From unknown Mon Sep 08 01:50:45 2025 Content-Disposition: inline Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-Mailer: MIME-tools 5.509 (Entity 5.509) Content-Type: text/plain; charset=utf-8 From: bug#6789 <6789@debbugs.gnu.org> To: bug#6789 <6789@debbugs.gnu.org> Subject: Status: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) Reply-To: bug#6789 <6789@debbugs.gnu.org> Date: Mon, 08 Sep 2025 08:50:45 +0000 retitle 6789 propose renaming gnulib memxfrm to amemxfrm (naming collision = with coreutils) reassign 6789 coreutils submitter 6789 Paul Eggert severity 6789 normal thanks From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 03 15:46:12 2010 Received: (at submit) by debbugs.gnu.org; 3 Aug 2010 19:46:12 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgNRE-0004QS-Ii for submit@debbugs.gnu.org; Tue, 03 Aug 2010 15:46:12 -0400 Received: from mail.gnu.org ([199.232.76.166] helo=mx10.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgNRD-0004QL-GT for submit@debbugs.gnu.org; Tue, 03 Aug 2010 15:46:12 -0400 Received: from lists.gnu.org ([199.232.76.165]:56565) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OgNRe-0003jK-3a for submit@debbugs.gnu.org; Tue, 03 Aug 2010 15:46:38 -0400 Received: from [140.186.70.92] (port=43681 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OgNRY-0006xE-Lm for bug-coreutils@gnu.org; Tue, 03 Aug 2010 15:46:37 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,T_RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OgNRT-0002OD-FR for bug-coreutils@gnu.org; Tue, 03 Aug 2010 15:46:32 -0400 Received: from kiwi.cs.ucla.edu ([131.179.128.19]:53639) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgNRT-0002Ns-4w; Tue, 03 Aug 2010 15:46:27 -0400 Received: from [131.179.64.200] (Penguin.CS.UCLA.EDU [131.179.64.200]) by kiwi.cs.ucla.edu (8.13.8+Sun/8.13.8/UCLACS-6.0) with ESMTP id o73JkL7P010198; Tue, 3 Aug 2010 12:46:22 -0700 (PDT) Message-ID: <4C58720D.1010002@cs.ucla.edu> Date: Tue, 03 Aug 2010 12:46:21 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.11) Gecko/20100713 Thunderbird/3.0.6 MIME-Version: 1.0 To: Bug-gnulib Subject: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -3.8 (---) X-Debbugs-Envelope-To: submit Cc: Bruno Haible , Bug-coreutils X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.1 (-----) On 2009-03-07 Bruno Haible wrote: > Paul Eggert has written the module 'memcoll', which generalizes the 'strcoll' > function to work on strings with embedded NULs. > Here is the generalization of 'strxfrm' to strings with embedded NUL bytes. Sorry, I didn't really notice this email until just now. As it happens, coreutils has had an memxfrm implementation since 2006, which it never exported to gnulib. The coreutils memxfrm is closer to how strxfrm behaves, in that it does not allocate memory: it relies on the caller to do memory allocation. The signatures differ as follows: // coreutils returns number of bytes that were translated, // (or would be translated if there were enough room). // It also sets errno on error. size_t memxfrm (char *restrict dst, size_t dstsize, char *restrict src, size_t srcsize); // gnulib returns pointer to destination, which is possibly-different if // the destination wasn't large enough. It updates *DSTSIZEPTR to // the newly allocated size, if it allocated storage. It returns // NULL (setting errno) on error. char *memxfrm (char *src, size_t srcsize, char *dst, size_t *dstsizeptr); For coreutils, the coreutils interface is more memory-efficient, because malloc is invoked at most once when comparing two lines. If the small buffer on the stack isn't large enough to hold the translated output for both strings, the two calls to memxfrm will tell sort.c exactly how big the buffer should be, and it can invoke malloc just once and then invoke memxfrm again (twice) to successfully do the translation. The gnulib interface is more convenient for applications that don't care about this sort of memory optimization, and I expect that for some (large) cases it is faster because it sometimes avoids translating the same chunk twice. So it's useful as well. However, the name "memxfrm" isn't well-chosen for the gnulib interface. As a general rule, the mem* functions do not allocate memory, and it's confusing that memxfrm is an exception. So I propose that the gnulib memxfrm be renamed to something else, to reflect the fact that it allocates memory. I suggest the name "amemxfrm", as a leading "a" is the usual convention for variants that allocate memory (e.g., "asprintf"). I guess the coreutils memxfrm could also be migrated into gnulib, afterwards. From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 03 19:33:22 2010 Received: (at submit) by debbugs.gnu.org; 3 Aug 2010 23:33:22 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgQz3-0007HP-L2 for submit@debbugs.gnu.org; Tue, 03 Aug 2010 19:33:22 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgQyp-0007H0-My for submit@debbugs.gnu.org; Tue, 03 Aug 2010 19:33:20 -0400 Received: from lists.gnu.org ([199.232.76.165]:59946) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OgQzD-0006p9-VF for submit@debbugs.gnu.org; Tue, 03 Aug 2010 19:33:32 -0400 Received: from [140.186.70.92] (port=56043 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OgQzB-00046D-SW for bug-coreutils@gnu.org; Tue, 03 Aug 2010 19:33:31 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_NONE, T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OgQzA-00079D-4J for bug-coreutils@gnu.org; Tue, 03 Aug 2010 19:33:29 -0400 Received: from mo-p00-ob.rzone.de ([81.169.146.162]:35742) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgQyy-00077u-Oy; Tue, 03 Aug 2010 19:33:17 -0400 DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; t=1280878394; l=32170; s=domk; d=haible.de; h=Content-Type:MIME-Version:In-Reply-To:References:Cc:Date:Subject:To: From:X-RZG-CLASS-ID:X-RZG-AUTH; bh=spI+sKRLithXfAri43EkCSM2bWc=; b=qXuoq9jhRGTy76IjlHmxrkqWuouESlmCjcWS3p8ZM59E2K0lHtnYGdd0LCSffijM9l9 HaOogytnK3leOZM0NqAD2nanb0REHdCwPk7gQ389IvzDFn0p6LzQgU4U5bfv2z6Wc/p5B 9hnulNQAySVZKT7wXo0n6ENrCywfw5zHym8= X-RZG-AUTH: :Ln4Re0+Ic/6oZXR1YgKryK8brksyK8dozXDwHXjf9hj/zDNRbvU449Jbdg== X-RZG-CLASS-ID: mo00 Received: from linuix.haible.de (dslb-088-068-073-150.pools.arcor-ip.net [88.68.73.150]) by post.strato.de (mrclete mo52) (RZmta 23.4) with ESMTP id B00321m73NTG3U ; Wed, 4 Aug 2010 01:33:13 +0200 (MEST) From: Bruno Haible To: Paul Eggert Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) Date: Wed, 4 Aug 2010 01:33:11 +0200 User-Agent: KMail/1.9.9 References: <4C58720D.1010002@cs.ucla.edu> In-Reply-To: <4C58720D.1010002@cs.ucla.edu> MIME-Version: 1.0 Content-Type: Multipart/Mixed; boundary="Boundary-00=_5cKWMLpg3qD0v70" Message-Id: <201008040133.13241.bruno@clisp.org> X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -3.7 (---) X-Debbugs-Envelope-To: submit Cc: Bug-coreutils , Bug-gnulib X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.0 (-----) --Boundary-00=_5cKWMLpg3qD0v70 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Content-Disposition: inline Hi Paul, > > Here is the generalization of 'strxfrm' to strings with embedded NUL by= tes. >=20 > Sorry, I didn't really notice this email until just now. As it happens, > coreutils has had an memxfrm implementation since 2006, which > it never exported to gnulib. And I'm sorry that I overlooked yours in coreutils when I contributed memxfrm to gnulib in 2009. > The coreutils memxfrm is closer to how=20 > strxfrm behaves, in that it does not allocate memory: it relies on the > caller to do memory allocation. The signatures differ as follows: >=20 > // coreutils returns number of bytes that were translated, > // (or would be translated if there were enough room). > // It also sets errno on error. > size_t memxfrm (char *restrict dst, size_t dstsize, > char *restrict src, size_t srcsize); >=20 > // gnulib returns pointer to destination, which is possibly-different if > // the destination wasn't large enough. It updates *DSTSIZEPTR to > // the newly allocated size, if it allocated storage. It returns > // NULL (setting errno) on error. > char *memxfrm (char *src, size_t srcsize, char *dst, size_t *dstsizeptr= ); Indeed the algorithm is virtually identical, and the only difference is the calling convention. > So I propose that the gnulib memxfrm be renamed to something else, to > reflect the fact that it allocates memory. I suggest the name > "amemxfrm", as a leading "a" is the usual convention for variants that > allocate memory (e.g., "asprintf"). >=20 > I guess the coreutils memxfrm could also be migrated into gnulib, > afterwards. This approach would make sense if the two functions had different functionality. But they effectively do the same, only with different calling conventions. Therefore I believe gnulib should only have one of these functions, either the best among the two, or a combination that combines the best properties of the two. > For coreutils, the coreutils interface is more memory-efficient, > because malloc is invoked at most once when comparing two lines. If > the small buffer on the stack isn't large enough to hold the > translated output for both strings, the two calls to memxfrm will tell > sort.c exactly how big the buffer should be, and it can invoke malloc > just once and then invoke memxfrm again (twice) to successfully do the > translation. >=20 > The gnulib interface is more convenient for applications that don't > care about this sort of memory optimization, and I expect that for > some (large) cases it is faster because it sometimes avoids translating > the same chunk twice. So it's useful as well. Since you want to let the two functions compete by performance, find attached a program that exercises a small string 3 times with both, then a large string 3 times with both. 1000 calls in each round. Compiled like this: $ gcc -O2 -Wall coreutils-memxfrm.c gnulib-memxfrm.c compare.c -I. -Drestri= ct=3D I observe timings like this: Time for gnulib_memxfrm: 0,036002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 0,036002 Time for coreutils_memxfrm: 0,036003 Time for gnulib_memxfrm: 0,032002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 2,65217 Time for coreutils_memxfrm: 3,45622 Time for gnulib_memxfrm: 1,97612 Time for coreutils_memxfrm: 3,42021 Time for gnulib_memxfrm: 1,98012 Time for coreutils_memxfrm: 3,42021 This means, when the stack buffer is sufficient - no mallocs needed on eith= er side - the timings are the same: 36 =CE=BCsec per call on each side. But when the stack buffer is not sufficient, then the use of coreutils memx= frm is 30% to 70% slower than the use of gnulib memxfrm, with a difference of 700 =CE=BCsec at least. You argue that the benefit of coreutils' memxfrm is= that it requires one less malloc. True, but a malloc of 40 KB is much much cheaper than a call to memxfrm on 40 KB (think of all the locale dependent processi= ng that it must do). To get figures about this, I added an extra strdup + free= to the first loop in compare(). The timings are indistinguishable: $ ./a.out=20 Time for gnulib_memxfrm: 0,032002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 0,036002 Time for coreutils_memxfrm: 0,032002 Time for gnulib_memxfrm: 0,036002 Time for coreutils_memxfrm: 0,036003 Time for gnulib_memxfrm: 2,18814 Time for coreutils_memxfrm: 3,41621 Time for gnulib_memxfrm: 1,98012 Time for coreutils_memxfrm: 3,42021 Time for gnulib_memxfrm: 1,98012 Time for coreutils_memxfrm: 3,42021 In summary, I think that gnulib memxfrm is more performant than coreutils memxfrm. It is also easier to use: 3 lines of code for gnulib memxfrm vs. 7 lines of code for coreutils memxfrm. I'd therefore suggest to keep the gnulib one, and that coreutils starts to = use the gnulib one (via a modified xmemxfrm wrapper). Bruno --Boundary-00=_5cKWMLpg3qD0v70 Content-Type: application/x-tgz; name="compare.tar.gz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="compare.tar.gz" H4sIAJiiWEwAA+19W28cR5amn/UrojWYHtIullnU1ZbdO0WJkmiJEoekpGmrDSGrKqoqXXmpzgtp lmGgH+YfLDDAAINuDOCXfdhXPfmN/6R/yZ7vnBORkVmk3LPT7dkFWOi2WFmZkXE5cc53rjHO02VU 2P74o7/dZ5s+d2/fxr+De3e2+ftAvtMfOzuDwa2PBoPbO3cHg3v37ux8tE3/7ux8ZLb/hn3yn7qs osKYj0ZFneUfvM8W5S/RoV/283dxNk7qiTVfJPk4Smx//psbzbWymozyPFm7GOdrl5J41Ll2Xn5a xWm3Rbpa2DKvi3H7l5uzrKY2tlKbfjct0v78ZvDbOC9sXcVJGf584zSPJzfGQsBmYzyndfy4rIo4 m/VMGa/su4r/6Zk4q0xhlzaqNm98f8Pw9/gB/UF312P6rS6jmTVlFi23e/zPQP7ZeXCD7prZSu/Y OHp1PHyy9+547/njnvk1P7DJ90zzwmzE5kuz/cDE5gt9Hf39ySeb9LMx3/N/jeFuEs2NF6N6+vY2 7YBvHuhP2ufEZrNqTk3hez41G+7uzQdhGx/TO8o6qehGmbp3Ojd4oJmEnn8ZdVia9u3E1Lg28qsv /X2b+isNqrDW3aEP/fCzEzL4603Ipx+bcU7rX0ULm1Fv8tR4Svi0LMaflnlR9cfm40/bM1jROOnN /t5wZtxc6OQGF4JJ8zME6jfTuCqpOW71iy+7T7YXRSaLZ8DNMD/+619f9Xwz3X49u03bpLT+ru/9 X8ETaZTQ/jUb/I5PzMAPgHu2Pg/yYM+4+68YPtb7b0gqO0IqS3pzRe3fPCF2wYTTJujPzd/Pfpfd 7AVD2mBK6xf1u5p5THX6rrRjsyV7uHt9kzbLoL8dPP/JZS3UVzVRuzbs1l0e3HqP1+b4qk7vXNHp tcFc2emdqzq9Ppqg07QaYHtpFGdmQ9ggba9XpTVRZqJTW2CNVAYY2VGlreSC2Xj+8N3w+fOeuTmx 7x7t9V+dPN66f1NWj1oZmnJOO1FpyD0uhKrbGz+8/YYo9eaLaDw3r7LKFpmdp7aoLn6s4tnCxsST MzOxhbn41yTOJjUesuasLogD7Nbl3KzObEyEblZ1ap7k9SlaqAtzmmfmxH4XlURsZxc/zolENwaf fXbb1NnE0B/3N/u/2961MbWdmcPi4scypr+qkno2rcqzaI49EKfmq2hemB3iP2gnyjJ56czObMaP PrJpviiiiv5Ey1FaxbawGX56TZtm6VumC8OEekhSCTfKCEbagTdr77uNL8O0oltKmYyqf1O2kBdu 4e4UkYDvm7TwtHUH1OfNX+aBH/yKJ3k2+8sW/Lkd2ex32zeVkm++sTQfsyibBdee2BFNFxFiUprj fJ7xou5GxSgqInNI8zxWGsCEPrF5QcT6tG/e9OXqWT2el+46XVwRy0lTai8lqjqlx823Fz9lMywX 3UUrfxaXIEDz5z/8T/OVHfXMCxsnPXMQFaexLO+jvMir+TnfQZcO4kkS0WX89DQn2qT+RfW0b/bi jIiUqJca928xx/QKi1f0zFE+irOeIWoF0hwRRd65ZSaFjb8lWi3iGfbfc1svLn5MY9sP5uR5VNPg Mb7gIg+XCIUGXFmepcFndwdmFJf447aZ0JY5nMdJEi9LMxxHE5ue9/hqRI/QlqaxvCYaLlwjZh5V FW35YUbTksT24k9E0rR+NT1T0CusbLBju6xsOqJv/Bq87yCK8eW+zGjMHYpkB/8WTONVFmPQcUUd OMsN5gKUMCVRVZoz6lHTGZr5uJrR2yf8+GuawjiLZzWR2PGiThLza7ObZ7bk6Z/Qv8fUP95pI7pC 3x/ZpIrMs2i5jMzesoyJOs1ZVPTNfmpeLqpcO35HNyN9o6fKFj/ocZ9W9Slx86afTR/7MljMUl6W aIJ/Q09iYkjByLf8yGk3M0nvEs+zCTUcZ63ZGvXN10SK9CPW8d6Osqx7d5olboialx4r+ZSoNCom uEDER30hagNOwfvdb2uTz8znhMg0MQe7Q7NxEIE8DW1138xwktKs09aNqjjPNukhmsIRxn3vnpnb GLxPKEJI841NxvO+eURdolEQyWUzYmDv0e2CdlWWRTwet4156mnXpGbnTt+8yE8dPd0fEJfl/d9v sYl5QaPNSi8XXnC/omRGA7TdPUGjXU4TnlfqY0l/yHpNL37CSoE/gOE6Rtxprf928I3Z1V+GcfOr eVJjOmMnYjz90Jatsghkc0jUVvFIH1/8RG8g8qH5LIgyoumUpvvx1mB7Ryn0UTQj/lDSpEW8lK1O EPHhIima5muIQ6JEIskZ9iNJiP2MGRC1PaNbqlUlfSGOHc1lvDwP5ZKIjloA56PNb15TI3UxNYs8 IwCdQWZRn6WHxLtoBeop9hnmmDo0LNJz2QQzu8iZh1KvmNIxQn7PJELjaCJFE2VUrfD469jSjKSG 9tIqn8mD82ik4lImbhLNQYoFSV4zySc0F7T0RP95Aqm58ec//BFvkrd0OrhHzcZ2DoFb/PkP/77Z 45VcRiRp8kr30JDwRLyIMrB22r7EGCLcbnkTouU9Wh+aA9oFTLclmIT51k5yGRZuy0BDJiNgUQOk mMM8iat4Qat28X6e0UswcDMhBXYe1SXoblSA/RPVHRbRd8QYNwIui/a14WckMQkgl9FoRnt6kln8 Tgt7JNCB+hWBo6HVTeqd8MEJcQ5aL15aTCaxceLQBVa25I7wXKEjuPTo6v1CNDsDW2MQpBsl08ES 3onBDQGI6D7aMgmUA5YMYJTzKBmZWXHxHq+mSVvylGDKIXTP0AYJkHpqHpE6vVAMR7SfVXgPQzuW LMyGmAJo2I/tqKC9JQiISW+BHl38BKbA20B2AW9gxovgiEQJrAramEcTMoxLMWXw+zHP1+XIcwRA oojPQTNie/fdVO4Vk4v3yfTiPc1k0YBT2WSFeVKQ4J+ASiErh8UIAIEolub8nMhhGWV9GQe9YDwn 0nW7NNZ37n23JPHA62VqYovEWTLMKZHNkCQRNTwRVrltiy3hY5gyQspLmgqaKhrbqICUIahBu4q2 Is10GYw2w7sAS4gByKB1Y6Z1SZIgGPX92555UPt10MLx0o5JnUvNPTe2h3mxpKGRBMkzRsMekIHk iPeQBFrxlmWxHXSnlNEFr73bHRLgfdUamXLf0m3ZFYFpmvWyzqYEpghLYUBYAhKDMBm0eklwjXga /bdqdXIS8V5WloiePooLS5gBYBEsRtoKKe3IJvEszlXA453DZJETE1sW+SixaSicIB0P9TK/lsf8 KgUA5nnWR514DKjvromwJRb0gphA9hvWRE6KOqPuzEG1xGyPK1uDzfBQ4nnKWDUCoY/stADKFQpV 0YQ9S3c4Fk3wo8Y6Kw2IAIl1MlKgeMv7Dby3nglDPCMGwU9agulCio6aScYQO6xawBFjGmaE7ZQt Q8bRpQNbzfMJ+geChwpdRQL/3xAKZF6FBaBGHs4xDHNK+y8BWiY246aM2qL3rYSXCUOnB95A2JPc LWVFie1OietiZ+ncWqE2ejexOWHn9B+amswCCYJwLXFkUC22NLdT0iLGp1GVgOsQsyVsGSzyoWeI hEGLAjsh+JXedp8FQQfLBZi3ZL1wEaXLaWWjtHQvZSFSKmZhwOpQOjgrGHeeZTxNlyq2XVgviI6h +IzoEbI7ZSLMIojPx4WtWUC03t5jTrIblXZEMhXdUyx0FEHZcfJuSMQRJ9RV4hAzc8f8PQmxPRGA 0BYURWB9qGNX6/CsuYNiD6IsmhHYMYdRUWXKQE4wOX3MnIAbW2BDu/5KF0rB4lmnl7AEgFyAKR2t D+5QU0RWOeT6ozxJ2svaWS/C5DFwF+tYRRRDAjycR0uiNXrJeM7L9LCIzoiaG8jYY5LFiFRlsCT6 6NFMoAONUFgI62eEGaOqnNFSYgcRNbB6TdM4v/gxqZywdwggJ3FNNH0MnMactkM2b6JkAbD0b0S9 Oaw/6OAzAuaW1KbFEiYbzy4i2EBJU7i8GxGzAWFRrRm6ZAk7zK+ia5nsjeZupk7wr/stTYCWnniI Xx61vcQAIWJ7kXaGaUUqC+BQwYSXmaMYZodJqXCfWRjvBN7RfQPZ32wxZZdQ7aHzASnSDhjPp3ky E4SEnzAg2s20uNRB6suS8DeJjlcOeR1CAMRsBxjPFSxO2FYU9JXeCpOUcj5iRIQ4IMkYwesw48xt DdgIGMZW5YoZPFEObAszwb3Ey/KlVZjgZHQDxqBbzqiZB6aExscYgvkwGm/Zr9xmZPmRJGDaBcNR xvgk1YpFZQWEpTymo4ufxgv0m7APXbI6x0RP5TK2SXnGEpsn/wlrJ7YkFULQ/4RBPjqmvXxckFxT ftxQR4aNnkQEDZgnywT1W2yUNrDXvyAqmoeLkJmcqQQRY2BPtJcnoCWSQZN4ElXCjYlTnxP110Xu AEFU6EYF3QctKgoMO9uo8T1eBlCpiC4m7ZklapmF3d/3q+yXF+/jF6tMRovUAu7ZtZjMM9qiCkpO cggA0s2n9nPiWzvMQXERTLAuwPgq4SlnwMYqgTEFBRt0Oq9Gd3dpUaIJm1m88HyVlhXUzCnwQtWY LYWysm5XRDHdEgxUl6yhyvRDpWM6w8acQg4XUKPCGXmkwkD2JCyv4XSFBtnQCEzDXpN1bl2V2kij qkeKOEyWw6pBE8KdhHHD79XUHOQVAfXTPKUd/0faURh2IiyAcANNyCn2McEj0jjNBhtLGUrQq8w4 uGGTt6NyIRIKtIbngen4Wbt/HUsy64dgC1fbkcscjKpp0CErVjygx7lBQouOGWU7AwY2ymtIGrAp RoB1tYqysyiBPFgwk8g2SYIlyzmpjOhfJGAKsE9YKGCQ7jyiVBpjZaHPLqdbUbbF/x5BqhBjcdas iYBn/PM0qpdVsEKNHZdG1gOvInxRMkW2XthCOtDHM0B+rNUe4CFtRFDfLhsASwgs85h0KHqJiUbz uL35eDT6FDEqGoS7l/ag6EYxm26IiFdgG+iAKhmskULDrlNofaQTQxOJpMfOVImBsdTEuGMPQY7U ZCPmIJKpi0IZJXYXJHvJ3M684h0sts2aFCBSFh7mtK1pEkGOMGmF04FXJyQdhFRf2Dpq+q1EdlzF MN/A1AQtvWBNn/BSQtxdmDtTkc5D6WS+3jizADHMRjacUuWIkXgMmFtlNztvDt8rwoBundLiQkc7 iyekePYgzxJafrQu9gGmhVjpmglUmCBJLBgj44VsmzJcajYF07xBDeI2CKiBNWMLqE0+eDVh3Ysf CTR1u0tM0QBEqBkktXOwelosNnhMWIMpYG2bc3cesyJCPE1ES5FY1l963kSC9r61M3Ro7V1ghVW+ XDIaycEtVP2MrcobnTj3RM9bKjswdJFFy6UjIaDLKk8FbYQeJGHo7R01JVHtbRY0xYsRCSBujmHH AY1/LoZHXr5syhoW3CdHLOmom0pTr3MhsgPgAXmIf2NwQSvsHqCtDToQD0RnRsDRRnbGCox6UISk 8dYkgrbzQBpzwm3FApoecz0tocMw4UXY8YySeg07cTuk+2ZZ7kVeQM8nCuD7gH4Tfg2TBKjxMSFD 3sm0PeBCYFSgGyTYO9TfAvhIZG/JFBGxvdGRJxaXOIEgVFqjhBl5ye/rMfQ0QvETWKEYj7ptpFaQ mV2Ja/PMsplAnmVjDxvCnL+CsSiWmBgT7XSoPm5jMvn2u3ZzWj2iCigCtE1IHSQeUZ1F5s72dh+S V9GrLjy9PQO4YKEi7FvxOs8ZbyBIdNpu2EbuKVbRsEtPlVs6DuoonKiIbS4th4zNGEkpZ7iM0dKa givCpj5iK3l7fF2YEPy0x2vZ4OykDF7c0gALlujH43lx8R5dbbkWnb3wjY2hYEPUkTpMkGWwGTQy TAnF9AnOZGrvHISAhudkwlt2r/A2KbdLV7wxgs45LBq4kUKXWTA9PWcyEEt049MKGiNOZnELNhZ0 HrG7AvpALxBFA0BP/WKQwqLNZuJT6a5Yz3wF7+0/1XE2PjdDGgfpv6u60xW+h3+8YoxBt/pd9gce zFTeIPXgycYzcbA73GJ/V0gSB27RxENBvI22WgsuCnrFdtBVlUW18OGCp8BZkSmCVB1KLf1YDCJt c/EvqZh2M9qapAKpi5WVp5I4dC4uiQ5YZJjWgn/qhiYMNzFHhD2mlv5QNFcxyUC2icsO7skh7AKZ ++4oif6aEnea45VP8mRKAMRCItJYCRw+JOWRVjA/o9UWzKfD4JXdha4pTgzPoonPBloxugi6Yb89 GJ2w5ZE8GIsi/ZBGnCfWrlYRRk2w5zXPO/pGzA2SJ4ZrnNvnq1gigpSzWLiXvB8KJYscsZrprZnN Fx6In7Kamy2m0YhwA+yu39pxxQE6FYvkM3ERjYmpP6QprovznvA7txqHxDaJq7mvw4IIKprRlcOo TswbmkBC4tXK5BP2ARLcNc/j0ei85bmMbaDTf+0YzBXa6gKuA2zcLqEzkZMoJDWNaOkqEwHAY3rx nkGHYMlTMbGz3OHdl0JIY9eMZlaldElUTReTD5kRWA2AjZ6DGYplnS1YIWzbFVi3wOZWOUMwLU4m DPiwhakDYqIu2ZDNnP/I4i2qui29L6rpQcG+oLpQjUddQuzMTBZoEAYK97qDOIEdvpDggGO0OnWe mAOdGHV3MCQdKqH1zAnBCqHC43wVRwk7zPF69B430Vak9Viy4RcrgbktK/VzvNH9XngDpZNm8gY/ s8c0Yw7tOSfQvKUHmr3JGaiNTXOT866OfJIHipUqVXinjT1ipvFPndtb1RZvGBSJI04OjkBS+7iY CgvP/PQF3N28KJ2lvlFWRWbTZWV7tFXqUsTU5a2UqUOUzpzgVAk4bkhg8a0h+808gyONi2hkVGAT RJmCcJnF9l5z7MobnpbY9UyqbHZOzWDQD+JXeDY2sDAnkQCjE1sUeRGxpZxXnEVcO6rhpyK1YqfP C2LDJwUpysxC2ECuejR3/rNPB4NNZVnYnMSEZgVBBqBEk8J8cCrzs2g0JmwQtQXEkEfEsNJL9lIf IQoT61xFUIWdU5nnKMtV44NsgoCTnfoiJyFDDRG/mpL4s8TCibMRX9x4hg4+w1fgSYdjR6TY0Dbf 7ImeQD36pzpKxNmFTl28975dyz7FOnF7XWlP5XNmvq5nRTyddjYq5pcYbQnZFjt1lYj4p4QBVkoT b8cL1ZuP7KKoK5UEp47ZNOiZLTrs2XHwagfc9xliDPptg9IBvX0VAjCGENlkRm9m0T2EH4zk41WQ yjvan53nVb41HPkQCfRzUq/iBm6f0NMjOPNnUcnaKDN6W3lTGzBlXLHiBN/4JZY0xs1iP3PmM7qH W6d1r4ocm9/Cf3bxr8konxei/SOcsBhX8biJYnlDy5/EU6atmgY6gX9rpmaARtCq3JkKZx/W0zk8 BcJnJ3khIYpiiybtR7zhWJIcEoV5mzjK+293vkHo1bCegUPwjItDbV3MiTH9aZRULgwFACDObTWP F1uP7AjgqWt45neh72zDt5ka4SU4Blj9RxZW+FW76ZaFmEBxjjmRVU3TFUEfQsY5W8boJm+H7Rhv J6yMiaLMBkAvkrt6RmPXbZSqwgJNn9Ly0vROL36EL7PHPlI2zTGOL6E+AZIqZnCOrULdS41HCXwY zl42MelylTBhQqQBFoRGRJguoYuywG+b1AUyiuBdOD30MoZ5qVblAo5EIcYeCCCgazSCkZXgMvWz nKcwH3miPCDJUpDcZY1pZ7MD08WD1+bMwvMu4ee2mNZzoQiN12Ex0yE18YPQdpsaYpqxWs/2xPdL WxHuUlovDEc0E4D98ULCfM08B7t7uZzaAuJLYxGh9U4wCER3LsCNshKeNTXGlufpiDqkrqC48Ex/ 2IibAh3ybppnAOiBqVfmgI3QYD9dbUaCj6BuBEZf6yJmSHBVK7xyw6tME1tX0h2xpxV+97NwBjIv EBCQxKmCMWV+m37EX9cMIx1nCFa9YNNcwz0xBbLeAr/mPClXGU7ZKFzkF38i9F6R7IqZtWYXPzK0 jUZMnPf6PqJTpgouwOlsDuhBD7ETEy/wLCKYaYS5ZxW8Kuo+T2XnyRyrDVG03ijZ+qcIxh3YheH9 JjAhobKhGSF2ahGN+mvsXNr6Yv2JiYXTBKrHEiw2FXlzQjJvFIkPDrhipaEL5msQlTjLqov3CCgj +RmfktRkpiMBenDI8bCdeTDVwN5G3D+K4vLcPKwrBrnHVWHrUZ66OLxXNAO0cuK5hKx1EXwLuN5c iM2p2vce092Lac1eKA6koJ2wEj5aF/ny4kel7L3v4mRLVkEE0CO7CrYnixSoWYP7fQmwZ8xarVoS ekhb+07ffEW9EzEulqkuw2F58SKa5whPQQAkFjmzztX4OHfsnvmZMFBRM5dRApc2tlnpfJGgSdzs IcsT+jqhGY9VX2BbhwS40F8+bELswTBUl3AMX22EIb7H0rwUOLXXmrdXGUd8ZZPWnvFbRh5p1pa4 fR5N0mjZg5ji6QniGNnPySIK3+esBY4ikOZeNovQc2c+YtxIitei6qlcUwNPDmQHq3A8y/KCvWZr RA/PXJ3oEnlpKXK5s1YSaNoGqiPLqBrg43FMw1oRNJ2ywvz04v1cSO/WbUKLed+8On7ULMKuRQzQ QtSzaU4zehWj2Xj14vHhcNPh2VU9j8RYOolcgK0K1gO1HzOpKPaAklk6hQbIOYsIkBK+LqNRBVAn KAuLtgVLCzaoZ3E8IgiMzow1SGiHVTYJ7pY5wuCIQGkVCo1fzgjmhewc5ER4Vp0z5Tyfqmv1DLyR o+7iBBYXxN17VAoFVOJfGxardmOGmCR2rEJGTregiZ45H+9l7Jkn6RGbOaOZeL2PYQuZWO9gQtdK TnaYs2cgeyDCzhldjgkvxmOiRPCG8h+gHFV2zLwICgl7AEZs0kxbdkVI16oSIyJvCt6K8GFiK8Jb Tt3lbZytag6uzTp82sE2H6zWuF/AHDwqsaE441h4yEeMKFB7vHvF7UIjZm1z8S8aNabMyIGRq020 MCm67AxOFYDp61G+QAKN1yvV6K9xXKLgAUfCU8DMyhzCOsNcgPpTsGiAC+K7ZRKvYFz9uhaPCq80 ZvYUcdCnDbDCI7t2UuQMgsVacMCPwJ6EMbMeipD21tTuF9GCbYpdx4I6IdYtlWs2zY0DOFUdvOBe dsJSOsY32kW3eoFpDATo+1G2N95z+Hb4Dg79K2ULSuyfDWGh90B8rRb+OSI0A4d2+kFoxsanaDIh vPuUOD77yWGVdYElU24BvaSO409it6wASFSZvXqyJRRcw/iFasUIrXHl5YKwMLv/OMJVjADcHwm6 ZsbsqF5cX8SD2VGlgVGIEo1hZoVhiIN1JZDbmfq517OYkG/SdUTHgVZ9i3VYtw7e0bifnUYcfumW qVTyAsoTeCT5dBK7L1dOihq+UmhHrDgKRNKrviUfNOudts5B9SZXaxltLg2ww4Z4DrV6pPkTzkDn neIZY7ieqLo04/AvWcbPzngosf+tYLRGe9Zol+4OeRRRrxxDYC2B1YilCx+Doa6FoK8Sa+JUnDm3 ObzQPwHbwv1WlxOWdeJtfPXi5dYBHI6VLjh1beTyORiiimYgZlyJKiQkCFdpQtoM20wbO0CZGw8u n+WwBMUKD9+wJFe7SAe5E/RcRvLHfsV2nh7YIf4ZInxeTD9YGEaGt7YdkvbcUdZcjdGtPW45KLXQ OJ7QhMGwjDArGxfLFvp6JIoPf+P3Xvwr2JG7s+QQ2DhTxEgwkqOBvOHgDS8sYb+lXbgFEZsqvb8t rs2wylN4WKhTLaViY3+493KTzYKw16XM7KA89MAOiAjrKYc4l2obFbNZhaSthvyGI1rpsnLaFyal rdM3UCbuoIhuVgbkhWWTrnCfJcQxaxtN6GXbRnAVNuAYDo6ggT9ALF3czEJtkm+Id5xJqgXc+fJ0 qSzE5YKglYCdNLG5bMxnnwGIjYONY+H22IyZy1lzKoACc7A5TiJkF5XOCyEgbuW5GKQ8nAhJiPs1 59lzkagaLS6uvL6o14qu0pY7FxYH0jCnGgYgIHVkoXZb8fw9ExdcwWlRyq/YpsdxcJeLFxIoCJXi HrOSzr72CTvsChcGF/pwNpzp1RmzY6ITp62xke73NVu+RO7ObO7AjtzDFC3C+Io1b5nhXZzh5Aq1 nI2SSSLqU7N1EJ9twaDQy2ObjMrqNMAMjIhmNHdjAjezGMGcLgREdYECTwvTe059r+I0qkJZo+xC 4pckkybK1FbTxHN1Q8V0hYTziOdBSDVr8ICmjTQhN7rcC+YfCcGpqyQ6gqskzl5xncRQNHpguPCN 30am1WVsOfCvnqW+OYmqEheYd5PqYiWCicUk6J9zfZBkP0+da1EyceSdzL19DJrkA7wEKyj5aW8b JA2RECVTjk4TR9hscPykpFlEYwRKklY0t5NfIVVPItyyop7TVBaTnlNCeU4D80zDdHYtbBKYskpE fk9/1Hw+qC+yf5V6Z6rvxJyi54I01KmcwUrAESo8cJdKUmcNL2q2h4CRIhrJt8ACMwd/xuZXFhtG WS6Q+Mic1EuxNeOl5mE7w5KyTJ7rxqr+MpAXeGRVi0U7ZgOHEEwg/Ggm97G/RnWiKIrNo56J3pYI /0kRT9YVIt/VxgTqLKmSqdTm/WDUCCX41hcuwPZ8jKB541JYALeE5R0ev9wzG+JZ5fnb9MHESIjr xnxrIYbPSVCwJnWCehQwSYjsnSfqUkMb4n/czSVRTkKAmIPIQAUuk/xeXfw0Q7LPoJEdtOcNFyQI RBN2fFPNIQB0wxVRUKCue1ukrGRaV2mkOPg0MBluuf2rAdkXP41Y5faUgFRzkQpwZWHmYq/YmlFU LrwTdRkxzqTHWzhi72RInVkhmbBgX50MInTMmb10efFe0EtUiAudM3MkxGzEni+fITFhUyDfVUTl WGnRLahYeZuVNF/l5cX/Ms/rmNh3TsDzf89quzJfR0vYIHKsEfzjHB3eBHgD8bhgh57RDFgfBIJQ QlYPgwCYRU1EzJxHzTWvNVZKsI+mJSAzjaF1Q1VOT3DuOmaCkRiALCKd/rgQKJWt1AktcYpQBSSQ eXHxnv4NYgm1SWJnUigACw5W6gNle2jWuZxvbasdEx179ULihRRCEGrHJqaWEJsLpsVm9kqCq0cw HKvkWyFIBCbLkriV+LaqeloFIQcyQB7R5cgczp+O1wCO0CjWvNtCMnsaWbAPV1jq0JTQzSEnbEBt kfyq8pyGojGnDJUTlztyQIQMRxOHWXqWimg1SSEC0mGBBkfLnOgTW72l+WWBnxjh3dFswjHpw1G9 9WReF1E82qLW4L7MNM6as0ZbwFa2g/SrDlKX9OWP8yoXFeA1EVoOm2RiEYDnqsSEwwDj50Roq9GV onwDf0EScTJEDqeQC8WkZmDe0DcSMMpkQxJPYsef9VDUGecYnASp6zPrXSVuMmZ+yKUY2JmkNXI6 xFlqMupzUYhMzboONHXjqrxaumv9qk3C5crUBpCaV8dbx6wzchwQyiJk1cV/ZFGa03DP2eNejyJX RkC81chEFkXOJeztSu8U9yin1lnBQEa10UUW4eRiWsSPM7McOCvhxkjX5JgFFQfHSDFAvkNdNoEL aQ49U5LPYFrkvac535cEmgGkMzv36Kprxw39GvebKh0a0pM1y+L8KCkxy7rIHOc8IE4QrbBzk62v SVjEjFo4yhmBFGKzEPXhAcNj9sSI34fjiyUZ4ICojgY/ZXMGqI14PFaKFpu3rIRCm0LiUjkHd+Tq NMBoWLA+1vZwZ/9ZT3DwCKxPGgnclKKIs6nHBlGA/Y/Zq1oG6nOAAQN/n7M/iIuz69GkPfAhhYmT FLBZPidud/EnAlls+4C5VbKai5ald8HxFIxqsXoEiDgJnfQ2YruNwV+AEocXNEZeNZyzKmIDwH4o tSnYsr3vQT5AiWaqL5mvYu5yIua2+CaEa+FMmCDEQ0YM7+VI0yOcTXgtPFZXAbM6Ry2WUk2a6rAt z1jSIG0aki9zqPRby7bEDwRbO3OFywKV3JW2NV23/RwZP40yorkwh0DsLGt0x7bmZx/R+pVTrF9L KL1XXoOVJQZ38SOtu89Jwv6QQJj9jIZZ1Sq7zmJBF18jtGnj4e4hz/n+w71NGfIzWFEQZO5AP1+M qogIJF9KhGJdrUYspybI2p1wzOxeiv2F+GZOURa32lCuqPkoVYfjUxQsq6QdZ/5GsSDe8y6QfHBf Qu2DINhGgyG+T1TcDWR6wf5H7Ksr3lAK4tA1Xg+6iT0GuNeqQ0ObfVzTIp6TzLeCwhDbgIoIY4TX mjsDs/Hi+PAR/bHZa7wWT/PUcsjSzz2/s202nuL5ne1NJ6tkOaBdcOaDemwbq1WwJhJ3+yKvJJJ9 wlK+qCZRrTYUxAJ7GuDt7Ll7KbPLqupeRtsUyeUPg/tR7QchVRlWlPVWCQdl3GbFd+YCkSatuB8h nSA5N3AbFGbvO7uoMXqRS7BTlBwNRBecyv9VPSHpz1O0yAlQSjZf/+2tb9rxHlXCOyNxhfGaKQRQ 1fI8pJTt7nuSXl9bJVZayOFmQ7Jum4ZuN/U4WkkPgjSliUsVAsXtAC9n75e9OvK+JB+IcWmunNC3 2tUesKhjZZoEmpNVYMEajppCeCR1WeqAoXJL7sIfkdrPIpsD+YivnnLEokDg2cWPI+QaYn6eQCNj Vi3olmWMpncTOSX1bGVrWNm9+Ze1JXqFc56oxUeabpxykNIlR51yOpKBEEbUx6N8UTOTaMdWBDgM 2qB4xbUUQFhKp+U9b8o/2axVFaeENhv7OhfDZREngvHXXJdDP6mcfel8YaUCn8a5M+e8x55q3pzh HBVZIw2fxpkkfrOd2pNHKZFsXuRjItgB7/I6kAQoGXO0XRdw8TH4IQ7WSGpNydMAbqN5gR2/bhjT GcYirIUhkNyGWWMFy4/E9xIBzlGvZVIvWLNHIhTQew/hlG1f1OO4SK2iMNKDuTZMybaJSM1QquXQ KpHKyiEy4gsCVgFp7LvQlESCkOZB9GUYECLxILB1jSRGwhPLm5OXPQkC0DE0trKfMc3uu6InPEda 2hLPdWK2NaScf5LobS2NiZUWVMFRJw5ukYyDopiwut3Ou2tY7lLaVFhxEE+IYFOzl4jPv/RZbkBr UpmMw618JmIcRjiT7EdQeNeO5QO/Y0Q1CQ+d2LKTl8RVJBiaSbg1m2g5R1GBHHPw7FtoN8hywkqO kCDh4ox15hrJecu/eHFJrLGvasF3SjkA0+pVGCFzEATKK0eqU+hg4gjCm2gZxEEo0eHgtqBqx6M4 LZahI8fngfZKV5LhwEK4pFz3BAXHZIdx/ib9MqbdvfU6yH3QFFc4VdcpKfM1u5rElW6EVqSmLOgY xEFSD6FeDI+H6w6tEWFPBq1EvVpQQ3TOg5wNUwwH6faZz6NleezMqahNM88QEwNKPUF6ZTSizSml QDRyi/g6GwNhnDmICqbTTGV6NyeybHt4CwJZ4INi57G+GgQbJTETmvT2jOTeec/QXNQppzqkPFBE U6k+pc9IxPMLzmFKYObk5LKzHKZNp+2WKHT7ch7nPEA8SjKREzpLUSJ+lDoFomvyRm2MeVb4AMr9 UEt9Vz2u0ohohAkUDnjwLLX53WtmUEklufLMy2fwDqhF0BnNnWONPVFuI6O333JyllrqxQDhinF0 jD0h5XSSRL0NjotUpT70OuL5qwwXVXLJq25qYaxk3dqjhqaaHxPLiNa7roL95p5sZ6w2rjYJC1RN AglUmm3bSYwlNYzZyVmO2h/xqMJWF20IQZh130R9o+W9RGvFkHiUjQWcK/gwbmczh22VbPnKTqck icq51Wxq2lRQs7ybMZM6JbJCq7jQci1GEottQmKryHXaecSw88Za0LBVUpKes99VXINgODrDsIRF brwipZg4GSfTuxpymyasFVkiJ6lPyJJmhy3bNF6u/0BygKaCU0zWU3yvjI7C7trsxNu+Ot6SwGVX qiDGPNHYYkaRTCisy8IVcq8fQNS7DI0brx+GB8a0dBk6bVR2eQEDHy1ySYkMfl6ESpyF/VLL767N RxxwzAqeGEeECNz+YoO2OjSaXDFeRda9P2TxQE2ycKtjsJ0BukzzwOByZUi9+JeGkmJdqx+7G0AA Mp2nkrxcuvA9jdYUns9E2AqOOCFanOYgOZj6QY4tnuDtKRBxqxqtKAjhvbi3ReIXqzuiGYwkoZCt J86CD94qSkuRqOyUPmKFRpZAPkqdsxkiZRmpJTIcWvf5Wmci6O5IWJX4oCWOCKa2OQd4TRE3teA4 Jg6WPcu7FbK+luTmn08190FzbOeMiEUV2DAQCsBEKWIeQLelGB3bcvlZNKJxV5Vx8stlVUumKOml ce4SxyTehgsJE5efqg/GuV8As2a2igAhqrWk4jBfWIOTnSroAU8pJM2kzD32W0YI08WYCxrrJgcb sXdVa9k3nDKx5EqQzh0UDlFLRqllsMEpd4KaJxpuq4ojKTKthJGrQltIcqHQwck5aTcZ51y6gm7A NxJaxTbWngszK3nvXfz7CJzcxaV3vByP6UW+2IYEregFiM/S+wYQsYavI9YZ2tk7Es/AgwzrifHE BsEnp4zTS+FCLqhSyxxeEp7ZCbYMrRw65hGhYxd2gKD9kMly6WpJMoarbYlgQgsdj7kCAtOcWBTU dEQ8K08qTUYQsxnu2s01qkUNO5dpOWbjkcQK6MKrhnaYS9xCzPnQPl5u1RhBNek4ngXWWtZ5eg7c SerskraBNQvWmNYMPmpja8abmanTiLrBg3XKFvn+phssmItb+U7BuCA0UMo+SWW9OLGXVLcCJEns PLuM9aDuxGftteFaDmjkKempaALGtQIR7s7S2sZnxxc/TRZsJ5WA0ov3pfgphWlAlbXsNi81UrEu FoEF9S8vVsFOSpaodGFScar+S9o9EbJKOUibs2fBGjnFznW3+0oQ+8hKQWaJdBRmw6aeKbAfRJWk osDm6uICWD0KogMcPD6m5lPjjGDmGCGySF1RLPcGTB/rc38g0WoRG6SllCQn0O97900rrjgIs1Ax 4q3nUeYLS+TiyGFbA3rk9YjQJNq4UbqOVDtxIZZS6GIXcAQC3KJfQS2KJhZeTaswhmFHNaJNfOca 3hRaZ/dOo0Xt1H028ZtZNJLK7z5dxynxcq5Ak9MhZh85YaCiWa10sI48ratlhYx/a1gWk9oLaQ2P rTu84FEsZTpgZirTQL8MzfmSWxsazJ3/IEguYA93UM3Q+fQWGvqd1ZBNZg9VYPOg7G4r7I89QZD2 WNUDUk5rdbIz6ZdB+QIwRwYpMN0xNKx82fTPW2COnn9IhNLobJKbTw+Popp5GxuiZgH08lYxcYRJ oSGtVVgK32msK+Kd8Vo5bY/7a7VRDRdlKGEj5XA2zbQH0mZWqJ5z/G+5jGVOwmXa17BCosYzX9i6 gZ1Oo3FyjEs6zTARpCunkTdDCb4sXEKjzuCpslyw2be3Q7P517XCojAKU4LGszBkcq+QAqCOa4Xw YiVoV9GoVrMa2YbD42ZQKsfyo6qus0Vn7YJuLDHvdND2naCAn3GS8UkfZ4fQJdKo6yzOJTX+hatT KkWYHs6RPPoVRNs4IFk+bQSckFVVZkwpDkw5IlHx+xp1krghp1bsOpN2k/vhRWLYNbHupOZWk4Op 6AObnCM5g9ovT7kUckU0gWK06G3TeTfFkqGFU6KASfBOWucCByWcm5d//sO/ETzMchlqo1lRD16O 1CAQJB5drUeucgEHWu0t8lV0YZd4LwEaGppfeDZcs9faZq3SKM8jTpHCIRb3OpPAAWgYKnXb7IIJ gYLdEIV/N1MZ8pzjKK2JYw3pNXnPGXtuDcKSUXdZNeBabWy285XaXH2RJg51vUhGk4/TLjD0KB4v XP0h5GDfbenavl5U3JyhUi5jxpk+KCPIOz2EGWNriOx2tvs0Bezm+XiOQCNmh+3yPZ0AjBGAQp1M /DDUyrfPnkStQEFqyP5wC06sSo+leExb30iJQGpuUfjlehQvE1THsxyzZpdzbIYSJvbXyJI+l067 KKJDDnjWsEg19Xh23A/L/cAWz754O2Xh1ZnYdm0nh0Hqdsw4K/FIQCQILtFIUpqjqVXA23rFKAtA uEIUvRw0tNvMExaDnu2Uk0JzvkyTO+8DbV5W34m5I5+V491Gd71vXUh0SDowZoGxlUtV08dPXbX0 SmNapRruoWKIVnVzzQ53Yqc5fcurj4zUREe/RAdk2x/37wOhCqqXB2FUWkYCVjc2iyCOt2K0wLLa EIe0M8To8OYszMY89uGEBddQQq1Hk9rvGjvFJuzvZ7KcSKwiFSBAPIh0Nkk8kpxMV97CKsGOmvK+ nPWorojKhl0Lg0+YswuwLYPTYKgdWnwN+Gx605NZdKfHuEQn9dcFnprLZg99pPmfxM6HXjZNQ+rz i0Fzkj1m10fpUtVxlEK5qMUpeRYXUI7BE1z1WgWoKGPOYZBCpU8t0BFj/NIVvOA891RLUzPtBksB 5y1KNTFJNzVCWZdrgW7a0FxqQwL91iqHPeOQn6ash/iucKTRxZ8qLY3nhghmP4rLM1HLaOexuuSK tATG4FYcRjcMgzOuAiFylydf3Eos7Yfs89IAfZut2FN5gKHnUgXE6ZAhZQYxD1pwqGWionXov70T AqROrzSXvDJfEU2fm4dRoSfVuIMpPuNXSu29q+z5PbUX+hQrHyz3QNHYLn9nUbrd512xM2iy/+/6 mlHxvKlSpimP4dl7e6+2jgjQt8omc3bXe//qOKx3QX1dcQBcnkz5EI5j9ZUlPkVCbgz4OSkN2QrW d7ZPuticMF6UHZtbjWNTFrNI2NCsTtFAba+b1KKuM4jVNfqbzx8pcyaisObpFUcGMUf23orwZsYH YuNUUwUbf07mhKm9/8Nmvvq5V3c8RlS/FdQ6H+godj8tMerDJ1pmPzD+S01MZZP76zKcOQ/Qlaxn ZYdE/AEML4KBzROuLMJBICyQGijZcVE2Rc/uaZVHBisuXreDRT5UdlCRW19xARGE5fU/ybNzc5zl Z8yhlnwyVKbVsOQkIMCWdpHERpx7O9swwcByWMCe5NkqSppzbYLKFQ5P1amrkJ2IPyKooVYoxUbZ Gfx2JO9d3IRWpJWOhhX+tJss9H0IxX0Dbc2dAwNW9NpWubobAs4k/kqc/uaNYA7VSDQnwlQdiOEz XYATRnnETrmm6rhGaKd8FkxoyKDFD2oIqAveFfFx5txAjLHvkPP6gJD47CDkKFWNUqfse6jmGg1Z Z+E/xZE1s0piKX3WY2sMB9pDiVISghLHJu840BOqAwWh61eZuTiKYFL13979hk2nd/sN5rpvplaU g46xsVVz9jBalnAlZXDqV+afX+/3hdc2nn2hnGiZkw6YeJHAgTpXhmEJb/aFWu8PMBsjUlhJls7a PfgM0YpP+HCQrFv9tmt/vN/3xULum8Yu3JMT2QoxODcjZbFzZyARKxpFEB434ElRdNzm3IMrcgii Js0ASL5v3t77ppPrl2gwlRT1kkoYkvzkj2kIcwc4VLHt0JIyJlLZnXEXDNdEKFWjAYUn4KTqVJNC ji5Fhd7Wc2a6CCc8MftU679FyPxEQg9YXhwjzmnK8kJO+wKMYnyczyIXiAQnQkpMFsvGBzzB08WD kAEGSYTBaSZByE3PHQxlXXFL74c/spWYgKKFrcIz84QFtCpEFa0aki3POoc8WPVCi89bYNfUHUVE De5yLJQkLBSjpmpGK4dR1CmFbq+yZb6sk6gQldHl6kw4RWIlpbnYEAP7eMsSwwd8skSocO54EMUM /ueIQ1zmWretpC5jEloT59LuE3GrI6/SJ15qrZDWQHlITyx4lRaRgwknYrb09n5IsxDPHZd4INbL QK6v2a/UCtbKDfXJmINbEobcBnQMy+SHplzDcZ7IUQ6lBOwwrhSNgAOymlxK9oEBZZWNI92FQYbR 7C4Jm2toSTmjnqvL0faOhOc9wPUWJxMf6EALoDaD4zrL/Al32CyxC2GXM6/ELccBJkIKYosM3YZh sKbYgEG1vPuaUTXF0/zZ07Uc1+lQfRBjymlur5t5aOrxhlzz2CrWDTNtWVEQwz8p0UFqkuadxr60 iAkMwZXLQ3THY2acEq7T0qjSmEfxuUtOvc9ZkswBVu6F9T/j0HsbBDj7yeWZ1mlnzbAK84PZRrGC owouNVyRGRWoznM0WKc+T2i+1s+lCZxC186P6wtNajS08G2HrHz1njZhhV63MJFF9rFLRWnX/xom KgZOT7l6JII2rCtvH8QgyenUfFIVTkcD0xBTjKu3wuWY2LzSWHC1yNvEturBNVliHlX68wuL1Vmt SVupij9do6dKL/6cRHfaunMyu2pgVrImsNK0PJmLti8mC9JGol6Q2nVVFO5d54kOrTySe4bl3nrW RCkziuSNAbqgvbicgi0+4URLFiSQCuBmUmOkE4rwFa1BKa32XDSVbLFjX7Wp5cKRIF+XEu4qOAni DSvWcQTqa1lRqRqYcwjXsK80MBwh5VTSqHg/Vpelm0LkQ6B8mNg0MBUq25oO6U738/Xj/ZEsk8hr CE3JKfWUubFzKMnIJcd28JFms4r7vmVovteujcTZwmUztxjaVvMSnpqOHfh3N49r4iW/u+mnmMsQ MfQMZlUIxFODy1bw5fusGDaCfYl8fdbISrFhCq9V/5jGYtnmGNadAYutpqqMYyYwrOxnMLH1HF45 jqtaMzdqOTnTSo5T7JZbdBCtlRMcqghAIxl4YY2NwAIDOmGhKOOBA0HC5HpCnjAkx1pdGewbpphs zXrPyWeIFI+uttvgnjdJNInTmEB1XUkMWuu8v56c9tdja47i8nutWkVlGP6ppiVJXWxXfAzLpUj5 41YRYRbgki0cpgGu2dwIBOEIsjQqvdlN2XjtTi3DQQxEEyxvgagTnFwOB5YPrQkyv0Ub9ZnojknG UoGoddNRnkZZjnivSWxmOA6LXURWXLs+a2VKjHB18b7srqs08nBOaz7GkT561rVkSfhQ1FZP5FXs z8A2Qg1n4EgOy+baOVqTRlJhEdYRFvlxpUzWAoslPOxb1PQSTtnE359prXfHmXxdCwksYggiJ8F2 KwhNOpQgMhZbJ2DJ3Vqyzra2fmwKjEsu3ZgVzIjHJ9XGnFGVNyZmJqhXObIog1WoN1VyxUpZrlCk N+u1a3FMeMNAnvs6IRUrvpHOsFZm7jedbPsne+0xsfgOAvP4eGw9aZJNDGLkFEHUVHYIp3Bk04uf gD4C87Cctsch8RqiysJCprVV8lKMAlw1vdnuOpmBvVcNf3qwVuCaKWCQP2Wo3pyqwPYf6uOMe8Ql 9aTcUQbuVrnwsbnlRP1AUX+Y0KrkcLUgnJrJUEKVsMylC7mao6InEm3PU9oGBPUl+xQHsTMvC6lO 3a6cF5tDdStdQQ4tm9xhid7Lx3aHkcVJ6VIBUiyWMczlcbJ2FnMQ7dcRit293Wav5Xqdb2eh1ozW prrboR9AHdYQDA91FInnYuE6BeO0XgdKj9LG1Wz5w8bQyPhN8pFn7iQNJXelkI5okPJHEkKor3Yn OopnS6L8QRcl6vI6jTco1GuaGk+xC1tW1Z1T6y0X5nqSV1UjyzU5peTM6qtDv3DGiET4sF0Z75Mk MXbHsIFPgaqviQ5Ut9Bsfoty8bMiWhKBKVAD+FFvV/CMOwgn657X3XPCp+QSVE3E6J//8Ed/HnVd VFxNg6Mu+Cg4rtVPPHxLm4udQiN0YCRcVTWpV1np083p6wZRx1xLQWCJcIhkO7iTXsnLcPEjhyo4 RMZ7jX7Vs1XLRi/PUJWBJiQS/8Ot8PSUwOx9aR1k3RZSD40DZAvJ75zCFcvLajlGWqrIs7BzRjzx BzRFAj9cw3wESd49DIm9LpZhtQb2+aqRqtr6/MqvSZaLF0s8765IqExGaItkXzOEiJwKyM6M3d2H W27y5lpq0Qu09YnpKh0vgNX4kBliZ2pTvvgXXp8mDKhzKnpwKN9lFdMk/ZTj/5sS4EBpqFMQpVvq JI0RQKiweQh1oBJr5aWx++0kvAQxJ4YDf5uis0x4erJOhMM8iVsuxWcT1psWQ5etRP30pSxSdTjt an5wweEsQjMhOm6HzzVHGXNMfSzR+yh/r9t8j5jDTI/oDMYbpGxkPu1quycHgnL6Ecf1xGGWpTKb Us7GcfKzzlyd5MYq8nPx32vNrp8Xc+kiNP4Zz+Z9RVXERkhhV5ccHBXTOIHj6gCBHATZDnIcluCO 2lTPuXeTc7lmsBP0s17GhPznMSc2CXd/zRz3kR1DchLqd6khElHsm0nNY3qreczmdnYY4vga5e4w VjDuUg6mxVs4C5HY7aSpV+zG94HD02M9KejnvcaMaNzxVBKWw1m6Tkt83cpn1qgKMCfNoXkWZznm sjQbnXFtSq3tY2QjuYcYBEL4U9NEJouMMzrNxjD2ZavNEako+aYXa4cEt4FNXKVQWgQSnyXs8Gbj BEwjkSKkeNc8P9vkmuc4UrspXe2sSGXb5ClyKjhHGgdwekfYmlYoZ+G54+B5OzRz3PXFi6NZI9Dk TIjU7Nzt++qbMHvKKFtbmOcMZLJEfAQOkUNKGYlXInXMAgcn8EWaqHKJEmLnZsgHWj3OaxShlfMU Sk4u5yIpzEs5L2wSaXkF9FqzxOcRc2scjiCBeUv25RnZ4l1aLThexaJ8ncSCSL1GiVM+wjZofA5i 09VMuWExnsentCM145w0IesymXhiM+ddaAfMEFSeO73skENGyuBwBjkzNAndrVLNmh7hF6krmOaI TQ1iDwSbWavyEdYaum3UvAxmfYI8pYNoFq3YsDAXDVyRX7vU9W1AGJx/V5JCtkT92hkfhTdBQBSH pJE8w4XxPI/HQBOJnbCliSaWVN8UD5AcSlA3ospNGlVcGhWitSReLbfOonSEg7L4B7pA2pyVupHQ bnK4ovAF+gJuiOKKk9rw3mVO8NbkU5NY1PkiILTks7ZR0F29aTAofo5xhIfJuoguLoOHqEQrBy9L Mmfr2DfikjDQLouaD8Dh5WwaOrLubKs6RWXuuhKvk7JZmKx0+azUrskqjQTwDem2lQDzGuYNfNGk hwW7pwnhgorFCSjwNmDCAYAWEyu0C61VBgwtLsUpFyXpng73uLCkB8NdENZu46I6oOIPhMmV9j97 zI7UTeUgzUwiWzTrhNTI1OoBsEHBFbEoi/riQnhew+FfoCbpH59wyh2WO1cGNQVGo19e1GGUO+Gf smJ/G4EW3M7lfubWH58ObSidcpQ7C2g+hCfiQgy0XGsGjr3vQlX2Eiva86guIvk6TWIpPNo9xPUz X/Dk9cOtnTt6OgLt/qjlBJdjtcW/bn0cujAk5htts5qrStwclhPzzOqxpEQ+jzoFj2eN47Ndr7MD sdtQzBVEl8LVDigiuDks7cZ2LXUxOReZxmfd9pU49UyTiFmhjjDKuGyhnFVOD9/lqQNTqiKtDxqU hUcsTBLriUkKt16AkjNJdEYQUzCNXPRUDHqcxenP1KNJ4fH7KtYxwodSnSL0jDAXars3p7+1EtC1 jqdEWHyVz5HvV0o+3P5+v1Hzh0hiAW2lS0lBFSjHz/WCg3YhmXxREi5+eFUx8yY+z80g28EcNGUC z+APmHMaXu0g2Zu8cL437xwQeaBdfe0MQLWcd85HiDYcbBLgX+JSLYChhlat/uJDy0ixQkZkpakm bWNbxwos3Yi1OC+xUWGR5cVPk6tsL5x9zgmqVjLkntYznF948R+nlsvXvaaJXNXUuZbxKInTiENU k469p9Mj1vliLSYnJfPZbBaDWO2Ia3G/Ss+Q5KiqDSeWZMhQiKW6I+nEpjE+OQ3I6VIAoE1nlNJQ qINzqN3xDDpGqSUl1V+Fw8sJiM3ipUFqeRDXfkg0H0nh/amvQOors7EBF9blSGvbqA6pgSyFnSWB XuzNTSO7IA6g2TpNiL/LEuaDeba3OQZPsI6EGsBdwoEK3YFk/befhZELPprwAwdz+3s0p9fXN+HQ i4jA0sK8HEX02qb8iK85ojW6OV4PxsmnhP7yM89RUJOA2xEu3XPBxUHsMScSCPfPmOOu9NyUwPwl ioOi/rjJZ9J6A94V+pnh+A2OdnImlcgV29rVSqJcvldODNPTDKwr70bKW8wM8jCnt5Q+AHdne7At 9ZDUCIf6dm8H29+EGwJhBgTZ22ZT7AUaDMnWlwlK5hHHzDOJ8XhU2PmI+hTVVc4+qSyx5xJMVzRe U7UIWFYHRmx0m2qCaqcGDOM1EqmAfXCiYYNxUhK2BeaPffiQ5UJtOnlBLPT9D0EXp4KtlT/0dqGv cvq2W3C+ekek4+e9JF6RRk04FNFWrAeylhHO4UkRn8ahvy2IC2Ff63h+FqXpop7ZZHHxI0rADmcw c09Q428Eo57myLsK0SheRtJsiUMacepWBpqqes6Nk7rTlftvB4Nv3Gsf8L8oqU6M2GzAFAKVvoxX ljCfft8kwDnocQzF5i/zwA836D+FrWoCK9sPbvxw46Prz/9/n3FeEJqIk3Irtel30yLtj//q7yCK 2b57+zb+Hdy7s83fB/Idnzv37t37aDC4vXOX/jO4N/hoe3Dr3t27H5ntv3pPLvnU0GmM+WhEUib/ 4H3EvX6JDv2yn08/Ns/zcZTYrXJJ8mYaj0mJS/PiXE4y9fokNrt5mC/Pi3g2r8zGw012V3KJns+2 WCRBESV9YVoBMAamnx5B/XGfGziB+q/VaAwsAXik1Ec+N+d5bXBKXGERqVnEI/gW5RC7T0kqpfkk np6jHfF+EWeFBQFRMyXUX3x58uIVF3xBodZD5FuMzfN4TKCERAy9GldwLIUZcTt44upuk8RDbD0f Cw/s496hDaKGPRrZIEhJPS9MvsRzm9Tdc5O4zDg8evngmzFOnDFkni9pPMCoCDuOE5R/MUR50zrp oQm62bzZP3n68tWJGb74rXkzPDoavjj57QO6uZrn9KuFIoSmYpzAYVEbrMCZp+fUebRwsHf08Ck9 Mtzdf75/8lsagnm8f/Ji7/jYPH55ZIbmcHh0sv/w1fPhkTl8dXT48nivb8yxRbcsGvjABE95jVjV rFCjR4b9W1rUkvqWIFTnFGUHx5bAx8REJHGW5z+/cGgkSnKuk0nyugqmkbq2PzVZXsFyas0X86pa fv7pp2dnZ/1ZVvcJGXyaSCPlp7+hmz/+9MYNovg34kwgIhDlbm82A3z+wvK//zgu+/WY9As7qd1D fxdn46Qmuf/FOM+m8aw//01w8eY6F53fDB+yRZHleKa5VFaTJB51r0HQctvUSwJnBcea5+bR3vGJ 2cinLJL52/H+13ubSv7fsZXn+Ohhcwt94TuYyN1GxiGduZAXHiSQXCcV5p86PU6XMM9VZ3nrfjRe MpHL3HPsRc5GxJwbwbpgH9J9myBqXOMjGaOy/RI0gvcArOZCovwyvAAqBMYK10LRYTy0AIewDC+5 GxWp3KSOFXFyruyAWxqdA0JyrRgaeY/3CesAmEBqPyeuFWdRcoNhDhxbzUsFwmDemVyPBNHwODCT Sp4yDh449RhbH1g+5mrsRRpL6kCU1PS+qXIWvJsPKGDrGu8i5HoSJWDy3HWT1RJ1OA2fQRP8c48t qHT/CkFEOW45I0xOrTFNYDBwFV7RGeaV0/XOoPtxd2A8XJTWKCwzLyIU7ocjN90KuO1ddcOT/Dsl ebOBBGTzMeadVGJ2JVYCIt/JF/zZU1CLhWjfXhZjfzf9jb82b3xPu2NqBlgZ11BsvgTe9BfK7gUl Ob54Q19D8PpLtPpWW/6G7w++08//8Lvtf+Anzuaor7xBDX/R9AQ9/l47796MyOwvUU8+YYd+MTaf 0G+b3Ehwn3Rom26Vvx7oz0IL2nl8tOefcJsyp5g3anWC07+0/Z6fTELkk3iTLg5cCzRZG9Lsr6jd TT/ZI1rTRXiTvuoL16fg3u+bJfJd3CMx82TvQfBLq0XVBjqNf/ll01Pqo/n1r7FYn+i8fdme2+6b iQGesJ8C7ngxacc40DQaV4lsekEiTFS84d2cnZG4K4OWMLF5nrJ4isBdYnZVZHWSEEm/yYuFiQqI ffFHSEiIyJqo3YzjPuf0vukU0VPYEc3vut70I4/5y/ZChevk6Z/Q53hBD7y9TUj4m7WfP6afmMTk rvB3TLRqaO5nold992ar49+3h2Gk0TRKknxsNtwjDzp34QW/wr2bnR/WFh+fH8J5cNRLD4d0e9mb IBMIBYSEzk+1afz/cuCML9GLVgNr+y4gX2Yvfnc0vfgfbnN+7q/5NkHUXwpV+yXmBjsMZjx/0KjM 2twW85lfNZuBmMff2YRQzw0dqVwP+iJDDOetp8zTN9EZo75Sf+c3ZCQ7obNfglz+6jrGz+h/UPca /e/ODut/d25d63+/xKcFSCd2CvCpbOxnJbwT1z1z+XUixP/u4V1/fuZDahKpIX9D489HP7v/7+I3 v/8HvP93dnau9/8v8fH2HxIvS/YHVs4AFJGQ7yhjjKHEThyXsGuYS4xCn/XMX2IPokcDPXwX02+e RjGBL/MFL8Y/jpO4XEKJ/42Ymf56NiS6gKY+YEN6zgH8f4kpie0y5x80JT24NiV1TUmYZDTy4Xn+ L1uUPtj8X9mwdKmNCHYcNaw6cwbd21iOOvz3v2o2EkF8Q1rtyu3S69dZILIJhQpMl58+Jhg7q+ZL 6N6shR0JUI3G4zqtiRZzr/aETQT6tzQQXGA9g4h40ujjMMi8K7mAm034Mr1pn8/vSDz/kcf8pIW6 JTA/geYXr54/h1rpOm1+45Rep/J4Y4B/zqF23yv60T3vsDvh50TowzcU3r6R4UWkE2SkDgw2H3Tf pfO96VUs//DmJTr4lzKORnOZ5VVuaAe+y6fvZC7e7TQ9k6568wbN23CCTDmZyz5MYW6+WrMMNfJt JoYP+jc0eGDuKy7mRpuAVOHZ3Bz3GtYPbdnCQ0ndNN7ChHfOEEXQl44PHYHYrsEstD/KIxz4JHdg g/Ept94ob/Ce0o3he/VNZqQeyrQu38ELT6MhbSvQuFq3qAlmidvkZ7CSjQcP3Cw3KjF2qI0QapfB kooxhnMon7Dx31OjS2i0avdZNgaftde0XyXKIu+JRfDMFTopPgsT2IKceUhJoGeWvYAst/RyR4+/ yiIUkNqUWOv6Qwvzmy8va77TQte2wBP6pMjPQvPv5eYSnVqe1MyevXOcZO2WcO/tmI9DhtK9FT1v bv/C3L29br1oN3j39uWtNLvTs47Lmmo6/pdt/ObjWcxf0iBCcLlFt2s+1DK6HzbTZTDN5xJWM1hv z3cnXKX2LT+0qXl9aOt0oozsky/NYv2Vl1iY2i/5oSET7PLft61rmIElBs7MIhx5p2EZzVvpS8MU 23385BN3BT34QVnm8ZzE7oLJvKEnlV30/mVelkCz68ILO7ERYyS+NnQqRKjoF0gWIuBmnVviSOhC 3/YhOrmq6VAQaTO/6tKJX3e5IbRsiQTpiHHTCOIvAxjQsnhhe4PhfO55e4y6T4TjJu8cE+R/5W1X zJrroxj45LIO6aquNTw2eJn8oB3E4F1kS2dPfH71AkpX1jpyRTc6Yv3zwFS39+Llwd5BMGHSn79t YE0Xf/4t3vEz+v+t23cG6/r/9rX+/0t8/vv0/2td/lqX/39Yl58SPU1pXg7++fHRwbunN/5uglLL Nrhy4zLbOZ7Eg+/ejZdJXeL/N0itQEbHzYc3SeKp64UtAzqUeCWbix1ajPU3NuHyF72+lBEhC4de MvEKStnEs5y4TcpzFW7ft8f9/vEnL7YG33DMQfgb10yTCrxEDedMX5hF3d7IDzwe9F4MNjkCYeN4 p/diZ1P6onEcGxzxYX9fx6c4CaTCK/zTaEqlStiOv9RpLl3ubGz2ZT9oPMfx2xffEJA+B7GHcR84 ovmssRzyUk/rbCy8BXtBt8gNgTCIApk0ISbB3SpoS//eJiSmfZ/wxtIFrjx/+O7hy+fPhyd7BtBs hikVQuUJ5CNgK5MwX+W2if5opsdEwLRlP8fXBv/Re4g2xZQRqRNa+zHlYt8IAHK4ShhUhZQRVPAC 66oaXZrtOGij1boM0k6IXl66+JGeuLaJ35bz5DzAr0Jzncf2aaJzWqhxVOLNHuTFKNpTaSjQjQbS +5gZaUEb5Zl4tYQUof1f40ytAOj0lMwZDJWo7wPq1q0j6Nb8NcxahD8v26M/+I0p/wLg+62Onvx3 C+q/0ceZKv+W7/g5/y99HP67O7hLvw8Gd3ZuX+O/68/15/pz/bn+XH+uP9ef68/15/pz/bn+XH+u P9ef68/15/pz/bn+XH+uP9ef68/15z/7+T8e3d8KAPAAAA== --Boundary-00=_5cKWMLpg3qD0v70-- From debbugs-submit-bounces@debbugs.gnu.org Wed Aug 04 19:21:10 2010 Received: (at submit) by debbugs.gnu.org; 4 Aug 2010 23:21:10 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgnGn-0004H3-IR for submit@debbugs.gnu.org; Wed, 04 Aug 2010 19:21:10 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgnGl-0004Gy-C0 for submit@debbugs.gnu.org; Wed, 04 Aug 2010 19:21:07 -0400 Received: from lists.gnu.org ([199.232.76.165]:40973) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OgnHF-0003qp-2D for submit@debbugs.gnu.org; Wed, 04 Aug 2010 19:21:37 -0400 Received: from [140.186.70.92] (port=48017 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OgnHD-00086p-G0 for bug-coreutils@gnu.org; Wed, 04 Aug 2010 19:21:36 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,T_RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OgnHC-0003mg-9r for bug-coreutils@gnu.org; Wed, 04 Aug 2010 19:21:35 -0400 Received: from kiwi.cs.ucla.edu ([131.179.128.19]:60501) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgnHB-0003mO-UY; Wed, 04 Aug 2010 19:21:34 -0400 Received: from [131.179.64.200] (Penguin.CS.UCLA.EDU [131.179.64.200]) by kiwi.cs.ucla.edu (8.13.8+Sun/8.13.8/UCLACS-6.0) with ESMTP id o74NLSbd025135; Wed, 4 Aug 2010 16:21:29 -0700 (PDT) Message-ID: <4C59F5F8.9080309@cs.ucla.edu> Date: Wed, 04 Aug 2010 16:21:28 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.11) Gecko/20100713 Thunderbird/3.0.6 MIME-Version: 1.0 To: Bruno Haible Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> In-Reply-To: <201008040133.13241.bruno@clisp.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable X-MIME-Autoconverted: from 8bit to quoted-printable by kiwi.cs.ucla.edu id o74NLSbd025135 X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -3.8 (---) X-Debbugs-Envelope-To: submit Cc: Bug-coreutils , Bug-gnulib X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.1 (-----) On 08/03/10 16:33, Bruno Haible wrote: > But when the stack buffer is not sufficient, then the use of coreutils = memxfrm > is 30% to 70% slower than the use of gnulib memxfrm, with a difference = of > 700 =CE=BCsec at least. (Ooo! Ooo! Performance measurements! I love this stuff!) It depends on the data. In the typical case, "sort" is applied to text data, which does not contain NUL bytes. The data in that benchmark contained many NUL bytes. If you take the same benchmark and uniformly replace "\0" with "\t" in compare.c, then the situation is much different: coreutils memxfrm is about 3 times faster than gnulib memxfrm on the larger test cases (this platform is Ubuntu 10.04, gcc 4.5.0, 2.4 GHz Pentium 4): 503-penguin $ gcc -std=3Dgnu99 -O2 -Wall coreutils-memxfrm.c gnulib-mem= xfrm.c compare1.c -I. 504-penguin $ ./a.out Time for gnulib_memxfrm: 0,032002 Time for coreutils_memxfrm: 0,028001 Time for gnulib_memxfrm: 0,024002 Time for coreutils_memxfrm: 0,024001 Time for gnulib_memxfrm: 0,036003 Time for coreutils_memxfrm: 0,032002 Time for gnulib_memxfrm: 18,2051 Time for coreutils_memxfrm: 5,48834 Time for gnulib_memxfrm: 16,045 Time for coreutils_memxfrm: 5,50034 Time for gnulib_memxfrm: 15,837 Time for coreutils_memxfrm: 5,44834 I expect that this performance glitch in gnulib memxfrm could be improved, as it shouldn't simply double buffer sizes when they're too small, as at that point it already knows what the final buffer size should be. Doing this should bring up gnulib memxfrm to be as fast as coreutils xmemxfrm for this benchmark. Also, I agree that gnulib memxfrm is faster in some important cases. Still, gnulib memxfrm is problematic, because it insists on managing memory itself. Come to think of it, looking at gnulib memxfrm gave me an idea to improve the performance of GNU sort by bypassing the need for an memxfrm-like function entirely. I pushed a patch to do that at . This avoids any potential naming collision for now. The point remains, though, that it's confusing that gnulib memxfrm's name begins with "mem", as the mem* functions don't allocate memory. Would you consider a patch that renames gnulib memxfrm to amemxfrm, or to some other such name? From debbugs-submit-bounces@debbugs.gnu.org Wed Aug 04 20:39:50 2010 Received: (at submit) by debbugs.gnu.org; 5 Aug 2010 00:39:50 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgoUu-0004py-GT for submit@debbugs.gnu.org; Wed, 04 Aug 2010 20:39:50 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OgndX-0004QY-Av for submit@debbugs.gnu.org; Wed, 04 Aug 2010 19:44:40 -0400 Received: from lists.gnu.org ([199.232.76.165]:35378) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1Ogne0-00042N-Vt for submit@debbugs.gnu.org; Wed, 04 Aug 2010 19:45:09 -0400 Received: from [140.186.70.92] (port=50273 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1Ogndw-0005Bs-Gz for bug-coreutils@gnu.org; Wed, 04 Aug 2010 19:45:08 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=0.8 required=5.0 tests=BAYES_00,RCVD_IN_PSBL autolearn=no version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1Ogndv-0006S2-6r for bug-coreutils@gnu.org; Wed, 04 Aug 2010 19:45:04 -0400 Received: from yxa-v.extundo.com ([83.241.177.39]:32843) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Ogndu-0006R0-Gz; Wed, 04 Aug 2010 19:45:03 -0400 Received: from mocca (c80-216-27-64.bredband.comhem.se [80.216.27.64]) (authenticated bits=0) by yxa-v.extundo.com (8.14.3/8.14.3/Debian-5+lenny1) with ESMTP id o74NiWPU027788 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES128-SHA bits=128 verify=NOT); Thu, 5 Aug 2010 01:44:35 +0200 From: Simon Josefsson To: Paul Eggert Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> <4C59F5F8.9080309@cs.ucla.edu> OpenPGP: id=B565716F; url=http://josefsson.org/key.txt Mail-Followup-To: bug-gnulib@gnu.org Mail-Copies-To: nobody X-Hashcash: 1:22:100804:bug-coreutils@gnu.org::+gY/jbyIxVUAGPrw:3K46 X-Hashcash: 1:22:100804:bug-gnulib@gnu.org::elKEn//ZsEGM0OPm:Bt3G X-Hashcash: 1:22:100804:bruno@clisp.org::xGFFLwaYmRpgcnZa:8NKf X-Hashcash: 1:22:100804:eggert@cs.ucla.edu::PAC60Uv9frDC/zuW:J3x1 Date: Thu, 05 Aug 2010 01:44:30 +0200 In-Reply-To: <4C59F5F8.9080309@cs.ucla.edu> (Paul Eggert's message of "Wed, 04 Aug 2010 16:21:28 -0700") Message-ID: <8739uurli9.fsf@mocca.josefsson.org> User-Agent: Gnus/5.110011 (No Gnus v0.11) Emacs/23.1 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-Virus-Scanned: clamav-milter 0.96.1 at yxa-v X-Virus-Status: Clean X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 1) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.9 (-----) X-Debbugs-Envelope-To: submit X-Mailman-Approved-At: Wed, 04 Aug 2010 20:39:48 -0400 Cc: Bug-coreutils , Bug-gnulib , Bruno Haible X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.9 (-----) Paul Eggert writes: > Come to think of it, looking at gnulib memxfrm gave me an idea > to improve the performance of GNU sort by bypassing the need for an > memxfrm-like function entirely. I pushed a patch to do that at > . I don't know this code at all, but would your approach lead to problems if two different strings have the same MD5 hash? MD5 is broken, and finding collisions takes just seconds on normal PC. See: http://en.wikipedia.org/wiki/MD5#Security /Simon From debbugs-submit-bounces@debbugs.gnu.org Wed Aug 04 22:58:08 2010 Received: (at submit) by debbugs.gnu.org; 5 Aug 2010 02:58:08 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Ogqel-0005l7-Ov for submit@debbugs.gnu.org; Wed, 04 Aug 2010 22:58:08 -0400 Received: from mail.gnu.org ([199.232.76.166] helo=mx10.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Ogqek-0005kr-DU for submit@debbugs.gnu.org; Wed, 04 Aug 2010 22:58:07 -0400 Received: from lists.gnu.org ([199.232.76.165]:39167) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OgqfE-0006Tx-Eo for submit@debbugs.gnu.org; Wed, 04 Aug 2010 22:58:36 -0400 Received: from [140.186.70.92] (port=58298 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OgqfC-0006U2-T9 for bug-coreutils@gnu.org; Wed, 04 Aug 2010 22:58:35 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,FREEMAIL_FROM, T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OgqfB-0004zk-Id for bug-coreutils@gnu.org; Wed, 04 Aug 2010 22:58:34 -0400 Received: from mail-bw0-f41.google.com ([209.85.214.41]:62652) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Ogqf8-0004yq-Fy; Wed, 04 Aug 2010 22:58:30 -0400 Received: by bwz9 with SMTP id 9so3780019bwz.0 for ; Wed, 04 Aug 2010 19:58:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:received:received:sender:message-id:date:from :user-agent:mime-version:to:subject:references:in-reply-to :content-type:content-transfer-encoding; bh=tuJje7xuCyR1OY3m19KlpBnOFDr16ToUjNdWfCE2bdg=; b=vJOTBp/Tul1BDe3FhznBuanp+mFXWXd3fO7WTNqIxCGlQxVKG8nnybZ580wGW4Yqt2 mjyAlNHiSmVWi1VDyagV64Zx1CWCF076nDcElILXnERWtWuxOquj0pj0Rd2MuJC4E2Wf ur5OzCfU3+nJIwJ1E3g7OSFk3O3PJ81ecvZOM= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=sender:message-id:date:from:user-agent:mime-version:to:subject :references:in-reply-to:content-type:content-transfer-encoding; b=NKdlpUmOw2AVzhI7u5SgLTcGLLqgT0jaR/x79PwIAiwtneWwc/5646hiEgGleVSCvj 4ro5zp7+F2R9rgNrU9YfRe+emUUg8kpp48sv7X4XXfTmTOznONoneW876IZKqwYpmlnm sVGPxowWmnhB3qXjDBOopildMmFqFjOz234F0= Received: by 10.204.81.130 with SMTP id x2mr6805174bkk.210.1280977109141; Wed, 04 Aug 2010 19:58:29 -0700 (PDT) Received: from yakj.usersys.redhat.com (s209p8.home.99maxprogres.cz [85.93.118.17]) by mx.google.com with ESMTPS id s34sm6453277bkk.1.2010.08.04.19.58.27 (version=TLSv1/SSLv3 cipher=RC4-MD5); Wed, 04 Aug 2010 19:58:28 -0700 (PDT) Message-ID: <4C5A28D2.3040102@gnu.org> Date: Thu, 05 Aug 2010 04:58:26 +0200 From: Paolo Bonzini User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.10) Gecko/20100621 Fedora/3.0.5-1.fc13 Lightning/1.0b2pre Thunderbird/3.0.5 MIME-Version: 1.0 To: bug-gnulib@gnu.org, Bug-coreutils , Paul Eggert Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> <4C59F5F8.9080309@cs.ucla.edu> <8739uurli9.fsf@mocca.josefsson.org> In-Reply-To: <8739uurli9.fsf@mocca.josefsson.org> Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 2) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.9 (-----) X-Debbugs-Envelope-To: submit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.9 (-----) On 08/05/2010 01:44 AM, Simon Josefsson wrote: > Paul Eggert writes: > >> Come to think of it, looking at gnulib memxfrm gave me an idea >> to improve the performance of GNU sort by bypassing the need for an >> memxfrm-like function entirely. I pushed a patch to do that at >> . > > I don't know this code at all, but would your approach lead to problems > if two different strings have the same MD5 hash? MD5 is broken, and > finding collisions takes just seconds on normal PC. See: > http://en.wikipedia.org/wiki/MD5#Security MD5 is used simply as a kind of "random key generator", so it doesn't matter. I wonder two things however: 1) why bother with memxfrm as a tie-breaker? isn't memcmp good enough? 2) maybe there's something cheaper than md5 that can be used? For example you could compare a^x and b^x where x is the output of a fast 32-bit random number generator? It doesn't need to be cryptographic, I'd pick http://en.wikipedia.org/wiki/Xorshift. Paolo From debbugs-submit-bounces@debbugs.gnu.org Thu Aug 05 19:29:14 2010 Received: (at submit) by debbugs.gnu.org; 5 Aug 2010 23:29:14 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oh9s9-0006hk-Tn for submit@debbugs.gnu.org; Thu, 05 Aug 2010 19:29:14 -0400 Received: from mail.gnu.org ([199.232.76.166] helo=mx10.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oh9s8-0006hf-35 for submit@debbugs.gnu.org; Thu, 05 Aug 2010 19:29:12 -0400 Received: from lists.gnu.org ([199.232.76.165]:49086) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1Oh9se-0000G6-F1 for submit@debbugs.gnu.org; Thu, 05 Aug 2010 19:29:44 -0400 Received: from [140.186.70.92] (port=47683 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1Oh9sd-0007u2-39 for bug-coreutils@gnu.org; Thu, 05 Aug 2010 19:29:44 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,T_RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1Oh9sc-00071G-11 for bug-coreutils@gnu.org; Thu, 05 Aug 2010 19:29:42 -0400 Received: from kiwi.cs.ucla.edu ([131.179.128.19]:34178) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oh9sb-00070x-Oa; Thu, 05 Aug 2010 19:29:41 -0400 Received: from [131.179.64.200] (Penguin.CS.UCLA.EDU [131.179.64.200]) by kiwi.cs.ucla.edu (8.13.8+Sun/8.13.8/UCLACS-6.0) with ESMTP id o75NTb5n009163; Thu, 5 Aug 2010 16:29:38 -0700 (PDT) Message-ID: <4C5B4961.6010007@cs.ucla.edu> Date: Thu, 05 Aug 2010 16:29:37 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.11) Gecko/20100713 Thunderbird/3.0.6 MIME-Version: 1.0 To: Paolo Bonzini Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> <4C59F5F8.9080309@cs.ucla.edu> <8739uurli9.fsf@mocca.josefsson.org> <4C5A28D2.3040102@gnu.org> In-Reply-To: <4C5A28D2.3040102@gnu.org> Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -3.9 (---) X-Debbugs-Envelope-To: submit Cc: Bug-coreutils , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.1 (-----) On 08/04/10 19:58, Paolo Bonzini wrote: > MD5 is used simply as a kind of "random key generator", so it doesn't > matter. That depends on what one is using "sort -R" for. If one uses it to choose data that are relevant for cryptographic purposes, it might matter. (Admittedly this is unlikely.) I'm not that familiar with cracking MD5, but I would guess that the cracking methods are rendered ineffective by the 128-bit salt that "sort -R" uses. If so, then there's no real problem. If the fact that MD5 is crackable is a problem, it'd be trivial to substitute (say) SHA256. However, this would slow down 'sort -R' considerably: switching to SHA256 would slow down 'sort -R' by a factor of 2.5 on the little million-line benchmark that I just tried it on ("seq 1000000", x86-64, Xeon E5620, gcc 4.5.1). > 1) why bother with memxfrm as a tie-breaker? isn't memcmp good enough? If two keys K1 and K2 compare equal, their random hashes are supposed to compare equal too. So if memcoll(K1,K2)==0, the random hashes must be the same. Hence we can't just do a memcmp on K1 and K2; we need to do a memcmp on strxfrm(K1) and strxfrm(K2). > 2) maybe there's something cheaper than md5 that can be used? For > example you could compare a^x and b^x where x is the output of a fast > 32-bit random number generator? That wouldn't be sufficiently random, even for non-cryptographic purposes, since keys that are natively nearby would tend to sort near to each other after being exclusive-ORed. But I see your point: perhaps there is something faster than MD5 for this sort of thing, and which is "secure" enough. Perhaps the ISAAC / ISAAC64 code that is already in GNU coreutils would work for that? From debbugs-submit-bounces@debbugs.gnu.org Fri Aug 06 04:22:27 2010 Received: (at submit) by debbugs.gnu.org; 6 Aug 2010 08:22:27 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OhICA-0001rG-FO for submit@debbugs.gnu.org; Fri, 06 Aug 2010 04:22:26 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OhIC8-0001rA-NU for submit@debbugs.gnu.org; Fri, 06 Aug 2010 04:22:25 -0400 Received: from lists.gnu.org ([199.232.76.165]:52566) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OhICf-00071m-Qf for submit@debbugs.gnu.org; Fri, 06 Aug 2010 04:22:57 -0400 Received: from [140.186.70.92] (port=33327 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OhICe-0006Df-EC for bug-coreutils@gnu.org; Fri, 06 Aug 2010 04:22:57 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,FREEMAIL_FROM, T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OhICd-0000ay-5J for bug-coreutils@gnu.org; Fri, 06 Aug 2010 04:22:56 -0400 Received: from mail-wy0-f169.google.com ([74.125.82.169]:40659) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OhICc-0000ar-Rh; Fri, 06 Aug 2010 04:22:55 -0400 Received: by wyg36 with SMTP id 36so8441617wyg.0 for ; Fri, 06 Aug 2010 01:22:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:received:received:sender:message-id:date:from :user-agent:mime-version:to:cc:subject:references:in-reply-to :content-type:content-transfer-encoding; bh=GF0niYck8wNYrdFiQCdjcPqTGhnaFzskRXn48GQeHHo=; b=A9gfx8Y5DMDp/KnmssoPMc2/GKQdYUnJL5VSztYNqu27YOf4FvuX0jtDXqd9J/JMVz r9Y6tyJlNoBhiI4+BeDmRWYCsbRqJrhXY1IpE/5/Gbz/nxdNP2StjdTpFeNGX3wdewtz rUj/I+LMq97LczgLNVDevw9sBzSABtTQpHnOw= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=sender:message-id:date:from:user-agent:mime-version:to:cc:subject :references:in-reply-to:content-type:content-transfer-encoding; b=PVXzAVmS3D8vcEBTqDzxey4uzZWSBtNZ2dXNDa9jlpkruCo+9SK+8GaTt/peDEf/+v vhRNq9trol8OP/+fDZOP7zTuNcgAgi8q82Gl+XroPsrJAPr+0v0jlS/Hldp47NhqzJvH TYl1PMCUJUQq9L+8UwAWCRpsYu/tcEXvYOVaQ= Received: by 10.227.157.17 with SMTP id z17mr9756019wbw.122.1281082973721; Fri, 06 Aug 2010 01:22:53 -0700 (PDT) Received: from yakj.usersys.redhat.com (93-34-165-61.ip50.fastwebnet.it [93.34.165.61]) by mx.google.com with ESMTPS id h3sm1076360wbb.9.2010.08.06.01.22.51 (version=TLSv1/SSLv3 cipher=RC4-MD5); Fri, 06 Aug 2010 01:22:52 -0700 (PDT) Message-ID: <4C5BC65A.4020001@gnu.org> Date: Fri, 06 Aug 2010 10:22:50 +0200 From: Paolo Bonzini User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.10) Gecko/20100621 Fedora/3.0.5-1.fc13 Lightning/1.0b2pre Thunderbird/3.0.5 MIME-Version: 1.0 To: Paul Eggert Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> <4C59F5F8.9080309@cs.ucla.edu> <8739uurli9.fsf@mocca.josefsson.org> <4C5A28D2.3040102@gnu.org> <4C5B4961.6010007@cs.ucla.edu> In-Reply-To: <4C5B4961.6010007@cs.ucla.edu> Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 8bit X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 2) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.9 (-----) X-Debbugs-Envelope-To: submit Cc: bug-gnulib@gnu.org, Bug-coreutils X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.9 (-----) On 08/06/2010 01:29 AM, Paul Eggert wrote: >> 1) why bother with memxfrm as a tie-breaker? isn't memcmp good enough? > > If two keys K1 and K2 compare equal, their random hashes are supposed > to compare equal too. So if memcoll(K1,K2)==0, the random hashes must > be the same. Hence we can't just do a memcmp on K1 and K2; we need to > do a memcmp on strxfrm(K1) and strxfrm(K2). I see. In practice, this is because "you cannot separate straße and strasse". >> 2) maybe there's something cheaper than md5 that can be used? For >> example you could compare a^x and b^x where x is the output of a fast >> 32-bit random number generator? > > That wouldn't be sufficiently random, even for non-cryptographic > purposes, since keys that are natively nearby would tend to sort near > to each other after being exclusive-ORed. You're right, keys that differ only in the leading or trailing bits would tend to stay respectively very far and very near, though you cannot say anything about the order. > But I see your point: perhaps there is something faster than MD5 for > this sort of thing, and which is "secure" enough. Perhaps the > ISAAC / ISAAC64 code that is already in GNU coreutils would work > for that? ISAAC is a RNG, so wouldn't that have the same problem above? You definitely need to use a hash function, it's just that you do not need a cryptographic one. Paolo From debbugs-submit-bounces@debbugs.gnu.org Fri Aug 06 13:53:33 2010 Received: (at submit) by debbugs.gnu.org; 6 Aug 2010 17:53:33 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OhR6r-0007DR-0I for submit@debbugs.gnu.org; Fri, 06 Aug 2010 13:53:33 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OhR6o-0007DL-FH for submit@debbugs.gnu.org; Fri, 06 Aug 2010 13:53:31 -0400 Received: from lists.gnu.org ([199.232.76.165]:53558) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OhR7M-000765-H6 for submit@debbugs.gnu.org; Fri, 06 Aug 2010 13:54:04 -0400 Received: from [140.186.70.92] (port=40591 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OhR7L-0005Ds-JK for bug-coreutils@gnu.org; Fri, 06 Aug 2010 13:54:04 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,T_RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OhR7K-00024D-Hm for bug-coreutils@gnu.org; Fri, 06 Aug 2010 13:54:03 -0400 Received: from kiwi.cs.ucla.edu ([131.179.128.19]:38249) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OhR7H-00023H-SC; Fri, 06 Aug 2010 13:54:00 -0400 Received: from [131.179.64.200] (Penguin.CS.UCLA.EDU [131.179.64.200]) by kiwi.cs.ucla.edu (8.13.8+Sun/8.13.8/UCLACS-6.0) with ESMTP id o76HruoW017830; Fri, 6 Aug 2010 10:53:57 -0700 (PDT) Message-ID: <4C5C4C33.8040707@cs.ucla.edu> Date: Fri, 06 Aug 2010 10:53:55 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.11) Gecko/20100713 Thunderbird/3.0.6 MIME-Version: 1.0 To: Paolo Bonzini Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> <4C59F5F8.9080309@cs.ucla.edu> <8739uurli9.fsf@mocca.josefsson.org> <4C5A28D2.3040102@gnu.org> <4C5B4961.6010007@cs.ucla.edu> <4C5BC65A.4020001@gnu.org> In-Reply-To: <4C5BC65A.4020001@gnu.org> Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.1 (-----) X-Debbugs-Envelope-To: submit Cc: bug-gnulib@gnu.org, Bug-coreutils X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.1 (-----) On 08/06/10 01:22, Paolo Bonzini wrote: > ISAAC is a RNG, so wouldn't that have the same problem above? You > definitely need to use a hash function, it's just that you do not need a > cryptographic one. I had been thinking of using ISAAC by making the key its seed, and asking it to generate some random values, and then comparing the random values. Any RNG can be used (or abused :-) in this way. I just now tried, that, though, and discovered that on my million line benchmark the MD5 method is about 4 times faster than the ISAAC-based method. So that idea was not a good one. I suppose we could try a non-cryptographic hash function at some point. From debbugs-submit-bounces@debbugs.gnu.org Sun Aug 08 12:43:15 2010 Received: (at submit) by debbugs.gnu.org; 8 Aug 2010 16:43:15 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi8xr-0002VH-B1 for submit@debbugs.gnu.org; Sun, 08 Aug 2010 12:43:15 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi8xp-0002VB-8R for submit@debbugs.gnu.org; Sun, 08 Aug 2010 12:43:10 -0400 Received: from lists.gnu.org ([199.232.76.165]:41541) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1Oi8yW-0000F6-3e for submit@debbugs.gnu.org; Sun, 08 Aug 2010 12:43:52 -0400 Received: from [140.186.70.92] (port=51857 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1Oi8yU-0002fl-Ed for bug-coreutils@gnu.org; Sun, 08 Aug 2010 12:43:57 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_NONE, T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1Oi5uL-0004ZL-2q for bug-coreutils@gnu.org; Sun, 08 Aug 2010 09:27:22 -0400 Received: from mo-p00-ob.rzone.de ([81.169.146.160]:58075) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi5uK-0004SW-RN for bug-coreutils@gnu.org; Sun, 08 Aug 2010 09:27:21 -0400 DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; t=1281273978; l=3420; s=domk; d=haible.de; h=Content-Transfer-Encoding:Content-Type:MIME-Version:In-Reply-To: References:Cc:Date:Subject:To:From:X-RZG-CLASS-ID:X-RZG-AUTH; bh=1XesTVvbjp1L8voJsCu4pq0lNb8=; b=uU8mzfdknSflmbxpde61VVkhuNSzs3evWkO0mJEiUzOqACTbPAafpjJZOYsXx29ejzk 7rTa1svGbVIt3yXYwXKUgWstjKGqCU6lGuCvx94XnQ1TScu69UlTcHFnb0ZZOj95LtRhl DSfq/ZdGPCisPa+6UR9ixMwoi7v2NncisVM= X-RZG-AUTH: :Ln4Re0+Ic/6oZXR1YgKryK8brksyK8dozXDwHXjf9hj/zDNRbvU449Jbdg== X-RZG-CLASS-ID: mo00 Received: from linuix.haible.de (dslb-088-068-073-150.pools.arcor-ip.net [88.68.73.150]) by post.strato.de (mrclete mo45) (RZmta 23.4) with ESMTP id 600304m78CVuKm ; Sun, 8 Aug 2010 15:26:17 +0200 (MEST) From: Bruno Haible To: Simon Josefsson Subject: Re: MD5 is broken Date: Sun, 8 Aug 2010 15:26:15 +0200 User-Agent: KMail/1.9.9 References: <4C58720D.1010002@cs.ucla.edu> <4C59F5F8.9080309@cs.ucla.edu> <8739uurli9.fsf@mocca.josefsson.org> In-Reply-To: <8739uurli9.fsf@mocca.josefsson.org> MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: 7bit Content-Disposition: inline Message-Id: <201008081526.17130.bruno@clisp.org> X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -4.0 (----) X-Debbugs-Envelope-To: submit Cc: Paul Eggert , bug-coreutils@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.3 (-----) Simon Josefsson wrote: > MD5 is broken, and > finding collisions takes just seconds on normal PC. See: > http://en.wikipedia.org/wiki/MD5#Security Here is a suggested patch to improve the awareness of this issue in coreutils. - The documentation of md5sum currently says "modifying a file so as to retain its MD5 [is] considered infeasible at the moment", but the research results of 2008 mentioned in showed how to manipulate a digital certificate so that the validity of its MD5 signature can be retained. - The documentation of md5sum says "For more secure hashes, consider using SHA-1 or SHA-2." Well, researchers have already discovered security weaknesses in , therefore it does not seem adequate to recommend SHA-1 any more. - The 'md5sum --help' output and, with it, the manual page are silent about the security problems. Here is a proposed patch to make this clearer. 2010-08-08 Bruno Haible md5sum: Put more emphasis on security weaknesses. * doc/coreutils.texi (md5sum invocation): Mention currently known security problems. Don't recommend SHA-1 as alternative. * src/md5sum.c (usage): Mention that MD5 is not secure. Recommend SHA-2 as alternative. Reported by Simon Josefsson . --- doc/coreutils.texi.orig Sun Aug 8 15:13:06 2010 +++ doc/coreutils.texi Sun Aug 8 15:10:26 2010 @@ -3414,14 +3414,13 @@ Note: The MD5 digest is more reliable than a simple CRC (provided by the @command{cksum} command) for detecting accidental file corruption, as the chances of accidentally having two files with identical MD5 -are vanishingly small. However, it should not be considered truly -secure against malicious tampering: although finding a file with a -given MD5 fingerprint, or modifying a file so as to retain its MD5 are -considered infeasible at the moment, it is known how to produce -different files with identical MD5 (a ``collision''), something which -can be a security issue in certain contexts. For more secure hashes, -consider using SHA-1 or SHA-2. @xref{sha1sum invocation}, and -@ref{sha2 utilities}. +are vanishingly small. However, it should not be considered secure +against malicious tampering: although finding a file with a given MD5 +fingerprint is considered infeasible at the moment, it is known how +to modify certain files, including digital certificates, so that they +appear valid when signed with an MD5 digest. (See +@url{http://en.wikipedia.org/wiki/MD5#Security} for details.) +For more secure hashes, consider using SHA-2. @xref{sha2 utilities}. If a @var{file} is specified as @samp{-} or if no files are given @command{md5sum} computes the checksum for the standard input. --- src/md5sum.c.orig Sun Aug 8 15:13:06 2010 +++ src/md5sum.c Sun Aug 8 14:48:57 2010 @@ -196,6 +196,15 @@ a line with checksum, a character indicating type (`*' for binary, ` ' for\n\ text), and name for each FILE.\n"), DIGEST_REFERENCE); +#if HASH_ALGO_MD5 + printf (_("\ +\n\ +The MD5 algorithm should not be used any more for security related purposes,\n\ +see <%s>.\n\ +Instead, better use an SHA-2 algorithm, implemented in the programs\n\ +sha224sum, sha256sum, sha384sum, sha512sum.\n"), + "http://en.wikipedia.org/wiki/MD5#Security"); +#endif emit_ancillary_info (); } From debbugs-submit-bounces@debbugs.gnu.org Sun Aug 08 12:46:45 2010 Received: (at submit) by debbugs.gnu.org; 8 Aug 2010 16:46:45 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi91J-0002Xd-9h for submit@debbugs.gnu.org; Sun, 08 Aug 2010 12:46:45 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi91G-0002XX-ME for submit@debbugs.gnu.org; Sun, 08 Aug 2010 12:46:43 -0400 Received: from lists.gnu.org ([199.232.76.165]:46348) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1Oi91x-0000GG-P5 for submit@debbugs.gnu.org; Sun, 08 Aug 2010 12:47:25 -0400 Received: from [140.186.70.92] (port=50929 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1Oi91w-0001oB-Nt for bug-coreutils@gnu.org; Sun, 08 Aug 2010 12:47:31 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_NONE, T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1Oi3CD-0001gC-BX for bug-coreutils@gnu.org; Sun, 08 Aug 2010 06:33:38 -0400 Received: from mo-p00-ob.rzone.de ([81.169.146.162]:27326) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi3CB-0000Om-EP; Sun, 08 Aug 2010 06:33:35 -0400 DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; t=1281263492; l=8755; s=domk; d=haible.de; h=Content-Transfer-Encoding:Content-Type:MIME-Version:In-Reply-To: References:Cc:Date:Subject:To:From:X-RZG-CLASS-ID:X-RZG-AUTH; bh=pMwNFSv9XbgOWIjkKAiVSVw0Euk=; b=qi0W5wqzFpxk6E42YZwe3qpdMs+6ONm6TxwuxVxxc2aOvq4a5ot8cNwDKa0IxgIOViE PdjKLLLu9CJxkkOxKGdYEaTigqr1XXqmGqJPcnKbnJ8I8lxMUtsYk/6VTzSBmnsdsw9kW XEP3M5VTpkzXkdM03jjMkrToIvnFAOHlEMw= X-RZG-AUTH: :Ln4Re0+Ic/6oZXR1YgKryK8brksyK8dozXDwHXjf9hj/zDNRbvU449Jbdg== X-RZG-CLASS-ID: mo00 Received: from linuix.haible.de (dslb-088-068-073-150.pools.arcor-ip.net [88.68.73.150]) by post.strato.de (mrclete mo33) (RZmta 23.4) with ESMTP id c002acm789Delo ; Sun, 8 Aug 2010 12:31:32 +0200 (MEST) From: Bruno Haible To: Paul Eggert Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) Date: Sun, 8 Aug 2010 12:31:29 +0200 User-Agent: KMail/1.9.9 References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> <4C59F5F8.9080309@cs.ucla.edu> In-Reply-To: <4C59F5F8.9080309@cs.ucla.edu> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Content-Disposition: inline Message-Id: <201008081231.31332.bruno@clisp.org> X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -4.4 (----) X-Debbugs-Envelope-To: submit Cc: Bug-coreutils , Bug-gnulib X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.2 (-----) Hi Paul, > (Ooo! Ooo! Performance measurements! I love this stuff!) Me too :-) > It depends on the data. In the typical case, "sort" is applied to > text data, which does not contain NUL bytes. The data in that > benchmark contained many NUL bytes. If you take the same benchmark > and uniformly replace "\0" with "\t" in compare.c, then the situation > is much different: coreutils memxfrm is about 3 times faster than > gnulib memxfrm on the larger test cases Indeed. By changing the compare.c program to try - first, a small string, 3 times, - then, a 40 KB string with \t separators, 3 times, - then, the same string with \0 separators, 3 times, I confirm your timings: Time for gnulib_memxfrm: 0,036002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 0,032002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 0,036003 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 10,9647 Time for coreutils_memxfrm: 3,54422 Time for gnulib_memxfrm: 10,4247 Time for coreutils_memxfrm: 3,54422 Time for gnulib_memxfrm: 10,4407 Time for coreutils_memxfrm: 3,54422 Time for gnulib_memxfrm: 1,98012 Time for coreutils_memxfrm: 3,42021 Time for gnulib_memxfrm: 1,98012 Time for coreutils_memxfrm: 3,41621 Time for gnulib_memxfrm: 1,98412 Time for coreutils_memxfrm: 3,41621 The reason is that gnulib_memxfrm duplicates the allocated memory size, from 4 KB to 8 KB to 16 KB etc., ignoring the expected result size of 108 KB that strxfrm is returned. After this is fixed, I get better timings. > I expect that this performance glitch in gnulib memxfrm could be > improved, as it shouldn't simply double buffer sizes when they're too > small, as at that point it already knows what the final buffer size > should be. Doing this should bring up gnulib memxfrm to be as fast as > coreutils xmemxfrm for this benchmark. Yes: Without strdup: Time for gnulib_memxfrm: 0,036002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 0,036002 Time for coreutils_memxfrm: 0,036003 Time for gnulib_memxfrm: 0,036002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 4,29627 Time for coreutils_memxfrm: 3,55222 Time for gnulib_memxfrm: 3,54422 Time for coreutils_memxfrm: 3,55222 Time for gnulib_memxfrm: 3,54022 Time for coreutils_memxfrm: 3,55222 Time for gnulib_memxfrm: 1,98412 Time for coreutils_memxfrm: 3,42421 Time for gnulib_memxfrm: 1,98412 Time for coreutils_memxfrm: 3,42421 Time for gnulib_memxfrm: 1,98812 Time for coreutils_memxfrm: 3,42021 With strdup: Time for gnulib_memxfrm: 0,036002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 0,032002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 0,036003 Time for coreutils_memxfrm: 0,032002 Time for gnulib_memxfrm: 4,39227 Time for coreutils_memxfrm: 3,54822 Time for gnulib_memxfrm: 3,62823 Time for coreutils_memxfrm: 3,54822 Time for gnulib_memxfrm: 3,64023 Time for coreutils_memxfrm: 3,54822 Time for gnulib_memxfrm: 1,98412 Time for coreutils_memxfrm: 3,41621 Time for gnulib_memxfrm: 1,98012 Time for coreutils_memxfrm: 3,42021 Time for gnulib_memxfrm: 1,98012 Time for coreutils_memxfrm: 3,41621 So, this means that my estimation of the overhead of strdup was incorrect. It is not unnoticeable. In the second of the three cases, it is about 2.5% of the 3.55 seconds. In other words, a malloc + memmove costs about 5% of one strxfrm call. But this means that reducing the average numbers of strxfrm calls from 2 to 1, at the cost of some more malloc, will be a speed-up. This is what I did in the patch below, and now gnulib_memxfrm is consistently the winner: Time for gnulib_memxfrm: 0,036002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 0,032002 Time for coreutils_memxfrm: 0,036002 Time for gnulib_memxfrm: 0,036003 Time for coreutils_memxfrm: 0,032002 Time for gnulib_memxfrm: 2,90418 Time for coreutils_memxfrm: 3,54022 Time for gnulib_memxfrm: 1,97212 Time for coreutils_memxfrm: 3,54022 Time for gnulib_memxfrm: 1,99212 Time for coreutils_memxfrm: 3,54022 Time for gnulib_memxfrm: 1,84011 Time for coreutils_memxfrm: 3,41621 Time for gnulib_memxfrm: 1,82811 Time for coreutils_memxfrm: 3,41621 Time for gnulib_memxfrm: 1,83611 Time for coreutils_memxfrm: 3,41621 > Still, gnulib memxfrm is > problematic, because it insists on managing memory itself. But by doing so it is now 44% faster than the coreutils_memxfrm on the case of long strings, with or without NULs. Starting from a certain complexity, doing malloc as part of the API is a win. Only people who do some kind of embedded systems programming require to be able to do memory allocation statically. For example, GNU libiconv now has a function iconv_open_into, that is like iconv_open without memory allocation. But very very few people need that. Even the most basic functions in libunistring (unistr.in.h: u8_to_u16, u8_to_u32, ..., uniconv.in.h: u8_conv_from_encoding, u8_conv_to_encoding, etc.) rely on implicit dynamic memory allocation. No one has complained about this. > The point > remains, though, that it's confusing that gnulib memxfrm's name begins > with "mem", as the mem* functions don't allocate memory. Would you > consider a patch that renames gnulib memxfrm to amemxfrm, or to some > other such name? No, this is not good. The variant which never allocates memory by itself would be more complex to use and slower on average that gnulib's function. Also, functions like 'strdup', 'putenv', 'setenv', 'scandir', 'fts', all do dynamic memory allocation without having an 'a' in their name to indicate this. 2010-08-08 Bruno Haible memxfrm: Speed up. * lib/memxfrm.c (memxfrm): Allocate enough memory ahead of time, so that usually only one call to strxfrm is necessary for each string part. Reported by Paul Eggert . --- lib/memxfrm.c.orig Sun Aug 8 11:56:19 2010 +++ lib/memxfrm.c Sun Aug 8 11:55:46 2010 @@ -64,12 +64,40 @@ for (;;) { /* Search next NUL byte. */ - const char *q = p + strlen (p); + size_t l = strlen (p); for (;;) { size_t k; + /* A call to strxfrm costs about 20 times more than a call to + strdup of the result. Therefore it is worth to try to avoid + calling strxfrm more than once on a given string, by making + enough room before calling strxfrm. + The size of the strxfrm result, k, is likely to be between + l and 3 * l. */ + if (3 * l >= allocated - length) + { + /* Grow the result buffer. */ + size_t new_allocated; + char *new_result; + + new_allocated = length + 3 * l + 1; + if (new_allocated < 2 * allocated) + new_allocated = 2 * allocated; + if (new_allocated < 64) + new_allocated = 64; + if (result == resultbuf) + new_result = (char *) malloc (new_allocated); + else + new_result = (char *) realloc (result, new_allocated); + if (new_result != NULL) + { + allocated = new_allocated; + result = new_result; + } + } + errno = 0; k = strxfrm (result + length, p, allocated - length); if (errno != 0) @@ -77,17 +105,21 @@ if (k >= allocated - length) { /* Grow the result buffer. */ + size_t new_allocated; char *new_result; - allocated = 2 * allocated; - if (allocated < 64) - allocated = 64; + new_allocated = length + k + 1; + if (new_allocated < 2 * allocated) + new_allocated = 2 * allocated; + if (new_allocated < 64) + new_allocated = 64; if (result == resultbuf) - new_result = (char *) malloc (allocated); + new_result = (char *) malloc (new_allocated); else - new_result = (char *) realloc (result, allocated); + new_result = (char *) realloc (result, new_allocated); if (new_result == NULL) goto out_of_memory_1; + allocated = new_allocated; result = new_result; } else @@ -97,7 +129,7 @@ } } - p = q + 1; + p = p + l + 1; if (p == p_end) break; result[length] = '\0'; @@ -105,12 +137,23 @@ } } - /* Shrink the allocated memory if possible. */ - if (result != resultbuf && (length > 0 ? length : 1) < allocated) + /* Shrink the allocated memory if possible. + It is not worth calling realloc when length + 1 == allocated; it would + save just one byte. */ + if (result != resultbuf && length + 1 < allocated) { - char *memory = (char *) realloc (result, length > 0 ? length : 1); - if (memory != NULL) - result = memory; + if ((length > 0 ? length : 1) <= *lengthp) + { + memcpy (resultbuf, result, length); + free (result); + result = resultbuf; + } + else + { + char *memory = (char *) realloc (result, length > 0 ? length : 1); + if (memory != NULL) + result = memory; + } } s[n] = orig_sentinel; From debbugs-submit-bounces@debbugs.gnu.org Sun Aug 08 13:26:24 2010 Received: (at submit) by debbugs.gnu.org; 8 Aug 2010 17:26:24 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi9da-0002v8-43 for submit@debbugs.gnu.org; Sun, 08 Aug 2010 13:26:24 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi8zP-0002Vv-2z for submit@debbugs.gnu.org; Sun, 08 Aug 2010 12:44:51 -0400 Received: from lists.gnu.org ([199.232.76.165]:39462) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1Oi905-0000FN-VN for submit@debbugs.gnu.org; Sun, 08 Aug 2010 12:45:30 -0400 Received: from [140.186.70.92] (port=51010 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1Oi8zw-0001wL-Sw for bug-coreutils@gnu.org; Sun, 08 Aug 2010 12:45:35 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: **** X-Spam-Status: No, score=4.7 required=5.0 tests=BAYES_50,FRT_PHARMAC, HTML_MESSAGE, HTML_OBFUSCATE_10_20, RCVD_IN_DNSWL_NONE, TVD_FUZZY_SECTOR, T_DKIM_INVALID, T_FRT_CONTACT, T_LOTS_OF_MONEY, T_REMOTE_IMAGE autolearn=no version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1Oi4wn-0003np-ID for bug-coreutils@gnu.org; Sun, 08 Aug 2010 08:25:54 -0400 Received: from mo-p00-ob.rzone.de ([81.169.146.161]:63460) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi4wm-00030g-Mq for bug-coreutils@gnu.org; Sun, 08 Aug 2010 08:25:49 -0400 DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; t=1281270286; l=188025; s=domk; d=haible.de; h=Content-Type:MIME-Version:In-Reply-To:References:Cc:Date:Subject:To: From:X-RZG-CLASS-ID:X-RZG-AUTH; bh=zOnVAWOLHGKAq3GatozfJ5bx3SY=; b=y3BPPC2oNgKYMK8Eeey6+eJW0wicuSOLChKhbEbOltWrWwar379eStB2W7nmH8bwQ77 J20TYatBXGDgyg78dvulDoi7VsduUTTe267K8R70bzLopS2r6FVTj27cUoOfrPluDPCpU OPCcUiiazkkXdY9cTcW4h9Jh2Ssjs5t7E5g= X-RZG-AUTH: :Ln4Re0+Ic/6oZXR1YgKryK8brksyK8dozXDwHXjf9hj/zDNRbvU449Jbdg== X-RZG-CLASS-ID: mo00 Received: from linuix.haible.de (dslb-088-068-073-150.pools.arcor-ip.net [88.68.73.150]) by post.strato.de (mrclete mo12) (RZmta 23.4) with ESMTP id N00257m78ApSNy ; Sun, 8 Aug 2010 14:24:42 +0200 (MEST) From: Bruno Haible To: Paul Eggert Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) Date: Sun, 8 Aug 2010 14:24:40 +0200 User-Agent: KMail/1.9.9 References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> <4C59F5F8.9080309@cs.ucla.edu> In-Reply-To: <4C59F5F8.9080309@cs.ucla.edu> MIME-Version: 1.0 Content-Type: Multipart/Mixed; boundary="Boundary-00=_JIqXMWmPTPMpK10" Message-Id: <201008081424.41509.bruno@clisp.org> X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Debbugs-Envelope-To: submit X-Mailman-Approved-At: Sun, 08 Aug 2010 13:26:16 -0400 Cc: bug-coreutils@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org --Boundary-00=_JIqXMWmPTPMpK10 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Content-Disposition: inline Hi Paul, > I pushed a patch to do that at > . The idea to allocate enough memory before calling strxfrm also gives a speedup in this case. Done through the attached patch. I called 'sort' like this: $ for i in `seq 10`; do time LC_ALL=de_DE.UTF-8 ./sort -R < input100 > output; done where the input100 file contains 100 copies of the attached 2-lines file. Timings before the patch: real 0m9.512s user 0m18.401s sys 0m0.468s real 0m8.871s user 0m17.033s sys 0m0.544s real 0m8.742s user 0m16.777s sys 0m0.472s real 0m8.784s user 0m16.829s sys 0m0.480s real 0m8.657s user 0m16.665s sys 0m0.452s real 0m8.700s user 0m16.737s sys 0m0.484s real 0m8.665s user 0m16.569s sys 0m0.500s real 0m8.826s user 0m16.937s sys 0m0.464s real 0m8.827s user 0m16.985s sys 0m0.428s real 0m8.680s user 0m16.765s sys 0m0.356s Timings with the patch: real 0m5.886s user 0m11.161s sys 0m0.384s real 0m5.137s user 0m9.705s sys 0m0.408s real 0m5.150s user 0m9.753s sys 0m0.404s real 0m5.090s user 0m9.697s sys 0m0.348s real 0m5.158s user 0m9.753s sys 0m0.420s real 0m5.149s user 0m9.825s sys 0m0.360s real 0m5.134s user 0m9.765s sys 0m0.364s real 0m5.080s user 0m9.669s sys 0m0.332s real 0m5.052s user 0m9.625s sys 0m0.336s real 0m5.084s user 0m9.713s sys 0m0.288s Total user time before: 169.698 sec Total user time with the patch: 98.666 sec Speedup: factor 1.72. 2010-08-08 Bruno Haible sort: reduce number of strxfrm calls * src/sort.c (compare_random): Allocate enough memory ahead of time, so that usually only one call to strxfrm is necessary for each string part. *** src/sort.c.orig Sun Aug 8 13:11:01 2010 --- src/sort.c Sun Aug 8 13:10:45 2010 *************** *** 2047,2052 **** --- 2047,2080 ---- /* Store the transformed data into a big-enough buffer. */ + /* A call to strxfrm costs about 20 times more than a call to + strdup of the result. Therefore it is worth to try to avoid + calling strxfrm more than once on a given string, by making + enough room before calling strxfrm. + The size of the strxfrm result of a string of length len is + likely to be between len and 3 * len. */ + if (lena + lenb >= lena && lena + lenb < SIZE_MAX / 3) + { + size_t new_bufsize = 3 * (lena + lenb) + 1; /* no overflow */ + if (new_bufsize > bufsize) + { + if (bufsize < SIZE_MAX / 3 * 2) + { + /* Ensure proportional growth of bufsize. */ + if (new_bufsize < bufsize + bufsize / 2) + new_bufsize = bufsize + bufsize / 2; + } + char *new_buf = malloc (new_bufsize); + if (new_buf != NULL) + { + if (buf != stackbuf) + free (buf); + buf = new_buf; + bufsize = new_bufsize; + } + } + } + size_t sizea = (texta < lima ? xstrxfrm (buf, texta, bufsize) + 1 : 0); bool a_fits = sizea <= bufsize; --Boundary-00=_JIqXMWmPTPMpK10 Content-Type: text/html; charset="utf-8"; name="input" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="input" PGgyPjxzcGFuIGNsYXNzPSJtdy1oZWFkbGluZSIgaWQ9IkxlYmVuIj5MZWJlbjwvc3Bhbj48L2gy Pgk8aDM+PHNwYW4gY2xhc3M9Im13LWhlYWRsaW5lIiBpZD0iV2VyZGVnYW5nIj5XZXJkZWdhbmc8 L3NwYW4+PC9oMz4JPHA+R2Vib3JlbiBhbHMgU29obiB2b24gPGEgaHJlZj0iL3dpa2kvQmFyYmFy YV9CdXNoIiB0aXRsZT0iQmFyYmFyYSBCdXNoIj5CYXJiYXJhIFBpZXJjZSBCdXNoPC9hPiB1bmQg PGEgaHJlZj0iL3dpa2kvR2VvcmdlX0guX1cuX0J1c2giIHRpdGxlPSJHZW9yZ2UgSC4gVy4gQnVz aCI+R2VvcmdlIEguIFcuIEJ1c2g8L2E+IHd1Y2hzIEdlb3JnZSBXLiB6dXNhbW1lbiBtaXQgdmll ciBqw7xuZ2VyZW4gR2VzY2h3aXN0ZXJuIOKAkyA8YSBocmVmPSIvd2lraS9KZWJfQnVzaCIgdGl0 bGU9IkplYiBCdXNoIj5KZWI8L2E+LCA8YSBocmVmPSIvd2lraS9OZWlsX0J1c2giIHRpdGxlPSJO ZWlsIEJ1c2giPk5laWw8L2E+LCA8YSBocmVmPSIvd2lraS9NYXJ2aW5fQnVzaCIgdGl0bGU9Ik1h cnZpbiBCdXNoIj5NYXJ2aW48L2E+IHVuZCBEb3JvdGh5IOKAkyBpbiA8YSBocmVmPSIvd2lraS9N aWRsYW5kXyhUZXhhcykiIHRpdGxlPSJNaWRsYW5kIChUZXhhcykiPk1pZGxhbmQ8L2E+IHVuZCA8 YSBocmVmPSIvd2lraS9Ib3VzdG9uIiB0aXRsZT0iSG91c3RvbiI+SG91c3RvbjwvYT4gYXVmLiBF aW5lIHdlaXRlcmUgasO8bmdlcmUgU2Nod2VzdGVyLCBSb2JpbiwgdmVyc3RhcmIgMTk1MyBkcmVp asOkaHJpZyBhbiA8YSBocmVmPSIvd2lraS9MZXVrJUMzJUE0bWllIiB0aXRsZT0iTGV1a8OkbWll Ij5MZXVrw6RtaWU8L2E+LjwvcD4JPGRpdiBjbGFzcz0idGh1bWIgdHJpZ2h0Ij4JPGRpdiBjbGFz cz0idGh1bWJpbm5lciIgc3R5bGU9IndpZHRoOjIwM3B4OyI+PGEgaHJlZj0iL3cvaW5kZXgucGhw P3RpdGxlPURhdGVpOk1yc2J1c2gtMjAwNjAyMDYuanBnJmFtcDtmaWxldGltZXN0YW1wPTIwMDcw MTIwMTQ1NzI4IiBjbGFzcz0iaW1hZ2UiPjxpbWcgYWx0PSIiIHNyYz0iaHR0cDovL3VwbG9hZC53 aWtpbWVkaWEub3JnL3dpa2lwZWRpYS9jb21tb25zLzYvNmEvTXJzYnVzaC0yMDA2MDIwNi5qcGci IHdpZHRoPSIyMDEiIGhlaWdodD0iMjc1IiBjbGFzcz0idGh1bWJpbWFnZSIgLz48L2E+CTxkaXYg Y2xhc3M9InRodW1iY2FwdGlvbiI+CTxkaXYgY2xhc3M9Im1hZ25pZnkiPjxhIGhyZWY9Ii93L2lu ZGV4LnBocD90aXRsZT1EYXRlaTpNcnNidXNoLTIwMDYwMjA2LmpwZyZhbXA7ZmlsZXRpbWVzdGFt cD0yMDA3MDEyMDE0NTcyOCIgY2xhc3M9ImludGVybmFsIiB0aXRsZT0idmVyZ3LDtsOfZXJuIj48 aW1nIHNyYz0iaHR0cDovL2JpdHMud2lraW1lZGlhLm9yZy9za2lucy0xLjUvY29tbW9uL2ltYWdl cy9tYWduaWZ5LWNsaXAucG5nIiB3aWR0aD0iMTUiIGhlaWdodD0iMTEiIGFsdD0iIiAvPjwvYT48 L2Rpdj4JPGEgaHJlZj0iL3dpa2kvTGF1cmFfQnVzaCIgdGl0bGU9IkxhdXJhIEJ1c2giPkxhdXJh IEJ1c2g8L2E+PC9kaXY+CTwvZGl2Pgk8L2Rpdj4JPHA+QnVzaCBiZXN1Y2h0ZSB2b24gMTk2MSBi aXMgMTk2NCBkaWUgPGEgaHJlZj0iL3dpa2kvUGhpbGxpcHNfQWNhZGVteSIgdGl0bGU9IlBoaWxs aXBzIEFjYWRlbXkiPlBoaWxsaXBzIEFjYWRlbXk8L2E+LCBkaWUgYXVjaCBzZWluIFZhdGVyIGJl c3VjaHQgaGF0dGUuIEFuc2NobGllw59lbmQgc3R1ZGllcnRlIGVyIHZvbiBTZXB0ZW1iZXIgMTk2 NCBiaXMgTWFpIDE5NjggR2VzY2hpY2h0ZSBhbiBkZXIgPGEgaHJlZj0iL3dpa2kvWWFsZV9Vbml2 ZXJzaXR5IiB0aXRsZT0iWWFsZSBVbml2ZXJzaXR5Ij5ZYWxlIFVuaXZlcnNpdHk8L2E+LCB3byBl ciwgZWJlbmZhbGxzIHdpZSBzZWluIFZhdGVyLCBNaXRnbGllZCBkZXIgVmVyZWluaWd1bmcgPGEg aHJlZj0iL3dpa2kvU2t1bGxfJTI2X0JvbmVzIiB0aXRsZT0iU2t1bGwgJmFtcDsgQm9uZXMiPlNr dWxsICZhbXA7IEJvbmVzPC9hPiB1bmQgZGVzIFN0dWRlbnRlbmJ1bmRlcyA8YSBocmVmPSIvd2lr aS9EZWx0YV9LYXBwYV9FcHNpbG9uIiB0aXRsZT0iRGVsdGEgS2FwcGEgRXBzaWxvbiI+RGVsdGEg S2FwcGEgRXBzaWxvbjwvYT4gd2FyLiBJbSBPa3RvYmVyIDE5NjUgd3VyZGUgZXIgZGVzc2VuIFBy w6RzaWRlbnQsIHdpZSB6dXZvciBlYmVuZmFsbHMgc2VpbiBWYXRlci4gMTk2OCBzY2hsb3NzIGVy IHNlaW4gU3R1ZGl1bSBhbiBkZXIgWWFsZS1Vbml2ZXJzaXTDpHQgYWxzIDxhIGhyZWY9Ii93aWtp L0JhY2hlbG9yIiB0aXRsZT0iQmFjaGVsb3IiPkJhY2hlbG9yPC9hPiBpbiBHZXNjaGljaHRlIGFi LiBad2lzY2hlbiAxOTcyIHVuZCAxOTc1IGJlc3VjaHRlIEdlb3JnZSBXLiBCdXNoIGRpZSA8YSBo cmVmPSIvd2lraS9IYXJ2YXJkX0J1c2luZXNzX1NjaG9vbCIgdGl0bGU9IkhhcnZhcmQgQnVzaW5l c3MgU2Nob29sIj5IYXJ2YXJkIEJ1c2luZXNzIFNjaG9vbDwvYT4gZGVyIDxhIGhyZWY9Ii93aWtp L0hhcnZhcmRfVW5pdmVyc2l0eSIgdGl0bGU9IkhhcnZhcmQgVW5pdmVyc2l0eSI+SGFydmFyZCBV bml2ZXJzaXR5PC9hPiwgd28gZXIgZGVuIFRpdGVsIDxhIGhyZWY9Ii93aWtpL01hc3Rlcl9vZl9C dXNpbmVzc19BZG1pbmlzdHJhdGlvbiIgdGl0bGU9Ik1hc3RlciBvZiBCdXNpbmVzcyBBZG1pbmlz dHJhdGlvbiI+TUJBPC9hPiAoTWFzdGVyIG9mIEJ1c2luZXNzIEFkbWluaXN0cmF0aW9uKSBlcndh cmIuIDE5NzcgaGVpcmF0ZXRlIGVyIDxhIGhyZWY9Ii93aWtpL0xhdXJhX0J1c2giIHRpdGxlPSJM YXVyYSBCdXNoIj5MYXVyYSBXZWxjaDwvYT4uIERpZSBad2lsbGluZ3N0w7ZjaHRlciA8YSBocmVm PSIvd2lraS9KZW5uYV9CdXNoIiB0aXRsZT0iSmVubmEgQnVzaCI+SmVubmE8L2E+IHVuZCBCYXJi YXJhIHd1cmRlbiBhbSAyNS4gTm92ZW1iZXIgMTk4MSBnZWJvcmVuLjwvcD4JPGgzPjxzcGFuIGNs YXNzPSJtdy1oZWFkbGluZSIgaWQ9IldlaHJkaWVuc3RfaW5fZGVyX05hdGlvbmFsZ2FyZGUiPldl aHJkaWVuc3QgaW4gZGVyIE5hdGlvbmFsZ2FyZGU8L3NwYW4+PC9oMz4JPHA+QnVzaCB2ZXJwZmxp Y2h0ZXRlIHNpY2ggMTk2OCBmw7xyIHNlY2hzIEphaHJlIGJlaSBkZXIgPGEgaHJlZj0iL3dpa2kv TmF0aW9uYWxnYXJkZV9kZXJfVmVyZWluaWd0ZW5fU3RhYXRlbiIgdGl0bGU9Ik5hdGlvbmFsZ2Fy ZGUgZGVyIFZlcmVpbmlndGVuIFN0YWF0ZW4iPk5hdGlvbmFsZ2FyZGU8L2E+LjxzdXAgaWQ9ImNp dGVfcmVmLTAiIGNsYXNzPSJyZWZlcmVuY2UiPjxhIGhyZWY9IiNjaXRlX25vdGUtMCI+WzFdPC9h Pjwvc3VwPiBCZWkgZGVyIDxhIGhyZWY9Ii93aWtpL0Fpcl9OYXRpb25hbF9HdWFyZCIgdGl0bGU9 IkFpciBOYXRpb25hbCBHdWFyZCI+QWlyIE5hdGlvbmFsIEd1YXJkPC9hPiBpbiBUZXhhcyB3dXJk ZSBlciBMZXV0bmFudCwgUGlsb3QgdW5kIEbDvGhyZXIgZWluZXIgU3RhZmZlbCA8YSBocmVmPSIv d2lraS9Db252YWlyX0YtMTAyIiB0aXRsZT0iQ29udmFpciBGLTEwMiI+Ri0xMDIgPGk+RGVsdGEg RGFnZ2VyczwvaT48L2E+LiBEYSBkaWUgTmF0aW9uYWxnYXJkZSB6dSBkaWVzZXIgWmVpdCB2b3J3 aWVnZW5kIGltIElubGFuZCBlaW5nZXNldHp0IHd1cmRlLCBzYWggc2ljaCBCdXNoIHNww6R0ZXIg bWl0IGRlbSBWb3J3dXJmIGtvbmZyb250aWVydCwgZWluZXIgRWluYmVydWZ1bmcgaW4gZGllIDxp PjxhIGhyZWY9Ii93aWtpL1VuaXRlZF9TdGF0ZXNfQXJteSIgdGl0bGU9IlVuaXRlZCBTdGF0ZXMg QXJteSI+QXJteTwvYT48L2k+IHp1dm9yZ2Vrb21tZW4genUgc2VpbiB1bmQgc2ljaCBkYW1pdCBl aW5lbSBFaW5zYXR6IGluIDxhIGhyZWY9Ii93aWtpL1ZpZXRuYW1rcmllZyIgdGl0bGU9IlZpZXRu YW1rcmllZyI+VmlldG5hbTwvYT4gZW50em9nZW4genUgaGFiZW4gdW5kIHd1cmRlIGRhaGVyIDxp PmRyYWZ0IGRvZGdlcjwvaT4gZ2VzY2hvbHRlbiAo4oCeZWluIHNpY2ggZGVyIEVpbmJlcnVmdW5n IEVudHppZWhlbmRlcuKAnCksIGJlaSBwYXRyaW90aXNjaGVuIEFtZXJpa2FuZXJuIGFsbGVzIGFu ZGVyZSBhbHMgZWluIEVocmVudGl0ZWwuIERpZXMgd2FyIGplZG9jaCBkYW1hbHMgbmljaHQgbnVy IHVudGVyIFBvbGl0aWtlcnPDtmhuZW4gZWluZSBkdXJjaGF1cyB2ZXJicmVpdGV0ZSBQcmF4aXMg KHNlaW4gVmF0ZXIgd2FyIGRhbWFscyA8YSBocmVmPSIvd2lraS9Lb25ncmVzc19kZXJfVmVyZWlu aWd0ZW5fU3RhYXRlbiIgdGl0bGU9IktvbmdyZXNzIGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuIj5L b25ncmVzc2FiZ2VvcmRuZXRlcjwvYT4gaW0gPGEgaHJlZj0iL3dpa2kvUmVwciVDMyVBNHNlbnRh bnRlbmhhdXNfZGVyX1ZlcmVpbmlndGVuX1N0YWF0ZW4iIHRpdGxlPSJSZXByw6RzZW50YW50ZW5o YXVzIGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuIj5SZXByw6RzZW50YW50ZW5oYXVzPC9hPikuIERl ciBWZXJkYWNodCwgQnVzaCBoYWJlIGF1w59lcmRlbSBzZWluZSBzaWNoIGF1cyBkZW0gRGllbnN0 IGluIGRlciBOYXRpb25hbGdhcmRlIGVyZ2ViZW5kZW4gUGZsaWNodGVuIG5pY2h0IGdld2lzc2Vu aGFmdCBlcmbDvGxsdCwgaGF0dGUgZGVzaGFsYiBncsO2w59lcmVzIHBvbGl0aXNjaGVzIEdld2lj aHQuIEF1ZiBEcnVjayBkZXIgw5ZmZmVudGxpY2hrZWl0IGxpZcOfIGVyIGRhaGVyIGltIEZlYnJ1 YXIgMjAwNCBkaWUgQWt0ZW4gw7xiZXIgZGllc2UgWmVpdCBmw7xyIFVudGVyc3VjaHVuZ2VuIGZy ZWlnZWJlbi48L3A+CTxoMz48c3BhbiBjbGFzcz0ibXctaGVhZGxpbmUiIGlkPSJVbnRlcm5laG1l cnQuQzMuQTR0aWdrZWl0Ij5VbnRlcm5laG1lcnTDpHRpZ2tlaXQ8L3NwYW4+PC9oMz4JPHA+U2Vp bmUgVW50ZXJuZWhtZXJ0w6R0aWdrZWl0IGJlZ2FubiBCdXNoIGltIEphaHIgMTk3OCBpbiBkZXIg PGEgaHJlZj0iL3dpa2kvRXJkJUMzJUI2bCIgdGl0bGU9IkVyZMO2bCI+RXJkw7ZsZsO2cmRlcmlu ZHVzdHJpZTwvYT4gbWl0IGRlciBHcsO8bmR1bmcgdm9uIDxpPkFyYnVzdG8gRW5lcmd5PC9pPiAo c3Bhbi4gZsO8ciA8aT5CdXNjaDwvaT4pLCBzcMOkdGVyIGluIDxpPkJ1c2ggRXhwbG9yYXRpb248 L2k+IHVtYmVuYW5udC4gQWxzIEFuZmFuZyBkZXIgMTk4MGVyLUphaHJlIGRpZSA8YSBocmVmPSIv d2lraS8lQzMlOTZscHJlaXMiIHRpdGxlPSLDlmxwcmVpcyI+w5ZscHJlaXNlPC9hPiBlaW5icmFj aGVuLCBnZXJpZXQgZGFzIFVudGVybmVobWVuIGluIFNjaHdpZXJpZ2tlaXRlbiB1bmQgbXVzc3Rl IGltIEphaHIgMTk4NCBtaXQgZGVtIMOWbHVudGVybmVobWVuIDxpPlNwZWN0cnVtIDcgRW5lcmd5 IENvcnAuPC9pPiBmdXNpb25pZXJlbi4gQnVzaCB3dXJkZSBWb3JzaXR6ZW5kZXIgZGVzIFVudGVy bmVobWVucy4gQWxzIGltIEphaHIgMTk4NiBkaWUgw5ZscHJlaXNlIGVybmV1dCBlaW5icmFjaGVu LCB3dXJkZSBlcyBqZWRvY2ggemFobHVuZ3N1bmbDpGhpZyB1bmQgdm9uIDxpPkhhcmtlbiBFbmVy Z3kgQ29ycC48L2k+IGF1Zmdla2F1ZnQuIEJ1c2ggd3VyZGUgZGFkdXJjaCBlaW5lciBkZXIgRGly ZWt0b3JlbiBiZWkgSGFya2VuLjwvcD4JPGgzPjxzcGFuIGNsYXNzPSJtdy1oZWFkbGluZSIgaWQ9 IlJlbGlnaW9zaXQuQzMuQTR0X3VuZF9BbGtvaG9scHJvYmxlbWUiPlJlbGlnaW9zaXTDpHQgdW5k IEFsa29ob2xwcm9ibGVtZTwvc3Bhbj48L2gzPgk8cD5EaWUgUHJvYmxlbWUgQnVzaHMgaW0gVW1n YW5nIG1pdCBBbGtvaG9sIHd1cmRlbiBpbSBKYWhyIDE5NzYgYWt0ZW5rdW5kaWcuIFdlZ2VuIDxh IGhyZWY9Ii93aWtpL1RydW5rZW5oZWl0IiB0aXRsZT0iVHJ1bmtlbmhlaXQiIGNsYXNzPSJtdy1y ZWRpcmVjdCI+VHJ1bmtlbmhlaXQ8L2E+IGFtIFN0ZXVlciB3dXJkZSBpaG0gaW4gPGEgaHJlZj0i L3dpa2kvTWFpbmUiIHRpdGxlPSJNYWluZSI+TWFpbmU8L2E+IGJlZnJpc3RldCBkZXIgRsO8aHJl cnNjaGVpbiBlbnR6b2dlbi4gWnVkZW0gbXVzc3RlIEJ1c2ggc2ljaCBlaW5lbSBzdHJlbmdlbiBF bnR6dWcgdW50ZXJ3ZXJmZW4uIFplaG4gSmFocmUgc3DDpHRlciBrb252ZXJ0aWVydGUgZXIgdm9u IGRlbiA8YSBocmVmPSIvd2lraS9FcGlzY29wYWxfQ2h1cmNoX2luX3RoZV9VU0EiIHRpdGxlPSJF cGlzY29wYWwgQ2h1cmNoIGluIHRoZSBVU0EiIGNsYXNzPSJtdy1yZWRpcmVjdCI+QW5nbGlrYW5l cm48L2E+IHp1IGRlbiA8YSBocmVmPSIvd2lraS9NZXRob2Rpc3Rpc2NoZV91bmRfV2VzbGV5YW5p c2NoZV9LaXJjaGVuIiB0aXRsZT0iTWV0aG9kaXN0aXNjaGUgdW5kIFdlc2xleWFuaXNjaGUgS2ly Y2hlbiI+TWV0aG9kaXN0ZW48L2E+IHVtIGZvcnRhbiBhbHMgPGEgaHJlZj0iL3dpa2kvRXJ3ZWNr dW5nc2Jld2VndW5nIiB0aXRsZT0iRXJ3ZWNrdW5nc2Jld2VndW5nIj5XaWVkZXJnZWJvcmVuZXIg Q2hyaXN0PC9hPiB2w7ZsbGlnIGF1ZiBBbGtvaG9sIHp1IHZlcnppY2h0ZW4uIERpZXNlciBXZWNo c2VsIHNlaW5lciBLb25mZXNzaW9uIGltIEphaHJlIDE5ODYgc3RlbGx0IGVpbmUgZWluc2NobmVp ZGVuZGUgVmVyw6RuZGVydW5nIHNlaW5lcyBQcml2YXRsZWJlbnMgZGFyLjwvcD4JPGgzPjxzcGFu IGNsYXNzPSJtdy1oZWFkbGluZSIgaWQ9IlBvbGl0aXNjaGVfS2FycmllcmUiPlBvbGl0aXNjaGUg S2FycmllcmU8L3NwYW4+PC9oMz4JPHA+MTk4OCB3YXIgR2VvcmdlIFcuIEJ1c2ggTWl0Z2xpZWQg ZGVzIFdhaGxrYW1wZnRlYW1zIHNlaW5lcyBWYXRlcnMgYmVpIGRlc3NlbiBzY2hsaWXDn2xpY2gg Z2V3b25uZW5lciBQcsOkc2lkZW50c2NoYWZ0c3dhaGwuIEFuc2NobGllw59lbmQgZXJ3YXJiIGVy LCBnZW1laW5zYW0gbWl0IG5haGVuIEZyZXVuZGVuIHNlaW5lcyBWYXRlcnMsIGRhcyA8YSBocmVm PSIvd2lraS9CYXNlYmFsbCIgdGl0bGU9IkJhc2ViYWxsIj5CYXNlYmFsbHRlYW08L2E+IDxhIGhy ZWY9Ii93aWtpL1RleGFzX1JhbmdlcnNfKEJhc2ViYWxsKSIgdGl0bGU9IlRleGFzIFJhbmdlcnMg KEJhc2ViYWxsKSI+VGV4YXMgUmFuZ2VyczwvYT4gKHNlaW4gQW50ZWlsIGJldHJ1ZyA1JiMxNjA7 JSkuIEVyIHdhciBiaXMgenUgc2VpbmVyIFdhaGwgenVtIEdvdXZlcm5ldXIgdm9uIDxhIGhyZWY9 Ii93aWtpL1RleGFzIiB0aXRsZT0iVGV4YXMiPlRleGFzPC9hPiAxOTk0IGRlciA8aT5NYW5hZ2lu ZyBQYXJ0bmVyPC9pPiBkZXMgVGVhbXMuIE1pdCBkZW0gVmVya2F1ZiBzZWluZXMgQW50ZWlscyBh biBkZW4gVGV4YXMgUmFuZ2VycyAxOTk4IHZlcmRpZW50ZSBCdXNoIDE1IE1pbGxpb25lbiBEb2xs YXIuPC9wPgk8cD5HZW9yZ2UgVy4gQnVzaCBiZXNpdHp0IGRpZSA8aT48YSBocmVmPSIvdy9pbmRl eC5waHA/dGl0bGU9UHJhaXJpZV9DaGFwZWxfUmFuY2gmYW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRs aW5rPTEiIGNsYXNzPSJuZXciIHRpdGxlPSJQcmFpcmllIENoYXBlbCBSYW5jaCAoU2VpdGUgbmlj aHQgdm9yaGFuZGVuKSI+UHJhaXJpZSBDaGFwZWwgUmFuY2g8L2E+PC9pPiBiZWkgPGEgaHJlZj0i L3dpa2kvQ3Jhd2ZvcmRfKFRleGFzKSIgdGl0bGU9IkNyYXdmb3JkIChUZXhhcykiPkNyYXdmb3Jk PC9hPiBpbiBUZXhhcywgYXVmIGRlciBlciBzZWluZSBGZXJpZW4gdmVyYnJpbmd0IHVuZCBhdWNo IFN0YWF0c2fDpHN0ZSBlbXBmaW5nLiBFciBow6RsdCBzaWNoIGF1w59lcmRlbSBvZnQgaW0gU29t bWVyc2l0eiBzZWluZXMgVmF0ZXJzIDxpPjxhIGhyZWY9Ii93aWtpL0J1c2gtQW53ZXNlbiIgdGl0 bGU9IkJ1c2gtQW53ZXNlbiI+V2Fsa2Vy4oCZcyBQb2ludDwvYT48L2k+IGJlaSA8YSBocmVmPSIv d2lraS9LZW5uZWJ1bmtwb3J0IiB0aXRsZT0iS2VubmVidW5rcG9ydCI+S2VubmVidW5rcG9ydDwv YT4gaW4gPGEgaHJlZj0iL3dpa2kvTWFpbmUiIHRpdGxlPSJNYWluZSI+TWFpbmU8L2E+IGF1Ziwg d28gYXVjaCBTdGFhdHNnw6RzdGUgZW1wZmFuZ2VuIHd1cmRlbi48L3A+CTxoMz48c3BhbiBjbGFz cz0ibXctaGVhZGxpbmUiIGlkPSJHb3V2ZXJuZXVyX3Zvbl9UZXhhcyI+R291dmVybmV1ciB2b24g VGV4YXM8L3NwYW4+PC9oMz4JPHA+RGllIHRleGFuaXNjaGUgR291dmVybmV1cnN3YWhsIGFtIDgu IE5vdmVtYmVyIDE5OTQga29ubnRlIEJ1c2ggZ2VnZW4gZGllIDxhIGhyZWY9Ii93aWtpL0RlbW9r cmF0aXNjaGVfUGFydGVpXyhWZXJlaW5pZ3RlX1N0YWF0ZW4pIiB0aXRsZT0iRGVtb2tyYXRpc2No ZSBQYXJ0ZWkgKFZlcmVpbmlndGUgU3RhYXRlbikiPmRlbW9rcmF0aXNjaGU8L2E+IEFtdHNpbmhh YmVyaW4gPGEgaHJlZj0iL3dpa2kvQW5uX1JpY2hhcmRzIiB0aXRsZT0iQW5uIFJpY2hhcmRzIj5B bm4gUmljaGFyZHM8L2E+IGbDvHIgc2ljaCBlbnRzY2hlaWRlbi4gU2VpbiBXYWhsa2FtcGYgd3Vy ZGUg4oCTIHdpZSBhbGxlIG5hY2hmb2xnZW5kZW4g4oCTIHZvbiA8YSBocmVmPSIvd2lraS9LYXJs X1JvdmUiIHRpdGxlPSJLYXJsIFJvdmUiPkthcmwgUm92ZTwvYT4gZ2VwbGFudC4gVW0gc2VpbmUg UG9zaXRpb24gYXVjaCB1bnRlciBkZW4gZGVtb2tyYXRpc2NoZW4gV8OkaGxlcm4genUgZmVzdGln ZW4sIHNldHp0ZSBCdXNoIGluIHNlaW5lciBlcnN0ZW4gQW10c3plaXQgYXVmIHdlaXRnZWhlbmRl IEtvb3BlcmF0aW9uIG1pdCBkZW0gcG9saXRpc2NoZW4gR2VnbmVyOyBzbyBlcm5hbm50ZSBlciBl aW5lbiBEZW1va3JhdGVuIHp1IHNlaW5lbSBTdGVsbHZlcnRyZXRlciB1bmQgc3TDpHJrdGUgZGll c2VtIGRlbiBSw7xja2VuLCBpbmRlbSBlciBzaWNoIGJlaXNwaWVsc3dlaXNlIGbDvHIgR2VzZXR6 ZXN2b3JoYWJlbiBkZXIgZ2VnbmVyaXNjaGVuIEZyYWt0aW9uIGltIHRleGFuaXNjaGVuIFBhcmxh bWVudCBlaW5zZXR6dGUuPC9wPgk8cD4xOTk4IHd1cmRlIGVyIGFscyB0ZXhhbmlzY2hlciBHb3V2 ZXJuZXVyIHdpZWRlcmdld8OkaGx0LCBzZWluIEdlZ2Vua2FuZGlkYXQgd2FyIDxhIGhyZWY9Ii93 L2luZGV4LnBocD90aXRsZT1HYXJyeV9NYXVybyZhbXA7YWN0aW9uPWVkaXQmYW1wO3JlZGxpbms9 MSIgY2xhc3M9Im5ldyIgdGl0bGU9IkdhcnJ5IE1hdXJvIChTZWl0ZSBuaWNodCB2b3JoYW5kZW4p Ij5HYXJyeSBNYXVybzwvYT4uIEJ1c2ggd2FyIGRlciBlcnN0ZSBHb3V2ZXJuZXVyIGluIGRlciB0 ZXhhbmlzY2hlbiBHZXNjaGljaHRlLCBkZW0gZGllIFdpZWRlcndhaGwgZ2VsYW5nLjwvcD4JPHA+ SW4gc2VpbmVyIEFtdHN6ZWl0IHdhciBCdXNoIGVpbiBlbnRzY2hpZWRlbmVyIEJlZsO8cndvcnRl ciBkZXIgPGEgaHJlZj0iL3dpa2kvVG9kZXNzdHJhZmVfaW5fZGVuX1ZlcmVpbmlndGVuX1N0YWF0 ZW4iIHRpdGxlPSJUb2Rlc3N0cmFmZSBpbiBkZW4gVmVyZWluaWd0ZW4gU3RhYXRlbiI+VG9kZXNz dHJhZmU8L2E+OiAxNTIgenVtIFRvZGUgVmVydXJ0ZWlsdGVuIHZlcndlaWdlcnRlIGVyIHfDpGhy ZW5kIHNlaW5lciBBbXRzemVpdCBkaWUgPGEgaHJlZj0iL3dpa2kvR25hZGVucmVjaHQiIHRpdGxl PSJHbmFkZW5yZWNodCIgY2xhc3M9Im13LXJlZGlyZWN0Ij5CZWduYWRpZ3VuZzwvYT4uIERpZXNl ciBVbXN0YW5kIGbDvGhydGUgYmVpIGRlbiBHZWduZXJuIGRlciBUb2Rlc3N0cmFmZSBpbSBJbi0g dW5kIEF1c2xhbmQgd2llZGVyaG9sdCB6dSBzY2hhcmZlciBLcml0aWsuPC9wPgk8aDM+PHNwYW4g Y2xhc3M9Im13LWhlYWRsaW5lIiBpZD0iRGVyX1dhaGxrYW1wZl8yMDAwIj5EZXIgV2FobGthbXBm IDIwMDA8L3NwYW4+PC9oMz4JPHA+SW0gSmFociAyMDAwIHd1cmRlIEJ1c2ggenVtIFByw6RzaWRl bnRzY2hhZnRza2FuZGlkYXRlbiBkZXIgUmVwdWJsaWthbmVyIDxhIGhyZWY9Ii93aWtpL05vbWlu aWVydW5nc3BhcnRlaXRhZ18oVmVyZWluaWd0ZV9TdGFhdGVuKSIgdGl0bGU9Ik5vbWluaWVydW5n c3BhcnRlaXRhZyAoVmVyZWluaWd0ZSBTdGFhdGVuKSI+bm9taW5pZXJ0PC9hPiB1bmQgdHJhdCB1 bnRlciBkZW0gTW90dG8gdm9tIOKAnm1pdGbDvGhsZW5kZW4gS29uc2VydmF0aXNtdXPigJwgKDxp PmNvbXBhc3Npb25hdGUgY29uc2VydmF0aXNtPC9pPikgbWl0IDxhIGhyZWY9Ii93aWtpL0RpY2tf Q2hlbmV5IiB0aXRsZT0iRGljayBDaGVuZXkiPkRpY2sgQ2hlbmV5PC9hPiBnZWdlbiBkZW4gS2Fu ZGlkYXRlbiBkZXIgRGVtb2tyYXRlbiB1bmQgZGFtYWxpZ2VuIFZpemVwcsOkc2lkZW50ZW4gPGEg aHJlZj0iL3dpa2kvQWxfR29yZSIgdGl0bGU9IkFsIEdvcmUiPkFsIEdvcmU8L2E+IHNvd2llIGdl Z2VuIGRlbiB2b24gZGVuIDxhIGhyZWY9Ii93aWtpL0dyZWVuX1BhcnR5XyhWZXJlaW5pZ3RlX1N0 YWF0ZW4pIiB0aXRsZT0iR3JlZW4gUGFydHkgKFZlcmVpbmlndGUgU3RhYXRlbikiPkdyw7xuZW48 L2E+IG5vbWluaWVydGVuIChpbnRlcm5hdGlvbmFsIGFscyBWZXJicmF1Y2hlcnNjaHV0emFud2Fs dCBiZWthbm50ZW4pIDxhIGhyZWY9Ii93aWtpL1JhbHBoX05hZGVyIiB0aXRsZT0iUmFscGggTmFk ZXIiPlJhbHBoIE5hZGVyPC9hPiBhbi4gRGllIEVudHNjaGVpZHVuZyB3dXJkZSBlaW4gaGFydGVz IEtvcGYtYW4tS29wZi1SZW5uZW4gendpc2NoZW4gZGVuIGJlaWRlbiBIYXVwdGthbmRpZGF0ZW4g QnVzaCB1bmQgR29yZSwgc28gZGFzcyBkaWUgRW50c2NoZWlkdW5nIHNjaGxpZcOfbGljaCBudXIg bm9jaCB2b20gRXJnZWJuaXMgaW0gQnVuZGVzc3RhYXQgPGEgaHJlZj0iL3dpa2kvRmxvcmlkYSIg dGl0bGU9IkZsb3JpZGEiPkZsb3JpZGE8L2E+IGFiaGluZy48L3A+CTxwPkRpZSBFcmdlYm5pc3Nl IGluIEZsb3JpZGEgd2FyZW4gaW4gaWhyZXIgQXVzesOkaGx1bmcgamVkb2NoIMO8YmVyYXVzIHVt c3RyaXR0ZW4sIHdhcyBkaWUgVmVyZWluaWd0ZW4gU3RhYXRlbiBiaXMgYW4gZGVuIFJhbmQgZWlu ZXIgU3RhYXRza3Jpc2UgZsO8aHJ0ZS4gRXJzdCBlaW4gVXJ0ZWlsIGRlcyA8YSBocmVmPSIvd2lr aS9PYmVyc3Rlcl9HZXJpY2h0c2hvZl9kZXJfVmVyZWluaWd0ZW5fU3RhYXRlbiIgdGl0bGU9Ik9i ZXJzdGVyIEdlcmljaHRzaG9mIGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuIj5TdXByZW1lIENvdXJ0 PC9hPiBiZWVuZGV0ZSBzY2hsaWXDn2xpY2ggZGllIGxhdWZlbmRlbiBOZXVhdXN6w6RobHVuZ2Vu IGRlciBTdGltbWVuLiBEYXMgR2VyaWNodCBlcmtsw6RydGUgZGllIHZvbiBGbG9yaWRhcyBTdGFh dHNnZXJpY2h0IGdlZm9yZGVydGUgKHVuZCB2b24gQWwgR29yZSB2ZXJsYW5ndGUpIE5ldWF1c3rD pGhsdW5nIGRlciBTdGltbWVuIGbDvHIgdmVyZmFzc3VuZ3N3aWRyaWcsIHdlaWwgdW5vcmRlbnRs aWNoIHVuZCBpbiBkZW4gdmVyc2NoaWVkZW5lbiBEaXN0cmlrdGVuIGRlcyBCdW5kZXNzdGFhdGVz IHVuZWluaGVpdGxpY2ggb3JnYW5pc2llcnQuIEVpbmUgdmVyZmFzc3VuZ3NnZW3DpMOfZSBOZXVh dXN6w6RobHVuZyBzZWkgYWJlciBuaWNodCBtZWhyIGlubmVyaGFsYiBkZXIgdm9yZ2VzZWhlbmVu IEZyaXN0IHp1IGdld8OkaHJsZWlzdGVuLCBkZXNoYWxiIHNlaSBqZWdsaWNoZSBOZXVhdXN6w6Ro bHVuZyB6dSBzdG9wcGVuLiBTb21pdCB3dXJkZSBkaWUgZXJzdGUgU3RpbW1lbnrDpGhsdW5nLCBi ZWkgZGVyIEdlb3JnZSBXLiBCdXNoIGtuYXBwIGbDvGhydGUsIGF1dG9tYXRpc2NoIGJlc3TDpHRp Z3QuIERpZXNlIEVudHNjaGVpZHVuZyBmaWVsIG1pdCBkZXIgZGVua2JhciBrbmFwcHN0ZW4gTWVo cmhlaXQgdm9uIGbDvG5mIHp1IHZpZXIgUmljaHRlcnN0aW1tZW4uIFZvbiBkZXIgTWluZGVyaGVp dCBzdGltbXRlbiB6d2VpIFJpY2h0ZXIgZGFmw7xyLCBkaWUgTmV1YXVzesOkaGx1bmcgd2llIGJl Z29ubmVuIHdlaXRlcmxhdWZlbiB6dSBsYXNzZW47IHp3ZWkgdGVpbHRlbiB6d2FyIGRpZSBNZWhy aGVpdHNtZWludW5nIGRhaGluZ2VoZW5kLCBkYXNzIGRpZSBsYXVmZW5kZSBOZXVhdXN6w6RobHVu ZyBuaWNodCBrb3JyZWt0IGFibGF1ZmUsIHdvbGx0ZW4gYWJlciBkZW4gRmFsbCBhbiBkYXMgb2Jl cnN0ZSBHZXJpY2h0IHZvbiBGbG9yaWRhIHp1csO8Y2t2ZXJ3ZWlzZW4sIGRhcyBlaW5oZWl0bGlj aGUgU3RhbmRhcmRzIGZlc3RsZWdlbiBzb2xsdGUsIG5hY2ggZGVuZW4gZGFubiBhbGxlIFN0aW1t ZW4gZXJuZXV0IGdlesOkaGx0IHdlcmRlbiBzb2xsdGVuLCBnZWdlYmVuZW5mYWxscyBhdWNoIG1p dCBWZXJsw6RuZ2VydW5nIGRlciBGcmlzdC48L3A+CTxwPkJ1c2ggZXJoaWVsdCBpbnNnZXNhbXQg ZXR3YSA1MDAuMDAwIFfDpGhsZXJzdGltbWVuIHdlbmlnZXIgYWxzIEdvcmUsIGtvbm50ZSBhYmVy IG1laHIgPGEgaHJlZj0iL3dpa2kvRWxlY3RvcmFsX0NvbGxlZ2UiIHRpdGxlPSJFbGVjdG9yYWwg Q29sbGVnZSI+V2FobG3DpG5uZXJzdGltbWVuPC9hPiBhdWYgc2ljaCB2ZXJlaW5pZ2VuLCB3YXMg YmVpIGRlciBpbmRpcmVrdGVuIFByw6RzaWRlbnRlbndhaGwgaW4gZGVuIFZlcmVpbmlndGVuIFN0 YWF0ZW4gYXVzc2NobGFnZ2ViZW5kIGlzdC48L3A+CTxoMj48c3BhbiBjbGFzcz0ibXctaGVhZGxp bmUiIGlkPSJQci5DMy5BNHNpZGVudHNjaGFmdCI+UHLDpHNpZGVudHNjaGFmdDwvc3Bhbj48L2gy Pgk8aDM+PHNwYW4gY2xhc3M9Im13LWhlYWRsaW5lIiBpZD0iRXJzdGVfQW10c3plaXRfYWxzX1By LkMzLkE0c2lkZW50Ij5FcnN0ZSBBbXRzemVpdCBhbHMgUHLDpHNpZGVudDwvc3Bhbj48L2gzPgk8 ZGl2IGNsYXNzPSJ0aHVtYiB0bGVmdCI+CTxkaXYgY2xhc3M9InRodW1iaW5uZXIiIHN0eWxlPSJ3 aWR0aDozMzJweDsiPjxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1EYXRlaTpCdXNoX2FuZF9T Y2hyJUMzJUI2ZGVyLmpwZyZhbXA7ZmlsZXRpbWVzdGFtcD0yMDA1MTEyMDA5NDAyOSIgY2xhc3M9 ImltYWdlIj48aW1nIGFsdD0iIiBzcmM9Imh0dHA6Ly91cGxvYWQud2lraW1lZGlhLm9yZy93aWtp cGVkaWEvY29tbW9ucy90aHVtYi9iL2I3L0J1c2hfYW5kX1NjaHIlQzMlQjZkZXIuanBnLzMzMHB4 LUJ1c2hfYW5kX1NjaHIlQzMlQjZkZXIuanBnIiB3aWR0aD0iMzMwIiBoZWlnaHQ9IjIyNSIgY2xh c3M9InRodW1iaW1hZ2UiIC8+PC9hPgk8ZGl2IGNsYXNzPSJ0aHVtYmNhcHRpb24iPgk8ZGl2IGNs YXNzPSJtYWduaWZ5Ij48YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9RGF0ZWk6QnVzaF9hbmRf U2NociVDMyVCNmRlci5qcGcmYW1wO2ZpbGV0aW1lc3RhbXA9MjAwNTExMjAwOTQwMjkiIGNsYXNz PSJpbnRlcm5hbCIgdGl0bGU9InZlcmdyw7bDn2VybiI+PGltZyBzcmM9Imh0dHA6Ly9iaXRzLndp a2ltZWRpYS5vcmcvc2tpbnMtMS41L2NvbW1vbi9pbWFnZXMvbWFnbmlmeS1jbGlwLnBuZyIgd2lk dGg9IjE1IiBoZWlnaHQ9IjExIiBhbHQ9IiIgLz48L2E+PC9kaXY+CTxhIGhyZWY9Ii93aWtpL0dl cmhhcmRfU2NociVDMyVCNmRlciIgdGl0bGU9IkdlcmhhcmQgU2NocsO2ZGVyIj5HZXJoYXJkIFNj aHLDtmRlcjwvYT4genVzYW1tZW4gbWl0IEJ1c2ggaW0gPGEgaHJlZj0iL3dpa2kvV2VpJUMzJTlG ZXNfSGF1cyIgdGl0bGU9IldlacOfZXMgSGF1cyI+V2Vpw59lbiBIYXVzPC9hPiAoMjAwMSk8L2Rp dj4JPC9kaXY+CTwvZGl2Pgk8cD5BbSAyMC4gSmFudWFyIDIwMDEgd3VyZGUgQnVzaCB2ZXJlaWRp Z3QuIEVyIHd1cmRlIGRhbWl0IGRlciB6d2VpdGUgUHLDpHNpZGVudCBpbiBkZXIgR2VzY2hpY2h0 ZSBkZXIgVmVyZWluaWd0ZW4gU3RhYXRlbiwgZGVzc2VuIFZhdGVyIGViZW5mYWxscyBQcsOkc2lk ZW50IGdld2VzZW4gd2FyIOKAkyBkaWVzZSBLb25zdGVsbGF0aW9uIHRyYWYgenV2b3IgbnVyIGF1 ZiBkZW4gc2VjaHN0ZW4gUHLDpHNpZGVudGVuLCA8YSBocmVmPSIvd2lraS9Kb2huX1F1aW5jeV9B ZGFtcyIgdGl0bGU9IkpvaG4gUXVpbmN5IEFkYW1zIj5Kb2huIFF1aW5jeSBBZGFtczwvYT4sIHp1 LCBkZXNzZW4gVmF0ZXIgPGEgaHJlZj0iL3dpa2kvSm9obl9BZGFtcyIgdGl0bGU9IkpvaG4gQWRh bXMiPkpvaG4gQWRhbXM8L2E+IGRlciB6d2VpdGUgUHLDpHNpZGVudCBnZXdlc2VuIHdhci4gR2Vv cmdlIFcuIEJ1c2ggaXN0IGF1Y2ggZGVyIGVyc3RlIFByw6RzaWRlbnQgbWl0IGVpbmVtIDxhIGhy ZWY9Ii93aWtpL01hc3Rlcl9vZl9CdXNpbmVzc19BZG1pbmlzdHJhdGlvbiIgdGl0bGU9Ik1hc3Rl ciBvZiBCdXNpbmVzcyBBZG1pbmlzdHJhdGlvbiI+TUJBPC9hPi1UaXRlbC48L3A+CTxwPk1pdCBC dXNoIHpvZ2VuIHZpZWxlIFJlcHVibGlrYW5lciB3aWVkZXIgaW5zIFdlacOfZSBIYXVzIGVpbiwg ZGllIHNjaG9uIHVudGVyIHNlaW5lbSBWYXRlciB3aWNodGlnZSDDhG10ZXIgaW5uZWdlaGFidCBo YXR0ZW4sIGluc2Jlc29uZGVyZSBSaWNoYXJkIENoZW5leSBhbHMgVml6ZXByw6RzaWRlbnQgdW5k IDxhIGhyZWY9Ii93aWtpL0RvbmFsZF9SdW1zZmVsZCIgdGl0bGU9IkRvbmFsZCBSdW1zZmVsZCI+ RG9uYWxkIFJ1bXNmZWxkPC9hPiBhbHMgVmVydGVpZGlndW5nc21pbmlzdGVyLiBBdcOfZW5taW5p c3RlciB3dXJkZSBkZXIgZnLDvGhlcmUgR29sZmtyaWVnc2dlbmVyYWwgPGEgaHJlZj0iL3dpa2kv Q29saW5fUG93ZWxsIiB0aXRsZT0iQ29saW4gUG93ZWxsIj5Db2xpbiBQb3dlbGw8L2E+LiBEaWUg d2ljaHRpZ3N0ZW4gQmVyYXRlciB3YXJlbiB3ZWl0ZXJoaW4gPGEgaHJlZj0iL3dpa2kvS2FybF9S b3ZlIiB0aXRsZT0iS2FybCBSb3ZlIj5LYXJsIFJvdmU8L2E+IHVuZCDigJMgYWxzIFNpY2hlcmhl aXRzYmVyYXRlcmluIOKAkyA8YSBocmVmPSIvd2lraS9Db25kb2xlZXp6YV9SaWNlIiB0aXRsZT0i Q29uZG9sZWV6emEgUmljZSI+Q29uZG9sZWV6emEgUmljZTwvYT4uIFZpZWxlIGRlciBuZXVlbiBN aXRhcmJlaXRlciBkZXIgPGEgaHJlZj0iL3dpa2kvQnVzaC1SZWdpZXJ1bmciIHRpdGxlPSJCdXNo LVJlZ2llcnVuZyIgY2xhc3M9Im13LXJlZGlyZWN0Ij5CdXNoLVJlZ2llcnVuZzwvYT4gd2FyZW4g dm9yaGVyIE1pdGdsaWVkZXIgZGVyIDxhIGhyZWY9Ii93aWtpL05lb2tvbnNlcnZhdGlzbXVzIiB0 aXRsZT0iTmVva29uc2VydmF0aXNtdXMiPm5lb2tvbnNlcnZhdGl2ZW48L2E+IERlbmtmYWJyaWsg PGk+PGEgaHJlZj0iL3dpa2kvUHJvamVjdF9mb3JfdGhlX05ld19BbWVyaWNhbl9DZW50dXJ5IiB0 aXRsZT0iUHJvamVjdCBmb3IgdGhlIE5ldyBBbWVyaWNhbiBDZW50dXJ5Ij5Qcm9qZWN0IGZvciB0 aGUgTmV3IEFtZXJpY2FuIENlbnR1cnk8L2E+PC9pPiwgZXR3YSA8YSBocmVmPSIvd2lraS9SaWNo YXJkX1BlcmxlIiB0aXRsZT0iUmljaGFyZCBQZXJsZSI+UmljaGFyZCBQZXJsZTwvYT4sIDxhIGhy ZWY9Ii93aWtpL1JpY2hhcmRfQXJtaXRhZ2UiIHRpdGxlPSJSaWNoYXJkIEFybWl0YWdlIj5SaWNo YXJkIEFybWl0YWdlPC9hPiwgPGEgaHJlZj0iL3dpa2kvUGF1bF9Xb2xmb3dpdHoiIHRpdGxlPSJQ YXVsIFdvbGZvd2l0eiI+UGF1bCBXb2xmb3dpdHo8L2E+IG9kZXIgPGEgaHJlZj0iL3dpa2kvTGV3 aXNfTGliYnkiIHRpdGxlPSJMZXdpcyBMaWJieSI+TGV3aXMgTGliYnk8L2E+LjwvcD4JPHA+V2ll IGluIHNlaW5lciBaZWl0IGFscyB0ZXhhbmlzY2hlciBHb3V2ZXJuZXVyIGvDvG5kaWd0ZSBHZW9y Z2UgVy4gQnVzaCBhdWNoIHp1IEJlZ2lubiBzZWluZXIgZXJzdGVuIEFtdHN6ZWl0IGVpbiBtw7Zn bGljaHN0IGVpbnZlcm5laG1saWNoZXMsIHp1bWluZGVzdCBhYmdlc3RpbW10ZXMgSGFuZGVsbiBt aXQgZGVtIHBvbGl0aXNjaGVuIEdlZ25lciBhbi4gQWxzIFNjaHdlcnB1bmt0ZSBiZW5hbm50ZSBl ciBlaW5lIFZlcmJlc3NlcnVuZyBkZXMgQmlsZHVuZ3N3ZXNlbnMsIFN0ZXVlcnNlbmt1bmdlbiwg UmVjaGVuc2NoYWZ0c3BmbGljaHRlbiBwb2xpdGlzY2hlciBBa3RldXJlIGdlZ2Vuw7xiZXIgZGVt IFZvbGssIFN0w6Rya3VuZyBkZXMgTWlsaXTDpHJzIHVuZCBTY2hhZmZ1bmcgdm9uIE3DtmdsaWNo a2VpdGVuIGbDvHIgQXJiZWl0ZXIsIFRlaWxlIGRlciBTb3ppYWx2ZXJzaWNoZXJ1bmdzYmVpdHLD pGdlIHByaXZhdCB6dSBpbnZlc3RpZXJlbi4gV2ljaHRpZ2VyIFBhcnRuZXIgYmVpIGRlciBBcmJl aXQgbWl0IGRlbSBTZW5hdCB3dXJkZSBmw7xyIEJ1c2ggZGVyIERlbW9rcmF0IDxhIGhyZWY9Ii93 aWtpL0Vkd2FyZF9LZW5uZWR5IiB0aXRsZT0iRWR3YXJkIEtlbm5lZHkiPkVkd2FyZCBLZW5uZWR5 PC9hPi48L3A+CTxwPkRlciBUb24gendpc2NoZW4gYmVpZGVuIFBhcnRlaWVuIHZlcnNjaMOkcmZ0 ZSBzaWNoIGplZG9jaCBpbSBTb21tZXIgMjAwMSBkdXJjaCBkZW4gV2VjaHNlbCBlaW5lcyByZXB1 Ymxpa2FuaXNjaGVuIFNlbmF0b3JzIHp1IGRlbiBEZW1va3JhdGVuLCB3YXMgenUgZWluZW0gVmVy bHVzdCBkZXIgcmVwdWJsaWthbmlzY2hlbiBTZW5hdHNtZWhyaGVpdCBmw7xocnRlIHVuZCB2b24g emFobHJlaWNoZW4gUmVwdWJsaWthbmVybiBhbHMgVmVydHJhdWVuc2JydWNoIGFuZ2VzZWhlbiB3 dXJkZS48L3A+CTxwPldpY2h0aWdzdGUgR2VzZXR6ZXNwcm9qZWt0ZSBiaXMgenVtIDxhIGhyZWY9 Ii93aWtpL1RlcnJvcmFuc2NobCVDMyVBNGdlX2FtXzExLl9TZXB0ZW1iZXJfMjAwMSIgdGl0bGU9 IlRlcnJvcmFuc2NobMOkZ2UgYW0gMTEuIFNlcHRlbWJlciAyMDAxIj4xMS4gU2VwdGVtYmVyIDIw MDE8L2E+IChkZW0gVGFnIGRlciBUZXJyb3JhbnNjaGzDpGdlIGF1ZiBkaWUgWndpbGxpbmdzdMO8 cm1lIGRlcyA8YSBocmVmPSIvd2lraS9Xb3JsZF9UcmFkZV9DZW50ZXIiIHRpdGxlPSJXb3JsZCBU cmFkZSBDZW50ZXIiPldvcmxkIFRyYWRlIENlbnRlcnM8L2E+LCBiZWthbm50IGFscyA5LzExKSB3 YXJlbiBlaW4gUHJvZ3JhbW0genVyIG1hc3NpdmVuIFNlbmt1bmcgZGVyIFN0ZXVlcm4gdW5kIGRp ZSBSZWZvcm0gZGVzIEJpbGR1bmdzd2VzZW5zLiBCZWlkZSB3dXJkZW4gdm9tIEtvbmdyZXNzIGFu Z2Vub21tZW4uIERlciBzb2dlbmFubnRlIDxpPjxhIGhyZWY9Ii93aWtpL05vX0NoaWxkX0xlZnRf QmVoaW5kX0FjdCIgdGl0bGU9Ik5vIENoaWxkIExlZnQgQmVoaW5kIEFjdCI+Tm8gQ2hpbGQgTGVm dCBCZWhpbmQgQWN0PC9hPjwvaT4gKEtlaW4gS2luZCBzb2xsIHp1csO8Y2tibGVpYmVuKSwgZGVy IGRpZSBRdWFsaXTDpHQgZGVzIMO2ZmZlbnRsaWNoZW4gU2NodWx3ZXNlbnMsIGplZG9jaCBhdWNo IGRlbiBadWdyaWZmIGRlcyBNaWxpdMOkcnMgYXVmIFBlcnNvbmFsaWVuIGRlciBTY2jDvGxlciB6 dW0gWndlY2sgZWluZXIgUmVrcnV0aWVydW5nIHZlcmJlc3Nlcm4gc29sbHRlLCB0cmF0IGltIEph bnVhciAyMDAyIGluIEtyYWZ0LjwvcD4JPHA+SW0gTcOkcnogMjAwMSB3dXJkZSBkZXIgZW5kZ8O8 bHRpZ2UgQXVzc3RpZWcgZGVyIFZlcmVpbmlndGVuIFN0YWF0ZW4gYXVzIGRlbSA8YSBocmVmPSIv d2lraS9LeW90by1Qcm90b2tvbGwiIHRpdGxlPSJLeW90by1Qcm90b2tvbGwiPkt5b3RvLUFia29t bWVuPC9hPiB6dXIgUmVkdXppZXJ1bmcgZGVyIDxhIGhyZWY9Ii93aWtpL1RyZWliaGF1c2dhcyIg dGl0bGU9IlRyZWliaGF1c2dhcyI+VHJlaWJoYXVzZ2FzZTwvYT4gdmVya8O8bmRldC4gRGllc2Vy IFNjaHJpdHQgc3RpZcOfIGltIEluLSB1bmQgQXVzbGFuZCBhdWYgc2NoYXJmZSBLcml0aWsuIElu IGRlciBLb250cm92ZXJzZSB1bSA8YSBocmVmPSIvd2lraS9FcmQlQzMlQjZsZiVDMyVCNnJkZXJ1 bmciIHRpdGxlPSJFcmTDtmxmw7ZyZGVydW5nIiBjbGFzcz0ibXctcmVkaXJlY3QiPsOWbGJvaHJ1 bmdlbjwvYT4gaW0gPGEgaHJlZj0iL3dpa2kvQXJjdGljX05hdGlvbmFsX1dpbGRsaWZlX1JlZnVn ZSIgdGl0bGU9IkFyY3RpYyBOYXRpb25hbCBXaWxkbGlmZSBSZWZ1Z2UiPkFyY3RpYyBOYXRpb25h bCBXaWxkbGlmZSBSZWZ1Z2U8L2E+IGRyw6RuZ3RlIGRpZSBSZWdpZXJ1bmcgQnVzaCBhdWYgZWlu ZSBBdWZoZWJ1bmcgZGVzIGRvcnQgYmVzdGVoZW5kZW4gRsO2cmRlcnZlcmJvdGVzIGbDvHIgRXJk w7ZsLjxzdXAgaWQ9ImNpdGVfcmVmLTEiIGNsYXNzPSJyZWZlcmVuY2UiPjxhIGhyZWY9IiNjaXRl X25vdGUtMSI+WzJdPC9hPjwvc3VwPiBJbSBBdWd1c3QgMjAwMSDDpG5kZXJ0ZSBHZW9yZ2UgVy4g QnVzaCBzZWluZSBIYWx0dW5nIGluIGRlciA8YSBocmVmPSIvd2lraS9CaW9ldGhpayIgdGl0bGU9 IkJpb2V0aGlrIj5CaW9ldGhpay1EZWJhdHRlPC9hPiwgaW5kZW0gZXIgc2ljaCBmw7xyIGRpZSDi gJMgd2VubiBhdWNoIGVpbmdlc2NocsOkbmt0ZSDigJMgRsO2cmRlcnVuZyBkZXIgPGEgaHJlZj0i L3dpa2kvU3RhbW16ZWxsZSIgdGl0bGU9IlN0YW1temVsbGUiPmVtYnJ5b25hbGVuIFN0YW1temVs bGVuZm9yc2NodW5nPC9hPiBlbnRzY2hpZWQuPC9wPgk8cD5JbiBkZW4gZXJzdGVuIE1vbmF0ZW4g c2VpbmVyIFByw6RzaWRlbnRzY2hhZnQgd2FyIEJ1c2ggaW5zZ2VzYW10IHJlbGF0aXYgdW5hdWZm w6RsbGlnLCBlciB2ZXJicmFjaHRlIHNlaHIgdmllbCBaZWl0IGF1ZiBzZWluZXIgUmFuY2ggaW4g VGV4YXMsIHdhcyBpaG0gZGVuIFJ1ZiBlaW5lcyDigJ5UZWlsemVpdHByw6RzaWRlbnRlbuKAnCBl aW5oYW5kZWx0ZS48L3A+CTxoND48c3BhbiBjbGFzcz0ibXctaGVhZGxpbmUiIGlkPSJBdS5DMy45 RmVucG9saXRpa19uYWNoX2RlbV8xMS5fU2VwdGVtYmVyXzIwMDEiPkF1w59lbnBvbGl0aWsgbmFj aCBkZW0gMTEuIFNlcHRlbWJlciAyMDAxPC9zcGFuPjwvaDQ+CTxkaXYgY2xhc3M9InRodW1iIHRy aWdodCI+CTxkaXYgY2xhc3M9InRodW1iaW5uZXIiIHN0eWxlPSJ3aWR0aDozMTJweDsiPjxhIGhy ZWY9Ii93L2luZGV4LnBocD90aXRsZT1EYXRlaTpCdXNoX2F0X01vdW50X1J1c2htb3JlLmpwZyZh bXA7ZmlsZXRpbWVzdGFtcD0yMDA3MTIyMzIyMDYwOSIgY2xhc3M9ImltYWdlIj48aW1nIGFsdD0i IiBzcmM9Imh0dHA6Ly91cGxvYWQud2lraW1lZGlhLm9yZy93aWtpcGVkaWEvY29tbW9ucy90aHVt Yi9hL2EzL0J1c2hfYXRfTW91bnRfUnVzaG1vcmUuanBnLzMxMHB4LUJ1c2hfYXRfTW91bnRfUnVz aG1vcmUuanBnIiB3aWR0aD0iMzEwIiBoZWlnaHQ9IjIzMCIgY2xhc3M9InRodW1iaW1hZ2UiIC8+ PC9hPgk8ZGl2IGNsYXNzPSJ0aHVtYmNhcHRpb24iPgk8ZGl2IGNsYXNzPSJtYWduaWZ5Ij48YSBo cmVmPSIvdy9pbmRleC5waHA/dGl0bGU9RGF0ZWk6QnVzaF9hdF9Nb3VudF9SdXNobW9yZS5qcGcm YW1wO2ZpbGV0aW1lc3RhbXA9MjAwNzEyMjMyMjA2MDkiIGNsYXNzPSJpbnRlcm5hbCIgdGl0bGU9 InZlcmdyw7bDn2VybiI+PGltZyBzcmM9Imh0dHA6Ly9iaXRzLndpa2ltZWRpYS5vcmcvc2tpbnMt MS41L2NvbW1vbi9pbWFnZXMvbWFnbmlmeS1jbGlwLnBuZyIgd2lkdGg9IjE1IiBoZWlnaHQ9IjEx IiBhbHQ9IiIgLz48L2E+PC9kaXY+CVByw6RzaWRlbnQgQnVzaCBzcHJpY2h0IHp1ciBTaWNoZXJo ZWl0c3BvbGl0aWsgYW0gPGEgaHJlZj0iL3dpa2kvTW91bnRfUnVzaG1vcmVfTmF0aW9uYWxfTWVt b3JpYWwiIHRpdGxlPSJNb3VudCBSdXNobW9yZSBOYXRpb25hbCBNZW1vcmlhbCI+TW91bnQgUnVz aG1vcmUgTmF0aW9uYWwgTWVtb3JpYWw8L2E+ICgyMDAyKTwvZGl2Pgk8L2Rpdj4JPC9kaXY+CTxw Pk1pdCBkZW4gPGEgaHJlZj0iL3dpa2kvVGVycm9yYW5zY2hsJUMzJUE0Z2VfYW1fMTEuX1NlcHRl bWJlcl8yMDAxIiB0aXRsZT0iVGVycm9yYW5zY2hsw6RnZSBhbSAxMS4gU2VwdGVtYmVyIDIwMDEi PlRlcnJvcmFuc2NobMOkZ2VuIHZvbSAxMS4gU2VwdGVtYmVyIDIwMDE8L2E+IGVyZnVociBkaWUg UG9saXRpayB2b24gR2VvcmdlIFcuIEJ1c2ggZWluZW4gdGllZiBncmVpZmVuZGVuIEVpbnNjaG5p dHQuIEFuZ2VzaWNodHMgZGVyIHNjaG9ja2llcmVuZCBob2hlbiBPcGZlcnphaGwgdW5kIGRlciBt ZWRpYWwgc3RhcmsgdHJhbnNwb3J0aWVydGVuIHN5bWJvbGlzY2hlbiBXaXJrdW5nIGRlciBBbnNj aGzDpGdlIHJpZWYgZXIgZWluZW4gPGk+PGEgaHJlZj0iL3dpa2kvS3JpZWdfZ2VnZW5fZGVuX1Rl cnJvciIgdGl0bGU9IktyaWVnIGdlZ2VuIGRlbiBUZXJyb3IiPktyaWVnIGdlZ2VuIGRlbiBUZXJy b3Jpc211czwvYT48L2k+IGF1cy48L3A+CTxwPk1pdCBicmVpdGVyIGludGVybmF0aW9uYWxlciBV bnRlcnN0w7x0enVuZyAoYXVjaCBkZXIgZGV1dHNjaGVuIEJ1bmRlc3JlZ2llcnVuZyB1bmQgdmll bGVyIG11c2xpbWlzY2hlciBTdGFhdGVuKSB1bmQgZGVyIFp1c3RpbW11bmcgZGVzIDxhIGhyZWY9 Ii93aWtpL1NpY2hlcmhlaXRzcmF0X2Rlcl9WZXJlaW50ZW5fTmF0aW9uZW4iIHRpdGxlPSJTaWNo ZXJoZWl0c3JhdCBkZXIgVmVyZWludGVuIE5hdGlvbmVuIj5TaWNoZXJoZWl0c3JhdGVzIGRlciBW ZXJlaW50ZW4gTmF0aW9uZW48L2E+IGbDvGhydGVuIGRpZSBWZXJlaW5pZ3RlbiBTdGFhdGVuIHVu ZCA8YSBocmVmPSIvd2lraS9WZXJlaW5pZ3Rlc19LJUMzJUI2bmlncmVpY2giIHRpdGxlPSJWZXJl aW5pZ3RlcyBLw7ZuaWdyZWljaCI+R3Jvw59icml0YW5uaWVuPC9hPiB6dW7DpGNoc3QgYWIgZGVt IDcuIE9rdG9iZXIgPGEgaHJlZj0iL3dpa2kvS3JpZWdfaW5fQWZnaGFuaXN0YW5fc2VpdF8yMDAx IiB0aXRsZT0iS3JpZWcgaW4gQWZnaGFuaXN0YW4gc2VpdCAyMDAxIj5LcmllZyBpbiBBZmdoYW5p c3RhbjwvYT4sIHdvIGRpZSBmw7xyIGRpZSBBbnNjaGzDpGdlIHZlcmFudHdvcnRsaWNoIGdlbWFj aHRlIFRlcnJvcm9yZ2FuaXNhdGlvbiA8YSBocmVmPSIvd2lraS9BbC1RYWlkYSIgdGl0bGU9IkFs LVFhaWRhIj5hbC1RYWlkYTwvYT4gaWhyZSBCYXNpcyBoYXR0ZS48L3A+CTxwPkVpbiB3ZWl0ZXJl cyBaaWVsIHdhciwgZGFzIDxhIGhyZWY9Ii93aWtpL0lzbGFtaXNjaGVyX0Z1bmRhbWVudGFsaXNt dXMiIHRpdGxlPSJJc2xhbWlzY2hlciBGdW5kYW1lbnRhbGlzbXVzIiBjbGFzcz0ibXctcmVkaXJl Y3QiPmlzbGFtaXN0aXNjaGU8L2E+IFJlZ2ltZSBkZXIgPGEgaHJlZj0iL3dpa2kvVGFsaWJhbiIg dGl0bGU9IlRhbGliYW4iPlRhbGliYW48L2E+IHp1IHN0w7xyemVuLiBEaWUgWmFobCBkZXIgZ2V0 w7Z0ZXRlbiBaaXZpbGlzdGVuIGluIGRpZXNlbSBLcmllZywgYmVpIGRlbSBhdWNoIHNvZ2VuYW5u dGUgPGEgaHJlZj0iL3dpa2kvRGFpc3lfQ3V0dGVyIiB0aXRsZT0iRGFpc3kgQ3V0dGVyIj5EYWlz eSBDdXR0ZXI8L2E+LCA8YSBocmVmPSIvd2lraS9TdHJldWJvbWJlIiB0aXRsZT0iU3RyZXVib21i ZSIgY2xhc3M9Im13LXJlZGlyZWN0Ij5TdHJldWJvbWJlbjwvYT4gdW5kIDxhIGhyZWY9Ii93aWtp L1VyYW5tdW5pdGlvbiIgdGl0bGU9IlVyYW5tdW5pdGlvbiI+VXJhbm11bml0aW9uPC9hPiB6dW0g RWluc2F0eiBrYW1lbiwgd3VyZGUgdm9uIGRlciBGcmFua2Z1cnRlciBLb25mZXJlbnogZGVyIGV1 cm9ww6Rpc2NoZW4gRXhpbC1BZmdoYW5lbiBpbSBEZXplbWJlciAyMDAxIGF1ZiBldHdhIDE4LjAw MCBnZXNjaMOkdHp0LjwvcD4JPHA+QW0gMTUuIEp1bmkgMjAwMiBoaWVsdCBQcsOkc2lkZW50IEJ1 c2ggZWluZSA8YSBocmVmPSIvd2lraS9OYWhvc3Rrb25mbGlrdCIgdGl0bGU9Ik5haG9zdGtvbmZs aWt0Ij5OYWhvc3RyZWRlPC9hPiwgZGllIG5lYmVuIGRlciBGb3JkZXJ1bmcgbmFjaCBlaW5lciBu ZXVlbiBwYWzDpHN0aW5lbnNpc2NoZW4gRsO8aHJ1bmcgYXVjaCBkZW4gR3J1bmRzdGVpbiBmw7xy IGRlbiBzcMOkdGVyZW4gZ2VtZWluc2FtZW4gRnJpZWRlbnNwbGFuIGRlciBWZXJlaW5pZ3RlbiBT dGFhdGVuLCA8YSBocmVmPSIvd2lraS9SdXNzbGFuZCIgdGl0bGU9IlJ1c3NsYW5kIj5SdXNzbGFu ZHM8L2E+LCBkZXIgPGEgaHJlZj0iL3dpa2kvRXVyb3AlQzMlQTRpc2NoZV9VbmlvbiIgdGl0bGU9 IkV1cm9ww6Rpc2NoZSBVbmlvbiI+RXVyb3DDpGlzY2hlbiBVbmlvbjwvYT4gdW5kIGRlciA8YSBo cmVmPSIvd2lraS9WZXJlaW50ZV9OYXRpb25lbiIgdGl0bGU9IlZlcmVpbnRlIE5hdGlvbmVuIj5W ZXJlaW50ZSBOYXRpb25lbjwvYT4sIGRlciBzb2dlbmFubnRlbiA8aT48YSBocmVmPSIvd2lraS9S b2FkbWFwXyhOYWhvc3Rrb25mbGlrdCkiIHRpdGxlPSJSb2FkbWFwIChOYWhvc3Rrb25mbGlrdCki PlJvYWRtYXA8L2E+PC9pPiwgZW50aGllbHQuIERpZXMgd2FyIHNlaW4gZXJzdGVzIHdhaHJuZWht YmFyZXMgRW5nYWdlbWVudCBpbiBkZW0gS29uZmxpa3QsIGRlbiBlciB6dXZvciBvZmZlbmJhciBp Z25vcmllcnQgaGF0dGUuPC9wPgk8cD5JbSBKdWxpIDIwMDIgZW50c2NoaWVkIHNpY2ggUHLDpHNp ZGVudCBCdXNoLCBlaW5lIHZvbSA8YSBocmVmPSIvd2lraS9Lb25ncmVzc19kZXJfVmVyZWluaWd0 ZW5fU3RhYXRlbiIgdGl0bGU9IktvbmdyZXNzIGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuIj5Lb25n cmVzczwvYT4gYmV3aWxsaWd0ZSBGaW5hbnpoaWxmZSBpbiBIw7ZoZSB2b24gMzQgTWlvLiBVU0Qg ZsO8ciBkZW4gPGEgaHJlZj0iL3dpa2kvQmV2JUMzJUI2bGtlcnVuZ3Nmb25kc19kZXJfVmVyZWlu dGVuX05hdGlvbmVuIiB0aXRsZT0iQmV2w7Zsa2VydW5nc2ZvbmRzIGRlciBWZXJlaW50ZW4gTmF0 aW9uZW4iPkJldsO2bGtlcnVuZ3Nmb25kcyBkZXIgVmVyZWludGVuIE5hdGlvbmVuPC9hPiAoVU5G UEEpIHp1csO8Y2t6dWhhbHRlbiwgZGEgZGllc2VyIHNlaW5lciBNZWludW5nIG5hY2ggaW4gZGVy IDxhIGhyZWY9Ii93aWtpL1ZvbGtzcmVwdWJsaWtfQ2hpbmEiIHRpdGxlPSJWb2xrc3JlcHVibGlr IENoaW5hIj5Wb2xrc3JlcHVibGlrIENoaW5hPC9hPiBad2FuZ3NhYnRyZWlidW5nZW4gdW5kIC1z dGVyaWxpc2F0aW9uZW4gZmluYW56aWVyZS48L3A+CTxwPkltIEF1Z3VzdCAyMDAyIHZlcnN1Y2h0 ZSBCdXNoLCBkZW4gbmV1IGVycmljaHRldGVuIDxhIGhyZWY9Ii93aWtpL0ludGVybmF0aW9uYWxl cl9TdHJhZmdlcmljaHRzaG9mIiB0aXRsZT0iSW50ZXJuYXRpb25hbGVyIFN0cmFmZ2VyaWNodHNo b2YiPkludGVybmF0aW9uYWxlbiBTdHJhZmdlcmljaHRzaG9mPC9hPiB6dSBzY2h3w6RjaGVuLiBC aWxhdGVyYWxlIEFia29tbWVuIG1pdCBhbmRlcmVuIFN0YWF0ZW4gc29sbHRlbiBBdXNsaWVmZXJ1 bmdlbiB2b24gQsO8cmdlcm4gZGVyIFZlcmVpbmlndGVuIFN0YWF0ZW4gbmFjaCA8YSBocmVmPSIv d2lraS9EZW5fSGFhZyIgdGl0bGU9IkRlbiBIYWFnIj5EZW4gSGFhZzwvYT4sIGRlbSBTaXR6IGRl cyBHZXJpY2h0c2hvZnMsIHZlcmhpbmRlcm47IGRlciA8aT48YSBocmVmPSIvd2lraS9BbWVyaWNh bl9TZXJ2aWNlbWVtYmVycyUyN19Qcm90ZWN0aW9uX0FjdCIgdGl0bGU9IkFtZXJpY2FuIFNlcnZp Y2VtZW1iZXJzJyBQcm90ZWN0aW9uIEFjdCIgY2xhc3M9Im13LXJlZGlyZWN0Ij5BbWVyaWNhbiBT ZXJ2aWNlbWVtYmVycycgUHJvdGVjdGlvbiBBY3Q8L2E+PC9pPiBlcmxhdWJ0ZSBkZW0gUHLDpHNp ZGVudGVuIHN0YXR0ZGVzc2VuLCBkZXJlbiBnZXdhbHRzYW1lIEJlZnJlaXVuZyBhbnp1b3JkbmVu LjwvcD4JPHA+RWluZW4gTW9uYXQgc3DDpHRlciB3dXJkZSBkaWUgbmV1ZSA8YSBocmVmPSIvd2lr aS9OYXRpb25hbGVfU2ljaGVyaGVpdHNzdHJhdGVnaWVfZGVyX1ZlcmVpbmlndGVuX1N0YWF0ZW4i IHRpdGxlPSJOYXRpb25hbGUgU2ljaGVyaGVpdHNzdHJhdGVnaWUgZGVyIFZlcmVpbmlndGVuIFN0 YWF0ZW4iPk5hdGlvbmFsZSBTaWNoZXJoZWl0c3N0cmF0ZWdpZTwvYT4gdmVyw7ZmZmVudGxpY2h0 LiBEaWVzZSBlbnRoaWVsdCBlaW5pZ2Ugw4RuZGVydW5nZW4gZGVyIFBvbGl0aWsgZGVyIFZlcmVp bmlndGVuIFN0YWF0ZW4sIGRpZSBzaWUgYXVjaCBhbHMgPGEgaHJlZj0iL3dpa2kvQnVzaC1Eb2t0 cmluIiB0aXRsZT0iQnVzaC1Eb2t0cmluIiBjbGFzcz0ibXctcmVkaXJlY3QiPkJ1c2gtRG9rdHJp bjwvYT4gYmVrYW5udCB3ZXJkZW4gbGllw59lbi4gRGVyIGF1ZmZhbGxlbmRzdGUgUHVua3Qgd2Fy IGhpZXJiZWkgZGFzIGV4cGxpeml0ZSBadWxhc3NlbiB2b24gPGEgaHJlZj0iL3dpa2kvUHIlQzMl QTR2ZW50aXZzY2hsYWciIHRpdGxlPSJQcsOkdmVudGl2c2NobGFnIj5QcsOkdmVudGl2c2NobMOk Z2VuPC9hPiBiZWkgQmVkcm9odW5nIGR1cmNoIDxhIGhyZWY9Ii93aWtpL01hc3NlbnZlcm5pY2h0 dW5nc3dhZmZlIiB0aXRsZT0iTWFzc2VudmVybmljaHR1bmdzd2FmZmUiPk1hc3NlbnZlcm5pY2h0 dW5nc3dhZmZlbjwvYT4uPC9wPgk8aDQ+PHNwYW4gY2xhc3M9Im13LWhlYWRsaW5lIiBpZD0iSXJh a2tyaWVnIj5JcmFra3JpZWc8L3NwYW4+PC9oND4JPGRpdiBjbGFzcz0idGh1bWIgdHJpZ2h0Ij4J PGRpdiBjbGFzcz0idGh1bWJpbm5lciIgc3R5bGU9IndpZHRoOjIyMnB4OyI+PGEgaHJlZj0iL3cv aW5kZXgucGhwP3RpdGxlPURhdGVpOkJ1c2hfV2FyX0J1ZGdldF8yMDAzLmpwZyZhbXA7ZmlsZXRp bWVzdGFtcD0yMDA2MDIyMjE1Mjc0NCIgY2xhc3M9ImltYWdlIj48aW1nIGFsdD0iIiBzcmM9Imh0 dHA6Ly91cGxvYWQud2lraW1lZGlhLm9yZy93aWtpcGVkaWEvY29tbW9ucy90aHVtYi81LzU2L0J1 c2hfV2FyX0J1ZGdldF8yMDAzLmpwZy8yMjBweC1CdXNoX1dhcl9CdWRnZXRfMjAwMy5qcGciIHdp ZHRoPSIyMjAiIGhlaWdodD0iMTQ2IiBjbGFzcz0idGh1bWJpbWFnZSIgLz48L2E+CTxkaXYgY2xh c3M9InRodW1iY2FwdGlvbiI+CTxkaXYgY2xhc3M9Im1hZ25pZnkiPjxhIGhyZWY9Ii93L2luZGV4 LnBocD90aXRsZT1EYXRlaTpCdXNoX1dhcl9CdWRnZXRfMjAwMy5qcGcmYW1wO2ZpbGV0aW1lc3Rh bXA9MjAwNjAyMjIxNTI3NDQiIGNsYXNzPSJpbnRlcm5hbCIgdGl0bGU9InZlcmdyw7bDn2VybiI+ PGltZyBzcmM9Imh0dHA6Ly9iaXRzLndpa2ltZWRpYS5vcmcvc2tpbnMtMS41L2NvbW1vbi9pbWFn ZXMvbWFnbmlmeS1jbGlwLnBuZyIgd2lkdGg9IjE1IiBoZWlnaHQ9IjExIiBhbHQ9IiIgLz48L2E+ PC9kaXY+CUJ1c2ggbWl0IFZlcnRlaWRpZ3VuZ3NtaW5pc3RlciA8YSBocmVmPSIvd2lraS9Eb25h bGRfUnVtc2ZlbGQiIHRpdGxlPSJEb25hbGQgUnVtc2ZlbGQiPkRvbmFsZCBSdW1zZmVsZDwvYT4g KE1pdHRlKSB1bmQgZGVzc2VuIFN0ZWxsdmVydHJldGVyIDxhIGhyZWY9Ii93aWtpL1BhdWxfV29s Zm93aXR6IiB0aXRsZT0iUGF1bCBXb2xmb3dpdHoiPlBhdWwgV29sZm93aXR6PC9hPiAyMDAzLCB6 dSBCZWdpbm4gZGVzIElyYWtrcmllZ3M8L2Rpdj4JPC9kaXY+CTwvZGl2Pgk8cD5JbSBMYXVmZSBk ZXMgSmFocmVzIDIwMDIgc3RlbGx0ZSBCdXNoIGVpbmVuIGRpcmVrdGVuIFp1c2FtbWVuaGFuZyB6 d2lzY2hlbiBkZW0gS3JpZWcgZ2VnZW4gZGVuIFRlcnJvcmlzbXVzIHVuZCA8YSBocmVmPSIvd2lr aS9TYWRkYW1fSHVzc2VpbiIgdGl0bGU9IlNhZGRhbSBIdXNzZWluIj5TYWRkYW0gSHVzc2Vpbjwv YT4gaGVyLiBCdXNoIHdhcmYgZGVtIDxhIGhyZWY9Ii93aWtpL0lyYWsiIHRpdGxlPSJJcmFrIj5J cmFrPC9hPiB6dWRlbSB2b3IsIGVyIGJlc2l0emUgPGEgaHJlZj0iL3dpa2kvTWFzc2VudmVybmlj aHR1bmdzd2FmZmUiIHRpdGxlPSJNYXNzZW52ZXJuaWNodHVuZ3N3YWZmZSI+TWFzc2VudmVybmlj aHR1bmdzd2FmZmVuPC9hPi4gRGVyIFZvcnd1cmYgd3VyZGUgc2Nob24gZGFtYWxzIHNrZXB0aXNj aCBhdWZnZW5vbW1lbiB1bmQgbGllw58gc2ljaCBzcMOkdGVyIG5pY2h0IGJld2Vpc2VuLiBTZWlu IHN0ZXRpZyB3YWNoc2VuZGVyIERydWNrIGF1ZiBkZW4gSXJhayBnaXBmZWx0ZSBzY2hsaWXDn2xp Y2ggaW0gTcOkcnogMjAwMyBpbSA8YSBocmVmPSIvd2lraS9JcmFra3JpZWciIHRpdGxlPSJJcmFr a3JpZWciPklyYWtrcmllZzwvYT4gbWl0IGRlciBJbnZhc2lvbiBkZXMgSXJha3MgZHVyY2ggYnJp dGlzY2hlIHVuZCBhbWVyaWthbmlzY2hlIFRydXBwZW52ZXJiw6RuZGUuIERpZSBUcnVwcGVuIGRl cyBJcmFrIHd1cmRlbiBpbm5lcmhhbGIgd2VuaWdlciBXb2NoZW4gYmVzaWVndCB1bmQgZGFzIExh bmQgYmVzZXR6dCBtaXQgZGVtIGVya2zDpHJ0ZW4gWmllbCwgZG9ydCBWb3JhdXNzZXR6dW5nZW4g ZsO8ciBlaW5lIGRlbW9rcmF0aXNjaGUgUmVnaWVydW5nIHp1IHNjaGFmZmVuLjwvcD4JPHA+RGEg d2VnZW4gZGVyIHN0YXJrZW4gT3Bwb3NpdGlvbiBpbSA8YSBocmVmPSIvd2lraS9TaWNoZXJoZWl0 c3JhdF9kZXJfVmVyZWludGVuX05hdGlvbmVuIiB0aXRsZT0iU2ljaGVyaGVpdHNyYXQgZGVyIFZl cmVpbnRlbiBOYXRpb25lbiI+U2ljaGVyaGVpdHNyYXQgZGVyIFZlcmVpbnRlbiBOYXRpb25lbjwv YT4gZGFzIGVpZ2VudGxpY2ggZ2V3w7xuc2NodGUgYXVzZHLDvGNrbGljaGUgVU5PLU1hbmRhdCBu aWNodCB6dSBiZWtvbW1lbiB3YXIsIHN0w7x0enRlIGVyIHNpY2ggYW0gRW5kZSBsZWRpZ2xpY2gg YXVmIGVpbmUgc28gZ2VuYW5udGUgPGk+PGEgaHJlZj0iL3dpa2kvS29hbGl0aW9uX2Rlcl9XaWxs aWdlbiIgdGl0bGU9IktvYWxpdGlvbiBkZXIgV2lsbGlnZW4iPktvYWxpdGlvbiBkZXIgV2lsbGln ZW48L2E+PC9pPiBhdXMgR3Jvw59icml0YW5uaWVuLCA8YSBocmVmPSIvd2lraS9TcGFuaWVuIiB0 aXRsZT0iU3BhbmllbiI+U3BhbmllbjwvYT4sIDxhIGhyZWY9Ii93aWtpL0l0YWxpZW4iIHRpdGxl PSJJdGFsaWVuIj5JdGFsaWVuPC9hPiwgPGEgaHJlZj0iL3dpa2kvUG9sZW4iIHRpdGxlPSJQb2xl biI+UG9sZW48L2E+LCA8YSBocmVmPSIvd2lraS9BdXN0cmFsaWVuIiB0aXRsZT0iQXVzdHJhbGll biI+QXVzdHJhbGllbjwvYT4gdW5kIGV0d2EgMzAgd2VpdGVyZW4gU3RhYXRlbi4gRGllIEdlZ25l ciBkZXMgSXJha2tyaWVnZXMsIGRhcnVudGVyIGRpZSBSZWdpZXJ1bmdlbiA8YSBocmVmPSIvd2lr aS9GcmFua3JlaWNoIiB0aXRsZT0iRnJhbmtyZWljaCI+RnJhbmtyZWljaHM8L2E+LCA8YSBocmVm PSIvd2lraS9SdXNzbGFuZCIgdGl0bGU9IlJ1c3NsYW5kIj5SdXNzbGFuZHM8L2E+LCA8YSBocmVm PSIvd2lraS9EZXV0c2NobGFuZCIgdGl0bGU9IkRldXRzY2hsYW5kIj5EZXV0c2NobGFuZHM8L2E+ IHVuZCA8YSBocmVmPSIvd2lraS8lQzMlOTZzdGVycmVpY2giIHRpdGxlPSLDlnN0ZXJyZWljaCI+ w5ZzdGVycmVpY2hzPC9hPiwgc2FoZW4gaW4gZWluZXIgRm9ydGbDvGhydW5nIGRlciBXYWZmZW5p bnNwZWt0aW9uZW4gZHVyY2ggZGllIDxhIGhyZWY9Ii93aWtpL0ludGVybmF0aW9uYWxlX0F0b21l bmVyZ2llb3JnYW5pc2F0aW9uIiB0aXRsZT0iSW50ZXJuYXRpb25hbGUgQXRvbWVuZXJnaWVvcmdh bmlzYXRpb24iIGNsYXNzPSJtdy1yZWRpcmVjdCI+SW50ZXJuYXRpb25hbGUgQXRvbWVuZXJnaWVv cmdhbmlzYXRpb248L2E+IChJQUVPKSBlaW4gYW5nZW1lc3NlbmVyZXMsIHZvcmzDpHVmaWcgYXVz cmVpY2hlbmRlcyBNaXR0ZWwgZsO8ciBlaW5lIEFicsO8c3R1bmcgZGVzIElyYWsuPC9wPgk8cD5B dWNoIGluIGRlciBpbnRlcm5hdGlvbmFsZW4gw5ZmZmVudGxpY2hrZWl0IHdhciBlcyB6dSBNYXNz ZW5wcm90ZXN0ZW4gZ2VnZW4gZGllIEF1w59lbnBvbGl0aWsgZGVyIFZlcmVpbmlndGVuIFN0YWF0 ZW4gdW5kIGlocmVyIFZlcmLDvG5kZXRlbiBnZWtvbW1lbi4gV2VsdHdlaXQgYmV0ZWlsaWd0ZW4g c2ljaCBpbSBGZWJydWFyIHVuZCBNw6RyeiAyMDAzIE1pbGxpb25lbiB2b24gTWVuc2NoZW4gYW4g QW50aWtyaWVnc2RlbW9uc3RyYXRpb25lbiBkZXIgPGEgaHJlZj0iL3dpa2kvRnJpZWRlbnNiZXdl Z3VuZyIgdGl0bGU9IkZyaWVkZW5zYmV3ZWd1bmciPkZyaWVkZW5zYmV3ZWd1bmc8L2E+IOKAkyBh dWNoIGluIHNvbGNoZW4gTMOkbmRlcm4sIGRlcmVuIFJlZ2llcnVuZ2VuIHNpY2ggaGludGVyIEJ1 c2ggZ2VzdGVsbHQgaGF0dGVuLiBVbnRlciBhbmRlcmVtIHd1cmRlIEJ1c2ggdm9yZ2V3b3JmZW4s IGRhc3MgZGVyIGJlZGV1dGVuZGVyZSBLcmllZ3NncnVuZCB3ZW5pZ2VyIGRlciBLYW1wZiBnZWdl biBkZW4gVGVycm9yaXNtdXMgc2VpLCBzb25kZXJuIHZpZWxtZWhyIGRpZSB3aXJ0c2NoYWZ0c3Bv bGl0aXNjaGVuIChadWdyaWZmIGF1ZiBkaWUgaXJha2lzY2hlbiBFcmTDtmxxdWVsbGVuKSB1bmQg Z2Vvc3RyYXRlZ2lzY2hlbiBJbnRlcmVzc2VuIGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuLjwvcD4J PHA+V8OkaHJlbmQgZGVyIEtyaWVnIGluIEFmZ2hhbmlzdGFuIGltIEFsbGdlbWVpbmVuIGR1cmNo IGRhcyBSZWNodCBhdWYgU2VsYnN0dmVydGVpZGlndW5nIGFscyBnZWRlY2t0IGdpbHQsIHdhciBk aWUgdsO2bGtlcnJlY2h0bGljaGUgTGVnaXRpbWF0aW9uIGRlcyBJcmFra3JpZWdlcyB2b24gQW5m YW5nIGFuIHN0YXJrIHVtc3RyaXR0ZW4uPC9wPgk8cD5EaWUgS3JpZWdzZ2VnbmVyIHNlaGVuIHNp Y2ggaW56d2lzY2hlbiBkYWR1cmNoIGJlc3TDpHRpZ3QsIGRhc3Mga2VpbmVybGVpIE1hc3NlbnZl cm5pY2h0dW5nc3dhZmZlbiBnZWZ1bmRlbiB3ZXJkZW4ga29ubnRlbiB1bmQgZGVyIFRlcnJvcmlz bXVzIGR1cmNoIGRlbiBLcmllZyBuaWNodCBnZXNjaHfDpGNodCB3dXJkZS4gVGF0c8OkY2hsaWNo IGJsaWViIGRlciBJcmFrIOKAkyB1bmQgbWl0IGlobSBhdWNoIHp1bmVobWVuZCBkZXIgR3Jvw590 ZWlsIGRlcyA8YSBocmVmPSIvd2lraS9OYWhlcl9Pc3RlbiIgdGl0bGU9Ik5haGVyIE9zdGVuIj5u YWhlbiBPc3RlbnM8L2E+IOKAkyBuYWNoIGRlbSBvZmZpemllbGxlbiBLcmllZ3NlbmRlICg8aT7i gJ5taXNzaW9uIGFjY29tcGxpc2hlZCHigJw8L2k+KSBlaW4gVW5ydWhlaGVyZCwgaW4gZGVtIHNp Y2ggQW5zY2hsw6RnZSBnZWdlbiBkaWUgPGEgaHJlZj0iL3dpa2kvT2trdXBhdGlvbiIgdGl0bGU9 Ik9ra3VwYXRpb24iPkJlc2F0enVuZ3N0cnVwcGVuPC9hPiwgZ2VnZW4gYW5kZXJlIEF1c2zDpG5k ZXIgdW5kIGdlZ2VuIG1pdCBpaG5lbiB6dXNhbW1lbmFyYmVpdGVuZGUsIGFiZXIgYXVjaCB2w7Zs bGlnIHVuYmV0ZWlsaWd0ZSBpcmFraXNjaGUgdW5kIGFyYWJpc2NoZSBaaXZpbGlzdGVuIGjDpHVm ZW4uIEF1Y2ggaW50ZXJuYXRpb25hbCBrYW0gZXMgenUgd2VpdGVyZW4gVGVycm9yYW5zY2hsw6Rn ZW4sIGRpZSBhbC1RYWlkYSB1bmQgaWhyIG5haGVzdGVoZW5kZW4gT3JnYW5pc2F0aW9uZW4sIHp1 Z2VzY2hyaWViZW4gd2VyZGVuLCBkYXJ1bnRlciBpbiA8YSBocmVmPSIvd2lraS9Jc3RhbmJ1bCIg dGl0bGU9IklzdGFuYnVsIj5Jc3RhbmJ1bDwvYT4gdW5kIGFtIDExLiBNw6RyeiAyMDA0IGluIDxh IGhyZWY9Ii93aWtpL01hZHJpZGVyX1p1Z2Fuc2NobCVDMyVBNGdlIiB0aXRsZT0iTWFkcmlkZXIg WnVnYW5zY2hsw6RnZSI+TWFkcmlkPC9hPi48L3A+CTxwPkVpbmVuIHdlaXRlcmVuIEVpbnNjaG5p dHQgZXJmdWhyIEJ1c2hzIEF1w59lbnBvbGl0aWsgaW0gRnLDvGhqYWhyIDIwMDQgYWxzIEZvbGdl IGRlcyBXYWhsc2llZ3MgZGVyIDxhIGhyZWY9Ii93aWtpL1BTT0UiIHRpdGxlPSJQU09FIiBjbGFz cz0ibXctcmVkaXJlY3QiPlBTT0U8L2E+IChTb3ppYWxpc3RlbikgYmVpIGRlbiA8YSBocmVmPSIv d2lraS9TcGFuaXNjaGVfUGFybGFtZW50c3dhaGxlbl8yMDA0IiB0aXRsZT0iU3BhbmlzY2hlIFBh cmxhbWVudHN3YWhsZW4gMjAwNCI+c3BhbmlzY2hlbiBQYXJsYW1lbnRzd2FobGVuPC9hPjogV2Vu aWdlIFRhZ2Ugdm9yIGRlciBXYWhsIHdhcmVuIGJlaSBlaW5lbSA8YSBocmVmPSIvd2lraS9NYWRy aWRlcl9adWdhbnNjaGwlQzMlQTRnZSIgdGl0bGU9Ik1hZHJpZGVyIFp1Z2Fuc2NobMOkZ2UiPkJv bWJlbmFuc2NobGFnIGF1ZiBNYWRyaWRlciBWb3JvcnR6w7xnZTwvYT4gMTkxIE1lbnNjaGVuIHVt cyBMZWJlbiBnZWtvbW1lbi4gRGllIGFtdGllcmVuZGUgUmVnaWVydW5nIDxhIGhyZWY9Ii93aWtp L0pvcyVDMyVBOV9NYXIlQzMlQURhX0F6bmFyIiB0aXRsZT0iSm9zw6kgTWFyw61hIEF6bmFyIj5B em5hcjwvYT4gdmVyc3VjaHRlIHp1bsOkY2hzdCwgZGllIG11dG1hw59saWNoIHZvbiBhbC1RYWlk YS1UZXJyb3Jpc3RlbiB2ZXLDvGJ0ZW4gQW5zY2hsw6RnZSwgd2lkZXIgYmVzc2VyZXMgV2lzc2Vu LCBkZXIgYmFza2lzY2hlbiBTZXBhcmF0aXN0ZW5vcmdhbmlzYXRpb24gPGEgaHJlZj0iL3dpa2kv RXVza2FkaV9UYV9Bc2thdGFzdW5hIiB0aXRsZT0iRXVza2FkaSBUYSBBc2thdGFzdW5hIj5FVEE8 L2E+IHp1enVzY2hyZWliZW4uIERpZSDDtmZmZW50bGljaGUgRW1ww7ZydW5nIGRhcsO8YmVyIHRy dWcgZGFubiBhYmVyIGVudHNjaGVpZGVuZCB6dW0gw7xiZXJyYXNjaGVuZGVuIFdhaGxzaWVnIGRl cyBTb3ppYWxpc3RlbiA8YSBocmVmPSIvd2lraS9Kb3MlQzMlQTlfTHVpc19Sb2RyJUMzJUFEZ3Vl el9aYXBhdGVybyIgdGl0bGU9Ikpvc8OpIEx1aXMgUm9kcsOtZ3VleiBaYXBhdGVybyI+Sm9zw6kg THVpcyBSb2Ryw61ndWV6IFphcGF0ZXJvPC9hPiBiZWkuIFdpZSBpbSBXYWhsa2FtcGYgYW5nZWvD vG5kaWd0LCBvcmRuZXRlIGRlciBuZXVlIE1pbmlzdGVycHLDpHNpZGVudCBrdXJ6IG5hY2ggc2Vp bmVyIFZlcmVpZGlndW5nIGRlbiBSw7xja3p1ZyBkZXIgc3BhbmlzY2hlbiBUcnVwcGVuIGF1cyBk ZW0gSXJhayBhbiwgZGEgZXIg4oCea2VpbmUgQW56ZWljaGVuIGRhZsO8ciBlcmtlbm5lbiBrw7Zu bmUsIGRhc3MgZGllIFRydXBwZW7igJwsIHdpZSB2b24gaWhtIGdlZm9yZGVydCwg4oCeYmlzIHp1 bSAzMC4gSnVuaSBkZXIgPGEgaHJlZj0iL3dpa2kvVmVyZWludGVfTmF0aW9uZW4iIHRpdGxlPSJW ZXJlaW50ZSBOYXRpb25lbiI+VU48L2E+IHVudGVyc3RlbGx0IHfDvHJkZW7igJwuIERhbWl0IHNj aGVydGUgZWluIGJpc2xhbmcgYWxzIHp1dmVybMOkc3NpZyBlaW5nZXN0dWZ0ZXIgUGFydG5lciBh dXMgZGVyIOKAnktvYWxpdGlvbiBkZXIgV2lsbGlnZW7igJwgYXVzLjwvcD4JPHA+SW0gTWFpIDIw MDQgZHJhbmdlbiB6dW5laG1lbmQgSW5mb3JtYXRpb25lbiDDvGJlciBQcmFrdGlrZW4gdGVpbHMg c3lzdGVtYXRpc2NoZXIgRm9sdGVyIHVuZCBNaXNzaGFuZGx1bmcgaXJha2lzY2hlciBHZWZhbmdl bmVyIGR1cmNoIEFuZ2Vow7ZyaWdlIGFtZXJpa2FuaXNjaGVuIE1pbGl0w6RycyBpbSA8YSBocmVm PSIvd2lraS9CYWdkYWQiIHRpdGxlPSJCYWdkYWQiPkJhZ2RhZGVyPC9hPiA8YSBocmVmPSIvd2lr aS9BYnUtR2h1cmFpYi1HZWYlQzMlQTRuZ25pcyIgdGl0bGU9IkFidS1HaHVyYWliLUdlZsOkbmdu aXMiPkFidS1HaHVyYWliLUdlZsOkbmduaXM8L2E+IGFuIGRpZSDDlmZmZW50bGljaGtlaXQuIERp ZSA8YSBocmVmPSIvd2lraS9Gb2x0ZXIiIHRpdGxlPSJGb2x0ZXIiPkZvbHRlcnVuZ2VuPC9hPiB3 dXJkZW4gZHVyY2ggRm90b3MgdW5kIFZpZGVvcyBiZWxlZ3QuIEJlaSBkZW4gPGEgaHJlZj0iL3dp a2kvTWlzc2hhbmRsdW5nIiB0aXRsZT0iTWlzc2hhbmRsdW5nIj5NaXNzaGFuZGx1bmdlbjwvYT4g aGF0dGUgZXMgYXVjaCBzY2hvbiBtZWhyZXJlIFRvZGVzb3BmZXIgZ2VnZWJlbi4gQmFsZCB3dXJk ZW4gw6RobmxpY2hlIFZvcmbDpGxsZSBhdWNoIGluIGFuZGVyZW4gdm9uIEFtZXJpa2FuZXJuIGdl ZsO8aHJ0ZW4gTWlsaXTDpHJnZWbDpG5nbmlzc2VuIGltIElyYWsgdW5kIGluIEFmZ2hhbmlzdGFu IGJla2FubnQuIFNjaG9uIHp1dm9yIHdhciBkaWUgQnVzaC1SZWdpZXJ1bmcgd2VnZW4gZGVyIEJl aGFuZGx1bmcgZGVyIEdlZmFuZ2VuZW4gYXVmIGRlbSBVUy1TdMO8dHpwdW5rdCA8YSBocmVmPSIv d2lraS9HdWFudGFuYW1vX0JheV9OYXZhbF9CYXNlIiB0aXRsZT0iR3VhbnRhbmFtbyBCYXkgTmF2 YWwgQmFzZSI+R3VhbnTDoW5hbW8gQmF5PC9hPiBpbiA8YSBocmVmPSIvd2lraS9LdWJhIiB0aXRs ZT0iS3ViYSI+S3ViYTwvYT4gaW4gZGllIEtyaXRpayBnZXJhdGVuLiBNaXQgZGVtIEJla2FubnR3 ZXJkZW4gZGVyIFZvcmbDpGxsZSBpbiBBYnUgR2h1cmFpYiB3ZWl0ZXRlIHNpY2ggZGllIEFuZ2Vs ZWdlbmhlaXQgc2NobmVsbCB6dSBlaW5lbSBTa2FuZGFsIGF1cywgZGVyIGRpZSBtb3JhbGlzY2hl IEdsYXVid8O8cmRpZ2tlaXQgZGVyIEJ1c2gtUmVnaWVydW5nIGRldXRsaWNoIHNjaHfDpGNodGUu PC9wPgk8cD5JbSBEZXplbWJlciAyMDA4IGJlc3VjaHRlIEJ1c2ggZGVuIElyYWsgdW5kIHd1cmRl IHZvbSBKb3VybmFsaXN0ZW4gPGEgaHJlZj0iL3dpa2kvTXVudGF6ZXJfYWwtWmFpZGkiIHRpdGxl PSJNdW50YXplciBhbC1aYWlkaSI+TXVudGF6ZXIgYWwtWmFpZGk8L2E+IG1pdCB6d2VpIFNjaHVo ZW4gYmV3b3JmZW47IGRhcyB2b24gZGllc2VtIHZlcndlbmRldGUgTW9kZWxsIGZhbmQgYmFsZCBk YXJhdWYgdm9yw7xiZXJnZWhlbmQgcmVpw59lbmRlbiBBYnNhdHogaW4gYWxsZXIgV2VsdC48L3A+ CTxoND48c3BhbiBjbGFzcz0ibXctaGVhZGxpbmUiIGlkPSJJbm5lbnBvbGl0aWtfbmFjaF9kZW1f MTEuX1NlcHRlbWJlcl8yMDAxIj5Jbm5lbnBvbGl0aWsgbmFjaCBkZW0gMTEuIFNlcHRlbWJlciAy MDAxPC9zcGFuPjwvaDQ+CTxwPklubmVucG9saXRpc2NoIGtvbm50ZSBzaWNoIEJ1c2ggaW5mb2xn ZSBkZXMgYWxsZ2VtZWluZW4gU2Nob2NrcyBkdXJjaCBkaWUgQW5zY2hsw6RnZSB6dW7DpGNoc3Qg YXVmIGVpbmUgYnJlaXRlIFVudGVyc3TDvHR6dW5nIGltIEthbXBmIGdlZ2VuIGRlbiBUZXJyb3Jp c211cyB2ZXJsYXNzZW46IE1hw59uYWhtZW4gd2llIHN0cmVuZ2VyZSBTaWNoZXJoZWl0c2tvbnRy b2xsZW4gdW5kIEVpbnJlaXNlYmVkaW5ndW5nZW4gdW5kIEVpbnNjaHLDpG5rdW5nZW4gZGVyIDxh IGhyZWY9Ii93aWtpL0IlQzMlQkNyZ2VycmVjaHQiIHRpdGxlPSJCw7xyZ2VycmVjaHQiPkLDvHJn ZXJyZWNodGU8L2E+IGR1cmNoIGRlbiA8aT48YSBocmVmPSIvd2lraS9VU0FfUEFUUklPVF9BY3Qi IHRpdGxlPSJVU0EgUEFUUklPVCBBY3QiPlBhdHJpb3QgQWN0IEk8L2E+PC9pPiBrb25udGVuIHrD vGdpZyB1bmQgcHJha3Rpc2NoIG9obmUgw7ZmZmVudGxpY2hlIEF1c2VpbmFuZGVyc2V0enVuZyB2 ZXJhYnNjaGllZGV0IHdlcmRlbi4gR2VvcmdlIFcuIEJ1c2gga29ubnRlIGRpZSBow7ZjaHN0ZW4g WnVzdGltbXVuZ3N3ZXJ0ZSB2ZXJ6ZWljaG5lbiwgZGllIGplbWFscyBpbiBkZW4gVmVyZWluaWd0 ZW4gU3RhYXRlbiBnZW1lc3NlbiB3dXJkZW4uIEVyc3Qgc3DDpHRlciB3dXJkZSBLcml0aWsgaGF1 cHRzw6RjaGxpY2ggYW4gZGVuIFBsw6RuZW4genUgZWluZW0gPGk+UGF0cmlvdCBBY3QgSUk8L2k+ IGxhdXQuIFVudGVyIFZlcndlaXMgYXVmIGRpZSBUZXJyb3Jpc211c2Jla8OkbXBmdW5nIHd1cmRl biBkaXZlcnNlIEluc3RpdHV0aW9uZW4gd2llIGRlciBab2xsICg8YSBocmVmPSIvd2lraS9Vbml0 ZWRfU3RhdGVzX0N1c3RvbXNfYW5kX0JvcmRlcl9Qcm90ZWN0aW9uIiB0aXRsZT0iVW5pdGVkIFN0 YXRlcyBDdXN0b21zIGFuZCBCb3JkZXIgUHJvdGVjdGlvbiI+Q0JQPC9hPiB1bmQgPGEgaHJlZj0i L3dpa2kvVW5pdGVkX1N0YXRlc19JbW1pZ3JhdGlvbl9hbmRfQ3VzdG9tc19FbmZvcmNlbWVudCIg dGl0bGU9IlVuaXRlZCBTdGF0ZXMgSW1taWdyYXRpb24gYW5kIEN1c3RvbXMgRW5mb3JjZW1lbnQi PklDRTwvYT4pLCBkaWUgPGEgaHJlZj0iL3dpa2kvVW5pdGVkX1N0YXRlc19Db2FzdF9HdWFyZCIg dGl0bGU9IlVuaXRlZCBTdGF0ZXMgQ29hc3QgR3VhcmQiPkvDvHN0ZW53YWNoZTwvYT4gdW5kIGRp ZSBLYXRhc3Ryb3BoZW5zY2h1dHpiZWjDtnJkZSA8YSBocmVmPSIvd2lraS9GZWRlcmFsX0VtZXJn ZW5jeV9NYW5hZ2VtZW50X0FnZW5jeSIgdGl0bGU9IkZlZGVyYWwgRW1lcmdlbmN5IE1hbmFnZW1l bnQgQWdlbmN5Ij5GZWRlcmFsIEVtZXJnZW5jeSBNYW5hZ2VtZW50IEFnZW5jeTwvYT4gaW4gZWlu ZW0gbmV1ZW4gPGk+PGEgaHJlZj0iL3dpa2kvSGVpbWF0c2NodXR6bWluaXN0ZXJpdW0iIHRpdGxl PSJIZWltYXRzY2h1dHptaW5pc3Rlcml1bSI+SGVpbWF0c2NodXR6bWluaXN0ZXJpdW08L2E+PC9p PiBtaXQgenVzYW1tZW4gMTgwLjAwMCBNaXRhcmJlaXRlcm4genVzYW1tZW5nZWZhc3N0LjwvcD4J PHA+SW0gTmFtZW4gZGVzIDxhIGhyZWY9Ii93aWtpL0hlaW1hdHNjaHV0em1pbmlzdGVyaXVtIiB0 aXRsZT0iSGVpbWF0c2NodXR6bWluaXN0ZXJpdW0iPkhlaW1hdHNjaHV0em1pbmlzdGVyaXVtczwv YT4gdW50ZXJ6ZWljaG5ldGUgR2VvcmdlIFcuIEJ1c2ggaW0gTWFpIDIwMDcgZGllIDxpPk5hdGlv bmFsIFNlY3VyaXR5IFByZXNpZGVudGlhbCBEaXJlY3RpdmUgNTE8L2k+IChOU1BEIDUxKSwgYXVj aCBhbHMgPGk+SG9tZWxhbmQgU2VjdXJpdHkgUHJlc2lkZW50aWFsIERpcmVjdGl2ZSAyMDwvaT4g KEhTUEQgMjApIGJla2FubnQsIGRpZSBpbSBGYWxsZSBlaW5lciBuYXRpb25hbGVuIEthdGFzdHJv cGhlIG9kZXIgTm90ZmFsbHMgZGllIEZvcnRkYXVlciBkZXIga29uc3RpdHV0aW9uZWxsZW4gUmVn aWVydW5nc2FyYmVpdCAo4oCeRW5kdXJpbmcgQ29uc3RpdHV0aW9uYWwgR292ZXJubWVudOKAnCkg c2ljaGVyc3RlbGxlbiBzb2xsLCBpbmRlbSBkZXIgUHLDpHNpZGVudCBkaWUgS29vcGVyYXRpb24g endpc2NoZW4gZGVyIDxhIGhyZWY9Ii93aWtpL0V4ZWt1dGl2ZSIgdGl0bGU9IkV4ZWt1dGl2ZSI+ RXhla3V0aXZlPC9hPiwgZGVyIDxhIGhyZWY9Ii93aWtpL0xlZ2lzbGF0aXZlIiB0aXRsZT0iTGVn aXNsYXRpdmUiPkxlZ2lzbGF0aXZlPC9hPiwgdW5kIGRlciA8YSBocmVmPSIvd2lraS9KdWRpa2F0 aXZlIiB0aXRsZT0iSnVkaWthdGl2ZSI+SnVkaWthdGl2ZTwvYT4ga29vcmRpbmllcnQuPHN1cCBp ZD0iY2l0ZV9yZWYtMiIgY2xhc3M9InJlZmVyZW5jZSI+PGEgaHJlZj0iI2NpdGVfbm90ZS0yIj5b M108L2E+PC9zdXA+PC9wPgk8cD5NaXR0bGVyd2VpbGUgd3VyZGUgYmVrYW5udCwgZGFzcyBzaWNo IGRhcyA8YSBocmVmPSIvd2lraS9GQkkiIHRpdGxlPSJGQkkiIGNsYXNzPSJtdy1yZWRpcmVjdCI+ RkJJPC9hPiB1bmQgZGllIDxhIGhyZWY9Ii93aWtpL05hdGlvbmFsX1NlY3VyaXR5X0FnZW5jeSIg dGl0bGU9Ik5hdGlvbmFsIFNlY3VyaXR5IEFnZW5jeSI+TmF0aW9uYWwgU2VjdXJpdHkgQWdlbmN5 PC9hPiAoTlNBKSBpbiBlaW5lbSBhbiBkZW4gUHLDpHNpZGVudGVuIGdlcmljaHRldGVuIE1lbW9y YW5kdW0gc2Nob24gaW0gQXVndXN0IDIwMDEgbWl0IGRlciBUZXJyb3JiZWRyb2h1bmcgZsO8ciBk aWUgVmVyZWluaWd0ZW4gU3RhYXRlbiBiZWZhc3N0IGhhdHRlbjsgZGllcyBrYW0gZGFyaW4gYWxs ZXJkaW5ncyB6dSBkZW0gU2NobHVzcywgZGFzcyBlcyB6d2FyIOKAnnZlcmTDpGNodGlnZSBBa3Rp dml0w6R0ZW7igJwgZ8OkYmUsIHNpY2ggR2Vyw7xjaHRlIMO8YmVyIGVpbmUgZ2VwbGFudGUgRmx1 Z3pldWdlbnRmw7xocnVuZyBhYmVyIOKAnm5pY2h0IGJlc3TDpHRpZ2Vu4oCcIGxpZcOfZW4uIERp ZXNlcyBiaXMgZGFoaW4gZ2VoZWltZSBEb2t1bWVudCB3dXJkZSB2b24gZGVyIFJlZ2llcnVuZyB3 aWRlcndpbGxpZyB1bmQgYXVmIERydWNrIGRlciB2b20gS29uZ3Jlc3MgZWluZ2VzZXR6dGVuIDxh IGhyZWY9Ii93aWtpL1VudGVyc3VjaHVuZ3Nrb21taXNzaW9uX3p1X2Rlbl9BbnNjaGwlQzMlQTRn ZW5fZGVzXzExLl9TZXB0ZW1iZXJzIiB0aXRsZT0iVW50ZXJzdWNodW5nc2tvbW1pc3Npb24genUg ZGVuIEFuc2NobMOkZ2VuIGRlcyAxMS4gU2VwdGVtYmVycyI+VW50ZXJzdWNodW5nc2tvbW1pc3Np b248L2E+IGltIEFwcmlsIDIwMDQgdmVyw7ZmZmVudGxpY2h0LiBBbGxlcmRpbmdzLCBzbyBzdGVs bHRlIHNpY2ggc2NobGllw59saWNoIGhlcmF1cywgd2FyZW4gZGllIFdhcm51bmdlbiB1bmQgSGlu d2Vpc2UgZGVzIE1lbW9yYW5kdW1zIHNlaHIgYWxsZ2VtZWluIGdlaGFsdGVuIGdld2VzZW4sIHdl c2hhbGIga29ua3JldGUgU2NodXR6bWHDn25haG1lbiBuaWNodCBtw7ZnbGljaCBlcnNjaGllbmVu LjwvcD4JPHA+SW0gTcOkcnogMjAwMiBlbnRzY2hpZWQgUHLDpHNpZGVudCBCdXNoLCA8YSBocmVm PSIvd2lraS9ab2xsXyhBYmdhYmUpIiB0aXRsZT0iWm9sbCAoQWJnYWJlKSI+RWluZnVocnrDtmxs ZTwvYT4gYXVmIFN0YWhscHJvZHVrdGUgenUgZXJoZWJlbiwgdW0gYW1lcmlrYW5pc2NoZSBGaXJt ZW4gZGllc2VzIFNla3RvcnMgdm9yIGF1c2zDpG5kaXNjaGVyIEtvbmt1cnJlbnogenUgc2Now7x0 emVuLiBJbiBkZXIgRm9sZ2UgdmVyaMOkbmd0ZSBkaWUgPGEgaHJlZj0iL3dpa2kvRXVyb3AlQzMl QTRpc2NoZV9VbmlvbiIgdGl0bGU9IkV1cm9ww6Rpc2NoZSBVbmlvbiI+RXVyb3DDpGlzY2hlIFVu aW9uPC9hPiwgZ2ViaWxsaWd0IHZvbiBkZXIgPGEgaHJlZj0iL3dpa2kvV2VsdGhhbmRlbHNvcmdh bmlzYXRpb24iIHRpdGxlPSJXZWx0aGFuZGVsc29yZ2FuaXNhdGlvbiI+V1RPPC9hPiwgU3RyYWZ6 w7ZsbGUgZ2VnZW4gZGllIFZlcmVpbmlndGVuIFN0YWF0ZW4uPC9wPgk8cD5JbSBKYWhyZSAyMDAy IGdld2FubiBkaWUgcmVwdWJsaWthbmlzY2hlIFBhcnRlaSBkaWUgPGEgaHJlZj0iL3dpa2kvU2Vu YXRfZGVyX1ZlcmVpbmlndGVuX1N0YWF0ZW4iIHRpdGxlPSJTZW5hdCBkZXIgVmVyZWluaWd0ZW4g U3RhYXRlbiI+U2VuYXRzd2FobGVuPC9hPiB1bmQga29ubnRlLCBlbnRnZWdlbiBkZW0gbm9ybWFs ZW4gVHJlbmQsIGRhc3MgZGllIFJlZ2llcnVuZ3NwYXJ0ZWkgaW4gZGVuIDxpPk1pZHRlcm0gRWxl Y3Rpb25zPC9pPiBTdGltbWVuIHZlcmxpZXJ0LCBpaHJlIE1laHJoZWl0IGltIDxhIGhyZWY9Ii93 aWtpL0tvbmdyZXNzX2Rlcl9WZXJlaW5pZ3Rlbl9TdGFhdGVuIiB0aXRsZT0iS29uZ3Jlc3MgZGVy IFZlcmVpbmlndGVuIFN0YWF0ZW4iPktvbmdyZXNzPC9hPiBhdXNiYXVlbi48L3A+CTxwPkVpbmUg R2VzZXR6ZXNpbml0aWF0aXZlIGRlcyBQcsOkc2lkZW50ZW4sIGRpZSBkdXJjaCBTdGV1ZXJlcmxl aWNodGVydW5nZW4gZGllIEtvbmp1bmt0dXIgYW5rdXJiZWxuIHNvbGx0ZSwgZ2V3YW5uIGltIE1h aSAyMDAzIEdlc2V0emVza3JhZnQuPC9wPgk8cD5JbSBOb3ZlbWJlciAyMDAzIGdlbGFuZyBlcyBQ csOkc2lkZW50IEJ1c2gsIGVpbmUgTWVocmhlaXQgZsO8ciBlaW5lIHVtZmFuZ3JlaWNoZSBHZXN1 bmRoZWl0c3JlZm9ybSBtaXQgRWluZsO8aHJ1bmcgc3RhYXRsaWNoZXIgWnVzY2jDvHNzZSBmw7xy IE1lZGlrYW1lbnRlIGltIFJhaG1lbiBkZXIgPGEgaHJlZj0iL3dpa2kvTWVkaWNhcmVfKFZlcmVp bmlndGVfU3RhYXRlbikiIHRpdGxlPSJNZWRpY2FyZSAoVmVyZWluaWd0ZSBTdGFhdGVuKSI+TWVk aWNhcmU8L2E+LVZlcnNpY2hlcnVuZyB6dSBnZXdpbm5lbi48L3A+CTxwPkltIEphbnVhciAyMDA0 IGvDvG5kaWd0ZSBQcsOkc2lkZW50IEJ1c2ggYW4sIGRlciBXZWx0cmF1bWJlaMO2cmRlIDxhIGhy ZWY9Ii93aWtpL05hdGlvbmFsX0Flcm9uYXV0aWNzX2FuZF9TcGFjZV9BZG1pbmlzdHJhdGlvbiIg dGl0bGU9Ik5hdGlvbmFsIEFlcm9uYXV0aWNzIGFuZCBTcGFjZSBBZG1pbmlzdHJhdGlvbiI+TkFT QTwvYT4gTWl0dGVsIGbDvHIgZWluZSBiZW1hbm50ZSBTdGF0aW9uIGF1ZiBkZW0gTW9uZCB6dXIg VmVyZsO8Z3VuZyB6dSBzdGVsbGVuLCBkaWUgYWxzIEJhaG5ob2YgdW5kIFRlc3RsYWJvciBmw7xy IHNww6R0ZXJlIDxhIGhyZWY9Ii93aWtpL0JlbWFubnRlcl9NYXJzZmx1ZyIgdGl0bGU9IkJlbWFu bnRlciBNYXJzZmx1ZyI+RmzDvGdlIHp1bSBNYXJzPC9hPiBkaWVuZW4gc29sbC48L3A+CTxwPkJ1 c2hzIGRlbW9rcmF0aXNjaGVyIEhlcmF1c2ZvcmRlcmVyIGluIGRlciBXYWhsIDIwMDQsIDxhIGhy ZWY9Ii93aWtpL0pvaG5fS2VycnkiIHRpdGxlPSJKb2huIEtlcnJ5Ij5Kb2huIEtlcnJ5PC9hPiwg csOkdW10ZSB1bm1pdHRlbGJhciBuYWNoIGRlciBXYWhsIHNlaW5lIE5pZWRlcmxhZ2UgZWluLCB3 b2JlaSBzaWNoIGRpZXNtYWwgPGEgaHJlZj0iL3dpa2kvT2hpbyIgdGl0bGU9Ik9oaW8iPk9oaW88 L2E+IGFscyBkZXIgYW0gbMOkbmdzdGVuIHrDpGhsZW5kZSB1bmQgd2FobGVudHNjaGVpZGVuZGUg U3RhYXQgZXJ3aWVzLiBCdXNoIGhhdHRlIOKAkyBhdWZncnVuZCBkZXIgZsO8ciBhbWVyaWthbmlz Y2hlIFZlcmjDpGx0bmlzc2Ugc2VociBncm/Dn2VuIFdhaGxiZXRlaWxpZ3VuZyDigJMgbWVociBT dGltbWVuIGFscyBqZWRlciBhbmRlcmUgenV2b3IgZ2V3w6RobHRlIGFtZXJpa2FuaXNjaGUgUHLD pHNpZGVudCBhdWYgc2ljaCB2ZXJlaW5lbiBrw7ZubmVuLiBadW0gZXJzdGVuIE1hbCBzZWl0IDE5 ODggZXJoaWVsdCBkZXIgV2FobHNpZWdlciBhbGxlcmRpbmdzIG5pY2h0IG51ciBkaWUgYWJzb2x1 dGUgTWVocmhlaXQgZGVyIFdhaGxtw6RubmVyc3RpbW1lbiwgc29uZGVybiBhdWNoIGRpZSBkZXIg YWJnZWdlYmVuZW4gV8OkaGxlcnN0aW1tZW4uIEdsZWljaHdvaGwgZ2lidCBlcyBLcml0aWtlciwg dS4mIzE2MDthLiBkZW4gaW0gS2FtcGYgdW0gZWluZW4gUGFybGFtZW50c3NpdHogdW50ZXJsZWdl bmVuIERlbW9rcmF0ZW4gPGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPUplZmZfRmlzaGVyJmFt cDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iSmVmZiBGaXNo ZXIgKFNlaXRlIG5pY2h0IHZvcmhhbmRlbikiPkplZmYgRmlzaGVyPC9hPiwgZGllIGJlaGF1cHRl biwgZGFzcyBudXIgaW4gV2FobGJlemlya2VuLCBpbiBkZW5lbiBlbGVrdHJvbmlzY2hlIFdhaGxt YXNjaGluZW4gZWluZ2VzZXR6dCB3dXJkZW4sIGV4dHJlbWUgQWJ3ZWljaHVuZ2VuIChVbnJlZ2Vs bcOkw59pZ2tlaXRlbikgdm9yZ2Vrb21tZW4gc2VpZW4uIChOw6RoZXJlcyBpbSBIYXVwdGFydGlr ZWwgenVyIDxhIGhyZWY9Ii93aWtpL1ByJUMzJUE0c2lkZW50c2NoYWZ0c3dhaGxfaW5fZGVuX1Zl cmVpbmlndGVuX1N0YWF0ZW5fMjAwNCIgdGl0bGU9IlByw6RzaWRlbnRzY2hhZnRzd2FobCBpbiBk ZW4gVmVyZWluaWd0ZW4gU3RhYXRlbiAyMDA0Ij5QcsOkc2lkZW50ZW53YWhsIGRlciBWZXJlaW5p Z3RlbiBTdGFhdGVuLCAyMDA0PC9hPik8L3A+CTxwPkVpbiBVUy1CdW5kZXNnZXJpY2h0IGluIDxh IGhyZWY9Ii93aWtpL0RldHJvaXQiIHRpdGxlPSJEZXRyb2l0Ij5EZXRyb2l0PC9hPiBoYXQgZXJz dG1hbHMgYW0gMTcuIEF1Z3VzdCAyMDA2IGRhcyB1bXN0cml0dGVuZSBBYmjDtnJwcm9ncmFtbSBk ZXIgUmVnaWVydW5nIGbDvHIgdmVyZmFzc3VuZ3N3aWRyaWcgZXJrbMOkcnQuIERpZSBFbnRzY2hl aWR1bmcgZGVyIFJpY2h0ZXJpbiBpbiBEZXRyb2l0IHN0ZWxsdCBCZW9iYWNodGVybiB6dWZvbGdl IGVpbmVuIGdyb8OfZW4gUsO8Y2tzY2hsYWcgZsO8ciBCdXNoIGluIGRlc3NlbiBLYW1wZiBnZWdl biBkZW4gVGVycm9yaXNtdXMgZGFyLiBCdXNoIGhhdHRlIGRhcyBBYmjDtnJwcm9ncmFtbSBuYWNo IGRlbiBBbnNjaGzDpGdlbiB2b20gMTEuIFNlcHRlbWJlciAyMDAxIHVudGVyIEF1c3NjaGx1c3Mg ZGVyIMOWZmZlbnRsaWNoa2VpdCBnZW5laG1pZ3QuIEVzIGVybGF1YnQgZGVuIEJlaMO2cmRlbiwg aW50ZXJuYXRpb25hbGUgVGVsZWZvbmdlc3Byw6RjaGUgYW1lcmlrYW5pc2NoZXIgQsO8cmdlciBt aXR6dWjDtnJlbiB1bmQgYXVjaCBFLU1haWxzIGFienVmYW5nZW4sIG9obmUgZGFmw7xyIGVpbmUg cmljaHRlcmxpY2hlIEdlbmVobWlndW5nIGJlYW50cmFnZW4genUgbcO8c3Nlbi4gRGFzIGdlaGVp bWUgUHJvZ3JhbW0gd2FyIDIwMDUgYXVmZ2VkZWNrdCB1bmQgZGFyYXVmaGluIGhlZnRpZyBrcml0 aXNpZXJ0IHdvcmRlbi48L3A+CTxoMz48c3BhbiBjbGFzcz0ibXctaGVhZGxpbmUiIGlkPSJad2Vp dGVfQW10c3plaXRfYWxzX1ByLkMzLkE0c2lkZW50Ij5ad2VpdGUgQW10c3plaXQgYWxzIFByw6Rz aWRlbnQ8L3NwYW4+PC9oMz4JPGRpdiBjbGFzcz0idGh1bWIgdHJpZ2h0Ij4JPGRpdiBjbGFzcz0i dGh1bWJpbm5lciIgc3R5bGU9IndpZHRoOjIyMnB4OyI+PGEgaHJlZj0iL3cvaW5kZXgucGhwP3Rp dGxlPURhdGVpOk1lcmtlbEJ1c2hXYXNoaW5ndG9uMS5qcGcmYW1wO2ZpbGV0aW1lc3RhbXA9MjAw NjAxMTMyMDUwNTEiIGNsYXNzPSJpbWFnZSI+PGltZyBhbHQ9IiIgc3JjPSJodHRwOi8vdXBsb2Fk Lndpa2ltZWRpYS5vcmcvd2lraXBlZGlhL2NvbW1vbnMvdGh1bWIvNS81Yy9NZXJrZWxCdXNoV2Fz aGluZ3RvbjEuanBnLzIyMHB4LU1lcmtlbEJ1c2hXYXNoaW5ndG9uMS5qcGciIHdpZHRoPSIyMjAi IGhlaWdodD0iMTQ3IiBjbGFzcz0idGh1bWJpbWFnZSIgLz48L2E+CTxkaXYgY2xhc3M9InRodW1i Y2FwdGlvbiI+CTxkaXYgY2xhc3M9Im1hZ25pZnkiPjxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRs ZT1EYXRlaTpNZXJrZWxCdXNoV2FzaGluZ3RvbjEuanBnJmFtcDtmaWxldGltZXN0YW1wPTIwMDYw MTEzMjA1MDUxIiBjbGFzcz0iaW50ZXJuYWwiIHRpdGxlPSJ2ZXJncsO2w59lcm4iPjxpbWcgc3Jj PSJodHRwOi8vYml0cy53aWtpbWVkaWEub3JnL3NraW5zLTEuNS9jb21tb24vaW1hZ2VzL21hZ25p ZnktY2xpcC5wbmciIHdpZHRoPSIxNSIgaGVpZ2h0PSIxMSIgYWx0PSIiIC8+PC9hPjwvZGl2PglC dXNoIG1pdCA8YSBocmVmPSIvd2lraS9BbmdlbGFfTWVya2VsIiB0aXRsZT0iQW5nZWxhIE1lcmtl bCI+QW5nZWxhIE1lcmtlbDwvYT4gYmVpIGlocmVtIEFudHJpdHRzYmVzdWNoPC9kaXY+CTwvZGl2 Pgk8L2Rpdj4JPHA+SW0gS2FiaW5ldHQgQnVzaHMgZGVyIHp3ZWl0ZW4gQW10c3BlcmlvZGUgd3Vy ZGUgZXR3YSBkaWUgSMOkbGZ0ZSBkZXIgTWluaXN0ZXIgYXVzZ2V0YXVzY2h0LiBBdcOfZW5taW5p c3RlciA8YSBocmVmPSIvd2lraS9Db2xpbl9Qb3dlbGwiIHRpdGxlPSJDb2xpbiBQb3dlbGwiPkNv bGluIFBvd2VsbDwvYT4sIGRlciBzY2hvbiBpbSBOb3ZlbWJlciBzZWluZW4gUsO8Y2t0cml0dCBl cmtsw6RydCBoYXR0ZSwgd3VyZGUgZHVyY2ggPGEgaHJlZj0iL3dpa2kvQ29uZG9sZWV6emFfUmlj ZSIgdGl0bGU9IkNvbmRvbGVlenphIFJpY2UiPkNvbmRvbGVlenphIFJpY2U8L2E+IGVyc2V0enQu PC9wPgk8cD5JbiBkZXIgQW5zcHJhY2hlIHNlaW5lciB6d2VpdGVuIEFtdHNlaW5zZXR6dW5nIGlt IEphbnVhciAyMDA1IGVya2zDpHJ0ZSBCdXNoLCBkYXNzIGVzIG51biBkaWUgUG9saXRpayBkZXIg VmVyZWluaWd0ZW4gU3RhYXRlbiB3w6RyZSwgVHlyYW5uZWllbiBhdWYgZGVyIFdlbHQgenUgYmVl bmRlbiwgdW5kIGRhc3MgZGFzIMOcYmVybGViZW4gZGVyIGFtZXJpa2FuaXNjaGVuIEZyZWloZWl0 IHZvbiBkZXIgRnJlaWhlaXQgamVkZXMgYW5kZXJlbiBMYW5kZXMgYWJow6RuZ2UuPC9wPgk8cD5B bmZhbmcgMjAwNSBzZXR6dGUgQnVzaCBkdXJjaCwgZGFzcyBkZXIgdm9ybWFscyBzdGVsbHZlcnRy ZXRlbmRlIFZlcnRlaWRpZ3VuZ3NtaW5pc3RlciA8YSBocmVmPSIvd2lraS9QYXVsX1dvbGZvd2l0 eiIgdGl0bGU9IlBhdWwgV29sZm93aXR6Ij5QYXVsIFdvbGZvd2l0ejwvYT4gUHLDpHNpZGVudCBk ZXIgPGEgaHJlZj0iL3dpa2kvV2VsdGJhbmsiIHRpdGxlPSJXZWx0YmFuayI+V2VsdGJhbms8L2E+ IHd1cmRlLiBBbSAxLiBBdWd1c3QgMjAwNSBiZXN0aW1tdGUgZXIgcGVyIERla3JldCBkZW4gVU5P LUtyaXRpa2VyIDxhIGhyZWY9Ii93aWtpL0pvaG5fUi5fQm9sdG9uIiB0aXRsZT0iSm9obiBSLiBC b2x0b24iPkpvaG4gUi4gQm9sdG9uPC9hPiB6dW0gbmV1ZW4gVU5PLUJvdHNjaGFmdGVyIGRlciBW ZXJlaW5pZ3RlbiBTdGFhdGVuLiAoRGllIEJlc2V0enVuZyBkaWVzZXMgUG9zdGVucyBpc3QgZWln ZW50bGljaCB6dXN0aW1tdW5nc3BmbGljaHRpZyBkdXJjaCBkZW4gPGEgaHJlZj0iL3dpa2kvU2Vu YXRfZGVyX1ZlcmVpbmlndGVuX1N0YWF0ZW4iIHRpdGxlPSJTZW5hdCBkZXIgVmVyZWluaWd0ZW4g U3RhYXRlbiI+U2VuYXQ8L2E+LCBpbiBkZXIgU29tbWVycGF1c2Uga2FubiBkZXIgUHLDpHNpZGVu dCBkaWVzIHVudGVyIGJlc3RpbW10ZW4gZm9ybWFsZW4gVm9yYXVzc2V0enVuZ2VuIHVtZ2VoZW4u KSBCb2x0b24gd2FyIHZvbiBkZXIgZGVtb2tyYXRpc2NoZW4gT3Bwb3NpdGlvbiBzb3dpZSB2b24g VGVpbGVuIGRlciBSZXB1Ymxpa2FuZXIgYWJnZWxlaG50IHdvcmRlbi48L3A+CTxwPkFtIDI5LiBB dWd1c3QgMjAwNSB0cmFmIGRlciA8YSBocmVmPSIvd2lraS9IdXJyaWthbl9LYXRyaW5hIiB0aXRs ZT0iSHVycmlrYW4gS2F0cmluYSI+SHVycmlrYW4gS2F0cmluYTwvYT4gYXVmIGRpZSBhbWVyaWth bmlzY2hlIFPDvGRrw7xzdGUgdW5kIGzDtnN0ZSBlaW5lIGRlciB2ZXJoZWVyZW5kc3RlbiBOYXR1 cmthdGFzdHJvcGhlbiBpbiBkZXIgR2VzY2hpY2h0ZSBkZXIgVmVyZWluaWd0ZW4gU3RhYXRlbiBh dXMuIERpZSBTdGFkdCA8YSBocmVmPSIvd2lraS9OZXdfT3JsZWFucyIgdGl0bGU9Ik5ldyBPcmxl YW5zIj5OZXcgT3JsZWFuczwvYT4sIGRpZSBudXIgbWFuZ2VsaGFmdCBhdWYgZGllIE5hdHVya2F0 YXN0cm9waGUgdm9yYmVyZWl0ZXQgd2FyLCB3dXJkZSDDvGJlcmZsdXRldC4gRXR3YSAxODAwIE1l bnNjaGVuIGthbWVuIHVtcyBMZWJlbiB1bmQgZGVyIFN0dXJtIHJpY2h0ZXRlIFNhY2hzY2jDpGRl biBpbSBXZXJ0IHZvbiA4MSBNaWxsaWFyZGVuIERvbGxhciBhbi4gSW4gZGllc2VtIFp1c2FtbWVu aGFuZyBlcmZ1aHIgQnVzaCBoZWZ0aWdlIEtyaXRpayBhbiBzZWluZW0gVm9yZ2VoZW4gdm9yIHVu ZCBuYWNoIGRlciBLYXRhc3Ryb3BoZSBkdXJjaCBkaWUgYW1lcmlrYW5pc2NoZW4gTWVkaWVuIHVu ZCB2aWVsZSBCZXRyb2ZmZW5lLiBJbnNiZXNvbmRlcmUgd3VyZGUgZGllIE5vdGZhbGxwbGFudW5n IGtyaXRpc2llcnQsIGRhIGVzIGtlaW5lIG5hdGlvbmFsZW4gRXZha3VpZXJ1bmdzcGzDpG5lIGdh YiB1bmQgQnVzaCBlaW5lIEtvbmdyZXNzc3R1ZGllIGbDvHIgZGVuIFNjaHV0eiB2b24gU3TDpGR0 ZW4gdm9yIEh1cnJpa2FuZW4gZGVyIFN0w6Rya2UgNSBhdWYgRWlzIGdlbGVndCBoYXR0ZS4gRGll IEhhdXNoYWx0c21pdHRlbCBmw7xyIEthdGFzdHJvcGhlbi0gdW5kIEhlaW1hdHNjaHV0eiB3dXJk ZW4gc3RhdHRkZXNzZW4gdGVpbHdlaXNlIGbDvHIgZGVuIElyYWtrcmllZyBnZW51dHp0LiBFYmVu c28gd3VyZGUgaWhtIHZvcmdld29yZmVuLCByZWNodHplaXRpZ2UgTWFobnVuZ2VuIHp1ciBWZXJz dMOkcmt1bmcgZGVyIERlaWNoZSBtaXNzYWNodGV0IHp1IGhhYmVuOiBCdXNoIGhhdHRlIGRlbiBD aGVmIGRlciBmw7xyIGRlbiBEZWljaGJhdSB6dXN0w6RuZGlnZW4gQmVow7ZyZGUgMjAwMiBlbnRs YXNzZW4sIG5hY2hkZW0gZGllc2VyIGRlbSBLb25ncmVzcyBQbMOkbmUgZsO8ciBlaW4gMTg4IE1p bGxpb25lbiBEb2xsYXIgdGV1cmVzIEZsdXR1bmdzcHJvamVrdCBhbSB1bnRlcmVuIE1pc3Npc3Np cHBpIHZvcmdlbGVndCBoYXR0ZS4gSW4gSW50ZXJ2aWV3cyBBbmZhbmcgU2VwdGVtYmVyIGJlaGF1 cHRldGUgQnVzaCBoaW5nZWdlbjogPGk+TmllbWFuZCBrb25udGUgZGVuIEJydWNoIGRlciBEZWlj aGUgdm9yYXVzc2VoZW4uPC9pPjxzdXAgaWQ9ImNpdGVfcmVmLTMiIGNsYXNzPSJyZWZlcmVuY2Ui PjxhIGhyZWY9IiNjaXRlX25vdGUtMyI+WzRdPC9hPjwvc3VwPjwvcD4JPHA+WnUgQnVzaHMgYmVk ZXV0ZW5kZXJlbiBpbm5lbnBvbGl0aXNjaGVuIEVyZm9sZ2VuIGluIGRlciB6d2VpdGVuIEFtdHN6 ZWl0IGdlaMO2cmVuIGRpZSBOZXViZXNldHp1bmdlbiB6d2VpZXIgU2l0emUgYW0gbcOkY2h0aWdl biA8aT5TdXByZW1lIENvdXJ0PC9pPi4gQW0gNS4gU2VwdGVtYmVyIDIwMDUgbm9taW5pZXJ0ZSBl ciA8YSBocmVmPSIvd2lraS9Kb2huX0cuX1JvYmVydHNfanVuaW9yIiB0aXRsZT0iSm9obiBHLiBS b2JlcnRzIGp1bmlvciIgY2xhc3M9Im13LXJlZGlyZWN0Ij5Kb2huIEcuIFJvYmVydHMganVuaW9y PC9hPiB6dW0gTmFjaGZvbGdlciBhbHMgPGEgaHJlZj0iL3dpa2kvQ2hpZWZfSnVzdGljZV9vZl90 aGVfVW5pdGVkX1N0YXRlcyIgdGl0bGU9IkNoaWVmIEp1c3RpY2Ugb2YgdGhlIFVuaXRlZCBTdGF0 ZXMiPkNoaWVmIEp1c3RpY2U8L2E+IGbDvHIgZGVuIHZlcnN0b3JiZW5lbiA8YSBocmVmPSIvd2lr aS9XaWxsaWFtX0guX1JlaG5xdWlzdCIgdGl0bGU9IldpbGxpYW0gSC4gUmVobnF1aXN0Ij5XaWxs aWFtIEguIFJlaG5xdWlzdDwvYT4uIE5hY2ggZGVzc2VuIEJlc3TDpHRpZ3VuZyBkdXJjaCBkZW4g U2VuYXQgbm9taW5pZXJ0ZSBCdXNoIGFtIDMuIE9rdG9iZXIgMjAwNSBzZWluZSBSZWNodHNiZXJh dGVyaW4gPGEgaHJlZj0iL3dpa2kvSGFycmlldF9NaWVycyIgdGl0bGU9IkhhcnJpZXQgTWllcnMi PkhhcnJpZXQgTWllcnM8L2E+IGFscyBOYWNoZm9sZ2VyaW4gZGVyIHp1csO8Y2tnZXRyZXRlbmVu IDxhIGhyZWY9Ii93aWtpL1NhbmRyYV9EYXlfTyVFMiU4MCU5OUNvbm5vciIgdGl0bGU9IlNhbmRy YSBEYXkgT+KAmUNvbm5vciI+U2FuZHJhIERheSBP4oCZQ29ubm9yPC9hPiBhbHMgUmljaHRlcmlu IGFtIE9iZXJzdGVuIEdlcmljaHRzaG9mIGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuLCB6b2cgZGll cyBhYmVyIG5hY2ggYXXDn2VyZ2V3w7ZobmxpY2ggc3RhcmtlciBLcml0aWsgYXVzIGFsbGVuIHBv bGl0aXNjaGVuIExhZ2VybiBhbSAyNy4gT2t0b2JlciAyMDA1IGF1ZiBNaWVyc+KAmSBCaXR0ZSBo aW4genVyw7xjayB1bmQgbm9taW5pZXJ0ZSBzdGF0dGRlc3NlbiA8YSBocmVmPSIvd2lraS9TYW11 ZWxfQWxpdG8iIHRpdGxlPSJTYW11ZWwgQWxpdG8iPlNhbXVlbCBBbGl0bzwvYT4sIGRlciBhbSAz MS4gSmFudWFyIDIwMDYgbWl0IGtuYXBwZXIgTWVocmhlaXQgdm9tIFNlbmF0IGJlc3TDpHRpZ3Qg d3VyZGUuPC9wPgk8ZGl2IGNsYXNzPSJ0aHVtYiB0bGVmdCI+CTxkaXYgY2xhc3M9InRodW1iaW5u ZXIiIHN0eWxlPSJ3aWR0aDozMzJweDsiPjxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1EYXRl aTpCdXNoX2FkZHJlc3Nlc19tZWRpYV9vbl9Jc3JhZWwtTGViYW5vbl93X0NoZW5leV9BdWdfMTRf MjAwNi5qcGcmYW1wO2ZpbGV0aW1lc3RhbXA9MjAwNjA4MTUwMTA3MzEiIGNsYXNzPSJpbWFnZSI+ PGltZyBhbHQ9IiIgc3JjPSJodHRwOi8vdXBsb2FkLndpa2ltZWRpYS5vcmcvd2lraXBlZGlhL2Nv bW1vbnMvdGh1bWIvNC80ZS9CdXNoX2FkZHJlc3Nlc19tZWRpYV9vbl9Jc3JhZWwtTGViYW5vbl93 X0NoZW5leV9BdWdfMTRfMjAwNi5qcGcvMzMwcHgtQnVzaF9hZGRyZXNzZXNfbWVkaWFfb25fSXNy YWVsLUxlYmFub25fd19DaGVuZXlfQXVnXzE0XzIwMDYuanBnIiB3aWR0aD0iMzMwIiBoZWlnaHQ9 IjIyMCIgY2xhc3M9InRodW1iaW1hZ2UiIC8+PC9hPgk8ZGl2IGNsYXNzPSJ0aHVtYmNhcHRpb24i Pgk8ZGl2IGNsYXNzPSJtYWduaWZ5Ij48YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9RGF0ZWk6 QnVzaF9hZGRyZXNzZXNfbWVkaWFfb25fSXNyYWVsLUxlYmFub25fd19DaGVuZXlfQXVnXzE0XzIw MDYuanBnJmFtcDtmaWxldGltZXN0YW1wPTIwMDYwODE1MDEwNzMxIiBjbGFzcz0iaW50ZXJuYWwi IHRpdGxlPSJ2ZXJncsO2w59lcm4iPjxpbWcgc3JjPSJodHRwOi8vYml0cy53aWtpbWVkaWEub3Jn L3NraW5zLTEuNS9jb21tb24vaW1hZ2VzL21hZ25pZnktY2xpcC5wbmciIHdpZHRoPSIxNSIgaGVp Z2h0PSIxMSIgYWx0PSIiIC8+PC9hPjwvZGl2PglCdXNoIG1pdCBWaXplcHLDpHNpZGVudCBEaWNr IENoZW5leSAoMjAwNik8L2Rpdj4JPC9kaXY+CTwvZGl2Pgk8cD5FYmVuZmFsbHMgaW0gT2t0b2Jl ciBzcGl0enRlIHNpY2ggZGllIHNvZ2VuYW5udGUgPGEgaHJlZj0iL3dpa2kvUGxhbWUtQWZmJUMz JUE0cmUiIHRpdGxlPSJQbGFtZS1BZmbDpHJlIj5QbGFtZS1BZmbDpHJlPC9hPiB6dSwgYmVpIGRl ciBob2NocmFuZ2lnZSBNaXRnbGllZGVyIGRlciBCdXNoLVJlZ2llcnVuZyBiZXNjaHVsZGlndCB3 dXJkZW4sIGRpZSBJZGVudGl0w6R0IGRlciBDSUEtQWdlbnRpbiB1bmQgRnJhdSBkZXMgQnVzaC1r cml0aXNjaGVuIERpcGxvbWF0ZW4gSm9zZXBoIFdpbHNvbiwgVmFsZXJ5IFBsYW1lIGFuIGRpZSBQ cmVzc2Ugd2VpdGVyZ2VnZWJlbiB6dSBoYWJlbi4gPGEgaHJlZj0iL3dpa2kvTGV3aXNfTGliYnki IHRpdGxlPSJMZXdpcyBMaWJieSI+TGV3aXMgTGliYnk8L2E+LCBTdGFic2NoZWYgdm9uIFZpemVw csOkc2lkZW50IDxhIGhyZWY9Ii93aWtpL0RpY2tfQ2hlbmV5IiB0aXRsZT0iRGljayBDaGVuZXki PkRpY2sgQ2hlbmV5PC9hPiwgd3VyZGUgdW50ZXIgYW5kZXJlbSB3ZWdlbiA8YSBocmVmPSIvd2lr aS9NZWluZWlkIiB0aXRsZT0iTWVpbmVpZCI+TWVpbmVpZHM8L2E+IHVuZCBCZWhpbmRlcnVuZyBk ZXIgSnVzdGl6IHZlcmhhZnRldC4gV2VpdGVyZSBCZXNjaHVsZGlndGUgc2luZCBSaWNoYXJkIENo ZW5leSB1bmQgPGEgaHJlZj0iL3dpa2kvS2FybF9Sb3ZlIiB0aXRsZT0iS2FybCBSb3ZlIj5LYXJs IFJvdmU8L2E+LCBlaW5lciBkZXIgd2ljaHRpZ3N0ZW4gQmVyYXRlciBCdXNocy4gSW0gQXByaWwg MjAwNiB3dXJkZW4gZGVzc2VuIEF1ZmdhYmVuYmVyZWljaCBhbHMgQmVyYXRlciB2ZXLDpG5kZXJ0 IHVuZCBpaG0gZGllIFBsYW51bmcgZGVzIFdhaGxrYW1wZmVzIGRlciBLb25ncmVzc3dhaGxlbiBp bSBOb3ZlbWJlciDDvGJlcnRyYWdlbi48L3A+CTxwPkluIGRlciBzZWl0IDIwMDYgaW4gZGVuIFZl cmVpbmlndGVuIFN0YWF0ZW4gaGVmdGlnIGdlZsO8aHJ0ZW4gRGViYXR0ZSB1bSBkYXMgQXVmZW50 aGFsdHNyZWNodCBpbGxlZ2FsaXNpZXJ0ZXIgKGhpc3BhbmlzY2hlciwgenVtZWlzdCBtZXhpa2Fu aXNjaGVyKSBFaW53YW5kZXJlciBuaW1tdCBCdXNoIGVpbmUgZWhlciBsaWJlcmFsZSBIYWx0dW5n IGVpbiB1bmQgYmVmw7xyd29ydGV0IGVybGVpY2h0ZXJ0ZSBBdWZlbnRoYWx0c2JlZGluZ3VuZ2Vu IGbDvHIgYmVyZWl0cyBpbSBJbmxhbmQgYmVmaW5kbGljaGUgRWlud2FuZGVyZXIsIMO8YmVyd2ll Z2VuZCBtaXQgZGVtIEhpbndlaXMsIGRhc3MgZGllIFZlcmVpbmlndGVuIFN0YWF0ZW4gZWluIHRy YWRpdGlvbmVsbGVzIEVpbndhbmRlcnVuZ3NsYW5kIHNpbmQuIFNlaW5lIGxpYmVyYWxlIEhhbHR1 bmcgaW4gZGllc2VyIERpc2t1c3Npb24gd2lyZCBkYWJlaSB2b24gZGVuIE1lZGllbiBvZnQgbWl0 IHNlaW5lciBIZXJrdW5mdCBhdXMgVGV4YXMsIGRlbSBhbSBzdMOkcmtzdGVuIG1leGlrYW5pc2No IGdlcHLDpGd0ZW4gQnVuZGVzc3RhYXQsIGluIFp1c2FtbWVuaGFuZyBnZWJyYWNodC4gQmVpIG5l b2tvbnNlcnZhdGl2ZW4gS3JlaXNlbiBzZWluZXIgUGFydGVpIHN0w7bDn3QgZGllc2UgSGFsdHVu ZyBhdWYgYmlzd2VpbGVuIGhhcnNjaGUgS3JpdGlrLiBHbGVpY2h3b2hsIHVudGVyemVpY2huZXQg R2VvcmdlIFcuIEJ1c2ggRW5kZSBPa3RvYmVyIDIwMDYgZWluIEdlc2V0eiB6dW0gQXVzYmF1IGRl ciA8YSBocmVmPSIvd2lraS9HcmVuemVfendpc2NoZW5fZGVuX1ZlcmVpbmlndGVuX1N0YWF0ZW5f dW5kX01leGlrbyIgdGl0bGU9IkdyZW56ZSB6d2lzY2hlbiBkZW4gVmVyZWluaWd0ZW4gU3RhYXRl biB1bmQgTWV4aWtvIj5HcmVuemUgenUgTWV4aWtvPC9hPiwgd2FzIHZvbiBkZXIgbWV4aWthbmlz Y2hlbiBSZWdpZXJ1bmcgbWFzc2l2IGtyaXRpc2llcnQgd2lyZC48c3VwIGlkPSJjaXRlX3JlZi00 IiBjbGFzcz0icmVmZXJlbmNlIj48YSBocmVmPSIjY2l0ZV9ub3RlLTQiPls1XTwvYT48L3N1cD48 L3A+CTxwPkdlb3JnZSBXLiBCdXNoIHdhciBzZWl0IEppbW15IENhcnRlciBpbSBKYWhyIDE5Nzkg ZGVyIGVyc3RlIGFtZXJpa2FuaXNjaGUgUHLDpHNpZGVudCwgZGVyIDxhIGhyZWY9Ii93aWtpLyVD MyU5NnN0ZXJyZWljaCIgdGl0bGU9IsOWc3RlcnJlaWNoIj7DlnN0ZXJyZWljaDwvYT4gYmVzdWNo dGU7IEJ1c2hzIEJlc3VjaCBhbSAyMC4gdW5kIDIxLiBKdW5pIDIwMDYgZsO8aHJ0ZSBpaG4gbWl0 IGRlbSBkYW1hbHMgYW10aWVyZW5kZW4gRVUtUmF0c3Byw6RzaWRlbnRlbiB1bmQgw7ZzdGVycmVp Y2hpc2NoZW4gQnVuZGVza2FuemxlciA8YSBocmVmPSIvd2lraS9Xb2xmZ2FuZ19TY2glQzMlQkNz c2VsIiB0aXRsZT0iV29sZmdhbmcgU2Now7xzc2VsIj5Xb2xmZ2FuZyBTY2jDvHNzZWw8L2E+IHVu ZCBtaXQgQnVuZGVzcHLDpHNpZGVudCA8YSBocmVmPSIvd2lraS9IZWluel9GaXNjaGVyIiB0aXRs ZT0iSGVpbnogRmlzY2hlciI+SGVpbnogRmlzY2hlcjwvYT4genVzYW1tZW4uIEJlaSBkZW4gTWlk dGVybS1FbGVjdGlvbnMgMjAwNiBlcmxpdHRlbiBkaWUgUmVwdWJsaWthbmVyIHVudGVyIEJ1c2gg ZWluZSBOaWVkZXJsYWdlIHVuZCB2ZXJsb3JlbiBzb3dvaGwgZGllIE1laHJoZWl0IGltIDxhIGhy ZWY9Ii93aWtpL1JlcHIlQzMlQTRzZW50YW50ZW5oYXVzX2Rlcl9WZXJlaW5pZ3Rlbl9TdGFhdGVu IiB0aXRsZT0iUmVwcsOkc2VudGFudGVuaGF1cyBkZXIgVmVyZWluaWd0ZW4gU3RhYXRlbiI+UmVw csOkc2VudGFudGVuaGF1czwvYT4gYWxzIGF1Y2ggZGllIE1laHJoZWl0IGltIDxhIGhyZWY9Ii93 aWtpL1NlbmF0X2Rlcl9WZXJlaW5pZ3Rlbl9TdGFhdGVuIiB0aXRsZT0iU2VuYXQgZGVyIFZlcmVp bmlndGVuIFN0YWF0ZW4iPlNlbmF0PC9hPi4gRGFzIGJlc3RpbW1lbmRlIFRoZW1hIGRlciBXYWhs ZW4gd2FyIGRlciBJcmFra3JpZWcuIE5hY2ggZGVyIFdhaGwgZ2FiIEJ1c2ggZGVuIHNjaG9uIGzD pG5nZXIgZ2VwbGFudGVuIFLDvGNrdHJpdHQgZGVzIFZlcnRlaWRpZ3VuZ3NtaW5pc3RlcnMgUnVt c2ZlbGQgYmVrYW5udCB1bmQgZXJuYW5udGUgZGVuIENJQS1NYW5uIDxhIGhyZWY9Ii93aWtpL1Jv YmVydF9HYXRlcyIgdGl0bGU9IlJvYmVydCBHYXRlcyI+Um9iZXJ0IEdhdGVzPC9hPiB6dSBkZXNz ZW4gTmFjaGZvbGdlci48L3A+CTxwPkltIFNvbW1lciAyMDA3IHpvZ2VuIHNpY2ggbWVocmVyZSBo b2NocmFuZ2lnZSBNaXRhcmJlaXRlciBkZXIgQnVzaC1SZWdpZXJ1bmcgenVyw7xjay4gUHJlc3Nl c3ByZWNoZXIgPGEgaHJlZj0iL3dpa2kvVG9ueV9Tbm93IiB0aXRsZT0iVG9ueSBTbm93Ij5Ub255 IFNub3c8L2E+IGF1cyBwZXJzw7ZubGljaGVuIEdyw7xuZGVuLCBLYXJsIFJvdmUgdW5kIGRlciBK dXN0aXptaW5pc3RlciA8YSBocmVmPSIvd2lraS9BbGJlcnRvX1IuX0dvbnphbGVzIiB0aXRsZT0i QWxiZXJ0byBSLiBHb256YWxlcyI+QWxiZXJ0byBSLiBHb256YWxlczwvYT4gamVkb2NoIG5hY2gg ZWluZXIgQWZmw6RyZSB1bSBkaWUgRW50bGFzc3VuZyB6YWhscmVpY2hlciBCdW5kZXNhbnfDpGx0 ZSwgbcO2Z2xpY2hlcndlaXNlIGF1cyBwb2xpdGlzY2hlbiBHcsO8bmRlbi4gSW0gTcOkcnogMjAw OCBsZWd0ZSBCdXNoIHNlaW4gVmV0byBnZWdlbiBlaW4gR2VzZXR6IGVpbiwgd2VsY2hlcyB1bnRl ciBhbmRlcmVtIGRpZSBBbndlbmR1bmcgZGVyIGFscyA8YSBocmVmPSIvd2lraS9XYXRlcmJvYXJk aW5nIiB0aXRsZT0iV2F0ZXJib2FyZGluZyI+V2F0ZXJib2FyZGluZzwvYT4gYmVrYW5udGVuIDxh IGhyZWY9Ii93aWtpL0ZvbHRlciIgdGl0bGU9IkZvbHRlciI+Rm9sdGVybWV0aG9kZTwvYT4gZHVy Y2ggZGllIENJQSB2ZXJoaW5kZXJuIHNvbGx0ZS4gQnVzaCBlcmtsw6RydGUsIGRhc3MgZGllIGF1 ZiBzb2xjaGUgV2Vpc2UgZXJ6aWVsdGVuIEVyZm9sZ2UgZGllc2UgQXJ0IHZvbiBGb2x0ZXIgcmVj aHRmZXJ0aWd0ZW4uIEdlZ2VuIGRpZSBBbndlbmR1bmcgZGVyIE1ldGhvZGUgaGF0dGVuIHNpY2gg enV2b3IgYXVjaCByYW5naG9oZSBNaWxpdMOkcnMgZGVyIFZlcmVpbmlndGVuIFN0YWF0ZW4gZ2V3 YW5kdC48c3VwIGlkPSJjaXRlX3JlZi01IiBjbGFzcz0icmVmZXJlbmNlIj48YSBocmVmPSIjY2l0 ZV9ub3RlLTUiPls2XTwvYT48L3N1cD4gQW0gMTYuIEFwcmlsIDIwMDggZmVpZXJ0ZSBkZXIgUHLD pHNpZGVudCB6dXNhbW1lbiBtaXQgUGFwc3QgPGEgaHJlZj0iL3dpa2kvQmVuZWRpa3RfWFZJLiIg dGl0bGU9IkJlbmVkaWt0IFhWSS4iPkJlbmVkaWt0IFhWSS48L2E+LCBkZXIgaW0gUmFobWVuIGVp bmVyIGFwb3N0b2xpc2NoZW4gUmVpc2UgZGllIFZlcmVpbmlndGVuIFN0YWF0ZW4gYmVzdWNodGUs IGRlc3NlbiA4MS4gR2VidXJ0c3RhZyB6dXNhbW1lbiBtaXQgOTAwMCBHw6RzdGVuIGltIFdlacOf ZW4gSGF1cy48L3A+CTxwPkFtIDI4LiBKdWxpIDIwMDggc3RpbW10ZSBlciwgYWxzIGVyc3RlciBQ csOkc2lkZW50IHNlaXQgNTEgSmFocmVuLCBkZXIgVG9kZXNzdHJhZmUgZ2VnZW4gZWluZW4gdmVy dXJ0ZWlsdGVuIDxhIGhyZWY9Ii93aWtpL1NvbGRhdCIgdGl0bGU9IlNvbGRhdCI+YW1lcmlrYW5p c2NoZW4gTWlsaXTDpHJhbmdlaMO2cmlnZW48L2E+IHp1LiA8c3VwIGlkPSJjaXRlX3JlZi02IiBj bGFzcz0icmVmZXJlbmNlIj48YSBocmVmPSIjY2l0ZV9ub3RlLTYiPls3XTwvYT48L3N1cD48L3A+ CTxwPkRpZSBsZXR6dGVuIE1vbmF0ZSB2b24gQnVzaHMgQW10c3plaXQgd3VyZGVuIGR1cmNoIGRp ZSBpbnRlcm5hdGlvbmFsZSBGaW5hbnprcmlzZSDDvGJlcnNjaGF0dGV0LCBiZWkgZGVyIGJpcyB6 dSBzZWluZW0gQXVzc2NoZWlkZW4gYXVzIGRlbSBBbXQsIHZpZWxlIEJhbmtlbiBkZXMgTGFuZGVz IGVudHdlZGVyIGluIGVpbmUgU2NoaWVmbGFnZSBnZXJpZXRlbiBvZGVyIHNvZ2FyIEtvbmt1cnMg YW5tZWxkZW4gbXVzc3Rlbi4gRHVyY2ggQnVzaHMgZ2VzY2h3w6RjaHRlIFBvc2l0aW9uIGltIEtv bmdyZXNzLCBtdXNzdGUgZXIgYmVpIGRlbSBlcnN0ZW4gUmV0dHVuZ3NwYWtldCBuaWNodCBudXIg dW0gZGllIFp1c3RpbW11bmcgZGVyIERlbW9rcmF0ZW4sIHNvbmRlcm4gYXVjaCBiZWkgc2VpbmVu IGVpZ2VuZW4gUGFydGVpZnJldW5kZW4gdW0gQmlsbGlndW5nIHdlcmJlbiwgZGllIHNpY2ggenVu ZWhtZW5kIHdlZ2VuIHNlaW5lciBVbnBvcHVsYXJpdMOkdCB2b24gaWhtIGRpc3RhbnppZXJ0ZW4u IEFtIDI5LiBTZXB0ZW1iZXIgMjAwOCBzY2hlaXRlcnRlIHRhdHPDpGNobGljaCBlaW4gdm9uIEJ1 c2ggZWluZ2VicmFjaHRlcyBQYWtldCBpbSBLb25ncmVzcywgbmljaHQgenVsZXR6dCB3ZWlsIGlo bSBhdWNoIGVpbmlnZSBQYXJ0ZWlmcmV1bmRlIGRpZSBHZWZvbGdzY2hhZnQgdmVyc2FndGVuLjxz dXAgaWQ9ImNpdGVfcmVmLTciIGNsYXNzPSJyZWZlcmVuY2UiPjxhIGhyZWY9IiNjaXRlX25vdGUt NyI+WzhdPC9hPjwvc3VwPjwvcD4JPGgzPjxzcGFuIGNsYXNzPSJtdy1oZWFkbGluZSIgaWQ9Ikly YWsiPklyYWs8L3NwYW4+PC9oMz4JPHA+RWluIGJlc3RpbW1lbmRlcyBUaGVtYSBkZXIgendlaXRl biBBbXRzemVpdCBCdXNocyBibGllYiBkZXIgSXJhaywgaW4gZGVtIDEzMC4wMDAgYW1lcmlrYW5p c2NoZSB1bmQgMjAuMDAwIGJyaXRpc2NoZSBTb2xkYXRlbiBzdGF0aW9uaWVydCBzaW5kLiBFaW5l IGlyYWtpc2NoZSDDnGJlcmdhbmdzdmVyZmFzc3VuZyB3dXJkZSB2ZXJhYnNjaGllZGV0LCBkZXJl biBaaWVsIGVzIHdhciwgZWluZW4gZGVtb2tyYXRpc2NoZW4gPGEgaHJlZj0iL3dpa2kvQnVuZGVz c3RhYXQjQnVuZGVzc3RhYXRfYWxzX0dlc2FtdHN0YWF0IiB0aXRsZT0iQnVuZGVzc3RhYXQiPkJ1 bmRlc3N0YWF0PC9hPiB6dSBiaWxkZW4sIGluIGRlbSBLdXJkZW4sIFN1bm5pdGVuIHVuZCBTY2hp aXRlbiBnZW1laW5zYW0gbGViZW4ga8O2bm50ZW4uIEFuZmFuZyBKYW51YXIgMjAwNSB3dXJkZSB2 b24gZGVuIElyYWtlcm4gZWluZSDDnGJlcmdhbmdzcmVnaWVydW5nIGdld8OkaGx0IHVuZCBpbSBP a3RvYmVyIMO8YmVyIGVpbmUgbmV1ZSBWZXJmYXNzdW5nIGFiZ2VzdGltbXQuPC9wPgk8cD5TZWl0 IGRlbSBvZmZpemllbGxlbiBFbmRlIGRlciBLYW1wZmhhbmRsdW5nZW4ga2FtIGVzIGltIElyYWsg enUgc3TDpG5kaWdlbiB0ZXJyb3Jpc3Rpc2NoZW4gQW5ncmlmZmVuIHVuZCBzZWl0IDIwMDYgenUg YsO8cmdlcmtyaWVnc8OkaG5saWNoZW4gWnVzdMOkbmRlbiBtaXQgS8OkbXBmZW4gendpc2NoZW4g U2NoaWl0ZW4gdW5kIFN1bm5pdGVuLiBTZWl0IEtyaWVnc2VuZGUgc2luZCB6ZWhudGF1c2VuZGUg SXJha2VyIHVuZCDDvGJlciAxMDAwIGFtZXJpa2FuaXNjaGUgU29sZGF0ZW4gZ2V3YWx0c2FtIHVt cyBMZWJlbiBnZWtvbW1lbi4gQnVzaHMgUG9saXRpayDDpG5kZXJ0ZSBzaWNoIGRhZHVyY2ggamVk b2NoIG5pY2h0LiBEaWUgZGVtb2tyYXRpc2NoZSBPcHBvc2l0aW9uIGtvbm50ZSBzaWNoIG5pY2h0 IGF1ZiBlaW5lbiBnZW1laW5zYW1lbiBBbHRlcm5hdGl2dm9yc2NobGFnIGVpbmlnZW4sIGFsbGVy ZGluZ3Mgd3VjaHMgaW4gQW5iZXRyYWNodCBkZXIgd2FjaHNlbmRlbiBBdXNnYWJlbiBmw7xyIGRl biBLcmllZywgZGVyIGdldMO2dGV0ZW4gQW1lcmlrYW5lciB1bmQgZGVyIGRhZHVyY2ggZXJ6d3Vu Z2VuZW4gbWlsaXTDpHJpc2NoZW4gSGFuZGx1bmdzdW5mw6RoaWdrZWl0IGluIGFuZGVyZW4gS29u Zmxpa3RlbiB3aWUgbWl0IElyYW4gb2RlciBOb3Jka29yZWEsIGRpZSBLcml0aWsuPC9wPgk8cD5J bSBNw6RyeiAyMDA2IHNldHp0ZSBkZXIgS29uZ3Jlc3MgZGllIDxhIGhyZWY9Ii93aWtpL0Jha2Vy LUtvbW1pc3Npb24iIHRpdGxlPSJCYWtlci1Lb21taXNzaW9uIj5CYWtlci1Lb21taXNzaW9uPC9h PiBlaW4sIGVpbmUgemVobmvDtnBmaWdlIEdydXBwZSB1bSBkZW4gZWhlbWFsaWdlbiBBdcOfZW5t aW5pc3RlciA8YSBocmVmPSIvd2lraS9KYW1lc19CYWtlciIgdGl0bGU9IkphbWVzIEJha2VyIj5K YW1lcyBCYWtlcjwvYT4sIHVtIGVpbmUgbmV1ZSBTdHJhdGVnaWUgZsO8ciBkZW4gSXJhayB6dSBl cmFyYmVpdGVuLiBEaWVzZSBsZWd0ZSBpbSBEZXplbWJlciBpaHJlIFZvcnNjaGzDpGdlIHZvciwg dS5BLiBlaW5lbiBBYnp1ZyBhbGxlciBLYW1wZnRydXBwZW4gYXVzIGRlbSBJcmFrIGJpcyAyMDA4 LiBEaWUgZGVtb2tyYXRpc2NoZSBPcHBvc2l0aW9uLCBkaWUgZGllIE1pZHRlcm0tRWxlY3Rpb25z IGdld29ubmVuIGhhdHRlbiwgZm9yZGVydGUgZGFuYWNoIGVpbmUgw4RuZGVydW5nIGRlciBTdHJh dGVnaWUgbWl0IEFienVnIGRlciBhbWVyaWthbmlzY2hlbiBUcnVwcGVuLiBBbSAxMS4gSmFudWFy IDIwMDcgc3RlbGx0ZSBCdXNoIGRhbm4gc2VpbmUgbmV1ZSBJcmFrLVN0cmF0ZWdpZSB2b3IsIGRp ZSBzb2dlbmFubnRlICJTdXJnZSIuIERpZXNlIGxpZcOfIGRpZSBWb3JzY2hsw6RnZSBkZXIgS29t bWlzc2lvbiB1bmQgZGllIEZvcmRlcnVuZ2VuIGRlciBPcHBvc2l0aW9uIHVuYmVyw7xja3NpY2h0 aWd0IHVuZCBoYXR0ZSBkaWUgRW50c2VuZHVuZyB2b24gMjEuMDAwIHdlaXRlcmVuIFNvbGRhdGVu IHp1bSBJbmhhbHQsIHVtIGRpZSBTaXR1YXRpb24genUgYmVmcmllZGVuLiBFaW4gQWJ6dWcgc29s bHRlIHNpY2ggYW5zY2hsaWXDn2VuLCBzb2JhbGQgZGllIGlyYWtpc2NoZSBSZWdpZXJ1bmcgYWxs ZWluZSBpbiBkZXIgTGFnZSBzZWllbiwgZsO8ciBTdGFiaWxpdMOkdCB6dSBzb3JnZW4uPC9wPgk8 aDM+PHNwYW4gY2xhc3M9Im13LWhlYWRsaW5lIiBpZD0iQnVzaF91bmRfRXVyb3BhIj5CdXNoIHVu ZCBFdXJvcGE8L3NwYW4+PC9oMz4JPGRpdiBjbGFzcz0idGh1bWIgdHJpZ2h0Ij4JPGRpdiBjbGFz cz0idGh1bWJpbm5lciIgc3R5bGU9IndpZHRoOjIyMnB4OyI+PGEgaHJlZj0iL3cvaW5kZXgucGhw P3RpdGxlPURhdGVpOlZsYWRpbWlyX1B1dGluX2FuZF9HZW9yZ2VfVy5fQnVzaC5qcGcmYW1wO2Zp bGV0aW1lc3RhbXA9MjAwNzA4MDgyMTE5MzAiIGNsYXNzPSJpbWFnZSI+PGltZyBhbHQ9IiIgc3Jj PSJodHRwOi8vdXBsb2FkLndpa2ltZWRpYS5vcmcvd2lraXBlZGlhL2NvbW1vbnMvdGh1bWIvOS85 NS9WbGFkaW1pcl9QdXRpbl9hbmRfR2VvcmdlX1cuX0J1c2guanBnLzIyMHB4LVZsYWRpbWlyX1B1 dGluX2FuZF9HZW9yZ2VfVy5fQnVzaC5qcGciIHdpZHRoPSIyMjAiIGhlaWdodD0iMTU3IiBjbGFz cz0idGh1bWJpbWFnZSIgLz48L2E+CTxkaXYgY2xhc3M9InRodW1iY2FwdGlvbiI+CTxkaXYgY2xh c3M9Im1hZ25pZnkiPjxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1EYXRlaTpWbGFkaW1pcl9Q dXRpbl9hbmRfR2VvcmdlX1cuX0J1c2guanBnJmFtcDtmaWxldGltZXN0YW1wPTIwMDcwODA4MjEx OTMwIiBjbGFzcz0iaW50ZXJuYWwiIHRpdGxlPSJ2ZXJncsO2w59lcm4iPjxpbWcgc3JjPSJodHRw Oi8vYml0cy53aWtpbWVkaWEub3JnL3NraW5zLTEuNS9jb21tb24vaW1hZ2VzL21hZ25pZnktY2xp cC5wbmciIHdpZHRoPSIxNSIgaGVpZ2h0PSIxMSIgYWx0PSIiIC8+PC9hPjwvZGl2PglHZW9yZ2Ug Vy4gQnVzaCB1bmQgPGEgaHJlZj0iL3dpa2kvV2xhZGltaXJfUHV0aW4iIHRpdGxlPSJXbGFkaW1p ciBQdXRpbiIgY2xhc3M9Im13LXJlZGlyZWN0Ij5XbGFkaW1pciBQdXRpbjwvYT4gaW4gPGEgaHJl Zj0iL3dpa2kvS2VubmVidW5rcG9ydCIgdGl0bGU9Iktlbm5lYnVua3BvcnQiPktlbm5lYnVua3Bv cnQ8L2E+LCBNYWluZSwgaW0gSnVsaSAyMDA3PC9kaXY+CTwvZGl2Pgk8L2Rpdj4JPHA+RGFzIFZl cmjDpGx0bmlzIGRlciBtZWlzdGVuIGV1cm9ww6Rpc2NoZW4gUmVnaWVydW5nZW4genVyIFJlZ2ll cnVuZyBCdXNoIHdhciwgdGVpbHMgaW5mb2xnZSBkZXMgbmVva29uc2VydmF0aXZlbiBQYXJhZGln bWFzIHNlaW5lciBQb2xpdGlrIHVuZCBzZWluZXMgV2VyZGVnYW5ncywgYmVsYXN0ZXQuIE5lYmVu IGRlciBzcGFuaXNjaGVuIHVudGVyIDxhIGhyZWY9Ii93aWtpL0pvcyVDMyVBOV9MdWlzX1JvZHIl QzMlQURndWV6X1phcGF0ZXJvIiB0aXRsZT0iSm9zw6kgTHVpcyBSb2Ryw61ndWV6IFphcGF0ZXJv Ij5aYXBhdGVybzwvYT4gdW5kIGRlciBpdGFsaWVuaXNjaGVuIHVudGVyIDxhIGhyZWY9Ii93aWtp L1JvbWFub19Qcm9kaSIgdGl0bGU9IlJvbWFubyBQcm9kaSI+Um9tYW5vIFByb2RpPC9hPiBnYWx0 IGRpZXMgZWJlbnNvIGbDvHIgZGllIGZyYW56w7ZzaXNjaGUgUmVnaWVydW5nIHVudGVyIDxhIGhy ZWY9Ii93aWtpL0phY3F1ZXNfQ2hpcmFjIiB0aXRsZT0iSmFjcXVlcyBDaGlyYWMiPkNoaXJhYzwv YT4uIFNvIGhhYmVuIGRpZSBXYWhsc2llZ2VyIFphcGF0ZXJvIHVuZCBQcm9kaSBkaWUgSXJhay1L b250aW5nZW50ZSBpaHJlciBMw6RuZGVyIGluIEFibGVobnVuZyBkZXMgSXJha2tyaWVnZXMgdW5t aXR0ZWxiYXIgbmFjaCBpaHJlbSBqZXdlaWxpZ2VuIFJlZ2llcnVuZ3N3ZWNoc2VsIGF1cyBkZW0g YXJhYmlzY2hlbiBMYW5kIGFiZ2V6b2dlbi48L3A+CTxwPkF1Y2ggZGFzIFZlcmjDpGx0bmlzIEJ1 c2hzIHp1bSBlaGVtYWxpZ2VuIGRldXRzY2hlbiBCdW5kZXNrYW56bGVyIDxhIGhyZWY9Ii93aWtp L0dlcmhhcmRfU2NociVDMyVCNmRlciIgdGl0bGU9IkdlcmhhcmQgU2NocsO2ZGVyIj5HZXJoYXJk IFNjaHLDtmRlcjwvYT4gd2FyIHdlZ2VuIGRlc3NlbiBhYmxlaG5lbmRlciBIYWx0dW5nIHp1bSBJ cmFrLUVuZ2FnZW1lbnQgYmVlaW50csOkY2h0aWd0LCBkaWVzIGdhbHQgamVkb2NoIG5pY2h0IGbD vHIgZGllIEJlemllaHVuZ2VuIGRlciBMw6RuZGVyIHVudGVyZWluYW5kZXIgaW5zZ2VzYW10LiBT Y2hyw7ZkZXJzIE5hY2hmb2xnZXJpbiwgQnVuZGVza2FuemxlcmluIDxhIGhyZWY9Ii93aWtpL0Fu Z2VsYV9NZXJrZWwiIHRpdGxlPSJBbmdlbGEgTWVya2VsIj5BbmdlbGEgTWVya2VsPC9hPiwgaGF0 IHNpY2ggZXJmb2xncmVpY2ggdW0gZWluIGJlc3NlcmVzIFZlcmjDpGx0bmlzIGJlbcO8aHQuIEds ZWljaHdvaGwgc3RhbmQgTWl0dGUgMjAwNiBkaWUgZGV1dHNjaGUgQmV2w7Zsa2VydW5nIGRlciBQ ZXJzb24gQnVzaCB1bmQgZGVzc2VuIFJlZ2llcnVuZyBtZWhyaGVpdGxpY2ggdW52ZXLDpG5kZXJ0 IHJlc2VydmllcnQgZ2VnZW7DvGJlci4gSW0gVmVyZ2xlaWNoIHp1IEJ1c2ggZ2VuaWXDn3QgZGVy IHZvcmhlcmlnZSBQcsOkc2lkZW50IDxhIGhyZWY9Ii93aWtpL0JpbGxfQ2xpbnRvbiIgdGl0bGU9 IkJpbGwgQ2xpbnRvbiI+Q2xpbnRvbjwvYT4gaGV1dGUgbmFjaCB3aWUgdm9yIHdlc2VudGxpY2gg aMO2aGVyZSBTeW1wYXRoaWV3ZXJ0ZSBpbiBFdXJvcGEuPC9wPgk8aDM+PHNwYW4gY2xhc3M9Im13 LWhlYWRsaW5lIiBpZD0iS3JpdGlrX3VuZF9wb2xhcmlzaWVyZW5kZV9XaXJrdW5nIj5Lcml0aWsg dW5kIHBvbGFyaXNpZXJlbmRlIFdpcmt1bmc8L3NwYW4+PC9oMz4JPGRpdiBjbGFzcz0idGh1bWIg dHJpZ2h0Ij4JPGRpdiBjbGFzcz0idGh1bWJpbm5lciIgc3R5bGU9IndpZHRoOjIyMnB4OyI+PGEg aHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPURhdGVpOkdvaG9tZWJ1c2guSlBHJmFtcDtmaWxldGlt ZXN0YW1wPTIwMDcwNDI2MTQ1MTEwIiBjbGFzcz0iaW1hZ2UiPjxpbWcgYWx0PSIiIHNyYz0iaHR0 cDovL3VwbG9hZC53aWtpbWVkaWEub3JnL3dpa2lwZWRpYS9jb21tb25zL3RodW1iL2UvZTAvR29o b21lYnVzaC5KUEcvMjIwcHgtR29ob21lYnVzaC5KUEciIHdpZHRoPSIyMjAiIGhlaWdodD0iMTY1 IiBjbGFzcz0idGh1bWJpbWFnZSIgLz48L2E+CTxkaXYgY2xhc3M9InRodW1iY2FwdGlvbiI+CTxk aXYgY2xhc3M9Im1hZ25pZnkiPjxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1EYXRlaTpHb2hv bWVidXNoLkpQRyZhbXA7ZmlsZXRpbWVzdGFtcD0yMDA3MDQyNjE0NTExMCIgY2xhc3M9ImludGVy bmFsIiB0aXRsZT0idmVyZ3LDtsOfZXJuIj48aW1nIHNyYz0iaHR0cDovL2JpdHMud2lraW1lZGlh Lm9yZy9za2lucy0xLjUvY29tbW9uL2ltYWdlcy9tYWduaWZ5LWNsaXAucG5nIiB3aWR0aD0iMTUi IGhlaWdodD0iMTEiIGFsdD0iIiAvPjwvYT48L2Rpdj4JQnVzaGtyaXRpc2NoZSBIYXVzYmVkYWNo dW5nIGFuIGRlciA8YSBocmVmPSIvd2lraS9XaWVuemVpbGUiIHRpdGxlPSJXaWVuemVpbGUiPldp ZW56ZWlsZTwvYT48L2Rpdj4JPC9kaXY+CTwvZGl2Pgk8cD5EaWUgUG9saXRpayBkZXIgYW1lcmlr YW5pc2NoZW4gUmVnaWVydW5nIHVudGVyIEdlb3JnZSBXLiBCdXNocyBQcsOkc2lkZW50c2NoYWZ0 IGbDvGhydGUgenUgZWluZXIgc3RhcmtlbiBQb2xhcmlzaWVydW5nIHp3aXNjaGVuIEJlZsO8cndv cnRlcm4gdW5kIEtyaXRpa2Vybi48L3A+CTxwPkRhcsO8YmVyIGhpbmF1cyB3ZXJkZW4gUGVyc8O2 bmxpY2hrZWl0IHVuZCBFaWdlbnNjaGFmdGVuIGRlciBQZXJzb24gR2VvcmdlIFcuIEJ1c2ggdm9u IEFuaMOkbmdlcm4gdW5kIEdlZ25lcm4gbWVpc3Qgc2VociBnZWdlbnPDpHR6bGljaCBlaW5nZXNj aMOkdHp0LiBXw6RocmVuZCBkaWUgZWluZW4gc2VpbmVuIEdsYXViZW4gYW4gR290dCB1bmQgZGll IEbDvGhydW5nc3JvbGxlIGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuIGFscyBTdMOkcmtlbiBzY2jD pHR6ZW4sIHdlaXNlbiBkaWUgYW5kZXJlbiBhdWYgc2VpbmUgZGVua3fDvHJkaWdlIEJpb2dyYXBo aWUsIHUuQS4gbWl0IEhpbndlaXMgYXVmIHNlaW5lIGZyw7xoZXJlbiBBbGtvaG9scHJvYmxlbWUs IHNlaW5lciBzZWxic3Rlcmtsw6RydGUg4oCeV2llZGVyZ2VidXJ04oCcIGFscyBDaHJpc3QgdW5k IEFudGktQWxrb2hvbGlrZXIgdW5kIHN0YXJrZSBzcHJhY2hsaWNoZW4gVW5zaWNoZXJoZWl0ZW4g KHNpZWhlIGF1Y2ggPGk+PGEgaHJlZj0iL3dpa2kvQnVzaGlzbSIgdGl0bGU9IkJ1c2hpc20iPkJ1 c2hpc208L2E+PC9pPikuPC9wPgk8cD5BbmdlYmxpY2ggw6R1w59lcnRlIEJ1c2ggbmFjaCBBbmdh YmVuIGRlcyBicml0aXNjaGVuIDxhIGhyZWY9Ii93aWtpL1RoZV9HdWFyZGlhbiIgdGl0bGU9IlRo ZSBHdWFyZGlhbiI+R3VhcmRpYW5zPC9hPiAyMDAzIGdlZ2Vuw7xiZXIgaG9jaHJhbmdpZ2VuIHBh bMOkc3RpbmVuc2lzY2hlbiBQb2xpdGlrZXJuLCBkYXNzIGVyIGltIEF1ZnRyYWcgR290dGVzIGdl aGFuZGVsdCBoYWJlLCBhbHMgZXIgZGVuIHNvIGdlbmFubnRlbiBLcmllZyBnZWdlbiBkZW4gVGVy cm9yaXNtdXMgYmVnYW5uLCBpbnNiZXNvbmRlcmUgbWl0IEJlenVnIGF1ZiBkaWUgSW52YXNpb24g aW0gSXJhay4gRGllc2VzIFppdGF0IHdpcmQgdm9uIFZlcnRyZXRlcm4gZGVzIFdlacOfZW4gSGF1 c2VzIGRlbWVudGllcnQuIE5hY2ggPGEgaHJlZj0iL3dpa2kvQnJpdGlzaF9Ccm9hZGNhc3Rpbmdf Q29ycG9yYXRpb24iIHRpdGxlPSJCcml0aXNoIEJyb2FkY2FzdGluZyBDb3Jwb3JhdGlvbiI+QkJD PC9hPi1BbmdhYmVuIGhhdCBkZXIgZWhlbWFsaWdlIHBhbMOkc3RpbmVuc2lzY2hlIEF1w59lbm1p bmlzdGVyIDxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1OYWJpbF9TY2hhYXRoJmFtcDthY3Rp b249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iTmFiaWwgU2NoYWF0aCAo U2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+TmFiaWwgU2NoYWF0aDwvYT4gZGllc2Ugw4R1w59lcnVu Z2VuIHp3ZWkgSmFocmUgc3DDpHRlciBiZXN0w6R0aWd0LjwvcD4JPHA+V8OkaHJlbmQgZWluZSBn cm/Dn2UgWmFobCBkZXIgPGEgaHJlZj0iL3dpa2kvTWFpbnN0cmVhbSIgdGl0bGU9Ik1haW5zdHJl YW0iPk1haW5zdHJlYW08L2E+LU1lZGllbiBpbSBadWdlIGRlciBBdHRlbnRhdGUgdm9tIDxhIGhy ZWY9Ii93aWtpL1RlcnJvcmFuc2NobCVDMyVBNGdlX2FtXzExLl9TZXB0ZW1iZXJfMjAwMV9pbl9k ZW5fVVNBIiB0aXRsZT0iVGVycm9yYW5zY2hsw6RnZSBhbSAxMS4gU2VwdGVtYmVyIDIwMDEgaW4g ZGVuIFVTQSIgY2xhc3M9Im13LXJlZGlyZWN0Ij4xMS4gU2VwdGVtYmVyIDIwMDE8L2E+IGRpZSBS ZWdpZXJ1bmdzbGluaWUgdmVydHJhdGVuLCBkaWUgYXVjaCDDvGJlciBkYXMgS29uemVwdCBkZXMg c29nZW5hbm50ZW4gPGEgaHJlZj0iL3dpa2kvRW1iZWRkZWRfSm91cm5hbGlzdCIgdGl0bGU9IkVt YmVkZGVkIEpvdXJuYWxpc3QiPmVpbmdlYmV0dGV0ZW4gSm91cm5hbGlzbXVzPC9hPiBhbHMgQmVy aWNodGVyc3RhdHRlciBpbSBhbnNjaGxpZcOfZW5kZW4gSXJha2tyaWVnIHdlaXRnZWhlbmQgYXVm Z2luZ2VuLCByaWVmZW4gZGllIEVyZWlnbmlzc2UgaW0gWnVnZSBkZXIgdW1zdHJpdHRlbmVuIFdh aGwgMjAwMCwgbm9jaCBtZWhyIGFiZXIgaW4gZGVyIEZvbGdlIGRlciBWZXJzY2jDpHJmdW5nIGRl ciA8YSBocmVmPSIvd2lraS9VbmlsYXRlcmFsaXQlQzMlQTR0IiB0aXRsZT0iVW5pbGF0ZXJhbGl0 w6R0Ij51bmlsYXRlcmFsaXN0aXNjaGVuPC9hPiBQb2xpdGlrIGRlciBWZXJlaW5pZ3RlbiBTdGFh dGVuIGluIGRlciBGb2xnZSBkZXIgVGVycm9yYW5zY2hsw6RnZSBhbSAxMS4gU2VwdGVtYmVyIDIw MDEgemFobHJlaWNoZSBLcml0aWtlciBhdWYgZGVuIFBsYW4uIERlciBEb2t1bWVudGFyZmlsbWVy IDxhIGhyZWY9Ii93aWtpL01pY2hhZWxfTW9vcmUiIHRpdGxlPSJNaWNoYWVsIE1vb3JlIj5NaWNo YWVsIE1vb3JlPC9hPiBlcmxhbmd0ZSBkYWJlaSBtaXQgc2VpbmVuIELDvGNoZXJuIDxpPjxhIGhy ZWY9Ii93aWtpL1N0dXBpZF9XaGl0ZV9NZW4iIHRpdGxlPSJTdHVwaWQgV2hpdGUgTWVuIj5TdHVw aWQgV2hpdGUgTWVuPC9hPjwvaT4gdW5kIDxpPjxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1W b2xsZV9EZWNrdW5nLF9Nci5fQnVzaCZhbXA7YWN0aW9uPWVkaXQmYW1wO3JlZGxpbms9MSIgY2xh c3M9Im5ldyIgdGl0bGU9IlZvbGxlIERlY2t1bmcsIE1yLiBCdXNoIChTZWl0ZSBuaWNodCB2b3Jo YW5kZW4pIj5Wb2xsZSBEZWNrdW5nLCBNci4gQnVzaDwvYT48L2k+IHNvd2llIG1pdCBzZWluZW0g RmlsbSA8aT48YSBocmVmPSIvd2lraS9GYWhyZW5oZWl0XzkvMTEiIHRpdGxlPSJGYWhyZW5oZWl0 IDkvMTEiPkZhaHJlbmhlaXQgOS8xMTwvYT48L2k+IGVpbmVuIGJldHLDpGNodGxpY2hlbiBCZWth bm50aGVpdHNncmFkIGFscyBCdXNoLUtyaXRpa2VyLjwvcD4JPHA+R2VvcmdlIFcuIEJ1c2ggaXN0 IGRlciBlcnN0ZSBhbWVyaWthbmlzY2hlIFByw6RzaWRlbnQsIGRlc3NlbiBIYW5kZWxuIGRpZSBQ cm9kdWt0aW9uIHVuZCBWZXLDtmZmZW50bGljaHVuZyBlaW5lcyBncm/Dn2VuIEtpbm9maWxtcyAo PGk+RmFocmVuaGVpdCA5LzExPC9pPiksIGRlbiBTdGFydCBlaW5lcyBnZXNhbXRlbiBSdW5kZnVu a25ldHplcyAoPGk+PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPUFpcl9BbWVyaWNhX1JhZGlv JmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iQWlyIEFt ZXJpY2EgUmFkaW8gKFNlaXRlIG5pY2h0IHZvcmhhbmRlbikiPkFpciBBbWVyaWNhIFJhZGlvPC9h PjwvaT4pIHVuZCBkaWUgUHJlbWllcmUgZWluZXIgRmVybnNlaHNlcmllICg8aT5UaGUgPGEgaHJl Zj0iL3dpa2kvQWxfRnJhbmtlbiIgdGl0bGU9IkFsIEZyYW5rZW4iPkFsIEZyYW5rZW48L2E+IFNo b3c8L2k+KSBiZXdpcmt0ZSwgZGVyZW4gZ2VtZWluc2FtZXMgWmllbCBlcyB3YXIsIHNlaW5lIFdp ZWRlcndhaGwgenUgdmVyaGluZGVybi48L3A+CTxwPkJ1c2ggaXN0IGF1w59lcmRlbSBub2NoIGRl ciBlcnN0ZSBQcsOkc2lkZW50LCBkZXIgZWluZSBOb21pbmllcnVuZyAoYW0gMjYuIEZlYnJ1YXIg MjAwNSkgdW5kIGFuc2NobGllw59lbmQgZGVuIEZpbG1wcmVpcyA8YSBocmVmPSIvd2lraS9Hb2xk ZW5lX0hpbWJlZXJlIiB0aXRsZT0iR29sZGVuZSBIaW1iZWVyZSI+R29sZGVuZSBIaW1iZWVyZTwv YT4gZGVyIDxpPjxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1Hb2xkZW5fUmFzcGJlcnJ5X0F3 YXJkX0ZvdW5kYXRpb24mYW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEiIGNsYXNzPSJuZXci IHRpdGxlPSJHb2xkZW4gUmFzcGJlcnJ5IEF3YXJkIEZvdW5kYXRpb24gKFNlaXRlIG5pY2h0IHZv cmhhbmRlbikiPkdvbGRlbiBSYXNwYmVycnkgQXdhcmQgRm91bmRhdGlvbjwvYT48L2k+IGFscyBz Y2hsZWNodGVzdGVyIEhhdXB0ZGFyc3RlbGxlciBlcmhhbHRlbiBoYXQuIE5hdMO8cmxpY2ggc3Bp ZWx0ZSBlciBpbiA8aT5GYWhyZW5oZWl0IDkvMTE8L2k+IHJlaW4gdGVjaG5pc2NoIGdlc2VoZW4g a2VpbmUgUm9sbGUsIHNvbmRlcm4gd3VyZGUgbnVyIGluIEFyY2hpdmF1Zm5haG1lbiBnZXplaWd0 LiBFcyBpc3QgYW56dW5laG1lbiwgZGFzcyBkaWUgVmVybGVpaHVuZyBkZXMgUHJlaXNlcyBpbiBk aWVzZW0gRmFsbCBhbHMgcG9saXRpc2NoZSBTdGVsbHVuZ25haG1lIGRlciBKdXJ5IHp1IGJldHJh Y2h0ZW4gaXN0LjwvcD4JPHA+SW0gRGV6ZW1iZXIgMjAwNCB3w6RobHQgZGFzIDxhIGhyZWY9Ii93 aWtpL1RJTUUiIHRpdGxlPSJUSU1FIiBjbGFzcz0ibXctcmVkaXJlY3QiPlRpbWUgTWFnYXppbmU8 L2E+IGlobiB6dXIgPGk+UGVyc29uIGRlcyBKYWhyZXM8L2k+IDIwMDQg4oCePGk+Zm9yIHNoYXJw ZW5pbmcgdGhlIGRlYmF0ZSB1bnRpbCB0aGUgY2hvaWNlcyBibGVkLCBmb3IgcmVmcmFtaW5nIHJl YWxpdHkgdG8gbWF0Y2ggaGlzIGRlc2lnbiwgZm9yIGdhbWJsaW5nIGhpcyBmb3J0dW5lcyDigJMg YW5kIG91cnMg4oCTIG9uIGhpcyBmYWl0aCBpbiB0aGUgcG93ZXIgb2YgbGVhZGVyc2hpcDwvaT7i gJwgKGZyZWkgw7xiZXJzZXR6dDog4oCeZGFmw7xyLCBkaWUgRGViYXR0ZSB6dXp1c3BpdHplbiBi aXMgV2FobG3DtmdsaWNoa2VpdGVuIGhlcnZvcnNwcnVkZWx0ZW4sIGRhZsO8ciwgZGllIFJlYWxp dMOkdCB1bXp1ZGV1dGVuIHVtIHNlaW5lbiBWb3JzdGVsbHVuZ2VuIHp1IGVudHNwcmVjaGVuLCBk YWbDvHIgc2VpbmUgLSB1bmQgdW5zZXJlIC0gR2VzY2hpY2tlIGF1ZnMgU3BpZWwgenUgc2V0emVu LCBtaXQgc2VpbmVtIEdsYXViZW4gYW4gZGllIEtyYWZ0IGR1cmNoIEbDvGhyZXJzY2hhZnTigJwp LjwvcD4JPHA+RGVyIDxhIGhyZWY9Ii93aWtpL0ZyZWVkb21fb2ZfSW5mb3JtYXRpb25fQWN0IiB0 aXRsZT0iRnJlZWRvbSBvZiBJbmZvcm1hdGlvbiBBY3QiPkZyZWVkb20gb2YgSW5mb3JtYXRpb24g QWN0PC9hPiBpc3QgaW4gZGVuIFZlcmVpbmlndGVuIFN0YWF0ZW4gc2VpdCBkZW4gVGVycm9yYW5z Y2hsw6RnZW4gdm9tIDExLiBTZXB0ZW1iZXIgMjAwMSBzdGFyayBiZXNjaG5pdHRlbiB3b3JkZW4u IEltbWVyIG1laHIgUmVnaWVydW5nc2FrdGVuIHdlcmRlbiBtaXQgZGVtIFZlcm1lcmsg4oCeR2Vo ZWlt4oCcIG9kZXIgZWluZmFjaCDigJ5OdXIgZsO8ciBkZW4gRGllbnN0Z2VicmF1Y2jigJwgdmVy c2VoZW4gdW5kIGRhbWl0IHVtZmFzc2VuZGVyIFRyYW5zcGFyZW56IGVudHpvZ2VuLjwvcD4JPGRp diBjbGFzcz0idGh1bWIgdHJpZ2h0Ij4JPGRpdiBjbGFzcz0idGh1bWJpbm5lciIgc3R5bGU9Indp ZHRoOjIyMnB4OyI+PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPURhdGVpOkZvcm1lcl9QcmVz aWRlbnRfR2VvcmdlX1cuX0J1c2hfYW5kX2hpc193aWZlX2JlZm9yZV90aGVpcl9mbGlnaHRfdG9f RGFsbGFzLmpwZyZhbXA7ZmlsZXRpbWVzdGFtcD0yMDA5MDEyMTEwMTA0MSIgY2xhc3M9ImltYWdl Ij48aW1nIGFsdD0iIiBzcmM9Imh0dHA6Ly91cGxvYWQud2lraW1lZGlhLm9yZy93aWtpcGVkaWEv Y29tbW9ucy90aHVtYi8xLzFlL0Zvcm1lcl9QcmVzaWRlbnRfR2VvcmdlX1cuX0J1c2hfYW5kX2hp c193aWZlX2JlZm9yZV90aGVpcl9mbGlnaHRfdG9fRGFsbGFzLmpwZy8yMjBweC1Gb3JtZXJfUHJl c2lkZW50X0dlb3JnZV9XLl9CdXNoX2FuZF9oaXNfd2lmZV9iZWZvcmVfdGhlaXJfZmxpZ2h0X3Rv X0RhbGxhcy5qcGciIHdpZHRoPSIyMjAiIGhlaWdodD0iMTY1IiBjbGFzcz0idGh1bWJpbWFnZSIg Lz48L2E+CTxkaXYgY2xhc3M9InRodW1iY2FwdGlvbiI+CTxkaXYgY2xhc3M9Im1hZ25pZnkiPjxh IGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1EYXRlaTpGb3JtZXJfUHJlc2lkZW50X0dlb3JnZV9X Ll9CdXNoX2FuZF9oaXNfd2lmZV9iZWZvcmVfdGhlaXJfZmxpZ2h0X3RvX0RhbGxhcy5qcGcmYW1w O2ZpbGV0aW1lc3RhbXA9MjAwOTAxMjExMDEwNDEiIGNsYXNzPSJpbnRlcm5hbCIgdGl0bGU9InZl cmdyw7bDn2VybiI+PGltZyBzcmM9Imh0dHA6Ly9iaXRzLndpa2ltZWRpYS5vcmcvc2tpbnMtMS41 L2NvbW1vbi9pbWFnZXMvbWFnbmlmeS1jbGlwLnBuZyIgd2lkdGg9IjE1IiBoZWlnaHQ9IjExIiBh bHQ9IiIgLz48L2E+PC9kaXY+CUV4IFByw6RzaWRlbnQgR2VvcmdlIFcuIEJ1c2ggdW5kIExhdXJh IEJ1c2ggZmxpZWdlbiBhbSAyMC4gSmFudWFyIDIwMDkgbWl0IGRlciA8YSBocmVmPSIvd2lraS9C b2VpbmdfNzQ3I01pbGl0LkMzLkE0cmlzY2hlX1ZhcmlhbnRlbiIgdGl0bGU9IkJvZWluZyA3NDci PlZDLTI1PC9hPiBuYWNoIDxhIGhyZWY9Ii93aWtpL0RhbGxhcyIgdGl0bGU9IkRhbGxhcyI+RGFs bGFzPC9hPi48L2Rpdj4JPC9kaXY+CTwvZGl2Pgk8cD5TdGFhdHNiZXN1Y2hlIEJ1c2hzIGJlc29u ZGVycyBpbiBldXJvcMOkaXNjaGVuIEzDpG5kZXJuIGbDvGhydGVuIGltbWVyIHdpZWRlciB6dSBE ZW1vbnN0cmF0aW9uZW4gZ2VnZW4gc2VpbmUgQXXDn2VucG9saXRpaywgaW5zYmVzb25kZXJlIGRl biBJcmFra3JpZWcgdW5kIGRhcyBJbnRlcm5pZXJ1bmdzbGFnZXIgR3VhbnTDoW5hbW8uIFNvIGth bSBlcyBBbmZhbmcgSnVuaSAyMDA0IGJlaSBlaW5lciA8YSBocmVmPSIvd2lraS9FdXJvcGEiIHRp dGxlPSJFdXJvcGEiPkV1cm9wYXJlaXNlPC9hPiBCdXNocyBhbmzDpHNzbGljaCBkZXMgNjAuIEph aHJlc3RhZ3MgZGVyIDxhIGhyZWY9Ii93aWtpL0ludmFzaW9uXyhNaWxpdCVDMyVBNHIpIiB0aXRs ZT0iSW52YXNpb24gKE1pbGl0w6RyKSI+SW52YXNpb248L2E+IGRlciA8YSBocmVmPSIvd2lraS9B bGxpaWVydGUiIHRpdGxlPSJBbGxpaWVydGUiPkFsbGlpZXJ0ZW48L2E+IGluIGRlciA8YSBocmVm PSIvd2lraS9Ob3JtYW5kaWUiIHRpdGxlPSJOb3JtYW5kaWUiPk5vcm1hbmRpZTwvYT4gYmVpbSA8 YSBocmVmPSIvd2lraS9TdGFhdHNiZXN1Y2giIHRpdGxlPSJTdGFhdHNiZXN1Y2giPlN0YWF0c2Jl c3VjaDwvYT4gaW4gSXRhbGllbiB6dSBtYXNzaXZlbiBTdHJhw59lbnByb3Rlc3RlbiBpbiA8YSBo cmVmPSIvd2lraS9Sb20iIHRpdGxlPSJSb20iPlJvbTwvYT4gZ2VnZW4gQnVzaC4gRG9ydCB3dXJk ZSBkZXIgUHLDpHNpZGVudCBhdWNoIHZvbiA8YSBocmVmPSIvd2lraS9QYXBzdCIgdGl0bGU9IlBh cHN0Ij5QYXBzdDwvYT4gPGEgaHJlZj0iL3dpa2kvSm9oYW5uZXNfUGF1bF9JSS4iIHRpdGxlPSJK b2hhbm5lcyBQYXVsIElJLiI+Sm9oYW5uZXMgUGF1bCBJSS48L2E+IHp1IGVpbmVyIEF1ZGllbnog ZW1wZmFuZ2VuLiBEZXIgUGFwc3QsIGViZW5mYWxscyBlaW4gZW50c2NoaWVkZW5lciBHZWduZXIg ZGVzIElyYWtrcmllZ2VzLCBrcml0aXNpZXJ0ZSBCdXNocyBJcmFrLVBvbGl0aWsgbWl0IHVuZ2V3 b2hudCBkZXV0bGljaGVuIFdvcnRlbiB1bmQgZm9yZGVydGUgaWhuIHp1IGVpbmVyIFZlcsOkbmRl cnVuZyBzZWluZXIgZW50c3ByZWNoZW5kZW4gUG9saXRpayBhdWYuPC9wPgk8cD5CZWxhc3RldCB3 YXJlbiBhdWNoIGRpZSBhdXN3w6RydGlnZW4gQmV6aWVodW5nZW4gZGVyIFJlZ2llcnVuZyBCdXNo IHp1IGVpbmlnZW4gbWl0dGVsLSB1bmQgc8O8ZGFtZXJpa2FuaXNjaGVuIFJlZ2llcnVuZ2VuLCBl dHdhIGRlciB2b24gPGEgaHJlZj0iL3dpa2kvSHVnb19DaCVDMyVBMXZleiIgdGl0bGU9Ikh1Z28g Q2jDoXZleiI+SHVnbyBDaMOhdmV6PC9hPiBpbiA8YSBocmVmPSIvd2lraS9WZW5lenVlbGEiIHRp dGxlPSJWZW5lenVlbGEiPlZlbmV6dWVsYTwvYT4uPC9wPgk8ZGw+CTxkdD5LbGltYXdhbmRlbDwv ZHQ+CTwvZGw+CTxwPkRpZSBSZWdpZXJ1bmcgQnVzaCBoYXQgZGllIFVudGVyZHLDvGNrdW5nIG1p c3NsaWViaWdlciBVbXdlbHRiZXJpY2h0ZSB2b3JhbmdldHJpZWJlbi4gQXVmIGtyaXRpc2NoZSBC ZXJpY2h0ZSDDvGJlciBkZW4gPGEgaHJlZj0iL3dpa2kvR2xvYmFsZV9FcnclQzMlQTRybXVuZyIg dGl0bGU9Ikdsb2JhbGUgRXJ3w6RybXVuZyI+S2xpbWF3YW5kZWw8L2E+IHd1cmRlIEVpbmZsdXNz IGdlbm9tbWVuLCBldHdhIGluZGVtIFdpc3NlbnNjaGFmdGxlciB6dSBlaW5lciBWZXJtZWlkdW5n IGRlciBrcml0aXNjaGVuIFBhc3NhZ2VuIGF1ZmdlZm9yZGVydCB3dXJkZW4uIEF1Y2ggS29udGFr dGUgenUgTWVkaWVuIHd1cmRlbiByZWdsZW1lbnRpZXJ0LiBEYXLDvGJlciBiZWtsYWd0IGhhdHRl IHNpY2ggZGllIEjDpGxmdGUgdm9uIDMwMCB6dSBkaWVzZW0gVGhlbWEgYmVmcmFndGVuIFdpc3Nl bnNjaGFmdGxlcm4uPHN1cCBpZD0iY2l0ZV9yZWYtOCIgY2xhc3M9InJlZmVyZW5jZSI+PGEgaHJl Zj0iI2NpdGVfbm90ZS04Ij5bOV08L2E+PC9zdXA+PC9wPgk8aDI+PHNwYW4gY2xhc3M9Im13LWhl YWRsaW5lIiBpZD0iTmFjaF9kZXJfUHIuQzMuQTRzaWRlbnRzY2hhZnQiPk5hY2ggZGVyIFByw6Rz aWRlbnRzY2hhZnQ8L3NwYW4+PC9oMj4JPHA+TmFjaCBkZXIgQW10c2VpbmbDvGhydW5nIHZvbiA8 YSBocmVmPSIvd2lraS9CYXJhY2tfT2JhbWEiIHRpdGxlPSJCYXJhY2sgT2JhbWEiPkJhcmFjayBP YmFtYTwvYT4ga8O8bmRpZ3RlIEJ1c2ggYW4sIHNpY2ggaW4gPGEgaHJlZj0iL3cvaW5kZXgucGhw P3RpdGxlPVByZXN0b25fSG9sbG93JmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFz cz0ibmV3IiB0aXRsZT0iUHJlc3RvbiBIb2xsb3cgKFNlaXRlIG5pY2h0IHZvcmhhbmRlbikiPlBy ZXN0b24gSG9sbG93PC9hPiBpbiBkZXIgTsOkaGUgdm9uIDxhIGhyZWY9Ii93aWtpL0RhbGxhcyIg dGl0bGU9IkRhbGxhcyI+RGFsbGFzPC9hPiwgPGEgaHJlZj0iL3dpa2kvVGV4YXMiIHRpdGxlPSJU ZXhhcyI+VGV4YXM8L2E+LCBtaXQgc2VpbmVyIEZyYXUgTGF1cmEgbmllZGVyenVsYXNzZW4uIFfD pGhyZW5kIGVpbmVzIEZlcm5zZWhpbnRlcnZpZXdzIGFtIDE3LiBNw6RyeiAyMDA5IHNhZ3RlIGVy LCBkYXNzIGVyIGFuIGVpbmVtIEJ1Y2ggc2NocmVpYmUsIGRhcyB1bnRlciBkZW0gTmFtZW4gPGk+ RGVjaXNpb24gUG9pbnRzPC9pPiBpbSBKYWhyIDIwMTAgZXJzY2hlaW5lbiBzb2xsIDxzdXAgaWQ9 ImNpdGVfcmVmLV85LTAiIGNsYXNzPSJyZWZlcmVuY2UiPjxhIGhyZWY9IiNjaXRlX25vdGUtLTki PlsxMF08L2E+PC9zdXA+LjwvcD4JPGgyPjxzcGFuIGNsYXNzPSJtdy1oZWFkbGluZSIgaWQ9IlZl cmZpbG11bmciPlZlcmZpbG11bmc8L3NwYW4+PC9oMj4JPHA+UmVnaXNzZXVyIDxhIGhyZWY9Ii93 aWtpL09saXZlcl9TdG9uZSIgdGl0bGU9Ik9saXZlciBTdG9uZSI+T2xpdmVyIFN0b25lPC9hPiB1 bmQgRHJlaGJ1Y2hhdXRvciA8YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9U3RhbmxleV9XZWlz ZXImYW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEiIGNsYXNzPSJuZXciIHRpdGxlPSJTdGFu bGV5IFdlaXNlciAoU2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+U3RhbmxleSBXZWlzZXI8L2E+IGVy YXJiZWl0ZXRlbiBlaW5lIEZpbG1iaW9ncmFmaWUgdm9uIFByw6RzaWRlbnQgQnVzaDog4oCePGEg aHJlZj0iL3dpa2kvVy5fJUUyJTgwJTkzX0Vpbl9taXNzdmVyc3RhbmRlbmVzX0xlYmVuIiB0aXRs ZT0iVy4g4oCTIEVpbiBtaXNzdmVyc3RhbmRlbmVzIExlYmVuIj5XLiDigJMgRWluIG1pc3N2ZXJz dGFuZGVuZXMgTGViZW48L2E+4oCcIGhhdHRlIGFtIDE3LiBPa3RvYmVyIDIwMDggaW4gZGVuIFZl cmVpbmlndGVuIFN0YWF0ZW4gUHJlbWllcmUuIEdlb3JnZSBXLiBCdXNoIHdpcmQgdm9uIDxhIGhy ZWY9Ii93aWtpL0pvc2hfQnJvbGluIiB0aXRsZT0iSm9zaCBCcm9saW4iPkpvc2ggQnJvbGluPC9h PiB1bmQgPGEgaHJlZj0iL3dpa2kvTGF1cmFfQnVzaCIgdGl0bGU9IkxhdXJhIEJ1c2giPkxhdXJh IEJ1c2g8L2E+IHZvbiA8YSBocmVmPSIvd2lraS9FbGl6YWJldGhfQmFua3MiIHRpdGxlPSJFbGl6 YWJldGggQmFua3MiPkVsaXphYmV0aCBCYW5rczwvYT4gZ2VzcGllbHQuPC9wPgk8aDI+PHNwYW4g Y2xhc3M9Im13LWhlYWRsaW5lIiBpZD0iVHJpdmlhIj5Ucml2aWE8L3NwYW4+PC9oMj4JPHVsPgk8 bGk+MjAwNSB3dXJkZSBkZXIgPGEgaHJlZj0iL3dpa2kvU2Nod2FtbWt1Z2VsayVDMyVBNGZlciIg dGl0bGU9IlNjaHdhbW1rdWdlbGvDpGZlciI+U2Nod2FtbWt1Z2Vsa8OkZmVyPC9hPiA8aT48YSBo cmVmPSIvd2lraS9BZ2F0aGlkaXVtX2J1c2hpIiB0aXRsZT0iQWdhdGhpZGl1bSBidXNoaSI+QWdh dGhpZGl1bSBidXNoaTwvYT48L2k+LCBkZXIgc2ljaCB2b24gPGEgaHJlZj0iL3dpa2kvU2NobGVp bXBpbHplIiB0aXRsZT0iU2NobGVpbXBpbHplIj5TY2hsZWltcGlsemVuPC9hPiBlcm7DpGhydCwg bmFjaCBpaG0gYmVuYW5udC48c3VwIGlkPSJjaXRlX3JlZi0xMCIgY2xhc3M9InJlZmVyZW5jZSI+ PGEgaHJlZj0iI2NpdGVfbm90ZS0xMCI+WzExXTwvYT48L3N1cD48L2xpPgk8L3VsPgk8aDI+PHNw YW4gY2xhc3M9Im13LWhlYWRsaW5lIiBpZD0iU2llaGVfYXVjaCI+U2llaGUgYXVjaDwvc3Bhbj48 L2gyPgk8dWw+CTxsaT48YSBocmVmPSIvd2lraS9LYWJpbmV0dF9HZW9yZ2VfVy5fQnVzaCIgdGl0 bGU9IkthYmluZXR0IEdlb3JnZSBXLiBCdXNoIj5LYWJpbmV0dCBCdXNoPC9hPjwvbGk+CTwvdWw+ CTxoMj48c3BhbiBjbGFzcz0ibXctaGVhZGxpbmUiIGlkPSJMaXRlcmF0dXIiPkxpdGVyYXR1cjwv c3Bhbj48L2gyPgk8dWw+CTxsaT48c3BhbiBjbGFzcz0iY2l0ZSI+R2VvcmdlIFcuIEJ1c2g6IDxp PkEgQ2hhcmdlIHRvIEtlZXAuPC9pPiBXaWxsaWFtIE1vcnJvdyAmYW1wOyBDb21wYW55LCA8c3Bh biBzdHlsZT0id2hpdGUtc3BhY2U6bm93cmFwOyI+MTk5OTwvc3Bhbj4sIDxhIGhyZWY9Ii93aWtp L1NwZXppYWw6SVNCTi1TdWNoZS8wNjg4MTc0NDE4IiBjbGFzcz0iaW50ZXJuYWwgbXctbWFnaWNs aW5rLWlzYm4iPklTQk4gMC02ODgtMTc0NDEtODwvYT4gKEF1dG9iaW9ncmFwaGllLCBlbmdsaXNj aCkuPC9zcGFuPjxzcGFuIHN0eWxlPSJkaXNwbGF5OiBub25lOyIgY2xhc3M9IlozOTg4IiB0aXRs ZT0iY3R4X3Zlcj1aMzkuODgtMjAwNCZhbXA7cmZ0X3ZhbF9mbXQ9aW5mbyUzQW9maSUyRmZtdCUz QWtldiUzQW10eCUzQWJvb2smYW1wO3JmdC5nZW5yZT1ib29rJmFtcDtyZnJfaWQ9aW5mbyUzQXNp ZCUyRmRlLndpa2lwZWRpYS5vcmclM0FHZW9yZ2UrVy4rQnVzaCZhbXA7cmZ0LmJ0aXRsZT1BK0No YXJnZSt0bytLZWVwJmFtcDtyZnQuYXU9R2VvcmdlK1cuK0J1c2gmYW1wO3JmdC5kYXRlPTE5OTkm YW1wO3JmdC5wdWI9V2lsbGlhbStNb3Jyb3crJTI2K0NvbXBhbnkmYW1wO3JmdC5pc2JuPTAtNjg4 LTE3NDQxLTgiPiYjMTYwOzwvc3Bhbj48L2xpPgk8bGk+Um9iZXJ0IHZvbiBSaW1zY2hhOiA8aT5H ZW9yZ2UgVy4gQnVzaC4gUHLDpHNpZGVudCBpbiBLcmlzZW56ZWl0ZW48L2k+LiBIZXluZSwgTcO8 bmNoZW4gMjAwMSwgPGEgaHJlZj0iL3dpa2kvU3BlemlhbDpJU0JOLVN1Y2hlLzM0NTMyMTI0NTIi IGNsYXNzPSJpbnRlcm5hbCBtdy1tYWdpY2xpbmstaXNibiI+SVNCTiAzLTQ1My0yMTI0NS0yPC9h Pi48L2xpPgk8bGk+SmFtZXMgSC4gSGF0ZmllbGQ6IDxpPkRhcyBCdXNoLUltcGVyaXVtLiBXaWUg R2VvcmcgVy4gQnVzaCB6dW0gUHLDpHNpZGVudGVuIGdlbWFjaHQgd3VyZGU8L2k+LiBBdGxhbnRp aywgQnJlbWVuIDIwMDIsIDxhIGhyZWY9Ii93aWtpL1NwZXppYWw6SVNCTi1TdWNoZS8zOTI2NTI5 NDIzIiBjbGFzcz0iaW50ZXJuYWwgbXctbWFnaWNsaW5rLWlzYm4iPklTQk4gMy05MjY1MjktNDIt MzwvYT4uPC9saT4JPGxpPkVyaWMgTGF1cmVudDogPGk+RGllIEtyaWVnZSBkZXIgRmFtaWxpZSBC dXNoLiBEaWUgd2FocmVuIEhpbnRlcmdyw7xuZGUgZGVzIElyYWstS29uZmxpa3RzPC9pPi4gUy4g RmlzY2hlciwgRnJhbmtmdXJ0IGFtIE1haW4gMjAwMywgPGEgaHJlZj0iL3dpa2kvU3BlemlhbDpJ U0JOLVN1Y2hlLzMxMDA0NDg1MDIiIGNsYXNzPSJpbnRlcm5hbCBtdy1tYWdpY2xpbmstaXNibiI+ SVNCTiAzLTEwLTA0NDg1MC0yPC9hPi48L2xpPgk8bGk+PGEgaHJlZj0iL3dpa2kvTWljaGFlbF9N b29yZSIgdGl0bGU9Ik1pY2hhZWwgTW9vcmUiPk1pY2hhZWwgTW9vcmU8L2E+OiA8aT5TdHVwaWQg V2hpdGUgTWVuLiBFaW5lIEFicmVjaG51bmcgbWl0IGRlbSBBbWVyaWthIHVudGVyIEdlb3JnZSBX LiBCdXNoPC9pPi4gUGlwZXIsIE3DvG5jaGVuIDIwMDMsIDxhIGhyZWY9Ii93aWtpL1NwZXppYWw6 SVNCTi1TdWNoZS8zNDkyMDQ1MTcwIiBjbGFzcz0iaW50ZXJuYWwgbXctbWFnaWNsaW5rLWlzYm4i PklTQk4gMy00OTItMDQ1MTctMDwvYT4uPC9saT4JPGxpPk1pY2hhZWwgTW9vcmU6IDxpPlZvbGxl IERlY2t1bmcgTXIuIEJ1c2guIER1ZGUsIHdoZXJl4oCZcyBteSBjb3VudHJ5PzwvaT4gUGlwZXIs IE3DvG5jaGVuIDIwMDMsIDxhIGhyZWY9Ii93aWtpL1NwZXppYWw6SVNCTi1TdWNoZS8zNDkyMDQ2 MTQyIiBjbGFzcz0iaW50ZXJuYWwgbXctbWFnaWNsaW5rLWlzYm4iPklTQk4gMy00OTItMDQ2MTQt MjwvYT4uPC9saT4JPGxpPkphY29iIFdlaXNiZXJnIChIcnNnLiksIDxhIGhyZWY9Ii93aWtpL0dl cmhhcmRfSGVuc2NoZWwiIHRpdGxlPSJHZXJoYXJkIEhlbnNjaGVsIj5HZXJoYXJkIEhlbnNjaGVs PC9hPiwgPGEgaHJlZj0iL3dpa2kvS2F0aHJpbl9QYXNzaWciIHRpdGxlPSJLYXRocmluIFBhc3Np ZyI+S2F0aHJpbiBQYXNzaWc8L2E+OiA8aT5Wb2xsIGRhbmViZW4sIE1yLiBQcmVzaWRlbnQhIFdh aHJlIFdvcnRlIHZvbiBHZW9yZ2UgVy4gQnVzaDwvaT4uIFJvd29obHQtVGFzY2hlbmJ1Y2gtVmVy bGFnLCBSZWluYmVrIDIwMDMsIDxhIGhyZWY9Ii93aWtpL1NwZXppYWw6SVNCTi1TdWNoZS8zNDk5 NjE2MTlYIiBjbGFzcz0iaW50ZXJuYWwgbXctbWFnaWNsaW5rLWlzYm4iPklTQk4gMy00OTktNjE2 MTktWDwvYT4uPC9saT4JPGxpPkJvYiBXb29kd2FyZDogPGk+QnVzaCBhdCB3YXIuIEFtZXJpa2Eg aW0gS3JpZWc8L2k+LiBEVkEsIE3DvG5jaGVuIDIwMDMsIDxhIGhyZWY9Ii93aWtpL1NwZXppYWw6 SVNCTi1TdWNoZS8zNDIxMDU2OTg2IiBjbGFzcz0iaW50ZXJuYWwgbXctbWFnaWNsaW5rLWlzYm4i PklTQk4gMy00MjEtMDU2OTgtNjwvYT4uPC9saT4JPGxpPjxhIGhyZWY9Ii93aWtpL1JpY2hhcmRf Q2xhcmtlIiB0aXRsZT0iUmljaGFyZCBDbGFya2UiPlJpY2hhcmQgQS4gQ2xhcmtlPC9hPjogPGk+ QWdhaW5zdCBBbGwgRW5lbWllcy4gRGVyIEluc2lkZXJiZXJpY2h0IMO8YmVyIEFtZXJpa2FzIEty aWVnIGdlZ2VuIGRlbiBUZXJyb3IuPC9pPiBIb2ZmbWFubiAmYW1wOyBDYW1wZSwgSGFtYnVyZyAy MDA0LCA8YSBocmVmPSIvd2lraS9TcGV6aWFsOklTQk4tU3VjaGUvMzQ1NTA5NDc4MyIgY2xhc3M9 ImludGVybmFsIG13LW1hZ2ljbGluay1pc2JuIj5JU0JOIDMtNDU1LTA5NDc4LTM8L2E+IChkZXV0 c2NoZSBBdXNnYWJlIGRlcyBnbGVpY2huYW1pZ2VuIEJ1Y2hlcyBkZXMgZWhlbWFsaWdlbiBSZWdp ZXJ1bmdzYmVyYXRlcnM7IE9yaWdpbmFsdGl0ZWw6IDxpPkFnYWluc3QgQWxsIEVuZW1pZXM6IElu c2lkZSBBbWVyaWNh4oCZcyBXYXIgb24gVGVycm9yIOKAkyBXaGF0IFJlYWxseSBIYXBwZW5lZDwv aT4uKTwvbGk+CTxsaT5IYW5zIExleWVuZGVja2VyOiA8aT5EaWUgTMO8Z2VuIGRlcyBXZWnDn2Vu IEhhdXNlczwvaT4uIFJvd29obHQsIFJlaW5iZWsgMjAwNCwgPGEgaHJlZj0iL3dpa2kvU3Blemlh bDpJU0JOLVN1Y2hlLzM0OTgwMzkyMDIiIGNsYXNzPSJpbnRlcm5hbCBtdy1tYWdpY2xpbmstaXNi biI+SVNCTiAzLTQ5OC0wMzkyMC0yPC9hPi48L2xpPgk8bGk+PGEgaHJlZj0iL3dpa2kvUGV0ZXJf U2luZ2VyIiB0aXRsZT0iUGV0ZXIgU2luZ2VyIj5QZXRlciBTaW5nZXI8L2E+OiA8aT5EZXIgUHLD pHNpZGVudCBkZXMgR3V0ZW4gdW5kIELDtnNlbi4gRGllIEV0aGlrIEdlb3JnZSBXLiBCdXNoczwv aT4uIEhhcmFsZCBGaXNjaGVyIFZlcmxhZywgRXJsYW5nZW4gMjAwNCwgPGEgaHJlZj0iL3dpa2kv U3BlemlhbDpJU0JOLVN1Y2hlLzM4OTEzMTQxMzIiIGNsYXNzPSJpbnRlcm5hbCBtdy1tYWdpY2xp bmstaXNibiI+SVNCTiAzLTg5MTMxLTQxMy0yPC9hPiAoT3JpZ2luYWx0aXRlbDogPGk+VGhlIFBy ZXNpZGVudCBvZiBHb29kIGFuZCBFdmlsPC9pPikuPC9saT4JPGxpPjxhIGhyZWY9Ii93aWtpL0Ny YWlnX1VuZ2VyIiB0aXRsZT0iQ3JhaWcgVW5nZXIiPkNyYWlnIFVuZ2VyPC9hPjogPGk+RGllIEJ1 c2hzIHVuZCBkaWUgU2F1ZHMuIMOWbCwgTWFjaHQgdW5kIFRlcnJvcjwvaT4uIFBpcGVyLCBNw7xu Y2hlbiAyMDA0LCA8YSBocmVmPSIvd2lraS9TcGV6aWFsOklTQk4tU3VjaGUvMzQ5MjA0NjMwNCIg Y2xhc3M9ImludGVybmFsIG13LW1hZ2ljbGluay1pc2JuIj5JU0JOIDMtNDkyLTA0NjMwLTQ8L2E+ LjwvbGk+CTxsaT5Cb2IgV29vZHdhcmQ6IDxpPkRlciBBbmdyaWZmLiBQbGFuIG9mIEF0dGFjazwv aT4uIERWQSwgTcO8bmNoZW4gMjAwNCwgPGEgaHJlZj0iL3dpa2kvU3BlemlhbDpJU0JOLVN1Y2hl LzM0MjEwNTc4NzciIGNsYXNzPSJpbnRlcm5hbCBtdy1tYWdpY2xpbmstaXNibiI+SVNCTiAzLTQy MS0wNTc4Ny03PC9hPi48L2xpPgk8bGk+UGV0ZXIgU2Nob2xsLUxhdG91cjogPGk+V2VsdG1hY2h0 IGltIFRyZWlic2FuZC4gQnVzaCBnZWdlbiBkaWUgQXlhdG9sbGFoczwvaT4uIFVsbHN0ZWluLCBC ZXJsaW4gMjAwNSwgPGEgaHJlZj0iL3dpa2kvU3BlemlhbDpJU0JOLVN1Y2hlLzM1NDgzNjc4Mjgi IGNsYXNzPSJpbnRlcm5hbCBtdy1tYWdpY2xpbmstaXNibiI+SVNCTiAzLTU0OC0zNjc4Mi04PC9h Pi48L2xpPgk8L3VsPgk8aDI+PHNwYW4gY2xhc3M9Im13LWhlYWRsaW5lIiBpZD0iRWluemVsbmFj aHdlaXNlIj5FaW56ZWxuYWNod2Vpc2U8L3NwYW4+PC9oMj4JPG9sIGNsYXNzPSJyZWZlcmVuY2Vz Ij4JPGxpIGlkPSJjaXRlX25vdGUtMCI+PGEgaHJlZj0iI2NpdGVfcmVmLTAiPuKGkTwvYT4gPGEg aHJlZj0iaHR0cDovL3d3dy5wYnMub3JnL3dnYmgvcGFnZXMvZnJvbnRsaW5lL3Nob3dzL2Nob2lj ZTIwMDAvYnVzaC9jcm9uLmh0bWwiIGNsYXNzPSJleHRlcm5hbCB0ZXh0IiByZWw9Im5vZm9sbG93 Ij5CdXNoIENocm9ub2xvZ3k8L2E+IGF1ZiB3d3cucGJzLm9yZywgYWJnZXJ1ZmVuIGFtIDIzLiBE ZXplbWJlciAyMDA4LjwvbGk+CTxsaSBpZD0iY2l0ZV9ub3RlLTEiPjxhIGhyZWY9IiNjaXRlX3Jl Zi0xIj7ihpE8L2E+IDxhIGhyZWY9Ii93aWtpL05ld19Zb3JrX1RpbWVzIiB0aXRsZT0iTmV3IFlv cmsgVGltZXMiIGNsYXNzPSJtdy1yZWRpcmVjdCI+TmV3IFlvcmsgVGltZXM8L2E+OiA8YSBocmVm PSJodHRwOi8vd3d3Lm55dGltZXMuY29tLzIwMDgvMDYvMTkvd2FzaGluZ3Rvbi8xOWRyaWxsLmh0 bWw/X3I9MSZhbXA7cGFydG5lcj1yc3NueXQiIGNsYXNzPSJleHRlcm5hbCB0ZXh0IiByZWw9Im5v Zm9sbG93Ij5CdXNoIENhbGxzIGZvciBFbmQgdG8gQmFuIG9uIE9mZnNob3JlIE9pbCBEcmlsbGlu ZzwvYT4sIDE5LiBKdW5pIDIwMDg8L2xpPgk8bGkgaWQ9ImNpdGVfbm90ZS0yIj48YSBocmVmPSIj Y2l0ZV9yZWYtMiI+4oaRPC9hPiBQcmVzc2V2ZXLDtmZmZW50bGljaHVuZyBkZXMgPGEgaHJlZj0i L3dpa2kvV2VpJUMzJTlGZXNfSGF1cyIgdGl0bGU9IldlacOfZXMgSGF1cyI+V2Vpw59lbiBIYXVz ZXM8L2E+IHZvbSA5LiBNYWkgMjAwNzogPGEgaHJlZj0iaHR0cDovL2dlb3JnZXdidXNoLXdoaXRl aG91c2UuYXJjaGl2ZXMuZ292L25ld3MvcmVsZWFzZXMvMjAwNy8wNS8yMDA3MDUwOS0xMi5odG1s IiBjbGFzcz0iZXh0ZXJuYWwgdGV4dCIgcmVsPSJub2ZvbGxvdyI+PGk+TmF0aW9uYWwgU2VjdXJp dHkgYW5kIEhvbWVsYW5kIFNlY3VyaXR5IFByZXNpZGVudGlhbCBEaXJlY3RpdmU8L2k+PC9hPjwv bGk+CTxsaSBpZD0iY2l0ZV9ub3RlLTMiPjxhIGhyZWY9IiNjaXRlX3JlZi0zIj7ihpE8L2E+IERl ciBTcGllZ2VsIE5yLiAzNiwgNS4gU2VwdGVtYmVyIDIwMDUsIGRpZSBOZXcgWW9yayBUaW1lcyB2 b20gNC4gU2VwdGVtYmVyIDIwMDU8L2xpPgk8bGkgaWQ9ImNpdGVfbm90ZS00Ij48YSBocmVmPSIj Y2l0ZV9yZWYtNCI+4oaRPC9hPiA8YSBocmVmPSJodHRwOi8vd3d3LnRhZ2Vzc2NoYXUuZGUvYWt0 dWVsbC9tZWxkdW5nZW4vMCwxMTg1LE9JRDYwMzc5MzJfUkVGMV9OQVZfQkFCLDAwLmh0bWwiIGNs YXNzPSJleHRlcm5hbCBmcmVlIiByZWw9Im5vZm9sbG93Ij5odHRwOi8vd3d3LnRhZ2Vzc2NoYXUu ZGUvYWt0dWVsbC9tZWxkdW5nZW4vMCwxMTg1LE9JRDYwMzc5MzJfUkVGMV9OQVZfQkFCLDAwLmh0 bWw8L2E+PC9saT4JPGxpIGlkPSJjaXRlX25vdGUtNSI+PGEgaHJlZj0iI2NpdGVfcmVmLTUiPuKG kTwvYT4gPGEgaHJlZj0iaHR0cDovL3d3dy5zcGllZ2VsLmRlL3BvbGl0aWsvYXVzbGFuZC8wLDE1 MTgsNTQwMjkwLDAwLmh0bWwiIGNsYXNzPSJleHRlcm5hbCB0ZXh0IiByZWw9Im5vZm9sbG93Ij5z cGllZ2VsLmRlLCDigJ5XQVRFUkJPQVJESU5HIOKAkyBCdXNoIGJsb2NraWVydCBBbnRpLUZvbHRl ci1HZXNldHrigJwsIDguIE3DpHJ6IDIwMDg8L2E+PC9saT4JPGxpIGlkPSJjaXRlX25vdGUtNiI+ PGEgaHJlZj0iI2NpdGVfcmVmLTYiPuKGkTwvYT4gPGEgaHJlZj0iL3dpa2kvTlpaIiB0aXRsZT0i TlpaIiBjbGFzcz0ibXctcmVkaXJlY3QiPk5aWjwvYT46IDxhIGhyZWY9Imh0dHA6Ly93d3cubnp6 LmNoL25hY2hyaWNodGVuL3NjaHdlaXovYnVzaF90b2Rlc3N0cmFmZV91cy1zb2xkYXRfMS43OTQ3 ODEuaHRtbCIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ciPkJ1c2ggc3RpbW10 IFRvZGVzc3RyYWZlIGdlZ2VuIHZlcnVydGVpbHRlbiBVUy1Tb2xkYXRlbiB6dTwvYT4gMjkuIEp1 bGkgMjAwODwvbGk+CTxsaSBpZD0iY2l0ZV9ub3RlLTciPjxhIGhyZWY9IiNjaXRlX3JlZi03Ij7i hpE8L2E+IDxhIGhyZWY9Imh0dHA6Ly93d3cuZmF6Lm5ldC9zL1J1YjU4MjQxRTRERjFCMTQ5NTM4 QUJDMjREMEU4MkE2MjY2L0RvY35FQjBGMjA0MDQzRUM5NDY0MzgwQkQ4MjA5NTQzNzMzQkV+QVRw bH5FY29tbW9uflNjb250ZW50Lmh0bWwsIiBjbGFzcz0iZXh0ZXJuYWwgdGV4dCIgcmVsPSJub2Zv bGxvdyI+4oCeQnVzaCBiZXNjaHfDtnJ0IEFiZ2VvcmRuZXRl4oCcPC9hPjwvbGk+CTxsaSBpZD0i Y2l0ZV9ub3RlLTgiPjxhIGhyZWY9IiNjaXRlX3JlZi04Ij7ihpE8L2E+IDxhIGhyZWY9Imh0dHA6 Ly93d3cubWRyLmRlL25hY2hyaWNodGVuL21lbGR1bmdlbi80MDY4ODIzLmh0bWwiIGNsYXNzPSJl eHRlcm5hbCB0ZXh0IiByZWw9Im5vZm9sbG93Ij5OYWNocmljaHRlbiB8IE1EUi5ERTwvYT48L2xp Pgk8bGkgaWQ9ImNpdGVfbm90ZS0tOSI+PGEgaHJlZj0iI2NpdGVfcmVmLV85LTAiPuKGkTwvYT4g PGEgaHJlZj0iaHR0cDovL3d3dy5ueXRpbWVzLmNvbS8yMDA5LzAzLzE5L3VzL3BvbGl0aWNzLzE5 YnVzaC5odG1sP19yPTEiIGNsYXNzPSJleHRlcm5hbCBmcmVlIiByZWw9Im5vZm9sbG93Ij5odHRw Oi8vd3d3Lm55dGltZXMuY29tLzIwMDkvMDMvMTkvdXMvcG9saXRpY3MvMTlidXNoLmh0bWw/X3I9 MTwvYT48L2xpPgk8bGkgaWQ9ImNpdGVfbm90ZS0xMCI+PGEgaHJlZj0iI2NpdGVfcmVmLTEwIj7i hpE8L2E+IDxjaXRlIHN0eWxlPSJmb250LXN0eWxlOm5vcm1hbCI+PGk+UHLDpHNlbnQgZsO8ciBQ csOkc2lkZW50ZW48L2k+LiAgSW46IDxpPjxhIGhyZWY9Ii93aWtpL0JpbGRfZGVyX1dpc3NlbnNj aGFmdCIgdGl0bGU9IkJpbGQgZGVyIFdpc3NlbnNjaGFmdCI+QmlsZCBkZXIgV2lzc2Vuc2NoYWZ0 PC9hPjwvaT4uIDcsIDIwMDksIFMuIDExLjwvY2l0ZT48L2xpPgk8L29sPgk8aDI+PHNwYW4gY2xh c3M9Im13LWhlYWRsaW5lIiBpZD0iV2VibGlua3MiPldlYmxpbmtzPC9zcGFuPjwvaDI+CTxkaXYg Y2xhc3M9InNpc3RlcnByb2plY3QiIHN0eWxlPSJtYXJnaW46MC4xZW0gMCAwIDA7Ij48aW1nIGFs dD0iIiBzcmM9Imh0dHA6Ly91cGxvYWQud2lraW1lZGlhLm9yZy93aWtpcGVkaWEvY29tbW9ucy90 aHVtYi80LzRhL0NvbW1vbnMtbG9nby5zdmcvMTJweC1Db21tb25zLWxvZ28uc3ZnLnBuZyIgd2lk dGg9IjEyIiBoZWlnaHQ9IjE2IiAvPiYjMTYwOzxiPjxzcGFuIGNsYXNzPSJwbGFpbmxpbmtzIj48 YSBocmVmPSJodHRwOi8vY29tbW9ucy53aWtpbWVkaWEub3JnL3dpa2kvQ2F0ZWdvcnk6R2Vvcmdl X1cuX0J1c2g/dXNlbGFuZz1kZSIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ci PkNvbW1vbnM6IEdlb3JnZSBXLiBCdXNoPC9hPjwvc3Bhbj48L2I+JiMxNjA74oCTIFNhbW1sdW5n IHZvbiBCaWxkZXJuLCBWaWRlb3MgdW5kIEF1ZGlvZGF0ZWllbjwvZGl2Pgk8ZGl2IGNsYXNzPSJz aXN0ZXJwcm9qZWN0IiBzdHlsZT0ibWFyZ2luOjAuMWVtIDAgMCAwOyI+PGltZyBhbHQ9Ildpa2lx dW90ZSIgc3JjPSJodHRwOi8vdXBsb2FkLndpa2ltZWRpYS5vcmcvd2lraXBlZGlhL2NvbW1vbnMv dGh1bWIvZi9mYS9XaWtpcXVvdGUtbG9nby5zdmcvMTNweC1XaWtpcXVvdGUtbG9nby5zdmcucG5n IiB3aWR0aD0iMTMiIGhlaWdodD0iMTUiIC8+JiMxNjA7PGI+PGEgaHJlZj0iaHR0cDovL2RlLndp a2lxdW90ZS5vcmcvd2lraS9HZW9yZ2VfVy5fQnVzaCIgY2xhc3M9ImV4dGl3IiB0aXRsZT0icTpH ZW9yZ2UgVy4gQnVzaCI+V2lraXF1b3RlOiBHZW9yZ2UgVy4gQnVzaDwvYT48L2I+JiMxNjA74oCT IFppdGF0ZTwvZGl2Pgk8ZGl2IGNsYXNzPSJzaXN0ZXJwcm9qZWN0IiBzdHlsZT0ibWFyZ2luOjAu MWVtIDAgMCAwOyI+PGltZyBhbHQ9Ildpa2lzb3VyY2UiIHNyYz0iaHR0cDovL3VwbG9hZC53aWtp bWVkaWEub3JnL3dpa2lwZWRpYS9jb21tb25zL3RodW1iLzQvNGMvV2lraXNvdXJjZS1sb2dvLnN2 Zy8xNXB4LVdpa2lzb3VyY2UtbG9nby5zdmcucG5nIiB3aWR0aD0iMTUiIGhlaWdodD0iMTYiIC8+ JiMxNjA7PGI+PGEgaHJlZj0iaHR0cDovL2RlLndpa2lzb3VyY2Uub3JnL3dpa2kvZW46QXV0aG9y Okdlb3JnZV9XYWxrZXJfQnVzaCIgY2xhc3M9ImV4dGl3IiB0aXRsZT0iczplbjpBdXRob3I6R2Vv cmdlIFdhbGtlciBCdXNoIj5XaWtpc291cmNlOiBHZW9yZ2UgVy4gQnVzaDwvYT48L2I+JiMxNjA7 4oCTIFF1ZWxsZW4gdW5kIFZvbGx0ZXh0ZSAoRW5nbGlzY2gpPC9kaXY+CTx1bD4JPGxpPjxhIGhy ZWY9Imh0dHBzOi8vcG9ydGFsLmQtbmIuZGUvb3BhYy5odG0/cXVlcnk9V29lJTNEMTIxNDUzOTFY JmFtcDttZXRob2Q9c2ltcGxlU2VhcmNoIiBjbGFzcz0iZXh0ZXJuYWwgdGV4dCIgcmVsPSJub2Zv bGxvdyI+TGl0ZXJhdHVyIHZvbiB1bmQgw7xiZXIgR2VvcmdlIFcuIEJ1c2g8L2E+IGltIEthdGFs b2cgZGVyIDxhIGhyZWY9Ii93aWtpL0RldXRzY2hlX05hdGlvbmFsYmlibGlvdGhlayIgdGl0bGU9 IkRldXRzY2hlIE5hdGlvbmFsYmlibGlvdGhlayI+RGV1dHNjaGVuIE5hdGlvbmFsYmlibGlvdGhl azwvYT4gPHNwYW4gY2xhc3M9Im1ldGFkYXRhIj48c21hbGw+KDxhIGhyZWY9Imh0dHA6Ly9kaXNw YXRjaC5vcGFjLmQtbmIuZGUvREI9NC4xL1BQTj9QUE49MTIxNDUzOTFYIiBjbGFzcz0iZXh0ZXJu YWwgdGV4dCIgcmVsPSJub2ZvbGxvdyI+RGF0ZW5zYXR6IHp1IEdlb3JnZSBXLiBCdXNoPC9hPiDi gKIgPGEgaHJlZj0iaHR0cDovL2Rpc3BhdGNoLm9wYWMuZC1uYi5kZS9EQj00LjEvU0VUPTQvVFRM PTEvUFJTPVBQJTdGL1BQTj9QUE49MTIxNDUzOTFYIiBjbGFzcz0iZXh0ZXJuYWwgdGV4dCIgcmVs PSJub2ZvbGxvdyI+UElDQS1EYXRlbnNhdHo8L2E+IOKAoiA8YSBocmVmPSJodHRwOi8vdG9vbHNl cnZlci5vcmcvfmFwcGVyL3BkL3BlcnNvbi9wbmQvMTIxNDUzOTFYIiBjbGFzcz0iZXh0ZXJuYWwg dGV4dCIgcmVsPSJub2ZvbGxvdyI+QXBwZXItUGVyc29uZW5zdWNoZTwvYT4pPC9zbWFsbD48L3Nw YW4+PC9saT4JPGxpPjxhIGhyZWY9Imh0dHA6Ly93d3cuZ2Vvcmdld2J1c2hsaWJyYXJ5LmNvbS8i IGNsYXNzPSJleHRlcm5hbCB0ZXh0IiByZWw9Im5vZm9sbG93Ij5HZW9yZ2UgVy4gQnVzaCBQcmVz aWRlbnRpYWwgTGlicmFyeTwvYT4gKGVuZ2xpc2NoKTwvbGk+CTxsaT48YSBocmVmPSJodHRwOi8v d3d3Lm5hY2hkZW5rc2VpdGVuLmRlLz9wPTIxMDYjbW9yZS0yMTA2IiBjbGFzcz0iZXh0ZXJuYWwg dGV4dCIgcmVsPSJub2ZvbGxvdyI+SG93YXJkIFppbm46IEFtdHNlbnRoZWJ1bmcgZHVyY2ggZGFz IFZvbGs8L2E+PC9saT4JPGxpPjxhIGhyZWY9Imh0dHA6Ly93d3cubmV0emVpdHVuZy5kZS9zcGV6 aWFsL3Vzd2FobGVuMjAwNC8yODU4NDYuaHRtbCIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0i bm9mb2xsb3ciPlBvcnRyw6R0OiBEZXIgUG9sYXJpc2llcmVyPC9hPiAoPGEgaHJlZj0iL3dpa2kv TmV0emVpdHVuZyIgdGl0bGU9Ik5ldHplaXR1bmciPk5ldHplaXR1bmc8L2E+LCBOZXVmYXNzdW5n IHZvbSAzLiBOb3ZlbWJlciAyMDA0KTwvbGk+CTxsaT48YSBocmVmPSJodHRwOi8vd3d3Lndzd3Mu b3JnL2RlLzIwMDIvYXVnMjAwMi90ZXhhLWEwOS5zaHRtbCIgY2xhc3M9ImV4dGVybmFsIHRleHQi IHJlbD0ibm9mb2xsb3ciPkpvc2VwaCBLYXksIFdpZSBHZW9yZ2UgVy4gQnVzaCB6dSBzZWluZW4g TWlsbGlvbmVuIGthbTwvYT4gKFdTV1MsIDkuIEF1Z3VzdCAyMDAyKTwvbGk+CTxsaT48YSBocmVm PSJodHRwOi8vd3d3Lndkci5kZS90aGVtZW4vX2ltYWdlc18vaW1hZ2VzLzIvcG9saXRpay9pbnRl cm5hdGlvbmFsL3VzYS9kYXNfa2FydGVsbC5wZGYiIGNsYXNzPSJleHRlcm5hbCB0ZXh0IiByZWw9 Im5vZm9sbG93Ij5IZWxtdXQgR3Jvc3NlLCBEYXMgS2FydGVsbCDigJMgTWFudXNrcmlwdCB6dXIg U2VuZHVuZzwvYT4gKDxhIGhyZWY9Ii93aWtpL1dlc3RkZXV0c2NoZXJfUnVuZGZ1bmsiIHRpdGxl PSJXZXN0ZGV1dHNjaGVyIFJ1bmRmdW5rIiBjbGFzcz0ibXctcmVkaXJlY3QiPldEUjwvYT4sIEF1 c3N0cmFobHVuZzogQVJEIDIyLiBKYW51YXIgMjAwMyDigJMgUERGOyA2MSBrQik8L2xpPgk8bGk+ PGEgaHJlZj0iaHR0cDovL3d3dy5hcmNoaXZlcy5nb3YvcHJlc2lkZW50aWFsLWxpYnJhcmllcy92 aXNpdC9idXNoZ3cuaHRtbCIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ciPkdl b3JnZSBXLiBCdXNoIFByZXNpZGVudGlhbCBMaWJyYXJ5IGFuZCBNdXNldW08L2E+LCA8YSBocmVm PSIvd2lraS9OYXRpb25hbF9BcmNoaXZlc19hbmRfUmVjb3Jkc19BZG1pbmlzdHJhdGlvbiIgdGl0 bGU9Ik5hdGlvbmFsIEFyY2hpdmVzIGFuZCBSZWNvcmRzIEFkbWluaXN0cmF0aW9uIj5OYXRpb25h bCBBcmNoaXZlcyBhbmQgUmVjb3JkcyBBZG1pbmlzdHJhdGlvbjwvYT48L2xpPgk8L3VsPgk8ZGl2 IGNsYXNzPSJCb3hlblZlcnNjaG1lbHplbiI+CTxkaXYgY2xhc3M9Ik5hdkZyYW1lIj4JPGRpdiBj bGFzcz0iTmF2UGljIj48YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9RGF0ZWk6U2VhbF9PZl9U aGVfUHJlc2lkZW50X09mX1RoZV9Vbml0ZWRfU3RhdGVzX09mX0FtZXJpY2Euc3ZnJmFtcDtmaWxl dGltZXN0YW1wPTIwMDcxMTA0MDYzNTU5IiBjbGFzcz0iaW1hZ2UiIHRpdGxlPSJTaWVnZWwgZGVz IFByw6RzaWRlbnRlbiBkZXIgVmVyZWluaWd0ZW4gU3RhYXRlbiI+PGltZyBhbHQ9IlNpZWdlbCBk ZXMgUHLDpHNpZGVudGVuIGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuIiBzcmM9Imh0dHA6Ly91cGxv YWQud2lraW1lZGlhLm9yZy93aWtpcGVkaWEvY29tbW9ucy90aHVtYi9mL2ZhL1NlYWxfT2ZfVGhl X1ByZXNpZGVudF9PZl9UaGVfVW5pdGVkX1N0YXRlc19PZl9BbWVyaWNhLnN2Zy85MHB4LVNlYWxf T2ZfVGhlX1ByZXNpZGVudF9PZl9UaGVfVW5pdGVkX1N0YXRlc19PZl9BbWVyaWNhLnN2Zy5wbmci IHdpZHRoPSI5MCIgaGVpZ2h0PSI5MCIgLz48L2E+PC9kaXY+CTxkaXYgY2xhc3M9Ik5hdkhlYWQi PjxhIGhyZWY9Ii93aWtpL0xpc3RlX2Rlcl9QciVDMyVBNHNpZGVudGVuX2Rlcl9WZXJlaW5pZ3Rl bl9TdGFhdGVuIiB0aXRsZT0iTGlzdGUgZGVyIFByw6RzaWRlbnRlbiBkZXIgVmVyZWluaWd0ZW4g U3RhYXRlbiI+UHLDpHNpZGVudGVuIGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuPC9hPjwvZGl2Pgk8 ZGl2IGNsYXNzPSJOYXZDb250ZW50Ij4JPHA+PGEgaHJlZj0iL3dpa2kvR2VvcmdlX1dhc2hpbmd0 b24iIHRpdGxlPSJHZW9yZ2UgV2FzaGluZ3RvbiI+R2VvcmdlIFdhc2hpbmd0b248L2E+JiMxNjA7 fCA8YSBocmVmPSIvd2lraS9Kb2huX0FkYW1zIiB0aXRsZT0iSm9obiBBZGFtcyI+Sm9obiBBZGFt czwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1Rob21hc19KZWZmZXJzb24iIHRpdGxlPSJUaG9t YXMgSmVmZmVyc29uIj5UaG9tYXMgSmVmZmVyc29uPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kv SmFtZXNfTWFkaXNvbiIgdGl0bGU9IkphbWVzIE1hZGlzb24iPkphbWVzIE1hZGlzb248L2E+JiMx NjA7fCA8YSBocmVmPSIvd2lraS9KYW1lc19Nb25yb2UiIHRpdGxlPSJKYW1lcyBNb25yb2UiPkph bWVzIE1vbnJvZTwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0pvaG5fUXVpbmN5X0FkYW1zIiB0 aXRsZT0iSm9obiBRdWluY3kgQWRhbXMiPkpvaG4gUXVpbmN5IEFkYW1zPC9hPiYjMTYwO3wgPGEg aHJlZj0iL3dpa2kvQW5kcmV3X0phY2tzb24iIHRpdGxlPSJBbmRyZXcgSmFja3NvbiI+QW5kcmV3 IEphY2tzb248L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9NYXJ0aW5fVmFuX0J1cmVuIiB0aXRs ZT0iTWFydGluIFZhbiBCdXJlbiI+TWFydGluIFZhbiBCdXJlbjwvYT4mIzE2MDt8IDxhIGhyZWY9 Ii93aWtpL1dpbGxpYW1fSC5fSGFycmlzb24iIHRpdGxlPSJXaWxsaWFtIEguIEhhcnJpc29uIj5X aWxsaWFtIEguIEhhcnJpc29uPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSm9obl9UeWxlciIg dGl0bGU9IkpvaG4gVHlsZXIiPkpvaG4gVHlsZXI8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9K YW1lc19LLl9Qb2xrIiB0aXRsZT0iSmFtZXMgSy4gUG9sayI+SmFtZXMgSy4gUG9sazwvYT4mIzE2 MDt8IDxhIGhyZWY9Ii93aWtpL1phY2hhcnlfVGF5bG9yIiB0aXRsZT0iWmFjaGFyeSBUYXlsb3Ii PlphY2hhcnkgVGF5bG9yPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvTWlsbGFyZF9GaWxsbW9y ZSIgdGl0bGU9Ik1pbGxhcmQgRmlsbG1vcmUiPk1pbGxhcmQgRmlsbG1vcmU8L2E+JiMxNjA7fCA8 YSBocmVmPSIvd2lraS9GcmFua2xpbl9QaWVyY2UiIHRpdGxlPSJGcmFua2xpbiBQaWVyY2UiPkZy YW5rbGluIFBpZXJjZTwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0phbWVzX0J1Y2hhbmFuIiB0 aXRsZT0iSmFtZXMgQnVjaGFuYW4iPkphbWVzIEJ1Y2hhbmFuPC9hPiYjMTYwO3wgPGEgaHJlZj0i L3dpa2kvQWJyYWhhbV9MaW5jb2xuIiB0aXRsZT0iQWJyYWhhbSBMaW5jb2xuIj5BYnJhaGFtIExp bmNvbG48L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9BbmRyZXdfSm9obnNvbiIgdGl0bGU9IkFu ZHJldyBKb2huc29uIj5BbmRyZXcgSm9obnNvbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1Vs eXNzZXNfUy5fR3JhbnQiIHRpdGxlPSJVbHlzc2VzIFMuIEdyYW50Ij5VbHlzc2VzIFMuIEdyYW50 PC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvUnV0aGVyZm9yZF9CLl9IYXllcyIgdGl0bGU9IlJ1 dGhlcmZvcmQgQi4gSGF5ZXMiPlJ1dGhlcmZvcmQgQi4gSGF5ZXM8L2E+JiMxNjA7fCA8YSBocmVm PSIvd2lraS9KYW1lc19BLl9HYXJmaWVsZCIgdGl0bGU9IkphbWVzIEEuIEdhcmZpZWxkIj5KYW1l cyBBLiBHYXJmaWVsZDwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0NoZXN0ZXJfQS5fQXJ0aHVy IiB0aXRsZT0iQ2hlc3RlciBBLiBBcnRodXIiPkNoZXN0ZXIgQS4gQXJ0aHVyPC9hPiYjMTYwO3wg PGEgaHJlZj0iL3dpa2kvR3JvdmVyX0NsZXZlbGFuZCIgdGl0bGU9Ikdyb3ZlciBDbGV2ZWxhbmQi Pkdyb3ZlciBDbGV2ZWxhbmQ8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9CZW5qYW1pbl9IYXJy aXNvbiIgdGl0bGU9IkJlbmphbWluIEhhcnJpc29uIj5CZW5qYW1pbiBIYXJyaXNvbjwvYT4mIzE2 MDt8IDxhIGhyZWY9Ii93aWtpL0dyb3Zlcl9DbGV2ZWxhbmQiIHRpdGxlPSJHcm92ZXIgQ2xldmVs YW5kIj5Hcm92ZXIgQ2xldmVsYW5kPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvV2lsbGlhbV9N Y0tpbmxleSIgdGl0bGU9IldpbGxpYW0gTWNLaW5sZXkiPldpbGxpYW0gTWNLaW5sZXk8L2E+JiMx NjA7fCA8YSBocmVmPSIvd2lraS9UaGVvZG9yZV9Sb29zZXZlbHQiIHRpdGxlPSJUaGVvZG9yZSBS b29zZXZlbHQiPlRoZW9kb3JlIFJvb3NldmVsdDwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1dp bGxpYW1fSG93YXJkX1RhZnQiIHRpdGxlPSJXaWxsaWFtIEhvd2FyZCBUYWZ0Ij5XaWxsaWFtIEgu IFRhZnQ8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9Xb29kcm93X1dpbHNvbiIgdGl0bGU9Ildv b2Ryb3cgV2lsc29uIj5Xb29kcm93IFdpbHNvbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1dh cnJlbl9HLl9IYXJkaW5nIiB0aXRsZT0iV2FycmVuIEcuIEhhcmRpbmciPldhcnJlbiBHLiBIYXJk aW5nPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvQ2FsdmluX0Nvb2xpZGdlIiB0aXRsZT0iQ2Fs dmluIENvb2xpZGdlIj5DYWx2aW4gQ29vbGlkZ2U8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9I ZXJiZXJ0X0MuX0hvb3ZlciIgdGl0bGU9IkhlcmJlcnQgQy4gSG9vdmVyIj5IZXJiZXJ0IEMuIEhv b3ZlcjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0ZyYW5rbGluX0QuX1Jvb3NldmVsdCIgdGl0 bGU9IkZyYW5rbGluIEQuIFJvb3NldmVsdCI+RnJhbmtsaW4gRC4gUm9vc2V2ZWx0PC9hPiYjMTYw O3wgPGEgaHJlZj0iL3dpa2kvSGFycnlfUy5fVHJ1bWFuIiB0aXRsZT0iSGFycnkgUy4gVHJ1bWFu Ij5IYXJyeSBTLiBUcnVtYW48L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9Ed2lnaHRfRC5fRWlz ZW5ob3dlciIgdGl0bGU9IkR3aWdodCBELiBFaXNlbmhvd2VyIj5Ed2lnaHQgRC4gRWlzZW5ob3dl cjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0pvaG5fRi5fS2VubmVkeSIgdGl0bGU9IkpvaG4g Ri4gS2VubmVkeSI+Sm9obiBGLiBLZW5uZWR5PC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvTHlu ZG9uX0IuX0pvaG5zb24iIHRpdGxlPSJMeW5kb24gQi4gSm9obnNvbiI+THluZG9uIEIuIEpvaG5z b248L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9SaWNoYXJkX05peG9uIiB0aXRsZT0iUmljaGFy ZCBOaXhvbiI+UmljaGFyZCBOaXhvbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0dlcmFsZF9G b3JkIiB0aXRsZT0iR2VyYWxkIEZvcmQiPkdlcmFsZCBGb3JkPC9hPiYjMTYwO3wgPGEgaHJlZj0i L3dpa2kvSmltbXlfQ2FydGVyIiB0aXRsZT0iSmltbXkgQ2FydGVyIj5KaW1teSBDYXJ0ZXI8L2E+ JiMxNjA7fCA8YSBocmVmPSIvd2lraS9Sb25hbGRfUmVhZ2FuIiB0aXRsZT0iUm9uYWxkIFJlYWdh biI+Um9uYWxkIFJlYWdhbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0dlb3JnZV9ILl9XLl9C dXNoIiB0aXRsZT0iR2VvcmdlIEguIFcuIEJ1c2giPkdlb3JnZSBILiBXLiBCdXNoPC9hPiYjMTYw O3wgPGEgaHJlZj0iL3dpa2kvQmlsbF9DbGludG9uIiB0aXRsZT0iQmlsbCBDbGludG9uIj5CaWxs IENsaW50b248L2E+JiMxNjA7fCA8c3Ryb25nIGNsYXNzPSJzZWxmbGluayI+R2VvcmdlIFcuIEJ1 c2g8L3N0cm9uZz4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0JhcmFja19PYmFtYSIgdGl0bGU9IkJh cmFjayBPYmFtYSI+QmFyYWNrIE9iYW1hPC9hPjwvcD4JPC9kaXY+CTxkaXYgY2xhc3M9InZpc3Vh bENsZWFyIj48L2Rpdj4JPC9kaXY+CTxkaXYgY2xhc3M9Ik5hdkZyYW1lIj4JPGRpdiBjbGFzcz0i TmF2UGljIj48YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9RGF0ZWk6U2VhbF9vZl9UZXhhcy5z dmcmYW1wO2ZpbGV0aW1lc3RhbXA9MjAwODEwMjAxNTM1NTEiIGNsYXNzPSJpbWFnZSIgdGl0bGU9 IlRleGFzIj48aW1nIGFsdD0iVGV4YXMiIHNyYz0iaHR0cDovL3VwbG9hZC53aWtpbWVkaWEub3Jn L3dpa2lwZWRpYS9jb21tb25zL3RodW1iL2MvY2IvU2VhbF9vZl9UZXhhcy5zdmcvNzVweC1TZWFs X29mX1RleGFzLnN2Zy5wbmciIHdpZHRoPSI3NSIgaGVpZ2h0PSI3NSIgLz48L2E+PC9kaXY+CTxk aXYgY2xhc3M9Ik5hdkhlYWQiPjxhIGhyZWY9Ii93aWtpL0xpc3RlX2Rlcl9Hb3V2ZXJuZXVyZV92 b25fVGV4YXMiIHRpdGxlPSJMaXN0ZSBkZXIgR291dmVybmV1cmUgdm9uIFRleGFzIj5QcsOkc2lk ZW50ZW4gdW5kIEdvdXZlcm5ldXJlIHZvbiBUZXhhczwvYT48L2Rpdj4JPGRpdiBjbGFzcz0iTmF2 Q29udGVudCI+CTxwPlJlcHVibGljIG9mIFRleGFzOjxiciAvPgk8YSBocmVmPSIvd2lraS9TYW1f SG91c3RvbiIgdGl0bGU9IlNhbSBIb3VzdG9uIj5Ib3VzdG9uPC9hPiYjMTYwO3wgPGEgaHJlZj0i L3dpa2kvTWlyYWJlYXVfQi5fTGFtYXIiIHRpdGxlPSJNaXJhYmVhdSBCLiBMYW1hciI+TGFtYXI8 L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9TYW1fSG91c3RvbiIgdGl0bGU9IlNhbSBIb3VzdG9u Ij5Ib3VzdG9uPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvQW5zb25fSm9uZXMiIHRpdGxlPSJB bnNvbiBKb25lcyI+Sm9uZXM8L2E+PC9wPgk8cD5CdW5kZXNzdGFhdCBUZXhhczo8YnIgLz4JPGEg aHJlZj0iL3dpa2kvSmFtZXNfUGluY2tuZXlfSGVuZGVyc29uIiB0aXRsZT0iSmFtZXMgUGluY2tu ZXkgSGVuZGVyc29uIj5KLiYjMTYwO1AuJiMxNjA7SGVuZGVyc29uPC9hPiYjMTYwO3wgPGEgaHJl Zj0iL3dpa2kvR2VvcmdlX1QuX1dvb2QiIHRpdGxlPSJHZW9yZ2UgVC4gV29vZCI+V29vZDwvYT4m IzE2MDt8IDxhIGhyZWY9Ii93aWtpL1BldGVyX0hhbnNib3JvdWdoX0JlbGwiIHRpdGxlPSJQZXRl ciBIYW5zYm9yb3VnaCBCZWxsIj5CZWxsPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSmFtZXNf V2lsc29uX0hlbmRlcnNvbiIgdGl0bGU9IkphbWVzIFdpbHNvbiBIZW5kZXJzb24iPkouJiMxNjA7 Vy4mIzE2MDtIZW5kZXJzb248L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9FbGlzaGFfTS5fUGVh c2UiIHRpdGxlPSJFbGlzaGEgTS4gUGVhc2UiPlBlYXNlPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dp a2kvSGFyZGluX1IuX1J1bm5lbHMiIHRpdGxlPSJIYXJkaW4gUi4gUnVubmVscyI+UnVubmVsczwv YT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1NhbV9Ib3VzdG9uIiB0aXRsZT0iU2FtIEhvdXN0b24i PkhvdXN0b248L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9FZHdhcmRfQ2xhcmtfKFBvbGl0aWtl cikiIHRpdGxlPSJFZHdhcmQgQ2xhcmsgKFBvbGl0aWtlcikiPkNsYXJrPC9hPiYjMTYwO3wgPGEg aHJlZj0iL3dpa2kvRnJhbmNpc19SLl9MdWJib2NrIiB0aXRsZT0iRnJhbmNpcyBSLiBMdWJib2Nr Ij5MdWJib2NrPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvUGVuZGxldG9uX011cnJhaCIgdGl0 bGU9IlBlbmRsZXRvbiBNdXJyYWgiPk11cnJhaDwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0Zs ZXRjaGVyX1N0b2NrZGFsZSIgdGl0bGU9IkZsZXRjaGVyIFN0b2NrZGFsZSI+U3RvY2tkYWxlPC9h PiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvQW5kcmV3X0ouX0hhbWlsdG9uIiB0aXRsZT0iQW5kcmV3 IEouIEhhbWlsdG9uIj5IYW1pbHRvbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0phbWVzX1cu X1Rocm9ja21vcnRvbiIgdGl0bGU9IkphbWVzIFcuIFRocm9ja21vcnRvbiI+VGhyb2NrbW9ydG9u PC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvRWxpc2hhX00uX1BlYXNlIiB0aXRsZT0iRWxpc2hh IE0uIFBlYXNlIj5QZWFzZTwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0VkbXVuZF9KLl9EYXZp cyIgdGl0bGU9IkVkbXVuZCBKLiBEYXZpcyI+RGF2aXM8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lr aS9SaWNoYXJkX0Nva2UiIHRpdGxlPSJSaWNoYXJkIENva2UiPkNva2U8L2E+JiMxNjA7fCA8YSBo cmVmPSIvd2lraS9SaWNoYXJkX0IuX0h1YmJhcmQiIHRpdGxlPSJSaWNoYXJkIEIuIEh1YmJhcmQi Pkh1YmJhcmQ8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9PcmFuX00uX1JvYmVydHMiIHRpdGxl PSJPcmFuIE0uIFJvYmVydHMiPlJvYmVydHM8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9Kb2hu X0lyZWxhbmRfKFBvbGl0aWtlcikiIHRpdGxlPSJKb2huIElyZWxhbmQgKFBvbGl0aWtlcikiPkly ZWxhbmQ8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9MYXdyZW5jZV9TdWxsaXZhbl9Sb3NzIiB0 aXRsZT0iTGF3cmVuY2UgU3VsbGl2YW4gUm9zcyI+Um9zczwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93 aWtpL0ppbV9Ib2dnIiB0aXRsZT0iSmltIEhvZ2ciPkhvZ2c8L2E+JiMxNjA7fCA8YSBocmVmPSIv d2lraS9DaGFybGVzX0EuX0N1bGJlcnNvbiIgdGl0bGU9IkNoYXJsZXMgQS4gQ3VsYmVyc29uIj5D dWxiZXJzb248L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9Kb3NlcGhfRC5fU2F5ZXJzIiB0aXRs ZT0iSm9zZXBoIEQuIFNheWVycyI+U2F5ZXJzPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvU2Ft dWVsX1cuX1QuX0xhbmhhbSIgdGl0bGU9IlNhbXVlbCBXLiBULiBMYW5oYW0iPkxhbmhhbTwvYT4m IzE2MDt8IDxhIGhyZWY9Ii93aWtpL1Rob21hc19NaXRjaGVsbF9DYW1wYmVsbCIgdGl0bGU9IlRo b21hcyBNaXRjaGVsbCBDYW1wYmVsbCI+Q2FtcGJlbGw8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lr aS9Pc2Nhcl9CcmFuY2hfQ29scXVpdHQiIHRpdGxlPSJPc2NhciBCcmFuY2ggQ29scXVpdHQiPkNv bHF1aXR0PC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSmFtZXNfRS5fRmVyZ3Vzb24iIHRpdGxl PSJKYW1lcyBFLiBGZXJndXNvbiI+Si4mIzE2MDtGZXJndXNvbjwvYT4mIzE2MDt8IDxhIGhyZWY9 Ii93aWtpL1dpbGxpYW1fUC5fSG9iYnkiIHRpdGxlPSJXaWxsaWFtIFAuIEhvYmJ5Ij5Ib2JieTwv YT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1BhdF9Nb3JyaXNfTmVmZiIgdGl0bGU9IlBhdCBNb3Jy aXMgTmVmZiI+TmVmZjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL01pcmlhbV9BLl9GZXJndXNv biIgdGl0bGU9Ik1pcmlhbSBBLiBGZXJndXNvbiI+TS4mIzE2MDtGZXJndXNvbjwvYT4mIzE2MDt8 IDxhIGhyZWY9Ii93aWtpL0Rhbl9Nb29keSIgdGl0bGU9IkRhbiBNb29keSI+TW9vZHk8L2E+JiMx NjA7fCA8YSBocmVmPSIvd2lraS9Sb3NzX1MuX1N0ZXJsaW5nIiB0aXRsZT0iUm9zcyBTLiBTdGVy bGluZyI+U3Rlcmxpbmc8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9NaXJpYW1fQS5fRmVyZ3Vz b24iIHRpdGxlPSJNaXJpYW0gQS4gRmVyZ3Vzb24iPk0uJiMxNjA7RmVyZ3Vzb248L2E+JiMxNjA7 fCA8YSBocmVmPSIvd2lraS9KYW1lc19BbGxyZWQiIHRpdGxlPSJKYW1lcyBBbGxyZWQiPkFsbHJl ZDwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1cuX0xlZV9PJUUyJTgwJTk5RGFuaWVsIiB0aXRs ZT0iVy4gTGVlIE/igJlEYW5pZWwiPk/igJlEYW5pZWw8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lr aS9Db2tlX1IuX1N0ZXZlbnNvbiIgdGl0bGU9IkNva2UgUi4gU3RldmVuc29uIj5TdGV2ZW5zb248 L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9CZWF1Zm9yZF9ILl9KZXN0ZXIiIHRpdGxlPSJCZWF1 Zm9yZCBILiBKZXN0ZXIiPkplc3RlcjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0FsbGFuX1No aXZlcnMiIHRpdGxlPSJBbGxhbiBTaGl2ZXJzIj5TaGl2ZXJzPC9hPiYjMTYwO3wgPGEgaHJlZj0i L3dpa2kvTWFyaW9uX1ByaWNlX0RhbmllbF9zZW5pb3IiIHRpdGxlPSJNYXJpb24gUHJpY2UgRGFu aWVsIHNlbmlvciI+RGFuaWVsPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSm9obl9Db25uYWxs eSIgdGl0bGU9IkpvaG4gQ29ubmFsbHkiPkNvbm5hbGx5PC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dp a2kvUHJlc3Rvbl9TbWl0aCIgdGl0bGU9IlByZXN0b24gU21pdGgiPlNtaXRoPC9hPiYjMTYwO3wg PGEgaHJlZj0iL3dpa2kvRG9scGhfQnJpc2NvZSIgdGl0bGU9IkRvbHBoIEJyaXNjb2UiPkJyaXNj b2U8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9CaWxsX0NsZW1lbnRzIiB0aXRsZT0iQmlsbCBD bGVtZW50cyI+Q2xlbWVudHM8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9NYXJrX1doaXRlXyhH b3V2ZXJuZXVyKSIgdGl0bGU9Ik1hcmsgV2hpdGUgKEdvdXZlcm5ldXIpIj5XaGl0ZTwvYT4mIzE2 MDt8IDxhIGhyZWY9Ii93aWtpL0JpbGxfQ2xlbWVudHMiIHRpdGxlPSJCaWxsIENsZW1lbnRzIj5D bGVtZW50czwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0Fubl9SaWNoYXJkcyIgdGl0bGU9IkFu biBSaWNoYXJkcyI+UmljaGFyZHM8L2E+JiMxNjA7fCA8c3Ryb25nIGNsYXNzPSJzZWxmbGluayI+ QnVzaDwvc3Ryb25nPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSmFtZXNfUmljaGFyZF9QZXJyeSIg dGl0bGU9IkphbWVzIFJpY2hhcmQgUGVycnkiPlBlcnJ5PC9hPjwvcD4JPC9kaXY+CTxkaXYgY2xh c3M9InZpc3VhbENsZWFyIj48L2Rpdj4JPC9kaXY+CTwvZGl2Pgk8ZGl2IGlkPSJub3JtZGF0ZW4i IGNsYXNzPSJjYXRsaW5rcyI+PGI+Tm9ybWRhdGVuPC9iPjogPGEgaHJlZj0iL3dpa2kvUGVyc29u ZW5uYW1lbmRhdGVpIiB0aXRsZT0iUGVyc29uZW5uYW1lbmRhdGVpIj5QTkQ8L2E+OiA8YSBocmVm PSJodHRwOi8vZC1uYi5pbmZvL2duZC8xMjE0NTM5MVgiIGNsYXNzPSJleHRlcm5hbCB0ZXh0IiBy ZWw9Im5vZm9sbG93Ij4xMjE0NTM5MVg8L2E+IHwgPGEgaHJlZj0iL3dpa2kvTGlicmFyeV9vZl9D b25ncmVzc19Db250cm9sX051bWJlciIgdGl0bGU9IkxpYnJhcnkgb2YgQ29uZ3Jlc3MgQ29udHJv bCBOdW1iZXIiPkxDQ048L2E+OiA8YSBocmVmPSJodHRwOi8vZXJyb2wub2NsYy5vcmcvbGFmL25v OTUwNDk4NDguaHRtbCIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ciPm5vOTUw NDk4NDg8L2E+IHwgPGEgaHJlZj0iL3dpa2kvVmlydHVhbF9JbnRlcm5hdGlvbmFsX0F1dGhvcml0 eV9GaWxlIiB0aXRsZT0iVmlydHVhbCBJbnRlcm5hdGlvbmFsIEF1dGhvcml0eSBGaWxlIj5WSUFG PC9hPjogPGEgaHJlZj0iaHR0cDovL3ZpYWYub3JnL3ZpYWYvNzE1NTk0ODUvIiBjbGFzcz0iZXh0 ZXJuYWwgdGV4dCIgcmVsPSJub2ZvbGxvdyI+NzE1NTk0ODU8L2E+IHwgPGEgaHJlZj0iaHR0cDov L3Rvb2xzZXJ2ZXIub3JnL35hcHBlci9wZC9wZXJzb24vR2VvcmdlX1cuX0J1c2giIGNsYXNzPSJl eHRlcm5hbCB0ZXh0IiByZWw9Im5vZm9sbG93Ij5XUC1QZXJzb25lbmluZm88L2E+PC9kaXY+CTx0 YWJsZSBjbGFzcz0ibWV0YWRhdGEiIHN0eWxlPSJtYXJnaW4tdG9wOjE1cHQ7Ij4JPHRyPgk8dGgg Y29sc3Bhbj0iMiI+PGEgaHJlZj0iL3dpa2kvSGlsZmU6UGVyc29uZW5kYXRlbiIgdGl0bGU9Ikhp bGZlOlBlcnNvbmVuZGF0ZW4iPlBlcnNvbmVuZGF0ZW48L2E+PC90aD4JPC90cj4JPHRyPgk8dGQg Y2xhc3M9Im1ldGFkYXRhLWxhYmVsIj5OQU1FPC90ZD4JPHRkIHN0eWxlPSJmb250LXdlaWdodDog Ym9sZDsiPkJ1c2gsIEdlb3JnZSBXLjwvdGQ+CTwvdHI+CTx0cj4JPHRkIGNsYXNzPSJtZXRhZGF0 YS1sYWJlbCI+QUxURVJOQVRJVk5BTUVOPC90ZD4JPHRkPkJ1c2gsIEdlb3JnZSBXYWxrZXI7IEJ1 c2gsIEdlb3JnZSBqdW4uPC90ZD4JPC90cj4JPHRyPgk8dGQgY2xhc3M9Im1ldGFkYXRhLWxhYmVs Ij5LVVJaQkVTQ0hSRUlCVU5HPC90ZD4JPHRkPjQzLiBQcsOkc2lkZW50IGRlciBWZXJlaW5pZ3Rl biBTdGFhdGVuIHZvbiBBbWVyaWthPC90ZD4JPC90cj4JPHRyPgk8dGQgY2xhc3M9Im1ldGFkYXRh LWxhYmVsIj5HRUJVUlRTREFUVU08L3RkPgk8dGQ+Ni4gSnVsaSAxOTQ2PC90ZD4JPC90cj4JPHRy Pgk8dGQgY2xhc3M9Im1ldGFkYXRhLWxhYmVsIj5HRUJVUlRTT1JUPC90ZD4JPHRkPjxhIGhyZWY9 Ii93aWtpL05ld19IYXZlbl8oQ29ubmVjdGljdXQpIiB0aXRsZT0iTmV3IEhhdmVuIChDb25uZWN0 aWN1dCkiPk5ldyBIYXZlbjwvYT4sIENvbm5lY3RpY3V0PC90ZD4JPC90cj4JPC90YWJsZT4JPGRp diBpZD0iaW50ZXJ3aWtpLXNrLWZhIiBjbGFzcz0iRkEiIHN0eWxlPSJkaXNwbGF5OiBub25lOyI+ PC9kaXY+CTxkaXYgaWQ9ImludGVyd2lraS1lbi1nYSIgY2xhc3M9IkdBIiBzdHlsZT0iZGlzcGxh eTogbm9uZTsiPjwvZGl2Pgk8ZGl2IGlkPSJpbnRlcndpa2ktc3YtZ2EiIGNsYXNzPSJHQSIgc3R5 bGU9ImRpc3BsYXk6IG5vbmU7Ij48L2Rpdj4JPGRpdiBpZD0iaW50ZXJ3aWtpLXpoLWdhIiBjbGFz cz0iR0EiIHN0eWxlPSJkaXNwbGF5OiBub25lOyI+PC9kaXY+CQo8aDI+PHNwYW4gY2xhc3M9Im13 LWhlYWRsaW5lIiBpZD0iRmFtaWxpZV91bmRfQXVzYmlsZHVuZyI+RmFtaWxpZSB1bmQgQXVzYmls ZHVuZzwvc3Bhbj48L2gyPgk8cD5EZXIgTmFtZSBHZW9yZ2UgSGVyYmVydCBXYWxrZXIgQnVzaCBp c3QgZWluZSA8YSBocmVmPSIvd2lraS9SZW1pbmlzemVueiIgdGl0bGU9IlJlbWluaXN6ZW56Ij5S ZW1pbmlzemVuejwvYT4gYW4gZGVuIEdyb8OfdmF0ZXIgbcO8dHRlcmxpY2hlcnNlaXRzLCA8YSBo cmVmPSIvd2lraS9HZW9yZ2VfSGVyYmVydF9XYWxrZXIiIHRpdGxlPSJHZW9yZ2UgSGVyYmVydCBX YWxrZXIiPkdlb3JnZSBIZXJiZXJ0IFdhbGtlcjwvYT4uIEdlb3JnZSBCdXNoIGlzdCBTb2huIHZv biA8YSBocmVmPSIvd2lraS9QcmVzY290dF9CdXNoIiB0aXRsZT0iUHJlc2NvdHQgQnVzaCI+UHJl c2NvdHQgQnVzaDwvYT4sIGRlbSBlaGVtYWxpZ2VuIDxhIGhyZWY9Ii93aWtpL1NlbmF0X2Rlcl9W ZXJlaW5pZ3Rlbl9TdGFhdGVuIiB0aXRsZT0iU2VuYXQgZGVyIFZlcmVpbmlndGVuIFN0YWF0ZW4i PlNlbmF0b3I8L2E+IHZvbiA8YSBocmVmPSIvd2lraS9Db25uZWN0aWN1dCIgdGl0bGU9IkNvbm5l Y3RpY3V0Ij5Db25uZWN0aWN1dDwvYT4uIEVyIHd1Y2hzIGluIDxhIGhyZWY9Ii93aWtpL0dyZWVu d2ljaF8oQ29ubmVjdGljdXQpIiB0aXRsZT0iR3JlZW53aWNoIChDb25uZWN0aWN1dCkiPkdyZWVu d2ljaDwvYT4gYXVmIHVuZCBiZXN1Y2h0ZSBkaWUgPGEgaHJlZj0iL3dpa2kvUGhpbGxpcHNfQWNh ZGVteSIgdGl0bGU9IlBoaWxsaXBzIEFjYWRlbXkiPlBoaWxsaXBzIEFjYWRlbXk8L2E+IGluIDxh IGhyZWY9Ii93aWtpL0FuZG92ZXJfKE1hc3NhY2h1c2V0dHMpIiB0aXRsZT0iQW5kb3ZlciAoTWFz c2FjaHVzZXR0cykiPkFuZG92ZXI8L2E+LCB3byBlciBhbHMgS2FwaXTDpG4gZGVzIDxhIGhyZWY9 Ii93aWtpL0Jhc2ViYWxsIiB0aXRsZT0iQmFzZWJhbGwiPkJhc2ViYWxsPC9hPi1UZWFtcyBmdW5n aWVydGUuIE5hY2hkZW0gZXIgaW0gSnVuaSAxOTQyIHNlaW5lbiBBYnNjaGx1c3MgZ2VtYWNodCBo YXR0ZSwgdHJhdCBlciBkZXIgTWFyaW5lIGJlaS48L3A+CTxwPlfDpGhyZW5kIGRlcyA8YSBocmVm PSIvd2lraS9ad2VpdGVyX1dlbHRrcmllZyIgdGl0bGU9Ilp3ZWl0ZXIgV2VsdGtyaWVnIj5ad2Vp dGVuIFdlbHRrcmllZ3M8L2E+IGRpZW50ZSBlciBhbHMgYmlzIGRhaGluIGrDvG5nc3RlciA8YSBo cmVmPSIvd2lraS9VU19OYXZ5IiB0aXRsZT0iVVMgTmF2eSIgY2xhc3M9Im13LXJlZGlyZWN0Ij5N YXJpbmVwaWxvdDwvYT4gdW5kIGVyaGllbHQgZsO8ciBzZWluZW4gRGllbnN0IGRhcyA8YSBocmVm PSIvd2lraS9PcmRlbl91bmRfRWhyZW56ZWljaGVuX2Rlcl9TdHJlaXRrciVDMyVBNGZ0ZV9kZXJf VmVyZWluaWd0ZW5fU3RhYXRlbiIgdGl0bGU9Ik9yZGVuIHVuZCBFaHJlbnplaWNoZW4gZGVyIFN0 cmVpdGtyw6RmdGUgZGVyIFZlcmVpbmlndGVuIFN0YWF0ZW4iPkRpc3Rpbmd1aXNoZWQgRmx5aW5n IENyb3NzPC9hPiwgZGFzIEZsdWd2ZXJkaWVuc3RrcmV1ei48L3A+CTxwPk5hY2ggZGVtIEtyaWVn IGJlc3VjaHRlIGVyIGRpZSA8YSBocmVmPSIvd2lraS9ZYWxlX1VuaXZlcnNpdHkiIHRpdGxlPSJZ YWxlIFVuaXZlcnNpdHkiPllhbGUtVW5pdmVyc2l0w6R0PC9hPiB1bmQgd3VyZGUgTWl0Z2xpZWQg ZGVyIGFrYWRlbWlzY2hlbiBHZW1laW5zY2hhZnQgPGEgaHJlZj0iL3dpa2kvUGhpX0JldGFfS2Fw cGEiIHRpdGxlPSJQaGkgQmV0YSBLYXBwYSI+UGhpIEJldGEgS2FwcGE8L2E+LiBCdXNoIHNvbGwg aW4gZGllIEJydWRlcnNjaGFmdCBkZXIgPGEgaHJlZj0iL3dpa2kvU2t1bGxfYW5kX0JvbmVzIiB0 aXRsZT0iU2t1bGwgYW5kIEJvbmVzIiBjbGFzcz0ibXctcmVkaXJlY3QiPlNrdWxsICZhbXA7IEJv bmVzPC9hPiBlaW5nZWbDvGhydCB3b3JkZW4gc2VpbiwgZGllIGlobiwgd2llIHZpZWxlIGFuZGVy ZSBQcsOkc2lkZW50ZW4sIGJlaW0gQXVmYmF1IHZvbiBCZXppZWh1bmdlbiB1bmQgcG9saXRpc2No IHVudGVyc3TDvHR6dGUuPC9wPgk8cD5BbSA2LiBKYW51YXIgMTk0NSBoZWlyYXRldGUgZXIgPGEg aHJlZj0iL3dpa2kvQmFyYmFyYV9CdXNoIiB0aXRsZT0iQmFyYmFyYSBCdXNoIj5CYXJiYXJhIFBp ZXJjZTwvYT4uIERpZSBiZWlkZW4gaGFiZW4gc2VjaHMgS2luZGVyOjwvcD4JPHVsPgk8bGk+PGEg aHJlZj0iL3dpa2kvR2VvcmdlX1cuX0J1c2giIHRpdGxlPSJHZW9yZ2UgVy4gQnVzaCI+R2Vvcmdl IFcuPC9hPiwgZ2Vib3JlbiAxOTQ2IChkZXIgNDMuIFVTLVByw6RzaWRlbnQpPC9saT4JPGxpPlBh dWxpbmUgUm9iaW5zb24gKFJvYmluKSwgZ2Vib3JlbiAxOTQ5LCBnZXN0b3JiZW4gMTk1MyBhbiA8 YSBocmVmPSIvd2lraS9MZXVrJUMzJUE0bWllIiB0aXRsZT0iTGV1a8OkbWllIj5MZXVrw6RtaWU8 L2E+PC9saT4JPGxpPjxhIGhyZWY9Ii93aWtpL0plYl9CdXNoIiB0aXRsZT0iSmViIEJ1c2giPkpv aG4gKEplYik8L2E+LCBnZWJvcmVuIDE5NTMgKDE5OTgtMjAwNyBHb3V2ZXJuZXVyIEZsb3JpZGFz KTwvbGk+CTxsaT48YSBocmVmPSIvd2lraS9OZWlsX0J1c2giIHRpdGxlPSJOZWlsIEJ1c2giPk5l aWw8L2E+LCBnZWJvcmVuIDE5NTU8L2xpPgk8bGk+PGEgaHJlZj0iL3dpa2kvTWFydmluX0J1c2gi IHRpdGxlPSJNYXJ2aW4gQnVzaCI+TWFydmluPC9hPiwgZ2Vib3JlbiAxOTU2PC9saT4JPGxpPnVu ZCBEb3JvdGh5LCBnZWJvcmVuIDE5NTkuPC9saT4JPC91bD4JPGgyPjxzcGFuIGNsYXNzPSJtdy1o ZWFkbGluZSIgaWQ9IlQuQzMuQTR0aWdrZWl0ZW5faW5fV2lydHNjaGFmdF91bmRfUG9saXRpayI+ VMOkdGlna2VpdGVuIGluIFdpcnRzY2hhZnQgdW5kIFBvbGl0aWs8L3NwYW4+PC9oMj4JPGRpdiBj bGFzcz0idGh1bWIgdHJpZ2h0Ij4JPGRpdiBjbGFzcz0idGh1bWJpbm5lciIgc3R5bGU9IndpZHRo OjIyMnB4OyI+PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPURhdGVpOkJ1c2hfc2VuaW9yX3Vu ZF9IYW5zLURpZXRyaWNoX0dlbnNjaGVyLmpwZyZhbXA7ZmlsZXRpbWVzdGFtcD0yMDA1MDgyODIx NDAwOCIgY2xhc3M9ImltYWdlIj48aW1nIGFsdD0iIiBzcmM9Imh0dHA6Ly91cGxvYWQud2lraW1l ZGlhLm9yZy93aWtpcGVkaWEvY29tbW9ucy90aHVtYi84Lzg4L0J1c2hfc2VuaW9yX3VuZF9IYW5z LURpZXRyaWNoX0dlbnNjaGVyLmpwZy8yMjBweC1CdXNoX3Nlbmlvcl91bmRfSGFucy1EaWV0cmlj aF9HZW5zY2hlci5qcGciIHdpZHRoPSIyMjAiIGhlaWdodD0iMTQ4IiBjbGFzcz0idGh1bWJpbWFn ZSIgLz48L2E+CTxkaXYgY2xhc3M9InRodW1iY2FwdGlvbiI+CTxkaXYgY2xhc3M9Im1hZ25pZnki PjxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1EYXRlaTpCdXNoX3Nlbmlvcl91bmRfSGFucy1E aWV0cmljaF9HZW5zY2hlci5qcGcmYW1wO2ZpbGV0aW1lc3RhbXA9MjAwNTA4MjgyMTQwMDgiIGNs YXNzPSJpbnRlcm5hbCIgdGl0bGU9InZlcmdyw7bDn2VybiI+PGltZyBzcmM9Imh0dHA6Ly9iaXRz Lndpa2ltZWRpYS5vcmcvc2tpbnMtMS41L2NvbW1vbi9pbWFnZXMvbWFnbmlmeS1jbGlwLnBuZyIg d2lkdGg9IjE1IiBoZWlnaHQ9IjExIiBhbHQ9IiIgLz48L2E+PC9kaXY+CVByw6RzaWRlbnQgQnVz aCBiZWtvbW10IHZvbiA8YSBocmVmPSIvd2lraS9IYW5zLURpZXRyaWNoX0dlbnNjaGVyIiB0aXRs ZT0iSGFucy1EaWV0cmljaCBHZW5zY2hlciI+SGFucy1EaWV0cmljaCBHZW5zY2hlcjwvYT4gZWlu IFN0w7xjayBkZXIgQmVybGluZXIgTWF1ZXIgw7xiZXJyZWljaHQgKDIxLiBOb3ZlbWJlciAxOTg5 KTwvZGl2Pgk8L2Rpdj4JPC9kaXY+CTxwPkVzIGdhYiB1bmQgZ2lidCBrYXVtIEZhbWlsaWVuIGlu IGRlbiBVU0EsIGRpZSBkZXJhcnQgdmllbGUgw4RtdGVyIHZlcmVpbnRlbjogc2VpbiBWYXRlciBQ cmVzY290dCBCdXNoIHdhciBTZW5hdG9yLCBlciBzZWxic3QgUHLDpHNpZGVudCB1bmQgVml6ZS1Q csOkc2lkZW50LCBzZWluIFNvaG4gR2VvcmdlIFcuIFByw6RzaWRlbnQgdW5kIDxhIGhyZWY9Ii93 aWtpL0dvdXZlcm5ldXJfKFZlcmVpbmlndGVfU3RhYXRlbikiIHRpdGxlPSJHb3V2ZXJuZXVyIChW ZXJlaW5pZ3RlIFN0YWF0ZW4pIj5Hb3V2ZXJuZXVyPC9hPiB2b24gPGEgaHJlZj0iL3dpa2kvVGV4 YXMiIHRpdGxlPSJUZXhhcyI+VGV4YXM8L2E+IHVuZCBTb2huIEplYiBHb3V2ZXJuZXVyIHZvbiA8 YSBocmVmPSIvd2lraS9GbG9yaWRhIiB0aXRsZT0iRmxvcmlkYSI+RmxvcmlkYTwvYT4uIE51ciBk aWUgRmFtaWxpZSB2b24gPGEgaHJlZj0iL3dpa2kvSm9obl9BZGFtcyIgdGl0bGU9IkpvaG4gQWRh bXMiPkpvaG4gQWRhbXM8L2E+IHVuZCBkaWUgPGEgaHJlZj0iL3dpa2kvS2VubmVkeV8oRmFtaWxp ZSkiIHRpdGxlPSJLZW5uZWR5IChGYW1pbGllKSI+S2VubmVkeXM8L2E+IHfDpHJlbiB2ZXJnbGVp Y2hiYXIuPC9wPgk8cD5CdXNoIHZlcnN1Y2h0ZSBzaWNoIGltIDxhIGhyZWY9Ii93aWtpL0VyZCVD MyVCNmwiIHRpdGxlPSJFcmTDtmwiPsOWbGdlc2Now6RmdDwvYT4gaW4gVGV4YXMsIHVudGVyIGFu ZGVyZW0gZ3LDvG5kZXRlIGVyIDE5NTMgZGllIEZpcm1hIDxhIGhyZWY9Ii93aWtpL1phcGF0YV9P aWwiIHRpdGxlPSJaYXBhdGEgT2lsIj5aYXBhdGEgT2lsPC9hPi4gRGllIEphaHJlIGluIFRleGFz IGhhbGZlbiBkYWJlaSwgc2VpbmVuIFNvaG4gR2VvcmdlIFcuIGFscyBUZXhhbmVyIHp1IGRlZmlu aWVyZW4sIHdhcyBkaWVzZW0gd2llZGVydW0genUgc2VpbmVtIHBvbGl0aXNjaGVuIEF1ZnN0aWVn IGltIHp3ZWl0Z3LDtsOfdGVuIFVTLVN0YWF0IHZlcmhhbGYuPC9wPgk8cD5TZWluZSBwb2xpdGlz Y2hlIEthcnJpZXJlIGJlZ2FubiAxOTYyIGFscyBWb3JzaXR6ZW5kZXIgZGVyIFJlcHVibGlrYW5p c2NoZW4gUGFydGVpIGltIHRleGFuaXNjaGVuIDxhIGhyZWY9Ii93aWtpL0hhcnJpc19Db3VudHlf KFRleGFzKSIgdGl0bGU9IkhhcnJpcyBDb3VudHkgKFRleGFzKSI+SGFycmlzIENvdW50eTwvYT4u IDE5NjQga2FuZGlkaWVydGUgZXIgZsO8ciBkZW4gPGEgaHJlZj0iL3dpa2kvU2VuYXRfZGVyX1Zl cmVpbmlndGVuX1N0YWF0ZW4iIHRpdGxlPSJTZW5hdCBkZXIgVmVyZWluaWd0ZW4gU3RhYXRlbiI+ U2VuYXQ8L2E+IHVuZCB2ZXJsb3IgZ2VnZW4gc2VpbmVuIGRlbW9rcmF0aXNjaGVuIEtvbmt1cnJl bnRlbiA8YSBocmVmPSIvd2lraS9SYWxwaF9XLl9ZYXJib3JvdWdoIiB0aXRsZT0iUmFscGggVy4g WWFyYm9yb3VnaCI+UmFscGggWWFyYm9yb3VnaDwvYT4gw7xiZXJyYXNjaGVuZCBrbmFwcC4gQXVm Z3J1bmQgZGVzIGd1dGVuIEVyZ2Vibmlzc2VzIGltIHZvbiBkZW4gRGVtb2tyYXRlbiBkb21pbmll cnRlbiBUZXhhcyB3dXJkZSBkZXIgZWhlbWFsaWdlIFZpemVwcsOkc2lkZW50IHVuZCBkYW1hbGln ZSBrYWxpZm9ybmlzY2hlIFNlbmF0b3IgPGEgaHJlZj0iL3dpa2kvUmljaGFyZF9OaXhvbiIgdGl0 bGU9IlJpY2hhcmQgTml4b24iPlJpY2hhcmQgTml4b248L2E+IGF1ZiBCdXNoIGF1Zm1lcmtzYW0u IE1pdCBOaXhvbnMgVW50ZXJzdMO8dHp1bmcgd3VyZGUgZXIgMTk2NiBhbHMgQWJnZW9yZG5ldGVy IGVpbmVzIHdvaGxoYWJlbmRlbiBCZXppcmtzIGluIEhvdXN0b24gaW4gZGFzIDxhIGhyZWY9Ii93 aWtpL1JlcHIlQzMlQTRzZW50YW50ZW5oYXVzX2Rlcl9WZXJlaW5pZ3Rlbl9TdGFhdGVuIiB0aXRs ZT0iUmVwcsOkc2VudGFudGVuaGF1cyBkZXIgVmVyZWluaWd0ZW4gU3RhYXRlbiI+VVMtUmVwcsOk c2VudGFudGVuaGF1czwvYT4gZ2V3w6RobHQgdW5kIDE5Njggd2llZGVyZ2V3w6RobHQuIDE5NzAg Z2FiIGVyIHNlaW4gTWFuZGF0IGF1ZiB1bmQgdW50ZXJuYWhtIGVpbmVuIGVybmV1dGVuIFZlcnN1 Y2gsIHp1bSBTZW5hdG9yIGdld8OkaGx0IHp1IHdlcmRlbi4gRXIgc2NoZWl0ZXJ0ZSBnZWdlbiA8 YSBocmVmPSIvd2lraS9MbG95ZF9CZW50c2VuIiB0aXRsZT0iTGxveWQgQmVudHNlbiI+TGxveWQg QmVudHNlbjwvYT4sIGRlciBkYXMgQW10IGJpcyAxOTkzIGlubmVoaWVsdC48L3A+CTxwPkluIGRl biAxOTcwZXIgSmFocmVuIGJla2xlaWRldGUgZXIgemFobHJlaWNoZSB3aWNodGlnZSDDhG10ZXI6 IFZvbiAxOTcxLTE5NzMgd2FyIGVyIDxhIGhyZWY9Ii93aWtpL0xpc3RlX2Rlcl9Cb3RzY2hhZnRl cl9kZXJfVmVyZWluaWd0ZW5fU3RhYXRlbl9iZWlfZGVuX1ZlcmVpbnRlbl9OYXRpb25lbiIgdGl0 bGU9Ikxpc3RlIGRlciBCb3RzY2hhZnRlciBkZXIgVmVyZWluaWd0ZW4gU3RhYXRlbiBiZWkgZGVu IFZlcmVpbnRlbiBOYXRpb25lbiIgY2xhc3M9Im13LXJlZGlyZWN0Ij5VUy1Cb3RzY2hhZnRlcjwv YT4gYmVpIGRlciA8YSBocmVmPSIvd2lraS9WZXJlaW50ZV9OYXRpb25lbiIgdGl0bGU9IlZlcmVp bnRlIE5hdGlvbmVuIj5VTk88L2E+LCAxOTczLzc0IFZvcnNpdHplbmRlciBkZXMgPGEgaHJlZj0i L3dpa2kvUmVwdWJsaWNhbl9OYXRpb25hbF9Db21taXR0ZWUiIHRpdGxlPSJSZXB1YmxpY2FuIE5h dGlvbmFsIENvbW1pdHRlZSI+UmVwdWJsaWNhbiBOYXRpb25hbCBDb21taXR0ZWU8L2E+LCAxOTc0 Lzc1IExlaXRlciBkZXMgYW1lcmlrYW5pc2NoZW4gVmVyYmluZHVuZ3Niw7xyb3MgaW4gPGEgaHJl Zj0iL3dpa2kvUGVraW5nIiB0aXRsZT0iUGVraW5nIj5QZWtpbmc8L2E+IHVuZCBkYW1pdCBlcnN0 ZXIgZGlwbG9tYXRpc2NoZXIgVmVydHJldGVyIGRlciBVU0EgaW4gQ2hpbmEgc293aWUgaW4gZGVu IEphaHJlbiAxOTc2LTE5NzcgRGlyZWt0b3IgZGVzIDxhIGhyZWY9Ii93aWtpL0dlaGVpbWRpZW5z dCIgdGl0bGU9IkdlaGVpbWRpZW5zdCIgY2xhc3M9Im13LXJlZGlyZWN0Ij5HZWhlaW1kaWVuc3Rl czwvYT4gPGEgaHJlZj0iL3dpa2kvQ2VudHJhbF9JbnRlbGxpZ2VuY2VfQWdlbmN5IiB0aXRsZT0i Q2VudHJhbCBJbnRlbGxpZ2VuY2UgQWdlbmN5Ij5DSUE8L2E+LiBWb24gMTk3NyBiaXMgMTk3OSB3 YXIgZXIgRGlyZWt0b3IgZGVzIFBoYXJtYWtvbnplcm5zIDxhIGhyZWY9Ii93aWtpL0VsaV9MaWxs eSIgdGl0bGU9IkVsaSBMaWxseSIgY2xhc3M9Im13LXJlZGlyZWN0Ij5FbGkgTGlsbHk8L2E+Ljwv cD4JPHA+MTk4MCB2ZXJsb3IgQnVzaCBkaWUgVm9yd2FobGVuIGFscyBQcsOkc2lkZW50c2NoYWZ0 c2thbmRpZGF0IGRlciBSZXB1Ymxpa2FuZXIsIGdlZ2VuIDxhIGhyZWY9Ii93aWtpL1JvbmFsZF9S ZWFnYW4iIHRpdGxlPSJSb25hbGQgUmVhZ2FuIj5Sb25hbGQgUmVhZ2FuPC9hPi4gRGllc2VyIGJv dCBpaG0gYW4sIGFuIHNlaW5lciBTZWl0ZSBhbHMgPGEgaHJlZj0iL3dpa2kvVml6ZXByJUMzJUE0 c2lkZW50X2Rlcl9WZXJlaW5pZ3Rlbl9TdGFhdGVuIiB0aXRsZT0iVml6ZXByw6RzaWRlbnQgZGVy IFZlcmVpbmlndGVuIFN0YWF0ZW4iPlZpemVwcsOkc2lkZW50PC9hPiB6dSBrYW5kaWRpZXJlbi4g WnVzYW1tZW4gZ2V3YW5uZW4gc2llIGRpZSBXYWhsLiBSZWFnYW4gYmVuw7Z0aWd0ZSBCdXNoIHVu dGVyIGFuZGVyZW0genVyIFN0w6Rya3VuZyBkZXIgUG9zaXRpb24gZ2VnZW4gZGllIDxhIGhyZWY9 Ii93aWtpL1Nvd2pldHVuaW9uIiB0aXRsZT0iU293amV0dW5pb24iPlNvd2pldHVuaW9uPC9hPi4g QnVzaCB3YXIgdmllbGVzLCB3YXMgUmVhZ2FuIG5pY2h0IHdhcjogZWluIE1hbm4gZGVzIDxhIGhy ZWY9Ii93aWtpL01pbGl0JUMzJUE0ciIgdGl0bGU9Ik1pbGl0w6RyIj5NaWxpdMOkcnM8L2E+LCBl aW4gbGFuZ2rDpGhyaWdlciBSZXB1Ymxpa2FuZXIsIGVpbiBQb2xpdGlrZXIgbWl0IGludGVybmF0 aW9uYWxlciBFcmZhaHJ1bmcsIGluc2Jlc29uZGVyZSBtaXQgZGVyIFVOTywgQ2hpbmEgdW5kIGFs cyBMZWl0ZXIgZGVyIDxhIGhyZWY9Ii93aWtpL0NlbnRyYWxfSW50ZWxsaWdlbmNlX0FnZW5jeSIg dGl0bGU9IkNlbnRyYWwgSW50ZWxsaWdlbmNlIEFnZW5jeSI+Q0lBPC9hPi4gUm9uYWxkIFJlYWdh biwgZGVyIGhpbmdlZ2VuIG5pY2h0IGltIFp3ZWl0ZW4gV2VsdGtyaWVnIGvDpG1wZnRlLCBiZWdh bm4gc2VpbmUgcG9saXRpc2NoZSBLYXJyaWVyZSBhbHMgPGEgaHJlZj0iL3dpa2kvRGVtb2tyYXRp c2NoZV9QYXJ0ZWlfKFZlcmVpbmlndGVfU3RhYXRlbikiIHRpdGxlPSJEZW1va3JhdGlzY2hlIFBh cnRlaSAoVmVyZWluaWd0ZSBTdGFhdGVuKSI+RGVtb2tyYXQ8L2E+IHVuZCB3YXIgTGVpdGVyIGRl ciA8YSBocmVmPSIvd2lraS9TY2hhdXNwaWVsZXIiIHRpdGxlPSJTY2hhdXNwaWVsZXIiPlNjaGF1 c3BpZWxlcjwvYT4tR2V3ZXJrc2NoYWZ0IDxhIGhyZWY9Ii93aWtpL1NjcmVlbl9BY3RvcnNfR3Vp bGQiIHRpdGxlPSJTY3JlZW4gQWN0b3JzIEd1aWxkIj5TQUc8L2E+LjwvcD4JPHA+QWIgTcOkcnog MTk4MSB3dXJkZSBCdXNoIEtvb3JkaW5hdG9yIGFsbGVyIGF1w59lbnBvbGl0aXNjaGVuIHVuZCBp bm5lbnBvbGl0aXNjaGVuIFTDpHRpZ2tlaXRlbiBkZXIgUmVnaWVydW5nIGluIEtyaXNlbnplaXRl bi48L3A+CTxoMj48c3BhbiBjbGFzcz0ibXctaGVhZGxpbmUiIGlkPSJQci5DMy5BNHNpZGVudHNj aGFmdCI+UHLDpHNpZGVudHNjaGFmdDwvc3Bhbj48L2gyPgk8ZGl2IGNsYXNzPSJ0aHVtYiB0cmln aHQiPgk8ZGl2IGNsYXNzPSJ0aHVtYmlubmVyIiBzdHlsZT0id2lkdGg6MjIycHg7Ij48YSBocmVm PSIvdy9pbmRleC5waHA/dGl0bGU9RGF0ZWk6R2VvcmdlX0guX1cuX0J1c2hfaW5hdWd1cmF0aW9u LmpwZyZhbXA7ZmlsZXRpbWVzdGFtcD0yMDA1MDcxNTE1MTkwNiIgY2xhc3M9ImltYWdlIj48aW1n IGFsdD0iIiBzcmM9Imh0dHA6Ly91cGxvYWQud2lraW1lZGlhLm9yZy93aWtpcGVkaWEvY29tbW9u cy90aHVtYi8wLzA5L0dlb3JnZV9ILl9XLl9CdXNoX2luYXVndXJhdGlvbi5qcGcvMjIwcHgtR2Vv cmdlX0guX1cuX0J1c2hfaW5hdWd1cmF0aW9uLmpwZyIgd2lkdGg9IjIyMCIgaGVpZ2h0PSIxNDYi IGNsYXNzPSJ0aHVtYmltYWdlIiAvPjwvYT4JPGRpdiBjbGFzcz0idGh1bWJjYXB0aW9uIj4JPGRp diBjbGFzcz0ibWFnbmlmeSI+PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPURhdGVpOkdlb3Jn ZV9ILl9XLl9CdXNoX2luYXVndXJhdGlvbi5qcGcmYW1wO2ZpbGV0aW1lc3RhbXA9MjAwNTA3MTUx NTE5MDYiIGNsYXNzPSJpbnRlcm5hbCIgdGl0bGU9InZlcmdyw7bDn2VybiI+PGltZyBzcmM9Imh0 dHA6Ly9iaXRzLndpa2ltZWRpYS5vcmcvc2tpbnMtMS41L2NvbW1vbi9pbWFnZXMvbWFnbmlmeS1j bGlwLnBuZyIgd2lkdGg9IjE1IiBoZWlnaHQ9IjExIiBhbHQ9IiIgLz48L2E+PC9kaXY+CUJ1c2gg YmVpIHNlaW5lciBWZXJlaWRpZ3VuZzwvZGl2Pgk8L2Rpdj4JPC9kaXY+CTxwPjxhIGhyZWY9Ii93 aWtpL1ByJUMzJUE0c2lkZW50c2NoYWZ0c3dhaGxfaW5fZGVuX1ZlcmVpbmlndGVuX1N0YWF0ZW5f MTk4NCIgdGl0bGU9IlByw6RzaWRlbnRzY2hhZnRzd2FobCBpbiBkZW4gVmVyZWluaWd0ZW4gU3Rh YXRlbiAxOTg0Ij4xOTg0PC9hPiB3dXJkZW4gR2VvcmdlIEguIFcuIEJ1c2ggdW5kIFJvbmFsZCBS ZWFnYW4gd2llZGVyZ2V3w6RobHQsIGJlaSBkZXIgPGEgaHJlZj0iL3dpa2kvUHIlQzMlQTRzaWRl bnRzY2hhZnRzd2FobF9pbl9kZW5fVmVyZWluaWd0ZW5fU3RhYXRlbl8xOTg4IiB0aXRsZT0iUHLD pHNpZGVudHNjaGFmdHN3YWhsIGluIGRlbiBWZXJlaW5pZ3RlbiBTdGFhdGVuIDE5ODgiPlByw6Rz aWRlbnRzY2hhZnRzd2FobCAxOTg4PC9hPiB6b2cgQnVzaCBtaXQgZGVtIFZpemUtS2FuZGlkYXRl biA8YSBocmVmPSIvd2lraS9EYW5fUXVheWxlIiB0aXRsZT0iRGFuIFF1YXlsZSI+RGFuIFF1YXls ZTwvYT4gaW4gc2VpbmVuIGVpZ2VuZW4gV2FobGthbXBmLCBkZW4gZXIgZ2VnZW4gZGllIERlbW9r cmF0ZW4gPGEgaHJlZj0iL3dpa2kvTWljaGFlbF9EdWtha2lzIiB0aXRsZT0iTWljaGFlbCBEdWth a2lzIj5NaWNoYWVsIER1a2FraXM8L2E+IHVuZCBMbG95ZCBCZW50c2VuIG1pdCA0MjYgZ2VnZW4g MTExIFdhaGxtw6RubmVyc3RpbW1lbiBrbGFyIGdld2Fubi48L3A+CTxwPk5hY2ggRW5kZSBkZXMg PGEgaHJlZj0iL3dpa2kvS2FsdGVyX0tyaWVnIiB0aXRsZT0iS2FsdGVyIEtyaWVnIj5LYWx0ZW4g S3JpZWdlczwvYT4gZW50d2FyZiBCdXNoIGRhcyBLb256ZXB0IGVpbmVyIDxhIGhyZWY9Ii93aWtp L05ldWVfV2VsdG9yZG51bmciIHRpdGxlPSJOZXVlIFdlbHRvcmRudW5nIj5OZXVlbiBXZWx0b3Jk bnVuZzwvYT4sIGRpZSB2b24gRnJpZWRlbiB1bmQgRnJlaWhlaXQgZ2V0cmFnZW4gd2VyZGVuIHNv bGx0ZS48L3A+CTxwPkFscyBQcsOkc2lkZW50IHNldHp0ZSBlciAow6RobmxpY2ggd2llIFJlYWdh bikgYXVmIG1pbGl0w6RyaXNjaGUgU3TDpHJrZTsgenUgQmVnaW5uIHNlaW5lciBSZWdpZXJ1bmdz emVpdCBicmFjaCBkYXMgU293amV0cmVpY2ggenVzYW1tZW4uIEVyIGJlZmFobCBkZW4gS3JpZWcg Z2VnZW4gZGVuIG1pdHRlbGFtZXJpa2FuaXNjaGVuIFN0YWF0IDxhIGhyZWY9Ii93aWtpL1BhbmFt YSIgdGl0bGU9IlBhbmFtYSI+UGFuYW1hPC9hPiwgbGllw58gZGVzc2VuIFN0YWF0cy1DaGVmIDxh IGhyZWY9Ii93aWtpL01hbnVlbF9Ob3JpZWdhIiB0aXRsZT0iTWFudWVsIE5vcmllZ2EiPk1hbnVl bCBOb3JpZWdhPC9hPiB2ZXJoYWZ0ZW4gdW5kIGlucyBCdW5kZXNnZWbDpG5nbmlzIG5hY2ggPGEg aHJlZj0iL3dpa2kvRmxvcmlkYSIgdGl0bGU9IkZsb3JpZGEiPkZsb3JpZGE8L2E+IGJyaW5nZW4u IEF1w59lcmRlbSBmw7xocnRlIGVyIGRpZSBVTi1Lb2FsaXRpb24gaW0gPGEgaHJlZj0iL3dpa2kv WndlaXRlcl9Hb2xma3JpZWciIHRpdGxlPSJad2VpdGVyIEdvbGZrcmllZyI+WndlaXRlbiBHb2xm a3JpZWc8L2E+IGdlZ2VuIGRlbiA8YSBocmVmPSIvd2lraS9JcmFrIiB0aXRsZT0iSXJhayI+SXJh azwvYT4gYW4sIHdlbGNoZXIgdW50ZXIgPGEgaHJlZj0iL3dpa2kvU2FkZGFtX0h1c3NlaW4iIHRp dGxlPSJTYWRkYW0gSHVzc2VpbiI+U2FkZGFtIEh1c3NlaW48L2E+IGRhcyBOYWNoYmFybGFuZCA8 YSBocmVmPSIvd2lraS9LdXdhaXQiIHRpdGxlPSJLdXdhaXQiPkt1d2FpdDwvYT4gYmVzZXR6dCBo YXR0ZS48L3A+CTxkaXYgY2xhc3M9InRodW1iIHRsZWZ0Ij4JPGRpdiBjbGFzcz0idGh1bWJpbm5l ciIgc3R5bGU9IndpZHRoOjIyMnB4OyI+PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPURhdGVp OkJ1c2hfYW5kX0dvcmJhY2hldl9hdF90aGVfTWFsdGFfc3VtbWl0X2luXzE5ODkuZ2lmJmFtcDtm aWxldGltZXN0YW1wPTIwMTAwNjA5MTIzMzE3IiBjbGFzcz0iaW1hZ2UiPjxpbWcgYWx0PSIiIHNy Yz0iaHR0cDovL3VwbG9hZC53aWtpbWVkaWEub3JnL3dpa2lwZWRpYS9jb21tb25zL3RodW1iLzAv MDMvQnVzaF9hbmRfR29yYmFjaGV2X2F0X3RoZV9NYWx0YV9zdW1taXRfaW5fMTk4OS5naWYvMjIw cHgtQnVzaF9hbmRfR29yYmFjaGV2X2F0X3RoZV9NYWx0YV9zdW1taXRfaW5fMTk4OS5naWYiIHdp ZHRoPSIyMjAiIGhlaWdodD0iMTQ5IiBjbGFzcz0idGh1bWJpbWFnZSIgLz48L2E+CTxkaXYgY2xh c3M9InRodW1iY2FwdGlvbiI+CTxkaXYgY2xhc3M9Im1hZ25pZnkiPjxhIGhyZWY9Ii93L2luZGV4 LnBocD90aXRsZT1EYXRlaTpCdXNoX2FuZF9Hb3JiYWNoZXZfYXRfdGhlX01hbHRhX3N1bW1pdF9p bl8xOTg5LmdpZiZhbXA7ZmlsZXRpbWVzdGFtcD0yMDEwMDYwOTEyMzMxNyIgY2xhc3M9ImludGVy bmFsIiB0aXRsZT0idmVyZ3LDtsOfZXJuIj48aW1nIHNyYz0iaHR0cDovL2JpdHMud2lraW1lZGlh Lm9yZy9za2lucy0xLjUvY29tbW9uL2ltYWdlcy9tYWduaWZ5LWNsaXAucG5nIiB3aWR0aD0iMTUi IGhlaWdodD0iMTEiIGFsdD0iIiAvPjwvYT48L2Rpdj4JR2lwZmVsdHJlZmZlbiB2b3IgTWFsdGEg MTk4OTwvZGl2Pgk8L2Rpdj4JPC9kaXY+CTxwPlp1IGVpbmVtIEdpcGZlbGdlc3Byw6RjaCB0cmFm IHNpY2ggZGVyIFByw6RzaWRlbnQgbWl0IGRlbSBzb3dqZXRpc2NoZW4gR2VuZXJhbHNla3JldMOk ciA8YSBocmVmPSIvd2lraS9NaWNoYWlsX1NlcmdlamV3aXRzY2hfR29yYmF0c2Nob3ciIHRpdGxl PSJNaWNoYWlsIFNlcmdlamV3aXRzY2ggR29yYmF0c2Nob3ciPk1pY2hhaWwgR29yYmF0c2Nob3c8 L2E+IGFtIDIuIHVuZCAzLiBEZXplbWJlciAxOTg5IHZvciBNYWx0YS4gV8OkaHJlbmQgZGVyIEph aHJlIDE5ODkgdW5kIDE5OTAgZXJ3YXJiIHNpY2ggQnVzaCBncm/Dn2UgVmVyZGllbnN0ZSB1bSBk aWUgPGEgaHJlZj0iL3dpa2kvRGV1dHNjaGVfV2llZGVydmVyZWluaWd1bmciIHRpdGxlPSJEZXV0 c2NoZSBXaWVkZXJ2ZXJlaW5pZ3VuZyI+V2llZGVydmVyZWluaWd1bmc8L2E+IERldXRzY2hsYW5k cywgenUgZGVyZW4gc2NobmVsbGVyIFZlcndpcmtsaWNodW5nIGF1Y2ggKGV0d2FzIGFid2FydGVu ZGVyKSBzZWluIEF1w59lbm1pbmlzdGVyIDxhIGhyZWY9Ii93aWtpL0phbWVzX0Jha2VyIiB0aXRs ZT0iSmFtZXMgQmFrZXIiPkphbWVzIEJha2VyPC9hPiB1bmQgc2VpbmUgQmVyYXRlcmluIDxhIGhy ZWY9Ii93aWtpL0NvbmRvbGVlenphX1JpY2UiIHRpdGxlPSJDb25kb2xlZXp6YSBSaWNlIj5Db25k b2xlZXp6YSBSaWNlPC9hPiBiZWl0cnVnZW4uPC9wPgk8cD5PYndvaGwgc2VpbmUgPGEgaHJlZj0i L3dpa2kvUG9wdWxhcml0JUMzJUE0dCIgdGl0bGU9IlBvcHVsYXJpdMOkdCI+UG9wdWxhcml0w6R0 PC9hPiB3w6RocmVuZCB1bmQga3VyeiBuYWNoIGRlbSBLcmllZyBzdGFyayBuYWNoIG9iZW4gc2No bmVsbHRlLCB3YXIgZGllIHp3ZWl0ZSBIw6RsZnRlIHNlaW5lciBQcsOkc2lkZW50c2NoYWZ0IHZv bSBFaW5kcnVjayDDvGJlcnNjaGF0dGV0LCBkYXNzIEJ1c2ggZGVuIEtvbnRha3QgenUgZGVuIGFs bHTDpGdsaWNoZW4gUHJvYmxlbWVuIGRlcyBMYW5kZXMgdmVybG9yZW4gaGF0dGUsIGRpZSBzaWNo IGR1cmNoIGVpbmUgPGEgaHJlZj0iL3dpa2kvV2lydHNjaGFmdHNrcmlzZSIgdGl0bGU9IldpcnRz Y2hhZnRza3Jpc2UiPldpcnRzY2hhZnRza3Jpc2U8L2E+IHZlcnNjaMOkcmZ0ZW4uIEdlZ2VuIEVu ZGUgZGVyIElyYWstSW50ZXJ2ZW50aW9uIHdlaWdlcnRlIHNpY2ggZGVyIFByw6RzaWRlbnQgYW0g MjcuIEZlYnJ1YXIgMTk5MSBpbSBPdmFsIE9mZmljZSBkZXMgV2Vpw59lbiBIYXVzZXMsIMO8YmVy IGRhcyBtaWxpdMOkcmlzY2hlIFppZWwgZGVyIDxhIGhyZWY9Ii93aWtpL1Jlc29sdXRpb25fNjc4 X2Rlc19VTi1TaWNoZXJoZWl0c3JhdGVzIiB0aXRsZT0iUmVzb2x1dGlvbiA2NzggZGVzIFVOLVNp Y2hlcmhlaXRzcmF0ZXMiPlJlc29sdXRpb24gNjc4IGRlcyBVTi1TaWNoZXJoZWl0c3JhdGVzPC9h PiAoTm92ZW1iZXIgMTk5MCkgaGluYXVzenVnZWhlbi4gRGVyIDxhIGhyZWY9Ii93aWtpL0tlcm5z YXR6IiB0aXRsZT0iS2VybnNhdHoiIGNsYXNzPSJtdy1yZWRpcmVjdCI+S2VybnNhdHo8L2E+IGRl ciBSZXNvbHV0aW9uIHp1ciBCZWZyZWl1bmcgS3V3YWl0cyBsYXV0ZXRlIOKAnndpdGggYWxsIG5l Y2Vzc2FyeSBtZWFucyBpbmNsdWRpbmcgZm9yY2XigJwuIEJ1c2hzIEVudHNjaGVpZHVuZyBzdG9w cHRlIGRlbiBzY2hvbiBhbmxhdWZlbmRlbiBWb3JzdG/DnyBuYWNoIDxhIGhyZWY9Ii93aWtpL0Jh Z2RhZCIgdGl0bGU9IkJhZ2RhZCI+QmFnZGFkPC9hPjsgZGllIE5lb2tvbnNlcnZhdGl2ZW4gaW4g QnVzaHMgPGEgaHJlZj0iL3dpa2kvS2FiaW5ldHRfR2VvcmdlX0guX1cuX0J1c2giIHRpdGxlPSJL YWJpbmV0dCBHZW9yZ2UgSC4gVy4gQnVzaCI+S2FiaW5ldHQ8L2E+LCB2b3IgYWxsZW0gVmVydGVp ZGlndW5nc21pbmlzdGVyIDxhIGhyZWY9Ii93aWtpL0RpY2tfQ2hlbmV5IiB0aXRsZT0iRGljayBD aGVuZXkiPlJpY2hhcmQgQ2hlbmV5PC9hPiwgaGF0dGVuIGRpZXMgZsO8ciBmYWxzY2ggZ2VoYWx0 ZW4uIERlciBnZXdhbHRzYW1lIFJlZ2ltZXdlY2hzZWwgZXJmb2xndGUgZXJzdCBpbSA8YSBocmVm PSIvd2lraS9JcmFra3JpZWciIHRpdGxlPSJJcmFra3JpZWciPklyYWtrcmllZzwvYT4gKDIwMDMp LjwvcD4JPHA+VW5wb3B1bMOkciB3YXIgYXVjaCBkZXIgQnJ1Y2ggc2VpbmVzIGJlcsO8aG10ZW4g V2FobHZlcnNwcmVjaGVucyB2b24gMTk4OCDigJ48YSBocmVmPSIvd2lraS9SZWFkX215X2xpcHM6 X25vX25ld190YXhlcyIgdGl0bGU9IlJlYWQgbXkgbGlwczogbm8gbmV3IHRheGVzIj5SZWFkIG15 IGxpcHM6IG5vIG5ldyB0YXhlczwvYT7igJwgKDxpPkxlc3QgZXMgdm9uIG1laW5lbiBMaXBwZW46 IEtlaW5lIG5ldWVuIFN0ZXVlcm48L2k+KSBkdXJjaCBkaWUgMTk5MCB2b3JnZW5vbW1lbmVuIFN0 ZXVlcmVyaMO2aHVuZ2VuLiBEaWVzIGFsbGVzIHdhcmVuIHdlc2VudGxpY2hlIEdyw7xuZGUgZsO8 ciBkaWUgTmllZGVybGFnZSBiZWkgZGVyIDxhIGhyZWY9Ii93aWtpL1ByJUMzJUE0c2lkZW50c2No YWZ0c3dhaGxfaW5fZGVuX1ZlcmVpbmlndGVuX1N0YWF0ZW5fMTk5MiIgdGl0bGU9IlByw6RzaWRl bnRzY2hhZnRzd2FobCBpbiBkZW4gVmVyZWluaWd0ZW4gU3RhYXRlbiAxOTkyIj5QcsOkc2lkZW50 c2NoYWZ0c3dhaGwgMTk5MjwvYT4gZ2VnZW4gZGVuIHVuZXJmYWhyZW5lbiwgYWJlciBkeW5hbWlz Y2ggYXVmdHJldGVuZGVuIDxhIGhyZWY9Ii93aWtpL0JpbGxfQ2xpbnRvbiIgdGl0bGU9IkJpbGwg Q2xpbnRvbiI+QmlsbCBDbGludG9uPC9hPi48L3A+CTxoMj48c3BhbiBjbGFzcz0ibXctaGVhZGxp bmUiIGlkPSJOYWNoX2Rlcl9Qci5DMy5BNHNpZGVudHNjaGFmdCI+TmFjaCBkZXIgUHLDpHNpZGVu dHNjaGFmdDwvc3Bhbj48L2gyPgk8ZGl2IGNsYXNzPSJ0aHVtYiB0cmlnaHQiPgk8ZGl2IGNsYXNz PSJ0aHVtYmlubmVyIiBzdHlsZT0id2lkdGg6MjIycHg7Ij48YSBocmVmPSIvdy9pbmRleC5waHA/ dGl0bGU9RGF0ZWk6QnVzaGhhdXMyLkpQRyZhbXA7ZmlsZXRpbWVzdGFtcD0yMDA3MDkxMTIxNTU0 MiIgY2xhc3M9ImltYWdlIj48aW1nIGFsdD0iIiBzcmM9Imh0dHA6Ly91cGxvYWQud2lraW1lZGlh Lm9yZy93aWtpcGVkaWEvY29tbW9ucy90aHVtYi8xLzFhL0J1c2hoYXVzMi5KUEcvMjIwcHgtQnVz aGhhdXMyLkpQRyIgd2lkdGg9IjIyMCIgaGVpZ2h0PSI5OCIgY2xhc3M9InRodW1iaW1hZ2UiIC8+ PC9hPgk8ZGl2IGNsYXNzPSJ0aHVtYmNhcHRpb24iPgk8ZGl2IGNsYXNzPSJtYWduaWZ5Ij48YSBo cmVmPSIvdy9pbmRleC5waHA/dGl0bGU9RGF0ZWk6QnVzaGhhdXMyLkpQRyZhbXA7ZmlsZXRpbWVz dGFtcD0yMDA3MDkxMTIxNTU0MiIgY2xhc3M9ImludGVybmFsIiB0aXRsZT0idmVyZ3LDtsOfZXJu Ij48aW1nIHNyYz0iaHR0cDovL2JpdHMud2lraW1lZGlhLm9yZy9za2lucy0xLjUvY29tbW9uL2lt YWdlcy9tYWduaWZ5LWNsaXAucG5nIiB3aWR0aD0iMTUiIGhlaWdodD0iMTEiIGFsdD0iIiAvPjwv YT48L2Rpdj4JRGVyIEJ1c2gtU29tbWVyc2l0eiBiZWkgS2VubmVidW5rcG9ydCAoV2Fsa2VyJ3Mg UG9pbnQpPC9kaXY+CTwvZGl2Pgk8L2Rpdj4JPHA+RGllIEJ1c2hzIGxlYmVuIGhldXRlIGluIDxh IGhyZWY9Ii93aWtpL0hvdXN0b24iIHRpdGxlPSJIb3VzdG9uIj5Ib3VzdG9uPC9hPiwgPGEgaHJl Zj0iL3dpa2kvVGV4YXMiIHRpdGxlPSJUZXhhcyI+VGV4YXM8L2E+IHVuZCBoYWJlbiBtaXQgPGk+ PGEgaHJlZj0iL3dpa2kvQnVzaC1Bbndlc2VuIiB0aXRsZT0iQnVzaC1Bbndlc2VuIj5XYWxrZXIn cyBQb2ludDwvYT48L2k+IGVpbmVuIFNvbW1lcnNpdHogYmVpIDxhIGhyZWY9Ii93aWtpL0tlbm5l YnVua3BvcnQiIHRpdGxlPSJLZW5uZWJ1bmtwb3J0Ij5LZW5uZWJ1bmtwb3J0PC9hPiwgPGEgaHJl Zj0iL3dpa2kvTWFpbmUiIHRpdGxlPSJNYWluZSI+TWFpbmU8L2E+LCBkZXIgc2Nob24gd8OkaHJl bmQgZGVyIEFtdHN6ZWl0IGdsZWljaHJhbmdpZyBuZWJlbiBkZW0gb2ZmaXppZWxsZW4gZGllbnN0 bGljaGVuIFNvbW1lcnNpdHogPGEgaHJlZj0iL3dpa2kvQ2FtcF9EYXZpZCIgdGl0bGU9IkNhbXAg RGF2aWQiPkNhbXAgRGF2aWQ8L2E+IGbDvHIgU3RhYXRzYmVzdWNoZSBiZW51dHp0IHd1cmRlLiBT byBlbXBmaW5nIFByw6RzaWRlbnQgQnVzaCBkb3J0IDE5ODkgZGVuIGRhbWFsaWdlbiBmcmFuesO2 c2lzY2hlbiBQcsOkc2lkZW50ZW4gPGEgaHJlZj0iL3dpa2kvRnJhbiVDMyVBN29pc19NaXR0ZXJy YW5kIiB0aXRsZT0iRnJhbsOnb2lzIE1pdHRlcnJhbmQiPkZyYW7Dp29pcyBNaXR0ZXJyYW5kPC9h Pi48L3A+CTxoMj48c3BhbiBjbGFzcz0ibXctaGVhZGxpbmUiIGlkPSJOYW1lbnNnZWJ1bmdlbl96 dV9FaHJlbl9CdXNocyI+TmFtZW5zZ2VidW5nZW4genUgRWhyZW4gQnVzaHM8L3NwYW4+PC9oMj4J PGRpdiBjbGFzcz0idGh1bWIgdHJpZ2h0Ij4JPGRpdiBjbGFzcz0idGh1bWJpbm5lciIgc3R5bGU9 IndpZHRoOjIyMnB4OyI+PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPURhdGVpOkdXX2FuZF9H SFdfQnVzaF9haXJjcmFmdF9jYXJyaWVyX2NocmlzdGVuaW5nLmpwZyZhbXA7ZmlsZXRpbWVzdGFt cD0yMDA2MTAxMDEzMDcxNyIgY2xhc3M9ImltYWdlIj48aW1nIGFsdD0iIiBzcmM9Imh0dHA6Ly91 cGxvYWQud2lraW1lZGlhLm9yZy93aWtpcGVkaWEvY29tbW9ucy90aHVtYi9jL2MyL0dXX2FuZF9H SFdfQnVzaF9haXJjcmFmdF9jYXJyaWVyX2NocmlzdGVuaW5nLmpwZy8yMjBweC1HV19hbmRfR0hX X0J1c2hfYWlyY3JhZnRfY2Fycmllcl9jaHJpc3RlbmluZy5qcGciIHdpZHRoPSIyMjAiIGhlaWdo dD0iMTYxIiBjbGFzcz0idGh1bWJpbWFnZSIgLz48L2E+CTxkaXYgY2xhc3M9InRodW1iY2FwdGlv biI+CTxkaXYgY2xhc3M9Im1hZ25pZnkiPjxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1EYXRl aTpHV19hbmRfR0hXX0J1c2hfYWlyY3JhZnRfY2Fycmllcl9jaHJpc3RlbmluZy5qcGcmYW1wO2Zp bGV0aW1lc3RhbXA9MjAwNjEwMTAxMzA3MTciIGNsYXNzPSJpbnRlcm5hbCIgdGl0bGU9InZlcmdy w7bDn2VybiI+PGltZyBzcmM9Imh0dHA6Ly9iaXRzLndpa2ltZWRpYS5vcmcvc2tpbnMtMS41L2Nv bW1vbi9pbWFnZXMvbWFnbmlmeS1jbGlwLnBuZyIgd2lkdGg9IjE1IiBoZWlnaHQ9IjExIiBhbHQ9 IiIgLz48L2E+PC9kaXY+CUdlb3JnZSBILiBXLiBCdXNoIChyZWNodHMpIHVuZCBzZWluIFNvaG4g YmVpIGRlciBUYXVmZSBkZXMgbmFjaCBHZW9yZ2UgSC4mIzE2MDtXLiBCdXNoIGJlbmFubnRlbiBG bHVnemV1Z3Ryw6RnZXJzIGFtIDEwLiBPa3RvYmVyIDIwMDY8L2Rpdj4JPC9kaXY+CTwvZGl2Pgk8 dWw+CTxsaT5EaWUgPGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPUdlb3JnZV9CdXNoX1ByZXNp ZGVudGlhbF9MaWJyYXJ5JmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3 IiB0aXRsZT0iR2VvcmdlIEJ1c2ggUHJlc2lkZW50aWFsIExpYnJhcnkgKFNlaXRlIG5pY2h0IHZv cmhhbmRlbikiPkdlb3JnZSBCdXNoIFByZXNpZGVudGlhbCBMaWJyYXJ5PC9hPiwgZGVyZW4gQXVm YmF1IDE5OTQgaW4gPGEgaHJlZj0iL3dpa2kvQ29sbGVnZV9TdGF0aW9uIiB0aXRsZT0iQ29sbGVn ZSBTdGF0aW9uIj5Db2xsZWdlIFN0YXRpb248L2E+LCBUZXhhcywgYmVnYW5uOzwvbGk+CTxsaT5E ZXIgaW50ZXJuYXRpb25hbGUgRmx1Z2hhZmVuIDxhIGhyZWY9Ii93aWtpL0hvdXN0b24iIHRpdGxl PSJIb3VzdG9uIj5Ib3VzdG9uPC9hPiB3dXJkZSAxOTk3IHp1bSA8YSBocmVmPSIvd2lraS9HZW9y Z2VfQnVzaF9JbnRlcmNvbnRpbmVudGFsX0FpcnBvcnQiIHRpdGxlPSJHZW9yZ2UgQnVzaCBJbnRl cmNvbnRpbmVudGFsIEFpcnBvcnQiPkdlb3JnZSBCdXNoIEludGVyY29udGluZW50YWwgQWlycG9y dDwvYT47PC9saT4JPGxpPkRlciB6ZWhudGUgPGEgaHJlZj0iL3dpa2kvRmx1Z3pldWd0ciVDMyVB NGdlciIgdGl0bGU9IkZsdWd6ZXVndHLDpGdlciI+Rmx1Z3pldWd0csOkZ2VyPC9hPiBkZXIgPGEg aHJlZj0iL3dpa2kvTmltaXR6LUtsYXNzZSIgdGl0bGU9Ik5pbWl0ei1LbGFzc2UiPk5pbWl0ei1L bGFzc2U8L2E+IGhlacOfdCA8YSBocmVmPSIvd2lraS9VU1NfR2VvcmdlX0guX1cuX0J1c2hfKENW Ti03NykiIHRpdGxlPSJVU1MgR2VvcmdlIEguIFcuIEJ1c2ggKENWTi03NykiPjxpPlVTUyBHZW9y Z2UgSC4gVy4gQnVzaDwvaT48L2E+LjwvbGk+CTwvdWw+CTxoMj48c3BhbiBjbGFzcz0ibXctaGVh ZGxpbmUiIGlkPSJTaWVoZV9hdWNoIj5TaWVoZSBhdWNoPC9zcGFuPjwvaDI+CTx1bD4JPGxpPjxh IGhyZWY9Ii93aWtpL0thYmluZXR0X0dlb3JnZV9ILl9XLl9CdXNoIiB0aXRsZT0iS2FiaW5ldHQg R2VvcmdlIEguIFcuIEJ1c2giPkthYmluZXR0IEJ1c2g8L2E+PC9saT4JPC91bD4JPGgyPjxzcGFu IGNsYXNzPSJtdy1oZWFkbGluZSIgaWQ9IlNjaHJpZnRlbiI+U2NocmlmdGVuPC9zcGFuPjwvaDI+ CTx1bD4JPGxpPjxjaXRlIGNsYXNzPSJib29rIiBzdHlsZT0iZm9udC1zdHlsZTpub3JtYWwiIGlk PSJSZWZlcmVuY2UtQnVzaC0xOTk5Ij5HZW9yZ2UgSC4gVy4gQnVzaDogPGk+QWxsIHRoZSBCZXN0 LCBHZW9yZ2UgQnVzaDogTXkgTGlmZSBpbiBMZXR0ZXJzIGFuZCBPdGhlciBXcml0aW5nczwvaT4u IE5ldyBZb3JrOiBTY3JpYm5lciAxOTk5LCA8YSBocmVmPSIvd2lraS9TcGV6aWFsOklTQk4tU3Vj aGUvMDY4NDgzOTU4WCIgY2xhc3M9ImludGVybmFsIG13LW1hZ2ljbGluay1pc2JuIj5JU0JOIDAt Njg0LTgzOTU4LVg8L2E+PC9jaXRlPjwvbGk+CTxsaT48Y2l0ZSBjbGFzcz0iYm9vayIgc3R5bGU9 ImZvbnQtc3R5bGU6bm9ybWFsIiBpZD0iUmVmZXJlbmNlLUJ1c2gtMTk5OCI+R2VvcmdlIEguIFcu IEJ1c2gsIFNjb3djcm9mdCwgQnJlbnQ6IDxpPkEgV29ybGQgVHJhbnNmb3JtZWQ8L2k+LiBOZXcg WW9yazogS25vcGYgMTk5OCwgPGEgaHJlZj0iL3dpa2kvU3BlemlhbDpJU0JOLVN1Y2hlLzA2Nzk0 MzI0ODUiIGNsYXNzPSJpbnRlcm5hbCBtdy1tYWdpY2xpbmstaXNibiI+SVNCTiAwLTY3OS00MzI0 OC01PC9hPjwvY2l0ZT48L2xpPgk8L3VsPgk8aDI+PHNwYW4gY2xhc3M9Im13LWhlYWRsaW5lIiBp ZD0iTGl0ZXJhdHVyIj5MaXRlcmF0dXI8L3NwYW4+PC9oMj4JPHVsPgk8bGk+PGNpdGUgY2xhc3M9 ImJvb2siIHN0eWxlPSJmb250LXN0eWxlOm5vcm1hbCIgaWQ9IlJlZmVyZW5jZS1CYXJpbGxlYXV4 LTE5OTIiPlJ5YW4gSi4gQmFyaWxsZWF1eCwgU3R1Y2tleSwgTWFyeSBFLjogPGk+TGVhZGVyc2hp cCBhbmQgdGhlIEJ1c2ggUHJlc2lkZW5jeTogUHJ1ZGVuY2Ugb3IgRHJpZnQgaW4gYW4gRXJhIG9m IENoYW5nZTwvaT4uIE5ldyBZb3JrOiBQcmFlZ2VyIDE5OTIsIDxhIGhyZWY9Ii93aWtpL1NwZXpp YWw6SVNCTi1TdWNoZS8wMjc1OTQ0MTgyIiBjbGFzcz0iaW50ZXJuYWwgbXctbWFnaWNsaW5rLWlz Ym4iPklTQk4gMC0yNzUtOTQ0MTgtMjwvYT48L2NpdGU+PC9saT4JPGxpPjxjaXRlIGNsYXNzPSJi b29rIiBzdHlsZT0iZm9udC1zdHlsZTpub3JtYWwiIGlkPSJSZWZlcmVuY2UtRHVjYXQtMjAwNCI+ U3RlcGhlbiBKLiBEdWNhdDogPGk+VGhlIFdpbXAgRmFjdG9yOiBHZW5kZXIgR2FwcywgSG9seSBX YXJzLCBhbmQgdGhlIFBvbGl0aWNzIG9mIEFueGlvdXMgTWFzY3VsaW5pdHk8L2k+LiBCb3N0b246 IEJlYWNvbiBQcmVzcyAyMDA0LCA8YSBocmVmPSIvd2lraS9TcGV6aWFsOklTQk4tU3VjaGUvMDgw NzA0MzQ0MyIgY2xhc3M9ImludGVybmFsIG13LW1hZ2ljbGluay1pc2JuIj5JU0JOIDAtODA3MC00 MzQ0LTM8L2E+PC9jaXRlPjwvbGk+CTxsaT48Y2l0ZSBjbGFzcz0iYm9vayIgc3R5bGU9ImZvbnQt c3R5bGU6bm9ybWFsIiBpZD0iUmVmZXJlbmNlLUR1ZmZ5LTE5OTIiPk1pY2hhZWwgRHVmZnksIEdv b2RnYW1lLCBEYW46IDxpPk1hcmNoaW5nIGluIFBsYWNlJiMxNjA7OiBUaGUgU3RhdHVzIFF1byBQ cmVzaWRlbmN5IG9mIEdlb3JnZSBCdXNoPC9pPi4gTmV3IFlvcms6IFNpbW9uICZhbXA7IFNjaHVz dGVyIDE5OTIsIDxhIGhyZWY9Ii93aWtpL1NwZXppYWw6SVNCTi1TdWNoZS8wNjcxNzM3MjAxIiBj bGFzcz0iaW50ZXJuYWwgbXctbWFnaWNsaW5rLWlzYm4iPklTQk4gMC02NzEtNzM3MjAtMTwvYT48 L2NpdGU+PC9saT4JPGxpPjxjaXRlIGNsYXNzPSJib29rIiBzdHlsZT0iZm9udC1zdHlsZTpub3Jt YWwiIGlkPSJSZWZlcmVuY2UtRml0endhdGVyLTE5OTUiPjxhIGhyZWY9Ii93L2luZGV4LnBocD90 aXRsZT1NYXJsaW5fRml0endhdGVyJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFz cz0ibmV3IiB0aXRsZT0iTWFybGluIEZpdHp3YXRlciAoU2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+ TWFybGluIEZpdHp3YXRlcjwvYT46IDxpPkNhbGwgdGhlIEJyaWVmaW5nPC9pPi4gTmV3IFlvcms6 IFRpbWVzIEJvb2tzIDE5OTUsIDxhIGhyZWY9Ii93aWtpL1NwZXppYWw6SVNCTi1TdWNoZS85Nzgw NzM4ODM0NTgwIiBjbGFzcz0iaW50ZXJuYWwgbXctbWFnaWNsaW5rLWlzYm4iPklTQk4gOTc4LTAt NzM4OC0zNDU4LTA8L2E+PC9jaXRlPjwvbGk+CTxsaT48Y2l0ZSBjbGFzcz0iYm9vayIgc3R5bGU9 ImZvbnQtc3R5bGU6bm9ybWFsIiBpZD0iUmVmZXJlbmNlLUdyZWVuLTIwMDAiPkpvaG4gUm9iZXJ0 IEdyZWVuOiA8aT5UaGUgUHJlc2lkZW5jeSBvZiBHZW9yZ2UgQnVzaDwvaT4uIExhd3JlbmNlOiBV bml2ZXJzaXR5IFByZXNzIG9mIEthbnNhcyAyMDAwLCA8YSBocmVmPSIvd2lraS9TcGV6aWFsOklT Qk4tU3VjaGUvMDcwMDYwOTkzOCIgY2xhc3M9ImludGVybmFsIG13LW1hZ2ljbGluay1pc2JuIj5J U0JOIDAtNzAwNi0wOTkzLTg8L2E+PC9jaXRlPjwvbGk+CTxsaT48Y2l0ZSBjbGFzcz0iYm9vayIg c3R5bGU9ImZvbnQtc3R5bGU6bm9ybWFsIiBpZD0iUmVmZXJlbmNlLUh5YW1zLTE5OTEiPkpvZSBI eWFtczogPGk+RmxpZ2h0IG9mIHRoZSBBdmVuZ2VyOiBHZW9yZ2UgQnVzaCBhdCBXYXI8L2k+LiBT YW4gRGllZ286IEhhcmNvdXJ0IEJyYWNlIEpvdmFub3ZpYyAxOTkxLCA8YSBocmVmPSIvd2lraS9T cGV6aWFsOklTQk4tU3VjaGUvMDE1MTMxNDY5MSIgY2xhc3M9ImludGVybmFsIG13LW1hZ2ljbGlu ay1pc2JuIj5JU0JOIDAtMTUtMTMxNDY5LTE8L2E+PC9jaXRlPjwvbGk+CTxsaT48Y2l0ZSBjbGFz cz0iYm9vayIgc3R5bGU9ImZvbnQtc3R5bGU6bm9ybWFsIiBpZD0iUmVmZXJlbmNlLUtlbGxleS0y MDA0Ij5LaXR0eSBLZWxsZXk6IDxpPlRoZSBGYW1pbHk6IFRoZSBUcnVlIFN0b3J5IG9mIHRoZSBC dXNoIER5bmFzdHk8L2k+LiBMb25kb246IERvdWJsZWRheSAyMDA0LCA8YSBocmVmPSIvd2lraS9T cGV6aWFsOklTQk4tU3VjaGUvMDM4NTUwMzI0NSIgY2xhc3M9ImludGVybmFsIG13LW1hZ2ljbGlu ay1pc2JuIj5JU0JOIDAtMzg1LTUwMzI0LTU8L2E+PC9jaXRlPjwvbGk+CTxsaT48Y2l0ZSBjbGFz cz0iYm9vayIgc3R5bGU9ImZvbnQtc3R5bGU6bm9ybWFsIiBpZD0iUmVmZXJlbmNlLVBvZGhvcmV0 ei0xOTkzIj5Kb2huIFBvZGhvcmV0ejogPGk+SGVsbCBvZiBhIFJpZGU6IEJhY2tzdGFnZSBhdCB0 aGUgV2hpdGUgSG91c2UgRm9sbGllcywgMTk4OS0xOTkzPC9pPi4gTmV3IFlvcms6IFNpbW9uICZh bXA7IFNjaHVzdGVyIDE5OTMsIDxhIGhyZWY9Ii93aWtpL1NwZXppYWw6SVNCTi1TdWNoZS8wNjcx Nzk2NDg4IiBjbGFzcz0iaW50ZXJuYWwgbXctbWFnaWNsaW5rLWlzYm4iPklTQk4gMC02NzEtNzk2 NDgtODwvYT48L2NpdGU+PC9saT4JPGxpPjxjaXRlIGNsYXNzPSJib29rIiBzdHlsZT0iZm9udC1z dHlsZTpub3JtYWwiIGlkPSJSZWZlcmVuY2UtU21pdGgtMTk5MiI+PGEgaHJlZj0iL3cvaW5kZXgu cGhwP3RpdGxlPUplYW5fRWR3YXJkX1NtaXRoJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0x IiBjbGFzcz0ibmV3IiB0aXRsZT0iSmVhbiBFZHdhcmQgU21pdGggKFNlaXRlIG5pY2h0IHZvcmhh bmRlbikiPkplYW4gRWR3YXJkIFNtaXRoPC9hPjogPGk+R2VvcmdlIEJ1c2gncyBXYXI8L2k+LiBO ZXcgWW9yazogSGVucnkgSG9sdCAmYW1wOyBDb21wYW55IDE5OTIsIDxhIGhyZWY9Ii93aWtpL1Nw ZXppYWw6SVNCTi1TdWNoZS8wODA1MDEzODgxIiBjbGFzcz0iaW50ZXJuYWwgbXctbWFnaWNsaW5r LWlzYm4iPklTQk4gMC04MDUwLTEzODgtMTwvYT48L2NpdGU+PC9saT4JPGxpPjxjaXRlIGNsYXNz PSJib29rIiBzdHlsZT0iZm9udC1zdHlsZTpub3JtYWwiIGlkPSJSZWZlcmVuY2UtVGFycGxleS0x OTkxIj5XZWJzdGVyIEcuIFRhcnBsZXksIENoYWl0a2luLCBBbnRvbjogPGk+R2VvcmdlIEJ1c2g6 IFRoZSBVbmF1dGhvcml6ZWQgQmlvZ3JhcGh5PC9pPi4gV2FzaGluZ3RvbjogRXhlY3V0aXZlIElu dGVsbGlnZW5jZSBSZXZpZXcgMTk5MSwgPGEgaHJlZj0iL3dpa2kvU3BlemlhbDpJU0JOLVN1Y2hl LzA5NDMyMzUwNTciIGNsYXNzPSJpbnRlcm5hbCBtdy1tYWdpY2xpbmstaXNibiI+SVNCTiAwLTk0 MzIzNS0wNS03PC9hPjwvY2l0ZT48L2xpPgk8L3VsPgk8aDI+PHNwYW4gY2xhc3M9Im13LWhlYWRs aW5lIiBpZD0iV2VibGlua3MiPldlYmxpbmtzPC9zcGFuPjwvaDI+CTxkaXYgY2xhc3M9InNpc3Rl cnByb2plY3QiIHN0eWxlPSJtYXJnaW46MC4xZW0gMCAwIDA7Ij48aW1nIGFsdD0iV2lraXF1b3Rl IiBzcmM9Imh0dHA6Ly91cGxvYWQud2lraW1lZGlhLm9yZy93aWtpcGVkaWEvY29tbW9ucy90aHVt Yi9mL2ZhL1dpa2lxdW90ZS1sb2dvLnN2Zy8xM3B4LVdpa2lxdW90ZS1sb2dvLnN2Zy5wbmciIHdp ZHRoPSIxMyIgaGVpZ2h0PSIxNSIgLz4mIzE2MDs8Yj48YSBocmVmPSJodHRwOi8vZGUud2lraXF1 b3RlLm9yZy93aWtpL0dlb3JnZV9ILl9XLl9CdXNoIiBjbGFzcz0iZXh0aXciIHRpdGxlPSJxOkdl b3JnZSBILiBXLiBCdXNoIj5XaWtpcXVvdGU6IEdlb3JnZSBILiBXLiBCdXNoPC9hPjwvYj4mIzE2 MDvigJMgWml0YXRlPC9kaXY+CTxkaXYgY2xhc3M9InNpc3RlcnByb2plY3QiIHN0eWxlPSJtYXJn aW46MC4xZW0gMCAwIDA7Ij48aW1nIGFsdD0iIiBzcmM9Imh0dHA6Ly91cGxvYWQud2lraW1lZGlh Lm9yZy93aWtpcGVkaWEvY29tbW9ucy90aHVtYi80LzRhL0NvbW1vbnMtbG9nby5zdmcvMTJweC1D b21tb25zLWxvZ28uc3ZnLnBuZyIgd2lkdGg9IjEyIiBoZWlnaHQ9IjE2IiAvPiYjMTYwOzxiPjxz cGFuIGNsYXNzPSJwbGFpbmxpbmtzIj48YSBocmVmPSJodHRwOi8vY29tbW9ucy53aWtpbWVkaWEu b3JnL3dpa2kvQ2F0ZWdvcnk6R2VvcmdlX0guX1cuX0J1c2g/dXNlbGFuZz1kZSIgY2xhc3M9ImV4 dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ciPkNvbW1vbnM6IEdlb3JnZSBILiBXLiBCdXNoPC9h Pjwvc3Bhbj48L2I+JiMxNjA74oCTIFNhbW1sdW5nIHZvbiBCaWxkZXJuLCBWaWRlb3MgdW5kIEF1 ZGlvZGF0ZWllbjwvZGl2Pgk8ZGl2IGNsYXNzPSJzaXN0ZXJwcm9qZWN0IiBzdHlsZT0ibWFyZ2lu OjAuMWVtIDAgMCAwOyI+PGltZyBhbHQ9Ildpa2lzb3VyY2UiIHNyYz0iaHR0cDovL3VwbG9hZC53 aWtpbWVkaWEub3JnL3dpa2lwZWRpYS9jb21tb25zL3RodW1iLzQvNGMvV2lraXNvdXJjZS1sb2dv LnN2Zy8xNXB4LVdpa2lzb3VyY2UtbG9nby5zdmcucG5nIiB3aWR0aD0iMTUiIGhlaWdodD0iMTYi IC8+JiMxNjA7PGI+PGEgaHJlZj0iaHR0cDovL2RlLndpa2lzb3VyY2Uub3JnL3dpa2kvZW46QXV0 aG9yOkdlb3JnZV9IZXJiZXJ0X1dhbGtlcl9CdXNoIiBjbGFzcz0iZXh0aXciIHRpdGxlPSJzOmVu OkF1dGhvcjpHZW9yZ2UgSGVyYmVydCBXYWxrZXIgQnVzaCI+V2lraXNvdXJjZTogR2VvcmdlIEgu IFcuIEJ1c2g8L2E+PC9iPiYjMTYwO+KAkyBRdWVsbGVuIHVuZCBWb2xsdGV4dGUgKEVuZ2xpc2No KTwvZGl2Pgk8dWw+CTxsaT48YSBocmVmPSJodHRwczovL3BvcnRhbC5kLW5iLmRlL29wYWMuaHRt P3F1ZXJ5PVdvZSUzRDExODg0NDkxMSZhbXA7bWV0aG9kPXNpbXBsZVNlYXJjaCIgY2xhc3M9ImV4 dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ciPkxpdGVyYXR1ciB2b24gdW5kIMO8YmVyIEdlb3Jn ZSBILiBXLiBCdXNoPC9hPiBpbSBLYXRhbG9nIGRlciA8YSBocmVmPSIvd2lraS9EZXV0c2NoZV9O YXRpb25hbGJpYmxpb3RoZWsiIHRpdGxlPSJEZXV0c2NoZSBOYXRpb25hbGJpYmxpb3RoZWsiPkRl dXRzY2hlbiBOYXRpb25hbGJpYmxpb3RoZWs8L2E+IDxzcGFuIGNsYXNzPSJtZXRhZGF0YSI+PHNt YWxsPig8YSBocmVmPSJodHRwOi8vZGlzcGF0Y2gub3BhYy5kLW5iLmRlL0RCPTQuMS9QUE4/UFBO PTExODg0NDkxMSIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ciPkRhdGVuc2F0 eiB6dSBHZW9yZ2UgSC4gVy4gQnVzaDwvYT4g4oCiIDxhIGhyZWY9Imh0dHA6Ly9kaXNwYXRjaC5v cGFjLmQtbmIuZGUvREI9NC4xL1NFVD00L1RUTD0xL1BSUz1QUCU3Ri9QUE4/UFBOPTExODg0NDkx MSIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ciPlBJQ0EtRGF0ZW5zYXR6PC9h PiDigKIgPGEgaHJlZj0iaHR0cDovL3Rvb2xzZXJ2ZXIub3JnL35hcHBlci9wZC9wZXJzb24vcG5k LzExODg0NDkxMSIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ciPkFwcGVyLVBl cnNvbmVuc3VjaGU8L2E+KTwvc21hbGw+PC9zcGFuPjwvbGk+CTxsaT48YSBocmVmPSJodHRwOi8v YmlvZ3VpZGUuY29uZ3Jlc3MuZ292L3NjcmlwdHMvYmlvZGlzcGxheS5wbD9pbmRleD1CMDAxMTY2 IiBjbGFzcz0iZXh0ZXJuYWwgdGV4dCIgcmVsPSJub2ZvbGxvdyI+R2VvcmdlIEguIFcuIEJ1c2g8 L2E+IGltIDxpPkJpb2dyYXBoaWNhbCBEaXJlY3Rvcnkgb2YgdGhlIFVuaXRlZCBTdGF0ZXMgQ29u Z3Jlc3M8L2k+PC9saT4JPGxpPjxhIGhyZWY9Imh0dHA6Ly9idXNobGlicmFyeS50YW11LmVkdS8i IGNsYXNzPSJleHRlcm5hbCB0ZXh0IiByZWw9Im5vZm9sbG93Ij5CdXNoIFByZXNpZGVudGlhbCBM aWJyYXJ5IGFuZCBNdXNldW08L2E+IChlbmdsaXNjaCk8L2xpPgk8bGk+PGEgaHJlZj0iaHR0cDov L3d3dy53aGl0ZWhvdXNlLmdvdi9oaXN0b3J5L3ByZXNpZGVudHMvZ2I0MS5odG1sIiBjbGFzcz0i ZXh0ZXJuYWwgdGV4dCIgcmVsPSJub2ZvbGxvdyI+V2hpdGUgSG91c2UgYmlvZ3JhcGh5PC9hPiAo ZW5nbGlzY2gpPC9saT4JPGxpPkdlb3JnZSBILiBXLiBCdXNoIGluIGRlciA8YSBocmVmPSJodHRw Oi8vd3d3LmltZGIuZGUvbmFtZS9ubTAxMjQxMzIvIiBjbGFzcz0iZXh0ZXJuYWwgdGV4dCIgcmVs PSJub2ZvbGxvdyI+ZGV1dHNjaGVuPC9hPiB1bmQgPGEgaHJlZj0iaHR0cDovL3d3dy5pbWRiLmNv bS9uYW1lL25tMDEyNDEzMi8iIGNsYXNzPSJleHRlcm5hbCB0ZXh0IiByZWw9Im5vZm9sbG93Ij5l bmdsaXNjaGVuPC9hPiBWZXJzaW9uIGRlciA8YSBocmVmPSIvd2lraS9JbnRlcm5ldF9Nb3ZpZV9E YXRhYmFzZSIgdGl0bGU9IkludGVybmV0IE1vdmllIERhdGFiYXNlIj5JbnRlcm5ldCBNb3ZpZSBE YXRhYmFzZTwvYT48L2xpPgk8bGk+PGEgaHJlZj0iaHR0cDovL3d3dy5taWxsZXJjZW50ZXIudmly Z2luaWEuZWR1L2luZGV4LnBocC9hY2FkZW1pYy9hbWVyaWNhbnByZXNpZGVudC9idXNoIiBjbGFz cz0iZXh0ZXJuYWwgdGV4dCIgcmVsPSJub2ZvbGxvdyI+RXNzYXlzIG9uIEJ1c2ggYW5kIEhpcyBB ZG1pbmlzdHJhdGlvbjwvYT4gKGVuZ2xpc2NoKTwvbGk+CTxsaT48YSBocmVmPSJodHRwOi8vbWls bGVyY2VudGVyLnZpcmdpbmlhLmVkdS9zY3JpcHBzL2RpZ2l0YWxhcmNoaXZlL3NwZWVjaERldGFp bC8zMyIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ciPkdlb3JnZSBILiBXLiBC dXNoIFNwZWVjaGVzPC9hPiAoZW5nbGlzY2gpPC9saT4JPC91bD4JPGRpdiBjbGFzcz0iQm94ZW5W ZXJzY2htZWx6ZW4iPgk8ZGl2IGNsYXNzPSJOYXZGcmFtZSI+CTxkaXYgY2xhc3M9Ik5hdlBpYyI+ PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPURhdGVpOlNlYWxfT2ZfVGhlX1ByZXNpZGVudF9P Zl9UaGVfVW5pdGVkX1N0YXRlc19PZl9BbWVyaWNhLnN2ZyZhbXA7ZmlsZXRpbWVzdGFtcD0yMDA3 MTEwNDA2MzU1OSIgY2xhc3M9ImltYWdlIiB0aXRsZT0iU2llZ2VsIGRlcyBQcsOkc2lkZW50ZW4g ZGVyIFZlcmVpbmlndGVuIFN0YWF0ZW4iPjxpbWcgYWx0PSJTaWVnZWwgZGVzIFByw6RzaWRlbnRl biBkZXIgVmVyZWluaWd0ZW4gU3RhYXRlbiIgc3JjPSJodHRwOi8vdXBsb2FkLndpa2ltZWRpYS5v cmcvd2lraXBlZGlhL2NvbW1vbnMvdGh1bWIvZi9mYS9TZWFsX09mX1RoZV9QcmVzaWRlbnRfT2Zf VGhlX1VuaXRlZF9TdGF0ZXNfT2ZfQW1lcmljYS5zdmcvOTBweC1TZWFsX09mX1RoZV9QcmVzaWRl bnRfT2ZfVGhlX1VuaXRlZF9TdGF0ZXNfT2ZfQW1lcmljYS5zdmcucG5nIiB3aWR0aD0iOTAiIGhl aWdodD0iOTAiIC8+PC9hPjwvZGl2Pgk8ZGl2IGNsYXNzPSJOYXZIZWFkIj48YSBocmVmPSIvd2lr aS9MaXN0ZV9kZXJfUHIlQzMlQTRzaWRlbnRlbl9kZXJfVmVyZWluaWd0ZW5fU3RhYXRlbiIgdGl0 bGU9Ikxpc3RlIGRlciBQcsOkc2lkZW50ZW4gZGVyIFZlcmVpbmlndGVuIFN0YWF0ZW4iPlByw6Rz aWRlbnRlbiBkZXIgVmVyZWluaWd0ZW4gU3RhYXRlbjwvYT48L2Rpdj4JPGRpdiBjbGFzcz0iTmF2 Q29udGVudCI+CTxwPjxhIGhyZWY9Ii93aWtpL0dlb3JnZV9XYXNoaW5ndG9uIiB0aXRsZT0iR2Vv cmdlIFdhc2hpbmd0b24iPkdlb3JnZSBXYXNoaW5ndG9uPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dp a2kvSm9obl9BZGFtcyIgdGl0bGU9IkpvaG4gQWRhbXMiPkpvaG4gQWRhbXM8L2E+JiMxNjA7fCA8 YSBocmVmPSIvd2lraS9UaG9tYXNfSmVmZmVyc29uIiB0aXRsZT0iVGhvbWFzIEplZmZlcnNvbiI+ VGhvbWFzIEplZmZlcnNvbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0phbWVzX01hZGlzb24i IHRpdGxlPSJKYW1lcyBNYWRpc29uIj5KYW1lcyBNYWRpc29uPC9hPiYjMTYwO3wgPGEgaHJlZj0i L3dpa2kvSmFtZXNfTW9ucm9lIiB0aXRsZT0iSmFtZXMgTW9ucm9lIj5KYW1lcyBNb25yb2U8L2E+ JiMxNjA7fCA8YSBocmVmPSIvd2lraS9Kb2huX1F1aW5jeV9BZGFtcyIgdGl0bGU9IkpvaG4gUXVp bmN5IEFkYW1zIj5Kb2huIFF1aW5jeSBBZGFtczwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0Fu ZHJld19KYWNrc29uIiB0aXRsZT0iQW5kcmV3IEphY2tzb24iPkFuZHJldyBKYWNrc29uPC9hPiYj MTYwO3wgPGEgaHJlZj0iL3dpa2kvTWFydGluX1Zhbl9CdXJlbiIgdGl0bGU9Ik1hcnRpbiBWYW4g QnVyZW4iPk1hcnRpbiBWYW4gQnVyZW48L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9XaWxsaWFt X0guX0hhcnJpc29uIiB0aXRsZT0iV2lsbGlhbSBILiBIYXJyaXNvbiI+V2lsbGlhbSBILiBIYXJy aXNvbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0pvaG5fVHlsZXIiIHRpdGxlPSJKb2huIFR5 bGVyIj5Kb2huIFR5bGVyPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSmFtZXNfSy5fUG9sayIg dGl0bGU9IkphbWVzIEsuIFBvbGsiPkphbWVzIEsuIFBvbGs8L2E+JiMxNjA7fCA8YSBocmVmPSIv d2lraS9aYWNoYXJ5X1RheWxvciIgdGl0bGU9IlphY2hhcnkgVGF5bG9yIj5aYWNoYXJ5IFRheWxv cjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL01pbGxhcmRfRmlsbG1vcmUiIHRpdGxlPSJNaWxs YXJkIEZpbGxtb3JlIj5NaWxsYXJkIEZpbGxtb3JlPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kv RnJhbmtsaW5fUGllcmNlIiB0aXRsZT0iRnJhbmtsaW4gUGllcmNlIj5GcmFua2xpbiBQaWVyY2U8 L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9KYW1lc19CdWNoYW5hbiIgdGl0bGU9IkphbWVzIEJ1 Y2hhbmFuIj5KYW1lcyBCdWNoYW5hbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0FicmFoYW1f TGluY29sbiIgdGl0bGU9IkFicmFoYW0gTGluY29sbiI+QWJyYWhhbSBMaW5jb2xuPC9hPiYjMTYw O3wgPGEgaHJlZj0iL3dpa2kvQW5kcmV3X0pvaG5zb24iIHRpdGxlPSJBbmRyZXcgSm9obnNvbiI+ QW5kcmV3IEpvaG5zb248L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9VbHlzc2VzX1MuX0dyYW50 IiB0aXRsZT0iVWx5c3NlcyBTLiBHcmFudCI+VWx5c3NlcyBTLiBHcmFudDwvYT4mIzE2MDt8IDxh IGhyZWY9Ii93aWtpL1J1dGhlcmZvcmRfQi5fSGF5ZXMiIHRpdGxlPSJSdXRoZXJmb3JkIEIuIEhh eWVzIj5SdXRoZXJmb3JkIEIuIEhheWVzPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSmFtZXNf QS5fR2FyZmllbGQiIHRpdGxlPSJKYW1lcyBBLiBHYXJmaWVsZCI+SmFtZXMgQS4gR2FyZmllbGQ8 L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9DaGVzdGVyX0EuX0FydGh1ciIgdGl0bGU9IkNoZXN0 ZXIgQS4gQXJ0aHVyIj5DaGVzdGVyIEEuIEFydGh1cjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtp L0dyb3Zlcl9DbGV2ZWxhbmQiIHRpdGxlPSJHcm92ZXIgQ2xldmVsYW5kIj5Hcm92ZXIgQ2xldmVs YW5kPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvQmVuamFtaW5fSGFycmlzb24iIHRpdGxlPSJC ZW5qYW1pbiBIYXJyaXNvbiI+QmVuamFtaW4gSGFycmlzb248L2E+JiMxNjA7fCA8YSBocmVmPSIv d2lraS9Hcm92ZXJfQ2xldmVsYW5kIiB0aXRsZT0iR3JvdmVyIENsZXZlbGFuZCI+R3JvdmVyIENs ZXZlbGFuZDwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1dpbGxpYW1fTWNLaW5sZXkiIHRpdGxl PSJXaWxsaWFtIE1jS2lubGV5Ij5XaWxsaWFtIE1jS2lubGV5PC9hPiYjMTYwO3wgPGEgaHJlZj0i L3dpa2kvVGhlb2RvcmVfUm9vc2V2ZWx0IiB0aXRsZT0iVGhlb2RvcmUgUm9vc2V2ZWx0Ij5UaGVv ZG9yZSBSb29zZXZlbHQ8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9XaWxsaWFtX0hvd2FyZF9U YWZ0IiB0aXRsZT0iV2lsbGlhbSBIb3dhcmQgVGFmdCI+V2lsbGlhbSBILiBUYWZ0PC9hPiYjMTYw O3wgPGEgaHJlZj0iL3dpa2kvV29vZHJvd19XaWxzb24iIHRpdGxlPSJXb29kcm93IFdpbHNvbiI+ V29vZHJvdyBXaWxzb248L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9XYXJyZW5fRy5fSGFyZGlu ZyIgdGl0bGU9IldhcnJlbiBHLiBIYXJkaW5nIj5XYXJyZW4gRy4gSGFyZGluZzwvYT4mIzE2MDt8 IDxhIGhyZWY9Ii93aWtpL0NhbHZpbl9Db29saWRnZSIgdGl0bGU9IkNhbHZpbiBDb29saWRnZSI+ Q2FsdmluIENvb2xpZGdlPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSGVyYmVydF9DLl9Ib292 ZXIiIHRpdGxlPSJIZXJiZXJ0IEMuIEhvb3ZlciI+SGVyYmVydCBDLiBIb292ZXI8L2E+JiMxNjA7 fCA8YSBocmVmPSIvd2lraS9GcmFua2xpbl9ELl9Sb29zZXZlbHQiIHRpdGxlPSJGcmFua2xpbiBE LiBSb29zZXZlbHQiPkZyYW5rbGluIEQuIFJvb3NldmVsdDwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93 aWtpL0hhcnJ5X1MuX1RydW1hbiIgdGl0bGU9IkhhcnJ5IFMuIFRydW1hbiI+SGFycnkgUy4gVHJ1 bWFuPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvRHdpZ2h0X0QuX0Vpc2VuaG93ZXIiIHRpdGxl PSJEd2lnaHQgRC4gRWlzZW5ob3dlciI+RHdpZ2h0IEQuIEVpc2VuaG93ZXI8L2E+JiMxNjA7fCA8 YSBocmVmPSIvd2lraS9Kb2huX0YuX0tlbm5lZHkiIHRpdGxlPSJKb2huIEYuIEtlbm5lZHkiPkpv aG4gRi4gS2VubmVkeTwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0x5bmRvbl9CLl9Kb2huc29u IiB0aXRsZT0iTHluZG9uIEIuIEpvaG5zb24iPkx5bmRvbiBCLiBKb2huc29uPC9hPiYjMTYwO3wg PGEgaHJlZj0iL3dpa2kvUmljaGFyZF9OaXhvbiIgdGl0bGU9IlJpY2hhcmQgTml4b24iPlJpY2hh cmQgTml4b248L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9HZXJhbGRfRm9yZCIgdGl0bGU9Ikdl cmFsZCBGb3JkIj5HZXJhbGQgRm9yZDwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0ppbW15X0Nh cnRlciIgdGl0bGU9IkppbW15IENhcnRlciI+SmltbXkgQ2FydGVyPC9hPiYjMTYwO3wgPGEgaHJl Zj0iL3dpa2kvUm9uYWxkX1JlYWdhbiIgdGl0bGU9IlJvbmFsZCBSZWFnYW4iPlJvbmFsZCBSZWFn YW48L2E+JiMxNjA7fCA8c3Ryb25nIGNsYXNzPSJzZWxmbGluayI+R2VvcmdlIEguIFcuIEJ1c2g8 L3N0cm9uZz4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0JpbGxfQ2xpbnRvbiIgdGl0bGU9IkJpbGwg Q2xpbnRvbiI+QmlsbCBDbGludG9uPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvR2VvcmdlX1cu X0J1c2giIHRpdGxlPSJHZW9yZ2UgVy4gQnVzaCI+R2VvcmdlIFcuIEJ1c2g8L2E+JiMxNjA7fCA8 YSBocmVmPSIvd2lraS9CYXJhY2tfT2JhbWEiIHRpdGxlPSJCYXJhY2sgT2JhbWEiPkJhcmFjayBP YmFtYTwvYT48L3A+CTwvZGl2Pgk8ZGl2IGNsYXNzPSJ2aXN1YWxDbGVhciI+PC9kaXY+CTwvZGl2 Pgk8ZGl2IGNsYXNzPSJOYXZGcmFtZSI+CTxkaXYgY2xhc3M9Ik5hdlBpYyI+PGEgaHJlZj0iL3cv aW5kZXgucGhwP3RpdGxlPURhdGVpOkNJQS5zdmcmYW1wO2ZpbGV0aW1lc3RhbXA9MjAwNzExMTAw NjU3MDgiIGNsYXNzPSJpbWFnZSIgdGl0bGU9IkNJQSI+PGltZyBhbHQ9IkNJQSIgc3JjPSJodHRw Oi8vdXBsb2FkLndpa2ltZWRpYS5vcmcvd2lraXBlZGlhL2NvbW1vbnMvdGh1bWIvMi8yMy9DSUEu c3ZnLzgwcHgtQ0lBLnN2Zy5wbmciIHdpZHRoPSI4MCIgaGVpZ2h0PSI4MCIgLz48L2E+PC9kaXY+ CTxkaXYgY2xhc3M9Ik5hdkhlYWQiPkRpcmVrdG9yZW4gZGVyIDxhIGhyZWY9Ii93aWtpL0NlbnRy YWxfSW50ZWxsaWdlbmNlX0FnZW5jeSIgdGl0bGU9IkNlbnRyYWwgSW50ZWxsaWdlbmNlIEFnZW5j eSI+Q2VudHJhbCBJbnRlbGxpZ2VuY2UgQWdlbmN5PC9hPiAoQ0lBKTwvZGl2Pgk8ZGl2IGNsYXNz PSJOYXZDb250ZW50Ij4JPHA+PGEgaHJlZj0iL3dpa2kvUm9zY29lX0hlbnJ5X0hpbGxlbmtvZXR0 ZXIiIHRpdGxlPSJSb3Njb2UgSGVucnkgSGlsbGVua29ldHRlciI+Um9zY29lIEhlbnJ5IEhpbGxl bmtvZXR0ZXI8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9XYWx0ZXJfQmVkZWxsX1NtaXRoIiB0 aXRsZT0iV2FsdGVyIEJlZGVsbCBTbWl0aCI+V2FsdGVyIEJlZGVsbCBTbWl0aDwvYT4mIzE2MDt8 IDxhIGhyZWY9Ii93aWtpL0FsbGVuX1dlbHNoX0R1bGxlcyIgdGl0bGU9IkFsbGVuIFdlbHNoIER1 bGxlcyI+QWxsZW4gV2Vsc2ggRHVsbGVzPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSm9obl9B bGV4X01jQ29uZSIgdGl0bGU9IkpvaG4gQWxleCBNY0NvbmUiPkpvaG4gQWxleCBNY0NvbmU8L2E+ JiMxNjA7fCA8YSBocmVmPSIvd2lraS9XaWxsaWFtX1JhYm9ybiIgdGl0bGU9IldpbGxpYW0gUmFi b3JuIj5XaWxsaWFtIFJhYm9ybjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1JpY2hhcmRfSGVs bXMiIHRpdGxlPSJSaWNoYXJkIEhlbG1zIj5SaWNoYXJkIEhlbG1zPC9hPiYjMTYwO3wgPGEgaHJl Zj0iL3dpa2kvSmFtZXNfUi5fU2NobGVzaW5nZXIiIHRpdGxlPSJKYW1lcyBSLiBTY2hsZXNpbmdl ciI+SmFtZXMgUi4gU2NobGVzaW5nZXI8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9XaWxsaWFt X0VnYW5fQ29sYnkiIHRpdGxlPSJXaWxsaWFtIEVnYW4gQ29sYnkiPldpbGxpYW0gRWdhbiBDb2xi eTwvYT4mIzE2MDt8IDxzdHJvbmcgY2xhc3M9InNlbGZsaW5rIj5HZW9yZ2UgSC4gVy4gQnVzaDwv c3Ryb25nPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvU3RhbnNmaWVsZF9UdXJuZXIiIHRpdGxlPSJT dGFuc2ZpZWxkIFR1cm5lciI+U3RhbnNmaWVsZCBUdXJuZXI8L2E+JiMxNjA7fCA8YSBocmVmPSIv d2lraS9XaWxsaWFtX0pvc2VwaF9DYXNleSIgdGl0bGU9IldpbGxpYW0gSm9zZXBoIENhc2V5Ij5X aWxsaWFtIEpvc2VwaCBDYXNleTwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1dpbGxpYW1fSGVk Z2NvY2tfV2Vic3RlciIgdGl0bGU9IldpbGxpYW0gSGVkZ2NvY2sgV2Vic3RlciI+V2lsbGlhbSBI ZWRnY29jayBXZWJzdGVyPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvUm9iZXJ0X0dhdGVzIiB0 aXRsZT0iUm9iZXJ0IEdhdGVzIj5Sb2JlcnQgR2F0ZXM8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lr aS9KYW1lc19Xb29sc2V5IiB0aXRsZT0iSmFtZXMgV29vbHNleSI+SmFtZXMgV29vbHNleTwvYT4m IzE2MDt8IDxhIGhyZWY9Ii93aWtpL0pvaG5fRGV1dGNoIiB0aXRsZT0iSm9obiBEZXV0Y2giPkpv aG4gRGV1dGNoPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvR2VvcmdlX1RlbmV0IiB0aXRsZT0i R2VvcmdlIFRlbmV0Ij5HZW9yZ2UgVGVuZXQ8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9Kb2hu X01jTGF1Z2hsaW5fKFBvbGl0aWtlcikiIHRpdGxlPSJKb2huIE1jTGF1Z2hsaW4gKFBvbGl0aWtl cikiPkpvaG4gTWNMYXVnaGxpbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1BvcnRlcl9Hb3Nz IiB0aXRsZT0iUG9ydGVyIEdvc3MiPlBvcnRlciBHb3NzPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dp a2kvTWljaGFlbF9WLl9IYXlkZW4iIHRpdGxlPSJNaWNoYWVsIFYuIEhheWRlbiI+TWljaGFlbCBW LiBIYXlkZW48L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9MZW9uX1BhbmV0dGEiIHRpdGxlPSJM ZW9uIFBhbmV0dGEiPkxlb24gUGFuZXR0YTwvYT48L3A+CTwvZGl2Pgk8ZGl2IGNsYXNzPSJ2aXN1 YWxDbGVhciI+PC9kaXY+CTwvZGl2Pgk8ZGl2IGNsYXNzPSJOYXZGcmFtZSI+CTxkaXYgY2xhc3M9 Ik5hdlBpYyI+PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPURhdGVpOlVTX1ZpY2VfUHJlc2lk ZW50X1NlYWwuc3ZnJmFtcDtmaWxldGltZXN0YW1wPTIwMDkxMjE1MTgwODQxIiBjbGFzcz0iaW1h Z2UiIHRpdGxlPSJTaWVnZWwgZGVzIFZpemVwcsOkc2lkZW50ZW4gZGVyIFZlcmVpbmlndGVuIFN0 YWF0ZW4iPjxpbWcgYWx0PSJTaWVnZWwgZGVzIFZpemVwcsOkc2lkZW50ZW4gZGVyIFZlcmVpbmln dGVuIFN0YWF0ZW4iIHNyYz0iaHR0cDovL3VwbG9hZC53aWtpbWVkaWEub3JnL3dpa2lwZWRpYS9j b21tb25zL3RodW1iLzkvOTAvVVNfVmljZV9QcmVzaWRlbnRfU2VhbC5zdmcvODBweC1VU19WaWNl X1ByZXNpZGVudF9TZWFsLnN2Zy5wbmciIHdpZHRoPSI4MCIgaGVpZ2h0PSI4MCIgLz48L2E+PC9k aXY+CTxkaXYgY2xhc3M9Ik5hdkhlYWQiPjxhIGhyZWY9Ii93aWtpL0xpc3RlX2Rlcl9WaXplcHIl QzMlQTRzaWRlbnRlbl9kZXJfVmVyZWluaWd0ZW5fU3RhYXRlbiIgdGl0bGU9Ikxpc3RlIGRlciBW aXplcHLDpHNpZGVudGVuIGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuIj5WaXplcHLDpHNpZGVudGVu IGRlciBWZXJlaW5pZ3RlbiBTdGFhdGVuPC9hPjwvZGl2Pgk8ZGl2IGNsYXNzPSJOYXZDb250ZW50 Ij4JPHA+PGEgaHJlZj0iL3dpa2kvSm9obl9BZGFtcyIgdGl0bGU9IkpvaG4gQWRhbXMiPkFkYW1z PC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvVGhvbWFzX0plZmZlcnNvbiIgdGl0bGU9IlRob21h cyBKZWZmZXJzb24iPkplZmZlcnNvbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0Fhcm9uX0J1 cnIiIHRpdGxlPSJBYXJvbiBCdXJyIj5CdXJyPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvR2Vv cmdlX0NsaW50b25fKFZpemVwciVDMyVBNHNpZGVudCkiIHRpdGxlPSJHZW9yZ2UgQ2xpbnRvbiAo Vml6ZXByw6RzaWRlbnQpIj5DbGludG9uPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvRWxicmlk Z2VfR2VycnkiIHRpdGxlPSJFbGJyaWRnZSBHZXJyeSI+R2Vycnk8L2E+JiMxNjA7fCA8YSBocmVm PSIvd2lraS9EYW5pZWxfRC5fVG9tcGtpbnMiIHRpdGxlPSJEYW5pZWwgRC4gVG9tcGtpbnMiPlRv bXBraW5zPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSm9obl9DLl9DYWxob3VuIiB0aXRsZT0i Sm9obiBDLiBDYWxob3VuIj5DYWxob3VuPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvTWFydGlu X1Zhbl9CdXJlbiIgdGl0bGU9Ik1hcnRpbiBWYW4gQnVyZW4iPlZhbiBCdXJlbjwvYT4mIzE2MDt8 IDxhIGhyZWY9Ii93aWtpL1JpY2hhcmRfTS5fSm9obnNvbiIgdGl0bGU9IlJpY2hhcmQgTS4gSm9o bnNvbiI+Ui4mIzE2MDtKb2huc29uPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSm9obl9UeWxl ciIgdGl0bGU9IkpvaG4gVHlsZXIiPlR5bGVyPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvR2Vv cmdlX01pZmZsaW5fRGFsbGFzIiB0aXRsZT0iR2VvcmdlIE1pZmZsaW4gRGFsbGFzIj5EYWxsYXM8 L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9NaWxsYXJkX0ZpbGxtb3JlIiB0aXRsZT0iTWlsbGFy ZCBGaWxsbW9yZSI+RmlsbG1vcmU8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9XaWxsaWFtX1Iu X0tpbmciIHRpdGxlPSJXaWxsaWFtIFIuIEtpbmciPktpbmc8L2E+JiMxNjA7fCA8YSBocmVmPSIv d2lraS9Kb2huX0NhYmVsbF9CcmVja2lucmlkZ2UiIHRpdGxlPSJKb2huIENhYmVsbCBCcmVja2lu cmlkZ2UiPkJyZWNraW5yaWRnZTwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0hhbm5pYmFsX0hh bWxpbiIgdGl0bGU9Ikhhbm5pYmFsIEhhbWxpbiI+SGFtbGluPC9hPiYjMTYwO3wgPGEgaHJlZj0i L3dpa2kvQW5kcmV3X0pvaG5zb24iIHRpdGxlPSJBbmRyZXcgSm9obnNvbiI+QS4mIzE2MDtKb2hu c29uPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvU2NodXlsZXJfQ29sZmF4IiB0aXRsZT0iU2No dXlsZXIgQ29sZmF4Ij5Db2xmYXg8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9IZW5yeV9XaWxz b25fKFBvbGl0aWtlcikiIHRpdGxlPSJIZW5yeSBXaWxzb24gKFBvbGl0aWtlcikiPldpbHNvbjwv YT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1dpbGxpYW1fQWxtb25fV2hlZWxlciIgdGl0bGU9Ildp bGxpYW0gQWxtb24gV2hlZWxlciI+V2hlZWxlcjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0No ZXN0ZXJfQS5fQXJ0aHVyIiB0aXRsZT0iQ2hlc3RlciBBLiBBcnRodXIiPkFydGh1cjwvYT4mIzE2 MDt8IDxhIGhyZWY9Ii93aWtpL1Rob21hc19BLl9IZW5kcmlja3MiIHRpdGxlPSJUaG9tYXMgQS4g SGVuZHJpY2tzIj5IZW5kcmlja3M8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9MZXZpX1AuX01v cnRvbiIgdGl0bGU9IkxldmkgUC4gTW9ydG9uIj5Nb3J0b248L2E+JiMxNjA7fCA8YSBocmVmPSIv d2lraS9BZGxhaV9Fd2luZ19TdGV2ZW5zb25fKDE4MzUlRTIlODAlOTMxOTE0KSIgdGl0bGU9IkFk bGFpIEV3aW5nIFN0ZXZlbnNvbiAoMTgzNeKAkzE5MTQpIj5TdGV2ZW5zb248L2E+JiMxNjA7fCA8 YSBocmVmPSIvd2lraS9HYXJyZXRfSG9iYXJ0IiB0aXRsZT0iR2FycmV0IEhvYmFydCI+SG9iYXJ0 PC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvVGhlb2RvcmVfUm9vc2V2ZWx0IiB0aXRsZT0iVGhl b2RvcmUgUm9vc2V2ZWx0Ij5Sb29zZXZlbHQ8L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9DaGFy bGVzX1cuX0ZhaXJiYW5rcyIgdGl0bGU9IkNoYXJsZXMgVy4gRmFpcmJhbmtzIj5GYWlyYmFua3M8 L2E+JiMxNjA7fCA8YSBocmVmPSIvd2lraS9KYW1lc19TLl9TaGVybWFuIiB0aXRsZT0iSmFtZXMg Uy4gU2hlcm1hbiI+U2hlcm1hbjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL1Rob21hc19SaWxl eV9NYXJzaGFsbCIgdGl0bGU9IlRob21hcyBSaWxleSBNYXJzaGFsbCI+TWFyc2hhbGw8L2E+JiMx NjA7fCA8YSBocmVmPSIvd2lraS9DYWx2aW5fQ29vbGlkZ2UiIHRpdGxlPSJDYWx2aW4gQ29vbGlk Z2UiPkNvb2xpZGdlPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvQ2hhcmxlc19HYXRlc19EYXdl cyIgdGl0bGU9IkNoYXJsZXMgR2F0ZXMgRGF3ZXMiPkRhd2VzPC9hPiYjMTYwO3wgPGEgaHJlZj0i L3dpa2kvQ2hhcmxlc19DdXJ0aXMiIHRpdGxlPSJDaGFybGVzIEN1cnRpcyI+Q3VydGlzPC9hPiYj MTYwO3wgPGEgaHJlZj0iL3dpa2kvSm9obl9OYW5jZV9HYXJuZXIiIHRpdGxlPSJKb2huIE5hbmNl IEdhcm5lciI+R2FybmVyPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSGVucnlfQWdhcmRfV2Fs bGFjZSIgdGl0bGU9IkhlbnJ5IEFnYXJkIFdhbGxhY2UiPldhbGxhY2U8L2E+JiMxNjA7fCA8YSBo cmVmPSIvd2lraS9IYXJyeV9TLl9UcnVtYW4iIHRpdGxlPSJIYXJyeSBTLiBUcnVtYW4iPlRydW1h bjwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0FsYmVuX1cuX0JhcmtsZXkiIHRpdGxlPSJBbGJl biBXLiBCYXJrbGV5Ij5CYXJrbGV5PC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvUmljaGFyZF9O aXhvbiIgdGl0bGU9IlJpY2hhcmQgTml4b24iPk5peG9uPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dp a2kvTHluZG9uX0IuX0pvaG5zb24iIHRpdGxlPSJMeW5kb24gQi4gSm9obnNvbiI+TC4mIzE2MDtK b2huc29uPC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvSHViZXJ0X0guX0h1bXBocmV5IiB0aXRs ZT0iSHViZXJ0IEguIEh1bXBocmV5Ij5IdW1waHJleTwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtp L1NwaXJvX1RoZW9kb3JlX0FnbmV3IiB0aXRsZT0iU3Bpcm8gVGhlb2RvcmUgQWduZXciPkFnbmV3 PC9hPiYjMTYwO3wgPGEgaHJlZj0iL3dpa2kvR2VyYWxkX0ZvcmQiIHRpdGxlPSJHZXJhbGQgRm9y ZCI+Rm9yZDwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL05lbHNvbl9BLl9Sb2NrZWZlbGxlciIg dGl0bGU9Ik5lbHNvbiBBLiBSb2NrZWZlbGxlciI+Um9ja2VmZWxsZXI8L2E+JiMxNjA7fCA8YSBo cmVmPSIvd2lraS9XYWx0ZXJfTW9uZGFsZSIgdGl0bGU9IldhbHRlciBNb25kYWxlIj5Nb25kYWxl PC9hPiYjMTYwO3wgPHN0cm9uZyBjbGFzcz0ic2VsZmxpbmsiPkJ1c2g8L3N0cm9uZz4mIzE2MDt8 IDxhIGhyZWY9Ii93aWtpL0Rhbl9RdWF5bGUiIHRpdGxlPSJEYW4gUXVheWxlIj5RdWF5bGU8L2E+ JiMxNjA7fCA8YSBocmVmPSIvd2lraS9BbF9Hb3JlIiB0aXRsZT0iQWwgR29yZSI+R29yZTwvYT4m IzE2MDt8IDxhIGhyZWY9Ii93aWtpL0RpY2tfQ2hlbmV5IiB0aXRsZT0iRGljayBDaGVuZXkiPkNo ZW5leTwvYT4mIzE2MDt8IDxhIGhyZWY9Ii93aWtpL0pvZV9CaWRlbiIgdGl0bGU9IkpvZSBCaWRl biI+QmlkZW48L2E+PC9wPgk8L2Rpdj4JPGRpdiBjbGFzcz0idmlzdWFsQ2xlYXIiPjwvZGl2Pgk8 L2Rpdj4JPGRpdiBjbGFzcz0iTmF2RnJhbWUiPgk8ZGl2IGNsYXNzPSJOYXZIZWFkIj48YSBocmVm PSIvd2lraS9Cb2JfSm9uZXNfQXdhcmQiIHRpdGxlPSJCb2IgSm9uZXMgQXdhcmQiPkJvYi1Kb25l cy1Bd2FyZDwvYT4tUHJlaXN0csOkZ2VyPC9kaXY+CTxkaXYgY2xhc3M9Ik5hdkNvbnRlbnQiPgk8 cD4xOTU1OiYjMTYwOzxhIGhyZWY9Ii93aWtpL0ZyYW5jaXNfT3VpbWV0IiB0aXRsZT0iRnJhbmNp cyBPdWltZXQiPkZyYW5jaXMgT3VpbWV0PC9hPiYjMTYwO3wgPHNwYW4gc3R5bGU9IndoaXRlLXNw YWNlOm5vd3JhcDsiPjE5NTY6JiMxNjA7PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPVdpbGxp YW1fQy5fQ2FtcGJlbGwmYW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEiIGNsYXNzPSJuZXci IHRpdGxlPSJXaWxsaWFtIEMuIENhbXBiZWxsIChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5XaWxs aWFtIEMuIENhbXBiZWxsPC9hPiYjMTYwO3w8L3NwYW4+IDE5NTc6JiMxNjA7PGEgaHJlZj0iL3dp a2kvTWlsZHJlZF9EaWRyaWtzb25fWmFoYXJpYXMiIHRpdGxlPSJNaWxkcmVkIERpZHJpa3NvbiBa YWhhcmlhcyI+QmFiZSBaYWhhcmlhczwvYT4mIzE2MDt8IDE5NTg6JiMxNjA7PGEgaHJlZj0iL3dp a2kvTWFyZ2FyZXRfQ3VydGlzIiB0aXRsZT0iTWFyZ2FyZXQgQ3VydGlzIj5NYXJnYXJldCBDdXJ0 aXM8L2E+JiMxNjA7fCA8c3BhbiBzdHlsZT0id2hpdGUtc3BhY2U6bm93cmFwOyI+MTk1OTomIzE2 MDs8YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9RmluZGxheV9TLl9Eb3VnbGFzJmFtcDthY3Rp b249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iRmluZGxheSBTLiBEb3Vn bGFzIChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5GaW5kbGF5IFMuIERvdWdsYXM8L2E+JiMxNjA7 fDwvc3Bhbj4gMTk2MDomIzE2MDs8YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9Q2hpY2tfRXZh bnMmYW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEiIGNsYXNzPSJuZXciIHRpdGxlPSJDaGlj ayBFdmFucyAoU2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+Q2hpY2sgRXZhbnM8L2E+JiMxNjA7fCAx OTYxOiYjMTYwOzxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1Kb2VfQ2FyciZhbXA7YWN0aW9u PWVkaXQmYW1wO3JlZGxpbms9MSIgY2xhc3M9Im5ldyIgdGl0bGU9IkpvZSBDYXJyIChTZWl0ZSBu aWNodCB2b3JoYW5kZW4pIj5Kb2UgQ2FycjwvYT4mIzE2MDt8IDE5NjI6JiMxNjA7PGEgaHJlZj0i L3dpa2kvSG9ydG9uX1NtaXRoIiB0aXRsZT0iSG9ydG9uIFNtaXRoIj5Ib3J0b24gU21pdGg8L2E+ JiMxNjA7fCAxOTYzOiYjMTYwOzxhIGhyZWY9Ii93aWtpL1BhdHR5X0JlcmciIHRpdGxlPSJQYXR0 eSBCZXJnIj5QYXR0eSBCZXJnPC9hPiYjMTYwO3wgMTk2NDomIzE2MDs8YSBocmVmPSIvdy9pbmRl eC5waHA/dGl0bGU9Q2hhcmxlc19Db2UmYW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEiIGNs YXNzPSJuZXciIHRpdGxlPSJDaGFybGVzIENvZSAoU2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+Q2hh cmxlcyBDb2U8L2E+JiMxNjA7fCAxOTY1OiYjMTYwOzxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRs ZT1HbGVubmFfQ29sbGV0dF9WYXJlJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFz cz0ibmV3IiB0aXRsZT0iR2xlbm5hIENvbGxldHQgVmFyZSAoU2VpdGUgbmljaHQgdm9yaGFuZGVu KSI+R2xlbm5hIENvbGxldHQgVmFyZTwvYT4mIzE2MDt8IDE5NjY6JiMxNjA7PGEgaHJlZj0iL3dp a2kvR2FyeV9QbGF5ZXIiIHRpdGxlPSJHYXJ5IFBsYXllciI+R2FyeSBQbGF5ZXI8L2E+JiMxNjA7 fCAxOTY3OiYjMTYwOzxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1SaWNoYXJkX1R1ZnRzJmFt cDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iUmljaGFyZCBU dWZ0cyAoU2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+UmljaGFyZCBUdWZ0czwvYT4mIzE2MDt8IDE5 Njg6JiMxNjA7PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPUJvYl9EaWNrc29uJmFtcDthY3Rp b249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iQm9iIERpY2tzb24gKFNl aXRlIG5pY2h0IHZvcmhhbmRlbikiPkJvYiBEaWNrc29uPC9hPiYjMTYwO3wgPHNwYW4gc3R5bGU9 IndoaXRlLXNwYWNlOm5vd3JhcDsiPjE5Njk6JiMxNjA7PGEgaHJlZj0iL3cvaW5kZXgucGhwP3Rp dGxlPUdlcmFsZF9ILl9NaWNrbGVtJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFz cz0ibmV3IiB0aXRsZT0iR2VyYWxkIEguIE1pY2tsZW0gKFNlaXRlIG5pY2h0IHZvcmhhbmRlbiki PkdlcmFsZCBILiBNaWNrbGVtPC9hPiYjMTYwO3w8L3NwYW4+IDE5NzA6JiMxNjA7PGEgaHJlZj0i L3dpa2kvUm9iZXJ0b19EZVZpY2Vuem8iIHRpdGxlPSJSb2JlcnRvIERlVmljZW56byI+Um9iZXJ0 byBEZVZpY2Vuem88L2E+JiMxNjA7fCAxOTcxOiYjMTYwOzxhIGhyZWY9Ii93aWtpL0Fybm9sZF9Q YWxtZXIiIHRpdGxlPSJBcm5vbGQgUGFsbWVyIj5Bcm5vbGQgUGFsbWVyPC9hPiYjMTYwO3wgMTk3 MjomIzE2MDs8YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9TWljaGFlbF9Cb25hbGxhY2smYW1w O2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEiIGNsYXNzPSJuZXciIHRpdGxlPSJNaWNoYWVsIEJv bmFsbGFjayAoU2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+TWljaGFlbCBCb25hbGxhY2s8L2E+JiMx NjA7fCAxOTczOiYjMTYwOzxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1HZW5lX0xpdHRsZXIm YW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEiIGNsYXNzPSJuZXciIHRpdGxlPSJHZW5lIExp dHRsZXIgKFNlaXRlIG5pY2h0IHZvcmhhbmRlbikiPkdlbmUgTGl0dGxlcjwvYT4mIzE2MDt8IDE5 NzQ6JiMxNjA7PGEgaHJlZj0iL3dpa2kvQnlyb25fTmVsc29uIiB0aXRsZT0iQnlyb24gTmVsc29u Ij5CeXJvbiBOZWxzb248L2E+JiMxNjA7fCAxOTc1OiYjMTYwOzxhIGhyZWY9Ii93aWtpL0phY2tf Tmlja2xhdXMiIHRpdGxlPSJKYWNrIE5pY2tsYXVzIj5KYWNrIE5pY2tsYXVzPC9hPiYjMTYwO3wg MTk3NjomIzE2MDs8YSBocmVmPSIvd2lraS9CZW5fSG9nYW4iIHRpdGxlPSJCZW4gSG9nYW4iPkJl biBIb2dhbjwvYT4mIzE2MDt8IDE5Nzc6JiMxNjA7PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxl PUpvc2VwaF9EZXkmYW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEiIGNsYXNzPSJuZXciIHRp dGxlPSJKb3NlcGggRGV5IChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5Kb3NlcGggRGV5PC9hPiYj MTYwO3wgMTk3ODomIzE2MDs8YSBocmVmPSIvd2lraS9CaW5nX0Nyb3NieSIgdGl0bGU9IkJpbmcg Q3Jvc2J5Ij5CaW5nIENyb3NieTwvYT4gdW5kIDxhIGhyZWY9Ii93aWtpL0JvYl9Ib3BlIiB0aXRs ZT0iQm9iIEhvcGUiPkJvYiBIb3BlPC9hPiYjMTYwO3wgMTk3OTomIzE2MDs8YSBocmVmPSIvd2lr aS9Ub21fS2l0ZSIgdGl0bGU9IlRvbSBLaXRlIj5Ub20gS2l0ZTwvYT4mIzE2MDt8IDE5ODA6JiMx NjA7PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPUNoYXJsZXNfWWF0ZXMmYW1wO2FjdGlvbj1l ZGl0JmFtcDtyZWRsaW5rPTEiIGNsYXNzPSJuZXciIHRpdGxlPSJDaGFybGVzIFlhdGVzIChTZWl0 ZSBuaWNodCB2b3JoYW5kZW4pIj5DaGFybGVzIFlhdGVzPC9hPiYjMTYwO3wgMTk4MTomIzE2MDs8 YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9Sm9Bbm5lX0Nhcm5lciZhbXA7YWN0aW9uPWVkaXQm YW1wO3JlZGxpbms9MSIgY2xhc3M9Im5ldyIgdGl0bGU9IkpvQW5uZSBDYXJuZXIgKFNlaXRlIG5p Y2h0IHZvcmhhbmRlbikiPkpvQW5uZSBDYXJuZXI8L2E+JiMxNjA7fCAxOTgyOiYjMTYwOzxhIGhy ZWY9Ii93L2luZGV4LnBocD90aXRsZT1CaWxseV9Kb2VfUGF0dG9uJmFtcDthY3Rpb249ZWRpdCZh bXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iQmlsbHkgSm9lIFBhdHRvbiAoU2VpdGUg bmljaHQgdm9yaGFuZGVuKSI+QmlsbHkgSm9lIFBhdHRvbjwvYT4mIzE2MDt8IDE5ODM6JiMxNjA7 PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPU1hdXJlZW5fUnV0dGxlX0dhcnJldHQmYW1wO2Fj dGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEiIGNsYXNzPSJuZXciIHRpdGxlPSJNYXVyZWVuIFJ1dHRs ZSBHYXJyZXR0IChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5NYXVyZWVuIFJ1dHRsZSBHYXJyZXR0 PC9hPiYjMTYwO3wgMTk4NDomIzE2MDs8YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9SmF5X1Np Z2VsJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iSmF5 IFNpZ2VsIChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5KYXkgU2lnZWw8L2E+JiMxNjA7fCAxOTg1 OiYjMTYwOzxhIGhyZWY9Ii93aWtpL0Z1enp5X1pvZWxsZXIiIHRpdGxlPSJGdXp6eSBab2VsbGVy Ij5GdXp6eSBab2VsbGVyPC9hPiYjMTYwO3wgMTk4NjomIzE2MDs8YSBocmVmPSIvdy9pbmRleC5w aHA/dGl0bGU9SmVzc19Td2VldHNlciZhbXA7YWN0aW9uPWVkaXQmYW1wO3JlZGxpbms9MSIgY2xh c3M9Im5ldyIgdGl0bGU9Ikplc3MgU3dlZXRzZXIgKFNlaXRlIG5pY2h0IHZvcmhhbmRlbikiPkpl c3MgU3dlZXRzZXI8L2E+JiMxNjA7fCAxOTg3OiYjMTYwOzxhIGhyZWY9Ii93aWtpL1RvbV9XYXRz b24iIHRpdGxlPSJUb20gV2F0c29uIj5Ub20gV2F0c29uPC9hPiYjMTYwO3wgPHNwYW4gc3R5bGU9 IndoaXRlLXNwYWNlOm5vd3JhcDsiPjE5ODg6JiMxNjA7PGEgaHJlZj0iL3cvaW5kZXgucGhwP3Rp dGxlPUlzYWFjX0IuX0dyYWluZ2VyJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFz cz0ibmV3IiB0aXRsZT0iSXNhYWMgQi4gR3JhaW5nZXIgKFNlaXRlIG5pY2h0IHZvcmhhbmRlbiki PklzYWFjIEIuIEdyYWluZ2VyPC9hPiYjMTYwO3w8L3NwYW4+IDxzcGFuIHN0eWxlPSJ3aGl0ZS1z cGFjZTpub3dyYXA7Ij4xOTg5OiYjMTYwOzxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1DaGlf Q2hpX1JvZHJpZ3VleiZhbXA7YWN0aW9uPWVkaXQmYW1wO3JlZGxpbms9MSIgY2xhc3M9Im5ldyIg dGl0bGU9IkNoaSBDaGkgUm9kcmlndWV6IChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5DaGkgQ2hp IFJvZHJpZ3VlejwvYT4mIzE2MDt8PC9zcGFuPiA8c3BhbiBzdHlsZT0id2hpdGUtc3BhY2U6bm93 cmFwOyI+MTk5MDomIzE2MDs8YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9UGVnZ3lfS2lya19C ZWxsJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iUGVn Z3kgS2lyayBCZWxsIChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5QZWdneSBLaXJrIEJlbGw8L2E+ JiMxNjA7fDwvc3Bhbj4gMTk5MTomIzE2MDs8YSBocmVmPSIvd2lraS9CZW5fQ3JlbnNoYXciIHRp dGxlPSJCZW4gQ3JlbnNoYXciPkJlbiBDcmVuc2hhdzwvYT4mIzE2MDt8IDE5OTI6JiMxNjA7PGEg aHJlZj0iL3dpa2kvR2VuZV9TYXJhemVuIiB0aXRsZT0iR2VuZSBTYXJhemVuIj5HZW5lIFNhcmF6 ZW48L2E+JiMxNjA7fCA8c3BhbiBzdHlsZT0id2hpdGUtc3BhY2U6bm93cmFwOyI+MTk5MzomIzE2 MDs8YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9UC5fSi5fQm9hdHdyaWdodCxfSnIuJmFtcDth Y3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iUC4gSi4gQm9hdHdy aWdodCwgSnIuIChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5QLiBKLiBCb2F0d3JpZ2h0LCBKci48 L2E+JiMxNjA7fDwvc3Bhbj4gMTk5NDomIzE2MDs8YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9 TGV3aXNfT2VobWlnJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0 aXRsZT0iTGV3aXMgT2VobWlnIChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5MZXdpcyBPZWhtaWc8 L2E+JiMxNjA7fCAxOTk1OiYjMTYwOzxhIGhyZWY9Ii93L2luZGV4LnBocD90aXRsZT1IZXJiZXJ0 X1dhcnJlbl9XaW5kJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0 aXRsZT0iSGVyYmVydCBXYXJyZW4gV2luZCAoU2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+SGVyYmVy dCBXYXJyZW4gV2luZDwvYT4mIzE2MDt8IDE5OTY6JiMxNjA7PGEgaHJlZj0iL3cvaW5kZXgucGhw P3RpdGxlPUJldHN5X1Jhd2xzJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0i bmV3IiB0aXRsZT0iQmV0c3kgUmF3bHMgKFNlaXRlIG5pY2h0IHZvcmhhbmRlbikiPkJldHN5IFJh d2xzPC9hPiYjMTYwO3wgPHNwYW4gc3R5bGU9IndoaXRlLXNwYWNlOm5vd3JhcDsiPjE5OTc6JiMx NjA7PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPUZyZWRfQnJhbmQsX0pyLiZhbXA7YWN0aW9u PWVkaXQmYW1wO3JlZGxpbms9MSIgY2xhc3M9Im5ldyIgdGl0bGU9IkZyZWQgQnJhbmQsIEpyLiAo U2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+RnJlZCBCcmFuZCwgSnIuPC9hPiYjMTYwO3w8L3NwYW4+ IDE5OTg6JiMxNjA7PGEgaHJlZj0iL3dpa2kvTmFuY3lfTG9wZXoiIHRpdGxlPSJOYW5jeSBMb3Bl eiI+TmFuY3kgTG9wZXo8L2E+JiMxNjA7fCAxOTk5OiYjMTYwOzxhIGhyZWY9Ii93L2luZGV4LnBo cD90aXRsZT1FZGdhcl9VcGRlZ3JhZmYmYW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEiIGNs YXNzPSJuZXciIHRpdGxlPSJFZGdhciBVcGRlZ3JhZmYgKFNlaXRlIG5pY2h0IHZvcmhhbmRlbiki PkVkZ2FyIFVwZGVncmFmZjwvYT4mIzE2MDt8IDIwMDA6JiMxNjA7PGEgaHJlZj0iL3cvaW5kZXgu cGhwP3RpdGxlPUJhcmJhcmFfTWNJbnRpcmUmYW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEi IGNsYXNzPSJuZXciIHRpdGxlPSJCYXJiYXJhIE1jSW50aXJlIChTZWl0ZSBuaWNodCB2b3JoYW5k ZW4pIj5CYXJiYXJhIE1jSW50aXJlPC9hPiYjMTYwO3wgMjAwMTomIzE2MDs8YSBocmVmPSIvdy9p bmRleC5waHA/dGl0bGU9VG9tX0NvdXNpbnMmYW1wO2FjdGlvbj1lZGl0JmFtcDtyZWRsaW5rPTEi IGNsYXNzPSJuZXciIHRpdGxlPSJUb20gQ291c2lucyAoU2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+ VG9tIENvdXNpbnM8L2E+JiMxNjA7fCAyMDAyOiYjMTYwOzxhIGhyZWY9Ii93L2luZGV4LnBocD90 aXRsZT1KdWR5X1JhbmtpbiZhbXA7YWN0aW9uPWVkaXQmYW1wO3JlZGxpbms9MSIgY2xhc3M9Im5l dyIgdGl0bGU9Ikp1ZHkgUmFua2luIChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5KdWR5IFJhbmtp bjwvYT4mIzE2MDt8IDIwMDM6JiMxNjA7PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPUNhcm9s X1NlbXBsZV9UaG9tcHNvbiZhbXA7YWN0aW9uPWVkaXQmYW1wO3JlZGxpbms9MSIgY2xhc3M9Im5l dyIgdGl0bGU9IkNhcm9sIFNlbXBsZSBUaG9tcHNvbiAoU2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+ Q2Fyb2wgU2VtcGxlIFRob21wc29uPC9hPiYjMTYwO3wgPHNwYW4gc3R5bGU9IndoaXRlLXNwYWNl Om5vd3JhcDsiPjIwMDQ6JiMxNjA7PGEgaHJlZj0iL3cvaW5kZXgucGhwP3RpdGxlPUphY2tfQnVy a2UsX0pyLiZhbXA7YWN0aW9uPWVkaXQmYW1wO3JlZGxpbms9MSIgY2xhc3M9Im5ldyIgdGl0bGU9 IkphY2sgQnVya2UsIEpyLiAoU2VpdGUgbmljaHQgdm9yaGFuZGVuKSI+SmFjayBCdXJrZSwgSnIu PC9hPiYjMTYwO3w8L3NwYW4+IDIwMDU6JiMxNjA7PGEgaHJlZj0iL3dpa2kvTmlja19QcmljZV8o R29sZmVyKSIgdGl0bGU9Ik5pY2sgUHJpY2UgKEdvbGZlcikiPk5pY2sgUHJpY2U8L2E+JiMxNjA7 fCAyMDA2OiYjMTYwOzxhIGhyZWY9Ii93aWtpL0pheV9IYWFzIiB0aXRsZT0iSmF5IEhhYXMiPkph eSBIYWFzPC9hPiYjMTYwO3wgMjAwNzomIzE2MDs8YSBocmVmPSIvdy9pbmRleC5waHA/dGl0bGU9 TG91aXNlX1N1Z2dzJmFtcDthY3Rpb249ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0 aXRsZT0iTG91aXNlIFN1Z2dzIChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5Mb3Vpc2UgU3VnZ3M8 L2E+JiMxNjA7fCA8c3BhbiBzdHlsZT0id2hpdGUtc3BhY2U6bm93cmFwOyI+MjAwODomIzE2MDs8 c3Ryb25nIGNsYXNzPSJzZWxmbGluayI+R2VvcmdlIEguIFcuIEJ1c2g8L3N0cm9uZz4mIzE2MDt8 PC9zcGFuPiA8c3BhbiBzdHlsZT0id2hpdGUtc3BhY2U6bm93cmFwOyI+MjAwOTomIzE2MDs8YSBo cmVmPSIvdy9pbmRleC5waHA/dGl0bGU9Ty5fR29yZG9uX0JyZXdlcixfSnIuJmFtcDthY3Rpb249 ZWRpdCZhbXA7cmVkbGluaz0xIiBjbGFzcz0ibmV3IiB0aXRsZT0iTy4gR29yZG9uIEJyZXdlciwg SnIuIChTZWl0ZSBuaWNodCB2b3JoYW5kZW4pIj5PLiBHb3Jkb24gQnJld2VyLCBKci48L2E+PC9z cGFuPjwvcD4JPHA+RGVyIEJvYiBKb25lcyBBd2FyZCB3aXJkIHNlaXQgMTk1NSBqw6RocmxpY2gg YWxzIEFuZXJrZW5udW5nIGhlcnZvcnJhZ2VuZGVyIFNwb3J0bGljaGtlaXQsIGRpZSBkZW0g4oCe R2Vpc3Qgdm9uIEJvYmJ5IEpvbmVz4oCcIGVudHNwcmljaHQsIHZlcmxpZWhlbi48L3A+CTwvZGl2 Pgk8ZGl2IGNsYXNzPSJ2aXN1YWxDbGVhciI+PC9kaXY+CTwvZGl2Pgk8L2Rpdj4JPGRpdiBpZD0i bm9ybWRhdGVuIiBjbGFzcz0iY2F0bGlua3MiPjxiPk5vcm1kYXRlbjwvYj46IDxhIGhyZWY9Ii93 aWtpL1BlcnNvbmVubmFtZW5kYXRlaSIgdGl0bGU9IlBlcnNvbmVubmFtZW5kYXRlaSI+UE5EPC9h PjogPGEgaHJlZj0iaHR0cDovL2QtbmIuaW5mby9nbmQvMTE4ODQ0OTExIiBjbGFzcz0iZXh0ZXJu YWwgdGV4dCIgcmVsPSJub2ZvbGxvdyI+MTE4ODQ0OTExPC9hPiB8IDxhIGhyZWY9Ii93aWtpL0xp YnJhcnlfb2ZfQ29uZ3Jlc3NfQ29udHJvbF9OdW1iZXIiIHRpdGxlPSJMaWJyYXJ5IG9mIENvbmdy ZXNzIENvbnRyb2wgTnVtYmVyIj5MQ0NOPC9hPjogPGEgaHJlZj0iaHR0cDovL2Vycm9sLm9jbGMu b3JnL2xhZi9uODAwMTU4NzkuaHRtbCIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0ibm9mb2xs b3ciPm44MDAxNTg3OTwvYT4gfCA8YSBocmVmPSIvd2lraS9WaXJ0dWFsX0ludGVybmF0aW9uYWxf QXV0aG9yaXR5X0ZpbGUiIHRpdGxlPSJWaXJ0dWFsIEludGVybmF0aW9uYWwgQXV0aG9yaXR5IEZp bGUiPlZJQUY8L2E+OiA8YSBocmVmPSJodHRwOi8vdmlhZi5vcmcvdmlhZi8zOTQxODg3Ni8iIGNs YXNzPSJleHRlcm5hbCB0ZXh0IiByZWw9Im5vZm9sbG93Ij4zOTQxODg3NjwvYT4gfCA8YSBocmVm PSJodHRwOi8vdG9vbHNlcnZlci5vcmcvfmFwcGVyL3BkL3BlcnNvbi9HZW9yZ2VfSC5fVy5fQnVz aCIgY2xhc3M9ImV4dGVybmFsIHRleHQiIHJlbD0ibm9mb2xsb3ciPldQLVBlcnNvbmVuaW5mbzwv YT48L2Rpdj4JPHRhYmxlIGNsYXNzPSJtZXRhZGF0YSIgc3R5bGU9Im1hcmdpbi10b3A6MTVwdDsi Pgk8dHI+CTx0aCBjb2xzcGFuPSIyIj48YSBocmVmPSIvd2lraS9IaWxmZTpQZXJzb25lbmRhdGVu IiB0aXRsZT0iSGlsZmU6UGVyc29uZW5kYXRlbiI+UGVyc29uZW5kYXRlbjwvYT48L3RoPgk8L3Ry Pgk8dHI+CTx0ZCBjbGFzcz0ibWV0YWRhdGEtbGFiZWwiPk5BTUU8L3RkPgk8dGQgc3R5bGU9ImZv bnQtd2VpZ2h0OiBib2xkOyI+QnVzaCwgR2VvcmdlIEguIFcuPC90ZD4JPC90cj4JPHRyPgk8dGQg Y2xhc3M9Im1ldGFkYXRhLWxhYmVsIj5BTFRFUk5BVElWTkFNRU48L3RkPgk8dGQ+QnVzaCwgR2Vv cmdlIEhlcmJlcnQgV2Fsa2VyOyBCdXNoLCBHZW9yZ2Ugc2VuLjwvdGQ+CTwvdHI+CTx0cj4JPHRk IGNsYXNzPSJtZXRhZGF0YS1sYWJlbCI+S1VSWkJFU0NIUkVJQlVORzwvdGQ+CTx0ZD40MS4gUHLD pHNpZGVudCBkZXIgVmVyZWluaWd0ZW4gU3RhYXRlbiB2b24gQW1lcmlrYTwvdGQ+CTwvdHI+CTx0 cj4JPHRkIGNsYXNzPSJtZXRhZGF0YS1sYWJlbCI+R0VCVVJUU0RBVFVNPC90ZD4JPHRkPjEyLiBK dW5pIDE5MjQ8L3RkPgk8L3RyPgk8dHI+CTx0ZCBjbGFzcz0ibWV0YWRhdGEtbGFiZWwiPkdFQlVS VFNPUlQ8L3RkPgk8dGQ+PGEgaHJlZj0iL3dpa2kvTWlsdG9uXyhNYXNzYWNodXNldHRzKSIgdGl0 bGU9Ik1pbHRvbiAoTWFzc2FjaHVzZXR0cykiPk1pbHRvbjwvYT4sIE1hc3NhY2h1c2V0dHM8L3Rk Pgk8L3RyPgk8L3RhYmxlPgk8ZGl2IGlkPSJpbnRlcndpa2ktZW4tZ2EiIGNsYXNzPSJHQSIgc3R5 bGU9ImRpc3BsYXk6IG5vbmU7Ij48L2Rpdj4JPGRpdiBpZD0iaW50ZXJ3aWtpLXN2LWdhIiBjbGFz cz0iR0EiIHN0eWxlPSJkaXNwbGF5OiBub25lOyI+PC9kaXY+CQo= --Boundary-00=_JIqXMWmPTPMpK10-- From debbugs-submit-bounces@debbugs.gnu.org Sun Aug 08 13:26:25 2010 Received: (at submit) by debbugs.gnu.org; 8 Aug 2010 17:26:25 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi9dh-0002vG-9I for submit@debbugs.gnu.org; Sun, 08 Aug 2010 13:26:25 -0400 Received: from mail.gnu.org ([199.232.76.166] helo=mx10.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oi9ch-0002uQ-Ua for submit@debbugs.gnu.org; Sun, 08 Aug 2010 13:25:24 -0400 Received: from lists.gnu.org ([199.232.76.165]:58578) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1Oi9dO-0000sA-T8 for submit@debbugs.gnu.org; Sun, 08 Aug 2010 13:26:07 -0400 Received: from [140.186.70.92] (port=54975 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1Oi9dH-000112-8Y for bug-coreutils@gnu.org; Sun, 08 Aug 2010 13:26:02 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=0.8 required=5.0 tests=BAYES_00,RCVD_IN_PSBL autolearn=no version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1Ohhm7-0005SZ-UM for bug-coreutils@gnu.org; Sat, 07 Aug 2010 07:41:16 -0400 Received: from yxa-v.extundo.com ([83.241.177.39]:38956) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Ohhm5-0005R2-5R; Sat, 07 Aug 2010 07:41:13 -0400 Received: from mocca (c80-216-27-64.bredband.comhem.se [80.216.27.64]) (authenticated bits=0) by yxa-v.extundo.com (8.14.3/8.14.3/Debian-5+lenny1) with ESMTP id o77BekgA017603 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES128-SHA bits=128 verify=NOT); Sat, 7 Aug 2010 13:40:49 +0200 From: Simon Josefsson To: Paul Eggert Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> <4C59F5F8.9080309@cs.ucla.edu> <8739uurli9.fsf@mocca.josefsson.org> <4C5A28D2.3040102@gnu.org> <4C5B4961.6010007@cs.ucla.edu> <4C5BC65A.4020001@gnu.org> <4C5C4C33.8040707@cs.ucla.edu> OpenPGP: id=B565716F; url=http://josefsson.org/key.txt Mail-Followup-To: bug-gnulib@gnu.org Mail-Copies-To: nobody X-Hashcash: 1:22:100807:bug-gnulib@gnu.org::IQGR7Sl9PKELZxnj:0sX0 X-Hashcash: 1:22:100807:bug-coreutils@gnu.org::XGlZpd3jEdo2kghn:5vAz X-Hashcash: 1:22:100807:bonzini@gnu.org::nUhg5HpdKUZXDuAY:Hcwv X-Hashcash: 1:22:100807:eggert@cs.ucla.edu::9YyZDbrqgzVhkCwS:SUvb Date: Sat, 07 Aug 2010 13:40:46 +0200 In-Reply-To: <4C5C4C33.8040707@cs.ucla.edu> (Paul Eggert's message of "Fri, 06 Aug 2010 10:53:55 -0700") Message-ID: <8739uqps5d.fsf@mocca.josefsson.org> User-Agent: Gnus/5.110011 (No Gnus v0.11) Emacs/23.1 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-Virus-Scanned: clamav-milter 0.96.1 at yxa-v X-Virus-Status: Clean X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 1) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.9 (-----) X-Debbugs-Envelope-To: submit X-Mailman-Approved-At: Sun, 08 Aug 2010 13:26:16 -0400 Cc: Bug-coreutils , Paolo Bonzini , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.9 (-----) Paul Eggert writes: > On 08/06/10 01:22, Paolo Bonzini wrote: >> ISAAC is a RNG, so wouldn't that have the same problem above? You >> definitely need to use a hash function, it's just that you do not need a >> cryptographic one. > > I had been thinking of using ISAAC by making the key its seed, and > asking it to generate some random values, and then comparing the > random values. Any RNG can be used (or abused :-) in this way. > > I just now tried, that, though, and discovered that on my million line > benchmark the MD5 method is about 4 times faster than the ISAAC-based > method. So that idea was not a good one. I suppose we could try a > non-cryptographic hash function at some point. I suspect FNV or Xorshift would be faster, since they are so simple: http://en.wikipedia.org/wiki/Fowler_Noll_Vo_hash http://en.wikipedia.org/wiki/Xorshift /Simon From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 09 02:21:20 2010 Received: (at submit) by debbugs.gnu.org; 9 Aug 2010 06:21:20 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiLjc-000345-CY for submit@debbugs.gnu.org; Mon, 09 Aug 2010 02:21:20 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiLjY-00033z-Vt for submit@debbugs.gnu.org; Mon, 09 Aug 2010 02:21:18 -0400 Received: from lists.gnu.org ([199.232.76.165]:43043) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OiLk1-00029y-NA for submit@debbugs.gnu.org; Mon, 09 Aug 2010 02:21:45 -0400 Received: from [140.186.70.92] (port=34201 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OiLju-0005YB-TN for bug-coreutils@gnu.org; Mon, 09 Aug 2010 02:21:44 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,T_RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OiLjr-0003M7-Oq for bug-coreutils@gnu.org; Mon, 09 Aug 2010 02:21:36 -0400 Received: from kiwi.cs.ucla.edu ([131.179.128.19]:48293) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiLjr-0003Ln-GK for bug-coreutils@gnu.org; Mon, 09 Aug 2010 02:21:35 -0400 Received: from [131.179.64.200] (Penguin.CS.UCLA.EDU [131.179.64.200]) by kiwi.cs.ucla.edu (8.13.8+Sun/8.13.8/UCLACS-6.0) with ESMTP id o796LTqt010295; Sun, 8 Aug 2010 23:21:31 -0700 (PDT) Message-ID: <4C5F9E69.5010602@cs.ucla.edu> Date: Sun, 08 Aug 2010 23:21:29 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.11) Gecko/20100713 Thunderbird/3.0.6 MIME-Version: 1.0 To: Bruno Haible Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> <4C59F5F8.9080309@cs.ucla.edu> <201008081424.41509.bruno@clisp.org> In-Reply-To: <201008081424.41509.bruno@clisp.org> Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.1 (-----) X-Debbugs-Envelope-To: submit Cc: bug-coreutils@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.1 (-----) On 08/08/10 05:24, Bruno Haible wrote: > sort: reduce number of strxfrm calls Thanks for that suggestion. Amusingly enough, it made 'sort -R' slower on the first benchmark I tried it on, which was 'sort -R *'. But that's an unfair benchmark, since '*' expanded to executables and other non-text files. Overall, it's a good idea. However, the code need not be quite that long, since there's no need to do size_t overflow checking. I pushed this: >From 0061819c7e1bbc26586cc5977ea96da016f7cea2 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sun, 8 Aug 2010 23:14:38 -0700 Subject: [PATCH] sort: speed up -R with long lines in hard locales * src/sort.c (compare_random): Guess that the output will be 3X the input. This avoids the overhead of calling strxfrm twice on typical implementations. Suggested by Bruno Haible. --- src/sort.c | 18 +++++++++++++----- 1 files changed, 13 insertions(+), 5 deletions(-) diff --git a/src/sort.c b/src/sort.c index dcfd24f..148ed3e 100644 --- a/src/sort.c +++ b/src/sort.c @@ -2024,6 +2024,7 @@ compare_random (char *restrict texta, size_t lena, char stackbuf[4000]; char *buf = stackbuf; size_t bufsize = sizeof stackbuf; + void *allocated = NULL; uint32_t dig[2][MD5_DIGEST_SIZE / sizeof (uint32_t)]; struct md5_ctx s[2]; s[0] = s[1] = random_md5_state; @@ -2047,6 +2048,16 @@ compare_random (char *restrict texta, size_t lena, /* Store the transformed data into a big-enough buffer. */ + /* A 3X size guess avoids the overhead of calling strxfrm + twice on typical implementations. Don't worry about + size_t overflow, as the guess need not be correct. */ + size_t guess_bufsize = 3 * (lena + lenb) + 2; + if (bufsize < guess_bufsize) + { + bufsize = MAX (guess_bufsize, bufsize * 3 / 2); + buf = allocated = xrealloc (allocated, bufsize); + } + size_t sizea = (texta < lima ? xstrxfrm (buf, texta, bufsize) + 1 : 0); bool a_fits = sizea <= bufsize; @@ -2062,9 +2073,7 @@ compare_random (char *restrict texta, size_t lena, bufsize = sizea + sizeb; if (bufsize < SIZE_MAX / 3) bufsize = bufsize * 3 / 2; - buf = (buf == stackbuf - ? xmalloc (bufsize) - : xrealloc (buf, bufsize)); + buf = allocated = xrealloc (allocated, bufsize); if (texta < lima) strxfrm (buf, texta, sizea); if (textb < limb) @@ -2119,8 +2128,7 @@ compare_random (char *restrict texta, size_t lena, diff = xfrm_diff; } - if (buf != stackbuf) - free (buf); + free (allocated); return diff; } -- 1.7.2 From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 09 02:28:05 2010 Received: (at submit) by debbugs.gnu.org; 9 Aug 2010 06:28:05 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiLq9-00036y-1c for submit@debbugs.gnu.org; Mon, 09 Aug 2010 02:28:05 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiLq6-00036a-VQ for submit@debbugs.gnu.org; Mon, 09 Aug 2010 02:28:03 -0400 Received: from lists.gnu.org ([199.232.76.165]:36244) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OiLql-0002Ch-F6 for submit@debbugs.gnu.org; Mon, 09 Aug 2010 02:28:43 -0400 Received: from [140.186.70.92] (port=44325 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OiLqk-0007rc-0l for bug-coreutils@gnu.org; Mon, 09 Aug 2010 02:28:42 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,T_RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OiLqi-0004L7-ML for bug-coreutils@gnu.org; Mon, 09 Aug 2010 02:28:41 -0400 Received: from kiwi.cs.ucla.edu ([131.179.128.19]:48316) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiLqi-0004Kt-BE for bug-coreutils@gnu.org; Mon, 09 Aug 2010 02:28:40 -0400 Received: from [131.179.64.200] (Penguin.CS.UCLA.EDU [131.179.64.200]) by kiwi.cs.ucla.edu (8.13.8+Sun/8.13.8/UCLACS-6.0) with ESMTP id o796SYfZ010325; Sun, 8 Aug 2010 23:28:35 -0700 (PDT) Message-ID: <4C5FA012.8010107@cs.ucla.edu> Date: Sun, 08 Aug 2010 23:28:34 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.11) Gecko/20100713 Thunderbird/3.0.6 MIME-Version: 1.0 To: Bruno Haible Subject: Re: MD5 is broken References: <4C58720D.1010002@cs.ucla.edu> <4C59F5F8.9080309@cs.ucla.edu> <8739uurli9.fsf@mocca.josefsson.org> <201008081526.17130.bruno@clisp.org> In-Reply-To: <201008081526.17130.bruno@clisp.org> Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable X-MIME-Autoconverted: from 8bit to quoted-printable by kiwi.cs.ucla.edu id o796SYfZ010325 X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.1 (-----) X-Debbugs-Envelope-To: submit Cc: Simon Josefsson , bug-coreutils@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.1 (-----) On 08/08/10 06:26, Bruno Haible wrote: > Here is a proposed patch to make this clearer. I like this patch, except I have qualms about putting a Wikipedia URL in the documentation, as Wikipedia is not that stable. Perhaps would be a better URL. Also, the --help output shouldn't point to Wikipedia (or to CERT, for that matter); it should at most refer to the coreutils manual. Jim and/or P=E1draig may have better advice here. From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 09 02:40:55 2010 Received: (at submit) by debbugs.gnu.org; 9 Aug 2010 06:40:55 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiM2Y-0003DG-DE for submit@debbugs.gnu.org; Mon, 09 Aug 2010 02:40:55 -0400 Received: from mail.gnu.org ([199.232.76.166] helo=mx10.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiM2W-0003D9-3o for submit@debbugs.gnu.org; Mon, 09 Aug 2010 02:40:52 -0400 Received: from lists.gnu.org ([199.232.76.165]:38602) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OiM3A-0002JX-Sn for submit@debbugs.gnu.org; Mon, 09 Aug 2010 02:41:32 -0400 Received: from [140.186.70.92] (port=56357 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OiM38-0001w3-OD for bug-coreutils@gnu.org; Mon, 09 Aug 2010 02:41:32 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,T_RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OiM36-00067G-9q for bug-coreutils@gnu.org; Mon, 09 Aug 2010 02:41:29 -0400 Received: from kiwi.cs.ucla.edu ([131.179.128.19]:48361) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiM35-00066y-Tr; Mon, 09 Aug 2010 02:41:28 -0400 Received: from [131.179.64.200] (Penguin.CS.UCLA.EDU [131.179.64.200]) by kiwi.cs.ucla.edu (8.13.8+Sun/8.13.8/UCLACS-6.0) with ESMTP id o796fOZH010406; Sun, 8 Aug 2010 23:41:25 -0700 (PDT) Message-ID: <4C5FA313.8010606@cs.ucla.edu> Date: Sun, 08 Aug 2010 23:41:23 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.11) Gecko/20100713 Thunderbird/3.0.6 MIME-Version: 1.0 To: Bruno Haible Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008040133.13241.bruno@clisp.org> <4C59F5F8.9080309@cs.ucla.edu> <201008081231.31332.bruno@clisp.org> In-Reply-To: <201008081231.31332.bruno@clisp.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.2 (-----) X-Debbugs-Envelope-To: submit Cc: Bug-coreutils , Bug-gnulib X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.2 (-----) On 08/08/10 03:31, Bruno Haible wrote: >> The point >> remains, though, that it's confusing that gnulib memxfrm's name begins >> with "mem", as the mem* functions don't allocate memory. Would you >> consider a patch that renames gnulib memxfrm to amemxfrm, or to some >> other such name? > > No, this is not good. The variant which never allocates memory by itself > would be more complex to use and slower on average that gnulib's function. Sorry, but this doesn't seem to address the point. The name for gnulib's strxfrm variant should be chosen so that it's not confusing, regardless of whether some other strxfrm variant exists. Currently, no other variant exists in coreutils and I think it unlikely that coreutils will use any similar variant any time soon, but removing coreutils memxfrm didn't fix the gnulib confusion. > Also, functions like 'strdup', 'putenv', 'setenv', 'scandir', 'fts', all > do dynamic memory allocation without having an 'a' in their name to > indicate this. My point was not that the function must start with "a". After all, lots of functions allocate memory without having "a" at the front: malloc is just one example. All I'm saying is that the gnulib variant shouldn't use a name starting with "mem", because the mem* names have similar properties and the gnulib variant departs dramatically from these properties. The "strdup"/"strndup" functions are cases in point. Their names were controversial, and they had quite some trouble getting into POSIX, precisely because their names began with "str" but (unlike the other str* functions) they allocated memory. It would be better to not go down that same road again. Thanks for improving the performance of the gnulib variant, by the way. From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 09 03:24:39 2010 Received: (at submit) by debbugs.gnu.org; 9 Aug 2010 07:24:39 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiMit-0003VQ-2F for submit@debbugs.gnu.org; Mon, 09 Aug 2010 03:24:39 -0400 Received: from mail.gnu.org ([199.232.76.166] helo=mx10.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiMiq-0003VK-Ug for submit@debbugs.gnu.org; Mon, 09 Aug 2010 03:24:37 -0400 Received: from lists.gnu.org ([199.232.76.165]:58475) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OiMjV-0002fy-Mh for submit@debbugs.gnu.org; Mon, 09 Aug 2010 03:25:17 -0400 Received: from [140.186.70.92] (port=60039 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OiMjS-0003Si-Ny for bug-coreutils@gnu.org; Mon, 09 Aug 2010 03:25:15 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_NONE, T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OiMjO-0006WO-HD for bug-coreutils@gnu.org; Mon, 09 Aug 2010 03:25:14 -0400 Received: from mo-p00-ob.rzone.de ([81.169.146.161]:63375) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OiMjO-0006Vn-Bu for bug-coreutils@gnu.org; Mon, 09 Aug 2010 03:25:10 -0400 DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; t=1281338708; l=414; s=domk; d=haible.de; h=Content-Transfer-Encoding:Content-Type:MIME-Version:In-Reply-To: References:Cc:Date:Subject:To:From:X-RZG-CLASS-ID:X-RZG-AUTH; bh=PdApBTBrv9Iho3+tUI38t/uDKdc=; b=AlwmPR9sSKeKVLCHabuN9KLe29YDDXbhryFN05DYEnScUwsP55CBAeUdpuC30qBqjIx WasMb0MwCPKztrYDpK2MaYtzYyLxG38uBf7sXhjgHDyKwJRtealjc1IlWDNyJJlassxuG fN4MLSxxMr+CQUv1+kLIXSv3vTX5YQoAukg= X-RZG-AUTH: :Ln4Re0+Ic/6oZXR1YgKryK8brksyK8dozXDwHXjf9hj/zDNRbvU449Jbdg== X-RZG-CLASS-ID: mo00 Received: from linuix.haible.de (dslb-088-068-073-150.pools.arcor-ip.net [88.68.73.150]) by post.strato.de (fruni mo40) (RZmta 23.4) with ESMTP id L04966m797FtXX ; Mon, 9 Aug 2010 09:25:07 +0200 (MEST) From: Bruno Haible To: Paul Eggert Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) Date: Mon, 9 Aug 2010 09:25:04 +0200 User-Agent: KMail/1.9.9 References: <4C58720D.1010002@cs.ucla.edu> <201008081424.41509.bruno@clisp.org> <4C5F9E69.5010602@cs.ucla.edu> In-Reply-To: <4C5F9E69.5010602@cs.ucla.edu> MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: 7bit Content-Disposition: inline Message-Id: <201008090925.06549.bruno@clisp.org> X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.2 (-----) X-Debbugs-Envelope-To: submit Cc: bug-coreutils@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.3 (-----) Hi Paul, > + buf = allocated = xrealloc (allocated, bufsize); The contents of the 'allocated' buffer is scratch, therefore malloc + free should be faster than realloc (except maybe on Linux systems, due to the mremap() system call). Also, the '3 * (lena + lenb)' guess is pessimistic; it is possible that it may return with ENOMEM when in fact strxfrm's real needs would not lead to ENOMEM. Bruno From debbugs-submit-bounces@debbugs.gnu.org Mon Aug 09 21:05:48 2010 Received: (at submit) by debbugs.gnu.org; 10 Aug 2010 01:05:48 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OidHn-0003nf-KV for submit@debbugs.gnu.org; Mon, 09 Aug 2010 21:05:47 -0400 Received: from mail.gnu.org ([199.232.76.166] helo=mx10.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OidHl-0003na-3i for submit@debbugs.gnu.org; Mon, 09 Aug 2010 21:05:45 -0400 Received: from lists.gnu.org ([199.232.76.165]:33765) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OidIR-000339-SR for submit@debbugs.gnu.org; Mon, 09 Aug 2010 21:06:27 -0400 Received: from [140.186.70.92] (port=55704 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OidIQ-0005Qw-3D for bug-coreutils@gnu.org; Mon, 09 Aug 2010 21:06:27 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00 autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OidIO-00013P-Hh for bug-coreutils@gnu.org; Mon, 09 Aug 2010 21:06:25 -0400 Received: from mail1.slb.deg.dub.stisp.net ([84.203.253.98]:19291) by eggs.gnu.org with smtp (Exim 4.69) (envelope-from ) id 1OidIO-000136-8N for bug-coreutils@gnu.org; Mon, 09 Aug 2010 21:06:24 -0400 Received: (qmail 668 invoked from network); 10 Aug 2010 01:06:21 -0000 Received: from unknown (HELO ?192.168.2.25?) (84.203.137.218) by mail1.slb.deg.dub.stisp.net with SMTP; 10 Aug 2010 01:06:21 -0000 Message-ID: <4C60A60A.2090308@draigBrady.com> Date: Tue, 10 Aug 2010 02:06:18 +0100 From: =?ISO-8859-1?Q?P=E1draig_Brady?= User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.8) Gecko/20100227 Thunderbird/3.0.3 MIME-Version: 1.0 To: Paul Eggert Subject: Re: bug#6789: MD5 is broken References: <4C58720D.1010002@cs.ucla.edu> <4C59F5F8.9080309@cs.ucla.edu> <8739uurli9.fsf@mocca.josefsson.org> <201008081526.17130.bruno@clisp.org> <4C5FA012.8010107@cs.ucla.edu> In-Reply-To: <4C5FA012.8010107@cs.ucla.edu> X-Enigmail-Version: 1.0.1 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 8bit X-detected-operating-system: by eggs.gnu.org: FreeBSD 4.6-4.9 X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -3.9 (---) X-Debbugs-Envelope-To: submit Cc: Simon Josefsson , bug-coreutils@gnu.org, Bruno Haible X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -4.7 (----) On 09/08/10 07:28, Paul Eggert wrote: > On 08/08/10 06:26, Bruno Haible wrote: >> Here is a proposed patch to make this clearer. > > I like this patch, except I have qualms about > putting a Wikipedia URL in the documentation, as > Wikipedia is not that stable. Perhaps > would > be a better URL. Also, the --help output shouldn't > point to Wikipedia (or to CERT, for that matter); > it should at most refer to the coreutils manual. > > Jim and/or Pádraig may have better advice here. We don't need to hand hold people interested in the details of MD5 weaknesses. They'll be well able to find the pertinent info. Therefore in the amended patch below I've just removed the URL. I also removed the addition to --help (and consequently the man page), as I think it's overkill. If we were to add something to --help it should probably be also done for sha1sum, but the amended texinfo is enough I think. cheers, Pádraig. commit 4caf1adec8e6ce0cb7ab75365ab312411b2d47bd Author: Bruno Haible Date: Tue Aug 10 01:56:36 2010 +0100 doc: improve the info on md5sum security weaknesses * doc/coreutils.texi (md5sum invocation): Mention currently known security problems. Don't recommend SHA-1 as alternative. Reported by Simon Josefsson diff --git a/doc/coreutils.texi b/doc/coreutils.texi index 942978f..e0e308b 100644 --- a/doc/coreutils.texi +++ b/doc/coreutils.texi @@ -3414,14 +3414,12 @@ options}. Note: The MD5 digest is more reliable than a simple CRC (provided by the @command{cksum} command) for detecting accidental file corruption, as the chances of accidentally having two files with identical MD5 -are vanishingly small. However, it should not be considered truly -secure against malicious tampering: although finding a file with a -given MD5 fingerprint, or modifying a file so as to retain its MD5 are -considered infeasible at the moment, it is known how to produce -different files with identical MD5 (a ``collision''), something which -can be a security issue in certain contexts. For more secure hashes, -consider using SHA-1 or SHA-2. @xref{sha1sum invocation}, and -@ref{sha2 utilities}. +are vanishingly small. However, it should not be considered secure +against malicious tampering: although finding a file with a given MD5 +fingerprint is considered infeasible at the moment, it is known how +to modify certain files, including digital certificates, so that they +appear valid when signed with an MD5 digest. +For more secure hashes, consider using SHA-2. @xref{sha2 utilities}. If a @var{file} is specified as @samp{-} or if no files are given @command{md5sum} computes the checksum for the standard input. From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 10 16:53:09 2010 Received: (at submit) by debbugs.gnu.org; 10 Aug 2010 20:53:09 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oivoq-0004J2-Kw for submit@debbugs.gnu.org; Tue, 10 Aug 2010 16:53:09 -0400 Received: from mail.gnu.org ([199.232.76.166] helo=mx10.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oivoo-0004Id-92 for submit@debbugs.gnu.org; Tue, 10 Aug 2010 16:53:06 -0400 Received: from lists.gnu.org ([199.232.76.165]:50369) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OivpX-0001rR-0y for submit@debbugs.gnu.org; Tue, 10 Aug 2010 16:53:51 -0400 Received: from [140.186.70.92] (port=54665 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OivpV-000663-MF for bug-coreutils@gnu.org; Tue, 10 Aug 2010 16:53:50 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,T_RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OivpU-0004ul-GF for bug-coreutils@gnu.org; Tue, 10 Aug 2010 16:53:49 -0400 Received: from kiwi.cs.ucla.edu ([131.179.128.19]:58196) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OivpU-0004uA-7b for bug-coreutils@gnu.org; Tue, 10 Aug 2010 16:53:48 -0400 Received: from [IPv6:::1] (Penguin.CS.UCLA.EDU [131.179.64.200]) by kiwi.cs.ucla.edu (8.13.8+Sun/8.13.8/UCLACS-6.0) with ESMTP id o7AKrfiC003485; Tue, 10 Aug 2010 13:53:42 -0700 (PDT) Message-ID: <4C61BC55.4000402@cs.ucla.edu> Date: Tue, 10 Aug 2010 22:53:41 +0200 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.11) Gecko/20100713 Thunderbird/3.0.6 MIME-Version: 1.0 To: Bruno Haible Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008081424.41509.bruno@clisp.org> <4C5F9E69.5010602@cs.ucla.edu> <201008090925.06549.bruno@clisp.org> In-Reply-To: <201008090925.06549.bruno@clisp.org> Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.2 (-----) X-Debbugs-Envelope-To: submit Cc: bug-coreutils@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.2 (-----) On 08/09/10 09:25, Bruno Haible wrote: > The contents of the 'allocated' buffer is scratch, therefore malloc + free > should be faster than realloc... > > Also, the '3 * (lena + lenb)' guess is pessimistic; it is possible that > it may return with ENOMEM when in fact strxfrm's real needs would not > lead to ENOMEM. Thanks again; I installed this: * src/sort.c (compare_random): Use free/xmalloc rather than xrealloc, since the old buffer contents need not be preserved. Also, don't fail if the guessed-sized malloc fails. Suggested by Bruno Haible. --- src/sort.c | 11 +++++++++-- 1 files changed, 9 insertions(+), 2 deletions(-) diff --git a/src/sort.c b/src/sort.c index 084f4e3..3dc7ae0 100644 --- a/src/sort.c +++ b/src/sort.c @@ -2056,7 +2056,13 @@ compare_random (char *restrict texta, size_t lena, if (bufsize < guess_bufsize) { bufsize = MAX (guess_bufsize, bufsize * 3 / 2); - buf = allocated = xrealloc (allocated, bufsize); + free (allocated); + buf = allocated = malloc (bufsize); + if (! buf) + { + buf = stackbuf; + bufsize = sizeof stackbuf; + } } size_t sizea = @@ -2074,7 +2080,8 @@ compare_random (char *restrict texta, size_t lena, bufsize = sizea + sizeb; if (bufsize < SIZE_MAX / 3) bufsize = bufsize * 3 / 2; - buf = allocated = xrealloc (allocated, bufsize); + free (allocated); + buf = allocated = xmalloc (bufsize); if (texta < lima) strxfrm (buf, texta, sizea); if (textb < limb) -- 1.7.2 From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 10 20:37:39 2010 Received: (at submit) by debbugs.gnu.org; 11 Aug 2010 00:37:39 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OizK6-0005pP-7S for submit@debbugs.gnu.org; Tue, 10 Aug 2010 20:37:38 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OizK3-0005pK-RI for submit@debbugs.gnu.org; Tue, 10 Aug 2010 20:37:36 -0400 Received: from lists.gnu.org ([199.232.76.165]:44497) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OizKn-0002qx-3V for submit@debbugs.gnu.org; Tue, 10 Aug 2010 20:38:21 -0400 Received: from [140.186.70.92] (port=50792 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OizKl-0004cK-KI for bug-coreutils@gnu.org; Tue, 10 Aug 2010 20:38:20 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_NONE, T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OizKk-0000Z6-HN for bug-coreutils@gnu.org; Tue, 10 Aug 2010 20:38:19 -0400 Received: from mo-p00-ob.rzone.de ([81.169.146.161]:29686) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OizKh-0000VX-VI; Tue, 10 Aug 2010 20:38:16 -0400 DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; t=1281487093; l=962; s=domk; d=haible.de; h=Content-Transfer-Encoding:Content-Type:MIME-Version:In-Reply-To: References:Cc:Date:Subject:To:From:X-RZG-CLASS-ID:X-RZG-AUTH; bh=NYlzGdus2Dp7O1MDlZbHZCWqoVI=; b=ppC4xVSKPib7CtdVEdZsYgErmgkGUdsWmfPQRhT5ZrQ6wwEytk/iSXkd65ZcV5NvXC7 sUais21bwOtLX75TuAbSlT9LLhs11rT47XRhUUuAnet5ZSsbP0AbViFYoN+XFBb4AxJdX yJw3O8dYmmtUX9XnQvM1RGrrTpwNYBgLp28= X-RZG-AUTH: :Ln4Re0+Ic/6oZXR1YgKryK8brksyK8dozXDwHXjf9hj/zDNRbvU449Jbdg== X-RZG-CLASS-ID: mo00 Received: from linuix.haible.de (dslb-088-068-073-150.pools.arcor-ip.net [88.68.73.150]) by post.strato.de (mrclete mo40) (RZmta 23.4) with ESMTP id L002e9m7ANIF35 ; Wed, 11 Aug 2010 02:38:13 +0200 (MEST) From: Bruno Haible To: Paul Eggert Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) Date: Wed, 11 Aug 2010 02:38:11 +0200 User-Agent: KMail/1.9.9 References: <4C58720D.1010002@cs.ucla.edu> <201008081231.31332.bruno@clisp.org> <4C5FA313.8010606@cs.ucla.edu> In-Reply-To: <4C5FA313.8010606@cs.ucla.edu> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Content-Disposition: inline Message-Id: <201008110238.12539.bruno@clisp.org> X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -4.1 (----) X-Debbugs-Envelope-To: submit Cc: bug-coreutils@gnu.org, bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.4 (-----) Hi Paul, > All I'm saying is that the gnulib variant shouldn't > use a name starting with "mem", because the mem* names have similar > properties and the gnulib variant departs dramatically from these > properties. > > The "strdup"/"strndup" functions are cases in point. Their names were > controversial, and they had quite some trouble getting into POSIX, precisely > because their names began with "str" but (unlike the other str* functions) > they allocated memory. But now they are in POSIX. So, precedent is existing. On the other hand, it has now appeared that strxfrm would be easier to use efficiently if it had a wrapper that incorporated the "allocate 3 * len bytes before calling strxfrm" heuristic. If we add such a wrapper to gnulib, it could be called 'astrxfrm' extern char * astrxfrm (const char *s, char *resultbuf, size_t *lengthp); and then I would agree to renaming memxfrm -> amemxfrm, for consistency. Bruno From debbugs-submit-bounces@debbugs.gnu.org Tue Aug 10 23:41:37 2010 Received: (at submit) by debbugs.gnu.org; 11 Aug 2010 03:41:37 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oj2C8-00071b-Tc for submit@debbugs.gnu.org; Tue, 10 Aug 2010 23:41:37 -0400 Received: from mail.gnu.org ([199.232.76.166] helo=mx10.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oj2C6-00071W-QA for submit@debbugs.gnu.org; Tue, 10 Aug 2010 23:41:35 -0400 Received: from lists.gnu.org ([199.232.76.165]:48220) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1Oj2Cq-0003hc-KP for submit@debbugs.gnu.org; Tue, 10 Aug 2010 23:42:20 -0400 Received: from [140.186.70.92] (port=44591 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1Oj2Cp-0001jz-AO for bug-coreutils@gnu.org; Tue, 10 Aug 2010 23:42:20 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,T_RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1Oj2Co-0008HU-1W for bug-coreutils@gnu.org; Tue, 10 Aug 2010 23:42:19 -0400 Received: from kiwi.cs.ucla.edu ([131.179.128.19]:60526) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Oj2Cn-0008HI-Nt; Tue, 10 Aug 2010 23:42:18 -0400 Received: from [IPv6:::1] (Penguin.CS.UCLA.EDU [131.179.64.200]) by kiwi.cs.ucla.edu (8.13.8+Sun/8.13.8/UCLACS-6.0) with ESMTP id o7B3gAKF008686; Tue, 10 Aug 2010 20:42:12 -0700 (PDT) Message-ID: <4C621C12.8010708@cs.ucla.edu> Date: Wed, 11 Aug 2010 05:42:10 +0200 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.11) Gecko/20100713 Thunderbird/3.0.6 MIME-Version: 1.0 To: Bruno Haible Subject: Re: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) References: <4C58720D.1010002@cs.ucla.edu> <201008081231.31332.bruno@clisp.org> <4C5FA313.8010606@cs.ucla.edu> <201008110238.12539.bruno@clisp.org> In-Reply-To: <201008110238.12539.bruno@clisp.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -5.2 (-----) X-Debbugs-Envelope-To: submit Cc: bug-coreutils@gnu.org, bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.2 (-----) On 08/11/10 02:38, Bruno Haible wrote: > extern char * astrxfrm (const char *s, char *resultbuf, size_t *lengthp); Yes, that looks like a useful addition. Thanks for the suggestion. From debbugs-submit-bounces@debbugs.gnu.org Sat Aug 14 13:18:29 2010 Received: (at submit) by debbugs.gnu.org; 14 Aug 2010 17:18:29 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OkKNI-0006I0-Rb for submit@debbugs.gnu.org; Sat, 14 Aug 2010 13:18:29 -0400 Received: from mail.gnu.org ([199.232.76.166] helo=mx10.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OkKNG-0006Hv-Oc for submit@debbugs.gnu.org; Sat, 14 Aug 2010 13:18:27 -0400 Received: from lists.gnu.org ([199.232.76.165]:43523) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OkKO9-0005Ti-9k for submit@debbugs.gnu.org; Sat, 14 Aug 2010 13:19:21 -0400 Received: from [140.186.70.92] (port=59067 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OkKO4-0001SS-52 for bug-coreutils@gnu.org; Sat, 14 Aug 2010 13:19:20 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_NONE, T_DKIM_INVALID autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OkKNz-0001d0-7F for bug-coreutils@gnu.org; Sat, 14 Aug 2010 13:19:16 -0400 Received: from mo-p00-ob.rzone.de ([81.169.146.161]:15120) by eggs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OkKNz-0001cb-1E for bug-coreutils@gnu.org; Sat, 14 Aug 2010 13:19:11 -0400 DKIM-Signature: v=1; a=rsa-sha1; c=relaxed/relaxed; t=1281806348; l=1124; s=domk; d=haible.de; h=Content-Transfer-Encoding:Content-Type:MIME-Version:In-Reply-To: References:Cc:Date:Subject:To:From:X-RZG-CLASS-ID:X-RZG-AUTH; bh=2WS3FvMw4vyOzKSUoSL3T0Mkoa0=; b=xZJOVaIZS3KoSgvYSEV6DLabLuITLJQNW1TWkbJu2pPHegi6eXIVvDoHjVM05zinPBs rs9cmVJ67a6Ov5O/lUKA6uHrWgcbmICZvP64wAB9nSqTG6TMDLBxbU6VOUs5mNoIuyaxM ssqdTEDQ4Susj+MODU5/EnRQsMGO8qJiJbY= X-RZG-AUTH: :Ln4Re0+Ic/6oZXR1YgKryK8brksyK8dozXDwHXjf9hj/zDNRbvU449Jbdg== X-RZG-CLASS-ID: mo00 Received: from linuix.haible.de (dslb-088-068-073-150.pools.arcor-ip.net [88.68.73.150]) by post.strato.de (jimi mo7) (RZmta 23.4) with ESMTP id 603c8am7EGdhqn ; Sat, 14 Aug 2010 19:19:06 +0200 (MEST) From: Bruno Haible To: =?iso-8859-1?q?P=E1draig_Brady?= Subject: Re: bug#6789: MD5 is broken Date: Sat, 14 Aug 2010 19:19:04 +0200 User-Agent: KMail/1.9.9 References: <4C58720D.1010002@cs.ucla.edu> <4C5FA012.8010107@cs.ucla.edu> <4C60A60A.2090308@draigBrady.com> In-Reply-To: <4C60A60A.2090308@draigBrady.com> MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: quoted-printable Content-Disposition: inline Message-Id: <201008141919.05601.bruno@clisp.org> X-detected-operating-system: by eggs.gnu.org: Solaris 10 (beta) X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -4.2 (----) X-Debbugs-Envelope-To: submit Cc: Simon Josefsson , Paul Eggert , bug-coreutils@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.5 (-----) Hi P=E1draig, > I also removed the addition to --help > (and consequently the man page), as I think it's overkill. It's common to list important issues with a program or function in the BUGS section of the manual page. For example, $ man 3 tempnam ... BUGS ... Never use this function. Use mkstemp(3) or tmpfile(3) instead. In particular if the use of a program may have severe security implications, I would expect to know about it from the manual page. > If we were to add something to --help it should > probably be also done for sha1sum The attacks on SHA-1 are less advanced than those on MD5, currently. But if you would warn against use of SHA-1 also, please go ahead. > commit 4caf1adec8e6ce0cb7ab75365ab312411b2d47bd > Author: Bruno Haible > Date: Tue Aug 10 01:56:36 2010 +0100 >=20 > doc: improve the info on md5sum security weaknesses >=20 > * doc/coreutils.texi (md5sum invocation): Mention currently known > security problems. Don't recommend SHA-1 as alternative. > Reported by Simon Josefsson You haven't pushed this so far, I think? Bruno From debbugs-submit-bounces@debbugs.gnu.org Sat Aug 14 18:56:39 2010 Received: (at submit) by debbugs.gnu.org; 14 Aug 2010 22:56:39 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OkPeY-0001QP-PY for submit@debbugs.gnu.org; Sat, 14 Aug 2010 18:56:39 -0400 Received: from mx10.gnu.org ([199.232.76.166]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1OkPeW-0001QH-Gf for submit@debbugs.gnu.org; Sat, 14 Aug 2010 18:56:37 -0400 Received: from lists.gnu.org ([199.232.76.165]:59323) by monty-python.gnu.org with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1OkPfP-0007O0-Mg for submit@debbugs.gnu.org; Sat, 14 Aug 2010 18:57:31 -0400 Received: from [140.186.70.92] (port=59117 helo=eggs.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1OkPfO-0001vP-0Y for bug-coreutils@gnu.org; Sat, 14 Aug 2010 18:57:31 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00 autolearn=unavailable version=3.3.1 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.69) (envelope-from ) id 1OkPfM-0007qq-Mo for bug-coreutils@gnu.org; Sat, 14 Aug 2010 18:57:29 -0400 Received: from mail1.slb.deg.dub.stisp.net ([84.203.253.98]:15957) by eggs.gnu.org with smtp (Exim 4.69) (envelope-from ) id 1OkPfM-0007qc-Av for bug-coreutils@gnu.org; Sat, 14 Aug 2010 18:57:28 -0400 Received: (qmail 97917 invoked from network); 14 Aug 2010 22:57:25 -0000 Received: from unknown (HELO ?192.168.2.25?) (84.203.137.218) by mail1.slb.deg.dub.stisp.net with SMTP; 14 Aug 2010 22:57:25 -0000 Message-ID: <4C671F3B.8080201@draigBrady.com> Date: Sat, 14 Aug 2010 23:56:59 +0100 From: =?ISO-8859-1?Q?P=E1draig_Brady?= User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.8) Gecko/20100227 Thunderbird/3.0.3 MIME-Version: 1.0 To: Bruno Haible Subject: Re: bug#6789: MD5 is broken References: <4C58720D.1010002@cs.ucla.edu> <4C5FA012.8010107@cs.ucla.edu> <4C60A60A.2090308@draigBrady.com> <201008141919.05601.bruno@clisp.org> In-Reply-To: <201008141919.05601.bruno@clisp.org> X-Enigmail-Version: 1.0.1 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 8bit X-detected-operating-system: by eggs.gnu.org: FreeBSD 4.6-4.9 X-detected-operating-system: by monty-python.gnu.org: GNU/Linux 2.6, seldom 2.4 (older, 4) X-Spam-Score: -4.7 (----) X-Debbugs-Envelope-To: submit Cc: Report bugs to X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -4.7 (----) On 14/08/10 18:19, Bruno Haible wrote: > Hi Pádraig, > >> I also removed the addition to --help >> (and consequently the man page), as I think it's overkill. > > It's common to list important issues with a program or function > in the BUGS section of the manual page. For example, > > $ man 3 tempnam > ... > BUGS > ... > Never use this function. Use mkstemp(3) or tmpfile(3) instead. > > In particular if the use of a program may have severe security implications, > I would expect to know about it from the manual page. OK cool. I was thinking that warnings would be more appropriate in library docs rather than the user util, but I will add the warning to BUGS in man/md5sum.x and leave --help unchanged. >> If we were to add something to --help it should >> probably be also done for sha1sum > > The attacks on SHA-1 are less advanced than those on MD5, currently. > But if you would warn against use of SHA-1 also, please go ahead. > >> commit 4caf1adec8e6ce0cb7ab75365ab312411b2d47bd >> Author: Bruno Haible >> Date: Tue Aug 10 01:56:36 2010 +0100 >> >> doc: improve the info on md5sum security weaknesses >> >> * doc/coreutils.texi (md5sum invocation): Mention currently known >> security problems. Don't recommend SHA-1 as alternative. >> Reported by Simon Josefsson > > You haven't pushed this so far, I think? I only added it to my local queue in case there was feedback on my amendments. I will apply the update now. thanks, Pádraig. From debbugs-submit-bounces@debbugs.gnu.org Sun Aug 07 11:53:24 2011 Received: (at 6789-done) by debbugs.gnu.org; 7 Aug 2011 15:53:24 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Qq5fI-00014D-Ap for submit@debbugs.gnu.org; Sun, 07 Aug 2011 11:53:24 -0400 Received: from mx.meyering.net ([82.230.74.64]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1Qq5fG-000146-TU for 6789-done@debbugs.gnu.org; Sun, 07 Aug 2011 11:53:23 -0400 Received: from rho.meyering.net (localhost.localdomain [127.0.0.1]) by rho.meyering.net (Acme Bit-Twister) with ESMTP id 1242560150; Sun, 7 Aug 2011 17:52:25 +0200 (CEST) From: Jim Meyering To: Paul Eggert Subject: Re: bug#6789: propose renaming gnulib memxfrm to amemxfrm (naming collision with coreutils) In-Reply-To: <4C61BC55.4000402@cs.ucla.edu> (Paul Eggert's message of "Tue, 10 Aug 2010 22:53:41 +0200") References: <4C58720D.1010002@cs.ucla.edu> <201008081424.41509.bruno@clisp.org> <4C5F9E69.5010602@cs.ucla.edu> <201008090925.06549.bruno@clisp.org> <4C61BC55.4000402@cs.ucla.edu> Date: Sun, 07 Aug 2011 17:52:24 +0200 Message-ID: <87ipq9jk1z.fsf@rho.meyering.net> Lines: 18 MIME-Version: 1.0 Content-Type: text/plain X-Spam-Score: -6.1 (------) X-Debbugs-Envelope-To: 6789-done Cc: 6789-done@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -6.1 (------) Paul Eggert wrote: > On 08/09/10 09:25, Bruno Haible wrote: > >> The contents of the 'allocated' buffer is scratch, therefore malloc + free >> should be faster than realloc... >> >> Also, the '3 * (lena + lenb)' guess is pessimistic; it is possible that >> it may return with ENOMEM when in fact strxfrm's real needs would not >> lead to ENOMEM. > > Thanks again; I installed this: > > * src/sort.c (compare_random): Use free/xmalloc rather than > xrealloc, since the old buffer contents need not be preserved. > Also, don't fail if the guessed-sized malloc fails. Suggested by > Bruno Haible. This was resolved a year ago. From unknown Mon Sep 08 01:50:45 2025 Received: (at fakecontrol) by fakecontrolmessage; To: internal_control@debbugs.gnu.org From: Debbugs Internal Request Subject: Internal Control Message-Id: bug archived. Date: Mon, 05 Sep 2011 11:24:05 +0000 User-Agent: Fakemail v42.6.9 # This is a fake control message. # # The action: # bug archived. thanks # This fakemail brought to you by your local debbugs # administrator