Index: trunk/APPLE_LICENSE =================================================================== --- trunk/APPLE_LICENSE (revision 0) +++ trunk/APPLE_LICENSE (revision 1) @@ -0,0 +1,367 @@ +APPLE PUBLIC SOURCE LICENSE +Version 2.0 - August 6, 2003 + +Please read this License carefully before downloading this software. +By downloading or using this software, you are agreeing to be bound by +the terms of this License. If you do not or cannot agree to the terms +of this License, please do not download or use the software. + +1. General; Definitions. This License applies to any program or other +work which Apple Computer, Inc. ("Apple") makes publicly available and +which contains a notice placed by Apple identifying such program or +work as "Original Code" and stating that it is subject to the terms of +this Apple Public Source License version 2.0 ("License"). As used in +this License: + +1.1 "Applicable Patent Rights" mean: (a) in the case where Apple is +the grantor of rights, (i) claims of patents that are now or hereafter +acquired, owned by or assigned to Apple and (ii) that cover subject +matter contained in the Original Code, but only to the extent +necessary to use, reproduce and/or distribute the Original Code +without infringement; and (b) in the case where You are the grantor of +rights, (i) claims of patents that are now or hereafter acquired, +owned by or assigned to You and (ii) that cover subject matter in Your +Modifications, taken alone or in combination with Original Code. + +1.2 "Contributor" means any person or entity that creates or +contributes to the creation of Modifications. + +1.3 "Covered Code" means the Original Code, Modifications, the +combination of Original Code and any Modifications, and/or any +respective portions thereof. + +1.4 "Externally Deploy" means: (a) to sublicense, distribute or +otherwise make Covered Code available, directly or indirectly, to +anyone other than You; and/or (b) to use Covered Code, alone or as +part of a Larger Work, in any way to provide a service, including but +not limited to delivery of content, through electronic communication +with a client other than You. + +1.5 "Larger Work" means a work which combines Covered Code or portions +thereof with code not governed by the terms of this License. + +1.6 "Modifications" mean any addition to, deletion from, and/or change +to, the substance and/or structure of the Original Code, any previous +Modifications, the combination of Original Code and any previous +Modifications, and/or any respective portions thereof. When code is +released as a series of files, a Modification is: (a) any addition to +or deletion from the contents of a file containing Covered Code; +and/or (b) any new file or other representation of computer program +statements that contains any part of Covered Code. + +1.7 "Original Code" means (a) the Source Code of a program or other +work as originally made available by Apple under this License, +including the Source Code of any updates or upgrades to such programs +or works made available by Apple under this License, and that has been +expressly identified by Apple as such in the header file(s) of such +work; and (b) the object code compiled from such Source Code and +originally made available by Apple under this License. + +1.8 "Source Code" means the human readable form of a program or other +work that is suitable for making modifications to it, including all +modules it contains, plus any associated interface definition files, +scripts used to control compilation and installation of an executable +(object code). + +1.9 "You" or "Your" means an individual or a legal entity exercising +rights under this License. For legal entities, "You" or "Your" +includes any entity which controls, is controlled by, or is under +common control with, You, where "control" means (a) the power, direct +or indirect, to cause the direction or management of such entity, +whether by contract or otherwise, or (b) ownership of fifty percent +(50%) or more of the outstanding shares or beneficial ownership of +such entity. + +2. Permitted Uses; Conditions & Restrictions. Subject to the terms +and conditions of this License, Apple hereby grants You, effective on +the date You accept this License and download the Original Code, a +world-wide, royalty-free, non-exclusive license, to the extent of +Apple's Applicable Patent Rights and copyrights covering the Original +Code, to do the following: + +2.1 Unmodified Code. You may use, reproduce, display, perform, +internally distribute within Your organization, and Externally Deploy +verbatim, unmodified copies of the Original Code, for commercial or +non-commercial purposes, provided that in each instance: + +(a) You must retain and reproduce in all copies of Original Code the +copyright and other proprietary notices and disclaimers of Apple as +they appear in the Original Code, and keep intact all notices in the +Original Code that refer to this License; and + +(b) You must include a copy of this License with every copy of Source +Code of Covered Code and documentation You distribute or Externally +Deploy, and You may not offer or impose any terms on such Source Code +that alter or restrict this License or the recipients' rights +hereunder, except as permitted under Section 6. + +2.2 Modified Code. You may modify Covered Code and use, reproduce, +display, perform, internally distribute within Your organization, and +Externally Deploy Your Modifications and Covered Code, for commercial +or non-commercial purposes, provided that in each instance You also +meet all of these conditions: + +(a) You must satisfy all the conditions of Section 2.1 with respect to +the Source Code of the Covered Code; + +(b) You must duplicate, to the extent it does not already exist, the +notice in Exhibit A in each file of the Source Code of all Your +Modifications, and cause the modified files to carry prominent notices +stating that You changed the files and the date of any change; and + +(c) If You Externally Deploy Your Modifications, You must make +Source Code of all Your Externally Deployed Modifications either +available to those to whom You have Externally Deployed Your +Modifications, or publicly available. Source Code of Your Externally +Deployed Modifications must be released under the terms set forth in +this License, including the license grants set forth in Section 3 +below, for as long as you Externally Deploy the Covered Code or twelve +(12) months from the date of initial External Deployment, whichever is +longer. You should preferably distribute the Source Code of Your +Externally Deployed Modifications electronically (e.g. download from a +web site). + +2.3 Distribution of Executable Versions. In addition, if You +Externally Deploy Covered Code (Original Code and/or Modifications) in +object code, executable form only, You must include a prominent +notice, in the code itself as well as in related documentation, +stating that Source Code of the Covered Code is available under the +terms of this License with information on how and where to obtain such +Source Code. + +2.4 Third Party Rights. You expressly acknowledge and agree that +although Apple and each Contributor grants the licenses to their +respective portions of the Covered Code set forth herein, no +assurances are provided by Apple or any Contributor that the Covered +Code does not infringe the patent or other intellectual property +rights of any other entity. Apple and each Contributor disclaim any +liability to You for claims brought by any other entity based on +infringement of intellectual property rights or otherwise. As a +condition to exercising the rights and licenses granted hereunder, You +hereby assume sole responsibility to secure any other intellectual +property rights needed, if any. For example, if a third party patent +license is required to allow You to distribute the Covered Code, it is +Your responsibility to acquire that license before distributing the +Covered Code. + +3. Your Grants. In consideration of, and as a condition to, the +licenses granted to You under this License, You hereby grant to any +person or entity receiving or distributing Covered Code under this +License a non-exclusive, royalty-free, perpetual, irrevocable license, +under Your Applicable Patent Rights and other intellectual property +rights (other than patent) owned or controlled by You, to use, +reproduce, display, perform, modify, sublicense, distribute and +Externally Deploy Your Modifications of the same scope and extent as +Apple's licenses under Sections 2.1 and 2.2 above. + +4. Larger Works. You may create a Larger Work by combining Covered +Code with other code not governed by the terms of this License and +distribute the Larger Work as a single product. In each such instance, +You must make sure the requirements of this License are fulfilled for +the Covered Code or any portion thereof. + +5. Limitations on Patent License. Except as expressly stated in +Section 2, no other patent rights, express or implied, are granted by +Apple herein. Modifications and/or Larger Works may require additional +patent licenses from Apple which Apple may grant in its sole +discretion. + +6. Additional Terms. You may choose to offer, and to charge a fee for, +warranty, support, indemnity or liability obligations and/or other +rights consistent with the scope of the license granted herein +("Additional Terms") to one or more recipients of Covered Code. +However, You may do so only on Your own behalf and as Your sole +responsibility, and not on behalf of Apple or any Contributor. You +must obtain the recipient's agreement that any such Additional Terms +are offered by You alone, and You hereby agree to indemnify, defend +and hold Apple and every Contributor harmless for any liability +incurred by or claims asserted against Apple or such Contributor by +reason of any such Additional Terms. + +7. Versions of the License. Apple may publish revised and/or new +versions of this License from time to time. Each version will be given +a distinguishing version number. Once Original Code has been published +under a particular version of this License, You may continue to use it +under the terms of that version. You may also choose to use such +Original Code under the terms of any subsequent version of this +License published by Apple. No one other than Apple has the right to +modify the terms applicable to Covered Code created under this +License. + +8. NO WARRANTY OR SUPPORT. The Covered Code may contain in whole or in +part pre-release, untested, or not fully tested works. The Covered +Code may contain errors that could cause failures or loss of data, and +may be incomplete or contain inaccuracies. You expressly acknowledge +and agree that use of the Covered Code, or any portion thereof, is at +Your sole and entire risk. THE COVERED CODE IS PROVIDED "AS IS" AND +WITHOUT WARRANTY, UPGRADES OR SUPPORT OF ANY KIND AND APPLE AND +APPLE'S LICENSOR(S) (COLLECTIVELY REFERRED TO AS "APPLE" FOR THE +PURPOSES OF SECTIONS 8 AND 9) AND ALL CONTRIBUTORS EXPRESSLY DISCLAIM +ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT +NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF +MERCHANTABILITY, OF SATISFACTORY QUALITY, OF FITNESS FOR A PARTICULAR +PURPOSE, OF ACCURACY, OF QUIET ENJOYMENT, AND NONINFRINGEMENT OF THIRD +PARTY RIGHTS. APPLE AND EACH CONTRIBUTOR DOES NOT WARRANT AGAINST +INTERFERENCE WITH YOUR ENJOYMENT OF THE COVERED CODE, THAT THE +FUNCTIONS CONTAINED IN THE COVERED CODE WILL MEET YOUR REQUIREMENTS, +THAT THE OPERATION OF THE COVERED CODE WILL BE UNINTERRUPTED OR +ERROR-FREE, OR THAT DEFECTS IN THE COVERED CODE WILL BE CORRECTED. NO +ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY APPLE, AN APPLE +AUTHORIZED REPRESENTATIVE OR ANY CONTRIBUTOR SHALL CREATE A WARRANTY. +You acknowledge that the Covered Code is not intended for use in the +operation of nuclear facilities, aircraft navigation, communication +systems, or air traffic control machines in which case the failure of +the Covered Code could lead to death, personal injury, or severe +physical or environmental damage. + +9. LIMITATION OF LIABILITY. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO +EVENT SHALL APPLE OR ANY CONTRIBUTOR BE LIABLE FOR ANY INCIDENTAL, +SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING +TO THIS LICENSE OR YOUR USE OR INABILITY TO USE THE COVERED CODE, OR +ANY PORTION THEREOF, WHETHER UNDER A THEORY OF CONTRACT, WARRANTY, +TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF +APPLE OR SUCH CONTRIBUTOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES AND NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY +REMEDY. SOME JURISDICTIONS DO NOT ALLOW THE LIMITATION OF LIABILITY OF +INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT APPLY +TO YOU. In no event shall Apple's total liability to You for all +damages (other than as may be required by applicable law) under this +License exceed the amount of fifty dollars ($50.00). + +10. Trademarks. This License does not grant any rights to use the +trademarks or trade names "Apple", "Apple Computer", "Mac", "Mac OS", +"QuickTime", "QuickTime Streaming Server" or any other trademarks, +service marks, logos or trade names belonging to Apple (collectively +"Apple Marks") or to any trademark, service mark, logo or trade name +belonging to any Contributor. You agree not to use any Apple Marks in +or as part of the name of products derived from the Original Code or +to endorse or promote products derived from the Original Code other +than as expressly permitted by and in strict compliance at all times +with Apple's third party trademark usage guidelines which are posted +at http://www.apple.com/legal/guidelinesfor3rdparties.html. + +11. Ownership. Subject to the licenses granted under this License, +each Contributor retains all rights, title and interest in and to any +Modifications made by such Contributor. Apple retains all rights, +title and interest in and to the Original Code and any Modifications +made by or on behalf of Apple ("Apple Modifications"), and such Apple +Modifications will not be automatically subject to this License. Apple +may, at its sole discretion, choose to license such Apple +Modifications under this License, or on different terms from those +contained in this License or may choose not to license them at all. + +12. Termination. + +12.1 Termination. This License and the rights granted hereunder will +terminate: + +(a) automatically without notice from Apple if You fail to comply with +any term(s) of this License and fail to cure such breach within 30 +days of becoming aware of such breach; + +(b) immediately in the event of the circumstances described in Section +13.5(b); or + +(c) automatically without notice from Apple if You, at any time during +the term of this License, commence an action for patent infringement +against Apple; provided that Apple did not first commence +an action for patent infringement against You in that instance. + +12.2 Effect of Termination. Upon termination, You agree to immediately +stop any further use, reproduction, modification, sublicensing and +distribution of the Covered Code. All sublicenses to the Covered Code +which have been properly granted prior to termination shall survive +any termination of this License. Provisions which, by their nature, +should remain in effect beyond the termination of this License shall +survive, including but not limited to Sections 3, 5, 8, 9, 10, 11, +12.2 and 13. No party will be liable to any other for compensation, +indemnity or damages of any sort solely as a result of terminating +this License in accordance with its terms, and termination of this +License will be without prejudice to any other right or remedy of +any party. + +13. Miscellaneous. + +13.1 Government End Users. The Covered Code is a "commercial item" as +defined in FAR 2.101. Government software and technical data rights in +the Covered Code include only those rights customarily provided to the +public as defined in this License. This customary commercial license +in technical data and software is provided in accordance with FAR +12.211 (Technical Data) and 12.212 (Computer Software) and, for +Department of Defense purchases, DFAR 252.227-7015 (Technical Data -- +Commercial Items) and 227.7202-3 (Rights in Commercial Computer +Software or Computer Software Documentation). Accordingly, all U.S. +Government End Users acquire Covered Code with only those rights set +forth herein. + +13.2 Relationship of Parties. This License will not be construed as +creating an agency, partnership, joint venture or any other form of +legal association between or among You, Apple or any Contributor, and +You will not represent to the contrary, whether expressly, by +implication, appearance or otherwise. + +13.3 Independent Development. Nothing in this License will impair +Apple's right to acquire, license, develop, have others develop for +it, market and/or distribute technology or products that perform the +same or similar functions as, or otherwise compete with, +Modifications, Larger Works, technology or products that You may +develop, produce, market or distribute. + +13.4 Waiver; Construction. Failure by Apple or any Contributor to +enforce any provision of this License will not be deemed a waiver of +future enforcement of that or any other provision. Any law or +regulation which provides that the language of a contract shall be +construed against the drafter will not apply to this License. + +13.5 Severability. (a) If for any reason a court of competent +jurisdiction finds any provision of this License, or portion thereof, +to be unenforceable, that provision of the License will be enforced to +the maximum extent permissible so as to effect the economic benefits +and intent of the parties, and the remainder of this License will +continue in full force and effect. (b) Notwithstanding the foregoing, +if applicable law prohibits or restricts You from fully and/or +specifically complying with Sections 2 and/or 3 or prevents the +enforceability of either of those Sections, this License will +immediately terminate and You must immediately discontinue any use of +the Covered Code and destroy all copies of it that are in your +possession or control. + +13.6 Dispute Resolution. Any litigation or other dispute resolution +between You and Apple relating to this License shall take place in the +Northern District of California, and You and Apple hereby consent to +the personal jurisdiction of, and venue in, the state and federal +courts within that District with respect to this License. The +application of the United Nations Convention on Contracts for the +International Sale of Goods is expressly excluded. + +13.7 Entire Agreement; Governing Law. This License constitutes the +entire agreement between the parties with respect to the subject +matter hereof. This License shall be governed by the laws of the +United States and the State of California, except that body of +California law concerning conflicts of law. + +Where You are located in the province of Quebec, Canada, the following +clause applies: The parties hereby confirm that they have requested +that this License and all related documents be drafted in English. Les +parties ont exige que le present contrat et tous les documents +connexes soient rediges en anglais. + +EXHIBIT A. + +"Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights +Reserved. + +This file contains Original Code and/or Modifications of Original Code +as defined in and that are subject to the Apple Public Source License +Version 2.0 (the 'License'). You may not use this file except in +compliance with the License. Please obtain a copy of the License at +http://www.opensource.apple.com/apsl/ and read it before using this +file. + +The Original Code and all software distributed under the License are +distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER +EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, +INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. +Please see the License for the specific language governing rights and +limitations under the License." Index: trunk/doc/archive/Users_Guide0.4.pdf =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/archive/Users_Guide0.4.pdf ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/archive/UsersGuide-v0.2.pdf =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/archive/UsersGuide-v0.2.pdf ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/archive/Users_Guide_v0.3.pdf =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/archive/Users_Guide_v0.3.pdf ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/themeinfo.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/themeinfo.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/User_Guide_src/install_complete.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/User_Guide_src/install_complete.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/User_Guide_src/Chameleon 2 v0.5.docx =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/User_Guide_src/Chameleon 2 v0.5.docx ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/User_Guide_src/install_stand.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/User_Guide_src/install_stand.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/User_Guide_src/colorchart.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/User_Guide_src/colorchart.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/User_Guide_src/Chameleon 2 v0.4.xml =================================================================== --- trunk/doc/User_Guide_src/Chameleon 2 v0.4.xml (revision 0) +++ trunk/doc/User_Guide_src/Chameleon 2 v0.4.xml (revision 1) @@ -0,0 +1,12299 @@ + + +Kevyn ShortellKevyn Shortell202009-03-29T08:05:00Z2009-03-30T07:05:00Z2009-03-30T07:05:00Z1415138626Apple71171059312iVBORw0KGgoAAAANSUhEUgAAAtAAAAD5CAYAAAAOawJLAAADJWlDQ1BJQ0MgUHJvZmlsZQAAeAGF +lE1IFGEYx/+zjQSxBtGXCMXQwSRUJgtSAtP1K1O2ZdVMCWKdfXedHGenmd0tRSKE6Jh1jC5WRIeI +TuGhQ6c6RASZdYmgo0UQBV4itv87k7tjVL4wM795nv/7fL3DAFWPUo5jRTRgys67yd6Ydnp0TNv8 +GlWoRhRcKcNzOhKJAZ+plc/1a/UtFGlZapSx1vs2fKt2mRBQNCp3ZAM+LHk84OOSL+SdPDVnJBsT +qTTZITe4Q8lO8i3y1myIx0OcFp4BVLVTkzMcl3EiO8gtRSMrYz4g63batMnvpT3tGVPUsN/INzkL +2rjy/UDbHmDTi4ptzAMe3AN211Vs9TXAzhFg8VDF9j3pz0fZ9crLHGr2wynRGGv6UCp9rwM23wB+ +Xi+VftwulX7eYQ7W8dQyCm7R17Iw5SUQ1BvsZvzkGv2Lg558VQuwwDmObAH6rwA3PwL7HwLbHwOJ +amCoFZHLbDe48uIi5wJ05pxp18xO5LVmXT+idfBohdZnG00NWsqyNN/laa7whFsU6SZMWQXO2V/b +eI8Ke3iQT/YXuSS87t+szKVTXZwlmtjWp7To6iY3kO9nzJ4+cj2v9xm3Zzhg5YCZ7xsKOHLKtuI8 +F6mJ1Njj8ZNkxldUJx+T85A85xUHZUzffi51IkGupT05meuXml3c2z4zMcQzkqxYMxOd8d/8xi0k +Zd591Nx1LP+bZ22RZxiFBQETNu82NCTRixga4cBFDhl6TCpMWqVf0GrCw+RflRYS5V0WFb1Y4Z4V +f895FLhbxj+FWBxzDeUImv5O/6Iv6wv6Xf3zfG2hvuKZc8+axqtrXxlXZpbVyLhBjTK+rCmIb7Da +DnotZGmd4hX05JX1jeHqMvZ8bdmjyRzianw11KUIZWrEOOPJrmX3RbLFN+HnW8v2r+lR+3z2SU0l +17K6eGYp+nw2XA1r/7OrYNKyq/DkjZAuPGuh7lUPqn1qi9oKTT2mtqttahffjqoD5R3DnJWJC6zb +ZfUp9mBjmt7KSVdmi+Dfwi+G/6VeYQvXNDT5D024uYxpCd8R3DZwh5T/w1+zAw3eoYKLCAAAAAlw +SFlzAAAXEgAAFxIBZ5/SUgAAIABJREFUeAHsvel3nNd17nkwzyDmGSQAzjNFURIlWrJmWR4TT7l2 +4uTedK9Op9fttfIl/0anv93+kNtJZ+XG917Hg2zZjh1LljVQ4iCRFGeQBAiCxEDM8wz08zvFlypC +AMd6C1XAPovFKhQK9Z73OdNz9nn23ilu6ZJy6+3gmR+jXy/9V/auIWAIGAKGgCFgCBgChoAhkNwI +LERVP3gdPPtfLUWKg/d4jn7wB8HvFr/mZyuGgCFgCBgChoAhYAgYAoZAsiEQTY6D1zxHP7in4Hd3 +EGJ+ERDk1FuvFz8Hnwk+x89WDAFDwBAwBAwBQ8AQMAQMgWRGICDL3AOv55d4Dn7n0nl1qwSkmGce +aXqk/vSnPx1/7LHHbn3EngwBQ8AQMAQMgcREYGHhtnEoMSu4xmuVkhLQjDUOhN1+UiDwySefuG9+ +85u5qiwdd+7WM5MMPy9EE2j97N/E6gx55pHe39/v8vPzXWlpqX60YggYAoaAIWAIGAKGgCFgCKxe +BG7evOl4qGToMRt1p4FV2kGWgwKj5sF7PCDX/KEbHh52Y2NjvLRiCBgChoAhYAgYAoaAIWAIrEoE +RkZGHMbjWwUeDB8OuHHAlf0bt3/QB4LXAYHOvPUFbmpqys3MzAQ/2rMhYAgYAoaAIWAIGAKGgCGw +ahCA5y4yGMODAwIdcGTuNwWiHJTgFzwj34B1ewt08IH5eSzXVgwBQ8AQMAQMAUPAEDAEDIHVhcDs +bLRaw99bwIXhxdE82VugF999YKYOSPTi39vPhoAhYAgYAoaAIWAIGAKGwGpHAAINHw648e37DSzQ +0aya18EH+SMrhoAhYAgYAoaAIWAIGAKGwFpDIJo838GVAwK9GJCARBuBXoyM/WwIGAKGgCFgCBgC +hoAhsBYQCAg0vPiOshSBvoNh3/Fp+8EQMAQMAUPAEDAEDAFDwBBYGwgsy4mXItBAEv0HawMiu0tD +wBAwBAwBQ8AQMAQMAUPgMwSW5cPLEejgT/lDK4aAIWAIGAKGgCFgCBgChsBaQ2BZHnwvAr3WgLL7 +NQQMAUPAEDAEDAFDwBAwBO6KgBHou8JjvzQEDAFDwBAwBAwBQ8AQMATuRMAI9J142E+GgCFgCBgC +hoAhYAgYAobAXREgPaEVQ8AQMAQMAUPAEFgjCCwsLLjBgQHX1d3tJicn3ODgkCPTsN5W8f+FikSK +kiDnZGe5zMxMt2XrVpebm+vS0tJcSsqyctNQ62Nfbgg8DAJGoB8GNfsbQ8AQMAQMAUMgCREYGx11 +3SLOH3zwgfvJT37sOju73MXmy25mZib0u0lNTXXp6WkuOzvHPfvsIVddVeX+5m/+xhNoI8+hw28X +iDECRqBjDKh9nSFgCBgChoAhkGgIYHWenZ11zc3N7t9/81t38tQp9/HHJ9zY2Jh/P+z6YlzOyEh3 +ResKXXlZmfs//vqvXU1NjX+kpxsVCRt/+/7YI3DPXsugs2IIGAKGgCFgCBgCyYvAuIjy0NCQa29v +d5cuNcvy3OHGJybd1HT4lmesy6mpKd7SvGnjRlddXe3q6utdSUmJS8/ISF5QreZrGoF7Eug1jY7d +vCFgCBgChoAhkOQIoG/u7Ox0zRcvuuNHj7qPjhxxA9I9T09Px+XO0tJSvfW5rq7WffVrX3W1tbWu +oqLC5eTkiFhbLIO4NIJdJOYIGIGOOaT2hYaAIWAIGAKGQGIgMCrN88T4hPv4k0/cURHnS82X5Dx4 +U5bn6VtOg+HVM/AJhDDX1lS7rXIYPHjwoCuVhAPybNKN8LC3bw4fASPQ4WNsVzAEDAFDwBAwBOKO +ABLM0ZFR19fb6y5euODefe8919vb56blMDg/jzwz/KgXkOjyslJ38Kmn3Pbt211jY5MrKCx06Yq6 +YcUQSGYEjEAnc+tZ3Q0BQ8AQMAQMgSUQQLaB02BLa4trb7vmurq63M2bPQ6LdIQ880fh+jgVFBS4 +vNwcV7++3m3dttWtX7/e5eXnu6ysrCVqbG8ZAsmFgBHo5Govq60hYAgYAoaAIXBPBCDPExMT7sSJ +E+6YdM9Xrlxx4+PjnlTHKzZASVGx27ix0e3bs9ft3bvPlUm6QexnK4bAakDACPRqaEW7B0PAEDAE +DAFD4BYCSDewOPf09Ljz5865kydPupt6PTU17ROmhA1UhiJrZGVlumrpnvfu3et27tzpNmzY4PJl +kbZ4z2Gjb98fLwSMQMcLabuOIWAIGAKGgCEQBwSwPn94+LD7RI6DJ06ektMg5HlSToPhSjaCW1tX +WKBQdVXuwIHH3WuvveYam5qMPAfg2POqQcAI9KppSrsRQ8AQMAQMgbWOALKNkZER19LS4k4pWUpH +R4fSdU+6ubm50Ak0IemI91woJ0Eszg0NDW7zli0+6oZZntd6z1x9928EevW1qd2RIWAIGAKGwBpE +gLjOP3/jDXdYabqPHDvurl5t8zpoHArjYX0uKlrneGB1/t//6n9zZeXlrqCg0GI9r8G+uBZu2Qj0 +Wmhlu0dDwBAwBAyBVYsA5HhOso0pWZr7+/tdp/TPw8PDkm1Mectz2DceWJeJ7VxUVORKS0tdeXmF +D1cX/C7sOtj3GwLxRsAIdLwRt+sZAoaAIWAIGAIxRGBUko3jx4+7trY29/bbb3vt87DiPyPbCLtA +kHNyslx2dpZ77dWX3csvv+w2bdrscvPyzGEwbPDt+1cUASPQKwq/XdwQMAQMAUPAEHh4BGaUFGVw +aNBduXzZXVSqbkh0n6zQc3PINh7+e+/vL1O8PAPLc1VVpdu2bbvbrZB15QpXl2aJUu4PQvtU0iJg +BDppm84qbggYAoaAIbCWEZiennI3btxwl5ub3ccff+zOnz+vZCk3faKUeJDn9PRUn5KbDINkGty9 +e7eXcGRlZ5v1eS13zDVy70ag10hD220aAoaAIWAIrB4E0D0TceNGe7u3PBPvuVlW6PGJyahMg+Hd +Lym6M9LTXbGcBrdv2+aeEoFuUOQNsg+m630rhsBqR8B6+WpvYbs/Q8AQMAQMgVWFALKN8bExd0Wh +6v7w7rvuzOkz7oYcBycmcRqcD/1eI7rnbBHnrUqSssM9+cQTbuvWra5YzoOEsrNiCKwFBIxAr4VW +tns0BAwBQ8AQWDUIEK6ur6/Pddy47mM9nzz5qRsYGFSa7vBjPUOeM9LTXI6cBjdtbHJPHjjgtopI +V1dXu2xpoS3qxqrpZnYj90DACPQ9ALJfGwKGgCFgCBgCiYCAD1enyBqdSo5y5MgRT55bWlrd0NCQ +wyrN78MupOmulsNgU2OD2/fYY263UnXX1ta5dL1v5Dls9O37EwkBI9CJ1BpWF0PAEDAEDAFDYBkE +SIgyMT7uemV9PqxU3Ty6um566Qa/C7sgzyC6Rn1dnXts3z63Z/cet33HToWwyzbpRtjg2/cnHAJG +oBOuSaxChoAhYAgYAobA5xHoks75D++84z799FN3TJkGO7u65UiI02D45BniTKi6qsoK94VnD7lX +Xn3Vbdmy1UfhMMvz59vK3ln9CBiBXv1tbHdoCBgChoAhsAoQGB0ddUc++sidPn3adXV3u/HxibiQ +Z6BLlfa5rLTE1dTUuO3bd7i9e/e5rKwsk22sgn5lt/BwCBiBfjjc7K8MAUPAEDAEDIG4IDCitNyt +V6+6s2fO+pB1Nzo640aeU1JSXW5ujissyHdPyGGQmM87dkZkG3G5ebuIIZCgCBiBTtCGsWoZAoaA +IWAIGAIgcFXZBX/15puSbpx2Fy5ecv0DA3FxGOTa6Yq4UVJc5Col3fja17/u4z2TKMWKIbDWETAC +vdZ7gN2/IWAIGAKGQEIiMDk56SNstCtZStu1dtfZ2el4Lx6aZ3TN6J7z8vLcpk2bXGNjgyuvqHC5 ++tk0zwnZXaxScUbACHScAbfLGQKGgCFgCBgC90JgTuHqukSYP/rwQ/fBB4fdu3/4g+uU7nlmZvZe +fxqT30OeCwry3Ib19e7P/+LPveW5QgTaEqXEBF77klWAwH0T6HjEl1wFeNotGAKGgCFgCBgCj4TA +7Oys6+3tdddleT6nFN2XLl9yYwpfF4n1/EhffR9/nOJlGzk52W7Xzl1uy9Ytkm9UuqKiIkvRfR/o +2UfWDgL3TaDXDiR2p2sdgWCzyHPwOlaYpCz+Ih2T3qsEx6XB83KfD+oaPC/3Of/+ooQLD5N+gfoE +dQqel7umrxN4Rn3gvuoZ9flEehl9v7G2yC3GKplxCtoswGvxc/D7h3kGl+DxMH+/0n/DyPd9Z9Ec +gDxjcHDQXbxwwR1VspS33n7btbZedeMKV7do2IZyC6mpKQpNl6XMglUKVfeKe+rJJ5VpcJus0QW3 +xzsXDvrl4udQKhWnL43un8HrWF56QW0bzIEBbrH8/nh+V4APz8HreF4/Ea5lBDoRWsHqkDAIcGw6 +0N/vLT3D8nzH4nO7LFrobr+/xIulaLF/b/F3LP456rtYyDIzM11xcYkj+1d+fn7Ub+98icWKEFeB +ZnJe9xFM1Hd88o4V+BahXfTBRT/e8ee3f9D3kHmsWFYp0vdSN458FxfIwIzSDo9PTLjxsTFfPzCd +YyG5RYAW/00i/xy0K05U6bpf2qe8vNylKMEEbfQoBaxoxzHhNMFjaspjl6xYBViwuKalCZ/0DFdY +WOgxW6d+87CLLv1mXNZY+tOI+vyE+lY8NMHB/cTimZBw3H9tba3Lyc31fYefubcptfuwMgtevnzZ +Xb5yRRroYX+Pc3Phx3pWFfw4rlWouoYNG1yN0nNXVVX5RCnR7cWYHhkZ8fMj8w59lPTilGQkhsG4 +zlRYPsb1unXrXJ7mtPT09Ee2uoMH45p2HdLGiPlvQjp23qffJiteacImS/MfSXRKSktjglUsxlY8 +v8MIdDzRtmslPAI3b950nxw/5lpaWrzH+7AWiaAEC0gw2WoFjPxKz7y6/T6vb/8QecHf8mpBpPjW +O/5v/Wv9F/0ev+DzuVpYt8nys3v3LrdRTjx5ebl6P9X/3eL/SO175dIl19zc7D4+8YknXpqfIySa +F3rliXHwHu8s3FqQ/S/4OfIi8rmlrcW3P6PPbli/3j0p6xQORltUT+obXfjsmBbXQUUMOKXED1eF +6bVr19zA4ICb1GIyPa3Uw9F/kASvaSfIT5WOtMvKypSFbYd78qknteBGjreDPvIwtwJWo+pvH3/y +iWtTyLK2tqtuQNhNCScW32TDKsAgIyPd5WqR3bChwfdnrJmQRmIIP0yBdJw7e8a1trS648ePu/br +1z2Be5jvWqm/SdeGgk3nN77xDffYY/tdqQgI5I3NU29Pjzt54oT76c9+5i5pTA/0D7pZkedg7IVV +Z2am9PRUV1pS5F584QW3a9dOd0Bh6+o1ziGSQYEAXhGxv6K55uq1Ntfeft07OmJwwAARPs0PahK7 +Z8Y1Y7damwWMAgeeOOB27d7tHShLSsv87x7marQZmSOZAy8KL04Vrl9vdz1q48nJKT8PJuO4Zg5k +k1GrDRYGhK987auPjNXD4LvSf/PZqFjpmtj1DYEVRADryZSsAjjtnD17zrWL6DHhjY6OqVZMcVpe +PMtdRHWj34v8yt/FZy/1yv+79Xz7F7xgyYp8d+Qz/k8dO/tMWTNZVDdubPILa7qsd5qLb9Uh8jn+ +p95YN66LRJw+c8YT1IsXL4pAR5FT/aGfpG/9t8DF9M7tBdm/v4hAR/7CXzNyNT4feZWVlenJT0lJ +xDKO5ZmjaOrBY1pkr0+phkdFBvr1zGvqBOHp7u7ypHBai3CEQN/60shXJ/z/vtXUEfp6+xz3PyX8 +U7Qpqq9f7xqbmlyurPGQw/stEA4IE8Tpxo0bHpuzZ8+6qyLQ9EUI9Iy3Xk3TYvf7tQn1uQz6s/oM +Y4kHmfM4kWATAjl7EAkMOGF9hsCB0yVZaSFwc/NzCXXPy1WG/pOq8QJRy8zI9GOA+5/X4GLssIE/ +p/s6L6KFBnpgYND3sdtjdbkvfsT3IY+Q5BplGsRRsLGx0W+MOTHgZAUrP3MN88ykXrNRbwF7/Xyz ++6YbGh7ybTvrT76SsZ+m+I1xf1+/J9DMT1iJizXGSVeOlRWL9P1ukGlLThH6dZrJgwySbIZaW1td +h8Y5YQjZFDN/hN22j9g1lvjzCFbMdYP9A65IIQ4r1G/AarewynlArJa4QNK8ZQQ6aZrKKhomAlj/ +erR4Mcm9/8EHInrdevS46ZnIseSd12YZ9Lx4qbfvfO/WT1BlSoSE33oz8s5nP0Q+4slpqSYlCHSp +rJyNjU2apIqXnLwh/eglL2jBfev3b2vR7dMid8MtKeG4va5FXgSEOKjAsgTt1t/xRBULCwt0tFvl +j+MbtNDW1tf7Y3ksU9SFBeOosqUReqtdiwXWFoj0wMCQl3BMThGGi+PL5CA9AT7Rz/1aOLKEc5vu +8bQIDwkmnv/iF916HXtX6Vgz2mIX/XeLX0NKziirHJZ5rPRgBnEaHBzypAVLPQssRDtZC6cmyJH6 +egckSWhxl1uuuA2n1rv9+/e7L3/5y37hvZ97Qz/KZoyxiZX+2NFjIpw9Im/DSUNCsNwh+9nUtNFL +JCCr+dIWI3GhLzQ3X3S/+MUv1B8iVkreY6yEXSCG2bKAc9pFpsHdsr5u3rLVk0b6HtKDAT3+7de/ +9iSaTUuHkrmwoZmanPCnJJDG+eBUK+wKh/D9zNF+XAuHVp3+nDl31mORk52jONjFbtOWLUvK1Jaq +Cpi1aJN38uRJT5rZ6N3UPDg8OOwNC7Qrn0H6EjHQLPUtifseWLHx69F6g0Glu+emxwqZVoUs0g+C +VeLe5b1rZgT63hjZJ1YxApATHiwOWAewPLfoGRIzMREhL/G6fRaxNE1KWHSJtYqFs6ys3BOMxSlz +A1IFYYV8XWuXxVxWXvSSY2MToRAKJkzqhzd+eXmFrx9xYTnKoz5YBpGSYEn9VGQQGcx1vWbhmBSW +WHUCvOOFaVjXGXVjfkPT26dICTeuu2yRIqyKtBuY3ItAs9lAr+6PdrX5YeN28tQpn21uYnxyVWEV +tMHw8Ignimhne252y1EtW/KFx7yGPkfWrLsVZBtghiUP6/PVq21+nI6NEZkiPmHd7la/+/kd4ztf +MizIMla79bK+M5Yg1MOy4IILpIux0ytL6KDIFiRLQyvUkpqaJgtrlt8Qb9261dVJl10tEs3mHdyx +lDKmvXVcEUEunD+vMd3r+rSJDMYzz6ul0E49vWm+r3Vqk/D0UwflUFntGjduvCeBBi+kLMEpCW3J +2G4Wgeb0ZXp6xmO6WvBC4si6MDDQr7m/0z2+/3F/kns/WK2G/mIEejW0ot3DQyOA1YQjydOa6H74 +wx8qUUGXLFw3vTVobo5FIX4LA1rR/Pxc19TU6L7+ta+5Lzz7rNu8ebM/Plx8g9SbBfeYNKBv/PSn +7orIKta42VlZNUKqN4RnnY509+/f5/7TX/6lq6ur8+GtgrpAbH7+xhvu+Mcfu6tEDRC54YhyapqN +iPMLx+L7SPafA2J34WJzxLFNfalOFvl76Xu9lV4RFk6LNP/urbcdqZlHRke0+Rn3pITvXY0FQsi9 +D+l4Ozc3Xw5q1W63Tn72yRrNRmy5MiLyzd/85je/ce+9967fNELIcaxLBjIijiHyle62bNnstmpM +v/baa95/AP0o5fD7HyjW8wcazxo7bdf85oqxHDYvhSwyrndu3+otiN/57p9oc1zmyTP1wkGQTctP +NMd8rHF9qTkSTg/9Lm25Wgvjj741N9/pfvzjH/tTwCeeespvdu52z8jX3n3nHS8vOnbsmDtz9rzv +t8yBydJX73Z/S/2OfjA8MhbB6l9/7NiE3Q9WS31Xsr1nBDrZWszqGzMEWHixAvbqWBgrAZpnjvCw +EsTD4z36RljI0BoScaNSFkycByHPix3zgr+h3khOurW4ncMiJPI8MyMHnhCIF3XjUSANIOl88cpn +kmTxx1pONIQ+WezR7FIX9JHDQyPeikp9k4HgBLg+6DP3BuTgj8QAoseGYrnC57Gkjuik4JJI94UL +F72Vvlt/T9utZqwCTCZEvih9srLekIa2TFKlXffAjJMWpBs4YHGyMaT+lSyEhLHDMTc6WqJubJQl +EwfcCmnAafNxkVSO+In3fFOW+fHxCd1b+OQUyyEnJbm5OdoM13qLeF193e2NDJE20OBzKofVGZnY +yMiot/iv9n7K/dEGzLNtV68p2kS2H7e8T3suVZBlYHm+fOmyx6utrd11qc/yN6sdrwCra9r8FeQX +3BOrpfBLxveMQCdjq1mdY4IARAbZwxvydn/vvfdEALtuH7HF5AL3+SU+xJesz7W11e5rX/2a1x/u +3rNn2dBwTNQnpAFFKwmZuHGj85aVN/bWchYLLONYqfbu3eNef/1171yEPpvFF7LYfKnZvfnmL/0m +5PSnp2+T59W+aATNy32i68YxaGBoUJFHRnSMqaN5aSkXL7YQwauSCNF+733wvrug/oeOMB6EKajv +Sj8H/QL9bJu0piUlxV4msLhefM4vzLLq/1ra20+E2SlZ7JE2INsIvmfx3yXazxDVbVu3eMnTl74k +y7MsmTU1tb5vEG2DY/53331PG/jL3jofxiZ4MSb0S8Y0m5cNG9Yr0+B/9DIF0nbzO+aY/v4+9+tf +/crPjWfOnBV5HvMnXMmC++J7fpifWSP6JE/oV+QgxnWeNhs5uXmf+yrwwpcBGeB7OklAy47MJR5t ++bnKrNAbYAVOAVa56l+5ecuHXl2hasb0skagYwqnfVmyIMDEhgMelmdkEDjEEB0giLkbz/vAisti +xhH2zp073c5du3zSAt5fXCCsODz6cHs6Uu2WFZqIBhCN2C9sEcszsT6xPm+R1RnNKtINdJtgiHf+ +gKz2p06dFJlv9XF5A63z4rqv5p9ZPCDR0zqqnV2G3NE+WKja2tq8jpeIBrTj3SzWqxmzKeE1KEs8 +ToBLOZTSv7AAorOEOLPp6JK8amoq0SMXMG7YzBLZIkNjJcOTU3S0mzdv8RZofsfYgXARTQRfgT5J +WyBisR/Hd/YiCDLOjERRYCPMeGbDHkTV4fq0DSdzZxTZ56ws47QRfTzsut1Z05X9yd+rmpFxzYP7 +D+bZ6I0xn6MtsdRf1nrCKQlSQCKSrJUSYIVePsCKeY33o7FabXgYgV5tLWr3c08EGNifiHy+/dZb +0ut+oqPTC17rF2/yzCKGNrKxYYM79PTTiru6yz3xxBPegWcpDS0T+Ftv/c59ePiwO3/+gjt/8ZK3 +3AWT+j1v/AE/QExYnIuefOoJ9/JLL7n9jz/u41ETvxarGovFz6R5PnHipDTkZ0SGhrwF30+mD3it +ZP84i0SanLF4ENZOq8Ydt+QdLEWSsDi++ctfuhMnT0l+061wg5J7xP7g4I5rJ+oPROdgk4g2eKn4 +5kg23tQpyzmFlTz84Ydei5v45DnS9FlZGdoU57gvfuE57yfwzW9/y0ufkG2IU/g41pckdfr1v/2b +j2Xd29N3K3Z7uJ2BfoqcZN26Qnfo0CH3nW9/22ufA/LMpoWIOf/zRz/y4/rY0aMyLnStOfIcjBmG +8WfjWpP1onHNhqdNm6A2hZ1kLuQ0oUMngsjp1lqJYIWjOXNgqn+sdgyMQK/2Frb7+xwCEDwcmZBv +EDYsyKj1uQ+G/YbnWSRMiWgQG0SkCVe3XEQCFjc0z2gRibyBJToSBin2FWWh5YFMo7Sk1Ouxq+Xw +lacYx0GECbLAXRYJuKqwZEPS/uJYtBbJM+hDlwnVxsKh/zx24BeUOW3a6GdEd8Ha2Cm9OCHqiP+7 +VgvwpPoQd8JsiYJV76qIyTmFEyPuNtrgZOhftDsbTGK5ExKuXk6l+AyU3XIYhHThENl5o8N1KWpN +j/Tv6MLjdW9E0mGDjg8DvhaE0gvGNM2A4y+k8JJkCPiEcAqwZotvS9qTsRx5RI9r5mQ/rrXpuK61 +hPWExEfLhgRdzUAKK4wHAVZsiqOxWo23bgR6Nbaq3dOSCDDZEY7pqKIfYMU9KWsBETd4P54F4sDE +Qsar7du2em/8g88c8iQVDeLigiwAxxRkEm8rYsOZM+d8nOCwyBccEF12Y0ODe/bZQ75+27fv8OHZ +SPKC7OC9P/zBW1tOnvpUmHYsqWFdfB+P8jMLPJq6MkUI2KG6kODhc0VkFKzatLnAKQtCHw+LJW2J +Vb62tsYnB6ENg7TenA6MjgyLCLa53/z2t+4deeiTnhkSFVZ8X8KSodXMU0SXfXv3+hi2fvGn4y0q +6FyR4PSI2BP9IR5jgQWW05eyslL31MGn3B7JB5ATBIVYz0g2jiiW+IcffiTJizaLkr4keqEfcG84 +/r7y8oteGvH6l76scVPuCtRfIciEeWT8/P7tt93hwx/4vhovyRNjKDs70+P90osvel8LyHOQ+IcN +OZrn6+3XFWf7hMIEKpLORHi40x2Rgm3bssVH96morHIZkrtEky4w61GMYULDUR8SyzCm4lGoB/K1 +eklcSG3OGMcRlEK9gkQpb/z8576/tisuPA7oC/PhbIrZlBGliQQ8BxVaL78gT/1tscxP1F3RQ66J +yJ+/eMHPf/HYeN4Nq3i01Updwwj0SiFv140rAsg2kEBgWSHJh9cdSoMasZrGtSr+Yugiy0UgsExB +IDYp4gaxVxcXJmpCSZ2XDvHoR0e809kNLcKEuAqrQP445iWcHhM1qZepG4sdxA8ScPTIUa+NJGkL +GtUwC5Mz1jxi527auNHtf2yf15TecU3hxMLap7jMOKehL+ZnCHTYBRkCyWXqRKAhS5wgsNhRiGSA +1bm1tcVv3E6fPuMtqTMhtR9YpaenKb5wobcw7tm9yzVoIyTbELu2z6AAL20cCT0YsZopo2L07z/7 +ZMxfQZ6RBkHeiEjR0NgYOXVRndCNQjCPaZN7RP0dUg9+jINYF9rI9y3161jcO/eFw22hEqMcePyA +a9J97dm31/s2UH/mIGQpV65c9pkGP5VjXrwibnB/jGn6KRFAnlWITLTPXo6l/kv4NSJufCipDEYG +LP9Yn8Mq1CcjEpyNAAAgAElEQVRDEjF8PzZv3uQjD9EXIKj+FEcXJhkUmLEZ7tCcQ5IoEgzFo1A/ +xnWW6lNXp7jYShxF3QJLvZ9rent8JkY2ezi4jir+PinXwyhBfYrkJ0P/euJAJP07Bo3owvw8oU1P +mrC9KgfdeGw2grqBFUaExVhF12+1vb4T/dV2d3Y/hoAQYPEizBrZtIhacUGyA0hoPKxtSzUARJRQ +cBuUtQ6nQcgz6U8XF+pHna/I+nxZiwixnllEQuASty/NZFgpnSbkfvOmTV7zTF0hGxxVEnYM7TPJ +ZnCUYcIOs1AfSElR0ToR5/1Kq7vLbd++/fZxeHBtCEBnJ9a9Hk8EOHZmcxR2YUFF1kJ4sqcOHvRH +4myOKPS7AXmlH/7gsJfdIN0ArzBlN+la9EnWsXfvPmW6W+927NjpakUAvM5aWN6qmD+WJ9U6TrTI +SQZVzzBIauSCn/2PhbZQ+ltI3Cb1Lxzr0N/Sv2gzwn6Rypr+3tHV6Z0uP/vr2L3iepC3nJxct2XT +RhHJgkf+ck5tsD7n6wQCaQTjKPBl8M5Vuj/CPJ5Sdjqcf9nQg3mY45mbgthztA6x2bSxyW3RfIN8 +w0fcEA7UrVVzC3KSlpZWv4EJe+MJOWWzSYY/HJNrNH7YULFRZqMHLqOab+ij45wUCi+cvOM1Z2NE +YJNHTOyDGteBAQE8qQOhOw8f/tAnsOLEBLzCqhtzIOOaU6V9+/Z5nLZpDiQJD2nhgwJZxpHx2rU2 +RQQa9I6NYc/PXJuxhAwRrJgDWddY49ZCMQK9Flp5jd8jVozrytR3RYvy0aNH3EeyQE8rUkI8EhUs +hp6Fg2gbWzZt9uGsnnv+eS/dYBKKLiwgOJ7haHRE1rjDHx52RxUtxEcKCcnKQR0ghBuVOhyielCO +jTgOUmfqQ/g1nOBO6EEqZbI3hmkJh+9hTYUQEgbstddedQcOHPC60jwdp0YX0oUT0QDLGTGVfWB/ +j1PsLZdcl7qh8YOEVVSUuUNf+IL7+jf+yOtdIVEsphDCZsV6/td//VdvSYXcT+g9QRnzEmCFzKW2 +pto9//wXvfSmoaFBhPXOBCUstMTsxhraK18AJCXo2WnjMAvkmc3FxqYmWWgfdwfkMMsJDMSJa0Pk +OR16//333cfqY0QrmZaTZazr5QmJ+jkSqvr6OjnIvihLeNMj3zpjp1j+Algqt+/Y4bNSBmOH8IUD +wvoD3dvbkm/gMxAhXeFizk1B7JEibBfWL+led2jTTsp5SCLYIo84IstzuzbHJ06e8CdKs7PhWFKp +T2RTnCHpxlZP6r+qpFHUh/eDQh9FU+x9PaSF56RkQNbnWPeF4HrRzxEZTo4P8dfU2OC+9Z3veskY +7cr1OeHqUF/94X//796xFSdLIiEtLHxW/+jve9TX4JKbm63NRpH7yle+4hp1soHDOdKbADPqxUkl +m47WlladwHEyqOQmwjFMzMAKAwfpuz1W3/q2N26A1VooRqDXQiuv8XvE0gOxOitvfhYJnLcWtD6E +ObEshjxYNNB9bpLF6ytf/YonD8WywLDIRhcsQujrsJITYg/yzFE2+rqwrBxo6aoqyz25f+bQM+5J +kZv1smBSNyZmPPM/1VHlu+++6zXPLBhsTDRvh1LAKz0txVvCSQ+7W4Qe+UalrOFIJIKjVEgqVnGS +UJySpapVpAsHrUjbhlO5SFume+vi9u3b3DPaaDwuQog1DYsjv7948aI04qe8JbXtWrukJVipIhkZ +Yw1YBKtUj9Xu3bu9dADrLlbxaKy4Lm1Ge4LV8WPHPMFHRkDovTALmzNOEWpkBd0vi+MXtXFsEpHO +VluyUbx+nQQprX6zeEYWaPCKbHBj24ZsenJzstw6kedXX33VE2dOgSDSj1q4x9zcPD9muC/GDgSG +Poq2mIx+6GQhgsSxDksDH9wHfJQ6sWEh3jOW3n16BKnmIVs4UzMnvitiz4aKDboPwxh8SYyf2XBy +YsO8xxyIlR7H6cBngMthNQWzI4oAQmxl5Fhk6JwLSfYUfYuQQTZ5Tz35pE4RRPAlXeOEJCDP+Ay8 +9bu3vKSkvf26P+2KnCTwLTHuq5Jdqbt63w/qU6ON8RbpxXFMhTwHmNHHkLiQ7ManDtdmgyRFrBVh +rnEYN5AFVZRXiNh/2WNFWERkQcxJa6EYgV4LrWz36K2lyA56e/s96YvtVHd3gJlMeCDTqKqq9MT5 +C7JYbmhouD0JRn/DrAg/iy0W8xM67j169Ngtq1A4hNUTME2GpWUlrlGWIBKmHJJGEpLKBIyMBGsg +xOaYwv95S+q4PPNDBDFSp3R/1Lx3725vCW8UgfbHliIFFBYISGmLFozDIgDErL2qemLZC3Ph4Nos +HDj0bJNVj7TM6yVJgAhAWLxuU9KI3/3ud2rDK65TbQkxCatOd2AlPf0ubTa2yGIPUeJ3QeH64IUU +B90mabE7JMNhMwSZC7N+4AIRgTTvkWMj4RpLtNjy/qC0t5xunD1zWiccJ722nkgQYWQDjVjBM0Uo +S+R7sNs9paQmVZKRFEhXGouCXIIC7hAriCB4/0FOt/SF64o3z4YlHsVbBzWuyS6Io95e9Y1t27b7 +TQu4I48IYpKzUUcDHfiExHpoe1T0H6SvQtINiPNLL7/spWxs8qILmNEn2BT/u8ZQdxex7iPyjbD6 +KNenzRjXeTrxamhY71555RU5upZFdOLCi/ZEF/7b3/7Gy9eISU5dQ6sTeKn9WDfYdDbJ8NLQ0HDH +hoM5kA3HTW1+PpJjPBKhVhmLIpv1WLfiZ60UzDn5+XmaZ8puY8XGNCD2n306eV/dq22NQCdv21rN +7xMBrIJYmQiLla6jTCYYrLlMfvEoENEc6elwsMD7HStCvhbsxcdcWBKmpNtFWwzBwZqAZntU1peI +9Tn2EyIhrXK1YEAgsDqDU5XC1VE3b63U4o80gkyNxJ4eUuILcJyXCT/2tYm0BpMzOtKmxg1e78yi +z8KB5YqFnzI7q02GjlF7enr9QkuyB3CLWPawvES+K9b/Q0poT2+dkjV81y5pjGXphTxTWMiuSS50 +Wm135bJ0pYr1HObJQYBVoxb8HdJFIh3YLHlQniyhAVYBBlh6m2UZZ6Nx7tx5r6efEJkLmzzTl7A+ +s9nAeY06egkOmzOdFhA1BWsjx/Rd0rr68H4i9LEuYIVVmBjI6H+xuCIR4HQFi3EsC2ndZ5COyXqK +ky1zDsf+E2qDey3KsagHbV+qPllQkC851m5tive6CvXX4D6JuMHG86Nb0g3GNf2DyD6xR15SLBFn +yCCOlU8/fdATaKyVtEN0gaQSfQWs2hS5hvEd2eCFa01l40Pf2Kq5GSNHkzbrhB9kXqTfcGpz9uwZ +R6rqK1dkiJGzMnUN60QQTCCimzY2+mQ3gewGeRjzD4Vr49A9PDzkxzXrRaf6NAaEyOmN/1jM/wMP +NNnrhc/mzRvlY1F3GyswXEvFCPRaau01eq8M6j179vpJkYX7Y1lbhkdG/c49zAkQuJlsOBZkIdu4 +scn96Z9+30+IheuKPtcaLKyjY6Pe+gxhffe9d2UVijiDhHXcixMKdSOCxFOKuPH1b3zDH/tTOSJI +QHCwBL355pv++Hl0FF1dOJbwABAwg+Q8vn+/D7W1X7pnSGr05MwCATm5qJjYx44fc0clR8B6FpYX +PHWjXj7SgjBDw47OeMvWbbLw1XunGTYcWPT+8Pu33fvvkaa72esleT+sEmC1XZsMjnnRiNfLGh4s +stHXZcOIdv0nP/6x0q9fFgno9xKD6M/E+jX1w/mpVtKNxx/f7/sXjoMQPCyzOPdC5H7/zh/8ZnFY +2uAwLM/BfbHw44NQqD7fI7KO9peoDzL2xaxAQBe0GWYj8JE2BuifI9bK+MV6BnccBevqar0vw9OS +GRFKj35BP2Bc46j5Sy8t6RYJA/fwxnWGrsuJTbVkCN/9zne8VZwxvrhASk/q1A2d+KVL0j1r/mOO +DnvTEWh5d2pzd+DA4/7EiyglGTK4+HlZffXtf/93vxFi7KCDDnvtoK32y2kQB8vHNa45KcE5j7al +cP2b3V2+HT/55GN3RHMglvowyTPX5foR3XOZe00yKMZzgNXiTTufX83FCPRqbl27t9sIoBkj5E9t +bZ178cWXpIluE/E66o9TIxNO7O0uTHNYeKt0XPnEEwe8FahUR4JYERZPNEyGHKEeP3bch9i7IEvh +wMCQrAl46t++jZi9YBJE60dIJMLoQVaJboF+jQWDhQynLjTPODHimBd4wYdRH26MOnGcWyJrJdEC +OObfLKslzl4BeQYnLGXELj4tfSSWeogA5DmsuNiRuqEnTfHWKTSIu2TVI9JCVXWNrxsWqg5F2Th9 ++lP3qSy8xGHFUh8WeY4sYjoOL5OmXljtFzndTcxnySQWk2eOc3Gy9M6f2jy2t1+Xs9FoqAQgqB+a +14bGBvf8FyNOjWhfKURNwQKM5Zl25PQgsjkLz3mN6xIBBWsrFmKkFJmZWbwd87KgExriO3uJzPiY +twqGTbi4CXBnfkGGQMSGnTt3eHkRllT6BadchKnDyntcfeGm+sXwCKnUwzm1YZ5j3NTX13pnaeRh +tZKUcGKDHj0ojBNObUgfTohR+iiOrZF6hTAB3rqw4PJzMRv0Usl6OO3iUVFR6ckz9WptbZGfhca2 +6oXWmPEEjmEVTmzWKdwgPhUH0D6LoLLpiybPI9rwML/g14Pj54ULF32s9LDWMu4VrOhfRNvAUZn1 +AqxKhBsbjcVrWlj4JNL3GoFOpNawuoSGAIMbKQeDvkAhq975wzuuWZm2cEyZnQ1Jk6jJBssLx5Zf +l6c54X0Il8VCxkQUFAgrEzXxbtGlYoG50tIakUqEpE0FD8hqZWWFe07H6l/+8pdFBqt8lQICfV56 +uv8hT3Oc4LCiIY/gd2EWFg7iT+NlToQSUh9Hh0RC7zcoqxQkgCQbR0XAbuqYdy4knKLvFasLDlk4 +YuGQtVUJXVjswKRHZPC0yPwnSg1PanM884lpHGbBshtghaZ+iwh9NFbBtbE4Qk5+qbTYJL5BVuId +aUNuS8hzsTZDELlvy+pI/w+kQSz+hE77N6Wypp/1qg0jR+Lh9a+gX3fq/tHxsymLHocBXrF45i4g +0ZFIG3MiguHdV3R9uZ/CwnwfV5nIMM8996yPcoKEAjLK+CEM5U9/8hNFX2mRs9mAJ4RhjWsigGRm +atxIEvH666/7EHps8hZvXOijWJ2R1Jw+fcaHM0T6FFa9ojHjVGKjNqGE99v32D4fpSSI8sNm/ZQi +wlCvEydPeW02/TTMQlKhRmWlJXzoc9p4ohfPldQl6KtgwnyMTpyTN04rMb5E0oeH289ozyqtGcj9 +mAORlrCOrEXyTB8wAh3mSLDvTigEmIDQ3cmlz4fdIcMUA39Kjj0Q2FhP1opmqkkvYuHgu7FILbVo +Y9HAaRB9HdYOLJlTU5OhHWVzz+jrqjVBo8duFMGPxKyNkEE0oSSzgNiQZANv/TAtG3QScIH8cey8 +WQsZ9WKhhXAFBQzHJCFpv97uQzWxqEWiNcS+7YJr8ky/ySFyg47AcRYkPjah17D0YYkKwlq1KKU5 +dRvU8fhsiMfhAVbFxSW3sSrXIrsYK/o0URY4ScABFB0uCy8OerHu69F40b+oI85iHO1iqaev+ZjI +asMRhU1jA9SsEI1IXuhr1DUeJBMSyXhbbYU+Cu6MIbLmNW1s0tF/jd+A0k8pOANj9UcyA+6E1YNQ +g0nsC47TzvsyFJcU+cgRzDNEtUhPz7hNuOiH9FHqQp2u6sH4CdNvILhXMCM8HP4WWKCJx8+4Dsgz +43pgoN87cxPDnXB/ET128A2xfWbMYFzBUZo5kJMuDAjRYSjBi7HC3HfzZrefnzG8sAGh6NehlAAr +HBpZK8AK7TNYrSanwQcFzwj0gyJmn09qBHBagWi88MILnkTj5f1zWebQAMaaJGJ0mpLVlkxaP/3p +T72EY6+scZ5IRKFI+KEf/su/+CP289LN+iPmkGZCFlnIINYN9NjPPfec1/Cij6RgXXnj52+438oy +eO3adXfteocnW6ESLi1kaFJZ8F9VrOf/9S//MhJLVJaNoATE57RCw/3jP/2Tl250ceyv7F9hFxa1 +zRs3uR0Ka/VHf/zHvu+waIAJ0ggser9Vmu6fvfGGCEok4UNIzefJPFhxWkAEib/927/1WJEFLCjU +a0oLam9vj/uHf/hHf1SPY+M1nSTQx8MhTJGrs9BmZ2eIlOS7b3/rW+55nSKsX7/BR9zgE5DX3//+ +9+5HP/qRYpxf8qEasUbHyUAbQLTqnrEMcnoD+fr+978va++XPOZYBymQLiKBvPGzn3n9+5VWYmyz +kQoHCqk2JF9L8fHbiWZBgg1ObgKnvOCqtP2vf/lL76j8tnwHcBr0cqxQSH1w1cgzhHVT00Yvgfrj +P/oj96TqWKh5kD6Mc15rq+LKi9D/03/7F0+eR0flZBnGXuNWtTixqZYDI9I1xjWa5yDNelDzSeHF +BvS//D//Rc6MLUqc0i5fAkld1JBhztEBViRnekGO8N/+7ne93I+5cS2XtX33a7nl1/C94wjGxIQO +r1hWTvRlyBPQYMZ6EvJkRqQByx/HbMPSX3oSr8kSIoOVAytqH1YYfWY6tIxWWIQWvGWwsHCdj8OK +HpUFIyD0RAhAy4tFiPoQ5ipMskUXpC2YhCFcWCkJG5UnvWYQLSDopj7VsOqERhIcWURIhx3r9gqu +xzMLKXVjw1VcUuwqAy2ipEBcF2zACxINZmQni5CScFgJmx/wAit09eXLYIVVHCcxZApYp7CiYbln +cxQWYRJawouThFT173x/0kP/KpKzbEDiSDGMpZF067Qh/Ys2NPIc3ese/DX9IiMjU+S52OtTSXmP +L0Om3qMPM67pm35cqy+MjuEwGO7YYYNJUp91av8gNjBjifoEBaspEgkiWrDZm5QDXETGEyJLvXVx +6oe1nvnfhzHUPMg4B0uwwcGVcY2jKXVk4xfWXMOY5rq5yoqJdZfwk8yBrFHReDHfMG54IN8YHtJ6 +MaMThJDJczRWxOFn3QSrtU6e6UpGoIPRbM9rBgG87iEgOGmQOrZUVpv3FUPzXWnJsH7EMgoAky6O +OkMKNUSaYo7ANkkC8MJLL3ly8+tf/9qnhMWRCkc9Ju8wCusWYaRKdJz6Fz/4Ux+L+sATT97OAMZi +9pas8TgMvvf+B16HGLaGl8UhRzreMjnCEd7vr/7qr7yEgw1NdMF6dl7RNv77D38o3fOHsgq1e4IY +Jrn3eKlv1NfV+gQGP/jBD7xOPLD0ssBypPt76Tb/8R/+QWmnu7VJknQjJFLvsfKEZJ175dWX3Z// ++Z97ecRirMAEOdD/+1//q2/LZkUyCGQu+lVoJehf6LJff+0V96z0t/sff8I1NDV5okJEFyKT/EwW +UBw/W2UBHRMxCbMNQ7vZBPpiiFd2dqas/PW+TxCujuyO60Sm+R1jB20xGUQPy2cAfX6QBCms26Cv +NkjDe+jpgz4CCPGecZ6OJlxsiIlbTF/90f/8kQ9lOCILb1jzX/S9Yk2tq6vxOvEf/ODP3MuqHzIJ +iCLjmge+KP+qUxLiPg8NjaifsuGI/pbYvcYBb926Ap0oPen+z//8n72kDkNCNHnG6RUJzt/93d/5 +aDUnT52+HeEnLGLPHYJVVVWFlwWBFZpsnzBK65gVI9DWB9YoAoRv8xOXyPNGEVoc5crLyr3ndxA6 +KRbQMLmxKEDMsVa26NgtNS3d1Uj/2Stije6PTHqQCRa7MArkhgQBRLdAV4czF6HOsFIxQUIEsViS +kYxjQSzh6GTDLHjmk/0Q6xR6P2Kuoj8kPjYLf1DArl16P1Kak54WqypkP9yFNhKmiSNVtKRe86wN +VyBzoU0JoYdWHWLf09vnTy+oUxiLGXjwAKsNajewwhLEor8YK/oSR89ojIkYQLxfrOJhFvoXD+pH +gpK6unqfJKhAkgI2qFgVifV8SVKXdklJ/DG9CFS4bRjmHSfGdwtykdLIGEJfzLgmpBgnXJAvLM+Q +QfwY6BOcRoRNniGh+YoAgiV1i4g8KbrppwF5ZnzQHzh9CPopp11kGgx7MwUmzHfZism/vn69zwgb +1I96UzeszuBFf8WgMaawomGNa+rD+EWH3bChIZJlUFpsNsWLxzUx732MedWLuYc5kPUijPkm6N20 +GVjV1da5HTu2+7bELyU4sQw+t5afzQK9llt/jd87kynZACEjk5JOQCLRiZ6UhYwJKlYGB83LWhyw +RPf6lLkXRSQgzsR8JmRTh5wY8dYPq0BWifV8UBo/vOHR+kGks7Nz/H22XrnidbwfyUL1kcJbjWrh +DbswOefKWrl9+zb3vT/5E9cgAkAWq2Ch5fosqNeEE2mQyZSGdz7kK2zLODKEIsWoBaOvffWrSvzw +tHfmCeoEAfhAmQ/JNNiqcIj9igoSccaKVY+5E/2ILCJXiVK2+frsVIQSyCrHqEEJsKJOZ4TTJ5+c +dNdvdHiyEnwmrGf6F8fhe1Qv4ug+/fQht2vPPpctqQvHy+fUx/9dMXSPHTuuTGmEZxwMbbMY1j0m +2vd6Mqh9JhuW5+XHgG52h7DHGY5+QX8gCdM1OY4e/uCw+1gZRPtkTQ1704K1cr1ObQ4detp9WWMH +S2o04eIkgogrEFV8BnBwxcobIalsCcIrzPdYegmL+c1v/rHikj/uGjT/M+dARBnD70if/z5ZTRUe +jnHNWA+LpEbIfKY02Bvdf/iT7/rQmDhRI1+jfYOCTvxX0onTntSLNN1hSsW4LtcnmgtYfelLr7mX +dGIKVoxzK58hYAT6Myzs1RpEAA91HmSf2i4nMfRoWBWZOIkZG6vJk+8hy2DvLCHX5pSZK5LQAHkH +1mdIdhgFSwbh14j33KTjdI53K8orRKgjToM+AoikJTg6dnZ1uj5p6yD7YRYmZxb5IllasFRhgS7T +woEVKHrhYJFA78fCgeU+HpZx7hvMKlQfrL0sGjyChYNTBKKSYK2/ePGil21wHB1WDGrwgIAEWCH/ +wcrIe9FWqgArQsNdutTs9a7E7Q67UD/ajfYkoQxWRxwc0dZDiqgXUTaaNabYDOEgy3tWHg0B2p44 +7hAcwmSyMS7Tpgq9OW2CdRKSytjhNALfgQmMAiENba7JRqpUFsrNiqCzadNm76gcRAAJ7pa2R7bR +0dnhfKZBaZ+nFK4uMuWEVLlbF4ewlkjaUqMYxowjrPaceFF3dM7DMqC0yFJ/UaddRCthbgzTKs64 +IbIPDt1gRsSaxeOadYhsoZdl5CCLKJtP6hpmvYCL/kXfYkPGuhGNVdCW9mwSDusDhoBHgMQYTGAk +DvlYcZghuSRaiKXFBhI9OytHEGllJyYv+etGnFPCawQmaaxUjZoE0V2zcBBTNChMxqcUI/itt9/W +Qtt5izyHu5CxYK0X1ps3b/IWy/UiqBAw3g8KJwBE2WhpafWWZxa2eBBCrk9YqxeFFdINHIzQPVM3 +FrMLysp4RYvZBaU17+wi/JosVEGlQ3jmujgL7tu7x2OFpb5ERCmaPIPVTUX/8FgpiQsbwPHx8Mkz +t+vrp80GDoPPfOGQO/TMIUmD8vzGk80G8iCkG2RA5AQmLJlSCNAn9FdyekM83q3a9O/bv1/P27wk +KxhD4My4fleRN27IyksITeafMArXZJNOvGdOa7717W97ORZzz+JC+LU33/yFlxdhEaefhk0GgzqU +yBH4kPooYRUJwYall3HEHH9O4+Yq5PnCRT8PIikJC6+gPpWSrO3csU3Jbnb6+ZlTJUh+UMCFcc2D +0zc2xv5kNKR2DK7LM1b5pw8+rTjPOxxzToBV9GfstRFo6wOGgEeA8E88sNpgocBrnePGmBJoXYlJ +mRinPMIswUKK5RSHSWLDop3FokBhcsaSSipltHVXddQ7MhL7KCRL3SN141GQLw22FjAikbCRQEJD +ASOI/Y32617/3CMvfZwwF0J0guO6gVWPUFskTCEWNVY93qdOsyIhWKYIO4gVjXqHXcApTVpxsEK3 +jxURnBZj1a36oBXnRANNadhrbNC/WPB9RBCRAaz2dcoyR6F/4bxIFAMsoDjQjnqdazgkLux2SJTv +B3f6IxEbyFBXL705sZWJF8z7FDYuRKmhTxD7m1McHKPD7BNcG9LF5pzxw7xD+y8uWMKJL98pCzR6 +7BkR/bALEqi0NNVNmGFJ3S4CzYlOQPAZ153CqlkbPTADP4hq2CVFFvs8nX5mCjeuR+ZFHkFhE3RN +EjHWJGI+I90gWYoC1gUfiflzgBUnGQ0ybGzzJ5afPx2M+YWT9AtNwpGkDWfVDgcBrH1kWUpTmlmc +cCC68TheDONusAqRnvapg0956Ub0cSpxgtFFXpF0A6sQEzchxeJRIKPIMdpFkMdk5SdxQrD4c32W +B+rHwo8mnRBsLP7hLRuRu+b4tKZamw1tMpCVsNhiGaewwA1rw9EsvNDIc5QajwJWtA1YQTggyGiL +gxJghaW3tfWql0iESZSC6/JM/wIf+ldtjZyftAENCkf1pIo+L4s9mmzCRHIvVh4NAa+bzcqUjKfK +HdA8tf+x/X6TF3wrpOvsLWuqT5zjdbzhYw+xJzU30YQwOuCg7N8LKnbrmbF++fIVfzIRS+PEosvc +8WNWZpaigJS4hsYN0htv8nIXEoBQPzbuEGbmwU9lsfc68TiQeirIvNah0wEcKic1XoK5Jqg8EkI2 +oD6hi04tfbi6kGdBMkSWylJfVlYq5/qN3sF+cezuoH72bBZo6wOGwB0IYEF5TMlOCBsEscTih4Nh +2LrgOyrxiD9oXZA1CIeZQh2llkVSrsrBiIkwKKRyZtH44IMPFOHisibp8HTYwTWDZ4gUcgyye3V2 +d7kLFy8Ev/LP/B4igDacz5EoIEzuxUKKJZy4tZBm9KQNeq7BWq/fUR8s4lif0fGellMcdYpH4dpk +pfRYyTp2TtY76huUACv6KW0IGQgTKwGi6y/4DQ9ORmid9+17zFvsiQJBwemJkw10z++8846PnsJG +NNx6BaaUU40AACAASURBVIis1mdwj2xaCCPGidJjIs9PKpkOsYyDDSiWfzIN4uR6+dJlndyMxE1z +Tl+8oDbnJCSoz+LWQM/bJV8LNlRzc+FtqBgj1IENB2S+UX1z65bNnhTW63UglWC8oNFns8HY6ulV +KFFhGI8yqXHdpfCXOEZfFWafjerI1WlLoqjgNB1xvA3PwBHglaPN+XqdIhGlCbkfmVeJVmVlaQTM +Ar00LvbuGkUAfenjBw74UFAkHvj009NyKrnkrQRMaIleWGR5kJXsK19+3YdHIjas1/zdslxGSNmU +O3fuvDvy0RE5Dg7GndxgVcVK6cng4pVDIIP1nCzipMTmOczC0XNpabFrbGhUdkbFyJaulH7ggdSF +IfOfyur83nvv6flTWXlHvB46zDpFf/e4NhFd0kGywkaT5+AzHiststQzljHMg++Pfqap6F85ij38 +8gsvebnT3j17vGMjRAWd+EeK1f2+sCKu+tWr17xVPCwny+i6rebXqDPSRQZrJS97RXGL9wjzvdLF +k+CHk5Og0AcuyNns8OEPfXhFxljYhfkkQojn9TznHWuXu+a8pCST05JtSI+18DnKuNxfPfj79FHC +6SFz2bVrp3v++eel592pFNSbbpNnsPpYpySn5PNyXj4NPb392qyGm+Y++k7wsSFU3nLjGmMz42lB +WFHXMAtyFjKcbpLV+SuKnnLgwONyCN5i5PkeoBuBvgdA9uu1hQBkCq9ojs3wPkZG0Nomi4qsaiwU +PBK5YHXJyEjzlsHt27aLONfKCq0Yxoq6EU2+WFjJAIYkIF7SjQC3yII74xeH6DoFv+f5Ns5gHv2L +mL6OWFORIpDFDaxwmtm8afMdCweLFzpeLPZByLrb9YtpfT7/ZdFY8dul8Lpdl1CxitQNYsJiixxo +48ZG19DQ4B3GvHxD12fc4GR5UqSko6PLy3MgV+ELcCL1W63/o4MnJi8xgnE688lS9DqaPHPvbKbQ +xyMN4OQsXgU5Bg+caj0jXObCTJ8QwkgJZ2QTSYkxTRz3Oo3pxsZGt1enimBG6M6ggBX64kvSPvOM +nCNeshLqQNIl5BuUpcY17wdjO3jmvVgXro1FnnjdaOl3y6F+z569GuOfOZvH+pqr5fuMQK+WlrT7 +iBkCOGtxfE/WJWQPRM0g6D/HbSQYCXMye9SbIO7qpqZGRyawZw49o+gIJS7Q+wXfzYTJA7KdKgeb +FCzrwZoWfCjk5wDD4Dnkyy359TjMINsgLNy3vvVNt0vEpFKbjcwoi17whyzKWADBLN51jr5e9Oug +bvF8JnPkzu3bfPjBg4q4wFEv/YsCaSORy5kzZ3UcfkGh9AZvEZJwiFI873slr6Wu509IdinONg/I +IBIO5DOLiRf9k0yrKWn6I/2LVwn6JQR5pTdLJJLZIktzk+bBLzz7rN9wIEcgksTignSLcR1XsG5X +AoNM5IcAv9u/itMLiLPfaGi9e/75L3pdPfHEg2Q8capG0l7GCHTSNp1VPEwEmEAeU3goLNIXmy9q +TYiEn0OPhpVipSa85e7Zk2EtBqUlpXIsesxnJduxc9fnLFTB33urg3TSxKOe1bGqc+HKJILrJsbz +Z3pSnCwbGxvcCy+84C1UkJLFBayw9OExTzr0tVh8f9Fiy0kGUQwaZHnesWu3J9LggZWezIxY81pa +WhUn+8ZahCnm98wmL0NzUJ2cNJ94/IDbI9kGISmJGLRcYc4iCga687AlPcvVYSXeD+ZA/Fj27N7l +tm3fLlL4vHeEW64+4OTHtebBxZuR5f5mtbzP/dJX0NQTPYeU6yTk8ZkQ/aZitdxpePdhBDo8bO2b +VwEC5QrPxSRcImJKHFuO+uKR0etBoUN/ivf0DsUVPfTsF1y5kqXgSLhcwfJSkF+gcE5FbmB+yC+2 +y312tb1PwgewKS4ucs8990Ufj5o04oRuYhFeXHiPDGEbRFzOK8kC1mh/FB2iuGRxHVb650g4RGWZ +27DePSXLMwQ6TxrToLCpJHU4KdcHFWHFyqMjQL9jjBJxY6cI4d7H9nkyuDhaQ/SVIEXEMS+WJAk9 +8uzMmJsLzJzRH1yFr3M1folHvmFDvTv4zNPeGRgHy+WKH9cVGteSeBTJMThdmxVELxFt9uo+NWEO +xPrMHHhIJ5U+Nras0MyBgYPlcrjZ+58hYAT6MyzslSHwOQTQQ3/p9S9LF10tp7tz/riL0GtEGsAK +vdKWaBZMHiRL2blju3tKXvkvvfyKnwg/dzNRbyBTgTTW19X5hTaSDXHl7yeqiiG8jFieyeCWn5/n +7/1rX/uq9zRHxrEcMWFBQdKzY3zMnTxxUg50WT57WtgpxUMA4IG/kr7F/ROHepucK1loX3jxRR9T +PPrLINDt7e0+xu/AQH/0r+z1QyAA7mjNOSEhic7Bgwf98Trz0d0KpLBEpHG9Yr5PTk7roWx63hFt +9RJCsMKSWlS0Tv1zi9suy/MXn3/BJ8a6F1bE0MYf5MjRo94STcIZ+jKqttVaImM63Tua19XWuNe/ +9CV/+kZCK05erdw/Akag7x8r++QaRoCjfY636kQ4sUT39fYpu9e0yGe43tF3g5yJMBOHLlkCGzT5 +PXPokNf7BQkC7va3fAYyhNPXhBZZwiUR2i5sb++71Sns3/njcB3Vkvhjp5wFIRnEfMZqxQK8XAFn +jszJSrhB2nKSrBBWblCxl70lepVa+HTbfsNYIitVbW2dzzLXIGtddDjEADN91GtJPY78oZWHRiAY +12yK16+v9+HqGKuLHQaXugCbHdqIuWpK0S4Y0zgVMq5XerO/VH0f9T2wIi669/3Y1KQ++ozSYm9e +djMcfT3+lnkd40jD+g2uq6PTtSic3aB8XmYWwItPr66NB/ecpTjiJJLZp+hMTRubfCKeYkUdup/+ +FY2fvbY40NYHDIF7IsCkUyeyRYpaJBzHFPrIa6IV/g1P6pVamLwMQ6GHOOLlGO573/ueT2ZxNzIY +3CwLx9PPPOMXj1EF9O/v7/POkrwmBnawbKzUvQX1fJRnNZtKhMxxZJmTky3yl+927d7pvvvt73gL +/CYlTOHYkjZermDVK5VzJp8jRvi4QvBhsRq/1OwtVfQBCl79yVw+wwAHUyfLs+5b4f22b90mC9UW +9x/UvyAqSy60LMxKqoIFKyM9w+OZzH1nJdvRSzcUhrKpqUEnSk+6V1971eueef9ehbH/5JNPusaG +Rh8DemhoQHPUjI8Rftt3g5Oze31RAv7+s/4ZiVrBkMWAUKYkKVu2bJQc6zn3jW/8kXdsRXJ0r8L3 +EaFonWRs+/Y/pkQl825CsZknp3S6OLGg8Rx54GGdrHtkMPpsDkyVNl7h6tS3du3a4V5XmFOyre6U +Y6olS7lXb1n698ubXZb+vL1rCKxJBLDsoDNmESK9KdpEwnVNKgA+jjrxJk/Uh1BiFZUVbr8mfyxU +BSLF92N9pgFZPPLz8n0cWeJET05OuIsXm5Us5KbPEjY1raNfLSAzsrJTkmkB4d4gzGRGAycWjTyF +ZCKpTENDg3fEInoEmwgW2uiF2d/sEv/xmXQt1hv091j0xpW4hAQDJDDp7Oz2OCHriSy6yUOkI+sr +WCHViOCVkSHHqrwcb6UimstehbQiSQqWesjzUnjxXpDBsUUZEbOEDWmaGS9W7h8B+ivacjKi7tNm +bZccNfMVCYj377cwLyDjIGwb47dA8d4Z1/Rbxrl3LpxHppAMNJq+ST3VP7WBIP01G4nsrGxFy8nU +aVKFj0W+Z/ce+X/s9HPgkhu8ZcCj3zJnEi96XHNonwwJ4N/d3aMNyLCPCz0xMe7n98j+OBkwi8zv +kTmQcZ3uT9iI80zEnK0izbv37PIbjUpJgtiELDWml4HM3o5CwAh0FBj20hBYDgEsO+zS0cn+4M/+ +TIktut3PfvYzEagJrzMMrJDL/X0s32eyy1E9ykUIX5CD41/8xZ97J7f7sboE9WBBLpAlYnPuZq8F +fuWVl93vfvc7d/TIEXdV2fa4P9JXB5ntkolA4wyEkyAWUcgzZKSmusZrSJ8XXjgWVUr/jQ78QYgJ +CzORWUjIQKzUy4o4QdKK40qJ3tvX5wYVM5xEDEQ1SRbrq7qSFk/Fdlb/pv9gQWZj0djQ4LWkbMxw +Ggz6/nILLdg8IcvnehFtpC3EGB8dHfd9KFmwCMbGSj2DLSSnUo5tB5TM6ft/+mc+Fv1y2vzl6klb +0Y7f+/733OjIV92vf/Urn6a6RaE4CTWIbIsHG/9kGNcY3sEGosc8DB6chFSL/JFQBs3z/scf96dE +92tAiMaOOeApacwZ20TuuCYZxycnTrhPlZac+Q/nWCQw03LKTJa+HIneoihLwouoJOs0ppEfYvx5 +8aWX3AYZEEgWxZhnHrTycAgYgX443Oyv1igCTEhY2gj18yU5X2DJjISLiq+ljYWCo7gGER2C32N1 +Wo7c3K2pggmWReR2BkYRQbIw4lwDiaYkw0Ib3CcWqjRZqrAQQ6SxPpdqsaiRwxBOQyzAD5ueFpzA +er0ss8SLLhIZRxuNhhxHzBmFDuM0IjnsVBHyLBufjwdOPNyARPtoBrcWWfr6vax69D1IG9FKCAkI +RiSmYGwkC+kI+s9KPhNJokAOrk1KJ08bLBcZ5l51ZAzQBswT+0QMSXSzS5u+HqVYp10Y17RLMoxr ++pb2eLdPSOijnAYW655w/g1Ok+7VR++GWRrEXP2f1NVIvYqEPd+LhnxAcyFjOpk2xj7KhvoA5Bhc +chW/fV3hOk+imQcxIjB/PYgB4W74rdXf0S+DBwIrHoiHiDiOO2b+3//9359+UV7XWCXotI/SSfV9 +VgyBpEcAYsmEypE9lpzIQhRfysSiwuTHYsJCy4L5MAQ6aAzugYV1XCQQa8usvNFJvxxvaUpQn0d5 +DnDwC69wAhuIBA9IXoDdo1zDW6TUD+gLPPjZE2dPSuLbFx7lPvhbT0+0CkTj5S19WmBZgO93c0Yf +mpdkY1zjYtg7WCZn/3lUPB/l7/3mT5izyQP3R11vaRPIMnMVchqfGlpz15weyVQW91HmPjZ8jGkw +YkMcCzKIXpxNH+MZ3BjTYEYBy2QqwXjmOehXYMXDW541L1r5PAKMFeROhON855133F//9V/v1qdG +9SBt5IQe6BoZQPNmgRYKVgyBB0GAyYfCIgd5XQ2FSZb74WHl3ghAML31XiTHSgQB+hCWPCQEPKys +PAK0CVZsHlbujUC6HGB5UDAaWlm7CNzPhsm2IGu3f9idGwKGgCFgCBgChoAhYAg8BAJGoB8CNPsT +Q8AQMAQMAUPAEDAEDIG1i4AR6LXb9nbnhoAhYAgYAoaAIWAIGAIPgYBpoB8CNPsTQ8AQSF4EvLOb +nIN4nsEhVM8kj+GZwvv87F/7/yMOdrxEUxo88zqVh5xx0P7ixMTr4DP+g/afIWAIGAKGwKpEwAj0 +qmxWuylDwBBYDoGJ8QmlYidO8ahrabni+HlsfMyT6YmJSUUriKRAxgPfJwIRofZe/wqJh9c/TkY4 +kvqoHgo5Rpg3wuSVK7Y04a8IF5ViHu7LwW/vGwKGgCGwKhAwAh2HZmQhJtwZYcLux7MzDlWK2SWw +uBGNADJB2CUrn0cgCHnGMyFyKOC2GgoGWchlZmbW7X6w0veGVZnQU9N6+LBdCykadzwUd0jpeseU +4KO3p8+Nakxe7xxU6L4IgZ5V1raJiakIgb4VwgoCzZglnnTQz9NuEejMjHSFxZtxw+MLbnw6zU3O +ZbpRhc0eGZtxGcJEtuzbIfOIy8rDJ3hRBjW+azVZqsFoaGhYob+mbnXriKU+Uft4qrJUEnEmIzNd +Yb2UTEJtE4/iQ6QpIQch0qZnZnXJ5AmNRn8l9jzJicBrNfXf+237GbXZwMBQ0oX3ZI6mn9N2PK/F +trvfNn6QzxmBfhC0HuKzWLkgz2+/9ZY7deqUt2hBOlZDYRASrqpCyRNILvLyq695Ir3SBCpRsIVU +sHnqUiarC+fP+4xWHxw+7NPREo+YSS2ZC+0PESEr2HZlrKtUQpemzZvjHtovgjNJIYh5O+FaW1pk +WW5xrWReE/YTE6lubCLDTUzNKkbxlJuZS3Ez85kK5Jnuxuey3LzuIZKVLdJeEbKd5bmNvhUarPsM +4iWLOKRCjKf1mFHClinFox0SIe6SjOOCy0oVeVao0Az9Ll2fydViVV6yzicyKCnNc3W1ZW7LlkZX +VVPpxw4Lmv9mvj+JJwaI8//3T//DffjhJ8IrW49IqMdE7N9+3srPdQef2Os2baxXWuNNymK3LvSq +shm7eOGyu36903109Jxrvnzd97vQLxyjC2RnZ7n/5T/+sbLZNSq9eI42j2so5KX2ORPa9LS1dbj/ +6//+Zzc4RFjg5CikQK+sLHb7925SZst6t++xncrpQZoPK4+KgBHoR0XwHn/Pok7xCRdkgcYCSfpn +iJXXXN76/T2+JiF/zTF1oTYIuhnFGc11Qwo8jlUnTwl3INHJTAhiAfiEkpIMKyB7981ud/3GdXet +vd0TukhyipykJdC0Kw82ALR7gdIPz89HLLVogunz8Wj7aY0nEkJMK302CxoEZUTW5ebma8L6ptJs +X3fdSkk+Nh4h0OOTM55Az4viLqTmuoWUDDefVSLmutRpwFLvBb2CMR1YDslAqWx7DsurLNVzYy5t +QQTaTbo0vZ+Xk+luFk8ou1yOKxvKdxPTou0569z4TKqkHhMuJ0sWIZFoLKF5uYrDnSPinoQF7Ds7 +e4V5q5tLyRe2iRt3GOtp8bpCt6F+0FUobfb0NJbg8MvCvE4qxiddf9+wa7ve585f7lTCjvhmMH2U +u8zLy3H9g6NuRidp3MtaKmyj55X6fHxixl1s6XJ9/cNJc/uk9R6T8aC2qsSVl5UkVZ9LdJCNQIfc +QhBKiMbevXt9mlsWdCxkpAidkdbSk42Q6xDW10OSMjMytVhqgMrKfuHCBVek9KoNjY0+cD+yjrVa +aNfOzk73yccf68hvwN3ouOElA7X169UfIrKXeB0bx7oN2Bylpaa7Qp0+1NXX6fShxjU2NHqLau6t +TH+xvubi72MDCq5Dg0Pu6tXr7uzZy7Iyz7iBkWnXMzApKUWa6+lL12a11E3PyuI8JzqbonS8mSL6 +EGaRZyzLC7oXLMCxKSluPlXjQdR5fiFb30rGtzQ3PZbl+kWYeyam3XVtMi91X3EFue2uSByzICvF +VVcVy2qf73bsaFL64Cq/+YxNfeL7LXML6W52PsvNpK9zs2mJm4SCcZebpk2fHikQ/ZT4nAT5bde8 +TjuUv2w6pcBNpJYKp+TJCJiWmq3NERu8NPXxu20w49vv4nU19gyzOrWaTCtxE2mJe8KyGI90rTdT +KYUamzIYqP+p8azcBYHA6HmXj9z+lRHo21CE8wISyWP7jh2eWLZfuybykeYX/1FZKCMpVZO/Rw/L +En3p0iVZdCpcfl6+Ky4t8anf2TysJUkHxG5kZMRN6qThWlubO378uN8soX/PVArVqupqL+GIFWUL +p9cu/a1smHhkZynNsDKblUu6s33Hdi/hQMaBrjeswqSGhhxNM5rlKVmdr13rkEW/y3388VnhfNb1 +izwPjom0ppW6hQxliNRiP58SOWZeUL39mh/yugeBpgR2RRmcnYzizumRsjDrUjqHXMqlYZeeOueK +0idcYeaC27q5WpahdS4tQ5ttPXJziOiRqiPyHK+Z9l+Y8P9x8iACvZCpjUqem0ktStgaQ6CnU/O0 +2VFa97Qs9en4EGg2agsLqSIxwsnluum0IuGVPAR6RlgtaDyBF/PAWiscFs+r/aZT1+kR3lwXa1zn +1d/pb2zc6H9I1KzEBoHk6QWxud8V+xZINJPO+vXrfR28TrP1qpdzeEclvfsgO58Vu5ElLgz9h9yQ +P97LUnSfVVVVrrGhweXm5fpj/rUw4c4JA04WsDq3XLni5Rvj2iSlqe0LlBaWUGfgkKzTV4bqz4kD +0SYaNmzwFmd0z8EpyxJdI2ZvIYEalPX2hvSjn356TkfJI66rRxbn4Ul3o2vE9UzJKiTaOpcpaVSK +nFllZfakOZEWetWFseLHiyxBo7OZbopF+caUu9Y/6AamzrpT57pdfWWuKyrIdHv2bRHWxZ5Er4Xx +E7POYl9kCBgChkAcEDACHQeQuQRWWEJf8dimaBVZskYie4AUEA0ASzTaMkoyEulZ1X9MVlciH6Dz +hjhmKHIBFml27txvmBZKD9wK/cfmgU3QoCQFEZJ33R356CO/meCeIdC5ssqnyBKQSHzufuCC7KN1 +5yQhP7/AyzYqZG3euGmjJ9B56stousMqbEoYH8PDI67jRpc7fbbZHf7whLt2vVsW5yxFv8iQtTPP +zaYWRMhpRrA9CZ7DqtmDfy/EOShz2kaNy5FRKg83oo1AqpwOO3vb3afnOt3GmhxXU57r0jRXbNUf +FUo/jcNW5DQn8e4ruCd7NgQMAUNgLSFgBHoFWjtdhKq6psbt2rXLdXd1ycHshrdcDmLBFRGFjHrW +uQJ1e+hLiiVDECCSkOe+3j53SWxxWHKGmppaV6RYucUlJZ4EPPQ1EvAPvWRD5G54eNgdO3bUXZej +4KwwyJEW2GuFRaBpb14nG3n2cKvSOdLxF4g8V0t+UiO9c76cRNE/I0kJkzyzkeRU48yZsxojN93F +5huutb3fXe9Jcb1jhQobJy2p12OiZ5bFOQH7x92qFNQXbSWP4ck5NzWr8X9j3nUPKwxf6mV3uW3U +bdlU7nZtrxaJzvWyjqTsR3cDwn5nCBgChkASImAEegUajeNYwr9tky4aUkkEA3SdeGTPyoI7oqQO +3gqdhCslhBIZx+DwkDyWx731cFaxMydlicb6Tvg2SNdqOJIm3jCSjZ6em66zo9OdOHHCnT13zmuD +0TpjMfSSjSRrx6BtiKiRoTYrlPyksrzCIcnZ0NjgHUTDPk0ItOQ3bnR4ycbpMy3uzIVud3NQer7M +MjmAlXiJhmS3KsltlQ2I9PTcgpsWkx7rn3adAzOuf+iaO9fc6zq6ajVu0rxOulqnGJmK2BE2/isw +LdolDQFDwBBIKgSMQK9gc7EIksFsy7btCsU1pdiaBUrCMOrOnjnn44Om3DoaTyb+5cmACDSSFBzn +sCBelTMdz5xXl+r4v7CwyBPpFYT+kS+NbONqa6u7odODS5cv++cpEeqqKlkKFWMTvTMENBkLtcZi +jqW5TvG9cRDkFKFcIb/8Bki/C7NAnvv6+txv/u037urVTnemuce1d4663kk5p8nJbkHRAIjdvNpK +ZOxEHBDZhPaNKbHLrGKFNHfJ2WzBNdYXuce2V8oRtUQnAVXaoK0+DFZbm9r9GAKGwOpFwAj0CrYt +lr5sRTMgCQnaYSzR6GgvZV6OWKBlbaJo7eR//kuasoAlWrVFzkHWLWIiFypeMCUrM9tbMSFpyViI +BIHOu0vym+bmZsW+vehD1pXLoa5MkSm8VjUJyXNgeab+OAyWKCRhjSzpFbqvGvVRdOzBZ8JqN05e +cBjskOX56NFjru3GkLvWnS55Q6aiayj0WLqiaiQhtg+KF6N9ckZ+EXPTbrZjSNkTp+SUOuIKs2cV +1SdVpxxlLpWMYsk5hB4UDvu8IWAIGAIJh4AR6BVuEggJx+SQlorKKpdfuM49JcnDiHS1ZFODTExM +T3mNZLLZMyEBaKKxKI6JQJNIZETh7iYmp33WOiybOdpAhE3KYtnEtMfhDz7wFvXr16+7mzdvemt7 +oTTeOdk5ilKRnLGvaQM2NBlKU12jCCqlCkNI+9TV1blcWaLjRZ6x6J8/d941X2pzzVeVcnso1Y3M +5MhJEMszYbTWDmNkM6Hh48YmZ13X/LhLadPPC0oWoxjX2XmFrrQk35WVrvPOqbHs4/ZdhoAhYAgY +AvdGwAj0vTGKyyfQBZdIzqG8aJ5c9usIe6CvN0I4Rdq8GTrZGLTuBRINEUAr3C6rYm//gKy3k94q +TfgzHslEoJGlvPP733vi7KOmiHgWFSsRRklpRLKRhG0UdPCMtHTFeM5SMo96t2nTJi/hWCcrdLwK +/aRdmyzS3re0D7rWTsmA5nLcfKYibCRR4oJY4oVrLk6poxNz7krHnLtxU7HjFWu5TslX5mbmXHFR +gWJKhxcFJZb3Yt9lCBgChsBqQsAIdAK2ZmCVrpQlMA+L7fSMTyAxp8yFaCMhGsla5kUGJiTpIGpF +b2+vJ884VOJgyH0nHplWCldZ0EfVDsgKfPY76bmRpRBdg0gUgbNgMrYJeKfJ8sy9lBYVu3WypEOa +aQ903PEqyGLGhPGAUuT29k+4oWGFBnTK6ucTFqwdq/NyePuNqMj0nMb+oOQc124M+r7XuHFObWcE +ejnc7H1DwBAwBMJCIH4rZFh3sAq/F+fCEkXnePGVV3ys6Hd+/7YnF739/SJuSgEuBzZIXTISabTe +HR0d3kmsq6tTkQXK3Nat27xcgDTQgVQgEYg08hMkG0ODAwqldsb98z//N4Xn6/VZ5kiMg7yhtEya +Z7TcSWh5RrJBXytaVyRLZpHbtn2bI9IGunwIdLwK/bhHUphzimBy5Ph5d+REhxua0NSU2+AWJClZ +S7KNu2E+rwgdU5JwXLhyU6dTY27/rkHX1FjmSpUGPL9A8bjph1YMAUPAEDAE4oKAEei4wPxwF4Hc +QCjJXjgp2QNROkbHFGNZ8g6ffEUEDyKdTAWyhDWNKBajo2M+rXlHxw2/UWDTQFQSyCkkbiUL4QSJ +y33zZrc7e/qMNLmXfB2R2gQWc/TbpAVORvLMBoUoG/natNRU1/gNDPiDO/0unoU+QZ+GQN/o6nOT +CzgLymHRSxOScGcSJngaPJOSbgyMTrrOvmFt7K66ask5duzY4HJzI2nLw7y8fbchYAgYAoZABIH4 +rpSG+gMjgCZ1x46dXsKBw1q/rNCtIpg4WyEjmIGQ6pFsBV0nDoXcw7g2BZBRstshUQmSdEDyVsIS +jeUZicnV1hZ38uRJ9+abvxR5HvWnAsXFRa6iqsaTfCJVrET9HrWtsVTi7FiuzUql4nM3NTX5KBvI +1rlJ/QAAIABJREFUOOJNnrkX8O7q7nYfHP7QdQxku9mMMpciAh2Rbzzq3a6uv2ekk2ylf2zKXWm7 +6d5+Z8bt3F6vMIOl8ifINCv06mpuuxtDwBBIYASMQCdw4/iqiURmydGOSB2kxcbpDpKTqxTKhFEj +vjKaYkhIMhVviRZZRtIxPDrixicnXNaNbB87ukROeVO6p0LJCrCSxpOk4rx5Q9E12q61uVOnPnX8 +jONgVla2W1csC63wz85RWmVZR9U0SVOCzQh9p0r9iHjOdfX1XkJTdMvyvFI3w/5vbHzOdXZNuMGp +dJ1QKJJJik1Ny7UHY2dWSVcGFCf6fNugy9Dmc0dbh7T4Tic4xZofTBO9HHb2viFgCBgCsULAVqlY +IRny92A1RCMMkc4ReS5Qdrh0rZhwOKxSxFumJJs1mvqi6cYi3dXVrVi3w27gFoGuVAziYMMQNolG +CsODDckpWZ2J7fz+++/7mMPliu1MNr5iEWjkJd5p0KOdHP/dJs/qL7kiWxskCSoWxqSTx2FwJazO +0cjRB6YUaGZgJNWNzqW4+Sz1apPzRkO05OuJqXl3rXfK5XUMuystXS43O0Mb6xxJjPKW/Ly9aQgY +AoaAIRA7BIxAxw7L0L/JH72LQEOIIB0kt4A8p8qqyO+mFa0Da2mEUodenZhdICD9k7JCz87O6J4W +Ik5s4lFIO4pE8tg0hEmikcZ0dnZ6B8cLSo7SI2dB5CQ4CEKesYRnCXsiUySR4dljBuFHS4+jIPdB +shcwzdNrNigrWXDSJMLJ1OSM2j5NMbWxngrhZDLvrxCAROQYn57XxmNaUTmGXUXZqEIQJtdJ1ApB +Z5c1BAwBQ+CRETAC/cgQxvcLIJFYQSFCGzZsiJBLkUy00oRY6xWBVvJfVQpqnTwFEk367wVZo9Ef +Yw0eHx9zMyJYSA0amjZ6y29Yd9Ry5YqP79wtnflZObPlibA3bdzonerWiUBDnJPN8gxW9JesjExX +pAQ927Zt82HqqhUeEWdBNNwrXSaV0bH3puKdj4ypxyLdEIFmg7jSFUuG6wskXIiHR2fcpdZhV1Yy +4nbunE2GmlsdDQFDwBBIegRWfgVNegjjfwOQIsKM8fAaYVWhSPF7O6WJRps7OTXprXqekIqYJksJ +SHQgpfApwGWVHhmDXKV4K3S1ZB1Y2x+1RAi6Mt3J0twsucZHH33kTp8+7aODiMGJMGc4rgXRDNPy +/aj3sdzfe8mP6k52xLq6Wp+kp7Gx0UcQQT8fCwyXu/b9vk97kxIdzXnvwLCby1TSlnmyDSaTjf9+ +7zakzwnDsYkZ16J030XFvW5ba7fmgHm9LtDpTVZIF7WvNQQMAUPAEDACneR9ACJULqcwNNEc02PB +7cXxTU54C3LQ84lXkukeRQggUBBcCHSftNGzc/Misal+k1BZWRkT8od0AEv3qRMn3M9/8Qsv3+C9 +QsVE3qgsfEhHskQ+k5E809xIT7CcI9XYtn271zwTfo/Ti0Qgz9QxINA9yrg5PC7pTqbycM4i33j0 +DRLfvxYK22PC2t0cHnftNwddS2uHy0qbVZKVDCPQa6ED2D0aAobAiiFgBHrFoI/dhSHOOIKRRY5I +HZBmolvgWDiqBxE6IKRJUyDRqiwEy2tkZYHGUkzs6N6eHq/bLdS9Qm4flODyHT7jneQubW1t7uzZ +s173zPtkFQRLcMS672M8Jw1oVDTFR2Cg7jnSNtMXINA4DKLjhjw/KF5h3/6ccJ+W7IhNkkuVhCOV +ljcL9IPgPifsJgXbkGJD3+iSJTpf6dg3mJTjQTC0zxoChoAh8KAIGIF+UMQS9PPocyurKl1xSbGr +H94gPfSgJ4iXL1/2SVdwLoSQJkuJrun4+IS7Ptnpunt6fSbAktIS98KLL/lQfpDC+y1sIrrkKAhp +PnbsmHv77bc9UYZgriONtchmRka6f+9+vzNRPgflRPlQJKJM4h02AXv37fP3wqYg0YhzgBt9cl4p +6hfUNvOymi+kJNFGL7iJFX5mrLBpvtk37j462ekGh+fcxi0NTj7GVgwBQ8AQMARCQsAIdEjArsTX +pkr/TLzi3Nw5WZ3nPYmCSPkFVgQlsEQnFZH2pF9xb5U8AgI8ODjonflGFTsaR8n8/AJPDu8mS+B+ +kYPwILoGqcRJSsN3FYk8E2cbyQYRKe72PSvRpvdzTcgxJxBZ2kwUyLkUPTwWZ2I9s7FK9BK9WUr0 +uiZs/dTHZ2aVAEixoQeGp+QDMekmxhW/3CdXMYt+wrabVcwQMASSFgEj0EnbdEtXHDKFkxiWWSyP +FRWVrr39mrt29arP/Dcg0kjM5WQrWFchzBOypPcq5NyHylrH5mD37t2e+GI9Xs7KOiM5y8fHj3tn +wSuKtnHy1CkfVaNRTnVIHErLyl1mdpZLTUtNKvEA95sKeU5TchRF1tjQ0ODKlF2wtjaSKTEZyHOy +9cNErS+bkMnpOdc9OKa+7dzHJ5vd7NSI27WrSQ6k6xK12lYvQ8AQMASSFgEj0EnbdMtXHCsq5BkC +hWUVh8IZEc8cJQmZEXnGEjsrUpmUUTqwJuteSGU+MjLqiSP3yIaBUHMR7bKkAPocjz45VGJpvqhI +G5+KOF9rb3d9IuAVioVcogx8EG9iTKeJPCdNEWlmP0EiHdqZSCwQ6Pr6Om99xqq+3GYiae7RKvrA +CMxyyqS40INK893S1usKslMVirHOyTXTiiFgCBgChkCMEbgngQ4W4uA5xte3rwsRAYg0hLKiolzH ++bmuX45zkMxBPXfLGW9OUSeSsfgIHWi6h4dc86VL3gI9L8lKlqzIRCTBAo9zGgk6jkvrfP78OT0u +ePLMpmKr4iHnS97A57xsI2LeThooIuQ53Us0ysrKXEPDBr8hwPqMHMXGatI0ZcwriiV6ambetXWO +uhzJuZ4eN2fCmINsX2gIGAKrFoFg/eQ5eL3czd6TQC/3h/Z+4iMQ6HlLRKx4EOpuXsSSpCvjir9L +DN4p5VCem59LLgdDWZanRP6RZlxtafWxmrO1UUDzi9WZcG0jIyPeSn3ixCeSexx2Q8MjbkwRSTYp +RB3SjfsZHInWwl7FokGdqcQoOUrZXCHpCcl0tm7benszkGh1Xq31SUuNyGcgrD6CSALd6JSkHNe7 +JeVIyVCGwkFXXl7oTysKC1c262QCQWRVMQQMAUPgkREwAv3IECbPF+BY1iQCWVJS6gkXjnQ35FCH +pIOwd5DPZCrUd3JGRFobgMvSNkOKj0vrTMSRlqutrkuJZXCcnJEDIvrg3Nw8n7462Fgk071SV+6v +SHGqScldXVOjeNUbfaIUNgzJek/J1gZBOxTmZLpsRWwZm551I+PTUucnzthBytEvJ8K5zgH3q9+e +ddfbB9z+fevd3j11yQi31dkQMAQMgYREwAh0QjZLOJWCZEGiSbIByURDi1V2THGWSSqCcyGkNFmI +NJQFOUcQnYPnEd0HKc1bWlpcZ3e3dzTknvNFMsvLK5IwtrNCI4s4e323dN5FRetcmfTbpTpRQPdM +9A1zFgxnvCz3rWoOV5iX7Yr06FUCk9EJEejE4c8aD4qfvjDvhlWvy9d6Her+ivJ8t2ljmSRd6T5U +43L3Zu8bAoaAIWAI3B8CRqDvD6dV8ymsmGh/y6SLzpUuOlUEDALd3NwsScekpB3jSUOgaZSA7Afk +P13yhty8fFe3vt4VKEpHtrIJIndA3pGenvgh3aI7Gm1FyVAb+WghcnqsravzOu/I/aSb5TkasDi9 +ZkOzoabU1VcWuUvtPT7yxfxcAjFo4cC44OSlvWdYtvF5V3Ux11WVZbma2jKdXpTGCSm7jCFgCBgC +qxcBI9Crt22XvbNUWZ4hZJCwDGmH0UL39fV73fCMNNKzkkX4FOCJZFZb9m4ivwjqmyYrbb4szmwO +KiurlBU6VSQzLSmjbECgOSXA0bFcFudaZcaoU5IUHCWxOpvl+R6dIqRf0y4VZQVu15ZqNzY1485c +6fKEdU6W30QqWKIHxyZFn+dcc0uXqy7O8E7FlZXFPmRjItXV6mIIGAKGQLIhYAQ62VosRvVFzkGE +DpJuEJFi7949nkhfvHDBE+kehX8jvXVg4Y3RZUP7mqCeGG0JSZeqtNDpItNSDks7HNplQ/liL9lQ ++xCeD6lGvazO1ZJrkDGREHW0m5WVQ4D+VFqa57ZsrpSEY8xtuFzo+ke0CZXuOJEcCtFlQ+rHJmdd ++80Rd/JCjyutrnRbts+5TDlBBiccK4ekXdkQMAQMgeRFwAh08rbdI9ecBTRTETmwQpP+GV30gGIk +E1N5SFEsIKXz6KK5kl4nln3t7reflORA7QHXR6Oelan4zpKi1FRX+0gbxKzOU7xnNM9WVhgBNVJh +QbYrK8tzlSV5rqYk3xPnAcVfTsSCvKRnYNJdyx11g6NTbnpqVn0sTX0pyXaWiQiu1ckQMATWLAK2 +Gq/Zpo/cOESTBzIBiDMxkscUP1lveW10T2+fD3m3IAc9SmDpjfy1/R9LBNKxOkuzTYbFquoqVy3y +XFlZ6R0/sUabZCOWaD/adxHGLjMjzVXKOe/ggXqX09zluobGfDrtRNtozmnzOzI54673jrhmyU2O +FWW6DesrXGNTpWnoH60b2F8bAobAGkbACPQabvzoW4dEY92sUXi0acVY7u/rdUPKXDgux0LC3CVf +8u/ou0uO17QBDo+EqduscIN1km5wOmBW58RsPzaZZaUk7SmRRGLIZZAKXm8m2iaT+kwo3N6AJCaX +r3S44ox59TFipicmrlYrQ8AQMASSAQEj0MnQSnGuI4Strr7elSrLXXaOMhhK1tErTTTP6KKTLQV4 +nOF74MuRBIYwe+vk/NiwocHrntE+o+G2+M4PDGfc/gCyXFpSoFTqme5a15hrqup1bSLSENVE0kIH +gMwoW2dH37g71zbotvSPK/a7kirJV4D7sGIIGAKGgCHwYAgYgX4wvNbEpyFt1TW1PglJjgh0iRzX +kA8Q7g5rFgTaSuwQwMoMxsg1Nm/Z7J0FIc9GbGKHcRjfRPvk5svRM1thE6v6XV15kRsam3ZDSqyi +QRLGJR/pO2dn0UJPuDQ36PqGJjyBzlQymLQ0I9CPBKz9sSFgCKxJBIxAr8lmv/dNQ6IhCKT/5jVx +liF1JCnpVgZDHA5JpZ1ox9X3vrOV/wR0BWwhzqVyDiyXpR+9M1bnfDkK8r6V5ECAduTEpqT4/2/v +S5sjya7rLoDaN9SOfWug95kekpKGmvAWsuUIh21F2F8U4Q/+c/qkMOUIy1oskbRozlBDcpbmcKb3 +DUtjXwq17wX4nFfIbrCJ7ga6q4DMqvtmsjOrUJX13nkvM8+779x7A/Lh9RGpHjZkO1c01wvDyNmp +8FqtNlpCZ8fnaxn59ptnMjubhlQojfFop5pqXRQBRUARsD8CSqDt30cXVkNDoEHomHiFESCYAW9z +YwNxohuSR5SOHLL+MfufkujTdxExJVexyPOl2VmjdU4jTJ2VHOX0Z9NP2gEBWnCnJqPwsAV5zhfl +zpNNqSA+dANGaDvFrmGs9CorVa7JvfsrMlDOw2nVA7+HpAn9aAcstQ6KgCKgCDgFASXQTumpC6on +E5GY6BCIAkGyTCspraVeRO0gcWYSlhqcDpVEv72DjLWS4cOwbJ5GMpQUU3LD+szYzoyywSgoWpyJ +gN/nxrURlkQME83hABxvW5JByDi7XResTwth7bKFqiyv5yWTr2IlqWUmdYNwgtSiCCgCioAicDoE +lECfDqe+/xSXqSkvYLg7WqO3t7bEhxjSuwhzt4njg0NYoh0VKfp8u5TkmfGdaWXmJOT6jetmz4yQ +tPBrpI3z7Y9O/hr7NggtNPtwdiwh1yZSUgeBZui4Gi2+NitNSEtWdyqSzdflk70SfBvKIkGf+Ia8 +NqupVkcRUAQUAfsioATavn1jq5oZ6ykIAkkCLaVekGdap5kVrwApRx3pv2uqiT6xz9rkecjEc2Z4 +ulg8Zqz4jPdMHDW+84mwOepNl2tIBgMDMj4akptX47JdyMvybh7XhP2aQW02HR1L1QFZWd2TRw/X +ZHZ2BI7DSqDt11taI0VAEbArAkqg7dozNq4XCV8YYddmod9tgTRvrK1JqVxuE2jUW/2RXnYeyXOb +QA+aMHU3bt4wFmfjLIiJiIape4mV848GJBr14bqISGrJLx7XoJQhmTjEGLBbaUDGYSzR6xm5fx9p +73FNj4zGMR7tV1e7Yaf1UQQUAUWACCiB1nHwTgiQ+FF6QDkCk69kkXSlBD10C+G7WgeadoWgWsQ5 +FAoj9XPYaJ4tqzMt9/y7lt5BgP0ZDPlARGPQQgcE2b4F80qpG2dCe7WTWmj8LxmEs3sOLfTkVPlI +r61j0l49pbVRBBQBuyKgBNquPeOAepEwxOEE94M//EPZRmg7hrirVGvYkEgCJLqfH8XEhpMMn9cn +aTgL3oDmmXpnaqD5vpJnBwzwM1aR86FIJIg+9svc5IaMRwalUTmQncoQrocznuycPr6TqciDVlam +58pwEj6EnOicflh/RhFQBBQBhyOgBNrhHXjR1aeGdxDEkHGhRxCKrYjwdpsg0wcwu5FAMxKu3SIR +dBszEmTKXAKIrJGIJySVRrQNWOppsVe9c7fRv9jzc2WBlt1w0CPphE/ylZrs1fCGzWJCWygVyg0Z +lIrsZsuSy5XhKAxnQkQU0aIIKAKKgCLwZgSUQL8ZH/3rWxAgWSRpiCEhyB99/LHsMMnKV19JNpuV +BpKvMPQdzK19Q6JpWabVORgMyOjIqFy/fk0iwxGJg0hrpI23DKYe+TMt0cl4EIlVxiCSc8vzXEYa +zaYtY9TkK3AmhKfj0+Ud+e7OssxOp2QKmwv6bS2KgCKgCCgCr0dACfTrsdG/nBIBkkZKExji7hCE +eRjZC5lspcJshc0WsrI1jxKu8IS0SfdmGYTVmc5YxIKpuWl5Hh0bNbiYqCVkVlr6AoFYNIDkKgnZ +KzTFdy8rUHHgGrCfIbpSb5qVor1sSVZW9iSEcHaTU8m+6CNtpCKgCCgC74OAEuj3QU+/+wIBkmha +WCcmJ+U//tmfyX4mI0uLiybt9xbiRBeK9kxv/KIB73lAacboyIikoQmfnZuTmZkZE6KOCWe09B8C +l+ZnYMkdl3jqmTx8tCWrW03ZLBxKgXIOGxXjTIj6PFvdl7/+6X2pHQ7KzQ+mEapSxdA26iatiiKg +CNgQASXQNuwUJ1eJRDIEC2wLS9YB7Jlhz+/zI050Q1qI0tFTBZMGs9B9NHmg5pltpgWaYepokdbS +nwgwLjS3YMAvYT/08F5k9CzTk9BeBNrqnRqyEeaQObGE+NB1WKW9Hjf0+rpiYuGje0VAEVAEXkVA +CfSriOjr90cAhDKEsG03bt6U2dlZyUEPvbOzK1999aWJ1EH3QtIIfMyxhRZ3bszGODM9JaNwoJya +mpY4nAUpZVHy7Niu7WjFk8mQ/Pt/e1MeLe7KT79cl+xSFudvj/+O/tB7nqyErInL9bx8c/+5/Pgf +fXJ5YVSuXpuE46smV3lPaPXrioAi0KMIKIHu0Y696GbREk3rsxV1ogo9dBNOhRVYoQfhWOVCEhGn +F/J/OlEyugbjO0ewMcEMibUWRYAIMKLFGBKU5MpNRObYE597QBoHA7gW7GWJbiJ+O9wVJJevyOr6 +PpyCwzJv19h7OrQUAUVAEbABAupqbYNO6Icq1EGgV1dXZXllRYrFAqJyHJhwX45u+5EVmm3ot1B9 +ju63c6x8ABKOmblJmYMeejYdlJEIJpYg0XadYu1mK3Ln8Y6sbuYhu9KESOc4VPSnFAFFwGEIKIF2 +WIc5qbpN6KAb0D4X4UDIJCt7e3tmq9XqdpWCng1ek80NmRdhWWc763XqR+vm9dlOpJ/uVQR8Pq+k +0wlYoWMymvBLetgrPg+08TZdpcgWanAozMrmbgmrRQ2M65ZODnt1cGq7FAFF4L0QUAnHe8GnXz4J +AVpjy8hhvPb8OUJjrcjXt2+buNAtxPEKR4ZNdIq2hvikbzvjPbaRLmGcDDxfXZN8oSiZzL4JXzcz +O2sSp6gO2hl92e1aUuaTSETkwxvTUoCUI/vdlmRKBRPWzm4rF4wJzTo9XdqVb75dkw+uH8j4OK9Z +fVR0e5zo+RUBRcBZCOhd0Vn9ZfvaMnEK5RpZWJwp1/j2t7+Vzz//XPYQ1m5iYsJohT1wvLOrBe4s +AFPFSl33PpwkSaDzubzEosPtLITQRbOdDO2nmuizoNqbn/V53TI7m5Y9aIzvrRTEs10SRr4AV7VV +aSFjYhEkejNTlAePNiUADXcqFVICbate0sooAoqAHRBQAm2HXuiROtBylctl5btvv5ON9XW5c+eO +MAY0HeyG4DgYRXIRhrjzIESWTVewz9YTaC/5D9t9eNCQAtKYt5A05vHjJ0JrexzZGZOplInKwWyN +WvoXAa+RcsRlZrIkM+k1XBcZ2ckfIAugvRi0Gcuo0tZeQe4+3oDlPCi3quNwlHUbh9n+7UFtuSKg +CCgCv4uAEujfxUNfvSMCfPBWq1XZ3NiU39z+Wh48eCD37j8wab4XLl+WyWkmZ/DgIdwO//aOP2Pb +r5FK1xt1aSDzHCMaMHHM+NiYDGH5njGhOXkYwDGX87X0HwJDQ4OIbDEsk+NVuTQWkt1NPzJ1Hkil +fiAw+tqu5EtVube4Kcl0SP5NYUFCAY/4/N7emPjaDm2tkCKgCDgRASXQTuw1G9WZxJmOc7u7u/J/ +/v7vZG1tXRYXn0k+X5AxEMgYiGM0GjPkmSSil4vhQcCjUq3AAt0CMTqUBizSkXBIkogPzQQrs5fm +VdLRy4PgDW2jlCcWC8nNm9NyMDgk+63nkqvsSR3h4jhW7FRYp1y5Jstr+3L7m+eyAyfIWx9NwBKt +Kyl26ietiyKgCFwcAkqgLw77nvhlap4ZbWNjY0M+/fRTyeZyJupGIBCUKaSzNvINxITuFx0wJxSM +ykFrvNlXysAgIjWQ6mQyhZBml/oGi54Y4B1uhM/nkbm5UWN5/tXdbXEh25+JFmcv/mwkSNX6oWRy +FXnydFcOGodI8T3WYTT0dIqAIqAIOBcBJdDO7bsLrTmtzgVYmTe3NuUh5Bq0OtfwHhOnxOMJk1SE +Fle+7hfybHUISTQLQ9uVeIygv8SADlrP4VjpQ4IZ6qPdPZBMxmqz7k+HgMs9hAlVSFLJiCSH3YgL +PSBbOYEW2l6RHTlsKUvKFyvydHlbDgcOpFypGwt0r68kna4n9VOKgCLQ7wgoge73EfAO7afVuVQs +yRoSo/ziF5/Jj370V4Yoj02MGblGDATa4/W0yfM7nL8XvkISTRrdBInO5xAL+yhKB99MpdMShi5a +CXQv9PTZ2sAJZTQWkXSqLHMpl+QSA5BKgEAjNLoZMGc7Xdc/nQWB/u3jNam0MBksVyFHQhxrWNH7 +bVLcdaD1BxQBRcBxCCiBdlyXXVyFSQopTcggIco2oms8evRY1tc3jH7T42qn7vb5fOKBZdVYni+u +qvb4ZeDFWNGGbOCYFnomlKEj4RqilFAfztTfjNChhMQeXXZetSAJnRhPIvxhRRb39yRfRap7TEwP +bOZRyJTjpVpTcsWarG/m4BQ7IKMjMQ1rd14DRX9HEVAEbIuAEmjbdo29KkarM8nz4rNn8ovPPjWh +2n71xRcShCV1Zm4WS7sBZFwbkUE4Cg72RIy6zuFPSzSdxEoVkKXlZXkOR8tHjx/LJOJi3/re92R0 +dFT8kHWQWCuR7hzudj5TPB6Rf/enfyQffnRFVrI/l2IJyXiqmKDajkAfSBEkem07L3//9/dkYS4l +//k/fYBrPWJneLVuioAioAh0HQEl0F2HuDd+YHt720g2lhYX4VT01IRpo/WUIdoY25m6XmbeU+58 +Qn+DPJNEsxhZByJzcDJSQrbGTThf0rJPa7QPiVc4IVES3caql//lZIlW6FDIL9GgWxLhQWkcDCC5 +iv2UHBy9TPqysVvA+PRi3CJcY6N5lCSol3tJ26YIKAKKwOsRUAL9emz0L0CA5I5puW9//bX835/+ +FJKNdVmCFTU9MoJwXDdNWm4XJBskfVjd1XIKBIhpHdroTchgitCScz81OYGkFUmTrZGTESXRpwDS +wR8hgQ5g4omALbIw4ZNm0SfVZweSLUP0g/Fht1IBs//m6aqUWzX5070rMgwt9HCUTsK9HZrSbv2g +9VEEFAH7IKAE2j59YauaMAQbiR4tz4Y0Ly2ZrIJVpOkmwWOaaso2jNYZZEDL6REgrsYSjfB/pVJJ +fAWf7EJXjhQzBlvLok89uZbeRsDtdpmIHNVqWpYzu7KWyUILDcmPzaQclCCVQaKz0Gxv7xQlHPCK +n5tf40L39gjV1ikCisDrEFAC/Tpk+vh9EjympS4im97/+Mu/lC++/FJInGuQHcQQfm3hylVxu1xI +z+1SS+l7jJMmJincmO6czoWr/ueyBUlHCtb9+YUFkwL8PU6vX3UAAl7IOP7kT/4A8dMh58l9Ls83 +ipKttqQOn4OXwp+LbwgJfRVZE3f2K/LzXzyVpWcZ+W9/PqwE+uK7RmugCCgCF4SAEugLAt6OP0vi +nM/npQpntwcPH5rjHWQY5HvUN3PJmdZnxndmSm4t74cA8WZhIhpa/FvYM7RdC+QpBH05U3/Tys9N +S28iQKlOOBIyk9HRVFDSUY9UdqvIToj22kzJQSt0pd4Ayd83dSsUq4gi40UUGXdvdo62ShFQBBSB +NyCgBPoN4PTbn0jgGNt5Z2dH/tdf/7UJV0cMmE0wCEIXRHZBE3JNyXNHh4bhSSAn1EVnYImuwNrP +8HfZ7L5MT8/I5NSUidDR0R/Vk9kGARcmp17ETR+N+2R+3I/03oi5XMWkyjY1fFmRWr0ly1v7UoMj +7F4mL+GgC6tSGpHjJUJ6pAgoAv2CgBLofunpN7STltD9TEbK0OPev39fNjc35QnCrGWzWRNiLZFI +SCgSQcQAWEVhMVPb8xvAfIc/EX+S6AFa+CCTaWAiI4cHUkEacK/X17b8Qw+toe7eAVwHfIUv34AO +AAAgAElEQVQrDS7IoSbGonJjYURWMw3ZzTcQ+QJxoTEw7GSI5urIXh6ZXwYOZWVtX1yoeygcdADK +WkVFQBFQBDqLgBLozuLpyLPVYPH87NNPZQvE+bNf/EJykGykEZt4DHGKGaaOxI3Ogirb6G73WkSJ +uugConPUakhPNzhkJjLj4+MyNT0tfhBpNxKvaOktBBjN4sNbCzIympTl3Zbs7FVlu1CXapMM2hoZ +F99mVqUOL8dCuSG/+mJFni9nsUKSRAhGdSS++N7RGigCisB5IqAE+jzRttlvNZsNWDkrxmHwyZMn +hkBvwImNGfOmZ2dNumlG2yB5tnuxwr5Z9nHadC2Nsd3r/mr9WO8G5BzG2gcN+iGsfmGsAJSKBZOk +hhZLE/1Eg26/Cp1jX3P8RoZDxhKdTIQR5cIt2UpTak1Ew7FRq6zVkjrqtb6ZlwOQ6QokJ26X23aR +Q2wEm1ZFEVAEehABJdA92KlvaxIfgnRaW3y2KD//+f8z6bi/QFbBOojzBPS2DJ8WAWEjeXaKXYmy +EpIQWsu5HE4pBC3rTi0kTcz+yAnOFkIJ8nhzY13GxsbNNjwcAeEa1igoTu3gE+rN2NAer1vmJyKy +dzku5cYO0miXMYHCZNBmk6UGiPPDtW1YyYuyur4niRjiWFexYqJFEVAEFIE+QUAJdJ90tNVMy7pZ +KhXhLLgtX3/1ldDqvIYEKbRqXr9xQ6LIimeyClpfsvHeaLJBLtyoO4kzJSeuI2sYo1vQeksyynY7 +rbDOXA2gcyFjce9jYsO2+aCLZrp0RurQ9N9O69U315f9mYj6ZWY8IvdWcrK2W5ED6I3tNno5odvL +V6TeOkAM86IMHiL0HhwMMaNDA9VL4s29rH9VBBSBXkBACXQv9OIp28D00Xu7e/LgwQP5h3/8BxNt +o9GowUEwLB//8IeGnIVh1XQKeSaJdA25jNX5+z/4vgn3Fo8nZAgkZGVlyZDOXC5v0o6TiJJQO7Ww +7kVkhGQadTp5plIpWchnhe0dgV6dxEuL8xFwuYbk1vevyMylCVnd/yfEB8+Y7ITZqst2JLoJ8lyu +NuRnnz2RCCQnW3sNWNCHpTmoGn3nj0RtgSKgCLwNASXQb0Ooh/5O2QYlATtI3HHnu++kCCs0ndMo +e0il0iYGsTEgOajNJI6MnZxKJo1FlhFD+F6xAOIMZ0g64lHOQSuuUwst0bRADsDqx+Q2jNPN0Gf5 +XBLZ4AKOtK47tS/Oo97RGEJGhgIykghIKuxCsp2m5KBGstMiimURp05/c7sgBe8QrrNDrGJ5YX+G +z4T1gfMATH9DEVAEFIELQEAJ9AWAft4/uQMN7dOnTxDjeU1+/cWXRrJBffMEpBoj6bSJ7UzLl1NW +XgcHBhHezWt02jeuXzfh9cYwESCRZpxqFkasoEaYk4QCdJrLSEW+C4c8ZlQsgIQ6sRgZCmY4JC2Z +XE7uPngIffSO7O7sShIW6YkjDLiCoMXZCHAiOzk2LDevpmVopSjrhZK9GPQRvC3os59u7CGc3YCU +K0NSG4pAr4/HihJoZw9Arb0i0KcInEXuqQS6hwcJBwJlGysrK3L/3j159OiRfPbZpybr2fTMDBKk +RCWMjWm5nWB5bjsKtmPmUuscjUZl4fJlSDf8JtnL8a4keWbkCraf8a0bkHDQAp9HivISpBAs1HE6 +rbBPW9hoiWa7uNEizbbEgAcdQL3YLG2409qn9W0jwJCRYyMRKV5KSb6OVZYnpbYzIWa5duKmdHDc +2i+Z8TaEOsONF0mAWEM71VJHVacQaLUOIYVDfHIH3jvfBwOmsq8jC2ezwRj9zhzbVoSq98Ghn757 +GiKtBLpHRwQ7n8lR7t29a5KjPHj4wFhgE8kULLZBiYJg+kE8qRd2SqE0w+drpxKfm5s1pJnk2bI6 +n9QOOhaSUI6OjRknQ1qhyyCcTUg6KO04zUVy0nnt8B5v4wx3x0nBNlYZaIFn1khqonlMMq3FmQhw +ApRMJSDfAEHNHUossCnw2RNEtrPd85vXkKEUmI9ykutQfnEuA4X9am65DvSzZL/mMQj395ngyYUV +wP65v1AKuLy0Lquru7gm7Zgj9G3DF/QZY09J9NtwOtvflUCfDS/bf5qWATqcVWBl/RKh6X7y4x/L +02fP5DlSdMficfnoo48kAOutRZx5Udm9mAsf9fR4vJKGVCEWj8nHf/Sx+KDd9vtffxPn90gkuQWD +QZmBrOMZnPBKsN7mQDppkebNkJg5kUizzpwMcMtC7726tgZN+4QwTnQQ2mjKOjjp4KbFWQhw7M4v +zEKKNCFVWKB//auHspE9kLU8Vk5s9PwmcTbkGWMRRro2gXYW1OdWW7OCRis9rkcn3HdfBYZOo+ub +WVmMBOAsOogVQIQ5RXvaW2/dZ/hssJ4L9VpTMkhb/+tf3ZPljSxWM53njM7x1n4WkEi/2rP6+l0R +UAL9rsjZ7HskU0aiAG0sCfNdWJ4Xsd+GxdXl9uBhfBn7tjWW5NkpN3DWk2SQjo5hhG27du2aibbB +126P+9S9wPO4QKQTIJXXoJvOwDq/jrjKjNKxj5TlvFlyc1qxiD9jeEMlK2trq+JBP1PiwjjYtNDH +E0lHJMNxGvbdri8fdPRNGElH5MbVUTlczMkWJn8tEBlDWrtdgXc4v13r9Q5N6fxX0J+Uy7lxfQ6A +eDqt1EEcv777HJlRS7K5syNrz4dhhXYjEhAldFFJJOnAPeSYZ8tJ+JsEViDP29tbcEQvSqlUheV5 +FwaXutx+sC17uapZFTrpu7Z9DzeSQWQ69Xg9xpikDLpzPaUEunNYXtiZSKJI/qiFzYIM3r59W376 +k5/AgQ66SfwtnR6RiclJQ6LMzZtPZpsXi+C3ZRs+Y3mm5vk6CDQlG++azjoGx0kScd4gfbihrK6t +A7cqrHztMAckAIYEADcnFfYzHST5AHjw8CEs7gGsMggecMMSgPU9EAg6+sHmpL7oZF15qQ6H/XLz ++riUWi55uFo2qbQdNjw7CYmjz8WU7R5M5F0kmg5rCYU6j1d2ZH1rXzbW/bLy1C+Tk36ZmAjL7Nys +uLBC6Ids7EXm2qPnjJ3b+fI6at/vK9Wa1CDt29rakZWlZRhaCvLLXz6TQuVAnuy5pQrjc6PprGcD +hxmfox4YnGh04oqBls4goAS6Mzhe2Flodc7u78OSmpPnz5/L48eP5TGcBXnBBPwB8cECGUHWOhJn +6oGdUHh5k0CHYUWl9IKRQiYmJl5Ynt8nykT7RuKRYRDLFs45gAcZcdmDRZpWacpfKOtw2i3SskQz +QgcdJw/QBk4OwrmCePBQY7zoOCQ8Lx5uThgIWkdzHURjEVmYn5KtTEPSkQ1pIY12qd6WTChEzkGA +9zRmmvT6PMYi6Jyat2tKsllrQPaG8be6i/sMJuzbxQqisBTl0dqBxO/nxO86EJfUjESQ91q2mTya +exZqcI8O2yc9x3/NPf3oxn5wiNVGHB+gUXQQ5J730FrTjQmqGEncxvo2HM5rsrTTEIQ7l2JtEM+G +Qcdp/Ik8J24+jDsvCLTVF+cIfc/+lDMYVc/C//4N40W/B5kGtb2f/fM/yz/+5MdwEIzKKBzJkuko +dGoxM/N0zkXTvtEO4S5L8jw7Mwsrx4TMzs2Z5c/3Ic/H0Q7CkZIxlEOhsCGWy8srsN42pQzteKuC +9MnA1YmF9eakqgoi/Wxx2Uw6+HBIp3OYUMEBE5MSLc5BgNdtKBxEhtAF2duvy8ztp9KEXKeaxUPf +Rlpo5yB6sTWlIcPv9xqDxoUxyfeAgBN0DruNbF02cnVxrVeMJd3t2jNGG1dzR1yNPXEPHhopGSfs +lA8MIfQoxzLv7m0CjaP2wXvU5uxf5f3RukcyokjroGlWb+uILAJlFJIAJaU1EJYm6ktDM63uDZBq +Uv8WNoc+FkzeAB/GHTeSaS2dQUAJdGdwPPeztJBcYQsJUTY3NuXenTuyhOWmVVigk0gkkoDmdRhy +B5JDLhc6gTxbdWSM51A4JAlILZhtb2pq0oSrY9xn6zOdAJtaPRhIjLaazpW0plCXmM3mTKa/Mkh0 +He/xgeG0QupvHhRNWE5gjWaEDlrWGZWDof1GRkaMFo6W905i6jScnFJfWvLoCBuPh+Ta5RHa96CF +zpqxyQe6M6d6TkG/c/XktRYK+XF/jmAy6wGpHABRIylzTg9aVW2AfLI0MPpIiqv19n1yCER08AAy +Abzphn6f93NKBth2s/FLPOb+nAtr3K7/gJl8Guvz4aAh0AeYjZJAt0D8ZQCkGs+HQ1x37VY6l3AS +Z7PqipWPeDwCB/yw8as4Z+h79ueUQDu0a6vQaj1++Ei++eY30Dz/Rlaerxqpxo0bN03YNpcLOjvc +wJxEkFhX1jkRi8sVxHemU8o4ZBa0YnSrHSTm1FRzPzY6Zsgm765G0gHS6UQCbQ1p3vwbINFbcPhh +qDta1xnmjkQ6AiLNVOhDDpH1WG3q1z0fgqlkRL53a0YKjUH5bgkZKRGXlhYyLc5AgPewaDQkhyCV +wYCvTSxRdaf3IOvPjWStOYQVrqGAOa6jvSwDh9jbrJHWRACVA1FGJUGc21VkEiq8gbrbrMqE8p0K +47MHYHlOj8TgUB4xksV3OpF+6fcQUAL9e5DY+w06iTGzIPXOd2B5puY5D898ShvoZMfoCzzmA9cJ +hQ8V3mYZ2omkLgIHv3Q6JSlsTIZCstct8kx8LE0w5SIk0S2Q5zHGjIbFrwEpROkoCYulkXMCpsfr +aEUXoZVrH1p5jp/19XVDpulQGYCMhRMIp4yX423rp2NeA7Rejo8lkeI7J4mQWw4wwSsgffYLMtBP +gLxvW3HTad972iTvfU93mu+TT9KJixpor8clPvcQrkdEVDFRVZxP10wLBtqU4nda8zsvToPUOX/m +/IbAuTaMzWLELY6zAMYcSTQdCTkOtXQGgVMTaCctM3UGGvudhcvw1Dv/77/5G/nZP/2TSclNy+KH +t27JzQ8+MGTQIoT2q/3JNeJDzA1rOcnr9WvXZX7+kiHSJHfmAXdOVzsJJIlkGg6LCchgKHsI3vlO +NjY3IenYkhp0p3Z/DpyMcPtdOkYyXF8O8aK50UHzypUrJv13Ipk00o43fV//drEI8DKIxZBdE3ro +3UxFHt57JkuuhtzbaMDpyckj82JwJYcw8YuHcHSOhIL6UzpyDQe8kgz5sEJ0IKUq49BfDA76qz2M +AG4aXpDn9DByAiB2dxgTcC+kHFo6h8CpCXTnflLPdFYESJxNtA0QoE3onvPYM9QOi0kUgmV4p+lZ +29aftgWYDn2MGEIrMC3ObNNFWURZL2LpA6FnfUKwiAfyBT5tjSaaE0mj9nPaE++o3ofQdDM+tAur +FLSuc2OYO2ZrJO5svxZ7IsCu4QSZTmgxPBQzhQYsTE1IcdpWaOVgZ+g3YumCttzodM9/zLtBbEhm +XCTwWhSBLiHACVsAEzYfVjw0fF3nQVYC3XlMO3ZGkrUWyPMK5BrbIM5/8Rd/IU8RbYM61jishjOX +Lpn4vvTsvijC+S6N5SNjCE4aTJBCnfMHsJ4zagglHN2WbJy2vlFYwP8A2Q4LIM/ryPC3vbMtjyCX +oY7YpADHiZy4KkOSRQLNxCvf/Pa3RgLEDI3j42MyOT1jHDeVRJ92lJz/5/gQXFgYlf/6X/5Yvrm/ +KU+2v5ZMvnoUG1op9Gl6hKIxDybJTFAzPhHBhOR8rXJcVp+EHvXmpTGpQMJRqCCRE1aItCgCnUSA +Pi4xxJD//o1pWZhOg0Sf7zjvZFvsei4l0DbtGVqd84jtzCgKD+7fR9a8DSlC60wN6wCcUKhdJdls +E06bNuKEahnHNVjRmIY7jpTcoyOjkkCMYkuDbJeJgCXp8COONicsdMZjhJMS6k0ZDfuhxQmO0x58 +R5ZoTmJIotnO/ey+yVLlR7IVWqZpdac1mkXJtIHBVv/wmo/HMYmOlrA065LDg0HZzSOTpnKwU/QT +HGcxCXHD+hwMeiQUZFiv87UCcyUhHg3g3odoHCvbxgrdOnBWNI5TAK0fuUAE+Jx1w/rs97llYnRY +RlJhjHNn+EVdIGxn/mkl0GeGrPtfoONXCWT566+/MmTtR3/1P43lkyHImFGQ+mBmmBvC8iNvxk4p +ljyClmYmR6EGlw57fE2nPbuQ5+N4kqyMjI1KGMloKHWgBfq7b781e2Z6ZLxlChidZvsz1nMMHobv +24DGex/h+0wIP0zU5hcWZAQrApQLUM6ixV4I+P0YkyNJmYXl+daloCytt6RSO5B8uZ0AyGlj8TzR +JbGgU1UYVud0IogVF4T69DDywvkVF8j77Ax9PFrydB0psXcQkhCOhE2EhtO+O79+6NVfIiXwYIwN +B90yNx6VT344C7+eEIxunl5tcsfbddrVZX06dhz6dz8hO40WZ0bYyOztyTe3vzHWQVqeeYOlLpfS +AqZlpsPbeTq/vHur2t8kEWOaV1qaGYeYBJokjZFDSJ7tWkjq6eDI+rN/KH/IQYNO8rwFR0Me8z2G +uzvtRWeXtrK+ZsxR0mFWNgaMzptp0tke9hX7h0Taac6pdsG4G/WgjMPr80oKIak+wvKsx7cna3vr +6EOkpIdTmtPGYTcwOumc7Qn8oIwgFu4oQgLSAu3zMRb6SZ/u3nu8p8RiQRDmpizMJGVzuyiPn+9J +oVx/kRGve7+uZ+5lBHBrMJE3ktEgyHNM5mdTkEeGMdZ9eIapBbrTfa8EutOIvsf5aHnOI0LCz3/2 +MyRJ2ZYvvvzCSARmZy+BZEL24PND+uBrk5lzvum/R7PMV90goEnotimDmJ2dlSSSpNDy3KnMgu9b +v7d9nwSSIQIpnbl2/bpUYInmhGAN7zNmdAmvnVxIuiyJkInYsZ81qwOUcnACwXZrsQ8CJH0xJEb4 +4Se3JBBdlyfLZawm7EuzhMkQUi1r+X0EeMtkVILZsbgsTCLyDJwxz5s8s1b8zQDiQMP9Q67Pj0ut +cmjIM/uvDkkYLkUtisCZEeD4buv7h2RqNCb/8g8W5NIM5ZF+GNw0adaZAT3FF5RAnwKkbn7EsgJS +U7sHqzPDpz18+NDst7eRFhXE88NbMaN1NhIHXiUOKbT4sM4kz0ybnUDGP5LoNCzQDBXntGKs/qg0 +Q90xS2GlUjE6YvYdNeu04lr96bS2sd4NtIHt4DEdJdl38UQcE4dgux/hrDo0pLcMu/Qto3FMT4+C +fB3A0pTGviEVkOfWASLFHGpotOP9xHuR2w3dM6Qb49CEzkxgXCOU3EUVWgNpFZwA0alWWpDhZKRY +xuoWJkClqnPvIxeFZ7//LqVJXJkKQvMchePgOBxkr8+PwvocgQGEcf77HaHutF+fht3B9dRnpRMa +JQAkzn/3t39rHAfpMEjJxuWrV0yMZBNejGszTiLPQIDVDcAJbzSVNtKTOUQNYaIUSgOcXEgsPbDK +Mksi5Q7sH1qjt+FcSI00w9yRhDqxsNZ0LuRqyPrGOvYtQ6JHMelhyvMYskSSjGixBwIciynoG//1 +J5ewOuWS2q+fyfpuEQlW6ORqAi7ao6IXWAta5Rj5IhUOyEgyLN/7YFKuzaclGLo4Ak04SHimp2Ec +AanPFasyjLjQj1d25e6zLUxmMRFSTfQFjhrn/DTvxgyHGEJ6+PnppNy6OiFX50dk7lICceOZiMw5 +bXFaTZVAX1CPkaCQPDMO7y5SLVP3/NOf/MRYNQcgC+CS+cLUZUPQeKN1UjGWZ1y1HhDL2HAURHPc +WG2npqZMu5xOwFh/SjrozGkmAyDLDIvFbIW76ChOiIwlF8eGRjuMTLPulHHsYEJASdFIPi2NGkk1 +2unxmtUQdS60xxXJh2M8FpAPro+ZqDAb23kz6ZGsHNPU2qOuF1GLdtSfdja2GYSOmxyLypX5lFy+ +PHLuzoOvtp/39eFhvyE5FawexJjoAkvtu9milCp1WKTrkHQgugquO6dOyF9ts77uLAIuRNbgFkRM +8fFkSC6DQP+bH16W6cmYTE3F8JxyFnfoLDrdP5sS6O5jfOIv7EM3u4ksd3fv3pVPP/vM6E9p1QzC +QhuFlc9LyybiNjqNPLcfWC48FEJyaW5OJgx5HjFE048QcE4nz692Jq3Pk4iMwlB3MchTKMNhquwt +RLagpIPh75xmi7ZIP2PTMkrH3h6Wl4slYdZLZjOkhGUS1nc7O3++2k+9/JqTGeqh5+ea8h/+pCnX +F5Ly2ZfL8mhpT/IgYtVGf2qiSR0CXvheDAclgcQz//3PPzaxn+fguMfIG3awzLEOJDnT01FEBAlK +fCQgl2E9XN/Myi+/fiYbuwUkzKlKDZNaLYrAcQTIDUajIUlhbFPr/K8+WZAJTBAvTacQivT8wzMe +r1u/HCuBPueeNlpTECs6bG2AaC0tLcnt27dNLRYuX0ZQf7+xbPKh6DTybCzPlDeA/EdBKJkcJQX5 +Bi21zHTXa+SZncY2Ud/NyQ+JJ/XelXJFcrm80bA0QaD5pLZIqeloh/xDizqWSaSAscqVEk4WKBkw +sgE4gQ7gWKNzXHxnMr7r4KDbyBMOWwk4yg3Io2e7srtXggXzUBCYw1gwacnkmogZixdf7a7WwGhC +aZmDTjwVgSZ0ZBhW+nGJIf4yw3nZgTwfB4CW6AjqSWevKCzR1LIuLu1gRRK69noDsjDo2o22Xa3R +x3Hrp2NOCM0zFIPX5cKG8Z3C5HAqPSxX4QPx0Y1xPHcDiBEfbH+un8C5oLYqgT5H4CnZWFpclN98 +fVsewFHw2+++NQP9OqI6kJxEoTElIWFmQaeRTRecywIg/4yycfXqVUmmU8ZRkHGU2Tantecsw4Jt +44SHjpHUeDP02+zsjFlhePzkidFFk4A6VZFqHtx4gO/s7GJikJMNZMXcwpYGiZ7FKgOjk7QT+uhy +4VnGTSc/yzEYBPGa8ozCUTcuo2NJhFksyldfP5el5xlZ3szIErY62DS3XiXRNDqQWIzDIn8Flrhb +Nybkj38wbYjz2ChCZsJ5D/M+2xXLWBKL+UHwsRw/FpGb10dldT0n9x5uyZPFHXm8tCW7uZLswSLd +wLNES38hQMPFVCIMrbMXY3rOjOkPMSkcHxuWMPT8CRDn9vjW+/B5jQwl0OeENCM1VI70zosg0YuL +z2R5eRkOWgmkUEYsV1htaX12WuGDm5erC0ldmGgkgoQj6ZG0aRf1wbzo+6VwomAmC2gz+5NaYhJN +4sOIHTAhGeLiPD1jm27VG9BkYqM+eoj9jo3hCK12c/LH97RcDAK81nyID02vex8smMlYSHIZjrtD +kOaGZCHDKVabclDDdqStZU17gUyz7dzckEME2PZ4SGYRB/fybFKuXx3DJM+LkJn2H5tcTaCFnBtj +RQ/D8fEQi1gHTPldbIfKrKLvqrRKg0NzlYgTXN5T2v3YC715MdePXX6Vo9S6j3I88Bi3VvgUDUka +1/QwordcmxuBsSok16+MIq9CGJ+xS+37qx5KoM+hv0memb3u6dOnIM6LcvfOd7gB1mVmdhZa4TBy +1HuQVdB5XcFrlpZXWh9pdV2Ynzf7COQbjB1s3QTOAWJb/QQJJWUdDNfHBxud8di/JNHM9uf0B10L +EwPqoQcHkakQKw8MTTg2PmZWIIKwRnNMaLk4BHjdcRUrhHBWV6+OYjIblqnZuMzPJ2VlLSvLq/uy +nS3JfqFylADo4ur6vr9she8aBuGMBhFlA+G75kGaJ2FtvjyTMs5UXhDqAYc5YhMX9iOJ/9xcHL4x +HpmcGTaynEWsKOxly/BNKEg2V5b9UlXKtYaJ/w1urcXhCDBijA8afTdY8yiS/vig45+eRkQNEOcr +GNthpJ+/eol+RUhFj/Gh5PniOlyfdF3C3lgEYHFkSLACIhn88vPP5XNsO4i4sQNHs+mZGfnggw+M +pdKJRJN1psWH0UIScHpkSu4f/OAHpj0kUE5sU6eGAtvPjdgw4+IGwhIeYixk4YBXLpWhSUUEFuMU +ZFmNOvXL53MexotugEAzZF8GzrAj6RFYw1omVCF10dbKQz+PgfPpidf/CsdfCNtN6CJ5LyqBZO3u +5uWr26vy2ztrcncRKyMDyHxah6NoHRZpzOqYfZKzO6N9f/2pL/AvXPUwLgViEWcvJgqMXDGJrIyz +iLJxDRa5fwFnqjQiEtAy5+QoBGxrGM5g4XBKFhZSBvdCoSaPHm3L6tq+PHq6hQnRvpHnZGCdLlSa +UmuwL49ZpXnMGbu151lw3J7Em1PqP+eIgHVPtOZzHMcc1JTw0CA1CIuzD+M5gZCGAUTW+ODSmERw +/MkP5422+crllFld4te0XDwCSqC70Ad8YDHRBgnGvXv3jFSDcg1ePCFYnP2QNlA/6uKSdxd+v9un +ZDtMdjpITtoRGSYlgbRatLySVGs5hgCwolV2fHwcxDJkrNCMbEHiSSmEeZhhvDixcJyTTBdLRVlD +zGjumcAjhtUIZpmk46gWOyBAjT4zafoQPQWhrXAcSfhlfi8u23A03NopSRnROjL5srFiMmoH+9ZW +BdcR/6Nlzof60wpHB0FGHUhC+zkKK7vZYIFOJoJYAXJeBKPT4O3GMn4qFTIWdTewGB+Pynw+ZULe +ZbIVXIM1yeYrpj8r6NMaLNN0QmxA915DbOkm9ibRDiZLNuvh0zTf0Z+h7G2IGn2MXy82N/T4PkTa +Yp+GMJ79PqyiwMmVY3sEY5h/mxyJmjE/Bp0zLc78Lk6jxSYIKIHuQkfQWZDOVvv7GfnRj34k9xCq +jo5WYZCKMYT/iscTxkLJ2aYTrwUuMQVhXZ2A1ZmW9Bs3bhjLs1PScnehy197Sk42htHvoWvXMCay +6O8WxgVS9taRcYzWaIwV25GV17bmd//ABzDD9GUwznP5nJEjsV1lTA698wsmMollcfndbx57RWKE +jRMvPlwOLNPMsY/Y7ZDj33qKOeFhxjr68HDmFouFQaJaZvk/ly/K7W/WISvLyNpWVp6uwkkU2fAy +IGEkWRyXhmRxf8S2XrzucKe8xJE0uV3Me/iHr2mhox40CUfJKDIITo/HJQ3S/MnHl/cSCGQAAAv3 +SURBVCAdS5noA0waQYtzWzeKLupwHe1wOp8P1nbE+J2YiMqHB2OmX6iBroAor61mIemoyoNHG7jH +lDExKkBqVYFUBxOkal1ylZpJsMMkLUz3/qJP251qmvfivVcbe9T/Zoni1b/16+uXg9Yg8GK84eDl +cXv88h7nAWH2YAwzhXwQfgphjOMYZFYRjOlREOV0KiyXLiXhDBiQSUyMOEHiPZHlxZh+5TfNH/Wf +C0NACXQXoG9AtkGylEH8XC7h805lEWiGOwuDTA8M8CHchR/v4ilZXTqKUfNM58cJWFWHYW1km9Ty +/AbgcdOjBjoYCmPCMQvMYrg5+kA681JCiDgSGqeNheOt5bjgA4JtpHMaY0bTwk7rNC3RXJk4qfB7 +lLkkk9CqFvxyc8aDB/uLJ/VJX7HFe7QCxUzIMTzg8EB0UmF9udFBjY5q37vlkpmpJCyXddneL0Bj +W5Ct/SLkRrRm1kHAkLIe5KsGx8MS9oz+UIOFuoV7WgN93YnJnwskgeSCuHqgqfdj6ZoOUwFkVqNV +zofXE+PDJrZtIgILHfXOcK7j0vY4LNAjIB604vm88LTqg9Je5ONE4WV7vdDJHo4dmkgMIVgqK8hE +SdkO9yTXlHaw7yroR75mopYKJR94Tat0FX1riDjTiIOQ89plIktOpEiaLUdFvuxEnzutm3ivIhJm +so8XfG0ZwPjs4/v0O6CjKscrJ3Ick+wXL17TeuwHIebYpuyI1mcm36LDK8d6FOHo6PibTodhjBoy +n7ciszgNq36qrxLoLvV2GbGAGbrs0hySiRwt3/sgeeBFx6UcXHFd+uXunbZ9k3CbyYAh0EggQq2l +kufTYU7Zy+jYOCKVYFnOH5AcHAqpi6bcx4HD4cRGcxWCKzBFaKT5oLUidJz4YTSamNDZstoIya18 +AA9z85g68eN2edOESUtF8KCj1v0libFL/U5TD0broEU6GPQfkaO2BpqOaWtrGfhqlJDMIy97sGRu +I5lHGdbL7f2SIWLFIyJdhn6auukWiTR+1BArq/uw5+HxYm57oB5mD9LM+4m5p+A4BGJBZ6kQ6hX2 ++2Bk8EkES9mMJMLjDz+aMFKNGLIuBpD6mqsAllXaaZOY45h06piYRqPtKE7JZBB9SvzxHxgv+6Xd +P+33ysh6mM1hglSswdBTxWpYCxlHK2Yin8Oe/UnpRxP7A1yPlGU1EfKDJBqX9hGB5nmt2jvvWWbV +/Cx7tpI4kxybcUsJJl+DDA/BodqL68mSY3hAkhmOMADiPDwMJ3vE+Q6FGGkL0iKOe+s64DHO0Sbh +x0k5f02L3RFQAt2FHqJFNo6YzgxlRqJJByumQCaZcKI3uAURL2laGX1oHy2HbB9vJFpOj8ALCz7G +B3GMRMLSgEYR99OeKXxA0JGQ1wEnWK8rHDsMfTiCsIf+QAO+ARVcK3wq2xsMDnlaPUmgneqk1r5s +21ay4/0zNBAxE/w4pB6pZMRYMPcR6aEOC2YOhIukqoqoQtwXkGqacoCdnaI0YJWuUztNknVE2gyx +PmJZJAgeNzZa4IAbyTKtcwGQCkYbCOA9WuKo+/SBfPhhjePnhrG8TQve9GQcOtF2eDda6LT8PgKW +xZLRcd5UaAWlo1oNpC4RRV/CAk0NPFePuNrA/muhX9nH7E/jlEgSzs30bZuIv5wh2ft6fRMWZ/lb ++5oh2cW38MJ1tIrMsU3sSZ55f+e45cSa45v3CBJpEmfKb/gZ6zxn+W39rD0ReP3TzZ71dUSteBGN +MAsfiHPbs/3QZG0jYXD8rQZtaN8w2stWjugQm1WSpJLhC6kj58OJETp6rdASbSIlYP+mQjnQ6OiI +IGGlTE1REvCmT9vnbx7IBeySDrqTqDDkWwqOeAkQpQk4HJI0kSSzX1qY3PA17c20RtJ6SQnA/Qdb +cJiG9h1Z8xqIV9wA2Sb5amJPUkbGwHtiENIL6pSZcS8S8RnLHB3+LGJBvSejuGD3Is44rcskJ+3J +Svu4k+3tx3Mx2QbDnwUPmTG23ZeGHKOPDyznQvQz+5ylvW+/OHqLDLr/ytHD2+z4DzHA3nqqm+c7 +X/M5b56TL/ccw9zwtpYeQkAJdJc6k9ZZLYrASQjw5kpCwa3fC7GgpZrFgXmEeq77+IAnWX1bIakK +YsmaBHpnqyhFWI29bsQiRkg8EmhGfeDKCq3Q1ngnaRsGeab+Oopl7VgcUXwQUYLWOVrslFy8DfXO +/b29cqJsrnOI6pn6EQFnecD0Yw9pmxUBRUARUAQUAUVAEVAEbIXA200NtqquVkYRUAQUAUXADghQ +XkHLMZ386NTngeaTWmgTaxjyNVqiKeGg3wedrBj1IwjHwAiSg/CYGlGeg5ZntT7boUe1DoqAInAW +BJRAnwUt/awioAgoAoqAIbzMksfy8cfTRidLHe3xclw7y/fbRLmtC6WsQ4nzcbT0WBFQBJyGgBJo +p/WY1lcRUAQUARsh8DISiWpqbdQtWhVFQBHoMgKqge4ywHp6RUARUAQUAUVAEVAEFIHeQkAJdG/1 +p7ZGEVAEFAFFQBFQBBQBRaDLCCiB7jLAenpFQBFQBBQBRUARUAQUgd5CQAl0b/WntkYRUAQUAUVA +EVAEFAFFoMsIKIHuMsB6ekVAEVAEFAFFQBFQBBSB3kJACXRv9ae2RhFQBBQBRUARUAQUAUWgywgo +ge4ywHp6RUARUAQUAUVAEVAEFIHeQkAJdG/1p7ZGEVAEFAFFQBFQBBQBRaDLCCiB7jLAenpFQBFQ +BBQBRUARUAQUgd5CQAl0b/WntkYRUAQUAUVAEVAEFAFFoMsIKIHuMsB6ekVAEVAEFAFFQBFQBBSB +3kJACXRv9ae2RhFQBBQBRUARUAQUAUWgywgoge4ywHp6RUARUAQUAUVAEVAEFIHeQkAJdG/1p7ZG +EVAEFAFFQBFQBBQBRaDLCCiB7jLAenpFQBFQBBQBRUARUAQUAecgcHh4+NbKKoF+K0T6AUVAEVAE +FAFFQBFQBBQBReAlAkqgX2KhR4qAIqAIKAKKgCKgCCgCisBbEVAC/VaI9AOKgCKgCCgCioAioAgo +AorASwSUQL/EQo8UAUVAEVAEFAFFQBFQBBSBtyKgBPqtEOkHFAFFQBFQBBQBRUARUAQUgZcIKIF+ +iYUeKQKKgCKgCCgCioAioAgoAm9FQAn0WyHSDygCioAioAgoAoqAIqAIKAIvEXC9PDzx6EUgvIGB +ASmVSlIoFE78oL6pCCgCioAioAgoAoqAIqAIOBWBwcFBId89Vl7w4GPvmcPXEWh+wdrMB3d2dgyB +fvUE+loRUAQUAUVAEVAE3o7AaZIzvP0sZ/vEK2TgbF/WTysCfYiA3+8/3mqLC/8ekT6JQB//sPnC +ysqKZDKZ4yfUY0VAEVAEFAFFQBFQBBQBmyNwERO384Ckm5PD4eFhqwm/x4mtP5xEoPk3fuEAW2tr +a0u4aVEEFAFFQBFQBBQBRUARUAT6AYFms8lmtrCRDxuDMt+wCoUeltiDDoXc3Ng82ALYaMfmFsbm +PdpIurkd/y5ealEEFAFFQBFQBBQBRUARUAQchYBlZSZj5lY72uj0VznaytjXsTWwkVAfnGSBNn/A +H8m6+cEhbFVs1vt8zU0JNEDQoggoAoqAIqAIKAKKgCLgWAQsAk3ey40EmmTZIsyWFZo8+EU5TqCt +E3BvkWdapEmUuScrtwi1RaDxlhZFQBFQBBQBRUARUAQUAUXAsQhY3Nfiv+S7JNLcc+P7x3mykWLw +DRYSZeuPZNkkzNZ7ODRMnPIOi1SrBZqoaFEEFAFFQBFQBBQBRUARcCoCFvflnvzXIswWgSYf5vvW +53Aoh69aoPkmP0RyzC+w8DU3Wp15suMEGi+1KAKKgCKgCCgCioAioAgoAo5FwCLHFue1LNHcWwSa +f7M+ZyzQx1trsW/rPb7ml7mROCt5BghaFAFFQBFQBBQBRUARUAR6CgGLHB8n0a8e8zOm0NJ8vFiv +LaL86p6fVenGccT0WBFQBBQBRUARUAQUAUXA6QhYBJrt4LFlcT6+t/5myDBfHC8WibaIsrXnZ6y/ +vXp8/Pt6rAgoAoqAIqAIKAKKgCKgCDgFgReWZVTYOrYItbVnW6y/yf8HjZf5UUAC8OoAAAAASUVO +RK5CYIJ= +iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJ +bWFnZVJlYWR5ccllPAAAQ49JREFUeNrtvXe8ZdlV3/lde59004v1Kld1Dupu5dDKEtAILIJkgk2G +wSYYxmDjwR7ZY8yAbMAGjwdsYWDAxthGIIwNyEgCISSEcugodVB1dVdOL9900t5r/tjnvPtaIKxW +V6tbUEefq+p33333nnv22mv91m/91jqiqlw5/uoe5soluGIAV44rBnDluGIAV46/kkf0ZH/A8RMf +4vTZT+AVeoMp5y48yubWMR5deze9fZscXFikG8UcOXAUGLI+eYiNoWF+LiUWTxIb+ukC6mNG5UWq +KkLVsDSYJy/X6af76GR7D62O7nlRXrjniybzVlwWx1rGUee8mPjhso4+8ODZMyeMqo9jSw3UtWOx +N89iupeN4Qab41Xm5+HoyhzdjgXfRTVlmG+wtjWlVk8/tWSxo9/psjUW8jontiVV2cVGMUYsw7zg +0OLVnB8+wGKvRyexdOJlvI5xZU6cQOE6OC0YjafU3hDFlpIh/TghjQ7QSa9C1X3O1/yGPX/89DGA +J+sQMajKF42mF7+jdpde68pyDy6lclOIDK4wjPMKJWWcT9ddJQ8XXuvK+a0oko+I8D4jcqc15uIV +D/AFtfCC8/5Vw/HWP/I6/msGz9oWFJUljStsZBjnGec3x0zLKc6NQP2SKkulA++U2PDlaQbUxcVE +87eo+p8SOHXFAJ7eS48Ih4rS/2ieV9+ZDLzppgPKumRcTMli8GK4sFZyaWuLooQkEqaFRz1EETjA +GChVqcYwmU73ro9OfH8nNV+VWb5NhPdcAYFPy6U3qFbftrqRf+jUxdHfdr4wopbtkeH0BVCfITbj +xPmCs6uOogbnoai1fQMqB5GBxApo+OYKaGGoCo5OK3kbRL9sjXwxaIRcMYCny7G/dqNfnxSbv1pX +3UP9rMdcN2V9NOa+ExucXZ9SE3FqNWdSeVSgzMMfqoLXZr0FfAVloVQV5DnUHiaVZzzxTKfaubBm +vvP8Gn9UFelHvHN/G6Qjf8ktwTzNT+6LrPj3bo+3vmF75NgeQTeGsoL1LWEyFY4eWqSqLaNhRF1C +lQvGgAB1veNCKD0McxhNQdTSSeeJWEH8AkUeMRnD2rDkvpNbnLqYP2d7tPlLVbn6Ye+rb1bkL60V +PC0xgKpSVe4HBh3zL6dTTS+sKxc3ckSgk8LmOmxvWwY9wzQvOXtxDBa8gygLW76qoKxBK1joX8v+ +5ds5uPgi9i3fzKBzkE66QBSleF8xKTbY3D7J1uSjPHzhrRw/+1HSa8D7/DZjOv9ZvX43oj8CfxYj +zExDAGm8jQGC2YRHE3auGMBnsetF6Ga9n5lMpj8UeSUv0LVtpKhgzxzkBaxvwHDsWNnbZTRSagWp +wo7XOrymF+/hmQf/Orde/fVcdeDF9LqDz/iZSxzm8L5nAl/BC4s38IlH/hsPX3wD/bkTDLKCTmRe +uT5278yi+GdJ9B+DFiAdr9xc1dyq+BtjWx/w6hesSGdjvI74bjHJvY8kWotl+lFj+KAI910xgL8Q +5UtWl9EvTibmW72qrm6WujlGticw6AQkv7oOowl0u1D6AuciqgKshWkOnXgvL7vh+7j9lu9iefHg +4z6LJE147s3fyIHl5/PRh1/PxeJ+sliJLdFoUv1QN5FnGYkfTmP36klR3bA98aZ2U6Y5zHcNg8Sy +NpygPmZrqFySHGPXv2fvfKdc7EcfT0z6VvH8V0Ee+StjAKqKczXOlVR1TllNKMptEgciNUKCEdct +qumvb4zKrz6/WfqlrmGcG4Z5SOPiCIochhPAw8KiUFWeqvLYGMZDuPXwt/GaF/4YK8tXPXHkuXIj +12z/OO9+8OtYGAhGPOo9G0O5A8Z3JDaDSlGveCeMKmVjVNNJHM4bpuUEa6CTpIzGCavbo2S5133x +4sC9OEuLH0qT5Ne8dz8nmIf/UhuA9w5r7bXLS1e9ds+e5Wcf3v+qPUWx3X/G+uujk2vv3p5uf/xs +ujC65+L28Tum+firYxt7nPObY2/yEjECvV5Y9K0xTKcwGUPtlHICZV1R5XO89rk/x8uf/22X9dxv +OPIV3H36OkbFwxggMo6yErYmnvmOUAGnL0CWeRZ6lpCaCs6Dw2ENeF9Q1xHGCKvDKVvjiG4mS3OZ ++cFur/stxrg3AL/0l9UAzJ7lq3744P5nfG+3s7hvF1oy1131avPs8d+JPvXIBzm2+Tq2Rh5r1Dvv +ceKNeshiJIrBKDgHw2nIAABqB2Kgmuzlb776t7j1+ldc9pNPkozDyy/mgbMPE6fhORsLZQWr1ZQo +gU4XRiMoq+AholhJYrBqsTZmUuTEtiYSAVEMwnBaY8wIG3eXKy1/cZ65V2jk/z6w9pcpDeyNRqM3 +zfUP/qNuZzEDNoEhyrismK5v1dPVtfF4y//raeXXc0iqLIooK8U7VGtkrodGDZIuq0Du+IbkmU6h +LLp83ct/40lZ/PZY6D2bqg74I7Kg4qm9p6iVPBdWloNJTyYgomQx9FLoJcpcKiSRwSnUXokNdDol +vcyTlxVb4206Brwbf2vku283xhz6y2IA8j//51v/zfOe99zvOXfu7BCo2zypdsi0cIxHyvntn5Xj +q2+R4URkuReb2tWyNlT1HllcgNiC9+EPVQAN5I4Aw214zuEf4Vk3v/pJvUBZfJi6DganGqjkJIVK +oag9KOzdC1WtgX2sYG0bzm14jp+fsj3yjMZQlOFvXGXZM8jYM7BUNVzampKXY3C8wNfm973XQ2AQ ++dwfT4cQ8HXvf//7v+lLX/Oa9f3793vAAqKKFLUyHjlWN/9Izo7fKJEkJKk34+K8bAxV8xKJbbDM +vELKKiB8FMoiXPzRCDrcwItv+7t4DSzfEzne+6fvpdvp8Pznv+DPXiDbp66gLoVKYqqqJEkg60BV +gidglDgNXgBCuFIC04gPoWoyhdoLuXjyuqbfdQwyYVpGXNp2HIwibM6zkl79ltqd+9LR9ML4c+af +lp9aAxgAf+eNb/znF0WkBpJm8SkqmE4r2dy8JGvlG3FuItPCkMWQl6LDQsUrpBGCwLREqxqxFiYF +RGkIAVUF+3pfSZp2mRaeNDJYEy7048xPeMMb3sBP/uRPYa3hv/233+Z1r3vdY17hnGGSQy+LSG2C +Kx0VjlIhTYNx5gXMLcCZRyEvwUaQJZDFwQhEQthKY8GrMsprJgUsDgx75xO8zrM63KSbeBR9Saaj +fwfxdxhSnmwG6ckwgFcA14lI3r6/ApVDirKWyVDl/OgX8fG9Bp9KUZSaWWE09VQVGgmm2wnGMhoj +URQYPtfE4cpDmsH5rQ9z9txJDh48SkGIzxFgpQk2n1WGorz97e9oFtpj7Z+1oPWtc5QFbIwqYquo +CtsT6HSFWpTShQVf3APnzoZ0NOuGBc8U0iQAVu9gMvWIEWIbClNFIWyOPEuDEXNZzPpwTGQrRNy3 +z/eueVcvu/Y/qdZfcAbw8l1LIIA4h5SVl7IwbIw+rpv1m8TUXopKpaxVyhqDBStG4tTjHVrWiDbg +L7Zh0QPQgk4GZ9ffxy/+zpfy2pf9GM+56fXMzaV4DdZmDJ+V9zTG8Cu/8iv85m/+Ji95yUv4yq/8 +qsf8fm3jJB/91P9LLxFSk7I1zjEmppN0GQ6nJBnEMUgGcQeW98LGajCIWgJmsDbQ1+MC8gqiSHEO +kgScryldzTCfcsOBZSI7x/Z0QhzVZOnZn4w1f5sgl55MHyCXuS/AAL8BPL8Bfon3RGVN5CrMidOn +7fG1v2svTf+HjSSKxrnKOHeyPC+mdiLbI5WFAaJedVJgNrfDQs71YTgKxlAW4cK6GlbXwoJfd/hF +POf6b+AZ176W/Ss30us8MVAwGm3yyZO/zX3n3sjJ04/gSiHLwERKJzH0u5bSVagEAxgMIO2H2P+R +94f3SNNgiFka8EKRB/xiDKSJkNeKOuh3BWuEhV6Hw8sxF7ZG9LuL9DJhvtf7cfGdH1H84zr/mw/d +/5QZQA/4HeCaAH9IAHth7bx9z0d+Prrz4V+2z7j1jMlzsbGVeHsCKl72L0R2bcuJipJYkdopZYWM +83DBaJjA4ThkBQrkDSk0nQQ/EyXQS7scXLmNo/tfxOE9z2ffnptY6B+ily0RxxnWRDueQRW899Su +oCg32Ryd5OLGgzx64T186sw7qexJ5ubh3KMBZGadsICqkCTC8lyXNE7ZzrdAHN0BDBbgkU/BsQdg +cTl4KoA4CeErsSkLcxHTYgzGUFThRCIrWOs5uCT0si5lNYeNt1jsd1Z7SeeZCucfzyI849CppywE +mBbxA1a950/v+QXzhx/+CXn09Cmuvwm8YgRsWauWpUqSYLbHdcAJJahVWtAoJixyloZFiCyUjVYy +ycDYYCCTEVQ5VNGEExc+zMnVDyMS4m+vM0caLdHJFkhshpEEMYJIhfMlpd9mkq9SunWqBrDFNoC4 +ySZMR5D2AvC0FsSClZitUcVc1+Kc4BXKibBZK/sOwMVzYcfHcTDcqg7vOyxLjKmxEVjvESCvwZqE +JLJc3J5wJKpIoophXtPP3B6Xll8j+Dd9oWCAHBgDZmP7Ef2NP/oec98jfyi+RpYWYd9+TF2JiSNY +H6qqYGoXqnjGAhXSijfiCIo6MG2i4QJGUXAr3gMOrAZs4D2MRwGApR2IFKI4GNREtpmabTbGM2QS +J41n2fW6NIWY2fO1g7VV6HYMNg1kROUhEpiUJWLAjTxz/ZhRXpMXAqUSWbjpVnjgvpD70xiuGMAr +G0NHtwNJFJ4LH6dExrCdwyj3LPZHqIfhuCCOzLdmafnvVdXLF4ABVMCZc6v3Pve/vOuri4urj5JG +QYSxsB+xBvUVUgY3LsZg1IeUbzJBfFho0eabdjPY2g4uP7aPBXfGgNrgluMk7LbhFuST8LM1AYy5 +KuTotvl7G4UF9i4sTjUFE4UdniTheWNCiKlqSHoekfB3cTz7WytQuJqLGzVZCnnpSSLY3hJ6Pbjp +VuX4sWBIKKQe0hhyDV7MCPTT8H3ysmTDl8SRsD7yxFFBZC2Vi6m9vkil9yIx5oNPRkp42ZnAyk0/ +/Fvv/cbo4uaj0u+IKXLEGGTvfkxVYLxCUSmiiCoax2jtEE8AdqrgJVy4Ig+7JE7CAtWu2f3NZlYH +6sMFthb6g+ARihw21kLRqCyCUVRF2OlFDmW56wLYGc4oi7AgxgbX3++HlC5KdmWWEsKA0og9TENT +u4aizpXNTQUPR64KBqjM8EsaBUNwjVQtiWGpn2KsDfI1H7E6VNJojshaLm4MTVn7bzGmg8hn93hc +HuBdd3/HZcwphKLceOf25BP/MDV0x7niHbK4jGQZTLYhtkhVw7SArCMkVmRS+LAD48BkVs0FzVKo +NSyytWHXtPHUa1gY9c2F7QRDSVPIsrD4+RTqZmfXVdjFURQW2LtmsQ24PIA8JLwun0CchffRUMPB +Js3nuuAJAogMnx83nqNsPiOvoF6HAwdgz15YWwvnNZ5Cv9uAWgvOCUms9NKILINxXmJNIJOGubI4 +EJwmjMb111oz/WdPRrEo+tTFX728LsVyYjDH79Yl3zWdMHYe9h5A1COuDpopY0SSGOnGCUVRBTrX +hEVvKH+iuDnBCIoixN9259soLBQSMIEQXL7aEIM6UViUum48wLRJzbLZotd1+BvXuOii4fpt4+bT +TtjpNFSz0HgbZoCwsfnwvMywCRoYwO0tWNkXsIS6YHhFgzdw4MSQpF1WR0Pmu4ZuBrGJ8F4ZTrZJ +Y2G+O6ByZr8gr4lj+fXL3c1/2Ykg7yDN+GljeY3A0V6fcm4gMhkrxkIcKb60qIPRtBBrEO8R75AW +LKkL7loaBO1cWFBXN6Ct2WneN4vT7Giv4XVt0cbY8PqWt6/roAYumvQyihvvEoUFTNLwnDS0crvL +2RWeWqKJ5nfWhvMzzd+4OjynQDG1QSuwqGysN9RxY9DdLFQPSy1RFTbGymIvYq6XgCib45yq6uO1 +xtiIvNA7VP2vX+55DtH+uZXLDywMF5YS/3/eNVl78/w8cTeyOnS1dJJI8tIxLZ14IBGk9g3ybxZM +fbO7TXhI87vWZTvPjtiyjcPaSr/NbJfaKCym92GB0k6oI9C4cWMb9N/fteObQG9teM+qDP9dN4Cx +LUWzy8C8C6EoVH8ao2qMoxJPXiiLizAahufbjKd0EEeCrz1IIIUublUgE3qZ0EkN29OcfrdPHDmm +5eRlUUKqaHFZDWC5t3T56UURqqR827WHix+bW/T/DONdJ1XyqcOJMNeJ2RyVYixSFWAMYuKwg10d +dlLrYncQf/M7E4WH+lm4aEOFelAzMwho3otdC+vBdsIfxnFYPNeIS4KCJ/xs29RNZsZS5iGkFA1Y +7PSCd9EmnYyimbcwFmpVXG3ZMx9x2haon4UTCzh1bE8dAiwOIiaFY1JUGAODLGFzUjKcjFgaWNT1 +ri+r+hZrzJ2X1QAkLp8UA7DGceTI4Ge287UvMa73xeq1KH1BbERGEydikLpCvSKRCbvetQG9AV0t +YwcNiIvDBazdY1PCqAkH2rjm1hW3uMJEzdtquPLSYIes2xA2ye6TDyDNmMbzNEDPNwRUWcK5U3D2 +JNz0TNh7AAbzbXEpyNCFQEKVNVSVZzipw3n7x3os1+ILA6O8DlXRHCIrdGLPIFWiyCAmoRPFNpa5 +F2ZRduflDAORRI4n44isMEiihY0hV28Mt9wk94JiKufFgfg6pHtiZt07rehjd2OH0xk4k8bl22bx +ffP6ulnsyDbv1Sxg6z3ai94uqnMzcqYFm6ZpFYsicA1IbFPMWWk4/Hv+dCCdTh6H/jxkvfD+cRy+ +Q9x4ldiCR5kUjiRp6hgNmHQKrgyv6SVQVAKpIMYznCoL3ZRBt8OkcOSFx5qSop6+rIiLX1SRy1Ym +jkbT0ZNWabJinifYo07ryhhsk+8HAw6kjPgqgL16V1pmmx3sG/VPFO1iC5vFbHNwaVyqd8FLmCZ+ +7071kODSW/BoZZbXx0nIEpKGbvZ+hhXaal5VhfdKUvjkneE119wEl84HQ5hfDOdoo0YM0rSk+Trk ++UkcvpNpPF3WmYUZYxrmM1byXJvKobA5dmSJUpQleRW6nbq97gt6ZpAq/rLhgGhabT8pi68oVrNX +OW+z2ulIREJcd0pRIggSN/FcZLZ7W+PWBvjZJqa38bh2uzxA3ewobS5+PQOGRsJutDY8T0O6NCeH +iWYIP4pmRtSmdr4JHXWD/uMUHrg7uP7nvDhgAjRwDC0R1QJQbbxQwC2C8xqMovE8bdbQfn7VYJs0 +BueFfmqpdcrGGGIbY03KOJ/S76bXqiuPqHfHLpsBxHSeFAMwgilqXq7eVbUT8Y3rdy7MdrARYiPB +1ypFHuJ/S/bsgMGGq6yrJg7LbOe7RmolbW2gWVSjYeF9k97pLlzRppA7KZ57bMrXhoLahQWvyobo +SeH+O+HOD8BL74BeP6iAoiRwC63XqZuqZdt9LNLucsEa3THiNoWUhtiyNoDCqg7usTY1/cwQR+HL +ePUYyaicy/px9zqBY5cLBUSDTu9JUBkAcF1eDm8pKi0FKGvEGEhTEUUliUXEI96LOlWxccj/vQZG +LWrAWpE3HqLJ2UWaHWRnIlENdZagDWxxhJ2dS5tF7IQOmeXwEIzJ2PD5rfdo2cg0g/vvhj95B7zk +i2HlQCCNsg74JISFVorWeqs0Bm8CDey8hsxCZ6yl2AYoRoJYqColaVjKSRGKXJHtMMgMkyInrypi +m+GckpcbN9jYveNy4cDIPAmaIBFhmuevHI6Lpcr5saK22c0NjhPBC7nzgZGzgW5FZvl8i6qtDQ+v +M7ZNduX77S5rf35Mbti8tgV4SPAsaTfk7DuKYx+8hjZNpe3u7PTgng/BH/0uPPtFcM0NISQk6czr +pOkMZ8zqIc33aU7F+ybDMTNpm0jIKLJMZ0ZIhDUOQRnlBUnscepxLmJa5fTrBKMLN2cy4PGKRD6j +AWRR/0kggoTt4fRL6lq0KjHOq9gIbBTRMSnDakxVK0kyS892yJ0mdmKCO/UNIdOieWNnO36n+5Ym +PDSLaeyslyBt3qPdMVG8Cxw2C996BGNmDGRs4aEP7uOPf+8SV93gefbtMzBpd3mXqKn5qweT7PoO +HrqZpa5Dnu8aIBk3ZeDAfinTPBhRXYFJamJjKGooCsckgU4MnhrVKIRGNUdL71G9TAYwnGxefgAo +ujKZFi90XnMNLlVqj5gw30daosfYBmhVQfHbVuNoFrcoGnRtZwUgGoRtzWOHPxg7y/1l13Otx2jj +vbFQl2HhjN2FJRoXLRbEx5y/92V88F3HWT7gefkdIcVrQ0W78MgsldypY+gMU3QSw9i7HfCKhvd3 +NXQyoawU26ScBiHyQlV7xECtQlkZOrFixVPVjto78HKgLHOjXB59QCQaX2bwZ5iU+e1VJQemuSu8 +V1uU4DxSuUrQKih3FSkLiCNUAnCS3bl4VQaE3bJwbdqkuxZfCAvXFpPaHeq1cbnM4rNzYaHqBgS2 +St2Wt69bwmi6l9Gxr+TODz+I65zklXdAb67JCuSxZeEdTNcAzJ0ScRNOhtNqx4vV5Qwseh/ifkgN +hdqFLKEsIYqEQdbn0mhIXYNoTBqXOI2ITIfaTVYia/qCbF8OLiAy5vIagBiDyydfitqoclq0oIcm +LzY27KbaoapIWYVi0M7Ob3Zr+93aIk7r1neTOk22sRNj299b03gPO4vDNmpA5qd5Tr+Lbmbz5Wwd +u50Hj32C89P38Yovhb2HZ+CwBXlRNNv91sy8kO6qDppdMyFUg+HFaeNlGg1BHM1eVNcgcfAAkyKn +YwXvPaPCMegJoo68mjInC0t7+jcuGom2uQxIMKrd+DKXA+kWVfHyaUmZRrGUWhtfqklTpCyQOEiw +ZP0SLOz5NI4+DhfCawBaLTUcx7uAX2MA+Bn4EpkpW6RxqVGzs3cblZdZYSmKQyqnHgbRNcz5b2A8 +voEPHXsL9599Oy97DRy9PoQlI8E7tO/VElZtdtEawW48MyN4Qn2/rRG0qWA3tVgrTKcOsVDXiqtd +EIiaik5iqZzivCB0MKakrCrAD06t37mv9uWJz7QERx9HeSfy1JcR/YP3csv2OL96WlHa2NhP3SX2 +vb9v0xe8yvvbnu+pK+RP/zCWj71X5MVf7PSlX+oCADKzXbxDCjEDhC0yZxf4a3d3G3fb11dFEI22 +RlI2As02faxd0BvGrLASfw1L8WsZDR0fP/YHPLL6Ll7+ZXDNjcFtt8bZ0tC7K5c0BFTriVoCyDRu +nzp4v2Ia3LuxoepYlzBqwGHgvMPfRWJRiRmPc4y40OxiOlR1zLiYsjiwuFrppP3Divvw5cgEo8Jd +RiZQwLvouXVtOko93t5UufdjnXRjU+zZkzXPemHhz5+LOHcmk6V9yuaGR3US6Nhxw/e3Ig15bHOH +MAsLO2RQo83TFgsA4maxVjW4b5qswQPTMfSTvaykX02nfjVptJ/xeIOPf/xPufP4m7n9NQVXX9ew +hzILHbKr9czIp3kDeSwP0ZawbeO1tjZmbGQxmdUN2vBgGtXR1Dsq7+hkwTsNejDJx5R1RBQZEpuR +1znd7vK8FYteDgwwSJcvqwe4tDl+QRqpTqtatrdi2+1buepG0aV9TusattatLC5DvWBYWNYQ0v2M +A2jDmugM9Lld1b9WjNEWZtproI0Pdn6m+EnSsPt8kx7G1VVcvfg3OLr0VcR2D2fPH+fUqU9x730f +4vjaW7j9NWP2HghuP4pmQNJGu4AmM90COkP27XdoaQiRQP4MR7C+1oSLhtTawQIN4VSXDT+QQLcD +LhJiY6lDekBiEuZ7ESJKElmQsofRyzLALtoYjy5jBiDReFreuDF2dS/r0us5XVyuXG9g5OrrS3Ue +6Q+8Lu6ptaqMHLmmVEDa3dHoAndSJXa53h0P42eLHDWva+sAbSWxdbfTPLh/Uxzhtqu+i2v2fTWL +C4epqiGraxc5+egp3vXe/wKL7+fFX+7pDXYVlGjy+xbx72YUP63auEMo6QyUtt5g9UIoNgkzI2qZ +zqoK3kEIP88vguk2ILZ0eAkNpb00YlpNqb0y6C3hHQtVK458ogaQmMtHBavqQHF7Xe19LB3Ebvir +b5Qqtmo6XS+uxs4t1nivPskwyys1eb6rRNsoeHa78N1kj/pZmtgWbFoxR0sJV03rWOT7LKdfzKEj +X8XH/vQi17zw6zlwYIm8mLC2vs6HPvARPvKJ/8Ce2z7GNTc1obia8Qg7IabJ+0VnHqrVG+7WDBg7 +y1ZaD4TA+mowwna92rG1RR5ek2WBmex2G9US4JxSVCGjmu9ZNsYjbORZ6mdMignd7mAhidPLEwKi +yzgDUUXnE5t0ofJnLq1JDRw5bHU6RceTMD4vzZT9h2uMmRE9pom1OxUynRVyfKtdN7v4ex9Eoq1A +VDUgbXHQt7dxdPmruHrfV7CyfAu9fpd68k4+dewuss5zOfbQI3zoI2/n9PC/ctULz7O8N+zQVnOw +Uzxi5v5bTGJtoHlbhG9tk0Y2C97WKeoG7W9vwtZaIxlvUlDvZqXl/lzT1xDNvkfRZAxqYGkuQ7FE +dhKmo3iPc4KK7dokRf1lMIDSXVaJGZujCWWtGItQIaOxpyhUxIR5P66GskTiCI2aOQC1n6Fovyuf +b5k83YUJ2rjZVgS1gmqSsNL7cq4/9HVcc/iLmJ9fIc0EcNSu5MCBQ7z5v7yZR44/wvHzv0O09wPc +9CzFSmgri9NZObiN921xx7tGnhi1QpeZYUgjI49sAKN13YhYm5B28lgIR66pO+ST8B3ml0IxKUpm +MvXWuxgbsEOew7nVCfv2xHS7TWVQFBHLJJ/ItPgLwPv+x2EA42JyGZMAKayIi62VvAhpTl4EnU+W +oCiSF2GnNbSuqg+GUdVNKXVXarc712/z/6Jxpy6H2B3m4fsilrJX8rpv/RGuvvooYmtoRrpNJhPO +nbnEXR+/m+Pn3sZ270EOP78gzUIvYZTtUgbHu4xvV4u5qwNNTRMCWlKrFX64pvCjGjxa2fQhnDwW +xCLt7p+MQjaxcrDpa4xmuoYW3LYZRQtqqwpOn6tIM9i7R5jvKogL399zeUCgB3xtZuWrJ3ZsePVr +aRTv3R67WiRIvxrmS+uySaUCYhfnAv3r3Izhay96u8PatKv2MN4Clyf0oxdy/f6v4aqDr+a9o/fx +yU/czfboPJgDFEVBkResrm7y4Ccf4J4H3soWv8ezv/wiSaf5mk0c1l1i0VbU0fYhSOPm1c7YO3Qm +PK3rWXfSeBoWq6oCPjh/Gs6fmXEIdRVwQJo1XoxZtbMVxLQn4/2MxGo1DVUN5y4o40nN9UeUlcWF +2ljB+yc+xTiK6yP0lye4KsK7J9YpZozkVbX2zgvDyQtE2WoVO3UosYaKb1Mbb3Pq3ZW4sgz5cQuo +2j6DcgpRtYc9yas4etXr2Lf8TAaDAZ1uxMtf9RIefOhu7vr4x1lYWGZ7a8wjx4/xwPE/Ysu9g8HB +kxxaDBe1bSYxhh3qsNUa7Ch56xku2d3+1dby2/P0LgDOtuPINQBy8xI8+uAsbNU+vGeaNV1DzZCL +WIAITL2rN2GXYYhp8IVrmjdi2BrBvcdGjEt3IEmUYV5T/DkR/PlHH4cBvP/XXsTh5z3A4tWn6K8M +cZXdMYTHbVwiGFv+XLcT3WGFF43HzqsXr1597VVNy/AZ0EZSRdNWRQP68qJB3Q6k7JP4W9iTvIq9 +e25ncf4wcSwgBeNJxWQqGBH27NnPe971Xobb22xM7mVi383coQscWAhhpa6am0U0ALLN113T5mUk +tKBZ04SiZJZxtB6prUZWZbPwLuTv3kM5CW5/8yKcPjYLFVUz0zBJZpqDqgIzCV4mTcE1zSjOBxzR +hsfdZeedekVjoCfOTv96v8ebiPihSU7+REoCUT5KuPf3b0OyQxx+9kkOPedhestT1M1y68dVClDO +29h+RVTyXRh9+VIvPVqUfu/qVrnoipl+L0vRskLqfFa7j7Bk9hD18DAP3V1xYPl2Xvjqr8MYi2pB +7cbkZYWra2qnFNOa4XCLreFpLhTv4Njwdzh0fcmehXDVvG/o3OixSqGWR2g1/60gtd3tbaFH3a4y +rmkaS5v0rSpnej5PyOdXT4UhUL5uBiWYGUmU9YI2sK6CsXXj0PuYTwMeUcLit6CwbWyJomBAcRLa +3m0MRY4B/k63R9cavuMJVgOVuFNR5CmPvP9WTt19mP03rXPw1hMsHg33U3KVPA4gCN771cjKT8QZ +PHomT/x4+Z++6Nlf/39tT1brqhppVU9lfW2Dg8tXk0QLGF3CsEwW7aWbHmKUVKx1P8DqpTWQgmme +U5YlZVlR5BWj7SFrG2c5v3YPw/pusqVTvPprQ1rVZhNt2tYi6x0a2QTJlWoTa5uaw452QGbETqsO +qqqwGaoy/Lf6cBuJsgqZ+GgT1i6Gn6Wpfu7oHWx7HqH7J4lD+Ek6QUAS78I9oiFtbEvW1jat7XEI +IfOLoQO6nWkwFb691+N9gx6/9Ll6gWhWxvVEWUk1STh7z/VcuP8aegeOc8PLTrB09FKjwv0sDKFB +0Fvb8Mn74fSjJs6iyetvPfgc/ZKX/k1d3zxvXF3rncOPm+VkLwcOHkS9R3GIKMYo8/MlV186yHve +/RAP3v8Ag7kF1lfXWd88x+rmp9iY3Iftn2DxYMlNh6DbbxZSd+kEdsm6za5K4u6S8g7IjGb5uZgZ +mZRPGwMoZ1wBCtYIYiBNlPG2UIwhzhRXh91NE/cjE2J4awQ2ms0fmIwhqXZJ4ZvaQH8xvKZoPMPq +hTD3oG1Bu/5WuP7m4BGyDJYX4j1PBL9Hf7aer0RpBaqcf/AAw9NXse/6iyw/6y6ylSH/K9pACe78 +7EUlyeDmZ+pzHn2wuPVX3vKP6l5nTp7zrFdQu4Jn3HIdx48/TH9wBFcrzpswVdx7rMb0e0tUVcUf +vPO/c+TqFdbH90B6gsFKzjW3ht0Qx7NGi7ZYY3VW/GlZvDbWO9e4ZDf7vUgIEy3zWBUB5LU6BFc1 +Uz6bymASQxT5jaRr3zCfLY9H0fhNw2E+qLZB4mCEzjWzCxpNgrVht6s2Mjc3UzO3hmh3GWTagU4/ +NJDGEWytG+77qMEmNfsPhd/FEcz15ec7afQTee4unwHs9uVRUmNMwoWHDnPqwQ6HXvlR5g+th6EH +Kn9hUWjf/obZU5wXr5Ju8Uu//bd4+SPfrC973tfL3pVriOxZzpw+z9VXX0dVlRRFST4ecurMp3jw ++Lso0g9iemvkAzhyPcwtBgKlvVAis7mAu1uuWuq4LRGbaBYWdsQmTUpXlLO+w7IIi140wySqOhhE +y+1nsbCyT99hLP9gNOETaZKyfFTPTcv6LaNJHTBOow1UByYSqkrxeTPDoDfrN7C76G/1s65iGilc +HINmYUROnMCtL1BWDodrEMcwPyc/nyTmf/dPUBr4v9YEixKlJeUo4dG3v4ibXv0o1774IYz11KX8 +xYYQ/u8eg9yVJv55q5em5d0n/z/7iRO/Lvv33KK+TGRajHneLX+Nsq7Z2jrHudUHWNt6iGywzc0v +Dn13Sdbk7bsZul1kjTJb3CiaVQ/b9Ex3aQldE19bmVndkCotuKtdKNnWjVGoD5/Xn5ON/QfMj6Z9 +93NFjnqnbGwNGY79Hy0vLr5ufXn99y6ed/O+yTrqEoqJhrFwLW+QN2qiRhzaMoQ7LeVtabgRkkwm +ofso63oOXxOuRSdF+33+hRf9v2rn8erxT8AKPmtRuBgPxnPqo7exdXov177wIY4+6xJR7KhK0zT2 +/bneYLIwl/z9qszfFkXaXVzCTadjtqYfCTq8GN5z313QDExKM1g5Gpovks4sTdshbGTWrt0Oj9pp +DmEm8DQm7Oi2CWN3oagsZ7G9bvP5ZvGrajbWxTuYnxOWls3b5ub4Byby96sPfz8ZeUbVkAtr2Hyr +OBRF6rrzMBk2ZE4UjKjlDdru5TJvSC5CGlhWj9UXxHE470tng6c4dBXs3R+uRacDR/alDy/NDf5Z +UD0JkTV4r5+zPDB6fGm+YiLHxUcXOP3gc9l79RY3v+JRDj3jInFW4yqDd/JnvICI/smB/fb1caS/ +urrpDqQZfm4OKQrUGGSnN6DZ0UkzxcvuEle0u7/d5e2ACLc7njfjZVqKtmUei4awaXd8VTUzg5r7 +DLWxuKpnIpJuF7Ie7z6wz/xMv5u9taxy1AdBST7dCTUv7cb8C+nWrxpthue7c6E7qfQz9ZL3AdTV +dSNvawxhdzdS3LSYbW2E89p7APYdCplNmsKgD5FaulFy70p/zk1yuLRWsrY1DRL6eFYg47YnyQBm +9KFDcayenOf9b34e83vH7L/pBDe/9Cz95Zy6fKwhBPAjf3jDkcErs2T0b89erL7Mhy+u1gagFCZs +hFxZdjeHOCjcjARpd4jmswpi+xktW+d86LxVwu4riqZ5tA5GUTbpXduS3mIAaCZ/zst7bKY/nfX5 +n0gousljW9aMKP+0rvknSUxs+mGRhluwdQm6A+j3hbIQhiO/A0DrcubNTDLjJdTD9kY4x4UVOHgU +5uZDZtDvhx6FBz8hbK47rrtutPpRGbKxFc47y8BJMxyrfvzk3RPqC4pih7EwXO1x9vi1fOpDB7nx +Jee46SVn6C8FQ9DGEIK1y7GVxewrrLXfm+f8yPpmsbcsDA6H9zDopBgxbAwnJDLr6oFZw8i0nOn7 +nZvl/U5nwsu6DhetKMOgybrJ43fHfOdmsq8WV6Q9Pjbo85Mdy29PHX5HnYTHiLYgc9nV/LLA62w8 +m1dURSFnrx13R9p9T6db/EBde9JUcM3JRfFjp5A4FzyK87CwDPsPhanjaRYeg0HwHB//KIy2laQD +xx7Rb8k6bCYpP5olTOI4hM44ms1L+rwZwKxm7kk6Nfkw5uNvu45jHz7CdS86yU0vPsvcco53didF +dF5dt5P+uyP7F9565sLqD7ky+pbR2C+NJjkb63notLFhPn9khRofhkO6pl6/Cyjt6P6awY7B0xiq +SplUIS8vyuDSXRO72yqbbVOuDBclfKjT5ZdsxpsN5KLBjQeQqUDZLtxSWfC76nlpnM64A+/Bekhs +/PY4qb5nsds/OTeIB8Vk+L+RKa42FKWn0xGSJHQDjbeDR5lbDAs/vxx2c5yE+w/0unDqEXjogWDs +WW+HM+jg+WE8rxTh+4GPPblZwOMpBlklSWqKccJH33oND33wEDfcfoZDN68x2DsiSTzTEnylqMqJ +btb9wd5i9q9Pnb/wrbWLvslV7hl5aYjimMwqZVUyzoN+vq6VyXim/mlFJO0gh7aGP1W/gwPqxs23 +A6Talq04apo6FUYbsu2mfLebzz4RJQYbwUZeUDjH4h7l4C3S1AIknUz0v9YVLxUBX84qgOp4j8DP +9DrZ71lT41VZXMi+t9bJYHXVfV0unl4SjGl7KxjMYDFMEFtYDiHDNue0MAfFSPjwnyibmw2bGM/U +xm3zjHfcXtf8cez5AQz/8XPevLc/81k473DOIRKaEWwz7KaqKuIoRkSoqxrvPUma4JzDN7NuxZgw +E6iumnZuwVpBTEVdRpy+f5F73jfHpdMRWSYk3YooUwa9jLwsSeJkazwd/sl8v/fLWWo/nEZJjTN7 +xyM3UG+pCxgOfSBkilnX7k5Rpp7F95bAadU3bRrXdgClSbjQZQGrZ+DUw3DuFJ2tDb6umtqjkcan +EpNe3NqqmE7DZ/bmlShRKqdx7fhbD97L0QfvDSPg8hEPqOdvZRlvMIaHDAlnztZcWi2Z5LXrdPW3 +DuyLFsvCvXA4QsoSegM4cAQOHA7CkE6/yesHYbFPPQJ3fQS2tgKuSDuzrGWHtjY7+sjUK6+PIjpR +wrucDyqxO573o0+tARgxeO8wVjCRo65rzh233P+hPsfvHrB+IcWIMB45FpYixvmQrBPXxshDeVH9 +d/Xyq0mUvd/XyUlX4QzSV69d7wXvdKdQtTONo97VHQwYZGgtF63l4SyVj+1Zit8yN8f/nZd628ZF +Dm6tBUPpDcIiRCm9ae1uH06K71L0qLH+mFi/agQurcLykjCYp04TPhglfMOx++meO8H7k4QvszF3 +ioSbRZw8XTMaeqrac2Gt4uKqWxyP/dG81Dt6A+zeQwHdL+4Juz7JQmqXpUHrcP/d8MhDDWmUhsfi +Alx3TXbX2rr+8nikN9cVvXZ2QtsCL/ByFebjmHd0EnjVs370qQkBfxEzGKeh/2u4nrD6Jwl3/XGB +GsvyPiXpH2Df0YK5ZUc25xBjV9OO+51uJ/sdrxmJysF+t3NNUQ2PlBWHRKZdG6uOpk6c86WDaT5l +vDjHxTiR8xH20rD2W+r95uY5q2YaU6pj3/X8knqeH6UhX8+nUE+DKDPtcr6sWNqa5n87KvnGJJE3 +phk/XXjqe/5ghU5qWLnt0v37rnbf+Lpv5rfvfJ/U50+JP/Gop9MJC1KqD9PfLS9Y7PJNc3N8bX/e +HxzMzSaKdbtNgacNQzU8cj8cP7ZrWlkU8E7WgZU93Q/cctPeb1xbXztxbDL8hRjzQ9sb/rs21+h1 +erC00lQdp/y9LOV8N+GnnjIM8FnjhEzD3N5KOXcCRDrc/+EAJqO4w2DBYrtjRpMJVe5Z2GPPHro2 +OpsX4f5TqpY4Viof4Zzy6AM1w2EdeHorAeBFMb6CrYsxRV7h1fKSr4x+4drnVn+jKvSL8224cBLW +Lgjdrn3v4nz0evUMvPGvGewrfybJ9CeqmlcQ8y1VHm2c+MgiH3lgg4M3uD986Svk/7jqOv33oyF/ +UqzJDyGaRxFHIuElScrL+n2e1Z9DOt2wiGlnhuyjJNQT4hg2LwkP3Kdsrs9K0GkjU+sOwrja0tf/ +ZmN7+4S1Jeo51Z2Tv1+W/NLaGn/v0jm+8dIZ+jc+O4yk9Y6fqOBu4O1PKwNQVWajzXTnZ8VjozAZ +K8kc3iveG8ZbmO3TYrcnLlbnswsnNL33QxuxGJPULk+t2NQYSaM4TpMkTosiTypnO6h0rTEda0wW +xVFqjXSS2HSSXtIRI91P/FGcnLvXHIoSg9aGgTfM9yOsiW/RTX4DZGSsVPlkG3P1aXoDfW2c8ptV +xI8lmV5KrX3Z+iW+5t1v16NZB6JIb1nZy9vb3Rw3ZdtONyxepxt+zrKwo5MUehmrUcIbt9e5a/2C +vq7fs8/NYq6qnF4znvqd3odRM/l8cbH85mGx/psmho118JWnrPlk3JHvnutnOliYfvfSSjCYQV9k +z+LgjstmALvn0c0WTR+zoM2/oqoJSoJqAtoBukAHkU4URd0kSQYgc4L0jGrPiOnFSTxQrwNEBmmS +9J1zHYWuQCfJknRJ5zqqdEAz7zVCNEKxiFhrjDUN/jDGYE24Z56qNuJKw+z3FjFBPQQGg2BsaM60 +1iLGLItwhzWCNRZfH+LUmZTp/DH2L3OHXjW8QzeuLvqTG9Ph5FGSxU36c7OxtFEzmzhJwm7v9Zod +32lEHTEkCdrvy6/3u/IjpfMPRxH0+vKe+fmYOo97p89VPzsa5t+JD14i6wQDUuVL06hz3UMP5A97 +r4wnem2nyx0re/R1Bw/lX9QfhNfP9SkO7ll84575a//VEwkBrf5WRMTGUZwYY1JjpJOmaS+K40Fs +o/moYxd8li2juiQiy4jMZ51sSZAlhDlgoErPe9/1qh1VTbW5PY33fkfP7tXjnMc1ENd7j/MOrx5R +2TG2UMjRHVWHILMFlfBvmEJmmhRRmruCGIwJ4g1rLdYarI0wYnZoWEVJ4nBvX1WY5gVpHJHEz+DE +Iznx9afpXjOks5WkW+cXiDYTTt9znO1excoh6B7aCvcRbBo7siz8d9YLHiFLoduTd8aJvjGL5T1l +CcePw8WzkFhQ5+lkk/He/f7fTwu+PS+waQrdXtA5lAWdu++q/u72tr7/wAG+dXGZVy0uMwjeJUxZ +WRjY31vop/88TZIPPV5hSGSMMWmSksSxQcSixIikRuh0005PhIGIzEu3N6+qi6q6IMgCwoKqzqM6 +71XngL5CR1UzlFTxiXpVr1qq994Ya1S9qKpR1Hiv0iyq1C4MePHeN94lLI00/Vah+zcs9Gw0jDRG +pA3nLiRxRJIkWGMoqoK6rsinU2pX0c167Flapqhq0iQlSzKG49AanyYRkY3wKFvb22RxSho5trZu +xp44wJ7bthlmKyR7ElQqLq7O4zcsbnlI0tmiOwiL323ifdYNlbs0YXtrS7773Fl+Y3Md6lI5c0p5 +5JFAf3czpa5L5hbgpS/ufOTAofJ9Fy64V6oPAHU6hXUg6dQ/ePNt/GB/boYpupnkNpK3DTrm33bS +6F1WLJ/LBNHIBuVhKKqJGBGMVxVBVFUdUAJTlFiVGLBevRUVY4yIijG7JHe6y5OY8MZiWl2jc86q +KmJEVVWc99R1TZqgzoWJJ6qKaRrr4ijCeY+rg7y4qiuKqgJRkjSl0+1ibMRkMqUoCowxDPo9OlnG +9mjEdDoCPFpHdLOMJEnIsg6CoAhZGtJRBVwdIQr75g+yla9xz9kPQ1awN/sSkkf2MxePqM0mGxtb +DKsNVq4tWXrGmMXl4PI7jdvvDWBuDqrVJT7wB5n7xMnVvVNb3thNech5pdudqZQa9dRga4s9f/zu +/LrFBZVWD9jrBw/Q64cFt1FIC3s9OR3H/Gavw3+sarnXmqBD/FxFQVGcJCAqohLuICaoCfen8ao4 +wi3wysCHkouY1BgzsdamIpKq6kRVY+99DBoDiYip8BpXrrZlWfqqLL2NIpMkiSZxrIpK7ZwKshMW +alcjhF1uGvcduIgajaLAT1hD3DQGpllKt9uldg7T7TDo9ogjG9KxIieJDEl/jiiKME2nrff4sihH +qlxEuGiNOVvW7tGkIxey/ae+t/bFdVvFhLPRJ9j3oiGHruLhyfn3dobnbzuIwvnxGbYG93DN9QUH +jsJgrnHVPUi6Qa/Xrfew9dFncfzOOcq1fPFQvfGzBavTYX3mj7WXv7/f40i3w7wIA2tYsZa9acbe +NNVu2pnF/qzb8ARNVpAmfHK+F/9Lb3hrXtZrXh87FPtzpoLVuWaShqqIqA/N2h7VWoypgEhESmPt +NI7jyISZMpExJlavifc+ct4lIpLEcVIASVVX8aScVuPx2KKYbq9re72eRlGkznvdke2ARDZSVztj +a4P3Puz+ZvGTOCJN04ARUKyxDbCjyRiUKLZInDZGQy5iVuu6XvPqz6Occc6fdHV5RsScHm6PLlbO +XRCR9Siy0363Q1XW2Kymuvadv+5t9U1ZxUtvTZnvduz7Hfr/3Ld27Ks2smP/QTzE18CtveZWMp3A +HyQJdPs82jNLm+WnXnjbxeNXRb5O2bM4pN/NcX4B0Ws7p86dfe0jZ+557dbyBnv2Bo8RNcCxfa+s +wRDdfnP3k2aimSqkqXzMGH61auYOXrZBkcZaRESNMSIiXkQExYmIiGBUVRREvRfvauO9BKzg1Drv +49rVtq7rVIwkGI3TbieJjCamtFEURTXeR+q9z6dTn0SxSZMEMdabSIwIKmLEe0+cJGggUgJyb2J8 +7WqMGMTYiRFZq+t61Tl3TtBzVe3OCpy11p63UXQR5YLz5ZoIo9q5WlDqZkJjFEX4hi4MGgVpSKoQ +bkSTM0lU/av+AOZ7lqKwrG7ULC3wqwcP0q1r/qmB/ejOjaqquMP70pT/nGX8NieuH04feu4tNt5+ +2aXtc3eIyCtr5/akcczi4gDnV7hwz1EurApz85ss7PF0m3sS9QdB8JEk5L2efbAu/TNHm2o2mkaW +ThcQfamo7wDTWCyRKB55wl4gStN0JzlXFVF1HtQhBq9K7Ry1qxvZkYq1kVhrjDHGRDaKkzhOvNdE +vY+t2NjUmhmJ0rluPxp0ejHgVDHOu6jRPiaoEjc3SRKBbifDGDN0db3hvF4Q4QzKqaosT0bGnlH1 +p6uqPJN1extVXW9Vde0jA+o9VV2Tpmm4NfmfYSCldTSfJV/RdPDuEmtqmMf2pjjlf/T7vN7DkoFj +YrkvSbhvVup2YIt78mJyz3Qy/fmyrPd7Y16XdcufdmtR39qEeu4iB27a5NA1nrnFQEP35xkmCXd3 +Yvs2rPzuaCgPnjqu7y0qvb3TCd7AhSLW1fvm0xsjI3fPxLeewtVExuxkQvI4e8WiuixVpGm/12Z0 +ogiRiEbWqrVWU02816D+azyFsdZagQiR2IhECqlzrqOqlVevIhIZMZlHu6hGaRTX1tpVVNcFzoqY +k0b0EUVOqOoj3rtzRmQ9iuMtrzXe+UZT2OzQT1vYnZRQ5PPAZIEqZ8XypjDRYmYwn/7xIqGhsDs/ +Ob/4wk/8wurW8DsunJp7sY9yrnvVFssr4Q6jgwEUF/dz8eHeP1k8WPxctrcmXtrAjWHQNf+p3C5u +3y10KSvs+rh4fhrL3Ts6hebDK1czqTypj4nt4+v2jpLWAwT5lXqPaLiZn6pXdV7Vq1dVVdNc+BAd +NEJM6pwrrDGViBRe/dirFgJnjLEjI3IJrxedd6eiKDkrwiVj7JqqlrNhKnpZBh18Xo7P8jS9FzoL +Oc94zpjzq8U3XDh04R/Glhs7CWc7qTwbZ28bPnSrXb33WdR19Y+L45xbj+W30pWzHHjufSRz+tub +W9WPO+eX2iKXVxhO3YsnJb/ymT53khdsDtcf53yAsiSyEU69eucaVk1crQiKGiM+iSIfeJx28Bre +K6VBNyNjHjFGKkQmlmii6ofWmrEq3jXIvv3fX6VDvQRpnDcn4sh/fxyHu6B0OxqvfvLws6efetE/ +P3yk+xobyf6tre3fdIX74fXj+39mWmxz6PmPnM+S9HdH5fQ7Ou1Nq8JArBf0U6wP2dkTs9JdTKB6 +9Yix0klTUFXnamKRptdGxTnnvNcqiZOJdxUmst6I8a2qRkzIqx8zsOnK8Rhs0T4QKiH6qHfVl/mq ++oFeZ/DG3r79g9Fw+NOT6bR75v49Px4tbBItXfwPvubb0aZxP8wfuFEtR1R59LIV53aEAcZoHEVa +VqWqoiEEOI/ivPPOe18TJt/VEm70eeV4IrFEhMhGPytOvyyN0hNZ2mHv3pUfS5Lkh8/ee5ByyvtV +5c7azW6MUdb0vOO5ptman+nxORnApxd/rhyfnyqpNeYDsTWviW10bxIlHDm876eGq/HfPPPJpVpV +f63tWG6zkwhekEWQ2c/8+JwN4MrxVPgCxRjz0KHDh7+i3+3e3+t0ZHl57pcvPbR0Wz6Kfw3Ykl3R +Pa951sTB9C94XDGALyiw6PFeiZPk1Mqela9NouhMv9/pWd99E5eOrtmI97YNM00P4c11TbdyYWLZ +n/e4YgBfIO4fIOv2iNOU2nuiJL5/ZWXPd873+7qwOHiFbh/5dtHozbvBvfccEeGwbUbR/nmPKwbw +ND+8euI4Zm5+gaUDB+kuLIa7pCcxSwcO/sHi8vIvLiz0SP3KT+jGVY9KxOaOHNyTRoZbwiDpP/9x +xQCe5lyStYZ9Bw5x4MhVuNpTVTXOeeraU9eOvQcO/pP5Qf9kHJkD0dYtt2Zp731t86t6GE+5cTiG +4eTPfzxeHuDK8XnmBObMjajznHz4z7/9nzFmbX4w9w8n04tvzi/s/esr04PvnsqnvsI0hR8r3NTe +pPqJHlcM4PN5GKiHXTYfWaSankXMZ0BsInivv9HrdL4vi3p3yPaBi9HKp9SXSHN3s+vNZSJWrxjA +53HxtYy5+Kd/jXIUITb/i+MESpKkP5dl8SsnF5e+za40sqowkvaIF3qqjK8YwBfIIQb00ReSuIOk +c5/dHdu91993vniY0d7roqqD2Gk7PnchTViEKwbwhbH4EdQXV6iP34aYohkl9ln8nTAZjofvsJPk +++ZHy+jc6XbiyVxesEeV01cM4GmM90U82BqtI+qHbqcYj8Mw68eRMogxvyfS+T4dHsQsnA5iFY9V +5bAId10xgKdryJcEX3WRMsaceB4dcwP9vQWP90Yv6vV99UROpuXho5X5MGWTCUTC4cuhhbliAE/C +EaVg9Voe/oPrUCdonZGbCXwO4/wEhuNi+nvJWuf702tSvBYYhaLm0OUoyV4xgMt8eMCmGaPRFB22 +wtMncF8mEVztfmPjUvx9+/OBSFIElbBlb3YZuIArBnC5XL4RytqxOc537oYhj0nrPncsYcV8zNXR +o248f43prDqtsV6Zr64QQU8TlG+hKD2jsibtdHYk7ZfvA5jkQ//xerh4jVkOdaS6Zr68DHcNuWIA +lyG/LzZ6nLrvIEU1RJx7Ej4EnNr3l8Pe12ZNO6T3zKGfcT7nFQP4vLn+GC5++Gby83uwWc6TInBW +iIy5040HXrzxql5FSBulrV4xgKfQ9ZcbC1Tnb6U3b0A6TyKtYB7UuneROllAcuc9logIqK4YwFPG +9QiTR27G+jkkLZ/cj/KcFwYPS9V7gaR50dwwPbliAE/V7o9hfGY/l+56BiZeh/xJTi+9+oXB4r3W +Lzyv1LVKFXelHPyUrT6oE6oTz6XbjZGoefLJ9ACqqJoHTd0rVCgUclX8FQN4SpAf6Knn0y+ezWCl +fMJI/LO0OerCPuTyzkj7VKpMrH3ikPOKAXwOwM9d2sforucg5vzluuHmZ/fZPjsxONBfR0kQhtZS +cYUJ/PzufFcJk3teRFWXj6+yd1mAgKz3iuS8wLJXLk1y3BUP8PkC/AbER3Qe/Wo62fXQKz//J+GS +Lc/GOSD2yvn6Cgh8srM8jzfh/sHJ5rVw7KUwPQC2AP8UdDurTsUnZ/AsxJaL/fRKMehJXHxHXOxj +MDpAls+RXnoBxmeoLYH4KTqrSEWTM8ABD2cqd8UDPFnLj6rHHP9i5jauR02JNzWOKbin8LS8YGpz +FjUXnfrTu+94csUALifaNoo5fQdJft2uWP80uFQa4ay54D3n1XIhDFa8YgCX97Dgyy569vmYmNlN +i54OhqkGp2YdOK+G0RVJ2JOw+FKljO75SuotATN9mkUmj2a6ZQyrg0uvqk2xMptYdcUAnljMJ5oi +wz3Uj34ZjFYg3n76hSa1eDOdWE3XNx88oOX2PJgrBvCED2Ms0emXIqvXUlYZmM1wM76nIRmhOinj +amVzayp+Wq9iroDAJ7SnMLEjSRVz8QZUHBJPnr6nqwagkvXrRlmcOZH6CU9fi/4Krz2g1GXB+sUC +dPSFcuY+yw5Pw03xoj87qfKKAXy2u0koixxfe9DkCwmt4GMtFR/mMF4xgM9l9wveV+RVGcbSfyHN +sFRVVV9ba5ToiTOSfyUNQL1D8ajIF86Y2h0PoDjnfJxEzY01ntjx/wO01j38AzCIrwAAAABJRU5E +rkJggk== +Chameleon 2.0 Users GuideRevision 0.4Table of ContentsIntroductionPage 2Running the InstallerPage 3Custom InstallPage 4Advanced OptionsPage 6Boot.plist configurationPage 7Custom boot.plist variablesPage 6ThemesPage 8Screen LayoutPage 9Boot devicesPage 8Boot promptPage 9Info boxPage 10MenuPage 11Boot displayPage 12IntroductionChameleon 2.0 the latest version of the of the Chameleon boot loader for OS X on X86 hardware. It is an EFI boot loader that is designed to replace the Darwin and PC_EFI boot loaders. It has several new features including:Graphical User Interface modeCustomizable ImagesSupport for GPT/MBR partition typesRAID supportiVBORw0KGgoAAAANSUhEUgAABAAAAAMACAIAAAA12IJaAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJ +bWFnZVJlYWR5ccllPAABydhJREFUeNrs/WmQZNmVH3b+zzn3vufuseZWmVlZe2FtoFBAA91NtjXZ +UnWTHJFscdE2kmkkcUbkjGnMNF/GZr6MaT7OhzGbxUY2MtkMKaMojc2IklEUF0ndTfRONIAG0I1G +YakqFGqvyj0zItz9vXfvPWc+3OceHpGZ1SDZpDGRJ5DI8vD4uWeEx4vMe+/Z6IUXfx6AmRIxTr6d +vFMBfsCH3Lt37969e/fu3bt3/3D48X0iBnTtNu5cv8vr+927d+/evXv37t27d/+QenrhxZc2tw4P +3jHgvlsN9+7du3fv3r179+7dP0Seq17vEh60jdj4qHv37t27d+/evXv37h9WT7UG4MTuwRQnNwoP +2Gq4d+/evXv37t27d+/+IfN87+4BG6lCY57QSm/uJ9y7d+/evXv37t27d//Q+XUE4FTm0OlEons2 +Ge7du3fv3r179+7du3/4/Lp2+NQe4tSD791kuHfv3r179+7du3fv/uHzTHRv/6BT0QReP6wC9+7d +u3fv3r179+7dP6x+owhYzfAHjQ/YfHPv3r179+7du3fv3v1D5k91AdpE+IPSjNy7d+/evXv37t27 +d/+QeT4ZHcBGhtBm7GB9p7p37969e/fu3bt37/7h9ccRgPUG4kN2EvfdcLh37969e/fu3bt37/5h +8bxZPXDqBu7TWBTu3bt37969e/fu3bt/eD0/aHTwamTA5m1e7Rncu3fv3r179+7du3f/UHr69Gde +uidAcHpqwH0jC+7du3fv3r179+7du3/oPBPdWwd8n8HCpyIL7t27d+/evXv37t27fxj9Zp7Q6ajB +yee6d76Ae/fu3bt37969e/fuHzJPL7z40oMCBA8oH1b37t27d+/evXv37t0/pP6BRcCnthEbH3Xv +3r179+7du3fv3v3D6k9NAlaAYQr6IWeMuXfv3r179+7du3fv/mHyfO/uARupQicbDN3bRtS9e/fu +3bt37969e/cPk19HAE5lDp1OJLpnk+HevXv37t27d+/evfuHz69rh0/tIU49+N5Nhnv37t27d+/e +vXv37h8+z0T39g86FU3g9cMqcO/evXv37t27d+/e/cPqN4qA1Qz3FhN8SIWBe/fu3bt37969e/fu +Hy5/qgvQJsIflGbk3r179+7du3fv3r37h8zfOzd4nSG0GTtY36nu3bt37969e/fu3bt/eP1xBGC9 +gfiQncR9Nxzu3bt37969e/fu3bt/WDxvVg+cuoH7NBaFe/fu3bt37969e/fuH17PDxodvBoZsHmb +V3sG9+7du3fv3r179+7dP5SePv2Zl+4JEJyeGnDfyIJ79+7du3fv3r179+4fOs9E99YB32ew8KnI +gnv37t27d+/evXv37h9Gv5kndDpqcPK57p0v4N69e/fu3bt37969+4fM0wsvvvSgAMEDyofVvXv3 +7t27d+/evXv3D6l/YBHwqW3Exkfdu3fv3r179+7du3f/sPpTk4AVYJiCfsgZY+7du3fv3r179+7d +u3+YPN+7e8BGqtDJBkP3thF17969e/fu3bt37979w+TXEYBTmUOnE4nu2WS4d+/evXv37t27d+/+ +4fPr2uFTe4hTD753k+HevXv37t27d+/evfuHzzPRvf2DTkUTeP2wCty7d+/evXv37t27d/+w+o0i +YDXDvcUEH1Jh4N69e/fu3bt37969+4fLn+oCtInwB6UZuXfv3r179+7du3fv/iHz984NXmcIbcYO +1neqe/fu3bt37969e/fuH15/HAFYbyA+ZCdx3w2He/fu3bt37969e/fuHxbPm9UDp27gPo1F4d69 +e/fu3bt37969+4fX84NGB69GBmze5tWewb179+7du3fv3r179w+lp09/5qV7AgSnpwbcN7Lg3r17 +9+7du3fv3r37h84z0b11wPcZLHwqsuDevXv37t27d+/evfuH0W/mCZ2OGpx8rnvnC7h37969e/fu +3bt37/4h8/TCiy89KEDwgPJhde/evXv37t27d+/e/UPqH1gEfGobsfFR9+7du3fv3r179+7dP6z+ +1CRgBRimoB9yxph79+7du3fv3r179+4fJs/37h6wkSp0ssHQvW1E3bt37969e/fu3bt3/zD5dQTg +VObQ6USiezYZ7t27d+/evXv37t27f/j8unb41B7i1IPv3WS4d+/evXv37t27d+/+4fNMdG//oFPR +BF4/rAL37t27d+/evXv37t0/rH6jCFjNcG8xwYdUGLh37969e/fu3bt37/7h8qe6AG0i/EFpRu7d +u3fv3r179+7du3/I/L1zg9cZQpuxg/Wd6t69e/fu3bt37969+4fXH0cA1huID9lJ3HfD4d69e/fu +3bt37969+4fF82b1wKkbuE9jUbh37969e/fu3bt37/7h9fyg0cGrkQGbt3m1Z3Dv3r179+7du3fv +3v1D6enTn3npngDB6akB940suHfv3r179+7du3fv/qHzTHRvHfB9Bgufiiy4d+/evXv37t27d+/+ +YfSbeUKnowYnn+ve+QLu3bt37969e/fu3bt/yDy98OJLDwoQPKB8WN27d+/e/T9vnokAA+i+XK2C +k89uxV9P9+7du38E/QOLgE9tIzY+6t69e/fu/7nwTLT+pWbETEwA6l3rG8QswsSod65W/8YkdVdQ +lb+e7t27d/+I+FOTgBVgmIJ+yBlj7t27d+/+n6lnluO/1plMbb2spxNn/AaQmZ28E/UeMzsdIIAB +pGZ1L+Gvv3v37t3/CHu+d/eAjVShkw2G7m0j6t69e/fu/1n4elq/Xv2PB/xELExEwkQEJjBBmJgg +zMIUhFfvjr8H4XqDCLR6A1CjByKrfxuINo6O/PV37969+x8pv44AnMocOp1IdM8mw7179+7d/7Pw +dam/XvQDVj+6kc4DItpM7/nQ59d10MDUVlGB+oH1Px6bH4WeDBf498u9e/fuH3a/rh0+tYc49eB7 +Nxnu3bt37/6frl+dxNNxTj+R8HiEX8/+WQJLIBYiIWJhEZbV2T8H4SAhSL3BwiwsIQQiIRLi+ovH +pxoDCFzDAixMAPFxmYF/v9y7d+/+R8PTCy/+/H1TiD5kS+HevXv37v+peqYTif40luqOJ/2mRizH +d9b/jR8CMe7J+8fmHVqMeDzg1zH7H2o1EKAAtOjq7P84JjD6e4oE/Pvl3r179w+d3ywCVjP8EI+E +e/fu3bv/p+eZ1gk/62wfA4iFAV4l+9QP1Y3A2MlnY93PAFhObgPU6k7A6q1Vbo+ZaVnnAtkPtxNY +5wf598u9e/fuHz5/qgvQJsIflGbk3r179+7/MP166W9qLLx56r+x9CciksDrRT8Rg4h5zBfCqh1Q +/d3M6s115x8zU7P6EdP6nm1uBszGJX7dCZjaasMAYON5jmMCOLUf8O+ve/fu3f/z7O9NAbpvucD6 +wVrLBty7d+/e/R+ur6k1IrQCJsxYHfJLXezz+jdiqVlAqw+tHie8Kha2jcb/4/q+9oK29am/qq7D +A5rNsNoQmJmaqmk99TczLQCKKhN9SLnwumS5Jh4VLf79de/evft/3vxxBGD9sA/ZSdx3w+HevXv3 +7v9J/EbOD+ox/6lT/1rrC4CJmZmF1jeISFYdPZmFeAwR4ESbIFot2Mez/HpLtcCsrE79zayoAarl +OCxgZlp0MzVoHRAYI82gzbDA8de4ERSolQN4QAmBXw/u3bt3/8/Y0wsvvvSg0cGnHry6re7du3fv +/g/L33f1DxCLMFld7I/Nf0Rqtx5mCkFgJiHWrYIwmIVA64rhzd/HM//1ql0NpuOC3qyYmqKUvNoM +qGpd9qsptC7/6yPsdJFAXeWvKwo2ggN13NgYInjQruCe18qvB/fu3bv/Z+H5QaODVyMDNm/XR7p3 +7969+z8cvzFvi4SxyvOREESYJAQWFpYYY4wxSAgxtE1omhhCbCaTpgltGydt07aTpm3aSdO0Tds2 +k0k7mbTteLuZTOJ02tZfbRvbSdNO2sm0adsmNrGJTdOEtm1jW2/HJobYxBhijCGMf3YIQaT+4tpR +VABedSAlltpK9NS4Md6cOFb3OeNWh2vX0XX5sl8P7t27d//PztOnP/PSPQGCH3YP4d69e/fu//H8 +6uAf6yledek/9uNnZmGAYgyrU3+OgVkCCwdhIhZh5vF3ZmYi1Acynzr+3ziAH9N3Vin+xQxZ1Uw1 +a1E1s1K0fqSUbGZFVYupqpqqwrQUXbUGKuvK4XtLhMf4QC1oxvFHDKD7FhMDOFkw4NePe/fu3f/T +8mMNwA/ROvTEs7h37969+39sLyzYSPuR8VBcVuW8HAIzCwsJCzPFIHXpH0VYWERYOIgw05gZtNoB +1IICZqZ17g2BAF1l4+iYyYMxvb/Utb2tVv+l5LLeCRQtWqzkrKiVAFAtRe3e3kF12Px4e1zon+4a +tJk19CHFxPfbBvj14969e/d/mP7EHIB1+GDzwQ8uJnDv3r179//InokAo/Gc3oS51vuuB/vymATE +IhyCCDOHEETqjF8J9UMiIswk9QFE4zZgnXCzmgqwWQZQx36Zrvv8qJqVoqalqKlqKVnV6q6glPFd +LVpMSy41ZKBFVeuqvRYNQ0upz1/UVoHm1X5gNW6s9iEtWmsDTs8Z2Lgfm3MG/Ppx7969+38a/sOK +gB9QPqzu3bt37/4fz9cRv6tunlg19WQmlsBEFCTUg/8QhZmDhBhEZMy/H2+LCLOEcWvARPV2Xf2L +CE7m/9QZAHWFbasggKqqFjPSUorW31TVSl34r9+tu4AaC1DLq5SgsqoINoMWVdQT/XG2wHiub6iT +BtY7kHXRcNGxu+g6LLCKJ9CaYaNQ2K8f9+7du/9D9KdTgD5kwvB9mXv37t27/yF9zfwBwKte/Syh +pgCxMBEHkRBYREIQEZYQ64o/xPHUP8ZYl/8hhFolLLVMmJmYRKQWAhDXVqAnqgB0naGjZrBSxrSe +nHPdD5RS6gag1Oyf1X9rP6CcanWAlZoFZKtuoaoG6DhYYEwuqof6dWJxjRJYrSHARtZQGRORdPzP +cRhhDAsUPdkz1K839+7du/9D8icnASvAMAX9kDPG3Lt37979D+XX7T5XZ/8gDgDiuIYfc/lFJDYi +HGIQCRJiqB14xjY8UUKIqx1CLQKoe4aaOCQ1mjA2eQCNrR/qUTzWKfljMbCWYoZSahJQLmolb5z/ +Fy1acs7HuwK1GhfQWjkw5hBBVxEB1Az+VQKQbkYJxsQeA+rYAa3FxOtQwrq7aM0LqsGEugf4IUIB +fr25d+/e/T+Cv88gsM13H5Q/5N69e/fuf3i/mvI7DvaqZ/9Sp3kJM3GIwiSxkSAsITYx1IP/JoYg +IkFCGJtx1qV/jIFZYpB68C9Sn2y9+jeuiUDj8n/8tFCHANR0/KKm9VxeSx4b/pSsYxlw0TzuBsqq +HiCVYrbaDBis6HpMmNZ8n/VCXsdQA1BX9KZkKGPd8RgzyMVgtpozYCWviwrWe4BVMKEonx4q7Neb +e/fu3f8T+NUG4FTm0H0HCH8IcO/evXv39/dYTfTdPPvfXP03TWCWGEUkxFhzf2qzf6mr/ljjAKtu +/DFwjQmwCBOLkIjQ+GTjJDHi4wkDG595PftX1GP7uvyviT01/SeXmuVfshbVnLOqppTNrOQ8dgzS +GjKomUFjRXFZzxUzlFyISHX8U2rEQcc0Hyt1/PBGd9Gx3ehq6nAZc4DqHzD2CBqLicf0Ib/e3Lt3 +7/6fyJ+eA/AHthH9kD2He/fu3bs/5Terflc9f46P62MIteNnjPWUP8T1rxBCCLGpY7ikHv43MYQY +ggjXLCAWWQ0FEGECiJkAEQFRbbpPqwgArfp01mV0yVnHA3uUUm9rXeSXnFU1l5Kzmmou67dx3a9j +jYDW0QJjV6BVwo+OG4zjG7XJqK72HGX1/1x7D6nVGuNcClC7DNW4wlgVoOtagROjhP16c+/evft/ +TE8vvPjzP0TT0BMPc+/evXv3P4xfT/siYiawsClC7dgjvDrEFxZpY4xNXfKHZpzBG5omBpGmaWIc +76+5/yFIDEGCrGcAiAityn6FZX3oT0TEXFNzVp9bzc4xG9fsWtRKzjVNX1cH/WPyTymlaC7FVNO4 +NyhmVu/RcY7AGARYZfGPBQarCgGF0XrIgI5dREsp46K/lFy3AaVoWe0JxlCAmlmpMwo2uwOpFb/e +3Lt37/6fxJ+YA2CGH+KRcO/evXv3f6A/lffPwgBquS/V/p6xNvap6f1SV/9tE2OMMYYYYxNjWN8I +Ept1KGDdC5THSuAaURChMQZgBjDzehswtthfZdWvO3XWk34YdEzp0VVLUNNScslasDru15zKesNQ +aoaP6olUorHMYD1m4HgjUEqpewBTy7WQOJdSshbLte5YNSc1KzlrLUIY6wusrJqEHs8N2GgN5Neb +e/fu3f8j+1NdgDYR/qA0I/fu3bt3f39/qt8/Tlb9BqmLeK5H+zHEGKRpYwihbZsQQoyxaWI9+6+b +gVoeEGOsIwLq4j8EYSKRAEIdE1b/KBwnHdVD+bEkYF2Za6ogKqWe0dsq/V7Lqi/QaidwPCCgRgZq +MYDW43xVVdSV/caR//oG1u+Pe4vjbkKqRXMNMSTNJY97gZJzvbemIZlp0ZSLqeJEw1C7ZwPg16d7 +9+7d/yP4e1OA7lsusH6wAuzevXv37j/Erzt+AhAGERMLEYLIKu9faqfPGGMbY2hCU5N/mhBjE2Ns +mybG0LQxSGjaJoawihGMZ/8hSBAhYhYSESYCqAYZHru0GIbbWXu1rrYDCmglToNMidqbV7cAqsk2 +IJgaiGxM7dfNOECtz625OqYoWhOBcs3JGVf51Y9jxcaKgrG30Grpb6u0/rptWJcTlDym/KScc8ql +aC45pVSKlqyb3UjXJQG1c+g4a6zOIvbrzb179+7/0f192oB+yE7ivhsO9+7du3e/9nXa18lZv3Lq +7J+ZmyaE06v/plkf/DexaUITa/qP1JiAhHHdX+sGWCgGIRIiMPN0arv7V4f8dtj6bldeTfmqWWdm +zJMoZwOdBZ2Fnb36bqNlNpmc25qdD3z+8PYUQM35MVjdFWhZF+Zq0XFeV0pp1cSz1KX82MznxKJf +V13/dRwSVqym9RigRVPOdSFfcs0Aqkf+Zci55JJTTiXnlFMee5HmtK47HvcAJ2uCT/cF8uvTvXv3 +7n8YTy+8+NKDRgfj/o1F1b179+7dP8ivO35u9vwhYgksfCLvv41RgrRt08QQmyYEmUwmMYa2aUIM +bdvEGJuxQiBIYBFpYmQWCSJMFIiNY4xPPn1U+Ju3jr465B/EeCfpNcKiAEyIcmGxSF1XkiINGAYA +Ozk3LFtN3IsSY3P+ycd/Yit+8v3Xz6SSMY70gqrmkmGohbs5l+PxYWOm0LgZMEDru6u64tXiv95e +V/QWHQeNjav/lFLdEuScU0qqmnJOw2oDUHJKRbWksfpYcylm4xSx1XRhBehB6UB+fbp37979g/wY +AXjwDOF7Ywpw7969e/cPOv4nJlMLgU/N+l33/FnV9QYRmUzG/J62iU0Tm7ZtYtO0oa79x7fxkbwq +ARYmMAsLn79Qkr2R6bcXw5dD+24zubPsNGcLTJNmOgzDncO46LucTIGiMIBA2VAMKQOw7W1p6Ynz +uz97dvqz/Z1PlZzHNbyqKtbVvbW3Z9ECg1rJWQGUkmtwQI9n+p7oBFTb/ozpQ6vqYS06pGJaUkop +55xLHvcA4+/DkEopw1DjAapahiHXOEBNGgKwmhpwHATw69O9e/fuf3h/eg7AfdOGHrSHcO/evXv3 +J8/+AZAw0RgHqL06WZjr7N6a+dPEEEJomxib2DRN28TYNE0T27apEYC4av0TxoEAsvo/S2AmYeb9 +89fi1jfefv83Bn3l/IUz04l1w3t9f5eZrMQy7N28dfMoazIIoyiGAaFBVhBDBCIoii6hBQfsTsLz +T5z7c2emnz26fQGwevAPWCmrQ33VUhN6Vj3/dZXoX4rWMcNFFWa1yrcWGOi6VKAUNct5LCQouaSU +cyk55zSkNC79h1oOkIaUc06pDCnVUoGNOICueoPa/ZoC+fXp3r1793+wl4uXnl89bD0tkjaeizae +hbAaKunevXv37jf92Oxz7LxPAJhDXf1vzvqtLf5jCG1bE/2bJoZ20jYxtpO6B2hr/k8tBgg1XyjU +cWAhBAkSds+k81e+cXv5t155/e91w1s7e02MB316//ad5TBgGp+YL+KNG9ezWqGYiymCFpTaAIio +CVNmHnIpBZMQVMvuDqXyzsH8683svb3zi0bOMO2Y8fhGFiSMLUdXYwdYWCQwkYgEqcMMOMg4miCs +JpwFEWaSGvuoxQvENYuJa5kEMwiregkmIpjVWcaA0aqFqY2veB1khvrh+h9VYyLz69O9e/fuf2gv +Fy89t3rYeNfanXwu2ny8e/fu3btfeybQqul+kNqWPwhTXeiGKMyhaVar/3V+f9vEIO1k0rbNesXf +NLFZjQIIsp4EHEKQEGU6iVu7h9Nzf/PO4le69LK0d2czTGdh2d9+9/28WCBGUZ3N5/0wDJlomUox +MMFYzMCIZmCOWijlUgoJQwiLozRpjaRbDq+rvTbZfntr50YuZ3a3pykFlkBkRFy3MyJChLERKcuq +L9E4lGDVpUjCulaZx4W/sBCRCMtYIT32LR2HpgnXJT0TA0br9b5hvE0oxerSv+4BYFZ3XON0A78+ +3bt37/6H8x9WBPyA8mF17969e/drv276SUTCYyyAiSVwGJfCYTz7b0IMoWljE5umbZoYmrZp25ry +E+qNpqkzgJs6A1iCBBEJJBxms3D+8psH/S/f7v8r4cV8jiGXrRmM+OhIDw+wszXZ3j136/b7XacG +7gYtQswGkBbAQiNbaUA/dFY0NjtNmBazYLpc3mmiEbrJlNrGLjwWt7f3hZ7Za39mOPrxgGfv3G7M +zKAEqJZiBq2rblpNBDYQajsgGAympitqJa9nAGspJZdS63xTLrUCOKU0DDmlYRhy3w85pSGlfkhp +qB8sQxpK1to4qJYR1+JkMxQ9XQzg16d79+7df7gPVd+3Z9C9NcUPri1w7969+0fRb477BYyYiUSY +WJiI16v/ICFEjnFs7tk0sXb+aZu2aWI79v1cnf3Xrv/jwK8gAuHQTm37/K9+cPBrQ/muKW7Py90D +xIbacPZofudwDmaSZvdwfnDUqQiyqgVEMWHuOuvmiHKem2d3wqVnzz974cyzbXtm0uxNmq2UB1Xt +l93NO++W9M7Nwy9dffdL0+fIwivX7r7Z8O+18vHp7kt5+ZGa9g8IwyCo/f9jE03VDLVJP8b2PJpS +hpBIKaohcMkonFVNRLhkYU65EOcaLyEiAq9Op4wIINTa4vqcZgEoZmYsasbMRQsxQw2wWni9+W+b +X5/u3bt3/2H+5CRgBRimoB9yxph79+7dP7p+8+yfyVjEFCHUNp08TvsNMmniOPOrjashX7FpY9M0 +bdu27XHmTwg1RNAECbEJIiEEEo5NM9D237oz/9vtzgEgd+7cPrqrRtjd3UkD3Tk4WPQ4d25re/fM +9RvvGNBOaNFZ04ThcJaHnSZevHT2haeufOHS+Y+d3X22lV3CFtAA8XiRDQCq5ebB4q3vvPLf3e1+ +u9l6bW8/9MOdw8Nbk/gnrpz7V4ejj7BN1Eo/dKVk1bJ77iY3d/tu2feHw5Cms70Ypk1sgO1r7+wF +iYx2GGLXlVKyWinZ1CynrKo55yHlUnJOeUgl5zT0Qz+kYRiGIfX9kFIa+qFPaehTqkGBcUTARhDA +an9R2Crk4Nene/fu3f+B/j6DwDbfve+d7t27d+9+3fTzVMt/CQJQ00QibtuwmfdfV/lNbGIT2rad +tG3ThKZtY5SmbgJCWKf9hCjMEmNs4hC2/vbN7m8ZvZ3AJdPdo5wHnNuZUIh3Dw4PFkiKK5fOgfjg +8HrKsEJBZoe3Z+emP/fskz/50Wc+e/nSxwW7QAswDDae1Nd/B7RYFjCQAQYaYHjrg1957e3/XCZv +Qt6RcG0+zyhPPP34H7l05rmDxd1bt99ZLG/0/Y2Cu6GxppnCYjfkfuiZyWw5iXuxeWxn69lZ+5zk +p47uPn3r+s6Qcp3mW3JR1aHOAUg5lzz0tRHQuAfo+z6l3Pd93Qb0/TAMKeWchzSkkkvOKeesqmU9 +IXgcDwzUBkV+fbp37979h/nVBuBU5tB9Bwh/CHDv3r37R8tvHP9DmDebfo5NO6PUBX0I0rTN2Om/ +tvts2rZtmza0bbuuCV4X/oYoIdQcoDCbmcX/5oNbf3+eXtvbP9Olg8NF6joEwdm9rW7o7h6UowXO +XZhO2jDked+r5Zj7x8tw+bOf/HOf+ehLe9tXGLtmUjQIxVWKzFg0W98BDFRgZMbIyEghHLx3+xe/ +/vL/K05eRXw/CKUOTTy7t/ukUOz7g2X3vurhkI0IxGhiJJktFgdFJScW3isphVC2t8+27WP7088j +fbwMz1x7f19Vcy5mmnLJKedS0jDkUuoEgJRS3w39MKzjAEPfDyn1/VgnkHPq+1RU6xyxXNQsazke +D6xW/Pp07969+w/38tjFZ2ra5cYHjt9dPZjW9cWngHv37t0/gp5XD2FmpprxL0xUk39iFBGp3Tub +EGJb53yNPf6bpmknTdMcr/6bplmn/ocIo4GpbG+1Tz9/+6j87bvd3x/ytb4biHaPlouu1xi3AjcG +TX1aDEgZ58+dz3mRhqQlpv7ibvNTf+Zn/3cvPP8np80FYGomsIYoMqGu14lAZET1i69NN40gRExC +qsVs2J3t3bz77rXrX+PQq0IVZomJYmRQWixuLZbKBGHKhRZ9GYY+JVJthc8G3lZbdsNhn+8O+b1l ++t4wXM361vkLQwhnySaq9SW02jIJZiAQwax2/6yBiVVRgWGcL1aHjlHduZCaEUyNiAGr/YKIQObX +s3v37t1/qJeLl56/p3/Q5iOxevBxn1H37t27f8Q9rSpXicBcV/7HbX+YQxMlNE0TQ2zG1X/t8R9r +1/8mrKIBzbrwt9YABMl9utbrN3ny8jz9+mH3ayEeJD3sBjUshlyYEWg/tpOs/WKZ5gssB9vZwWKx +LDn284vPX/6Lv/Cz/9tzu59W3TULsAnQEMYmm6vj//qLjn/VjxmBTAKrWZAzwsMHN7+T9bpaISAE +cOhgB0RDNyzv3DEYJIqCUjZV6jtLJYPmareMOhBYkAaUlJTuFnqrL69Lc+3Jpy/0y3M5EfP4SYyt +PmvruvE1t3q3manVCcQ23lsU602BgWB127AaCAz169m9e/fuP9TLxUvPrT6gZvbgRx7vIdy7d+/+ +UfZc5/3SOvlHavd6Fg4hBJGmCSHEJoYYpK7w1wv9Sdu0TQwxtm3TjkOAQx30FWIQ5hins+ljz37c +rt39u719VXGNpU2p75MprG1pMp0UWjJj2S3mCyw7M2B7uwl0rju69LlP/OV/8Sf+SpQrZhOGwAQg +GLiur2lz9Q+Ax9P2+m+DEchAplqEWlOJU1y/9d1OX23bTIQQwVKGnAw9E5ViXYd+sGGwXMBCsQ0S +LbToehjQROQMJoKSIklUCWnZ3zk4uHHh/JYOF4ZxD0DHk7zqILCxpyfBVm/jpsDGNT9MSx0QVhN/ +rMYO6riAdRDAr2f37t27v6/fTAzizQICQFeP3LwT7t27d+8e4/wvWrX/r8f/QZiZiZlD4BBCbJpY +q4CDjF0+mxhX7T5DiCHUCcEhhhAkNE2UEJpGD45el+aWyCJEIWqHZMYoBgkkTWZO4KMu2XiMT9Qd +bvVHj3/yuX/zj33u3xN63LTlseoLTGBZZX/CAF39OvEvx7jGJgCJiAyck0zCOaLzwARCzBQiOCAr +ht7Atr07MWDooIoYQzudhKa00zhpzwgRlFWjIbTTnXarNWjf9YvlPMQkzZtXD/7m7sXf3tlBkBiD +hCDrF6rOPmvbpok1JyqMk9DqODQZX2URDoHHaWRMxDIOu9H19savZ/fu3bu/v+d7HqkrdPrBqzai +7t27d//o+vEonWu7ejKtK2yumwFmjkFCreUNEgLXJWzTNCJSB36FEN58440vfvFXmiYwUds2df0f +AjNLO0Hc+cZ717508+YNiVcms8cW/fVFr1BszWg6s5yzBBBr/byyAdrODy+d237pj7z478DOlhJg +ZJZYMvFqkT+m/hegrP89gMEMZlpKNqWsuWiXS0/ETJBgjJlgp+8XOWsBE9gMElCAfrBmsrW7v5MB +IyrGi66bz+323eGDq7e65SR1u8t5MIPaUuKwf2avncVUur67WuiqtC/Py9+98NSXZ1sQCSGKCNe+ +p2P0REJYvVzjRiCGuN4uBGERovXctdqKdfxe1Pf9enbv3r37B3le7wlWD+NTO4nNBwPu3bt3/4j7 +VQUVEzGx1INnYpZ6Gs0yHlPXhj41vaeJsW3HLp9NE//BL/36bLIdQghR6qpXhFmIhSVeO+y+kem7 +02kDw2J+cDTPOSEGbprZMGAYUDJKIQBDwtaE0hDJnnvhE39+t302F5GYJSYzhQmgNasHdHwOdJzz +U//DJiF0Sw2BhE04qKGogQtAs8mZPvVakIfSJxXmEACGCHKZz3Z2weizZZOS47J+eopsy17v9GXZ +D/noKB3OS9IkUcMEfVkeHX5QcDvb1+4c/fqVp9/YO8tBpBmnJYQYY+2CGqUGUZoxP0rq/kBCEOFV +0UVgYQaICYDg1Ffo17N79+7d38/zvaGBU41C77nt3r1794+0r4vN2v6/HjkLEwuJcBCuK9UYQ20E +NI71FW5ibNoYgjQx/s///X/7T/6pl0KQtmljjMwUAjOFdtLPy9fn6auQ9yXezPlO1821wApAu6aT +oUcpgJImmCIIYpA0DNNw6eJjz86HRAzYAGRmAcRQDNlQal79xr8FVqtmCVDN/8//5P/xL/7cH/v3 +//JfuXbjWjGoFiIqyIYh61AKDEQsoDYnQUEUQAAqzMNsm+cdjubL+TzBWATSgAI4AAwORNwsjvD+ ++4sbtzIRdnekbSkPNqS07L951P/mdHqzbp9iGKeojTlRUZpmPPVfv54iIsIiHGKoEQAWYRmDACzM +dJzz6teze/fu3d/X86ksoFM3xrYQphtP5N69e/ePqGciNcNxWdXx8T8TE5PIuEINIuO5dQghhKat +2Swxxsgi5y+cC6t8FyISISKJMdDkmyV8FXKzFM22HPTmkMvQoWlCbJqsJRdjgIlThgAhYMhFKM+2 +ioRFzoeL5TwlNmtVNxvj1MBFqMv2dfa/mYHxa7/26//r/+A//MpX/+Ff/X//tS996evCEy0KNpRM +sIPF9W6wxdJgQjY7OMpHC6AWFVPp862dvSkzDo7QJRsGzQmlAAwlqEGzCcd2OmlatkL9EoDsbZ0P +trs8MqObd5a/as0v75+fx1hX9kGEZQyhBAkhxFBvxxgkyPiKynEQoNZgENfmoExEZkb1Dr+e3bt3 +7/5+nk8++DiRaPPp7t1DuHfv3v2j6UVqtv9xHKAe/zNxYB4HgYVxzRpqHvtqwFetDG6ayCy17JeZ +QxDmKCLSXj8avknxNdU7OcGUYcEMyojTQtSlIaahSQOyFs1mhSYhTgJPZ/butS/+xpf/yy7f2N7a +LWXSdwxjtQQ1U4ERjOoXt9oDAFBCAXD+/GPPPPUMQH/mX/pzP/WFPwZQMYWZSLNI1w8X75OFocd8 +MSyXvWYeenS9ZUVSBZdmEs6d3ckZ/YCup8USaUAtjQCQCo4W88WiQ2ERHjo6uFPmCw2yH0PMaQA+ +mPdf2Tn3VTMmFgkcYyNB4irvpy79x0ZJIbCMCUDj71zrL1bbAAIxCR/3vPPr2b179+7v9XwyYeg4 +kQj3Kya4J8HIvXv37h9BXzus1eYzBBATcyCWwPVcmlmYxqrWGGpdQM1hF+HjXJcQQz3AFt7e75N8 +4273W4vh9Zy7nJGHJg9RFdKCg2Wba1HLMWeAsLXFAOcc1BAa6/Jrv/bl//N//8v/6be+89V+WMSW +lOdKR0YASA2GcVQuxtJfGAwMs/LCCy/+4i/+j7/yq7/yN/6L//zCxQtqw7QVpuUyX//6t//Bux98 +M8hW08RuwDAMk8k5Ax8eWbfEMNQXDVs7FCLyAM2cBk4DkUUhJoIaQMREKee+LwYqpblx4+ZQuscu +PMvMfVpyvHW0fPnClbdrAlVtrspEIlQzf0IYAytBZP061lSgWu7LMk5l4I3knzqqwa9n9+7du7/X +y8VLz63C2boKCo8jA4g23713voB79+7dP0K+5v/UfjOrvB9m4RADE8cosQkiEmNcd/6v/X/aJpy4 +M4QY67KWmSXGCAzz8pWF/Z15/3vM6HoMA/bPnCHWxXKYTaVppCgNebEcBmJIwJCpz5pSNrIQYmhI +Mbxz9euvvPmb71z93UV+W9oDYeO4FallZiIzsnEvYFSnaRmMSVTp/IVzzzzzzHTaMs2VbnXdW99+ +45d+/5W/9e6135j338p6VLQQ0Cc1S8ZWsuUCAzgwgWfT7fniaL7EtAUxqRqgHKioCSM2aKIQoxhU +TZpiTGqTdiLGcyqTGANwe3sn7M+evnu3rZMAxjEAWof/mplq0VwKAK1vZuN/YKWYmYKQS6mDxWru +k2r9r1/P7t27d3/C0wsvvnRyGgA2owmbwYKNrYN79+7dP3JeWOq5sjCxjNN/WbhpxiaVbdu2bTOZ +NE3TtG3Ttu1sNm2bOJm0TdtM2rYOA161ug8xxqYttw/feOfaL8/OfHf/sXeOjq7tbO8cHB1psd3d +s8Nwd0iFhQCoIWfrOpiCCGAqsK6DFUBpSNZ1tlwChiZsa9mZtY8/funFy2c/ce7M5QvnLm5NdifT +mcQmSisIDAFYoQoFsOyWXXdnGA7uLN+9ev17b7zzlbuHr56/sJ/yzZt33okNQkQTQISi2N2Vra2t +lOfDUJqGgmBn58IwdL/91buTSLu7xASFtS1YQMD21iSE2PcLEHJSEdMCJNrdp7O7k0Bnh/4Wi+xs +/UQ5+jfuXPt4LiknHVJKQxqGNAzDsuv7oR+6Ydn13bLr+r7vh74fuq5PQ+r7fkgl5ZxSKrkUNbOc +s5rB1HRVB+HXs3v37t2v38K6aGAdO7gnf4jvfQr37t27f/R8HbpFx4lATLUHJdU5wFxzUbiWsYbA +4y5BVn1qeEz4CRKYuEtX373762+888s8ffXi/jPDIkfZXxxp31mMNKSjfigsWPYmAiaUUk+1QYzI +AMAMNYAtABNQjDg8tEW32JpsGS3efu/X337377Agxu3Z9NzW7Nxssj+b7gPCHJkF4KJZ9c6y/2Cx +PEjpoM931Y5ixN65xmhx8+71RW/bgajACBC0DZdsXTe07WxZjo6ObHtbbt66vrd34crlg/evWt9j +a0YE9D3aFqoY+lRKqS+msPUJk0CTrdmwnM9jd2YrgKmUfr58Zzu+t7P7ybt3RQRSpEipQZYgXFgS +89hfNUtm5tr+v85dE6UCgFjYrBQjJlJYLQquewC/nt27d+9+7cNm5hCgRAxT0InGoutnuae1kHv3 +7t0/Op7G+V/MwJgKRMRMJMwsRCREXDcDYyugUPcBvDHlilkktuXa0d9/84PfGPI7KV599klkfj02 +l3KJw+K6MBU1AMyU1eo037rcZ4YKCCAhNhMZG/owgQAWbG3hbtFFf72UOVHXbimLGd+Ypzfnd4Ip +S5iVYlBIaIRbUJbmqpE2kaQlEp1GUsNgmC+tTzaZEgvlbJ1BDCw2LG2+7GZbfdPEshxUY9/3B4fz +J594QvXdW7eVGLMpVKGFALtzUJpYJhMQFWaQQRWTWdstusVR2Wr6ECZHh3PiGxa/T+FzMZxVMxEW +FREVKRIC5xKC5CxEdYPFEkTyOHyBqAAcRFK21XdW63eylAe1xvPr2b1794+uP1U+zACwUUZwqqb4 +njai7t27d/+o+JMNQMckyzr9F4Taib4e9xOBmVhYmKXeWUd9MTEH8PLtO3/znRt/M07fKHS1aW17 +T5JasWEYbhd0xCiKnEsxpAQzFIUqRLhpgwi0wFSZIAwiGEEBEjCjndD5cxQbXaajbKUfdMjImQzE +jU62ODTLyVa/td/Pduft9vU4vdZMFIQ+WTGNDWWzXEwNfQ+1OjCAiNBEaiItlmZA0/DQ23KRDDg6 +6oh46IfFsr/42IX9PTJFP9TtirRxSoApDCgKFrQNUrY7d27lXErBcnmj5IEZoO6o+/r+Y98gWkVR +aot/YSYKwnX+b4xRVhssESGiIMxAECYmIhCRqdZmoADWZcF+Pbt37979cVJrLQIe9wobiUSrLQJt +BBc2Y9/u3bt3/2j5euRfW0zWDpTEJCLCq67/q4aVTYyxiU0t/A1NbGLTxBAkxChxuHr4d4/yl5rZ +naPlzUJ24YJMZ20aErMV7VgsK4jAgftBTWEGFsBgZKVYGkCEWlObC2AggAhaACAEpAwRqsXE/QBh +lhBLIc2mBrNMlCBJNRXLRjYkhECBoQYiqSNiUrKuw3RCk2ksRUMAM1QRAoGgasxjFyAWqNVK3I7Z +9vZ2U1r2HUIgK8YcYiAWVUUIiA3BiAmpQJjYqKRCkttJC3RKXeCdvdmPLeaNGVTNzMqq8LcUK1pK +0VxKvb+UUoqWsioIrin/ZgYC2VgLbFC/nt27d+/+pF8PCj61h+CTVQX3bjLcu3fv/hHy40FyzcyR +jaSg2oOSZdWMkuvZfz3tr60oZTWldjJlmn3j7vI3WLr5vOQSzPjM2XOqw6RpVLXvNGWQIEY2Vc0o +CgogpqIoA2AQgdZ0TqIxAqBQXX12hCAQsemE9vZk0lDX2Z07/XKeSlHVXErpBlsu0NeJXYQmsmbk +TKVQPxRgjA3HBtIixtxMLASIQBgxkAhqo5668YBBC1Qt5XJ4ODcbzuyfI4aqdb11facK4cAMM2gx +EHZ3ds6dmRohhMht03W6NT1jhD4dzhffbrdeJwpEBAKL1LaqLCyhBlJq93+uB/6yenFZuFZorEeA +rd9q9bZfz+7du3e/9ryxB8ADogm8flgF7t27d/9oehqX/jYm/4wN1urxC1HteF//zyxCwlSLVUEk +wk3DzSRRWOZy1Ma9kuj82XbaxtRb34kpQgMtdcFKKRsRCIDWs3CMC2KBCJgIhnGfUccOBMQIU8SA +aStty9NJ2Nvf2t7ipgWJ9YMeHJZlZ7kmyityxnyO5VKXS0vZiMwUKelyoUXRthBCLjWTBmAYMCSt +m40y5kAhK9SgOjbuvHP3cDqdXHxsPw2YTiIBpWRdd+IxBJ4MQ686tDFSEJAu5rh7eDME2d4ilRt3 +D77fTpIIBREmEhEQxp6rteRi9TWHEJhpLLEeB4ExbUxrrvuB+v3y69m9e/fu136zdEA/9JF8z4fc +u3fv/hHytQK43lHPmOtin4mIQYx6KD0eTdctwTinlkIIRFYSz5qP7M4+xpDl8hrJcGZ/WxXQ1koU +RhiXuI2aaYESah2XFaLxTyYFjKFqQ7acaiN8Aeo5OYgBQWjq9KwiYTGZ6fYWJlNIgBr6DnlASZQH +skyR2BQKpIQ0IBeUgjpqIIZ6bk8MEg5FaVBkgxopSG0MRNRfxZAVpdR5wIdbs10O6FM2mKqVnDXX +LkpBeJZzTrk0bdu2O9PJ9mQLR8shJzMl6CHCOxcvXyUaOycRKIis91W1nJpXLZWYGYAQg7Ba7kN4 +/f0dXzW/nt27d+9+02+GBvgk0gfvIdy7d+/+0fTjUvJkd/l6f90H1KAAapNKrkWpRDAjkiHZ/ObT +j599iXUH6HZ2sbe3tZwPEbMmsGnSbGxbOVvJWsbUGhDBQHWRrVpKQU5QG5sC1adnqmVeWDUMTWYD +QUOwENG0NGlo2tL2jNoGUOo6W8x1MUe3tDSgJNNipoiMScNNJCHSLDmTFtbSDj31vZWEUpALckIp +MIOBUOsQCGZgRttgsTxKuTuzv5Wy1aykUuonD2hI2VQ5KxbdkaJrmt22lZKQBgjtNmFnSG8cLa4S +jzOW63l/Lfwd1/11+u+4BahF2Mdjf1en/4KTaa9+Pbt379792t87N3idIXT6was2ou7du3f/yPra +Fod5veKvXThRz6rHdX89rSZe5QTV1SrVh/EMP3Px7E8HwvkzU9O+5AV4AT4oxUpWK1pyru131rMd +VTUlKGCG1S5jtdglIxRQbdYDYdTjbyKQGDGCIDCaiOmEtrZob6/Z35+c2Zvu7TXbWxzEmoDphLZn +NJlSjFRUmSgKqSZoIVLTXjWbkilKwtBZGqwUaP1lMIyfLRlSQiladDmbTNp2nMqrClOYsqpoBhEb +0A+2WB71ac5BJGAYrAwNrC14pxveCzLGUoSFZYytjIf+REECEbgWZ8uY61MX/MIb5XCwMV/Lr2f3 +7t273/DHKUDr0MCpncTmgzdThty7d+/+0fO07qhAqyyg4/U4AYSa+UN1rUpMzGMUYOxsCZB85Mm/ ++Pwz/9L+zmNNjLOpguapKDPaydRM10XGQaiJbDWRJQBA3WbU4/ZS6pbAUD9JMgOywoAQwAH1HwUm +BKnhAgtsQRJTJ7LcmqXtnTKdYjrF1oSaSIEgMCEwKUNjQAgQMhEzszRY1+Hg0A4ObbHA0CEnWu8E +6kp7KBBGKci5m23tBKFiMMCs/mIrnEvquiSESYuUtOsPAN6azaxQtxxSNshNaW5u72XmWNf79Qsf +M/+Fx/5LtfhaZNxzEbHQiWyfMShAGGu4/Xp27969+9HzvaGBzf5B9zQWhXv37t0/ov64lBWr3PKN +fcD6bdWNHjZ+XITNjACQ1S3C4s6Fpy/8W9vTHyPE0EQ1MqAAQy7GbSmWFUpQWFZLiqy1A08E2MZP +Zlzc15UtkTJDeJwIRjyGAmIDDkAABZAAAo7gBhxgjGJopyBBNstqCoNAGmRDNpiRWaNGuUANWS0n +OrzDb7yGN17D4vBM3zc100YVWTEMEELbEoC+TzkvmFkLiMACYpBAKZnNQTb0kMAAFotsWgAJjSgv +OCSRLeWrKd82GIgMEBZmNhitwinr134VbRm/UavbxHTi+7VK2fLr2b179+7HFKATWUCnbqxSKjc7 +B7l37979I+l5nQWE1bIf6yT/Ey2BQDx+7HhrUEsDmBkKIpCe19zM54fLrut7y4o+YzEMg2q2ogRm +KJCKGepUXVhBybneWOUCrTLfNz+f+pUIgoyfc/2zJSBEgMAMCbW0ALFhNbCgaQlAKiBCCBChVDCk +TAim474iDbQ8it/4Bt54w669f5i6oIXVoDb+ocJQtVoh3Q2HIlSzgwBSQyllSF1WbVsyIA8mjJKt +6zKIJtNtDpp1bjYxvHXu0nenE9ROSquaiuMNlqxiLOs92Im8nxoR4VOhAL+e3bt37370fGo22DqR +aPPp7t1DuHfv3v2j5ze7fp5oNV9X3bzK9qlN6kXGTkAgYql9Ow0EEW4a2Xnse0fdG2pdyTpm8dT5 +X7GrZ/F1IVsKVOtxPhmK2biUr83460Sw1cqYxr/wacwRWu8Kjt/WzfsBIgQeE40IUDOqewajklCy +iRhYjRIztJDmJoZzb77TP3mFQXT9dh7SckjZFDXRRgTAcRMhAosAhqw1TwmqVhuGxiASKGcTYQno +eiuaRIKBum4xpMM+3TW7LQJT1CQfAMKyyqoawyzjaz7uq0hWhRm1KgCQ0xsDv57du3fvHmO89N46 +4PuWFZ+ILLh37979I+U32/7UIAAfp/+cGAZQJ1jVabRVrBL364rd1BQod4++z3xoYFgkAQimoWQq +OozJPOMBN5jGul61Oup2POavs3JVDahlAiYBzOOHauktxrjDKlkIJ7cEBFWLsQVRLmBBE5GyMXFR +5IwoMKBP6LswbZ7+3vfuHh3i6Sd3zp0lwHJWU9RhZHUOgAGpjC+naqqftinWE7uYIIJcFAoQDBYj +EdB1/WJ5J6eUi/XDMqVFn+4alZOZP+MQANgqDiBS07FoFf4YwSpHa7X6N7+e3bt3737Tn94obLoP +KSZw7969+0fKr3JIrKac1/XlauqXbJ6yr5JhxvXo8Z6hJgYRCbPacLB4HXy35B6IBGYBrIURCCEQ +E9f1NNWTdYPVNx1X27oKEYwbE4Pq8TSu+qj6wHWgoDIRhEDC9QYApNwHpjZCC7oexACrGtomApI6 +NGHaxvMvv/zB99/of+LzF7f3pnu7euYMWEAUah9OWxX7kkENWgAIQLxKQ1K1nC1nkCAlhUFEUjIz +xIbUtO+HYuDAAIEH09tAHrdTAItg9U7943gcDEAix32R1tu0Vbx7rNXY3L/59ezevXv3x+7kZuBB +0QS4d+/e/SPodXXqv15fEpHWMt/VECoCrTrTk8GYGSBmghnXA3AaE9LPXPpguXwPOCja5TRoMc2o +R/tBwMJqlrLlvOqfA6o3sGp1X0/3bX2cT+PD15/eeATOp9+towNA4zOoWsqm0PGZAeGxo3+MSEkJ ++6JPvfzyrS9/4/Czn57s7cfYHLVbtLuPGMEMVdICEJq42q6Mz9Ou/+jxl4IIpSApiBlgEFKyIVsI +IcZGRAhQGAvm/btXnr66Luk1NVq/1kwh8OYA5lUn0DpzGfdEANbfOL+e3bt3757xIUXAp7YRGx91 +7969+0fOM9E6k4SpTgUel5WmAIGJakN8rDKBcKIpTZ0iTDAzo4P5W4a5kTJb0b5oTRRCbCACVa2H +/UxjB33AckZOUK2N9tdTwI5Pu9fn4ITV9kABjOlDa1yjBKpj0MAMTYQaUgIMUaCFJIAFtw4SMSbN +5W987epvfbn7/Av03LOXsn3AzdGZs5jNEGL90wUAreIVhLovQtFUW5OaotTlOxACmdbpAaYFUCpW +E/1j0+4INyVbyqa66NO1Lt2oK36gVgIQsBqzABy/2uMXSFiPaMaYQOXXs3v37t3f15/ePVCdO38y +f+hUEMG9e/fuHynPY58ZxkYz0LEIlWhj0bk6aN5oTUOrk3Uea4T54uVu0X+/626kXMwAGCME3pVQ +iLQkpGRq4zE8bMz2GWt/merS/3hZj9XZ/3FBwpj2wzLmI9nq2ZixTo1hGZ+k1hOPO4ciZrxcwhQ7 +0wnb/pe//NYXf+32J57l5z+yNej7sSlNAwoWGzQtiJVJal/OnMaq5VWMIpWiaiBebUgIWqyu5FOp +XyJq+lTfDSl1pZSc60xiJc59ujWu8OsLsfpG8HH577q90vgNGvc867DIcRaQX8/u3bt3f+z53t0D +NlKFTkUN7mkj6t69e/c/+r7m/4wNQHnsLWOGzQaUPC5F+URXynXSD8jUlAwwC+93+Z1cBitUtC5T +Q5TdkrtuQCp1IQ4da2dBhJJrLS+BECMTUMoqILE+5zYwQ+REHfA4NtiO4dgAdNUOSBW5wMZnE7AW +KwxQeaw/ev73v8G/9KtHzz7DX/jJC9MtJu4lIjYUBE1LIghRi3WmFgIzQQ0gaxrSAihUUcpxZ1Jh +DAl9byVj9dozgcyw7Eu3WKiNX5YZCLnoEZFR/QLW3VVX/9k85h8LH4hYiInGAgkzYpLjMgy/nt27 +d+/+ZARg3Cscv+lq2uX984fcu3fv/tHxq2LfdffPsbfPelW9ykWvS39bHU6Pj1MzIrCwEIj4+s13 +il0XjiwTVYhQiG2ILQUihjDT6gjbzDZLfmsdbU10WdcDjOtfADSevtPGPNwxBX98Z0zBr9GAOl5A +BExgIcLUVOpaXfjCMH/6rde2f+s3bjx5ET/7Umy37oAOJZAwYsSkJWFIQBACGQjCshrFhRgDMzhM +VGvj09rMtL4syAVllYaUs/ZJS4EpioFICCgZKRdiSmleD7GYmIkxfm6MVRugMT5AJFxrAwBAjYTp +xNJfza9n9+7du9/069rhU3uIEw++3ybDvXv37h85vzkFDKtKUz5O+MG47h8PpE/k6BOghq1dNXp3 +0b3ZDYe5hxUuxUrp+uFOycYEVSPiICwyPknN0mGurXXGDJexrndV2jtuGHTsBbTR+nOdngQmNkXK +IFrtKwpExrW4WTETwp7Yk8s7T969uf87X3klBvzsH3t8upWyDSQQQSkGpRipRhKIlRnMZlZonHQA +MmMBrKRBmWC19sDM1ETQNpAALRhyUrOmDSFSKsjF1CyEQAEGaDHV7tylOY1D1ei4AhtMx9utdcHF ++NLwRur/uPQ/HQTw69m9e/ePumeie/sHnYomnCgudu/evftHzetxHjmtT9yJiZlsI9d/I/nnxLs0 +nskbQ4Z8oLhrdhcow5AJTUnIuV/Mb9aBXzlbP+T6Z+jq9J6ZVGFACKyqJdvm0f/6sF/CiaT/WnJc +9x5jQ1ICr9ry1EnAeV1SHAa1oZ9fXNz+zPzWR3/36z+4s7j1R3/mzOUnhKmNAUEAIARhnmmJwkwE +NYQAImTTccwY0PWZWUpJKZsBusoC6pOVjKJIA1KGKpg5hlZEap1AySohtDEAMFWgTLcOcVxHYXzc ++GesDTCz4/kL65d+3QRjHM+83qf59ezevXv3q3fWFQMf+ki+50Pu3bt3/0h4JtqMAGAjArBOSl+v +9evKfyzMHQsFiJnMSARGb8+77xOHAs3aGJ0n3jIyYy2GEKfT9hwh1gHANfnHDKXYmExPZqalHrQz +jhfDRgQS5nWlLxmIGNaoMQQG46CKsWEoDDljbMVJsBI4X2rLz/DwU4fXL7/8rffe++C1n/3ZMx// +lPT5nRCSgKzAgLYJMTKQCLZKzkftMDF2AarhDwhRVAXT2P1zrNVlIl6VHRuGQQ8O58OQowCErteU +koHNOJdCfDj0d2VsYFTbqo7bACaueVY8zksDERgnmrTW0cjr0gy/nt27d+9+7TdDA3wS6YP3EO7d +u3f/SPmTEYDjNvObB/DjHqC2+xy7Um7EEIgoNkPY+d15enlQJdlq2ieOFqXofog7GWgavnWjfP/V +Pg9bjG2hRlhqP341SECIKGqmCIIgEIIwGCANrBO2UI/gycCEEEAIQxEzMSAD9cs2Qi4gYwLH0FhB +6aItP7off+FM+2dbfeHNH1x95bVf//znt597PsJuhgZFC4mRoIkwGhSHsTESG5sRKUFpVRUNGIIE +qJi2pUBrG9CMrGgaCoK+w5CwmGO+QMrH+ykDiI04EreqYioU7uZ8w8zUlMYBC1yLDUh41V51ff7P +OJV0BawbXax7N/n17N69e/c41RXoZIbQ6Qev24i6d+/e/SPmNyMAul5h1jEAx2vQVXEwMU6vRAlm +OuR05+C1IR1qmQS6/Mp33/0b/+V7X/rqLcI5lJ27t6Z/9+/1f/2/PPzu9+6AtPa9zKmmAI0de8aZ +AwxGRJlYYi1QJIQOlLWoluM/lnhQLKVJwrCCrgMytSGGwBwZKml5jocXd+hff/rCX9ppPw+dvvr6 +119/+7//o3/s4sd/7HHIHSVIGE/xx1jDySJjoMYaDDAiKJCAIec42ZkvF8NgQ0IBCpASjhZ2OLc0 +QLPUeImmcT9QhwcTkUG65SINWZhLXhgGIhaR2klp/K3uro6H/hKt2i/VKWzHRRo6bt6Ix1lofj27 +d+/ePaDHKUD3HSl86sGbKUPu3bt3/+h5IpJ1yS9OnF+fjAicjAwAYJHQzJf9jZQzdPvW9eXvv3x4 +6xZ+8MZyWDbb0+defnneH8mVM+21qyBmDgxQVhhgejxMt8YftHbtpAaojXhgbCQgOQZFUSfrwiBg +zWCCZvRL9IvzNHxmO/zspb1/+cnzfyGUT3eL2be+89VvfOf/8+KP73z6M2fa7ZugBIMQsURiYQbz +OJhrlc+z2gysmw4JhOvLFA8O+6IwtZwoDRgGDB36Af0SQ4eckRMPCcsljubIiWIMw2B3D+YpFRFW +pKJ90QQYFIbVJODVq8oCYhKRVZUw1oBorMxmkRMdkfx6du/evfvxWAkPGiJwOqywuu3evXv3j6I/ +VXO7Xogev2tGq2Py9aTaMS9IAWDr7PeLzXdmF4vKrVt3Jg0++2k8fYVT1hs33l/O7ekrF5668tT2 +jjERjwMH6t/rY1GBBDDX9X3KNDfpSWbAnpZYRwoYwxgFyCXmoQkCy7DSBNpCQWBOvXD6yLnJn/rE +U//ex5/8N89v/9E7N9qb1+df/p1f+8rv/hc/8VPnX/j8duZXit00BsuYTC8MZiMyqXcKqOb/0PHr +UUsLRCAs86Pl3QPNGd0S8yNbzqnvWHNruTVt0xCODuzO7XI0t5TNFLlQKpYKhKiZTqaz7dr4qA74 +AtfggNGq7yeRrccBEBHXDqs0DgMeJzSva7VpnQLk17N79+7djylA9x8dvGoUunmb15sM9+7du390 +fO0CxFQb8I+3MU5ZObE/GFth2iozZWM0L4Dbd24uF8tlNxcO2ztbZ86QAZcf58m0J7l+6TKa2bU4 +efvJK5LLkNIypWSGlMAEZlhZJ3iO6e4GUz0yOgCncd7XujcoJeGsw0QwsZw0oSzPhf7nHt/5D158 +/n//+U/+u09c+iOz9koa+K2rv/urX/lPX3nrr//cn/rkk8+2R93boTFjhAgONcdpYFEeT9rHZj/r +ut7N+EeNUWjGnTt35nP0S3RLWi6o6ygPbd/Ho8P8wdXh3feHazfs8NByAjE3TUMsaShMaCcRQNcf +FMtqPWp1M1Crfuv4yjEOMx7yM5GBUPOCWIiI1NZDwcalPwsDYBK/nt27d+8eQDBTIj65XdCNAgK+ +dw/h3r1794+Or6tGOs7mX6X0HDeZGQ/9ichMx4lUtg4XjHsGM/TpwIxgvL293U5u7p/F+UvhsUvn +C27E1rb2AdY22mMXd0s5NDPAmMez9qIoCjWIrEIPhGIGtrpKNoMWsBwfyQuHstxJNlOLk/Z5HraJ +P/WZH/+Lk/YMwPP53YPDq9977Wu/972/KrM3/sRPf4LCu73enm2hTwgBugojk4F4bCcKOt7SHKfa +0/hqmiIZYOHuQZd6JIVp3SdY7lOx7miuRTGdIESatBQjiKjrUzabtnU+gJqVrNr1d4NsWSxYdWHi +VbBlo+6Xx+P/cejaOHmNCUpMpDUCYGUsAyhF7zke8+vfvXv3j6IP64ShjXt587lWd+qpBCP37t27 +f0Q8MWlRDrw6+183mcE9b6ty4fGw3FSVIGaAWcl9kNlQbt2+82qIR88+fxaQVO5mXTLj/Hna30Xb +MuHQTGvSS+18WWtZicYGmqqAohAXLSIQhhGIkBQlIQgxJn03LAeehSd3pp9+7MwXnrz0Ezdv9N/4 ++rcFZ1NvWZfvf/Dmb3/1f3jt7S8++8lbFx9vgNeHNLQtsoJ4LDaQGiSu6/t171HAAGGshxHnjCAA +0ZCMadL3dOu2DQM0oxSYGjHUkipixO4eNYFChDSkgKoVM1GQcNOEYRiSYXcqIlLUSim1xmAMvKz6 +/hCTsDARM8Fq4XX9p+94CsNqt8Y0VlSjTmX269m9e/fuw6mNwqY7+Vy8+Xj37t27f0R8ratlYSIy +NXBd9x/X+xKR4XSlAI/9QO24JQ2slJRzZxj6IZFgMtXUa58zjI2sjTSJVHSw+gZbNbE8Hu5rCtTk +ezNQaWrjnQQYJEAMTDvDYrtfntuePH/54o9fPPPC4xefnbR7zNvnduOr3736ve+9fv7i7Hvf/9LX +vvm3jN9/4XO70/1YcDAkQGBWz/etbnOsViCMAQagFo4B9QsuBYFQrCYFhcUil8wi8b13DoYFUkIa +IIxhMDU0LabT1am/gMhUbcimhtZAoJLNEDkiaNZipRi3AkCYc13iU4GBmMfm/zXth0iEx7wg4fGj +vO7/SURkoHu6Yvv17969+0fah7U7Hp1I/OBoAty7d+/+0fPjRF0aC3NXiT+rzB/amANQT8h1XHGS +6nELelPNeWGS63iv+fJO38OItqdn+2Gx7LoYhEjr+no9akB1rACuk3dLBhFiBBPSACGKPCk52DBd +dpzm21uTT7/w3M9dufTZc3vPTcIeDEBOuWRNsxn/D//gv3jsir5744uXr9ilx3cK3ln2N8EQIaY2 +lxQEwkX1OL5BFImyqa6+uHEwl6la4EChz3mxyCmhac7fvHn7+nWUhECkGYdLiwFbWzSbSTMxiUoM +XiUR8aqjUMq4e9dU57NZE2JrKGpiJmrrUcpWG4Ay82qgGI+p/8y1NROvGoLWtCsmMqGiICYxKmqA +1SCAX//u3bt/xP0Di4A3thHYTDBy7969+0fH8yq7XHgssqXjbpIk679Rx7Yzto4BMKj2AaLxfjOD +AuCiiiATgQwd2mY6aVqiYpZhIDSqsRYdj30/DTAUPZEFJAIodCAh1tIe3MbBzb3FrY9fff2jr37z +yoWtX/jcJ/+1S2dfjDIzOTIZjhZ653b69ne+9b03f+Xa0X+V43//ic/2F568fTB8q/D7k6kwE1Fs +4iyGqFbMQALm9R6gEB0PQ7OCUsZ636G3lNAtte8Rw+7h3e6dtwcySj1Sz/M55gsEptlsu5kEYmM2 +YiNBEKLax5MoJcvFQDg8wrVrw91bndkkylbKQ85lLHgQWR/5A3UnUCcfc919yXjwzyzEQsJjA1Cm +0wlafv27d+/efTi1e6Ca+3kyf+hUEMG9e/fuHwUvLGomxxn/4+qzVgWs2uDUjPRxBNUYKVivNsel +/7gRmE62F4W0xGFJsK1S5qZm3M/7LmWECAlD7rLJ8dl/vTHW+FrtRFQz8puS4+JQ+u7CNPzYc1d+ +6qnLP/7eu3f/3t/9B7evl36h01nWol0ni8Xt6zff+OZ3fvWVN39pe+/aT/8L59vtw2W6ng3tFCD0 +uYRAIqlLt7PZ9oSLIRdlhioMYC7rFvyqpoZcUKC5IGcreUiDxYYWR/M33yyHB5hOAaMuoesQGKEJ +gOU8xFbX43qVjGGqyKAgTGRpMBYSxqKz998/GPaOLl9+fjqZLY7GTVc9+8dxJ9CxIIBFRGoO0Fgg +IESZiJnVtJ73ExkRwDA1v/7du3fvPmzuBsaHbaQKnYoabKYZuXfv3v2PsBcWACJ10W9EbAoJYFmn +mtR0EyLQqjPm2IFebewcOqYIgczUDJP2yvI6h2aSh65pz4lyt7xDESEgBpSCPiUSqgk/NQuoZquE +GiPIEG4sS+qz9XtUntybfuLKkz95bv8TW5PHt2dn97fKqx+5+uYbb7zxxitPP/PU9Zs3bt66+f03 +vvL2tV8t8vtPfLTs7OS+HM07ixFQcKwdNgEzNUhAI1BoySAB2fG0r1U4g8xQillBn5EzmkjLXgG2 +Et58c7h5C7MplguDUik6maAYlazdsJiwwZAzwGCzwKxMgUFgJa0v5xjxQFTLV2/ocnjzmYsfTIkU +OtYeMPN6mb/KCBJhGER4nf9vdFwHHERyURu3Yf7vnXv37t3DTOXipeeO9wrHb+stAm08HW1Us7l3 +7979j6yvq39iAiC8ajLDwky190wIIkFEREKQIDEGCSGGEGOQwE0TYoxBJIQgIsQsgUUk4lK7dXTr +zncnk11k6fshxsZ0CIyUAIYqNJOYMHHJNmkoJ5hCC5HtcHk8zc+n7gqGZ89u/+mnzv9rT1z84ztb +z4vsqoX58ohFU+m+8jtflsB37y5/79tf/PZb/5c7/d+5cHm4/PiE5G4qcyK0ATBw7eSjACE2gQha +TAQoYB4LjtnAABQEMhNVSQlpoKLoBisFJROoGbrp++/112+YMCyjZCplHFsWA5nVImLrh1UTUSMy +IWtNp4TGLAsb2JipFCQFhZigGbpIbzbyWIvnixaYabFSSs7JDCWrllKK5pTUTIuWosWKFlWFmtYW +TKpW1tULNqZRbdZw+/Xv3r37R9DLYxefWQe11x849ZfjeqLNvcC9e/fuf8R87TdPTKY29puh2myG +mIWYQgxMLEFEOIQQgoQQYgh1PxBjDEHG1X8QFol1HyAcpb186amm2bt584OjozvbO9M+307Zio79 ++4VgZSunAWYw6jpjTKzsDYszpXv86jtR9BPPPfGnLp/7o08+9lONXIJN+j6nIfdDv1gulsvDu4dX +v/29X//uG1+8dfRVar97/srVsxeZ4yLZHQnZYCDU9HgjkBEwThcuRQkUJJasJGOXT1MYg5SKhpSs +67IW5Gxdb0LUJ8yPjHR24/rynXdKkDFkEYSCUBOlbRqiQjSWNNT5ZUWRE3LWUoqVrJa1kFksGbmA +OTJLzjk0XNSGtDiYvyNhNpPnzLSUUouq62pfi5aSS9ZcSlEtJZdiqlqKqqoWK0UN9fR/DMKMk9r8 ++nfv3v2j7eXipedXCPduEdZVU/VhWE26ce/evfsfVc+r85JaYbquOhVhFhZmHs/9OTQxiIQYYpC6 +8A8h1PV/iEFqkCBITVKv/dfScn93+qmnnvnIub3nQjsN3JQSoFvdPOowycNusKcDnbd0dhKet/T4 +TvvZKX/6/O4fRXr2lZeX1l/5yc/9guWzi0VOaZHSIpXlcnn3zp0bV6+/9e1Xfvt7r31xwNee/djh +859cnrt0ZDIQg6gUG4ppbFBT4dfzvNTAAqsFYwQmyWPiP5WCosiZcua+LzCkZAeHZgYt1PcwY7bm +7beXt29qbLh2/WcCj6O6DKQEk0DEiAHbu2EyES02PrNaP+jhkS4WOixKSZOSuB9SKaXWTE+aPYKo +3Rz6a+1kJ+JpLUVNVTXnoqqllJy0qI7r/6L1TjW1okXHfqqmtiqrHgcDm1//7t27f7R92KwYMLu3 +jOC4b+h6B+HevXv3P5KeiWrX/7HQltaVpXUBTwCxiDCzMEvgujHgdZ/Kdbkq2aozUB0SbKu/jksp +80Nphx+fhR9/7LHFL377rz/zzCcuX/rY9et3mzbdunv9vXffe+6ZzwpPAkeDNGEi0go3e8381lMX +v/vKq++/f3NvZ/fw6AZJv1j28/nBzVsf3LrzxjL9QOX1i1fwzHmbbheiG0e9tg2rgtmaYCAIo2Cd +GgpTMI+1xSJQRdFCHA3ISXMpWqhkKsWGwbSoENpAxtACAP3Cbt8ZSjEQus6aQEEoBA6BiMACZk25 +dp2GGmDIxUSY2UBmZCkBCaXg2m2DLaZTmJIEm0xx9jFZHh3u7XJsUuFX7hx96bErL9y42tZZYKtK +AJbAnFiOW4OO1cFWbzOhgJjICExsakym5te/e/fuH3EfNkIDfDzX3bT+K3a/R7p37979j7JftZgZ +V/8Ac+0DShRExmFTIJZxvVnvGGMDXEtqV38ece3FpqWoCMaWQJZyMgtv/uD911595913u7/87/3Z +/dn24dHty+fl6OZXol25cvHJlApRtAIzEIvNDh87f+Nbv/+tl7/19U9+8mPvXn3tYPHuzdvv3jl8 +E3Rz/2x64um4u492Os86FEMQTFsU0xCQMoKgiegGiNStCkBjR/+xyxBgBM2AUQFy0lKoFBuy5QxT +G5YIjEmkYcHMW2yR0ZnNmWk6gx3ZkIxBxUrOYEYzATPaBgbUkoDFIgvDjIJQiMQBTbQggKENFALf +vl3efMeg6DK29vJP/wS1MyMg8t6VK58wnYmYGpkZ86oVaA3U1EhLlvWkYGEpXISpEBnXcWWrQzEG +q+iqralf/+7du38EvVy89NxmyGAjQ2gzdmCrOxUg9+7du//R8/UvSADrzB9iEAXhVbcZrilAYazo +rSW+QUKtAAghBBmzgJqa+xNEWCSIjPlDtVslM8HATFdvffPND37p977zm/PDg0987DNtO2WetnH3 ++vX3nrhyXrUEHrvYa14C3Xxx9ftvfO3l7/xKlz944/2v3p5/K7bvPPFMeuYjw2NPHOzsHkKWhiKM +tsEwQAQSaEhoWzChH9CGsaOoMAioI8okoChygSmpcU7UD3kYbEjWZfQDlh1yggCT2Az9uScv/tzP +/JH/2fbWkzdu3hyGm4slUjYiaEF9GQ0AmTBYQERqaOLY1bSJXKMBZqwFpsaMyRTthHZ3w8ULlz7y +zDOTZnL1+t0XPxOvPGmz1lref/zcnz0T/9zR3cZMS63zNdRsn5JLUR3LAEoZE39U1dTUUlYzVTMC +SlEijGPZxjIAv/7du3f/iHq5eOk5GkfYjOUCJx+PkzUEtM4rcu/evfsfGc+1r+eq4tdgIgwIEURk +nfovzCFyzfuvhb0xyupGCCGwcIxRhGtNcAhhtfInERknihEzGbOYfJD55XZ67ZUf/O7rb35rMm2n +7fTMmfO3bt3pluXy40/mYsSk1M276+9e/dbvf+8fXL3zm5Pdd2e7H1x6qn/iGVy8ovvnFrG9Q5JJ +jBkiYCbTsf+oERRjK0/m9Syv2qiUQKwGVZgiJwwdhoShK91guWA+xzCgJECJlcTi5XP/wosf/Suf +//i/f2by6ccvfHZrv33r7dfmyzumAFEqaAITs5rp6oBdwtjfs1YGa4FEENe6YCERMysFANrGtmaT +EIWke+bZ/NyzTdMMwc49fu7PnZ/8G/18G6SqMDUtaqpFa1GwlVxyXfuXomNlsNYSgVqUXLcDGBNk +YbbaBvj17969+0fVh/Xo4HuzhXD/xqLu3bt3/6Pm1YxX/f659vcHE9VZv6ucIIIIC7NIkI2ggEgt +C2BmEqlTdem48XydDKCr2b5qJABYTc+f/9jerYtPPfXdnb3h+rXf+m9/8R9e2PvCk5f+yOHhMJ8v +7nZ/VLV0/fz27fffevflefcG5Oqzn7Dz58+1M+VwCzwww3iV0lP/CaDa8wbMVGtpm1iXvDCrGf+s +xUzJjOpwsb43IpSMvrea3L9YAoRckDoKgjRgd/rY5z/155+78qfOzD4HQylAmX3i8p/nl+hv/f3/ +2+Hi2t0Da4N0y5LrSIRaRMHgZMyIgZgFQLbCgJmlbCImaFQlCLWNpazvXr3W9dfOnsXjlzjGIdCZ +5y7/xbPhX+nnu0SDGdVdRS2x4HEE2yr7avyGyDovy1bZTUxUQIARw8rmuAbz69+9e/ePpg+nZoOd +urEaRrM5PsC9e/fuf6T8uuv/mPN/fHtM/SeSEJhotdKUutDnILyaP1UHhtFqVjATsciq0hZgYVvV +AhdVZoZpXpz99Ef/zO9+73qy7+zuhdu3jlS/9spbXysGNfvvvvg3ZtPJkPuSbHefd85j/8yknRSS +uQIgkMAYpQBgGAlZCGbrWcQWxZAxwACDFqhCiaAhq1lBKVoUWqxLqGv6oUMppopSoAXIJGjSonn+ +2Z/+2NP/4qee/3lL+yVnjElEvFim6zfvgJpGtpvYAbFplkNnURAEplCFFtJsqlZKkUAxiJZch9YT +mdkQY6sl3L7ZDUW3tvHsc7S3B4VNI66c/7kLk3+zO9gyS0AgpHUvCxHJOdexYMDYsGkczcbjL+Gg +Ysi1WJjMUIxqFUbt8erXv3v37h9ZT5/+zEsnSwew3kPc9+2eUgP37t27f7g9rxf+QBCuhb/CYBaq +q/wxmZ9XTT9DkBCaEEViDLGJMcamaWoP0LZt2iaGEJs2xhhjHIeCxRhEJMZIRDEGZhah6Q7f6X/p +5e/+vcXwLoXbKavmnWV/nQNCmCy6ro1RRJoYFb3a0DTcNg0HNhRQEc4cDIAwalWvak3Ct/FvfkCN +TAFQKVYSTDkXK5ly0ZRNsw0ZqQAFRNCEOt5LEMogF899/mPP/dTnPvFvTZuz4yJe6maJ37v7lV/5 +h3/ju69/8fBwub3Fs9ne4eFcbVj2dWYwtIAYswnVfPsQ0DRoI2ezotZEzGYEotu3bdnZ9gxXHm/P +PRZjO48ttrcx4bNPnPkrcvSv5py1aC5acs655Jz7vk8p9/0wpKHrhqHvl93QLbu+77u+77q+64e+ +64eU0pD6PuVc6v9SyoCN7UHH3qB+/bt37/5R9HLx0vM40SUU9wwROC4muCfByL179+4fbr/K/KEx +4YcItqr6DSJMEsaEn7Hnf035iRKYQwy1AiCGIMIhSC0A4FXdgKyy/+sYgbHGgHk8qmYumXemH3nq +qSt9f3T11rcmrYKHgjydyVCGpsFkxn3qICnGEkPt2Q8YzMQKQHXQ1fiVmRJQl/tssNp+RwtyQSnI +CX1n/WBdb31nfY++t35ASkgJOSMn5AQUKonO7nz0uSf/2B//yX/3k8/+AtlM1XQVXMg4+Ob3/7+/ +8eW/evXGl7Z2hNiWg3ZDv7U1IaQgY6KOMJlRzsaGEEiEjFDMYNTGIGyHc5svrJngyhX6yHN7O3vB +cLS/fyGKXP9gOLhjz17+E7p8rqbsm6qZqaF2+x/HAWidCZDr7K+xDGAcEaamVsahAGNVsNVv/Ik6 +YP95ce/e/aPo5eKl51YPG+9auw8pJnDv3r37Hw3PxMRsarWdJ3HNVrcQhIiYQ034qZ1/JHAt/o21 +BxCzrBb9QUKQWgQcxgLhdW3A2JOeCcxCwgyCMJvBoJq5lSvnLzw/2zm6destRc/EBRTYolAINm0l +a1GzGEFsRdWQgQzKpqYFJSNlaIECalbLD1QpZ+o7lIJS0HXWddYPyANKoiFbTpQHGsYjfwBIiTTR +1uT8j330T3zhU//OZz/5F7aaj5QMG6doEYhKeO3L3/yPv/r7/wni1cm2KsqkDVvbcvN2vn5z2N2i +rdk0pZwSInMpMAUxajcjFooizNwPOJobMc6e5aeflLPnzbifzIYL557qFvbqK7fffdsWR/noLl16 +7OPb0wvDkFTrF6VqCkMeh/1azlnNchongZV1M6CipZSsY08g1VVRBo1pQLDaoch/Xty7d/8oenrh +xZceFCC4XzThwwIK7t27d//QeV41/+FaM8qhhgIkCBOt+vjU5j912K+EGOLYCCjEGJsYQhwHAccg +McbYxNoXKMYQQ4gxisi6LVCtGRBhCYEIqw5D1EyXtw9ee/fGr9xZ/PJhd7UVS0pFbX9//2h+OJQs +MrbTUYJqTftZBXMFALIhEBQoGWYgQyoCUlVd9kgJBGihbg5hKcW6XkmQBptOkAtaaj/2zJ/89Ef+ +5cvnX4y0X0uZj7tGmC3sW7/5jf/4zQ9+dWeP+6WShFTy4RFY1YbHf+wjf+bu4cuvvv5V6KxbLIis +GwoxJJowBQEoqFqxHCJ2d3Dp0vbufgO+w8G2t3gy2795I7/6yt00YDZprWSzcvHCZz/7Y3/qfPun +F4eSNZekKaeUchpSynkYUt/3fU376YbVjb7vh+WySykPQxrSkFMehlRUyzhAeLUdWEUF/OfFvXv3 +j5o/nQL0oG3Eqadw7969+x8Bz2P3/3XrT6kfEa6BgRAC19yeVfYPi0gIXPsAxdVdQeqRfwhRQu0W +GkKtGF7FAAgEZiZa1ayuR4WN1aumuW3DpQu7f2Q62zm3f25x1JcyaMlH887MiJAzmRETilrJSAVa +qI7XHRJSghXkjCEhJ2hBUR566gdLyUpBGpATug4EXi71aKGzWdRCs2a2t33hyYs/8TNf+F/85Mf/ +l2e2P8o0NSsA6rm7mTJTb9/9rd/9T9668St7ZzD0gM2EtpZdN4l7T1744z/3hf/oxY/+wuUzn33v +vdcXRzdFsiIzIUbsbm23TXs0H44WJTR67jw9cYWeeGJvNjPD4WzK+3tnmrD7vVevv/GDjgkEnk4e +09LzVJNee+2N3yrW7c8+jSJmxYzMTMemn1ZWb1p0dfxf369pQaZ1xa9WSv1ayGxsArpqBuo/L+7d +u3/k/GYKEAAlYpjiZP7QqSCCe/fu3f9o+LUkorF/J60HfrEEAbiu5GWd1BM48Dj8S2Td7F+CkASp +zX/qxIBVCtA4LHjVL2isBMCq3dCqDoENCoCZt5pPPnb+0237VBP2F8uDrrtNDBGeNTswmS+SZjLj +vrc0YMjICWndyadH6sd7crIuabe0fkDqkRJKBoz6wZpAbSshhOmkmR+ppsdf+sn/8NnHfp4oqqpa +Abi+MGYKkPKNb3z3r735wd85tx+PDjPKXulnR3fTY/uf++xH/vJPvfCXtporpehksv/45c9du/nK +7aPXwwQSEBvM5+nu3UEau/Q4X7yCx843O3tbJB2FfmdnMpudvX1bf+/3rt26BjIiYDaj5fJgOg2a +gRJ2treu3X6jy0dntz4OtGlIdQNQV/irtP9yvB9Yv1e0FM2laM2LGg/9rWYAAUYg858X9+7dP5J+ +3ACcCBBsbB3GPCG6TxmBe/fu3T/Uflz6n+j+KXXuLxEHCcwUxtQd5rHSV2IYj/tDYGau+f7ENEJh +CaEu9EVkbEo5DgkAkax2HVYDAcJMIDPUUuS65FZVTVt7s0+cO/Opc7s/ef7clb6jYSjzxWIYSurD +cm5aGi2UeyuJNUMzaaKSqSQyZcukmYaEvq8t3ygP1C+oZLKCreksyGR5lA7vlrfe7l99Pb3x5rXv +v/a9W7dvP375sbbZhRGAogqgwAgY0s33r3/19Vdf+/1vDaT01vf7c9uf//yP/aWf+PS/fenMj2sJ +BjBxycN0svfsUz/B8eDuwetDKd1gJNg9g8efxIWLtLvLsdFmgrZtJ+1WLvH171//zncWfYdZQ5N2 +mrPm3mAUggImAYqUMS/29q3DNy5eeiLgbMlF1WrVr6rm8eDfxghALnmV6lO0jHUDNfGnbgDGOmCC +jRMU/OfFvXv3j5pfbwBOpQeN75566s0iYvfu3bt/qD1vHJzUlv9AjQMwM0nN/WfiMXO/Hv+Pp/oh +BJEQQqjNgmqqfy0FliC8DiMIMzGIanKRyCoXSGTsBXQ6FoGxlT1KKWalbcP5/dnnnn/6CxfOfzwP +ZzRtCx4z3e2WaXG0GAbSjDxQGigNVAbKA6UOw4B+iTxg0rQBuwFXWnry/JlPPPvk5564/Im7t28d +Ht25c7vcuWsRtL9P+zuTqx98cOPmm1/+nV9aLK8+9tjlrdmeFhRVBmspTdgLYTYM82+9/MbvfL38 +9It/+l/9M//HKxc/I5gWHQywosQEkLDA6NU3v/T6298ixtY2PXaZHr9CO/vUtIiNhcZYioStu3f1 +u9+9dfVdBEEbIIHbuPvExRdnk4/kga9dv8VExJZK2d7GouuX6Y2uP3ryqWdSt5NTMbNaClxyUdWc +tdRun3k1B3j135zLeh6wmsF0nJw2NgLynxf37t0/cj6sNgqnxonxqaqCe+aNuXfv3v2PgLdVBtBx +cmRt1FMX5LxODBojA8fJQswEq2n9ta1nbTJpqspB6u3akWe8DeRSIhGMSikATIkiESAEVRVhVQBK +Bggz1GBQNuMyv7TNj3/+oz/H4eDWwesfXHtrsPdJFnfu3Oj7RUqdqhpy3/dtOw3SNu1ka7oTZIp8 +icPO9uzs3u6Fs2f2zu7vJruzODh6+513L5ylyCYEo0YLf/T5/Q+uvj+/iy/+xqtf+d3/6ud+9l// +3Cf/p1uzC6VkEKWs53Z+8qPP3fzzf+Hub/3DL3/uM3960u6ZGYiYohZl4ZQP333vzdff/+1X3v67 +dw6/f+Hi1mTaz3ZzbKxtWAKFoO0ETdsc3G2///3b77+rmsAgMIiw3U72di589Mk/8dzjf+H64be+ +9s3/9t1rX3v37TdmO9QtsbNHky1cPfjNr3+HX3zuLy2OtgxjgcKqDeoqt//ENxM1q6pGM8xARAZi +sjptrX7cf17cu3f/qHl64cWfv2918D136j1P6t69e/cPsV/P/xIGEdf8HyKWwMIcY2CW2r+nZvvH +Jq6b/6xa/ksQGXv+hCCBg4RQHxiEhWPNExKOIRBzqJ2FasoQi4QAsxAEgIiM+Uion0z9H6z+hT3O +cawxBAahbZpma76YL4ahLyUBZGallBAkSIhNbNpplNnRXWI5sRw2xWH65pe+8tfeeufl+Xz53vu3 +3r+G6zfwE5996qWf+YVr126//uY3b95+uZngmSe/8Gd//v9w/swzNTRRdzLXjn7z++/9199++e3P +/9hf/sIL/5NuOLp269WrV1+5ffv2tVuv3F6+etS9t7tjW7uYbttsSiDb3toyU2ZMpzs5D++9s3jn +neHWgc0mCIyUaGtKW9tbkfD5F/78C8/+rxZHE1WdTOmt9779u9/9xS99/W9zM8y20uNXbHuPotCV +/V84E/7CsJylVIZh6Lp+GIauG4Zh6Lt+2fXdsksp9X0ahqHv+34oueSUUsklFzUtZlb0uAuQ/7y4 +d+/+UfMBwOoDWk9zVgHpB+4h3Lt37/5HxKuxnAgIrA6PWQ1CoBo5pfH4H8CqcdAYDViHBerpMh33 +zBxXliAmM1UVIi0FzAAYbApQPZAWAlSVRaxYCHWoLwFQBRNWU4oZALPU7JXlcuj7CNoLIGEd/+xY +h/9CE3UJHbCYHxAzzFR5WC6Xy9vFDrIe3nxfrr0Vl4vhznUuc2CpB1fbrfDR5x+fUH/+xnsfNFu3 +bt7+nf/ff/u/+Yt/9j+6/NiPq9nQD1dv/f61O6+++oPvvn/z2t/7tf/TF7/012NjBYtsV4MMMNvZ +5Wce32onxuGIIzWtzeJW38nO7IndnScPDxbvvvHWtWuUFmUqxQoA7O3uijCTLrvFfLnohwHWmpXF +EZ3f/dhLP/HRTzz7c7/4W3/1Oz/4rbPnsHcee/t0sPxyo19o8IkxAADAaFXiZgCYyVAjA7bKg13F +BmqkZh0u8J8X9+7dP5I+bIZJN/7p0vov3f0e6d69e/c/Kp5PJouMh+/EQuv4ALHVrj1ExCJEEBnX +6PXuurJkqRuFWswLEMwUELP6PmxcnNfW+kyMOnggCDNMVVNftKTOMKQh5wxFGedeqWouKGVIw3yx +OLT5ohzNby37m323mC/mXbfIw5A1932npeRiJVnJpjYv9n7uzXRP85Q0hpZAcw55fnB798y5aftk +Y0+fbY+e/ei50rV/7T/+r4WbZmLZLl4/vPvsp2bN5O4v/dr/fXvyws3r3Rtvf+v20Q8uXCKEAcGm +Wwcd3U2KIGFn65zE+WzWTdtG6XAypRBp0hIzaUmXL3zh0tmfvnz+C8t5emzrnffPfrDsDw/773/v +9d/KaZgvusVy2NrCbIqrN759+PgHE57BpBZDp3ywf44/9okz7W7z9HNoJoNmPP34z0z18TsfKKzO +O4ZBV2lWMF0398fGIEzc841G3QP4z4t79+4fQR/ueeSJDKHNBxNx/ah79+7dP+y+/gVpaiTjur+u +420VTa0TE3GclwOpx8erkgCMqecjouMlPtVOk0SytdVGob4f+n6R+pRLKkVJkXPKOeecVW0WaRiG +5XLZLftl1w0pa7K+75aLxZCGflj2XaelKGzo+vnRAkDJhUhE2CixSBBmIQ4hsjBxbCdNZIQAmkTZ +ASjIVgwtIEGExIhsMp0MwwATkiARpSBsbV0+X0QAtmbyzNXre2+/8tuf+Mylnf3hnXf/x6vvlbK8 +sBueXdzozlxsJ9Nb3Nw2LhzQNmjbjsNyMomTSdtOrJ32akYw0sefOPszT5z/V2J+5vADAXB576OX +90BEr737P3zr5W9kS5bSbNsmM0xmuLP4TrPzAzt8PkS8dfVrN27/4Ob8d967/rXzF+STnzrXD+9H +TJ9+4k9v6S+kxTnDvFZcmOl49m+mZnWkQz3fV6zKMFb1GFrKZsBn8x9F/3lx7979o+PphRd//tQG +4gEDxvCgpCL37t27f+j8qsh37AHKNTmfiYWDCLHEIHWqVxPrcC9pmnH0bwhSu3+uhwET8ZVL+3uz +aT90w5BSP6ScSs4iZLA8DCmlfujTMKhmSyWVYsWKas66OJrnkkAmwgQ1IzPRXAoGCSAS06YMIhTB +AHdFjzgkzTEnYSKDrnYjRhyEiUhgALEgCLcomcQIaigiwgwOsYkxl1SrmVMR5tjExqwnTsujw2a6 +O+Th3fe/1ezd+NTnnmmm+sFbenTtygcfHH3/re8keuvck3rucZy/GGOrzTQ3UwsR29MwbWbCYE4i +kwtnX/z4c38aRz+9PGzNwAFkKMWITBUUD3/lK//X33/ll7nVprV2Ws6cRRmwP/m4DJ+/ev2NuP0B +T96Ks3JmbwfgQFtndp/++NN/8uiDz964ilxyGnJKaRhSX8sA+qHvh2XXpZS6ru+HNPRDX0cBDzml +nGuPoKJWJ4QZTK1o8Z8X9+7dP4I+rKsB7s0WOvXg1W337t27/1HwaibrFJExFLDqCsqn8kWIiGDj +Rwk0pp7DAKjq2f3Zk5fOUS69IEdJUYZB+mEoKQ3DYDlbShEcYixmYI4araCUUgT7O7uqRTWZFUMp +JRllVTZtSwmmZEWsJbNklokY2FEtHANviaoBRlR/QY0IpkrM0k4mbZhaCSUvlfqU5n231EJ7exdn +052+HyaT/dn29PDu3Vw4hiiCdrKVUx9gGcO5ve2+f+rarYjuWWnv0LDYnZwLj4vR7itvZBuYh1mD +7a1Zlsnt7R2NLRSlnR3uzB4j/dhnPvGvNeUnj65up6zAQOCSAAoEMiMQBGc++tyn3rv9K1ljLpL7 +xfUPUlG6qd89t/f+/qWt6V6WMDU+2t5qt+Knzu/8C9vhxWuvTfs+GVLt6L/+fTzghxHRanqx1fyp +daugUylADzj+958X9+7dPxI+VH3vdqHeqFlEq9v1ke7du3f/0HuQ8OgN60lg41+O6xu2eh4bx/ce +540QiGhVTXX3cPn6W9efuXxORLIpKDOzEFmQ1homaUiGlA0E8GCJSI05xmgGIstZ1cSMAQ4hmPZa +zIiVhRDqACsggEIbA0hKSloMZKWUlAcyijFMJtNm0nbLbtF1ZJjGuLM1bdqtxUIWC4UFtBMrRkSz +2dZsOjUzMppNp4t+CRqIm6HXbsi7588mu/P+1Zd/8O53Hr/yvLEdHeLs+WdvXY+3b1///rvf1ojL +z5y9eHm6dxZxMm9abRvMpphOwv7k8zev4dvf+uDwjTeffvIjFy7sEswQx3+MgNlenh8tDg7vpPLO +1bvfuXO4ZLY+4+w+TSa0fwbTKWs5bALYtnbaT1+++Mmd6TOT8LEbb5+7WSd+5WwKLTqOAy5astaO +PnUumNbXq+gq56eWAut6H7DeDaxrBfznxb1794+ap09/5qV7AgR6sm/o/SML7t27d//w+s0UIKmt +/EmExx6gEiRwiM3YAzTEICJNDBIkjjlAEmNkphBiDBKCMPNnPvlMI5yGIZech1RyLiWXIZVckMqQ +0zD0ylAb51OlIfXDADOu08WY62E2GVnWOsaKQEVLHUMGgqppKSXnOtw25zz0vTDv7O62k0ld82Yt +psbMMUaWkHPWoswUmwhQnYKrRVNOVjS0IU6pmbaqXIMPQ7lxZ/79m3e+HRp98skX2+aM6XSxiDdu +zb/92m/Nh6tPPR8vXonT7WFnG23k2YS2J1uzdjfq+be+t/Xdb926+sFyflSe+cjz2/tnL1++Arau +70GFwzJsHR0t7xwc3b559DKQzpzldord3RAkNw0kYDIJxHk7fvLpC3+mzD87bS+k5dZ8viiatVgu +JadcShlSKrkMw1BTgPo+9X0/9EPXD33XDUPq+mEYUgWllJRyLiWlXHt/llX4QK34z4t79+4fQT/W +APwQrUNPPIt79+7dP9S+7gFWNQDGIrUGoM7xDVGET9QAhBBilBjrFIDjGoBaghtiCEFmk/ZTz10R +oVxySrnkbKWkfkj9kIdBTVWtH7o09F3X931Xx4G17STGIBJAlHMuwyAhCLGZDcOQc95sNkrjaHcj +IhauZ9pWuxmZpVJUtX6SRKTQVBRMIQQAwoFDAGPaNtPZzu7e3nTvHIiJTESatr929avvXv+tRDfN +lhza55758WnzxH/93/xnd+/Od8408+E9jvbYJZpsUzO1SYsCOrt1cS9+ojvauX0t6WI7HUnpJ6nE +mzdvS6vv3PjOweKdvXM72/s70mrGnSHfiDPMZnT2TBSx2VajtmgnaFq0cbudbA394dkzTz2+/W/o +3Z/t+/Gk30xTUjPLOZdSUkopl5RS3w85567rhyH1fV8HAgx96oe+71PdX6WUh5RLzrkWAFjJudSx +Ces5AP7z4t69+0fNh408IT0VPjgZRDhRXOzevXv3D7Xf6AJEAK1rAOrflqoQPvUXqAEoRUXGvH+I +jB1mCHU1uez6b7/x3sefvhSIhVmJVBUwVS0wAoKwNU0Z0tAPw7ITCU3TTJp27DRkYGZrp6ql5iHV +wAARG5SJhQUwNTO1rGVIiZmbttVSChBCmG5txRgsNE0IbdtK20ym06Zp2ulk0s6U1n/hU91CAFBT +GMxsGGa7+3/8+U9+9L0Pvg/ImbOXBeduX9/6hT+7/3sv//Ltw689sS8UDWwULLQQoSfO/PGZvCDp +8VxIUp8XWZd3hkUXmq393dlsd8rN7NW38dr3v7t3+f2nnguTGfa2eDqz2QwNZ9CWELZ3t/f3Jl13 +Uy13y8NlPw9ye5a6ZjDTwSBmlouZWdGSSzFVVS2llFLMoKWYaSlFa0ykaNFS6m3TolbTg+qR/3rj +V+/0nxf37t0/sj5sbB3uPzLgnmIC9+7du3/ofc2rWaf+r2+MJQGr8gAzU5gAZqaGwHWxb3XyV+30 +Px6qmAXirh9u3plfeWw/a2GmsnpyZq4rzihCsy1h7ibTnDMM/XIpEoIwxcgkRhbjpI71ZQm1zyWM +zZBLMYBAIcZ2sjPb227aqYWGiUMT2xDa6WwymZTxb/zNEQeWFEDZLIY9WepAIMDsg3cuMi4CuP1B +AcCk58589jOf3L1xdO7W3d9RWsaG23b7wrmP7+98vEmfyYvzWXR63i6fx91bt+5e/+DGu2+/9dY7 +Z85fZJpsbz02a88sBzsfsbuXpzuIDbantjebMp6fTi8/+cSzi/8/e38eL8lZ3ffjZ3mql7vf2Uej +ZTQarWhhF2AWIW8Ygw0mxIbEOGCMv3aMIXa85PXy8o1XcBzHSbzEeInzS2wnNtiJg78x3g3IBmSh +BSEJSWgdafaZu3d31XPO+f3xVFVXd98ZCYKQRvc0w6hv97truqvqVp/znM/5nPyhz9z9F8Q2iBvt +Ns5OZ1H6KytL21uqhqWaX1VUVBTMRDWmAF9VNYpqmRQkax8zVUtJQFL/p2NYHVAxNbXSwFWHPR7+ +++K8885vLf6MTcBjacRYEcF55513/tznDRouQAZCyACgBqRmVIb3KaZkwnTHCMxA1QSFgSFF6oiG +KAYMcGJpdWW9f/F525kCdBi5CKEdJRaxsBhB1QyyTjeEDFQVIM9zEeEQkjENIxQSOcuIyRDbITBS +d3Z2ZmqK253ImQEwUmhlSYAURRAp2eEQUa6mFtEAidS0ymVQUxBsUE4ZbtQu6ppAahVQ0zT/WA3E +4NSxSHDevvl/fNkFN3Kr1x9MLR1tTcUpWp5Z6Q0IB4hmBsQ8szg/u7i466KLLnrOfR/72P+3ClnW +Bu4+dM3z8MJLoDNjc/O0ML+7jXvmO8/fPvPiordvut8FfSjYfcsrD01PY0AoiqKw1T0719rW21hv +q0jp8VPdVMTMynZfURGVGMs7ElNfcL26r6JaGgWZaDo9hlmQ/74477zzW5YPY9lDmo4IQ6nQJkUE +55133vlnBY/1kj8AIFElCjIoTUJN1FjByNSUjMDMQFWViZIQSBAZWc3Q1FQFqJ/nUfVzjx7dt2tx +28z0AEmDgLD2LI9SxCKKFFIQkSKpxGxmupvxII8G1M6YQzY9Ozs7N2PUHqgmf6JS+p/KDUm6gxDF +0mQxYlQ1NEDWKsAHUE3vsHptynbqj1tVAEYNMlXHHTPVjBBkHfvrO+q93N8AwD6CCSgAAqBIBAQE +AcouuPTgwZUdn/nsX2S0tnd/7M7A7r1z3c5cxjsee2Rp++xF2/a/OV9vI8D6OrQ6F5238IoTJx+1 +rqSBa4Cy1r9/5+Jp7u2NhQGAlNG+SvL4KeU+KtW6v6iKihkk/U9KB9JIYE1OoJo+vlTVm2Sf6r8v +zjvv/BblwyYtAo3UYaxqsJntqPPOO+/8OcnXcwDUgNFMRTGglRJ/4nTXkoDfUhJgqkqEqqaoqKpE +lIoACCioDGBEKgpEWRaQCQIWfZEoigCBjbKZ9iwxnzq9TkQZ8/T0VLc7FYFjLJItkQGs5oCYIxKi +lrJ9REI0ADBQU2aOGlNbsERI6QHEYRxfjizA4Y9WTckt94hpWQCxYRI06pk/rJCkNKBOmZCq8chg +gJiKDwDARAB26njrude9bt/F21bXHpyeBoBef6PfW+bDj/HpY7uOxAFv3LzvghdRxoja74Upft5C +99Z8cG+7K1FkugvHT3/yuZe+oVjfNxiASIxRzKDU+FvKBCyWRQBR0TRTOXUCSBRVVbHklGQq6T2r +SNpJZiailAoi/vvivPPOb02+mgQ8ZhU07hw00VbsvPPOO39u87UTKACkGcDVMOBkB5TsfZiZsyzZ +/ATOOAuBmbJk3JMFZg6BiEprIERkouQKSkwzU+2kQEnxe/IdylrtVivb6OVlYA+AWNYfhl4/iIAj +Y1zqOgBgtcZfrvdA3dELlUdQY1dUC94G9VOb9AGUaYOOvXykSaD+F4mqgWj1e8AqSSlBYp6ZhY3+ +WsaAgP1+f+nUvUcfOdHi7e126/HHT+zde8lFV1xBgQCBML/zwd86sfFn8zt7nWkztmB43YG3Fyff +sL5KIpIM/qNITP5KMeZFLNKQ30Ec5P3BoNjU/yfN/y2KVCowS39bOSDMf1+cd975Lcvzrt37sVzI +qZ/AxoU9vbiegDMOOO+8886fo7ylyLsRtpoZlWkBEhKkBRNCBCKi1Ms7NA9lMgOmCkFI7vspVE+i +mzyPYqZqoiCGoqYGMcogj2AGycPTINkQDQfbJuuaaqZVUrxYJWlPM25FxCpGDZI4plz8VhUp9TEi +5f2kn0mxdAqoRSTGqKppvlZ1q0hVUY3pBaXGRmNaYi+tdkQkai3Hr4bvqoEZiMhgYLFgkXZRZGDd +men989suzHt5u9Wdm5kaFP0jjzw2t7gNmVWIO2tHT34mdDbaHSBCjdYJ2+LGNVIEqSovyelHRKOk +zypFobEookiMMUYpYl5EjbH+QBal3FGShh9IXfQA898X5513fgvzvHvPJRU0XMhpvLJe5Smvm4jo +vPPOO//s4KvY38qZYIRmyJTW6qGM6xEAgZiqxe0qM8DhinwpiCGsFtrTP9+04rFqIR9TUytYZfBT +Bf6QxgKbqkGK+dNzMWoV69cxv2jqRaiH32od7msZ9KupWrV2nhQylWomShXEl3AZ69dJQn0bSw5G +/i1JzdBmwzdizbzFDAGSDAfAVA2JF3buNjPtb7Tb1s9XThw9vLhjNxJNT808cuSmuQXNZUDErRaQ +dWz9K8Bayf4/9QCoqMQoUaOIRIkxFkURi1iUlQEpiiiiMaaWYBGJqbk5vTMEEFGwcvnfz3/nnXd+ +y/Kh2TFgNtlGMPQNbVScnXfeeeefDbyakZYqoBSwVkqYdCUlQlVBJpOoBIgIKqSEIkooiIhogoIC +ZgyIwAACiBhF2UzQQjAFJCY0IyJTRWIAS8UHaor1k/AHqb5wa+3Po2g2sniT/hmodPy1mU9D2VJq +eUrZT/mDpk9plSqoHGVQKX1gQv8DTbFR9d+R5AfrdAgpvX/CVBVJNRMEMCIzIaIoGqbnZkJr7dj9 +3S4dP7F+1623XfX8F0ZZ2Ll40er6w/PbENAQod97/ILz+8cenUmyHalGAVQlkLLmUXUFi6iWMw20 +ahC2kq5sP0HNkNDU/Px33nnntzgfGld3qr9ZKtdk2uyVzjvvvPPPEr4pcwdEU0BSNUZTQk59wQAa +IyKKGIIgkUZBQhFFEKm098kJR8DM2KwwDgxAhCoCiCCqgdlUAZFSS0C6Tic30jKCTjUAoabgHsfk +/gBQTiFAHPHyrwoNtcclVPG9Qun3afUT1kgM6kSh4pvRfr39FPdX76RqA6hbaRGQuJpXTMiERFxW +VQCSTqpMPhC41ZndeyAefWBxsXPo0KmH7vvMFdc9/9ILb/jk3Z8g1mixEGPqU+sRkcUoaWBvkkKZ +iEkpW9Lk8VmXHEr/H5O6oFI2OxuYJvdPrEoxfv4777zzW5rn3XsONEsGDYVQs3Zg1YP1wpjzzjvv +/LOBTyN465C6DLqremkS9hBSfb9ZXkUaBuKIjR7basxwuR5vAGZl+2mypEw6fjUDq9XzpRaoltmU +E27LGbdaqXRULVaKnKTYiUntUt2KmMQ7MUZRifVz6ZEoUsQixlgUlcYnRokSo5SPJOmMSBTJC0nP +i6bNatlQm7Y28vakqf8RtUq4LwCQRE3lRwVQVYPQnppfXz2VtfK7bv2HVjaftfdbPCTZIxAAEIgo +Ft1tsy9YXY5WefrHWIuWJBYxRimKIsbqoxUxxmoqQBQdvjmDsg0ARDT5LPn577zzzm9lfigB2nSk +cDNjSFmF88477/yzi8eJtXYVJcRyUZkMVBUFFDEJgYbNA0XkwABAZABgbKRmgcnMNI3/RTATRCJi +AlFABEU1KHsMYgQq/TXLf50Im2vw9Rp/SjOGWUrD4acS85g1VvGxUvhAufg/VARNrvqr6dg2mwv/ +ozqgVKoAolL+w5zuARJx6p8gJCIhImJEUFFiqvqnCRUJURGQeG7nBcVjK9u37fiHm/7iO17wzpmF +6+44dNNUl80sj7nixv7L4uOPGoBK2eJsZUeyVAMBhlmTWPlImmVgZlpqnap3bmaEqOVsYD//nXfe ++a3Lh9ohaFItBJsbizrvvPPOP3t4NSNEEWWmklZAghRYIpuKIAIqxigIEBEDgGAEAMhCab1vJilC +D2DRmMiYUYU5pJBaRCSVEZJGhggRVMqRXrUNfyXvSYs0UJUXRoLyOitQszpJqEYWaGX6WWUCMGwA +qHobShTSRIG6JaBOJ4bR/6j7J6a3R0OTUmx6JCEgMjNhMlTFwIwspSxIiBkJKcmEjAgJQTRrTe+7 +4MDqcrF+/6GHHrz70udfYI8SYxDMTaDXXzlx8rTqdKXrH6r9k/xHVKzqoVYDNdVUUSnzhDTQLWV0 +2tD/+PnvvPPOb3U+jM0GG7tTfbs0xwc477zzzj+reIXS/NMsXUEtLVsDGIACgBUAGZgxkppEgACI +AAIAFjit/QOAEhkYIglKMKNKIJS6YgU1BczlWIByAkA5bgyJUkdvGXY31/nL0HwYkaulQL8R0Nf9 +vnUdIBnvlD3EWjcIlA+CNSoGZRpQjg2u/sWRNKAhfUK0apZkWu0v6wCUvFEJmZmIhISoeiCQacoE +mAiYiJgJMc+llS3OzO7Ye+GFN3/ik3suee7enc9ZKe7iDAxBYm91/aRqF6DUS5W6qcoc1Qxq96Fq +1d/QTBWqGkD5GQlRDapZyH7+O++881udx6uvvXG0KACTUwNGW8HUeeedd/5ZxtfafuJK20KAGAiR +Q1rPDsTIxCFjJmIOgYkDMQXOOBARp7iXquCWqJwbQJXDDwIADb1Fa9c2aob7Q+kPomlT0JmEOgaA +dTGgXvJvrOtXNqPDwV6N3GAoFoIGUA8Ls7OYAKX3h43RCWnqGSDWn5TKAWhETEyMhCGUsiCmwIFq +LOVFREjMOMgPPXDf0eN3Xf2Sue0Xn3r4xP9pzRgYtHD/YusbVw49z0Bjoaoay8FeMc+LvLwVeVHk +eTEY5EVR5HmMscjzZAoaJabRwbFsERad+ER+/jvvvPNbkQ9jiUKdQ0w8qJsJjJx33nnnnw28Wl0E +MDFgAlAEMgVAMWIoYswgEGoswAIARICgYMagpsrMle6fmVTL6L/yyIQk+4Hh6N/aTwcBZEJrb41p +vaBqUM0pq1flq5C+/CzJ56da+Ne6YlDmBmniGJQmoVV6MOwcwOFmR/5ttZQdAUAzabFqIlpa/4cq +/CdEYk4JADMTc0hvJoSgpGqcsgI2RkQiIAOM0u12pmbnptYXH7j/YZ4N09mOfn6cMxBd39g4ZWqi +Yoa1+CdF9WqWsh0VheEHrWapjfgjWfVBmg0Afv4777zzW5cPDZ2QjpUPztJM4Lzzzjv/LONrIVCV +EACoJIdLFSQmVSkK4GAQwcopXcHMAoeyEzUQEZpytfJPgMDMSTZTNdBSGeJv0nwMqkpEVsXrMIzI +DQDTRK2G7KfZy1uG8XU7r6ohlrr/es1fRlRDZjrsEa4yj4YMqZF0JNm/gVXVi3IyGhEQlGlPym04 +hMCMFEMIRBICE7GqMnMwiyAcyNSQkDlVOHBto3/+RReuLB8ueLHoFZ2pXf3iOAD0+yf27eX53XOf +ve0koJa9v6Jm5YAzTf2+OGxzrjuAS+1Wpfk300Yzg5//zjvv/Fbn8ZrrbjxTgWCzasLZCgrOO++8 +8+c0n/x4sPwPEgIxQfoLkuAnqVuQiZN8JZR6FwxJAJRU8UyIEIiRquX/8ipchfxVtaEpta+TgXoq +8Ka9vPX6/QjcmO1VTRBOoiAbegDhhPd/cxBY2ixs3gEMAATDqkXZB4w4bAMgzJhTJpAqAIEZiUJg +rqoBgZm4dAoiTqqqqpQAyIPTJ5c/P71jaW7PQ+tws2aa9/DCHa9fDG+6584emMRopWdpEYuiyIsi +xpiUP0VRDAZFkReDPC+KKFHy5FcaRZKd6tBsFfz8d955550/YxPwWBoxtgnnnXfe+Wcfr0CEkByB +AEDUEA0p+ViaigKAmrGRMaBSMDBTRiUls6RrYSIkLbt+y2XyWvRPdRqAmwbZTcMfUx0qggDFxpf/ +oZK2NEf+jjxraja0D0rFgeqFYCZl6aOWADXaC6xRpcBmSlBlL8kOiBhTEwAzSRQi4iT1ZxEiDkFV +iCgLmQZTEQ6swsTERirGoZQOMXNozzLM2SAO1jXMzERYYYZ+vrw2WFFlA4tp6oCqppFgOozry/nA +UFU/oPyM1ZciVPtq8yZgP/+dd975rcY3JUAAoIgEpjCqHxorIjjvvPPOP1v55ApqakCGSFE0AKUc +IBnwVFdSIIYoysZGRmAqqiEQGysJlikEStkCXLpmVrWFMyzSVCvx6Q0MHxl2BozG9zayhF92A9Rr +/zCaCZQbFwNCqJoBYp1FqMKmxqPVDOCRgcRICIBMCEXSAlFdFVFVqdIANVMhDsEMgqkyq2m5y4yJ +DMAEjQlVDQJ1WvOrK8vt+ekWTRewwgFE1zf6q6bz6ZOJqorY2OyDYZKDzfX9dKCsWvNHKveqn//O +O++882GTAkEjdRg1GNrUdtR55513/lnFp+CYFIEMEUWNzIhBBQCYSZN/v6gFZjNhK8cIAIIKCBEi +xJj6XamW/IzF/aMqoOHSPjRcehqJQSnTL9e2TU2xGd+nt42VkkeGE6+SDX7qByiDe6gcMlN3b4U1 +WhHEiDG9ahg9l5lALZeimEyNRJAwSPL9ZGIJzCkNyEyVQ7LvTEmIKqmaCllmiKjKITAYpvfT61Nv +nYqcOYIGMIOoG7G3GmUGQETSm8c03tdM1ar2X22kAlVvtIqpARKm0o2p+fed88477/xIBaBa1oKx +H8c212widt55551/tvLlYokaECCCGoKUhptJB8RmxBTFSFGROSCIJS8hACVGRhWpu34VkcsL8tmX +/xtilUY+kIZ2pWbgYayuo728UA8IU6sD/VolVD9bFQMUAKTMBIY1gfrWNMycmAeM1RRgQtLkc6Rk +xMqkKGiZVqop48zKRX8zVUtuScYMCERcbz0Qc7DZ2VmS2fUlndqxyHQ4j6A6yPs9U1VQNVBJ/xMr +3f8hZRXVfkh7qNw59XvW0fTGz3/nnXfe+VA3BY/mDTTWVTCRWDjvvPPOP5v5qg6QWoOtnA4sMbUF +J+E5AEIgsAiRFAnQAiMAmpFWHj/ESQWkmGJdGkaiw7C00ZKLWEp+tJ7oBc3AvSnsKWN3KHt/R+sG +jUC/vGc2FsqrGBJY5RzU/OfOFPqXUwoI0xADpjTcgJGUlQSNA4KZMnAZjZuKtlKrQYrZq+6FkIGp +WmAmFlSNamR9LbrFRW2e3dB7iG2ld+SKK+H0Q7OPHVoCMEnjgKvhxw3zz+bbtrG0qpoCVic5fv47 +77zzW50PdV1gVDzUrCZQc0nMeeedd36L8I31eAACBSQEU0MSUUYEQouFVcN9lRALTSPElCgNF0NV +NAMirEx9YLIGkMQ5Tf1PvYTfFOrUQXkJaOns2eRFrbn9Rj/ASFNBbfypMrY6DpsNA0tfG1iO2kUk +LbOBtJYkakxoxEhqRkrGZqpkWVCFEDgHyMAAgkFMQTsHNjBmVjMlIeXAnKstLi6sL+drq8u4EBCj +SC90+sQi5QRgME3jgNMkACv9PQ3ST9qYiwyNQcvpMxKiqPj577zzzjsfmh0DZnDmV1JjCch55513 +fkvwqSe4jozFABHIAFGAUAwQGdRAERGNk0OOEqIpSpLKIyDhmPvkE2YCDVWPSqNC0MwEhhWDak09 +9blaNeSrIQQqZTATwb2UfkRncMds+BRJSh2QyAyiGAASM4CRproAqRkIGnMIZoVZMFOzrG7V1ZCB +GVefpFy6Z2YANhMAIAJuzy8tP9heWZ+az9QimPX6q3kclCqg5PuTegCgdDBSq0clVAnMyMQ0gNKC +CU3Nz3/nnXfeeagHgUH1RdWAoDlaDDaxEXXeeeedf/bzosJEaaEZCc1MAcGU02WURIwQgcAkplAY +yzIAYulBKemlozKaKrwWTTKV8WX+yYX8USHQiNAlJSoqm75EASz98428oh4joGNBf1VDwGayUi78 +I1jVHIAIKhEJowASsVmaghDFAAKSpW8YjAVAVr0fTGb80KpVTJzidUE0MEQ6ebrf6czm/cdncc5U +iIpBvp4Xg9L/E0rxv4g2JxlXsw5SdlAPSLaqAjDSKeHnv/POO+88795zwEwbfWlaz6pvcFY9mIZE +Ou+8885vIb504EcsJwRX9xFBVBHKyDaJd2rTHlMzTbE8AJhKEsRb+YzVkhUbLpJLKWwHs3KxW6yc +eFtq6EGHyneQKFba/6iKApZa+2SaCZVJTh0oq1mSDqUqgVWVAa2l9GOVCrXaWrOsLYhB2iHVYLFk +DWSG6aOkHAkB0tjiJGEyQEKEZHdEiOVeQkRL8hws9zyY2s5tC8eX79m2JxoMVGKnc976yQvWl83A +RNRUowiYiURVk1gOBY7ljIBSGqRWqYRUyixGDRDVz2fnnXfeeVDevedAvQ6UuNHXQ/PFZSHVeeed +d37r8WXsas3uXUxCHlFFwLQIDWhmqNVYLk2RtTbcKtVEFAFUVUTLZzUFrcM/ZYxuZgYqaim6FwWs +cgYt5e9QzfptCn5ShqDJUAjAhq5Bm0l9tBTRqFrZVFxrasbuA0DKIbDRjVDG/tiQN0E1LYxSPpCe +NjAEtNqxv4z/R97b6ZUNwCOLOwvDjaj9TntX78SBjbXkJWpS+v+oiIqIqcVYhv4iEqOamaRZAVru +/NFP7eez884773w10QY2GSIAY9Xh6r7zzjvv/BbltWozFdFSb2ImagAo1cq8aVq3F5VoJmYiKjGK +qImmv80MoqT5tVA9LjFK4s1EJapE05g2lXoBtKwJaPojZUBsohZF1UDN1EC0Xs4fEcmU71nLDKQs +KWipjdFaR1RlIOnfG71fSvDLgkD5QtCU40hMO0NVJaqoSjm818RUJRYxeXiKFBJVJabnpYgxxiJG +EREVDYFb2WKvl6F1mUCL9SIOUrivZauvxigpSZJm8mNjDdCjGU5DN+Xns/POO7/Feapng40R6U61 +oKONDTnvvPPOb2l+qNTXhprHTLSMv6UyqFEpQ9UUwafcQCUOM4TyjppakvHEKjOoHS7TA+lPirar +LMJErUwjAIaOmONRfnkntRmkrVcRP9TBffOjnX3/NBOD9NlVKkG+mkrU4XyCMsqXqGJWfjhRNZEo +YqaiUWL6Z8tFfRUinupuy9cyti4aqOVFUZTJT2oDBhvvc7Dhj7UdavX+y3FgzeV/P5+dd975Lc7j +1dfeOOZ5VzsEbXqb9Mhz3nnnnd+yPBMPC6yEI/KgCZefupW2Gs5VOtOcYeOWjH3GHj6Lb0/Ts6ha +zpendP9Q1S6MlAaDQfoPIjERIhFj4BACETJnRERZFpg4BGZmDsyIIQtMBIghMCEtbpu/6Hx45Mj/ +Oe/SwfLgk7MzB4587htXTkxb7QQkqlJWD/IoEqUoYlFEkZjnIhqrrCN5h4pUyis9g8Opn8/OO+/8 +VuPLiQCjRhA0WS8Yqyw477zzzjuffEKHK+ip+Xa4PG4NVdBQkJN06mm1XrRqz5XmC7SqCUBzIb+5 +/cYqfqnMqR9prvE/1fsn1RAgaaJKB56ykCBVgSCKxJhW/UupvprGKEn4I2YSpYiiqjFKFFlf2zh8 +dCPQAmmbAA2jiqhKuV+0mgJcjgE2ERn+q1CXQcaypvILz89n55133vnhc9hoBqi50W1R8/XOO++8 +8843+aZWvnztMHaHZhAPALX4vn58jG+uVaeF/DFdPpRal2fE/qkrD0kLVLkdWWW+WYbsZW+AaCxi +svK3pBFKWUF5k41e//ixlen2Lo0EFNSimqiCiJSL+WqqkrKksg+hGgYsVT9DWgiz0hgV6z4HP5+d +d95551MCoGOJQtMoFDZpJnDeeeedd/5s/NgyfCOar+9gc016U350af+Zvn90E8GSNvqiVWLZNy2q +mlqeVVJrb5UDpCzAVGTHjh1zsztUKaOpFPen8kHp/mNqho0uiUr9L0rVgGSVpvS/vuPnp/POO+88 +wVmagMfSiMazzjvvvPPOf8G8qDSbbseW88/1z1s9YLUQKGU0oial5MkkJhWPaSqBiFXe/SpRijIb +EBE5vdQ7vRIR2RTbsMOUkqVpWTZIRkCq6eWmmuYnqELD56e8PzoL2c9P55133nkw0/HsAZFgQj80 +VkRw3nnnnXfe+TE+tSXXOUBdGCjdgcwANIqpamXpI1E0iiTbfhWNqcPXdHll/fjxDQ5TgBRwB1oo +HYLSi6WM/lO0n/4jBohl40EV9yM0hivX7dF+vJx33nnnaTJ7gIZUaKxqMGEj6rzzzjvvvPM6WRCo +JgaoWikGEk2upSpiMUosxUBW9vWWcwNM1WIRW60MgDOeJ2wBoqgme1VVsKaySJKsKCbbpOYssrT2 +37RF8uPlvPPOOz9SAShzhcalu3QJPYN+yHnnnXfeeefH+KEbkhkAVsZHAo2uYImmJmZQNf6KaJRq +wK9EiRIVgDkDZYQu8wwBDUN/HS7/Wzk+wNBgODkhTV2o3slkJuDHy3nnnXe+7h0eyyFGXrxZkuG8 +884777zzm/ATRYA0KljTJDRL0b+KqsWoVo4NlnJgmKopSJSs1SGaBphqZ/McMpXUI1yODzO1JAiS +ykTJqtHMCkMFkjUcmfx4Oe+8887XPCFO+geNVRNGmoudd9555513/kx8MuOvgm+UZHhq1hgPbBIr +O0+zFNBXncFQdgiozc8udDvzKDOBZ1QpqppBFJUo9cjjcjBC+m+58K+1BAiGs9jMj5fzzjvvfJNv +1gX0rK+kiaecd9555513fpLHag2+nA9gKirS6A62tHQfRSWqgqlKqgOomqiIxmPHV2PkEOanOjum +uh0VjVaOCxCpmoFNVQXMJKa+4vr9JMV/XYFAP17OO++8800er7nuq2DiZqaIY4WDTYcMO++88847 +7zxMDpxnTgtMSAiIiMSIyIQASExMSMQhECIRIQBmgYgDMSJiYDaDV35lZ8ceOXlk6rN36PLSBhiW +Mh+tZwuUI8TSnTj8W0UVSp0RmJmIwhlufrycd975LchPzg2uFULNjKF+UJ133nnnnXf+7DwhmpR2 +nA1LUBFNAqFSFhTFRNUMkEAMVEViVDEVQYQsTGc8f+RI/9TJNTCI5RyB4SzgpB4qTUWtfDJtH6qu +gHSfEP14Oe+8887X/FACtOlI4bEXNyVDzjvvvPPOO78pr2aAtRAIUicAANX+nbUrKFT6n6TsSaG9 +mBYxMnYIp6an51QtZQrJJVRK9Y+Uo78MUhZhpfcPVP8sEGLD/NOPl/POO+98yVOze2DsDmxiLArO +O++88847/+T4OvpGMzOVlBtoCvTFpPL+F1URlahipskXKApxRtgFCFGiiolGNY2iKhalMNWo5Sxh +gHIiQG0A2mgAqEsBfrycd95558v7dKbRwZVRaPM+1UmG884777zzzp+F1zQKQE2lxlJjbprXW4pz +RK2aG5CmBGgS8ZtqpzWThS4BV2kBxCKqiqqgQSznh5laPWSgkhaJmA6FQI0lMD9ezjvvvPMEAHj1 +tTdOtA7oZDtXM29w3nnnnXfe+SfkAYBSFzAAIhAiIiARADGlxuD0PBIxEiIiEyEiMZji133ddXOL +7XvuPnrXZx4lppRIlOY+ZqYmYgDlbGEp54iVQ4dr79GyY6AcSebHy3nnnXceoHYB2rSDePTBka04 +77zzzjvv/BPyhKhmzJQs+StHIKxzAEREqvMBTstUnMyAEAAg5Q+1p7+ZqVQzBUxF01SBujVYRQ1A +Y5RKd2RjZQA/Xs4777zzTZ3QeNXgLM0EzjvvvPPOO/+EvJoRYvLugcbiPYBq2bxrplq2AcSoYmZQ +REkWnmnhPkmAJGoskuOnRkmTgZP0X5P4p47+Tev5AynwRz9ezjvvvPNNHq+57sYzFQjOYCyqzjvv +vPPOO/8k+RSLV0KgNBYAzIA4AEBdByCmVDGoigKpYkAABoZazRSrLEQBADRKkv0nJ1AzSwmAytD3 +P+UAjSZgP17OO++882duAh5LIxrPOu+888477/yT5UWlDNuHunxARNOY6gBl7B5LO/+Ypv1GkWgx +iqgpaLINVUuKf1MRiSKmWr3QzGKUtPwPkPRD1oz+/Xg577zzzg9TgtFJwApAYAr4JGeMOe+88847 +7/wT86kAkEoB9Xjg8suJeDgwODUFlw0DqAZc9gDU2y+zCQCoRwqYWUozUqNwSipgxADUj5fzzjvv +/JCnyewBGlKhUYOhSRtR55133nnnnX8y/DCOVykbAOoH0pDgUsijpa1n8vUX1Sha/63lLGCTqLXu +X3TE8TNF/0MZkO9/55133vlRvq4AjCmHxoVEE0mG884777zzzn8BfC3iR0pDK7GqDAAxVZMsEcAI +kajyqBirAFSdwSnQVwOzSmI07DMeJgNJduT733nnnXe+yde9w2M5xNiLJ5MM55133nnnnf8C+KTS +SdPBoPTxLAP1JO1XiWmel6glqx9VlbTyL6pSWgAl3U9dMaijf60aDIbvxsT3v/POO+/8JE+Ik/5B +Y9UEql+WAOedd955553/InitF+kbzvy1oB8RVSKApowAANVA1KKUOp8U4qvVob+qxLq3OBn/QyX+ +UTPf/84777zzm/ONJmA1gycaH9C8Oe+888477/wXw9OwA7i0BwUAQisbhQGs1AXV31sKQKZabyNN ++EpBf20MCqO+n77/nXfeeec35cdcgJoQPJHMyHnnnXfeeee/SL6ZA5haw/wHGotY5aJ+bRlUbaSW ++I/8WNn+qO9/55133vmz8DRaHYCGQqhZO6gfVOedd955553/v+e18vkxbej4RdWg+jNc2K+8PssG +AAAQtXqGQPlyHat0+/533nnnnd+cH1YA6gTiLJnEpgmH884777zzzn/RPDVW95MiqC4IpMaAM2xz +ZNU/bURUfH8677zzzj8hT83ugbE7sImxKDjvvPPOO+/8l5DXaoxXqgaM2flbdVPR5n0AME1zf8sU +Qs18fzrvvPPOPxmezjQ6uBoZ0LxPdWnVeeedd95557+EfB35ayXpkcr3J91J6UF1PzX7lqv+pTDI +96fzzjvv/JPj8eprb5woEIy3T21aWXDeeeedd975p4ivp4Y1RwiP3TYT/Pj+dN55551/Yp4QJ/uA +NxksPFZZcN5555133vmnjlcbuv4njVD1iKUJYLXgx/en88477/wXyjd1QuNVg9FtTc4XcN555513 +3nnnnXfeeefPMR6vue7GMxUIztA+rM4777zzzjvvvPPOO+/8OcqfsQl4LI1oPOu8884777zzzjvv +vPPOn6v82CRgBSAwBXySM8acd95555133nnnnXfe+XOJp8nsARpSoVGDoUkbUeedd95555133nnn +nXf+XOLrCsCYcmhcSDSRZDjvvPPOO++8884777zz5x5f9w6P5RBjL55MMpx33nnnnXfeeeedd975 +c48nxEn/oLFqAtUvS4DzzjvvvPPOO++88847f67yjSZgNYPJZoKzdBg477zzzjvvvPPOO++88+cW +P+YC1ITgiWRGzjvvvPPOO++888477/w5xk/ODa4VQs3aQf2gOu+8884777zzzjvvvPPnLj+sANQJ +xFkyiU0TDuedd95555133nnnnXf+XOGp2T0wdgc2MRYF55133nnnnXfeeeedd/7c5elMo4OrkQHN ++1TlDM4777zzzjvvvPPOO+/8Ocnj1dfeOFEgGJ8asGllwXnnnXfeeeedd955550/53hCnOwD3mSw +8FhlwXnnnXfeeeedd955550/F/mmTmi8ajC6rcn5As4777zzzjvvvPPOO+/8OcbjNdfdeKYCwRna +h9V555133nnnnXfeeeedP0f5MzYBj6URjWedd95555133nnnnXfe+XOVH5sErAAEpoBPcsaY8847 +77zzzjvvvPPOO38u8TSZPUBDKjRqMDRpI+q8884777zzzjvvvPPOn0t8XQEYUw6NC4kmkgznnXfe +eeedd9555513/tzj697hsRxi7MWTSYbzzjvvvPPOO++88847f+7xhDjpHzRWTaD6ZQlw3nnnnXfe +eeedd955589VvtEErGYw2Uxwlg4D55133nnnnXfeeeedd/7c4sdcgJoQPJHMyHnnnXfeeeedd955 +550/x/jJucG1QqhZO6gfVOedd95555133nnnnXf+3OWHFYA6gThLJrFpwuG8884777zzzjvvvPPO +nys8NbsHxu7AJsai4LzzzjvvvPPOO++8886fuzydaXRwNTKgeZ+qnMF555133nnnnXfeeeedPyd5 +vPraGycKBONTAzatLDjvvPPOO++8884777zz5xxPiJN9wJsMFh6rLDjvvPPOO++8884777zz5yLf +1AmNVw1GtzU5X8B555133nnnnXfeeeedP8d4vOa6G89UIDhD+7A677zzzjvvvPPOO++88+cof8Ym +4LE0ovGs884777zzzjvvvPPOO3+u8mOTgBWAwBTwSc4Yc95555133nnnnXfeeefPJZ4mswdoSIVG +DYYmbUSdd95555133nnnnXfe+XOJrysAY8qhcSHRRJLhvPPOO++8884777zzzp97fN07PJZDjL14 +Mslw3nnnnXfeeeedd9555889nhAn/YPGqglUvywBzjvvvPPOO++888477/y5yjeagNUMJpsJztJh +4LzzzjvvvPPOO++8886fW/yYC1ATgieSGTnvvPPOO++8884777zz5xg/OTe4Vgg1awf1g+q88847 +77zzzjvvvPPOn7v8sAJQJxBnySQ2TTicd95555133nnnnXfe+XOFp2b3wNgd2MRYFJx33nnnnXfe +eeedd975c5enM40OrkYGNO9TlTM477zzzjvvvPPOO++88+ckj1dfe+NEgWB8asCmlQXnnXfeeeed +d9555513/pzjCXGyD3iTwcJjlQXnnXfeeeedd9555513/lzkmzqh8arB6LYm5ws477zzzjvvvPPO +O++88+cYj9dcd+OZCgRnaB9W55133nnnnXfeeeedd/4c5c/YBDyWRjSedd5555133nnnnXfeeefP +VX5sErACEJgCPskZY84777zzzjvvvPPOO+/8ucTTZPYADanQqMHQpI2o884777zzzjvvvPPOO38u +8XUFYEw5NC4kmkgynHfeeeedd95555133vlzj697h8dyiLEXTyYZzjvvvPPOO++888477/y5xxPi +pH/QWDWB6pclwHnnnXfeeeedd955550/V/lGE7CawWQzwVk6DJx33nnnnXfeeeedd975c4sfcwFq +QvBEMiPnnXfeeeedd9555513/hzj8Zrrvmr0lZu2CzQLB+S886O87N2z44rLD+zdu/vgpQf2nbdn +lAcAQCzvI5Z/18/W989R/vHDR+6/74HDh4/e87kHjhw9WT3r54/zzjvvvPPOO/8M5YcVgPplZ8kk +Nk04nN+y/PRU+3Wvu/HVN3zFFVdc2u1OiYiqiCiOBdGbb98SVt85R3kkZOIQwsbG+j333PfXf3PT +hz/8V+sbAz9/nHfeeeedd975ZyaP11x345lGB4+9uLqvzjvPjG/55te94x3/ZG5udmOj9/DDj9x+ ++2cff/zxo0ePr66uWlo2Hw2mn0xgfc7xiDg7O7t7947zztt33XXPufDCC6anp1ZWVv/zf/6d3/nd +/60Gfv4477zzzjvvvPPPNL6sAEymC83NTeYQzm9lfufOhd/4wL/ZuXPn0tLSX/7VRz/84f/z0EOH +YiGAKCqEBABqShVf3R/e6kcm7pyTPCKaSqvduuiifa973dfd+OpXLi4uHD9+/F3f+QNHjy35+eO8 +884777zzzj+jeLz62hsnCgRPNodwfgvy11x9yb/7hZ8kos9+9p5f/MVfefDBR5AIqbk0bgBnXFk3 +tVH4WcWbGhjs33/+e9/73c95zhWq+i++70c+c+cDfv4477zzzjvvvPPPHJ5377mkelkd1mBjW9jY +CgJApZN2fivy11x9yQd+7ReKovij//m/f/pnfmHp9AoFQkQTKyPhxh9TBcDqRwVDsDJgHn3qWcKD +AjIi4dLplY/8+V9OT3evuOKyb3rj6z75yU8dPXbSzx/nnXfeeeedd/4ZwleFgLI6UHKNB4ezxCbm +Czi/tfj5+emfe/+Pra+v/6df+61f+ZXfNjVkNDVTAwTfP4BgaiqCjAD4S7/8W//p135rY2Pj597/ +Y/Pz075/nHfeeeedd975Zwh/tibgM7QPq/Nbk/+t3/i5gwcP/NH//PC///cfIEZIipcz355ku/qz +kk8yIRV7z3ve9cY3vO7zn3/w7d/+A36+Oe+8884777zzzwSeEl1nCWdKIxrPOr8V+a+88cVXX33V +Zz97z6/+ym+Vpvhqk9iT2P6T42sRTrpT86pmaqqiqgZmAoDpDwJWkTeKaCJFBayxfdMRkc9T9v6r +1Eh/9Vd+66677rnqqiu+8sYX+/n2jOIBwEws1bBMff+cu7xKeRzrO2YCYGbRTOo/KtHMzGSS9/3p +vPPObzV+bBKwAhCYAj7JGWPObwmemf7g939tbm72ve/94bvvvh/wC1s4P/tS+vizNvoIghmoKYAx +8fRUe3a6s2v73PZt8zu3LezesX1xcd6QgBARARmQllZWT55cOn7y9MnTy6dPLZ9eWltdWysKSR8H +AQwUm1kyfknff+MRJDSxK688+Iu/+L6VldU3/+PvEPXz7Wnmq6SxwTcau0df6PvzHOBHkzqbbOKv +jq9t8tsOWPMThnq+/5133vlnMx82ebRhG1R6hW52ZXR+6/AvfelzDx488OEPf+Suu+6lwLXyZ1Me +v8DtI1Id9Jc8pS2AxMiBZqY6F1+w43lXXXjlpRfu3bmjFUJgRkNCVAFDNGAlNgRDMgrA5xMFo4BM +BqSAR48df+DBh2+55Y4HHji0vLySF9EgzfRVBEqBQfl+8It6/2fgVYSY7777/k996tOve93XvvSl +z//4Tbf5+fZ08dU1EeugMP09tHVSMyoXg31/nhP8aJTfSOhTh5IZIjKjAgDgOA8EZMOSHampEbPv +/2fX7zuAiakhoJhS6pIsl0Kr3A/QIGWJiR+5CPj+dP5Zy1cVgDHl0KYDhM8COP+s5c30p37i+77y +K2/4ru/+vjs/c0/Z+PsE23/CZfIGb+PrcWYqqtvnpl7yvANf+4rn7Nm10A4ZIIkBKKiSKiIQIBmQ +IQKSAhmTYkBkYEJiZAYKzMycUQhETEwidnpp6W/+9qa/+eu/O3LkWJSIQIDpik+bFgSe3P48I5+K +AFdfc8Wv/sov/OVf/s2P/NgvbDqtw8+3p5SfWPUf710xhaa7a2NYuu/PZy7fCOi1Pr6IQKB57J8+ +fezk8cNF0QeAELK5ue1zcwvd6fnAbQMEwGH3Po0c7pH0z/f/OcXXcb8pAqiYGagY5GpGHAEHYmIo +akSIABlCi4FBUK1FyACERAgAnK7ffj44/yzmx+cAPKGN6GT51flnN9/ttj74+7++vr727e98T6/X +HyuwP/H2RytQI8Co2scAVCUjvPLAzte9+urrn3dJ1qJYmCoaUPobFA0JjAEAgAFQAIECUEoGGAIB +BUTCkAExhRAoIDMzEwcmJibmoKa33XbHh//kz2699bPr6z3cpA72JN7/k/i8aXd1u53f/I1/Pz09 +86Z/9M5BLn6+fTn5CTVI4/AigJkBmCoSAVAtBzrzHHXf/88IvmzbGC78l88W+foDn7+jKPLdu3df +fvnl27dvZ+bV1dWHHnro3nvvTUPKd+7ct7BtbyubUgPCqomIhoqgM8mBfP8/M/nq19xE1MCiaQ6w +IbxhKIoGmFaIgNhCQCJEBgC1CNEwRjBBVQJFU85wBqxDsQ2QUCQ6Uybg+9/5c5oPY+f0Zhc+ar7M ++a3GX3bp/j17dn3oQ3/f2+in5f8vbPu42fab/rMIYBAldtvhq192xT/6+uft2jFDiLFQUSWkUtVL +AIpGWIp5NUmHgJCSQT8iGVMp4yFGTFduBEImRiIubwGJAobrr3/xS15y/YmTp/7oj/74wx/+i+Xl +VQRAqhRBWiqCNn//T/rzpkizt9G//fY7v+mbvuHyyy++4zP3+/n2ZeNhROJvSFC2sBsgWrcdXvCC +q1/+8pc873nX/uz7f/HWW++rdUFnrq76/n+G8FBW2FRrzd2Dn79jaip717u+49WvfvX555+/uLiY +ZRkixhg3NjYOHz5y++23ffCDH7z55puPH38sy6b2H3hOK5tKjgZUXmzQ9/85xJsBgJiqmBUiaxBW +lSK0VEHbndb09L6F+e0L84uzMwtzszNT3RCyVggZMSDkEosoRZ6v9nrLK6unV1aPLi0fPb1yYmOd +BgNiaJHOQpyiPENkDOmt+f53/lnDhwakZnDmV45USJ3fOvwFF5ynanfffa+VC6Zfiu1bxROJaiB4 +6QsuePc7b1hc6JiaRFVBs2pqBSEZigGAIaIZpgcBAQwNDNIKDQIBWBLxEyESEBIzEyNTCIGZiRkR +iQgBEBERd+3c8f9857d/6z/9lg/8+m//6f/5643eRnp7X8r9Sahin/3sPd/4ja+74ILzUgLg59uX +gS/dXagO6QCRCAHRdu2cf8c73vK613399PT0YDBot9tfeeMrb7313gZvZ72S+v5/OnkbarjqCkBx +152feNvbvvUtb3nrnj27Y4yDweD48eOqiuViAG3fvu1rv/Zrb7zxxr/927993/ved+LEifs+d/N5 +5x2cXzyvvrYBpPQP6pk5vv+fmbyZAliMIqDrSisQBrGlRDQzc/Hu3Rfv23v+7t07ty/MTs20soCI +aoaIalo6SwAgogEQIpgBgqrFIi6trx0/dfrQ4aP3Hzr86LFjvY11Uu0SzFE+rTEQI6UYC/x4OX+u +86FRGqD6kpfO7zqlOEM1wfktwZ9//nlFUZw8eQrPmFN+IdsffnMToIrKlZfv/M7veNWFFyyAaCFK +hoSAZGCIhkqAhqYpwE9fzOWCPyASIhBbuTU0QkICJEIEJqbAzBSIkUKK/omImKqIIP0XAGZmZv7l +93/vP37zN/3qf/rNv7vp5kGRMyIAgQHCl2B/IsCpU6dF5Pzzz/Pz7cvDq0hD1m+ImJyipmeyd//z +d7zxjW/IsszMVlZWBoPB9PT0Qw8+PFoqHdOB+P5/hvEj4h978MG7/9W/+uHXvOY1GxsbjzzyCBER +JT6NxrQk/lFVIrr++ut/6Zd+6Ud+5Efuv//+xx+/vyjijl371JiQanVY6uD3/f8M5FUEyUS0MF1S +XrVONLT21IUX7rn24IED55+3c3ExC8EARFXVNvIBQHMyauoDtkrx1VirAVycnd8+v3DlxRe/qiiO +nTx5/8OHbnvgwaNHj68PIASY1zhHRYbMTKMzVv14OX/u8WHilQpAEyoiqB4s9XbObx3+4CX7iyI/ +fXpp7Dyri02TOrNNVWiIlHQ16REx6XbDd7z7Vde/9BI2yXPNEJOYJ82oRgaQskXXEAFIDQArOVAt +1k0eDoSpqyu5uhAiICETETEyh5BEQYSEAESl0VBaF6yjhIsvvuh9P/v/fvrTt/7kT/3bI4ePVVoR +TY3CX8znTbwaAJw+vZTng4OX7N+M9/PtS8ybQeX8iKZKTIRADC9+4VU/93M/PTc3l+f5+vp6Ou6I +JCKHDj2eXtB0BfX9+Qzky9/85NmiYGAbvVP/+B9940te8tJHH32UiBoT7ze5mdnp06dnZma+7/u+ +7z3veU9RFMePP9TpTs/MLqoBADLQcPu+/59JvJkAgJoWMS5ptmItMaaZ6esOHLjuskvO37OnnWVR +Yr8oenlepfGjRx8M68C9cp3ARlubWXoGEHHHtm27dmx//tVXPvz447fee/89Dz5yst87LXGRZV6K +FjLQSMeIHy/nzy1+KAGqSwNj8c1YVuH8VuMXF+dVrdfrT/KTPpiTmWh530b4qHLJVdvf/aOvXZjv +FoWoWEA0ACVAAUvr8gZAAApomDw7kRAMrcwAAAkNEICAABENEYAJCQghLQCmZX5mIiSsHmCCShIA +KRmo1gjTjy984Qt+93d+/cd//Gc+ftM/mNmm7/+JP29z/xCaWK/XV7XFxXk/355qvtH4iwCWon9E +/ba3vek93/s9Mca1tbVU/FEtycFg8MgjjwEilJkDmBoy+P58Bh9fG067l/WXvexlR44c3iTiO8Nt +dXV1YWHhjW984+///u8j4qOP3HXwshdmWRcabfxJCOT7/xnCp9/KGIslCEvWjRCgO/W8g5c+74pL +du/Ybob5oBj085TUJwfY+iA+4W1TfgA5GBDh/vP2Xbhn74uuOHrLPfd/9sEHT/Z6y4g7WWesQGDm +TbQWfrycf+bzodk9cJblzMZ957cWr40aqTV++AK2b03xrgDB1/6Ta7/h216CYoMoLQRiFABWQAVg +AC17/DBp+pP8h1ANEdBSlJaM/KpcoBQGEZYFgDLWZyYOxEQMhICUigBUA0RWqYmbccPU1NT73/8T +/+N/fPADv/7fer0eVoJyBAL8IvbnUEig5ufbl4vX1PJrhEhs7/7nb3/729+2urqGCIhojVu73Tp2 +7Nix46cBaGgNvtloMN//z6jjCwAIOuivHjx4oNfrDQYDKkeI1MGc1b/X6X7zqcFgcNFFF9XJ/+HD +D56/7zLikNL9yhnW9//Tz6eyj4j0DI5Bd4BsWevAhRe95KrL9+zYqQYr6z0zI6QniPJHlv9HFv7P +ztsgN4Adi9u/5vrtV1580d/deffjjz92WGNX427OWxKZ+Qzj5Pz4Ov/M5UPdLbfpuuZQBTE0xHB+ +a/EwqpE0/QK3b0NeTDsz4Tt+5hsOXL0vFgOGFNaDgKGiEhCbKgICMqKULb3AgAJIgAqmVi7wJOs+ +IKv6ARDLpf265w8JoQr7CYAQUhtAswIwFiikO+n21rd+8/XXv/D7v/9HH3v8KFM1HsgI8IvZn3XR +ufnr5+fbl5w302q8FyACIRHDP3vbm97+9retrKykgo+Z1Wv/IhJCuOmmvy+byxtjwnx/PoOPb7k+ +YIBLy8eYdy0tLQ8G/bqrZzL0H1vuBYAQQlEU6XwAgPXVE73+3qmpeTFg4CoD9P3/NPNmKiIKctrC +aWkJZe2FhVdcddVlF50PgGsbG8kMDppX2MrMafM6gE0MfXlCHgEAijwHgN3btn/Dy17y2Qcfvumu +uzfWVx4x3gGDuZgHaiH58XL+XOLDmNtdnUM0NzeZQzi/dfjRmUkIYF/A9m24fTGdXmh9z3/8p9v3 +zRaxCMjIqmBiRgaWUgtCMwBKr0UwALMk8ScDw9IRSAEIwcroHYHJUg0AsawCEKUMgIkhhQRUt/4m +LdBI5bcZNDQfOXjw4G/+1i9913d938MPHRr+IsEXuD+BcXRIqZ9vTxGfyjmV+h9S599XvPS53/M9 +37WyshpCMDMRaQaCMUYi+shH/roZ+o8u//v+f0bxWh3f1K8hS6ePnzp1anl5aTAYPKH+p5nqZ1l2 +7NgxazgKnT59bKozhzwM+lIrsO//p4tXEQDNwY5Kq4eZtjuX7LvgJVdfMdOd2ugPSjeIZuw/2dk7 +dsPRH6rg/knpxgDMIM8jIl65/8I92xY/fuddhw8fPqa0bmE39lsagNSPr/PnCh820zFv2lasmwmM +nH/28zgay34B29fhg2Jxdufsd/z8P5vdM50XOUOSZWMkIQMDFAMCS/Y/qmCEKcwnQDMENQAkQyVM +Zu4GSGqKgFh+BxgRIHJdBqDqVuYDZWNAiu3rBZ6xhf+GVK5cJ962uPgrv/zz3/veH/78fQ/Vv1rV +3KgvYH+OCfX8fHsq+OY3NSISwuL26Z/8yR9V1RC4ufAPAKqqqlNTU/fcc89dd9+vxtZsABj2Afv+ +fwbyw1pajPk999xzxRVXNEP5M4Z/iOnQA0Cn07nnnnuaz66tnJA9B4IxoDVajX3/Pz28marJOsCR +IsSsC62pF1966ZUXX6AGaxs9rOQ5MJ4BgNoZ5rSPDfuu7k/WiJoL/5M3MesNoNNuf+Xzrr1tdvYz +DzywFmkgen6QlggzjJmu+PF1/pnJh7FEAUZtTM7UTOD8FuJH20ee7PZtyKvZtvN2fPsvfFd3IcuL +fkaZEhYQk4e3qEW0wKYIihDNMiQVSAIeAgQBJDJDM0AABUvyfyNGREUozZyx1gJVHp9EUE51Ra5c +P5vx/Zl+HIsVtm/f/hsf+A/v/Rc/fPttdw13XdUq+KT357gOz8+3Ly3flP4DoBlQsPd+77sWFhY2 +Njag4QVZ3ymKGEL49V//bTM2q2RlkGRjfryekXyZm6GaEoJKAQCrq6t33HHHpZdeGmOcLPKkY8nM +IhJjTCNBAODo0aO333776PquxHzAXVZjEGNG3/9PF68iarJkeFLaMWtzd+aGa6/evbiw0RtAuehj +ZSQz/FUdi98n4/jGkj9OJga4Sdxf/ziRD8RYIOK1F++fn5m+6a67ix49WvR382BGInMoZ1X68XX+ +GcyHxsjMzUcGTAQxzm8x/kxqlvGOq8bjja5fBZjfve3tP/dDPI1FMQjcEivSZhWjGCMJJW9PS/2a +aFrNaREo225hWOzF4UU8ufSjJYN3qKZ7lS2+yQ+o9AStr/c0VHeMaIWbyUAdIyIiM5tZt9v9j//h +33zn//Peu++6b1hNs9R+fPb9ObkG6efbU8MP1TuGCIR4yYHzXvOar+n1ein4a0b/SfwzOzvzF3/x +V5/81GcAeOJ73vf/M5Knejxg2WCUfrzjjjuOHDkyPT3dbrcXFxdTtYeo3giePHlyfn5+cXHx+PHj +S0tL8/Pzd955ZzNVKKM6ydvaBU5LB7b59c2P11PMm4maLAGf0CCt9vTM4suec8Xc1NR6vzd08W+q +ferY31SHv8hjDb2lZQSNFwDSJnH0+87MNnWUGs8Dcij2Li7ecPXVH/3s3TGHIznuCflM2Rbsx9f5 +ZzR/xibgsTRibDHM+a3Dj0auo2ssm24fmsMapdXtvvkHvx/bM3EwYDZDVDSIhgEUADEqsBAgmAIr +qgFZ9cVuAoAAhGoAyZTDgA2kul6nTgCAUtCj5Ro/AVC1/J/GBgMCEodK9lN+X0y6hTTzgbo7MN1p +tVo/9/6feOd3fO/RI8cb65FDLdDZ9ydMfCn5+fYl5ivj/7rK+a3/9JtbrdZgMIgxplAv/Z0OKzM/ +/PDDv/ALvwLAyd3K1NLRrDxAff8/A/nhTVNNsIrXbrjhhte+9rU333zzH/3RH3W73WYp7/Tp0z/4 +gz/41re+dXp6em1t7UMf+tD3fd/3NfVgQ3VHLOpxI+l8KOdJ+/7/cvGp63cJ+ETMpNWZnl94yWWX +tTlb3+inlRystD4GilBdpVNZD9HA1KyehkqNIF7rUnFq8Kiv82AIhFXUX+YDVroAYXXZHn5N1O5A +Zog4gDjb7b78qitu+tznBOhIgbs5nxVJthN+fJ1/xvJhLHtoahvqNGKsiOD8luInm4DPzA+nfQGA +gSqGb/zeH5zZfUHR73FoQamsRgikGpWQiMQKQjAyQSMoq1OYRvoyqCIBkFRpgKU1/zS7Ha1+V6k/ +mMr5wMn+BxEoSf+xNIhL02Dr1aLJVf9NtUCqmh7fuXPH+372x7/n3T+0vr7eSHLG9XZn2z8Afr49 +FXyVYiGAmRoyLsxP33DDK1U1aULqhX8AIKITJ06sr6//zM/8/MpKX82SBdAwlyuXmX3/PwP52gUI +UqNQ+t38oR/6ofe9730i8ra3ve05z3nOd33Xd83PzxdFkWXZ8vLyL/7iL77nPe9JNYG5ubn3vOc9 +27Zte9vb3lYn+cMF3XygpmicDMR8/3+ZeTONMV/G7IS2pN3pzs696JJLAlIvH5R1Y7Dqul8t/lfL +Oc1GgDiUBaVgvVw0EkzhOw2v+2X1uFxGssrlotFcvLlhaHOOWBHjVKv1koMH//6++8XgaATifNoE +yxHkfnydfybyYxMW029FY+5GY/FjbD3Y+S3Cj+ghk/f2GXmopf9iKgqveNPbdx68Nu+RxrbGtsWW +FC2JLY3tqJlYS4wNM0OOgIqoSEKohEZoCMDJ2KdKKBDSzC9sSjeR0gJ/I5RHQLJSJ4rVU/V0MWja +/kxqhceeaj6uqldeefkP/eD3hpBJ9dkRntT+HK7++/n2peaTNWR9fiaV1/XXP3dubq7X66Xl/1oC +tLGxcddddx07duzXfu237r33UbPGOT465sL3/zOUr+NysDTKY+fOnT/wAz9Q//J+67d+66WXXrq8 +vNzr9ZaXly+++OJ3vOMdqf5z6NChfr+fmDe/+c2T2X6UnBDLUoOfD19eXkVE4jqGEzGTrBM6M8+/ +aD8a9AaDoiiKWOSxiDEWsciLvCiKQZHnRbrleSwG+SDPizzP8zwvBoOYD2KeS17EPC/yfszzPB/k +eV7kMc/zPBZ5MciLIi+K9KIYi6Kx/TwWg5jnMUqUGGOMMf3r5f2iSI+mZ4ui2Oj324FfsP8iaHWl +1TlcZH0kEWnsCj8fnH9m8cOm4FHJ8nhKMfZK57cYD6Mro0/Mm9lVL/6qq1/1+tgHiy2JIUoWpa3S +kdiS2FZti2ZimRgX0DIOSiSMQiSBIpowCqERIpfT1gmQEJPAB4e6fyMDxeFCTuoE5qGUpwz509Jv +6e6n2rT9GYsD0rOTqQIRqepXf/Wr3/It3zg2dOYJ9+doJuXn2xfAm6k2vkfN1Ewa9xXq0lI1tdlE +XvnKr6jTNjMriuL06dP33HPPLbfcIiJ/8MH/+YlP3QFIkgRnKdSjEUvBxvXUj9czjK+OV1L5f9VX +fdX27dtvv/32P/mTPzl16tT09PQ3fdM3AUAIAQBe/vKXz87Omtmf//mf/+Ef/uG3f/u333vvvQDw +9re/ffISV8RCzSbOB9//TzlvpgDaRzxaBGl3sdW99sLzCWGQ5zGmKDuF6EVMwXdRxKIo8rwo8kGe +xzyXWGjMiyIfFPl6Plju50v9/HQ/P93Pl/vF8mCwkedFnmvMizgoUiaQgv/GBofbzwspJJbpRV4U +hUQps42ikBiLxk1ilBg3BnknC1dfsA+oJZ3OY0UWGU3FTPz4Ov8M5OvS+VgOMfLizZIM57cUP1IF +2JwvlftllDYzu/0r3vRdMSJEUgkmLY2ZxUxi0JilP6ItkUyspcACLMjKpARKaIGVCBiMwAiBEBiB +AdBq508rCwJQmgXBsBU4ecBgahoon6KxUL4O/ZtaoMlnxxxC0/13vesdl116URV9VqbkZ98/I1UA +P9+emG/G+sPMs1yU3fzHah9bCHjNNc8BgPX19WPHjj3wwAO33HLLTTfddPz48b179/7X//rfP/ax +mylNkUtjpcvt29gGq8TDj9czh7fRIgACwPOf//z777//ox/96H333ffTP/3TAHDdtdcCQJYxAOzf +vx8AHn300ZtvvvngwYP9fv/9738/AFxzzTWtVmtMAlTk/XL7Zo0TzPf/U8ubqanmYI8XHDvTxq3L +9+5pEW0MBlFiEWMeYxHjoMhTKaCIxSAWRVHksShiYVLkebHWz4+vD1YHRYB4XsuumpYXz8dXLcqr +FuUl83plV7exDGJxspev94sY85QtFLGIRTGIxaDIBzEv6sg+FkVRDGKRx6KQmMciL4p+LNI7yWPM +Y0w/1n8kxvXBYKbVunjPLoMQW93HcpJ0JWsswfr54PwzhA9jIuaJwcL1i4c+o85vQb5ZBTg7bwBi +cMObv5tCW6Iws6laDIikwCmWByhSSK4BFXNDEDBCJBAkFFACIDABRAY0SJp+qGYAA0FSbadlOkCu +l/nr+Z1Vp+9IZA+bmf+M+YGeSRHUFAJlWfb93//ud7/7h/Miju/Pyf3TEBKMWCr5+bbp+ZO+KYdO +/CPmPEjYNOlvJgaNPgubnu18+tOfvuOOz6ysLJ86dcrMdu3adcUVVzz22OM/9uM/c/LkCgBpU0cG +ZT8p0mhjd2UDb2pU2nr48Xp6+abHCyIjALRardOnT997770HDx78sz/7s0ceeXj7jh0AEKPW+fyp +kyc++clPnDhx4tChQ0VRAMD8/Pzu3bsfffTR5uVNVeo8nrQ63xh8/z+1vKqYHpVQtKYMed+2HdNZ +1s9zRBAwtMr5B0wAQE2TT4QZAQxU+9GmA144hVfM0YGubWOZY22RUVXFUQNF6hueLOjeDfyH0/Lg +uiLAdCA1rIfCJAdgqNqF0yVhzCiqSNPgq5uUH88ISpOMPsTFbnfHtm0nTp3sc/uE0U7oM2R+Pjj/ +TONDA1IzOPMraUzt4PyW4mE8ct2cByRRueQ5119w+fNjHDCyQVLtoMa0aF8uuUql1hFEIkBEwYIA +EaIyKJgaKaiV1/nS3KGcAabIRGaohgYKKGoIKkAMZlzZgEIygyz7ABAbw97ruL/p/wMTbcFNI6A6 +MUhCoKuuuuI1r7nhj//4z0pb8rPsT0ITg9GWAz/fJnmVs0X2peETQDmo1Uy1sRI8LH4aMu7Yvu30 +6dMPPfTweeft3b9//759+44dO/ZrH/jPt992F1GGGCqjWYXKJ0RrT8Fq0KzpSFtwXQ3z4/V08tUc +gDoHAIDHH398586dH/zgB6+4/PI777zzU7fcqr2NfQDPu2LqH+7M77jtDgAgDn/6px+5eP89Dzz4 +0Bvf8Iak9Ju0AVXJwRSGEw+HHeG+/58i3kzVdBnDOrYNWzOz89unOoO8qBL/ssdXzBhBy1pzcpyz +POreDr9wO109A/s6MkUFGVg1EIaIkcr4HhHmwPa09Tmz9JXb+bNr/JEj8falfIowYzIFo+QSAWUZ +2aqVpuaXoFUfJXkENRtIrDSYS5vYPT213OsVPTvd15lOpxv7tSmQnw/OP0P40Lj00ejsGxibGzw2 +cMf5rcSfJXKt1+PSort2p6a/5k3vMskZGQhACZAMkJTMUEsrhrQ0QzFdqc0gQwJUiooQQZGVTAWI +GAhQNck0EBBJIILmOfQKHCiooaEaCaNSgJBBSzAT6HYoowCAyGwGCoqGoy3Em7h/bqoLqhf+sdFL +oKrf8z3f+ambbz1y+Hg5o8BocizASO1kmEX4+TYxwMs2C/oR0hIvpTW2UfduorJLs9o+AgAwAkC/ +13/FK15x3XXXra6u3Xb7Hf/lv/zeQw89RiHLsrYBiBgiMoIhM6X2QwCT0lcKy1wWuTwTGkHn8J37 +9eHp4auTRM24yvtuvfXW/fv3X3fdtR/5yJ9liL1P/qdXX3nqM7//gu7s9rW1wQMP3f3Yn79vascr +u1PzDzz4EABcdtllAHD61KkjR45MLnAk6RmQATZdZX3/PyV8Mv0sGE8M2DptzFp7Z6YKKUSttm0o +LxAAAgZqaooGjLYc5WXbWt9+Pk1ZjmCmZEbAxFRNgymnPyJSuRiUin3bMnt1R1+42P7oifB7D22c +7BVTGaVOMihXhahepkqr/MNMgCZVsYaAo48jAZw3M/PwYGCdzuOD3sUtJrXGpcPPB+effj7AZiOC +JwaXQvWgjo0cc34L8DAaHA8bSsrL2dD3E0T11a/9lmxqKkqRusyRGMQAGAgxAiILIAJXJVZUIAVQ +pJghJoc3FERlVgFlM1FgJiDQAgYDW12La33KFQTACACBAxIZMVHUaEUhFvKiPyharX6r1Z6amup0 +OjRUeQ+NgGp/z7GUYKwloDkNoMl3u93v+Z7v+NEfff9wCwYGk/tnbFg9+PnW5FUER7pvMSVqUJXv +iYGAAJWIWhlrmhIUBVKNSKna86VmmwmOHD313d/9Lw3s5KklQuSQZa0OcenCSlQPglCJ0m5xu9XO +Wlk+iIPBoNfPA5IBpLwRABvNoGVyUn1Gvz582fmGB2jZcAPwN3/zN6dOnfwPv/xrb3/9V77vm4sX +XPsQX/Gd7b0vBmrR0uOXb/+bVvu2tc/9yu+9e/dv/Un45CH+p297OwDcfscdk1eA+lRqZOuADL7/ +nzLeDO1YbEmrY5Ttnp5G0VysXv43MDRKhp5pPAyYGZiY9Yv4wm1T24Os9DQLARGJiRGIiBiJCKm0 +hca6Ryw5/QOqwSzrG8+nF+5c/Lk7lj9zcmOmlamVkyaqr4BhExkAgAkgWITmnPDSKs8qMVB6FQEY +tIHmp2eWV5Yjt04o7LKNMSGQnw/OP738UAK06UjhCRU4Ob/l+LEWgLHXNsu4APOLi5dd/aJYDIgI +TAzTUN8AamAMjCBIQABiYIJtBIpAhChIhKSBkFExKhRCIEiCEgDFbGOpWD9tGz0qIhohkJWrO4SI +QElmhMN5v2YQo4j08jxvtVrT09PT09MhjFj+JXFwigDGpEH1mn3S/IxVCWpT+Zdc/6KLD+x74P5H +YKhAH9+3tQQIKpt6P99q3kxLnf1Q2Z+ss4GYCHXnjoWXvexFL3jBcy+++KLdu3en+ZpFURw+fOTB +Bx/89Kdv/8Qnb02afkvBQSkO4dNL6wiQZe3ATMxgSkQIKCgAunf3zuc//7qrr7nq4CUHdu3a1W63 +syyLMfb7/aNHj372s/fc9Hef+NSnbt/YyEWhFo/BqBHWE45k9+P7peXrs6Wp/0HEPM9//Kfe/29/ ++N1/8ENz5121U/e+A6hr64cALDBMXfLibGaue9GLv+HSn/vqV/YPn7i6+/gHT8YX/M6v/QpM3MxM +TcqjjSPqL9//X3LeDERkg8N6ESxrZ53OVMYDjdRcULFU7zFMIz7MDBTActUZtANTXOR5RsyEzISM +RMyMiEghZQCQSgGAiEO/6HQNx0Lt0p2LU7wyKCLFmEeb6maA2PjWw7H3D1VTQXkmxiGS6oQGaXo9 +CspCK6y2OlrAUi9f6LY6IgZDIZCfD84/vXxodg/A5suTYyUG57cYP1rrnHhtw449xudf//LQapkU +YGyoZmlqF5ilwaoBJEk4GQABy1GcEdMQplKur4yCkEMRCBRgY73YOJbnSwCRkCAEUiRAAg7IRCEg +MVFAAM4CERMnC1CFcuyXpVmwg8Fgdna2HhE61gMw2QfcrADUmUDylKwfz7LsDd/w2l/4dx+wieC+ +sX/4TBnUFj/f6iX/9N2J5X+BmALD9ddf+63/9Fue+9zrWq3WZKC2Y8eOa665+vWvf12v17vlllv/ ++//44O233S0KmLq/ETEpbk2JmAgRyEAvvHDvK17+0htueMX+iy4KWVZvLUYpYkHM3enpSy45ePDg +wde97utWVlb+7M//+nd/94OHD580QwVTsXpGkKkBbVJa9eP7FPKN/u8kAaqGhsMd/+vXD132u/uv +7tq2t2D/8wgFICV/WEKAFTbtmcXOzvUD538yrn1ycAzec8MFH/3b7OhGMSECUjUjFSAanp++/58S +3gzh6ICs0wamhSxT1bSYXk7z1Ur0D2YmZW+OKoGtxPiChfbeFsqGhcCESOlXnYmZiBCZ0hDIcqkI +Ry7vyey10+aH1uTmw0sci4uv2jc33b35Uw9g4FabzUBlKDsUs6YmFEZW/EuFoAqIGKfrDaQedV7s +ZCeLgXXaRyNcgJEJ/Hxw/hnCh7HZYGN3apVeY5qd81uLHxM2mm7CiykBdKc6z33hKzUOAoKpKREC +p8ItqBpT0nGDMCAAkCGoBQKQ1KRrgEAFIIIRExMVFjeWBoMjA+hbiwIFULVAxK1MAJfWNk4vryyt +ra+trkcRQJrqdhYXF+bm5nfs3LF927YQstTkl8L3fr+fZrjMzMzURp9jY4A27Qpo6oLSpuo0QES+ +8itv+N3f+9Djjx8j4rPsz6YEyM+3xlWpDKaJS9FiCPTc5172gz/wniTUVtV+vx9CaOZpooqIKjLI +i0679YpXfMX117/o3nvv++AH//BTN9+6vtbnLJXakQDU5PwL9rzy5S991atesX///uQNr6obGxtl +n0GlCjA1AIugqhpFFhYWvuWb3/z1r/3a3//9P/jN3/y9vABgMCttgmq/Kb+efPl4GqqAqIroDOCC +2dYHvn/vgavv0c71OLgLLC8HAGKl35DjsPG3xDm0YO3YdL+3sOPyx64hPbA4dXRjuaE0BwDI817W +6iKhmpESEtRGQH68voS8mcYoK6EVqW2WtdudNlJM6/sEACAKZbu/GYCCmYgAKKgJWC/Pn79tfgpt +DZCIOMX96Q8hBSYmQGBmpGQUXY6hT7N7yUBUpqam7nhk6ejy2nnzU2/6phfHudbCefO3f/y+xw6f +ztpZyFi1XAbSuhEBqt4QxHTlMACNAASMuH3b1Ppa3o9KTAigJh1mztpSWE/jeitMR2EuU0o/H5x/ +evkw+mKoc4jm5iZzCOe3Dj8qAUIAa/b+Jp6QJMYXvujFrfaUaEQiQ2MgK8u1bGaWzNOUgEHTpF8h +AFBCIlTgNAYYAQRAqMgLWz2+Fk8NWoatFloBwDTF7Y1e/ulb7/3cA488+vjxldX1GGOt4E1herud +LSzOX7z/omuvvfraa6/udLoikpqNVXVlZaUoioWFhUlhT1PoP1YWqJf8VVW1OW/PWq3WN73x63/l +V397uD9hdH8Cj5ZT/HyjYUaUgjkuF/67bf6X//K73vCGbwAAkaS7gMkKAKf8jUK3E8xgkOdgcNVV +V/7Ij/yrU6dO33nnnXff/bljx46r6oFL9n/Fy156ySWXJO2Qqg4Gg6Tp4RDKOQBVbpZaD5jZzPI8 +X1lZWVtbK4riNa/5mpe97CU/+VM/d++9jynUNkEIACpCzH49+XLxw3FvQ4k4wNe/cOfl1x6xFuDg +k6D3QbYdMEAa+odqcgr0OE5B7OORz55vli2efxgQjh8PnzuyAaPRPwD0B72paTVFZFZTBkoqoOqN ++fH6UvEGAU/kYO0MOMxmmYKVF1ctD4upIYKBmhloWrVXUCGzFthzFtogkjExldE/l6kAcSAiQkYg +KKdIVraeBGBgaACKQvypQ6ekKM7ft7Bn18Ln105c/ILzdl28/fOffvieTz90/NSaAoSMOVkJEagA +IYglqViSJAEztjqtqcVWa7H7khc95/5bH77t9kPd6RYYGGAwm+lkyxIty05EncYcII239PPB+aeZ +D2OJwlDotllz8ITAyPlnP4+jsewkbwCq0ulkL33FV5tEJkxumQCGCGbJTMMMCMwAM7AIQmiMiCgI +yIBgSgooiGjExHnf8hPLuhrbHNK3Qmsqs5782Uc/9alP333q9HpUYyLOsizrIEJlIYMGJqJHjywd +OXzilltu37V75w2vevkrX/ly5lBXA3q9npnNz89nDRHImRb+mw2CaeG/Xv5PHYSq+tVffePv/O6H +Ti+tUPKs2Wx/jgtJt/D5lmb31sFc2vHEvGfPwi//x5+7+OKLRQRxrDYzqdWuDxwQBjAoimhmi4sL +r3rVK1/+8q8AAGZOcX+eF3meIyV7WExZKZgRlX5/zbh/aWlpY2MjxoiIWZZNT08DwL59+37pP/7b +n/iJn/3ox2+rzgqExqAAv558GfhJLWLKBD9/ZOXYofPb8zC3awnwFMgp4GqTBNgBAFh+fOHUod3b +Ljo8v29FAwDB4UN8SuLkqbW6fGJxYbciowknn4yG9MiP15eEBwBTXeeWYAsoZO0WIxZgI43YZX3O +VK3KAtIwAFsv5KIuXzydSRwwMzMyExFxSEUA5EDAhMhIhJQKRkO/fzQzgw7hyR5++vGTUOQHLzmP +p9q8QdOZ8bbWVTdceuFz9h6678hj9x89fnh5bX1QRDXV0mmMiZm7bW7PdLKZVjbX4bmWdbKp+dmc +W8dOrQGapL4v0lwhA6IsU5NBUeTtTicWZTXCzwfnn1Y+jCUKT7K5zfktxI+K10f4xlL3hRddkLXn +xACSVhIVkABFzVJkbspAYAhgjECgZpExEIgCEAQwzBRQAXPT4kTP1mMra0cQZss64e7b7//T/+8T +h48sEVLIsm7q80JseDETULk4G1pg0jaLRw4f/93f+9BNN33iTW/6xmuvvaYoooiEEHq9nqpu27Yt +hDA5EGCyKyCF+ykHaCYD6fFWq/Wc51z28Zv+4az7E5588+iz+3wrq+hqVQM3EtPBS/b+xq//0uzs +bIwxxeJw1ptqatXDClQiSkckxqiqqpYX0cw4dQUSIaAaQDlyrhr1QESIeZ4vLy9vbPRijMyUZdnU +1FRzQESe52r2Ez/xoz/6Yz/5sY/fBoD1vLAx8aUf36eOTx6diVLTgKRiAPDnd6999JPxFS+eXltd +2HnRo62ulBoSwWI99FbnVk8shE5+wQvuDfMGCvkJWDl07W/+qVaLFCOnVlFs9AcbU90ZUFQ0KsdN +2Jj9qx+v/xveLArYyQIsBENuh1BY2e1bzuUoq3NVKqCl7AYUGLCvds227raAg1xDSGJ/5BA4y0II +wISkiIAUjQsgAYyAhUEEFAQxADGZDp27HuN7Tq512njJZVNix1q0jthm4owh7Fnobpvbd/X+jaX1 +lZPLy6dW+v3C1HIRyAK02DLOGQZoMQQNnJsudKd6p1ePHl0CQlEFSkUoIMQOhw1kC9mJQs5DYz8f +nH8G8MMm4DpRGOsSmAhinN9i/BnVLMP0wMyuue6FRGwq5ZAeNDMlIga1Ul6R/NsU0BSoNGsRgzTk +N6IaIGaaQ3/5JKxq1uqKxQAKqB/+Xx/91Mc+IwKddoeIUtkBEQIHYiaESs9TVmZVFYIBZCHLVOXR +Rw//6q/+5td8zatf//rXEpGIEFFa611YWEiLxGNNwE230HrVv/l3rQhK91/1yq/4+E23QC1Q2GyG +mp9vI3YEtX0T0/4Ld/3mb/zy9PS0mRGzqmltv4kwFNw0VUBJjm+lY4eZpsQtNQCnRcFm20VZ/q9l +JIAhcBRZX19fXV0t8pyZW63W1NSwR7yZhBARmvX7/R/70R/+jne958GHjjXsaNCvJ18eviq5VGNH +ANRi+g3940cvf8GrLgob/+XEYxdLoUhqBkBEQdrTg91XPtxejBCgfxIO33XwtLylfcnXveyf3Pfb +f/m2TTPN48ceueCCKwCNy/6Q4YXQj9f/PZ+EPDG0Bj2yjKmVMVJhmia9lLN1y3F8SSWKQITlRYFM +zRReuG06mOUh46zFgZiALKe4qrqGvG60AWEDsYdWABRIUVGQIU2UTBkF4va///y8rMv2/XzBhQ/1 +8r8n6hlkiETcyWwKsgWYXuD2dHvbtvliZ6+QQV70i3wQi14R86ggymIRTMBUdb7VOf3I0Y2NQbvb +kZS6KACBgDETZsE0rkXWNlNUA5tQD/r54/yXlT9jE/BYGjFZxHd+i/CjkauN+WWkvuBOu3Xp5deB +GVkZAKMhIJRNUpguhKDlZk2VEAxIxBiNUzMAImCk/tKqrgwybkmMFIJa8aH/+j8/e8u97Xa70w4A +hAREnIUQWsGkVIXWC/NE1G5lpioKRVGoGFPgTsjz/H/98UeOHz/+bd/2rcnMBwDW19eZeX5+fmz5 +v/67HhSaYv30Y3PtX0TS31dffdX8/Mzq8mrTM3xyN9p4JrC1zjczGQZSYGBAgbdvm/7AB/79zMxM +2WynWoX1qJpqPMPI3UaCbqwTgHReVcqcYa/16I/pDOGU/p08ubS+vm4A7VarOzeHiCIybgk/Oig6 +yYre/74ff+tbvzsq1soQv558+c+fdFAklhqe6T0Xt176U72P4/n7frmzk2MPgDW0DELlwpXB0v1w ++ti78ZrvJgiFDG581cvf8pa3/t7v/e7kKIB8sLqyenJ+dochKiKIMRMAppYPP17/t7yagi5FMm4B +cQiZghmiNBN9S0ZACMCa5gETQARCKwx2dLLnbJ+VYkD5hg2OKawArRqvWaePHWEQbBG2EANQhhgI +CYAZyxV5MIWMdOX07McPEWh+6cGpxe3Zyb51A0RbRxgg9CBsCES2wDBLOke6nWV7K2wDnEFsE7YC +5gA5gppYNOu2Wh2gBx47WTYsW92jbmCa+hIE2DCsU2fW1pmDnw/OP718GMseMPm8jOqHxooIzm8p +frIJeKQoD6Bm+/efPzU9VxRG9dz1xminaq6iJcmOqRCBQQRjonSZJ1AC4rixoUvLbGBIDG0Q/eP/ +/of3fua+TrcTQgBDIsxarSxjERn0B6pGiGJQ+u8ggGhRFETUamXdblvFeoMczVrtNhb4d3//aTN4 ++9vfVsd2a2trIYSpqammtqeeDJB+HOv6ba4Qa3XrdrtXXHbgkzffTmfbn6XlzRY+3xqW/4hMlDH+ +7M/8yI4dO0TEEFUMTJGSzUbpu2dJa4NVZ2BpZQCmw0E9dRN48xBBc5oPABESUb/fX1pa7vV6WRam +p6eZuRZ3jcX6tfoLGpMfEGnnzp3Ts93l5X59kvv15MvAWzreYCJGCEjAhGv99XSMFmam9u2eW7nx +pw79RbGr+MDcAUjDmNLflsPRz3R7+P49r/nOVifMnjhx6PHDeV68453v/NCHPpjn+SZFgKMPTnfn +kBlNEDm9CyQ0Exwm+X68viiewACXc7N2QM4QKTZzdksLSJDaw6qFk1RINhRcV3jurO1YuXfj+GMY +NqA9oC7RDFEbaSpwm6CdUQuoDRgMM0NWIMA0ODq1pRl0QnbPva3PnMohwFVXLLTbFHqdEFqFDAjb +JF3EGcQNhJ7asmTLhT2MimLtqAuCOw13Iy5k3FW1QJLHwWynoxvF0WPLxKF0CMbhZU/NmINkwSwe +H8RZTp+K/Xxw/mnkR7KB2tB92KYzHIAy0Ybl/NbgJ+cAjPNm11z7PFAgMiYjtECABsl/OSBmCMGA +ERiMQQMpg5JFRmGLDJEgkgnFXJdOZJIzIBkGav3N//6T++/8XKfdCSEAEGdharpLBL3+oN/Lwcoe +UqZKTZIkO0hq0OsNer0Bks1OTxGzAWRZlmWtT37q1g996H8llXla419ZWcnzfEzkk5b2k5o8RYfp +kTroF5H0bHpcVa+//oUp0Nx0fw7Xobfq+ZYE3JX4J8Vw+ta3vv6FL3zhYDAwM40CpslXz9TM6u2X +tfSyeVgBNIGG5b+OqiMzm5unLQKEwCGEwSA/fPjw448/bqaLiwtzc3OpbaCZ3Y0leHUSKCIiMjs7 ++9hjj735zf9seXmj0iX79eTLyGsS/wx/m06fPl42aRQFAFA72/N1/+7U4Dcf/sR1S5+Hlcfg1H30 ++G2XP3TrP9M9H9lz4/eYFb219ZnZ+b17zusP+pdccuDbv/2dMGEHnN7CY4fvMxNTLdesG9PH/Hh9 +0Xy6DgwoU2MkhiykqHx4jUxNY0iUwnbgZLhpgAIoBAp0bWu5feqemC9xS0O3w9Nt6mbUCdQG6Bi1 +DduKbcWOUEuxDdg2bAO0ANtAHYSOZdnUpx+Cft8W5unyy+bBNAudjNst7rao3ebQ4tDCdidrd7Ks +E1qdrNvOOi2GEE4g3RnpLwv6SAE3KT+AuA5G8+3ZpeNLa2sDDiH1H4BhcsCoquWIxEAUFSIFU9PS +l8LPH+efHj7UPXWjkuXxlGJMP+T8FuOHum0rIy1FIEACUA5h//6DiMqgaekfwZjAgEqXDiyLuamg +C4aGyohgAkgIpkZAkPfWWvkyIhpg4M5nb735zk/f0mq1mYMBZhl3O+3BIC9EQTFkARrVrBH3ntQs +xmwAvY08ZDIzPbWx0YtRsiwg2F/91ccuvHDfS15y/WAwIKLBYLC+vj43NxfjuCWINW5jq/4pIqzv +A8DBgwfarayI0YBgYn+OZlJb8XxrjnE1Awp04fk73vWud6oqc6YaGyWmsmZUebmb6TBCMwQoV+vL +gooZIjKAEtX+PIZEYEZERNTr9U+fPtXr9brd7o4dO1IfSF3qafZ2j2UCzQRgcXHx5n+45Yd+8F8P +8lL7BsMyl19Pnlp+7PqjZgERoFhePpWyuAsuuFDV4iDnLOx8+bf1T3zd2uOf0XyNZ3a1LrhoZnFn +6HDRWwFAQBwM+jMzUwvzc/3e4B/94zf/xm/+RrFZEaAYrJ86cWT7jr0AQJxV/cfDIoAfry+OV4jr +0LEQDImYpS7WIVTdHYhMpWWngSkIAagaIQgi4QtmBmYcppBbRC3ATLGN1EFsGbWAO4AZYKbYAgyA +WWWEmDzHDAA1X+5+6iEAw/0Xts4/f8Y0dkJHLCIwIWJlTwZimqnYQJSEUTIQyyRkYqbWz+XBKA/2 +tQthTxtefPTIaVMkZgUkZGDUMvwCSAInZkA2DD2GUCQVkJ8Pzj9tfG3IPZZDjF98J5IM57cUP1IF +aPKi1u225+YWCIRRCZXAUvGT0JgE0JAsMBAk838jNAYLYIxKJgQSQEly6J9uYR4otgNsrJ66+WN/ +hUBEARA58PRUt9cf5LkyUtXfCVjpRIZiDBgu5aEBIsVCNjY2ZmamiAkMmTNV/fCHP3Ly5ClmTrLv +9fX1wWAwpu+vb82WX6luTSBVA+bn52ZmptXsbPuzUYnbUudb40QyRGBCRvjn//yd3W5XVavov9pD +jVxOTQAMUdPKv5kgGDLViURp7odWS4PKGTtIzFlRxCNHjj7++GMAsGvXrtnZWQAYa+2YdHqtb+n4 +xhjn5uY+8YlP/uAP/L9FYYDD2qmplZGFX0+eMr5ZpEmlIEYkxEcfuT/58L7+9a9/5zvfubK6oggS +Jd9YyuZn5q551cLzXz972QvbOxbVeoP1VTUTFVVRsyLGmZnZvCgOXHzJW9761jMUAeDUqUf6vXU1 +MxO15O2YvKfUj9cXyxswL+VmISAFQKprK4TASKmFPyABUmEQEQtEAELEAJQDHWzJgXavMAkt4Ay5 +DdRBaiO2DFtGbYDMMC38Z4ZtoMwoJQYZYADIoNMNh492bj5qgHbFVdML8100zrgTuJ1xi6nTok5G +nYxaAVpt6nZCaGfQyiCwBbYsWMbAxIGyjNuI/U7riPY/c+TYYeAMEAMxMQMFAiQkIpJyZYqRgwVa +jVStCPn54PzTxlNzKM8Zqgk0sgbj/Jbkm1WABq8IsLCwkIWAyduflFkZLcmBmIHZmIxRmSyYBjTG +6kfSjJRBA4oM1lq6GlgDaYvtHz7xNysrK61WmwIi0PRUu9cfSJQQqJJU1u+wzkqGWvCG3QsgUoyy +tr4+Mz2VxsKHVuvw0RN//ud/Wa/1FkWRjEGbkp6xZKAWBRVFEWMcw1SVmXfv3g7l1MjG/mwIRXCk +QreVzje10UoSHLz0ghtueGUSX400mVgV2huAQdlCXsWASJQmA1UtvyngrwcIJaE/hhAI4dSpk4cO +PVoU+c6duxYWFpor/WPKn2YdqZkDpGxhZmbm/vs//2M//n5RUiAzbMwxQL8+fLnOH6vOIgOytbUT +p04dNbNOp/PTP/0zSBhjAaqqYgbFYFCsrxTrS0VvLQ4GmtwCRCz9IotIjITYyjJVed3Xv27slGje +Hnv8cxoLUzWzuuTTOJ/9eH1hvIgasQoAEHDZliuldo+JmZAAqAAqAJUYIM35QkJkxGj0wunBNuwJ +AmWELaAMKAPMDFtALcQglNb+W4BtpMywhZABZgBtxDZCy9rc+cyD4eEeTE/T5VcsdLIOU5Zxu0Xt +jNotbhG1M+pk1GmFNlMro3bGkLG1GVusASEQZAiBgQkIYaG9uL7EK8tIGRdIEViRCZkoALAgl57H +gYAQkNcLocCm5ueD808j36wL6FlfSRNPOb+FeBiPXMvmYFO74Py9jMAoCMZgjMosgZVJCZVRGIwI +iJQo9QkopZ5gS1UCQ1OKaxkUTNYKsHz62P33fY45IyIT6nRbojoYFMghDWAvdcCWCgBVGmBDx8eh +9UvykSSKhUQpup2WqTFRIL7lltuOHTtWu/30er3mwnBzvT/F/enWlP2kH1MNIUWW+/btLcXoMOJ3 +ORl0brnzrdEUTgjM9Na3vCnLsjKKHy7+D52/02JhygQQ0AwNSNVQFazMCBANQRGUiFNPCDEz0/ra +2sMPP7Kysrxt27YdO3YQYYyxNndqtnc3o/+xCkACQgj9fv///dc/M8jFDJLxfNNkza8PTylfu38m +UFQAIMb+5++/M63Z//iP//hll1+2srKqCqKW/qiBGqph/cjwqfKOigoxDQb5Vc+56sorn3OmIoBK +ceTow6JRJCbTMQCrEz8/Xl8Qb6aEUFBQQCCGugsRMSJF4hwwB8qJBJGQCNP/ECwN7ENEesF0D1WB +kAIgG2SQDH+QgQJg+sMAZBQMs+QFROkOBKW22WD6E/ezCe7eHS67ZBsBM4WAgSkLmDFlLc6YskDt +QFmgLKN2i7NWgCxAxhQYMgZiDQQBtRV4NptaOmomWUbEFDCwIBWIBVIMZEiEnIzuIH0XGkvIAMo2 +AD9/nH9a+Ob6Lo1CeuYcwvmtxm8SuWq16n7wkouRlAkDK5ERJamPEhqnJQ8yRiMEJgsEgSwjC2yB +jMACGGjO1ueARJAx3X//PRvrg8ABiEJGWeB+L89CoNLJ3cCwjP4NCJCZQhaydhZCwNTWOe4bb4jY +2xi0220ODIBZli0trd1yy61p+V9V+/3+YDCoY/1moF8URQr3qwlTIwv/9eQpM7v00gPEeCb1VGPG +8NY6f1Rk6MePhEiLizM33PDKSoVfBv6NI5YW/5PBZ5kapH+0XP0HrCLv1JFJBsBMgUlFDh8+cvjw +4U6nvWfPnk6nU4f+0GjqSGlbM/ofK/uUCjeRTqfzS7/0n44cPm2Kao10Ts2vD0813+j9TZ24xkhg +8vn7bktHbefO3W9445vWVtcQMeXsKW1Pd1Rl0wdV02+3gYGpzM3OvfrGV8OZb+trx1dXTyff0UoI +VEb/fry+CL5nnKQyyJzke4BMzIYExICESIzEREwU0ixfIiY2oN1Bruis5IVw0v9kCAGMTYNpBpqJ +tcHaAB3ANkBAJAA2CIABKAAFytp4+njnk4cAmQ4caO/dtaBKGbczzjLKmDPGwBQCZgGzQK2MMqaM +MQSCQJCifybIiAIRonVabei3Th4npACB06QaBiJiIwIgIAZmIgZi5ACKgNQD1mFblJ8/zj8NPE28 +slYIjb+4shF1fgvyOFEBAEICM2bau3cPohArkwVWRmCsrpIMhBoYOGjGxmQBjUDTHU7NAAygRSBh +ZmYyk/vuexCZOTAotrIwGAzS0gkCqll5L7UZEAHA6lrv+LGThx49cuLEqcGgT4RDDUkZPSIAmlme +D7qdjqghERHd8Zk7B4OBiMQoRVH0+7060G/emrqguiZQP5LiyxRT7t27m4YDxZrhyzCw3YrnD9W2 +PGn1VF98/XNnZ2d7vZ4apFX40aVXLLVAVsbsUDlypkNbpxNWTnsCJiCi1dXVhx9+eDDo7969e2Fx +IR2sZojfsAmCScOfVMZpSv+npqbuvvuev/jLj6uiJGMircVI5a+FXx+eSj7ZRiUDKAMwNTl69KGi +yNPe/5a3fPPi4kK/31dVkfJP837K5ZsPVtm95XlRtpsDXH/99XDW27Ej9xd5vyEEQj9eXxyvYOsC +FgiJy7bcNMcr/UYZIlBAYmZAIqIq28eMoA90ZTvfQ71cAJEUQdlCB7tdnmuFOQrz0plZa02vtLor +oTNgRoIuQoeIk5+QKkuLw+cf7HxuldqZXXHl7NzUHAIzZUwZYQgUAqXQPyPKmFoBOVDIqMVIgStp +K5biH0SbbU/313BjNQuBEUIpZAqMwEycuhcQCZiJCChgOzPmnlJywPDzx/mniw9w1pHCEypwcn7L +8ePL2DQi5maen59jBAAjwjQDGBEQCckQ1IAILYXsVup36hDZkriDsAACJkLi06dOnzx1KjADIAdE +QsmVgDQZiSIals5qzNTrD06fXqlsvDXP+6ur69NT3e3bF7HcelMOhP1BMTPTYkIzI6KjR04eOXJ0 +584dZmpm/f6g3e6UohTVcuTBWHSoKqO9Ac07MzMzgTlGqdsPSvWCDNVJW/B8a8DJHJZe87VfBQBp +6C+UI12hYZxtw0wAhw+nI19tXxAZiQCBiUT0yJEjyysrC/Pzc3PzZipRkqC/jumbdxoJrY21Atf5 +QHKF+p3f+R9mQ7fQRjLj14enlk/PlxmXmYKB6fraqRMnHqvztxtuePVgkKtKFipDlVQcHD3EEzpG +U7B8MEBEZM7z4sorr5qfn19eXj5TAmBmjz1+70UXXc0GihmV5to4Wkj34/uEvBBTr1AI6VpQ9v2m +6B/LMX0pXi4TdWIAVTQIiNHwBa21rJ/3AWdncHYOQsD+aTr6WHZijU5u8EpOEqFFtq1T7JnVvbvz ++QuL7FKQfWQtxWhIEgYz/3Bftiy8ZyG78opt7awj0kewCBDITJUpmKqQBI2KgbDFWBCFLGS5DgJj +QCBSQmIEYmjT1LGTJIMsZIzEysGQAAkIDZEQoqXhOWhgjCEiA2FfAJLVmZ8/zj9N/HAW3eTQoskS +Z3OWmPNbhW9+CzYWs5MEqEXQYmJK8szS9RMBkAyBku1BmupESbZjBkRDr5fkEGpKgQExY37s8cN5 +IRxaBsDV0E2oR+8goIEZhECDQTx54lQUrcYMGyECyPrGuprt2rUjmck3yxexiGCWhZAXBRLnRfHI +I4/u2LFdYlSzfr8/NTU1DBpSXFj9XI4BbsT+QzEJ1Kb1RoRpDzb2J58pg9oi59twELIBEkxPt6+9 +9hozA0MzJSDbVHwN2FQGlYcy+f6Ui4KQov+NjY3Dh4+o6q5du6a63Shx2Ek8Ees379RDHqohX9g0 +fZqamjp06NAtt96pAmLJjtCas1OqJRa/nnzp+bHwW8HMtMg3Hnnk7vrRffsuOHjw0jzPzTSFjel8 +MRjp6h49f8oTqigKBU3VQpG4c+eOF7zgBX/1V381ORW4vhWD9VOnDm/fvg9NFJgU62aA0uXWj+8T +8aZG7aA5ABEkqxwgoLQygGlFKTn+gAGVqzhIhGhkpnMkL11YXpjSmYxWYvaxB7u3n+p+Zq31QJ8f +K2wAoGBASEgt5h1oB6h4Ybd/w56V5163PvsSixcrt2H98em/fyhDon3n28UX7EAITKQWWM1QGYOh +CjErSylGCoSBjBgD44BLGT+lCkAnZBS7qycCYkaUlvlZiQ2AicQACIOqGooZologLBg468ccEGG4 +7uDnj/Nfbp7GVEBjd5o17uqVzm9Fvlr+bKjHEACAQ5YKm8zAZATABMRAaBwgMGRkgSELxAEDU8iI +A3CAEIACcgAmJTIkYuIQsqPHT5oiIzICEamoVs4wgGUjIDEC4NLSUpQI5Tim1GWVROG0vrG+srxC +RFatJisYAIqhmTFTeoGqPfbY42BWxKiqRZHnRS6VJChKVFGRGKXs/ytlBFFSFWAoGVdTEYnCxCEL +ZtYw4h3dn6NKqq1w/jR0UMkfli44f8/MzEyv10uSnmSxmAQ/qpstvZparUNDLAVAiIjARKdOnXro +oYeYad++87qdjojUwqGmlH9soO/Y2v9YHSDldSGEj3704xrL7Q3Pf7VG769fH55KvhzCZSoCqo88 +fE+zneZFL3rhtm3bVAUA87wQEVFpenY1h/qVabupiqauHioHHaIZtFrtyy+/As7QB1zfTp14ZDDY +SBsFsDQnfXQ8oh/fs/OgSKaIHJCzqsRHCEjEGYeU2ZcNAIhESICswAgKOIvSnac7+tt+/nP7v+22 +S95x33k/f2zmz1fskRizNsx3aXuXt7dpBqMN1g5vbHwsp3+X73j7owff++EDf/FLi4M/5O5pfuxQ +59ZTWSujSy/r7F7cZopEgYgorewjETKVjQeBIRAxIzOFUsRDlprZCEExdrKpwSqvnQohMHNGFBiJ +mUPIIDkSpC0xM6VZlQQcAEmRMbCp/747/7TxYWyCQJ1DNDc3mUM4v3V4m1iUbfAWMg4hMCESpUs5 +pf8jE2FVDSit2pEALaUOVEVxJGZMiJghAgVeW1tPy3IKiAQaLU0UtuT3Q2CAjDQoisEgT++fG+9f +DAiBkNfWN+bn5xBQ1bAU5hujxRiJMJkKIuDS0lIdH5S6EU5CXyv7jUsjGlNN/zEDA4OGFCgFjqpm +iJgFboYQZorAo+WULXb+mKTWXwAjRCC4/PKDRBSjcAAzIERATHu1WvIb6ZhoruCaARECGBOZ2aHH +Hjt58uTOHTu2b9+eIr/6lc01/qb5z2Qm0BSKNGc+qOotn/5M3YMw/LyEfn14SvnmBUdNzBQJTp58 +vCg2mhej5z7veSFjwDROEGKUpB6pJkJs4vSqWv5CYzmiMF1UUDR+3Wtf+9/+239dXV1tFOs2qQYc +PvzA/v1XM4OakSLSsAjgx/cJeTUr/X84pDgfDBEpfYUAEpebQzQgMDMjRCQkRUIYUHjPZw+c7OVL +EqdZdy10pua3L+zcO7dj1+zitrnZmU4ntLNgMe+tL5849PAj99778MOPrubxf88u/PXJ7a/9w9Pf +98iR27Pu45BNdYsrLpudas8WhRIQIBkZG6sKIjGyYPleKt0iolJa+cJ0liEGgkBTJ06RFZ2QBeAA +HASZkdIigZnFtNgERtUZiEjGmRUIFADyurzt54/zX2Y+jAqGoKloHH1QNxMYOf/s53E0lm02l4DB +VKcdAiEhMVLp0obIXIo4K2EQlvXd9KVLKYuw8r5yck0AIwpFUaRsgbEa2giV5Wf57g0JB72BqjRi +Ma2TAQNQ0xhFVaGcE5bsPkABDIyQwYAQBGEwyEVFJQKAmMUiB8hAksG8GmAZ8tswF0hG4wZgKlUG +YFYZuoVWliYFNQtwo4WUrXa+NWxzCAnh0ssOJFWXallHslrYA7D5Cmy1wdRmEpjzPH/44YfXNzb2 +7ds3PzrFeUzoX6/rNxf4x9b7J6VBU1NTRVEcOnRYAZPnqKml022y0urXky8hb6ZpV6eqUWIHg/Xj +Rx8aOymuuuqq1EVUZ2Up8cNxE7CxvpK0ijEkkLnf67/oxS/6/T/4g2/8hm9IPUVE1JwV3RACra6u +npqf3Q5sgNnY1v34np0nxIZEPjX+ElVfF4GonMFryJgcnonT+QBgABSLJdXOwvyBxT3d3Rcu7tq7 +sG3bwkx3Yaoz2+HpNs12wlQ767RCe6pDjHlv4/DDD/7D3/3dxz72yRMrGx+a3/3pz24zgGmk7dvh +OQd3E2UAA0QEI0RJC/9aRviV1xgiGqUyBRMjaqLRjDlg7K6dzMxagRk4ADIRKxAQKqAiBLBClcC0 +1DopCiGxWfII8uuD80/f7+NoojBSNRiNXSbnCzi/NfhR8XrNlyNvkz1boIDEgTjjEDggBgIKTBlz +4CxwCMwhcAghC1mgLAshcAiUtSgLlHw8Q5ZxYKhME2wkGMRqtFd6FA2sXFWeeP8IQOXCc6k7T4F/ +JSHhVPZPdXtVVYnJ8iU5v2gsKtlP8vyJmgwEyxHAUTUpfvJ6plB61lTNpNJ04pnmqW2586dqoygL +OyYXXXhhpQ4qbf8RAFSxXCOcCNwwNYyXQVtgXl/f+Nzn7t3Y2LjooovmZmeb0X+zDjAi1R8N98fU +Qc0H0xY6nc7y8sr62oZKs/23/jh+fXgqecLK9zNN3CgefvAzY7qwK6+88pprrh30+8RMVAZq5RXB +TKX6E1XTr6ZBurYQIlNawa2vCcCBV1dWXvyiF/+bn//59E/s37//67/+dZsKgY4deUAsiQ+Hs4Er +Q3c/vk/AG6b5X4REiESEjERIgRmRwJABuZwlnxbhjTl5gpnO72lf/rKFF7xm7vk3zl969dzunTPT +rW6mGeasOUlBseBikMV+O1+bi72909lLn3/te9/73f/u3/zrN732Vd3exqEBLIc2QTh4kKbmpUUZ +ERvUxnJYycBKYZJVHyVlI6UpASEgGChhC2O3WGtjaFFIvqDp24yThykTIVFGgaFcJSNARIZkeMqh +GnHo1wfnnwZ+yI0mA5tI93BkBKzzW4Yfl60Ph0gDQj4okhSbAjOHpJGkFPYTBeaQBQ4hMGdZCIFC +CJyFkDKBLEs/ZVkoBZ/EnU4HqjJBteI7vp6nqu12Z+RtIzS7MxEghKzRFAhmkNbtA5OZVL2AFgJX +QbylMUEiUaSQGGMRpUj6f5FYiESVqFKoRBExsWQtqEOPcZEosYhNC6DJ25Y7f2qja7B0QHft2llW +VJK3S93gAWZDnSI0Zz0jIBEaQAi8tLR89913qcrFF1+cRP9jHv/NOkBT2NN8vOn3P/aqlGm02+2V +lWW1xvQGHfk4fn14Kvhh3q6Y6mpIcOTwA6qSIrMQQjoi73nvv9ixY7uIJNsYM0sd+1mWTXW7c7Mz +8/Nz2xbnF7ctzM/PzU5Pd9otIqqxMvxE5Cp5CCEsryy/4Q1vfOlLXwoADzzwgIj86I/+2GRXgGqx +unxKRM2kLkFWJ4Yf37PzRsQAjBSS9L7UyCMBIAFlXMbNGTMDclnhQTNpT8/uu+4V2y+6bGb7IrZJ +SLEstKYWgnLVvmzRTRPETK2/Af2NKy+98Ed/8Hv+409//7UHzpOo7Q4/+jj/9O99/I9v+0uBfjdr +Y1rSqgpKUNlJDR2lhhcCSDVhQts2M8t5a2O9y4EBGSkwBa57BogZidM7CaH6bmRERGIwSuJZvz44 +/3TxdJamz2Ya0XjW+a3Mj9qqqBUxAmAK/9OVu4r3Q8hCCIEDh8Ahy9KPWcZZloWMqwdCq92qngoh +hOnpaaCh7hsZRxoQsLwCd9pZlgXAyfefOgG0020DgjT8JNO7Z+ZYGguCKnQ7bdNqFV9VpNByvm9U +jSp5FfSLRtFYVDMAoqqYRJVoEs1UTQAsSqw8SWHT3WjjmcDWOX/S+r1lgRcWFkTUUlqGAGgK1fK/ +avp+xRErxzT0zbLAp06duueeu7MsO3DgQJZlKfqfbPZtJgDNib/N4sBkN3A90C0FmnleQHMEHuH4 ++e/Xhy89n8osmuQ8qrq6enJ19UQCLrnkkoMHD5rZ9S956Wte85q1tTVmVlMz6Ha727dv27Nnz77z +zjtvz+5du3bu3LF927Zt27dt27lj++7du/bu3XPe3r27d++an59jzrSyGa3/IJIadKemvuNd3wkA +zPynf/p/Hnzo4Z993/thojn42LEHVWJqUK6lSirix/eJ+PQrRJC09WmeDBKkEd4MDIhY6j+hMR9E +Nc4s7pqbm0FUKad5jCu8GvNEbLjoQISIg41+v7dx4w0vvuGGl69tDDjDY0c6n7/pwE/92oM/9ft/ +dMuDdygOulmLkFJVp7xclPZukMaVpIs8k7YYp9utqdA9eXT16CMD0y4HZgrEBMypkThlmEjESJzK +BsRQeh4RpDLIaLXTrw/Of5n58ewBy5krI3rlsSKC81uKn2gCbvCEyfOeAyEnowOmLCRroKT5yUJG +nOL7rNXKhrdUAmhlWStrZa1UNiDCvXt3I7AhpMAwEA9d4Kv/mgEgLG7bhhQAS4twsOH7b2etxYV5 +UyOsJSWmABlTloVYxKQ8IYJtiwsSI5iqCqpBNClERSxF9moiKjFaGiaalvxFQDUNGIVqzqiJgEgs +ihhtOCtqwooL65XkrXO+Nb7lEJCYEFFVqpV+K4dBGJgqEuqI5Lo830wty7Jjx47fddfdnU7nwIED +zJyGOTSD+E1LAWMR/5j5T/NOzaSFOjVDItvs/fj14angR1bZq6Ts8UOfS4+0Wp0bXv3qz3/+8wDw +z//5d8/MzIgqAs5Mz+zZs3v3rp3z87PtdhsRxExqyZ5IjFFUASAEnup2t29bPG/v7h3bt2dZK+Wl +SeaNiEzU7/W+4uVfcfGBAyLCzP/1//fbZvqe97x3zFDYTNZWT5tWHUCweXXIj+8EXxp8pv4wIq5k +pGlUF5UPlV5AIzH+3LbduYg2tl+miVAuJpRVRAMzVANN3xNl0zcy0ecfXbrp1nvbIQTCHXOwlnP3 ++P6/+ZPFH/7l297/wY987HN3ruSr7VaYnmp3WlmLOUMMAUPATsbddtZpdQmner25w0dmbr+t+/G/ +3P6JP738wbv3cYuJA4SAFJAYmJECEQfkDJmQGZnLZmIGREJO9XMR9euD808jH5rZQKWmGLYRjPUU +b2Y76vyznJ+cA9BgQKKYGTFTOcOlnONCRBy4NAOqvDnq1ipABFPC0o4za7Vk0E8qoP37L2q3Q4wK +iKqKVH8LpAlgVme23U5rcXFxeWlJRjPgVha279yOCFWtPy39goG22x0DKGJEMP3/s3fmcXZUVeI/ +596qekvv3Uk6CwnZQyAkYRVkTwBXcANRcRB0hAH9zYgKuIyOMooKIzg6gogCLggIuKGIhEDAhR2y +AAlkIfvenV7fUlX3nN8ft151vaU7UVHS9HmfwOd1vW/dd1/dW7fu2Q0pVO3to8MwIGNCMmnXY+sr +DtHTg0seRGAzy1NUyRIqcsoQ2wjXwA/CMIydkcrDbmKXlhE23yKph1EjA6NCpZQp5VnC6PoyI1sv +n1gwGAgCB/A8d/v2HatWrWxobJw6bZrd/ce6/+T2vWKvD+XpgJLlwCpOTwYKI6LWOp3yoFR8IA5L +RRumKOvDP4AHYiiZWZgNAO/avTke0w996Lydu3YGQXDSSScvWLCwt7c3k041NzWl02kGMMaAwdiB +I54ekUxob2uI9p+osL6uLpvJ9Pb19fb2cclAhYhhGIxqG33WWWddc/XV9qu//rWv3Xnnz++++64t +W7Yk96O7d29obGrVSgFotnXBiOMsCTK+NXkAUEw2ia9CpaIwAIWI2maQs0me7cZegSK7lTdeKl3X +1Nrhh0rZ5EBMZKtzsN3rW+cuIquqtwOuiIEYGMAQo3I279i5afPGHKc+dXz3BW8/9rrf9N6yeF3Q +n8lsmvzgpt6HH1k9ZcqaQ6e3TD+gdVRzJu0BARdD7ivSnj7T0W227qRtO9K7dzr9Hdlif4Ph5vqM +p1xE5ZDWjnJAKQatlQJEILAGaofZ2AriiFEpFIUIjAqBqMJJQ9YH4f+ZfCwAVCRfK23+yptLBhEL +P5L4AS8IKwOU/MmQiPL5YnNzs9KOAlRaaa3ROjtaP0ylSoKErd0UP6QVok0Kip7r+EFk9R0/fnxr +a9O2bR2ua+OMldbahIRRDeHI69M68TTWZ1Mpt7+3P18ohiZMe+l0OtVQXweIHDl7cLyvIIZsXTbX +n2fDoJCBGxuzo9tawyAgYGRAABMSk31kxP4eDPb5gSUrMzMxIwLbpEKRoMFMkM/1G2YAJGaNUB50 +jyN4/sT5c2INPZXSfdrLBRoRGDhK98oqUqYiAHuet3XrthdXrmxsqJ8xfbpT2v1XbO4rnH8GkwQq +PH9sfbeaxoGmpubK/sfxDLI+vNp85MttI3+ZACD0i12dWy0wZfKUOXPm/Md//DsAXHzxxalUSmvd +2tqiEEsh4JF+gCPXESwL/+AByRIA2JDdhDY2NHie17WnyzBHeV5RE5kTTjjxmquvJiKlVHd396pV +K//lvPO+/rWvlfubBblcb319K2omZpu+IC7HI+Nbk2cgBYwA1k8fUAFgpPtHVKg0xOmXrWsWAQAH +YeOYdvSyfr6oU47N4FxKwGYNPlHBEcNggA2xYSBbPY7QIIACArVqzYY9Xb2tWVg4r6v9oJlfnZA7 +85iG7/56w++f2x0Gqazf/sqO8KUn8ir1ilfHqTSkUmCIiwXwi2CKnilkQ5MmTiudGtOgDmrp35Dn +Hqp3tHa0C+hEUb72F2iFdkIQaWZWGokAlQHWhCEorSAuES/rg/CvCe/EFYPL5YaykxNpREH4kcZX +CgFMNneb/cgPwu07dk04YIJWCrXWiNaXUymtMSr2HtV4RAUKrUo19vC0mrd0JpsvFu0WOZvNzpg+ +ddv2Drv9Dvwgk0n39fVXmCKs5tgwuY7T0trciogK2DDZ6r2lbhNHYS6GKe156XRq1649oKyHAU0c +N1Y7niHDbKzRwoQGgK2UwWyVOCYqPmWYbRZnBUzRTsMwRbUcGQBx6/adZEKlXYWJnSLogetZHqAz +YubPgPe8NRkNXAtmxsgWFBsKknF4Kc/bsWPn888/X1eXnTFjhi7f/VckaqzW5Vd4+VeEBSf/rOCN +MWPHtqdSbpgLK+ZeLaWdrCd/L18qGDcQNLK7YyuUkvF/4Nxz//KXPwPAaaeffuJJJxFRa0szMIdE +pXstytOLiY0+QOWRitrAQRh6rtvS0rxnT5cV+5VWvh/MmjVr/PjxW7dutfPhvvvu+7d/u7haIdKx +e1t9fXOptGA8gUHGdzCeGDxg6+OPYF1hlI4K7qIGtAbbqGg8g1W1EFBza7vPYIzR7FhNjGEICUIi +IiQGq7oJjQkNGlKhocCQ0gqRkJRC6CuEz69c1VfEeeP2TDvwwDDIGs1vPHr84bMzT6zY9as/7lry +fM+67RRQVhUzxS7oiTMUMAJq7aimjDOh2cwdk5vXvu2w9p0NGf8n64786crWtIOMDmiHUQPG4WbI +wFaGJGv3sDWqrY0A0QWlyFC584asD8L/M3knUcMcBrFGxcHFA3mahR9pfNIKkOCJiVevWXf00Ueg +itLxaV0qf2i9JZRNomYrqcRt6HgfjwhKKcdxwzC0wsIRRxz27LPLczlfO9pG57qu40fG3yjFDkeV +ASJbMCJCWFL/lbT1AGwdCqwz6JgxbXs6u5kYFYRkPNedOm0qARjDwOB5GkCHDBBlfbeZpynWI5f0 +UmBMnLCS7Q7XaqKUVute2QgDpRKiC8jEZS7kI2z+xJWAUSMzkOF8Pp9OZ0tmFgCy18wWAlMlFw7r +9u3t3t2xdOlzjuPOmjXL87wKR3+oiuutVvzHocAV+/5qUSH+0xjT359raGgYM6Zt/cZdik1ouOQQ +h7I+/GP4CDFkEMGYoGvPNjtko0ePHj9+/FVXfRUALrzwwvq6eqWxlEgKDFG5d36NjX7yTyrnjSHH +cRoa6nt6+6ybojFhS2vr3Hnztm6N7A8PPfTQJz/5yYkTJ27atCl5dxeL3SY0jqeJQZFGBcmiYDK+ +1bxCpCBwkRlBwcDu31b/tWY2ZgA0NnGzQiRjXNdpaB61p1jUAEDErIEMsApYhQAhQcAUkgqJQ+bQ +cBCyo8hR5GgMERjI0XrH7q61a9cxukdM7mkd88aiMQAmH2ZUWp10bOqEwxo2b+1+/uXuVRtz67b5 +nb1hGBAwa6TmLLU3+Ae25qe09U5s7mzJdKe9PiL/qR3HdcIEVIiOGyUvtU5MgPbhYHMTARmlFBCC +QmAAMjaA2dNMhTCRPErWB+H/2byTjBhghsHPVMk9jfAjja+KFRk4vmXrVuvyg6i0Vo7jxLt/RCiZ +ABTawsBo0z5EOjv7JFbaqaur6+3ttdq+yZMPnDL1wBXPv6wZAKBQ8LPZNBkyplRuM9b4QSnBPw/E +BlivcruNVwgEzMCjR7f6QdDbn+Nos0Gjx4wZM3ZiGEZOPKi8kKx7abRO2x0qE5VSD5UkAECKqoMR +IlIpBJmJN2/eTmwrPqoyvylTmYxyxM03FUUDB0HY2dHZNmq0jdwDiARDZgDkkoc2MIPrOt09Pc88 +8zQRzZ59UDabNcYopSq0+xU7/urMnvGVj719krr/uA5AaTtomDkIgnw+19LSfNBBMzZu2kWAqpSx +g4lBlRlYZX34+/lYcLOV+5ipv6/bmgeZ+cwz37Fx40ZmfsOxxx57zLEArJVDAz5+A2Weh5AESkNc +gzeGvVQq5Qc2hRcCpDxv5syZ9//+9xYIw7CvP3f44Ydv2rSpwuJULOYdz0vaiGR8h+BRgWJKaywa +AIJSrV2lSvFhDNbEipHVUCGHVF/X6Kbrcr1FdNwoyJcBmHziouGMhoAgMBwaMkb5ihxjnBBRhUoB +oMPE5Om1r2zeubsjrfENswAyEykoKCAEJlD9fj2AHj/BnXRA6q1Bb1jo8wv5MOhjU1SQc3VOq16t +u8gEgW9CH4zvdHXV7ciNWtvppBxAdFA5gAjoRBUr2bHFxxGsSYiUMjYCgoAUIDBkNDIRk0qajGT+ +CP/P5JPbu4pgHao+s3wrKPzI4WvsXImjwuhbtuywhk7HcbR2lNZRRWCtUWntOEo51hCgdZQoKIoR +0LYCjELEbDbruq6NHnZdd+GCkxrqM4aMzf9Y8IvZuqxSaAvJY+xKMyAKlLxySlo/m2TOeue3tjSl +U96unR1AgAqITSrlzZl/NDrpwGBAmjGFTqMBN2BtGAMDoUFDGBokQENoCMKQjGFDQIaNlSoYyRAQ +MjExBKHZ3dGldRQCXO09lVBJjrD5Q2xjpwFAabWnq8s6/MfnMcdVowEBiFgpVSgUnn76qVwuN2vW +rObmJmsgqpiNsU43KRIka4HVTPlvSjWbYjEgVvxbIAiiveBJJx2PSLFXWBwMIOvDq8+XVYDjzo6t +8R/HHHPM448/DgBnnnFGa5uN7ye2KXi4RhkHWwqsYtCH5slQyvPs+gMASqkJ4yckb9uOjt3TZ8yo +9gLy/bxNA0rM5VliZXxr8khhWKeRALRSClCjRkTHeohG1x+hpCRCABOalpbRATthSDYlpzEGDAFx +SBQQ+4YCIt+QTxwY8g35hovGBCEXAir4YTEwhcCsfGlNby6Y1NQ/b8YoggamAjMBG2Bfc05DMTDQ +73t5zgZuVjVk0y11mVFeqtWDBsdknYJOFTltjMMBoAn6io078m27+nXKc8g+xpRjn2o2/I2VQoWA +CpWteayjB54NRiFMI7GR9UT415KvzsIWh6VXnhynERV+5PFJvRqV5pey6rqO3V19/TntOKUqJ6XN +PdqgAFRaaUc72rFmAdtgqQwnWxEglfIymYyVDJh5xozpbzz2SGBkIkQOA1MoFusb6rWjo0I+CZWb +3fpHdaRKun9iMMQAMHpUW102s3XrztAwKCBDTDx56szxE6YWQwjZDUJUqWajswG5odEBuQZcQzok +bViHIZBBMsisQgI2EBqbbsLuMmwGIETE7q7uXC4fOx8nvV/K/MdH4PxRCBDlkyXDGzZswrKEqKUA +zJJu1boCPPvMsx27d0+dOm3MmDFhaJRS1Xn9qzZ5bIxJpvqpcPqvSPdZU06wx4vFYrFYPO64Y5ub +6pXWA6UpyIaCk6wPrzKvrCDNbIwJg0Kh1w5TQ0NDW1vbE088DgDHHnMskymlh7JjaicAlxLBJ3fh +HM+LfeDZui7Gz8iWlpbkBMvn82PGjIGqggCFQl9pPSz9wkRJYBnfaj4MKe3YSm8EDEopx8Yv6sgB +kJHRetLbJAEIza2jckUfrZmVODIYErOhvKEiUWDYJ/JDKhryQyoGphBQMaSibwpFExB3dOVeXrO6 +wN68CZ0Txk/yAwAOiHwwRTA54AJQAbmgIae4oCAADimq9RgCB0gFZUIIQyDDFFAIPX7b5r76vgAd +7SjtYKTMskn/NaLSqAA12sRmaEUaVAqBAYEBKQsGoor0sj4I/9rwA+tdzZLCFSfHbkbCjyC+Uo2t +kn8AYNH3N2zc6Ggb2oR2A4cl1x8bDmDdPCNDb8Iij6hKOzSsr693HKckHuDpp586Y+aBIRExKMTA +D3P5fF1dNpNNKUSrzys51uNAd6wjBzEzZzOpiQe0K4TNW3eYkFBZ/1Ezqn3MvGNOCkCF7ASk2Kln +r61IaZ+8gFMBeQE5AbghOSFpAjcEFbIKGRl0CIpBMSljmAwSoTFMDAy4dfuOICRUKlE7UkEidQxE +WalH2Pyh8hmk9IaNmwAgDE10XmlLZf3FiNl13eefX/HK+vXjx4+fPPnAMAyTUb/V6v+kQjfpAVK9 +v0+KCtVyQlI37Pt+R0dHfX396aefYhV5UU1qhYlqALI+vLp8lGqpWMjFwNSpUwvFQqFQmDJlypSp +U8LQWDfxOLuP/X88C+yb+F9pMuydt52JF6hMNpu0APhFP+V51RaAIPArysNFu1gZ30F4hSrLPoZG +2TpdNjmcisqBgVIKtQ0bA0RDVFdXl8k29eUK2iZhMIaNASKb5ScgKhguGPYNFwwVQmsBoHxg8r7J +hybvh76BTZu3b962FRz1hpl+qmGCCfoU5RXlgHOKC0B55jxCHrnIXAAuIhcQCgAF5AJwgSlgw2AM +h6yIi77b6Y9a05lWqNh22O7+S0n/Qeko/x2Wkh3Z/6NGZgWsmZTJQxT0JOuD8K8Nr6pNA8kdXvLk +0nvhRxifNMwnN3MRz2FITzzxjNIlzx6tlYq9e1QpOxUmtlhsK71Ez3trESVyHCebzcZHstns2We9 +64DxY8gQMStEE1Bfb79Cp76+rr4+6zjaeupHql9iBiZmR2FDXWb82FGjRrV0dnZt297BhkEBEBlD +Dc0Nx566MFWXNUAGkEBjtt049Qa8EFM+pALwQvAMeyE7oXFCdgw5IbvGaGOUMWhIGVYEDhESI4Ni +Bga14sWX48uDVdezpgQ1IuZPQv4hYiZat+4VY6JYDS4JcFiyRqZTqbVr165YsaKpqXHmzJlxta+K +rX919a6KXX7sz5Pc3A99MBkZbIzp6+sjoo985Ly6rGN/TVzzNXEvyHry9/KJ/D8MYAAhn++JmdbW +Ns/1AGDOoYc2NTXbpJ/JMs/VgR/VGV33kbeG89L6k0nOt1GjRvX29lULACEZa2wgTiQolvEdhLcG +YB0WXQgQAIk1KNDKan0Ml6rEWHc7VGyopbEF0C36AQIgMzIzARGBYQ6NNQLkDRVDLoRUDKgQcj4o +yQAB5XxT9GHduvV7+vItXv6ogzKg6oC6mPLIOaYccwG5oLgAVAAuABcBCgBF5CJTjqGAnIcwpCBg +w2QIKegrNOwsjtrU43ieRnRAoUJHaa1QRRZwrW3FE0CllP11CkrpsMFAFon9PHG1C4esD8L/83g1 +WOngxO0avx8IIhZ+pPGlzVwFb3P84LPPrigWi0priFZvBLDigIpj5koO3giAFY4Z8TM4k8mkUqm4 +iM/48WM/8IGzx48fE4SGiG0N4P7+XF9/Dhjq6+paWpubGusbGrINDXVNTXUtzU3to1vHtLdlsune +3r4tW3b09uTtwkshGUNNrfUnvn1B67hWA0XQQACcbeG61gDcInoBpANIh5gKOOOzF0AqwFRAbmAc +Q5rACVkTO0TKkCJSxNoYJFJMTj5XXLPmFRsAQAyDXs8aj8ORMd+ii8IAsGnT9kIxn055EE0ItGIA +M7ue19nZ8dRTTwPgwQcfnEqlKjwuam7+4t1/Ut+ftA/Ee/rkKTVrCCTFiUKhsG3bttbW1g9+8GwA +1ipKXmVTVdp8L7I+vAq8LS8YCYoKAHK5AQFAO7qtrQ0Apk2dmvI8Q0SRyQ3i/9sjNd/E7/fKExPG +W1SElJdKmpUmT5686qVVUBWC4tja1QgqtmPJ+A7Jo4KwkKvXwGRKNhr72EAdVYwEVFFkMClsbR3V +nw/IEBJF0VeGKDSGCA0BkW/CnKGcMUXDObvvD6ngm2JIuWKYC6mvUFz7ypqccWa1902fNNoPQsV9 +CFb9n0fKMfcD5YBzTDmEHHKBKc+UB8gj59gUOTRgGMLA2h96guZNfY17itrRCpRS2rHVf1E7oDQr +BUprbd2BFETuQIhKGTvZiOqUMYGvNcp8EP415FX5yQOORMnmqmUI4UcOX+7AgRW8zdO8a2fn2rVr +begvc+TDk/T4T+6ukkeS4gEza62bmppc142fspMmTfzQh943a8aBiBiE0caLiPr68909vd3dfflC +kUuyQdEvdnf37NzRuWv3nt7+fBiScpAJjCFU3D6h5fSzTxw3aRSjD05A6GPWc1vb2FFGKVJOiG6I +ng+pANwAUwGnDbgheAZSht2APMOOIR2yS+wYUgYUgUOsAZ1Nmzd39+QQ4+iIQa5nmVveiJg/Cc8Z +sM4bXV09O3fscFynVFg68p9WSlEYPvbYY93dXQcdNKutrS3O2FhTp1utvq329on5uMTvYLUCqvd2 +RNTT09PT03P++f8y+6ApUY1rtL+Fkw7fsp78XXzCRmSva7GYi1eJXH9/a1sbAIwbN147Oto1ltz4 +S3t7W6UP0DpVl44k/z80r1ARUWSajOoVDmQRHT16dGtr65NPPFE9SbSb0snfW14rXca3Fo9M1Ohx +EBhkJibrMxqryaP/aw2Anus01DX35oq2/C8yoCEgAwS2+hcYAsP5kPpC7g9NIaRcSHnf5ELKBaYQ +mKKBPZ1dW7ZtCbR3zJT+1tZRJuy1+36gHJs+oBxSniHyAgLOM+eRc8D9yHk2BQ6IQptjiCEMggB7 +wlEbuutCRkfbvBeO0hpUFO+rbDyzUqgU68i1KfqBDLZgQb3js6nxPJX1Qfh/Jq/KHYYGHIlqBhNU +ORgJ//rnsZb9KJpVUbwmFvxgyZI/2b2ULvkCVWhtkw615WmFMKnZdRynsbFRax1/Om7cuAsu+OAJ +Jx7dUJcyZIhIRVZ6MMb4xaCvP9fd09/X19/Xl/f9kMgmwEKlgAwzmXRaHzpv0jvOOXFMewuwr7SP +WFQZnRrTptIOKzYaSWmjnFC5pLwAUiGnQvAC8kK2TkEpAx6BZ9A14ASkQ3ANa8PagDKMzy5bTqV4 +BJT5U5MveV0bwqVLV1jHnrgaMDCnPO+555aue+WVcePGHXjg5DAMbdmvmqV8Kyp81fTmj4/HkcHV +RoOKxiuEDd/3d+7cqbW+5ur/rq93FQ4k7YgqgikbjiLj+3fyXHJKRYVgTBiPyPr165ubmyZNmtTQ +2GBFa2NHzcoBaMt/Dej7oyPlB+P3g/JMxphIxgO0j0YAcF0XAN75rnf19PSsXr0aShFKcb9TXgpU +4veWBQDI+NbmjYEM5ZQJFJChkg8gWhMzgg0BRmUYmhuaXDfdUwoAACIgBiIgwyGRMRwSGOIwzIem +L+RcSPmQ+gOTC0yuaPr9MCTYvm3r7p6+jIZjDyJws2y6mHJA/UD9CHmGfqZ+5BxyDjgHlAfqB+5j +7mWTgyBgP+Ag5CCkwCgTForZ3YXW9V3plKNBKdQalFX8a0CNqEFZGcbKkgqVIkA7ddkwIGgKVL6r +PHJE1gfhXwO+UlBIckMEEwg/gvhy5/UqXgGARnzyqWXFYjGp2k962SaTZ8d/VmRiKeXkNqlUqqmp +Ka75ysz19fVvfcvp537wrNmzp6XTnq0OFkXv2YqSiMSRttnm4zOhIUOug5MPbHvHW448deHhDdkU +kq/YRy46GVU/rsWr16ADdAldYI1Go1E6AB0qL0AvAC/ETACpMAoMcAPwQk4ZcAg9Ak3sEDhhqP0g +XP3yWo269O01ryeM9PkWp/AnePKpZ5jIWLdvBADwvNSmzZueefaZTDpz8CGH2LrSyW263cQnNfrx +C2rVAaiO661pN6hZTCDe5xlj+vv7N27cOH78+G/979dSaRU7iVQGN8t68jfxpZw5aCv0oQJVKhmB +CFrh1q1bt23b9tWrrrIWIUAkYyDa5A8IYok/OXGw9GcZUMUDhGbARG4TGFghxPd9x3E+/7nP79q1 +a+z48aNGjaqoIeC51ktNUWWuZBnf2rwtF8O53rQKjDHRcVSoNKAtD6ZQaUJkgLaWtmLIZIwNGLBB +wGgYjLHvKQwhNGAoCMO+wPQE1B+YfEj9AfWFps83Rd9s2byx16gprbm5U+vY+Mg9AH3Mfcz9wH1I +/Qg54H7gfuAcUw9zL3MfmDwEofF9ColDYwIDYQjG7wtbtxVGbe93Uq5CxwXlKoWgtKM0KsWICjXY +qYyolEaltFKgFDIQcxAGdToI832oBwpgy/og/GvCO3FJsHJhIDqzFMGZPC78COMTO1cEXR1cogBI +4dYt2599dukJJxxXoSGzO/hk8p8Kv6DypECIiERkZYCenh6bjp2ZXdedfdBBEycesG7tuhUrVm7c +uGVPV68JQyI2Np0fgVHABEqjp510vTNudPPcWZMmTRydqkuFaIpBoBEUgFtX57U1gaOKQV55HgMj +OMwugyJGZges4AGogBBRgUE2CFqxAQg1K2AC0AgGiBzHW/7cU939eY02iaCu3vSXOVGNvPk2UAxY +ASACw4rlKwuFQspzS4ZI7fv+X/78l/6+/mOOOaapsSl2wqkOABis1FcMJ518klr/wWIGkraF5IyN +Q4S7u7vXr18/f968b1331U9c+vl83hDYvI+cuEVkPfmr+aT/j3WsQkStUCGa6J4GAPj61666446f +9/T29Pf3Odqx+3VHV9xfWPGmVCwcq4BKnomZqLT5ZwBCBYVCAQA+8IFz3/ves//05z/t3LHzs1d8 +prWtNZ1OP/Xkk9///ve7uroQMVtXr2xN27i6ocyHvfMYBkFLQ7gzCDJEhthxFTNoBQRaIQMDKEDt +tjW17On3EaNsTcisNIAyxBgSKVYKgJk1kUYgY/qBiJ2AOcsQEjoa6/K5bTu2+piZO37nhDENftCD +7CPZm5cACNgAhMA+kA9QBMgj5dkUOQg5MBwyhwEHBkzIoTGB6g5Gre1q6CenOaWNcrRWrByFGmyq +MI7KRSIBY8kfTBEQEgMQm9A0qHwQMgCiBpkPwr+GvBMHDcTyQZX/UJnysgIT/nXPl+9cuXw3RrZi +CxOHxLfffs8xxxzteV6103/F+2R5zqQ8kDyeTqe11j09Pf39/fGuLpPOHHzw7ClTJ/d0927YsHH7 +th2de7r6+vp9P2AmrVS2LtWQzY4b0zJ+TFtDNuMqAMUUGEBGJHQh21rntjUaB4phXpPLDjBHlQQA +HGAdpZoAZSv+gkGDSjMiK0Oo7HaWQ0SNZJgZTPGRPz2iUKPGUrmoGtezwpwyEuebQhszwsC7dnW9 +/PLLc+fODcKADaXqMo8//tjatWsnTZo0ZcoUIuOVp1ysqOqajA2okApqBgDUdB+Kt/jVwkZ55DqE +Ydjd3b1u3bojjjj85h9+++P/fkXHrl4CJIrq+MTlgWU92Xe+fLvMNrm/4ziuq8aOO0B1bD/18NFB +aH77bOevfvXra6/9n8985nOdezrRTiRbvRvtADFX7b7tBp+BseaXJd4AAxFF2V2ZlZNCry7lpbbv +3HnhhRe++93v/vrXv37yyScDwNq1a7dt26a1PvnkU/7wwAM/uOmmm266KZ3JAiEDIiDTgAuQjO9Q +PDEApE0PcR2CYUPgQVQ3PlojNTDXZbKZVHbd9j02dabx3FzK7fOcfqUMMTNxoYBKaXRSrlPnOvUe +pz2nCMZn5RNkDaRTXl93Z1d/H3rucTOLbra5UOhUttJ4tIwY4JDBRzYABaYCcsDG55DYDyggCA0H +hoIAAsNB4IfZjqB1XVdGKwTtgnJAOagcjgPemJlRARACAAECKkWsAJgMMYQuFLF/VykBqMwH4V9L +3qmQHhAV2F1dwn8obqVa2hD+dc9XBQGXqiBhKXUjKFSAzC+++PIzzzx7/PHH1czckrQMJLf71fEA +9jgRua7b3NzsOE5PT08icJNdx21paa6vr581c3rg+75fDI1hMsysEDSAAlbMYEJDhg0hEjjk1Tup +URndmAkUFdh3kFhbTT7ZWrQEjMAMmkFziIAIIQACkq1MY1ApBSGwQURNBkC5rn5xxdOdnV2OdmxM +hE0Aat1dqq0lUfmrETbfEpZuBADD7CA+uHjJvPmHFYv5psb6bdu3P/7EE1qrOXMOsdljq3X/SXV+ +tct+tYt/9St2JSo3yGCFMaGm1BqGYW9v79q1aydMmHDPXT/+r//6ykNLnkDlJj2/ZT3Zdz45H5hY +aVQIytGuq9Oee8YbDv6Pc7zJR3V4bJ5bPO0L13Z/7nOfV6g+fdnl/f19QRBqR0dDU6Xk5yqdf3yk +hi1gYPcPwKzcVH7Hhv4NS824GQ2Zxje99W2XXHLxdd/636OOPLJYLDJzX1/funXr7r777ltvveWG +G27Ytbtj/SudYUnMwEorn8yH2rzSmpnCvp7mhlGFQtHRaSBQTsQYZgfZJzW+qZEJA61Uc3OXxj5j +/GIB+/Ipv+AYX5Oxi0uA6Guvw83uSNen6xpHNWYbM26eOQfQ7nL37h09rEbXhUdOA+B+pk5iXRov +Ag4BDELAHAAFNlscB4ZDw6G1ABjyAwhCCkEZygVNO/3Wzfk6z1OsHK0diJx8NABaZ0QkY4PjSGsm +AjBaad8PmEzoh82QD3K5KEFQ+b5N1gfh/8l8hWuysk8zKM/QXLPasPAjhK+uA1DNWztsENJdd/3K +ZlWv3rpVO2RX6P5jLWwsJxhjlFJ1dXWjRo2qr6/DqP4XWedPW71Hu246nclksulMNuWltHYBwRD7 +YRgSEROicdPcPMprH1vXkHVdDjUEDvpa+UoXHaeo3cD1isopaM9XXgheiA6BZkZgREJllBOCY9Ah +1IZdA44Bx0fHoBsSPf7YgwoUMysAGvx6Dmj/R+Z8I4ZS6QgEZMA//vHxfK4/nXIB4M9//tPOHTum +T58+ZsyYWPyr8N5Jpvep/miwyGCoChSu+H8836pd16plgFwut2HDhu7u7quu+vIN3/2aq7n81pD1 +ZJ94tuk3rVcYgtKoUCmtHUenU15zffZj79l+0BlrvdYuHN1/xPtW/exGffHJUz7z2c9+4j/+HwPU +1deRMaVgXeCKUCWoPIiVd6DtTxQLoLRCRGBWrlvo3tP/+IfHwLmw5ugF9TffecM1c+YepoB/97vf +PfTQQ0uWLHn22WcLhcKHPvQhQPje9TdOn3yQdhxHqVLkP8v47itPHAamWfX7QVEBh8aUEscpp1RH +Zuzotq5sqjPrduT7itu3NG7bOKFjywG5jnaTa8Gg0YGMh/UOtDg0BgsTwo7x/ZvcXWu3btr4yrbO +7r5CMSRtgj3dnTldd/DovpkTOPB3IHcBdzHvYd7D3AHUBdTNYS/4feAXuehTwadiQMUi+yH5od39 +c0gUsgmhj1s29jV1+o52NOkoCFhpJ4phAAQVBTPYIgBRDWDAMCQk4jCfCXYzldZDmQ/Cv6a8E2vW +yi2zlSJFhf+Q8COMj/euGK9cMY+2eLtSwLxs+cq1a9fOmjWrlu87Vu+9qoWB2CxgN2RRdR6lGxub +PC9VKOTy+bwxRSJDYcjMZMgYMiZkIiImY4AY2LhoHJfSHtfXeamMozwV2m2jAoc4RHIVk2YCcACA +WXMUA8jsGkYEhxEIAULFxMwKGRkQlEFCZFKArHHj2ud3bN2C2rHbEQ2DXs9ySWrkzTeFsZ83Axii +bds7ly5bdvJJJ69YsWzZ0mVNTc2zZ882xnieN1iG/ood+RBFnYwxyUDzpE8/lIekVzgFVQsJSbc0 +mxdo9+7dfX19Bx98cCrtBf1BnA5I1pN94ZkJIHKdsop/RKU1eq6TSrnpbPqMQ4pTj3me/Anofg2c +uRQ81jz/U1d/taX/01P+77vXL1+27MYf/HDWzFl7uvZoras8f0oORYDlygtOFArn5B/xecpNFzY8 +0zbqifo5H6xPH5/bdsefH/9TesycP/7pj0EwoNRQSvX1dr300qYFh2z56FHTd68ZtWyrBgrt5k/G +dx95pTUzmL7ddQ2NgV/0tAsM6GhrViYG18HNXb17dnZ7PX1pRVohZVwAz44uxI8LQFbIzKjQAWoF +auGunp7+Lf2N9c2jDlLepmK+6GSPPjDXmOV8YXepyBgBKmBiBjBMzECGDYFhNoYCg8bY1J9giAKi +kCBUJnR7oHVdT3OoHe26pB1QtuivExU4A2QAUmgXDoWKkBE4JAI2xdBv5H6/pxMVImqZD8K/5rxT +MgdUWKPKTo6zhVYDwr/u+arNF0E81RCYLK8VECH054rf/s6N//utqx3Hqblpg/JSABWuQdVYaXPG +zOR5nuPodCqdz+fz+VyxkA+KfhCGigPNIbBhMOgYB0FrTrtOygPXQa0VKCYiBaABDKB20FGKINTA +SjEAkCYd1RQmxXF+EIcVEjNbPyiEkB00iEgAhIwUFhf9/mc2YaAaCLuxjsCJ62mdksp0kCNuviHG +cymq9gkAv7jnN8ce84YlS5b09fUeddRRDQ0N8W57sFeFXr+mi39yi1/tMjSEXFpTNK2YjdYwVVdX +98ILK/t6Cwwqch+X9WQfeDImvlyI0bVzHO26TjrlZuvSh4/z3vmeJenRDro/RvdgoC5Mn0n55vrZ +7//SpTOfXNn06J/+fMIb33jzrT8644y39/T2EpFSKrl8JOJxax2xGYIrP7WVAZTpXZmqd7jhckxP +yPUe3hMet2X187/5TdDU1GwnnjFhPpdbs3YdcvDxT+DMecs+ZaZf9N0pOVK2RBUTo8JSqzIfhuax +mC+2NfVtKjR46WxoTKoUP6YA0YHdvXkNWJ9Nc3QQCEEhUCmlfrTyYlTXAQAMEAA0ImXDvr6e8JXQ +61deOmWOmlyEsGhy/ahTGFdnZ2YiYABiJgYyFNoEo4aJODBsDIUABiDUEAZFbtsRtK3tb0y5DmlH +aYdRae1gbAJCZmZFimzJQCIAZEAKQkXEfj5T3BWEHBUUlPkg/GvNO7UC16A8eqAsuFj4kcknrQA1 +eUYARq3VM0+v+M1vfvfud78DhnxVbP1rRgPHEZ9WaWdrgCKqlOcphLTrhhk/9IsU+mwCoBApVIoV +GgRWSIiMtsCnIasUVAo0MRl0EAyBo4AQAgRHG5tjQiFrYEBmNIgpDDW6mgPrqgBAzFpDyADK9bxn +Hv5Fx65tjuMCIAHrss194vokHAOwKl5n5My3hBtilL71qWdWPPDAA6+sX9/S0jJjxnSr/q/Wu1fs +0W0EcHV+z3guJT2CKoJMBjMm1AxKqbn7t+aFxsbGRx650+5luRQKLOvJ3vmBvTor1M0ZNb1djWpG +z/UKlJ3WRu948x/bZu4C+Co6k4E2ASswe1RqHgWfnHLMtf/1kYPf/82ejj2dZ555xpe+9KUrrvgM +Kszn8o6jY3muYj2B8lkEJetiFQ8IgEGnzsxEROhfN6rZOfmkY+6979GXXnoZooInEFUgALj5f+Dg +2VDshnHTukfV6y0BsS0QrWQ+7CuPqLTWpntnY1NDvlCXclImxY7j2LLKDGCXVgOgo8ps9omASiED +o1aEpTqCaA3RqIENMwBrl5o47KBc0WmY3rJ93oTOYn8XFwOIcgxZoxEBAxsGtm8MGwYKOTQcMhNx +CEwAIZABFXC/07y10LYzyKY8h7ULWqNyQSlAxVFEOisiRrK6f0bWWhWLgTFhsVhs5h7TvQuVKr9o +Mh+Ef814JxkxwAyDn6mgKsJJ+JHDQ+XOtZoHYEYEIvjBD35yzDFHTZgwfsitV9neq0ISqMgNSgRk +iNgwADMRGWLDQACslELtsg3VJUQOIx8TYGRSyEDEitEAICkCDUyImthBJGAHmBUwgIYiI0VFgpAV +eMyowLWBBoBoDAIiGwClldKdO1556pFfaOVE6v9S9s8a10chm0ol9Aicb2XJQAGZIZ/3f/Tjn02a +OH727NnZbLam102FTaCmE38cNhA7/1Sr8JMRJsmNfnLi7dUCYN/U1dVprf/y2NM2pWlpt8dDrryy +nhCZaGeMCApxzji45lOrMuN2pDPMJgjz4GYw1QaI50D6bWC2RZs0NgA7MP1OCB959zkvf+hPB/zo +iU1pz33qqac++tF/veqqqyZOnNjT06OUhrLkwhWKhqTNp3LxsYEJiAjoMBlgn8lHz/3Zj/77ezfe ++e0bfr5py25jognQUNdw8/f+7ay33GZ6t4ED2imManC39ZKiUghQlAjI2IoCMh+G4AEwKAQtjV09 +xfpUfb0JjHZcRAVKaSwlV43qb1sfQgUK7QRiRK2QAJRGRmBARgCwsViMTERGg+EAstns1k3dTmZj +tjGFXIzLNTIzMAExEzATmAAIgJgMQQjMwAbIByCggBnSPWrMhlxrUaXSrmbtMmqtFaAGVBqiNP+E +gMqGpysbykShATLs96X6NvsGSreAzAfhX3s+6aehEosmlWxuNWUI4UcaP/jOtZQMHUEpRcSACnbs +6vz2d7739a99uSr39qBiwGCSQFmlMEAmIiZiAgabCM5GBbMhYqMoWsttNmZAZmDbhM3FzAgKQRnW +aBwAAkWKDbIGIu0SoOai1SxrWx6UGdm1Widgm3QQGRQCLPnN94wJtXZK6v+SCK4Gu57JnzYS51uk +nIjS5yMTocb1r2w54vC51vvfVl21+/g4AsRW46ppCoBEgG+FCr+6SkDSL6hayIwHaIgyYXEYwJgx +Y9av37Bx41alvPLhVbKeDMWrAfctVPi+U7vGHbsp34/IrNwTlJqKRKAPgdQJYLoBDDABEwABhYgp +cj/qTbj4Mxe3P/J83fr+/qlTp0ybNv2cc875xtVXn3D88T29vY7WAz7+iape5c4+lTdjxNtEnk4d ++3sg7EVgKBTqMs6nP3fBxR89c+myl15ctb6vPz9uXNvJJx0x9sADzaZf2wxorheOaUR3p0OGFCuK +KwHKfNhHXkG+Y/uo0c3duXrtpg2x5zoAyIi2LrNSGhQiKlDICIBobI1drUChRmS0kjgohSYu88ak +mJhNnWvWBWM/tvzCc5uXLBz7l/Gj9riuBqPIWD2otQeUxAAC+zQBozgENsAGGRV7hjONWjeuybVq +L8UuonJBaULHAcWAbB2SGDQoMrG5SYVBEcKwWMiN4s6gZ49N/iPzQfj9hK+uGxyHCSdt9/FBEn5E +8smHJVXqdGHAu8NqZxylH330iSVL/qSUGtoBI35UVuy9oEa14JJrPjNHm/NoS2aLglpdf2mXFmEU +nYSR1dewMqCYFZNm0EQOGw2hxlCD7ypfa187Re0WteNrt6hdX7m+0r7WRrsMilmzm3JfevL329e/ +oFFb+7PCkpc/1ro+ydwgA0LUSJ1vpathNWEh6Uymfty4cWEY1kztnywUXZ3Zs6Y1qaazGSTy/Cil +akYC1Ao+GagnYNMNaa2bmpruuvuXSrtRFpqyMBlZT4bm2db31crJZEIoYirkVOrDXt3/eulLvMzH +MXU8UA9wDrgAnAeTByoA+2A6lTOR1AcOOnbNF86fBAB3/fzOurq6D37wgxd+9KO3335HY0MDESeW +E+v3j8k1JuGFl/zUpp9RSgPqeip2AHWDKQL44PeZPTvrMnDcgnkf/fi7L73i3Pedd+rYCePNznt0 +uBoBPIZ0Y+HoGd0pz3XdaDWII33KL4XMh0F5NpDNbdF+jwmKQdEnAqW00hq1VtoFpZV2lOOgdtHx +lOtp19Oepx1PuR47nnJS4KUwlQLHAy8Fbgq9lPLSyksrN61Tmbpsuivb/q3cWV9c9/Ffrly4YWdT +YArKySGEEBpTCEyBwgKbAlOBqYjsaw4RFWAauQEKWb2JJvxhy9zvrTh0rT865SrQLmgHtau0Bq20 +1qi1DY2jKBGQ0lqRMWEY+H4h7Xfh7rUcVR+T+SD8/sIPuADFpoEKSaJCqhB+xPGVW6XKc0u1XWzR +AAVsUGEY0te+cd3Yce0HzZq570aAmi4ZsWsGGyZmQ2QV/8DMBNYpyOpx0BZ4iYKGGTWADcuz9bmQ +EBgYtEECJmSFrAgdtDUhiRG0BgJwMJIzNCT37syAwN621cv+9NvvIypUqACJQSe2FjWuT8kFCKIy +CiN3vkVFMSNRyMZK4h/+8PB5550bJ/+pjgMeIqts2dY7kRRoMKkgLjVds+WalYCTIQeIOH78+GKx +uHjxn2zBuAGXD2LUIOvJELz9nJkBNSD0dGchBEQAfRhwF1JP6YEFwAwUAkYeGlHFVtqN3gLIPPK+ +s3f94S8Tfv7clt/f97tj33jcxz/+8SuuuDyTSb/zne/sz+VK1cGq426Su/94mpXGmrBkATAQ7AY1 +GihAhRqBQ6DufiZCxaAaVPFh3fsNsEURDag0n3TS839ateDJjcYj9n1ApKhOmUIrw8p8GIIHIFSq +0NPTXrd7S199vZcKwtBxXVRaoVJKodJKKUJUWoFCg4hag/UFUugoxbZ0tDVD2whfBAZCZs3GGFLg +1lFAHq4IZ67omzJr9YnHZZ4/vGXlgc2bWjPd6XqjiDi0xgA0IRh2Ata9Qd2ufNsrPQcs7536XG76 +etNudKreBUdpUJpBa6URbOEyxQhIDIBaMRMSKsPGhAZNaPK9bbn1/bmC1pUhlzIfhH9teScZPVBN +JE8uvRd+hPHJHVJ5ouuavFJoHYH2dPR88Qv//b3v/W9bW9u+2AEG8+6Ion+tVp8IiImNPWTYALPN ++0lMKqoNAJEazjAp6x0KwAQGGFkBMLBSgGHogLJbf1JM1p0UQWtgYK3B2hmiwu7ADKR0pmvn1j/c +8lUwRmtls08o2Ov11INJUCNwvsWXgaMCTLRjZ9evfnXve9/7np07d6rIJsnJPXeFIh+qqoBBVZWJ +WOU/WEExqEoGCrWqBVeEBbuu297e/r3v3ZTPBcxlKShVyf9E1pOaPJSr4hXinj6PihAyeGY36AKY +AqACsl4ZlHAB4ugNhwge6bOyE771nxcd9IdLtj/6lz+n05mJkyadc845l1122THHHjtq1KggCAab +M5iIAK4oSmhdGd1sE+UAwg7WTcgFYFvuEDQCKAO6AXKLoeebUPpZCABFaJnW8YmznvrsLUet20WO +JmZFpby3Mh/2kWfF/q5NrWPru/sydW46CD1PO6g0KJtrXylUrNC+Z1srUCsGAK1s/K1CJFUKFoiG +lJFJMzEZYEeTaVA+uLjGTF/lT7ljy8mTtu4+0NkxMb1rlNeZdYpW/syHbqffuKXYuqk4akPQvIub +fEylHcy47GgEtKV/FaIGG31s/cfYVpG0MwYBICj6EBYL+d5R/rbC7u129y/zQfj9incqaoNVvEnm +MksGEQs/cviyh7cCGy9Vg7ePeSZApZAMMSKuW7/tv/7rq9de+3Xr3v3XvuLSv0xktfuGyNgQAI70 +/9YWAADIJedfq74HAGY0xBqQgJCV4mgDQKwIHAQmVggayZDSoFgZAtYIpJi1Vf+T1SoxkNZpk+u5 +/4YvF3M9yiagQ4jV/3u9nkkXoJE935TNBVmKlUQCuOXWO848822ZTCYIglgGqPbhGSRFLEB5gG9y +f5/c58USha00zMzWRS25NayuDxCnotJaT5gwIZ/P33HHr2hALlYJ9b+sJ3ub/8Soo11TTz5lAg1O +CIWHwJkLXIRIWiMgKmn94ze2VHefcicTzj/0jcu+edHMf71h1XPPPbu7o+Oggw4CgEWLFv3LBz/o +F4vKcapLi1QnGUu+IWZXwe6O3noDEOwBLADkgVRJNiBw6qBvCXR9CzQMZJGxPh1FOODI9Z/tTl35 +89nrO4xiQ6GdS8DEoCjW+8p8GJQnCAnSnWszozLFfAa1Q66rPYWolFZknf6VlQFQKU2IoJRCINT2 +IClUpYxAhBjtzZkVEDCFHGrD7GggqqcAXGWoeS01rzLTTM5gL2kI2SaXUJpYEbBSyktzRkEdgFIO +oSbUSilGDYxKaTsvEJGYlWFAG+WCbCAIAgjDXK6/rn87bVvJBmV9EH4/5FVFbbDYkSjZXLUOT/iR +w5er7nFQHgGsIgbIJspBhRrxiSeXXXvtt5M1XPdx6x8ndYnc/G2ePbJ7f7Jlv5is+r/k9A+lvM4J +318rLaCNCGZAJmRWRIpYG1LGaMMOkyaj2ThgFASOCrQOtONrx1duUbtF5QYu5u+/8Zu7N2/WqJVW +CtAWMrJCQin2d2/Xs8wtb6TON5XwxCAAwFy/f911/9fU1FQsFgfzy48tQtUOYxVHKpS7FRmlSnaq +fQoDSIoN2Wy2vb3929++PpcLEv0vqwIm68leeBsCjqg05gsu+QAMUPgj9N8BgMAFMP1g8kA5oDyY +PHAeKAcmDyYHJgemAKYXvVNAw7lnd5937ISVq15atfKFxx57bM2aNU2NjUkLQ8X/k//iI/aNCcNs +tu6uX9171Zf/M5PxIMwBFcDkS//6AQByT0Pn/0ZCPCX+z4AMEMLsU176+keWnjID0o5SpZxgpZB3 +mQ974ZXWqLCQKzb1rcPenWExFxZ8ExpGjIrsRj4/yjr6KK3A7sW1AmX/adAatVJau1pr7SjHcVxH +ua52vZSbdlIpN5XR6bSTrnMyWS+Tach4LVlnVIPX0ujVN2TqG7INjdnWOq+1wW2r91qybjaTQi/D +qTp208pNgeuxdlE76LioFaLWWkPUQxXVkwAVhoaKgV/MpXI7vJ0rgoBQq4T6X9YH4fcXXtVS9NYs +AkVlBjvhRwyPNfw39tJ+XITTJkr/xS/v//a3b7C5XIbw6k5+aoyxMZd208dshQEyRGQMkbFxAGAF +ApsSyKoPbUyA/ZxLXjwEYAgZ0AAYRiI0oAyjlQGIVUiaSRMpIA1GQahUqDBQOlTa165xdf4PN12/ +5tmljuOiQitioMyfv4lHVIlwaGQGw3D//Y8sX7581KhRvu9Xu+VU7/grQoErwgaSMgCWgjyx/FUh +A1TUFKs46Hne9OnTX3rppV/84j6C2FCA5QWAZXz3hUcEUID9vqZARTH6/XdB74+AisABUB+Y/uhf +2A8mB6YfqB/CPjA5CLsQM6RPTI/e/vmP1k9pyG7ctOWpp5465ZRTFi5caIzRWif1/dXvKyLCiSib +zf7h/t+f864z0y5pnQIGMH1gCkB5oBywgeIr0Pl/kYGRS5OXB/4hARBMOHL9Fy975MaLNx7QnFw5 +UebDvvAAgErlOveMKqwPu3cYPxfki6XQMrT7bEBE7YBSpBSBYqUIFShFSiulUCmFWisNSmutHe0o +x1WOp1xPua7yPDeVdr2046WVm3ZSaZ3KOKmsSmVVus5JZ51MnZOpx0y98up0qg7cDHhZ7aWVm0I3 +Ba6HjqccDxxbAcABrUlppTQgRnFmiEEYhIViGPRxz/b6jhf8/jxW6hpkfRB+f+ErBYWq53T8pyrb +FAo/cvhy5/W98ANpcJRNCYQAzHD77b+86qprwjCs1rZWvOzW3z6YKdL3MwAbsu4/xnBpcz+QBtRG +tjORdcYEYORYU2xNAGA/JgYGZmRCJkWsmDWRBkJrEyBWHGowGkKlA6187YQO5n55zfXLljxtd/+A +qAdSbA0kQdrb9QGZb5AMBqXkzh4Z1Ne/8b+u6yqlwjCsuR0f4mU39MmsUxV7fSsAJKdf8kh1bEAs +r1rnn9GjR6dSqSuv/LohHf1eYlkf/ho+4b6FAAj5ojK+jvxkGCG3GLq+DcFmYALKAfUBlfb9YT+Y +fqAcmH4IcxB2Km8mhY0z566++t+mfvTf/t9dP7/z17/+dSaTsRHbSZEvnhsV0mA8tdLp9J133vmW +t74VAGZN8sDTzGkM+0uWhzxQHnruhdAHxgHdf/zGRDKAYnBC0E2FQ9+86hsXbFLIpSRRnFTLyXwY +gkdUAJjbuXV0YWOhazsHOT9XCE2IKqrFzojEDKWqYIxIiISolPUIUjZ3kOto1Eo72r4crR3Xc11P +OZ52PdfzvFRKuSntpbWXdry0a1MGpdJOOq1TaSedVum0k8k6qTSmUspLgeeB4yrHQa1txiguFbIm +YLSSicIgDAv5gvFzpntX4+7ncx0dNu+njK/w+yfvJIK0apcMqAomEH6E8Um3ddCDFwkuO44AhkEh +kFY2Xc9vf7s4DIPPfe7yVCpVc+MVp3tPanZpINc/UVQBjIiIDUfRAEBs5QRgpChRqCplA1IGWCEB +a8OkWGGc15SRWCOwAULSgG6UDhpYIWrDAAaMcpTK53/6pZ+seXqT53qoECOdb42w+kGuZ/X+UuZb +Mh2Q/QgAcdOmnTfddMsll1y4fv36TCZTYQQYoqZv0p9ba13N2zfxtq9mNYCKXLSx84/jOE1NTZMn +T77ppptfWLkeUEVp5kv1vyL3XllP9sKXB90CFwJk38EoKx0DI/jrwP9fyLwZ3INLRZjiCGACMtGf +FAI46B4FvPhNJ728YNJ3Wg892YQBEamBKhxc0x8sGlkAJnIcRyl19dVXX3HFFUohM8w6gCHVyKQR +egEBkAFdCLZAYUWpgHXJ+59Lv0wNHFEIngHfBzfrD/xehTIf9p1XWjNTbtv60RPUrk6nfrT2c9pV +ykl5NthXK2Sbvim2wFmhDlElxP3YYAAYhWkRESpWjDZvhBuVdSZrJnaYDXCpvAxQKbYMbZJpAmBG +BvuvNBNszk8FBATs+yEXihzkwu7tjbuX9e/ehkonHnQyvsLvd7yqDNIaRIxIfCr8SOa5iq96U1ry +tJ1hVlmjEBDv+/3DX/jif+dyuTirutX3G2Osr3/s+RMdD8PojyCMPH/if2yYicmUnP4JCGxsABAT +GRsbYIiA2JboREAwVntHbBgJwJBi1iFowypkJEATajLKkGaTdrTp77vlsz9c+/SmSPcfuTcpGAjq +3ev1LH9TKQmM7PlGHHvS2wROP/3pL1aseH78+PGFQqHmdr86Q2i1x39StR/r/mtiFR9BrWxC9fX1 +06ZNW/XSSzfe+GObujTOJjnQf1kf9pEfMJvg2KbASRXARP4z1jgHFELvb6HnDvC3AocQ5ga8gEwO +wn4I+4HyEO5B1cBmdMOooPOpS3Zu2qgdF0pSXMXgljn/2LpyzJ7n7d69+wMf+MAVV1yhlSLitHKm +HxCA0wQcgMmByUOYAy5CYV2s5gdKqP+rjrCBIgPnnF8/ON7+0MHMRDIfhuAjO8CWdaN7Xy50bjOF +3mIu7welwl0YBZEnqzjY2tI2YYNGBLRJ+RUq5WittNZae47jlOwB2nWU42rtOI7nRLUFUo6bRjel +vbTyUtpLKddT2tXa1Vb37zigNWgNSrFSgMigDCpQCgCKAYV+sZjvC/dsbdj5TG77ZlQDegEZX+H3 +T75SekBUUOU/VGFEEH5E8dVBwIPzpepXA96vkYrMygBKOQ8veezCi/595cqVSRkgfh+/ibZiAGT9 +/mMZwdoEKIoMsGn+yVYGSDyUreIGyRYPhlLtMODSpr2ky0EkRgZg0AyOIYcBDSmglKvXL13zvx/9 +/sbnd6J2rHJJK7QiQPR7caDa175dz4G4V5lvtpBCbPxnBmJk0J//z68iYlNTUxAESW1uhTWgwo+/ +wrG72u8/lgcqvP+TaSKrs4g2NDSMHTsOAD7zmS+FJgoijff9qLA8tZ+sJ3ub/wrtfYgAbzxoe6Yh +cJNONab0hCpuhJ47oP/PYHqBihD2QdgHpvQv6LF/op4IDAceuGr1vZ/v7M45rhuGoV1PkqtWcp1x +tPY8DwDuvvvuww8//Pbbb1dKERMAzJlQN36MD9CAJnb+KUCYg2BjpdtPxXsGMEAhFAFTDjz/x+m/ +fDZrVxobBJwwBsp82CfeJtnMbXulrXNF0LnZz/UE+Vw+CAf8lxGs571V7Nh73BYOQBVZA7RSWiuM +qgmgUugq7WpHxc5BjqsdRzuO67jasUHDrnLsjt/VjqtdFx0XlaOV1rYiASqbZ9SaIxAxNJQPAlPM +Ffu6cM/6hi1P9G3bAgOePzK+wu+/vKqWHiDhKlQRU5zc6wg/QvjqOgCD8wlXs1JROgRQqCM7AIBC +/dLLr3zs/13+05/eXiwWTeJFpVcyBZB1/TfR89sYQzYmmIiBTFwGmInBELApbfZt6AGXAoHRCg1A +kcqemZFAMSkGBNAEyrAiQGIXAX3zmxsW3XD5L/bsLGjlOFpZGwYxDO36P8T1HND+y3yr4RxVitlg +2L2751Of+kxbW5vWulgsVtcFS0oFsS6/ItVjdbxvhWWgQgBIfmpb1lo3NjaOGjV69OhR//3fX1v3 +ylZiIGN/kKrVH1lPhuRjXTgiM4/OwrxDNrBK7KdLKUAjdTsx5JdD76+h8HLJ9b8Xwt4oJCDsh6AL +GNnUufUwKXvHD7/yqa7efs8r6XnVwMspvbTWO3fuvPnmm4899tizzz5769atyUoRcw7MNjf4QHVR +yEH0rw/CHijXLiT/ZAI/BB8BEIJd2SfunfOZH0/MBcmKdCjz4W/gERUQ9m7b3Lj9GdXxSm/XrrC/ +L5cvGGZVSvVPAFb3b3flHMWXg0IEBoWoUGnUChUCxmHCrtZaacfu/bXjaEdrrbR2teMo7TqOdrRC +7WgHtdZaOVqh0oA6CjlQNgGRAkDfmHzBD/P9/d2d6T1r0+v+mNu9K075L+Mr/H7OO7GWpPypTBVF +Kyr8h4QfYXy8d41iN/fKlyIBKuMBkBlJ9/fmvnv9rUuXrfjsZz7V1NSUzO0YRwCzVd0ZY4hMaJjJ +hIZMSIaMISZDDGAoyvRjJQ1GiEoDsAYrBdiSU6y0YjaErKwhwMQ7ckYgrZEYHI2Oo3bu6vvON+5d ++2Kn1o6jIuclAAbQeiC5aKnuQcXvHfx6lktSMt8ivrRmsbUGGAbN8PQzL1511dVf/OLn1q5d6/u+ +9dWu8NWpyOFj/0walJLmgvh0uzM0xlTUCKtIJJpOp+vq6urrG8aNG3v77Xf++t4HARzmhD83caz+ +l/Vhn/iydEl09JRCQ9seLpYiQeLy0JTYYQOA8cF/FlQGnKmA9cAhcBiFATABM2ID5fonzlDjnrhn +5sz7P/kfFx599BsOOOCA+vp613UdxwmCoFAo7N69+7nnnlu0aNG9996by+WgVgLZuVM8lTFEWpk+ +AAIFgATsAevIsZYTdlACZggAnDSoAnZtbV3xwoF3Pjrm2c3GD4jYoHVSl/nw9/BaA1N/x+5M4S8e +H94FYRZG5ZGdTNbxXABbUgKiTFIIsZoJEB2FiKCshACotFbAoCPvIZvQqVRMBBBYAdhy7QQ2Sy2T +IRU9MAiIUCkNQEB2xhJT0YRcyHO+P+ja3dKxitY96xdCVCpR9kHGV/j9mncSFbkHPiiv3UhxttBq +QPjXPV+l6iTAvbafeFIy2Xz5DKCQiAE1gtEM8Mc/PrX65Y9/8IPvOe200zKZtN2WAUAUD0BEFJJh +YwxTbAkgw8YaAYCIgIEJE/V6wRhbBz6OCY46ZgA1RhUBgEFFFgpg0MyGIeM5Xb2F+36+7N7fLMvl +jXZcBEBdimiOAsmAmVAN/ntrXh/QA3zCEifzrcK1DICZ2ABqpX7160WtrS3//u8fW7t2bRAEVoNb +HQaQjNa1uYNs0h7P8+xe32LGmNDGkxBprW1TsekJShHDSinXdT3Pq6urS6czo0a1PfTQkm9c/X8A +msuKSww4/8j6sM88QakQGLM67fDNXl1IxUhKx3K1eqXGPcxD8AKoDKgxwE4kBhABG6AQASEIzlyY ++cGDXZ/97OessG7HMRYAksJeXP0tMYsAAA+ZDKAByEDYAyXdAZAPWFcW+1vKBRogYKi2vzj+wSdn +3bciu6EjCMIwDAxFLoiRoBiXiJb58LetD6hUsb+oVz82elJnR3CQah5LwD6l3XTa0dbzHxPFHxhR +6dK+HyBKW2E/BQBdqhIMEEWNRcXhgYFsAgkEZMOASikgQ2B9BomsvQGJ2TcmLBTAL5quPc6eLa3b +lua3vAKMpWoAIOMr/LDgnVharfAiShwsCy4WfmTySSvAX9c+Khuki6DYpkwgg9puwvX2nZ3XXnfT +r39z/7kfOPu44461+zD7tDZkOAoAIDLEbAwTkQFDDGTI5gax2pmBxJ+MiGQUgAFQyArYegNFNcKs +9yYAEgAyK0DDylEU8IMPLv/5L5/dvqtfOa5WDkS7f4RIBCj9XrUPv7fi+iQDARMWOplvA0EjZXYU +IAYAdfMtP0+n0xde+JEtW7b09/f7vq+UslneodzD284ZpVQmk/E8DxGNMb7vB0FQLBZTqVQqlaqv +rwcA3/dteLFSKp1Ox2KA3RFqre3GMZ3ONDTUP/LIo5++/EvEjvX0wIRDXNwFWR/+Ol7ZsrsUFB3K +o/aYGIIAwICHibpaVZ42wAAmD7wBlAuQjvz92AAbNEwMjS07zjz2gEfWdGuNoaEgCOIYktgrLK4l +V23bTGs9YZQB1mCKwARIQAqQQDnA7oANTwEYIATfgeKuxt8tOerOpxt29fphUAhtSoLIqlA7BZDM +h79xfVBoiPPrV7V27QgmzusKJumGNkMNzOmMl854AyqZgegsAETQCpVNRAFgzQUYKxsAFCBpq5RC +AkYFCoAYkAmQUSEyamADkYtRAFAwVCwUwc9Tfw56Opp3r1Zrn8n19kVZTMtMvjK+wu/vvJOMGGCG +wc+sznso/IjgKyod/Y3t88DuyZpSrXZeIzLA6jUbvnLVdYcect/73vfuQw452HEcsup/AusCxGTI +GMPEhomJDIEhZiJDaMLS7h8MsQYGRI7MAkQIipgRCBk5ct1nBEC2AV1+0Ty3bOMtd/3llU1doJTj +emgf23G6z+Tvxb/peipkE1mbFYLMt5o8s7G2kyhTPCKAuv76W/d0dV1x+aeKxeLu3bsLhUKssE8m +e9Fap9NppdTu3bsfe+yJZctWbN68tXNPV66/EFLoKKexsW7atMlHHHn4EYfPHzdunNY6CALf961s +EBsKlFKpVCqdTiPiT35y2zXfvAHABQYeyG1bQ6cr68m+8IhAhm20NyL858/HfGBjwxEHdU4cuyfT +kEtnc+gxK/B9QAMu2vratcSAMAAIokdYMhWP8mdMIAAODdeMGBm6oESD62Q8AiII+kCHgJFzCTAC +B9FX2Lz+CkBB97oJ1//uiIfWUNHPkaHI74whYSliJoinisyHv58nA/nOLqfnkTHjp/aOPaivOF43 +jQoyQS7M1GVSda7yAHRseAawyh9EQGuERVCAyAw2Ej1iABQyg2K06n9GRkCNKmSyA6kRCsAFQ/35 +gikWqFCg7o6mzg2ZjcvCnVuMQZvsX8ZL+GHHO0k32litxUxYSnZeS4YQfgTxe/Z0I2Imkx5cptyH +9tE6w6jS6qwUEmgkYGBQRpHh55a++MILL8+cOeXUU0+aP39ua2srABORMSHbPD9R+G9p92+9/xGs +Zg+I0Mb/MnNkgUer+wcgJGD7TFfoaASArVu7/vL06kV/XrVxew8orR3PpvnEKKU3R24/Vf3/265n +JpPWWu3Z0y3zrSaPqEv+4MhEoIAYFTq3/ew3y5e98NWr/mvygQcSURiG1qPDqvA9zwvDsLu7e8WK +Fb/85b2PP/lcUDQAiktu+sDgY5jLd2/fsfRPf37O0TBt+qQ3nb5gwYJTmpubs9ms67oVbkWbN2++ +8sqvP/7EMkDX7ueipgbV6cp6sm98qfIDGe7IwXcfrnMfrW+umzJ1FM6dWDx82s5p4zuz9T3puhx6 +TAoCH1wAm7NrwCYAiQw8MCAAcKi2dyoAGN3e3toyzkt5AA4AApeiCQxFCwKZMAzC0Pf9fH9/b3// +njAM+4Mw7ytgH0wfsLHZMkAhKA3cAwSggRkCA4pw1XPTrrl/zuodhTA0keI/imHHMlOpVjIfXkVe +aVvkHfo2rEnv2Fh34EE9Y6b3NY71G1uKVNftpeozmXrELCrH6vsRbTU2ZLDGXEwECVj3wZK6AaLq +YhZmRkQHwGfIM/T5YSGfN75v8v3c09XQtaVhy4tm0xo/CFGp0jOBZLyEH3Y8Hjrv1PIzqdxhqOxk ++6nwI4q/6MIPfOi8911xxRf/8penUSMZUzGHavjB17AYxA7xA7yNuaJSdkeb0cewQcTW1sYjDjv0 +DW84etbMaa7nMjOX6gBYmQCA2BggYjIKGMggExIpIGSjkIEZgRUYQEJkrcDRAAi5fLB81StLHn9x +6cvb+/NF5bgANkdM9GQYSPdf5vT/t/5e+57hjW888hvfuPJHP77jxu/fIfOtJs9MJVfrRLgEECI4 +ik848eizz3rX4YfPz2Qydqh831+37pUlSx69//4H12/YiqAZkJgVKuJ4w4jMXDJkWWU+MFA24x15 +1NxTF55yxBGHtbS0AEBnZ+ezzy77wx8e/MtfnjasSyn/IeE1AAn/Hxmvv4VnNlEGVYT4NlNaaaVd +RzWlnenteNik3qOn7hw7eld9XVcqEwQEYMDFUpxAMlyYo/AeQMjnxnzw6/Ri//jGpjGhTR4WZQeI +nfcBmChRO0IB2JreWlEQFK59T//px6wibFOuGhhzB8HsAQgYwUegwP3jY0det2RUZ59vQmMMh8Yg +Wl1zab6V2YhkPrz6fLRQEDuZlJo4vWfU1L7mCdTQrDN1OpV2U25TJlvn6KynPa1crVwF1nFQQbS5 +jyRHBkIwzIxADIYhZAgJikQ53/Qbk8vlfd83fhAW+nV3R0PnlrotL5otaymgUgUykPESfvjyTsIE +H5kGqjRzZVKF8CON37Rpi+M4bW2tHCVfrjbuJ3kYov0BnkubaVAApBAJADUwoyYEgM7Ovgce/NPD +jzze1tI4deqk2bNnHXTQjLbWFkcpYNZKEVvdjs34ZlU5oBUqBkClgZRV+zAQQSEMdnV0r1i98bnn +163fsru7v8iAiNpx07HWn9mKzIqYEtl+Xo3fq5AMt7a2OI6zefNWmW9D8MxUUreXNm2ggDkkfHjJ +Uw8//Hg65ba2NmUy6WIQ9vT09PT0M6NGh6y6F5hZmUSVoMikwBAaRhURiKovFyx55JklS55UClJp +DwDy+SIzIGhrF6XIHyn2/q8ZEiPrw1/LR+YULmVcAQAwxASGyA9MRw6fXp/60WNTxtRNn3NAeOK0 +7XOmbG5p3sUe+8UBMSAWBpjBMBtUDz1Tv9pvq29o9ItBVPmDknE31ntPKwaK0v8QoVKEDKyVk8m0 +PL2p4cR5q1F3epxCRVEJk4DtfwUA8L17Hnrj9/6cLfoFU1L8IyKXx/jY3b/Mh380z4rCog8vv1C3 +4aWGtrH+hFl9LeMLDW2F+uZ8vuCkUp6nM46XSqeyjkqhSitwFXoIGqP0syGDYQgIisQFoiJDgbhQ +9IMwMEHoF4thsaj6u9M9u1o6NngbV5mOnUFItsRY9YNAxkv4Ycc71aarJFFLnSn8yOI3b96mFB58 +8Kx7730gGc/6qrSPAHGCIGA0wEojM2gCA5pC3rGre/vOpY89vjTlOS0tTRMPGD+2vW3M6Lbmpob6 ++rrm+jrtaGRb99coq+QLgu6erq6evj3dPVt3d2/d2bFh886enlxorHDgKHSsCXhA6x/dOwpLBYxf +1eupEeCQQw5SCjdt2irzbaj5gAp1nHvKbhaBS7n7EJyCT1u37YljLIFdRCDAqExYYrNeEiQGinZB +XCSO2cYRMAEB5vO2RoRTYuI5MeACBlXxVTJef9v4lhy9Il8gVBilBzKsFaKBUKkgMOsLuLFLPbBy +7PjGCW85uPct89a0NG1TKcMIQQhAwMSI4LioCTdumHL94xPdlBOGJpoMZKONEznj7XukSL2fiEs2 +BBCaR9e6F+xpb2vf6vt5z7EpJAEQAgBwgfozdz9y1I1/TvuBb0wUSmz7H883pTXAoEXQZD68uvxA +fHBA4dbNuH1TSzarRk8ojJ2WbxxTrGvqzzblsnXguMp1AJXSjkJ0tFJKaUBj645wVFieTEjMTAaD +UOV7VX93tr/L27MttW0t79xqisWiYa01KkSsGQIk4yX88OPx0Hmn1lRnJpur9nkQfuTwmYx3989v +6u/v+8i//kc+n0PQxOZVa58S7h+lUtWG2OrkOQplAZurjYDIEEbVBdh1nbTnakeXHvNRZs8wCPMF +31r/iUFrq+G3wceRYlkpTAR2Wq1/otv4ql1PBGTgdDp18w+/XVdX/56z/rXoG5lve+XJmHj7bsWA +Mr7klF/1xvJQnnW+AoMqnqt4SDab2PrLeP2DxnfAL8ieYasHMoDjKFTYnHGOnRycPHPnIeN3pFI5 +1ykq5NBgENQ/u+6Aqx8ctbOXmNjYgiN7mQ9cPX8A2NHq+Cn0+TNWN9Rvq8tynLy36OvOPe3fX3zw +fSuVXwwYVMLjf6D/NR+0Mh/+OXwMAjEoQNd1GpuwbWyheRw3tgTphoKbwlQmdNOsHVIOqCjdmKYA +yehiHoOiG+SdXG+qb7fTsc3s3k79vRwEQMil2n/Vvp1y/YUf1jzOmbugyq5d6TY0mIuz8COBZzZf +ufJTCxeefPEln3x+xSrUWMsO8Hf0h8t4jhthiBx27UEq5W2wOl0rHVR+YylzUcJZG6Lo31JUzEA4 +TNnWP6HSeTWvp+3vnEMPuuH6axcvXvKfX7y22m1U5ltNvkYNCisxqurCwDho+1Wb+/IwAywv71SD +l/H6x/HVQ1zaTCdN2oyoUaFCUFo1p7G9gduy5DqcK8CGDtjeB6EhGkjzw9VhG4PPBx6wESEoxPZG +/baD88dM3jNhdD8ibe2se3Dl2EUve3tyUR4CitakveuAZXz/+XxJsIxHFlCh8jyVSkOmDlMZTGXA +9diG/ge+CYpYyEMhz/kc+wUKAiYCQlCYyPkr4yv865N3avmx1QwrploORsK//nlE/YcHlrzjHW97 +79nven7F1179/kSFAko2qXgqR1oXAgZiBm1z8gFEKX6QiUu2WF16ikdlXrjk8pHQKyJEPgC2h1FK +H13RH3y1r6dCNvzes99VX1/3hweWDP4skflWyUNZlYDYk0cNsq0vOzgg5enqjSYm1PxQEXNcofgf +fG2V8XrV+GTwd1QooORaQ9GdS9a6p0K9qwi7eqyCQDGQ1QyU9v5YPr415oN1QEp8NJAXngyDxm3d +5ubHvVueaLcOgVEGIfIHmuWa1aBlfPcLPhGAoe1dzwSmEJiCz3u6UaGdSAktAIKCRNwRAmhQUJXs +Qa6/8K/H+yUh41KFViaxOkO5oU34kcU/9tjSNWvWveENR8yePZ1Cq2J5VfsTOeVGvjfRrGWyUb6A +SimtEBRiVM0RUSMqrVArUIhaodalNwq1UlppBF3iFaJC6/lpPcoBk/2JvjpKPP4qXk+7+589e/ob +3nDEmjXrHntsqcy3v5aHqMSOLqunNrA3g/i40joRpV3ZPtrSDokw7nivDyV5MoaV1skcajJe/1De +jm+ZTr00vgxAxpbxAwAkppBsOjAIyZCt+F1epHno+WDnQNn4liYAKsUMZJgYDEFoTGjzjlEpfyhD +lKws0b6M737LJ+93RK20g2gfEw5qF5RC7aDWpY+wcn2Q6yn8650f4MqFgYEzq4IJhB9xvCH47vU/ +bGho+PjHL/Q8r6Z+dJ/b3xuvVHm9rbh8o7L/on28DdxFpa1vgC36GEFKoQKMMI0aS37BWNGfMk+B +V6n/pT+V1kzsuvrjH7+wsbHxu9f/0JDMt7+dt/uteB9vZcDSZk7FW7F9bD/+f3x63L5c/9eKL5fT +KgsvWEnA5nRKvOEKww5GOX33Ph+ib0xE8UYmu/L2o31/eX/+2vkm4yu88MLvb7yqcLcdTIxIfCr8 +SOQXP/Tkiy+uOvjgWRdf8mH7zEWF1dg+tL9vPNoaPlT9xlZ2RAStFCKV9g1JZQ9ACYPSiWVq/tK/ +f1z/7S7BEF18yUcOPvigF15YufihJ2W+CS/8PvLld/SA2r7qftdJrOoJt/f+/A3tJ75Ixkt44YUf +rnyUBajMMSiZS6+G8xAIPzL5xsbMHT+7wfO8G773w1/+8vdKJz0ohmpt3ytnvT54KOX+f/e73/pv +F33Y9/33feDinp68zDfhhRdeeOGFF35/4FW19AAJV6EKq0FSnhB+pPE9PfnLr7gym81e/G8fueSS +8wHAxgNYu31NV7O9tf+64jGOYmQAgEsuOf+iCy/IZrOXX3FlT09e5o/wwgsvvPDCC7+f8LEFoCJV +UM0CwkMAwo8U/tA506679r8R8cUXX/rWt65fv35zqahORXK92onYBwFeJzwTA8PkyQf8x39cPGfO +bCK69JNfWPH8Wpk/wgsvvPDCCy/8/sNX1gHYaxrRCkD4Eci3j2n9/o3XjB49uqur68HFj/zud/dv +2LAl8ENANGTUkO0TUxKo+HOY8rZsmes5Bx444e1vf8vCBSc2Nzfv2rXrwosu276jU+aP8MILL7zw +wgu/X/F46LxTa7oQDSFSCC+8VvCB959xwQXnNjY29PfnNm7ctGzZC1u3bt2xY1dvb68tsj5EeaZa +r2HJI2JDQ0N7++jx48fNmzfnwAMnZbOZnp7em2++7fY7f2sMy/wRXnjhhRdeeOH3Nz4ZBBxVUd3b +mSC88PZ9XTb19refcsrJxx900IxMJhuGITNReVgwMyPW2ElHKf2qPhp2vFKolHYcJ5frX7Vq9UMP +/+l3v3u4P1eU+SO88MILL7zwwu+ffEUWoCQEe3MzEl74KPXs2Pa2g2ZNHTeuffqMqRPGj43yhGJF +I4CDqNSHNb9l6/bVL6/dvn3nqpfWbd/RMbQgLvNHeOGFF1544YV/zflqF6Ca4QLxyRSVOBVeeOGF +F1544YUXXnjhhyE/YAGITxs663m1wCG88MILL7zwwgsvvPDCDxc+Ubu0sqRw1ErVe+GFF1544YUX +XnjhhRd+uPJqsNLBpZIByfeqJDMIL7zwwgsvvPDCCy+88MOSr6wDUJIh1F4tC8ILL7zwwgsvvPDC +Cy/8sOMVoqowDSTTmJS3MmBQEF544YUXXnjhhRdeeOGHI5/0E6q0GpS3pZLnCy+88MILL7zwwgsv +vPDDkcdD5y0YzEAwSPgwCS+88MILL7zwwgsvvPDDlB80CLhCjEh8KrzwwgsvvPDCCy+88MIPV76i +EjABKGAC3McaY8ILL7zwwgsvvPDCCy/8cOJVtfQACVeh8gRD1WlEhRdeeOGFF1544YUXXvjhxMcW +gArPoZoFhIcAhBdeeOGFF1544YUXXvhhwMexwxUyRMXJ1UKG8MILL7zwwgsvvPDCCz/8eIVYnT+o +wpqg4tMsILzwwgsvvPDCCy+88MIPVz4RBEzMUB1MMESEgfDCCy+88MILL7zwwgs/vPiKLEBJCPbm +ZiS88MILL7zwwgsvvPDCDzO+um5w7CGUtB3EB0l44YUXXnjhhRdeeOGFH778gAUgFiCGkCRqChzC +Cy+88MILL7zwwgsv/HDhVTJ6oOIN1EgsCsILL7zwwgsvvPDCCy/88OXVYKWDSyUDku9VSWYQXnjh +hRdeeOGFF1544Yclj3PmLqgyEFRWDahpWRBeeOGFF1544YUXXnjhhx2vEKvjgGsUFq6wLAgvvPDC +Cy+88MILL7zww5FP+glVWg3K26quLyC88MILL7zwwgsvvPDCDzN+gCsXBgbOrAomEF74oXgAaB/d +/M1rPrd86aLlSxetWLZ4/vyZKU9bfv78mcuXLnrfOW99bfvfPrp5xbLF7zvnrTJerwmvNa5Ytnj5 +0kXDsf8N9enlSxdd+z//KeP7z+QVgl1PavLLly5evnSR1ijX8zXhU557z103LF+6KJ1yY/7ST5y/ +YtniRNpBuPQT599z1w1/z3g1NmSXL130zWs+98//vfbhdc9dNzCXuVXE/WEmu6zZiWrflP4tXr50 +0fz5MxGV1hgfT/K2P1rj+855q+Uv/cT5jQ1ZmW/C/4P4QYOAK8SIxKfCCz8Eb35x942LFt112mmn +xNiPb/3uU0/eb9fHEsb7R/9Zxvc15ON1Sq6P8HvnFVZMnRo8sVzP14QvFIPrr78FACZMGBMDF5x/ +LgC0j26N3A6MueD8c6+//pZhO14MADNmTD/ssFmD8Ax7eQ0F2Naee+aBz3320vgC/vlP92qNMt+E +/0fwToX0gKiACQbCCMoyiVZLG8ILn7QuXfs/X5gxYzoAvPNd5617ZZv9dPSo5rmHzizn8bXtf3k3 +ZHz/+ddfJ1ei4dZ/rlCuyPj+s3gYjJ87/7Qo3E2u52vEL1/xMgC84x1vuu5btwJAbAo45JAZO5Y8 +BQCZjAcAzz//8t8zXvHd91r8XiyptK4/7IjTjTGIitkk1jE9d/5pMf/Naz532mmnnHba2Tt2dZW0 +swoSq9/c+adV9Gf+/JkAcMutt1173c322+bPP+i1+73Cv855VS09QMJVqMJqUJVGVHjhB/jGhqxV +/J922tlr122JgV27uxY//CRimZsaGfO+c96+fOmie+6+UWtMtj92TGvsQXTpJ863+g/bn4b69PJl +i5cvXUTGLDzlaMuMHdNqvXrsn1OnjEv0n973vrfHTdnFOtH/+FlC57z3LZHV9dIPA1CiP3TqgmNi +i2376Ob4937zmv9cvnRR+5hWrfF/rv5s6StI5sM+8jW1FyXevO+ct9pr/slLP1xe45BKQ7/YXv/4 +I8s7jo4nw8JTjk58tQKA9qrZFffHDmL76GZ7evToRQUAU6eMjWdXvA+Q8f0n8zWN2rEbxvKli7VG +QGXHt310s0L45jWfW7Fssb0x7T87jmSMbd+uD/PmzbAOKqX5FtkzS/6Kcv33zvf09Fqltb3OsSng +Yx+Lrqc9smNX576Plz1x6pRxlo/vPrt0D70+X/7pC5cvXZRKufZPe1Nf+onzY3VV/LCwWiq7ntjn +i6qRYLHs9Y2vfabkZVHRn5rPl8rrWdMrg5naWprLt/tq6dKXjWGZb8L/I/h4LlYkD6oUKaruBOGF +r+SPPmouAKxevWbHrs6h+XHjxlx37ResoXPGjOk/v+P6mG+oTyc9iC44/9yf33E9s6lYhT/1qY9c +d91X7ftFi+5acPJRixbdZf/81S9/nPJseitavnRx0pz6i7u/b3tiLc+xIWL50sWf/9wnY+yeu24s +bTXgnrtujL/Iftelnzg/eX3mzJn53DMPnH76AnvuqQuOkfmwd54qTOEVvFmx7KHkwN398xtLkhXV +HJHk6Wef9ZZ4Mlx33Vff/763x+0PMruo1H8EgMsvvyQ+3b7mz5/5q1/+JJ5dX/qvT1bsRGV8/zn8 +YDunKtcytjfm0ucW2bG2N2aykQqHIjv01153s4VHj2oGgE9e+hEAuP2O38r13xe+UAzsH+mUg6im +TJ54y623rV69ZsaM6Vbz8o53vGn16jXlkYd7H6/582f+6pc/rrj77HgNvT7ffc/vSlIHIao5c2Ym +5RNroNiyZafd/S9+sOyWt9Oj5tbqtNPOBoDTT18QCxuJ/lRcH6x9PatMiPH1fPKp5baT1/7PfzbU +p2W+Cf8P5WOlbMVELzu51p0gvPCVwOgxowDgT39+YgjervUXnH/uffc9OHf+aW887u1WBkiGB5x2 +2tlz5582d/5pdqmdMWO61bIkdSrbtu08dN7C444/w/75tredNnf+wkPnLbR/Njc1AsDCU46x5tRD +5y08dN5C+ygaM7oVAOKnPzMlsTmHLrCYtSq875y3z5gxffXqNXPnL4z7c8H558ZerXaLaTt83vkf +A4C3vGWhzIe98wqH4Beecmxi4BasXr1m5sxoRM5579uSI7Lw1HhEBh7GRx05335qRyQWJAafXWVK +vtNOO2X16jWHHXH60qUv273Cj2/9LgCcd/7H5s4/7dB5CzZv2VqxE5Xx/SfyMBQfCZaYuDEX2mnw +1reeWi15lqfGA0RlZ9TiB++aOmXcBeefu/DUsxGVXP994RHVLbfeBgATJrQDwCWXXLB82YvXX38z +AIwd08ZMF5x/7ne/e/NfNV5kTPLum3No2d039Pq8YeN2K3XYr7vkkgtK8omLqKw5Ip/3AWDhwjcC +wFVfu+7QeQvt4mAMD/L8gly+YL9o0aK7yJgq20BNo0H55SoJBslQYPtRT2/une86z65Cf/7TvVaY +kfkm/D+IVxWOGbVE3rLgYuGFH4Kv9WStCE5HAFi06OHFDz8JAL19+QqVcF9/cceuLstv39lZ9eCP +ls6f/exeRNXTm7N/fu7zX7eTedGih2PYrvjXX/8T+yv++6vXAcCEA8bEFgDb/ySmtLbYuAmj473j +ZZdfaeEdu7rsE84qk+zrvPM/tmNXFzOtXbMxaVWQ+TAUn9CBVfPJEUGMR2QMAFhDzWWXX2nb2bU7 +GpFDDpkRN/K5z3/Dvlm6dJV901CfLZ9dwEzls6tsDr/n7IvsDgBR2Swcq1evWbr0ZQBA1D/4wR3J +Dsv4/nN5GIpP6PXtjQmg7I05iOK/TDFhZ5RdQ371yx8vWvTwrt1dcv33nf/1r/9g99zMZsaM6c8/ +//Lzz6+2C6bVuL/wwuq/aryamuqSd5/S0d1nNUFDr8/G8OrVa6zK33PVjBnTr/radbFN4B3veNMt +t96mtGamJ598zrY2dkxrwuO05vMLmDn+og984Iwqb59KPily1vQmqpiQa9dtOeyI0237F5x/rnWU +kvkm/D+CT9oFaMgzVdVHwgtfxu/csQsAjj/uDbX84MsWvqeeXlrZfkIl3D66+Z67bkym/Kvuj9Jl +UaShqc6uQFa5+9ST99umrCbJbj2T24AktnzpogiDAWLXrj1x/7dt21GydZBd9Ldt2QmJFBClJ4HM +hyH5AeN4DX6QEYHyEYn4bdt2AsCY9tGJyRAnQ4Dq+dM+uvmeu25YsWxx+ewa6P8733We9VKwfDaT +BoD16zcNshOV8f2n8tXjNdimyt6YNdUTpT1b8qOB9edLX77Wvr/66uvl+v9VvPWoueD8c8eOaQOA +Hbs6t+/ssCJ9HADwV41X4u6r6M++rM9kExM1NmQPOKB99eo1d939+5J8Ahecf64VVxDVule2WbPD +okV3PffMA5d+4nxEGPz3IgBc960fxjJDsj/VfOlZQ9VTce7802KbQzKC0xi+7ls3W/M4APz7//uQ +zDfh/xG8k1xSk5MesUI8qC4yLLzwZfxTT6+wu7cxo1t37e7cl/YTczTarL3/fW//3GcvPe20s62C +NrFLU4gVKsDauUFi3jrz2Kbi/le/YqyUq6Hs9wLA6NEtvX3bbPvjxrUDwK6duwFUctG3LqAVTwKZ +P0PwVa8B/uWX18ycWTYiFe2PHt3S21ew/LhxYwBg185d1TaoOA+J7we2/fed89bPffbShaeevWt3 +J3Nydg1Mxf7IKlU237iG2y4P1n8Z338Mr4e832sM1pDjFQV/H3Xk/IrT4xiP66//2rvPuqjUglz/ +vfNxGMD113/NuvsjRgvsNVd/sRQA8LeNV+37ccj1GZ5//mUAOOrIQ+fNP+T662+JbQI/u+1XALDu +lS1xf5YufXnu/NPaRzdffvklNnupzWU0uA1Kv/Nd5/3qlz+28UI8iFt/7etJNX9v5fXs6y/ar7jg +/HOv+9bNMt+Ef9X56rrBsYdQch7HB0l44Qfje/sK1nq++MG75s8/KA481wrmz5/pODphGOWqN5Hh +1Vp1c/kCopo2dUIkpzq6iq/pFly25lrXkeuv/5rj6Or+x6v2lV+51mJaY8XvtSbja67+og2jqa9L +2WeDfa6Uf3XyuSXzYe989c475r9y1XXxiFS0nxwRAGioj0dkddzEWe95s23zkkv+xR6x+5J4dhUK +BYDE7NKqZDxlAKDy/uzu7AaA009fYGPyFMKtt1xXkvRkfP/ZfPnBKp65Qj3MTHbRiMfLvqxn18JT +jk5WLAGAaVMn2NSNdtt62GEHyfXfdx4RrO/KjBnTrfY9VsPPmDHdxgP8VeNl777TTjvF3n1aJe++ +va/PO3Z1AMDHPvbhC84/1x60QQgl+aRy/dmxq9OafY4/7g21fm+Z7LF23ZbY47TcAkBDrCcVjk8V +13P+/JmjRzXGH73jHW+yKiqZb8L/I3gHEkncLVchSVRIFcILPwT/qcu+cs9dE2fMmF7ttnHYEacn +nuJYarbSJdc+d//8p3vj9R0AnnvmgTmHLlBaV/DVWuTkwvrcc6tsa88980B8/KqvXXfHnfclV+2l +S18aDLvjzt+efdYZM2ZMX750QFV8y623Waf/kmW3Uq+Y6IbMn6F5WL50UfLP444/o6c3N8TADTEi +8Z9HH3VYnNPJuvRYz8hBZ9eziw6dtxAxMumo8v6Hobnl1ttsRZ64J6XAYhnffzYPAMmht3Omt68Q +N5fMy15qDZNaseQcWLToYTu4kVJX469++eNLL/38jl1dHzj34089ef+Pb/3uYUecbvMwyvXfF/7X +v/5DcheOqOLtuJXSy1rY23gZwxV331evuja+u4denxEVgI7Hd8euTgD1wgurrTRy6aWfj/tvE/ZX +K49qWixLeUgJUX3u89+oOLH8WtVYTyqqoFRcz4Nm1Xh0XnLJZ2W+Cf+P4FUyeqCaqEosCsILPySv +3n3WRVZ/FpOXXvr5444/IwzNYAtlss33vu8Se+4nPvG5O+68zyblgFp1QCtsqaX+DJhiEdW7z7rI +JlUY/EVDYMzwnrMvuvTSz8dHFp56doVpWA0iksh8GJof7DXYwMWKt4oROe20aETi1+Wf+VoMLDz1 +bFuQznYjnl2XXvr5O+68b+Gp7xmsb8n+X3vdzbG0cNzxZ/zudw8l+iPj+8/j9+U1ePvReMVz4Kqv +XffJT3/FxpDY1ze+9pnVq9c8+NDj1mpkZ9HVX/9s8iEq4zU0b8MA7IbbMl3dvfGR6lrgex2virvv +vvse/qvWZ+vof8utt9nNkK1CAKWyZdZV2mr9k0uKjTmu9XvLul30TfLb98rv9Xrefse9NsVQrGs4 +6ug3J31TZb4J/yryeOi8U5P+Q1VvqKYORnjhhRd+f+OtPWH+YadVmGXk+ggvvPDCCy98mTpjztwF +VSoWGixcEmqHXgkvvPDCv/a8FQCsz4ZcH+GFF1544YUfjFeI1XHANcPYyywLwgsvvPDCCy+88MIL +L/xw5JN+QlTBlbdVXV9AeOGFF34/4m1ebWNYro/wwgsvvPDCD8HjofMWDGYgGCTRMgkvvPDCCy+8 +8MILL7zww5RXpZKZVG0mqE6szkzCCy+88MILL7zwwgsv/PDloyxAZdIDE6DaB1FDeOGFF1544YUX +XnjhhR9mvKqWHiDhKhT5CdWqbi288MILL7zwwgsvvPDCDzs+tgBQVa31oYUM4YUXXnjhhRdeeOGF +F3748XHscIUMUXFytZAhvPDCCy+88MILL7zwwg8/XiFW5w+qsCao+DQLCC+88MILL7zwwgsvvPDD +lU8EARMzVAcTDBFhILzwwgsvvPDCCy+88MIPL74iC1ASgr25GQkvvPDCCy+88MILL7zww4yvrhsc +ewglbQfxQRJeeOGFF1544YUXXnjhhy8/YAGIBYghJImaAofwwgsvvPDCCy+88MILP1x4lYweqHgD +NRKLgvDCCy+88MILL7zwwgs/fHk1WOngUsmA5HtVkhmEF1544YUXXnjhhRde+GHJ45y5C6oMBJVV +A2paFoQXXnjhhRdeeOGFF174YccrxOo44BqFhSssC8ILL7zwwgsvvPDCCy/8cOSTfkKVVoPytqrr +CwgvvPDCCy+88MILL7zww4zHQ+ctGMxAMEj4MAkvvPDCCy+88MILL7zww5QfNAi4QoxIfCq88MIL +L7zwwgsvvPDCD1e+ohIwAShgAtzHGmPCCy+88MILL7zwwgsv/HDiVbX0AAlXofIEQ9VpRIUXXnjh +hRdeeOGFF1744cTHFoAKz6FKR6IqIUN44YUXXnjhhRdeeOGFH358HDtcIUNUnFwtZAgvvPDCCy+8 +8MILL7zww49XiNX5gyqsCSo+zQLCCy+88MILL7zwwgsv/HDlE0HAxAzVwQRDRBgIL7zwwgsvvPDC +Cy+88MOLr8gClIRgb25GwgsvvPDCCy+88MILL/ww46vrBsceQknbQXyQhBdeeOGFF1544YUXXvjh +yw9YAGIBYghJoqbAIbzwwgsvvPDCCy+88MIPF14lowcq3kCNxKIgvPDCCy+88MILL7zwwg9fXg1W +OrhUMiD5XpVkBuGFF1544YUXXnjhhRd+WPI4Z+6CKgNBZdWAmpYF4YUXXvjhyGvtvPXNJ8+YMcX3 +C0QE8hqpL6WU56VXr37lvvuXGENyvwgvvPAjh49iAGr6CZUfLGtFeOGFF3448inPOf9DZ3d07Fjy +6GOB7wOAQiBmZdUj9uTyP6sPCv864IkBALyUd9IJx7a1td9y68/9wMj9Irzwwo8QvqwOQGw+qHAb +GiSYQHjhhRd+mPFvPv2EhsbUvb+5P5VJa9SD8XJ8hBwPKfQLxTPOfHNfr//7Pzwq94vwwgs/Qng8 +dN6CwQwEg4QPk/DCCy/8MOX//f996Od33pUvFjUqqQsjPACEZNKe995zzvrO//1Y7hfhhRd+hPBO +hZSQhEqJRYeSNoQXXnjhhxHv+8VcoegoB7G2dqSuvm7iAeNnTJs6bcrkluZmQOzs7FzzyoY1a9dt +3Lwl35/bt/6owdoXfn/jNep8sRgEvtwvwgsv/MjhncRnAECICphgYNEsa6UqtZDwwgsv/HDiwzAE +YrsMVqyS9Q31hx0279xzzh41adQLe9a9tGfTqsIrDNDa1nDkUcee1/KBjvU7f3rn3c8uXVHI5QZr +v2rN3Ut/hH/NeQAFxGEYyv0ivPDCjxzeqWEgSCyakZ8QqmojgvDCCy/88OMBQGE1f8DECZdc+OED +50750ar7bvvtw+vzXSGQgxoAQjYOqMmZ5g9MO+WSKy565dk1N/zg1q1bNiedTCpW4Vr9IeH3T54Z +OHFQ7hfhhRd+JPADQcEVAQQVIkV5qlHhhRde+OHLcwU/fcbU73zz690TzMm//cR/vXC346aOHD31 ++PZZx7ZPP7Z9+nHts44cPdVxU198/s5TfvuJvgPhW9/4ytRp02pLF7VUMlbNLPz+yyuU+0V44YUf +UbwqVQoo+6A8jICqzxReeOGFH7Y8Jjd/B0w64H+u+vKvd//lbUu+hEqfMHZWW3299gAcwzoEbdAx +2sPmuuzC8XMCR71tyZd/3/PUN678wvgJ4ytW3qqFGIYGhN/feLlfhBde+BHCq5ITJJQ7DyWLBqv4 +tJLBVHjhhRf+9cBn6+s/+fF/e7zvxQ8/+e1D26Yc2DwqrU2rw+0uHODBRA8P8GCCB82Yn9vU/s2j +L/7A1BMnNY45/4lvPe2v+X8X/2u2vm7o9mOPlH3sj/CvDW+LAsj9Irzwwo8YPmkXoCHPVFUfCS+8 +8MIPX54A4KgjDhs3e8JFz/zfrJZx0+saRjvmAA/GedzuUptrRqVoVIpa3WByXeY/Dn7vnNapV8w9 +92Mz3jSlqf3fnv6/iYdOPnze3HiLWbP9Ch3zeee9f8mS+x5++LcPP/zbj33so61tLUPzsfV2H9sX +/m/kFcr9Irzwwo8oPmkaUOUQDS5DCC+88MIPW57YOoXXN9Sdf+45N63+XafpPqq+ZYwORznc4nFT +ips9aE6pJlc1uph1wvdMPXNa8zQAaPTq5rccNCPbuNvsuXntfR98/9l19Vn7vcmvjnLLDNKfcz/4 +0Y997NNnnfWOk048bm/8QGIH+9H4CeMefvi35533/n3k/9r2RyhfsgDI/SK88MKPEF5VnRnrSypP +rtCpCC+88MIPS16hXQcnTZxYP6HlTzsefGvL+FYPGjxu9LjeVQ3aa3CzjU59g1OfRveoUcceM/ZE +e/767h03rLxtSkq9pWXCkh0PNk8aNWH8+Or+VC++FcbZ7Tt2JNUzH/rQudYscN5574/58857f+Jg +1P7V37gSAC644NyHH/5tJpupbr/m9RmiP8IjqnILgNwvwgsv/OufL8ubZuWGCkkieXJSpyK88MIL +P+z4JDxr+rSXe9bOSG8/qsVJa25wsV6n6nQq62RdVMBhGPbXu5lTJp6hUAFAwQTfev62Sdm+lpR7 +dKs7w9u+unf9jOnT9rE/yWDTg2bN3LJl2xNPPsNM5533/tNPX/Ces/7lPWf9y+mnLzjvvHOts1D5 +QSsDqMuv+CIA3HLLbaec8vZ8Ll/d/r5fH+HlfhFeeOFHLK+qTQPVKRTK3wsvvPDCD1c++ZoyZeq2 +/o2tbnBgnWlxOauyb550ztTG2d35bYVgTxD2BKbn6DELmlKtlr/9pUVBuHZy3Zhmlydng1Yv2Na/ +aeqBB/41/QEAuO2nN331q1+49trvbt2yDVGdfvqCxx9/qrNjT8fujscff+r00xcAwOmnn/L44091 +7O7o7NgTH6x4VbdfEfy61/4IL/eL8MILPzJ5VeEFVPEGMflexUKG8MILL/xw51tbW/ywJ+2Aq2ls +uu+gloMPGX34aZPPPqTtDR5C1nFmtx5+WPvx9pTnOzY+sOmXU7KOo3BipphyIOton3paW1sHa7+8 +bwML8bkf/OinPvWf3/zmV974xjcAwIQJ43p6euxHPT29EyaMy2QzEyaM7+nptWfFBxPNcs32K5Le +7LU/wkdviOV+EV544UcUryoeTrEjUbK5IdIqCy+88MIPKz7hDQLgaHARmTGtCkeMOZKZs072bdPP +O7x9YVMqe8yENynlAEDBhDe/9PP5zSkHepV50lG9BEojO4oBMFl6vXq7GX+a3Lg/++zShx9+9JJL +/pWZtmzZ1tjYaMnGxoYtW7blc/ktW7Y1NjbY1koH+xM/DWu2X/57994f4aMjUQyA3C/CCy/8SOFV +hUYkhqBWMEG1BkV44YUXfljxA2tlR+eeZq8pZGDg7uL6F3bdS2wAwFXuGw9458mTLhidnWLhX637 +Y5pfbE/v8nCFMVt6CpuYyTC3eI2dezqTAQY10zLESWnsxp2ZM9lMa2vr7t0diOqBBx465pijWtta +WttajjnmqAceeIiZ7MG2UW2tbS3HHHPkAw88ZFvYumXbli3bDj98Xs32qwMehu6P8DV9w+R+EV54 +4V/3fKWgAIOWUFE1sywLL7zwwg8jPnnwlfWvjM9OZqjr93f6Yfeyndc/vP6bIQUAoJWe0DDLxv5u +6tvz4KabJqaezQUvAvgIbiHs6ve3E9eNr5u8bv36ZIafmv2pSAH0s9t+cN/v7gKA73//Vmb68Y9v +f+CBh+65+yf33P2TBx5Y/OMf346ofvSj2xIHH/7Rj26L27/hhh/OmzdnyZL7xk8YV7P9v7Y/wleo +0OR+EV544V/3PB46b0FFZozkUlhLO0LCCy+88MOU/9ePnPXzu37pKAUAc+YcctU3v/CDFZ92+QmN +yMy5Yveh4z6ycMoVrvLiU77+zE19/d84IJshcEpfRj5jgEd99OCrP/vp/1616uXq72WuoV0epJPC +v5Y8M4QUvPfsd/3gh/fI/SK88MKPEH7QIOCaarPYkCq88MILP5x5hag2bty0e9OeuaNO7/URwCBi +yml6cfcPF637im8Klnt657o1e26bmE0N7P4BAKHHh7mjT9+2sWPz5s2DtV+tXR4sCFX415pHAJT7 +RXjhhR85fEVsHCEqqPIfGjx1mvDCCy/8sOITr97evp/edudR7ae2ZI7LF0MTAgA63PTijh/f/9KV +uWKfH4R3rPzR1NTmwLhhyGHIYQjGhH3FsCV73BvaF/7s9p/39eWqg0prWV1r90f4/YeX+0V44YUf +Obyqlh4gsWhWxBTXDmsTXnjhhR8ufOIjZnryqafXPr/htKn/5nizSRUR2HFUJtW8tvenf9nyzfs3 +/SVvHhiVzSgNjoOOA45DIYauO+stUy5++bl1zzz7XEX7OGh/aK9hqcK/Zjyx3C/CCy/8iOLjJ2KF +bozKE6hVp7IWXnjhhR+mPMd8f3/uf6//Xms48fQpl2e8eQGFxAECpHTrqo47lm779Mz6fMgaAAGY +OCxSmHLmvWnKZc3++O/c+IN8fx6q3CvjP8v7o5J/Cr9/8QrlfhFeeOFHFK+SCdGgPD9afHItIUN4 +4YUXfpjymNz8bVy/6XNfuHKsmv22aV+a1HImQaNPRUNFAD061esqJjYhFXwKDDcd0HjmmTO+NIYP ++vwXv7x54+aaOpghEjMLv5/zcr8IL7zwI4RXNZ0my60JySo2ILzwwgv/uuHtkVUrV33ik5/Z9Hzf +W6d/dsHkL09ufk9dag5gs0/1AXmATXXenMnN71445cq3Tf3sxuU9n7zssy+/vHbf20/+Kfz+yBPL +/SK88MKPKN6BMhfJGiUzS9ZSVdWo8MILL/ww5InRsSkRlOUR1cYNm7561TVHHnnYOe87+y1Tj+8q +bu/1t4dUAABXZxq89ka3ff3aLV//znefe+65vr5chXV1kBKMA+0Lv1/zle5Dcr8IL7zwr3M+kdgO +FGJyEYTqworlplLhhRde+GHGO47Dg7iJ9/X1L1nyp2eeWTpx0sQZ06ZOnTKluaUZADo7Ote/8tzq +dWs3btzU19dfcyUdzO1ksJVX+P2KZwDHceR+EV544UcO71SdWRYslTy5QqcivPDCCz/seM9L1WXT ++aKvqnhL9vT0vPjCyhdfWBm3n1hVa/D73h/h90+egOuyac9Lyf0ivPDCjxxet4+dioilDxAAS29i +gwImDKRYOiK88MILP/z4lubGGTOnvPjCKuVoBFWqAJX0BMGSFjlqPxk0LPzrjA8p9AvF004/Zfu2 +jjVrN8j9Irzwwo8QHg+dt2Cw0sEVxoHSexJeeOGFH6Z8ynPO/9DZHR07HvnjY8V8EZXNAAnErBDt +/wdrP/mp8MOdt3G/Xso76YRj29rab/3RXYWiL/eL8MILP0J4PHTeqVBeI738TbVNAYQXXnjhhy+v +tXrLm06aOXOq7xeICIZ6cbk6ea8v4YcTrxR6Xmb16ld+d9/DxCz3i/DCCz9yeJwzd0HFyfsuQwgv +vPDCCy+88MILL7zww4tXFWmS7cG4rfJWAKrSKgsvvPDCCy+88MILL7zww4ivyJpcxpW3VV1fQHjh +hRdeeOGFF1544YUfZvxQQcC1rAlDGRSEF1544YUXXnjhhRde+P2cHzQIuGZzg8cWCC+88MIPP/78 +88856qj5YRgiADOXcqgxIBIzGXI9Z+XKNT/72S+7u3rlegovvPDCC/864a0AUPYxEwwSU1xb2hBe +eOGFH578l6/89LvOfBMM8jJEZKg/n//1b/5w/XdvzeeLcj2FF1544YV/HfAV5dMVAEDCVShZUx3K +wwiEF1544Yc77xd9AKBBXgjAAEqpd73zLeef/16bQl6up/DCCy+88MOdH6gYXGEpsH9WNJ2sMCy8 +8MIL//rgVemFpVeMaq20Uoh48UXnfeDcd8j1FF544YUX/nXAx7HDFTJEhdtQtZAhvPDCC/864MEY +E4ahMaamF5AVBvr6cz19/R+/5CNnnLFQrqfwwgsvvPDDndftY6cxU6zxit8kDmLpNGv+RuGFF174 +1wd/0inHdO7a/vvf//7pp5/OZrPt7e1JUim1Y8eOO++4Y9u2bQdOmeIH4eGHz3vp5TVbt27bP3/v +5APHdXX1xFhrS2Oh4Mt8EF544YUXvoJP2gWoKpNobRlCeOGFF/71wWvECQccsGnTprVr1z777LNx +IqD4tWrVqueff76lpbmxvi7luZlMevKUSX9zfy6/7KIVyxYvX7po+dJFX7ny0wdOGvvq/t6bvv/N +8897j+VPOvGoT33qIvsV+9j+We95y/Kliw6ZPV3mj/DCCy/865tPmgZUOUSDnCm88MIL/zrhDfHU +qVMnTZrkuu769et37do1cIJSQRC88MILzc3Ns2fPJgZDBABhaP7O/rz//Rf/+398/swz3/T2t536 +1/b/kNnTly9ddPllF9Xkn3zquaOPPszykw88YOnSFzZs3P7XXx+W+SO88MIL//rmq+sGxx5ClSfH +1cWEF1544V8nvCGl1CGHHAIAfX19L774YmITDFu2bNm0adPUqVPHjG4PwhAAiBiA/57+2Ncrr2xM +qmcuv+xiaxa4/LILY/7yyy4qHbwobv+6674MAB8896zlSxe1NDdUtL906QvTp09taW4AgKOPPmzj +xs32owMnjf/ud660Zgf7KaJ64P6ffvc7V77n3W9+4P7bTj7paNtfADjllGOXL11820+/feCksbb9 +2HBx+WUXxb/3Q//yLtu9FcsWn3zSMfbgpElj/+/bX16+dNFXv3J5U1ODzDfhhRde+P2TH3ABqllS +uOLkpMuQ8MILL/xw5wERAGbPnl1fX6+UWrlyZRAEcSKglStXFgqFg2bPdlMeEAPbNRT+nv7Y15FH +zt++feeSJY8z0+WXXXTqwhPPOPNfzjjzX05deNLll11snYUSB0+8/LILbQuXXvpfAPDT2+6eO/+0 +PV29Fe1v3Lh53Lj2Y485vKmpobmlefXq9bY/H/3oBwFg7vzTjj76sIULj497d8IJxyLi6W8+9+El +j9sjALBjZ8dJJ7979Ki2j370g1Y4SfbkissvBoCjj5rzqU9dcuONPzp03sK5809b8siTtsULP/pB +RJw7/7SjjzrstFOPl/kmvPDCC79/8qraNJDMH1SVWBSEF1544V9HPAPA6NGjJ0+ezMxbt27duHEj +ACBiPp9/4YUXGhsbZ06ZoXxCYzRxVrme0n9HfwAAbr/9hv/64qe+9a3vv7ByDaI6deGJTz713IaN +29dv2PrkU8+duvBEAFi44IQnn3puw8atGzZuf/Kp505deBJUvarbf+nl9du375wyZeJxxx7+yisb +rYTQ0txw5hlvevLJ55hp9eq18+cfEvOPPvqXu+/5fUW3V764ek9X75NPPXfUkfMBwHZv/Ya4JyfG +osLBB8+cc/DM+MSmpuiLAODll9fMn3+IzDfhhRde+P2TVxVeQBVvbDhceZJR4YUXXvjXCc/MxIyI +c+bMQcRisRh7Aa1Zu6anq/vNC09fU9xy1dM/vvSJ/7vsmetvWPWLuacc/KaFx/2t/QEAeP/7L/7M +Z77y9a//53ve/WYAGDt2THd3j+V7enrHjh3T0twwblx7T0+vbT8+mGifa7bf3d375FPPvfG4o6dM +mbh06Qv2o/Hj2gHgU5+6ZMWyxSeccGxzU0PMW0NHRbP2SE9Pr/107NgxPT3W1BD1pKmp4cmnVlz5 +39eecMKxt99+w3e/c+WkSWMB4IDx0RctX7roxBPf2NLcKPNNeOGFF37/5B1bFrhcXKBEAIGqliGE +F1544V8fPAMYQ6DU1KnT2traOjo6XnrppZNPPrmurm7dy+ve9JY3LYZVP3jsYVd79U4KEBZ1riyY +wiff//YPTxz7o5/8IgzNX9mfaId93/2PvO1tCy668F/u+cV927fvbGpqtHxjY8P27Tv3dPVu376z +sbHB9j8+mPgiHOz3Ll36wplnvAkArvrqt21/Xli5Zvv2nbfddvePfvLLKhsCl6uL4vxx6sBJE3bt +7gAA2xN7vLGhYfv2nd3dvQBw9z2/v/ue33/s4g9edNGH9nT1/OcX/qf6i2S+CS+88MLvn7wqdxgq +c1StDiaocjASXnjhhR/GPDMYY4qBX99QP2PGTGbu6OhYs3ZtV1d3+9gxD+Wf/+HGhw5qbZ/X1jqr +KTO90XvDmPavH3HBHVv+3Hu89/Y3n/LX98dq3LmluaG5pWXX7g4A9eDiR48+6rBJk8YeOGns0Ucd +9uDiRwHIHpx84PgDJ4096sj5Dy5+1LZgN9nz5h0y2O9d+eLqmIz78+DiR09/0ylx1tGq/pT5iR54 +4IRDZk8/4YRj//LnJ+25Rx912IG2e0cf9uDiR5P8U08vA4BtW22uoeiLJpWnN5X5Jrzwwgu/v/EV +gkIZN0QwgfDCCy/864A3JjTGkDHG0MxZM13PZeZVK1f17OneBJ2/3/LE8WPbZ9aZGRkzq44npwv/ +Nv1NH5r1lqsO//D/rvv1ke85elx729/Qnzvu+N4jS34BADfd9FNmuvqaGx9c/Ohvf/OTe3/zk0UP +PnL1NTcCqG9cfcODix+99zc/ufc3P1n80B+vvuaGuP3v3/TTQ+fMXrFs8SGzp1e3/8LKNSueX7ls +2QvJ/tx0089eeWXjvb/5yfKli777nSuHuD7btu1443FH3X77DX/842M/u/3XcfdsTx5c/OjV19yI +qN7z7jfbFEA/uOna39z7h5/d/mv7e2/8/s9eeWXjbwe+SOab8MILL/z+yOOh8xaUVwOACmtC1WES +XnjhhX998JddcfGZbz8dGJRWQRD85Mc/2rF9e8pLnXDiSX/2H9vE60e1eHUa63RdweRmNs1998wP +9/jFq5/7zvq+Z48YfWznXblf37t4f/u9NtHnnq5eGV/hhRdeeOFr8oMGAUNV4urSp8ILL7zwrxOe +DIchBcYEQeh43oyZs8gYv+h39O7JqB3z2/3j2084rv20fn9HBvGkCW8FwDtX/0bx5tPas5pWz54z +az/8vZ17uu3uX8ZXeOGFF174mnxFqiBCVFDlP1RhRBBeeOGFf33wxByEYRiawIRhEE6ZOs1LpYiI +KHRSuTHZ4tHtR5886YwTJ7zjxAPe2lY37umdq9ft+cOE1MYGXXDAZNIpuZ7CCy+88MIPO15VSw+Q +cBWqSGBXlUZUeOGFF34Y88zGMBmi0FCxWGxsbp598CGj29vbmkbVNzfsya/948ZrckHPCRPfMb/9 +1B7ff2DD/01MP2PMy7sL65vT7Vs2bZfrKbzwwgsv/LDjYwGgwj2ISlmiy5pOMMILL7zww55nhjA0 +YRgaQ0FIZOiNJ57yrveeM3fOERMbDt+d37m++1f3vnxZLuhGVA9uvN/4v1DICKqzsHVK4xuefnqZ +XE/hhRdeeOGHHR/HDlfIEGUn1xIyhBdeeOGHPc8MxlApD5AJwpCZEDHvF+Y2n9qaPQnA3dL32/vX +XPFS55rnd90yKlVHjPmwa3zjGRv/XHx26fNyPYUXXnjhhR92vEKszh9UYU1Q8WklnZnwwgsv/OuB +dz03NCYkCg2FhgxxEIZBaPJBwc/pt0z+Qkv2FAB3Q89vfrP6/fVqZUCmYLrGNZ4xm/7ltp/8olb+ +Nbn+wgsvvPDC7/f8ofNOjSUDZqjOEzRIsiHhhRde+GHPHzJnRn19PZVXwopOMKaxvuEd716QnrZ5 +fdfD/f4GhU6dO3Fa6+l7Xmz7/g0/e3nNBrmewgsvvPDCD0c+KQBUQBWGgyG+SXjhhRf+9ck3NdW/ +8egj5h42q/2AZiLYvqlz+dJVf37s6b7+nFwf4YUXXnjhhymPh847tfxMqsUlDQdKeOGFF1544YUX +XnjhhR+m/IAFID5tCEmipsAhvPDCCy+88MILL7zwwg8XXiWjByreQI3EoiC88MILL7zwwgsvvPDC +D19eDVY6uJQoNPlelWQG4YUXXnjhhRdeeOGFF35Y8jhn7oIqA0Gl21BNy4LwwgsvvPDCCy+88MIL +P+x4hagqTANVRQSg2rIgvPDCCy+88MILL7zwwg9HPuknVGk1KG+rur6A8MILL7zwwgsvvPDCCz/M +eDx03oLBDASDhA+T8MILL7zwwgsvvPDCCz9M+SgN6OA5g/5/e3ceH1V19w/8e85MJhtZ2cKWsAQw +hCxYEkVNAllEa8Ei9KcIaH0qUrHVWpb2qUsrLnXp44JYithXayFgn8elBh8FQxRCRQ1tCWETgkAC +whjINpPZ7z3n98dNJjd3JgG0y3PTz7x48bq5875nzj1zX8n93vM95/QoLpTBw8PDm9f/4Iffmzx5 +oqoKRiRlcJgUESMphBCq1Wr7/HjDa6/96YvTdrQnPDw8PHw/8T1XAhZEnKQgdpFrjMHDw8Ob2P/y +qZ/dMHMG9fJShRCqcHk8lVXVa174bWubE+0JDw8PD98PvGGKUE5EpEsV6jnBUOg0ovDw8PAm9mpA +ISLRy4sRSSLO+cyy6XctWWSzWdGe8PDw8PD9wHevGGzoKeicJbRn0foVhuHh4eH7h+e9vywWzogR +0YL5c+5ashDtCQ8PDw/fD3xw7LAhhjCkDYUGGfDw8PDm91ISkd/v93q9Xq/X4/EEN7RtRmSxWLxe +n6PDtXD+3Nu/Ow/tCQ8PDw9vdm9ljOtTgvQF6ZcWC44egIeHh+83nlkYEW3ZsuXAgQM2m83r9aqq +yjknokAgkJqaeuedd9ps1ijFFggoXtV3881zvjjz5fb3d6I94eHh4eHN6/X9AiJkJtHwMQQ8PDx8 +f/GSiHw+n9Pp9Hq9V111VWlpaXFxcXFxcWlpaV5eHuNcSrLZbJGRETabLTo6Ki115Feuz8oVS/bv +q6qrrayrrXxs1fK01JR/xPmuXLGkrrYyM2Pcv7b95829/v2t5fv3VZVvXP3N6wovqfzpRXl1tZXz +5l6P6xkeHh7+H+H1XQO8JxK9HAkPDw/fbzwjIs45Y8xmsxUVFU3vepWUlEydOpUzJoQqhBCSBEki +UoT6Neszf/7d9973wOzZM791Q+ml1j8zI72utnLliiUX8kTE/oXtX1SY9/BDP3777feyc8teeGH9 +VVfnX2L5LLiF6xkeHh7+7+5D1w0OZggZDw6uLgYPDw/fX7wMRgJSSp/Pp+0MTgQkZfd9NEkpROcB +X7k+2uvEicaez+zv1roFVq64K+i1B/n6230i8dxzjxDRwgXz6morkxLjLvJ8H3t0ZV1t5WOPLt/2 +3sbbFs4hohnTr6yrrbzn7oUbN6yuq628fdEczXf1UVRpH6qV//7W8l+veWzuTde9v7W8qDBPKzot +NWXN6kfqaisff2xlUmKC4XyvuOJyu/3LTZvfllLU7Nn/4EO/0jpA6mor9++ren/r5ulF+UE/vSh/ +U/ka7WSD5RPR0CEDyzeu3r+v6vZFc7U9qboPTUiI00q4fdEc7di62srpRfm4/uHh4eEv6LtTgMIu +KWw4WJ8yBA8PD29+z/Tb2o+MMW0KICJShdoZIkgi2bXxNeqjvaZOzbXbm3bs+ERKsXLFktKSwlmz +F82avai0pGjliru1e2XdzsKVK+7SSrj//p8T0cby17Nzy1rbnL2db3CPlGLe3Otnz5p5730PVFRs +GzZsqO6MadKkCT/84QMVW7bdeutcIlq54u6S4gLdhy4Jll9QMI0xdu11C3ZW79HOd/HihYyxrJyS +/LwpJSXXGM63tKSwvv54Vw072+fpZ9Zl5ZRk55adO9+8ePFCzaelDv/Zf9534kRjdm5Zdm5ZV/lS +q97Sex6o2LJtwYJ5Wvl3LV7IGMvOLcvPm1JWeg0RXZGfs2zZ0nXrXtUO/3DHJ7j+4eHh4S/oeWjX +gP7vR8jEogQPDw/fb3xXB0DnHafX6/X5fNoUQD6fTxIRMa4yq8qYqlqEjOERNmb5GvUhItq8ee3P +H172/PMvHzx8jDFeWlJYs2dvQ6P9ZMOZmj17S0sKiaikuKBmz96GxjMNjfaaPXtLS4pCMnz6Ol/9 +b/wZ06+025t27Kw5cvSkzksi+uDD3a1tTofDOWzY0KTEuNKSwj1/qW1otGsfWlJcEPTV1btff+O9 +YPnJSQmzZ82sqdnLGK+vP5abm2moT0rKkNY2R2/ts2/fwazJGdoj/Ly8KSkpQ95+e2vP9mRE9OGO +j9vbnQ6HMyVlSFJiXEJCnPahRHT0qPahIhjJZGak43qGh4eHv0hvDWYBhV1DWHtW1LXdPYgYHh4e +vj94KSVJIrJYLH6/f82aNdrNsRIITJg4ccH8BVJR9zQdqvpiX6PbzjmbEDdqwjdSF3Z8a+N/v/OV +6kNENH/+3WlpI5588sHomOg33tyakjKkvd1BRIxR8GZ32LChDodTKz+4s6W1XX/73tv56n/LM8bH +j08/evSYbmf3Hba+AyQuLjYlZYjD0bnacTAq0D60S3ae3fBhQ4lo2bKly5Yt1cIDQ33s9qakxHhD ++xQV5v2/78wqKJimr2RMdBQRuV1effmGBC3tNXJ4jw/dtetjIl6zZ/8jq/7r5w8vKyiYVl29+5lf +rW1otOP6h4eHh+/bWw1/nLoSiXoUZ4gh4OHh4fuHF0IKVUopiaTFYsnLz4+OihJSqqpITkh0up3P +HnjtD6c/irRGDrBGEqPKlsNe1fvja7/14+F3vPTrDV6f/xLr03lH++7WnTfcULzkrkVvvPmu3d6U +kBCv+fj4OLu9qbXNabc3xcfHafUP7tR9EOvjfHt2+Ir6+s+TkpOIiDMK3qaH3mE7nS7tQ7UDQz5U +6tvz4OFjdntTefnrr254I2wf9Paq6oUL5iUkxLW3d1f7gZ/96OjRY9m5ZStXLFm4YJ5WH7fHS0Sx +A6LDfV9M36eh+9C39Of7xptb33hz6z13L1yy5Pa2dueDD/0K1z88PDx83573TBjqkagaOpggJMEI +Hh4e3sReEqmqKqWUUloslmuuKZg+fXrxjBllpSVZk7NW7f/d+rM7MwcOyxmYPDEhOj3edsWQoU9+ +447Xvvjo1GTvovnfvvT6MO22OykxLjEp6dz5ZiK+vao6P29KampKWmpKft6U7VXVRELbOTpteFpq +St7U3O1V1fqb4JyczD7PV//gnB86dDRrckZmRnowUz+0PtqP2oempaUYPlSzhvbcXlV97cwZaanD +w56vlqizYvkSIkpNHaoNKU5JGdJ46gwRpaWOCNI9e/ba7U2zZ8/s+/sSkoIfmtpz+lTN7/nLPiI6 +e8aO6x8eHh7+gt4QKPRwfQwmgIeHh+8HXlWFoqpCdt4Du91un9/v9nj9Hf6Kk9X/07T7uiEjx8co +46PVibFydJT3++kzb594/ROX/8cLx98ePX38ZeNHf4X6vPbab3bueJOI1q/fKKV4+pl126uq36nY +sKViQ+X2nU8/s46IP/X02u1V1VsqNmyp2FD1wa6nn1kbLP/l9RuzJmfs31eVmZHey/n2mENz0+a3 +d+36ePPmzhJcbi8R149lDvqnn1m3vWrnlreDH7oubDaOdr7r1286caJxS8WGutrKl15cZTjfD3d8 +surRZ/PzptTVVr7y8rMH9h8mop/+9LGS4oKXXlzV2uYgosWLb5VSNDTan/jlC2PGpGrT+Mybez1j +3dULVkDrLlj38qYTJxrf6fpQIpo393ptaYVX1j9bsWXbxk1v4/qHh4eHv6BnWTnFhrTR3nqTdaED +PDw8fH/wD/3i/pml099+680DB/bHx8d/9z++l5iQoKpSquKJw0+e8XwxKjou1kqxlliv6p6QkH3T +hP9w+H1P733xZMffvjF4muWDqFd+/z9mOd8Z069c/cLjdy7+cc2e/bge4OHh4f+dPQ8ZdBU+jNC9 +Cw8PD99PvFCloiqSJCMSUqpCVVShKGqrz5Fobbw6WblmaMHVQ8tc/i+jGSsa8U0i9sf6Ci5Plw2N +sYj6tHFp/8fPNzMjfXpRvjb7/uoXHl/16LPBu39cD/Dw8PD/tt6q7x0gEoxxkoJYj0FdwdAhZGoh +eHh4eBN7KWUgoKraUr9CKIoIqKoUUlDAQsqgSMpPyRsUM9rCxICI6IGxw/7SVH+8ddvo2JY4S4xL +iYyMtP0fP9+Dh47SYZ6dWxb6KAjXAzw8PPy/reeh0QPpUoU684TCrTYMDw8Pb3YvhaoKYY2IiI6N +iYqKUoVQFMWvBGIsAxJsg1s8n+9qfMYdcBSMujF3aKnD73+/Yc2oqL+q6tHz3pOJUUObm1rQnvDw +8PDwpvPBAMCQHmQMKQxHwsPDw/cDLyQFFGXaNYWL7rjzpptvjYyM8gcURREWaRsdl9/sazrZ/qct +R1e4A+2M8e2NW1X/m5xJRrzFe2ZM/BV79x5Ae8LDw8PDm84Hxw4bYogeB4cLMuDh4eFN7yWRqgqL +xRphtUVYIxRVVVVVSNXldWcnliZHFxFFfNHxztZjPznScuzAud8NiowVknmUtuHxs5rrLFU7PkJ7 +wsPDw8ObznPGQucPMvQm8OBhGoCHh4fvH97CLYqqBhTFryh+RVGFVFRVUYVX8fndlutHP5QUM4Mo +osFRUVE/fwA/HBCqV20bFj8rk93235u3qKpEe8LDw8PDm89n5ZQGIwMpKXSeoF4mG4KHh4c3vb/q +6m/ExccJIUO8VIVIiosvLsu3pJ442fahy9/AmTU2YtS45Gvdnw8vf/WtT/bsQ3vCw8PDw5vR6wMA +AzJ0HPTxSfDw8PD9048YPrRkxjUTJo5KGBIrBbWddx09dPK9bR+cb2lD+8DDw8PDm9SzrJzSnkeK +cE7fccDh4eHh4eHh4eHh4U3qu3sAgof1EUmEDTjg4eHh4eHh4eHh4c3iuX70gGGDwkwsSvDw8PDw +8PDw8PDw5vW8t6WDuyYK1W/zrpgBHh4eHh4eHh4eHt6Unk3OLg7pIDCmDYXtWYCHh4eHh4eHh4eH +N53njHFD10DIIgIU2rMADw8PDw8PDw8PD29Gr88TMvYa9CwrdH0BeHh4eHh4eHh4eHiTeZaVU9xb +B0Evw4cFPDw8PDw8PDw8PLxJfa+DgA1hhO5deHh4eHh4eHh4eHizesNKwIKIkxTELnKNMXh4eHiz ++gGx1tjYaEWRfUysHFJ8jz1WztraO7w+ifaEh4eHhzeRD7MQmP7HsDvh4eHh+4H/0b2LZs26Xggh +pSQiKSXTZkrr2tb2axvB/3WFSJvNtnbtb//79Uq0Jzw8PDy8ibw1GCv0jCE6fzQUp19hGB4eHt7U +3uvzHThw4JVXXlEURVGUqKio6Oho7aZfu7/X3+sTkRBC2xZCqKrKOb/vvvv8fj/aEx4eHh7eXN7a +FRMY4gZu6EcICSzg4eHhze0ZMYfD8e677xYUFCxYsGDr1q27d++22Wzavb724pxr9/3B/7UAIBAI +MMYWL15MjKE94eHh4eHN5bnWLxB8U19Q1z7edVgngIeHh+8HXpKUUo4cOfIXv/jF1VdfnZCQEB0d +HRMTExMTExUVFRkZGRsbGxkZGRUVZbPZonSv6OjoqKiomJgYxphQVbQnPDw8PLy5vL5fQPR5JA95 +Cx4eHt7EXorOZB6n0+lyuQ4ePNj5kEQIVVVVVVUUJfi/9goEAqqqaqArR4hdfH1Wrliyf19VXW1l +XW3lY6uWp6Wm/N3P97u3zdXKv+fuBUSkfcTkSRPqaitvXzTnK5e/csWSutrKpMQ4XD/w8PDw/cDr +uwZ4TyR6jyHg4eHhTe+lFBaLxePx/PKXv4yMjFy+fLkQoqOjw+VyOZ1Ov98vpdRu92XXSxsKLKXU +ogIpJZG81PrMn3/3vfc9MHv2zG/dUHqp9c/MSK+rrVy5YklY/83ripYtW7rq0Wezc8u+bGqZXpTf +0GiXUhw8fDQ7t+zVDW99jfaUuH7g4eHh+40PXTdYdCHjwcFpROHh4eH7gRdC+v3+pKSkOXPmJCQk +eL3eQCDw7W9/e8WKFQ899ND06dN9Pp/hxlcIoSiK2+12OBxOp1MbD3BJ9dFeJ0406h/PrFxxt/bY +fuWKu4Jee+iuv90nEs899wgRLVwwT3sebyh/8ODkYLGvv/Hejp2faG9lZuh7AAQRzZh+ZV1t5T13 +L9y4YbX2llb+Y48u37+v6rFHV76/tVzvdfMjdZ5FWmrKmtWP1NVWPv7YyqTEBCJ6f2v5mtWPEInM +jPT9+6puWzhH87cvmqOdSF1t5fSifK190lJTXnpxVV1t5WOPLu/qWBBaCfPmXv/+1vLpRfm4nuHh +4eH/Qb47BSjsksKGg/UpQ/Dw8PDm9ywQCHz22WdvvvnmCy+8YLVao6KiOOecc8aYdter/e/3+51O +Z3t7e3t7u9vtDgQCWjwge3atXrA+2mvq1Fy7vWnHjk+kFCtXLCktKZw1e9Gs2YtKS4pWrrhbSxbS +7SxcueIurYT77/85EW0sfz07t6y1zWko//Bnx4jo4Yd+rN18X6g+NGnShB/+8IGKLdtuvXUuEc2b +e8PsWTPvve+BioptKSlDQr2+PRcvXsgYy8opyc+bUlJyTbA9u8dYMyKiK/Jzli1bum7dq9m5Zdm5 +ZR/u+ER7d/HihUSUnVumO5wTUWHhVURUNnP+jp01uD7h4eHh/0Geh3YNGCYKDdmGh4eH7w9ee9fn +81VUVDzxxBNNTU2c882bNz/++OOPP/54dXW1zWZTVdXlcrW1tTkcDrfbrXYN+dVPDHop9SEi2rx5 +7c8fXvb88y8fPHyMMV5aUlizZ29Do/1kw5maPXtLSwqJqKS4oGbP3obGMw2N9po9e0tLiijkFVp+ +zZ599973gN3etHz50pdeXKVL2Tem8WjbH3y4u7XN6XA4hw0bmpQYN2P6NLu9acfOmvr6k2G96NqR +nJQwe9bMmpq9jPH6+mO5uZnh0oS623/SpAmZGenB9klKjJs9a+ann/6NiOrrP8/NzQyey65dH7/+ +xnu4PuHh4eH/oZ73tnSwtqE9wuna5sEgAx4eHt7sPpjAExMTExsba7VahRAWi8VqtVoslkAg0NLS +4nA4PB6Poij6NJjgtpTaTEIXXx8iovnz7/7pTx978skH5950HRGlpAxpb3do3uFwpqQMSUqMGzZs +qMPh1Oof3KkrX/Z2vjt21nzn5u9XbNlWUDDtzjvnB3/ha7XWeWY4o7i42PT0sfX1n+tu9I2ed33i +8GFDiWjZsqV1tZUFBVclJsTp2kT/zInX7Nn/yKr/KiiYtnnz2jWrH9EGJQ8fNoSIli+/p662sqBg +WlJifNg/VLie4eHh4f9Bnhv+OAUTifTFhf5qhoeHhze7l0RSSi3bR/tfS/Vxu93t7e1OpzMQCGgR +gmEB4OCDfymlEPJS6tN5Z/3u1p27du1ectciImG3NyUkxGs+Pj7Obm9qbXPa7U3x8Z13/MGdug9i +fZxve7vzwYd+Zbc3lZUWdT0TYsE/AL31CTidrmPHjicmJQZv9EO9Fhgwxg8ePma3N/3Xf/06O7ck +O7fsB/f+3JAjpK/PG29uzc4tW7fu1cLCq7TMn4OHP+86vCw7t+yeHz7cM7DB9QkPDw//j/W8Z8JQ +dyIRhRtMEJJgBA8PD29WL7qm8uSca7lADofDkOoT+gquB0ydYwDEpdSns98gKTEuMSnp3PlmIr69 +qjo/b0pqakpaakp+3pTtVdVEQts5Om14WmpK3tTc7VXVWgnanXdOTmbY8r8z74Z5c6+XUmgP2rdX +VRsy+Hurj/bjoUNHsyZnZGakB3P6DZ7rniFtr6q+duaMtNThwfM9d755/PhxmRnpd9+9KLT99/xl +HxGdPWPX3uo6PCVcfXB9wsPDw/9jvTFQ0Ls+BhPAw8PDm90LQdqNvtfrdTgcHR0dfr+fiCwWS2fG +C9fKlMFbZFVVtZ3dCwN39gBcQn1ee+03O3e8SUTr12+UUjz9zLrtVdXvVGzYUrGhcvvOp59ZR8Sf +enrt9qrqLRUbtlRsqPpg19PPrA2W//L6jVmTM/bvq8rMSDeUX1X157FjU/fvq9pSsWF7VfX69ZsM +g8B080BLQzoTEW3a/HZ19e7Nmzs/y+X2SimSEuPCjQMW69dvOnGicUvFhrraypdeXMUYX79+Y0rK +kM2b1+7ZUxvE8+Zery198Mr6Zyu2bNu46W1tf8/DH8P1CQ8PD//P9Cwrp7iXR0TBZYRDHx3Bw8PD +m94vWvit4cMG/+QnPxFCREREBB/wB2/39Q/7VVXVFgHQdnq93tjY2N/+9rc7du6u3P6XftY+04vy +V7/w+J2Lf1yzZz+uH3h4ePj+53sdBEwhE1d3vQsPDw/fL7xk2pq+2iN/IYQ+418fCWg79T92rw4m ++k/7FBXmabP1r37h8VWPPluzZx+uH3h4ePh+6a363gEiwRgnKYj1mFg0GDqETC0EDw8Pb1YvhKLP +9Q/m9gQf8+sf+ZNu0s/gu9oYgH7TPjur92TnlOD6gYeHh+/3nodGD6RLFTKMKQ6ZRhQeHh7erF5R +FFVVtTt+bSN496893Ne/q88LCkYFgUBACyHQnvDw8PDwJvLWYIe2YX0cQ0ihBQ06Aw8PD29ur6qq +z+dzOp2cc4vFYkjv0TaCqf+GTgBVVd1ut6IoQgi0Jzw8PDy8uby1qzugxxs9hxGI4GyhoQAeHh7e +pD6gBAYNGrR8+XIpZXBCTP2U/0II/Y96IISwWq02m01VFLQnPDw8PLy5PMvKKQ07OjhkpwgpFB4e +Ht7EvuDqSXl5U1RVBu/spVTDRgJhX1JKi8VSWVl94NBptCc8PDw8vIk8y8opDe6Ski7iSIKHh4fv +B97vcxOp+qFQPbyg0LekEIadUnBbZDTaEx4eHh7eRF4fABgQGeYT7f2T4OHh4eHh4eHh4eHN4UPX +DQ4OE9aPLA7uFPDw8PDw8PDw8PDw5vXdPQDBAKKPSCJswAEPDw8PDw8PDw8PbxbfvTZYyCICRGEm +FiV4eHh4eHh4eHh4ePN63tvSwV1LBui3eVfMAA8PDw8PDw8PDw9vSs8mZxeHdBAIw3CBsD0L8PDw +8PDw8PDw8PCm85yx0HHAYRYWNvQswMPDw8PDw8PDw8Ob0evzhIy9Bj3L4vrj4eHh4eHh4eHh4eHN +6FlWTnFvHQS9DB8W8PDw8PDw8PDw8PAm9Z3TgPY+Z1CP4kIZPDw8fH/ygwYlZUwcM/Gy9LFjRiYm +JjBGLS1tJ06c+uzI8UOHjre0tqE94eHh4eFN73uuBCyIOElB7CLXGIOHh4fvJ35gcmLxjGm33Dwr +adDQ+s+bjzc2t7f7iGRCfNSYtIHjxw5sbvritT++8+GOT1rbHGhPeHh4eHjz+jALgel/DLsTHh4e +vp/57KwJ9/3wjlGjJ7zxzv53th9pOueWTFotnIgURTDGhg6KuaFswk03ZJ04dmjNSxsOHKxHe8LD +w8PDm9V3BQCGzCFjIlHfXQnw8PDw5vXTrsx98on/3Hu4ZdXqHS1t3tSRCQNibT5VahMnE5HNwl0d +vsZT7QOToh+8tyhr/ICfPfjMpzV1aE94eHh4eDN64zoAF5xGtI+YAx4eHt50Pjs7Y80Lq97fffqB +53eOTBmQkhKvSIqMtOZPSrFaOTEW8AU+3vuFsLAISfZzzlNfOB6/f8b0vCH3/uiRAwePoD3h4eHh +4U3nWVZOadgUoj5CCnh4ePj+4ZOT4l949uFzngGLH3nvsrHJMXFRAUY+QcMGxa77cWlkhIWIvE7v +HT/7U2tsZJQkGyNnu+fIsdb1j1wXb2le/pMnW1rb0Z7w8PDw8ObynLrXEBYhM4l2HklEPYIGeHh4 ++H7hy0oLho4a8+DaXSNSk6KSYh2Mua0Wt5UrFh5h6TQ2Cxecu62WDit3EEUlx45IS3hw7a4RYybO +mHHlpdbnu7fNrautrKutvOfuBUSUlpryL2yflSuW7N9XlZmR3rfPzJhQvnG1Vu3kpARcP/Dw8PBm +9/qYgPdEopcj4eHh4fuDHzQoacGtN5a/d+iUOxA/eICTUcDKhdVitVnbAuKldw/85t0Dv3n34Jqt +hxyxkRarRVgsgQiLk1HCkLhGt/+1bYdvveXGgcmJF1+fb15XtGzZ0lWPPpudW/ZlU8v0ovyGRvsl +1T8zI72utnLliiV9++lFV45OGz69KD8pMS41dWhmRvrXac8bvlWSNTlj1uxF2bllrW1OXD/w8PDw +Zveh6waLLmQ8OLi6GDw8PHw/8FmTx8clDi6vaRw+KjFg5cLCycqJc2a1SM5Otbgam12NzR2n29xk +s3KrhVm5tDBh4T4LGzEqqbymMXFQSkbGmIuvz+DByUH6+hvv7dj5CRFtKl9TvnGNtnPuTdeVb1yt ++dsWztEeutfVVk4vytfKf+65R4ho4YJ5dbWVSYlxWvlpqSm/XvNYXW3lY48uT0iII6LFixfefPON +q194fNmyJa+8/Oxzzz2idTWEtk/PsCG/rrbyB0tvK9+4pq628vZFc6QU8+Zet3DBPCLaUrFB2xPs +PdDq9pOVd+N6g4eHhzeX704BCruksOFgfcoQPDw8vKl9xsRxB042f85tscOSBBGzWpjFYrVZfMQi +IyMeuXnqE4uueGLRFb+Ymxvt9HktzBJhYVYrs1gEY7HDko5z2+GG1ssmjLv4+hz+7BgRPfzQj29b +OCfod39UkzU5Q3tIXzzjqrfeeo+I8vOyli9fum7dq9m5Zdm5ZR/u+ETz99//cyLaWP669jBeK3/x +4oVElJ1blp83paz0Gu3DcnIy1617dfasmeXlrxNR5qSJYdsn9AHSpEkTfvCDByq2bFuwYB5j/PU3 +tm4sf52Iiqbf9OqGt7T2XLnirtKSwlmzF31r9qLSksKePRK43uDh4eH/r3se2jVgGEQcsg0PDw/f +H/yYMSMPn3EoNmtEYpyw2ZiFS86/dCsHmlwHz3tUKbsOYWccvv1291lXgCyccS4jbTwx1h9hPXzW +OXbMqIuvT82efffe94Dd3rR8+dKXXlyVlBjHGN/zl31ElDFp/KTLxo0fP66q6s9EJKUkooyM8Vpg +EHapF63MpMS42bNmfvrpXiI6evRYbm6m9u5bb7134sSp/QcOv7rhrXPnm3tpHwqt9oc7dre2OR0O +Z0rKkKTEuJ6f2XlUaUlRzZ69DY32xkZ7zZ69pSWFuN7g4eHhTeS5IQvIsKFNg921zYNBBjw8PLzZ +/cCk5BZPwGLh3GqxDoz3MfbZOdfh826PT1U5l92/K6XKmNevHjnvOdjk9jJmSY6zWiOsEZYWTyA5 +KeGS6rNjZ813bv5+xZZtBQXT7rxzPhHV7Nm//8DhOXOunzFj2ttvv9fS2k5Ee/5yYNWjzxYWXrV5 +89o1q/UJPBQMD7Tyhw8bSkTLly+tq60sLLwqKTFeY26XW0rZ8y4/tD6GiELzLPhBcXGxPUOFzvZM +SRnicDi1t4KhAq43eHh4eLN4bvhjEEwk0hcXGkPAw8PDm9+TJGKccyKfJWK/EtESkGSxUISVWzlR +990zs3CyWcnKWwJ0QI3wWSK4JGJMEmPskuvT3u588KFf2e1NZaVFmteygG688fodOz4J+tffeC8r +p2TdulcLC6/Sknx0H8SC5R88fMxub/rVr36dnVuWlVNyzw8fDmEU2kfc846fDD5onE5X2Pa025vi +4+O0842Pj7Pbm1rbnLje4OHh4c3iec+Eoe4/EhRuMEFIghE8PDy8WX1LW2vygChFFYqUR1rcXsH4 +kIEsYQCzRZDVQqS7e+acRVhZQhwfnOQV7EizS5VSUdTkAbaWlvaLr8935t0wb+71Ugrtif72qurO +m/hDR4movv7zg4ePGeqvJQidPWPX9mi3+zk5mfryt1dVz7xuRlpqSrjzDXuvL/R3/IYwoI9XsPzt +VdX5eVPSUlPSUofn503ZXlWN6w0eHh7eRN4YKOhdH4MJ4OHh4c3uT5w4PXFEfIQUp53+tg6fJEmM +WGwMS0qg2JjuAEASRUWypEQWE63dLre5lVNOb4QUE4cnHG84ffH1qar689ixqfv3VW2p2LC9qnr9 ++k3a/h07a+z2pv/936qutP6EuTddp82x88r6Zyu2bNu46e1g+S+v35g1OUObv1/z69dvOnG8cUvF +hrraypdeXBU2vafrXj9s+7DQGYE6/1DI8GHA08+s3V5VvaVig3YiTz+zDtcbPDw8vIk8y8op7rka +gP6JkQj3h0TAw8PD9wNfMmPaw6t+dtWvdp5UuLRYyMJJShZhJUGpyTF/XTwlLtJKRO429/THPqhL +TCApSEgpBAnBVHWMVey8/5pVDz9RvesvX7M+8+Ze9+1vf3Phonv/XueblBinTdivbSQlxoVdsRjX +Azw8PPy/p+91EDCFmyhaSgEPDw/fP/z+g/Wu1nOLLh8hHF4iSaogSSQkqZKECP0NSqqUUpCURCTa +vQsvH+E8bz94+NjXrE9SYtycOd+sfP/Dv+P5anf/wY2uCUP7Kj/Yn4DrBx4eHr7fe8NUQYIxTuHm +fOjJ4OHh4U3vz51rKd/8pzsKxw5PiiSPn4QgKaSiSEUhxS9URVVVRVGEUKSiSkWRqkqKQopCbt/w +ZNsdhWM2vbal+Xzb16xPa5tzwcJ7X93w1r+2fQ4ePorrBx4eHv7fxPPQ6IF0qUKGMcUh04jCw8PD +m9hvfb+6+fSJX38nixSVFEFCEnFiRIxHRtgsFovVao20WlkwUZ4xEkSKunZe9pfH67dX/RntCQ8P +Dw9vOs+yckrDZQ4ZE4lC8ofg4eHh+4PPzc148flH3jzQ+v23DhHjFBVBTEZF2uZfNjCSc2IU8Cr/ +U2d3RFhISPKrpCi/uWnSTRnx99z/i7q6I2hPeHh4eHjTeTY5u9gwjWjIQAFhWDEeHh4evj/5gmum +/vLxn+xq9Nz39qFTzV6KtBInCkiSkhgjRmTjFJDkV9IGRj1/46SrRth++sBTuz/ei/aEh4eHhzej +Z1k5pWFHB/cRUsDDw8P3M3/5lMwf/eCOIeMm/v6T03/Ybz/R6iWfqo33JcbIxscMjL4tO+X2/JFn +jx56/qXf1+07gvaEh4eHhzepD6YAEZGQki7iSIKHh4fvf37QoKRrS6++5Tuz4oeOqDvrPHrO1eZV +iSgx2jpxUMzkYQPa7ac3/bGiqurj5pY2tCc8PDw8vHm9PgAwILpQmhE8PDx8f/NDhyRnTkrPmDhu +zJhRyYkJRKy5tfXEidOHj3x+4FD9uXOtaE94eHh4eLP70BSgsMMFggcLbQkxeHh4eHh4eHh4eHgz ++u4egOBhfUQSYQMOeHh4eHh4eHh4eHiz+O61wUIWEegsJWQbHh4eHh4eHh4eHt6snve2dHDXkgH6 +bd4VM8DDw8PDw8PDw8PDm9Ib1wHoiiH4BXsW4OHh4eHh4eHh4eFN5zlj3NA1oJ9PtGcp3R0K8PDw +8PDw8PDw8PBm9Po8IWOvQc+yuP54eHh4eHh4eHh4eHgzepaVU9xbB0Evw4cFPDw8PDw8PDw8PLxJ +fec0oL3PGdSjuFAGDw8P35/8uHGjrp72jWlXTklLG2GzRTJGHo/3xMnTn9bs/eijvSdOnkJ7wsPD +w8Ob3vdcCVgQcZKC2EWuMQYPDw/fT/zYMaO+e/vca8sK3D6q/7z5eGNze7uPSCbER41JGzh+7MDI +CHXb+9UbN/7pxMnTaE94eHh4ePP6MAuB6X8MuxMeHh6+n/nrZhb850/u9imRb7yz/53tR5rOuSWT +VgsnIkURjLGhg2JuKJtw0w1ZVul58um1lVW70Z7w8PDw8Gb1XQGAIXMo7ALCfQB4eHh4s/r5t8z6 +yYrv7/ikcdXqHS1t3lEjE2KjbYKRkEQkGWOcyOv2N55qH5gU/eC9RVd/Y9hTz6x7/Y330J7w8PDw +8Gb0liFDRzPGiJjuje4fuw5mjIUH8PDw8Kb2180s/MXPf/T61s/uf3J7UnL06DHJipUPSIgaP3Zg +RvrAcakDE+IiPT7VLeWwEfHegFpecWDk0MTvLbz2+PHG48cb0J7w8PDw8KbzLCunNGwKUR8hBTw8 +PHz/8KPThpdveP7TAy2LH3nvsrHJsfHRzoBy49VjbywYnzJogIVzIhJCNDe7qnbVl1cdtQ2IdDs8 +R461rn/kutz02Nu/t6Kh8czF1ycpMU5Iam93attE1NrmxPcFDw8PD/9P9py61xAWITOJdh5JRPoe +BHh4ePj+4RffOd/ltzy4dteI1KTIpNgvA+KGgvSlc78xYki8dvdPRJzzwYPjbrnp8h/Omny+1R05 +MHZEWsKDa3f5KPr22+ddUn3WrHl84a03an7NmsdvnX9j337liiX791UlJcbh+4KHh4eH/zt6fUzA +eyLRy5Hw8PDw/cGnp6fOLCssf+/QKXcgfvCANikHD469teSy4DGNp1qONLYIIbUfy8omfSMl7pxP +TRga1+j2v7bt8MxrC8aMHvnV6qN/PIPvCx4eHh7+n+lD1w0WXch4cHB1MXh4ePh+4KcXXen0iPKa +xuGjEgNW7hIsb8LgQfHRGv1s/+klz+/83qs1NcfOdf72tPAJoxI9PsVn4SNGJZXXNHoDlmuu/sYl +1kca+mcZ42mpw196cVVdbeVjq5ZrqUH61RyDr3lzr6urrfzB0tvqaqvKN65OS03B9wsPDw8P/xV8 +dwpQ2CWFDQfrU4bg4eHhTe2nXZF74GTz59wWOyxJEEVFWk42ezbtOvbu3xr//Jl9wwf1O1q9fqJB +cZHBQ9o6ApZIm2AUOyzpOLcdbmi9Mi/3kuozfMSwb15XdP3MQv2TmMWLFxJRdm5Zfv6UkpJreukl +IG0415dNzUXTbxo8aODixQvx/cLDw8PDfwXPQ7sGDBOFhmzDw8PD9wefljbi8BmHYrNGJMYJmy0y +0nroy47/rDg455VPi1/Y9cy+L0cPj1+7YGr6sATNH//sbPWptgEJUdJm44mx/gjr4bPOMaNHXEp9 +aPasmU8++eBTTz2UNTlD80mJcbNnzayp2SulqK//PDc3M7RLV1/s4UP1rW3Omj1786bmat0F+H7h +4eHh4S/Jc0MWkGFDmyyoa5sHgwx4eHh4s/uYqKgWT8Bi4dxqsQ6M9zFW3+I52+GXxElQ5tiB/3tv +4TfGDtIOOd1wfvHaj6p9QmHMkhxntUZYIywtnkB0dNSl1IfWrXv1W7MXzZq9aP+Bw0SSiIYPG0pE +y5Yt3b+vqqBgWmJCnOEXd9cYhO70ISmFw+FkjA0fNhTfLzw8PDz8pXqrNj1Qz3BB6AYQ8NAYAh4e +Hr5feJJEjHNO5LFE7Fci3AFJFgtxzm3WNbfkjh3S+Xy9bt+p21/+9KBPpejI/WpEtiUiVhIxJokx +4+OWvuqjvRob7cEn+0Ti4OFjdntTefnrr254yyC1O37Ogv0ALPhBaakjzp1vPnP2S3y/8PDw8PCX +6nnPhKHuRCIKN5ggJMEIHh4e3qze4/UlD4hSVKFIeaTF7RWMD0lmCQMYt2SOTLg6fbAmz548d/NL +uw9F2NjQJD4o0SvYkWaXKqWiqMkDbB6P7+LrE+4tTkTbq6qvnTkjLTUlpP5M3wMQzFzKzEgvKJi2 ++6MabRkBfL/w8PDw8JfkDYFCD9fHYAJ4eHh4s/uGxi8mjoiPkOK009/W4ZMkiRGLjWFJ8RQb++eT +bR83tteccvxhd+PxAQlsSDKLidaeyre5lVNOb4QUE4cnnGz84uvXZ/36TSdONG6p2FBXW/nSi6uI +eEJCnO45TY8QYsyYUZs3r9216+NNm9/G9wsPDw8P/xU8y8op7rkaABl6E0J2C3h4ePh+4O+685YF +ty+46lc7TypcWixk4YwRWSxEbEhcZP7gGCJpZfxMc0dNs5csnKQkIaUQJART1TFWsfP+azb+bsPv +//DWRdZHv/qvfvsi6z9v7vUPP/Tj+fPvPnj4GL5feHh4ePiv7HsdBEzhJqKWUsDDw8P3D7+z+tO4 +KLbo8hHC4SWSpAqSjISUHmXmqPg/3pL52i2Ty2+e9Hh2MmvuICJSpZSCpCQi0e5dePmIAVZRveuv +F1+f1jZna5tTY61tzpbW9kusv8T3Cw8PDw//9b1hqiDBGKeQ/CFDJwI8PDx8P/BH6xuqqv58R+HY +4UmR5FO0Y6UQJAUnaeHcyrmF8wjOpVBJCJKShCAhyBsYnmy7o3DM+x/8+fiJxn9a/d94c2t2TsnB +w8fw/cLDw8PDfx3PQ6MH0qUKGSawC5lGFB4eHt7Efu26TYk28evvZJE/QH6FhCRBJARJVffshEgV +JKQUCklJiiB/YO287Fjy/va3/432hIeHh4c3nWdZOaXhMoeMiUQh+UPw8PDw/cHf8M0Zv3x85e8+ +avz+W4fIYiWbhaQYOzC2bHSSJGnhvPFs2/+edFCklYQkv0qK8pubJn33ihErH3hq2/u70J7w8PDw +8KbzliFDRzPGtBXmu97o/rHrYBacf9oA4OHh4U3t6+sbXG73PTeXXD48YffJFke7jzhvdQf+2tj+ +11PtfznlqHf4KYKTX5A3kJYU+ftbcuZNSXn62XV/ersS7QkPDw8Pb0bPsnJKw44O7iOkgIeHh+9n +/ls3lDz403va1Ijff3L6D/vtJ1q95FO18b7EGNn4mIHRt2Wn3J4/Mk56Hnvqpa1bd6E94eHh4eFN +6oMpQEQkpKSLOJLg4eHh+58fNy71ru/dUlpytTNgqTvrPHrO1eZViSgx2jpxUMzkYQPiuLpte/Ur +v/ufEydOoT3h4eHh4c3r9QGAAdGF0ozg4eHh+5ufMD6tqPCKaVdMSUsdFhMZTYxcbk9Dwxcf1+zd +savm2LFGtCc8PDw8vNl9aApQ2OECwYOFtoQYPDw8PDw8PDw8PLwZfXcPQPCwPiKJsAEHPDw8PDw8 +PDw8PLxZfPfaYCGLCHSWErINDw8PDw8PDw8PD29Wz3tbOrhryQD9Nu+KGeDh4eHh4eHh4eHhTenZ +5OzikA4CY9pQ2J4FeHh4eHh4eHh4eHjTec4YN3QN6OcT7VlKd4cCPDw8PDw8PDw8PLwZvT5PyNhr +0LMsrj8eHh4eHh4eHh4eHt6MnmXlFPfWQdDL8GEBDw8PDw8PDw8PD29S3+sgYEMYoXsXHh4eHh4e +Hh4eHt6s3rASsCDiJAWxi1xjDB4eHt6sPnNS+rQrspzODrfb63C6PB6f0+lyutwup9vt8QYCfiHR +nvDw8PDw/dCHWQhM/2PYnfDw8PD9wE8vnDruipltgdhRg21DEiOT42zxMVZSfAGPu7W5ub3N2eZw +OJ3utjZHa2ubw+lyuTwOZ4fb7XG5PD6/gvaEh4eHhzer7woADJlDYRcQ7gPAw8PDm8yXFl8pxl1b +2zZ0YKJ1YHLEgPjIAbHWKCtxn4i1iGGDKMYqYhnFWmW0haK45FJRfJ72Vse5c+db29pbWttb2zv2 +13322dHjaE94eHh4eBN5a9eWIW4wHhwSWMDDw8Ob2zPGbDYeGWmJsFijYmJiBkRHxUWR4F4uLIm8 +IYJUVZAipF8loVpEwCpUG0XZLPGRKSmWQb7Lomgw6zhxogHtCQ8PDw9vLs+1foHgm/qCuvbxrsM6 +ATw8PHw/8JwxyawkuRRcFUxypiiSmEhI5hFWsqhkIx5psUbZIqOjYyJiE2Rssid6SGv0sC+iRtVH +jW2Ug5vsX7o6PJdan6TEuKTEOLQ/PDw8PPy/ynMdEn0eyUPegoeHhzexZ5wJyVTBAn7ye0kSl0xG +xrAOt3B2CI9XBHyy859bBjxS9UnFT6pfkEeQj8VbZUtLS1u781Lrs3jxrX987TcJCXHannlzr9+/ +ryozIx3fFzw8PDz8P8fruwZ4TyR6jyHg4eHhTe8ZManIgEL+gHR1KIoiByRY3F7F1RHweJQOt+L0 +qC6P4nYHvIrqU2SHV/W4AopHkVJYrDI2QrS0OPx+/yXVJykxLicnMyVlyMQJo7vekn0+s7nw+WZm +pNfVVq5csQTfLzw8PDz8xfjQdYNFFwr5Y9k1jSg8PDx8P/CMU0ChgJ/8PuF0KMwqrZHUfM7r9QY8 +noDHE3A4vS6fqliYXxVub0BV1YgoGRFNEZFkjRDRPOBwdHi9yiXVJz097cSJRru9KTV1ZNdbjIim +T7+yrrayfOPq1NQUza9csaSutlJ/Z//+1vKXXlzFGM/MmFBXW3n7ojla+c899wgRLVwwr662Mtix +gO8XHh4eHr43350CFHZJYcPB+pQheHh4eFN7xsivCK8/4HYHvAElKs7W3OR3tgc87oDb4e9wBKKi +LREJ3OUXTq/qVwVjwu9X3O5AR4fX6fBEiEBbu8Pj8V5SfSZljK+tPXj06LHc3Ey9/7KpuWj6TYMH +Dbxr8UIiWrliSWlJ4azZi2bNXlRaUrhyxV2h3QXB8u+//+dEtLH89ezcsvZ2J75feHh4ePi+PQ/t +GjBMFBqyDQ8PD98fPBEL+BWvJ9Dh8kTEWhwu9WSDx+OVDofi8orkodEDkiM9buHzqy6v6nIFnO1e +V4fX1eFra3E5zjmsqt/l8gopL6k++flTGhtP79lTm583JSkxjjFOJIno8KH6ltb2mj178/OmEFFJ +cUHNnr0NjWcaGu01e/aWlhR1lc90ZUoyvvD9wsPDw8Nf2PPelg7WNrS/NV3bPBhkwMPDw5vdWzjz +u72u9jah+Jg14vgRZ3u74nQpXlUOGhkTGWttbvW5XKrLqbgcfr9fdfpka1ugucnVfN6jetUIUp0d +7kuqT1rq8PHjx+VNzRk/YVxKypD09DTtt3SwR8LhcGq39cOGDXU4nFr9HQ5nSsqQpMQ43R2/DB7Y +8xkPvl94eHh4+At73vPg7kQifXGhMQQ8PDy86T3jfleH0t5qs1LHeVfbGWf7OZfX5Y+J4qpfOX/O +42hX2tsVZ4fwq9zZoTaddZ/5oqO11dfhUpiqRnC13eG6pPpMnZpLRFddnT9mTKrd3pSWNir4zEbz +aakjzje3EJHd3hQfH6fVPz4+zm5vam1zMsa6YgAW/IWO7xceHh4e/lI975kw1P0MicINJghJMIKH +h4c3q7dw7nE4hc+nejxue5Onqdl3vi3gdLV/4fjiaHtTQ0fzWY+j2d/W7GtqaDtT39J+3u33KB0e +f0uHP4IUn9vt8XovqT7jxqU9//zLty74wYKF99bXf64NA9DeSk0dnpmRXlAwbfdHNURie1V1ft6U +0WnD01JT8qbmbq+qJqJz55snTEjPzEhfuvQ2fd7PwcNH7famnJxMfL/w8PDw8BfjjYGC3vU5eA4e +Hh7e3D4i0jZiYGQs+VvPnm9qONt6xt7x5fmOL863NJ5vPtnS0tDecqK16Yj9/GenW4+fdbe0+lrb +3K0tnvY2R0uTJeDocLR7XJ5Lqk9OTubHn/xN8zU1e/PzpmiT9tjtTVdfk79589rq6t2bNr9NxJ96 +eu32quotFRu2VGyo+mDX08+sJaL16zempAzZvHltTc3enh/H1728IWtyRl1tZWZGOr5feHh4ePi+ +PcvKKe65GgDpexN6DpgLhg7w8PDwpvf5U7NyczPSxk5sc0cdbfQePuk9ftbX1qFKoqgoa4TNSkxK +YqqUFou02qzWCAuPZFYbORV1Tv7AnOiTv3zqFX9Avfj6JCXGtbY5gz+mpaY0NNrxfcHDw8PD/5O9 +ZWjKuK73mH6DOqebEMEBavoi4OHh4c3uz5z98m97D+/59JMvGg4kR7UWXh43t2xsXsaAYfGqRfE6 +21wtzU4LKTERwutRSUgLk5wYI+nziyvGxYrWEx/XHLik+nh9AT1ra3Pg+4KHh4eH/xf4rJxSY/Qg +BfUMFHoJNeDh4eH7hycisnIeFWUtK7vqtoXzms63u7zsXAu1+nhiSkLTmXMHj7edPM9cTrXdq3T4 +5QPzU1s/31m+eSvaEx4eHh7edN4aZm93DMG1//WrB4fZhoeHhze/D6gideigefNuio1Niunwkexg +Cc6RtsjoGMpLHVgydXCrV2nusH7RJvfttw9MiNh38jR+f8LDw8PDm9J39QAYMoeMiUQhQQY8PDx8 +f/MlM/KWLr0jZWiKJHmu6dyxz485HI74+Pht23acPHk6K+uynNzJGZMm+oU1MiLi4Qce+ezIKbQn +PDw8PLzpPJucXWyYRjSkN6HHwQYADw8P34+8arVY4uOjJ04YfcUVl0/KmBgbGxsZGfkfdy5zdniI +yGql2JiYlJTkUaNGfPppncPpQXvCw8PDw5vOs6yc0rApRH2EFPDw8PD93kupRERYR40cPGDAgLr9 +n+u8IJJELLjsItoTHh4eHt5cXj8IWEhJF3EkwcPDw8PDw8PDw8Ob1BtmAdIjulCaETw8PDw8PDw8 +PDy8yXzousGCOtcM0y8gHNwp4OHh4eHh4eHh4eHN67t7AHouIhA+kggbcMDDw8PDw8PDw8PDm8V3 +Bg1dAUGPDUMw0bUNDw8PDw8PDw8PD29Wz4MTWRiEtqEtkNm1zbtiBnh4eHh4eHh4eHh4U3rjOgBd +MQS/YM8CPDw8PDw8PDw8PLzpPA/mCel3hvYXGHoW4OHh4eHh4eHh4eHN6PV5QsZeg55lcf3x8PDw +8PDw8PDw8PBm9Cwrp7i3DoJehg8LeHh4eHh4eHh4eHiT+l4HARvCCN278PDw8PDw8PDw8PBm9YaV +gAURJymIXeQaY/Dw8PDw8PDw8PDwZvI8NHogXapQzwmGQqcRhYeHh4eHh4eHh4c3kw/2ABgyh4yJ +RCFBBjw8PDw8PDw8PDy8+Xxw7LAhhjAcHBpkwMPDw8PDw8PDw8Obz3PGQucPMvQm8OBhGoCHh4eH +h4eHh4eHN6vXDQIWUlLoYII+RhjAw8PDw8PDw8PDw5vLG2YB0iO6UJoRPDw8PDw8PDw8PLzJfOi6 +wcEMIX3fQXCngIeHh4eHh4eHh4c3r+/uAQgGEH1EEmEDDnh4eHh4eHh4eHh4s3iuHz1g2KAwE4sS +PDw8PDw8PDw8PLx5Pe9t6eCuJQP027wrZoCHh4eHh4eHh4eHN6Vnk7OLQzoIjKsGhO1ZgIeHh4eH +h4eHh4c3neeMhY4DDrOwsKFnAR4eHh4eHh4eHh7ejF6fJ2TsNehZVuj6AvDw8PDw8PDw8PDwJvMs +K6e4tw6CXoYPC3h4eHh4eHh4eHh4k/peBwEbwgjdu/Dw8PDw8PDw8PDwZvWGlYAFEScpiF3kGmPw +8PDw8PDw8PDw8GbyPDR6IF2qUM8JhkKnEYWHh4eHh4eHh4eHN5MP9gAYMoeMiUQhQQY8PDw8PDw8 +PDw8vPl8cOywIYYwHBwaZMDDw8PDw8PDw8PDm89zxkLnDzL0JvDgYRqAh4eHh4eHh4eHhzer1w0C +FlJS6GCCPkYYwMPDw8PDw8PDw8ObyxtmAdIjulCaETw8PDw8PDw8PDy8yXzousHBDCF930Fwp4CH +h4eHh4eHh4eHN6/v7gEIBhB9RBJhAw54eHh4eHh4eHh4eLN4rh89YNigMBOLEjw8PDw8PDw8PDy8 +eT3vbengriUD9Nu8K2aAh4eHh4eHh4eHhzelZ5Ozi0M6CIyrBoTtWYCHh4eHh4eHh4eHN53njIWO +Aw6zsLChZwEeHh4eHh4eHh4e3oxenydk7DXoWVbo+gLw8PDw8PDw8PDw8CbzLCunuLcOgl6GDwt4 +eHh4eHh4eHh4eJP6XgcBG8II3bvw8PDw8PDw8PDw8Gb1hpWABREnKYhd5Bpj8PDw8PDw8PDw8PBm +8jw0eiBdqlDPCYZCpxGFh4eHh4eHh4eHhzeTD/YAGDKHjIlEIUEGPDw8PDw8PDw8PLz5fHDssCGG +MBwcGmTAw8PDw8PDw8PDw5vPc8ZC5w8y9Cbw4GEagIeHh4eHh4eHh4c3q9cNAhZSUuhggj5GGMDD +w8PDw8PDw8PDm8sbZgHSI7pQmhE8PDw8PDw8PDw8vMl86LrBwQwhfd9BcKeAh4eHh4eHh4eHhzev +7+4BCAYQfUQSYQMOeHh4eHh4eHh4eHizeK4fPWDYoDATixI8PDw8PDw8PDw8vHk9723p4K4lA/Tb +vCtmgIeHh4eHh4eHh4c3pWeTs4tDOgiMqwaE7VmAh4eHh4eHh4eHhzed54yFjgMOs7CwoWcBHh4e +Hh4eHh4eHt6MXp8nZOw16FlW6PoC8PDw8PDw8PDw8PAm8ywrp7i3DoJehg8LeHh4eHh4eHh4eHiT ++l4HARvCCN278PDw8PDw8PDw8PBm9YaVgAURJymIXeQaY/Dw8PDw8PDw8PDwZvI8NHogXapQzwmG +QqcRhYeHh4eHh4eHh4c3kw/2ABgyh4yJRCFBBjw8PDw8PDw8PDy8+Xxw7LAhhjAcHBpkwMPDw8PD +w8PDw8Obz3PGQucPMvQm8OBhGoCHh4eHh4eHh4eHN6vXDQIWUlLoYII+RhjAw8PDw8PDw8PDw5vL +G2YB0iO6UJoRPDw8PDw8PDw8PLzJfOi6wcEMIX3fQXCngIeHh4eHh4eHh4c3r+/uAQgGEH1EEmED +Dnh4eHh4eHh4eHh4s3iuHz1g2KAwE4sSPDw8PDw8PDw8PLx5Pe9t6eCuJQP027wrZoCHh4eHh4eH +h4eHN6Vnk7OLQzoIjKsGhO1ZgIeHh4eHh4eHh4c3nf//Etp73CXrfDAAAAAASUVORK5CYIJ= +Chameleon can be installed on any BIOS bootable device such as USB flash drives, hard drives, and of course off a cd-rom.Installing ChameleonChameleon 2.0 includes it’s own installer package which will install the required boot loader components as well as the new themes onto a hard drive or other bootable device. Once the install is complete you will need to reboot your computer to use the new boot loader featuresTo get started, double click on the Chameleon Installer.iVBORw0KGgoAAAANSUhEUgAAAnEAAAG6CAIAAADoKIeFAAAB32lDQ1BJQ0MgUHJvZmlsZQAAeAGt +ksFLFHEUx78zErthLGJWRAZDqJjMxjJ7qdtuewhhhUVXzfCy/nbdlZxxmBndig5dunUrOnReJOrW +RS/hHjsUKKJpnfobJImWZfr+5seyHpQuvuHN+/we39+bee/3A3oGS667rAOwncCbfHDfeDj3yIgd +QsNNJq+gtyR8N1so5Lk6w473qabtJmWtT/7e2I2v6deNkVbs1efi1hmbOumExw8CmsnEQFVxRvKC +4qLkeuAG1NQki1qpTH5ONr3iZI78npyoKt6UvKD4i+Q1UZV7D8gpp7zkAHqcfLdc8QU5QxZlX9jk +Btm07RXW17fJo8L1uFf/Qx6Sc2GkPdsHsh9ZM9HNzbwBPqwB12U7RiTD8GPg8m9gc72bOzqIZqVd +jfuLaSvSab0bwIW3YXg0C8RuA+3vYdjaCMP2OtDzA2gei1WPtZVa+8Yf/s9a9az0wA57oEVndDqr +uUSqFNBoAnNcjGeAd/SRa0D/T6BALmagp9MdVzOkFLiYz00kLauueopS5/Oyl1d5TpHJDi5VnOkp +xj76IPLIYQJJWHzqsNTZSe38S+CWvNZo/v31QsaTFlSeRDPJrbhPvaVqLTCyvLkV0xh3xB3TsFKp +e/gHmVWEZApHLZsAAAAJcEhZcwAACxMAAAsTAQCanBgAACAASURBVHgB7L0HgF1Vuf696+lTM5lM +ek8oCRAgdCX0jgh8ooKIivdvA6+KXq5YsSIqXMtVRKWJqNgQ5EoHKdKLARJaeplMn9PLLt/v3SuM +Y2YSJoWSZG2Gk332XvXZ+6xnvWW9yzzy4ptDIwwqVa9S8MrFMPAsyww5gmD9SRhyYoaGbxiWYZiW +YRphaBqObdmmaXHJMIIwdG3Lsc3GTKKnt7R0Za9FEslkBH5AIpOMpknOwAuCIIxymmEQcpXC1n/S +DjKYIempnSwcfkBVqhaTnKZhmRQtN0lLw6R6yWWQKypKSqBkg7tclC5IMfKVM2kD59QblSOVBTSe +nkZpQrlKUnJLY6X9kpv06ivlydfQl7qivFQpqEjRkjIIKEG6KQcXohKkrVIgqAYmJai7lCrNMCJs ++DeqT3ogh2ool6QMWhQhxFeaKuX4AQmoSWrxFc6Si++CFIUE3BBApIJX80YNoCvSJ/U86HpUvLRU +HZQqdUXlSIF850IE5quNGkgrnQJ/0vCIya46IChLHfQr6ilnUTOjgiKoDYv7UV6yRvfITCYFsupU +dEU1ScqNXgMBStob3Xs1IyVIz+W6NExKjK7wqljytgooXOGrTXssOwx4i9cfIEguDsnCs5BGR7ei +Nq8vxw8c2xbYo1dEEpMkqkKVQjIOzqlCXRn2EzTWVyTYUIC0TWWxLHvgXBWlPlU50j75AaqWSVZ6 +K51S74i0RHKrAkkpuaRF0YMELLrIqSc3ohcpdF07mXbTCTfuurFYBAFZuE8yXjD5tQriEaRSGIeU +IJ1TVZKWQ/oMZPKP3JaLklLeR85osE3NdFD9lKK70iqf8tUPWIYOMpLY8nyfE/VDkMKkJOli9C6Y +FMh3juj3Ihd5f3hcjDZyUb3M0RvCV6qQm/JIowaqRkftpCmvXqRWycvxatmSYf036aX8kOUub0TU +5qiPgoy80yqlSsYnlUa/UFUUN+UXQN4g8P3QFhjWF0yHeYrRyy93oxpViVIRh/Q3ysu/HL7vk4ZM +nLz6ajJSyRPlQ5CVVsrDkqIAXb7xQQ2G1EsfQ8CzoschTQRhec2laoqXc2ktp5KBzkkhgCzwUZA0 +JuoeP2myyM9JagJeqicRKamFMmk8gPKoI9hDyuGZ+IFPAWSwHSsECOlQ1Eyp1AIbeXA2mSMcol8o +NyhPSiK5SQmBAzx0JDpUjVKiACy1cJnEQEMz5VVi7LV4K2zqokLBmhsyHkky6qbZPBL+oQRQEpio +MoKdM88PeaPoETek4eQSPHhg8kkptsOryFWpSgqLyE/ecNNNpNJuKm3bDoVRlSOPwKtUC30TGmIH +7D1t/sy2tqZ01Av9oRHQCGgENAIaAY3A8Ai09xWfXtbx+CvrVvV2ZppaYvEEs0YHfq+V8hOb3Hcd +OH3yqGSlUmhvzw1fgL6qEdAIaAQ0AhoBjUCEAHL6gVObJjWn/vjIkjX5vOMmHA4UC7VyYZ89p7Zl +rEKhoLHSCGgENAIaAY2ARuA1EUD163leS8KZN6Vl1VMrfa8W+BZyKjrp2q5jM9Vq9TWL0Ak0AhoB +jYBGQCOgERhAAOqc2ZoK/apYV/E0Ett0GNbFsOtGdvmBhK+eYH+u1Wo97e1P3fzX9ueeq2Sz3InX +17ftvvu8k05obmtzXVeszxs5BrI/d/NfOp5bWOmPsjc0tO4+Z/eTTh5h9nWd7bf+/ebFS5/LFvop +sC5dv9u0Oce//eQxo1+j9o00Sl/eSREww1rGWt466qVcpa07uyveaYEd20mx0N3WCGgEthECaUe5 +0OLE5JsLLvpdoWPFt87Ya9jCIbBKpbLwrrsfvfraTDw+unV0y/jxXOxevbqjo7NQre53ztlzjzg8 +Ho8PS6sq+wv33LXohmtS8Vjr2LbG8ZNwtupbvbJj7dpiubLre94/+7AjNp39nofvvP7WqxMZt2V8 +S+voMSir13Ws7V7TUyv6Z57wgcMOOHJj2Yftkb64EyLgWoVmd/Go+AtNxhLXNUqZtBHUnGxYXLPr +Smd+V3zsG48JU1p+HbaN0++/PDxH3owBp9CRZ9mylKi2sBBtWV6dSyOw8yDwtVuebWybgnu1g5M1 +js0cw3YeCfXZu+95/MpfTE6n95g0cc/jj5915nvJ8OJ11//zb3/758qV3IJNoVWk1aElkP2le+96 +5forZrVm9pk3ZfKCo9qOehc+1OvuvHHZ3bc9+eTL3MI3edZhR24s+72P3HXNX65ompSeu/+0o/Y7 +4di9TytUcjc/+usHnr538ROrrv7LFdQOrQ6bfWh79JWdDYGwY8l+jc/UzVxkFOOGUWNxSaXilfJ9 +qSQe8FZ81sJ0tq/Qu9tSa1pvWM/yow3wefDBB0eNGrXLLrtscH3rv/4lOn7+859T1Gc/+9k99tjj +7LPPHlosvPvII4+8/PLLPT09Y8aMGT9+/Lx589Lp9CayDC1ki6/09fW9613vuvLKKydPnrzFheiM +GoGdAQFZJiqrHENnzKhEkHOjJVDDdLy7vf2Z666flUrul05P9IPmNWuCF1+EU5vXrpkbBE2p9KNh +SIJxu+82ety4ofl729eu+vM1e0xJ7z+3pb4tnrSzYbadZUQpq3/qpFizO/qRheFLf75m9K67jxo3 +fmj29o61v7n16pZp6TmHjW0dna7F+zuKK4rVfJAqjJtRF28e9/y97STYddru49qGyT60QH1lZ0Og +6DtW6SW7+nQx2L1UcnPZ7ip+BGGs33GamjNNjXa8+X6nUje34v4zF+9KTd8An9/85jd77bXXzJkz +N7i+6a/FYrG9vX3atGmbSMYsUHkIkobzWCw29DeYzWa/9a1vrVq16rjjjoPXV6xYce2110KoEPDG +smyixi24BaOTi2nr0LZtQWk6i0ZgB0YgWqnLul3DGd+cCvriG/vNLL7tjqYwPCSTmWCE9bls8tln +JVBAEKaef97M52KmEUun+3N5kjWffdZQvFbf+3+j0uFhB46LNyTcOsvx272VD7Ce1/bWxBusJqvu +sIzTc/cKkjWe8YGh2e/6x9/seLjviZPrmlijHnYFy5/uvLcWVPJ2Z7LJHZNuSJ0Yv/+Xr5DsvSef +MzS7vqIRiDeNXrSyoSXRF9YeNN2xRmyCa8dsuxTUOrrWdOXWeW3jzUQ8/tjaZHd6EkrYDRDDVx71 +7MZ+HRskHviKdHvdddddddVVA1eGnkBXHKrkweeDU1JCR0fHb3/7W8W4cHAymezu7sYnYmNZBmff ++nOlvuJzcxHY+qp1CRqB7QsBIlTILyU0HcTVePRl2A44S5fumUpNtKxRppkyQre3x3rscVK65TKq +tBiBMIKQBKuXLh1We1zXtWjq7s3J1rp4Y9KtiztJ36otYeJr12GkSTsp24o783ZvXta9eNjsK/pe +nDZ/9JgJTU7MJmyTaZc7vZcIqEE5mVjS9+PJVGLqvqNXtL84bPZhe6Qv7jwIxNYunF1dnCu3dLxy +THrcbfX2Wiuo+b7nlfoIzxKPG9Wa8c9/pvJdKwu7LlgfO2cIOrAXb1c+n7/gggs+9alP/fGPf3z2 +2Wf33nvvT3ziExjySX7TTTfdeeedXV1daGU/97nPvfLKK3AhIuZ//Md/7Lnnnh/96EdvvvlmWHbl +ypVIru973/tmzZpFLorlc+C9VbUMrpwab7vtts9//vOlUmnYRW5kueGGG0jT0tJy7rnnqmKHreu+ +++679957TzrppGuuuaa/v/+ss87abbfdfvjDHyIBH3nkke9///tVe2688ca//e1v2GuOPfbYM888 +c6B5NJKD6oYmIM3ixYt/+ctfIkM3NjaecMIJJ554InLtJuAa3Ed9rhHYYRDwiA0lMZgCp+ZLtMCN +zUPT/dk212lKxOtsO+Y4tusQo0kiN8VjjufZnhd4fptZ6e/PDltCs1tondCSGF0Xb0q56biVcJj2 +EzDK8FJOJWYnY6brtE4o9ee7hs2eD7K7TxuTyaRch8CH2H7lj+GoFtg0mj54sWDstOZFa9qHzb7D +PC3dkS1DYHlXebxTyiRNpzaztKatp/lPY8b1E/WMRWPZfDLXNaHaNSks1ZtetzVuVS0zjKcSRMLB +24Wrzpo1ay677LIPfOAD55133sc+9rF//OMfb3vb2zo7O9HH/u53vxs7diy8Qsrp06d/+MMfhlY5 ++IqL37hx4y688MIZM2Z85StfgYA//elP0x1+dHyq93aglsHdhPC4PmnSJEhu8HV1zi0MsoceeuiP +fvSjn/zkJ3/4wx+gc24NWxdtWLRoEerib37zm/DrT3/6UwiYLlAIM4Ojjz66tbX19ttvh3cxndLT +D33oQ3QN261qnhofhk2A0PzFL34RAqYNTzzxxMUXX5xIJA4//PCNwTW0I/qKRmDHQADtUdzzUMI6 +UCvxNtWPZ2jfEA/jrp2pq2NKbicTZjptJJMSJbFcNotFs1TKlCsJM0dE1GFL8IkCXJeIN2dijUk7 +FUMqNdzIDcQLzIpnxqBny67LkmzY7K5jJxLxTCJBMSjskoSpoMFGWPa9Us2rMNLZQRJ2tyVyxdDG +6ys7OQKjZu+5KD9p8tr7xjYV40GDXftoV8dtRq0rt2ayl2u1JJ5oyYkVDSewO5/qdusCJzkUMYiH +t0u9YOeffz7mVX48WDeXLl160EEHKc0wwiuyHZZOuISUZEFWQ7jkhGP//fdXHDNnzhwkS1WUuqXO +qXTovDaXk3BmEOFAmg3atu+++9IeBGLKv/rqq1WyYesiYyaT+cY3voH4iOhM+y+66KK6ujoaiVYZ +ARo/rDvuuGP+/PkQORexHz/zzDNtbW2qTD45hk0AQ6MeP+OMM3p7e5F9AQS5GaYnPZUOhWuDLuiv +GoEdBwGJlkx4cEycahjYCCfFxo4tdHe5jY1WOm021BuNjUb0UwwLBbOvz8pm3Xy+UKnEmkepX9EG +AFUzo/LYbOuTdiZpJV0zYa/nVCRNHPSh9MDIBUYtMwpW3CAvX9uax5b6qgknRsQnZNWMm0g6CeRU +gv07VsXxahXUeP21Mc1jh619aIH6yk6HQLL+vs743J5VM6dMvOuhZ595tmvf3WbOnTImZ/S5MZay +GOv6Cqt5TWftG5iyRnsDfAaYT4mV9fX16E5JM2BnbWho+N73vgdd3XLLLYiwUBp31ds4IF/ec889 +f/rTn7hILgpUd1WB6nyglsG14+XLV4RjqHrwdXVOFiRjrK18paiBYjdWVyqVQqYkGZpkstA2pU+G +QWkVzaCoRx99FHGWuxhuScZF1Ug+N5YAb2QIGPdgVSbKbbyUBzIOhYtk+tAI7JAI4KPEH4Yih5+j +hFLayFqa+j32WHXvPbXGhgRs2tRkNDeb9fWCSL6APYpZbs1xV7evq5s7Z9gS7AlzV3Q+vnfctVDz +JhwjZpnIqVSMCpffMmcVf0Vn3pq4z7DZd5sy7/Eld9q+nUrE0m4iE0sk7QQaa8aBaGcJ0yuH7Uv6 +9pt+5LDZd8gnpzu1uQhUy/nfP/xQ3rNdLze2Mf3MkkXNjf74UZmX1/b+c1lne2fv6HlHNcTqoaZh +S4aHeLv45C5KVPWm8ZWDcw6IBDn117/+9eWXX/7jH/8YsyIp1V1O1q5dC+leeuml++2336233opC +mCwqAZ/qfHB6ztWBlRTCRhBEmfzqtX/7l8mwyj7wuem6oDryq8RwKhKwKo4rHDA0CmGW6KiLuC4j +etILlWVjCWjk/fffT8lwMylZ8zN69GgSq4xD4VKF60+NwI6HAMthYDY2vRHdbzQN3XCGrvrccshB +/QsXPhoEhzU12c3NQqvMmvn98IOMtt56rKfXaBndcvBBfdH8dwOkmvc+dvXfnnh6cfv+b5tloMB1 +Lfbe4ednOmz4ZbJ73D8Xtxeqxrh5x/aVhomMuP/sQ59b8eCLj689cMHMmOW6KIAtdL+Ga7oxy3eN +4IVHlyK57r/LgmKuvEHV+qtGQCGQM9N1CaveZDvCeqwJccf++8IloeF29vQ3J83JTWx4JgrbjcEF +PXBXJVDnKqU6R/iDn1CTQpksNlVKH0RMXJaQ4SBF1K287/jrok196KGHkA4HihoojZOB84FmkAu7 +7Pe//31YCsUy0iRcpVSy8N/gLJyTi2JHUheFqMSqGZxzhXN8i5gQoBmePXs2BaJ5pvEDTd1YggMO +OOBXv/oVtIrWd/Xq1U8++eSpp55KYg5KHtypwefc0odGYAdDgF+h7CMXeI7nK3Pq8GNK0fcnnnzS +8gfufyII90qlYolEyKaLcGoQ1JKpp8PuFYYx4cTjSaZ+RRvAVPSNxnlnPPf87xPN6T32maQCGEYi +JutxjIXPr3l+0drGvc4g2bDZvUpwwv5n3/vc9S83ts/Za5JHIDnxrGL/ULanC156au2apb0nHXgO +58Nm36Ax+uvOicDsfQ65r6Orac39SkPCutBYpVrzarNbk7mKt6hYt9uYXTf2/sAEigxUAj7VycB1 +1qHiJaQcgKHA5uZmaHXKlClwDH7Chx12GF61Bx988Cc/+UlUuOecc85TTz31gx/84OMf//gAt6mH +omrZ4AEdcsghSJOUj8MtJk/EPmTi9773vQNtUCcDRUGHr1mXSqx4lOoGOkJdqHC/853vKKvwggUL +Tj/9dFU+nxzDJkAo//KXv0wu7MTQ8Mknn3zMMcdA7aSn8CjfenIdtoMb9Fd/1Qhsvwigt8LDhymr ++YHv/a5n1Sun7NE2bGdwwWCY8Fes6Hv6mXFTJo8fNao+klOzxeKa7u61y1fUz51jT5rElFz9ijYo +RGUvrno2u+yWKbObps1sbWwSF6f+3uKyVzqXvtCbmXhCasKcTWdfk1366Ct/HNtWN37iqIYGbEth +LzawFV1r23MHzDx9XP3UjWXfoDH6686MwAvP/bP9nmsmNznpVJI3f1XOW+eM2+2Q46dMnYpEuDFk +cLtFC4rQyZuMDnbZsmU4+JAYn1hOcPrFTonUyElTUxOkwquoiiIBFEgafIjwxYVoSYk2FcbCVMkJ +bMRBgaSfMGECFxF5Vd7BnwiL6FdpAOVA1apSPgdnwdsIWXbJkiVkfM26oH+CIqGkVeSKNRSTrbKt +QttUh2GVGuHFob0emoAaVe0qF1gBBfS5MbgGd02fawR2JAR+fM+SdOtEm73Lz770ht7VS0+ZKw4R +wx78PPgtjUpnVjzwgJHPJ1MpxiB+PGYmPfHgQ7oLecaCYQlVlaayN6YTLz78Z6e2vKHOR2mczTme +M3nmAe/oK5RHkr2uMf3Q83d0F1623DJTa7+WbElPP2j3o3N9hU1nH7ZH+uLOiQAk8c8//CAVs0ut +u+99yFHwx7bCgZd86E+Ai/AWBEMtAwkUf6uLI68dpyF0v1DpSLJsfV3MADZREY0ZmoCLILC5/dpE +LfqWRmD7QuCn9y1tHDcFXyHzrEuu71m99J0b51Q6xu+ZZWfMXplZKzUXc3A0RQxS5XJZTXg30f83 +N/smGqZv7WwIoKrF/Dlx4sSdreO6vxoBjcDrisDP7l9W3zoZ11u2qMFLQTwYN1Efd9EFoZ7CDWFg +os3FoXPzYQt5c7MP2yR9cedEgOAGdHzTb/vOiYzutUZAI7A1CLD0LCSsIGH+ang1RhvTvGZxWzkS +vbnZX7N3OoFGQCOgEdAIaAS2DAEzcp7FNOlAdRh9iNO9ZQXpXBoBjYBGQCOgEdjJEQjH7i+Bc1ko +Cq/yx55WOzkiuvsaAY2ARkAjoBHYMgSOOf+7iKcWwQEjb71NGVO3rAKdSyOgEdAIaAQ0AjsJAnga +sdMbe7sgpxqyO7k+NAIaAY2ARkAjoBHYIgSgVFH5+oaDZZWzLSpEZ9IIaAQ0AhoBjYBGwAgD/kQ6 +tXD61Zyq3wiNgEZAI6AR0AhsMQIYU5FP2SEcT6VIUt3iknRGjYBGQCOgEdAI7NwIyPoZ2Tg5tFij +GkVP27nx0L3XCGgENAIaAY3AliIgQcPDkCD6bERKPCTto7SlQOp8GgGNgEZAI7DTI4BsattsyBg6 +kZSqfZR2+jdCA6AR0AhoBDQCW4oAWl/W0ODv6yCvYlHVh0ZAI6AR0AhoBDQCW4aA0v3y6SCiaoPq +loGoc2kENAIaAY2ARgAEYFJC58sublFoQq371W+FRkAjoBHQCGgEthABUf3CrIEhPkpaTt1CFHU2 +jYBGQCOgEdAIsIOkCKmhaRmWqWVU/UK8IQgUi8X//u///tKXvvSG1PaGVvLzn/+crr3wwgtbXyur +3JYvX05RuVxuoLRtWP5Ama958qZU+pqt2soEjz76KE/q97//vSpnh+zjVkKks28ZAiZcGrA3s28R +9VfT6paBuLPlOv3009va2h566CHV8V//+td8ZYRSX+GAsWPHXnPNNRuDpVqtXnXVVb/61a82lmD7 +vf63v/2Nrq1atWprutDe3v7BD35w2rRp+++//6GHHjpz5kzO7733XsrcJuVvbtvesEr7+vp4kThK +pdLmNnJz0zNZ4Undf//9KuMb1sfNbadOv/0hYBqmiTXVkr3etKS6/T2/N6PF++677wMPPPD4448f +dNBB1P/kk0/y+cwzz6i2PPbYY7xK8MGb0bQtqfP//u//br/99ne84x0LFizYrPxLly79xS9+0djY +eMEFF2xWxk0kXr169WGHHZbNZmfNmvXe9753/PjxL7744l/+8pdyubyJXPqWQuD1eCIaW43AZiEA +j8KpQRiwlgZW1TEfNgu9nTTxfvvtR8/hVNX/p556ipPnnnvO8zzHcR5++OHm5ubZs2dvL+jccsst +f/jDH+bPn7+5DYbt0BlCgZubcRPpv/e970GooPfnP/+5qalJpfzMZz6DcL+JXPqWQuD1eCIaW43A +ZiEQ4PUbGGiALeFWfWgERoAAcip7BCpOxTi6ePFiFB2VSoUTcj/yyCOQLgk4R6V21FFHobqEeJAF +N1Y2NHzqqafuuuuuu+222wknnJDP50mJCvQjH/nIXnvtBcFwd4DC0S0jUL7nPe9ZtGjRaaedRpbz +zz8f6yPK5IMPPviII4647bbbBip6zQaQ64477iD9pZdeevjhh6uMG6t6oFhOUPBedNFFnNBf2vP3 +v/994C6N+drXvkbLzzjjjAHxHVL8+te/DjJKAF27du1A+oGTQqHw29/+lq8o0gcIVd2NxWIDyYYt +/5e//CVy7Zw5cwDhC1/4Qmdnp0p/880307wrrrji+uuvf9vb3ob+4IYbbkDq/fSnP03iD3zgAytX +rlQpR9JCUq5YseLss8/eZZdd9tlnH7rJvssqOzOq//mf/3n729/O46bGK6+8knZySz2v448/ni6/ +733vo9ILL7xQPWKVcWOfquWXXHIJD5S36MADDxxsL6C/7373u6dPn87bePHFF1PIsE9kY7BsrFJ1 +fdjXZqAjvOe8kICw6UL03Z0TAdS9vPnEUbIYAuHVnRMF3evNQqC+vh6e6+npWbJkycKFCxlVjz32 +WEqAP2BWxFaGP74yFJ5zzjnYxlCNIntxznA8tCJsWqeccgrW2b333ps0FM77CLscd9xxyGp77LEH +9Ik++aSTTnriiSfITnUMak8//TQDNIX39/f/7ne/+9CHPvSNb3wDKRlxmVFY1TKSBsyYMQP9Kunn +zp3LuM/JJqpWxarPdDrNaM55a2sr8wCsgAN3v/Od7+D8kkql7rvvPuROdf1Tn/rUj370oz333JM+ +cp0GD6QfOEF1qShq07LvsOVjcG1paYHmeTRIz1dffbUqFiMlcP3mN7+BeCBm/J5I8/73vx8wYUH0 +3sjoKuVIWshzBCU0/7SfycGPf/xjuFNl/6//+q9vfetbvAD/+Z//yUP54he/yByCW+p5Pfvss1Dg +unXreGS0jXpVrk18qpbfeuutn/jEJ1zXBRymGhAbWf70pz99/vOf7+jogNSZuNTV1XFx2CeyMVg2 +Ue/GXpuBjvAEaQzKmE0Uom/ttAhgThU2FT6FXflPHxqBESCgNKVQHQw6atQo5EUywXMciDvKmMrQ +z0WG8o997GPnnnsuTPnHP/5xaNlq5P34xz+OIPW5z30OKQpaxX8EsQZJ6Nprr/3KV75y3nnnYaP9 +9re/PZC9t7eXUZsBF+GMi8issDISJ7Tx/PPPw4tcHEkDDjjgACRdEjMtUGbR16xatQE58p3vfCfn +U6dO/exnPwvBqOt8JpNJ3Ephes6hT1rO5APqamho+MlPfgIZwKwYoV955ZWBLOpEzTmgxng8vsGt +wV+Hls9dgPrBD37A/IO5BV9vuummwVmAi5bcddddWH9RLUyaNImviOakoal8jrCFgNPV1YXtmS6r +7Kqby5Yt4/FRDtMg1Aa4rXH+s5/9jMSccPBWQH7oKhTI99xzj7r+mp9In5iTedBMuWq1mvKMU0Ah +pOIuR0uYDVDOsE9k07AMW/umXxs6wmSO1/7yyy8fNru+uNMjwGqaUHyU+OWzPbk+NAIjQQAd5nXX +XYc+FokE5uMgF3LqhAkTEBeQ+ZCB1JIShBJoUqk6EZI2KJy5PxTIxWOOOWbwLcQavlKLuqhO1EV1 +ZeLEiYzsnFMjn2eeeaZSlo4ZMwZlJoPvCBugShv8+ZpVD0487DmkAimOGzeOu8ht/LKQnjlHjP7o +Rz/KCeIanxADrMDJwAHpco4syPyD3+TA9Q1OhpaPph2pDlbjEaC4Jj3EOTgXukolSQMXKZH8uKug +AyvOR9hClQyIPvzhD6vy1TNVD5ECcfnmOpphJkZ0BBEZZS9XmAcwteJENWPkLlcnnngiRoGBjKpf +XETPjHIYaRuJGTdpyifN0GPTsAxN/5qvDeoH5n9DM+orGoEBBPg98hOGU7GAad3vACz6ZFMIDMip +SIQYlhgoGUwRFhlJuWXbNiM1XEIRqEbRkiHM4SQ8WJhTpcOpjGKcbzAmQkVchJ5Vskwmwwkigvo6 +kk9qH0kDhha19VUrW/LgkukmX7kODpyoT5AZnIZzRbF0EyR33333De4OfB1aPjMbVOXQG1po7KlK +9BxIP5KTEbZQJeO5qC7A7hTO8KFAg29UmBV5qAAAIABJREFUXbSQczh14JENbfNIWrWxNACFARtF +BTpk1L9//etfEWSHJt4CWLb4tRlau76ysyIg/kmMfXAqYqoWVHfW12Az+z1lyhRUlEgh5FP8iqiK +Ay2WNjxQuIgBDF+Vl156iU8loAxbA6paisI6hVYQ6XYgDYsyGS4H/JKUazEXBxK85skIG0A5yv1H +qYv5OvKqqYL0ysK36fZg4yRBd3c38vTkyZM3lpipCRI5jIg+HDUAcu3GUm5wHVUqGGKW/ulPf0p7 +Lrvssg0SvObXEbaQZBAYDIoGe3CZ6tHgdguNIW0jiCtxGXP14GTb8ByZGEU0cjkaeBTp2PV5fzZ4 +IlsAy8hfm23YF13UjoQA00ccfy3bsmQiqVeo7kjP9nXui9LHMu5jHaQqzF2qQiyU6uSTn/wkJxj5 +YIg777wTf5b//d//VbcGfyrG5e5Xv/pVhI8f/vCHcA9uIAg6Dz74IFYrqFo5wijF6eC8mz4fYQOI +q0A52AXxZ8GDZuRVYzZGvGZYx0484D07bJPQXh599NHIQCgqWdKKUAUmzD+GJsbNh2EdMjj55JPR +5WIBxYqM9KmslUPTqytKzwyvYM5EEcpF/H43K5zTCFuInzCqCKY4uGTzXGgV63ygWBS8OBVTL5Zv ++qWMpmhoMdxurM1bcx02/f73v8/kQ82E0JMrzf8GT2TLYBnha7M17dd5d2AEIpWM6Mgi4w20qg+N +wMgQUJzKYKrUtopTkfnmzZunCsB/BHcP9MD4u5511lkYwNasWTO0bG4Rp5Bk+O+8613vglwxtjEa +4ueCCAuj4N+E7MWJMqAOLWFjV0bYANgOay4yFo6puJKOvGpUoKxIYTRnWrCBT9DQJjG3wJ0KnsPt +FtqDhoe1KaLyhUeZl8Bb0BVyLfMJOGPT5MSzABwchaA0zo888kh07xuIkkObtMGVkbRw9OjRN954 +I8uEIG+eCzoJdAlKx86ECRJl8gTszAnwSPrud7+7QRXb6ivSMLAw7cA5jtkA74yyDW/wRLYMlhG+ +NtuqL7qcHQwBohKqHpnHfuby3jVLbrrs31Q6O1hvdXfeFAQgKuZuDMebqJ1xGcZFNlUCx0BKHFYR +g5Rjy8DFzT0ZSQOQeKho8AKJEVZNy/HAwpwczU9fo2nYI4mUhKf0gKl4YxmQmPHFJRm64pGUTDk0 +mPlNIpHgHDDpizrfWBXDXh9hC4ELdQLLkJgMDS4HDFH8Mi8ZueJ6cPbNOmc1F8hs8MJQwgZPZIth +Gclrs1kN1ol3BgQOO/cr9WOnSjSlYz5zWZ9wqixj14dGQCOgEdAIaAQ0ApuLwOEf/mr92Cm4JqH7 +DbXf7+bCp9NrBDQCGgGNgEZgEAIh0QnRoDg4KemlNINw2V5P/aDoh7nQ6K+G64qVZUVvpWEG9fHG +bLG3EnQm3VgqlqoF5TBIWVZ90mmNOaP8IG4ETTG7xTHrTStjGf+mzdtegdDt1ghoBDQCbzgCyr2A +uJwS80EvpXnD8d+WFYZhsRK+WPSeK1SXheaafCXne7laUGHGVKrFvZoXEt8jsKqB6cn28xKOsj+M +x5w623YrntWYHJ+OTzP8trixn2PXb8uW6bI0AhoBjcDOgYCsnsHp1zIck4Wq2u93O3zqoRF4wepa ++I+890i28kJ9IgNv4nDj+UYqkWi0RiGVFmplkvGka7XAsRzHdDwyGb5je16Y9QMrnWg0zM5Cqae/ +lu3P3miHkxJxy/frSGxbErTSNuvqEpMaEru4VpNt/Sue+3YImG6yRkAjoBF4vRBgXSriKVwqq8tV +5N/Xqypd7rZGwA8K2cojfZX7qsE/TcuzrNAOrIpH7BoPQvUDI1uomUbeZq4UbTtU41HLdS/houtP +ZEuFUY3pVDK5rq93Vdca1xHWzeX9mOG01He9tDbH1n9kFM9wk8AIYhmAjuuTU+pjM9OxmaPSu6Xd +yZalFcXb+rnq8jQCGoHtGQFGXN8LkVOFWvWxXSDgB7mcd19X8U/FcjuuZS56htAKfBNSrJWrXHBt +q+ZX0zE3sP1SGZ6VbkGoo5tSTQ2NHdmeNd25sGaWjb5Se2+p5NclE/WZZLXs+3a1WvNWdhVrVWN0 +Y6KvWPZCw3aMsm8ENUrwgsqyanLVyuB2s9PNpMY0J+a2pvfNxKe5dqulVjlvFwjqRmoENAIagdcB +gcieKmpfh3XlSDb6eIsjgAtSrnavZ93fm3+l5hfFVxslA/pZ3/DCkD+4MOaGsnNlgJCJu5HlxhO5 +oArnphqcdDLd0VtesbZcM/yYa1TYqDRwKiXZkasf/qxWLBQWJt8MilzXh8aYaK6GXxPzAHYCzvNF +j7uJuFkLa129y3PO8q7cneNaxja6+6Sd4xOuRLTXh0ZAI6AR2DkRiEyo4rDiMP6KxlAfb1UE/KDa +V7mnv3xrrrQisGq2FcYiw6ZtE1TSCAjaHITIo7gilWpV1PgoZXsKpVpgNMRimTrbtNxa2Vy0ridf +riCwQpBe0SjVoGQEUSNfqZm24ai9PQIj7mB5Fe0x/AqPivpX2JWdVYxqaJSqntFvpJJC57UYecs9 +/avG1PfXpx8e03h4xjk27rS8VVHU7dIIaAQ0Aq8jAmwpwcAIs+L3yxjKwKmPtyIC2cqTS7quLvvL +DOymRKg3TIydCKEQqsioWEl9o1xmVmTUfJEp4zE7NAPPDxtTCdsO8gWerZ0r1Hp6ZL8X6BNaFAE3 +KVwpa5PZGyY0qhWhz4aM6I6Lvp8vSxohbOFWSVmqyCcHyZiFNdY7wq+mUbFrSzp67LC/vfF3pvV/ +u477QFv9kVFC/aER0AhoBHYiBKLIYqIAdso1n+25dqKubyddrfqda3LXre69r1iqNtW7qXjcC6s8 +MJEgFdkFGDujC04okqVwHJQrFvKG+kRoO13ZXLEUVmv5XFZywaMwImTJvtckT8TsasUvwsc1NlMT +ykTYxcSOElh4lAhbrxJqLCEKYb4HHiKxyMG5shclNpy4ka5D/ex34uLklh9b8Z3Zo1fMHPMBveR5 +O3nLdDM1AhqBbYOADJh4J7HXW7VG8AfNqdsG1m1SCvJh3rtraef1uVJvImaVSoYTuAk7nq/VXIs1 +LmbCiVc9JkJe0kn1F8qm7cVdw8fwCRfaYTIVL1Zqff3FUtmPO45XMiqekUQGddiezCiXjCoOvsR3 +SJiFslHF/8gy3FQks8o7EREpfr8morB8UibXep48dYRdW21U7zauGGFinUwjoBHQCLxFEGDPpa1p +iZhSxRAXOLUoEMDWlKXzbkMEih6LWa7KV59HHZsrl6u1OIXnvVK1UGpryLRmZlQ8pM6g5ofZUrdl +pa0wLBQ8WTPjG42N9qjmZF/W6OorFYo+itxS0ciVjGTaiLHypRRJojZmUQmYVAkkl9BwYLBklS1B +EUbFu4nSMQcgp2JGjRbSKOfhU9+/uzAudxGTuYtXcLSaRjm4cY7mWeRgR4yvcaulMTE75jRIBn1o +BDQCGoG3NgKXXnrp1jYQq1sQ4vPrsEoCheHWFqfzbzUCQVDurv5xde+NXlDtzwem7xZLRimoNDUQ +q8FgsSla+pfaF5cqKGrDwIQIwzIhkwJETNONGfUZp6k+tba72N3tFSu+adlh1VrbUbMThlkxqkXR +8aL+xQsJjpRVp7ZRg7c9oUD+fM8oY3KNVqaKoxOLVvH7RdmLwTWiUt4RkVnR6iLXRlvuYsrlYjIu +zFypBXHXRuQtV7gKs3Z15HuSsaZ0fFzcajVNmRnoQyOgEdAI7KgIEK+Orvl+6Ejkh2jQ3FG7ul30 +q+K/2F3+ZV/xuarvY/4sVDBy+7G4kXDtBKpa20RzW6qUSyyNccXPqFwMGzMui0jLZXyX7FGNydbm +xNqe/IqVNcv27aRRLfhdfb6TMlIZ4cVCybBdUf+Kk1G0bAaKrXlCrg4F4jZcE5ywlcqimuhAbCVj +Omn7oV+IrvDOiJUAWo3UwiLmekapDJuyub1RRNXsWrhGVYnVRDttfN/687Vez33FNcc45hjbbF5f +tP5HI6AR0AjsWAggaEClDIUO4QIQV3es3m1PvQmCSj64I1+7ua/SXsJ5lxiCdggr4cqbTtmJRGT1 +RvazjUpVfJHKBaNcw/PI7+mHWX2YsrXFbG1uWtfT1dtXCxFvUwTHcvrLHlJpul4ky1JZyBIqRRVc +KYvOFh4V8Tby6a1EPr3xaIWMAIdJIDBSMZaiOr39XmODWyzKnAsy5joHBbIKB1kWTqUcpNVSJeAN +4mu5EkD/sZiJatrziDHsuo5drpSdZHvJW21bKdee4BitOEhJQfrQCGgENAI7CgIQqm2ZhFQn5gPC +h9b9vjkPtuK/3F3+Ran2QiXArh24luM6VsEM8CrK1CNZwqEsmsFUGrLchQgMmELLJY/VpREf+sis +bERdl3EWr1pHqlLVT2QMFqz29HsOzrroICA8OLgk0mcV76SK4cYNoU9ZlByxoyekCMvyVbyB1eQq +QOcMEyMEGytWlpUaA8rkJrQqLwv8ikQbvTXQKq+QqKChVcrxw6AUUkvoGvlqpebbthNmg0oyFvOD +cmC8WDWWuNYEx5xgamZ9c146XatGQCOw7RFgYMTbF2Z1GCWV/LHtK9ElbhKBnvKt/cFVjhnUglrC +iVXLnARd+Wo6kdlrWqY/mx/VNNpxaus6u+rq4nXJht5c1ssRb1C8hyQyAyeWMWNCBjGxL1eGPmEy +s2bkinhzi3tRUDXyOUhOqA4hlaeMHlgIFUtqWVyTlL6X9TAcqIK5IrrfiFuxueK4JDSJ4PpqRBBI +WtGqsC/m1UiihYxJxnVo1aEiVL6GlAzXolhGg40CmVfNscNUPFH1SpZFPP/l1XBV3JlkG+NZ2rNJ +kPRNjYBGQCOwPSEg1jMkoe2pydt/W70g11m5Kle9HWYqVy0YqlTxkvFEsVasT6Raks3L2nuKVW9U +Q6UWOd1Wq2FPOd9fqpTKITSJUVNkUMcYM84YOzb23Etlw7dnj28p10pL12TLWEktoz4Wg327y1U3 +YSSjMElwG7mokSLhY6FBLLG4I8k18fuFGuUMduQTvS5EizwKVScMBGOu8ZYI6coC2ehrtApVnIQj +WiUjBlrKgVbRYcO1rNiB9ZUrU4Hwh1EkzJrn2ZbPQthasLRmrIRWXWuiZtbt/6XWPdAI7PQIiKiK +9c5i3NPHG4dAyVuyqv/yWHJVKpbM5nEz8giKhMo3T3SGotHXn13Yn8WPd1SD3d7TE4+ZyYSdLVbz +lSKGz0LkviuUVhPl8KS2+lIp3tnf09aSycSTz7/SDaGymgWWrlWCdV0ealui+yKhEtqXxwwpVpFQ +o75yrtbPcJcrCLIk5k9Uu3BkTCjW8SKd8KvpkUTV5Itow+QRlqVMWDm6Ct1CwPhP4VTFBjgV1s9W +Io8nwgijC6ka2aBcl4zhF0dGuNwnvoTpV4NXfKPdNia6FjLrq/5Rb9zT0DVpBDQCGoFtg0BkRTVZ +prF+kN02pepSNolAV/H2zuJVMads+k6+VinVQpaJep6Z82qVWhUHIhx0Y0mjucFIsmCFVaS1MJtn +uVMoIiN8aRhNTUYhZ1QDY9K41Ghn/EOLlpiu0d9fXr1qVa7oJVMG3sKoXzu6xEKKjxIK2GJe5Et4 +WrgNQos+RWaFYmVhjpAiiTnWS5bstxpdR0uMwIqimMOriFsSxgIMpPzD6h6ZigkHhz6iKMJtGLB9 +DQFECoSYiOP4ZsQcE60vBKwqRb1csv1knP4GeMexlkvIFV2wV6gEiwxzZdqd4VptUpk+NAIaAY3A +doWAjIkseWR9KuOdjG36eJ0R8INKV+Xa7sLNUBFx7XvxwSXYAp5HQVgl6mBNZFD2E4edUkiWNSyT +wmcYNU12m6n5CJqO5U4eE+/r91zDaxjtNcQSzy5pL4eVxqTRsc5jx5l4wkikRXYsox+mHEI9qHiE +SJyOOCIhkoo7EhIqi2HQynqRhEoQ4UjiZHUpojDtQjnsBIkYIQ4zTc2NExqaJz25pG9K24GOHZM4 +ThwW7w6uw7w5tJe3B+5k71YiclUrVZTW7DKHojpX8cqJeJBImkU2nYvUxwiycYdCqrVqIP3DTS7a +xRf34CCs9Feedu3mpD0jZutVN6/z66iL1whoBLYpAtAoUgcyBDH0ORiB9fE6IlDx173Qc4lfezkd +F4V7jpj0hk3sQJgGQoU4kQWrHmKkiJWubcN20BvLSdnF1A98pMlCAZINyqVaR3ulocVoShpL1/UX +Sj6SZD8sKP7B4qOEdEhe+RoX66ksgMGMKjH3I+qDAInYEK2BobfilxQZQckiXkVBoi7WOq5pxphR +s8aNmjO6eXom0xyPQ5/Gkw98s6lhzHAArbcbsPZ1sLMR5O37Nfg1X+gMan2m1+F5ZbrDnCGbryST +sqM5NldXpFxps8cesGh+WVob9HaXH03FxtfFZ1im2i5nuGr1NY2ARkAj8FZCAOWdaOXMaC1N5Gvy +VmrdjtWWbHnxivz38/n2wMfAaSXi1pTmsb3ZfG9fb1XWcUKaRlHIVdyFcPDhSKVMJEuo1CsbRaIg +RV6+xFEiaTxjtIwRDg48i6BIuZyPZ1A8Ld655IUj4TOkVEiU0sTnNloqgzZCdMEi+q73VJLAEUjJ +ZVa0NLSOmjVh/N5Tx+3X1jq9LpMRuXXrDmjSYnGq25BJNzCHKJVyfdnlvYVVNaNMaGKWDcGpai0X +GmRRk4gLsY/4K++kGZZrq6tBJ7SasCeKflkfGgGNgEZgO0AAm5fYU8U4po/XCYGu3BPPtF9i2jnL +s+NxVgXzX2z5up5aZKWEUBFO2RwGXuRESDFETpXngUWTMPlsg8qyVEgXORIegl9YkErIhTq7ftqU +1kdfWkpGwj6wcAXZFA62vMgLCWkVoqJMPl9lViL0yooaQ6JGoEm2vXRr/bSZMw6bOenAttapDvde +nwOLKcyaSe/RUp65tuvFcmGlnRYLMbvA0ln5o17VTrG9suqG70SNqPQVn88kO5P2LNusG3nTUEez +0yu6aIzCEgRZ9AKVEBuuV2PtbCwmcU6Yb8hkhrpZEozzs3hvoQ1HcRO3rYxlZGQ1kj40AhoBjcCI +EYg0viYDOvZUhhZ9vC4IrMvfuSr/i/qMVyjGPWykflgpB1m8eH0z7oj2PW67BXg1DNGLJtmCLUD3 +a+O8g1ETBiXmL3F9MTzCEuiEA2TZmpEaLQzaWl+3ors3X5Gt2VD5+sSCYFkqYijLQ4VHRMernINE +r4/UCGFIdEOjlDPq3LHzpxyx65QFY8fuGmfjtzfqSCSSUyfs2Z+d2N33XDnstOp8lM9OYOLbLFhE +r6El8ztcnaKX0gpL1S7P7k860+L2lI00EwotBWEhNApekK96OcOsOhaUXMWzGHcqZHuVUYRjy/Sq +vPRhzEFIlqowZrPZLKyLdTkF32KKJhmRoOwGI0zZVqMZ1ut1PhtBXl/WCGgE/oUA4wl/jEdqPq4F +1X9Bs63O1pVuLIY3TWkZvbqn24rX+lmQGZh49hJkHobza2aJzU3DWp5YunxlXuPLBjKJiOPQ3EKf +lbxdYFPxKHQRkXULecNNGnUNhukZSzq7+guEwBdjJApe5E6SScwHWh+FYhDZC1pFVINQXQlJCN20 +JOccMveE3Wcf2dTYtK26ubnlNNQ3p5IHLF/zVLm0qqnRLRQDCWIsmwTwRkYeS/RBiFVcgulgJagG +4WI/LKacXaMbUiGabD/I1oKeatBT83LYo0XRjc8XBIqw6UqQMHTIuDPHME5jrLVEQeDacVbHFv1q +uSY70eKhZ4eEU3aRl6tBNV+qxkhiW7WwVKuVyB+J7txusY0Wy2jSOwFs7rPW6TUCOxUCIhcwbmDh +i0binarvr29nWavSWbh2Ve9NcSu1dNWaQjXPSB1PsNTEZv0o/taBF/YXAxx6xVCK8tMXMZQR3PQJ +9StRGGpBKF5LVZHkoFKhHBS8SSPTIAreCk5JYQUCaExbfSxczYvemKUylIAqWAU2YsYEMfNs4exa +1hjfMHfvfc7YbfqCVPrNj7WLoXXq+H1XttvF/Kq6dEwCWyCrRw1GPhWLrxhZUdeGCVc8gxHcq/5K +1OFxe7JhFmp+d2D0EjUC3bYSQ9GNo/o2JViiCWII+KZNeexwRyh/WaQrOwUbIVuw82/cMT0fN2MS +mLI9QMV38ObyrMAMSqgCEJ1tk2VBEDql2JZXC9Z45lr8uqBVx2w1jUbTSL2+L5AuXSOgEdj+EIis +qPhaIq0qtdv214W3ZIuJarui/yfF0gPlkr8m31Py8LoxGuOm5VswH+M+llGWnDLoV/KmWEmhUliA +aAnYUxO+bC3u2Tj9QqgiiAayxhSaZNUNJr/6RonnINufesaYxhQSaUdPRUyBOCWxWsaU7cehZJTD +rKuBZrJdRnNi1wPmnzl39mFvpJr3NZ+M7VgTxsxbsa7Uk+vIxGO8g6hhfVCJfJcAJJEIS5WQTetk +Tx46FuLDtS40OgmIHFlJ4Vk6ypyBmQR7QIh1lFibZCc9Miyb4ZEAzy+WBMlUQxhUUkfzSCaSFv7U +7C/LelqZ0oQe64RFQR7FryA7pUPQOHCJyCv2XWKjMBvqqhk9rIMy/EbHnEysqtfspk6gEdAI7CQI +KCMqoiox7pjBM+DoYxsggL9Re+kHnYW/V8pmqQLTyXqYuG0jicKn45rTPcVSe3+tXIUz0EXKSI/Q +SWxe5NQUm5sS+N5wfFSW1RB5lMeDeAo38HjYRZW9xwkTiCewmFpLPLdwNctTIRUclIRaxP8I2Q15 +imE/mzVitdFvm33W/vNOeyvIpkPBdYjvMGrP5esezBmy8Q0dEU5Dmx2ZOZk6QKXiwcVUITTLnp+M +iU9TpVp1o3AVOHBBn+h4Mb4i19qukCgX+cRaisW0UMaECiubJnuwAyv+eOAGahimWbuD55LnUzIR +LGgbcxpOXBS/EucphH2p2cc2LUt9+GYmY9xNV2p502IFUrFmdtjmaKIq2sabpkUfCqm+ohHQCLxZ +CMg0PxouHJnT6/Wp2+I5EEGop/K/3cUHazWx1KG8RJIyUNWyhgZP3YTdU6z0ZtmlzUxnsOWFxLvP +5yOlLl5IaC+RRFlOEo3vJfZPjXxrGOspBBIxQ6t+lJ1K+92FiGUDO4dOuVxLN8jW4uLJaolaGFbC +pljuSsweu+Dt8z/S1jphW/Ts9SojlaxrSk9j11g7Lq8jjUeCZC8b0dXydoobkeUxTYBWmXzUfKYL +zC/CsAZBEs3R84jBJIlFAQB4yp5KY7GPyjTDJC4jd5H1edtl2ZJ4KYm0KobaQNWBcCxzFOYlkYbZ +h1aJrVEoe0T/R51OcuY30C3LiMu1frLGYzY78Tk25vF2I5athumYOck2R71eGOlyNQIage0BAcYo +Jv0MRAxijGUyVdfH1iAQBMXu8g+K3kJWqkCE7CEq0pQnsiMKXmypVdltrYa1TwINZsV/BsthPCV8 +CVOIa5LJglG/Lu5gTCUXG8iwnIZQhXAKj6q7Wp2zlyh+8TbiaRGGHuYmdiAkIfpMIQkh1/5eo94Z +f9R+583b/chIabk1fXoj8jY1TO4tLKnVikwLTAt/JCRIAYSuhSZfhNWwevKaAgLUqKRYJiwojLFL +S6xi+h+xabTgWnCIEom8TjJx6SW2ieSFUzmEueV9l7efkuVw4Fo055EqWdyDHTudIBYKJC2aYbIQ +878k/sOyO6ztQ/NQLNpgnhcb4bFnbI8RNsSsKXgzvRGQ6To0AhqBtx4CMmGXwciQsUMfIEDcH7Gg +VfvApVQqYt0Lwnyh2A9VBWG5XAkbG5vq002u1eTY7K0dt+wkUouCzg9KHaWftvf9IxZLYhENLA/t +buA7cRP3XbY+9RP1JsHry+X1ftaBHbouPjikCf2SQZQFBnQYtIK+VwVOwlcGv99oz1QIlkcEhaDd +7e0RisWTBg4gGiGsyePjSfKHp1JvhzGz7fATF1zQ2sq+39vHEY/FM4nRfZXlKtY/3ZEXUhn7TZS6 +8KHQpEQejryjFeKQKwZUvL0IoFEqidJF1C38o47IxwhIxc9IhFQTnKHfZMyJxW1MqPh+8egk7DDT +EtS8LFkiDawt0ZyMQqVCze6rngbsNMByG54CpSEWM4dhBhOTGROKZdnJNsaj9LssuyvjTkg6s0wz +tn1Ar1upEdAIbFMEmL8zbZd46Nu02O2ssGyuA1We6/qpVDIZS9XVt9msHXWSwFLzisSlrVZKvX0d +3f3Lly5/cmXnoqLX3lQfmz5p3LiWXXyv0fdaxrfssTp77fKeu3FziVchX6x0uMY4Gcdd0cm2MwFx +dxmBCzmUjKLEhBHFkooIROQjx0g1CKGywJRZTiYla1IrxGQoyv7hLE5Vy2NyWdmvjYi+pUhIVW5N +bBgu5lUJDRF5Aucyh8879/ADz5LRfrs66lNji/5Kce+Ndl2NFLOhSKii0V1PkxAh/Aq9ibgovki8 +urJ6F+YDw2JZwmuKFlech3mfxS+MnFzMxONEImZVKn69SKWlakCoYdKg7yUxcidpSCvCqHgaI6QK +d0pwq6p4xHOPW6zqAdUqATjEVUoWs6KRxtzLE2/IJMvVinjPc9Foz9fySXcXx2zcrp6AbqxGQCOw +tQjgKinekvhziDps5zuQSvPFTtPxW1rGxNxGF+5iCBYR6V+acNdJ8ZdONjY1jp1m7DnPO5lwDas7 +nntp6T3PPP3AU+atY8Ylxo01/VzTS2uXMpiPqnezuarlmA1py3WcYtGqiPuM+M4gVDkxcQirFEIS +4IuE5AQZsB84Ok/DY3j2icmA3Am5wpG4KsXgV5yBWWxDQL+CkaqT1aucwMVIUEh1kAviFsI1oYCt +cus7F3x+zzmHbI9PMpVqSpYTHqtCMUJH4qB6I0UKh8UiVmWLm0isj0hOVLp4MAGvLN512Q7PNLL9 +IqUyCxGxlDNZVyNYFYET0V908EK6rMBB5JXoVJEzFy9/VDw3eVIsvGEqJRZWqkbZzMJfnIrlnkjP +zECZEllJ15Z62bwOnXyAcr6aiDuyZW3VAAAgAElEQVS+zyMUobcW5HtLj0dRFSdLW/WhEdAI7BwI +RHYkUakxw8ZH6dWBZefofKmS9YP+cWOnxdyM4lH1qXrP+b/J7qJXlHCADLWJdGr6pPmTx81v7zz7 ++RfuXlu4PpEurOpZ1V+wZ49vtuDAsFqXMMvVIFeodPcx0qKfDPHClYgDslkobsChG2P5pMHSDcZ5 +RErbt1ELi7GOgR/P1Wh/UwRQvuJ/I2Iou8S4EpKwyrJUdJamkG6Z4IKRIRb/3kQ46T3HfWfK5Bnb +6dNznTjq9EqlFHdx/5Hox4qMQAOgROqMLKkJNoljFWuk60aRG1TZfjWKlcGzwYZBnCkyAiPsKVwW +uSbx4JA9cZ+GI6OiuANvWjwFxErmK/wEIhUxAqhUxz9sqBdRoZQWWamjlUqoFXyeAjEVHRuNPubV +KoKpCKeWj0OTBGYyzGypTFayV/wlftiXdGZbht4GQB6KPjQCOzwCMvNmQs/UPPLo2OH7a9xxxx3n +nnvu7bffjv6vpbllwti5rpMeTKUKAth0MKECEwQmhlZZV4GBs5LL5VavXX7vnfcXi9k993LzebO7 +L2yrr2cd49qefCbpoKFlxCdMUiwR1jUKmyI9IfF45RBXUQfdgIqVH3EqCl72lmHlKpuyESVQkQQX +MY7meoVEGbQRoSEMJFeCPyBdQaWNjUKxcEBfvxGvTXnPUd/ffgk1gh1n2ibZ8A67ZURpTrS+RagN ++gIB9mFFghXTqlxSvBWdCt1isYYaEwlckkSU5EB8BBzyouAlOxlUTr4qxThO1BhQRU+AbkBSsfYG +KVP0NpJS2Ffywb4wcw237Zp4CZOFqrPFUhH1Me8Dhu0ovWh9UTuEQQKVNHWz620V4bi3UH2yFqyT +BulDI6AR2NERgE1kXs6avW3e076+7J33/qMUuKwaieHME1aPPuLAxsaGoRUtWLBg8eLFjzzyyOTJ +k4feHXxlQ9lx8L2RnS9duvSWW2456KCDmpvHqhF22Hz/VlEkOKI/ZDUFHqiEteOo+NXVK7vOO/+s ++QePvui709dlaxOam2Y0TXh46Yt2zM+VAwSWGGEKEkYmcPpzbNMWefjKcAzaUmcsRowe7IE+YzGi +qs3mblAmTqRF+WNFDfITHrwcMoSLXGXgGMM5RAsHUEgsLfzKrjLpYOq7j79s0qS39IIZ6cNrHYlY +A2tjBA5mIDj3qgj7skgmEjcJrC+72Qg38uzQ16KkpUiCRoEhwQPhY05SabNQAG24VZS0ICaa4ygi +EvInGWVpDlQZSZ+sxoFFIeOk6yZiyZ5CLjJxR5yKitgK0S1TuUywQhyWoiclwi5PQppEFdBqtOm6 +6Js5qjWPMIfxkJqlkHKtIot9goWJWG/Smi1ErQ+NgEZgx0UAYyrDAwcD2bY8ent7v/yt61YEu8w/ +4h1HnXL6Poe/45XqrC9+4zqub1k12Wx27ty5xxxzzJZlH8ilpE+2094EoarEMmwzLrMVDEJqRKs3 +3njD9KnjLvveJTVceGvG2HGN1956yrmfG9+bDdKJ2OTmlkeXLQljZcp2zFhbUwZHUBaU9nZ7/TkJ +5lCfEjmVQoEczLG6oYoU4UhiBsknIztOSfgcMVjjIwN/xBKylobEiLw4A/OQELAgGzyBGbKJ7pvN +G1529GmHX7IDECpox92GBJ7Q7MkTvZfIerLuhTiFEQXCYzAVoMFMQmeQIqrYyCCNNpgpCAYMtAgg +GY/BY4JnqRwgv5rr+U5Aoyg5ZGmNMCtgkoUa8UPrL+UTrlmfkT1q5LlEjgaRR5JUSl4eBC8FXlEI +0Pg3IdMybcIuKzvbSFNhWFJaRSZQJAyN+mQ6yZ522G7NsFBeXvCeFU7Wh0ZAI7DjIsAvn5GK/kXk +quh1q3vLMPj7P9z++6Z3rWgYd8fL2QeW5u96JbuudeIfR53x+9/ftmlnqLPPPvvggw9+/vnnTzvt +tDlz5nzhC19QzUFh29nZiTjL3QcffJCLKiXS7fHHH//pT3+aKx0dHZ/4xCf23HPPmTNnvvOd73z8 +8cdV3uXLl59++unTp08/4YQTFi1axEXFl0899RQ8feGFF6pkJ598Ml+rREwQNxb/xz/+8V577dU0 +qnGX2TMuv+x7ixc//4WLPpfN9v/8yp8ef+wRtbK7eM0V//2xv/3+ynVVw8+knD/euuhrn3riEyc8 +ff5pz15z+bLOjmKlHCKh/vBrSy755POdK0vfvfClr3zk2ZuuWYUUU99oIU5BH/jEMPqzFgMqJeSA +49gMz7gsWYRSglYlWl+0t0y0XTkEwCH2P/bxZnuZopFblzl2/4umT5+murC9f7IVjB+wyoVJjHAP +srgDRBBRxEQAglzqRvSGfMl1GE1cdjmxTTyGULwyO8ERjLlI5G0WrTXyQwzbQsH4WiMAQ6VQHNIq +5VMEwTFYNBypmlkhU6wEFTb54U7kJOUSV58YGl5EzJJW/IQj/a5Ed2LSQ1EqYiIuwZTJf+K3RIMj +MbpULSEg01Iec9TgnqKvaRV49KER2IERkGE6GmFQjm0jTq3VajfdvsJ3M690Bn9fad613OSTc67c +dPty7m4CzhUrVrzyyisw6K677ppKpX7+858/+eSTpP/gBz/IZ1tb25e+9KVZs2ZxrlJColOmTNln +n33Qx7773e/+wx/+cOaZZ37729+mkFNPPfWll16Cwt/3vvc98MADcDAnt912G3nXrFkDrRaLRRK0 +t7dzhWPJkiV8VXR7ySWXfOYzn2H8vfzyH1140RenTJs+unXM8cedRLK3v33BJz/55bx/b0f276uX +ldetKzFoPvVY19c+9Ux/p3fxt+cfdmzLrX9a+/nzni+Ufd82utdVO9dUrvjGstYJyXjSuu+vXe0r +SiKM4TiDzZWlMrg0mWzxZjfXOYTOl4vIWMT/YWgm/h3nkdMNIzgpsa0KmUQKz861xgG7v++AfbZL +L9+oExt+sEwmDGNoBXgr4b9oJwDRouLYRa/RAFdqIbpuCA/tNwf8BY+K+5FMMlDSirOuIuBUSlx+ +AVkoTUIMwnbybAXt6F+KwhNYpGB4jwIEcymqUhXfMf7KlWi9TSSzKnGW7KiCWQGF8IqqgK94a0v8 +h4hoFc1TFFXQWv6ikrkgXCu6Yu6EHaVwoXRAHxoBjcAOioD83hGNogFHzrb+gN6W9zhtLU0TW9mG +xcWNs56tpcu1lZVgea/D3dcM4w4pvv3tb29paeHkiSee2HvvvQ844AAaVldXt4H69/vf//7b3vY2 +bt17771Itwian/vc5/gKp3Lrqquuesc73vHiiy9OmzaNor773UuTLPA0jCeeWC/Ccj7scfnll3P9 +Zz+7as6ee4mrC2bUam32rrtxcfLkWQccOKPH+qZlCdehnMRf97Y/dTCUn3vuXvsc2jBpz3GP3t/7 +0vOFxQsLrZNTjLwcJ58zYc6+mXtucv5ybfvyF4ozZmVQ57IiFq1kLC7LWOHO1Z2sYhWrqsijkZaY +vFCs6EKJ7YA4HK2oYXUmIm1Xp9FkH3Tsgg9J6TvOgZtSLF8W0hEWVazJatFIncuDQBTlOl6/UZx9 +thoXOpR0keMQCXiZITkuop7lUWN7VnMQEgm5kleywLJSuvgSCPMBOKKqnEf8hx03olVEXjTJir+j +sPskY0LoEnBYthuW50ImVNHJOJEUA+hctmDluiERg8VcgDMarSEUMe0R1yePlclVr53g/XFzN4Rw +atSHRkAjsIMhIMa9kA2vGWwQl7bFgWg4tqkar89MawpaGqz6OI4bZm/OXt3nl5orm9b9qvohUU6Q +U/kUoWLjx7x589TNZcuWcQKnqq977LEHJ2h9EWc5ocAbfnP9X/96K0pdvrLLmEo27GdXVxfm20wm +M2ePvRAZ2ZgU/00O2XENAdEvZe1rKt66QlGKkgHaMXraxZto7FS/s68bFeXU2amVy8prVlbGTE8h +JHFM2y2VSBnptHxBzctebwk8kkKbrbAZ3ssloiGJ0AO/IpwxcK9nUMIwCQGIQIYemD85p1Ji+XY3 +vPPwj+H3S4ew/8mT2zZPT1r75h1E2SWovpgzZapHj1T3EdCrQTIhYeyRUD3clMRcwU15ZUUujPZ3 +k3c4uk4UCDTAcVbdsDMt0abWs6mUKWQqjkXCrHJQhJpVcjnyKoKY0feqi8Li8rvAGduSEEriOcWu +Bmh05GvcTfphDbk2afFsqjUrCiJhWoSWJMaHqO4jA68sTUbdQH1sNQ+1mixsbUfln7D20LQaPQP9 +oRHYkRAQRw0UY9HAz49+WxzYZo/YL2OtWrzPRHfuKHtavT27wdl3oltetuiI+fXc3eJKFCMOm33s +2LFcR3mr7iKncsLF2bNxtjRefvnlO26/ExFZlbD77rtHfkKSloUx0DbOU8p/ivNRo0Yhzubz+ecW +LmQBBSsiqkKqeP1K+rL/nO8+qwx+fEUiSTr2qFYY0nh64ToWoToxa/VyRC2jvgUphfkKp/ClLHmM +lqPKmE6kJBZHQtNYUgmKRPCBBKtokjLisxqnWpI4+JArVApaaH3hY6XtJC9X8n3GnMkn7LrbLpUB +Ytg2j06a+uYetu1CY0wUmOpFYmWkBhcJVZSxXIMX5TrkCTjwILwUyXsiIELG0fwD5pM1N3BYQi4C +I+nXv+LRDE1WzPBoZMYWMbdicPyEIzYFAREvI8co0euyUIdVMzwOVPFQrGyYI/yaKxFDkucR5kqy +9w054Gs0wCzIwQmZXOiWI9uwOFKRMcmMSZbviAW46ndV/BfeXKh17RoBjcDrgwDBwplLywR+2xx4 +2pxy8pETV/zihacWj44bk+qMtoxx211PjVt6xSknH8XdLaimsbFx6tSpUObDDz+MEDm0hEMOOWTC +hAlPP/30jTfe+Mwzz/BJmjPOOAM/I6ywCxcufPzxJ9atW9fd3c31iRMn8Qnd4nqLqfXKK6886aST +IFFVLHrEM888i/PPXHD+fffd/cxTjz/00P2Q6uxZ+3DxHw89+twzPdl+T4K8ytbWNnLJESe2cH7n +zZ0rXy7ee3PXspdKrePis3dN53KShmO9fTQiWMZ9dLzFYlBipzaJoiesKUtlkFCr0K3EnhXudAyW +qyYyIrwiIbPABk0mJ0TPD4qNe+3yDhyS2XgFOUwkV1XNW+YTbYTQyOYfYcD6IpmIQKLrDZOgEfEi +hbGJG2IimnCxLq+nXrVNG2+v6IFxPxL0xGtJCgFqGhHZSiMrNcXyJ7sRRKuaItoGeV7JKL/ALoEP +pfYwhj+28oeKfK2lVVGNqC6Y7oA4E7R8iY1rpKNooWkYaWTnOMIbmkS2FAdl2WdO5GCiAUu/aGDF +Y9MDB7WzZ6z1jBXSVn1oBDQCOwoCDAdKFytjD4PUNjnQrCIg/sf7jut54uofXHLxBZ+88Lvf+Frt +uev+89xTx40bt2m96yYa8KlPfYqg8Keccspvf/vbocnS6fR1112HAHreeedhc4U7f/KTn8yfPx+J +8+tf/zpEjh6Yke60009Teek58iguTv39/RdddBFeURMnTpRb0bD7ta9/8/3nfPDxxx79/0476cQT +j77l5j+zymXijPojT5i09MX8+e9+pjdbqauT5OwxE0uGu8yr//gXpvb3ep8+e9HlFy+dtkv6o1+Y +WqjI4Im4w8GQHc1Zoi+yHVtYKsstBl5GcKImFdWyVM9Y17GerZFWFRNHrjqi+BWrKnJt3pgy5sDW +0dPLFeRuKRzBjscHCW0Ri0kJ2+pAE4BK4KGHHnzggfsffeyRlStXcmXzCmflS/QqCrEJb/FErFTM +jcVscJBbgYmbkvAiExIRWMW3DukQz1vwFAbFJu1GW83ITVEAMF2MMsoJf5ImcmXiLtdJz2IbScOD +YHO4aLUr1YoGPprlUC/cTF08QQhbiFYJykLjuDWJFBv4ZuTwFCWTWqRV9ak4cyZMrbLmR9a4YujF +7Cqbtsrmr2KOXRYYnZuHz7ZOjXrmzlePtWvXbuvi34TydrwevQkg6iq3CgEGhtCc/6FvZtuX3/eL +r25VUa9mZiQtFAoIlPjWIuHFYjE4Dw8jTKRbJqe+WrCBrAmzMjwNXNnghEpR544ePZrr8LcyyrJC +Bu7E6Wkg8UAJXKdtqlUM0mxLgyockxqhKkrl4qpVq+rr6hlTC7lqLXljybpj3ZpSruCNn5gqFv3O +3irDOHJkMmk2xBklzaUrCoz+bsrO5kThl8wIBQZVo6FexmIXjQBhZgkVVOUuyy2FwiUkIee4umAc +DY18QahR9qKRMLMS9gGVo9gXTSlKVkOWYsfu98299ngbykUX8cdheJaFN7ACB6Qtxb4+xze/+c0v +fvGLGyub2FI4lPX09AxOgPIAr2zp9siO7tzC1Z0vwWEcMdl+HA15mEm4mXS8UCmDG1rZiI/gQh6X +zEv4iGaDIiayqAbuU9kraMYjCmTvAcgSfIQOeWBInKBEFZGxlutQrLAmBlpoO2qnFAs1Ih+rmQoZ +CORkm9h0K1XifsjCZZbrRCKvZCCxhOwQyVgC+pOR2YCLj7DjFljNDOWaBjMDPJkQYlH7E/Mf9yf0 +y65NsMU9LSOaoEVVb8OPUqmEEQTtDp+85MwaeRx8MpscqIWVaUcffbT6esUVV5x1lmhotutjx+vR +dv04tq/GX3rppR/5yEe2ps2HfvBL9WOnMuJF+thtJ+ZAUfj44N8rrj2sKKECx4FZt8aYqvo5ZsyY +TXe4vr5+IAE1qnNOBgh1gE3VrYaGV0M7iWoOiUIEF9oswoVhjG5tYYM3r+JUg2d956FS0bNds2U0 +bp12pVph5zWiEsLADbgihWZ/uYZhlXj3xKiLxdmujU3jZLWM+BrL0knoTwylUk8k6qAxhDv5AneS +Bn0mS06pFG5gUI5nZMhGWnISIoaKhjfK7nqNo5umlMtFWmJjYWRtpUi7ODwJbcABcKvSf8rZG3Uw +j2Gt8FC1PJMSEFZW7ZG0BTmOLtBy+gKv4RFdsrx8RZa9pBO27/KI5DpsChpwm+xaE1GqBGHAmC0X +ZT9VBEUKEZYFSTy/2LAdFW60updmAAyZhH7lyciURT6xhrpywgtA7RGNGhjIKYRKOZgHoWBYz+hq ++sI28twiKR+SS+RjnkjCxYEZCdUjonBjKtPR3w9JlypsfIQfMQ23cHgjmcOynLAUWAtT9r44gEsp +2+hgBRqLth977LFhy2Oi+f/+3/9DfzPsXX1RI6AR2HIExKIkyjb2pWEcj6SDLS/s33LCoxwJPFPf +pIPuDMjEjNPD9u5fTsgQo2EyFjNEMjgyckvs1iBAD+tXg3K5L2//3qrkY2GiYOUSMbs3W7Rtv1ow +GhocxsVsLvBTso8p0onE9oEVGL4RMQl8H5NNTxnxZU8VFsYwfEe0xzgsOkx8SomXhIHQssmntJqM +t5IdmckT8x4HWWRdJrHuSkZdvI39WWvQteUiftmOOJgJrUaaTKEiWEHREtdHKh9KLVtzLFu2dCih +qgK7e8SGPcKjSvwF6Cqiw1LVx6tWxD4xNvuFksQmhPoIjQQZEqYqBLPIzAk74hJARkywkVWV5xgI ++WFs9sT5C9xEVH31BRe+5FwBxdsPGZM4YkeKAkvKYpksz0tqicIVYl7ld0JIB25ysSwGY3ms8uJE +/MoviEUy6bhTgkt9I42rkutXvDIK7Ja6dL4qQjaRPNCDROpl4irK/jdsTx86+ZLxQsqeO0KINp2s +r6/vy1/+8i9+8QtRfA86ZBry6hW0RwRIGXRTn2oENALbBgEm1tEPjaDujCU70EGvUPyqcWQwoXJF +9XKATUnJRdb7M2JGVChSJisKPUY7YvsGfrXm9NX+3FV+bsaYcR3lPGEIkb0Zfvu60feFda6dx/3T +KTGqM6AjhrIMhtUyFMrmM6K2JRVagCheEm5HbFTuexJjL5/30U2yWRsjH1UzbjOCowcW0QqXmUhO +EpqkJiQkiUggRXGrYqzu6l02IbmbZ8oCHvIKp4oqU/5nyOeQL+QlPaW/IQ9WeU1L3UMO9hsfcm2j +F0QijbgA+VKQwffHC5nESH+gyJrsQI7WV26FSLESvwh7JRpXphHgLOtEsaeiWFWip8w05A9azRIu +Q0JVCSDQJ49GISNl8QQJihR5QoGWvCNKk0D4Zfg7IuAqW79FfsW0AWdvnkVk3yUkhbgQiyJayB7v +XzsZc/MsjaoYo9L1hpljx3LXjjWm011etlT1UGhUWa5qmSli7aNoYEMilNl21gvXOeZr6GA2itqg +G+eccw4bRagL/AQuuOCCBQsW4GeA5YVQJ0uXLv373/9O5JNhp5iDitGnGgGNwJYhICTDqOHIdPvV +aeyWlfTWyaXm4wipnKjzwW0bzKbqOjZUXEoYlBFMCSqASASZYoJFcc021qXqi33B3clkHPG16pXT +sVjRL8cJrS4R3o32zoqTDNsa3VoRaVU2dINTARSxU8QR00wnRKjCmyiRFIJDu+tXw/4im9OIeY9D +jHzIrKyfiUI6cEWGflfomRuM1xIlONIPk72h0cjnuh969rJj019tHDWe/V/FcQkxNvRc32GAl3kB +Qh52RFQQkRpTkZMQq/z/eh0qmMbQ0llONGHC+KHXh73CoylXCnCbmklwErGbKF1BKS6xHHEKg5Ik +t6iDWViNpMhXeYklypLQYaR7ATLFvlICc5e4OFGz1Y8kZpoSvfQgo9QGJFBSrNLrUggEyQyJgxPu +Mt1BgUy9CKAUwCZC6tlRGlMAl0SRvArRYjr1K0LP7K7Tm8uzXS6rVMuVUkD4B8dkQRbTAB4NswIi +DBsxiYOI5T7wy6a5KB1rsIyt0uvg7j5AqNhNb7jhhoEF3PRlUnQceuihGMVVDE7poT40AhqBbYeA +jB5iupL9U0UQ2GEOpXlWhDowJY8YVno5QLTqRGgoWkGIsIFiDv4TEdUnUH5QrVTLsVsTTn8ynujP +56e3jVuyrh3C83zbcQmLY/h2GE+aXtnI5QN2pLFcMyixZxgOKUauH2oV8xv1ZeoZ4Y3+vA9BllD5 +GsR/kJGdiyLxRC6mNEzZUGXc52DoF8FTklFjKI6iotRNpY2O7Mu3/uO/DtnrEzMmL2AIJ358iDiV +CMT3hfE92iINrbLQKlkiSVck19dTDzx58pQVK1cSbSpq+voPXqoZM2eOGdM2+OImznOFDs/P0WvF +ZzArkr10QSY7fHpMZfjOFAJNL8EIYVV0vLzBrDEGZ+HgCDE4WMhSPefIxsxd1viKO1i08pWUJAR5 +qSiauChipkYYlABHqH9lUU3kHsyWQRKCA500eaI5EM8LayhlSgux4IpTr9zig5lWJFLL74qFNi57 +54idm+LRBVmBAyfjokzTRKFdRZMcBfhnxQ0bxFX8xUl7Lyloiw60viqImMpNLLDBhLpBkQOuBhtc +5yuLyu677z64mTkl8csI9jnwCxpI/MILL9x1110EWiG0J08Z1ycWrRFke8DaolJy969//as6P/HE +E3GGwLX47rvvRlYmtBmRugeCtOBOxUU2YaR2mv2hD31o2AUCyqf32WefJZLo1KlTCQl+3HHHIYIP +NGwkJ5iZH330UQrh508J7FKlgswMmxcPr4ceeohI4zixs3HWLrvsQshxGr9B4sE9JQYcIcdHAuMG +heivOwACjEgMAshU2FOZOu8IrEovOOBUHg8nIodHBx2UeUN0qBMuMyTTadhHXEvY31RcoGX85s+r +eKWSU7Yeqzj/DEp2f64csxI9/YgoheZYqqtCBCSYlbWSYbUYFiIHGTclfMlo3lwf88pmtVpO1UmU +JeAlTi/iiAzojLB4JEXaUKFS9I44ndIUWzZD5QEI40abkHNVHHAifSPjPKZZ/IfFXhuJrau6V/31 +4a/M6z5579nvb2hs8XxW3tQgYORCdmqxIz8oGeNhGgpXeuAIh9fpgwXE+82fT3jIrHg8+67rJJOp +GTNmTJkyZYQ1Mo1Z073YcoOk48g8QNx6zXLND9XuviIvBlUeKEtmUKpH27oh84EqPUSjq6YOQnIR +s0b0JjUDoEjqssBGPHWhVZWAlODMsT59lItzWFZuyQMRZkXipy3QJ6IqZzJjwQEYlgVsbnBEKgTx +BI6iGOKDzIlQO8+S2RKJpAVG3MRHjxesjDkhiWu4nNWYbiGo4k5Mn+S9M7pZWmMZ4rK+Bcc999wz +YCWFJ4499tgtKATyYCkaocRU3quvvhrZ989//vNgWoXG4L+hhX/pS1/6y1/+Ap0M3MLf+Pzzz1df +YS+82N773vfyE1NXLr74Ypaxff7zn8eRDd9jVrup67/61a9YLwdnD66UW9A8Ppmwl0qmPon+/Zvf +/GaETnCY/Jl2sOhucAmc0waOgbFC3f3/2bv3GNuzqz7wderUu+6jH7dN2+bhtqOIhwcIYZJxMobG +CZoIIfJfpDwmaUgcSIhCFGmU/BMpUYgiIhAMIcQiCgErjBJD4A8sgxhESDITMok9xoS2PfjRdvvR +3bdv33dVnXOq6pz5fNc6dVzcfvh298V925x9zz21f/u399pr79/vrO9ea++99mg0stDd0GS+PuKk +DLD/3yqcHpecbqnl04p83m48obf8+8XVA/bPGVaX/3yxV31oyPTdmLr4kQBUbVuMGwo4XQVQCWF/ +4s2ODplDpDOdKtBER4dPH22/ZzzeP+ANn6Oc9dmnLl8CkLwS7o+pFkjGYboNMkQw6/FoPLCN1Xnj +HNFefGbE2Lh7ppw5OF18lAO/NndiHCbc1WtjDHRkHx6bK433uyijBgAeQ8R3KUXiGPex1kYi+Ihe +FVkdiX84Hb3vsXf9/K9/929/+Bfh6frKGckT/LMFaxdgZvst4ilg6EBHiu6Wz+9FoI++9a3fxPnG +H/tjbxF5+OGHbx9Q2QYef/K9RyuX4dz+QcY2+pdn3XvObIInAyQt6kEMB0lnNzcyq82SUGbgHmRs +OqKtcDGgeKjBJ91YpnU4p9GbbViNhTadKKV7Q5EMSGrS2iNAx630PP8N0E6fly7bnRYl9cQJMDo+ +s+MB27KCeVIyNaDmh5USWQ0xrwcAACAASURBVId8TAedmAjI/G+IW3i1mRfNEKEeh1XKeZ0sWVr5 +ZKi/pMCv9aKcQ5YW8duPPPbYY85uWgBqF4RtQO40kc5AMf0zf+bPADmTtX2XH1DHVJzOeTrOucoj +jzyyANS+xSk3rRFILwC10+mRv/ALv3C6+Lve9S570xtQ7c5Cqt8urf7Wb/1Wau7pzM8Zp3b/iT/x +JxpQqbaO3KA6d87GztOlCAdq9A/90A8RBdI19i/9pb9kWCCOjvyO6Did/3T8NrvxdJFl/IumB8gB +uBPBEfiJIHoVh9M/19OGIz+PW1pVaBo4pTaSpHzDlhAn2LM8yZ+sTzqcHaz+2uWDj+3fHExGU3n2 +9sdnd9YsBD5wJnk23ZLa+s4mxMyGRkBG6Ym68cRFa2VqaRJFBBbaWrM2ZCI2o4YTKZROOJEdjXRk +mz12Eo8R+KhJRYgLUXdA4zhTrQJtSTb1WnFD5QK0kPXSwaff81++/9/+ytt/89Gf3b95sDHcomVr +Ar94+VdQweUTyiA2ONEgDV8LnkP3zgWmP3sfH3zwtdTWW8yAL1DJ/sGNj336/7p5+Fmtq0HAdDQx +pple35vcGI3BITTFNjRy9Bt77wEXu+sbmxvmp3OejGBo4qhUc6LBV31mkGSbTa050tv6jYVWEJEI +QfWuCO02KcBVGbRq4RL/Roy0Mqf4bAa2c6ssxlI8ozwmU921vsxDlBf8h2bToZe6GYBMjfUVrrxO +llJtrDn5fBXI7k/sY87SX8XsZ85UxWAt47np9cPZZ1PyxYfTmPqGN7zhxRNYcc4E4+r3fu/3WsT0 +9re/fUEBrC7iIo54slfHNlBnVEAd+Pdd3/VdnYHDMkrn6cyLOC323nvv/Uf/6B+9+93vfstb3tLp +sPBtb3vbZz7zme/7vu/7pV/6JTi3yM8n2iJuE/nf+Tt/py85R2OadhQjBviQkcjBy3P6gVkU78iP +/uiPsqOIEw5a9C//5b9UCj99t5XLRZGf+ImfoFX3JTcy6vrxH/9xTtwWLWUVeOc737nIfzpym914 +usgy/kXTA6XIRVeNEIGsr/aGNaxGQJFwFQwzJXaQAE3ngJoZsXg2ZxGOzAyW0kXJ8qOJJb/jjb2D +JyeD/zKbOGgsy5Foqmd2TVDaEQoE17lxz9njw8H6hjNrVrZ34SJByv/D8PyZreidW3E2qwBxr1/F +19ZzMmg2dUA15sDy50DpIe5lkG2/zLcuGwB6+jPSWWZ+8my58QGoRdm3IQFfS9ZJgdbPXv3I//mb +P/Azv/y//tpv/OCnPvPbh5OjrTXu6DNOYqDuMQWuVF300jUS2/hZ/fTKfBm5PHnpo5+69J8OB89Q +9YxvdG4wLE+q9T3Lx8KqfoBM0yMuk4wwjp65ucds35BmbtKDCKQVhoE3QZttXkJNG4OvpX1mRMLq +XmOLdEot7mWKD7KWTR5B+6la/UVE8SaLgo+q8yDkL8+IJlk9X9O68nh8wc/0dmqXIo6fRdybtj8+ +wOXO+g5UNqXqpfJoN9bW+P9w1hwFNkNbL9gKTKqRQhW//a+Xj6nY+8mf/Ml/8k/+CWMDYFiMiihe +p9mAMbfYWuHcIoOp1kX8dMQwy9zq3/pbf+tbvuVbGFoXt/w2WZhpfqYhqa2LX66Z10UeeLYwa1tg +1XkQdMpy50Fhkfk5Iwy5WtS3nKa80K0XGGm69Nd+7dc6g9fy7//9v99x3mPYqDuuXkQWO+Bxgvm+ +dfr7NrvxdJFl/IumBxprDLMDG8/5frxamtotwa1I7GsV2m4DN/uy0bRzxuhnAjW+HSgZ9DnTlUcO +8VobnDezeenKh5/Y+8nR0dNbG2cJZXsKEb58eXz1xshSIR532XWl8wDgzvZO+WqfDk0Erk1Xn7nk +TJIcNEYN2l5fo6GKWAQ1YjEuey9BjD9EuPAVACr5Hj2y0DcCuo20wMA61RLQzML2uQrksAz51CE2 +4YE3A/tA6jy4K5NP/+cP/pt3/cr3/ttf+t7/+F//1ac/9dHDcjy0KT8eAk3BjGwP6UU6pb2F7hc8 +jMcHTz79kY9++j88efW3Ns+NjDlgoR7wzYqrx7QxoFM6ZcBML2UxrePB0z/Z++SN7ZnLQRZpRbYZ +MRQeSxdBzegEjuoi1MChb9tbJLqrIr3nu3XQvDL6tiqSTTwKfXWLzFkqhR8PCH1dzT+zrivgNBva +Ih63iCgCfTnQ9g0kPX2MKcJEzBVwXEEdj6CwnMYBPAbbSGOFMLOHJdyeyehwdDzbmw5eyubRxWuP +65e2rNdcI/tqvwt2lvdBxS6Zbjrx2d+2un7sYx9rN9p9FyA9O5uUH/uxH7PAp2+dXjzF5+jCUs09 +yGL5z+JnqwgP3l2QDzXroVTRQbzTP/rRj3bk+b4tNcJq3/0jf+SPnBA4tF6d9nwLES3iFKwTeQI/ +PW/KHRVLdd9iA39OpfwldGMTXH5/EfRASYOIhmg0JY5e3Y2Cl4ufYgOq9pA1neiuy/4OlPpkli6m +XqOK1eHW5PDaZy7+5w9+7Fcef/K3/+DXH2yt7ly7OZpMD+klFvhOZsebZywCXbviKBlGyNEMcO6e +tTcCYg7On9t46tL40mWq4Mo992XPIr8/wbDZETg8PFjjGZhcbrHrsHEie83JqVsR0KRz2y1LSkcf +jcZDjtGKRHuZEvyoSxhAM0aqLaUKkvhaBmyiRdHDBqPHnv7NT135ze1H33nv2S//8gf/0Bse/LoH +L/wPZ3bvd/wZuApalIOh9Icqv1ChmDzY379y5cYTNw4uHq8cxCHGdlhg3w5oGb4AuYl9J9VRNYcK +TYGZXoWUek9mAxz8W+qc/kwf50O/awqGCwFjAAmPIbECABLglTMHVXia44OMePI2sPfWBl93c5m8 +GfEEay0+qp6XB30VNQanOqSqz+Gi6VJeKZh/IT1Le2Nt4zQLwe7mEFqaIQhvFpkxS3iTaihTIG5c +wPZLVTU6g7KMIizAFgN/cmPlAqtwcXS7X3TH9773vZ0bxph0vN2SJ/kWeNYJpydQTrLkr18QD8Gs +oyyirLKnb71AvO20neG0K5jT6e6evrWgtlDBaavU00X6IsJkbRhxGvwWtzqyoOASigu3ZHDJ72kn +nla1bUm6JacdSYsUS7qeneE2u3FBZBn54uqBkitWikZw+//qDH7kQvMu0npDX55GUynzbGUCjXCM +/smnHTcOhx//1Ht+86Pv/uzTn7x2ffTaLxs8eOHM6GCwf7BP05CTPN3ctdl/eLjPTytInVkHYx5U ++tHk+Pzuxo3rR1euHZWNN9VQU27cMD1L2PMhzHXAUXDCKqQ6LyyQRoaWOTdu1scRx8Q6066PVUtM +xGQwMyNRXo8o3/IryKEE4mRztLTaKMICDGziGbgMmBwznTmTu5PJjceffvQTTz363g//23O79967 ++2WvufCmB+9985fc94bd3S8/e2Z7a/P3XlHNkWcOGd0bja/fHD21P748mhyYKzUg2OIvF3RNa7mW +6edaTAtBezyh4Rql1eBQN7oMQNaD0C10VvEor9OVcztbCN4YTbbXhzsbazfG/OsWTlNBS3dUVueY +gU63Mx7srlhKJg4yg5+l+udtQVECSK7Xw8TqcWm3oSVPwao56fvObJn3tE1W5+dEORw4hHzNIqO8 +a46jiackHFQwJWzEI78MlFd4OcfpMDbYHOJ2dGZ923CNqeFoepgmT22DvjEYfnpj8MYmcpvfC7VS +/s+rt90mzWdn8wv6zu/8zj73qe+yhQKzW1Y2Pbvgy0l5Phddp2lCxGfD2yLD7VBYrCg+3ZaFpXdB +itfVRfy0gr5IXEZ+n/cAQTCIV3LCK8P7V3Hwa9cY38LcHBcPO3Ml9ZaGRW5GM4j99uOf/dVHP/aL +n/zsR0yaynb2zOC1D65cuTyZDo7jUSFrblfXbXThvXV4dOPgyBpdwGbSdjyKvN8mGoeDJ546lA5l +6UAQkYGXzLe0k9GVfGVTXl2PIQAckrdSKCuyWD2Uy16yVNOlkJVaxlwpkL+EbXwCszqCv0jnslUW +8NBhs9yU4sPLBB0OQfTjwCcuPDBABQTk0W5XnXxz8fGrFz959X3DlXdtDHZ3tu8/u/vgA+e+9MK9 +bzyz/brzOxfO7F7Y3j63vsa7T4DnJQQ8pP8BpdVCh3uTQ256QSmfQjePjg4CGDisDyjHdgYceevy +IOiOsb6XJpq26JpAVXrACEa6iLKxitMsrbWuXk1ZOu7x9MLZcxvre1f3TFbngJraC1XDkcqgt4K+ +rOt8Ldk6vLuydz2PVc8Hw5CodbzqTNUqKlXek3Ir40wZWIl9J0eqO7OzMY73rMRlAJl2x3iXAuHG +QFYwyQtxy+TLJjGHVS9lnbrDM5RaED63tXvp5k0vydbaJg+YNFo2/Iwl7G5bfWY2+3In7oTW7YXT +c5zmF6lifYDE7ZW+3VycjDegWrXwAz/wA3avQp1HH32UQfV2Sbz4fJrW06tMtSY+n1OBXsz+Pif5 +051jHpR7qWdnW4zF7QFb3F0A7SLl6ac/d5TQ6Y1DiwzLyO/nHiCUmKVsBslPFxS92vtCE4j1XpfU +bVlYgBdNiyAmOktCfubSB9/34Z/++Gc+yE8+hzybm5krPXthtntm6CRym1LSI3B57Tj+eO3iB2+r +EEOnTadWclJQLERam126QnAC4IHlnZnGI3zNaRHhAydRl+nSdBr9khwvER3AKGwg1iFEtMUyLXJ2 +G0DlN98DkUL1hKZWKm4EUVIfvKy9rS3fEWQ+Pdpasf810p8ch9nAqRz1AapW0Ya7ZWHW6lJkx+M9 +n6vjxz91+b+ufkIhm1q3d9Y3TB6vr92zu3l2e/uBzY1zW+tc1u5sbp7ZtKllsI1V4er1J1nMbTuC +Fy6jkFvaNeX2IHOd0+l4yp0RnxmxXPPDlyLBUROQVRz/Ddja0iAFXcCVHsjQIa9jbUGJpRSB6KMZ +FhhMWHNEs4tv6vSg4vec2eA4cDQ5vL7PM8dVfENTzv/WY3GZI7HxQUZFZTrOWAEq84i0lSlwHjkQ +UYtEEa1rFVkck/kUlut/HAqhCWIdHHTAJ/ERO61my5Nm4JQhOufNOcKPN5D5QMFN71mGDjV6sHRc +Vxj0KWLn8fHAouLD7eHa4fRwcy0mXzttTL570YxMjmbX1oZXhyufO0kp1bxg+JN/8k9yStCbUrgh +/OEf/mG7P1+wxEu5adVuF7Nt5q/9tb/2Uki8+DImYn/9139dOeuErQdeLBu+fUqLqVxF7Or5u3/3 +775A2dMA/Fu/9Vu35DQ1u0g5bRtYJC4jv597IMPlWve6VkpDiYcveH889thjvb3MgNfBq8a/L4qF +qKUVFkqqZfF2zr3+9a+XHN2gkNF0i2mSzc3tN73pTaTeletPvP933vnBj/230fX7VtbPbm5etoyT +hZBYfIDbH7Kb4MskM43BRslhLdCVBi54MZzxek8p2TpTa6Zng8k4XRfUKSUvKk6JUc6SxM2ruRsZ +DREVpGbZNMLmyQIJeoTa3ZjJthLfcQLMVZOCLdwdTl7uILjsJ46DlBDXUiMrmFoPg4q8GewFvQRc +UnxjTYSgUIQMP+BkKfWqdIOF2ZJjzv2bTqydstzYm67c2H8Go4orhVvwDFuQjPqbqEn37/jEk/+l +TQEygBntVySZk6EQsSjAEomepG83vF2NVZh3GfeN1dI5t7VyqscBwTZ5NKFURnSMTBzmouvsT4pH ++9qtpHMODrh0Dg9aDcWfuanTw0NQVxOKJW0Jus4y0EHQc0/nTONTKSb0mpbGYZhURT1xzwoP9cNI +ioIZ30QbTrdgY2DQszLdclFtTiJ7PqrA2CbliigOvI0PPAXOgW374eEBEfUYemRBci1U5mHfhMvO +5sb+OLptqtZNGNavnGWuXHxRmEqHg6OLfZOUSC+/9TLPVuC4+LFRxGbNNOxFBjOIXcJJRIuiIHwR +v52toovMtxmxvvcd73hHZ+ZuwQLdF5g6fU6a9913n/XGNsC465sXi8VqrGfnf/DBBx293Kf6cDRB +QD300EOdjbpsLrnjb33rW1+sC6dn17VM+SLrgZIwvbHDTzmi5Y4FcxIwzFq7RjVmKKO/xYFrp6t5 +//vfb2Gh1Xc2vVnybtc5ZD2d4TbjjayNoI2vCvalCMo2pTGrPfLII489+R/f+5F/c/nq5dXxa9b3 +v2a6+cTRmXgbmEwGF147W9sYMCJClGgwnLbTEdetynQGiqUo6SIOcbIyaGOWnaP7K+O1I4L1+Cj6 +hduMrsQrDDZvB1AdouJYbNhJOtOZyFlIQOsi00lowheEWOvEuy/0avHd7W2RBU0xUPxHhkeXKtEM +gYLcFZcifd1S5FoT2+jl0WZJsBnZgrRQi0JaKF7Qix++KgIz8K8onMBcuIq+WAqxbsFnrNDRTSEw +tT00lUlfBL/6/zwxr1SNJ0JEDpeVIr0BFWLpH5xICepYRjusLUZApzhBz6CBJidb2lKKrGzujidl +NZXChd74cAi35pU7/Gf1zObGzcnhwfgYCNKMq3tXIbExgbK+9Jj8jPOs4ufvjarKrVKqK1bTEAWL +YkYkJr9dt1Wjeiw8JCFVmrT1HKU0h0r5HB1O8yYYItRQSXF4b/3bAztnNg6HV26Oan+yu8wpjmLV +RDq/t8ZemkxShHrA+zjL3sD57NLaygELQaffzjffPRwEtrcEFhqbL9/znvdYuWrriJU1zJjcMthk +CVHobS8NUw1JW3X7+Z//+a/7uq/7xm/8RhhjD8yCPYosJwynJx0Xt15yhFuov/yX/7IdpSgQFyq1 +J+erv/qrnSYJ5KTY2/ov/sW/+Kqv+qoXqOKf/tN/Cikb8inZ5IAVvKZg+XSEmnAaQMrTFET4INSH +JAn0tROXG0XuDJ2R16YvoG7D6wtUt7z1+7MHAkNkF1+kbFlZm3iHAkA1xXL6rBJHlANOv+3nhFU/ +eJ5FVf5zP/dzXtwXhamNmv3tByCg0+ODhvNuU2fQznf/6o98Zu//IWSJ8pXx62ZZNRT/Cb7Zfh98 +PQkcSXl0bO9pUDU4mVNTVw4mK9f3YjmM4iMPS9TN+D8CDTbv296KIDkL2AAkVIBDVE9oh4CT2mBD +Dr6LRpP5PCQsRwJT5kQDUcWP+iCQgrbWCJbVCNHqlAPAdtSAit5zUot63AjklWMHT48otvRJpfKb +3hNEAEmAs8yb0Z43A964ygpbLan9IcYBpH/yS6xScYt4gtlSvCN4TETf+l+ZoqRXXFvUHmpeJRTq +Ekakm0qTFsGbPNpueKErNNnAQroU+JqFuBz4bfI1GMunDKoJytSAwGWK5GGUlm8gonv1TO2W8cBE +9vanVLt7z+riA+fDGAoUGzm7hjFaJ6DmoTBnx2X9ONPbZ86vXK8TavVI2NOsgkbxth8o4mVKM6UX +7uo3kBk2NLbsCvG8EQRM8e5nzUxLdXUNGnBydX90z84mR1vcFDNahL5WHtlArPtopGm7CQYTEOuD +jfGMjy6wyl3o5Gj16Y3Bl1cv3+4X4DF45YrBsjtl4I1wu4VvIx9Q4RRCRnrqwoIK5KyKAk7SeQr8 +0Ic+xEfubRB7EVm+//u/34CgTwiw18Ue2VsK9w/8lsTTlw899BALloLWKpMSP1nhdIbTmisE/cEf +/EGOJti3NI1KelqYMAno4aXh93TvLePdA94TP2kSIEclB4vuRPC+3gKoTRXESm/Me756bP9abIYz +ouTPxZvvV8rTShexuu+Xf/mXORjjA4XTlgWU0nGdwvHv/t2/a1cpz/cDm25+5qknjk1Pmj09ollO +7p1tXCTWCUCy7777N2584hue/I1vvfiBh6cH98WdAkFMVlqaezSzN5/W6LBxS5BMo5q2XN8a0L0o +iAjYdLi1E1Pp2TND4GeSFaCgSS4z+5HClNGARB1BQwTDZhbgGGCJaZBTzQO9mOm9qrlVKNUSH/BI +IamjAwXGCwYklu5LOpPUPr07hZSnSbcSJgNE8XBTUVmMCdvgWcEb3mC2DNAUkAQr4VxfivgUYyJu +Cd4VIdk6Z+3yDHqVItiA6jItLUANiNKGay6z4+oNS0VO/7iVk9irIsR3dk4UtiouRat9K4WgzOK4 +xRZG1JK66hgfXN08OLx8bbwpk/vyc1J/dDwaHRsvKhVt1ax2q5LGEqXjnrs/c9XJLKDYPNeKJImI +CxnxSMdhPU2Tu2GmVlyHGVrpyVNWJNjfwFwd0sW5vNybjNyKA5JqCM4PDo/NvmMLgsqWUYBx2yG/ +UczbyEZ7PZ495StM3HagulmD8xu/8RtMnc+5L8VPzH5QNuHbJvm7Mj7yyCM8Ii1Mr+xPqqPk0eQW +1f1emH9NDFGvf/qnf9qyoEiskwDeqMvcOLDunqQ97182ZCMMHipuWc1rnuhtFU6X/Kt/9a/S6R3j +041tkaI62q09S1wVns68jC97YNEDBau8kpeQWqS+nIiR3WkN9TSp3ka2+O2dvuV3aEWfYKlFp7Mp +scb8hb/wFywKsBPOFKl0EpeyS5G1FsO8CBOW+VebzwyNOX/hGK/3lkFuDfMzEGkh/cFP/rzio+Hj +a4d/2KqewfBg9eB1ALU0vezQj7y+9vWrZ/YvfO2vHV17/bVPvHmw9p/uuY8EH0yOneLplPLkCUxu +ZDaQKOcB2JEjlI3Dw7V42onvCOd0Rita2xlw/94NgX/Mv5G/jlYtNw7mWaEggilW+xqBFuSm6AjB +DGK8TIjENIiYFVgqbtVS0AvGlB7WWCAz/VhRKjIRT15D1tHNYCokyFysRrIDM2IXfpunNYaSjbRG +X1ucsEMxLbWpjK6Fpm4HinQLnFBTw77KOl4w06gjQ+FO2BZQlhllzEAjHZV6MVwoFQswGqWtps+N +V/bTcHkOxtMNKFOYpN4gNArGDbW2SJzNILpgdZEpC0UCYwBOk8sSa88SNV2wXozOzvqNB6cKSMl/ +FIyQDD4KCyUwCURbvZK6Yt+WJGc1zVNANsK7HEH4qwkeU1pXQ4RMVKNQx9e4JYDt9EM1QU4Bz4hI +urF3aCSRoQmtGkue4Aodet1y6HiOtkGZ/opBr6wp2M04Z/I2Wam0Pru2Ovj8aJHKTgVWUDZYLz/d +zi/iE5/4BGMsl0B8JrgFdxd5WTjZkBaXpyPPp2vS3qxOMngFqH6MvQCCE3y2ZQuILMpdrPF5PuKQ +6fkq5enwNA+3xGGnYB6HTLCPhSGa24fTECv/81XapJyNY5guzmiMCHAF0sYZt1TUlxrCeM7YSzM2 +rLfxlEXtluo65wtU+nzd+Jw1LhO/CHogAuTYKWEV7kh72uj0fKTcfTammqFp954mU3uTmf1kXmLz +Q357BIGleqZm/YbJhaZsaEmjBdKMyQDVJaD19jPI3GLsOj4c/YcP/O+PPmY7/B8/e8+1/Rv7s4MH +h2cfmx287nj3d1YOvkQXEKD33Ls9furC1oX/dny0vbp75Xj05vV19roxiIQ55B7fPRtb5D0INbEX +TaWssqB7yNa4vRuZyBuE9b0WGa2bbY1wj18C0pUqU9tvgltZmApQj1e2uPiZrty8mgyMimvMlmib +WK3FrhLVDCxRINYj0GFwCUO3YEOksjyF9NGliuwqWA28B0olUkkha1CEamiRMAVaCyi1RUEcCdQK +alJ7q78YaONn8KCAoXElWC//vPrcCm8V8OYT1KzE4F/BjKqVTRXhd56fqq0gcFIRZ1LS4a5LFDCs +0qh6hfqhiU7v0xUpGOsOcQt3SimO20CdoF7FYxa2zMsesZlnJA7I9Yk+x0+mmc1hbwwPnLVW09tG +TmA1luRQrNESsuCwGisSU0HRz6tS7crdskDE2SG+PAvNYf3ADuYRwVZxG/40XOuOvRhD4yJl8wKw +2YPT6kBfxg3eMTOpDAc0V0OClFbd4Knh7N7nlOOh+4LBaPINFV4w10u5CYp6suZ0YWhqwvJ0yu9R +nABZHBL3kqsgLoTbKW7QQKoIt5N5mef3eQ8QBZm+ih+l/LZPBOTL65Weww+5ItrEQHZHFndPV+LA +B+7KrHqgfTamtm8wQNtEjC7NgsBUWMsgY4jaK+6arMyGkD0saNsyXfmk3tGvvO+HPviJ925tbBCG +uzvDvY0nBwevXdm6OJuyvV5eGbwmkut4ZXd7y3B9/6k/0CuF13cvrxzt3Nwbr63zGJcNEtnPMpiN +RrNMlJ74/eG3yDE0RDaRm12PtZ4Wntlvgx9QYXsMcQkp5ehVLd0rsIZmed1iqOp35uKW2oRvz7DG +xiuUkheoqFnSxk7PKTI9QjtyvyPiwc5KScHGhtpaIzNkQtmiKiuesq3FXVnhca3EATaqK5tpiMCz +DiiDLpmBXwek5hFvjdvFiW8vUd+SiHIe9gljzZLOR8StEKwg7illcVa1EXvR3ro7qmlpY6Cl4Fld +VTbEQ31OCvForlkfFCwUmmfUbANtysEq1gXdXW009pF5RCU061mdzA5/1pKlzAamFRhMr1brpGC4 +kR61vvRtKKMKwS0s4dKjCcnqK6+T0th0K0McfVKasfum3o8HU0vGcDs2/eCVqhl0xKMrm5jnAMpx +906uGa7RYg+Pn14fvsGerFS2DMseWPbA3d4DEU/GYUxvd5LTzY2NcZzhlvA7RVj6qavPRQ2omYPM +ADl/EabaZtfrBq19aIhdZHVqMVX1z/7ZP0vf7XWAauEmtDG4YVVmmIom/P6NR9/xwY+/b2vLQafU +S8uCVtd2n5gevGl6/Q/ONj9r5qplHxjbumcEU3de+5EzF54eH9jFn2VH7tq9S/yxvu6uxc09gDx/ +ZniJfXcc8Ns+uzLeywQhZ6JxWejEmJpvi3a4ZhNr/Bc2imRxb+0+aEsmaX5tlKlTYhewuStEJ6s+ +s4CobZjkbBS+UlJlYDaUH1e+SX/5kz3XZbOtbAS6jg+2kfJuEtaWH5v9LeyZMggbHTgGR1XwA6QB +m9rN0khwxLBZVcTfAFKAsGroZ7l4pI06uVS7L9+FiA1sUnCI80pORF2Mz6BIkls+qjME6XhTc0v+ +Jiml69KKVN0Q3rCKqou0cQAAIABJREFUMUlS6tIIIGOaZAobKpLuG98LbkcTC4OjngYdqzRD/fr6 +ajRVDqeYFjbiCvjm9fCTtoRWfRdZX3kKXob29OvSGKLM2sVc2qKfmzSY5EFa7Z47vRVYhtkaH4wP +j9BHxOOQYuZAwbY5G9aoMEfVHOfwQWU4ATaZur42nq5cGcy2To9Qi7Pl17IHlj1w1/VAfrtRMGYm +FK2GJIfuQLAf7sIDnAbcCp9SpD97t9yiSp4/mXTMkjLzgknmXFbcBksI2qqnaVcOP4GlGQ4Fe5Mc +3DURe/nyZQXf9773SWcxTp7PvudDj//f9rQEezRU/snRmXPj6fDqYPLA4epn+bWRSLrZQnPu/r2t +ey/tffaNe1e31p3sPRnSIohdi1wcGw5deFOi1WztDm4eWGIaWZndMoUKiBPWLvnbI0xtVyU3daw+ +IEMBJ82VwuqjFDGaSutD+lsjs1i+RNSiQ4mxbKdMxxHlPq0VQQ62XxqtUuZH6b4xbPpQYXudEYys +Z6hZmhzxXYeuNBLAYzoTXDd2YHGF2TJjxj7X1jJBrwwuWYnDoXgtVor0L3UtiXldcldQvKsTT3og +IbiSjna3VED9qwpkhf6ufMmGcwGiL2AsyNoKNGArbOu6EBFxt9XljqulM6eLCik9lGAqrEU3/6N8 +52+NWoBWdtyWTUKiHTZsrCkyXXULk+a8PQttrzclxTt0G1FOe9WlpaWVSunXoLPhpzuBltkDi25X +sLAYk02KeFRq3yrN8vLgr0eDrNHbyBtg/LY6cEBvDrzzRGYOS/rsnJXln2UPLHvg7u6BEoQkNtli +/a8f/J0IVkBQNM+dP38aVsWlSD+9PuLZtf3RP/pHZbCMEErZPweA/4+T0E44eQa36M7yP5cPPfSQ +kxRtYOdLzFyOk6RsUzP5iiysvXHwxPs/+nOG/Nw4SDmeRLpe37PU6Hj13IcmOx84GnA8Gymp4fc8 +EP+MD3z1+wfD46sfetvF//7NT//2t6yM7+NMiYoD0kCRLYlbWwNodzCO3M6SH6LZFN1gFv8D7ZgQ +Yt1Ms6Kl1xGqAdSyr8IqzhawQoB2AHicD/gQ1iZo7SdpHO27kb/AgNbYK3s7TulpiGp1CgKVWglE +iW4MKZUiNYHqEpqijzcfAC89DLB82la7F20pIApcyzSKn8ZgKpdKU28ZJHGOt5ivhdIXU9dJWMRV +zb6at8gSp1rggzdNyxiioE48cFhIrz9TKasvOsV8R+qqEiVTNF0XDs1rO8mZdHe0t1DcA0pK8eZb +HFf4CQqWshgme/uQuzJTH70SyWfckKW1+sTn7Ln0mD6RB3u+Q7Vg2LeADlxHUx3hqxhIw2sQkHSB +v0L3ij3fZ4zQVoduJREbtf7LeTXndzbQlJiKagZme33X0a1WV21trFkhzKJtfxvIPV65fjy71oPC +0F2GZQ8se+Bu7QE/cWLBSDo+9OeS4GXzCt6oknDOrCf9kixQgfXovDrQPt29pYaF5xfpQJRdtzOY +Pf22b/s2FATxTrTR22IBNNExdUpthcFU0m//9m8Hrm3vtdCJUvvxx//fZ25cXLMPcXXGC8Dh4Wj9 +y34VxDKlTdcc5HRjwCkcJW/lg+cfWDl7fmX/upmt8T1/8L8d20a4urq1O1mbrV676aSXgRVc4/0Z +o+j42iwHv0TczWw2ZbVjDT4iZ9dy3svezZXRjVg4yWW65u5Zym0kMiMqXJGB6D/g717+rWxsDZbE +WcTcAkxow7ys4GXbFNdPmaJLBumek/gh10sIlryWATAQygGAwgCUCysq0SoYk75AtFRhBufoi2yk +tYZWwxk8SfNsKyqfTTa2xoNgrR+GLvjMy1HEoyUDD2z3MyiALOAq3E1/BOllFqBpQ47iGJMYrhAv +UuhoYFs+pYS9Kph4ZUtbqhYpwvxb7WVRn+OrW4VwKPurnBpBXdL8r4qC1roXWRn8rzz+Sk8RtoRa +DKU6HdgwaZ5T+u7ZWdwWliYawKsmLCiwyacfiluJshUiVv+oIhxXq8uhUq6Kq/M7W5dsbUbTU1Bv +eLJCbW3/iDfHdJPny0o0OZrsbG3fHO8dTyaZZ2UtH8ZlNMw/mj01HJxPM5Zh2QPLHriLe8Av2pQf +wRAFqiTPnWEW4EFQQGhpLvxrCLRa79mA+nnrU+SWUgvrMag2CwtQEVEF+tC3aot0Pdib2qtwCBtW +Vze3uaQtcdYbOeI0KngwmxBc2U1BekY7AZZ8Im1ONzbtLlmNCTTij2s7aO8EVJ0029yYWX803Jjd +c3ZjdJOvWy71s6jkOkEs12YwlejcLj2PeTMASTEqhbhVPXZgx6+a3UU/7FEKgVkrMSCtFitZ9gk7 +mf6iP1nPUvPdkb9As6FCfpeFH51OfM9DIZCZPNK/SiTZAldtyfQeCKmtrtob0+IJFroM8Jvf7VXB +LhtvAGlpgWaUBV2Uy8b10mKT2NW4LIbd1caGK1yhrBcx6RugUpFVlKFAv3KF1v3u5bGJSS+wdNW9 +ksw144v/RYa0rgAvmTBQBetdqGLFatJYWTWK4l4Z+j3HVcC1VMbmMyOVKM0O6ZvR7A/20v+KBBQb +VquZGohgq/uYCQP4r573dzhUCNlYDTjuNebje4uLiZ2tVdPzx5bXUzzXsxN1Mjm+djwKR0y+1i2l +kumNg9H2xj3Gc+IeuFd5dHhoNp/bkaPBU+uzh4yOYklehmUPLHvgbu2B/oX6mfLdHeXsTvHZiuli +Y/idIvt8dEgxtxZo2pHV6X3b6/ccjS4dToYsnyQmS29hRrRy54GRqhLPnF15zevK450MMYQek1vc +8OkMSApg4CJDJWgk3MxlBsAG8fdLYj5z7YiXOzmtTiLWKaY0MIqLu8GSmuQLbhHEJ7OJ9EJ3dbRd +NLgGb6pAPGRpPyoFAFWvIuqFqYK7sJbohYjBPMQpnYVkmpDnVnFfcQiFTol7lwRwZHCpg9YoIW47 +rerCFaeAdErzqe3sqRjWWDwEdNPeORRRzcWzZOlKeCb+8dY8iAsSdab2oiZ4n9r2i20RCJQ8kLXc +O2ScUVPCoSLgr9+7oryAKDcDHydA7jIpkO9ER1Q02NylCyDlD/4BtCJbL0URkV4dguckYs9IQraT +Xap6A1kunAbDLBW2DLhN0+jLk+5VSL14KDs25KT3JxE136kPe6WcVhF9a/W4IqbbZ8Pp9f29dTvA +8ZaNszkVbnYcJ8AHkwxoLa/KLcwcT28Cc9XNVradzO7A3XJWcWitnD3Sg0urg9va+xFu7oLgB2Lj +uLG1RfsvwI5JHO6C7Zq9Zej8AkXcsgvAigrGsFu8N3Qpu3KdHmMvgNpP0+HpiVMk/Dx7V+vpbMv4 +sgdeRg9kIieLDeGQadWXQegVKLoA0WfX7dba6va5ja/a2JraPWJSapMll2wdDKBUsGcmklWXZ+5b +2Tm/cgQUjSyy1V6YOYY8eGZSq6YDqZ7k7OoaX/kRxzvbK+y+zzwT9IsyRxAXDhGPRCR0IXPNQcIq +EGsmEmUoFYSDi2QxmV46KISOzlpKalAQvI2yjdWSKFJeXLbMg1qTvJPZ0EBRmYXljDAvFUoepFN1 +oQv8QxYUxYoLfQtsgqAFBlGj3QWZqNkpaw54K8ThdKMjGBChGWspYOjRQOC8FOXUWUALALTUp18Z +d4VuuxoDQoVb+HQpoJPEamNaUcUbiqTnsorLKY6Hhp+kVrrLTnFLoooCb4XBsoTnSuz87gXj1NUA +3DSbnzz40FRLmlZ0mo0mm07Q5852ZUiQU726GkymUCoSUyqZ9Xnp8fiXontjos3MqMcibXU8ziW8 +ZN4N/xC2TtXJ7y3vg82pHDwlaw6Mc59rTLtX+VbKyikOFA+52sfAMBu41G+m4ilvdTHyKvj6zu/8 +TtBlDytg44rINrlnM23ihjciayze9ra3ATlr/p+d5zlT7IK1gPFP/ak/pZRVF7yZLrJZYGFuCELz +duTu4uxx/te4HlRKOkcxDz300KLIMrLsgTvYAye/0YglsqBFxx2k/wqQOi13zq78jxvDC/b4aR8t +zWEz8LImqGZRQKl0s5V77+e2d0DR3NoghOMgHgI55jKLZGuRJ5kbpW0wy5kowGN98OB95153j907 +AHLA8EvmJidVA7LGfhgoBX5kLlgFIYCzBW1rfjLQ1QQsmZFFX07yl/hWGIUQOfUowFLsvQQsgjUP +mmGB/D1zCQYKhKA7iduZUxFmmniMktGrmH+laEvrWCR7cNpwoSCEt0W154VQVw0LIKvqYI+ZV9PD +GRychGYyVRRsp9KydbufVujXQv2AkOFFlrKmjfjXGzKfvHbpseTpxuIzUxChoLHSAyCnwDLIXQAm +Ed6nw5OQiICZ+ptIOiSE5nTE1ajeTOUHvnLZvDUnioig4zlGZ7XnqgwbyHa3Yz7891ZUTLk0KuqH +Xo8mdMJuyBYoDqxMQgplKdGA64gKY1e8xSKE7mxwxpo3GWxfLmuEhUvFcRRWh8d5oHI5cmc6mB7G +i9e16cr+6dc79d2tgeN+Kw0txbebnA9R2Mlv0S3M8sfEvzd/ohwwfdM3fdOf+3N/7jQ63pL59OU/ ++2f/DDUwyXc/+v/gH/yDvsv1qXUVsNyOu4sXL3Ig9fa3v90tg5o//af/NH+NP/7jP26DgLLcnZ4m +uIwve+CO9UCNgGlx5n4YpFoo3THiX3hCt0ic4er2+eEf394eHE1mB3wvWB0zolPGEyGRRi93hPi5 +e2r3yHR2MGbyzXIh8AZ6bUolW6kstabGvotVYMFsS+xfvHrw2KUb0IiGR27uOTXM4t7NyNzSTUtf +KXuvGimCMc8WcLRoJn+JWtgmWCljxS/dVMHIZPnkJPRrHwh7KfgEwPnGG3Aq5G4MC1pTNGv5cRdF +X070Fcd85HWDKEWT/lrE3Q0aQYJUFfym1LoM3GrsSbYUBxN2SY4yucidRWMqwAv9Akh0xIUAPDQq +PnNZ1Qeoih/cBMaKH5wvgniQpahJzAgg4i8pudUMnOiCXUqHdI3dk7oLWZ8ePXh8giYnqd/lauZ8 +8FHAqUa3upb0TzEgr49BhoKeviYLHhy2k7/odeZ5EbXgEHIXrOK1sbPbovK19bXzZ7ebOJpSlKDI +njAW71pVmdGSA8hzGyl+nWIZqRYqIroR31rTTVbRIQeLRmp2UN9FwYFxX//1X/83/sbfWPD0Pd/z +PbwBu7Tw0L44gwffQA6qLdywdGa22Z/6qZ9ivKVuWiGhoB/v6fNtOttjjz2mCl77ub+nXwJL6c4/ +5/KFQal9g3/t135tZ3YOj4p4yecpUAo91ZJGEVoyXLf9HbRbdfGcTqCawvJ72QMvswfKH25EYMRt +/fJfJsG7rviZ4Vef3eAa6dCGzvUd7mli5iW/aAkkKiWVkLZVcVpTV7PDKJ0R6BRQ64XXVnZrrc09 +21tfeuGe/VEQyxaUmzcPb+xPrPuNAsetUvlwB07cPghZcAJ4WgssxYtyYq4xak1qC4gGtgs1RXQ7 +pRY3HUSkNHLMIfZEfBPcba2FpgI+VRqasL8WN4VI9OvwaXAAhmGPUq1ERgsqBBUBQq0UYkB5GWB8 +6HMXZfa0lM500AnqqC5lkQeTPfKoudikQAqouUCXoiOF9VuiZoaBakKApLS6/u7LRsdwXoq4S+ky +dru6B1Ta9NNXpYKnlAuXlVlUQ2RTl+Y0ZOa+3kCoeHArqnxdpuoTLA+RZKmGML/X1inVZUW07i21 +2129WhWmH3RdT5Zru7oyy1sGhqBjTbUejCc39g+w6qHnjVJ1fmq6znuxurtZ+vLAeretXWchpS4n +qhpgyeX90VkDO6QNdSde1szZztaHG/EmPbsMeITi95X/4pLF9vF3vvOdrYOaFv2Zn/kZ0HWaMyho +dtNhbWy8p9P52jWCgKmdyOmuSB+AcTobJJbzF3/xFx2+5gg58Owu9Rf68gT+D//hP/wrf+Wv/M2/ ++Te7yAc+8AERE7Rcf3PV+9f/+l9vx+Odbhc7H/qN4r2L/XRFy/iyB+5ID2RT6mrmUjOPeEcovrJE +nrMVZ6ffsrtznt10PMp6XQ4W2DwZ6HKI5oVsdyHsppPSIYY012zYp7JMDsm1TGraPnEwOfrkp/aJ +a2cNEIrTY+uNwVJctJt4g3BQyr5Vsm/3TOQdTKLlwC3wQ+mRjTUYTQSjCpc+B/OEwFvP7ZHshc3B +ttp7Q31EmSbdy6AI9wjXAo8GQgI9AFC+D0ltkpYQV7XiwbCQT0jrAElhieJpXUFmfzc8e/gM1NhT +nBEY80GUnu61t1VbypQdagUSGTQU+Ik0/QV0pYEne09TVwG54v1+NRbiNiAacvkSl56hXYGffgi/ +ZYOVroEZeUg6QUG9ig1t7Fa7K48Ulz4iPqpLXKHSetMhpZIqqzpx3zj3UDwmFAqLPY6hI8TDZG3O +MbwIU9WxUpANstatEGnOT0O43FlZPTBXOprYYxVAtHCX6smBQ1EKwcyfrliFNJxMD6YWmtdba51w ++mFmAZ3zyl2tp0MGUxcMKkCaZfhoapdqdZnyd0HggM1BpKDxX//rf40d4MrF/MMPP7xgDZhRDbkd +fde73rVI7EhvN1/skbOAX3on3pLTJc2Sx2+w6ggal4DcWchsy2Zk6Z1c6neRT3/60yKMyQ6hw4Zd +7G377XQ82GX3t//23+ZJhmmawblLLb+XPXCneyDbR4OrNeK/08R/L+nhW7ilhtMpdZ+Qcv70/1wn +hDs8a7CxPTvL/9ExuJpt7a5s2HHK8W/WLk0JXL1ACm8P122BsPDXmamWOO2NjkbH483tAQRSH6nL +XxJk5SifpPSLTsHpyo4NqaUdAiQy2hwt+QdOuE9CFmgR4v3zl0jih/fCxUyvNkionUG4TMHu9joj +uUKfgJWd9C+VCEiocW4TrlVXwZgCMNnUjv4iyBlYrZTcVXXpuJlbLQMy4qgHO6VTVQ07QGlOApjP +v2YtFTOkslVLf+uogFYRRzM1hlDyIJI20tu8VdUod92UGXK4JYjr4zCTizSti7sCqE02AFkggpTq +UJDSRDRHXA8kc8GeUYLMPqFZZOUUMCBRnuKgurEGBM1bXZcKK4NfQlWU/PXsQqq5LWxu3lJpZVCL +0BOrYbU8Ihmo7myviavRxuWGc99eOXn4Tbru2HQ2SpuVx4djxx758aktHva5yjy+vu9ouOPR0RgD +qzyLeAxekqMj59aB5uPZjbtHT9X2v/gX/6Lvn/qpn4KsMAyCLn6ALMNmN9/ylrc42uWW9beKWC7k +u72kLSKd6PKW4PwZW94XiVReDl6cscHY+2M/9mN9nqu7fTYzFVa9ANhpM86F5Fut0y2b+q7v+i7K +K2S1bBgkLwguI8seuFM9ECctpR9EAt1Vv9UX1cL+GTeCKriILIhsDb7mwZ0/vLY+Ph7Nbu7P7Pwb +zgb3X8gRMfds7RAHpDzXgxHuKytnN9cmk4Ft9qUo1ClpVtasZw6MxU+gxmVZ7HRmAnL/RhJJ842t +HESzdzUgRA/mC8IUKR2UGhSDa6me+zcDQkr1JVLRkqEpo6uVxCDBzkWUrW0pWCKxxXt/jsykMB4S +SpQDoZgJA1sFSJ5gORoEwDFyVkZNaOHuKmxUQUgAKlSRb+zBzoKNpBTWdu3S8Q90XfJQodWpueAK +//NPUcB5kKNoJr2UQqz2J8UK25onFARoV5hx0pbS9tLAaot+CM64xI8aa/lSFavWaik8LnVfztyt +2tXSFEI/6mBKKC6eR9koWP0VxM0LP8+jOIIeP+XSKtyu2kyndnVfKSR0LVJkaCBP7dUhSUGh+sdr +sLPOB741Cu7OWERkw0RqBMC1vkx1jB8WvW2v15ZTWMrzA0BnNhoOzJ7Cabu5c3R5vDLNOIjAFqV2 +OriGk7vnp2pZr+VFzpIzjUodpLZWV604/cKyIG7RnHN8ersLzjOaWFmxOpdPbydKdf6OfMM3fENf +3s63nzmMtGHPQeU9Wduzp01fOiiNK/O1NcuAEex0ET5Qfb+wQ7fbYWCZZ9kDz90D+bFHTjz33VdL +auOobwwv4otLiRtHb3nw3tdvnzkaHg/29xhUZw88MBwcr9+4cXQwitNVOx2yLIm/Am5XLUnazP5U +kGbZSKlrLL3kY1wYsriOD2eUOcApw+ZuIIeef3gwsKZk93xJ/MMgKx1DsGSz19Dq5ih82xHK+hv2 +WPeLoFIEOiwEn9KBrsVQIDArnpiOKzHAZkeN9aj0M9owhbWNw+y0J3gMRYJJJ48S0se2XAgnrZOD +RmRaARvegqmwkP4NVwr7oi/qwxNwVZ08yda4W3GJnZ5Isgcw8OOT6/rkVhlg3e2qG3dJ1ADYiaYu +Pv+c6Jr4n9OvWd6UrQnpDDWqOvl7oCBbILzs0u56LgHjqi4wVq3LqKLM7Brd9QbbVKqWZEkRefAz +D/k9ZAwA5IwndGA6pG3FIpVTvfLL5hIpf5sHFHCIu73RJAv/0KmWpy4FlVK1T1iMVcjqZS1g3V0z +ibo6mGQ+IGxy9GvNoFGdiq2VQ4ozJaXVxknhCaN3y1+6KVZ+5Ed+xMmMfXoaY6yNK3RQU5g/+qM/ ++kMVes6VZzTLi/gQ9f3d3/3dYPhnf/ZneeembgK/7/u+7/u8reLXhXXX3K1S//yf/3Noaoq0t8L3 +xOoP//APWwBlRbFDruyccYtrNi5LVcTqa3bW2eb0ZkOBz1vXMsOyB15sD/iNm+4hHHJ+6lzGvFga +r3T+RtAFFwb6C0yVuIhzBrc9edvZ3V9YWxsdXhxs37dyz/m1i89QSI9jqrWf4XgwmczObW+YDrTf +hll4v3zU8R9EDO6yAF+fbZ21rSGAtL41GI1sY7X0N5tTHepMzgJLUpiQZfWFUtYTkaTtkYf03GD+ +NQurIseSW5ZS+pw9KoEHHprKDwPp3DAcB/cLbFNhJHACM3JAo0IwLJoR0F4hfpkWo9IVitN/yeaU +Kn5CqXQ4dQUIynwa6V+JgQeivcR5mqqB0KuwKvVUZogFXRJOYFLEe5MFNIWdSa8MDcmhM89ef4rP +cFpGbHwavRgWJFMBWMjUEmWvIa4CP8jW6CH9IE+NIdzVvZ1B7T2GgEQBtlJVtU66SwE/SuW9Rq3U +1ibrVjqnKg/IFU3PJQCZYkWthjgxOZRNItOi/ABbU20ytZqZblTXyVhUpaGI4bJkOH+m0VRNYSxs +eRwD7MilrymdXeFkephKs7IpSxvkYealKivCBuwNygNImRn3l26tblyzhHZ1NQdU9JBR5JUN4NMk +JWsqrbE5Mc0J1cR/4id+YsHbww8/fMt5pX/v7/09O14eeeQR7WbatTr3DW94wyL/80W48mbFjW1p +ODQd+x3f8R3odGaLmEC7LTpIEWguWYDdMlkLR61psnbJJQszJ+KLk5ifr6Jl+rIHXkIP+DlT0TJQ +fgmF75IiC8nyOfg8ifmtYrKvRNZWXnvP7H9Z2Xz3yr0rO+e4cBhu76xfvz5h112PlpClIzSEfbsJ +nZV9M/qlDjq3bU5rcP364XCTk52ZtUimZ4lfk6DAmJZxE/QOZudqXw3sAXuqpbigxpBLfBPHBKvM +kuxIAVeb1d/AIJoKZDJtWWoiSA7omohlTy7fCAgqiyAg6bWmyV/LaoBBDIlYLFVPRaKB6nIWn8SM +BpIKCdxSKl7vxCq4FNxCBM0ofGEw21iRgkbYTr2y5bqoF5EgxKngstFU2vxOVbHIpb1hBoWqsdOx +IcWt8AZ4EBE3MtB74nJWk7VaIu51i2yeSCBWQl2KoCokf7erMLLSQmp+q/XFqk4KmnhoBtLmDlW8 +qgpUB/U9Acg6jBvLcKh1InlDUp3eCx2YemQYNJhDaHEetViTWz8uxpr53a31/UNzpaGWkVMmX8ty +LWE6sESJ50KgKnN3UTBY8xyuHiaj2LIMHx2Nj9eur65cOOH7lf9rlRCt8TQftEBK5OmURZyGuojb +IvSOd7zjH//jf2y5kGW6/Wtd3O2I9FtIsRhbzasId+KMvQtPpZ3foqRHHnnEzlSG3wcffHBBzeIm +22loriDZ7Cw8XtxaRpY9cKd7IJjjTHISo3/Ld5r+F4Re2I/Um39HOLFo1/eifinD4zeeW3v4aOdX +X/963oOG59bX9pgMncC6uTE9PpqsHl+5ebRBDpLvJUO3NmZfemH34pUDqufGlnVMzp+ZgR8TrnQ0 +eaJ4TWeO3gSBxCtJDdUAJGOvHbG+/XiJYGqZ3g1A1iZXsphF1zfZHbEJJwqGZY5hmZpbWizVU35A +67tQpqR5VRp8JdkrPWbBrgJUUIVKbwvYIItFNVdO37IR02Q6cspKid5UumOyyV63InBKPaXmpl7/ +NbcQBeBpo5Q0XrIylSHgVxjTObXL/aSw8aqhVM8qEVLSxRFJjTWqEAvlgsymmc4sQM1ldV1XR3fU +LY2Xqbt4SEdR9SBZE6+aoseXjjgH17I2p/mqrmzhvXLqh7Q7jzRKfLd3x46XzP1NG/gxI0T3re7S +b9X0EBiN80qIREdHxC1trp5MYnHom+6qW6wGVpAnUO2agGI9Ew3VLICXNRO64Y1uPTDwshJ4Zn9N +EbXySdz7NtsaXl1fuUAP67c9bL2aAwAWXlQLICJdU3jOUqD6zW9+83PeumU/z3PmWSYue+Dl9IBf +Zf+6a1zdAubl0PvClsV9TNaRWb8r9IB3AauLSC9SGE7efGb1xsrqbxKvhBQV86H7HhiPj545vAIg +2frW6UMhGmj8invvufTM5OKVSRwQglKnjq8P4Nnu9nz2zmJMRchKFl1wGJSi3JzscYystPJoloIR +8eAWQMbVTgS3W5C1S62UVkpDBajkdeR48WCuNCI+Ejl4GWFdMre12Nwg6GWNaE5OeQhznPtuGy9M +o3G2iCephwCpSomH27k5MgAW+K/dPl0cUClF6Asy55YIwChltxEl/JzARhCx9DkqXigXIvZd39ij +ECdSleJTdYigzD4wx6ceBNRFKBcFBXVRd4LM6duCroweypSt0sxAx6DKsUKqCE43sBUY5/JE+Ws4 +X9hlEOy3XsRqT0MQAAAgAElEQVQn2KxgJXqybrlEinLZ3Rt8qybjLQ0p/v1BVnO8URBRTm+IJiVD +cmTg5S6PSOI92oh5l3skqqq9p9nRxk/I7IizpexlBrdZOmg/Tb3esQRvDNf4Vlq3aspSuOlNRy31 +y+87DV6GZQ8se+Du6IH6RfYCiDD0yvw+uUrhZux0h3CPYvd3nzd+Ov3Z8cbSsF4BfDaCGsl2ZJEu +0sVFto7/p5uXHrrKqLTHAeHqa86fv7Q3phCYldx2oBtEJRrRnM4++8zoicv79BcLjubdM8t+mCtX +CcuoLAQ6TCU6x/sR/QJ5ysBLyEYK87lPj9mryU6Tc+WZQRHStpUqcTbhnIZd86CAk8hWF/yOgC6p +LZJPYar8QYjCe3lwOb+s4vNKq155YjQuG2km+aoUgd6JCgaT0sjCA/cLKQOrUORkZVMyl5Uyyuap +ILN6Az8FOag10mBPQORzQc62kQKeKuK765WnKXRmAKM05G5S8khBSnHf/fRgnq5AAfMQ2kglh6vz +Y+WQnxoBSG8e5kRUnSUD6SjpuVUMy4yIZoaH6kytnrNRXarA3sFkfHyoYPOAaaVQkL+fC2KYRARC +i2RCtJR4Vael6ZSq/QSDXeLZREtaDb+zqDd50htT06hGd5KjswJV22RNGdrnuru1oQvq5PLZGg/A +RjSDvelsPGd3+WfZA8seuJt6IIKL5GI2w1XrfHeKPdu3zWrYHEaGoGw1gamR3ih2SxUW41m80B5S ++hZMlWjJ+22ud1eFoGxHGk0X4Eo2dXpn6O/Z6v7ejePjydHW7trFq9fHRw4rj7Dj5IhAjPTM8TKD +6doIqNAKLF8yGQkU+xYBTphScy1lAooAlZmXh3obTvbsril9N/NqNeumRkt2LVmKUkjaSi45a4FS +lu+WIKawTGoVcTRUctYsHb2w5lBpmUiBN7I7SCyQxQW0sUOCCpooFCzpHDMy5iObk9Je+2M+lJin +fcIAQV2G6DmusAmDpZO5zChUCBZmYzc415tNq/L+KshIVFvgXCFDLhtR0siO52+BUAOkjCdjBTmD +KAW62tjpMqdFNRmZYUHRCYbJlnvpAWpf+rZywtRMQldf6WF3lUr3FuV0ZuGWp5lQ3Y6khxjC7p7A +fDPcFaXhjLR00+rnpiaDIqilK6rJeEj+pHbKHCM9tbDarfbE69IjoEPLn1ZXdwXpa2mwvaqZLB0M +nVTDRKJ1ysuSyWMWDjpynqxp3aF9KAodTkezVV4Otvys+rWv2pZfyx5Y9sAr3wORAvX7b2HTouAO +sAVQ+bO29o8m6Khw3+JSns9Pyi1VWvXw5//8nz+9y/uWDLdctmS5BUoltrYqfXFLRNnB2uXVzSdn +k3WbFjjV/8zTz6zPsv/PRkCYtMYroWFA8G/Gm5LtK9F+rNTdjCwms0k9m2eAEOFLO6GeMuFaicnh +kQzWJUFQt/Qm+U6Os0yKQNBgVYla3a4IqU3glokxcWQJ3EaFlunyIJKZxc89pDQdhlGpgwetVhaa +otOomXU3DUKtRNbULHQRQoakbnwtFVCKukBXi/sgNyMq+iS5DFWLWwC+4a2ApeJa4nMS0JQBTjRg +aBedOM0v+i474lsD1dgpaX4VlDMpmlDg13VhwN3mAZ99C28JcvJRZcFXMe8ReF49LEgnFP4lV0Na +EVFpatCZzZJ4daDvhjGR6PGypZvSnDzu6lWJ89CTvpWzejNEBKcHhi93a5SjrHT8pCEnqjZqpkyz ++xVeFuU8BzxEFV61U9xk6nrcKWUxtcBVoe+14Tq/S7p2fWghnbi3FDpzqJRc/Z3cy7DsgWUP3A09 +4LwMv/2pI5ATTsnIl8GcaUvw2Z42T5ORIv2tb31rA9vpW7fEWX2threV7fz5826xDDt9wjI/Ba30 +40GbKKHIokYHlcLvKAT9+Mc/7khF+7s587RDzm50qxgUkdmt69evY8xSwOxA33h6NDq+9PFvGF27 +7+rG+J4vf3Sy8vTqpsNoIuFoDZnCmk9Jmr4qXKSV0g1IwaMZfdRCTe4Md+6xibCg0YLbbFHNol8Y +zBosXSA69akPdKQ1buwGOcQDKm6X1bH1HjsqgtCsvuXRMEAL3WsHqoyMt/LDxblsb0xygbdSIkWI +bEKcVq2UQPUBP1m1qx4R3wVy6Ggl4snjUzAfGCbZZfCnoDFgVubrgETS0gkJfaGfXFbbJKBO6kfl +LWiMtO9b85LzQvgBgdHvqznoRz9DuLsaV+hQr9m9i6sgYqmAyEiZky3aSGXiuQ4/Rx23UlhG5ZQY +9BWTszR4dzueXhCKW7fSUTUDLU3cw6pCyRLetDHNznhiUm3vcUMPNdoSMM/v9Jg4jU51nZL3qGKs +tZrF9C5F8NrsbA0PxkwiSZE/Vv10dey6AUuENGdlxgHwag4tsnLOyqZYeiYsIZmOOJ5yTrJ2ZX3t +y5ZKavp0GZY9cJf1gN/wqtExvLlTY167sJ8NqN1q6e5SQ1+4EzBjuxu8lI2ay4O2zeNOurDPrCdZ +eV1hWLY1TU47z2z6hpQ2g9vu5pt/UYcP8+TCegxTO9HhFcqyrJFE4+HHn/mdb7RR9fV/6D/sX3rt +5U9+1dk3XVSXlZ4mU5l5AaTzubbIuNk0zh9OVCLimMTf2Jjt3xxsnkk6gYtNM6BkZtSdglJqEwzw +aRQEkOyT9s+Q1LHkFZQ6k5yMhnmGM62PRoErPw/ZxIKbsr4CIWgR/Y+AjVDORwQSR+7LRgQTtiS3 +uGINVIUBnb+XFAWf3KcxU1sL+dyt0rVvByKS8tGbwh5Zn3VP8IxNtaBOW6yW6vy+G2xEool21ZWo +UCotRKmdmJWzGJYNWSH8lxonosnAKZwX7KVGsFSgCGhVGiallFGaah51VoU1e02Tdi6QxxEELWRC +kLaoWzKSqFrSqELHqLPhtHiIoTVEEgpl5YniKEOxqrfT6mqRSELnDzehkJ4vssFRj6aa5jXQ1R50 +aqzhiFoSh8q0f/AZHJ0dGj2VGdy3W10Rrw5wd22VsQSyevGc5BtDx8Hh+MBJhSsDzoEta6LCrgF/ +Z9RYppQuK5eii4cR7pZh2QPLHngle8BvfG19cO+9236tEY93JEC1F6DzwnefXZDfE0Do8CamYNOr +7efMCiY6KECV//777+eNpcfsjL0PP/wwZdSieXfZnKUINqHDZsUFE1Lb2/s3nrl/+/6LZzfObZ69 +cTw6u7q6hRixSI5TFgnH9AixXjNW1ESe8EhAvn83diNlbWkllHUZ0QdBlY34thyJHZhLh1KqyLpo +GgynANV8Yax5kext/FTRQqwnsZYvwQ+A6jIUSmqrCwWBDqpfAclcCrNhNh4UVCCuOgyjIINs2tJg +E6BFESpooFVUhdBgwwfP7ggKulRRihRB7XIPk2mjQo2LRWlepuKaUFykbGR7XWAmH0VONOMQVUsh +kyrS8AJsieKfa+kJD/iRJeGEpihcTJitcPHI6svSbiZbYn+warFS+gTCKYftxlGXNUpQND1ZmK1G +mawI60cQynjTyUAxi4jmDzR3axI9KFuzpyikbNH3raBbyTVnN1XIAOlDMG8IFTP5w2TYmnHaJUUn +pHOKGXfp68whHplV+K78H40P+Um0Z7rfAouQ7Vw1QCxTCluwXThzx793aigcLpdh2QPLHnh5PWBr +3Plz22d2rMaJfPWjvwOh9UuETtumFr/8xd3brImHMzhqo/fp/BJhsyOfJKJMAVWXQAMWoCkcdYsM +EnGMIlPw7/zO7yAiPth8qg8GufL4G659mhul6drOleloZ3N3BBENB7YYJ5lq11eu27NAmNqKmqHH +yvZOBCX5Rx8lKolFDh+4hojhrnfC3IisZPg1n0r1BIGQKfKasK7jRYlakpT8nRZCA1cfeeBB+p5g +LXtm4gQxgIFw9JGStrkPJ2orDkHvfqRvYTlNGgZT+AJalZlWGhrJET2YoC4gKLjFtjwnA4Jp4VCo +QSCNZZUtrRrPmDSjl6bVVpymoFYDDnk0RJgDDGgpTA18+F8whgMMdwrM6H7QPwkna3Hnd084bJpd +HOX0AzYqgkLKra7sX185uJFxT/wPV6XSqadB0xNsUzaUIRZetFQ2n2JNUijrlBPobSZ9e0bppuxj +yd3gaBnkc6s05jl7ctXKMgRDVlvKhFsMJmdqLlRGhNNo3cCTPi0z6fVEpGf0k26AuVP1ulTcwvNR +jm4Ii/6Pj/Kjwa2Ty8eT47MGETODosPZeLqj8YOR2975EFqGZQ8se+Du6IHd7fXd3TXnUK1ZrXQH +f52bGxtjJlQi4XcH6b874fNfAUJToRTNPg2qC3AWagnxww8/3JcqElq+9ARqY6pvwR5wxmFLiz/8 +4Q9/6lOf+oqvuXj+fLYinH3dR7fOP03YkXZbG6s3o/rMNuyEqdk+86YkI0UzCCJSC1OhKbiSTqZR +lSz3tRhz50wUJvtTdaD2ObQKRYDKSkeGErItkdUoAy02UrhcFMXeSPvpNogC2kIjdUmVLifhGllf +eACAie/IWfewVYogse6Ka8MBaV6PUKVzLFGc5o35E2hv+l1h4uqpFTTiqRHNKtu1BEJKXQ66iJ+E +eb1Vm55pmjKHCE6wJwIzTgC1IQRX6b1COGMLaneyB2gKUYBTtUhikUlx3ZhRQiN0qfKORt+7lvy7 +Z+egrovwnE5gRder1WOZy6yu6OrCWzeteUtbM6qQJdVVfepKRRYVV2/byuLJegfc7FseBA71TBUu +3qqvpAuqqArn1OaPqdKzQ6vqwlsi83xpOmJWJ6mBw32v4ZHxXSzAcaOvZngb+z8/JXXSRewOzkLK +6ISWagrj6nAQP0GLNz98LMOyB5Y98Ir2wPbW2qEjzsCE33oLl5fPD29hFx544NnwKUX6Lb7EPm91 +DitWxLlRYJWOa55VEQuRPvrRj/LKXWA6c2tBh0QCrr6liMBUVl/ZQHK7axnufHpja7J57pmbT75p +dnzGbvrZ8fBwHFHHc/3m2oad9/T2YDREJI0LCZjmbEuNG32eC9dnZxyzWuJ4e8cUV5ASiNLzLF+C +oHQp5AAtSAuIEp21/kgVEZp1gFo0VyuBU0EJ9xLN1NDeEAKS2n7IPpnbJGkVnmcGdmXdbbhFE5NE +t0s8A2xsxHjbRdwqaNQlxHozk0ipXw2QVvf0LZd4nr8JZYlVKuo1ECoNrIh+7gsRt0BFClYTXIXz +CuFZYv7M86DcOhmg0heBq7qZ+4VqSQ/FU6HAFa4z+V57Jje3z6aBWooU4jgspEm9HZdJSloBw6p2 +xBMkwunS2lNJXcqZSMEtgOvmm0ePz4dSXtVSVo/iEJNFKmRryOIyCZWoD8NA1eg7NEvJzlKF6h93 +vS3NW9jTV8owDJRbpfUsU0qfUFZ1ZrZCQXmT+kHSlX3LgiUX/8oOhnuIIoxIf4fcMix7YNkDr2gP +mNoZT45Go0NC9Y4Fc5amM61Fun7tGm216QLUc+fPS8+M5rOCs4uFTjYb6oCLRRYqqct//+//vYlV +AMlX5zd/8zdb6wtH3/3ud7P0Atqv/MqvdKpUF2kcbQtztNThEPQ+/vjjjqcAtF/2FRemaxcvX5t9 +xdf+f5/94Fc+8f63DjcPeDzeev17zz5webI/uHZjcuaezG9tssQeD7idIyEJTPsgd846zY3zh4HD +U/f3Ype1RoaIhFhUWx24Yy/NkZmwGEtzgEz1KdlK+xGntmZxb22mjIGvNufQawMMhVjkqRCBmz8B +SMBZojtKVSpoxUi6uiuzZHmQ6oBtxZsOeMiiHuWqlGzhpNpCakNccQIaw6mu9ttEUtc0bdYPVwbc +mgxOznmFBRJFJxypjh1bqYK94nqO5chiI23Rd4UT6ceCW+mtsM5BRUWdQU41BWaSQTRXVTdIcxTB +1aeDUs7B1e2QL4MATYNVhfrJWxA7L+gy5Yvhkz7xIBUJAwYf1VfJoCVpTKrSM10qw8zKqUgPXOb5 +C0c1Rf+k6oLS8Fg9kK5gnPBQjEuKoOJpVtFPh+Cattu3VFeuHLCU3aeZUlUIfs9tRnFcyLHShv03 +R1ub/ChlAXAOUELEaG82GubQwowg085lWPbAsgfugh6gpG4ccYs230tzZzhia7WeiLnV7hezngbR +fvYgjZpob4y7t1RjQe8tKS6/53u+Z5Fo0a+jj6mbdE0YKR1B+2ectsinBG8SwFItX1PBZKq7VFtH +OVrchAHus4Fue5/Ym75vtnX89KXxl9y/e/zVHzg7Gt+8Ztff2ILY7Y3hlRtHw9bwHDC+Nbx8NaLR +uINMhJHb2wPTWayOAve/nB+RkuOR47ey+lcgG0eWONWYAWpG1NJU2OxglrmwEn3RhKwytZ2m9smk +NeX7F+Z1yNTgCWRG70EZqRP1rqsxISqUoA5xoasjaqMsNgWEESfiU33BMCitHZ8UTlQDcqR8zeRR +c5mIhYaEVkllDq70wtqCw+TATAon2kEbSfUwUygVcV/ArPLcUotCxWWolalZdQGCgrqUpWHz3ocZ +ZUtxT5kCHnelH9xcuWxdtn7ecPhBuMJGWldlUdKNiKS7imyVDo3uImS7FmwoG16KZ3mV8smT66z1 +l4K4vj50BnjyV2Nzs5iXLVAao2xKZRq7FrWlCaXfN3wGkqt1oV8PQgQPfmnJgOx6BkMWHaXJDprh +zqt4M0MfZnHmmRauO+lhZNf0oal9ax4YXgKrTi+fzqwc319deY4Ragovw7IHlj3wSvTA4eHxIctS +WfciYe4UD4ATgkI7qAbtBCl0ymcD6u3XeMsyJQVB6SKx5ZCKRATQKy5DR9SLGfg6nT1+dn37qcH4 +009ev+fM5nRz7erggNjcrvlR7uHskzFRuhtNlMAMLpKqQRcez8u1vT5qRIRLORXOOalbwQwuHQKf +ptwKR0neVWuaSp5CgtiHOcefZM6vPdYGXQoLc1l24yBFqX0wleRtSyb6qhYn6KOtlu3RX4yhCR5W +CyEjhCs1CIEHalMtLg0DirvdjooUqWzB4LkQD1oABrw5hgU4AXQrlajhnEYFEmRTXL1pTTK7yvig +oMWFFEG2QoNKL4Ccwwk473linAAhXGG6Kipy+UoAOb07SI2FRp1N1fxSBVAVX4vXqrQaS4YCBeTS +RVQtPZxVPCyJnwqhVqFan/7EsOBSFaK6JVBdtUNx8+iWpm2vrzK3uoWYbMgqlR6ugvlTkTSq8sQg +4fUoHT38iFfvBcjLMpFaqrhFcKixMGcWHFmNBuRqxXhduuOSEdgkq7uY81YfjA+38lSaJ1XaMY2f +UHTX9zIse2DZA69sD0QaZInotOcP79jP0i+cYip84ZunalDK9tvKa2MqISRMjvaG6xefeOY6m9u5 +3e0Hzp35749dlN9RMxuzjSeemfDhoAvoBzdvrhxOj+PGAaASuHUoG0zdOhvpGUFJ7NprWAKRuNy3 +WClyLWU3HPoG1cr861I68cpBgenYgFNAJ2IUBbqOslFHYHat/iUdZXEJ2wjoLOSh/VgihIG+VZpo +8IDkJbvLcCrucNaIXobcE1CJmtgAHNmdektYh8kW8ZHvDczVHCr4sUlfZC1rkrkgXzlEmu3soFRt +63mJFp6c/G3i+Eo/wF2IUjCc4miS/7mRt01KWifRreoBEXfdj34sZ2G84nYuWZHUGqo+YfK1HGyB +jrIls2L+VqMqWgwUG2Lzu3omnV6MacIJJ0mqRhSl3PUsooCurOyNvT/zJyV7wVayhmfXmK9svsCz +4AEljlB1qbtpqYvSpJNabfe80thquz07XIvIY/zkJdxaX6UZg840ILtU9RJM5eoh+nI02sFsbdi7 +VIHqismU2exz56n1aDIVLcOyB5Y98Er2QH73ftirfqYZDr+aA8EkaIFvgHpLAK6ra5e3dq5Yjkym +b24OHnviugnO3TOD9dWVixepkJnypMCtrVmqGRmcDQsrM4ZH/QKW1jZnSvX81YXzGzura7QNsg6C +Eqm0VTqoU8fNFwNjGx8UAxLKjqwl3i8AY1guKUxxJFgjYXFbEdI8o5tS4NCBSTRU8AaPs5zVd7ng +J2rxFINtGhoQDcVir2EjrILE5CrK7mpKz5I2nhUMV+k0tkMEPZqFcP4YEKSieiFUEV0Z6pfNfgFp +CsqjoJQAQMVDp5qWhgn1HQiJovW5lFYTG6jCbZlV017ZCtMSWXMI/MrlOltBooVdZ+JTK43yEdJ1 +oLTgGRIFjE5uIZjBUXVCchZO527lcdl8IiMXxhBBTW8L+qSVSy1yOpuUZil1Kiif/N19TbbpF6hn +AKQ3ipqSaX3+z0MqKg69fiq2BirUSnEXMXu6Phxurgc8173Ats8eHjuC0dTM5vowi5PMR2ysb2+s +qdbqJEaX49k+EkXlpI7l32UPLHvgFe2BnI3hv7m12EkjYV71YQGrC2SFph0Oh48djPY319bP7mxZ +c3vtYLS9FUV0ZFcMb/g7vPuWBdIyy9kAoMbiWuAVkBtwrqR/bCGMEOMZ4JnrmTRrl1BZZ0volnuH +VsWosPuOZuWioZSYzFNC0FqCq4tRlh+cBEjKuS5+kI3ghgdlPxRdK5yWCLMRzMoX92tJjhlcKGti +j6URERtbo2jKUEIcNVWn7lCcf7sjgzYEikphCiQXwaTXlptoxrU/VV3RvVCAwaWKydCBuMezgKDM +krFUCSESBspA6m9a7VZzVTmVgm2KJxvdujBYYndao5dLHW7t9OUnky19tRZAFUlx1dWoItX3dX83 +phb9tLF4C3uJzZl02R8lMGZ1t1vhsBT6JFbxeTbXFZp/gyojpFCmcaIDgKts1lv1iKQeHGryhLfQ +TmafPOX5gCmvZwYAjcFlNFYESnLv4BFvb2yqfSNn1mcdPoeFdFNxJmgHJ8HdgnmEE+EQLG6pl2HZ +A8seuGt6wM8WqvqJzkfedw1jL5GRBlSFG1BPw6r4ePaoI93Go+MHzp67dnBsucfr7j1jH+LkuKCR +0ISpjLFm0ph2HXJi+//RjJPeSHM+VgcrW4NhdNPBytOXx/CAACRq7RUk2Q7K/KsvScbsutmPpM66 +2YIEBBUkf6N3lnpKQJu45VbQh1mVVkR4Bj9OsCFO6CLCI8oVhHBwbi7Wq3vQJ7ZJ3CzajhBOqiIK +BhzKqiwNIIGxlvUuW9DnsrSl9JXMPm5UPAOIArlYjAM8tUnXpqBM3oWOnA2KuV+UG2LTS6V1zbO5 +W+iLTxAiM4IiQjCsqgsaNcTKXBpnp9wEqBeTJ8ysxupL9Veq8wSU8F+kfMkgnm+kC8PqTi6Tpy6q +tuRpgOxLEEWdDScnyNqkkMkzaqA9aVHlCgWh25t2FY76luzRdF1b6xwIplZMNnFlE6d6MpJEs1ey +gDlgbz1diKZFRraZUjDU0FUWIplAPWIipqSWx986lNGK9HU466HKNuY9OvxUEFmGZQ8se+AV7wH6 +6dznWay/r/4AOwXt6Eh/a+TxysXNnWuEJ3F5de8G10uMtE9fnuxNJpZ9ENnWFllaGXG5Ot3cHmyv +Dy+c3WHwBAwgbXdr5TX3be6N4oKJQIsWSCxOB3RcApCsj+03gm4+CRpvSpzn1U6bdGodwc0dxGZt +WlU8SmfqilzOjlWfsvHiHXz6RIv1gcT04UJiK6ZFCGTi20fxkvAB1KitVoC2voggfOo1UKVazZ9q +40FdBK5cNp6hE9UpuiZcb8h3s3oxSIDDMFPzqY1SACBogECNDxIvoE2SSKR8okLeKfGTikQqSzLg +X7xrCUEZcbK2cv2ZEw0V6ltctZ5pVLd8QqrqlS6iVKCo4l1d7uY6POSGUHhZsXzlboUe/aTVyFYp +RfqmxEW2dFRbwjVWXZXft+7tBzGn10XKEj6aAM3qhWo++3FaWj128gurveDFGJpgvtgNW/uTmEEm +4zhgUQ5HlijV0zE7Y1X5Uc6qAboS8WLxb89yV4tiP1mGZQ8se+AV7YEIh/zawUjCF8lvsnE0rcrk +1FzojVc+NrKWdzocHx9fvXkIOXbWV0fHh7at0tSzGrMy8h5hcekqPxCHsyvXOV0tADtcWV8dcviw +75BUTtLpi3RQcBIlNcoTKKLP0VCRIfu4m/eRLkWIibV2zuhgO1l7y24kdQlrBl4Lg8lWMJkTVWWG +HGV09miCI+RzwWqTkhjh7nNilY3ILvbVKHMsjQUAlCWRgoxio4S0GDCIuiZPY49Y6kzW1KhAYRsO +I9nLuUT6pmBvXpP3JoWSU+0qBboo0La1EREpcoiLUNaTEdmT71RUCqJcMohrkaDgtUsrV0pD1aXS +dfLZe9O9nSFE9HmRTS3FtoicvjU/kf6EXoLMgkQhHSVP9VWnIDGH1UpsW3SPZrqUbCh0var4XORk +By3GNKFb0UDLNYM6w3A1TZ+oUUHFpZiGiH/8YqlKYYqtqJ672VOL65SubiwyM0vVpdhzsxFP/E5J +OnYQxGEWLknHxMFSSc2jXYZlD9wdPRD0KU44RJvLnbuDsTvJRUPs1dEHb4wOoh1CnePZ5tbqbGIf +a/YLxrLK5CZqOeWOL5tkXB3fKP+9JDWxe+3m8eWjo0jtEtPDjWy2Z+Clxuk66cSxku5mbpVIZZWD +jpWIPoh1l+OILP8pQIp10LYIWFumWttyosty309Gexa9pjcE5pitR9BRKB4Eq3sioyseRUfV5bkQ +MyzYUoJJRHepvJHhaMpMyhd4EPFNJFO8Ra2siUnUEMGSbZnlZoU0U5sDbZi1C8NkKjAIKSypUdOk +zAFVagUp2IjubhuSsUhptFL0VRpVeVIW7wV1GLjy1MpVnpIaYgsmexoVqc6ZHtbbpQ7mzQV4+gSt +6lLf6dtuoe9qob8BKX8kKF53c5Ub8RfhViYl88yS5iNbB/Wi0a3r5ijuCUrREPEw08OIakVT0A+p +GZHiZ07LnxoNdLXi8hRXqbCxHCMQNI2d8+HMco/DiodkVREPX9ubsSvbY6O7kDBxEULLsOyBZQ/c +PT0QCZZ1stlSfvdwdQc5galHs+uHg4+Oj453Nzc2h5t7di0cDo4dRlmreyiR2TYTWLKJIROHxFbL +1a1saN3miK0AACAASURBVCHkmOMor1HraK6E6TqPrBS4KKkzy5SkEHysqYqXwXJl/6AgsFz2EH8Q +JZLdwuCy8faqH8LXh+RFJ8IaHQKasts44Y5nAynL9ZKHgw7BGpAjneEZ7KRQlqVXd0X0+xSpfpC+ +FSdyk63QAsH5rcIPt3wyzqBi1ryviAy+o2qpsbbxIMu2PA8NqIUHyVPBX0gJDARVpLxs+rOoLeCn +19M0AxhSJOxVR2PnxtNDrgc1M+DhY3vomcykplFR5Sqx2FZQBiGZK57LqhcPXRYD4USyW8UMpvoW ++jpEYoYaBc/BwuoZt4TA1UkIjRPK2OgM3aJkKUxVqbFF6BfKSk5K8ez5Skxt1Sdu0UTpmuigZkEv +CEUttnrZshI4G1WTuSr16pbXQmuUspGcJWlsNV3anUnWNYeUr37Oq3bQeBmWPbDsgVe6B/wQIyuw +8cX0kzzRv+e9ezj9xNF0b324vrfPn9vh9oYdpcfXr+XUEAemcl7DOfnmpiPFyTVSjBAcfMnZMw9e +2IRe2UPCQJ7tN5FZcQNVsosADOBF38yspxPL2/l+hGNNdsJRopMFtWdV9bI4eR1LZoGQCNGp2+VH +02LdrGwqVJBDfkbIsDJvRP4AA5UHX0vBcgtOqKW/lRKRIZ9Ci2TuuEhBeHLSHXu/R+27lY7DEKmK +FFGvoQMqiPimeUucB4lVaSoqWMJSkEOnlQ0g2cLWnCsEUqPqcC5/Wj6nlLZUoqdw89L21WcCazL7 +iJiQ5rIqRXSXjtItRbgLh45QBIMw1bpFYnL639/hIDn1pAxYFZ93Y3WyuHQVYSYaYY+JKk93cq+F +lgdjemYxREhvo1oFRWSY5zHSyugrma0kzwM1bDJfADu7dVgotd72rhQ/6dwJ/yieOLX+cBaQriZ7 +wXxQCPm8mdRWhdKqyWR6eHwz7QzBEyp9vfxe9sCyB16RHijJQ7Dx7ecnW1evCB93utLTIkb8+vjR +werhvWd3ru8f0DjfcOE+8ikawYa5zNlslKVDOxtDAo3SyeC2Ndz8+j/wpddvrphA5eCXRmjTKolG +3vHeQHplBrQlXVl9zZsSzSCTGkracbQr3kLWtSL2pwr6l5Dt+VS6qbhu94mMVIw8Dz+BEChLfYzo +rw9Zn2VN8lvWW8BMxIJn+m4yKFkYEzggetEpwy8hniLqLenfOcMVA/WJWomnFsZMu3n8VZ2/cxiA +N2X6ltI+JcNnsSoyJ6sgTCpbaNPSIqQChBCg9WbjDKWAn+oW+muh/vRwOLp8fu/aqpPOQtDHY9lY +OX9f4hremIQBZFHovpJHQySkrkLiJh76Uqs3FO/88rVhwN2k+Co07Zz4lAwpubA/t8OXVDK4FfqV +P9l0ac8Ke0UK5sOn6Mni6qi2XWnup7GKxxlWAS2eQyRvSOFiT5mv8ixR676qSFUy2LS/J0/EO5sS +/mPMdGv8QuQyZ6hWsixYUEf8lIW/CqfjJ2nLv8seWPbAF7QHImcKU0/9NL+gDPyeV3Y8HR2tfoKj +/KevjrY2V3c2h89cG1kzyYXv+vpsd3O4apfqcOXmwbFtM/rCFpfXX9h98trl63uWDEUHJeJpCpzj +E3Ckp62rtBn9BgKFniyEhXMDKUmaDftZcNT7Z6JzkKelAMXMW8IXoAbwTmyGUBBYIiIiPfpxVJMC +AwbkQt9URt77nIQ8uxLuiZzcafp4iB5c2hJw9ZijnsL70qKkiwe/kyMwAMJjBC5M1V7N1PBkoxuV +Q+MecXlLIuvro2yQtWGsKEqXHwAUAiSbkIIdq+9gakGj7+PR2vjavZPx2uF0PxxCCd/DlXP3ZiG0 +cqqQXwxZVXce1PKyFkJL+Vwk/TXv3rBRtcvgEyJS1GtCVy4RKYV5+lMDBYfDbKwxxs4zyBO2u3ix +ESJVdg7D+kqGcg1duXJpEBAwrpwy5z5crClraUdsuKXNLxiY05evmOGtMMOIUNaCGtBUw0P55BQa +ZCvDbGt9i2Jr6W8AOKwsw7IHlj3wSvdARuKkUA1+p+U15pXm6E7W34JmdPT4U1c/wtk9pQHSTCbH +V27uE3BO+BhEawwE2BAJUUg655/Atss39z7y6ct6xTyrZcBQIquWylkS1/nys9Paz6DziEgwQFJb +yBNJV8I07hdsdS0vCpG/dnnW4l4CFFY14ka4k8SFc5nYK4VGcbO5xKM1nnkmTLLVH0ghoiDeJMkG +m8F29OPaV5On2DnzOMOJu13EdyoqxFIWplo8JQPFC6ZG4hfPGmWJr4DDbAZFthRKdcWIXUif26Uw +qctHuVRBVy60C83W+Vq8F8/JVhCIjsyBEEQKhqfjrfH1C9PjjfHRdaqYsvh0y7ok3aV/FNQJKVXo +0kOEdEUZrrtSlx2CKdWQ+XXKJIoC5tXurszzXEU56Z5gpavXyrXrB7wopJRKRVJFPWKvCAoa2PyE +t+4cmbn4nxwfchVdnNDXk636oShVvcWJ5tTG1aB9GyFQQ8pjFWRm0+X5ISppUsKyYNFSFq839Roc +yOa+1Q80+w32kywdW4ZlDyx74O7oAQ6DartJpF3/bO8Ovu4MFzDVDqHrh799NN3fXt/eHK5BxonF +HnQC64a4ajic3djPuXBjp6LGgW96gcCiyMJNYs4xNcTpxOmqDJJ2l/I4uBJbLuiVJGsEfQlfepUg +hUillkAs9mS3EBcPFroroTxCQFxiFw+R0RGguaUgpMRbHklhSRLdI6MRLEUW6kQ+wwlfhU/yyJyC +pQ27CQJRJsGlJMhWFVV0zq3ahQwIqriWprFtTM6NsKHepqCiVp1TJtWH5xSpmdRkPMGbBgn3mjeA +kWwNTjVoCBpVweneucObr5kdb0wOrx8eTRT0wap1Se3UV6OkKJ5OKAVapV2vFDfU7m5C/QkKVuYk +FOClZ1wUq52n0T0c1ODGTZyjmYcY4sAqPhlSqoJbwd1qnZz4UYvb+k0Qz2V1oz5PpAzdsvF/hJnk +L2KdLfu1umB1floXaB8M24KhRZVSLK3u1Lx9jdvyOlipVL/TPBML7MpNxOzweDI+vrEyiJ6qdt8d +CSvLsOyBZQ+8Mj3QUidueGpM/kow8dhjj/Wh4g5oc1qqc+Kc6fZyGCFZLldwXKv4tdGHpgDzaHB9 +PDkc5VDxbSeHZ4p0Go8N0xlvD6y4YAMSROzmJFQubKJ5DCZnRzfPToefodJtrsfMO3cnpMNojRTQ +zZW9QzGQPJe5RHCsuOUAyG5XOkWJx8H46msOr33JdHW0snF58/ylgPqJIKYURsKS3YDw6huPrr1x +642/Cr0A8NwIHOkcxghPMldOqi15LpI/JzCQy/+fvfcAl+yq7nxPVZ3KdXPsnFtZLamVUETIwhI2 +NsaJAePw3uf3YRv7MZ9txm9mPGMGw9hg4zDzxvaAwYzTgA0egkWQwAogJCS1pJZa6py7b/fNleOp +er//2lXVt4NiX0nw5u6urrvPPnuvvfY6p9Z/rx3WNhUP51SKileCIZyTpygQM2CGoBprxUnTzB/z +uLaYmX09lIRDMoMHfAtRjITeF5hBUGYdkW51iC45HW8O0WEGboErErlFEVJEreYH5cGglmbckiU2 +lVqRemk+zLDKN9OrUgRN0LpS9kREhMfhmOi0yL285CeiZ2cctourlRbcH2emd1myKnSbiBmLLpfA +2wa6NW1Kk60zoaF7cnUw3lXD5Sk7nnXjvBu2DDsZB5lbHCTOe6VT4mmV9Yf4i4RZeU4TaAvtcBTY +xMZpbjrC15pG7WoIGXSbA8n1/nDpAneJ4xPYD0caDCvphQmg6izddqalP0sSWJLA6ycB/bTN6YNp +966iWQyGpqend+3a5U4tBdg4au2CCy4YHh4+m/YTTzyBQ/DR0VGQNWfhDW94w2WXXXZ2zhdI4Qj0 +fD4/NDTk8kxNTXGGuY5Gb0yUG0f7Y32M8aIvtR0UX7/FZigWatY4OdVjbUzEb9UAPy8Uz7RKOT8W +SbbCOfaSEprl/sb8Kn/8uB/TdhocEIJ/yR7pUMZd0Y+adNSoLDrZ4MksM4AEWQLYAIObsywfvr7V +iIdSR0O1vlC9PzYyTVkH4ShMwFXYZGV5JCh07qLTZbOapQM1LsnEV/spGQzDIRWLjSqnuWJVl2GP +IXzYE4a17SJVRHBgI97Q9R1sJg6TBPSyqw42CGCAs3dV1vCgZuliDLLwQb1GlojgpzPqq2XSELfM +rtPAXQfPYqCWbJYY742yjSkIquVqDpgTcuDkNuH1DSnCh1qEKwCMDQPoi3RDRFIkAf13je/ESdET +VmOd9OCxzSGJetNNhpZIk8nOAyODngLcGiQTabfJeBD0GaRBUJ0DQ1xATtREz1LMWAd3uStSdIT4 +X+90c8gEJFORsalKTXQi22EYoxNLFdsXZsSwsjbzZXZP8wgY4GWoBVtWPYsYfgxx9SWPinjVb+Bz +30eydA8XBN0VlaWwJIElCbw+EpC7X7kPRRstXgBQd+zYMTc31yVZLBY5S5VTw88Jq6tXrwZHXWYK +Pvjggxy2umnTpm7xF40cPHjwkUce4Rxyl3Pz5s0cis6obq66M1+eWdm/otYo+KEYO2rQXyi8KFtO +tVqH1UktPO6ihZJpbWDwyuOlmYtja74OOHEQTWL4SGjwSKGk1UYOORAViKUVPdi4dEWkbSVDNFsZ +ggyfStcqAwFApVS9km4WxpObvhJ48pmLFSulj+aklI2+okbBZmlbB3UQAFCNAsREUHcUMYhRxBSv +6XXSWRI1dUU4Voguexr1beaLEt0TRdFjA3XjkKAu1yHAtvap1MalAVSCvQyKEGgLXhuRiTgxxly6 +tsDCgPFALa6lKm3Iyl9N5QoP2kPH5HTy8aq9reqw0FHugBrFyjzGlsN4BAWggpeCN2uRcMvhqDWc +VlCFExHELZO1Ual2ywGSYSE1kpOPHoeBpSNFKQeHRGAJJxjkVGFCB4bIoFukSPQqTgaBpSG66y3R +BC4lARK18kgRlXA/I+IYmTSE4lRkZR0bMczSULhSa2ge3Wrh8HNyORYgSzZ9QxOvDjJdcUqNJSvi +ZKRSTbiGw3QIyYktyy+3HsidIYE8S2gqSS2FJQm8fhJAV0j/yI1QR7ecPzP0q88AVEcTiCX95ptv +tiVRz1sPuHv48GGMV4epx48f//a3v40NOj4+ftttt7lh4e3bt+/cubNQKKxateqOO+4Awr/zne9U +KpW///u/X7ly5Y033oiRSrj99tvz9R0zu68M+iuV8sDM8dFwtBIf3ZkYmquVm+XJ9UFxrFnNhGK5 +5PLncFlYyfY2pi7xWDVz6PZQfDKxdnsjt7IytTI09jBKP6jFKhOXNUujDI2GUif9kaejUc50b5WO +Xe3F5lrIML8uHC2HBrf7qTnUovSv2ZqRqDRuUBgLkodIATYCPD9o1U+scuzKVnnEi1TDI09EEtPd +pyA8kEaO1SeuDIojIb8aHXsi0jMNWRRwY3Z9fXYD+2xDfi2+4ruN0kizONIsDRUL49GRp0PpE07j +o9kdbDiy0sK2mtehNa6doEYeKmLcEgjUJWxzfHpFcfdytLEWY8vQzlEGeABOmW5mj2nREBFUfwd6 +IUKbqZfXSwZckx3B/Y1a0lzUsvY1KFXnGkENCgRk2z9s1Gy8V8WsoJUXVGtsnJxqvFVkaEdciAiq +EbEPpajUcomCoYzBoVBc6XzTKHGlCtqXNMGurC2Gf1zydFTEJqrFvzWNSzXHhoJdEb5hTEBI860t +Imb8U0r5LZ9w2jCeU9wYGSaVS+vbsTgcF76iCGNk4ya7ZZAi4sUkZb8WK6eQkq1pkpNCHB/G/RDd +U8WZxpDVak+LipbCkgSWJPB6S4BfPasfpDwYAZYOX4zAMOxCC3UhSdK5uzDlnPEVK1bMz8+DzaDm +3XffffXVV7/rXe+iD/7ss8+SH3zFJL3zzjt/7ud+7rrrriNlcHBw69atDC+/7W1vu/baa0mhFsoG +rXy5ubteTkzsX1mvx8cu3eZH65Xp9RoZbbCSpNi7/pnkxnuBtMrUBs2nJvP+0G4B2MoH/dFnsUcZ +YGvUUvLfG/eqx65u1hLRld8KL/tWKEg2J6/GNsVGAduac5tDrXh6w7c5OK45vxkG0LMELB7pymgZ +srWJq5qTW4FTtLDbdVM5cq0XqcXXfTXct7c5vQULEu3Jh6JkAOTqx67F+Vxy01f9gb31yS3aeIMF +PL+2dmJLdOBAcvPd8bX3h+N5f3BvJDXj9x2Nr74/lJy0ivVFgJSK2GJUzB5pa1v0K3w1HOKu1LcB +qkMXvrVN1lbecos2MnVKQ9z6LIGHTSU6+sIAG+x1dZGN4lAmkBPAZr4v0hgM19a2mr1M/hF4rOXa +XK1RUUuZ9415vYMa+IUUZVXKghMgUSKKGy66N1So5FIsM1CkS/s49FpIAZbEsxHhW6PWNNCEzCXw +RxEN08C2QWabuNWLxGCJD/nEG+MKBqjKSZoNFKv3QAaDVU1g44cS4BRkhmLm0qFd1jorAf2IgKME +VR1V07kx14N2AUVoMuSu0V03m2DnuwWcAWftVAepyZPSU4RZfg/qyrRS8aiZqYbkruVL30sSWJLA +6yQBfrwEzgalw090cX6WTI6+QHNe+K4rGIvF0LxoCmxNDFNWLTEvi5165MgRMmDmcnffvn1k6O3t +dSkUIUJmF+EWl6XG7ko1jwYeGin1r94ZRApATlDuLRdataDVs+xENJ7DyW84OROU+oG0eLwZjsI8 +M1LViK9Vs2g9NCDnQAflFEZtuH9fBNxN5JNj+4PCeDnHWipbo5uazqze3orkW4kTreoAKlAo5cwp +9jqwPaZvR3jZw63yWHPi9nBjEJ1eK6Za5VG/5wSjzqH4nFfr9YI4+MQtBw9geVAcxegMKsrQqtJS +uRKuz64LJ2aBYUZQZRZH6mGcVcggZU1LDUMQja/hZbi3QES4ruEINYdvREUGAreEBxY07m05Ydtk +qeFuN+JNEdwyAnsE5CrRAksdCiRCxJHilkw6AzkBTyMZa672myvZDyJvfcwBNmqF0nSlVtJd+DQL +FbQWBbOYVQeBKghmt0GaW/o4cLW2cKlg2Ugn8KUM1kwBJGu4zIxuk4KYFeEWZMkNq+QX+HEJHcha +fuQPTLoJY/I6xkQf4qqn/WRJFwUDXdIlXrodOAtEyEI6UkKM1pIIQVVKOkPExgV5QGs6OqS73ozj +jTxx32ddOqUEzKA2JjJ7ZvgpqGOkmVysWIkxCPRMcQERYT1AUbctLIGrk8PS95IEXi8J8FukBw5I +Mc+j1fqLwge2iKOzcHbHgRzp3bsvUBcLlVgAzAkemKRYnPfff7/L7AaN0+k0RuoDDzzw9NNP33TT +TevXr19IylXklMtc+clKUEUNxVKVUkVb//CMj2Eei/qVZq2aHSsf38QCECseSqXgDbXlrhCGLQUB +4XBZiKFWTHEjHJ/jMK50BmVsU8VBKpYsV1HK8QKYxJBp2NeYH9OQ6HSNGTK5aKoTpRkbmGj1TteP +XV05eHNrw5eDqggGs5sRlrQzMNnkMNeqdvDY8TWtimWY2ex0ORmatYx2AzVSkf6DAg9DMmXvQEtb +xQM/rhFm/wCfoAV5ZEV1IAGwdAYW2p8M9h7INiUHrWC2Fau9G3gvuEURFyBFWTAGVgU/NBAGDDlI +bKt3Fn41hsLeKFnw0Cefe2RqtUoVLNSaihtMssrXUYAyPKtRVgffuiSOBB1eGKBCwzVN+TsxVcpb +jLStJ0GyQ8o2zhiOkaIHAz3jU7W44oiFsjaccBpMUq8hpchaTidDWueyiVGDZFL0rM3zQyYZnclV +RJweRF3eG2gR38qrVGeV2iixWc+MRuiFowuHHzP5yAxHo2F2apFWrzWpkctYxKuwx8cmxSGloWNm +W6mPcw1kEDcrrVJMJ77Rl1kKSxJYksDrLAF+tkApv2pfVqH97BeFo3gsVq2d8u7dpUl6N/58EUAX +83Tt2rVkAFkB5re+9a3g68L8LOh95zvfyazqPffcw7okRn3d3S6gcomqrNQPoHzQO+VaLdonrZpO ++Dk8PdDURqqw/+rkmkdiPVP12VXlqQs4361lzn5RgFgK6DvhKVhgFkYhV8EwK8z0ZkarmGj5E7KP +Y+kKS5zKKE036MeGHBYG2yif1q04Xcw3pg9bVAGMUD287MnSnrsaxWE/XgCkYqPPNWOTVAGwYbsQ +NFZp3If9Mn+jo8+FM5MQbWMVajrKVPAgtxwCofEp0g1Wp+GXqXJnrklJIw6IY4yie+0W31xSnHoZ +WRAgGSlnm0KcEWBRs4I0x6EsECj+3CCq3TXzSzTFD7c4qj3c6zeWh1tpZpNZ3yssZfEq0NrgXKAa +75zIhuQsCX8aYsk6AZSFgjg1MNSlMw2t96ASKqaCLqguw0iVMlwUY5YoTrhHcSPCBTQZi6FnI+vP +WFUiTwaIVZUiBSeIQmVxzIs0bFE3reamsyNpAq8T6a6s2APOEZoNZmBHZguMEyg/MqGI3h+EbD1M +IhBXcW7z9rEgXIdWhJgfZRRET9BYLVXtnBm1EZNUR7/Z75O5AD8V9+cKOtlNKcosvtndSp8B95eM +0agNFsizsDvbSV76uySBJQm8FhKQ3qKrrZ87n8UIbDMdHhk5Gz5JIZ27z1cJKy/YA/OVr3yFDMyh +8s3aXRKffPJJN2LM4mESmShlthWU3bBhA7rDGb4MAnOXIWIyOGQF6Er1E+EmVhgO3KTZ0vF4IhZm +dQeKPtLkCG9Ojynu356aPTbcbPjlPAtGWE9ZajUSfigOBKJ/8b6E/jp+wHv6kXKhOJ8/umb3Y/7J +Q9Hm/JpwYi7eU0AHSqXameRMDSJM1GPZfAITQ7fK0mr0tMrDbE3EJGoUR9HekXg+kihG0pPVyQua +1STLVcKtSFD3ZdOgLgE+bJRUMZyerE8rgyChyfJitK/n9x1kO0ojz4BqqFmPNRtqiBcrNCv9/JXG +l35WvVpcCi0paEuRZLwGvAEemFbcsTXMevKWi3lTTaDahCuGKT4roEbrKAVCADMKvC32pjhIkynG +G4SSpzpt002lQusT3mY/3KNdShiB/OeczzqTguVKLQ9XAjZf7nzZkqQOhLHn2Bb5DsNwbEBzWqV2 +oS9VagWJq7HGAynEISV+YEwZxTyJqtR8NbQz6IYyiIhF3LvfbRoRFQFWNRVgdOggaPBWBLlLQToH +XFMROQl4tK9qObNmoJ1pSzbudoNZme0iHMcLgf0H+vbsHNv17NjeXcNQpgOCQPSDNNsaDCYlk0zD +B3RKFXw16dVm41YC/0lArnGvw1ftdBru6fZSePkSyOa8p7aH3SebffnlF5RYRFILqC5Fv28kYApH +rpSkfXUgy2KEeDyujaG1Wi6bxVp1JAHU3r4+0rl7diVPWQAmmTplgdKb3/xmNy2KnXrXXXfdd999 +LANmdw14/I53vANAvffee6OsIPK8a665hjxEmG1lQ85nPvOZiy66CDxGuWgUs1JmaBM100DV1ZqZ +eCtbldLSfvzwbD18MnLitky9vv/Izk3rxmae3dq36fF430wtfbJ64AdagwdaI88yMoyJtvcZPz/n +PTm/7bKLrlrdc2doOtSMZ3s3PIp2K9vRb0jO7e+U1YUSt3FI6TeUI2o3yFSPXcONULTK4Vz+8sfC +sRL6Orrs0erxrY3DdwZRDkv3Y8seCadmZHfSHjN3YiserR3bWt13Z8hlWPFIKDET7t0fbSQZQ66H +ryBjbMXjsb6J2MChypFl5d13+mPb/J5JWcZYYNhVqGDYMHRngBDUpF6MV0ECWhzMqGgIF1mSiIWK +/UQAPjWgQCmstKZcMWDFAgkELu2PIhARNUuMtGLx1ngkPCbzTHY+H+2sDDg/W/+qxcocqAT80PPo +6ZdTKlEw3gQNiMpgTxG7RHQIkCjpCuS0oER3y6qWhQcdxOWMyE5+8Eyh80YL/6BhvR8Vd9mMDhnJ +1a5FmYwBvsN4rIyUy2F1JnD1bD0JOoQMRrAy1xHktdJPyFCWWzJqIW1grFYYz3oZmKl1ZAWcyjPQ +FytXg69++bID++hjef0Dxd/+wFcRGbUkYhIfa3wrdWxZdqBGQNYKTw4KPFPrItQbTGFowRmMR0Sd +1+77IMzOho5P8AkXCqwrbI0Mt4aHWoNDGhN6fcPu3ZGP/GFbL/3Gv65ed639DDzv6LHQ33/G9SW9 +t9zZuORi91a9ELPPR+qFynxv3OPNPHggPD0T6jb/e4Ov7zMu2uoLLWp9atMB590E0A5oxMScmZnB +vkQ/gNdg5MDAQF9fn8PChZW8/e1vX3h5RhyIZdEvBigFXVl2y/z8z/88KaxIsq56uwToi9cIN0p8 +4YUXppffe2g6xFTo+CVPst6yVMWiDYUzR/svPVgtetMT3p6d2wrz0VpVLl5PTE2MrWlesbGFB6Vg +5cM1HKlGG5WaVwgO7Tt8uFoNs1e1FpQe3/EtPxJNpJsXXlPO6IQ4Dej5qx9kaBfZScOmj/g9R3Cu +5DQsEMIn0j8RSn/RC9IsKOFgcnIKA1C54Wp85UMYoM2mz2JjDavyJIb2+wP7IWWKvhpfpQys9wzF +0OvCIeqKju+Ijj7brMVbkQrdIaoIpXPJjV8PKglS0LECVOijdBmzRclbdegJErnLJYE8CIdNusAn +H9aWOkiADRY5g2ZArGaIyW+ABPoSeE9cceKk8wLhsDfqDcZCo+FQigU0WMJCUwYGCBxTy06RRr1Y +mW206qA4+NTDkG9KdCQHgMd448K9i/CsuOGrxhYsnAI8axQ5HbSrc2AQpVFWcaJGwZ7gnzYieTed +SbrtHCW/zG5rjoDbmbAGfuSk86Sm6YaahjQ+/fEbHeYZF+0vVvRleipjy7I33bp7zZpJScBGI0TZ +WbewZ0RoI3f1LGhRh4S2o/pevlTlXPFOmu6yMolmcpfCTPvrZbDZ/UJJS5A06UsrrCfENA25NILQ +oCODBy86Rdqi2qX2vRahX/2/vhj90j/7lUpXDKd4RJ79/a3f+90qKHsq9Xsjls+HvvtoG/Cv2dp5 +ne6Y8wAAIABJREFUHb83eFsULhyO7nguvOPZyHM7w+Vy6KILgyVMPR/Z2ppVqRbeG36Vi/ZOA34g +KNOcjNyKLtOT0SiGpgPFV8Bxd8a0W/bsFG5RBXWZMi/nqseERqiocKtaa4ETrANRpx/nDBVv4kik +XMKIq0bjzlgKahWGUkM4VCpVvFSPtk4yGjx1gjUjYZVtaoOEAhaE5xXzUYwvTK5wzKwFvvjYJg0H +OYCiFLupeHwscDccLjZR8aYZBSRksKUxrTCzuAGDvegb1WC1oOJdkDEXxtLBX7ohTXc4F64jQjkp +YQqZleb5FbAcPU7tKOg2w7BBdZAVQ0I10knBJK3j7IIp24TghFN0sErdUamyle0u9IFb4txyq7kF +OsYbBVl3xT4ZrznoR1KYTexP0goa+6fxXkJdX8XyTC2oCFDNsQNCQ4IUd5zDrYJhqnv/9A2HNKQ7 +8uxyU8TQlHQStDbKiuqPhksVXApx2uj4VKIj7oDN4uSzQpIDmbUEl5aaLS5BkYQE7EEY1dO+QLR8 +Lsln767xN93xzM237RR9bHBymeGun5G9D+06EBRPxNhARsiJ2Qe9HZbNkSZKnyZmxZmasHaoQWQq +1+2QB7vl2sWgLx+yJaJ+LWjgWpiXR6uNrfN6Gq/fAxdPPhX+xCdjJyc7L7SxBI5ax0AXRObmkMn3 +AK/feyzww+QX/SqF++6PfPLTMXD0VaL/vzFZaRBtKFhE0TrD1I3fvsaS5cdKKDcOp+O1GfQqCzhY +2SsbQHNdzQY75VuFGR9TFaSMMotpGgw9hmJiAU2hGPjxUDzN5hkvNxepFCOc/IF9YGDRMY+Ef2xj +UBGBk7NvUIs29Af2oCDYeYImBXa4qwyWU+oaJU4cHUjEoAUKujbIc7Cnb4Il6qEQ6aTACUjcZsaS +UacLHxyoQ1vQ2RhDUs4GomRQ3LwrUB1N5hLwgI74ZK5O09BePKNtPwS4dUt/NaualJNFugXCMzSg +jbgyfex7w+FgKBxKNiNUpjW1ULMNUHRpAFQc4zdwSlAqT1cb2jlDRcyhAqvAs9DOmBZNaw4RWFVD +4ZNEIYSyICu+XR4Y41KZLEBT+GcYSQYCT4S7SrQg+XMf1hC1Yx6Bd6Bat8huDBCHmojDDKOvcT1B +rV43stzt7SvddOvORiOSyyaf27EiO69DAQn3fePiiy89OjhcUNUEo0ZBVW01QoGF3zKXYUO4GKrX +rYnGm5XpfNnCJQbqWc3LRi/5htBUtErF/ShdJtmttntVZ7AaQQ2dI3OSeZM6QcWoXAJ9/cOu3eEP +/Z4NehgvG9YHP/rWxurVzfHxFi/V9HTowKHwk09GntruxPf6M3wGByuWN//1r8n7NWHjxlNCdimv +3ve934h84z5/ejrM5O5ff6p8rumyRah8ZjYEoGKGXHhBkye1BK6LIFP99ESGXyiapnO1KIRfDyLC +0k6otY4Xa7N4m5FHi4Ctps0YzoyqkRKjnZVmqRgJMQGYlAoURNm8o4+XA9RRBJXK4TVeKd8qlcwf +uvkXVINM4fLDEiIwvooWNqXrOpLSlJaBjG40VeOuZq8AUehc6UHQh1xAGpkwxUTUyKEvbUaMPKST +QajjgouoLg39oTAdXjrAJidFiGOQy9w2mHRAgF2LqQdv3AXU3WpeuhHkF8xb7eKKU9ZtyRJzWpyQ +DZQycI0qp38AfzSEGhkBhiZTqnwznxjzhmPeeNhP2TCveKW3wtQpspdXB/wNEgSoFSzUaoPRePw+ +euk+Wxhl5ogaaFqU90/cwjbf/HfWGPKh1dZYJXb1LXHYlgSVqFFfJyJHhBIAKlkQrq3xgbiLk07E +laP5kqHJDTZoo/sNcBex0HA5+uA50jabK3U1pNPVa67bT5zuyO13PP0///bGfXvGuWw2w0cOD46M +FcQJ/w0FqULVWUUQdOm6r01ZevLKAO5aG7l0gbsM6cIM6+nEqmsbcMkotAmXnddYpZFIKBGNCUbh +palVwZi+QbPWFVKH3uv/FwH+xcdt2Z7x8sNvqb/rX9W7VleaVyLdWrMmeOMt9MFef27PyQG73294 +w+tgQR8+Et6791V/pFddEVx+aWX9eh2z+Cu/lljC1HO+Ay83ETUohaQFm6ZHXm757538tMQx41B1 +vrRvYrq8cmi4Vq3N5YJovMobmq1opzymGGO8flQnyXD0B8V09hvrh4QlvF7MkrYqpRBLjFFZUnzm +ZEfErQa0JIksELFpQ9S2boCaUtCm1gVU5j3Aeb9hrNVBqaxYU7VQIFGo6YrwV0OBVtwy6JYLpJr1 +pitLhAXutu1m7nJtsC3DzoiQS6hjRqpqIJ2JUjvbFQoUdMhBHhBXgQk/O8auXPAY9xYMc8RKTd/i +nJPVaxoWpqecDo/ksdj8LeFwAh5sOFPzwxI43RLoUpvO3AZRm9VaCd8OdY4pCOv4No5EbUMXr5sD +N2uIBGJNg4TDOa7VRkMXGEYyLqh4BztVxiSjv3QdyEyEYiY9IlzqwVmQjWggrWwk2nsu/pVJ0OUi +5BUDVq+aoh2i4qQbRN6EGY60rrrmgMNU7mazKShQBFKOE3IWi9ED+8ZOTPTPzaYHBotjY9kLLppw +XkRUnT0jslGkG3AFzCQFaerW8BJ6rWIpunfn+MRE3/RkenC4tHF9acNFR5JhZqjrLBpg+NfExMOK +7NzRf2hfMpsNF4vh3t7WyEjrhuuDZcu6tE+LsEro4Uci2IjZXGigvzU8rPwXXxQMaNn4mWHPnvDu +veFDh9Vbwb686ILmhg3uVT0z59nXTKAeOdp+DBs3BD/37gVbnk/P3Z3pcMnHjoWwXCenNCaMuIaG +WuvWNd9wXcAv64zw+LbwzKyqSCVbN90o8DtyJPTk9si+feHR0dZttzaWLVsg4k5hJLD96cjefWFM +tI0bmsiqc+fMv3Pz3qOPtcdeL70kWH4WtZdOCtKVivfMDtVLuwpFr7fHGxlpvoEnNX6KSUa5/uV+ +H0ztsvKNf9FWiVisReejm+gi5/N0oLBund63M2guXZ6nBHhl5ZklFPL1U1/4Ez9Pwq9TcYesjaBa +qO3nPCx2xuSBMr8ZDULVMmfF6gViLA0QDEeaYAlO8EE4/XBxgpNoMc4pdGQoEwPT1DQQq7mfji4m +lVL8thnJFDkbREUT8kvQoKIN6kKMOm00tC0FSlMLmSkIBcbZ9YuhTmkqfQwglJm49L4LlsqVuOOG +PR+I6GO2plCEALjZQKWDatiDDY1y2wwrVhcEQUo8L1C7btGloFsA6NoR68qGdYXLJC0stbU8Bi2A +aDGnk2IZ3x5IrBzvvaEvfsM274FYLM05owgFBFJPRAqWXZTsltGmE4sE1XoJC5UJWUzeVI+X4vi2 +jqAEZo5tMa4a1YIFDXS4KOEAkGZuuggpwCSV8mGVloLJx4mLPCJnIqKUwNIytOm7uuzCUVMWGz5F +sFauDahk0cQeU9UmQ1G0QLoGEshsYFwtn9Lu/X0ldVNs3sv1pdge88XPX13In9owCo2h4dyP//R3 +Rkc57lRPk/cLObiqXRVgKo+Cs83d89/13Nhn//bqnBx1tcN9njc6tuEXf+nhkbG8HwhgcCqxa/ey +P/3YtQxKd3K1/372H1pv/eHGz7zzNBijb/FnfxG7/wEyL6xZRX75PdXbbj1NZTMd8Ff/I4Z+P51y +6yd/vPGTP16XkF8sPPCtU2Xf+Y7TOHmBor/zwTjrZc7O8Hd/3/z3/7Z6Bqp9+e4oKEXmkeEmmPqJ +T0W/9vX2Ml0S//kr/vt/vbrlcr2j3cAk4l98ItZotBvwNc/7wheb1193Wtu7mU+cCH/8L9tb6n/l +PdR+WraXRYqNOr/30Xi33m4Vn/nsaU+qUvW6Nbo8n/q0GKCr9MZbtGHdhfN/Oh1KS38XWQL8NPiU +Kw1gVei6yORfQ3IOTflmnKzpYVDl2IQwMZ+rNVh4rK0zbKuJxxlJa/WkYl6kwUwhhikIRB8Q9cTA +b7qvGceRkFZPtDiKnNFFVn9wxhawxLIa2W02lMqCzHiKYSvZMtSUjGmq1vSwREkKGtahHcjqVl4A +YPyCUeLSyNQgnJRo2j9rMEwoYB/3BFACHT3glBdXqHV9nClmd0E7Nzar6kg3+xgrEB7cbKiw0+Yj +wTs3xSueTZXzDVdQQ78DruQnguXTPlnd1wxrs57o9zdv7PvZS5b/xorBtwwMyNGEH2UiWWel6COW +UOw22Nuo12r1WrVerswXSpNBq55IeAMjXrpXEK7GGiIK/Cy0L+HcbqmZhpp8C+fsm4ZIVsph35ZT +cWsC2Wg1Uj0t0ArrsogCN6wLQktJbFfNG29FIK77aoAaLjgkTjfBZI2RKhPZ2CObuDOWSAE+mVJV +YaThB+s2nqSI+DfcfeqJVX/36ZsdoC5fMbvlygP9/QVuzUz3/vUn38gCcjKrgVRkNFXMAs4fSFeT +Q962bSs/8Wc3O0BdtWb2+hsODg1rZ/bkyd4//uitdZmpYW1QjYTKJeAhksnULru0dsftlWuvricT +1u5W6Atfij7y3dPA6TOfjd7/ADgnXjE6MeOuujJAWTsGFn7zDv/7/5hwgJpMtm6+qXHN1U4coX/4 +XPSLXz4FlgtLLYyD3ydwu2kBCpdd2nnwCzOdK57LqdS6tc2bbmjc9YP11avaBaemwx/74/Z2l3OV +8/7m704DVPJwvCP4RF+zG755X+T//fM2sOGt5ZKLAwzo48dD//j5U0jczfzCkZdLipFVALWnp3XF +luDON9evu7aBWKgCH1kLnxQv6vh4E7O7W/vYKNPPTb67Kef/dLqkliKLLgHgo1SsFXJVvA2ceoqL +Xs2rTZBmUIXA0EKpfrwe4LKnWeMkUXRoEKL734iG0tEWOFeUb7xWLMHcH/2IEJhLlp6BVt+wBms5 +wQ1cAa7QRuyfiTe0YQbqKDu+GWLlT09/EGURUyAfhASmIUFl6Xd9CdvQ2lREzig4Z5ZNi8lIcIvb +ptxPyboDCS5F6sT9diydL2tZBw9EUpww9wnMk1kM2wZgkJ7MTu9LZTvFaZnRbmA+HQi4wu5krS99 +Jy1NIhmeQVbz80BZOhZAi/bP1BO9/saxoVsyicuTyXQ8EY7hZICGiSxeZm38lFXU7cW9TPOBqFir +9UotW6mz9Rb3jZpA1SpiaodpcA6w7wCJaxQ1CkIM9cWxiQBxSdQdWJVATIASjOGN0JGnANskuWZa +T0Xyt2HeU+lWhESqRrE6KIUglzxp7EERB8YgZtAj6UEZBvDaUTolc+UyKIXy3FTqoW9ftGd3G1Nv +vu1ZplodY3yXiv49d28RW5538SWH7/rh70KzWo1+6hN3FPKpcjm+Y/vqK7YepCfHO0eljlWXn1px +igwDpar/hc+1iVyx9fDP/sK2eDQ0Px/+yH++PTufKhbj2767+sZbDrFHKh6LDg+X/s//a9t112fj +rYsjkRhzFXNz4fe+L6M5Hc97/InIwn0RD33H2ul5F2wOfvcD7aU3ZJua4lzW03j58t3tYVuA53c/ +UFm9SneB0r/+W9lMX/26/8M/1HjhHjg0uzbZ6MhpxKHwAuFNb2xceUWwYkW3SP2/fyJ6zzf0S2MI +mt2TbGk9u/jUtJBp/frgB+9o9GS8T306CgaTjfXGJ06GVixXETqOn/2HNnbSvf7tf1u9YDOPGrKh +j/xBfHJK+V9ieAWkGGN/7y9XGWemj+4CS4R++b2oodOeVDrl/Zc/qnzyr6Jf+Vo73x9+pHLGGqXz +fzovsZlL2V6BBKqVRiOvhYjS9Npw/v0cwFPY57tSn2LVKaYGnt+BzGwV3AmGe+LDqd46E3zhBkYn +7s4TSZCpheGV6mkNLav39rOXRvoUuKIArz4ra6Lxps8Hr0sJVjkJclI9zYGRBi7OZbdQFxBlpo/s +D1O+Uo429Epmp9AlVFPigArKHZORj8DGpZ8tdVP3+qmpnLBExQ0CiZKuzYt2S2O8dqv7zV3saQL5 +QXo+ADBgidUIWFaxPhkENpsb+GC6VEaqjfqCf/CWm4i1pi7a0PfeTePvG+q9ur831ZOJppLxaDQe +djvzabbeFNt9ysxpHTnXAdRKrZAvT1bqRQ5v5+C2HmxakMymkInAFR/ArB0sggTbMGb+EeEYjIdt +gZ+hbye3CisnjTesFS3SOrjblqRhIWW7eCwJGPS6XhGicC+4+6YSaBIcNrgRBeE3lbAxhi6RcigD +YWqy97/96V1/8OG3/dl/fctTT6wjhU1Zb/2xR66/YRePgPxUSi/qsUc2FYt21IDnveHGHY7bVKp+ +0UVHjYz3ZLusrlwzXTrfLE1iRTpMfvuBTYV8m8ib37KDUfZ6szU67F9x1TGX+aFvraEDw37WcqW+ +eu3sTTcfj0ZtMZy9/+zyZHLU5WRiskufmwCSu8SA01B9JzCfOjDQuZB553XtNlboOEDl9g+8qW25 +sx716adfBIEw/roUx8Z4ci81gNYLAFWl3ESpK7+wRadTDG3aGPyn/1h90xuDa64Obrm5LQHyTE62 +OXnwWxE3+Uoi0OsAlfia1a0XmOs9vZb21SsgxcTtrTefAlQIDQ22LrqoLZnnb9eZ9S/K0zmT6NL1 +4kmgUmZNIYOXWj1oemvxSL/2lARxForVk/I27IXY2scSG6AinYxct35DlvGziEA0mtB21URGa1zT +mdbweKt3iFPKkYIAlfyoY8aBWQCsFbwAcEqXYT9IZZrDY81Mv+CB3CzekcUDvNl+UAqir/lGHWPs +kgeQMAd9UrtadsKHu2ZvOfkoHT2+UEE5tW40pf2tFJnJSQAAwAlXC9oc1Y/CALldCs+Q7gIQwi1Z +ooCrrV9F3aNDK+aLmHQ6EzDJJYlYrtwFNAf81bO71hx+bFOoeFN/z+bevlg6E0ulUzF2FUfwgMFw +o7NyZKXKmQO7ZRjrRdBC1WKtkWXYG2cOA6Ma71UwzHNNgz2khFjasMotAxUhJTe4NABzyk+3nPFq +RUTKFVfGDlkrLmoOay2dbEqxep24hJqUMcx2qEl1fNTtsLJ809GBPVdQz4HTZG1DUbssKQBeEGH/ +TKNhvRVLeftPPnTRxUcQNYGcLjJxvL3OJ5Wq9PWXuIG9GDRDvcQtzM7ivxo2FRaiGpcy4jVwHTp2 +rE0EzxLDQ+VKtaXHVG/0Dmj4lzA12aNxXzvkgXTaRweHdlJ8ft5jWRDvgwtK7gTqXbumrcEPHAy/ +79cT934zwkbts8PEBC820lHYtImBfU1n8OG3kGnvIfLwheQyPN831XVDvb7gopv6EiL8viZOhHC8 +0M27sEXdRCKpVOu3frOKN00Xui3lsmsus3CpfdvzbrxBczfdsJDbbuILRM6TVPtJHWH+pF3J87Xr +bB4W5emcTXYpZbEkwO/Q4JT9qd3Hu1i0Xys6DkelUZxeAXj8rB0K0kpEtXoTtwwJP4bPoNliLhpp +VSMtoDHg/FTpz1AiXe/p1W+qWBKNkJmY6FyUCAt7EkmcvwBUoEiI0db+4XrfkAwY9kTo7C3DP7Sh +gwqKO4zEcgX5UIWs/QGJuFQZ8SdkFbRQNf/bKk4pZHEw4PBDdKwE6p5c8OMICCalP6V/AU6wh1tC +bltLrOlVGMOnHVPGbk6Uu7QIhukotOSzHrKMXJGfCAupIvVMv792OHH1UOaayJoTDxz6Sq0+xxDu +shTtVE9L666w9xEMhGAZyQXaeIpxaoDaqFSzldo8LOBxkPFegjJaDw2xqqTBHowJlGkGnJAiWsqM +ZSa52UZMJ093q63mkJiaK6tUbyi9B+u+iKwZplDgLhRUi2Ul3UmS/Iq4uVK6O7ZliBRloHJbqMVd +0pEqRQmStn10IT7aIZGsbtp8nB/LM9vXiKIni3P9hpMO1IXWtL/pTU/JTSahVEp87CM/7uILvytl +tL44ZaiAihYGnghDI/Rwp062iWCtvv9953AxViqxLpiBwSDmszW4OTfvf+u+dQ89ODI9w9Il146F +hE/Ff/5n6x/8cBgjlSSGOv/i4/G//pvWD9zeeOsP1fsXLPo9dty9ayr4l5+K8TlFohObn3+hisi1 +0NYEFzvlXvwvj5LlPF+7x3/2uQib2V68gOVIpzj28VReXqqzw8LR3Zc1HL1YpOjx3PtN//4HfQbG +X/hJnV1jN2VRnk6X2lLk1ZCAIIn1rwzovRrUX0uaaonWKDEshpOBSLo3Usw3mLViem8+X3l87x70 +MsYZs4BAS8Rv4pQQq46D22g6jvdQrKzgxR8hS1XR+0BpPAlqCkjiyTD+oHDXD2wwAspyp0Y9xHQs +46UOHdodEtOSxMEzFCdaG5UAHmnTjlPRKF/gk1RT9yh3hyu63YFVEt0H7e/ULqip8Umej2kYQbhd +ckU6qryB10Io46gBh722+4WR3mrZEIWKYBH8CMt8RNewYaaGwdrw+hIrBnuu7EtcmU6sjkYSkVhr +6/VDBw4+NTs7m52d8dZt8BlSxBES+43Q3KylplcCHrM5qcZ//tWr1UqxNFNvFnCRoXFyBizN5iMb +vKl1HWBqxw3huAcUCVgAQsujbB2AgU+ioDIRMBg+25KxVkOWuw4XyUDbEZHqgqDBLbOktLHd67c3 +mmxwRQrUVClX1iMhPwUhpW6KkYUr8tSqbccXZCCnC319pTt/6HHysyjpyW0bSNyza+X2p9ZsufKQ +xvlhw5ZPc/pRu8Dz/2FwuLe/rHej03aXNxZlY5J+hBUdgPQiYXY21ttfYFHT8SNDH/vIjdVq24CO +RFqZdKtUZmgXZs8MbO3/8AcreDXauauNOeT84pejrEX6tV+pXrGl/QxKp5aXnkmhe/2imIov31gU +/ypiw+ZWbWygW/55Igj8T/5r7NsPtZtDLlbr8P7nFpiqz1P0xZO7Q9889s5BVi9e6pw5XgEpttB8 +4IPxSmcAQE8qo5WA53xS56zUJS7K03kB+ku3FkECUhxO6y8CsdeNBGhK3XwHAdOn1dG+TCKSmZub +iUSboAiDY2z+qOGFS4qSUyq1xBcdOjgSLxWrWfZlmi4GezjgDETEyQvkEilzodYbSmcwzqR/0deM +RwFdBI1Psp8Gzcisoel04oAcOhrlJLuKyTyoOHwlgoEF0JJOYTeY2flu6z9utNWa6pL1w1gugAoS +WE76B4ANH1kpuiljmiqgKTbAGIvTFsqCIozEEoiQE8AjW2na600Mpf2xgd7LR3qu7kmt9hMwjU+n +JuNQPT29V1xx9Te/8bXp6blyqdzTE28xYSqrswV+4ksZauVKRZhaqZUruVJ5thWusVUmzWC4gzRV +qADMkAJvDu3gX3hmYEY6oX2L4XEzapVkLXLfTiBtsSAxGr4APtWezggqlCHo6iIuAKZedYRO1agL +F6ygvtxqJsNp13HRozEGWMOlYIirijqBtwWeb7rlmV3PrWS1Ecnf+PoVK1ZN9fWU3DPl3WDDTKGg +3S++33jfb36RpXAQsPfSuhHGJz08PUFemM6AtquhW9XIaA7HhyTSpfkPH/piNCoCNFBPmRjTE5Fw +MhHGUXO9Fv0vf/QGB6ibNlbe/a7q+nXMyIb/6E+T33303MDM3OEHf6e649kw64xYFeyWMjG4+kd/ +Ev+Tj5WdtepW9Diufvonaz/2oyZNd9397rLbTTk9QgPZG8ryH5L58X39Xh8f9KdnOcfVP33Bd4DK +/m/mON94SwPwO3wk9OvvP7Wn6BzFXloSvY1OxlC+4PUtsGs76S/178slVSx5H/79NqBeeEHAgMH6 +dWxI8/7gj2KPfPdUB+KlVL8oT+elVLSU55VJQHYdO0fcbvMX+5m8sipeo1JmodKWVj2oVIMsg73Z +PEdvSX9hEyRjIfPRgG6SXmcaFQ2Vjsc4k7LIciSWp5LKjhusjUAWnmaPlAg4hJh9ZHIU4UgRsylF +h7tpZyqw6XaeCB4MkgFRgBbTikpRgsChNDVzUYCu6RMBH8rUoBMGoOE+UNMHVUsRIMEGEsknj5Fg +ieWEGciC6NKtBkWsViBRLvXpB7j1UDBlxhaMM7dEaU24miFbmo42Z5eNpe5YP/xLW9b+1oYVPzE0 +vCozGM70xDOZdCqTSabSOPDZfPHFPX09k5MTM7PT9Xq5XOWogmKhkJ/PZadnpyFbKVc53r1Umi5W +JiPJmmZP8edgGOmetBhwJqDx2U4kxcxEk6kQSwJ0Kg4uTYAUJF3JbpTYliwJ27CpTGiQEv6RzTXT +uhq6WFCdZIsk2WBqHRoZrJZf1ZnwueWq4Lko7iRvrPJo8AfSLoLQeGSOQxVVTm7F4/Vbb9tuCazl +id79BfaGWnttu87QMJu4FJh5PTkxwMsGgrJ0lrmDSJQ90WA4dVp+48pldt/1hpQsr9DoeJtIve4f +OTzAj1OPMqLirM7lg3gZlKdhe3YNFArtgdn3vGdy3VoWsi8k+bxxzlf59ffVfv/DleXLTC469DC0 +47m28bpyZTuR8gzA8mqd48NTe7Hw5jtOgeg//GOUs2heNDz6WJsHNsuCwedpTZ5R3cLx3gMHTmvA +kaMvTXAdii+X1O7d4e6s8Pt+tbZhvZ71C4UFd1kFuTAs1tNZSHMpvogSYL6MAKDYj3QRCb9WpADR +bujUWeNImcm5ynQ2LwBtsO8W1AkXyuyc0QlkPhv4UGyBl4qE9h8qSX/YMi2+6hzFhspDiYBSUeAT +3SwUxK0SKlh4iQoGxlCgLKaVy3PttBFamBkhtEPVaQayjZHCV1vxpCTw0jQvFXLlflSqzviGLGWV +zsfsXUxeEpXZwTOamsFXODJAxVYmG2O8jEWTDSb5hj14IDAzR/8gP+/Vi14q1D8Y3Xrh2P9xzebf +3rL+F1eOb+0f6u0bivf2Z5LJPs72SUTjiahO5EQ+/X3969ZvnJ2dOXLwYD5fKBWK+Vx+dmZ2anJq +8sQUlAuFubn8sWprtneI9c+SkiDfYAzW1YR2G8SGAsJ2w7PE1Tal2Vcb0ly8m9qWBq3gxindrsby +UeAWNO0ZKhc4ZGvBuKP1Wbb+VqBOIo/GVie51UDKZoMN6qaYdcuz4+PQnRTuMj7hGMYsFvpqYwC1 +AAAgAElEQVQtCGRw4eJLDq1Yqe4F4fjx4ccfu1AdGmsGq5aMP92652tXMDvg0nWNcAz7icKeZgdc +c3SvLQr1/xre5VeeInL3F66MhtWhY7kDtTiuwj5HJAmujh87ZWrV2TdmgUmKbLYt1KpNnbr0M5pD +4rq1rR+66xTstct4HntRLruUzojC089EcLrk4i/3+47bG6zFdaUKxdDvfDDhzNaz6Rw4EDppq3OP +dvwuLVzAxQlx3SLdxVPdlJceWbOm8wjx8/ClKKsKXMB1Q/dAt5dI7eWS6vqTgn63Xt63cz4p8vQt +2DT87OkeMBbr6bzEli5le9kSAAVQHQxqLttyW72Y/YUfe9PLJnHeBQ4cOMBwYobphfMIIKt8t+N/ +ICjP1R6eK+awukpTK/NHL+lZdpgm5g9c6wWpSHoG5aLBW20QZNcNY542FscqSrRqvYVVir6Tti2N +Mszm+VV24wBm2rRqTpfQuQAJYsPzAboQ5YZyREtqRRIbVe2Ub5ECaerxILcqVO8P1fpb1X7ODG+W ++5ulfi9IhlMFNCoKF6UvSKbhZqsJKhxmOHS0YU/dNFdNkAVEmTLU+GRLW33AXRbuoojBeGlkW/HL +3RKOBnORZGh8Wd8tm1f+q3Xjbx0dvLinJx1LR5KJWDweS8RTUToaBNS+IIhNp/QbtAocbnY8s51t +MpneTKVWzc7NzM3Pzc3mp6cmUOujy9PRdB1v+KyapjqCU3jwBpM0h2t927Cqwzz12ax1umnGJU12 +weVU3MqKlFHQBLBFBDzuFhY/KhHhI22Kk86VWbTkUX4DNtftcCMECASGKaJs5NfjMgYoaaRQam3i +9gQ5hkjFLcAYn2eeXpPNaqlrJl25/IoDRCBFGB2de3r7OuPVO3pkeMPGiZ6eClX09ZeZLj0xIecY +DALveGaV77PrKFIsxSeODTyzffW9X7ts9ZrpVEqTB5Da/sSaeXPHn0jUr7thL+wh0oH+cqGQOH5U +RHK5xOOPLedUomYQyedihw8NPPX4mi9+/rK166cyPcxmpx5/dCXZCEePxQYHWgcO+h//ZGrP3vZw +YiHvXb0Vrw4S5nzW+/XfTMzNh+hv4eiO1eyHD4c+90/RWfPtx+vPgGSyM8LKzCuradw6mkceiZCH +nje/GhbIPLMjDCDhOxDKrurn+0aAbCCBjhthBj++eZ8/OyePg/VGCKR8blf4u49GWAP1j/8Uu/wy +ef77zsP+vHUI8PmHdc7LSPG//KsYxxi7Wug2XX554HZ1kYILC7fyiDVKP/SWDkiqrxP+9nfaQrjx +hsCNl2LhMQTt5i8pRdWHjnA8aozNr+x5xVJ3VbB9aGVndyweHLuepK69Oli7ljda4eWSwpFFl58j +R8Lsotm/P/xnH4/t3tP+JSx8UtDHqH3o4Tb/xybCQCzvBrtUebEJi/J0oMNkDozhjIIPcnb+fjl3 +78otTZfIz8fVqFr/9wgPPfQQx2+fT1s/8Y/3RlN9KBbOT9XA6fnQOqPs9PT0rl27GDqUIdxiUUDq +ggsuGB4ePiMbl9u2bVuxYsXY2NjZt14gBRjO5/ODg1I9Cznn58chblQJXLj20CzmM5wNiOnAIpQE +e+I9bz7PbxbVyW8JbESfcVw6FkHZUr0gt7oVnwuSWSGOs1DNSFURzsbD5x/Dg86aoSgDiTZtSWZg +VdOcYC0HddYGpQ2wkHIrQ/FcOJYj3mwWI96E+KG42XDQ5KNLp6dN51NOfp1s0hTAZiESS6Kg7GZz +2XJKGximZrMQniWYdIOfXN7D+39vejAeWzE8vGXl8A3JxCgjwwxuM4XsR5hDZjzZ56gddQgQiX3T +3mYzwmFydB9YgpROp5PJ1NGjHLcy3JPuzc7mCuXc1Oy+mdzui9ff0TPsvE3ZPCjcmu0FBQkR/vlD +i0jkoyR9iAMV3AUOVZeaavnFgoLLTAaZj2gNQz6XLiFZEdf/gH8nIuG0EVEtrkb+GuBBjYCghKwM +1xuydq1MTD1KUEopZuMaKxrSR7DURUV8i3fXvxExq8lxLll5wyPZK6/au+3xzdzBjf6XvnDtL/zi +vTqkIeTddsfT7LrZv08e9udme+7+0lYVXxAAGAnAeO4mww99Ar2UDKA0vR+482kcBe/dLSJTU5nP +f+ZMIoyp4FL04ssmR0YLU5PqjO7cmdq5U8WZf73owsZzO6V9yfb+/yeJfz62bHKJG4QvfEmISFx9 +SD2tdviFn68vPL50bKz1K++p4cPPjpGQwuXTyau/1193CsAWpp8RX7Om9eH/VP3zj8cOHtJTYVvL +Pfeee6LXFbzzB+t//t81Vw3yffpv2sPaGzcGExO4Mha3D35Lzig++p/PtQfIkXj+b9wpvOOn6p/8 +qzZZ6DjzkdNy8OP4x3/6Qk6azqD6cknRD8AXEp4OoYMzRedPkSfFTmJG10k840ltvSpYtbLp2Dt8 +OPyH5kDqYx8tr1qpV2Sxns7dX/X/52fb0ug2EN/973lvu2/1K79UPdvJcDfnUuScEjDNJA0ie8V+ +0efM9rITAdQdO3ZMTU0Vi8zGFfgmTgrpL5vW8xQ4ePDg3Xff7W6Cqa5PoO9miD2VUZ99ItKMhGoF +E1aWihQymt3sFSJspVcOPDCY889geksruwEhoIUJsWWPhVL7ZIpR0AihoNH7FIQw/XZ0Hz4i0IZK +NAihCoIAFSqUipXiy7b5Y9sio9u8SC3cc9Qf3xZbti02ukv0REcB3jSmJ6LCY0CFD2YEWNh9ItK5 +ptNIYdEy+2VhG0BlcXI159VLnOfqzc961flYvHHp5Wt+9arN79u8+m39g6PmbjeeSqUTcdwhEZKx +eNSP8bQZ6XVql/bWa6w8qhRZhpTL5QvFQjrdOz8/d3j/4ePHJg5PPLPn0Dfmao+PX6B5PtY90TqH +kTAMY7S0zagTrDVK6Q4aDYR0uSBIYhiCJi6oiQb/LY9uEbVL4aiBaHs22slftwV7wj8H0hQnYpa9 +WCKbcUgK1LiF0FwctiHMXVUKcQqancAlC8LFsOUkQkESu8EV4ZExFMFdaN5087OZTHuB7OxM77/c +e7kQKsSe5sY7fuZbP/YTDw8O4dr3FAnmI8aWzV182ZFUqr30k+yqz4LqssY6QaVTjZ/7xW/91Lse +Hh7Ja2qmE1i1tGLV/FVXH+nL8JLh/Cj4pV99ePWauc59b/26xoc+UPh3v1W67NJTmGfrtTW//obr +G2zcxEglfxdQ8T30b36jeuebT+V31DDX/uQPyzff2FjoJ4/GDw02sSlfuq9BfO7/3ocqP/PO2uBg +543vsmsRbL4f+9E6p6NwdfttwTt+qtZ16oS3IxZJ4fLp/35vlVXErhzLCF5xuOsHG5zdlsm0SUEf +74w0n5/byw0vixTCpxZE3a0Fn4i//6HKf/h3VYTZTXRPiku6g+//jSr+pLq3kLzTQi5lsZ7OAvpL +0UWSgF4uNomEQlt+5gOFycPf/h8fOn/CANuDDz44N3fqp96lyUHlN9988xl7YT/3uc9hp15//fXV +avXzn//8m970pieffHJiYmLVqlW33HKLO8Z8+/btO3fuBJ5JvOOOO8Dmf/7nf65UKr29vcuXL7/h +hhuefvppUHZ+fr6vr6d/9VMVf2eh1KrNrixPr0qteDBgaHTi2pY/E1u+h9W/wfSljMSywS+SnooM +bW/UglBlYzC3GVsvFK4lxp4JpU5Ujl/V8udaPftxkhCUB5rTl7VqDKJVIn37Y8P7UdzlQrR14tbY ++GP1uc2t8nA4ddIbeiIckXNzdK5g0hS3+67tvzPSvzc8sBelyd36xFYvUo4OP4tk0CWNyUtDfjU2 +dLBy4I3RZU8E0xdSYzgxF13xeDha1sKZeqw1c6VXGSGbP/pEszUtUKFww4Z5OcAOfwC1ocH0ltGB +yy+77PL+oX5bGhP1WeMcj2KYYpU42zQUYRcQJUkATXEoyLFsjUqZUd5SKV/MFQvI8OC+A9999AHg +M9MXNKKzPcPVFes9fCDX97z9R991iZpm6pGGCJcdRPHX4BNswB5VBV2osw4Nd8nPXQds7ZXmHdvU +gZmTFdmUuYM3gkPmsG0Ul+4ONQp4bAUTY4AMFSh0zD4yqxwQyzhByNP6WDuvFIapl2FPKNCJ4fFx +6fgnQu/E+XmgXj4KfIsn/e0miiZN5vnaDLprJtnarJLfcNrhIvFGjVNTesrl2OBQobeX+fxOBpOP ++NR/1aXa3F3ema6JTx8Fi60WnpvpKVdiy1cU+gfLdOa0pFAVyUkkcfLPTvfMnrhw/Zokw7zyxkwa +Tgrnw5h3nHnCuS5WTfuL5jDuyp5RxhJHR5svZfkrP2WcPACuLOVl9uEVBwYbGT0+djxUqYQYz+zr +05E4Z/saZIcJJhqAt2oVDWzXRleVhUW8yMtXtICo8ww4LGQsGiDvDiO/YoIvnRSSJ/PMTAgnxgt3 +0/I4GOs++0nBEuen4l6Rt5oiz7dia7GeziuWwP+fCn70ox99z3vecz4tuvYn/01ycCWreHDMItvr +fGh1yzIqe05AJQPp3MVc6mZeGAGMs9nsN7/5zauuumrr1q1f/vKXgclNmzYxxvvII4/89E//NMOS +mLwUYciXDAwa/8iP/Ajqw40tX3PNNay4+c7DD00d6etjZR2jrvyzNqGRawCJ9DKnufnN+Ey0f2c4 +2qwevC2SGQ1FJ/yB/V51OBIv9ix7roTDRsYqG8ysFvlFt6rJ4NhN/tCecO93armhYPaqAC/A6cPC +hnpP/eQ10ZGdrcGd9WM3evFlXuaolD4WJ5ak6XFpYVOeSjQDS9N4ialg6vLQwE68HrJ8uJldH1t9 +H+PSrVpPY/KS6PDOSCuoTW6pnbwwPPiE8k9eG4oV/TVfbcyvqk1sCfq+ISwBYIJENR+bOh5Ucull +w5ckehkbKteDQia9DOzUGVFCI04R40/74bojd2SHYVEHDfolVf5XKrn5bL6Uzc7nc7PFUnHOi89W +IqW+Pm/NRq9nWMq9jToGb1QuqDN7Drr6OCPSuhFU2tXiyJ8PORUsTk5BoB6FugWyFKHjnhTXnbgj +SC0qZ4qVqBIpYgShwF33DSmUL7VQF+JivbRYwiNSXW6ArDKrzq0ltrEByJIfCvjlwEgVn9YJIF0C +N/aoTjteuGVLn8ghGDbMI/+psDB+KpU5+ObYeFY5LUM3F9y6Fqkx7q6Bt0ZQaBT9CePNTRLH482x +ZVluMN2AlRyNyz+LTic3+5XTDJDi6HhhrL8c1ckPJinjgelVbMoF7LSj8APKngG0Z2dbmILnwoGB +c5BamOelxJmvZYZ144YXyQt4dB0HdrPyLuPUqXt5npHxsRaf8yTiir90Ukge4Fx4spujwKj7woH3 +hVzxA+zre5FWL9bTWVjvUvwVSwAFZpMqLZ2fulgBFzsvQIq7z4eprtR11123fv164ky+MmIMpoKa +wO2+ffsuu+wyDFNukRKLxeiPA6LcIqxevZo1ShAfHhqZ3HV4RSKKRVLPazOfn4pUa6aFULishAw3 +QqmjOCmUvo5mMVj9zPEWh6YyagxGJQPmWdFrqoUefzTUmFlJnAHbeq0VSk14lcn67LpI4rByKP2Z +cOY4CBeKZ0MNvKYelXHT0aGSKkO7zls6apDVwjY4HEod87wtocryUN/RYGZ1OJH107mgou53ePjJ +VlI6NNy7vzl3YWsQtZ5qVUdbqe+UZpOt5lw06K2W0r2poeHhy8v53l4s68mj+dLhar0WNCtNL14s +FwSoEc7vo6/U1eTiljlzfGJgouLLARO1UmanTKlcKeULudz8fG6+NDszPTn7bLayZ3x9aWyNlxnQ +YiuWQeGhCaUG1ggPbFcMCkIfUTXIJJ1Lp9JJpeGI1y5JJ+jb8vOXO9BRoh6lgI1AhK6MUJOyVoRE +RSHCH5fTCpJdBZ0DJqRtEOW+eeiiD1LaSQNcQg0MdsMGTJoSXHXslYIyHYUiezysRi4dmpKHUjAM +TTIT4dvRcTlhtcuhKFLcmOxwrTQXuilErJJ2uprfaRf0VReMGatUpAjIbb0Nxy280TmAPTyWJBP0 +C7UphwkbEbGFae4Vgzr9S34X7WqW/ixJYEkCr7EE+CVLfWiNEtHFCeZ9VKQW/ra7y4i6d5+vsv6O +nzTtjLOAeXrnnXc+8MADDPDedNNNDnEXFof4kSNHGB+GuHSKF5mvlOv1aCQUQYuymrWdGeUIV0Eo +yG72iiyn5JSWjJfMAp3MZCAHdFa+yGErWluLkkMi8ahXDtLgpTPvtO4pNtcsj8BaK6op21Ykz9oW +5kF1qijEgQTWDBt4oBbR+9ohatVTNctK1SY0oR9Eeo8E82v9nqONufXR4d3U5YZDQ7JcTe/7OVYI +c2ZaUE5Jc+Y2k46mDfvljSNvX7vyulRqOJ+fnpg4wsKjfGGuUMjWa6xVDuezOQ6I8dP0kzhtSKO+ +tExDvZg2TVzbmINe/ApWa4yl50u4KSjk54rZ3PSJyd1zub2R3pnlF3lDrI9Bj+MtuSrljj+c9uEt +sGLvDN8CA9ormUp0NI0mCwP0RkmG7VfKpKFWq4w+MEQ2yceoKRHQciagDduqCvu4oT+It8z3hRt2 +JqdQwx6Q3l7joS09uGZA2Dp1UKB3p90+hrsiSL02egx9JXIITL7NP6MO1KIWWd00qs08Oe2WWDXm +XV+hDVvkNzgktwqSxf2x+MIvqHHHfZ9K70hGpaw+vqgIPtUuEvW87ZbdlWxD7CXltWzG4ury8bON +skQNOmd5JVwC11NyXootSeC1koD7LfPr0w7551MHr4CZeCwmL/YohtMD6acnvNSrNWvWvPOd7wQ1 +77nnnne/+92sIu6WpBZGjO+7775bb70V0xZz9tnnnsI6BU2BWI73RCdp5TF/m9oSUz25oZVfGVvz +L81GszF5LXSAPeEO+fA0VDHdR2YLSo1UWqXlaDpWcWHKBlXNqkIxGte8pNS9oYVrqow529OiIU1b +D4XPI7ewRRrSjUyiA1k23Heweui2xtzqViPhpY4CA26RGNBFHwBfia0ym9SalWKl1YiwDi/wj44O +rRgfuKYvvSGRSQI9oUhxYKC3VhtuhYNly1ccOLCf5UUDzaFKtTafnU9mUnW2wmmLEaiAc2JgVSeH +A6X4bMBNUrlSZAcqAJzLFadnD07O7WhFJ4Yv9AaGxR7NUV+BrbrEWc/Fdlh7dLTCaX/3tggLDCO5 +ROMLAAiGNIJJl+IQgnTDQocWLqeKU5PhKw9K47dGXrUY3rieniw2eiQ2JEv3haB0s+qAEtXCU2KW +GiZ5FsYPd4WsqsCeiJmbKgmHxhUEOHTdGbLkcTt69ZIYRsIeTxzRcYsUaPLd/YFQexdhxWon2Euk +bGojiY4UNOwSQXUzi5Sri0SrQjSsl9AhpuJKsVaTqDeKBEqFPfwAcN5qPNZMJ+kNhzgWooPp7dK8 +7wt7tO3UpT9LEliSwKssAX7NqAB+u27hx+LUxjTe8MjI9NQUsLqQIoBKupvkW5j+onEMKYYqsV83 +bNjw6KOPOkuXQWDmVtmrww4YpgMh0tPDepAyw8X4u6+XY0GzDjhJ+Tqbw/QZvn1bDRw6lBlRbVb7 +vUa6GZSbOCfCto0XW5U+5WLnTEXzj6hp6dzYMa95QWN+pd9/VHZtZayV2Ue6CzJuQAIuqcjAg/S2 +bnX2ExoZWIULsNY8NkgfI/b4vBfL1SevDPUcaNSabsUv6eWZ8VYyH6rHgsKKVvRoIpxOJFewcTbl +37h+/JoMJ4OEMBobsWgs5HOAa5I9SPWgOjY+PnH8eD6Xw8UR208np04ODg0BoQ3GnUEjngTuegHU +OpOn7KEs5lmMna8UsoXJuT0z87uD6OTA2lr/uJfpFRQxzIi1F6G7EGjUl0s10OGlNZZXRsjhGo06 +58OmXhoILto+USrVXUMvvV8Em0tu03DYSQ4HHHZJXA/LgQdFiFOFwS2Y6ohrrppsRtYRFMZYXus6 +CHiwTbEsYYNs6sRwaUREj2fhHkrYK+VshthwTgBvTKpdxA3tFKHhjrq1V3no5gCopDr2DAWFuBb0 +3Emh68DlgkQr50orn0S3EAONiBGw4sRUq4J4sEAznYXNHdd8PRQNcTeScS+DoyYniHb2pT9LEliS +wOskgc5Pm7m3s63KV8gTIIdZyVqkXDbbhVUAtbevj3Tuvly6rES999573QJgFiKBnVAYHx9nDvUz +n/nMhRdeyJqmlStXshKYSdbNmzefPHmycPjaxKr70GVOZ4bwbGr6TouPUoe8wlht/11AmpYa5S7w +IjNB4qifOdQsXNs49GZ/7ImwP0V+BtbQnuFYoTn0WH3yivrUpV6AAjvgD+xFd6O4FZzqdDrXRndd +msNa4lTb1rmWU4WcszEo9xxszmyJDByI2uFrZXPe1iz1hPN3tgIs2UK6p7Ri5Gd7k+sjq1L79j+1 +bdu/sBmGCdHLt1ybGBlmxhQFm8qk+gYGhvOjY+PLjh49Mp/LIYSTJybA2qiPs5g6tjpeezlQlg0z +WKdYqIVSMTtTmJk/nC3uLraO947Xlq2VDwdOV8WREKY2DKPBZR1aP4AIUae0BQ8oelP6Jl7aY1jl +xtUt7tCjDU5dfDIwkJVlqKZSNgfoiDjYI9EBBhHVYG+nEMjmNWEMmurldKSOkJEBeE8Kj4NHRk6+ +4Z9vKLOuh7VplFIRs6ThnWeHC2hWU6uZ1EI9TeEr6cppdVG8bR+agcst0t3LpAKAmVnG9DPoT7ih +/rY0+OOYN9JUqkv3DUudu/x1rVCCJSqfRZTH+FcTXKWG9FwqxYSvLNYoeq02M97K6OygpbAkgSUJ +vN4S0I/X9M2V7/5A4eThBxdjLw1tckt/Z2ZmsI3cMBSKno00hFeAqU5ImKSsSFo4osXSJDCCFALG +K+Ysa5eompy5yq7j1b/ixLeIFysWGflkgQeugFt+vFUtai2nNmlGcQwP7Vg4ghNC6WAM0waHMKYr +OFhAa4bdljjGTlFhKNxmgtNZvDDOE+S8EGxAj+NBwpmYXKLVZORpJNlghoW+YJF9O2WtXTHOxjI9 +Hspv8srLoqseYKSXGmulWKLww430NyOhZCZ28djApb09qyJ+jNFXlney3IiFVGjXZCoZ9nXYK5Y0 +FXF6DFOjRw4d3LdvzxPbtuGOatXK1emezOYLNg/0DwOjYCrmKYLC/X05X2XAd3Juf7a0u9ScHByv +Da/0QHSAAaxycIWDCBoItkEcI492YR2iyQGw+r63/+i7L3FoIIwxgCQnQTY9ESxCMyWRhSggQyRg +/RryLMwJcvBp44qbjkWe5HEnsmHQOx7MxHQFEa9kbqJTlQQTJgIXKfWB9CzcEAKXbPBliWylKv5k +XHZq5ClwMg9V6wZ/+BhEQcT1k1SLAZhuuLvGqiCNl0T9C2uUDWWT4hootCPauXRFubK8gkDiymmk +2hRIMIzsisgyiQ5BpPReGuedboESSSbV8NXRR+YZf0VfciNLEPgJENyPgohyL4UlCSxJ4KVJ4Pz3 +0lzzE+9PDa2SZuZHyO90sQI2JfDJrCedaDCVQArLfZ2t+cpqWTiH2qUATdDU1QJaA+HcQrOkoxtT +9XXzjWflsjeCc3zWwXLIijXRfNM3sRa5Ai/DNcAJG4gRvQbb8cNVIQEjmUzIYYyQJyR/+igv1skK +SABkU2xdrSuNj4JDv5uKlB4jDwtbyMHq04T0poYuOwOJIqKqQ63chkj/c+U57eUAk8IN2d/DqTuG +BjYno4NRTsn0A5Y8iyoeGth0GMNZg0avm7iZ0Sl0TU6mDqryKhtPJlKpJM7wWb+bzeHKzGPRFjmr +LNVqVMslVviWc/n5+ezhqexOLzE3vCJYPuqxt0GM4HIIJ4zmN9j1CYAfZ//RNJinQTRN6EiAHUtp +ouXNljXJWNu5a8ghmfHflL6lqRbBAN8ALcUNjUiFPsnUrgdhlKkX6SrdpOfyUBA2VFY0RJlnJDSC +HZ6RASr5XR5R5JZVB6A6Onoohk9YqCxjNhrWFmLulnFCNsqJE7IbBZjhI+J6r9Rv4K6oKYelU4Sc +5EFWZCIncZMDV90Uy667Crphxfm2uhBXe8TY7ne/1EZj2xVUW+DHbiveGdOO++Fa6NhcuTWY2siK ++G7xpciSBJYk8NpLALxDP2t1qPutLgoHIDSGKWFRqJ2TCHyT7r5dBuIuuPQe7458aNJnCTBnnbZa +cnabac7m6jFOCzcTimlXlizVq7jZlxEWwzEh9qtNHxJDnYXwvx/Xwlec6etwUBLlaDdENwFAA3eV +gn1mE3hNt5yHEUhL1C3T8jrHxiYaNRqMB2Ho4xlYdnAiHD/kx09mp+PxyPhI6pJMamOFYeahFfEY +KFlnvBpQlVYFvOoNhqH5J8tDO07UcshxhYrnSr4dYonevn7Ok+EAVMo0AhnfeAVgsrlYwMPg3vnC +fj9Z6F3VGF3p4ciCBUz4NcQkhRJEZG1jzBHR4QFqFw3kA5AQh2dhjzWNBgp1uDSNr0RQxL4BY4cW +ygqPBsltEAAMYEgPTZhERFEVUzaCtdRKG1qQ5ppGksAMwVo2JwCKy1w0Ii6dOJXLHjUJcQF2Sk5u +kJYIKSWN+pLqoM71EtQWyyd+DLmNG9HhI9tdN6zJ+qtLinDLtVrWOQSgoD/qGynd4J80JTvQ7YxI +q8V2Q9/wbxipGhwbomKlrCJJ2ILa1Y7qtojYtdpOu2ryXVBqHmfsfjB1cSwsH8VLYUkCSxJ4XSRg +P2vPt1+pNMD3deigqnRUPDI2WPvxauyLfcn8vuNlO0pLGy4qdSkiORXiJDhWAptvHXoUZdI5AK43 +FPVbTCsyIspSWRwCcF6L1lqhsm1STSRsyyYg1A4oTW0cNFeFNkfYnvnD9GHizcZUoayhSAdXOPTx +/Wo97CfyXvHqtYPre9NrYn4Sgn0ZQx7AUvaayLtlnyysYlMMu1sDebkPnHcOTDAenqogFX/nIc5X +zwCzOLxn2XO5VMM/lB9rTGf3ZsvHI4ni8BqPo9liKS2/kg0N0lMBkGmmqjAVyGec2bcY5y8AACAA +SURBVPxjAKukEIdnSbMLNqbxu/ofAVIv+p0PxR2wkV841H2bLB0I0AylSxTf+jhUQ0QqbgCGoBxB +CDjTWbVD0CxXOJZjZoDfOhOkCxGtLhmsbCpy6GvESRcb1KlV7eYbGQeEhmHQ4Y4rQr0iwh0bTnDV +kYHmu0C6cvPtyloTVJZgKdyEvtimjTatS5wgUiR2hEXTlEhOGmuRhQTdLSujDC7oTUW2ItMJEIGm +E6mxBEH4p3tEYqkyFzSfGE5fmoixVZq6llb/duS29HdJAq+ZBPRLb9nYr/3mX7N6F70iQcyCwGXK +X97Mv62ZfGh0YNdcIR80IqhvnDjVahqpvfLC4SOTxRNTJdlqTLVyplvVy821Mn2iUi3gwj5ULQGG +LVS/9D6oCdEKNrjUPVqVCrEzQB2sWOpGn6KLpVixYhGq09poQA6rAbxwcZTzSrPxRjkebg6tW3VN +f+/6WKSfCdOw79YNSy1qjJfBa3DP1vBoJhhS6GP2mka0/ZZVR0Ybh8PaHoNGZQUS7i7YKYMKxkV+ +rjwVyVdZCjZXKbYipWiqNrreG17mJXp0oI029sANutrBpLl8wgxlltGBKAqa9gKQIk1fAaD15S3W +LeLmLhpfqAAwWwNlyNJmWmttbj8EUjpAxV0s1LY9ZwgBLgokbBUuBCni8Bgap4qDqaC7CcY1WHJA +4OZTkLIO1cRtBxTVvaBa68qQU8gkeepxkNk5Z3ZIKbPbWNbziopxMlNErTPJSPZ63ErHpkce2ILC +eBpCegcmRcXld5xbQ8QSVAz5aLt4tvxKVLIuNQDOLYN28WmBiGUx+u00SzFSnQTdpcmiA3tWQLK3 +Tgm32Co12dw21HNpJs4W46WwJIElCby2EtCvFYWHnSqFYlrwtWXg/Gs7A0ohuDAlHhkKync1ahf2 +tvaUw0dqkWwkUk8lG4Vy6+BEdv2ygVK+Pleox5L4hpViYsCwmAtp72kNa5UxWGlBTEwExYaWdAqU +9Sq1EMudHPDIquNscPzh2T5OdDTSdGoX3LaCeBCMhxv9xfl0YS42Px2aPlHKZAY3rFiWTHOiSD0S +aQpHUe0M2LJnVsDCiXVccR4A/3WCnaTU4sgZh3MCDVmmQZ19p/LYW6+ys6JWDWqVZjhe8ntnmvjm +9QWiIyu84eWyTYVwBoeCHeljoQXWHgH8YMgXw1SNZY0PZjQp1i6KYKnjYRw4YffnqQCTSESF1V6h +JnFiYtNukW6JqsqASsjRNRwNA9Q6wz8HKryBYpJgBbnCEQcZuKtv13bb0iM724ZkrULr7kDQLFSX +U5ToC0EHpKR7VBSim0HOnLpIOSgStxyiZ8uwefTtYKUUV5X6y9A9qAtlt/9VfDr+kaFiIkJMyfjQ +T0mSYLbS+G+wpwyAMSkQVxkThfurPpFisMrYO0JbGCQZeHCiszzcFTETsnKqGl3SXr4RgnX1Gtny +zrjfG/OXBoEXinMpviSBV18CpiCAVexUEOX0H/SrX/trVUMoHlkTaazItIJKMNNozja8bF94rpIt +7shjdcajoSo7V0qASsRLpYFVHRWJnSc9FYTQj5inQCYBsymSxnBh8Y92bbKquCceAQA5r9RtqABi +kSKfJEefB+mh+CovGK8UM5VsIoKHv6CYjM4lUycaQb5cyUbCI8ifFbwYsQ0QG/Fjd0o5gtHmfsms +U7zcUzVmqixR+UbCPAVIWHxEIdwxgrp1ViDl8seyxX3NxExvSpp9cMwbXqHmAPnOBlUDzMQxFS1d +DLe0Qgzb6lwUNX/1FqDfbdRX7qXQ2+j9jkkEs8am2ksMUpbd/piuB3uwBYEoYM/dFs7ZujCdxmx9 +DoiTAmUHgWRWq6mFEgtstXZPxdBCmSlucAvPZKY8X8aF/vCYHFlZpSy6Y+TWpoF5lJIfxAVxyt8N +1M51t3ZYgnPhkyG9I05mFQ81yaaVazaXLSKu9gXkWDzg/GPAG2+LiJjcaAXB1dLedUMpqrYKqFQB +aTDswbfJWfjq0mGGu9YNcpIhWUX4qDUWsb+OH5inCdqWXatM53ctH7jK3Vz6XpLAkgReKwnoMGr0 +iBZ9Aq2vVa2LWc/LYTsciwzFvKF29WGBV6Vx1O+9v+bNNOoclewVmUDFgGMcuKYVTFqIhAnI0Gid +pctS1mFZjlJoLAb22QBaC0cjiaEerNRoox6JhnvjkZFIqC8WGfTjo+Em2/GjmcEgG5riBMgwW3lC +yXIlM5+dYYEutgnu7YWiqEEbxZWe5HHgTVGJ0vnMl9ruUvkybmGcUjmginmKg6gqZ6rjAn82Wzpc +qBzFdT4jivGk1z8mz4JxTBS2XWJDo2fdkl1Ra2thYYOtdlbdNNnmeqXQuW+rrtyrgLcKAb7boELM +KXMjIq3eQTUrJs67KEVOycpZimChYbakZiBMQZlTHUQgcsalimNQ2gJg3bKKKAtBsFO4bkPTPCah +kQ22Y3OTDfueb9rLJY5AaJouHf+WWRgl1iUW1z+gLjIQ71YEQcJpvwaKGEs0kHQyQ0RfDgVdo6wV +rqCmme0uME9FvDBKt4EB+OEWdNqD4UbZsWSZjD6Lxq33oFrcszOkd/J0DPDNpWSInLudkg571Fgo +n8zGD/Wn14rsUliSwJIEXhMJ6OcpfRXysYL4tX9fhy64diMv1hxGXP1mvadWGdm86a5GMF+qTJfq +7PasppLgKGtt8Zqvs1VRi6yerZcZXI0Mjo7E/B5GFsN4OIqmcePvBT1es0eRBHteouFIAl0H8spz +Lyocm1W+BfsZo0UN1+oVNpjm8/709FS5UMz09ICabDxlPxBnqKAneQqNZr0pVw3ArBmmDO9yW4eW +sSkIcG1V8Zdfz+E3P1cFSoscFsCUJyO9PUNtNMXoEfaYVUql0rz2QUFLL9tOIeYXSe/ipV4F8pua +JjeXGuoEBA0VyKmJWLO3ZIBCzeVUVLhFQYGo1aUXqQPPiE53QRHeM8tGfhAFzCOzFhwxPwo15TBS +hgrOEsXs4y7woLogaAt6XVm+ucWotdpAMGQikeocCDE1Dp8UhKwMXCveTunwplIUB035tjwarzYY +cyvRaBTyYX+WWkRekw/529xaparCiGvwn3EFs5IdWY1t0EBrKQS4KzomNxolcSFVo6yKGLs2WYkg +bKiomKFRfPORhC1dlyZJBIYMxZiRFTs23UtXAyEgn+n87kSsPxHtV6alsCSBJQm8+hJgKJHfo6DF +Yvb7fvVrffVqAE1doAoi3W8XUVvPCnuOPJYrTG1ctmXThkurVY4RLdZbBVzsNlqlRqPK4aLYhgyN +z1RPHJo5mpsrrR3cOj42XsJbhOGBFCADx2gxVCfEw03mpxFos8nue1YacQ9Nx6Gq/eVSgeoTIGqi +lEjG5+dnJqdPJtNJszvZLFMDOBngtbFd/CoGHGuKyyRDWzwhcSPEWG+5Ml+qTtaDyXJ9qlQvU+Xw +qDAy1c9Zp1pNIzAw/BNA2l5P12jBhnSwEtHOLVuDA+6CW+hftYIMpJs6ZvCQSxLdYCaX1jRRBlfs +j9Q3wTWcqF1ZCvXYhTOOhXyd4WJBEaBrpiSWK2jhiukVZIrUKJMHWAJytHDMgJNsyBZmiEDNdQJI +gX4i7lf0gE4V5y63BP8AqnqLcgwJpkKKD7VAR80kDjNckMMERUQV6baSIUIeAA9ukQ914dyDvCpF +IYrbN39E0+ggzP+PvTeLteu6zjX3Xnvt9vSH5xz2FCVKlmM5lvsmjn1TjgM4qALkqhcDMVLIo5+r +3gv1UvXil3ovBAEuECCpAKkXV24AJ76xHcdxbmzr2pItyWpIimLP0+6z+6a+/x9rL21SFC2ZpJzr +rMnNdeaazZhjjrnW+OeY3YJzlUiIcRTGqFpWLoGuMmn5AbdK7BKpOBLGSW6ApVd848VP9iBCHvHm +smBGY8ueBSefwl01ydatRkbKUvB0tNd5ubHycVEvXCGBQgIPXwJ65fXeTjhwJvTJwy/zgZYQwBkk +MziVhkPNZe7epXHe7c3dlzrd4X/5yV8dP36qUmPpUS+dpGM2row4ULeWsrrWSvDIkebefr/XeePW +9uXTZ461ylWmMiGO2PwN6NnoqoJ07BEY6B0v0sFs1GlUK8tLq4P+zRoHONXqzfrCjYPrly+/sbWl +xZmjARt8WNDL7heWHUmZc4oFCMpMLSoVX2/Y7vZudPvXDgc3p9okO2Znf5NvK66V1jdKVbbHaBWV +lDLLhIUBWEge8kU1E4jhQi0YF4UbQkAsnNTuTB0DwJw5AJDwCyUODkGEWpFWdh6jyqx7wm/tT0Yp +fYJJgV/FKIQfUfEkKRBnGECICrfSd6jpGHsgDhci4EN6KU8wZugCdWRtGwJF3MZZQBRscAAGBZGL +zMTip0ZkwbwOJwbCpnS1yWj+svSSiJ4U3cIDo9/gMVkgCBEZx65L9A8IIVkM/gedsGjJDXsgqIQ2 +s+O5JQ0h5BURpEr/QBXIagooEsJPwkQsrmYIFoLBP6vb4BC5qRIY6Ez2myzpJckKH1IV0gdxEfSE +BYYsfmoNtcxaLfd4slgwoZoWrpBAIYGHLwG99fSb48/DL+6BlQBm5nZn4Cek8cQ1Q1T/uSMkz0X4 +le2fPvbY4vkLhy9f+Ol/+fF/+p1P//e1KgOwZcxCuhkajo1pOj7KUm+eOnWS8+f50uiQ8dvmYjqS +nmK01wYDw7dGGzQnqlNTlVK20qPcSUGXV1bW+EJpiUlVTpOq8V3XypXX3zh18tTC4lKfBbv6ejZu +wIgvVgun3uNlJncw3O4MLu91rg84raCCvVtqLZZqi6XF1dLSig7pxaHBtY8Wi9PYiTZH5woybfEI +tDwrTEoCqRAjq8wck5gTLeTMePAKKfiXjkbjsyaWZLb8SENGHPWRSOSV7pbjhlyh6x2FfkenR7li +iVjbgm4cGX8qyyiLzIglDYUqlyENnIAmUQI2taeBMyDZGYUu4m3SY52zAYY0BOrqtpNPw7b6FBo9 +HxGnOgoVYKsxTJYLpYfTQqSZEwNKlV2jshGocCIizgkgDk0CowoUBCccKkIVCFTCkEAmMt16UbcS +iGeuNc3NC4NpdxrLYAyyBq4rOyHuaoiGOxD85YBiWpyRiRicEHsGVGgiOspN63QC6hsLHyoA1Q1V +XAoJvBcSyHQDb91/09OpOYIiMx01hAGjM4ayKx5wlBBiueaYyk6+5tLNfq+KbVdNB9/9wf977Ojp +c48+3R8cigQqmZFcLJSEZVzSshsbm5xS9PqFi7du7px7fCMx/imlPgLHQQxMgKL0pPewTIw3tiyI +q5RZsZtWU+Bzb28H9csBSbV6fe9g++KFC2fOPDLQXKoQfACksp9m3O0Mr3V6V3vj/fGkw6HCgGKd +L8K1SovrQtN6K4MQ5kSll9HdgAl0XbYQjjCxLKcVsIAHuhvQJRBd78QyaAxp2GfApDDMp0AIm42j +gKI8EppAggQ4KHCL9pc4CTF8ZtU1GwAMsUJHsJkMcGUVr6stMyFQeIAHA4/YNiaREfoECkUUqooo +vetCbDjHiNsaS7w0AU1bcwByn1VmNHujoTVeWpylRndegzp+wZ43C8E7NClFTjdZcfJGMli3oJTA +TPI3YwCaxjlldeJc1KAgvEEkaDqrpKRAUsI/eYN7ElFNizFWWhEFbw3PI5CE2rHJB4ilFRAF2YMq +UQhEFQG8U4GxDs7kcXNNuaowdiDr7I70SOtpxkd0X7hCAoUE3hsJ8Lbq/de33qSD3ptCH2ApKFFc +EAy/MM6AKrSb+TH+IpaUeKKmncGtV1+73u0w0FpmxLXbP/zO9/6fxebRldUVNDWmJmcjYFQynwpF +9q5U69Xjx47zYYDLVy+fPfcYh9onYyEM5fNPZGWlheKXbpPlqntW7rJal9VGpVaTr4uz2hiyfPOy +wvnD58+/ttBarjda7C7t9Q8Ou1cH45vd/g4LkMFWRl8ZAwRBV5ZLzVVtjMGyVG0DJKiLSnSI7TCi +0KpaFOMokklr4wcarbLJGgfuyBJlpVKoeyOlmIUW6X2gJNpcg4deoaPxX2gKIVWc0A445IExJ0Sp +ti4aTwY83BqWhAdGRBIIs6Ev5oxnNrnEHrewaoQjVshkFJFxpjIEtPglZ2OYwMm7ZZCPjn6anqgm +i4PJrXLtlpZJM0HtLCTGR0bhtCVG74GCJCJuGc7FmSbSkIGodpSj0OhPqJok4Xgmr5bKOFQKj7ua +vvh3LrJTZRUUDFNTPw3qhbhFGJiN4oJ/1dEdFNmjlgnxrq66OGyY5nAS+GSooHcofCU9PxKTCNuU +p4JuFowFkRiBUL3YFc3bnLAA/QPVZN0di2DQXBaXQgKFBB6qBPy2ceEtnGmUh1reAyUuGLMBKkCb +4ei8x8EyWHHAan4lFy6td9aOjA/bUmTMTjFfeP6NV/7Tt/7v/+53/uetra1yOmSVEUJhoRE7V9T5 +GDF5ubm5eeyNS+evX7ty8vQZlueSBFJUi3VJ0ola/GNHkM4NlCYkAoBlNBcdW63VB2yLQVNOE8aH +99uXL1yqrK6t9Afbe4dXJ6VObWE8AM9rpZVWqekxXnbFhC2CxmTiU00WqElRM3mqbGtkjdCSxval +MN4rUTnCCeULooAcAlrbMYE0pA9DNrJL+4NqXj5TqSt72EnYPZm9i/FKEfyoGAV5/Q4e4Z9oKxAX +dMiboQhRYV0Z3gjH2BIRwp2eq6DOo82ktMRMigYwysq8ww9uuabyMOo+Xa0nWzG2WUuOTEoLo8ol +hu1ZIsYst3gxk+ouqB/jusCzkQxq1I5KgVJCtZkA+UsCScnzu+KEBLFcC2kY+GEb+BQPJKMIsphP +MkomFg5pzLLqCLXIF6U4SKIjRVRfWSwKJTApeMNPu7PVWJuMu+XJMN3b5QtLU57V5oKeWPpb6rjA +xqxEGk7+cmmt+f5WVVP12cM5X3AUX1wLCRQSeBgS0CuH6p9o3W82KvUwirknzddee41vzvC9z3um +ulck2En0PILy5XN2nfB98jfeeOOpp56idq+++iqfitvY2ABccYLeSrK0XjoyLG3fmPK1tT6f+q5O +X730XO8//1+fePqZ1ZWjSwuri8uLJEPlUQKrkSppcuz4sVs3r732yqtbW8cZIJa+nDkSTL3dlJMO +VQYKViYTSMayXpYfaZcOZAa9EV8I7w1uTOs3aq3BdveFtnS2igBE0ZWrmyUYQ5kCA6hISKCpUdD4 +VU9SqrIqlYvC8VgpBy+KjQToZRtDsCk+DHukFjDPtHBAoGgRGLl0owQCVJdLOEcp5SlVaYiZSLAU +uCI+w9oLVDDekBcHKdR90BSuG20U5QFn/kIn0uCnaiJoUIGnKJdA4F/dApYEy2iu1SbH00Rf8sld +UmqkkzOT8sVplS/+xfBvBqUUmNEx7JGFEFzODH7qVWVNmtrOpbuOISd1CEjBiKv7HCSgOuEkSYM9 +9EkGEeqFcIT9NohpAmx6OUggI6fnjjDRhKDriD+yUFPSUwQJcdSXEE7cajaY4E863TEPic6XoBvs +aW/KRVaUi4fvQ/B4rDQeb6YnyMszSD/SZIpLIYFCAu+VBADTBOU90zIPqtibN2+++OKLfMoU9ALS +QM0nn3wSSHsr/R/96EcnT558t5iqb57v76+vr+dQSimck4seya9EURy3ROHhFn94FELFObZ+Y7q8 +Xt65URocNlhlyiTrrYPLf/+DP33fic8fO3r2qad+V+reI7eTira4rK6uUOjF8xdev3jhiSeeBCcp +BA2IC2tE+19AUQ3Soex0GC8fZu+zu7Xb2d87aLcPhuObO90XBpU2pccYLIZIg7G+VmlhTYc2SC+D +vXDq2UoY0CIj+CcE9W2wyTQytUNnWm1yYdRXWjv0tWpsDODW65KCiDS4RyUsEqUBV6TN54xXSneA +iIu8d16ymQQnVe6jAWXGef8lFaX64gdQCX4QrZfbhD4HfjKMjKFLiUWkgJRAJsESbMwWExEreRqY +SQNlSRib0tLAOEtL67XpUfpEyna7Y9C0Xn4kqV0ajw8bnAip77ErBWzDHMWqrABsxm89cMrqJAKF +TLQfRq6Zp1QlVlo7AmcjtOommT2RNQs5gsInTrUjPYM/LMaO2VCFihxRlOJEbrVIPyuFWAW4shIJ +//UEM/WAJT29fqPPI8UKNVmonvPOeFOqLGO9ntTKZ1vpafXo1Pqa6VdxQSl8xbWQQCGBhyoBQ551 +tl/MB1IWgPr888/v7Ozk1A75MvhohMl4V1jNk71zz/nz53/wgx989atfDeCMcV38eAJTMVXxE4IH +zRJRhFAEtyidhdqxZFIrdfvVanllbdpofmg4aV/ZfZ4vuw0Hg5+c/7tXb7RutZ8798hnjx4526gv +cYoD01tQP7J57PIbV1558dXjx84wpmr9iX0qLQagUk1BKYt3dawP/6Y91hrt7928+cr1nRcm5d3D +8u603muxwKShr9+wr3TZm/KBTOwPriANilBYztUYFqiJwtXPipgQuJGz8ZqrV7gAOwOl0PWoVoY3 +uWYEzas0e6hvqJk+QALqAFIa2wSA+cIo6OQ9lEAmG3WwnOJcXNXRZAX8c34KEMpq5NvFUaJ5Ijss +UReYVaH2QEEeT69GocplK1BRIIThR2Yfw+DV2Spl9TNq9emJSsnLnV37t140wzo51Wq+wffYoQkp +qqbGQVA+hglWRd89g0B9Cc1AGTwHexLzLJd4Q1bULsalzWGIglqqW0NqS1WCpqhEyAcdwkUnF7hu +dOtQczXzK9yGOLUO0xau+Ogvgup29YVdcumBsYWKnCVAyVTtKxlq61SlOj3XTI9Ft5KHHAdVnvzc +o1IKV0igkMDDl0DAz4Mph1f6DkANukAs4Z/73OcC2N5aWL/f/+u//usvfOELzz777JUrV06fPv35 +z38+PmP+k5/85IUXXmi32wT+wR/8AZj9/e9/n7ON/vIv/xIb97Of/exPf/pTRnf39vb4FjrIvby8 +HJolMJWy8EjpVKtMZl66dAkDGvBLmp9Mmt9Fi9VGT1TGG0lp/fTysZ3+c+3etUe2PtIZ7jz38j+/ +dP6HR9fPMZ7G6YPVtLp19NjRrRNYq8+/8N3Jd9sf+fB/eP31l3d3b66vbz7xvg+xoBc9xvwre035 +GPj27qWd3Qu7e5e225f2D29VqpyYr/MWjp7SMC9YhcGBosSBo4AHWlU6NoxU614pZYb4COS/DUFu +wq+UAajoVut/RaFhyYLCBcxsJBEJuKJ5Uf1M4wIPKGsCVXoYnbNFtpQtOHEsRiGJ2NHBpCzUMFLz +3SZkD5QSKMIDfOY4Wsm2V1IFfgBqnL4Ee9LuJKMsG454cKShxEAy4W7Ygllq9yo8w9pqMiOMdb1a +Kx0FIpXzns6wenKQXJhMetSaKscPVpG/JGPYgxN6PvCAgwd+ug1Rc+vwiFI9bcvq1gkEww5R9kgJ +Trv3QAJ+mN2BeUrv4vDglNY10Ixydu/QwH6HhUBI2u9rzwytgMnL3CqGNfwLUN1LgAGEpm4Be2cr +aaP0eK28zmPP+xVXoJTHPvertKitSykuhQQKCTx4Cegdo1fMcBrvW4wA3nchjMrOW6jz9AgntsGK +xrs5Xn5A8Vvf+tZHP/rRj33sY9/4xjcwRp944omDgwNM0q985SsLCwvYu2Rl9JUEP/7xj5955plA +aKI+85nPLC4ufu973/vFL37xyU9+EoUSUeAo1cSPw2allKWlpePHj+N56RejRv3YoHI9WX5tsrMx +mh52yy+gxuvptFppNiud1jKYUllMH7+2+4v9/itrrZO9/gd/9so/HPRe35scnJ5+4MfP/ueNrSMn +z2xdunBl8nKvtZAedrbb7euHvf3d/Z2D7vXe4BDdiuIDOwE2bS1dljoGlmLQlShOvyMEvYmfxoiF +u1QzoBQNLHXMDQoU5Y7zNVQqDUh6tLlijWT4A+3i3DtumWYTCkLHGTFrMH8pS0aq7UjtyWG5r+GT +ra7gEHDLBwPI0myKTzR7IAeQAA0VARYGIBkXAykDQaEMmiplDAvHbSQzaAWOkgyXcxVAouqYSXgg +hFsghK0y1elRPligDO/MAauL1TPj6SvDgT6XF6WoiOivAJl64MUkgSoIso7V1Y6i5WaxYsorgBQ+ +lxIvckC8SmnOI6NqYVKSkmsKgcgLmpIegYO75iDD9ehnaACA9FN9Pp2xAfws8Y0lZmoy/2gDuFD/ +wEVUklp9co7lATzS4tku0BQvj32AaxZR/CkkUEjg4UlAg0L0ZROfTRgv6H0XhiF4DxrEvh2mRq5P +fepTjz32GH5GiVlkBKaiFFAWr7zyym//9m9jgBJFSI1xUmn8pqpQKpFFp8tPJszLPvfcc5ikgalo +lsBUPGGnkpc0pMRObTVZgnRuvHj91j7fY5uwwjdJB40aa4tKZU6u0fRVuTU9Df1h7cVqMt2fnq8O +jlST1cPRs4srYuDy/r9e3L82HlW3Fj5x6/zLNzrPQZY1p4AK+VlLzPwocmUclTOE8dQZtrQql/2k +isw0o5UjJikribQGhwFb7F1sHc5R8ll00uSGMRKGVs+GhSFCcQ5U+MxkJBYjGB1LEbKAqcJQC14o +ldMAyAJloqBGONzWgS5/QZZCUeKYtih0BjCh2eOrO5jyrewcJZAAbAi978dHAEBBhMAhNEnMLxwI +oTSuXQTGU6Zkb+r/DNUgG4EUigfMYHa0Wl6rTbe0tendumltMX1kZ3Q+qaikGLbFF8gnriw0/lCc +GttA5ZssKhLAKlUTY66m8M4ReXa6XTExTEq1O7CNfKDJ/+iyYsKKAxEhTEuQ3NvwjYhLmIQjPZuw +GKZ0Yril4TR/zKJrpn492C46Jqu/dNSYVS7Xy4Oz5aTFA89TzXOOJ/zxFuBX4mIEGCkUrpDAQ5aA +33TpFFlvuAdSHNgWdHiNc4LxYnObx+ZRd3hWV7Mjv9EIEYUN+qUvfek73/kOA7y/+7u/G4gbUVEE +xC9cuIDZShWiIOxREkCBBPN2Kn4wlbFfRo/x81WX5eYjZx99Yfzqzd6BBAEKdO/f2wAAIABJREFU +SvWDOhglNgUqoybfhqs3pynGGYOZ092FylaTL5K6lvWFg16bHayA8CjhnKN0xK5Bo6X2F8bMKGLV +Il6rWlSkxOPd+owBSrN7LpMr4VK4KFZsSibwuLEyJUQGjXWoEsx+odx1SwHGszBYtTLWO2dUugdy +MTRBsswsBiZtzqKRAU7SAKKMA9P4jAxr0tRAG4fhUSh7jShdK6fcmPgBJzjEwSSOYCjrD5DPvaWk +WKpjExv6QlClVYIATuXlZ7bxwAyyhQYGHP5o+bRSa5RPpOW7z57OP12m/eYlf9jK0xpT5km1B4OI +Quy51YAuPezmSVy4amImuLKoww9e4iRhr63FT8ZIr0zOSEoqKOKQCvS1hLMQCwEKmdgDbqHn6Cg5 +aJIXsWstmNdPMZir2VMjroxXzwHzjVUKhQGyQzNt8BXyNRY8U+WoNa8Akolb/Dzt+CPkHhIz78Wl +kEAhgfuVQLzRvHS8pFYD90swy1+3ERkvdlwjIsJ/hUIeeeSRP/qjP8JO/eY3v8lU6B0UWABM+Mc/ +/vEvf/nLTKaiO1AlwGqOqRi1BHKL5/Lly5i/Tz/99Ac+8AFWI6OyB7sfX2hqeyn6a3Vpyhgs6lW3 +qUZry5VeWlpEQPjBqkZleVLuEdXw957BIWZGW0uCAWK1GaYhiOLUQJbLMgG2wHENLS0+Ij1mH3qT +vChNQA6CJAj8g37YKISgYYEuAZUdXOGAKI3ookkZrQXVrFJBRAKhSUPqantIZzWAcxxuZzNXmd22 +2MrgPQVBJDCM7BREuRSBbUS58Oam0wmCgBzWEh/0VnYOke+KEmnIi0IXGMOJuwIBDwIeEsBnWNjm +MOBcIbbMSEMCrkpscw06wETAD4Y1YqQWRDXS9YXKuTsAlUbMnQp7G0caSHb7+zd2L+zt9viMvOpo +Yx0p0SGgFqqUgZAr/mAePrilsqqR/XiU2BPSUJU/2KV2+Y+elutFXrWms6vndHtKmI0GkmfWb1Bx +bi/k0O2U+DQDjoEEWoqG0BPiJUikUUpFqqFxhNBpo4tYnmSAGh1KXjc8uV9JYcQu/MW1kEAhgYcn +AV41vfj0vHlf0bYPxAFmHI3wVvgkhPCwIN9VQSxN2t3dBRHPnTuHugxLl0Fg5lZjr06XlZGl0srK +CquWgEymbEmMs25FMcnhJwTblLFZRowBVxKzKgrtUx99erH0e0n9sDxaGfO1NtSi+UM/Mgo6bVxm +cq6ZnkZX1pKlevnosHIJAwLTDYeHbTDovrAksEelDaXspAR15ioQC0GPxEKBZAtLfFBFmlcYaQuP +b7BI11sJ44EmRdMcAB7jrhgu+KEQWlUwDDaDEDa8CBRAGPKlnWlJH24QGCYejNxCFAgGEJIBZ1zk +L6WTWMaxbSk8rDIdeeeMbKZKqV4rAUueyBYRPTD8NwU9Px7PJFRoSo38mTnCwyl2ZsNlQVLx8nIF +yzPMwE+nRIiecNrUUvpYIzlBpfMseKI1IwT/PVxvcHBj/9Wd9sXhuAtZqqMOAcIBsCEZz7l5wIvE +2IEMkyqCVmCXKquvjbICWpI5JfWCFOHcKoz/9lv6CoQOiKs+SrQUFAy6wbCaz+VmVxdEIA40hUN9 +6MiDvTxXPFHZMwBXBl1y8QzAHjzgoMQjxEFe0xHnfNXmITP3hye/VTaxLRf+4lpIoJDAQ5IApz1o +PnWmbO63lHq9jlmp/aN7e2zNDHIA6vLKCuHEvtsCANS/+7u/Aw7J+IlPfIIVRniOHTt25syZv/iL +v8Dc/PSnPw3lv/qrv4I4a5cY2v32t7/9e7/3e6F2AVTMVvxcIfLoo4/+y7/8yz/90z9hpELk4sWL +eJaXP3ts40dXLg4G5/+gdOTZev06hx6huUDHwbg9XfnX5v6HG6WnStP6MD0/rL4MKyhfHExpdQ9J +gR8OvvHRNjGCynnBGIvozSq60moaCBHUWdUKNSulblv6FPsVh0qlDYAxoljkiY5m2WfMTUsjC0MF +MgI/F5gbQsrLkpZBtmyVxBjKsdOGXNCBMroeytzigGQQglsCqSBjxXCCZjdWlLoHsllbyxoHhqYA +dVDq9zJ802PCD2YMzAJRT3ySHU+URQJBlCFcSakv47oGLWV0djxCFzoQkYw+gcyyVq28US0t52tu +lV0pg/E7/Y7MAgMqxpPBAeckD3bFXuAQuMVGoJ7Yo7JUHAefSqAYsceEgf56dJeo4F9hRPsKz9QU +Y1Tpbabrb6AmqQzAKtAhE3dHSIAjhLyCw7BxTVIR2LXaDivGEJ2A3N0sGvc22zTKNwCLmr+Nw5I7 +vNWUj9yPGqwlm1YRMCJCAnQQ6TjiCUeWmbcY/pXUC1dI4KFLgFdd73u5/PRX//fOjde/+x//jwdS +ZCz95WhcViTxVkMfu5BdLrhfAVODJUxS7EtIzXOIhQpMgpqUgt0ZY7yUzm0EahTMk6xYtziMVK5w +hY0LqfBAMMI7kxd2Bt/qjrZBBy0SQZOyIWVQrjKZCmh2GpNKj8N72aia1KmUzD5ULSYFIARmAGNx +np/QD13MKbJ9jQaLDrjFYF1T5gh6EzUK8hEFBVk23s6IegTIw0CEWpiqYHDoeoqTurc5CwUIhqIP +zY+fkV5yoZ3JOMMCG5HG1B4Ld1mItCDTkCwUiukpA5ostpaAf5yAeWhDrVRqH7hDUBf6wjALgKvX +/qcvPsPQuuEf4DROCCypoG1c4ZARCw7gkFtixRiBtoOJdRKF8B8KnIMPvqSVVqOyUa8sBwVRmbm8 +xXMPMbk/9wAonf6tg/41Ha/sXgsFyeO2QIywQX2BVQLhTbWIZLSxkoofJbbTHSzyCzube99FOMai +shASHQX7oRC3cVVKJcmcqOGiES0iuinInHANPHjEmEeC5uM5USvzOJEe+u6QBas0VoM3gGVl/SSt +8PWkSVpamnQfEWF3GeNK3xFkza94whGbOzFTuEIChQRul8DXv/71r33ta7eHvbu7j/+P/2tz/RS6 +AEtOr9u7y/32qcE54BP7D6yKnjIhLPfl+vaZfkkM1N6aApSNQJiP5cQUB7ISiAc0RZsQBY6iZSKQ +K+FkBHqJJTFMqvLlcn36xFp5cXPj21f2XmNjZq/PUBvb+3wGAoqvwZdPSpyETpWqrINl2Q52ho9f +hzZqEY2MssZhagCowC2BaHOOSUJ7gqZMvtYWBMCoUWwOBiQZwtX32myvIH3sy2lViSGFhUp2NLVQ +NgaEgVKgHXTEAUjoX7JYrcsqtWilhEH60PIEop1BXxAdrhiFjmFew6pmDYNOqdThlHZ9nCcbHJ50 +5eEWFY+1ChpRHPyIHRuj5IsSeGQChzIPdQis8qQpRbBLB4yBDhkiC3+QD35wAg/ttljdYFCdnAFU +qp0dLTLzCjPmA9VasxDCB6N2u3+5P9Q+q7xS+MWVC/KYgnoG9CQw0xGHctt61ipcj8DzpAiNTYJI +eKaNxq6O6Jh/PESFjasmEHVVOftF6aYRnCi9Y3VxoeTlAYATnKDU8wIaWiDWUCqypIYBpISNO+uL +NGoJZzp0u9P2Hp83GLcW2UBTmg7e9aiPSBeukEAhgYcjAd5+fzybdah8OPvBlYG+A6twD47kL6c0 +r2QBVG5jHAwExQ9wgqCE5EAbcMsV0nnetLw13n1mtfa9du2HYPJ4mNRSvumsYbpabYrim/bKY0bX +bNIxLspi4G5PujWUZoNNhyjukXbOaIvFUFgFYjHJyqlywCEZZeUAvWEd8r0Rb1MBfjptKVlQVirb +yhSlLyC0HcwI7aRncLJO15gz2taf4CY9lUAvA6UCWmxcYwAITBSgThT7c1h2xLwz6ELhmK1Mo5IA +3a6VvYzxMgjMrZcKg9DqFnggGl6AZOjwdRQ6NRCPD6DiITAz+CjOdipgQAh1RECZ35Om3IJbhOiH +DEkhC7XVAk3f5mNkeYvc4eE2XDwQENzvXj4cYJ66DVwubUHXJwM8sAo4VPOodLVIV5PcwCpcqJOC +qPUIqDdCKvFmp94DXSWPis+Hq6UpxRCYgTEh0X3xhCsypCDyRm/Dxah0JENbIGocbUcLAqhYpaTk +RxuRCxcMkEDlIFh3mwJ6+fzuwZ7S6BFqc+xlqZEswPdMJHf+VdLCFRIoJPAeSoDXFk1DgTr9Jzck +3kMGHnxR6JUAVEiHB9QER3M7dR5WcyV0Gx/TSq3/+cXy8ebaP93cuTniGycANBOQLDeuTGpVjiFk +V6B0OBONqEIZrMSiSUE1m6eIsnuYWWPAMBqTkWR0KIO9TJECouTSwlrkzoKgrkxY7FeSYcFgC6Kv +pX8xT409MoKBT4pgIylzota/QOzUg8YoYhJIL4OCgYgGLRQ6Ghw6hMMq83YANoFDq3UIC3VY7gvB +qQalAdspk442TzHOyAL8kAAusVDBXxnEBldo+pnJgETgZKsLT5hfyjXDBpmqgmXDzGyJTT1d4DMy +tfTun/akUfLmyP15S0VI3DJ7utu50BsKZ5TJUKcnGZg0joJJsuBNDykpjWGV5ogTNhRibtXDAOD4 +wB6bhfC5HeOUJRF0xqxSfmMUaMpRLkTwIDTKjVKIFRsmTkbIgrWQhjKtDzO6MhJgbEZi+iEnC4rZ +BPKSmCXcUMMepUt349qEbg3ZCSGWvhoEK41x3b2febGE3zIJOekat/kVT+EKCRQSeAgS0LuGxkul +ZFEJvxEu1yl5bYDVwNc3dcxs/ok0efrcQ2A6Plc5OLre+P7u8GeM+LJwuDfRZ1XRs4KrGMBkYBYU +ZOWLVSd+/mJS6MuXo0q7BzbJ0BGwMURsZa1D9kAvTElmxZi8RJM6AUfskjEMexKDf6hXjjQ63JO2 +DU3KFWUKbvGjIBS9PqcaiIvWZs2Rt3iiaklAoaA4Zi4egBOCYCQzoxhGLIcBO9laI8ygFGqLjj4U +tBNFdoAfJQyQY1gzQI3NjX+gdIrFn8Fk8BN7Z0EUEN2opnR21uRZYABtWmm0qpvVBDT1kzdLmf/N +m+AOD7d3uMHoYKfz2njSp0aUy7MbxWWkjHzyu4dhSBFEhUOwIZNGQx8SQlwaL5+Z2qI2N+GqLMZC +rjOAdqUoMiBzRlYPhtmIgABU2h36OG7D3KSXg1+3GKM8AAZOTaMay9V3oUDjMQloJsY59reNoB6E +kORmJR4O30AsjeraHcLhNoZh8nARFW+znHFfXAsJFBJ4oBJAefCOATcMFkor/Ya5eQ2SK5fwhMah +vpFmPmUuhHJpsTH84srksenyD3qT7QkbFxg6FkQBqdJx/CS3rtbvLC6luwcjQIjRYL7o9qH3L9WT +xn998Wa3N9K4q6EIZYo5hNkHtnF6PgCGStXCJZarAEiYnp7ClGo2UJG+6hFaMAzAZhAYC4YAEohz +Wz98+YS0mKQUgZoGR0mMRpa655xeTotl1rai4Wj86HTZxx6c7Hk5ksrlKZgolqrhj8FJGMOjQrFu +K6VD6PT4HIxX0FCw+mEeRL79oQnghAg8BEjgp3RDSK1Z2WhW194EBJF50803Qe7HkzuS5jjRGVzb +773OZ9nACPFPnJGJigilYMCMmVMX4UFUfBiISs1XExqb40lvOD7gDQC6qDsOUrkTZT0eSq9wl6I7 +hUr4+h9FRzIHRHZy8UN6tDUO+vp5LEFXODSmhrgisdoL5p2fIuiK8Xggw8OD0u62CkKMOBdu6cMe +/ZjJ+KB/gW8/LDVOVSvahB0uF1TckhGPaReXQgKFBB6iBDTlxOuWcPK70fUhFvXrJp0pm7k/cDSv +enIGSUIvI79tJo9NO6fW1p4/XPzX/fbhoFc+ulVvtzlhMWXYdu+wLxsO7ClNW0xJGmjRzz9/Zfep +R7dOb7XOX95HXaLPZKcymuePvcgMJSV2LcZKfAszZuDG2pCq0V2GgBloZfgXM9SH6UjnBuB5sFcA +jGolBBvIgI1BI7w0nunqMV6wjaI1CMzcJ23M6qexUByeO16IRDXFmA1cCGK9LS4J45lwRYdzYAXj +2zGHlwmE/gFm+8ykgzqVil+GDbBpQA0dbkBlqPdIIz1CFXOp3uHJNf4dnry58paC/EH/fLt3nUKp +GpXiKnCKR1k3+sWZGJQC8BCA07PuOeBKWl5qHF9srbOIrd1/na/78XU+GoJOCdRSxvbBaldKYwwW +KbFUGUcvhwW3jOjo1pQDF8NWVrk2ixmBiA4K1QdNkbbkkPUtMkAlcVRBdILJmXgwVek8QWH7lg6C +gKbIUqCTkUvV4T+8qU6l3vDWaHK42jrbrK8iqFxWufSUPtpDWQtXSKCQwMOSgHq60jr+ouZv/EsX +aiUUDRINT66A8MRqphA2sTFc7Gutv/uRSnp6bfF7NwevcS5Sq9nstAenjrYa++XdXa3E3W+PGbnF +JEWBMq4L3P7wZ9eZ6yIErQoyZQo6JiwZDwQOmadEI3pSllzcSmUDzBg3AQCgl88LRHEzqYaLvaSA +Li6AjdW5LGQFg7nFJMWaZEMO2XUuhDUvqpl1Tyh9luDKwGUO1VOzmFCgCGiKU7g1O0DK2Q5igIBK +aW9f48/CyJiMpFDP0WJsuRCrdfJKmBmFDHtcdiWt1JO1hdoGA8lKdDcXjUJM7gl/tM5brqWd7iu9 +wbbQCJgJazjAycgpuMnHn3PQiuHf7DZZapxs1FZcStKqHRsMzzMzQO5p4m04GnRNJhriJ0jB+g9N +suMhWHCtNpX0VN6s7i4F0UU4EtOTEGjqAd6AVdiOF40rSCmx25AVITv6W7W0fHAwZUUSrc8ToiyO +ioyqIPcOygcDRuPeduel5emJlYUz8J+7kGp+DU9WUvGnkEAhgYcmgZQXPntNH1oZv17C89oEfygd +POEPT37N0XSe5/JoY7rzPyyVf1EeP9+bXuoOp5V+urm2ADyurDRv7HQXm2mnN97bZw+rzSNGTdGb +LFBiGyJ605YQVqViAYNEe2xAXOxFzcIx/OidHix0IiW4KBUMjnpzJ0CIdUgWjK1RtzRmOBd1jBIH +sKGPycuKYtuaMAx4o+o1ZegQII9J3HqtAgzAXmyYYZaUokEHJoP7IDfFsQzKo8FMOhIFG7JuQX3Y +SLUqmOXNODAVhS4sEbLoym2oeOoY9SKYoyFb1dV6ul4pv+3ab6Qtina5Pzx5Q9BMuZ/kuwGoPKlU +X4VbJnAlVnQbnKi3oQCH+LEmimU+dHhWmqfq1aV8HKKS1Jdbp3YOLpAg5SMJNMKIvVh80Uh9FCxa +zaD727jRgqaqpomK076UKHR3D0ktC0s+iQm5EYXo5EGeRlC1YM55dDNyAdrDJAJ9nZvXppinyuLO +kypi6FXpIW3zIYFTXjiNA0/2Opd6w/2tlfc1G8tzcnvTO0td/C0kUEjgoUhAL5vUT5n51NBCD6WY +fztEQ7vAT3hylZ1DLJ6wVnNYJWWuglGY9emT5cP3TSfnG0s/75dfP+z1N4+0+v1xs1Zud/u1arVZ +q7D/sMOwrXfCDNG2tuSwPxjQxWCtN1C05cPuEIOGE+Y0Zssh/bdk+mDposrR/lLxLGBBpap1pDpR +ryAHaaTBPZYLgJGRpUMM/6K7mUklFyGyFLFrSRm2lL/1trxQvbXbI4pxXeAZ4CQxS3+ZKAV90fWE +M8u70FShRCkZ064GAFigW8BtyfOpxJJChjVdAat4OJEzBqQJg+JrjXSVrUwOvctFT93M5f7wcH2r +czPJQu0MbpKPzAgknlyKFmIhE3jwOG0WLi5lnZOSWpenyWLtSKu2CdjnLRssVCsLq4sndzuXBn0W +h5drVT8AdFaA1ekUiM1KpNyEf2UGhhUSI/AeIkYyiJR0iJFWoN54gFI1FvIxKVpEwjRXQRA/vFEK +YZBEnpzLeNie7m1PWdMr9DV/UAhHspiqiYhZsIrIkjrdYLR/eefZzZVzq4unc0lmJIo/hQQKCTxs +CdjYoHuejmPE8GGX92uln6uYgNLAUbbWcOJSHAoBmqJwY9cNIaSH3ztUsEP4vNaj5d7ZenKrV/mv +N/Z+Mej2J6OU05tubXebwKQP7A30wnZhQnRpoXFwOOkOBlBstSqbq43LN4DjEepYY4vl0vqK1glz +ykQcYqF1TGx7pXTrYkYU4/AEONIgMGgFnqG10fsgmbSyTjPAobgFvaxOYhDSm2EovTsq7V/qMdoM +xggaQRrMGnJ5ZRO5UOIgKyYsaciFMSonLS6ABxuGhnnCBJRGrwDUSAbe89M457S1VHvkPtEUmtFA +yD/37PVe7fZvBEvZ1RgGXqoPoWbSTx5u1W4OF/QmzdraQn0LuJzrGylB7mrpynJjuD+9Sm4OIBoO +NGNKLE+DKYmgwW86Guv8LBxyRjIIk/bFUX0kE4BKPIgoCxUQdZ+DxPygCIdkxy/HR5A4aDhRSRyF +PxpOrl/VTh7aKAfUvKby3M0FM4qJ6psyx4Vd330Rg/X4+lP0IYiMJ/9uBIqwQgKFBB6sBNS113m/ +fjkzBfJgS/i1U0OhBC7CSSiXQFOuwCcuB1T8AauhfN8Kq0EqasSa09Jkoz76/fXSRzvVn4/qrzaW +htev7nNg3GAwqtU4r7/U6481bzotLbRKv3V2bfugf9Dt7B30d3b70rBWsgGB4Nky30DvjbUmBczz +kiI0NZtQATkhlk1YjQ/75AcmUNGfQK+wZHb2AspaGpqJVc+JYqeCc1jGaH+pdfg1iHLVEhjfUhfD +h+ZxoSNwZf4VOkAFXS0AgEMPoN83RPFFAa8NlilmE5DdurKebIpxiONkWCvzIda7OUSXB9/hj0Yh +NjxccygNT3d4o927GpAZ6AItVdxIIzEaViOKwIgF2lr19cXGFht4ollzBt7qadQ2puUJ35Dn8EoJ +BOGqWu6+RH/CsOogiSIz3EmDkD08ThsJC22s6wqsIglYyX+elqah1UTI1kZtdHTYxbR90/PrxIp7 +pZkT2O38Ku4uIfPpEcL+4ZXxpHP8yIfq1cV5gd+es7grJFBI4EFKQNhhlai9NJmKepD0/63QQqcE +rM5r7RxTgdI4HJg0dyjfgFVyEZ4TCcTN61YprS0lvzOZfnzSubS+9MKoxChipTcYNxuVpVZj9wAT +dnTjRm9np7ey2GBDCRlRyujWA5b4WndjBfZ7Y1YVgUccLsEEJyOH0uxW2Tr0x1mAMWYnQTsWDGco +Yt0tYxd97RlZEJFctKZyAXseCka5UyIATBQAgIFLAqxbWUWYMU6Pn4cBuBUweJCZRJSF/So65iSq +DM9wQiCAzXEYjBjr2EV9Q5uzMHbhaHlxky8ARWKuyO3t/BHF9Q43j6mTKQc7nKeCVIGio+Lww0/O +1zdv3R2Bh8XmxlLz6DtB05y3ZpUvnyft/lWYgSwzuQPO+3CvQmW5EogXacc+YHV0PBRPY0loiGV2 +JTG39DzIRFbbuNlKMUhREVISp/Ve49L+Dudb0cPReIBqBxNur6yCYXabkPhyfXXH/4ypWQ2MxAp0 +Mq7dwd6Fa/9ycuNDi83NWaLibyGBQgIPUQKZKmPyTj51y3+TXdQWfQ0o5iYpHk4hBjKpOeE4PBxk +mAsiUDZyRRroRLI8DZ6kXEvGjy2XHx2Mtzvl55vLV7uDbfTemZNr/eFwMh7dvNm7yVCxV/Cyz3U8 +HINuMjoZMjV6dfketedBQVamOQWrzGgCaTEhh1WKjQiuoKk5fZfwUK/WrWLAZ+uEZkfhhrkDMGMJ +TTpCaApi345A1EtpZI9iB6PXVSvzgCkGzSBosIcI9jEYTEqNMONlvlCIo4yMNjNArXFpo3LwsLO3 +vd/eXWytLC2u1zliKiN3J7IiQ9JHi9xxDUDNYZVBFL4nZEEIuWHbWcVMuAxmgCJIltOl5pHVxROs +OKbhou3e2lhkvGsjNqobvAa9EdaqulD60jzoaIGAoxpO93NB09A1kbFu4KRc5EMySYkQqPtVUojh +TRyaiJg37sZUK58k4vBempKnAhlmQ+7OoqbBPs4B2HgpeDWdaHpoBuUIdPvMYpwRRqbT/sVrPzx2 +5P3rS2e5LVwhgUIC74EE0DkcVBD94feguF9bEfO6G5UdsBoWahzuzzXXvwGrZIFdAtHO4c+5z1Pm +IU5ZriZHVpLPT8eDRnJ1t/fzy29cXjuCRkwadTYBlweDIToUmDh1gu+/Dm9ud1G7h72xjDCQlU04 +/sQN62zRmAy6EgRooclR1lLEnpaDJ27RwqhUaVU7ARsRECFXrCrylhjoA4ScHUFCIAEUx8ly4j70 +OAaWAZtbwkMrM+BM0RjTgQEEhuLmCv8YyvyEAQEkIpllhCpdiJ29HZB1mc/ytTZq9RbThpEkmgD/ +fFvM+3MonUPWdGP58as7P6GAsOpCFEIv1xdqYpvdtK3VYxuP1fiKEEcjMeiei0aRd3F3bVDWKqeV +Wie5xKZVzsNi5Bz5U270GzRnHEt5wxK1yU7lghmuCEQ/O9hTG9m8Jko8OiUJ6LPxmT/sezWWkynH +LCOBJJbZSiPQAbLwVVmomTIXPPRywlrlJheF1jG500OgiMvgnly59bPeoH1s7f0xvTqjUfwtJFBI +4AFLALXjETut+8XlL+wDLube5IArvnjKd0wXFha2trZOnjx57/S/QmxoTyob6ht9jR9MVf2teeMa +lHMVn3+vBgVNVMAqsfP4Op9xnjHWEtXKZ7aaZzYa/W7/9cPRxen04trKpJIuMA48HI7Pv95eWqyt +LFYPDkc15izLFYZ/ZY+hBLnFvmSYkb0uXuriAV1hWGh2Zj1xMM6ULQ7Nif4VwFlxY04RlSlito+A +vhjEcXowKcNy4uB+ziaEIKCoNTLW7FbBskSTEguhEky96WB5mV2bOgJi/wDU0lmJMAaTpFFKle/n +Jlf3RDkQTNvb398/2F9oYbRuNpsrgay5eO/w3IGmxBICJa6Ljc2V1snd9qUGG5eGsu24qrK2DoGT +cVLaXD9+4thjsEKL0EBcw4m9mTNfgvPwEBye+XACK+XFheqZ/d5FzsCSFW7jEgljnqpQfhAIjxjM +AgPVuIqqxU5iOjEwiaMVWBDO9DrSw77newlgLa2JCy6CqaCcSdUfpuW140S8AAAgAElEQVTrgXRi +RMd9CCW2qFUQIUFBZGZtAdg70GEOJD3bkPSF9s7pzY9ywEtEFddCAoUEHrwEePs0uKXXjHc00zUP +pJibN2+++OKLfPQU6ugpvtT25JNPbmxsvJX43/7t3/Lp03PnzvG91Rs3bjwMTM0LDU0NP6GvA1aJ +nf8IHWlyJx1oQI0QMqKvyYsnpznvzwNzT1KuL9Qe5zeZ9jr9K93+pa21g/5w7/rN3atXDnX0IAZz +WuUTNxWVoeXXQJsmMtkDY8hEn1YSIvn4q/SpJvM8xqhTHcBLcNETpYClNu0Add4Rmo0cekAYmtLs +oYuBAStocWh4EFRAEKuUIc1qmXU9jXRrrflEI9282P7/DjpXmfDjyFkMUzAVVY6tdofLMMAikWCM +KyrQ/nan0+5cWGi2jqwfazU4bOHNJUghVeSZe8TU7DYC43pk+Rxj6b1hZ2GVeujEPoww6At2y6Wz +Jx7dPHIqoJRreGiXcMEtdLid55yQ/DaPisDylK5QbdAfITfWcwm8DWnCPI8GC+EMq1xxokTvxH48 +ADDeWBpGLGY0UQO+csQBzvvqoEBHRiTOIso9QU2kXAq32t6zOJWtPGiNJgwO+Ht0FKfeg3jAQ+ny +BwMzxBVtV1dXfpXSQefm5Vs/OXnkw7/50zwSaOEKCfwaJMB+O0qlV+91v/P92/tjBkB9/vnnd3Z2 +cjJ8Axyz76mnnroDVvf29rBQ//iP/xgjNU/8MDyhK1GdeAJQKYVbxn6jOMLD8aFyQsIf+p1bPGhq +8JVwPJEgV8Tczvu5fatL+FBo49HF0qMIvD85WN46GJZvbe++Nhjtjsu9Trtfa1Sqab03HA2GYzBV +hXjraoArUIpixJBFX0uDs3mGr4WG+ratCeKiPVmUBPihxGPRLzOCHNNPYqAXta4E/iwrRCZTiFXL +Y7a1UvJiY3FpZYETBI/VK+sVjCO7pfKHL978W+CZT3mHTSwis7pBTY8P2l8l2O+ogHPdx4pZa/9D +ehTXXltcWFpdOsogbQg2GiL8CDb3hPDjGqUxP7q19tTlmz+mQkur6gR0DzyVOymdPfPYxvoJAanN +0/krjTLfLhCc8a6/d40ajQbt7m67sz2eDuJAZsGbATVASzTcFyFQIGqSBAZttZFjaQ4FAoqEeO10 +e1cfJCA5c7HRPcoFKG6IMDTipXsUIfytpklamy7Wj5RHx0fjwWHvZmewTR2VmMsMVpXeHSyueo8N ++YRFu+g195T5XvtqJfnZ8fUPKn3hCgkUEnhoEkg54/RBEeeFvwNQgzIQS/jnPve50KQRiKWI5/XX +X3//+98/z8Df/M3fPP744+973/sIxN597bXXvvSlL+H/+7//e8aHu93uCy+8gO37xS9+8fr16z/8 +4Q+h+elPf/qRRx65RxpUKmnOnDmDB9R/9tlnuWKhPvHEE1jJZIQN3PHjx1966aUTJ05cvnz57Nmz +gD3pAdrz588TFRYt6phqEo6T2kY72uWeuH2ba1LX2Xj8Tq1sPT0cHR72rpfWDm7sXCyV91q1/rDX +rteSjcVGkpZ3d7rDAecmsYrYH3dDydYqmDvs0sGKjcFD1Cv4C0ziAGBULSpVZiInQrDrtJpU65V6 +ZSEpLzRrrVrCCTvNJFmoJq1GdTGttCplJm/v7pabx9a2Gj3meyHF6DEOwBAa6Sc3wxIhAn7BqK4R +ycAH+j3z6yyL6d7B/kF7f2V5dWPtVKu5PA+i8/4QrAt489KqrR1d+8DVnefY9MKhxPQbGEFdaCxv +Hjk+j6Phd5tkjfImCTEJd5mLtosb0vcG2NPbnf4eQwJgNqO1MU0r4DRMUjH8wlfozECL7HqEQw6B +cwiB3UoVVR00xcEn3/4TjuJsg/I32i4SRHhwBoPwTXYazjJjRv1IaXoUakz0cjzF4nhjr3O9O9hJ +BJ7ZKjMJnztfoyEE92JUtAXBnoCnuJ32RZZDb648rojCFRIoJPBAJSAIsP7iELaydPGDcIPBYN5C +nSdJOLEN1n7M3OLi4kc+8pF/+Id/uHLlCoDXjCMPSqWDg4O+5gDl8HAbfuzdH/3oRx/84Ae//OUv +f+tb3wJ6gdg//MM//OlPfwqyBqbeO01gKhr8Ax/4AHmxkv/xH/8RTMVgRR1vb28TBUt8UH13d5fh +6NVVjgQqY08jLPCVK9ZqACr+8IR25jZX0/iD4V96raac4/MoyVZP/DajgxO+PLbW6Q/2xqX2YHBQ +XmgvtXrTSafRSln7g6JExSaNVKt5JyPOiGDJTC2plstVlCYfudF445T52Ua92mg2FirlhVoKcDY5 +SIiPvmLW/lJ+5hM0qivHVs9em77A2G8MKQtgrMelrq2vhQD2CGiJM/AIMGxCSQx+rmBPGUnD1sn2 +Lsh6bOvU5vpp1ooFmhKbw6qS2uXy5A6RcnQD65Vu7L8ENjC3CvINu4d7+7cWF1bnoZSUuMiS08ED +tbjNr4QwZXrY3T/obA/Hh8gOyvoBTqCmKpkNwyJc3RlKZfaRQBSNsh7IJYoyCaRgwJidu7Qlq6P5 +AgFfJrBhqQR4ottBbuiYTRdENlEUQXm0cImPC5Yalc1kupXFKR7LFUR8ZDja3Du8etjbU4l0pKJg +8ywKhPA8mNvgXGlEnX+lG7svMSKyunDa9IpLIYFCAg9OArxmVgS2cdztvX/aMXb6dnSIncdUkn3q +U58C277zne+wUgm7E1vw7fJG+GOPPfaxj30M/7FjxzArf//3fx/NCFJiueYZ75Em1DQlhubFHmVQ +ut1ug53odJAVfogi8NSpU0A1Viz4ikVLFoxUdDelkBIPLqiFJ/w5D3hCs8+H3MvP9s6khsoDAhvV +I0rp4XA0O4N+kTE0J1eUbEAYvqTMbOsvA0vnCSLv6nqk+qnt2vnaqBdj5EKOGSbw5EQ/TMaxDzIU +5IATcZ3AIcgjcQWW6UkjIICkPLly/eLB4faJo08sL67dgaZI8g4mo7G48lGz0aS312HNl04hTsrj +16++tLV+ZnV5k1gagowh9ri6dFGbpxkt1esf7rdvHfb3mHQGBTUJOlv0REUEnMo2QyZ5Z5jqAfDo +XpASAIuMgZEk47bP5837slAZVMCQFZ6JNUGa8TKTiYLslMbL0yRh0ur7i+WF6unyhPEMl+1kUSn4 +r1UXjq4/0Rsc7Lbf6PbbDCQ4m1KyWg0GtPrM5yPqyYgWEV196xc+r+48z3A6B2KYanEpJFBI4MFJ +wLAac4qhRe6XdCzqgcq8FssVXB47X8yjjz4KtjGu+41vfONP/uRP5lcMzScLfw7J0Mc/X0qe+B5p +Ij0rUv/5n/8ZqxRDmVwEMgqNZgc+6/U6TOJntdTPf/5z0rAlBNv3t37rt0hJFInR3ZEGD44QKhh1 +DH/OSXgi6o7Ad3iLqq0kb3sS/Tsk8isnqyarxxY/dr3yPTZ+cKA/2COVjQIHR42pLOHS4lh0uhU3 +aIgqZ63v0aOnmCHl9MXBsHPYbfcHh6xlDqwMuOLBa3far1x89vjmIyeOPo7cYJJreILhXG4SriGT +61Lt7HA8GKRXtWyKYpPJjb3z3d7h5jolZguRSBbU5q+OnZASEMLCGwzagToq2VY1t2ASd9E5mPeT +Jl6PvAqBpshB4e4ucKVqhGOYsooKNCUEPiQf0lhukp3PfCAX1rzKssQkPU799ZJvhMzsdaNyMgNU +552/ULuoaZNPADRWDns7N7bf4KN1qrRLytYq01SwF1+9dX64ja4AsmS90tmjn6qlS/OUC38hgUIC +D0QC2kszr8vuk2i9VusPOP5Wem3eET5/O+8HyZhq/fM//3MGgTE6icqzsyp4PuX9+6npN7/5TVZL +feUrX8Fu/rM/+zMQFEwlHAeih4fr6dOnmVVdWVnBSGVcGhzNHVlAU27DY2yVPsPDlbxcqUJei7jl ++t+cW60+Paq9cn1wFUyNIyPQ1TgwQDrcSlzgAH4YQtK0cfLouXpd3R2EgyOWIdb9g92d/Rvd3q5w +hex+OpDP1RvnB6Peo6c+yAJoRcy5kB4ilRztQs5L6dlupT9IWPajb8gscGZQ98bl6/2jR87EEU4h +/7jSStDvD7qd3gG26WQ65HMz5IrzKwSWMB/jvWq0zBjFK2SNa4Q7pdJ7UEA2Ot0d/Opi2K7FBOfY +wk7SPuDsLAXqJxLCNpxOS/JiMYx+UvJT0QzzEmhQJzkyYAMVdueUZWYWlHLOOcTA3fx1sbm+eGpt +r31ze/cK1RRlkrAgHDj3V3L1KXv2AsX+5hmQjyeDm/u/OLH+0TnahbeQQCGB+5aAh+L0TfJ4S++b +Hnst0o3NzZs3bgCr89QAVMLzdbYRxQwrC46OHj0KpL3xxhsoQcZgieLK4iMQ6+WXX37uueewFOdJ +3b+fQikCBf3qq69CjZFeVH8smApwNRYkzLO+8sorzOZ+8pOfxIQlGbGRmARkjyt8Es4VGVIFidJG +FX4c9CMEP564vf8qvGcUknJ1efT50drfjK8IJEAaAMAYkeFFhihGELhaXlyeB1RqjZTSetpqLhw/ +euqVCy+g+oGigBONl5ZKN7evsuD23CMfrrHW9nbAyCUWaBpXpFgenO60D7u9AaAOAjH+PJzsX7r2 +MuuKjVJaPD2ecB1CmStMg1AUqtMZAx0NmfLjwVhUQ8kTt/jdGcgCFUXFPTBLFsGh8Y8QitbA+LTE +uUj8aGwBpanFNCf+GNrN1pRh8PtkjwiXtUrpXs4NWkM5PvQ2SLariQZRcAghHp54nCKEazyBii2V +15aOri5t7e7fuHELm1XfIOL9ExuUXvXRzeYfWxzpwTbhB72r+90ry81fMtsiDgpXSKCQwDuQQOyl +4ZXV0d3W9u8g0y9LgsXJWiHWIu3v7eWwCqAur6wQTuw8AdYBMeSLpmARL1Ff+MIXlpeXScAqJJYg +/emf/ilZPvzhDwNs87nu38+M7Pe//32WOzFdevbs2W9/+9vPPPMMbOAAAOiHZ21tDXOWuoD6Aahh +mHINF1DKFe1GFrQbnrhyC53cn99KA87ANRLcf3Xun0LOXpDK2IZ/i+Jgu/LCz1tPPFY6uC5Eyh4V +46pAVhUSxtiVO/vt7cYtLTdj2o8PmNkRRfvKru9N2VLCccR8/C6yKG+ZM9+3X7nwkycf+yh9myAE +D3iCk7gOhoNer9MbdAf9vmZDD7VZMyvaRPg09639C5Gda9CHnsxr1USJA06IAiOVhkBjKh4lcLj8 +jvIfh3vbErcsO6JDAREw2Lti0mR0ZMLpWKPdfp+2BxTFt0CUyUtE5JRaO0bRIppRE0K7PytS/pFN +A+wGPBgeTdvsaWYLljkxQ+JGLiQTfp43PMg48HV9BWQ9cv6NF1lVB1m+YsQ+KA6YlJ3qfox4C4OV +MyWS0l73F2mlzLfZg1pxLSRQSOB+JDB7N8vlp7/6v3VuXPruf/w/74dcnjeW/rJolpFVykDjolvB +J9wdmEoWEjC7if16xxZVdATZ35o+L+U+PWAkRceyI8zWWHIciEg4yp8rtywtBtdZ9ISfLITj4Yo/ +PPhx+OM2PPBGINf8NqjlPHOLi9u3evJk79wjHijRc739Xi9gu4eaH2OCV8ajYbfLOiMhYp8vhY4n +rLftdroMydKJID3Zgad+t0ulSQN0DUfjtJJQTXCMb5wR/B+++IWPf0Srw3CCIsBUC04NVg5R6MzJ +J4hSuggTSyxmlVAZ7BxWGmMdpwCeGdKUpsxxSKfOnsh2T5IMySjxZLy7t31r+9rewba27pZl/uHI +G04lOEiXiPNVxPOQPL05Ul4xZ+7wOOX8lbgA90ipWmKketqYEHI3G8mwv1TqH+XMLArhzKnR9IBP +wQxGXYZVBa5x7hVgbMCDOO0DAkp0+SonYbAmVrkGq+KZTgAnMaWlVm2rXj4adYyrOi924eEaXUCu ++OMWP3PYL732k2pjwmQLCCqaXoRFVh46zFb4J5ByW/Xl9cX3ccpHkC2uhQT+PUvg61//+te+9rX7 +kcDHnvlfGqsneQd9hv79ULo9L0AFfGJ6Bm6hGQlh3RDX2xPqDkXAhOVbw2Hr4QEqxeWj0BQEq4TA +J/7Q45ieeBh/pr/PTtmwRIkFe3B4wkKlguGR6vcIcHjIS72CYGBDhFAKtyOOlWAXx5BhSeE6wIam +IzvWDoQJOWwfGG/L/V631+tTHBk5lApEYTXVsN8fsO7FeEM8e2RAKoigItGsQBB+iZWP3KhnIC0O +K/hRwKqm91ngQT2rmg7iU57ECGVCtfuPD2hiW0i9VjU7MnGcznnJ579kUB4RVqHiwbcRlMURxT0X +nVCYsHapMhTwj/U5WEX4Oi3d2rnUH+2lo+XyuJXWUhaMQfb61St77e1pwvlPhgd49C9yKauqFZcZ +KRN8kxGVGywoXWRX7IxUhEg8s2Rikx6I640IVTltDhZEcf5GWmoM20fLkzenJPiIQq18pJRwbgYd +LM7DYti5D7iOJz3adoh5DphhIIKgIKs/hwDVDE0p1EUHk+LdXxCaJvvT6WZm375ZGVU2HieuPE5I +nWs8JHiGo/6t/ddbSxyE6aW/UI4qW0owAP1aylD4hIVQW8sfShONDBWukEAhgQclAdSG1yhJWz4Y +x0uOYYp7MOQePhWDToaC+FFPaCscOPSZz3wGExZ/rrZChRECXwAp4Z3DQyxdEjPzClKyoRbLjwTc +CtUmY2xEUvoDNVi4496ghxYNTOV2OBhgNYKvrJKFOE6q3ViIMmQaUDqdIJlHRKlgftxNvExIe2ki +JOFe2pYuEokITCvMlBMmyJimgsxIqT9CDNM1TadRISCuNDy9B63l5SRoJeUfK7iIFl6KFjH+J74g +SpQvebDgVVGSkf84OmSmsBqERo1Bt8c0tD59M5vhI6rXO6iUD7rbC9NxSgYc5moy5TszlWllwByF +WLAg4AAUjJoSIrm4UIjor/1ZgkhPIFUh3BTcwXAqxwrVZh7R9MAskieZSmTg1CO6OshhuFnmHAZS +381p8lSyraez2VCq1+69sX+4S3LsVIiLVTuBaM6SGcsitIGKqF613E6Tu/Q4s2T+g4j4izU/HPX4 +vlunf4N+lzor7klo3DuSURcPg9Oz5aFtpKsbi0+nycM9vywru/hTSODfjwQ8CsV8Ki/6v59KZzVl +RTFQyUh1DH4CjYxM9rpgHzN3DJay4KS0t7f/858+R4qOR0rZyUogY6Sdww7GRrd9iNLFNMD8CE2J +0uTcBsQZXZSQK9rSipS/Us2zWzzyVn2wb6Vsu1xksF6EUXjMKFpaAfgFabOuj+kIRO0R/QA863ps +lzBACTaRsLnwkigMH5FG9VOQsAHk50+ZGTYbuxrXnWj+DXxQEiWWw67l6lsufmIcCdE8jZlXXITo +ap+K5WgR8yMowfhlbvWwh/x0oIRlAS8SIDVu9kdt4bgI0yqETKqTMfXtT6oAa5ZeuSA+u+WvSiOE +8OAgBGbiCgwAizS+RuIAThI4f9ZakJVsyBIpkc1wuTw46k8MOOU7vZQb1c390j5DCII/WIKiHaVn +3Bq5A2IV6DohilF1Ly2tzEn3ziKRZ3/Y6fXb3eF+KeloOZIPgs7IzmqUUaY3w2GUjAwtnF2qnWOA +GTy+B/E7CyvuCwkUEri3BPzG8fbRlWWNQ2ike+f4txWr+VoPuoaHD6nRAcf+Q1NgOLKShXDQD2Nx +b5eDkCa2IAHQHliIdccnYzAN0XRDBkv1fbSB5kmHWvkC2dDJqDfpQQ3TAVoAH7YpiOUQDkrWrgg+ +EAOAaRlMllJTgAGHqGV5oDXTovraTGTPYYdpSZ3mqwWZHJ2DcvX6FhWqTNDMiiNGWxhBGsxoDeFV +yhW0NBhkw0hJhZia4VSxNl91YwcVExQ5wQSrZdHu2KPR7vVK1cPOcMrKNRVoczewSIzIXuavYnIl +jEeBhjwXMrvAQLBNPoogHbf8swdUJlbWcFqtjPrpoDNsYEPDE8RET65cG1WqdE5q/BcFMrAUCiHz +uZ7xYFqbSPAWjlB+1kZZ3qg0BVC8aOlnTt0hmUEaVdEvylWFXa49hGPeqYMRHRJVv1nubyXTNwd7 +o6x3eOWAhVaz1em19VxQkNgyX8FblB61cHOLAbM3nrZLCaMXdw75IHNt/O3t9wWlfYbw04YJMqLg +tUhQUK1NmQ6VnxdFsW5hpfZkvZp9zULtREKlK1whgUICD0wCHmR7YNTeBSEpV7/VWl9jXcuVaUag +TYOlXjujK9akARL/oM9k4bSLmagPfQxYNUTgcKDvaDG5yMHF3e7hGEWMYYPu5rQ/MEdzTuJKI7Ve +noNeoxRQBAChLKIqgJUP8EvrmvRFy4S5qWxWTORkLlBgWZlStJIw9TmeMhmNWproozBWYfgnE7a4 +gsqAMxhB0SAflSM7wJwNxYWSAyZkI05lp5HMyAOCwDkB5BXgaQbyTacMCgg1mdQqzKWNUZYpE7HY +cQCTLEtqbqVcSQTvjOJCLzNwRUBbcRkW1kyryHOHhcreEzeCMB2gIQfKWXxAMMRHiBGMO1oNjS2g +VDzMqEz+izkXlMUK/GdtbFhHzITAFXkpOE2ro8F01BumTOpRqrgT8wiOJTaTXsqGGNMlAjoTujWT +UW3UGU0Y+abBaAItBpjGup6AZD1QFD8D1DAKyR9yzK+ERAcmSsTPT1nNgwCVnonmNWvJcCudrqrG +qmRUU3y+K9eqrw1GbSQs9oKGC9LF4Ke60xweZBYPjm02ON64XZ4coZIkRAQDzoPu7vBpo3Gpy4xp +WKWqiJ8SUsWQhG4hy8UE2XRN16SRHl2oPpYm+mC7u1NvfmQp6L+rGhWJCwkUEriLBKwjtD81VMld +UvyqQValceEVBmL4H1al9IqmDzXGKkMTb6/ble5n2U5YitywZifW1hpiveRWaEs4c5D8s44BfjKi +IIJsOD7O5aNhWJWLRTmdNMA6AE8b6ykUcJXWlGasDcUGiFMDTqT6deIMujyAzcrTKtYYCQgwN0mh +hINBaCVDocYkrfrYjgQGS1OimyxJFn55h43gnE+LeBUoRDy7JRTU9/Uo1bGQMHBoARB6nJlDYyPR +dAJk5s0UOd4oRafklrHjVCK2ctZ2zH6CbtrsH9aQLBZSTivMl6v/EAYusCTYdon5GiXVklOfyYD5 +Sy6W/EoE+mn41zWjrCrmITWHbVUVTe4Y1Zo7Ia2KUVS0uxjX4mBqwn+JTpUmIVzBjRYfJ2ylnI46 +5XF9kHpqTwie6MT5cnWYDMu1Sk0Phlc1u3dhQiOmuply1CjxFBpUiY5ObYhIhC6GKLFhkA7hQDPC +aTChl2NJQCCVIwR8Ev7Tz4BJh9POtfFmMuQIe4JwksKv7KqVhSprnEqMhbxJKHij9OAN+Qc6wkNU +pA0Kj66ttfjyQXLY3eXo/OGY45/0USEErUo5JYmjFtQuQsSr6yJ5MtCebDQrp6qVRRoBec4DKg0h +mfrR/ZVrV2QsJFBIQBLgTVLve4qRE0jwLsQS76GI2NkjJQ9OEBD/AQ/hB2ObxkhdZAwpEGeANdra +T67QLTZl9J6DFgzNYghCvJKkk2mVPSHkhjore6AmzJGTuka1co+X1FBmRJB1okRIg6dlbRAcCzWE +OGbStUfdWKHYGsQwJTBFQ5fKw/FICG3kBBkqdbCEtb7MMoIxZezgyRhlBRiD12h3XE2jqR64w6CV +bgavUNNAtJAX6GPAVgRR/9whefkFQ1JnlAyYovugq0AhPIo+LbOcRFWgr2Dd75JITzbqLg8qNK0g +DpeO6sfiBBRVBVneLAmGV2OhuBVeK07tZNw1jQBgJFxm/JcIPNSNMWrqnFZBV6x5llCRTA6GhWKy +EFUvkyJQ1YGXrFKSq+Bc4wDGjT6f14FHyYMeAyUQTnJuWNxLf6c6POT7Ob1aMyquz8JAVKPwCiCD +EMSPFexhrvKfx0UPDE0PIyzFZcBh/mgkoEU5/RORmd/lEpChF2jkGyVQ3dVn0KB6Oj1SGbHmlhXP +MCE23s5FBYmNpnzbZKW0UV0aDm8JCE0U9iyvDD5hQCam6OiDffTfeHU8KcGSt5fgk+06XLWvNxDX +wJ/79czYERLsKgo0La/VSifSModN8YJkaBo85wznVchIFH8KCRQS+BUlYAxgBI7X8+30Rv7iUcSd +/ri34uM1Fpo6kVDVX48jPnACZY62RY+ij0kiVaLJQZ2dqwN0pZEZ+hwpdcLYoO0EcJF04IXG3ypD +jaQqXjCHHgU6hApkhXF9wYNInUtnuIZ6BYtKAAVYeYeM7FSUiugTBLROARx9lgTjc8q2jSSpgtMg +PSAi5tBHGiIVJrIyhpRCC+wVWGIJ7aQi0Mbp27MaXNM/YZD+xPCuGdO0HMpOShkC4kC4g3Zj26e8 +KSOZ9AMEX2zQV5FSelqoI4NP+l4iVdEaaOabNUOICSyRXsqIvaiJjVQYxI2bgsTISZ0MskxSFvxO +lIPdldpeSUMwiK2uBqlEEqwD6OASM9nQpQLLfB4OorJb4YTfqJR9JogNUZjsGitwX4LiaQa4YnCR +IulsaDAAI9N7YdVSoqa1TjDjFpMohYTUjs4KTSFZA/f14X6llvaqLU7qY/FMaXjYmDgVAoOPET2Z +aVnc8ocgQQg09NPgM7EVZl7FuwqUcO3Nb5VaIYrlGgly+KF8njWEJDN9sTY5k0wZdeWJpjQ91LkT +92/j7ho1n71WWa6kt+jrUbqfiZlVqjvaXAhKaWom1U4Qy9p512XAVW+pq+BmQaj6qTqmxpW8fnid +l4ertJZONjl9mXTqTM0cD1gOrnrY5txdqzAXX3gLCRQSuKcEpPf1HxOQv7fpjsg3rxHm/TOqvNNG +C1G5zaGKgVVFR5Te+LCrshBphLCGyIeCF/Dw7qMtMf6EmqJsR0JBqM07lD/WokCYc2awWKRRQrdo +rRGsoNNBYjShDFhNv8l41TKkCUYiWObk3PhIOfAMzK1qeQ4UlThWy1KsBpHhAPI6bsaaDOo2fKlQ +UsFakPENOdl2to+JlnqjVOjr+x9yrgPs41jHpJFrlokAIYIBYmItieUAACAASURBVAUaWFjW5aqU +qq8KRSy0nN8mKYqWYFU+yIJzKhGY0UQvWSukVmZpSeeDT3oKBleokiszurRPA0dy+ilM/YKxaiuk +0YMWu29L5Xq91mykjXqdoQLIHLLoudfXjKeHtLlirNJGanvq6nJF32hXo4sGD2pC8c8HWngGEAr3 +koKNXLUOHDDe4JEMcS7ZN8cHCwmbdFPmBdJRrw5CSBrCG5KEMFROVkF5QmKlcWWgowxgHYCOq2RC +dl+VTuH8lFkVyZJZLgqM7NXpemV4BmGquPkCleQ2F4zdFnT7TWSfTwa8NRuNXl97VeFBnS36lfH9 +eYTF+wFXhnaGdmleVWRWCzzBfFTETa9K6Ue51IuzJxhpSMvDUSUZr1YmRyplrH7aRM8QArydO925 +Hf2EkVsdLPnnGX5rliKkkEAhgXtJgBeYVwk7lTdWb++7dn4h76Z6rDSgSAJeUuBCChXyugHzBK/Y +KnqLhWfaiqdPQaNkiAc40LV4ZDwpPRm4oPdJrFMA/fKDdwy2kkRGFj/t1rTikNmtIV7yqutOMqkj +sQB9mX0oLowS9DXaDHQUnqCuZBrCGDpfSbmQkvI1u8hfgTVDxxzqC2MSE7eoJBCb7JTE0KQsYryU +qJqRy5WX5lIVVFeJmcrZphSkyqmOdAXIINhhwhKMDjgGjegO6PQGmbPs1tTYM3jMGPbMygTx4Srm +aCULeg/IAe0MLsp4xaAsg6qsr6WepKtUBzowAulTT8QzZUoW6xw30CIr8FQYRzmSmaopzGM6erFV +58c9FSAR0sanbkf0hSxAS0WZaDGqQ371LCQb10wjwSYJCcuH2hFru1PNWq1UajWPMw8bnHKPPJlI +hQGchs/dA5i1L83kB09cQnQ6KveS6piBCXUzjD1ciVNRRilxjgeUomZ6JCmRMP4qDd86BUORT2cv +rZZPkUilqv1vc9Trtvu5mzxqPlceSMIIJySdrpVKV2jVGNrNaMAPI/Y+VQrGVAzc4plVQXz6Vum5 +gXlawOPAqo4DSd9IW+PBWn28pnIsOsdlF3gIAeaB8EMIzxseYucZztMUnkIChQTehQT8PvKCxub6 +O1XGvIK4N1HRCR00r4lETwo18gb1eHWxSWRAoq+lYK05UCCoPFa0WF/zeqNnISbdJ11gEAZT0PjS +jqTGAJMWgBSjgngx4EAEMEAo60UlWsjEHJt2YHD+kVf3gJ4oKjSvLDqyE4mGYvEsw27AI9HYfCyg +ZZhW87UuSdtOUOmk5Fer6tPl8AR7YK8UUsq57+DcSNafpiMFNdL1Gu3UeCrZpM6w1tRbQIFZnRtN +IShTmXOm6EagHWOsUz7EBphpbFw3sKyhXDBdI8Ic0BoVpzImDjbx00HxEhMOKxornuiqTEYlkpPq +ZJnMcNIrw6xWiFEyxw5CnwW04xpfj00YBOewH02jAsgwhV1MTQXnlQqH0UINPtDn7kvQxwn24DJ4 +psaQ841qLR9iNik9YxFEC0W9BqP+cDwkc73SqNUaFC0RaGzUCU2J/hKNyFVZEBr1lIGLowmo6WCS +jpMae3wNmVQ1oEhwb0wyOHGjxDLXqKtShkQ02kAWBqBH6Y1Lyd7euLXw+urKZsPzujAsnu/mghli +ck+kits8V+7JwzudQYdBdKgaR7m6c2NBwon5VEXdZvAc1XFBIVmlVAJHEYSfFkpLy+l0KxkuEsw7 +lJdLxtyPyGg+rjATgVxzxt5al6hRcS0kUEjgXUjALy8IoZm5O1z+Kt4RftstL/R8zrjVG693NXtj +gT3u2fLhDR1oZPSj1s14EQ+R2GJS07K3qqMEa2kiLPJkJ8QxilAwGFkk0FF78FrCWNRpfNqwyBRU +aRTLSlC26ExI8Qe2pEEqSZUOu12a8lVUyhDAww9/UMqyOqWpVFfUDX/AT+5VeFqjAtI4qg7TtKon +6hxQI8mA/R8YmO4uYGqxH1YJZfNOMbVAZeAZavxXCfAPJFZlNFMdIrEXUY0acaY6RmjZmHQFsIZB +b6xFuBN6oDKzQXHgaNzrYVsDjLI3GXyuYtZxXATzmBV2FDERy0pozsKTrQnky46hlwFEYR8CinQi +GOhVL0MbXxJmqQFs1RarWcUwpQzipjrgiLpyGqFAVUDElLNEzbxzib6DRKtGhz9YEU5RKEhoqQrj +uUdQfirIz22OoGoR0EyzlNPesN0fd0aw5O+xDPiM3KTbTFrV8hK0RQGmoOImcH8CcfDQYFOPdC4j +wMiW1uqENVysqZaFGlA6AyGYoCix43Bxbc7EETJPZZuqkwPiTpLBbvPW1XKXD7wm1cNRt33wSr1Z +azWXm41lg6uy5C5A6K3XPEHwzC0erpwUyAEiGlYfD4aj7nB8GEhp2fjhgsecectPUjdYUgWLU7T1 +GJIynkf19RTCttd6ZVPLqcotxEuJcQ32ggFyzXuI4hZHytwf6fOU+a2KLFwhgUIC71gCeumta7x/ +3i/tO8zLO0nKuL6ZxYHcolvRm9DTu6t72YQBWrzK0hvoBq0cIoEQEKcetCHESkQAhV4VHJcZ06sQ +hX0KkelkyDAwXXu0POihdEYmoAJamHEacGQnBuBralhX1BD1zFokripaC3lAQ6t9jWRq/lU00FPj +lGxZtQwAUmSqAZkETxo/hWkdLs/SEbamYt6hG7VYVxhAUgGkMMn11nyxKgfWAqqWB3saZD+iydkf +IkvUKIcZpl6IuaAg8ugYOSEaZCVKqi8kYAkPBi2wnvCdH/czUNkURe2BZA3bwgThTaGhwV00QVXJ +gAYR+AU9hAFbEBM3UuGKTipAKR0Pdv0OQXWJXI2Myg9W2QgiU1xnL8CiGgqeSab2k4TkLAMNR6vk +6Fd5IpvEMIRksJJ7k/1hpQdXdIYIFxNVtvkO07RT58w/xAo3PBjiVu0kWamXodOtBqVeuaaTbNmL +REYMTa7UQPxw9S+AE8oBSHlUABLtKayi7UbJcK9xcCsd9rS4t1ZHlBSVTpmbbY8G3Vv71etptbHQ +Wm3Vl2pVfQ42nuXcI+mIQ1oJ+SN+xrN50Ng0jQDp3XCS/kDneVAP2pFW1wAAmWbcwjMkg3P+OoFu +I9CejFtlUnaqRghdpFa6niab1fIai8NhGpdJW4+Rni7n0IXnIxgOvx5NPdJy4Y9rnj2iimshgUIC +v5IE9HLxCku50X39lUgoE0pAllp4TEWvsTCBiUiR1XtOGludTqbOstTDzPm1l5UpDVNFKWiQl9FT +BvbQWYyPQglDt4IqhVOvbyEiYVBygrU5ArEAG1l2GhlEz2oVEOwQ4nORvH8jO8M2tDQ0iMF0m/R0 +sqA4QZNTvrAAuPGmT7gSMJJDWh4AZlhS4MGI7lgALgWoSGojezRz2kMjzeZ4BJOpNf+lWH2sHTZV +Lf5TMPiDstRcKWWIImqSg9ipsuuFLVZj/SdmLUOj4IEnSSUv0Df6CrI1kQRwBxmgVwuLvLSKRHAu +mBwOGUqXeJ2RkxYYFRAS8R8zmhFlt57Ln44QgtKpBkiYUWva0UYfuIiQDaKIi5/EggUsSnoAqDkD +AtXqeNjn5wYeMbIKLQiMp6PBpDNKBtjmLIwScFBvAaqhsVqZdPhmTgf+1cER5+KPv8z59kb6xNuo +POQjcaRXUSAQ5ik/P2gilxNUH0L8QV/wab87DppEJwQ5DPcbvf3WoIugRqytVW9EK/VidIBqcQ4i +P56Q4f74yv7hNbbBLC1w8EKJz5sPhxxCMkQoFCHch1PJAXDV4ETUy/KEIYtNtZGfQIVH3e1Rf0Zv +h1iNjHCepyFKe3tUGbGt56lcX6yfaKabHCZMWbhA02gtknFLIB5CuOIPD/7cKZtdHlJ4CgkUEngg +EshfN0yIu7x782XwDs7f3sPPq6ykkdxaBIUT/4KINAMODYHJidUorQHcae5QCkJoIxyCDuOTaF2U +MYOGAKmNTgANBNPEKhpWcIFxQGHoJqxQ6REocV6AdYrUfEkb7YUrY1lfIK6gim9VS11iJJpT9qTG +9GEAFuVoAhEMZZ2u9CyDvlDQAKfUPEqfyklXE+e+BIOT5Agdq6pi41Il152kVNU3hjmW1CqCOkED +Lm0/IgoqSwneSwo+Yjxi76BqhaN0IFSWqkA6SBnZxbDGPAEomEGQ6kMomUjRd+E/w+0aSB6LPRhi +nBxKyE6bYaTMuaVTgR/JC+XVZnz8oNGQ2SiZEo6UGLRURm8RwtrCVFYXKZyMZmjJUS7pcfI0GofD +1wfjmwAO1VJd1YwaRHf3jSQCEsEb5iYfealsNJITN0eXbnWuBhm1v6fOkZFwgj5MfVonvSerBZbx +8+iosFkMC5YsS6OpUYpA2kVT3BKreh6TbrVzsDTs1hSeIBwkB/OaWGBEnTFoOFYfQ123KgIcdvp8 +73xY3Tvs6YukKprU+q/HQW1II6o+eiTiLZEM1LaKUkqnJYF4c/o7Yl2+EuPoUECNED9QCiGxeh6V +cr2yulT7YCVhvCADS16oTOBqQXGBE+tztxFYXAsJFBJ4LyTgLjbvMJaS3sN3W+Qdry7547VGbwA2 +vOPCIzlhCjij8U9CpW6EqbJwHAzAqHfNVXgqpxDZuLbyZmqCvGArgCUrQUtxVaALIgeJtPQX3dOo +1AHDwA+0k6yNAScWxMnAgiZQDxyp1eqTOmtwwCNggYsUoO0ak2VpjL8aGuzKsLMJIg1nDANM8FAO +JYthJlUFsuxLoaLW0iTLwFImjVQqc5MCGdl8jOLCOfo2BliF2h6uhgvqAkNpw8uFSslwzP5/Fk9x +7EQd/ugRGMIwlWGAOc6E8/1hg52/ErShH9kySs0sdEPMAiWa0UXkOqaKaW2q6hbgw0FOwDJa+iWY +fEomlKzXNYMNBS1a4ntrdXCWXsdrr722cmTdsoasG1h/pcT9Vxdi43aheiqttIalbWYQkTg11b5j +EpDecIhfyJHWG6VT9fI6LK0sHjvo7bj/ovakdiJMk+pxUWK1kCEqjDY1lwNVm0AsJZfLGaIFOPNK +4M0w9WFtf68x6Tex5z0Yz6OAtEFTPW1kYustXSk9IHruKE1be6vj5nBU5SxoPjjEYiikSWUkUjhx +McFrlAg/YgYOqMAMRLnP0VRV8E9MRo1ITQK1njMSOC016Hlx5NKQzqTqyLptoJ7JB2bhle6XuXgx +59sl/PkVT/h/GaUivpBAIYF3IwGpA2kvjisSvOZZc72Zh9zdEzmkfObzkla3emnRB9JQvpcSARJQ +X7Jc+OMi8eEnCfjKWC4qTUgMxgEZ0nj4WfoDePCpL0Y60X/kx4jTVk+0H6pQQ5pS17IDGexVknBg +qYqGN6ktzXpyaDDwCgJCHsucnSYT7FjUl44RRI8y/yVrCuqmJzZqGIOMNqIghftS+FRGpWpIVJYq +Jq8SUwjqD2QiDoKoQGqumioNehotLsUJTnnpLNYR1qiqAJxRIl0EFhVjM/p0Bk3PakGRTopn3VCj +Bpcs5dXZikz8UZqPcGRwVWqY7okWFGnilCrVfVChuRGcyuBCXLSEQLs8ZRqWjgk2LguiaJ96s9lY +XKg1mvVGk/VO4Cd8svzJLQX/ckhDTSRRv+kk1ZnDHwo6PBFFSD05Ui+tj0qdYWWPY5in5b725riD +BV+laatWWq1MV8AJiJO+mvId2wZfPVAtqQESwRmQ8luBFmGzhbv/f3vnAWVbUtX9vqFvd7/83kRm +YBJhkAwDAwywEBSQKEFY6lJxBvxAFFiislBEUII6AroQQZQcREkqOSMioChITkMY0sQ3b17seMP3 +2/W/d3f1uaFv9+u+73X3PvOmeteuXbuq/vdU7bOr6tQxzDFC4kgeetFEcSok6wXl0sLEzMFtC9Oc +IMyPmCZCbA9seYKfoFVhCYAsPFfSwvS8VWYblLzv9Exnh49MlibmmLaeneGrOHZTUyheL48hqThq +ABxmBomm/91eQhhDplRVJUySbTuamMjo1wQY7pQEiN0v3EGsbc9x15llPdyozVIX02i3nOUg1JV4 +iwF4wtfvIi7tJarL5TqMDnaeEEQgEAisAgHrUXS05Kf6GElXXFYV+UyMntiRhWRI8ryohTYzxICS +LCs6jbYhA+toI7StlNojv/VnLJC5rRhP28xhgzheCmzMUjKiadqWGFJpAY9hn5EuGVeboDUNptTM +ohlnXnZMI8g8Bo9ThJnkbNoEJjOYOJxYqTThl/w9PGUzldTc7B/Lh9ja6sQEual3u4lkN/vN//xj +VRhTl84WxuErlyYrk5Sc3M8EgT0SWL3RwLhMkxnXzeS1cDvm0yYW5gWoL94nptGmvynTtvTwh6Yb +aLySY16mRl6z3ulJgdJRa3DicVKzRPNOJwpYcUyulW1Ktu3VbLPhQMdmk2+6Yj+ntvNNlO0c4sCP +XWWjMJZziuMcJvDWqIdfhqz9XPZLsAALTXG6oBN4i7+v5yoQSLbvjU4CW1IrY9vSj4xlYB6VTds8 ++4Avr4XaT091LUwZ920/98aZ7/Epb+PKsiYLZPUyqbY/J8JsmClYtFgWsekBDG212txbbu4d49sK +s60FXgNqtmp2QDImzraC26/Jr5o8cxaA5+bn4TDzYRhzRBX3KA9qyCFJ2fwZa02M11pzLWYF7OgM +1NjDn60Em/ns1AF+qlGbafY+2VQnaLHJJyEekyC4oyx7YiJmhzYs2IlX/Eu/hrWbD7Thqi7wIYn6 +oSle3UpwEfLriLYKLr3a2CY+tF/ppl8MxFdW6KU6IhYIBAIrRMAcSevMNvfbHgxWqiEZV+vQnd7r +NIMB2un26vDWe23sSGaDscycS1ZPGcfS0zSGghgW1Ia79M+GPRlKTKRtTTJPYtxcRVsHtAP224fs +2wQspWNQkw6sts3N4fng+5kMxhk3sVrCzNrh7Hxv0lxWqkx9sGOssZmlsUVGnAQ4zO7RiFRfjCKi +6E+DF8fv2vkAtTZWadjFrpu9NcvHENu+bI667bYAjFlE25hEa6iA7auyZDtmz4ZuG8fgUBxeLCO1 +fekG5zCZTBuPKdrG5eTdsu6LVbZHABtpzbgyIPNOzRTu6eQUlShVK5OTU1PbtuGA0qiEmz3EoL0w +7FJnKtCpcKfeCHUuKzqZVQ9dGI7TIuBQRE5LRkyXtzdRreqd/zpaPDsGeO/ULQ7PXdkYm0bKGmpN +t9Awtl/F3LhkhRLfWGaQLA1ryW0yNlWu76ly7gGLt1w8wPCyDbuQ7HZZ4NZhloPHJm5KJsJJhw2M +PLgZzlz6PfgxbHKfuXp+0zpPaNxt3I7cQCVe3Zq3b7Xbxm+OuUwXtbJ/MpaiPbSVANpgVXaLay3i +H/cl3wm0WztVP51NyCs99oSXbh8plHLmGEB9oX5komKfaROkhLrgeEeDph3wrTlkTlGF1N+akF3w +leSSIsSPMBAIBFaKAOOWeS/pgbc9JqKCfkWfHEaXidF7Ux4CzwUn5e/oVCdPmhnNGcBUBDk7FtTY +icZAMpCRG2eNAYm3UMxJohjbWGQXk5ELTKdCYKbMMFNqsmfJppGHYRPbbK+E1kq8U1lqzNvMZ5pl +tbVDrJm5SDYZi+GrjPPGaKPJtlK1mOGWgUhDD9bINgLZk4CR1Ich16bh0pwgfKsy71ZyMWtrxVs+ +G/ytBeaAWPsZQSFLzUmW65LnauaBM3irVcywDeWGARyWD9GMuM1m4zbzZGAJPH/Y0b62mIyl3DnF +8Qi16uSkzdPi/nLGMY8DuDxLL8Rh2G9jJSRglgp0x9pZlDGFZLRy0zWkEqklh4ZmiLygntFcmFx8 +8XvPxC1n6vvnx65tGUK0AfRsK5PdE4ZH21uFBloeRYxjC507S3N7q6VtyV5Z2/OiAUp+uf1kTPbO +ztp+8Tqr4PZ7mUFMbx4DlrLxvi+FstmawphgYBKBe44dSzBtkoOtYaVZqoThtTrYDWPF2rNSx7Jq +FsBS0z+rOTVNqaaEvXnm5loDZ2ft0Pz2r4QqK2Kx7pA8/HBDU8Jc8/BU2s1HMrjpEu0Z1LOEP0wR +hFxmUZNNzQn4LuZKgggEAoFVIKDexLhpwxWjiVTApa8W1PVguozLa/Dr8NOgRj5mUG2F0xTSeyFs +iEx20GjGKZtDtj/pIs3mgNNcMDYTK8rIZ4f+JFOaput4ujdp89Ls3RoOWLDJVhuIYNsjv62VEq3P +4VtwRjtDHY4Jq45M19kWJoYQypQBJwOzg7xswvwqw50NdWY/edMkHUFkI6UN2qnyZWTM60xNMPc6 +tRBvJlHo59gEGz7Jw/Iv1aaSjL/WRNx1jotnPpvcNkTaXDFhqgg5KAJlmA0y2/Lpjh27mKqlLeyy +tWMdJph3ZL56caBFsypFCA1AHhUnj3bThey5gJIK4QB5z4tMvxq6TD+CvMquEMynqqePN3fPNa+p +V260OyhZVtttlRxWQoyZzUawUtCa4njbamsXG7/4AXteqHU+lQRUewrZudNuq/Sdel58tV/aJvPZ +qW3mVBkQll+XHFZSrJeUq41WdaFSazDxa85sZkr57dtGlPL4+UilSslGyrJCVko7yk3O492F23l0 +7ntsrEYnFZSwfuR2O1IlCPiH5cdmN1tHmRhnBdpbBCHaCSu5c6tAiJYphXab6rRJJHknHKsgAoFA +YEUIyIxiBpILsJKs6sbkoPNr9OnOnaZGKcJMNd3Vsqjf45cxiCS+MZXEw7nZQzv7N7mx2C6zxGRk +FGDbLT4iG2lwWM2g4r7hdmLizNVgCwl7TFBq2mFhsrBSSFm5jHHU0LbNMpbZ/h/e4pRaKsPkpxlm +m1zdZnXiMiOIL0tei1IKFPVmeEzjNf5m2jdizrHppHZqmu0Gwi4izvQyi3NkI24K8cghqnyl1TRx +BhPfeWXXbxrWMZZUCnsJwd7aKm9KMnKmURyCi6qKGLCc6TK5vHL1C/MsuYzznfBUcbr5LjA8kSux +H65z5Xxo1hanyjdrtE6tNw82y4ft7U9z95mrH2evVak+wQG3pRYbZPHRE9IdrDr6evzNizBV/Ay1 +2radO7mNZmem52ZmeDrhTrNHJ9vYxeyD7eeanKjxaMfuNqsBx1WxTSnNJ5snmoxobkrdjlK8+HYv +YPDLOyutXZXWHhxx7h5Wbe0A6MbuRvMGu0MSDKmLWK5kQK3+cIi27yVuSNumNj1W2qm2eXNE5GCK +JhRRsKkwnZNEFn8FaY4wEAgEVocAVgCLaks6XINVIOB92GikNYp1xrI2J3lvSkIe5mJoFPbJctoo +QiQpUQ7bioNDkuxtSrfFTEYj7KytOtqzPKlmi5kJRhiLiBuLCv7Zm5j8TfZWBG9IUIQps+LsYpxi +7GKulGxYQgwis8s2YJnjWppn/wkLZGY6meVF1txfcw5svGZi0Q4EsBHU4oTIYa/xLdLWIhzhNN4l +lxZbaycG2Yso9kKL7WNiUxD7nmyBszpO++Un5Xha/RJQhDKfidFGSHQhFHg5s5uTp66OHqBz2Rsm +L7GfHvFzVQVJDGdt7MxW8zTzVbl4lDG/tXOvdv4WcuVFD0Pzi+ys7dm5e8/czOyNN+zHU7U9dmXW +L20u2A6ALLXm6tNjtfkavaWWXqtl1jdN/JoR7VhW60PcZNwdcLhRmLYv75gsn1It7+GsflrA7W13 +uD27WW+aqO6Zb97APZq6ifUJu+whzO5qonaTWSQJmI0fm28erJXs6+3d94/DCCFahIcFO+p8aVMW +q0BcgUAgsEoE6LR6Xm7PdZmaAcMTvS5PdXOlbPT9tg0yNy3pSYMf4wcP2ORNo4mNBTwkm21MQ4jp +TP6H8dNAYmMRjiBun5lHFNnepeQ6pP1AtrhkUcQxdVggDjfAQqLE9hjZeJWGLXIxENEu+5qNbTFO +1SAbM3uUbMaTU+OtBDzjUpPNwBzOamfJ443AsLrhIzB+M3qZMO+XWJEwbQaSoc7ayrhrU8FMQmMv +y7yMghq+dWbLnLbzaSJti0rNNIhMvo0ZVXRaSWsSDtA5IElFpyb3qEXOz+keon1YyxbdJ1/GZqY/ +PdDA6kC4CGYmd1wkrePQyeb4UaZXy81Jfm/UMYU/tzDHG0Gt2jxfprepDpZR7Zkq2dTOeqr9yPzD +lPKOTWVsorrPTjsq7a6Wp9KDoN2T3FeF+o1zyGBp+0LrmN1Y7VuD+9dU2dNeuqx3oDidAsF93yhP +C09C/zlyQjRh4UrPj9YXxEd3N9EuMv4EAoHAcSCA2Unv2XVU0NMge46DPZk2uqTxwDo5GclsxjGZ +zNTtE1MDBsbUXspEXpKUpYHBQtLMaTTnEJcRf4QhCEfQRhQ7+N38hrQ+ZUc72IuuGGrSEDRPkyHH +1jDNwhmXswkt3S7zDeyPmVrTrK3GtuvJLDUcALAjivTGKCMmw5fVJNXYdnClvHY4E5aSHUGcW8jY +yzuhbBEyU4oh5b0UGtIBMP+b6tMzxaSsWl1XT2aX1BLGkFn0yy7JmSI5P6e7JeEsK+C5vFZ5FjFz +jssXCM+e83syc4Eh6Z4VgDnfPNaamOVOYzKY3eLcF3aEdLXBtxhq8kqTS8qEhN0l6R8/oTms/BMx +NjY5ds6eqVtQE2qbbroBlSpNVvfOzx7TAwO3Q9s2c/+ly26QRKeHypRamWGWhudJCXhDIESLyENZ +05wjGg0QHkphhIFAIHBcCDDByZIR/tiyWrqHMzpkzrQoWpKdSF6mGUoEuOi58l0JczNiHmPq2CaT +Bg+MEOuoyQyiC++Tha26fcYTRxPrlzLbQIA1TPuYMLmY2JRui6tMCVtDEEOfCaepwuT1MnGGEWXH +Ep4oWm0nMY23kOI4l45k02/vFdlcn03c2bQzO48maphSW1jjEGDbCIyj2hnz0rhJMWY704U2EYPD +IcVQMrykwdJ1FZgedaIrx5JxtiCm0VlZCkm5nkKd8+iAXLmGAp1rKCQVosvqR5XLOOFKtk/sbZRu +nJk9mu7A9q8KriCLBbUJC2iZ1dRjOH2KKOcIsvI6P1OaO1ybnx4/WqpPnjvLG8BJiW5mil28KI6I +Cq2Wd3Jjcb6VadYPyL3tRxZb7zBBSrccHDjcmKmOzVV5HYDDGAAAIABJREFUmyddJInwaG5Bc9oF +ugnVJMJAIBA4TgTcvmFTO/15OJU+ItA/9STuJoURANqiiwa1bXptyte+6W09nVzkTVbSyjb3MW33 +ZeQwy2wDidlfSFxATmXlyD8sn3mNKGPhFauKA2GGGpO46PVi8mwMs029NiuchjHEzB/Vc4ONihw5 +YPOzVp6tknJY0viE+Z3sG+L90zRtizNqb6pQ0Wz4E20ecmofUXFEdIeOUnfS8XDArZB9AKc7SXnF +91QnSIVWNA89l5iFChSiklHzCYkOD4VLDp+rZ5W6mdLczc8rz/PUnslbVkpXTi/cyG+fbhxLN8Rl +SnnYssl/M3L21rSRdrfOHpyYPbSbJzke7xZacz/47nfOOOvsHTt3citSbveV8llAibXKroXGAXFQ +5c+39junAtql2CyO9YpGaXq8tIOG5JepSrermDktDgI5oagKjTAQCATWBIHUf23ViFcr3b62NdP9 +GAi8mJyGmadCw2kLkMtea1m0OZZKWgpTRovll2QRY/SRKoxrmhFO5xAx48u5S9hNy2y1ZIji3Rcz +pMkTxefE6WyXRz58VdsabJe90pJmh9MhC1hy26eLUjOWyeOEpddUGIBQRwl+USJ0UuK8ThsXGT04 +WeJxkYIiV1HgeNSJXNhppeahknIOtKIkiUgMjeRtTeIDlEvmetpCfhtkBPKAWcjl8jkhzMURrVzK +nqd6rlxtTrtATiwroCKYn9g1cfPxynVzjf1122Sb7Bpg2Ouqk0z/N8aOcV/ZFnI2tnFgFpa1Xpk5 +MmVTGyV2C3OUBziV919z9fz83K7de1DLxb0kIq+S6Fp5z8zYAWZ3bcnBXpixvUj24GZ3b7q1ufNJ +1YeLoEtHS6UzKILsHtI6v5wvDtGcUJQwrkAgEFhbBOhoKKSn21adglEhgWTS+hXpmSWwGE1KLacZ +Pfp/e0i1oriwXuaS2rbK5K8az8wjA4QdK8g8WpU39iBs0y1KkdfLl6ZWWtuLTla3pFQymFAbtuwg +NzulwcYiFp1qNUwo/9n8tn2+LZWZqpQq2G5d3nZTmy4nholKZhWhcPOM/aIFvsuLUGoeugBM54vw +LM4fICwZDdyIQeRK4BSiDpoID53vZXUTqEJMoVKVy/ndWeAUKtCTk2dctiaqw/bamdvHTq83OaaY +p7Y68yO1yg42HHFnHZ2/cn7hMGfqkzRZ40SR8ekDU80F1vrn7VDD9AhotWq1bty/n3O8du7ZQwVQ +232pYpXytlpl+2z9mEXTncsDoVlM7sQUJbQ7nQ1K9hPw/7R+CEop2FSkxCGJy/R1iAJNNK5AIBBY +WwTosnRz7Jetp6oHFgoQE6EC36MuACGxNif1Zw0iqJbVNBeW8jCTdjI+X/9it5L1eR7r7dSgqjEq +7KS1d1lsQxJmEu9V44a5jFZH8zPRQ4otgPL2i31UdJwT+VBokvadNDu1wfR3BjIIy94J88oPaJqL +9SSoyYryIp/r6Rct8D2L+J7qBAJ5Uk7nST3lYTpftEJlVFIewsdgEHIV+GIq1I8OnROK5mI9af1M +JKFf8CpUca7Eo67EOd2Ey7gqEc7PCU+iJqiqlrcT2ntX6TLJ1tiO8QvG+Lhqc471hcM3HjhycHay +Nrl9V2V2do47kEWDOT4Nl46+4vuCRw4f4lsOO/fu022fl5XRpdr4Hnb/cpOmtQgznzyQahKYMNnG +toXlPmriHrdm+TA5OqmXwnYVO3YU5Yt1Xkpn5QYZCAQCa4mAD/O8fNnXag5TIL3XByPJw/GMJPkD +sxnX9Cit0VMDDcJmdxkgbH6MiS+zpIwkNqphH3mfwY6ktzXf6qTNA3PMjilnrMOOpok2tMFX6IQq +YPKdMTqvZ05LUmE/fi7TU5KMPWVypss4kadCi5+HEsg50IoWknKmVCXBReE8KmFx8nILMh6VvIZv +l1cFukMwF+zdRLdwzqEUZVF2kpwjMVXDs3hURB66jBNKRbMTniSiZ5IzC8o5u5itSftO2TZePXT4 +4I0ceblj+zZW8DmaiW8mMDViT5Dcv5x9vzB/+IYbduzZo+c8L5RUNROiWmLl1RZw2zXhXlePTLO+ +TAhzc7XNra3SsCsBV3UHPwcXWQhRwqXsTovjfC86iEAgEFgPBNyQVtOZRYPMqndLjQI9ayOZXACO +hiRUQ9Hv6f2MNTCNti+s2eIrwweCNtdlHqq968JjPnuS7OOqPO/zcsI2M64USkZdbkRFqGgvToQq +6UwyerVzAWcWiIIMUQRyJURhit+dV6kFvkeVKw+VZOpSQU50810JhMRy4Tx7TkvYQ43C3RryLFKr +EEkuzigWoVDCOcfx0c+kaB7mwjntMp7RCcQoSAJ5FpWeh5LMayU6zyu1/XTCR4BcEoMQLXnC7mvb +jh0Tk5OHcFiPTk/ZOcw12xyHy8k+Bb6pZ1+Kq3K4Jh7tzj17WctHAzoJvSBoXm6eHN87PXcDt7k9 +NMKyfXwEdnKX3bhpNhiC5Q0Oum5WbfpXPyLaIBCxuibNoj2EiCsQCARGgwB9kOdevrJBhxyqRHVa +hoN+0qYxjUoQZjI7UWWg6xuLAYUS0zwwemDwdTOE7VVQrGlSrkFNIUm6iEIoi5eimni0QJAKR1lc +UkSqSDtVHOfnWUR7EoQyepZC1PmS9FQncj5M54tIjMUfw6NOeHaXd44IQhHK4mIQPvi6AISYnpTn +kpiSXFIKiXLlNFFhReiEmIpahl6XC1u2pRc/N0XAKxQkNc6E0AUfwgsRTXbnSD1R6fQkJ5SUyzud +a3YmBLDu3nfK/OwshpO5kyneorECeTYsY19ZZG0t2GeADh84sHPvXs5sUtEm0bHf0BOV3UdbN9jz +ZTr7F45246sx3iaYvMxVbx6GoybnPx+5VMl+VUUgrkAgEFgvBBhqUsfUOwGLI9Gqy6Mn52OT+jzD +4uIgkgYgpnPhsLJKkkYECC7KhQ3hIUOSlCiED4GY5yIKE474ChUV32mXhOPMnEjsduB6JJAnddPd +RUsm50Mr6gpzjpgScL4IZxZkCnpcrJBLUc/rqU6QlKfmNDJ5FNqNqyfBzC9hXgjzaC5coHUD6Ncn +C4QqCa2rIK9UmHllVMOco1y5BhUEh6S26s59JaYXNDjqYiLYQ77ntNNnjhzha6wcI2x3uj3EMGnL +1+arfAOCE4MP7N+/79RTMavKQj29GuPsgSpNtsZmSTIPlcdPpnzlttqGJ8vBD8Jfvvvaah1j/7st ++CYP1Vuthkt5hIFAIDB6BMyqcri8dcXVmlQfvzRU0QYfKUTkAp6ksUxRjZ6MCz6MupKcqYEDGQ1D +5PVLwMGHk6eKk6c6rSIU9VxElV18T/Uokv2YSiIUgZiIxFgE16NqjsTELMjnUc/lhLLnMv1UeRYR +eRZPIm+uMFclmpCrIANH2lKiQaeoMCTkcgFoiXWHSkJS8vqJFdUtIYFcg9R6KCKvnjh5Wa4EMdSS +5MqV5FGSvCwnuhXmykWjecfu3XOzfDlw2r7YYJ1KP719sI+teiyKHjl44849+zh9q5CdgqZqe4/N +X+18ALN3yDpmVbdeqjg/BN87PDpemkS4AIJnDyIQCARGjACd0fopZ68xmDGK9CseKR9Z+snAT8os +RDjPItqZLuCq4IjOkxieVKhSNQ5Cc/mYWIiKn6eiVuXmZcHR5UwIVOXRbloC3aHnVWU8o6I5s8Dx +JAgpcQGP0pZu/S7mGgpint0Jl/S8JClVoQsUovBdDEIFQfglAY+KEBOQiSrMiYKwJ7V/lXTzYN4U +RVXO97zwuYgWCI8qSfJeB6K5Wt0qrp+oJF3eCWWUtgKtangSFbIPwo9X69OznPSFX0kt6Q8UPFWr +8QYOU7sHD+zfe+ppfBQn14+GyfHdx+auwwElV8IuOazkt4aiwAiL2U3Rmm8e2jZm3ydXk4vVsBxx +BQKBwIlBwM7jS9122OLpwIXhgJzOdMLV5R2ejBJwpoY2hJ2ARkxRZyLPRVQTwpInzN0LBOAoRBIl +Gp0tZ2d0dgGI7lbA1IV8h7S/ipqWLr6Y4nsopjI606OeSiWddjFxeoZWlaXDaCFXITWJLxl2c3kX +djFx8miBo+wSKISelKMqJhxPLeQiKnlCvxCGdsuqLHA8r2uD8ItU0SI8VEYPcwJ5ol4QhBcBX6lw +lMWTcsKTEHZ+dbxW3lFZmJ7mbWzzNhHCuKaZW3YtQVx/7bU3Oftsv0WVsVrhGMwdC61DTBj71d7u +m6Z/jd9WwgzwUZcJIhAIBE4KBKzn2nN0Nb3gsgZV8jFI4wsDSYGjMpyvVEIuJTHKaFwT4SF2FBoZ +Ul2GqPJ6kjiENoilsVLv4CvqqRBcMEXkodekwBRfxZGUR3O6O0mp1DDPW6BVfzELSUSlM+cXOEQL +HOXKmTlHfMvTaYjTXlx3kjiuR1kGhJLsCXIhl0vqZ/IQvtOFLERJ5RJftELnSIZQdVCoqKsVoSy6 +8cTpZ1wl2TMko9cHATuua+fO+aNH2fTL3Ytd5cbls3H6gPxcfR6zeuZZZyGZ389TtX0Lc4ekn8Yx +f7xo5VNbzcSml4TnGkcbjflqdaJnZYIZCAQCo0eAPqtBgDNy0yuk/auAHENGnt7NUarzpVoDjfKK +IzHna0DJhxUX8yQZVFlTMsJHiUY9aORFi5AAIRccEchDFELVJA9VtELxoXURhVDohEfbQtmfPMlp +1TyTWlToOj3VcylJ0Z7MPC8CuqSnE2tXnqgLi3blnisnCqmqvwQGhOQS2i5T0ON8ES6sjPrJ/PdS +FEkXg5ZCQifEzKNS7sIQuU5FuXNgkkt3F0y/r7xcmPmVVyPne9EQunieq+7ZM3P4MJuNsKv2UfOx +Fh+kX2jUOeekPjd/w/XXn3LaaSgBWJU7Mb6jPD/Zas1yi3O7ybtFwAjqRsixw1ZJ/k1z+AP7hfM6 +BB0IBAInEAEGBxtJeH/O+usyVrVHPRk4eo4vzocgGzIFjnQ5X6k+rIhQqug8ZJzS6IMSJxBACVGp +glDFPBShyqj07pC8zoRWVCH8xGgHRFWiyyhBYkoq0LmGnO7WkKeKdk5O5EnQuqQN2tUW6AFihSRF +PXTNzhlMuDyEg98zC6leW0kqC7RHySjaNbh+ONCKOuFiBUJiSbE9YHGf6HaCQ5JuJxGSIfSbCj5R +FSeioFxJYiLs1859+2aPHh07xiG9Y7isdT6BykHTvDPWbB07ArPETmBXyxknk9U9M41r9AArm+o3 +ZlpJbVtW09aaro3t8lp11yc4gUAgMFoEMCL2PMweJcJliqbzdw8lPZkocj4EUTIWOCpMfMkzeDHW +aFyDUC5C0WTX6CYxolySh4MeqRIBX4RCVwXR70IbSR7mBLRHJSMOodfNOQUBoi5ToLsl+3HEJ8wJ +pwt1S1LtQEkFSY/mkk57FnEKURdbETFYCan8TCgkhPaoCCUpNS+UVEVF9IvmWXIlUq6fRvy8IFK5 +qbhIkgypXColJwr6EdAFXwTZIbbv3s29gsPKp+3n5+c5txcPltdW6XQHDxzgVOpdu3Z5xsnxPbON +6zmL31dSvRRxDC0MamNsduHwttqZSvVauXAQgUAgMHIE6MdWJu/SLGtSTQ5xuq5R2dWTSbrz24V0 +suSdnyRGLkky+pBE6GMZUachlOQC7rCKg7BfFAWt0AmVr6hXSQShCGREJEbbyoouhJLMxaiGZ8/p +XBJ5ov044qf0djVc0pmuwTkiJOlhd6qLFWS6o7nkaOi8UfxAQrXwSyma1yfPJdo5TuTyTpPqyiH4 +sQi5JAChm01iugNT+qKAhF1PrhkaPlfOJMo7NpR69MgRzqKy7/w26riqHE6Nab32qqsmarXaxARi +aB6vTlbLO1pjh0wH/5gv5vwx+2tPwKY3MUldaBz2mnhxQQQCgcCJQ4Dhy8yP3hxvDxmDa6NuX5Dp +yUTG+SIKIVG3lJ5ELo1xGsugRciCuhhDifJKWHzywvdLlSQqohCSRRwI0QWiO4q8mD2T+qU634sT +J4/mMijPBXJaST05MAuXCzu/m+NJJwORV49fjShXv5+PCpPqoerfzSm0K1foNITfbKIV6kaSmGhp +U5U8FOEFIe90gdixdy/bgKeP2afimAPmqH182LQNuHTNVVefc9655OVC4WR193Qj7VTi5k36bCUV +ItlXO2jJnt9QMtts8XHhJQdGFgqNaCAQCIwQAZmbFks71meHLFjdviDck4kMfEKGCRFOaySSRVRY +UCgjSsV8xQsxZOCoLC8RVa5BaglFSKdorwBMaEUVilPgJ5FFMUWl0JMgBnM8VQSh61Fe16CkXN6T +nHAlTnQndXNceEMQ/eq/LL+fQKHVEiP0uwJC9w8Ed5ffS2S0fpEuKXG6m0AApiuHEJ2XDmfXKadg +RBeOHLE9Sg2+9GuTwGzfnZmZPnDgwL5TTkEesfHq9nKTk67r3F/847HQbjT+pQ6L22rT0mW+4zRf +b0xXyrvyUoIOBAKBE4eAvevGgo895/LIPHw96PaMIAV5DSLdfMRcXjKe0YchcTwqeUY3z4gAqRry +RPvYB9+vXLPTIvKiRRM6IRl0QogpIokYMi4pTi6Tp0Lr6s7YSVmiH2ZBlYs54QLiFKIutpkIbyME +P26/prlYP4EBfOVFea5EN5WYHkJwoaoQJvZiUq6nZ7mI8mmaPaedxg7gmZkZZofqaY6oyfd9yyX2 +AO/YuZODILjJq+WJSmmqMXYk3XlmTOmdGGDeT/VummaD2fM0PTEe25R64h3MQGDUCMiIMlpgUzk3 +bfFt92Eq4kNSQXhZvg89DDHQCkXY+JQNoM4sEJTIuEPowiIKUa8Y2UWL8GiBCd+TnM4J5HMBzy5m +HnpSvywSKISuPM9ekNmC0QIsa4hAt2Y43EVc3GBOU6KYKlq0cwrR7uohoGdBKWTeZd/pp++/+pq5 +uVkWcvkkTbVVqfNQ22pdd821Z9/spmhAslra1SodsaJ5ITWd8yD7im2Hw7MfHYCPzdWb6UvmqVQK +ImN3BYITCAQCI0KA/pe6oH1PLbNlKyhdw0R3hmX5hc6v4UC5NEi5TmfC8SR3UsWUMKmeKyfysgq0 +ooQiyCWiEC3wTTobvJxO7MVBzfl5ZVyVM/uJuUAQ64cA4OveowhomVJoLJ9uNr+pRIiJgKfmhPP9 +N1UulSLLigwbffedcfo1P/pRuVTmRVP7RnDDziM8dvTIsSNH+HgcuWrVXXP1qyrlxTUZu+P0rfJk +YqExq7MLR7wINMcVCAQCJxCBjgli7tcGhlXWRMNHd/5l+T7ueMEogcll1UmXaIUSgw2hMM+Yp0KT +xVP7RXMZp0V46PxciaeqiFzGCy0wC1EXC+KEI8BPw+2kMH9WE8fvtPzGg/aL+mMs82j3b+1+qgiE ++YgN3327cf/+NIVr+/L43gzhDfv3c1wwRLVcq45tZ6ew+iW3s3oohL2lmiaVCOrNo7jBJR2tdMKh +jAoEAoEA5omzCVm3XNF6ajduGkcYLApJy/K7ByCUwBRfQxU6pVlJKkKcQnH9otLmqYo6E8JpySia +hznf9XQzC3oKkhE9ORHwX003GFEIp1VnohAeFgiS3LKKznNJoQwqoYrbyRFLR4/Ozs4yWWRGNH0P +DrVHDx3etXcPPXK8vGu+ZCdF2JW2KbXPfKiP4dlaLl5ibc7Vm7O1MtbXqucNSXkiCAQCgROBQIst +EUxCLfHrVlkP79Lq4a5lWb4kESOjwu68cKS2oFySYnpBnh3CmU4o1aMDiJ56CtlzmaA3LgJ+G+gm +VLRwszlTfBlImLKXMLlyGjTgOCZuUOGQa+/pp//k+1eSg/7HQy2nASN89PChyamp2uQEb6nOt+iX +bE5qn/ErRebT8lIN/3hdtdRYaBypVberCLKrhl5iEIFAIDBCBLCjNpVUzbv9mhTvQ09B22C+C7sY +RF43RZXqwv2IgphHnSBjTud6CvxCNJcMejMhoB+aML/r1EAlOT+XxFL6G18SUCg9OaeAFZ8u33va +qfuvu47ybFWV7UdNXmFtHD18ZN/kxHhle6nOV8qnzYKyU0mZ+ZyqyXHrWohZXWgw/WvWVlUqFBHR +QCAQGCEC6oljVZaDOl12LUv3Tq4+76r78RHwpG5hcQqqXExEd3b4PZk95QdIFgqK6OZGwO8EiO5b +Tkz4EmPmFlqhO6kQLuBYuSrJw2cGmFN/jx47Ui3TDdPeqLGx+dlZzlrCTlfHdi2MTZv5lIp0jhK0 +PQynhVX2vy80Z11/EIFAIHACEUgDAh20Ze/HpX66XpXR0IN2H1NUUj9+ITWvlmfJmYPp7izdnMEa +InUrI5DfLdB+DzstAn5uUN3EuhgCLgmBMCHXnlNO4XAlLHDa09Aar3AGC8dAzG3bub1W3jnXvEbr +MvRUI2Rdk7fKTiVWWOv1Wd+mpCK28o8VbQ8ETjgCuKh25oOPFOtaIUYQ15+XmPN7Cjizm+iZV2ID +krr1BCcQGAYB3VSEuoGdIK/sqPgymTD9PofgUnYIL2ty29TuvXsOHbTDCOHalw1LpeljR7CpldK2 +SmuiVZqj39iyKpPAnWzWkXgSTicUNpoLTB278o5I/A0EAoGRIqB+TW+1z05lfXxEldDg4oV116Ag +4JJOLCvgkkEEAmuOQH77QcuIchvLW6U4aKwsUdHIwOFSRghViejufftmjk1jTbUKwwEsLKvOzc7V +OFy/un22OWeTvShMr9DIlFpmotjasZlmk0Mj2pfr7zDibyAQCIwIAfqyXcwfMQ6kR+QRFdyzGFVm +RWFPPcEMBEaGgN+ulIj5VBTCLzjQ4iMDQejWFEJXpVrdtW+vKSnxPWNzP+HPTs8gXy3tTlECe+9N +dti0JCsrfY0m0792JXYEgUAgcMIQUDdUpz9hlYiCA4ENjUBuMkUTypTmIUyaqTC3f2YMW60du3ZN +TE7SFZHhWOAWvmp9wVze5nYMbRsfthIm0oxnMqA8DOMGzzePtgXiTyAQCJxIBNQ1WxyAxhySnn1P +ZHWi7EBggyLgpjQncoPa01vFlObt3Y2r2jJjbEaUDolVnefTNOVqacrE8g6ajoCAZz3XXqeZdlVO +5JqDDgQCgZEgYAMA3To9+uY9diSFRyGBwGZCILemTg82qzQfE+hXbXJycvs2jChc9hyxtlqfnSe1 +zNGDdryDWVU5pnRa/rFrCQ7/Gs1pIYnwZoI02hIIbDAE6KR835hDvK2vRmfcYL9eVPdkRMCtqRPL +mlWa4WZ1+47tFT6+WKnUqnZiKF+Fm5s5VirN8wkarKm80jSFbB3Wum3aqNRozaUtEW1AwrKejHdG +1GkrIGA7FHkITi+nqqNuhVZHGwOBdUXArakTg81qbgJxVau1iUq1Yl5pubxQX5ifmW/Wm1pGTR5s +MqQ6/AGLmv7VGwsLjdimtK6/aigPBIZCgF6PnHVQ+mZcgUAgsCYIuDV1op9Z7S6O11WZ0KU/krc5 +1mg1K/Mz1UY63sGE1VEJ6bUs2iRftdGoN5rz3aqCEwgEAqNEgD6bdvmn41li8neU0EdZmx4Bt6ZO +yKwSpe1i5gS0HFYO0E9HO9hzLvO/zPGWG5NVy2QGNfmvHcuaeGZWy6y9Lri/64TSIwwEAoHRIEBv +tVfM7Yk33NTRQB6lbCUE3JrmBJbVjavsaw4J5pApXz6hCmG+aJlJYLb/TpTHqmaLYaWdSpoKNhML +L4XNsTnpCYOa4xl0IDBiBOiP/EtTSGZc4woEAoG1RCC3poPpvFRsKq+nYi/NBS2PNeql+hxTSime +jKif0ZKMrJnaeqNtU6UnLGuOZ9CBwGgQoJPSYdmQb+up3Y/Mo6lElBIIbAUE1L/cQxWhkOYXel9t +YoJPlM8vLNTrHFfIf+XWQq1SSRO/Jr0ImBnX5LnyZXK45t2afxtXIBAInBgE6Mu8SKOPXJyYGkSp +gcDmRoA+xkUbsaCE0G5ZFVWqCSUxocEGYHblm0m1d2iajblas8GRwumNmvTxVLOstjfYJoQRaTR5 +nSasqcCLMBA4MQikZ1qWb+y8X5sEPjG1iFIDgc2OgNtLEQqxrG5ccwGBgU2FSa80L5TZpHqlzF7C +zv58667Jvjpy+KlhUx2NIAKBE4RAmkSyc1rsv2xG6QRVJ4oNBDYrArk1zS0otCwrDXc+dHV8vFxl +X5Lt++VU/Ua9Wm6OlytL4NHrqmZc7SglDgeuy6zaI3L4rEugikggMCIE6Hls/bUpqeiEI4I8itna +CGAmAcBNqUchRAseDO3E1GSa12WqF7e0XJ+37xxz+cMv1hRlnenfhpZUJRNhIBAIjB4B+iZdEgfV +bKqRcQUCgcC6IeBWU4RCm/9d+jE4t6x8pqa9ImOfXC03ZsfVY+mv/k8rNtaDS616M7b+rtuPF4oD +gWEQ4Bk3zS21n3+HyRIygUAgsGoE3F5KQ+p+9olyv+BDa9Io7f4dZ9tvOiufr0dN8ATMub62mMqO +JzOw6V96u8a+YmOn/tolJauuZGQMBAKBVSKQvtWYXFV6ZyzArBLFyBYIrBgBDCd5CN1JlVmVItGE +TP+yWZhT9c0xbdWqnK6fHoDJ7f3VTCj/l2zr74rrERkCgUBgDRGwB157rLWH3/YT7xpqD1WBQCDQ +hYDbTicQcSOaM+Ez/UtIH+Xxt86nVBs1M8XIc3aSvlRDx7W4fZ4mXqdJWEQQCJw4BOzpVlv1rVPa +825cgUAgsN4IuAWlIOiCq+pmFWJ8YoLXWpn9NceUSd96zYjUV+0xuHPJ0DZbdoy+5n47KfE3EAgE +RohAMqgETC3ZdzDiCgQCgVEiIPNZCPMKmFmt1fjqzIKd/lBfmGVKKW307QilLty2svXmfLPZUIrN +P/nscEc4/gYCgcD6IkCnY/sD2x04sSXc1PXFOrQHAhkCbkfhOe2EPFeJT27fzhKNnVDI+6fz46yu +5l1VXVgPxBhdOnRWSJCBQCAwagTsUVbn/S7ueRh1HaK8QGDrIoAdpfFuTUU7B2J8fJydSqmftlhS +bdXtc+V+yU/lO6tp8YYzH5bY1HBVHaggAoERIGCnVcXPAAAgAElEQVT9ka5oCzp2jFLWU0dQeBQR +CGxtBHI7ChIe7e6JnFPIYqotlTaxqVVOKfTLPNTUjSHYxmRbldKSalhThyiIQGB0CKRuTBcst5j7 +DZM6OuCjpEBgEQFZU8ULllX2dXJySgSWspFOU5J7qiy4pukLqiWbHW41wpouIhtUIDByBOwx196l +Sc+2Iy89CgwEtjQCbkFBwemcEL/Ch9/G7b1Us5fNcWT5a13XKHNTMav2SMyXVpu4qnEFAoHAiUPA +5n71vQv10RNXkyg5ENiyCHTbUaDImZyplDoor9OMjzV9rSZ1XxNNJtZeN28fo79lkYyGBwInEoHU +S9ljyFEtLKrG5O+J/C2i7K2JAIaz0PDclHpSbYIlVfNG6wt4o2mbkmxskrBTlhLRbC3w16d/nXA9 +QQQCgcC6IkD/pd/Znods38O6lhjKA4FAYAkCMqKw3JrmNEyi5WrFthLijjLZ26za3C9fVsWsGmE7 +kyy0N2nMpuoKg9pBIv4GAiNCwI966DzljqjcKCYQCASKCLhBdQIJp3mjhgsDam+SN/iu6tLsdhqa +LbLW67GeuhSZiAUCI0TAHmT1rbfUJUdYchQVCAQCHQTkiSoUz02pJ0FUxsfNMeXz4wvV9kKNllFt +iqnUSruVNPcrJQrDW83RCDoQWFcEOhvyW3agqLrrupYXygOBQKAnAm5Q3Zoi5rRSOaTQTCrfn6kn +L1UBYTNRTAXb7G/bT8WUhjXtCXUwA4H1Q0BdlZAHXTrgkhNY1q/U0BwIBAI9EciNqB9PKCbR2kQt +5eId1M42JZ6KkymFn+wqfzlo366e+oMZCAQC64pA6nsWsPnBrnUtLJQHAoFAPwTU+wp90PpkupSr +Yq+pVm1PUqPSqKc9hXoMxrDKhrZ4P7V9hn6/goIfCAQC64eA9dc0wVTm4TYdpr9+ZYXmQCAQGISA +dcZ0JTPaI8BVtZMf6KrNcrlV5eU3TKkZU/7X7l/rzYkRfuogpCMtEFgvBOSn0nt55o3XU9cL5dAb +CAyPQLctJa+YyaaOE8LBVWWbkj0Su+pE2bNxMqgKPTGIQCAQGA0CdtiD3k+1193iCgQCgROEAIaT +khV6FdzEisP0b7KpHJdkH1LNL9sOYW+pJqc1SwjjmoERZCCw7gjYdl97ncYKWtpH173oKCAQCASW +IOAG1U1pgWDrr3mmpVKTo5Ty/prWcEgwi5oZ25xeUlJEAoFAYB0QsA5rL7aNcTx30+i4AoFA4EQj +oJ5onbNzUSOR1fFxjvrluKRmvWofJy/ZjqTFCWC6sM39xgb+E/0TRvlbFgF6Izt+OfiMT9OESd2y +t0E0/CRBAMNJTRR6lTqG1ZKY+C1XbXcS75M3mzqs0B+FjeDkh2bYVMcuiEBg1AjYdkGmi+xYltj4 +O2rwo7xAoAsBLKgmbHNT6jQErmqr2eDIX75O0yp1u6R05yIThWTsKioYgUAgsMYIaNKIbYTsd8C0 +5usza1xSqAsEAoHhEciNqGjyyi5y6i89tladLLNkk3VZbKYt5Ng2peHLCclAIBBYUwRaY3w0yiaA +U4eNJ9k1BTeUBQIrR0CGM88nmyo+IXO/vEpuq6aNCmLeaWVKJazs9qAcBjaHMuhAYN0RsE2/TDbF +Yuq6Ix0FBAJDIuB2UQQhGZ05Xq1al7UpXr7+llTaW3CWblO8yciGNR0S6hALBNYWAeutqftxjlJM +Ga0ttqEtEFgDBGRKraN2zGq5UmGjEh2X7fpmQc2Mtp3Vzt81KDdUBAKBwKoQaE8YldmhlK/NrEpX +ZAoEAoE1Q0DWVOqcFsH3ydMO33F7D67tmJqTasK4rrGeumY/QigKBFaMAE+8dEE7Qj/1zRXnjwyB +QCCwtghYZ0xeaa7WzSrMapWPk/MYTLettJ+K26ZVJjYZ1zxz0IFAIDAaBHibLT3esixjnXQ0hUYp +gUAgMBgBmVVkZErdyqaDCcfS6zTsUrKZX5v4bXurvGUes7+DcY3UQGB9EWBXAwXwvy3MxMPt+oId +2gOBVSGQm1UUELUvvpk5rbQ4/Yy/9OC0WQm6PQO8qoIiUyAQCBwvAh1DqpP0j1db5A8EAoE1REDW +VAqdNqJcYp9SqcWRv/Y6DZcWVu3J2IysPR7HWzQJmAgCgZEikPpdi4NDy81mfD51pNBHYYHAAATM +NHZdZjATnyN/2f2Lg2o7ITT9a3yLJ4tqKzpduYMRCAQC644AqzO1aqU2jlVtP92ue5FRQCAQCAyD +gFtQEbKmbZqOW6mwoGoeqyWk6V+UQpc5xUVvrQ5TSMgEAoHAWiJQqzKHVKrXW+mQs3i0XUtsQ1cg +sMYImPVMdjOZzkqz3uDL5EwAt4uh/0J2ZoNh2v7DlGWN6xHqAoFAoA8CC/ONI0fnZxcaVU46i/N+ ++6AU7EDghCGQ21EqsRgt44zyfzr2wRKshmw5ZOOSUUuvMK5L8YhYILBeCByZnp+cqNuuQaaP4nzC +9YI59AYCK0eg28WEowtl7FEyO2qvqPKH/+nC7IugF/Mt5LgCgUDgxCBg319MXdF6Y/tZ98TUJEoN +BAKBHggkk7noniIhs1qppu8zWqdlz2/qvATJc+2hJViBQCAwEgSsK2JWbRthbL4fCeJRSCAwPAIy +qJIv0BVO/bVjCOm4WFQzp8lV5U/4qcMDHJKBwBojwDpLi5doWk2+HhWH6K8xuKEuEFhDBOSeKkQt ++3517AOW1Q5Uwq4mb5U3V9ew0FAVCAQCK0OgY0nTqow97MYVCAQCJxcCbkeplltW+zRN+50ZHdii +12lKleSnJvsqK3tytSVqEwhscgTs0dY6anrUtSXVuAKBQOBkQUCmsV9ttBnCHFT7GI1tA07Oavip +/QALfiCw/gikqV+K4fupzWYjXlBdf8SjhEBghQi40yknldwQ+Knpi294q7ygansi4CV257RCPS+v +sKwQDwQCgeNBwN4Sxzlt2U6H+Cb58SAZeQOBdUFABjVX7Zz29G/apiQnlVdsbBt/1+VZulKCEQgE +AmuJAPZU3Y29gmlD/loqD12BQCCwlgjQV9VdRXA+IdoxoukTyEZVyuO4rWtZZOgKBAKBFSKgI1Z4 +141jQmM9dYXghXggMBIE1Dfpq5Qmg0qIn6oIb9So65ZL2FSbBR5JpaKQQCAQKCJAF7V9+J2zV2I9 +tQhQxDcHAvV63RYg7TXszXPRb+3NGVtPTS+octRvedxeWk12d/O0M1oSCGwoBPRMyxn6egjeUHWP +yp6sCHAzfeADH/jiF7947bXXnnvuuTe/+c1/+qd/evfu3etRXwo688wz73znOw9Q/rCHPew+97nP +s5/97AEyPZO+853vfPSjH/3Wt751/vnn3/e+973jHe/YU2xubu5///d/P/3pTy8sLDzqUY+6zW1u +42KY83/8x3/8yle+cve73/0XfuEXnA+B/Pve976b3OQmv/zLv3zKKad40je/+c23ve1tqKLa5AJM +XE+F7qTKT7WXU9mglL6e2hrjA+WLBz6Et+p4BhEIjAwBe8DluZY9SvbdKD3sjqzwKGiTInDDDTdg +DJ7+9KdjaW5729tiVp///OdjX9epuf/0T/+EcVqd8p/85Cc//OEP++X967/+6+c+97kXXHDB7/zO +79zhDnd41atehVXGRnbL/9u//dszn/lMzjbiO8QPetCD/uEf/sFlHv/4x7/zne8Eh7/927/9/d// +fedjNZ/whCdgqr/73e+S5cCBA0r67Gc/SxToZmZmHvrQh77rXe8qWEdFZVPtLEK6sO1LMp+1YnO/ +dnkpQQQCgcAoEUi+qR3CwndpbB54lGVHWZsVgec973nf//73P/OZz5x22mnexnSDeWwtiTe84Q2r +Vofhv8UtbvHnf/7n3Rre/OY3Hz58+C1veQvm7f3vf//8/PxznvOcD37wg3/xF3/R7e/igD7ucY+T +klqt9nd/93e/8Ru/QfQTn/jEpz71Kdzcqamphz/84ZSFHb31rW+Ntmc961mvfOUrMZ+IPfKRj8Rg +/8Ef/AE0pfzqr/7qC17wAuib3exmf/iHf/iIRzzCZ62xl3JYLUwvqNqOXz0O2ys1i34q2cO4AkJc +gcCIEbC+aXsc0jLMiMuO4jYfAjfeeOPrXve63/u938sNKs3U+P65z33u/ve/P7OdTKJiUWRoyUL0 +P/7jP/BumcV9yEMe8qMf/YgsT3rSkzDPDhGW7KUvfamEP/7xjz/gAQ94zGMeQ+oTn/hEbJjE8Imx +bTe96U0vueSSF73oRcz3enYIbOeFF15IBZinJXr55Zd/8pOffNOb3kTpWM1cEh/xrW99KyVSK+Zy +8T6xavv377/00ku/8Y1v/PjHP86Fod3mQTOLi6eupv3zP//z/e53Pwyq+BdffDHuKfS///u/Hzx4 +kJpAcz34wQ9GUjQOPfO9omkjUHz5y18mCoDCUEmEFGrlGtv6L35qwaYql8sHEQgEAuuOQHuWyFZl +4v3UdUd7KxTAAiTm5G53u1t3Y6+66iomMzEkX//61zF4XPiCiDGbSi5mWZ/61Ke+/e1vxyDhC8LH +Iv793//97Ows9KFDh6Dx6iSM9/aMZzyD2VSSsHBkgeBiovXIkSNYyn/913/90pe+9L3vfU98wte+ +9rXXX3/9v/zLv5xxxhkvfvGL4TzlKU+55z3viYvJiunP/MzPuCTE1772tXvd617M5eI+4jhivB/7 +2Mfe/va3Jwn7x5NBLpzT1JZHCuy67N+VV1551llnuQA0HKKEPHOMj48rCf4PfvADmWH4Mvkk8QBB +qCcMSSo0M6oLo2rWNM0AM/dbqYqdCwcdCAQCo0TATvy1r1uoQ4+y5ChrMyKA3aJZ+/bt624cnh8j +PnOee/fuxbjihOXrjn/1V3+FycSOMmv6oQ99iOyPfvSjcRBZqoQmLyaNVUmpxR5j23Bq81JYmGSi +FcPMlqjTTz/9l37pl/JUNL/kJS9h9xClfOELXyBpx44dzNPiRGLGJiYmcmHM/9lnnw3n85//vBcq +Aewfqbmw0+wqYmr3nHPO+bM/+zMxeRTYtm2bC1AW88lE4ct5VdLk5CSzwXp64Fnh9a9/PZ73O97x +DpqJAKC5BplMcRKNnyon1UKXdMIzBhEIBAKjQCC98GYzW7Y/qRTrqaPAfHOXwS5fGojX1d1MmNjF +arW95sdO3dwDc6vGciNG6+qrr8Ya4R2+8Y1vRBXWF3PlOpk9dtqJa665BrrfBuBb3vKWkqSgZR8g +Mb24qsgz8Suj7qUw95tv63U+BhUrjutJhXEYxaeezPG6DH6nas7TAGbV+ciwKVpWlkcKHi9YjcYb +VpMFqZtJEQpt8ldnE9r75fJWSTEbrNCLCCIQCARGhkDqmJyjNLICo6DNiwDbcHBSeXuku4mYk29/ ++9tuzzBOPU0jfOwujiYaLr30UpYe2SiEvdTqabda59zlLnfB4WNiWRyWPz1ppQSeLhuLsOu//du/ +zUyy5n4/8pGP4EpiYn29M1fLsi5m7DWveY3P6JLKSi3NcTHstCaQ4ePQcymJOrOv2MVw0DHMLPcy +d81MNQ8ZbiBzApquS660WUkzwG0duZgJZJ6ulxJEIBAIrDkC9s3UZhNjat+lST7rmhcRCrcWAniB +rIyyF/dlL3tZo9Gg8UyDsAPoiiuuwOfDOWMzDmYVK4KJys0kW2oRZmWUJU/4cvUwk7e73e2e9rSn +8QYn9nIwlPh5bAj6oz/6I96uYd8sS6HuL/bLiO1k2bU7FSOEScNlpAmvfvWraQ6Tz3jAeKIs5W7f +vr2QhTozVcvOLMwk5p9LApdddhnu5le/+lWitPe6667TjDQW9B73uAea4eO8opwNWcrCNmMRvF1D +Q5gKdg++YBqJJquaztBn4tc2ANul7BEGAoHAiUDAemCrmc7Q53H2RNQgytxsCOCxvfzlL//Lv/xL +fM073elObLVlfxCNxN+CwPDgy7I5iF2+rH164/ELEWBalZXF/OWWX//1X8c7zCd+PUs3Qbksf7IY +yUwsLma+ZtktDOfXfu3XeEWVGn7sYx8rCMBEG7VFhj1NVOPJT37yn/zJn3DyQ0GSKM40IduvMNK6 +5I7zMgyGk8VjjrzAamJ3d+7cqewsmrIh6973vvdFF12EoeWBQ3xs+fnnn//ABz7wrne9K/unaIX4 +HspwynaW2eprptSmmtiplBtUp51wDUEEAoHAOiGAEWUDvp32cPEv/8HR63/y8Tddvk4lhdpNgAC2 +Kj+1YNkWYa7YhYtxyod1jA3LpWwLYn+QNODbnXfeeWx2xZYgT1KumYMXOGwIJy9nDkMzb4yrV1gN +7ZmROV6mWDWP2i1w9OhR5mCp4a5du7pTh+HwTICGW93qVr6W7LmYDKfowglT1IeJa3BziACtcOH9 +w2EX9EJ9Wjsh+IRqrbbDbGu6nFDUSwwiEAgE+iGAJ8Cjc7/UYfh3edhvT+49i0lfznyw7b/D5AmZ +QGBIBLR1tiDMEN+Tjxizu4UJXmzGK17xij/90z8tKOkX5QVW7ChrliyCvve979XLoP2End9zWddT +2R6cL3Y6f3iCRvXc1oQGDG23HurTs0pAhx11eaIYTkyoHV3Ic3GrvTHKYjb/FFcgEAiMHAH6I2Xa +qaGlseZibx15PaLALYwAy5McIXTqqad2Y4DHxtSrz4t2CxQ4vBeLCeT0IpxdXFuWVwsCGzSa20jR +HpbKtuPX/qW1m1xygzY2qh0IbGAEzD1tYVerrKnGk+0G/iE3ctV5Z4aNRT1bwHpkv6Se8ryEytUz +aaMzMZY4qR7SHEWxpuwDM1Oafa5RllXhRm941D8Q2HAI0DeresjdcFWPCgcCWxYBM5l8/iIdgmb9 +11zVdFJhmvh1sxqWdcveIdHw0SMg35Q1GY40G33pUWIgEAisDAEMpNxTZUsrqekV1XRoCxZ1ZepC +OhAIBNYaAXpoo9lgpwOKY0F1rdENfYHAeiKAidVlmyI67qmI9Sw2dAcCgUBvBFhJxaZiS6vNMKi9 +IQpuIHBSICBLKSc1d1XTeio1TN5qx03tGNqTouZRiUBgCyGQXhhnxii9SxNu6hb65aOpmwGBZDv5 +AEZaR7UGGWMzNCzaEAhsTATMSU0X+343Zgui1oHAFkNAVnOpw2pOKpcbVBGEIpQaYSAQCKw3AnTM +ZFTZ9xuPt+sNdugPBNYagWQ02f2LOV1UHX15EYugAoHRIpA+Zmx7k+zzW9EVRwt+lBYIrBgBOqk8 +VHLqgdiMadphyF+Z2OjIK4Y1MgQCa4SAdc+03Zfv0ti1RmpDTSAQCKw9AgVj2Y6mP3Rj/mbOajwi +rz3+oTEQWBaBJscnIVQyPzUs6rJwhUAgcLIggAHlIVhmVM/CZlDNri4a1pw+Weod9QgENjUC3unS +3G+8TrOpf+w1aRzfbVgTPaEkEAgEAoFNi4Ctp8a876b9edesYcf5FaQ1q8eWVJQWZ6yXQuhDb04T +tadj3NZymc+wQ/uFjOgtiVk0OhAYNQKcEcpMER213GAWOMzqqPGP8gKB1SDgZnKJ7Szr2AefA16c +BF5NGZEnEAgEVoWAGVLWU+MM/VWhF5kCgVEjgB31IvFZOa3bo0rKBXLaxYIIBAKB9UbA1lPzV9zW +u7zQHwgEAitFAAOJEVUuN5ZuViFg6lqp5pAPBAKBtUEguad0UzuAO1zVtcE0tAQC64yAddbO5bR1 +4XSRwt9O+hLamUEEAoHAeiDAo62WUW36yB+B16Ok0BkIBALHg0BuJqVHFtT5ThxPKZE3EAgEjguB +lj3FYkw5Qx/jGpuUjgvMyBwIrDcC6q6UIkJ2NA+VpGqIv95VCv2BQCCwiEBnhiitpy6ygwoEAoGT +HQGZVWrZvU3pZK961C8Q2LwI8K5bqVwpN5ux7rJ5f+Ro2aZAoOCP0iY4Yqp9Ob0pWhyNCAQ2GAK2 +LSntTaqWO8dwb7AWRHUDgS2PQE9T2pO55aEKAAKB9UWgNZZODGXfL+XEeur6gh3aA4E1QmB4ezm8 +5BpVLdQEAlsbAYxquhZfG9/aeETrA4GTGgG3kU70rO7g1J5ZghkIBALHj4DeSaUDVm3Xb2z7PX5E +Q0MgMCoE6Lc9O20Y1GF+gZ7QDZNxQ8is4T3gQDmxIRAYppKOkhPD5Boskywp0792hn5Y1MFYRWog +cFIgQP/30U1jQSHqtVzDkcJ1bgKCTw5861vfuuqqq2ZmZhqNhqO3CZrGL16tVqemps4666xb3epW ++YbwVbQOZMDnPe95z//8z//ccMMNCwsLmwyriYmJffv23e1ud3vYwx6mj0+sAqVCFu+S6VtvnRdr +CkIRDQQCgZMKAfptPrr1tJ09mSdVK0ZfGVnTK6644pRTTrnlLW956qmnbtu27TgNz+hbMaBEGjg9 +Pb1///4f/ehHH/jABy644IILL7xwdQ2UNX3ve9+LbX7oQx9661vf+rTTTsPwDCh9YyXRwOuvv/6b +3/zmpz/96ac+9WkPetADH/7wh69hA6tNPk/eaG4sUKK2gcCWRaBgVgs4hEEtAEKUMfRzn/vckSNH +LrnkknPOOWezQrR9+3aeFTClP/zhD7/4xS/eeOONd7/73VdqKubn5//mb/7m2muvfeYzn3nve997 +s2LFU8JP/dRP/fzP//ynPvWp17/+9TxsPf3pT6/Vat03zwo47QnfVjU7H3QF2UM0EAgEThQC/czq +Zh0BjwdnGVQme+9///tv37G9/cXZpHEznXPOnlNrUzoV7+yzz969e/dnPvMZniQuvvji4c2qDCrG ++PnPf/4ZZ55Rr9e5o3RTbTKsbLKH+e1m8+KL785j1otf/GKeJJ761Kcej1nVT4BizibktZrjuWkj +byAQCIwaAY10Pg+s6KgrcdKXhwX99re/jZG4733vOzk5mc44Ty8RnvQ155flWunkrXIR0tg73elO +zG3igQ25vIoFZb73+9///nOf+9y9e/c26o1mKX3xPp1lcNIDtrIKCihuD649e/Zc+uuXXv6Xl7/v +fe9jEphl6ZXpWipte5TMoMY2paW4RCwQ2BAIhCkd8DMxbuJ4/eAHP7j5zW+O/0GUARTEIMg1DHSz +s7Pf/e53Dxw4gDwjL5bmpje96YAS8yQy4hxjFJlmZEp2mOLy7F9O16/8yq/kzAE0jVLTIHSxDecW +t7jFlVdeed5550EPrgBZjh079slPfvLnfu7nduzYgXNPWWRRLoU9S//a1772iU98AstNG1nEZdcP +Jryn5PDMb3zjGyx2PupRjxo+y4okaSwt4maAoKWEu3bvouEf//jHmczYtWvXgPYOKAg9XOUSnzUO +gzoAp0gKBAKBjYkAAxxeF6uMZ5xxBgNovW6bVyH0zoMRAy82+7zlLW9hfGczLRua2C3MmDswx5JE +dsx+6Utfwkt+17ve9drXvhbzvCR5uYgNz6rtcpJKd2ER9YU6BA2n+ZhV6MG/IU7qxz72sZvc5Ca3 +v/3toWdnbV80V93/QHX9e+ELXnif+9znq1/96q0vvDW25K1vfeur/u5V3WLLcg7eePBLX/ySi33+ +859/zWte49G1J+xmaLeM9s1MW2Np+JlnnsnzAUmDseqXqulxpn3jXZp+EAU/EAgENjACvAGCi6k9 +q4zLC8lDLXPEebmMhRm8QEjeD3/4w+fc7Jz73e9+7rVgmZg9Hh4RFuouuecl+H9vevObvvH1b9zh +DncYPq8KGr64VknLebYhiwvDQGVZSaX5gEBzcFX7lY4kLjWO9W1ucxsc+vm5+ZlKBVNdrY5rIhR7 +2Z0Xp/ZFf/ait/3z2x7wgAd4Kqoo3aNDEu9+z7tf8IIXfPUrX5X84x77OP6tQs+QxYGVgAWWuXTR +WBrOriUcbqCg1f6jD6nTxLiluMea2NTlbq8VKA3RQCAQCAROAgQY3BkxGZfZrYMRLZVtro/XLMtl +m/7lGlxH5h4ZWy+660UL9YVuSZzOz372sz/5yU9IYjb4nve8Z7fFogKUOL8wz3sVFDe1bQoaU8ca +Jy9yoIGMbKyV0bruuuv++7//G+NHVRnZ73rXuzaaNidJFopgqxHyeISDq418++K7KGnmFm3MZKIc +KLAZA7LzHg4yN7vZzagPTx3QvAxSqS5glcnVM+NL/+qlVOmSe11ybPpYASKqgaP5hje8gXd72IfM +Au2d73xnZP4lXU9+8pOxoCRBXHbZZbi5f/zHf0zb73LRXVD4ohe9SGJvfOMbycJ23Dve8Y7s2WbO +ADf6ec97nlQ9/vGPf8QjHvGYxzwGmbe//e28PsRkADRv0z7rWc9ifxZz0ai6173uBbP7MnibZv6b +6QlA27hoPlPZQLFz587uLMtzOo9bZWwrkyHLZwiJQCAQCAQ2DgIYsPHxcS0lyjDINnQsz6C/bGti +WdG2NfW6mARm5H1Iuo4ePUq0WwqcSMI2M6eKXcGCIoOVZYLxwQ9+8KMf/WjmlnnpBSZi7I6hLF7t +eNzjHsd6pLShAeIrX/kKM9isUyqqpJ6hfhlrKc8QFtiFWkAYPJ+JNrw1prh5/sC66MKyopAKc2F7 +ui9cOqxdNx8O9u9lL3vZs5/9bB4geH/pF3/xF5k5h3/w4EGmxF/ykpc85znPedrTnvbCF77w0KFD +vC7MhltM4Dvf+U5e4JEY4EgzDy4vf/nLeQrBQuNzQ4uPANpE82P9+Mc/Fv1bv/VbtIJyL730Uky1 +mN2hdkkbQNUKYNFkHibICAhAASACc3Uh33rjoea4VKyu4MgVCAQCgcD6IcBIinPGcGlD59LLTc5S +9mKMgRVrtBhn30mycHAwgQz0LL9xfAQXBAM6JjYXhkaesZ5jm/CcNP8MEwPPEQpYa8Zu8uKrwWTS +FZuH7WEPFIW2HevkSbPBikVZbLdOqCgUUYiqUXnTRAMCUAzGGceUlVesb9uiJhuDmVEUovvCs+Qo +om4+HGwqc+Y8OtDGZzzjGZgYjmSCT4WpDC4sjWULEiDTdjWZglj9BQGJUVtppglMA2B9mZf+2Z/9 +WZ4wnE8W0ahFDJrf5T//8z+ZiwZYfH2sPjrFHswAAAvvSURBVJWUTCHkpmg3rVKVFpQgA85AMRir +AangrPXU2KU0AKVICgQCgY2KAAMlAzoDLpdGXlqiKMQAd4TZPwZoJL3lDNDM9+L9YFNhYiaVevrp +pxNlcrJ7wpD1VE5dIInJSXJddNFFVIYNOBgSxm7cLO0HJokZ2kJ2lDNAcyIBbhxW1qvRj0BezSHk +IqqGE9LwfrnEVxasHaZdloZQcKFH2ZEpKKF1QIRkgU+UhwwcbiURYg4liSqsLK1GBlNKSCqXioCQ +KhWtKBVg97JoslAN55Mk2rPjDaPhFa94hTgAzkwAM8ZS6yEZ1WRC4WO2MK0E89CjJBcenkCVhKtj +JVuxjysQCAQCgc2EgIZm3A4I0Qymfg1uKQPxF77whWuuuYbzEyRJRggGcRm/w4cPYwjhYBoJoTW+ +S5hQBcHkJRzmfrGjHL+gncDMhWLAeBmUWkkh2nDaMLR5dtwmvD2mhTFCLLJ6Uj8CY0CSTAIhyoli +JqmJ6H4ZEaAsQpaQqY8usnANyMt0NHVjgTOvtopgfvs73/kOXi9RLA2PI/iscoJR6HxSKUt8aPHF +dDEIyRT4RLmUhZ9A8ueddx5M1lN5JcaS+1+OEtXjIjuyLFpDCIr+WfumADcbxfhXtmmBrmeQvvki +IRAIBAKBjYAAYzFDJK+oEnLJSCgsRPMk0eeffz7WlDcrND0rJo2GYMITJ5WFUswVBhsCVxXDWVCC +MKUQMuLjpbH/BQGMFiYZS8ACIUuJ1A0ms8GM42xE0koefq1UkRdf8IEPfCA7bHkfpqB/mCgVoIaE +QIG2fhcC2HhCtiijFmHqo0sGrxNb8pflUprwxCc+kVAJPDd89KMfhX7sYx8LdCwDo+1tb3sbE+OP +fOQj4ROlDq7FaXzxq6++2udpczFqRVRZ1ArRrDr/3//9H8YL/a9+9asRg48eDvdgKReHlSh4ahOv +svQLUctFKdTToeiH1QC+nfSQ/lXH2g7rAOFICgQCgUBgIyHA4Ig9YNkSoyIXkEFTAzThMC3hiyUs +zr3jHe9goRGTg6lj3lLDPV7XBz/4Qc6Jxd2ByXEBDMoFnZSCp8vFzC2mkeU98vI6zbvf/W5sALlu +d7vb/dd//ReWG5vKUfUf+chHWHxFD9YCN4vsXGTBTmB6P/ShD7GDadkTJ9z9gsD9IiPNZ8oUKNBW +qGEexdfkWQF3mWbiFpuRSZfa2zMvjx0Yzqc85SkcqXHeeecBMtVjKy9lsYaKVWMdlGby5AFQTP9S +HCpRhQA01ROHKLtzwZCp2ic84QksneZiAkFZcj7lXnbZZZRIxt/93d9lf5NkXve61/3mb/4mm6fO +PfdcHhHe/OY3s7k6byk04Cg0FzXNjVNJFr+ZhOfZqNvtLmTvF0WrZnxLFz7kaTMHr/7cu/6mn2jw +A4FAIBDYcAgwUOL64ADhI7L5hTEXC6Exevi24AnhaJJRW4fyjPhAaNO6YM5flsYf0sCNBrKjRFkY +03kIwHIsq6GfgNtUTAXNp+bsj2XvjzYT9csFH4vI8RQ8AWCBLrjgAqqHV0dNVBmvYU8N+Km40TwK +UPlcAJ14+T55nif1pBHWXuueqd1MfhqeALCC3UkgiUGl4d1J4uiZI5lU29XMD0ETWL3GGNOQ7jej ++unJ+Xd40JNqO8/gVklnE5rLGlcgEAgEApsHAewBLibjIxOtDPeyqTKrwzcSeWZ6e8qjvCd/WSaW +QzIFDVqgXTb7YAE3q5g0Gk6rKUWmcUBGxFgExT5xbhR+KjYVDmZ1sDWVQgw2V7dylOCgd/P7cQaY +wJ5ZaBR+cM8kHoC4eiblTLDCoLKMim3++te/zrQ8INDwXGalNN5quRQn6K8UtpAPBAKBkx4BOZGM +1HghTEUyEcoYOoyROOlbNqiCNJBmMuVLk+Wr5a5wv5w8OmBQmZrGs2dll4z4cFsBK5rJtAFvzfL8 +QfMBASj6oTSYD1xpHmSsctqF95g/dvj//eJDBmeI1EAgEAgENhYCjI+4HayGMq/Ie6L4LtCYnI3V +iuFrS9O4sIjsnMJUsNxIk3E3h9GA24c3jw+Nq8o8MBPmBTd6GCUbSAagcFI5ZIq1WG6Pe9zjHsC1 +ullftfqVb35PeWIH29iqjTp3WMz9bqCbIaoaCAQCwyKARcH5wGDwYgxH1jFLyQofIfZjM/lhWAjc +cbxM3FOdMsEmHSYzhzSoQhOLQi6eQvik+eWXX84rQOwb4vVQpliXnT0e9vc4CeQwpUDE2z6sH/Pw +cdvb3pYzEc8666zjMag0yx/VhnqEOQlwiCoEAoFAILAaBLArLFXioeK0sW2H7bUsoTGwrkbXSZwH +s8c0Ly3FCtJS6JUaQh4ysCu4a3irGFe27fASLYhp2vwkbvrKqkYzuRl40qKlnFGFRw7Nk8RxPmOZ +Y8onFlqtKof98vWjlVUqpAOBQCAQ2DgIYF3YMiOzylojF9ti8e02TguWqSn2gEcHDAMXzYRenYWQ +vWGbEj6uXkdhDplHENYdl6nBxklmRYAHDu4HJre5eIxY9RrqkkZzO5XG2J6En8qNtXnurSWNjEgg +EAgEAgkBrIVMDqaUazMZCf3CGAbayHX8PziqmBvH8DBJDlD49CB2/GpPEg1AxDPWGsJVaFe1tXme +PwpNi2ggEAgEAkUEkt2x4xSKCRFfioADtaJF2aU6tlKMpxl78GjZYb+b6RlkK/2G0dZAIBAIBAKB +kwOB5MrzYfLyGswUnBwtiloEAoFAIBAIBAIjRoDNXJSYXFNzVJmCb5/1POJ6RHGBQCAQCAQCgcCG +RkC7o2lCmiq3ed8qm37NtsYVCAQCgUAgEAgEAkMjwLd3+ODdpZdeSg5sqvJhV/FZw6oOjWIIBgKB +QCAQCGx5BNyg8kIOYKS3UpuY07T5Lbb+bvn7IwAIBAKBQCAQGBIBPhYrDxWDqvXUzpfeSmVeUg03 +dUgcQywQCAQCgUBgiyNwxRVXvP/972fKVwaV06YEiKZ/eT81Jn63+B0SzQ8EAoFAIBAYCgEMKl+k +54voGNTvfe97Mq7k5JVnC9n3i0UNozoUliEUCAQCgUAgsIURKBhUn/4FEt+WxPdTLbqFUYqmBwKB +QCAQCAQCyyDA1xdyDxWD6t5qOycfrzU/lbnf2KO0DJiRHAgEAoFAILB1EWCa98Mf/rAb0dygQoOL +LaZyij5fJmcHcHipW/dOiZYHAoFAIBAIDEQAg1owogXj2s6d/NTS2fd+0sKR6778oVcO1BmJgUAg +EAgEAoFAINAbgds/6Mm1nWfgp1bt+wylsTs86Ml8/qhk762mxVZmhO2DeRZJCkg0DpuaiGOMtVuY +8yKMo0/rGSXhTpHmCxuLFPs/S4StbcfoMulOxrZwR0E7lzIimIQtrwskrRbVCYvpAIvFRClXPBVB +oWS3Uiwp6U2RpGAxbjnaFVfZSYWyZAwOdmxLOnOxRLEMgZS5U6SqwSo2BClqiRFtSQ5g7uTstC3F +vc0kJ9oyqJqdMqULVUmd2teuIDk81WpEFkGRCkZR5+dQfLFalNDJmJKUl8z5r2CqrFKLkp2qp9yL +gAvyljbIKZLrh2NqrT0JnwRcp54pklpsdUptNiytzPTHIgkRE0xgmoxATtKm3NK42vkUEaeTlCUm +hX6jpne61UZTpBq4BitnUYWzIUw2KTWmtS+xjLbOZsClavG729nbnSjp1jKTklpiCeRUdOLmgCcV +lqWdiTzQyms5SyUrC46lW6AMFLlYAinkSEkmBWYqOWVIKVZspqQtnQo1fY43uYmlfG09KeMSnUmm +HYBCqq3X3u6BvPBUkzZTdbCcqbIpT6pCm6OUdm5LoCLWlgSGNcwydv6mqAfiJgHjkSvlbv9AqUou +spipvSMlAbAk2fDgomDVhij6rKle98QymSTRzpCAVEZLT4MMdWjXJtVdkoaS3Z/Ipv8t4GpLJp2k +lmsVO4B2epaPxmoAt6qqClYfy6HiU26Lkp4Qs7+dH6LdiJSUBNsqnN/JbXlM5WIplpJqqYJSYaqx +agFNKWKbZLtRHYYUS50XAtHNaUtSdKpDLtxWu4SliIl2+mhC0IAuW/1JsWoDoT5hZKnWZRJTIVGT +sa/sGWH0WOn/A0B1iDc2vLUPAAAAAElFTkSuQmCC +Click “Continue” and you will be given the option of selecting, “Install” using the default settings, “Customize” to pick addition options or “Change Install Location” to pick a different volume to install to.iVBORw0KGgoAAAANSUhEUgAAAm4AAAG6CAIAAAA+jV3gAAAB32lDQ1BJQ0MgUHJvZmlsZQAAeAGt +ksFLFHEUx78zErthLGJWRAZDqJjMxjJ7qdtuewhhhUVXzfCy/nbdlZxxmBndig5dunUrOnReJOrW +RS/hHjsUKKJpnfobJImWZfr+5seyHpQuvuHN+/we39+bee/3A3oGS667rAOwncCbfHDfeDj3yIgd +QsNNJq+gtyR8N1so5Lk6w473qabtJmWtT/7e2I2v6deNkVbs1efi1hmbOumExw8CmsnEQFVxRvKC +4qLkeuAG1NQki1qpTH5ONr3iZI78npyoKt6UvKD4i+Q1UZV7D8gpp7zkAHqcfLdc8QU5QxZlX9jk +Btm07RXW17fJo8L1uFf/Qx6Sc2GkPdsHsh9ZM9HNzbwBPqwB12U7RiTD8GPg8m9gc72bOzqIZqVd +jfuLaSvSab0bwIW3YXg0C8RuA+3vYdjaCMP2OtDzA2gei1WPtZVa+8Yf/s9a9az0wA57oEVndDqr +uUSqFNBoAnNcjGeAd/SRa0D/T6BALmagp9MdVzOkFLiYz00kLauueopS5/Oyl1d5TpHJDi5VnOkp +xj76IPLIYQJJWHzqsNTZSe38S+CWvNZo/v31QsaTFlSeRDPJrbhPvaVqLTCyvLkV0xh3xB3TsFKp +e/gHmVWEZApHLZsAAAAJcEhZcwAACxMAAAsTAQCanBgAACAASURBVHgB7J0HgF1Vnf9vfX1qJr0n +JCEkAQKEjhRRkaaCu6gogqJrAxd1Xf+irmtdRBHbWlARFF3FRhGlSJHeS4CEll4m0+f19277f37n +JrOzmUkIKZBJzjU+7jv31O99c77nV87vmK//0vVhre7XSn61HIW+ZZkRVxhuvIkibszICAzDMgzT +MkwjikzDsS3bNC2SDCOMIte2HNtszqV6eivLV/daZJFCRhiEZDIpaJqUDP0wDCNV0ozCiFQq2/gZ +ya1hRuSndYpwBSFNxa2YlDQNy6RqeUheOibNSymDUqoqqYGaDZ6SKEOQauQrd9IH7mlX1SONhXSe +kao8kaSSldLSWem/lCZ//JX65GsUSFuqLE0KKlK15AxDapBhykWCqkH6KhWCamhSQ/yUWqUbhsKG +/6r2ZARyxR0lSeqgRwohvtJVqScIyUBL0koQ4yyl+C5IUUnIAwFEGthUVnWAociY4vfB0FX10tP4 +olZpS9UjFfKdBAXmpk4N5JVBgT95eMUUjwcgKEsbjEuNlDvVTVWRgtqweK7KUlQ9ozCFYpDjQamU +uEtSr/oZCFDSX/VsU0FqkJFLunRMalQp/FQs+bUKKKTw1aY/lh2F/Io3XiBIKS4pwruQTqtHqs8b +6wlCx7YFdvUTkcxkUU3EtZCNi3uaiFOG/QSNjQ0JNlQgfYuLWJY9cB9XFX/G9Uj/5A8w7pkUZbQy +qPg3Ij2R0nGF5JRS0iP1IgGLIXLrywP1Q4pc105n3WzKTbpuIqEgoAjPycYPTP5aBXEFqVTGJTXI +4OImycslYwYy+Y88lkTJKb9H7uiwTcsMMP5TUk+lVwH1x3/AMnVQkMyWHwTcxH8IUpnUJENUvwWT +CvnOpf5eJJHfD6+L2UYS4x+z+oXwlSbkobxS1cG406qfdGVTIq1KWa5NdUuBjd9klPKHLE/5Rag+ +qzEKMvKbjnPG2fikUfUXGlfFQ/kLoGwYBkFkCwwbK2bAvEX145enqsW4RmmIS8aryvJfriAIyEMh +bjb9NJmp5I3yIchKL+VlSVWALt/4oAVD2mWMEeBZ6nVIF0FYfubSNNXLvfSWWynA4KQSQBb4qEg6 +o4bHnzRF5M9JWgJemicTOWmFOuk8gPKqFewR9fBOgjCgAgrYjhUBhAxIdVMatcBGXpxNYYWD+gvl +AfVJTWQ3qSF0gIeBqCtuUWoUgKUVkskMNHRTfkrMvRa/Cpu2aFCw5oHMR5KNtuk2r4T/UAMoCUw0 +qWDnzg8iflGMiAfScUoJHrww+aQW2+GnSKo0JZUp8pNfuOmmMlk3k7Vtx4nqtXqpb1JT4vCDZiya +NW5cS1Z1Xn9oBDQCGgGNgEZAIzA8Au195SdWdDzy0oY1vZ25ljbHqxQnt7j/fMTMqaPStVqpvb0w +fDmdqhHQCGgENAIaAY2AQgCp/IjpLVNaM398cNm6YtHxqqWDD5g+LmeVSiUNkUZAI6AR0AhoBDQC +L4sA+l3f99tSzsJpbWseX+2EgTd3fK5er79sSZ1BI6AR0AhoBDQCGoEBBKDOWWMyUVB3MCU3JDDV +KlP7wPNNN5iUPc/raW9//Ia/tD/zTC2f50mysXHcvHkLTzulddw413XFoLyFa6D4Mzdc3/HM4lq/ +Kt7UNGbe/Hmnnb6NxTd0tt/0jxuWLn8mX+qnwoZs434z5p/8utPHjn6Z1rfQKZ28lyJgRl7OWjlm +1AuF2rju/FwczkI7sZdioYetEdAI7CQEso7yil30gW9+/awDh60T3qrVaov/fvtDv7g6l0yOHjO6 +beJEErvXru3o6CzV64eee86C15+QTCaHZdO4+HN3/H3Jb67KJBNjxo9rnjgFt6m+tas71q8vV2tz +3/neOce/fuvF73jgtmtu+kUq57ZNbBszeiz+bBs61nev6/HKwdmnnHf84SduqfiwI9KJeyECrlVq +dZeOSj7XYixzXaOSyxqh5+Sj8rq5q51FXcnxrz4myuMRH0jcd//XV3PbuzHg3rntRbYvJ/orx3G2 +r6wupRHYexD48o1Po+AVn95hx4w8+vTtdzxyxc+mZrP7T5l8wMknzz77XXggP//La57629+eWr2a +R5AobIpsOrQGir9w599fuubHs8fkDl44bepxbxj3hn/GCXrDbdeuuP3mxx57kUc4F88+/sQtFb/z +wb9fdf2PW6ZkFxw24w2HnnLSQWeWaoUbHvr1PU/cufTRNb+4/se0DpsOW3xof3TK3oZA1LHs0OYn +G2YtMcpJw/DYHVKr+ZViXyaNC7uVnL04m+8r9e633JrRGzWyf2gzfO69995Ro0btu+++m6Xv+Nfr +1fXTn/6Uqv7t3/5t//33P+ecc4ZWy2L0wQcffPHFF3t6esaOHTtx4sSFCxdms9mtFBlayXan9PX1 +/fM///MVV1wxderU7a5EF9QI7A0IsM/Taci5auvSMOPtbm9/8pfXzM6kD81mJwdh67p14fPPQ6Wt +69ctCMOWTPahKCLDhHn7jZ4wYWj53vb1a/581f7TsoctaGscl0zb+SjfzvafjNU/fUqi1R394OLo +hT9fNXruvFETJg4t3t6x/n9u+kXbjOz848ePGZ31kv0d5VXlejHMlCbs05BsnfDsne1kmDtj3oRx +wxQfWqFO2dsQKAeOVXnBrj9RDudVKm4h3133vTBK9DtOS2uupdlOtt7t1BoW1NynCsmuzMzN8Pmf +//mfAw88cNasWZulb/1ruVxub2+fMWPGVrKx+EPai//uuE8kEkP/BvP5/Ne//vU1a9a8+c1vhs5X +rVp19dVXw6Pw7paKbKXF7XgEkVOK1erQvm1HbbqIRmAPRoBNss7Y5uSW/lSW3nxrSxQdnctNMqLG +Qj799NOyrz+MMs8+axYLCdNIZLP9hSLZWs9591CY1t7511HZ6PgjJiSbUm6D5QTt/up72H5r++uS +TVaL1XB8zum5fRXZms86b2jxv9//NzsZHXLq1IYWtpRHXeHKJzrv9MJa0e5Mt7hjs02ZU5N3//wl +sr3r9HOHFtcpGoFky+glq5vaUn2Rd6/pjjcSk1w7YduV0OvoWtdV2OCPm2imksmH16e7s1PQtG6G +GM7u6GC39NexWeaBr8iyv/zlL6+88sqBlKE3sBRXXPPg+8E5qaGjo+O3v/1tTLRQbzqd7u7uxs1h +S0UGF9/x+1hZxecrRWDHm9Y1aARGFgIElHCSRMHYgoLXWb78gExmsmWNMs2MEbm9PdbDjzBCt1pF +X5YgXEUYkWHt8uXD1tDQtWT6vNb0mIZkc9ptSDrpwPKWscy1GzDAZJ2MbSWdhfNaV3QvHbb4qr7n +ZywaPXZSi5OwCa5k2tVO/wXCXlBPLpEOgmQ6k5p+yOhV7c8PW3xkvQnd252OQGL94jn1pYVqW8dL +b8pOuLnRXm+FXhD4fqWPICrJpFH3jKeeyhS7VpfmHrcxws2QTkBa/LqKxeKnPvWpiy666I9//OPT +Tz990EEHfexjH8NIT/brrrvutttu6+rqQvX66U9/+qWXXoICESg/+MEPHnDAAR/+8IdvuOEGyHX1 +6tXIqe95z3tmz55NKarlc+B3G7cyuHFavPnmmz/72c9WKpVhd6lR5De/+Q152trazj///LjaYdu6 +66677rzzztNOO+2qq67q7+9/97vfvd9++33ve99D3j3xxBPf+973xv259tpr//a3v2GUOemkk84+ +++yB7tFJLpobmoE8S5cu/fnPf47E3NzcfMopp5x66qlIsVuBa/AY9b1GYI9BwCcyGn8nW1p1Zvvz +41ynJZVssO2E49iuQwAlCauUTDi+b/t+6AfjzFp/f37YGlrd0phJbanRDcmWjJtNWimHRT7RnAw/ +49QSdjphus6YSZX+YtewxYthft6MsblcxnWISmg5lvxjFvJCm/iDdN1PhONntC5Z1z5s8T3mJemB +bB8CK7uqE51KLm063qzKunE9rX8aO6GfkGTs+soX04WuSfWuKVGl0fS7rQlrvNwwzkfwBxe/Lrxv +1q1b9+1vf/u888674IILPvKRj9x///3HHHNMZ2cnStff/e5348ePh07IOXPmzA984AOwKRdf8dqb +MGHCZz7zmX322eeLX/wivPuJT3yC4fBHx2f8ux1oZfAw4TnSp0yZArcNTo/veYSx9dhjj/3+97// +wx/+8A9/+AMszqNh26IPS5YsQSf8ta99DVr90Y9+BO8yBCphQfDGN75xzJgxt9xyC3SLWZSRvv/9 +72do2GXj7sXzw7AZEJE///nPw7v04dFHH/3Sl76USqVOOOGELcE1dCA6RSOwZyCArsghBmb8NzN0 +SAiDSdfONTSwALfTKTObNdJpiVxYrZrlslmp5Kq1lFkgSumwNQRE5m1IJVtziea0nUkggxqu8uzw +Q7PmmwlY2bIb8mQbtrjr2KlUMpdKUQ1aubTjpmwHJq4GfsXza0xwdpiG1O2NNqeh/dcpezMCo+Yc +sKQ4Zer6u8a3lJNhk+19uKvjZsPrKqyb6hfGWBLjs+IkyoYT2p2Pd7sNoZMeChd8I38eSvd74YUX +YjrlbwbL5fLly4888shY/YuoiiSHFRMKISdFkMwQJbnhOuyww2JqmT9/PnJkXFX8KL6n0aHL2UJB +go7BfwN5NuvbIYccQn8Qf6n/F7/4RZxt2LYomMvlvvrVryIsIijT/4svvrihoYFOojpGXMa16tZb +b120aBH8TSK24SeffHLcuHFxnXxyDZsBYkYHftZZZ/X29iLpAghSMgRPfhodCtdmQ9BfNQJ7DgLE +hd4KlSbGjy91d7nNzVY2azY1Gs3NhvoLjEols6/PyufdYrFUqyVaR8V/PJvhUs+NKoaG05i2c2kr +7ZopeyOVIlfiYW/ZTmgUQsPLjYIMNyvL13Gt4yt99ZSTSDkOkmnOTaWdFFIpcfcdq+b4Xg1dXb83 +tnX8sK0PrVCn7HUIpBvv6kwu6Fkza9rkv9/39JNPdx2y36wF08YWjD43wV4UY0NfaS0/09mHhKbs +rd4MnwHCi4XIxsZGFKTkGbChNjU1fetb34KlbrzxRgRWmIyn8a9xQJq84447/vSnP5FIKSqMn76s +VIq/LlUhCsPQm/WKr9SDHIwllXuqGqh2S21lMhkkSLKhLqYIfYuVxhAnvaJLVPXQQw8hvPIUoyzZ +SIw7yeeWMuBXDO/i6BvXiQYbf+OBgkPhIpu+NAJ7JALidiSR87dgK23cf/81d97hNTelINGWFqO1 +1WxsFCCKJWxNrGk9x13bvqFhwfxha7AnLVjV+chBSddCl5tyjIRlIpUSEgI9LX/C3NWCVZ1Fa/LB +wxbfb9rCR5bdZgd2JpXIuqlcIpW2U5iY+PNXZzuYfjVqX9Z36MwThy2+R74wPahXikC9Wvz9A/cV +fdv1C+Obs08uW9LaHEwclXtxfe9TKzrbO3tHL3xDU6IRRhq2ZuiHXxefPEVTGv/S+MrFPRf8gVT6 +61//+vLLL//BD36AyZCc8VNu1q9fD9deeumlhx566E033YTWlyJxBj7j+8H5uY8vLKDwNGIfGuNN +af/nv0i6cfGBz623BcNRPs4MlSLvxtWRwgUxo/Vlj02ciBMygiajiItsKQOdvPvuu6kZSiYnm3ZG +jx5N5rjgULjiyvWnRmDPQ4CNLdhK+VvYfD0eD7Xt6CP7Fy9+KAyPb2mxW1uFTVkj82fD36E68+rh +nl6jbXTbUUf2qdXuZgC1HnTS2r89+sTS9sOOmW2gpXUtDr3hr850OGnL5Ni2p5a2l+rGhIUn9VWG +CVt42Jxjn1l17/OPrD/iuFkJy3XR8looeA3XdBNW4Brhcw8tR049bN/jyoXqZk3rrxqBGIGCmW1I +WY0m5wA2YjJIOvY/Fi+LDLezp781bU5t4aQx0ctsCS5YQf48VIb4Ps4Z3yPqQUvoQmFKNonGCl4E +SryQkNjgQnSq/N7xvEVlet999yELDlQ1UBs3A/cD3aAUNtfLLrsMckJ7jOwIRcV6V2hvcBHuKUW1 +29IWlcSZ425wTwr3uAuxDkD9O2fOHCpEvUznB7q6pQyHH374r371K9gU1e7atWsfe+yxM844g8xc +1Dx4UIPveaQvjcAehgB/hWJojH/6Q8dWDoLJp5+28p67Hw2jAzOZRCoVccghVBqGXjrzRNS9yjAm +nXoy2YatoRwYzQvPeubZ36das/sfPCWOLqgESjlocPGz655dsr75wLPINmxxvxaectg5dz5zzYvN +7fMPnOIT5Q3/XU7hCyMevfD4+nXLe0874lzuhy0+dDg6ZS9EYM7BR9/V0dWy7u5YH8J+zkSt7vne +nDHpQs1fUm7Yb+zcLf1+IICYA+IMfMY3A+nsH8XxJ3blhflaW1th02nTpkEtePwef/zx+MceddRR +H//4x9HTnnvuuY8//vh3v/vdj370owOUFr+RuJXN3s7RRx+N7Ej9uM5izkTIQwJ+17veNdCH+Gag +KljwZduKM8f0SXMDA6Et9LTf+MY3Yovvcccd9/a3vz2un0+uYTMggv/Hf/wHpbABw76nn376m970 +Jhid/FSuym3k1GEHuNl49VeNwMhFAC2V+ZaLvv7W/ccNOwa8KpgdglWr+p54csK0qRNHjWpUUmm+ +XF7X3b1+5arGBfPtKVNYgMd/PJtVEhcvr3k6v+LGaXNaZswa09wiXkv9veUVL3Uuf643N/mUzKT5 +Wy++Lr/8oZf+OH5cw8TJo5qasBtFvdi3VnWtby8cPuvtExqnb6n4Zp3RX/dmBJ575qn2O66a2uJk +M+nAD9cU/A3OhP2OPnna9OnIf1tCBgdaVJ2ImPySUbSuWLECnx0y493KDe672CCREblpaWmBS/gp +xlWRAeYjD25BeNXCr+REZQpRYYbkBhLiokLyT5o0iUQE3Ljs4E9EQ5SodIB6YOi4UT4HF8GBCMl1 +2bJlFHzZtmB9QhehiY05FUsn5tjYbgpb0xxGU1qEDoeOemgGWoxbj0uBFVDAmluCa/DQ9L1GYE9C +4Ad3LDNP+9evvXWB+DgMe/FXwZ/QqGxu1T33GMViOpNh6uFvxsxlJx91dHepyBQwLI/GtcXFm7Op +5x/4s+OtbGoI0AznC47vTJ11+Fv6StVtKd7QnL3v2Vu7Sy9abpWFdOCl27Izj5z3xkJfaevFhx2R +Ttw7EYAbnvrDdzMJuzJm3kFHvwHa2Fk48CMf+idAInQFr9DKQIaYtuPEbW8dPyAUvDDothTZ8bYg +/q00RGeGZiARBF7puLbSin6kERhZCPzoruXmyRd+5W1bplLGw58x28VYq7KOjnVZrLhRBzE3VavV +eHm7lWG/tsW30jH9aG9DAH0sps3JkyfvbQPX49UIaAR2KQI/uXuFg91y63TIUxQ+6KDwLBhYVpM4 +dCU+bF9f2+LDdkkn7p0IEIuAgW/91753IqNHrRHQCOwIAuwdcwJ1NMzL1rKDE9BrW/xlR6czaAQ0 +AhoBjYBGYPsQMI2IzTARIbO3r7wupRHQCGgENAIagb0cgWj8YRKigcOk9nIg9PA1AhoBjYBGQCOw +fQi86cJvEjlo+Dgv21ejLqUR0AhoBDQCGoG9CgG8iCxMpXvVmPVgNQIaAY2ARkAjsBMRMM3QklPP +9KUR0AhoBDQCGgGNwHYhgG5XU+l2IacLaQQ0AhoBjYBGQCHAFhULtyONhkZAI6AR0AhoBDQC24eA +UKlm0u3DTpfSCGgENAIaAY0ACBDIW7sd6V+CRkAjoBHQCGgEth8BAlBbnLWy/RXokhoBjYBGQCOg +Edi7ETBNqHSLZ0zt3djo0WsENAIaAY2ARmAbEBAFrz4aaRuA0lk0AhoBjYBGQCMwPAKodjWVDg+N +TtUIaAQ0AhoBjcC2IGBiK9VS6bYgpfNoBDQCGgGNgEZgWAQIGmhP3v+Is9549LCPdaJGYCgCvb29 +q1ev5jT4RCIx9OlOSWF599nPfvbvf//7CSecEB+Ru33VPvnkk9/5znc48Xv//fffvhp2SqmHHnro ++9//fl9f33777UeFP/3pT6+99lpOIG9ra9sp9W9WyUsvvdTV1TVq1KiVK1euX79+9OjRm2XYFV8f +ffTRZ555pqmpKZPJbKn+q6++mpMzxo0bd9ttt/3617+mh+PHj99SZp2uERhBCPzyL/+wTO3AO4Le +2Gva1VtuueX000+fN2/e6173upkzZ77rXe/aRd2BSq9U1w4ec7ts2TKqYeIe2k+IjTmdizPthz7d +uSnPPfcc3bj77rvjav/2t7/xdc2aNTu3lbg2KO39738/h5w//fTTZ599dsyjb3/72+PB8jlnzpzT +Tjvt/vvv37mtf/3rX3/Pe97D2mUr1fIiGPiKFSvuvPNObqD8rWTWjzQCIwkBUwIH6ksj8PIIFIvF +Cy64AAHrne98J6LeW9/6Vsdx4mKXXnrpBz7wgVeBk16+l69ijuXLl3/uc5/75je/+Sq2+fJNQdjT +pk1jLXLPPfdMmTJlsEx/9NFHswbiPT788MMf/ehHgyB4+eq2OQf0/MEPfhBReysl3vSmN7muS69O +PPHEdDrNzVYy60cagRGEAJGOsJXqk2FG0Ct7zbr67LPP9vf3T5w4EfI466yzfvSjH6Gvi3vz3e9+ +94YbbthBCfI1G9j2Nvz888+jqkUK3N4Kdkm5xYsXI/Xee++9Tz311O23337HHXcMNPPe9773d7/7 +3TXXXEPKOnUNPNrxGyr/0pe+NHv27K1UdfLJJ7P8Qst9yimn8GtZsGDBVjLrRxqBEYRAGASEaNCX +RuDlEchms2TCCIfWdHDu888/3/M8UpgomUy5Qe75f//v//F1n332edvb3nbFFVfE+QuFwnHHHUc6 +BjyUgfPnz//MZz5D5vgpQu0nPvEJtMeHH374b37zmzgx/nzkkUc+/OEPH3XUUczC//Iv/3LffffF +6fA3FV5yySUY3o488si41NKlS9FC0zRyM/eD69nK/UBVN9988xve8IYjjjjiV7/61UB+1KFI5Bhc +6d5JJ51Uq9VQz1588cVkePDBB+nDP/7xD+5//vOfo/RmXHQVgbWzs3Oghm288X0fiR/ZccaMGVQL +dAMLlE9+8pOk0JMvf/nLBx54IKuZYbWp8bugOaoattFDDz3UsuSvPp/P8y6okzVBnJMUxg7XInBj +pX7961+PtZVHrKLI9qc//Yl7BsVb5hE9pJ+oauOycfdAI/46FDHSv/Wtb33xi1+ETS+77DLwQTCN +M+tPjcBIR0A2w+gYDSP9Lb46/YdFZs2aBYsw22LoGpjijznmmHhqRn23cOFCOoPwykwKnfznf/4n +Lj+f//znY0pDo8gNNrx3vOMdGzZsgDt/8Ytf/PWvf437/6lPfQpGZJ5FgXzVVVcNHhQCVk9Pz7nn +nguPXn/99RBw/BR7JxXCgp/+9KcpiCcUxHzGGWeghT7ggAOY6OG2wfVs5T6u6qabbvrYxz6GEhIu +YTUA91MEgsHo+Oc//5lHF1100fTp00lkYXHIIYdwg1USGQsbJPfwCp5EUCz2SARWRkfiK7r+/d// +HaMjIP/rv/4rMALdV77ylbgGWI3BfuELX/j973+Pa89dd90FMw2t/Bvf+AYi6fHHHw/jcgPxb5YH +RuTdJZNJJEhUrNRJhXGe3/72t3xF+8oYGR1uRLwUMv/bv/0bDM0wycb9f//3f/Nj+OpXv4rGOH71 +pMfdixdGwyJGHngU4ZUbsMUiwI2+NAJ7BgKmYTqhoRW8e8bb3OWjYM593/veh0qTqfAPf/gDOt5J +kyYxOSJhMOF+/OMfjyVXlMADwkqpVGL2v+666/bdd9+4f/V6HYnqIx/5yA9/+EO4Fg3kP/3TP8Gs +sdCDaytTPJIubk0D46FRrvgrrk90YMmSJXPnzo1TOjo6UGkiC/IV7oR0aYvu8XXChAlwUpxtWz6R +NW+88UZqRlx77LHHEH9ZHyCIl8tlOPLUU0+lQvpGVVARAjf8CuvALnHlAxpvZDhYmVEPPNqW1vHH +ibWvVItrK0sWGPEnP/kJWA34+iLJsVBANITqYFNsooOtobQSkzo3vIuxY8cObpfKUcWjASYRzmbF +cOaZZ9IWFy+URNB7y1veEpfinYIqlleWEQDOe4kdtnHeJuexxx5LWRY9g+sfuB8WMZ6y3InzDNwM +FNE3GoERjkBohdrvaIS/w1et+0yyEN6FF15o2zZKV+S/LbmuQHVIVOeccw7yK90b7JEEGcANJMaT +frVa5R4dI2Tc3NyM4MvXzVR/PPrLX/5Cu5DuCy+8QAa4jc/4evOb3xzzKF9pl89FixbFjyC8+GYb +PyHLmKHjvsWtoMmkQugBHTIqaAhvS7Uh2v7gBz/A+wbpmTyDO7mlIoPT0aPyldVJvEWEBUFjYyN6 +WiTFgWyAwKBgdFIQXqHSgUcve4NwD9pvfOMbEfrjVwDlt7a2rlq1ircJMSOL0/m4HppG7uSetQ6q +cnQPcToaBW7wWoJ0h3WN5um2IxbXqT81AnsAAhaS6R4wDD2EVwcBRBN2fCLzodljCn7ggQeGtovh +ECUhMhmEhCZwswybSVHx05hQmb6HfUqLbPCARFEgD8hnm1Ubf4VduGF347BPtzuR8SJfIkuhgsaI +OGBcHFwh+lhIHfqB3lBuD360jfdx5wf2ZQJFfI8cP1DDsPgMPN36DUZlpExEZ0TtOCeCKXZl7hkg +IilW6sEbcNFdx9kGr0hQzCLdYorGLPrud78b1cKwjW4LYsMW1IkagZGJgMlmmFewsB2Zg9S93skI +MOfG2x5gU6pmRuYztixyg9CDtIrND7sdKkpSXlZ4Ouyww2JuJv4D+Z944gk+4wuCwQMol8uhXoZT +t77dAsGRUgPFkcM2VbND/2UBgVsNohv1I2vGxsXNRo30hlQHM+ErFMt8r7TJWCKHp2FlyqL0xtLM +Dbz1Sqva9vzoackM8916662xMB2XRZGAbhyjLxoCbKgDm2J5is8RX2Od8JbswcMitu290jk1AiML +Ada4DvPcyOq07u1rggD7FNHW4mmCoAltz4SIKgAAIABJREFU4GaCsBJTF3yJAvbyyy/HfxWxJtZP +YmlDKfq9732P3uJqFNPDlnqOPIrEiU0O3xZmanZxDOSEsYgzgNMvJj30t7EcjBUzdnEayBbfYMPj +hq7io4QX0mAC2Czntn+Fj4nRw8DZr4lmm4KxZAz9QzO40f7xj39EAxwrXbFE0k/kNrJh0SQ4A2y0 +jW2hpkaPSp/xFkbR+uMf/5iC6Jx36f5Lek79LImmTp06IK3SLssgLMdYpukP1m6Ecl4640XFjf9w +7HJFtmFDKW0JsW3EQWfTCIw4BKBSHHi1gnfEvbjXoMP4cOJKgyyC4MUsjwr3Zz/7GfMvXWHeh0ER +UGIvG2gMiyOOKuzrwAUUaxyupLFX0Vb6jeMrkeTYaYOP7uC4B0irVEslyIUvvvgin1SCHhXD5NDa +YHFkKYpA5Eh1SLFD87zSFCRsGAUNM6pdDKUM9rzzzqMS/HrglZaWFmRQtNlsMsF8SAaIkHvwAbFX +2gGcY+FObJDEJ4K68M8aDMUr7fk25sd/ipy4U4FbXIQ1DT5lvDveI+kHH3ww42IHC09ZHGAFBwo8 +mFBos34a2sqWEBuaU6doBPYMBMIwMA9754XXfXsnzDh7BiJ6FFtBABcYdvbjIsv+ztifc3BmhLCG +hgZkwTgRJsPYxmINRuEeoW1gph5cavA97kWoNGPxbnA691SCXBuLg5AokzW8u1mega/oYLm2blUd +yLyNN1hzu7u7cU7eLD+6ayRmKDy2YqKgRnSLQQArVgADgGxWcCtf0WnHiL06nq4f+tCHCHf8+OOP +o0XfSq8GHvGaGDIvN1ZxD6RvdrMlxDbLpr9qBPYABI4//4tQ6QXXfVs2m+tLI6AR2NsQgETZ7oKV +lI1Je9vY9Xg1AjsLgRM+8J/ag3dnganr0QiMPAQwS7OBNd4sO/J6r3usEdhdEIgcvRdmd3kXO9CP +ICwHUSEy+uvRhnJtRdlfbZhhY7I5X+6thZ1pN5FJZLywGoUZy2pMO2MSzqggTBphS8Juc8xG08pZ +hjjU6GtvQyDePLq3jVqPVyOwcxHA0IMH786tU9f2qiIQReVa9HzZf6ZUXxGZ64q1QuAXvLCG6a7i +JX3PjziUNrTqoemHvO4ILUR/lEw4Dbbt1nyrOT0xm5xhBOOSxqGO3fiqdl03phHQCGgE9ggE2Afj +xO4Se8Rw9qJBREboh2u96P6i/2C+9lxjKgddlko1PzAyqVSzNQoZtORVycZSyfNCx3Ic0/EpZASO +7ftRPgitbKrZMDtLlZ5+L9+fv9aOpqSSVhA0kNm2KBnaJn5EU5pS+7pWi20l9iJ89VA1AhoBjcA2 +I2BZpoOYoq8RhEAQlvK1B/tqd9XDp0zLt6zIDq2aT0gcHx4NQiNf8kyjaLNEUhudPGJwSLqfcnnZ +qXylNKo5m0mnN/T1rula5zpCtoVikDCctsauF9YXOHOPgiFnWZpGIiHqf1i4MT2tMTErm5g1Krtf +1p1qWVobPIJ+MrqrGgGNwC5HAKl0l7ehG9gpCARhoeDf1VX+U7naHpmGaxlOZLGdCS70qnUSXNvy +gno24YZ2UKlCr9IsPDq6JdPS1NyR71nXXYg8s2r0Vdp7K5WgIZ1qzKXr1SCw63XPX91V9urG6OZU +X7nqR4btGNXACD1q8MPainp6zerwFrPTzWXGtqYWjMkekkvOcO0xlrFxM+JOGaOuRCOgEdAIjDgE +xFaKHKOv3RwBvIoK3p2+dXdv8SUvKMOjLIBECRsYfhTxDwpMuFHIqwwRKfEgstxkqhDWodpMk5NN +Zzt6q6vWVz0jSLhGjRNCQ6dWMYwg6Ic26zWLEztMvhlUuaEPtbBBVYEnJ/BhA+C+WPZ5mkqaXuR1 +9a4sOCu7CrdNaBvf7B6cdU5OuZN2cwB19zQCGgGNwK5DACWgI2pBfe2uCARhva92R3/1pkJlVWh5 +thUllNHStk2MoCERlMMI6RPvoopXR1eP5rWnVPFCoymRyDXYpuV6VXPJhp5itYZ4Ci/6ZaPiwcSI +nUax5pm24cQHMIdG0sGqKipiaBX6FB2vkCpnYxn1yKjUfaPfyKSFxb0EZas9/WvGNvY3Zh8Y23xC +zjkp6bTtrijqfmkENAIagV2IAHFLkEq1C+8uhHhHqs7XHlvW9YtqsMLAJkrUeMPEkInICY+KRIoF +NDA4o8z3DS8QCTKZsCMz9IOoOZOy7bBY4t3ahZLX0yPnpcCasKGIs2mhSCqMfCHLek1YsyknCuJy +EBSrkkd4WihVclZq8slFNscymhsdoVXTqNneso4eO+pvb/6daf117oTzxjWeqDLqD42ARkAjsBch +QHRux8MvRV+7GQL1oHNd4Zdre+8qV+otjW4mmfSjupw7gLwYc1yIIVMlOJHIkUJtMG2E6bupMRXZ +Tle+UK5Eda9YyEsp6BMihCOT7CY1jFTCrteCMjTsGRzhRcWItqYZoOkV+oxUbYpHEynR+vI99BGA +ReotVH2V2XCSRrYBHXPQideSW3141TfmjF41a+x5+ti+3ezXpLujEdAI7FoEmDa1VLprIX6ltSMN +Fv2/L++8plDpTSWsSsVwQjdlJ4ue51psUjFTTrLus/7x006mv1Q1bT/pGgFGTZjPjtKZZLnm9fWX +K9Ug6Th+xaj5RhqJ0+EQNKNaMeq46hKOIWWWqkYdlyLLcDNKQoUuhY1Fo8sNJ6Dwqbjb6HnsjG0c +xVqjfrsh55noSyOgEdAIjCAEiES9I70VtyP+vyNV6LI7EYGyz26UK4v1Z9G5FqrVupek8qJfqZcq +45pyY3L71HxkzNALonyl27KyVhSVSr5segmM5mZ7VGu6L2909VVK5QBtbaVsFCpGOmsk2LpSUXKn +jclTwhrVQikl7BsabDXlvFFET3FYovbICJBKMZGqnTCxG/AZ750nRMtThGKe4t+rtsPEPmvco14W +qdcRw2rSamtOzUk4O/n8bWleXxoBjYBGYGcjcOmll+5olZHpoBXc0Vp0+R1GIAyr3fU/ru291g/r +/cXQDNxyxaiEtZYmQisYbBKtesEL7UsrNbSxUWjCf1GVwEYhAqXpJozGnNPSmFnfXe7u9su1wLTs +qG6t7/DslGHWjHpZFLnoeHEsghplt6hteNC1L8zHv8A3qphT1Y5S8V1isykevGh0MaYqBuU3IhIq +qlukWKRV6FY5MaWTQsg1L0y6NgJutUYqhNrVUexJJ1qyyQlJi8NhZEGgL42ARkAjsKciQFQ5va/0 +tX+5teD57urP+8rP1IMA02apFnhekEgaKddOoY+1TdSzlVq1wt4WV1yHquWoOeey+bNaxR3JHtWc +HtOaWt9TXLXas+zAThv1UtDVFzgZI5MTOixVDNsVHa/4Dal9LzCr5wunOlSIA7AnIGAHlV0x6kJI +pWA2bQdRUFIpyK/ioAabKt2vCLW+UalCohaZy+iTXQtvpzoRleinjSdwf9Hr9d2XXHOsY461zdaN +Vev/aAQ0AhqBPQsB5AvnZU+R3LOGvHuNJgxrxfDWondDX629ghsuAf7sCDLCKTebsVMpE1Uqjj2R +bdTq4l5ULRlVD2eioKcfQg0gyDFt5pjWlg09Xb19XoQwmzGQM/urPjJotlHkyEpVOBIGRd9bq4pi +FvoUYVZ5FdWUd25SbXERaDDVhkYmwRZSp7ffb25yy2URS+Fg0rmokG00SK5QKfUgm1ZqIdpdvlZr +IayfSJjon32fuL+u69jVWtVJt1f8tbaVce1JjjEGnyepSF8aAY2ARmBPQUD2lRLkfE8ZzggbRy14 +sbv6s4r3XC30oB7XclzHKpkhjkK5RuRIqJNdL5hBI/arEDABM2e14rMrVNFggITKMdsNOWfpmg3k +qtSDVM5go2lPv+/gdss5BfAc1FsRWbOOw1HNcJOGsCb+umpXDJ9wIeTKjfj1KlspNxX+ichrrFpd +jU2kMCUPYVP5sUCryK/qVwObwqOiZ4ZNqSeIwkpEK5FrFOs1L8BDPMqHtXQiEYTV0Hi+bixzrUmO +OcnUhDrCfq26uxoBjcAWEWBidGJpY4tZ9INdg0BP9ab+8ErHDL3QSzmJepWbsKtYz6ZyB87I9eeL +o1pGO463obOroSHZkG7qLeT9AsEAxSFIAilwYxn7TMohFPYVqrAmBGZ6RqGMU7Z4DIV1o1iA24Th +EElF1swpHsVKWhVvo1ipy4YWLvS9pIiCV1Eq9lR8kYQdEVM3BfCAm2M2FdLFdKrkVziYbKTDpg4N +odc1pGYoFu0xamq0xGxudewok0zV/YplEVp/ZT1ak3Sm2MZE9ubsGnR1rRoBjYBG4FVFwEHueVUb +3Osb88NCZ+3KQv0WCKlatyCmSs1PJ1Nlr9yYyrSlW1e095Tr/qimmqfcZ+v1qKda7K/UKtUIdsRg +KRKnY4ydYIwfn3jmhaoR2HMmtlW9yvJ1+SoWUMtoTCQg3e5q3U0ZaRXMCEqjFC1SJTQs7IeVFQ8j +SRMPXhhR7iBFPlHewq9InzB0ykAMJo1fiXCtbGxVX9XuUXH3VWxKQYyv1AOboqiGYtlyA9nH3kkl +YhPKyQmW5/u2FbCB1QuXe8Zq2NS1JmtC3ev/JjQAGoERjwAznr5ePQQq/rI1/Zcn0msyiXS+iOeQ +T+gi9LpFgimUjb7+/OL+PB65o5rs9p6eZMJMp+x8uV6slTFqlpQjrjCZJxrgKeMaK5VkZ3/PuLZc +Lpl+9qVueJTtKJCzVws3dPnoZom4izxKuF1YDS6sI4+qsXIfb4ARnS1yLJEZoEblmku0B45Tg1kd +Xyl+N+VH7ozXXEQApoyQK3VCxioVloV3cYnCT4ojaGrse60pJyZC++KvVDfyYbUhnQhUWAkoPCAc +hBnUw5cCo902JrsWEuoml6dX723oljQCGgGNwM5BwInn1p1Tma5lqwh0lW/pLF+ZcKpm4BS9WsWL +2N7p+2bB92peHZ8gXG0TaaO1yUiz44Tdn16UL3IsSyQCIjRpGC0tRqlg1ENjyoTMaGfifUuWma7R +319du2ZNoeynMwZ+v+hYO7rE+onbEVrWclGkSehZKI2XrT5FQoVZZWeNcCGZuTbKkZxvqtLRDCOe +og3m8mviaYRlHeMn/2F7jqzAhHqjAMETUTYKOUAm4AQ4IkIkI5g44ZioduHduFF0yBU7SCcZb4jL +b6hM9LbIqaVauMQwV2fdfVxrnDSmL42ARkAjMKIQYE4kRMOI6vLI7GwQ1rpqV3eXboCBCDHfizct +sRFwJgqjOiEBPZE4ObYbUsogR3pYHYXGMFianPfiBYiVjuVOHZvs6/ddw28a7TclUk8va69Gtea0 +0bHB58yXZMpIZUVSrKIEph4iM8TBApEvHfEtQgAVDyPkUXazoHr1lTxKYF8lX7IrFMGXfqEBdsJU +gviDuZbW5klNrVMeW9Y3bdwRjp2QaEtcFttccQKGR+mvSKfE3Pd9LwjqtTqaaY53QxtdqPnVVDJM +pc0yp70pHTFia9KhkrpXD2V8lhwPx08QR98wqvXXnnDt1rS9T8LW22ZG5q9c91ojsLciIG5HyBN7 +6/BfpXHXgg3P9VwSeC9mk3BnWCA8vGET2A+CgUfhSyS/uo/QKEKka9uQHKzGNlBODQ3CANmxVIJb +w2rF62ivNbUZLWlj+Yb+UiVAbuyH/MTTV9yOkAUpK1+TYhmVHSyYSCX8vWI8eI8AC2oTCyMXVyNl +4KSIOAqFqYbEmAkt+4wdNXvCqPmjW2fmcq3JJKxpPHbP11qaxg4H1kbjAHtWB/sPwdlB4EGrxVJn +6PWZfofvVxkOS4V8sZZOy8Hh2FNdkWmlzz5nrrKmY0ts2NtdfSiTmNiQ3Mcy4wNrhmtWp2kENAIa +gd0JAVHZKfeR3alTe1Zf8tWlq4qXFYvtYYDx0kolrWmt43vzxd6+3rrsv4QrjbJwqngA4bPDlcmY +yJEwqF81ysQqUv66RDsiazJntI0V6g19i9BFhUKAs08yK362lBX1LYSspE9qE+9ZtdcFFasofEXQ +3eh8JHEekImrbElpGjNq9qSJB02fcOi4MTMbcrmNFlHJvp0X7GixqdRtymWbWDpUKoW+/Mre0hrP +qBIumH0/UKmNSBpFqIlFKSLOwAHCLupgNtJWvbX1sBM2TdmTRYmsL42ARkAjsNsjoKMd7cJX1FV4 +9Mn2S0y7YPl2MmniLE0Mg5UbejxlgYRHEUU5ngU65Ea4MEIqFfLAWknEeo4dZTspXIvUCP1AK2wk +JUJCg904Y9qYh15YTkGiNLDzBEkU6rV85ViEbAo/USefmwiVUA+yJcaQIA+oi20/O6Zxxqx9jp81 +5YhxY6Y7PNs1F9ZQCDWX3b+tOmt91/PV0mo7K9ZfTl1lsPKPduN+il2VbTN8J8hDra/8bC7dmbZn +22bDtncNnTMnq6JwxuArgYlFC1CLsM/6HnteEwmstLRgyRqGttnKixuzOGSh8iawcNK2cpaRk+1E ++tIIaAQ0AtuMgApnv825dcZXhMCG4m1rij9rzPmlctLH/hlEtWqYxx83MJM4e7EFxHZL0GkUofxM +c/ZZiILXxh8HgyXESRxeYu1iVIQcUPyGSK6ekRktxDmmsWFVd2+xJmeiodcNCN3AdlKETrZ1Cn2I +Ijf29xHlPTIiPCGhB41KwWhwxy+a9vq5044bP35ukhPXXq0rlUpPn3RAf35yd98z1ajTagjQMDuh +iZeyYAGx0VP0vAjYsBzfrKhS7/Lt/rQzI2lP20I3Yc5KGJUio+SHxbpfMMy6Y8HEdXyE5QBBgUMu +EYUt06+buBAnHERiaQpDNYe7QrZYjjPQLGZmshGvyW4yooxtNZtRo96oEwOoPzUCGoGtICAmKq1D +2wpA2/1oQ+XacnTdtLbRa3u6raTXz0bK0MRHl3jvEFvgmRUOE428IvFt+QpzBHKES0pRG6ZNWLNW +tEuc3a0CDBHttlQ03LTR0GSYvrGss6u/RDR6MTSixUXKJJuEaKC7KnKCSFqwKYIZPOpKvEBYpi09 +/+gFp8ybc2JLc8t2j2sHCzY1tmbSh69c93i1sqal2S2VQwksLPH68Q9WTkiMQfgUYZGxcYJNPYyW +BlE548wd+KGirg7CvBf21MMezy9gaxZtNm5c8Caipcu56KIoxjE5geEZQ6wl6gDXTrKrtRzUq56c +/GpisY0IcewiHdfDerFST5DFtryo4nkVsXyIaMrjNttos4wWHZR/B1+9Lq4R2LMRUGc979lDfHVH +x2aTztLVa3qvS1qZ5WvWlepFJuhkir0iNvs+2UUa+lF/OcQ1V4ygaDgDETqZuM2A8LsSNMELI3FE +qovcBoMK06DFTRu5JtHi1vAzimrM+81Zq48Np0VRDrPXhRrQ98bhh1giwcfwKFTt5Y2JTQsOOvis +/WYel8m+9vFvMaJOn3jI6na7XFzTkE1IHAokc9VhpFGx5ooBFZ1slHLFxxcxvR6sRrBM2lMNs+QF +3aHRS5AHFNix0IkCHP22KZEMTRBDnDdt6uNoOaLqy+ZaiWNsRJx0zn+TjukHOAyTwZRI/bXAwUHL +t0IzrCD4IyjbJvt64HFqsS3fC9f55npctWBTxxxjGs2mkXl1f1C6NY2ARmD3RwDFn9Kt7f49HRE9 +JNLsqv4fliv3VCvBumJPxZfNHs1J0wosCI/pHqsnW0WZ62tFUyygaiUDGbBV1EkFcoK3b+O+C4+K +2BnK3lDYkW0zmPMamyX8ghw36htjmzPInx09NTHz4WfEdhdTTvmGidEAszEGdsl3Ga2puYcvOnvB +nONfTV3uy74p27EmjV24akOlp9CRSyaQQdG1BqCi3JFgwVQqqtQiTouTU3EYWIRb1obI6CRIsbKA +Qq8MlKUCCwiOYxDLZxhJcfIjsXIKHRlw5mJPj6wwhDglt5CtONpZeEZzniv7YGUlE/ns7xUtuAo3 +QXFqh5fxyRIBV2y3HDLAIqjLM3rYyGQEzY45lYhSLztMnUEjoBHYSxAQW6lY1fS1MxDAhai98t3O +0j9qVbNSg+BkQ0vStpE7odEJrdmecqW936vWoQoUjjLBI2ISLxepNMNhosSgN5wAvWQ9QvpkhYMw +CiXweji1lCO+ieGHT6+YUSuwQrSWbaVwCT5HwijiUoSkhvTEbJ/PGwlv9DFz3n3YwjN3B0l0KLoO +4RhGHbByw70FQ46eYSBCZaislQmTFQMMKk5ZrBAis+oH6YS4KdXqdVdFl8AnC9ZEkYthFSnWdoU7 +SeQTSyjW0FIV8yhkbJocdQ6shC0EN/FykqMDxBnJD6iZgBP0jaUMNy7aXYnGFEG6tBxgd5a9Onwz +0wmeZmte0bTYQlT2zA7bHE3IQ9t4zVTlQyHVKRoBjcBrhQDrb06GYcLS144iQJyfntp/d5fv9Tyx +wqGhRG4y0MeyCQaf25TdU6715jkezczmsNNFhJ4vFpXmFsciVJTInewHUdN6hfNKlbsMUzyVwB1m +ZDWOsjPZoLukyDW0CyiOq162SU7wFp9US3S/kBH2wmpXas7441636EPjxkza0VHtyvKZdENLdgan +tNpJoTg6j7zIaTKikJUYTHCr5bM6gE1Zc3iBhLgU/yQPXiTUou8TKUkyi7gPeLGtlA5j+5TVhUnQ +RJ4i2cOgsu9IHI9ENhUjbBi3gSgsSxOWI0qNHMCmhMIoVX0C8aMzJzvLGliW7b9Vr5+iyYTNEXiO +jem73Ujk61E2YU6xzVG7Eiddt0ZAI7C7I6CmLz70tWMIhGG5u/rdsr+YrSbwH2d2iuzki6SIFhc7 +aV2OOfOw5EkUwLy4xGAVTGaEJiEI8TYy2egZNCQdDKWU4ig09sMQRxAqQRrrrtfnHyjaXRyIeFtE +hIewCewHN4jSUrhBOLW/12h0Jr7h0AsWzjtRaSZ3bFS7vnRL09Te0jLPK7MaMC1cjJAXBRCGFpl8 +ETLDognFAgKMGMusrFPQCmNzlvjBjF+RqJg/EWvBTjKJdE6COOea4g/MU46x4yl55Pcusj41y+VA +sajHlb5YHH0dO5uSEGD4K1E7RQi/XxFPYDmN1Q5gd5gVlS/vixPoOKO1x4iaEtY0HJR2PWC6BY2A +RmB3RIB1ut5CJy+G6DxiHav3MctWKmUsd2FULJX7YagwqlZrUXNzS2O2xbVaHJsjrJOWnUZGiV9p +EFY6Kj9q77s/kUhj7QwtHxVuGDhJE0dcjhoNUo0mceSr1QBtOldoR66LWw15oqBiEBSBeRzirKHU +jcMb4f6CB686oxRehSxgDlS4vT3CrDjHMPUTKhCyZMaHF/iH81FvhzFr3AmnHvepMWM4XntkXMlE +Mpca3VdbGYfdZzj8g+tkUCaaW2hQ2FGiASs/5xhxOBXjKA5cxLuoVMRuKuZR/hNfym0ISMV1SERS +E5xh3XTCSSRtzKO4c/HqJBQwqxF0uew5Ig9kLTGXjFKtRssuil/VGYL+s1+Gt0BtCMGksnBJyEIJ +7bGcHJvgVQZdlt2VcyelndmmmRgZ0OteagQ0AjsVgb2aSvOFDvR1rhtkMul0ItPQOM5mz6eTZjL3 +/DKxYuu1Sm9fR3f/yuUrH1vduaTst7c0JmZOmTChbd/Abw78tolt+6/NX72y53Y8V5J1OBcLHN4u +Ts5xV3Vy8EtILFwm3lIBTaJoKiFCsZIi8CA5OUamSXiUjaGIUrmM7CWtEUKhLMd0s6k03t9SyMtB +aUTZrSiRNPZU4lxuMZ1KJAfl01vInbDw/BOOeLdM8iPqasyMLwerxVFXnXKqtK+RyKOitt3IjvAf +tAqriXAo7kXIl7LrFsIDw3JVYl+KqlbcgGFDEU8pSWIumSQ6MLtJ8dBFBq3UQ8L/kgelLpmRMslD +XhE9xWcYkVQoU0JQ1dEuC3/ziG05oFonXoZ4P8kmVNTOmHJ54025dLVeI8qJlDLai14x7e7rmM0j +6g3ozmoENAI7igDejyNt6t3RIUt5ZNBiudN0gra2sQm32YWymHlFIIolIsnjOhn+ZdPNLc3jZxgH +LPRPJ7rC2o5nXlh+x5NP3PO4edPYCakJ482g0PLC+uXM4aMa3XyhbjlmU9ZyHadctmriESPuMIhQ +TgJ/GKNWisiAexFyEhzAsdsoNg2fWTlAO4CUCadCjXgfJaBV3HrZLUO0vZKRaZBdp9xAwchLyHBw +CsIVojThea3qmLcd99kD5h8t/R5pVybTkq6mfHZzYmBWwl9suheZG/JSZMohM0qIV9wmeluckoBX +Nt26nENnGvl+kUlZfIgQyp1sjBGsysCJoC+KduFattAg4EoMKeWfJa66G+HiTbFzhhWUWE9pGo0y +G3ZxD+Y5fVC6YlZCVtq1pV1OjUPxHqKBr6eSThDwCkXE9cJib+URFfJwqvRVXxoBjcDegYAyFcXT +1d4xYEZZqeWDsH/C+BkJNxfTZ/wZA8C90i9ugkOUhxKrjxk2lc3MnLJo6oRF7Z3nPPvc7etL16Sy +pTU9a/pL9pyJrRbUF9UbUma1HhZKte4+JliUkBH+tBIgQA7nhJ4jN8G2R4O9F0zvrGLswEb3K4Y4 +5nt8UNV5ooibfMWlRoROzmlxJV5gne2kKCZN4doqkf+UkRVP3VQ05Z1v/sa0qfts6vEI+6/rJNGZ +12qVpItHj0QkjjkINABKZExlJU1xOhu7T5VCG21tWOe4UxXagneDAzPRoCgIjJCmUJjyNuLFIWni +CA01qqp4Al1avAWESJYpiKRKD4y4Kc3xH06yUwwotSkLtNpqhBIh4C0Q8NCxUdtjOq0jhoooagX4 +KEn4JMPMV6oUpXgtWBZEfWlnjmXoiPzyUvSlEdjjEWCaYkba869bb731/PPPv+WWW1DytbW2TRq/ +wHWygxk0hgASHcyjoANviRFVNkZgvKwVCoW161feedvd5XL+gAPdYtHs7ovGNTay/3B9TzGXdlDD +MtETzCiRihqahUSRlZBv/GqE06eDQS4OW6+oFC0up7uw45TT0AjhF3MDiRg+C73CnczVCMzwBHIq +sRqQpWDQ5mZhVqb+vn4j6U175xsGf8EDAAAgAElEQVQuG7k8qmDHLbZFTprDJqmYzFEbVORnCWuB +AOeeIq+K2VSSYrpSt8KyWKNhxFQKLyOcjCQZYRFwKIsWl+IUiEvyNdZ+4w6NcVS0AmgCJBebZ5Ap +xbNJcgrpSjlIF0L2cMD2xN+XIjSdL1fK6Ij5PWC0VvlFtYuSIQpT6J1pm1Nm64jCvaX6Y164QTqk +L42ARmBPRwA22ckK3v7+/rvuugvVWVNTU09PD3HSjz322Gam/yHXcccdt3Tp0gcffHDq1KlDHv6f +hM0lxf/zcJu+LF++/MYbbzzyyCNbW8fHE+uwxf5PQ0pMREnIdgh8SYk5x1UL6mtXd11w4bsXHTX6 +4m/O3JD3JrW27NMy6YHlz9uJoFANEU8SRBVIGbnQ6S9wPpry1ZVZGFdSaTORIJIOtr6AKRjB1OZU +NZgSd9Cy/GNLDNISvrhcMnOLFGXg68I9/MrUTyWJrNAq57pkw+nvOPnbU6bs1jteZAwvd6USTWxu +EThYeLC4i4Pdyy4XJVwS417OkxFK5N2hlEUTS5WEdgJDIvtBw9xksmapBNpQqmhiQUzUwypuEdIm +BWVvDQypZE2200CecHDadVOJdE+poMzXikrRA1sRCmQal3UVx9ewqUYdtiNfhV6lCdhUnW0uSmWu +uucTgzAZ0bJUUvVqslsnXJxK9KatOcLP+tIIaAT2XASwlTKF7bSrt7f3O9/5DpHhTjjhhCOOOOLE +E09k9rn88stJ37428vn8ggUL3vSmN21f8YFSsazJqdVb4dE4s8zWTMccxoJIqtj02mt/M3P6hG9/ +6xIPZ1zPGD+h+eqb3nr+pyf25sNsKjG1te2hFcuiRJW6HTMxriWHSycbQXu7/f6CxF5ozIhUSqVM +5UyoWNTQN4ooJJF95JMJHT8j3IiYo7FcQxuJlGyGITMCLm69vCHEKTgGn15maiLu5ouGnx995gmX +7AE8CtpJtymFTzOn4sBvQoEMHMZU0fsgPxEQLUCDkITF4EL0rcrYjMqXlQdeP+gMQDKZgL4Ez0o1 +RFo1N9KcgLbxZy57Y4RQAZMitIhrWX+lmHLNxpycEiPvhT2/IuzSlDRKWV4EKTg6IS7jsoQEy2oJ +m6ucLSNdhVjJaZVZN5ExMhrT2TSHyWGXNaNSdWXJf1qoWF8aAY3AnosAf/nxDL8Thsjsd/3118MX +3CxZsuTFF19E6IQ3uEgncSttnHPOOUcdddSzzz575plnzp8//3Of+1ycGa1sZ2cn9fD03nvvJTHO +iSx78sknf+ITnyClo6PjYx/72AEHHDBr1qy3ve1tjzzySFx25cqVb3/722fOnHnKKafQHxJjmnz8 +8ceh58985jNxttNPP52vdQIciGdK8IMf/ODAAw9sGdW875x9Lv/2t5YuffZzF386n+//6RU/Ovmk +13tVd+m6H/+/j/zt91dsqBtBLuP88aYlX77o0Y+d8sSFZz591eUrOjvKtWqEPPq9Ly+75OPPdq6u +fPMzL3zxQ09fd9UaZJbGZgvhCdYwIptJn80UMCgRAhzHZlbGC8ki4BFsKqH01Oku6lRw5n0use1x +XDYHvJSNwobcSYddPHPmjHgII/2Tw1iCkG0qrF3kR4Lk7QAR/KN+MgCCFOoqVkOaJB0iE+dbbmwT +JyC0qyxK8O1iCaIcyNRmoSDCaC3MKz9IxHq5gedYl8jikVgWbPZV+mS2uJRrYY1jdnii/J5cQtwT +8sJXfCx5xeNXKXElBhNrHaqKwxni3Eud/E9ckeiwEpor9QriMD3lNasO95QDzabAoy+NwB6MAEt/ +EZZ2wuV53kMPPQQtoNeFxtCp8hnreGE+nm6ljVWrVr300ksQ59y5czOZzE9/+tPHHnuM/O973/v4 +HDdu3Be+8IXZs2dzH+eEO6dNm3bwwQejdH3HO97xhz/84eyzz/6v//ovKjnjjDNeeOEFmPs973nP +PffcA/Vyc/PNN1N23bp1sGm5XCZDe3s7KVzLli3ja8yyl1xyySc/+Umm3csv//5nLv78tBkzR48Z +e/KbTyPb61533Mc//h/F4M6O/D/Wrqhu2FBhrnz84a4vX/Rkf6f/pf9adPxJbTf9af1nL3i2VA0C +2+jeUO9cV/vxV1eMmZROpq27/tLVvqoiohe+MNhT2euCl5LJ2Wp2a4NDFHtJRKIiSg8zMsHpuFd+ +NEzc5MRuGr8ktJqd643D573n8INHpL+uDG/IxT6XKEqgA4AdoT0VlF9UpfhqMWrUvDUvQqENz6Hi +5oK2oE/xKJK1BZpYcbuNeTeTEeddQBYmk/h/kJy8W0Fb/Zeq8OkVmRe6owLBXKqq1cUdjH/Vmtow +oyTUWHilOPpetjAhqqIY4Ct+1xKuQfFrzO5URRP0ln+qZhKEYkUhzJOooxItlgHoSyOgEdhDEeDk +TCX17PDwYDW8ckaPHj127NhEIoGaF/pE2sNbB3GTpy8bUR0ufN3rXtfW1sbNo48+etBBBx1++OH0 +q6GhYTMd72WXXXbMMcfw6M4776RyxMpPf/rTfIVKeXTllVe+5S1vef7552fMmEFV3/zmpWk2ZhrG +o49uFFi5H/ZCF036T35y5fwDDhTvFUykdW/O3P1InDp19uFH7NNjfc2yhOLQQOJ5e/OfOpjBzz// +wIOPbZpywISH7u594dnS0sWlMVMzTLhcp587af4huTuuc66/un3lc+V9ZufQ2bKTFdVjIinbT6HM +tZ3sPhWLqUifShVMWZhVFJ6EYkD4VVti2FWJANvVabTYR5503Pul9j3nwvMoUawK1wh5xmTJLk+l +s+VFIHiSjv+uCnnPid7CgpJP+QKRgZ8w3EYiOlheNXbleOlBJuFUyiqfXiRTCkmgXiE8AEcwlXtF +e9hoFZsi4KIujmlbRcAnG+tAlyDABNkUchSPbvTN6SRhDkNYXI48FQdgieIrNgH8y+gN4YHpj3gz ++eworvvtxNFPmvupYw1pU18aAY3AHoUAMdLU7LXDg0IQhLEgQq5cjs3xSegTEbBUKpG+dQVv3Djc +yQ1SKZ8iQmz5WrhwYfxwxYoV3ECl8df999+fG6RhhFduqPA3/3PNX/5yE5pbvsLucbZhP7u6ujDN +0vP5+x+IgMhBoHhicslRZzi5BJW8fVXN31AqS1WiM3SMnnZxEBo/Pejs60YPOX1OZvWK6rrVtbEz +M4hEXDP2y6QyRjYrX9DlcshaCiejyObEaWb1aoWYRSLiQKuIYszXG4mTYEnUr4Kqo+zln9zTKPF1 +u5vedsJH8OBlQNj25M3tnLcnvX3tLiLfEt9eTJWyrmNE8fARx+thOiUR5ZFHfTyPoEbRwspPVqRA +dbCa8KRKJ2gDat4k22Y4CZaYUBtJVOoUDhVfIXEakosqNi0hqVzuxTa6MVHIm5QIt2pLAh1RENKV +c1Xla9JNB5GHFJu2eDd1z1IxH0yLuI+E5BD9vDLeypZilAu0x4nuMKrJhtR29Popa3/Npuod6A+N +wJ6EABMJf+s748JfY9999+3u7p48eTIq2dbWViLYTZkyZf369aTviH9TTITD9nH8+PGko6GNnyKV +ckPinDm4TRrYa2+95TYYPa5h3rx5yvVH8iIrw9b4Q8UuUdyPGjUKyi8Wi88sXswOCLY01IVL8d+V +/NXgmcB9Ojbm8RX5I+3Yo8ZAjMYTizewedRJWGtXIlgZjW3IJDI1c4kNVFhZ8aqKZ8SmRtgZKymh +i3BtSbENJi0TPdtp6hUJSQ+nosCEMFDtQsOxSpPZnJRinzF/6ilz99u3NsAHO+fVSVdf28u2XdiL +9QESpBIila5b5FHRuJIGHUo6nAk4cCh0pJS9Ig7CwWrZAeHJphmoK6UWH4ovFfQid3LJlhdejSzU +/ldspVpMrZIi7wubqpQV5S3OR2x74XWgb4dZcaWWBY5RqBDgkfcRFSpy+gwloGnUvOyowZ2YUiiQ +ld1XfKMomGahJPtvxLpbD7pqwXPSkr40AhqBPQuBeKrZCWPCSoorUOxthGTJZhgkPKyVKFpx/OHp +drTBLprp06fDlA888AAi49Aajj766EmTJj3xxBPXXnvtk08+ySd5zjrrLFyHoPPFixc/8sijGzZs +gOBJnzx5Cp+wLJ5QdOyKK6447bTT4M64WpSFZ5/9bu4/+akL77rr9icff+S+++6GS+fMPpjE++97 +6Jkne/L9vgRexenUsZFCXn9qG/e33dC5+sXynTd0rXihMmZCcs7cbKEgebg22j4VrzLdo8gtl8MK +R6RJiDshS9nrgjxaJ2qgxIMVynQMtpmmciKqIg+zQwZ1JTcEsg/LzQfu+xZcizn6BKlL5NS4md3m +E92DsMcrv6KQDUKy/oA7NxodQUMRJJVxehpCIepusRxvZNz4fDRYTJS9eBQJeuKIJJUANZ1QdlBl +gaZa/snBAGpbkmJrkOcnqcoL7BKVUFqPEnhWxy5OymtaeqVaRFHBKgfEWZcVKxwdIwNF1UzHyCNH +thF70CTspLgaywFvvCaJ0CvjooM1n/MHHHTLvrHeN1ZJX/WlEdAI7CkIMB3IOnqnXKhPEQff+c53 +3n///V/96le/973vXXrppbjLnnfeeRMmTNi6cnUrHbjooouQbt/61rf+9re/HZotm83+8pe/RNy8 +4IILsKdCmT/84Q8XLVqEfPmVr3wF/kbZywR35tvPjMsyYKRPvJbY/3rxxRfj6IQMLY/UbPvlr3zt +vee+75GHH/qnM0879dQ33njDn9mmMnmfxhNPmbL8+eKF73iyN19raJDsnPKSSEf7Lmz86Oem9/f6 +nzhnyeVfWj5j3+yHPze9VJM5U6R9JfkwWQsnqA+m3UpVHjHfMnET26gcbyf1jQ0dG0ka2TQmYOV9 +I9pdsZgixRaNaWOPGDN6ZrWGlC31IcYxW8M920VeUsPOupD7WULdd9+999xz90MPP7h69WpSXlnl +bF0R46XiM6Er3oiVSbiJhA0O8ig08TwSOmQdIuKpuJ4jC+JDC55CnNibXXXYizwUcR/JVRWUG/5J +HuWdxNO4IXbLSB5eBKeyqV2qNCtqdrW4oV0ombZ4g/C08GssFgt746kkMmsYmMqHSWWTVqRXjZkk +SyXMqLJpR/amik879lSEWjlsVUytK0Kj85Xho3NrBDQCuzcC5pxT/uWun/3nTukkEyiWUcRHTKTo +VKFPxFOchvjcPql0oFdIlhAqs9JAymY3NIrOFqcn0uN2ucHpCcrEdjuQeaAG0qHhuFfMzRwMg7cn +5jIOFK1Uy2vWrGlsaGQqLRXqXvrainXrhnWVQsmfODnDyDp768zeSI3ptNmUlLPTl68qMem7GTtf +EK1eOifMF9aNpkaZgl0HMVj0fvU6T9kmKcwt8QK5x3sFw2dkFEvCiHIajIR+lSgN6BXFdmhKVbKL +sZI46dCvHbj/MWgQXYQdh1lZds5ABlxwtVS7a66vfe1rn//857dUN75m+Ijhqj04A6oC/Ktl2Nt2 +dRcWr+18AeriSsgp36jBo1zKzWWTpVoV3FC9KhqCMnldshzhQy0CRShkVwyUFxevof5WzMcxAHAk ++AgL8sKQL0GJJpQhlnSYVcgS4ytsrfop1cKISMPxAoUChFuyTey1tTphOmTDMfttlIArBcgsETZE +DpbY+hRkEeDi7eu4JXYhw7SmwYIA5yREVnT7hN/HowklsmsTCfEAy1DrMtW0/tAIaAReKwSQ+j70 +oQ/tSOvHvu8LMIGakXakmk1lYabY4Qi9KCtx7KOwGte2T6mbatr8v3gFb570f783NjYOJOA/HN9z +M8CjAyQaP0L/vDG/6N+QH5Q8JL6Y3Bqjx7Rxsppfc+rh04FzX6Xs267ZNhoHTbtWr3HkGSEDId4m +vIsis7/qYTQl9DwB5BJJzknjtDbZ7iJew7LlEdYTI6i0owQb1IJQJl+gTPKgtGSrKI1CCczFyZzM +1MhGTkqETlHjquKu3zy6ZVq1WqYnNtZD9kSKbIsPk7AFUz+UGis55e7Vuli+sNNpqO6dtQgIxxbr +bekLUhtDoOeMBTrDt7li+cWa7FvJpuzA5RVJOiQKGlCanBujmFRiJmColkQ5vxSxkEqEXEESZy7O +RUdPq3bl0g2AoZCwrrwZWanIJ5ZOV26Qa2kdyEnB+E0lNMrF8gd1wkYij1ctnNbOI7LyIaVEGuaN +pFxckZFHfaL8NmdyHf39cHOlxtFDeATTcQsfNrI57KuJKqG1OGMfgiu31KIvjYBGYEQjgMFoRxyC +ho4d1uRK4WP6Gl0MZ0ACZnoednT/604MHxomUzAzI3MiE7bEUw1DlK1BPaxW+4r2761aMRGlSlYh +lbB782XbDuolo6nJYTrMF8IgI+eGIotIBB7IgFkbgZIY9Ak5ZJSJXk41YWcLs7ZiO6ZfUVTiHUpU +I4x/lk25WHXJNCvFkZB8Md1xUUT2UxKIrmI0JMdxHqoHS1suwpbtQBqKTZW6UhgIMojZiPRtlQal +lR25VqxYPpRH4wq7e8Q+vY1XnXAJsJRiwUo9wD9WhDwxJAeligQOhN8IYAQHEkwqAjNlwoQUcZSl +IOZVZTHlPYbCeRiSffHnAjcRTEFKXUKT3MdAsZSBg8msSJGq4GPqYnsr70taUbEEMZ2y6CECAw9J +rIoxWF6r/HAUrcK47HLJJp0KFBoYWbyP3KDmV9FStzVki3URqQm8gdZD6ZAJeign0HAKfOQUK8Zz +GXvBxs7p/2gENAIjFgHW05ummRE7hsEdZ/pDCI4F0ME8OiCSQqIxj4o9DYEDZ0smOZiN3X/sUOF/ +THLE2w2Duuf0eX/tKj3TmGzmuDRiBHoespDR3c2+RqMBF14i1jnEx5V5HKGTfSy4CNVrKPpE/GGG +54apXiZQbhxCBUhs2HLJwAOUi+ZFo8wMWxdlrwhSyq2GOZ1nwg3M6RJAQKriUc1Y29W7wghSaNHp +oHSSOOvwPr0hM7WpOqVsXLs0ssuv2P952GY41nvY9GETRf6UFyLSpECKO48fcuKKTWxeE2UvLw36 +5A2F1TpqUlui/AEycXRR0nJaDi9MrVQ2CpqsJJSnLmwKhrCjSKLqly6bdJXFFDIGeZ7SrKyl4kSV +E9quSiQH6UkduV8RMApnTiZQbYmuHm0ElloeUS2hGyDsdMKtQvw1P5toSLpWVQqYzWyEQjAlVH8Y +4u+L+QBPXonuYHPaHuqKvB/pkPfD/iJ0okZgZCHATBDPYSOr28P1NmZHRFJu4vvBuRSHKpbZ9BT7 +KF4iMJGIoQiVPsYwiSmBdprToiv15/vC29PpJMJq3a9CcxjLknEcANto7yQ+YLWlmQB3Jv668bws +c64tDimsULKI5Whhg4BwgMiIeO36tainP2BrKdMxlxjwkFArRhk/I7yCRWO5UdMoJAEZCNGK2ITw +1NRsVI3u+57+dr5/nWmk4H4q4SBOjwUAPRclpKJexaOUoj9xceGBXXnh3jVs9ewHmjRp4rCPhiby +aqq1EpTDekJ6LshJx9USB2dpN+0muFcrD6Ex4vwh/8XSJC8TBx9Zf/Am1IoJqypVxeHxYXPcoQFE +/gGTqpanRKgHf5qAAvkXp0sNSuXL15h3EU+ph7LSnCHH+NBDyUwK0qnapMNX3gVmUTy6qRnS7C0U +IX52l1ZrFRTg3NBJll4JmjRMOVA+qKOIhlartWrFWxLybvWlEdAIjGQEmILUKckjeQyD+660y8Ss +FwIZUO3ydUASjR/xycX0KL5GPIyITMOFSIqOjpj1fr1WryZuSqX6c8lEf7E4c9yEMgYwUbrafIp4 +Y0fJtOlXDaZNO+FzLAzzKlv2MzAoU7YlpjWqzzVKSHSZgn1sZvIkm1V7SROxLCVheOkr9lG2QjIR +y8VkHd8oZuWQGf4x9WeyRkf+xZvu//dVax5IWA3E/fFqnldWmmhZCMiQuUTAjm9YAmyy9qmEXfIx +deo0fKA2qxpG22fWrLFjx22WvqWvhVKHHxRgsgFZXBEWYwnZyFuu82ZYaAh3IorGu01iTmNvcBwX +kKfgBt3iOiu8qUAQOZV1BwE/lEYXJiYbtMc/oVVu1KECVCoUjl5dGhHVOi+CG1T0ZCBdfk2i1BUt +gigJVH5y0DfpsOorvyEx54oG2mCnTJVNy9I6RTlZD2s5HZLNTojRxG+oB5zdJhtrlHnXqwVLt4SM +TtcIaARGBAJMBuItOSL6uvVOCjfi4yMLfzWVbso9QKIDN2STE6ZFrGAnAxMa2zC4h1FlavRrfqVi +Va2Ha85TYWD3F6q1utnTDxuW0nYSdyEElGqVQ0OiejksFUOYlclapnrbGNUIq6RQ9uL2hKsm2sl6 +2eznDHBOdGHixsmIaV2d3c15L7JbVGIlyeGjELAwNDZXJCQ1jzNfS4oiKTyBSY/n9DXda/7ywBf/ +8dhlpULRdRogTk+d/8bMLWQKfaqjVWMqYmbfeLMJjZ3+Xzb+HrpoUUtLc4y86zr4fxGLar+5Em1x +Wy5WL+u6l1puiLkxxT/XTnNCui8x6OEmsUkSo1GkQjxgwZkXxTF2lqyDVGw/svEP8VH4T0EXcxv3 +rD/IDDXicwsscW3ciDbeU167oKMUv6KBhymVmleqlRMGpO+sh0CVl0tG6sdZF6qO6wdbcWhSJE0l +eBOTTnMUl1csPyZZOeEUlUnA/hZhjxyb4INK0c8jSFcOCeKvj3Ldem/MtvxUdB6NwO6LABaf3bdz +29wz5tf4iif0wZZR6ohJlBvybCJUJkcVBp3gOEiMGB95gHE1QMtrV71Ov/GmWokzXiT6m52NVvd0 +JRMOIQPLbHCQKHRioUy6tsyVFno8k+2nHOuNsriju4pGMZtTsRckUmAALyQzYo1zlZ6wWpJZW3rF +gZe2keFkb1csdkgzzO9cSKTMxvF8DWGQCI+QmYs8FPXC6qPLf7di/X2L9j131rQTU4kcRZHccHLC +eksRPGRwE8WzV471ZHKnbCzmUgMpO/tC+hw1qo3NRUSGSqXSuHAPuH29bFPIm6vaH/GNHgZY9kL8 +esA3k2aniJMvc26d0BjkBOBsImnIuL5jlKoQKwQoXGi6vAUJ5ierCIYZmnZCjl2DAlmXkCL0htCf +Ems0RWTFA+2RBCwxMphaUeqqeEnyKEYe2rYlhC64ST28D7XfVMzjMX0qC6sdmDhsx3ZusgnIlKdr +1KzMt3yrWfWcg78a8X3pJL5UqSI/F7XxmA6wvqLz9MkzViaNUf/7nl4WOJ1BI6AR2J0QYPZQEV92 +pz690r5AkANF8DkauB9g0MEpZGY/ImwWYmZUBVGyoT8UPlW2UnyLKtbt+cpL5SKuugidEZTakHEK +OGiamOV8dj1Wy6aTwvXFKOeNNHIFE7clwsX6Dsx2RlotTjB/4hSE40wijaYPrsOwKZIl9MBx32zS +YF6GYhF00Dfi4YLRlBpkRhZ5hZlb+RypkUEMlGLKpQhV4Z5KDV2VNTc98JVxz//2oNlnzJ52UmNT +gxqEcITt27AMOkV0iJQQXlFkAA585Yq5XN3unA+4k8AXr7SucqWwesNj1bAbqisTH8rEpUioLl+q +i31RBWrgFTF2vvKOKvWwMZXCOIxSGx5FTGQJgocYRUQehSnJzchVjCTYCQ0tCah5QYBEmBUi5MbZ +xKYALosNJcqDCTIjKypVPCJeZKwHjivnnpxYVfl9oXLgYFLSJVq90iHL74iqaILeArFwpLAqrxv9 +fehaCZZLpsdyx/PZf4yWV6pjHzJOfyx0cCCznLxnrnPNSa8UQ51fI6AR2B0QQH7DDzGeYHeH/mxn +H2I2RSQdkEeRLwfXtUkYFWoS4xffmcX4j1Ao4kcds1Wdia6WKFVW1xMPRHVO+LLgQg5Ma2lOyK5Q +iRDgkDmRinBscROcGmOns9AhUzzhGuyk7RaLVVgBqyfiYE3N6dw7roQYlF0ZSEhoHS3hUbaNotcF +eEUG/xuNge4xp4tkSU/JLN838p/0XDaMGPgAExEplTVqtrGu74XuJy55eOk1c6YcPWPyG8aP3TeX +STJyatjoMaysp6gTcZ+R2mTOF2su/PQaXjh2dfev7K8875lVPIPgRWARARSSU/pVERphJgYCDrAm +KwM06p7f7Zd4ydJ50tGoxCpftUSAKUW+JABvgt1N6LvZ5CSEB+Niw6YVNAeyWNnEu+As8ebV7lJa +QgSN6iGaXi46QzotwIXgD33ypqiKFN4LynbeL67FsLioE5Sgj+aAcPxyr3ha/hunh2G5VsmmExk3 +4wdFjOicRYP9nC0zhOtwbc44xFmBcduhsYbjBDHRvobvRTetEdAIbB8CcND/Z+8+4CwrqvyB9+vc +PTnBkGfICAqCIgrKLIgKqCiKuqKIICL4N6OsWVHXsJgRFQyoCIqIGEBEJC5IEslBJUgcJofO6f2/ +51T3s7cnOCLujtL16blTt+6pU6fq3nd+dU6lmO/62DKvD7kIX+R3rc0zKjgKLkuKSI2GijPxMiDU +TnWDnIG2JrcTjf5E20BdxyNLb1nY+8Om+oWtzZO6u7ssk6GclyyxFiaWNtoFl/OWjrZgHxC2TQrd +ygHMDB3srSxe6lQQJ3yZulkXo339tDp1Phib6OZegPQvRYxJH5M0tTMKCybo66KpqeOwaQx2OhQz +dTH0BiPGSou5QzsDAKjAqYhJeIZ7Y8nN0r4Hr7r9B9ffce7smdtvs9meW2z07A1mzm1rAzrh7A0H +b+CR3oCNe9JC/b/D0d7e7qUrHlza8efewRVTZ9VV7OlvNpYpPxzmzXFCWcTZdmntgX9o6s/CmGJY +w7gCUVqMWzdc4upSMDisxsGwXwcajDFrOk2tZwN3IeiEyVGQL11BrphAsNLs2loEm+CMIO1LLYYM +snpHkF5TeyMwtWSHl1aWcvbrcJGWu9+ss/qB+rBrB5ywFqet2ZU3uHnjIr09rU2NPjIfon6Yed3t +lSazk3yHKJxH2DPU09ykkgvqqxuvDz+rx1eGnp4exy5tsskmtZ7u48t/nNt4C/yft0BYpdn//j+X +5O8SAFIWuxOXmj0KR0viKAtBTR4AACAASURBVBylKFHG2FqsIbWuAto2tPb1L39owVW3333h/fNv +3XaX7tb69uUdPX1D/QCvbrCBa7ZlIpdq41KHuTSZtVu1AGTCJLsYAcrKlMnNjy7qXbSEzVk3dXoc +PGJ3nrByqgMcjP3djXbrDcVdUMFsF1aXk0rNy8WcazfnE6UxY1uASAnTkxNYNAfwQrPnLUTkIsaK +TxjeyBiK3mEj/L0IrOGs9Ny78MYHlt7Ydtt3p03afPPZT50ze+fZM588ccIM547FIF/O0Ckml4L+ +10IK2d3VtXTpykdWdi8YrOuO/SvaQgRdATUCKHHuN3d6uMoDfkqvAoaFYcqUZPBFHyOqcN6Pr+ju +7pELtgXajVTkwJfudezhn9z9mTu+7bhXBtBKTyRDcNlFv5s+Y9qmm23Z2x0+XhnxZanrt3gat0Eb +twUpQbgS0SjdC9V5CsgzNbev7/yfXv68A545ffrE7512wRnfueBnv/k8Ud/w6hOetseOb37HK7wj +gvEHTGhp6DfH2qCo2ukLmRXlS8oeDMYhV7XSbFbaYN+hL/3IXs/e+bj3vspwfUPlz811MyuVdd3/ +iHF//fXXX3755cccc8zo3b6yQn+5OA3iiiuu2HbbbZ398JfUkZjjHM466yw7bjraYSRNZ7Hv9NNP +d9zvvHnzJP7iF79YsGABN75TIhxo+DchovODv/a1r9k99FWvetW73/3uWhHjkfEW+NdqgTDI/Lr/ +KQOMLDBJepHRv/DRIFqeRg2ZL3EJzRjuwSa7LvTf88D5N/7pFw8v/PPyFT0bbVaZPXNiT3elq7uL +RxElNdoywaLAhv4ue6dC0mp/JcY4pQ/0DU6Z0LxyxcDS5QPpyA0hgNzKlUYtwaF9fa30Hwh4iJGy +0PuQwKlrTByoSdfHfOA8VtPwmz8+YX5g8rGowlc5IjB6GR13ijmVTCwKOozj7tD4YdWxNRtj+6SJ +E+NpX9/K+xfedt+jt11/5w8nT5g2bcJmG8zcava0nTacPmfChM0nTWxrbUmlHi3yDwtx1phDPTt7 +eld09Dza1bukp6/beKd+QKs9bHM+rb2FOXWlxEQh32B2I1RcpeI1aa702QYu5ovQLLy+d9x2z4oV +HZJuu+XuRQuWPXvf3XzBFpw8/8A9kGnksjIIE6w0jum75/zwil1223qb7bcsPl5IGbCZtmnUPxo6 +CtXIwcG2GIzO6MskTaKpmd7TJ7YuWtj79ZPOefoeO06byiMR2ZoaWaU+E/7z2OwkFu1kMNzrjTz4 +wEITpjbbYgMwOQzP8Lu+0tLQuLK3Z2JTm14act7oANeYqLyy0vBgc2XLwmTt1+7u7m222cYhhg5E +Ovzww9cEpa997WvvuOMOBwx89KMfXS2U2mTDURAmGdxzzz0ORiyF/vKXv5T4spe9bN68eVI+85nP +WCDrUIr3vve9NjJzEBNoXLt45al+7ec///mf/OQnT3va09aFfpzm/7YFaNHbbrttiy22WMf3+38r +7fpWemNMLfxnDl5/ceHW0NRtzSQdU7NQl8AsdrWt3vPwRbfd/fM/P/xHA6LIJk2sbDS7bumSvqGK +abc5dba/3ppO5qWZPCu7B+zpCs+4Te3OQM230YgNlUce7ZcOXFk8gJBPFYqaGmNmNLXK11dv5m56 +calZKXQ0EstJ49aom9kuOZOFecQI47YVqF06Nvbp5ful0+PU60iJPo/M6eMVtz0hNQ4wTBkF27Ly +MBCAwQe/w5atd/bMgvuXLfjzst811J3VXJnQ3jZj0oTZsyZvOnPalhPbNp7SPnPihJltbZPNLCVJ ++JP/9kCGaH/4aM+f/s6+flvnQtCOnv6OgYHugaH+kDD/IDixo58BP/JFsPuZ1+IBnzmQGW1kLhwy +DcKCZ4/mvoyeekvq9c73Hxaji3V1X/jU6Tf//g8nnfyuZZ3dzR5EzmDi/cY14TJM8IG6E7/y9pje +VV/XuSJeq5aP4lDgn7PuomgFpeGuv+JRNDWC8L8OYyqY3HSTGRf99mTp4pJFeNxju0H/sW6j/Ixo +C23SX/fxD566xZyN3v/Rw810kyFGSQG8E21bJyzq6PCRtDa2RCH27h+M7hAPSbV+cbW6OV9R8Fpr +AGlO47n33nvXjlKnnHKKbTQcLbBWZjphEwHekUceWci+//3vW+Y0Osvznve8j33sY84edgoTg5Ud +PPrpmuIOWHTOwZw5c9ZEMJ6+XrWADtMznvGMSy+91OFa65Vg678wocQg0Pov6NolLGg6mkZ3eEy9 +VDV0aABT3cOLbv/VtcdfcM0X/vjQXfymLRRatTppRnXCxPq+ob6+3lhz6pCv+sZBqpy+tLuCwbq+ +Pg47ai9GuHLbhOqipYxKuFspJ3MVZ2NsEmftY+pubIzYWUJqjq7SQ9sTw+ReM48sz0jlG/blQIyn +cgPS7Ny/tLnRUAAJAPwJAFS6kVp/xv8kmvHU6uiaBCe1oschKyQuU5Okx6JVSyGtqmyoa+VQba/r +q+9c2nv/A0uuveG+cy76/Yk/veo9Z1zy5tN/9drvnf+a753/hh9d+I6fXvKfF1x50qXXnvLf159+ +3S3n3nzn+bfedclNd1xCgGUr5i9d9siiJQ8sXHKfvwWL7354wV0Pzr/1zw/fcM/DV9/z8BV3P3TJ +Hx+89E8P/fb+Bb9fsPwPK3oe7q9bUdcUTnKwFB0AoJXOVV+b2wCzRDtyejXxCca/aBLVVwsNL4vZ +QHlwWTxCoJpT2x1SoHui0Qb9QSATxOzMF1N50VTqvvrFs5+7xzGHvuT9N/3ujzgLx7/1y6d9/ZfQ +zrrem2+86y1HfWzfZx7+4v2OWbxwebwUIYFw/oOLDnru25YvWylXZ0fvQfu940dnXBjvtFr35f86 +43vfveDeBxYcsPdb/3zfI1gVae06GRPCDdMmTAafwNeo8iknnXPNlbf+5KxL9tvrLZf85jpf1LdP +Pf/lL/zAU7Z73YsPfM+dN92jk+H4tfhK9e0qjZ2dXS854H0/Puu8obplGDpPd4899nBq4cEHH7xw +4WpOZOODWZedrte0HVXUelR46Utf+oMf/KAkGNe88sor999//1HPh6O4cfOyWsY8UouvfOUrT3nK +Uwi87777cjsjAPPYisybN+/Vr371mCwOFDrqqKO23npr3CB3eerQw5NPPvk973nP3LlzeZI5lku6 +kxP3228/JvgLX/jCwly6Qr/+9a9bxMw7vf322zvbUaK2cs6jcVnpl112Wck++rpaURE4w1FT85az +3R3DoMTRucSZ77vuuquWKel84ChvvfXWNTHUiTniiCMKsYOtdt555/vvv99tKcjJyir4ne98pxDU +rmrnsEgOAM1ywgknSF8T/8Ln17/+9TOf+UzN6KzJu+++W49Hx6V2jhOZlatS2s35zc6T5p/A06uR +Xk5xdvu6173um9/8pggy19e85jWe+kWJr/Y79Jq87re+9a3aeU1bcMv7hAqll5w67J+t3r6wEmom +qdvzzjvPd8A9NdrZK72oVKp5Rdcjl9/06V9c8cE/PnBLtZ5BGXUHbNbKzzJ9MlRbGBamodCGTUa8 +YhMcY6s2QqLiq2w+BK0TQ31aR1qMyKKOMYegPj/KGc7Bg/7YgyimyUiBkZQyfI2VMLlaNIwYMFMJ +BA1LyOFiVknm7F/x4J9ngMeKDmYccxMotg0jq7z+MAzczdFWtSBYQdOw80iSm+ADKlAN6TGxe77J +O5CVGc3t2dw2UGle2VldvLDrvodW3HjXgitufvCc6+897YrbT7nkti/8+oaPn3f1h8797bt/cc17 +Mb9v/tX3Pnr1nxdc98DCGx5adMNDS26av/y2hR1/WNx1H9TsHFjcM9gxULXV/kBYw7nZITOX2FHN +XMZTDMTap0ZaL0WrRr8ExKoOerToo/IsvzAo3VpgFDOzQW96gLvtbu8FFUOwWl3c0WkGthyqjOeP +zvj1ksUrvvad982aNe3Ur5zrdaj7Iw8vWrI4ANJmGid/4bt7PmfXX1/57VO/99EpU9rJFlZy2pEz +Nphpv4ir//tG3K687OY/3zf/N7+6hhje/7lnX7zLLtt39/Tfd88jFrWQUDUFX1YaqF5jiOrn5Bo1 +Hqw77IgDd9t9h/0P2vP753xsr+fsbObUBrOnffSTb7jm5lNnzJx0yld/0t7S7OTZZKKv1vv6Qz+1 +9babvvhle1mc/PDDDzug13m6fLPmpX/jG9+Iwv6RAfxcddVVRdefffbZdK4jCEcX+NBDD9H73MWH +H344VBv9SPy0007jBP7kJz95++23A84DDzyQ/Qr5wImn55xzDs07Jgtujg/iTuQurjGUwiHsCOGf +//zngIrtW6Y+gJbPfvazBn2dtPilL32psPr2t7/9rne96/Wvfz3XNESBptLdclNrt2OPPXa1Q7Or +FVVGC6PLQcuf/vSn/+M//uMDH/gAsB8t87Rp0wD8t771rZJ47rnnOkpyp512WhNDPZKCW+jVggvB +cFIpSFPzAXz3u9/1lkcXoZG1vHVlwO/mm2+GcJ6uiT+B8dHCRIJtb3/721WZ2EDR+LRzmuUFh8r9 +8Ic/zF0PvGGn2knXD5BewNItOQuswmO3jpq+6KKL9JnW9B16TV43sNdZ4c+QZTxQPgZ56IHHLXjB +P/vZz3xnl1xyyY9//OOf/vSny5ZFL3vV4CenoyToyT73uc/VBYN5q5L91ZQCqK7lu1Gir2Q0q6Lj +9tzzmX4MO+2483V3XNoz2BO4Ulc55RM3f+Zd15x35j2TpluGWOnMg0QoZZvbgi5HfCi96nhnA6Sg +rtmBHhUrK+DTyuV1y1cM1Jtp6pgSutPkW+o1sYHJGGZlfxxoyvtHTYMKQGKqEbSAc3QtnQvM2u1f +C7Rzb52wRxuDMp3NsaKG3keGXqPITgJ/ELHgbrmVDl+9QHAeKM42TS+xBRvAhkLnJcYQcUzhydZF +ZoYwgd1Jx4GQ8FWD2DLC1TKbKNrWwaZakbk51D0Q5qkmM/COKVjOVMltbCMvyXOAs4hE5vigEikJ +EF8YP0BKSDzFxUvOHolC1Y56iTlHKRtKrSEeTUr+jLjt7YNZ0Rqai/t4RVccVhY0OVo5bWJrSzOn +etyadvT+jx6x7fZb7DnvqbfedLcUjIM5JtzvRpRbG6656vcPP7how9kbNDaZ6JUESvP66ur2es5T +r7z892D7souvf+0RL7zhujv7evt/d+0d02dM2WzuxqUBkY3kCeuTVD62QPrsSHmIwItuaW9pb2uZ +PLF98tQpjTGjrG7f5z1j623ntLU2P32PHW68gcUMhS2KjR16j3vrV1pamz7+6aNwHqgu+v4Z34EZ +hkLnz5/P5rj44otl/4cGDr2tttqKoaMU/ttDDz10THEwEnTR70xPSnbMU+obHEJQPzE4pHdrKpNO +gFuUsKFERucyOsv9y+jxSGVrj4A6vQ+iPv7xj3MOFxv0oIMOUm5LS8uznvWsmlWqUGKzjQzsQV98 +GFvUzgte8AIYwO8NUDVgjXOJrFbU8gj/M888c88993z5y19u1rHsY/LCNpqt2GGnnnrqkekPXwvD +Mdlrt7opcrGb/3LUYz5TuvOenZ3JyvSoWP9r4a/iXtYOO+ygygQ+6aSTnvOc5/AKqIj3VStO74Sl +++xnP5sb4Fe/+lUtfdVIeU2u5eDnM844Y03f4Ytf/GL9GHKWVRKrsnqipfgV54Lxx6ne/Alf/OIX +/Uj22WcfKgBA0hRf+MIXpK+pBK+Wl0b/jmNHV2hNZKumF7AsVz/dEgrZ6M5B1rBu8bK7O7oXeNrV +0X/fHcua7KhQV334vo5F883zCf0+e5PYowZSsUJi2V/ai3VxSmno+uUrQnmm/g+1bL4MOIwBtYqD +X8wZiaUyFKjlp8CAT1gWPKWU89TgIqXt1lgdSAvfr/HRlkA72OAR/KCLYVIJEMuAKDgMHAUhcKs9 +gDbgMOfphPGawEwMGEBxKw5uhSVHvlT1wMYj2Vl+zO4wnXOxDQ5QB6DibzyvABKElh2NXIA2nMOJ +VezCOA0nA2GjFVRchUvEo2i1YQjHWUhoiZRoYjiaQ4luCR/AM9KIAfD1AW9geEJrvVHnyIJXznZ2 +DRh2l7OHVKT0MGCh1ov0ZCvW2WWT3sFpk1rbWiBt3RZzN1YLCDWhvcWrVx3lCjalCia9lRNPfosV +xYe88P996cTTu7tA9HAVotzGur3m7XrVFTcNDQ1eedkNrz3yRTNmTrnxhjt/c8E1++2/x3D1w5cb +GB/y6C5kU+As7hpgL2RcdXj64whDk5jiTdddctF1L3/R8fv/23Fnfu+i+Cw5FaIWlSsuvfEnP7rs +ze94ObObPKYf3f/An+jrN2fgaCl7eCXrf+DFDFs+3jvvvJOPdO+99x5TEqS89NJLIR8Fyvoc85QN +xPlZEv38AWGxisaQjb5lPh522GFmNrHDeCZrj8BAiQNgCt2p8m41ApGAHDjXdIWADQ05ahlFilXN +JtNyxx133O67785gHU0gvhZRlVgmXtUOPB6Tl6imdzHvANUNN9xQvNZrYTgme+3WOPRqHe+sw7lz +5/Ka1ihF1sKfMKW5isZb09nMtSZluOtkcBiM5r+WOHnW9B0ygdaS8Qn4yCuo7YTz91YfmLFHcRTR +oWMa+lnSAoJ0iastwK9OB0evylN+g0Kja8npby6+n0qtG3XBBRf4taP3C3nnO9/J/PWjEu677z6d +aNP0zeY3m3HVUv5030XnXP7h3v6eDTdppzFvumYBZUtp/f6qhTM2ZBiGW3XyDOd1V2+5dvln3nX7 +sS++/n1H33LT1UsZmpaUWkoPC20RZ1aRIVJO1Kbc6og5CHpM3WxtpyzNWirLGf3QY38AWhWGgRMr +Z4qGlZ0OUBafLeiVWNZjEADiah46GsLFo4RAPOFQWKu5nNGj0NGZaNBResBMzvUNslxeApKhb2yS +ly7lAJLENugSo7NxOHmIBF3IBkoRBIimezmUeLlNhChvK6AimAVOCOLxhwDuJmyTQUrAXoJK1FRE +Ef5yIwgilbhEMquyIK/0OPAcq2Te3j7Su83sioveSWkHzu0ETtKiJohSZFR03NTVdXT3L1ne24Io +ZZNoDNW5bCI46CIRyei3ViLmhrNnnXbWB79z9ofP++klP/3xxZEfkyLzYN2uu+/Y2dH9g+9dsNkW +dkOc/Kzn7AJZL/rVNaYHx0BvNorqYOuKMUm0ZGHirUkP2TLBrW+e+UzOwcHqfXc/8pajTnzHe151 +9vmfOeyI/ZGYdhSE1eqz/+2prz/qwDcd/pn775kf20APVTfedJLteY1T/CaDLz9Z/mMvflx+sGxK +CFFU86rlMf781jhsxzziWKrZcGp91113SRlDM+YWXHE8FhXBMznmqVsOUqDOtUuTMFU/9KEPGad8 +05veVKMkzLXXXlu7FZHiyjFe2s2VFTuaQPwxiFrjwBzXOFzTXO6GgYsNtxaGNaWnLjUma4lsuumm +tJl1R6Np1sJ/NNm6xL0jVaj5AIp4nM9jHIeUauGmPWnv/+XvcF0qsn7S+Mk/PsFIgC/bq+KW0ZPi +bHEVl3LNNdeUcYJVS0LgVenocWiUmQ7GTnyvelLGAHhC3vjGN5YPkeuDj4I3n/uF50HAzXdgbN8g +xyGHHGLgwRiDRJ9C7SO+8U/f/dXvvrq8Y7lqTp7WssU2k/9w89KujkEzeO/4/eIddp2JPha39A/d +/8fOr3zkT42N9Ucet3Vre8PJH7978WLjYvZBChUZ6NhsLUaagE1sedsFOrikkXpnl0Kv+Qvi5FE6 +iLuyBLDXWryvfQkbeSwMVA4gDPWa2zUwGSFuZgioIHyajJ6CDWYKjIQA4ZKl7kFLIh/KQsyi1Yln +Q0OpmIs0Ma6EsQ8fttQ9BAWHoc0ZUpA1FjhGccDVU+OpAQyAKu1FpSMODR8wNJIoQwkFXRN1ym9N +rtEfT+BoDhaGXVjs0awmhkrhMBeGbcSERktTWJmYdPdaeWkVZkKRFD5eZeWG/p6KkwqlfoMqRJcC +n+wTKL10Siw64vWVTgYpQaCS2aylbTHx51u/7uo7OBL2eNYOm8/hVARcf6kCmX11u+2+41e/cNa8 +fXfHxBjnj3/w64kT2+ZuvRnOhCkBzwTueIkRtPDItbSMshBvPmf2TTferVD0RnCRbDZn9oIFy66+ +8raVK7rYrJEp877/hNfv+eydDz3khEULVvD6vuTlz+CnMTroimbdzQjEfoOm7azq2PRo7UHPlb/U +oGMxtlYlNoAC+dimq9qsfn1cShy2fndcjn6qXLKrchid4mdOgzNuOCTLgGh56rcsXcppp53GRvS0 +/Pz5n1VK6bV5LocffjgrmVOaYIb6IFBZCKvdinlKjDHjnYp4DKKOFpuPl6EMTY9M7+5aGFrIq0uh +LrfccgvP6mgma4rrzZhKZtmSPoThzGJS/50CK6t0xTSRAVpuAOgIs5nF1LK21TspzYXS988mrhkk +r3zlK9flO3zMn9ya2uGfNP1xm8Hrg/bh8slsuOGGOj5+Bq7iUqR7utoGMo2Nq8cvh/VZnAZ+QrBQ +P9QYANvU/OwyVuQj4LcxZDJv3jysrDpHZuBEp3XOnDnHH398IaiVMtjfc/H1n77y1h83tvVPseAS +BtRVn7L7LLOHgOifbllKd2++1RT0cGjF4rrLzl+I5hn/NmvuDm27Pmuqk5tvvmY5jRyzjWjnHPV0 +ogutCTL7eys93Y12FmybEPhq8wbrZDBsah5W3eJiPK4dK2OCLhgIzEvflfm0/LHQzuRe2FYUNGuy +SBLmJj7p9UVGWYONGKHMHXyYVv5Cj+faRwADa8t0JBlJEoOszGWzgjFPH68Jw0SJoVwEoE5VIHRB +wYKOmOFpWhO/sdFKfyzCxDAcyRAhqxOAlPUjoT+BbGHLjqSLBLoUO3LEPpOjEPsERMiAJxyVXuqi +rAL8wbyMiWanAX8EEby5hByUBUQxQesv/0WuUhVP7ZuhCiQRIoIk6GJ6M9k++K6v7rHjkXs/7f/N +mDn5sDfsiw+pivyYo99r3lM7Orr2fu7TJe6x505dnT37vWAPXErfJRilJYpYCKm0ZKmeNtEjGemU +yHLwIfs8On/xPs845torb9l19+3mPfdpB8x7x8sOePfuezzJ2MCbj/ocDpHV625s/NQXj91mu01f +dfCHli3v2HTTWWec9Tm9xjlz5phNagwyCvufgY5jsc2bN0+y+ZZz584tz80pNcdHD7XcmoWHjE5n +q4lceOGFJX21V4NqCjVGu+pTXlOdXWqdo4iPdwzB2972Nh5g7iJ5TR/lhgUkY2jG3HImo/FzNqpq +mU3tKW2uUlyRJr+YmGM40ExmnlUOZA5ec5G4L3iG0Ztr8453vOPoo482v4kaue666yQaWQQSVuxw +Xwk1VKjxfwyi1vKKkJmlC7MNYJX0NTEkM2KyUWWjKzia25g4K9BwKeTz0g2Ueh0I1sR/TN613Hr7 +2vNJT3oSeP7Upz6FkomCrd6AL8dCKW+hZPclc4zzFniVUsjDyFn7d4hszCdXWD3RrqEKtjvg6Mu+ +9dG/v+bw0mtgWfp6TOvykwCffvCgjt2pq+hXMboUPxidXLOEDLPrXULQ4uaFiDw57e3tek+F3kw8 +tilANZ5qiMIjnSldY/1fb5qz1xxuM9N8KCb+cQSZsHDMMUdceN1nb7/velDX0lhtbaz/yFuvmzy9 ++ZAjt/nMcddvuuWkltb6iZNbt3/qrDO/csuznjfz8Hdt+dn33HHXTSulOxWkKOgDXrnR3gdtQNWG +d7fHZhahjuk+2s9wJrSjuJubq50r62If9pxY5CmAR4DISBh8pXnbWlLnSgUAOWF1ydJw6kqAkTkl +JeL2LmDBBCr3xvgopQwfICIgiJZI3Q0XUQY8pOEYkSgq2JKTszHMzZyaxBHt7YKiUPqwDX6nNRx8 +0kaUC9ITWLpERUgpQdGqFolZ6MA9B7/o33csj+KLSboQQHXSSPWo8CFMgJnbBBWJ0MttYRiP0nOr +32A/RYkwO6qZSInOU3/DRQDdYDRcRJCNBHwiL5jkuWVna5yEtCKSTOoSVfOaGLg8zPb4xSe9srb0 +W9nZKePkqW2c7XozK0dmxZG5CKCckCHFllg+Q2Af6Vk1DVgq6J6QhCl5Szci8uoD6Tp61Fg3/+El +m248U5zz1kTiqdMnOFOo14mm3CQTYzkvN4YNnHvMbbNcx0HnDY2xToavpOHpCx5d7ldD8Y1Ufb3+ +X6+X6QOw11FK+gHk1/yNctEAPE/ve9/7GKA61qP9zDhzqMJRtibKWpv41Xs0xp9sCydk+vFrkuRv +FXU0H50J6DhmZe2aGJLNEOzo7OsSN6LJAjHqXCNeE/8awWojrNs5c+awN+bOnVvsnNFk7HvdjtGl +lKd2/6C3R4vtdfwTfYej67iOcRg0euxgHXONJtv7iA+NzHUZnfyY4r5yfR+fjs4jHC0/Aw4f5qP0 +kaGwsaxNtDOvet68eTqYprT5+jkfEBmzAZ81aj8YnVD9Yk4JrPQ6IZZQOr88yeKIlV6y/Pa2r91+ +z+9aW6umpEIXx3HQU7RpS1vjVk+a+sdbl1J2r3zTjtyhAtVMI8/YIG4OOmyTeS+c5Wl7a0NXZ6yc +n9AYiz7h4pSJDYsGHWgaxqUNeHs7w5zlgYv9BC1TSUsI8tmJ1/oZQ6TYCiJlzQwOSqHWl9t4Ng82 +ASSeCoAwlLQpLazJVNnhFJWYJql0TubQ16ncAQb6II/7mBYUxGkOhhJPBFIyQ1NZZkKFYFAEJDtF +1YwnRclidwhvXsUzI04DOXdJhPEag4qwMEtIuQJaSsDfX9widYkMcTtsPhbUTBjzhGDKYjeHLzMh +Ry3gDbNeJGqU3DxCXFgOM8cHWwVkjYgS8EkwSQlUblU8kDiIUqSEN8Uhrkmri9OSI9OAsBTBGz95 +0gR+e5RelklMtuftWDEsTPKKS5Ydl3gL6UYugMpLMVzZLDc6CoA8Wdu7w67ORVQDtOhD2KG6DWdP +d5KNyvI8T50+KWh9xn7NTgAAIABJREFUh616d0FQIF/vrX4wTv2T5EB3i6+aGnuH6pZuuOFGo+Ek +RFmPg1/9uuOoeowetxtdLVUeA42e1jR7DURLFmOuqxLrygujeY6J/62i1rLzP5tzBEprKSWyJoY1 +scfQr/121WZcE/+186k95TcWarclsqYdsuCrMJp4fJLR6NZYbTzUgnkOq332tyb6YfBpsEHZmgxH +sOdrZm4aQeGh8nRNDHlLTH83y9cVInJJ+S0xQI2GYmXKEiPVUKtHOlDc+qYEY2XVs/nfvBa6bz5u +Vq+ZwNw7Hi1ecccd919pcWdATtWBpNXevoEwcapOF6nusEuMj06b2Tprw4nTZoVGbGh0AtrQM/aZ +RY9fePb8Ky9ctOCh3isvWnTbTSuBykB/PQOjdUKlo3sIEyoylo0mGGBOR7tlUNKhfb0xlZc6pKCp +TnjJ3cq760+uMFlSRSsSVMfQ5siMJICHj4UrZuKAWyHQMafUogQYjNfYfRAOmT2UJ4FDI5TVMnUI +NOY7LIOpobXTT0sY5QZY5goZR6WyBUF1wd0yjErXQ1wEMcu3GF7iOf/II6IOc1arkc9ESkmM6oTy +TxwtyIc+HfkaW32LU7Rcky5Qh+QCIC9QKh6AmsiqDUUCTbOseGNpyBbjuMRL68kbTZQA6aUUAEYf +qAafeJL9l00Hq8xDVnrAHvEqFk3Fe6wM1XskkT/cu1B3dRkdSh1xjvoqS03TBpVSPoNCLFNpBJ9Z +6U+UegUEpmAhSPZKvC8Zo9DqkIFSsOvVYNvY0NDjC2A/11e6egd6+gbJj6Zv8OHR8jwR4oZpuXDX +55qy5CxsHbMV1HorsG6HvR5rM3vXWzn/BQSjHhpmbrvb61+yz99fGcairhP3uqkBnLEc6CIWHRu7 +5vLVJxrTv+bR5ac17iIj25Sn18AGN4IJC4YKLP61VBwNMGbU8t3LbmYvx73JEeKWuEEyIxbcPgoy +FwDcWj7FA7z5dnUbzWl3Dkeo9dgjodrTV7364vmtbQ07PHWDSdNaZ2zY+uSnzZo0rWXitIHLz1uw ++dbtT9592vQZLZvOab/99yuuvXTJpb9YeMeNKzfcrG2TORPsANDSHrsxWN2oXBgQrt1YSFrtsl1A +M0s3tgy0I66SQl9XAlnZl8xBcQDJMoYQdChNWkCCf5h3EROgxcylZGGev2GIymWa9HLR3YE6aWJG +dRIqAr3gBLNmRFkryF88TQKsYr5SJhYcIliBTAIEZCS0kIephyC0v2vuYiheIFmWyMUcXLnDtjtu +EEWAhJEQ8JBBBJMoPSGn8FGKjJE4EpAB+BgejuVGKWbaqUGSrAptqUUUml2vaIECrsU8RcTgS2kD +wNSEVC6JrK6yoy/grXYhcGKhQgoS8/SG6Rg00Qwl6K/roMgle/DMUBpKij/t6ao1gmc2vipEwKq8 +JkXHgeHZXCnkxNZmfVRGsLyRx3wu05qaGtqbm2KbQILZWCJWGlUmtU4y1ZdR29zU2NOrz2c1VmRw +1kxDZTpP75gfThb8r3kxdDdnzpz1uW5WUhqXXZ8lHC0b24M7eowdP5pgPF5awGYXa9+A86821Gk/ +vaSy3YFHX/bNj/5V0nUhMPhhiELHjavdTCIvknkKHV3XYpWuiTOghbJlpVehKcMkuAFRIO0RLaMg +6YxaRjA/8EDjfVf/6avwrlo/yIPHmo2N6WPVaNVefTmgyP8KwKpTZtRts4vjuzGLgyeZOI2NVQZK +19JBBujkmfaur/Z2VXk+2YJx9IqD2errJjBiGuLQULoT5LD8YnRzZU7/aa4Czskxkyn0MrwMNMKZ +L9HwJ6VoJUwDSE7va65+CZ3OFhyKSUmQJsSQmfYv81wSP8SHJ+JS4gUeUpsXuIJM9G6gUbGc2GRG +Yen3TGGXhwx0elqxMbkp99NXTcauEKDLeOUplZHBmmpfNTGXC34osXXJwQe+YseAJSHRq2Ch6DAu +QrKsZoEWVMHB43TGYoWepR7Gt6nIhOVzJnaCtyKQFdyKRzJiy3kLnrM0MqEMYCZAwme4rLOFJWo0 +8YJz6BWEAxMfLQ5YqH5JF1FZdcQnUkA75ONmbHCwQXwntt0oAhREJD+2/kQIHC1fS8kSpfsDil5Q +SDvk+J04ojy419XF/oaNTYtWdCoIw3jLPoDmBpMIlnR1lSU6ml3FJ7fZ+Kihw4BB+tt9rG2tsY2z +vfJb6jdvqd/2iQOl0XDjYbwF/tdb4O8fK93rdR+0C9vjFuAlPGObMhCNkgJCaCrUJhD9TSWt6pco +3SvQhw/3vSKAt1tFsE3hqPTuzqFWHX82Iiu5TXc/tFglYYOlRDPSetU+Gqxu4pRinYRCrA7U1zdW +7S5O79mJt2qfI0jJCmx04mgo8Jbman9fpaG5OnVSc08HS9Xu9hU+vRXLQ5VzwLICaUxnl+IPt6h4 +mhFghOmZLs1YnGoAIuUJ8XLSbFgnXkBuHhTKPUE08T4QMay9xBX1YqgEBqAnekIdIBEipYQ0Melo +Sj+fROpQ8peoIILBDNCOfwBMZnQrbk1PoAV6t5APMVsq7VfTdoRocrewJOFKpSKxFJMWM4jyVB0l +yo45zkX4qF9T+JYV5FFh4lmAU7CJBoxYAlXEo36REMSJLgE8IwRRuwKrIe5wOs7D2VLUoM1dBgNZ +M2MwR5uoRgDgV+QU8SKiaRuq9njqBmfZgCgRuEZu3w2Pd9qmIUhZQZTmr0L939Agk3oh4bSIo/3s +kGV8tL213iC9bf5t1FBpcqipzsTg8sGe4Bn77sZcKLxXdve0NU/1YxH3wo1k9PQzUm0jUhmoPNpU +nWs0YBxN8wWPX8ZbYD1tAb/Q2I/lcZQOagqrDnE/jkXUWBVMdR0dqR+a3tY0daBnUX9fA7uQouRZ +TaioOKYlj2uOxImT6jbYOE/qQBA7tQ5SV0O5KTkAhSvgkCkJEek045SBW5WYxERRLl4+wKmr2dij +tPmESWFvQZfiyA3kzuE6WELDugqsQE81dF8CElRTBObBNoGHDJ5KlEW5kEnwNExGShwGyAKf0sT0 +SBXivSWYuVTR45NaPiTNPwt4YDkbDnPLYBUXIGojQxZkbsyLLbQgsMqKBNYWf28iEEM8CPQJlobq +p/XJVmQQFyQWe6sgq24KyMGH2CIBxmik5G4M0b3I4d7gIhCxfHfJWd6oDnpPPBrBb7eRAvBIAqk8 +0qQgueRO56pE8sRTz0Y8tEGZccLgTFS35AwypmrKrzWwNXxeaQg3LJ+BlkeDP5oiT5RLBlAte4xr +hgAB7a4pDPED3TOLtrUPoCwxfbphaEVXpzPgCYCwHMfmmHkGaHdfTDAyYyoehd081AHDValqBm9T +fexOKdkuldba9g1WFtVXNoryxsN4C4y3wPrbAtygftD/VKGGnatK7VFjfdvk5h2aW4cs/zC1w0oY +ms4gZ/FeshwsOqArJ06va59SNwALOWnjtEnBlgsNAWM2p8l5rQxN6rW+MQZK6Upb5nLQLl4coBem +G/2b8EMrFlChajkweRchqy3xcAZOAWw5/afo4oBMuwayUCVS08APquWy1L5c0CKOj06AecLsJH7R +QKAcOEQZOjwNprCDitWYoAL2sIVAMUcJ6CbGBHAmBoTR7CmkxI3vO0dqY6NdyJ0vn/YXYQerKTwo +nYBA8TSLo8y05yh4NfVXPhlPhVL3sP+AQYIKOd0K+ERi1jFqkdldBelxm9ndipOhoE5WcriUkuKR +RAUFqiX0yhgyZ2Kh9ywYK6vgbuFZ5FHHaLjELb2K5FPEKGyjEfIcHlOQglJXQFNDx8gUBYnJFcTa +PLGZ/FI0L8+Eq7gW8tfbG7dgsk+fCx/AGue/qFp8hw2NQwASHiPlCg50zgHUPrszxWSo+v7B/uZw +Teg/GYtXfqV/6NHSU0xZxi/jLTDeAutjC4QGyG73+ijc3yTTaHUzqe7pzQ0zh/r7KcGY+0OfmbcZ +O7JVgUcYfNW6aTNspVthVrY2h6IL1RZOPNovtuENdRwQG3OLDJnKxcc2e/rkjadOcVyEWSG8u1Rt +UKYbkE1D7UFQmEfVQlPIAS+LfgWZoAUBy0wgUuyQQDsnYNPanuEQTIryzprLEk5dehXD3A4wegNK +LKOStH9iD1Cn5AtxFATdC/PwPOZwYKaoS7GoKPSAZ70Ep3Ab9yVkwQllcdXGKPLwHBwjzYZ+o08w +EoqQUUSidRSaDm3PoxbaNcG+IF8Zl1VH8msNxL62EhAUfIpbcqYtjoPKSg+qURgZgJ24JRHMR4NH +QkQEwuT/EYkGkTlNPXzE4/vOuVTylNsotzDPvAjw8R7DQrXBRboxQqhsdsKH/EZe5ZLPrfYpLz1f +TdQoK4VtYmGltakxektZwbB3Y796lQqkdRhcWJvVykRT8BBYUZq+h2YvJojCPHVqmxfqzo6DQ5Wh +/thra/lQXdfozztEGQ/jLTDeAutVC1QrjbHC7p88jFE0DfVtUxr27G37WZdJQ4yxmBlkx6J6i1Uc +OApR2ydZoZ+jd0PV7t7w65pJS385B9MO9eYxQRqa3ZTd+qZ6mpNvFhAsWNY91NfjEXsOqpXD0Shf +qpZOLDLwJFOtSmTOyiMzBV00MhuDhgVpdHesSKHE02pEH/rdlYrPET5C06ABS4kigUkJ2FAh/LqJ +N1CWzEJAAzDIDfSxCk7UNBmKyei2gFwBIQ8yAMVBfMzEkSEX13LzAgbPQ+A8ZjXUvkFW2x8mUg6D +UD7Fw9MCn65qpGpqRDYR8oQHVYlkSWlJXohlFBdqIEQAYgd+aLA0gkMADDMefNxmq4Y8iW0kkcVf +6TRof6GIN4yrAUzD3uYgzo5RTMvKcqMZExTDKtRQUV7Yl2YXe+TFWZJUpIr21JjZ+PF28JG3tEb2 +VOJp8scBcWNToz0WepauLLWTQi7fW2OILp6zyT2L6d+O2okZ5pqlmzuCl9ix33p8mqI61NrY3tPf +1WKE2edqwVPFJLd/jl0aosbjYbwFnngtYO5qWeP+r1b1iQ1PmtS8dWyI21vX1F7lTeXLDW0eI1kV +Jim9aFrvUA5LVfvDxAwNy9yEpo3OKgmtPbWtddOZU7vM+7Xos7Ouo6N/ZVefhRNhrtn8qMx9NZs3 +9kkNCzLAr9h8aWZp2RiGHNHgJu7S1xRx8btSmkzYAIAMoZFDqLzJxNDa8Cmn6hSXLIQWyAneAhUY +uDlfKZiENR1yxuoawJPYVkzGsHmgV1qoEKKYgOGEzHmnEBceMJT1CQo9bvGXOKq4yIs9tM71pkop +oFiMPHGP1ArbANEy2Tir6ZachRUCDMu1RGqgKBEHt9IDpbJe2SOI9MI/2ioN7siVTVSIRVUEmbJU +J/gkpEVrYJRA6JG4jEIUjSDjcRtpaa3m1DBkiou5zaOAv/i6g1gnxnYfORAe3SACJ0Ij9kaw1c7d +vX0ru7qJ6qXHF6Von1k0XfSj7HIUZVZMYWud4KTcKKsiu/2Hic2jS76mxgajEn0+1kDValNDs+U0 +A9UlOmqlr5Yij1/GW2C8BdavFjCQk8bL+iXV3yxNONFWCZOG/q2z/eGlPct7exobmofaKpXe2AZh +qKWtMmVmmGp03FBf6LC6BitHKcMwofr6qbMYvLQwtLs68OcHumhpk3sTQiptbVUTe7u7K7ZloDEp +ZRYMlTdhYpy8BopibLUanl7AA6VE8MSQ/REIN4Kd1K7i2KauVCiMDJcvJyEDtGBeDnnKJSV0amJG +qSIgMKtFwEQIeC4wg9UIZkgPXR+aO4Lsoe4LnrnJJLir2cILTW+nE7ghXccYBrHGcUlURl7gMzKm +NRadBgKPlAIzUEZGkoCWRGKPA5MStwoERnr2EoI1TtmAMcc4MU87lBKDW2Jh4KKkJEOsAYmhrSJj +2pFRscwbWUYw1dNgn65dAiCBfGQLk1cLJHPp4gDP20FgkwQGIdATR6ZX4bUGUiLWAlmKeHgUsknF +JRIyJMyy/GeDBeOg8DhKcdtQPzA0ZL+FmoEbY6N2v2pp6Bvq5gqK8XnCN8ZkBUP4JvTq2zXWNzrW +xoskoPSB3j7u34Gh5U3hKc73jcV4GG+B8RZY/1ogPHDrn1Rrk4gKSi30P2hGp+RzumnKtLq9Ymei +AV6ySnNbdZK4/U7bq063bq42tAzZSc8spFhUymqgFtsaLJ9nRPC5xaa1nT0DPYO9oDfUNyVbX7X3 +wtBgxZ71kNj+upFxqI67OCxCC0lzWz7jrxQujWyTozBSbcUwlJvxZuIwzLDectOi8PWlz5ZGzlWw +oYjL1CElBv/U3WHijIynKhEKesSrHAWlVRQmTYBO2mcjDYMykCyxKp5CsrRoQYIaAYyAAUhvF/sc +9bRWRyJLV0WCxmJQ06NgrbxZSrkGioCqZI6nv2QUNGrtTwRbFcHfU1fE4McjQVwbhzBxE9Zbye6u +IDeZCy5KwarAlZTCRHXEtUABOWwZi5Gl8Ey2KAUCSJQ9JYjigoP/Ura8T4MVgbMGs6Cgr72mIm1C +cpEtCk0ChQrhbyii5r5FuqXtbYZLokSbRxa0dvXJEdjuRiu6zR+PuUjdvf29cfha1szEb8fnVgZX +dPWZRt5jvbNaVxwWHvtm9Q8MQFarYwarnMaejIfxFhhvgfWxBTiTHreTYf7361fgswCn0muRmiSt +lR1nt+/W2NTrLNKOrqoVew3VyoyZdU31dVNb242JUu72BQydXlc3qaWxr68Cd8M2MQfEShiTZZpi +fItbT2BxxgRXQ1+2cbCloNkoLJjWKg3buSywx3Qeu/VCuDB0IUcqZZq0qyOwRy7FuRXCJs5xSjAW +to4VhzibrpJoRFGLs2ilC5RvAICQGhz2FOAMbEAAsfgnTTxmF6aijyzQLnW6eIiRGQN1RqxGEYDN +XA6uCZMFkkkonfxRdwOHOdc3aNKgjKflL1mRPAAjeUZ6mnpELX/BOiGtICUOAjBLqBipS9p2UcGs +i/oGvLjVDkpMv3Fmi2pGTcFw7jWBMp5m6UopHIK/pstCiy0Yr7KAX2YnqlyKKDSyY+j19/Q5eC0m +07o1iqlepa1kEkopUhAU/I7Ss0EiBYdsH59Be5MNiwyBemr0PU5wI1CUCHfBcPYGuvsGzGOziXh8 +vSC0OqTEmJHUULH+Gjy3NjWxWYeGrIuutjbDZh+kKUixf8Q4muYLGb+Mt8D62AL/3A7eAp+hlWja +UaHcujYPPHP2tAcXNTzS29HY1VltaavOmsVSqF/ZM9Dd4ziumNzLnqCwmhsalvf217cMb1prRYzF +o2YkmcWKtQWC7EhkEjvtNjBQ1z4tvLLdXRXe4MbW6oQpMf8IvgJUFoUQm9/C4NS5Yd61DU+fYe3x +xMZqfAZczjPCmb4OrE28iUlJTBlZEy0aOY0TUOlx2IAygFCNIzWwGTC48yibIQDean/qGzDENWRJ +EEqNH3xLxH+5XjbwQAp4IBIMwye0dniqA0HTRyqCT4Ei3svgkXyUWBLRRyi30WCBMZEFkCeHgnZk +C+YeyZ5XNFEj7yRXeeJRKuhWfg2oKXAQcIjqpxjk8Rcp/nLKmFxC9DM0mkcJe2GwZnGQXnoUSsIg +HGnh2udf3LlKrA7pRnhHwK8MZhMgeObc7FJZgmGlFGyjN5NvhCCdPX3ROVX3kTbUVsjQFzHCTREz +idSCT3mAzCj7+iNCMpvv+k9nzvqrhvoGs96IqaJKG6wuH5Y7ZB8P4y0w3gLrVwuErv4n/YkW3Kw1 +Zy40GMZSiX9BVSs++vaZNKF9wlSbx9S1TambOoX1OdAz0BfbJsT+eTZ7q5vY3ByG3dAgzKNDAYNd +fujeCc0Wh8Qm9QFjOU+EXxdktrZbVFqN07rs29AW+Eq3cu1a3Bn7QjB0uoKe0oR5tq03BziWnOY5 +LYyeQC9ewZzQFNsj5AQiahqIBn+6G6SVv1T8fMXhTky4onYDjGEDHC2jgIbxrENNAxcTLzUsy7TY +5AY28kaJ5MlJv5GiOolJwBvDwAlVzgUh4MFtpDPHkz4aOUFdvUQKnAyDSkmHFiWkBZZi5r10fMBw +Yp4kraF0ZQmBLp7nGGTc6hCkE1tKaW31JYCCivAIiIQmOOQCIU0XbeUTznSJOEb2rKn0QLHEPIml +RFeFoneNR9m8IU4K6U7LeKYxi5xaspQe+aP2mT07FnGbrSEvYn+9Bkv1thJoo6GyuWJerlbKqnko +l+d9Q/0lZttCu4E5WM2jcP9Wh8LROzDQY0OsaD2z2xoYuIOWxBjYzxByjIfxFhhvgfWpBfycU8es +TzKtoyzAslD+BTVHYmX/pnKHprFuo6nV55vuMXVa/dTJTXr8be1Ntg7kvHXDfYaRVXwrYpeZup6O +sCap08ltjRNamzt7KrHpT0OcABN7GtRXqe8YSmyodCyPrR7aW4dnFRnpLKiAW2zpADZy0JELFzJZ +aEFHg0DBJNuwSzhR034FXZA48BW8cRpD0GLrJMx4Q2EeJSQHglLEMNhSnJ7wAPNC0+BhleKWxp+C +Q0cLqdAjnqA4nEj7p5UsGZOw59hH+Ud4DVGQiQCx1WL5NDJn5EpsGG70RBGilpcwnFgoo+wIao1B +wFuGQgMdpegoCBGBMYniIFODBOCNwFIBpLBHE/j1QtBo8PAN5GysYZhXaJabIBVspYtjhXl0PhJK +pWsoMhQBgq6Ekjd5aEYZ9SuaYkP5yB7Cp5ByluK0Q4hNziFbMScg41MkR5yVJB45XTHBsN0e9mzu +rEVkjJWpg0ZAoWYc9Wbqrz0rGaEjjQl6EfezTaMxwozl/h0Y6B2sWzEi9Pj/4y0w3gLrXQvQYMOa +cL0TbR0EKoBauxbbtFxruT1tGNxyct28pvaBTTah4BsmN7VSXHbvpebamhtsVrC0c6BqfkcqUzq0 +raW66cwJtuxlaBrVgjpNLVVnsRnB0lrUL1ykBR3JzAwNdU0Fm6RjIo8pS7mzgTalzW18j54Wdlu2 +FYy5QgbkqElMTJ+RMUcZIQS4pTuL/kXPFKZ5MYGRsegF5KTHGNopMhh4msfUIJAI4xHQ56HHmaFK +zuzBIYuINw1gUrDAub8AQWSMoo2PFqhIj6V4DSyDeMSBrGRN5A+BEHmFTCn1Ktw8LOiVaBUEIV4C +GxmiCoVJcg6Bky76E4mFUYTFJG4TzFRBSrmV4g+9mvorpQfzrLjbEDttUynhRU94jgZRcLpeo3Xc +So//ok34aaM6lUC+2PSPnOn7FREwRKqIYBIJEXF6NxlEwseb0mIYQRsmQRQXPachzSLuYUCmvXZL +f8JcJ68mPtYYrHUVkNk60IZHaApTK6HJ0NfHxxtnlEeR42G8BcZbYD1rAShDYfyT/TgJXRSKyOhQ +jNEamtYiMWmSjdi308T6lXX1N0aXn+KuVOdOn9XbO7C4fylc5NBrSmOUToRMW0ybumhx34KlfbE7 +oLm4CajG7RwLE1YR3BqsykJFFrctHcp8AGaYexoq0iidYbBc9U8pF1xkj5ZHDEp8QvPCS5stxELV +WF6CsqjQsGVTL8sSeCCekAO5i4JWI2No9DstjxKNSgampmYvYAYa4z71eAPUyY9P9pBWCyR/bQO8 +lQvASvYAp4QN5IjjkQgmqlZwKG89VT4CHPwFECSABd7kB5WXEE9HRCCkQskZ5lfJmBgWfJQYvIIs +apocZNREpRGUEm2biIUD/mgVyqxvzuFGe00En2KMZlsB3bjNsuJRQcGRkVEMy1cv4g/nqGAmerMe +uVW0fk9p3pAum4tsUZGU33/Yqo6XDghRxtB49jCiBXIU3FP7Fon7VKSlLRowSTq2r9lJhuQHLHTx +LgfDE8xWtSF+ft6ileaGRjsgNZkIZXbbUIc5gj54T12jwuNhvAXGW2D9aAG/yFQ864c0pLjrrrsc +XPrnP/957RIVBEVTIlCzAKed9Eukll5TOiKtg3t0LJq7zJFsnXYHrN9gypRFnb3WxzMN25x9xqub +pgFV9/DinkeWxNJCg6mhtoVqjGIuXUYfBurQ46CUxuztCo0vUKP22KNbQ/kaW2W1dIaOhsQ2iIjR +1tTCIBZDcV7i2LcvJyjBS5o6Bm5N8R1R1iLxl1CKPoAhYR5N6Pxym9mHC81y0XCfkkFibAOUZGEV +ZaKMAUXETRuRrRVkaVJDCLkC5woHnNEV/Ij6RUCs3ECdRBrcCsAQT5D3LwFlOkLRlywR8Tgbs3Ao +xEoPuFepLAtNkUf2IgwyzagpcCB8cW7HGeY90eaBr6oApFOGYSZpyEZ2DxPpVUQFEWOimiFINqbE +EuT2SIbO7r7ewX4ZZScDoeXCJH4qCYeZFkz0QuXg6tfmZFY0DsgwcdXmEVDD1JjUzQiN9HDsZmK0 +xpClqDp1ksNChaVNDU6SGTTkanBB8XlAeNXZbdGRqXQ6wz6Zjl/GW2C8BdavFghV8Pi6jJYvX+7U +bobglClTlixZ4ti1vffee7WHzs+bN+/OO++85pprtthii1qr/OIXv3B03Oc+97nRibWnYyIFLyWW +SAHRGqZSSaMJClm1vqtzZQxVtU5oXLBsRe9Apw2P6DhbEdGDoTTjgJfKUGMPOGQDcKyZDQsLyyN6 +mw5l1FqZCgvhqB1rTfmxTqbT8pi0bgEtxV00u50fzEIKE5CSlZzq1ZRgrt2if5knzgyXMexR8GZx +KiswHblsSqxAIJUdACxQwYmv0ml5kzup+zJghyGrM9zPEl1z2hH7KhJdCwQSgH5Ob/MwnEAXaDQy +TimiuALVxA14C3d4Fj1ySaSIG3UBbwmPcVuAJCpZ4vF/Yk/iNBEILIsISmRu/aljSUcsErCawgQg +lezI4lm0AOdBtG1SglK9E6JqKy3sqfaM5k3O0ZgJV95mhGx2LL3EYOzpCPIVgUMwwiScgz1vXIsV +bghk8TSaIqscEqKP1JIyDI0kCVGL2N543noFLGb0UetsrgD4nOQbOzNgbiy+uSEGUlUtexWG6rWD +uUcKloDAchiZ+od6qvXGAFrHrdJs5vHLeAusRy1AC/iVFw3wOIjl/O0vfvGLTg/dZ599nvnMZz73 +uc8FZl/4whcRf8NBAAAgAElEQVSkryP3I4444sorr3zRi160LvSYIxuDoBKLbSq99kgEZaVxSX3L +/Gpfk1UH9rd/aOHipmrMnIzJRLGNDg1nGiU9W7XnkYHPsHXM2s0TvKlqys46S9hD57JFGKOxmZF9 +4dtCR5tqBDg90prUOvXN/SgCOAOiQs7Q+7JQ1vRs+hEjji09W8BARAoaTGLUMN9MAkG0B+hiQAcM +MDHDiAkyfApYxgLShIRwFHurZXw0MTjYUNAFVtPYkqIs7ReU/qhqnlL8KfCcLKMUj+B6QbXEk4yr +SbT6cMATAXgoOBGAlIJ5jK3bEnFVwVpKVD8zRhUSYPAJyuRMAE8JEH8Y5yOyRUisZf2H2BzjGorB +mr2BaISw/wJs4yVCsmSi0ChBYxaRxLMB7YfQFyfexW1Y7ciimYKt0qOghNtIEoofOylDpmTi6ti+ +kMvT7NzIixt5oiLZzloGN8OhZe5u9HgQqBN7c2CQD2WwOtjR1cuyDfduMAaiUeHGhia7I2la03sd +dsqWRWEeb+n4Pr7d3yz2Lxc+od5YAfavGTSd05Qfc9100IXHnP0xZGSWZD8rsoqU4arHwOcfl+Vf ++4NZ13aLLWlHq8Z1zbcaOu/4Zz/7GSQTueOOO/70pz8xOuPw0oYG6ev4BZx77rmHHXYYu7YUcO21 +177sZS/bbrvttt9++5e//OUl8ZJLLnn+85+/1VZbzZs376KLLlKicMwxx7zwhS9U6Jvf/GZI/JWv +fEW50l3/+7//+2Mf+9jhhx/+5mPee+737zVdkkdt0fyer/znH972qus/8sabz/32g+F2c/4a/Z7D +jVYHGpwrcBinnsWkHgeDA5vKUB/stI9glYOR7gujM2yImHNUVlAQMjQmO4ZaxISpmstjxMNL6XG6 +Frl2afDQ47HPQyAN7S+jsoxZehpGYVZYxEvyh57FSTvHFZyzxtJkpLtD1LLjYGrwgjucgorzhgFP +GJeKgy4JqNC9II0SAvw8TM5KJEZAAsr8MuIDEcpNcguxsJKYlDhrtEiJpMgzHMlMQZUWHjIRJPiL +4KEiAXJAq+BxtkAIkBBIZkTDmDrMODLGoDIjtbl63TW/O/07P/rCiaee+b1zL734mpUrOhcvXL7H +Tv/+p7seQNbf3/fjH14kMeQvzVGkzYaSePRrTzjlpLM1WumRZAkJwKUWMQ27+9yzL1q6ZEVgecJq +iJotMEwCy301pbkyP/QtdeSSLd6CAs8+mxazzuQtruBK3ZnfvfDFzz2u30fVUDnslR898ZM/QKne +sLmlUZrul8lKMSzaZ/PAwV4nuQ30DfUNLP2Hgqif26677nrIIYfsv//+pUH+9a7Gj+bMmfOY6/X6 +17/+7W9/+6rZf/nLX/7+979fNf3vT/nGN77xjGc8o/Ch4j75yU+uO89/nFRFhifCB7Purf247Xak +r6dleXT5dfVT7r33Xtfi4+XFXceeIPq77757xYqY93/77bcffPDBN9988xve8AYu3+c85zkSb7zx +xle/+tUtLS3f+ta3JkyYAEFlAZkPPPDAfffd9653vWvrrbdua2s7++yzDbvC0ZUrV5588sl62R/6 +0Idee/Su2+84pbG+obm+8unj77j998tfcfQWT91r2sU/ffR3ly6m18KGqFZZAc5Wa26xq1FsywB1 +0rAwlhnw2TIx7MhApty5nlIO11w6HhH7cxv6NO1ODky+X/Fw1yWCqkIAc9pbwJVqDnPNPM/cO4nT +Mla7Fo9l+m9jvlKiEbahtUesTGqdbxneh6JPtPC0hELPDgvDlzDZBYfHhCG2P9WMHkMKWexCehw8 +qEsAGHuUSCCZyZvOTGwLeKhCCXKJjk6MW/d4ZmpQJl4iCjDLKkgMNIKsnorLUvr3aQHHo9KVKRlh +c1JKRy6IhEfdmHTfyve9+4Qvf+GUvr7+zedstnjxsm989Qd33n5vwa2gr9R1dfZ+62vnLFu6ouQN +GcKbmoxcsq1QRqcH5yxRs4RICBPwlixe+YkPfv3hhxaW4kstUMoVVcMqC9I90koxFq4NM33Bo4sf +uH+hapq/XToETNJ+60jT113Au8ihx2asVIHhGamPA9qam5tanU9UV9fV13fzTfd2rOw2U0mwurS5 +pXGo0hGAG02B5PEP3/3ud3VS/Yovvvjix5/738FRfW+99Va/5b+Dxz826w9+8APutL+1DDW65ZZb +/tZca6F/6KGH7r///hrBY5Oqlv2vRtbbD+avSv64E/iNxxlTj0vgfPBlzJo1a8MNN2ymEpqawGdf +Xx8YA4qewr+/qSDdMbl0A9/97nfXMp522ml+V//+7/++ww47PO95z4Osl1566Utf+lJoiuaDH/zg +05/+9GnTpn31q19lGW+77bZdXV0EWLhw4aJF8+e9dFJ9c3VZR/+Dd3U98kDPU3afus1TJs7YuOWy +ny+4+Zplu+83gxnHzwZsbO4GTYGQbeoqTEbw1hZKzFJUSiyMvMa6nu66Siw5rQNVPazPobrWhAqC +2AWJqrM9oUFW9AGTIx7OMAcLNhT1zTZlghQfIx4JyUVPFt3N4gytSfUrFH/ZAxQioWhTxQ1jFV09 +4rgK8PIPkSxcoH1RhYCKAoE5GhckMDX0cmDYsGva6CP6HLAMBikkyiCLf6LDWYZLT0drQcSSEnCS +oqqUHAKxC2wHgdYrU6XcEC8D2JYlCk0wizQ5R54GGgnV2H+Ra5cX/dRTznjkkQVf/eZnJk6cQlow +9pZ3kL+6siN6YOjlnjxl0s8vPhlDAXOlESz+y8PpdF8iHV2+MnDYEhv5meeTjZyylV0VIyUFiOyZ +xcP4AMxMHvHAR7oiLCRNth//4KlbbrnxcR84THpQRilVW2sVxwMaCSVoUkVHmwQRx3ylx35b9ZW+ +/iE/nAP3fee5v/z0bk/fDhPjqvW2u69YibqyvjotZP0HzOP97W9/+6Y3vWlEuvXofz9hlplful/3 +eiTWKFG+853vjLpb1+jPf/7zj3zkI3/4wx/WNcNfo3vb297GlvjUpz5VCB+bVH+tkL88X28/mL+I ++L8Vs/Fn6sLHozx9Z+bgzAwbb7zxpptuutlmm2200UYzZsyQvo4O3tGCMGrd7rHHHqMTWZ9uP/CB +Dzz72c+Gl5MmTVq2bFkZCpW+yy67iLe3t4tTN6xSMrBce3p6Pve5L73tsEuuvGxpb8/gffc6ALLu +9huWf+zY277yoT+0tjfQdJRjf06EWdFh4QH7kpYNNd2WU4cgyYAJSlAhvJGVng56N55GrvQAx+Sj +9kgJzLPcM3eEZ84yZKlJzcxqYbNSxFSqtYuFAI56HKdtO4smR1Vj7DPBLAzctJkUyqCMsrwrpmpC +Bd1bptsMj4kmXMkI1RTkD+Pw3KYZSl1jFXaqp6Au8TLgLQULAzSNLUUEGJRtEHBgEKcPVlupVABP +0rsGriRkhjDRToHH/guSNP7cuS38RQkWxaVZhmb4KQhJYpWKULJjmwWFnCIZR9DVWde9MjoEfX0d +5//8N4e+7qXTZ0zRIIUg6htImHyS//JlHQe/4K0P3P9IFFet/vC7Fxz8/Lc98ymvOeA5x9z0uztL +EahFli/vPOrQD19w3pUF1dRICMArRaOpr7vgF1e85Q3/ee1Vtx36kuMPnHfMmd8731OUSjzj2784 +5MB3PWun173nrZ9TnVNPOufaq2798VkXHzDvrZdf8jsN/v3Tzn/dKz6499OOOPLVJ9x68x+j0Ojm +RIj2iauheiOnrvHqeh3JVq07/JUfQ3DMG/5r72cca2ckO0P/9srbX/L898zZfMenPvWpX/va16JP +9z+DGQk777zz5Zdfzg04e/bsAw44oPxYUOlK6n1usskm8tZGT374wx/y+vzoRz968pOfTOcaQDE+ +8olPfAITxg3+Rkme8pSn+Anvu+++119/fSltTK5S6NVXXy27nzwHkk7AW97yls033xzzRx555H/K +GHd+tvvttx8CctbYjibDzRgNaY3sLFiwwCOUrq95zWvIpnutf+xHDVa33HLLo446yq/b0yLJdddd +p6aYm3WBrLBdtGjRK17xCuI961nPYnOXRNfVSjKmgsiuuOIKQC77a1/7Wtqmln10RMW9FClrEeOk +k07afffd6UZ8UDID6LH58+erVHEak+2Vr3wlA2C33XYr3EYXMSa+qvCf+cxnvNzvfe97GJ5//vno +a1KJY77PPvt4m57KW76ftUg7urjFixdjNXfuXA3+xje+US5Px3wwo+mfgPEJbbyZj1O9YZgRTY0O +vfySp0+fvsEGG/im/Zyk19Bu3Uvz1hH7bYzO4oN2+x//8R9//OMf9eZ4cb3agLgMSgGfpawSd/vi +F7/41FNPPeTQPe+/t/Pkj99h1HPKjDAfNtu6/aQf7/ap03c58Yc7v/MT2/IcUk423dUizMrQwCI5 +xRTIOa8UFNnMQUncjMz59okBh5SpFOtY7A5I+zNAw4OXNhYQjQHXVJcmJZWx1XjEr1jOXEtlGvga +SBBl2W6XIVs8jbRwCJFqHfoG6iSIRomJ1mQMt20iEBlwBpwB5In3gGGYLN25Iy2UZaFKIUMbJz3K +KGgkDiaVAual10IpV0H+/EOPZ2QUi8bKCPpRyBoiqW+OfUYFtXriK1YCGYo96jb+srKyw5PCMP7T +82iKZUWdy4N+wqS6hx56hBbYcadtFO0PfwRR5SJAZklhBu+/75H+3vCfnvOD33z6hG+99JDnXnz1 +qd8484Qtt940SwjS3p7+d77pxC232fS5+z/L67MWRe9SOgK3EQFuQ3XGXG+64a5TTjrrHccfftSx +L/vCp7+/cmW3p/PnL/zSiWd88dTjf3PNN9727kM14Gtev/8uu213wIv3PP3sj+317J3xmj17xvs/ +euTFV3995sypp536iyJn+USbDTZEA+q6RVczZh5F90IXsHLSKeGJ+ein3viT8z9jauCjDy8+9OUf +2WveU353808+/vGPGzA7/fTTQ75RAcbAwg9/+MOQDED6JX76058uz7l2/B75aY499tiaj8dk+6uu +uuonP/kJN91LXvISvxG/XGaN+Qd+etw/VLOCuJTmzZt34IEHFlwck6sU+ta3vpWqPe+88+AQuHrS +k57EgrznnnvcjhJwOApLPvvZz/r90g9f+tKXViV43/ve94IXvODBBx+88MILy+R/8IDsy1/+MtkM +IWmxPffck0kHdH/9619fcMEFnhZJjjzySLhrIQAftWthTjZ2rcoa9xltAq5WkjEVfPTRRzm9wIaM +YFsbriqwFNJq8LWIoVtjjMl7MQ5l6gbKnXba6fjjj9cIKnXCCSdI4ckjqiGt97///Yi7u+MbW1NY +VXgv12RPomKo9yNjTaqHH37YG9xnn328zf/MUL6ftTTa6HJ9P96+kVcIjaduiqdjPpjR9E/AeFtr +rAd/fCruE9cR9mM224hdaDHMxIkTTfnxCXqLnq62GD85r6cEfeHRNDpobv2KBAOofjlu9UwBp+HP +M844A45K5GQYDaWUVLl1VaghWx9Wd0/ncw+aOWlyU0+3+Xf1T9p12gYbt957Z+ePv3X/A3d33X3L +iusuWWahvGUw4Taj/en29MQyT3V5+3pjrKvSVJ3YHhsbaLG2dsxj1m4MgprvY2bvQF3XioAZ+MoI +80icccOQEqhlEVngChs00CUxuDQ+n2cxMUFh2IXphIz8xX5JpHHnRcF7ef0VnoSEFW7JHJZrS4Br +eQb4y/Bq4BnMS84RiSktWToQwj8fESYs2vIlpLtVrrDMcrg0Of6PS4CoBOg14it2F5Jn0EQha/w3 +TINzAGfBp5x2VPvoAkQTrpJjZimXtLP1Kvh1ly+Oh22TooLLl4cXd9LUiSQkRpGzxAuHqEV2TaLw +LOZHZ164087bHPaGF7VNbNt441mTp05UaD6tfuj4r7a0Nr/vo0eU6tvvKrZo0ET8ul5GhiCuUnON +//Xl43bdfYfnHbhnb29fTG7yTusbnSlz4S+uVINNt9gQ+YRJbQY38Jwxc0pjs/2x6vZ9wTOetNOc +9glNu+6+/c03/qmIpNkFmx9FS0bIflisj8keTF1lxvRJCPyGyAxoz/nh5Yjeftwrp81o2H//F5gb +b/ijGBbBaFT4/Oc/b7yTz4be/9WvfuWJn4CZesCJPn3a054GDFhCJYfZBt/85jeZqn6thkX0O7l5 +jNH4EUlnO/rlStdzBfVnnXXWqrlKyoknnog/c8caNqqcych8URbFXQhGXw866CDGruEeoLtaq9TP +FojCHtwMFclLhnIlmwix6QH9dR4vJvVoJvoZhx56KP6EueGGGxBT/eCWSLr14EdGiSWsSZLRzaI3 +oFlMwqDTTNeAVSO51/b/qmKolAEvUEoBzZkzR2YpWltTq9TkyZOleBHavLW11QJCi98p0rWUsarw +9K3m4gLEcMxo2plnnun78R61pHeqFEBYY76qtLVHIrD/N7/5jemcLCIBYJe3M+aDGZ3lCRg3yWZE +//3dtdel0pnlXdFJ1CXk6PU18Pbo0fiCPV1tCfpltXQOkFpchDqwtEZ/rfSjdd+4fXh1TjnlFF3v +d77znWi8Tk9936GNaO9VrFJ9TBOUeCQ832r7yS95zWYbzpy4sm/FWz683Xe+fM8vfzTfX2NTZasn +Tdpt36nM0Bbu1kFDVgGZdKX1i+2THKNmr4aKw0q7OmNfHZvxAkVA5SxxpbZbDDNgG7nwiJbJuiSB +bfyoCmWkmnEC5yANS5EDFmrSD0VTywgGgj6NuaLE4aU0nGn1+C9NRro+/L1JLDls6ARUeYkte+HD +ygGukT1zIQtJsi5h9yQ60u+BpnLmghnK3Ub/nhqXLQSk9brkQpMFDkNvSVGWdRuUvohcITyy/I5K +daIu0mOEb3hPJXUnXkD7iO0YOF0IUMoPiZNANO78S29wd2fdsoWRy7mzml0jwELPFzyyYIMNZhTw +1pVR1nBGWSP/MIiW+CMPLTz4lfuFADlVuCSi+e1/33TLjX/89g8/zg6MPOkGRxYtqTVK82bb4j51 +2uRpUyepZnPOxUWsnFkbTvv8197ziQ+ecsZ3fvkfHz7yeQc8w7uIUNonX9+lF1136kk/0f13B/w8 +z50XYqVLrBrVVhG0hpVpkTk25rX9keYIb0eDOgLc++9fsONOc9wOVntsCG0gAzpGQauEmg6l9WAn +Y6LMQzFxz68DOR8jexEOibP5aN5VeESC4RXz+8ojP14mVBlwkbJqroJwHinC77TkEo+KrRIYr+xd +DeLJagn0EihuJTJ2uUBByxge0Igj+pxzzlEL/WmoWSPYZpttSrymcPQkpIymqRGvSZLRFZQdWpem +q2X8q5FVxaAb9UXUiHPVuwCEqzLRwizy2267rayqX23j1HKtSfgawegIzmoBvEsizB79/awq7Zi8 +bmUpieZ4i2DIhzGa7Ake7+931tfjFHxtOm4+AmhqlMLn7muWoufl57rqt8geXW3JOoC1dIapwMeC +Q+m4eQRQBeMfeILS8sHpN+k4K9QVeOt7+q3qBkJZLqyFK68cmPDLnv6hDWdMWLzMSVh1E6c2Hfuh +bQ1B1RsgrdTbAjXAwDnerQ1LljHQHCRpG5qAxra2imk7XIuC/XVtUUQj9fbEUVnD531CXHM4c05V +uFVTj8eYJahyYkyox8AJuMLfGyZsunBpfzN4QV0J1ieSqgAXk6UIQ4BizAUNMzFxi3IKJZzZSnGB +SVILB4Rh2+Y+A/AeTwiaqxupLlWMPgLgKTai0dMUz61kQBjlpO+XACFPzdZUr8gcKSWE9k/4d42/ +9Gmro8ITGIKqAG2AUw7HsqFRkl5K5GVPm6ojXpzApUpYJRxK7+6oW2KkTDs317VPHka4zeduNHnK +xAvOu+zJu+wQnvDwiMZfZBsJNTFxRjB7o5m33PiHYJ8yI5SI5lnP2eXJu2xz3JtPPO2sj226+Wye +XYe0xEbz2ecozHCI9swQJqNyAo+icdQCn2f/224/+81Xvn/az9/9ls89ZdevbbDBNJIE/3x3993z +yNuPPvFrp71vz713/skPLzn5iz/SycgduYKL9c3eoKA1okmyCmEQcxg4mcgb6Y9130xXUw7O//lv +o8Q6i2G7WJZl+CMyryGgoToBW/ET8hmyZddAu5pk/GvOTL8piMXntBq6vzGJ14p+8JPkgeRt4mtc +lQHzkbeJQ4t9SV8fffTRhaYGLXrY3//+9xmjdAvv66ocRqcUnNCfGNNi6yIJPsZra45itzUZRhex +jnFLjJjphKed+LdLb2Y0Q/WFWMZQGSG1Hslqma+j8LW86q7NlVU+snX5fmp5i5xM5NKAkN6jMY1Z +I37CRvr7B/2ka5rn720HP11OBl1UZqhZA94BDwxvSa039NgKMCW4hqM1Dqxewz++jPJxlAhXjAiI +FSlB0ULr1AUbzZys0//g/BUtjdXmxpY+UBkOtPqJk1rYAEYozQ4FFs40BSh0GmvAyCXgNMYJVxAb +1AzrxXFp9lWwwX2ugzSPd2VHPGLSOTSt3zBqKkf6t0wsCuM1V5TG0GkuicGKArU+kqeX9owhSaqZ +HQPBqdFEGpQBSyObGdG/xCrvSc8SqnltIWEcEjdsEYLMYVZQvKBgjr9iQn4AoCzlwrOgTETXmLHN +U55hompKlJEZHWATQ3dBWQqN7KgzJchGECWsT/jkUXKGf5pVXQKJ5c3MBXICM1Q2zeLMkG9S3mxb +lGgLpaeKHsZRiY2xt1TpT2vVlpamN77538/72SU//P7PbaghnRV35RW/e+D+hwvIJd/hS7Rbte4l +h+x7w3V3nP+zK2D3sqUrlyxarqyQua7uuA8c/sy9nvKm131s0aKlhI8xcocZWCyVbwRBJPiXoQg5 +HA+tWvfIw4uNyLa0Nb7gRXuyI/v7BrTeFnNm33HbvchUx7JUkU23mL3g0aW/vfKWlSvsRsnZYJlo +fCUq7aXkFxzDCvpueMbh4c6ob6yfvfGM22+714Pu3oH9X/ws47Vn/+BSOx/deectOo7WW4/WwkUq +1zJwaNyO6kTjV8DXOm/ePMOTxTylptdlVYnVpUZGjM7AUeNqcq3WkKqVu44RPWCUW221FSezznRZ +9jYmr1Ul+sFGQ+fMmaN0T5na9MlNN91UKOUFsaxVaGroh+dpDIfRt7QQfOLP5Jri8q3Nbl0XSfDh +LWfcc5DqkRg/1vKjma973OgV/GNdaFgvpSwO1A7cBkyFwke9AD9PHoNbypqmOHm0JuExrLXSaNl0 +OLQSZ7VvBpzzePs2RhOsJU4kDajf47MhkpF1hqmPai1ZnoCP/HKHRxYfr8r7SnzieotGX1zFpTxe +zNfCpyAoAjg6GkqVbvu/huYFjyy21n5o8oQ24xLLV/ShD0drtXnJYmeUOnw0VHlHR93KWLRQdbBa +6G6jkg4Q7Qw7EjwYN6UczXkwNYmK9Rs3QzBAK4fWQJqIK0MWYHCQ4gAvu80iDG2Ql3Qeag55y2gc +Sg+LZocTskAOj2CqdwP24hjwNBYL1jKF0zGW0Ji7+waUqnXahWDJbWAnw4iph28iQfDPGac1hFCQ +uOpEHTMiGmS5HEWkBoRlgQ3KZBYMI5Y3LgEAWbUSL5YryQOJs7LKVVJwS/wusBRlSSnuVtlVEKZi +pS2QNcUujMUexYRf1wwvHEpAdvArnveeDxz9vW+f87y9D3vNK9728gOPOffsC7OcJMmmKMRFkkMO +fd7rjnrxh99z8r897YgX7fv/brpxeO1BtEClcsKJx5qIdOzrPr5ieWdnb1jpUVTpOgxziXchlMpm +NBpZuOePDx3+ivcf+Jxjj3r1R9789lduvOks38NBL9vn0fmL99vzmCsvv+mpT99u3r5PO2i/dxxy +4PFP3+NJDMzj/t/n481GbsFaUvsCRgCfVX06vgffom0CBwePevNL/us/T3/+3m+1qHTuVpt8/uS3 +vf89pz51uzfs/eyXGu7iApVfpuTzlwvzkWvXxB8auQYbBj75dXbccUdeU2G12vYvLDJm/pERNd5g +mtQas29/+9tmlo6heQy3JuSzbuliSLnXXnv5qdqSZQwf45qcW6TVKT/88MM99Ws97rjjDOuQx625 +OWb2AleJCFioFlCOYTL6lpeYZcnYtdSnMPR0XSRBNnfuXGaxEpkHkLtM5xnNfB3j3ss+++xjCZ9B +Ze1ZvKMmBrvlrichPry7zHQdCLs9mCxJWii+Wv5rEl5jwmyW9BjI90kY59Jclspw1JmZZW7aajmv +mugd6UMwo30AgjFst97IqpRP7JRqZdsDjrr8Wx/7p26FUEWpU/RhBW5eoTh4Xbv67u5t/8YDC1dy +p02b2LZ06eDS7p7WFlgztGJJeDgnT7FTIBSp9nRhU5k4Jfy3Di61CRHjASpNmEQ9M0+rM6c0D/UN +zl8y0NQaWwmhaZsYAICsfUJMNQJRNGFscpQamZFK/7JuaUfak/0HKdHY3g5eUseugASIhv4UjOdx ++eYqT5SBT6xPUGQhTQIqEinxB+kzFPgJ5rl0x6NQrgld4iUdfzo6knPfBr8Cg7XAqdwWGMZHKWX6 +sVxxdkmyAvZdtx980KE7Rh2CRbAKsREnHoN2dSx1id/XiG8TLf+tXkiJEI+ZLkUEcay1hUZAJUUV +xyQGa3Oe0ZKcFqMgZvfUmcGhIEagbzGas5QF8xd3dXZvseUmpt0qWYvJIhY3wkikpPT39S9dat3z +dDS4FUoO8PJqol7JmWyqVjpDK5fHNvK8uuorRENpdjKz3fPtiGC+aMHS6b6MlvrCLUitP1mwZONN +pqqVl7585cpJkyY0NdUvX97jUXu7FchFhoqdjciOGy+JTp+zX5SlnIHqYFNjQ2dHr6XZG204XXV7 ++geM0i6Yv2TWrC0nNe9a+o6uQhYYK17mzJlD3c+dO7es8C7ptWtHRwfjko+nlvJXIya+MnChyF+l +/JsI8DQ0Q0eTR0aOqzHZi92sLz46nV1o5IijqySqbxmjZaJxUOE2mnhMnB5Q6Kp1/6uSFD6sZ+08 +Rp4xRYTXVQsAACAASURBVKzLLbuT53aMqOTnzCtDwupId7mliVRw7W7eNQnP0lXTMaUQD0/YrNHK +ZK51EXg0jeJYJmVO9ej0f4G4jd//zhXVz3n9B/m0hn+K/9Qt4kMPGMzgGxL31sGqSH/Dvd09XS2N +TQ3NTXyqy7t72pihNrbvHnKe8sTJiaM0o2WjBkcdnQYOQ0NWwxjtqzY1h97jvA2saqg8siKcsGZC +dPXkjFkAYNYu/cuOtBgm5yLR1EwrQEXvU9CUKRyk6HEOwDCBKIdImbnAQ0rogLTJymgl6AWfdC1u +gYXeULHwCiVXs7LSkouyBcSpRtROBBzGrZx5JYwS09QJGYJGknlPDhFLZKLHY76xjE0hWGPJmDCp +lBFFHUCSWj5ya4ooU10QKz9HB5UYA7FuE7mxQoa6cMBf+0RK+plLYjRajilGNr7zprqOZWGPShSX +RbdGo2kWxcliW/coPm4issHs0KrIIqFcUzaJZMNEFunFom1satpgw+kozdPu7be9UFQnOiLZqiQP +2ZJ9/Kf9Ujaw6uWFtNmhqU/slFcHwrXg+oxZ5r6GDCFb8tFWG86eXoBW3pkzJ5t1xG89YUKr2yjX +F6IuFd9e1YqYSe0tK3t67GfUa/cj+201lapWGluamlqaciISQePznrXh9JYmLm1HNYx0plLa0RdK +uejl0YniFLQwJnHttzyrjzuOKrEGh6uCaJFntaDFsBZqAhccdWusp5a4pohRnlVxFPFflaQwXHWA +aU0FrT29jDuOoRktf62C3vXacRSTNQm/poFMPJnyY0pf99taceue5YlDGXrsX6C2PpFSCxE4Wq4i +0FS8t3qbs9TszDBr0uTl3YOsgI2nTbQ5YN9gICKtFngG1ezJAE64dh0bOVBtnhBKHIBYMdJaaTAa +Sj8uXNILPOwpyHfqSBlGEv+tsilcsBfLZnKsFI4aSYVbGMpI7YKrYsdABYOyg9bD9MbmRBCOSlVQ +WDwJBoAwcJTCzdUs8JitM4wlWckAhpz/EvtUKSKrLksNQQvgKR3DUPdJQndrpKL9SxZP4+V74FHi +KEraP9zC9mkiMBDKLSYQyIiyYGE8T86BQyCBDGlcDpN5ClnZuAx6EUA+gqZhgGZxnioxuCEGQhl3 +tVvRaBzl2uWEl6vQEDvkz/pGpTIeVwVrPX8hTlyDJm+ytKAsuFhuIRNYC0l8/Qm0hZW88Y5IlS0c +7ZzNgxBBxDMl6kXgTJTs1ZSybPsXm+dm4xTmaPBXlj0p5dWxQ+lT8ZSwjbl4OWpUD8eNG+iXaKpq +c1PF4KgPVz8wd+GNs9Y0aQsrVVtHR6TXsQghT4aQLANYeu973ztaL488Gf9/vAXGW+Af3gKNfrH/ +8EL+8QUUNKVbRGoBmg7WLWhpX17tdXpy3bLOlRxWti9cuKSvs7/PVCOKCUU1NgmkVodaWir2rJgx +qbmjg6s3IHBCa93MKS2PLuoxZYkecyBaaMOhitlG9B4VDzVxRhlGmAPaEoDpRykR0osLsA2dWjnD +qymERk4A4L0MJQ6WUoPbpxBwsojjfZTBVBCbWCUlHoUqjpCKPXBUDaxmUjSWUBmo8VeHUk7wHn6v +qBO0ZPSIAjfUW1Ah8DseBpyrhd4A2oJVAIBgw3ZbJuIWwBANEH7OAiHh5i5JWYR4kTC+KXF1yXQZ +iwxBnLVQimikZ4NogRWLh9e9hLnG0G+KIdIiZ7QSvsROSYqEAXWlsFpi8ixPkRZpg1cSlAjBSK6I +kh2DwiaEUeURhuTkjsYBmav06KAg4OyFYmklJ9/MAiZj88hwgpRE//sDrNZHeRZMgnNOK0rB3EL3 +qE+GLoMHdq7vHdIO2WCVQV9XwHC9+cQ9AwNNDY0t8TrCQ+E0mqre30go37w7s+XLkNvIk/H/x1tg +vAX+l1qAcqj/14BSDVYQVKQYpqUJe+vu7jErd6ihd3DQ7rsAo72pvmewv7nZOj4jU7IFoX1FTBOt +b6SjqktXGKAKhUtf/X/2zgNQzqJq/9t3b6+5qaSSAKH3Kh3pfFgRFAQBKyqI2P0UAUXBjtgLCoqI +IEV6BwlI7wkhvd+b3L69/X/POXuX+1EifOQLf3Enm73vzjtz5sx5d88z58zMmWgoTHyGFJOgOGyx +2FgUA+zJJJWphEbGegOBIIPSjwKZTIsyEWg4Kh+sLZRFq4KjPoEKHZ2ECuxR2JQ1DekEUwob9khf +o8H5BHLgSwYeuUZ3u4mJKsUy8UzHJPoLYgH8Fq0Jymhw+KkCjYMZRFDoMs4MM3jXlb9BxzCDOjQn +zyqFLRaEZGNopyx7KYeEvucFLLmvkuowj+qH5ojhxSBDBeFj5J1a9E79st7py2fEqTiwNtBnfl1E +Sj5CbmqTeL2AiBg4UVetGNtcuKzovi78pdaU4IdEJglW3ROrHngHwDMNiawM4w9jjL5o75CVoRgU +vF0aevHCXc36jllH4Id2DZhzWLuWD39kMrKhKSpSnRwcJMRzcOLqhaIc6lQZPXdC6zI/Rm0To5Ep +57XIF6uUteV0j3BIRQIK5okHoXyYSJtFap0Uy7VUk0BNAm+mBEAf3KFvJgf/d207svZnnh3KcLwG +mgdFWY4nQmVW73LGButwCwTdLePmBczi9ag1ouCWM7libx+eNilKBDMwXFzRnZW9Yto5HJOtwHQj +KlJ6ExvFQAWQwDOMmcv2UCBNSGPuWWCJYsR5cP8wIMeLTOxRNCSqEzuVkmRCFohVAbNEaQ7iWGYk ++ISI7D9viywuAABz/HIhe9TxTytWBIdob1mxJMMb/pLPq0pB7Jlho+YMz+gIieVIKokRZpt/OI0V +yiRa4T8y4TYFYElYAhtmY4EC1W8ROchT3cGKsguqOoTTgrPhLSJDcmBgoCfQry0Sxgn0R6ZIaY2S +giIqQlAdUENc62kp15kpqFiFtOVbQ0I2Syo8wrmKWbvUZKSiZJgn2k6TCwd76x3XME+qjAwca7XL +ZWBwYNhrUYYLnoKSERGr1WSDADLUrMnQ7qqEQziM5BnPGrpzSz2WYxe3rnLpLL2si0dwIPNrDePW +p7mQLWyrNvG/vaAF1uP8b2u/jnq+9+N1VPi3LYqi8c7yLpd+Lf3HSICB7+jf/Vun30BpoTyYD76Q +LRQb4rF4OJ5k+30+WOQYZtsDisnIVBwKNBiRwmLfJ0jm3/0EDkxiFAG7WZBJygssRAtHw0EQSAgR +LuO2JQdtqIVb2IImuVRaMMNH7BtAAiNYxgY7ZAyT3JpE50rtUpeSYCd0MEfAS6sIGTKBQ3S3cM7B +FVgColDKwJhtOQU8NDlqAEAXVNdwRdVBB0xndDdWpn188ZbBBrd4wSHvasIKU0tV+E+LmFnwg51t +5q81UxlbwM+LEEVDZhCrUa8PVCBPaxQEUrvAnsOPqAi3qKIWHXICwaGeMHEBBSEmRqqwKJpZUnVK +hpso6GVtcSEaFLYZVj729Q3sud2xC+YvUxnjQe86QDt31Z9vG+xPqkN2C/rSbDwOOgVlri1flI0s +oqgm0TBqglXz8ZLhPWIl8MdOOueE93yZKPbz560QfesmBSjMUjJ45vmSqda4zUvS5gTSIg1BLW4b +YKDGE1QxjfOYmLDC1ihfXQ8pSBV2xYCoWRbIqd+aQI0QNzvE7KvRVROVCzXzOhNxhapnYb7Oqq+j +OCtRWfZZDfjwOmq+zqKIwoPZsoHSm2MPDJtA2MnDMaUEwHud9F65ONHzoflqmz7Z10tniVZItPAf +/OAHr0yilvtWlIDWO7xlEjpotGbJlxYXSsloOJpMgZ75uhgRGIqFfDEcC+YK5XA0iDqLx8vMgLKu +I4zHNxAc29RQasqvWZsF/9BzqGwKsFBIBiKCAv84W5KDnUFd8MuWFBXMi4sqxCEMCeAZjYkxhz6V +QWkHyKCmJWdhsLSnZivBRXPqYuPKkWv7QVHulDfoEQBUE3qf2o43XNO24EGIoAvjy7ABnmT7CCSo +rWuzDslQeUM1qgsmzXeqtVHWIgUggpmLQEB9KvIZO5vMSoLhKhF6wRDBpmMpyAWdUoIhY5KSzpjz +QE9VgA/iTHz6DCvbKIf76vp7GaRU2OOCFdQElvIqvMMJ4qomx7w1q9Yx3h8/cYyKVaVkBqvzQJWM +nVe68y5bNrc0UIZnoY5DzQTCc2HyW323JhC4jE7rNUAIwiFqPU2jTxUkQ4Is14888uyShStvuu+n +MuvL5QXzl0ya3FXfUMfAiKes4Q5jFNDXHjQVqeWDLcQCQThh52gpz/eoIjG+inLiMhOf134YPVyk +xfy9eGNylH/iXYgqroM54h2Fh2MmFL7tfOer8vmXF5T3uHSvuET2X1b//7wA4RoId4CzHCj108uJ +UMjyCHZDEpyBWHdEWiBQ2hvsBRty2DtBPN5X3BZCfD4iALPYlbNoXnHN8BtsvVb9/1MJSJ+gNt4q +aTSOcj2YfSYYyrc11Q+m0tiXUzu1+UzKCv9qrFzmHG8i0hHXlLC6HNBNNIBwfLtNJw0OB5gcjcVk +gBKuQco6qGALqD7NbmpRsBQl9ihzoig5UFPbNAFK28JBeVWxeEacIUNCvuxb9blSFC7X0pLoRV6G +LmHxI5rAEsYimehiXmrCIiuxCEjYjNmEIra5UhWAtAGJgEwaV9YkGhn1DedS1Aa3XlJcsVBpxIiE +J1Wnnjkn4ZZiJLpGddqFGf9euJNZfFoBLipkzV5kECBNbrToEZdUpCQdIZ+XKtoF9LnLixy98uFM +b0tyIMTZYiLIy3a7trTrGgYQjigb/FDNZUUOHTn/nF9efqmOOaOkKBrbtO7S8Mymlqbr77h4yqbj +/a4oUMzGDV4SPsUMIZEjweZ6dp+oALegj7S5p2IOsVaMPqpKKPDko/MmbjJWGCkPbf69R3x2wQvL +uaY4/aI6W6rASy7gWUT0DeF7J5lQCAqsJxdpq2KNBONs0NET4TurGvyHMaZSISXKZcZ5dJVs/kGA +NrRnxomIzqjrauYrXoArmKHrj5P+ihX/LTIJJ/S73/2OXZUccYHB7TxzqjGRehhAAH7VzDfSHT9j +h1gHr0iEFdTEBmJPC3t1CEPximVqmW9JCWjlzVsyFVn5GFpcKoZ7+gnIEKqPh9cNZFj9SDSiaLTc +EA+HEmWgZThdZNkt6gjTc2Jnw+qB3sEkq4AUL1cThxxNysyoeWvj7Jwx/QvykTwgAxBY8YKiQNn2 +kNcaIt8AUzFJzWKTLxdlaJgqnMMuNAAA/MBIiHBBPjaNTE9uGWqqpD8e1DyvkYR6lTqVwlfyO05f +s63eIohoOIcFSTGYcWjkWrBNNXPwgtzy9BqU0l9wunIwnCGBzFZrw7S4eOZFXTBDqt95M1SmdfS+ +KX6VIamiX9m7oNQQkfdiJpIdaMtlI/lSio/AhHodDjS3aRaZejQhaDewpBUvAzWuf/Pzqx5+8Onr +rr7znYd+6t47H+YWaWBg+KxPXbD/Lh/6ylk/yqTZOcuxaMPvOPhTSxatkqCCgd//8vr3HHbm3jvo +VFHoAHVIDagjcTxLLpP94ukXHbzHR/bd+eRrr7pLbHOOaf/Qf3/hxwfudsrBe5169pcugiAcXnHp +TZf/4cann5h/9EGf+vvVd3zkhHOgcNZp3zvygE+tXLHm6Ld/msCE5KQz2aMPOuOKS2/hmn5c+M1L +//LHOziE/qufv/iogz6z706nfunMi4hGRHcG+4ePOvCT99z92HHv+OpHPvgtULNv3cBpp35nx9kn +HPK2T8/5x9OKMlgRtMTOdTwS/8XFV+60045EzCEgETEZaIWEKcYRoZxXShQh4t0QNt3zR7+/5OBP +v/XyKrSCPYcxN3Xq1HPPPXc0Bb8mINHo89HOOOMMR6lXPBRzdHXOovjQhz7kOViQRJn3cIbOPAHt +iMUDSgF+mJigIAwQG6hKgcC8BPph3yQ9xW9czfcLMAw6gBke3ZeHOaQ7jCH++te/ck5GdYb4rrvu +IvoSsZMQGo06HU7UIdiQT3m+/PBUP+MT9ihMKAlO4IFhwjNddtllXt39uoSLgnnPqb2/9SXAGLfE +9M5bK7nqyRSWrumfT9wiudSIVZQr9g2n6GoRs1Q2ojQ/GxkBElQtJ5AAab3DyfnLe9HsOGlZ0As4 +sBAJYwKvI8F4KY8zlg0JaG9QCu0PxLI1QgrORMg1XkGoMUXqFgwVwS30MhDlQEsVKoKUAgzDS5qj +OjO1KEwcfTI/qG5PBFJAFBXhjSyKAcmgtaxhFhjbehGDElGjJJxw16vwroYMqKgLlObMhsaTCUtu +5NEInWKxLgkOtYkTsmY+0pb3AjhXMvNIrRg2qAlzWUOfRmUNkw8tkvHsH+kRdCisTLtFTimbyA52 +loqxbGEQw4u68MltojEgLrPGzLYzESBGHxlIFJjUgcAxHzh0ux02O/iwPX/9x3N222tbR5lzvnLx +vgfu/LNL/vuB+5646/aHaIqYV35eKVC2emXPDy/44w9/8fk7HtCpotCEjrpp7bIY7Xe/vXH1qrV/ +v/Oi6+784Z57bw9N7nz2tB+sXdP780u+/pNff41AgF8+64fwdsQ79jvi6H0233L6by8/58DD9/zW +986gra+e++Hf/PGcCRPH5vOFOfc+DvEH7ntyyeLVd9z6IHdZdHvVFXfsuPNshLHDTrN/8fuvXn3z +hf+4+7H77tQRYPlCEbw//xuXnPqxo8/5zkcR9Okf/0FLa+Nd//zpCacc/s2v/ZYycIMY8e+K31Dw +95fc8IPv/vHsb3yVgy05jQuPJTF0KEWQVawxjkzhmFKO02JjjMcMEoWR5GhRPfiTbMLfvLwKUAQw +MO1H+vnPfz76jE+nBOBVjx8nWA9xWYE9SBHRcP+XHYo50rj+UpjIc56DJxY70hEL5u+//36AlmlI +ovRxFDaHedEFQh5yjgq+WapAn3NVicvPPCgrol9uYuJQZaxAeAqi8RGN1lvxd5CP4IKMPPbbb7+n +n36aY8I8n15w1hvBEDhFg0YRKTF9aJoYe362zMsPTwWGYZuREBQ4Mp1pUUxeYtBDnBxa91hCRE71 +Jmrv/xESIFKZFMpbKwGlzKUN5p8ulFJ10bp4OAIg5li/gTnCUiAiK+TLQzq6hj0qZdYcMY+K9YkY +MFvNTRsgBi+KL5cVAsTqAnELsaKAukkyVFT63YwkrCgSOSAK0AZQ4TTmFsS5FgRKE8oMJYADQCts +sBlKFzu3qAgogsXcAnX0MrgiCzShIYgANkIWufYMII0mJanICz1LAvmgDJ45xIpRa8gZcG5pgqRx +gJQyeXpRi5JcYKciItp1CjTqhrLqqHl1U1XATqsL57xkU4LieMnNpBbzZu8KR8GkkbvwKDxINueH +u8rFWC4/mC/kvC6sstTIA+16eVqp0DHA83bJoQlcZ+g4DgRta2vhZFDKkz515geOOHrfmZtN3Xz2 +tGefWqCS+q/yJPYUFwrFm679Bxbe5GkKmwfb0NRD1OMshaPhRS+sePShZzkflHNGubVi+Zo59z55 +zAcOnzJt0oyZk4494bD773l8xbKeurp4XX0iGo20dbTARXunggc1NDa2d7TQl7332+G+ux7j4q7b +Hj7h5CMee2huLpt//J/PdXS0TJ0+oaEpcdS79u0a2wZSbrbF1KeflFnjHJ75pRM4YaZrbEfPinX3 +3/vkPgfs2L26b/sdZr3w/PJ1Pf0SBWO2AtGh6W35t7/++34HbH/oYfuhrD/3uc/xVccUEykL+850 +IH5FDg1ldczLV/oQro9ivFdDBRHP6OVVADBA2tGCmL0vCegKBTcKsRG55uRg7Dwi3EKH38arHYpJ +yfUnpm+Jm+9RamGeIxdxyRLzFg793FMaAvOICczQASznJMf1E/S7hIYn5C/zl/vvvz8nmeOexWAF +ArkLNmOAnnjiiVwT8P3kk0/mbBYCyBHqnaa9OmGSXnJ4quf7O19FxhnIAZH+y+BEoyvWrt9yEnD7 +6C3RLRDUE5GjUSKNk/8ZbY8wEzeYzeUzOru7jgO6Nf1ZUoCFEks8ArhqQQswAwRC69bXEWhGc6lA +BWt9S3miBgYWPjU4NFDabLsWlhrJjrRVJHiJk3muQOKKCQVOgHnMLKLc2aWKBaFrwy38vRiLJPeg +ZlKF/rX51s5YNKYpMAGMtY6+lOYnB4AsB575Z/9TDwzsfnDHzK0JyCntT0kYkDYFl/gDHtiD00dr +CM5pFCBUhgGb3RdZUTY8ll6mOatOHj0FX7WLlO2tfPaNs5QdAUsKktSQeUrdhIUZa0N0Kem8OZDD +DNyCUoIrq0KOqOUixXR7MddQZiRTHM7kkrRL92GG9bqNzapF0uSr1zKZiAho50yM6pFKGleyaAOB +KdMmePUo+3w9uWjMKB/TaaeK/vcv8M1+8eyTDzp0V1U2+PdS7zrmgDWr+k475fztd978v8/98LTp +45cukvNw8y1n0DRMbrH1dD6uXNEzabJOSyXRKU08G2Ncg+n4Yfc7YIcvfOYijlu6965Hr7j+uzdd +949HH557920PHXjIbiwaIv9nP/zLLTfO6RzTumjBiq23nqE5aaMwpqsNTujsypXaFfSri/+mSf1A +YLsdZ2Hddoxp5VY8GiLEYKFUWLZ0zbuP2adYzuKuQJUDdW60UZHVLkAFF689yOorVsHpikWLsQUp +Ei5Nv6i+E4AQAxEbFxDFhP3617/OLdhYz6GY1bqvdkFwPlCTuzasfTEcoH8kH3OWWLgex5+PbjW+ +GrVqPsHisTI5yaQaTu+DH/wgzOPUhXOgmqW2XhhPMjYxVilGdrU6tu96Dk/lPEdwHejFtMXWf4kp +XCVSu3jLS4DfsdsjG6ynOGruvvtuRsoMmXt7exnTMbx9xaVu++67b3X5A6YGkw34iDga9/WGCX05 +6zfccANOoU98eatDj5qIIxcljWkXThSyyVIwFizlQsSgYblLOKK1u2BBvLHMkV6Jetbmag8oCaDV +ahiiBsbKV/161eplmS9ftFVrVxigwrmKetWEolyvKEBDJbPDwA/UHzgNHvh8JDiByxQrDcTCaly+ +MHnjn1YvfI6QEWplj0M6/utDE92G40kIQgxZwVEIdy/PPvXgwKztmqZvLtiCshJTnqZ8aZjC8lJa +LVrBTy/wNsNRJiK9EXsViBJvvp3GIJlrmCShjr05mZV0nJVTZt0KomxOMWf5Ygy0NraNqgrTC1nS +VksLnm2xDPlQ8LuAK7UEcrm6UgqnLtFjcQ5k09lBuMDE4hZO3ZYOXfCiFTADDJH1TOtWl1a4RY4k +oP8GoeqZJcvhDa7EJFf6ULkpVk2k2Hw33vOT3/38us9+4nu3PvCzdmKpm3+ekvQpHI5+8sxjjz/p +kC+ccdHXv/izS/5y9phxst4WL1o+YVIbknlh7jI+jrVMSNKKP1NmByyJR+S/3c6zk8PpKy67aZMp +49pamzkPldPFb7v5wZ9d8hX69ftfXXft1Xdfc8v36hvrPn7iN/XtsgEHFMSn6JZaO1r5ePpn37fH +vtsQZ5evKG0R8Z6QhFwxxmMj6LjxHQvmr9Ishb6oOkmU1aoq95rTvyyMiQkC/eQnP1kPSQ7dxPbF +POUnj1+XkmDVazkUE56dLM7e9dB/+S3mhvHr3njjja99oAARQPQly3/QPMAn4wCgdPSML65jlNUj +jzyC15fZX2cAUbzi4al+F044r4ajY5gxBbCxcV/Odi3nP0QCppg3UF8ZvXKwLaPF/fffHw8MRw0z +omQS/uWj2mqDTMnw2+BHS9RsvtZMdbDIsHr3NV7gkwGJFy1aRHnUBKPOK6//5ta7x+pwzobykWCM +/XncEu6E2A6vMpFwmSi4qLD6RiLu+rRlMD0UTA2Uvvnxp3/0xecTthUEg/KEM6d95oLN6ltCABWq +s5DWgqOsgs+h+xXBjfPAHV9pABsXlab5UQtkwzVwIvOLVyTwh+8vXfRc8rRzZpz3h60+ed6m2+/V +SnkUC6gGgwAV166dhazoVksgBEjsYAw1JUdTc+FyDSo41AGEtPjY/X3fOOXpe67roYrToIDMRCZZ +dTCJ3Lko8Vi9ruXRNSykQKWwnd2mW7aWeETvyVY2CRpo2UJftDe1BagYf+TY3C04KmAxjIcfxhyl +dHMxOb5cijI8KRULyUw/ppVDO4ICRxEOnfWXBgqQ1TMSuvCRl6a1bXihMqEAQDXv2UUqZgzAKpyT +z4ukesaPPhh7bJ5ZtmQVXtmDj9Cporms1gyrHMn6zPGiw8NJotLvsfe2mI9kTpsxfvPZ06+/+s6h +wTSHr1139R2zt54xcZNxkoaxSlWmnzmpb+y4jufnLRK3JebJ4jvtuuXPfnjF/m/fBdzbbc9tr/zj +rQ2NdZttPiUWiXR394+f0IlT+unH5i9dsnpwMOUsGB/W30BgwiZdu+259U9/fNXq5WsjkWA6mc2l +mWZg1TdLGoLlYImuvePd+9x5+6PPz5/LFAU/Hw5XYY2ME/mX75h9ow/+fLXyrAy64oorODeUXwrI +hwH38pK4QLFo+ekdf/zxjJgp8FoOxWTtD9jPpsynnnoK+Hk52fXkHHPMMWxE4eBV3inGSt31FF7P +LZQSh5FxnBmmP8eRekkGAfixAVfS2Wef7b5rbr388NTRlJkipS8Eqce61YzRKyWWYuGH9/nsV7pf +y3srSEA6cPTv+Y30iZ/ctddey9eUC/yrzMxjdDKKJJFfHYq+pAkWv7HujkV0KIVp06ZRxVdGMI3B +75lj9ljjx7br6oo7vvFs2MKRQi1mU6DGob4MBgHg973vfeeccw4/frZjn/GJC+Y9PpzJplYtSX3m +xH/86eIF/7hl7bfOfOLsjz/56L19vtDqhstXXHz23M8f98QPvzDvvhu788RiCwT+9JOFwwOF1Usz +537yuYXPDaHrr/vDit9/b3Ehx2xrOZ0u3XNT94WfnfuVE5789qfn3XPtWjLRy+vWZC88fd6Vv1j+ +5P19P/zcvAs/M+/xB/rBTsAMmvzEgMxsWpJGFw8NFoH0STPqJ05vEOSUAwO9uct+tPicU58576PP +ij92WgAAIABJREFU3vSnVYpvzvyl4yV1DCReeHLoR1+Y/5Xjn/ruZ+c9+/Cgwx6rO++/ce0FZ8z7 +yglPffuTz935t+41KzLX/2FVJlW674aeb5/xPE2ifJm1pW9iA7QzfIW47FFbSOxPBJDmI2T5TnAX +iBUQUsD0g/DFUM3GJOqFSmIpAi0GS54PETLUT3OfBnKxQLKrkGpjeVGprOh4qWxfoZgDR0nIlgPU +hPEjTl0yaYWXqJtBr0fCta27UR27Pvo9OhD0iAM+9uD9T9A70kgpXVvz6kU1LVyw4oPv+fIhe338 +1A98/eOnHzNu/BhuChSNHhd/v+aeA3f/6GH7fvLv19x7xuffD81yKXTOd05funjl4ft+9PD9P8qi +pPMu+DTFxY8lHx4hqpM+cvSPL/zjuw4709vdY+/tCeC834E7w+pue22VSmUOePtu+lGUy+857qB1 +a/v33O6kb33jt+98zwFXXnH79Vff43zCD75+Os4384Ifns6M7D67fny/3T62764ff+qJBaA7E6U8 +D34FBA48+SOH73fg9vvtdSwnemIS4YEEnyps/as/cDL64M9XK85PD7MMhIbytGnT/If2ksKQYmaR +ZbQnnnii33oth2LyS4cmpt6xxx7Lr/UlNNf/Eav0L3/5C/ph6tSpLFF2U3j9VV7tLvDPTDCco50o +Q/QG1hzh18XJzLokpnvBWge/lx+eOpomS5noDhOxjDxerTuscsJUwEU3umLt+i0mASmumQefeu8l +r+87/YpSAMw+85nP4DkhMfjFZ8vZe2Sywo1Jju9///s+EVKti5sF4HzwwQcxKD0TBwvrHfiNsRB/ +//33Z9RJrYceeoh1fThsjzvuODxCnP3LscZ8a/mis1iO7z1n0n74wx8GvFm4CO5y97vfO/+HP7j4 +1M9t+q73bPbccwNnnHBfY3O0qTUye/uWO65d3dIRO+/3W6WGgtdesnzC9MSYcYm/X7Zi8dzhL/xo +i6a2xLOP9F/6/UXtXbHDj5s4dXb9mPGR8z4+b82yzNd/vRWLU+66ZtXtf+2etU3Tbgd13HtDDybm +wceOO/i9XcteyHz/rOcbmsKNrdGZWzX+46a1LR3RL/5kc3AMQ1DqlznIaGDOLT3XXaKhNPboYceN +r2uMorVRjj/+4vODffl3f2zSsnmpe/6+9r0fm7Tz/u23/GXNrVesefdHJu20T/uKRamLvvLC5Fn1 +B7177M1/Xr1qSebLP92isTly21/X3PznNWMnxfc+oguwqmsIz9y28cbLVj1way9N8Jq9U7NsU0IW +YEznhFs4VMWOWZwgH+YEWCLPLYYgWAGM2XQplrfwxjzAmeffeeSxWwomsZtxVpuvFWORa6CFfN4F +hwColVF/CexTaA0WOoknkJctzM1yKtObyaWoyCfmlZvbNUvqdjmZMEk+74JnFRdZfRS/FbSkmGeS +0bOml0lEItvqpuEinLhlzAUVGTqIJfNsw3nfuj6WFFkPRU+t2botXxrGwUFsd+nqamEQgEyQ1fCA +mOSIUxb7NDc3wIY4N24gTk/hnAuSvuaZXNeYZsLn0gMCFRUY4zDaMOaRP/UYw6hPJRaNDzS3tiDZ +gcFBVjlhJYOmsJeIh8FLnLragBQOgsfZTJY5VCYR8ghXWBuORcKE4KVHuHzDpbbulW381jCtSAAb +Sdy8hvSSgz9frQZDH36DuG0db16t2EvyGcsyDl7/oZjMR2LRvqTia//Ib581Sq92QNtroYMHi7E4 +q5leyxFyr3h4arUVxjfAZG3NUVUg/44Xb/y80gNO/dqIenjDAuArxXeOnxBL0vlisfyBd67JIb9q +Vq6nHRbvcZfCbHQDINnpBXDi1SETJ7DfwrcDNpOYWAVHyWRFn/8sKc8SDHLypXW843dsitdnzF0c +S4Q+8fXZRx47edwmdf1rc4M9LOwJAJbb7NIxZlJi2uashQm88MwwA//pW7AJBhUf3nLnlo5OGVmu +plG76MT7btDsziHvm7jZti1HnzyR63/csBaVyoukVr4x46iTJozdJMHCot41Bba4MOMH9ijobiyw +/9Fjjvv0lER96LH7+jEu5z0+SLsLnhnqWZnddKvGGbMbdtpXU3RPPjgADLg5yEf8sXNuXUfJnfdt +75qQ2Hz75kK+PPexITTn3ddpdcwxn5i8495tu+zfvt0eLXX14fFTtOC4a2Jiy52ahT1mFvPOoieH +DTQuutuT7FRAwixRCpC0SCqnXlOFmIkOvbTOC2kwICC5zoaIk+IW0AJiwJJAsVAXK02OlCYxXatQ +egr0mhtOrXUcRZJIA3uUddGiANI4OejSBMnwEtLc0svwlY+iLNysFOsap4AbVFUB6yY8wwZIo945 +Kcc/w7DOsW3gFqxSngK2GFY98fLxeLhrXItPBlPbGaOptrYmcJQL8JVWyBcFu6BpibccaGmqoxhP +DDsejoguSaYGHCZks/UpKFnxFQJHyYdae3uzrchVh+KRCCvMqcVJpbTA029qqmeRMCXZqyMeQ0Q8 +KmHX02GCjBAvKRLLjx8/TpXpnSW/fi3vDHNfC5KBoED168JRWgfR8SGvfzrztbS+no7gUH0jOApl +zEQUyGvBUQoD26RX4wfndg1HX004/zn5+lFvqBi8/NT5ibI/msTSIWxQ4BPkYy6H/Fdz8I6WNQDJ +R5YJ+M4zFruDjuTwPR4eHuZi2rRpzHCwop1ZFvwq2KYsExhNAZVCQ+m8LD9OTc4Uihl2UwYCY8Yn +Zkxt6uvLRTmqSmZEuSFauv2q1U891L92NUcuK1ND/2BFGGhbSBGWiLUdXJM4BYvZwmy6FK8LdXTF +mYSdOpNdNkG8wcMD7KZQmTET4g0tYeg4QbeKmGElSZMSMikdmL1jC2h97SUrnpwz8NdfLvvSxbMH +e4XDQON3PjkP/Q99WhFCyPMkTU3q7dEmtmsvWemoAxinhgtDAwUcuQTonzRDUevQ78apAI+E8naD +jFtkOBKAkVhs4AFKH1jl8UOe02woAeoz4+tjAtWHAgtEE4JVT4IHs/YI6sSFwJ7KBhgSlzVKQMJI +oSMU6KIIR52yWFeFytijfblCTtUNDlmv6xSgrJ4aEHINPX3kCnk5QcNRaFS6xt2RKzVq1jArnryW +A6TXIwsJqKdV29Q6WyHkK7BAPoNV0Xd01BfBKtr2X12bUUvvHESdRV0bbHNRnwg31kXXDfL9UAcK +mJA2PuBd3VEuRr9l8kARhkU2Bh5Z5I0nnxlocDEaDbHVirx8rkSLfIyFAxlsXJzztrgM/zB0GJXA +kVYLc/JaORVjF5cO1qul1y0BwB7v9OuuVqtQk8CrSICf7QaLwYuJwGQJrhvWy4Gj7m7iN3/vvfeS +z91X4aGSDeL69jgm8N2jwgwE0ahfUotZHBays2b9wgsvZBqDaf/q+BfkBv/yhaFCqZ9ahXy+d0gR +akgYColoLF/OVhXxvMcHbr1q1c77dXzhJ7P+ccO6v/xsOVoVuwATkFTCQ4fWKgSG+yo+QzxoTW2h +SDQIzmWy+eZwZNXyPCeE41NtaAol1aC0vCBtRNfTY8wvX6cqmvhRLWpSa0fk+M9MPvvk54YHCz2r +Mu1dAtuJ0+s+8rVNuYANmVZcjSS0bVsnBmPy7ceMfduh2oyB3he3JfbqBLOZ0qql6bETZImibwVp +xgCi0AVgo+6YynUsARUs8hE6mi06wiHgxOL1UxfKbBASAauIzergCvIZMpgr2O6asSXAExCi59kQ +EmqOFCaEyg1yGJc5DcAGNiBqgZN5cjwIkQ0qpBHhL8SSYb/Y9AsYtS7Aj0pC1nIq8lSWktriJtSo +BZN89JeJRTepDk3KmzRYYM2D8HN1qKJMBgAApBWgOJwgCvWC+PJIw5Zn02uK+XcWMObZVeuKPVAc +oQHSbL0tlgeGc6oOZNr6aiGmQTjEuYC4qnMboGVpN1uqgoSALsUismLJhEgqix/AHxwGqM5c08Qp +39tIpD4e6RvWkWrKUWHxTcRovibEpgwE9Nw9Uea1+3hHKv2H/q0u0P0P7X+t2/8HErAf+oagi6OD +NQW+2ohTiNkMg23KQji2MLNAwNf4vbwdAnexKIl1Dfvb5CjLAYgRChhPmzaNiGjYoMQfAYzZnU1d +Nroxz8/eMlYYscEGU9VXzbEFm7tXXnklSw0L5dX5ooK3MVuVG4nkxMB/SfcA+t0V8tBAYIXt4yeY +0dxHkg/dpW1zPauzLMptbo6MGR9j8c6CZ4YXPVd86h9hwjKQ5j8W6FkR3GFPbdq7/a+rVi7N3nK5 +ljXuvH8bnluHPjQm+lD/9UfqHl2MdeJLeICXG/+08rlHBvAwP3RnPziKQ3jMuNj02Y0d42JLn0/d +esXqNUtTi54beuiOXkDEgUSEAoFd9mtHhbIo96G7etmZ88T9/bij0Zs7mkP4b79aueDZ4RULUwue +G4aTyZtpbe5zjw11r8AsN45Q4kzZWrx1KDNcwFaGW10jKDuTXMYrBlNCISZQ2uAEoKXRgFnVlFN5 +Omhdk+EFoqDbASFtr62vD05PBGZFQk3aZqQxCeOGEiZavpDO5IbgSngWCRBit65J+Ccko/WRIYMA +wp+NQZ01ohxvVEUtqVEv5jI2HsihPKTED4xZSRggU43apGmlALdAIwrz3y6gT6p2jQtVAU2x94wJ +CPqgAYLcpaIGZ2aFU5LEZHBWC5Mt/oa1TbHRzw5ZCTKtCsffQgAchXiVMl8MCtAV/kHTzNByY10D +fFAmlSmUtRGG+dFggnXAOjJG3Gsy1s6H4Z5u11JNAjUJvHkS4CfIKScj+uyN8cEeGFYosGiIYGP4 +ZnHzYmiyTO6kk05iTuLV9lN//vOfp1lwEYctsbtYnctHHMKXXXbZWWedxfYYEjYuO8FZdsRyQYKc +8Y42YdXAaaedRknKg6xMr7JFmsBpP/39h3xelr5l2feAdYR5SZwb9BHqx1Tn03MC6aGmlrbGx+/v +nffE4P7vGLtqcfqua7u33b116qz6A98x7u9/WvWbby/YYttNOjq7XC0unheGyAHvHs/x4P+8s/ef +d/QRsYGNoUe+X/NVbIkh0SLGotSaqVQsOdeqmke0Ccs5N6/z2Vasyc22a9r3qDFEaYD+SWdNu+rX +y++6ppsXhu+mWzcyLWo0KggxZVbDcZ+afP2lq6782XJI1TeGsVCZXj3y+AlUf+jO3l+euxAFu/vb +O2Zs3ThpWt0Oe7cS3uFbn3j+Kz/forExClgCD7AhJIAuUJFR8H0AlUxcuL4DB9TUdCkoiE3GQph6 +2awgAcmF4AAAEVGzzHA5Fi+PC4fGAgGBIAjKSz52zt+xf9lkpg8wAiEYcDS1KnQUpNxEEyIgKkM7 +XVQ6LAFySb7SCEYo02TrTQucoAN2usk4Ut6fr5izJNiDBuaj7bfRk+GW0aFbuhwpSUNigHeMdduN +hWRglSEFSahpnDhBgBN+eNEcnnOZsNw1DHYi3iiFhZHWL8RIGQI0pbPFZK4IorJhlwI8bkQGnURM +F5zrneHA+TAbScNAbIYnBwV3MluUQSZNzV/ArxbqmryopZoEahJ40yXAz5wVvKfce8m5G4QVMAz4 +xGpkihR7EfjEPGWmk/dXs0rX3y5LDVkdB0KP9g/7IiYPgUZ1jcktsb6XNb3d2V8uWTsnl2f0jj3B +7otyU310aDhfihCiobhmWWD+EyEOmmbyCtVWLBYmzQztsF+5ubHcvbJQ14JHTZq0d03omYcLmeFY +VZmi0eqaylvumh8/jaPCy31r8i2dkWhc6y1xk6ZT0ras0AGcUKy8UHRAKQ5SVDN6U9oWxR0sDw0W +BtcVxk6Mc1qIgZSKecpnSoMDhda2qI53riaUuFk5aHZ6xPwobNc1RLDwCOwDTdQ6tjULgFs7IzrY +nOJ4ZWVictZlKd4QoWkUMrO5RGgisaOUOWBm5kBNAvRjIGWThgRaNhUgDC/dT2FGhgNNxBANBVID +gfzCdx5x7JZ0ELZQ+jDM96aUo/32WKgrFKxnTYxcrYKEIt8BQDSXI7RqbijVkytm6AGObl+vS3XJ +wXDIBFJBGkGRwZgoO3qNGH8uCSoKzyxVxigMA+18HsrjsCVTcGX4aoadEJRMUYZtwy0uXLLeNC1C +E1nxTn9JPH1K0H3Nc/P94amZpai+O5Cbm5rNsnzkhXzsayYKPGgKS0RWl3yaVutWEt5BRIrn7Yun +bwV+ZoJYUom6DGsiRDJSRGLiWxLVKBELD7OMGLHSC4scqaW+OAD4MpWJ25Uohwrl/KRYYCrLghhZ +agWWJXWjlmoSqEng9Ujgja/gPegjZ1s8ldfT6nrKgpe+4MhPkOfnDZqSXu8iwGoTGJ0sEKh+9ItX +W00HuObyAPkKYqSjmHGPZXNlsIGlHRriWyyFVcvC6VQ5EmdPgUwjPJ2FHAECC8Q2ihBa1U5oATx6 +VjMzlQBaBKWOeKbok0OAYgGbsn0CHlJpf2EI6GK+XNgD2GTu2EcULr5OABMvKBfoQGa4mpqi9Y2c +3axiKFnAQMqXa5yrsVDHGKxCJYcEXfh6IkMvijY0R0BK0896R88KY8JBXMRoc1pHLzvDUKurD5Fj +DMlPq5IgR1FgSaP4ckERFjgDGH40qbiyu7QL0HLNLQ95KCQwJDP4iIUL7YFSeyRcb/qdPSAggv7J +qWtQylsyvU44Sh8tDgOyBeqozkv880fdM4iqXIpVmc5V97KXtsIuEDK03MnKGxVRI3kO1/TR+VSm +E+fdSqhFMamPQj75KvQxZpY39JWFBNyPbW55SFVdNuRTBhlUzHSnTzGI82TBUWjZ96HSBq0AxlYM +lAPp2Oqib4d/Yahky8OhFrPqCg0xUpNC6bydt2C34IubjA15USwRjeSKBVCYLw8NMIIBQ+GilmoS +qEngTZTAaAtoA7ABapKwDjcArddDwg3TdGFpQzy3Ds0GgrEMViN+zWOxjIhYCsPrIlhggGu0DLSa +4sNBhx2QCw0ni5F4MN5QLqYDg33hTDLMSaVmAEi9Sc8aQAoNcco5Upo1Q74sTpbtYIyydjcx4kE1 +09AxVVoa3S2jBF+nlsCg+dDm+mxI52ind5JlSjVyMZIDJ2C2AZb4IRstOlp9okuFAUCpeZWpqxU0 +poKhBIwJaEdAAjrik3k4i5IYb6xEQYJbX8SrGdM6bUV180sSMI8uu1Ijgc5QsSMUrCuFaQz7S1yx +pRXXpOEoBmkBizSVXpstaAspDTE/CpqCygjBmYZb9cWgDlbVUclIdqQyubQRhpeBfz6qkCVo6nGM +wCR5PBHu+jPiIwBGklMXUUPTHh9isa+C3bIyECdBTcRhRjs79QQrK5NFQlVE1vuovuoodf5ozCFM +tKYpaQWoqKatRe7lsSaRuVmoLDTK562Lxhtv1OWzENDWIhE4i3W5Ofa9SJKVWjguGCnxlSEHY1Rn +nhpBM+r5WgOh3K0kVaNxUaylmgRqEtjYEuCX5/bOxm54A7bnIOrvufLKZK6XmDAhbM5iBAyNRfFg +hlOcqpYppZJsbS/H6qT5hEwoKpQUB3tJKaJJWaeEc6+cSkmhof0r2tn0LEpLWhRHIspXmtCcgY4B +VoAcLDkZc4CoWScgk1urMhbRmSAZhcyyUfcNG2Q1mkInnwICG09+obZkzqInHSalrE2/o1Wl0IEc +aWUVEE+0AsBb4AXuYnT6DlFGD5TnI+5cCIsrdubYKiQc1BxEDYLi/kXvMyygBL2AoM594xN7ZmS+ +k8cy4nGhSD3KH/nBK4MU3MhIHhufS9mjwtEM9mi2kKYVls40tMjLioEr3qgEbknjG7eGRrpy2wv5 +wJx1VplW0qqZ0CRBZWotrnKtpP9FIP4gzBkLcQdmYSctWj26LxnSfUdHQ1mjIbHQca3DQob0jY82 +FcpdMWz1GYXwV0/HfMLuDGCwIk74b+AHZTVnDUHQ83UfSRKs0p4yFSmm7ltb0NcF3cd+ZTbfClOS +XATlwq2LxbBBceKyBF3oyYiopPW9GLrFUq4qJNWqpZoEahJ4kySAGtxgm2HelC7QAW/XobQ/tWDV +2vSkjs5cNtc3WIzGs+iagYw2thNyp5QPRqK23cW8uzp0rRwEZjCnUFUM8zOpYDKJ3tfwH/RA0ylZ +CyhHMlnzoQ03KD3dKgOWXgYFKnyy4ADAFQk96wgqm9U0LBRkKULZCqA3zd+nwrJT0bDc8kQBs9X0 +yTJhQU24CuauqW8fDYCdVtxMIjNJ1QLmHbv77SxVKFDRAQM5ALRKbFi08+PSwwFi+gt9owrxw7s4 +ZzI1J98vB3U0hMawHro5sm0olBCT8lmixNH2QgGmRtUaS1g1SVrK5lKEYshzYkBI56ZxBKmgiNbg +XEBh1wZmyh4Fb9BVHw1UyEcynlTdbllNE514UAH6oguqmfS44KMenCWfLgWbVYxMgy7xr0ICML+g +rPDV2lVXLEKFI6JXgagLE2yT1Bl+menMs4YCVSDlnIgRG6moOlxbN+EHS5ek5mjZ+gIFvi1OLR4D +FnWp0QxfQtGr9ILA/1yyaJeF6OBnvpiXw8d5NYYZzPh3SaQt8UxqhumIMGp/axLYeBLgdzeyMGPj +NbrhW5JW19RXdji3kCUbBP0eAsEipWiRbaAEAdfdYIBZ01AoXAJCShZhQEqnzNKbMs5MgSL+SsxJ +0862kkMHxZALbXKphfrDXSly5ilFAeLUlefQPLdSrHw0N6D3kNooQwq73mSDqfQ8baJkRbgCgeRx +LXXvaQRHxR03uAsDqFheZlkKPEhgmnkjHaFhDzYAb9Q0qhwbC4IAJIESaF23GEkwGgBr7SRzFcOW +stPfoKflOYYoYGdyUIuScGK3JSaNa96jJb7Ho4F7YrEG4sgiMYjDjnkW2f3IdhftGrGLYjafwh5l +shUDt74pUM+5aSOCEoY522Jc/VUPRnXQ4VDCAYfMuPQLckAjGuXlcTBcai4uyoiciYhawkg+iEMl +MtSWfXBqKmI+UjK5JkHW4U2Ax3y2yZALUbYkUKewYbBcCFBz25fvm9mvrFTyIZRcym4QU8QuhLtM +pmqaU7VolO8XcqAKAwuxhCcjEqIUk/XV5y9+SHa8QX2Cs1ZDpWyJc1nT+XykWIRDVsxFbFeMLZ3T +18W//zUQrTyz2p+aBDa6BPjJAz3VX/FGb/8NN+hKhHc8jQSKDwQG2UWwqn+QyVBhXiGUSReZAU2X +WMcbWxPOMAuI/iqw7gZQQb9F8EASMIgr+Sw58TuAZRYkZk+A6SvUJpl6mc4FcRsaZLnQUl1MsZCk +JV1v+iQfHl2bOkWnaz4VjWkThNL7ZjmpbSlVESTHFKxyDGOVU00CBsuwv6Z2DVHIFGWA33zIIusf +TTVj2WBQcjdkU9U+fYuXVaQMPHjH6FSPzGPsnkx0N95sEtJg9rSUT7RGJo9r3q21cYdErJXlS9xi +zwaRjAxHoIU5jxo3jy5bR3Hvyh4dTGX7gbxEnRbranK0Mk1ocCXySogC6QnJzFgUvo6AJZmOmrpr +Jp2Ly2tJOFZLHUF0XsBo6s3q6kI4JMHxhvyRnnwDJminSeskiGBd0/EKslIPsm6SYmhC38YfLnyq +cBc66pEtRFILRscfE7cgaBBo+QaZYtgeCmW4lBDNnhZjDIlskp5a7DF1JAYjwUQNd5AMVUOh+mgw +EgoOpTOE3qUBkBKblONikDfPAsc6T0AoWrNE9UhrqSaBN1MC/AxHtmK8mWz8L9uGe2pKl1hK5Vfm +iwTWITJDAM0fLAa1MjcabIiWsReTClxXjiW0dpeZJvabUqSprdzSKY8sR6eh/VFZKLRIvBwv4O+V +OpbepwkzWZpai1HWJRWDrPkkMcUo9WeIKLWJ8kVFykhjX6DUJTq0DG6ZakaNOiRXuirNqqQOSOWK +jpLl82Y9UxVPzgnzmiwgorAYtnh+QD6F1RDAb2BQ1f7APGiB+xqusDJZtcuQSauNyIZng3nBDDhK +JjtkMmzUSDRHNh3bsXdjYpu6uga21sSwfuiYOCTyq7XBeujKMl2m8Ap5QrAX85ncQCafwlHZ0KjJ +Ua0HpnWYNv8qgMGlMylSZrFJXEbXRYC4JGoDS+8IdSlJEpIZ5ukpwLbyrK4hk+RvK6pezLcqZIJJ +Dn5eno88aaw/UWUsYIMS3UJ68qQqh01NcI7EeJEpzo15HqJEYCypIWvMuYU94Z+MRbHqiOtkaQgK +fEmQOcTxHPCd4zvGSEQuipDmFLhBoGLagjE+GWW5eVmQTVykbK5YQqrRSKbIWYGslcNrTwwNvn/y +BOjrp8dcSzUJ1CTwJksgmykQvuzf+9cIjCJF3jP5HtaPstAGBxpImbagMp1N8ZZEdGH/ECeVyLRC +rWFQ5qgSjNSVO8bnm1uDubRmP0EpJg5xjWLGMe2HFkaBBrUnJAQ+JupKbWMKRBsXbJUDGZDJ7Cop +WbVuy2FMq2L2uR4XW6a7pShR1pa8lvJfLnXX8lZMN/lv1Xk+kEIdA5yeLTPINL4enYEQOMFd8imp +AYFhecD2uYKRWWxNRQaWZNxyhQ42K4U1Vcw2oVWxeGHGjCmHtzZtTgDYukQkFo9GosRnjjieASRE +X9DyIpsUBUL5B45mcsPgKNjKQIQIDPF6gxNscSTt1hUMmlkm1gViuiUhGi5qRhNrz+AQ9IIhCa2a +jAKcC9sMh7gj8xGcM5BTFYNAz0HsyjdBIRkqujToKbckKxOj+kIZ6jIiMSsQIoI9gNBWXUFNT98g +nDJ6uI7lAB81/VFaJhXhH2lTV3ufbOpUrbj8uTA+qQR9itFTZ5V3wtcDqAhVu341XFF1ScikBDv5 +Uqipvm4ww8EzsIVzWFGRiHZEEIdYLIT3hRriCP5qqSaBmgTeVAlk0oW3zgreZHZNViAZA03RU2jD +xsbwrtNnPDh/Ke5acDSaYHNMkBizgSQLUstNreXmDvYYBAp4dM0hiU7C2ZvPlLOEngEjMQFZ6Zot +1seD7Z2lxlZhGxSyWS2wROOBo+hoLFFX00zmAWOoaDQmRgbUpI5NR7s6NgNPD9xNH7+ofAEtO29T +AAAgAElEQVRMm6uKOyStTLUAet/BQFCBs9GwihzX3Vir4Dds8FGzuYZJzOTJRA4EMuAoXUkwGhBC +8JEEhHC3sT7aFBn//NPB3hWNs2bu0do0q7kFcyiUwCAlRB1dYauUIZBBGI7cogUxymURtMA0mSsM +ACLERWpqt4APCM2gToBhVhqgAhlHFN2CED0F5yBrJcly7NC70EFykxApYGLkEzlCUC9p5qZqmymp +ezhXDcwoAHxSlwuro+GOr/pxuGEkISwUE7qQo9hKClUJP8QxPvzllrPnD9HAj3yBq7UlAiMWqppD +mKyURtTwRD5fDBsr6No5sfIU4z6JkhpAqLfGg3Gq+X1xbIkNoxysVijhECAKA/hJ31ltBFl28XJB +RjbPml4OTii6lQ6a1iZKK9Kr/alJ4M2QAL/Bf1cHL6x7Qm5c8B6ODNixHOVEVJtAQrEyxhUzmr3J +wWi4nA2X6xtZa+pqM5hoyDc1o50CyZRqB23BjsxZwCBcTNRFMiy9iQIe2KXB1s58S4fUO5saCB8o +MDA9KEWs1ivQiOLGNERXspwHlcpH1VEJaW2u+SScc51KvtGpmKemSh16uSNtjn05Etcef6yMIcdR +sJa9rRbcB/0OiGrvCowRcI4QEz7faRYqFNjdCHuEj4cX2aNYePDAWqR8Y2tkamdip47GncNTVt+z +5MZcvg/7cnw9/ZTaruAogtGYAn6AUW0YxRQ1HC1ksgOZHJOjRYxRnLokFTQUEZYYfsAVL0dTYaSZ +g959bCrJbWQ+lfJ6hOAWVyQkZjmgCICEoFj+42Ln3eVHeT04t1a5ALztBuV1YagG1FERmZCjArSA +GYowwUvbNeStOXYK3a1pGlB56Ns71fwWzZFoUc/dQdpWFQnUucXzRWojOCrKI9eOqeQw2IKUy0c8 +iCHbh6P5Tw0k4A24jIVDGSSN75zpBP+SMFcQDisiUpE4+GzpxTdcBFlHO3j9V1DDVD2kWqpJYKNL +4N8VSquCckBVmLwiMQHCDc3h5FABk4qpu/6hzCMvzEcdY4qhg0CUcKSETQn8NDSyfEOhaKW8KJDT +olPUPQgarwMshR+cd8ZhM8Gg0ALLL5NmzjXIVCtzgQ4K0vKkEQ2OykZLoqxRmphzrOIhSf2iJt1A +MS2PcqygAbdG0FQa016ob1fcgKWckNSXVpbaVXOGMTJrwM6sGWHEVSCIrm1fITAG57hBAbLCLWAj +RIAk+Q/Z8ZLDPC0EWhIT25u2b0ls35CYHA0nwrHyjrt1LFr8BAEaB3rXBabNiESjRHQCdjW8YFU0 +gxFgmN1FOf7zL88518nUunxpmPVcOMNZyQVXzjOcqnfe6+q1ARu9cJgR/lkZFXP0gl8DSMCYCwAJ +PiuSsV5DloICNu5a3wVI0EfIhrL4AOgjA4Vq2xSDK3KgRjGkKOS2pqkIKQGqkYUrynDUuU4oN569 +L3pwJna+P16dj0bVPpqPXVANh1AQBFLZ6vg7hcWi5RurENF3w/quwpizhDqKsrNIkEpi6w5k9LBK +Rb5L7HKmsNimum14ZQG1lk2XyzoDnFnUCCuCvarVr73VJFCTwJsngX9vKPWROO/FYraQy3a1NHJ8 +ZF/funC0BHhoUF/iAn2GSiKKoRbrouDax8RTyewA+ylNBQM5OHhRXsT3QTMl6nUSR7A52NCIKSa1 +i3ZjkyWIRZJrl8XBqEIL0MoFLzlgfUkwihUbCCoOq1xgTpn9IeXpXryR94rK5cYIotCWHJIsTgFH +AQArybAAjOEVtOVO1ALoaAIFLDaAFrumL9QFPHC3ktwABecollobaE50NETGtjVvM6Zpp6b6yZEE +TBN5qcRK0aam5u222+mO229eu7YvnUo3NcXLrCeSjVkGNgmDDLV0JiMozeTSmcFUurccyrHXpaFV +AgT2quocECJHiGUgB/+CMcMw8kmVWywIMhNWWepu5b16oc9I0iYXq6ipckjSCkMZgt4W18Jd2tX4 +58UWraC9WUW9GQzDAxUdL/VojAGWZSlBx4pJ8rBtj94vdNefI/YoXXYQxZTEErWu6f6IGQoRZFKV +hjenjlDA3v2Wxl6iq8QFHWptrOvVkWolfaNgxqSnMnrWds6afBUs5ZUFa1/+quyNSu2tJoGaBN4M +CfBj3MCBAzdyL+iAB9zJFzPZ4kBjIjYwyJlXGqxjAdTFiK8rhRO2yTrW3XCnIR7jDMieviwrbgqc +Tl1iSarysedQkZSRcioFmVnUjg5wBP1LUED51OQ8C0YUCAkkgKxAFBPKZuBkSFnAI1BQhXmZfjQV +qSsuyFEtM5KUz2cSutVUKoobW5NyrEYhExvF1SRtAeS0RUWsT5a3CPhZ3ETTZneKsplWEOOINGrj +ZEZlUziV4rDzzrGNW41v37WtcRbnCxAzh8PdIuz7kdFEC5p7mzV79kMP39/dvWpdL0cCxNPZFFOh +GPrg6NDQIGQzaezRbDrTm8r1R+pKRLpHCKo/osklGZDG/MkvQoshnFy73lN6RGfhT523jvMOBYDN +5ECPKkLwiiY07guEKEk9a0VLrkmU4ZbDtpWBGYTPuxujFFFz5nTVaAMRIVVGJDwvkNJE7XBloy7j +CqEZiNKQd42SvEjkwCps0Efok+CWj0hRt3iNSuoTOfbIqAWTpKpYKCwGqFRiykCbYWASERDCXoVt +XxenmhK6UmfFGPBThdEdnncqKcaUzn/lIdK2W+Ivtk2Fmo/3RXHUrmoS2CgS4Ef3b2mVSsOMpBFB +5SLRQndfZmjYoqmZZ489kb1DRY5FQyVFEuYMKwXqY8GFS1LBeICteSgn1BwWSSSm0EWCKGw7li7p +fGbcwrhzyyEA2Ba7YkOg0SKKPo4+tZVHKFZTlFKkml2UgsY2EqwatgkATOMLNTGkeDOdy4X9lT61 +ItYJgNmQRUrWNC/VwVEQkXKoTa41BxwKeIRjAhLBJIVp1JU1y4/pS3ZYdBqirZHojHGdO3W2bduQ +6IwRrD9OsCdO70Ih4yAEQalKRTkMW1tap03f9MnHH1u2eHFzU0uOVaOZLI5cToQdHBCUDg/3cVxa +MJJu7tAyXfQ7tfE6qoPIwy5EznvFxYglSgauZs/XNS+z9vyagn5LkrFb+sgVny2JPvm6Zxe8+0AE +8SIQ8rHSCM8EWtsyXbCGcQzvPEctBYKSbYmBQoWwYaHQ0XHRKOCNcIYlkhGbFT6h4zgKHVGwoYwu +bAj1IjTaw1Jjxh4tvpgcaO2OYJvWjRN+dti1PFAy1RDPF99upIyUoVHHwQrRUL6cswCBWkxOsVC0 +zPYjKDN/H48LVfn1aiMqDxv6UEE25NZSTQI1CWx8CTCO3/iNbtgWbRSPRsTwDCWZ2JM2AR9kX/75 +Vwu7V+SO++QMAsk+OafviTm9ex4yZsedWtFZlAGisAZkH5TLgBDKVyN8udEUyo21wKuWZnp7MlNn +1TW1xiEKEVAHbQWOSiGaCtMiI1vvw2SqoA4SMixkNUKwAglwZ/qXj2HT3ZKAo4cY/x/6mgy1ZdYV +2lZ4gL2SEG9M5nFLx4gC82mZR7QioMWctRW5SSA/E26Id41t237yuL0aEzPi0TrMUDzDMQuQIzhl +9MAYAjalxIuhYrhE5NxSfsaMmY898vCSJYvax3Tg9eWEnWQqnRzK9vd1s5ppKL061iBjFI+xb2mF +AgkeSPAjEDHY4L1ybXIQfgB7bo+6PxPkoHVpfsMn5AC4kkUZhxaDHKOiutUmHLa9IuMeqCAfBPVi +GfsuA3XAEu9QULvWll8IpM31zTu1oMB7alAPzpNQkBZtHECOt6ULqwgnUIMUrfMuCiN0qhcVsrpj +nTJScE5ZB1FIiQhNW8fJVEKMpcBgoYBVzabkeJwTYHQAQ0wBGcQGIiTgUdYYjXHUkixZvvjCYB9S +1kDU5Fh7q0ngzZEAP/wNecganejvH7ztrjnpUjSXL8ai4Xg59/YDdm9ttSWe/7OP++6779y5cx98 +8MEpU6b8zzuv9ZOPxL10qRTk9DQmOW3ne4CFySigZx4eWL08XSxNJ1zDysWZp//Zv/kOLf1Dsj1M +9QAlGJflRKP0uOVKu6LXWNGDrnz20f47r17z7o9O2n6vuKpAlYB8Iz5ANCLWJ9ocLUlh1Df2EGCA +y1czWRW29Gf5wvSPvzS/kvM//xzwrrEHvWusEdcN9CrUFH1pZIsFnLDKCco+U0s4BfqFLxqTFJ0b +Rcmigoe0RKW5oT0em9jZue2kzj3qEl3gHx5spocjYcVliOAOZH+LVhWDBHqnv5yPWSwXOB6dVUUN +DQ11dfXLly9v7+xsamge6B0cTg/29C5YN/j87OkHNXV6TKgK6lSwwUERbICejRWUzzX94ZbZfwI2 +k63Ea71TYUtemAJAAoioKnaLfA0zYA8sNLQTylpdIYdfVFukpKERtUgICjTiGtCR792BCqiCPSq6 +lWkWrT6zlod9U0QqtoZ4V55BlzdDebFn3RFumbELMy/iqGGkkVbrzj911Vd9kyxV/limSUloajDv +PHNNEocWJglLtBQsZvIKHK1dpBqslHRGm9WSUyFEjKQCPy6MUmug9laTQE0Cb7IE+NHLQNtQqa+v +7+vn/3HKrkccdsBWhA8dTpeuufGJr573h2986f3Vk7o3SFsf+9jHbrzxxltvvXXy5MkAKuNzJvzq +Y4l0IZjG7YkBB0QwD2qNoVE5QsU0rbQnO/VkfICXnFFK/COb88OaBBcv//Fi0PfT52ze1BFHue9+ +UOd2e7S2d0XRfUI5VDQuPoiZC1GZIKubFyNLgdS2LUVhck5+OZv8GzMhfvq3Z7revOTCJb1rciee +NbWpncoEfCcMglSzJ01cu1VnnyEujBHX2tBCf7CAAVFwAi8uQYULwQCrgvLJWGNs1jZT3sWi3ESs +hS2koEg0HjdvrhAUvoVJIGhZIF8uaTa5KARlfZFWFg0nMUGHGxqaly5dsnTh0rb2jnX9i9YNzC/H +143bTAusMIVlk9liHxgWZvByYw6qVRQk064pKWTi46hEpsRFpmOJQZp2WPI1rN6yTMqQI/oW70L+ +A0Tk9qINXARvyNkMei7FEnAL+gI8hsSIlHyBtL2rEaui1oGxijfCdtkagjroUsZKVZjmCVIcbhE4 +9GUK+ju5uqHEyECd8g//870ilpEH6mVU1ccWBqsVVKZdzeiLGpPU+YHK4IzNXc6RXLlMyuMJ0QCI +8SJbm4phDFX1p5ZqEqhJ4M2WAA7e0brjjbADnl3511uubHvve1pab31hkAWj65KFNV2bXNVxzDZX +3nzyye+181ZeuYUTTjhhwYIFv/zlL7/61a/Omzfv6KOPPvfcc73o1Vdf/ac//emRRx5pbm4++eST +TzvtNIrdfPPNTOV94AMfOPTQQz/3uc/ddtttl172+2efeyIaK2+6Ves7Tpoar2MnaaUtFHGC6Apm +KXIaDMP65x7pv//WnpWLUyzA2WzbxiNPmIjB9sDNPc8+MkCYpN9cuGD2Ti2HHz/hqQf759yy9pD3 +jZu1dSu2zuJ5wzddvnrVkjTEZ23T+PZjx7e0EsE48LvvLFq3Onfc6ZOv//3KNcsz2+zeduQHJ6ht +tBx4gIqMhro2qZPStOWX3OmamGjtiqE92drwoy/NJ5DtJ87dtKFBQW7vvLbnuUcGT/3q9PtvWHf/ +Lev2O6rrhWeH5j0+1NIWPfK4iZNmNEDyhSeHbrt69bruTFNLbLe9Zu2w7V5t9dvUhac0N7dGFIwi +GmG1spCUUFZlt0TBUQxo0MlAlC0VeHULmXQml02lhpKDyeH+/v66RH2hkF2++tn+dLEQ7W3eJDtx +uuIS5+cbVMC99LjASTPsIJD1iF6QWfkWmeIHtuU9thk+IYCJQjqfKxsZkKFkaKcLbvFmkKNRjuGK +/voIw6COtrygGLB1Q3x0hLMaIq4z2qilsz9DABIsUQs4xHtPSYGlGcqOshTTQjObT+Wal1U2Zqw7 +cK58CI/CUShUwUusjkqVfOfGRwx+LT5UzrtgV7K21U0bcHAX85K74hgmGTHQNZtJZS8Wvn18Icws +hAXa/A9ploFZfs3NW+hBxFjhfhQ3tcuaBGoS2KgSYFqsqhveWMPsKb/mlqXFaOOCntI9y4K3Lwny +zjU519yyhLvrIb906VKg9JRTTtliiy3q6+t/9atfPfroo5Rfu3btmWeemUqlrrzyym9+85tbbrkl +mfvss8/UqVO5+OhHP3rkkUeiR5LJ5C677PyVb++7xwFjHrh9zZzbVsdxfaKUTIVJh5ZxkZHhuogT +SYszt276wOkzdnhb+wO39T5w+7rGhsCmWzV1jCWefeBth3dts0sr+yrTw8W1q7K8o6lWLk3/4pwF +fT25Iz44ads9Wh++u+8PFy5C03GLzLWrs5f9YMn4KYQJCs+5ee3S5xVSiAbRj6g8+VPNSEU/VhP8 +kM/BIGMnxtcsyz4xh/B7RC4s3fW37k23bipkgkMDxXWrszdevoolQptMr1+9LHPNH1YQJHbxM6nL +frIoFIzstf/mgWL8luueLWZay4F0vjjciI8WP219fTQhHEVfO47SKIfeoIJhQFHoiwU2t6SGh1PJ +4d61fT19Pd3d3WtX96WSfYF4bya8PNyyasY22RnbBDgV3ByMQhQsXZehAEYiFUAIHqx3JmkV84Tk +eVU0vF07kKiYgStioTTlVZI/hlu6tsekR+bEHVwMdLmrTHKw5/RIDR25gBNbgkSmXmbY4el1M9rh +CtmS6D5NUR4KhNFgt7E4NF9r1SevrtkQAVpQww0gJnmOBqLOg2iRvD2/Hv1OfjV53+2jKHuCIoli +SIDW7RM4KsbkLaiwRCk5ITK2Zpv1gZzwp++vKrMqTpzzSUJ2ckal9laTQE0Cb4YE+PmONhPeEAuc +V7mkNzKus22TrlA8IaOoOV/MZvLLsqUlfRHuxjnBa73p/PPP33vvvTs7O7nADN1hhx2GhobAUSbw +SIcddphtpwvMnDmzo6MDSnvttdekSZPYPHrEEUcA1XPX/mDn7Opr/7j8+ScHTjpl1qJcsqJkME1y +2ipKFTrMctxtdm1XgECWdgRLt1+1ev4TQ0e9d3xLZ6KuUdKYuU1T25g45qmKo7h5C5bn3LoW/bvL +AR1b7dIa3r117mODy15IL34+OW3zRunEQOC/Tpq42bZNDU1rbrlizZL5yUnT64uAqOrLhoOuZlJH +oJQcKmFdQXvHfdofvbf/4Tt6d9y7/dH7+vK58k57d6hNI7vj29rfdvA4eLj47LndKzPFwTHPP9JD +tT12O7g+0bJqzP19fc/NnfdU1/h9k+lhTE/8uYQq0jaJUQkQZf8EWEroBQzSTDqVwqGbSQ0NDw4y +ud2f6l23trv32YHM/HHTU2OnBBrbtFcVJY73G3McroEBnIuwVHkZcUmU/BH8c2wgx8HB+de7YRJ/ +ueNwwjXI5HjJBZuRwCpRG+FalyAMf7ykVaS6KuLj1FM0lqgFAzYzKvq2m8jXf1GGkQQIyoWvk/Lm +WIxGeWIEJvGQW4uqPvJcKAzD0KQwF7w7HS+pkcQIh+KM6sbk6DzljyrFLWvEs0XZq6iMCZO7PFxY +pSFdANg2yHBu4Y2vDewRYKQuQfx6ISiDXxExs1UOX0t8vWsrjypSrv2pSWDjS2ADruDFwTu+LRdv +bpzeVupsCTXHmfUJ9g2FV/QX0+1ZLTf8VwnspAhWKe+OfNOmTcMY/da3vnXqqafOmjXrnHPOwSSt +kqmOx++5557f/OY3Tz71WFTLgzRYxwtISHoviVNMV/yRXmanaXDuk/0P3ta99IUkmy7JROEOJQnJ +7sX1ztkbOU5pq6gp1ertlr8YgCSiPZp84rS6npXZvjW56ZtVtOukqfV0MWYEXQtXNCx/PF65QQ63 +lAwA+EsLM7ZuaOuKLnk+tXZF5r4b1u68LzBv07um3+sbY6k0M4aJCRPGDPSuqCvsn0leQ8Xrr7sO +1ckwIhqNsmUF5To0MMgRLZEG1pExRpBrFwuHd8lDy0EtaC5B/7I5yg+lBvXelxwYXLu6+/m+wRfC +zesmbBHoGCddD/YU2clKHCWtfBG/6HSSC0QYYBhGz9Hybq3q8ZqdKteuylLHJGNqX1eOFjwYs/C8 +AHKgvPADZDX5U5eXz2zLiLRQFUJEKynpIX3jxHmQq1m0NS6peGuRNwK3EH2qZYUh7rPO8MmAJjVk +qMYXwzaJqkdQcYQWPSW/VYFPbtNBM0x1j/J0hwvrsjJU/xUSZbjj7y/eHpGMd4d8CtAQ4uWlTBOI +cnnRMk2z0jgdiEdLfMFYbsR0Kct4xYYH832RtH44NUwdJY/aZU0CG0MC/GxHjv54w80xFXrALo33 +L5+749u2bLatICxnLbQG/nbr0wfs3LyeidL1t/yhD32IqVOQ8sILL2S10eOPPw54eBUsURRHJpM5 +44wzmpqafnf52d35qz/17ocAkYFBXKymh0wnEk+g8sHOCLvip4vqG8NnfXdLdPT5n3qKeynbZ+KF +tNGSWqZYaQgzCK3d3Koo+N0r05vv2MiqWnCUW80d8iM7ZVUx/6GqIFbm50btRgUVFMuwwrgBg5lQ +tIIPdpf92m/+85orfrZs3ZrsLvtNywxLpVb2nBQbprTtPa5tlz+s/SKUx0+YOG58V+CxwPvff+Ie +b9tz7jPPLlq0cNKkTYolQlTk+gf66xrrCd5KfVpU3FzWKOPS1RLdXCqTIphROpMcGhoGd9ntsrZ3 +cXffM+Xoqs7NA22dYo9esKIVdASKwCGuiUFMElJYPx0zBA8GjXxE0SMfL6S7BnvKcWDghiGQg4SX +VHXJS/jBI9ByGyOvVgxmNADg0lBc4Z8AV4NM5bu5Seu0a6ArJgFs44e7AlQ1UJkfdYbhgeZoHQKc +bY4TVQxwHB67iWw5FVXIoIBYkhkuItDkvUIBAjRttC1bXHkSKfJdILry2mpCjDhwWlGRMlxUpjWh +bARldytvqvOiA0OecDIMyDmPiH1L8VipoS7CknVOaBiB8krVGo5WBFH7U5PAxpUAP2HXghug2Ugk +cvRRB26y9NfzHps7Jh6Y3BQY1xi4+fbHJiz6+dFHHcTd/0UbzzzzzOWXX47Wf9/73tfa2oohhR2G +vnD79W9/+1tPT48DKvjauypyzSWraKV/HaBCgNqRBtE3roMtgwlOVBMAxpbTu65dTd5gH1CDRg9M +nCKD+Kk5ff1r8zKSTMOh/lg/uf3e7dx66I7eZfNTT8zpW7U03d4Vmzy9AfisKkJXqdaIKXdDIxCR +xuVwNUl7GdynObZhEPTV1uZsu2cbtZYvSG+9U1s8GqPpRBBtKSf2C0+WC0Nb333HY6tWrwAyt95q +63e88z2YHdddd/UjDz2Eyl2zZvXz8+ZmUsQnynT3rMlmsoUssYkyHIDGfGhycGigr7+vr3ddb8/a +nu7Va1atXN69amn3wsVPzVt4U3fynrapq6bvGJgwrRJKF9MNVrHbcO2CXlL9/gUBhIAi0MXARBJE +qkCLIxygyEzqCGZI7xu0qDpYa5hKjupaRd3V54rkvIAwgwImc4dJcrhAGiAc5T0TmipvTVDWRgxi +BkuUZ8FdbsEJ4xg+CguNE02Fwl5Iu0jx7kJB+dYXL6AmrIAyoU8u//Xo9c51pRdWkeacgqhw0/ip +5FiLnin3BeXtXRdWUn88+d1R13DuL7VoLzVE962M7GkLQEGY6MEkxwkwHIB+9VteoVr7U5NATQJv +ggS0gtd+5G+8bcBs/PjxHz7+0Otv+N2P7q/v7U21tTU0hvpOP+WdEyZMqJqSr6shkPK8887jHfDY +fvvtWb5bV1eHr/i9733v3XfffdFFF82ZM+fSSy/98Ic//Itf/OK0j3/h0KO3nL55/8K5wzdfufqA +d9kyWswAhQbUUd6eEo2hfQ4ff/cNq391/rxdD+yaMrOBqc07/7b6kGMnbP+2jkXPD99+1ZoXnh4+ ++ayZLhiUVbEUnLZZwztP2eSmy1de9OUXoDN5Zv1RJ07CP+zQQo40nb28FepKj+OpNSpqfGRFMZeU +BCcUgLAYSA8FYuHY1JkNi+cnd99vbCHT0Nk4c8KY3ec13x8IPNvePuZr/31mMjk8fvyEc869IBIL +77DDTt/+zve/e+H5P734x5BKJBKzZ2/VPzgYi8XWrF41duxYDhrlKDTWBrPThQNccyAqAQDZ7JJK +DqwbXte/dCD5fLK8snlcbvzUAHtqOc2UgA8MdWBYihvUYc0OSGlzva6r6YrW01pfTMmrl8CMqrja +91xqUYwsy9W1SYZPCKpCyub3vDhCc3ytmrZqASJGnPLkwxh0ZEdaQ9xHaArCYDk8Vr7AlOQdZnin +Li6BnM+/Gh21AgMW05/hi/Osdkp24Ll5Hbwtqle+Jj5uMCyHIjSV+Ca48xncBeQs3zviJcQ8XbVG +eQf59A5LfmH8ey+UYZkqYReO2RRWeZeeQXslx4RPQUQBBcZhNutdbvz3jvup3tdSTQJvBQnwa535 +9pPv/f15G6Qz/LxZTIsRyVohjEWUOxv/cb0y/fm/s0qdKxYfQbm6MxUoxTDFPAViARLQjLvs5SDe +ei6weFnqNz096dbWhkwGA5Y1G2WdsRwvZ5MoqLKtOimzC4JteajUSEz2TrI/l2iM1DUE3UxMZ/I6 +rzOkYH9YXeg4LEtWTuKhJbLgcH8+Fpf2RZtzFyRAweFU5CX4MbtNNhALdEd0NGRxYzquoLLxZxI4 +SbVYnInLLsOrdMkP5re1N330tA90tWzd3LRJOBL7858vufQPvz3zs1885JBDhwaHxo4bG4pE2SCK +1UhD7HjBxFy1Ynl395rHHn20sbFxk0mTG5oaZ202q621E/QESnN5BaNnsW56KItXt7tv4UDq+VSp +u31crnNSIFonPACiHKWI50AHQR2IY9LRL/XOcCu/4J3/dfyWDmXwT+IuJUn0ha6BHxIUn+ENCrah +lmvlGJTy7iWRD68KnPhUK6Qo40ehyd1tFAxivQmIqDlDPqOn5hAmAhcpIA2RWqgp7lxZArcAACAA +SURBVPKR2BQ8u0xW/NEXnrK3yFPgbBya1g3+8DJk4q4Ps9RK1VL0u8aqsE1roa0K1Nx+hS3roD9W +ClT7S1U++bsKq5kKD56rsgaN1SpWSPyQRAo26LW1JTpWnVtwwg2nqQKRQGNkYkvdpizH41dAYsRJ +4sIo1d5qEqhJ4DVJ4IILLmA/yGsq+iqFdn735zbYvlKaAC/R6azUBUeBOn7h5ACob/C3DRi/Iv+A +K62AoyAr1qp0SW56fWhaS9uzAGg4LGOUfZbm0ZU6I0w86IqGwriANwULpPehcmNLDHXMdhF0E8o0 +Xq+Vtfh3hbvuQqR5cFhKjjOuo2heQt1K0ZsBQS7aTeqLMixjMSOJAHtkghC80Hr8FwhZeQoGs+F0 +qshmDMFqsfmJewbWdWc/8uEvTB27VzTGMtyi4bjq0WY0Fusc08nwoZTPoychSSjzYrbY3t6OY5oo +uY0N9azEHRhsRtUuW7aMktk09mg2nWKtbnpwqL9/YGnPwNxAoq9zYnFCV6CuTiyBoFhv2Hxc+1AA +ybi1R9fUI8lMxpwSzFuOguyb5eqSUd+5a4ABHbBZfTRNzps+8Z938NVE5DgBfbJpnQchMTLssCGL +8kcEpXwImi1rlyKH5J24wM9wlPJeRhS9SYLvZzXdTaN6KFxgxhEfys5QEztOzm8ZJxQj31t0hh29 +RJxBwMgBNRWEgqA3Sh14MPuV+lTBcHeBeDf1rvb9vwrrRXXevXdcO9aq4ItJfTS2rbLJxGCbEtV+ +QTYeCeWCK/rS5fb6TUMhm9N+kUbtqiaBmgQ2qgQ2sIcIiCJhLP4fdQLUhLK/exNce/L8psBBQ8Hu +SLg/w9mi5XJTQ6yhsdQ7mI9xKLcZTEQDx7Oaz5YJFYSrMKbwumVMGXYdSNeh2gpBQtizhJV4STqM +k0x8s+UgiA2OAbfKAZVtNq7kK3RswZE0ILdMz2qKFNADoW0CT/SJ1ms+XgKvs+0zPRiJh8eNqd+y +sX7Tha33HH/8bjvtsGsomCeQIVgKqa232fa4958wbdp0xgoai2jLiKlSmR2izCeFYoglmltaOdGF +A0dpvVAkGD8mdJiZ0uQw4f9e6B9eGKkbbt6k0DUpQCAk1iQRLwkDFEFCRLY1wwkuWIBjB2TSQV5u +UsOz8Mn6i9wFNnw0Ra9MM9p41+hEvKkkSehCGXJIYAAM2S0hVhUhDIR03+lbz4S41oqqmiGI9Mgk +uQCoLuPQiHg+1xSW9WkS4gOQ6bwwTCGBW3iwgVJyHeF8cKC+WDmxZoCt0uZUgJQsdeNZxSzxkWtu +ea9li1NcjKoWbSnf+CdP2dZZZIJwnGEVHuEBrvikFpwNUbFa1jtJ2JL6VbnUbcq7uNR3+pUrsfMn +VVqJg769fnYs1FAtW7uoSaAmgY0sAUWV28hNbvDmRsBUqikeHtuee1c2dm1L3dCClelCCQ2mHROZ +vPSPQhboMBSZRKhLNpamyefkteZgNFJmyhC3J4te2b9PuD38xWgvpgypKRK21RLsqSR0pTb86dwY +lZFRbhCLoSMb1+mbv9FRirA7kUg2HY8E28rZqVPbpzc3TIlF6iD4rncfYwiMCeh+UlHeasttt5q9 +FWY1hzzrXC1Cz5vmlncb5SyQLnBoCHkNjY2gK2uLOHcrncoVcsVIrLB24IWB9MpwItk5JdDWFYjV +az2RLGZ6TQdwPpthKijF8MVAZyqR7rB813AU+UiaVYwxRV9V+/JXI1bwA1vToMKBQfBT/TZZPkig +2UfPFN96OZghIlU33OIROEEXI+9qnXezU+EYzkEyEMuxTe/WlsxTIgxjOPqkqdUUG7SJwe3xilnN +bdAFHe54Fdp1UvBQ8RxQx8YWqkwNWKc0717XuqC6uqcOqSlnmz5a6/Z8lK8CI8KiaySVNLNevI0i +6LesjrWosuo17dKEi82yrJaL1FiCDvwzKqLRVKavWHqss2GrREzr1/iC4OZVrVqqSaAmgY0lgQ22 +7GhjMfzSdoQsoxIf6yMTSkNHl+ru72qb1zc8VCyE0drYybkc+i24/eady7qTq3tSssyYRuWUlSyL +eHHzigqxbeOJYDbFnJuOXZO6BywhmuFoMoElypQGsSoAG2xW2kaNooJRXRR29SuFi7rklA8wi0BE +g4FUb7yQjodKHdM22bm1eXos3MoColCkskoYvQdMhmTPU02wrFleqVSuCP2nVcssJCIDugAr+1tQ +pCwqKhY575I4RopWP5juCQ9lCYPRl0mWw6lofa5reqBzfCDRJHc0NrS4QUU7OuJTNb8uM4iOnehl ++gsuijSYCr5GdPqpxhP0jw6OAKe6a9tJpa7hyPpceQjkAANwaVaa5mKrH5EPcKJ74gGCVHEYhsaL +1RmRAOomGO8wNSRwW+pMXcnW+KlioUYVluO4Kwg0Q5nHQWENdMxxTS0Z2caynhfRfY1PiKt3JhnJ +Xo9b/CuUcSCE5ScfOB0hfwQdRcXLO+fWEe7SHQjRHC/xbOWVqWx9lJebW4bo4tOSZGUXoj+SlGN0 +RjLUOl0WHcNv8iV7G4twi71O3aVHO5q2aoyzNbiWahKoSWDjSgBEeC3BEzYuU6+ptZcgKHVG58TD +HcX0oYXc5s3l+enQslx4IBzO19cVhtPlxasGpo9vSw3l+4bzsbpAHeemhOQVTA4GifCAfzSTNkNd +k5TSZsV8uaEecA1kckFWMDneyIZjLRK7RW3HC6oZvebaFri2ikyCxkOF1mR/w3BfrH9tcO3qVGNj ++4yJ4+saOImGqdyS4NO2mhYsvjwq1vZQEpofbc6yIdOsZQ59cXijDcoxO5xnv6ii6OazOKVz2SKr +lkLxVKR5XYl4uRFh55iJgc4JskQFbIaCQhupYYGEez6BDfy6mKHS9SzbwWgmx/pFFexy4lSAIuza +fDHRSSTCZ/CAN7/mCsIGG4IQy1RThk8CDLNErZJErd6pK+JEFanuEGIV+cRBeRTgrt697yArbGNV +m9/VGrRRDtlmj3pJUWIIBB1aYVSUFJCb+c18uUjBnicaZXhBgp9Kslq6VpP6i6lKo1D2favi08oL +yXRlnJsc+Ey4fyQJVFOqMmHMLT6AwS4obxpRiIxuiT63wEIyRxhTlmWKBxedfxSlipBVQs2YJA2w +EQKDBoZbA+m58UhzLFLz9EpItVSTwMaTAEdiKw7ZWzMF4+Ep4cLExnIxU1xXKPUWAgMtob7MQPKZ +IWzMeDSYZSFtCiwJB+obQNMyShOrDnVcLgZRixijICUJIyncgJnCeh4L5BYONMU55rOYGq7siABZ +kSKvOk4YLzZ0xDcJFMdlko2ZgUSY8HvFZF20r65+daE4lM4MhENj0KQ6KysQLgDUiF9rktGMQDM2 +lBQltigB52mai//H3pv9WHZdZ553OHeMOTKGnJlkkqIsyqLmwbJUblkuyOgGqO4XATbcMLpf9Fz9 +N3S/6KXfC4aBAgzYZcD9onYZkK2yJMuyXJbEkkiJU5KZyZxjjrhx56F+37fuPXkzMkmRzEjass/O +myf22cPaa6997/r22qPsTp1ghDEKfrCeiEwDTqcAU1lUtH9wfe/w0rC6NV+XQl9ez62cUXVA+rA4 +VQEbNNbMUsFwC7SIYSxT7DwN9+oV3U0IVQbMpLhR9xMDCGbNpq8uJ6Py6ak/VvFAjsaKPVob0YI3 +L/VidpYyIAhxYa2q6+xGI5VC1JRlNu6gGCSUmOxGWXgmMfl5UKxK9l3cQVY2KAubGX734l6aUvKD +uJDNicWpHKXzLlCHlCsI5ynAB3GSKXteRzdrMZrnqVVilO5aixZr09iA6+4UpBAdxPH4K6TYKGW8 +bYZcFO0CxqCONIBAgy4hgtWg7DnX6P2EZAhWFj6qjT3+G/zAPFXQnUXd9ubBy6eXdGpY5jIJZBJ4 +HyXACpfxz/p9LPQ4ino3bBfKxRPlnE48kCsIs9r9a8n8d7q5rX4vj64/ZHLUdg+mJ4uStLYIg6/H +xn/dCo5m5D4O7Db0GMt6EzZudgulYvXEHEq01O9x9ct8pbhazC+Ui8tJZa0wnGWzyuzyYC+/UTg8 +LLAXJ19rtWd397ZYaovK5KR5gSfaz0O1Uo/oaI46VKBUPXOh3hUKXPZGmKLa+6PDi/AOO6N2r93u +bO81rzba1zjFnmHDSi23uK5j/yoYJGyXxGJGvYKQdqJqHS1IAN5i1S5VZsiaGtjMQo8zCOxU2qsj +nI8dJgJM63ATkTKfgJlC9X4XnEgpWYVdCAQaqiU1Yy8ZZTxNgADPkVdlx3wE3UEFmVlKTF4I0rMR +nHv8GfOUcokCPrGwSaYTi7yRhldOMAAF9Rr8B5OGT/IglugWQJgE+NOCVBaESZ86+2EJfggnMeXq +EeAXlXItIqOmkB0LulMQXxiFexgAfoiCznjEO0rhOS7V9Fn+7U6DSom2swUf8gwGePJKJnoIaW8g +ZY8SG63be5UrizMXVHbmMglkEnhfJMAP81d+rjTF1NTzy0THsGoy7M1126sfeOp3+4PdZnuz2eNw +2k69Bnz2+qMuy3Wl5Ybo5XavxQhqcXlttZzMMXxYKMxUSzP5fC03mMsN5+RhE2q+VChWUXEAbr6I +ESKdWivWcrlFBmLRvt1eu1avHRwkm5sb3A46OzcHWI4YrQUwh5SlY8r7Q26q1LguR0rIDGUMl2hu +C9MRE2DqqNPpdXv7B82r+x0Q9JDrwJnOZDh37sQYRDFxBDm2QSlUCtcf9LLUsbf6MHdIeAqTUtCe +5JNKx5/3eCb4ZTAgUJOsvIa5SRLr8ZAwPENW2OmyeIW0SuTVxhlYI/vMyciCxgfqRMqYKiRSChET +wvkoHxLr+NzJ0bi8kkZru5yXJ1EMTasOOAozWbIH9jDtjbwhBVmZs84+DpnwplxkB0R5Oo0GpY1e +sbiMSiEfjk9SjcwbIaQfc+tCVYSJR1+EIkTNZAnBE5t/FGYJUCh+oE7iwsMLJD1CALiqmhCEDdPA +P0ZHA2dq1Ao+9d2SDMUYRJwF0lCmh4EQkM/mwSvV8mK1xM2CmcskkEng/ZAAGhso9c/6/SjuUZUB +iIajADzpMzwPrOCrb/7TfmPjyVPPPnXxwx2O2esc9kaNUb/YHzW5s5PLPLEEsdi3OreubF3b32le +WP7EyfWTTQ53MAxI7/neb5Sa1FqBhcLcIck542yWZ/GQj2AYsbN2sdVsIN8qQFptVmuV3d2tO5u3 +azM1W5l9TiMCL3XqrwZwB0Ap14hyi4tBlvOKiMgzoNtq7zY7d3qDO63eRrPXosiVNUFjfZHLw7VA +Rhhg2BMueo9mtKr0u1SvAtHC3PwdcAtcoXZVC6tjsIRXRgh5JTBGLHl11UQZrPIfa3oJeQKfDuZB +LpVFXptTArzJmLAQCHC14YidCkgIVYwE0BlbaYZq8EBrwYyXJEO2IuvXwH5CoF+tJJyLqCIm2Ykl +SqgPjtqWxbAGSiHFh2TQ4b/8MMOLxaKxB1qTghStYIiQBpyDWwRCWd2O0ioXacnuJ39E03Tou4Cj +pIEIyaAAYwh/XC6BrjJp+YCySuwSqXhcuBAYrFYzX9AiexAhSLy5LJghO5uvmOFWkxLuqkm2bjUy +UpaCmTRtvlZd+KSYzlwmgUwCj14C/AaPeV/po+dZJQReRlljFJViU3i4iHqr517jzubuK81W77/9 +9M9PnTpbLLOaqJ0Mk0EySvplRngT1sla9504Udvb77Sb17e2b5w7f7KeLzFNCVkmmLmgQ/cvp07j +w7qW2VtWpHrZacP+0fm5xW5ns1ziqIpKrTKzcXDnxo3ra2taZtnvskOHpblsX2ElkXQ4W0gBTmZh +0aT42r1Gq73R6tw+7G6OtLl1wEb82kJuYSm3vJIrsb9FC6OEYSz4lerHHvK4rpAC884WDCYd3BAC +UOGkbSdaGNyNi1lSAAB+IEKtSCurjqFjljLhN5SSETo41Ru/ilEIH6ICkBSIs/ZHiAq3rneo6Rhy +IA4XIuDFwJQn9DJiATayrY18Im5TLJAJNnTgB/WCP2ptRKFGZEmXR4mBsCBdbTKav3F6oZC+KXqF +B4a4gWGyQBAiiIhIio5uASEkixH+oBP2K7lJA3CSi13CODjnlTSEkFdEgFW6BarAuKZgISF8JEzE +4mqGYKEQ/LNgDQ6RmyqBOc5EvsmSXpIs5jiUCjpBXAQ9K4HZip9aQ21sm+bbfLO45FTMZS6TQCaB +Ry+BXzEoBb9SKzNFTTwIKl7T55GQNBfhN7d/9sQTs5evHL525Wf/7Sf/5Tc++z+XS4yy5jEChwnH +EPawLa0F88Df2bNn2q1DbvbsMUjLjaZ9qSeGdG0eMEZrkEFhojE1DSkdK/XJm/RyfmFhiRtBc0yY +cgxxuVQsFG++ef3smbMzs3Mdlt4yvCvXZVgXG6XfAVbR8FyItt3s3thr3ulyuEAR6zZXn82VZ3Oz +i7m5BR2ci0Nxa/8r9qUhEyWOqhVS2r4RVsEpYAAroCx6GbyJ1UZxb6wZD14hBf9SzSh6VreSzHae +gNnwRn0kEhGTypbjhVyh4h2FWkeVR7liiVjML5vIJI+dMIQgIGRGLGkoVLmMZMADNIkSnqk9jZeB +xK6sQEW8DdusWDaukIZAPd128mlsVneQ0eERcaqjUOF0oJGTqPRwWls0cWJAqcbPqGwEKpyIiHMC +iEOTwKgCBcEJZ4BQBQKVMCQwFplevTxbCcQzz7Lm3QW9tDuNZQwGUAPOlZ0Q9zBEw/0G/nLMJC3O +OEQMRYg94yg0ER3lJhWwv7Iy85EMR91Q2SOTwPshAf300h/7+1HgsZYxjZo6NdBnkKZPPMBnirIp +lLIDrza32WmXsORKSfd7P/z/Tq6fu/j4s53uoUigiRlCwx4pcGaQlOvKyipnCb155erW5s7FJ1cK +hj2lzIv+oMDkJiKUFDXWqxyofEETpxax9jYpJaDm3t4OWpdjjMqVyt7B9tUrV86ff6yreVIBdxck +ZUPMoNXs3W62b3HB92DYHORYAcUmVy5wzc0uC0Qr9TFyMN8pdYzKBkOg6zIFbISJATmtZQWNUNlg +LYGoeCeW+WIkwxoDHQVdzPN57DHgEyyUB1LMm9pCgg4UeEXp81RqoyZPlWY2wBViBYpAsgOFmhTL +03aYgCc8oILxRmwbisgIfQIFHgpVRZTedSE2nGPEbZlVW5pc5lwKDiXusHCM8YFqVcu2tN5Kje68 +xnL8Qjvv9oEfaFKKnF7GxckbyWDdglICM8nfMQPQNLwpqxOnogb84A0iQdNZJSUFkhL+yRvck4hq +WoyxeIooeKt6soAk1I5dOiArrYAoyB5UiUIgqgiYnQiDdaol8ndNeaowdg7rqI3kRP1ZRkP0nrlM +ApkE3h8JMMCbYsz7U+KxlBIgGqTCL2hDoU5c+DH10pR4oqbN7tbrb9zhCNx+P8+waqtz+N3v/+fZ +2vrC4gIKGsOSowwwIZm6hCKbT0qV0qmTp7a2tm7cunHh4hPFhANwBSyoOWlXyMomC30vlSY7Ve+s +wWXdLQuIcvVaHaWHSsWWTUpFzgS+fPmNmfp8pVpnV2i7c3DYutUdbLY6OywlBlIZYmWgD+BcmM/V +FrWzhYMMpVQDG9DMKtEhtrqIQplqnYujSCZljd/zo2heXByLI7uTxUeh5Q2QYhZapPcZrihxjRB6 +0Y0GeaEpYFRxAjlQEGzg3Wiq2rpoPGO84dVoJBgwEJJAUA19MWcYs4El9niFVQMbsQIkg4dMMZUh +fMUvORu6hEne7oJ8dEDT6HSpMNsdbuXLW1rwzOSzs5AYHxkFz5YYnQYKkoh4tZlOfpIhDZmDakc5 +Co1uhKppSWpu0qYhsUpjwz3oi39lUnaqrIKCYWrqb4M6H24RRl+juOBfdXS/RNanZUK8q6ueDRud +OUsEPhkYaB8KVknPh8QkwhLlW0HvCsaCSIw3qF7sZmYAoMBS8g+VCsvuTwSD5jJ7ZBLIJPBIJSDk ++FX7xQm9bG4KxybwOe1x8BhWQVPgNZ7kwiWV5tKJwSHXa9OLr2gu8PL1S//l2//xf/qN/31tbS2f +9Fg4hHZl7RBbT9B7jJEur6yurp68fu3ynds3z5w7z0JbkkCKpmGpkVSh1vPYEaRD/aQAiQBXGbJF +tZbKlS77WlCQnJmf5PcbN65cKy4uLXS623uHt4a5Znlm0KUxyrmFeq7mgVy2tYTlgaJkUlOtFGBJ +UZPvhMq2ItYwLGlsTQraUb6Aonc6AiQAhvDVVksADOnDbI3sUvqAmVfEFCvKHlYRVs7YusVUpQg+ +VIyCvCQHj2DPwIofF3TIOwYPosKWMqoRjmklIoQ7PU8hnIeUSWmJib6yG1xlzBn2SCb6gnlOKV6s +FNZiALNcODHMzfSL1xibZ9UXM9iwCEGIqJeg7ovrAs8GMKhROyoFOAnMJgLkLwkkpclBTrAKs8C2 +pGG8hwFQUzyQjCLMj8i6dsruhjHL4hZqkS9KcZBER7KovrJYFErgKlMWftqdLcLaHNzKD3vJ3i5X +uI/4rtZm9I2lm6X+CmxMSqTh5M/nlmofrJc0DT/+ck4XHMVnz0wCmQQehQRAlvHQ06Og/rY033jj +DS5f437Nt031dpFAJtHTwMlFNGwb4fK169evP/PMMyiU119/nUtjVlZWQFOcELdYmFvOnejltjdG +XHPW6WHhjF6/9kL7v/6/n3r2ucWF9bmZxdn5WZJJS6KwQNWkcPLUya3N229cen1t7RSjwFKTE0eC +kbeJcgyhykCBy0ACwFigy4oibbOBTLfd7zI72t0YVTbK9e5266WGVLWKADtRkYurXDsjHYr2RzNC +AiRAL+NXPUmpyqpUHgrHY10cvCg2EqCObfrApvgw2pFaeDxRvoKrcARGLr+SQMjhcgnnwKM0pSoN +MRMJlgJOxGfYdgEGhhny4iCFlg+agnODjKI8qsxf6EQa/FRNBI0l8BTlEgjqqzfA4l6ZyOXy8FRS +uOemoEKumgzPD/NXRyWu2Ysx3jGCUuCYjtFOLPFfTTNmBj/1KrHMTG3n0l3HkJP6AaRgWNVdDRJQ +nXCSpDEe+iSDCPVCOIJ8m780ARa8HCSQkdPzRphoQtB1xB9ZqCnpKYKEOOpLCOdi1apM3hearQFf +kvF97J7SplxkRbl4uKqBr8dC9clacpq8fAfpPppM9sgkkEngfZLAMc+Vbm5uvvzyy9xXCmiBZIDl +008/DZLdX5sf//jHZ86cebdQirLkPlTuF0sRlFI4uxb1kT6Jojhe0745fkKCJTQWWLWwMppfzu9s +5LqHVdaLMoG6dXDjb374Rx84/cWT6xeeeeY3peU9PDssao/K4uIChV69fOXNq1eeeupp4JFCUHy4 +sD20gQXw1EgcOk4H5Ha63Q67UlvN/b2DRuOgN9jcab3ULTYoPQZaMTuqDOjVczNLOmNB6hjIhVPP +RMKA1g3BNiFobWPMWBFTO1SltSUPhnaNmVbT0tNW/WTyUqMgIsXtFUDo33DAiZT4lKlK6Q4QcZG3 +QcZuEBxgRixAIqPN+yapKNUXP2BJ8GNbUGTNmBIHNMb4pMQiUiBJAJLQCMyYrA8iVvI0HpMGypIw +FqSlgSmW5JbLo/V7Vk2LgBwjo5X8Y4XytcHgsMpxjbr2XOGwDXMUq7ImzGh82ItjeQqQaD9MWjNP +qUqstHYEToZh1TsyeyI76VWkKEigakd6Zp1ZVh0znQoVOaIoRY5XOLGUndxhriyB8CCRKAFV122A +APydjQ5fKRadyR7V1INohBu3V56RlUI5f6GenFNHDgJeJTBJ48LGObI/mQQyCTwqCaBsju3HBo6+ ++OKLOzs7KbPcBA6+YCA+EE3TZO/cc/ny5R/+8Ie///u/H3gZg7f48QSUYpjiJwQPUBpRhFAEr+ia +mfLJwrCca3VKpfzC0qha+0hv2Li5+yJXqvW63Z9e/uvXN+pbjRcuPvb59RMXqpU5Dl1g6grqJ1ZP +3rh+89LLr586eZ7JKqtNrFEpL3CUagpBWYarw3f4N+Lu8f39vc3NS3d2Xhrmdw/zu6NKm7tQmfHi +/hn2g857Dz1IibXBE4CRpkW/8zR0WbOqefSJVrJxKXHZVE21KlwAmQFOKH00KmOYPMcEzasUemht +qJk+uhuwAbw1gAm6cKMnoOS9jyAlO22wk+KsWtXRZIX3U34KELhqeNvFUaJ5IjssUReko0LtgYI8 +njqNQpXLNp+iwsgzQVAECY/XG6t7Ua6MThdzXrisyj/AafZ0eLZeu86159CEGlVT4yAoH5YEq3io +EXIOsJfQjI/Bc7AnMU9yBbbRNAJU5+WpeAtWvRleLVUJmqIKAjxiCVfCVODOpTT2iKuJ39nEKmIM +Q5ZYLtlFUK1WjhttSakvjDftIGcJ0NlpX8lQe5+KpdHFWnIyepN8yXGQ5ZufelRK5jIJZBJ4lBLQ +7o1jcfySj+BokAVZCf/CF74QeHZ/WZ1O5y/+4i++9KUvPf/88zdv3jx37twXv/hFdo6Q8qc//elL +L73UaDQI/J3f+R2g+gc/+AEnEP3Zn/0ZFu3nP//5n/3sZwzh7u3tcQ04gD0/Px8KJaAUCnika0ol +JiqvXbuGuQzmFWqfLtS+h/Iq958qDlYKueVz8yd3Oi802rcfW/tYs7fzwmv/8MrlH60vX2TQjKMB +S0lpbf3k+tppbNMXX/re8HuNj33037355mu7u5vLy6tPfeAjLM1FfTG3yh5R7tze3r22s3tld+/a +duPa/uFWscTh9ToeYf2sxnKBKCqHfsSh1sEM1L1Ua5ikVrPSxYzjEch/m32CBPuVMnAUlWq1rygU +q+05KsVwKxhAJJiKwkXjg0mEoKMJVOlhYk6Wy1I2Gpn+ArGYgPxhSwYTrpSCSZpuFyF7gJOwEB7g +0xkJp2qxLZIq8AFH44wk2JNSNzpqAhXaMtqVhhIDwAS3YfkRodTuTHj2tF5jthdberGcWwcZFfe2 +zmh6plu4Mhy2qbWE4A+sIn9JxsThhA4PPODggY9eQ9S8OjyiVE9brnp1AiqLox25xgAAIABJREFU +WPRUBlHgySu1IAEfjOyAOqWPuoxTwYR8mi3GTfLikVQdFgIhpNPRphdEioHLvClmNPwLR905gAGK +40O2UjGp5p4s55f52vP7iicIytc+9au0qK1LyR6ZBDIJHL8EMN5YOHMsdBl6nbZHp2kSTuxb3QfO +bx4s/Pa3v/3xj3/8E5/4xDe/+U1Mz6eeeurg4AAD9Gtf+9rMzAzWLQQZYiXBT37yk+eeey6AmajP +fe5zs7Oz3//+91999dVPf/rT6JGIAj7RIPhxWKiUMjc3d+rUKTyvvNqvVk52i3cK828Md1b6o8NW +/iW0dyUZlYq1WrFZnwdKirPJk7d3X93vXFqqn2l3PvzzS3970H5zb3hwbvShnzz/X1fWTpw5v3bt +ys3ha+36THLY3G407hy293f3dw5ad9rdQ1Qq+g7IBM+0JXReWhi9GSOrRHE0HSGoS/wo01iCSzVR +kkpp1awX9CY6HednaFKhUWh5Yg1gKPQAuTiUjlem0EJN48dhxGDsUpZMUluN2lTDwl2jJltUgR9Q +lrP7YaZWE58o9FD6fEWgoSKAwAmQ4A+ADOCEMiCqlDH2G69GTVIq3PBJMhxFBFeBH6qOmYQHQngF +OdjrUhqtc3eAMrwzB5rOls4PRpd6Xd1TF6WoiOimgJSWLcwQqIIg61g97cagM4kVU7ZiFT6VEi/8 +I14CoyKRUbUwKUnJNYVA5AVESY/AgVsV7GoSG90LmfukH+mWckYC8LNYl26WsriBFGsxqlvgIoqF +cmV4kal/vtLmXY8AUTx87QNT06jMk0kgk8CjkoAODozf5UOXgNn3NjSIfSsojVyf+cxnnnjiCfwM +BbNuCChFF6AjLl269Ou//uuYm0QRUmYwVIq+FoNXZNFB78Mhc64vvPACBmhAKQoloBRPWKXkJQ0p +sUrrNVYVXRzM3tna5yK0IWt1C0m3Wma5UC7P+TKamsrXR+coqFd+uVQY7Y8ul7onSoXFw/7zswti +4Mb+P13dvz3ol9ZmPrV1+bWN5guQZfUoWEJ+VgUz94lcGSzlXF88FcYmUYhYJlhLqojtJOljiHk2 +NJbVMNCHdYtlw2lHPihOKtfoRcJQ5uOxX4hQnAMVPjEQicXkRbVShOxdqtDTGhZKZfM+WaBMFNQI +h9sKiOUbWykU3Y0hix5nlBKabe69wXCvj087AgCAhFD3wiFzQ0GEwCE0ScwnHMAQWMVrBMa3TMnu +qv0xmEE2AiGJB6hg5rOUXyqP1rTC/N26UXk2eWynf7lQVEkxNosvAE9cWWj8oTg1tvHJL+OoSACr +VE2MWbYkJC/J0uz0tmLSl5Rqd9Aa+UCT/3gmiSM7YUhMIoKgXkRcwsSL9GywYobSd+GVhtPcMMun +mdb1iDrEgqz+0j9jxjhfyXcv5At1vvB8q/me4wl//ArwK3E2zIsUMpdJ4BFLgB/bsd1XCqQFt/x6 +U7bj98xrGptGHfEsLo5P30YRRBQW51e+8pXvfve7jOL+5m/+ZgBtREUREL9y5QpGKqokCsL6JAEU +SDBtleIHShngZYgYP/eqzNceu/D4S4PXN9sH0qmAnzQ+YIMJ4vHAYr/GpWyV2ijB9mLEcrQ7U1yr +cQOoa1mZOWg32HkK9vYLnEaU9NntZ5DUvsCY9URnajmuNSyaUeLx5nrszYAZmYxekiPVij71K+nZ +2IoOJUTmi1Wnda+UOJ/Q6fJTgGEszFOtcbURo9LhGWvK47pjIxh0tPGKIgYvSQN2MtiLZmf4VxOi +xtc4qY5C2SxE6VoM5cbEDybBIc4qWoodyvoD0hNqKSkWkdighr6AUzmUIPBSefmYbTwwg2yhgSjw +R8snxXI1fzrJP3hmdPrbZdp3H+mXLT8qMx1eKLVhEFGIPbcaiCUkM0/iwlUTM8GVRR1+YBInCXuV +LH4yRnplckZSUkERh1SAriU8DrEQoDAWe6As9BwdJQdN8iJ2Le9i6pqmj5lRA61MVc/RcqcphcIA +2aGZVLnse4mly1Q5an0ETfm2E46s4mkes0cmgUwCj0oC/KL5ycbv+hjKqNhk1I974oJohL+HAh57 +7LHf+73fwyr91re+xTTnEQos5SX8k5/85Fe/+lUmSlEcaBDQNIVSTFgCecVz48YNjN1nn332Qx/6 +EOuK0dTd3U/O1LQtFEtxcW7EQGsIA7UOIueL7SQ3i/LCD0RVi/PDfJuoqq9VBn6Y9azPSfsTq90s +VSETR/qx8BWFOMPpCnWtJyI9Rh7qkrzoSowzCEpjxthdDDyCJTYlQSzhkx1c4UAmDduiQBmSBcys +SQFCAqGp9nMDoml1tALwxslzNmqV2ZodyxiYpyIQCegiOwWhpikCSwiFDm9uOh3vB7ZhG3FvtrJz +nntLlEhDXvS4MBhO3AMIVBDekAA+w542h4HiCrEdRhoS8FRiG2fQgWfDisxoxKivIXdoJ8szxYtH +cJRGTJ0KewtHGki2Ovsbu1f2dtvc1q462jRHSvQDqIUqZfzjiT+Yhw9eqaxqZD8eJfZkM1TlD3ap +Xfqhg+V6kVet6ezqMN2bEmahEDUlZXQXVJzbCzm0mjluScAxbEBL0RD6hjCua5kopetLFXDkoq9G +zzA/HONo9CP5weFJ/c4Bq3Lhz56ZBDIJPDoJ8EPTeQTH4sAwTjK4HzUJITzsxXdVEKuNdnd3AcKL +Fy+iJcOuZaSXedPYbNNijWMut7CwwEIkkJLpWBLjrFLRR3L4CcESZQCWYWEwlcQsdELpVPqfnc39 +VqFymO8vDLgmDW1o/lCLDHWOqjeYeKsl59B95cJcJb/eK17DuMRQw+FhHwsqL/Qd1qeUoHSclLLO +QQVZDZaBEySbmeNKE2lSQaPtOW5BkYq37sUTY3o0BzjH4CpmCn5UaihToS+QDDDYzCJQuGCkl1JG +4QIVxrmAvQBsAQkEA//IgDMc8pfS0fsyhW054WG9aN9bX2QhFXOVcg408iS1iKCSgcagIDiJcVFD +r2rk+91Sva3YicXmPM7n7KQBwsdQ4fODYJVD6jkTai55olo4TaXTLHiiNSME/9u4dvdgY//1ncbV +3qCFnKmO+gHurMhQju+5ecCLxNg5DJMqglZgdynrqA2uwleSOSX1ghThvCqM//Zb+gqEDgJX1yRa +CgrG2mBYzedyx08XRCAOEIVDXTXkEV2+V3yjxt8BuDLWkovvAOzBAw5KfIU4bmvU5zSusoHSXIox +OdKEJ57KY3fkdRKc/c0kkEng2CTAz9q/9YcmWKlUMCK173Nvjy2VQQ8cnV9YIJzYd1sCOPrXf/3X +oCAZP/WpT7FoCM/JkyfPnz//p3/6pxiXn/3sZ6H853/+5xBnORLjt9/5znd+67d+K7QtOIqRip8n +RB5//PF//Md//Pu//3tMUohcvXoVz/z850+u/Pjm1W738u/kTjxfqdzhaCLEASh2B43Rwj/V9j9a +zT2TG1V6yeVe6TVYQefiYEoLdkgK6nA8jQ+giWFSzvDFNERdllCR1s4gh4wza1hwGgqthtQo1ioO +TYoKBL2IYrkmqpkFnDHvLEUs6BS2CPNcYGr2KC+rVLrjBagkxixmIS6OXNCBMioeyrziQGKAgVcC +qSADwnCCQjdE5FoHslDr8xrshaZwtJvrtMewJi0tRW37jCfY6UlNsuOJskggZDJyKyn1ZfDWWKWM +zo5HoEK/IZLRFZARVi/nV0q5+XT1rLIrZTB+1O/IcWDgx2DYPeDs4u4uzMCA4Mff615b7FFZKo6D +TyVQErHHrID+egiXqOBfYUT7Cc/qnUSnwUY56SFOGsUbd1WgQ4buhZAARwh5xUZYtCapCKxYbWPN +wRiiE367d0Xj3mOJRvnGXVHz7TSsosNbSrhLvl9ledioBBeICAnQL6S/GHgZAkn9kWBakmIjc5kE +MgkcrwT4jT317//P7/2n//tYyMYiXo6rZZERP2aIYwWyTQX3HqA0WMIAxZo8oguwR0FHwJJSsDJj +IJfSeY1ADXV5AhVbFodJyhOusGghFR7oR3hz+NJO99ut/jagoHUfKFB2lHTzJSZKwcpmdVhsc6Au +G0wLFSolIw8NiwEB9gAVoFcctifQQ8VysmtHQ76iA1wxIleT8YG6RHsCeERBQXaMtyGiFcHvMAeh +Jqz18iWyo2opTlrexisUIBj6PRQ+foZzyUVKMk4gwCajobTNElzWFs3IECQLhWJoylwmi20jUB8n +PO7ZLMvlGgfuB1QEujDMUt7S7f/ty88xfm7UBy8ND8JIKmiLFlZx4pMoD/8SK8YItNVLrJMohP9Q +4Eh6YCUp1qvFlUpxPiiIysSlLZ56iEn9qQccaXa2Djq3deSxOysUJI/bgh4MbFBf0JRAeFMtIhlt +rKTiR4nt9CbAEuZRBSXwW4RjGo5DqCnOsTwlCpL5qZR6GztRw0UjWkT0TpA54Rpm8LAwXwmaj0ZX +K/N1Ij2k3A8LVmmsKr8AVop1CkmR+4uGSW5u2HpMhN1TjCddRgA1feIJR2zqxEzmMglkErhXAt/4 +xje+/vWv3xv27t4++b/+XxoCfXeZ3jo18AZqYu0BUdEvJoSFuzzfOtMviYHa/SkA1wiE+VgYTHEA +KoF4AFGUCFHAJ8olAnkSTkYQl1gSw2SomMroqaX87OrKd27uvcGGynaH8TS25fnIAi0D4e6RHIeS +U6USK1pZiYNV4ZPQoY02RBGjo3EYFuAoKEsgSpzDjFCagCgTq+UZ4S7aEwuDUUfGaXVRmq0TpI81 +OSopMaSwR8mOgha4xqgvCAqiA4o4cAi1S5ZQ30RYtNK9AHwodwJRyoAuQA5XDDXHWK7RVDOCQSeX +a3Jguq7HGY8AD1vy8IpmxzYFhCgOfsSOTU/yRQl8ZQJ+xh7qEBDlCVGKYJsN0AIdMkQW/iAf/MAD +HtpttrTCyDk5A59UO7vpL2TqD0+01yQh+3Yajc6NTk8bpdJK4RdXLsgjCOoQ0IHAKEcc+rLbVtZ6 +Wg+z800RCJsEkfBMGw1cHdEx/3iICotWTSDqqvL4E6WbRnCi9I7Vw4WSly8AnOCEoB7810ACsUZQ +kSU1DCAlelGTLki1XOAIhlZr1NhjOnxQn2UHTG7UfddjPCKduUwCmQQejQT49R/nfaVoOiAK92i4 +fTDVVNsSDY7yGoNdACd+8BLgJCTF10BZnqRP8yb5tcHuc4vl7zfKPwKKB71COeHqZI3Flcsj9N2o +nR8whGYDjsFPlvW22lKpoSurbBZEX/e19UV7JHqCKICKCVSOfAMFySibBsQNW5AbP7zPBNRpNqRb +AVdpautQdL3wz1Yvw7DDtjHJqlwDyyhZ33RNeiqBOgZBha9YtFb9AC9RYDlRHLnASiLmlAEVCsdI +ZYqUBKh0rdFlIJeRXl696BfzWr0BjzbDC0gMHe4noS8D8bhwFA+BY/OO4myVggGEUEcENPZ7QpRX +4IoQfcLIkz1arwOib3ELWNoiRzy8hhN/arjcfuvGYRdj1G3gcmkLejxjnAOiQEE1jxKrRVqawAZN +4VN9E0Str4A6IaRS09qp00APyUPf0+FqaUox8o0xmJDotXjwABlSEHmjk+FiVDqSoS0QNY62owXB +UWxQUvKhjciFCwZIoHIQrHtLgbhcd3uwpzT6CjU4kzJXLczA90QkR/8qaeYyCWQSeB8lwM+WM3gn +WuR9LPjYi0KdBI5COTyAJfCZWqXTaJrqnnvYGBXLnS/O5k/Vlv5+c2ezzy0j4DKTiywcLg7LJc4I +ZDefVDeTiGhAmafEokABMxujCLJ1OLa9QF8UJcPFqE5GdJn+BDvJpSWyCJ01Pi0ZrFirJMNewfJD +TUvtYozSIAwAotBBTYpgAyjznVa7IOvII8PoXxJIHQN+AYTGKvQ4ihs6hMMqc3LgNIE9a3MIC2xY +uAvBkUaewdgRE4o2RjHFyALqkAAusUeBXZm/xlRoSs3jjB/CJNtYeMLYUq4JJMgwJZmBFsSCVVwl +meEil3Ly4Ks0aRQlskv9aUtFSLwyM7rbvNLuCV6UyQgHFPHRCmdwiDpSuulRtNIYTWmOOBBDIeZW +HQtwjZvt2O2Dz+0YZyGJoDOSQjgHTXuElIZnZxBxhEa5UQqxYsPEyQhZIJaUUKb1YUZP7H5DMhLT +BzlZUEwZqCB6IaaP9UlPbuP2kN4M2aFPLF00CBarg4o7PdNiCb9lEnLSM17TJ57MZRLIJPAIJJBn +Xyk/338NLlUlaWVA04DVu6plMrdEmjR96iEwGVwsHqwvV3+w2/s5w7osAW4PdY0p6lUoFaOUjL4C +fixmscbEz18MCN002S822kCSzBrhGePA1tE6AQ/QwnBkxouJSRSoE3DsLRnDjCcxsIdW5eChwz0p +2VCgPNGhwBUfCkK/6/rSAFqUNcuIvDUTDUsCCgW8MWrxgJcQBBqZ9cQMYoULkMneGEEFpVBbVPOh +EJ0osoP36F7wGzOaUWgsbPxdpVMs/jE6Bj+x5xUgAcgNZkpnZwU+Dgx8TYrVemm1VABEpdzvd2kT +HPHwesR1+wc7zTcGww41olxh3DRJA57ou2NhJBEyhUOwIZNqVVf5IC4Nik8Ma1GbmkxVFkMgzwku +u1IUGUg5IasvhtmIgMBR2h36OPUkPJxL5wa/XjE9+QIYLzVFaghXl4UCDcMkoJkY1djfNnB6yEGS +m5R42LuOWKqlpSPC4TUGXdJwERVvk5zxnj0zCWQSOFYJoDyO+WaYY2XvPRKbVhypTglPKBroRprp +lGlh+dxstfflheETo/kftofbQ3YeMD4sZAJJpdr4oJlGLS3JmZ1Ldg/6YA9Dvlyl9pEPzlUK1f/+ +8mar3dfgqhEIHYrxg5EHpHGQPbiFJtVaJFaggEMYmp6elEY2PpG+RAaP04LTjPRirxBAAnFuW4e7 +R0iLAUoRaGfgE5xDEUvLc3YuJ7gyI1vUmDN+VLmsYY9Atr3CSOXS+EPFUjX8MQIJY3hUKLZsMXcI +nTYXsnhRjLWxWAA3KGjKBV5CBB4CG/BTupGjXCuu1EpLd3FgKiPe6SZI/XhSR5oUHprd2/vtN7kP +DWgQ/8ovTKIiAicYMGN3cYMoFyezGB8XGFRXB8N2b3BAjwTEou44SKVO1MSV0ivcpehNoRK+/kfR +kcwBkZ1cfJAebY2Dvj4eOdATDg2lIa5IrPaCeeenCHpgfD2Q4eFBbndbBSFGnAtXSpLCOVMQB50r +XMMwVz1bKmrzdLhUUPFKRjymnT0yCWQSeIQSQPkc51zpI+T0vZIe65ipP1Ca1jgpYZJgwqavtcIT +o+bZpaUXD2f/ab9x2G3n19cqjQbHHyaMze4ddmSxATm5UZ3pRuMravkXl3afeXzt3Fr98o19tCRq +TFYpQ3a+bkVGJymxYjFNfNcHik5G50AbSTWEyzgvo6mM8WJ0ksC4iB4lC7RQx8JdNCohWDzGacwX +waRhTE8P5AJpFK2RXvAYvc+CpoHAG56bXltENcWYzVkIYqvNzgnamUxFdXO+BIPYMT83FgjdAoz0 +iQEnhW6k4TmGBNS9cTRUt3GU8dwT1eQEVUylesSTKvojnrS50paC/EHncqN9RyVaAjyFSW4xFepP +HGFBKeANATi+4pQP58UkP1c9NVtfZl1ao/Mm1+pxLR4NQV8EESUM4APRrpRGFCxSYsmIo3PD0lnG +b/RqygGHYRkTQkoYY7wh+iVUHxBF2pLDuEsxxlESRxVEJ5iciIfmps8Ehe0tndsATZGlQCcjl6rD +f3hTnXLt3lZ/eLhYv1CrLCKoVFap9JQ+2kNZM5dJIJPAo5IACufYboZ5VDw+NN3QJqFfIBaeVO/g +iQVKUQ6xMSbsZ7mz+7Ficm5p9vub3Tc4vaheqzUb3bPr9ep+fndXa2r3GwOGZzFA0ZsM3oKyP/r5 +HeaxCEGZAkhjvRyTkQz6gYLMQaIIPeFKLl6lqcFjTJnQ+4CWD/NDXzNhhos9oGAtLvCMdbYsSQV6 +ecUAxXZkRw3ZdYyDFS4amaVM6HoW08qcZX7U064YTIAHIIpTuBU6+MlRDGKAgGJub1+DzILGmGik +UM+/CsvNo7Q5eSXMMYV4RfVDsJgUK4WlmfIK3y4lepCLRiEm9YQ/Wue+Z26ndand3RYIgS5h+wYm +GTCFMukgc4pVMcY7fi3MVc9UywsupVAvn+z2LjP8T+5RwftoNLJaGGocnyAF6787CgogWCitNpX0 +VN6k7i4F0UU4EtM3IUDUo7iBprAdoMYzpAR9qKWOblY5yR8cjFhkROvzDVEWR4/R0MxEUGr69wft +7eYr86PTCzPn4T91IdX0GZ60rMyTSSCTwLFLgF9z/GCPnfK/CILTSgR/6Bo84Q9P+kxBdJr1fH9l +tPO/zOVfzQ9ebI+utXqjYidZXZoBFRcWahs7rdla0mwP9vbZe2pjiKFR25rYrFKXtnuwIRULBhS0 +SQagxTrUSCljjN6qwdolUgKH0rzApzdlgn/YgmTBtOq3cgPGbMEqdDc4zZomDFzWBtuyhGEwGw2v +6UCHgHRM0FbKRfQ17MWOF2ZAKRpQYKK3A2BTHCubPOTLhCJRsCFbFrCHjUTre1mojANKUeiCEAGK +nrxKxYfB5HoRzLmN9dJiJVku5t9yFTfSFkW71B+etCFoptRP8t3AUUqj+ircMoErsaLX4ESdDAU4 +xF9roli5Qz9noXa2UppLRx2Khcp8/ezOwRUSJNxXQCP02UzF0V/qImC/anbcd9FGC5qqmiYqTvtS +okDdHSO1LCz5vCTkRhSikwd5GjjVginnAZ+pAO1hpoAuzubtEcaosrjPpIpYvCrdJQYbsBRYHuF0 +BPea19q9/bWFD9Sq81Nyu+uNjNkzk0AmgUckAX5sUx3jR1TIvwCyoVRgJDyppk6RFU/YpimakjLV +vOjJyujp/OEHRsPL1blfdPJvHrY7qyfqnc6gVs43Wp1yqVQrF9k32GRs1ltZeihZ221YG4zaYp5W +qujX/GGrh/nC8W8amOW8/C2ZJti1aHCUvjQ7a1LQpOhLQxdaFcAgjRS3B2zBYzKyGogxXlQ2s6QC +DEYpKQ4rlpRhOfmStfmZ0tZumygGb0Fl8JLELOJlEhTQRcUTzgzuTE2FEqVkTKla78MCvQFec54r +JZYUMqPpAVizw4mcVX9SYOR7qZosshfJoQ94INI0NPWHh+f9zs0ke7TZ3XQ5ghBoCEtATeOTePBg +7DhcXMoWJyW1zo8Ks+UT9fIqGJ+2bPBQKs4szp7ZbV7rdljmnS+X/AWgjwKajkYg67hE6lfgX57R +X4XEMLvHgZEMIiUdYqQVqDceEFSNBZMmRYtImOYqCOKHN0ohDJLIk0MTDxujve0Rq3MFuuYPCuFI +pjFqnEMmwSpinNSR3f7+jZ3nVxcuLs6eSyXpmOyRSSCTwKOXALrx7g/90Rf3z1JCqlkCQQM+2RvD +uUhxhgMgip6NbTOEkB4+j2heh3Cv1eP59oVKYatd/O8be692W51hP+GMpa3tVg10ZKS3NAYtLBUm +O+dmqgeHw1a3C8V6vbi6WL2xAQr30cIaQMznlhe04pdDIeLMCS1NYrsqpVsFM2wYZx3AkUZ6ASlg +DGWNugfApIx1+AAOfS3EZcERI43ezULprX5u/1qbIWWgRYgIwHjnBkT0iukLGLAU2Vt0yIXpKSfl +LVwHEnpGd8KEjwatwNFIBszz0WDmqD5XfuwhQRSa0UDIP/XstV9vdTaCpfHT0AVMquugZtJHHl7V +bg4X4hZq5aWZyhooOdUlUoLUlZOF+Wpvf3SL3BwT1OtqNpRYvg2mJILGvFF/oFOucMgZySA92hdH +9ZFM4CjxAKHsUbDTXQ0S81ErRQ/AHRSiKhz+W1BJnErf7w3v3NJWHNooxdG0pvI8yAUzionqmzKH +et3ZfRnz9NTyM3QdiIxv/oMIZGGZBDIJHK8EdDTeWG8cL+F/dmrokYBDOAmdEiDKE9TEpTiKP9A0 +dO79aBqkokasHs0NVyr9317OfbxZ+kW/8np1rnfn1j6nuXW7/XKZo/Nz7c5Ac6Kj3Ew992sXlrYP +Oget5t5BZ2e3I8Vq3RrIB4zNc9V4e6BlJkCdVwmhoNk8CrYJqGywahDYBzUwOYraBHEFIST2uGvg +KFDHzhaUMlYp8IYdjNKXNodfYydPrWrxK3UxamiOFjrCVOZWwWMQgu4VSMAZBdDvGJk43N+rfGV4 +2eBjl61sJRtenLA47JXzXHz6IIfo0uAj/mgUYsPDM0XQ8LR6G432rUDKABVoqeIGGInRaBpRBEYs +iFavLM9W19iBE82aMnC/p1peGeWHXNXOyZISCMJVtdxriW6E0dRBEsXYTPfAOCPqABZtJAi0aa4n +aIokYCX9MMIM3DKQbpkzis43JPo3bEPa3lST0WsRelM1SeN+Nh2iuHujHDKdHiHsH94cDJunTnyk +UpqdFvi9ObO3TAKZBI5TAmAHP2J+kf86Haok0HRaWadQCoLGgb2kOaJzA03JRXhKJIA2lVQxtzRX ++I3h6JPD5rXluZf6OYYKi+3uoFYtztWruwcYrP2NjfbOTnthtsqOEDKii1GpByzWtcrG5uu0BywU +AoY4C4LJS4YHpdCtqXU0j7OAXsw8AnKs4x2Dh1W2TFvUtGdbAUJyoWmVC7TzeC8anBLBXaLQ+5iz +JMCWlQ3kwQhe8dP+oKzwwCPJJKIsrFXRMSdRZXiGEwLBaU6vYFhYZyLqqmqOrtiFo/nZVe7gicQ8 +kdtb+SOK5xE3DaXDEecwXKaCVIGio+LwM/62+jt799W9EHiYra3M1dbfCYimvNVKXDBeaHRuwYwk +X8h3OZ7DnQmV5UogXqQd+3eRqiTgsVwJDbFMniTmlQ4Hmchqi3a8+AtSVISUxGkJ1yC3v8MpVHRs +jKM2qaO9xhUMI9uExJfrqzf+j5ma1MAArEAn49nq7l25/Y9nVj4yW1udJMr+ZhLIJPAIJYD2YInF +IyzgXwLp0NeoabAwNUDxcDIwSAmHhOPwcMpgynCAa+SKNNCJZGkaPIXPXr2LAAAgAElEQVR8uTB4 +Yj7/eHew3cy/WJu/1epuo+7On1nq9HrDQX9zs73JeLDX4rI/ddAbAGoyMTFoDFotrn32HCeAyhSm +0JTZSpAsJtuwQbEIgRMUNCfiEh5a1SpVDPgEnFDo6NkwbsBj7J5hU8BMQWy8EXZ6dYysT6xe1Llq +ZR4wvKAZBI3xEMEaBnpJqWFkvMwFCmiUkSFlRqHBYIiPM41yO3vb+43d2frC3OxyhYOgxjFHAVVw +JaX/ABc4mqJpfsTFPpRKhQXYsO2sYibcGF2AQUjmk7naicXZ06wdpuGi7e5vLDJS8P3h1dIKJnG7 +j22qnpMudAcUXTfgU2Pm/l7QNPRIZJobLykX+ZBMUiIE6v4pKcSoJg5NRMwbbmMalUuBOFCXpuRb +gQzpx8g5i5oGazjFXcOkUNV0oukjJc8IdPtMYpwRYqNR5+rtH5088cHluQsinrlMApkEHrEE/tUO +8KZym1bbaOpA07BH45x9nql6DTQlC9kJRCmHP6WWpkxDnDJfKpxYKHxxNOhWC7d227+4cf3G0gkU +YaFa4RCMfLfbQ3WCDmdPc99qb3O7hbY9bA9kcgGo7KLxJTOsmEVFMrJKEFiFAkdHS/96yg2eeEX5 +omoDSChaeEYERISNHoH0nhbog38c9YCqBQkAb5zsJOGh1TfmlHGaV8JDGTOqTNGYzqH6CQx9zRP+ +MYv5SPUHfojkOCNU6Tns7O0AqPPch1dfKVfqTAlGkmgC/NNtMe1PEXQKUJOV+Sdv7fyUAsKGC1EI +tFxfqIltdsHWF0+uPFHmHh8OMGJkPRWNIh/gHtigrDpOiuVm4RqbTTm1iuFx5E+50V3QfHAsyg27 +0wY6lQtmeCIQfexgT21kY5oo8eiUJKCrxv16WPNqLCdTjklGAkmswV4agX6Pha/KQs2UeeChcxO2 +KS+pKLQ0yX0dAkVc5vXw5tbP293GyaUPxtTphEb2N5NAJoFjlgBqxyN9x0z2HZEDpbhhlHtDZ2Zm +1tbWzpw5846yvZtEoTSpZGht1DR+oJQnDkrxDJKpZk9vjEEvExVoSuw0rE5nnOZIV5fmz6/Vzq9U +O63Om4f9q6PR1aWFYTGZYbC31xtcfrMxN1temC0dHPbLzEfmi4zxyvpC9/GKNclYIptVvHrFo7aC +rlDozGjiYJzJNhwKE7UrXLO+xngiaqx/2f8B6GL+xom+pAw7iTP0OTgQgmChlr1YoVvzyu4s5Fjb +VMCwG3Xn59ltqRMb9g8AKx1kCGMwSRqlVPlS6/zX054IBMr29vf3D/Zn6pioq7XaQgBqKt4jniMg +Siwh0OM5W11dqJ/ZbVyrsvOoJ0uOpyprWxAUGRRyq8unTp98QmxMRunx4MTRxIk9KirYkYvY8POM +cAKL+dmZ0vn99lVOqpLNbVMSCWOMqlA+EAiPGBwHBpjxVJkWO4npu8AkjlZgaTdT50gPa56rC4BY +WhNnHo2F5DPl4I8ElMi1ffRdRMddByW2qFUQIUFBZCZtAcY70GEOJD37iHQRevPc6scL/zbW6kf1 +s2cmgfdbAlrBO+7iHk/Rm5ubL7/8MpeMoqFQT1yR9vTTT6+srNxP/a/+6q+4avTixYvcb7qxsfEo +oDQtNBQ0/ISaDjQldvr2N9KkTqrPOBohZARHyYsnpTntTwNTTyFfmSk/yWc4ajc7N1uda2tLB53e +3p3N3Vs3D3UuIOZxUuKSmaLK0N4LEE2TlGxiMVKiRosFIrlsVWpUE3UeSNQhDMAkcOhJUDBSu25A +OO/kHA8PetQXmlLooYLR/tbL4tCoIISAIDYo45alPEt1qsnaUu2parJ6tfH/HzRvMZnHMbA6aGlG +Gh/L7Igbq36LRIIxnKhA+xvNZqN5ZaZWP7F8sl7lbIS7q4pCqsgz9YipyWsExvPE/EUGzNu95swi +9dBxephc0Bfa5nMXTj++euIsTRMNFB784YJb6PA6zTkh6WsaFYH5ET2gcrfTR24s0RJmG8kEdR5Q +FbAZTXniRIlOif14wF28sdqLWIxmorrcM8Shyvvql0BHJiPOIko9QU2kXAqv2p8zO5Jl3K33hwwF ++CI4ilOnQTzgoXT5g4EJ0Iq2q6snn2LuoLl5Y+unZ058lF6KSsxcJoFMAsctATbMMZbnX95xkAZH +X3zxxZ2dnZQYV21j5D3zzDNH0HRvbw979A/+4A8wSdPEj8ITKhKNiSdwlFJ4ZYA3iiM8HPeBExL+ +UOu84kFBA6uE44kEqf7lddrP6/2uwMWc1cdnc48DlJ3hwfzaQS+/tb37Rre/O8i3m41OuVosJZV2 +r9/tDYBSFeItp4GpICjNg9mKmpbiZvcLt3OG1rZlCdCiNFlnBOahu2P5LrN9nJhPYhAXba4EvgYV +IsMRxEr5AdtRKXm2Oju3MMPxficrxeUippDdXP6jVzf/ClTmxuywgEVkUjeowQj/zY79jgoU13us +fbXSP6QjcfuN2Zm5xbl1RmJDsNEQ4UewqSeEH88ojbnPtaVnbmz+hArNLQr7Wweeph3mLpx/YmX5 +NI2CoxWmn7ziJvyqTVM/ngdG9fvdRmu30dwejLpxSLJQzTgaWCUa7oIQKOw0SQKDttrIsTSHAsFC +QrwKurGruwFIzjxr9IpSAYorIsKi9chBhBBWSgpJeTRbOZHvn+oPuoftzWZ3mzoqMY8Jmiq9+1U8 +9Ts20hOGFyLqAXg6fK9xq1j4+anlDyt95jIJZBJ4BBK4z9Z4r2XwOz+Co0EJZCX8C1/4QijQCMQu +xPPmm29+8IMfnC7wL//yL5988skPfOADBGLdvvHGG1/5ylfw/83f/A2DwK1W66WXXsLS/fKXv3zn +zp0f/ehH0PzsZz/72GOPvU0aNClpzp8/jwewf/7553lijz711FPYxGSEDdypU6deeeWV06dP37hx +48KFC2A86cHXy5cvExX2K1qYahKOk7ae6OvUA7W3doWKDq7jc3Zh7dle//CwfSe3dLCxczWX36uX +O712o1IurMxWC0l+d6fV63K6EeuBfasaurVcxLhhmw02a4wQoiyBXdARB+6iYdGkMgo5wIHdoqVC +qVKsFGcK+ZlauV4ucA5OrVCYKRXq1dJsUqwX80zMPtjN104urVXbzOVCiiFiHDghENJHbgIhAgL8 +NqmttxXJMAdqPRLCFbtM9g72Dxr7C/OLK0tn67X5aeyc9odgRWLK1ctL60sfurXzArtWOCiY7gLD +pDPV+dUTp6bhM/xukyh5ioSYhLuxi7aLF9K3u1jP283OHgMAQDVDsjEFK7w0OlI9/IJV6Eywiuz6 +CoccAt4QAtuNiqo6IIqDTy7dE3zibHHyN9ouEkR4cAaD8E12Gs4yY7b8RG60DjUmcTlNYnawste8 +0+ruFISZ44VjEj5vfkZDCOXFqGgLeT25TnE7jassbF5deFIRmcskkEngWCWAJkmkgo/DdbvdaXt0 +miThxFZZzjFxs7OzH/vYx/72b//25s2b4FwtTijI5Q4ODjqa35PDw2v4sW5//OMff/jDH/7qV7/6 +7W9/G8QFWX/3d3/3Zz/7GYAaUPr2aQJKUdwf+tCHyItN/Hd/93dAKeYpWnh7e5soWOLe8t3dXcac +Fxc5uCeP9YyMgFWe2KaBo/jDE0qZ11Q74w+Gf+mzlHDazuMkWzz96wwBDrnya6nZ6e4Nco1u9yA/ +05irt0fDZrWesJwH/YhmLVQTrcsd9jnSgVUw5UIpny+hK7lmRoOKI+Zeq5VStVadKeZnygl4WeO4 +Hy5ZxYj9pfxMJ6iWFk4uXrg9eokB3hg3Fq5YfUtLW02PDZ/AV+KMN8IJG0wSg79XsKeMxmBWJAGo +J9fOri6fY/lXgCixKZoqqV0qT94QKSctsARpY/8VIIF5UwCv1zrc29+anVmcRlBS4iJLSgcP1OI1 +fRLCdOhha/+gud0bHCI7KOsDJgGWquR4rBXh6s0IKiOPBKJocPVoLVGUSSAFg8HsuKUtWefMZQBc +EmAzUgnwIA/lpb4TM1QFkc2hkjAerUXiVr9ctbhaGK1NcihXKQEIH+v1V/cObx2295SV/lNQMM+i +QAjfB3MbnCuNiuRfbmP3FcY/FmfOiVzmMglkEjhGCWiu1J3ch6cZA6RvRYfYaSgl2Wc+8xkg7bvf +/S6Lj7AysfzeKm+EP/HEE5/4xCfwnzx5EiPyt3/7t1GIACR2aprxbdKEdqbEULhYn4w8NxoNIBNV +DqDCD1EEnj17FoTGZgVWsV/JgkmKyqYUUuLBBbXwhD/lAU8o9OmQt/OzLbNQRtOBfNXSCaX0mDd6 +lpG9yBgKkye6dWLvoZGZSf1lGOk8QeRdPU+UPrNdvlzut2MgXIAxgQLhomFSprBPGRTSAA/xHMIh +gKMUggpJQx4lEGwMb965enC4fXr9qfnZpSMgiiSPMBmNxZPbxPrD9l6TZVw6GbiQH7x565W15fOL +86vE0hAuSKiRCj+oTdOMlmp3DvcbW4edPSaUAT9NcE7WMVER4SUuwJJWkXcCpR7ljl4FKcGtyBjQ +SDJeO9wi3pE9yhACZqsYsqxESTA5lono2imNV5xJwqSlb5vPz5TO5YeMXrhsJ4tKwX+5NLO+/FS7 +e7DbuN7qNBg2cDalZAEaDGhBmQ8v1DcjWkR0dbcufN7aeZExc86vMNXskUkgk8CxSYDxwaP6673R +jnU65J1WXqleS2OniT/++ONAGoO33/zmN//wD/9wehHQdLLwp0gMffzTpaSJ3yZNpGdt6T/8wz9g +g2IWk4tAhppR6KBmpVKBSfwsgPrFL35BGvZ0YOn+2q/9GimJIjEqO9LgwRFCBaOO4U85CU9EHQl8 +h69o2GLhLQ+Ff4dE3nOyUmHx5Own7hS/z84NztYHcqSp0dvAp6GUVVla5ooqt74GBNHgrNpdXz/L +7CdHI3Z7zcNWo9M9ZFVyQGSgFIq90Wxcuvr8qdXHTq8/idxgkmd4guFUbhLuZB50rnyhN+h2k1ta +CUWxheHG3uVW+3B1mRLHa4tIHNSmn44dkhLswZ7rdhsBNioZbANjgB2bm/gVOOXnNX4eZlNoFCCK +HBQe0Oj5SMIxQ1kYBYgSDh+SD2ksN8nORzSQS4CqKrtcSuQkXi/eRsjMTFeLZ8Y46rzTD2oXNa1x +Gn914bC9s7F9ndviVGmXNF51TFPBXtwy6/xwGz0AZMkSpAvrnyknc9OUM38mgUwCDykBOsGhKx6S +jrJXyuVOlyNppc6mHeHTr9N+AIxp1D/5kz9hpBcTk6g0O+t7p1M+vJ+afutb32IB1Ne+9jWs5D/+ +4z8GOIFSwnEAeXh4njt3jhnThYUFTFIGn4HP1JEFEOU1PIZUqTE8PMnLkyqktYhXnr9ybrH0bL98 +6U73FlAaJzygonGofqlu625hArBh5EiS6pn1i5WKejkIB0cs46j7B7s7+xut9q7ghOz+diCfWxuX +u/3242c/zFJmRUy5kB4ilRztQs5zyYVWsdMtsJJHt7jMcLJPa+PGnc76ifNx0FLIP560EvQ73Vaz +fYAlOhz1uPCFXHHcBA2ltopBXf8ChKNieeoZ4U6p9B4CkEVOLwe/eha2YjG4OVOwWWgccMKVAvUR +IUEaTmcaef0XJj4p+ahojFQCjeUkRwbsgMLKHLFyzIKakoe8iOHIc7a2PHt2aa+xub17k2qKMklY +2g2K+1Za3RjPZh7vEiZKZWrXcndz/9XTyx8/Qj97zSSQSeBhJKAbMx4mf5qXMdKV1dXNjQ3QNA3E +A44Snq6YjShmT1lDtL6+DpJdv34d3cdAK1E8WU8EUL322msvvPACduE0qYf3UyhFoJdff/11qDGc +i8aPNVCBqYaAAnOoly5dYqb205/+NAYryYiNxCQgezzhk3CeyJAqWOffnUaFfoREVLw+fBXeNwqF +fGm+/8X+0l8ObgobgBn0vqFhDBNjIDFwwNX87Pw0jlJrpJRUknpt5tT62UtXXkLjg0CBIhoUzeU2 +t2+xdPbiYx8ts2r2QWiBAANE4yk86J5rNg5b7S5YDvAwyNwb7l+7/RorhA1OWgY9GPLsQZknTANM +FKqjEwMUjZfy48E0BGGcIF7xuw8wDlQUFffoK1mEgoY9Qihao9+jHKcX8aGxA6vIElOYEI/x21hq +RDgGa5RCeAz20kchGSAN5bhhrVvYLhU0ZIJLv1cIMw3BE99AxebyS3Pri3Nru/sbG1tYqLoFiN+f +klN6yccpm38sb6QH24QftG/tt27O137JlEqUmD0zCWQS+KUS0GaYY0LSHPYly39YXrS/t5eiKTg6 +v7BAOLHT3LC0h3FdFATLcYn60pe+ND8/TwIWFrGq6I/+6I/I8tGPfhQ8m8718H5mW3/wgx+wgomp +0AsXLnznO9957rnnYAOH3od+eJaWljBeqQtgHzgaZijPcIGgPFFqZAmNH09eoZP601cpvsk4ZCR4 ++Oo8PIWUvSA1Zhv+LYqD7eJLv6g/9UTu4I6AaPxVMZwKW1UhQYtdvrnf2K5uaQUZU3rcHGZHFO0r +K749Yk8IRwRzeU5kUd48x69vX7ry06ef+DhdmiAED3iCk3h2e912u9nutrqdjmY6D7XJcly0iXAD +9tb+lcjOM+hDT8a0aqLEgSJEAWZKQ6ChFI8SOFx+R/mPw73viFdWEtGPgAjQ620tSaF/YsgZVv3d +TgfzGSwU38JOnxuMZUlKLQejaBEdUxMwe9pYpPwhm0bRjXMw3B812IvMHipzYobEjVxIJvx88fAg +44DV5QUA9cTl6y+zUA6y3CPERiZOf5RV6u6LeAvzlCMgCrm91qtJMc8V6EEte2YSyCTwMBLgt5l/ +6t//H9/7T//Pw1BJ88YiXpa/Mnwq0lapwBLuCJSShQTMXGKtHtlaimog+/3p01Ie0gM0UnSsJMJI +jcXDFEogDp3Pk1cWCQPnrGPCTxbC8fDEHx78OPzxGh54I5Bn+hrUUp5VhqGCkPs9abJ37hEPlOh5 +3E67HWjdRrsPMLiLg36v1WLpkICww82cgyErZ1vNFuOu9B1IT3ZQqdNqUWnSgFi9/iApFqgm8MXl +YgT/uy9/6ZMf04IvnBAIDJXdZYxyiEInTj4hk9JFmFhiWarNywErfaoDnX4AjBnJlCbPoUVnL5we +73pEdEhGUh0Odve2t7Zv7x1sa8ttXsYejrzhVIKD9Ig4P0U8DUnTmyPlFXPmDo9TTj+JC0yPlKol +JqmnhAkhd61a6HXmcp11TraiEE6G6o8OuIyl228xdipMjdOpwGDjHMRpH4BPoksXLgl6ZZjyDFbF +M9jPeUlJrl5eq+TXo47xVJ/FLjw8o+fHE3+84md++pU3flqqDplRAThF0+uqyMqXDiMV/gmk3Hpl +fnn2AxzKEWSzZyaBf8sS+MY3vvH1r3/9YSTwief+AxdqHZsDn0BNDM2AKxQiISwF4nl/Gfz+mYy8 +PxyN8OhwlOLSoWYKglVC4BN/qG8MTTwMMtO7Z4dr2J3EAjk4PGGPUsHwSON7mDc85KVeQTAgIUIo +hdc+p0CwDaPH2KPgHDxDwZEd2wbChBw2DlDd6PlOu9VudyiOF46OAkhYINXrdLosZTHMEM8mFwAK +ImhGFCrIgx/6aGxoCgPNCn70LnTQ28YC6W5V00FcnUmMwEXfA/7rj49RYl9HpVwyOzJonC6iSTFO +qcQirELFg18jyITwOpCHjg8ssByp2BPeD3T9qmL9HOW2dq51+ntJfz4/qCflhDVgkL1z6+ZeY3tU +4JQmowI8+hO5lFXViseElAneZUTlBgtKF9kVOyEVIRLPJJnYpOPheiNCVU6beoVMHJeR5Kq9xnp+ +eHfegfsMyvkTuQLHXNCv4tQqxpY7YOpg2KZtexjjYBjmIMAJoPpmAqiOQZRCXXQwKd59h8+osD8a +rY6t2buVUWXj68STrxNS5xlfEjy9fmdr/836HKdUqgqYnuMqW0owAP1ywnj3kLVNa/MfSQoaB8pc +JoFMAsciAW6G0U/4WBy/bUb2cMdC7X0gYqwZgx9+tBJKCgf8fO5zn8NgxZ9qq9BchMAY+El48/AQ +u5bEzKoCkGyExc4jAa8Cs+EAi5CUviIGe3bQ7rZRngGlvPa6XWxEYJX1rhDHSaMbAlH74J5UOUEC +QKJUMB/ehl75o80wEVLgXUqWJWQkIjApcoY+YUIKdg4HTJBXJQgoTNc0I4wnQCvFTqdBq3K5MEhJ ++ceiLHgQTIoWMf4nvqBGlB9psFBVUSSMP44OmSmsDKF+tdtqM8Wsy2cms3dEtdsHxfxBa3tmNND8 +PQ7jtDDippfiqNgdYZKKPzHNf8AvakqI5OJCHTP2jxNEeiKoipi1MANaHKiwgBx7RNOjr0geCiqR +0VEP2+rchd5qnmMToPUgp4lRybaSTGY6qV6jfX3/cJfkWKUQF6t2ws6UJTM2jtAOKKLapXwjKTyg +ozlO5j+IiL/Y7r1+m4vVmp0Nulvqo7gDocHtSEZdPNZNh5YvbTVZXJl9Nik82lPGxmVnfzIJ/JuR +gO+h+DdT26goa4NBSIajY4QTRGT4sd0C8piVY0SUNSS5vb39X/zsBVI0PRzKDlQCGQhtHjYxLVqN +Q3QthgDGRihIdCXHLKDcomcivSmdxhMvf/V/8opH3pIP2y3mbYWLDLaKoAmP+UQ5Bw0j2aTHYzrC +zpRg4JxVPJZKmJsUayJS7kZVEoWZI9IEUpAgAcDnTx4TxqatBm+HmlsDFpREieWwYnn6lYc0eERC +NE1j5hUXIXrap2I5ocf8CEEwdZk3PWwjP53/YFnAiwRIjWudfkPwLcK0CiHD0nBAfTvDEng6Tq9c +EJ+88nfMEeHBgeEkiOsZuEXuYCmyk8Z4SQLnF0HBEw1G7cni9PhHvfl8d92n/TvlO33kq6XV/dw+ +AwYi6+IiqyvoupiBQFYFuk6Iol/aS3ILU9I9WiTy7PSa7U6j1dvPFZpaYeTDmVXBqB05LAT4J4zv +Gp2RhZkLc+WLjCIDw29D/Ghh2XsmgUwCby8BllBoycSvmtNcrEdWw8MNZnS3sfZQEJiJLE4hHNDD +NNzb5biioe1FcLMNBGLLcWkLhiAKrseIqC4m62oOtKfFLJANVYz6kfrTWBwnBoF3WKIAlUOGPsKX +6BK4pZUt45Sa3gsURBvLAy3UcTjNSTp7AACBTDnqhF0treSAGxSel6yoUGWC5rg4YrT1EIDBaNY4 +XTFfRDkDPTaDlFRAqdlLFWtjVS92geNjIw50YN0rKhbrM9q9Uix5bBlOGZ5QgTZurdTNiKxjGFJM +qnvxKNBI50ImDyGR2YZliiAdr/yzR6COg3RSKvY7SbfZq2IxwxPERE8uX+4XS/RJyvwXBTKwugkh +c2HOoDsqD7WfxMIRuE/aaJw3Kk0BBg8BiP3Eqh8yQTKqok+Uqwq7XHsIx5hTvyL6IdAZ1fKdtcLo +7ohulPUOn5yHUK/Vm+2GvhcURCl+WJxuXwfq+2O5iQGzNxg1cgXGKo4O8CBzbdht73eEoB3G6ZOq +K8r4gZcXTVOmH+Xvi6JYk7BQfrpSGl8soXaCE6XOXCaBTALHIAFGAv8ZnHSqf8xaMiPNKC6YQgTR +NCLq5TB6YjsaF/F3O0wEjloYhbpqo8tCIAJ7XV1gxcThcACIHg7Qv5gx0OMoPqBG80mqnYZjveIG +hUUpgAe4QVlEFcEon66XVDShi3IJ41LZrF7JyTyfMLI4omglYVpzMOKkXJge6loW60T8wyFbUwFj +MBlooGgAj8qRHTwej7eFbgMdZBGOZJWRjOprqBPEJL1gSjin2cW7ThkUENqxUC4yTzZARyZMsmK1 +kVt2JDW3Li4WhOoM1UJvbM6KgLbQMvarWVSR5w17lM0jbgRBOfhCDnSy+IBgiI8QAxdvtBSqXuwq +HmZUJv/FnAsaxwrz1cQRT9mImRC4Ii8FJ0mp3x31272ECTtKFXdiHsGxambYTtjRYrpEQGVIb2bY +L/eb/SHD2zQYTaAd0aNYqhNIrMKMkSImiYgm/pBj+iQk+i1RIn4+yqpsxlE6JJqzLBd6a8loUTVW +Jc2Okrw7V68sdfsNJCz2goYL0sOoqbrDrUeSxYNja1WOHG7khyeoJAkRQZczmls7XC40yLWYDQ0b +VBWJapoC9PUKWR4myGZpeiTVZH2m9ERS0L3o7kXdveYo6L+7KmWpMwlkErhPAp4Uuy/0YQKkQMeO +Xy7Iwv+wIaVONDWogVSZlXjbrZZUPitxwi7khWU4sUrWyOrFswJZwplf5J9VC6gzJgoQyGLjViwf +4ML6WuzH0bAKxIFz2gdPoWCqlKUUYrknNgCaMigija9zYVDhgWfWmdashkZ0P/OOFEo40IMyMgJq +4NEaj7PGgV4pSFSSlR5bKb1FRijO5R5ezwkRz1wJ/HRtJKU6FhLGC63pQX0zKygAACWoK8oOpBjr +XrxRik6uzWO1qUTWT4X218wmoKa9+WH7yD4h5ajImjJ1G8KcBY2E1i4xXXakWjJdTgaMXXKxeFci +0EdjvK4ZZZW0g5KeAfWmqijwMWPkQixUSMUoKhpejGuZLzXhv0SnSpMQruBGy4gLbIEc9Zv5QaWb +eNpOwF3Q4e/5Uq/Qy5eLZX0xvD7ZnQoT6jONzXSihoJH0KBK9G/KPUQiUDEyiQ1jcwgHmhFOgwm0 +HEsCAqkcIcCSYJ/uBUw6nHYuD1YLPU6TJwgnKbxnVyrOlFi2lGPk4y6h4I3SgzfkH6AID1GRBuDb +v71U5xKCwmFrl1PsewMOadK1PghalXJKEkctqF2EiFfXxR0hTqRcqRXPloqzNALynMZRGkIy9Vf3 +Pdcuy5hJIJOAJEDnO37V71wc8fNTXjt7pNuBBwLiP5gh2GAA09Coh0wfBeKMqwZZ+8kVKsWGi37e +gATjr5h9EC8WkuGoxKYOckOdxTpQE9TISUujUXnHS2ooM+zHik8ipLiTvDb2DQQWAhozGZpxrEds ++2GGEpigmHP53qAvYDZgAgjFChDCql1mEIGWPFbvcICOAoOBaXuoBA0AACAASURBVJQ6rqwhU4/O +Yb5KJQNTaGeQWYAL4jEqK4Jofd5QXfILfaTFKBkMRV1CV4ECdvR7kmeFiKpAF8Eq3yWRnmzUXR40 +Z1JEHC4djY99CRaqCrKzWdwLr4ZAcSuYVpzayXBrGoG7SDjPIC8ReKgbA9HUOSkBqtjurIoimRwM +C7yM9LBjUgSqOvAyrhRsUBnnxENMhwtu4FHyoKNACUApyXlhmS7dnFLvkBts2uVaVFwXs0BUQ+0K +IIOAw18r2MM45T9fF31haHoEzKJahhemDzACUZTTHxGZ+F0uAWPQAoT8ogSqu7oKGjlPRieKfVbP +snYZJsTGW7moILHRlG+ZLJdUS3O93pbwz0Rhz/IaoyYMAKWmo5vy6Lbx0/HMA6vYXoFP9tvw1H7c +AFrjferXd8aOkGBXUUxJ55fKudNJniOhxntP+RIEzynDaRXGJLI/mQQyCbxHCTDu+BbqIv29Qfmo +P96t78gtEHUigSlGoNMHPKDDUaiyr1DS8vDAoNR5tjrUVoqY8c0+k2noaHSCtARwSDpgQoNsxZ6G +SxUvdEN9ghgCA7LCuO7QIFKHxhmloV7EfhIugVHe4iKrFF0i+gSBqCNwRheDYGqO2HdRKJSAZwAe +7BBzqCGNgwoKWexCSoEE1gkssRh2WBRW45guhRNxT7zUMH9iDNeMacoNHSddDAFxILhBqbFdU96E +4UrgX6jFfnoVKYNBa29k3knNS6QqWqPJ3BrTg5gwEuklOlXD4CXLVGLVHKqYEre2PckyTHTpj3Kw +K1LbImkIRqrVwyCVSAJx4BtcYhQbsVRgnnvZICorFU749HPji3rY0YSBrpEBdyHgjWaAK0YQQTz6 +GDL9MSm9h1UtJWpavqQvi1oMR5AO70cq2Ffs0THKV3r7xXLSLtU5Ro/1MLneYXXoVAgMPvp0YEZ5 +ccsfgiBFhWFZxRI/GBWZVRXvKlDCtTd9VWqFKJZnJEhRh14G3zWEJKN8tjw8XxgxtMo3mtIsU7LY +ifu3cA+Mms5eLs4Xky26eJTu78TEBtUbbS7gpDQ1k2onZGUVvOvS5UkbRxXcLAhSH1XH1HiS119e +5+XLlVtKhquciEw69aEmji8Yr+lzEqy/D6zCdILMn0kgk8DbSYDfoNT9fW5aEUz7Jwn5KRsk7lU3 +xKKBQVNFR5R+6GFFjUOkCML2ITV6XXijXzK6UZOUehvzQ0Ihp405dD62obCX02CwT6RIQqVo+RCs +oMoBYBSgzFVNrclU1cqiISYhEObkvPi8N2AMqC1pxQ0UlTjWvcKRRorhAPI6FEblqKI2c6lQoYht +IFMbcrLkbA0rDdWkVOjrBg451wH2cSxN0vA0Kz9ADml/YoUV2FNW4aqUqq8KRSy0nN8GKPqVYFU+ +yAJv5ipP7ZAf0iS1MgtPnA8+6SAYU6FKrrGJpY0WOJLTPWFaF2hVWyGNNrTYNZvLVyrlWjWpVioM +DEDmkOXL7Y5mMz1uzRPTlDZS21NXlyv6Brky49+GSYRACq5I4TuAUCRAYyqxah04YHTB4xbiXLKv +DQ5mCmyuTRj8T/rtCsAgaQhmSBLCUDnjCsoTEssNil2dPADr4HI8JROy+6l0CuejzKrIOJnlosDI +XhotF3vnEaaKmy5QSe5xwdg9Qfe+RPbpZKBarVptd7THFB7Ux6I7Gde8Iyx+H3BlRGf8luZVRSa1 +wBPMR0Xc9KqUPpRLvTgqgnGFJN/rFwuDxeLwRDGPjU+b6DuEAO/lTm9uR3/DyK1+lfzTDN+fJQvJ +JJBJ4O0koLHEVKm8XcIjcf4dPkjjWFdAkQT8NkEJ6VEy6wWoE6pimejHKxjTFjrduIxuIR68QMXi +kamk9GTggbonsY7o828emGNElSQyqfhol6X1BWtZ0NXq5KNmUO4qyVjJLBHpra8wQVDTKDFAUTCC +llI/HcYwn8QtD1JSvmYO+SuMZnyYg3ZhTELgFU0EUJOdkhh/lP2LlxJVM3K58lJYqoLqKhlTOVuQ +QlI51ZEeABmENkxGAs2BwoAQvQAdtiDjlV2WGmAGhhmontiUAD1cxfyrZEGnATmglIFDmaqYj3nA +lJWy1JN0xVJX5zsgfeqJeEZMt2KL47paNwWMCtooRzJTNQV1TDXP1it8eKcCJELa+NTbiC6QBWip +KBMtRnXUCRE8IBvXTMO9JgkJy4faEWsrU81aKhbLZQ8m96ocOI88mSSFAZzGyA38k/almfzFE5cQ +HfXz7UJpwDCEeheGHJ7EqSiDkzjHAzhRM30lKZEw/ioNd4sCncinuZeU8mdJpFLV/vc46nXP+9RL +GjWdKw0kYYQTkoyWcrmbtGqM345pwA/D8j77CcZUTCD9pArik/AonyfM0wIe7FV1cK5RNakPukuV +wZLKsegcN37AQwgwDYQfQvi+4SF2muE0TebJJJBJ4F1IQFapQOceN60X7om470U/51A90wpI9KRH +I3lQj18sFojMRdS09KoVBooCTcciFatpftWoV4hJ5UkFGHuBEhS9lCKpMbf044cUQ39awgkWYwEJ +WdG90pRam8T8mbZQcEqRF+wAmigkFK7sN7ITiWJiGSxja6Ai0Vh4LIVlLFZzsS5J+0bQ5KTkUy7p +hnB4gj1bsphpHMEOvPVl62mqUQiDZtOcHmLFyhByyADUCDQWLvzbAaIQlGHMaVD0HlCKMaApH2ID +wzQArhdYxoRnyldzhiAiwao4/00cSOKjM9slJhw2MzY70SUZiEokJ43JypfesJ2HWS36omTOBIQ+ +S2EHZW5rLTDSzZE8miIFh2EKK5iaCsWLRQ6IhRp8oMbdhaBrE+xJyZtnasxfv6jW8iFmk9IWxgii +haJe3X6nN+iRuVKslstVipYINADqhKZEN4lG5Kks9Dyop8xZHE1ATbvDZFAoszfXSElVDTlGeTWD +viwkm2Cn+ld8qdQHkNPYAmkYZe4nG9cKe3uD+sybiwurVc/ZwrB4fpALZohJPZEqXtNcqScNbza7 +TUbKoWr45Ok+jQUJJ+ZTFcUvad9FUAKDFTWn4hRFEH5aKMnNJ6O1Qm+WYH5DablwlfoRGc3HE2Yi +kGfK2P11iRplz0wCmQTehQQEN/e69Bd4b/C9b/p9T+maeNUPXT/R8Q8Vpc87eza8IwNFjFrUUhiv +yyESy0vaWdZVqV/ANhoKgjyRCXFMIPQKJhUJdA4e6i+Haaij8rTRkOmlXD9WiqBj0bSQ4g9sSXEU +CyUd0y+XJNxCShnCdfjhD7pYNqYUFPECCf4Am7yr8KRMBaRoVB2mYFVPtDhYRpIuGzhAQvcSMKzY +x6qEsnBHGFaAHKgMNf6rBPgHCUsykakOkViH6E4NK1MdA7MsSnoA2L6ANrahBuQUQE3MkQzlQbuN +JQ0eyrpkhLmEEcfpDsxRFtkSxCQra5o5qE6WJUgvq4XOBciENQgW0ndgNFedC+1cKTADDU6LNjay +imG6GKBNdAwRdeWoQGGpUUiHG5Ke03foMki0anT4gxUkKQ4BQEtV0M47gvK3gvy8psCpFgHENAM5 +avcanUGzD0u+EaXLGYXDVq1QL+XnoC0KMAUVN4G7EYiDLw0WdF+HJiIPtqKWhizLYnW07NFA0An2 +wARFiR2Hi2tzJo6QeSJLVH0bgHZY6O7Wtm7lW1yoWigd9luNg0uVWrlem69V542pypK6wJ77n2mC +4JlXPDw5xo/zPjR2Puj2+q3e4DAA0rLxlwseU+YtP0ndGEkVLE7R1teQlPF9VBdPIWxXrRRXtUIq +X0e8lBjPYC8YINe0hyhecaRM/ZE+TZm+qsjMZRLIJPCOJcCPXrbIO3f8FEkcz7u5HMgrKhV1CT39 +ZPUuCzCwil+w1AUqQYuBSCDgw6m/bOQwG8Il1KlQOM/AXZEorFGIjIY9xnrpyKPcAQ2lMyCBENDC +aNOoIlspwFxTw5ZCK6GVWV7EU0VrbQ4gaG2v4UrNrYoG6mmQkG1cLet96S/VgExCJQ2SwrTOeWc1 +CFtKMeZQiVp2a8CTfiKxIUC5rC7Jq3VCMA8tNiXIWkSBs8FDdqfBDaNLnQ9zQUEUpzPeBGSQlSip +vgCAVTmYr6B5gZt23L1AUyNiag8Sa2yWUgmvCQSN6aIJmEoGNIgwL+ghDNiCmLiR5lZ0oQiC0t9g +t24PMJfI1cho+mCVnRwyvHVUAiyqoeCZZGo/SUhOlDzmrJKjO+VJahLDEJLBJm4P93vFNlzRByJc +TJTYnttLkmaFA/kQK9zwxRC3aifJSp0LnUHVzbXzZZ0uy2YiMmJW8qQG4oenP4GXUI6vdBoVOER7 +CqJou36ht1c92Ep6bS3TLVcQpXgfMe/a6HdbW/ulO0mpOlNfrFfmyqXxJfOupWlD14KDSWrtgQEG +rfmisdkZAdKp4VD7ro7foB60I60uc59ME27hGRrBOX+dQK8RaM+YW2VSdqpGCD2jerKcFFZL+SWm +ZmAaN5a2vkb6djmHHnw/1C52+j3aHXklLM0eUdkzk0AmgfckAebxhBnv0fFLlV1m3RVU9OsVFDDJ +qAD9vEljG9PJ1DWWVpg4/9plU0qxlNAFGslliJTRO1QVg6BQwqwtokFR0F6yQkSBkcchtmUfoAJj +ZMdp+A/1qoU9sEOITy/yBozxubKhnKFBDIbasK1j/8QJCpzyBQGgjDdrwpXwkBxS7uAuY4/CDIZt +B8Jt6T1FUhtZn2OnTTBSaI5HMGNt5r8UqzvRYVPV4j8FM5+JjtQ8KGWIItqRM9GpsuuF5VVmJSdG +LOOfwIAnQCUvQDe6CLIskQQoBxkQV2uFvFqKRHAudOz1GC+XeJ2RgxEYAxAA8V+QH4uZ1Fbk6CME +pVMNkDBD07SjTTzgECEbOxEXH4kFe1eU9AWg5pj/pdKg1+HjBu4zfAotCAxG/e6w2S90scRZ6yS8 +oN7CUSNiqThscmtNE/7VrxHn4o+/zOe2+7pbrZ/vcTsb6VUUwIMxysdfNJFLCarrIP6gL9S03/0F +TZATghx6+9X2fr3bQlB9VsmqE8K6bL4N+g5RLQ4p5MM3pLc/uLl/eJt9LHMznJOQ4xbxXo8zQ3oI +hSIE93AqOYD6yhr1IqUcvOFRbeQnUOFRd3vUjdGvQ6wqQCMEd9MQpc05qozY1vcpX5mtnK4lqxzw +S1m4ANFoLZLxSiAeQnjiD8//aO89ACQ9ivPvndnZdPlOEQkUkYzIiCSyCEIEixxtwEgmB2My/Mk2 +wRbhIwpjG4MwyWSETRAZhEEkkzNIoCzuTtKFzTPz/aqfmdq+d2bnZtPs3m61Tr3V1dXV3c/02/V2 +fKHdWbLknBNEIBAILAoCPG5M79mzN5vj0ZstqsBHi4lKPHUe9DP6T0qsQ8DRMTDAZIxonQVWztYF +rV8wI2PmBz1MQtLZ0gczM4j9TENMK6mdbGQUVpoyK2H7ZWwkamNOqwKaON6fupJk3u1cvJmTqo21 +MLRmofgktPWSDAlTSTlLqqVB2SnyscVBTCc7bq17ZWYXDTaLab07fT2Vsy6auPQKwQwkKdS1WlUZ +0VKlVHdEqWoKJOvG5liLoE7ooJRptGjdLZuMbCRNgTCLDBUZ3dDDmvnkvcHysiogh6pk0K3ANrGJ +XaIwAGmvDiZmqnhl4X/m1G22uGrFo0BMhqMJ7Ow0i/XhBHmXgAZ5M+72m/EdguFhGyQapvBBiZlJ +S5jO+DC2YmBsb0ZyNkRGlznyRR5nxPDw3qlLJqvbsTNUy+pqP6PNlNtI1ETMfphVY3DJZ1b6Dx4u +H7F9+tIdo1dKjf3+aVkcjMw88OoyVB9CPi1Em43UvzQFStAqSErUJuUSgITJ72JLpwarvXDUxgZG +d2+cGhs0fhlwQI7C2+oB0+ZMNFNie7WwN7YBAJwaneCz4lMD1+0dty+Ammak7f+kPTU6y8Vaaqop +MUTZb2uESSZZBKxsSb4Qm/JvwMJ7BNrgpAZlaRG2F47+0lD/lo2DN+0vMzvQsJE8UA3A7Re0UuCs +6FlQzPADgUCgFwgwwcvjN9ecCk8s6fU0011gY3i0zQyZM1OCebFJTrjWy5gptfFMYmNX7F0a38yo +OePYiDaN6Zq9A2kxqdgpGxPYplrLMGVECoRsEy9dznD/EDZQZoNOycYWk1wwoNt6zSJh7DAfg4ND +tSG21WCGsAZ41u+lUUxSy26X9JVOFdeGcWnAYR1bMl3YEAjyIWcrMAumZls5WEJFU+eMWMNG2gDG +elIOR5ptsREeU7WUnG5Ws6hmrNOcNKWgLhSoMpx2APWVp6oc12c/FLdEDFE+XgSS5WJgTAFYvyxz +1T7F4MSuAZ0sPtgyFc0K87AVFgtiq7VAbpdJsWRNVdMvwKd7kgAbYnkdYYBnYmYch4ZsdRoNtg+J +D50NYV552bjooos2H7QtYY3a9APbX+u701/ziFVw/cD1K/3rpvp2sjoI4tTUzgsjgHyygtBmMCpD +w33XHypto0ibNxy+e/ya9Npivye1M8X8pNZcTNh+oWSZNESznysxrTYyVCZuzgvEL8DNVGazmYve +O7jruuHaxAij9zTjTlMAbYyotTYScWSWNyhrINbuyM2O5A5UR6amB7ifmU/+sL8JNKmMQUpJUjYq +q3KkPFYYSkAFmraTsBtRq0L6Z4VUjZBGwH69lBBmvW+YFy4uRpriHdLqyA5sLDwrDKywm9z+nB7M +/HcR7T6E6P1pivhAIBCYCwJsl6EX9BTeXTqnPaEU1ufkaZG1oD2rdAPWMTVNrK3i0GvZOIU/NjNm +FDQimFUmbOnJzABj2rAU1tFBs5sHm8E3tpjOpNsjPUM2O6JJp0cPaPOW1kvbqI8ZXRORw4Ra1mRi +vZWtaHKRL1YVw4d6lvw4KlLrG2ArMLYLTbaYyKZWDKQdkm8UY5ChH1OK9Itm7q2fpzKWq8172riU +Aa4Jkwm9HgaJOBTS81Fzq6nJ0D3TeVt/iXlKm2AZCzH2tCpgxcgx7ea1wyDpMgVberU9QnZpO1uB +hgcpJZty7eJDFvXILd2vyAyq9b68ldgeIVsUpUpDduKGXK2nx4ra8Aq4+CXMVpfqLLHyPsKIlj1O +CA6NjAxvWD84PDI0PMIWJswm5WRHE5O7lF4ONOwnMqhnnKHadNDql0UoCs5Q+aChvm3TfaNT/ddx +NXK9NGGHa9J7FeXqq68b7NvSX9+MeUA58gMVvhs7zAcIrJbUgHrgkh3yoNkqeM0tuIY5tkccyUPP +WCaubGRRoFyaGhq7dt3UKLf68iOmaQ/bzVoe4ieo9zPPTxKm2alhes0qs7NJY+30Kmd3hQyXhiaY +mx4f47s01qjJlDEubx8pO0oAHGb9CKb/3Uym38GKZP9UVPwk2TCfiUki/ZoAQ0tJgFh7oQWxbj1B +qzODuqs6OE5ZLBtrcpYCXy7xZjzwhK/fRVzqS1DO5ZqMJnYeEUQgEAjMAwGmLb1r5AncrwaeQBPj +AWzKQtITeVq6L2izPnQuyaCi02jrKTCK1jHbKqi94NtjjOGxQSo20/ZnWN/NmAQ21ijZzjQ3Swip +tDhHb08Hl2yqzcKaBlNq1tBsMocUU8cxiZ3jZl9mMms2S8k0JcNLjFOa1UujO8bFZiEpuZk9lgYx +sZWhIVJT7kYVSW5mm//5x4ovFi7d98vwrlwa7h8m5zTYTBCYCbZyo4HumCrTnZulqzPImEz7UmyP +F0MOqsogEQ3kST9uWVN1A40zNTamVIdrRju9IJA7ag1OxpeULNGcxUQBq4lpIGXbi22jNDtnuG2x +VuMbqpjNkfV8lWQ9dy5gdCts+cVgjnD7whBjM8rhzpC1n8t+CRZXoclODjqBN/P7eqoCgWSjbTQj +2Fza37cu/cgYBCZL2X7NKw/4cpzTfnqKa35KuG390deM/YEvZhtXBjUZHiuXSTVGbyLMdJmCGUNl +AZsMwL5WKrWt5drWPj5zMF6f4hxPrT5olxZjim1Tt/2a/KppHM7i7sTkJBzmOQxjLpKijfIygRyS +5M2fvvrQwGB9os4cgN10gRp757NV3oaBTMYSfipRg2lmPtl+J6ixySch3o4gaFFWj8REzO5YmLJ7 +qfiXfg2rN19GY2A6xTcdpq8b4exVggufX0e0FXBf18A28aHdpUY/44mvpND76ohQIBAIzBEBXsob +fcBcEyabas9x86F1mj6AR5anXc+5PbTWZSRrQRdmQ0lWRum+0rsz9oEQhtN6ufTPejvZRyyj7Tay +ccOADQxtjc/uum/cd2+zrOSOHU06MNY2Acc4h/lek8EmMyislLCudk8633e0ASpFpjyYL9bPzMDY +AiJDAjhM4VGJVF5sIaLoT30WV+Lacf5BukODKfW2mHMzs2bw6FkbziaiG4MUgDFDaHuNqA0FsK1S +Fm134FmPbargkB1jVjpo+9YMs7jJUlo3TNbWHaexLGu6GGOz/NbBmk2lH+ZQzAiD0eERClGq9A8P +j4ysW8dwk0ol3OzdBe2F3pYyU4BmgZvlRqjpLOtkTd13YThOi4BDFjktGTFd3k6QWtGb/zW1eHLs +7taRG+6auLjaN4qUVdSqbr5hbL+KDdqS8Ul8Y5kdsjiMpLXikfL0lgrXFLAwi+O9hdMybCyy5jJF +02FOw05RsZeY4Z7NQGDV7cSO4YzT78GPYTP4TMjzm07zYkZroznSgEqcvZq0DwfYFm7uoEyOUtk/ +2UjR7tt0P3VITUa+agSTdskH+qxpp+KniwM5k2Mvdqn5SKGUM6MA6lPTu4f67ftoghRfDo4/aNDU +A75Vh8QpKF8mVHz58BXlkiLEDz8QCATmioCtlHkaHiceRQ92IEyMhxaJ9NB6KjgpfVOnnu30VNOJ +028pC1I2DaexE41dpP8iNUMz+iGOkdiQiGxsr5A5ZhynmDOFwDqZPSbXZMaSKSMNvSUm2Y5yDpY4 +C1mqTtr0ZppKtXVBjJgNiGzGFXvXP8BJz2qNDaKqMb0sVbFO00QwRoZMWl3D3pkNtLm2NPEH34rM +mUgcU7OWvaWzPt9qYMMNqz+mALJUG2YpLo1TzSpwL26lgvW1HtwwgMPSIJoRtylrBsm8EFgErx12 +3a4tFGMgN45wm8FgZXjYJmMZ7HLvMG8BDHD2dYjDsN/GckjA7CvQGmokUcLkk9DyTa5LJVJLCtCz +AgjTZmZtg7kwqfiw9pahE8amt0/2XVU3hFBijYu3KWsThkdjbAoNtLyBGMcWMTeWJrZWSuuA0LI2 +8RlnC+JpFG4/GTO64+O283uaFW77vcwOphPDgKVknNMlU7ZNkxnTCUwZ0ObYhASTdmG7vUrjFAl7 +a2WwBmPZ2itSClIkjfktNv2zklPSFGtKWFKxQa1VcHzc7q9v/EqosixmSg7JOw8NmhwmartG0gY9 +osFNTrQnAEP4wh+mCHycm9KcgO9iriSIQCAQmAcCPE1ssGh0uAR4FAta2jBdxuXV5zX5qS8jHdOk +tnppCnloIaxnTObPaLonmyi2P8kRZxO9acIXU4nxpMOzq3mSBU1zcrzLm7SNyexwDPch2Iyq9T+w +7QXf1kEJTk8wkuC6dHo4hiGsKDInZ7uS6DnIU3abBEwBclqESVR6OevhzGxyVCRdFGQdpPXVqfBl +ZGyMmapgg+lUQ8YuiUI/txxYr0kalnYpNoWk27UqMjjn5nYmrUltPaNNCOOngpCCLFCGtSCxLY1u +2LCJ+Vjqwn5Zu4VhiMlFJqVn+lc0q1D40ADkQXHyYCtdSJ4LKKrgd5D3tMjMVkKXmY0grZLLB/OR +yqEDtc0TtSun+6+xFpQMqm2gSsNTfGyYzT2wHFAf4crZSn0Te7n4Ads61DqfQgKqvXxs3GjNKn0O +ngOr9kvbjD17rs2KKgHC6Z1Kw1Ni7CkpV6r1ylT/YJXZXRu6ZhaU375hO8mPn49YipRMowwqZH9p +Q7nGHbmbGGTumfgDW6TRSQElrB+5UY9UCDz+YfAx1bX6Hma/WV32GkGIdsJybjYVCNF6NYQWkftJ +xDJ0wrEKIhAIBOaEAB1E2kHRdSI9vYjzCKrTaU2a5j/RbBaap9SS6HFnFEbfkfjGVBSv4mYG7T7e +NGjFZJkB1sPPBlpGhOyNYXhqdpTBGoNMLJsNLNgVwrYRlJp2WFgqjBNSli9dGyW0DbB0Ybalh9OX +UkthmOE0e2wzqOusTDizfYxcSWtBcoGi3PSKqZtmdJm2gthQ2HTSNalqtsEHc4g4c8gsvJGMsClk +/A1R4auopombkviuKvt3U2+OjaRQmEkIdslWOOFIh5k6bwgcRRXRYanSZXJ5pZrNz5PkMs53wmPF +aeW7QPdErsR+uKbL+dCsG46Ub1CtHzxdu7ZW3mWnNm1wz4T8ANunStND5b7hUp2trozIE9JNrJr6 +2vzNszBV/AyDg+s2bqQZjY+NToyN8VJCS7M3JturZXP4bNEaHhrkjY4Na1YCLpVi51GaNLZxZ7Kd +uQV180n24ltbwM6XN/bXN/XXtzDspvWwImuXMlc3V2s7rIUkGNIjYqmS3bTywyHYaEs0SNt5NtpX +2qi6eXVE5GCKxhdRMKUwnZNEZn4FaQ4/EAgE5ofA/g/D8Mj5o2s0+ajzanZhDU4aqykKeZgzvlGY +JUtpnQeBpEQpbHcNw49kZlO8LVTSCWFebUXR3tyJNRPMdC/CGEIGrajgn52g5G8ysyI44kAWpsyy +M0f3RJfFhCjJMIDYQaaQrZ+yYWppki0lLH6ZxWRWF1kb7NpQwLppZg/t/L51nBbGRw4zzUgi7RZi +2Ju6uTSAxcTavT52ksROpNjWJPb5sJXJFi8rA9Rfo6IcTytfAgpfVjMxGgiJLvgCL2e2cvLY+dEd +dFL+7nXOpkf8XFVBEns52Hd4vXaIjUxxvMHYKLWZdfNvIVX3BZMkv8jGwS0bN2+ZGBu/Zsd2xqW2 +ba7M2qRN+NrtjKX6xPRo3+DkYMVWXpnaxY5iNc1YamCq8SjloZHZ3ITN09rmsfKG4fJBlfIWrs2n +BjRva+H2ymZP01Bly2RtB200PSYNg2oarDFY0BqZBZKARObnWwAAIABJREFUmfa+ydq1gyX7SHpr ++3EYIUSLcL9gPp0vbUoyV+hCPhAIBDIEmChtug69Eg9bHutWypKm7q1hemxQlsxAYtJt8DpN2tSJ +WBfAK7GZxNQXm8402jB+6j+sC2LYxyDPrCKKbDtSGiikLT62cGRBxLFwGB7uIsAwosS2DVk3lXor +UtH/YPHtezK2WTgVg2R2ktPsoH2Uin3LjGTJrMa2Xi5MtWvdGXvAsLIxIqDbptMyYQ6IWJYwbZqR +Hs7qSndr873MNGMmy5wmQQ0fGbMlTNvMNJR2OqVqIpzkG5hRxBxJxS7c76CzQ5TyTVVuU4Scn9Nt +RGdh7TfrWdJlbKbz03sMLGsSyS2C2oamxh9qx42QtYE9zKGWa8P83kQwTz8xNcGRnvrgJB+At4kN +lkjtVSqZ0uZaqf3I/EuWlYnooco2u5OotLlSHknvf9YmaVf7Zsha7Do+yj1V32sNy+uFFMppYsnZ +04HidGkD7b5aHlXF8f3nyAnR+AWXXhvtWRAf3a1EI8v4EwgEAvNFYMaU8oChpG0/1ZZpnUrqBuzZ +Nvtjz6iNIRLfHldjqp+wlSdmZZGXJJHqD8wnzoaINhRkgMjog56HYZ91JHYHu40S0tqT3cRgB1Sx +z8QhaONKehpbnzTDZlwuDrR4czYSsD9mYU2zNg3bRiYz0HAwt3aRkE560lHaSEPFw15SrJTWrlDC +QLLJh0sF6XI5y8muH7Og2E8OllCRdtCn8rSNMWkrVotry2yR2ofRZZL0U+yTUIGcn9NtRFP/25bf +yvRS5TrFzDmtCcXx5LlAW2Yu0CXdtgAwJ2t760PjtDRmfNn3Tbuwa50rVfYSDGoMqtFnRvMT2vCU +fyL6+ob7jtoyckNKQmlTo+tQqNJwZevk+F69J9Ac7GnRv5TIGghBngB7l0yx/WPMyfAaKaVeEQjR +InJfRjTniEYDhPtSGH4gEAgsBIEZUzqbltZejOcwZ1qQxMk8pDGl2UcEcDywGqni59bDxofpeTaZ +1Gdge1gjTdYPXYw1WbSats9mMqzE6KXE9vxjBNPWJCwtljXF28Ip875WfsTQZ8JpPjCNcZkdw3ay +CYlxJ1ptTzBTuOaTHZfGEW362frDtTfkwOyczS2zmWhoEAtqi2ZczGtbehmWpu7NcrLk+GYyk1NQ +dAe/SzE0dC9psLS4AtODTrSk2Kd7LYipU1aSQlSup1DmPNghVa6hQOcaClGF4H71o8plnHAl64e2 +VkvXjI3vSS2w8auCK8jaSDQNRvFFk4o7oghyyR+rqpNjpYldg5OjA3tK08NHj3NyNylRYybbGUdC +Asq0Ut5Iw+IWKstFPyBt268RtqfDBMnRUnAJcHWs0jdRSTd9qvz47pKkjWfFaTWiHpUT0OECgUBg +4QhgT5oXAnSnzDsCnli9d7sl4cGHtuCMHW1YXJvXtU9n2wNOKtIm42hdiA0W08ZdOgwzyNZ/mNmF +ZMDHTancx4fBszEiylhUxZgyXDD7jCWcGeNi6azrsu25NvWbei/EbPTJZK35qOaGAJuEtfxsBbTE +zOyQjTLZCsS50TQ3y9DTjppQ0KzXE23j4VQ/guKIaPUdpdaohXDArZC8A6c1SmnF91gniIVWMPc9 +lZiFAhSCklH18Ql2D4VLdp+qbZFamdLcys8Lz2vUluET+ksXj05dw2+fGo7FG+KyoLxj2Qy/2TZm +evVL8IOMXzs0ft1mXuB4q5uqT/zx97877IgjN2zcSFMk31ZnKpIjx8H+TVPVnQqiKrVTC9nvnDJo +5GJzNvZUVEujA6UNVCR3yOeGM6cllhQaKcJ9iHCBQCCwKAjweKVTe5kyHjmef2fkNMw8Vg9nQ4BU +di5lxtRYLHHJTwktlDvJIkanI1XY1DTtm24LYlqX25Ewl5YYtTY45fCK2c807mSEyRCzkR/pGJna +Jl9zzIrBJ1G6EwEDbjtuUWo2Mo0vYemcCf0O6ryyEOSIn5TMsMWcCTfFcs5i0YIi11bgeNCJXNhp +xea+onIOtIJEiUgMdeANTeIDlEvmehpCGSCOFfLQhVQunxOeBKZopVLyPNZT5Wpz2gVyYr8CyoLZ +iE1Dxw/0Xz1R3T5t22WTOQMMO2Y6zBx/tW8v7co2g7NXjWutMKjT/WO7R2wio8S+X27eAKfy9iuv +mJyc2LR5C2pxtCUReZFED5a3jPXtZArX1hXsxIttL7L3NWu9qWnTiInVp4OgS3tKpcPIguTuUzt3 +zheHYE4oiB8uEAgEFhcBHjR2qO5jS8gALg//bDkRS5QLzAQT31KareOxb/SkJo3DaNkA1DZIptGp +8cwq2kA13cnAxQVT6UACa6YoRV6HJk2ttDYWlCzrpFQyWE7rreyWNSarLWeSswkIy8l/2E4znxoR +pyKlAjZql9fd1CbnRDdByczDF26ecLZgge/yIhSb+y4A0/kiPInzOwhLRv01YhC5EjiFoIMmwn3n +e16tBKoQk69YpXJ+axI4hQK05eQJ91sSlWH94OHr+w6drnF1MC9r08yGDPZvYA8RLWvP5MWTU7u4 +3p6o4UEuABkY3TlSm2Idf9JuHExvflaqev2a7du5bWvjli0UALWtTgXrL68b7F8/Pr3Xgqnl8h5o +hpKWmIL41tLZc2Q/Af+P6ocgl4IpRUoconCmr0kUaILhAoFAYHER4JFtfxhGTyNdwGz5uQCExBqc +9Bir76D3lbG0ASujTKyjXVLPZ7fYgGSPOi/xdrdPxRj97Im1wyi2xwjryFhV3YUNEK0bt1Eleoix +xU2Or9jlwQNcl4dCk7QPlNklC6a/2X9BWPKm73VBW4equVhbYq5pkc/1zBYs8D2J+B7rBAJ5VE7n +UW3lYTpftHwlVFTuw8dO4OMKfDHl60eHzgkFc7G2tH4motCvn0a+snMlHnQlzmklXMZViXB+TngU +JUFVpbwe3w5OJWeS9b4NA8f18THT2gSLCLuu2bn72vHhweH1m/rHxydogawMTPBNtnRBFR/2273r +Oj6rsHHrNjX7PK+MLg0ObGEfL400LTiY1eQ9VDO9+MkkNgwr7ajGYLg+zve/0Um55DeK2DSfKJ8p +8750lm+QgUAgsJgI8Pztf9tRhwx5aL0PkhgclyfKX4/NpqYXZ3Wa6l8QNnNLv2CTYMxumQGlA7HO +DLPIgQS7HZ7Zr1Jl2CZ7uQzHlNPFYT7TbBra4Mt3QgUw+WbXnJczpyUpfzZ+LtNWkoRtZXKmyziR +x0KLn/sSyDnQChaicqZUJcEZ4TwoYXHyfAsyHpS8em2XVwFafTAX7K1Eq3DOIRclUXKinCMxFcOT +eFBE7ruME4pFsxMeJaJtlDMLyrlPmN1G2w5aN1C5bte113Af5Yb161id5wIlPl/ARIi9ONJ+uYZ+ +anLXjh0btmzR651nSqyqCVEpsapqi7ONktDW9fqapnbTCn/TyrLIwX7eEgPTDfwcOJLgowSn5E6L +43zPOohAIBBYCgSwNnbLawfV/jR2EJNMLgCHoPn0iYxHedTTiVKYRtunzWxhlWhEbELLxqN2WIWX +erYZ2cdMebvndME6s6kUj4RybjtFKGvPToSq40wSegVzAWcWiIIMQQRyJQRhit+aVrEFvgeVKvcV +ZepSRk608l0JhMRy4Tx5TkvYfXW+rRryJFIrH0kc9waLkC/hnOP46GdSMPdz4Zx2GU/oBGJkJIE8 +iXLPfUnmpRKdp5Xa2XTCR4BUEoMQLXn8Vrduw4ah4eHrGJ7uGR2xu5EHbb8bA0zeT/mYnX2ircLN +l4xfN27Zyjo9GtCJ7xlBcyh5eGDr6MQOmjnt1KJtax6e3a9lDTdN+UKwhsHl07WKzfHqR0QbBCJW +1qRZtPsQ4QKBQKA3CHS7g1fPKr3AbMVCQH0EhFnKZlAJeOKNRT/Ck58me9EDg8+KIWxHODGiSbn6 +MvlEyRGEUBLPRSXxYIEgFo6SuKSIVJBGrDjOz5OI9igIJfQkhaDzJemxTuR8mM4XkRjWl8p50An4 +ovFFO8eDzvFUIrzPdQEIMT0qVy4xRbmk8iWIy2mCwgrfCTEVtATtnAtbsn0dPzdZwCtkJDXOhJCD +D+GZiCa5c6SeoHR6lBOKyuWdzjU7EwJTtnnbQZPj49hLZkpGOAZjGfJKWMassoBan7IP8ezauXPj +1q3crKSsTaJptqGH+jfvqe+w18p0Hy8cm4fhH5RVKv1JTE5jTdd2WVRy+c+XJGdaRSNN/AkEAoHe +IGCf/m48swvKkEc775L0qNMbzvQdqd9hzhYOq6ZEqSOAwJE3bAj36YmkRD58CMQ8FUGYcMSXr6D4 +TrskHGfmRGI3PNcjgTyqlW7NWjI5H1pBV5hzxJSA80U4syBT0ONihVQKelqPdYKoPDankcmD0G5T +PQpm7oR5wc+DuXCBVgPQr08SCBUSWq4gr1iYeWFUwpyjVLkGZQSHqIbqZrsS0zPqHHQxEewG33LI +oWO7d/P1U672tZZu40WmaPuY8uVzDNziu3P79m0HH4w1VRLK6cUYYFtTabjeN06UjUd562SRQ4NU +28NkKfhB+Mt3Vuv1vexkt8XcNB71WqviUh5+IBAI9B6B5hG5uefs3ZZ6KBR4ByEiF/AodWEKqtOk +O/De05XkTPUXyKj3Ia07lRo+nDxWnDzWaWWhoKciqOTie6wHkZyNqSh8EYiJSIxGKjHFV3Wc42I5 +0SFWyaUqTyI657fGtqqFkyvMBUTj4woycJRRijToFBSG+DgXgJZYq68oJCWvn1hBNQkJ5Bqk1n0R +efHEyfNyJYihlihXrigPEuV5OdGqMFcuGs0bNm+eGOeTfaP28QR7PdVPb1/KY/cdC567r71m45Zt +3JFVSE5GI4Nb905e4XwAs0NgTWuqppcKzg/Bhwb3DJSGES6A4MmDCAQCgR4jwMOYzqzNki3R3qHM +ImJsf6QRzpOIdqaCEpY2p/MoeiVlqlh1f9A47woLQfHzWPQrX2WkQsKRc6b4ebCVJi8Xy+mcKb7S +qmzy23I8SqkK8gpSl1b9uaTSFsSURFG5sPMVVdCcM5UqF4DGKSPR8j1VKxOQYcrPiVxStEvqd0En +Vs1pEfh5XnkJxRfH+WgWv5B1rlZNxfUThM7lFcwL2Up7LooiV/vu+kBlenSc+7gYRdJuKDpAjAwO +coSG+dtrd27fevAhfJYm10/y4YHNeyeuZrhJqlSONDxtmmMrWprvTTt765O169b12WfAveKNAsSf +QCAQWD4EKnp57rIAPL2FXoCEznTCtcFxmoQScKZ6NAScgEZMQWcijyOoWV/J4+eDCQTgyEcSJeqU +LWUqs4oNjRhOQdEF32XEVxBfhAuLIx+mYp0pjjM96PIU0mkXE6etr3w9qkOO0tZZ3svjYq5wNiJX +q1Tue1SOqphwPNblnZA8vjuEod2gShKOJ3FtEO6IFS3CfSV0PyeQJ+gZQXgW8BULR0k8Kic8CmHn +VwYGyxv6p0ZHOUVtY0uEbG+dGUg2IkH8+aqrrnfkkd5ElbDSzx2VG6bq19ldDU3XOB6T5niN31DC +NO+epkj8DQQCgZWBgB2GsfHPQp13PepW6D8KHGXgfMXi4xRF56LuTIT7mE9oZIh1GYJK61Hi4Fvf +lbpIHZlX0GMhcDBF5L6XpMAUX9kRlQdzujVKsZQwT1ugVX4xC1EEpTPnFzgECxylypk5R3xL06yI +055da5Q4rkdJOviSbAtyIZVL6mdyH77ThSQEicWJL1q+cySDrzLIV9DVilASNTxxZrOpkmzrk9DL +g4BdqrVx4+SePWzfpfViTmm4fK9N32mfmJ7Emh5+xBFI5u15ZHDb1MR10k/lmCSeMe6prmZZ0+He +ieqeanWyUhlqW5hgBgKBQO8R4Jndz6iUPoKeIi9ZK0exzle3ov5FacWRmPPVj+S9iYt5lOyojCgJ +4aNEnR008qJFSAAfB0cE8hAFXyXJfWUtX3xoOYIQ8p3wYEMo+5NHOa2SZ1IzCl2nx3oqRSnYlpmn +RUBOepqhRuEJurBoV+6pcqIQq/JLoINPKqHtMgU9zhfhwkqon8x/LwWRdDFoKcR3Qsw8KOUuDJHr +VJCWA5NUal0wvV15vjBzlxcj53vWEHK8xlW2bBnbtYv9Q5hT+3Z4X53vvk9Vp7mWZHpicsef/3zQ +IYegBGCV79DAhvLkcL0+ThOnuWksi4ARlA2fq4CtkPwb5a4Gdv7mZQg6EAgElhEBOgfWStNL71xK +QX/RtltxPgT6kClwlInzFeu9iQjFis59uid1OihxAgGUEJQqCBXMfREqjHJv9UnrTGgF5cNPjIZH +UDm6jCIkpqgCnWvI6VYNeaxo5+REHgUtJ23QrrZAdxArRCnovmt2TmfC5SEc/LZJiPXSSlJJoD1I +QtGuwfXDgVbQCRcrEBJLiu29inai5gSHKDUnEZLB90YFn6CyE1FQrigxEXa3cdu28T17+vZycW4f +A9RpPjnK5c8c+qrV9+6GWWJPr6vlSpLhypax6pV6b5Up9YaZVkkbBtW01UcH+zZ5qVrLE5xAIBDo +LQJsO5qxI+2z5plv7UHaMknvfAiCJCxwlIf4kqfPootRdwahVPiiSa5OTWIEcZKHgx6pEgFfhHxX +BTGbQxtR7ucEtAclIw6+l805BQGCLlOgWyVn44iPnxNOF8qWpBqeogqSHswlnfYk4hSCLjYnorMS +YvmZUIgP7UERilJsnimxCoqYLZgnyZVIuX4a8fOMiKVR4YiSDLE45ZITBf0IyMEXQXKI9Zs301YY +nvIF+cnJSe7SZbzKcVMeumt37uSm6E2bNnnC4YEt49U/cy2+r5J6LuIYWtjRat/41K51g4cr1kvl +wkEEAoFAzxHg5rIu8uRp54ktCLZlIuN8iDxJ/swTRYclSTodovC9CyPoNISiXMCHp+Ig7I7soOU7 +oTIo6EUSgS8CGRGJ0TCuogu+JHMxiuHJczqXRJ7gbBzxU3yjGC7pTNfgHBGSdL811sUKMq3BXLI3 +dF4pfiChWvilFMzLk6cS7RwncnmniXXlEPxY+DgJQKixSUwtMMXPCEjY9eSaoeHjciZBDsmQ657d +u7kxyr6rW51mYMqF0VjUqy6/fGhwcHBoCDE0D1SGK+UN9b7rTAf/mBTmljD7i2FPb7yJSexUdZeX +xLMLIhAIBJYPAbuiodFTdC6EnvaCTFsmMs4XUfAJuoH0KFKpa1MXBi1ChtPF6EGUVsLikxa+OxWS +oIiCTxJxIEQXiNYg8mK2jZot1vmenTh5MJdBeS6Q04pqy4FZcC7s/FaOR60EIi8evxpB3Gw/HwUm +1n2Vv5VTqFeu0GkIb2yi5ashSUy0tKlI7ovwjJB3ukBs2LqVDb2je+0bbUz0cus9I9a0obd05eVX +HHXM0aTFoXC4snm0mjYf0XiTPlslhUhm1a5Dstc2lIzX6nzMd5/bHAuZRjAQCAR6iECdq25n7QIK +5dDT3g0TGYTx6R1EOK0OSIZQfkGhbCd9nK9mIYYMHBXAi4Eq1yC1+CKkU7QXACa0gvLFKfCTyIyY +glLoURCdOR4rAt/1KK1rUFQu71FOuBInWqNaOS58QBCzlX+//NkECrWWGL63Cgi1Hwi9nymKhASh +Peh0K4EwTFcOITrPHc6mgw7Cdk7t3m3bjqp8WddmetmIOzY2unPnzm0HHYQ8YgOV9eUaj+Q07Yt/ +vA1aQ+Nfei1kkGpzz2W+pDQ5XR3tL2/Kcwk6EAgElg8BbiBrWoVuCsHT7v2Ly6vvaOUj4PKS8STe ++4jjQcnTwXlCBIhVTyc6N59EyeWanRaRZy0a3wnJoBNCTBFJxOylS4qTy+Sx0HKtCZsx++iHWVDl +Yk64gDiFoIutJsLrCMEvO1vVXGw2gQ58pUV5rsRtqvKV701LJXFffA/metrmiyQfh9lyyCHs5R0b +G+PSv2n2+zHvwvd0yyV2827YuJF7G2jklfJQf2mk2rc7tTyzoTyd2F3dyivlacqXbUyjQwOx86gt +3sEMBHqNAI8ql8jPHE7vJn91HOpHcvn98r3HIS20fBHQONfmzAKBAN0NvguLKARzPaLRAyG/EAtT +ziUJStiJPK2YHQRcOJeE6XzRue+SYhaCueSaopcOh1bNcGhFOBqY06AtpmAX7ZxCsPWnQUCvgFLI +LMu2Qw/dfsWVExPjLNLyUZhKvX+aQWa9fvWVVx15g+ujAclKaVO9tNuy5iBpupYhNUcbl8LhlY8H +gK+8TdfSB8NTrmREwtYCBCcQCAR6hADnSjMTNodM1Tu0Jtgvv/DMqxdQKvVNrtOZcDzKh6RiSphY +T5UTeV4FWkF8EaQSUQgW+Cad9VlOJ/ZMX+b8vDCuypmziblAEEuHAOCr7ZEFtCwoNAZPjc0blQgx +EfDYnHC+/6ZKpVxkUJFhy+62ww698pJLyqUyB0Ttm7xVuyxw757de3fv5qttpBqsbJqYvry/PLPw +Yi1OnwRPlhUaazo+tduzQHO4QCAQWEYEMEHzNKUUWr2Gnue8Dvvle3fjqVACEwchJ1q+xOBDyM8T +5rHQJPHY2YK5jNMi3Hd+rsRjlUUu45kWmIWgiwWx7Ajw09Cc5OevaOJ4S8sbHrQ7yo+NzIOtv7WP +SkUgzGdk+ODaNdu3p3laHbmZJvcd27dzhS9EpTxY6VvPnl+9HtKc9aIIYadL0xQS3nRtD4Peki5A +WnYoowCBwJpHYG5rpa1wqfugjyhE7Zff2u+gBKb46qHQKc2KUhbiFLKbLShtHqugMyGcloyCuZ/z +XU8rs6CnIBnBlYmA/2pqYAQhnFaZCUK4XyCIcoMqOk8lhbKj+MpuIxch7dkzPj7OWqjZzvQhNtTu +uW7Xpq1bOLQ8UN40WbKLHcylnUeNKxqm+xjHWioOn9Ympmvjg2WMrhXPK5LShBcIBAK9RgBTughZ ++pOsB9s17pcvScRIKL81LRypLSiXpJiekSeHcKYTivVgB6KtnkLyXCboAxcBbwZqhAoWGpszxZdd +hCkzCROX06ABxzFxOwqHVFsPPfSyiy4mBTO9bLHjhl6E9+y6bnhkZHB4iNOlk3WeS/YbNe7dlSLb +G8epGP5xzLRUnaruHqysVxYkVwk9xyACgUCghwgs9tE073EKdejMd2EXg8h7IgUV68KzEQUxDzpB +wpzO9RT4hWAuGfRqQkA/NH7e6lRBRTk/l8RA+pEtCciXnpxTwIovhG895ODtV19NfrZiyo6iGkdP +q3t27d42PDTQv740zcfAR81wsvlIifl8qcnRdM3Hmk5VmeM1I6siFbKIYCAQCPQQAa5oWIxRaaHE +/mzrUffY2fgIeFSrsDgFVS4mojU5/LbMtvIdJAsZRXB1I+AtAaK1yYkJX2JaYZXvQ1IIF3CsXBUE +8vCZ5uUm3j17d1fK7KJP2536+ibHx7kRCfNc6ds01TdqVlMq0m1H0DysWjRlJ/tUbdz1BxEIBALL +iAAdAhemLIEtbdZJPQ4h70oUMxu/ENtUY389Sc7sTLcmaeV01hCxaxmBvLVAext2WgT83I66ZXUx +BFwSAmF83JaDDuIKJAxvOttdH+jnpntubZhYt3H9YHnjRO1KLb5gQY2QUU1jUzYfsXo6PT3uO4+U +xVr+saLugcDyIsAO3saL75KWg47D9ec55vy2As5sJdqmlViHqFY9wQkEukFAjQpfDdgJ0sp8ii9L +CdPbOQROySE8r+F1I5u3brnuWrspEK59UrBUGt27G1PaX1rXXx+qlyZ4bmzJlJneZjJ7kGxYa9cH +VmtTzA+78qZI/A0EAoGeIsAzOP/DMPMuqfoUT553LmIWBFzSif0KuGQQgcCiI5A3P2jZTpqxxqZk +B41xJSgaGTg4JYRQkQhu3rZtbO8oRpSxKdND3JfCkunE+MQg99xX1o/XJjCcNiJNZ2BkQS0xQYT7 +xmo17nhoONffZMTfQCAQ6BECPMtpU2CPsmufDYWYq2uvKLiBQK8Q8BZLhlhNBSHcwYEWHxkIfDei +EHL9lcqmbVtNSanMLYKSGR8dQ75S2pyCePaJGJlf05KMq/RVa8zxmkvs8AKBQGDZEEjLNMuWe2Qc +CBzACOSWUjS+LGjuw6SS8nOzl4xgfcOmTUPDw5hdZLiqt87IdHrKBri19djXBjoMWRNpNjPZTcap +DHona3saAvEnEAgElhMBO76mN93lLEXkHQgcoAi4Bc2J3I62HZvmBpWKb2ZgWjcbbLaTBxJjOsnH +YcqV0ojBkj+g6cYGeNhTZLnU3lU5YUnCBQKBQE8RSI9uT3OMzAKB1YVAbkSd7mxNAUBDUvmDw8PD +69fZaks6Zsq66fT4JFFl7gW02xjMmGoYylQu/9iIBId/1dqosAw7urraVNTmQEOAO8hineVA+9Gi +vCsRATeiTuzXmlINN6jrN6zvL5cq/f2DFbvLk8+xTYztLZUm+QiMXciQxqBpnthMqVnWtPeoWp9g +t5PDEQbVoQgiEOgpAnZzGc9luEAgEFgwAm5EnehsTXPLx8C0MjjUX+m3MWi5PDU9NTk2WZuuMVLF +pfFqsp+6qwFDmv5NV6c4EiN7vODih4JAIBCYPwJ8zClcIBAILA4CbkSdmM2atubHMVOMJs8jaWt9 +1Xqtf3KsUk23MZiwHlR8rCn2NY1Mq9Xpam2yVVVwAoFAoJcI8Mza8kwvs4y8AoHVjYAbUSdkTQlS +cTFzAlrDU+6yTzcx2MEXJnl5LsvV4YomjdJuI7Og+cNKVJl11Skf3TqxuhGO2gUCKw0Be1pXWpmi +PIHAgY6AG9GcwKC6TZVZzauJFWRel0+WQtjIs8xMLxt5h8p9FTPBsNLmI7OmOC2XJr/WNyE9YUeF +Q/iBwLIgoDs9lyXryDQQWLUI5Ea0M51DgCnlWCmm0wac5b7qdGl6Iu1mIGyD13TtURqYJttqFna6 +2jCl0hMGNccz6ECgNwjwvsuDmh7T3mQYuQQCawwBPV8+HhUhHyQKT9/g0BBfAp+cmpqe5i5B/ivX +pwb7+xvnYczANp3t203jVD4ADs/GsjaaDRcIBAJz4kFUAAAgAElEQVTLg0BM8C4P7pHrqkdAg1Gq +ieHEJ+gGVUHZURcTIGzl5aojs6R2CKZWnRisVbnmNx2JSR8rNYNqu3xtmheRao3zMGFEBV74gcDy +IMAzyA7eeA6XB/3IddUj4GZShHwMqtvUXEBoYEph8lTamLPcV5vuL9vUUeMp1RxvdpS0j1FpmNJV +35CigiseAV6UY4J3xf9KUcADF4HciOaGE1oGlao5H7oyMFCusNXIdvBywX11ulKuDZT79wFA++5t +1GoXHnFh77SsKb6IfaQjEAgEAkuPALcdxah06WGOHNY8AlhHMHAL6kEI0UII+zo0Mpwmb5nPZXRa +np6sKMqXSjGiKGvO8Va1XLrmAQ4AAoFlQ4BnM13xuWwFiIwDgdWPgBtLEfJtknffr7C5QeVDMY1l +F/vEabk6PmDLo8l2Yj71TxO+Zk1L9elabOJd/a0oariiESj1NV54V3Qpo3CBwAGOgJtJ1YMgs0Gy +qfLhiwmR9vEOsIE3XVvPdoahdFe2fR2cGST7Gpv+peMx9h0Zu4nXnJQoi/ADgUCgdwjYR51igrd3 +eEdOax0B7CUQ4PuQ1E2p+Aoyx8u2Xy64tzFofbDCRffppZfU/rya5eT/km3iXeuwRv0DgeVFgB28 +6RV3eUsRuQcCqx8BN5lOUGfR7jsKzPFCM9BkDDrNp0urg2aBkeeGI30rRt+DgRvnYRIy4QUCy4lA +ujjQ3m7DBQKBwFIjkJtM6MLAVLGUAWJgaIjjqEzx2jDUvl86aEQaheYnYWRfa3W70V4TvEtdhdAf +CAQCbRDgcQ5D2gaXYAUCS4mA29ScyDM0azo4yHdfpuyyhumpcfuusG0yajosK3ZUxnW6NlmrVRVj +S6Y+BdwUjr+BQCCwtAjYBG/Y0qXFOLQHAjMIuO2E5bQTGqdKenj9erYZ2fWBnBudHGDlNH9UMZds +StKzi60lNJNHUIFAINBzBGLbUc8hjwwDgWRHgcGNqGjnQAwMDLD5KI076yyX1qftq+DuNCrlu6Zp +bMoVDfuY0hiYOlBBBAI9QIDnMa6z7wHOkUUgMINAbj7hehBiRihRXCLIQqktg9YwpRWuEHRn41Hm +eNMCKjuTbPdRWi4NI+oQBREI9A6BtNe+d9lFToFAIOAIyIgqWDCoMqvDwyMiMJDVdOeRBqNKki4O +xPqWbAq4Xg0j6sAGEQj0HoG4OLD3mEeOax0BN5wA4XROiN/PF9cG7DypmcnaALL81fqonYqx2xls +gpcry1gu5W+4QCAQWC4EbGdguEAgEFgWBFrNJ8XImdx8lB5QzsMM9NW4UoVIE0n/zLNY7Gu9caP9 +stQiMg0E1joCnCvl4VzrKET9A4GeIyCTmGebW1DnDw6xXGpjz+kpxp5p55FMa5Kwu5ASUatP8dfn +eJ1wPUEEAoHAkiKQvkq8pDmE8kAgEGiHgGwnMW5Ec1q2tlzptw8h2sCzr1Sr2AQvXzLFmhphm43M +t6MwZkrlwo42kYi/gUCPEEhXfPYor8gmEAgE2iDgdtQJhJzmSAwOu8nQtF7lO6b7arCLGmwBdXo6 +1kr3RSZCgUAPEeD9tTlD1MNcI6tAIBAAAY075QsQt6AeBdE/MGDDUL7yPVVprMZoidTOxpTqaQOS +JnilRH6MTXM0gg4ElhQB3nHjtqMlRTiUBwKdEHA76kYUaacVyw2CZkn5Asx0GpPKw68livlem+Jt +jEqxoGFEOyEecYHAEiDAo8oO3n3uSVmCXEJlIBAIdEIgt51+d6CYBAeHBlNizo42dx7xDpwsKPxk +TvnLnfdhRDuBHHGBwNIhwLMXtx0tHbyhORDYDwIad8p3Ubes4vTb8dKKbTOq9len041HevvFnqaJ +X8akXNXryYMIBAKBHiPAM1u2i8nCBQKBwDIh4HbULWiBYGBqFzUwfVQrl+sVTq9hQe2p5X/t47Ub +BBOjYVqXqSaRbSCwVhGwUWkcK12rv37UewUhUDCfsq9iJlM6gE9xGZjywDK/25zXbczwYmd5mE0g +rOkK+lWjKGsIAdZKZ57KNVTvqGogsDIQcKuZF8ctq5jM8SZTyqVGxevJbKuDnS5NQ9RMRdjUDIwg +A4ElR4BXXXuZDRcIBALLhYCsKbm7BS0QbOK1cWipVOPCo/x5tRGqRZghzcajOb1clYp8A4G1gwCP +IYe+Y1S6dn7xqOnKRUBPIr47yiq6MjDADZ9calSbrtg3wEu2yWhmltc29DLBG1vxV+6PGyVb5Qik +75Wu8jpG9QKBFY4A9pISyvei5gaV2d1yxTYccedRraabBP0N2AguaqiFKXXsgggEeo1AvZK+Ldzr +bCO/QCAQyBHAcGpWNregTkMwMK3XqlzDy/dh6qXWAShTvEUmCkmY5xJ0IBAILAUCTBExa5SvvSxF +LqEzEAgEukIgt52iSSZzyE287GsYrAyX+zgYM6MNU8ljzIg0WyqdiQ0qEAgEeoGAfWQt3lt7gXTk +EQh0QqD1MZQpFR+fCV6OgNuKaLUfRT7YlAWVsDJgMIrrlFnEBQKBwCIjwHX24QKBQGAFIODmUAQ+ +hXLmQKVCwExkjc+upeLaMTaLt3ncZFvDiK6AnzGKsBYR4DEsHlNbizBEnQOBFYaALCg+5RJd7u9n +71G6e7dihtOsZ2No2vy7wuoQxQkE1hACjEpjKmgN/d5R1ZWOgAynSul0w5pWmNplr+4AX1bTFC/j +0cYVKwxU40Fe6b9tlG81IxDfK13Nv27U7QBCAHtJaeV7sd2awqlU+AY4J0jZ39DfWCJtWFRZ1sYg +1dMGEQgEAj1CoG6rLvE22yO0I5tAoDMCbkdlQRXET7cG9qXzMGw8suldm91tjE3ZhB9TvJ1xjdhA +YGkRYMcC6y7hAoFAYMUhkFtTCkfQPrVmVrS/XsN2Ykr7+tL+I+jGNO+Kq0QUKBBYGwjEtqO18TtH +LQ8kBGREVWKnjSiX2HpUqnMNr52HwWnR1IaoZlvtrTiOwSRgwgsEeooAzx2zQ+ECgUBgRSBgFrHF +mZ1MfK7hZR8vw1FGozYqbZhPCysQdrQFvGAEAr1AwK72bPfw9iLvyCMQCARaEXDDKUJGtEHzuPb3 +s1hq41OLSHO8qIAu9/N/q7bgBAKBQA8QGOSG7Nh11AOgI4tAYN4ImNFM5jJZzH4eWD4AnhZH4Tc3 +HzWnfJGMsem8oY6EgcD8EJiarFbiDt75YRepAoGlQyA3n+QyEywz9OT/dEuDRVgR+Fope5GM2tdh +U5VwX3aEAoFAYJER2D06GTO8i4xpqAsEFoJAq/GDI4dath2Z+bSjpTYktY8ksouXRdRSZSGZRtpA +IBBYCAI6r5bebBeiJtIGAoHAoiKQLOXMYBTdsqb9lYpdHmjDUXbvmjU1y5rGqYuafygLBAKBOSDA +U8gdvLGHdw6QhWggsNQIyI4qlwLdz028tr+BaV4MqVnRNDDlT4xKl/pnCf2BwKwIYEb59mGY0lkB +iohAYHkR0GBUPiVhB69uacCg2rVHmNM0NuXE6fKWM3IPBNY0AmZK7dU2XCAQCKwsBDQe1aSRG9R0 +ek2HXlg0tcg0Mi31p1GpkshfWZVZgtL4dJoTS5BJqDwAEPAG78QyFJrLyNixsAwZR5aBQCAwCwL0 +CB3Mg913ZBcGzqyU2oGYtTQqBZxqtfqJT3zi29/+9tVXXz05OdkBrlkwDvYqQYCHZXh4+JBDDrnD +He7w4Ac/mBWQ5TGojEpr1ZjgXSWtKqqxmhCQQcWXo2oQdqlKpb86bR+HKXEVrw1QYde5u0F1J7Ca +QGiti4zoxz/+8RNOOOH000+/0Y1uRDdKB9oqGZy1gADt4c9//vOvfvWrb33rW+ed95kHPOCMhzzk +Ib1vDxjRSiyVroUGF3U8sBAw87jvk+k2EmOKCeXKz/RNJ1nOdCSmpYaepCXmQGUwAH39619/6aWX +Pv/5z7/zne+8+ip4oP4wy1pu3qVOOumkBz7wgd/85jff+973YlZf+MIXDg4O9rJQvMBWVvtbbC/x +jLwCgcVHAIMhmyFCA1A27tpEL47bGcoDa2GCV3aUGd1//Md/POzww6anpwVIwmCVj8UXv1WtFo1c +MWQvncz512q3u93tjzrqqDe84Q28b/Gy1WNriimNVrhamlXUY3UhoGdTw1OZDXxGpTany2Nbb2xz +KJcwpbq0YXXVP6sNhpPF0d/85jeveMUrtm7dWp2u1kp8as4OBOlQUCbbiZyamhoYGOgkccDGAZHN +/9t9WH2ruJqtv4/Z0nq9ltyWLVvOfPyZZ7/+7E9+8pMPfehD+S5hq/xScGyCNz79vRTIhs5AYIkQ +wGja0RfWSm1EiqszKrXDpmnVdIkyXV61dJR79uz54he/eJ/73GfDhg0sj6myZkpnqfW111776U9/ ++pe//CVpjz/++BNPPPHUU09lUe2YY475/ve/z3zgstTopz/9KdOPD3/4w5ci9/ve9753uctdXvKS +l8xWTTD8yEc+csYZZzAjuhQFkE4wp47sAFq6LHLN/L40A8woBA0Df9PmTbSTL3/5yyylb968WY0k +T7JEdKyVLhGwoTYQmD8CPP/qI+QTdGfjDtZKuS0wfa203sfgbObVG7H557pSUzLe+vznP3/44Yff +7GY3gx4fHxseHrGaptq2jkovuOCCs/72LCzo6fc+vb/Sf+F3LjznHef84Ac/qFVrVBGfQe2y1PX8 +88//93//94c8+CFzzf2yyy7DTjB72SEhTQWLYuP1Waq5/c/bn/nMZ97kxjfZtnVbBz1zjdq9e/cf +//jHm970pkoIzh/+8IcfcMYD5qpnfvIcs05TvNTeTOnY6Bg+7eQXv/gFaGPRezMJQSma92LPrx6R +KhAIBJYGAcwEvYPrlo3Etxk8m8TDktjOI0ao/TbBa86FVxMBCKOjo7/+9a9vfOMbs/o1OTE5xpfm +arVKZUDTdxqRe5URfsITn3Cve93rrW95q2OifpZOFjF8EZ6kZ0Tdxk7W4881x2c/+9nHHX/ca179 +mg4JTXXNlEu/E54EGwtt5nbuBXAlrcR5nznv1a9+9c9++jNFPeLhj+Df4mbRmqlz6jwlNXtMmNOe +SI4K0k6YeGA5gMawadMmbwaeatEJsLencdH1hsJAIBBYRATUFzT89AUKuy8Qq8o0b4mrBGdGpWTa +g45jEavWjSo6RDrJG9zgBtjOcn+ZTnNsdBzm3r17zedv9u+DH/ogM5zPe97zRsdmokTjk93lV1z+ +V3/9V1gmRq7bd2wnLf5TnvqUU+5wyol/ceITn/TEHTt3SCEm+W1vf9trX/fam9z0Jvc67V4XfOsC +8S/+48WPfNQjjz3u2Dvf5c6vfs2rT737qeL/6ZI/ofmYY4+5zW1vc/4Xzxcz9yen7AisOO//wPsf ++rCHfvFLX7zbqXdDPxmJf9XVV1GGk2580vE3PP69574X5uv+6XVf/8bXP/CBD5x865M/9elPzVZa +TAj6kVc1x8bHpND9sbExql/g79m75y1vfQuajzr6qNPufZrXEf47znkHFTniyCNuerObfu3rX0MP +hTz9PqcD3RkPOEOSF373wpe//OVXXnklGp71989CRvVSppdedikYnnDiCQL2sssvE382YBU7J5/q +UlRGxjSGyYkJKshJGNoJrWV83BpJNw1sUWRsiSVcIBAIrEwEsIsF02gTvIxKjd2wpgVTSkUKSVZm +1bosFbaHPpFj+Kx70UvKYVBJjvHAafjlPuPX61//+rY1qZ0j1XOf+9zTTjvtgx/84De+8Y3Pfe5z +SDFpfLvb3e79738/08hf/epXWZRVUqZV3/72t2OYzz33XNYXocV/6lOfSt/NWuz73vc+lj8vvvhi +8Z/+9KdTSA44nnnmmRgYMXOf0lIAcVjN/d73vvfGN77xZS972d/93d+95jWvue6664iiYORL2b72 +ta/d9a53hfP4xz/+Nre5DWucnKa9053uNFtpAQon5Z6Lgu4LNA9CYKHf+ta3ssJKse94xzs+6lGP +uvzyy+GDBgV79KMfzdLyRz/6UWbLYR566KGvetWrLrzwwoMPPvhd73oXHE73MmlMkLK94AUvgEO9 +LrnkEgjc0572NKws870f+tCHUPuMZzxD/NmAVexcfQ0G7amo8FrJLI2ZUn4I2gwtB0yo9ZI7nsbe +ZLTkNYkMAoHVjoBZTzl6DRuSYk4IW9ch9moFgGHo+vXrWfRqGNLUV9JdKgiRu2uuuQY7mnNyGohe ++tKXPvKRj7z5zW/O8t7PfvYzYpkDxIQcccQR2EumkX/yk58oCahyhw5GDiYzxlhN+NiJ73znO09+ +8pNveMMbsnz7sIc9DJ3wMQ+s0WKkt2/fjuX77W9/u3PnTulx396BkjAcaOYh3/3ud2PAWNJj2P37 +3/8ePkwIVhwPOugg9MORVVi3bt1hhx0GDh1Ka9YkOc9FQffhy9I4B1N697vfnS1LZPec5zwHY/+Z +z3yGWBsEn3wyLw3siT366KOJhYk5BzfKcPvb3/7HP/4xHH/FoWyC3euI7eSg5xOe8ATmWnEQvBxc +ddVVpGoLLPz5OT7x0GgJLIwnFcIBxGg5VLk3jk9/hwsEAoEVjUBuKRPNqFTbjti+CNFYJXViRVdm +joVLY6360NAQozE3pfSVwkQddz7yoN9nSIdkaz4SZiClWHSiBJphECcRMSHYAxbYsBYSIBZ7KRqb +QS7QWEo03+pWtxJfOqGxHPDPOecccW5961v/6U9/ut71rpcXgyjlCBMa+8R4Dhrl+CjBPe5xj2Mc +jI+5olTHHnssUaossdAdSivlKgC+5Eki15Z/6aWXPuIRj5AkPi8NvBNA4D/2sY8taPjCF77wlre8 +xe2TYqXWJQmqGGggX+yxokCMIEw2TyHQCmyjlHP8gyq1EHzeA8gdfKDx9ZNBz1HlvMTTdfY9yWle +xYtEgcCaRUB9hHxAyIP0F/W+fvbu2pnKxtiUeDOo8lcTaNSIkQZVZqmPTlmOII4o/EJlsUBvetOb +GCAy2CpEaTMn2kQoOfQ73/lO5jCZ4dy4cSN2BZ0uQHaiIZCHZsRJH82gk2lk9DOfiQ//mGOOgXjR +i150j3vcA6KtQwn8gkI4mvhVXsQyOcyol9lR5qIx8Ah4UaH3W1rp92qSRK4tn4Hv7373O0VRDOrF +CJUgtfvhD38ovpIzVj7rrLP+67/+C2CZhT777LMVm1cKSQfqyCOPJEgqAUUuBKFJRXVU2Vween4u +N6VUAeXoYWqX3xEQFJyf5jmlisvs5wRXCAcCvUPAe4GcgJb9sCnexjRvo0i5GCwP9q7ES5ATtWD4 +SJ/IvhIqThcMLUennAfF5EwhS4zPetazmCMVh/OUrPyJpoAi8IUkBDcosUuFE6s/+tGPLrroItZB +JeMCBMlIaTG3p556KkuGrA5iTpihVRkY7N7tbndj3ZHhKfJM2GL7pcd9yo9OBfUjepQX7Oc//zkF +xg7d8573xDBIgKVKzUUT7Ka0rs31Q6gKBcQ45MryMLWmPJw6ZZ/Ogx70IIT/5m/+5n//93+5FgNV +u3btYtpcLw1Uc8eOHczcOkpwrrjiCp/N9npxPfItb3lLFkrBgRphfRmhIozytsDCZ/qX6kPgGFay +KMtUhILwWXYV3cGndjjKQEUQ08QDVVhqx31LsVa61CCH/kBgQQjQ7+TpCSZjyhUNZkqTb6xcZpXR +LHqx4YW+G0cvSV9JL4kdnc1hElizZHTFLOItbnELljmxQwiTCmQ8Lapw8BkCMqfKzPCLX/zis846 +iz0ymEn4Alq5kClB0cziss7KCVG6e3YMUTzx3/Oe90CTIyYEx9FG8d1HCQVQMFcIBz4cCMbHzLJi +dT72sY+xTCvhM888Ewt9k5vchLnr/Za2UE1pkE8uWGgWX+XYOsT66L3vfW+WhFnO5CYp7rAld4Sf +8pSncAKHkfFxxx1HXRihcunx/e9/f/Zn8caAAzqwQpKdULy+MKH9yle+kqDXCzPGtixGpSjEMbV7 +7rnnshKMzGzAckURmSKAwzbf7373w1cQPrGic99/TQjRFADLzYsXk+f8HFS5J65UOum0x331P8/u +SWaRyQGJwL/8y79woeUBWfQDvNA+cyWCMQoEPq/qU9N7OVGHAeWQ6dCgnZxT90QHR6XxxTnAAWgU +nxEed+iw2eeUU06hZ6d/pNOkx8QhQU3bVpMlPaYrt23bxhxmW4ECE2uqa4BYDSWVkCzItAYf85jH +0N1/9rOf9Sj14yy7OmeuBL8vOnl7KCTEmlIXFWx+pS0o9CAIU2tNyToTgnuP4bMhy5kMSdleRBmw +VTDZgqQoxBjWa9HXhUWQhF+K7UsF/mIF9VDwXOB4uWEQzJ5qPsB329velvcDLPp+M2JNmleH/Yp1 +EDj5jGdwRUO4QCAQOAAQwGbQa8hG2ng0XWdvxjSZE7coThwAVequiIxCtL2Wgy4aasDBmnauKd03 +t950l4NJucXdrxVkXhfzwOjzK1/5CmuZnIqRUVdeGvB1n2+rJNoK+5Ukwyy0C3dfWk/SgeDtpO1V +SiMjI3mmaHADz0biXGEH0DxJLr/oNI8GdpQlUqYuuLmQlyHaDO1k0TNqr5Drx5jkbR8X3EAgEFgB +CBQMBkHGBGnUqb82MsPBx4leZT71ZCTENCMDPo45Mh5i/LGMlWVnEyumX/rSlzASrBoyZbrKAD8Q +q0N7oFWwRMoaOSd0aS0aPfeoLiyBp0uXepRdZBMIBALdI0DvwLu25EW7X7JvfdsEb7qId9ZJzu7z +WuGSDC+YfuQIJvts2QvDAUfGHHqj6H3J2daE83z9N3JOED1GgJ8AO8qk93nnncfEPsu3tJbeDUmp +LYdhVud7bI9/ycguEFgaBNx20llAk4kIhqacoTCO3R3YeIhFeHBpSrRsWln0OvbYY+kfGXa8+c1v +ZksRRxXZ2srpzHx+ddnKFxkvBwJM6jLZzuYmdl+zNM6UPnaUIzfdLJEubnn3ub1zcVWHtkAgEFh0 +BMxScne2fRwmfarTNvHOzO66NV19BpUa0T+ypMf2FjYf0XtyYwAnNNgyE+PCRW9mB4pCtQr2NNEw +HvjAB7Kyyyop71s9bv98oCZM6YHSZqKcaxcB+gUflYJC2nqUdhvZF0vtmoY1Ag04cJqCFUq29hxz +zDHaK4spZWiyRhCIahYQYEKCFyw2EvOChYNm2r8g05sgpjS2HfUG6sglEFgcBLAoODOijE6THU2M +tWJQ6SvZWcq5C6Z2df4hRqWL07AOQC20fKypVs31LCxLJdhNH6PSZUE+Mg0EukJAvYOGpPnANK2V +okEnYRqq1pRBVWXpQzkV0xWUIRQILB0CTPA2dwguXSahORAIBBYTgWRFyjadJEublkoXM4PQFQgE +AnNBgNfceKGbC2AhGwgsEwIymvsOTxtrQg172jSsydCulcneZfo1IttAYB8EwpTuA0cEAoEDAoGG +sUxbeL3AblCdE0QgEAj0BgF21O/n8q3elCNyCQQCgQ4IYCZ9oRQCSRt1Nr/qJMsaprQDgBEVCCwp +AjyVfBkmdvAuKcihPBBYEAIFG9kIpj+2i3ff6H1DC8o3EgcCgUCXCNTqtUoY0i7BCrFAYNkRwFLO +DE9TaWx4auZ0ZnE0p5e9wFGAQGAtIMBDx8WBYUzXwm+9oDryEaIFpY/EgUAgEAisagRiB++q/nkX +o3IL/JLfYhRh7epgDIqj/vhcR5DTBG0Ayt286WvY0O6QF712gYuaBwI9RIArx1gr7WGGkVUgEAjM +FwG3jvuYzHRNGhy0usB8c4h0gUAgME8EYlQ6T+AiWSDQSwRkLJUjY9P8olG3o16eXNiZQQQCgcDS +IVBJ2+qXTn9oDgQCgQUhgF3UvC5a3Ea6NYWAKbegbCJxIBAIzBuBkp1Nm9n7N289kTAQCASWGgHs +pWfhdMOKNid4WwWcE0QgEAgsEQL2ausvvEuUR6gNBAKBeSPgJtM15LYTZquASwYRCAQCPUKAL8OE +Ke0R1pFNIDBfBLCXek5FyHzmPooVzIn55hbpAoFAYI4IxKe/5whYiAcCy4yArCmFaN15tMwli+wD +gTWMQOPTwWsYgah6ILCiESiMPikrHDFV7pxe0TWJwgUCqxQBthzFYZhV+ttGtVY7Am0taFvmakci +6hcILDMC9b7YdrTMP0FkHwh0i0D3ZrJ7yW7zDrlAIBDogEC9r/H14A4yERUIBALLi4CbRifalqdz +bNskwQwEAoGFI8BhNHbwLlxPaFhDCPiWbyfWUOVnr6qbMSdml11QDPrbIr/U+S6o0CsjsePmxMoo +1yKUwn99Jxao1CFyYoEKV05yh8iJhZeN27FjrXThMK4VDTxU1Wr1M5/5zPe+970dO3ZMTU2tvsds +fr8lz+TQ0NC2bdtue9vb/uVf/mV/f/8iPqUqEgodbSkvBL3ki561az5widXddPnFF7H5BVbzaOf8 +BKUT7v5X3/zQm+aROJKsKQRkRP/7v//7xBNPvNOd7nSjG93okEMOwWasKRBmqyzg/PnPf/7Vr371 +rW9966KLLj799HufccYZSwGOm8/ZShJ2tBWZVd90F7H5BVat7acbzi3v/7TS8Xd91Lc+8uZupENm +zSIwOTn5tre97aqrrnrCE55w5zvfOfrrti0BO8eHz775zW++973vPfjgg5/1rGcNDg62lVwIs4M1 +jd+lFdi103QX3vwCq9b20yXnlvcLU9olVGtYTA/YNddc87KXveywww8rl+wssnrtuMBZ7YKt8Gbh +mACv1arV2pVXXvGGN7xhw4YNz3zmM3tmTfWLrOF22qbqa6TpLkrzC6wW8qje4n5PrdRnrshu0xaD +tcYRmJ6eZlL3oosuesUrXrF169bqdLVWSl+cNisaTWemdZgtTaNSBqZbtmw58/Fnnv36s//nf/6H +md5KZZF3JMhqkp2yDyM68zNk1IHbdGlCuDk1m9T6bFIEN4/md6BgpQoKGcrMhV/5nV/Zj9+JXCBW +s6mu8Co9W1zw1zgCtLm9e/d+/etfv8997oKYn60AABNXSURBVMMYi3UUAKHjVt8tvxuIfv7zn3/1 +q1/97W9/y7Tncccdx94cFly7SbgUMp/73OcOP/zwW93qVouoHKBAg+ccApTwN23eBGhf+cpX7nGP +e2zatKl7rLov1VLo7D73FS658KbLNMx55533y1/+EpyPP/54Wuxd73rXLmvN2+fVV19Nj3/LW97y +Zje72Vx/qX/9139917ve9YMf/KDL7BbY/BaOVaGc7Ey83vWud5vb3KbAX3gwR+a+973vXe5yl5e8 +5CVzUrtArGbLC7WL/L48W07BPxAR4L3vy1/+Mk8F3QH0+PjY8PCI9Qupb+hyVPpP//RPb3zTGx/x +iEfc4ua32Llz54c+9KEf/uCHZ5999pwAueyyyzBRRx111JxStRWmADzkN7/ZzdvGzo9pUzs8TMlR +zrHRMXxA+8UvfsE7xP3vf/+BgYH5aY5U80NggU33ggsuOOtvz+K17z6n36e/0v+db3/n7W9/+w++ +361to3mPj48fcb0jXvziFw8PD5Nw48aN3VekVk3vZNP25tqNW2DzWyBWrSX853/+Z147bnXLub2t +7t69+49//ONNb3rTVoXOyZHhaePllXkyj+2GWCBWs2VBZximdDZw1jqfljo2Nvb73//+xje+MasI +kxOTY/39tN1KZUATLCya7hcjRrSvfd1rP/JfHznttNNcGM1YGg92Qzz72c8+7vjjXvPq13Qj3Fnm +3//t3xGYawE666xzUKVmszscEJpIDqAA7aSTTmIsDowgNtehSeccI7YDAgtsuqOjo0944hPuec97 +vu2tb/NfbU6NFuF73eter3zFK6+44opbnXyr/3z/fz75SU/uUOBCVK1eg9N9E11I81sgVoWSK4hO +XPflV6rzPnPeq1/96p/99GdtdYqZI2N51Oacy0Kw6lAwFrvi09+d8FnjcfQp2IYb3OAGWIJyfxl6 +bHQcJrO+5vN3f//e9P+9iUmYO97pjrnk6JilPeed5/DiL/7Ff7z45Fuf/Ovf/JrgVVdf9cQnPfGk +G590/A2Pf++574Xzun963de/8fUPfOADyHzq05+C841vfuNep93rqKOPgvO2t79tz949MC+7/DKC +SD7s4Q879rhj6Q2vufaaZ/7dM7HBD33YQ/9w0R+Q4R/8t7/j7RCoQj7/980Lvgn/T5f86a/++q+O +OfaY29z2Nud/8Xyl6uxTH8rAazXITE5M0Gw4CQNoQMduDrBa4w2p99UH83k33Q988AMcbXr+85+v +hqqf3ulLL7uUJnTCiSec+Bcn0lBpda1tgxcpcofPhiBawmGHHQa9fcf2pzz1Kafc4RQl3LFzhxJe +8K0L7nu/+x59zNE0+Fe88hUwaTNoUOzLXv6ypz7tqWrh4rT6C2x+C8GqtTBwvPp6JHmseKB4DHne +AUFJ3vyWN9/hjneg1o993GPhXPjdC1/+8pdfeeWVPI/P+vtnweG5Pv0+p5PqjAecAURKlSNDLpNT +k+J37y8Qq1lbMt8rZSph1uiIWMMI8M7H+GpkZGTz5s10Bzhf5KcR+9t6Z4QYkz30oQ9t+366ffv2 +Sy+9VFE8IexsIjuCH/zgB5nO/cY3vsEUGf0RnMc//vHf/va3jz766Oc85zks2RL7qEc96klPetJ7 +3vOe7373u8973vPWrVv38Ic/XEpe+MIXvuhFL3ruc5/LVQk/+clP/vqv//rTn/40Gj7+8Y8/+ck2 +MiA5Fg61nI6FCYea0m/+6U9/OvbYY+E//elPv/71r88J0U996lM83ueff37nOuaxtgmi1MdGXuAC +IqADQOpFFl0ilmsLen4ILLDp/uY3v6EB2Ca7dnMnT3va02j/H/7whykbzeMZz3jGueeeWygnBbj8 +8stpyay20lZ5m0QV86i3u93taK40knvf+95f/OIX73e/+zFsfeQjH3m3u90NyYMOOui6665DEv0o +hPiP//gPdq598pOfFKeQS2twHs1vgVi1lgEOOnGUX4/k3zXdYx7zGHYqPPCBD+QZZN2HxSNeMjCf +SJ5wwglsd3/HO97BI8l0DpxDDz30Va96FavUL3jBC1g5JgrNjkyeS9sy7Jc5D6w662SCN0xpZ4jW +biyWbP369azzJUtqplQWAkQwDN3YBhZHuQNIE8IFHNGGBkWhllh8gjxIzCqz58J3eWCQWHDCXvLg +IcapTRJiVhFm6wF9zfvf//5HP/rRUsUc0R3veEfEsJcPetCDnvjEJ0KzyQijLgHSkjU0jtoR+8Y3 +vvHHP/4xW0UoKqs1rJO9+93vxtKzpEpfSRV4qhHr7GyyKR1KKNfLtsm5VqPrJAuKDYyd00bsoiOw +kKbLhiPsKL+dl4qenV+TG4V43+LcMO9wTN0TyzHrs846i/PWRx55pAtD0MawxwhffPHFvErSeuGw ++wyzSizaWDThPe8BD3gA73kMCv/hH/7hiCOOIIoWiG+9fF8ftvacc85BgLtQCHZ2C2l+C8Gqbamo +LM4esIThS1/6Up5TJFkH/dnPfiZAyJQn92//9m9ZkCYKSb2y6xmHw9Z3Kb/97W8PDlIlZESThR5k +iXXvLwSrDrnEHbwdwFnTUXq1xLDRiciU4tN202NijRh0kOmMERuFeAOVpSxISpWi3Id43OMex/Qa +Po/Q61//ekaKJFSmEmMse5Ob3IR+TQrZJEnvRpSKhNmTGEGn4VBU8XNVaPjYxz7Gg8q7sDJiMAET +jrTd+ta3pkNk45Xyms1Hp+DC58WZtHSX0PiUU1GzpQ3+oiMgwOfddJn/UIvygjEGfeUrX8nbGI0Z +5sknn6y2pH3gMAsb4mgP7NzGhNBWGXHSqJgmoTHQntndirXA0N785jdHCVFkx2uf5wVB+2Emg8mV +Bz/4wbI0eWwrvZDmt0CsWgsDh/JQBWqnh4gRp+DiWSAKmvcGhvIMNxl2v/a1r2VfHqkkLEmCX/jC +F97ylrf4a6j4yEiDcnGaYJeOJKoy/iI+qqZqP31hlwUMsVWHAG2Otz98ds3Qjt3BdMeAtbPj3Avv +njwPrWI8FbRm8Xft2gV+qCXISJGxIMNEgnRAEqAYyIvmOfzd734nYTh0cJg6RbkSgiShzOKT1pPn +/O9///tkgeE85ZRTJHnMMceghF7s803H7U6K6uA7ICLIVwRz1GQHjY/acL1BwDGfX9NlGpajLBde +eKH/4vyglJygRp/MmiiKdgif2WCXFEEB1N54P2O+hMlb+Bzk+OhHP8qsJtb0Fre4hQQworyrXXvt +tbkGsmNd4N/+7d/e9773feQjH8mj2tILaX4LxKptebz6xIIPxZNYzmdy+//+7/9YpmHeiIkfBBxk +aDA566yz/t//+39f+9rXkBH4kkEJBA6CJKK79xeCFcWYzTGwKDOymC06+GsZAVoq7/X4bKXhsafV +eiuk4eZB57cSnPpi+Yd5MHzF0g196Utfgv6Lv/gLrOCePXu4upb1J6CWTg6hwqTPuuc978m7nlKx +ZMLUkOiHPOQhmN5PfOITyKOBs5tMGSkKJSLwoSm2gtQC57T4zOU+9rGPZW3VkyPAGzTDiLe+9a0M +FwgyOND+W6Xt0qdgOHJh7o58BeNabks9rrtjPr+mqwOL3Pv405/+VL84v6baD1dPMwvCIJVWQStl +NZQRKm2m0DAQ5ten1rR2Vv1PPfVUBDDPGE4W+3/0ox+xM4BNajCZ8mX6l5EZ1pTWjgmBqbT3uMc9 +WGhgbZXxWUF/52Bqfd02vwVi1bYkqr6iAMFlnM+UOE8frwtscaC0esyBkZVjzCryoEFCOHw2gxkC +YQVfyEiha3P98yDmhFWHZswZG/u9wwUCbRFgnY/FG+wWTZlGTLOjsXb/Aogkb+UcrGTCFltIH8QK +E9s06OCIYqGIY+/MX7EZ4TWvsVMu0sybOytJ9FBMvcIX88wzz8S2Ma9Lx8SKC4tVmEC0MWRkTeXv +//7vEaNsKPES8qRRYCWn8DjRegKhWXNlVezNb34zs3Nyn/3sZ+GjnIozbqDAOM6GKmEH3zOFEE3W +dLU4rp5BW1t4g7l0CCyw6dII7373u3OghcbG9jSmamlsNACmKBkpYiBpojimdpmo5FWp0DZoY7Qr +thFhKbGjmEME2PXGg8B0LodNGXJxvpllBdo/hpmtbWjjGeGmayRpPGiA4K0RPQh/5zvfKWSRB9Xk +4KTWZ0/onJrfArHKSyLaHzHKkz+S/hj+4Q9/4HQcB6/ZG8gUFCCQEJy51YQlFebSea6Z9WV6gPda +HAkBQfUSMtCeizLt0l8gVrO1WAakpaPu+PDvfuJts0kEfy0jwJiMRZ0f/vCHtGyaO48cDZGnFAcs +NOXuwWFUyhYMbCevonkq3jrpcXIONKuzbTf7YE25qIjnChkmh+nIWA2lIyskX5QgVhCT75sg9qtT +Sy+8X+NYFWPUQn15ocYkU2tf2d2vnhBYFAQWpemyMKGlBBq/2ryXjXYLh/ck53RJYE21jYh9bbyn +qjGTVo0Ze9ClnoLYQprfomBVKE83Qfbu8vw6AkoCLAzcGakTBGT2fyHAk0hQmwS70dxZZiFYzab5 +5qc/mbeGOXSIsykK/qpEgAcb00V/wfVp3PmHKYWDNZ2TERUy9Bq4VpR4llqZdFJtd/oUdmfwgt+a +drE47CfEzVUbTyl2lCVSxvEMZ7njBgDn3T/ONfeQdwQWpenSDme7fKdtu/XcOxC0B8UW3tKYF+mQ +qsuo+TW/RcGqyxLmYoVtz4rKYXGQ2fycJ1wUen5Ydcg6Jng7gLPWo3gfxI6y1ZAxIic4eTdkyDUP +O7p2cAQcIGKJlK+jM/4AOgAsvHevHTSWsaZrs+nOr/kFVgt/VEG+f9ORJz3pUfdbxkYfWa9kBHgx +Z0qWKRcGpkz2Mi5crGmWlVzr+ZVN77nsLmENjHkqdgWztzOmducH5sJTrbWmu5DmF1gt8FF95/s/ +U7rBKQ//3qdirXThT+6q1cAjymoK65TsPGR7LTtv2RpwwxvekDVOnsBVW+25VIxJXdZ1WFdjXZkN +yWyPYr8Sh3Z0kG4umkJ2MRFYI013UZpfYLWQ+babnf7kMKWL+eiuVl08ZmzBYIf6JZdcwm6aSy+9 +FJpbweCv1irPqV48hOx+Yi6Xd1tOpjJ2h2YJaiEP55wKEMKzIbAWmu5iNb/AarZWtF++bTviG4v7 +lQuBNY6AnlV2HrGPhs0+LJqyHMjmGtYF1zgyqj6rTbrakNlvHIPRWB9dIQ1jLTTdxWp+gdX8G236 +XmmY0vkDuKZS8sSyborNYC+ujnzEqFQNgD6IuW7wgcCtqVZxQFR2dTddmtwiNr/Aan5N2o7QhgsE +ukcgGQu7zEXnr7tPGJKBwPIiEE23e/wDq+6xMslSye5BnVuakA4EAoFAIBAIBAIBR6Bej3OlDkYQ +gUAgEAgEAoHAHBBgGybSjEhtdWcO6UI0EAgEAoFAIBAIBPr6sKN85xgkMKOVmN6NJhEIBAKBQCAQ +CMwJAT7vwxck+dIGqTClsVY6J/RCOBAIBAKBQGCtI+B2lMNvYFGztdI4GbjWW0XUPxAIBAKBQKBb +BPjKnsaj2FGtlfbV+xiVdps+5AKBQCAQCAQCgbWMwG9/+1s+bMy8ruyo1koBJM6VruVWEXUPBAKB +QCAQ6BYB7OjnP/95vkOOHeUD5rKpJLaD9jEo7RbFkAsEAoFAIBBYqwgU7KjP8YKHHYbBX6vIRL0D +gUAgEAgEAoH9I/DrX/86H49iR31sqsSx7Wj/IIZEIBAIBAKBwJpFgLnc888/321nbkehgSUdhlmz +8ETFA4FAIBAIBAKBjghgRwu2s2BTlbp06C0e/JMvvLOjqogMBAKBQCAQCAQCgfYI3Oz0p5QOveWD +bc20XivZMdO0flqv1e07lBZI6Yg0DhcMEi6VCBq/3lc3jr5YaZSEmzlxHyFakYehlM0Y2I3bCnVn +YTNhQ7gp1kglrWhIwpbWBVSepN8UUqCmKhORcgknPjIIWC4WlfSmQFIwE7YUSaohIw1KosKIU04F +QdKZMzmKZQhItpFlCpbKVgxLpZoY0ZC0qJTAYiSQwl5nohNtCUyk7rWULlRZMhVW+smr1MjJclQS +QZEyRlHz51B4pljk0FSbohrZJRg9wlRZoZzhRU+pZwAXnHW2uiHRxHafVFZUK3rCJwk1y+kprNZJ +pvkTCSZK1tRouTYKKpBNo0FlIuYMIFFN36OyyKTQG2o6gq06miKVoJncEDStbZzJesFIiZQyq9vD +ZsClIL87/0yLYpslbKpNmAAysemXh58B3kjT5FgQWmktZalkecGxapunBGRpRfOCW8uxKJNKuag+ +KaWRyrSppCGdMk05ml5XZgHXkxLuo1Oam/obOZi8FcDaQLNQFpWUNpgqQ5IzWZU1+RaS81JYWpRa +XRKvkUFBvJGqwU1ajUWqlLrxA6UiSUEzQZLSAysA9okmvTkyVrkIoi/VRxWyHJSpJBoJElsJLT51 +MoaJSpMSSNJQMqyQTf+bh2tIJp3Elgf7aVt9o+NTU1PqwCkOolYoK4+lSAVsJE8xJEjMmR9CMpam +IddQ4Xyi5EhjKmdyMbZSJeGUmUqsUqgYYptko1JNhrRKnejZOA0+uaQy5MINtfuwFDDR1IyaORjQ +6doiYqzYQKj+yipuj0xiyidoMvZpReP//4ctrxHxuTLyAAAAAElFTkSuQmCC +Custom InstallIf you select Customize you have the option of selecting different themes or variables to be passed at boot time to the kerneliVBORw0KGgoAAAANSUhEUgAAAm0AAAG6CAIAAADVuubjAAAB32lDQ1BJQ0MgUHJvZmlsZQAAeAGt +ksFLFHEUx78zErthLGJWRAZDqJjMxjJ7qdtuewhhhUVXzfCy/nbdlZxxmBndig5dunUrOnReJOrW +RS/hHjsUKKJpnfobJImWZfr+5seyHpQuvuHN+/we39+bee/3A3oGS667rAOwncCbfHDfeDj3yIgd +QsNNJq+gtyR8N1so5Lk6w473qabtJmWtT/7e2I2v6deNkVbs1efi1hmbOumExw8CmsnEQFVxRvKC +4qLkeuAG1NQki1qpTH5ONr3iZI78npyoKt6UvKD4i+Q1UZV7D8gpp7zkAHqcfLdc8QU5QxZlX9jk +Btm07RXW17fJo8L1uFf/Qx6Sc2GkPdsHsh9ZM9HNzbwBPqwB12U7RiTD8GPg8m9gc72bOzqIZqVd +jfuLaSvSab0bwIW3YXg0C8RuA+3vYdjaCMP2OtDzA2gei1WPtZVa+8Yf/s9a9az0wA57oEVndDqr +uUSqFNBoAnNcjGeAd/SRa0D/T6BALmagp9MdVzOkFLiYz00kLauueopS5/Oyl1d5TpHJDi5VnOkp +xj76IPLIYQJJWHzqsNTZSe38S+CWvNZo/v31QsaTFlSeRDPJrbhPvaVqLTCyvLkV0xh3xB3TsFKp +e/gHmVWEZApHLZsAAAAJcEhZcwAACxMAAAsTAQCanBgAACAASURBVHgB7J0HgB1F/ce3vX49l0sl +lRCSEEgooUsIvSsgKB0BFRAQsYIKAkpRBBEUpYOICIKARnqR3ksqBNLLJdfv9fe2/D/zJqzvfy2X +u0u7zHK8zM5O/e3sfOdX5jf6AVc+4WZzdjZpZ1KeaxuG7nG57tqA5xHQPc3RNEPTdEPTNc/TNcs0 +TF03iNI01/MCpmGZekVJuLEpvWhZk0ESkUlzHZdEOhl1nZyu7bquV8ipe65HLIWt/fVEUNM90lM7 +Wbgcl6pkLTo5dc3QKVo8JC0NE9WLXBq5CkWJEihZ4ymRoguiGHFLSLSBMPUWyhGVuTSenhbSeCKW +pOQWjRXtF7lJL28pT9x6jqirkJcqBVVE0SKl61KC6Ka4iCiUINoqCoSqrk4J8imlimZoBdrwb6E+ +0QNxyYYSJcqgRQUKcUtTRTmOSwJqErU4ks4iF/eCUhTi8kAQRFTwRd5CA+iK6JN8H3S9ULxoqbwo +VdRVKEcUyD0RBWJ+0Sg/regU9CcNr5jssgOCyqIO+lXoKaFCMwsFFUitGTwv5CVr4RmZySSJLDtV +iJFNEuUWhoEglGhv4dkXGSlB9FzEi4aJEgsxDBVDjFZBFGK4NWmPYXouo3jtBQXJxSWy8C5EowuP +Cm1eW47jWqYpyF4YIiIxSQpVyFJIxkWYKmRMh79QY21FgjYUINomsxiG6YdlUfJXliPaJz5A2TKR +ld6KTskxIloicssCSSlyiRYVXiTEoosEbfGgMJC8QMCMxAKxcCAUCASDBRKQheckY4CJr1VQvEBS +URiXKEF0TlZJWi7RZ0gm/hGPRaRIKcYjIRpsUjMdlJ9S4alolUP58gMWUwcZSWzYjkNAfgiiMFGS +6GJhLOgUyD1X4XsRkYwfXhezjYiUg7kwQrilCvFQvNJCA2WjC+2kKV9EUqvIy/VF2SLD2jvRS/Eh +i6eMiEKbC30UlBFjWqaUyfil0sIXKoviofgCyOu6juOZggxrC6bDvMXC4BdPCzXKEkVFXKK/hbz8 +y+U4DmnIROCLoclMJd4oP4KyopXiZYmiILq444caNFEvffQgnlF4HaKJUFgMc1E1xYuwaC1BkYHO +iUIgsiAfBYnGFLrHJ00W8TmJmiAv1ZOIlNRCmTQegvKqC2T3KId34rgOBZDBtAwPQogOFZopKjWg +jXhxJpkLdCh8oTygPFESyXVKcC3IQ0cKl6xRlCgILGohmsSQhmaKocTcazAqTOqiQkFrHoj5SCSj +bprNK+EfSoBKgkxUWSA7IdvxGFH0iAei4eQS9OCFiV9KMS2GIrGiKlFYAfzECNcD4WgsEI1ZXi6b +SzYPLw/usfOY3cYNHlwZK7Rc/SgKKAooCigKKAooCnRMgdrm1IeL17z7+erlTXVWPp3YpjJwwp5j +Rw6IZLPJ2tp4x5lUrKKAooCigKKAooCiQIEC8ON7jq4cURV99K2FVj6T3GWn0YNLjGQyqeijKKAo +oCigKKAooCiwTgog1rVtuzpsTR1VbblOfsKQklwut85sKoGigKKAooCigKKAooBPAaBzXE3UQndc +GkQ3W9Ct+w+/CKBDzufzjbW1Hzz579o5c7KtrTwJlZUNnjRp6lFHVA0eHAgEhAa5k8vPPufJJ9bM +mZVtKWQvL6+ZtMOko47uZvbVdbUz//vk/EVzWpMtFFgaK5s4ZofDv3T0oIHrqL2TRqnorZQCupcv +MZbUDFgQzw5uaJ2AhZlrBrdSWqhuKwooCvQRBWKWru92zm+uOXFKhwUCWtlsdtbzL7x9z30lodDA +moHVw4YR2bBixZo1dclcbtoZp00+YEYoFOoQSmX2T158ft6D90ZDwZohgyuGjcBIqnnFsjWrVqUy +2QlfP338/gd0nf3FN597YOY94ZJA9bDqmoGDsF5bvWZVw8rGfMo5+Ygz99/jwM6yd9gjFbkVUiBg +JKsC8weEPqnUFgYCWrokprl5q9VLrZywzNqtPjRk49OkYN+IxSPGuv+zzOx+M3xjzu5n6VlKxFaW +ZfUsr8qlKLD1UAC5rjDf7bDDcKKzX3jx3dvvHBmL7Thim50OP3y7k0/C2PjT+x/4+KmnPl62jEcg +KFAKV9q+BLIveOn5zx/403Y1JbtMHTVy+kGDDzoBe+fVzz28+IWn33//Mx5hR7zd/gd2lv2lt56/ +94k/VY6ITd59zEHTjjh05+OS2fiTb//11Q9fmv/e8nue+BO1A6UdZm/fHhWztVHAW7NwWsVHpePm +aamQpuXZCJLN2ulEczSCtboR2m5WrLU52TRxkTGmyStjq1Ab+rz22msDBgzYfvvt28T3/vaJwnXH +HXdQ1A9+8IMdd9zxtNNOa18sK9G33nrrs88+a2xsHDRo0LBhw6ZOnRqLxbrI0r6QHsc0NzefcMIJ +t99++8iRI3tciMqoKLA1UMAqLQkUtih10NmG2tqP7n9gu2hkWiy2jeNWrVzpfvopOFq1auVk162M +xt72PBIMnTRx4NCh7fM31a5a/s97dxwV231yddngUMRs9Vpr2eYTNVpGjwhWBQa+Nctb8M97B06Y +NGDosPbZa9es+tvMe6rHxHbYf0jNwFg+1LImtTSVS7jR5NBtS0NVQ+e+VEuCCWMmDR3cQfb2BaqY +rY0CKccy0gvM3Icpd1I6HYi3NuTsvOsFWyyrsqqkssIMVb1iZUsnZwMfx0P10bFt6PO3v/1typQp +48aNaxPf9W0qlaqtrR0zZkwXyVj5wefJ745wMBhs/w22trZec801y5cvP+yww8DypUuX3nfffYAo +oNtZli5q7MEjUJxcLFXbt60HpaksigL9mALWoIpQZ9/J/KefrfS8fUpKhmteWbw1Mnu22LzvetG5 +c/VEPKhrwVisJZ4gWdVpp7Sn0YqX/jMg5u2/59BQeThQalhOrb3sVfbYmvbKULlRaZTuX2I1vrCU +ZBUnntk++/NvPGWGvF2PHFlayb5xr95d8mHdS3k3mzDrIpWBQbHy6JGhV+76nGQnHX1G++wqRlEg +VDlw3rLy6nCzl39NDwzRgsMDZtA0025+Tf3K+vhqe/AwPRwKvbMq0hAbgYC1DcWwa0f02tnX0Sax +fwsXe//99999991+TPsAEMUlSy4OF6ekhDVr1jz00EMSZcHdSCTS0NCAXUNnWYqz9z4sxVT8ri8F +el+1KkFRYMuigBXCz0Uncl1r0aKdotFtDGOArkc1L9DUaLzzLt0LZDKIyYI4pHA9EqxYtKjDEkrr +542eVBWpKQ1VRAKlISviGPmFLHDNUpQuMStqGiFr6qSqxQ3zO8y+tPnTMbsNHDS80gqauE/SzUyd +vQDHFpRTEow4TigSDY/edeDS2k87zL5lvQbV2j6nQHDVrPG5+fFM9ZrPD4kNfbrMXGW4ecex7XQz +blJCIS2X1z7+OJqoX5acMH2tD5t2jQCxGF2JROL73//+xRdf/Oijj86ePXvnnXf+zne+g2Ke5I8/ +/vhzzz1XX1+PxPWHP/zh559/Dv7BSn7zm9/caaedzj333CeffBJkXbZsGRzqqaeeut1225GLYvn1 +x62spbhyanz66acvvfTSdDrd4YY0sjz44IOkqa6uPvvss2WxHdb18ssvv/TSS0cdddS9997b0tJy +yimnTJw48fe//z2c7oEHHnj66afL9jz88MNPPfUUuphDDz305JNP9ptHI7morn0C0syfP/+uu+6C +V66oqDjiiCOOPPJI+NcuyFXcRxVWFOg3FLD4SDpbb8ZaWgcHrMpwqNQ0g5ZlBiz8IwmvSaGgZdum +bbu2M1jPtrS0dlhCVSBZM7w6PLA0VBkNxEJG2GJ5j7MmzY5a2aAZCeoBq2Z4uiVR32H2hNs6acyg +kpJowMLpoGEZ4o8pKO+auBe0HdcOukPGVM1bWdth9n7zhlRHekaBJfWZYVa6JKJb+XHplYMbqx4b +NLQFj2Ns8GpNROL1w3P1I7x0mW43GEOX50s6sDYCPLgYXZjbrFy58sYbbzzzzDMvuOCC88477403 +3th3333r6uqQtf79738fMmQIWELKsWPHnnPOOUApF7eY6Q0dOvTHP/7xtttue8UVVwC63/ve9+gO +Hx2/ctz6tRR3E5AjfsSIEQBbcbwM8wgF63777XfLLbf88Y9//Mc//gGE86jDumjDvHnzEAX/6le/ +AlNvu+02QJcuUAirgYMPPrimpuaZZ54Ba1GF0tOzzjqLrqGLlc2T80OHCWCOf/aznwG6tOG99967 +8sorw+HwjBkzOiNX+46oGEWB/kEBC/+W8oNp3x/YwFDALCktZeltRsJ6LKZFIsIrYSajp1J6Ol2S +yYb1OB5IOyzBwetuaThUVRKsiJjRINynFiiYctiunrX1IJBsmKWtJOswe8Ayw+FQSThMMQjjIlYg +bFrAcMax03k7y+xmuhEQ3VyrZ2rffhWzNVNgwPid5iVGjFz18pDKVMgtN/Pn1q95WsvXx1eOtOM1 +hvDfmbaCKc1yzboPGgKlrhVpTy7ARnweBZHvhRdeiLoUsSraykWLFu21115S6guTCg+H5hL8ICVZ +4MlgIglw7b777hJXdthhBzhIWZR8JMNU2n4tG48Lt2KAn5+mTdt23XVX2gPjS/n33HOPTNZhXWQs +KSn55S9/CZsIi0z7L7vsstLSUhqJxBhGGVuqZ599drfddgO8iUQf/NFHHw0ePFiWyS9XhwlAZUTf +J554YlNTEzwuBIE/Bt1JT6XtydWmC+pWUaDfUKArHA0OGZJsqA9UVBixmF5eplVUaIXPz0sm9eZm +o7U1kEgks9lg1QD55bQhSq5kQMLVrLKIWRIxIgE9bK7FUThKjOkN03K1uKvlSwaAhG3ycju4aki6 +ORe2gmHLgictCYQjVhh+FIf6lpG17HwWEV1LflDVkA5rb1+gitnqKBApe7kuNLlx+bhR2zz/+uyP +ZtfvOnHc5FGD4lpzIMi2E211c3IFw3S7XV1d7KFuQx8f7ST7WFZWhlyUNL7etLy8/IYbbgCi/vWv +f8GqAmM8laPR5yNffPHFxx57jEhyUaB8uk5+FOtcioIJBp7btIpbyoEDRntKmKL8YjurKxqNwjuS +DCkxWWiblBWDmrSKJlHU22+/DdvKUxSxJCNSNpLfzhJgRQzoYtYry0RwjXWxn7E9uUimLkWBfkkB +S/jD70Q/WrbjjstfejFfUR4GQSsrtaoqvaxMUCGRRL/EajZvBVbUri6dvEOHJZjDJy+te3fnUMBA +hBu2tKChw4/i9wHxLN8voayztC5hbLNLh9knjpr67sLnTMeMhoOxQLgkGI6YYdRKfPuFExt0O+PV +LmyeNvbADrP3y7elOrW+FMhlEo+8+XrCNgN2fEhF7KOF86oqnGEDSj5b1fTx4rrauqaBUw8qD5YB +Rx2WDPYwuvjlKQJSOdK45SLMBXjAj/71r3+96aabbr31VtSEpJRPCaxatQqg/fWvfz1t2rSZM2ci +7CWLTMCvDBenJywvtJ6ANAwfguIv4v7fv/C4Mrv/23VdwBv5ZWJwFE5XFkcMF6iMsJftNDISk2NY +THohs3SWgEa+8sorlAwek5L9OQMHDiSxzNieXLJw9aso0P8ogH6UD6HtSlz2s3qfvVpmzXrbdfev +rDSrqgSUsjrmm+EjLBxj9U5jk1Y9sHrvvZoL69w21Kna+dAVT7334fza3ffdTkM4GzA4x4ZPTrc4 +PEvnJLaP59cmc9rQqYc2pzvwSrj7+P3mLH3t03dX7Tl9XNAIBBDuGsh1tYAeCBpOQHM/eXsRHOru +209PxTNtqla3igKSAnE9Vho2ynSO9itDUxCyzP/OWuhpgbrGlqqIPrKSw8OEMLYzcgEJ4vMoJJBh +mVKGYfLAJESgwCSbQaVcF1YSsyN4NYAQUSrjHTtbJKWvv/46XKBflF8aAT/sN4Nc6Fl/+9vfgkwI +jeEawScpbgXzirMQJhfFdqcuCpGJZTMIE0MY+yAWAUh9x48fT4FIlWm839TOEuyxxx5/+ctfgFIk +uitWrHj//fePPfZYEnNRcnGnisM8UpeiQD+jgFAuynHfvmMpx9nm6KOWvPrKe643JRoNhsMehxaC +o66bj0Q/9BqWatrwIw8nWYclpBytYuqJc+Y+Eq6K7bjLCOk8sMBKioMDZ81dOXfeqoopJ5Ksw+x2 +1j1i99NemvPAZxW1O0wZYePEDWtdTtVzPR4t+GDVykVNR+15BuEOs7fvjorZCikwfpd9Xl5TX7ny +FSkJYd9mMJvL2/nxNZF41p6XKp04aEJn44fZXwKATMCvDPjx7BPF0kca7gJ7VVVVQOmoUaPAFex7 +999/f6xh995774suugjx7BlnnPHBBx/cfPPN559/vo9n8o3IWtq8nX322QeukfIxlEWFCXsH73vS +SSf5bZABvyggcJ11ycQSO6nO7wh1IZ69/vrrpZZ3+vTpxx9/vCyfX64OE8B8X3755eRC7wv0Hn30 +0YcccghwTnoKL+RbC6gddrBNf9WtosCWSwH9mIuv+fKOgzvsAGYUTA3O0qXNH340dNTIYQMGlBX4 +0dZUamVDw6olS8sm72COGMHSW345bQqR2VPLZ7cu/teo8ZVjxtVUVAozpZam1OLP6xZ90lSyzRHR +4Tt0nX1l66K3P390yODSYdsMKC9HV+Q1odNaWr+qNr7HuOOHlo3uLHubxqjbrZkCn8z5uPbFe0dW +WrFoxLHd5XF7tTV04j6Hjxo9Gs6vM8pgLouEE+aSkYx8dfHixRjpkBhbVgIY66J3hDskUFlZCZAw +FGVRJAD2SIMdEDa0gCspkZSCUqgeCYBAXBRI+uHDhxMJayvzFv/CFCI7pQGUAzzLSvktzoLFEDzr +woULybjOuoB8nBMhgJWAinYTFazUlQLVVIeilBrBwva9bp+AGmXtMhe0ghRAZmfkKu6aCisK9CcK +6Ed991dfniyMGjq8+CT4fgbESpa++qqWSESiUeYdPhi9JLbN3vs0JBN8/x2CqCxNZq+IhT99859W +fkl5qYNAuDVu2dbIcXsc05zMdCd7aUXs9bnPNiQ/MwIZltBOPlIdG7vXpIPjzcmus3fYIxW5dVIA +YPj4HzdHg2a6ZtLO+xwEZvQVHRjk7T8BIsEqQIVa/AQSs2Vk92vH8Ae5LvDZnSy9rwvU76IiGtM+ +AZFQYH371UUt6pGiwJZFAf3wC6/+Suc4Smf4htkWxiqVFbQUYbHWRgrExJTJZOTCtos+b9rsXTRM +PdraKIAYFnXmNttss7V1XPVXUUBRYINSQD/8O1cdM7lmnXWwzgUR/QW1r2JZZ0aZYNNm72YjVTJF +AUUBRQFFAUWB9aWA5RQOfFlntnXynV2XsGmzd9029VRRQFFAUUBRQFGgxxRg34uHL+we51cZFQUU +BRQFFAUUBbZmCgg/DJwPtTWTQPVdUUBRQFFAUUBRoMcUwDdQx55celyiyqgooCigKKAooCiw9VDA +QD269fRW9VRRQFFAUUBRQFGgbylgiIPM1KUooCigKKAooCigKNAjCigc7RHZVCZFAUUBRQFFAUWB +AgUM7IwUKRQFFAUUBRQFFAUUBXpGAeyMepZR5VIUUBRQFFAUUBRQFNCUnZEaBIoCigKKAooCigI9 +p4DBCSo9z61yKgooCigKKAooCmzdFOBYxq2bAKr3igKKAooCigKKAr2gAPpRxY/2gn4qq6KAooCi +gKLA1k0BhaNb9/tXvVcUUBRQFFAU6B0FFI72jn4qt6KAooCigKLA1k0Bc5sd9zzx4H22biKo3q8f +BTgFb+nSpatXr+Zcd3m0+/rl74+p33777VtuuYXz7SdOnEj/7rjjjocffpgzw6urqzdEd5PJ5Ftv +vTVy5Mh0Ov3666+PGjVqQ9TSpsz33ntvzpw55eXl0Wi0zSP/9r777uPci8GDBz/33HN//etfBwwY +MGTIEP+pCigK9EsKGLpSj/bLF7thOlVbW/uNb3xjzJgxu++++3777Tdu3DjCL7300oaprbelgmpM +6FyATW/LWlf+Tz755O67737llVdkwqeeeorb5cuXrytfD5/vv//+pmmS+ZBDDnEch8D9998vO8sv +sLrXXnvdeuutPSy9k2zXXHPNqaee+tFHH3XyXEQDn3R88eLFjAoCn3/+eReJ1SNFgf5BAUvBaP94 +kRuhFytWrGD6bm1t3W677U466aRhw4Z9+umnTzzxRCaT6Vnt//nPf5555pljjjlm+vTpPSthQ+da +tGjRnXfeWVFR8f3vf39D19X98gGnhoYG+DzeCIg1YsQIPy/hnXfe+eWXX164cOFVV1212267TZs2 +zX/ay8BRRx0Ftw2T3UU54PqLL75IMw488MBnn322uG1d5FKPFAW2aApY6ty0Lfr9bczG33DDDYDo ++PHj//nPf1ZWVsqqL7nkklwu17Nm/Otf//rHP/7BXN+z7BshFwsFJLSsHjZCXd2vYtasWch1r732 +2mOPPRbiX3nllUhTZfYpU6bcdtttRE6dOhWsfffdd/sQR08//fR1NvLwww//6U9/CtyOHTv2Bz/4 +weTJk9eZRSVQFNjSKYAfBnUpCqybAkzcDz30EOl+8pOf+CAqswWDwWXLlsFTfv3rX5cxjz32GLe/ +/e1v5W1dXR1z/QEHHIAQ+Etf+pKUA//lL3+BXyHBr3/96xkzZsiUyI2//e1vAwagNSABDMj4eDwu +y583b95xxx3HNH3hhReipqWQvffem5KffvppmbKL3yeffJJCrrvuOhIfdNBBe+65J9n99G+88cYF +F1yw4447Tpo06dBDD81ms0hlL7vsMhKgiSTjf//7X8J33XUXvPgOO+xAvQAGXfNL6GbAtu3f/e53 +0AFqUOztt99OR2ReFiXE0BJYSYhw4okndihEzefzMn1nKxjeyC677EIa6AawUSYLApmFlRB9f+CB +B2C1ITukW7JkCY/mzp1LMl6cTEY3v/a1r4GFu+66K+9ORsrmQQ15255ixLPYuuKKKyzL4u1Dn0gk +IhOrX0WBfkwBSzli6Mdvtw+7xrQr9XAdMmdM6PPnzwdrZY1wQtz6jCZ8CfrCE0444eyzz4aXMgyx +ett2222RDDOtw7KAXsSQ/bDDDlu1atXBBx8MxiBQRZAIzwokUDUFYtmEfq6mpqalpeXvf/87IPHm +m29yi/EL6IhEsev+oi6lEDZMw2Ki2aVHrAmQKpeWltKMk08+GXz62c9+RvMwqKGoWCwGioCmVHHE +EUegdySSRQCmQ+AriwDKweiG3nVdb5unP/rRj4AxTIS++93vokGkRrr885//nGRAGi0kvGbNGmpH +PIsZl89r+uUA86+99lpJ4SJASv+RDIDu5CUM3tNN5AePPPLIpZdeSgyLIapA6Dpo0CB6R+GIrImk +F3SfbpIGNCUxixXgHNExoCiLlc1LJBLcdkgx4iWIEoC2fkaZXf0qCvRXCliups7x7q8vty/7hYEu +xQEhPTDQhVslL3ZJsJI+z7rHHnswU8NfggpweCQAVEAUUFMiB0ah8DRILzF8lT1pamriFuRj0ses +hryYqoIiQDLsFDDcHlFkxuJfcBFsnjBhAoza+++/TwkAcH19fSqVondHHnnk0KFDwXuy0NOvfOUr +gNDo0aN9sPRRDe5t5syZjz/+uP+ouJbOwqgzAVGeUiwKTlhD1iV//vOfzzvvPN+yFx4O61+wEJwD +DgF+XdeLCwT4uWQMLGPxI5YpLDVgneGnoSS0hTelLi6AjZQwmhAQECUMv8j6Btso1hAsHaAziYmX +75qSjz/+eBlTXIUMd0gxHvnY6Qfa51UxigL9jAKGqwyN+tkr3TDdgfGiYLgQXwjZ/XqQEJL4/PPP +ZwbHnrOzjLNnz+aRr8+TARkps2DhQgmEhw8fzi+zPxJmJnqJCr60Uybu7BekBER5KvlL4JMw7C/c +M9iAmev3vvc90K6z7DC12MF+85vf/Na3vkUamb2zxO3jwXsiab/cDbL99tuXlZUh6YVH9BMjsgbC +gXNigMP18jiGYBzLYRAU1IQHxaYXvK+qqgIaEZKDyrCnNF7WRdW//OUvCWMZ9OUvf3nfffeV8ZCI +RQxicNY6dLZDa+fuU0yWqX4VBfoxBQxdOdjtx6+377om+R7kt3CB61vqOeecAxMG14hq7ZRTTvnj +H//YYQlgBvE+T4nYktvOVIAdltCbSCye4Czhotj1iOLQVygWl4k8Gckz2AO2oR8tftTNsOyjv/8S +RlOGi7vZhvvsZskyGQwuvOyjjz560UUXSd1kIBA4+uijeUoHYUaBRilFl+kRWctAsZiBdw1HS09X +rlyJaBcpgkzT5rc7FGuTRd0qCvRLChieOu+lX77Yvu4U3JtkEK+++mr4pzbFy72MwAwAw1OkhW0S +YM+C/FCKFu+55x75VMoMfa0qOkvifduiDz74gFsZKdNv0F8agx0NtcOSwmXCzFEdIMQvilhZNXwb +/BywhHEQktgetEd2B5CGVmRH4wsHSYBFRg9K62YWCYTAHjpdyUbLjDCa6Ggx6QJxUZH6m195CseM +mB2DLGAe6Tfi4vZ1dUix9slUjKJAv6eAoSk/9f3+JfdRB9mGD66AJQAJ/OXzzz+PthLLFMJYzSBc +Rep78cUXI3pFtFhcJ5JS1Io+Iztw4ED5FI0pASyGMN5hTj/jjDOYtTGcuemmm1BhglU8Pffcc4uL +2kDhjz/+GMsa9J1wYHJNILWVuJsAYzCahcNDyytlrYAK6kb8UdAYtJhtOtt1CzH8keJTbINfffVV +uS0VOeoG3WeJyJryWQ3wW2yNdf3116MtZp+MXN/AjksRLgiKZhq+Vi5xMLxqY6FNHzujWNfdV08V +BfolBTDX/X8mDP2yk6pTfUIBNoSAnQgG4RRh3VBPAnVMsszOiCLhbNChwsYhFQQkimsEabBKRVh6 +8803Iy0EJuVT7HKZ1mHOUKBioQpKIVPFFw/wjKUP8760KiouagOFsQfGI8RZZ51FI1GOokE888wz +qQshM4sAUATuE5MiOHJWCSSgg4SxekUpGGubwgAAIABJREFUK+1gu9+wP/zhDwAnemKseFiUsLnl +N7/5Tfez9ywlBlNkhKrSWJowhkUgKECOtph4VKr0S25VglfmzbJagpHlKSpSqZAurrozihWnUWFF +ga2EAvruX7/w8RuFQby6FAW6SQG4FtzlgDGwocXKPBwbIdSVes02RWGdhC0u2jgpKS1+CtOD1hBb +GD8Su1xipB2QH7kRArSfHTvsxmlTF8JqGo9lkOwszYNJDYfDJIN/peUy3CZX17d0EKEuS4eNY9fK +rlzWQCyAOnw7HTa1sbGR/rbnRIsTd0ax4jQqrCjQ7ykAjl7w+I2X9ft+qg4qCmy1FABBER6gGf3F +L36x1RJBdVxRYMNRQNnrbjjaqpIVBTYLCrzwwgvY8cpNsZtFg1QjFAX6FwUste2lH7xQx005XtzT +WnLe6lR2ccpepuluWaiiNdWUdesigWA0GM27Gc+NGkZZxKoJWgMcN6S5lUGz2tLLdKPE0MThIerq +lxSQm0T7ZddUpxQFNgcKWGrby+bwGnrcBs9LZb1PU/acZG6xp69MZOOOHc+7WTRb6XzIztue67iu +kXN120XN5yF/aPFCQavUNANZ26iIDIuFxmjO4JA2zTLLetwMlVFRQFFAUWCrpYBVbCey1VJhi+u4 +p7m2uyLvvZGw32rNflIWLgErsdexHS0aDlcYA+A+k/kMyVgn5fOuZViWbtlk0hzLtG2v1XGNWLhC +0+uS6caWfGtL68OmNyIcMhynlMSmQU7X1EtLwyPKw9sHjErTEB7j1KUooCigKKAo0IYCFgyKurYg +CjhusjX7VnP25Zz7sW7YhuGZrpG18YdjA6KOq7Um87qWMFkfFfY05XG0IeLtcEC3jHBrOjmgIhaN +RFY3Ny2vXxmwBNLGE05Qs6rL6hesinuuRkaXk6F1DWerjA4guCwyqiw4LhYcNyA2MRYYaRhKCLwF +DRnVVEUBRYENSwH40Q1bgSq9ryjguPG4/XJ96rFUptbTtYChWZ7hOjpAmM/kiAiYRt7JxYIB13TS +GbBV1AyIDqyMVpZXrGltXNkQ9/J6RmtO1zal005pJFxWEsllHMfM5fL2svpUPqcNrAg3pzK2p5mW +lnE0N08JtptdnIssX+Y+o9cFSqKDqsKTa2K7loTGBMwaQxOHt6hLUUBRQFFgq6WABQejrs2cApgR +xfMv2cYrTYnP804KEGX1I2Svjmbjh8/zwL9gwBOnWLowk5gMGYFQOO7mwNlouRWLxNY0ZZauyuQ1 +JxjQshx75VrZtKY5TguYmcsanIulc6dR5OpmpMEaRTl5jfPN8HZFOJGyeRoO6XkvX9+0JG4tqY8/ +N7R6SEVgl5h1eDggvMarS1FAUUBRYOukgCWkgeraXCnguLnm7IstmZnx9FLXyJuGFywoKk1TR/Hp +4h3Z9eA7MSdK53OI6BG4NibTeVcrDwZLSk3dCOQz+rzVjYlMFsYUULRTWjoPDMNwaolsXjc1Sx60 +7GohC02qkAyDqWCnEO0KROUkLC3naemcrbVo0YiA8HyQvJnGluWDylrKYm8OqphRYh0asqo3Vyqq +dikKKAooCmxACsCPMlmqa3OkQGv2/YX192ScxRp6UHymazrKS5hNQFTwomg9HS2T0XAan3cE7xgK +mp7u2o5XEQ2bpptI8m7NeDLf2CjOUQEygULByEYEPlKgh7d5T8tlBWSWlwi5cMpxEhmRRoA0P65l +O9HmTLntRVzPAonDWS0WNXNJR2CtoS1r1AzPKC/5WNc/GzHgkKrYzpsjHVWbFAUUBRQFOqFAwNQj +AaMszK8esHqopbLyGKKoazOjQM6pWxm/f0XTy6l0rrIsEA2FbC8nDhQAvQTAiX8yTiECdCMCgCTW +81B3l5eFPdOqb42n0l4un4i3iuRgJ2AJQIbYNapp4aCZyzopMDjPwWQCVmFqdd1BwCsw1Cv8Ivt1 +KvJ6TU4fTMBxAiRL57Tm3ForJHhfdKhENtYLFF/aNLcq6lXGdlAn8W1mo0k1R1FAUaBTCgCd5RFj +ULlVU2KWR7SeQaniRzul7yZ5AB+YsJ9fVPdAPN0UDhrptGa5gbAZSuTzAYP9KHrYCuVsFj92xIq2 +JDO6aYcCmoMiE/wzvUg0lMrmm1tS6YwTsiw7rWVtLQKvaXH4l5ZJazkMc/G5ENaTGS2HDZGhBaIF +3hS0FVAsBLkETBOwjObtwU2pSYnc8JxdBrgiuRBpCrwsKeUtCMolrHx1bU0c4fDSsDVIbaYSRFGX +ooCiwJZAgdKwsU3S9YYEgxYsaU9abLE3vyf5VJ4NQIGUzcaTuxO5uYha45lMLh+ikoSdziXTg8tL +akq2zdpwl27e8VrTDYYRMzwvmbTF/hZHq6gwB1RFmlu1+uZ0MuUgpE2ntHhai8S0ILtU0gWO0xQM +JXdZV+QS0OtqbCnlkE0ExcJCidI9zQEvXS3vlWecmtbMcD0z/KTtU93uLvZLi7udWCVUFFAUUBTY +9BR4tWnsgJhRHjHLpL3IerbIQhi4nllU8r6ngOtmGnKPrmh62HZzLQlXdwKptJZ2s5Xl+E/Q2Aya +yTsLauenswhhPVcH/LwMrotcWEk9ENTKSqzKsuiqhlRDg53KOrphejlj1Zq8Gdb0rJZLCfktol0s +iZDfil2hppYHq21hQ8SfY2sZVKiFnaPCWIlNpS6MbCSdqcg5ZcMqSo48ckbf91mVqCiwRVGAM3E5 +8G6LavL6NbbfdHB9O0L6eMZtSbvCRLNHl9o/2iOy9WmmrPNpQ+au5tScnOOgzkxmnXzeCYa0cMAM +I4Y1haghnc2k2cYSELZCmZRXURJgkyfHlCGjHVARqakKr2pMLF2WN0zHjGjYAdU3O1ZUi5YIsEym +NTMgRLuoSEFNRLLAat4WgGpRIOa+edEf9J1iA0zhgj2185ZpBoHVsmAPx9bastQ/igKKAooCmz0F +kMwh6utZMy3/XN+e5Ve5ekMB180m3GcT+Sebs7VpjG7x32d6eO/DBBez2HBY13mt7FcxtWxO2BNl +klomj/WQ09gCmjqgY021XlNVubqxvqk578HGRjU4zJaMDfcZKxM6y3RGACTwiZg3mxGKT7BTsLEI +dRHwZsVvqLCbRXQEJairRYNsFbUakxglGUZKaEQ5PbQ33SQv53c+8MADnBrdy3JUdkWBTUUB12WL +dm8/hE3V+O7Uu7l1kJOJ8dPW9Qm4HfZrfTtC+g7L6X6khffy7qdWKfuQAlnns4bMnen8J1k3b7tu +wLAwFUvqLpZBJWVwkOAmG1xQfXpsTcErAqrNTNpm92cBAx14U06SLi2x5i9fTap0zgmXsAtFa2yx +rXDBktbR0uBuWnCZOSyMslogVIBMrHMLG2D4Fb4XTHErrHilybeLPBn0xdOg1pp32EVDlxnNxR0v +KyvjAOrm5uYRI0b86U9/mjp1avHTDsPLli374x//eOGFF3b4tMeRb7755owZM1566aVp06ZRCLUc +fvjhs2bN6nGBKqOiQGcUsO188YfASexjxozhYNfrr7++syzEY4Aize6OP/74r3zlK6TvIvGmfdSm +g5u2MZdddtlbb73FwmXkyJF33333008/fc899zz44IPdadX6doT03Sm2izRWv15gddHxTfyoMTOz +xb3b0t28mw9bwVyGgFufyMXCJVPGlLS0JgZUDrSs/Oq6+tLSUGmkvCneasfx9VewAMJbAgFD23Z4 +STrrNscz7OwEI/W8FsceCIY0qLk5LRHX8LEhPC0U9J3IeAXfiWY0I8yLpCzXEpZMQsxLjJDrFvAU +HSoiDrm8kqusvExdRLN//vOfgOh3v/vdG264gVFe9KTjoGCxNSrt7XhtU7oslhOqX3311WAwuIFq +aVOput06KeA4KFz+N4AfffRRhhxSlssvv5xAhzSZNGnSY489tt122/H0jjvuIFlxCR1m2YSRbTq4 +CVvS0NDADPPBBx+wBGHtAtH222+/vffeu5vUW9+OkL6XnbXgeHpZhMq+XhSw3Xhd9u547hmQKpMz +4APTmPSEwql8qiwcrY5ULa5tTOXsAeXZPIAmeEGvMZNoSWfTGQ9oRAIhdm1a2qCh2pAhwTkLMppj +jh9WncmnF61szaD1NNBoBkHchkwuENYiBfMztKTkokaKBIMFYKJZxaSoIN3FXldsXykgp+A/8dyL +nTBQml1rxFu8DJedZUCz0B43btzDDz/M0/PPP3/BggWpVOo73/nO1772NdK8/PLLP//5zxOJRCAQ +ePHFF2V6UtbW1nKg9K233soys30uCiGysbFxn332YTXKHDR48OBnn332iiuugAk+55xzjj322GJq +A5y777479V533XU/+tGP/FpWrlx58cUX19XVUfu1114Lx/zJJ5/84Ac/+PKXv/yHP/yhqqqKSY30 +s2fPPvfcc8877zzK7KKW4hpVeKulAIOt+ENg+ShH3RNPPHH00UdDFsbhT3/602eeeYax+vWvf51b +1BkwoAcccMCVV175wx/+8MADDzziiCOI//GPf/zaa6+R5cwzz+STIcBwZZRi8DJ37lwGpByTG5nU +bTq4kWsvro65Zc2aNe+///7kyZOJh+wslKEzrD+E+vDDD4lMp9PHHXccH/V7771HZEVFBVTda6+9 +eLS+HSF9ce09CPfUf0MPqlJZePf2wuUtNwUjy6PBSGsCUyEb50SIcxN4TEhpzS2ts1pasb8dUG7W +NjaGgnokbLamcolsCkVmsmB2C+56eSH4HTG4LJ0O1bU0Dq4uKQlF5n7eAIjqlgYy57Pu6nob5Sje +dJE34EpX7I1hOMKJFt4CYbnXhafEwLCSmD/BfdoaJ6QBq0H867JFpjDA2i8Dm5qa+OZvv/32M844 +g6ff/va3x48fz/gGBRncVHLRRRcxF5x++ul8EqbJUW24AfZaWlqYVhj0iIU7zPWrX/3qoIMOIi+f +zUMPPZRh808uxwTEJ1RaWvqlL33pkEMOKV77UywK/t/+9rdHHXUUEl3SUAslh8Pha665ZptttgE1 +EQftsMMO6FreeecdCn/llVeY40488UQaTztB1rPOOotlbxe1qJGrKAAFGGz+h7B48eLPPvsMgGQs +3XfffYcddhgJ4FDfffddvothw4aR2LKse++9l2HGcpOMq1evZvwT+Mc//lFfX//CCy+0trYec8wx +DOlRo0bx9He/+91dd90VCoUOPfRQPpzicb5x6F/cwY1TY2e1RCKRSy+9FOto1iXMMCRjRQ6JoJ6U +oqPBkaQj5he/+AVEjkajrLOffPJJEq9vR0jfWUu6GW/JibWbqVWy3lCgPvVMXeruoJXRHSuRz6bz +Hts4bVuP2/lsPocREIa1wYhWVa7hoYqKsnmvNcFhKx7iWRhKoiortWRcy7naiKHRgdaw1+ct1ANa +S0tmxfLl8ZQdiWpY+WKXtKZejAvsjJA2pRICDsFm1K1Cm174FbypWOUJ4MQiVw4illTALfwoXu+J +F6JdkLVgV4EqqE3HWUTvu+++rMf33HNPng4fPhyUev3112EEuWUhyZTx1a9+lVFORoYpcIjwBE6U +9fj06dNlgW1ygZrPP/88Xw6J0XcyjxB44403WL8zxVAOJVAFNfqNIQHAue22237jG98Ann//+99z +S+Hk5btiqpozZw4yImJIOWjQIJb/FAKKA8lMXtSIlheIRaXaRS1+dSqwNVOAwSzHLUQAO1m3sZpk +ZcbgXLhwIdgJjjK5V1dXy2SMNEYjA0/eourjQyD8+OOPk4zFJRY0yCrJxeqTp6w7x44dS+FwWohk +emBf08u3U9zBXhbV++wnnXQSXyhLapYsP/nJT2gb9JSUhKRA5ve+9z3008ickCqxVqbGTz/9lM8Z +DF7fjpC+lw3GD0MvS1DZ100Bx83WZ+9rSD6J9BTf8U3YzuIAAesh18vh8S8veE3O4EZIH4WDzKPS +FMJVkEznFJe8A0NpGYGRg0LNLXZAs8sH2uXB8OyFtRkvWxHR1qy2OcklFNbCMQGEGWS/lIP7BekL +ECGtVfBPhNkSJkVwomYBL+0CJ4rTXtEk4dgIrKRdCH4tNxzUy0OBEaXWyExgAN1DOtqmkwi1Ro8e +LSOXL18OV3fBBRdIgyOZmF+YQt8anLU5PF9JSQk6D2YQ4tvnkp8K63G/OnKBgiAi5VMXv3w5/lNi +ZLHEXHLJJU899RTLf2rhFtna1VdfjXkwCioYUGJISaUyLwFuCct1KIGua2nTd3W7dVKAcSvHD8MG +npLV2KmnngopUBOAhUzrTPSMVZlGkkiORhnDqJMlAJN+Mr4Rhj0JeEpYpiSXHJ8bmc5+BzdyvZ1V +h04ULemMGTMQ3hZ/vzCgEyZMAGjJKCmMwJwAaxo5e6xvR0i/lpnorCnrigdHCxzHutKp5z2mQNZZ +/UnjdU7+s1gI4HTjaXg7E799wCcgKjYt4aLPhl0U7GPANNFfAmls9+QUUMd14BqTSYDVzaTza2qz +5dVaZURbtLolmXYQu7aAfMKuV9gZIYwlr7gNCW0ou0WFWlT4tReQCV4KL4DAagEThW0Rhj+Y7OLm +Hi8Nbrg0WDO0cttBA7YbOmCHgVVjFzWH5q1K55YlNa2peGqQdCj+zt9++204QnhNMJIphhmBVTaT +wn/+8x+QT24VoAQGKya7jH4s8X7zm9+0z1VeXk5GDIBPO+20v/3tbzCLFAL3ydqc7Lvttlv7V0Az +/KnqpptuojrUriQGR+GGkTDfcsstcp4iUqakEALyS/NxtOta2terYrZCCvhjntG1/fbbP/LII5II +8JfM7Mz1WOTef//9SHrRjzK0SA9PKUcvKf1RBzOKhTljlRGOlpQBLwdn8exPDNdGJrLfwY1cb/vq +kOIyjbDaQOuJGCkWi9E2YqAJ1GbqmDlzpqQPTydOnAh8Ss2oLGp9O0L63uKo8ire/i32YUxrZv7S +xG8TiVrXQWFphEPGqKohTa2JpuamnONxaB1olxKAKkx+LIARVjLKalQIXe2MlsIbUcE6F39GJA2V +aNWDBO66toFzonjcAQhDMXFYN3mF1BY0LvCdlAaIym0tiHOl/J9IaW0knDnADWe0sFZeM2C74cN2 +Hj102uCasaUlJQJvC9cKJMJfXO0/aWL8SARcYBiSUtSQ8H9XXXXVL3/5S0S+SKtuvPFGVt/YrIuR +iqg5FsO+EV3mr3/9a1Sq7XMRg2yWpT1yY7IgIkNK8+c///mMM85AyIM8B9sl1qdftOt//CgxmCYh +3UWWS8NAayQ/fHKomubNm/fvf/8bRpY0ss18kG1wFAlzF7X41anA1kwBf3ZmDDMg/fGPkRHKdTQO +4CjzO1IZFnPwRoxVFpfYtDMs2fHljzoM8RiQfC+IhVEBTpkyBar6TyWFKdwvf6PR3O/gRquxs4qw +CsSCARNC5LTYA7Ke5oOV62AstqAMT8mLfhqZE+ZFfOws5VHQYFQxYMCA9e0I6TtrSTfj9UlHffv5 +26/oZmqVbL0oUB9/76Pa63QzbthmKORFI0Y0EEqn9Xw+E884KSS5rob/P7AQDWjIFGZBsQjyRqGV +zOXx/CecLeCeIZMTOk4wkg2jFTVapVU2ZnDN2wsWtcaFKwbEuUJEXDg6TVgSGYIxhUP1XXPwCH8O +DBVAll2kSIlNOzawbMy4EfuPG7Hn4JrRHQ6jj5YmPlqS/HhZskpv+sHxO66z4xhNsAyH+QPtwEvS +w4kiLx04cGAXedvnkomxM8LU4vPPP5e36JlQhFAU31IXpRU/ohk0gC+QtS2/HfaxOD3hHtTSpgR1 +248pgHxF2hN13UemfsYbl0zG8GPs+bd+XkCUNWL7eD/Bxg90s4Mbp2Ew9BhbYCrYzU+eqQYElW1b +346Q/oXm7ScOCU0cGuS3Bx1UdkY9IFq3sqxOPLc8cWdZiZ1MhWx0no6XzbitWN86egiqc4SZGUjC +kHoeItwIx5m5yHVNPGugpBSoqTv40XVxfusJea8Lz5rXogOFVLamrHRpQ1MiK445Q5zr4J+h4Eae +XELFiuMG9J2F81iEzB5YReYgPAtq6bhWGhiy26gDJoyaPmTIBIQh3eoJDo+6kVLiZZuU8HldV9Em +F6tLrAb4HjAuuPnmm4tL44vquqg2T/28fqBNgg5v17eWDgtRkf2SArBB3RlLSBqLu99ZFjZ0FSfb +HMLd7ODGaSp0w865+3WhrvYTr29HSO/n7VkAfra7C/yeVbB15lqdfjjlPT6qeuCKxgYjlG9x8LKg +Y5GbhWuEU8zraQ4H9fIJlI+ScXTEwSzhAq6hzgQyswkzyUHcGM164sDtZEILRLTSck23tYV19S1J +3MwLvhPhLfwlyYQfBmhdcOwnD29hewwGRLg9ol47rlVHdthn8hGTxh9YWVG5vi8Focr6ZulZenaw +LFmyBKs8dtH0rASVS1FgA1FAil43UOGbQ7H9poPr2xHS95L+hYObe1mGyl5EAfaV1CXvW970eMiI +Llq+MplLYJ0aCrueY7K/EyG/a3stKRdDXKH4BCMdwW4idNUdXOsKzwh51xOWRzkHUyDgE9xFeIu/ +3JJyoTTNYljkZYNmoCJmNLOxNCE2tLCthRKEfBg9K9tXCgeIAqLgdL5VG1Y+eeddTpw4dno0tlbW +VNTezSuIDAc96ObVJtUaRQFFAUWBLimAaxzMU9TVNxRw3MzSlj+m0q9m0s7KRGPaxrWmVhHSDccA +7XQDFwEaW0J108sm0JIKz7cwkZgasSXUCjviOG7bxFgXEBUMpyv2gAKNqD85NbSsQvhYEMeH2tqg +iiic55rGLLecFYr1EApRfBgBwwh+2QOD1W5rvVYVnrDHbidPHr9/Z8KlbnabreXdTKmSKQr0Ywr0 ++w+h33RwI3cEHBXiQHX1ngLYDNWmb65L/jeb0dNZ0E3sXQmZJhwnGDq0KtaYSte25DEa4iAXM4D7 +asFc4gsXfjTK4aA4l9csB68IOfZui+UNbCimtrweTiHlvG6c/GHBK1SnacS33gq2j2Liy35SsY1S +2BCxgwVfCghyW1vxRjRw3/Gn7D71uD7hQfv3sYu9f/WqBEUBRYHNigI4YEHryQULgZ0Xjln45UJF +hRRX2i5hh8iWX65fP/JxLxtvcBZQL4tQ2aGA4yYb0rc2pF7L59lUweIEASvbTfBJ5GRsYRDUmMo2 +tXLimRYrESdvA3iZgqchIBDjIDjObNLkWDSUnWnOH8VcqMCn8guvqXtG2QAT1wriaDUw2TXjyIsz +eeF3vrBbBlku3C28L2xooj68bfmhpxx2+/77nNwnICqassEunBDV1NRwDsYGq0EVrCigKKAosGEp +ILaxb9gatoLSXTfVkLk5Zc8CCBHSBoO62KZpCx4ReEM3mhMnl+XRdwonf606nCgmtaGowEgU3MK8 +SGdDp1MaslCOkguAxDkfbgJhMWFMG3K5HaYIoS4WQ7wt0+DcCYOTW1CdwpKiBwVc81mtpUkrs4Yd +NO2CqZMO3FiGQb16u7gPxCiXNSO+cHtVkMqsKKAooCiw6SjQ2/2nm67lfVmz4+Q93BLkmjF4TadT +GAW5XiKZagGeXC+TyXoVFZVlscqAUWmZ0YAZMswIAlTZAsdNr0nfVtv8RjAYQcPpGjaSW9exQrrY +A5rLOuEynW2dmYzDIS1crunhWgetp+t4TlrD8wHmtaBmFlmudGCUF+iLlpQzRwFVkDJUMCNqahSw +ygYYuFs8AYKUQCywyh/WRk1rtHGDZxw5/fuwd31Jml6XNWfuqlv+8OKihQ3tSvLeeuNGRCvnnHMB +3mHaPVURigKKAooCWwYFtmocbY2vsV07EMArZiQSjJaWDTbZ22lF4NHzdiqHR4Fsuql5TUPLkkVL +3l9WNy9l11aWBceOGDq0envHrnDs6mHVO65ovW9J4wuea4RyAK6Dx4Nw0CqxAkvrOM7FRRgL05mM +s98FUyCOG0Xr6XnY6eKByNKi5QJE2QAKZ1kSFXtGs4h2U8JbAptH5VaWeKs4+wwPuukCMypNkzIZ +TahLcwXExYI3XjJj6tkz9jxF8MGb04Vng/N//q9jjtn1jEvEEYzF15MP3/f0fxYPGjpm1ooxJOtQ +LoLqgo2kaDXY1ilt03GEhKd7PIEVF9WH4Q1XPn4h6Mvo0aPhv/uqwZxms8suu+D2ZX0L7HHG9a1I +pe9DCsTjcbz5cOHAoQ+L3UBFrVixgjGP+X2Hn/YGqnRTFdvbfTObqt29qRfusyW+sjW9rLq6YsSw +bUcM27G6clwsOjQUqAgEovKtB6xoLFJRWTFkzKiddtvp6KNnXHHqYXcfuftvasIHffRh07+fn/nB +gkfrM7cvjf98/qpncTxUEglwjCitKo8ZJRHL1Y2s7ZmG7qIpxfwn6Flh0NEDBbEnsiwvFPbYMIoz +P7a7AL3EY1UE9wknirlRkJNbgiKMTwZkxXhRILHYeFo4nkWwp2HBm8LC4nrXTdd8ZfrVB+272YEo +1AAIF9Tm37cHrI47xX8LVzbecu3PIfUOp17/2RqPZG1eKC6+8A7IGRp4/MKxEQFcNJDmzjvv5Lyq +Non78HYDlf+zn/0M92/f/OY3kRbgE66vGowX4o8/7omJRI8z9lXL+0E5HNKHw0u/IzvvvDNH2Pq3 +GyLAR4FjannmyYYov6/KxBMno52zlc466yx5hrlfMo2XH4IfIwOoeDAFeu6559rEc4uTRZ+wZ5xx +BhOCTEM8Xlw4JICD5/B43D7jxoyx3K1s30s62+q4LUOHjAkGSmCDoLX8lURvyxjBN3IwC78O7vei +Y0fsNnLobrV1p8395IVVyQfCseTyxuUtSY7RrjLQi3q50rCeybnxZLah2XHAUdPDepaT0gFUmM6A +5QWCLvpol9ULG11ATMdE5AuGkBvTXLaN0iAYTW7xFCjYTU5fwfMfGAzTiemSLsA1g2O/gmIVu9yw +N+Lrh10/auS2G3PQdL8unKIFIuFUOn3jZT9OpxLTjzpply+Jkxrvu/mqlqb6g48/KzpqZ+u9F0iG +Q+riYvFHOn/+fIzupK8vxL+c61taK7ChAAAgAElEQVScYAsKczIzDvrxL4G7RLydsUin8Ry29d// +/pdjQ7agjqimKgqskwJ8qpgN4vMWzCNx8ezKLfFy/BeXw/oAF8SslYsj24dvuOEGzqcrxtpbb70V +p//4MQZcFy1a1Ht3Cu0r7WYMM3P/v1jO4DCaNYvnpaurqocPmRywYm1eMFSAPeLyyQHIAlpCceqI +P1ZSyFVWrFry0nOvpFKtO00JJBJ6Q7M3uKwsoJurGhOwoUhfsZjFXVEw7JVWCARFPovLITvj4dHI +Mjw8E4Gh4vB0POhyNHcajarDAWf43ZPsJpEoO+NNAjixwkW0y8YYOFQcMsCAAp/ADbAK6Da3aKH8 +qK8f9NvNFkShJEQ2wyHdCo2dPO2tF57845UXNDY2fDbv42ceuaty4OCvnn85KwwrEm7zLjikl3PZ +OLDXd5jJF+L7UeOrww093tfwAC5fFgf8cjw4nuiR93IwpIwEqDiCg/U73yc+wfF6ijNxcnEOjFzR +8z1z4iOu8PGt/9577/nv3Q/AtI0dO5Z68bYvI/EeTJkUiBMyTkaU5XDq4eTJk1lQI1/FWTZHaPkl +yADcNs5UQVNukVFzisWbb7559dVXMyBx28RGty7aj9d+6fQcGJal4XOYU3GgDGw6Z6bKSBgjVuUw +uwcffLCsiHicwf7973/nSCl5wlSHGWV29duHFIDsLI/QPnDYC4ONNaIs/C9/+QtS/REjRnBYPe8d +z9LEy1HK+ZrwVdwis0VQP2TIEIDB/yj++te/kpFhIE+el6Wtc/TKZBv/lyOEcXUrT5Sj9uIZlZMN +P/zwQ46gKI4kDZ8SOMr320VryYsyAsLCthYnY1sLHymygU0IorSHGb0vL05vfuKJJzg07sUXX6TP +HLjB/NVhBdOnT2eG8meHDtPISH88dZGm60csVZitOPCyqmoIktvOEv+/imAQgU+2ruQ8Ow8Pkcnl +8lknt2JZ/QUXnvKHP1zd0tK0ujk7vKpy8uBRS1bH2fkZz9j5vGvgqiiMmNfSHR3GI5P2EMzaeSxr +QWhduC5iA5M43kEAJ7ccvo1EF14TH7nsfsGmF66UC0AnA0DMP4QBV4Iii/AAL05ribmjTzn8plEj +R4n7zfiyIiG6bG//1aGT92ttqr/+8u/f9IvvsXFryklXv7rUAEdhWNs0H06UmA4PSiOe8x84mJAX +etttt/mYwbKUT/Tyyy/nGHBZWn19PZi6atWql19+GRgD5HCjDwvIuRycCUMajrhiecvJEsxZZJS5 +/F+Ou+K8mscee4zEnGDDEopHHGIDYj355JP8Ug6nZREJmtIMNvDwlKIQ4fqFyAAoyxEfYDmTphxj +yAA57oYDamgPOEeyDttPC999912qA4nvueceWRrYj2SMIc35XLRfFgg2U+/SpUtZFiCalilJwwRN +erkO6DCjTKl++5ACkJ3hxEhgEcPrAwUpnNHIUp5zkBhvcGysvfiV8SwZeYkMJ25Zhz388MPI6plC +33rrLWIYuhTFchBhaTEn1/XoJeOmuhYsWDB69GgWBKwYOCUUF/CyJciTWPhyQnAbJ6McP8fMzOnF +XTSYCQHqsUKV7rj9lNAEytxxxx2Y/fuRmyTQlzjKK2emwIxixowZHOgoz1blJCzie9Y3lmzMQSy0 +e5bdzyWXP7y/dcqw5ayE5wTYULFZ09MefvjBsaOH3njDdXlMb/PakKEV98388tk/HNbU6sbCwZFV +1W8vXugFM5Rt6cHBlSXBANpMvanBbokLmCyLCn4Uaa3c+stuFexs2WDKH3DKL3JjDIuwG+KzQkuK +FDcYFvteQE1YWzSgvCHYUFqCBS9bXNhg2prQ7NaBx824bsSI4X4fN9tAIBpGDczC4uDzfxeKlS98 +/bE1C94dM+3wiXsfSWTQMq0o+37+38XRLohA2yw8/RSsXr/1rW+BsizqOfGUeLjME044AZjkHCV4 +WbLLxOANsiDmpmnTpu2xxx5ALFl22mknib4s+Bha4CUnF3LWdxsdLd8/nAEGHYxndDycP0OZTHmn +nHIKKMiwRP3jYxuPCLM05FBJCodtlQ3wfzlpi7kVhhgGBSaSrnGkOUtpWs6JH521nxU6Ne644458 +ULKnnFhJU1lJ0FmOhOOgOjm29913X1CZovgt5q2p8dhjj6X8zjL6LVSBPqQAkkZGAkencbyXlENy +nhrvEcEAIwpIKK6LUXrttddKk3US8NJBCynhIBnsHW+Zk3RZKrGw8zN2PXr9ZBs/AF4im+EsYUCO +75RFgFwx8L1AFsC1uEl8rZdeeimDvA2HWpyGMCsSPpk2eYmHthwwzKcEcrfJspFv13p26H2tEItX +CzkIQEGMQVhEABpcxEtSdlYL5zYjqmICYrgwaHyWggHHnEg5POXAW7LLlKzUOPMSOxRieG0ICpgc +ORwAuTwLQFkLnC7HAcLyI2ChPURKjGQ+YowippfJODuQW7nQYyZF4M6wrhxQsf34bW+68Yb58+f+ +9LIftra23HH7bYcfekA+E5i/8k8/Oe+pR25fndOckqj16Mx5V1383neO+PDC42bfe9PiujWpbMZr +iTu/v2rhdRfNrVuW/s2PF1zx7dmP37s8EPLKKoxoTGfTi+aZMKBZNJ0Z4cPIskyA1kK0i0sjoDQo +cFec2VI44hsE5YJPRbaMgyQsj+KrSw7d/bKxY8fILmzmv4htA6ZREg4OGjriwG9eS2tD0bLDzvs1 +MfwFzA74UaxzkYYh2+iwa/4pED7QwhFeccUVvEopTZIvmrz+6pVhWRyWxcJospJFIMz4AV9ZFBdX +x/w1a9YsnnIxeuFrecpnz+mSMhnjhEgJmbxC+SXLJvkNKC6QIQcEMoxpanE84c7az5QqpVV+T994 +4w3Qt/2Ewrdz7rnn4naKQ6GLC0dCKG87y1icWIXXiwLMbMULJgaJL1r0T0MDHeWijVfPgOmwfF9h +wVMAA9EFB/Qy9uQoYpQyubXP2PXobZ9+o8UgzWbUIZ5hKQyXyYdM32GvEQuxNuULveuuu2g8eg2a +xIqQdSqrPeIhFOuJDi2GwFpmctbKbRa7lI8NPAtKaOvrODZaT4srEi6Siu97HGZIcUw5EwoLfDAM +4Qa/hIkB9ooHXPsqkEehvAE1kQOw7GJ2Y0VDMoTm/DLOWMhIuy+Zkolv1KhRsAtYbTDsECAz2fEO +KITVN4IFxjQvBh4C3CUgzeo4zY6hCblJUFtbK5uBZIxbOWSRy11yySXMuTfddMuPL/vZqDFjB9YM +Ovywo0j5pS9Nv+iiyxPOS2ta/7ticWb16jQi1g/eqb/q4o9a6uwrr91t/0OrZz626tIL5iYzjmNq +DatzdSuzf/rl4prhkVDEePnf9bVL0yAo0AgiIr9FaIygNxIyq0ot3NOLSI7dtkWj2BuDGhXU5II9 +JSW6UvmS8ERft0rbY9Kpe+yyj3i8JVzIdYOWEYsE+Nv98FMm7H3kwWdfOWjYCBmDkBuGtU0/UHMy +EyHgahPf2S1CJFamyGClDK2zZG3iEYGCPQxaeaF/Kk7AU4bcFw/flkMRBSSjRSZDQIdOi1mgOFfX +YdhixLlMIm2Sdb/9cJYsL6RqjUJ8wIb7YXmBrLuYZSmupbOMxWlUeL0oAFoUs/7MdRC5TQkMEngA +IpnopbaCcGeqLpb46LwBGCT5PuhSZpsVnqyi69Hbphkb8xbAQwApJ3yWGijyGbGYIKDpR6zCxVmK +WBgg1KFVMKnY4ct4PiUWqayh27cWEMFYgeld8k5tEvAVp9NpFr5t4jfmLc7rCvxOr+sE0tAhsern +xTPdMMXwS5gY4nm6zhoAQsaQtImQAxRZHLnQISN/8/kJYjhdC50z2AlSsoqBhWVFAy+LzA3OEinB +O++8gwaC5TxlNjTUy+1W7723llXtrCWIoHn05z/ffeJJp5x80ulHHnlUSTQ2foLYqjhy5HZ77Llt +0njQMAS+2a6Lne3Tj61BGHv22VN22a/8hLOHbjMqvGBucv6sZEsTh4qKSo4+Y/hxZw/b+xBhQbDk +k1SOvaEc5JK32ScaDGmVpVbA0FfUZdK2jadAOFFc0IOX5AVW2QwD9ynCcL74XkC6a2r1dVqludeh +088SpW8h13YDc6MGVowcViL/LrjhvuO/faF/O7ambMKgtlJQvj3w4LLLLpNKIzoK54ehQWc9Zqca +HyoLIJlG6jI7S+zHM9L+/Oc/szIjhtVVsfKJGNZn8I5ydQxcSehCi8nKmjAXeh34Br+0LgKIQ+Tu +FJZ3yEuQM5OYhSDxEgi7335WGCwrsTdhnkIPysxLCSzSWRciNmSChmK0rX1jOszYPpmK6T4FkKWz +hUmakbNSZwgBITI7am/eC+Y2jB+ku0Qyg8FOYGHEUk+udXzm1a+RQQ4zB8xgpg4TIocx2jGs0njR +oBHcm5+469HrJ9v4AXoKJwpjTdWYLEAfdHws8oBMeYGgiH8QKJIA4nwRfabcwQIr1WGbmRP49GCx +uIoT8E2B0FC7M3OK4sQbLowJad/wo/QHuGKVxIU1I6OBlQVLNvpPPE/X2Qe5QoEfJaWcXzrL4svW +YOpJg2BWpmQqIcAQlJMjBT74twf+/e+ZUhrQNeuAIQATEKL2HXacUmAN7Ww2l80VTi/DvZ+TbjXv +zTqrkymBo/QGLWhjLeewaENGO3XNDaDg6PGi5SuXZYWCFNzTtDETo+GoFouJG0S4nJuG7wULKacm +LIbAz5aUjTgATEWWSxYBmbgxwh2SOBxGqE6Jx32gCIs2aJmG8gN3PQ97XbhVAdV9swQSTd1AF2ug +cca8SmvxwOqU/Bs1JjSwOu3fDggsHaPNJVmbBjDj8IGxUGUxxKeFcF6+0zbJ5C1qGHQHLNqQHfnm +qR2mLI4EpxkhfOGsw/iwmcWKn/IIuEKUxOTISJacLgZHUoSLFBfcxaK4OEtnYRaFfORkoRZmT5mL +eYTvAkyFPV2v9iObwXqICRds5kNg9cCqHytilBqMf5qNSqXDhrXP2FmDVXx3KCBt0xgbCG9RITGb +y/U6eZmXWLjwcnnK0CWGMHufYDQZqAw83pqf2K8LUGF1xZzJjhEGHqp9aQQOR4vsDenI/vvv7yfu +evT6yTZ+gGn2wQcfRGRIm2kwsFfMAvWmPQxvZMKsQqSxAkUha0RwxWoGO6Ni8XhvaulZXkvswOiL +iwmC8cQSjLeOCoeBQqnAJ8Jx4tsvvrpfZxuZeHFGxhy3vqgNxp9bIpmwCDCheJ4LKyxLkCyLzI5G +Cqhm/S5toAhLvEeaP2fWrHHjJ7De52KzH5JYrowzxwk4+exaWgGFEcscUCMssD+ctfrwSTWwliuW +ZLgtq0bdKVSbXELvCR8utosKTlN4LNK8fMpBM0o8JrvhiOAygW12zrAHBvteYSRcOKAbI16skOB6 +BSfPsaSG1tqoTR55xISJ29MKXpsoiyfwsJvxxXs/csbujz/+wMKZYtNk+wvNH0xe++FBvJRP8E4R +bAAbMq8vHOMWqYOMZMGL7Iv9MFjf8K7lQh7M86srXsP6bhBYsWEcxOzGS/c/9eLyAXJmNFg9EFq2 +kCUzBiNwBgxv6pLls4xjOMkwYNl+CYiYBO6WjjCrymUiiVk6yNU6604K77r9iFv8viAZRvrHqC5e +fGCsi/kVhQPzNJsPkPTFfeG2w4x+sSqwvhRAOInYH1kC44HVnq8TpRzUSSjtGFcMGL9YVANSO4AO +m8WZXNYXj1JiECcgH5a5UDEyKZEd9GVeZYM1CyYGpCyww9Hr17VpAyx/YUuYltGV+APebxIrAD9c +HOBzKL71w/BFfhi7LS55WxzvJ9hUATEh98nFB8wSm4mJr5d5jXmQGY1JB/kq8mue9qAWhg4TE+8D +yQbrO3/m8ovCOhHGlxeALo31mtSoQWi0CyxP0NUDk1gqMgrJss02I/gFYhmOrGjgNtgXwViXpeE8 +/uSTT7njjtsv+f6Fl3z/J7FIpLm1derUncdvtwsJ3nj97anTR1dUBwUEaho7OXArf8CR1W883/jc +k3WTdy1Z+llm8YJ0zdDQ+AmxwhYJkWytvrMAqgAh9reZjJtOC1wEa4UgFxdFtnC2UF6ii1zgpaUF +8bGAnyPAOy02wwCuODMCTd1UxZTtj8GQWMM/Q0F1SprNG0aBf4NlKQsp7MXaAwxoBIAhBWqPo4J8 +9NGy5JJI3nbxyzuVw4NAG5cOXeTiEWxBe87Az0IL5VrNjyGALWLxbXfCnXWEJYLMvl7t77DB/tdR +jK9t2tZhxjZp1O16UQA05WqfhQmwGERBR9aL7H3iQ2D/BvxT+ywyxs8lQVRGFoeLM4qxu1n6CGTA +dyahLW5/vwlzblrf9IXFFDMOe9qwDGSbFFIOXJUi1md1jJhXLr56UJM8Vwszioceeqh9dqZg9lHB +aGK4hVwevIS9QIbG2ELVyrtkzcJUeNzxx8m8ku9E5sASkmURlk2wCOIRzhNc7aqrf3X6Gd949523 +v3rcUUceefC/nvwnO1K22bbswCNGLPo0ceHXPmpqzUoBJGe3BCPe9lPLzv/p6JYm+3unzbvpykVj +to+d+9PRySyeBTwp1wXn+EOIK39yOS+dEY8AUapjnyjb6MW2UVtbvcaWCJ0rnPFCekyKiEeui5YU +dWk6oY0atGfNwLGZLPy1KI+9rTCkawW8ImIzvcBIZnbWQ6zZ21xE8qgzEN1M+6OapSjQJQWw+ceg +rE0SVjnMhygR4DHQu0srkDZp1O2WSwF9/BHfevnOX/RJB5A1IVtDy4jKHWYU7ISpZ6KU4qbeVIHD +F1buIGJnhVApsjUpnZP1khINFniJ3MzP5ZdAPBgM0PIIF+kc98IJL+w14YDQdCaFkK2stAxmKhnP +5SMPp41nV69Mx5P2sG2i9KyuKceeFJSakYheHhIHoS9amgwGzUDUbI07mBhFSgTsuXCZZUJsGxBn +x4KLnM7N04IkFmdGuAMsnNaCEwICiaTQd4ozXgo6VA5BE7ZFMJu6KArhrZ0OHjrtV1N23Jd9rQF2 +i7DtsrCvFD0rF0Dd5wLej5YmPlqS/HhZskpvuvw0YfClLkUBRQFFgS2CAut7jveafOnEIaGJQ4P8 +9qCDBZPQHuTrKAuwJHeXo1lEMwqfAaRxCRjp3YWCqusCfKEWyZCoyMQEfBD1EVQ++p9ozsXFASeY +CQYR7MfPDmzewJrqDHxf1sq5sx3r9XTKNgN69UDO/TSxPcJNPB4BQd3yqG54eksmj6I0JzwCYoXL +0WccwCZ2tghxC17xDCBPyGZFPcIxEY8FXnIDiJOGnS1sCaVSbIuQ/YZKCpLevPBEL2JhPQvZA3bF +wMpRmUyKlpicBWNj6ARXy05UYbIEVwqeCvslrk4XG7Lr6ldRQFFAUUBRoC8pYPWtVA3I5CpWufdl +Y7tRFt2RXCZpwcUOe/c/42Gx6UdHbQmIosQEUMFCz3WRsTo5N5NpTpiPGNlE0AsnjXg4aDa1pkzT +YftKebnl5bzWuOtExTmgCFo5S1Tu+ARBMbgVdrZsZTH1oCX2hsIs4iMJgAMZcekHVofwW4TtrmGS +T8R8sXlU6EExOypsSiQLj8iDorQ0NJjzTfNAtBFAn2pa+GkoQKknIBkoZQOTaACBDcCbdoPwKomi +gKKAosBWSgHJwvSTzqP+hP2VrGcxiPrMKAgqQVTavHAki41EF1jzPA4idfgvj49cGzTN5a3m/H/q +k3PKQhWcgIYLwHxexwi3oUEHrUrF3hVLtxygUfhJyIktK8ImKKujzhRgxumh7H7RhN8iTId0y6YS +UzdSSS1dMFwVDKio1iEjMl6YUQS18KZCdA00Frz7khd8pSgeZbUV9U2LNSeM8JwGikbaeQH6tIbE +QsMrQFrkLfz2kzequqEooCigKLDZU6Av5bqbtrMSGmFGCchwcXskfBLjP0In6nGcGaJRIczVAVGx +zSWXE9tdcno692mz+0IkEoJNzdkZnL2mnEzINFzXC5pabV3WiniDKwL5FFypOBwNOATGYC8FcOp6 +LCyUn1gEhSPC5x+SWyfntaQ49EVoTLn4BTFhNBEIowrlgmcFR4FkAcOm4ErRmCL7JXt5hZaIN7w+ ++8ZDY7+oGDDMcfLC+Ah21bMDjuUJq1+Ri/01BJE4w16D82SkisL/ovxNdWGwzbYT7BU7bACGiGe1 +O6Sww5QqUlFAUUBRYPOkgMVs228uKVWWSOlLdAWoCp8F/0NQeSugB6MgIRcFRLlgRvO2gzN6F/8L +meDMsNUSCYVbEomxg4cuXF0LyNmOaQVsWHjH9EIR3c5o8YRrBh0joLtpzQhq0aAWxyms4QkrIM8r +KUOyq7UkHEAxjfBWwyeDADYi4TJxZg7ockmdaKGNBb6SCmAq2RvDyd4FHAXsozFtTetnM9/40T5T +vrPtyOmOkxWsNJtgwq6Fh3xhBCxAs8D1CugESrk2uYwX+nJ0ARsoMVMUDWp3sQEJT9Ok8WUGxUlY +0+C4kS1M/9NnFz9WYUUBRYHNjwJsNYQhKbZZ8dvIPkM2McozjvzIfhAQ3Fs/6Aa94AJH6QsBf1KG +DSVceCgiCZDAxTZXaEZN4b6P80E9bgVTyp+dtdNpK2O8k7U+dtNmSzwTNMKNLfhISFYFo/VZhL+g +qceJ3LmUlzR1oI5z2MBIuMmqsqCd4ay0TLQUQa7GATD4xcUAGBTkKdLdSMEQTMAntsROYTeMKQ4T +pU0CZQsHdxOL+BhYxOYIKBS+jRAao38tsKfLG5b/+80rpjYcvfP408srqm2HXTJ50uH6wfEss2DL +JFC0cMo35WKQ1FsTry4HB6uPzp5LLTWd54tiGxIm3B2mxGMACUjma7VlMhxm4tgd33vsG8Z8Gnux +O++8U/pY7rCcNpH4JcDDMyc+tolXt4oCigIbjgJMpHi6Zsc/uyGoBfcj0iWIXyMbOtgY2Q9x1O/h +lhuQMMmvxNFiEKVTxRLdL5SjQA8bZ9nrovO/UDjygLncQbhrZvJ1dtnMbJKTWzgc0zVj3rLGelyt +4xEwlRW7Ywy8zTsYCpnwl6TIZHW2mXJGN4rTNQ0ZDuWOlRQcLAhHgA6Ii2M/TJkCuDbCbigpMFW0 +ytGQD3NimGBzMb4tnOhCvORFUZdyIbjFRolcQglaENCSNe9m3lv098WrXt9t+zPGjTqQQ1PImrNt +rJpgScnikgjQxc8DhbJcIC+FFq7O9w2tTbBe/0Cza665hh1E7XNhX42nOuJZfrLrSXD7nSAuLwuU +JVkb5wkcVYg7Knx6SK8COLrj2+O2vXsUWTsbhfHYgCcjFOTEgMG8zfYNUzGKAooCG44CKHFwzY/n +LJbFuGHiFGr8OvWsOpzNIanCBaac1XtWyEbLBfuz0eraIBUBn365cg6Vtz58+k+JEYmFyNRE0Grb +MKHCvMh2wFDmefSjyBG9tPFCY/rzVELPZXjmgaelUQsDXrzJZ/N59tRwKLduGPjtQ7uJZpXqDQN2 +Vlu1Jov6U9gZwUdyHDfbYCwT8a8lJa7oQbGzZTspu3LghdniEhVhIeDlEG9RVAEq+QH2QNCsUJ1y +ISImGfVyKGkghF9BwWLWp5fPfPPqh54558M5D6cS6aAZhpsWomn23QjjKaFexbGDcOZAj+FTC39C +o9p34ILkHBctoontLk7dkXEQHJgkJZTt8OIR0Fj8EskIA4pKFZCWIEoMh0LwOcGSEj7ssMM44Qe3 +pTgL5DhP6ZEK77JsIMZTLk42SEN23+Mah8njqQOcBonBZp5yUQjfOdvhgXwwW0ZSLy1HZTtq1KjO +GGiZUv0qCigKtKcAruX41qRsCXe4+OFpn4YYZEUcNMIR3Mh4ucVTNC55/ZS4IGbFjOMdlsIkwyke +jzCwwLkuvkKJR4IlE8P7crgIDi7kyZh+CRs/YBhi2t6yLzkLM8/6nCgvgEh50TcQdC2IFlg1wX0i +4wVTBH46toszeli6vJ0NJtO1Of1NL2eYhjAp4gy0khh8HTs2Ab6AbeMTHPmpHgi6ICXu+kJRYXUb +DJnlJWGxmyUsTuEmg2AxDRHGK71gQ9PAasEOyNLwsYBoV3j+w1OgraUKolluhdcFAfHil0JhIgFd +0DrIHyBaKJlflgH4PIKXBU5XNi949sPrHnjq1Bfe+M2yFbPzOTtsWQawTQMw5RUlCY0pVRfKE7dE +9iGfxqeCzz9RbtGFI0D/4AuiJY7iDq3DS+JoUW4RlF8FLtf9eJLhkx1Hj8TwEeIinPOBOVOC41Ok +B3lObuERZyfhS4sA7j2l33mOA8JPJOcXgqA4KuOEFsmnUggOr/fbbz/OGrvttttIRi480eB7ixMq +KKeNPIqn6lIUUBTomgL4YfUFSwQAvPbrUWZfTm7ARR1eXeU5OaMLzl+l91YEv7hQYCErD1PClfSM +GTOoFDTl+8WJNMtx+bXygc+ePfu8885j6dzm0MOuG7khnnLey//4uQ1RwQYt00dKAky1si45UfK2 +5K1EUJmSvnooRIW/BeF8wWYnpmsbHhxjOZrK+qb5q5J3Zey6cLAUsGFHDJxjY2O2OZ7B3Icjz5DZ +Eo97P55EogImkftGWH25RkO9bVqIKAveFQIWnKjwlaQ7GaTBCaHdFLZFnNiMsLegKAREATrp/I8w +ElfgVjQPVWhWwB4xiHzZh8oFrHIr/kxxOIxoQ1Y8Zc8o7G9Tbvnrc//292fOf+g/5//37buXL/ss +n3MA+xDpaQNk4NBT6ipgKW2QgC2J0/tfvodi1SaoyWnSxcXCbrLEIb7DSz4qTk8YxAXG/FWRfMpn +CTrKMEeXUC/nY4CRrEmJlA5IYS7bWCThNhI/8hyxh4YVpSnrXNQzshC+SQ5awYskAmG5cGYIsUDm +sA7WATRMJlO/igKKAt2kABZGvlBQBvwjHPwS+MqQHrFg5VhMPmpWtIidgFK5SuaX7xEPBEwXZEHP +SphCOO4Jr6Kg8vDhw/lCecT8AOhih0jKztQ9fqUbOoC97haMo5I6YKSPmhJEiedtyUiecit/BXwK +syJAS4hxPXwumeFcvmXFmo4eDn0AACAASURBVNfnfv7M0trZ201Jh41oSyKTc/Pwghjm5jwnVGIG +NaspneFYFjuDoFKLleKnCJTUy8uCq+uz9Y2wfFpFlU5kLMyeFaSpNhCYT1t44gX/pNEQB3QD7lZI +2BYJLR4SXQ5KKyhHEa7Ddwo+EsMd2FCC0tQIm6PCrcDX/2PvTuDkPMo78XdPd889OizJN0ayjcGy +WYMTDCGBlUUSIBA27B+WLAt8COYmQD4QlhBInHAmgGEDIZCYyxAnEAiQw5wBjFmb2A5rbA4DtmXj +S7Jujeaenu7/96nSvOn0tGTZGo8tpeszalXXW9db/b71q9/zPPUUfw62pfZGEQUZLrkzst+grSyY +ylM3b/vebbu+N/DDT6wcOemkYx+59tizjl398OGhVSAJqGfRbuyHCZRetOcKPlkwFqfYk5cWwtjc +hkfcb7E/1xzehPzCtHbI6pKdEWz7+Z//+SLd8rPgvkVtUhDKIs/CiNevOBKZa0lvb3H+GmenOX/h +AMv5jl5LdeKvQLd1fbCw5m5KdwS6I9A2AvzZFcAJU13NBkdt2YpFqtnDotlVki2Htm7YsIFk+Fd/ +9Vfb8ntnTebkvTk9u/Jnxi8nFc9JJ51EwdTRPLitnvvua/XwletmipmHRryVvrQiqAwZRMEbBAl6 +FjyTqS3XCrObbvvi92785zu3/WzP6NRxDyofu3p4arI8MTnhyDM5Mb++oSbHhrMTPWxfa+XmbDn0 +mtLrM3PLh3r3jtZ37akn+W00A+H27qVuhYV89pamZusAzO7S8mygFySzmRSPBJlOfeUdkCKTfpTY +1t900pLqH4UoPA7wTx2WX0HPpMpRWt2CpkFJ7bTpCSnxXDIG5iBpeDiuzszsvXXbD2+564f/9uNP +LxtauXLoQUevPuXYlWcec9TaoaGTRoYH+vsWmWnBUQclIouc/uej11uf14KPtiYW8Y58lJrTC3np +pZcWOEoJ6kgpQp6iYI4wanBOX1ti61cMtVDScMKcD0FrzdAa9yrmoxPzWZ5Ohm+92o13R6A7Agce +AR7Os3hWNhHCoWKR2rGgPHlHXF4Qm0ag77p169oym0NM6ax/29bohEns+Z2fYx3vCNi2Ukv5NbSA +S9neorcFIw1xxtQMpb4iQB0bAkjwjGNaotJNt33ty5e/9ivfed/PttzADeDIcPm4Y0u7ds6MT00Q +lgbnmwxjIsQSPO6dnHakI/U2JSzZ7Mw0wSnHueVtO+vSh5xCnbz32VE6N11BFgGkT/JiNYRjBLXF +/pTgjqggCyDklhsjccQUiEJTlkGktXooEftkA8xDfZzsndinlCz+zaJdB5eGgjdhatQ/G3VqVBvM +kYYGSg7H7BtwoszWW3d/9+ob/+6LV//hxV992V9/+Xl//aVX/sM33n75//vUtddfdsvPfrR9+9bx +8SntBkjf24C3Mc8x+IBn4ciT0MKnA4SFMhmvn3N+qDwd7qhTZAxksEDa4ca5j5aufnEvofeHdFci +romkZsVJ631YqDqmVLr8jsmz/n30ox/dmqE1TqZEowOYbbDJq+nWq914dwS6I3DgEWDE4F3LdkDW +r4UoqLWU+TnLhJj1MbDHJl01S4DSL33pS2eddVaexhFZi+zMVp0kRnFjrznmI3N+N+0UIOaVjWBp +f9sBWtu9T+NHwv7RDKWtw1RId4vEQFCbXZJE847tP/rujy/adMeP+KKvlJt9faH7HFndHBquzMzO +NNjxKgaLq3Ph/9aJK+CtpzE7U7YNpjEb4FVjTFRtbt+FTtrZUmblSx4LC4UZes5yaaA3cFGjagZy +QYCjzvhDJZNP/BDe+hfMMvnUJaENlaqUhGoBsb0h1I327AgluRUCY6NCQuN6f8n+VOAqscmDYDoD +3AoAcqOzeGplKEmP3XUirNPT4/52T996286rem5RyKbTgcFaL2VwrbpiqG9kYGBNX++y/lpvtWew +r2/49tFl23eOTEz2HjWYmj7gB+BxQB7VRVsu60dn9YBDONp2KX8lrRXalpkusSTyIyKmlCXUIcQ+ +ILMAaSnWocglQyGGu/J7nVgcPOEJT3DYbWGpK10GB+ThtYiplw3dxHRz0ws/Gf4xZ5Bz7dq1BWYv +zNZN6Y5AdwQ6jgBQBKUM9yxqvWgsiRZmA5mWttQxTHAddlloT7zj7IYK6EVk0U1rXy8viRfLfLzz +ggsu8KaT67J4AMNM7k0spoVslLSwrSVLKZ/25Bdd9rG3LFl7i9VQJqAZQS1wzLnG99vf/ja7Emeg +0tK5lNtKeSKKo+4a3XzNTz9x/aarxqYme6osaBPh4xWw3Dz5jNKyofL0tEREr2IHCf9EEAuSQq7x +8TIL2F7uF6ZLw0eFl/n+SmX3rtBaMi8irsXn/Pku2D8qHh51UwgWi+ByvAAjG+EjEMQKoFFRsNuf +MTJhLTwGvXCRiRBxsSq4xYfHhMMUojoMIG2Jke5PZldhbQ6xUGAuNRifhMa4r5rVDzNRXiEocq4n +jYYa1EwKHbXZF4srJ0iWX5WjM+v31B8+OnvGGWuOudfnpvlp2ObZeVKYqu/r6/x/3haUkYlvgZHz +V+J/y097usFzKwxbt9pOal8aYW9x6HEuZc+ZF1horSTXg7xSqLSlL/xqqaurrc0tzNNN6Y5AdwQO +MAKMG7y5HV8iE4L3yxsqD0OkAkTVxkyX+X2b7sb7KE+RDQFVSsitm9szJV3YmaU+N61VrbiwN/c0 +Bdf+1re+ZbCI5iw33D9CUFhCt9ZGpcx4UooO2HLkpHiWHfeiM4YyB2zD3gZTtlWMlKKtAKGeEim8 +5gaHa696+8/ZG+KsFTTvQ2+7dvuWyYc9cvX//O111d7y+GQAGPjhb49lUbnGkS2EdCBMMM3e3nJY +9/Q2Y2fnRGm6Wg9crNOjxmXmuBoidbAZBojOzDaJXuElqMMRsUY/PaPZUL2n/mCN7JUCYgEqgJwP +8E+AoDogyO9OGAcJWoF5gdYpLiX24jAhTr4aMm1132HKS8OqP+mAtkQ8E3InuNUf/iPguvNiotus +maLuCEYpRMcJ1KE+cTF74Ng3cwgBOsJIyEc+0/qj5Cr93BQqFkAdQVQeLwze2bF9ANwGorJ1fNJy +PQcDonImFG6H4Y4d6CZ2R6A7Ah1HIFvmd7zkTc/L3IXWhQzpTd1tpdrWxG06IBOI2aOtyP3ylZ1R +gMSiBJuH3v/+9xsLGibTHMMtmGqfLOWWLfMdm7B/iCcau2vttwV1WdfVMWdbYp6U8yfYziHnaQVj +GcDDjt03jU1udXVibPaW63efftbK2bnmnbeMAVGJsOTYE0LbSIRan7M3NJA0sDFOHY3jWUbHY/sm +qhZ5+PAbI80XKzu/xfbTGtcKtQAzoIgyVnuSDW1CKaeeQaZgR8nIaHw0qkAN+UawfSXkwICQtS0L +X1pbRkOJp3K2IGTH90Ex7X6x/GLZlATFhL1qQzLD+hdtTU7tmS8RC+tcqH4TVQW3AZb5SDi5+wKw +3eks9plIpxuG/ZnLotHK+guXhPM4razeynaIwZtDbLs/aWrrj3WQDdnlaeF1kJm72boj0B2BB/4I +ECgSArfuO3/g97m1hz10dosSIBm7ZNOiiH30qCH+R1EsSJfYsRUKsKc97WnZdxR5d87DmxSDZruF +kFRAmxO//OUvs9eS/5xzznnNa16D+MJIgaqMrJxUnYj82muvXdjKjbf8y+cuO396duqYEwaB4bVX +bg0z2Gbzmiu2rTomtijByGWrHL7d/P5Ve9752h+9/Gn/9vsv+f61/7oLzDgxje9X7NAB3XwpUItS +Q9b6w3oIEQRSliH9gyEGHRmuADxKU1WHCJePBcDWCNIpLigOkrRFtRnC1Z5gepkLgtvgsom8xiU4 +Z7SSZwbMUgpmCUSVB3shfZWYOC7Y9tWfOpkXwWOMmfmSIAMoVU00lKTBuDJCrOZgyeLJggmC+hog +CumTXBqix1/UEYmHDKOpoiR18GwsDPsu35P/KEEPklzek1q7ebsj0B2B+20EwASpVSGwvd/6cW8b +zsYx97Z0SzkC8auuuooglzgXxbz55pt9ZtHulVdeme2sWrLvi8rARuszn/kMOTClplT7h3hro4vm +BQpnf/GLX5x339to+LjHPY76k30zFzbZi41VzAte8AICAVpoG/OZcaoBuBaw/b0bP/GV735wz9ge +3G/Zyr4HP2TZT6/bNTHGeXrz+mt2nH72avljH8ts49Ybxj/wRzcS+Z73u6f2D1b+4q037djBQZCT +vfftMyHRBXtAq1LDceMglsZsFbrRg4KuLVvjJFE4gfDlAPPCqtYelZnQiQIkEgiQHCgI2whdmewy +6008UhGwJ8A5kOkqKEMcASTuyfJI+eCRCfbkzJnxYMzYLhqoiacODMenzkzsTebBCT6BIk4MswNW +qXujpkBWyJ1dBuqnDPk5CARNTRuukPHGf/luup/dEeiOQHcEuiPQeQQWzV6XepIRM3UXc0dCXSsL +2EmlTLrLEtpV0LiwC3zNSKTowjszyfj4xz8OCNkK8QKFlTKe/sY3vsF4Mm/mA5yqfc973sOkiDMa +emnEd+3atXbQa0K7dtDnVuZmp7517Z/96LbLHRS63PaVoFbN/3LOmp/9dBSC9vZyIlg66ZTlpdJt +QGh0R+lbX6TAKz363DXrTh84+7ErNv14/Lor95z1iysZHPX2E4AyeilNp8NBk8SVZVKFB92BoQBX +m1iAIjyr0Z6GYTbDpYArNj4UnGgi4liDVQ4NZVUE6hqlsd2RgaC1mpRxeGTEgTOQmwtBcWBYgluA +l411XQqaCBcTEEa1KU+wUibBCVzhtETYDE1zu2Hciygn30a6GkRXqdS99CVGK9NcHUBJ46t82pE1 +3Xd86YbuCHRHoDsC3RHYzwgwcTGtLkJAAamO7c8TKMOgJmBjTJUd1hQEsa0lZkE2G9gYRAgMDl29 +7bbbfL7pTW+y80GEao0Rpgg0pUO1UTermkOk22zmfUiEverXnCCn0GxOffW7F/zoln9j9QPA8MuU +WDrj7KMu+ZtN1125va+/52Fnrea8QTrcqvb27NwaFj6f+9jPvvCJAJmBwcre3bNUjLH3pNycmmqG +4pO+M9nv8B/keJfYYVIq0XpCVlgFw+yN0Suc1VYWqkroKAdQhNCBiyGsdaZZaTTJeCWEFW4CLdCV +Nab77iBxRDiHQYLPjJfyw7b49JslhBPxF3iZUqIBaI0xw1TnimO0adcpwyhWS05Vi6uycvUApxPM +ay6GRooWA6UjuBRieJnz9+5ndwS6I9Adge4I7H8EWkxF95/pYK4wJyHgtruAkREQJeFUCrwhjtL3 +Z5Bpb5A9DBs2bLDv3sYjXDbvQXTuFYlu0S5e+8IXvpDsl4hYVcxMEow284GUBMi+yqz1XOQ7P/zQ +jzZ9t7/fTpWQYfb2JmuqZrlvoHrK+hU3/GAX3HrWS88Im52EGUjkqqPjy3973gkbnrrG1cH+ysT4 +HFdBQ9VwJQ8Ulw9Xts85oDQAb2CkND0e9NGpmuEu0EksyagnWGCVhjh8BwYUhZf2QF9BDVpB+PZM +hSoUnmWTXZegXeAhxmsvadDZEK6GfNVnqoRsWX4D6jOjY2SP7wF+kTltS81oDXQVQjG1xfQpOiaF +3a8VAYcPmlIkbcWRT82WEWqqQ9/URLjkZXaU4tGVJQ+OXnJaC4F/x5Ztxz7vvPMO/iDSjpV0E7sj +0B2B7ggs4ghUHV+9KNXRjP7ar/0aqSxmyfKWiJUM1q5206Kt8cUGoIVtsSd65StfaYOtT2fiPOc5 +z3GOB+qJ1DrxQ3FTJzMiSElWjIB+4QtfUInd/bYW2RRBkkxurDjwzuc27xi9/vpbt2Ci0EIpR4ZO +z9SD0jWbtqOc/ojVcHTl6v41xwz31MZVxTiIfvTRG9d85192fPWzW2q95dMePnLHzRO9g9WHnTVS +b/RgdyND5bHJhkrwttjZwjQ3HNU280YXZJQCcmZSD50K3gz/RD0l1kMYKmLqzwne4EqAf/7gNAhn +cyQbCIR2eieEKVDsWE0gmgBPTl99RkiHqWkI7uZKSGjjx6PUTL9hKFATQgN4NWYGDCkjg7JJ9ktE +rJTiUtQcqJzLYvLJpkkNoNxt5vTU8NJ9GNI/+7M/8wxkb2ELGya6cCqhPHmhtjDDwad4PhmpeTJ5 +StrfOu/ga+vm/E84Ah4h0jK7rZjJuH06Jtsis67qP+FoFLd8gE3Y9nw7CuLIO8d70dzrAjnem+g1 +Wf04u8oGGAJb2k1ubjgHP7Ah1qte9ap169axEvrLv/xL22Y4hDOvMcrdsGEDxScoZXDkkEgGR4xy +PbLycKz6vve9zy/nvGgpH/vYx7TLoFfKHduvA2aV2PzIZQEDYhtXGNAk5JvrOXn9UU959ilP/h8n +M+EZWZnxK4DqlIeNvOj1p3JZdPGf33r+S374139+6523hsO86em5/v4yQ6HJ6eB7SikDhAh7JwFn +X5gp2fQ5NRZPURwFk44gxTipS+XkNgEn1nrgWQpAjqsEf8CPwnV6MhCuCJAVZ/RWEikHiOY4VEs7 +R4OAqjSBK/oIOONr8oMfRZIi1le4rn598wfUpUcH+Pu17XU8YJsyFWYHlCbTX12K5lKjOZJxl9R3 +idHUxET2QEFAI9AxWC3JIFsxYjnCtT3XgJ4igWZdoiNLi2NQffUogl7TnDhdg6frhBNOcPiafd8i +Mkt/7Wtfe9/51OV0UOe10g1HxgjQNHHcw6WOic4c5aas8rkNabs72TjiaUs8Ur9aB3/ta19jIvr5 +z3/+oosuKnzWF/fr1TNRF1+PmEjVkdSLcjOQj+bSdAZKzYBmOtgphYLTtLhwvX/ppZcW7ZpfWgcX +WApQU6lir71NqES7iqjTr8XVXL7EpThzJFtX8Vcz7HNfdO6/3vhByNXsac5ViUkdF1qyGfS33/wI +3mYBQ29v+fRHrqlPN5etKD3kEYN/9ZVzQJ90wthH/uLyc859+MSuOdRz2WpO6ZvTE00Cz+k9zThQ +JSxmmzaDUpSS9NZx02qcozI+Vprau283C0DlazfEtAG5SfOaBMtm7+Cy/WFeC+cgViBZ4o4QDs7R +oQaJFLdVFMtM5rXSwaT4LBdIybwoKmE0lNcEyeY2sBCUSkqbbZgRkzyrn2AW5XXvEGeOFjZJlfOu +GEVcUk8oR1WrQq0noNXPwOUkPda94L76t4TBctXv26rqbmscFnqcZFvocgFJ9ey15e/41bqN1ITH +k3zaGu2DM0c75lzERLKTYmfXIlbbrep+GQF+RRg5WtwTvHl+Fi7sil7ZFmm+Kr4e2RHrCQznpS99 +KTGPFYYdjHlP4724a0Sf5OkNb3hD5vr3ooalLBKT8GIFYwfMCFoRUGt89rfmKVTyAELdAzTNXqkA +0ZxNVUKOq1y1HlABYPPzIOLS5Hijv7cW9jWlnthSCV+wvfQYwx3kNPhWkMbS8PJge9nMtVnnTbdM +5omeDw3XhpalTPCwWp6bDlcEfTa99AQZXTHSW2lU6o0mEAVyo3uS/yAe/pSthshX/WoPUExmPkAL +JRXIeB1farj1hycHTDe4pr8EjRgkqPMZBR3rZj8Mx7yJg0b/AaVsiW4WOJdluSHyzQshN5yKayhw +UW34ZWxpjWrJkI2G7rkaIJ30r/oWhNv2m8l5vWxSqYLbGEt/biEaX7rgR8yrLlbZHUNeruXf+t51 +iyEb6QWtfAZRlagz24q3VvjmN7+ZJyYiFpy1aI5TUH60PeSUEZs2bZLf/isM2PLx7W9/O1fAjpSR +qOxb3/rWXBuNQ7Yhv+mmmzZu3JgTbfGivCDdssVLikv2dFkZYMOWCDlP9/OBPAKwk2wje1H3/LTJ +2xCJj3zkI/mUBaaR3NG4F9Yb1FU2BPp897vfTbz5QL7Be9c3uxYZr+QJn79cQqCO9bQNwnXXXcfx +dZGTvwHLXDo+qxNjRTnoEoMJNJfHHun4Us7s7GF+fsgDeCwoit8vkaqHYBEbtnYQ2pw5LWL9rVXl +2c1na6SncdRAbUV9avvsTIVUEzOz1cQ2z4DJcs/0XCPUjZXS8Ejp6OPD1VEQtRByztVgLJ+6/CeY +WLE6Dg2Sgz3yYfgUoFUOqyXvz449dZgkJwsjSIOA+llhkqtQDeyBOnVCaCDkU8D/XDXQdryAKNiW +BapRLVGtRvUwtauIdrOk11UQGAiqn4qkbTBZne0WfE3a0fhowlr1JEVp9DT9WURYT7AzUjmeCqGj +V47+Rr6hu4NLU9M6HDtfIXrKE22pPAmHeRBcND8drb/cAeMZR/MMtTBjxtGF6VJMTJ49EZ461q5d +K0L9aToTEbJpt4hX1OdCD2SRqSWceuqptjWTpuCR5513nvPg8Fd7lOkR6BrMiaCXFATKcqUNF9/x +jndYjHs81EF5n3si7kYy2SXjytI/ieYRC23vP6M8X1/xilcQq7BdB6vOU2xzMSpDNzzQRoBFpG0C +FmQWQ04QatXWewY++9nPcs2DS+g2TM1rI1IWDwN3054iT6OdfpCG9OWBdmuH0h9vRGEDaF0I8Nx+ +2z0an7ZBsBJl9eKdsrQl+PWiETFyz3vhhRd6FzB+XYKm9DUETl4QBjEsZjZv3syvvdMpwG2GgEPp ++SGW7ZlLb/4h1rKUxRNudqZJLlV7Bpb1nt7b37DTozHX7Ks2QYLtnJAp8KYpUsbG+JofXF5yzBnM +4XvBa2BDqKO7A8P8KsmKFfsMU6BqWSLgGRwokenu2BGIB8z4rw82mXSfoBH2hAB2OvAJrNJ6qtnV +QDVYaHpPEtrAy7RDhvY0YCxZAKGetpnOJKdF4uoJvabjvgdDuwlKw4YWaCbzIq3rnjyq9uEPnhI7 +qxZwBhOFuBAUqYWaKLUbRJddBZNqs5OVTrc/KofNqhKAqAiBsDsFtHkFEPRX1UsevHVACJp2DPlS +x055Oa1khQIyvdUMvHOgnsylzGWkGvnl7FhPTgRpSCfhCrMRlEIiHyAEJHinCcIsqZ9f//rXTaZI +pDgsPEBtCy/97//9v6lvTcd2XV9++eWmY/MI66pWfcfCUt2UB84I+N03bNhAHWi9RXZSdEwKesqv +eJFSRKwCLZiI6yzLPEWWU8WlIyPCwqig5jmyUEW6cBCsVtetW5ffUJ/kOpiY19+YeFXFVeKl9j5C +ZRs6rI9dMmUDXWIhOdugeukHk7IPeznsQ+t6ZKT0qD2VH05Mbq/UesJHfKOJvfGZAE4hh3M93fHK +VYSrThJt9vc2HIsGMKBOrRrnmOKvwInMFuQwJuJitw7GauVjjxoZaNS+u3XH4HCZmrM5FzktQoLJ +BQsK+MQ7w951NvSdJKgyqDkzvCCpSRqhSxI1kdFav/RHDf40WgRYiIm6pInYh5q2vsDM8N6XsLOI +B5zrAFidhz0wzwQp08oGRal0P3Pa5WJVAWvVGafd1KKregV0NeRGwHMz7ZHVE4ZR/jLQFr1agohX +wpu2P5GGNye/YAt7Asna9KN2UrFZyzmJmNg+iLPOxQ/4lbSNamElRQq5K/MQzXmxzZjSCYQf+9jH +enuLPExIiHmLr/coQmKc87NANgtn3b8UPPge1dPNfD+OAN3nunXryCStfrJvcFYdHhjGla3PSWsP +C0EFvdX+hC6t+Q+vOJVHAZwwVecLTVzrjSwcBNScnal1CckwMtqaWRyIYrGWyDk96/sIhORETx3W +5syojsfLtNVz330FHYmS3Hct3Pc1t4Ko1io9A8srvzg98I8TrITQsBoBbBOmzkzjprENZnCkxMiI +8ar45HSIc9nUmB7pVXvKFVICvA28Tc+Q6PbASiJZBG/r7snGzJRLmBx2a6Mn3oY1cpUAjXIfCJBB +khYRPmUUNuka4PhLVrWwGYYpC7EgIr4YEJbwDzeVB5zrdACYS/CbZ/kEovLAxRDnJsADsfosKKpy +/YGmBb5qVEOClLB6Ekki3wIC4O6celgdKx9SkxBHy5OAOyKUptOahs7/jhqRbQkCHD0A6TzApYPs +GzktkMYhCuhaWBDoEiiZEKFacXYCGgFcWzNjk8hua0oRzwJeX7MXkSJ9YcR8SuJHrqX+hVe7KQ/w +ESC8tQm+kNj7NR0rbXIn8AcqB+h8Fj8cIMPheIn8xn3lnotYqh5Y8FMMAh8DjA8IfqCvpUnbvZsT +vFC2Y2CurZdoZ7zO1rsOJ+YvtvXSEsfT7pAlbvO+b264sn6k99Rwdjtdqg02CVGJcIP5oaSlMjIK +KxoEuXX7XMrNWeiaUarcB0qrpSEHfzZKKwb6T1y9YoKVL4+A46Wxsdm9E07OC5d7iGwY8iSBLVcM +AmAL5EsnfcKwgDQCUmwPDicYs8UFakKlLG4N+Ez61DwYuiUleKGQYRVqIoiJ0WZJbMhmXUzMNeqM +Y8WiD7JpA6jrJ3ANJE7klVQ5VJ4JfYF6mB0lPauCIe9NalpdRY5RZAuCnD8GyJ/byZ1ZchxlvG1p +eYBwiDIcOhjM1eHeV1xxRQxoqUTR4hSEHM+fUliukSBR1fDyQfQq3WuMktqaZaUFHSUSxlLKAl3s +ltK0qIEACgZDx4svvpg0uEjvGEGaqZT+9E//NO/JuVvc7VhJN3GJRwCVpAXXqAX0nXfe2WoRee65 +52JISGqrsDd3DxhkpQPLbc+PbEvc7fu6OQ8z5WW2A/JeFIdyt7bbcRC89aCUr3UCnkzlEVmL5kzZ +CW+8tllyo6rMdL10xLyyWbh411qbWPp4oi1L3+yitthRhDLSOHd88M5dU3ump6qV3sZAuTwNDqcb +fQPl5auDpOGFjZl0eFilYQ8o1ED1ZmbLQIWSkmuhyWb9Z7dNAKkejhrCNseOCztfbBstM3wFNuDK +vlKvkoO7meDCodCncsgwE2AGokTUqULUM+BtHjhBmuawUp8oJiwM8XqmnvN2toorFaazCTID+VKA +oLxACCoRApuhY4JhkltdysHdQcAMgnFrMiOgvvsiJJPgoOB481TUEMLh2PwTFUZme1spfT2cOX+u +9L7/tN40PTF0hKMducq7aQAAIABJREFUW4NwQtuyNOd8/vOfX1DMA2sZ6TiZFG7cuBEF9AITFLPU +b20OB127dq23Fx/l25nNLQkS813Wgzae/uEf/iEotQRmYMJQSLplOCBkcJQrcWoCuKUA45mEF+gD +Q6OeIMfOLNIZ9ZgULrnkktbOdOMPwBHwELIL8xzSQfjVCqFF7ioxo4cBT/LwtHbeTHX11VcjXqxP +n/jEJ2a71tYMh3vcygCU2lZL5IOOk3svvCNvXMdBINplN1RALyKLbhpGdN+r6p0ynt5EwGnV4n2x +FrG1xkThJ7BPcmFDS5lSfuivveRbH/3jpWzyENuyABRMZDlYiVj3+SSXtw4Sz199jtev2zx9ydhY +BcXsr6GHpbu2NUaWl04+s2Qby9R4ZWxypqfSmJ1tooYQ6KjB2p6J2VpPcxqiVLlWaJYbZX7kK9WG +nSFkoYQKk+OhiGQ6FGpFVq8zpf4R4Opk05D39veVbMGEZQHGyWQXsgInSlm4GMLeeS4IREmDA72S +nwSQpsLQp2KNyW4W5BGuQt+MhYpDOyFrNKXCTprOxEUjXWeiZ2l9EN+LkPBeZvXoSQhvU42YbgZ7 +KVE2aWcD7zlUMhr10ujc+vHGw/c21j/86GPPf95jivru04i1KnMhM1Rh2t7WnLfLJAW6vDxtl+7p +V8+MDSe8N+zvcFyTXeYZpE/FJhml6MBa98m4CjItnOEuyybx3JO7VcG2dVi15oj9aX/bMne/3u8j +4Fn1hBBdFpY1B+6SBSJt/R/8wR8QPChy5IFocftu0PTbcSls0LzaUHbhIJD92JLbZqyOehqoYqwQ +UEMn5LYAQaakRdNFRG05J9hW3LyRqqniuKaOTL10JoPIuz573dbZkfXH9a0/vtdnUcnBRxbtvJeD +b3Kxcuax8NkWKervL59x7OCWW6avnJ3sHZtt9kGsZnnV6ia7mxW1wTtGJyDW7AzGGFxvpK86M1N2 +ugtwgjkEwmhik41SuUw8K0DBMGdtNJ1Cunc0IJCutLcnDniZGYujSdnWhn+G2eRCiEhWmeSKAfSC +QJk1pwYhIC/pJpUCB8guFgjMAJg88CHoL7oc/YpImBEJCTNlQ2HVDg0D/xLmQURBSsbasObNX1kV +yZbZKtqa6GWC0cgZNSSq6jPqRFhzisLExYmrL7Hc3yMOI0l4wJKXJG6jJfgtrP2BzaGDqFq9VywD +W6pvjxbCugJEc6lWEJXSerW1igPbMbXmzHGqtYWJ3ZQH7Ah4CO/dT3bEL5Xc4P7u0aBlE8KFGbji +WbgbLWcunoE2nY4JwWxQXL0fI4e3XNc45mAE56Pxf/7qs7f+C8euvH17ZfP0WHVivNk30Fyzho1N +z96p+uTUXBmulqlMk1PcSmXP9GxPX9j4JGCTmWS1yUWRqmvVJurJnFfiOAOlemlwZQhjJyfKhMDV +/ubQ8jA4grjQNK+Woh4AnAS2xKecMCB5kCEUljASvwSZybBIzWhoAG2iWGGFlLSqrkY6rE1oiiwC +SCnBRN1iglUAzDrXN5cy0QTGNn1qCMOOz/RwicPcoHBJ8LuPyyXDXWglLUyidAkbTtZGEuXRz6h6 +aYM3jbhsfzYa+cdd2h4dVGtILXvgB8hbfVA97mZa2hEgqGgT8y5t+w/o1vBCQmDbyR7Qvdx/5xIr +2f/lB+yVjJpF90y+OaUA0X1fnaU9s3FkaHBoRaPMX/zy0orleGd9qj4TvhFAV61Mmjrc22vrZ70x +F5tVkuVqE9pRfPbaVdlETAPDwp1emS03vOwfDP+94+P2ozZ7BwJcARW3DDZxhvOHchgDy28vJsCz +D4rFb2wtTaevkNAGdNFQJgsm4lxQBXoRRAga9SfGiYPGX4Ixnu7DXilBYiCrvsE80Jg8EwUztt/U +5tYk+4W+KLWymXGis8pGi8k7khGLFLcDIuFxMgMOQS7pbpIhByFGi9NzIef9FYpfsy1yf/Xnbtsl +PrK/vpA43W3+bob/bCPgCTmw/OM/24C03i9xKynU4fv6JAbUekOHSTzjpc62zbO+wtQiXaRaOm5F +84kDfZUVK3tWLKtVy5WBwdpMs9FTa/oSktuQozZGZxnvhrt5PJKUdNlAdai/d3yqzMVBpRLnuoTj +AlLctEm0WimP7Ql/DoP9+8yIGPFqNpAsOSQCQMAMVIfk1qbVpOnMlkGhN8X27E9NzBVugeEAV9iW +DnuREgLbRB9BJ1zPItaAT/wymQhpjhET4TOoCz6qtmS7BB4zAfVf5qNoq7b2JSbsdJuCai0OMpQG +mpL92quarJZ0gAI4+G43dEegOwLdEeiOwN2NgDk2UZ67y/fAvJ7RtPjMrDR/Fh12tTJ38rLShtpg +/YQTsK3Kslo/SKo3m4N9tYHeCr3prvE6rwoBPEk6OtDXPHG1c9fKcbYowsqvQh+Hus2G3ZQJk/A5 +AEwyj4CCKEwR/7N1BBYqQhRsTCFTLSkdCYF9zV4D4THkg1sCmlhXEPlLJ37DWtAlHn0A/4mhBjbP +e7EP2WwS+WoyKgB+nBMlV7rwL+yeiIuTHZOvegUjFY8aUhPxSyeWGYlJpJzBVVsKRtPpUHFx0t3I +M5+/GMlupDsC3RHojkB3BBaOAP1owVUWXn0gpsDFbIEi0hoyDS2gtIgwynIblZkzh3v2lnq+h73Z +00Ieu+6oNdPT9R2zu4AioWgt0VAIBrcevHLF9h0zW3ex5gWfsWEUmsKwoYGQzQZozTUVAYdZWguf +woUCgpiMgzJ0AdcgqTCJ/W0CRUw0X0Il1aNUmPPwqBAbUsMaSM74MWyVSfZHoopkjigRvoLtrAR1 +KSyAwj1h1CmPm9Rzn7hsgYvxHXaS9BLqKhP0PdqNPAnLA9RTD3HTXBzJVipqiI7kfxHvhu4IdEeg +OwLdEeg4AnA0ZssHSHDmDjfithA5QOMAXQKf+WrGUZCZUZOQnb66AFeJGURlltg/95ix7Xumll9f +muqvz/UcvXz5NTffOTvHwV950PFnM7agBFgxOrpzx9TOsalyT5zIvW94mqG55BdJy9neB44CNhta +QJ04lIWFQBewASowNBVnhIe6NHSfyb0fwAsmmuJEvsAVcGKralBEiq9AXR4QCZIFV4MgKpQIohrg +Yu4AvghWAaEMGhXiKtzVAfbGkDV5Y4hsTIKjXMAnxI1sbjTR4gD+RIL1OHqetKeZjyZKG9UuceAa +5sMf/rAdBR3bZRx73nnnFb6wO+bpJnZHoDsC3RFYyhFY5H0v9sw5JAh6Mfo3FdpawF9zsaOu9cY2 +bNgAMrlVa4VMO5QdgvGe97ynNbG1VGs846WUAk1FFgJqzpA/mz0T43vn5mbq/UPVrbtHp+vjXBqB +KM6GgGJgTxzbUm5Up0BUT7M8wzVgI07kzpcCjchg50r9QwF7QJRvdzY+tsSM7w3MA6hALqAuoSD3 +DnA0yF8S1QaA2RUarvBDahp2Q84pm4yCwURhW/j4jbJQmZRVVSCNSRHBbAR1Jm2odCiY8S/8KCUR +MagMqTNQ9JnsjGhhI9FnllfrV3L/Cywz7sqsoWg9Y21qLpSj2lKJppWNL0sXSBocI/qc5zyHx/aO +rfJp4lRCefzWHTM8QBKd5uH5b/P3+wDpW7cbizUCVu2cbJjfrODVeeONN9oW6WCDxar/MK3Hpk+b +RDvuH+XamgswjsAO01vbX7dJ/UyWixNsQjfBsbnauHGjedBgmeycDyf9IBt4wQte4OyLg3ROkWfS +DJwFfErMO22l5MQc0YFydWdP35bmTG1mrl5u1u/YtqPWDM/0YT3kbLVwrsu/A8xr8moUjnMTrALC +EHX2lDFF7ukD4cLZXplgNtwVORNmIDLYGAo1XTKaYAmUMiMSgZqAKhISuCoS9sDgkB0Q/OM4MJFR +SCkzYJMij0thdpR+mQS+MX64I31qQPK8/tJ19WSkjI2iiCzIxFz9qlknmgA4qkkC58hJ/yqP0Ujy +3sjpD2SSCaufTVNS0GrFpbgaLS9dMDF5A+0ts726Y2D0KINsbX2y8OJRYV0Kzldqu3ooXx1wVsAh +b38eMI9orpBvI2u+jpXD+65boo4jc8QkOqWA4x4udSz9s39dPv9uuOGGthuUjSOetsQj9avJ03E3 +Dgq1B+yiiy4qfNYX9+vgB/tEi69HTCTJ+BbjbnBQ/vjNMiJOVbU0QzdBmiC9kK8euCneup/3vOfl +Y2/lvOqqqxy1wVicSXThhtgZ61xq2Wm0YcMG57hqUXjZy1721Kc+VaNcp4LhD3zgA9qV7tOM9pa3 +vOX5z3/+K172hi9cfHNPNTaNbt8y9YG3//TVv/lvf/Ti677wsdt5V2C3C00DToCOs1z43ktYGAeZ +hRVPE+9kZ9SYAZzcBDbpPqFR0E16UNtG086TTEPVoxYIBBExTpdwJ3FAGJCWVLCEvSG/TXZGWGzY +64KxhNzZsAhDzRgm4kfyJz+uaeEbn7DcaWhJnAvao6vZoWCCyUSGY2NMxstAxIyyVgmJoYL2zJJ1 +R7VRf6pZi7qht3H1wD/VfXPVctVWaz6D9hf8plA2H+jY1gVrOAdRCYt7qC+ByqWXXprbgqA6UEwE +SOfCsynaetX9ekSOAD8hnO9wRm9icQSe9dv+btO2yKc85Sn7u3qEpVtP0M29+MUv5paIGxNz9b2+ +QUT/rW9968IV872u8D4t2JNtdg69DY6gwB5BLnEW196mM59ZtEt46+rBNCE/V22jo6My83fsgEZH +pXOaatX/+Mc/XqJTdRwMiZRY8tjzDj4VMbVxIO5Qute+9rUcoppnnaPr5wSinEHziWpZxCfqc19y +9sPOWF7tqfT2lP/09df/6Jo9/+MlD37kL638xj/c9d1Ld8zONEGUA2FrznyxK7SvWe0N3wsgB/kB +Rb29gZ19w8EgA5aSS/pgkAS5yZ2QzP58habQCFMkmyXyFXf3wCnDXqByIqOQFeBBUOglA7ykMSUu +hrtBT5PaMgyUgDKIzYrSeX4JgImUgb3aAgZTi3mEc350NiivzqSBV3mY4yKyaVtqZp86Bj594qkF +4ooFhMPjhKnR/BIGT6OfjwjBA9MxuARoD+ahVdyZ247j4Lf21a9+dV4ae8+J3eAfDauHxJ1RJXCN +ze0D5/LOMpTyqU99yiqN06L3vve9vvKgy2NfPv0bjjqyO+MoJ8AELc4f5e+Nt0/FHT1RuNgtxozX +QDVwKCoFk3bsMCc4Z5xxBveHRZ5u5LAbAcSACDd7UfdMtm18JEpxgLwnxH05wyQTA0+CucjE6PPd +73438eZhd9d322Hzs2cbCsjJXy5X9R2LtA2CSZ5b/yIn3uV1+/SnPw1EjZUTvF0yz5vz/+RP/kS6 +9yhnxqPIO8kDFnfpXPTk4CMm0sUJCATQ4rbNYVIkbBYjPsWlSHf1njbD2EQpJ/mZDfn7ftWrXqWG +j3/84+ZQcjayO1TA5IgrwFHBVb4rSeH4XxU3sp5vD7Q8Hvft27dsePLI2Y9Z3ajUb//JxObbpk57 ++LKH/Jfhn/+vDn8pXXflbmJYBI43B0jD8kh94Z8oiVi5wO0dCnpmy2kIPGkTw6FgwJs4LJwi450O +0HI18DIJSzHOvrQrBlvVucDL5AJQngiJsIJJf4AQyMkTNUDElEFmAdcEscStGerCwkh7UTrhHDTX +mcQ1ZZAN5Aeyuqy4GhNMhl/7ZJcbXBaUEiBHHfOYSuCcpKSadV+u7dOYpiZSxiX9yDjqJ+sYMo52 +7BAURBEEsCcDx/HwktjNp6Nd/viP/1iih8H6zMt58cUXe3444eQ8wdPF5zV5FOz0uhJpkEoRxxFj +eHQ5Vzr77LMzJbUidDXjKD/1hZrHI2cGOf/889/0pje19s1E8KxnPYsT8+zwzNkvOmmFh8fI3Jqz +Gz+8RsDMZgn1sY99DBy2repArCWapZg1nJsyBWXxidnMI2395JFDUj2WLh1ed323vW31L01tDPAW +3qPxaRuEdevWkYdbZ6if4NdbuXbt2qzdw2s3btwoHZqa8y2IrY+9wlIcFcCvvYXpb//2bx+MPc3d +dv5QMpjy86R6KJVEWaNjBrTWFjAAZ045MDmfdyPd1XvaADqriIPjWwvinb6arR73uMd98IMfNMeh +/+bWnIehbzHPQkJ8VB9wVnrv97znfa9+3jcv/9au6am5W24OU9of/b89b3n5Dz/whz/tH6zwEQiN +ZoFNrTQ61uSKYXYmDHiA3ECyFWIFVGeRBDXJfsvlqTEOHOJqlEqC37A2GtwHitAozHGTc10U1vgC +RTgHemGVdPiaM5DQuoxZqsQWmuC+846HgtomeNOoXkVbCZ6JYRWChUTKgc3ze0MNsL5lsa225AmB +bSKghl5VwVChLPxmypQiOqNjQT0TeGuCuJhpUiwRoqOL9Wi0/oB3H0c3/XCemY4hX+pYC32MxZaQ +V/rmOPZKIBABtRqzAsul/HyWaICNHQRgs+Bz/It33sSnaSc3cfCraQwDZ6UUUGrDhg1w1PFYipCL +IKAeTjiaT/kwpfL35tITnvAEz6e5suieJSCpSQGZFtpUEqDaeeDf/va3DxeZVXE73UjrCFA5eTAs +vxzXY3IvLknx8FAHFClFxOz09Kc/3fRoWvPIoWXFpSMjYqYtqHmOWLm23drCQTCNg1LGB3L6pMjj +Vtc76KvXR1wldM9EPlAZshA9uuRFBroWpnJ6c6Xcj6Fqwl2UYHRoMbMUi9w1MCeBq/lCuqv3tBUY +rAiBWF6P5OIGUeT3fu/3iOAtA3MoQFor5tncVo679LSnPc3q7wtf/IvPXHz5X7z1+nde9Mjlq0Ls +8KBTB9/43jPGJudYGDXtWkmnmHGoC6IQykAWkXBVn2SqycKWkHZ6Msx0OeYdHA4sBH7us7c3nP+B +KG8T4a17DURM5kUakgFbzXDoUqAjyXC+H9FkKuyqtqRKFwdj2ZIm4AxSJk1q7PhM8tsAv5QzDmLD +89NPqGaZM10Gk47pVjCPembJucGIa2ceO6NFdaayuRU16567xnJzzfM9XaL/vRJ+uzb/1EXb3pz8 +ghUpRQTjLAyCJII0RzjlqxZYVq95svOEkJHkdHlAWn5Wc8rXv/51bzI5bf6qlIg5kQUcTGU9RwJM +ckXAS6aUjYy85O94xzuI73L9nslclmwK61WqqB/HpcLPIiyTBRJ8v6+jc1e7n/duBEws69at84Na +ZuVFFVmI58e6rfjR22r2+OUUfKN1ydWW7TD96u0ogBOmuouOHqcXDgIh8GWXXbZhwwZynYU2B0DU +TG4ZmoclHyBBeiSnI9Md1kYg1NE8eMmG0b6XxWmLTJx8zKrf9GG6cU6N5TYyTiOFEWaJ+cKWPH/F +pEZN1ZqBQIx4BGOwfDPZ4fKYPobxd3/3d+RyfjBUg4jMhsKCs5p/hfwE+9So1vXn9PUP/eX/tvrL +/1SbnKzPzfWsP3vl0cf33/zj8b//6K3rz1np4LQdmxtn/dJK+1vSVs5kgpOEtNhhOgA89If2ugwP +NmcnOUIqDQ6qvAkds4Ervgg14avdMsAVjLkEUNG7gCVM0XExfPlWwtoI+wz3CwAsoaNbVioy+0pQ +nPa9xOo2o6NfB875lgTImhPCTWAgfaKYcNHRMam4S7qh91GES14151aSDDlsiSXlPFKYJpEJB+tO +fDRhcFxmu6sbCooUiXFhiULBRzu25w3cH4625adWICzKs5vnxLtXrJSLnB4tj1PxVcTshoYWlm75 +kunS/EjjlQ91cuyoJ9BrnJd6b37zm+UX6PXzG55LWT4yMKHOJw2WOVfuXSCGyhm6n0fACBDeOiDT +PJPvxfPjBFmTO9G9OeoAN4hymCcPkOFwvGQyz+JZnRex+xEQHOBGikHwsrBUsBiFvpYmbUXMCXD0 +N3/zNzHX1kukSowSmEMTDhWGqK0Zlixuml+cYJIyrSAEtEdve9vb3v/+91P/0jNbmpmtFk5hudXX +v/71Vvo5FGaQ+RLJLQtMq3vCMZYab3zjG6UbOGf4AUtbDixeEFNPMMgUXJVunvVZxO1npZ1+4Xkv +fumz/uGYEwZ+54/WH7N6uHeg8crzH3rqmSNf+syWC153/fvPv+nKy7ZX+6BTk8SVnW8INpP1DXfz +XBo1GuGq3tmiE+MwKxztonoUvnadIo6DvONmxlnbZ5qrdShFfBosE/NLglkwFoY/nN2n/abgNlA2 +QV3s+Ex45jsaqnU3EKvWwE854n/pAaIupK/iRMFhfJQktHqbA3yVISAwGQrJFvQ37Y2RB0hr1PBY +PKlTv0NdmsAehNPFZrZqWUC5q+Xc/r6ql+o/wgxLywOEg5ThWKIy/4ZtggVZx81U3kyU1Jnb1nwU +BLShUnBNr6Xb9ewpK6IzqK3EPPGdc8458mSEdpU5CYbqCfzyl7/sq0p85oAiw2ASkawlgqmeXotr +V6UU5hLz2bv/HzYjgEoS7+uuh4TAv3X9dO6552JISGqrsDffGDDIvz5RhOdEtsPmhg+uo14ThCc/ +2Cb/4lDu1tIdB8FbD0ppVbCpPJkjsibzTNmzfpBoJw9pZrrmdi+RbBYu98L+prVLhx4PCeeiBOhl +giOnAqVuz8QEO6VYQSAQGdtaG8JEW78WcTa3RRwlFTyvajCX5XQTooAfqNNhVVmMRhzn59GoT8iN +thpZg27iYzOybe/l9aEvTc02jlk1tGP3DL44vKL28j88rc5bPaVouafeUwYnaNxgf2XnbrrEMsNd +tI/p7MBAmZ3OUFoG8Z3bPxA4ND3FC1L4TBAg1xSnen0Rt7Ml4CfhJWirOgfG96SqBGNEuOANJIdo +x+kuaS9pXPYtaTejLvFkx6QzOpBJYUotVRJYZmzLuJmbg9mhzsw1KK5y6BjNJxAFnyynwHAkJHeA +SSeqX6yWiH8FvdIyLivI7AaNRu553M8SBk+LnxsyFT93W+MErULbsrQtT/7KSshjkNe2RBfvfOc7 +F2ajCsUsrcmYc3t4IKWcF154IX0nOQcJFU38S1/6UgU3bNgAcXNt+KiUAkdf8pKXMCy3KKYwY3mU +CWjRlmWcxOc+97mw3FrQrXntBbOAeaEr1y0G6vCKeAidNu85NAshYcXDkO/CGo7ltkei7aA0CEFR +hXjRkdOU709Kd3gNRWtvrQxAqW219DLouEVk69UcB5kdB4Fol91QAb2ILNZkGNH9jRs3PvOZzzSe +F1xwAeC0aqF5sRZhRWii8BNAhIUNLWVK+bQnv+iyj71lsZo0GUEvAZ65PVAqFNLwxWqltR44moMW +RcCnPvgUck987mp+ZmT5DTdt2T03M7diuG9ytrFl2yROObys1JyujI7P2eICioYcPjrTMwZZGexW +moEoyd6VN104Ck3DBeBgnLJiO2m4LmqEm4XMCHE4EayOtZGACJJnoJ7AUp7QsyYzn6gz6TtRSfwv +A5imAwd9Zbib+CISmdEUVQXYIafN0l0QSfALDhPmBZomXIXc8gc0ZqIJMhMJBp9ZVhxcNkMmpEyM +NtBXH6wG3COFLl7LxQRv+8nfoau7JtdvG334ntn1p6889vzn/Qdrr9bxX9y4H5Etnxlqf1zN22WS +gn+eroNpGlyZvPaHyrkGj4plWRa95hQP0pYtWxgQHWQrHjmKW62I4BlMSA7QN/slGHAW6owD5Oxe +eiCPgGcVHBJdmuIOpp8WiKQR9hR4ABQ58kC0GAQ3aNbt+NIZNK82lF04CMx0Gdtn1UlRFeppoIqx +wtACUeYH3HuaKWmRv4ioLecE24qbN1I11SywzJRXZ7ywwrs+e93W2ZH1x/WtP77XZ1HJwUequcaD +L3DgnHop7M9I5MBlD+WquzDlGRGfBlcffBomYaY+Xqlt3bxjtDHXWDY0sGbZ8Pdv3iq/I1x6m72b +d8wMrgjqBUjGxpjszoVrBWCW6VryNd8/EvjEiNfUTZ8MTV0GoqzWFSSSVRa+ygBNUVhfpcNpHnfp +2iGcEJiXtJXoorLyZEwNjWbCOF/BGGlwyFfhH48QcC5fSowTIqoBgmZJrDh/wCErVkPyhRQwDFgz +6IJG9SqeURPHTX12I25N3/RBisXBnH2r8iRH9lkarFxUkopH55Yw+PlgJAkPeY5fsK1lvxr4sSA9 +SHhT3DTXVsnCr16wVhCVQUNZ97kwc8cUz1ueNUQODKKKE64IHevpJh5GI+AhpA29Fx0+4n/99IB3 +fsINWkaHhYNAr4eAto1nG5S06XS8p2aDtiL3y9fqPIG5X1pfhEYNpVrMuSJ5ehUXxAXzWk91Z//g +rm3j4Wahr6988+bRWdRzOPBl69YZsk4qTFs82Q1NzZi4y2GUO9WcHEve52196WsqBRjRttXLexsz +c6Mz9Vp/uc4FkoPBhwNywA+XgRk7AU8WkE5RYVKvgt6+gC4NATytQkEZIpLErYTMgaBywMDkFxB4 +wrmQrCYQRUmBX4hwZUgh6kki5QDRwOfIqZ7Yt+pL+oz0ZN8UVDWxWFcYEAmqyjXlnisCU5W0CNBb +dQV8gXCtuBY1LmnwqxGX7c9GI//cS9qhbmPdEViMEbDAahPzLkatR0gdKBAhsL1nh+n97Jt7D9Pe +F902vcJOn4KJWByCIqMis5WbJ6cm+qq1Sm+NreyeyamB/iap7cRkY5qidBlvugFLTdtDKUSdhkbu +mux+CGMbM80a0uciL4AwtVLePBoi1/7+0sRUAkiUjvkt7pgkqKhq3j8Dk6BsiG3Z+2TT2WTjAz4x +0ZCygqpk2hOA6gtU9zVJa6v6EG2GGBnAEbpGnvyZbjjOfZMT3GlbkDmqSJbAyUFgfFUyfUYuBr3i +Se0a1sKS+P516BveTF/rYDjbchSsRcequSDjo3nYjqqXPPgdl7zNboPdEbgPR4CA0Wan+7CBw7lq +0zUp1OF7B2kCPny7n3pezLkZRPNnJqPi080fjk/Pcr+wZmTZnsk5Tv+OXznM99/MXMAhUAk9JQzj +eCFxx2o53Of2DgWggkyKxv5yJWxoy6VtO6eROS4DEUEHxZCFTibRLr4I84hwZyaC2wFRJkgIpQoV +pAqFVf4C0gAuqvqNAAAgAElEQVStA164XKBYpY9Mzv9CJ5oFs1grbgpBCGyhLxz1SeIKkueZYXBH +lsVyStJEghtFFMzAmaXKWfYb6JuyaBowxVfZUhHAGfldkJBAVLLVQEiDSYyTEtfSIfPdw/wB6Xa/ +OwLdEeiOwH04AlWc7T6sfqmqzlBaUFJfBVA6V9raN7inOd0DxnaP72WBSQC7befM+OyM3aIQRY4m +d7qhNmyQ3w7UelaN9I6NTYAQMDbUX1q9vO+u7VOOJIN2zjhThLf6qUmQE4ZIIFPNcmJyYDWjL7iS +EiHt7ITW9OJ4avZ5EsiU4C08EWaWCWLJYDn/UyrtV8EmQ4Ga1LTa9QvFpWQMrNZ9ax9ek+Cg1hVU +DhZqkPQ5CZYzbEcf5E42SqJBqfVtHh33mSYpm1ippYC8mQeGwjVVpUg3dEegOwLdEeiOwAFG4AjB +UXcIOH2C0izXzfc8XbppamK82ahMz9Vnx5rQpb/WMzoz29vbMzUxl6WdYGpysjSyIuBmbra5a3Qa +icxwUuutzEw3J6bDeii4WvIFCHOhGhCFl3jbTIJMQFiDl4ngwktdCdFrOoNFfiCaXSuH7NQl+Mqa +Nxn7BAaHqFhqkEXtAlcNBYBJT7ZjoRBN0Bs3lVBUihZ1IBKSVBmagsNISWrRLJ1VR8B2CoisuBRt ++STEFiICnpMJkoKQO0yL3SBXvblgDGo3dEegOwLdEeiOwH5HgL3ufq8d1hcSIy3vnvrR3ilOjAIb +bF/p6+9pznB01IAiAKzB+lY0NqsE3MxO+2bfQkBmwGS5tGdsbme9Lm6QwGGll9fAMuEtugaxpAfg +JZqYjYns2gxYTYnqB6uucuYQJjxhqZRktoAq4StE5FYwOGsipqEHzba4UUFUDhcF9SgY3vvS7wHz +on4flKOaTgJYnSGdlqJImCAlgXAWLINJ966GuIX5SsBwQv8g2dLVllHTXp3A72QGHMJkXXJ5aQPH +Gvzf2lHQsVnbOs877zwuhzpe7SZ2R6A7At0RWPoRqJaDCh2BAY7Wm6Oz5Run63NDztpuNHZMTgxD +sHKjmXSWyKItLtPjgKcJMDiUJ/PMHKy/Wpqcafb003faHhP2shgqSupINSY5AKba3yStBUvgJ5eC +bgBoIgl+sV6UFESJ2DzK7V/gExjzD5SmjSiBVYAKHvcnhEuwFhgJxSTCwpxTEfEk5hV1iVbVLxYo +nrhm4H+KBOCl+v2veKwSEmGN6wnC4/+EwVJkDBIMqlNDGaql66F69DDsqub5bjSwVIE4gRMr/hP2 +5zKN74I///M/lyeLH9r6xerv5ptvZtDBWxuxRNvV7tfuCCzuCHjeuMFiiMtMRs2cJ9sW6VyExW3l +sKvNpk+bRDvuH7Vz2jESxUFJh92t7a/Di+Zfd38NLGW6udVEXLQ427il3hivVWrjE9BndqCXYz/i +3blKb3mm3qzUyghcX1+T1rPB7qgniOUxI0ONkdm7tk8DP5ACaWRgGRQbfwPHmOE0e6pOkgnU4p8I +AtWRS170XKIiJd21yyWZ7QQaJemrq6HjDOwK6JIzNJRJOKxOBrTEvJqLNzFb7aYbyJia7yXzyAyf +4tp21SfkE0n9CtQUdCD+n0fZRjL0lRD55cxOBPUqSYDDGCq1GAVRUlepeEG+KpBvt5xJq8tLFUxM +3kB7y2yv7tgmjJRBtmJrds7GDYId7vzCc9HHTptnXR5P+DDiq89mg+zeT06n29qfau7zMoNq9XTh +tuM4dxPvdgScOuBwRvsXuezg0IqMhM8/j1YbjsomUYa7rfAIyGD6dX6Dty9v6+Rl0wvbel/eU/tE +j0Ac5de99T4P63griIqPTv+w3DO7cmTkxtt2WzCuO/qoGyZ3Nwk66Sbxusly34pSrVmZnJwbtmd0 +ll1u3yNOPfHS791MITo8Ug4/RFXa1oBPHhVwWk5xp2fDTBccYqIMc0CO/aawh3oSOoJM+f25yvuu +T2hkfG2tkROy4qABfmmUkb9ALLzTIWtAC2ylc0b9IDkDwa38EBcEorYSoV2ms1FQxxLjgr9zGoWv +CYmzG4cMuooEvqYuicsA+yMkGyL/94Bz/83Le2M1YDOM/PA+baqRspTBctVW6+SNqjOGWypBWdna +3B04Ls2BBHx7EvzGDTUaR95hGkv5Q3TbOvAIeLo43/md3/kdjnI8bBZk+8tvW2TrvLS/bEdGOqWM +MyG40rTM5bTvm9/85pOe9KR7d2sWHyRPzpPOXP/eVbJkpfhhODLDXGOq3nNLY66ybe9Uf18P54Q7 +9kyVexrEs5Vas1aujDbn7BUZ2zvHyBZCIZ2nnDS0Zc/O0XF+/wJvoONcvTxFaUrv6NBQNkTQJcGe +AnGiSxKKZi+7QeDK6cxt/hDAlRoSEMR2lASHWYIKUIW8ZQVEBVzN+wIE1facqCTAMYtbU+YoAOs0 +nFDTN9FQpsaFCAGEEjOmRv/SVpmkEraxlYwX6OoMF/zqdz1OpEFbZWD0hIMmOPcYBBO1gWcq1Lpq +E7cgKFpJjdznH2YcMIkj8ivWsTGXAG3bxMTzrdNGndCXQVRB2Xj161hDN7E7Aoc+ArCTCBeaZg1C +m1SDNIWfehDiqjNMiEOc8OVsk09/+tNPfvKTeWOXAb4WB1Uden8eIDU49YxAKMuK+Mv9m7/5m444 +SvnSOgjXXXcdN37FoYfOR8tnLlmdcH/NOYOTxBhMOHZi69at69atc4ar5Ytbxn255DVXPPWpT3XK +9/04CD0N7gCOrJAn2an6rXftvoFnIgQOOJEF7hqbcKtc55bDejbsVcdGA0jg2eR4MMKdY+M33L4T +eJDNOiWNSWtYHvGp2x/u6eUng51TXiUoKbUpC950MkymleFjj6VuPvgzAaSCQAsWAdGMsooE3Uzk +MtsBaU5x2lm4FbAHDtN2F7+JqgJlVYitpmzoKXwJ/wzJ31DkSb+dTzmhY5gKpyI+o6GkSVUWjjKA +kgE/DhxFQ9PP7qaY5gp66K6j2iQ31qUwWZqnramRJfrIOGqG6hgyjrZ1hXhNykKnYm3Zul+7I7BY +I2CVduaZZ1q9URC0repArDMJzP5AVHMgk/hEhJTFI8199G/8xm8A0a985Sv7U14sVieXvp5du3YV +giIRKpiF92h82gZh3bp1RMHWGTpM8AtT165dm13Pc7e7ceNG6Y7ghJSvfvWroSaxkxRHBQDRl7/8 +5Q4ivN/Pe2B/uvSjfd+26LH2U43O/qDemBioDfRVqtBwZhYCBlqEm4XZ5t44kIaQtsnIiO6UtNAw +IKyedtBS4WK35HjRELD2DoREV8AXwW1gE1zEMpOO0x5QQQpYwj+hlHNGXVK5eJbWqpl9LC8NUBYB +1YfgeWnYfSiYhb2Zm8K/SFQpMx8VJuVrCGmlgEYf0an0l6TEIfhNiIgcqxlASokgW2ooRff1VhNC +LAJcB8yRHKXkFGE5HE4YUn+iVLqpSF/agG6S5EDTjiFfausRL/P0MXmJmi95AIS2bN2v3RFYxBFw +vM+GDRu+9rWvfeYzn2kVn0jhId3Z7wvbsgrEpZwjiYmCGbRsYZ7DOoWFUeFEPkeKY72L+1o4CPyA +rlu3zvnn8vjk9YlbXa+/r95rcZXQPZ988slQ+cQTT7zllltcMhED3U2bNsnZ5nfX1SUOSy65u8/u +D3zmQEBPNP+Tm65qAMl6eXRyZnaqOT3bsNcTZFarDeQsvE+A1azXTDJYusne3vIkD3nJYHVuttyY +bTIv2vT90au/sXtstImMYpD+GOgOMCYqlzMCBSgmsgg1CY3Fp2ZiY4yvAA9osfUNXSl5L71szTaY ++p23TE6OzyF/AhSMviQAE4//9We2dO13dl/8Zz+76QdjkQIdZWPfm8ASwxYR1C9EqWTQq+dhDxVQ +GAgJcXNQgz+5Az5TbcTCubCqcj9VTkOspJuKzDIoleTAEVvC4JXwpnl5OoaOOPqgBz3Ikt/RLkU3 +LVGf//zn+yo/HuDByJeAq5QiWzfSHYFDGQG08gUveIEp/tJLL831WNJhqM5LTivzDnUXjx8f9+hp +hxyHcxK32AVw5lNCs8FR2z0tHARC4IyjJMPF0WlFKSPszSXvdXQa5pq10c6WIC13ZPonP/nJwpCw +KLLEkTxrLlqj5rJvfetb7tk5GyTaBOXWZQXTb23GUo5hSE6xoEDMDQprkf05KG8te+A4CcB73vOe +V7zxzCc/7QTyW2gQ2zX769PjjXJvuTHTU2YNNNesVMNSF1L0DYdX+n5KNxCYrEShLABmgeU8tc99 +ZPOW26be+Odnrji6AqXIVCFlWOuE+BQqBSSFrjFxR59cHTFEIjuN9GSU62rAVbV0+6bxL/3tlk3X +8wsRd/DYJ636by84IZcNXJvH49Bilktbb5/+/pV7TnvEyMkPC1zchwMsfhPCaVj+kMGmUgG9TIWT +2bCcbB4gRxY1ZASBHSJqRtICdyF3MowgNM7N6Yagw5nXBgYnJJ4HoLi6NKHgox2b8wbmhWrr1fXr +1zMLpD5pO3RJHse20GN50rL6hOyoqzdtHbpu/BBHgPDWAZnsa3I90NHhsib3F73oRQeeyjyK+9vc +dYhduh+LO44pi2f1QQQKtEqJFnasGATOdR3LSpcMfdetW9eW05wAU1j/th08TJXj3QeuTg5+xjOe +0VZqKb+mWXmRGiQct7EPnd+4caNHhHGzRdn/+T//R/r+WrBRgcL5Ax/4AFnH+973PuriYjmzvyIL +05mHgeEsJIEfJtPP/vPbH/4LvQNksj2z1XJvPaFEgE5P0+mi8lQrTR5uwdXgMG+6wTLRt8m95Yk9 +jbe//Afve8NP+0O0G1Tyea9d95p3PXRwubNUQ5lanwwLo+k6ogPuiIhLDvfO4Aru8EilQieaTHvE +0TvS1Pirlj753ltvvn78t99yyts+eeYr33bqI39phfwBbGnDSTBOpRKeBaxCshQgZah4ExKrLUKG +0iS5FQ9JbxLSBq8tla65YtebX/iDy/5pmyK5DhngKD0oGyIBl2X95KA3IQS5CT5l2Je5WgqPiS4l +uI3Y0gaIaOfZAcJCGQ7zole84hW///u/T+/S1lmTGuC0YiV582iJnHPOOW15ul+7I3BPRwCVdJ6o +UiaTO++808nSRQ3nnnuu46zZGbUKe/NVYIBaiTuD2jm1shWljoyIQ7wpL6lF3c4111yzkFlK7zgI +3npQCgvOOuusTOURWYvmTNmthr3j9o7nIc1MF2cj5pXNO07mdP8O4KLZ6xodvNsQiORtVYTXBkKQ +/tznPpewbuGtnnrqqSDQ6DNje+xjH4s3mOle+MIXejTf9KY3XXHFFcaXHsIUmW3APv/5z3tATZfm +2fPOO4/47sILL6SxN0VarTzlKU+R0ynQF37kvc940ZoHrZ7Y/LOJN7/umlPXj5x8+rKvfu527OqJ +/9+Jj3h8HLP8xU/dsenHo3fdPnX08f1n/eLKxz1pDWD82w9sGttTnxqfe+srr3/a809c/3PD//TJ +O7bdOf3Ktz5kZrZnerp5xZe3/9ulO3dvn1mxuvfRG1c96pdX9fWXd9w1/dG33bL2YUOnnDH0zS9s +1coTnnEMmIRkoJFEN+SuoXiNr3tH547r6TnxlMEATlZOzdLunTOX/PWdILZaKz/il1Y++X8d24Pq +ZrBUJsHhDd/b+6VPbdl2x9SKNb1PfvZxZ/78Mle4Bf7OV3b869d27Nw6MzhSfewTV51xzrJ//uTm +qYnG//3itu//6+7Xvfc0eAzCEWjdEMIWN9UJXNNpcfvgE0KzdXIpozJ8dReB8Qloo+SSBOtN09Md +d9zh9+3YIOMCoW1ZKuc73vEOC7jHP/7xHidAa7Z68YtfLN3z4wl5/vOf//GPf9zLdvTRR3saO9bc +TeyOwMGPgIfQPOM5NK0hYb/yK7/SWtZR85/4xCfwpLaD0kyPV199NeJFVvfEJz4xz2mtBQ/3uJWB +yfxDH/oQpQw6Tu698I68kh0HgWiX3VABvYgsumkY0f2NGzc+85nPNJ4XXHAB4LRqsTvcWoT+zkTh +J8hGSQvbWrIUWzAyDznUFq0UrrrqKkpgjwgEJXwjTwNvnpUrr7xy4YbctvY8YQbrIx/5CGMtVT3r +Wc/ypL73ve814kyfwe2zn/1suofXvva1iDxzOHuf/VQqIR9mXQ25MRJrGcvDHTu33PazXWOjqyqV +2ky95647Jsf31jf9ZO+ZP7fiG/+45Z/+5tbHPGnZxN4yu6NfeOKaNcf2X3LxHZd88o6HP2rZyMr+ +X/jVNTf9cGzZUbUnPev449f1M2EFUds3T0OT6anypf+w5et/v/W0/zLy5P953Le/uO2f//rO2bnG +E//H0fSv27dMT47Xb7tpwtXLv7z9y3+z+ZG/uHyuUd5HAYOYlh//1NX/dNHmj//pLSD215593MBw +Dchx7PDxd948umv2GS878bafTFz2z9uOe1DfozYeVeAXG6Xbb574yDtuPum0wef97tqvfHrLxe/9 +2Rs/ePrwsuo3P7/1K5++65gT+37jBSeSRQ8MVUZW1M48Z9m/fm3nQ88a0QogDFaaxcvJBBdMCvAb +LyfC9U2eSHE1uSeMS5zrJrf7+tBp8RP576PglfDumaHYbnRswttlklq4JpP+J3/yJ29729t4WvDs +0ZgWxb1jnhbpHhjveS7L0MOjUuTpRrojcI9GwKTPXtdcR3RZWNaYwXIlJj160xwvEn01y2EFJkZF +jjwQzfdLkUfkYw7vuBS25rDp1pu4cBCw2LVr165cuTLX49NSQ215oKyAyR0RUEMnuGqDDSzIlLQo +cn9FCAoXZzax2CepMEzEaCY1t2ooDQ0oxfRdtQw58E1mDZZKLrvsMspkG4/8Hmy0/uqv/grfh6Mu +GTXLEMGOIkxXhUh93jVo/sVFsOHZRthPM3cd6Rucmt4q3tvf84o/Wj88WPnRNXs23zo5uq1erdWe +8uwTMEIi33UPG7r5+rEbfzj2yMf2nXx6bCbtH6yc8ajl/QPwJ6ikkIWr//eL28Wf9JsngK5Vx/W+ +93d/evkXtz/h6UcTzwrRyptP6R+qqGrLrVM776oPr7BP1X7OJEqtlTb+xpqRFb2fu/C2a/7v7uv/ +3+gzX3rSQx+x7KYf7sV3z3jUslPWDx1zXN9ll2y/7so9Z//Xo7L+Mpqulr7ztR3m/EdtOAp1ftgj +l9124+SPr9n7qA0rv/VPYafwrFecdPyDB6KHhLfN0nEPDju3o0/oP+Pnl0n064JGnzZc+RoVzmOn +OHEIpASu1Lw2whJQE2UHDfUHRGVenFVWtHswAcjxN0TCQ56zEOdMQx4wC9KFOJor90h0dL3raTys +Tzc8mKHr5lniEfAQ0obei0YXKvjvRSUP5CJucH/3aNAy/1mYgZ+jhVvXcubiZtt0OiYEs0Fx9X6M +LJp/XQBmaDxYAkYPNWEn2Mvc1NW7vUnoKA/gtK1ehD+tLBYgPMkbsNatW/f2t7+dBI8O33T5lre8 +xWqltVozr4YmZzdL7KvVpupzU+k0ljXH9Z+ydmTXrplaXyDJ5GRzqNb4+ue2fP/q3du3TPWmRGAD +NDJdAx6qIva00zQDycwUQWd9erLRN9Cz6ug+ite1D7GhpkwIPLanYYuLsOb4vqHlFfXkCslRYVBa +Oe0DJK4e1v/cclD9jxfdcd139vz9hbf9/l+sH90ZIAwX3/nKn4Au9WtFwXBOFNqX+Ny5LfQN/3jR +nbl7/YM9E2P1veTPEw2e9088ZYCKF0bug7w00oGO2bYoeVAK6pkOQyW/9VOEPRGXTgks44yatIEV +iOYFQTSpA3CUFRpP+ksbvGl+8f3ZaHhzlrY73da6I7A4I8Dcsk3Muzj1HhG1MME129t0e5jezaL5 +1zX9WfKzv2LzDUTzfAfVeJmR7uqBBwjccvYhzxOe8AS8U4TkhCKhrRRpiV3MH/3oR9/97ne/7GUv +YySN++Y8YBv4zdb31hu7pdRnZ3fuHYMlQq1S7q/1zjani0n4J9/b87XPbX7Uuat+7wOnXf7FHZ/5 +0O0giog17ydp1OGxKkpju/Ztx2T7OrKyh/4SyE1Nzy6rVDffPkvlSZQ6NNIzHg0G4gaezc/z7thG +F5tkMhaqELKCsRWrqs99zUl/fN71Y6P1bZunjjo6QPiEkwdecv6pIroBvVoHi1x35Wr3OP6rzzrm +cU9eEw0lBjnXaNZ6y9NTDQz7mOODg2oo2HPqQJA5kWDUsWEmO7sPUE77Z7RC3kt+y6+vDoNVNFRZ +NYd0N+oKPqrPufMSljh08XKJB7zb3H09AmZFOyPv61YO0/pJkg5riVE+eXIRBp8Um6zViQdshbBv +agOUgoUVi3DmP/tTBth3xe6DH0VaBApR5kiPfvSjIfG6deu4r8Q+uYyCxDSgukh1+qlPfcpWIdpW +izskNW8kOvvss12lNOU1qt7cMjsXMNzge2HeV1Ol0vOzrXuc2pIxbu+e0h03RZS7oh9/d/zqS8Oc +eNuWaSa4y5ZV1xzXe9cdU7SkN18/9/3LK3wvCDdcU9p2R/nsXwyrvK///eY7b53+6qdCYvyojSvD +OjfhXqCOJP/iv2Sjm7amxG6T2ADa/NLf3nn9d/ewUbr6mzak1smB1xzbe/L64VXH9t7604mv/d2W +u26duPn6vVd/YyfwC0ScD+ecexS0Y4J79aV0v1PXXrGb6BjS/NyG0CV84cN33vSjsTs2Tdx0/Zie +nPTQsMS9/pq9W+9AyFOPeMPnL4mNMTIKZ7kuqiVWmjA37HgpRJO3I9yUHwlomkXBGi2WBfN96f7f +HYHuCHRHoDsC/2EEnF3SSn7+w7V79IUKinUyH4lO2CCSJd1FMelHf+u3fsuelqwZXljh61//eolA +kZyWDVGWe5APX3zxxa973evshBGs4x73uMfRj9KZMSTxCUJYhTHWzUJ2sEql+v73v5+E/YOfeAFi +qk5Eanpmuj4bQAJOHDPKujVYZqn0g++UJveOLF85/L0rdv7k2tGNTz9m8y2Tl/7j1rN+YcXa0wZ/ ++enHXvK3mz/6pzedftaDVq0+OuPZLT+pqOQJzziup9q86ps7r/rGLke+2AD66//rWBWyyhG0iOcF +gUtwnSWoiuOXkWeuxLY2a1jxyIc+YmTD09Y4J1yG33rdus995PZL/2GrP5T31IcPU4VmyAdp/h58 +2tCzX3XSP//15s9+KETfg8MV3PTUM4d//bnHK371N3de+NZNAO8XfnXVKQ8fPnHdwNmPX/H9f93z +jlf89E1/efrwcA1SqkQ35NFDWAtWmQ9DU4mYaN5sE34krAlAfvKqb/dLT8i6o/Pd0B2B7gh0R6A7 +AvsbgfJDnvjCb1/01v1dvkfpAAx24ovUopgi7ERM6bp87o+PHrh+Nl0s4sBzq1iY1FdDhVkXAWYO +rHkppbdOX/iz7d+Zma0AjLn63MR0c2SwtndstlHlh2HurttKN1zbs3s7vsXVAmyrn/iQnrPPbS4b +bm69sz6wnBFdnK29866eH/5bfWqsF0qF3lRolgZGmmc8eva4dWXi3F13zS5fXXU0adjm2EI6EdY6 +4U3XHlMHv8z7/wPoAIyvAykBr+Xm3tH66I76MSf0VWsOaIkAbnOYnWqM7qmvWFmjdt2X5D+LHDQ3 +gbE7ohPV7YGhKk4Z7pnAM8ug6SZz3xWrq3FKuezJPROJ+txso2+oqmk4SoPL15Jg5yi9Lx+HIJPn +fd4bnMAa2B92UuFi1+1P7A0yPVNbv2vi4dv2rl+/6tjzn/eYyNEN3RHojkB3BA6HESC8BEACGgZ9 +qP98CgTI0KRQO8Ip4V2fvW7r7Mj64/rWH9/r817cH/1omkTvRdEFRfQyWxix1DWP626+k2xYuyD7 +3Segm9nXc2tWwNz6tYhD1plZKH5Hs0Ep6mju5vRMEzBwTVSpzMESDhM231aZnGhW+xrNufBTT8BZ +n+H/r857UbW/RkLL5HViDxlvT7mnH64Ejma4o23sKY3vhYh1bPKo4wlGA1wJbGVQKut/Qzo6L9GN +LZsYKhQk3U0HuZQr5ZGR2uCw48AjG6oH1WBmxHkj6u1ZtQYfjKBdzUUkGxAlKinr0DJeDRMkR+OB +8Vq32ZRkWAdCOzsvp1fbwGCPlNShsCqKnJiobS0cUKSNpGDe2XDYZzU5nYhepavahbLT3O0y9F20 +pyNu52ACRcCHP/xh66eOmdlm2zfc0Si3Y/5uYncEuiPQHYH7egRauc8itAUyhTZj5UWo9+6qyJR0 +sn7rUN/MDmgCvhi9AlPQANvqjG+bYzuquBdkdeaoHS+BgvZQOkl0pmdsfK7aV+4bas5NlkZ3VabG +K04exSOhCByBagKKRl0IMhUJQJp30Rdck50OGspSt39ecJpIoSJyKq0f7G8ho4NCnX8KxqTH93kQ +zbwzNRMfQUhdTe2K6AnA3teZlGylEHnmA4GtewGxeKqIIvu85qYarA80F24fErVVT/Sz4SSKKN83 +vM/Pkd5mk93Qkg6UOKEKGF7a4HfkEus5z3nO/lym0bjTpsuzWIZIVqPcXlsC2nLaKvZY2vvutnZY +joCHxzGZ1FImPTfAOoQIre0c78Pyxg6t0/wN0eh13D/KqIX/4SPvHG/zeuuEfGjjd3+UzgiaP2ea +d47P7KwDNLBTr0CBnlogyURIMhsT41zLO7+lHEe4DAaWiFT7I689nv19DJOINJsTE2Uy3zC1hbjy +9MWfeGwdsRnUgAW2pq+Z/GUr2cTh0LjMNdUJljJPDXKZ8gTCIYV5lNJ/CePT94Rw+Up85kzaSiAK ++TINVTlEzDAsrj+B0JA+4b1y+CuVZ+4GNhmbQZ3uQjmaPOmDSX2IXjmZPJkdcWVhHSBdVfKLa1px +FYYFLxa+tE+HickbSA5BNdAxkNLIINu/j1WKkVJwa1UkMj1z7IavthRzgFWkc3fF92T+Sgfxmte8 +hsDDNiq+JEV+93d/1yV6epvliyLdSHcEOo4AKxCOe7jUede73pX96/KiZeN7W2bZOOJpSzxSv5qH +vXf2U+2xFRAAACAASURBVHA8d9FFF3Ee0HanXjpWLG2JR8DXRdv3cr+MhZ8tt5txdPfETZu3T564 +avXM9Myu0bla37RV4p6pObDBr1BjtlytpZ0tSagb56g1y+jp3JwzQMqNuebUhIN4AE+iJbSPicwl +0AyMSWjUjL01mG5cakLKnCfQDjhxgxCOHaJH6CCMhEHBVpOQVg3BEedZpkugMbcQDDVBZr6XSIV8 ++Uv6z01GE5kfu+p7Einz1QA4U/bEgxMZjRaSJ0KC5UDuVBB7jltIm2qiYvte0pFwHPRz1g969Y1T +TJ/Rc8uOmWDYAl/98d9SBctV2nT6b6Fjm2golJUNCeiY4eATHYrAtpweJfvxoIlg733wxe9RTg4L +eWNhK3ePSnUzP2BHgLWjDQVc81C8hS3CgoVd0XPbIotpqkg8UiPWE47b8qgT8FhhfPOb3+x4jvfB +3D6iT/L0hje8IXP9gylyP+aZ3954P3bhkJvOj2l9bnpsZlOVtrBR3gu+qnVu96Yny3HudgAHHWAF +1DFDRS4DORjrVNnaNMkwAxHLYUAkJyoJVuEiC6CMjkFDE9KgsKqDi2SkMAw2B8Jl3pmMiXC4gLX0 +B8+8XJn/aT6kwQFLCUqzm6HAuPiLVnPMZ0I+/xdEMLjmvDw24DBTT1ZUSX/pE0UGiroanccpE37D +XfcokTlScE1wmygc8HbX6nQLEBRYat3daULfuJxyPNyExcR0abh3zYq+h/VVjot6lyr4KcGkhQwV +e8fgEqA99ImJrw+HML/zne/MIOr+1OwkptYbNSmQ0aG51LF2Vblk25Wt4rLxWJlzch7y3//7f1fJ +2rVrEWiJ6LKzhdmr81uW/eaff/75XGYiu7YP7m990NpuN/7AHwHYSYQLTXXVk8MQpLXPngQuTrmJ +lugME0dgidhbz8Wp4zR82v5OvNla5MiI29DvsQeibocDAK7qO95X2yDY3NgqNLIT0gKXOwGrE2Pl +/C6VMJhAc/n+lO4Vy9X+y7/8i3NQyAP4he3Y0JIlwh2T9uEa8nzq02PNA3ypNMoea/PuUQrQALx6 +z9TkHK3nZIPVbu9dlSly2uCIDG3md1IOLecSCGqpIo7vLuFkZUeqlZzmAmD2ARh8aoTKcGgoSJL4 +QG94OwJFoadM5jkhAgWoiYACxUBN4JQ2nGQOGp/7ED0BZxLwpoQEolHvv/8KGUQl5Ay6obh2hag5 +OSoKcbT0/BVVbYR4FpV0tSccD+9T2Q4kt1kyq8onuhk3lQTFwFUEfBJiC8YEEDRm+1dUTzp22WP2 +Ns/ZPDGyK1hpYqaRZSlCxtE8Qy1sL+PowvQDpFgUZ4ST59prr82KVS+qrwv9kLXWk11aepPtwgKB +3mQ+nNVmmkAynKZAmJyPKkJkKVnJnBV30MKmTZusykUgKF8iENSZbhbpEDdPMa2tdOOH4wjwfsq/ +rqUYVZ8t763aelORVZf1VraR9OwRn7hHSyhPtaUVTzIkwNZnkMai8HC8/f312dFehQ0giRHAc/tt +92h82gZh3bp1XhDrDOtRgl8iImdoUq86YYLCJXvagaYcx9pX6Uw6jma5s+dvgF97a1Zwe+gL6/3d +0UGmHwkgahCFiVle4yfrc9wvoIGl8lw5rGZqZStFu1Nm6jMOHO3tbxDt1gYwsADL5Suby1cTxMZB +pMANRAHCal8TsrLN8Rda0v7AHirDkRVzNYZIxLNpzJx6TdKroTyC8AzUhRQ31RNCYELUfCBoopjQ +K/qVGGrx2wRU5y8ZRNWVJLoqib9MQ32ithrqiZ0qofskQEYuoXiw6gBymaEspMy4K+7eHUNKaq1X +Vm9sdNVmKNygqkCmIiF5dvQ3m6NK9Lwx1r9s9syHrXrB6ce/5vg1vzI8sryvvwq3it4uTcRbR5ID +TTuGfOke9YT1h5MScsgUQXEzGs+chTOs/VVofmQ8DG691Zw88/2rV8iHyYLFk1LGB7EAoubNLICy +muZfG+g6v4gLES85uFWEZ5Lu0af7G+fDMZ0SfcOGDdSBzlQgOyluQYqfu81lab7qaXn6059uP71j +EsBMPuqxKHgERFgYFdQ8RxaqSBcOghcElOZzvH1as7JU9aIZEC+puEqsPLiMhcqOQvG6ueTdBLrW +rHK2QfXSj2R1n2+CpW95kVqEoGryOTW7bbY+Q7IKWrhfmJwJgFw90re8v7Zp996eHr7poQwrmubM +jCLl6kBz1XGzy1aUZyZD4wk1KQshDQJX570+qR7LvRCrxyvSP9BYuaZeiwNaosGp6RClgijqydR6 +WOFmpAS6GUSjWxLlUdW8WUwuFekZOKP0fEgWQ/lLXPQvFQeKqoJmUDMnh5AWFmaGmj5htqvBLxNh +DXG0Amk/q9PQprHM8PobI5M5q3qyRDfUw3YEbe7tq59yyoOfsmLkYbVaz0B/tbev1p8kxva8RqtL +GLwS3rT9mXx7c/IL1tYjGNY6l1nzqiTnYUZkGZvj7IwIkcRZ52IJjjAEb21VtX5VLc/4OeXrX/+6 +l9yBTfmr5bAIRyLeZC7N1PwHf/AH6Ca7Esid5VRmBIJftk6tdXbjR8wIEEsAAL/1pZdemo9Os4vd +Q8L5TCtDbb3fvNiSQvK/P6FLa/7DK27fYwGc+ZTQjn7kFw4Cas6XjnUJyTAy2nbXQNQbXZx4mE97 +pV6REz11iJMzoDqaB7fVc999zTsT77v67/OawVoO49N3TQdC9oLS2bkgjsPDlUeffMqVN9xKSgtE +a/32wZT5jy2NY3XNkRXNZavKNSSSILc31I0QA+FzCNp0L10pA9yga9PTc4N95aNWN4bZtQR6laen +m8E+gXfa+hJMLoEiXwdZCYrwBXzKkDhiAGEyfFUqh0hPk/y/o2k2u011tl7KGYjegUKuJ3hk8p4v +JYCTW6Kku9UNX0ODq2bWyvNO56eAaPKx0D8Q9+irwKJZ/uHB2kj1uJ/+oLzzjuHTHvLYFSOnLVtu +H2pPP4cONizvZXDF136muPt6vgT/FXy0Y1vewI44ylkHYVFhi4sOHpj8OXEJVGMSxLMdG1qYaOJD +Q7Ouq7jq7TWNcq2FZ5gLcBTZeH6WUuTJEU9pW0r36xEwAoS3DsjM9rpux6/vBCqTu9Xb/s5ayHdN +jLm/zV2H77BYdLqv4gYtUg8s8ikGwUqUBoQuGfpamrSNgDkBjvJbh7m2XiIo8iIzh/7qV7/6jGc8 +o/XSEsf3rdmXuNVDb24ePWNuyjNUpbpnlpuiUrOvBmpKPb1NtIoWc+f4aI33vUpjcHhuaFmjv59z ++dLKY2ZXrrGZszQ+0WS5A4H2EVnEsTIHcoBi30DIfnv7eDmYXXHMXC2hIO+AgAq2hHoyBdPjPrRD +aqld046RYHuQWAPpL8AoCWwD5BLoRtH/aKOrEkUyaoFMHSF9zZJb4mWMEzoGiMpjD6utKcmOSTpJ +bwDnbFBq+acQ0Klkn5wtoZqOgQvRNCbqLzpCND09vKZ65oP6/9cpK15/+oOfN1cfmJndNTWzZ2hw +aGBwKEBU53BnYclnf1pG4HSA0FGGw3PkJZdckg1uaZ7Ifw58dgRNDGXnG9/4xiuuuCJus1TCL7m0 +zPGOn17jyy+/3BvrqkeO3y4R5IMSiEdoEJsX4IxynfRnBe2qbmSbCJSUUqdjtd3Ew3EEUEkHzuu5 +J+HOO+/MDCnfyLnnnoshWV21CkjyJWCQHwxSCn7ZZDsc7/0Afeau1XOen3lGRsWh3K1FOg6Ctx6U +Up04QzpTeUTWojlTdqtkLyxNSh7S/KIRJnm/ZLNwud/N95KssPUuD7d4BtTwgjc30dNTGVpWcWo3 +HODPaPfeqe/eeAPBJBJGb9o/BGYa2CRQGRq2STTczLIG4kxvaqY0aKGDrk0FfJZ7QlzrCDNHyDDj +HVkRADk12azPljlCYu5LuivDPsFhwkVxGAYvSVDhTxyPnoY28oFEkBkIlhhqG5R6FRM9DXhOGTK7 +JYMNCzDlE5zpbTSXzIWkWy+wlgotKecJHOSmnSo2gzqaLUBdPbqY9uoMLQurXQrgGcS0Xlref8JR +I49c3v/Iof6TapX+Sm/z5x6z6uZbrkXg9uzcUVp3ipNZ+WxisRS2/HN1D/1SPhHWm6YnWkw42rFd +aCe0LUvlZNGDEZLWWswqDsk60tbWOp2CQAy7ceNG+iqvsfxMgVoztMXtSWX4wAW0V5rw6k1vepP8 +bAVZQOC+a9euzd6hYbMOeLcFr7qXH4jmLaoA3maJtmq7Xw/HEfAQOm3ec0h+g4RloW5xI8SMn/jE +J/CktoPSIMTVV1+NeHndKNGPPKMzKwNQalstYQ86Tu5djEkR8a51HATiHHZDBfQisuimYUT3vaTP +fOYzjecFF1wAOK1aqFesRWytMVH4CX7913+9qP9+iSymf92lvIF5+DTPNyxGZmbGN+1831x1U39l ++Ke376hUWKUDgmZ/rYxxgkqI2DsQprlOEj1qpG9ifHqPfZNMVWtNhJQ3+8Gh0tTeYHIjK0uT4/KX +h4ab5J9giWaRRDSOIIWGqQjAA13wKSL8FUCuxB1BHghC4UJLClNdgEiJvIZmdB4WMzgqGwHmoYnz +IKpF+QJEk/WQnOI4qGrVGdw3bRgNYion937peBaSXl+ZC4lwMSFYOvz/7J0HgFxVvf/vzNxpO7O9 +Zjdld0MCxAQEYhBCiQFRIICP8nyi4QVRLIgFEDtIU4oaC4LPwoPwRAWeDcsDaQoP/qFKSwiE9Gyy +fWdnZ+ZO/39+5+zeN8yWhM1mU7iH5ebc0++Ze8/3/Mr5/egOSpQWrD6jLFBtGvWVJYfUls4vLZlu +BoB9yPEclp9KS8uee/rphx+6/6CD5y489rjS0op0MoFPuDd6sms7uOaml6Ymzb4uvybsWVYovaWV +J3lz4OtikULfxxZ/FuYDYEAX+gijiVcLC+s4L88bb7xRV1dnW2weXqYwhRdv+/btAKc9AHbHjLYI ++DkUgfzVlq3SAltpSFgwuLA1J77vzgDvKnAI69LWrBn7Wdggsr1DiM67QZX9D0Ttx+cBeduLvgid +y6TxsfB5Dp8E1HTZZaKga7dDhI+LibLnCgKUqSPoMnyMmiQtrKLjtKZLAttUZ91Qzew2+7qK2hk+ +jH0jhXnkh+GazlrJbCQc8EX6kxngC/3VLKdTsJ1LJoSdsESBQ3JCfl+J3+zsTaJik0lRX8CSdCg5 +sIoyAA/4AmsX3ilmAsE5wImsXFZA1GWKqSOAjWYBP6A0p3i5kHoEWKzAnhRWaMfc8idwqUAUyk5q +KWJW0jWlBzEKIUuWOpZKTPSBUe4FX6VJ6QurIAK06ogqsI00F7az1tqFSKUuelLcEvB6Rm24yug9 +gfS8dX53TX147pSqIyvDs3Ec4PVl8ddmcsRHc4o58ZNzzZ4z5+lnnujo2Nbdg61/fyIJNzLNRsRK +yn5C2p2sADiBkXB44OfIL/fmwA8AMrEhtTHszfkGwipCUeLYt3xdaAONXaYwlzHAZSpMYVEgFKYQ +h7olFCbyVTsgWjgh+3qclxBp6DieoujFGEcLe3kV9e6/6eW3B8yk6Y9l+CRg52j4ObSiL6tIpsPH +yGpgN74HI/skX5cV1g5Dc5cyvZmOXis6kBJAUcQZttp7UJYxITjzZkDAFXwq8bnWbYy7/IYnJ2pH +IChnQkyfGCcSfBL6UozKgzKYN6KmG/QdMlYgIOcTSMT4kT7oQnX+BGpEoihYKPQimKqATShOhXMC +meqEDIBHIFmjEyNSRSSRGCMnhT9yBSCVJhFwSBLkKYAKC5d0vWhjcohBSnlAl3+gTRGCJo3kgLQT +8laY3pkNNfNrKg8NBWp8WOH3Y87JY+IIx+UzPcCn1MFgP9uQivKKltYDXvzn85s3bCgrLU9ZiYSV +jPbn4nHsIXAmkjFOXuBLg102mo6G7GWc4MzAPjgDHHQpYvPugw+xu4aMDAkm8Ng6Dbur74lod5/E +0cIHhx4lsNbDvY2hViTrLOAglOVvfr6uY2vq3Itnco7zxSd7X3iyZ+H7a4+YXwGyUgZ8AgupCiTL +wUpAi3bdeXCGttD83bbJ6um0mmcHSyv8Amy4TMkjLhULgtTSyrdQflCrMFcRoArO0YQ6ygm9KNJN +DUAKRDWmejQNKh0JssqfPr6iHkkQUYOoOt8pJpMA0ZwAJw1jPolhwKoVjE8IwU0vgrIQskr/Ngbe +W56Qv66+8rDpDceEAzP93iAEqIvzryZsDY9gKVsHNhAME3o3n3VnPbkMJ4TSM2fOev7ZZzZuXF9V +Ww2zF785vf0mUvy00KPFxFbh/O+muIOXu2linWb31AzAYHxLnI89Nc490i8qRXCh9kjXE9LpRPpN +Y0B9ff0PPvpkIudNpbM+r8efT510wlEVFSMc0Vu0aBE2ZTgdP+7TdeCfPQW5nAuHaFglwrUcAJNX +OPTKM5HtWxLZXCs2Gdo2WC8/1XfQ4eV9USHE1DItklGXJx8IKzCTVPUfmJQUsm/Vc32P/K797E9O +PewYv8oUBSXhlwr0KryEu6u0iiiMkhHsXIhROL38DQaFmlvWJX701deHkt707wln1b/3rHrVuKRr +EEWIS6A1QJSRoNYkcWUJC6MQdA0LGmIU/WEUkxlPf9TAwn5ZqMrva6qpOXRqzdHBQJ1AO3b2vTnT +g50FeMUmLmywd0jLWE6UvgTvPdl8Bl/n6VQS9ginmRHdV9XUlIbKIj39PSlvX6o/6eX05B7AUZkC +Jzgz4MyAMwP7wgwIaTZRAaNQ37z+rhlHLjnlhLklAfdAIveHv77wjevuvPqrH95JJY6dHAnn89CQ +xm4I6mGgKfQoQr4SXyCRcSXgdkK6gQ/IPlVz0JxGTohDCXBxc1CcwvhF8odzNCSa3EFHwoz99Y82 +AL2fu+ag0mo/ekNHvbfmnUdXVNV5IRMF4uCzIqGkMdSCYKiSoswVCaE5pF4kfcPiRd9H6QHBK6ZY +baP/8zfM0sXu+M7GnvbUsi82l1ZR2QiXm6QDwzqIE7sh6Skp9MIwCDwIysY8D7QvCCoSUwyNga8u +I4GN3Jgv7Jt9yIyzUMEN+Mo5QsoAcF+rmLgCn4ybkeP9FAvD0lpOJMhZgc9MJp1MohETi8UTA6FQ +2aZNGzet21RZVd3dt74d5abyGd7A7tWL+cIXvoDVPc6N4CBCHtUJzgw4M+DMwL42AxOGo4DZvf/9 +wL2V/3pOecXf1vZXh8zuWKa9btpvqz94yL33X3DBv46mG8KMnXfeeehMcqgAZTYMk2J/8tprr9Uz +yfLKSSx0ONH+uuCCCzjeTjHOD3DwAC+VJ5988uWXX4614v/65YpVq1/w+vIHzK34l/Ob/UFPfshj +D5zPACYUFI2IBi/ywdXP9j3xt862DXE0bg48NHzaeU2Qav/v/s5Vz0YwhHTbd96YM7/81KWNL63s +e/KBrvf/W8PseRVoD21YM/A/v96+bWOCxmcfEj7pQ1PKK7BObNx+4/ru7alzPz/9Tyva2rdYhxxV +edq/N8rgAUWwFtGm1103DdvrkgCokVPXFKio8wkuZnM//OrrmXTuomsP4LgUePnIHztXP9v/8W+0 +PvGX7ice6H7P6XVrV0XX/DNaXuk97dymqTNDNLn2xeiDv9ve3WGVlvvefczsww89BkXcoGdGWVmF +KRYnvCZ2swVGMVaV1zQoIKpsKmkEzXCgBQy1ElYqGY9HY/2xAbwrBAM4Wklu2b6qL5HNeHtK6mf6 +aoyI0p/Sv8WEXzl2/cMf/hAFnG9/+9sT3rjToDMDzgw4MzA5M2AiDpyQnlB0/sMDm7JHht/ozG2N +usqCrv6Ey7JyWW/4Dw9sPO+8NOKB0TribDI4imWZxYsXb968GYumWPTmuB5GtnAGicUK7D5z2EDr +bmG48q677sLAP6f3OHIEPYqtuAUL3nXmssrHHn35j3dtaZgWeN+ZjaLro55MhKd5rMRJ5+L8xY2q +dHbWvNLFH5iy9pXIQ7/dXtsUeP+ZdQfMLa2u92/fbB17al3TDGz/uBID2a5tSa4AXtumxE+veaO0 +wrvk36d2bEk89ufO9q3WJ795APzh3s5U1/bkL7+/8aDDSvu60k/e33XoURXTZpXQIbQmQ4D1KvSf +4gDbMyDjEQO57vom/3OP9b3wZOTIxVXJeO7R33csPKU2Y7mikWz39uRff73t4MNKp7WWvPZi9A93 +bv3o5bO3rY//8sfrpzSVHrP4oBee2vrAfasOPfCsvMFJlYFwaAp4qXXEPTRN34qFS6falQ3EsVg6 +ymbQJk/yv2X190Wi8UikL9rfE4vHeg1/j+WJYylvxgFGJmT0oq6M/HXXwiurtt18yyPr1w1aOSlo +LL/yyeVsvz7+8Yv3adFIwRM5UWcGnBl4O87AhOkZcQ5vY4/ZUFM5rc7tDwg5VJbOJq305mRuY69J +7hg4qicenzi4aUSVnAgEKDiKyQ+OByG0I5xyyinaKiPH2/X5AfS7sFmMohfW4EDxV7u+/67kdnD0 +tRcj539s9vpUbJCxiwJRCsmpcHnR2UX59pAjq8T+H5qqrhw4+voL0dP/dUp5TSAYltmYdUhpZa0f +wlSKKzki8Pvk37rA4wUnVM9dUOE5quLV5/s3r01seC3WclBYoNIwzji/6cBDS0Ol7Q/c3b7x9djU +1pKssnoPWHKshXZFeqpOfFJYH3SBZ0sHRxxfBY4+83DPEcdVPfd4bzqVn39cNel6E3DEsVXHvq8B +GL7lqlc72qxsf+1rz3ZS7eh3v68kUL6t9one3tWvrnmpbsqiWGJAQNRj4qwcdVwZ01BAPQo7FdCm +2FeAFLUS8Th8XCseHejvR6DdF+/p7uroWRWxXm9ojdfPMMKVwpdOQNCrUzpDzYznX6b9oiv+dMYZ +85ddOruo/n33rLj/rxvqG1tf2tpKsZ1RLIIPwYk921huUYPOrTMDzgzs5TOwceNGVu/h2vis8Kz8 +Radc9vJnKRzehOEohMWUypS/LNxamaspd5f5jVTa1Rv1bO3LJqqS5Bb2OmIc4CRdnxDSsNfS0oLR +GZh+mIPB7to111xT6EVBl6EKBo5xTffiS897RR9IiE7OmGBrXvcCCSox0VFFEsmJUterL/atfLBj +09oYhytJRLk3GsvKYZWhgI/SFI7XpDEJ1OrpEDYx6IipesC4qSXY2ZbsbU+1Hqhh1JjajAVIlISl +QSCQ+CCU8Y+y2MC9kKc6lVwpKDg6c16oss678bV411br8b90vWsRGK9Eugp0S8K+eAI5bKCxsTbS +szWYWWzF/kDFP913H8DDHgKmKOf9obKjkf60lTJDKI6xQRCOLjSwOtwiR1yw388fwlA8nFM+Gu+X +a28s0t+1veO13v61nrLuxoONavxvKssS2aQQ0Dv80cBleYyRgiaLGeHr29PPZapnRoc2EapwLBq5 ++foreIS5S2989fF2iunyuiW8YWija9hVgJ+vrRddcsklmP3DRYaDoyPNt5PmzMDeMgOYj8fTkSZ7 +sDh9xx13MDJOhJ9++ul8y3AfEeTh10EPF4MJSOtA1nXr1sGGZJEvegwUUeFQaotRy5YtY8VDtEcZ +0qGyWDo4dQrbcrh1+6J2dust5MvEtI/484QF4Se2vHrEse8oU6c+UF7NVBi//9vLJ7xLTDeNr5uP +fvSjiEuBSTzfol6ENwDmUTcFDQqUwpxEV4Wf5/ZfX9WR/t1nz34aBIn0Y459EAZR39XWaKVWHqsL +ubtvXV8S9nzxu+8AQa//7EsUjKsjJbqGHKhUZKhoEgErymhRWYWYt+9oSxx0RBgdWkCUrLJqFGYH +u5EqytK9VBGbR6ITRCJ6vCAomCSmCod8/Qp/VVldgNBEfrngPVX3/6b97p9s7m5PLnhPizUgKkXY +WyC4sqEZlcc1VC64s+sr3E5pbGqYUmc8b3z4w8uOPnbhq6+sWr9+3dSp0zDiZyVTfZG+YLgkjRVd +sBQUzGIMWM7oKIXcVNyKJ+IcDI1FowOAbn9/rKtnQ0fvK3nvtpqDjMoaGR4DRjEYNSVO1LiUn3B7 +MyGjeXNgb8QWB/tBb06WO8z9fPGLXyQCWnuDAbpd/rUvJ+IDi04794jjTiZ9xQ+vifR2nXT2BSXN +h5vPPkwxTtdJTRVsF8cY24R7z++u0xGfD5Zw/nFmwJmBvXgGsOGH8krhAIE6jGDfeOONcBnx9Q1F +hHYhBa666iq+8Q9+8IOsJBhRwVnvaC6YMAoI1qINYzeL91+sm11xxRUQWuywx40ydoPjjowT3ob3 +Bz3xgdNPnLbpF2uef7XWb0wvNRrCxv0PPd+4/j8+cPp7C6mN4XVHS2Gr8utf/5olHxPhrLOstuw+ +wE5NueL6lT2ORlPAtWeb+Yc7ttFUXzeIgvHZoVblcIiNd/BXJQ56cbT00T9up1B/L5qr4pK7aYaY +1HvpyV7EnEKeUlARl/gOO+y4KuJPP9yz+fX4C0/2btuUqKrzTW8NgZ2DQMq/qrzUUbU4bwpYAocC +lmxWNAGqysA1FZ+glrIX4TYOXVhJlS1vJObNr/R7fXQdcIWCpijKrn0xn4nO+/vDz2/bvhW8nDd3 +3r+ceQ5k3H33/e7Zp5+GMm5v3/7amlctsYdudXS2J61kJmklklZKZKDxWH800tvX29vT3dPZ1dmx +vX1b25aObZs61m14ac26/+mI/aOyeVvrEUZji3gh5UHEuiFavThZwy4SwM+wR99m8dbyEsvTDgvs +K3UaP5YngAEI/8x5C1Y+fN+tV1/c09O9dvWLD9x7W2VtwzkXXYnalxkM2KyFYS2NkPCjH/2IrSj7 +U3hEOhvhOp8obwibX14SEvG/MW/ePPCYV6WlpQXVbqzYc3qPW2x76lq8Wpz7xvvS8uXLdQrMJUYO +36m5uZmtrk50rs4MODOwizPA18TntnTpUtqB5oE0wgW6bhNowCEaCzsYiUXP0UAUHxK33HILjnSK +HMggLuQrps09CKI8iLtw9d+VyQLJsJd24dKTe569/Yc3XH3Z5778neuuSb9y5+c/diZ2wG0i8i11 +7QKf2gAAIABJREFUAUxed911cPmg3JlizB9ra1KYBYFSufnmm3HZQcqFF16I/53PfPrLAW9l60Hh +bZvj998LQA4iAIdixPLfEFsxEHYff+qUaH/m59evAShmzAqhZPvI77dzTPOwY6ubWkoe+m37XT/a +AE2pYVERjq6WA0NnfmzaQCRz89fW3n3LZhi8536uGbYwpJvuBxaopjL1A1KXFoAiDZ90DhWLsaHB +XPjOHjGEizGHRNTweXzNs8S61VHvqc9YoUrzna2159WWHUFKVVXtlVdceuuty6dMabzm2ptMn+fw +w+ffcONyXppbb/nRd79zwzPPPNXe0d7X35+Ixdu3b+vt7Yb4i4CcXd09vT29/T09vZ3gK2F7R3vb +5nYQ9PUt97cNPO5v2DLziFTjLKE+sepAYMBAuNhpUuS4RIjpWZD8EQJ6XsNVhDDsV2iXxAz6Obia +OeicxnnH9/d23XjlZd+/6hLkte8899rHN7nBUQjWEZoeJYndKEY4sU/Nh3f77bfrUrwGGKnnO0Tj +jC+NRNS58TsBj4gyQCPsIFhD7JHZCPM1UgA5K7XQBsddKMXYI5PI9pZ3Fe7xQw89tENxvu7auToz +4MzA8BmAbcuyrH39kssOFYKHHa0uyT6Vr1XHoVBxo7Ro0SK+RwB1eFOkYGkALVS+30KD1aSjbQqf +kk8btf8RK05aojJYMBG9sbIj2oRQWPrhs9l9MGtsHDjdz04BqBu+WXj00UftbgvjzD5BZzG5+KVi +jUMOV3gCld+DlRSU1XJpiHq8AWD+OGVs2By/rbMzUVERsqzspTfMQ0TIWVK3K/+eJU3HL2nEyBHG +io45peHIk2qF++oThdpYXyoQFv42Bz0/8dXZCSuN/023O/+e0xtOOLOBdLFE7zIOP6byXYsrB/rS +Pj8I4xbvLvKvcel3DuRojfxlUUSqffd7a0EmdicgJadlAFfoThjIWiD66WsO5CgrpCoIlYwJuOJn +O2XlopHMAQfVHDD1/XXl88pKp3kATPMpJuGYY4679tpvR/uj9Q31bnyo0kout2jRCSe+9/0Ql9u2 +bunoaH/+ued6urpCGDpyudvb2yoraqBEOVGDOBRj0AnLSkSTMHM7etdF4q/Fcx1VDampUw1vEEGy +jI0RsgmQ0WKwSZmYYLQQz4xwZ5jxbC15lW1BKb+17QRU/4jekgA87XDQPOmiH/zq0uPXPSHnRFsX +nDJn4RIiIsstGVWRW7dQeGU7xU6Wn2fx4sXadwqvB98hX6P2Zci7pE1dQ7XfeeeduIaAckVCwylV +3k9qsRujQc4fg/d6W4boHa8ssKFoFhJ2w4YNhfuAwt6duDMDzgzscAbYqiKAY8vLJ4a/3qOPPlpL +f7TuC9X57mx5EBALDQpSYF8X3AVih7d/9913gybD3czRBec7WBNshB5ed3JSJuz8KMOFQkdczEYe +EIVcQM5MCs8/HETf0rOBxCOWB1nphRUcrqCGaneqtcTdUl65CvT0eCBD0V8VTy9SXdl/hysMfGKE +gbGJLUCe3p0Pl/vAD06GwNWEB+svET1a2LoCupSFlqU6AAOiwpSo8kLaQllShWJoNJEKugnkUAaZ +ougEC5tUIE/Z2pXuVaIuLxCV9CTiWVyyCKZmy174R6S7I/mJC7/cXH+M14fSLQ60VeuUxKepz1dT +WyM6t+k0OEqTEHHZZBaEgB89MNAfDpWgdxvpLwO8easoib+WdCaZiKOZm+iP9vVFNnVGXjUCvTVN +2cY6XmIGIsYcAE5BemhltQ9gZtgciH1ghfryXGoADH+MgJYd4KS9clIMNCr6vWDbej1uXAiEG6ef +eOH1f17+KX9J2cmfvokUysetzFuiR/lm9Otks3e0V0LbHfcBBxygR8tPrL1CUp4PWH/D9qsIxckW +De9LuvC2bSIR+NKXvsQ2GQqb3TSy2PEJI3SDztWZgbftDPANEnCsjcAFoSY4isIEs4GETqtBAKLI +U0hhAWfbDdbCKLrhhhvgKiGRGb6L5Xv83ve+BxsS7q5WX9Jze/HFF5PIHhpva3zC+hvfI9Ou7AJM +XM88JGH3qS9rQVqhOI24DjwEkVLjvVFXh+nps/AVym3IFwrnevrTPhNLRsLdzWLGyAcQ5jEGBEbi +ppt6WNFD81QjoivjwjY9CqtYRBKpocAeRVzANSCmDQyBkagR0VpOqeQAn6ARiVIYcFUqrwKiyvKt +wkLBKtok5LEL4fUk+k2/p6G25B3hkgPWVfxj6dJ3zz/8SLcrjZ1CgJQW5h1y6LkfPq+lpZWNgqz+ +ULsyUlrH/K2COjYu2FvwBcrKK/DTAqOSxjNZrOxjH9GDdDQ2gHW/tX0D68zgQNm0TN1UA1NHKCFh +EQkCkZYYHsAphomJYKo3pTYEpCAlhdRWx15lE7CjAI5iUYHDvrj/hAlfVBy+rs90h4KiZHXkKR9Z +99SfDzjixPqm6bqYJ+qGYC2q8pZuAXKmCGE5LNmdr0gtyFA+4MIq6AZj9APtQb5nWNZIWwtznbgz +A84MvKUZQJMI5KMK3yZkDxi5YMECbuHTYhWACL6+UVcERImzi73nnnvw5gs6clsY2NEiXkW6h9L+ +D37wg8Is4ugh4gyYnfEe9EIqRuOKhrXP3Q4CKchgGH5PfVXqrKTvj+XB6BttiUwOFBOP2lYaKhF4 +QAYoVuxFnxacy7sSpONMrczlNfOICeF2ouKaBWlMF2xioSCVbT9pAsO2ltK/1ROEnXeMCwKlyt49 +fUPbCb4qQSmNq/bFhD19CURlsWVvJhN+01WZTzY3V7WWhWb4zCBIdtbZH1TwC3NVeVCjq6wx9x2H +zp0zF4I6hzIu7rSxKa8IYshNkJKHESfbWXy54ZM8DLQiEvW4zUQ8lUllTV+mK7I2kmjzBGI1M4zK +OsNXojzGUJOnZvzApCJJBUcheSHN8fXN46Csq0CUMQtJLsi949eBtxwZJMroAI9N8NnVZtemmmsr +mpoG/Shd/N0VoTJUcwffOjjc6fpdsvWA32AQkc0sx45hS2CYSe957QGMGEFzjR0uZDTq8swozGFA +FAoVXSQ+fhpkIzJiRSfRmQFnBnZmBviCcCSslXJZIlAyQlkBHEX/AKU/vYUFQZG/cHARywFQq2vX +rkUyOGLjaP+xVz7qqKPQH7SZT5QEhlE85BMe7nNtxHZ2UyLHDXdTy5PUrMBKQeC2xGzMRT+QCz5R +V7mmdyCazXiANFympFLChT3soJrNHbHtnXGhybJ56HEricou3F1pBbu1/oArietvr3hSoyL4J9Bl +4W1MkBIaVHBMnWyBWqVviFqgScMSFCkplOEe6AWMsPWX6DfiPf5Mwu/OVbdMe1dFWavPU4EA1G0O +6gSDheJkRih5MYNLE5gHZjCC8MgPPaKjnNGuZBiOcjcDMclplmw2nctlwFTM0PcnOj3RJDajeq1Y +3hP3lqTqWo2aKUagVLjQUM8yGkP4z7KhUD7aIJGRj2rghDblecFU+mT8EOs8EeA6hHdSd4wA8Jx/ +/vmYxSgqA493lnt1pdlYC56rUFuDNFTpNanbZMemVmNVaemxRRV3/pZPlG0sHFr2vKghYKaDr3SH +1VHcBfhhCvF9opTEfhbl+5tuuontMDyo5uZmsnbYiFPAmQFnBobPAEqgfFacEwX2rr76al3g2muv +PfXUU4FVDoV/85vf1PQoG1/Ozi1btowTL+i78A1yxnR4gzoFFhEHIDl7iuQFIzwkgs1YhwVB0TPS +jOLR6u7udNfM9370f+/81u7uZqLaB9EI7EFgrOuAdhHiWK6shkS4wuVTAtpMPLU+nn89YWxOZSNe +bxqFoYFEvrKspHVK5eo3enoH0r5gHp5iMpaH0My4XJhxSFviMQasgc8pMk5wK50P+I1k3LAgTz0C +roCNUG/KtYvQtcASNKgCVJEsIhxVtu/dWb87UxHrC0V7fX1drq7t8XC4ZuHCY+qb8KCSR4VVsFPo +XGzfC2oi9cTtKRFwDuozS1v6huYF24TOFQo0m+ZcqFjITfOkRiqZbd+2fdP25/qsTewVQHqAs7bJ +qGkUGlTRnkI0g6N4V2WUmgXNU/AIJEKAMlqPX3zL4ECGdKhwKGxCwj0nYs3ris05uKrhyvOKubVS +YicCvxSmqdiWihLYSAExJ4dn0EcYTsiOVHysNBjLymvNIOE7VtGhPN4l7E0CnHbvbKIZKrTpUBHn +X2cGnBl4azOAxh+fFawd9rhFNTnlyWZ3uD0j9BLYvNqfYVGtcdxyZpJDIgT0dRgG6wxXAsQKvUAE +06aNIzfd+2JHunTOFP+cRh/XcXRn0uY4qu0LVVx+zwxPpimcz1rZ7kyuJ2NEyt29ViT2ShTq0u91 +JWEqxvEP4zFKQvBs85gggJ4DtPJZF7QaZKiwNw0FmSGEiyjwiBgVg3+lftx2ZuMDBn65Nd3GLPIX +xF14NlTtn2ZkG6xY2IoEPJbhy8aC3t5gyfZMNpqwIh53LRStgLXhyYDS1IdrS6eAJ6aPuFVUKJbk +6RpyVChO7CoIGQp9jAIRlbKYoABQ0SLqj26NxN7IBbrLSsQ1aVW9UdMkjwNsaVpTHgBaE4UmaVjo +SxCUp5ABK3ITuJbjOfRLGaW1ixdXSsqQpPIuBV5ZMJL9I5tNnqKoLd5mPirAb0K+H0SeRe3v8JYB +cFirsBii/d0n3S/syIk7M7C/zgDEKGHEp2tpaRkxHf3BEdP3lUTOe7CC7nvhrQzb7fNU+4yh39Ut +gGVltphlf08Z3Zm0C9WbGAJRWJ3weFOihSTKRJB6sD3T4uIbZHULhSi4ghKvaXrTKbfXE6guxdSC +N5PGoUuZ31PrcZX7PFWmv86dC+N0JVyVjbg63bGY2/TnXcGEFe6LdKNYixAVE/KCnBCiIKg0ryhF +LBlKotChkNxCVEN1MgKIUDoXKalIRHPJvJXGzHxPJL5pwNqCefqc2/AHjYp6sern5xhqTkAU0AUv +dZBW1Y8Mw5Zfmz2i9M0jK9ktuWSKZFeBOFU4lgPoisKSIokHWxnvP2Ak3N3hO1Dd3lv5Hcc7Aqee +MwPODDgzsDtnYJ+Xj9oLsR3Z0XQJNzWXLk1ZtbNnnZzJ9sWtrngaw7PJkiDYmc7kUyjnAi2gCFy+ +dCKbsjxVdbU+sxSpqdsdCnhDLhcOYUqNXKlEAm7T5XV7AlhuAG1dHmhUkZcGPTAYK+C/AkqptBUs +CUajZldXJ94+w6WlIGUeJi1omaMvsYaRyaVzSDwFWhUBCoiSnUICygEeADUP3zqV7o/GN/Ungc8Y +vr29iotbWj2IoKL3BBYq6pNONXryIFCZkJuwkAW0h6wVMi7KAKtSXhudIO4Su4C6CnrFtCAYPBFh +p3+diejMacOZAWcGnBmYxBkARydopZzEQRd1xRqtA+lE7KuOjPiAr29+pn+g84Aph86aOTeJFb1k +LJ0fyGc8mXwcH5w454QG5PhJd3L7xu4t/b3x5qojGuob4skE2CJUHR3BFAYAFb8UchXbgeBzDofh +6AtJHhDECdoKjMoyvwFQNBAPBP19fd0dXe3BUFDRl5k0yrWQmdChwrfNgqO4BUX4qxAW0/lkuODj +Jqy+eLIjne1IpDvj6QT4V1MnuFhSgSdwOc2ixKyKoAQU0fkFF9WvKqQuNCWDVHq5uPHWWIv0F3CV +p6AAhRWPF8P+cmgHNq+yaIhAlrj6n3+c4MyAMwPODDgzMPIMTPD50ZE7mehUDZa61UEIHYJPG1DH +6DMy0NHV91o8kX76xXumTJnq8WGdwTJzZtbMmxkfjF0TrViFINXVwUh/0opv7e5pmza9ocTlRTRJ +ywiVPfQkAsahIGxhuL/YeQB9YItC/Lk4J1pWWpFKdvm8CLr9QX+oM9rR1ra1rq6BApkUh3FQxOWk +CqpDSvqJihSoyh+UJX620wMJqzORbI+luvJyiDXr9hnBcqO80qiqMbwcZVEKTYAl6r2MBfwDNWHn +Cnoqo748BUpGWjIqesU8FPDJAMFIRYnmgVj1R49ALwpPNMJTUVY0kkSOK7X2noBPAiwTLVy4EJN+ +e8+onJE4M+DMwNt5BvYxHAW8bPrShkwi/IT61r4Wpdi1SN/W81Jra3jDxtjajS89/fxfj373qT6v +HPSA/MuZOFxLQ1Uqgs4F9k2d2mQlYnjqTMObxUNpRjTQ4OTCKxUNWgFcCUAOo+DUKe1wJ8MRstVV +Xl6Jh08DISmqYz4M+3i2bd46tWlqKFyaxB4gXF0JKbi5kIOZJJgKlqGC3BNPtUXiHalUwvBA1xol +YcMXNsIVRmm5EQirHlE7QsYJZSl8ZKGShcTkT51BpRUhUkURWBJ5IHSLkARTGCsTEtTA9VjBcMZP +L7QAAEsxGinYJKgKe/6CtQcU3JlIdOX3/GicETgz4MyAMwNqBibSLuAkT2khZKLMQiDFvhIBO0lh +VFxtHE2m4sHSrqTlhYbzmqnHVv6uoX7azJZDk6mYNIEfbABShJpYBRKysqamFmtBmzdu6u7qnXlA +jVthnpTEUC/sWDcCTVCTP+GeKkJUndAkz+NC09b0mkBmJNIL9xRDRT6/PxLt2bRx4/TpM1IiGxXU +TgGjnH3JJuLp9ri1HW/d2Vw8a6DyxGFWHLIa4SpBUOzaQzsSkHFKBJRWAk7dN7go6K0KUEYrnDM0 +URoiEZhXhUX5SBnUlWOjymoEzwqkCh7D+1W2DCXC4wwxh6XLSQyvrNp28y2PrF/XPazP/Monl7Ph ++PjHLx5uHH9YYSfBmQFnBpwZmKQZ2CfloxpB9QzpuOCaAlFBuKE4a65dkoiG0niqe936DszbZjIu +uKmJZOwf/3t3OFhfXlEOMkJSYq8A4hFxJS1yzsTr905pmMKJqLbtbc0zWz0mxm0FkRThKf+AtjBE +1WCEulMHPQXUAFFkn9B5JcESABaaDyrW9Hqw97thw/pQSZk/UMLpTysZjSW2p7JdiWQvisPgKZxV +znSCmuVlRrBCDrFAQcp2QBqVCIgokEmKOPyWiJCkCsQFRxVMSjElEwUUCdgCZMBCcaJtpBGXWtr6 +Em3RrBi7FZoVpWXKcJxU9IalFUmftMBvdNEVfzrjjPnLLp1d1Ol996y4/68b6htbX9raSjH5Ad4c +OPeJifmWlhYI1jfnjP8Oi9uc2znyyCPfahPjrvhWO3LKv31mAKtbmDUgYL5gL39qjBPhraTINgJU +A8YZRjzigrV6zq3tu0fOgIS9/BcpHp5eQAXBVCgETo2gw9NJsYuZ/nhltRg5AD68fqOizNiw9Y2/ +Pvwz/IqlUy4Rf4qujYvTuhCaRCFbq2o45dgQj0U72rfBngWRQGo9LHSLxHqCuP8aSkITV5ijYtYe +UMUuBCjr9flTHGGBYYoxfNPVP9C2ccvLHd1r2nue2dTx987o8wnXhpQr4vZnyqtxO2NMnW3MONCo +azbKqpRzGHCOP0Sw/NG/4t9CM2oo4UFARLoX4AT4QFlMTijbC1Cl6PTKWBkTjF+KqR+cduwT0lSn +GunC3VUWd2VfwDFZeqTN4unfvfcoJr++Pf1cpro9mi38W9fWc/P1V/A7zl1649oOOQZUNA7MymOr +Gk9BdXV1O2PPqKj6aLdY9bR9P41WZsT0cVccsTUncS+cAU5z3X///fbAsJCFm1v7dndEcAuIbyWW +lN3R+ES1yUlxpgJ/FRipxtrf66+/rlv+xCc+gZ0jnKPNnTsXR0x2dxhMeM973oONXDasfMV2uh3B +UqA9scuWLcO7l84inXUZXxTve9/7bD8Zdq1Jjpiisbknwvr16zHPr/0AjK9/VlUqFqIm5ipYYfkh +MT2F5UaoFsxksHdjpwNtqslTIK+0yqhOGz2d+YxlJDFz5M2v2/Ky9cj333XoGRXl9aWhinBZWCGj +AAkaRR7T3TCloburff0b6+rqpoCagktDgQJ5dRwUK4PSh6Cn5ArLVs6tyIkamklZmRQS0VRn3t/p +K0n1JF4dAAuU1k8wrBC9FmcyYktB2KrwV4W2FbDXyCcl5WGlVy6SriBT7tVYJFcXEPAXNBVhJ7nq +2KuArkJiqalaln8IJOpa6k4wGBBV/ZIO3E5ywAs37l9wobr8a19G1XnRaececdzJjGHFD6+J9Had +dPYFJc2Hm88+TLFCI7q4Gr311ltx641JB5E2K9tJ2LPGbqd2RzrJT+F058zA23YGsAXG9gKEYwY+ +/elP40Aas7rEwcipU6cSeeSRRzC6iS1u7Z7lqquuwhzgBz/4QZzANDU1XXbZZaO58sZ1DOv5gw8+ +SCM64DAYa2hXXHEF4AqgQCwN5Uz2v3j7mMiAbTacQbJ94Gm5EidlxA7QGeHJR8waI5ElEhYrBWz4 +JKJNPdlXja/cEnRJIkyxvkKsAVTlNfnmA43qRqOyJlBRHiwpNbqjbQ+t/MVLLz++bsPL2SymCtwY +QIAY5RQKhGRFRTkbn96ens2bNvq8XiFUlfhQUAf8hAYVOwmCnES4S6eS+P1MxJPxgXhPV99ANJrO +dvUmXrE8W93+FMYcMNpXUm5U1RpTphtNM41ps4yaqUYAFi5sWOXOhTdCA6ro+yiakh7BNh1AOFEj +UnQkuTqQy3gIvE5YDwYUkX0OpihqVY9ZF4aFC4VKgMCGjQxmk6tpahqndzV5QllPZmAmPQG/y/TP +nLdg5cP33Xr1xT093WtXv/jAvbdV1jacc9GVEP44YqNY4ajYPPX29oKmJLKX4vvEjei1117LLhXj +ZH/6059wY44BXhhKWPVcsWKFrgvQfvGLX8TINRtbfJQCwzodZ0/oA2OQBT+m8KZ0IksD216IXeza +645IZ9ONZ8QTTzzx3HPP5XbEirq6c337zABvBbs3bMni4QS/yOz59LP/13/9V0tLC040v/Wtb/Fa +wvkkXb+EX/nKV7SPP3i2kGXY2AIY7Jf8rrvuoiJvKRah7WlkJQSloBAgGDC9aafv8Qh2+DSIMhKA +E0auHpIGUeJ4hWINh7bW6XywuO/mEwYj+UJHA1H8xiArYWJth4m6Ot3NnDkT3sAeBFFGwoJpL856 +YOO/ApkQ6ZCDzBFvD1fipIwGpePoCQEYHpipqMGSubMBVWBTeTzVidqUIrncEnQukZCvwY0hH6zg +el0cIJlWc8jU+taSUhdEYd6VenHDg0+8fNc/Vv5kw+aXElZCaNWsD1drgHV1bYPp9b2xZt1ANKEs +/EK18S8vQBb7CGLdV8z6yjEWTLQmkzkrkWWH1db26rotD22PPBhzvZz3DyDsLK8yKhsEO2ccZNTP +MCoajFCp0KMEwEFTnygBDSrfKjKUH0nYtpRQXFk7InVUEBQEa8lVhCwEJe3Y5OxgXXjNQ+gjhZVJ +ejrStg9pGRsOcIOJQE4L35QWCinXob5297/4WcMIZuagcxrnHd/f23XjlZd9/6pLmOd3nnvt45uE +TTDcXykuIPDfAhOJVUmvPnCW2ORizBqSFJxjzOxb8S185ZVXYpJePwKvJfwlnIHjE54fUe+ayWJ5 +gkXMJu9DH/oQ37ZuEGxmQ82iwMr1i1/8QrdAGVZAyi9fvny0irqkc337zABvBa8ZQMgei7cLFOTZ +ednwUgJxtmbNGphWeBAT1pVKxy8979gTTzzBLW47cbqAKAHfJitXriSFDSJNwc5dvXq1ZrSQSODV +5eWkNXLpTifuVddEIsERteHOB3/+85/zqdpYi/dQyK1FixbB8gVQR3wE/Kwxe7/97W/tWroYc8LM +0CBq/CNWnLREOagxIYHXAsjkVy9qjRTSjz32WDCsKEvfgkBM0OLFi1nm8MXKboVZ1qoivE/MIJBM +IhQD7yI+07Ex9Jvf/AYOAEQDjq54mYArtn7sy2ApMAwgE9wDR2lfANCDy24vEIcoG/ICotEdXOAO +PgY15svM8mRr3EbVtLKG3uTLA1b7jLrD4unel9f+v9c2PFtfNbM8cACW/7ymt66+ob6uEar0lVcf +yz02cNg7j9+8eW1fX1dVVe2s2YegiAtEYbUPEMWBdk/flt6+jX2RLT0DW/pj3R4vTsXR1jXqpxqg +NYc+IQExnkCAXhQYU4gl5KDQz4rzCmqiE8T4+R/RJqkKI4mBbYKXQwg3mKVUigRE4eJCaEIl0zh+ +YJRSLmJZEdiqdqR3BaIg5SCtqRi5cH2pgnFE/sGkEcpTMIcpY0OvjGxSAu5IIabDQfOki37wq0uP +X/eEnBNtXXDKnIVLiEDtmyUjGJLmi8Vv2uWXX/7YY49BcQJ72qW8Fhygv6D9t5xwwgm4Omd7pz9I +9r+sYryZvH4sebTP20ULbPx5l97//vcjy+EVIp0XmCsBbGZ91HGu9IjPOCKjVbRLOpG3zwzAafzA +Bz7A88KuhDOH2B4/Qrgr0XwLIKFQEMimjVdXT44uQJytIRw7vPniVpOXUKMRSAOXRZcEcmCQ4HX4 +6KOPBkfZCLLQ6ay94co6zFPjJY0xF46HpZ6Ngt406HSWZWhQJDKs7Sz4zc3NheV1nC8OMhRSviiL +ueVz5ituaWkpyprk2wnzP8peaTiI6ochndzRdLGYcYDw4YcfhoaApwEXDqIT71cop7Ej40VkijUT +ANYHBXD9Cm2hUZksXPOwYrKjQaDNz8bOTmeBnayAxAlgKr1A+8MwIfLa65mAvyHl6XCXrc/11mTy +sYTrVY5N+s281xMMeuIlZeCIJ2we0N73en/yjcqSJis5d9Ubj0atzZFcdFp+zvP/fKSmrrppet2W +jdtya62SkBmL9wwMdMSs/r7+3miiw0rFNFEIXgJmcvSzTPAP+m/QRrxbdGJJEXO+Cke1wi0zpuGT +b0KoR27gsgpaDslBFS+XtZ3yQKPkArqi0yTKQSRkpZrc4rqc7riTYhRUyrr0JcQoAEl5zs+gpqsQ +mqOosHOBWPzYUAV9wIHoIONXKk9igG3LMdtwwBdunH7ihdf/efmn/CVlJ3/6JlIYRdzKDKdH9ei+ +/OUvL168mHfjm9/8JpvcwiGzV+PIKQsT2ynSNYlJhC+Q14OIzSziY4ZTNPyLhZcLB5iPlsAt4M1i +AAAgAElEQVSmzW7cNnM/WkW7pBPZz2YA3NKvk34uFhb9LnFrr3Uc0GJBI4XNGXg54gwUKrUCGCAN +yx0UgsZOFkbUc4ZXJH3t2rW4nScLLjFoBON3eLE9lQJ8Qo/q4dljQDiC+BPws9VigP8lS5bgixQq +CBfCqCZBqcOntavoyFe/+lW8BbMVhrtbuF3A4zeJfOzMLTSYFrgW1Z2cW7HaPiE9Fb5SwxscO5fy +HC3gbYBpRoBcIIWXklcTmROrnvZjRYpe71AdIgJMsg4ixwIy+WHguTPFBIqRRSKBCClEeLMpQ0VW +yZJguNQzswLHnJz/dOc8ZhaZZSCUg+kKsIE3JWFXVWgaY0j71niD6f78hoHUNq+rIpbp1m5K2/qf +eW7tikef/Vl/on3thmceevrnj79w90vrHn1983Od0fV5TwzD8RxcgWFbXmEEQ2JFQeBKae4IMgKo +2EZQ+kT0Ivq3ihYUTMUmH4iJPSNEsAAe2dCgYN7QVdqR1EFZJlH+oBopAHVLHGKXxukCSpeSwDbc +WlqQ7kBfGLaKqAVQSJeS2NRNKrO6iqNLnJK0gwUICjMhkxzg6/pMdyjo5e/IUz5y8MIlJ33s6vqm +6TqFnxeCdbQhsZGCncsSU1QAsRNfLyaQNJOtKLfwlpeEXZ2WXZFuIy7kBXs71sSi/bVdd7SKdgEn +sp/NAFuoQsEkpCHvQNEzwneFbUYiCz2sNZ2Lq/miYvoWCgGRPBQnggYbdGkTjBxennUSHdenhsJe +BaLwWqEsYRGx8NojhyvJ0+FCkUXbTuSRWeQBUVK+9KUvHXbYYRDudq4dgRBCAR4suOSSS+xEO8I8 +gNkQ7nbK5EcEqyakV3YWuh2gyw52y3aunVIUsdUvgT2dBa0JY+3ll19m7YN5W1het08KuiG8cwSt +Xc10E2iBAvyEBDCVoONsWPgtaQpvKWZ+xsyWyorSLOc/AQ3cpfm8SldWUXtiG88dzLgi/mAe3R/8 +emY9fT6Tg6CDKqz+UJTToTm3hREkN/aGzEwojBFdI1RmVNcIMUcczVs0iTj6aQZFkUfg0SPuYrxB +4ZqCfAJspvBOoQshJcknEVSjd6hYpkH8bKeFvpQsRY7qn0pQUzFdwVSBWG7BXTBPEaBMi8ZdEBSX +NZr8NTmBqshWdgnwe0nngA8D4MdHix7spGW6wAmMIs+M2IAMjDEAqJMcZtemmmsrZjSF9d/F311x +9ic/a9/OrCs7uF5oysKAmITvlhReZtizCJmINzc3k66BUOtv81awnyULVkdh9cI4ikjQB/B12fkh +B+U7pwXeXvwpwpdjBYQlZaPsDisWFnDi+9kMwOrnhFVHRwfPBaWFzMgmpJDK89qws0fTDYEUBeDB +wl1Dw4jVTG/FWJeKJoQFClYH+jgsU6xs+i1Fuo/SHO8h2zuQxq4CB/inP/2p1uKh60LRqV1mj0QY +ElxrmENIOhizrWbFU6N7BaeHRILGHRCUr5LpYqh8VlDYo20IoJeQGSMKJRQ+F+3AKGK28eZdmD7J +8SHqZiK69fuE88Yj2UG3qtPH0QNzyuuCqADVX1tz0m6HeSd9/vz50Ar69+DVLMRRTbMCq0Ta2tog +c+GQsFBC/puucKpvfigI5SrQWFGahxbUpB7oAifW5bFMIwyqEYewC3jKci6LLGCVgMQRSSdaviAN +uXJwBeTzicU+CEqAEEAFdJkPyqNDJAQo4lqFfzRIAWqRQvsAG4EUIE00fTJyS2BUBIzcCrcWKIWm +5ACoEnOKBSIMLikCV64wdSlPUwoIAUghOgkKONkfYBSJjmgE4pIsqtMR/dIFolD6ZSTqpxPMpkCK +40BamU5pDqu2JukC732We3WluaG2Jq7/mlv9tTUJ+7bau6nVWEWxwgFBFvAVISOBpcE7oJm6p5xy +CuwHMBXylLNryJPY2sNBstVrC1sojCPcQnuIFQ1sZoPMd84rhGYvTCegFOkDX3sR31hXH16xsFkn +vp/NgNbuQXUD5u3ZZ5/Nas77pp8RyRTrDO8euYAHicQ5msWOn/fwa1/7Gi+VXdieFhCXzR9k7rJl +y2BXcswDSQSMOiha5FmzZ8/mnKVdmEZ4FeGRID3ltQeD7aw9GwH1QdDTTz8d0oiA3E2Ph0/vtttu +04lc4d+SziQgcOF52ZRoZhIVRxs/Xx8tgMePP/64LrN06VIYjexm0DMqZI+P1sLuS3fNOumjj634 +1q53wL6D7X9XZ2dSnd6zGwREMWNw8MEHF3mgRIMZXSEE6ZDkd9xxB++N1vxGHRexM8JzGkQniBkH +LyHqUZ5k9YQsYFdy3nnngYW8OryUCFBZ5vjxEFwBumxPGAbsFLTPISMeffRRNjK8xNC1bIKAZFqD +wUJT9N6X/seWrZ3ZRLlv2hOpRD4FSzOy0BXoTvpezSfDwdhiy/9c0tjsypaWZhZanjdi+df8fl9Z +Ykm38Te3PwoaleePyhoDlv8lSECtNAQsAWwQo7Qm+kR+oSlBTTi9maRIQ0WLxxBOLxBICwRuhf+h +D9KApor1ShUNsYJ/QDykoUZWRblSF9gUmFf0JZ3SCNZ0hXhlAG7pF2wWyhXQVWxh8gFLBinWIPIG +9g8pTBlSQGgIVosjHgpToVApYBlzehPz+lJz5tU1XHneu2Wguz/w8wGKMH9G21+zJUICyrJStJ3n +VYHtw7JVJCOBXIADRmFeBsROCAiIsNPnvRrjaXgnabAIrXlzZAdmmlRHOsBIhrcwYsXhxZyU/WYG +YHWwsMCrLJSJss2Cl8YKpte0oof9j//4DziftoGColz4w7oW5Cxrl84lzhvLQldUmPeNXoq0WIvK +7BO3sAnZQxR91Lsycmh6zYbkU+Wb5WvlSmAO6YV9DI2z2rAaEG6698WOdOmcKf45jT6u4+gXKmli +WHcMF/KR5a8/ErGhlMWmrLycdHLf6uDgoSHTYi6oCLWhFzU2HXAGgFW2e2AwLaP9ReMsrEgR2PIs +WrSIOSIwZXq+uNIIxAqiBJhyLIU0AvOBSFnZwoaa57ZtwqDce43qf/r9HSKVBG8CRio7kC9/Jtj/ +zoDxDiPvT5sb0t61DEVjG4MSDR2KYlrEJfhEOtxRsA18gjsKhedFXRZ/LIreFeYtCAd6KXRMDAho +DZ51URAI6JIF+AGQwmhV+Eoj9ADHla8HDjBIyS0gS0RQk2teXHaLvzPKQObSneL8cks7ACo4Tcvc +EkBKoTWTksgDgtaMGRDVzSWiAvAlZfIUtOlXeA9xrOuqBibjwo/FT8kGH+YBXI2iLvlZWTJg+FOs +KIufm115USK3nPjUiXw/WspOZGwQpfxwWoFEXZ1IEb7q9vV1xIqFBZz4fjYDbMcJwx+KhbsQREFH +9n+cRODFRpNojHMadi0bRGm8MF7YF+/b/vHKFQpNCx9wX4lDj17w2IrrJmS4gCiquWydkC2xCLLq +8TLBHyOMA0f1kGDn8qLQVOEI2YUBjSyd9AIPgV4oQO/c6kQ2GgRu9XYD2oIIo4IioaSO0KBOj+de +7U09nMj0cOoSliarN9CWSXFOMc8uIxkP5DwWxnJx0e32i7U/0AUiD5EnwAPlB3R5/FJrUMaIXDMp +nF5pB6yCNg0a+C0VUSjWa03JogXADCwASlGRBbypQqA1AVooRXXgRGhQuLWa9FRQSoPgMb3TGzNC +HC4utShJRVJ0uiZJuVqWAK8/JCxcsug0GRcalFvGIzOQkquAcVqeiBZQ05VNgN/oScwZSM9LuObM +rZ08elRGowK/3VD0Tf8WvQlvynNunBnYC2YAhRfETEVsRpYaJPdwwnixYbaNuOfbC8a+/wxhsunR +CVyYwDYgEzqPl4bXhUAK7A6u4/59aG14XXsLxuA1O4W+QFNKEgFBNSUKdmpOCIlkkU5F4JZcCjNI +qhP8+VmVrnBtzd+3RdajAmTB3cVVC8QcIIQgM5AEY3LAJ4/DkdOgnEJJA5aAokIv4Ap4IyD4hHIE +5IA0gBDtX1AKBIWP6gsJ6AJgaDWhB4sMVXyf0Q6KSlTCnJBXCtOUZgIDeoKsAK1PmoXITDIYwtC5 +UoBQ7shQU8ud8G819JAITIK4oDijUipLjEcoVKoo76TSDmdIYjI2AXIYwpRPSIRbTVvTIGEUOJOs +3Rr4XXZr+07jzgzsphngjPLwltnfwz8jDM9yUvaDGYANOWGBtQ98IkxYizvRUOGCC15yC3ZqNCUO +WIKapNjgqiGWK23bdU1XXbbvjArf/w74nhUbRWm3z8zjkhTVVp8vL8Sc5crSqiLd4HmaOSMBBCom +MOQgJxtBoGQG1y6iiwuNCD6BUuL1LCwQSEVAFzGktuEHRhLHNCCoFh9QNKjSM6KckIlIK5XWEtAL +9zVnCbARgHbhJ8PgRcap9IN4CGhH4JN2iPNbyhCVNBRcJAu7CghBE/gwVQxhyFPkqRQAItHIBbkZ +ofg9hcCFOazsNtARvF+wWPYH/EnPTnBmwJkBZwacGRh1BkQDdNTMfSdDIyJXO6LxEgQlQrAjuoy+ +vun58h5f8rhwckltZQ1u00BHTNDBWE3FXdlUHq1XE6tFiheKDzJwCMIUQIVVC9LktEV4ECumkA/U +VCdE4RKDZzByCQAnwEagPO1Ap0a7BQKF+AMUFXuWXyKrhKNCjCpU8yoRZjouHYGUwCqMWWAPag1g +pkFgFT6woKCiHYlQRgowJHSFgHCY1IrMZWzCFuYWmhihaV4YzhyVEftH0NDsK1QVeLzyQihw3Qtf +jS984QuIPFGdlal0gjMDzgw4M7AXzACGfvYHHGUmNYIWTinwqSnUQuwkUZe0y9sR6prZmZ5ofVXg +yb70Kri5+DizgNS8C6INNIK2AwLBISg5DrpgUYhAXDAIVi0pGc+AlQXSIPuErarOgDK/HnYr0KOQ +jJyZAYaRqqoCsI6pqAl4CsMQBucwLRSLDEo9RT5KRTE6qKAUsCSFw6AUVppHIC7ASY9gp4B6VmhW +yFkiaAwJh1mpGoG1iDzBSzYEopdELwwdG04xQXSyqI5+E90JxlvCfDZL1DjlEfeWwDEAFDQQE6Ar +v7eMyRmHMwPODLztZ8DcT1C04IcsxEXihaEIRMkqqDcYdRnhQPrE8lxrvmyllevB54sXtrDAEjAq +eCPUHhiUEHsL4VKzL5oBeOD04h3tkINK/e7AC2u6ElZGeKrQeYpkhJmK4BMqECMMgJawglE+sqQp +6FTUmQQswTalpguJCRkKRQimAtJiEdcnjFkKEAQyIV5h7UK8qsOg0KlgpyY0BdLdcgA0jRTWI6xm +4kA1QwdEeVxLqRRJv0A7BhksQVy9M5DGIXkpoES5gH0a+nVwVibvn1dWbbv5lkfWrxOvPm8O+ZVP +Loc///GPX4xC75uznDtnBpwZcGZgj83ARMpH99hDjN5xIYjqOGU1mtq3uja3Wh1J3wbdrfn41MrK +V2LhZ/oHYinLVV/nHxhIBwKmlTAisSQACQsU+MNKnQZXKLzVb/S9o6VuWl3JhrZ+8ExjHiglSKb0 +jwAzoV/h+gKNHGvR5GbWsAaExKQYdGIOpi7kJgUUKEI1UoW2tIQVLIeDQI8wlxkD9KVgJH/gLleY +ukp0SteiOqQS87Bqs4LclI8rZSKeETAmUTYEYHySDYHgOnxgABsjEvCuke+K+zjFi9ZzMglXfoKL +rvjTGWfMX3bp7KLu7rtnxf1/3VDf2PrS1lbNZigqMO7bm266icPynKTaYQscX8aljEMN73CinALj +mwH7VcRAEkdlODQ/vnb2eC0OW3PUokhpmVFx2pVDE0UGFNFiwXJFS0sL0rc9PvLxDUAM+uzfAYDk +AW3U1BEbSu2IngS7sKriS/Yd5on8S2WwxePOY5+orjaI3/Op9cH6GkwFCsnYP5CFwiMAUX6QNWE8 +u6pj47Z+iFFuIfhg8IKjwCd6sAhBYerCR6WYHCHFgK2iCIVdHFCySDBNmRCCW8uBTiSaQg8q1BRE +VJhHhOehNcz2avNJYCfmhxJxEZ3SALn8kQgkQpKSBF7SLMQlIApZDIKiJyx0sJKVMj1AON4A5ZAM +dT1GpN+I9QvwM/JJDqhYv749/Vymuj2aLfxb19Zz8/VX8OvMXXrj2g45zlQ4MNQgW1RAxw2rCzqO +fZnCMkVx7IDbZ7Gw/4eJIgoUJhaV17cc/sNe9ohZTuLbbQY4yI7jqYl9avtVxGQPZnomtvHJaY1v +BENLmMFBiYHzsra5CThJbAtwjoT9fZwmcXZRjwcjAZhq+vznP89ZIO0qrmicGAnAbp1OXLZsGX7i +dJx0TpNz3Babi9hfLKo1ybeQPAIz+2vQuKifjjioaQOnHSFdB4oRKZoKV6bG6F1Smn+/O1ubzMYS +6VQ0maqtDFWU+pun4kjNX1cV4uwNBBxIpnmnIsL0CLVKW6LrC3sWvIQSBQJdch4mhEF8IEphAVUS +/WKWAWAD4YBJxJ+wdgFmCFY4vUI1AqWgb79cAWPNlaVBzMQOkEgZJZGV8gqnRWiKuDSF9pAHZ55o +HYuOEh0BzOgroWEUELxknKJnpOhdtI3AfhjIoDVdsC8EqnfhvFLRLO7sLdtV3LnEE4nlX/vkt77w +kSce/ksyk+dvxQ+vifR2vfesj5Y2H44he4oVtog1K5w+EjCbdc011+g4viAKyxTFoT6Hm/8eMbGo +4oi3rBfYTR0xy0l0ZsCegbfDe4K5EohpHHDhAQmbhbhc1Y+P9QnOHAJ4bBEAP2zpkA7NikE6tiN4 +gMBuIlbtoE3t6SqKYCgRs0c//vGP7XTiWLXDpj/gCk7b6ZMfAUf3/1AIk8RtBBVQVWpH+qpBtPA6 +NDUYYDjQH/sX/8BpNaWzXJ5czErWVpdgqT7ocw0k4PG6gj4PwMM7IKSesr0HagpwKkAixe82OUgL +PQoZSjH4saBjpFuxUuGdIhxVp1kATpBVEBgAVgdaeDsEVhW4EgcUaQRydqBPpJsEQJQGRTkIjjHs +X6V/BHj7XEZZyJvJZXnByIVm1crZnIWNcavcudBOLCoHZoRyxZSSSkdKSmAIQvVNLkkKw9YT8LtM +/8x5C1Y+fN+tV1/c09O9dvWLD9x7W2VtwzkXXYkSNY7VCjnwMtaRwk9+8hOcNOmcz3zmM3jb1nF8 +MGF3ECOCixcvLqpXmIj9T+yaYkcGJxXsrAt9jmqrpxibZGmgBeysYiqLvthQj7EKFPXl3O43MwCr +H/PL8D+gkLCRi4l5/WhYaW5paUG9HEdDpBS9J4ANhBS5J510El759pvZgM1j2ynE5r62pM/TwbPl +M8GMImjKThdruiTyJTID2sQ8U0cWVixGnAo8TNxyyy1Yky06V0l3uAfAxBhr+IgVJyeRvid3pZyc +xyroRYOoDZ+CnOoYDCejdUQfidFX6unyOlLQDKjm8rta/NbJZcmzzGxzZyTe1dsfi2YsK7+tPZHK +ZFG7LQsbfk6qQDKiK+s2KksDmbQP0AL8Sko8M6aUVJSauAUFMlGyhRysKheJgFh+UNQnwAk0ppQO +LZDG0dL+bsHL/h7FDVYHWmACQ+PKcRfFs4WXyx8Nak4njlwgbYFVCiQyxuYtFjQruTTLGMB1NI+Q +hqInDNCCxxyzAf5pM0lFdI4AavU6UBggReA6+S8H5CZGMDMHndM47/j+3q4br7zs+1ddwpned557 +7eOb3ODoaP5HC38s4uyFNfjBBL5XBY2+d955J7a/8UiqLWUX1ipMBHehbkHW888/H38Utq8rkJKz +N/hKZAusvTFrBCVOMV6qwgad+NthBrq6unipMFeEGXpetttvv52nZrMFyYWkABtG2gl80XuChRne +GWAGSQTs3P1vouDc/vKXv9ReVHk6bRYRxw+wfL/+9a9rX2narK797GxESLFv7QhziPNztq02Quss +TKljqRgPMGPYWbQb2a0RPnsIj/0wAIe2NoqGRgWggyAKfPHGc4UboK8UJjARpFOeCLd2IzpLEqHm +cjX+zAlVxuFx7+qMf12gNN2xvT+XM1OpjA+q1AsuZkEmrP2FSoyDmyt7osloIh6JJnv7knQgf0oz +CDgEw8rwG25l4QnrY6BAFwCZV37NiKBtBLZBoQKr3KKIxMYHGSctAIQIQUW6iUiVRsFFTq+iyqt4 +wvCZwUKyKEAxoJSrsG3VLQ8iVeAGI5elooJh9nNCCisT9pDRSSU9lf4mN+BeFKFyOGiedNEPfnXp +8euekL1864JT5ixcQiSby5slO2WrGbDESiVgyTKH0wnWNXb9IGVjYyPqD0hxxngstCQARVY3LPEu +WrRIexOyy7NQQmfglwPnUNiYZC/MURycKxRpT9jlnch+PwOYh/3P//xPFheYHAAqz0scHwlQV+CH +fvyi90SDK1kICwu5HfvHXLGuXnjhhRCdtr9eZDG4EsF8P1xc9rjgK5tOTPwXWqwjTsrwGWB+IEMR +SBdlIVulTSaf77Eoa5JvFfdwkvucrO40HGoQ1VcNpQCnDvyQBB0ni4i+MkDKE9cR+1o4cA/Upvvo +8vy/euPHV5XOqij3loVZ313BgIn0NID135zR2Wm9sKa9v9/yihkhQUSIVOhFMRafNKyY0deX7Utg +t9dwoSuUUGSlsopAijhiU6dZhFWrLEShiEutFOQmOKr4wEAjaCjUrTrNArhSizOjiFTJYvgUgxKF +ABWvahiV4PMGwtXpGmpyS1MQrxDQPCp8ZiGLFXJDsNKsBNlRTGqAbev1uMMBX33j9BMvvJ6+/SVl +J3/6JlL483p2lh4F244//nicpsERYguMzyncGEAxjOGYyX5OBK580uyO7RQ7wgvToj5azV+yN1h2 +ASfyNpwBlnK9XNhcR4R2KN/igQq27XBJPFPErg4H1EuWLMH9y/43Y8An9CgeUu1Hu/TSS9lkrFix +4tFHHwVKEXaSxdaTPatdBhAdruJLLrIYmLdITyFy7MJE0IFA0RdsZraHO9YsLLm7426W7P07jIig +QCbrrL4qMJWLBlF9pRbTQlxXJ65TiubK7fKZ2day/MnhzFkB15zKslqgiCmd3lQ5pbFi2pSw12V2 +dVvtbYkcphtw+Y0KDwSlsnNEU6JkFDWinJHBlzgkIJxVxXcFLIFVUBPMI5LEhp+iQeHEAopUR+NX +JKm8VCjfYmVQaTCJe3BlGhBaE4KYRihGABrRXRK5qbJ0KPQuQEsZ9I8UOQtlrB6XB5byFJNTN+pP +7SUkcdICfF2f6Q4FvfwdecpHDl645KSPXV3fNF2nsNWBYN3JweBqFIIAHMUXqY2jp5122g6r46eW +z7u9vZ2S7KxH3CMXNeIAatGEOLeIBhAEMg+2nJ64/Z7gNRnvoejX2BTbfjNj8Frx3QtTlzXWfiho +R02Cwxy65JJLeHCy4PTY4hUkJqjNj3j8jMUZJjlCFiraDdoRtiNg9miCVbvYbo3st3xde9Y0EOqr +xkhWRn4YXmj9M3O1X26tJ6Ihk0RKFsGnXdJunwgMYK+7utx9XD6bCri391mr27a2VVbDe3UH/Fi6 +wBdNGgjMm+6pjWWxWLqrJwGAxSzRABK+qyHmEUBfrN1C/4lsElkmlKIAueAfWdCdQk0qFq4wdblX +ATgUCKQRainzv+ArQahYr9hzoCCUJQhNEOVh7tUxUyAT0OQwDLekSzlKUhcrvqpHSFjAePLD7NpU +c21FU9OgS+SLv7siVIav0EG6GPWsdL0mqHc8NHAU5Y6Wlhb0HcDRz33uc/hRwBvwDmuyTWaHy/eJ +nj2KuDCBeXPGqAXluj+piozxpE7WTs6A9syIEg1Hkx955BFdy35PoKs4i8yriNwdZ46FNNlOtr/X +FuPBkfvCicUTFwFaRXueBkRxHa2N+ONjuLm5mUdAt4g1Fgp10aJF6BDhP1jrHw1/OjT+qA4G40Ma +WaldgOpoeLEsa2UlO32SI0Mr6CR3q7b5zDg60M8//zxKXLujf42dtGyDKBF+V0DUpkQBUW7hxhDR +gSwCiSydevWklh2x2xxxwOKK1DW9Lvi+5spzsdabjs/I5/2V5YHGKRWmJ4Bcc8PmASuVLw+zTXP5 +UOVFTIvZBNizGBtCionNI863KCUgwTYFn+TCetUiUnR9IU+hJoWvC3BiMomGwFoFgWKBQRktEsGq +0trF1J9oGOGaBr4uWIlxfA6VKtzlls0ikImiEwHQRSUYSi9c6vcGXFU1Itwli44mMyBDmuVeXWlu +qK2J67/mVn9tTcK+rfZuajVWUWxnRoUYBvYsWpEURrjCpwgbbWcqUgYGFKvA8uXL0ctHpFooxRne +AjpHKDvMnz9/eJaT8vacAUQDkJss+shNYUvqSbDfE1YYVHzRAwdKOW0JHYbr7/1jonhwPhykJ+gW +EEA+/VyXX345kmM+SeYE8lEbM2EeUAFEJZ5tLrM09nlc5uq2226DfAc1dJtLly7lzCEHbdEzGpEh +PGlT6pp90gX/WHHdRPWHTseaNWtgVYM37BFYfTgMgELa8Pb/8pe/MN1wvfFXChWIFGF4mV1PYQwE +2uHKHpDNC4EIPeqAnggRriTqOLfEddDlqUtEN2K3piM7HGEub8WT2xLZLaY/mkxHOrr6rGRKzP4h +jTXdwFgmjTYTOklClYKXKNxyJIYA+CGxdbmyaPZCLCIXQPcHokiYtFCl6rCp3Gr6VZGtMkKlHASR +CjDTJoDKP0SEoqVBZRSJzigARvIH9NKC6XWV+KsCZl1lcBbi3U0Df47Gt3fF5iRc8zL+OfObJ8// +KPPMXhVteDTgR5xbdjwobuDrW+9sRiwzsYkQo6gUsQRAoY7RMi8PVMVo/pbHqOhk7a8zwBLBelik +Ylr4nvDCsEKyZY9Go5zfsGWr++uE8FxQ4aFQqGgfzJKLmi4HySbwo55s/6PKIsDE/HC8NIweJUm7 +OUxAMUcwwYugFIETxCi7CebULrw7IsA5zfJC2zSlvuXd1d1p+pIr7zcp+pafkwi3RDTucquhlEgh +ghbGdYNFV7crEA60hI0WgDKZi5bVRdOu7p6+9alMX9ZlxQeSvgAHT/1WOpNKZ6EmBZh0oTUAACAA +SURBVK+VEUHITQBVjscwDDxvKyOC3HAMFB4nt4AiNCXQK2xepWoECauVdXE+inVcCgO3YK0USIv+ +EbVyeRrzurIoI9FzOBAuLQ9VB8wGv6fKgztyFUpd79zU9T8U8QzZ4i96qN13y4SDkZjPBb2Gzy2T +z6rEOzOB39tozwLpQHcweO+55x7ohrFBlEZgZjggOtpkvj3T9eta9OyF7wkmC3RuEa4UVdmfbkek +GlmNMWm0Tz/mIJzs+jMAM0UgqtsEVkmHOV649kHOk4vKcpHBcYhUdiV6TqFrkdKji0VJZMhIGuAG +cJCIHRxyL3TKIVxoE5twWq9ytDK8zZSBrUcEpP/nP//JlbcZrgvUsB4GI4HmQOINB6+trQ3ePYs1 +5QFX9MHIojwlWdl5TNIJxAkk6nQdGfPq9vvKDYO/qeV1h6YzsZjVYVRGO3s3Ga5IiS+Ztgb8PndN +OOA2XX292E3KoksU5FyKUqb1+jxIWDlRA7hCTUpQglWgkQDoCgNWMXjBVGg5r9ft9Xv8npDbFQr6 +SnzuMpcr6HaHvO6SgDdseko8rlG1dcqCDZV1gQgaxVgTlO3EpAZ+U5YVLVMZ3jEzPzxxd6TAhkJX +gteM09+LFy/eHV04bToz4MzA/jED5kQJwGDEFVKihbNDOrkwsu1EVkkO5CJexqoTIBfEc4oK8Dc4 +4afjRLjVcehazv/BW0fJjZMMwC2wymEGjjmDphpHxy6jcZQ1Gn0w6mrRLDjKVghoxCQ0WQwJ1gqS +f1jNcPZZsqGbAUswlSucXg2ixIvQVMMqQ7WRVQ97jKvXDFWEIVKNisZ5+A3P5bOZyngyFckaA6lU +1BUaKC2x8rl4oMRMp8U/G4pH7oCJ4k8ul8FuA2YWfG6vy+WFYYvzGHDUlUf0GUC2GQyEPK6QzwQs +g648+tgwbmXXsvMh4C1vqGhO9InRhsmCreLRTRpeFnc8dM82izB05/zrzIAzA84MjDoDsAsHiapR +i+xchuaLjlaW3EIcpRjH5MEzTrtzuAr6EppvtLo6nRNacPyIwxmAfETvi6UWdIRCtSuOUUZDHT0C +dQToThjOHA0GL0FQ0JTxkE4iup3AM2somArlShWIUYCTXihJhKBb0xEdt8dAhHYKb3cQz6PE5AMp +gb2At1oKK1Y3AJZBB0kFSDBaVIQYv9Zg43gZR2tKFxj1Ol7irdp75GbzBdymgtNOcGbAmQFnBpwZ +GGMGWCbHu9a+uVXINZ0ArtjBLmLn2ilEWlpa/u3f/g2pEmeJxoZhCtswTOPEuRY2peNjlNFDgsDl +GBMSL47kU4VEOMygI5CJnB+8JNLU1ASsQqEyJGhczdQlhVyulOeqI7qubplGdKTwOnyEO58CFnvc +Pv3HAIkI3LoxUTCYuGMQ3fnOhpX0uisqg7OxfyTKvbszYGOPnQoCyN3ZidO2MwPODDgzsBtnYFCh +ZkJ6QOGMdoTcGwq6WZ0+YhegF6JTUBYGry5AVR1Bm3fEKuNOBOHwv0OPnGTQ6sGAH1iokU/DJABJ +AY4xISVFtYwlHp4z4KoDZXSxQjQtbIS4DhOFpuN+2F2vGDZbA34c0+x6S6O2AK8ehXW0Fh2PnqPO +kZPhzIAzA3v9DIg5ggkZJAhUU1vb1dmZfPOJBUCUdHILe0FiitIQypAAEodHQR34qxTgimYHsMqB +qpdffnnC1djolC7gx6JmTXdwcYE9xkBcA6pGQeSm2M6AeOVQMAhKMXJ1YQpQXV8ZJ+lcmUMeQW8e +bGYvbeoUnaVvue4rAccqvtw0U86x7lJ4ZdW2m295ZP267mGt5Fc+uZzp+vjHLy5SNxtW0klwZsCZ +AWcG9t4ZAEcnZnCQcej7oE/UH4nYUAqIlpWXk05uYTfo8qBeC8CgfEsW+pBaBRxNItSIsA9OFU4a +AGaFtXY9joQVr3iQQYg/m5ub4e5yGJFhEIBG2tcRrN5wUIdnAek1iAKWFOCqg4ZPrho1wUsi+koL +tGPH7VtSiHPVT2FHdv2hdqUFe3j2qOSJlDiWSMoyLXR2a8ffA4950RV/OuOM+csuLdZrv++eFff/ +dUN9Y+tLW1v15Iy/G6emMwPODOzpGYCxhOWAEU+2jD001liORSDmY0Udu+Rem+uaddJHH1vxrQkZ +n1bZRdkVyaJeGSHmwCRCEY7SHQWYd+jUoiOkLN9UH15+QkZII/xmdA17lo4gT7WqMHESCcAkV25R +CQbLUVwiThXSiXAlriMaUInrWx2hfdK52re6NXvw0scwKLVT7GI7H5GBiY0GOd6atCwN1VYymctC +anuymXQiYSHVZYeQTJGYw/FYIp7A8gQbB8pTHV2iZCLBQ1PGsuLpTBYalMdMh6YbVQe6a2YfeWDt +lee9e8QhUWzEdBI1B4ICMxb9dPEFS845QvgNdohFI5867fD+vu7Fl9/z6uPtGx69sIhjweTz6+h3 +A7E3DpLsuk7EmQFnBvaqGeC0N1bDWEtZhVhaIYSKdN2vuOIKrPeNeKADhRU8w3CMAo1RTPKi71n0 +aCwFGAvDgiDpy5Yto/2f/exnxEkHtlnBsAiIEfwiSz6TbYdhAuVfPCGQCYnJ6qnwQuCKRZBr0dRw +y4qPq6nh6ZB9uw9E6c5er+mIoZLCUIlz5SVgQ0QE3jInXjjJqilOmxIlQgq/HA+oI1ThVhcTTBoi +OilJFrc6hV64xWwSj81Vzw9QBaRSC9u7NEzJ2EBUkauupJWwrCSNUFHelVwGraJ0MplS5uppinzO +s+RzKBhzZgZtIBcYSVymFQuDMhIx3Qv9SxzIlMfE2q9YbhCJJwOWjkSVSYhPqig5KHF5HTBIQa5Z +jo19DwdnSBkxMAzkmiPacIeOx+wZtdCIxl1oPJFY/rUvJ+IDi04794jjTiZ9xQ+vifR2nXT2BSXN +h5vPPqwVp4t6wT3yhz70oaLEolt8JmMwCw78iO9YUWHn1pkBZwZ2xwzATcQtubbchHX+66677vbb +b7c7euyxx7QnczvFjrC4oa2CJwmwEOUVPLrAg7SXaLuYjuAiZt26deCunf7jH/8YhiIgjdUUjA3o +BdPOncyI6Rp9oXyr42Dd1vo4b7XiniqvgGaQ3Uqcn0EBn2APZiHZXnELWuifhwLESWG0gCfxeCwG +zURh1nHQkQOvUHgU4FaQLJeFFqRkkhOg3GeyVsoCrzSOcptOpaAOwdRMFpiUIDCm8A/DROK8Rc7a +yMkTboE2OuaPu5wLswtgJwdDVYqbe9kNmIKbUtT0YBxf6Eu6y5sCk7qk/COmAlW7qk1VRjoBZSnG +k4pRJcwi8bB0LKdeqDNyoDAvMXZoh2efeeaZOpFReQJ+l+mfOW/BL779hdXPP3nj3St72rc+cO9t +lbUN51x05f+8lsVRmp7V4e3YKRQAU3Gsjd15Eu+4446nnnqKrwhFX2YdcQDb1Ztvvhno5RgV3yG+ +qNC4vvrqqzExiMoYZnVx4aRm2PjKV76C7wg0sSnj6AnbM+xEnBkY9wxA+djmDzk3WAh1iPA++clP +3nbbbdqiTlEXfJ7ocmoT83zCcDSR92mD2EUlwVosomC8F4gpzKJr1FnQpNGrdGHWZMaVOfPJ7HAv +6AtNYOCR30wzNoHDXB4KD7xL8V8Cn9qGEYn0r37pZUrEFRcUgolE+J/xWBxTfYmBGIdJc+kMvrQV +wIk9P2wpAGN6W0IEzFPopaFN4kO3RCTqVYZ0PS5Ff0szYqeItV5ISQmYT9BtCLk52K5qhOoCkupP +qEyBS8qDeRxs1YQmyaoRbWCXqNLLFmpUgggh2DZwBe35x4UykSJqSczn8FPKcSB3xufFLU5a0bJS +aaSA5WhUhAqP8FIKITRvtl0cP2icFsocdE7jvN+3vfT3G6+8bKBzM2T8O8+99vFNbCRyEKx24cII +3wx0MyloezU3N7PrJII9awhQTFpz8pgs0JGPkG9Pq6Rx3hez4LiDwIcGuXAUOONEFlyjCy64AIsf +iMYBUc4H8+uzEyrszok7M+DMwC7OAHQFvFlIUrudT3ziE5xtK2Lz2rnQl3za9i2sWlLsWzvCCnPD +DTdgj95Ga52FuAcfbfiWQe3fLrxHIljzYbHex4LIXxVDVUdwSsaaCJ0H1cIPmUqCiGkQDyIw0odB +opyiFAFNC/yDiksmkpCAMELTMELF11hKOLVpeNGgjwIzUpUjT/6FAhXKT0zDg1IyURQRzgOlvYAW +esiD1BRjgEqVEkImSkQ4ruqWi8ghVfVBgAXaYOpyg0+VPLQfxJ/yriK/hlQS+NXdkYMDcDmfA7kM +txbL8p4syG/kPAKTUlRQkgGrbhWZKjcqKPqUBqU5/nHjJ4ZnY++mf3e/x6tYyowUxoR0qMhaBcyA +n25XtzTKFQtTvMoQ1TofIr7IpwruQpHPhoPmSRf94FeXHr/uid9RsnXBKXMWiusVHsQseZMOmt0P +lqqQtXOL5kJzczNYeP3115933nk4B/3MZz6joVqbtIWNbPN1UU+jmG4EL8o6gosJEBQc5cFh2oO7 +UNJ2R07EmQFnBnZ9BlgAkXSy2bU9qrKpZXVlXwtzaMT2kQpp4ZrOJT6inAikhAzF6k5RIxC+2ORB +i6WlpaUoa5JvYQDugQDyaPCB4Un3Oo7YEDgTRqjSf5ErVKMCReKpJMK/fAJyEDN6qRSaPySmU0nA +EmFhLguCxrL5LCZmhbTD0h44I4aH5OmEC6tUbEAXegE5AA36IssDQAFDbo/pFyEuUKLJSqkmqEIj +WbIFID15upYiiDKzeazgMnU5KFJJkuJ0h6U+kBhAFiJPPLFQRFoHjAfP/SggFB6qIGseDoUUEwCH +vlXsWsVLFZCjmrQ6GKSCJCisdWGLASZzFjmniWA1lwUioewoQksQxNCXAulwaOl/kG8vDchRWVi+ +IjmV5rmTkqJEJb2IPxkBd/pQj4bFRHE4o55N8kcOKDYvXrz4gQce0NkYayw6rQTbFuMR4YAv3Dj9 +xAuv//PyT/lLyk7+9E2kUCVuZUajR/kai+Sj7HORyK5cuRJfSyOPRoGuncXn99vf/hYWLgToWWed +RTooe9NNN4GvCxcuhNcED8ou7EScGXBmYFdmgA8WMuZXv/qVbgTq5bOf/SzmAZYuXUocUSgRhC+F +ajHsgPGbaXcKiI6o7gv/6Xvf+x7SU7i7mkelq1x88cUk4nKO7xoLBIWQbLc5OREEYRPckYJIfWEp +B1b4X1OPUF9ieA/CEQpS8CaTsRIJWe9RvdEUITfo3WidWAWrXFSCaKUiU+Q/GW8eyBlslHyh1fDl +aYpPSrRpoRzzuQD4Bshhyx2UIlGQQVFsPlxXg4O5HGaBgDeKuVjP824NZsREHYfCCheBKGSNdCpd +cqDSDeVEQehHAVkCMkkaISKYJEnYGFSnYQTC3aZPXH7ySCb2cKVBFGsV/apzKS9Aa5hAnQB2DoGn +pg4BfrGPJPAqgajuBbB0u7w6Dk08+NshzQRe6UiIYGrADGVj4M57TNUeAxNCFqpaoFr1aOsZyaAQ +kQsrV+CTwYPGNMGfy+fNezzpnXg/wFGoPXiq2K+A5lND/r8LfF2f6Q4FZZty5CkfWffUnw844sT6 +pum6hCfqhmD9v9JjxvgIYRDBzMFP4Uc+8pExyxp8n/g1BEHh7mplP10eMD777LOpftlll8HjHbsR +J9eZAWcGdmYGYErh14FTizZnCN6PzW7Fpg1cWRaKIukmrsDsMsDB2rVrYTsN7461jk8VCc4ll1yC +DkRRgU996lNf//rXYTKddtppRVmTdju0Fu90h5p2pLiGShWRhR1cFIBR/wMYghnwLRUuykXgUBIJ +ClQVwqo4NUAl/gSAoIQg3UwTtisEH4173GYu7+X8BrVFPVUITWlGrkBCXsCBe6KUpmUYnfjZFDAE +Q0yXGHDPClIIyqhBKowQ2KMjUhSxCDmWx203Y0hnM4LKCi2BMY8f2ENHF6kh6OSC3s1lQRoAGIyG +CiT4hFNK74LYSjUIjILpO4i2ApKo2lASkaPMFREBXZk9uZWqgri0K4mC6gzJdOHURR6B/YFA7CBo +SwWQXRGPCvOYDtU72AdlCRDKIwiFjSovY8WZF97IhZfLXEmeAmDBWtWGBl1R2YW3SydEeDb4zzyz +6WUMZtbr4SQN3Y4d+L1QLEIZHZpvuLR/dm2qubaiqWnQFcHF310RKuMMzGCzXua8XrjrOwxaRoJ6 +ER57NEHZ0tKCkgIK4atWrYLZW9QC+1O0x6E40YBHrRflLwrgn4BNK7VOPfXURx55pKiKc+vMgDMD +45gBPqtvfOMbsH+QnRFYgPBEAqCef/75ujVcaUE12rff//732XOzXLDBZW3CYcmiRYv++7//m0TY +wiMOAAnO73//e9Q/kdHAKLbLUJ0TNSynWlnJTp/kyKh6Rnqh16Mpjg+CgEICVmVN47DEs05D/slq +jxKsYAMLOOulUFaK68hSzgLK0g+McRwDoGLdx2O1lHYDovAVRSlWDmN48ribBhHSwiWVfIE2YBO4 +EKpLyEtBIBH8gVDAjkA0rWP9FvTOuoToZE2nDNXQcKV9koBTaCx6Z+9DtyaEktsLNlPXK4cshXUq +vrEFhvJZVFYJ0hmpjDRv5jwC1ASkeoxERk8+uCP/aNatGpj4YwEUBahpQEZAy8TQzk1J1PTATRVU +w42ogRFbmNEMFhks/8Bz5mGFbJSuhYmML5g0jQlAMnummM6gNRmGwCSFgGq5k9EqqpMqORNF3ZzU +wDkp5DRTYMCglu0FpaRJ9iJsaRgl5DCdqt5AYT8zqOhTMFwmY+cCru74SIazSeHxznKvrjQba2tm +6JZqa6DpE3aryY5Nrcaq0tJj7RQ7smzZMvuDefDBBz/3uc/Bkm1SAQbRhz/8YfTpOWAKfXnCCSew +J73mmmvsukT4RJubmzGPDD0K8weleU6YseFF8YFx8qmjo1RY3ok7M+DMwPhmAJVA4PP000/X1dGf +hw80RlO/+MUvgD1wlM8QGQ2fJzJOwPiPf/zjGLXQarztttvQkEC38ZhjjqEk6wCMpf/f3pkAyFVU +a7i7p6dnyUYgIRBIyEaAALLKJiKbbAo8QWQTFRAEAX3KU56yubEIiiDge/rYRVAUZd/3RQVBEGSH +sBMICQnZZqZne9+p03NSud3TmemehCR9LuHOqVOnlvvf6vrvqapbl6xwaksOCJfJbWCj2Ifh0Aev +OCORKR2xaWIZpQT1v0JgER4lGkbDhgOfUfzTEBRXVL5JHabtJI5hXHEwoRMhNHEv9VXI8JKlvFUp +EWJAby+H7H5AbqLHt+LlDMLilcp6IRiEdzA1b/iHGFhBYkmOcYHO9K0VtLhjMgcK5eCCcp1C/5Cm +MKbIcllCNAECoUdx47hiDkhO+JxM8TEh6eAHBwKCAqUwoXbSSyKuVUhUiJBLTeHG4hUHZTCgqPBw +QE2xFf9UK1BIK7VQt1EkPGKLlVRSqzQXDinCm1QGjg7sK3WWN5mETcVTR5CMqAkx8gEZDsx5NqG6 +AV+BEEjkNVbybWjINTU2D2puxsX8sGH0B5lV5zWsttH4Yb3twyCZlz3AhOVCrG5nuUFJQ8Z5WPLD +Et9iR7akfUkla+vxSjmKY1ngsPLKK6NnyZIuSuI+MgSdWPhXnNA1joAjsHQQwKuZOnUqz7vVdAKJ +qi71fRi040/UYjFB7ebDeVFLYdjQzat3JMHAT/Tz9OlCeYEz6NWFw5guhAHw+8TRxK2EcsQFpI8X +BsJC/EjYSmYNA3mRuSzRwc9FG0i6W96mFLIkBc6leMBkKrQkJQWi1MlUcXbFKcPt7EixgAZvLWxQ +IC4gFWPsFkKDkISKZHxVvE3mQYXicT3hmnAdQqLiOUKZkCjuG14ehQk5cwnKVgUIyFZqzyFj51xc +8B3VnRVqowwdW5ba12cZWy04fzwi4IByPeK2djO3St3wWxmf7vEmeUqgVjrnKljwMAEOuN5woTip +zOmmM/WZLOt7xLvM1tXnZRMH0Oc6xX1lihUvnCMvC6XCY4qsw6JywS/FhZXnl45cjuTibVd8cFFw +JM+P7HgCEol8uMnwGT6lXXvCoI9B3Zy5pLGSKFFKoghaaEljVzoCjsDSR4BOhgGtpV/uAJbIIGGS +SIv7u97Kk35RO8e4i5T8hIM0leZOnsKM8I7s8wN/6n9CdoyPZrphS/XeoB5GMiFAyVkssYBH6OXD +kCtfrobqNKsOGJhBXYi4Q2YrhVllnSzjxPIfDAf5MHqM/8VAsoyqQiHiuZGcSHiVRa8pRkzhIQah +qRtV7uyW+VcZz6Siss5X+TiVq5fPfVMnGXfF66Tjz9Y3yNxrh3h5Mr0o47wwN9OMFChLh4RWxfWT +gefgGyogMCildzD0zPaEsq+QOLxcNn8DhUOMwTmWLOUVF0riBHBZcUoVQ80crhO662qXd1nkyNaT +haxFrueRItRAtFxymi/CtXe1pqmsrPKi5A4ZfweOus4cX1/NMMDNl2hlWjR8Gk4GvyHRPIWrRyv5 +VHiQBaO7zJeUTE/dSupd6Qg4Ao7A8oJA0tvoE4nS9y1CnOqI0SEKwyllijtFmNczwssXdMjwmax9 +kQU7EAIvZnSghCqzzFBmZEMD4R8dwMQydPN4QxjINndwRAqnUHbCg3NxYGGEUHXepCSSKVVcUWEu +YcG6DDvaUQ0OPoMGGXZlhdSpD3+gTfEuA2dRIL08ZnAmtCKFZ3NcgHTu0r8z7SrXiZ8HkWGS78jL +gGh4RGBYlPdVxVB8224WusLEMl4choSlBHkASPN+JlhxOUTiF0JqOJ5kDS0Dj/iS0D9erww1syxY +HjJQcCWhRuIid7a24kOLc0v6Oj6DmuNvrr6ecnn7h4lVVjB38QYsTxPQPEkxJTf4nMlinlDSDOLK +kwVLenlgYQwdhx8R71iKYYoYls3mSMS1NvC8AJHKUwyoy/h3z+NQte3Z+bJaBD29I+AILKsIiBfS +9wOSwFjPC1MFJUF6cEhG6FQthFRxtMLYZlhwhIF4dIFZMOcgoLQRqiGkBG0JBac76c+Jwg8lk+6u +doZ4GXeEKGAMsQtsBD1QmEwGQhwZ8QxlUU8YRYUloClG3jlTJfKEE6BZqSyDsZ2ymknywPfszJKs +cFkybAudSigkEkqSsVEqLRu456gYdZChVtLBeRSCqZCi8FC4bqojSYVfIdKAB1/gFj+RgWVmhCH+ +wrywzFsKBmEAOmw2HxYHM9mKntpy+TJMW5djhJYS6zJ8Pyc8W/AWLEVx9VCdDMFSCfRNwoCB0CVP +mFQw4IYQzVnyAwyqRWZSG2opkKCAPnnY4K3cdphcIJeb3CnvyxJPFfxwBBwBR8AR6BUBdhOgE67w +ELoRzhES1FygDxmThTVDtkKT0iWLdxnMxFsNFBXCgW4gTvHl6ODrwxssskCmO9sp75Yw9klOOLR1 +vHYJn8qSmC4iMswZduFVdsBSEIx4cLCreLoZ8iJXNGF/It7IJG8IjxWr4luFaU1icNG6WmVXP6kX +XEH5/BOKCS9lCsOTjxCj8K44ilRPJmAZSoZ/ud7AmlyN+J2FQ953IZtwLQIM1ymebfhL1fMEqaZc +ltATBAmxCjmGrZEkx3S2KyvczK70XBfvvuRSuRzuq+yVIaQsK4jIjrXI+nwgPiVI8EU3soFucSVh +PQFTypSMmAFlmDxoJGGWcVtQlocKuQRSoeXSuEZSsHuR5C+XgO8rZBoixGLZOdhjjI3H2EWht52v +l52qek0cAUegRhBgVK9cR0nX30cgyCWQUjCXTlscIP1PMxGV9NKMQnKCKkkAxclcIPzGMCKURW9O +Pow9wjB4lrIEiP1exQ+FxOjVZaK0I82278Gvo8DgvpIxRCNsF8pQbmf8E4aElsTLgmWFnrp4PZS9 +ABnmpJbwOZOC0I94ekJSCLKmB96UNcHiY4o/LCPR2FI+Hz+R5UfCyOIvhslLWTwkbCyES53wtIXE +YGFJIYOqXJFQG0thReaayAOD4CcKVbFxhPjQVAhOxEnEgeY5RLiThwYpSy4BO7IKbC4VZukPxlRL +pkLluUHMJCueV/ifoXQZJO7kGYJIihc3HezqebVHnFCCPEggg7wwO9Vn04VcY2NdfdiCQvSgxBVx ++QLDMnOw2wML3HkvjV2NlplKeUUcAUeg1hFYDI+WhCf0v0KaekgvHyT4AU6BKXo6X+ERuEXGNoPL +IwwDM/aoIRVx+YLrFP7K7KJwKjmQgt49HKSFTyEpVtQQryOloSASidMky3Dr6hrrGiBA5QxYSTzS +PBsj6U68QkdwAtyRyzV0NbCOBg6CZjgJ7+HuCb0Ju8lbKlKvwHbiwAm7c8hJ0oQtbSmHkimevZYQ +sMZ/Fu8ykJp4rEKQDKcKPQJAkGUrBEZoqbmwf7ARpg5D0dSCa6FC2caw5CeVae/M4whTYEO2gfrx +FCCurviJVLUz1ZBhD32qwZu5lKV0D7aMQLMRQ6OUL+/DwqSAKNtF4ZFzqXJR8k2eYMAqZTxyWfUr +jxBcWEMDaSUHWXiUy2ZXrU+N6OwovT6IApbQ8cyz0y741b2vTpWddRc9uh/52y9oHkcccRwLgBeN +8pAj4Ag4Ah8ZAmFQsaf0wEs9gTJ/oQ4O8bVUklAQJQj36dAugYKhvieC40UB0JnYIgW2kgU0jNMy +FyfsKyOLdfirYoaTCD0x6MsyGdgRDW6UvHUqriUEJcOV4iuJv8dArpjoAX9K0RQCnYTtINikF0qF +9cieVUr4nl2pehb+QlzkJBOILGGF+cKOu1oNaCTFsiBIULhVHFMuRkplAa4Qp7i2etUy7QkbCWXK +6iD+o6ZiTEJmYWEyqFf2FISDuVhc3/BuKxRGiWHtLguHQEDoUZ4OuBL2WuBNmBwb0MomW2Ffw5Ts +xdsdtk9sE1TDI4ksCpKJUC6pQV6uoVRqIxQKL8sGwtwJIep0N9OqPIzgy7KoCcOGpqbGwYNyjU0N +jU2sWco1NFBPljAxpkvt9Xhjbv3cBTkGsslwAA/ui9Sgl4PYY065ae+9N//Ki6n4RQAAIABJREFU +8cl18Df+8Yrbb31t1OgJT789oXwmveTtakfAEViCCMyZM4dNdCvYD4GO97XXXhs/frz0lsvnsXCf +eiGexR30gGIWemy1RRR26Ukb3E0hSPKiU9bxRpHD2h8oSugGhpFxW+lMYR1xTyFM1rtAK6STjhs7 +Jc4wJCv9OjHYZejqcSoDocrgq+QgmQoVCiHX1eWEq9J5SI4dHRjA7JId7RkgxbGEmWTaU4+wPDUw +u3Aebh78mm1oIDX1LlwiyYWz+Z9/zPJCb2EvXxy7TLqxrpGSoctQCSpCSOpNDpTBJbO7rtBcd4qP +sfFKqCx4khXGeJnQoQxtUyYznlI0l87lsa8CFwHJCzCSH1colQ+j2AInniU1kwLxKcVt5C3Q4LrL +YmJZFs3aIDZT7Orim6hwZtOg5qbmQWyswCBAlgW+sGVTI5/rk/Va0SHIyu2SO8GEKrLgLYdspRQZ +DoDID4Y9ifjqZ28OJZf70rvt/+xYZeJcGdW2Y/7cDy848xTu7AaHnPX8Q+9hBrYWi8AXly666CLd +R/crX/kKzx/sUxgbuOwIOAJLCAHeDuejoXzriV6Dn97FF1+c+FAaHz1k975Zs2YVV+Cuu+468sgj +2VaXjT9Z+rDlllsmbHr7aaOHtukK2M/o+OOPZ7eyRMKlGezfel2rmRKq9LKhq5Vgjyy0FNwa7YWJ +gheEUyUsHAPdhDc/g18CORCCNem9hbOk/4Y6pC9nSk9W7jAxyjcqxSWUeT3ZxL6wkb0MrpIlJBry +gKll9pLVvgzzig2EjDuYTUOtUHRHV1s75ciuOtQH7mIuVNhFJg3ldVLcxXAtob4QIabkH1iSrWZz +fMklB8UKAHIJ7DAYODb4p8Kk4ZDxZ/FKNSAsKIuLuBoqAF+SkCxIJ6OoYoWG4vBWcUXlCzKwbaBJ +8SkpWnzL4MUyjwsTUyXUSqhsAcH7L024oY1N4lFn6xobm5qam3E0uaiAG862eKV6F7RKnAGYClhQ +BWzsQIMc4C/oAmCJFJUH2VcIwmOTTLYxKt4/ge+88vmXBS0tvzjxv1sWzNt+z4M22253Crvilz/+ +cNaMXT5/ePO4TbOP34NZcVqtE/v/TZ06lR9nv6rIBrx81pQ9eGUAwA9HwBHoDwJDhw69/fbbdY8w +9uk87bTTLrvsMsuA/Tt7WxUIEe6///58xQUuvPPOO9kg8JVXXkk8Ils+xT/tCy+8kG4Ekj7iiCNe +ffVV6eg/okNmx6zo4m7XohICXSzdraQM3pMEw4EmSD15hn6cADkLRTKMGTSk7GFNZU7IE1KEkEgt +fickAAPwrEExsjhIDpyZdoZKEaAmIWPp53u8QZiaLGVqU17ZzKXZIyHdmZdRTVbdUD5xMBhsKFOG +sBpWvNHZ2dWab9G649FyKdyJYAITCTKwWOA8IUCmEqmbztsK2afC7uqMyEoVJJ2N/IKoXD83VfZl +6mqsZ18h8VCpNBWmlcDPQpOCARpWWsntx0TM4DhGtmUZsExWyiVmMrDjkKZG5jWzjY0yBouby57C +PAIUdfqYk5Xcm/AogrzYo5BEE4azkqieF5u8MgO233zhhRd4hOSzSiBsmVCZusYGRgYmbrjFxWd8 +67kn/nbWNY988N7bd/zpkuEjV9vvmFNve7GTD7FpnS2VCfwgf/WrX7Hbp31Wgs9EnHjiiXw67YQT +TmCtLwn5Ftt666136qmnkuryyy9n43t+jbjIfNqJfUHxaPmqzFtvvcUnn+6//352kGAT/I/we0x2 +aS44AsssAoxy2UabbF4dP8WyZ+dRRx11ySWX7LbbbsX1Z8dQPhoBiRLFT4/dQ++++25c22LL4p+2 +2lD0xIkT+Z1+hCRKTWSjA62QMlziAkoolXawM18HDRTUo6cTlzgZHZUZS8lQY8UqcB9K6edlfFj+ +hIM4+BNaRAFPwpxh8LZAnxAkxlADtuLBynswbHogA6lwlryDIvwmc5/i8LXJ7kbsUMS2A7KzYD2z +rLIMSThehkUhYaFbvlzKiyGMnYZ3QOR7L5AnA8cI4ZbIep5Q+Qw2Mqor1YZI+U+uUDZHClOTGRxD +iFA8bpnOpdpUErqWS2S2kR33GasmtficMg7MOVSEFBQhfjw+M8O7TIcOHjyUYViuhc2SZKuFhob6 +HGPRPQ8lkizgGeqFrBO6Wk3OcawpYyE2iGVLq0o9L1EepUR+MzfddNNjjz3GdtXjx4+3evKdNeZ3 +O9bdb/SG173z9P1nnfpf895/k1u28UE/eegNPPiu3r5Xqh+E4fNM9pNmc12+iXjvvffy7MLG1ux6 +z++Np1e+KbHDDjvggPJdwwceeICi2bOeHzO/YQwIwqyjR4/mi99M2/BDtbq54Ag4AmUQ4PujjM3i +kpoNn4Xg+TUxzGuxU6dOHTdunAUZqkVjQROKf9oaxScU+V4b35mxj69ZkqUsLDLJtNiyrfMVTurF +GqcKyqEXJr5AwyTjgAjho6AnJMTJGUdPOFD22g3uKnwl7Cs8LOtiWAyUYTEMjqmQKBSIewmtyQgv +83cdwjHCrZIqrG6Vl22kXDiUGspyV17ElDU8vGWp2cI2DGwKGcvAabPUiUOID5+VtBKkFCQhTbIR +FpOddNEiQJ7kSe300mRFD1yIOUPH+bwkU2dUPG/ELF85DVCxkqmTCVN1IiFIKgVHIvC+STbHGqKC +K4zAQVVV4MLjoCr1bDa9GcTGxUniWMvKhDh2icp8mBAP8rDDDsNH1IL4HClLjQc3ZXc55ryrj//U +1L/+Bf2ELfaY8onPInBnss2liY2fE27o2LFjrcK33noru/sybYOGDTwfeughPjPOTMyZZ57JVyP4 +1Nqxxx7LwyyxuvsuXxXWcV3aHk4tJKqxlqELjoAj0BsC9KjMdPKQysOr2lx66aU8LvP8yhNtyVR8 +uDse7EFGU2xZ/NNWGxzfN998c8KECfGDeHHypaARPihfTGwgstn39PXS5SMHL42OuHAEMhA2Er9M +jlCM0KeYhyQhBeuBwtBu4FgihEDFVaNiOB9MIIo/p5ODeHqsHZL50XZ2wYVuSRu8y5AB64VEG5bR +klmgR7kyBCrNOKjkHLZvx+vkJUxIrJ43JoXdYVGhTDhRxhgFEg6pAH4MtRH/VEaaxWFlTBUr6LOB +hTz1DcxciiMdEgV/Foc219Dc1DhkUNPQwSuNXGWl1VcbsdbYURMnrbnOOmOnrDdmynqjJ689YuyY +VUaPHjpiRNOQIYzPBnhkEBv/suRBlB1mEGtMLi/Q0EseWgHOglc4VNMTWoJ/Wd3H06uRKCUxbMs4 ++ODG3KjRY3c+8kw0Dc1Dd//62Wj4V8/+FE0lvuuCGc4ltMcUCyBojfEvGUDmC2scXDhfJFU9JdKE +HnnkET7lrZrEmUFgnqBZDMXwL4AnYj3oCDgCxQhAn/ij9jlCJkqYHOHM180Y2mUqFCFBkzy5ssrX +siK25HLf4p+2JjnuuON42GXEeOONNyZ/y2fpCwv90bgbTdQDVoljF3a32AWCFNKCH4MvKJZBCTuh +IS1dmMQLN8mGukqlkqeI4SAJf8U5lXHakAE5y/ojGVENb4XCkDIwKp4jvlxWCINBW2ZRmbfEJ6QE +8YElXhbgMlwqX4mRpcGhGqjljU1qQD3ZmV2qiAec7mIRbyrVLvu1y87tMn0rLA/fcpHBmHdBpEiU +Ms6LcynXwuiyDPMywEzHnuHFEbLJyWuXQrbZXENY2iRZFQ5Djxqa3BM5AH/L5FkmSgsOl1yiDr3p +S5hWpMJ3LJ4fJSfGdVmMPKhJ1vtsuccXpz5686TNdh61xlgtpG5uBoe1ZIE89DAbyvDst7/97fPO +Ow+bESNG4IYyzZmwZwYUmmRQ6A9/+APfL0zEEmTdxNVXX423yrwpXz1k5LnYxjWOgCNgCDC++tRT +T91zzz22Uo/u14ZbGXZiwmXHHXe0hQuacP311zcbHlhffvllhossTxOKf9oWhcC3h0866SQemvfc +c89YvzTlhTyq/WbJbrekUugQLhFSEV9TJKHbQJNoQnbqcQojybfJILiCJZGBnAIryiIeXgFlnQ6c +ybCpkCKOqBCzbK4OZ8lkJCwLxzLhCNvBYKREjYKXSZiTFFYTLfsCSrwc+JmBs3SIGXdP5jNl93UZ +tpVqw7WyVZC+0Sl7usvyI70QIVR5+4WRZDZJgh3xGtkzkMHf4Mqy4y1BGZXFaV3kqaLn1oX6lIwR +C6ld0VFSWWS1iKKPSfTOLpIyBGJ9LBdbDrimt/W6FDR5ZH7cyJXWWEMGYzmO+/kVg4auRBPSYH0q +3T4qrPDS8KJnhmevu+66rbfemvwZTTrggAPOOeecO+64A8IGK5bjQpA618LyoieffPKggw5ii8Hx +48ez2IHPl7KkiMFessSLZfaUKGiYDxQvWoiHHAFHYBEE+AT3ySefzOgrPxYO+ku+7wShHnrooWr3 +4osvnnXWWRY899xzx4wZw+Mpa4vopu+7777tt9/+2muvRcmw8CJZ9wQSP+0etfTyvFHDr1sXK5l+ +KQsLebS3gos7a2HBiAkkSOKgCd6kUCQGHLCf+qicY+oQz1BoV8yQSQ3xMFAbqI8QXqYMcspnMGVU +GDOpHfbiDYa1SNAstBriw3hoGM6VMshPjGVkGJ6UzFmagmObCdv9Ba+TcqgxRTMMzDsi8DP5s9aH +r4sJXTOSzJuorB5qyEGfsnkBm+7KAl4c0kJvTgEk5yx8GQ4Nqlzm3Eczcui7pcBSdCSUFjShKEWA +V0EOZx4nyxgXJ++jht9DmfdHWeazdua54dnRI0espRmOHMFsaItl3jb9jQmpZ4cM+aRpEgLu4yWX +XML0J6OyrC3iLVJGeimU8SUeWiFXoniHdY1wMNDEkC/r8vkGKoO9O+20E8+2P/7xjzG45ZZbGHQa +N24cyRNFeNARcARiBFhMAH3utddeqmTdO0+isUFCvvjii6E9eBTG/dOf/sRPjDlOyPiGG25IWMbB +xE+bKH6/jCeRFU5tyQHhOPkSldPr7nbYfZedbmUUd9+xJpbhPFIVND2kokHOcBQMo8QoIXUBJVw4 +GKMNs5ky+cQrLXirwnbynxxiFP5IivCmJuEeQSZFKRiODSaSBD4TS0kv6aQCEHCoIYRKEbLaB3NG +eaEHIsRvZkC2QfxL1ujyfmgYksXplLdKcE3t0pAWlYOi58I1sOiZshdVDEyomNXKaIqjtBKqt1gT +iEXWoJ7fbRs0rWXQtNbmiSunTv3SVgNzDQFJzb9khtzDxx9/nNXwLE8oacC4EG+MsXpI71FJm4SS +28GwEqS42CSs0ccr5SAH+gXqgP+ayM2DjoAjMLAI4DJNnTp10qRJi/2F9r3cZ555BoeYg/X2DAvT +b3DmgLkpRbsgJRn44uw/PTW9fciU1RumjM5x7nspZsm+gCaLQAExDcRyIlarUjAglbyCsjAziSUu +nENCCcWH2mLGxWhWsrJHXNmwHxCjuWwZDxlKYrIVtxSOFHYMHqcsTsIH1cqTTpYfCXFyyOsnYeSX +wWGyzIT1tWQqBBk8S1Sgy3JZACU7SrCDEpFDJqYrQZlqttBi4CSFIs4vobGgCbGxyRobnzUq1iBr +kCgVgqLg3WbagUcb3CIQWRGVCVZiyeSUCEfiSrJDSjHIpOWdFnxHzEomL6kk1eqrr14yKqGM93Yw +Qk3YeNARcAQGFgHojQmUgc1zKefG3nLJXpJ+p7gLs2ppP2gGC4NhdFFSCtHJxKcIGk1iGEt2XccX +FI9Qe0GhRERes8RlZHeCdvlyF2t/pFPHXtdJSraaK9xYkHV4VW1koDf4vqz1EcoVCuVr3Dlok/8g +TuFOyY+R4EI+VEwvJ752U5qgNuWDBkt/BQNGE/YWTOgTpWhsfDYDlKZXwQoyfRljbLLt8uwWjJMt +xBIuCYE7xegu8yslM4+vpaSBKx0BR8ARWMoICMcUF6nKBIXEZmaAoGYFTcgNDQe+jDKluKoEoUbZ +fZ4Posl7CdjjLiKw9x+KOlbAsmu8fAuFM5OfstJHSBb/Upwi8SfJhxiZ0Ozk29p07vXshkeGYinf +HMPzlHdTqKdWAEE9Sz1b/ckNAwv2S+hvWuzj/HsLJvSWRPUWawIGcVQsx1El7VGaXmU9a0KN4pzN +y/i2Bq0+S034qMpdahfoBTkCjsAKg8Di1xmVuVQ6uwQhxd0fUcIhqJRQxSkVKkWnAnrhWjprGbBl +PZCwZ1hAJMwIH7LXgnTlfIC6UcZ4U+mwhhNODW96aiboyZOzCVphglo4AgVp0DRqE59jm1hfLCcs +CZa0iZVmY0Ici6z6+KwGsQZZg4moWKlZBcOFxnFQjVUTl5uwIcjUgs4lyDi5H46AI+AIOAK9ICA7 +uPYSJWrtdhHKmKlNbICGoJzJITimMCd0hxLiZEcDmA/yIRoTWQEknqi8l8KHwLpkZFeGeUnb2CyE +qqWTlkMpk7MKWrQVp4LUO9Qc+1hjyhDf66k4CaZkFSfAhiPWqKzKklHFBrEZsgZNMHvTx8WpWWxs +ZqaMBdKqgTyXhJprbLGN6etbmVAuPVwR18RlR8ARcARqHAE6yj4hoJ1vgk7ilBgobyFAchZU/oEM +dTVRgVkDO2LDl8Iwllc1YdDAVWRih7BlONDwl+IsWwQtnShkjoRALBpNYpYqYGyxqjF9nERli0LQ +hJYkETS9WlqsCbEepelVCIqFN8OCJlhyszeNCpxV0CRmhgB9apQZIKjSouJUxPLKT5gfRfTDEXAE +HAFHoFcEdG1Or9F9jKALTrAOGpgPJQKZCH2GoVo0zJQSpd13YEkhSNRqr2dmTK1b18w1H0ulShKq +Xs8aJCsEk80yVlqsKu1s+aiB6UsKxUWrWaxH1qBlGGtUqQamV8GUCZtEPmaWSKVBS2uxJhAVx8Yy +NgT5lgzD54wjiJ0fjoAj4Ag4Ar0gUOH3R8lNe1vOMJ9mjqwcpkJsYFEYcGiQhAhQowpmj0GsNO5E +r+ViqYeWaxlarGriWJPVRoNkonkSNEGjYrNYJknCQDVxfYo1moPq9XJMYwljoUysJk8UoWnjHEwT +ZxXLmgOaOMPYoDHXlctyp7rm5MWX9cMRcAQcgRUSAeni+KhIhpWrC7v3fl0p74/26nDQ1RazS3Hu +2iOrcZxEZaW0+Gw5aEKClhaZbl0L1ViCxrIqqz2xFlTBgppQS4zLQqOHKTWrOFgsa27FZ0tLlMZq +Wg3quaTGojRVwl6DXEtx/rGlpk2YaRKNio1Nr1GJnGOlplKDwY1dKzV3DmlMtbSkj7/o0aG5wtMS +sX44Ao6AI7BiIACJtnWmhwzODGvKNNVX6DNk+8W/9LNQUQI+U5pgBmhMJqEamNKYzwSMMdOgKbHn +IKiDvdggc1Z+1fpggEbPxKIkVktEicBhBggaRCg+NBPTW87FejR6YIyg51hjyjhKlVQytkwYaFR8 +xiC2UblYY3mKdaiVaRBMEwsq29mElZrTq7an12xNv51untva1ZJfeCuxKXkUo1qsKU6oNolznDCW +9So0E7uiOBjLcUKTVbBzsaA5mL0GF3u2ytDy+CBRSC4n/ieKpqs/Gxrl4CFD1JgoDnLm3Jqf3Zlq +k3at+2TaOaBe+BkFOVc3qDk3ihw0Ez0vtnpu4Ag4AqURSKcg0THD61cdmh3auPhermQmWdkxr+qD +H7P2CPqrRk5otATTayxnDo2CV2A+ZBXsTAeEjJ5YsyGoaS1KNZwpggNj1siozNliEThUo7KdrSam +QdBSEoIFNUlsE0dpLDWMDRKy1l+ViSiCcW4qJzQEExpNFStjjeolTbg0FVS24iwKf3T1VDcbaY0Y +3Dmnla2OzbycYNiqYMHe0qiB3nrOBMPBPSrcSoJxWm0v1NYqrHIcjO2RCzn2CD05S4uyElW2oCbR +ohMVSGSuQauD3m6StM6Z09Geb2+XPSzl+391dXypDeP5C1rqOprWGDsWGy1OzwtS82e1vsgWzjR2 +/vFSNb8GeQkMQg3/qLa8CsZX5OoHrTFsRH22MdG0tCZ+dgQcgX4hwHAunuioYdlVB9c11VfKo+XT +0UEk+pFijVba9AhoSJXQqJnp6QXoQfRsOahgUUqiakZC9BgQ5IxM/iqroAacObRoBCyLz1pKfMae +oJ5Vj6yH6UsGe6wW/lX72BhZa77QqKe4hFlx0CqTyNaCsWDG5KOyxpreglZQGTO6fl5HampIrdTc +3dLe1V5wqCxFaUHRJg7B5NKmPTZqyZm7qQf2KgTOWyS1Xprefb2K4vMiCXoaABnGBdG0aEf8072c +2eEzaKRYBK2M2ZOhyomcNagVACwEKhZwqwO12dM+zM+f39KVb2vJo21uyLW0tWXy87pau/N1syau +u66WpeW213d3tL7Z3T07xzfnWeHFXph82iYUoPTJh+TZsKurI9XQmBq38kaDmwZRUIxDybq50hFw +BMojwJwow7l4opBoPaRa0cH86MI+t4850F/QrRQbmx6BWGwSGk1ieo2lL6BDIUoFjVU5PkunHsyw +NAEDMiGoWSFoxeysglZGSy8+k9aUyBrUM/qgKJwIaolmoxFqplEJOc4hlotziGNVNk0sxFHIemhu +yJZtQi5jlojSoJ75OlxDLj2seaHOClqoCpIBHuvLg29JEPTG6dn4DL0dmi2l60EQQQHnrAIa1cd1 +QCYTPSNQBEcooo5zONJ4ih0dabahDJ9L6FEXsalWxjLUUrRQpTSqITthy4Efn82uOub911+f+fbM +lq7WefNbch0NQ7KZpvS89q7OOa++MSsz+2Obbgp/h9I7OnOd7fMy7+efbcikcmGQKJ1lvbQUQu1h +Vq6NYLoxNagxtcawN1dbaawSNmfDRKvkZ0fAEVjKCCx+vS6/Uu2J4pqVVGJgegSCJExoNBPVqz39 +Gh0QZ4IImspkkhOlZ+su1R69dm1aBDJ61ejZskLo7SAtUXaOBWQLqo1qOGs9LWhmpsHebBJyIiuC +vWlUH+ILNYxlKzQ2iw1Mr5YWVJvE2WxUnwgmjIuDVhmQ11gEy8SEREI11vur9pwTN1dtLKFmhQ1C +b4cZW03IRA/NXM+WHDOV0cNqJlMxPTQfZDJB7slMZMuEtPGhzLrm5Ml8SujdV16hOcyeO6e7rbup +oakxBzKp5596atCQIRMmTYK3SUieI4asO2PGP9KpNpzOVD0f8tO3xXhsTHW1p+pyuM7s+ZVa0Jaa +Me/lUcO20VpplaiGBv3sCDgCSx+BPq0z4leqP9e4fiWVGJg+8dsmB9Mg0CuppXYinNGQXIMmI2iU +GdBDxbFkawfJkfVsAkHVcI4roMHeNOhLHpaKWJWpmOUcy7GlGvemseQJIZGKWDssCo3VpGSsKc3S +NHEmpqxSsDxV0LtQMk+i1AbQkDXImZuLXpEM6gIxWybEchBUgbPBbnozJgdky8cyN4G0lo8K5pBi +o/VBIBMNaoaqUdkqQFZxbkqlY9aenO7sfuvVqYOam+cvWNDSumDIoMF82La5sfHhe+/nCzPDhg8n +N47BTasMqh/b0f0SDYrNMLvZjVG+YC+f3E0Hf1QGeNltOpuam5+qFaM4u1IXHAFH4KNCgH0Ykv1U +yarQWWivEceWVGJgehUSZ4L0GnQBnC2KVGi0d1CZWARlTTOz7kONVY8ZejsIqkaFxJkkqkFQOSEU +B7FXZcmo3mJNb8WpJg7GNmQeG8SyRpXUoEwcZmz6Yo1FLWmhTNFEccu0AirrHdQkevdVk6gkBnYQ +ZTJCwlJjVWmZW8OLE6LUAxJlrJVWh0Ad9NC0ekaDoPq4OJJbBVSw/MdOWa8j3zbtrTf58t+8lpbZ +c+byIaK2dr6nk3novvs/8x979xSeWaVp8rv5l8gWYHRalNFmfFBxSQOJsjkGx7zW99s7W+vqBgVL +eRyhSla6WPjhCDgCSxEBtrEt0fuUrID+XBNRJZXY6K86/nmrzJlYOg4EPScyVOKkn1JBzbBBo2VZ +iXEOmi1nFTRPlbUmqkHWoJ5RWjAWkBPBOLnFanINqr1pzF6FWG85x1GxfZyV2SQEszF9scaillmB +OnOP7KwCtVWlCiUrj6UexCKYjckqxI3BLDVz2h5MiRlCnIqgkqjyKMYcypoqxGf0ZItGc9CsLDf0 +WjEynLDRRm35/LzXXsvV17e2tXV0djc2NrW05d9/792n//XUhhtvpJUZ2rzGzI6m7lQL18Q/+dh8 +z8cA5aO6dSnW/OKPtrTNnt86raF+ohVhCLjgCDgCSx+BLL1I30uljyj+6WrHUawnW7O3zkXLwjjW +WFDttT+yDBHosFCSFhlBozjbYZeAxmQV4oJU5myC2mjmqkQT4hexMU1so5Z21qzU0pRmbxoTLMoE +zcHOCX0iaGbLtVDyolRZfCvtShOpNJhQYlysIU+U3G5aFPSmBiwJUqUxKIJyJ2eSJM4EoT3TWz3J +hINyVcPZDj4av+7mm7fMX/D+9OmNufrWjo7GeoZ2G3LZ7L8ef2yt8eMGDR6McVNu5YbMqNbu12Ro +NxNWGKVT7Z0p3odhkZE0bb7ykOaLvS3z8tNWTgmPchgsLjgCjsBHggC7w8szdd+PuKeIUy1WrwYk +4ZePrGcVpDOIugNTJgTS0oVpDlq0prK0JmgsyWPBggkleosyORawjw0suSrjs0X1lkQNEmfLPE6e +sFmxgwkEuFhuZbHSQIijYtkMioWEmT2NYUkUBxp1CkuSKPVRNlU/FZlDZaI4tETyUQGNGqBB4NzQ +2Ljh1ls9cf8DH8yayVeNunO55samBa2tuc76Rx7+60677UpC6tBcN7Gz7jVyYVURmckHeiUixWtH +zJhm+Vhvd6qxPjU//3YotnDCxIrWCvjZEXAElhoCfDetkrL40VrfEadfrD7xaycTNBzWKVhupkSj +sQhx92cVMMHSqkAOpknIGuSsAmYqJIIJvViXyrM3vZWuQpzWck7Y1HjQIDKh74BMmzatsbFx+PDh +ZZKQLa3FMqc5YaxBzhzqkmID+XG2g6BqVIBBOZRxETDTWM2EPFVjxlokNadyAAAgAElEQVSl5iFD +Nthqq4dvvy2b6e7IdDXU5+BRinn7jdffeu211ceMwX6lpokfLLi3IcuCIplx4dcpE6UM6qZl8VFX +d+qf98waM75xeNNUrZtdLEFKt2AstDGS3NExaJDMpxYfJJw9e3Z53IpTuWbpIzA/HKuuumrfi54z +Zw43d+zYsWWSfPDBB7NmzRozZkwulytj5lFlEGCMtExsuSjrMhJGi9WrQXwmB4J0anqoHGvosOyQ +N/PCwYemEwJBlHbEQbPUWA1anglBY80GwQyoockmoLTLieX4EhJ6ohK4ebBiBGbMmLHXXnsde+yx +e+6553e+853y+Rjyesu4LxzxLbb2kxCee+65rbbaap999qGUn/70p6Si3yEhZtpUOKPU/JXkAtvK +eiUVOA9Zefj4KVM6OjsYnp0+8/1rbrgebiSPpx5/PN+WJ3lTbqXmzBj4k3GiMPgCJQubsrdRXYMM +6j7z6Ox33mydl3+jozPPlSbYNHHt//rXvz7/+c9PmTLloYceSkQRnDdv3le+8pWNNtroF7/4RXHs +Y489ttpqq51xxhkW9fvf/x7Nk08+iWb//fffYIMN1l9//YMOOuj55583m2VBgBK22GKL9dZb70tf ++tLUqVMHqkq//vWvv/Wtb/WWW/nY3lL1XX/wwQcfcMABRx999N577z1z5kxNuMcee6y99trrhuMf +//hHIrdf/vKXJDn55JM/8YlPPP7444lYgii33357cj7xxBM32WSTr33tayi572usscbGG2/8yU9+ +8uc//3lxKtcUI9C/+dHi9NZrJKIWq1eDOJU+UFtCgsTa2exVEycsI1sqtdGgKRFMLjaIo2LZiouV +sWwGLiwdBK688kp+9j/60Y8obsGCBYstVG+WtTcEqA4O41APkhyQORNlB49Nq6yyyu233/7hhx9C +Tg8++ODOO++MEnbE2yMhlsicNSEaCkJDEIpVJdmOX2+9d19/Y+aMGSNHjDx4n33YA4LNAtlO6fUX +X5q0wRQ4fXB2/Jz067IpYEY2MOIsLmk6lW9NicOAY5pJtbXPbsnPyNWvqdUj85IHHeJvfvObww47 +rGQszwE//OEP//CHP0CoJQ2am5v/8pe/fO9739PYP/3pT2jMEv0XvvCF//zP/zz33HP/93//1/TL +gsBFjR49mker//mf/zn77LMHpEo8c3BPe8uqfGxvqfquB+SRI0di//Wvf/2qq6467rjjNO1tt902 +ceLEkvlg841vfIOo888//4orrthss81iM8iYZ6Cf/OQn++23H3oa0vvvv68GFMTT0rPPPrvLLrvw +hApVxwldLkaA5+diZb819Bd6JFL2qJNlmF4FOhcEPVsUQQ7z+RCKNb0pNRWdlwnqMWgwPpfJM66J +yVpPTRUrExfuwaWJALeDh2jGryhUO3o6mlNPPZV+5GMf+9hJJ52kUffff//nPvc5HsDpPhgh4/ZB +ut/97nfpX3bccUf8CTRvvPEG3cpnPvOZCy64gJ4l0X4wwPtceeWVIdR8Pq/+KD0Ufg+k8uKLL6r9 +I488csghh8Be+Hl0ZFApvdK3v/1tBI7LL7/8ubfebM/nZ8ycceOdd+LMorzlrrv+cv1fSII8b+ag +/zvtlQtPfvGev7yXYkF9XaqtteuqX75+zvHP/ebHU+d80CHreNOtD/71VnhCebQ3Nh0xYgS17e1e +UP+11lqrt1j0PJ3wiKCOzttvv93a2oo/GtuDBgPC2r/H+mVBbmhowDHlRmtl7rrrrk996lOf/exn +eTJQzfHHH8+94FGAy0TgKYHxBjw8JggwiFuLPmdce+21P/vZz4h64YUXaEi0MbxeBidABmX5WHI4 +8sgjP/7xj/ME9sUvfvGWW24hycMPP3zEEUcg9OUwkLmhDMD0JQnNVc0YMGDwIJHk6quvxoDxFdUj +J0aMaTy0EJp6IqEHixGQh+4BPLgZHMUZltdrLGfjJwRTqt5i1cbO2nNZEMFoUpUETTBjEzQqLiuW +S8YWX51rPloEDj30UH7zECTOotZk7ty5dFXQ2wMPPECv98c//hE9j9WXXXbZfffdxy2+4447ON90 +003//Oc/b7zxRjpNBrVoFQxkIZDPE0888dRTT6GJn8DY7QjL0047DbbjUZ2od955hyLoUg8//PCL +LroIe9rMeeedB3njolGr6dOn48S0tLQgkAoZUs93dKy/2WYd7R1z583L1efqMunpuALdqW8ccTQ9 +183X37/trpOO/uHab7w0/80XFzA5+uRDs7o6u7951jp7fHF0vo1hYlmFtPr4LL4gDGrgx7IpqxGA +CMKAIcgEmtl3333j3EAJhJmB41kk1i8L8qOPPsqtvPXWW7kv1Adkvv/97+Okcvz4xz/mGQgl7hf0 +iRk+K4Ofr7zyCrdyzTXXpFUQm2gtaGhUTCUikJxni1dffZW2hL3iUz4W9HgKofGceeaZr7/+urI7 +D3knnHACGfb9oFBgP/DAAzXJqFGjvvzlL1N5HWwvzofHu6233pphia9+9auJ2JdffpmfDC02oScI +69OAyfmSSy4p8xxWnLBmNWExw0BfvVFRIuPe9JhZlAnKYX080xrssCSqsaDlXCz0ZpOovweXTQSG +DBlChwipMHtkU33bbrstj/9sGIQLcu+991JzBvpYcXPzzTezqkJ9iOuuuw5uoCukSeBaEYvXwlQi +o52wHYI1IQQaCf7rnXfeec011+CX4B+Q5O677yZnnFcSPv3009AkPR1cyJQk/hAVIFadRc7wKO6d +Bsetu87wEasgM2bCKPLgQYM22XDDOR/MZFkI1P76cx23Xv1O64LOl5+eSw4vPDV3/Y8Pq89lVluj +ccRqOfas72hnI/s5EyZMIJaDfFQY8DP+yg033MADxPXXX/8f//Efcf6Uvvnmm/OYoiDEUR+5zHMS +/hYkqoOZDFdw77hNTPdyj2wq8aijjsJnZRkOj0RQGjeOoA5vFreW+KJw3ZhTZPBjnXXWeffdd+Mo +5OJYWh3oYT9p0qTx48erPe2WYCJtmSAEDB0ySMt8qJpdeuml0CqNjdukTTqRnAvkKYc5CB7yElEE +42aDz8otVhuaLq45YxXkr2M5xWldEyPAtE0J9zG2qEame9Lk8Q1D05tejS02LrqkMjYolouTFGuK +U7lmeUSAO8sEFRNFeEj0HfEl0PaGDh2KBkfkmWeewd205YuwGl2GtQq8RhyFnXbaCfZlWghvUqP0 +DI+iP+ecc+j76HPxQuh8GWGDhnfffXd6ZzxUOmL8TlbGYoxGq4Gg7R8eRdADP3f85HX4KTAzCpVS +xOCmpnx72/S3p+O4bLbJFnMaHthwy5UGDWFgNzX7/XxDEyM0shWDMGan7MawoHUGu9xTkGYYX/IA +yqwk4omByTl61cSaXjw2lqhgwNg1I+E8VQxguVVmhTvF/B/V46Zwu9977z04jHtKtpzt+cNuvQlW +bnFrsSgEbr0GixOWjOURjUexOIf+yow24yAy16sPZ5acxoZ7yiMCi4bwO02vAneNg/bP+rvEGDIg +sBBJpycwZkkazjqLmJC5lTx9ctCwGctJJEwU4UEQKOxpsKSxoLXZEZdlyliIDcrIcZKETOfCkVAS +LJObRy2/CLz55ptKWvSVdCW8/cK1vPXWW5AiHMPD+Kc//Wk0jN+y3pK1ixCVjuwxaPnnP/+ZkUli +4VSGsBhqw8HaMhywcqIhYUZviNdLN8rgLTIjY7iPLA2ld+OgApzxG+BX0jJOSBIaHp4HGiqDt8rC +EGrLMXzkiPqccE9YkJtqaW0j+w9nTaeDm/7O/LUnjVlr8qCRoxs6u1KTNhz8/BNzYeH332md9nor +M6ZCrvOnz/pwuiTvjzPK8CP+pc0aknyxB74OXj7ziCUtgYunh2Xwx4WvzET4Mcccw+MLE5l6RxA4 +eEIqeS2xsri1xLH9lWmBv/vd78Dqt7/9LQ1GOZUm1/cbwWQ/t4DWVVw0DZinN8ZviYrvrzUMGiQ+ +ayKhDg5Tn4TegmTFtAUPmqZxoTcEKnx/tLfs+qJP/OTsZlvahIHpTVisgVm6UAsIMGEJWW7IuOic +Oaeccoo2D3oouh4mgeg0d911V3DAYcUZhSxZb0KnxgoRhtqYRt100015ZscNZQrtwgsvxIaRW1xP +luMyVkxCzdBanZIoeUKiuDv//ve/d9hhB9wyhot1PgmHmEyampqI1eRQMuxIP8iw4TbbbEOb17lS +9jkaOnjI7A8/hBd5Q7Sjk31z2758yJcvueySex+YlWvuWGfjIdvvNWrz7Va5/vK3z/7Gc6PHNY1c +o4H5UZYaPfPU1Et/csyfr72e3PSwqiLowQTe6aefDgjAwtwwQ508XrDghRUuVInZPt6LYFgSUv/7 +3/9O5fGte5Iu/IsNzwTgs1AVJMZIeZjgwYUizD9L2Hy0QYYNqDaVZJEXk6A0AG40Y9TcaO5d+boV +t5by9uVjWUFG++ExjnVMUNqwYcOw5+5QNwi7fFpieQhgloE5e+wJ0nR1xROPOKwDYnEcOetCpPj+ +MqILc9MOYUTc60Qp2DOvDzIsd8dlp5Hw6ovaMLLNkyReKQ2bhVGJhB4sRiC93m6H3nvZGcURrnEE +liMEYFAOowEW3zLfgxeFUgd19VogV7oVWIF3V7QvQ4/MQ7d6sWoGwQwePBg3qxgBGAulnWEgZBxc +MoF68TA44EhWatBv0osxi0ZvpTxH6WRLcqL0QH71xReffeyJ7jTM2sGHvpsaGkasttakDSe/9+Fj +09O35MKHhZkQxQNtz3c2NtexFQOLA/kiKTEfH3vSasM3wbmBxjj35OrjLsX3TTTcBQjJhutLG0Xa +kq0liq9EZO6ARy6mb/s1M9pbSYxdw5Hjxo3rzYABba46sco6YUwmtF6dJE5EebCPCLCzaB8t3cwR +WHYRgCxjvrSKJpS2p4+RKJaxrAnLrFGEq+iY7AwlQ6VwMKQLfZpbBl9CqMptakPOlG5pCSJzXmvS +pGmvv8HyIpKTCW+itrfMYT3SSk1rz0nlurs6Am+noNKGpjpJwaxreK+UJadz2t4a1b2x1llzVtnP +JRHgrqnTVjK2WFmytRSb9UXDWDoOMYuS2M2DeYEBIVHKxRnlKFMBFvSWidWoxWay2BzcgO+POpF6 +M1jREGCBic6ALokLozvWbJW6oEllRJQWpQaTJ09mGwTIFU6FblFiacZqw3nyhhs89sDD2Xr2dKjL +d+XTXR0LZs9vWinXnB41v+ttKU24NJzYLrBO/FF22WVZz9y25C67lqcLyxQCLG5iPJ8hdKbSdXJ0 +maqeV6ZKBLJOo1Ui6MmXQQR0+HSJViymzFi2QlEyhsyQGo4mygSVwqaWatgqq4wcvfqMadPaOvK8 +Ttre2Tl/5pyGIcPr69kJMPxAO1PMiULESuCyeT36TKq1Y5qycjE3WzVcWEYQYDyZYxmpjFdjYBH4 +CNYZDewFeG6OwEeFAESodMgZr7S4Ggl6MyrFkig9NNXotcbMnfk+06CsPGLotq1l/qz3W+rHftiU +Tc2fJybZepxd8UkZ2kVglpR1vG0dszo72/F3ezITv9XoWXP2syPgCCxpBHx+dEkj7PmvyAgslkrt +4o014wFelGqAS9o0dKX2BfPZqShdl507f15bZ9eQlTsyw2Q3XSZHYU1IFCHNYl0Egl180HvuvNb3 +2TzA8iE3ZKdSg90FR2ApIJAp/I6XQlFehCOwIiKgpKVnvFI7dBmtrqSNzxgAQ0x1ynwjRrN1LSzJ +DGi2I5XvzDfMmc7ODIE7iYA7SQZ9QqXsAcBSI+HRBa3tc4xETVgRYfZrcgSWXQQy8nDrhyPgCFSB +AKSoB3kYj6oAgxqJooFcVW/2kJ8eI0aNwtVUhmzM8lHxVDY/sjFsmxM2phdCFZcUTg1VhY4z2Y7O +7rk9GcjfKi7CkzoCjkCFCJSY1KkwJ0/mCNQ2AkaNRqXKmpztMCo1YzBTIuRDpiuvNoodGpj75AUY ++SDbvJXrU03y0bRAr3yaCSpF7GZfQJbscmbrhu7ZSp8rAInyKiR7ArAbAGfk2m5NfvXLEwL4o8tT +db2ujsAyjgAESQ2NSpU4lUfVMVUZPZZ61iuCCPkCWXtXJ+yIq8lrLa0L6hbMrM/Co8EDlW2MGPaV +12fCS6RhtdH8/Eyl4fisGS53Z/ZJ5/skbAjAxvfsuLTc1d8rXLMIsM5IR4lqFgG/cEdgwBDg1wSf +2RkB1kSjZ1YYQaUUhgaZMzKC2iMPGz68qbF5zty5uWx9V10q31bXPX9Yw6g5nXzdhVTMiXYWBnUh +1HRO5NZ2+RQlWWluyMvvwaZ3Bxx00C677Lzm6DWnT39v+b0Qr3mtIVD4akGtXbZfryOwhBAwEiV/ +3E1oEhJFVipFgPBUGbhPXpiJKXClkSM++GCmfAQmxyLdutZZw+ra3sl3dBYGd2HOMBXDX3mdtCvV +mv+A3BLXQoZUI6Fc9oPsAVtXV3/wgQdSefaJXfYr7DV0BBQBvsrkA7veGByBgUTA/EsEpUk9K5Uq +jyqJ6nkRl3TEiLqXXoJqM6ksHmd+XtPQ7vq6tEyaymoj5mHaC2/CwJP8dOe3z+C73nFuyyODKvrb +bbedfOQ8n2efdK5oIG+J5+UILEkEsvJVQz8cAUdgQBFQMoMMlErJW4mBc+yMInMoyxLF0Tx4UK6p +Od/WipPZUF/X1tJc3zE419TatkBYU36r4XVSOJWtAVl2lO+Y197RksvJx600hwG9jqWaGV+d44BK +l6lPmS5VCLyw5ROBRcaUls9L8Fo7AssiAjAoBzVTAWcUAcpE0ENlzhxmyX5Gw1ddlUFbvtGdYmq1 +s751dhMMCnHWhRFdkZkcZSUSa3e7Uh3t+QXtstRoWYTA6+QI1AYC7K/r/mht3OpKr5LPflWa1NNV +gkC6oX61yWsvTNm6ZvaNVJmFDI9Oez6V4p8fjoAjUCECfPK9wpQhWZmfZzXZetoVB4GNN96Yz/mu +ONfjV+IIOAIrOgLPPPMMswMcfFqYRfK8kM2Zg6EgG/5hSoVvSHA88sgjVeLh+xlVCaAndwQcAUfA +EahpBJhy8XHdmm4BfvGOgCPgCDgC1SAAj/oKhWoA9LSOgCPgCDgCNY2Af++lpm+/X7wj4Ag4Ao5A +lQj4/rpVAujJHQFHwBFwBGoaAV9nVNO33y/eEXAEHAFHoEoECi+AV5mLJ3cEHAFHwBFwBGoTATYZ +q80L96t2BBwBR8ARcAQGAAHfF3AAQPQsHAFHwBFwBGoWAXi0Zq/dL9wRcAQcAUfAEagWgUw64wO7 +1YLo6R0BR8ARcARqFoFM+IZEzV6+X7gj4Ag4Ao6AI1AVAk6jVcHniR0BR8ARcARqHAFfr1vjDcAv +3xFwBBwBR6AqBHw/o6rg88SOgCPgCDgCNY4A63W7ahwCv3xHwBFwBBwBR6BiBHw/o4qh84SOgCPg +CDgCjkAq0+Xvj3ozcAQcAUfAEXAEKkUg46+PVgqdp3MEHAFHwBFwBFLMj/o+DN4OHAFHwBFwBByB +ChHg/VEf2K0QO0/mCDgCjoAj4Aj4OiNvA46AI+AIOAKOQOUIwKOVJ/aUjoAj4Ag4Ao5AjSOQ6fYF +uzXeBPzyHQFHwBFwBKpAINPt86NVwOdJHQFHwBFwBGocAZ8frfEG4JfvCDgCjoAjUBUC/r2XquDz +xI6AI+AIOAI1jgDvj9Y4An75joAj4Ag4Ao5A5Qj4914qx85TOgKOgCPgCDgC/v1RbwOOgCPgCDgC +jkDlCPh+RpVj5ykdAUfAEXAEHAHfpt7bgCPgCDgCjoAjUDkCvs6ocuw8pSPgCDgCjoAjwD4MfjgC +joAj4Ag4Ao5AhQj4/roVAufJHAFHwBFwBBwBEPD3XrwZOAKOgCPgCDgClSPg++tWjp2ndAQcAUfA +EXAEMj6w643AEXAEHAFHwBGoGAHeH/UPkFaMnid0BBwBR8ARqHUEeO/FV+zWeiPw63cEHAFHwBGo +GAHWGTmPVoyeJ3QEHAFHwBGodQR8f91abwF+/Y6AI+AIOALVIJBJ+86A1eDnaR0BR8ARcARqG4FM +V6eP69Z2E/CrdwQcAUfAEagCAd9ftwrwPKkj4Ag4Ao5AzSPgr4/WfBNwABwBR8ARcASqQAAe9fdH +q8DPkzoCjoAj4AjUNgL+He/avv9+9Y6AI+AIOALVIeDzo9Xh56kdAUfAEXAEahsB3nrxcd3abgJ+ +9Y6AI+AIOAJVIODjulWA50kdAUfAEXAEah4BeNQPR8ARcAQcAUfAEagQAZ8frRA4T+YIOAKOgCPg +CIAA3/H2wxFwBBwBR8ARcAQqRIB96p1JK8TOkzkCjoAj4Ag4Ar5LvbcBR8ARcAQcAUegcgR8frRy +7DylI+AIOAKOgCPAel1/f9SbgSPgCDgCjoAjUCECPq5bIXCezBFwBBwBR8ARAAHW6/o6I28JjoAj +4Ag4Ao5AhQhkupxGK4TOkzkCjoAj4Ag4Aikf1/VG4Ag4Ao6AI+AIVI6A7wtYOXae0hFwBBwBR8AR +cB71NuAIOAKOgCPgCFSOADzqE6SVw+cpHQFHwBFwBGocAfdHa7wB+OU7Ao6AI+AIVIWA72dUFXye +2BFwBBwBR6DGEXB/tMYbgF++I+AIOAKOQFUIOI9WBZ8ndgQcAUfAEahxBDLptO+vW+NtwC/fEXAE +HAFHoHIEmB/19bqVw+cpHQFHwBFwBGocAfbX9cMRcAQcAUfAEXAEKkQgm/b3RyuEroaS3XvvvTV0 +tX6pjoAj4Aj0B4Fsf4zdthYRmDJlSi1e9rJxzUy76MwL566urlgmKIsburvTmUxdXR2yHdRd5WXj +IrwWjsAKjoC/P7qC32C/vBUGAaPGRfgyI0vu0ehZhRXmkv1CHIHlAgH3R5eL2+SVrHUEYoLEK80E ++lRQjEQNo9jYlC44Ao7AEkIgm/LXXpYQtJ6tIzAQCECKOpxLZkaQRqUIKPUYiNI8D0fAEeg3Anx/ +1Im036h5Akdg6SMAWVqhJhcotGdct9jANC44Ao7AEkLA3x9dQsB6to7AACBgfGl5xcSJstjALF1w +BByBpYNA1oaMlk55Xooj4Aj0FwHIUn+nKih3xmcy1GAs9LcUt3cEHIHKEPB1RpXh5qkcgY8GAaVS +yi5eavTRVMhLdQRqHgHfX7fmm4ADsGwjkPA7qSwaVWrFY3nZvhSvnSOwYiLg/uiKeV/9qlZ4BErS +Z0nlCg+FX6Aj8NEi4OuMPlr8vXRHoK8I9J0j+27Z17LdzhFwBHpHwL8/2js2HuMILBsIGC+aULJe +5WNLJnGlI+AIVI8A63Wrz8RzqCEEbIG3CTV08UvgUo38TChfCGYlke9j8vKZr9ixhpsJK8z12t03 +ocpLM4hMqDLDZSe5QWRC9XXz+dHqMayVHPhFdXZ23njjjf/4xz9mzpzZ3t6+4v3GlvK95Jfc0NCw +8sorf/zjH//sZz+r282XrAOWhrb+/hNBSzWAvYPlubwLK3bT7Xsr6st9dKz6glLCJr32Dgc9ePU5 +Ca0HHYEEAsqgN9100+TJkz/xiU+su+66I0eOpN9PmHmwXwiA6vvvv//8888//PDDr7762q677rLn +nnuWQdW4s7dSnESLkVnhm25/W1ExRKZxrAyKfgnpidsd8PA15/YrjRvXGgL5fP78889/7733vvrV +r2677bbeWQ9sA4Ad+Qjagw8+eNlll40YMeKb3/xmLpfrrYgyVOr3pRi02mm6/WpFxUChcaxKwtIX +pfNoX1CqaRv9dc2aNevkk08etdqoTFreOdYu2zdnrrJldPP5UFYoMGDe1dXZ2fXuu9N+9rOfDR48 ++LjjjusvleodqbI+K1jyGmm6lbWixL12rMr84hJYFQfrho/b4PD9diuOcI0jAAIdHR1MiD7xxBMn +nHDCaquthkY6fvwn/Q83amkdjDi15dv4qkJlBTKb29HZQY9TWfIKUgEdhYIYaemkOAtupY5AonLi +l7zW2LVuvvlm0q699trxjkVxawyPMYvsWe8kGuOj8rLTdEvd83K6uOWUs1s0rr+tKEZsecEqRqb8 +b2pRbJKharCKcTM5S79oARccgRgB+v358+fff//9u+22G04STEasdeLFfTeLj6677rrnnnuOOdRd +dtll3LhxcW5VyuR8zDHHvP3225Xl86UvfWnYsGGMTieS85Sw+uqrb7755gl99cHf/OY3v/71rx9/ +/HGy2n333T/5yU+eeOKJiWxBGBj5lSMAL+ehw4aC9j333LPjjjsOHTq0GGTLoUyU2dSs0N+mWwwU +AzA33HADjRmcJ06cSJPebrvtis1KalhGMH369Gw2u/HGG2+44Yb9vVNxyymZf0JZTSsiq+qxStTn +o/1NJSqTCFaJVSI3C/p6XYPChSQCPP3dfffd0Ax9AXJra0tjY5N0CqFjSAzqQqJT1p+y7z770uPQ +jzD8e+ihh9Jqn3322bFjxw4ZMiSZez/DXZ1dpOjsEC6v4KAm0FVx8p/+9Kf0j5tsvEm/8pw7d+7r +r7++wQYblElFhSlUS+yt9G68SuLCAY+2LGjhDNqAdu+9937mM5+pr68vU4RH9YZAv5pucSYPPfTQ +YYcfNmHChN123a0uW/f3v/39ggsuePwxeSTqy3HWWWe1traOXn309773vcbGRhL2q/3HLacvxVXZ +iqrEqriGH+1vqrg+saZKrOKsYtl5NEbD5YUI0Le3tLS88sorU6ZMYbwx35ZvqauDirLZeh60sYMp +F1qnUpdedulGG22kDh/Te0RBCfQmW2+z9Z133Fm9w2dOW1xo32XjqkSS3vQJs0Twhhtv+MlPfvLv +p/+d0MdBhr4JAgJnKaVLPM7YQPS8zNIlA0KMALeFg8sE7fXWW++ll14Cf6DurzeTKKIGg4Ddr6ab +gGjBggVfPeKrO+200/m/PN/AJ8/i25dIaEGMd9555x+c+oNp06Ztsukmv73yt1878msWu1ghbjmL +NcagmlZUJVYlq0eeHH2HSzMZqN9UySqZshqsLJNiwb/jXYyJa6eLKFEAABApSURBVAoI0KHQv48Z +M4bePFOXQW5Z0IqSwV458zf6R4/zwgsvPPvcs7Fyr733Iq8vf+XLm2626YdzPpwxc8ZRRx+11dZb +TV5n8hFHHjHzg5lqTLd1/gXnn37G6etvsP7On975oYcfUv2bb725/wH7j58wfttPbvvXv/2VrFSP +8a677Tph4oQ999rTjK/83ZX7fn7fq66+ip7r4ksuxvKuu+/a5hPbkPyQLx2Cu8xztyaPz/AW14Xm +7XfeppIPPvTgQQcfRM64I9RWLc8971yeBtYatxb5oHnk0UdOOeWUd999F/tv/uc30Tzw4AMHHHgA +7vgWW25xwYUXaCqdv1GZUvLteZXjMyDOmz8P7xZI821tXCAvvYA2mJMckAt3wv/0E4F+Nd34jiD/ +7qrf8TLSd77znQUtCxu5yW+9/RbNde3Ja2sbptkkkhO0RsV8PDd01KhRKHtr/DTg3ffYndY1cdLE +U39wKpZxyzn5lJOP/vrRNJLiUkxTZSuqBiurQyzY5Vfzmyr5G4+R6e03FdekWK4Sq96aYYaxp97i +XF/LCPBEiYPU1NTEtCJ9gR6wKZjQgjl43oyPffbZZ6211mJa9NJLL4WxNOrCCy/E/owzzrj22msh +WvRbbLHFlVdeedtttzFueeedd6oZs56Mm9F5XX755byWiqx6/Fo8WtbdXHLJJS+//DJZqX7VVVf9 +4Q9/+Mgjj/CWCHOQqpw9e/ajjz7KkDLJd911V3jukEMO4XXMv//971/84hdffPFFfUZWYzvLk3N4 +duYn+uqrr37jG9/49Kc/fdVVVz3wwAO33norZm+88caZZ5550UUXMdPJYis0rACiYhTNRX33u99F +AzgHH3zwfffd961vfYuLhRRRApFV2EpBnzhS4ffHkqJMto6V0GQFj4I5yIM/CcnEj34hAGj9arqJ +O0JTWXPNNYcPH57Qa/DrX/86Tev3v//91Vdf/c477xx77LHFZlSAKFrR1772tQMOOICpcWxKNv63 +3npr//33pyzmYlmI8IUvfAFLazn/93//R+P/7//+7+KfW6LQiltRlVglqqFB8uRAruY3VfI3bsiQ +uZVSsg5llBVjVaYRMkDnP9Qy+NR0FI7aoEGDmKIrkGgmg6AjXZxVMIDgFZYCQTk/+MEP7r77bgZ4 +2aZnlVVWwQCBR3IEFs7QrSDQyhkufuqpp/baSxxWstp6661PO+00ZAbEzjnnHLgEcqVnueKKK3S9 +Et3NY489hh4b2JEzx5ZbbvmrX/1KlTARtaVcGIgo+JXaQnjo6cjgb0pRy5C0cJLLCHqNOumkk1gT +RBxzn//+97/33Xdf5rfAge7s8MMPZ8KMKCz12UIvCs0mmxSmVymIp/upU6d+7GMfo1w15kwRQpSh +8gTjQwZ2w4sLme5MV5r/uuhwsWxubqbc2NLlviPQr6abyJYVRhBbfLNortwUdp7ioYrXfHlSZOCd +VLxOfdhhh/Fe9RprrBFnwu2GjDF+7bXXtAmhKdn4r7/+ehrMj370o9GjR5MDvxTO2nJ4yqRtY8CT +ZZx5SbmaVlQNViUrw8VyAKBiWNlvqrffOCVqthTR22+qZK1MWQ1WlklC8P11E4B4sICAPu4xV0cP +ojzKmYYbfiPSgrHDJsYLA0iUHwD9C64bTiQaDDBWgf7o7LPPZjkfDERHA9monjwnTZqkMrxFtsg8 +qpOWOVfVa4kq33777eedd57RjBlAb6wr1iq9+eab66+/vq3T0WqrZVxn/TWi1/zxNdWGTpMoZDo4 +vGT8Ti7n9NNPZ+2PXhFny40ek66QtZ2Mx6LXhGSogmpMJmgHSsWZM8/aJAEiZM5UQKPM2IU+IqC4 +9avpxjkzrAJZ2s0lCu+Ths2MtS4X33TTTTVWn59QspIuzoHbynJr+IM2/KlPfQrf9Pjjjy/Z+Imi +OG02lgPNAH8aN/Rzn/ucPrpZVEmhmlZUJVa91YdLACLOGFT2m+rtN26/IwSTS1ajpJIkesmcB/AX +l1mkIyxZsitrEgEaHM99nFmywU/CDnnI7DlgqeJjq622OvrooxkX1SjAI63KLOj/4x//iLcKlUKQ +/MxUr78HlTEmiMzWg6RlpYbpCSJDWjgB3//+9xlHPfLII1WJ3hKq/TrrrEMvpjJnzKw4UyJQlumx +4co0NtbvsccevEFLWUccccQHH3yAAWVZuQTR40kwqoz3bJnE9YkvUPPXcw+Qhb8kUYnRbJIgcyZD +P/qFgEHX36arN4WhC95aYdbA7pTdbvU7WXynUTrXwCCwWapABbRRjR8//sADD2TMFn3Jxg+D0p6Z +kohzoDjGVBjUpTldc801cVRJuZpWVCVWJetjl08sN47qqVmsL/+b6stvnNwAqmQFyiirwapMI8zg +U5SJ9qiaRYBmyhM9Z2b76BSsi9dfRRzUpskYLPOLyCD2t7/9DRpDZqCVrueZZ55RG7onOg5cxief +fBJj1teoXn9gKpMzOSCTkNfvGEPDjBHgn//855ihp9PBgIdclg7hN1gmVFITaj68hcnDPlOYuK3M +VEG6GGhUfI6LjpObnlE7XnGhX9tvv/2oG8+wJKd0CB5O1ay4Lq6XKGZnyWTevHno4/pYbnHRxTL5 +c5CQsT6SKP5k6Ee/EDDo+th0EzdCX/Zld8ann35ao7gp5InMsx1tEvcUhuYu067wTWkMiRz0dlNn +GJcHyu233x6Dko2faQ4GYBjnoFXTfuAPLLXl4NFefPHF//Vf/4Vnlsi/fDA0or62oiqxKlkTvXyN +AgSzMf1if1N9+Y1bbpZ/BUK/sCrTCKXr8cMRKIkAU3S4WXPmzIGr+G3T5mipvT3rMTnKR0uYVmS0 +Fhu6AM4wAR0BY57bbLMNQZZdsJiIgSzeq8OnZKUGPIdefxIIHNpnqcyy2FtuuYWhLVZz8DYqlUTP +Br8MruI0MGLGQcXIKpGQIK+xHnXUUTiRjLn985//3GmnnbDUbOOzFc2lkb9dIMZqP3XqVFYe8U4n +32OhPlSG5OzUD09vttlmDPcRZIMFJoYZmobv9957b/aLoNOML8RKiYtGtuIQVCYVHTTHSiutBP4l +74srF4tAv5pu4qYQZNRkhx12YKqe9sy9ZoSWCVH0DLbjI+rLYEzwM6LLmD+NPJEDt/vcc89lcQA0 +CYnyE8CgZOOnOcHKd9xxB7lNnDiR2X0sreWwdo98aN6slUsUEQe15aAJjUh+of1qRVViFddEZWvt +1Key31RffuNWSnEFymiqxKq3hpceu81+j/45uclLb9aurykEmKRhFhMSolnzg+f3RivkJ8oBDrTj +BBo8pDPSBZ3oSh+LRY+DpWuOUEKlunRixowZ8DR0ZZbFArOz+J22oscMULIYhLT4HChxfC0qFngI +oJ79egs+Tm4ySzRZQJioKvXHt8afwIxrZAKMIPMuXCDGlra8oPM0+CIc5EA+LE7Bz2bcm0cBOu7y +yT22JAL9bbolM2Ekg/ZMm6fxa5s3M5ofGp51TNNHobfGDyXTZiCAPuaTMKumFQ0IVon69CW42N9U +H3/jfSkrtqkGqzifWIZHv/Don38Zq1x2BBQBenaa8l//+le6DFaisr8uBEm3UsygjliVCPDbhkSZ +FmXICxLlhQE8eJ48EsxdZSm1k7w2m25lrcixqv4XV84VqJ1fnV9pSQToxHniZpyWiUAW0eD58ZNz +Ei2JVZVKUAVbvHa+kY7LAuYg7yRaMaq12XQra0WOVfW/uLqha6x35AF7VNxePeGKjQCeKD4ow5W8 +1MEYL6uEehtBXbFxWKJXp24EU6rMFjNWzIJnloD6iG6VmNda062mFTlWVf7i0mO22u8f1/n8aJW/ +2RU5Ob9PZlBY+8oiW1besjCV9TVMgjLqyM9vRb7yJX9tjOUycs4kHJPQzz//PC+8shyUN1YhUff7 +q4e/RprugLQix6qaX5zzaPW/1hU/B35jrLlgMTqbG7AKhvcykZnDQ7/iX/ySvEJ+uqz2ZAiXx2G2 +bcLdR2axSTU/6SVZ3+Uv71pougPVihyritt3eo0tPv/4DRdUnN4T1g4CTODhmDJLysFMHoti0NTO +5S+JK2VqiuW+LIRmtJwDN9TnRJcEzit20x3YVuRYVdACeb/HXYoKcKvFJPxcmSul3+dlFX5sjCa5 +P1plO8CTYGwcYBE4qszNk/eGwIrddGk5A9iKHKveWlEZvbwn64cj0HcEQodf4Q7RfS/FLR2BAUfA +m27fIXWs+o4Vlhl3KfqFlxs7Ao6AI+AIOAIxAv7+aIyGy46AI+AIOAKOQF8RYN0lpjIx09cUbucI +OAKOgCPgCDgCAQFIVD9NkfVVRt4kHAFHwBFwBByBfiHAF6tuvvlm/X6Gz4/2Czo3dgQcAUfAEah1 +BIxEeV0NLDIpfwOw1puEX78j4Ag4Ao5AXxHgw3nqiUKihflR35Gmr+C5nSPgCDgCjkBtI/DSSy/x +UWSGc5VEC/OjtY2JX70j4Ag4Ao6AI9AnBCDR2267jS+rQ6JTp05VQiVlxtcZ9Qk/N3IEHAFHwBGo +YQQSJGpDu0DC+6POpDXcNPzSHQFHwBFwBBaHwAsvvBB7opCoeaUk9XVGi8PP4x0BR8ARcARqGAGG +cO+44w4jzphEkQHGx3VruHX4pTsCjoAj4AiURQASTRBnglBJnV51o889dfv/lM3HIx0BR8ARcAQc +AUegNALpVTf+XIq96ru70qkueQcmyN3yXUkJhEREdvGP/QMJp9MERd+d6haNfoFSJDXuKYbtBsMW ++LLroKbsiUFd2IxQtyTsSSiZ99jIX02luSIHY0kb2RSSpImkOC2wJ1oz11AoAhu5OMlJsy5cjxWl +YUkRrEJQ02vpFNAT5G8mVARLUy4sUVWCQCGBFhmC6YxUQ1LplYhQsJSokEBi1CCE7ZqJDrIkEJNu +RQVR8+KvJCtcX6GCpLDYQhKFIhRMRj23Q8MLqxVlG6IKxQUYe3KUwkKlTGFVJ41UsadCCmc3X4rB +QgPBIoSCBttQ9YBPUPfUMwTCFSMFmwCtlCnZh0BARAxDUCGIypZ6hCMkKMgFTU9UITfRiqqnPhLm +t6EwygVpDUQdDrmZC7Po0cpfsdW8QkDqoPXoDhmSLAS57/yTXDS2B5eebMkjgExsuPPoF97TQo4U +JHBoAciaVlKm01r50HLkpIVQpFTNKi4tR6Ikl0L7CtmFvCQqFNqTScE6FCr5Gd6SJly05RMSLpJn +sCmcutNyLZJDUCjmPZWSqFBDaRgotQ5iKBaFuvakDOmDjUqSlkzlWsJlFgpImBdSFbQhV1GRKqQu +3KBQumbQkyBY6Q9WAVgkWvDgoGC9FoLkF66np+5BJTbBopAgAKkJJT50MoKJ1ibUUi0FEPm9YBv+ +lxNHwTLkSWwmV0fbSi1obW9v1w6cwjCVIqU+kkKLl8RySHxATP4GA1EGGwQtW9LqVfToJWU4SCPm +kouaiFZTaZ3USpSF+FCNnnzsonoUwTxUSqWesxbQE1r4V4oOdVioQtJsF1FpQExDM+rJT4AOexMR +I9UGQu2vkCXA/1J1jZLfLeby6/1/vtg6hnINXbEAAAAASUVORK5CYIJ= +OptionsEHCIacquireCan fix some rare USB issues on boot.ForceWakeCleans the hibernate image on resumeGUIGUI bootloader on or ofUHCIresetReset USB for some rare USB issues on bootThemes Default theme and Twilight are offered as for you to use ExtrasKexts for AHCI and Intel PIIXATA will get installed into /ExtraFinishing Chameleon installiVBORw0KGgoAAAANSUhEUgAAAm0AAAG6CAIAAADVuubjAAAB32lDQ1BJQ0MgUHJvZmlsZQAAeAGt +ksFLFHEUx78zErthLGJWRAZDqJjMxjJ7qdtuewhhhUVXzfCy/nbdlZxxmBndig5dunUrOnReJOrW +RS/hHjsUKKJpnfobJImWZfr+5seyHpQuvuHN+/we39+bee/3A3oGS667rAOwncCbfHDfeDj3yIgd +QsNNJq+gtyR8N1so5Lk6w473qabtJmWtT/7e2I2v6deNkVbs1efi1hmbOumExw8CmsnEQFVxRvKC +4qLkeuAG1NQki1qpTH5ONr3iZI78npyoKt6UvKD4i+Q1UZV7D8gpp7zkAHqcfLdc8QU5QxZlX9jk +Btm07RXW17fJo8L1uFf/Qx6Sc2GkPdsHsh9ZM9HNzbwBPqwB12U7RiTD8GPg8m9gc72bOzqIZqVd +jfuLaSvSab0bwIW3YXg0C8RuA+3vYdjaCMP2OtDzA2gei1WPtZVa+8Yf/s9a9az0wA57oEVndDqr +uUSqFNBoAnNcjGeAd/SRa0D/T6BALmagp9MdVzOkFLiYz00kLauueopS5/Oyl1d5TpHJDi5VnOkp +xj76IPLIYQJJWHzqsNTZSe38S+CWvNZo/v31QsaTFlSeRDPJrbhPvaVqLTCyvLkV0xh3xB3TsFKp +e/gHmVWEZApHLZsAAAAJcEhZcwAACxMAAAsTAQCanBgAACAASURBVHgB7J0HoB1Fvf+3nn57SXLT +QwqQBAi9KiAo0lTgiYogKPosoH/r84nt2bFie+pDRVBUxI7yaFKkh04ICQTSy+3l9LLl//nthuN9 +t5GEG0junSXsnTM7Mzv73XPmO78yv9F7enp839c0jXN4hOnhZ66SGR7VdDUxJP+FguqvQkAhoBBQ +CCgEdgKBn/zsmng8EUskEvFEbV3dTtTcmaK6pg8urusvfKwmNI3MMHf73+BTmJbq/BfkWJ7nlUql +dHCUy2XaDdk0JMjh57BA9VztxxBCrearhEJAIaAQUAgoBHYcgc7Ojmg0Jkc0NjDQv+MVd6HkyGz6 +L0qVVFimSqVQZ5hjRyJxCD+Z0jdu3NjV1QWD8pluW5a1C11RVRQCCgGFgEJAITB5EMjm8ts6Ordu +7cwXSxaCaEiiruv29vYink4eINSTKgQUAgoBhYBCYBcQMAyjtakhlUg8s2adNTAwEIlE8vm84zi7 +0JaqohBQCCgEFAIKgcmGADInpIkGt7WlycI4appmaBmdbECo51UIKAQUAgoBhcAuIwB11tYktvsZ +jabOxXuoUqn0trc/dsPf21euxB+J+0Vra6cuXrzsjNMap061bXu79XWkjlSrr7zhr50rV5QGgup1 +da2Llyw+48wdrN7R1X7jP29YvW5lOjdAgzXJ2v3nLTn1VWdOaXmRu4/UI5U3eRHQ/UrK2NDatCZT +mtqT3s/3DM+MTF441JMrBBQC44GAaer6Lbfcgp53xNYgLaTVFf+4ffkvrklFoy2tLc3Tp5PZs2VL +Z2dXrlw+/MILlr7mxGg0OiKVhtWfueMfq35zdSIaaZ02tX76LNyE+7ds6ty2Ddvsfm99x6ITXjN2 +9TseuO3aG38RS9nN05tbW6ZgxO3o3NaztbeSd8877aITjjxptOojPpHKnIQI2Eau0V7dFH2mQVtr +21ohldS8ipX281v322Qd1h2d9vJjwrSVXwd6IG7NV5qfz2i/wRH7tgtVRmznRTNDtdWLFlMFFAKT +HAGRR0eDAEn0qdvvePjKn81OJg+YNfPAU09deN7bfM999pfXPnnTTU9u2sQlhgCoFKl0eCNUX3Pn +P56/9icLW1OHLJsz+/iTp578Zs0wO267fv3tNz/66HNcMnRt4QknjVb9zgf/cfVff9IwK7n0iHkn +H37aKQefnStlblj+63sev3P1I5t/8defcHeodMTqw/ujciYbAn7n2sPrn6hZsErLRzWtomtGqeQU +sv2JuB1LGNGFK5Lp/lzf/uuMeX1+ra8PnU3ee++9TU1N++6777jj9tfg+OlPf0rLH//4xw844IAL +Lrhg+F3g2gcffPC5557DAXDKlCnTp09ftmxZMpkco8rwRnY5p7+//81vfvOVV145e/bsXW5EVVQI +TAYEhEf5uY74qD3t7U/88tqFifjhyeRM12vcutV79ll4tHHb1qWe15BILvd9CrQt3r+lrW14C33t +2zb/+eoD5iSPWNpcOzUaN9N+ul0zjIQxMHdWpNFueXCFv+bPV7fst7ipbfrw6u2d23574y+a5yWX +nDCttSVZiQ505jfmy1kvkWubXxNtbHv6znYK7DdvcdvUEaoPb1DlTDYE8q5lFNaY5cfz3uJCwc6k +e8pOxfMjA5bV0JhqqDejjXdbpZqlJfvJTLQ7sc8QfH77298edNBBCxYsGJI/9kdc9trb2+fNmzdG +MWZ+uCcgVlKGNI5+YXpwFRzpv/rVr27evPn1r389XM76tGuuuQYShXRHqzK4+ktPh8MCU9XhfXvp +jasWFAITCQH5MfNTGfGRVt98a4PvH5tKzdD82kw6/tRTnsZ/fuLpp/VsJqJrkWRyIJOlWOMFbx/e +wpY7/7cp6Z9wVFu0LmbXGJbb7my6R9MN09karTMajJoTUlbv7RspVn/uRcOr/+P+m8yof+jps2sa +YnbU7/Y2PN51Z8UrZc2ueIM9JVmXOD1698+fp9jbzrxweHWVoxCINrSs2lTXHOv3K/fq9jQtMsM2 +I6ZZ8Cqd3Vu7Mx3O1Ol6LBp9aFu8JzkLBesQxNC1onrdWRZBiv3lL3951VVXDWlt8EcoiiNseXB6 +cBla6OzsvO6660KWhXdZ4U30MfwaRqsyuPpLT4eaKs47i8BLv7VqQSGwdyEg8uhoPGqtW3dgIjHT +MJp0PaH5dl+v8dDDPJ5dLKImi5iG7vkU2LJuXfiTG/LkNd2r5i5ujLfWROvjdk3UirtGZS2hIcwa +fIWTVsI0otayxY3re1aPWH1j/7PzDmuZMqPBipgW9zKLXc4a3/NpJxWJu26UuFFzD23Z2P7siNWH +dEZ9nGwIRLatWFRenSk2dz7/umTbzbXmNsOruK7jFPpNQ4tGtXJFe/LJRLZ7U26/47VRrBswFt+u +bDb7sY997MMf/vAf//jHp5566uCDD77kkkswzAPpX/7yl9tuu627uxuN6yc+8Ynnn38e/kOUfM97 +3nPggQe+733vu+GGG2DWTZs2IaGef/75CxcupBbNcq5+b8O7DH5B3PHmm2/+1Kc+VSgUcrnc4Eth +miq/+c1vKNPc3HzxxReHzY54r7vuuuvOO+8844wzrr76aha5vf3tb99///2///3vI+medNJJ73jH +O2iQ1q6//vqbbroJW8wpp5xy3nnnkRl2jzPHiAUos3r16p///OfIyvX19aeddtrpp5/OYDIGXGHn +1VkhMMEQGEseTQ6kp9pWQyxaY5oRyzJtSzMtAiJp0YjlOKbjeI47VS8NDKRHnLE22rnWGc2xlppo +Q8JORo2YxfTe13zNSViliBmP6LbVOqMwkO0esXrWSy+eNyWVStiWAY9ahvzjJ1/xTIeFO67nRLxp +8xpXbW0fsfoEe0/qcXYWgQ3dxelWIRXXrcqCwtapvY1/mtI2oBsuoS/T2Xime0a5e5ZfqNWdHqNt +cyU1grcR5MHBtwt3m61bt37nO9+56KKLLr300ve///3333//cccdRyAwdK2/+93vpk2bBpdQcp99 +9nn3u98NlXLwETe9tra2T37yk/Pnz//85z8P6X7kIx/hQWAmzuH3tnqXwQ8IyZE/a9YsiG1wfpjm +EgbWV7/61T/4wQ9+9KMf/eEPf4DCuTTivejDqlWrUAV/5StfgVN//OMfQ7o8Ao0wG3jta1/b2tqK +syFciymUJ33Xu97Fo2GLDbtHV0mMWADh+DOf+QykSx8eeeSRL3zhCwREO/HEE0eDa/iDqByFwMRA +YCw/I8TAqG2mamqYepvxmJ5MavE4Drdasajn83qhkCqWYnrG9LZrqIYg4tqmUROLNqYi9XEzEUH6 +1OzAlcPx9JKjR6Bkw6xJUyz8xQ6pblsm0RVTsRjNoIyLW3bMtKDhousUKk6J0c304jC6ud3ONKS6 ++jjJEWhadOCq7KzZ2+6a1pCPenVm5X3dnTdrle7M1tlOptXwLEMvWJG8Znlm12M9do1nxYcjBtnw +5Qy/nx/84Acxl6JWxVq5bt26o48+OtT6IqQiw2G5hD8oSRVkMoRIEhxHHHFEyCtLlixBggybCi+F +aW4actXgu2cyGT5CftUyg6+SPvTQQ+kPgi/t/+IXvwiLjXgvCqdSqS9/+cuIiYjI9P+yyy6rqamh +k2iMEZTxpbr11lsPO+wwyJtM7MFPPPHE1KlTwzY5c4xYAFZG9X3uuef29fUh4wII8jHsTnluOhyu +IY+gPioEJgwCY/kZRaZNy/V02/X1RjKp19Vq9fVa8PPzczm9v99Ip+1sNlcqRRqbwl/OEFDKqaas +p1m1cTMVN+K2HjO38ygSJVF8DdPytIynVVJNMOGQunyc2jit0F+OWRFi/iKTpuxY3Iohj+acomWU +LKdSQkU3UJnSOG3Euw9vUOVMOgTitXd1RZf2bl4wZ+Y/7nvqiae6D91/wdI5UzJavx1h2YnW0Z/b +wtd04aGeHhluH62yXSg+1tbWohcFw6rdtK6u7lvf+hYU9be//Q1RFRrjavhtrMqRd9xxx5/+9Ccy +qUWD4dUXlUfxzqUphGDoefhbox0kYKynXKKparOj3YttM8JtndASU4W+hbpiWJNe0SWaWr58OWIr +VzHEUozMsJOcRyuAFzGki1tv2CaKa7yLqxWHw0UxdSgEJiQCY/Fo7QEHbL7zjkp9XQwGbWjQGhv1 +2lpBIZvDvsRstmLZW9o7apYuCX9yQwAyZyzd2PXwwVHbQIUbs7SIoSOP6r6PepbfL6mSu7Era8w8 +ZMTq+89Z9vDa20zXTMQiSTuWisTiZgyzEr99Zvz8dYp++9r+w/c5acTqQzqjPk5OBMrF7O8fuC/r +mLaTmVaffGLtqsZ6d3pT6rltfU+u72rv6mtZdnJdpBY6GhEfKIpvF2euoiANv2l85CDNAXkgj/76 +17++4oorfvjDH2ImpGR4lcS2bdsg2m984xuHH374jTfeiLKXKmEBzmF6cHnS4YHVE5JG4ENR/ELe +//mLjBtWr57Hvhf0Rv2wMDyKpBs2Rw4HrIyyl+U0YSYux4iYPEVYZbQCdPLuu++mZfiYkqzPaWlp +oXBYcThcYePqrBCYeAgIj3KM+GDNxx49sGLFcs87oaHBbGwUKmV2zG+GH6GO5672UG+f1tzSfMzR +/cE8d0gjjQefsuWmRx5f3X7EcQs1lLO24eui8tItw4MIXe3J1e25sta27JT+guzXNuQ4YtGrV268 +99mHtx11/IKIYdsodw30upqt2xHDtTXvmeXrkFCP2Pf4fKY4pK76qBAIEcjoyZqYUav7tlmLpSBq +mf9csdbX7K7egca4PrshohmijB0NLiiBq2GBMB2WDNMIeXASKlBoksWgoV4XURK3I2Q1iBBVKt93 +/GzRlN53331IgdWmqq2RqKar3aAWdtZvf/vbMBNKY6RGfqShuhXOG1yFNLVodkfuFf7S5XleeGRy +SOMfxCQAre+iRYtoEK0ynQ/LhH0bscCRRx75q1/9CipFo7tly5ZHH330rLPOkqaDxsOKg+GqPp1K +KAQmGALCo+H3fviD5V135plnbLjn7kc8/6BEIhKL+ZGI8KjnVeKJx/2ejZo24/RTKTZiC3lXq192 +7sqnfx9rTB5wyCyZsspUXf56vrbi6a1Pr9pWf9C5FBuxulPyTjvigjtXXvtcffuSg2Y5BHHDW1fz +Xc/n0prHtm1d13fGUReSHrF6cDd1muwILDrk2Ls6uxu23h1qQli3GSmVK05lUWs8U3JW5Wv2n7Lf +aN8fmCAkg7AA5zBRzWedKJ4+oeMutNfY2AiVzpkzB17Bv/eEE07AG/aYY4750Ic+hHr2wgsvfOyx +x773ve994AMfqPJZ+HrCuwx5VcceeyxSI+3jSYsJE/EO2fdtb3tbtQ9hotoUFPii9woLV3/y1Qfh +Xqhnv/71r4dW3uOPP/6cc84J2+fMMWIBhO/Pfe5z1MLuC/WeeeaZr3vd66BzyvMsQT1JVO8y5AHV +R4XAhEFAx+Ew/N4PfyTcKBga3I0b+x9/om3O7OlNTbWBPJrO57f29GzbsLF26RJz1iym3iO2EFbP +b34qvf5vcxY1zFvQWt8gbkoDffn1z3ete6YvNfO0xIwlY1ffml63/Pk/TptaM31mU10dtiK/D5vW +xu5t7ZkjF5zTVjt3tOrDH0flTFoEnln5ZPsdV89usJKJuOt4mzNOh9W2/7Gnzpk7F8lvNFhwl0XD +iXDJNxn96vr163HSoTC+rCRw1sXuiHRIoqGhASLhqxg2RQFojzL4AeFDC7lSEk0pLIXpkQQMxEGD +lJ8xYwaZiLZh3cFnhEJ0p3SAdqDn8KacB1fBYwiZde3atVR80XtB+QQnQgEbEirWTUywoa0UquZ2 +GEq5I1w4/KmHF+CO4d3DWmAFFLDmaHANfjSVVghMJAT0qrPfiE/FT4LfT1MytfGee7RsNp5IMO7w +g9FTyZnHHNuTy/L7H5FEw9bC6vXJ2LMP/NmqbKircVEIpzOWY81ecOQb+nPFHaleU5+87+lbe3LP +GXaRya1biTcn9zl68Wsz/bmxq4/4RCpzciIAMTz5h+8lImahdfHBx54MZ4wXDnzJh/8EyISrIBXu +Ui0QcnaYueN3x/EHvS70uSNVXvq9YP0xbkRnhhcgEwR29rnGuIu6pBDYuxDQ8X0Y/sMY/Az8hlkW +xiyVGXSowmKujRaIgalYLIYT28Hlh6Rf2epDOqM+TmYEUMNizpw5c+ZkBkE9u0JAITDuCOg/+9nP +xubR8JbMc2HE6oS6amLZwQ69stV3sJOqmEJAIaAQUAgoBHYWgbH8dQe39aJy5+DCw9OvbPXh/VE5 +CgGFgEJAIaAQGBcELKwaxMIel7ZUIwoBhYBCQCGgEJhsCIg8yv5Qk+2x1fMqBBQCCgGFgEJgXBCQ +WGXj0pBqRCGgEFAIKAQUApMQAYmTMgkfWz2yQkAhoBBQCCgExgUBJY+OC4yqEYWAQkAhoBCYpAgo +Hp2kL149tkJAIaAQUAiMCwJKrzsuMKpGFAIKAYWAQmCSIqDk0Un64tVjKwQUAgoBhcC4IKB4dFxg +VI0oBBQCCgGFwCRFQPHoJH3x6rEVAgoBhYBCYFwQUDw6LjCqRhQCCgGFgEJgkiJgTNLnVo+tEFAI +KAQUAgqB8UBAyaPjgaJqQyGgEFAIKAQmKwKKRyfrm1fPrRBQCCgEFALjgYD52te+9sADDxyPplQb +CoHxQWD58uU/+MEP2Ct+//33p8Wf/vSn119/Pftvs5n8jt+ALbtvv/32jRs3zp07d8dr7YEld+3x +d/BBnnjiie9+97vscH7AAQfsYJU9s9jvf/97HuRvf/tbd3f3smXLRutkPp//7Gc/+89//vOEE06g +zJBv2mi1VL5CYGwElDw6Nj7q6r8QOOecc6ZOnfq73/3uX1m7J/XMM89cddVVd999d9j8TTfdxMfN +mzfv1N1yudz555//rne9a6dq7YGFd+3xd/BB1q5dC7a33XbbDpbfM4uxY9Ull1zy1FNPzZs3b9Om +TWN0slwu87y/+tWvwjJDvmljVFSXFAJjIGCNcU1dUgiMLwLf+MY3nn322e9973vxeHx8W6a1IY1H +o9H3vOc9kUhk3G+0ZzY45PH3zE7upl794Q9/oOX//M//PP3003fTLVSzCoExEJB9vMe4rC4pBMYR +ARgUdesVV1wxjm1WmxrSOFT9hS98oXp1wieGPP6Ef97BD7ht2zY+IowOzlRphcDLhoBa9/KyQT2h +bnTDDTccf/zxl19++c0333zyyScfddRRVV0Zz3n//fdfeumlmNwWL158yimnlEolMi+++GJIlMSp +p54aMtzDDz/8vve975hjjsEO+u///u/33Xffi2KUzWYRO2hh/vz5b3rTm6688sqwyvDGM5kMPaRk +WMBxHOxnr3rVqxhtyadidcfAj370o+TQ5y9+8YsHHXTQueeei9VwxJ50dXV96EMfOuyww8JGbr31 +1rAYKugzzjiDLh1yyCH/7//9v56enjA/ROknP/nJtddee9xxxx1xxBG/+c1visXiRz7ykSVLllx0 +0UWhErLaVYR1lOcLFix4y1vegs1yxD5g8b3gggv23Xdf7kWHXdel2PDHJxOFMK+GrmILvOWWW6qt +rV69+swzz6S3b3zjG0lX84cnRnyPvGjg4qHC8gDCx0ceeST8OCJEdPLHP/4x3cBWDXqf+9znwsIj +PguXRrzvaPlvfvObN2zYwFVAoCeAOXYPw1sPOfPN5KtCdV5BeCmdToMeL25ISfVRITAcAaXXHY6J +ynlxBHACYghGmYEXDOP+unXroLc3vOENNTU1DEDnnXceA9NnPvMZwzCqIyxEcuONN8Jer3vd65Yu +Xco9nnzyyd7e3gsvvBDvj6997WurVq3CAWTsew8MDDDIMsBxC3yRuAXNQirDG2fspoeJRCJs8D/+ +4z8YE2fPng3PYSGjIkIMLidcZRSmJOnOzs5kMnnXXXehE77mmmuG9ASDK3OCLVu2zJkz5wMf+MBz +zz2HsY0yd955J7QXi8VQIz/66KPY6h566KE77rgDlXKIEjlbt26dMWPGmjVrLrvssj//+c9wJLz+ +v//7v7j40Z+wq5THmltfXw/R0ib9+Z//+Z8hfQBbhnvgYv7BvX74wx+2tLS8973vHf74zG8AFrL8 +2Mc+9rOf/Yz0Aw88MGvWLCYiZ511FrAzfeH40Y9+NOQW1Y+jvUcceYCro6MjLLl+/Xo+0iU+jgYR +3w3w5F3w1vgCcFB4tGcZ7b6j5Z944ol8kYCaSVJTU5Nt22P0sPp0QxLUAhxeDf5Kn/rUp7h63XXX +8VwnnXTSkJLqo0JgOAJKrzscE5Wzowjg+4OH5H777cfgzrCOQAlHMooxquJbi7Gqra0NKSFs7h3v +eMenP/1pxlAkGOiKzHcGR3gVgQnGhUppbYzbT58+HY4JCzBqQzZ/+ctf4NHhjQ9uhLE+FCwYKKdN +mwYNIxvBUu9///urPsDogfHeRJw69NBDoVKmCLquD24E9g1J9N577zVNs3rpq1/9KmkGX3iUBJQG +XzIK4+UUlunr66NBXLToJ8M94zVXEVXf/e53c8dqO7Ayjbz+9a8Hh9NOO40pBVgxEakWIEEfgPet +b33rxz/+ccCnq7h9waPDH//rX/865ZH7oRke5L/+67/++Mc/wtmUh0TpSWhT5AWROfgW1fRo77Fa +YHhiRIiYpoSTEjqAuF+tNdqzjHbf0fJ5/F/84hcAi3y/aNGiavs7mzj77LP5enDA+tT9+c9/zrxw +ypQpO9uOKj8JEVDy6CR86eP2yDBlSHuQBI2GQgmKRHR3yGRHH300os8HP/hBBLgRbwlPIJMhOSEa +wj3VFkYsXM2Ea3/9618zOodVCoVC9dJoiaeffppLSISQKAlYpLa2FvkGgePYY48Na9FPxFB4hY8o +oofzKO6gXEJAGUyiiJJh41Ba2A7PTsfCwmEOIIT40AGGezxLySfNOVR0h8UQ1yBR0izbYJ5BScSs +wcTDpZUrV3KmcTg4rBWqNMN09YywiycqHyEYNMmh+TAsCXrk08mwMI9crTUksePvsVpxRIjCPkNI +O/gso913tPzq3V9iAqVuY2MjqmbMDUzRULFUddcvsWVVfcIj8H9muxP+adUDvjwIIOsgMFmWBeEh +D1VtTkPujviFJhPWgTmqcuGQMkM+IqXBZMigMBPG1yFXR/sYGmirOl7kszAdKmbDWkOkz+FNhY0M +8TSGsTgoHErY1cTgloc3NXYOPQE6yqDgHVIS2iaHe2Fo5ID7ATBUkw4uySSAg5zW1laKMaGhJFpc +csKnqKurG1x+tPQOvsdq9REhCjPRe1eLhYkxnmW0+46WP6TlXfuIahezMXW5C8LokUceubevqd01 +HFStXUBA8egugKaqvAgCmPpw3mFezwiOkIrNKazAUEUCTxDODK/4g6RSqdAiRZiFF2k0uHz11Vcz +/qJKRW8ZLqUPCYOLgxsf0hQWXHKgc8yrJLDthV48mA+HlBzjY9jIYIcdCiPPYXMlwcOGdR9//HES +O9VyWLF6fv7558N+QoHVzDAR6i2BjilI9Qh1v4MfnzTSG1U4V4vhwUQOb4Rz2EkSiLycRztGfI/h +7RCXqUVXQwE3bGFEiMJMpOEh06kxnmXE+3KL0fKH9H+MHg4pOeQjql1y4FE8yHB8G3JVfVQIjIaA +4tHRkFH5u4gAQzNjNy5FONeEKtCqrBkyH+teKMNYj48Mbi9YpLCb4gXD/bCwDpeuBvcjVMziiQqh +fuc73+ESusSQdQY3PrgKaZxjMVuSwIv4nnvuwfWGNEppTJVDSo7xEVcdpFj0pRg+CVyAwTWMFIHP +EbVwBqZX3/rWtx577DF8hTBhjtHUiJeYcHzyk5/Ekor9mAIEGhtunMMEiEaaW2AUxDJNH5ivhALf +kMcPG2ExzJe+9CV6i0fSf//3f9Psq1/9as6AwOPQyBhRNUZ7j3gd0wLvl7f2b//2b4O13CNCVAUf +Iy4dpiKWUVoY7VlGu+9o+TQ15Bijh0NKDvmIupuvBPM8zlj6h1xVHxUCoyGgeHQ0ZFT+LiKAvIjQ +hr4RjS4OPnjfMGKGbZFGV4bRDq0vQgNnLFIwAb6vnCnz5S9/ORR0Rrs3IzUWWcIEwlvQIdXx+vnT +n/5E+cGND68Oi0CcMApiGc60LG755je/ObzYGDmYTrE1Lly4EGHl7W9/O3MFggFRnjTev6x1oW8E +Q6B7OOjSsTGaGvESoi2MSMfwMzr88MNH7B4zD54dQyOTDxy44F3k4FAiH/L4PCYiOySHVzM9BC6m +NdyXiQiORYAP6yOX8xQjdobM0d4jZIPfMtZlFAm4HwNItYXRIAJ81gVheuQt88UIZfrRnmW0+46W +X717NTFGD6tlRkuwmIpLYBsKtaMVU/kKgcEI6Kw34Pc/OEulFQIvHQFse1AL7rXDm8InluUxocEM +RxukyVBghUEZK1m6MLzKkBwIAMsfdkSqk2b4ro56gxsfUouPEFVYPjRADi+wIzl0GDEaQqrelFqQ +Gd68SKJoqnekkcFleHBcnxB2IWaEITpZleAHFxucxhEmhHewOEiB4Y/PYh6AgrQGV0f25XjRu1Bl +tPeI0y8POxiBwe2PCBE2YzyeELKH2EpHfJbR7jta/uC7h+mxezi8fJiDjP6Pf/wDiX8X3uNobar8 +CY+A4tEJ/4rVA+7pCAzm0T29rxO6fzAoK1yxjLJMaEI/qHq4cUZArXsZZ0BVcwqBnUUAUzFLWsdY +grKzDaryu4YAGwTxIqornnetEVVrEiKg5NGJ8NJdL+/6GV8bKPsd+dL6vLNJ073aaH0631fyuuJ2 +JBFJVLyi7yUMozZutUasJteLal5DxGy29FrdSBnavwILTARE1DMoBBQCCoGXCwElj75cSO+e+/h+ +vuQ/m3dW5srrfX1rtpRxnUzFK2ESK1SiTsXxPZeoOGVPdzxMeL6hawN+NGLVmKZdcoz6+PRkdJ7m +To1qh1tm7e7po2pVIaAQUAhMZAQUj+6VTi0bCQAAIABJREFUb9fXPMfbUvHvzzoPpkvP1MZScGUu +V3JcLRGL1RtNSJ+5SpFimk/QHM8yLEu3HCpprmU6jp92PSMZq9f0rlyhd6CSHkhfb/qzYlHDdWso +bBrU9Ewdd6BZdbF9baPBNCJ7JVKq0woBhYBCYDcjoHh0NwM83s27Xi5derC/dFfZe1I3HMPwTc8o +OfhCOpCo62npXEXXsiYCqaERILbia77kOzFbt4xYupBrqk8m4vGO/r7N3VttS5g2k3UjmtVc271m +W8b3NCp6hM3RWfbOSYOCa+NzaiMLkpEFTcn9k/Zsw1BK4PF+r6o9hYBCYK9FQPHoXvPqXC+Tce7q +zv8pX2z3dc02NMs3PFeHCCvFMhm2aVTccjJie6ZbKMKt8miQaEtDoqGuvjPdu7Un41f0otZfaO8r +FNyaeKw2FS8XXdcslyvOpu58pay11Mf680XH10xLK7qaV6EFxyutL8c3b/Ju0bvsVGJKY2xpa/LQ +VHSebbYamlqCvNd8hVRHFQIKgd2BgOLR3YHqOLeJG1Gmcqdj3N2Xfb7i5iFRBE3Rvbqa4/v8g/8i +ti+7UXkIk7gMGXY0lvHK8GyizkrGk519xY3bihXNjdhaKUsxq0R0d9cdgDPLJYNvgc4njSY7+tEG +azTlVjT2GiFKK+ls3uFqLKpX/Ep334aMtaE7c1tb87R6+5CkdWrMlpDr6lAIKAQUApMTAcWje/R7 +d71yf+mOgeKNmcJGz6iYhh8JDJWmqWP49Az+95E7cScqVMr4EKFw7c0VKp5WF4mkakzdsCtFfVVH +b7ZYQjCFFJ28VqhAwwicWrZU0U3NigcIeFrUwpIqmmE4Fe4U1a4wqkbI9LKvFcqONqAl4oGuOELd +Yu/A5im1A7XJB6bUn5iyTolazXs0lKpzCgGFgEJg9yCgeHT34DoeraZLj67t/kXRXa9hByUOu6Zj +vETYhERFFsXq6RJuRmO7kYorsmM0Yvq657h+fSJmml4253q+mclVentLdAfKhApFkI0LP9Kgzz4l +vlYuCWXWpUQvnHfdbFHKCEkLn0rJQknOHBSzDK2+1hJO1bWSWVnb2Wv6A+31v9ON/92v7aKptScF +BdVJIaAQUAhMIgQUj+6JL7vsdm3N/HJL3135Qrmh1k5Eo45flo2wkBRDgvMwXgYZli8SpPAaNOtb +ul5XG/NNqzudyRf8ciWbSUstuBMWhCDZbpLisYhZLrl5OLiilctCkwi1uu6i4BXu9IPWAhKNxETZ +y2fPQfQVeTdTdILCmhXVkjWolt0u3JTs4kMbv76oZeOCKRehdd4TMVV9UggoBBQCuwcBxaO7B9dd +bRU5MOv8Y13XtZlCXyxisEe15dkxM5qtVGyD9Sh6zIqWnUrFd+JWYiBX1E0namsuhkxoz/TjiWi+ +VOkfyBeKbtSynIJWcrQ4sqbFbmVasaCVccwl5kJMzxW1Mj5EhmYnAtkUrhQqFkUuCdOUc0DcWu+j +Z+3g02zRyrdrP9nBwqqYQkAhoBDYQxAgrvJL6Yni0ZeC3jjXzTssPLkqW34aVWumWCxXotwg6xTK +ucLUulRran7JQbr0Kq6fLvQYRtLw/VzOkfUtrlZfbzY1xvvTWnd/IZd3UdIW8lqmoMWTWoRVKoVA +4jQxc0rgopIntYR6PY0lpewKitApHkq07msu8ihm0WDRS+j0e9Y7FgvLchVxmKt48wYrX0QURtOM +X1OwVEa3xJgaNZrrY4si1g7tFC311aEQUAgoBF45BNim6SXeXPHoSwRwfKp7XrGn/Mctfdc7Xnkg +6+munS9oBa/UUEf8BI3FoMWKu6Z9daGEEtb3dMjPLxK6yEOU1O2IVpuyGmoT23ryPT1OvuTqhumX +jW2dFTOm6SWtnBf9LapdPIngRVkVamoVuNoR2uOf62hFTKjBylFxVmJRKf66KHIxoAb0iaZXZFM0 +tsivyKlwbeC1FI8KG5cqXtQ2EW2LJXI13eruzPbGIw3JaFvUYFcWmQ2oQyGgEFAITFQEFI++8m+2 +5D7bU/x5f35l2XUxZ+ZKbqXiRqJazDZjqGFNHa1soVQssIzFFl+hYt6vT9ks8iwW8T8ym+rjrY2x +bb3ZjZsqhumaca2cc7v7XSuhJVLChbmCZtqi2hVHIV44NFzBxVcI1aJB3H0rAgK2T1kAExyIp1RM +xk3Xd3NBDpIrkih14eCQUHFTKhRhUIPCedTItoF7U5mYSfTTxO93IFvpc+znbX2KpU8x9Z3ej3N7 +V9QfhYBCQCGwZyPwwsC5Z/dyovbO80pZ79Zs5Yb+UnsBp1vi95k+TIQLbjJhxmI6GlQ8eXxTK5XF +n6iY04oVvIfc3gHY1IUdW5v11saGjt7uvv6Kjxib0JAwB4oO0meyVgivUBSChD5R85aKooOFO0WM +DdyISoEvbjRYzSIgY571tESEpaJW34BTX2fn8yKQQsDkc9AgK2aQWRFMaQeptFDyUOrysVjyoPxI +REft7DjE9LVtyyyWila8veBsMY2Ebc6wtFacnKQhdSgEFAIKgYmCgOLRV+xNltzneoo/K1SeKXkV +eMc2LNsycrqHZ1CqFgkS3mSBC6ZPn6UpREXAtFksOKz+DDjQRTaNxbSalLV6cwelCmU3ltJYUNo7 +4Fg42VoSyagA7xZEyizjYVTS7KgmlIl3brAAhjNECLOSEC/ewD5KosA/EXa1jZuKECcHNMlFqFRc +hOFUJFcSmlApJCrqZaiUdlzfK/jcxbe1bLlUcU3T8tNeKR6JuF7R054ta2ttY4alz9AVmwp+6lAI +KAQmAgKKR1+Zt9hbvHHAu8rSvYpXiVmRcpGE150tJ2Opg+alBtLZpoYWy6p0dHXX1ERr4nV9mbST +IdafeABJtAQShjZ/RgpxsD9ThDJhL72iZfKQm7gIeWUtm4HYhN4QRkXKTAUkimW0KO5FoS6XtSsc +qHnJEb1uwKfYUHE+EmpEQCUaQ3BAzCGVCuNiLg0kVwiYYuRDpRY3Qp2rScvwK0pjtNMoh1nEapl+ +IhorOwXDIGb+hrK/OWrNMrXpLMPZ3rr6oxBQCCgE9loEFI++3K/O8TJdpasy5Vtgo2LZgJUKJSce +jeUr+dpYojneuL69N192mupKlcBZtlz2e4vZgUKpUPShRoyUImta2pQ2bdq0yMo1Rc01F01vLlYK +67ami1g9Da02EoFxe4plO6bFg3BF8Bm1uCNNwsFCfVhWcSmSPPHXhQ4lBSNyRmcLuSJ3Qs8xDQGY +PDhViFYWsAYfg1Wi4twbUCkVMbjSDlSKfhp+ZXUNTB+6I+UIPWgQJd+oOI5puCxUrXjrKtomqNQ2 +Zio2fbm/gup+CgGFwLgioHh0XOF8scYKztrNA1dE4psTkXg6i6uQQ3Ai1LlZIibktf6B9IqBNP63 +TXVme29vNKLHY2Y6X86W8hgyc4HbrdBYRRS/s6bWFgrRroHeqc2pVDT+9PM9kCgrT2DmSsnr6HZQ +yRJNF0mUULpQGkRYRhINekg6XOsiqlokWMIvwIuBIy4hHdghDVq1nEDf+0J5JE5qcRDdlzrCrLQJ +Ewe5UCykiw8UjlFsLFNifWsp8FoibC8OSmUt7RVr4hE3iB0Bf7vEfNDdsve8q7Wb2kzbQDZVX8UA +X3VSCCgE9jYE1OD18r2x7vwtXfmrIlZRd61spVSo+CzjdBw941RKlTJOQDjWRuJaY50WZ3EJqzwr +fjrLZiu+iIZwpKY1NGi5jFb2tFltiRZr+n2r1uq2NjBQ3LJ5cybvxBMaXr6oVju7xeKJnxHK1XxW +5Ei4WfgM9gvOIptCq7KIRoiQwhzbJUj2Kw3yUQgjmKIE5nBK4lqk6xYGT/6wEgfxlQ6xMbiLyIkQ +63tsC+OyqRthH6I+NByxdDS6kG54U1THBdONR3leDwdfj0ssPBUJNVfyVmn6pqQ93zamys3UoRBQ +CCgE9ioEFI++HK/L9UrdpWt6cjdAP8SO78N3lgAIeA95fpmIfxWRNdmDG0ZKIEFWsDQKh2Gk1NnF +peIiUFqGPXtKtH/AsTWnrsWpi8SeWtte9Ev1ca2zw2Enl2hMiyVFRiyi+6Udwi+EsQCRLC1xJkL0 +FJciJFEWrqBxdQJJlKC9gWTJ6k9EXvqF4tfyYhHCC6YaGutn1DXOenRt/5ypR1lmROIpcRgsZ8Xl +FxKlvyKXEkzfcSquWy6VUUizYxtK6EzJKcaiXiyu59nALVANI7BGLRopV8qePJ8hO77Bybj1en5p +oPS4bTbGzfkRU62QeTm+k+oeCgGFwHghoHh0vJActZ2S2/FM7+Vu5blkFOL0MsR910zi9sEukChk +icxXdhAXRXy0TROGg9JY7skuoK7nIjXmchCrVyxUOttLdc1aQ1xb1zGQK7hIjAMwn/j1ip8RUiB1 +5WNUrKGyWAWzqMS1D+gO0iOKQrBehb6Kb1Fg1KSKeAZ5sZpIa1vD/ClNC9ualrQ07pNKNUajUKb2 +6D1faaibMtLjiVDKwdrUwQ5DELbrVuDUbK7Lq/TrTqfjFHkc5gnpbCkel13AsaHaIs1Knx32UEWr +y9JXr6+nuDwRmV4TnW/o4TY04R3UWSGgEFAI7LkIKB7dve8mXVy9MfvtbLbdczFYGrGoMadxWl86 +29ffV5Z1lhCllhdCFZcfnHQ4EgkdCRL6dIpanmhEgXcu8YwoGk1pzVOEdz3HIDhRJuPi3RNNilct +dUVrCxsHcietia9ssKwFzaroeUXE3e5tJMEckIaLrD6pa21aOGP6wXPbDp/auk9NKrXdCirFd/GA +Gg0Wj9p1qWQd84ZCIdOf3tCX21zRioQCZokPPGoijPo+2mFR74rrr4uYixaYBbPFypay1wWVxsyZ +ojtWh0JAIaAQ2LMRUDy6G99Pd+aRJ9ov182M4ZjRqM5iUAIVbOjorQRWR0gUIZRNV+BCEkKEPvKo +MAcWSkLRs40oy0YhWuRFuAdOYcEoYRBqzNp5c1qXr1lHRUIxsMgEGRTeNZzAkwipFHKiTc4vsCnx +HGT1iyaRHNASm06ytXbegvknLJh11NTWuRbXds+BBRQ2TSUPaC4u2Nb9bDG3yUyKxZddVHlY+cd9 +w36KLZUVMnwmkkOpP/90Kt4VNxeaes2Odw1VMzulomfGyCtBh0X+L/nYZJ0Ka1sjESyz3MGQCQz3 +ZskuTsvigYWmm6DBUdNIGVpKVg6pQyGgEFAI7DACasjYYah2smBH9rbN2Z/VppxcPupg83T9UtFL +433r6lFLdiaLmnYOLvV9dJ5xtjPz0OuaOOBgpIQ1ibFLHF0MiTAD+l4PmbWiJVqENVtrazb29GVL +ss0Z6lyX+AwsG0XcZPmmcIfob0MHH1aFIoSKj5BEFtQKGa3GnnbYnNfsN+f4adP2i7KJ2st1xGLx +uTMOHEjP7OlfWfS7jBoXxbLl6fgkCxawGj1FvYtoDcXxyfAL5W7HHIhb86LmnFG6CW0WPD/naznH +y5adjKaXLQMaLuMRjEsUMnxYUYRgQ3fKOg7DEQthWG6FcZrNWmFarMUJOBbTMsWIyGTWaX7CNOp1 +v1atyRkFeZWtEFAI/AsBxaP/wmIcUx2F6/P+X+Y0t2zp7TGilQEWTHo6HrkEcofV3IpeYHNQv5Il +di0foQ1XNmaJBbyGORPKLGXNHBtxByGEiGSby2p2XKup03RHW9vVPZAjzLwYF1HeIl9STOIw8ABB +eASRsaBSRDJI1JZwgFBMc3zJsUtPW7zopIb6hnF80p1qqq62MRE/csPWx4qFzQ31di7vSdBgCcSP +N3DgdcQzCJmKKy8PWPLKnr/a9fMJa7/ggtwNLbXrpSteb9nrrTgZ7MuixMZvC9JEqLTZ5Fz0w7gh +RzA2Y3w1RBFgm1FWr+bdcrEiO7nqWGl9whfbyMVlr5wtlCMUMY2KX6hUCtQPRHQuN5tas6E1qGj7 +O/WiVWGFwKRCQPHoOL9u1pV05a7Z3PeXqJFYt3lrrpxldI7GWBZisr6T1aKe4w/kPRxxxfCJYtMV +cZNRW3cJrSuRESqeL55HZZHYoE+hGZS3cS1VJ8rbEo5FfolBvz5p9LOwNCs6YZa10AJq3jDAEMIW +ZAyJwtOVtDa9bunBh5y7/z7HJ5KvfGxbDKdzpx+6qd3MZzfXJCMSbAKZPOgwcqhYcMVoiirWj9ni +0YuAXnY3oeqOmrM1PVdxezytj0gO6K1DcRO9N2ptXQIV6iCGIK+btMducYTLl0W0EqNY89m2nL9R +S3dc3IMpoEsI/pJr4ZHlGJ7uFRD5EZFNnSU8kDitmIZT8bY6+jZ8s6BSS2/VtXpdS4zzN0Y1pxBQ +COzlCCgeHc8XSBTZjQM/yhfuKRbcrdnegiPrOuqjuuEasB1jPZZOloQy0Jeyulg9oU9GfiIYYB+N +ubIdt2PirAuJisDpyRpQqJEVMpjwauslxoJsH+poU+oTSJ6dvSUx7eFYxMoWXbbshoZR/LIGBmpJ +d2uNsf2OPOy8pYtOeDlVuC8KqGkZM6Ys29hR6M10pqIRBExUrC6oBP5HABKL+YWSzwZwstcND+bj +h9Xha10EIA6snnArD8o8gdmDYRhi7fR8qU55ZFU2lqMA3lss35HphbCmlBamRdDUDfyg2Z+V9a4y +jfEd1vGK8juIKUF1WoeUccIS0VbstewewAyou6L1smZJc+stfTYxo170MVUBhYBCYJIgoHh03F40 +PkPthe915f5ZKuqFEuwma1eiponECYe2NSZ784X2gUqxDE+gZ5TRHeGSWLjIowk2ByW4vGa5qCPL +PnInukfEUPgADmAXUvbrJkQfHrxiOi1ACf4Wlo9CJDgZCZ2IDxEyGnITQ306rUUqLcctevsRy87e +E2TQ4RBbxFxoOnBDx70ZTTaU4UGEx9BUB2ZLpgvQp3hhMT3w9aLjxiPil1Qql+0ghAROWFAm+luM +qcivpi3ESSZnrJ9YQHNFTKIwsa6zbzmwEpUQ3MStSfYEEO8jx6VlokrQN+YxJGyUuhJvyYdxubOL +rVmW5fBJj0e4mixVsrrBaqF8Re809RYiGpraK6YhHw6pylEIKAReKQQUj44P8kTy6S39d0/+3kpF +LG8oJpGYNNSwrHfBwzZm9uZLfWl2PNOTKWxzPjHls9lAYYsnEZpJJE6WfgRjeoH9RwP/GMZ3GoE4 +dN+obTITSbcnFzCrZ2bQFxcryTrZjls8UA1R+cJE2AiL3bFF045/1WHvndo6Y3yebfe0kojXNCTn +seuqGRV+o/NIiuwRI3pYibIEsRoOUwOolAlHxWWKwJzC9yuQIpEUHYdYSFJYBH3AC+2jdBV7p0wt +dGIichWZHvqUJUbiaSRSqRhevfAeCMEyL2EuEmiPXaiUeBe5okOEfVTlFGdOA8WyzLdYGaBqNGKy +q51lYu5u1yLpsp+M6LNMvWn3IKRaVQgoBPYOBBSPjsN78rx8T/F7eWcFq0ogP/bgFKnJERkR5S22 +0bLsXFbBeidB/tLiA4MlMJoQjoQdxL1IZ0GnWxO1MI5Si93NWPpCmEB4BDmsp1xecpAodfEYgjMI +9Q5bE7cPYhBdpRCDEOpAn1ZrTT/58EuXLT4pUEiOw6Pt1iYa6mb35dZWKnmmArqBTxGSogDCo/k6 +H4TJsGLCr4AAHYbSKpMUlMHYmSU2MM8fMKiYPBFowU4KiVxOhrji6uL9y1V2puMqZfhHraBlLvkW +/IpWPFATi1uvZSZjFlVwUKJ1qhBXvyB+v7K7qulC7dAqml7eF5vKsedqr+bXRYw5eCTtVqxU4woB +hcAei4DiUXk1xN8Ri1i5nyG2UMhjrfP8bC4/AD15frFY8uvrG2qTDbbRYJnsRx01zDjSSfhSXa/Q +Wfhxe//9kUgcC6dnOGhuPdeK6rjdsnWoG6vVCRBfLLps0sLhmb5t40dDGd8taEQ+YBCHNUvocsMA +Rvi74K8b7DkKqcIU0Aaa275eoVW8YRj3iQQIUzLcQwr8w9uor1NbMPXE04//WGsre2XvHUc0Ek3F +WvpLG8J4+jwO/yA6eSgdhS0cKNQokX4Dr+YQcQgVgygeWwS1KBTEViomUf6ER+AnBKTiKyTCqA7O +UG48YkWiJiZR/Ld4dRLml6kIKlyWF1EGppaoSlquVOLONvreoDNE82dpjGwqxzuCQuF3QgfLLAml +sewEG+FVut2G2Z2yZ8Sthboe2TugV71UCCgExg+BSc2j6UwnajrbdhOJeDySqKmdarK204ozklec +PHFgy6VCX39nz8CGdRse3dS1Ku+0N9RG9pnV1ta8r+vUu07z9OYDtqSv2dB7O64q0TKEi9UN9xYr +Zdkbu9jOxSPOLaNuLoMCURSUsKBYRhF1kJksLVEnJMoCUISoVELWjJaIk5CXPbdZPBouZcmkZe8z +IugWAmE0dE1ik20xl0q4hsCDN5M6cdnFJx71dhnh96qjNjEt724St9xg19JA6eqLJCra2u3UCPnB +qVCaiIXiT4RkKatrYTswzBcJki+XwBBylRJBTTJT0SiRf1k1ij8uls9C2SO0L2XQ5VIY+ZIylBWh +UzyEEUaFLyXIVBmlspA3l1iBA6plgmKIu5MsNkXbjPmWN16XihfLJSL3Sy2tPVvJxu19Lb1+r3oD +qrMKAYXAS0Vgbxt3X+rzSn2kz2y+S7fc5uYpEbvehq8YfUUUCmUhKWNbCf4l4/UN9dPmaQcuc84k +hMKWzpVr1t3xxOP3PKbfOKUt1jZNdzMNa7atYwBvqrXTmbJh6XVJw7asfN4oiQuM+L8gPFkRHGC0 +Us6nAP5ESEgQAHtoo8/UHIZklzgJyJcQKryIu1EETsWJl4UxBNPLaYkaWV1KAv5FUkJ6g1AQqxCi +Cb1rFFvfdPynDlxyrPR7bzsSiYZ4MeawahOjciD2oZrlEGkb5gqYlK1jAvE9IDZR1+KFBLyyuNZm +azldSw+INMrMQ8RPUrIGRrDKAycivujXhWhZLYNoK1GiAocsccyVW3Hwplgkw/RJLKbcGkUyC3Nx +BpZrIpiiImYaZMRtU+7LRnDo2z0U7+VY1HJdXqEItxUv21d4OIhoOFv6qg6FgEJgciAw6Xi0UEq7 +3kDbtHkROxVyZ3gOXzfpQK34wssXnaGE4mN4jSUT+8w6bHbbYe1dFzz9zO3bctfGkrnNvZsHcuai +6Y0GvOeXa2J6sexlcqWefkZXdI8+3rMSBUA224SbfTvC8kaNZRaM7UBvuiYqXzG+MdjjcRrsD4qg +yUd8aETcZPcVW8IBllk2ij5SF6ItEtgvMKzilxvzZ7319V+fM3v+Cz3ey/7aVhRVealUiNq48Ei0 +4ZCAQAOgRLoMLKMxNlxjlWmgx0ZJ65XZvjSIX8G7wV2ZeE9UBEYYU/grcC/ixSFj4vYMLwZNcQWu +NHgLiI/MURBGA/Uvgqbcjj9sThfQn7QWWJ2DVUWoD1zeAvEMLRNtPebSMgKoCKGGi1OSBEjS9HSh +SFWql9y1rt8ftxYZmgq1Ly9FHQqBCY9AaHKa4I956623Xnzxxbfccgu6vebG5hnTltpWcjB9hs8P +gw4mUUZwSEsMp7IGAoNlKZPJbNm24c7b7s7n0wceZGezek+/P7W2lnWG23qzqbiF9pVRnnBFkZhf +Uy8MipSEZOMUfVw8LYxwYTz6gEdR3rJnCytL2eCMCH0hMZCJsTPTJ8TJQI2oDEkgoRKQASkK+qyv +F1pl3O8f0KKVOW89+dt7L4kGsOME2yCbx2GHDGjMCtaiCJ1BWSDAPqZIqmIqlayQq4KkUCwWaOgw +FsOtSERGDsREwKEuyluqUyGsycdQ6Y3zMwZR0QegA5BSrJOR5S0Uk5LCuFIPxoWNK7hbV8S7lyrc +Op0v5FEN833AUB2UF40u6gXfi6Fu5t7sGltGCO7LlR+teB3SIXUoBBQCEx2BcZZHBwYG7rrrLjRm +dXV1vb29BEB/9atfXc/YP+w4/vjjV69e/eCDD86ePXvYxf+TMVRG/D8Xd+jDunXr/va3vx199NGN +jdPCUXXEav/nRoGAiG6QlQ94jhJSjqPklrds6r70g28/7JiWy765T0e6MqOxYX7DjAfWPWtG3EzR +QzCJEDogpqU8ayDDlmeBZ64MwTiOyj0jEWLlYN9zGX8RSU02SoMmcf7Myz9WvyAn4XnLIcO2yE8a +zi2kIVfGfRqJJIVT2a0l6c19y6nfmTVrj17cIs/wYkcsUsc6FoGDWQdOuWEUe1nQEoiVBK+XXWKE +D3l36GJRwNIkwZvAkMB9cDCJRFLP5UAbPhUFLIiJVjiITIScSUVZRgM9BlImK2dgTgg4btuxSLw3 +lwlM1gGPov41fPTG3FwmVWxKw/oZ3pQItbwJ6RK3gEqDjcpFl8xRrjiEGIz63FkaKVZKsjDHWxGL +9MWNRULO6lAIKAQmLgLjKY/29fV997vfJfDbiSeeeNRRR5100kkMPVdccQX5uwZgOp1eunTp6173 +ul2rXq0VSplsQT0GiYaFZahmLGaLFYTRgEqvv/43+8xt+863Lq/gelvRprXVX3PjGy/+xPS+tJeM +RWY3Ni9fv9aPFGnb0iNTG1I4cLLgs6/HGchIgIXahMijNMo4zmiKFY0RWYQgid0jZ0ZzHIvwG2KA +xs8FzojEZN0LhRFtceLlDSFIQTB48DJME003ndWcdMvZJ14+AUgUtKN2XQwPZva6gdyE/3hw6DII +zgfziWhoABpsJBQGEaJmDQzMaHqZduDmg7YAJKMRuEvwLBQ95FR9O8cJaDJr4ZBlMMKmgEkV7ogv +2UAhG7P12pTs/SLvhbW9IuZyK7kpdXkR5ODZhKCMjxKyK1Ml7KyyY4x0FValpJFn0kRBX6uNJ+Ps +D4ctVvdzxQ055ynhYXUoBBQCExeBceNRhr6//vWvkAWJVatWPffcc4ibkAYH+WSOgeEFF1xwzDHH +PP3002efffaSJUs+/elPh4VRxnZ1ddEOV++9914yw5JIsaeeeupHPvIRcjo7Oy+55JIDDzxwwYIF +b3rTmx5++OGw7oYNG84555x99tl+MHn0AAAgAElEQVTntNNOoz9khhz52GOPwc2f/OQnw2Jnnnkm +H8tEMRBXFPeHP/zhQQcd1NBUv++i+Vd851urVz/96cs+kU4P/PTKH596ymsqRXv11p/85/tv+v2V +HWXNTSWsP9646osffuSS0x7/4NlPXX3F+q7OfKnoI4l+/4trL//Q012bCt/85JrPv/epv1y9GWml +tt5AbIIy8GthxGfdBPRJGADLMhmScTsyCGkElUqkvGDPlmCLbwZ9DrHnsfc127bktUxH6pQjLttn +n3nhI+ztZ7ZYcT1WpDBxkS8JMrcFRJBP8JUBEORPO6A05EjyYTFxtSVh6nj9oFRlRoIzF/OPwGMs +WBfk+hiqhXblCymiJAlIjq+7fOMJWMGi3kCNzGqWfMkrsXkOVwJHJ5vY9cS1cAIylrLi3xvobiXK +EhMdmgqjFeLKS5v8J75HdDgQlwvlAoIwPeU1Bx3uzbuKSoFHHQqBCYvAuPFopVJZvnw5nIA6Fw5D +lco5VO1Ce1wdA8KNGzc+//zzsOZ+++2XSCR++tOfPvroo5R/5zvfyXnq1Kmf/exnFy5cSDosCXHO +mTPnkEMOQdf6lre85Q9/+MN55533ta99jUbOOuusNWvWQNvnn3/+PffcA++SuPnmm6m7detWqDSf +z1Ogvb2dHI61a9fyMaTYyy+//KMf/Shj7hVX/OCTl31mzrx9WlqnnPr6Myj2qlcd/6EPfS7r3tmZ +/ueW9cWOjgID5WMPdX/xw08MdDlf+NphJ5zSfOOftn3q0qdzRdc1tZ6OctfW0k++vL51RjwaN+76 +e3f7xoIIXTi/YENlWQtuSTrbpZmNNRbh6SUTWYo4PAzHxJ4jHTjOMGpTElupEEigzOzaph25+Pwj +D9krvXODhxh6YkmL70eQ/qFGOC+Iti8aUpyzeGq0u6WKjx4bkkOzzQFnwZ3iQiQTCxSw4mQbkm4i +Ia66gCw0JuH9YDh5t4J28Jem8OAVaReuowHBXJoqlcX/i3/FUrA2JpBNQ7GV6qh5Wa2EkIpKgI94 +WUtMhoBcQ2qnKW5Bb/kXtEyG8Kvogbnidxb8FfIA6lAIKAQmIgLjZh+F0nDDaWlpmTJlSiQSQbsL +dyLn4Z6DoMnVFw2VDhG+6lWvam5uJvHII48cfPDBRx55JJjX1NQMUe1++9vfPu6447h055130jgC +5Sc+8Qk+wqNcuuqqq97whjc8++yz8+bNo6lvfvMbcRZgatojj2wXVUmPeKCCJv9//ueqJQceJO4q +mEXLlUX77U/m7NkLjzxqfq/xFcMQfkPxiJ/tzX/qZPi++OKDDnl13awD25bf3bfm6dzqFbnW2QlG +W44zL5yx5NDUHX+x/npN+4Zn8vMXplDVsmIVjWMkKstM4cstXawyFSupyJ2BBpi60KroOYm3gNgb +rH5h9SSia3eX1mAefcrx75LWJ86Bq1EkWxSiEeYMmZLVnIGqlheByEk+3rpBLHu25xYKlHKB8w8F +ICyIjUxUr7xqbMnhvINCQqjUDTx4kUmpJEF4he0AHJFU0gHnYZcNqBTRFi1xyNlBaHuKMQm0CfBr +kZT3QiXUzPEoUQw9KFy2MBV3X4nQK6YAHMroDaF/6Y+4LzmsHC477QTIj+r7I2xzR3UoBBQCEwmB +cftVIwJCV7AgRyrFCvgo3Inwl8vlyB9brxsCCnGSQB7lLMLD6MeyZcvCi+vXrycBj4YfDzjgABLI +wYitJGjwN7+99u9/vxGFLR+h9rDYiOfu7m7MsfR8yQEHIRqysSd+lxyyexmCoFtIm1eXnI5cXpoS +VaGl9baLR9C0uW5Xfw/qx7mLEpvWF7duKk3ZJ4EwxDFv/0QsoSWT8gEVLvumxfAq8k22j2ZILxaI +SiTCDZyKEMZgvZ01CYdE+0G0dHS8/JM0NyV2bk/dm058P/66PBD2PKGFgHjkZnvxQVRbAteLeRLG +kycKHx9BvOzFYxIqHknUwdUIXhTlK5K8oAFJSWmR+ySfyAxod6OskGFnV6I+bWdQaVMIVJyDxEtI +DpoIapGkcUmLPXR7pjA3OT5O1IaEMqIijCv7pMrHqB13/Qrya9zg3ZQrRhDYQTcI60jcDVHLBwZb +WTqMWoH7sT07dKqz8LQddX7MOEBRafAO1EkhMHEQCMb78XgcHDT23Xffnp6emTNnooltbGwkQN2s +WbO2bdtGPld3+SYhC45Yfdq0aeSjmA2vIo+SIHPRIpwkNWy0t95yG3QetrB48eLA10fKIiVD1ThA +hT5QpJuamuD7bDa7csUKFjuweqEsRIq3rpQvuitd+6nQgMdHJI+4ZTa1wora4ys6WCRqRYwtGxCp +tNpmpBEZlznE7imUHDx7ELGIxYtQM5ZRghPhyxJjxUtcRnlWzpQLEmseQkVvCVpodOHgUJPJUE5O +tl9bMvu0/fbft1QlgzAht9q7D9O0oS4mB8iOgfgYqLhFEhVFK3lwoeRDmIAD98FFwQxQBEEIOJhz +wHayPgbeikkmMFI+/NoFIijFxNJJG9KOkLKkaRbzquTI+8KOKnVFZ4u3EStceB2o2aFVHKdldqNl +CsRv5H34mYLsKUMNWkK7y+IZnIephd44sPWKMxQV48ySZKmNWHTLbnfJfUbupA6FgEJgAiGw6/Q2 +BAQso/j+hO5FyJSse0G2w0KJfhVPH64OKb8jH1kwM3fuXGjygQceQFgcXuXYY4+dMWPG448/fv31 +1z/xxBOcKXPuuefiKwSXr1ix4uGHH+no6IDdyZ85cxZnKBbXJzp25ZVXnnHGGRBn2Cw6wvPOezvp +j37sg3fddfsTjz183313Q6SLFh5C5v33LV/5RG96wJGgqriYWibyx2tObyZ92w1dm57L33lD9/o1 +hda26KL9kpmMlOHYbu8MSJWxHv1tPu8V2PVMItgJU8qyFiTRMkEBJdar8KWlsZw0lhIhFUmYxTBo +KUkQod7L1x+07xtwJGZDE+QtkVDD2+wxZ7QOQh07f/gea4Fk8gFxbjc0gkbAhTTGhmiIg2i5xVq8 +nW7DLc+gMNHx4kIk6InnkTQC1HQisH0GVmea5Z9E/A9WIAVUDfJ8JYP6ArsEHZS7+xH8qEOfpsBH +WnoV3BEVBVMcEGdSli2wIYw8KBpmOkYZ2YWN0II6USXFsVj2bOM1SfRdeS46WHLYWMBCpexo2xxt +o/RVHQoBhcBEQSAYfsbjYdCaIgi+9a1vvf/++7/85S9///vf/8Y3voFz7EUXXdTW1ja2TnWM+3/4 +wx9Grn3jG9943XXXDS+WTCZ/+ctfImheeuml2FDhyx/96EeHHXYYkuWXvvQlyBsdL6Pb2eecHdZl +8EPuxE2Jda6XXXYZnk1Iz3IpGGq/+KWvvOPCdz780PJ/O/uM009/7d9u+DMrUmbOrz3ptFnrns1+ +8C1P9KVLNTVSnL1bInF/32W1H/j03IE+5yMXrLriC+vm7Zt836fn5koyYCLTcDBM808IITgx5haK +conBllGb6EX5cNmoo3V0bmdopNKQfQN3G1HqipUU+TWrzZlyVGvLPsUS8rW0hwDHUA3x7BJzSQvj +dSDxM3+6775777nn7uUPPbhp0yZydq5xVqmIwTIgM+Eq3oiRiNiRiAkOcsnTcTUSLmQSIoIpEh5L +UJh8iNZXWBMbsy0RGyjA/wj6yKxBRUnwT8oE7khcDW/Ewhgpw4tgo7VgNSq3Fe16MLPhvvAx9+IN +QtJCrqFALNSNa5JIq56rB05LQTG5i/SqNhFlnoTpVNbnyBpU8WDHhoo4K5uninl1vad17Rw+qrRC +QCGwByOg44lz4YUXjksPGT2xhiI4YhZFlQp3IpjiJcR51+TRaq+QKWFThqRqzpAEN0VVi5cT+eF9 +SeDlBF9ir60WrrZAPhwc9oqBme1e8O3ERMYGoYVifvPmzbU1tYyjuUy5Er++YNzasbWQyTnTZyZ4 +sq6+MkM38mI8rtdFGRn1dRtzjPh2wkxnRJkXTwnteWWtrlbGX9tCABZ1X7nMVZZDCm1LOEDSuKtg +7PS1bE7oUPZ4kbCuEooBdaLYC3VpSlYrFiKnHP6Vgw44DsWhjZhjMSTLIhmYgAOilmZ3z/GVr3zl +M5/5zGht41yGUxiO2YMLoCTAm1oee8eOnsyKLV1r4C2OiGzZjfbbT8XsVDKaKxXBDY1rwEHwJa9L +5iKcoMZAHgVk4buwegmtd0B7xPeHIMGHXgjXIlmCErcIjK/kQ6vClBhcoWppStI0ROb22QkVCKhk +6thoS2ViccjCYpbWBKJtUB5BFtW+SMASNJ+KzABsfHstO8dqY2hW15gN4I2EsIpKn7j6uDChO7ZN +Ah0eaGjBpCy4tTopBBQCrxQCiHzvfe97X8rdd0XdOtr9oKXQwwh1KHNwbKJQGseOj6ejtYwP8GiX +wvza2tpqAbyFwzSJKolWGTS8hNp5e3lRuyE5BJKQeF6S1Fpam9kszSlZZe8p17qvkHdMW29uwR3T +LJVL7GJGREBYtw53Il8fKFYwlBJTnvhwkShbn7EBm6xsER9hWdoI5YnhU+4TiDRoA+FLPsCXlEFX +yZJQbopgxEAcTckwjVRkxUTcFO1tUN126lsa5hSLeXpiYjFk7aNItTgtCVUw7odikzzUqJON7U88 +jn+Yu7CoabjKnYkICIdW6h25HfIaj0DPeRa4DE/mguFkS7JEJRkzXZtXJPkwKGjAZ7IbTECjEhgB +47Rkyn6kCIQ0ApJIkIRaZDoCyHBk4CsmwFBJKFfejExT5Ix105YEEi13D6hTw+BNI9yUg7kPioTt +LB5OWdh6nUsU5SS1RA7mjcRsHI+RRB0i+NYnUp0DAxBzocSGQvj/0nEDpzWKWSyh8QuesSJhHorj +trQyyQ7RGPAueBPBwXw3V8wVnEIRxzuvghhPNhMn27BjVixuxZOxZPVHPaRu2II6KwReWQTGk0d5 +EiiTI4ZH6St0QN5V2ZexeUT/pn85D0OGms74y7DIgMhoLbFSPQ8dq1v2isX+rPl7o5SN+LGckYlF +zL503jTdck6rq7MYC9MZz03IPqBIIRJjR37+wqCEpEcfy5DKKC97lbCIhSE7oDrGD9FP4gtK3CIM +foZJvVBjyRgr1ZGNHDHXcVBF1k0SZ66g1USnsr9pBYo2bMQs04IxAioNtJRCPzBBSEXk76gcKHd5 +Kcf69euGk2jYYE+v2KR38CgTEwGKCiiwUHbxhhXxTozHbq4gcQGhO0IUQYCEi/LBLDBbMg7jFktF +TKqBlZT36AnhYTx2xIEL3EQkDcRciglHkg6BYh4DAVM4YESagoxpi2WsvC+5SxAqEHMpMx7CLHCR +zKIYgOW1yhcn4FTolgUtyahVgD9dLYm7ke2WnCLK6eaaZLYswjTRNdB3BKpjYhrKvjJs6e5b2YL2 +TMJcSjuT5ABSDn6SMCgqq62ZrU+mV67KrH6q9EyH09WrDWR8YjsWStj/cUHQI0kjXuMnG/W6KVbL +EhwPavY9oHZxW01b6NLPr5h2OCYJeuox92QExplHX9lH5VeK+MtPi8RgEq3+2KoMSgEyWYPPKBnQ +n0iTrPhzGOGIpeu55YrVX/lzd3Hl/CltncUsIQDxs2XI7e9Bl+fX2GYWt02rwEjOII64yZIVVrbQ +KJu6iEqWUkAbxC3CdYjNvV1H4ttlsy56RzY+Yxjm1nSTURsdr4hQuL0E8hDX+MgBGfCPprhU0rZ0 +962fEd/f0WWxDXWFR0VNKf8zzHPIB+pSntZfluEl9HaWew872KN7WN6oGSJ5CjEFrrM8Dv47js/E +RZ4HWqzIrt1odAPQkFYljhAaDwZkpg7gLOs4sY+iNA1FTM4Ba0KlaUJYSMgoAQTK5NWEyEhbvEGC +EwXeTKAlA3KoMSDcMZwdkG6ZbdQCf2D6gJM27yKw1xImQlx/RcksBI/XrhmP2FmWMZW0pmStpmfY +5ds2I/XJZLeTLpQdFBdllpMaeoJ49igU2OgHRbWZdvwOS38RXcuoqO09F/i50Vl+cYiea3rX3NP7 +wB0D9zxWXtkd6feTpt7I1zf4vmJYlnBVcV4EXFrWy31+aaPeq+lrbyrcp3e5zVvql0UXn1B77LGN +Ry5oXMDiumrLew8YqqcTEIGJw6PhLwphlESYHvy6BjNomI9NFLcQBmIEUBb6I/pAoPzOUUqz9XOh +/Gy/d3s8HkVMLTtF9Ep5txglfLlEUdfau0pW3J9ab1fySKWyORo8ylCBeClih64nYyI84REUiwup +obl1y/5Ank1fxFzHIUY7ZFPWugRhFsiR4d4WSuYCY7RE5Q10v1Svq9eymZ77nvrOKcn/qm+azv6p +4nyEuOo7tmsxqMtcAGEOuyBKy0BFyehPRRmcggFKbrkbDvy5RmyVpT8zZkwf8dLwTF5NsZSDz8LZ +Awm6TOdRqIJSVOIo4tgFDUlVUfX67F8W7P8i0w6JdiQUyIPLNGQ740oLzFei4vzMFjoBA0sZ2gCZ +UD1AgVBaDXW21IYUmRVxkOAqUxyUw9wXQZOKbM4Tvjtag/ZtCgVyKeSKKdQtCSWza01fJst2s6wi +LZYKHiEZLJ3FU1A/r4aZABF9tYjEIMQS77lFXV+VjNQZ2iumv5Gn3Z1H+Evk1QxkBu7tvP/3XX/9 +Z+XBnmRGb2IuycQvJi/yX05pwTumP+E3gHN48IbR3kTtbr14q/bQLbn7mp6reZV9xDktZx7TelRd +TV31Li9UUH8VAi8rAhOHR4Et1CqHP6qqRpePYU54pliYEOoJ/DsRKlC6wXkiiroEo/fKpXIxcmPM +GohHYwPZ7D5T29Z2tENyjmtaNuFpNNf0o3HdKWqZrMdOL4atewX238KpRMsMQKdiTuM2qVqED20g +60KKBdS5GjEZZIwgUySbwDWU/oQ2URnrOZBERcCUYtzRFwdPUdgmklpn+rkb7/+PYw+6ZP7s4xm2 +idHuIzbFPPFfYUwPthtDYyxUSpVAohUJdXfqeGfPnrNx0yaiPgVd335i0Jy/YMGUKVMHZ46RzuQ6 +HTfDU4ccBpsiwcsjyASHs8P0hc9MG9DiEggQJkV/C+2xBhichXcDxOBdIcjw9QY2Y66yBldcuoKV +qZSkIMjLjYLJimAeKJNhTQINodqVBTCBWy9b8UhYDIZ46gTzHt4XIz5tSg+xyIozrlzixOwqEJ1F +qGVRjB3EuMd9F+0Ace09Cx7GtZiuibK6jJY4CKLP6hg2Wyu5q+PmQdLQxDrkVxdocbO57K1b//Hz +zl8vN56sNPDt5OlZ1BUg9gJvyqODY/XjiIntvxBdT0R7k+U/e3f+vfOOwzsOeGfL205ue00qmVKa +3on1DdqbnmaC8Gj4o4VHwZ60iCbBEf60wqtkkiCbYZi/MI64h7A/KBKORFsVJyOn5BQKVtF4qGQ9 +6RXMgUwxYsR6BxBFco2RRHeJSESwKWsZ/XLezwVOLnZCOJIRvLE24hTRXBUTNRLtiA1giIuL2CGD +OE4meBUFmk6hT3RWOIvSFVM2E6VPwrLBxt3kihNNoEtkbMfUit+v2F8D8XRzz+a/P/D5ZT1nHrzo +HXX1zY7LKpkKpIv8xw4oZuDLJOMR7ELjoY43wGE3nVjge/hhhxGaMS2eynhoW/F4Yv78+XPmzNnB +OzJ12dqz2rC9uGUJ94s7rl7E10RixQtH8mLKvFCWt6AwD7ZIQ7YDVZ4QbW04XRBiC9iURw+FWgAU +iVwWw4iHLVQaFuAqOHNsLx/UIg2zyiV5IcKmSPb0BcpEJCUlsxQcd2FWwOYCR6AqEA/eIIIgvsMk +hM55l8yQKCQ9wMhnRSJ8wYqYCuK4dEuqwk8OgRQ3YJ5JvndaD8tgDE1czSfMEap/OD+w+cEfbPnp +rfq9bjNznGBN7nY6HPasVe6sXqnmhL/m8CNpZoucdaPSqN+rPfVAz3+c3H3MJdMvPrztMGbP/Jar +c+hqSyqhENitCEwEHg1pknPIo4NJFOzCnzSJgCxlFBT2lG0uZXkf/zsYRSkED2Ahdc1ipcupvbGU +Y+cWCe5mJv1Nvd3RiEVEwDxrGTBMEjPHRclkyrBroL7TWWbKHt0Efu3sKaJITKZEKMQlqOi4MG40 +IREY7EA9WMxtFxBpAf1wgm26EXNxQH3Bp5ShWNgkGKyRwBi4IVGRn4L5OqN8xSs+su5367fdd9i+ +Fy6Yc1IskqJq2XHwakIkpYrYShnfiSdAo0wXqCukKscLs4vw0/ickTubmppZR0Tsp1gsjsN21c/r +RW+ADmBj+8OO1ssD5isejjzgm4izKMRK59mKTmgSfgJwJgY1CduxtFwR1alI3Ij4us1bkFh9DLAC +kaebEdlJTYRUuDCgRi5FY8KjVKE1EJBhXITWABnomOE9mLXIpRB5WBtzLO+MfNoJ3gWzH4hZvH9R +mwMvr97Vcc8ObdsUE5DJpWu0LGZU6VXJKKcssefy/eJLZ1uxLF+XYIExHUAkpvP0qaJtiGpN/3pP +Lwrcnl0g/MV19Xf9fOMvf1a4rrchx2I0IT+B/oUj+HK+8OHF/g6qF4IsFcikTZRKDfZN/v3Ltzz5 +rp5z3znn/Ja6FjqgqPTFMFXXxxOBvZ5HYccqHjgZVdPhj7n6kYSMZUg2DHI4elRYoCIVcS3CG1PI +VOyj2Eb1gnF7uvB8PotjrscSBfi0JmFlcMfUMcU5rG4s5nUrhle+lk9rcaa/oloUsWJbJ/4uWjxA +FCkR35eIZUbi4qdLxFdyGH/hBhSGrMdgUIZfEXFEweuIoZQWZDhmeGVEDlS+MkoEUhG1GG+pQlM4 +o9JCd2HzjQ98aeqz1x288KyFc06prasJHoLauDaZsigmsDpRQ0glYAKa4iPHuGt6IU6iWwRt78Qp +X8hs6ni06PXAc3kiQOlesSw8l86VsSnyvGKVFOdY2EvnHRXKXm0shgsYztSQKEIk8w/kPKqAGOdw +8Qlp4UsWDrH9XOCaCwJkQquwIAn03/LmoTWK8RchPlAYEIme6VRQ3ceiyXthChI2TpqSGFP5frGo +io1GyZcw9EEBaY2muAW9BeJAWCKP101IQc82IsyVMJLKfI11xuKuSnOsN0Ybzy2wyhtWuqJvtfUZ +OwHfnlqUySjT2RVbVnxxwzdvjTygN7KEKICGDgMiR/CtlvNOUWlYPawbNhK2RlrEU6O3qfD19JWP +rV7xmVkfWzp9adgNLqpDIfAyIBAOrS/DjXbjLUIq5ddblUT5FZEZHtwYBg1JlDSyhEifsvxQfHrF +LOqV+VNmlCtFcoX2sv6AX2bTLnEpYg+0FP6EOOVK2D6bUOmyX7ep2xH2gtHiSbiQwZOYDGZdKsbP +GUoguCsVRMQ0JG3ZsrOmLMBgvEbVF8RYQLiBMilAsXygmuWjkOgLJCeyDIUhXQbuYOwOW+YMJxLz +CFkW+XNr/5pbH7/82pvOv/3+b27a8hRDdcwi5LsM0yifQ/akV9w6aE/aJzNUbMqHV+hgttLe/dym +7rsreg+uQJBiSD90UiYTMtKimwvk8kD48xxCF6Ehd3qyOQRWYIFEEfp4EVAStRhRRR4lLwgKT2s8 +IzTGVUoyWRHf4YA4BZSABVGzC78G+nYaRPhksQ1NcVA9bJYW+Met5UVQPohKiNGU94uZljK8Prm3 +oC0VySEdNhKm+ablSwV6mbATkDEmUpFLsaRbFjE52LcNsQntrnzBtM3y3dybD35uwe/Mu/n5Wy9a +/6Hb6h/Sk6jCBXBBiYNEiE74mIPTYc7Y58HlaTBsLczkzOqyZOS2uocu2vAhOhD2hC6N3aS6qhAY +FwT2bnm0ypQkqpoc2BFo+CGFOSTCn1NwRtAhThtDmI6TroOIwVgm6xHijpbd1reiq3SdbXTFIjWF +Qp41f8iBvb0lJFckCiLcorOlbVblY9SM1wTjg2cigLolvaePvT7YtAtHTS2OMrfCiI204kqA3CDU +H4MvQyiN4D7KiAyJUgI/IRnug4GbsVjoBALAvzQYlBm7YRXso1QMB3fGfSgBXSKNiEK4JIs9+sqb +73v6tw+v+vPU5n0XzDxm9rTjWpvnxuPi4oSOV/S6wQjNehh2ww4jAozLV2cXGimVCn3pzX3ZDSU3 +Xd+i6QTrxzDMkln05BHZdEzSYrgWToLAYD3+saV2KFKDmfAT4Ah6osIVeyazhIC9wBP2/f/svQnA +XVV57n/mc74xc8IQYgTKFEBQsFqnFK1aB2wdilonuFzn4Yr2j1IVp1rqgKiFqqWKekv/vWKdx0sR +VEQUFBHCTBLGzMk3ne/M5/6e5z1n5+RLQExiEvSsnOxv7bXe9a53rb33+6x3jWAb06epOqqaZgcQ +CDazFIWMUKpkxBUmTPqJaqeu8cBGnMNIddsSMrAWnsA8Vc0TwRiN5KACo5sc4sYbFY+GlgqSy6Jt +MENXB6ix46648cTxVCulPA0cBkrVCGOH3sF0nulIvIfMQmJnqkq9UshTyHWZ9gE7Uav7QhJVBQuv +G41L7vjq+7acu2HBdIoJeZQft9uxbAZDbnl2/Mgunblzwfo3rf37s6tnvPCQv6anRA2VeGn2hWrq +y/AHWgMPbxyNhxLfcPgDRPHz/fBh4zF8dq5Aqn4aqlQ3bhuozZZq9bF71/10xR0/uGvNDYcdN13K +DI5NVmqtOmjHxFx6ZIvD9KTmNnNES545um3WegyNsI4BlEzPGi2s3VDdsAlFmpo9V2sK2X8Hzc6Z +H/Qr1qdz7MQrrR2Q4FkqOU4eLUkp8+WD48JRKwHsTnwycbB+8MZUIzoMfQscYgHDCuuKJFqwgZZn +mR3dvBBgb6UrK9dfd/fm6wZu/OKckSVL9jt+6X6P2m/+McND8zhKTAN7QII7h0mlLPeUs5DT5fLm +zRP3T0yva6amtUnFgESgHUCJACcd4k0vunrIpQyjSQGAUasgGYEQ0x5Afhooqk/VsX7YccFBDQ7K +hSIFg4W38hOCrad5Q7RRaAlNq2tXShjY8wJcYnUrWtnBAZPgNzlCA38youVEuLKDlescLGT4k50i +6NpFVI3I6oF1+oHpCRgqZrGvXEkAACAASURBVJleRretZKMhRPcDbxI0zkVytdOFLCYpM6gQj86P +HAyz6dWF1HxWeIjuYeXiA6Sb4T/v+PJ7xj42MZ8nypPYc2WIb1z9MDzIenvD/OmzNpzTuL1+yiEv +YqynD6V77kn8seb0MMZRPp74fnh2eHpbnb0IGrF6vu7elEJEJdMrmGdrhfqdd3/nutu/dd/61WPj +lf0PSu83f7gynS5PlznyDEp0aHGIBfjZepl9UYHRdj2tcU3CG7XmrKHCxHhj81jD/bcSAoSbmGCk +EgXPnr0s528IGzQ6JswTjHkbHe3DoGUbUsGocobc+FU9SoqQ2FKo71D3XDGGSMgmDzBHHyMW2llm +MSttMrbn3DnJBknDw4qt1SbuWn/jqrU3XnPzf44OzZkzdNDC+YfsN+foRXOXDg0tGRkeKBWt0VUj +vzen48M4pHOqUh2frKwtVzdVatOMcdIIKLE/LajZ0r7BDGQSIhwCt9yGoOAUilIDgVQjtwJFPwiq +BXMTP8QkHx0swXCiUhvIZwcLuYkqc8Ckuum3F0Z6ihA2KJN1Ve10EgylmA6GH5gUZqLnQ9HDkQBg +2K8HB7IwjSlwUTRE0evbTs0dLmFrsoyVVDqdDQmY55RjtpreNY550Y5FSGDHEC+tHOghyGYzYGQH +myVYuphF2spwfoAmGnZxo1VXkZmW3JhIZ+8ppA8OJg+jK1VA+/Wrd379/WPnTczTsLCcK3YPlIKW +SlG7imWm8xxR24FSxHj/xvMKdxZecOhfI0PMQNwDwvSz+OOsgYcxjsYDA0H5jIWoXSjlNjFGZzxU +6UpZAOqbvfO+S2+845ur77uNQVDIRobT+++X2ryp1kozydYTZevs78loKhsdNCamGyzJB8zoLa1W +pOMHUIfZ9P1r64SDrNg6DILSlco3y1wY1r2gU+niyzBP15236FhC+Nwh4fA13TLS5gWLgChoivlF +by0OnYuC1R68mKpAnjSybR2DDbYqXbugC0tiUOZCGvhrI50Uc4sQAFMP8JYVm+FEmXV3bVm3esu1 +2dT/KaSHBgfmjQztt2B08fw5Bw8PHDBrcP7w0PyBgVHmkSIJYLMTDhlU/4Bji3WkU7U62+ICn+zt +M9loTAskkNA/4Bux1cgAJv0gsBExrPEbSFQJqqPo0aVCjHmkVRcpFqQnChGvtOBlszV/ZLSQn9oy +xeCzDn7xuiU3QUxAbQlxmYvEnkcs7R1KTY3rsVLzyg4WXrJCnqpGTF6b7DRWiEJO5YEZylUUym54 +sFDVLlbyQwBMspKFd0mwTbtHm9kJm0muh0sLKaCU9p1Ps2GHJnKB8WhpaMPkJC9JKVdk90ksVzqZ +1X5gF4/MxnZ7CSfZiNfDxIGgFPHy1T86e8u5m+fRNtyjcvN1taar5xzwvrHm+N+v/2iR9cI8Mlwj +hTBnbzx33up5TzvkJITsQ+kefTB/ZJk9nL7YB3o0ICiqvDc26d1NAqV8UZfWivduWHHtzV+4894V +7EXPxjhsLsZY2sj89tBwltO7WzGRFyzOMXyVxXBkcScDdJgijHAx0RezB3xlh9sNm1GWgG6aTeM0 +LIfC1WAeHYuc3iwUJFM4A3IygIkTCAgP0LNcZRW625DNZQWiTDHlaRDiIUOYof1BEeUHRsYue9bp +MKRrtMFyDja9c5FkRQFI3iQPcEKta0rwkHuPKbUN1mp1it+W6l13b/p5ZpXQKpcdGMwXGAzO52YP +FUcGBhYUC6OlPFvEDhaLw0WG+9IDiIrbMr6G3nCmyYIR3MrwZnoWW4pjRLU4P6zaYi4z+1ioV5o9 +8JRE2Mk4pZMjdYA0ZQlgAlGAKGpAzQUKCIw5QuQgmVeYgCZM//H8VsEZKUk+e7jApn2VWn28zG4Z +W5AbBGXjvTwQBfQafdU6ceMDbmofgMTsTMSQ9qB2yYBJhOOhdGEK40dI/cwBNEVCnHgCqxzIM80e +wA36YDWn109BktLJrLPbOA6PHToM8DZhec/UXHCLodHQ7hA09JCflcEMqnJE/EA2x4bsxZy6c1kV +wxApLxqtkUZ7LJfdkk1tPaFIQuzDLr67G+674az7P7Rhv3LHEt2DAteq5TfPfuXrD/mfW6pb/nP9 +129ormR+dCf/RmrD/DKC7TewcNn+y6J5vQdF62f1R1QDD1cctf2pi4yhrvv2t7/9pS99iTNQ//Iv +/5KweIymkRdNt3n8/l/d+sWb7vz5ZGU6k2thSjL9UpCTaS9g+x1NBJEm1VbomXaewy8ByqwMjEad +eSVt9ibD+CgNa/SN9aK1qrIQ0tiYkylj1cmmRfgZJyNWehkUJCHmFEOb9GfSuxhtdsxKdrchC6ts +dfZ6LSmRUugc6O0tGtgWHxUsdORZMTWJ+TJhb4GEzDnqLkhFSgxc9RSCmu6KbE+z2VEHtgv0HjNV +mA30g496MgHFialWaqK8EUFJTirkAZLJHoSTmSsv039PXrXmZ1HLEAAtlJ8kIhaBUdAcwA8CwS2u +RIAlgU8Iz622TnRJqRZJyygykGbsF55B40DVBtYeBTHgsZZIu8Z7ZREwPT3NFsqSAXACuTdOUumS +QUhLESwSzIWobTVuyIXnHtlhq6h73MPMSCghycJPnGeFDGQdwElCtWlAStcnTzBNQyfVKlFHLjN/ +sTglLwCsNTLykBzApk3AU2CqUbGQZdcFvQOeKsWJBTGjnF3smaM7WCyUq7JhlTXVhMDUKxtVptY9 +XHCUMtNg3Ty2+R/uPPfOeWs0sWjPumqt/JzC8nOOfB8G8ZzSnLMOesupq89oDvB6Upl2jTaCId6n +Sh+eM2sOQVj9naj+n34N7L4a2M04ynr8K664gg+MY7M4k5L5ck95ylPY9WZ7gZcvX37zzTcTzjfA +QdxPfvKTOeQS//aUDx7SxVCUZuP222//+te/zjneCYiSNhTc4x//eLIbHM6/+UOPYRIfoIIC/PQ/ +/HrDmukjjp//kjc+MldI00EIigADTGZhZlE6z0a2nC3CdBJJxcY0mt3DSv+qDMFqroEybTZkRxCt +ybGAnBfDAKIcTsJR0uAlGhnbCN2K9gc20ONkzLcMbDBfid101XHb8xCwz5QX9q5b1dCjt2UzWR2D +OkJr+wkhPM8UYu/VEIgFYGgqLyOshjFxk+Fp5Jb9K3mYDSto8eQdOCR6BalkF9rwBfWRUz3MskFR +P5jn4gm3eEIK1P9OoIDKbQgxgYJbhxAeIApKUT9IQoiQpq3Jw1oOBNBYErGiokymsthghYzYKqs5 +yZ2QVIpe4yxY1clcs3yHi4XJWn262qQWsYBdvRnQVwYuGQFUnslFxzs93uhSTFJty0CkRXUhOjKr +FcJgNnHRe+EakwwKUJYMwvIcCQkJA4yZeKs3gWaBm0ckB+OZw7ZgcLhQz26erHjHRmJp9HGUKUXE +tuetYdK4BiDEXYDd1NQ1Oo3bG3KpaXoCInyfvbp5qgm6X1r9H/934Crtiqm2zIM64lW5D+Aitpem +179domqzemL7qM8u+/gA34Dd3xz0159e88Ur2r8q6D2wg0Mmi3gI+fqjXo16CdeJ7f/p18BuqoFE +i+4Gfpz+8YlPfIIJcieddBK49bSnPY239rzzznuQU0G+//3vf+Yzn+EQpQsuuODSSy996EIEUsYV +2A4Xyck04QMBmmrjljsmp9cRWJ6sr7ppSx7jJtW+b9UkIEogWLLfgWhd/tFdyXeXxTQUD506KkU/ +Ni51LANHP02QkZ5F1aezLD8lECMPckARJAB7SAJPQuKINEAR5cst43Mgq0ZDWRJaNAIZX2XA4emi +KVNjQFcZyjECyvFegx0sBIro7NVyjpLMR8RATjxkB4whfCh9hBR4IDHKnR0h6CgGB7yuBg7AORof +/rKohA+yn4TQGK/0DzPCBfqC1pQRJiaABvlVCwRGLeAhCj9hTsgVR21DgF/JuzYutxScMoLEkRyc +5lYTaDXDmY5NeswVRTZClrBl+UsSW7fCdWoFG53dFQjXcKJymSq3yrXmnJHSQFEbCUJGKYArnRXD +rTvMoY/lnixPgtvwLFWmoqK6XATlKxzuFIF81edAo8FYG0+TEsGc/gPwglpVMV0VSIVMehDxMdmP +bFvKLHfJU+Q43I2s1Uig29sTeQmn7MV8Dsp8ukAiRkzFk67y9nrJsW87vizcr+677l8nLk6N7iyI +8mx63YxbPw497+0cveIHVOd89qiP7z+0daXQ99b893W1m3RYeq/jIY0WEBJRQ+beyL6/XwO7pQZ2 +G46CZN/4xjfAMDw33XQTpiH2H2P7OMIJ3KG4Rx999Mknn/zMZz6TWA5/Dpof/vCHT3/60w8++GCM +VIA2Ar/3ve+9+MUvhv6xj33sGWecgeEbX8WqVav+9m//9rjjjnvuc5/761//evtcbl916X/96Oxq +vbLowEE046+vXoemRQv+6qfr5y1SSxZYGp3HNn7t3/x87MNvW/H6k6856zW/+fXPNmNisnSU9fIA +ITvAYTwxLMowZN6bGdEIRq+yKLA0qG7QkeGsly0KJtDmqFSpWrY3GuioV5KjEMiL3l11rqLlgRmL +C9xSPexqBLwpyvgHTzQvGp8QYSS2DrrWgSgKwoUxntkrMq8kAY+B3jC2OlBhYEP7A6WgOwiKSLKS +8XvJjRDUBq40OB7PrEHzxNMSTlhCtSoMo9yKErgyCAlvwFH7CReQkMQ2JYHIw4+iicDGKEXGkZZw +nV7ujGA+ONg1zJycEDVNoh6waANKqQHaDV2oVqltdUxO1zeNVYsQGdGhYIi6UmkylgkHWaWMUofJ +SMPAtiyPm+ZI55WEY8gcZQ84J5cId2EpF3VOEWCO8LClStXk8lOGj54FeRlKXUTdcnLQVK1ClDYF +Ia3rZ7reZDQdsUBNCSx2nGZTxUTVCbK2UpvttQxGq6b2VcenR4/u1NTU+fdcuHb+hCY046LkM2Qm +MAkPT4TE1ZU8M21EBcPeJN0sePsGytnPHPLh4+Y+Ksntnsl73nr7u8cLFQZcZjLkdLoFE+fffSEC +IzbCJ6n6nn4N7JYa2G04yhqSn//853Tk0p27evXqlStXco2u3auvvprYHYoLwXe/+90vf/nL9AMz +qAnNdddd99KXvpSTBT/3uc8NDQ29+tWv3rBhA+F8A0960pMY/nzhC194sR2BfBWnnXbaVVdd9aIX +veiv/uqvfvSjHxHId5LA9nW3f/H71/7L2OQY39bonOIj/mT01us3lyebzNe96Vcbj3y0JnRoHUu9 +dddtU+e/93a6fP/H2w8tDWYv+OAdGzeyQRAne1tvojQLGt1DfWc5zoO9G9Cr9Ry6HYsU6Fqzrgky +0YxgKWQ4MI+uXencmjHDh70AyUJBW05MQcK4oWLis8ZCwqFwgUy0K9ofhQBAYkdiI0LEbcCerEYT +Y+YyxIv1DGoCDAPDuiIM2+zBVtgMQqO0jdmywBiLtVoDBohF+wkDbA0LNsjTsBFwFdjQgXrFiUBi +dJEGAidyuOENYhjCXJhqthQEvCBQvbvwsNiBi6xCwZKDyXSVFZbM+TQOEeKpVbASlILTiAqU0mKw +Ean2BHyMzSSBBjBjfdE422Zg2GGMOCMV0KAtnYxIBnLKGCqU+scqRUJkS4pAFD/VrYnJBTOUn7Iz +BOrRA9YwoSveOzPoMRFADfPH1+BPjkgOu4mpujKV14PBZJHCVs7zisYiGW3IL/6ep5ahVcZW9vSk +j7XaHBu077r4vn50708uzVzFqK9LaGnjVU6u4SFme08ULqHcvqxJkiTKIXoBy7V/PPDM5yx+VhLD +DLh33Py+W7Kr8zRmcQlbPP7REXFp9ioEJjJRDknyvqdfA7tYA9YTu8jDyRkpmZiYWLBgwaJFixYu +XDh37lyu+AkhnNgdZnLMMceceuqpwCF25377MdUnddFFF6FlmCt05JFHYpVWq9XLLruM8Be84AVv +eMMbjj322OXLl3P74x//GLJrrrkGw3fp0qVnnnlmEBAVrlmvXHbNP115w1dyA/VZLKyUCmsf+9gF +nBkCgt7+m81o4SWHzIIYEBrfmLriO+uh+dM/X/DIIwce/WezMRquvxp1hmJtCwNQoAyPMS/E82Xq +1XRlmimXzYEh6UF2aGAgE4Z5+ufktFcAPkyWyQnMI2GAAM9DjyV2lM8I6sBRgE0K13u3ckUSfuLD +TFf31qKpwQzmEyGDsMT2aGhzEUBf0BAp8ElCOIHTGpdldSnM3bXL6CmiYFuD30AOaIgfIJHqD2ik +TGocyNqGoX5dAINjAEmAB/AQOIGE/MQAuIoeYJc7EEvZGUQ7dQF/E/MK4EEGeAKixAYyUQOB+mLu +wWNlZ4iCQI4nZ5SCkhzJBSbQqjEReSCGCTU5tskB2SLDj4f4aNkwbExlstiUVJj+1PDsueKDVFEu +mEPPFSFJRSBO0vrRkyoCIcCojXBJJQIXjzrBKrVhqpSiVgjPosAaUjcOjKkt5ujyXhGPo2sXmhx5 +aCEpI6a0bfSvmV7L622Sfe6CYEDR2PjYRev+oz6PduK2csbdtmG7sQy1yvQbZ7389Ye+upfnhXd+ +4T8mv1Vgv7EHyrfZRlQERmyE32frtrdQff/DqAa2HUvYBcF5OznVeb4dh35gUIKdDHxiRxL+QG1A +pgV95CMf+clPfkIn8NKlS8n/7rvv5vqud73r7LPPxjMyMrJlyxY8oCljqL/85S8HBwe55UvA3XXX +Xfjp7IU/2eG4xbXblR9c+7EVq65h9T0rIrAvHZha9ui53774zuuv3lAsZY541HxWnBKOes0VMpvW +YfSl/uvzq7/2RenRgcHsxJY6ilVrT9LtSoXNAzWFByWLZmT/IBQ2eAN0aVWi58GCYayNQSqUJtiJ +iqSXFQpUthSulS1yUOPj7uMlgNYzmheHMo0R004JrF4BB08KdR+jkQ/lTip0BdzCg19KuItV+ARO +GFUeWwWN4Mx4J7OWtATFih62QkrDPNmpagghxwRWDZAQd0CUHLtRSUEiRHjgKOShIFJiXcFCJNAQ +JkQBbOHwM5CsCVYuI+IBQ4IMBHLRVEYjGfWsQKcVc3HvsIK5MJI2jSZUKxxCsoAbo4vBGdmYUaVR +T5eR9g7EFVQoT9CvCX3sI0w70sulUiCgatViEAI30F3imX/Ij5lLCI4oRKLAQKNYuq54kUiNmETJ +rqVO3ANMPIekNdMtpn0hbbXRAHopDm8UzCkmy4xpY4CihXyOZcksuq031+ezS1k/pcz2Mecvr331 +ml9cmbnWM7v8YH4nIbe+Rk4bld4bqDfA38y2gUzQfW7hKf949HvVMOm66zb++j33fIQtjHUERa9L +0nYC01emr7167S/+YuSpFKF3FkVvor6/XwM7UQO7DUcZ4DriiCM2btz4hCc8ARCN1xR4w3AkvDv8 +NVPCE0444cMf/vDy5cvf+ta3Hn/88divixcvhugd73gHPboJda1WO/300+n7pYsYVszvjY/5sMMO +g4YOZG7xkHskuerGT6+489pSyStVWIPISkhpuHRxIHfIUbNvu2Eziu+U1y7DjMOhItGw8xbq5nmv +OHD5cxYQO1jKlhlMYRZMThvkAoqzhrMbmhxQKsBjc93qlEzAclnGqCxCj59hBbLLLu1dhkVD82pS +rgBaHMgFDT7GprJengiYEYuT7WV9guVETy8O3SoUsTHKLX3LqGZKwBWND73Ide8JriZDiYfekGYn +EgXNtGFGc403Leb90iJgihNZgRnAGE+egrvPE04Nm794MFvJF9SBklvL1cEw5WmkUWUT51s83CZq +DQmRXHxcCvLCYgZ+uCeKH3LS7Ah/cCMqMlKqwFRKZiglez24gFIEI98w8sAztwYYUwwxyIinxhVi +vwsK5wCZokejhYhOTSc8U384SZtFNTwsZi2x9e7kuORRRri4mi0XPQWenbsH8KjdEIU1gYATfW7W +QKN6ki0qPb0AJCSSilH2egP+MOFxEMIyGRICohDQY0FqjmnLNHWQH0HVep3B0Xyu2kptTrdL+6C6 +p/eIXqJvbvhebW46HcZo1HjUYK9flWcXgXihCX8SQmDin+FJKM251ph+TOuIC5Z9bJB5d103VZ96 ++y3vXlcY46PshEWqRJjwEMcTn5f+5vrvPfmgJ1KrD6SRuoz7f/s18DvUgFvXvwP9A5IyMvqsZz0r +phdhMoJ5WKUYmrfeeuuzn/1sYh8oJfOJ3vSmNzGnlytw+LKXvYy3HNOTMVCMVOYoXXnllQyvEsVM +YAxQJgDDau3atZVK5aijjqLfmHOkP/axjzHv99/+7d+I2jh+0013XYklKrzRIaOsfG+gl7lhOcqR +x2lMdM780oJFw3MWSB2yowLjo3960gK+uB9csubKH2xYd2/1yks33PjrCRClUcdWSJWG0pPTLZig +H+GMtYdmhDkKmlv2ukOBspzUw2Ztzcilr5KpuWyVAJh5LQ2qEyfdijLBSGU4szsFCfUKH4wVpt6A +tTjUN7+wfoBb+nWxXEnFQCk2LjikHwOrMVcIXAQ/4IyO8uQXKhuYDO0vpESGaoqjT9k0X9NNjZ0x +dIpaB27V1Um3p7Nmji6Sq+rQ+EgSnLt2p2TrZqccpfkNogF7xNrUo7IpL2xxcTWdIAfJcYiXQBfV +TtG4pQ7xcEvWOD0x41CYxeGP2oNYVWR05KEoCfgaaQAnjDv8WHusNaIgiEFPqRGL1TDsQ6QkrQxR +BNINzrOg7KF+lbFdFBzOKi95BYI6r3gNggx5ohJ4zaIxEeUS/pkYMhUtTGeuZMoIKHtHdkdM6dSt +8AZw4F0mXWZtqQ4fEk2teV9ksU9do2Np5fqVl9eu4sAdF5466LqkElUpPb9u/MxaTsIf3MOH1q4f +WJ1/4bLzFg8v7qX9yK2f+O/6z4o5llp3s4voHUmCwIiN8JA8UA9ZL/O+v18DD7EGsqxOYbLrQ6R+ +EDLad5ihBx100OWXX04f7A033IDn3nvvPeWUU5YsWVIqzWxZMw7KBKK3ve1tJMQqpYOX2bb04j7v +ec87/PDDWYR6ySWXQAMSY84yRxfFxDxe5hmxPBT/9ddfD4yxumbOnDlkdO2114K1z3jGM+j4XXJ4 +av+lHFNFVy/aSTq2Umv/7LI1pYHskccvHJlTmreodMwJC0bmFIfnNH707XVLDh085rFz5s4rLl46 +uOJX4z+/fNPl31p/03UTiw4aOHDpEPv2FAfZckGrGMkXAKCfFsVKz1x5us2qU1YlMheX3W7JSco6 +LVjFstSyUW+iy1pV4AEFiv4NhGBlC52KMAGxMHBBROBZXXzGD83UBVeso6SyPSxKWVQc4YMhyR2J +ACdZ4LjKEz9QyjN4Q48HCCEYyYE0BJDaM67AnG7P6HcVknmTQrIOPCaJUmEKTxx52LKFyqKn0SVs +sJOoLintfUoUfMiFhCFbQga6a0iYeqBHl1BbqPKYlTwuCOHK1O0ulCH84YOnU0BMPcNtqE2VkVRh +BJsS+kBuSieBzQ3OAcP0IctoFM1W7c+xAbROSBUZWZBORRHCj/rkSm2Ip3ExIJNq7Dwmstbp35Yc +inZquFSgGYT5S1qlYQIXx+ppK+A8GwHqobDqWD3p6ZHSCDtDYc7SqcsGW2zR4AFX2LHZ1lz2eRQk +7zMOYxT3ndXf/2rmB+mix59//7LxJg6UM58/7Lwn7/ek3ty+fc93z7jrvalBdhl5iFWUnmhOHFU/ +5JgFR1OrfZO0tzL/mP0//elPwaBdqYH0Oeec86pXvWpXWCRpGZ5kNHR8fJxhUT42zEcMU6CR64PY +o0nyGR5Qlhed+UpJOMzxww0EBaGJ4mMgI8IxZzF/6f5t5Fb97PZ/AezamSYdd9ix2nFeq0Pb7DZL +S1/HVWEKVNuz5qX+5DjO4oYZY6sybnI59jBKlTc3MT1H5zPc0q6W23R4YgXqQBXOWsukhjBfsqky +ghDt+aKaZDTh+T6FNjblqKYuSSkDloIiONOhxMAYGpFFLwyPMa3XCjd6d2UFstF5Ub3EEoPEqH7N +b5LyRYXi70y7RYOjMIw6IEFglaCLJASGzYQ1xiAuGOwQzErJgEK3/arxWm+UTzGx1XBCXDotPdCr +bmfrfLKAuaxhj/CVNj3/2X+zLPIlOfkFEOLtgCIw5mISGwAjDkS7DxZWBGKjy+x2FzcYiWDQiI8x +BpqANZULtvTZgs1ioMqBUqhMiWxyqKfaNUwglYYfJhQTehjCQYOXNnkJSsLxUFjKCB9RanaPysvS +VWqA94T9GXCEwwTOgdxwxoPAqnk/DoU4xwByEJEHJGlbHKqj88bFnbe0UOD47g3jU8FQT5kXoJBl +4sCmchlWcKHaKfjoAFsbZScZJ3A3u/dq0BbNrHktZpYUM4ftOzjqDpg6X/ebrnn7t/f7qYpEQX4f +TlXc4dtOt5tT1U8c+N43HPaa3qzunbr3qdc8/7bCvZ05ur1xD+QXz/az1/zZp074KGoEBbXv1O0D +idwP3wM1wByd1772tbuS0QN2t+4EU8AyZhhhGtJtAgrypuJYQroT3JixNCMVy2AI4WPmyuResgC5 +uSULrFJAlPDpqRbrCupYh9jHTG9ib1tUpzEDGwkliMpr11BfXvlg20UKkQGsXDtX1LDg0DBbAqKV +WYuAluUEUXRFu1hoM4coW2jPHilUJrFR2bZeE0PG2a8VKlCQvly6fN2hCmih31GLoAVII/TyTFqm +E7IBKfJIPE+RlV3Ct03PrSccsfGNMD7WdwK9xhJ0Og5DSgAAPbddECVcIeFsXKKg0fhOoVBODoc/ +gWREwckFeIa/0MUJucXP8h1BBfTceixWT8zY1vajU5UHtBirKBROlYgDdSwwNPRjEwhywBzOlEz4 +55M76VImI6IgkzYzQssjQHElGKXkV/lEI2JDi1CHexOodIGpErcTDudOMr0epqUHlUIBq06otNAa +IyGgkkNOPDwIVW22za6B02CZKxBKCLgqNe8NdrytUgkSi4WQ3xWoRgVrVZSvegfYKJfXkj2w2Hp4 +sJRhYJ79+zkDM53XkNChowAAIABJREFUStFarTnWrIgnrRnmHpn3xHRloDCbj4V8eOAMYFTqmKfs +FZJupNfm249kEGDfUfeUbt3Yul81b9QrFYejxdPxE/Cz7DwUBVBUHAS4xK/yO2SHl95Yc66Vp8+Y +fdrrDv2fveScevj/3fieWzKri5nusGhEhzC9/JN8ISA8l0F4irCktKSXYd/fr4FdqYHdiaPI4X0X +svTi7opMDzFtACrXXk+mNXcgP7tR2VCvZbEI0ZJ0qBon0syK5GwtdCuBwyOphQd4tzkIGBGsN9FV +LNxDOYKegApYiBEJHKLQGJsUmKU1awk9snGsQV8ulFiiqPKhEVlaQEv03wq2PUQHkPDZcsVh/xGL +4q0ZjYA0soC52Bp1pPSdL0nIF7MJR6yMRTQ4AEASwMnGJVEUQXqc5L60oYePVbwkDa2FVeruZZiz +3JXs8NCrmcd2BN1j0yV4ek8GMENAG928hh9McPLVtKPN0vvACbKFDPhxBFKZJA9YpY0C3sAHsfFE +20k7InnLBbUtPMTb0aGIaBziVojVhSWywO85xM7Uqo9yCdKAKaKoUvA4Urvrm8DgoEj8sAgm9iMM +MisQ8Wg9mAltBRy1AVuGzNNZ9b7SW0DNQwN/yFS9JCJfZACnSe6TghSYZCHxvLuuk1C3OtuFKmU+ +UbY1Xp7iQHcEgEOcsMaZ8Zie0zXNKGKhi6JkMbcmAXCyY5Z4Mc8pa9rxCEBtsKa21kxvyKT3lyj7 +gOPlR4rbx+5Yl98s0Me5KjrXRMIIjFgKrxrsUiZJEuIZnm3TMkH3r4t/8f5l75rRB3vRyn///ye+ +XRje0UKXhENw3u4W4SnCkkVLKM7ONfFniNy/7ddAKLOHUz0kwLm90ETlMgOjhSMLpRYrPZjLUcxJ +zTGwGZ2W2AzecT41PDc1OCvVAAjpm2X5uxz7KmSFYex44pk4mJjo1kxOg6Oo18GBFP2yGzcK8WS0 +oXyNPVIRRhT0LP2W4BOwyo53cAaZhGox29OKWHjJpoBskERgIB+Q5uWnNW9ahB8+tACYFYyFRHeo +4McqCxmkE2wqyQIKe9GIAubBFvihqxAsBN4QSahpAJC5TCww6WWmMKdcMAebAxFR/XjoEKakgEG0 +AAThNoiVpy05tDts+VmdKhYXZZflx6tkrEJObnHwUSD0NGUohZNzxRGuWyfnFj8yBOS4kJ1cIoQo +AslICtm4S0LJ7MCgJ06MyStAN3iGPDwDVZxBiyaF+YQYwVaVQJ1zNiq2jStWVQ00KpEywkcqEVPn +BmbkJ8TNGm1fhZ8a4let6haM5BAchNdQAO0z1Zjew2yOxaNstCRSHb5GvAdNa+xxpNlPGTY7Yjt7 +nmxWi63IP11v7UMLSePTu3NqVX2InhbXzm+9uN62ofKz2CaEm16yrp89yE5oLfuXR31sqKCOqMRd +v/E371n9YS90ScIesoflTEPNO8urHkSNPGRefcJ+DXRqACXxh+D4KpJijKROLGTnswYPDajJPigz +b8OG0pKhienWTs2Zxza5aQzKUkFaTnpNfXeoPm2xK10sfNVkIp01AmDk0/vNHT1g9qyJCSytNJ26 +6FlRuvcPawadB3wCeOhZoBTYACxDucqaNAE2GQ6RtA0CqtlojcomMRzEJDS3S0IS9eWiVGHo3f7U +FCDHGIlEixl4QHRKHsTKyPOPxFwdjh4CdAhlQX3j0ObCZpoIhg32XuiABHnRQ6uR486kG0aXGe5V +g6DrQkhlYahWpu7HJl6loF6N9AF7MRZLGZGf2oA4eUQQBDgpDXJ6jBMOiE24HmQPQAqtDVoEgvGq +cAXIg0OY0Od4VCEktpEHH/yCN0+eIk3cKt9g7rQQwIfnKNuUvnd3YEgoVzvCS/5YKko6bqmfeOh+ +NCqRxJXYBsJ0KZ9TU8kFlKXLSIIKJZjlfDfZme30MHPuIGB5sXsdCjwYEckw5SA2Hih3HGXTSrfq +2k1rrJUq977eym8vOZoGTJK/efq2NAMYFD6K/1uvSNtLM+M2oqJEPX520F2iCbofXzS4qLe4U7Wp +t9709/cXNmsf3YS+l/9v8bcR/ubybRRELZ2+69fA7qiBPwQcnaFlspmBWdknDAykG7X2tHesrVWw +HTOYR6gxtjBlI8DR2V7p0WpPV+nO1bxZzAjglvXd6FNMEyblsndgo5EBIOiS5ZNdt2V65YYJEAhL +Dl05xQlcrGwpSs/aBrVd4r5cYAODT12vggnrX6tg1Ct4hmPxCbON2AKJhHz1ooPSeklwHuOjnhnE +rQDJaB24JYTGoGQxqBIpKfodiA21RqB0tDOCUnaqmRMrBJK6lgMRMV65BXopERZqkCk5DFnFWNFg +IVtMBI4CcuJvUIQPfpxAHQSynLol0N2hIQ8FE3RZHiRPHH7yDW4EyignbdQPUSFA1+aLVFRI5Cgk +cwMCtvyUFsBzzzlFVlAoRhez0+AwBkNGVOSi+rEA0IqZCqynT5FxPDjEFr35BXEnCbIhIQhtKI3C +chtlIfNcPjdrZCCYw5MQUjCI3hVMc8edGS0kDu1WNKym2cGZHhCXkCR4C6ziSLWKnlnAppOptKbX +7XXHVxY4ek/1Xtdgj0Quas99j5eo+EVYQtkbSNS2ZGyOODSZO/+wf3rU/K076AaDj97yycs6C12c +KtJGXHJNcklCEg9R6TRFCBydoToSqr6nXwO/Uw1Yy/5OKR4OxMPZo0YKh2qz22oqP8g2MerCRWdh +DaBFMUZRfkzijcM32nUZl9LvGJrM881xAon09eyB0uL5s8vM8gX2plKTk/WJco2RXxlqbG8UM12Z +u1tWjWjSCGAT1p4bytp23CeaoaxRkgCnoDqGTsNuw1buVr/UscnEy4GJygbhoicWXFSkLVfxBO89 +QUlMZEdLTi2kAXWMQ2EsytoxauKRwWrZ1PfoWabqBLbVDjYHvSqoizRkp7SwB6qjteGxVYWADiBl +gijmQ4imFruYsJWFbVYUWxDia3gCESV51/IjHJIoV9QAmQZ/qT6b2krFDbcmxktBIFMjwA0FYhVP +bcCIunIqmey+VdYQ2C8mInFBPBcMMrLTTGbscpvXxFKrzlD1QNXF4DdlJ1ON2rojQYjoodPpam2i +PI2o2Kx6o+j/F/ZQdeodGCry/JCbOWulIc6OV17am5a9hRGbjlzY5XNZBiNqvKwag23nswVWzjTa +m1D3+4LGRwZ2YFjf2KSCSMDuj5qKagpP+CN2RlQvQeJP0jqEXNhB9wMHvf05B23dQZcY3A/uufSj +9386T0MYNyOXCEky7b2NwK1RaYpAQfaFKlVB+u7hXwO2jx7mxVDf2XZupPXnU4P3ba6MVSu5bKGF +mVDVXget4kB61nwWiUgVtmpSYOyYx4fJV4ZpUqujyzRgyQLQ6XZj9d1lVDRTedGnrWZ6gCOC2+3p +6TR7L6Au0cjsnMAHPTSsw9TAIY2ncgIoJpoPgsYDTxhiGwneusAJpJEdVilX9CcAqZ5e+gYxPd0Z +G8OcMpSZsWKNIeSzAwWYxoKDCU7YHBgDqy5gEC5FL20np6JBbBjTjYMAXapNnc8obff9spsgqWAo +YiqHiyEZ8gRXYEKsWgwI3M0FwIBSCZHEg396IMYYGCo34x+xZCTnQPyEa0axAY96iBzFzUAoUCTI +ZBBTgYhBXSmhLcgoizLt2oiRhdi7RxeUorjAHrLxdJCKtDAXwHtLBJ4OBOyEQFcEiIcfMpoUPFbB +pMtFXjj8tDngrJJZAPhIQufFH3ZRYOwzemVJy4RbttFlUwXaLtDw03hoiplE2VprWieP+q1la3o6 +SBi2Z/ouDbtcJsdhNTxIBCS8Ua3R69tojeXVQeznLVn2jgN1cHS3bmmP71gCV1QnqtcfQduH7JgL +S7HLb5rzyrcc8cYZ8fdN3vfWW95VHmyyFbTrvSd+e+bbh/SIQREoSJRoh9qjh3Xf26+B314Dodh+ +O92+Q8F7v/2r3xvieBQTZzY/UXsPNdrNdrow0B7B3+R0l3ZpKFVoZ4st+kaZdqTFo9gL6MSBLGvk +MR/oatOGtFOVRqVZBXelu9WL2GaDBdCUzegBNXpllbCVGhyxLciCUe+6x5gr2hZ1zDZGMk/pJ4zj +ux0oRQ8v7DawFjj0osbQ5l7tqtgAUajE34pbxo1hScDgXlyi6BNWRuAWSpefEEeIkjihFBQOUSxZ +25bVWKk7h6VqgHm2p/dIJ8tygBBsXAoiGhZ9Mh8KoCWtc4krFQXXYA5P5WidRSyl5ocHthSEYGK5 +Qgz2EIXDTx1LGN0IkiM5dwHbyAxeSnLnG1hFSDChOPhpBIjYUIeZqCTB02yhxCEAgdBYAmUnDvyJ +9oTuJYkIWJJPxYZFmzymkNZ4DDeyU6bQQ+4qjYFSicqgqQqYHhzI4YcPe0MGVHPllYOG/YvGOWqc +jlHaXtV6tcmkXAiRgBlnnPTVHC9zzFqzwrpmSp3OFXgMvCSNBrDKQphmewKlr1LtPReoQ0Gm095m +OhEHT/iTkIco5I5SVavl5xef/o/HvNfvx1ZGjWbjnTe+f0Vm5dYTXXqz62X1QOFbmaUpgnaUstsa +3Pf1a2Bna6BH7+4si72VLrAzUBMZEk8iTym9bL/Bx+TyVc4WnSyztVg7207Pm6+d62eXBhmVQrOz +7Z8UOhviF3O1WhrQlVXCpA8WvTA7Jq8xLXrzcNiams7aYg8jndZCIBq8UNKRllNbBDzM32EnXuBN +Ji6wYY2MGi1PCnhIRXbc4rigW6EBw2TlsLIQzsxPMRTxSPBjyxKOQ/NK++P8rACeQE0BAQTAFd2S +TDPGIrSWVxIgwQodv8RwQrS/YM/2Ih7QGkNZXI2RgcdISDjyq+wsBfHMXtGATwZCEfAzKyQXWpin +AvEbouIq1sazULJwwIFk1K5qPG4NXSqgy0J5hS3cUg/k6ClITqZiqqRgsIdjoVSscyeX4CD+MvuU +guT49SgD+ZwcUUlFFkFDchgiTKXGcewaoOSWkUvKFXVFIlzkQggEAd7K3RWiEDi4fngNBvNsScT6 +UWLbOtSFp+O+X6QQBrspMF1rMHFtIHYAAD/bLXLUFKRsmnXWYDNHf2OttlqMoLZLBYCZF5I5R9ok +Yl+AUuCnxpAtRbJAHQ9/qItOCH7J6h+PgBJ0/N3AuBWRn5Bv9b6yt3DlxPZRFxw/c4IujC+6439f +PPa1AgvOnE5p+XUyUsby69obriCHKCbkiVuKEDgqgr7r18Au18DDu183sLMXUBM0jcBC4/H7zbln +Q/b+6mSuPNUuDrQXLMBGyExUGtMVTtjSVF4sCb51Drcaq9YzRW/drl5KiNGb2qII7ctCQCxIyAic +YkuBRmpwjjpjp8tpOoFzpfbQLE04AlxBU2wJnDa2jWWdnOWCYYcGsH2JnUcHrJbcY7p5uwA4o6wF +tEYXbYGLEWO8UTh9xcABSejYtHkkFETHK1TADCpwRxQggQPdWdIvvRFXhRmBrO7FNzz88bpYNI/y +AhsQCQCDj3WOJpmCFu4axQPDwCE6LcXDfMgxAqW+cHGrCpPASgKkmYPQxbKJOVEk9xUaysiPKoUV +TreMLDJ7CMBzVcABpxpAJIsBAT+FuFrIjlQ4NTLwE4WQtEvcEyt0dKeuMkVCEXZrOHn9bdqSCmCj +DcEzAvlUITZ/xZNxZQGkKxl1bfMXtmrKWGAEmarUMHJ4pnoWrkPqCmEoCDkrdzooGItXKehKbiAz +lDV2sZfwrBXVjClaciy1Yr4b+1AiJgUltybHkYbckn3vuLDeuGpBTgJXesiJS/wdD6/n3PpwrV2f +LFQpSEK3jaebqNasLaku/LfHfGrR0DYTdCH+zYYb3rXynDYnulCHkaPqt+vHF9W9lW+XaUe8bW9d +BOO7yrQ1Ud/Xr4GdrYEHeLl3lt0eS5fgZeToNQURJn3T8QlLSwO1k0aGBodmsz1MamBWavYs7M5G +pVGj9xLMy+bZyy01XCjIpGs1ATwUKB8X+/igLYYK2kEQxSoM88QQunPBy9IgM3vbU1P6IukxViuZ +/rqKFnEyJ4hc2b4HejQmgMd+9Mz41dJSn76CuQN/FCizSciL3l0kBnrR0SCo+AMG4Fn8VBp1EasX +0Z88OldIjIpHS6H3bdeyQhTJO4aUe4ZlHaL0DT+kVY7I46mtYA/GqzAFdW5rUiBBkb32A2zgVuEY +4qaXBGH8wa4LnB1EifDkJaLKOnpOiaQ54QMGG/AIoDbInbxwghXiu3OYCafeEFso6NqmvAhARiE8 +BIgEjTh4LRBVp7oythFuoHJyl5Rw8icQhvwiR65kKuKIcvVKHAvJHTVDHJUZcmKdR+5Kr9I7uVsV +unVtkBZifpzrIrPWKKuKcnUxDgruIDlFI5JUxNcYnLOPXQnZ7yvPwlIdqMBIKTNsWEvaqLDllWqP +6WxZTNsmq18YzLcj3V50FKvAyUE4FeBBHW3E6eo/HHjmm+edWp9mB68HI+btHirnPnXYPxwz7+gZ +dCx0efuN715b3ELrYmvUjNxn3G6l27GPIkg39F2/BnZTDSQN8t3Eb0+xST6DrZDZ9cXWJ3GHOLnU +/rPbz0gVv5WakxocVVt/YDA/Pl6jzzafSdfqmv7Bar0yq/0yqcqk7Ei+ytEBxqjS4+P1bJHNbtpM +PGG4VVgDFmpKZ3qSHQHT7VGvgUHdA3Uoa9k9wB5zVsEMoJHFi+gcdqtHKzILyZWtNTZYJFJIQkTy +AqdRstqBgb5iUhnASCtEsVELT9FjpRkR1UlIMsNJoBE9tCCfDqwmUC0Aa2sXRHCClu8qGm4V6UFW +KXcSGh4wfGCFwkZs5QuZ7jvqklQz1A63YQLCTdnhnEXHj8AU1hIKD7o0iCFgs22HR0wM4VQgwgjt +upgkxNFsHYuK/BSNAN/iQS6c6KNc4GK3gIH9irJdCKkkIYkN4hBAZQ7nVM5KZj11SK3nAQAm/RiY +KY487mmHJ/UgPuCoTgJPN6JaLTnYr6NlbQeryF3hh0r5ch1sVEHUUaHBVFvNBLAlL2OhvK8Zj6da +JHBX3c4NJutyLwOWXt9Go9rMjWdSM3fK7JRij/yJD4p5xQPNwuZ2VZWCi+eNP3nwXT97ShybOuyU +pS/AKL9i008vr12jU1kg6xJ0pOaVgGKy9qElZ5+89DmdwORPO/XBGz78g9pPisx0wCWZBpPktod+ +axbbZSQqCdAeaBS004VdkrTv6dfATtcAX/zD2PEhIH1yDas0rkmpiM02Dx5NLc8PNg48UNNgRvMl +sIadeQeL+YFClrWYm6cabSZ0oPfpIsKCLLYXzx9iO15MTKnLOlZmm+PVUHx8h3yeWC30C7HdL7DH +LeoUjc8kHdQrSegKRizUrlRhgKIXoaJ/NTnI+hrxMBM5dERI5hO/tX5R/X2WweAKPUzAWvSvrFhj +qhDF3ZsQgxCK8joNAB4CNDBYC410iJOLg7MIJA7BSMgtNDgpFpKRtREUf0A4CUFKV7CJXTNOoUB+ +EOCUFucQcAgX3PAGdEUuEBBOCKn0zKIlARPCbSsHEFKBAFI8BeQHFMXEe2JwjVtC+EGjPm3ja4e5 +Cw5viQ3g+Vad5wY/VYiK2skdMtHoj0LonlVx0ileCe3p14O+wRBS5BcT7sUmVfG6CTzq2oWJUVZx +tlY72bGhcqNFtai6eKZ017KPrhsTvJbkKBD1AC1XHGTsDMiWRgZoMc2wOotzDmp07erA8b3bD4nM +GM+zU6OuOAmsiuCXeLp+Pc3pxusWv3K4MDxUHP7kMecsqsxmwl+HPlLFlXZnefr1c1/+xiNfa0bb +XL5/96WfXPP5PBtNdYk7eUWOQbstt63yBA3PeEZalrSlRylI6I3g0b/2a2BXasCab1cY7PG0yduP +p9ehkZAlgdLEAw3h2drRw60/ZRhQm8Y0sT3bj5y7oJgerHLDoGapM+kGhQgsPWLO7A0b6+s21rT5 +H/CpWbXpZj2tw14wKdQv2iaJTED31sIfw0FTcA110o82s4BGzlNDp2BxomfjgBdsRzQyxNK/Vp1Y +otWyVpLIOFOQ59AaBdGhoDgSYu/KigXqMHn9C5DjKnOWotsT/tD44CKoLDLjqBS9syME8tD78CdU +PF1woqQBjRkhG1HyGAnC+urcGi1IBT1MxNnoRaw4dLUrDLcaiDCOIkNMQiOHKAl0EvxkpBDQjoUu +jC6Lr4jx8+vUhqc6Y+IDosAPUgkyDa4dDkbcYBKZqEKMx+Lu3M1YyWFO2pAZMbRek5HRqHxL69eq +Ixg1w63Smi886amW+cijoaSejwaBQNEj3/BhZyLk5AFBQLcviIi0moSLxasOBma8NJmXxOQjLFEk +Yad7RVBXLIbJ0N/bzGfYsJrVL5MBonsLSuM7YnOI+em5nf4NntoOf2oj1o/PHPm3B5/i+k4dM//o +Dy49MzNJu7H7ckTCFI3O8gtKz/zH494X/IM+rvdO3Pu2m949PdBki+sdZ7TD3GcEwqs3hNtWmyJQ +ELzbZxpZ96/9GvidasB663dK8fskvuWWWziIdPXq1Q+eCW9/fADhATIDNdl1OjxJeJDBDU+p+bjJ +DY/cwilrU+i2zMJZszZMAaOsc2fFS6pKv5yNAmyB+zZW7t+kJYQMoEpr4toaudy8hS/So3ctQS/K +F/wDEXHoUDQ7ihV1CdqhWjk3WwqUebyYjJ7RE/gKQ9Ql/b06QdozksBXNKcGa5nQa01NNnj0i5FC +K3qkA+OhQSKy1q2TdzJ1vgTKmnT/J73EiE2I7CEHkhAlrjLYOsRaJi04JLi1oscDQogYztBt+3ZA +3AEnwwzcrPBVHBxpt7rALbQfitOgKA/RrkxSRUIChILkQ6ECQR0CK/IKYaChGqkKOAiBaFKwHTEH +krOfFBO7gDqKYBwV+2BiyFRyIgNfLTDEMKFyRBnthm4BBYXIl05NTdeqtJhcHGRAaFLBBHqqCBKH +iQmtE24Z4KSGKQVZw0H4amxWywYHtRsB6kN0W4QBVFUX9a9YlpyCoKpyoy/WHg29JsOsQ6UCVaA5 +paw6ZsddBsPTUxxIb6Z756ISZDjBpnBg7gA6Y1QAlcEu/N0QkD5Xbb/1ka8bLo50KVKnHf7K/zHn +lBoDpT2OCbp/2jrm/Md8dLDgrRV6opju/M5fv+/GzB0F2oO4LvNOpknWPUm20gR9b1RPCKY9RaAg +oStmUPVv+zWwEzXQVSQ7kXRHScbGxr7xjW987Wtf++EPf/iVr3wFUNyyRf1R27vly5dz9tkMyPzW +t771mte85sorr9yefvsQPmwc4eGJryKuAGoE9hLInylPTTTHpxqlYm7dlvFqY4otjWDBZkMoQTSm +bZF0K1cBSFhZz+ITYBIgRPcBadotCFOSRahAYMH0PhOGJTGYjBAAclKdXHxlewemHcFZihjV7Mqm +15ceXdEQzsAqdpUgXPaZRt1s/4VlQ6wgzfv2AZmoWphDzA+M1EIXDDJxEsMWVhqDVoCi8RVUFhZG +LoF/CECgzSkwRgwhcN8pgEE4bGn3B06rqugRhaYXHaX/Oz/opdm66ixQJO7kt94TjUEaMSIL5Y7E +RnGFGC87gRaVgqspoKfaEVU+DHoDbWRHQnCUJ8VPgOpnRwr4BOfIAj/VDnE4CIDbADbxQYau8Epo +yxIPgE0qfsENMgnTxVFYaRzU9cnV9MZFwgh0TgSSgny5jYlgCrFsBFHzgCUEzCpiIIF3khNgeMGg +USigyyPWJF4dG8QLwqAEpiuo3WhVaMuRw96yR8kaaYGfw0uHprbwaiKuHo1+vc4hWJCjueHeYD7M +9x171nGtw2t6TZWKnqDFlfmfOf7ji4YW9lKG/4u3Xnzx2Dd6Fro4OPJKrubTkSECoYrAxJPQRAjV +OtagCBQklIP59i/9GtilGuD73m2Ow7Q/8YlP0GFy0kknPf7xj3/a057Gm3reeecR/hDzOO200wDR +5z73uQ+FPj6D7eEzrFLCkyg8MEznNmWKa9q1PAsM2Lj+3vUb823Nk2ShHjiUY0dANrWRydJmVyMG +O2XlMEfXx3Gj5MAt1lOi6EEarBDwVdsVseH7gPCMuUWgJlF8tlKIdO0CWsww8sJQBXiUjiRof5Ss +DA3wz3CIkgUnIMZDiIABbQBY8kecOg4Vr34xjJ4wH6VnxUdkoAWAB26hvsNYjDFRo7LYhNGGz9DF +X/ISWFrFw5AfSEDueMiCH1GAemhLI4P91vVdiVQ/EIANEoBUoFHggflzixOEYLcFEDpExXdCiiwa +iuCGReSFAMSGDCpZtDmcUJQNT9qy8NE3Lqs06ooKVFbqKIatH6VyVw4QhEj4XYFcY2ouHtnrkKma +VBxyV0Y2MRWEMyQTopaQyUiF4yQ+yUWsxsuVlnDkUUG6JjXc6LGNmbpqP0EAb5hDgvXZbrJ6lfm6 +mtYrliCoCpzL5tn/iKplGI/DS7FiYcKs3QDRvQKlfG7+pDJLhhbnJ/1QKQZCd35b/VjY1Xzz47d/ +GnPTZepcFg4tPO/oD42US5Sa3+Bk/tNHffRRC47tpQn/jRtXnHX7h1KDWfZxMv+tzLvZke+2gaRM +hAl/b0giJLstTmaWDC6OsvShNCq8f93FGki09C7yQQu3sER5L/HcdNNNt99++8033wyk4Qgn8KFk +gCH7ile84oorrgjin//85y94wQsOP/zwI4444oUvfGEEYuk+4xnPOOSQQ5YvX37ppZeSI+51r3vd +c57zHDJ9wxveAAyff/755Es415/85Ccf+MAHXvWqV73hde/82r+vzOS0aHTDmsr5H7r1LS++5r2v +vv5rn79HvW0cqYZyB06kuzUvN7BQ02ixU2uc8k0Z05h9LEJlkR/9inybYW6yXgXcjcUSCCl1aQMU +RGR3JKLQiPjVOUm0exTp0UUpowqAXhJqPBUYM3LHxCJ1dbrAsguNptBjawJauoLlnIZmYxHFLVG9 +HoZY+ERd0xdIdiAEiCizkuwAGGlxm57GKnKArfibMzl28IBYSdpBwc5N3BIKK1KGlWYMVoiClKbj +sVoTle02BAg4FClcAAAgAElEQVSLTeK5chAVOSHugLFrQAJYMGSGVQdQO4yVkCFnklDtEJBQrLqa +Vrfxc44dXIRPVEdI64qiTkJIKk1Ybv5ckC0RnjaEZCC1wS+SwEmeoGdEnLemK4AoKYvrnJ5YnhFk +IQOvTZGVT6SNHmAPqWJw1nmptGM9Q+/qKKXcAHMxRxgPiNlJNOvYa7daa1YZJW3UWrXG5r2CoFFc +rtEefeTo0sVVLMioVkoZP+ITv3YG/lH1F19Z+bUkbXiesvhJZx34xgb7lUzWP7T0zGcvfeYMAm6n +qpNv/dVZ9xc36USX7ZnrCe0gRz+5blTQbKXshiuzNsI/ctZSfFEchfVdvwZ2rQasKnaNRaSu1+vA +Xi6X27RpE721K1eu5IqfkKuvvprYh5IJ9Hfcccf4uDbwXLFixfOf//zrr7/+9NNPP/fcc5/85CcT +eN111730pS8tFouf+9znhoaGgE+SgJd33333qlWr3va2tx166KEDAwOXXHIJQ62A6MTExAUXXMCe +1O95z3te/ppHH7FsVi6TLWTS/3TmTSt+NfY3r3nE8U+cc9nX1157+UaUGpqd+R+0/zkurVBk3yLt +vaB+VE/mLBSEncVh2TGCJW9Jj1aVWcOPmZnuBOZWytQWJyM7dPniVy+d4RMy9HJMtwBZUUUy1Ejr +3ZHoa6W7GNwlECWOPIQQC0PYSmV37UtUBN1jsYBSMOgcJYTksgCelyQ7LCa/YJ66kxbJYRvWJwzD +IkSJo2koi5ADSxSRwGOMXS/mgSd+cYa1Hanw9gbqlvsuDokSaSHuWnUdwDPSkJw4yIFMOdu+JKdm +QjAlBK5CPJtuovJoNBYzHQA0I5AWJjwaOEfxOzAGffTo2iNWLhrEifzQ41SrFkAVK+vQIrmYYoV8 +AbFmoeyQIQpo7FTRjIjUEo9JdehwAbzbCszWVn0KO9t11ou6UzeQO6Siucb4KOjZ0nFEOnOtUMiX +Cnlynq7Xq5z5rjYZTdAWq0gLxVwrPSm0VVVAshdcNEznz52/LH04a2AlgZ7iDn4Y1+1i+pMr/3Wq +NjlD0P919Buek1n+lnmnvnHZDiboQvyh6z/6f6tXapEMOcxg7jw7gdvHziDe/hZ+tdayzOEUIdrZ +M2Tr3/ZrYOdqwOph55Jum6rRaABaCxYsWLRo0cKFC+fOncsVPyGEE7st+W+/u/DCC0l16qmn/t3f +/d2znvWsN7/5zaS56KKLUCIveclLjjzyyKc//ekA5OWXX87njSP23e9+9zvf+c7nPe95+LGJaW+W +y2Vo1q9fv2HDmuV/OfLox81vZRv33FK+/+7KYceM/smxwyc8hcNfUtdfvYVuWAw4zZUUmoofCMQu +dHyMDCsWhvjLeKE0GDAA0oCaqEv8fM4V+ngZ9Oku2IhN57E4tYZCPXVS08LLGIMUpw7MoH/5gRmA +HDTikECRnwy2JhALeEhNk8gg7dQdZYKcAnV3S0ImXEHTIpM1uJAARMcs9rQdoIJfoCBMOphqw45b ++FMukgg+YUuiwEKFxX/+WE5gRl6VSBXvG5LrRxLwOBDINPIbI6X8DdIE499aUnDdMiAPJHJdnngF +Rbi2tldkJleMTBMYP0SlcYOcEJBItYFI5o8ftjhdbYCSI3EMckuS4Gw56SfABoQ+HqhimUfm2c5U +uBga1MUK1k4YoCustQsC0B3+JFcnbTcLis+ENTbPIkQNBUsesYyIazSUMQX3FyNmpVpnj0LWNMdb +wLReGnW8xtpCX1vVs2C1s9HuXoFSJKFZzMji40ZPSHOgfVQHNUBht/thkl5Tu+Ebq77TqaPun2K+ +dOETz3//Y96tCVrbuctW//CT938uP0Dz03EJW+62D4nAhOa3enjIGxuPGzmBIlCQvj26XfX3A3ay +Bmzg7GTabZLRasYQnG83PDyMyQgKAmPMjiX8Ifbr9nKMKUiPe9zjegOxO7l917veRXMSz8jICPOY +ku/huOOOwz84qLl/fDLQHHTQQdisX/jCF84995OXfHXoxa87+NBlA6tW6kDHFb8c+8Drb8RTGsyi +5lDiQCN4Nj7Zxt+qSSMCcgMwk2LW+CjqEVVIhzHbNdATRyyapD4h/UjfLOOjmJhhWaJ8cahITMYw +ntCE9AnzpQOoMjeZmhuKCGXqvkopJaIBFYAQuyMGEVUQzfcRGKBchQhCIFQQWxjK3MSDpCbGvBMP +UWhLAJRzoB1ZY3hloek2AlrGHnEDJCist3ASopMJRYhjVbjtdhGTq3qJUeYulwAJwYB/wg1Fksz2 +GRIkIeBE1IOgXQlsCotQ/7mGhMEzksNZ9UDO9sTaGAjK46npCQ05Y99LGNNofwlLEnhGWnF2vyui +Bv5FpSo7GFIpXbgNIbnyjFRNbNfH1SYj3PTI3J4geUc8qLzMJkKIRXiSWBA9SuVsJIYJmzRTDexW +jzWpcD8RwnmvcHpi6Rb5cktyxhAqOh5BIvK/yrpmS8tp33TpjtBwaNMQqrerrUEKn64QLczfS45v +CgR69MLjDrh5/n2LxpH6AR0vfCnz8Ts+/dwlzxoubTPnaNHwzJ3/gsmaiTVvueGsqcE6DdeZbHeY +0Q4De1NCsE1VtQ8Ym//oI46jCKFAemn7/n4N7HQN7DYcBcAYxdy4ceMTnvAEQDQ+deDzxz/+MeEJ +1D10Qffff3+If/GLX5x00klJqsWLF+N/xzve8epXvxqFEi4BaXLh84i8wk/UySef/MQnPvFr37ng +y/9+5QUfvOnDXzh+1jyV+qBDB//+48smp5vMMGqzagUsQVeyuykdsEIg1JWMRfSv+lStQ9FjmESs +dWES5eCw+mBZP8p3yuRYNv9DpwOi6riz3SmYtNxcsValeT0tU32JWDndImn/BCOQYAxjhQ8fdQyO +GnsQCdBFZUu3EodY6G6AxJQ6iA0N7mzIFGLhB8lZKILw3RG+4B8Zyk8+HkbFrxzh6bSRi2DDZjEN +lTjUrJMw8nVu1EzwhFhMnK884EQPrJILUqn2jGqAE+a1yA1+QpGAZ2GIw4nqMQoDLKgWjhOfGpPM +QyMdVCMKmVUJjHdSq64xTdRxVUR2ki2KRtUpV9UtLQlIlJ1Dwu4DX6ODVzNps5xKq8iI4kHQgKBm +nFiBUc+ES1hk0N8Ot85jcrhWU0VVO78oCyEUHWa8pOTApvb02vqwNW/IwJa7zHqDVEPgWU3FYVyU +h8kZQ2qRYI0yuXxLNr2fc9wLaMpHHZ/VQYsOesKtJ/6fqR+k2dHEVeFq8IXbqBS+C0zS8m++fOd/ +nXrUK7YSPICv2Wyc9cv33ZC6nVXdqqYukwcgn5lXh6wn960h4eOdmWo+IXMiwoeW2IvNkY5s/T9/ +KDXA97x7HE08el9jehEW4axZs7BKmeNz6623PvvZzyZ2h9nQK/udrrv33nt7aU45RYu4v2THoOk3 +v/lNbl/2spfx9jPkefHFFzMCSuBVV12VfA985Li45UqmDNMyF2m6MvW0580fGc1Xplmelznq0XMW +HlBaefPUVz531913lO/4zfgvfriFbjP2kVFbHxREA1v70+3GstFaVeNb6Xx7eNDGHutNB2EudAQ4 +seeY8gNqYjPx7QOuwJiAE3WJ6emGNWoBD0lkoTKDVxmIoKPfvSsvscAQSYig71HRaE/KHNhp7R89 +twGx8ERI1DW3yAxII4Y6ZiMJUYZD9D4wE8LIYzMrwJh1iRHFLTKHMDKIjU+yyTxEao7bXGBCFApU +CbtqVJLbSWYC480yDZyFmgYniiOI6tAa6kCX7fWmARUspzt3bKPSDoyogJKNarKERhfVGGXEDxFX +lQIAc+6IJ0eg8a+TiW+DHmJ+gFoUn4UodKVCT5WSi7s8LKEfgTjB1s0UFZx786cOJYBz5CqePFxB +OytWVD/E8nBDNonHUyaNjv4WaOaZXIQAWk+l7lsmGfGP+btsz0CZykznJTjwG9Gy7OksxjCJq9jt +Qcf3xYR8GsrPWPjUwft5qCqIflRFeHpvCRzIffLOC7dM73jxW6/gX7z54i9t+q9CbF1ERC+3Xp69 +4QlZknuExG0SGEk42O7+LGIjPEWgIL259/39GtiVGugqv13h4bS8mliQjFx+73vfu+yyy+jfpUe3 +VqsxwHnAAQcQu8MczjzzzCT8n//5nxM/nic96Umsonn/+9/P+Ci3jLYyEffEE0/87Gc/e/bZZ59x +xhkEzpkzh1jW2AR28m3MsEdZz8qMJBbe8L0fcsToX73soEXzhydq4286+/AvfOrO7355Db9cPn3I +USOPeepszKwivazNNFu+8ZHxGbI8cXCEDW7YkCHN4aPlKfW5lgalFkEpTFg03SDrXhqMbKXSPtRT +ys8KFysHP+YpU0wAOdS9Ou+8kEaLO93FR8L4nEMdhQYHLK2uZTwpAxuLKHrZTP72CYYGVuEQm+TB +B0gAWZXcqSDDAw/KIlvK0IhSJl+Y0PkLVKCTMWqJxVgMAqTlcZEKGmdoYDAfSUR2IB+pDHUqLGR+ +j6I4Kgv5GRtUj24cIF4Yph0gQZIggJL0ghYR4NUd/6m0bGp6KrVlvSRkd1WqnUoQ8NvQxFYO5KYd +Q16dhCRV+g6SdVSlLWkJQIPDdSUCSqLCKCFlj1QQQKZU7ieXIEFv7CSYYgoakTlkdA2oKrC8NSdI +i4CVv1E27GO4qbmCVRtRRHp7BUqh1aEaIiURhfWukzDRRg3pDHPhWlrlDLaCtsxIEhNaeO1KVgcA +dhqLkmPPuvjEaKEe+4hj/uyeR19a/UWaVzweKvUZLjy+FjL5X9dX/Odtl7zm2NO70Tv4u2L9infd +8qH2MDsiUhkJo+0oHzimm6ibvEcGcWFIptL4s+qJiI3wiZbYLoN+QL8GdqYG0uecc86rXvWqnUm6 +XRoGRMFOZtsyLIrdB3ZimDKEyfWB7NHteOwgYO3atYywjo6O9sZt2LCBTxocjVY5/bc4MuWKGEwP +jitAjn/9xJWNoe9W6q1F84Y2bqlV6uXJcSxP+t5ambq0bCOTps8Q9TeYz27a0mSTI5zQgiHYWanJ +sfboHOnHqQnNc0EzMrkXkANNcVzKlc5MWt0aHpj8AgxwVhrEgJlUqVLJ0KEfUpstcLqL15JGoYAH +QELKmAvEEHg4Eybki0MtMBoaHkIQjNsYn0O9So/TDWtkDYTWwkbA3hvgwEQmrJd8RBYSyRkhDDoQ +qxpUhq2QqWuMwg0JAdTyiuef/JJlMbiogkDnxZeUCKkCaaTikceHmUs8I43wyQgnkXx0uTJ184JU +5IsYwKfSGiBVHMKRxPTTk6lN65QQU350nipQs36Icl2RHEgDepneTJQEC7PPUuGHMnIR+kIQyZ2d +qlGiqywBotwiST6X5dxsYnmyFHxyUiVSnWD0ezCbzgbS0RWvvPC7MwAxyEusaMFYDNdQt42CPO4w +4JnRQHGRjYjerNkLQ2lsMedGmApzunPpUhkuliarnDUmzlrABVTTTVrKArL55nG5zBxefqUgzR53 +fGLT09OTk5P//avL3r75/ZWlPG8Et3Otqhg9ctVb9WWVg3/y9O+MctzSjtx0rfzCy1753eYVBWYZ +4JLkwbWH1TaxvayCkhCII3lyDbJsurQq9dE573nq8SfRT4Y+oQJ7GfT9f8w18JGPfOS1r93x7PGH +WC2782UCLHlHmaCLAXrggQeyXdG8efNYnbIrIEoxmPQ7A0QJxN5lSnCiSsJDMxNPNJnx48gaV5q9 +bv/5o7R071kzXsy1C7liTdMnU7NmZYZHimr95zXwicLkjNLoUkV7MvGeTiYQUVaIl7VIvzNT1xNo +wUIUaGU6NTFpgCSwkqpzXJohBPWHzu2YrV45Ch90aEdXeh0kIMet+/GkiFD3KNxQxFDCB/yLZYhk +hFjIgIMnkMZjk4Q6982gSwT0YV3FlF0IPL4LE0EX+EF3JXYSxTNnEBSnjZyACiAHGCZWc0eti8AG +VFK3AzbgUBG2xigiITgEQywpOnMGiqhWwQkHf5LWEqOvhDdKI5lFrP92pHXdQgBtUBJL1h0QNe6W +hjpNloDGSEpxBGY8M7hR8ADIhLOJEhmi6oSIdsrLlBKVhAQiG9woFKcUYAtSIJcLn0pq1A8hEw7c +dmjcMgDRKYNGx6nnbsH1uHkc7j0mjIYUrOg9ZnkofAiGgFFSvb3UktaL6pZ+WwZNVSWKyUxXoebE +b+xUeCBWZ1ejaEGGPHvyikw0kXEnHnLCSZXHtafcKLNoSMebIMc1ftRJOn9D65b/uO3LOxaynTrn +2nO/U/6hQDSYQJdwC1ZxC8PE08N/B6kSMjw4nsJkHVEROCSnCI7oX/o1sHtqwOpw97ASF6CrVCph +gzI+yhU/IbuP/QNykr5BI0oXywlCu66drmUL6+7fOE5/2ujQwILR0bHxmnQBOye0C5s2cuYoy/f0 +MWJ/TFSauVw76xWcDJPS1ck2uUAOGgxlJsWNOnPPKTq67ENGpRmZDQssoYvdtYu+xppBxbNpAAeu +hWbhw++YegS421CmRhw0raSyPEgCAsEN5Ss1zaIOANVmKAIAcihX6Wvo0f7euVc4alSIEG4FnCgO +9QF2KPmL3qCMAQ+ECoxVV5g/WpCIB6/IPGsEz1YECsvV9SN2OKL5Bb3DQ7+FAEQJb1xXsJW+ss1H +iNBaj8h5uYubWIlkBCJKqAwZE4smOpYoHOjOZUoX8oRTLqTyT/UZwKxMOj/+RC4hBjyVpFtFCjQj +rsiiVNipvLcOnKoyPcuPy0kglovimC0BERaQjOQIRhKcqhRW1Kd7BTppbTpTChXNYAwyEsWdCVgz +mm0w/omZCSrSoKOzmufEmd4NLRyFLeT0QupGOMqegoV2WrPNw+0VKOXb4dtilJEP/KWPeNGBd81V +FSRVg2RRRx0RNQqQKRU+cfu/bpjc0JG758+lq/77Y/d8Jj+0o9WiCauEuapkWxdRCUFkHdcgxJ9O +HXj3XERFYMRG+D6ObluJ/btdrQErtl1lsjfT80nEV8E1QLT3yjeTyW0qDW7mEGT0OPOIV94/zoDl +0HA6n0mtW1fDvsSGwFoCPunmpSRaXJBqYw/xAQJFuWKbVDIMMIJnFQYzOawKOtWAVdSotiICOwe0 +ZSDATK8vyegDJG2FOcBlKWtN/7H5KHvRql+ftj3oXDQvrJENPkAjliggilLmFpDAE5uvIhMgJyHI +AeDxc5PNYs0iUa2+iRdnYgmPUU8gGXCylndqm4Z+YoSLJ7QQuxGghEYaskASoF178AaBk3AJVCCJ +lL4RQnwCvZAD5ytiABVi2A1BBigDYCQtcnIECuWFzDgmT06zczetVSI1LAqpYfcFwo1fcCIvolRM +W65JFAw10qiiyMEtokI2bkNO2ECAYDBBUmobxwugdpJbG5x0RkiIpDxJCJ2zE2mwDf62idXoIa25 +kVKldw2IODKy8DxiMtZJL8q101JhNDQPJjHrhYYdLzBTzOrNHAtF281inuPbhJ2DBU73y5EtSMog +RbNdhoW5RA574conxhJMMOmog496+fCLsve4I8XlUtmTX1SHTNLcTe07Llxx0QxZ7xu774xfvrs8 +WNvxiS7d5B2Geiw9zJNcEs8M+ghnCvY9TYREVARGbISfIUb/tl8Du1gDfyCvVAKlCZp2zdFsPbty +ulIu5vIjgyW6UsemKwMlFoxk6JKtNjF32E3XvYtMj2ynAVHUfQCWgC3dzjP1COTSsj2NY20cl8oo +eRxHAEn9Ma6GwWplyjzb8pQ6fvmiQVlQCmAQJtmIhDP0QIjAA8VNV7B3ltczAAMAPpPRnywQNQcY +avaK1THJ6UwGWemghlLJOfPEY65SzST3/GHlHU/VV2LIkTIIfgLJnEtIQiAMtRyF0jF6B64TCwdw +172gEISTjUt46DGUukVygDhLAGMkf1VqW2YKNCWpgDSSK8Tdy8E2Ki0QCxoEYM7zpjUiU13lBKJ4 +lJzs3JJQXcR9XI3fKp0tSDyk5Sf+XSEjhCsOwZiVTZQkRB4XgHqSeE4Y7KGUbDSJ3CoSfw9/CnSd +lvonrVohfnBwg0ayibeI+ekpdxpJej0F+oG7gKiZgIxsucAjHmD3rDYDveqkxsO2gtig+LFUOZAI +rDW0w1iedJqDTw3+KtDecZSH74veJqY+POvIZz597IktWqc2tV2N+lgC6nW1PztQ+Ozq/33/+JpE +Ymzws37xvt+kb+EI4KDuEuuOelSB5bjqh0v89myN6lAGeZdeNMzvGq8/fewJCImo0T0WuiIRo+/p +18Cu10Bo3F3nszc5JB8GHhqbccUTHTjV9o0cj1atNBeMjI5NN9n074A5wzRSa03DIYoSHKWjlY0X +6LalR5cl+RwvOmQNnkmjdUvprGzQdGr9piqGC0oP9cpaPrQZ3bYoUNQi2lArZDw+Ss+kdmdFK3pu +ETpX9qUHAjFVGYhtsvQFBPUsGxSmMKOLBxjHmK0whZKEoBrYpkkuCpOT7QjMgDrcS/EqUEOhBPEw +3WNMGLmj4kO/c4uiCSWO6o8kxIre6gm/Gg0GD4pGONvBasIUU4280zh8oAwgVLw5BwgJ52xdIYbI +uBpxkZMcIYYhHpxwy9kJgQJWIQ4ocsgkILpONBLGPbqY+KQKGuRTccyKCwT4dYW1ccsxuhWNb5yb +aAIU4xZYwmyVJF00DVaw0TMKcO2WyFTigIvyqlzGTq4E82giL3b108a4roRgTloEJi9mpZGW3lso +eVWIRV620wliDh/1cAE2MVXVLuTTDIjS84gx6h12dXwaVVpkEhR1rVZIlYO9JY8dnr3i+MoYa2TC +DjMVTjv8ZUfd/QjVst4SfhKuc0U4VQevaG5l5u6LVnwpkfZLN1z87xu+CguVQ6G+dDkofSdY7PB3 +QhQYIZHEZI7scJbfP8haTQQ77fCXIySiInCiKzrE/T/9GtgdNWANsTsY7V0efB7xhYQnrkBpM7Wu +ODiGwkRFbpmaYI9AOmDXb6qxIof+UtR0lji20wWcMq3iQHogn50/MqjzwmzzMWqzcG5xqsLZG0I7 +DE2pwlYaWxalh35Xv66Um0262NWII9W8KkYVos2PtEVD0YtKNUHJZisKGC1Mp6V+7r9F9QOZ/GSt +8mMqL3av0RdjFw9KGJXND1E7zyzM0yKSy4DkCpQCk+iYwN3OEzE1gTjUi7R3YJi7MSkmaREyYJ7I +ACq0PxKG6UzCQCbBJOEwcJtAfvQV6QnCY/5CEiDTik54Y1jCYxLrN6FJJ5fAXZUolxrf2LVEQXqW +4eY1LBrJYY0AwRkPqfgFkyQwJFQxIygMPnGSU6xdtHhUaotNOEkiksCETBVFtbvqlJfpuVK98SA6 +/CKJ515VahrmFDsXn75hhKfgcFdtyMnWhCDkD9CJiHJN3R21qtZ8kA5KzdqlpGAsc9mYf26EUiCy +aB6SR62duINBwWgPXvnE+L7oKcXIO/zgw//Xga858LbZKh7Oxexcqee4pVlQlEl6z+Z7IPnNmt+8 +c8UHW8M+0QWa3l+H3oVJkhOY+IM4IQvPjKvlOPDW2QiGeAiJqNHINt/+pV8Du7MGrCp2J8O9xiuw +k+x7v5Zq6o4Kc3Bb2WqzuWWyDloM5jOVZp1RErqVMnx71oicLsyk0Eyuzckbm8fZ5NSgVU/lM1k2 +YShzyKh7bjFGQVO0IYAHiAI/2G1YovqEmQNS0o9wQnAaxfSoJ2qUlaasIcFJO1tB03nLhF5UKpin +E0khBi3coYzylcZAJxtKgxWBUuj8uj2uUtMWnxwhVi+iyi7bFA8cQtdDxi0OAJBZBo0JIlRRVvfC +FeMZEkqbe6tecYgXJHLqghmUYospb4aMklJGZCOExEITLOaegVUxj4xsCEIFAbCEtDgSjm1IbbYl +SpUSTiWPzFH1BoGSU+dmq1x056pAHqolKs2QFkVWVlBA43tVFDQSrRNC+g6UOpDHCmW0YCIVt3CI +fMliq6fbMYBgFCFKEeDKdgnkKYFdtM6sLtctIXSN5GgsWACnQigGP/3cGQ3Vgi1kUqZm066zk5Hs +UWaSI3q70WpWQVNNPiIcIaaBz72FoKpZOz40JsNj54FSJxx5wpvmnL7wNnaccp26/kUVHr8A1MCq +zD2fX/GlerX6lp+9877Sep/oEsx2dI3XBg7hCZJezjPCiYpYy4Awb5p7OoIhHkIiKgLvKJt+WL8G +drUG9G3/QbqA1S2VFROVaVmBaKhmu1jKtJmry8kZnvja0uxbGaPFQS5s8sddc8L75aKdUbVjk81N +jYY0tVUzkyXpNabzFnONT5JwVDApiY3JRKzarIGIDgQagVVi2cwBUIEbZOr5Y8km+OpuWLYVlM3K +FvnoZTASeLZ1izAwB0hw8CGRdu/zc4JS/Llgo5C1dw1EGHqnCREO8Uht2kpvwxNiNLuVG3gQTDRk +a27uKVQgBcGxQQTEUNPDyMgrp6vS1MD2UaoENiwSOVI0iDsgSgZ2hCCGbHSOivMh56QlhOKoUKZR +WgIR3n3am9emtrBjUcCqoTGGRWEVlKphattmH2SIJyiBl6uUq+o2SshVshImTCIcp+SO1Z0itN8h +URpkhAlV5GDIwpEvPKJ0URyS8wQJoSD4JUw0HVyK4KApV6SHieXp8OKPWwCRLX5oLBUB2tFX3Ojg +12xdhys4rbnWLIZWfWkGL1sTDBTVZ8yGRzwvWDAoIUb7gAOZ6Cxl6JECPPVRJzV/2Tzv1n9df+ik +CpZIiCd+FKhU/OKar6z+8b1X1H9RYAeToOFKwROX3EaqiArKoAn/jBBVnaPlaS+4bfgts05HJObo +Ih5C9kE0qeC+Z7fXQGi23c527zMERxvt8Xr69mqjOVQsFLPFKdbY19NNzlT2DB2MRfp1pWRzbTSj +dk5AQVvwkqbeoNjoagPYpBGwUNEMeXZA9anRmWybqUaEoOzoKSW5IS/FuYqCPW+dg8oDTqTNmdDr +/tuYuYPC5YfiUO8rCho+KGWM2sAGYlDEoKO3QELnwgdlKmBDI4NhXlpKiJAYjQGY8TOrUDhcSY5K +AaicjxODJvQAACAASURBVBh2oowZRPFT2wJc9zguHikfktgHGEseLOyklRUgagwQjR1/QUcAAEcW +Sg8Z9WluCeTEnJgQAIFIIvFc0YgzsT7Ltn8UU4DBj+Wbw1rrokLJZHOgxSYhBDgR269b54sMkRYB +JAnBRFkYhIoo+IdZqeaFIVn455ohCieI6jrx6HJGjCCIEonEOEqmPGvxN7ISrBDLzPMlkCKqcvip +tpku1IQP3JiIC+rATf3wkMWmH7xl4iV6Xl3vGMg8I7YE0ZKXKjPiVG4NmuY42C/DiKv5KouOR9ns +DYepTZcpWAVi/cXxT/u72a8/6OZ5HhV3qwLpegTkvV6dW/P58UtyJYY6HBWxQZYQJx5K1BvV64/C +JpThoQKb7YNumocYCBMgingIuTfqpp/nH0sN9CiPh3+RUUC9aqXeWtVoTeWz+aky0FkfKDCZtslY +U7bA+rx2Ns92a6xXadcY7NTxVKi49KKRodZIfe2GqtZ7MAKkpTJtZgYxXKfvWYZaG2RlBRr3GsXE +sHPnLQpRs17BHk/ipXcUZSo9C9AaEaXu3BsMpfYwBxTdl6spu5hrXveJgoYelYkTEnRd2JEBNjLj +HMsVRQSZ5TJIIBN6nFQo+vBb4xMgLIGS6bgQIJW7TDUZyjlCABM6NqkQmaRWcFjYBHYcAidMbDTD +RK0EZHChRIZAVvZQhmAhAyWlGiWQJJMAYSJj+09uHtiyiRZKRzw8jDezsVQk4YokVFfiAs8QJTwQ +RC3hIVCUJpZHErhURkGehQoON1cIz4WhSJXdWVDh6oUmiW1H4I2qjjnM0JCEmsHBVnVoxgC8ZMPf +xVRaRSCx2jo0UMjUGElCUkVLSzLafGcpVks7ZpkRZxg0WPqiXoRava0j5h2sMXtlgWnKP8kuOJXU +6RoHf2Yn4zwU3nbe+aR+9pYHUw+sitz//PjlQzcMnX/zhTcuXpWeFeeyduWypAic45PAUQPhogTJ +bTfYf7vVxE1C1vEkUfYQyNMZbyy7e+kbFp/+2KNPBETj4Km+JbpNjfZvfg810KOtfw/c9zDLXhDF +P169MZ2pzxkZHC9PY1kunT+XL0qaqsDYZLvNodwFFudlUZIYl2isUrZ43KGLxydTDIiyoS6WH4tK +pbLT2lGBj1Ujml7DjZbEEmUcFA2HTgB7UMKgI37olcQ7FrF+FMcHztKaGB9F2+KXirTKJjmOfl1z +FiZhJhKIIuanLDCdoY+diWjzYMt6fFQEpPTTU0tb6rbTqatxPo+VouLJOiglFZ3PXfORCCUnHfDD +H2fHX+qG5ORLAcESnBoQxCOnRcXTYWsMA5ilxs2LEuEVZBqqCeenhPYgBrH8CNGvnq1smjU1luHU +MDHk53PRZ7GmX72atkShNvaQTBgChwA/B4o/RTJz/OQetRGB0CNVdAAQKw5c3GgISuEcwrDdcS49 +OpiX32ypKGqbOJEFvpoMbkrSrVIBJLF+IpDhhxwJSc6QAbCNR1irUN4KaXIerkTKpJg9LtZO4kzS +Rdbi6InwzioF/xGM4VNYiXNbZ5A6GBIYkIcPVwsuijCb7u2e/ysD2lYpuMXWY49/1OPefdjfPXP1 +43OrosyuCJXKPzzhl9hdf1RWRCXhuo1ym3Jm8m4UkdQU56GvapIpWSMAYgSIIti+0NTY8w+ln+Oe +rIE/KHu0t+KarUojs6rVzK6fqJSKGVa7bxyrMNeR7Viz+XY+nR1vN8GVyYkmS1z4CDE6D1kytGZs +0/gU0340YxZ0bDa0Zz1KDY3J0lJ6b6U9bQvE4B8pO52faE8tohcQwlZ2qkcg8ePCWMEDiOJiyQqq +M1QzzNGTQDXWDExQmVrQAjAnszKNRoEThEu3WqGLyADAFf2Kk51M7t5VBy2EoROdqAjDoeLwJx7M +FpJhNsWCUZSVUVmWKD3YFQ3rwg2tRdEgw0mzkdKOfMC5DnQRYkhW7pSXq1UfwcAwHOR8FY46hGuz +kquOzaYC661xVQLIABxmU2xizARmGbgkosi0GGxHQqC0/4+98wCUu6ry//SZ1/tLD+kECAkt1AAB +ll4ssKK4KIiuBdvqsrro7qpgR9HFjroqoujaKIKAAiISaYYiNaSQ9kry+nvTy//zPWdm8oTAP2BC +cd/N5Pfu7/7uPffc85s533vObTbITQpxBYrYX/2BOGVMCNyJWcNXVVopy3OsOYhADZyjiLPHoSux +SHgsmyPNS1l5xaEjycCJPeJlEfe286w2wWa8kBSKOYJ6dWRWQRLNQqU0OxZJSmZGk9PIiWtJ1UBX +OwWSLhhmWZbeIOma8Yszn9RKsFpKiVhNTr5g7VbPk5cJSDiUMqOHCL2GPRfu+YHm9+798F4/eejq +9TN6gy3uu6i0pPoXCWw3PDN9fMr4ODKg6zOQn7mx88zGVx178DFsR4qTmTAxQXe7op1I3BUS+DvE +Ue+ep/PrewZXoTdRmuimbLYwkk2jkzg5I5Jj/bt6sCxYRH+huzlXBFOyf3SsayCPnsU3y/Rdzkpj +HhA4hLMRs4z8WvdZYF8kliUYTqDZ0XMYqfZmtCWCzdqVwxN7hbgZmqAaSGk8KF1zcEzqjnBUh/7F +WkVpAnsKZjvCqgADmEH/2ninK3EpX8Na/pJehg0rBVqjalUX6t7ByeAEKARHHSRwYMIA85NdoUOE +qbkEStFqzienCfQTeIpYQA5fP0rjVVwZpdcBJ7FtiWqybXavTgCPyYY4DKXIUIYWLwuWkJ5JZEeb +GSvM5LdicmlilDWTuUXIGfkAbxB39FA/wxBItZsx7ZUaI7roljaMD1Y7FGADgYi2TXFSLqMMTV6f +YZLeKbPPhlPsbCASFClHeNe8QeNfIjVLFN5UnVcaCqSyuFr1tSGRrwFWrLKpEgsVaKc5LCzVdrkc +4FKxYnkdvGvSyIy/Fo8uDKtwRWBMPGJGm1Cafy43OxaGHY+w4GORGkZO2XrLq3qZXB1KfTASK5Bw +euNr9npyj1+tvu6WrjtHZmYCdbxC+wJxrUpKra4El1015ZnZxmcgG0IbKzSsjx9dOOLVc09ZOG+h +D4gCoszOhYEK3Ym/ExLYtRL4+8RRlvIN5/6SLybrom2Kl1jqIrWF1gvmtLhlNFngmDMiUXaSyaEB +9LPGYK1nhgugoqFBJhmhvEvs+Se3LatT2GheO8srL1oPnYgCBWwIpKBSscdAKXzFFEYLC7HMKQpp +iqcNdDUO6qOSVGBKmYJCF3SCKWt/20IRrBMo+7YMkMS+Ab3ILN0qLbQNJwwzQEeCVrgaeJADtBYg +yRYSS1Cgam7VCSABzFCyEgFaIvxBRNQr+DEYxiBWCoEC3kzoAB4UMbaJUwUf5mFBQmYlBEALAz81 +0J4KgShOM8cac6lmUCeb68/ls16WR8wt8k10lR9KLhmzHfVmjD3+kk6N5PAWqY3WC7EsegRBj/NH +jBvzIBkFjQNBHUEyMdgTsDHvzICqXNCaybuAmotONPUmJBaP69aA1p3eEpdxwj5EoLLxIAj2bFpb +ZTa9+gFGAWZkd3KIN8tCyWfgTV04b2ujEb6pekH2NYOCmBcvhWyek/vgvpQrZPHcR/ke2+Co9xr1 +pXx5BNALZvx0CsBsn0X7zJw6c9kTB1+36saViUeGJqWCjXwv7fvhDNs7+iveecXV1lSfViM8orE0 +eyjf1FOzb3rJKdOO32/BfpxaweIWN0Mnlrj8lTwnbna9BP5+cJRflgfO93700UfrZ94dbWXP3OBw +JptL6yDuGk7b1pBnUbsoFJnTIQ8tUOEeSH6ntTVsJaPxU0xYZvYWQdlYYM1DwyNDxd33aUI/YP/x +C2faCM7hsRwxbNuybkXVgZooVnQf1h6qWXHTtmCM4M1WlQBa6WR+cGuuuT0WjWnYS/paulIApisp +7LdQCjx89+BDfxo65Pi2+XvXo3nRs+SEAcGMYQn5Xdvo1iqCcypFrSvBUE0PDEFE2axYiqg6qFgp +jeRhrtkkZJ2xZuYsmWkFVyo1yLCKgBO6C9YQ0r04maTrjTeBtKl8uAWuSOSRNJ5FStlIIdVayNax +p12uMJrOjlEvzacIs3PrGw3qYBVg81ImExExiPJm8KasHWoLtXCnd6e0SnE9seB/rMdDjjJLkoIF +IlRt1iH3bmjixFZ/gibbln6YjMpl/QCVs2q4pQMBbbLhsUfaOOphsiYOGpc4uIXvFcPkWgxKBwUh +IAo89hxpa1JCmE6BlYxMVksx6mDyhT01RP0AKuAQb31/uPXAU+LswRsJhfNF9gqELO6GjDzAL8tA +KxzJuPo2vEc1HbVk7pJH1jxy+8Y7786t3Ny0pdDBUYUV4dJCCQyxVtrjEQna3igRfQ/0jSyNFcO9 +xanDHQdG9j1i6qHsmguCAp+4lAm+vkVinAgTEngRJbCTcZRzs3//+99jAnLeS39/Pz+kI488srmZ +jU6eHpYvX/7YY495Kh3J3Xbb7bjjjnvve9/L7ICnZ32e99dff/0Xv/jF8z+y6MTTpmXZ7Y8d6lF6 +7K07VgzGgsVsCEuU+S3hiGbqoo3j9dqVno12QRfWehL4tWr6C5sCxkq/+E5X94b0R76yqLkzjN5k +bhE6kdFTFDEdb37o/GTd3kJv8qsHpAEDzRsi3QbJeIq6xIbbuGbshh93r3mUfSFUy6EntL3qLdO8 +LJmFHwargCiEezdmHrpraME+DXMWSoeXNYwZNJSVYnGdbqWwdxlOE3LTXLN/6FJg05ATHUUQb75y +xjBPisuMJHSxVwcbBBiGTxBRiGUYgO1DEGOQNbaNqhIFOebJpJSmN9NYy+yWMU+hQykxkK0pJtuL +hShLjgqFTCozDBdCCzaVTQSa2hThQy3CEqjJ7rJRQtINBUlRO/TfG1+Jk2KYCsMuPXgscwgdxGoi +VSGymVnMCyMu3IJbg2EikhTBeNCbMxiDoLCQUrDhkCx6liLzUd5ynooUnR/+6yxbo0MmYJiKjE14 +9DcushWG2RUAJJb3GM7Jp6zFkRSrm3kFOG/5DWGzUnEgxvxWTd+FBXauzzPSH0Gy8utuC3oqKi+X +AJLBD1fMU4dSfuOcorjPyD6bNm/6y6aHV65+4In8mp7a/pHaVLAlzCb9mjXA11Ev0lqBoPT70RCx +xoL7cg2p2kmpzgXh2fs2L1m0aK9pU6fhxXX4xJkMgqJtqJTwcpHCBB//ZySwM3F0YGDgsssuW7p0 +6WGHHcaPh034wNQvfelL73vf+zhwe7sivfLKK+lOdnV1/fCHP/zv//7vm2666cYbb6zOod9ukWcm +cgTrDTfccOutt86aNQuF8uY3v/nQo9u3Bn5WE6vJ5kcjwRirX9BZKLkoS0KBIp1FVWKwk19cTV0J +bShDMxRMjbBPeuFL//5Ic1v0gs/tPpqUu/JNH5ydzxVrm1hvLl9uHltWmdGwrEqQNktZcXQuFZCB +AIiiN1GskHUrjUTiV1y6fmQg9+6L5k6eWdO9Pi2wtqUy6EohJTrEzEplNr0vWkSoy9QxEVO29tgy +lMdZQQhDIPihRSvvHPjVdzcdcWrnSWd2oosIqCZIgP3eCaBUhPrM5+xuWwoCGB7gkx0TkQkqXowZ +dvLIl7c6D9TiLRV9Q1P+YnOTLpevTbAip8snkGksZdoNKVkPmR9LD2JUOa4jKEAUjBSkWYuEfI6d +1nA4pwqBkDXNMqkWqCkbFwchwz9qFOia2Mkjxo0Uf6v2iUTE98BqcWq6WgY9UoyKVQVlBZCG4uKW +BJOGJECiDzmbcJCY+CFOz8awmdKa00RFxkYM8zMYSuOZZTzbaomyErkysEtZbxGl2K/Iz03D9wFZ +Ahmhw3b2JNAJJKeBUyRX0FaCBPK8PJHDEE178AKlXPlRA6UEVMG8ufOOHfuHrVu3bti6YfNQ1+p1 +6/oK/QPFwZHSWDKQyvFV09czUhusaQjWtYSb20Ktc+tmTe2YMqN9Bjvl4jR205MresarcOSWyCbC +hARedAnsNByl/3zNNdfw4yGCW5Xv+tjYGD8hAulnn302X/Rntm7evHlYovvuu++JJ5546KGHYqFe +ccUVb33rWzdv3vzRj370zjvv5Od3+umnX3jhhXQ2Kf7LX/7yxz/+8X333ce89vPOO+/d73735Zdf +DvSC2a9//etPPvlkcl599dWXf+fSM97WMaM92fVU8hMXrJy3Z8OcPRpv+sVG1M7xp0/f5wjZx9df +tWnNY8M9G9OdUxNLDms5/IQOFNqPv7pmdCifHitc/J5HTztn+p771197xaYtmzPvuXg+MzozmdKd +v9l67239g1uzOGYPOrpt6T+0xRPBvp7Mdz+5btbCurl71d36q15qOeaMSfsua8ZkQQmiW1Hu7H1P +pdyODBemhELT59Zi3skSKgVYQ/nrH25e++hYJBrcZ1nLiW+crNU1Ji3X7FxX3T9yw1XdWzalmzti +J541ZdEBjVADyVfc2Penm/v6e7O1DZFDj2/b68DG667oSieLd1y/5aE/DV5w6QJpXvb7tWNhKKK5 +uPzBo8bcK3m57RacZf1iWnHSqbqMrxhVhnCCBHPCAZYy0bhFfYMuRHgtFbhVp0F3yixDjSlYyeZ8 +tsa2hC2y+V0yM5AvZB2zAdHm9rLBp8ZKPBWEgzrCoYMCuqsmq8gQjrgyg2SGdrSOQKWWS3FDFoNA +QNRAiyuNElc8NgzmlibYnbWlcktnS0Vovhua1jRu+cCMMWhEkBKGuHNl/Q8Rs8d6odbdIR/fd2qR +iFipbKxwa/05doJkGbMowgnZeIiLHykiXkxP3j7jrEiJzgquEbzETAyOM/hq+wJmGaKQdWpvS414 +WQcUAhqA3777eEE+jn4jYEqCiPPy84inUil+v4RslnNXdRwrTaoWQQMQAGC3OJ0Ocb+FuAP2y1oK +E8z9vUtgp+Eov4e77757+vTpuHNBUL73/vPge3/XXXcBcvwYnkOY/BiOPvro73znOw8//DCkzjzz +TIzUSy+99J577vna174G3J511ll0YD/4wQ/uueeeP/vZz7q7u/lNQnD58uU/+tGPQO7zzz9/yZIl +KJi+/u4NTw2MDrfRD87mQz2bUmMj+TWPjyzav/mWa7qv/dH6g09oTI5oK/BDju/omJz49ZWbfn3F +pr2XNja0JA45rmP1w6ONrdETzpw6dXaCKaxA1NauDEoykw7ednX3737eu2Bxw4lvmPKH67dc98PN +bNV2/Os6GX/d2p1JjeU3rE7y9I+/2fqbH3Xte1gT29uzjISABg9Hgkec0n7t97u+99l1QOxJZ02p +qef0CRCr9L3PrR0eyJ3xzukbHk/eft2WKTPiS49uda1NWXrnG9cmv/PptTMX1L7pX2fd+JPuKy99 +6iNf36O+MXLrL3tv/EnPpOnxV79lOgq3pi7c0BxddGDjn27u331JA7WgkcByoBoYULyyKhR1jw/S +QdS0lj217Qn1iOFSjEvDJ05UpQVu5LlfVyyh923DYW8alhxEgAQ9QgcCDAWG8pqD+XYpRTS+jscu +pbID2XxaIIrZGg00tsqpi0WusqRZcYGTtdxvQRrdqbTSHXJUhfSsrnpkcbXOUrwgLAnADGvJAOdU +S9WkU4QLxR0vaQhBmF0pDh2cFuKKdlVg1YuIDfPEqmti9je1KA+LX6NsP4SfQ1sR6SBbkwml5ILN +y0Qnj5LNlwt14uLD+KdpFKRSGyngrDQZmkaWx1i/nC0PxyKGK8W6L6XaeLTALOOXmTtXotxecKgD +GoE98I8vBZ0qINMDfWIaQopajWTsG0AR8nN1pOSKJvFAnEcetlfbRNqEBF5sCew0HOUnMTIy0tHR +MWnSJHe2AId0MOlmPvLIIzx9bhyl3XvssQdXiNx+++2rVq064YQTDjzwwDlz5nzrW9/CbQuO8iiZ +TG60cNJJJ/FzIv/8+fMZdyGybNkyTFt+h7liH7eowYZ4bTrTSzyWCJ3/sT3ra8OPrBzqWp8a3pKP +RKMnnzUN9YqrcfbCurWPjj758Oi+h8bn7KHFpIna8F5LmxI16EIDBpQZztVQ4I7rt/L0hNdPA7ra +psQu/dcn/nj91mNe04lKLdfyibmJujCkcNv29+Trm1mnKg0uV2o0cPSrOxqaY7+4fMPKOwYf/fPw +P75j5u77NK5+eAR7d6+ljXP3rJs0JX77r7c+eNfQfke2uiEIWcquuLkP3bJ0eSum88J9Gzc8mXps +5cjS5S2/v3YLGc48f+bU3bD5yjgxZTcOEw90TkvsdUAjiWhfoJErs465FUFSDIqIy6dttimeYSba +4PjFlc1TaXnGdJm4lDAcNRhDGkIdM0YpK6SpWHLybRpuQa2YrYmWJgWKjflSthTQMSiozXR2CBB1 +9IJIc5uW2UABlgQQHojAnLlnHQK5inW7eFmJxbIJlszc9CLOs3yhBmCOqRSklPsDfEkuTHoKZ33K +5sYcxOwzI5sIcEdBmu6MUVxsqH71Ociu7oUVUYYKcWYAcSyonA5auRTk41a7wNNMW6bmGlVVjYkJ +D4halZPKH9avRCLZnPwVnOsFwJaYasQQabEIrGK0GqDAkpbNYM6yk4jm+pbGAB1VQIsrwCNaL+/g +4AfDjqZExsMntx5ohENvFYCrgAoFf/rybugEd/+3JLDTcJTfOTYovhqC7yQCdgJ7bpvy9P8rV/CR +PADnhg0biNxyyy1AIxFcQKOjo0Rmz579qU996tOf/vTb3va2BQsWXHTRRUxiIr0a+BFSUSrXRQoT +D9J51LfGWjqmJObOahgYyEbj+hGmUqW6aPF3v+h+6J7Brd3pmCWiCPntulFlOtrO9za9SREOtsIw +zKQ4Wy3U1hlnMcys+XFMTJzAo0NFt2k6psbrmsLQcYKob1Qto6oEaoUmWz3suX8TUH3N9zc9uGLo +55dvuPBrew73C4TBxc+953E0KfSphYIAMME0ZKB/iw6Lueb7m529RG0oOZofwf+cLLLz/vS5Nahs +lLJrfOGAqXiAgeI8IkGmp61OkevVTChwHT0s3Y1VzwhcWiDqHQKVh4KBqBa0WIAUZWkF+l42FnhA +YXftmqWlXEzeyreFAozLsksUe8BaplIpmcYSzaq4WYHMznUKlFBLDexV2m+JIS//vphBSUXlppGh +ErN3ZN5jmxdNMu1i7lL5e1Zxq/I6eCRRWGPLhHzK1bgRUHgQNOrbIbSjlIvaZUhZnqq9xqLi4LFJ +kt0Y6muifcN8P/SUoXQ6Z9DhqrxKJW6JvFCzkgWi8CR8ZISc3g9D7yFWVZGWyxapkdtYOMD4OW0E +1yEltzCdHirm7ACwtlhMl5IxnZ62036/YvTFCoAiVXk/GBOTny23VQT1W8/jOMpTv32xGJyoZ0IC +z08CO+13SD9x4cKFfX19TDLC9PTvPT/4P/zhD6R7L/I5WANuf/KTn5DhmGOOwe4ksnjx4uuuu+5p +Rd7ylre8+tWv/u53v3vJJZe8853vvP/++7F9PQ+wzS8wlx/JFwdJyedy/SOjaCUCJkIiGsuVMlUt +/Pj9Qzf/omvpUW0f/uqCP17f97/f2IjexK+k0T40Mo45VFY+MDogHCLgYGpoCTF+CcilM7nGcKRr +IyNccqXWNYTGVKFUvPBMKkIBdczqUp+Vyi0EwR7wo7ktcvYHZn78vEdHh/NbutKtnULaaXNq3v5f +81QKALDFLcQ9oGpb2mnj2HFnTjr8xA4SUdPitsiynGAmXcTCnjRVNijqCP3uUCFlJGUtXMFpKX3r +QIJSxgY1BY3ZxDxbGMYqAi8pC2UdPiNaKoi16sgK2wYL0ukKBs/KZkWkBtm9IdQYyU8NlepoKPNy +ZcEiReA0z3k7WV6E8ge1aRF7XIglA36x6RGjrFs3Ac0qVQkVKzeKv6qLorbWVv5qbv1DFsdjihsR +0mkRdjYvQjODHCZJlAZ3JBMpOAGrVBZrD2nYZGxaTTazfISpvDvSRdD4gSWAUAit+ValodGsV83b +p4jgEiHbuDIRGbgUNyYxKPkq8l1ivDMWkf0KRYgkM3Z+i1oaklu4UGBeEjfMQK2NRwZGdUqaUpSZ +TMQ1sZWtJ1l5qzZYIM8rFGyc7Vco8xXxT/z9Py0B64HvDAnQr8TX+uSTTzJXiOVcrHvBKr3jjjue +eOIJpv/wdLuV3HbbbcxC+spXvnL00UczIMp0pIMOOggknj179r333ov1+eCDD4LEjIBSnKHTq666 +anh4mNFW1tJgpOIUIn2//fbjyqBpb29vvtSdKwiG8Y9lWWxHTHoz9FTvEMrddfLIUGDTakU5KO2x ++8buuW2A+JbuDFNwGxsjHVNiPZvSjJKufbTw0B/DbHVEWLUysGVTcL/DWon/7uddm9dnbrpKHuOl +R7cwX8a8a2aykGTKkb/oerQqwIP/EI0Jttzw482P3jfEHKV7bh0ERPE2d0yOzdmzvm1ybP0TyZt/ +2t2zPrn20ZF7bumHbVRwNRx4VCv68/Zrt9xzG2O/6QfuHMR1jN7Zf7lmQf/q25tXPzK6aU1y9aOj +cDJz91oSH1050rsJgxxuhD159gcGMGweEH0FrGSUOzUgBZaEakDURgSxTdlHAo0NDFAK/oEWBfPf +UsRhjEbBjxQ7CMRgZ6m2NjgnEVgQCTVoRZE6JHQaihhnuXwqnR2BK0hRL9vn1jRIGjLIoFr59gkd +LAXpVeS3rVJltaBKPZuJmSJQIIUiisAPjFlOGCBRldLhoC2egUdAEXH+W4QWESQKaxpXFQFKsfQo +w4XXR9+ICC/RWq2emdnf5CSwa3xG05Dl8qV3QhCpce/OrMlyEY6zBf8AUYhXKfPFQCA0hX/QNAO0 +VF9TBx/kSabzNqtIQ6eJGAtgNGQovnhmp74AnwRVPBEmJDAhgZdIAtuHtxfADAMeU6ZMecMb3vCb +3/wGlyzeXUxMxkfPPffcqVOn8nS7ND/0oQ+RDijip2UO0ete9zpu8Q9feeWVF1xwASthCFi3hx9+ +OOOjW7Zs+eQnP8kVVcIUXybrkpP8wCpDqiy5WbFixdd/8BYMUxLRLZks0yKlYoAT9vyW7jEF95cV +btUOxAAAIABJREFUgdRIQ1NL/f139j/+wPDRr5nUtS512zW9Sw5pnrWg9h9eM/nXP+767mdX77Fk +Rlt7p+vEdY+HIXLMGVM46/vuW/vvvmWAeYIsAD31jZOhjw71GtGk0mmmTwVaplI1aEeeQoC5tT7C +ih25+z4Ny0/rYCsG6J97wexffGfjbVf38sHknbd3PUOhRqMMD7stqDvrvTOv+2HXz76xEVK19WFs +03mL6k89eyrF77m1//KL16BdDzmube7e9dNn1+x3RDN7OHz6/Cc++s096uujICXYABvkka4HJ9ib +icE81tEyJsqpNWY8AZmy7YFAW43D9ghYq26AuhBc+0NE1KTLA+FSLF6aHA5NkhnGosdSeaoIp+rY +v8xYegAkAh7obTQ0B/CHU8qNM8EBojKoU6TcYAmQKOkKFYBQosnWq5YlBx0zIgVvlfz+fsWcBWEe +NDAcfXqtZzM6fBHIVa5FmSrgivdbG1JIMrDqZqUg0zhxgqAm/PChOvqHMl55agCsVlhOKiWzANLa +hRjJ09IUS2UKY9kCcMrCXDLwuhEZdBIxRZibm+b0eObUhMPga5o3BwXzz0M1l2ffBk1+gvGwqJur +RMxOhAkJTEjgpZRA8DOf+cw555yzU1gAwMBO7EWGRbEUwU4MU9/x8tns0eeulxm/zP4Fnse7hfH6 +UlF1Qap1x3VhNi8zeHszlz+1dUU2R78dS4KFFqWG2ujIaK4YYR+GQs+GwKoHQoNb0Y8acmLO4PT5 +of2OKjXWl3o352uacKRJjfb3hB6+N58ejVU1KeqspqG010G5KbODuHMHenJN7ZFoPKi5OSwhTcqS +8G140ap80HLgKICOpkZpStWi/IKlkeH8cF9+0rQ4Z4C40SKXqYVcujg8lG9uiTLsuk0saPAKGNMi +xkRhu6Yugm0X85kvzAzKlJju29we0SnlZLct8vGoF3LFeF2EqtHGjOCyBxOBiSosd2E0Dshk531M +o8yYwYBmY2nuD81PYkCGAw1NwobkUCC35rWnvGEvGghbaHwYBhuKWepvjYU6Q8HaUAi80DRL6uTV +gKBZFmfksiPJLdlCmhbg32Z2LsBMccnBQMgEUoYZ4RCAYZhahq6K2eeioKDAzEK5g6I5roJ58uOn +JVFYZeDqY4ogGYmiDNsGWkRcsl41NUKzPNPKEFdOE7ysI+r00Eb1J8xGVNsdxc07zSIibvkgH/ua +iY5AXSal6uIR6VSt2i0nvAOHZGeCN4n6VuAmiUgSarWOBGCvIu02zKxV9i1KxMKj2nPZWmeHwIOg +kGVaL0Rr4olSKF/KTY8FZjHKSLeSHwhXgklo4jIhgQkJPA8JfP7zn2cTgudR4BlZK1r8GQ9eQAJg +6TOMUKLocX7bQCnBJxS8AIKYm9OmTXtaQYD5aSl+C7Jmc6D4JjY/RyvjFctk2T4XtcOq/wJYkkoH +ujaEU8lSJK4pkag4HJz5LPv/5dm9KMKeYjFpZJBjSzejUQlwRTjqcGe6b2wERMxjTbZOxTEq1S8A +AVrMhQsb8o6iXe1WSzbR1Ch3vLtMvEGfhoMNDdHaeg5iVjY0LEggzUtcm9qH2jqwBxUcDxTxCUQG +XWSta4wAk6acdUVlC2DCQTzDqHJ5IG00joJQq6kNkWIMyT3rUITpCVJSKS5cICTDzvusWbSjRsWV +PaU4KEucR/QSCIIBgzEK0mEI51sDxdZIuNaUO8s9gAP9ky/XcJTLWKpPIEobbbMFZAvOUZyP+OcP +AamCC+WoWJXRXPUqe27L7AIhwZ20XhZaFTJKIE4bnU9uBVcOfrqxGsWksgn25KXQLZtOOAArqeq+ +Nm88pIBkD1CGB+7IbPSMPtm4gQ1AFFr2fSjXQS0gsbEBxAFz7LGgb4d/YSgkHzv2J9sVqbj2vK+U +JD2Vy+oLao+8XXQM+ZAtEY1kC3kgmC+P9vp5xQ6LumAnrhMS+DuQwM7EUcQBZBJ8ZeeLKR0ZpKVS +Kr++Lp7tQy8BXzosAwWlsSvmDXGkxmhfBNsLZI2WwFXTerYunkkwo2OFSDwYrysVUoHhgXB6jMVq +Jev6S7ehQAmgI2oNyER/oYjdjiFdtibzdOzENKAX7Ym65akyWE5Kw4eZIzqGRfvpmCqXVjaYc6jT +lVCBK0UqKXACYBtaiR+SUaEQqQYAAz2MnpZ25rGNa7r+JQ8YJpS1PgFtgY74ZOzNNkGM1+usNALc ++pRdjZKybDSl3Rsc5zRbR5Vig7aHCm2hYE0xTGVYXqJmS/5wQACimKJ5bNFkamsmn6RSKmJMFCgF +khGCM+3wRkEi0FVD4RlSNihLmtywhkDkIXCrTBagqddRwUjSeCM89XfEreTPc1hD1NC014dY7Ktg +jyyPU4aaiCNbPKtxIatw2ipVFU7W26i26qgA/lAFDJNLVRMsAwVVtdXIM7agl1lstikzi9Sx5KHx +xoWy3OuWoWty8kaiwSxHEcmqL5fCZUE3CagkBTNUZ5gaQTPn+VqDnzwtBxUTfaugkjjxd0ICExJ4 +cSSwk3H0xWF6fC3Cz0rIljaPZfvZ9YXl6ixeB0BjURyX4STHaKeLyTEWyXN+i9SeYAkthYbirC5p +RNQoE5Pw6ZWSSdtz3Pb2U0WmZNFYUqH4D9G8UoMaGCNIO1oG4thwMuNAULNLgCW3U2UmkgsYU4EK +IhgwyF6EMnH08jhbqpxJdcmQRUk6RjpIk5Mi0ubgjVSyMognagG8WatqG+QC5D4Ll64D+QXtVru4 +YhGOTTvCL82p0sAnXl+UPn0CqqYVEGQlDDQZIuWKFzkWYNLw5FCkFs2P/AAZeih4HZA91j1RWaIC +0TSWaCafohbmytQ1ybmKaSveKGTA4/AmtpUq7BHmIR9DKSECH4cozwDbBjkkauatiKmUR4R2/iLM +BwtxgywDTmo0YjRfMjS5wQZtdMThKWKh4Zp4hQxpG7c2/EkNYtjK0wXhLxVRE6TcDYCJLwb4b8in +dLJZRRD0dD1Hkux5YW+ZgmRT860u6CtC87FcGcG3zOQkFUG5cGtiMaxPfLdMOBd0ynDVbF5M3EIx +WxWSSk2ECQlMSOAlksArG0dR4i43R9LB5Oquranpbe3ZTHZguBCNZ1A0Q2n0jkyuYi4YidrKFnPq +MhCFDgNjMKTQU3Tw08ng2BhaUh1/oEMKl2A1oBlJZJKH1tZo71Q9ACk9D9pT4GQb5vkUYZSsw6es +VVOvUCBRutjIojTNzacaZKGiXnnkgQxmpenOEmFBVbj+5anpbu8KAJyW3ZDGjFHVgFHFFhO2owIU +KOhogRxAWQXbEpxZP2zQz2b9gl6OLsnqKs4ZQM3K5csOVHWhDmY/N0aWhEIJMSlXJRocVS8IYDhU +tTFhVQOjxUw2OZrcmuMogJCOQuNI0TJcwbkBkmo2I487GIOEYxt01UZDFNKRjAcVt0e6lchUSn9t +6Y4iFDPpEeFWL86CD5HqpDkDaahTl/hXJotbhLxiwOpVU7SCswyHXgSiLkyATVKn72UGK+8aUhSB +rIrbOxEpI8itNxN+MDcJqpearS1Q4Nvi1OIxMFFRdWX4EopeuRU6Po3VomzRwAYM7C5SyMnV47wa +w/Rk/Lsk0hZ4JxMmaUUYE38nJPDiSeCVjaMuJ6l0DXdlRrNrmKPBbt4jwFekGC2w3JON1PQ0yKHH +HA0ZZo8YbTSPjpLGKTHXpoQPU4iIm1Jbykg129QNHf9CKrRJpRS6Dy+lyJmDFO2HL1cOQxDUFCV1 +mqfTmVIitZDZlSYLSUmBD8hCkI/jH2nEUbvlYKlO0JplDKBf+ZhNKeQgAGjmhOQK8sEebIDc6Gi0 +OdYVBEFHdkOgdj2iG0FXAKBFX1eOy+bgcZoAPc3HMTgBOMeGNQsJ33VLYvrkxkOb4of+OXB7LFan +U6W1eTL53aHIKkdWtmDA2rBorpDJJbFEGWDFtK1tCNRyFFpFUAIwZ1uMq0a1AFFYTFfDQgmHiJmV +HiEFKKJSPr7ZhUvNxUUekYMgL4+ICZYMZfpel1dhZJXFXKPKr3Ii69gmtNN7lwzVQihbEKJXANgf +OUsUV9ckb6a/9Z/kSXZT2JomQdm7oM+hQVZrLN8v5IC3gF6FGogPg52J6ODl9V3zIH4IvNxioDbB +trShYqYYDYZSuVykUIBDpshFbAGMzZXT18W//xMIWhHhxN8JCbzYEnhl46hrEK44GNkBPhAYZsFA +1+AwA6ACvHwonSow6pkqMms31hNOM/InDchEGxAF5RbB8ciWQMTkquT47gA2WZBdeTRkhQYmUR9T +uMBtXZ1sFmqqiWm3I6lIV5pmowBX3LprVGOoqEsbFJTSr+AExWFAut1sF+IKrkQrupsEoYKyKDNB +OtfghLgog/rmOhZZvzW9jE2DKcnTkDYeLg/Z4lwluLnGFdBVi8xRDAwQQXEzfklAGoyYFnOJ5sjM +yY0HN9fvl4g1M1+JRyzPYK8i2BY/WO5S5ubIZYkoXl1ZosPJzCB4l6jR1FwNiJaHBg2rRF7BWyEY +A/gdXCtIKU6sjXoKIlYbb6UkCyulhiA6z+BEuVpZq0AtIjMX5A+3tBFqxJwm746gvogNZ5ZhleeQ +dWMUmUDfOh8ufIrwFDpqkc08Ug1Gx18TjyBo+GfpcnyLByjqxZnzQkI0S1qM0R+ygXlKsZaUuqAG +QAKI6uvAqprMmd4cRBocSaVjvHLtbcTYPLDKoAPftjD+dN6AIHTCBtUrnQgTEngpJfAKxlE0CJIz +TaJLMseu8Wydw/YLAdR+sBDUPNxosC6q48nGtC9dKZbQTF1Gl1hXSpaGllITW6kDfimpfvQV2iwS +L8XzuHmli1FwXFFc/GloLkSZiFQIMsOTwLCidJ/BoXQmmhf9KPOM9X/SlSjQEqBlelmmkpEqv2oH +TuVVkL42veyAykNrmWGJZXBOGMtkxhCZxbBt1wfeCyOoCNQ3JKiqfjAeqMBrDVfYl8zRxSrS9CKS +4dkwXhgDiJLIYpg0azISjZF5k9qOqE8srqmpYxVNDLuHholDdnW1Opj9XJ6Uy7BdPpfFKs2xd246 +l8Q/WVevAVHN/qV2mDa3KmhB1JkUKTPaJC6j6yJAXBK1IaU3hLLkJJBOhAx6C7CtNCtrsCT52xSq +belWhEQAyZHP83PLm8buE1U6AtYj0SOkJweqUli/JOQjj1Unzo15XqJEYCypIqvMuYU9gZ/MRLHq +cOtkqQgKfEmQOcTxGfCd4ztGN0TOCQ79VocElmz/RFoBWVGWd5fp1+x8lMkWikg1GkkXcrwI+i7s +sRXX908+AH399JonwoQEJiTwEkvgFYyjLrkqmqZzW5gtyvgWfjNgMmXbxrQ3xJsS0TWDI6EQe9Oj +2QCTUpbt07G+akptU3KNzcFsSiOeQBSDhXhEMeAY6kMFoz2DWv4RAhwTNcWWjjzbiAuzSoE0sOQm +jgxUAwCUn6lUDD5X4lKJprhlP6CpLXgppT9TAbqKt2x6yH8rjvKEFLoY1PRkGUCm7rkKAMAS3M44 +q8FsgwfpbgqwHpRRz3Qgg5WpXX8lGbdZoeMeXQ0PsyKoKxbPz52728nNDQvZ3LUmEYnFo5FoJBji +YGRVCoqwxYLmE9lAKPjJP0A0nR0FRAFWeiFssxC3FaKamkspt6tg0AwyJyJKpDt0YfQDHth5hoVA +F9xLaNVgFOBcwGYgxBMZjoCcIZyKGP55Ck122EMUyISCLg1ayiPJysSotiBMytIdMfsPIsI8UNCm +WUFNb9/wmzyOl04cXNQAsVKtjcY/0qasljmZfc9DYFXyJ1JBYuiTjZY6q1xzWieq6UVa3au+iopL +2PpP4LiFUENtzXCaQ8VgCxtX+x6xnxE7NcRinAEuFAWH/ftvRSYuExKYkMBLI4G/BxxFlRDGMj0c +YMgKAqAUJYUqrK8PHzRn7l2r1uOlBUSjCdbBBNk/NjDG9NNSQ3OpsY3lBIE8jlzzQ6Ik8fFyCFqG +zWUASIw/5rVmCrXxYGt7sZ5DS6UHg5xC6uYUQIu6xAZ1Hc0AnpyuZiSUB0HJbwradbGZdnrNbvR4 +pPzaTZXDgMDbVLADrV9R+o4Ejh8OVKS44sZOBbxhg1uN4FLc5p3KOA4E0oAoTUnQFRA8cEsAP3ha +XxttiEx54i/B/k31C+Yf2tywoLEJQyiUwBRlBzqawo4QBj+GX/hvC7ZNEWf4sFEVSDqWzQ+BIGyw +0NBquzogNMM5oYXZZyAKZBxO9AhCtBSQg6zlJMmBQ1dBA8kGd2SwbgR3pAg+PacZmiptRqSe4VM1 +JCMD2ClQhJbKqK/j03yQG4FuhIBQTCgi/7DllLzZYMhPuOORs2e1V9+UkNXqEoGKbarqECbzohE1 +PJGOnW0dBcWdE8tPNp4TyKneg1prPBinGtMXxxZYGBrElVLEFcBWC4AnbWd6EWRZrUuEhEyOGbyc +iFBw+5wv/8TgaFl6E38mJPBSSOCViqMGnbogNL+GI0N22EYpEdWsy1CshFnFKGb/2HA0XMqES7X1 +zCx1nRlM1OUaGqVvx5IqzfFU6EQZsiBBuJCoiaSZaxMFObBIg83tuaY2ASTrF9gdUEhgSlBaWLWX +cRGtjSWEomT+DvqUW5VRDqlswQkqlf+uUEk3Oo6UwgwyGu7yRKrc9L4TwA0rM8iMG1ktrGG17XtQ +7iColqnAGPvJsY+Ej3GabQoFVjHCHvvCw4ssUWw7eGDyUa6+OTKrPXFAW/3S8G7dtz91QzY3gGU5 +pZZ2SmeXQRTBqEMBPzpDU5sU5RxE8+nMUDrLgGgBMxRfLkEZDUIEJAYecMXHoVQAaYagNx9rSnKr +jKGSXy+S5hMjIDFLAUJAIwTFfB8XO1eXn8RFNrdTiYDc9oD8ihik8U4piExIUQZqwABFmIClLRDy +2hw4Be1WNRUoP/T9dWD02SOqI1Cj3rsjNO0ns70avV+kVgFRUa7EHVBJoacFKZePeBBDtuRGY57q +RcAbWBkLh9JIGpc5owj+JWGIgJM72fOowAb3LN3FJaw9Asf7df1XMAGoekkTYUICL64EXqk4WpUS +6oOgXfAKLPwP1zWGObUbY4rhusGR9H1PrkIXY4ShgICTcKSINQn21NUzX0PbzEpzkSGrKaboeuAz +XgNSCjw4wowjZIJBQQU2XzrFOGtQZ0My6GhqXyqeUFHf6GtUJJoajYkhx7QdgnQvOtJNE1PxaMYy +FPCoAqVSl/ZBd7vWBinle6S8VLJ0rqozgJFBA3BmVBfal04DIMpKFc4152g2KEBWoAVmhNgCSW5D +FrdkMUzzgabEtNaGfZsS+9YlZkbDiXCstP/BbWvXPcD+i0P9fYHZczmZld0UwFz1LZgDTU8EDGYh +EUfJ6l8uk0mPJftyxVEmcOEDZ+oWXDnPcKrWeaurcfjRgzLGCPwsj7KZ6IjAJ1GQmAhoBJ9lyVir +Kc1ToRpPre1CI0giZINYrH/aSC9BwdCObERIgRrZSBNsW9UUhJTQ1MiCfOTJZsqbUYigcWVkzGSk +oBUnv1G1W3OtC6fhEArCP2smmajAgsOt0o1ViOi7YbeeyHhtLMoiIuEpgVU6kNHLKhb4LrGamcxi +m+LmYGC6tCZJl0pAKRO9QhHmM3lRKz9xmZDAhAReIgm8snEUBEVuXAuFTD6b6Wyq5zjIgYG+cLQI +cqg7XySCniMPmxRqai7arbUjnhzLDLFu0vQveINfF83FDj6QS9QyebcUbAzW1WOESeei2lhMCVwR +5NFlKjDa0DZfJcJHflefAIxWxfqBimMqEQwpszykP83orF7L+pYHFTihLvkhmY0CiKL9Lb9mpgBr +0LH5TZQC5agC7Ss2wBWL0xbKghx4WQluegJyZEtuDTQm2uoik1oaF3c0HNBQOzOSgGn2VioyL7Sh +oXGffQ645Xc3bt06kEqmGhriJSYQybosgZlscQy1VDotHE1nU+nhZKq/FMqyrKWuWQIE8/QOLIBA +pMCbIxz8C8MMwEgnlB8xA8iMVy/lcuBajVhWwRvdhSpkGnKWRQVlCHpdxAW61KvOz7YanbglibTo +GwbDAwUdLPVqrF7mYSlAx7JJ8rBtr94jTsdRU/J3BKUbgw1qTSODWm3N4IJMqtLw6tQQMtjVH6nj +JboKRGhQc31Nv05JK+obBTMmPeXRu7aj0+SlYOKubFf78ldlb1QmLhMSmJDASyGBVzyO+pY6uUI6 +UxiqT8SGhjnGSt10+v41MfbOlbYJ2wAdE214UhePcabjloEMU2zyHDVdZAKq0rHk0I/kkWYqBhlN +1OINQATly55/cqXJZxaMlJRuSCYExXiyUTeZULalkTuHuXUFbfpRapIIKTAj5eh6k3sCitX0KVob +2CAf009IxDpxHUldoDh1URC7k/ksQn1mM1G1WZyibEYVxDj1jNL4ltHXZE4mObm8fVL9oimtB7XU +L+DgAHbF4by2CEt8ZC6JEcbbFuy55z333tnb29XXz17/8VQmyfAnJj4gOjIyDNl0Cks0k0r3J7OD +kZoiW9gjBJV3FqFiEAI/pGzDFYM3eXS9pbSIxsIfJa2NikMBVDM50KKyELygCY3nQiByVmrRBGsC +eXjkmG15qBrhc3UzlCyqznyt6mogIqRKd4T3BUyaqB2rrMtlXCE0Q1C9I2saOfkQSIFV2KCN0CfA +LbdIUY/4jAtqEyn2yigFk4SqWMgsBihUZKRA615gEhGwN70y2xIuTillZ0qdAOPyFD/axIhC2kVK +57nyEqnbbfBtdVNgwrW7TRwTsQkJvCgSeEXiqNRLJVSklI1E870D6ZFR2yzNHHqsfewfKXDSGfoo +kjAfGGvbY8E1TyWD8QBL8NBM6DhskUhMmxMJn7DqmKukw5bxBuPFLYVA38pmBWjAiLYVR5naVCO0 +qmlJaVGNKEo7YxUJUw3YpP1N3aPBUZTcoc0JROyvlKllsUaAygYr0rCmdikOiAKH5ENnEte4b0j+ +WwKOXJgkM5W6pmZ2Lm3JjIpOXbQ5Ep07uf2A9pYldYn2GLvwx9nOiQO50Mb4BYFPilJQfsLmpubZ +c+Y9eP/KDevWNTY0ZZkjms7gv+WE1+Eh4ejo6AAnoAUjqcY2TcpFuVMaZ6MaiDwsInLeKiIVG5QE +PMyerjgfs/M8TkZ/JMnYI90S496C6JOuZxbh6r0QxItASMc+YwMmoNom5QI09Hi48h419wdKtvoF +CmXCBoSCRgdFo4AfwhmWSCrWKnxCx0EUOqJg/RhFrP+0DRftZakyY48atwVHWXsizKZ24wQsx6Ll +hZKoini/uHQjJaQMjRpOTIiGcqWs7f+nqeNkC0VLrDSCMmP28bggFbzUglNeNvShgmxI/ZvDN7/5 +TY4mhMzee+/9qle9qkrv2dKrGSYizyGBDRs2fP/73/cMb3rTm2bOnPkcmZ/Xo11H+Xmx8X888ysS +R8e/M+u/ow4xOUNjDOZJldgxGvHAT769pndT9qz3zGWT2AdXDDywov+wEzr2P6AZhUUe8Ak7QJZB +qQQCoXnVt5f3TDu1MfO3a326f0t61oKahuY4RCEC5KCqAFFpQ9NfmlVkE3wYQBXOQUImhexFCJbx +AO5M+XIbNsUt/h06xPhfKWsSVJfZVahagQGWSkK8sbUhj3QsKBifkmFELUJZDFmbfzsG3qfDdfHO +SS37zpy8rD4xNx6twQDFIRyzLXCEpXQd6EDApjR4IVQIF9kVt5ibO3f+yvvufeqpta0dbTh7OTdn +LJkaG8kMDvQyfWkk1R2rkxmKo9iXrkKBAA8E+BGCGGZwLcdNDgIPMM8tUXdjAhvULrVv4IQcQFaS +yOO4YnhjVFS2WoVjthek0wMV5IOgtuWx7zI4ByZxhYLqtbo8IoQ2jzdXSkGBa3JYL86DIJAarRNA +iteliBWEE6hBitq5ikKFTjVSJqsngTv/uHJslEPpAs2tjQcevNgRFFIiQtXWcBIVEGMxMJzPY0+z ++Dge51wXnawQ064LYgMRsqVRxhiNcYCSbFi++AJg70/uFAQ1VgKXX375o48+SpyzhMfj6LOle6nt +Xh977LGf/vSna9as6enp4RDiWbNm7WZh2bJl5prebqG/z8SNGzd++tOf9rYtX758J+LorqP89/km +dk2rdjKODg0N/f73v+cn3tTUxNQVTlI78sgjOab7mczzZeJndtddd/HLeubTHUnxPrjnLBaDHIjG +wKYtbw+UDIcevneoe2OqUJzDngyb16X/cvfgwv2aBkdkdZjeAUcwK0uJeilxS5VqRakxhQdF+cif +B2/9Zc8Z75i+77K4ikCV/fYqrj/UIXYnqlwQAEDaXF+QAE+vRq/KbOnPxjWpyy5cVU756z/HnD7p +2NMnGXE9QKlCTfsrVVZTwAnTmrCxfHSWPRPQqrigMUZRuFE0LPp3RHNSGuta47Fp7e1LprcfWpPo +BPxwXDMkHAlr84UIXkCWsmgOMTCgK+3lvMtCKc9Z50wjqqurq6mp5TfZ2t7eUNc41D88mhre0r+6 +b/iJPecc29Duuz6VIQcMgAQUuAoYdCNg0EdJ+hAX8IBqJluJ11qnzBY8MxnAA+BQRewR6epjwB5A +aFAniLWygg2PVGskp0ERpQgICigiDuLI5e4oBU7BHgXdvjRb1lhXnwDBekVcyYN4BZ9WDfnFnt0K +tMzMhRled5VVsSzSqt0TKUsJUr566Q/Wrt5IdNHiBeCoEk1KkphhvPOs6pxD2wgJG7QYLKRz2hRa +q0XVU+EIwqA7nOVOCLELUj7GNg2I4+UamJrw/ve//3vf+57Q/hnhqaeeam9vf0byRMKEBF6pEtiZ +ODowMHDZZZctXbr0sMMOi8VieAbB1C996Uvve9/7qsdu7xQ5vfOd77zhhhtuvvlmunWgKb9VBvlq +Y4lUPpjC24npBj4w9mmVoU45GMXUrPQjK/JkdgCWnDnKDkc2zocdCSheddk6oPd9Fy1saIuj2Q85 +tn2fQ5tbO6MoPkEc+hnPHsTMc6hEYNUNi8rcH9Vtc08YkJM7zgb8OqbG3//Z+a40v3/JU/1Q5WI8 +AAAgAElEQVQ92XMumNXQSmF2cmevA+llDzrA2+05u4e4AMa0OpONaQ+2LwgKSOC8ZcPgfDDANKDc +WKw+tmDxbqczBTcRa2KpKBASjcfNiSv4hG8BEvBZEsKXihpBLgg+mVCkqUSjYxifo3V1jevXP7V+ +zfqW1ra+wbV9Q6tK8b7Ju2tGlY7gNlAUhDiKwKqbcVCtQiCJFnf4KeOKtcXqNXGRx4HE8EwrKQEe +Qynlt0QiEi/0bVMLeQ4QkVuK1msRtiFnM+WJiiWwFugFdQyG4ZN0dDjlBIFUYkVUBRhW9kPYalqD +T9f25LFcZY55g2SHWwQOfRmBfjU+PRPdAmgq2zPDeFpiX0FFvWNhmFqGZANvmgM1BqZzQ+WeGeu4 +yqCMB5eBeHwg6v3QWWQVUyGMiar2lANO+E0WmBF2yimnVJJfmr8f//jHv/vd73rdtbW1hx9+OOcQ +r1692i3dl4aniVonJLDLJLDTcBQwu+aaa+T2LBb5tWDfjI2N4b0hkH722WfbKSrbbwcDBvzGcBz9 +x3/8x+OPP/7qV7/64osv9qy//OUvf/zjH993332NjY3nnXfeu9/9brLdeOONgPQ//dM/nXjiif/2 +b//229/+9odX/uCRRx+IxkrzFjW/5txZ8RpWjJbrQgsnsIfNRuSMFzr0j943eOfNWzavSzLjZvcl +9ae+aRqm2p9u3PLIfUNshPTdS1bveUDTyWdPfeiuwRU3bT3h9ZMX7N2MlbPu8dHfXNXd9VQK4gsW +1x/3hilNzeyKH/je59b2dWfPev/M636wuWdjevEhLae+earqRsUBBgx9RUOdM2qkMW2yJU86pyWa +O2NobVYx/PeFq9ik9vyL59XVaQPbW6/Z8uh9w2/7jzl3Xt935019R53W+eQjI4/fP9LUEj31rGnT +59ZB8skHR377y+6+3nRDU+zgZQv2W7KspXZxTXi3xsbmiHaciEaYmywYjTAI6jYoIIrpDDQZgrJ6 +AmduPp1KZzPJ5MjY8Njo4OBgTaI2n89s7H5kMFXIR/sbZ2SmzdGew7lVhgFwLyUuZNKSHuDHWiT0 +Ml+lmmxaH8yW09hG9aT+STewUWz8182gTqUMC4SdgKDVAk399e6FxanLM4oBmyjErcOblZCodewa +pXSWZwg0ghqlwEKc9uQUUpqJ7BBLNs0sszFU4nyssDFjzYFzpUN4HIhCoYpcYnVcKKc7N97ep2Xw +5lDE+gqSFTyLy/IAs+IwSXeBptnoKcuucOnjBWFAISzE5n9IgwuM7Gs83nYWRIzG/fnnn/+rX/0K +8vvuu+9Li6Mg+he/+EWXzcEHH0yXl161327evPm6666rqanx24nrhAT+PiRQ/XH/rc1h4fjdd9+N +Ixd3Ln6btWvXcnXXLs5bnj5HBevXrwdH3/rWt+6xxx70Xr/97W//+c9/Jv/WrVs/+MEPJpPJn/3s +Z5/61Kf22msvEnEUz5o1i8g73vGOU089FSUCYB944NKPfnb5ocd0/Ol3PSt+2x3H44lGMkUmBVrC +M0aCKyJOGC3M37vhn94/d7/DW//02/4//a6vvi4wb1FD2yQ2qg8cfnLn4gObWT+ZGi1s7cpwRU1t +Xp/61kWrB7ZkT3nz9CWHNt/7+4ErLlmLmuMRiVu7M1d+6akpu7ERUHjFjVvXP6FNg6gQPY6+kxvV +zFOUYzXAD+kc9zFpWrxnQ+aBFeyux8aExdt+1Ttv74Z8OjgyVOjrztxwVRdzgmbMqe3ekL76ik1s +ALvu4eSVX10bCkaWHb0wUIjfdO0jhXRzKZDKFUbrcc3inq2tjSYEoih6B1Eq5Sgb9C8MaHv5Qp51 +LMnR0eTYaP/WgS0DW3p7e7d2DyTHBgLx/nR4Y7ipa+7izNzFAY74Nr+i4AQb12UodJFIBXWCN2ud +SVrZPCB5PqbelUG3Ln8eG7IiFnKTX4/4Y6BVzaZX5sQdWQxxeapEUty+hI5loxYelT23RhAQtfnV +4tOxiqcEmk9V5Kcge2Wwqlgcmou16opX06x/ILYpYlPM9B4NQZ0H0SLw2Fjyu23X7SZSj/GgbFRK +IBsSoHa7SyYzAwMacgDynSVyyf2QthnaQfasD6Uz+Q0bekaGOUeXRS9QYLQeCk7OqOzAhV/TunXr ++vr6diDvC8xy//33V7l6+9vfXgVRyDFK+s///M90sl8g6WcUY+QVLfGM5Kcn7Eg2MD7N+vEdCDuY +E730fOW86yjvQLMmsrxwCfiv+IWXr5bk/MmRkZGOjo5JkyZ1dna2trZyJU4K6Tyt5ny2yGc+8xnM +0LPOOosMGKBcKcjPnkE7wnHHHXfUUUeROH/+/La2NiLMVthzzz35xdL7fsu5b5s5d8rSQzTo8sSD +Q1Nb6yO14bKGwSjJakkojwQBucDig1qXnzpp5u41cxex+UJg1QMjTGBtak/U1Mtcmr+4Ydq8OgxT +V3hmMZRW3LwV5XvgMW2LDmw+9h+n4Krd8GRq3RNjVWX6qnOnnfbmaQcsb4HCU6vGsMbcJYf2xHrT +wCoqr6JJSUGL2hTNwP5HtlLk3ls4fjzw5zsGctnSAUe0SUmaOt7/8NbjT59x+nmzm1pjvZvTheGO +J+5jvmzg0IOPn9FxaGfHNAaiHnv8ITBlLDWK0Ykbl82IogaikPUAggKfOHIzWRaIplnKMjQ4ODDY +D3j2bu3q2bx184ZNazbcuWno9slzkksOC8zbNxCtlwYH3jDECc45LJU/RheJqnUVjCyDSrWNllnQ +a4BkqFGhA1RVvndE9GJkVFnEKVuK7g3k9LSCmgCwkg0ggTdnALCHvtDRnKVAEdQ8hYgmRhl2csUu +YtgYE3MMx7gqLtus3sVRKXtNwl23s42OcmIJjjNGVdISRUE3fxWemeKPxXYg8N63X/zq489/zfHn +f/mS75N+829WnH/ex//hkHOOPfQtZ5z03vv//Ei1ahrOt2KgP/XlL/7ssP3fttesM4888B37LDh7 +zzlvOOHIf7nh2rtdZoDE4sWLb7rpJq/lL3/5C78Lwmc/+9kqWz/60Y/4ZU2fPp3fI/1RBkQYoTzn +nHOYo1DNs7MifCerpHAdVePbjdBpdm69l1zNg23t6VyfhpT8lpn7esQRR0yZMmXOnDlMsJg8eTJj +SdUJsU5kB7Pdeeedxx9/PKRQLAhn//33/8pXvlJlY3xkx3Pi0z7wwAPhCjnD/1e/+tXtjhNXie86 +ytUqJiK7VALjHW1/U0V8UXDX8OMk1NfXx+NxsBMUpFNG+nN/jbzi/fbbjwj2KFeHvdmzZ2OGMs/t +bW9724IFCy666CKM0SqXnofb22+/nS/ugw+tjGo+kLrpOP/Ya95z4gtTjD9S36woDT724OBdv+1d +/+QYiytJRGmOjLHXumfXlRM1shy8JmIKlOrvlZt4+pxatqpHeU2bXbNlc2agJztn97IanT6rFj0e +M4LoYuJlZcof34jc8IZHCqbu+UsNc/eua+mMPvVEcuum9B3Xb126vBWjlgxuCNbWx5IpRgkTU6d2 +DPVvqskfnR67moLXXXstLnQUFsNOuNFQ8iNDwxy8EqmLYHayn7nMT+2CTg1a4sJuuNoQl41xM1ny +jySHdR0YGxoGS58YGH4y3Ng3dY9A22RBGsBTYMUqOyVpqov4dWvSBeLACSTQQhSm26m0l8bQOHl0 +VUJP1VY4sysRipMNNCqDKI/BFTf18Lia/CnLx0ezZT7afhS8ICGQw5hBB6TKIGrfXyjh7C07aZE3 +Arcd+By3VK/tAggjMEAXJzkigrCEkKlFLeIZlHlKxII/Eqs8M1ZpSfn1kZ/mkM1Rlucqv6Oht6ev +a1MvuQcHhn9z3e0f+/fLqiXXP9X13rd/8uc3/PfkqW2qgOH8bO797/jMn+99pJqHCN3LRx9e1921 +1cdH+Rrg0almwPeDK4hb5itUEy+88EJfzVJNYXHw//7v/95yyy0rVqyYNm1aNf1vj7Bghp8/Iy+Q +uuqqq4jzK97uZEMyMKDg3D6tXr6f1fTxwMwQMINEuLjG56fDjRH8yCPbpLSD2T7xiU987nOfq2oS +1BQdiw996EMPPPAA40fjq9jxnB/4wAdYI1QtSysYe5o9e3Y15WmRXUf5aRVN3O46CUjL7ZTA8OfC +hQvxY8yYMYOOmNujdMe6urpIf47B0eeu/S1veQu/mX/913994oknmF7EHIpqfvQFPwBcMf/yL/+C +q+p7V338k9/el6cgyNAwntWySkQhsmlA+caO/frp19du6Upf8IW93nPxHqLGjj+2pMQzaUGliJiq +RUHb7JLGZg3w9G5Osdk9/lJAlNvGNrmPnbKKmNuQdDJggAokGCO0W+GNJ/KYIjxi3m95bWjwwKNk +kv70Gxv6ejIHHtWeHpWiLy8vKdTt1nLEfnPePWi+qylTp02e0knmN77xnK98/Vvve98HTzvtNXvt +tahQZB+K7ODQIBpfG7Myh4izb9I5VoGmUnhwh0eHhwcH+unX92zp6u7t6t7UtXlD99r1Dz229rcD +2bvaF/bNWRxo7FBbEDAICg4BDcxlhXOCYMLa6YChWwMSboVMyqIUsI1HDlEkSI58HHWAHMtgGe2R +YaojqzLzn2CZwTjBnEG4Nngy2x3KvBQ++sqa1UgKiCtHKGhtOA0VoamYULqQ2EStMtazoRYOKneD +lUcMnQoprW5xavOuVdyqgCbxKkbqK1F+oiz+IYFmqqUWqZKyjE+/iBQNq4QHVj72iY98laGQZcv3 +75yk7wCBTaN+ftVNfHPEeSnwu5v/VAXRf/+vt914xzd/e+fXvvbtC97x7tfOmj3FuAjwW2MOwUEH +HeQUZs+eDUAS3vzmN3sKV1w4DJEw7w/XDqD7rW99y3+S/GCZG1jNtlMi8MPUwiopzMR99tnnO9/5 +zo50pqulni3yrne9qwqiTKSgmX/4wx+uvPJK0sfP/N+RbAzcYrKjQ+iMfuMb3wB6MYKZh0HVmO/3 +3HNPlYcdz4lXoAqiBxxwAOb4HXfcgeRRUFVqVdgmZddRrlY3EXkRJLDT7FHUwUknncRMdzp0hxxy +CIMi9CKvv/56xz+evoDGPPzwww899BBTFV7/+tfj/6GLCk1IYbny7eRLz1QjKvJfQn9X5Opfd1HL +YB+IknEDVJWiwVGBZR0IeinOwCFLSx+6p5/nwwPMXOU0x9C03WrXPjb60IqBmqPame7qJaT9g6V9 +j2h9YMXAPbf0z15Y17sp07U+1doZmzmnDuysEC4rU9WIekOzYxLZ9kNENEQq9V/Og8sXuNIiGVbf +RwNLDmu58Sc9G1enlhzUEo/GMJ5qInU1EXzXPU8+WDrmkL1/v3Il0Dd9+oy9F+2N4/Y3N/z62mt/ +GU/EsN17erox+fFHxeOx3i09rW1tRbbHLQiC8uyJy/a4NC6XSadTOAZGRkfHRtKjQ6O9A6v6Bp8o +RHtbZmWbJwfqGwU/4DpWXRgNziFrMd3CobPNlbiJQs3VB6nyYcqPTeGRVUob/ZFZ28IMAkBbGQIE +sbygJW+zXPVyqAeWKULcMJLM4KgThyuegLgyi42goNrygpS8AspigxKBDQEzhrIdwuM16l24Bzik +1aI614V3ysWoQUftIi7otggNd+p69UrkXq0Q97oVcFr3SEyQZukyl7nRfwVP9LjfQkpCqyYFAps3 +9s6dP/Or3/7PltYmdr445tBztBEl4wJrNnk+mvnIQ2u8RGNT/atedwwrR+k6HH5Mx3EnHVpfFy2m +JIhEInHCCSf85Cc/8ZxYfvwSPV69gj3jf4NvfOMbf/7zn7vTFT9wNdvOijBhkE5bdcoupvB73/te +ABUPJ9bqC64F65ZJhV4cpzTUPI5CAFOrZHckG78Leude5Nxzz8XGJX7sscfScWeJAXGQlaUHRHY8 +J5mxvLkSWPh39dVXuxXOzK+5c+cC7f6oet11lKtVTEReHAmYdt8ZVdGnY4yBtdu4iT75yU/Syf38 +5z+/cuVKvqNMLuDpC6iEnx+kwFG+0HPmzOGb7TP9Xve61y1ZsoRhDOYoksLMBbrV737XhxPRljkL +67s2JG/8WXdVpbFOQDv/mVkDD4n60JEnTxkZzn/7M4+jJnebX8ck21t/1c0yzX0Pb5s2u/Z3v+j5 +0WXrZN8Yx+iyQjE4e/e61751xuhQ/isfefKnX9uAg/es983CLYzidpUns8xNHy9lelbYYAKmclaC +ljdxRcmi61luXyuoSI0EYuHYrPmaeXHIUZPy6bqWyD5zOt7U0bg/Ka2tHf/1nx/8+tcvnTJl6kUX +fz4SC++33wGf/dylGBNf/9plX7jks/fee3dPb8/g8HBqLNnT3cXewslUamgA27Ovf6B/YLi/n2lE +WxhB6+nu7dm8oWfNuodWbbxx8+gd8ckb5+6fnTpf2KMNfYxhcAuW0PXABpHyhgbexMo3hacOBsIn +iymlkipAIhjOERd4mI8aJPMAWRcsJdwYdYApI4chkBNUQRugBTkk3jIBWZmOrKoH1DfPgdC0AlRy +BsCSwTbE/dUgcPb/Yy8L55kM0Bem0lJDWbJhp2KCqyIwm1latskDET4KZHAzkTjIqouCHloGbqHJ +Rw/8mWXwiyeMT8YG/dI3Lmxpa6J4bV1i/oLdPCdud4pDEqE1t2gInzA8NPpv77lkw1OboUAnbGQs +PzTM0i7nzLM813U8iHq+Kp7hWX2uki/oGd9PNAA/2PEL3pj0wJyGp41iPi/yWG+en97zf/7nfz5b +2R3JRne/aiOefPLJVVI+usTtH//4R0/c8Zz43qpWLDpqvCubYalqFdVNM3Yd5WpdE5EXRwIvxEzc +Lmf8cjCPcK0ApQyLYjiCnaQ0NDQAde5EGl/wtttuq96OjwOKBH+0fPly7FGfpjT+Bzl79uxrr70W +lKUnTk5GT//xH/8Rl282sG5D8rtbtqSam+vS6cIHP7s3Q4SsJeXQxqNOmXbkKVPZPpepjstOmnzQ +cR3o00hMRsTYYDZRrwOrmT309gsXpNI5zt8MhUpHnTb5mNdOJh0XK/pqv2UtS49uGR3MxeJy9UrJ +msv3g5fsLmOOT4GJSB0HH9sBMqHcUdwY4WhVdLfPf4HVd120O6iADYr+y4wJXFHl2XRxZCg/b2H7 +vOkndDbt3dgwIwxgRu4m/7JlR1x88adHhkcmTZ4U4gxVVH6xuHz5Mf9w7AndPV1dmzb29vas/POf +8djWscYzGOrp2dzS3M5sXFbUYIYyBsbU3NRIZmxkpHdgzVDyiWSxt3Vydvr0QLRGBiW8wSEQIm59 +TBGPKLcocfbWYZMm63+gu4Ulhjdw5WCgq4GQo6ZSDTVJVvPGaXieQBB8gQjJXlwELZdwhxohbkJz +yCROxJprXRErTwpBiGyQBgWBqNXr/STosAEFAsYFAXn1BvD9GnJzmDkn3lhRcaBS1C5aMl4JMCBO +PN14K7fI6PPWdGuGKcPvomvMGDfltlYLib5Ibgti1Yl7Jnuy39JFnZ02DmoNaWgsz2Ilp96IGcen +vuaoH3z7auZWU+L2W+7ls/SQRWefe+qhR+ybzBZCxS3RsJ1at62qZ43R1/zhD3/IyB/qnhna3d30 +NXdtwMhjeuDHPvaxK664wp2ZzJnALONne+aZZ76AugEeLzVv3jzmMD4bhR3Jhp+sWvwLX/gCkO+3 +1VFkup6esuM5qwO6FGTmV5X+s0V2HeVnq3EifRdJYKfhKPzR5/UZRvgrGAsBi4BSAktI/xbuQeLt +FgdZQWt+mfxEHapD2Tm1odlNLY+AnuEwZijzVzm8xHQaqKnVhOVNGGAJCznMBoGhUn1TDLXFyhCQ +A80brwX9tAeAQBcliy1L9dgZpvjZPwGVjWUpnY6aRtebOkYLK49P00Wb23nacktWnISoeM9PxmAm +nEoWWHchTC00PnD7UF9v5u3//OFZk5ZFY0y6LYS0Ia/Yps5oLNbe0a45t7kcOApJ9igvZAqMQuGy +Zeyzvq6W0c+h4UYwgM02yZlJMTyaSSXTTM8dHhkcHFq/ZeixQGKgfVphameAxXuQxvYCOIX02MrW +D0BxywA1Py0AIz5BF391sGMp2j2/YrMiGbUdLs2lCR2AWW2kpNJE2WFJUE1xM09JRXQ8ktWodTjK +6paf0s249DxqvluKoidySN6JCzUrIOp5RNGrZFf9jIa4HZtJ5wmWqKYfG0vb8M/yqBy1GHQpAzFo +mw1KnNbx5aVjAW96xQRKWRuVEx7MciVRSGlykEz4b3SsgBWyzCL3tHTReHoo105yKdDe0XL5lRdd ++IFLfWsk0u5Z8Rc+i5bMv+Sy98dmBQZSpdbaeaFQ7OlU/vqe2TTMh/e5P3/9hOb8NU9Pe/y33YJ2 +X//618877zw6xywNd2JMenrta1+LZni+tFlN50VwcT1H2R3JxjhxlQITFavxaoRuOcv2+JXteM6q +gQuR54D5ahW7jnK1ionIiyOBnYmjcKxtF8JhNxN3RQP8Nz/+l0/cA9URaQgcOxLsjYQH05wVym1d +rK6+2D+ci3HCNtpQy9uDTDvKZUpsBgQSxLR1bgkjhuFAYijlYD7I3vRMWGVHJB2uSSKTikpB4BoQ +A2uVAiTbgFzRpuRoVogl6pEpWUxYgWjFbBJ9duLV5CTtqM7yztRwJB6e3FG7V33tvDXNt5999sEH +7HdQKJhjn0KAFPp7L15y1hvfNHv2HDoKsuaxdsWpFDZ3UOZO+y3EEo1NzZzTwm8e4vkCu+yzTj/M +9KuxUXb3e3JwdE2kZrRxRr5zeoCtjjjNmx2RmIULJYgAYNqY2DYEhmfqpYF8AA/i8CxwsqbRQPLr +lo8pXiEHj9y7K96UkyBoIQ8pBADJgIeo4Io4MRVTNj13+qTxiBdktaioFr/qBXk2FwB5gHUn4unE +yUzvxzNwA146L7IgyUwKliiOa4NGqvaegdpi+cSPobVy20gqpHwiEgnKZoGKiPPIWw2yEojbH/WH +lG78k6Zkw2Z7bKK2WcFlHjzVrmqFExmfWJGk2hUIzJs386qrv3DzDXf+6Ae/fuShJz3jXx5Yde4b +Pnb1TV+MJjbjl2+t3XMcgadHGadkgyFS+W0yAwgbkTVpDItUxy+fXmBn3zPj5tZbb2Vli08hxhR+ +8sknWSz+fOthXrHbcJjUz1F2R7LNmjWrSoEVAds1H3GnkWfHc47vGQwPD1fpP1tk11F+thon0neR +BHYyju4iLp+bbBlIUXWBQDw8qTV7eiZ2TVPNyOrNqXwxiP6kkemcVJb2JdARJzKG0JVs2J4incPU +GoPRSIlhQrydbLrLIv1IJIibGLWr8TyAARLsgJMW8JQDipLNBbGobL976sa2AxUgTn6IG325GalL +EMXGOpFIJhWPBFtKmVmzWuc01u0Wi9RA8PQzzjT4RcXbjBqqKgQW7bVk0Z6LMKg5sVlHZbGnPE0R +ZghHVAWpHLAa5EzyeqCVIVGO0kols/lsIRLLbx16cii1OZwYa98t0NIZiNVqrpOWtNJqqNggKBwK +RzF5Mc0ZPqQ5HMpmIArPfwUwpu2rOp82SqyAB7gLfhiYkV9voIoKlg4MyDHsieJbH0cyaldxAy1e +gRN0MYqUSZlmiiaNddS3DoSEACuk8zKhzu7BjrhGnHQV4SG2te9FjE8UblVMhbwI9TpGwkPZZ2AZ +aL4H0pWbq5e1JqgswVJ4CH2xbU4Lj/NQlZMoKW8L1KXGWhHLse2RuFWZvwokQNbqVDobO55wyrIT +Tl1294qHPvPxy9evE4p0bdpy+60PHn3cgcn0QKG4ssgX0cL4Oe2eUsVLVnR85CMf8UQsLY9Uh+v8 +dhddmXfDrik/+MEPnP52YYbxIIcu8owf66mytPvuuzuOAsPMY2KJXfXR+MiOZGMRQbUIXdXly5dX +b58W2fGc4ycMr1q1ajwduB1/6/FdR/mZdU2k7FIJ8NN+ZQfByrjAbW1kanTk1cXM3M6W6Eh6ZGA0 +nckVE4kSfl303j4LOzpaa9lQF23ORNwoiXmm7KKxFXToGHuCaxMZnaQmONQ+5iVS0PUoWbNoBZ88 +jdfpg/G6DQ/w4prVK03K+CL4xFZDw4GBDfHe1Y1bVs1oC548o/GfZraf0tGyNxsPcVIbypXi2n5c +lry2UoBLVrPy4X8ug++WVZ94aNNsgjvGbgujYyxjwZ3LbgrDwwNssECNbEM/xuyikQ2Do6vW9f5h +VdfvRgOrOueM7b5/YNp8OZmxnoEigiwq/RFwgiuMjxKIy9iyiUU0kzZq7i6dEsYa7QvCU2l2Q03y +C04MQixVFMovAdJWCznLAGNi1S1g4y/KbD4vQh4KkqyrP6U7YraysNOsfM8J1IkTmzQEM3w8rqeW +UxzyqeAcmXl38grQy8Glb50DmkZlqstRDSH4uhdDLGxKHBVkgBQMY7szrM8bx72vMVf/oVSRzSQp +M1QcqDNRZsBa4e1SwypBgoHtcSkqZ3VtS6vGjMOqQJyGmlwKHHjw3v/2H+dVqAaYU8Zbo1wmm4zW +lpeEMTo4HqX4RTDJwIuMdzYyf9sTn4m7VfovLMKwznYLVoce8a8sWrTI84zf28h3XyGd2YWs5Hkm +Ed+JhXQc1OR5ZgZP2ZFsTKCdPXu252dKVJW3Z9Lc8ZzMheQ37BRYisOhHR5/8MEHWbNXpVxVWbuO +crWuiciLIwFXDy9OXTuzlup3sUp0fEo83BZLnRgfeVVjcWki1BENx4Co2hpQLruua2i3zobGRFTn +d8YCNQ2B2ho2OmBZIQoe3S2rFD2IgkR7xmuC/C4aG4IJVqBmgwyLot1Qmpy4jI5mihCKW+rbNDvg +ms5p6BSdC2YnOLglPym7dc7ohoX9T81Z82BL97rWUHFKTV19OJELR3No4SijtOhykAmVyv7xAk+0 +UI6lK4Ana1ZYuYKu9ONAWbwylmRL+eGREfYjIvSzk1xytMA0pVA8GWnsK8Y35SKbIg2DU+dn91ga +mL4gwO72ABKooCCVb5htJhd2tjoK7HtnJh0gB4BpzJIAMmFAG/xYIUvkYopeKeCfXd6a5t4AACAA +SURBVCUoS0QCRPwRVyVTr1WnPBb4i2TgxSHHuRJaGNaS2zNy9h04rWSjQAa50I040Oiihh5xCtIE +gudUxN6OVFlI2+eyy5tTpVtAfjjxD9R5TfK0Qxk6BB5VpUTdvA6K2GvVIlqrl1zwL4b5VHsA3AU1 +9Zo+E4/0Hill/QyjaxfvJVhBFa8E5TfsVxEi1XSTHk9p7CWf+p8vfvZ7D6x8PJlMc8sODLfcdFcl +I87/Bd4uis+ew3JSBSYNfPSjH2WszmcSYW4ykd4f4ctlCSlTjVjRyLClJ2LhsXTS4zvlygESuEnx +JDN1nwlNfJ99DWV1Gu3RRx9dhU+wpFopa04YOmV+PqtHWMpVTa/+tNk6lIn6ns4SWDYdZPsFOg2s +6qFpLFH1RzuSjckc1WUzMMkGL0zCoguCx5hVBv/zP//DWjvf3WLHc2LiM8vSeWDsEzi/+OKLzznn +nGOOOWa7Rv+uo1wV3UTkxZFAxY314tT2otYSjId3C+en1ZcK6UJfvtifDww1hQbSQ2MPj6SDwXg0 +mGHabBI0DbPqAJ9tCY0ZZ9M49FchiJLFDHVcyeL/rMNAYQKPDDUWZzbEObazkBzVudxofxQ34Mqn +huPCC3Vt8RmBwuT0WH16KBFOB2KFsZroQE1td74wkkoPhUMdqEgdfxUI5ws5rVzAayulCaJhPUlN +sxcEO8kjLSKyOLVHEZsTodDBWAoV2IKiUMgxi2h4ZNPQ2Opioq+xVqeytE4KtE9Tc3BKY2uWvZQ2 +sEd90tQ27ihzE4bBGwwpeXl1C/aQQpNBMul8QwVHQZg1Nu0ccvU3dCvc4Y8pffQ4dQEzgjd7TApl +6U8wIksdEIQ4KUT0iFvDJNVicaNUxhV5lQ1FlJniJmR4JpHyXMis/HawtpOlXl4cdie18+54lZIf +xDX3yTKLUwVq575aOyzBucMzVydONhUPaltmzT6rzqjy2p1Xoxbj7He4pSC1VyY821fIHtsFmpqT +RSmqhoI4Kj9Qj8EgWU+r6c4kYBwM9Pb03/rbP/34B7+mQFNzA6tfqqBy3jtPnzFziguKJpz4qiO+ +9dVfkIGcIAqB3Q988QYbMqDQScfZWF1ayloyX6QBzjFUyVJvFqUYWzvhwnbZzGwiQAsIqfLMLXuz +wFu1juXLl2PGrVmzhhR2l/3yl79MhHWcp5122nve8x7PVgUhrD0m1p5xxhkO/CAfoUqKuUvnnXce +tzuYDexknSuYTc+DqbagcpWUR1xoxHc8J1sXsRG/LyViXpWfOcqsKDZ88CWqUKs2Z5dS9iZMXF8c +CUgZvhLD+O/i/4//UCzcVhua3xjiCO9jO6Ov6gidUV84pqmxNRxDzZZQ9ENJTdBlBDGd1YIJfKvo +NeCEM01R32RgXhKzhNBsePlqE9FcNhIN17U1NHfUdTTHJrdGF0yKHzY5ftKk2BnT699cVzytKXpY +e+uihuam2oZIfUO8voEN5OsBQCbWYviwCy7IybpWZjUz+KlzwTFGMT7Zuy/DhjbsnoAvOjNqWxGN +DY+OAJdDI0MDzLwdHukf6+8f3LJ17dpNd67e/JvNgytGCr3xmsKkmYE5iwKTZgnUAVE0u8wyC1Lc +pvrR2gQ5OdlFz7yA6iiYqQdSyveLFECiqHmk7WRyQ0uVdiIiY1iifNw42QoykQaEKBmMdAOLG2o3 +ZIWCYKNcSBFuHVONqqUYAyTCCRSEeSCZwzMFDYZ5TaRQBcWx6SnGO6Je2sstTgIsUYrTxjKH/h03 +VqFJQXUaeN3se8ypeQ7nxiaJwrPxH5iEOGw738aM2PBb7xbYUxKxX50ClFV7JfBIeAxZW1NEUQ8Q +gU+ZxbY9oWha8IbTIurde589Fu+zsLlFm+wMDY44IM3YbfLHPnX+u97/elilFFKiSFt705e/+eH5 +C3crUzE48fgFF1zAoQ7VnwzTcNgGiAFIVot5BoCk6uatFn/BESbPj59jXwVRbFAOJaXe8eOarATF +BVpdXsmaS/aIwKlL+nYZwNLF/QvmMeA6PgONYli0mrKD2T784Q9jK3Os2/jq2MiQKVGvec1rxlex +gzkxr9lfiY0XnBMQnU1pOGaj6hKocliN7DrK1SomIrtaAkFmw59zzjm7upqdRZ/fJEHwg5mGZYZR +JufntsDACekk8ohA3PM/jYHRZN9o4a4F8w/IFwaT6a1JtnDPZHDw4krNl7JMzpXSK+IYTOdSOE7D +HZ0dsWBDKRANheoS0bpgsCZQaAgUGxRhvUwwGgon0GmYkcEwQCyDKxKOjo4Ns7ITXBweHOzr7+vt +6e7o6Fy2bHl9Q0NB0Cn+OJsENYs2zBc5eZJlnzwwA1SNy+c5u0T7SNDOUibDzkTDI8n1w5mNucIY +4M76znhNoKFN++IyUos9qxlAZn0Kfsz+oyFoZJQ4nQMZ2Tk5IdHY4I22SyTGtsAxqXIiICgYTBEw +CbiFGv7P3OrXvvbNewnYLN3Bz5GMqytxfyScKA88qy6wBJQCsMnmGl8DinKeCyFIpBRC9gDYyOJk +rDemp1TncEV+qgDMoKaIbVrkRYSdhl6ke2MZmKM3AF35283yw33tpChCuxT0ag3aiYsDpVCXVgPb +I2RFXZCScHhu1jPyhBMZlGUqekSlHLpONqpwOZDHuybwRmaR1/9yKUShd8ETUijuc5LNllXV8OB5 +iVCdcSX0tVvGxbUJQ7E4bWZnR2ezJp2ZVKtNkLSRRr7Ut2UoM9Q6uXMm4ITnUDVZYP0oFhK20axZ +s8pJgQAuTfy6aP/nUPTVzM8rgk2GX5SFWLiXcdJihrLok3Vx2yXCFxxbGSzHhq4OMW435/hEfLBM +OMKbikULeI9/ND6+I9lgAE84Zi58EjRD/lnCDuZE2giWYeDxXYpnIVlO3nWUn7veiadsGURH82+R +w7af2d9C5aUtS0fbA2wQqV49Ao4+k71VG+4dHt0yb8qS+XMXmQU4liuNlvLhfCmZz2c4nBM3KstP ++jLdT/VtHB5Izmrdf/KkyUksHbMSpNxwCrudAfUQ04I5E5KzV8Mh5gvpGRqxEA43Y1JSfaKmtiaR +TNTEwdPerT01dTUApkCUybXYoxin8tsyrajAsaCYqIawDJbyIEhvIZUeTGZ6c4XeVG5LMpdCgbZ3 +ChdrmzkJXDNiiBOAEIGo6VNvtGtz8ms1CzjPnBTmENk27gIeWmEqHtcit2zsr0U7gKU5KrmVLjF9 +UkY7MpssveGVO1VNKccGN4JBOyEBidCEApDpJp1NaHIicAidsg1nFif4qklGBpaCxgoFYacZx6RA +PxGPpPWCthXnKY+EoKCvmct0CIBeSAkFDZ/gRnGYgS1YN0HpbRIhxZIhQh6GiuEWgVBXlhFxHlWE +oKIGpaJpdGRNWg8DImSDwv9j7z0AJSuq/P/O4eU8eXgzw6AESaIgCCIgKhgwYUYFXddds7hrXlfF +1V0TroqKaXEXdcEcSCIqIooikmFkhplh8svv9esc/p/vOd2XnnlvEOHBf+HXNT331a1bderUqe7z +rXMqXBijafV6SbQmk5cPEKvMViMN9zcpSG6AK73m0jX4dyIk1XGUKYNk+wEHrtWsttmgFKIJ4sHs +af5CRE9j4cHFPd2rBxZ177kThiN2jz76aDW1KbABhtCUsGBRLEvCvPtJ5tYBdjYvXp2bYd4UsP/+ +wP/9yQYDDCYI81bUnHg/cyJtLNHmgn81/tBR/qtVtzI8SAk8InHUwdJbXodQaRTUSj3ct1A4X3Z0 +cl02V/rDTRctWbI8muB0hnysGqvEarFygu2lsbDUOxT7+9NT04V8duvY+LYVKxe3heNMTUKcN8BE +qQpdGwRUfFjvWLbdKdK7bKphn2hXZ0+xMJqIxxKJJKpwZGbXtm1bh4YWk0EHybMSuMROlZLeD4qO +VbC1uloxW86XMrn8SK6wc7Y4WtMm1ooWRnWHuntDfQOhOFtZcEuqIi05lt7HSWvuXMGE2Wq0QkuL +TUHL4qRRbnU5ugAzpvoD7S+zjzXG1AQFXKwRTRjTYMBGZdHg+qu6qFhQ7SaXPXI0cvzmKZkRIleB +kxdzOoY3EIdzEXD7EuwxCxXiIA3gpLqcuBnTDkuwkUgge5WiMMWJ0yKKMCHqQXW57WjNpqDyWWX8 +hWHFCSAoJ1Ewu2nbYyAIEUTEQ6r2MQEpZGMBkSRsdBhw8JTAFdQU2unroDZySx5SyCwi5g8QM3bL +X1AZufGRMBGLNdMFCwXnn6VtcIjcyA9NN+VVtdVLWV76Bh0nLoL61mnSmjithpqc3lQRzvPNCvvw +Sgy2QksCLQk8hBJ4hOEo4BXYl46ZyIaIXz2lOT1ICUqRc/v4zatXd2zcNHvXppv/cMMlRx91aiKO +czWM+VeN8cK1Elal6f4w2Ld8+TLOeOd9KaVSPs0bSsuSGKN+lBjqDtORWwIaEy7YdQod6U7upJTD +3d29k8yJznKoH2cmxDlnfPs9W5cvW97e0cluFly5hp1FuakxUApgKuqdedLxbHHbVHZXkRMEoti1 +obaOUKIj1NET6uzmiGCrEYXLPld2bsiPLA2OAhVMmmUjoIJTm24kkQb5RC+Z2aijYIw7r2hq+Jde +RgWzlhVUNguPPBQkCAYQiaLS1wrcUMr1uz1Cp6PHvV6xJOmYmaXOkZGnugxZkRlPyUOlKuUmvsEe +jwRmVoQWUYYMVCVS1ielcjXP+mRDC8iSqKv1nWJyyeIVqDHaEXGao1SBtDrDyHKhdg8AVRAAJ4Jl +0dUb64lKJ8mfWQGIQ5NEbwIVwQkHfVCMRGV0CdRFplsGNArWZF0TmmsX7tqbf/i2SPL2gp16cfN+ +U4to2KCBv/LGx+WBcCeE2DMQpXZER0GOiY7HkwPtB7dAVNJuhZYEHhYJPMJwtFkmAUaSyHwGgZTg +SgTsJIWnXAMcZaddunO0kI9jw8Vjxat///3Fi1asWXVIoTgrEqhhABJLJMKpQNKsAwODnBZ0z6bN +Y6MTa/YdiAB0duQhC26hWYlootO1LhaIYQz6XrjEuUSstI3FY0Dm1NQEKpe9oYlkcmpmfPOmTStX +7lPU3KhQuwjJMut/c9nSzmx+B2/rrlSzlVARIGT6jTNVOvqEoMxrOmwwx6kI+hoAga7ab6hGmlhW +8HkxWMPDqczod8ssw8VgDDsMaBRuMbdnLkfHToBQEQlNwEAGAhS4ReNLnKQYZHJVbcYG6p6nQkTw +2BIFmVTL1SwwoY5HgAQDG7FtOERB6JPoxhzJEij5rS089aD8Zq0mYiZ7nkfikXChzGmJ4Qj7g/GI +a4GVOt3KGpATF9TZQcHwA03BM0E34rYe9WywboJSqjHJ3zoD0CS/lXWagagBfshAz2la0UZ3QBb+ +KevcSyJ1MWI4en54S9kcAVnoC23IoUf4NBiwQhKIGgJg25ZWMBgGGE/4VRyEbHVYNNbfdgh+EN23 +QksCLQk8LBJ4ROIoipPg8vF4M3wGcQDPn5KTiENptji24e5dHG9bLofxpuYKs7++5n870ou6e7pB +RkxKNpNiPDJdCSyzzySejC9ZvIRVA9t2bBteszoa43BboQr1S7VCVgaTK3tpPFmoumcBLltTWDHE +/tQ2NB76FCuWZb6sfNq48e72tq5kqq1Y4L2hM7O5HcXKaK4wUQ7Ngqd4VrV1tS3U3RVK92gTi456 +oA0ODLRFNVqK2Vs8kv1nqCblbjBJIjAsu816mM2yMCyL01breHHQS8xyA9rZ6kg0uByDtspGvl1o +ChVVnSAHCAQYjBMeqbVWNZEA7ZSf5jfQiAzCaegLmQ2HzLQSe9zCqiMTnBhOKNEiVAJ7xCVnAzkB +ku1sQT46gqm2NB7pKFbHwokxVp6xFIvnjvfEKChsNokxYqAiiYhbM9ApD02kQXtFX02UHHwMQS2w +DcNYftDhQ1AeM9nJD33xr2QVp8mqyBnmkX0bxIn1CE5XspLN+acW0kXEBwpWO2UJDGsSaV6CJj5x +CeRnhank50NmKsAG5VvB0ArGnIh7GtQujnTGDxGJdCUPiEf6bDDhDBrp1qUlgZYEHkoJPPJwVNBl +hqZAzAzQADibI8QJjp0shPM4t7Fktre/MpuR4mO2ifm/jVvXX/KL85969BksuAjHOB5Bo3wWC3Hu +HkoP12jfAOsNF2/dsnHXzu3LVqxkWS1ZnDJri1BX2J78V6CrUOpSfbKKAFU8tejVeCJZ1MpiFplE +8P1OZ7Zt2hLt6e0uFMenZndUQ9lEe6UIhidC3W2htPlvWX/rNgda0k/Dd/sP1elql6pUtxSseV/J +ZnakcN1WkHKUEgoXFAEtBK5mrzi6oLKDhZwUl8YHyWwJTDSp4m4PMTVYt2sxUgFCPjSMimwNDhEw +huICOP436FC2jhw8civKII10jCoRaeAuTRO8mSeZnCYxI0UHGLLKjDMQIpvoC+M5gbgnGRlyv2Ui +0l8NtZejW3DJs8yLWWvxYkxqiKCxi7UFng29oEbraBTIJCRrCJC/ZJCUbL5WnJABwfrpCgalMABk +igeyUYXxI7LWOhUnyS5GVdS8nNeiZxTxcUZDXKSof1W90TEblH5nK7A2AefC1VJsapKdUTW+q+l2 +fWN1uBJEYKNRIx2neDjUm35sW1xT7/5N5NehKluhJYGWBB5iCTzycDQQiKsJYWkDTVnlD2SiRLR5 +pFZjuzfL+t/4xjeSztEqBA4WWbFftLMv1F8KjY/otL9CCdumtmHLLfmrPvOEQ567etVBrAZixop3 +qmzctGH9+nUHHPC4FStXLF6yeGx0593rNwwNLcH5Kx3ZCCw5qvGicBSr9oGabSDTCPRiOS5LiLSj +BqVXzJfZF5ovjtSSI4m24njujoz0tHQowIl+7BkMwRgKFNWPWoQEMIBmJi51SE5UpSlGLkrnlv8E +V8pSpJYBXWxGD2zqiUEduQXGDc3rsOdlA7LcChIAUauX9IQt3FU2gxCuMsUMdHnqWCI+3apzJDCM +4SkBUqh4pyksF/JYW8yZTAaa5nmI0zQRNCAhUx2YsRpZSsNQgKW8Mo4TieqSWGS39/9wclSsurIa +3lyLs/3JXbt1+KTCOh2DOrHEf3VNnRniSCnOujL1ndVubXQ5+SiBMvCpHmmwTSlJ0gAe+mSDCE1G +OMJ7M3zpAmx3BapERpZfBZ0HCFobeehFaD75qYKMBNpLSntHKJ1iwj6SzVX4krA9CVGAxFRHvcjK +I7yDga9Hd2rfdGwpZfkOMmo0Mq1LSwItCTwcElhgHOVISQ4e45fMFmbeQAKAcRQIy9/nNuX444/n +FC4O9Go+3Hlutr2lBPAJXrJenBqbr9RLOmeGsYONd33ziJ1h1113HbvTVtR4kWeoe6DW1ReeGAll +Z7QqEtNkbGbblb//6l2b9z9k/5OXLT0QRXTVz6/46te+9K53vw8Q7enpZpva5o2b7tm8ae3ax4CN +0vsGYG512Gny2tAKw3IzlsDPYoHdp7ns9NRMJjNTqoxO5O4oRjPU7v5VDI4Ufry2UHuvtoFKF4O3 +YLSpbBjQQiE0rxkfgkYDIUcC0MU1Ln/x6AZQim4lUJY0dL38lkZEWhsVzNXLG5ZIgzcZqU6fFIiL +vJlibPxQipWVhxZzzY5uoKE0X6gAkFgRAIM4NVI7QZkdF90tKbEonWw8IgiKYKOxIIinkqeBMXmg +DD9QAD5JxwiLhfoStUW7rZEWAQUcosnwPpHEFo4TSCUjdryi0mEb5qhWdTWYkVvYlsJyFRrRfxiz +xjy1KrPyWiCx4X3V0MjYE1l6pAk14ZOg1pGfmWYWUfvsplJFjkfUYpms1zx/oxaeKsEaK5Hwny83 +jgv5fmu7Rgp8pVhlJktUMw4N3pSrXjCZjCTCw22xFRrFQaDhhhFVZ45YK7Qk0JLAQyaBhcRRXorE +ic+cN3bMMcdwPghHIoCpn/nMZ3hVU/NbuB98W3gVMGd1cozn8PAwusPtUcdRR1BAlOBKhBQ0C4F6 +SWlPLI5UE6FcIR4Pd/fWuvtrvFdrajzMwfRXX7ru4rv/cOpLbjrikCPX7HPMKac+54QTT+nrG+BV +a2wK7R9cvG3r9vV3bliyeCX+UtOZ2KHSXIAo1qfgk0W3nKjAltByjReJT09PjY6u3zVxRzU8ORue +rCXzvNuUWS7eKsO+zy4bXQCT2BlcQRe0LmzqargllQrP/jHlSwpmpYIZqeT0ABfgpSMTGh91iuuS +a52g8Spt7iobgkYf8ABpQG7QEYJY51yxQeEEmGRTDRYSU3QeoMZHYE97G3EqELLKq23VUaPxRHFY +oi0wq0otQilFbLrUK1Ups/b0yM07IwiEIGEtG2ZgobFFIllbGg3Nv4Xf2dOMaXV5W3or7zCHJtRo +mjoHQdnxgbBKhBbROkd6Cc3A0Xl29iTmRinxhqxonfucjUM9N8FqKENuk6oETVUcmMwSXIo7wgUC +F9E6puqvhGJlLZk6YBUxugnLU16ai6BynA/Mm2psWpRhBHmQswRoxelfyVDbnKLx2pp0bLEPJf2b +D2G+6sQ94vW0ri0JtCTwEElgwXCUn/GPfvQjfr1Ebr/9ds4A43QSfuQE0jlb0pFs3macccYZ69ev +P//88znukiNXTjvttI/YcaBk/v73v88hYZwE1tXVddZZZ+Gk/cpXvnLZZZcB0q94xSs4LJRTtS6/ +/HKO2aRS3nsKimOA+gtQAxxly4nXzjWdGNzwh9qvLr9r55Y8ySvXdj7pxKXJdOyOG0e2bZrCH3zV +T25dd8vWI465fuuG3C1/2vril77oqcc/g9d8rl93+ze/+bUtWzanP5065pgTX//6N3exECgUee97 +3rHlnk3ved9HzvvCpzdtuvuYY45/7vOfPTG5aXJqy3hmy/TsmI6kRxdHQ4uWy4ULPmFYgKYEdDqA +gSaVXnVj1HSsFDHuOxL5bwYfNx5XTgdR9KnpfD1Cq1IEJQuAmTHEQwAVbYu6B5CABBQ0iardjUsM +SqlZ1Yc6Bp55ivHHH3ZfMMkKNYzRYGcIxR2ZBITwQLkAO6P17Y80gQ8gaptsnbbRpy6zQQXY1lJq +dPQS1rrNZ5xwIYVH8NyWZoYXK7onEVoELKrkfQaD0mXFyKZqNU+raZ1/YBX5SzJGHE4Y7cAngYr4 +6NZFza2l+yO102xW3VoGhIBYdFUBUeDKrXi2PJjXjnPK722p54IJxTRDTGiUJSKpWpoLhJRCQftb +6AVMW+ZKMaDhXyBqIwMYoDo+FItHY6nQvolwHz86vtt+9RFkEFdt3lqrpXVpSaAlgQWXwILhKKto +cJwuX74cdy4IyjFdvKYEtMMcxHnLyxM4tXJv3ON9BUd5S8MJJ5zAQWIgJUdOH3744by0jxdTHHDA +ARxQyelijo7HH3/8hRdeCGpilfLyB9QHry3EAsbqvfLKKznGGkcxb11Ad7j6gAFCgKNEEpVFaw/c +fPyzl911y9TVP9vR0588/JhFq/fvvOuW5Piu/KHHDPX0p6Pp0uj4yOjIxB9v/lkxfsvUeOmib/yx +rT1x6DFLZyZLl1zywzvuvPEjH/0gum/zPeu3btn2gQ+8be1+y8OR8s9+9oNQx12dvNnF1Ct4CZhp +62eXVDBKU55PIBN447QB1vvYO7nQpL7gFhE5fKJ1pV65QWmi0Al2dTWKYiQ/GlxPDb2IO8L568m4 +ZdrMdbSykdEW61KvjFGzF7V/hmW6BplsRQV7gFgO5adeDlmDT7S5a3zUPjRUBfjXQBHijo6OmlAG +QZXTXb5+C59WSumGnWQjUIVz5eCh5hiT8EAKt8AG21ritUW8FEAF7l8ASjviKyu19aVihfGE16Iq +fIwCTBKlvdRuCErEkuxqVdQRp/FUTJn9qnSjo6tF4R/xcusN8YJqhWcwxDWSBrpkw3BnuGNvdDcO +LN3ERTYZ+gaNbBjGB0Ccpbm+TExdZh/6AC40JrAqopFEsromGukEMr0irnzn/ZbveeCSCZ62Ii0J +tCTwUEhgwXAUx+bMzAwLW3nHIU5dTECQlYUfQOltt93G0/vAUW8YJ/0ed9xxnGFNBAMUHIUgGMkb +iAiYnpi25Fy7di1nbhHhdOnh4WEWFgG66A4/YxccBc4xfx1EyebMeFmuYOrTn3rGdDS5a3I9b00B +R7dsmHnCUxct2SfV3hkb3xXaZ7/Orh7cc/LREdjYXozM/vH3m9FK+x7cu//hPQDMtk3jd2/Y+M2L +P96/uHs2N0G2A47sWrayNlNon/xDZmTn2MCyQZQdPlLO7CWSxCVp6lt2ElEA1bWhKURMT1YDaR0N +/j2mD7FpOM/IXr0i7W3QRUbX5HWXL0Sw/CxR6Q3TkKc6f8cgXJYuB+WUtGiFWmkIRaBM7VDTUbQV +XnuuxDxH8Nu5u5iwKHEaDs08b7Op6AXgfp6RnzHkul4gZNxQESlwCE3BpxtbhgoOVDDgia76le1e +nW+QKdVfT4QkT5EMs53xcG+iNqRtSH9rqCU6YvtMlDdGoqrJXbLEHO3ElQmNP1RHpzg42U39kWeA +VZombk22wjh7EBTHZMedIBo2YoCCBjTc859II7MXJw2JSUQQ1E0DGokiPTNVMUAZuHBLx2k+mMXS +TOWaIx1iTlZ/8b0zzxBOhovD4UgbX0u+/HzbiXicL7nHlbnl3UUKrdCSwEMsgb9dT+2FIX7M2KCg +IIHTqEFNsBMUdNvUx8h7KVpPBjiJtXHugHSWVMeqVat4qxHvHnrd617Hodsf/vCHWbVUz21/UBOM +u3/5y18Cn6wq8rOqSXRHLhFyESc4jpIZHP3Tn/70ve/fzAnXsbgyEDCV0XGuzuQL1RxhjQgBjcaW +vmxGJ98sXpFGy7MmaNGy9PREgZevDKxE1Ulfr1zdBoClO2Vtof5YQESqFt+aeoUIoAUo4KbDv+cY +I2PR1uBIr6JM7Zb8bGCFAilAFwG9qQyNjyt03VKBYZgbplrRartcUO484iF4D3rVzV+g0cxWqAGW +5AE48fGi1vGgahLUwNUPoqNS9gVRu1Y/mYSIA0hwSLCeEUtQ1h9gnlRqNBAV/GYP6AAAIABJREFU +bpkpDX2hpkoog4OlyvIxtokIqMyERRTEbZjE7GAiFV4aC88/G+p9alT3vPh3htRwLcEUeCSeh0FE +IfaMN/pXMGY8iQtrmphxrkzUHgcjCZKwrYklTkHPr0JWkJw0UMQh5YhrEq6nmBCgUBc7jyyn6NcJ +1GlSFrFrPRfT1XQ90+fMhhqKy0i1Od0IpeyLRHFoxlLVUKGXhcoBXu4BpYExSob7kJhx1Lq0JNCS +wIOVgCmMB0tE5fnpctI05xWsWLFi8eLFrG5lOyZvTuBlC6Tz9IFVcuaZZ+IWPvvss3l5Au+Ux+gM +6GCJEsfq5SVKGzZs+PWvf828KSmOo2CnaxCAE5PUGQBN0Ti8C3D7ttFzv/yG9316f8sf6ums4V/1 +wLINeWKZlzLYQLmDT109Mu6mJ/LafpAMTYxp+U3fUBzQ95ah/jT1aERQf+0codCmBUS8SRvzjjyi +ZjN2jtOOeahmB28UKJoauBI4WUCTEoAleWvNKygkMzUKCpIITVSzrqha0BlSYBtrj82cVWFT69jE +7NynIog4blGciqiXKrCBqBfeYJWATxhgwyoqzFpxDmrPKZ08lEWJC4DxCRv8OyQIbMgAn25JG4cO +4UoxC4w8ZOCqzGaWQQeeDVNkQCNkWsGjVKyvPbpmDxClH4OgyvYSyAPJXGF6ZHLT1GSe5WNqoxnl +SIlBAK2QTAz8uBJ35uGDW+BfLbI4EWW2CWaoKu7s0rrgwzSwtYuy6k0rrq/k7jlh1jtIkcZYQdVZ +fyGHXFYveiPgMKCn6Ah9Q2wZEXmUUw/rXzNSGNUxrx+u1kGU77OjKZEgbiVgVcHjrWtLAi0JPHQS +eIDwNpch4ArXK0Yeu1mwKdn3glXKu/3Av1NPPZWnc4v81ZRbb73129/+Nu+7Z3qVzTOZTMax0y3X +7373u2wPtYWyNZCSnS1f+MIXoOmJ1GiKdTe/LmjqiTyd3Lbiyu+Kq8wUB93W0ObLhmUKr7txolQu +4Vp0HJWWjIUOfEIfj+788/jkWHb9rRPjO3M9/Ynlq9qx2DxIAwKl5qBDZceJm3XoICFk7eRFJcog +XDRLjnebSL+b4iUCBqOOATxADp8qBgpxeHBNKksFPAYVzMAiUaCA39MWDQlNwQkDOcc86WIYID8E +HfwoQDAs5C+1o/RlBJvNRITVoWUND8w2wuxOhICiWQCVYFANLio4kFDK4kJQWmSvkQmUtmg2bDUr +Y+WsOHnA7zpO2AlBsMo4h1OfOmOrU5Gleywp8v5yIsTvI+SLMyPTGyYym0uVHHKmORoE2EhFJrLD +kfFAFIlF+S7Y158rHYT8kSecC1zJZjlpF6RIV6u58N/iJn0lQgeBa1ziPQUFk48zrO6zeutXq8i/ +VyAoHOoFQubI5YuED6P+HYArA1pK8R2APf9eQYmvEAdq1cqct5Vohskg7pHg1tnY49YTW9eWBFoS +WCgJLBiOYv/xfiIW+HDcwTnnnMMGGF7qdsMNN7zmNa/hlYc8fQAcj4yMQOqoo45iFS6vGMR5655b +auFNueeee+7f/d3fsTCYFUbk5L27mJtHHHEELzI877zzAhwlQu2BPQq6v+xlL+PliO9+97tT0eVr +H7Ns17bCz7+7nRm5I47rX7Ky7TeX7PzRNzaiv9DvBBiPpWqrHtN58ukrspnyhZ+969Lv3LN4Rdvz +zhpOtdtpRqYoceECpdLXpmnRlSpoqhnYkFlm6hWkRGNiWaJD9YZLM/VQxKAmKpsiUqaIyroFIvBA +EWxKN1NYB0SiFLFlQGVjn3Pmn1uxGMRkxvyFAvodBY15mrd1KxipqGOqoKJS3tAah6ptAjF8COVm +hDpANaSgSfMhS1lrkGGDAYzbkVzJRu0yoM3idDtMaGGw7ZCj4UIj1DGY5+SxBU0ORYgoFmtLhpen +Q6ujYY1jguCQ6bfN8eYMHq9Ui5PZzVO5jZVqTsBp4w+kREtplAYZ1ilE6tT4I4sTNtUK4SiPLFLP +ygOz4GlmgTlLrEwzx5XZulslDXTpO+TMFd844iUDHwK0ycmnnmKJNFljHWhmdewfj+gsjcDScnLQ +d4x7QPQ6wwa61EKFdGhbKpxOR5KJWC7HZiuGP3HQkYq4YoZ6JMBLjwQZxFArtCTQksBDJoGFfI83 +piGzoZiPTItiOIJeGKa8xpYrYPaAm8BqIyjP3YGKDxkQZSIWfUGNXEFZrniS8SoDnMRhg0BxrniA +gwCTJIK7pG8dva7W+ZtCOcuRurg0Z2fKsST6LxpP1zi0HouhyuG4miAMR5K1zHQpFqNcBNMBpygq +mOlRP0tPwIBm49TWgva3oOVQrOh0oBEi2CsoUJQ7j9DOsmBsuyHQyMmBbghCDWVKEWCJ4qhUFLFU +PCqVi+0yREGji6kH9UrcAZKcFCTF09HskOKaZ8Eti4naZQLyiErR4LJTIWgdAtASAE4eySDDOp8R +k+h3EBeGWbgb3/n8k557oCABzDB4QG9DH4qKGFRARHyaz1Z5GDqA3MYzpQjUTiCF/xThrHkwJRZt +S0UHktEuiuwRAE5PCSIqOicREMkWxmYKO3WcsWEYlBSxvkCMsEF7cRWQSHc4t56Bq8vLOYQ+CaqB +jwvQuOLO0zEKVYTntJRgca5+61fltId+qfPrnWgiApWROelwJeDE82wuXDpdvWyQr87GSLW3rFMj +nZVKi1KpEIlFeSsRKNpZze1DFQjEXSxcCfpeNq6WoAt5gtDEWivakkBLAnUJ/N96jzdg6SuMgCvG +yPyGgVICP+8H02N7e6G8r9oFLFETvjqJWrjFLOZKACO9auI80vQR78i2s3ZBXHAUPim7uPfxhfLS +WP+vtk/dzcZJNBiwBEbqXALZlGEwphquoafjFc7ajVcw6fR+UClBVCFaGAVN0FDB3LYkosE5rgiN +CYKykCfRLoKoTpZxykLC7mQZDUZMXmoXO7IWV2ZIYaRSHO0sZHVnL/AZklWkAAhhr1DEVLlWOJmd +L8Vr06jKQyIaGTMRFIcr8zbDDzpaWh4wcDqhUJaT0PXSG7WFDNhyRLhV820FL9XBj9ixFbmUU1mp +bwOqIEIbDE2x28hJFQw7wBXoUMCL8Af5EKcriITDqY74QEIn/LHQ1Ig2LvRIIyqc8LhHuHrEE4vl +TKawrVCS61k0zHTTX5ixivxr5/YfpjbiED3QFFEA+eZdB2iEwEaCh/BMH1WsOaJj/BPhkVl9Vouo +K1L/eO1Gw8ioFlVkpaiLOGX5AsAJQfDJx10LPDX4VGaKwIAvNzN/O7epRIQJ+1yulpliCrzS1sFm +l1CtuNctZCLRCi0JtCTw8ErggZuJ8/IJbhF8o+e8GRY8sVmxgpfcwgARIJM4YAmck8Ktj82DK5wE +ZWPhocrkc3sS12QS11OyUookYrwHWQtJEomajLl8uAJVM92YOIxVQzkgEFsEIpgLbArEWaejA3SC +ATYQ+ARK4bLjRDc5BkE+AAy4dSuQ93jYlhIgJ5uRYgVZpaaxQcnAyltbtSQsB95wwxogkEEOWzSs +vbaaW6ARdSwXojkDsZ7ForkZwUUesZeGpUOcjAMBKsc8ZVqUDOhzrcgtikO999SW+ILK7jWQk5lc +5rDF/YizlYr8BaJEqLdu2FGd2aPCCRDUoKseNysKZsAqUvRBhuSQJdrWBoLu5cVeQY/sEeHWg39/ +IDid2zZbxAy1PuBioMXLVbThhA/4BAQ6mNGP9EhOk9ak81DNs6lN3es12MabkdaIgeGRHS/VnK6e +phaDvToAk+JDFnMbIEN4oCwUFFSN2otk6AtETaDv6EFAFOuTnHzoI0oRJBzLoHoQrA2VHG55fe3M +lJ7qK5ThyMlQKtIO3w2R7PlXWVuhJYGWBB5GCSwwjj6MnO9WFbrEQZRUj4CXYCcI6inNUBoont1I +1KKJwnEd4SXp3t+OToyWeXcIoMyEImezRauJOEcAsmtPepuJQ9Qfc1rYfJxaoAU+Zoai/HKzdatL +jlMWu+alN3HkckINwEkpLYg1y5WpR0xV7FSygZfYfOho6VzMUJQofj+0OZBJFWz0ZGO+6VxgtWYO +YZQvGaSL6UBHQQMqlLgsS1tABKvYu4A0iTKgsXcNNKgIcxOYweEMwNbyQjvMUIwwisgfK3CRJYrs +ZPgaoEJTWEIw8BAg+fQnEGsRlWrggUxSshnKCuzVCaFkrJ3XsyRi878ak05RJgtBPOgpT/Fbmw3d +lC8JW1TI4A0c4qP1zIAQaErtRo+qlceglO7AWQo/SjFuNaoA1HhZnc1VI09E4acdiaAVJIdAznBa +iUbZ64UIEYRGvV4LT8WGEacgZMFXOIQyvQ8zumLxGx4jMX2QkwkKv7oqYghCXQw4khrGjeysMpSh +OCk8ZXwGwWiqkrQfbrNYPG4ycTnp6rfBlUgrtCTQksCCS+BRgqPIJdAjgYyAUsfUe/VKYz6pOX9z +wVhlTXRmUV/q2snSbXhzWfObr+q1pOhWQZQ7J3G6gny8J9LUJXH+YjrozZHlaCYPHsmgEZgxV2oK +WgfcgVhMfzLLhZWJ9rQMuI4p6HtOyAzmoVI5Wmh2ShrWtSdXFChYxYeKUO56HamjLJqao/tsCybq +lQxUCnJjzhIBLCEILmJfYgAx5QlIsGRJOEEtiAC9PCs45xHFAXsUL+CNAY3zGduaeFH59JR4HRqd +H9/bCorYgiMHUWVVR+gKz44TxGPRVFt8MB4BQe2Znu8Wgi7YI9LccR4vlmcmsndXqgVaRBUCuGaS +hnYibaMKPWHA0ciAYF0mqZRe0IO45AtvmNSi1jSBKiKGf1wboGyNokqHyQZZfTGMDU9wEKXfoU/g +1s1KRjzEddtY2QvnmhYlD/hqNOHBM9BN+DOmxw01zdkgyTVqnC1tRRqpeO9c+bi7JUgXdfHWKOn3 +rWtLAi0JLKgEHj04GoilWWsECsUjrmXI6Xmac95bPNSRKp3UXV1d6/p9vjpeZZMBbmHBEjAqvcYH +tVTLaQ1OR2dscqYM8ODp5e1oBz+2MxlJ3XjnaC5flk/V4AcFitmDeQeecUI9oAXAaPERS04AIUxM +m5KUOjZwkvePAuaeBaR9WyoJZBDnZuXwRhHyYnpSBZoX7ATk0MJS8ZyLy+mszMJG5Womjh6XHWyO +x7wtKVK9ZlrxlKYRpyIRtzMBVClWbDQ0C508r1kxdW+qWCwAGlTUFBxEIQIPDgzEqd1gI5GODqTj +vcZ4U5lGtLkLgjiRIJAxwIZsced0/h5ecQYuiH+emekmLGRoAgPG2L2gQTarSAYxMd5MkBqsVPOl +ygzDEfCMthMgFQRRhqo62NKtFt0pVcLXf6/as1mCF6cUH6RHXxPc9KRqfQFMGjCJTFxcnln9BfNW +nioYfvH1QIazM6HJcVWEGAlWuXKSFc6ZeZgpbCpVM52p5fFoIpBVIChPoSARo926tCTQksBDKIFH +IY42SytQMUGEp83qJshMBozX4DYdWV3LLu/tvXW244/TmdliPrxoKJnJlFKpGC7ZqVnODdYyV2yz +NqYYDVzRybevnzxw1dCKobaN26ZRkegw2aN46nRAkpmb5MR+xSjxd0n6jBrbYDLmucW9ixMV1y7m +ph1qIz3rIGeOXIEu6pQUbB0DaQwXYaRhmK7mvwXPqFoOXsAYpY9HtyLkhuesLSaimWLMDFkIYqV1 +dArXmUBFb3OIBL5rn5OrC4QxAeZ5w3STNjeY4VrHA9g0EHW9bSCKG7c/FeuniYFU94gEWn6PSNBZ +QU9BfqawMZPfpRpNAlwFSNZjqtQ+fk4FtQA2JBA0XWpzutFYuDO1pKOtj6nzTOGeQjFbqfJ2d/UL +IuJkqyr4bI2SL8FEylOaTAAIWSjLPhndGmXHQreJSSEnjOFp8EEJzQdEkbbkUB9PiFuykdmbIDrO +ZEM8mKS4dqEwPqbDGcgsspSwbJRSc/gPb2pTKF8aK1dne9qG08keBBXIKpCe8nt/qGgrtCTQksBD +JYFHOY4iNlclrlz8lnigdIj4iiQXMI/cFWzXRGHysGhsRW/HNaPFuzmfqC2d5oDA5YvaUtPhyUmt +oJ3OVLSz085qQJRA7PW37WLuihQ0KWhUV8o+AYmvDwhk3hEtaJOsqFpupaYBY4wYV/oglp3Vh+Zl +koyA5xZ1jC+X4GDGdCYLUIFnbjE9sRrZPENxndVg2hZ1zNolFL127JjeZYqUqVZMJZADBCUo3bQ5 +4Ml5C2KAhGhoalq+ZeGiTy5Sqc25YlRZJabKKSvZ1inU8cbqjsaiyUhve2LgPk7H9U4xCo53Ts17 +ae41NJFbny+OC4GAFrd6HZCstCDGHhmVBlC5a7eOW5HO1LJUottqjLQlFhdLG/H6U7rGpiYW7Mqh +GqnKfU+SkvXfRglKIFkQrT6V9FRfo+1WC6LzdCRGn9YRlIGUjZMkRot7KUdT6EMtCHjgE7HwzEyN +VUX0Pt8QFbHHdSg0ZjwpMPrLlfx4dl1XbWl3+0r4D4KLN7h6JKirFWlJoCWBhZVA0095YQn/36DW +rEGIu6Ih4nGPBNcAQZt5D5cHahPP6gz/JVy5NV/bkivVooXYYG87kNjdnR6ZyHWkY9l8ZWo6r5lC +YAmPqGlPrFXpSrN4sB71FACIaD8MKItdKAcprkXblc9iJXKChehcpj9x2kqHmhVIEYyqci5UsSMF +SGSeFUhjiRPTq25TkhfARr1rCtCsTGCOSdlkgoP5Q7Dnm1t00gJWDtv/U6ECaE11LGUyTy+TiDyC +DVmxID1sxLSal2XJBHAUbS78EJroyq30u5tK1i6SOb24Ld6TjPVFw41TFlV6t4C0g/sg7pGgI+im +IE72SQdRagOnVbnECBX491vnRCMMJSiDsaYIS3UY5HSnlyfjnUJLC9FIsqtt+cTMJu5jceTBi2M5 +EqsGWYhguWpG3N4tCx0NeizQNd5w9TKfBoKqZ2HJTkRCbjxCdIrApJmq4jbg3H9wgQAtwgQB45vR +nTXMUBWxARN1qiKv22psROtArlv5eKtT2S350vRQ937pVFeT3O6NesHWtSWBlgQeIgk8ynHUpeYa +hbhHAjUdwCoRt0oDKCVnoHZRksnaY8Kz+9WqG1OdtxfC98zmC4P9bYVCJZ0IZ3IF3m6TTkTZH5jF +JWu7Vkogn1ls2Bk4azFMkymUa3g2V8Jw4XQ3+WPLoakxGSVYtKhvNL7UOotQUKOGA6h9VCpoQR5p +bfPTAsYUZPkPrl30NTOjlCJFFiH2KzndZrL3pnW1x8cm8zzCZ4tjFrAkM/s8mPgEcdHvpDNr255W +pTxSNqZRTenDAkMBbkM2P8pTcsiABv5NrcOJgun9WASHd28q1sO2I0ud54JIg9Qg7hGuc4N1kyzR +bHHU6qkbiFChaqEUMoEH88FCW+niUlY4EVodrkU6Ev1tiUEAPuhZ5yEebe/pWDaZ3VIssKg7nIjb +F4ABClBaqwGr9RppX4R/YZy+SnHvurl/kQwiJR9ipBdoNxHgU50FM0aKHpEwjSsnSBzeqIU0SCJP +zkSczdSmxmusxRXiGn+BqMgm13S9cP2p7sjnWe1hsTy9beLPg91rejpWBJK0J61LSwItCTzkEnj0 +42igVhw+HTvZBsOpEX5QAwiKkvUdMqSQH6nvoXYthVdVrQrnh5ORsXz0xpGpvxRzhWo5VqzVxsZz +aaDRjuVzxMJGYYKzsz01M1vNFYtQbGuLDvakto0AwWVUMKYGerCvW+t7eW0ZFglBa5HsZAYsTvQv +3kI/0ACO5OAFocAwW9sJFmJGoYw5n4hAZsEtK4xwMNrGFWrPlUPTW/J4ksEVwSHogvlCKVudpOpA +AhYeg7u23QWjU0GaW6AOHpQM2kkTOBpiOYh6NjCej3yYtbbOxD4PEkGh6R2E/IPIVH5DrjDiLNWv +hltgpMYN6iZ9FOHWcEXpMvJ4YXtve3IIiGwaDylnEBKx7q5Uabq2gwIcBFQqagaUp3wbjJIIGuDV +yhW2QKkcckYyCJP+JdB8JOMgynNQUJYowGnjDDLzgSIcUpy4Qph31YHMqonTKsul6q4d2nVDHwUg +GrRUkfmCM6Mn3nyjzLFduybvxDBd0ncg4wYe+jd/PgKttJYEWhJYSAk8anEUJeJYiLRcoTiCcgUy +CQGIEncodYU7F0qdlEudtaKh6kCyfGJf6PBs/PZyckOqs7RrxzSHtRWL5UQiilbNFyqaB62F2ttC ++w/3js8UZnLZqZnCxGRBWtUUq8MeGNaVjuJ31boScM6WBaGd2SQKHAqlzFSV79dOY2BCFJ0J3Ao/ +yGzuVhS0tDITpTbHiT0KtmEBo/GlyuHXgJOrlrHYLW0xyNC8LHQEqMynQgd4wOhE6XMQAfQ5kAFY +apMpLDAAOM3UYzetrCQzucrATykR5kWm8wVEFyTvEfdO4alHuAbw6ZFcaSST3+Ew6YgCLTXc0EVi +NCj1R2LPngJnbcm+jtQQm228WwMG5kZSiYFauDqT420HFQkE4apZNmTxMYRBqSVJFHUDnTwI2Vzf +9JHwz4xyXYFSJAErwQfHMliL/9xkjvOcb4gPbthxND6q0RJDFkE3TZM05rJpKXq2+yNLac6PEKZn +t1eq2SX9ByfjHc0C371k664lgZYEFlICj1ocRUjoEYfSZk0d4CjwiUlKBsIeCtehlFKkB0TI1iz4 +aKi3M3J0tXZENbulr/OOcggPYTRfrKRT0c621OQMpmp5ZCQ/MZHv7kix+YOyKGL06QxLc01fY+0V +8hVWBoFBHPjAhCVeQWlzU9M6fMeKAF3MNoJwLPStI4fpaxm16GibYQUFKYWaVSmgzty8qG9qBHR5 +hNLHkCUDVqysH7rd8hOnWUCswMAcyGSiLuxU0TFOvNXwDCckAtIcUYE3WEce6r3TnE8xCUddHYNR +cL4RkFsjqo5ojvst1z1CM45Waxw9v5EG0gSq9obDT70TrCvuvbUhCDx0pAc604vuD4IG/KTjvC08 +kinsgBlJPhIucgaHjSRUlzGOeJG279NFqpKAuXAlNMTSuJKZW0YbFKKoO299tRekaAg5eaY1WxXe +wcc5U4xqDETNmPb+qjfQUpyQ+LL2iqzxY5dGCwx9ufFsXHPFqU07r1s2cHBHerCRqfW3JYGWBB5C +CTyacdTF5soaHQ0QBqYnEQ7+BSbJIyA1RcUhgoGkHVm9lOeBjmcL8hCJhBORyuqu8KpiZTwbvjXd +tSNXHEfNrVzWW+CQ4Up5dDQ/ihvYVt6yD7VSqoBoMi5xhxpi5XiHs81rgqZMWwpKmaEExnyCDesT +WxAsQTtz2i3prlIbqhRcxJp0bY6SdbMGMMbiqWaFylTEHhsBpy2Hkd2JvYsuV6uMB0yuBmC4QQYR +7GBwl5zyHhNl/k8oo4J4knE+A8AQdy7IMzE1Pp2Z7Gjr7uzoS3LUU/3J/UVQZOsgGkBpuBbjeGYT +hNAatmGgOdShBQwkPRzrTPf3dCxlpTAd5303t7MoPm8npuID1J8vY5Vq2MQxVdTl1YGdcpXb94Ku +YTgio9zAknqRD9kkJVKgLkvWUgz5xKHxLOYNa33qlFf9cFguXcm3AhkyiLFiNmqha7CDA9A1jBSk +etutL6DplD3R0+pPrCDUarXC5p3XL+5/bF/nsFFvXVoSaEngIZTA/ys4in6UimycteuWKFCKaLkG +OtehlJykk4hG9njQA0HOIMVyhuOR/u7IcbVKMRXZMZm/fdvWbb39aMFIKhkDborFEnoTaFi+tGt2 +tjQ6nkMLz+YrMrZAUzbM2KtjWB+LlsShShJAhfZGQUv52jQbPHGL5kWNSpNaEJjxACICRnM82vYV +6AN+nOdARmAA5CbIQuLedTeGlIE0t6QrHzkpa0az630SXVlzhX8MYj7S+w4eKlEvSGmGDRNTE6Bp +l17xM5BItjEN6FkkeiPkkbnXAD6b0DQ20LXvjombqMCtNxeFEMvaC2WxzW7Xtp7FA6sTvJ3H3kww +bwc5G351ToIUz88a41g0kY1sYVMp51LhFUf+1OtjBc0B+xJctzjNNKdxzgxXBKKPBdhTH5kZzSPx +aDnJwDgtl5Edr86ybCrRKEgimeXjpRMY9Jjw1VioGWUuRBi1uFXKTSAKrUWygQ6JIi7Durp97LZ8 +MbO497E+Xdqg0frbkkBLAgssgf+fcZR3haI6V6xYwYu4F7hlKBapGfSRDq8nUBFxLFGuBH8UVOp5 +uAKlHse7y1OHUlKaMdWLB2WDCOuBEuGVQ+mVA6lCrnDPbHlzrba5t7sajbXj4y2VKhvvyXR2JLo7 +4jOz5QRzkOEorl3ZXSg+brEjcSGyL8WWq5izVrjl2hy7kwDjhv5CX3SuQM2UNWYTj+rKl60eIC6G +r5/WS063kDgcn3MBIQgQagAh5etqVxZnJMRipggmXa3Y1cWuSh3LMD0DUumcQhiDSfIopzXYJCjN +rsAj+1up1aZ4Kd3MdDvvcu8cTKe7HU0D8e4R2QNBeUoKlLh2pAa725ZNZrak2GRUkg3nS6jcCqRv +K5HQYN+SpYtXUzs9EpihQecS8TgEoWwMKqdH/OrpJEbDHe3xldP5zZxFJWvbjEgkjBnqkCnD1xDR +GKwnOpJxFVUTO5kZuMAkgV5gITfT5UgPO553EoCv9CbBuXCmnHJdqqzwYilZUgMX0bFxgzIbmqoi +UpyCyDT6AoC3REuzRIPbSb3VPLti8PAI0+at0JJASwIPjQQW+Nc1OTn9819em6vGi6VKIh5N1oon +n/iknh7tf98jfOlLX/rGN75x9913k44uu/jii4855pg98izUrWtndKXraIdSiLs96rWQJwjSewai +nkJBdDRlm1Vwc3wun5Fwsj2xL59qLZ8tbM8Vtgz1zhRKU7tGJ3dsn9Wxf6x2isV5dUxUdWibBbCn +iUn2q9gkIzo0GuEhL0+VDtXknPkPddICGAkW2sQnAKkNNsCbjUPqXkFz9kJT2tz1L9hkSlmsAgZY +q+6ixPrEXRkPszYnFRvqTa9NxQY3Z346k93BBB5HvGKAgqOob2yyPULoJ8uPAAAgAElEQVRd75v6 +lqI3LFGFFs9ks5nspvZ0W3/f4rYUX4C65zYQMvL0uHdKcBtkINLftQY/eb6Ube+hHTotD9SHvpAs +HBpeumqwf7nDJ1eP0C8enFuIcNvMOSnBbfDIE8M1hj+JYqGM3FiTJcA2GBPOmadXqGZQypUgSoxI +LE4E0CXqy7t4irnMoyJvD+LA5GkNSqCjUQvBRBREnJpIWS3caitOR002cbGtXMUJYO92ozqNGMQD +EWpX3BlooKxoW3N15RMNzWRHt43dtKz/UIYoqrEVWhJoSWChJTBHOz6ICiYmJj74sQv3OfJZp5x4 +UFsqkslVf3jJje8/55sfes/L93gL9x//+Md/+Zd/OfTQQ2+88UYU6M0337xq1aoHUfNei7p+RF0S +cX1NVm7x63oZ0j3wLlJSPO46nVsiaGcwlXQiniFQvtw2x7mdGyK8aDO1qiNE66qF6kzX0EwpPDY+ +eXexPFkJ57OZQiIVjceS+VKZkQc4qkpsa6kDKvCJMsRgRUdLa7PRhbdtuso2mxKURWOysAjAQ3H7 +Yl1m+DgKn8zALapcGey1phCp1iAWD1fYdkrNHamOzu52Tu9bnIz2RTGCLHSGD908eimQzOuv3fYV +kUbboAYj/Dd2LG6PHMJ17ytdTePPMorYeXdHe2dP5yIcsC5Y7wiPI9gg4sL3q9fGfOdQ74HbRm+g +QZ09GknkZmxqthoaXrl6oG+pwNO2LTVf6ZTmfoFgg3f9nfdRuVzM5CYz2fFKregHIAvSDEQdqETD +xh8kCjiNJIlOW31kT+kOJQKEpNia58ykDv0nO3OrPiQKBChueOC2rPkMPIW0eCwSS9Q6kv3h8pJy +pTibH80Wx2mjMnNpQKny26CKq+xRg3nSiEJE8G9T4FOZHdHIbUv6DlL+VmhJoCWBhZbAguEoP/KL +v3v5xb2nv6i754q7pvvbY2Oz5Z1DK77X/+KDL77srLNOd+3p/Ltqm5qaotSiRYtOOOEETz/33HP/ +93//92Mf+9ixxx571113vepVr3ryk5/88Y9/fNOmTS972ctOPvnkpUuXnn/++aAgMDw4OPi+971v +27ZtZ5111pve9CYofP3rX//KV77ygQ984Pvf//6vfvWrxz72sV/+8pe/973vUaSvr++DH/zgE5/4 +RLJB8Le//e369evXrFkDzZe//OXwA523vvWtj3vc41avXg0Pr3/96y+88MJisXjOOeckk0mg9Gc/ ++9kNN9zwT//0T673TVfXwaVZNXtD5rtGkjqXjs/y7qFDSuXZ2fyuUO/MyMTmUHiqLVEo5TPJRGSg +IxWJhScncqUi5xex+tdelIZiTUQxa9hRg7XqjkE0JZgLNBIAXdQralTmIKc0sCs0Hokno8loeyTc +nk60JSKcdJOORNrjkbZUvCMWbYuGbUHwfIx2pRf3DqXyzN9CCs8wAZAQAumj0MAPoQBxM6ZNaesh +s3fodM8IV2womZqZnslMd3f1DPQub0t3NQNnc7wZQUXIQluid1HvATsmbmGDCocAM1bAO9qe6hrs +X9KMnR5v7pQGAf1thlLiQX8RyRexm8ezhSlMf3AaT6xPuwosDRppHnFhKnQaQAVNDPq6HBzbEAI7 +i6JqutwAvCY9o/foCTsJZmvy1/vOM3g6ZAmIEYlRnI4zmTFD3h+qLYIaE7ccGdFRGZjK7soVJyIC +zPpKMQmfO7t6RwjixahoCnZtQp3qJjKbWcY82L2vHrRCSwItCSyoBBYMR7Hnfnj55sqRHetHqltn +wl3p8HQunM9XK/GOH16+6YwzSqBRwPnjH//4I444Aqv0KU95ytlnnw0Q4mvl6cjICPA2y2GvWjJT +dKgL4hdddNHKlStBVhCOUkDjcccdt27duk9+8pNQaGtrGx8fpwiPTjzxRODw2muvPe2004DbI488 +8rvf/S4QSwTFjc4FoVetWvVv//Zvn/jEJ8i8ePFiVOo999zD1N6f//xn4HbJkiX77LPPL37xi9// +/vdPfepTmTT9yU9+csopp/iiJCi40nfFHajmQEEHLd1bJB7jPJ1VPO1Z+jg8f1Xe4tWbLRSnKqFM +sTgTbs90tuVr1WyqLcb6HZQjajWSimkVbrXMuQ0se0lE4uFwHEXJy2PkS6wx35pKxlPpVHs03J6I +AZZpDvThpamYr3tjY970VLx7cc/wztod+HXdXSxQMd0tFW06um7yOLjyzMBGIGGmkuBW1rv0OMEB +mCVIoOnioeWDfStY7+UIytMASpXVQiBP7hApxymw5mhkeh14wFwpaFfKzU5Nj3W09zTDp/eFFwno +EIGa3wZXUpgCnc1Nz2THS5VZZAdlfQAkkFKNrLtYEa7uDD5l3pFBFIWsfCVwzfOI1pFIiwFgdtbS +l6xq5pR/Tv83A1IZiCAPlaW9DQNUFRkKKlEAqA+H4UMzFR2M1IYaJUJbtmwZGhoa7N6nVB6cmt0x +m59SUQZPTsF4FgVS+D4Yt8658og6/0Ijk+vwfPS0rxATrTCfBBivowqaNVVzLr5sBHdl0ft8bwnN +GR7++ANmiR8LTWie2Hr4mX801bhgOEqvbBqPLR7oXTEUSabiyXi0q1Qp5Ev3FKqbJmI83ePbiZn4 +oQ99yM1HQO6CCy7AML1vyYJtGJqsSPrxj388MzPDdXh4ePv27SDcxo0bDzjgAC8ORgKlV1111Utf ++lK0DzOvWJM//OEP77zzTlep73//+/n+YQ0D59dddx1w/rznPc+/Uh0dHV/72tfS6TRFQE1wlIDN +yhVcf8YznsGviLKu6D3i8WbO7z+aqhTbLyMJfo7AXirer5R2XVCyOPQUM23a0LeBpYc6Zvb0rwEk +evYBhf74keOJjYly3v3fQosGDggUDSNlBNuWG8EM2ODXKhyCNsohnKB93JPg4BGubt+1eWZ2fOmi +tV0dvaghpEdwHoOI31pZB8caLwgrV/NTWdZt6dTfSLhyz451Q30re7oGyUFHeObgSsSpNdMkTuZ8 +YXY6MzZbmGISGeTTpKZtXxGTboCqsNDo1lv+cte6TWLO+OepkQ097tC1A0M9Jz7xtRdf8ql991vh +uEg26BR4JXhBlijOA0aGwjCTlYoKI+syESELymNLzCRh8jLjEA63x1eEq7akIBxiVPee97yHb117 +ezvjyES8fVHf2nxxZjKzNVfI4DCwYiLOijMY0AoyO5tQ3wzvEdHVu3Lhc8fErbjKOaSiXn3rT0MC +6IG///u/R85oAH7sjeTd/qKsWNVx/fXXk/qsZz0Ln9l73/ve3XLMd5PP5xn3P//5z+/p6Znv+YNK +e2AsUSX68B//8R+3bt36oKpvFW5IYMFwFF22pLeY7OpY3Vsd6I50Jdl4F56YiW6drOT6Cq7pGpXq +L3D4kY98BAB74xvfyCwpduF//Md/NGeYG1+7dq2DMToFYB4eHiYP8T1yHnSQ5oH4PXDdf//9sXQJ +VBfA26c+9alLL70UyzXFFgdUUDjM74c8xLF3+/v7AVHoYzEzOL399tt37tz5ox/96OlPf3pXVxeP +0P40h+B62cl6HArNIaixOfF+xlGv0cjCr2G+n7XHIz2LOx6/K3oNmzQ4NB+8kZp2G8hwlGVYWtSK +HjdlDQihvlmju2jRcmY8OfmwWMrO5jKF4ixrkHlKkD1naj+Tzazf/Oclg/ssXbQvciORq0eUQ9Ar +APIIcUTNtTMxXKoUi7EdWvoEtUh1ZGpjLj872EeNdVetF3RSwdWeVskJ8GDJFYsZRxrVDLABMPQ8 +SMnF2hLEd24fufWmdaRPTExf/cvrn3bK0W0c/xgOLV06ODBgOlFDBhGhaZTFAGUlFAhKCg2QfMSp +5Kb/dg4D+YWmarLVS42csmtLtREys9Gp6LI6iFpZhpj4bN71rnfRCsaOzD7wlU5zzH6qezY/MTK+ +lRfASVpWU32NMV2Ff8LfGmtEGPe44YQsWXM0vOjIRKzTnrQudQkwjucHjoNqwSWSzWbRbHjO/lYc +pbsxD5hpWnCWWgQXXAILhqOgy4lP7Pjtljsef+yBXayLYXzN4pee0A+uuOXEJ2hKbF7WsQhBNdD0 +6quvDjJg+RHnOxSkLFQEZXTJJZdQ40te8hLM2W9961vMsJIIjhKoBT4xTEkhEH/mM5/JnCv5sXpf +8IIX8IhE1HozmnJLQb9Sijja3BW6s90c95RHxLUnfkg5sX5XcQc46sc4oJ8J6H3pbYcImgtmGGzE +Yqlli9YkkykXnXpcOyZL0zOTE9Mjufyk4YnN55mIdoxsLJbzq5YfhHd0D4G4xBw+JUqDUm47Y8O5 +aKEYYemO3s3Sztk9uZFtuwqL+lf6UUouf7/SS9AvFHPZ/Aw2aLVW4jUulPIzJego9ZX7ctVpBqJi +2SJ2PfmUo/mQ7eYb14Gj73j3GYuW9Au0aqGpySmKAMD6XmNqc2RgNpKZ4QwrPdVHhBrwRsQWfPEV +IycfVY15SqIBOdmRAZudsC9rLBVr+q386U9/esUrXkFdCOGKK6749Kc//Zvf/IY4KR3pvo7lvVOZ +0fHJ7TRTlElmITcQbm+ZZckxZPnI2G2Ad6VaHJ3+y9K+w6HQCoEEmAPCHg1uFzDC9BNj8QdAEAXF +kg7mrR5A2VaRh1kCTT/ZB1czOHTac05asfmrd95wx2AytLIztLgjdNmVNyy9+0unPedpjlJBDbhS +P/vZz/7hD38ALPFWke7DLsbaxP/nf/7nvPPOYwwe5F+oCBoWQxNqaCI0FM4N4ozxSXd7lAhgifFK +IPKc5zyHDHfcccdJJ52EV5mUINAiinDrEeIEgQca0jCYOMHjXAk8egSFSDjeVT6ur1dmPcAgu82M +Nu4MBZRIihLt09XR1QyitJd9O6lkevHQsgPWHtbTtcSdkMpspND5o+M7/rLxTyxVNvHU5eMgEVyB +zyAIDIorstPx2clQdlpnGmDz5QrTW3beNTUzPpUZn5jaOTqxdcfo3Vt3rbtnx+3bdq0bm95cKE6E +w0WOgMTjQP84+MEDTnHdEqEVFvG21BPVj/axRxKCuabhEjg050UoM5152xv+49hDzzz7Hz87OZ6X +WMKhm2687XWvOfs5T3/Ve9750ZnpKagFAVMVZ/itN9/5T2/98HNOfvVLnveGKTLYBqSb/7zuNS99 +74nHvOpZp5z23//93958NDszdv/5n/+JqfTrX//63//933ft2sV0PoM/XIVvfvObQd3ezkUb7hx5 +3RnvGB+bRj7FYuUNr/3nHTvGb7lp3Xve+e/PP+XvX/q8t138rUvgmSZf+pOr3/r6j1508cUHHnTA +f/3Xf8EYqHzUUUfx3cbxyOqEgFWPMNz89re/7XFW4b34xS/2+DXXXMPqPOL8Tp/2tKfhxcHPyY/a +n2JIve51r9t3331ZYcBv2RObr7/73e+e/exnL1u27DGPeQwt4hH73w455JCxsTHPxtTMV7/6VY9D +luazwBBqzASRiHDwrx522GEsfWAtIRBIIswzjwNN0llj6GXn5WRu7S984QtZ1ciKQnjA1cnixDPP +PNMp4IsicfPmzX4798qCRNAuSMfTy7A7uCXCLgYo4P0K4ug9WEVo1IK16pk/97nPsSyDZr7yla8k +BX8+vbxjxw7KInlS5hW1l517nbdbR0dHTz/99OXLlx999NH4seeWaqU8YAk0/cofMA0rCKLwa/y7 +Vz5z/PpvfPbjHzr7Le/6xDkfLt36zbe+9vl8OXjaTB7z7qMf/Si/JX7DzEbwrWKNLhmYkjz88MP5 +GaBK+Fo3F1moOHOcfI2+853voKROPfVU3MJ8g4OpUxS6QyPoCJQODw/j3aVqbALD1jq+OspyJVtz +cDT9q4D6fwdTmwGMZqKhMLVlbnOtVmfGo3dc00b6zK5oZiQ2OxbLTcaK07FKNlYrsa6UlU28qI0V +xHyS2enM+NhYdnY2k8kwJ1SwQARSRd4wl6+x/YMxjCwpC45e07Pj6zfdhO3YSBYPxLnCgF+LpWJm +dnp8amTX6LadI1tHR8uZmRAn+wNLXo7XWY9Nbxqb2jSR2Tad3ZXNTxSKmVq4yNvSgEbMO0Gmfxw4 +HTUbcZ4KVoOP8NA8sQb5bs+JPfOOgqC4YasV2dDvO/tLxx535Llf/MB1v7vxV1ddB99I4F1vP+fV +Z53+re99ga/Bj35whZppOA1Nr+JLn7/gqKMP/8nPv/658/+1u7uNqrZsGnvL6z/0+CccfNGPP//G +t7+SL+QPfvAD6LOwnN8U2hbHCb+UN7zhDQMDAwAb0/+sBvjpT3/Kijyk9OMf/Xj79h2b1490tHff +fNMdjBSXLutra4++4MUnX/TTz77+jad/7jMX5vIFGpLJzN5w/R2/uPR3n/z82U8/5WhGkCzEQ/Vj +MMEtk21qZlNgJoUVCSTgIsLDzJJ1UIFbFrT7wJefNqv8OE2FhQiMjL0oCM3CqFtvvRUwAGWb6NWj +zPjyMyTP5Zdf7t5O6INkPsYlEyv+HFNBNXQCUy0MI2666Sbwlae4iN7xjne85jWv2bBhAzY6UEoi +t275/cM//MM73/lOr2leTubWznp+joJ5y1ve8vOf/xyBgzcw4BT49sKYb4rzlD2uzJKCu3zPSWfJ +BXFQvzkPjYKC+9g8zqJIhh2s6kD1cSUz1bHLAIsCu+LDH/4wKUxO/fM//zNShSUfPcwr6uaKgvje +uvW1r30tP0q2KrBkpGXmBuJakMieLrUHTBTbixWzjBlf+fIXMsjimwfMgFIcEseyHZ42UwZBGeLx +I+GLxW81eMQ2U36rLLvlJ0EiwzF/RJ4gTgq/z6AIW2UIfsuvi+DxJzzhCc1F+Ml5OjOsLHHiV8oP +GBThl8m3H/WEyoYlfjZESIdhNBTs8aPigAgGztzylBSPECcQRwF5JIhTEXEHS0eCAK64JZCBFI8Q +DyLO4d90VdU6akjbWwv5vJMFxDjalzWxlXIpl2OtkCYAC7xps1JlnWwum8PdSgvJT3FsvEIuB2yR +J5/PlsqVWDRCM4v5PO8LI3ntas58qA+DQAVkgx9Xa2i4UUP8vzy9O3fssCRBhj+1DGHOsudfrJYq +8xr0WgV/o/bGNLLM5EY3bb9teKlmtT1IRtRcq05OjY+N78TW1NbacP04vOCrZFWrhFfaiJmJWU/V +s3p+q05xIs4yEbCTeNNV+ZGWPPzKSSvpLUdrspGWTkZKhc5YaYA8Z7/jn0886Snl2sz++6/9y50b +n37Kk6+47Nd9/T37DC+VFXLYY6+5+o9nvf6F9A/CUXttMVE0Fv3972548lOeOLR4CBudll1xydV0 +3BmvfSHvCzr2+Mcfc+wTAE4MxO7ubr5d/Ij858CUP9mIc0XPMluP2cFicsadr371q6+55renv/gF +1/72U8ef9KR0R+hxh62hCdT4xKMPwrV9911bDjpsDQ1qa0ud8+k39XUP9nR0f+4zF6Cp/cf1pCc9 +iSmPd7/73Wp8I7DCDmDgt0wVDCgZ/hLBSYPLkczkeu5zn+t5GZsGdhgjUdQ0vGE6Nyjt9pehJwiK +EkBd7PZgzg1yYKzA/CKGJg8RCFdMVX7dMsdDIdQLV8zZq666ihEGEAKfb3/72/nts7hhXk7m1o7a +Qc6QwsCF2t8U6CaGNXi2MNbhluHFgQceeN8UWBfiji5sTbxi2IiwhJDBUdb+DA8PU5wU+EELBSzN +K+p5K8JXMbdbGbUw5mAwhB1MKQwDt+PnpdBK/FslsGA4SsX0PT91gIrvBAqaryYpoOkeIOoskr5q +1ap52XWtMe+jhUpkhAsplDVLjXztkhS3gSIRHqGquP3a177GCJGhItzSIhriqAnMeIQ83lKPUJaC +XB2GiRBIgSAZyhz1gGO5VKI46YAZVVG8VCpCmJTZzIzqBtjyOSw6lxuDElAEL2mpUCjixzQ+ec5+ +FqAGIqxbwX0MRhIX37w8RqMBaW5YIQ5kQhREMCAQOsC8KtJSJu4EakrVf/3hQAqeJjhtKW7saPbO +8vljctRzKrPyWgvhwW49yQgRtUQuOh0wwvqjaElgX9HrVPXUrrXQ2MSWQnkqVu4KV9piiVgiyePa +rh3bcdXWIpzDZNAIj/bxUiqqZvmlQcoI3suI6nUWlM+L62mDlKfUwdXLUhc4au3W0ILG8cW2UQRm +K1swS5lF4WpnODRO1atWreJFBYlwfzLRydtMu1NrJ0YKs5ncpz7+FXqTwsiNbLJoWTELmtorB971 +3jd94mNffNkL3/jC05/96teenkwlduzYtWbtPnGGO/Zmnv0P2uf3196gtlnw70/jTn+NeIilK7/8 +5S9BWQZ5YNIZZ5yxc3zjb3/zu//88r/wmoGd23ed+4lvrv/L5qXL6thAQ5h46Opu7+7sHuo6OBbp +wgxioxe624mDOs21EAdc+RJiwWA2YUJt2LDhyiuvRLPzC6VSMmAT423m+0zcuSKCaQiMsZ4AcMUp +vWbNGhKbA4YvlTIUAAvxXvpyv+YMQRwOEbKDaJDIeBcbPbgl4n5XgNx/MjhIYRUcnZeT+197cxV7 +i2M8vOhFL2KZEjiKXQuE7y1nkB5YDoHAMYIx8ZEGzltaEUBmUITIvKJuzhDE5+1WhhpkALmDbK3I +AkpgIXEUtlDQhPv4YSwg6w+elAFNHfmI8yNEFxCIA3sEIBbvCuqAkYEn8pR6AU+e4sPM5XIAFdMw +oKMcmfk8GbgVklUr2ILktBe/YMlW8kWm0Oo4ym2pWMQ6RAexuhXiBCl4wz90PqAnPU6S0I9HppgF +B5GqLfXRvhdSSYlwLy3GlgkykRiLcjg+aYKJWsxtP+VUDUIJo2s0PY0rKEtmJCDLj2ORLCuVsbcG +HoSRosUT+ye+oMYjuwTJdRtVdSnUEdZlprQEhMqpYi6PDa9XyjACAGhUA8fmzUTDM7nx9lql8TI7 +hiM13t8SrUWLNYxR8Wd5zcT0lpIiuRgFiOivxSGrDJ6fRKRGulGwQYXlsqfkcfk6KWqhIJInm2rE +5Sv4gUQoWhoI51Yr93xBdmwkuWwpK55iF/zXhQy8aF4mv3WauVyNooysyaV/YPDjn3z/TTfd9qH3 +f3LRkoHnvfAZAwN9v7ryWsQUjoQ5wequv9w9ONRfl+zudbkoPe34448Hw+KJ+FNPPH7Jyh467tvf +urCrq2PNfstp7Lve9sn9D1z9vUvPxRh98mGvxB2N853RFV/zJT1HxiLtEMGZya8Vy9K43b0mu2Mc +fMIJJ1x22WXkYb0CCwVYXc+vm4WBPMddyYwMjl/szm9+85vM1DgJqHFMChOHzJLiZaX4HqQxibBo +MViZZIUHcnoGflNE+O1MTkpoBCbzGMgyh4qB5SlcKbLH9B4ppOOgZh1DkI3IvJzsrfbmgs4JKbij +mtPnjYPWeHeZCfbRw7x5/moiSxpvu+02XGtYivjJGQRQJOjuvYl6XrLzdquDNwMOMHveUq3EByOB +BcbRB8PKw1aWyQxsT2Ys3LEJHOJCzOfAO2bicIRq5n9qapoMSwcHs9ncty64gDk/EvF/ZmezGBW5 +zCyKtlriaFtfJSlFyVkKqGDpa/0ADLeEFNLnpJga91vi3NXQgKRHwxEZxCKDYSlcIiIS5Gm8z0ww +5nTrdAScAUEHOdPvaEk3NA0KoOG2FbnJBA2jS52iLgDhTHwd8sCKIEEaWfDZVrWbkiVTylLPr+GR +iuhWnNtf3amEbhSMebvarT1WTNVyBo81SkCGkctc6Wwe+emQB5MFvEiAtDhdKGeE3SJMr5BSjVcr +tLdQjQOm9fwq5YxYcWPIUri1PKqVDPZUV8dREoxdo6+nDpZEnFG4p7e4SjYUsfzEa2WhTqSCD4O0 ++woYbV/84hexeNCtTGfMAAfMI3Okk3HlEH7zjbcfeNB+hxy6/5KlQwK2SOj4E4+64GsX/fyyq09+ +5rHr79py7W/+/NJXCKhcuhKy8T08PAyioNltGqJ6xBMPw9F68UUXff1bnyjUdhz5pIPPP+87L33l +KfQ52UdHJvdZvRTH/pWXXwspvrikppMDUY61CundONDEhGIKlglOpgaxq6A2V8ky28dQEuuTR5ih +rLth7QKTdtB0jMHcBD+wjDFtXTRMu8AqSAC++vyfpwdXlilxIgrTJWRzxAIvERdnnnDKCr5lty/J +z0InOPzXf/1X1vLg1MU5yfkqOLGZvmGJAyYvkzLgLomMKmjIfvvtB0z6tDF+0Xk5mVt7wJhHIPKF +L3wBLMewYyiwx9O5tyzpcNv6zDPPfGAmBDNcjMhZmYVp+5GPfIRRO7UgWHoEgbOxfm+inssMKfN2 +K93BCiwsZlqHberrUbw4gxJmTLGkHbznpdlKvG8JPCJxlO8ZQMjvxyO8lIxfIxYh2oGvI6taSEdx +kIH9CagqsxQBzTz4hxXHq1gwAdFuJRyhtoZC854lHQUOWdfD6FbpPiwJrCLKoOgroJSlVO14Xh7H +AS0EWB81wgNWqnJIFSsij6vdctE8pOvregXa86DTc7UTH2WK+UMMOCWvCkG+Xh1PtMUQdMFcxlsL +9EbRzOAOC2JFXhxK08I+1ZqZqhsLDuJunUFXZ86hn7E7raG8QpydPLiU4RRbSBWaWev4I0ZkF/NX +T+yxiBJRosGc7oMgGDK2KUcV5OOWfxaBVZ7K6o3Fo+VCrJgtpbCV4QlioqcQTpSjcQYkCf6LAgUi +FNF7bViuVEtwmoxaBlkhe6OP6mW90YaakrRYNkQU/4qrIv6SaOm6Jd0EZS1Xut6PhrSsG9UntXS4 +MMQib6/ir15ZDIIKxlfJHB56H2z4n4s+n81n9L2gIrEV+uTHvzA1NdPR0T68evmpzzmRlH2Gl7/v +Q2/GG3zeZ/+bvarPf9FJL3vV0/FchNkEasFFj75mLylzlqc9/9mv+4eXhaKFgw7Zj/Hf8pUDiPGo +Jx98xaXXnPSMo8R2OPT6N73o0x+/4PzPX/ys04476RlPfO87z7vssh8mo3Ufr/rJDDvm5DAZ2U7D +HCEuYqbrvMbgykIh1jcxPiCFAR+GF1rYpwBZ+uQLAylLk5nyxHp77Y0AACAASURBVLeMh5N5SiZE +UMrM8oBtAakgAkEWKCAfVksBiqRTNVh+1llngUMck+KrW0nHtGLSkSWBXKmdhbU4ilkvA6Bixb7t +bW8jD9jAgkEETkNgjDlXcBT7GEiel5O5tUOkOdAoOhE8JuBldeO7OcPcOK1glhT+5z66Pymsc4QC +QiAzzXfzmqEGq7E4hByygOu8op6XOMXn7Vb6iFoYf7AtAsj3BU1QuOWWWz7/+c/zqIWj88rz/iSG +GZggwfuTdQHzSKHaLxkwhKzHmTYEzuQItfUvumI1GigSLxaY/KvlMAf1Ao1i2bKVinonFZOF1QoI +OltB+WLAQI+T9sAZLfYR1/LC2hIbdBm1gByABnXxiEUftTJqEzakZVFYblaqmClZSjK3J4CEqhac +AGrEOElOlk9VL1uR2iJYdcxZ6t0cUtF6kyhZALmI2SPKIw0tsiqA9VrPZmgDahiKCqMEcppRvDeo +gCeIgjAKxgCTGCiIvQZGmPMRSmAG9qUgHQ8t9dcNWREAikFZEaCA4aZyIkp2Y0CeFa323m7sGcrJ +SLWGrdxvv6cee6waJNwSEAocaYYaQjn95xae9MefCvANQkkySxeLlhS4IhXJ039cEh2lVJfgzXk0 +MYQihbZqvoOznPQVIbdAXgt39e2o0XdVTG4azZF8wLR4RkwmKTFrYOl8KJ0EGPIIrRGXugpponoq +cRmQqz0qJngmkd7mVNtIaShW61GLldObqTz3J7ANA7WIkVdkLDd7D19zEaiLihfp5CDa1pmmUrWd +K/zUamOj4/1DXZzu2NGOvJZFqnXvLrUXOX85N8Erg8Ymd3Z0ptJplh1YQxrNdNeDGms9Q6SQL9Bj +nZ3tyehQbqp7yeJliIzRCfz7lVsCtxiUWG+ux+9P65rzgIjgKARBL9KdCJMVrBZsdsY2FyHO3AdX +Km1Ox6Jl5BHMGjY/YgER87LNj3AXUfUeBjR+I9hoPhltXk7mrb25OuIQ91UUe6TPe/uZz3yG+UsW +8sz79H4m0gtIzLsmKIIlynDEzdx5RR3knBuZ261IAyLN8plb6v/BFBayPcjdwwtvj/KbbwRUObAi +NYjSJ6Ap6EgMRyxI4U25nM/lpO9ZeoNexSLkBivT18QarHKxBNuMQSamEulnziyXOSSiPJetxouu +7IgWVtNiOdaqKZABkNNmdyoFUKUppdoTJbEByiSAEKl7nfwC2MknKzXHVU5OgnEO8RiVqkpe4Rhh +/QsZ5W8UG6TGwF3lbmikSARuKCkI55Uddp44myR0kAEEWVhr9qs/hYSAlrPRxRlFmPB06xBgE1Q6 +R4LCei2AJds6vUbmrlz1azYT7a8N+LQGgmABp+pGBDWiB2syZLGqKSyEVo76OiMxxRmx5glUKZbq +Ggmj4nJQQ9kkyxWh6QZVbHkUFUoJXVWN7r3nxbgW9QoCJVYpd/IILWSkatFwpJhnkVQ2XEkWYxqF +ywokG2ObcLwUKYUT0QQCoXPpYxtRGKEyy6Y43EEe4Bo0aFIU27WESOBJzHi/GDC7cKDp6cIqsWig +a4m0kRQWAQnzNTjRIzLTz4nKYKTEMfEkESSxvzUEyyzj0XY2JOP10Ne/QaW9I02U2p035C/+I+HF +y/q9IZkM3+ydvW28XSAym5vkePpShWOY9LKeoaEuNcpAlMzeCmFnY0AgnwTDSc6paGdx8UA6ujzO ++r8BTfkjMr8iTTpCMrWv7oMxRAKwaYZhvpz3AaJUugeCumBYgeyRuVcM/T0SmfvcA0TJAOQQmnPO +y8m8tTeXIh60a4/0ubfoMexX350y9+n9T5m3F/DhBxQClppFHTydG5lLEGm0QHSuoB58yt+Mo/7b +o2IiHjdtiSaSzvT/AIYwA78lv1oZg+zCEI7qRgtwLM3+eCnXJwIg08R0Nm5XXntCLdFIrFqLM81D +aaizOgdqTlOQgEEi1SAzh9xQY1jP+k7pcRRiLKwD3CtCCqEMqaCsabO6EjGrDwOUxBhaORQuVcpC +ZUNL0CCaRD6s0WXWEOwJY+9WKygoABiMRqMTErJlzZmJ4Sp9DEahmutoK5DUK6LRVqCb1a24oEcq +jJoBUHQldJUoVJceD/NSFzWB8QGpSqwHJGwWPElgHuKw2lH3GJr1w3mwsGEVBmgV+CduhdHS2gbA +koDRqIsCaMO3SyVEaBv+Z9ocY/GorHaWQZFNAYaFXOYEhh0jRaKxJiy1RnGhMVaSCKUKvLZGxi7s +MEqgBnAU1rlhUS5jnHhplvfS5BPAiuGc1rcy7nH9LpOY9qPuVZs6AT6JagMMYsGwDldC9DGuYNVe +/0gY9TgM3JtOosGiIZZwS6EBqHQZAQ5jtf5oeTAcYqUydaqP9ha8gTz1rtxrtlAsFe8slcaoXeML +602Tl2GnsSpTUnT08jvthLEzFxFeIb8OPnmtOlfWDDtSio61xRui74wF0p1dZWMaOtybCC2NhTn0 +qY6dfAmc54DhoAl1Eq0/D0gCzGLi0L4/7t8HRL5V6BEggb3iaPBjoxF7xv1eKkE/XWGhZRKSYv5Z +fscGFDjaVJYVGtoG4Gg2VD8/YL3TU1oY72eZsTEKGoUgFQEWombkbdWkYEleUj0XtKE75Y8jI0Wp +Wms0eMixQlQEQlMFW21A7woKVkYS8CCG8AVCnyTglFNtqJ0hJNWyxSISiYPNlNWuA+iig+T+FA6y +uoWcQgjsElhi6Ws1KqAmMEUKJ+Ke55Ihf2omS2NM02woOCliCIgDKBMDloqKxqKYWgIHnQHHQag4 +o4VRtEKGHREqMJq0l+YzjICYABLpcTAPVKWJqdn2Vcjc1J24NauTIuzWjHEReOMDQLJ0BIadhhfk +EknwDXCDS8xhgytVGOZVaxCVfQonfMohf3EaR78ioZjZ/6qa/3QDXPHGGeCOAYaMfoxJ26uqnhI1 +rVfSl0U9RiAJ21T6HsuK7ThwFaomS9PRRCwfb+OUvBDrjEuzqarlQmDwUWb0UmMVq8QlGUKK1sOy +quV5pRZlJtUYgr6EK96s2xpxSxE7FPUMAeRQP981hMQ11JGorozUUgJoGxSSPQjifi9h3kdqdSMk +ol3R2BjjO2q374Rbn+KHTAxxbDeTbHEJilysrU14W4o0hz72Rlm3qGlB6/T90k+AX0q9MgQTC/XG +qoOcdkw+DaAagS8Yt8G1kay/8zahOUMrfh8SYD6Sqcf7yNB69KiXwPw42qwFmuMNcZgG4NfcpCz8 +EerXput44qqdX7ngjeAp0gJu9ZCEUhfY6GfM718Tk7qzgtJs2uuAbUVGFD5WoYA3BLxSXrrE9InW +C6FM0OOgL9pPxq98mDJStZSoijEIfll2brC3UJ1l4WxcS2ygqMy+ypWK5CCGA0hjWKKevaFm4NKg +SFQ7CSEKOdlwZgcrD8qMWqGv92ooWBtgn4AHFcyssPkQ2JDq56mAAkuKuFqp8oII+LSn0LLyZnqi +XGURqxVGFmwzrsK0TmAajpJbhQUmVg4+GR0YoEKVUnXjSi+QIZCdsUk1LlxVXyGNPLRwn4bCyWQi +nYqxoxaXAGRmWaycL+BrgyCQzBWjlD7S6IC2Wr2ibwiXwO1tGIkQyMGLT+hxOQCUW4BKUO/AAX4F +81iIc8k+XZlpj7CJltcClWLlfBJUkDSEMWRxYaieegMVcYmFKtEigyh1FKDsV8mE4nZVPqXzUWE1 +pJ7N5KJELx6v9UVLKxGmqmuuUFl2C87Ybkm733jx5mxAWjqVyhfYEyUeNMBiLOnvbEdY/D7gyuAc +ty3dq4Y0WkHEmfeGWNerUfpQL+0KazdRPBYulaORSk+02s+KXJ44Gwhwd+50Z/1o3zBKa1CleDPD +c4u0UloSaEngPiQwP47eRwF7ZD/C+dSNKQp+4GTghwlESIlSRDfgnCBV6EtRYRjThSCAdjUIcgAL +9CsRGUnKTwEu6Hoya87RfvBa9YGTllS5+EBGdlOasuC0eRS1hvfoGDS7ajKg9MlUU1YYH+hoNBiI +KAxBRWmEDmPoeXHLBdapH/MERplWResDeCh/a4dAVIAAMyABehc0ojKi1Gjjinrjpa3UBLVV85g0 +zmxHAaWC2giEUpugBgcsuOwQDAIxBNCJCjJb2U0pvzIYjH+6YU2C8nDlc66SBSMG5IBGBgtlpGI4 +hkFS1sXSTvJF40Ud4oD0aSfiqTHFihVOKGqhFBgqXKMeyUzdJZxjuNHRluTDPQ0gE9ImpqGGj39M +gMquYuoxmqMRiLAB2VjL5OU1kpAw+dA6npp9qW6N61U85kMupThJHnkyMWooIJcAghUU1/uXbrIv +nqqDaK0czkfiFRwQGloY3nDlmaoyZBJjREAmWqavJDUG3LKfUoMc5JOdisXDy8lEhQTlaAq0q+lu +t2jwqLlUkEhWTyclVusNhbbTq+62rVOBH7zx+CMc3Un1SKMJag0N9fq5wjw9YD5eNYdgLUrF2irF +3mSlV/Wozt2awK0L0ApYIbNT+b7BGE+bGQ7ytCItCbQkcP8lMA+O7vE7vA9a+r36j7b5p6ufvZSo +F3Ql4D9XbA8ZiuhoKVXTFmgJ1ByrUkxH85NGt0JM+k6/fwNecAQtL41Ibgwt/fIhhcdPCzYBYmwf +wSqKV2pSi5GYM9NuiQjeYzQxjmR0hqBRlhvFeYhWSvAHjyk4xASl7CIgpab5V6tJW0RQ4+Tkk4jr +taPwBHtmw2KgxXmHlk4tABM0vSh4Qa1pHg8/G/aFYEOmnxzPWGPwbwEEhaBM4loNFNFQw/2YiiE2 +AEx+b93AMsY707yaJwQOSVbD+W/EwSM+bN/RamMFrGWsdR7HZRoqk4LUJUtdStV8GGa1youaOfIP ++ix8rSQiQAkObg7d0bQoIAxT2L+0VBAejfLmNKjBBzrcxg+Ma5w9aXjjmRbz127UasUQs5HSoQqe +RA95u4rlQqnCuRbsukklEimqlgjk97SMRoleoxO5qgjDDtopQ5ZAF9DSYjVWiSTYg2swSVMNbwzi +1Q36spCtAZwaXPGl0gBAQV4F8uBcLsdGtkTYgtjWfk9P92DK5mlhWDzPF5wZngQRz+W3QakgEqRn +s8UsDnKoGnZytQGNCRJOjE81lLikfS98kuisqDv1TI9IIk4PxUJdsdpQpNRBMr+hoF64CuKIjO7j +CjOeyDVgbG5bvEWta0sCLQncfwnsiaPBz+++SOjH3aRo/Fa/cv0+679SND73UdyGUgT/X3tvAmVZ +Vp3pvfm9iMjIjBwqq6iJKooqhCgQAoQEQggQAgGSsNxuw0Ja3QK1ZFa3etnLXqtty7LlhdtaWLIl +y70a96ABd0tWYxXdloxAKiHUjALUUIAQUBRUQRXUmHNGxvBGf//ZL3acvO/FlBH5IiNi38o6sc8+ ++0z/ve/8d5977rmMwoyJWvuSFuKQiM+loVl+Vb1bwSvqi3/Sw0sKx/lhUMGZwkDb3DH2lXAKeXIF +V8rBhBFS03mTkkTmS3FFGYN0682QX+fGPB21WlPDb02kTnv4w0As71KNUl8ZYvgDZ6qREFWtQQc0 +yqg7PHZVPxnCITJM2t02DUiupCaHeV9VhvJtB7hUMByUTGn8rxpoPzRYl3NMd0jEL2Tg1Gwy3Ums +LF8S+sfrhbHxCjWRKQU9SS2Si9xbWsKHhgzlVzKxXMd9YwsHnktWeXuEB6usYO6zmgfWgeblr3Bn +AS3hB0KE3Dgwias7C5b0csPCile8EUS8Y1XDI2JYtqaNhugrOwGKSBMFae9C7NlfR9/cBFqddNpH +U0BSLYT9EqrideIAla4K8hN11tQZgcH01HGw1Jlf7i10aRKsXS612YKwvzhVma6XZylbJdAoSkmn +IN1DAAcXDb4zr8roxSeeoLI6l3VYrIWWJ2r0uUI8NIKq1JykV6tTy9QiMNee+tStSfVKv9I+N3X6 +8fIiH0it1C91F+cvfr051ZieOjzVOpwIVVn8MOIZDd3A2kwUgbDTXWZTD02Z99odthXuXTJ2TNik +i4s2euMTfkI9ESRdSHCqbF2GWNr1qPs7afgWN2+CaklUeRp4qdFCa541gFy5QBJRDixdNnu39Kiq +jCMQCAQ2jUCRR9fPyO8QAwtXLZOSKOMpYyU/fP1eFZfvZ0TFz1djBeOBVv9gINbj0J1yoo00cIiU +GEtFwWXm66ok4YdSyKDfYYqXW3hGdhhDdomNoAfKwl3TZCJvTUC4qTS8KIYkhmTWExGqai3GgQHT +UK9ZSj1PVRmMTb0a2YbdSoO+Bi/1gEyiJM2N0mht4M7yD14dxY1jPNQi28R2GpwwTuO/cqWxkrxa +GETjKavS0Ooljd68yyGPMzEb7pbuPFIrqIjqICm5rqITQUn3NfqzDAfHFSqvNNnIXPcWDNNATO+h +YU3JUiv6KTFgInSVCZMKA06ICM/KAwyaRWFqjYZtJVeq0Cc3G7yV24HJBblOMsO8NZWXNuRyaz8E +mqgTRZsx0/kTQjpUUppqVs12L5UeTGNMg0AGb3ipf6FTXaJVXHPo1Yj6oFLr1GoLza5eMlFruDDU +Wp0nYaU7C+0y1S4tlRss8tV7Q2TEoSSkB2oPYfpnZEnJRkKeZCTE+RQ/ce66lc751sXTtc6SFuU2 +mkCptg941jrfbS+evlB/slZvzUzPTTdnG3V9TtWuZReEjlrIWQJ/4GeumguNl5oBkDuaNitstccG +/eA8ctbl6JNppbW0mSKt5fxNBoqaMgnD1iqTstM1NNwWTdeO1SrX1ctHWdRNozmGaOsy0tWVcijg ++rAGm6yfpC5pHSZb6NktKcJAIBC4AgS2xqOFCvjhyyNLA5f9RvXTFQ/wYFEK/baxSd5lMtNNsYaE +lSP91OVNalRhBzUGJdy6yoBJO8Yp5j4pCYe2yvDJ6JzWqJBQYcKxj1fZhaUgGHlwmvVjbNVKHpqD +Ju1PlN61GO4ZayMzZZCiF1WXtKufWsLoTf0a/6GY9FImrRIZkkMjO6TLlKMIg9nankhbg54S6Y38 +zuGh9100mqV0gBkOZekv1aZ9BeR3ivfEfDzDZIDUs0/qUIkMjTVxM7vS0y98rgbrNnFfmfaEA9JD +T+EF49r9gXxKkIDiKAa61eKgtDwKI1ouaux0mCYXvCljjXlbUAZK/hff2+olnStydAFBduoBCDMj +zXlMzh1cCMiJOIGLf4IFT1cl6QKg5zj+9Xqvs8y/dIK7zJpSFgX0Bt12f6FbaeODs7hJZEG/RaKJ +DuvV/gLfolmg/bqpUcvVPv7yDHepu7DUXuyWO/XW8PvbnBYA0790oak4L1D3DWof5Ysyk5xuFvRQ +HA04dC60li5MtxcBqsuaWN2BsAqbq0HXEN1iD0L+cYV0LvQeu3DpCV5ZmZ1hM4QSnwTvdNgYpAMo +VCGup6XCAUJVVusXljpoG4J6Ixml9Nb3JOgeRr8ONVUKzQ2s2pCk93DUGTVb11O5eah541Ttulrl +EHVxGIPa2cKMKEoENITIJiD7oWzpcE0IgUAgsCMIbMCj/O42WQ0/X5maeRo5GGTsPytEowEHowKu +Jd6hRgooTs8CNSiIYcQ9lMPcIyNtWqQrDzc5l5AYw70elDKqiiJwAqiM8QhvU2MHJfEOfxpHErfr +5XdxSU9eFiwreurzeihDJM5gainvjNrjQCMp6tEDQXiT9bUaW5nQpQRNXmpoZ6CncxqfSUv3D0w8 +ksPGVXUVX5Yupb5jSldTJFEbS2GVQJ8og1YmP1FjLauK5EPTIDgRJxG/huFV3MlNg+pSF7CjqMTm +arDmMyElGgOQum+QmYrifoX/mUrXJHFPzaNBzIFTEtjpxRUN4ES5kUAGeW4E5ACyF0Wj1ZJ7KEzR +gxITksqYXufBq8Il1m2RHXKOKUsH9WLPIaHVutR5pN07BcnQLfVVp1ET5JztZCLyEKXhVtZKreqJ +VuXGU91vnV7gA3mpEM5/ehQORuIG7luagyb26eGzCNL+pZlPouogOUFP9ScGTcyEkvOix6WCVXcb +/cX6wsXZzmJD+grggByN10MDZsuZX6bFuq/Q7VodADsLy7j9nfr5S0v6FreqTuWrslQl3VEtulJT +T0klSedWAvZqTzJQ29CMpKb6k16nUqWhSReU8pJFdxvVcrM6N9u4u1rRHoH8lNTCFZo0OVlTjo7N +/2AtV4SBQCCwfQQ24NGxFRR+rowPGlDSWAHBMHqKg3SIR+AWzW2i1RAjHpUnk9SQiu6iCcWhOqSR +L5u8OQpMB3nxkCApeQNaQqsKU0XkwEhLdhlvWtUmBGicwYgkr6LNLgK2E6/oCKaDOxqNZr/JOho4 +CCog0KCX/JdULMtb0lc3rbly4MTuHAqUJ3k61EPNajAPSUWsvENCR9PIjNmQIOW6MM4CgGZwwYTa +a3Vazhhrk6di6jQVTSvoCw2qtdKSn1Kl0+OdfBZAsRVEk/ZxF5BoC5eYcZtnlhV22acZvJkroBPd +gy0z0DxVbqmx0Iee0AKitoviMTVdTWeAjWCSActfuRfBtZOZmLHZ1BNpStDCI75d1oRbudN46KGH +jhw/lrCm2HSC9VdnJ/1VQKpFZ+o316rTndIZngiCOD3Ve8EYYJ8oEFlsUWu2Sjc3y8do0pFDN1xc +OpvuWXQ+6Z1RjpqbnE6doURL5pzpdIEplSf9kEGVMZ2kJKBk7ykRNlPQlxoXzrf6y3wEV6cdbtYl +xp90tZGJV2O5fdIFouuOgvXqbb031enW2XyOD/mwoAk06YwgpSWp39ZWg2DIiFRNB+hmapvaaY1M +haoXyZoShjIGOnupPP1MSi3uttj6qMMTZfWR9dbQOw8WeKqeurVBwCnwE2GmdlI8RDB5g4IiORAI +BLaCwGU86mPlBiWk0S4NOCbJPA0riuqHyhigUWmFX/XkBoKUh8IfTYhJQsYETmWelmFM7AuvQRMa +5ZD18S+8QZbRanNA5cdZ06uYjHiMzZqu1BAtf4+hUSZ2wJ+qmko0iukpJpv0QqmwHsXzmI+3Qvrs +K8CQpS38GDt5niWvidJTeWpGA6ePmUcGRXG9Bnk6o1o13SmPFNfWei16gI1Io0CGPXqunsqGsZmR +W4Ml3JSWvOIF4XWqC1AYNaa1u3rvg5lTCER3B/REu7Gz9qfV0O4HqHj+xoM8Kk/bJzJxqqGXWxIt +CtKDULrUTJsE0mURjp7LahkzK5DY75AHrwMeq3Izgi/LoibOT3NqqnVoptGaaramWLMEZ9JOljAx +p0vr7QANnSJBvXoI1ZUD2QZlEywJTbNyvFk61i0tdKrn2fZ4UF7WezTppop2lQbTjdJcdXAEbqBw +7Os1tqFt8WUB9ZIeJLIxEvKoiIpOryy4FeYQj2nMHnmVltiRkWcBlXKnuXhuurPQoiLOPv9z/8bR +5BQMqkzvk4XZdXqY7rEqLGUyLzvdx2lDkFa5ucyU9NIiX5vRRU2leLfpR6N2mhOZGqCAk7LCkek8 +qEn6Z01NSVgNuTMpidrZBBiugASIDLiCeFa9zFUnNr3QayzRFoxln04BoR2m9BA80dt5MSX9JWpH +blbQeFIIgUAgsFUEVnmUn9+GmfntyYwxY8UWkWHI8zJ2IYt6GFUSm1KmZA0TMKJGZT351K29Rh5Y +R+4phKkFGRq48UZQQ0WJONOULDGs0gM5hnpGt0SomnxVCSpUVChC5mXENGq0ITl27WUCs6/JSWYn +cSxhpjSZl/w6PGLRIy0X5/E4EH6tNZvkpt3DLpJdnM3//OMpL/SW9vLFsauUW9UWNSc3M0Gg2wC1 +mxIYi+kyY7loboB70U4LUVhrSnvxMqFDTW1TJ4O4qqbrAo3XZ+RNaoDmSISqxsuVpqfk0FpT6kDm +nUsK4AlicqG0mFjLolkqw2aK/T7fRIUzp2amp6Zn2FgBxq2xwBe2nNJHy/HKUgXDQMjqdOlM8EAV +mersQE7grZ7fPGMuYzm8Nla0LCWtlqbTSYYNmCNlsTX3O+DLa5vqIc1VmDIem3n62cUHe/22tMam +iXXULlkNuccEikjFrrKULDQNALnWav2jlf7REt8vWBp0eGWnP2hoQ2J4WEu4dTY5q8kD54HucruN +BhdVGLNVFNcodxLYYUnd/CkNmvXGYHmA96/tLChGN3x6sjtkx8SU6O2kmVIcn4jfhSGbJiNujYhy +RakfqZuYaSOFjnae4l86G+o3H9bDJe3wsYbu+Sles0pwEXJ2TFYDLz+G2CY9sh/pol8NTG9ZkS8v +I2KBQCCwNQRWeXRL+fjtabAhz8ov1mUGAH6v/NQtXb9YjReJKhi/5ETyNJSxK901Qw7EYE0Ncemf +hjojR2hRy4vkMdTlEuq5njaxH25kr8lVaodEUxkwtebd8HCY5pUNhIw7WCtDrdoAvc9Li7imNJn2 +wF08MxO76KEhzgAaZu7oRGovRIgp5acBi+1u9c5+gyFTIKWhFi6nmQz5+Kca1NKh+ec0l6cYvGsf +LaE3NEBro5SsLe40XKsoNFSHt8rozDJgVmBqfSp6ZWdg52/yYnmOCxOL9jW6ilAZhHn/ZQo3tDVF +I8o1vp0+NTU9jaNJpxJuunGhdDsLalA6aDMNWIkN/2LjBypkO31+Es0O/WhGqvBUr86Ubq83RdX0 +lf9WSsHALCHdo1PPvLD8jV5pASt1VF1XKIx1VuSuJeZJeqkSV6UW4SCWS1OV7lyNvQh4GMvBTQsv +xrCSSJdLh0uH2Qy9MMXKYRw9zT1A6Xo5Rzhz2PngZGjinnl4zkKXuzJ9MkFrlXl7qMYtENeiFmyz +xWQ6aJX+JS5Ue/J/muXXmUznOYXWI5Rcl3xzT5e2usa9JG/08PqN7urS5WMFWmnMJYB6p3uxWdV+ +5QYpoR3KvfJDQ6Yf6NUdMqeohcafprcQvSW5pQmmjzAQCAS2hMBlPMpvid/hZvLLjF8spukX67nQ +pPxK0WE/7PSTZgRn0LIqyLnCmlInGVJk8CI3ThmDEA+y5AxRjRYH6WCiscNUKQIUJTKm1sRhicfI +w1AJH+uVzUaZdx7LvbZmNdMMqp4FwmByhRiPYTWseKOzS/WrmgAAIABJREFU12c5qPWYIZauaMSU +CUwEMrC/RNrDMKsptjTfh15N5t1HDmZkVb3yacBXD+RoqP/wAGK53+LxW/JQRQnseVurQb0avoUB +Gh4HijEwkRlDtKb1KEgPK9VF5iGnpman2LKgUWu1NAeLm8uewtwC4NpcfmCOQudGNSRgLjcYjQ2z +WMYUklH1pmOThVix5AA9NcAwXalsbDQ3Jlel1Jxr3rnYPdUuPTEQQhSii4tbKV0TwmPolSIDLbcf +0ujB5Wx5+WitPA2EqlrmqwdAmf+tU8ZE7tKS1nl3eaqt8yUSTG8GA5Zl431cKmWRNJUxkcBkAdcc +q45Qcl1oeVd5iSZBtmqDLhhVq/ujFTY1b1+p6Z9aTktTqgphfZ3cWXVwaUkb0w/PEkWpitWWI3LD +wwVNDcv9C1NpRR7J4GaHyZ4BDNEb/ihNIORwHs0F9G7mhYQQCAQCV4DAKo/yu+J3WChijNJt3N4G +vBV9Gsj044UhhgXyiyVVw2LiPsmMTZof1p90kKb53TTPC0/CnIx22nwn0WeaiuMuXtbyxvQeDJse +aCJVgw9q3drr2SfR7jI+BPugM7zhgPAUkak4LUNi2KBOI20yMPPHiyHMDjPEaXgTZ/JWSNoKSKOj +BmodrKG1Wd3UBbnRqYd4LUmifLYy0JBJHh7n0mwayZirLuKWsyU7c9X4pBoWNQ9MmBpCDqqgMKiC +zHoceujQYaZh6QurY7XVQpM5ReaiVwdXSrZGESIDkEdNk0dH5UL23MCSCuE69p4Xm7Va6DZrCeS1 +7BaC9VTtZL1/ZLn/eLd6VldQYlOtmEqOKSEEplkHngIMpthOtjY4zOItTuDYg2JdTyMBVXces7O6 +rNK33XkxVWdaE/WssBaFWgaM0w2VOaakwLOclN6g1qk2ekzqymnN6JNzPyRO6uP0kUqTEi8amyJW +y4cqffa/PYx7Ob/8IAuiKZMGmrGd5GE/UiMI+Afbw9P9wTyT3jxR9h4hmOyCal65VBBMtvtCZBPy +MJmoQhccqxACgUBgSwis8uhmstlPF0t+fzbijOZK055DZ4ifqLLYbx3/i4GD/xMH8PNVEjfh4kDt +tZvcVfxHsa/98lkuiy/IYhg9JYSWcNNwL6E1uRQsA2GdCIWqdFTQFMyElZrHuEYtWu7K+KU1PLxl +acXSGCY2RcaaOJ1Wm9QgiA+flbyKUgsS7WZITGM0fmVa+yEnWGUyLlnXtKIHLsScqWMetpGNuArE +80ao8ZVTlcReSHwnldW6aSiHIGkUHInAmtgabzIyWqaRG4GDppqwzuNJt8ntLddaYZ4lt3G9C55q +mlG9G2xeyAvRiVs5cj0yzwqnKrf0Bie6/XP9ygW9nSm3nnn4Ouulyt1mpdQqD1jYii+ekF7BaqW8 +MX/zKlQUp6HRmJ6d5TJaWlxYXlzkjoQrjcsTDYVyDbMmq9VscDvHCjW1gG2jWGqU5orlcSbizOnT +uZPqTa9rAZKvzFYHh6uDORxurh6ewmrD5d6RXv+0rpAEQ/qJKFciTbVfvwwxfOohF6SWmi2UysOv +Xnt3TMjBNJnQhAKPonRNMlk9C2NQC1UgEAhsDoGNeZTfm/9uJVOujVwr49dQk7w0S8Ie5WooCU5S +To0cRFIhlkPrU3E8EsemdD2cZASCW/UUUffspIp/meXFGBbEXaUI/ulNSf4mjjWBtxmoQoWpOh2M +TQxHzIOSDfaDBJk51iAlB7XcZg0JD7xEl8zgYis3V06ARjAmDfWSvkZNxQmxg6PxIdLyIBzeNMYl +1xV+1c49emlEL59oLRILe1i7pAeWtTr9N38ox1PtS0ARGmUmxRAhkwuhgZcrRzV56pXJ65RJ+zdf +5lrlmD4vqmAJWTZKNwz618kn5eD2Rf7pStUrfwu5Nt8ws+SMzDbmZo/MLS8unT19Co9U6+QqPI/U +PK82XywPlrsLpUa7UdPTVmZ09VggTeqKOFfYVJBwkWlWQneGWi1WOdSqHK9V5vgcCz3g8tYVrvs1 +/Zqatbl2/zTXaPqZDNlUJehiUFQXmSLJQLxeavfPNcr64vno9eMwIphsgocF7nS9lWZZtgpd2AcC +gYAjsMqj6wxJ/NLyVKcolZLGtiHvyB1LHJCUjBncSJM3jSD6/XMzLD5MA7HKTH6G9Gnw0PiDw4d7 +J0qkIK0/Si5CWtOjh0WKYg69wTpsOAArUojWCWmMSkMVuRh8oHt9JUZLg1MzyMasHTWLMNmZXTXg +AZf7LOJlM1Tt147XgUJtk5cshkzGvAuiKlFqdpHhTX1lrIX7mXSrwpEVXhyhGL4bpseWWr3UTEub +UjcxTvZDzGhijqSlbj9cp8x1kqze1OUxTcj1uTzGdA3VhlWvkS9TM4ufbmJQ6ZJIxw4UOyxp+Ife +seFjvz7P1Gml3+J8k8D0/HJnmbd3Bo02X3PXlAaPRXUflXh05fmoTjL/oE/eh6mWmrVj2nWofKRW +mUo3f7omua4ur5Dnr9N8YbszuKQLy/uFFYVziaVDvw4KTjszcN33KgvWcUI/HblgMmHhSPeM+i2Y +nrJHhWGV8ScQCASuCIFVHuXXRQljB6mxSo0oaQzQD1vkox+ovIek129VShsk9LSJyVjszZJEGwwU +kibnUE4griF+B8MODp9GEW2uLv8gPW/Sdgt6ERVyJg1DeZQMM3omKVaTln0Bla5DPoD+iF5Vsi0R +1solsTMauFZbBdkbnYySDFlqSWoxhIr3Q15tkgQ7sqqHPQMZb3lnk2U+ok/Ik3dI6Mg43FN7xqbI +Ws0aOcYqR6wuU2wySzoVl2W0SK7P5TGmafAdqx9VeqvyMk2Za0Yzmsaz5wZjlbnBJuWxDUDZ7l8a +NJe40pjoZZU314W2bK71+N5Bw7zP5Hoy8aCrJP3jFMox5Z8JpVKrdOvc1DNpCa1NF906jSq3akfb +S5fsJoHLQb8W+5cy6QIhyi9AN5IptbrIbAz3kFaodwTBZBPy0Bg015hMCQgeWoERBgKBwBUjsMqj +axUxOoTxI8yVipI5cUPyJkWOGHDwazUflTCnDnmG6ccsmzRgQDw8F03UR1l4mTyo6uozmDiUMF7K +rB8/DJjWIkGz0GpK18NSpnvVfswoT8ZpGjB5t0yKQZysOsLjpFStAGbmViHVsSccySqftT5sbEMN +TMppSpnVQ80G9KkHZWy6qwW8OKRpbFNNyk4ovkyHRU1eJ9ykGSVs3lKwjBwFpUddGMlx2dhaMLMR +2bIUkvJyCm3Oo+vkyksoyHkJhaRCdMPyKcptXPBCZppHe+Wzi0vz6QocnlVwBVlYUxMTyEalyV9k +Fyii7OHHk9T2Ynn5QqO9UJ8vd1tPX+IN3VSIXcxUu3pQHRGrtFaZ5cJinymVbCeQa9u3CNavQ4bU +rhxs8NtbrJWWa7x5kw6STPBozpq57AajgrUkwkAgENgmAhvzaF6BjwL8Ju2O22mEXz2yoqskOqRb +TefqO9j6dZOLvIkZNX7ITUzLdBktxMYaPMS5iLh67ILKdnuwnbxDCuNBKkyKoyByhgZXvVtoTuOW +FuNqxjcNXZjJ72SOViFFsw2A5l5Vn556smlRvSn/krU/vB+apmRxOvVWCQ3NhjyT5Qmn/hE1jQmj +oaM0mrQdDbgVsq+jGU2yvKb3VBdIRbZoHnouUxYaUIiajXWfkOjmoXDLzeca26RRpZU8qs8bzz3U +XOvOavkbC52znPt04ShdiBt9coOliX0RGxO8diY4IUvnmkvnj3D3xi1dZ7D8za9/7fobbzo0O8ul +SL2jh4pIBzU2qoc7vTMWpah0nSqm85wqGNai2Rr9KnrlhXr5EB3JD+xz1sxlM0sFSjTBQ4Q4AoFA +YEcQKPIovzd+/F50LqPMU+2XOTQgl15BWeUZpZKWwpRRsfwwW8wYcawoCDXN9qb9gJjNZf8juFKZ +KVZuKe+piDyTx4lvqTlXayn58Em1pFcHk2HoyZQ2PoC9tb6WQkWQybNEZa+UMOhQnHcWgRoJUyGr +alOuxlfMcs1OyQZFXlpB41EXcmOXLTUPLSnXIFuUJBOSwkbvYUmmByi3zMsZGmWAOFbYIxdyuX0u +eBaUJlsuy56neq682Fx2g1zY0MCqYB7icPOOevXJ5d6prhbHJi4DDL1O2mJqv1e6xHWlpd8sTmPj +Kti0W128OKUpjDKrfNleA5wqpx5/rN1ePnxkjmI5uJZMyJtkcqMyt1g6w8ytHifo5RatJ+L64xoc +/pS4iEm1DwIhl+fL5eupguwe0js/XG8aorlgUcI4AoFAYGcRKPIopfPb45e/VjWkkuQGq1G74U1j +hkaBlWFU1hwwllxPLYdMfql0okS5qGnjBXYn6KR3D3hOSqHY28uRKlbt4UBvchrhuH+XDbSpoUqb +qNEX1YwZq36gTf6DOMWd5gunJg2LUv1qQPqrQOWnw4XNRM3mCkLDzTOuFS3o3d4ES81DN0DpehM8 +i+vXMTYbG6wxQ8gLQVOIOmgmeOh6r2tUoCjMLLRUy+X60SxoCg0Yq8kzbtgSa8NM44aZ0slun22B +uVPrMg/SqB5i0RBX1nz7G+3OBfatJ6nVYJeP+sKZqX6HZ/dtbSiYbvvUqsHg7KlT7Kc1OzdHAyh2 +9LCGVSvTjerMUveSounK5SZQLMmVmKKE/OVBBptzSF9ZsBNBLQUexco0JHGovBWhIBONIxAIBHYW +gTE8SgX2U+T3v1ZlboBgZkNN+g3bwMHQa0wpVxX/EtrT7vN8SYsVR6qC23ft3lOTosoKWL13okVF +UCNeqo0Vcg01hsufpBxS9ECTN1X0Uc46u+FRoCz1zTHtpKDyVwYvBGVfCb0vlLZO19xsrLDVvNjn +5awVLeg9i+k91QUM8qRczpPG2qN0vckWWkZLykP0kAQhR0FvSgvtpCPngkVzs7GynSaSKN9OjYVW +nRfiUS/ENaOC23hRJrg+FzyJllBUrTJDqHek0iHLQelQ/RklPk7aX+bZwYWzZy6eW2o1WjOHq0tL +y1yBPBBY5jNraQsqvtV38cJ5vpcwe/SYXfZ5XZlcbtTnWLXLRZqeM4gymW2xCV7CxIdDVuU66uMG +D5b4mDdl0i4Lh01c4U4KX23z5XJWb4iBQCCwkwiM59FN1sAv1gcgy4LG85LkN8Yi1HTLbCOmDS4Y +i2sZFDT3xaSW2JPRQyMZnMi7B9r2nUmvcq2lOV62u1HhjG9wZ5pEozT0FrpgDZD9yrictzOXzdLC +tfS5zVhLMo61yZVu40Keimz6PDSDXINs0UJSrrSikuGqcR41Y9Pk9RZsPGr2NmS7vTVgNARzg31U +GDXONdRiWSw7Sa4xM2uGZ/GoCXnoNi5YKiW74EkmjE1yZaFw9gpmedGx49P12vkL586y3eShmWme +yLNFEt8lYApEd41cv+wv32lfOH360Nyc3dt5paRaNxFqZZ6k6oHssCVc63bvmmZ001P9FYrl2Qar +d8u4pIc4HRxkIaQQDsvusmlc71WHEAgEAlcDgQ141H+K9ssf2wKzyQ3Q2DDEmIDEb51fPOMLSsn6 +WpkepjJkYKh5LHmiei+F23nWFenjpNzX8yLBtAiVSslohxOnCVa1V2eCNdKVZPRm5wauLAgFG6IY +5IUQRWn60byWWtB71HLloSWpuFSRC6N6LwTBzHLjPHsum7GHNvKOlpBnsWItxJKDPYFNsNCMc43j +Y6fJonmYG+ey23hGFzCjIjPIs1jteWiWeatMzvNasWuViR4DcpkZgslmTzh6TB861Gy1zuOYzi9M +ad/jhha44Vqy4Qbfp9NX12psbInnOjt3lGfzlECZhF4RMi8ft+pHF5ZPc5nrRhGV1uIRaActXbhp +pheBRxdsLN2vaWrXTiKlIWCitqaSTfYQIY5AIBCYAAKXjY/r1Gc/VIaAtWwwsAECQTS5ErUM/Nyl +YhDhZ5/meCkHBV8Kw1ivasKgqXAbyCwkyQ6iCJbFa7GWeLQgkIrGsrilCakhw1TTuD7PYrInIVhG +z1KIut4sPdWFXI/S9SYkhQZSOzzqAnqTCU12jUdd47lM8AHXDRBM6Ul54WZmSW5p9RLlyGWihhWh +C6a0qDKMO9xY2S4/ON1Uga5QkRXjSgQ70CN4JSaT3TVWPFEr05NcsKTc3uW8ZFciwGNHjh1vLy1B +lsyRTPHGiyrkfrACp/LQdNDR53UunDkze/QoeydZ1bJY4WzkZvXI/OC07inZ/8OWBOOV8o80dSr9 +4WRBz1VmaC4oKR356UuWq1fFME/8CQQCgYkgsFkeXb8x/K7z8ch+5wyFqwNHGnQYJdDwpJQkGwUQ +OCgcNYKHDENWiIXoETDzXERRojG9hRY1vctuicaVuZDUw8DLMYM8aVQerdpscj2yRb3AXGNKM3C9 +Ca4s2BTKcbNCLot6Xk91gaQ8NZexyaPITqiehDI/DPNCmEdz44JsF4CdfbIgWCOR7SjYWyrKvDHW +wlxjufISrCI0JA2LXrmuTOkVrR91MxNY+z133cnFixf5minb9upKl6fIzGyJmV6+s8AOvWdOnTp2 +4gRUallopzejzjqmcmtQWiJJnii3nDzbMPdUi5aUgxPCX76bOhhcYt26HuAmT9R7bR23wiMMBAKB +CSNw5TzqY5YNT7TbRwcTcgNPsvHLojZiMhb40OmF5EobLLCxoYe8fhhY6NHkqabJU122KizquYha +dtN7qkexXEtpSYQmYGZCUgxzmdL01h3XuFkurJNq2a2oPIvJuX40dbRYNHmBuYHJhBwFGzRWUUoU +dBY1DAk53ADZzEZDS8LS7O0UW9QuCTPIS7BiPTQhb55p8rq8EMwoliQv3JI8SpLX5cJogXnhJlPy +oSNHlpf4Ct+CvoogZ9JOvT5+x3I7HnJePHd2du4Yu2AVslPRVOPopfZjrgcwve+1QqV26aWGcyL4 +duB8vdzCuACCZw8hEAgEJozAejzKD9VHk3Wa5b9njPMsJrvSomZspbmcJzEkWaWWamMfMoePg4Wo +6fNUyrd6vdlkQWOHKxHQ59FR2QxGQ89LkqVaXotaOFbjSZarYG9R+jJafm5peQtmlsWScmPXW1Kh +5FxpuXIDZA6ryGQLPdeoEpBRWpgLuaXJbmnnhTKhNJdNIMzryltoetO4npJNX6g6L9YuFS+fKHJu +b9G8kaOy12JJ1KqPqNdr3YUldtzCf+TCoukAMdVo8LYM07bnzpw6euI6PjaTl0/2Vv3IpeUncTTJ +ldqRHNMVLlbT0jRvWsc7aPfPT5f0TW/v+LAB8ScQCAR2CYH1eHS0Sfx0C0MANq50wTOicZmMZuBK +G84wcAEZM4u6EnsOojbZa/aEuRuBARoLsaQQG5GVc4VB3QBhtBco7cB+RdRfi6qUEb0pTe+hKS2j +Kz3qqTTSZTczzdhQTbl86CzkKqQm88uG2tzejd3MNHm0oLHsZlAIPSlH1ZRoPLWQi6jZE/qBMbKz +qWVB43m9NAQ/SDXZBA8to4e5gD1RrwjBq0BvqWgsiyflgidh7PpavVE5VO0sLPC2tLxKjLSYTuzI +yiOEp5544mk33eSXqGWsVdmC8lBncF4bMqwcwzdh0tSu9MNCmN2dXzGJv4FAIHBNILA1Hl2ryT7u +2JjC4FHQWEbXWyohhyUxsthYZoKHcCcyNqS6DVHL60mmIdTAlcZHey/eop6KwIHShDz0lhSUprfq +SMqjuTyaZKm0MM9bkK39piwkEbUyc31BQ7SgsVy5MteYXnlWOuKyVzeaZBovx7KsE5rlWJALudzS +TpOH6F0uZCFKKofpTbbQNWZDaG2w0KJerAmWxS4806xFqGY5NiSjtwcDbZs1O9uen2exLlcvXMqF +yyfY7KPry902VHrDjTdimV/PU41jneXzVj6dY254ldlTX0WraRXScm++12vXas2xjQllIBAITB6B +DXiUAYJhIm/WqMZSXW9jig0ultc0ZuZ6G0TyocTNPMlI1BiUjOgpxEY6ZOxNNsEMCDnQmIA9QiG0 +luShVW2h6ZHtIIpgoQseHRplf/Ikl63lmdVqgV6mp3ouS7LoWGWeFwM7rJyV2LDxRN3YZC/cc+VC +IdXabwbrhOQytN2mUI7rTXBjy2inzM+XRbF0M2QrkNAFU+ZRK9yNEfIyLcqVg5JcdnWh9OvK60WZ +H3kzcr1XjWAH93C1ubnFCxdYMASX6kPgpQEfce/0uuw90l1un37qqePXXUchAGv1NuuHKu3WYLDE +Jc7lZl4sBhJoGyHb/KqR/FtgQwbW+eZtCDkQCAR2EYENeHRsyxgsxo4prkcgo41TZmkaK831Zu9D +iQmWanIeMjbZiEMhLmBAIUStKASrzkMTrDFW+2iYtw3ZohZinBTDgKjV6DaWYGaWVJDzEnJ5tIQ8 +1WTX5EKehGyHlYbsxRbkdcwKSRb10Et2zfqC2yM4+GOzkOqtNUvLguxRMprsJXj5aJAt6oKbFQQz +SwXrporrxC4nNCTZ5WSC2RD6RYWeqFVnQqFwSzIlxn7MHju2ND9fusSmuCVc0y6fEGVjZ97v6g8u +XURZZgWvF8u+I63a3GLvcbtpNR5NPyMVnJ6MDtlUpQ0WGqXD3iqrOsJAIBDYLQQ25lF+8KPDx1gl +fXA9AlEyFjTWT9ObPQMW44uNZQiWi9BkstuIZmZEOcweDeVYUSagN8FCLwphrYPSSPIwF5A9ajam +IfS2uaZgQNRtCvKo5Voa0xPmgsuFtiWrYWBJBUuP5pYuexbTFKJutiVh/UJI5TRRICGyR02wJEvN +KyXVoiasFc2z5IVY4XZqTJ9XRCoXFQdJZkMqh9WSC4XyMbADvQlkR5g5coRrBce0VC+32232ycVT +5bVSfMxzZ86wC/Thw4c9Y6s+t9R7iv3u/cmo12IaoQWJ9kpLnQvTjRss1VvlxiEEAoHAhBHYmEdp +ED91fq6Flo1V5sYY5FnyHzxJjFZWAiMOSYQ+fhF1GcGS3MAdU9Ng7AfVIVvogrXBot4kEwhNwMaE +pBgyq8mF0CxzM5rh2XM5t8Se6Foa06f0YTPc0pVegmtMMEsPR1PdrGAzGs0tJyPnneIEGaqFM2XR +vD15LpNd40Ju7zKpXjgCJ4uQwwwQ7GIzM7sCU/qqgRl7OXnJyOg5ciVR3oeh1vmLF9kTSt/J7XVx +SdkMGjp94tFHm41Go9nEjJLrtVatcmhQOq8y+MdcMPuA6S+sLoUpSe30LnhLvLoQAoFAYLcQ2BSP +0jj7qRdaOVaZG5tBISTq7OhJ5LJxzcYvZBOMNd2M4cPymrHpyYveD2skURMKIVlMg2ByQRiNYm/K +sUlrpbreqzNNHs1tKDw3yGVLGqtBWTjc2PWjGk+6FoS8eZw1ohxrnT4aTKqH1v5RTaFfeYEuI/jF +ZrKFdiGZmclWmjXJQxO8IuxdLgiHjh5l+e7CJX12jfldtrPHV03Ld8uPP/rYrbc9nbwcFNiqHVno +pdVGXLypPD0ZRUicqg2PdM9GIUv9AR/n3eyPt9CeiAYCgcDOIrCFn6L91AvVj1Vig56QocEEl230 +MRa0sFCgEScDnD/BwgwbNFaX10hRXoIVS2iClWmyNwAlskUtNE1Bn0xWzSxqBXoSwvoaTzWB0Mux +vF6CJeX2nuSCF+LCaNKoxo33hLBW+zfUr2VQ6LWZEfpVgWDXD4LdnFkSGYkie9TlUQFjlF44gsl5 +7WgOHz8OcXYuXtQ6ox5fytUEL8tuFxcXzpw5c+z4cewxq9dmKn12lu5yffGPW0FdaIlHVRGffEn7 +M5Cx21uoVg7ntYQcCAQCu4XAFniUJvJT98HFW2wDx6g+tzcbz+JDj2k8auUzuuUVkWrDHMbIOXcS +tSMv2WUT8qpNJnTBbCgTwZQmJBORpVuaJrfJU5HtGM24knJZ+SgLRbmZC25gmkLUzfaT4H1E4Myu +1TU3W8tgHb3lpfC8ECdUq9dCv7SsJR6a3qN5OWPrxZJPvsxddx0rdxcXF9nTrzsYEPb5Pm6lzNrd +Q7OzbM7ARV6rNKvlqV7pYrryRKDwKKTL+6Mi1HSkmV7WLS0067HUaCzeoQwEJo3A1niU1tmoYYNI +3tgN9T7ckBfZQhOQObw0VxYEDBhrCN3YhEI0L8dkykGwsJCK0g63JGrGLuR5TbmOgRvnlihdb3Ie +uqUpC9Hc8kDJVw+H0ZLRcBVxcIG5DNqmNNhNdk0hOnpqMLD7PyuQ+ZVjJ0+eeuzx5eUlHszyqZfa +oNrlccZg8OTjT9x0y82UgGWtfHhQvqiq9T17PRxNl6MENNzv8QPgw23dfvr6d6qVisg42oDQBAKB +wGQQ2DKPWrNsaBht4ob6wg/ehgDLZQOTl+lKNJ7kzqgpzZhUz5ULeV0F2aKEJpDLhEK0oJd1NmC5 +nNSrA5nr88Z4Ua5cy8wNQrh6CAC+XXtUgWz0iQzb2cXmF5UJpsTAU3PB9X5OLZfVYmyKDQt0j11/ +8vFHHqmUK7wIqm/s8kn7Aa/GXLx08SIfYiNXo3Z4uftotaI1vXboirPveydaRYZKlzoXvYqhXfwJ +BAKBXULgCnmU1tqQYT/mvPEb6n2s8VwUgpIDwQ6TLTQz9AgW5hnzVGSyeOpa0dzGZRM8dH1eiKda +FbmNV1pQFqJuFsKuI8Cp4XKyML8/M41fafmFh+wH7Ycg8+jouXZ/1ASM+TgM31A7e+pUmp61t2u6 +1H761Cm250WoVRq10gwrfO3ekMvZ7hIR9BappmMUdPvzuLt80n7XYYwGBAKBwJXzqGFnYwcDRAHK +DfWjgw6FoDS9DU+UaSVbklVhmkJ1a0WtNE+1qCsRXDYbi+ZhrvdyRpWFcgqWEb02EfCzZhcYUQSX +rc1EETwsCCQ5m5qc57ICjUQJrbpZtjqan19aWsLjFHGmb6tR7Pz5C4ePzvFycr1yuF3W7g060lKj +4T4M3fSBUnLxkml/udtfalRgXDXPO5LyRBAIBAITRWC7PGqN9Z+x/aq9BxvqPTsZMc6ze15sTJ+n +ehWmzI09yZUueHUbCl4IwlrZc5uQ9y4Cfn65lpD6MKAcAAAgAElEQVQtWrjYXGl6I0WUxpEoOXIZ +NNA4Jk6iaMh19OTJbz/0DXIwwcuaOnbfxXj+wvnW1FSj1eQt0vYArmSB0XBPXStIi+F4AYZ/vE5a +7nV6Fxu1GauC7NZCrzGEQCAQmBgCO8Oj3lwfblxjwvp6N3YzhHwYsqiluvFaQsHMoy6QMZfzcgr6 +QjS3DHk/IWAnmjC/6qyDluT63BJ29LezzMBCKyfXFLDic99Hrztx6sknqU9PSVlC1OcV0978hYvH +Ws16dabc5cveC2JNVhtZZj5HKjsuXYVQaafH1K4Y1ppUqCKigUAgMDEEdphHrd3+w7bfuXdmLT0G +njRqbJpCUW5mwmh29GOVY+3XsSxUFNH9jYBfCQijl5wp0ZuZPVW10J1RBDdwrLwoBOzRM7vLLrvz +ly7WKrX0Oim7BZbaS0vseQQ310qHO6UFUaYVkfYzQoZT7UEp69Y7/SUvP4RAIBDYRQSuCo96f3xU +8nHEktbSF1K9HATPkivXl0ezjGrWLyFSDzIC+dWC7Newyyagz0nUadXNMHBLBIwJOeaOH2eTI1iX +qV1czXqVLezZmmF5enamUZld7j+uz45qKlcPRIeMmrxSFhrxxLTbXfKlRlbFQT5Z0fdAYBcRuLo8 +6h1j1HDZxyM0uX6sgStHhbF5zWydpNFyQhMIbAYBu6gI7QJ2gbzGnaY3mkTp1zkCh2VH8Lpa01NH +js6dP6eNANHqK4Hl8sKli/BotTxdHTQH5WV+N3pMygTvSjb9kOTQanfAXr/DtLAXvmISfwOBQGCi +CEyIR/M+2YDimnxkMWXBwC1d2NDALUMIBHYcgfzyQzbi5DI2r5TqkGFWoiZjg4bDMiJYk4geOXZs +8dICDIpXyqQt3/zmMeny0nKDDexrM0v9ZVhTvmh63cXoU5mJYlxa7PfZyGF4ePkrivgbCAQCE0Ig +3dlOqK7x1TCabPUYX1BoA4FJIeBXLBVCmRZF8AMNsumxQSB0BkWwo1qrHT52VIWUK2wSaDZLC4vY +18pHUpRAO+sa96qUxKxWXq/P1K6OpI4gEAgEdgeB3efR3el31BoIbBuBnCZNJjT6zEOUVGVhznmJ +AQeHDh9utlpwLjZswzvAJ+125Nr2ZyDXYRtxVpMowkykiYeKu9vuzw8N4k8gEAjsHgIrP9Tda0HU +HAjsXQScPnMhJ9GxXmnOpvT9CC7pQAQs4mTfIpi0zSdfKrXylJAxJ9QwStsyIEKm2LJbvRflghlG +GAgEAhNDIHh0YlBHRfsTgZxBXV6fSgHCnFELG61Wa2Ya4kTLuiGelXaX2iRV2PZPWy4MH5HigDKD +yz9WHsGt/Ov1FwzTINH9eW1Fr/YIAsGje+RERTOvbQScQV3YkErpkLPpzKGZaqVcq1YbtRqPVfnC +2vLipXK5zaddtOtC8j7T9LB4FAZFw2Kj3mCZ5U0OTLCpQxFCIDBJBIJHJ4l21LWfEXAGdWF9Ks1p +D5e01mhWa1V5n5VKp9tpL7b73b49Fk2eaiJP25ABFk3/ur0Ob78YGe9nZKNvgcC1jUDw6LV9fqJ1 +ewoBZ1AX1qLS0W7xOilup1xP3qXB1exX24u1XtpyQcYkWAiV8qtNPmmv1+312ykhgkAgENg1BIJH +dw36qHhfIuAM6oJRKVH6a8pcQDbHlE3q03YLeseFuV3mbyu9Vk2ZRKLJT11h06QTlVZ4ltpxv9YF +S48wEAgEJoNA8OhkcI5aDhACzqC5AJs6oRqn5ohAgUzn8glSBDxPVhuxeUO/26yUauJfeaniTZvm +Fa2KfRX2S8tWTpBojmfIgcAkEQgenSTaUddBQSBn0PXlHBF4lNdHxZei0lKvW+4us+ooxRNxalFR +muBNxCqx2xvyqJUTbJrjGXIgMBkEgkcng3PUckARMNfTPVETLASRgmPaaDb5rHe70+l22SqQ/yqD +TqNaTZO6sl7FUISaPFS+5o1WXqz82DgCgUBgFxAIHt0F0KPKg4CAuaH0FNYkJOpsalEjUTczTFi4 +y2ZGolG979LvLTf6PbbwTW+/pI+Pik21pleOKSa9Pq++BIMaeBEGAruDQPDo7uAetR4EBJwjTbAQ +NnVCzQ0MEHgUJRQpb7NS6nerFTbfXdlfF8ZM9LoKHv5o8OgqHCEFAruBQPDobqAedR4YBHIGzVkT +2dgUJFyPXKvXKzXWFmm9LjvX97q1Sr9eqV6Gl71OKkLVlkZsxts1KiU04TLriAQCgcBVRiB49CoD +HMUHAgkBqJG/Tp8eRTDZcIJcm1OtNGfLNC7uZ6XbHn7c0B+PwqAUtjK127NHpAFzIBAI7BYCwaO7 +hXzUe1AQcKY0wULN7V7+YTVnUz7/An8KHX2ytNJbquuRaCJOuNP+WbqotDzo9mPJ7kG5lqKf1yYC +u/Ad72sTiGhVIHD1EHCOtCqIMgFrhGohelMipFW7dZbrpv3oB5VBkyel7KOrh6OsWkrrjLTaSDwr +Hu1rl10dVogS4ggEAoEJIhD+6ATBjqoOPAKQJRgQujPqPGp6izK1yyJfdq6X9zlo1NjBPt3xkjvR +pXAUbYpHtWRX8TgCgUBglxAIHt0l4KPaA4aA86ULAGCyhw4JU7vIuJh4n10+RdprJP9TD0xh1tUl +u2jj1RdHLYRAYJcQCB7dJeCj2oOHQM6XyAWX1FJBBaHebPLaKTO7ckD1PdKGhOR/QqJ+GLn2B9qq +3uZ1PSmEQCAQmBgCwaMTgzoqCgSGCDih5kKOjqi00eBrLh3tyNDtLPF8NC3QXTGCViFRY9Zuv93v +9yxFj0l95nfFOP4GAoHAVUUgePSqwhuFBwKXIeDEidZlF8xDtQytmRnWFWl3QN4Pbdd5WpqeiA5L +gytZhaRHpHqFtEtsmBB/AoFAYOIIBI9OHPKoMBBIJAoMzqAmuwahXq+z2ih5nAMekQ66+sS3H+aP +8p3S5JWyD8NlPBouqQMVQiAwAQSCRycAclQRCKwikHMnWo8irBoliT0CeTiqR599eLTGDoF+yBNl +ajc9NGUpkpYbpUekwaAOUQiBwMQQyH6aE6szKgoEAoEVBjUkCmxqnNpqTZkAO/bSrkbmhloWrdqV +O1rWzO+gFwwa11QgsFsIBI/uFvJR78FFwFkTCFzOBdNX+YhaXe+NiiP7dWz5a89E9QKMtmAQkbKd +PY9I+RtHIBAI7AoCwaO7AntUGggIgVHuLCjZ2ygRJ6++1Ev9SpmdGcScckNT/kSrkOtguFW9lHEE +AoHAZBEIHp0s3lFbIJAQMD7MwShwqiU1mjwildfZ7eB1pqVGxqtWCLsdJaE/6PDXp3ZdsEIiDAQC +gauKQPDoVYU3Cg8E1kTAiJNkZ9BcNqKt1Krs16DlREzk9mua1+XLpFCpBK0uUqi3XsSjdgSJriAR +fwOBCSEQPDohoKOaQGAsAk6iLmDmMm+/cECaOKWDHt8lvbwM7cagh6bdbjwfvRyZiAUCE0QgeHSC +YEdVgUCGgHmcFpra6dOTEKr1uhxQ9lvo1PSxF47kkbK8CGmQVhzZvG5KGwbhleZohBwIXFUEgkev +KrxReCCwHgJOos6gWLtsqWwQKBrluy7d4dqiZMOkbooyzauZ3aE/Cn0GgwJIHIHAJBEIHp0k2lFX +IDAGgZw4fWtAUxJtNBspD++Iriw10v4L5pkO1xlBqsGgY5ANVSAwEQSCRycCc1QSCIxDwDxOCz3d +adU0Vb1GWtO6ol61100/WNsEEDJN8714o2zD69lDCAQCgQkjEDw6YcCjukDgMgScRJ0+CwIuqXZj +YHPAfqUyqPEKKfQpAuV/W7WrDQKTYsirl5UfkUAgELjaCASPXm2Eo/xAYGMECtxp5GrKxKN1QkrB +JWWpUb47oE3sQrL2WDQejm6MdVgEAjuNQPDoTiMa5QUCW0HAKTPP5LRqSqZ2E4+ybZE+RJof+tCL +3iJNzmmWEISagRFiIHB1EQgevbr4RumBwIYIGJVi5vRZEFiyK7+zXO6zpVHOo/JNlSAWzQg2lzes +PQwCgUBgmwhoF+w4AoFAYNcRMDbNGZQmWbRWr7O1LtsW9bs1fdC7rFVFcOiwzVq+y7zuZZ8g3fXu +RAMCgYODQPijB+dcR0+vUQScQfP2OaGiZFK3UtMKI3Y16vdto8AVEk1sym4M/eDRHL6QA4EJIhD+ +6ATBjqoCgTUQgDVtMjanT5cRcEkH/R5b7PLVl0F51PVkZreopEAyrlFhqAOBQGDHEAh/dMegjIIC +gW0ikBOnyRRoXMguu/xWG7VWpcQ7MKv16Olo+hBp9nh0NTWkQCAQmAACwaMTADmqCAQ2QGDUcXRO +JScy87p9HpDyFLRXlWalPKNPMzYdbijHSnr8DQQCgauOQPDoVYc4KggENoOAc2GBQYmSvV6rQafi +xz5fUkvlaWtA2Wr61p6SBoNuBuiwCQR2GoHg0Z1GNMoLBLaNwCiVVqpVFhulfXVrYk1R59ApXfm7 +7VqjgEAgELgiBIJHrwi2yBQIXB0EjEGtbJdN4JvevCZaHtT5WJrN7OKJ6rPeHLioMZV7dc5IlBoI +bIhA8OiGEIVBIDAJBCBLqrHQ63MqRVOr8UFv3hSt8E3S4WPRIZ0arSZC9ZwhBAKBwKQQCB6dFNJR +TyCwEQJOokafFiVMmwKW0qsvrDTSrK4mdYdeKfszxMzuRshGeiBwNRGI90evJrpRdiBwpQjkVEoZ +RPX1NFFoddCHOOFRNmhQ6cjD2d0rrSvyBQKBwHYQCH90O+hF3kBg5xEwBrVyXZZQKbPWqDxgi129 ++sJhD0rlnIpYNa8bb7wkYCIIBCaKQPDoROGOygKBdRAQHY4cIsmkZ4tdVu3ifuKHyh8dcqfiFgkS +HQEvFIHAJBAIHp0EylFHILBJBJw1TTAGHco8Jq1WeUAqz1QJaWqXcpErVf7fZBVhFggEAjuLQPz2 +dhbPKC0Q2GEExJiJKxNdVnksyte80wNR9CurjVZmerEMr3SHT0AUFwhshECsM9oIoUgPBCaOQM6d +VL4arXDjy/9pKwYlqGV8fZTFR5IuPyBUy3i5OmKBQCCwwwiEP7rDgEZxgcB2EBhlPjR2UCzrjMSd +eoVUzmhZD0orBJVy3BBvB/XIGwhsC4Hg0W3BF5kDgauBQKLJVTeUKoxKq7Wa9gaUI8pa3TSvK5dU +HurVaEaUGQgEAptBIHh0MyiFTSAwOQSMRK2+glxll11tAcjPFhYVhSaXlD/Bo5M7QVFTIFBAIH5+ +BUAiGghcQwiYG2ohzWK9rm3FAJtqYyO97yKvlDdLr6FGR1MCgQOGQPijB+yER3f3CALOnbTX2VSf +fBm+38KD0rSNkbanL1eTP5o41Zh1j3QymhkI7AsEwh/dF6cxOrGPEIAO13l3RTsaaT/A1aejevcl +/NF9dAFEV/YcAuGP7rlTFg0+EAi4c2nOKH1GwB9NX0/TJ1/0ZFTrduWhskGDgWK5DgRA0clA4JpB +IHj0mjkV0ZBAYAWBUTp0zXBqNy01Gm4QWBKnrmRd/etZVlUhBQKBwFVAIOZ1rwKoUWQgsHMIQIfG +iCaY6wlxan6Xgy0YKvWY1905vKOkQGDLCASPbhmyyBAITAYBo097VmokSog/qhleHo8OeJVUR6UM +j2qGdzKtiloCgUCggEDwaAGQiAYC1zQCMKbectHz0fQCaWmAP6qXStMD1Gu66dG4QGCfIjDmsco+ +7Wl0KxDYMwiYc+khgh/4o2JSvFD5oOabrt4NY7ZnOhkNDQT2CwLBo/vlTEY/9hcCBUa0KKHmdfmn +914U4ptWNa+rY38BEL0JBPYMAqt3snumydHQQOCAIQBH2sdbFGorBvqvUH/lmV72Kw5CPWBXR3R3 +9xG47Be4+82JFgQCgUCGgJFivi2D5nUrlR4Jmt1NL5VezqPkDirNIAwxELjqCMS87lWHOCoIBHYE +AVGnHRCp3NI0u8u8brVm6h2pJQoJBAKBrSIQ/uhWEQv7QGDSCOQ0mWSWFzGvy5b17AiIMHwy6sKk +2xf1BQIHG4HwRw/2+Y/eX6sIGCk6NeZRTezavoCEQ6+U9PS0dIVTr9VuRbsCgX2IQPDoPjyp0aX9 +gUCBROmU2NKW7CJrwZHN7g67S5JJJnh0f6ARvQgErlkEYl73mj010bBAQAhAh/k6I6KJSauDEh8g +Tct1kyrACgQCgd1CIHh0t5CPegOBLSCQuFLuJpxaqVbKXR6R8nCUd0hXn4+SipkV6sIW6gjTQCAQ +uCIEgkevCLbIFAhMHAGoUe+PDg+tM6IJaTeG4XyvtSgYdOJnJio86AgEjx70KyD6f40jYPTpjSSa +1hnJG8X5LA9WvzyqeByBQCAwcQRindHEIY8KA4HNIZDzoskelitaqat/eKTZdO7mCg6rQCAQ2EkE +gkd3Es0oKxDYWQScOCkW2aOJRInxlBRCveyZqEd3tiVRWiAQCKyFQMzrroVM6AOBaxEB0SRLjcoV +no7KGZVLehnF0mhsZBZHIBAITASB4NGJwByVBALbQABStBVGVkZ6MqqZpDSpSxCUuQ1wI2sgsG0E +gke3DWEUEAhMFoHkbcoLLeGXJhJd0Uy2HVFbIBAIJASCR+NCCASuXQSMJs0ZzV1SPRnVkbzSFXc0 +2PTaPZHRsn2NQPDovj690bn9iEDiywrbGelBqDooxX7saPQpENgbCASP7o3zFK084AgYU17umA4X +2zuJmkBowgFHLLofCEwMgeDRiUEdFQUCO4PAkCnTgl0vMbjToQghEJgwAsGjEwY8qgsEtowAHOkP +RxHIr2lcvfCiw2g1eNTQiDAQmDwCw6mhyVccNQYCgcBmECgQ5DCa/kCk/M0fjV4e20zxYRMIBALb +RSD80e0iGPkDgYkhAE2uOqapVpGouHSVTHN5Yg2LigKBg4xA8OhBPvub7fuv/uqvbtY07AKBQCAQ +OGAIBI8esBO+9e6+/e1v33qmyLEzCOB9clAWYb/fz2Wicj35klqlUq1ql10/sDd5ZxoRpQQCgcC6 +CMTz0XXhicRA4JpBwKnxMr6s2FYMPr+7OsF7zTQ8GhII7HMEwh/d5yc4urc/EIA7vSN4pXyC1KOW +lBvkspuFEAgEAlcJgeDRqwRsFBsI7AwCkKJN51KcE6RTKQJKO3amviglEAgEtojA6l3tFjOGeSAQ +CEwUAcjS63N5SKEpyZWY5bLnCiEQCASuBgLBo1cD1SgzENgZBEbpMCdO6hg12JmKo5RAIBDYNAIx +r7tpqMIwENglBCBLm9o1wbgzD2mXRXNhlxob1QYCBw6B4NEDd8qjw3saAaNSujC61GhP9ysaHwjs +XQRiXnfvnrto+YFAoOB30mc0prT+5/KBQCQ6GQhcYwiEP3qNnZBoTiCwOQTG0udY5ebKC6tAIBC4 +QgTCH71C4CJbIDBhBDbPkZu3nHAXorpAYF8iEDy6L09rdGpfIeC86MLY7q2fOjZLKAOBQGD7CMS8 +7vYxjBICgckhAFn6tgx5rUGiORpryWOhW8t4z+l38Bpg92br/v5DzFHKV+pt81wHj24TwMgeCEwC +gZw+bSDwAc7HBWtHITqJxu2FOiCG+++//9FHH11cXOz1eo7eXmj7Bm3kjNdqtampqRtvvPGuu+7a +Jj0AFPi85z1/85GPPPzlL505fXqJLbM2aMHeSeYu9Pjx1rO/89jLX37rm970HD7wsE24rOvBo3vn +EoiWHmwEGC7z0X8sX45VHmzYSsagDzzwwPHjx++8884TJ05MT0/vyOh5jQBLBxcWFk6dOvXII498 +4AMfeMYznvGsZz3ryjrY7Xb/zXv++nd+54vHTx57xWu+8yf//o0nb5jle0LXSE+334xev//UYxe+ +eN+jf/j+r/zOu//6rW+9+81vei53Idssebv5t1l9ZA8EAoHNI1Cg0kLGINECIERxrT796U9fvHjx +pS996a233rpfIZqZmeH+APp8+OGHP/e5z509e/Z7v/d7cbZGAVlHs7y8/Evv+Mh/+Oz5v/Of//BL +XnUXL1hp+Uy51NeH+/bJ0SiVbpqdedqdN7z6b3/3Jz50/2+/6+Nf/sqZ/+EXX9ZsNrfTw/I73/nO +n/7pn95OEZE3EAgEJolA7pV6vfuVIbyDVyAYiTKR+/KXv3zm0Ew5vXlr5SBfQYHXZpZBKREdX6jl +yhgM5ufnP/GJT0AML37xizdPpZDoL77jw199ePDz/+2rT9xwRPzJv3KpUir3BsNnpddm97fUKr7T +iz3T+nzMtz/oPfnYhX/6zg/efVv1H//SD26HSquvfvWrn//852+pKWEcCAQCu4gAlJmzZiG6iw27 +pqpmtvOrX/3qY4899v3f//2HDh2CE+z+I3HNNR3oCWW/B5hbaqWRKFngziNHjtB35GPHjuWXylon +qNPp/N7//bn3ffjcG//hD91y89Fuv9zrl7t9+KZkIcIO/ltudwbl6g4WuPmi6E6nX+r2BhJ65Uqj +3rz55L1/+JXGYPHu55zc/G1HAcmY1y0AEtFAYG8gsJnxcW/05Cq0Egppt9vf/OY377jjjkajQRRy +AjEEatsMdEtLS1//+tfPnDmD/dzc3NGjR2+++eZNtpSMOME8obzuuuuYbt1MdXnJX0jHT/3UT+XK +dWQ6ZV1DsAPX6pnPfOY3vvGN2267DXn9BoDMpUuXfuu933ze615cnp6+tNyvixaqlTLkKbCSb7pO +/WsmXbp47tN//oePfP3LtOqGW+646fa77n7xKy6ceepnf+i2/+2e/3DzHc9eM+dVTJD3zkx1n6A/ +WKaDM9N3vfq5v3XPfT/xxjsPHz58Zc+Vg0ev4hmLogOBQGBXEGDgfuihh3hqeP3118MT3W6nVquj +NAqVsO7x7W9/+95778Wrg4cgIVb53nfffZsntr/6q79iSpnaP/rRj7KG5Sd/8ifh8nUrvCyR5nHQ +7Mu060YsCybqbKdLlI4/9dRTUCkreNfnUdYWvefffbl/5PjhO2681O4/dLpz87FaraJFuhWRKH82 +gGts0778mY/+01946w23PvP5L3ttpVq9/wuf+sDvv+tX/+19nQQ+YWeXnrsyo5uotNzp9r95Znmh +Uzpyx839z3zzPf/vl9/6lhdu6Ux5x4NHHYoQAoFAYJ8gwEQlriTuIDN1vW6vkzxR1p3ibcAJ6z8c +JS8keustt77yla90BkrMtgU6YU3TS1/yUvy8f/27//rLX/ry8573vM0ji5+EsYWbyTXAcUxNg7w5 +4EVaS8fpPiDQnXWe/MG7uM4fue/MiWfdsdTtn10YtHv9+eXO8dnebKNar5WBrNTbAqNbg5eXFt71 +3/3M3S/54Z/+hX+SY7jc6bWZVy2V4DDkzfRuZ236gMVcRbd/fqn/1HxvcXmw1Blwv3DiWTd95L6v +v/knFrnvuQKXNHh0Z09TlBYIBAK7jAADJeQBo+BQMiaWK2XYotMZVCqa2vVhfa1WfuUrX4FaXvii +F3a6nVEb5nv/8i//EoeVJGZ6X/KSl4yyFA2gxnanzdQh1U1NTyFDbx//+MfxESmBjC972cvsdYsn +n3zyU5/6FIRHU5/97Ge/6EUv4uGoxvpOmypYbIz9D/zAD6zfbOyHR/JiMaY0ZikpHCjwsdbJzjsz +3z5bvvV5J6rVGhS32Onz7HDpLB8UYrpYy42u4PjiB99z/uxTz/mJX/ibx7qF7AvnheoDT3bPNHFK +B/f98b/4/Ad+a+H8UyduffYPvvUf33DnC0htL1780L/8rx/+wkdwrl/+d9/xna98E8qF86f+/J/9 +V4988WPTcyd/6Od+5Zbn/kCh5M1Eud+gUp6n4pXyDgxMDlD1Wm3uaccf+dpDQDE7O7uZcgo2waMF +QCIaCAQCex4BSKter9ujQSjEDnrFGLph33hphHVJrVZrrPGHPvQh9K9//esph2WxRH/kR35ktEwW +zcLHDz74IO+iwJpkgVlvuOEGaJLGvPe97+UFldtvvx2H9Y//+I8xeOMb38hGCiyaxZLDmvrFL36R +2ekf//Eft+hoLQUNJUMLdBJuoBC6AAhAUTDLo5hRabsyPXN0ul6rNuuVWkU+KMVUEoVeGY+e+db9 +R07eeujYybwuk7mxQVD5lfIX7v3dT9/za6/5+d+4+Ttf8pk/+j/v+aX/+G3v+tShYzf8zZ//3vyp +R//eP/9sd3kRKrUsH/j1/+zI9bf87L/83Jc/fM+//+1f+Lu/8bHRwjehkT/K+0D9KlRa6fUHXc1g +D2aOTHcrQ/w3UUjRJHi0iEjEA4FAYK8jgDOKE8bcphiBYXjlsH6Jb9Y+4BUYiFxuAgVq8K1WL1y4 +gCf62te+li0dSH3uc5/LDDBODLzrxiZAxry0ij07P5CRGiH17/iO7yCV0sjOtgmsgWJFEjzHu61W +AvViYM1jkdTnP/95+JVdIwqFj0ZpHrk8RKAWugAIQDFqn2twWFszzWa1MlXHM6vWqiVmNkGoCkgJ +hPXAygvK5OX5M9OzR1uNMfzSS8pGvUbqX9/77jte9Oq7X/ZjZH3FT/03n/nDd33t4//u+/7WPwSr +s99+4Mn7P/WMF7zKSj372EMPf+HD/8kv/l7nwlNPf86L8Va786cPHbs+q3NTot1G8SIP/+G683+n +N2DKYrpVa820gGJTpYwYjenniE0oAoFAIBDYYwjAIoySsAuHUSkdsCgCTLNWf5jZgyyxdAP2QmIu +961vfSteJkqeO1rqyZPyt+DL0clAno+yEwJJf/AHf0CuF77whTTmM5/5DMQJL547d87W8ZLE7Gsh +O4VDfqxRgoOZmvZmrCVgb90h5CBqHSfM7wbGZrcsM9P92mDQbFSbNZYElXkqynujOG1MiYPClp+O +lkrHb7z9G/f9RaM+ZiOITk03KPUar5xUzz/x8He/5i1Ds3r1+mfcffHUI0Rf/GM/s3j+yf/nf/xP +b737pT/2X/wfx2+6Y+GMJtI/+d7f4Fwi3PzsF1986hvHrr9xbKc2UnKTwQNlUGLNbrkGj3Z71X5/ +9pCuCo6Nso9JDx4dA0qoAoFAYE8jYMSJe2TutqEAAAizSURBVIFgMuzix/pde9rTnvbZz3728ccf +v+mmm8ySjAi4lUZ4eJmQHxrokBCZJLO00CpCyQszzOvCnWyJgHPJO51vfvOb8RHf97730SorkNLw +gHOnk+w8OmWVE1O+0C0PTfPCx8o2+icWUEDhmOHpUpTJY3OhtLqOHVrsLS3Xq/JHoVL2MeLBqJx5 +bji0hGn1lmKtcgr6Zzz3+z78u+98+PP//q4X/VAhqZvItVmrturVIyeeduaR+xGwgfVPPXL/c77/ +DYrWp97wc+94+d/6++/55Z/5/37959/+G/eevPE2bF77tv/+ru95daHALUXTbYGYUi5pcto7ZfzR +comlVTOXarWTALKlAs1YcMcRCAQCgcB+QgCKYkDkFVJCDrjEj0LU9S7cfvvtMOhf/MVfMPXqSsBB +ZlsDnFEefEJRkDQCLilk6WYmYEwthBAtru0tt9yCnrVL0DAPLFlqdP78edqGkpleKJPFRPZkFP/V +S8Cjfc1rXvPhD3+Yd1dMuaWQBtBCwgLHF84yBkyi3jJ3qbfYbmmutYo7CJNNNQnLzUa51aw0Ebb4 +77te9iN3vuAV7/2Vtz/6lU9a3t7S+c+8/7cl14RMo6YyX/iaNz3wVx889+gD9ergCx/83fbipRe8 +6ifQP/XQ57E/ccPTnv19P1wa9NDceNsdd77wlR/+/f/10umHiZa6LCyeR9jyv2Z5qllp1SvNBv2q +Mp2NQJe5jbhlbsEeqBcg2kw0/NHNoBQ2gUAgsGcQgBugK5btQCTm6sFAKC3cTDd+9Ed/9GMf+9g9 +99zDO6C4j9AbTzTJTt7Xve51f/Inf/Lud78btw8li4xGiYq68Gg5mJWFDllbRF5effmjP/qj3/zN +3yTX3Xff/clPfhK2hkff8IY3/Nmf/RnfoqEc3vV81ateRXYOsjCvC93+6Z/+KU9JWYu0fsvdGUXA +tyMj3belRpS2Tl6A+t47Kvd+63xnfmn2+tlGnXVGPBylAfJD5Y2ul3vNgv/Br99zz6//o3/yD149 +c/hYc/pQtVb/ju95xVSr0m0JRjaHQH79W/9LJnJ/5e+88NDccd7X+Xv/87+67Vl6hPy5D/7+R//t +b+KtkvHN/+h/xxLlz/7y//Wv3vFz/9PffvaJG29bWpj/uf/l9+96wZaX7DJrS2+YqU7+KG/0DOjp +wvnFcvv8d99WAoo1+7NuQuyvuy48kRgIBAJ7EAH8Rd4kYVNAfEG2IoJWjUSNCzfZIR5S4lCSxd6f +yXPhXEJOtiwo128osyjJpnApgezOcDwoZRAfpeQNC3QD51FIlO7Tcj7/wm4M+ND2go1bFgTeq2HC ++T0feuDQnT9627NOTk/X2MoIfx4z/r8yEvUqcNufePiBmSPH5k7c4MqC0GkvXzx76tj1w1l0S4VW +L50/c/h4ccUvDLq8cOnIiS2vMMorhU15t4jFY7ypu7TcY0nTxfvf9x/94DO5j7mCc0rJ4Y/m8IYc +CAQC+wEBCAlXkmk6JlHhJ+NRo9LNdw97ZnHH2lP4WP2GSl/ZWyjBHrhumH19A6dSvHA6Tq+pZUNu +xoxHwt9z24Ofe/zTS0971dzhuWaTh7esNNIhOjUpRbceNA8/9+4Nck1PHZm7ZcSmMXt4DPVOT/Nk +Wg+nr/Dgee/KQqJur9Rp9y6eWlh67FPPu6UCCEBxZcUGj14ZbpErEAgErl0EzFnEG+PtEXb1u/32 +26ETd/6u3XZvr2V0EGeU6Vy6zJupT3/603OXd62yQQaHm2nn8x/96FNfrV133Q83D7Wa00zuikXx +S9PWDmvl3pN6Y9LFhV7n0tKZr37kxtKDz3veDwDChvcca/U2eHQtZEIfCAQCexgBxkTW9fBY8Vvf ++taXvvQlnkTaatv9yqY4o5wt6JNHrTwcpeP0d5PEwDNgvDFe1GFnpfv//Innv+7H5uaurzeGGzKs ++G97+GLwpmvLRXtttD24eOmJr3zwfXODc3Sc7gOCm21VCB7dKmJhHwgEAnsDAZ4LspgWLuElFvYe +4kkhS3sImendT2wKg/K0lefBuKGnT59mLhpPFBJd/7Fo4RQyB04uJjZ5P+cT/+KX557xnDtf9F23 +3/XMI9edqKbveRfs92iUvQDPPXXq4Qe+9sBnP3/ma3/znOc857u+62U33ngj3d9Oj4JHt4Ne5A0E +AoFrGgG4hEePuBrM2rH0Bl+NZTUbbvFzTXdpXOO4V2AKl57yuTR6irxJT9QL42EwXIIXyxNcCJX9 +CO//k/d96t+cw7U1T9ct97TA/RMXA3dX3FF93+tfT3+RuXug+9vpV/DodtCLvIFAIHCtIwCjsETW +qJRnhxwsZ91n3MDtAmTAQTeRr8zbNipl5wd8WV7XYYoYN5cDrPYHXMDCwWwEByuwOLh12OoNx9jL +PXh0LCyhDAQCgf2DAKOn0YxRAotx9k/fUk+gwMQRWl27zcNuO/BomQAHKHz3/UGiBgso0UGDa5s+ +aI5z8GiORsiBQCCwnxEwstnBAXS/gmUQQTncf+zXPu5gv7Y1KbyD7YiiAoFAIBAIBAKBvYhA8Ohe +PGvR5kAgEAgEAoHdR4Ddj2lE8Ojun4loQSAQCAQCgcCeQwAS5dM9NPsKV3btuQ5HgwOBQCAQCAQC +gZ1CgFeD+LAdX6WlwPBHdwrVKCcQCAQCgUDgQCDgJMrLM3Q4ePRAnPXoZCAQCAQCgcCOIMCH2c0T +hUSHz0dZCL4jRUchgUAgEAgEAoHA/kbggQceeP/73890rpHo8Pno/u5z9C4QCAQCgUAgENgRBCBR +vuL+tre9DRJ98MEHjVApWbtg7EgFUUggEAgEAoFAILBfESiQqE/t0t94PrpfT3r0KxAIBAKBQGBn +EOALB7knCom6V0oF4Y/uDMpRSiAQCAQCgcC+RIAp3HvvvdeJMydRZLocPLovz3t0KhAIBAKBQGAH +EIBEC8RZIFTqKP/ar/3aW97ylh2oLYoIBAKBQCAQCAQOHgL/P+31m0OBwkolAAAAAElFTkSuQmCC +If you see this screen, you’re done with the install and everything has installed. All you need to do now is reboot and watch your computer load the new Chameleon and enjoy the extra features that it has over the previous versions!BootingChameleon is setup to automatically boot your operating system with the default settings but has the ability to pass variables to the kernel. You can pass startup options to the kernel by pressing any key when you see the boot logo and the type them to be sent to the operating system after you hit enter.Advanced OptionsAdvanced startup options use the following syntax: [device]<kernel> [arguments]Example arguments includedevice: rd= device name> rd=*<IODeviceTree path> (Device name sample rd=/dev/disk0s2)(Device tree sample rd=*/PCI0@0/CHN0@0/@0:1)Kernel: Sometimes you need to use a different kernel for testing, or you need to use the old one after an install that didn’t work the way you wanted it too =)kernel: kernel name Example: mach_kernel.voodooFlags allow you pass arguments without having to make them a permanent config settings. Examples of valid flags are:-f This forces rebuilding of extensions cache-sBoots into a single user command line mode-vVerbose, boots in text mode showing all debug info and errors-xBoots into safe mode "Graphics Mode"="1024x768x32" : Tells VESA to boot with this resolution, the x32 is bit depth and is only compatible with VESA 3.0 and uprd=disk0s1: Tells Darwin to boot from a certain partition specified in BSD format. Disk 0 specifies first HDD and s1 specifies first partition as 0 is the MBR.cpus=1: Tells the system how many CPUs or cores to use, useful for Core Duo users.platform=X86PC: Can be used if problems with normal booting, platform=ACPI: another option if normal booting fails-legacy - Boots OS X in 32bit mode rather than 64bit if 64bit is used due to a 64bit processoridehalt=0 - May stop stutteringkernel debug flags (e.g. debug=0x144) io=0xffffffff defined in IOKit/IOKitDebug.h)Example: mach_kernel rd=disk0s1 -v "Graphics Mode"="1024x768x32@85"If the computer won't start up properly, you may be able to start it up using safe mode. Use the startup command “-x to start up in safe mode, which ignores all cached driver files.Example: -x -vSpecial booter commands: ?memory Displays information about the computer's memory ?video Displays VESA video modes supported by the computer's BIOS. ?norescan Leaves CD-ROM rescan mode.Additional useful command-line options: config=<file> Use an alternate Boot.plist file.Boot.plistOptions useful in the com.apple.Boot.plist file:"Boot Graphics"=Yes|NoUse graphics mode or text mode when starting."Quiet Boot"=Yes|NoUse quiet boot mode (no messages or prompt).Timeout=8Number of seconds to pause at the boot: prompt."Instant Menu"=YesForce displaying the partition selection menu. GUI=NoDisable the GUI (enabled by default).USBBusFix=YesEnable the EHCI and UHCI fixes (disabled by default). EHCIacquire=YesEnable the EHCI fix (disabled by default).UHCIreset=YesEnable the UHCI fix (disabled by default).Wake=NoDisable wake up after hibernation (enabled by default). ForceWake=YesForce using the sleepimage (disabled by default). WakeImage=<file>Use an alternate sleepimage file (default path is /private/var/vm/sleepimage).DropSSDT=YesSkip the SSDT tables while relocating the ACPI tables.DSDT=<file>Use an alternate DSDT.aml file (default paths are /DSDT.aml or /Extra/DSDT.aml).Rescan=YesEnable CD-ROM rescan mode."Rescan Prompt"=YesPrompts for enable CD-ROM rescan mode.ThemesChameleon 2 lets you create or customize the boot loader themes! You can edit the file in /Extra/Themes/Default/theme.plist. The following variables are changeable in the theme.plist to customize your theme.Images and ColorChameleon 2 has user replaceable images, and colors that you can customize. The images are saved in the /Extra/Themes/Default folder. All images must be in .png format .You can change the color of all the text and other widgets by using RGB color codes. Below is a basic color code chart but the full RGB color pallet is supported.iVBORw0KGgoAAAANSUhEUgAAAVMAAAClCAIAAABulYmTAAAB32lDQ1BJQ0MgUHJvZmlsZQAAeAGt +ksFLFHEUx78zErthLGJWRAZDqJjMxjJ7qdtuewhhhUVXzfCy/nbdlZxxmBndig5dunUrOnReJOrW +RS/hHjsUKKJpnfobJImWZfr+5seyHpQuvuHN+/we39+bee/3A3oGS667rAOwncCbfHDfeDj3yIgd +QsNNJq+gtyR8N1so5Lk6w473qabtJmWtT/7e2I2v6deNkVbs1efi1hmbOumExw8CmsnEQFVxRvKC +4qLkeuAG1NQki1qpTH5ONr3iZI78npyoKt6UvKD4i+Q1UZV7D8gpp7zkAHqcfLdc8QU5QxZlX9jk +Btm07RXW17fJo8L1uFf/Qx6Sc2GkPdsHsh9ZM9HNzbwBPqwB12U7RiTD8GPg8m9gc72bOzqIZqVd +jfuLaSvSab0bwIW3YXg0C8RuA+3vYdjaCMP2OtDzA2gei1WPtZVa+8Yf/s9a9az0wA57oEVndDqr +uUSqFNBoAnNcjGeAd/SRa0D/T6BALmagp9MdVzOkFLiYz00kLauueopS5/Oyl1d5TpHJDi5VnOkp +xj76IPLIYQJJWHzqsNTZSe38S+CWvNZo/v31QsaTFlSeRDPJrbhPvaVqLTCyvLkV0xh3xB3TsFKp +e/gHmVWEZApHLZsAAAAJcEhZcwAACxMAAAsTAQCanBgAACAASURBVHgB7Z0HmBRV1obvRJhAzhIc +whBEJKiwKIKoi/IrIIKElaAr8UFEENPqKmLAFVTcRRAkLepKcBGRHBRwMSASFBQkiAxKzjAwTOj/ +rb5NTVPd03QPPdMz1ec+8/TcOnVu+qrOTVX1nYhjx44pCXmJwKFDh+rUqUMJd91110cffZSXRUne +gsDlEeCGLFasWOTlFUVDEBAEbIeAWL7tLqk0SBDwAwGxfD9AEhVBwHYIRBeQFl24cOGPP/4o6Qy+ +q/T111+npKQ0atSodu3avjXlrD0QiF6zJvLAgYwbbsiqUSOgFkWvXh158GDmtddmXnNNQAk9lWNn +z0Z4oV07FRfnebYwSkI/5v/www9sfVWuXLlJkyY1atRo1qzZ6tWrfUA5ceLEAQMGrFy50oeOnMoj +BKK++65U6dL8qbQ0XURCv34cxj/2WB6VSLZFx41LGDAg+n//C7SIom+/TcKYzz4LNKGnPvnwF3Hi +hOepQioJ8Zi/a9euNm3aMOBj+XfccQfD/ooVK77//vtWrVoVUkCl2gUHgdRRoyJOncq66qqCU6WC +U5MQj/kvvfQSZs9Q/9VXX7311luzZs1aunRpUlISANEL9OnTp169ehzec88969ev90QtPT39zTff +vPHGG+k4mjdv/t5772VlZaHGrIF+ZMiQIfQj999//3//+1/PtCLJCwQijh6NHzKkxHXXlaxSpdgd +d+iBOnbaNOIJ3boZM4WsrISHH+awyKRJVCChd+8SDRqUrFy5RN26ifffH7l9u65V5N69id26lahR +o1jLlpHbtmVXNSuryOTJxW++mSTFGzcuOnYsGRpnHY7YGTOKtW5dIimp+HXXxT/6KLIis2bFP/NM +9DffEI8bOZJC0U/o2bNEcjKZRxw/XvStt4o3aZJ4773RX39tZJJzffRZO/2GeMz/9ttvQfNhboVi +xTSsNzgD3UHHjh137Nhx2223lS9fnh6hXbt29A7Vq1d3R3/UqFFjx469+uqre/bsOW/evKeeeioj +I2PgwIG8pLBhw4atW7e+//776NMLuKeS+JUjkNirlyMignyif/wxO7fMzMROnaJ/+OF8//6OhARm +6Yndu5/87rsL3bsXmTYtdtmyrFdfzSpVKvaTTzLr1Uvr0YOEUb/8ktG8OUJsL2blyrj4+LP//rdK +T6cXiNqxw1GsWFb16qzzjSIcDn6w1bhXXklv0SKtW7ciM2Zgz1lly17o0aPI22/HjxyJRsZttxm9 +wIcfpv7zn5G7d0dv2BB56BAJdTxq48asWrWYCMQsW0b35ChVSqWmxqxZE5GWdnrxYtS814cTtguh +tHzM++DBg0BarVo1C7Cff/45Zl+lSpXZs2dHRkYytjNuT58+/cUXXzQ1Gd7fffddDln5N23atEWL +Fr169ZowYQKWr3UqVKgwevToUqVKETFTSSQoCMQsX+6ZT/Tnn2P2mTVrpt99N2czly+nX4hZvfpC +165np00r3rp1kXHjVFSUIzHxzPTpKj4enVNffx1x8GD0xo2O8uWjt2yJWbhQnTnDKG2YfUzMyU2b +MM7ELl0iV6xQdDQOB0t3Ul3o1SurYsX0AweiJkyIWbAAyzcGf6VS33rrQu/eRKK/+opfz3D+uefO +Dx1aZOxYuonM5OTTK1dG7tlT4vrr2b+gXJWY6LU+yD2zKuySUFp+bGxsuXLlDh8+vG/fPguOu3fv +RlKrVi3MnojextdCU/PAgQPnz5/nUL8hp3XIim5C61SsWPHPf/6zqR/aCIuX0FYguKWfwDKLFCHP +hMGDYz/9VGcetXMnkahdu4q1b28WF7l/P/GsmjXPPflk/PPPq4yMc489lpWcbCikpiYMHBj72WeM +1Q7najwiKysiPT1qzx5OZjZqZIzJbiHiwIEI7JNC+/UzxWz7I488dQpJ+sXJXcZNN5kK7hFH0aIc +OipVMoTEIyLoQYga5Z4754iM9FofY7Jhr3DVVVeFeJ3fuHFjIJ02bdq5c+c0tj/99NNnn32mR2k6 +BS08cuQIEcvQXbZsWd0vaLWjR4+iU7p06ZiYGJ1KfvMOAcZtYyTkzw1tbUWZVase37fv+P79+u98 +375Ugwl2kalTdX1YqEc4r2zMkiWYfUb9+id372Z4N2urH8JFpqSYEh1xlCnjiIoifnrRIjP/0/Pn +G3JnNaK2btWal9mEdw4nrsydaxYdz6k+Lk17/QvlmA+SL7zwAhP7X3755U9/+hPjM28UL1my5Omn +n2beXqJECRbqY8aMoX9inY9yhw4d3MFnytC2bduFCxc+++yzPXr0GD9+PGfvvfdedx2J5ycCGa1a +ZZUvH5WSkvjgg+l33qnOn8ew0/r0udCpU/zAgYzkaZ07M8wWmTOHQfsM266xsVSPwTb622+j3PYL +Mpo2ZYXPYJ7QvXtWvXpR69a5WhEbm96xY+zHH8cPHnyhc2c27dkdiEhNPTt9enq7drFz58Y/8cSF +rVsZuotOmnTyYi8QAAI51CeAHAqPaogtn637BQsWPPPMM5s2bZrqHBPq16/Pop3xfMaMGYMHD371 +1VcBMzEx8fXXX7/lllsswL7xxhvM7ZctW7bcuezs3Lnz88wnJYQIAUfp0mdmzoz/299iVqzgj1pg +nPwV+ec/YxcvzqxWLXXMGHYFjc281auLjh59fvhw5ufRK1cm/OUv6Z06Zdc6OvrcM8/EPfdc7NKl +Gfv3GwsBJvPOHT5yYLrBBl7cP/6BviMu7vwjjxBJffNNVh+8bxP30kscZubqLa/0tm291ye7ZvaJ +RRSQb/WY7bMSZq7Ohpw7ur///ntaWhpbgNHROXZSp06dIi3bgXQQ7mkLSFx/q0cN//rXv4bLt3rn +zkX+8QfjNvt2l70KxsyfbT/eDrKEM2ciTp50VK5sERuHmZnG9oHDkcXerXOgdumkp0f+/rsjPt6f +cr1k6xTlWJ+cEhQ2ub4hczSnfG5OXFxczZo1PQvlQb2n0CIp7gwWoRyGEoG4OLb0/KyAo1w575qJ +icZugtcQFZVVpYqXMzExWUlJXuSBiHKsTyCZFHzdEO/wFXyApIaCgC0REMu35WWVRgkCl0FALP8y +AMlpQcCWCESz3Ldlwwpgo95++21BuwBel/CsUoTD+bAkPBsvrRYEwhMBnjTJbD88L720OtwRiLiT +d60k5CUCTPJN7t28LEfyFgT8QoAbkk9jo/ke3i91UQoGArybHIxsJA9BIPcIbHeSIMhsP/cISkpB +oPAiIJZfeK+d1FwQyD0CYvm5x05SCgKFFwGx/MJ77aTmgkDuEfDL8vk8lg/g69atG2g5uU4YaEH2 +009NTTWJSdxbx7tAJouJKYeYDDIizT5qCokEJRP3DCVuGwSyLX/v3r281UPgBjpz5sw333wD9b1u +56OPPgqVJaz4gTY71wkDLaiQ6sMmpp+qdu3aVVMS0hBIRPv27Vu1atXrncGkKtuzZ0/Dhg010fCg +QYMyMzN1q+fMmQOpmaYq/fQiMVZQMimkqEq1/UEg2/K19tq1a7mTzp49i9l/8MEH/mQhOv4gwFtT +nmpQD0NGhByzN7nGPv74Y+1HiL4YWtEnnnhCJxw2bBid72+//YYcNvH58+cjP336NJ/9L168GF4j +2IfhMmKcRx6UTHS58ms/BLzw8L3zzjuMP8OHD6e1XgntYLb9+eefT5w4cfz48Y0bNz7wwAMal4iI +COjxYcVHzug0efJkC17cwdzozB2inFRqlrPhdvjFF1+MGDHitdde27ZtG2hDNMjhli1bwAGWYS5B +vJOaFj5y7JlZGDzFkBdh5ChAQNKlSxftRACbh4kcFiPkdBOVKlXS9ERBySTcLkpYtdc65sNsB2v9 +448/zq0Gv50nFryOxrADZyb3Ls7tYLmGMA+1J598EkcXeMjCvHlV4KGHHnJPC+M9dzncW7BrmdNU +d4VwizPCN2jQAMahbt26nTx58u677+YQr4LgwPQeDwIaECKsCOgXWN7DO2bSkxPRqwByMIUkMeVB +ySTcLkpYtdfKyYPLCt1+Jo3JyckM+yaJtZY/9thjRYsWZY7KTcaaEw4siDHhzIM2E4X+/ftj/0Ra +tmyp9fllagHTHpMCMme+YMrDOXLNNddAEz5p0iQcirA4Z91uGjDzKRDW4OgIEjpiJKYcCiOESJhh +ETeRREHLg5KJma1E7IeA1fLxSAXpNe6uWChCjAsxJrNN92Yz28ehFXcYBH5FnIzr3HlMMvV4xeRT +K6/RflGcB3QW9CDcizjJcc8qbOOYK1N3hmsQ+M9//rNu3TrcgeFETFOMwkQI9aAGR2/jmxLk2viR +a8JCfrXTAVPflF95JmF7gcKh4dbZPk+Sfv31V5iw8WNB+zUfvgkERo73O24+nNiVKVNGLyk5y3RU +D0rXXXedVtb3n45zl9Mj0DWwiWBmFc4RplH79+9nl44lOjsjIMMh3YHGhGkUGyU6TgS0gRoXY7CM +s84y5ZqhEGVTyCn0kRAJSia6LPm1OQL6qR6DD06suB15vMeTISycZrPbzyFDd0JCAotS4jx2Ym8P +P/bEmeGjA6sscXoNJvas+fUq1EzIgMbzAhQ6uZMr2xxRV/PYw6PhjPA8wCNiBlwDMG/iAQrewUwh +EWYBbIiw2iIO7zgbAfos6wJ2SYmzn4/3IfbwiMM7zEXhESxx5ll8g6VxDkomulz5tRkC+obMNj7z +eT7tZGbOzdT+oo8k04DRHjp0KGfRwe/95s2biWjLZ5+PbT9GMw0TrnJQdk/IDjanmEowgmWXGgYx +r5bPdv2tt96q0WPvQ4Omf8Gwd+/eTJrY3mPbjyFdy/E4To+AkDkCPS/9spbT50I+zK4BctZoQcxE +ZyW/NkPAavn+2yDzT8Zwr/qs59kjMB9Ne9UJN6FXy7/szcTcinmTpxpCxnmLnM4Cp4NmX2CeDUom +Zm4SsQcC+oa07vD5Y5ZsKZkLUYu+vgUtQjnMBQI5ORHw6oAANyRsGXiWEpRMPLMViQ0QsO7w2aBJ +BbMJPNosmBWTWoUhAsLDF4YXXZosCBgIyJgv94EgEI4IRLDcD8d252Ob2RbSHzhr/rN8LFmKEgS8 +I8DTX+Hb9w6NSAUBGyMg63wbX1xpmiDgCwHh2/eFTlDOCd9+UGCUTIKFgItvXxjggwVoTvm4L+8F +7ZxQEnm+ISB8+/kGtRQkCBQ4BOSpXoG7JFIhQSAfEBDLzweQjSK88vDlU9lSjCBwKQJeePguVZAj +QUAQsCcCAX+xw0ejX375JTTPFie8fKsza9YsQGrXrp1m5rMnYNIqQcAWCLhm+6+88go8eaYvDfi2 +OIQkl888aeaqVas4hBMG1gcINqHTGzlypKX5MEkgJ+hpLWwTsG7Cz2lRk0N3BLzy7YMtaLuHo0eP ++i/kk373tPDwU6L/QvfqSdzGCLgs//bbb6eRcLbDukEENi5+YY9geCcC/Tu/MPBD/0LEa4AKGjWC +/nR/x44dK1euJEOvyiLUCHjl2+cUzEV0CmbQXCb+Cz/88EMzrekl3X+hXJ1wQMBl+TfccAPfcvOG +OWyQEDyY/Jk6opkzde+gQYF178UXX4SEAxJeTfzOBAH2TgL+eZBwn6EJXQz9xbhx44hD8sP4U7p0 +aXg7unfvrnn+wgFir230wbePfmRkJOymZtA5+C9kdmamhStFJ/df6LXCIrQZAq51PtQO8GRDlcko +RBcA0xvcmzjSgJaPBjOS8+tu+RD1QRpJT4H+gAEDoJTD8uk1UGPBj5cIPTvgt2LFinwegA8J8odG +Eoo+uoCZM2dCOBnOr7Vovv25c+f269dv0aJF7nz7YMiMiRetiBAg5MWLARH/hQsXLtTEvqTCOQf4 +E/FfiLIE2yOQvcOHYWP5mKX2gQO79ksvvbRhwwaMnHUmNqz9QGlE6BeQM/KXLVsW4l3iphM+FHDX +QV/wxhtvwOQHVy8S7j96BO5vMoFMDob5ZcuWQR3tzhVve6zdG+iDbx81mDl1N0ocsk2d0H/hzp07 +NRUyCSFK1Zbvv1AXJ7/2RuASy6ep3HAsEYkwM2eoh1Rz9OjRHDLymPNGDrFYJp8Q8sG0zy0FMxxC +H0G/MIhjCYJWY77AXmDNmjV9pLLrKd98+7SablQvl9wR8F/Imqtz587uaYn7L7QklENbIuBa59O2 +a6+9ltk4Azg7+RC8YpNsziOHzpVfvUXsCQH27ylEwvYyv6YjLc1FBW+3ufPEViLbBF7T2l7I9McH +377tmy8NLAgIZI/52CrmzQqcLX29pNe/HFJR90W+P/XG8RZqrORxvIXXB+ac9CAM+MxCOcU0YcqU +KfB8u88j/Mm28Oq48/Dp/Q6mVKNGjWKRz8NUVvuFt2lS80KHANPtS0Zsc2DXEXahtM8cNuRxnhlQ +8+655x745KHohToeZzIs+zF7COHHjx+Ps038auIfPqf5QkAFFVJlFjvMeiDV57mpuw/CQtocqXah +QyBvOXl484eHfAxxevIPOmwWslNFn8IThEIHVu4qzB4HDohJe9ddd4Xz44zcoSepgo4ANySbvtmz +/aAXQIY8ESC458xLKfq9FHehxAUBQSCfEbhktp/PZUtxgoAgECoExPJDhbyUKwiEEgGx/FCiL2UL +AqFCQPj28wN5vcOnX2fKj/KkDEHAJwLs8OXt3r7P0uWkICAIhAYB6/P80NRCShUEBIF8R0D49vMc +cs23Ty/LZ0t5XpgUIAhcDgF9Q0YvWbr0cppy/ooQ2O6WWt7kcQNDoqFBQO83yd5+aNCXUgWB0CIg +lh9a/KV0QSA0CIjlhwZ3KVUQCC0CYvmhxV9KFwRCg0DQLH+XUh8otTI0rQjrUuE7P3z4sAUCWBX2 +7dunuRXcT3lVRuHQoUOQo7lrStzeCGRbfjWIdC7+8Xnd9UotCqTpa5TqqdQ/AkkiujAUaYclXbt2 +PXjwoAbEf2p9WJL79u0L08H1zoCp6xzmzJmDKxRIFvg+GspDLcxJGQ6Fhg0bQpdSuXLlQYMGmTRK +cnXsjUC25et23qRUV6UqKLVBqXuV2m/v1oe6dVfItw/NEcQ+KSkpsBu1aNHiiSeeoEHwJvPiwOLF +i3F2MG/evF69ejHOI/eqjHzYsGEQB+A6iUzgUJk/f36oUZHy8wMB6/f5jyjVXakjSpWDP1uprUpV +wuWGUvjKeVep3UpVVKqvUk8qRZ+Bwt+VMoj1laqSH7W1Txnw7cNorjnOhw8fDv3hiBEjoM2EDZFG +amp9S2s9hfg1YLIAxzmaDz/8MBSdTO+x+erVqzdt2hQh3QEUqcuXL+/QoYNXZSYCEC7/+OOPKOMr +pUuXLqh17NjRUrQc2g8Bq+XrFhq8+UpFKXWDMzJKqeeUaq1Ub6XeU+oZpcpDpK3U887pPWsEHPQc +cGrKT04IuPPwoRMUvn2m93gx1CVCmsragR4Epv1q1Vi6uQJxvQrwqgwtInSgpj4R7VXpYmr5b08E +eKPUavkDlBqoFM70ODFWqZJKOS6u3vsodRXeoHHCpdQnTst/xwnLFKUeUmqaU2JPnPKgVUHh24fJ +D+JzXTsdQQKlt7sXA+QI0fGqrGn5zUxIqJXzoMWSZcFCwGr5SUqddVp+jYuWzFL/tLPOD7jVHPs/ +dFHexk0uUX8QCBbfPgSeaWlpukS9M4+EoD0mmHIkxPn1VNYSfrXxk4lW9qcVolOoEbDu8D2t1Bfc +Jc6BfZCzZWWd4z9RfGvigkP/ocNGAGt+wm/OX/nxH4Fg8e1DZ87OvC6XCNYLxyFCtuvMyiBHwqFX +ZTb/8bdn6qPMDr+ZViI2RsBq+TS1qlKTnS1mAj9dqVilujgPH1bqNedD+/7sJzmf/+nRXi/4/+XU +kR9/ENB8+7AjwLfP87gHH3wQd4N4IvMnrbsOW3H4LNWj/dSpU6E2ZxeQjfrdu3ezd4gmi3YeFmqP +KV6VMXtcnuH7AGVYkmfPnn3fffe5FyFxuyJgne3rdnLxMe+JSjHss8k3Xil8MtIRjHCeZit5uDMy +VKnlSm1XCrNvodRGnVh+/UDAnW8f10N+pPCicv/99+Mkm1EaCnMCu/Qo0aFMnjy5TZs2+DLl/Rz8 +o+nNf6/K6I8ZMwbnCNj8yZMn0eEpgJeSRGQ7BCIcfjcpU6nfnRt+lZwTAZ0O4V7nNMF7F+J35jZW +3L5tW57y7ePUkGf4llk6j+t4zs9evfaPasLrVZmzPBGg76DXMDUlYlcEAubbj1Iq+2HRRVQQVr8Y +l/8hQcA53lvdluAWnaf6nvXxqoyapePwTCgSmyHgZZ1vsxZKcwQBQcATAbF8T0xEIgjYHwGx/Hy6 +xrw1lU8lSTGCwOUQ4I1S4du/HEhXft7hqFO3LpbPPtyVZyY5CAJXjgBbzsK3f+Uw+pUDlm95dd+v +ZKIkCOQNAjLbzxtcJVdBoGAjEM0rXwW7hoW+dprenGYI1IX+WtqiAS6+/aXPLLVFcwpHI4Rvv3Bc +J1vXUvj2bX15pXGCgE8EZJ3vEx45KQjYFAGxfJteWGmWIOATAeuHNpViKzUt1rR0dOkvTnyxJ22P +z7RyUhAQBAorApeM+a8kvfJH8z/mXTtvat2pv/7p1x1Nd9QqWquwtqyA1TvQh/mBEuPz2S/f2/GN +vaXdXon0A2Xjt+Qph4UdAd4uybb8MTXG/O3qv3176ts+2/s03dD0jZQ3asXVmlJnSoRBwy8hTxDw +yrcfKDE+3F7QbJcsWfLmm28uXbo0VB+LFi2iuhDseCXSD4iNP0+aLZkWAARclh+lovpf1T/LkdV+ +S/spB6Z8d/q74buH9/+l/5h9Y2IjYOVRn9T/ZHGDxeNqjTty05Eu5bqUjCo5o+6Mozcd3dNsz4ir +R5AcHa/C7uW6b7txW7dy3VY1XHXq5lMrrltROVb4nlxX3ivffkDE+Az10O9CmwmjFqbOmP/II498 +9913FOCVSD9QNn5XReWf7RBwrfMbJTZKjEpce3LtoXSYNVVCZEJ0RPSsQ7OIZzpg31BJRZMaJjRM +iU/Zenbr5jObp9aZ2qFsh0n7J5WILvFC0gtnMs/QR3gVlowuWSe+zsTaE8fuG4va3WXufrra04N3 +DrYdkoE1yAfffkDE+DjG4PEsgzwf3lMD2LUeeughIpDqeiXSD4iNH26vwFol2oUHAdelrVLEIGn8 +KfUnXfO59eeeaHFC/2HhWhgREdH5p86tNrc6nnG8Y7mOX536auCOgQ/8/MC+tH3MF8rHlPcUmjiM +/2P8C7+98OjOR5HUKFrDlIdtRPPtszLv1q0bNFiQ4TVo0IAZO4BAjA95vkbGZNFnuW4hxtcs+t9/ +/z3uNLTZu4OZk74PNn7PQt0zlLjNEHCN+etPr6dhyXHJunmzD8/edGbTHaXuaFKsiXuDEXJYrYjB +zdOiRAtHKxeX14WsC16F5h7Bb+d/I8nR9KP8xkYay4cwDz749gMixodyy+veoabN9yTSD4iNH6bQ +ML9MNm6+y/J/v/D7nvN7WpVodVPxmxjMWerT5hlFZrhbfoYjI92RjpypQVpWGnuBDPgclo8tfzj9 +MFbtKTSBS81KJZ5l+OmSoHzz7QdEjA/T3oYNGzwx1dMHTyJ9Mvefjd8zW5HYBoHshVzXn7qezTrL +DtzE5IkvJ738v0b/61mhp0ERm2F4aCGw/6cjmPGaE2uaF2/erky7NqXbrG+yfmTSSK9Ch+GhR4IV +Ad98+wER4zdu3Hjt2rXHjh1zL4OrlhORfkBs/O55StxmCGRb/rrT69r92G7ViVXdynd79upn6yfU +X3JsSbONzVaeWOnZZlb4m89uHl97/ITkCSgM32XQcHsVeqYViW++/YCI8SHJTk5O7tGjx+HDhwGW +8Rzy/Oeffz4nIv2A2PjlStkYgQi1yto6HtFViK3wx4XLs0eViCrBEoCZgnsWXoXuCuEW31bRC+s2 +wzL+7dnhHzBgAHz7devWNWHheX6fPn3YtNc8uWzRa4+X+M+AGJ83fDQx/oQJEzSjNr40hg4d+skn +n5QtW/bAgQN443311Vfbtm2bk/7MmTP79++v2fhh5u/UqRNF51SoWSuJ2AYBzbrtxfJt08IC0hBt ++bw1xfs2/n+lGygxfmZmJrv9dBYWx3heifQDZeMvIEhKNYKCAJYPG5drhy8oOUomQURAD/ieGeZE +jM/4bz6Wc0/lVT9QNn73DCVuDwSy1/n2aI+0QhAQBPxBQCzfH5RERxCwGwJi+Xa7otIeQcAfBIRv +3x+UrkiHbXy27oVv/4pAlMRBRUD49oMKp8/MhG/fJzxyMr8RkNl+fiMu5QkCBQEB4dvP86sgfPt5 +DrEUEAgCF/n2ly4JJJXo5gKB7WYa/9/kMZNIRBAILgLCtx9cPC+Tm9dvaS+TRk4LAnmDwCU8fHlT +hOQqCAgCBREB2eEriFdF6iQI5DUCYvl5jbDkLwgURAT8svxbblE9eii3D0kLYktsVqeA+PaFP99m +Vz8fmpNt+Xv3KgccOg6VlaXw1/DNN6pZM1cFHn1Uvf8+TqDzoT7hVURQ+PYD4s+H5xMmVTPAEfDz +zz+bhzrCl//hdRnCsrXZlq+bv3atmjNHnT1rmP0HH4QlJPnY6Cvn288Ff/6HH35Ij6PD0qUuH+oX +Bcb/fv365SMGUlRoELBa/jvvqK5d1XCDXEvFxHip09tvq2+/Vffea5xq0MCIz5/vUitbVr33nvrt +N2PKgPzWW11y+eeJAGw8I0aMeO2117Zt2zZ8+PAjR45wuGXLFjQtfPvz5s1jMq/58+H2QCExMbFL +ly6oEffKn59TJsgJEHUVuRhiLl7jiwLjv6b60crya1cErMwcbduqatVU9+64alDPPuul1az2mzZV +5coZpxITjXhKihGPilKMH02aKLoGLJ++47PPVO3aav9+46wECwKab3/u3LkMsPjJsPDt4zZH65t8 ++1i+hW//yy+/RMcHf75nJppFe+HChaTS+euuhDjvdWkJLF1d6fsl2B0Bq+X37OlqcWqqSk42hv10 +g2j78qFNG8Psf/lFzZtnKP/f/6nGjdUdjvQldgAAB45JREFUdxgbBBI8EQgW334u+PN37txJP6Kr +9MADBm86Yd26dTpSs2ZNHZFfeyNgtfwhQ4yxukYN9fHH6oUX1KZNLku2oBDh4WWzTh1DhUH+iy+y +dStXzo6HeYy3pkwEgsi3nwv+/CFDhnTu3NmsjCbtZfFvSiRiewR4o9S6zoe7+ddf1eefqwMHjOYz +bluCngI43UBdckbf2Hv2qIQEVbSo6+9f/7pERw40AkHk2xf+fLmpcoeA1fIHDFDTpyt8sbKez8xU +Szw+51mzxiho6FA1frx6993sQleuNDqLpCRjsvDww2rQIKP76OByyZetJjEQCCLfvvDnyx2VawRw +g2P87d0LeYwrnDjh+OYbR/v2rlNz5hjyxx4zDpOSHOvWGYenTzumTzciJNQ5XH+948svDYkOKSmO +li1dp7RCeP6yew8gbKrdeeedF7FxsF1/6623cgj1PU/UTTkRZgS9e/dmGs/2Ho/fcY+tz+7atate +vXoI8ZzVt29fmLO1/KOPPoKot3bt2sjxwK2FOWUCGz/P/7WO/v3pJ8ONqrtE4vZGQN+QxkXPxV/l +yo6YGO8J4+IcycmOChW8n81FWYU9iVfLv+y9hTsN+PM91RBCxW+RY+f41TD7AvNsTpmYChIJQwT0 +DWnd4fNz5nDxqZAX9XPn1I4dXuQiCgiBgPj2hT8/IGxFGQSs63wBRRAQBMIBAbH8cLjK0kZBwIqA +WL4VETkWBMIBAeHbz/OrzOePdevWEb79PAdaCvAbAeHb9xsqURQEbISA8PDZ6GJKUwSBQBCI4PWS +QPRFN2AEhG8/YMgkQV4iwA1ZrFix6CVLXNwMeVlWWOe9PZtun7ehPV6HDmtspPEhQED49kMAuhQp +CBQQBOSpXgG5EFINQSBfERDLz1e4pTBBoIAgIJZfQC6EVEMQyFcErsjyIeflj090CO7xfG2BFOY3 +AocOHTqnr5Zbkpy4+t1UJGpDBFyW362bgmAL4j1NuQMJX6VKhuTFF321GdI+/o4fN3Tc477SyDk3 +BKC41k9VIb08ePCgPjNy5EgLAf7Ro0f9F3oy6pPtnj17GjZseOONN1auXHnQoEGZkK44g1eufn1K +fu2NgMvyR49WcXFq5041aZLRXli0INiBhPfJJ+3d/PxrnTsPn1mqV759znbq1MmdAL9MmTIBCT0Z +9YcNGwZ7DyQfe/fuXbFixXwnU3pOXP1m9SRiVwSyefiqVlVPPWU0c+RIiJzV668bcd0dEDlyRPXt +q66+2qDZxgPHqlXGWR+BHODtvuoqVaqUwboP9z7h66+NtHDy6tCnj3Go6TpnzjTiw4a5ToXDPx98 ++zQ/MjLSnQBfA+K/0MKoHyhXfzjgL23MZuZgeJ86VeFjq0ULdeyYatVKdeli4MPEkNf8NmxQ0PJi ++WPGKMjgYddmOeA1QOgM2fa2bUaqihUN1m2MHxcSuOXYvFmlpRlFlCih/v1vlZGh5s5VrVsbbL+Q +Pv/lL17zs6fQB98+Dd6xY4dJgH/LLbc0gc88EKGFUR9mHkh7qjGFcwYivrn6tZr82huBbMtnts9Q +z4If/tzISMNhhg7LlhlmD5229quzaJHauFGtWGEs7L0G/G1g9txmaJIPHcFHH6mJE43M6QI4i4eI +6GjD7CtUwEWMkYfTZ4TRoYRP8MG3DwjHjh0zCfBr1aqlYfFfaGHUP3HiBDkUhRHZGeLi4rQkJ65+ +rSa/9kYg2/JpJ75VGNLXrzdG+4YNXQ3XL58yyDM4m8EHGxebBQTo9zF7Qr16xq8W3nOPYfmw97KD +CBU/PL9//7uCtBcvPddcY5D8h0nwzbcPCM2aNfMkwPdfaGHUZ8uAPNPS0rTxs70PvSeSnLj6w+Qq +hHkzndbphoGeEmrnWVrMcp0AnTZuNrmF9N/gwW5pLo3qVcChQy4pBP4ELcTyCWwTMB3AjZc+1D68 +dNw4HQaBuff+/fvZaatevfr69evhzOWQ7iCPmg7JNyt/tvd0/uzzs8NPPCeu/jyqhmRboBCwWr5n +5W6/3ViuswTAL8uUKQqXm7fdpj791FPRJUGfEYUl/csvG9T9M2YYcu3The6jfn1jj4B9BLb6GjUy +Rn69/xdWU33ffPs5IpvbE5g9fvumcPEULg/PzJ49+7777iOeE1d/bsuRdIUJgctbPk+UFiwwtv1Y +k+M/4/HHjS26KlVybCTzBby8Vq9uzOQfekhlZalx47JXCnpsx10fu4CEu+82fimieXMjEj4BsmcW +28y32Wxr2bJlXjd8zJgxCxYsSEpKqlq1auvWrTs4XaDwqebkyZPbtGkDQ0v79u2nTZsWHx+f1zWR +/AsIAhFwRfkZePtr3z5VvLixM+dPQJmlAeM8+3nhHLZv34Zp8Twfx7Wh/UoXbx+QeWPw7pcDlv6U +lBQ2/MV5tjssNo7zlS43ZABGyeY/L/n5H3zMC/zPRDSDiIBe3lsyzImr36ImhzZD4PKzfZs1OFTN +4a2pUBUt5QoCFgSEh88CiBwKAuGCgIz54XKlpZ2CgDsC7PD52uLz+p2Jmd73DFbSmkARASvNf+Yu +lLggEBIEDAbOkBQcnoWyoRqeDZdWFzQEGJX/HwS7wKDdB5jPAAAAAElFTkSuQmCC +Screen Set the display dimensions to use when in the graphic user interface, will attempt to find the closest one available.screen_width <key>screen_width</key><string>1024</string>1024 pixels wide screenscreen_height <key>screen_height</key><string>768</string>768 pixels high screenscreen_bgcolor <key>screen_bgcolor</key><string>#222334</string>web format #RRGGBBiVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAIAAAC6s0uzAAAB32lDQ1BJQ0MgUHJvZmlsZQAAeAGt +ksFLFHEUx78zErthLGJWRAZDqJjMxjJ7qdtuewhhhUVXzfCy/nbdlZxxmBndig5dunUrOnReJOrW +RS/hHjsUKKJpnfobJImWZfr+5seyHpQuvuHN+/we39+bee/3A3oGS667rAOwncCbfHDfeDj3yIgd +QsNNJq+gtyR8N1so5Lk6w473qabtJmWtT/7e2I2v6deNkVbs1efi1hmbOumExw8CmsnEQFVxRvKC +4qLkeuAG1NQki1qpTH5ONr3iZI78npyoKt6UvKD4i+Q1UZV7D8gpp7zkAHqcfLdc8QU5QxZlX9jk +Btm07RXW17fJo8L1uFf/Qx6Sc2GkPdsHsh9ZM9HNzbwBPqwB12U7RiTD8GPg8m9gc72bOzqIZqVd +jfuLaSvSab0bwIW3YXg0C8RuA+3vYdjaCMP2OtDzA2gei1WPtZVa+8Yf/s9a9az0wA57oEVndDqr +uUSqFNBoAnNcjGeAd/SRa0D/T6BALmagp9MdVzOkFLiYz00kLauueopS5/Oyl1d5TpHJDi5VnOkp +xj76IPLIYQJJWHzqsNTZSe38S+CWvNZo/v31QsaTFlSeRDPJrbhPvaVqLTCyvLkV0xh3xB3TsFKp +e/gHmVWEZApHLZsAACAASURBVHgB7b133BRFvr59yDlnJCpZkqJIDi6IIMecAHENuLqu4nrMrBkx +YVzEsGvYVUFE5awYQFBBQQRdRUSUIEFyzjn5Xj/r3fr0mZ7p7plnQs/MPX88T3V1ddW3rqruuyt2 +oV9//fW/9BMBERABERABEUgvgcLpTU6piYAIiIAIiIAI/D8CEmDVAxEQAREQARHIAAEJcAagK0kR +EAEREAERkACrDoiACIiACIhABggUuffee9Oc7Kuvvjpt2rQOHTo40121atUrr7zy7LPPrlu3rmHD +hqVLl7ZnPU7ZMOl3TJ8+/cEHH/zb3/721VdfNWrUqHLlytaG8Bi8c+fO8ePHDx8+/MMPP2S2XfPm +zUNopDXJ6bjttts++eSTXr16Wc/wULUm4fj6669Hjx791FNPff7556VKlTr22GPt2QwanIakw5lx +Cz+WIyvqVfhv26x4+kXUgZDqDs/ldP527drFQ+qCCy5wJrpy5cpy5crVq1fvnHPOqVq1atu2bXfs +2GECeJxyxpBm98svv0zpHnPMMWeccUaJEiVKliw5d+7csBl88ODBVq1a1apV64orrqhTpw4Gjx07 +NmxGRi24d955B2v79Oljz4azGnz00UcUfePGjc8///yKFSsWKlToueeeyzjhNLAKZ8ZtbYnlyIp6 +Ff7bNiuefhF1ILS6818RhqbucM6cOdddd139+vV5tkYIMDLWokULGJH6L7/8UqFCheuvv95Y4nEq +dab6xlyzZk0aZ0eOHCEkTXaaPjyCw2bwQw89VKNGDXhi2IEDB/r27du7d++wGWnscf5dv349L2GV +KlVyCnA4q8EJJ5zQrVs3npjYv2/fPl4cqbr79+/nMIMGpyHpcGbcWYvc7mypV+G/bbPi6WcrQMh1 +J30C/Oabb/JI5VemTJkLL7zQAtq4cSOSTOez9aEdXLt27aNHj3qcsoHT79i7d2+RIkXo17VJ051+ +2mmncRgqg9Gwu+66yxr5008/jRkzJmxGWvOs48wzzxwwYEC/fv1OP/104xkqqtZOqkHRokVffPFF +6/PYY49Rk7///vsMGpyGpMOZcVsKsRzZUq9Cfttmy9PPVoOQ6076JmEhupN/+5lGMI8q81uyZAkO +WhL/8fgvhlTXrl27ZcsWj1M2cPodtHdpSr722mvmYffpp5/ykkX7EkvCY/DWrVu3bdvGa8G8efPo +F6XzuXr16gMHDgyVke6yYx4AY+rPPPOM81R4qDqt2rNnD5MAIGw9f/75Z9xVqlTJoMFpSDqcGbel +ENWRLfUq/LdtVjz9nHUg5LqTPgF2QnG6zWOrWrVq1pNBNdzIm8cpGzgjjieffPLQoUM00xm3/t3v +foceX3311VgSHoOXLl2KPRMmTKC38M4777zkkkuaNm06c+bMUBkZUXb0lv/5z39+4YUXnDPaQmsw +/eS33HJL3bp1TS6+/PLL119/HT2mVmSwGqQh6XBmPKIuOQ+zqF5lxW0b/qefs/RjuT3uFI9TsWJL +2L9owld6X7hs2bKPP/7YhGF8t0uXLrHC09jllHPaM20IfBha8zgVK7ZU+Lvz8u6773JXt2nTpn37 +9u+9995nn332wQcfMAycQYMjjFy9ejUo6HOmFHr27Ilhp5566uDBg6lbGTTSWToRBnfu3Pmyyy47 +++yz6Sp0BsMdToNtlaaiPvLII/fffz/14R//+EdmDU4nq1BlPKLO2EO6IkNer6ypOIwAh/m2xcgQ +Pv2cDAO6Pe4Uj1MBIw8eLFUt4G+++YZGofm98cYbHgYx5sHZNWvW2DD0neJGhj1O2cBpcETkZfHi +xbfffjtttW+//fb5559nyQdvGA8//DCWZNDgCCMZnsSeQYMGobvMzmXCNnOhV6xYwR2eQSOdhRVh +MP3k33333f/8z//wZsOPoSamNeGgwzOcBpu8UAeYak7p33fffTSCmXOe2WqQNlZhy7izajnd4a9X +TmvDf9uG8+nnZBjQ7XGneJwKGHnwYKlqAffv35/lEMaOsmXLehhElx1nly9fTh+pCWbmFTOD1+OU +R4RJPxWRF1bWkgSv1SahwoUL477hhhvIbwYNjjCS+wTzbCsNd+vWrfnLyHoGjTTEzN8Ig4cNG7Z9 ++3YmEjvDNGjQgNV74TQYO1mpzJRjIE+dOpXBCGt5Bg1OT9IhzLiFH+GYP39+yOuV02AzohHm25Yt +HDA4bE8/J8OAbo87xeNUwMiDB0tVC5ixeiqT+ZkXilg2de/enaW0X3zxhQ1Ad26PHj2KFy/uccoG +ToMjIi8sNSFRM9vFpE5vKg78M2hwhJFNmjRhiSrrNS0f7hzeFZo1a5ZBI60xOCIMvueee350/Gi4 +8xjCgx7pcBpMFi6//PJ27dpNmTLFqb74Z9Dg9CQdwow7q5bTHf565bQ2/LdtOJ9+ToYB3R53isep +gJHHEcxO1/Z1sE6Xxh/jnSwQ8g3sEYAOW+cyJELSO8rjmMFU2mcPPPAA/TCkYmLwOOWRREpP0UDn +lYKOR9b1M2uRae5MGqI9FzaDb7zxxvLly7M2hhWQdMQxd4bnZtiMjFVSDAbbZUiECWE1WLhwIbcZ +OysxH975YwAlswanmlVoMx6rLjn9w1+vQn7bZsvTz1noxh1O3YljHTDTktlJ4+mnnz58+LA7e8F9 +3CDYu8As4+GJxpZY7O1nY/M4ZcOk38HSI+emg8xyYgzbmBEeg3lhYtaVfRc799xz6YsLm5Gxyi7i +QRkeqtbgl156ybJ1Olj3RZgMGpzqpEObcVs0Ho7w16vw37ZZ8fRz14Fw6k4hDHU+PjzcNE8ff/xx +hIdXbDozPUImdop3K2YJnXTSScWKFYuIweNURMi0HbIMiQ5SGpcAYeEyE52cSYfH4A0bNjAejIVm +flA4jXRa5eEOD1UPI52nMmhwBpOGQGZTdxZBEHcIrQ35bZstT78Cln4aKkYcAsx8VMYUWbDL4FyE +3gTJp8KIgAiIgAiIgAhYAnEIMG1lXnxo+zJGixijwQzcSoktSjlEQAREQAREIDiBOJYhobXMTCZq +xoBnzZrF4SmnnMKQbfDEFFIEREAEREAERMAQCCTAfPaHn23sIsB8D3Lz5s3s6swaX+sflan32aiX +yFMEREAEREAEwkkg+MQpX/v9BZgv2f3www9MOOIrRkSHoLIMiaUI/NhnmBU4ZufIqClJfaNikacI +iIAIiECWEkDXkqXB/gLMjoDvv/8+W+SznSHSa5AxEkw7eOLEiWgwi2JTMSk6S8tGZouACIiACIhA +EAL+Ss6W66xjYRN/vpfgFGDzCsB+FHyfOZYAqwUcpAwURgREQAREIIsIJKsF7C/ABYEiAS4IPV0r +AiIgAiIQQgLJEmD/LmiTedq+fKCGXVrYZ4fBYH5sNVykSJEQopFJIiACIiACIhB+AoEEGNFlHtac +OXP49B4rgJl1Rbfz8ccfz7dr4l2GlKwXh/CTlYUiIAIiIAI5QCB1Xbn+XdBMtuJDp6NGjUJ9mW/F +SDBA2XGeTxgNGTKEHfONT1TKbrslwFFByVMEREAERCCcBFInZP4tYHbwnzRpEp/9ufnmm/lkLxrM +wiS+lM6e7BMmTGjevDlfuHPbF06OskoEREAEREAEQkLAX4B37NixadMmvqVz3nnnWaP5AgGdzyNH +jkSJGzduzOaU9pQcIiACIiACIiACvgT8hRNxpZOZFjBNYTZ/NiuA6UlmJywavpJeX8QKIAIiIAIi +IAJuAv4CzIfcW7duTW8zG0Gz9yQavHPnTsaAP/vsszp16vCdO2mwG6t8REAEREAERMCbgL8A0/zt +3bs37d0ZM2YwGwu5ZW8s1iPVq1ePTmk02DuBVJ91Dj9rhleqaSt+ERABERCBZBHwnwVtUmI/rJkz +Z7IjNErMPKzatWt36NChbt263nY41dGETK5Gpjp+79zprAiIgAiIQM4TSJ3Q+AswW3Aw02rKlCnr +169nABgFpU3MXzbi6N69e4sWLTy6oFNnN0XujhzP5Ap8zlcsZVAEREAERMCbgFtrkiU0hb0T5iw7 +b7AM6c033yRJup0ZD27QoAHqiyS/8cYbGzdu9I0hFQHcREwq+Mc6lQozFKcIiIAIiIAIJEbAfwyY ++c8LFixo3779Nddcw9d/ixUrRpuYvbHKly//4YcfLl26tEaNGmHbkxINTtYbSmJYdZUIiIAIiIAI +eBPwbwEz+svvuOOOY/tJBJgNsJgIzTAwkkzUrBJOv9QFaeMGCeONRmdFQAREQAREIHUE/FvAaC3S ++8EHH9DzzE5YdD7TKU3P8/jx45Fej28Rpsjo4MqqdnCKikDRioAIiIAIFJyAvwBXrFixb9++K1eu +fPjhh9n9CgHevXs3/dJ0O1922WVsgxXrY8AFN84dQ3D1Ndea8Olvo7stl48IiIAIiIAIOAkEGitl +82cWIM2ePXvdunWsAGbac4UKFVq2bNm1a9fKlSt7iKL7VEG00B2bMyfe7oKk6x2zzoqACIiACOQw +Abf0JEtQAgkwZM3EK+Ze8UOAaQczEsyELG/oSbTbHZV30u6zyULmjlk+IiACIiACuUrArT7JUpOg +ApwY2WTZ7Y4nMXu4KlngEjZAF+YAgSRWyByg4Z0F3XHefHQ2/ATc93uyarX/LOgw04lKIaqnzYUb +pT0lhwgEIaAqFISSDSNcFoUcIhBBIAsEONYN7CG0HqfIf6wII9DoUAREQAREQARSRyDsAhxLLL0l +Fl6+AVLHVDGLgAiIgAiIgC+BUAtwwuprsi0N9i1+BRABERABEcgUgVALcMGhoMGS4YJjVAwiIAIi +IAJJJ+C/EUfSkyxghAkIKpc4G9MJxFBAm3V5bhNQjXKWr/Nec/rLLQIiEEEgywQ44SddwhdG8NKh +CIiACIiACCSFQKi7oCNUM+IwKflXJCIgAiIgAiKQEQJhbwFLdDNSLZSoCIiACIhAqgmEugWc6swr +fhEQAREQARHIFAEJcKbIK10REAEREIG8JiABzuviV+ZFQAREQAQyRUACnCnySlcEREAERCCvCUiA +87r4lXkREAEREIFMEZAAZ4q80hUBERABEchrAhLgvC5+ZV4EREAERCBTBCTAmSKvdEVABERABPKa +gAQ4r4tfmRcBERABEcgUAQlwpsgrXREQAREQgbwmIAHO6+JX5kVABERABDJFQAKcKfJKN08JVKlS +5aGHHsrTzCvbIiACDgISYAcMOUVABERABEQgXQTiEGA+TLR///6DBw+myzalIwIiIAIiIAI5SyAO +AT5w4MDXX3+9cOFCfSIwZ6uDMpZ2Ak8//XSbNm3KlSvXvn37iRMnOtN/6qmn8OzZs+fo0aPfeeed +W2+91Z71uMqE2blzZ//+/WfOnHnbbbc1b968VatWo0aNspeffvrpU6ZMefzxx0888cQmTZrccMMN +hw8ftmc90rVh5BABEUgCAdQ04G/Tpk0333zzc889d+TIkYCXuO0LeGHwYGlIIrgxCpkPBApY5SpX +rvzggw8aULfffnvRokXvvPPOMWPGXHrppcSMw5y65ZZbihUrdvnll990003ly5evWbNm27Ztfa+y +/Ddv3kxstWvXRmufffbZSy65hMPHHnvMBChZsmSjRo1atmyJ1v7hD3/g1AMPPOCbro3c20FsET/v +8DorAiEnEFGfOUyWwXFExC3NQ+H555+XACeLvuLJRgIFvButAK9atapEiRLDhw+3EM477zyE9ujR +o7/88kvx4sWtTnPrcRUNZUJ6XGXjwWEEuF27djRtjf/FF19csWJFRpE4RICbNWu2b98+c6pz5840 +l3F7pGtCBvlbQD5BklAYEUgngdRV6aBd0OQWI+rVq1erVq1ChQq5DZKPCIhAXASmT5/OsM5pp51m +r8K9fv16JHbGjBlMthg0aJA5xcTps88+27g9rrLxWAeKXqRIEXN4wQUXbN++fdmyZebw/PPPR4aN ++/jjj1+6dCluj3RNSP0VARFIIoFAAnzo0CHuzzlz5vAgaN26NS/Ra9asWbt2rSZkJbEkFFW+EVi+ +fDkSeMIJJ9iM0y2Mm5uLliiN4zp16thTvPgat8dVNrB1HHfccRHuDRs2GB+a1PYUrW26tTj0SNcG +lkMERCBZBIr6RsSd+cMPPzD0u3jxYp4CpUuXplPriy++oKOM9+tTTjmFu9c3EgUQARGIIFCmTBla +wLRKq1WrZk799NNPOLjLypYty9vt1q1bq1atak6hu8bhcZUJ4PxL/PaQhHDTiWV8CheO8vLtka6N +Rw4REIFkEYhyE0ZEzXTKf/3rX5999tnJJ59coUKFRx99lDmZP/744+TJk1966aWVK1ea3umIq3Qo +AiLgTYBRWO4d7iwb7KuvvkJx69atS8uVU/Q2m1Po6KxZs4zb4yobj3V8++231k1CvCvXr1/f+rgd +Hum6A8tHBESggAT8BZjZHD///DPDUSNHjmQWJenVqFGDJQ0jRoxYsWIFSmw6rwpohy4XgXwj0KdP +H9SUXbHo+KU/adKkSePHj7/++usZtTWnhg0bhs/cuXMHDx68evVqw8fjKgIwb6t79+6WJPOf3333 +XcaMWHT0xBNPsNzIDgnbME6HR7rOYHKLgAgkhYCPAPMaTlcYKyXMizPTr4455hhek5mrybOjVKlS +e/fu5dmRFFMUiQjkFQG08K233uIOatCgASM7/fr1u+KKK+644w4gcMchnCwiGjBgAFOUue84Rf8w +pzyu4uyiRYs+//xzi/Gqq65iIRORM4erb9++999/vz0V1eGRbtTw8hQBESgIgUK+HchMCXn44Ye3 +bds2dOjQdevW3XfffUzFYgolA8NLliy5++67GQaO9Vrtni/tm1y8mUlDEvGapPC5TSC5VY4OJFST +fib2yqhUqVIEOlYK0W/M/TVw4EAGgJiKYQJ4X0WYLVu20Jv99ttvI73z5s1r3Lgxe31ERO5xGCtd +j0vsqeTysdHKIQKZIpC6Ku3TAibDyG2XLl2YBX3XXXe9+OKLbM3D1jkTJkxgUKp3795sshNLfTMF +S+mKQBYR4PZp0aJFt27dnOrL4A7N1pdffplOJgIwBsSUC3atsvmKepU963QQkgsDqq9vus6Y5RYB +ESggAf9Z0KyUYGSIZJghwjs4fWL44GYWJZ1jzqdGAU3R5SIgAoYAndIXXXTRlVdeyYTH6tWr87LL +EmE6k1PNJ1Pppjpfil8EwknAvwva2M1IFcuQ6I6m7wsZZqUEA1RmUMojY6lrudtE05CETUsOEYBA +2qoc7dGpU6fu3r2bbicGehigDc6fqRuMInfs2NG5mDjg5QVJN518AmZHwUSggARSd8v7CzCjtszA +ZC94vsSADCPArERkXIpNAxgJbtq0adQFhSbDqbPbAk1DEjYtOUQAAqpy3tVAfLz56GzWEUhdlfYX +YL7BwNSPBQsWnHvuuTR86X9Gg5ni8dFHHzH/+brrrvPQ4NTZbYswDUnYtOQQAQioynlXA/Hx5qOz +WUcgdVXav1OL+c90SfXo0YNBKSc4uqBZwsgGPTSFPRrBzkvkFgEREAEREAERMAT8BZjZmHxEhQ03 +WHSE6PKJNNb1My7FJjv0TjMMzDRL0RQBERABERABEYiLgH8XNHLLHj0sQOKjpEzoQI937NjBlu5s +QsnsaD4myqYcsZJMXcvdppiGJGxacogABFTlvKuB+Hjz0dmsI5C6Ku3fAmbQl0WKyDB7ySK6zK6k +4Us7uFevXkzCYo1E1tGUwSIgAiIgAiKQcQL+LWBj4p49e1iDxHgwnc9MgWZdP93R7NHh3f+cuhcH +Cy4NSdi05BABCKjKeVcD8fHmo7NZRyB1VTqoABtktH2Z+Yw1AWddpc5uW4RpSMKmJYcIQEBVzrsa +iI83H53NOgKpq9L+XdBOWNjh3eR1BpZbBERABERABEQgFgH/vaBjXSl/ERABERABERCBhAlIgBNG +pwtFQAREQAREIHECEuDE2elKERABERABEUiYgAQ4YXS6UAREQAREQAQSJyABTpydrhQBERABERCB +hAlIgBNGpwtFQAREQAREIHECEuDE2elKERABERABEUiYQHzrgBNORheKQA4TcK/Tz+HMKmsiIALJ +IqAWcLJIKh4REAEREAERiIOABDgOWAoqAiIgAiIgAskiIAFOFknFIwIiIAIiIAJxEJAAxwFLQUVA +BERABEQgWQQkwMkiqXjyhQDfBMuXrCYjn8KVDIqKIzcJaBZ0bparcpVSAhKVlOJV5CKQJwTUAs6T +glY2RUAEREAEwkVAAhyu8pA1IiACIiACeUJAApwnBa1sioAIiIAIhIuABDhc5SFrREAEREAE8oRA +fAJ88ODBw4cP5wkaZVMEREAEREAEUkcgDgHet2/fzJkzv//+e00BTV15KGYREAEREIE8IRCHAO/a +tetf//rXF198IQHOk8qhbIqACIiACKSOQBwCXKRIkbJly5YsWTJ11ihmERABERABEcgTAnEIcNGi +RevWrVutWjVawGoE50n9UDZFQAREQARSRCDQTlhMvNq0adPy5ctLly7NSPCcOXNw1K5du0qVKjSL +U2SZohUBERABERCBHCbgL8A0dpctW/a3v/1t+vTpR48eZSS4cuXKFSpU6NSp08UXX9y4cWNpcA7X +D2VNBERABEQgRQT8BXj37t3vvvvu1KlTzzzzzHLlyk2aNKlNmzbHHHPMe++9R2v4z3/+c61atVJk +nKIVAREQAREQgVwl4C/AmzdvXrBgQf/+/YcPH24obN++/Y9//GPr1q1feeWVxYsXV69eXY3gXK0f +ypcIiIAIiECKCPhPwjp06BD6Wq9ePTPxitHfVatWrVu3rmnTpvRIMzZ85MiRFBmnaEVABERABEQg +Vwn4t4ArVarEzOePP/64bdu2pUqVmjt3btWqVZkR/f7772/dupWzav7mauVQvkRABERABFJHwF+A +K1as+Lvf/W7evHl33XUXY8D79+8fOHAgf5kL3bVr15YtW0qAU1c8ilkEREAERCBXCRQKsqKXruYv +v/ySqVjbtm1jKtZpp522fv36FStWoL6sRPJAU6hQoYizQZKLuMT7MA1JeBugsyIgAiIgAjlMIHUq +E1SAWX2E4rIeie8xFC9evGbNmixAQn3dljmLwX1WAuzkI7cIiIAIiEDICaROyPy7oGn+Ll26dOzY +sYz+mq8hMRJcrFixhg0bDhgwoFWrVrhDjk/miYAIiIAIiEDYCPgL8M6dO5lvxXeQOnbsyFxotoNG +hjds2DB79uxx48axKUeDBg3ClivZIwIiIAIiIAIhJ+AvwKwDnj9/fu/evW+99VZnZqZNm/bXv/51 +yZIlbBCteVhOMnKLgAiIgAiIgC8B/3XAdH/zBSTWHR04cMCM4NIpzeJgPEuUKMEiYA59k1EAERAB +ERABERABJwH/FjAzrRo1asRG0Cz/pbHLADCbU7L/xpQpU+iOrl+/vpq/TqByi4AIiIAIiEAQAv4C +XL58edYdsfvVG2+8wTZYTLnas2cPA8OsCR4yZAhTsQoX9m9GBzFFYURABERABEQgfwgEWoYEDhSX +zxGyDpgPMKDBKHGd337e6pu62du2hNKQhE1LDhEQAREQgXwjkDqVCSrAiRFPnd3WnjQkYdOSQwRE +QAREIN8IpE5l1Hucb3VJ+RUBERABEQgFAQlwKIpBRoiACIiACOQbAQlwvpW48isCIiACIhAKAhLg +UBSDjBABERABEcg3AhLgfCtx5VcEREAERCAUBCTAoSgGGSECIiACIpBvBCTA+Vbiyq8IiIAIiEAo +CEiAQ1EMMkIEREAERCDfCEiA863ElV8REAEREIFQEJAAh6IYZIQIiIAIiEC+EZAA51uJK78iIAIi +IAKhICABDkUxyAgREAEREIF8IyABzrcSV35FQAREQARCQUACHIpikBEiIAIiIAL5RkACnG8lrvyK +gAiIgAiEgoAEOBTFICNEQAREQATyjYAEON9KXPkVAREQAREIBQEJcCiKQUaIgAiIgAjkGwEJcL6V +uPIrAiIgAiIQCgIS4FAUg4wQAREQARHINwIS4HwrceVXBERABEQgFAQkwKEoBhkhAiIgAiKQbwTi +E+Bff/vlGyPlVwREQAREQASSTiAOAT506NDSpUvXrl2bdCMUoQiIgAiIgAjkG4E4BHjXrl3jxo37 +9NNPjx49mm+YlF8REAEREAERSC6BOAQY3d2+ffvu3buTa4FiEwEREAEREIE8JBCHABcqVKhcuXJl +y5bNQ0zKsgiIgAiIgAgkl0DRgNEx+2rv3r3HHntsy5YtCxeOQ7YDxq9gIlBAArwgFjAGXZ6rBHh8 +5WrWlK+sJhBUSvft2zdlypS33357y5Yt9EKrQmd1qeee8VLf3CvTJOZI1SOJMBVVEgkEFWAGgJn/ +PH/+/H/84x/vvPPO6tWrjxw5kkQ7FJUIiIAIiIAI5BWBQF3QtHcPHz5cqlSpgQMHtmjR4r333lu2 +bNm5557brFmz4sWL6+0yr2qMMisCIiACIpAUAv4CTEt306ZNy5cv3/jb78orryThMWPGLFq0aMCA +Ad26datUqVJSTFEkIiACIiACIpA/BAr5juay/Jc+57feemv9+vW4O3bsWLly5XXr1k2aNKl+/frP +PPNM586dixQpEhWZu3Hsm1zUeDw805CER+o6FRIC7moQEsNkRkgIJP3JE5J8yYw0EHA/XpJVnfxb +wMx5LlGiBAuQtm3bxmZY5cuXZzwY6aUpbPql05B/JSEC8RJI1h0Sb7oKHwYC7idmGKySDSIQQcC/ +BcwFPMt27NgxceLEzZs3/+lPfypWrBgaTBXHH3nmFxGpPXTfBkl/LKYhCZsdOUJLQNUgtEWTEcNU +HzKCPVcTTV11CiTAYD148OCSJUuY/FytWjVaw4z78peWsTfx1Nlt001DEjYtOUJLQNUgtEWTEcNU +HzKCPVcTTV118u+Cps3KDpTTpk376quvWIm0Z8+eihUrVqlSpVWrVr169apZs6bbuFwtBuVLBERA +BERA+CEylAAAIABJREFUBJJFwF+ADxw4wBYcTz/9NE3eRo0a1alTh9Ywk6JnzJjBphy///3vNQs6 +WYWheERABERABPKHgL8Ao7LTp09v3Ljx8OHD69WrZ9CwGdaoUaP4MhKTok8++WSPYeD8QamcioAI +iIAIiEBwAjHnT9ko2AKapcDdu3e36sspPslw9tln85clwkzIsoHlEAEREAEREAERCELAvwWMyjLi +++2339LYZQ0SS35ZjEQvNKPCNHzpf9YYcBDQCiMCIiACIiACTgL+s6CRW7qg2fqK1UcIMHtPMg+L +H8uCTz31VDbDQp6dMTrdbm3WMiQnH7mTRSANNS1ZpiqeNBBQfUgD5PxJInXVyV+Aobx///45c+ZM +njyZzShxY03JkiXbt29/5plnMgvaoxhSZ7dNNA1J2LTkCC0BVYPQFk1GDFN9yAj2XE00ddUpkAAb +rOzFwXok2r4s/zX90kWL+vRgp85uW9JpSMKmJUdoCagahLZoMmKY6kNGsOdqoqmrTnEIcAJwU2e3 +NSYNSdi05AgtAVWD0BZNRgxTfcgI9lxNNHXVyX8WdK4yVb5EQAREQAREIIMEJMAZhK+kRUAEREAE +8peABDh/y145FwEREAERyCABCXAG4StpERABERCB/CUgAc7fslfORUAEREAEMkhAApxB+EpaBERA +BEQgfwlIgPO37JVzERABERCBDBKQAGcQvpIWAREQARHIXwIS4Pwte+VcBERABEQggwQkwBmEr6RF +QAREQATyl4AEOH/LXjkXAREQARHIIAEJcAbhK2kREAEREIH8JSABzt+yV85FQAREQAQySEACnEH4 +SloEREAERCB/CUiA87fslXMREAEREIEMEpAAZxC+kg4FgcOHDx84cCAUpsgIERCBfCIgAc6n0lZe +oxEYMWJE69ato50J5FeqVKmRI0cGCpr6QFWqVHnooYcSTmfx4sU//fSTuTxU+Uo4R7pQBMJMoGiY +jZNtIhB+AhdeeGHz5s3Db2cQC2+77bbdu3dPnTqVwLmUryB5VxgRSD8BCXD6mSvFnCLwz3/+M6fy +85/M5Gq+/pM//ReBzBNQF3Tmy0AWpJ8AncYdf/s9/PDDR48edRrw4Ycf9u7du169emeddZZpC3L2 +T3/60+WXX+4MxuGdd96Jz7nnnvvOO++YU7/++uujjz7aokWLWrVqDRky5IsvvrCXRI3Wno3q+OWX +X+655x5iO/bYY0lux44dNljA2GIFi2onBs+cOfObb7459dRTd+3a5cwX6T799NNt2rQpV65c+/bt +J06caC05/fTTp0yZ8vjjj5944olNmjS54YYbGFO3Z41j586d/fv3J3Ja2PQWtGrVatSoUTaMdwxP +PfUUKfbs2XP06NFwvvXWW+2FcohA1hPgVkzdz00n6WmlIYmk26wIk04grmpw0003FSpU6A9/+MNf +/vKXyr/9UA5j0quvvsqpLl26oBAXXXRR0aJFx48fz6kHH3yQJFatWmWCrVixgsNXXnmFw5IlSyK6 +xp+YixQp8j//8z/I1QknnFC6dOmff/6ZU7GiNVdF/Xvw4MHGjRt36NCBVG6//fbatWsjVCakR2zk +BlN9g0W1k4SOP/74Ro0akZ19+/Y584UBoOCFY8yYMZdeeil5x2FSIRiXtGzZEqUEKaceeOCBiBxt +3rwZf5OFZ5999pJLLuHwscce843hlltuKVasGC8fGFy+fPmaNWu2bds2IvKoh8Qf8YsaTJ4iEIRA +RF3iMMhVQcIkLaKoiaXObptcGpKwackRWgLBq8Hq1at5pjPxyuRl+/btNWrUQOo43LNnD4/4iy++ +2GbzvPPOQ5M4XL58OcL8zDPPmFNPPPEEc5Ro2HFohYoGa/Hixe+66y4TBtUxpzyiNSGj/p03bx6Z +mjBhgjn7ySefdO3adf/+/d6xWQH2CBbLThI6++yze/XqZVK0+eK1o0SJEsOHD7d2ggVQ9BzgQ7Bm +zZoh2OZs586daezakMZhBLhdu3Y0jo0PkCtWrEh2OIwVg7HTvk8QCbmjFR4RedTD4PUh6uXyFAEn +gdRVpzi6oDGI20wLNtyFIZ8sIjB58uRDhw6ZthpmV6hQ4fzzzzf2f/XVV+vXr+cQZTW/0047bcGC +BXg2aNCgU6dO//rXv0zIt99++8wzz6Q/1pnxGTNm0GxFw4wnE5K//fZbpjJ5ROu8PMKNwvGiMGzY +sLfeeovOZ7qFP//8c4QwYGwewWLZGWGAPZw+fTp3PSisD26YIMzGB2KIqHHzvrJ06VIb0ulAtuke +MD4XXHABrz7Lli0zh1FjMHYOGjTIhIGnZeuMVm4RyF4CcUzC2rt3L4M91apV4yWX1kD25lmW5zMB +2rL0DFetWtVCYLzWuI1yWD22AbZt24YcDhw48M9//jOywY3w5ZdfIo02gHGYVrJzRrRxf/zxxwSI +FW1EJPawevXq7777Lu1pJBzdolec/tgzzjjD20h7uUewWHbaayMchEdf6VG3/vQ5416zZg0j5Tho +mNpT9AEcOXLEHjodxx13nD007g0bNhhEUWOgBcwLR506dexVtqSsjxwikNUE4hPgadOmMVpGU0AC +nNWlns/Gly1bFgVdu3YtQ5KGw/z5843DtGiZuMSIphMR6sshQsgMow8++AA9Rr/79OnjDIObTml6 +iTiLw5yiGY12ekcbEYnzsO9vv4ULF06aNOnll19mUtjcuXMDxuYRLJadZcqUcaZu3fjTAubNg5dv +42nWCls5LFw4UEeas/OM2IjK6DeOqDFQUvQobN261b4t8SpgrZJDBHKAQKA7x+QT0aXpwDtpDmRb +WchbAqbJRXeuJfDZZ58ZN2OZOH744Ye6//kxcXfo0KGm4xQZoOuVXmj6nxnCZFKSjcE46H3FQcep +OaTfmNYbk7m8o42IxB7S8Yvi0prk8htvvPH999/HTZ92wNg8gsWy0yYd4SAqXiwsJc7Svw0NIEWE +9D7EeBuA2Ggr169f3/q4HbSSSRcO5hT6PWvWLHcw+YhAFhOginv/mGrBeyizJ3idf/PNN2kE42N+ +3hdy1s3F95J4A6QhiXhNUvj0EwheDRgApheHlTBLlizhmc5cXKTUTMLCbCSW5/6PP/7IJKbnn3+e +Nt/VV19ts/P666/zDkpzbc6cOdaT7lkzCxqBpOlMVy0zn5kmPXjwYDRm0aJFvtHaqJwO2og0VVl1 +w6wxJisxtZg34O+++847NjsJyyOYh53MN0YUsZ8wNl/c+2gwq4zIFP70EHDqvvvuM9biZv6ztfy6 +666zU8qZ6datWzdOmUlY0OD1hXkkH330EUPv9Kh7x0BJkS5Fw2MH8WbYmJLSJCyLWo60EQj+eInX +JP9Z0DyJaAfwAs6QD27uCh4NPFYYZOLQO73U2W3TTUMSNi05Qksgrmrw/fffs7KWS2jaoiv333+/ +1QwqeY8ePTjFs56zV155JStiba7ZJQoBtoGNvxUqDhF1pJ3LEWlWEDF/yoTxjtbGH+FAwLCBH0qM +etn5wB6xOQXYI1gsO+nrNv29W7ZsceaLXnrTpDYdYNdeey0v5cZaDwE2C5YIZgSYtdSVKlXiNYLs +0IVgJ057xMBzpnv37sDkEoYAmDrHBJQISlEPKYKIX9Rg8hSBIAQi6hKHQa4KEqYQgdyxO324edgN +4IUXXuAGoCvs5JNPZqk+7+ObNm1ivSOjVNwbzvBOt3uo2Dc55+VB3GlIIogZCpNZAvFWA94jWefD +KGPTpk3d1/JyyQwg2l7x9rIaCLQU0Us7xmzJJBDtunXrGAPGQrbjYFqWjQpHwNg8gkW1EzIMu7I0 +y5kWbtq+yCFPA94w0NGIs96HyDm6Ttc905jBDlgzRO19lT2LVMOTFxHmwdF0fu655+ypWA53mSb9 +yRMrafnnHoHUVSd/AWa9Ad10zP5gGQD3AEshWRHPXcReQjQI2PmdG9JtnykDt3/Sb4M0JJF79Sn3 +cpSl1YA9nqKWBV3fzPaKeiobPa0AsxIpuP28H/DawQPniiuu4Co6xsH1yCOPXHXVVb6RZGl98M2X +AmSEQOqqU+REEnf2kEzWI7ILD+sobr75ZrqjWQF50kkn0XHHSgzer5nVQgD3hfIRARHwJsBsJu8A ++XyWtddsRsYoAJtQ0vpnBhYj9IxS5zMT5T3HCBQOkh9mYTDc27BhQ6QXAWb5PP1ULLega4iOqaQ3 +aoOYpDAiIALZQoAOZ3b0POWUU+I1mN0xWXp0zTXXIL1M/nrjjTfck8/jjVPhRSA8BPxbwNjKnGeE +FgcTIthIiDEYJqqwITvCzCCZbonwFKcsEYEQEmAElznMiRlGOzhIn3NikesqEcgsAX8BZgoiEx+Y +qYih3AzM7WQveL4SQ5uYaY30PxMgg3mg/e3soFdzPINloaRFQAREQASCE/CfhEU/M1sTMP2KdQhs +IcR8CtbkMT+CxRjs2442eyTmlEYTTALpgUunEiagmpYwupy8UPUhJ4s1U5lKXXXyF2DyjGqycJDN +a9Bd+qJpB9PzzFoCdpIzLeNYXFJnd6wU5Z+fBFTT8rPcY+Va9SEWGfknQCB11clfgBnoZa4m3zdl +NoTti2YvDhYjsS6eyRGZXQecAE1dknsEUneH5B6rfMiR6kM+lHLa8pi66uQ/BozWvvfee2y7wa54 +jPiyGpiN8RDjv//972z0wz4GUbcySBsaJSQCIiACIiAC2UjAX4BZboT6sg2W83tq9ELTAmYLXDql +2TtX64CzsexlswiIgAiIQAYJ+AswSwj4Hhlzr/i6CyO+NMbN2l82pWP+M5Oz3M3zDOZHSYuACIiA +CIhAVhDwX0HEJq6tW7dm/w22g+YL4SyHf+edd/g66Ysvvsh3UpmKlax1wKxuQsv5fFsEuJtuugl/ +vsIU4W8PL7vsMgKwPbX18XYwaM0+mt5hdFYEREAEREAEUkrAfxIWya9cufK1117jE6q0d/mxMIld +oOmF5tNjHTt2xCeWie7GsfcypK5du/IlODZ9tbu9M/uaz5fS+z127NioqWAMG8fzl2VRCxYsiBom +wvP3v/892wL0798/wl+H2Usg3pqWvTmV5UEIqD4EoaQwAQmkrjoFEmCsZNsNvoHKiC9SR6d0xYoV ++Y4bo7/eGYjXbr56RrR87IxJ1yZmvknOF7n5IEytWrWipjVu3Di+kXLnnXcOHz6cT0TQWI8aTJ65 +TcBd03I7v8pdvAS8X/3jjU3h84qA+/GStOpERKn7uQvJNy2+eEif9k8//UTIjz/+mBiefPJJj6vO +OOOMLl26ME2Mhvgdd9xhQ9JD3rNnT/vhdLrQ2TaE/nMCnHPOOXwZzYTkleLuu+9mdjc7XdOVzZRv +G4McWUTAXdPkIwJOAllUmWVq2Ag4K5JxJ8vCpH1YOKpBCdi9c+dOGrv9+vVj/TEfOuTHhx+iRo7n +xo0bUWs+loL71FNPRURtSKT0mGOOadOmDZcfOHAAiW3btq35ijhTyZi/TUgOGcNmc032fL/99tv5 +gCsffbIxyJFFBNw1TT4i4CSQRZVZpoaNgLMiGXeyLAydAJMxM9x78cUX0/CfMWOGR1aZsUXDd8OG +DYR59tlnQfPll1/a8CxfxoePGfPlRBZKfffdd+aUFWC6rAkwYcIE4//JJ58wCM0qZxuDHNlCwNwV ++isCsQhkS02WnSEk4K5UyTIyjAJM3ug9Js+XXnqpdz75QDdbcZkw69atY1nU0KFDnZcMGjSINVQl +SpS49957rb8VYJQbYWaPa76Vps5nyycbHe47RD4i4CSQjbVaNoeEgLMiGXeyDPNfhuROOw0+bHJJ +KldffbVHWkyQZo/ML774gq5jfszeIjBSyscT7VW0fZk+xqyx2267zXpaB1/5ZmEVCs02I+zwxTcW +P/jgA3tWjiwiwP2QRdbK1DQTUPVIM3AlF5CA/0YcASNKbjCztMljgRPJvf766yjrgw8+aKeosQyJ +xcqsGP7d735n7HnooYdKly69a9cuxolZT+w2su9vP2ZZT5o0icXNTLqeO3cuA8/ukPIJOQE9ZENe +QDJPBEQggkBIBTjCyqiHY8aM6dOnD33O9izdyIgoC5OMADOJmrnQjA3Pnj37rrvuOvPMM5lyZQPj +YIETU6wZA6YXmt+5557L4mY+tigBdlKSWwREQAREIBUEQtoF7ZtVJlstXbp0wIABzpCsTkZ62aiL +6c1sFTJkyBAGienHfuKJJ8qWLXvllVdGNJJOOOGEqVOnDhs2bM2aNcyUpklNY5rJ0s445RYBERAB +ERCBVBDIVgFGLOlbplEbAYU9s/h6xEcffcSg7+rVq+mRZmYW47u0dJlQ/cwzzzjD83VFdvB4/PHH +69evz95bDBiPGDGClUvOMHKLgAiIgAiIQCoIBN0JK7G07eisvTyiDWr9M+hg+jRjwJjaokULpmVl +0BIlLQIiIAIiEDYCqRMyCXDYylr2iIAIiIAIhIhA6gQ4W7ugQ1Q4MkUEREAEREAE4icgAY6fma4Q +AREQAREQgQITkAAXGKEiEAEREAEREIH4CUiA42emK0RABERABESgwASyeCMOm3fnCHkIZ1lbO+UQ +AREQAREQAUsg61vATvUlVxGHNp9yiIAIiIAIiECoCGS9AIeKpowRAREQAREQgYAEJMABQSmYCIiA +CIiACCSTgAQ4mTQVlwiIgAiIgAgEJBDfJCx2V+YjB9WqVWN35YAJKJgIiIAIiIAIiICbQCAB3rdv +34cffvjKK6+sWrVq79695cuXR4D5iP1FF11Urlw5d6TyEQEREAEREAER8Cbgvxf0/v37x48f/+ij +jzZp0uTkk0+uVasWX+6bN2/ep59+OmjQID7HyzeFYqXhnpOc9GVCaUgiVu7kLwIiIAIikPMEUqcy +/i3grVu3zp07t3fv3vfcc0+JEiWKFi2KiPJ79dVX0eBFixaddNJJfPIv58tAGRQBERABERCBJBLw +EU6EdufOnXQ7t2vXjs/dlypVqlixYsWLF0eJO3XqVKRIkQ0bNhw+fDiJBikqERABERABEcgHAj4C +TNO7cuXKjPjOnDlz8+bNe/bsQYyRZHqhv/76a6SXCVm0ifOBlPIoAiIgAiIgAkkk4D8GjMrS1Xzf +ffeRKr3NzMDatGnT4sWLly5deu21115zzTUaA05ieSgqERABERCBUBFI3RiwvwADgo7oBQsWvPji +i9999x0zomnyVq1alSnQZ511VpkyZTxIpc5um2gakrBpySECIiACIpBvBFKnMoEE2In7yJEjDP06 +fTzcqbPbJpqGJGxacoiACIiACOQbgdSpjM8YsBt0cPV1XysfERABERABERABQyBuARY4ERABERAB +ERCBghOQABecoWIQAREQAREQgbgJSIDjRqYLREAEREAERKDgBCTABWeoGERABERABEQgbgIS4LiR +6QIREAEREAERKDgBCXDBGSoGERABERABEYibgAQ4bmS6QAREQAREQAQKTkACXHCGikEEREAEREAE +4iYgAY4bmS4QAREQAREQgYITkAAXnKFiEAEREAEREIG4CUiA40amC0RABERABESg4AQkwAVnqBhE +QAREQAREIG4CEuC4kekCERABERABESg4AQlwwRkqBhEQAREQARGIm4AEOG5kukAEREAEREAECk5A +AlxwhopBBERABERABOImUDTuK3SBCGQ5gUKFCmV5DnLf/F9//TX3M6kc5j0BtYDzvgrkGQCpb1YU +uIopK4pJRhaQgL8A8yp66NChAiajy0VABERABERABJwE/Lug9+/fP3v27OXLl3fq1KlZs2ZcvH79 ++nnz5lWoUOGEE04oUaKEMzq5RUAEREAEREAEghDwbwHv3bv3k08+GTFixMiRI7/88ksi3b59+0cf +ffTAAw988MEH+/btC5KMwoiACIiACIiACDgJ+Asw/c979uypUaPGgQMHXnnlla1btx5zzDGnn346 +LeD33ntvxYoVR48edcYotwiIgAiIgAiIgC8BfwFmDLh48eI9evS4+uqrt23b9u2335YrV65nz55D +hgzZsWPHsmXLjhw54puMAohAaAlQw3P1t3nzZrB/+OGH4c9gaKuHDBOB1BHwF2DSZkZimTJlOnTo +0LFjxy+++GLXrl3FihWrWbMm/c80jrm3U2efYhaB9BDYuXNn//79Z86cedtttzVv3rxVq1ajRo2y +SZ911ln09zz33HMtWrSg1wf/p59+uk2bNryMtm/ffuLEiTYkjqeeegpPXlJHjx79zjvv3Hrrreas +OxKksXfv3vXq1ePU1KlTbSS//PLLPffcQ1rHHnvs5ZdfzpuuORXL314Y1UHWiISOq+OPP/6xxx6z +NyydW08++eRpp52GARdeeOHLL79sL3ebak55U6JjbMqUKY8//viJJ57YpEmTG2644fDhwzbOWFhs +ADlEIO8I+L4ar1279sYbb/zLX/5CyPnz55977rl33HEHD44//vGPXbt2/fzzz2kBx4rETTNWyIT9 +05BEwrbpwhASiFVhTGOxdu3aqMizzz57ySWXENLIFbmoXLkyL6CFCxfmLJMQb7/99qJFi955551j +xoy59NJLCYnDZPaWW27h9RTBu+mmm8qXL897atu2bc2piEheffVVXm27dOmC0l900UVEOH78eEIe +PHiwcePGJMeIDwkZkzz8TeRR/5pMYQZaji5eccUVmHr//febwFhYunTpP/zhD6+99tpll13GqX/+ +85/mVISpNnJvSiVLlmzUqFHLli3RWqIlQmaKmGs9sJgABI742UTlEIHMEoiomRwmyx7/iBBgbp67 +7rqLJHk0MBXrpJNOon1w3HHHcXdt2rTJw5TU2W0TTUMSNi05coBArApjpKVdu3Y02kw2L7744ooV +K7IKgEMEqWzZskuWLMG9atUqJv8PHz7c0jjvvPMQWiZD0EJlvObBBx80p4iTC2kom0NnJHQdcQlJ +OCOhhcohSwwwcsKECeYUUyB508WMWP42BrfDZKpfv37YZs7yAo0eM7OSw1NOOYV2tvEnAK3tq666 +yhw6TTU+5q83JQSYhRJ0jJnAnTt3plMBtzcWEzhWuZiz+isCGSSQusrpvwyJ2/Xss882y43Mq33r +1q1RZTrfuIGrVKniNk4+IpClBJDSIkWKGOMvuOCCcePGMcuBHml86JWleYdj+vTpTEik59bmETdd +zQjzjBkzeEkdNGiQOcXdwb3zzTff2JA2kq+++oqW9Pnnn0+nrjlrIsETYeZGGzZsGK8CeJ76248w +sfxt5LEctNHtvhb0eCPtrCqkTczyQi4hL3Sqz507l/mVGG8jsaZaH+vwoESOkGETkvcJgOD2xWJj +lkME8oqA/xgwnVSsAGZEZ9q0aYyB0S3Gg6ZWrVo8FurUqWNv7LyipszmKgH6dWzWjHvDhg3GBzkx +DtQLjWERvA1phHnNmjU09XhV5b6wp7hTrBuHjWTp0qUcIlesJjA/JjniwzzH6tWrv/vuu8y6YFwW +CWf+I+v9OBXLn1PeP6cNNPEJbDLFhMoBAwbQsqfZet9996H6znisqU5P4/agRNPZhqczwMzQ9MVi +L5FDBPKKgL8A0zfF2/HNN9/8xBNPsA6YBsH333/PiNd1113HhAttkpVX1SXnM0tz0OaR9e64maBk +fYwDaSSYOWt8fvrpJxzoHGJGI5KmpL0EtbZup4MOJA6ZS7Hy//6Mlvft2/ff//430TLis2XLFhqj +TL8gfCx/Z8xuN28G1nPRokW4MZX7+pxzzuF2ZvIXrXDSatiwYcD3aQ9KDJPbtKwjOBZ7iRwikA8E +otwtEdnm5uQFnBuVaSnX/vZjKsfgwYO5V023G13zEZfoUASylACNQmv5Z599Rhuufv361sc4aC9S +5zlr/elPrlq1at26dWkacoo+anMKoZo1a5YN5nQQCYc//PADV5kfE7CHDh1KBziXo7i0HQnD/Mf3 +338fN4bF8ndGG9X99ddfW3/socGN1pIc0v/www/TwuZtgDfpH3/8MeC9HISSTRFHcCzOq+QWgZwn +4C/ATLugz5nJFDwUTj75ZIaOmIHFTYsMsx7p559/Nr1MOU9KGcwHAsx/pvuXGU/07tDlw0IaOyRs +s9+nTx+k8aGHHqJnlXbkpEmTmL18/fXXE9KcYvgWH/qNeE9dvXq1vdDpYCIF47svvPACTU+mROEg +Lba7oQVJ5zatUiKh5YqEv/7667zsMpU6lr8z2qhuVkO98cYbrGViAzv6rli/QD85NzJ/MZ4kFi9e +zDRsJk9hSdQYmFbWvXt3eyoIJRsYR3AszqvkFoHcJ8A7r/ePwaprrrnmr3/9a0QwOqKZpUIfGu/O +EafsoRufPZUsRxqSSJapiicMBGJVGDO/909/+lOlSpUQvFKlSjFF2U7oZWjTzm0mF3QImyasmZxI +xxA9zyZ39PGiVegoMTCIy2ocJgObUxGRoK+8yGIPC5AQ7yuvvJI3WhOSnV/x4UckzmnVsfzNVe6/ +JlNcRQPdZHzgwIFmXjeBGfel7Uvq5OLuu+9mTTBmM9jEqQhTzVIr/L0pMTTOAiRrBqNUzB0xhx5Y +TIBY5WJjk0MEMkUgdZWzEFlyx+70oQv6b3/729ixY3masByCO5ZBKdZj8E7NCsV7772XNYvO8E63 +e0jJNznn5UHcaUgiiBkKky0EYlUYajUq9fbbbzNvmQU/1GozTBsrX3T8ICoIEh1CaHZEMJQb4URB +ETy6fJm9GBHAHvKCS0ua5OiItp441q1bt3DhQqylqcr0K3sqlr8NENVBS503ZvbiqFatmjMATV56 +nsmCeZNgdQPjtSx8cIZxuuOl5LwWtweWWOUSEYMORSD9BFJXOf2XIfEYQnpZEcGIL0rMVEneoHn6 +sCsWfVnuEbL001GKIpBEAqgmGzn5RkgwpDEiGOt58HzmmWfMlhcM0EyePPmRRx6JCOY8ZHyUn9PH +uJknxS+IP7tuuYPhg9aa6dO4adrSie0OxhoHlvVbf16prdvbEZCSiSQBLN6p66wI5AYBfwFG/Hk9 +44xfAAAgAElEQVQ3Z40Ew8BM7+QVmG4xeqhYlciP1/zcAKFciEDBCTRo0IDBVDqTGXal2cqMJwZ6 +2RWr4DF7xMAUMI+zYTiVESxhyLhsEAFvAv5d0PZ60/9OU5i3afOzp2I5UtdytymmIQmblhw5QCBW +hWEQl+lX9Os4V/Emll8afMyi2r17N21TNqthkDWxeEJ4VUEoeWOJVS4hhCCT8o1A6ipnHAKcAPTU +2W2NSUMSNi05coCAKkw4C1HlEs5ykVUQSF3l9F+GpAIQAREQAREQARFIOoHc6RxLOhpFmCcE3K+3 +eZJxZVMERCCzBNQCzix/pS4CIiACIpCnBCTAeVrwyrYIiIAIiEBmCUiAM8tfqYuACIiACOQpAQlw +nha8si0CIiACIpBZAhLgzPJX6ukmkPTNUNOdgfxIT8WUH+Wc77nULOh8rwF5mH893POw0JVlEQgh +AbWAQ1goMkkEREAERCD3CUiAc7+MlUMREAEREIEQEpAAh7BQZJIIiIAIiEDuE5AA534ZK4ciIAIi +IAIhJCABDmGhyCQREAEREIHcJyABzv0yVg5FQAREQARCSEACHMJCkUkiIAIiIAK5T0ACnPtlrByK +gAiIgAiEkIAEOISFIpNEQAREQARyn4AEOPfLWDkUAREQAREIIQEJcAgLRSaJgAiIgAjkPgEJcO6X +sXIoAiIgAiIQQgIS4BAWikwSAREQARHIfQJxCPDR3365j0Q5FAEREAEREIHUEwgqwEeOHPnll1++ +/PLLnTt3pt4qpSACIiACIiACOU4gqAAfPHjw888/HzFixOTJk7dv357jVJQ9ERABERABEUgxgaIB +4z98+PCaNWvWr18/bdo0BLhXr14NGzYsVKhQwMsVTAREQAREQAREwEkgaAu4aNGixYsX79GjR79+ +/RYuXPj666/PnTsXVXbGJbcIiIAIiIAIiEBAAv4tYFR23bp1ixcvZgx427ZttWrVatas2Ycffjhv +3ryzzz67b9++VapUUVM4IG4FEwEREAEREAFDwF+A9+7di9yOHTt206ZNuA8cOFCqVClaw0uWLPn7 +3/9et27drl27FilSREBFQAREQAREQASCE/AX4BIlSpx00knEOHv2bKZAX3zxxbgLFy7MoqRff/1V +I8HBWSukCIiACIiACFgChRBRexDVQQDWIB06dOinn35avXp1t27dypYty5AwAkzvNG1fj+avu2va +N7moNnh4piEJj9R1SgREQAREILcJpE5l/AXYkF26dOnUqVMZCUZ3GfStWbNmhw4dWrVq5c09dXbb +dNOQhE1Ljpwk4K5COZnNrM5U0l/cs5qGjE8zAfcjIlkV0l+Aaf5+9913f/3rX1euXFm5cmV6pGny +bt26FcfVV1/ds2dPxoNj4Uid3TbFNCRh05Ij9wi460/u5TE3cpSsR15u0FAu0knA/ZRIVm30HwNm +3Pejjz5iBfBll13WoEGD8uXL0x29cePGcePGvfvuu40bNz722GPTyUJpiYAIiIAIiEAOEPAX4C1b +ttD2ZbnRhRdeSGOX5u9ve0IfZS70Sy+9RNd0vXr1GBLOARbKggiIgAiIgAikjYC/cDLhmQY4HdEo +rjELH34VKlSgKYx/2mxVQiIgAiIgAiKQMwT8BbhatWrsvPH222/T8GXWFVOgd+zYsWrVqvfee69G +jRrHHXecxyzonMGkjIiACIiACIhAcgn4T8JitHn58uXsPfnpp5/u27cPud2/fz9t36ZNm15zzTVd +unQpWbJkLJtSN3ZtU0xDEjYtOXKPgOpPOMtU5RLOcslPq1JXG/0FGOK0fdkG64cffmDu1e7duxkJ +LleuHNOv+HmoLxemzm5bD9KQhE1LjtwjoPoTzjJVuYSzXPLTqtTVxkACbKAz3Gt+ZgyYiVdusyKK +xx0gWbO3bUJpSMKmJUfuEVD9CWeZqlzCWS75aVXqaqP/GLAlTuczP3sohwiIgAiIgAiIQMIEgn6O +MOEEdKEIiIAIiIAIiICbgATYzUQ+IuBFgIEYPs3JPESvQDonAiIgAn4EJMB+hHReBBwEvv322+rV +q7MlHN8mcXjH4WRD9YSvjSOZ2EHZy/2hhx4y553u2FfojAiIQEoIxDEGnJL0FakIZBUBsyD+k08+ +YRleYobfdtttLCXg0yaJXa6rREAEcoaABDhnilIZSQeBDRs20Pw99dRT05GY0hABEchpAuqCzuni +VeaSSuDmm2+eMmUK+9L0799/xYoVxP3000+3adOGZfHt27efOHGiTe30008n5OOPP37iiSc2adLk +hhtu4OPZnB0yZMjMmTO/+eYbJHzXrl02vNvBMPM999zTokULPnZy+eWXs/2cCUPM//u//zty5MgT +TjihR48e77zzDp8mu+SSS3gt6N69+6xZs0wwhqiffPLJ0047ja3a2cX95ZdfdicRy4fvr5BB7KSx +3rx5c/a/GzVqlA0cK2smwFNPPQUKPpI2evRobLv11lvthXKIgAhEEFALOAKIDkUgJgE07/PPP2cx +HlJXpkyZO+6447HHHrv99ttRKb4YdtZZZ40ZM2bgwIFc/9lnn/GdErapQXF//PFHvubJyPFf/vIX +do6bPXv2gQMH+LpJsWLFYqWEfPbu3ZsBWgRs0aJFr7766sUXXzxp0iQTM0PIpUuXRlZJbsCAASg0 ++8VeccUVHCKc7JbDGn1se+655xDmSy+9lA7zK6+8Ek/csVJ0+pP6Bx98MHfu3NatWw8dOhRR5+/B +gwdvuukmY0DUrHEKaxFgEuW7pcOGDcNIPhzujFluERCB/0OAnTFS9/s/Kf12kPS00pBE0m1WhOEh +EG/9Qec6deqE/WyHziexhw8fbvNy3nnnoTdsG4cP0ssO6mzdas527twZaTTus88+u1evXvaqqI55 +8+Zh2IQJE8xZFLRr165sAcshMR9//PHMxMaNRhKM1wITjBYnhwsWLODwlFNOoQFt/DEJkb7qqqvM +Ier44IMPut3Gh7+bN28mnnbt2tFqN57If8WKFa0BUbNGk5098mzMREJCdA/YaONyYEDEL67LFVgE +kkggoipymKzI1QXtZisfEfAnMH36dBqy9PHaoLj5bDbCbHzOP/98u1Erkkmr0Yb0dSDktI9pRL71 +1lt0PtNfTcsbvTcXnnHGGexGh7t+/fr8peVt/M28MISQQ9rZ9957LxbSgH7zzTfppqYJa4IF/Mv7 +hN1454ILLti+ffuyZcvMtVGzNmPGDJIYNGiQCUPznVeNgGkpmAjkJwEJcH6Wu3JdUAKMBKOvtD5t +RI0aNcK9Zs0a40P7z56iaUib1R76Ouivfvfdd+nlpp8ZJWOslz5he5Xt1zUyTOvWnrIOlkvRO823 +y2it3nfffR7d3faSCAcfOrM+xs0ENOMTNWsIP68IderUsVfVqlXLuuUQARFwE5AAu5nIRwT8CaCO +tC9pF9qgZnWvVR2jjvZsvA4Gif/9738TJ/OttmzZQjN3/vz5JhLfmOlzPuecc2iwstiJGVVE0rBh +Q/d+tt4mkTsbwGST+VweBiD2tIBpatureEexbjlEQATcBCTAbibyEQF/ArQsGQdispUN+tVXX1Wt +WrVu3brWJ2EH/dsoLo1mUrnxxhvff/993DRqA0bIBOaVK1c+/PDDNJ2Zoc2kKiaCYW3Ay00wZ3Jk +k0a86fGOFQmtZJLAchMA/bZTsmNdIn8RyHMCEuA8rwDKfoIE+vTpgzqypRRdr7Q4maI8fvz466+/ +3o6bxoq3UqVKS5YsYUiYq2KFoWebxitjwHRoo2R8jZv2a9u2bWOFj/Bn8RK9wZjEtWy8ddFFFzEd +bO/evRHBIg6ZP8Xsbuv57LPP0g3OxCvWUz3xxBOspPLOmgGCzXBgdtjgwYNXr15tY5NDBETATUAC +7GYiHxHwJ4AaMUMKVWMBLutt+vXrxwRpFv/4Xsmw7p49exgwdnZfR1xVoUKFO++8k2XENDoR7Pvv +v3/EiBHMKI4IFuuQhjhC+Pzzz9MtzFIiFvKyXIo50rfcckusS/BnuhZTvWwAZk2z/pisMZeK/nBs +sKeiOljmhGDXrl2bsWdmffPGABAMiBpYniIgAhCI43vACfByDzvF2w/mm2gakvC1QQGyl0AB6w89 +w+gWS24QOZQyIAf6hBkrrVGjhnf4devWLVy4EAtp0TItyzuw+ywvB/Q8Y5iZPr127VrksHz58u6Q +ET4MOSPhbLqJ9LIgqnHjxvRjR4TxOKS1TX81LygsieZNguXIHoFjnSpgucSKVv4ikACB1NVGbcSR +QHHoEhH4/wkgM6hjvDiYk4z6smNU1AvZVcPMeWY+l53SFTWktyeN15NOOsmGoW1q3QEd5I6dvAIG +ZmswUDzzzDM0fLnk559/njx58iOPPBLwcgUTgTwkIAHOw0JXlkNBgElbobAjSUbQFc9gM1tusQkl +7XVmYLEwmk7sJEWvaEQgBwmoCzoHC1VZCk4gdZ1LwW0IW0hWEzGa27FjR+ei3oBG0g5m+hife6J9 +z25cDAwHvDAimMolAogOM0ggdbVRApzBYlXSmSeQulsr83nLZgtULtlcerlme+pqo2ZB51pdUX5E +QAREQASygoAEOCuKSUaKgAiIgAjkGoEER2hyDYPyIwL/IeDubvrPGf0XAREQgWQSUAs4mTQVlwiI +gAiIgAgEJCABDghKwURABERABEQgmQQkwMmkqbhEQAREQAREICABCXBAUAomAiIgAiIgAskkIAFO +Jk3FlXUEkr45edYRyAqDVUxZUUwyMl4CmgUdLzGFzzUCerjnWokqPyKQJQTUAs6SgpKZIiACIiAC +uUUgaAuYD6jx+dJdu3aRfb6ywgfO+K4ZH0vJLRrKjQiIgAiIgAikiUAgAd65c+fM336bNm3CLj51 +wvdBTz75ZPZbj+tDoWnKk5IRAREQAREQgdAT8BfgAwcOIL585vPo0aN822TJkiXmA93ffPMNHxXv +169fmTJlQp9NGSgCIiACIiAC4SLgL8Co7KefflqxYsXrrruuZMmSr7zyCp3Pffv25aNjU6ZMadq0 +aatWrbR7X7hKVdaIgAiIgAiEnoD/JCw+7blly5YOHTp06tTpxBNPRHFXrVpVv379wYMHb9y4cfHi +xYcPHw59NmWgCIiACIiACISLgH8LuEKFCjVr1jSNXXqbZ8yYwWe6+WT3W2+9xZysKlWqaCpWuIpU +1oiACIiACGQDAX8BrlSpUq9evX788cdHH320VKlS9EL3799/7969S5cu7d27d/PmzQsX9m9GZwMK +2SgCIiACIiAC6SNQKMguBHv27Jk3b97cuXPpju7YsWO3bt3wmT9/ft26dWvVquUhwO6x4SDJxZX7 +NCQRlz0KLAIiIAIikEsEUqcygQQYlMuXL6cXesWKFcWKFWNCFs1i1iAdf/zx3pRTZ7dNNw1J2LTk +EAEREAERyDcCqVMZfwE+cuTI999/zzKkZcuWMeJLFzSt2G3btjEefM0113Tv3p21SbHKI3V22xTT +kIRNSw4REAEREIF8I5A6lYmpnRYxM61o+/7yyy+DBg1q2LAhO2+wKxbzn8eNGzdhwoRjjz0WTxtY +DhEQAREQAREQgSAE/AV48+bN9D+z8HfgwIHFixdnzjM7ctAspgXMmuCff/6ZkWCPRnAQIxRGBERA +BERABPKNgL8Am1VGSC9bQBs6+PCrUaMGK4D5JX1eVb6VgfIrAiIgAiKQhwT8Bbhy5crsPfnmm2/S +8G3Xrh0NXwaAV65cSf8zS4TpglbzNw/rjbIsAiIgAiJQQAL+k7DQXaZfvfrqq5988sn+/fuR2337 +9jEM3KxZs2uvvbZr165My4plROrGrm2KaUjCpiWHCIiACIhAvhFIncr4CzCs0eANGzawFwfjwXwZ +CcVlKhZt3yZNmnioLxemzm5bA9KQhE1LDhEQAREQgXwjkDqVCSTABjcTr8yPnTfMMLDbrIiCcQdI ++oBxGpKIyJQORUAEREAE8odA6lTGfwzYUjaiaw/lEAEREAEREAERSJiAtnFOGJ0uFAEREAEREIHE +CUiAE2enK0VABERABEQgYQIS4ITR6UIREAEREAERSJyABDhxdrpSBERABERABBImIAFOGJ0uFAER +EAEREIHECUiAE2enK0VABERABEQgYQIS4ITR6UIREAEREAERSJyABDhxdrpSBERABERABBImIAFO +GJ0uFAEREAEREIHECUiAE2enK0VABERABEQgYQIS4ITR6UIREAEREAERSJyABDhxdrpSBERABERA +BBImIAFOGJ0uFAEREAEREIHECUiAE2enK0VABERABEQgYQIS4ITR6UIREAEREAERSJyABDhxdrpS +BERABERABBImIAFOGJ0uFAEREAEREIHECUiAE2enK0VABERABEQgYQIS4ITR6UIREAEREAERSJyA +BDhxdrpSBERABERABBImIAFOGJ0uFAEREAEREIHECUiAE2enK0VABERABEQgYQIS4ITR6UIREAER +EAERSJyABDhxdrpSBERABERABBImIAFOGJ0uFAEREAEREIHECQQV4KNHj+7du/fAgQOJJ6UrRUAE +REAEREAE/kOg6H8cXv/37ds3f/78H3/8sUKFCt26dStSpMjq1av5W79+/dKlS3tdqXMiIAIiIAIi +IALRCPgL8OHDh//9738/9dRTGzZsKFu27Lp16woXLjx79uyDBw8OGDCgV69epUqVihZzMv0KFSpk +o/v111+tO6CjgJcHTEXBREAEREAERCA4AX8B3rFjxwcffPDLL79ceuml27Zte+2110qWLNmgQQN8 +xo4d26hRo2bNmjkVLnjaAUNGRM5hXBpcwMsDGqlgIiACIiACIhAXAX8B3rx585o1ay666KKhQ4fu +3r17xowZ9Dzfe++99EiPHDly0aJFaHCxYsXiSrWAgYNrcIT6FjBdXS4CIiACIiACySLgMwmLtuaR +I0dIjNFf/jIViw7n8uXL0wiuVKkSPnREJ8uUuOIJoqxBwsSVqAKLgAiIgAiIQLII+LSA0bAqVarQ +5J08eXKJEiXojqYRvGLFihdeeGHJkiXVqlVr3Lgxs7GSZU1c8WCbR1+01DcumAosAiIgAiKQZgJe +GmZMQeRQ3DFjxtDbjBifd955RYsWpSOayVn9+/dv2bIlc7JiGe1WQQ/JjBUJ/u54PAKThEf4xAzw +SE6nREAEREAEcpiAW1CSpSP+Amyw7ty5c9myZZs2bapatWrFihVNR7TvGqQk2u2OKoHyTha1BJLW +JSIgAiIgAtlIwK0+yZISny5oA4tu588+++zTTz9dv349a4IZA65cufIpp5zSp08fHOkBSobdFOJK +OlnI4kpUgUVABERABEQgKgF/AWb3qylTpowaNQqtPfbYY5mNxVSsVatWPffcc1u2bBk8eLCZnxU1 +9uR6FkSDpb7JLQvFJgIiIAIiUEAC/gK8devWmTNn1qtX78Ybb6xZsybzn5kXvX37dhYEz5o1q1On +Tm3btvUYBi6gfRGXJ6bBUt8IjDoUAREQARHIOIGY86esZbt27WLyc48ePRBaBJgBYKZiHXfccawM +pim8du1as07JhpdDBERABERABETAl4C/AJcrV47O52nTps2dO5fBYBb+sh8WE7ImTpyIm1NpXoYU +b3M23vC+yBRABERABERABApOwH8WNCo7ffr00aNHo74s/GUGFgK8ceNGDgcOHHj55Zd7zMNyT5tK +lhy6Y47KIlnJRY1cniIgAiIgAjlPwC03yVIWfwEGLr3QfH2Btb98j2HPnj1Yw1cZWrdu3a9fP8aG +3cbZ8nCfSpbdJOGO3KZrHElMKyJmHYqACIiACOQJAbfWJEtcAgkwlGkHM/GK1cB8FZidn8uUKUPD +l79uy5xF4j6bLLtNKu74berJTchGK4cIiIAIiEBeEXALTbL0JagAW9wmYbdBNoDT4Q6WLLttKu4k +OJX0VGxycoiACIiACOQVAbfKJEti/JchRYB2mxIRIM2H7heCZKFJc0aUnAiIgAiIQF4RiFuAw0lH +ohvOcpFVIiACIiACsQj4L0OKdaX8RUAEREAEREAEEiYgAU4YnS4UAREQAREQgcQJSIATZ6crRUAE +REAERCBhAjkyBhxX/p3zyDR4HBc6BRYBERABEUgWgbwTYKf6ApFDaXCyKpPiEQEREIFUE3A+w7P9 +6Z1HXdAUm7PkUl1LFL8IiIAIiEByCUQ8wyMOk5tWGmLLFwHO9nJKQ1VQEiIgAiKQdQSy+tme+wJM +8WR1CWXd/SCDRUAERCCdBLL3CZ/jAuxbMNk+hJDOWq60REAERCCcBHwf9eE0O2cFmPLwLRKpbzgr +pawSAREQgagEPB7avg/8qBFm1jM3Bdi3JChFj4LMbJEodREQAREQgVgEPB7dvk/+WHFmyj/XBJgC +8C0Dj/LLVDEoXREQAREQgYAEPJ7hvs//gEmkJ1hOCbAveorNo+TSQ1yp5CSB5cuXly1btlWrVocO +HbIZ5PvZderUadKkyb59+6xnhOOyyy6j3j7wwAMR/rEOS5UqNXLkyFhn5S8CeULA40nuKwThQZQj +AgxxX+geBRae8pAlWUqgYcOGDz300A8//PDII4/YLAwbNmzt2rUvvfQSqmk9nQ6EecKECUWLFn3j +jTec/h7uCy+8sHnz5h4BdEoE8oSAxyPdVw5Cgii1+0C5KXggS5iIO5WIqFKRaEQSOhQBqlm3bt2+ +/vrrefPmNW3adPbs2Z07d7722mtHjRoVC864ceMGDhx45513Dh8+nKtat24dK6T8RUAEohLweP4n +68nvTiJZMf8XEaXu5+aV9LTcSchHBJJOIGC9XbRoUcmSJZHhAwcOtGzZskGDBrt37/a49owzzujS +pcumTZuKFClyxx132JAvvvhiz54958yZY3xmzpzZq1evDz/8kMNzzjnn7bffNv4rVqy4++67aRDT +/qYre/v27TYGOUQgfwh43O9JgeCOPynREokE2M1WPiIQhUDAW+7RRx/l4k6dOvH3448/9rhq48aN +dD6PHj2aMKeeeioiagMjpcccc0ybNm0YUUbLkdi2bdsePHiQAAg8SeDgsHHjxh06dHjllVduv/32 +2rVrn3766TaGWI4oGZOXCOQ0gVj3QnB/N57g13qHlAC72cpHBKIQ8L6R7NnDhw+3a9eO6y+//HLr +GdVB1zQN3w0bNnD22Wef5ZIvv/zShnzvvffweeyxx+6///5ixYp999135pQVYLqsCcAQsvH/5JNP +unbtun//fhuD20F4/UQg3wi4b4R4fdzE4o0hVngJsJutfEQgCoFYt1CEP/3J1atX5/qOHTseOXIk +4qzzsH379qeddprxWbduXeHChYcOHeoMMGjQoDJlypQoUeLee++1/laAUW6EuVmzZuPHjw/Y+Rwl +V/ISgVwnYO+dhB1uQglHFXFh1gsw+XHTkY8IJJ1AxJ0T65BZymgkkokBjz/+eKxgixcvJgD6Wus/ +PwS4Zs2aTs1eunQpYcqVK8dkaRuPFWB8GBU2rW1a0t27d3///fdtsKgOYtNPBPKNQNR7IS5PN7G4 +LvcInAsCTPbcgOQjAkkk4HELOU+99dZbJPrwww/jSeuW1UdLlixxBrBuJk8VL1786aef/ut/fldf +fTXXOoeNhwwZUrp0aTzpiLYXOgXYeP70009PPPEEc76Q4e+//96GdDuSCERRiUC2EHDfCPH6uHMa +bwyxwueFAMfKvPxFIIkEmFRVrVq1E088kZlTREv7FQFmRvTRo0fdqRx33HH//d//7fTftm0bXcqI +rvGcOnUqtz1jw5deeinx0GI2/laAp02bduaZZzLkbPyZEU34f/zjH8443W73o0Q+IpDDBNy3QAI+ +bj4JRBL1krwQYPBFzbw8RSCJBC644AJmNc+dO9fGSVOYuvfMM89YH+OYNWsW/mPHjo3wZxpzpUqV +mPa8a9eu+vXrM0hMj/TmzZvRdSZYGSG3Asy4L8J86623rl69mrlX7KXFakU7VysiZh2KQK4ScKuj +9UlWlm2E1pG0mJMVUdR4rLnWETVYUjxtEh6OpCSkSETATeDNN9+k4jnX8hKGpjB7a7BFJRtVOi9h +dw76lt1LhFn+SyQTJ04kAP3JVstff/11/OmrJhIrwLhHjBhBMH4oMR3aDz74oDMVuUUg5wmk52nv +TiVZYHNhJywnHfeWJc6zxg07t6d8RCAbCTB9euHChVT7Fi1amNnX2ZgL2SwCCRDweNon9yHvTihZ +8eeaAFOKbljuok0WPnfM8hEBERABEUg1AY/nfNIf7+60kpVEjnyMwVnYoPGlA1A3U2ckcouACIiA +CISTgMfT2/fhH6oc5aAAG75BisGjFENVSDJGBERABETAEPB4bgd57IcKY4ICzD60Zq1FqDITYQyF +4VselKVHcUZEqEMREAEREIFwEvB92ofQ7KKJ2bRgwQIuZI945mQmFkParjKl4q2ynM3GwksbQyUk +AiIgAmEmkKUP8EACbBYgOjVs+vTpLFVkeWKdOnXCXCrWNorHab/1l0MEREAERCCrCWSp+sLcX4Dp +amZPHxYystaQC0xjkc+2sPMOX0Pr169fhQoVsqLwTCFJhrOisGSkCIiACEQlENGayl71JXf+Asxw +7/z589kYr3LlyibnJsPsJMAH0dgLvnz58lmkahGFF7WA5SkCIiACIhBaAlktuk6q/mOfbIbHJrd8 +ZI2Nau2VuA2CGjVqIMDWP8LhFubwgHPaFh6rIgDqUAREQAREILMEnGJhLEmWZPgLcEFynjq7C2KV +rhUBERABERCBgARSJ2T+XdDWRJrCa9as2bt3L4O+NHz5fKk9JYcIiIAIiIAIiEBcBAIJMN8DZ9rz +lClTEGC+u0Kfc5UqVTp37ty3b1++Fh5XegosAiIgAiIgAiIAAX8B5uNoSC9fYuGjLnzElM+l8QnS +lStXjh49euvWrYMGDZIGqyaJgAiIgAiIQLwE/AUYlZ0xYwbrfYcOHVqrVi0WI7EsGM9XX5kJLsIA +AANSSURBVH0V/w4dOvDBNXVHx8td4UVABERABPKcgP847s6dO3fs2NG9e3dWHNWuXZsWMP3PrAC+ +8MILzagwf/McorIvAiIgAiIgAvES8Bdg1vuy3yTfBkeGbexMwmZxMBOyOKvmr8UihwiIgAiIgAgE +JOC/DIlZV4wBv/baa0WKFGH+M13Qu3fvRoy3bdvWu3fv3//+9zVr1oyVWOpmb8dKUf4iIAIiIAIi +kEQCqRMyfwEmG8jt7NmzZ86cuX37dvSYPmc24mDo94wzzqhXr55HC9htdxKhKCoREAEREAERSD+B +DGzEQcN34cKFGzZsoMnLdGgmRRct6jOHSwKc/pqhFEVABERABFJKIFkC7KOgJg+sO6IXeuzYsatX +r+YjSHREV69e/cwzz7zggguc+1OmNMOKXAREQAREQARyiYB/FzTrgCdOnDhy5EhWIrVp04ZPEPJ9 +pMWLF/NBpMGDBw8ZMsRjHbBawLlUV5QXERABERABCKSvBcyS3zlz5px88sm33HIL3c5mHfCePXvG +jRv3zTffoMQnnHCCxzCwSksEREAEREAERMBNwH8ZklkHfMoppzRo0KBq1aplypShycswcJ8+fdiR +Y+3atXRQu+M1Psl6TYgVv/xFQAREQAREIJ0Ekqhr/mPA7PzMb9asWQz6VqxYkXyiu/z9+uuvWQfM +vhwsT/LIfBJt9UhFp0RABERABEQguwj4CzD7XnXr1u2RRx656KKLWrVqRfN3y5Yty5cvZ0b0wIED +mzZt6i3A2YVD1oqACIiACIhAegj4T8LCDmY+0wJ+6623li1bxpeRGPFFhnv16sVulHXr1tVMq/QU +lVIRAREQARHIJQKBBJgMHzx4EBlmRjQjvggwq4/YhJLxYE2/yqXaoLyIgAiIgAikjUBQAU6bQUpI +BERABERABPKBgP8s6HygoDyKgAiIgAiIQJoJSIDTDFzJiYAIiIAIiMD/IyABVj0QAREQAREQgQwQ +kABnALqSFAEREAEREAEJsOqACIiACIiACGSAgAQ4A9CVpAiIgAiIgAhIgFUHREAEREAERCADBCTA +GYCuJEVABERABERAAqw6IAIiIAIiIAIZICABzgB0JSkCIiACIiACEmDVAREQAREQARHIAIH/Dz93 +dVWwJbMUAAAAAElFTkSuQmCC +The Chameleon screen layoutBackground Set the position of background.png within the screenbackground_pos_x<key>background_pos_x</key><string>-0</string>0 pixels from reverse origin along the x axisbackground_pos_y <key>background_pos_y</key><string>-0</string>0 pixels from reverse origin along the y axisLogoSet the position of logo.png within the screenlogo_pos_x <key>logo_pos_x</key><string>0</string>0 pixels from origin along the x axislogo_pos_y <key>logo_pos_y</key><string>0</string>0 pixels from origin along the y axisDevices Set the position of the device list within the screendevices_pos_x <key>devices_pos_x</key><string></string>blank to center on the x axisdevices_pos_y <key>logo_pos_y</key><string></string>blank to center on the y axisdevices_max_visible <key>devices_max_visible</key>maximum number of devices visible<string>4</string>devices_icon_spacing <key>devices_icon_spacing</key>spaces between the drive icons<string>20</string>devices_layout <key>devices_layout</key><string>horizontal</string>horizontal or vertical listdevices_bgcolor <key>devices_bgcolor</key><string>#000000</string>web format #RRGGBBdevices_transparency <key>devices_transparency</key><string>128</string>0 (Opaque) -> 255 (Transparent)Boot prompt Set the position of the boot prompt within the screenbootprompt_pos_x <key>bootprompt_pos_x</key><string></string>blank to center on the x axisbootprompt_pos_y <key>bootprompt_pos_y</key><string></string>blank to center on the y axisbootprompt_width <key>bootprompt_width</key><string>-20</string>20 pixels less than the screen's width windowbootprompt_height <key>bootprompt_height</key><string>20</string>20 pixel high windowbootprompt_textmargin_h <key>bootprompt_textmargin_h</key>8 pixel horizontal text margin left and right<string>8</string>bootprompt_textmargin_v <key>bootprompt_textmargin_v</key>4 px vertical text margin both top and bottom<string>4</string>bootprompt_bgcolor <key>bootprompt_bgcolor</key><string>0x333445</string>web format #RRGGBBbootprompt_transparency <key>bootprompt_transparency</key><string>0</string>0 (Opaque) -> 255 (Transparent)Info box Set the position of the info box within the screeninfobox_pos_x <key>infobox_pos_x</key><string></string>blank to center on the x axisinfobox_pos_y <key>infobox_pos_y</key><string></string>blank center on the y axisinfobox_width <key>infobox_width</key><string>550</string>550 pixels wideinfobox_height <key>infobox_height</key><string>406</string>406 pixels highinfobox_bgcolor <key>infobox_bgcolor</key><string>#333445</string>web format #RRGGBBinfobox_transparency <key>infobox_transparency</key><string>64</string>0 (Opaque) -> 255 (Transparent)Menu Set the position of the pop up menu within the screenmenu_pos_x <key>menu_pos_x</key><string></string>center on the x axismenu_pos_y <key>menu_pos_y</key><string></string>center on the y axismenu_bgcolor <key>menu_bgcolor</key><string>#111223</string>web format #RRGGBBmenu_transparency <key>menu_transparency</key><string>0</string>0 (Opaque) -> 255 (Transparent)Boot DisplaySet the display dimensions to use when booting the kernel, will attempt to find the closest one available.boot_width <key>boot_width</key><string>1280</string>1280 pixels wide screenboot_height <key>boot_height</key><string>1024</string>1024 pixels tall screenGetting in touchChameleon homepagehttp://chameleon.osx86.hu/E-mail : voodoo@mercurysquad.comHope you guys like the bootloader!We appreciate your feedback and supportPAGE PAGE 1 \ No newline at end of file Index: trunk/doc/User_Guide_src/install_start.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/User_Guide_src/install_start.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/User_Guide_src/install_cust.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/User_Guide_src/install_cust.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/User_Guide_src/install_dest.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/User_Guide_src/install_dest.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/User_Guide_src/screen_format.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/User_Guide_src/screen_format.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/User_Guide_src/chameleon.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/User_Guide_src/chameleon.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/User_Guide_src/xnulogo.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/User_Guide_src/xnulogo.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/Users_Guide0.5.pdf =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/doc/Users_Guide0.5.pdf ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/doc/BootHelp.txt =================================================================== --- trunk/doc/BootHelp.txt (revision 0) +++ trunk/doc/BootHelp.txt (revision 1) @@ -0,0 +1,91 @@ +The boot: prompt waits for you to type advanced startup options. +If you don't type anything, the computer continues starting up normally. It +uses the kernel and configuration files on the startup device, which it also +uses as the root device. + +Advanced startup options use the following syntax: + + [device] [arguments] + +Example arguments include + + device: rd= (e.g. rd=disk0s2) + rd=* (e.g. rd=*/PCI0@0/CHN0@0/@0:1) + + kernel: kernel name (e.g. "mach_kernel" - must be in "/" ) + + flags: -v (verbose) -s (single user mode), + -x (safe mode) -F (ignore boot configuration file) + + "Graphics Mode"="WIDTHxHEIGHTxDEPTH" (e.g. "1024x768x32") + + kernel flags (e.g. debug=0x144) + io=0xffffffff (defined in IOKit/IOKitDebug.h) + +Example: mach_kernel rd=disk0s1 -v "Graphics Mode"="1920x1200x32" + +If the computer won't start up properly, you may be able to start it up using +safe mode. Type -x to start up in safe mode, which ignores all cached +driver files. + +Special booter hotkeys: + F5 Rescans optical drive. + F10 Scans and displays all BIOS accessible drives. + +Special booter commands: + ?memory Displays information about the computer's memory. + ?video Displays VESA video modes supported by the computer's BIOS. + ?norescan Leaves optical drive rescan mode. + +Additional useful command-line options: + config= Use an alternate Boot.plist file. + +Options useful in the com.apple.Boot.plist file: + Wait=Yes|No Prompt for a key press before starting the kernel. + "Quiet Boot"=Yes|No Use quiet boot mode (no messages or prompt). + Timeout=8 Number of seconds to pause at the boot: prompt. + "Instant Menu"=Yes Force displaying the partition selection menu. + + "Default Partition" Sets the default boot partition, + =hd(x,y) where 'x' is the disk number, 'y' the partition number. + "Hide Partition" Remove unwanted partition(s) from the boot menu. + =hd(x,y) [hd(m,n)] + + GUI=No Disable the GUI (enabled by default). + "Boot Banner"=Yes|No Show boot banner in GUI mode (enabled by default). + "Legacy Logo"=Yes|No Use the legacy grey apple logo (disabled by default). + + PciRoot= Use an alternate value for PciRoot. (default value: 0). + + GraphicsEnabler=Yes|No Automatic device-properties generation for graphics cards. + VideoROM= Use an alternate ROM image (default path: /NVIDIA.ROM). + VBIOS=Yes|No Inject VBIOS to device-properties. + + EthernetBuiltIn=Yes|No Automatic "built-in"=yes device-properties generation + for ethernet interfaces. + + USBBusFix=Yes Enable the EHCI and UHCI fixes (disabled by default). + EHCIacquire=Yes Enable the EHCI fix (disabled by default). + UHCIreset=Yes Enable the UHCI fix (disabled by default). + + Wake=No Disable wake up after hibernation (enbaled by default). + ForceWake=Yes Force using the sleepimage (disabled by default). + WakeImage= Use an alternate sleepimage file + (default path is /private/var/vm/sleepimage). + + DropSSDT=Yes Skip the SSDT tables while relocating the ACPI tables. + DSDT= Use an alternate DSDT.aml file + (default path: /DSDT.aml /Extra/DSDT.aml) + + SMBIOS= Use an alternate smbios.plist file + (default path: /smbios.plist /Extra/smbios.plist + bt(0,0)/Extra/smbios.plist). + + SMBIOSdefaults=No Don't use the Default values for SMBIOS overriding + if smbios.plist doesn't exist, factory + values are kept. + + "Scan Single Drive" Scan the drive only where the booter got loaded from. + =Yes|No Fix rescan issues when using a DVD reader in AHCI mode. + Rescan=Yes Enable CD-ROM rescan mode. + "Rescan Prompt"=Yes Prompts for enable CD-ROM rescan mode. Index: trunk/doc/README =================================================================== --- trunk/doc/README (revision 0) +++ trunk/doc/README (revision 1) @@ -0,0 +1,97 @@ + + Chameleon Boot Loader + ===================== + + What is it? + ----------- + + Chameleon is combination of various boot loader components. It is based + on David Elliott's fake EFI implementation added to Apple's boot-132 + project. Chameleon is extended with the following key features: + + + Features + -------- + + - Device Property Injection via device-properties string in com.apple.Boot.plist + - hybrid boot0+boot1h loaders for both MBR and GPT partitioned disks. + - automatic FSB detection code even for recent AMD CPUs. + - Apple Software RAID support. + - stage2 loader (boot) can be placed as a regular file in the boot + partition's root folder. It has precedence over the embedded + startupfile. + + + Installation + ============ + + Normal Install (non-RAID): + -------------------------- + + Suppose that your installation is on /dev/disk0s2 + + - Install boot0 to the MBR: + sudo fdisk -f boot0 -u -y /dev/rdisk0 + + - Install boot1h to the partition's bootsector: + sudo dd if=boot1h of=/dev/rdisk0s2 + + - Install boot to the partition's root directory: + sudo cp boot / + + No need to use startupfiletool anymore! + + + RAID Install: + ------------- + + Suppose that your installation is on /dev/disk3, which is either a mirror- or a + stripeset consisting of /dev/disk0 and /dev/disk1 + + Mac OS X creates a small helper partition at the end of each RAID member disk, + namely /dev/disk0s3 and /dev/disk1s3 + + - Install boot0 to the MBR of both disks: + sudo fdisk -f boot0 -u -y /dev/rdisk0 + sudo fdisk -f boot0 -u -y /dev/rdisk1 + + - Install boot1h to the bootsector of each boot partition: + sudo dd if=boot1h of=/dev/rdisk0s3 + sudo dd if=boot1h of=/dev/rdisk1s3 + + - Install boot to both helper partition's root directories. + diskutil mount disk0s3 + cp boot /Volumes/Boot\ OSX + diskutil unmount disk0s3 + diskutil mount disk1s3 + cp boot /Volumes/Boot\ OSX + diskutil unmount disk1s3 + + - Add "rd=uuid boot-uuid=506D8F03-0596-32D8-BE0B-E3A4E7D5C72A" to your kernel flags + (replace with your root volume's UUID; find out using "Disk Utility.app", right + click on your root volume, then Get Info"): + nano /Library/Preferences/SystemConfiguration/com.apple.Boot.plist + touch /System/Library/Extensions + + + Support: + -------- + + If you have any questions, issues etc. feel free to join us + at irc.voodooprojects.org #chameleon + + + Source Code + ----------- + + For downloading the source code please visit the project page at + http://chameleon.osx86.hu + + + Licensing + --------- + + Chameleon is released under the terms and conditions of + Apple Public Source License (see APPLE_LICENSE). + To use "Chameleon" for commercial purposes please contact us at: + http://chameleon.osx86.hu/contact Index: trunk/version =================================================================== --- trunk/version (revision 0) +++ trunk/version (revision 1) @@ -0,0 +1 @@ +2.0-RC4 \ No newline at end of file Index: trunk/artwork/themes/default/text_scroll_prev.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/text_scroll_prev.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/device_fat32.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/device_fat32.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/font_small.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/font_small.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/text_scroll_next.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/text_scroll_next.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/device_fat16.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/device_fat16.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/logo.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/logo.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/device_ext3.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/device_ext3.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_single_user.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_single_user.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/boot.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/boot.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/device_hfsplus.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/device_hfsplus.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_ignore_caches_disabled.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_ignore_caches_disabled.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/device_selection.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/device_selection.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_video_info.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_video_info.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_memory_info.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_memory_info.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_selection.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_selection.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/device_scroll_prev.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/device_scroll_prev.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/theme.plist =================================================================== --- trunk/artwork/themes/default/theme.plist (revision 0) +++ trunk/artwork/themes/default/theme.plist (revision 1) @@ -0,0 +1,106 @@ + + + + + Enabled + no + screen_width + 1024 + screen_height + 768 + screen_textmargin_h + 10 + screen_textmargin_v + 10 + screen_bgcolor + #222334 + background_pos_x + 50% + background_pos_y + 0 + logo_pos_x + + logo_pos_y + 3% + logo_bgcolor + #000000 + logo_transparency + 255 + devices_pos_x + + devices_pos_y + + devices_bgcolor + #222334 + devices_transparency + 0 + devices_max_visible + 5 + devices_iconspacing + 20 + devices_layout + horizontal + bootprompt_pos_x + %50 + bootprompt_pos_y + -2 + bootprompt_width + 50% + bootprompt_height + 20 + bootprompt_textmargin_h + 10 + bootprompt_textmargin_v + 5 + bootprompt_bgcolor + #222334 + bootprompt_transparency + 1 + infobox_pos_x + + infobox_pos_y + + infobox_width + 650 + infobox_height + 406 + infobox_textmargin_h + 10 + infobox_textmargin_v + 10 + infobox_bgcolor + #222334 + infobox_transparency + 10 + menu_pos_x + + menu_pos_y + -5% + menu_textmargin_h + 10 + menu_textmargin_v + 5 + menu_bgcolor + #222334 + menu_transparency + 1 + progressbar_pos_x + + progressbar_pos_y + -30% + progressbar_width + 100 + progressbar_height + 40 + countdown_pos_x + + countdown_pos_y + -20% + boot_width + 1024 + boot_height + 768 + boot_bgcolor + #AAAAAA + + Index: trunk/artwork/themes/default/device_scroll_next.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/device_scroll_next.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_help.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_help.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_ignore_caches.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_ignore_caches.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/background.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/background.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_verbose_disabled.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_verbose_disabled.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/device_cdrom.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/device_cdrom.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_boot.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_boot.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/progress_bar_background.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/progress_bar_background.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/font_console.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/font_console.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/progress_bar.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/progress_bar.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/device_ntfs.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/device_ntfs.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_verbose.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_verbose.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/menu_single_user_disabled.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/menu_single_user_disabled.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/default/device_generic.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/default/device_generic.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/text_scroll_prev.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/text_scroll_prev.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/device_fat32.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/device_fat32.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/font_small.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/font_small.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/text_scroll_next.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/text_scroll_next.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/device_fat16.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/device_fat16.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/logo.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/logo.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/device_ext3.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/device_ext3.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_single_user.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_single_user.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/boot.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/boot.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/device_hfsplus.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/device_hfsplus.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_ignore_caches_disabled.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_ignore_caches_disabled.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/device_selection.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/device_selection.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_video_info.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_video_info.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_memory_info.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_memory_info.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_selection.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_selection.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/device_scroll_prev.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/device_scroll_prev.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/theme.plist =================================================================== --- trunk/artwork/themes/bullet/theme.plist (revision 0) +++ trunk/artwork/themes/bullet/theme.plist (revision 1) @@ -0,0 +1,116 @@ + + + + + Enabled + yes + + screen_width + 1024 + screen_height + 768 + screen_textmargin_h + 10 + screen_textmargin_v + 10 + screen_bgcolor + #aaaaaa + + background_pos_x + 50% + background_pos_y + 0 + + logo_pos_x + + logo_pos_y + 3% + logo_bgcolor + #aaaaaa + logo_transparency + 255 + + devices_pos_x + + devices_pos_y + + devices_bgcolor + #aaaaaa + devices_transparency + 0 + devices_max_visible + 5 + devices_iconspacing + 20 + devices_layout + horizontal + + bootprompt_pos_x + %50 + bootprompt_pos_y + -2 + bootprompt_width + 50% + bootprompt_height + 20 + bootprompt_textmargin_h + 10 + bootprompt_textmargin_v + 5 + bootprompt_bgcolor + #aaaaaa + bootprompt_transparency + 1 + + infobox_pos_x + + infobox_pos_y + + infobox_width + 650 + infobox_height + 406 + infobox_textmargin_h + 10 + infobox_textmargin_v + 10 + infobox_bgcolor + #aaaaaa + infobox_transparency + 10 + + menu_pos_x + + menu_pos_y + -5% + menu_textmargin_h + 10 + menu_textmargin_v + 5 + menu_bgcolor + #aaaaaa + menu_transparency + 1 + + progressbar_pos_x + + progressbar_pos_y + -37% + progressbar_width + 100 + progressbar_height + 40 + + countdown_pos_x + + countdown_pos_y + -30% + + boot_width + 1024 + boot_height + 768 + boot_bgcolor + #aaaaaa + + Index: trunk/artwork/themes/bullet/device_scroll_next.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/device_scroll_next.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_help.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_help.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_ignore_caches.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_ignore_caches.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/background.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/background.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_verbose_disabled.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_verbose_disabled.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/device_cdrom.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/device_cdrom.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_boot.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_boot.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/progress_bar_background.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/progress_bar_background.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/font_console.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/font_console.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/progress_bar.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/progress_bar.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/device_ntfs.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/device_ntfs.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_verbose.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_verbose.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/menu_single_user_disabled.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/menu_single_user_disabled.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/bullet/device_generic.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/bullet/device_generic.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/pinktink/logo.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/pinktink/logo.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/pinktink/theme.plist =================================================================== --- trunk/artwork/themes/pinktink/theme.plist (revision 0) +++ trunk/artwork/themes/pinktink/theme.plist (revision 1) @@ -0,0 +1,106 @@ + + + + + Enabled + no + screen_width + 1024 + screen_height + 768 + screen_textmargin_h + 10 + screen_textmargin_v + 10 + screen_bgcolor + #FF1493 + background_pos_x + + background_pos_y + + logo_pos_x + 20% + logo_pos_y + 20% + logo_bgcolor + #000000 + logo_transparency + 255 + devices_pos_x + + devices_pos_y + + devices_bgcolor + #FF1493 + devices_transparency + 0 + devices_max_visible + 5 + devices_iconspacing + 20 + devices_layout + horizontal + bootprompt_pos_x + %50 + bootprompt_pos_y + -2 + bootprompt_width + 50% + bootprompt_height + 20 + bootprompt_textmargin_h + 10 + bootprompt_textmargin_v + 5 + bootprompt_bgcolor + #FF1493 + bootprompt_transparency + 1 + infobox_pos_x + + infobox_pos_y + + infobox_width + 650 + infobox_height + 406 + infobox_textmargin_h + 10 + infobox_textmargin_v + 10 + infobox_bgcolor + #FF1493 + infobox_transparency + 10 + menu_pos_x + + menu_pos_y + -5% + menu_textmargin_h + 10 + menu_textmargin_v + 5 + menu_bgcolor + #FF1493 + menu_transparency + 1 + progressbar_pos_x + + progressbar_pos_y + -30% + progressbar_width + 100 + progressbar_height + 40 + countdown_pos_x + + countdown_pos_y + -20% + boot_width + 1024 + boot_height + 768 + boot_bgcolor + #AAAAAA + + Index: trunk/artwork/themes/msi_netbook/logo.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/msi_netbook/logo.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/msi_netbook/theme.plist =================================================================== --- trunk/artwork/themes/msi_netbook/theme.plist (revision 0) +++ trunk/artwork/themes/msi_netbook/theme.plist (revision 1) @@ -0,0 +1,106 @@ + + + + + Enabled + no + screen_width + 1024 + screen_height + 768 + screen_textmargin_h + 10 + screen_textmargin_v + 10 + screen_bgcolor + #000000 + background_pos_x + 50% + background_pos_y + 0 + logo_pos_x + + logo_pos_y + 15% + logo_bgcolor + #000000 + logo_transparency + 255 + devices_pos_x + + devices_pos_y + + devices_bgcolor + #000000 + devices_transparency + 0 + devices_max_visible + 5 + devices_iconspacing + 20 + devices_layout + horizontal + bootprompt_pos_x + %50 + bootprompt_pos_y + -2 + bootprompt_width + 50% + bootprompt_height + 20 + bootprompt_textmargin_h + 10 + bootprompt_textmargin_v + 5 + bootprompt_bgcolor + #000000 + bootprompt_transparency + 1 + infobox_pos_x + + infobox_pos_y + + infobox_width + 650 + infobox_height + 406 + infobox_textmargin_h + 10 + infobox_textmargin_v + 10 + infobox_bgcolor + #000000 + infobox_transparency + 10 + menu_pos_x + + menu_pos_y + -5% + menu_textmargin_h + 10 + menu_textmargin_v + 5 + menu_bgcolor + #000000 + menu_transparency + 1 + progressbar_pos_x + + progressbar_pos_y + -30% + progressbar_width + 100 + progressbar_height + 40 + countdown_pos_x + + countdown_pos_y + -20% + boot_width + 1024 + boot_height + 768 + boot_bgcolor + #AAAAAA + + Index: trunk/artwork/themes/twilight/font_small.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/twilight/font_small.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/twilight/logo.png =================================================================== Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: trunk/artwork/themes/twilight/logo.png ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Index: trunk/artwork/themes/twilight/theme.plist =================================================================== --- trunk/artwork/themes/twilight/theme.plist (revision 0) +++ trunk/artwork/themes/twilight/theme.plist (revision 1) @@ -0,0 +1,106 @@ + + + + + Enabled + no + screen_width + 1024 + screen_height + 768 + screen_textmargin_h + 10 + screen_textmargin_v + 10 + screen_bgcolor + #000000 + background_pos_x + 50% + background_pos_y + 0 + logo_pos_x + + logo_pos_y + 3% + logo_bgcolor + #000000 + logo_transparency + 255 + devices_pos_x + + devices_pos_y + + devices_bgcolor + #000000 + devices_transparency + 0 + devices_max_visible + 5 + devices_iconspacing + 20 + devices_layout + horizontal + bootprompt_pos_x + %50 + bootprompt_pos_y + -2 + bootprompt_width + 50% + bootprompt_height + 20 + bootprompt_textmargin_h + 10 + bootprompt_textmargin_v + 5 + bootprompt_bgcolor + #000000 + bootprompt_transparency + 1 + infobox_pos_x + + infobox_pos_y + + infobox_width + 650 + infobox_height + 406 + infobox_textmargin_h + 10 + infobox_textmargin_v + 10 + infobox_bgcolor + #000000 + infobox_transparency + 10 + menu_pos_x + + menu_pos_y + -5% + menu_textmargin_h + 10 + menu_textmargin_v + 5 + menu_bgcolor + #000000 + menu_transparency + 1 + progressbar_pos_x + + progressbar_pos_y + -30% + progressbar_width + 100 + progressbar_height + 40 + countdown_pos_x + + countdown_pos_y + -20% + boot_width + 1024 + boot_height + 768 + boot_bgcolor + #AAAAAA + + Index: trunk/efisysinst.sh =================================================================== --- trunk/efisysinst.sh (revision 0) +++ trunk/efisysinst.sh (revision 1) @@ -0,0 +1,31 @@ +#!/bin/sh + +# efisysinst.sh +# +# +# Created by mackerintel on 2/2/09. +# Copyright 2009 mackerintel. All rights reserved. + +if [[ x$1 == x ]]; then + echo Usage: $0 disknumber; + exit 0; +fi + +if [[ `dd if=/dev/disk${1}s1 count=8 bs=1 skip=82 | uuencode -m -|head -n 2|tail -n 1` != "RkFUMzIgICA=" ]]; then + echo "/dev/disk${1}s1" "isn't" a FAT32 partition; + exit 1; +fi + +if [ ! -f boot1f32 ]; then + echo "boot1f32 not found"; + exit 1; +fi +if [ ! -f boot0 ]; then + echo "boot0 not found"; + exit 1; +fi +dd if=/dev/disk${1}s1 count=1 bs=512 of=/tmp/origbs +cp boot1f32 /tmp/newbs +dd if=/tmp/origbs of=/tmp/newbs skip=3 seek=3 bs=1 count=87 conv=notrunc +dd of=/dev/disk${1}s1 count=1 bs=512 if=/tmp/newbs +dd if=boot0 of=/dev/disk${1} count=430 bs=1 Index: trunk/i386/libsaio/fake_efi.h =================================================================== --- trunk/i386/libsaio/fake_efi.h (revision 0) +++ trunk/i386/libsaio/fake_efi.h (revision 1) @@ -0,0 +1,14 @@ +/* + * Copyright 2007 David F. Elliott. All rights reserved. + */ + +#ifndef __LIBSAIO_FAKE_EFI_H +#define __LIBSAIO_FAKE_EFI_H + +/* Set up space for up to 10 configuration table entries */ +#define MAX_CONFIGURATION_TABLE_ENTRIES 10 + +extern void +setupFakeEfi(void); + +#endif /* !__LIBSAIO_FAKE_EFI_H */ Index: trunk/i386/libsaio/xml.c =================================================================== --- trunk/i386/libsaio/xml.c (revision 0) +++ trunk/i386/libsaio/xml.c (revision 1) @@ -0,0 +1,665 @@ +/* + * Copyright (c) 2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 2003 Apple Computer, Inc. All Rights + * Reserved. + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +#include "bootstruct.h" +#include "libsaio.h" +#include "sl.h" +#include "xml.h" + +struct Module { + struct Module *nextModule; + long willLoad; + TagPtr dict; + char *plistAddr; + long plistLength; + char *driverPath; +}; +typedef struct Module Module, *ModulePtr; + +struct DriverInfo { + char *plistAddr; + long plistLength; + void *moduleAddr; + long moduleLength; +}; +typedef struct DriverInfo DriverInfo, *DriverInfoPtr; + +#define kDriverPackageSignature1 'MKXT' +#define kDriverPackageSignature2 'MOSX' + +struct DriversPackage { + unsigned long signature1; + unsigned long signature2; + unsigned long length; + unsigned long alder32; + unsigned long version; + unsigned long numDrivers; + unsigned long reserved1; + unsigned long reserved2; +}; +typedef struct DriversPackage DriversPackage; + +enum { + kCFBundleType2, + kCFBundleType3 +}; + + +#define USEMALLOC 1 +#define DOFREE 1 + +static long ParseTagList(char *buffer, TagPtr *tag, long type, long empty); +static long ParseTagKey(char *buffer, TagPtr *tag); +static long ParseTagString(char *buffer, TagPtr *tag); +static long ParseTagInteger(char *buffer, TagPtr *tag); +static long ParseTagData(char *buffer, TagPtr *tag); +static long ParseTagDate(char *buffer, TagPtr *tag); +static long ParseTagBoolean(char *buffer, TagPtr *tag, long type); +static long GetNextTag(char *buffer, char **tag, long *start); +static long FixDataMatchingTag(char *buffer, char *tag); +static TagPtr NewTag(void); +static char *NewSymbol(char *string); +#if DOFREE +static void FreeSymbol(char *string); +#endif + + +//========================================================================== +// XMLGetProperty + +TagPtr +XMLGetProperty( TagPtr dict, const char * key ) +{ + TagPtr tagList, tag; + + if (dict->type != kTagTypeDict) return 0; + + tag = 0; + tagList = dict->tag; + while (tagList) + { + tag = tagList; + tagList = tag->tagNext; + + if ((tag->type != kTagTypeKey) || (tag->string == 0)) continue; + + if (!strcmp(tag->string, key)) return tag->tag; + } + + return 0; +} + + +#if UNUSED +//========================================================================== +// XMLParseFile +// Expects to see one dictionary in the XML file. +// Puts the first dictionary it finds in the +// tag pointer and returns 0, or returns -1 if not found. +// +long +XMLParseFile( char * buffer, TagPtr * dict ) +{ + long length, pos; + TagPtr tag; + pos = 0; + + while (1) + { + length = XMLParseNextTag(buffer + pos, &tag); + if (length == -1) break; + + pos += length; + + if (tag == 0) continue; + if (tag->type == kTagTypeDict) break; + + XMLFreeTag(tag); + } + if (length < 0) { + return -1; + } + *dict = tag; + return 0; +} +#endif /* UNUSED */ + +//========================================================================== +// ParseNextTag + +long +XMLParseNextTag( char * buffer, TagPtr * tag ) +{ + long length, pos; + char * tagName; + + length = GetNextTag(buffer, &tagName, 0); + if (length == -1) return -1; + + pos = length; + if (!strncmp(tagName, kXMLTagPList, 6)) + { + length = 0; + } + else if (!strcmp(tagName, kXMLTagDict)) + { + length = ParseTagList(buffer + pos, tag, kTagTypeDict, 0); + } + else if (!strcmp(tagName, kXMLTagDict "/")) + { + length = ParseTagList(buffer + pos, tag, kTagTypeDict, 1); + } + else if (!strcmp(tagName, kXMLTagKey)) + { + length = ParseTagKey(buffer + pos, tag); + } + else if (!strcmp(tagName, kXMLTagString)) + { + length = ParseTagString(buffer + pos, tag); + } + else if (!strcmp(tagName, kXMLTagInteger)) + { + length = ParseTagInteger(buffer + pos, tag); + } + else if (!strcmp(tagName, kXMLTagData)) + { + length = ParseTagData(buffer + pos, tag); + } + else if (!strcmp(tagName, kXMLTagDate)) + { + length = ParseTagDate(buffer + pos, tag); + } + else if (!strcmp(tagName, kXMLTagFalse)) + { + length = ParseTagBoolean(buffer + pos, tag, kTagTypeFalse); + } + else if (!strcmp(tagName, kXMLTagTrue)) + { + length = ParseTagBoolean(buffer + pos, tag, kTagTypeTrue); + } + else if (!strcmp(tagName, kXMLTagArray)) + { + length = ParseTagList(buffer + pos, tag, kTagTypeArray, 0); + } + else if (!strcmp(tagName, kXMLTagArray "/")) + { + length = ParseTagList(buffer + pos, tag, kTagTypeArray, 1); + } + else + { + *tag = 0; + length = 0; + } + + if (length == -1) return -1; + + return pos + length; +} + +//========================================================================== +// ParseTagList + +static long +ParseTagList( char * buffer, TagPtr * tag, long type, long empty ) +{ + long length, pos; + TagPtr tagList, tmpTag; + + tagList = 0; + pos = 0; + + if (!empty) + { + while (1) + { + length = XMLParseNextTag(buffer + pos, &tmpTag); + if (length == -1) break; + + pos += length; + + if (tmpTag == 0) break; + tmpTag->tagNext = tagList; + tagList = tmpTag; + } + + if (length == -1) + { + XMLFreeTag(tagList); + return -1; + } + } + + tmpTag = NewTag(); + if (tmpTag == 0) + { + XMLFreeTag(tagList); + return -1; + } + + tmpTag->type = type; + tmpTag->string = 0; + tmpTag->tag = tagList; + tmpTag->tagNext = 0; + + *tag = tmpTag; + + return pos; +} + +//========================================================================== +// ParseTagKey + +static long +ParseTagKey( char * buffer, TagPtr * tag ) +{ + long length, length2; + char *string; + TagPtr tmpTag, subTag; + + length = FixDataMatchingTag(buffer, kXMLTagKey); + if (length == -1) return -1; + + length2 = XMLParseNextTag(buffer + length, &subTag); + if (length2 == -1) return -1; + + tmpTag = NewTag(); + if (tmpTag == 0) + { + XMLFreeTag(subTag); + return -1; + } + + string = NewSymbol(buffer); + if (string == 0) + { + XMLFreeTag(subTag); + XMLFreeTag(tmpTag); + return -1; + } + + tmpTag->type = kTagTypeKey; + tmpTag->string = string; + tmpTag->tag = subTag; + tmpTag->tagNext = 0; + + *tag = tmpTag; + + return length + length2; +} + +//========================================================================== +// ParseTagString + +static long +ParseTagString( char * buffer, TagPtr * tag ) +{ + long length; + char * string; + TagPtr tmpTag; + + length = FixDataMatchingTag(buffer, kXMLTagString); + if (length == -1) return -1; + + tmpTag = NewTag(); + if (tmpTag == 0) return -1; + + string = NewSymbol(buffer); + if (string == 0) + { + XMLFreeTag(tmpTag); + return -1; + } + + tmpTag->type = kTagTypeString; + tmpTag->string = string; + tmpTag->tag = 0; + tmpTag->tagNext = 0; + + *tag = tmpTag; + return length; +} + +//========================================================================== +// ParseTagInteger + +static long +ParseTagInteger( char * buffer, TagPtr * tag ) +{ + long length, integer; + TagPtr tmpTag; + + length = FixDataMatchingTag(buffer, kXMLTagInteger); + if (length == -1) return -1; + + tmpTag = NewTag(); + if (tmpTag == 0) return -1; + + integer = 0; + + tmpTag->type = kTagTypeInteger; + tmpTag->string = (char *)integer; + tmpTag->tag = 0; + tmpTag->tagNext = 0; + + *tag = tmpTag; + + return length; +} + +//========================================================================== +// ParseTagData + +static long +ParseTagData( char * buffer, TagPtr * tag ) +{ + long length; + TagPtr tmpTag; + + length = FixDataMatchingTag(buffer, kXMLTagData); + if (length == -1) return -1; + + tmpTag = NewTag(); + if (tmpTag == 0) return -1; + + tmpTag->type = kTagTypeData; + tmpTag->string = 0; + tmpTag->tag = 0; + tmpTag->tagNext = 0; + + *tag = tmpTag; + + return length; +} + +//========================================================================== +// ParseTagDate + +static long +ParseTagDate( char * buffer, TagPtr * tag ) +{ + long length; + TagPtr tmpTag; + + length = FixDataMatchingTag(buffer, kXMLTagDate); + if (length == -1) return -1; + + tmpTag = NewTag(); + if (tmpTag == 0) return -1; + + tmpTag->type = kTagTypeDate; + tmpTag->string = 0; + tmpTag->tag = 0; + tmpTag->tagNext = 0; + + *tag = tmpTag; + + return length; +} + +//========================================================================== +// ParseTagBoolean + +static long +ParseTagBoolean( char * buffer, TagPtr * tag, long type ) +{ + TagPtr tmpTag; + + tmpTag = NewTag(); + if (tmpTag == 0) return -1; + + tmpTag->type = type; + tmpTag->string = 0; + tmpTag->tag = 0; + tmpTag->tagNext = 0; + + *tag = tmpTag; + + return 0; +} + +//========================================================================== +// GetNextTag + +static long +GetNextTag( char * buffer, char ** tag, long * start ) +{ + long cnt, cnt2; + + if (tag == 0) return -1; + + // Find the start of the tag. + cnt = 0; + while ((buffer[cnt] != '\0') && (buffer[cnt] != '<')) cnt++; + if (buffer[cnt] == '\0') return -1; + + // Find the end of the tag. + cnt2 = cnt + 1; + while ((buffer[cnt2] != '\0') && (buffer[cnt2] != '>')) cnt2++; + if (buffer[cnt2] == '\0') return -1; + + // Fix the tag data. + *tag = buffer + cnt + 1; + buffer[cnt2] = '\0'; + if (start) *start = cnt; + + return cnt2 + 1; +} + +//========================================================================== +// FixDataMatchingTag +// Modifies 'buffer' to add a '\0' at the end of the tag matching 'tag'. +// Returns the length of the data found, counting the end tag, +// or -1 if the end tag was not found. + +static long +FixDataMatchingTag( char * buffer, char * tag ) +{ + long length, start, stop; + char * endTag; + + start = 0; + while (1) + { + length = GetNextTag(buffer + start, &endTag, &stop); + if (length == -1) return -1; + + if ((*endTag == '/') && !strcmp(endTag + 1, tag)) break; + start += length; + } + + buffer[start + stop] = '\0'; + + return start + length; +} + +//========================================================================== +// NewTag + +#define kTagsPerBlock (0x1000) + +static TagPtr gTagsFree; + +static TagPtr +NewTag( void ) +{ + long cnt; + TagPtr tag; + + if (gTagsFree == 0) + { +#if USEMALLOC + tag = (TagPtr)malloc(kTagsPerBlock * sizeof(Tag)); +#else + tag = (TagPtr)AllocateBootXMemory(kTagsPerBlock * sizeof(Tag)); +#endif + if (tag == 0) return 0; + + // Initalize the new tags. + for (cnt = 0; cnt < kTagsPerBlock; cnt++) + { + tag[cnt].type = kTagTypeNone; + tag[cnt].string = 0; + tag[cnt].tag = 0; + tag[cnt].tagNext = tag + cnt + 1; + } + tag[kTagsPerBlock - 1].tagNext = 0; + + gTagsFree = tag; + } + + tag = gTagsFree; + gTagsFree = tag->tagNext; + + return tag; +} + +//========================================================================== +// XMLFreeTag + +void +XMLFreeTag( TagPtr tag ) +{ +#if DOFREE + if (tag == 0) return; + + if (tag->string) FreeSymbol(tag->string); + + XMLFreeTag(tag->tag); + XMLFreeTag(tag->tagNext); + + // Clear and free the tag. + tag->type = kTagTypeNone; + tag->string = 0; + tag->tag = 0; + tag->tagNext = gTagsFree; + gTagsFree = tag; +#else + return; +#endif +} + +//========================================================================== +// Symbol object. + +struct Symbol +{ + long refCount; + struct Symbol *next; + char string[]; +}; +typedef struct Symbol Symbol, *SymbolPtr; + +static SymbolPtr FindSymbol(char * string, SymbolPtr * prevSymbol); + +static SymbolPtr gSymbolsHead; + +//========================================================================== +// NewSymbol + +static char * +NewSymbol( char * string ) +{ +static SymbolPtr lastGuy = 0; + SymbolPtr symbol; + + // Look for string in the list of symbols. + symbol = FindSymbol(string, 0); + + // Add the new symbol. + if (symbol == 0) + { +#if USEMALLOC + symbol = (SymbolPtr)malloc(sizeof(Symbol) + 1 + strlen(string)); +#else + symbol = (SymbolPtr)AllocateBootXMemory(sizeof(Symbol) + 1 + strlen(string)); +#endif + if (symbol == 0) //return 0; + stop("NULL symbol!"); + + // Set the symbol's data. + symbol->refCount = 0; + strcpy(symbol->string, string); + + // Add the symbol to the list. + symbol->next = gSymbolsHead; + gSymbolsHead = symbol; + } + + // Update the refCount and return the string. + symbol->refCount++; + + if (lastGuy && lastGuy->next != 0) stop("last guy not last!"); + return symbol->string; +} + +//========================================================================== +// FreeSymbol + +#if DOFREE +static void +FreeSymbol( char * string ) +{ + SymbolPtr symbol, prev; + prev = 0; + + // Look for string in the list of symbols. + symbol = FindSymbol(string, &prev); + if (symbol == 0) return; + + // Update the refCount. + symbol->refCount--; + + if (symbol->refCount != 0) return; + + // Remove the symbol from the list. + if (prev != 0) prev->next = symbol->next; + else gSymbolsHead = symbol->next; + + // Free the symbol's memory. + free(symbol); +} +#endif + +//========================================================================== +// FindSymbol + +static SymbolPtr +FindSymbol( char * string, SymbolPtr * prevSymbol ) +{ + SymbolPtr symbol, prev; + + symbol = gSymbolsHead; + prev = 0; + + while (symbol != 0) { + if (!strcmp(symbol->string, string)) break; + + prev = symbol; + symbol = symbol->next; + } + + if ((symbol != 0) && (prevSymbol != 0)) *prevSymbol = prev; + + return symbol; +} Index: trunk/i386/libsaio/asm.s =================================================================== --- trunk/i386/libsaio/asm.s (revision 0) +++ trunk/i386/libsaio/asm.s (revision 1) @@ -0,0 +1,497 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Mach Operating System + * Copyright (c) 1990 Carnegie-Mellon University + * Copyright (c) 1989 Carnegie-Mellon University + * All rights reserved. The CMU software License Agreement specifies + * the terms and conditions for use and redistribution. + */ +/* + * HISTORY + * $Log: asm.s,v $ + * Revision 1.8 2005/06/24 22:47:12 curtisg + * Merging changes for 4159531 to pass data to the kernel in EFI format. + * + * Revision 1.7 2004/05/13 17:58:38 curtisg + * Integrating: + * : (Silent boot) + * : (5 sec boot timeout is too short) + * : (Boot option to display graphics modes) + * : (Default graphics mode should be 32-bit) + * : (Booter should always find a video mode) + * : (Booter displays "0MB" VRAM) + * + * Revision 1.6 2003/11/05 20:51:02 curtisg + * Integrated 3069695,3331770,3370488,3371823 + * + * Revision 1.5.26.1 2003/10/27 23:57:59 curtisg + * Added printing of volume names, better handling of extended + * partitions, and updated Apple license strings. + * New chain booter should work better with foreign operating + * systems. + * + * Revision 1.5 2002/11/05 20:34:26 jliu + * Integrating: + * 3051234 boot shouldnt require Graphics = Yes + * 3091627 Need support for refresh rate adjustment + * + * Revision 1.4 2002/10/02 00:06:18 curtisg + * Integrating PR-3032510. + * + * Revision 1.3.6.1 2002/08/30 21:16:29 curtisg + * KERNBOOTSTRUCT is going away in favor of KernelBootArgs_t in . + * + * Revision 1.3 2002/07/09 14:06:21 jliu + * Merging changes from PR-2954224 branch in boot/i386. + * + * Revision 1.2.30.1 2002/07/05 16:24:51 jliu + * Merged UFS/HFS/HFS+ filesystem support from BootX. + * Moved boot2 load address due to increased size. boot0/boot1 also changed. + * Updated boot graphics and CLUT. + * Added support to chain load foreign booters. + * Fixed param passing bug in network loader. + * Misc cleanup in libsaio. + * + * Revision 1.2 2000/05/23 23:01:11 lindak + * Merged PR-2309530 into Kodiak (liu i386 booter: does not support label-less + * ufs partitions) + * + * Revision 1.1.1.2.4.1 2000/05/13 17:07:39 jliu + * New boot0 (boot1 has been deprecated). Booter must now reside in its own partition, no disk label required. + * + * Revision 1.1.1.2 1999/08/04 21:16:57 wsanchez + * Impoort of boot-66 + * + * Revision 1.3 1999/08/04 21:12:12 wsanchez + * Update APSL + * + * Revision 1.2 1999/03/25 05:48:30 wsanchez + * Add APL. + * Remove unused gzip code. + * Remove unused Adobe fonts. + * + * Revision 1.1.1.1.66.2 1999/03/16 16:08:54 wsanchez + * Substitute License + * + * Revision 1.1.1.1.66.1 1999/03/16 07:33:21 wsanchez + * Add APL + * + * Revision 1.1.1.1 1997/12/05 21:57:57 wsanchez + * Import of boot-25 (~mwatson) + * + * Revision 2.1.1.2 90//03//22 17:59:50 rvb + * Added _sp() => where is the stack at. [kupfer] + * + * Revision 2.1.1.1 90//02//09 17:25:04 rvb + * Add Intel copyright + * [90//02//09 rvb] + * + */ + + +// INTEL CORPORATION PROPRIETARY INFORMATION +// +// This software is supplied under the terms of a license agreement or +// nondisclosure agreement with Intel Corporation and may not be copied +// nor disclosed except in accordance with the terms of that agreement. +// +// Copyright 1988 Intel Corporation +// Copyright 1988, 1989 by Intel Corporation +// + +#include +#include "memory.h" + +#define data32 .byte 0x66 +#define addr32 .byte 0x67 + + .file "asm.s" + +CR0_PE_ON = 0x1 +#ifdef BOOT1 +CR0_PE_OFF = 0x7ffffffe +#else +CR0_PE_OFF = 0x7ffffff0 +#endif + +STACK32_BASE = ADDR32(STACK_SEG, 0) +STACK16_SEG = STACK_SEG +CODE32_BASE = ADDR32(BASE_SEG, 0) +CODE16_SEG = BASE_SEG + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// Pointer to 6-bytes in memory that contains the base address and the limit +// (size of GDT table in bytes) of the GDT. The LGDT is the only instruction +// that directly loads a linear address (not a segment relative address) and +// a limit in protected mode. + +.globl _Gdtr + //.data + .section __INIT,__data // turbo - Data that must be in the first segment + .align 2, 0x90 +_Gdtr: + .word GDTLIMIT + .long vtop(_Gdt) + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// IDTR representing real-mode IVT. The values are constant. + //.const + .section __INIT,__data // turbo - Data that must be in the first segment +// Real mode IDT + .align 2 +.globl _Idtr_real +_Idtr_real: + .word 0x03ff + .long 0x00000000 + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// IDTR representing protected-mode IDT. It is initially NULL which tells the +// procesor that no IDT is available. After we get into protected mode we can +// allocate memory for a proper IDT and update this IDTR to point to it. + //.data + .section __INIT,__data // turbo - Data that must be in the first segment + .align 2 +.globl _Idtr_prot +_Idtr_prot: + .word 0 + .long 0 + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// Data area for __switch_stack. +// +save_sp: .long STACK_OFS +save_ss: .long STACK_SEG + + //.text + .section __INIT,__text // turbo - This code must reside within the first segment +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// real_to_prot() +// +// Transfer from real mode to protected mode. +// Preserves all registers except EAX. +// +LABEL(__real_to_prot) + + // Interrupts are disabled in protected mode. + + cli + + // Load the Global Descriptor Table Register (GDTR). + + addr32 + data32 + lgdt OFFSET16(_Gdtr) + + // Enter protected mode by setting the PE bit in CR0. + + mov %cr0, %eax + data32 + or $CR0_PE_ON, %eax + mov %eax, %cr0 + + // Make intrasegment jump to flush the processor pipeline and + // reload CS register. + + data32 + ljmp $0x08, $xprot + +xprot: + // we are in USE32 mode now + // set up the protected mode segment registers : DS, SS, ES, FS, GS + + mov $0x10, %eax + movw %ax, %ds + movw %ax, %ss + movw %ax, %es + movw %ax, %fs + movw %ax, %gs + + // set up the PM IDT + lidt _Idtr_prot + + // Convert STACK_SEG:SP to 32-bit linear stack pointer. + + movzwl %sp, %eax + addl $STACK32_BASE, %eax + movl %eax, %esp + + // Convert STACK_SEG:BP to 32-bit linear base pointer. + + movzwl %bp, %eax + addl $STACK32_BASE, %eax + movl %eax, %ebp + + // Modify the caller's return address on the stack from + // segment offset to linear address. + + popl %eax + addl $CODE32_BASE, %eax + pushl %eax + + ret + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// prot_to_real() +// +// Transfer from protected mode to real mode. +// Preserves all registers except EAX. +// +LABEL(__prot_to_real) + + // Load real-mode IDT while we're still in USE32 mode so we don't need + // 32-bit addressing prefixes. + lidt _Idtr_real + + // Set up segment registers appropriate for real mode. + + movw $0x30, %ax + movw %ax, %ds + movw %ax, %es + movw %ax, %fs + movw %ax, %gs + movw %ax, %ss + + ljmp $0x18, $x16 // change to USE16 mode + +x16: + mov %cr0, %eax // clear the PE bit of CR0 + data32 + and $CR0_PE_OFF, %eax + mov %eax, %cr0 + + // make intersegment jmp to flush the processor pipeline + // and reload CS register + + data32 + ljmp $CODE16_SEG, $xreal - CODE32_BASE + +xreal: + // we are in real mode now + // set up the real mode segment registers : DS, DS, ES, FS, GS + + movw %cs, %ax + movw %ax, %ds + movw %ax, %es + movw %ax, %fs + movw %ax, %gs + + // load stack segment register SS. + + data32 + movl $STACK16_SEG, %eax + movw %ax, %ss + + // clear top 16-bits of ESP and EBP. + + data32 + movzwl %sp, %esp + data32 + movzwl %bp, %ebp + + // Modify caller's return address on the stack + // from linear address to segment offset. + + data32 + popl %eax + data32 + movzwl %ax, %eax + data32 + pushl %eax + + // Reenable maskable interrupts. + + sti + + data32 + ret + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// halt() +// +LABEL(_halt) +#ifdef BOOT1 + hlt +#else + call _bgetc +#endif + jmp _halt + +#ifndef BOOT1 +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// startprog(phyaddr, arg) +// Start the program on protected mode where phyaddr is the entry point. +// Passes arg to the program in %eax. +// +LABEL(_startprog) + push %ebp + mov %esp, %ebp + + mov 0xc(%ebp), %eax // argument to program + mov 0x8(%ebp), %ecx // entry offset + mov $0x28, %ebx // segment + push %ebx + push %ecx + + // set up %ds and %es + + mov $0x20, %ebx + movw %bx, %ds + movw %bx, %es + + lret +#endif + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// Returns the current stack pointer. +// +LABEL(__sp) + mov %esp, %eax + ret + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// Returns the current frame pointer. +// +LABEL(__bp) + mov %ebp, %eax + ret + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// switch_stack() +// +// Switches stack pointer between SS:SP and memory save_ss:save_sp. +// Call this function from real mode only!!! +// +// AX, DI, and SI are clobbered. +// +LABEL(__switch_stack) + popl %eax # save return address + popl %edi # discard upper 16-bit + + data32 + addr32 + movl OFFSET16(save_ss), %esi # new SS to SI + + data32 + addr32 + movl OFFSET16(save_sp), %edi # new SP to DI + + addr32 + mov %ss, OFFSET16(save_ss) # save current SS to memory + + data32 + addr32 + movl %esp, OFFSET16(save_sp) # save current SP to memory + + cli + mov %si, %ss # switch stack + mov %di, %sp + sti + + pushl %eax # push IP of caller onto the new stack + + xorl %eax, %eax + xorl %esi, %esi + xorl %edi, %edi + + ret + +#ifndef BOOT1 +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// loader() +// +// Issue a request to the network loader. +// +LABEL(_loader) + enter $0, $0 + pushal + + # + # Pass a far pointer to the command structure + # to the INT call through DX:CX. + # + # The command code is in BX. + # + + movw 8(%ebp), %bx # 8[EBP] = command code + movw 12(%ebp), %cx # 12[EBP] = command structure offset + movw 14(%ebp), %dx # 14[EBP] = command structure segment + + call __prot_to_real # Revert to real mode + + ###### Real Mode Begin ###### + + data32 + call __switch_stack # Switch to NBP stack + + int $0x2b # Call NBP + + data32 + call __switch_stack # Restore stack + + data32 + call __real_to_prot # Back to protected mode + + ###### Real Mode End ###### + + popal + leave + ret +#endif + +#if UNUSED +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +// pcpy(src, dst, cnt) +// where src is a virtual address and dst is a physical address +// +LABEL(_pcpy) + push %ebp + mov %esp, %ebp + push %es + push %esi + push %edi + push %ecx + + cld + + // set %es to point at the flat segment + + mov $0x20, %eax + movw %ax , %es + + mov 0x8(%ebp), %esi // source + mov 0xc(%ebp), %edi // destination + mov 0x10(%ebp), %ecx // count + + rep + movsb + + pop %ecx + pop %edi + pop %esi + pop %es + pop %ebp + + ret +#endif Index: trunk/i386/libsaio/console.c =================================================================== --- trunk/i386/libsaio/console.c (revision 0) +++ trunk/i386/libsaio/console.c (revision 1) @@ -0,0 +1,152 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Mach Operating System + * Copyright (c) 1990 Carnegie-Mellon University + * Copyright (c) 1989 Carnegie-Mellon University + * All rights reserved. The CMU software License Agreement specifies + * the terms and conditions for use and redistribution. + */ + +/* + * INTEL CORPORATION PROPRIETARY INFORMATION + * + * This software is supplied under the terms of a license agreement or + * nondisclosure agreement with Intel Corporation and may not be copied + * nor disclosed except in accordance with the terms of that agreement. + * + * Copyright 1988, 1989 Intel Corporation + */ + +/* + * Copyright 1993 NeXT, Inc. + * All rights reserved. + */ + +#include "libsaio.h" +#include "bootstruct.h" + +extern int vprf(const char * fmt, va_list ap); + +BOOL gVerboseMode; +BOOL gErrors; + +/* + * write one character to console + */ +void putchar(int c) +{ + if ( c == '\t' ) + { + for (c = 0; c < 8; c++) putc(' '); + return; + } + + if ( c == '\n' ) + { + putc('\r'); + } + + putc(c); +} + +int getc() +{ + int c = bgetc(); + + if ((c & 0xff) == 0) + return c; + else + return (c & 0xff); +} + +// Read and echo a character from console. This doesn't echo backspace +// since that screws up higher level handling + +int getchar() +{ + register int c = getc(); + + if ( c == '\r' ) c = '\n'; + + if ( c >= ' ' && c < 0x7f) putchar(c); + + return (c); +} + +int printf(const char * fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + if (bootArgs->Video.v_display == VGA_TEXT_MODE) + prf(fmt, ap, putchar, 0); + else + vprf(fmt, ap); + va_end(ap); + return 0; +} + +int verbose(const char * fmt, ...) +{ + va_list ap; + + if (gVerboseMode) + { + va_start(ap, fmt); + if (bootArgs->Video.v_display == VGA_TEXT_MODE) + prf(fmt, ap, putchar, 0); + else + vprf(fmt, ap); + va_end(ap); + } + return(0); +} + +int error(const char * fmt, ...) +{ + va_list ap; + gErrors = YES; + va_start(ap, fmt); + if (bootArgs->Video.v_display == VGA_TEXT_MODE) + prf(fmt, ap, putchar, 0); + else + vprf(fmt, ap); + va_end(ap); + return(0); +} + +void stop(const char * fmt, ...) +{ + va_list ap; + + printf("\n"); + va_start(ap, fmt); + if (bootArgs->Video.v_display == VGA_TEXT_MODE) + prf(fmt, ap, putchar, 0); + else + vprf(fmt, ap); + va_end(ap); + printf("\n"); + halt(); +} Index: trunk/i386/libsaio/xml.h =================================================================== --- trunk/i386/libsaio/xml.h (revision 0) +++ trunk/i386/libsaio/xml.h (revision 1) @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +#ifndef __LIBSAIO_XML_H +#define __LIBSAIO_XML_H + +enum { + kTagTypeNone = 0, + kTagTypeDict, + kTagTypeKey, + kTagTypeString, + kTagTypeInteger, + kTagTypeData, + kTagTypeDate, + kTagTypeFalse, + kTagTypeTrue, + kTagTypeArray +}; + +#define kXMLTagPList "plist " +#define kXMLTagDict "dict" +#define kXMLTagKey "key" +#define kXMLTagString "string" +#define kXMLTagInteger "integer" +#define kXMLTagData "data" +#define kXMLTagDate "date" +#define kXMLTagFalse "false/" +#define kXMLTagTrue "true/" +#define kXMLTagArray "array" + + +#define kPropCFBundleIdentifier ("CFBundleIdentifier") +#define kPropCFBundleExecutable ("CFBundleExecutable") +#define kPropOSBundleRequired ("OSBundleRequired") +#define kPropOSBundleLibraries ("OSBundleLibraries") +#define kPropIOKitPersonalities ("IOKitPersonalities") +#define kPropIONameMatch ("IONameMatch") + +/* +struct Tag { + long type; + char *string; + struct Tag *tag; + struct Tag *tagNext; +}; +typedef struct Tag Tag, *TagPtr; + */ + +extern long gImageFirstBootXAddr; +extern long gImageLastKernelAddr; + +TagPtr XMLGetProperty( TagPtr dict, const char * key ); +long XMLParseNextTag(char *buffer, TagPtr *tag); +void XMLFreeTag(TagPtr tag); +//========================================================================== +// XMLParseFile +// Expects to see one dictionary in the XML file. +// Puts the first dictionary it finds in the +// tag pointer and returns 0, or returns -1 if not found. +// +long XMLParseFile( char * buffer, TagPtr * dict ); + +#endif /* __LIBSAIO_XML_H */ Index: trunk/i386/libsaio/efi.h =================================================================== --- trunk/i386/libsaio/efi.h (revision 0) +++ trunk/i386/libsaio/efi.h (revision 1) @@ -0,0 +1,558 @@ +/* + * Copyright (c) 2005 Apple Computer, Inc. All rights reserved. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ + */ + +#ifndef _PEXPERT_I386_EFI_H +#define _PEXPERT_I386_EFI_H + +#include + +typedef uint8_t EFI_UINT8; +typedef uint16_t EFI_UINT16; +typedef uint32_t EFI_UINT32; +typedef uint64_t EFI_UINT64; + +typedef uint32_t EFI_UINTN; /* natural size for firmware, not kernel */ + +typedef int8_t EFI_INT8; +typedef int16_t EFI_INT16; +typedef int32_t EFI_INT32; +typedef int64_t EFI_INT64; + +typedef int8_t EFI_CHAR8; +typedef int16_t EFI_CHAR16; +typedef int32_t EFI_CHAR32; +typedef int64_t EFI_CHAR64; + +typedef uint32_t EFI_STATUS; +typedef uint8_t EFI_BOOLEAN; +typedef void VOID; + +typedef uint32_t EFI_PTR32; +typedef uint32_t EFI_HANDLE32; + +typedef uint64_t EFI_PTR64; +typedef uint64_t EFI_HANDLE64; +/* + +Portions Copyright 2004, Intel Corporation +All rights reserved. This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +*/ + + +// +// Modifiers for EFI Runtime and Boot Services +// +#define EFI_RUNTIMESERVICE +#define EFIAPI +#define IN +#define OUT +#define OPTIONAL + +#define EFI_MAX_BIT 0x80000000 + +// +// Set the upper bit to indicate EFI Error. +// +#define EFIERR(a) (EFI_MAX_BIT | (a)) + +#define EFIWARN(a) (a) +#define EFI_ERROR(a) (((INTN) (a)) < 0) + +#define EFI_SUCCESS 0 +#define EFI_LOAD_ERROR EFIERR (1) +#define EFI_INVALID_PARAMETER EFIERR (2) +#define EFI_UNSUPPORTED EFIERR (3) +#define EFI_BAD_BUFFER_SIZE EFIERR (4) +#define EFI_BUFFER_TOO_SMALL EFIERR (5) +#define EFI_NOT_READY EFIERR (6) +#define EFI_DEVICE_ERROR EFIERR (7) +#define EFI_WRITE_PROTECTED EFIERR (8) +#define EFI_OUT_OF_RESOURCES EFIERR (9) +#define EFI_VOLUME_CORRUPTED EFIERR (10) +#define EFI_VOLUME_FULL EFIERR (11) +#define EFI_NO_MEDIA EFIERR (12) +#define EFI_MEDIA_CHANGED EFIERR (13) +#define EFI_NOT_FOUND EFIERR (14) +#define EFI_ACCESS_DENIED EFIERR (15) +#define EFI_NO_RESPONSE EFIERR (16) +#define EFI_NO_MAPPING EFIERR (17) +#define EFI_TIMEOUT EFIERR (18) +#define EFI_NOT_STARTED EFIERR (19) +#define EFI_ALREADY_STARTED EFIERR (20) +#define EFI_ABORTED EFIERR (21) +#define EFI_ICMP_ERROR EFIERR (22) +#define EFI_TFTP_ERROR EFIERR (23) +#define EFI_PROTOCOL_ERROR EFIERR (24) +#define EFI_INCOMPATIBLE_VERSION EFIERR (25) +#define EFI_SECURITY_VIOLATION EFIERR (26) +#define EFI_CRC_ERROR EFIERR (27) + +#define EFI_WARN_UNKNOWN_GLYPH EFIWARN (1) +#define EFI_WARN_DELETE_FAILURE EFIWARN (2) +#define EFI_WARN_WRITE_FAILURE EFIWARN (3) +#define EFI_WARN_BUFFER_TOO_SMALL EFIWARN (4) + +// +// EFI Specification Revision information +// +#define EFI_SPECIFICATION_MAJOR_REVISION 1 +#define EFI_SPECIFICATION_MINOR_REVISION 10 + +typedef struct { + EFI_UINT32 Data1; + EFI_UINT16 Data2; + EFI_UINT16 Data3; + EFI_UINT8 Data4[8]; +} EFI_GUID; + +#define APPLE_VENDOR_GUID \ + {0xAC39C713, 0x7E50, 0x423D, {0x88, 0x9D, 0x27,0x8F, 0xCC, 0x34, 0x22, 0xB6} } + +#define EFI_GLOBAL_VARIABLE_GUID \ + {0x8BE4DF61, 0x93CA, 0x11d2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C} } + +typedef union { + EFI_GUID Guid; + EFI_UINT8 Raw[16]; +} EFI_GUID_UNION; + +// +// EFI Time Abstraction: +// Year: 2000 - 20XX +// Month: 1 - 12 +// Day: 1 - 31 +// Hour: 0 - 23 +// Minute: 0 - 59 +// Second: 0 - 59 +// Nanosecond: 0 - 999,999,999 +// TimeZone: -1440 to 1440 or 2047 +// +typedef struct { + EFI_UINT16 Year; + EFI_UINT8 Month; + EFI_UINT8 Day; + EFI_UINT8 Hour; + EFI_UINT8 Minute; + EFI_UINT8 Second; + EFI_UINT8 Pad1; + EFI_UINT32 Nanosecond; + EFI_INT16 TimeZone; + EFI_UINT8 Daylight; + EFI_UINT8 Pad2; +} EFI_TIME; + +// +// Bit definitions for EFI_TIME.Daylight +// +#define EFI_TIME_ADJUST_DAYLIGHT 0x01 +#define EFI_TIME_IN_DAYLIGHT 0x02 + +// +// Value definition for EFI_TIME.TimeZone +// +#define EFI_UNSPECIFIED_TIMEZONE 0x07FF + +typedef enum { + EfiReservedMemoryType, + EfiLoaderCode, + EfiLoaderData, + EfiBootServicesCode, + EfiBootServicesData, + EfiRuntimeServicesCode, + EfiRuntimeServicesData, + EfiConventionalMemory, + EfiUnusableMemory, + EfiACPIReclaimMemory, + EfiACPIMemoryNVS, + EfiMemoryMappedIO, + EfiMemoryMappedIOPortSpace, + EfiPalCode, + EfiMaxMemoryType +} EFI_MEMORY_TYPE; + +typedef struct { + EFI_UINT64 Signature; + EFI_UINT32 Revision; + EFI_UINT32 HeaderSize; + EFI_UINT32 CRC32; + EFI_UINT32 Reserved; +} __attribute__((aligned(8))) EFI_TABLE_HEADER; + +// +// possible caching types for the memory range +// +#define EFI_MEMORY_UC 0x0000000000000001ULL +#define EFI_MEMORY_WC 0x0000000000000002ULL +#define EFI_MEMORY_WT 0x0000000000000004ULL +#define EFI_MEMORY_WB 0x0000000000000008ULL +#define EFI_MEMORY_UCE 0x0000000000000010ULL + +// +// physical memory protection on range +// +#define EFI_MEMORY_WP 0x0000000000001000ULL +#define EFI_MEMORY_RP 0x0000000000002000ULL +#define EFI_MEMORY_XP 0x0000000000004000ULL + +// +// range requires a runtime mapping +// +#define EFI_MEMORY_RUNTIME 0x8000000000000000ULL + +typedef EFI_UINT64 EFI_PHYSICAL_ADDRESS; +typedef EFI_UINT64 EFI_VIRTUAL_ADDRESS; + +#define EFI_MEMORY_DESCRIPTOR_VERSION 1 +typedef struct { + EFI_UINT32 Type; + EFI_UINT32 Pad; + EFI_PHYSICAL_ADDRESS PhysicalStart; + EFI_VIRTUAL_ADDRESS VirtualStart; + EFI_UINT64 NumberOfPages; + EFI_UINT64 Attribute; +} __attribute__((aligned(8))) EFI_MEMORY_DESCRIPTOR; + + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_SET_VIRTUAL_ADDRESS_MAP) ( + IN EFI_UINTN MemoryMapSize, + IN EFI_UINTN DescriptorSize, + IN EFI_UINT32 DescriptorVersion, + IN EFI_MEMORY_DESCRIPTOR * VirtualMap + ) __attribute__((regparm(0))); + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_CONVERT_POINTER) ( + IN EFI_UINTN DebugDisposition, + IN OUT VOID **Address + ) __attribute__((regparm(0))); + +// +// Variable attributes +// +#define EFI_VARIABLE_NON_VOLATILE 0x00000001 +#define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x00000002 +#define EFI_VARIABLE_RUNTIME_ACCESS 0x00000004 +#define EFI_VARIABLE_READ_ONLY 0x00000008 + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_GET_VARIABLE) ( + IN EFI_CHAR16 * VariableName, + IN EFI_GUID * VendorGuid, + OUT EFI_UINT32 * Attributes OPTIONAL, + IN OUT EFI_UINTN * DataSize, + OUT VOID * Data + ) __attribute__((regparm(0))); + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_GET_NEXT_VARIABLE_NAME) ( + IN OUT EFI_UINTN * VariableNameSize, + IN OUT EFI_CHAR16 * VariableName, + IN OUT EFI_GUID * VendorGuid + ) __attribute__((regparm(0))); + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_SET_VARIABLE) ( + IN EFI_CHAR16 * VariableName, + IN EFI_GUID * VendorGuid, + IN EFI_UINT32 Attributes, + IN EFI_UINTN DataSize, + IN VOID * Data + ) __attribute__((regparm(0))); + +// +// EFI Time +// +typedef struct { + EFI_UINT32 Resolution; + EFI_UINT32 Accuracy; + EFI_BOOLEAN SetsToZero; +} __attribute__((aligned(4))) EFI_TIME_CAPABILITIES; + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_GET_TIME) ( + OUT EFI_TIME * Time, + OUT EFI_TIME_CAPABILITIES * Capabilities OPTIONAL + ) __attribute__((regparm(0))); + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_SET_TIME) ( + IN EFI_TIME * Time + ) __attribute__((regparm(0))); + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_GET_WAKEUP_TIME) ( + OUT EFI_BOOLEAN * Enabled, + OUT EFI_BOOLEAN * Pending, + OUT EFI_TIME * Time + ) __attribute__((regparm(0))); + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_SET_WAKEUP_TIME) ( + IN EFI_BOOLEAN Enable, + IN EFI_TIME * Time OPTIONAL + ) __attribute((regparm(0))); + +typedef enum { + EfiResetCold, + EfiResetWarm, + EfiResetShutdown, + +#ifdef TIANO_EXTENSION_FLAG + EfiResetUpdate +#endif + +} EFI_RESET_TYPE; + +typedef +EFI_RUNTIMESERVICE +VOID +(EFIAPI *EFI_RESET_SYSTEM) ( + IN EFI_RESET_TYPE ResetType, + IN EFI_STATUS ResetStatus, + IN EFI_UINTN DataSize, + IN EFI_CHAR16 * ResetData OPTIONAL + ) __attribute__((regparm(0))); + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_GET_NEXT_HIGH_MONO_COUNT) ( + OUT EFI_UINT32 * HighCount + ) __attribute__((regparm(0))); + +// +// Definition of Status Code extended data header +// +// HeaderSize The size of the architecture. This is specified to enable +// the future expansion +// +// Size The size of the data in bytes. This does not include the size +// of the header structure. +// +// Type A GUID defining the type of the data +// +// +#ifdef TIANO_EXTENSION_FLAG + +typedef +EFI_RUNTIMESERVICE +EFI_STATUS +(EFIAPI *EFI_REPORT_STATUS_CODE) ( + IN EFI_STATUS_CODE_TYPE Type, + IN EFI_STATUS_CODE_VALUE Value, + IN EFI_UINT32 Instance, + IN EFI_GUID * CallerId OPTIONAL, + IN EFI_STATUS_CODE_DATA * Data OPTIONAL + ) __attribute__((regparm(0))); + +#endif +// +// EFI Runtime Services Table +// +#define EFI_RUNTIME_SERVICES_SIGNATURE 0x56524553544e5552ULL +#define EFI_RUNTIME_SERVICES_REVISION ((EFI_SPECIFICATION_MAJOR_REVISION << 16) | (EFI_SPECIFICATION_MINOR_REVISION)) + +typedef struct { + EFI_TABLE_HEADER Hdr; + + // + // Time services + // + EFI_PTR32 GetTime; + EFI_PTR32 SetTime; + EFI_PTR32 GetWakeupTime; + EFI_PTR32 SetWakeupTime; + + // + // Virtual memory services + // + EFI_PTR32 SetVirtualAddressMap; + EFI_PTR32 ConvertPointer; + + // + // Variable services + // + EFI_PTR32 GetVariable; + EFI_PTR32 GetNextVariableName; + EFI_PTR32 SetVariable; + + // + // Misc + // + EFI_PTR32 GetNextHighMonotonicCount; + EFI_PTR32 ResetSystem; + +#ifdef TIANO_EXTENSION_FLAG + // + // //////////////////////////////////////////////////// + // Extended EFI Services + ////////////////////////////////////////////////////// + // + EFI_PTR32 ReportStatusCode; +#endif + +} __attribute__((aligned(8))) EFI_RUNTIME_SERVICES_32; + +typedef struct { + EFI_TABLE_HEADER Hdr; + + // + // Time services + // + EFI_PTR64 GetTime; + EFI_PTR64 SetTime; + EFI_PTR64 GetWakeupTime; + EFI_PTR64 SetWakeupTime; + + // + // Virtual memory services + // + EFI_PTR64 SetVirtualAddressMap; + EFI_PTR64 ConvertPointer; + + // + // Variable services + // + EFI_PTR64 GetVariable; + EFI_PTR64 GetNextVariableName; + EFI_PTR64 SetVariable; + + // + // Misc + // + EFI_PTR64 GetNextHighMonotonicCount; + EFI_PTR64 ResetSystem; + +#ifdef TIANO_EXTENSION_FLAG + // + // //////////////////////////////////////////////////// + // Extended EFI Services + ////////////////////////////////////////////////////// + // + EFI_PTR64 ReportStatusCode; +#endif + +} __attribute__((aligned(8))) EFI_RUNTIME_SERVICES_64; + +// +// EFI Configuration Table +// +typedef struct { + EFI_GUID VendorGuid; + EFI_PTR32 VendorTable; +} EFI_CONFIGURATION_TABLE_32; + +typedef struct { + EFI_GUID VendorGuid; + EFI_PTR64 VendorTable; +} __attribute__((aligned(8))) EFI_CONFIGURATION_TABLE_64; + +// +// EFI System Table +// +#define EFI_SYSTEM_TABLE_SIGNATURE 0x5453595320494249ULL +#define EFI_SYSTEM_TABLE_REVISION ((EFI_SPECIFICATION_MAJOR_REVISION << 16) | (EFI_SPECIFICATION_MINOR_REVISION)) +#define EFI_2_00_SYSTEM_TABLE_REVISION ((2 << 16) | 00) +#define EFI_1_02_SYSTEM_TABLE_REVISION ((1 << 16) | 02) +#define EFI_1_10_SYSTEM_TABLE_REVISION ((1 << 16) | 10) + +typedef struct EFI_SYSTEM_TABLE_32 { + EFI_TABLE_HEADER Hdr; + + EFI_PTR32 FirmwareVendor; + EFI_UINT32 FirmwareRevision; + + EFI_HANDLE32 ConsoleInHandle; + EFI_PTR32 ConIn; + + EFI_HANDLE32 ConsoleOutHandle; + EFI_PTR32 ConOut; + + EFI_HANDLE32 StandardErrorHandle; + EFI_PTR32 StdErr; + + EFI_PTR32 RuntimeServices; + EFI_PTR32 BootServices; + + EFI_UINT32 NumberOfTableEntries; + EFI_PTR32 ConfigurationTable; + +} __attribute__((aligned(8))) EFI_SYSTEM_TABLE_32; + +typedef struct EFI_SYSTEM_TABLE_64 { + EFI_TABLE_HEADER Hdr; + + EFI_PTR64 FirmwareVendor; + EFI_UINT32 FirmwareRevision; + + EFI_UINT32 __pad; + + EFI_HANDLE64 ConsoleInHandle; + EFI_PTR64 ConIn; + + EFI_HANDLE64 ConsoleOutHandle; + EFI_PTR64 ConOut; + + EFI_HANDLE64 StandardErrorHandle; + EFI_PTR64 StdErr; + + EFI_PTR64 RuntimeServices; + EFI_PTR64 BootServices; + + EFI_UINT64 NumberOfTableEntries; + EFI_PTR64 ConfigurationTable; + +} __attribute__((aligned(8))) EFI_SYSTEM_TABLE_64; + +#endif /* _PEXPERT_I386_EFI_H */ Index: trunk/i386/libsaio/bootstruct.c =================================================================== --- trunk/i386/libsaio/bootstruct.c (revision 0) +++ trunk/i386/libsaio/bootstruct.c (revision 1) @@ -0,0 +1,173 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Copyright 1993 NeXT, Inc. + * All rights reserved. + */ + +#include "libsaio.h" +#include "bootstruct.h" + +/*========================================================================== + * Initialize the structure of parameters passed to + * the kernel by the booter. + */ + +boot_args *bootArgs; +PrivateBootInfo_t *bootInfo; +Node *gMemoryMapNode; + +static char platformName[64]; + +void initKernBootStruct( void ) +{ + Node *node; + int nameLen; + static int init_done = 0; + + if ( !init_done ) + { + bootArgs = (boot_args *)malloc(sizeof(boot_args)); + bootInfo = (PrivateBootInfo_t *)malloc(sizeof(PrivateBootInfo_t)); + if (bootArgs == 0 || bootInfo == 0) + stop("Couldn't allocate boot info\n"); + + bzero(bootArgs, sizeof(boot_args)); + bzero(bootInfo, sizeof(PrivateBootInfo_t)); + + // Get system memory map. Also update the size of the + // conventional/extended memory for backwards compatibility. + + bootInfo->memoryMapCount = + getMemoryMap( bootInfo->memoryMap, kMemoryMapCountMax, + (unsigned long *) &bootInfo->convmem, + (unsigned long *) &bootInfo->extmem ); + + if ( bootInfo->memoryMapCount == 0 ) + { + // BIOS did not provide a memory map, systems with + // discontiguous memory or unusual memory hole locations + // may have problems. + + bootInfo->convmem = getConventionalMemorySize(); + bootInfo->extmem = getExtendedMemorySize(); + } + + bootInfo->configEnd = bootInfo->config; + bootArgs->Video.v_display = VGA_TEXT_MODE; + + DT__Initialize(); + + node = DT__FindNode("/", true); + if (node == 0) { + stop("Couldn't create root node"); + } + getPlatformName(platformName); + nameLen = strlen(platformName) + 1; + DT__AddProperty(node, "compatible", nameLen, platformName); + DT__AddProperty(node, "model", nameLen, platformName); + + gMemoryMapNode = DT__FindNode("/chosen/memory-map", true); + + bootArgs->Version = kBootArgsVersion; + bootArgs->Revision = 5; + + init_done = 1; + } + +} + + +/* Copy boot args after kernel and record address. */ + +void +reserveKernBootStruct(void) +{ + void *oldAddr = bootArgs; + bootArgs = (boot_args *)AllocateKernelMemory(sizeof(boot_args)); + bcopy(oldAddr, bootArgs, sizeof(boot_args)); +} + +void +finalizeBootStruct(void) +{ + uint32_t size; + void *addr; + int i; + EfiMemoryRange *memoryMap; + MemoryRange *range; + int memoryMapCount = bootInfo->memoryMapCount; + + if (memoryMapCount == 0) { + // XXX could make a two-part map here + stop("Unable to convert memory map into proper format\n"); + } + + // convert memory map to boot_args memory map + memoryMap = (EfiMemoryRange *)AllocateKernelMemory(sizeof(EfiMemoryRange) * memoryMapCount); + bootArgs->MemoryMap = (uint32_t)memoryMap; + bootArgs->MemoryMapSize = sizeof(EfiMemoryRange) * memoryMapCount; + bootArgs->MemoryMapDescriptorSize = sizeof(EfiMemoryRange); + bootArgs->MemoryMapDescriptorVersion = 0; + + for (i=0; imemoryMap[i]; + switch(range->type) { + case kMemoryRangeACPI: + memoryMap->Type = kEfiACPIReclaimMemory; + break; + case kMemoryRangeNVS: + memoryMap->Type = kEfiACPIMemoryNVS; + break; + case kMemoryRangeUsable: + memoryMap->Type = kEfiConventionalMemory; + break; + case kMemoryRangeReserved: + default: + memoryMap->Type = kEfiReservedMemoryType; + break; + } + memoryMap->PhysicalStart = range->base; + memoryMap->VirtualStart = range->base; + memoryMap->NumberOfPages = range->length >> I386_PGSHIFT; + memoryMap->Attribute = 0; + } + + // copy bootFile into device tree + // XXX + + // add PCI info somehow into device tree + // XXX + + // Flatten device tree + DT__FlattenDeviceTree(0, &size); + addr = (void *)AllocateKernelMemory(size); + if (addr == 0) { + stop("Couldn't allocate device tree\n"); + } + + DT__FlattenDeviceTree((void **)&addr, &size); + bootArgs->deviceTreeP = (uint32_t)addr; + bootArgs->deviceTreeLength = size; +} Index: trunk/i386/libsaio/ntfs_private.h =================================================================== --- trunk/i386/libsaio/ntfs_private.h (revision 0) +++ trunk/i386/libsaio/ntfs_private.h (revision 1) @@ -0,0 +1,397 @@ +/* + * Copyright (c) 2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* $NetBSD: ntfs.h,v 1.9 1999/10/31 19:45:26 jdolecek Exp $ */ + +/*- + * Copyright (c) 1998, 1999 Semen Ustimenko + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD: src/sys/fs/ntfs/ntfs.h,v 1.14 2001/11/27 00:18:33 jhb Exp $ + */ + +/*#define NTFS_DEBUG 1*/ + +#ifdef APPLE +/* We're using FreeBSD style byte order macros in the source. */ +#include +#define le16toh(x) OSSwapLittleToHostInt16(x) +#define le32toh(x) OSSwapLittleToHostInt32(x) +#define le64toh(x) OSSwapLittleToHostInt64(x) + +/* FreeBSD mutexes correspond to Darwin's simple locks */ +#define mtx_lock(lock) simple_lock(lock) +#define mtx_unlock(lock) simple_unlock(lock) +#define mtx_destroy(lock) /* Nothing. */ + +#define lockdestroy(lock) /* Nothing. */ + +#endif + +typedef u_int64_t cn_t; +typedef u_int16_t wchar; + +#pragma pack(1) +#define BBSIZE 1024 +#define BBOFF ((off_t)(0)) +#define BBLOCK ((daddr_t)(0)) +#define NTFS_MFTINO 0 +#define NTFS_VOLUMEINO 3 +#define NTFS_ATTRDEFINO 4 +#define NTFS_ROOTINO 5 +#define NTFS_BITMAPINO 6 +#define NTFS_BOOTINO 7 +#define NTFS_BADCLUSINO 8 +#define NTFS_UPCASEINO 10 +#define NTFS_MAXFILENAME 255 + +struct fixuphdr { + u_int32_t fh_magic; + u_int16_t fh_foff; + u_int16_t fh_fnum; +}; + +#define NTFS_AF_INRUN 0x00000001 +struct attrhdr { + u_int32_t a_type; + u_int32_t reclen; + u_int8_t a_flag; + u_int8_t a_namelen; + u_int8_t a_nameoff; + u_int8_t reserved1; + u_int8_t a_compression; + u_int8_t reserved2; + u_int16_t a_index; +}; +#define NTFS_A_STD 0x10 +#define NTFS_A_ATTRLIST 0x20 +#define NTFS_A_NAME 0x30 +#define NTFS_A_VOLUMENAME 0x60 +#define NTFS_A_DATA 0x80 +#define NTFS_A_INDXROOT 0x90 +#define NTFS_A_INDX 0xA0 +#define NTFS_A_INDXBITMAP 0xB0 + +#define NTFS_MAXATTRNAME 255 +struct attr { + struct attrhdr a_hdr; + union { + struct { + u_int16_t a_datalen; + u_int16_t reserved1; + u_int16_t a_dataoff; + u_int16_t a_indexed; + } a_S_r; + struct { + cn_t a_vcnstart; + cn_t a_vcnend; + u_int16_t a_dataoff; + u_int16_t a_compressalg; + u_int32_t reserved1; + u_int64_t a_allocated; + u_int64_t a_datalen; + u_int64_t a_initialized; + } a_S_nr; + } a_S; +}; +#define a_r a_S.a_S_r +#define a_nr a_S.a_S_nr + +typedef struct { + u_int64_t t_create; + u_int64_t t_write; + u_int64_t t_mftwrite; + u_int64_t t_access; +} ntfs_times_t; + +#define NTFS_FFLAG_RDONLY 0x01LL +#define NTFS_FFLAG_HIDDEN 0x02LL +#define NTFS_FFLAG_SYSTEM 0x04LL +#define NTFS_FFLAG_ARCHIVE 0x20LL +#define NTFS_FFLAG_COMPRESSED 0x0800LL +#define NTFS_FFLAG_DIR 0x10000000LL + +struct attr_name { + u_int32_t n_pnumber; /* Parent ntnode */ + u_int32_t reserved; + ntfs_times_t n_times; + u_int64_t n_size; + u_int64_t n_attrsz; + u_int64_t n_flag; + u_int8_t n_namelen; + u_int8_t n_nametype; + u_int16_t n_name[1]; +}; + +#define NTFS_IRFLAG_INDXALLOC 0x00000001 +struct attr_indexroot { + u_int32_t ir_unkn1; /* attribute type (0x30 for $FILE_NAME) */ + u_int32_t ir_unkn2; /* collation rule (0x01 for file names) */ + u_int32_t ir_size; /* size of index allocation entry */ + u_int32_t ir_unkn3; /* clusters per index record, and 3 bytes padding */ + u_int32_t ir_unkn4; /* (offset to first index entry?) always 0x10 */ + u_int32_t ir_datalen; /* (total size of index enties?) sizeof something */ + u_int32_t ir_allocated; /* (allocated size of index entries?) */ + u_int8_t ir_flag; /* 1=index allocation needed (large index) */ + u_int8_t ir_pad1; /* padding */ + u_int16_t ir_pad2; /* padding */ +}; + +struct attr_attrlist { + u_int32_t al_type; /* Attribute type */ + u_int16_t reclen; /* length of this entry */ + u_int8_t al_namelen; /* Attribute name len */ + u_int8_t al_nameoff; /* Name offset from entry start */ + u_int64_t al_vcnstart; /* VCN number */ + u_int32_t al_inumber; /* Parent ntnode */ + u_int32_t reserved; + u_int16_t al_index; /* Attribute index in MFT record */ + u_int16_t al_name[1]; /* Name */ +}; + +#define NTFS_INDXMAGIC (u_int32_t)(0x58444E49) +struct attr_indexalloc { + struct fixuphdr ia_fixup; + u_int64_t unknown1; + cn_t ia_bufcn; + u_int16_t ia_hdrsize; + u_int16_t unknown2; + u_int32_t ia_inuse; + u_int32_t ia_allocated; +}; + +#define NTFS_IEFLAG_SUBNODE 0x00000001 +#define NTFS_IEFLAG_LAST 0x00000002 + +struct attr_indexentry { + u_int32_t ie_number; + u_int32_t unknown1; + u_int16_t reclen; + u_int16_t ie_size; + u_int32_t ie_flag;/* 1 - has subnodes, 2 - last */ + u_int32_t ie_fpnumber; + u_int32_t unknown2; + ntfs_times_t ie_ftimes; + u_int64_t ie_fallocated; + u_int64_t ie_fsize; + u_int32_t ie_fflag; + u_int32_t unknown3; /* used by reparse points and external attributes? */ + u_int8_t ie_fnamelen; + u_int8_t ie_fnametype; + wchar ie_fname[NTFS_MAXFILENAME]; + /* cn_t ie_bufcn; buffer with subnodes */ +}; + +#define NTFS_FILEMAGIC (u_int32_t)(0x454C4946) +#define NTFS_FRFLAG_DIR 0x0002 +struct filerec { + struct fixuphdr fr_fixup; + u_int8_t reserved[8]; + u_int16_t fr_seqnum; /* Sequence number */ + u_int16_t fr_nlink; + u_int16_t fr_attroff; /* offset to attributes */ + u_int16_t fr_flags; /* 1-nonresident attr, 2-directory */ + u_int32_t fr_size;/* hdr + attributes */ + u_int32_t fr_allocated; /* allocated length of record */ + u_int64_t fr_mainrec; /* main record */ + u_int16_t fr_attrnum; /* maximum attr number + 1 ??? */ +}; + +#define NTFS_ATTRNAME_MAXLEN 0x40 +#define NTFS_ADFLAG_NONRES 0x0080 /* Attrib can be non resident */ +#define NTFS_ADFLAG_INDEX 0x0002 /* Attrib can be indexed */ +struct attrdef { + wchar ad_name[NTFS_ATTRNAME_MAXLEN]; + u_int32_t ad_type; + u_int32_t reserved1[2]; + u_int32_t ad_flag; + u_int64_t ad_minlen; + u_int64_t ad_maxlen; /* -1 for nonlimited */ +}; + +struct ntvattrdef { + char ad_name[0x40]; + int ad_namelen; + u_int32_t ad_type; +}; + +#define NTFS_BBID "NTFS " +#define NTFS_BBIDLEN 8 +struct bootfile { + u_int8_t reserved1[3]; /* asm jmp near ... */ + u_int8_t bf_sysid[8]; /* 'NTFS ' */ + u_int16_t bf_bps; /* bytes per sector */ + u_int8_t bf_spc; /* sectors per cluster */ + u_int8_t reserved2[7]; /* unused (zeroed) */ + u_int8_t bf_media; /* media desc. (0xF8) */ + u_int8_t reserved3[2]; + u_int16_t bf_spt; /* sectors per track */ + u_int16_t bf_heads; /* number of heads */ + u_int8_t reserver4[12]; + u_int64_t bf_spv; /* sectors per volume */ + cn_t bf_mftcn; /* $MFT cluster number */ + cn_t bf_mftmirrcn; /* $MFTMirr cn */ + u_int8_t bf_mftrecsz; /* MFT record size (clust) */ + /* 0xF6 inducates 1/4 */ + u_int32_t bf_ibsz; /* index buffer size */ + u_int32_t bf_volsn; /* volume ser. num. */ +}; + +/* + * Darwin's ntfs.util needs to include this file to get definitions + * for the on-disk structures. It doesn't need the ntfsmount structure. + * In fact, since it doesn't #define KERNEL, the struct netexport below + * won't be defined. + * + * So, I'm using #ifdef KERNEL around the things that are only relevant + * to the in-kernel implementation. + * + * I don't know if FreeBSD defines KERNEL, or if I need to use or + * invent a different conditional here. + */ +#ifdef KERNEL + +#define NTFS_SYSNODESNUM 0x0B +struct ntfsmount { + struct mount *ntm_mountp; /* filesystem vfs structure */ + struct bootfile ntm_bootfile; + dev_t ntm_dev; /* device mounted */ + struct vnode *ntm_devvp; /* block device mounted vnode */ + struct vnode *ntm_sysvn[NTFS_SYSNODESNUM]; + u_int32_t ntm_bpmftrec; + uid_t ntm_uid; + gid_t ntm_gid; + mode_t ntm_mode; + u_long ntm_flag; + cn_t ntm_cfree; + struct ntvattrdef *ntm_ad; /* attribute names are stored in native byte order */ + int ntm_adnum; + wchar * ntm_82u; /* 8bit to Unicode */ + char ** ntm_u28; /* Unicode to 8 bit */ +#ifdef APPLE + struct netexport ntm_export; /* NFS export information */ +#endif +}; + +#define ntm_mftcn ntm_bootfile.bf_mftcn +#define ntm_mftmirrcn ntm_bootfile.bf_mftmirrcn +#define ntm_mftrecsz ntm_bootfile.bf_mftrecsz +#define ntm_spc ntm_bootfile.bf_spc +#define ntm_bps ntm_bootfile.bf_bps + +#pragma pack() + +#define NTFS_NEXTREC(s, type) ((type)(((caddr_t) s) + le16toh((s)->reclen))) + +/* Convert mount ptr to ntfsmount ptr. */ +#define VFSTONTFS(mp) ((struct ntfsmount *)((mp)->mnt_data)) +#define VTONT(v) FTONT(VTOF(v)) +#define VTOF(v) ((struct fnode *)((v)->v_data)) +#define FTOV(f) ((f)->f_vp) +#define FTONT(f) ((f)->f_ip) +#define ntfs_cntobn(cn) ((daddr_t)(cn) * (ntmp->ntm_spc)) +#define ntfs_cntob(cn) ((off_t)(cn) * (ntmp)->ntm_spc * (ntmp)->ntm_bps) +#define ntfs_btocn(off) (cn_t)((off) / ((ntmp)->ntm_spc * (ntmp)->ntm_bps)) +#define ntfs_btocl(off) (cn_t)((off + ntfs_cntob(1) - 1) / ((ntmp)->ntm_spc * (ntmp)->ntm_bps)) +#define ntfs_btocnoff(off) (off_t)((off) % ((ntmp)->ntm_spc * (ntmp)->ntm_bps)) +#define ntfs_bntob(bn) (daddr_t)((bn) * (ntmp)->ntm_bps) + +#define ntfs_bpbl (daddr_t)((ntmp)->ntm_bps) + +#ifdef MALLOC_DECLARE +MALLOC_DECLARE(M_NTFSMNT); +MALLOC_DECLARE(M_NTFSNTNODE); +MALLOC_DECLARE(M_NTFSFNODE); +MALLOC_DECLARE(M_NTFSDIR); +MALLOC_DECLARE(M_NTFSNTHASH); +#endif + +#ifndef M_NTFSMNT +#define M_NTFSMNT M_TEMP +#endif +#ifndef M_NTFSNTNODE +#define M_NTFSNTNODE M_TEMP +#endif +#ifndef M_NTFSFNODE +#define M_NTFSFNODE M_TEMP +#endif +#ifndef M_NTFSDIR +#define M_NTFSDIR M_TEMP +#endif +#ifndef M_NTFSNTHASH +#define M_NTFSNTHASH M_TEMP +#endif +#ifndef M_NTFSRUN +#define M_NTFSRUN M_TEMP +#endif +#ifndef M_NTFSRDATA +#define M_NTFSRDATA M_TEMP +#endif +#ifndef M_NTFSNTVATTR +#define M_NTFSNTVATTR M_TEMP +#endif +#ifndef M_NTFSDECOMP +#define M_NTFSDECOMP M_TEMP +#endif +#define VT_NTFS VT_OTHER + +#if defined(NTFS_DEBUG) +#define dprintf(a) printf a +#if NTFS_DEBUG > 1 +#define ddprintf(a) printf a +#else +#define ddprintf(a) +#endif +#else +#define dprintf(a) +#define ddprintf(a) +#endif + +#ifdef APPLE +typedef int vop_t(void *); +#else +#endif +extern vop_t **ntfs_vnodeop_p; +#endif /* KERNEL */ Index: trunk/i386/libsaio/io_inline.h =================================================================== --- trunk/i386/libsaio/io_inline.h (revision 0) +++ trunk/i386/libsaio/io_inline.h (revision 1) @@ -0,0 +1,82 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Copyright (c) 1992 NeXT Computer, Inc. + * + * Inlines for io space access. + * + * HISTORY + * + * 20 May 1992 ? at NeXT + * Created. + */ + +#ifndef __LIBSAIO_IO_INLINE_H +#define __LIBSAIO_IO_INLINE_H + +/* + *############################################################################ + * + * x86 IN/OUT I/O inline functions. + * + * IN : inb, inw, inl + * IN(port) + * + * OUT: outb, outw, outl + * OUT(port, data) + * + *############################################################################ + */ + +#define __IN(s, u) \ +static inline unsigned u \ +in##s(unsigned short port) \ +{ \ + unsigned u data; \ + asm volatile ( \ + "in" #s " %1,%0" \ + : "=a" (data) \ + : "d" (port)); \ + return (data); \ +} + +#define __OUT(s, u) \ +static inline void \ +out##s(unsigned short port, unsigned u data) \ +{ \ + asm volatile ( \ + "out" #s " %1,%0" \ + : \ + : "d" (port), "a" (data)); \ +} + +__IN(b, char) /* inb() */ +__IN(w, short) /* inw() */ +__IN(l, long) /* inl() */ + +__OUT(b, char) /* outb() */ +__OUT(w, short) /* outw() */ +__OUT(l, long) /* outl() */ + +#endif /* !__LIBSAIO_IO_INLINE_H */ Index: trunk/i386/libsaio/hfs_CaseTables.h =================================================================== --- trunk/i386/libsaio/hfs_CaseTables.h (revision 0) +++ trunk/i386/libsaio/hfs_CaseTables.h (revision 1) @@ -0,0 +1,560 @@ +/* + * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + File: CaseTables.h +*/ + + +/* The lower case table consists of a 256-entry high-byte table followed by some number of + 256-entry subtables. The high-byte table contains either an offset to the subtable for + characters with that high byte or zero, which means that there are no case mappings or + ignored characters in that block. Ignored characters are mapped to zero. + */ + +#if UNCOMPRESSED +u_int16_t gLowerCaseTable[] = { + + // High-byte indices ( == 0 iff no case mapping and no ignorables ) + + /* 0 */ 0x0100, 0x0200, 0x0000, 0x0300, 0x0400, 0x0500, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* 1 */ 0x0600, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* 2 */ 0x0700, 0x0800, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* 3 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* 4 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* 5 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* 6 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* 7 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* 8 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* 9 */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* A */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* B */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* C */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* D */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* E */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* F */ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0900, 0x0A00, + + // Table 1 (for high byte 0x00) + + /* 0 */ 0xFFFF, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, + /* 1 */ 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F, + /* 2 */ 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, + /* 3 */ 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, + /* 4 */ 0x0040, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, + /* 5 */ 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, + /* 6 */ 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, + /* 7 */ 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F, + /* 8 */ 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x008D, 0x008E, 0x008F, + /* 9 */ 0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009A, 0x009B, 0x009C, 0x009D, 0x009E, 0x009F, + /* A */ 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, + /* B */ 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF, + /* C */ 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00E6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, + /* D */ 0x00F0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00F8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00FE, 0x00DF, + /* E */ 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, + /* F */ 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF, + + // Table 2 (for high byte 0x01) + + /* 0 */ 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 0x0105, 0x0106, 0x0107, 0x0108, 0x0109, 0x010A, 0x010B, 0x010C, 0x010D, 0x010E, 0x010F, + /* 1 */ 0x0111, 0x0111, 0x0112, 0x0113, 0x0114, 0x0115, 0x0116, 0x0117, 0x0118, 0x0119, 0x011A, 0x011B, 0x011C, 0x011D, 0x011E, 0x011F, + /* 2 */ 0x0120, 0x0121, 0x0122, 0x0123, 0x0124, 0x0125, 0x0127, 0x0127, 0x0128, 0x0129, 0x012A, 0x012B, 0x012C, 0x012D, 0x012E, 0x012F, + /* 3 */ 0x0130, 0x0131, 0x0133, 0x0133, 0x0134, 0x0135, 0x0136, 0x0137, 0x0138, 0x0139, 0x013A, 0x013B, 0x013C, 0x013D, 0x013E, 0x0140, + /* 4 */ 0x0140, 0x0142, 0x0142, 0x0143, 0x0144, 0x0145, 0x0146, 0x0147, 0x0148, 0x0149, 0x014B, 0x014B, 0x014C, 0x014D, 0x014E, 0x014F, + /* 5 */ 0x0150, 0x0151, 0x0153, 0x0153, 0x0154, 0x0155, 0x0156, 0x0157, 0x0158, 0x0159, 0x015A, 0x015B, 0x015C, 0x015D, 0x015E, 0x015F, + /* 6 */ 0x0160, 0x0161, 0x0162, 0x0163, 0x0164, 0x0165, 0x0167, 0x0167, 0x0168, 0x0169, 0x016A, 0x016B, 0x016C, 0x016D, 0x016E, 0x016F, + /* 7 */ 0x0170, 0x0171, 0x0172, 0x0173, 0x0174, 0x0175, 0x0176, 0x0177, 0x0178, 0x0179, 0x017A, 0x017B, 0x017C, 0x017D, 0x017E, 0x017F, + /* 8 */ 0x0180, 0x0253, 0x0183, 0x0183, 0x0185, 0x0185, 0x0254, 0x0188, 0x0188, 0x0256, 0x0257, 0x018C, 0x018C, 0x018D, 0x01DD, 0x0259, + /* 9 */ 0x025B, 0x0192, 0x0192, 0x0260, 0x0263, 0x0195, 0x0269, 0x0268, 0x0199, 0x0199, 0x019A, 0x019B, 0x026F, 0x0272, 0x019E, 0x0275, + /* A */ 0x01A0, 0x01A1, 0x01A3, 0x01A3, 0x01A5, 0x01A5, 0x01A6, 0x01A8, 0x01A8, 0x0283, 0x01AA, 0x01AB, 0x01AD, 0x01AD, 0x0288, 0x01AF, + /* B */ 0x01B0, 0x028A, 0x028B, 0x01B4, 0x01B4, 0x01B6, 0x01B6, 0x0292, 0x01B9, 0x01B9, 0x01BA, 0x01BB, 0x01BD, 0x01BD, 0x01BE, 0x01BF, + /* C */ 0x01C0, 0x01C1, 0x01C2, 0x01C3, 0x01C6, 0x01C6, 0x01C6, 0x01C9, 0x01C9, 0x01C9, 0x01CC, 0x01CC, 0x01CC, 0x01CD, 0x01CE, 0x01CF, + /* D */ 0x01D0, 0x01D1, 0x01D2, 0x01D3, 0x01D4, 0x01D5, 0x01D6, 0x01D7, 0x01D8, 0x01D9, 0x01DA, 0x01DB, 0x01DC, 0x01DD, 0x01DE, 0x01DF, + /* E */ 0x01E0, 0x01E1, 0x01E2, 0x01E3, 0x01E5, 0x01E5, 0x01E6, 0x01E7, 0x01E8, 0x01E9, 0x01EA, 0x01EB, 0x01EC, 0x01ED, 0x01EE, 0x01EF, + /* F */ 0x01F0, 0x01F3, 0x01F3, 0x01F3, 0x01F4, 0x01F5, 0x01F6, 0x01F7, 0x01F8, 0x01F9, 0x01FA, 0x01FB, 0x01FC, 0x01FD, 0x01FE, 0x01FF, + + // Table 3 (for high byte 0x03) + + /* 0 */ 0x0300, 0x0301, 0x0302, 0x0303, 0x0304, 0x0305, 0x0306, 0x0307, 0x0308, 0x0309, 0x030A, 0x030B, 0x030C, 0x030D, 0x030E, 0x030F, + /* 1 */ 0x0310, 0x0311, 0x0312, 0x0313, 0x0314, 0x0315, 0x0316, 0x0317, 0x0318, 0x0319, 0x031A, 0x031B, 0x031C, 0x031D, 0x031E, 0x031F, + /* 2 */ 0x0320, 0x0321, 0x0322, 0x0323, 0x0324, 0x0325, 0x0326, 0x0327, 0x0328, 0x0329, 0x032A, 0x032B, 0x032C, 0x032D, 0x032E, 0x032F, + /* 3 */ 0x0330, 0x0331, 0x0332, 0x0333, 0x0334, 0x0335, 0x0336, 0x0337, 0x0338, 0x0339, 0x033A, 0x033B, 0x033C, 0x033D, 0x033E, 0x033F, + /* 4 */ 0x0340, 0x0341, 0x0342, 0x0343, 0x0344, 0x0345, 0x0346, 0x0347, 0x0348, 0x0349, 0x034A, 0x034B, 0x034C, 0x034D, 0x034E, 0x034F, + /* 5 */ 0x0350, 0x0351, 0x0352, 0x0353, 0x0354, 0x0355, 0x0356, 0x0357, 0x0358, 0x0359, 0x035A, 0x035B, 0x035C, 0x035D, 0x035E, 0x035F, + /* 6 */ 0x0360, 0x0361, 0x0362, 0x0363, 0x0364, 0x0365, 0x0366, 0x0367, 0x0368, 0x0369, 0x036A, 0x036B, 0x036C, 0x036D, 0x036E, 0x036F, + /* 7 */ 0x0370, 0x0371, 0x0372, 0x0373, 0x0374, 0x0375, 0x0376, 0x0377, 0x0378, 0x0379, 0x037A, 0x037B, 0x037C, 0x037D, 0x037E, 0x037F, + /* 8 */ 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386, 0x0387, 0x0388, 0x0389, 0x038A, 0x038B, 0x038C, 0x038D, 0x038E, 0x038F, + /* 9 */ 0x0390, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, + /* A */ 0x03C0, 0x03C1, 0x03A2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF, + /* B */ 0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, + /* C */ 0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0x03CF, + /* D */ 0x03D0, 0x03D1, 0x03D2, 0x03D3, 0x03D4, 0x03D5, 0x03D6, 0x03D7, 0x03D8, 0x03D9, 0x03DA, 0x03DB, 0x03DC, 0x03DD, 0x03DE, 0x03DF, + /* E */ 0x03E0, 0x03E1, 0x03E3, 0x03E3, 0x03E5, 0x03E5, 0x03E7, 0x03E7, 0x03E9, 0x03E9, 0x03EB, 0x03EB, 0x03ED, 0x03ED, 0x03EF, 0x03EF, + /* F */ 0x03F0, 0x03F1, 0x03F2, 0x03F3, 0x03F4, 0x03F5, 0x03F6, 0x03F7, 0x03F8, 0x03F9, 0x03FA, 0x03FB, 0x03FC, 0x03FD, 0x03FE, 0x03FF, + + // Table 4 (for high byte 0x04) + + /* 0 */ 0x0400, 0x0401, 0x0452, 0x0403, 0x0454, 0x0455, 0x0456, 0x0407, 0x0458, 0x0459, 0x045A, 0x045B, 0x040C, 0x040D, 0x040E, 0x045F, + /* 1 */ 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0419, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, + /* 2 */ 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, + /* 3 */ 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, + /* 4 */ 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, + /* 5 */ 0x0450, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x045D, 0x045E, 0x045F, + /* 6 */ 0x0461, 0x0461, 0x0463, 0x0463, 0x0465, 0x0465, 0x0467, 0x0467, 0x0469, 0x0469, 0x046B, 0x046B, 0x046D, 0x046D, 0x046F, 0x046F, + /* 7 */ 0x0471, 0x0471, 0x0473, 0x0473, 0x0475, 0x0475, 0x0476, 0x0477, 0x0479, 0x0479, 0x047B, 0x047B, 0x047D, 0x047D, 0x047F, 0x047F, + /* 8 */ 0x0481, 0x0481, 0x0482, 0x0483, 0x0484, 0x0485, 0x0486, 0x0487, 0x0488, 0x0489, 0x048A, 0x048B, 0x048C, 0x048D, 0x048E, 0x048F, + /* 9 */ 0x0491, 0x0491, 0x0493, 0x0493, 0x0495, 0x0495, 0x0497, 0x0497, 0x0499, 0x0499, 0x049B, 0x049B, 0x049D, 0x049D, 0x049F, 0x049F, + /* A */ 0x04A1, 0x04A1, 0x04A3, 0x04A3, 0x04A5, 0x04A5, 0x04A7, 0x04A7, 0x04A9, 0x04A9, 0x04AB, 0x04AB, 0x04AD, 0x04AD, 0x04AF, 0x04AF, + /* B */ 0x04B1, 0x04B1, 0x04B3, 0x04B3, 0x04B5, 0x04B5, 0x04B7, 0x04B7, 0x04B9, 0x04B9, 0x04BB, 0x04BB, 0x04BD, 0x04BD, 0x04BF, 0x04BF, + /* C */ 0x04C0, 0x04C1, 0x04C2, 0x04C4, 0x04C4, 0x04C5, 0x04C6, 0x04C8, 0x04C8, 0x04C9, 0x04CA, 0x04CC, 0x04CC, 0x04CD, 0x04CE, 0x04CF, + /* D */ 0x04D0, 0x04D1, 0x04D2, 0x04D3, 0x04D4, 0x04D5, 0x04D6, 0x04D7, 0x04D8, 0x04D9, 0x04DA, 0x04DB, 0x04DC, 0x04DD, 0x04DE, 0x04DF, + /* E */ 0x04E0, 0x04E1, 0x04E2, 0x04E3, 0x04E4, 0x04E5, 0x04E6, 0x04E7, 0x04E8, 0x04E9, 0x04EA, 0x04EB, 0x04EC, 0x04ED, 0x04EE, 0x04EF, + /* F */ 0x04F0, 0x04F1, 0x04F2, 0x04F3, 0x04F4, 0x04F5, 0x04F6, 0x04F7, 0x04F8, 0x04F9, 0x04FA, 0x04FB, 0x04FC, 0x04FD, 0x04FE, 0x04FF, + + // Table 5 (for high byte 0x05) + + /* 0 */ 0x0500, 0x0501, 0x0502, 0x0503, 0x0504, 0x0505, 0x0506, 0x0507, 0x0508, 0x0509, 0x050A, 0x050B, 0x050C, 0x050D, 0x050E, 0x050F, + /* 1 */ 0x0510, 0x0511, 0x0512, 0x0513, 0x0514, 0x0515, 0x0516, 0x0517, 0x0518, 0x0519, 0x051A, 0x051B, 0x051C, 0x051D, 0x051E, 0x051F, + /* 2 */ 0x0520, 0x0521, 0x0522, 0x0523, 0x0524, 0x0525, 0x0526, 0x0527, 0x0528, 0x0529, 0x052A, 0x052B, 0x052C, 0x052D, 0x052E, 0x052F, + /* 3 */ 0x0530, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567, 0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F, + /* 4 */ 0x0570, 0x0571, 0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577, 0x0578, 0x0579, 0x057A, 0x057B, 0x057C, 0x057D, 0x057E, 0x057F, + /* 5 */ 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585, 0x0586, 0x0557, 0x0558, 0x0559, 0x055A, 0x055B, 0x055C, 0x055D, 0x055E, 0x055F, + /* 6 */ 0x0560, 0x0561, 0x0562, 0x0563, 0x0564, 0x0565, 0x0566, 0x0567, 0x0568, 0x0569, 0x056A, 0x056B, 0x056C, 0x056D, 0x056E, 0x056F, + /* 7 */ 0x0570, 0x0571, 0x0572, 0x0573, 0x0574, 0x0575, 0x0576, 0x0577, 0x0578, 0x0579, 0x057A, 0x057B, 0x057C, 0x057D, 0x057E, 0x057F, + /* 8 */ 0x0580, 0x0581, 0x0582, 0x0583, 0x0584, 0x0585, 0x0586, 0x0587, 0x0588, 0x0589, 0x058A, 0x058B, 0x058C, 0x058D, 0x058E, 0x058F, + /* 9 */ 0x0590, 0x0591, 0x0592, 0x0593, 0x0594, 0x0595, 0x0596, 0x0597, 0x0598, 0x0599, 0x059A, 0x059B, 0x059C, 0x059D, 0x059E, 0x059F, + /* A */ 0x05A0, 0x05A1, 0x05A2, 0x05A3, 0x05A4, 0x05A5, 0x05A6, 0x05A7, 0x05A8, 0x05A9, 0x05AA, 0x05AB, 0x05AC, 0x05AD, 0x05AE, 0x05AF, + /* B */ 0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7, 0x05B8, 0x05B9, 0x05BA, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF, + /* C */ 0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05C4, 0x05C5, 0x05C6, 0x05C7, 0x05C8, 0x05C9, 0x05CA, 0x05CB, 0x05CC, 0x05CD, 0x05CE, 0x05CF, + /* D */ 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF, + /* E */ 0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7, 0x05E8, 0x05E9, 0x05EA, 0x05EB, 0x05EC, 0x05ED, 0x05EE, 0x05EF, + /* F */ 0x05F0, 0x05F1, 0x05F2, 0x05F3, 0x05F4, 0x05F5, 0x05F6, 0x05F7, 0x05F8, 0x05F9, 0x05FA, 0x05FB, 0x05FC, 0x05FD, 0x05FE, 0x05FF, + + // Table 6 (for high byte 0x10) + + /* 0 */ 0x1000, 0x1001, 0x1002, 0x1003, 0x1004, 0x1005, 0x1006, 0x1007, 0x1008, 0x1009, 0x100A, 0x100B, 0x100C, 0x100D, 0x100E, 0x100F, + /* 1 */ 0x1010, 0x1011, 0x1012, 0x1013, 0x1014, 0x1015, 0x1016, 0x1017, 0x1018, 0x1019, 0x101A, 0x101B, 0x101C, 0x101D, 0x101E, 0x101F, + /* 2 */ 0x1020, 0x1021, 0x1022, 0x1023, 0x1024, 0x1025, 0x1026, 0x1027, 0x1028, 0x1029, 0x102A, 0x102B, 0x102C, 0x102D, 0x102E, 0x102F, + /* 3 */ 0x1030, 0x1031, 0x1032, 0x1033, 0x1034, 0x1035, 0x1036, 0x1037, 0x1038, 0x1039, 0x103A, 0x103B, 0x103C, 0x103D, 0x103E, 0x103F, + /* 4 */ 0x1040, 0x1041, 0x1042, 0x1043, 0x1044, 0x1045, 0x1046, 0x1047, 0x1048, 0x1049, 0x104A, 0x104B, 0x104C, 0x104D, 0x104E, 0x104F, + /* 5 */ 0x1050, 0x1051, 0x1052, 0x1053, 0x1054, 0x1055, 0x1056, 0x1057, 0x1058, 0x1059, 0x105A, 0x105B, 0x105C, 0x105D, 0x105E, 0x105F, + /* 6 */ 0x1060, 0x1061, 0x1062, 0x1063, 0x1064, 0x1065, 0x1066, 0x1067, 0x1068, 0x1069, 0x106A, 0x106B, 0x106C, 0x106D, 0x106E, 0x106F, + /* 7 */ 0x1070, 0x1071, 0x1072, 0x1073, 0x1074, 0x1075, 0x1076, 0x1077, 0x1078, 0x1079, 0x107A, 0x107B, 0x107C, 0x107D, 0x107E, 0x107F, + /* 8 */ 0x1080, 0x1081, 0x1082, 0x1083, 0x1084, 0x1085, 0x1086, 0x1087, 0x1088, 0x1089, 0x108A, 0x108B, 0x108C, 0x108D, 0x108E, 0x108F, + /* 9 */ 0x1090, 0x1091, 0x1092, 0x1093, 0x1094, 0x1095, 0x1096, 0x1097, 0x1098, 0x1099, 0x109A, 0x109B, 0x109C, 0x109D, 0x109E, 0x109F, + /* A */ 0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7, 0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF, + /* B */ 0x10E0, 0x10E1, 0x10E2, 0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7, 0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10EF, + /* C */ 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10C6, 0x10C7, 0x10C8, 0x10C9, 0x10CA, 0x10CB, 0x10CC, 0x10CD, 0x10CE, 0x10CF, + /* D */ 0x10D0, 0x10D1, 0x10D2, 0x10D3, 0x10D4, 0x10D5, 0x10D6, 0x10D7, 0x10D8, 0x10D9, 0x10DA, 0x10DB, 0x10DC, 0x10DD, 0x10DE, 0x10DF, + /* E */ 0x10E0, 0x10E1, 0x10E2, 0x10E3, 0x10E4, 0x10E5, 0x10E6, 0x10E7, 0x10E8, 0x10E9, 0x10EA, 0x10EB, 0x10EC, 0x10ED, 0x10EE, 0x10EF, + /* F */ 0x10F0, 0x10F1, 0x10F2, 0x10F3, 0x10F4, 0x10F5, 0x10F6, 0x10F7, 0x10F8, 0x10F9, 0x10FA, 0x10FB, 0x10FC, 0x10FD, 0x10FE, 0x10FF, + + // Table 7 (for high byte 0x20) + + /* 0 */ 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x200B, 0x0000, 0x0000, 0x0000, 0x0000, + /* 1 */ 0x2010, 0x2011, 0x2012, 0x2013, 0x2014, 0x2015, 0x2016, 0x2017, 0x2018, 0x2019, 0x201A, 0x201B, 0x201C, 0x201D, 0x201E, 0x201F, + /* 2 */ 0x2020, 0x2021, 0x2022, 0x2023, 0x2024, 0x2025, 0x2026, 0x2027, 0x2028, 0x2029, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x202F, + /* 3 */ 0x2030, 0x2031, 0x2032, 0x2033, 0x2034, 0x2035, 0x2036, 0x2037, 0x2038, 0x2039, 0x203A, 0x203B, 0x203C, 0x203D, 0x203E, 0x203F, + /* 4 */ 0x2040, 0x2041, 0x2042, 0x2043, 0x2044, 0x2045, 0x2046, 0x2047, 0x2048, 0x2049, 0x204A, 0x204B, 0x204C, 0x204D, 0x204E, 0x204F, + /* 5 */ 0x2050, 0x2051, 0x2052, 0x2053, 0x2054, 0x2055, 0x2056, 0x2057, 0x2058, 0x2059, 0x205A, 0x205B, 0x205C, 0x205D, 0x205E, 0x205F, + /* 6 */ 0x2060, 0x2061, 0x2062, 0x2063, 0x2064, 0x2065, 0x2066, 0x2067, 0x2068, 0x2069, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + /* 7 */ 0x2070, 0x2071, 0x2072, 0x2073, 0x2074, 0x2075, 0x2076, 0x2077, 0x2078, 0x2079, 0x207A, 0x207B, 0x207C, 0x207D, 0x207E, 0x207F, + /* 8 */ 0x2080, 0x2081, 0x2082, 0x2083, 0x2084, 0x2085, 0x2086, 0x2087, 0x2088, 0x2089, 0x208A, 0x208B, 0x208C, 0x208D, 0x208E, 0x208F, + /* 9 */ 0x2090, 0x2091, 0x2092, 0x2093, 0x2094, 0x2095, 0x2096, 0x2097, 0x2098, 0x2099, 0x209A, 0x209B, 0x209C, 0x209D, 0x209E, 0x209F, + /* A */ 0x20A0, 0x20A1, 0x20A2, 0x20A3, 0x20A4, 0x20A5, 0x20A6, 0x20A7, 0x20A8, 0x20A9, 0x20AA, 0x20AB, 0x20AC, 0x20AD, 0x20AE, 0x20AF, + /* B */ 0x20B0, 0x20B1, 0x20B2, 0x20B3, 0x20B4, 0x20B5, 0x20B6, 0x20B7, 0x20B8, 0x20B9, 0x20BA, 0x20BB, 0x20BC, 0x20BD, 0x20BE, 0x20BF, + /* C */ 0x20C0, 0x20C1, 0x20C2, 0x20C3, 0x20C4, 0x20C5, 0x20C6, 0x20C7, 0x20C8, 0x20C9, 0x20CA, 0x20CB, 0x20CC, 0x20CD, 0x20CE, 0x20CF, + /* D */ 0x20D0, 0x20D1, 0x20D2, 0x20D3, 0x20D4, 0x20D5, 0x20D6, 0x20D7, 0x20D8, 0x20D9, 0x20DA, 0x20DB, 0x20DC, 0x20DD, 0x20DE, 0x20DF, + /* E */ 0x20E0, 0x20E1, 0x20E2, 0x20E3, 0x20E4, 0x20E5, 0x20E6, 0x20E7, 0x20E8, 0x20E9, 0x20EA, 0x20EB, 0x20EC, 0x20ED, 0x20EE, 0x20EF, + /* F */ 0x20F0, 0x20F1, 0x20F2, 0x20F3, 0x20F4, 0x20F5, 0x20F6, 0x20F7, 0x20F8, 0x20F9, 0x20FA, 0x20FB, 0x20FC, 0x20FD, 0x20FE, 0x20FF, + + // Table 8 (for high byte 0x21) + + /* 0 */ 0x2100, 0x2101, 0x2102, 0x2103, 0x2104, 0x2105, 0x2106, 0x2107, 0x2108, 0x2109, 0x210A, 0x210B, 0x210C, 0x210D, 0x210E, 0x210F, + /* 1 */ 0x2110, 0x2111, 0x2112, 0x2113, 0x2114, 0x2115, 0x2116, 0x2117, 0x2118, 0x2119, 0x211A, 0x211B, 0x211C, 0x211D, 0x211E, 0x211F, + /* 2 */ 0x2120, 0x2121, 0x2122, 0x2123, 0x2124, 0x2125, 0x2126, 0x2127, 0x2128, 0x2129, 0x212A, 0x212B, 0x212C, 0x212D, 0x212E, 0x212F, + /* 3 */ 0x2130, 0x2131, 0x2132, 0x2133, 0x2134, 0x2135, 0x2136, 0x2137, 0x2138, 0x2139, 0x213A, 0x213B, 0x213C, 0x213D, 0x213E, 0x213F, + /* 4 */ 0x2140, 0x2141, 0x2142, 0x2143, 0x2144, 0x2145, 0x2146, 0x2147, 0x2148, 0x2149, 0x214A, 0x214B, 0x214C, 0x214D, 0x214E, 0x214F, + /* 5 */ 0x2150, 0x2151, 0x2152, 0x2153, 0x2154, 0x2155, 0x2156, 0x2157, 0x2158, 0x2159, 0x215A, 0x215B, 0x215C, 0x215D, 0x215E, 0x215F, + /* 6 */ 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F, + /* 7 */ 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0x217A, 0x217B, 0x217C, 0x217D, 0x217E, 0x217F, + /* 8 */ 0x2180, 0x2181, 0x2182, 0x2183, 0x2184, 0x2185, 0x2186, 0x2187, 0x2188, 0x2189, 0x218A, 0x218B, 0x218C, 0x218D, 0x218E, 0x218F, + /* 9 */ 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x2195, 0x2196, 0x2197, 0x2198, 0x2199, 0x219A, 0x219B, 0x219C, 0x219D, 0x219E, 0x219F, + /* A */ 0x21A0, 0x21A1, 0x21A2, 0x21A3, 0x21A4, 0x21A5, 0x21A6, 0x21A7, 0x21A8, 0x21A9, 0x21AA, 0x21AB, 0x21AC, 0x21AD, 0x21AE, 0x21AF, + /* B */ 0x21B0, 0x21B1, 0x21B2, 0x21B3, 0x21B4, 0x21B5, 0x21B6, 0x21B7, 0x21B8, 0x21B9, 0x21BA, 0x21BB, 0x21BC, 0x21BD, 0x21BE, 0x21BF, + /* C */ 0x21C0, 0x21C1, 0x21C2, 0x21C3, 0x21C4, 0x21C5, 0x21C6, 0x21C7, 0x21C8, 0x21C9, 0x21CA, 0x21CB, 0x21CC, 0x21CD, 0x21CE, 0x21CF, + /* D */ 0x21D0, 0x21D1, 0x21D2, 0x21D3, 0x21D4, 0x21D5, 0x21D6, 0x21D7, 0x21D8, 0x21D9, 0x21DA, 0x21DB, 0x21DC, 0x21DD, 0x21DE, 0x21DF, + /* E */ 0x21E0, 0x21E1, 0x21E2, 0x21E3, 0x21E4, 0x21E5, 0x21E6, 0x21E7, 0x21E8, 0x21E9, 0x21EA, 0x21EB, 0x21EC, 0x21ED, 0x21EE, 0x21EF, + /* F */ 0x21F0, 0x21F1, 0x21F2, 0x21F3, 0x21F4, 0x21F5, 0x21F6, 0x21F7, 0x21F8, 0x21F9, 0x21FA, 0x21FB, 0x21FC, 0x21FD, 0x21FE, 0x21FF, + + // Table 9 (for high byte 0xFE) + + /* 0 */ 0xFE00, 0xFE01, 0xFE02, 0xFE03, 0xFE04, 0xFE05, 0xFE06, 0xFE07, 0xFE08, 0xFE09, 0xFE0A, 0xFE0B, 0xFE0C, 0xFE0D, 0xFE0E, 0xFE0F, + /* 1 */ 0xFE10, 0xFE11, 0xFE12, 0xFE13, 0xFE14, 0xFE15, 0xFE16, 0xFE17, 0xFE18, 0xFE19, 0xFE1A, 0xFE1B, 0xFE1C, 0xFE1D, 0xFE1E, 0xFE1F, + /* 2 */ 0xFE20, 0xFE21, 0xFE22, 0xFE23, 0xFE24, 0xFE25, 0xFE26, 0xFE27, 0xFE28, 0xFE29, 0xFE2A, 0xFE2B, 0xFE2C, 0xFE2D, 0xFE2E, 0xFE2F, + /* 3 */ 0xFE30, 0xFE31, 0xFE32, 0xFE33, 0xFE34, 0xFE35, 0xFE36, 0xFE37, 0xFE38, 0xFE39, 0xFE3A, 0xFE3B, 0xFE3C, 0xFE3D, 0xFE3E, 0xFE3F, + /* 4 */ 0xFE40, 0xFE41, 0xFE42, 0xFE43, 0xFE44, 0xFE45, 0xFE46, 0xFE47, 0xFE48, 0xFE49, 0xFE4A, 0xFE4B, 0xFE4C, 0xFE4D, 0xFE4E, 0xFE4F, + /* 5 */ 0xFE50, 0xFE51, 0xFE52, 0xFE53, 0xFE54, 0xFE55, 0xFE56, 0xFE57, 0xFE58, 0xFE59, 0xFE5A, 0xFE5B, 0xFE5C, 0xFE5D, 0xFE5E, 0xFE5F, + /* 6 */ 0xFE60, 0xFE61, 0xFE62, 0xFE63, 0xFE64, 0xFE65, 0xFE66, 0xFE67, 0xFE68, 0xFE69, 0xFE6A, 0xFE6B, 0xFE6C, 0xFE6D, 0xFE6E, 0xFE6F, + /* 7 */ 0xFE70, 0xFE71, 0xFE72, 0xFE73, 0xFE74, 0xFE75, 0xFE76, 0xFE77, 0xFE78, 0xFE79, 0xFE7A, 0xFE7B, 0xFE7C, 0xFE7D, 0xFE7E, 0xFE7F, + /* 8 */ 0xFE80, 0xFE81, 0xFE82, 0xFE83, 0xFE84, 0xFE85, 0xFE86, 0xFE87, 0xFE88, 0xFE89, 0xFE8A, 0xFE8B, 0xFE8C, 0xFE8D, 0xFE8E, 0xFE8F, + /* 9 */ 0xFE90, 0xFE91, 0xFE92, 0xFE93, 0xFE94, 0xFE95, 0xFE96, 0xFE97, 0xFE98, 0xFE99, 0xFE9A, 0xFE9B, 0xFE9C, 0xFE9D, 0xFE9E, 0xFE9F, + /* A */ 0xFEA0, 0xFEA1, 0xFEA2, 0xFEA3, 0xFEA4, 0xFEA5, 0xFEA6, 0xFEA7, 0xFEA8, 0xFEA9, 0xFEAA, 0xFEAB, 0xFEAC, 0xFEAD, 0xFEAE, 0xFEAF, + /* B */ 0xFEB0, 0xFEB1, 0xFEB2, 0xFEB3, 0xFEB4, 0xFEB5, 0xFEB6, 0xFEB7, 0xFEB8, 0xFEB9, 0xFEBA, 0xFEBB, 0xFEBC, 0xFEBD, 0xFEBE, 0xFEBF, + /* C */ 0xFEC0, 0xFEC1, 0xFEC2, 0xFEC3, 0xFEC4, 0xFEC5, 0xFEC6, 0xFEC7, 0xFEC8, 0xFEC9, 0xFECA, 0xFECB, 0xFECC, 0xFECD, 0xFECE, 0xFECF, + /* D */ 0xFED0, 0xFED1, 0xFED2, 0xFED3, 0xFED4, 0xFED5, 0xFED6, 0xFED7, 0xFED8, 0xFED9, 0xFEDA, 0xFEDB, 0xFEDC, 0xFEDD, 0xFEDE, 0xFEDF, + /* E */ 0xFEE0, 0xFEE1, 0xFEE2, 0xFEE3, 0xFEE4, 0xFEE5, 0xFEE6, 0xFEE7, 0xFEE8, 0xFEE9, 0xFEEA, 0xFEEB, 0xFEEC, 0xFEED, 0xFEEE, 0xFEEF, + /* F */ 0xFEF0, 0xFEF1, 0xFEF2, 0xFEF3, 0xFEF4, 0xFEF5, 0xFEF6, 0xFEF7, 0xFEF8, 0xFEF9, 0xFEFA, 0xFEFB, 0xFEFC, 0xFEFD, 0xFEFE, 0x0000, + + // Table 10 (for high byte 0xFF) + + /* 0 */ 0xFF00, 0xFF01, 0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07, 0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, + /* 1 */ 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F, + /* 2 */ 0xFF20, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, + /* 3 */ 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0xFF3B, 0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F, + /* 4 */ 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, + /* 5 */ 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFF5E, 0xFF5F, + /* 6 */ 0xFF60, 0xFF61, 0xFF62, 0xFF63, 0xFF64, 0xFF65, 0xFF66, 0xFF67, 0xFF68, 0xFF69, 0xFF6A, 0xFF6B, 0xFF6C, 0xFF6D, 0xFF6E, 0xFF6F, + /* 7 */ 0xFF70, 0xFF71, 0xFF72, 0xFF73, 0xFF74, 0xFF75, 0xFF76, 0xFF77, 0xFF78, 0xFF79, 0xFF7A, 0xFF7B, 0xFF7C, 0xFF7D, 0xFF7E, 0xFF7F, + /* 8 */ 0xFF80, 0xFF81, 0xFF82, 0xFF83, 0xFF84, 0xFF85, 0xFF86, 0xFF87, 0xFF88, 0xFF89, 0xFF8A, 0xFF8B, 0xFF8C, 0xFF8D, 0xFF8E, 0xFF8F, + /* 9 */ 0xFF90, 0xFF91, 0xFF92, 0xFF93, 0xFF94, 0xFF95, 0xFF96, 0xFF97, 0xFF98, 0xFF99, 0xFF9A, 0xFF9B, 0xFF9C, 0xFF9D, 0xFF9E, 0xFF9F, + /* A */ 0xFFA0, 0xFFA1, 0xFFA2, 0xFFA3, 0xFFA4, 0xFFA5, 0xFFA6, 0xFFA7, 0xFFA8, 0xFFA9, 0xFFAA, 0xFFAB, 0xFFAC, 0xFFAD, 0xFFAE, 0xFFAF, + /* B */ 0xFFB0, 0xFFB1, 0xFFB2, 0xFFB3, 0xFFB4, 0xFFB5, 0xFFB6, 0xFFB7, 0xFFB8, 0xFFB9, 0xFFBA, 0xFFBB, 0xFFBC, 0xFFBD, 0xFFBE, 0xFFBF, + /* C */ 0xFFC0, 0xFFC1, 0xFFC2, 0xFFC3, 0xFFC4, 0xFFC5, 0xFFC6, 0xFFC7, 0xFFC8, 0xFFC9, 0xFFCA, 0xFFCB, 0xFFCC, 0xFFCD, 0xFFCE, 0xFFCF, + /* D */ 0xFFD0, 0xFFD1, 0xFFD2, 0xFFD3, 0xFFD4, 0xFFD5, 0xFFD6, 0xFFD7, 0xFFD8, 0xFFD9, 0xFFDA, 0xFFDB, 0xFFDC, 0xFFDD, 0xFFDE, 0xFFDF, + /* E */ 0xFFE0, 0xFFE1, 0xFFE2, 0xFFE3, 0xFFE4, 0xFFE5, 0xFFE6, 0xFFE7, 0xFFE8, 0xFFE9, 0xFFEA, 0xFFEB, 0xFFEC, 0xFFED, 0xFFEE, 0xFFEF, + /* F */ 0xFFF0, 0xFFF1, 0xFFF2, 0xFFF3, 0xFFF4, 0xFFF5, 0xFFF6, 0xFFF7, 0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF, +}; + +/* RelString case folding table */ + +unsigned short gCompareTable[] = { + + /* 0 */ 0x0000, 0x0100, 0x0200, 0x0300, 0x0400, 0x0500, 0x0600, 0x0700, 0x0800, 0x0900, 0x0A00, 0x0B00, 0x0C00, 0x0D00, 0x0E00, 0x0F00, + /* 1 */ 0x1000, 0x1100, 0x1200, 0x1300, 0x1400, 0x1500, 0x1600, 0x1700, 0x1800, 0x1900, 0x1A00, 0x1B00, 0x1C00, 0x1D00, 0x1E00, 0x1F00, + /* 2 */ 0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500, 0x2600, 0x2700, 0x2800, 0x2900, 0x2A00, 0x2B00, 0x2C00, 0x2D00, 0x2E00, 0x2F00, + /* 3 */ 0x3000, 0x3100, 0x3200, 0x3300, 0x3400, 0x3500, 0x3600, 0x3700, 0x3800, 0x3900, 0x3A00, 0x3B00, 0x3C00, 0x3D00, 0x3E00, 0x3F00, + /* 4 */ 0x4000, 0x4100, 0x4200, 0x4300, 0x4400, 0x4500, 0x4600, 0x4700, 0x4800, 0x4900, 0x4A00, 0x4B00, 0x4C00, 0x4D00, 0x4E00, 0x4F00, + /* 5 */ 0x5000, 0x5100, 0x5200, 0x5300, 0x5400, 0x5500, 0x5600, 0x5700, 0x5800, 0x5900, 0x5A00, 0x5B00, 0x5C00, 0x5D00, 0x5E00, 0x5F00, + + // 0x60 maps to 'a' + // range 0x61 to 0x7a ('a' to 'z') map to upper case + + /* 6 */ 0x4180, 0x4100, 0x4200, 0x4300, 0x4400, 0x4500, 0x4600, 0x4700, 0x4800, 0x4900, 0x4A00, 0x4B00, 0x4C00, 0x4D00, 0x4E00, 0x4F00, + /* 7 */ 0x5000, 0x5100, 0x5200, 0x5300, 0x5400, 0x5500, 0x5600, 0x5700, 0x5800, 0x5900, 0x5A00, 0x7B00, 0x7C00, 0x7D00, 0x7E00, 0x7F00, + + // range 0x80 to 0xd8 gets mapped... + + /* 8 */ 0x4108, 0x410C, 0x4310, 0x4502, 0x4E0A, 0x4F08, 0x5508, 0x4182, 0x4104, 0x4186, 0x4108, 0x410A, 0x410C, 0x4310, 0x4502, 0x4584, + /* 9 */ 0x4586, 0x4588, 0x4982, 0x4984, 0x4986, 0x4988, 0x4E0A, 0x4F82, 0x4F84, 0x4F86, 0x4F08, 0x4F0A, 0x5582, 0x5584, 0x5586, 0x5508, + /* A */ 0xA000, 0xA100, 0xA200, 0xA300, 0xA400, 0xA500, 0xA600, 0x5382, 0xA800, 0xA900, 0xAA00, 0xAB00, 0xAC00, 0xAD00, 0x4114, 0x4F0E, + /* B */ 0xB000, 0xB100, 0xB200, 0xB300, 0xB400, 0xB500, 0xB600, 0xB700, 0xB800, 0xB900, 0xBA00, 0x4192, 0x4F92, 0xBD00, 0x4114, 0x4F0E, + /* C */ 0xC000, 0xC100, 0xC200, 0xC300, 0xC400, 0xC500, 0xC600, 0x2206, 0x2208, 0xC900, 0x2000, 0x4104, 0x410A, 0x4F0A, 0x4F14, 0x4F14, + /* D */ 0xD000, 0xD100, 0x2202, 0x2204, 0x2702, 0x2704, 0xD600, 0xD700, 0x5988, 0xD900, 0xDA00, 0xDB00, 0xDC00, 0xDD00, 0xDE00, 0xDF00, + + /* E */ 0xE000, 0xE100, 0xE200, 0xE300, 0xE400, 0xE500, 0xE600, 0xE700, 0xE800, 0xE900, 0xEA00, 0xEB00, 0xEC00, 0xED00, 0xEE00, 0xEF00, + /* F */ 0xF000, 0xF100, 0xF200, 0xF300, 0xF400, 0xF500, 0xF600, 0xF700, 0xF800, 0xF900, 0xFA00, 0xFB00, 0xFC00, 0xFD00, 0xFE00, 0xFF00, + +}; +#else /* ! UNCOMPRESSED */ + +enum { + kTypeLiteral = 0, + kTypeAscending = 1, + kTypeAscending256 = 2 +}; + +struct compressed_block { + unsigned char type; + unsigned char count; + unsigned short data; +}; + +unsigned short *gLowerCaseTable; + +struct compressed_block gLowerCaseTableCompressed[] = { + {0x0, 0x1, 0x100}, + {0x0, 0x1, 0x200}, + {0x0, 0x1, 0x0}, + {0x0, 0x1, 0x300}, + {0x0, 0x1, 0x400}, + {0x0, 0x1, 0x500}, + {0x0, 0xa, 0x0}, + {0x0, 0x1, 0x600}, + {0x0, 0xf, 0x0}, + {0x0, 0x1, 0x700}, + {0x0, 0x1, 0x800}, + {0x0, 0xdc, 0x0}, + {0x0, 0x1, 0x900}, + {0x0, 0x1, 0xa00}, + {0x0, 0x1, 0xffff}, + {0x1, 0x40, 0x1}, + {0x1, 0x1a, 0x61}, + {0x1, 0x6b, 0x5b}, + {0x0, 0x1, 0xe6}, + {0x1, 0x9, 0xc7}, + {0x0, 0x1, 0xf0}, + {0x1, 0x7, 0xd1}, + {0x0, 0x1, 0xf8}, + {0x1, 0x5, 0xd9}, + {0x0, 0x1, 0xfe}, + {0x1, 0x31, 0xdf}, + {0x0, 0x2, 0x111}, + {0x1, 0x14, 0x112}, + {0x0, 0x2, 0x127}, + {0x1, 0xa, 0x128}, + {0x0, 0x2, 0x133}, + {0x1, 0xb, 0x134}, + {0x0, 0x2, 0x140}, + {0x0, 0x2, 0x142}, + {0x1, 0x7, 0x143}, + {0x0, 0x2, 0x14b}, + {0x1, 0x6, 0x14c}, + {0x0, 0x2, 0x153}, + {0x1, 0x12, 0x154}, + {0x0, 0x2, 0x167}, + {0x1, 0x19, 0x168}, + {0x0, 0x1, 0x253}, + {0x0, 0x2, 0x183}, + {0x0, 0x2, 0x185}, + {0x0, 0x1, 0x254}, + {0x0, 0x2, 0x188}, + {0x1, 0x2, 0x256}, + {0x0, 0x2, 0x18c}, + {0x0, 0x1, 0x18d}, + {0x0, 0x1, 0x1dd}, + {0x0, 0x1, 0x259}, + {0x0, 0x1, 0x25b}, + {0x0, 0x2, 0x192}, + {0x0, 0x1, 0x260}, + {0x0, 0x1, 0x263}, + {0x0, 0x1, 0x195}, + {0x0, 0x1, 0x269}, + {0x0, 0x1, 0x268}, + {0x0, 0x2, 0x199}, + {0x1, 0x2, 0x19a}, + {0x0, 0x1, 0x26f}, + {0x0, 0x1, 0x272}, + {0x0, 0x1, 0x19e}, + {0x0, 0x1, 0x275}, + {0x1, 0x2, 0x1a0}, + {0x0, 0x2, 0x1a3}, + {0x0, 0x2, 0x1a5}, + {0x0, 0x1, 0x1a6}, + {0x0, 0x2, 0x1a8}, + {0x0, 0x1, 0x283}, + {0x1, 0x2, 0x1aa}, + {0x0, 0x2, 0x1ad}, + {0x0, 0x1, 0x288}, + {0x1, 0x2, 0x1af}, + {0x1, 0x2, 0x28a}, + {0x0, 0x2, 0x1b4}, + {0x0, 0x2, 0x1b6}, + {0x0, 0x1, 0x292}, + {0x0, 0x2, 0x1b9}, + {0x1, 0x2, 0x1ba}, + {0x0, 0x2, 0x1bd}, + {0x1, 0x6, 0x1be}, + {0x0, 0x3, 0x1c6}, + {0x0, 0x3, 0x1c9}, + {0x0, 0x3, 0x1cc}, + {0x1, 0x17, 0x1cd}, + {0x0, 0x2, 0x1e5}, + {0x1, 0xb, 0x1e6}, + {0x0, 0x3, 0x1f3}, + {0x1, 0xc, 0x1f4}, + {0x1, 0x91, 0x300}, + {0x1, 0x11, 0x3b1}, + {0x0, 0x1, 0x3a2}, + {0x1, 0x7, 0x3c3}, + {0x1, 0x38, 0x3aa}, + {0x0, 0x2, 0x3e3}, + {0x0, 0x2, 0x3e5}, + {0x0, 0x2, 0x3e7}, + {0x0, 0x2, 0x3e9}, + {0x0, 0x2, 0x3eb}, + {0x0, 0x2, 0x3ed}, + {0x0, 0x2, 0x3ef}, + {0x1, 0x12, 0x3f0}, + {0x0, 0x1, 0x452}, + {0x0, 0x1, 0x403}, + {0x1, 0x3, 0x454}, + {0x0, 0x1, 0x407}, + {0x1, 0x4, 0x458}, + {0x1, 0x3, 0x40c}, + {0x0, 0x1, 0x45f}, + {0x1, 0x9, 0x430}, + {0x0, 0x1, 0x419}, + {0x1, 0x16, 0x43a}, + {0x1, 0x30, 0x430}, + {0x0, 0x2, 0x461}, + {0x0, 0x2, 0x463}, + {0x0, 0x2, 0x465}, + {0x0, 0x2, 0x467}, + {0x0, 0x2, 0x469}, + {0x0, 0x2, 0x46b}, + {0x0, 0x2, 0x46d}, + {0x0, 0x2, 0x46f}, + {0x0, 0x2, 0x471}, + {0x0, 0x2, 0x473}, + {0x0, 0x2, 0x475}, + {0x1, 0x2, 0x476}, + {0x0, 0x2, 0x479}, + {0x0, 0x2, 0x47b}, + {0x0, 0x2, 0x47d}, + {0x0, 0x2, 0x47f}, + {0x0, 0x2, 0x481}, + {0x1, 0xe, 0x482}, + {0x0, 0x2, 0x491}, + {0x0, 0x2, 0x493}, + {0x0, 0x2, 0x495}, + {0x0, 0x2, 0x497}, + {0x0, 0x2, 0x499}, + {0x0, 0x2, 0x49b}, + {0x0, 0x2, 0x49d}, + {0x0, 0x2, 0x49f}, + {0x0, 0x2, 0x4a1}, + {0x0, 0x2, 0x4a3}, + {0x0, 0x2, 0x4a5}, + {0x0, 0x2, 0x4a7}, + {0x0, 0x2, 0x4a9}, + {0x0, 0x2, 0x4ab}, + {0x0, 0x2, 0x4ad}, + {0x0, 0x2, 0x4af}, + {0x0, 0x2, 0x4b1}, + {0x0, 0x2, 0x4b3}, + {0x0, 0x2, 0x4b5}, + {0x0, 0x2, 0x4b7}, + {0x0, 0x2, 0x4b9}, + {0x0, 0x2, 0x4bb}, + {0x0, 0x2, 0x4bd}, + {0x0, 0x2, 0x4bf}, + {0x1, 0x3, 0x4c0}, + {0x0, 0x2, 0x4c4}, + {0x1, 0x2, 0x4c5}, + {0x0, 0x2, 0x4c8}, + {0x1, 0x2, 0x4c9}, + {0x0, 0x2, 0x4cc}, + {0x1, 0x64, 0x4cd}, + {0x1, 0x26, 0x561}, + {0x1, 0xa9, 0x557}, + {0x1, 0xa0, 0x1000}, + {0x1, 0x26, 0x10d0}, + {0x1, 0x3a, 0x10c6}, + {0x1, 0xc, 0x2000}, + {0x0, 0x4, 0x0}, + {0x1, 0x1a, 0x2010}, + {0x0, 0x5, 0x0}, + {0x1, 0x3b, 0x202f}, + {0x0, 0x6, 0x0}, + {0x1, 0xf0, 0x2070}, + {0x1, 0x10, 0x2170}, + {0x1, 0x90, 0x2170}, + {0x1, 0xff, 0xfe00}, + {0x0, 0x1, 0x0}, + {0x1, 0x21, 0xff00}, + {0x1, 0x1a, 0xff41}, + {0x1, 0xc5, 0xff3b}, +}; +// Please update count if you add/remove entries but also please just let +// the compiler calculate it so you don't get it wrong. +//#define kLowerCaseTableNBlocks 182 +#define kLowerCaseTableNBlocks (sizeof(gLowerCaseTableCompressed)/sizeof(*gLowerCaseTableCompressed)) +// WARNING: The expanded size MUST be updated if you change the table and +// cannot be calculated at compile time. +#define kLowerCaseTableDataSize 5632 /* size of uncompressed structure in bytes */ + +unsigned short *gCompareTable; + +struct compressed_block gCompareTableCompressed[] = { + {0x2, 0x60, 0x0}, + {0x0, 0x1, 0x4180}, + {0x2, 0x1a, 0x4100}, + {0x2, 0x5, 0x7b00}, + {0x0, 0x1, 0x4108}, + {0x0, 0x1, 0x410c}, + {0x0, 0x1, 0x4310}, + {0x0, 0x1, 0x4502}, + {0x0, 0x1, 0x4e0a}, + {0x0, 0x1, 0x4f08}, + {0x0, 0x1, 0x5508}, + {0x0, 0x1, 0x4182}, + {0x0, 0x1, 0x4104}, + {0x0, 0x1, 0x4186}, + {0x0, 0x1, 0x4108}, + {0x0, 0x1, 0x410a}, + {0x0, 0x1, 0x410c}, + {0x0, 0x1, 0x4310}, + {0x0, 0x1, 0x4502}, + {0x0, 0x1, 0x4584}, + {0x0, 0x1, 0x4586}, + {0x0, 0x1, 0x4588}, + {0x0, 0x1, 0x4982}, + {0x0, 0x1, 0x4984}, + {0x0, 0x1, 0x4986}, + {0x0, 0x1, 0x4988}, + {0x0, 0x1, 0x4e0a}, + {0x0, 0x1, 0x4f82}, + {0x0, 0x1, 0x4f84}, + {0x0, 0x1, 0x4f86}, + {0x0, 0x1, 0x4f08}, + {0x0, 0x1, 0x4f0a}, + {0x0, 0x1, 0x5582}, + {0x0, 0x1, 0x5584}, + {0x0, 0x1, 0x5586}, + {0x0, 0x1, 0x5508}, + {0x2, 0x7, 0xa000}, + {0x0, 0x1, 0x5382}, + {0x2, 0x6, 0xa800}, + {0x0, 0x1, 0x4114}, + {0x0, 0x1, 0x4f0e}, + {0x2, 0xb, 0xb000}, + {0x0, 0x1, 0x4192}, + {0x0, 0x1, 0x4f92}, + {0x0, 0x1, 0xbd00}, + {0x0, 0x1, 0x4114}, + {0x0, 0x1, 0x4f0e}, + {0x2, 0x7, 0xc000}, + {0x0, 0x1, 0x2206}, + {0x0, 0x1, 0x2208}, + {0x0, 0x1, 0xc900}, + {0x0, 0x1, 0x2000}, + {0x0, 0x1, 0x4104}, + {0x0, 0x1, 0x410a}, + {0x0, 0x1, 0x4f0a}, + {0x0, 0x2, 0x4f14}, + {0x2, 0x2, 0xd000}, + {0x0, 0x1, 0x2202}, + {0x0, 0x1, 0x2204}, + {0x0, 0x1, 0x2702}, + {0x0, 0x1, 0x2704}, + {0x2, 0x2, 0xd600}, + {0x0, 0x1, 0x5988}, + {0x2, 0x27, 0xd900}, +}; +// Please update count if you add/remove entries but also please just let +// the compiler calculate it so you don't get it wrong. +//#define kCompareTableNBlocks 64 +#define kCompareTableNBlocks (sizeof(gCompareTableCompressed)/sizeof(*gCompareTableCompressed)) +// WARNING: The expanded size MUST be updated if you change the table and +// cannot be calculated at compile time. +#define kCompareTableDataSize 512 /* size of uncompressed structure in bytes */ + +#endif /* UNCOMPRESSED */ Index: trunk/i386/libsaio/ext2fs.c =================================================================== --- trunk/i386/libsaio/ext2fs.c (revision 0) +++ trunk/i386/libsaio/ext2fs.c (revision 1) @@ -0,0 +1,41 @@ +/* + * ext2fs.c + * + * + * Created by mackerintel on 1/26/09. + * Copyright 2009 __MyCompanyName__. All rights reserved. + * + */ + +#include "libsaio.h" +#include "sl.h" +#include "ext2fs.h" + +#define EX2ProbeSize 2048 + +BOOL EX2Probe (const void *buf) +{ + return (OSReadLittleInt16(buf+0x438,0)==0xEF53); +} +void EX2GetDescription(CICell ih, char *str, long strMaxLen) +{ + char * buf=malloc (EX2ProbeSize); + str[0]=0; + if (!buf) + return; + Seek(ih, 0); + Read(ih, (long)buf, EX2ProbeSize); + if (!EX2Probe (buf)) + { + free (buf); + return; + } + if (OSReadLittleInt32 (buf+0x44c,0)<1) + { + free (buf); + return; + } + str[strMaxLen]=0; + strncpy (str, buf+0x478, min (strMaxLen, 16)); + free (buf); +} \ No newline at end of file Index: trunk/i386/libsaio/vbe.c =================================================================== --- trunk/i386/libsaio/vbe.c (revision 0) +++ trunk/i386/libsaio/vbe.c (revision 1) @@ -0,0 +1,310 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Copyright 1993 NeXT, Inc. + * All rights reserved. + */ + +#include "libsaio.h" +#include "vbe.h" + +/* + * Various inline routines for video I/O + */ +static inline void +outi (int port, int index, int val) +{ + outw (port, (val << 8) | index); +} + +static inline void +outib (int port, int index, int val) +{ + outb (port, index); + outb (port + 1, val); +} + +static inline int +ini (int port, int index) +{ + outb (port, index); + return inb (port + 1); +} + +static inline void +rmwi (int port, int index, int clear, int set) +{ + outb (port, index); + outb (port + 1, (inb (port + 1) & ~clear) | set); +} + +/* + * Globals + */ +static biosBuf_t bb; + +int getVBEInfo( void * infoBlock ) +{ + bb.intno = 0x10; + bb.eax.rr = funcGetControllerInfo; + bb.es = SEG( infoBlock ); + bb.edi.rr = OFF( infoBlock ); + bios( &bb ); + return(bb.eax.r.h); +} + +int getVBEModeInfo( int mode, void * minfo_p ) +{ + bb.intno = 0x10; + bb.eax.rr = funcGetModeInfo; + bb.ecx.rr = mode; + bb.es = SEG(minfo_p); + bb.edi.rr = OFF(minfo_p); + bios(&bb); + return(bb.eax.r.h); +} + +int getVBEDACFormat(unsigned char *format) +{ + bb.intno = 0x10; + bb.eax.rr = funcGetSetPaletteFormat; + bb.ebx.r.l = subfuncGet; + bios(&bb); + *format = bb.ebx.r.h; + return(bb.eax.r.h); +} + +int setVBEDACFormat(unsigned char format) +{ + bb.intno = 0x10; + bb.eax.rr = funcGetSetPaletteFormat; + bb.ebx.r.l = subfuncSet; + bb.ebx.r.h = format; + bios(&bb); + return(bb.eax.r.h); +} + +/* + * Default GTF parameter values. + */ +#define kCellGranularity 8.0 // character cell granularity +#define kMinVSyncPlusBP 550.0 // min VSync + BP interval (us) +#define kMinFrontPorch 1.0 // minimum front porch in lines(V)/cells(H) +#define kVSyncLines 3.0 // width of VSync in lines +#define kHSyncWidth 8.0 // HSync as a percent of total line width +#define kC 30.0 // C = (C'-J) * (K/256) + J +#define kM 300.0 // M = K/256 * M' + +int Round(double f) +{ + return (int)(f + 0.5); +} + +/* + * from http://www.azillionmonkeys.com/qed/sqroot.html + */ + +double Sqrt( double y ) +{ + double x, z, tempf; + unsigned long *tfptr = ((unsigned long *)&tempf) + 1; + + tempf = y; + *tfptr = (0xbfcdd90a - *tfptr)>>1; /* estimate of 1/sqrt(y) */ + x = tempf; + z = y*0.5; /* hoist out the “/2” */ + x = (1.5*x) - (x*x)*(x*z); /* iteration formula */ + x = (1.5*x) - (x*x)*(x*z); + x = (1.5*x) - (x*x)*(x*z); + x = (1.5*x) - (x*x)*(x*z); + x = (1.5*x) - (x*x)*(x*z); + return x*y; +} + +int generateCRTCTiming( unsigned short width, + unsigned short height, + unsigned long paramValue, + int paramType, + VBECRTCInfoBlock * timing ) +{ + double h_period_est, h_freq, h_period, h_total_pixels, h_sync_pixels; + double h_active_pixels, h_ideal_duty_cycle, h_blank_pixels, pixel_freq = 0; + double v_sync_plus_bp = 0, v_total_lines = 0, v_field_rate_est, v_frame_rate = 0; + const double h_pixels = (double) width; + const double v_lines = (double) height; + + enum { + left_margin_pixels = 0, + right_margin_pixels = 0, + top_margin_lines = 0, + bot_margin_lines = 0, + interlace = 0 + }; + + // Total number of active pixels in image and both margins + h_active_pixels = h_pixels + left_margin_pixels + right_margin_pixels; + + if (paramType == kCRTCParamPixelClock) + { + // Pixel clock provided in MHz + pixel_freq = (double) paramValue / 1000000; + + // Ideal horizontal period from the blanking duty cycle equation + h_period = ((kC - 100) + (Sqrt(((100 - kC) * (100 - kC)) + (0.4 * kM * + (h_active_pixels + right_margin_pixels + left_margin_pixels) / + pixel_freq)))) / 2.0 / kM * 1000; + } + else /* kCRTCParamRefreshRate */ + { + double v_field_rate_in = (double) paramValue; + + // Estimate the horizontal period + h_period_est = ((1 / v_field_rate_in) - kMinVSyncPlusBP / 1000000) / + (v_lines + (2 * top_margin_lines) + kMinFrontPorch + interlace) * + 1000000; + + // Number of lines in Vsync + back porch + v_sync_plus_bp = Round(kMinVSyncPlusBP / h_period_est); + + // Total number of lines in Vetical field period + v_total_lines = v_lines + top_margin_lines + bot_margin_lines + + v_sync_plus_bp + interlace + kMinFrontPorch; + + // Estimate the vertical field frequency + v_field_rate_est = 1 / h_period_est / v_total_lines * 1000000; + + // Find the actual horizontal period + h_period = h_period_est / (v_field_rate_in / v_field_rate_est); + + // Find the vertical frame rate (no interlace) + v_frame_rate = 1 / h_period / v_total_lines * 1000000; + } + + // Ideal blanking duty cycle from the blanking duty cycle equation + h_ideal_duty_cycle = kC - (kM * h_period / 1000); + + // Number of pixels in the blanking time to the nearest double character cell + h_blank_pixels = Round(h_active_pixels * h_ideal_duty_cycle / + (100 - h_ideal_duty_cycle) / (2 * kCellGranularity)) * + (2 * kCellGranularity); + + // Total number of horizontal pixels + h_total_pixels = h_active_pixels + h_blank_pixels; + + if (paramType == kCRTCParamPixelClock) + { + // Horizontal frequency + h_freq = pixel_freq / h_total_pixels * 1000; + + // Number of lines in V sync + back porch + v_sync_plus_bp = Round(kMinVSyncPlusBP * h_freq / 1000); + + // Total number of lines in vertical field period + v_total_lines = v_lines + top_margin_lines + bot_margin_lines + + interlace + v_sync_plus_bp + kMinFrontPorch; + + // Vertical frame frequency + v_frame_rate = Round(h_freq / v_total_lines * 1000); + } + else + { + // Find pixel clock frequency + pixel_freq = Round(h_total_pixels / h_period); + } + + h_sync_pixels = Round(h_total_pixels * kHSyncWidth / 100 / kCellGranularity) * + kCellGranularity; + + timing->HTotal = h_total_pixels; + timing->HSyncStart = h_active_pixels + (h_blank_pixels / 2) - h_sync_pixels; + timing->HSyncEnd = timing->HSyncStart + h_sync_pixels; + timing->VTotal = v_total_lines; + timing->VSyncStart = v_total_lines - v_sync_plus_bp; + timing->VSyncEnd = timing->VSyncStart + kVSyncLines; + timing->Flags = kCRTCNegativeHorizontalSync; + timing->PixelClock = pixel_freq * 1000000; + timing->RefreshRate = v_frame_rate * 100; + + return 0; +} + +int setVBEMode(unsigned short mode, const VBECRTCInfoBlock * timing) +{ + bb.intno = 0x10; + bb.eax.rr = funcSetMode; + bb.ebx.rr = mode; + if (timing) { + bb.es = SEG(timing); + bb.edi.rr = OFF(timing); + } + bios(&bb); + return(bb.eax.r.h); +} + +int setVBEPalette(void *palette) +{ + bb.intno = 0x10; + bb.eax.rr = funcGetSetPaletteData; + bb.ebx.r.l = subfuncSet; + bb.ecx.rr = 256; + bb.edx.rr = 0; + bb.es = SEG(palette); + bb.edi.rr = OFF(palette); + bios(&bb); + return(bb.eax.r.h); +} + +int getVBEPalette(void *palette) +{ + bb.intno = 0x10; + bb.eax.rr = funcGetSetPaletteData; + bb.ebx.r.l = subfuncGet; + bb.ecx.rr = 256; + bb.edx.rr = 0; + bb.es = SEG(palette); + bb.edi.rr = OFF(palette); + bios(&bb); + return(bb.eax.r.h); +} + +int getVBECurrentMode(unsigned short *mode) +{ + bb.intno = 0x10; + bb.eax.rr = funcGetCurrentMode; + bios(&bb); + *mode = bb.ebx.rr; + return(bb.eax.r.h); +} + +int getVBEPixelClock(unsigned short mode, unsigned long * pixelClock) +{ + bb.intno = 0x10; + bb.eax.rr = funcGetSetPixelClock; + bb.ebx.r.l = 0; + bb.ecx.rx = *pixelClock; + bb.edx.rr = mode; + bios(&bb); + *pixelClock = bb.ecx.rx; + return(bb.eax.r.h); +} Index: trunk/i386/libsaio/bootstruct.h =================================================================== --- trunk/i386/libsaio/bootstruct.h (revision 0) +++ trunk/i386/libsaio/bootstruct.h (revision 1) @@ -0,0 +1,138 @@ +/* + * Copyright (c) 2002-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 2002-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +#ifndef __BOOTSTRUCT_H +#define __BOOTSTRUCT_H + +#include +#include "saio_types.h" +#include "bios.h" +#include "device_tree.h" + +/*! + Kernel boot args global also used by booter for its own data. + */ +extern boot_args *bootArgs; +extern Node *gMemoryMapNode; + +#define VGA_TEXT_MODE 0 + +/* + * Maximum number of boot drivers that can be loaded. + */ +#define NDRIVERS 500 + +#define CONFIG_SIZE (40 * 4096) + +/* + * Max size fo config data array, in bytes. + */ +#define IO_CONFIG_DATA_SIZE 163840 + +#define kMemoryMapCountMax 40 + +/* + * PCI bus information. + */ +typedef struct _PCI_bus_info_t { + union { + struct { + unsigned char configMethod1 :1; + unsigned char configMethod2 :1; + unsigned char :2; + unsigned char specialCycle1 :1; + unsigned char specialCycle2 :1; + } s; + unsigned char d; + } u_bus; + unsigned char maxBusNum; + unsigned char majorVersion; + unsigned char minorVersion; + unsigned char BIOSPresent; +} PCI_bus_info_t; + +typedef struct { + unsigned long address; // address where driver was loaded + unsigned long size; // number of bytes + unsigned long type; // driver type +} driver_config_t; + +/* + * INT15, E820h - Query System Address Map. + * + * Documented in ACPI Specification Rev 2.0, + * Chapter 15 (System Address Map Interfaces). + */ + +/* + * ACPI defined memory range types. + */ +enum { + kMemoryRangeUsable = 1, // RAM usable by the OS. + kMemoryRangeReserved = 2, // Reserved. (Do not use) + kMemoryRangeACPI = 3, // ACPI tables. Can be reclaimed. + kMemoryRangeNVS = 4, // ACPI NVS memory. (Do not use) + + /* Undefined types should be treated as kMemoryRangeReserved */ +}; + +/*! + PrivateBootInfo has fields used by the booter that used to be part of + KernelBootArgs_t *bootArgs. When the switch was made to EFI the structure + completely changed to boot_args *bootArgs. This (new to boot-132) structure + contains the fields the kernel no longer cares about but the booter still + uses internally. Some fields (e.g. the video information) remain interesting + to the kernel and are thus located in bootArgs although with different field names. + */ +typedef struct PrivateBootInfo { + int convmem; // conventional memory + int extmem; // extended memory +#if 0 + int numBootDrivers; // number of drivers loaded +#endif + char bootFile[128]; // kernel file name + + unsigned long memoryMapCount; + MemoryRange memoryMap[kMemoryMapCountMax]; + + PCI_bus_info_t pciInfo; + +#if 0 + driver_config_t driverConfig[NDRIVERS]; +#endif + char * configEnd; // pointer to end of config files + char config[CONFIG_SIZE]; + + config_file_t bootConfig; // boot.plist + config_file_t overrideConfig; // additional boot.plist which can override bootConfig keys + config_file_t themeDefault; // default theme.plist + config_file_t themeConfig; // theme.plist + config_file_t smbiosConfig; // smbios.plist + config_file_t helperConfig; // boot helper partition's boot.plist + config_file_t ramdiskConfig; // RAMDisk.plist +} PrivateBootInfo_t; + +extern PrivateBootInfo_t *bootInfo; + +#endif /* __BOOTSTRUCT_H */ Index: trunk/i386/libsaio/device_tree.c =================================================================== --- trunk/i386/libsaio/device_tree.c (revision 0) +++ trunk/i386/libsaio/device_tree.c (revision 1) @@ -0,0 +1,540 @@ +/* + * Copyright (c) 2005 Apple Computer, Inc. All Rights Reserved. + */ + +#if 1 +/* + + Structures for a Flattened Device Tree + */ + +#define kPropNameLength 32 + +typedef struct DeviceTreeNodeProperty { + char name[kPropNameLength]; // NUL terminated property name + unsigned long length; // Length (bytes) of folloing prop value + // unsigned long value[1]; // Variable length value of property + // Padded to a multiple of a longword? +} DeviceTreeNodeProperty; + +typedef struct OpaqueDTEntry { + unsigned long nProperties; // Number of props[] elements (0 => end) + unsigned long nChildren; // Number of children[] elements + // DeviceTreeNodeProperty props[];// array size == nProperties + // DeviceTreeNode children[]; // array size == nChildren +} DeviceTreeNode; + +typedef char DTPropertyNameBuf[32]; +/* Entry Name Definitions (Entry Names are C-Strings)*/ +enum { + kDTMaxEntryNameLength = 31 /* Max length of a C-String Entry Name (terminator not included) */ +}; + +/* length of DTEntryNameBuf = kDTMaxEntryNameLength +1*/ +typedef char DTEntryNameBuf[32]; +#endif + +#include "libsaio.h" +#include "device_tree.h" + +#if DEBUG +#define DPRINTF(args...) printf(args) +void +DT__PrintTree(Node *node); +#else +#define DPRINTF(args...) +#endif + + +#define RoundToLong(x) (((x) + 3) & ~3) + +static struct _DTSizeInfo { + uint32_t numNodes; + uint32_t numProperties; + uint32_t totalPropertySize; +} DTInfo; + +#define kAllocSize 4096 + +static Node *rootNode; + +static Node *freeNodes, *allocedNodes; +static Property *freeProperties, *allocedProperties; + +Property * +DT__AddProperty(Node *node, char *name, uint32_t length, void *value) +{ + Property *prop; + + DPRINTF("DT__AddProperty([Node '%s'], '%s', %d, 0x%x)\n", DT__GetName(node), name, length, value); + if (freeProperties == NULL) { + void *buf = malloc(kAllocSize); + int i; + + DPRINTF("Allocating more free properties\n"); + if (buf == 0) return 0; + bzero(buf, kAllocSize); + // Use the first property to record the allocated buffer + // for later freeing. + prop = (Property *)buf; + prop->next = allocedProperties; + allocedProperties = prop; + prop->value = buf; + prop++; + for (i=1; i<(kAllocSize / sizeof(Property)); i++) { + prop->next = freeProperties; + freeProperties = prop; + prop++; + } + } + prop = freeProperties; + freeProperties = prop->next; + + prop->name = name; + prop->length = length; + prop->value = value; + + // Always add to end of list + if (node->properties == 0) { + node->properties = prop; + } else { + node->last_prop->next = prop; + } + node->last_prop = prop; + prop->next = 0; + + DPRINTF("Done [0x%x]\n", prop); + + DTInfo.numProperties++; + DTInfo.totalPropertySize += RoundToLong(length); + + return prop; +} + +Node * +DT__AddChild(Node *parent, char *name) +{ + Node *node; + + if (freeNodes == NULL) { + void *buf = malloc(kAllocSize); + int i; + + DPRINTF("Allocating more free nodes\n"); + if (buf == 0) return 0; + bzero(buf, kAllocSize); + node = (Node *)buf; + // Use the first node to record the allocated buffer + // for later freeing. + node->next = allocedNodes; + allocedNodes = node; + node->children = (Node *)buf; + node++; + for (i=1; i<(kAllocSize / sizeof(Node)); i++) { + node->next = freeNodes; + freeNodes = node; + node++; + } + } + DPRINTF("DT__AddChild(0x%x, '%s')\n", parent, name); + node = freeNodes; + freeNodes = node->next; + DPRINTF("Got free node 0x%x\n", node); + DPRINTF("prop = 0x%x, children = 0x%x, next = 0x%x\n", node->properties, node->children, node->next); + + if (parent == NULL) { + rootNode = node; + node->next = 0; + } else { + node->next = parent->children; + parent->children = node; + } + DTInfo.numNodes++; + DT__AddProperty(node, "name", strlen(name) + 1, name); + return node; +} + +void +DT__FreeProperty(Property *prop) +{ + prop->next = freeProperties; + freeProperties = prop; +} +void +DT__FreeNode(Node *node) +{ + node->next = freeNodes; + freeNodes = node; +} + +void +DT__Initialize(void) +{ + DPRINTF("DT__Initialize\n"); + + freeNodes = 0; + allocedNodes = 0; + freeProperties = 0; + allocedProperties = 0; + + DTInfo.numNodes = 0; + DTInfo.numProperties = 0; + DTInfo.totalPropertySize = 0; + + rootNode = DT__AddChild(NULL, "/"); + DPRINTF("DT__Initialize done\n"); +} + +/* + * Free up memory used by in-memory representation + * of device tree. + */ +void +DT__Finalize(void) +{ + Node *node; + Property *prop; + + DPRINTF("DT__Finalize\n"); + for (prop = allocedProperties; prop != NULL; prop = prop->next) { + free(prop->value); + } + allocedProperties = NULL; + freeProperties = NULL; + + for (node = allocedNodes; node != NULL; node = node->next) { + free((void *)node->children); + } + allocedNodes = NULL; + freeNodes = NULL; + rootNode = NULL; + + // XXX leaks any created strings + + DTInfo.numNodes = 0; + DTInfo.numProperties = 0; + DTInfo.totalPropertySize = 0; +} + +static void * +FlattenNodes(Node *node, void *buffer) +{ + Property *prop; + DeviceTreeNode *flatNode; + DeviceTreeNodeProperty *flatProp; + int count; + + if (node == 0) return buffer; + + flatNode = (DeviceTreeNode *)buffer; + buffer += sizeof(DeviceTreeNode); + + for (count = 0, prop = node->properties; prop != 0; count++, prop = prop->next) { + flatProp = (DeviceTreeNodeProperty *)buffer; + strcpy(flatProp->name, prop->name); + flatProp->length = prop->length; + buffer += sizeof(DeviceTreeNodeProperty); + bcopy(prop->value, buffer, prop->length); + buffer += RoundToLong(prop->length); + } + flatNode->nProperties = count; + + for (count = 0, node = node->children; node != 0; count++, node = node->next) { + buffer = FlattenNodes(node, buffer); + } + flatNode->nChildren = count; + + return buffer; +} + +/* + * Flatten the in-memory representation of the device tree + * into a binary DT block. + * To get the buffer size needed, call with result = 0. + * To have a buffer allocated for you, call with *result = 0. + * To use your own buffer, call with *result = &buffer. + */ + +void +DT__FlattenDeviceTree(void **buffer_p, uint32_t *length) +{ + uint32_t totalSize; + void *buf; + + DPRINTF("DT__FlattenDeviceTree(0x%x, 0x%x)\n", buffer_p, length); +#if DEBUG + if (buffer_p) DT__PrintTree(rootNode); +#endif + + totalSize = DTInfo.numNodes * sizeof(DeviceTreeNode) + + DTInfo.numProperties * sizeof(DeviceTreeNodeProperty) + + DTInfo.totalPropertySize; + + DPRINTF("Total size 0x%x\n", totalSize); + if (buffer_p != 0) { + if (totalSize == 0) { + buf = 0; + } else { + if (*buffer_p == 0) { + buf = malloc(totalSize); + } else { + buf = *buffer_p; + } + bzero(buf, totalSize); + + FlattenNodes(rootNode, buf); + } + *buffer_p = buf; + } + if (length) + *length = totalSize; +} + +char * +DT__GetName(Node *node) +{ + Property *prop; + + //DPRINTF("DT__GetName(0x%x)\n", node); + //DPRINTF("Node properties = 0x%x\n", node->properties); + for (prop = node->properties; prop; prop = prop->next) { + //DPRINTF("Prop '%s'\n", prop->name); + if (strcmp(prop->name, "name") == 0) { + return prop->value; + } + } + //DPRINTF("DT__GetName returns 0\n"); + return "(null)"; +} + +Node * +DT__FindNode(char *path, bool createIfMissing) +{ + Node *node, *child; + DTPropertyNameBuf nameBuf; + char *bp; + int i; + + DPRINTF("DT__FindNode('%s', %d)\n", path, createIfMissing); + + // Start at root + node = rootNode; + DPRINTF("root = 0x%x\n", rootNode); + + while (node) { + // Skip leading slash + while (*path == '/') path++; + + for (i=0, bp = nameBuf; ++i < kDTMaxEntryNameLength && *path && *path != '/'; bp++, path++) *bp = *path; + *bp = '\0'; + + if (nameBuf[0] == '\0') { + // last path entry + break; + } + DPRINTF("Node '%s'\n", nameBuf); + + for (child = node->children; child != 0; child = child->next) { + DPRINTF("Child 0x%x\n", child); + if (strcmp(DT__GetName(child), nameBuf) == 0) { + break; + } + } + if (child == 0 && createIfMissing) { + DPRINTF("Creating node\n"); + char *str = malloc(strlen(nameBuf) + 1); + // XXX this will leak + strcpy(str, nameBuf); + + child = DT__AddChild(node, str); + } + node = child; + } + return node; +} + +#if DEBUG + +void +DT__PrintNode(Node *node, int level) +{ + char spaces[10], *cp = spaces; + Property *prop; + + if (level > 9) level = 9; + while (level--) *cp++ = ' '; + *cp = '\0'; + + printf("%s===Node===\n", spaces); + for (prop = node->properties; prop; prop = prop->next) { + char c = *((char *)prop->value); + if (prop->length < 64 && ( + strcmp(prop->name, "name") == 0 || + (c >= '0' && c <= '9') || + (c >= 'a' && c <= 'z') || + (c >= 'A' && c <= 'Z') || c == '_')) { + printf("%s Property '%s' [%d] = '%s'\n", spaces, prop->name, prop->length, prop->value); + } else { + printf("%s Property '%s' [%d] = (data)\n", spaces, prop->name, prop->length); + } + } + printf("%s==========\n", spaces); +} + +static void +_PrintTree(Node *node, int level) +{ + DT__PrintNode(node, level); + level++; + for (node = node->children; node; node = node->next) + _PrintTree(node, level); +} + +void +DT__PrintTree(Node *node) +{ + if (node == 0) node = rootNode; + _PrintTree(node, 0); +} + +void +DT__PrintFlattenedNode(DTEntry entry, int level) +{ + char spaces[10], *cp = spaces; + DTPropertyIterator propIter; + char *name; + void *prop; + int propSize; + + if (level > 9) level = 9; + while (level--) *cp++ = ' '; + *cp = '\0'; + + printf("%s===Entry %p===\n", spaces, entry); + if (kSuccess != DTCreatePropertyIterator(entry, &propIter)) { + printf("Couldn't create property iterator\n"); + return; + } + while( kSuccess == DTIterateProperties( propIter, &name)) { + if( kSuccess != DTGetProperty( entry, name, &prop, &propSize )) + continue; + printf("%s Property %s = %s\n", spaces, name, prop); + } + DTDisposePropertyIterator(propIter); + + printf("%s==========\n", spaces); +} + +static void +_PrintFlattenedTree(DTEntry entry, int level) +{ + DTEntryIterator entryIter; + + PrintFlattenedNode(entry, level); + + if (kSuccess != DTCreateEntryIterator(entry, &entryIter)) { + printf("Couldn't create entry iterator\n"); + return; + } + level++; + while (kSuccess == DTIterateEntries( entryIter, &entry )) { + _PrintFlattenedTree(entry, level); + } + DTDisposeEntryIterator(entryIter); +} + +void +DT__PrintFlattenedTree(DTEntry entry) +{ + _PrintFlattenedTree(entry, 0); +} + + +int +main(int argc, char **argv) +{ + DTEntry dtEntry; + DTPropertyIterator propIter; + DTEntryIterator entryIter; + void *prop; + int propSize; + char *name; + void *flatTree; + uint32_t flatSize; + + Node *node; + + node = AddChild(NULL, "device-tree"); + AddProperty(node, "potato", 4, "foo"); + AddProperty(node, "chemistry", 4, "bar"); + AddProperty(node, "physics", 4, "baz"); + + node = AddChild(node, "dev"); + AddProperty(node, "one", 4, "one"); + AddProperty(node, "two", 4, "two"); + AddProperty(node, "three", 6, "three"); + + node = AddChild(rootNode, "foo"); + AddProperty(node, "aaa", 4, "aab"); + AddProperty(node, "bbb", 4, "bbc"); + AddProperty(node, "cccc", 6, "ccccd"); + + node = FindNode("/this/is/a/test", 1); + AddProperty(node, "dddd", 12, "abcdefghijk"); + + printf("In-memory tree:\n\n"); + + PrintTree(rootNode); + + FlattenDeviceTree(&flatTree, &flatSize); + + printf("Flat tree = %p, size %d\n", flatTree, flatSize); + + dtEntry = (DTEntry)flatTree; + + printf("\n\nPrinting flat tree\n\n"); + + DTInit(dtEntry); + + PrintFlattenedTree((DTEntry)flatTree); +#if 0 + printf("=== Entry %p ===\n", dtEntry); + if (kSuccess != DTCreatePropertyIterator(dtEntry, &propIter)) { + printf("Couldn't create property iterator\n"); + return 1; + } + while( kSuccess == DTIterateProperties( propIter, &name)) { + if( kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize )) + continue; + printf(" Property %s = %s\n", name, prop); + } + DTDisposePropertyIterator(propIter); + printf("========\n"); + + if (kSuccess != DTCreateEntryIterator(dtEntry, &entryIter)) { + printf("Couldn't create entry iterator\n"); + return 1; + } + while (kSuccess == DTIterateEntries( entryIter, &dtEntry )) { + printf("=== Entry %p ===\n", dtEntry); + + if (kSuccess != DTCreatePropertyIterator(dtEntry, &propIter)) { + printf("Couldn't create property iterator\n"); + return 1; + } + while( kSuccess == DTIterateProperties( propIter, &name)) { + if( kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize )) + continue; + printf(" Property %s = %s\n", name, prop); + } + DTDisposePropertyIterator(propIter); + printf("========\n"); + } + DTDisposeEntryIterator(entryIter); +#endif + + return 0; +} + +#endif + Index: trunk/i386/libsaio/hfs.c =================================================================== --- trunk/i386/libsaio/hfs.c (revision 0) +++ trunk/i386/libsaio/hfs.c (revision 1) @@ -0,0 +1,1062 @@ +/* + * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * hfs.c - File System Module for HFS and HFS+. + * + * Copyright (c) 1999-2002 Apple Computer, Inc. + * + * DRI: Josh de Cesare + */ + +#include +#include + +#include "hfs.h" + +#define kBlockSize (0x200) + +#define kMDBBaseOffset (2 * kBlockSize) + +#define kBTreeCatalog (0) +#define kBTreeExtents (1) + +#ifdef __i386__ + +static CICell gCurrentIH; +static long long gAllocationOffset; +static long gIsHFSPlus; +static long gCaseSensitive; +static long gBlockSize; +static long gCacheBlockSize; +static char *gBTreeHeaderBuffer; +static BTHeaderRec *gBTHeaders[2]; +static char *gHFSMdbVib; +static HFSMasterDirectoryBlock *gHFSMDB; +static char *gHFSPlusHeader; +static HFSPlusVolumeHeader *gHFSPlus; +static char *gLinkTemp; +static long long gVolID; +static char *gTempStr; + +#else /* !__i386__ */ + +static CICell gCurrentIH; +static long long gAllocationOffset; +static long gIsHFSPlus; +static long gBlockSize; +static long gCaseSensitive; +static long gCacheBlockSize; +static char gBTreeHeaderBuffer[512]; +static BTHeaderRec *gBTHeaders[2]; +static char gHFSMdbVib[kBlockSize]; +static HFSMasterDirectoryBlock *gHFSMDB =(HFSMasterDirectoryBlock*)gHFSMdbVib; +static char gHFSPlusHeader[kBlockSize]; +static HFSPlusVolumeHeader *gHFSPlus =(HFSPlusVolumeHeader*)gHFSPlusHeader; +static char gLinkTemp[64]; +static long long gVolID; + +#endif /* !__i386__ */ + +static long ReadFile(void *file, uint64_t *length, void *base, uint64_t offset); +static long GetCatalogEntryInfo(void *entry, long *flags, long *time, + FinderInfo *finderInfo, long *infoValid); +static long ResolvePathToCatalogEntry(char *filePath, long *flags, + void *entry, long dirID, long *dirIndex); + +static long GetCatalogEntry(long *dirIndex, char **name, + long *flags, long *time, + FinderInfo *finderInfo, long *infoValid); +static long ReadCatalogEntry(char *fileName, long dirID, void *entry, + long *dirIndex); +static long ReadExtentsEntry(long fileID, long startBlock, void *entry); + +static long ReadBTreeEntry(long btree, void *key, char *entry, long *dirIndex); +static void GetBTreeRecord(long index, char *nodeBuffer, long nodeSize, + char **key, char **data); + +static long ReadExtent(char *extent, uint64_t extentSize, long extentFile, + uint64_t offset, uint64_t size, void *buffer, long cache); + +static long GetExtentStart(void *extents, long index); +static long GetExtentSize(void *extents, long index); + +static long CompareHFSCatalogKeys(void *key, void *testKey); +static long CompareHFSPlusCatalogKeys(void *key, void *testKey); +static long CompareHFSExtentsKeys(void *key, void *testKey); +static long CompareHFSPlusExtentsKeys(void *key, void *testKey); + +extern long FastRelString(u_int8_t *str1, u_int8_t *str2); +extern long BinaryUnicodeCompare(u_int16_t *uniStr1, u_int32_t len1, + u_int16_t *uniStr2, u_int32_t len2); + + +static void +SwapFinderInfo(FndrFileInfo *dst, FndrFileInfo *src) +{ + dst->fdType = SWAP_BE32(src->fdType); + dst->fdCreator = SWAP_BE32(src->fdCreator); + dst->fdFlags = SWAP_BE16(src->fdFlags); + // Don't bother with location +} + +void HFSFree(CICell ih) +{ + if(gCurrentIH == ih) + gCurrentIH = 0; + free(ih); +} + +BOOL +HFSProbe (const void *buf) +{ + const HFSMasterDirectoryBlock *mdb; + const HFSPlusVolumeHeader *header; + mdb=(const HFSMasterDirectoryBlock *)(((const char*)buf)+kMDBBaseOffset); + header=(const HFSPlusVolumeHeader *)(((const char*)buf)+kMDBBaseOffset); + + if ( SWAP_BE16(mdb->drSigWord) == kHFSSigWord ) + return TRUE; + if (SWAP_BE16(header->signature) != kHFSPlusSigWord && + SWAP_BE16(header->signature) != kHFSXSigWord) + return FALSE; + return TRUE; +} + +long HFSInitPartition(CICell ih) +{ + long extentSize, extentFile, nodeSize; + void *extent; + + if (ih == gCurrentIH) { +#ifdef __i386__ + CacheInit(ih, gCacheBlockSize); +#endif + return 0; + } + +#ifdef __i386__ + if (!gTempStr) gTempStr = (char *)malloc(4096); + if (!gLinkTemp) gLinkTemp = (char *)malloc(64); + if (!gBTreeHeaderBuffer) gBTreeHeaderBuffer = (char *)malloc(512); + if (!gHFSMdbVib) { + gHFSMdbVib = (char *)malloc(kBlockSize); + gHFSMDB = (HFSMasterDirectoryBlock *)gHFSMdbVib; + } + if (!gHFSPlusHeader) { + gHFSPlusHeader = (char *)malloc(kBlockSize); + gHFSPlus = (HFSPlusVolumeHeader *)gHFSPlusHeader; + } + if (!gTempStr || !gLinkTemp || !gBTreeHeaderBuffer || + !gHFSMdbVib || !gHFSPlusHeader) return -1; +#endif /* __i386__ */ + + gAllocationOffset = 0; + gIsHFSPlus = 0; + gCaseSensitive = 0; + gBTHeaders[0] = 0; + gBTHeaders[1] = 0; + + // Look for the HFS MDB + Seek(ih, kMDBBaseOffset); + Read(ih, (long)gHFSMdbVib, kBlockSize); + + if ( SWAP_BE16(gHFSMDB->drSigWord) == kHFSSigWord ) { + gAllocationOffset = SWAP_BE16(gHFSMDB->drAlBlSt) * kBlockSize; + + // See if it is HFSPlus + if (SWAP_BE16(gHFSMDB->drEmbedSigWord) != kHFSPlusSigWord) { + // Normal HFS; + gCacheBlockSize = gBlockSize = SWAP_BE32(gHFSMDB->drAlBlkSiz); + CacheInit(ih, gCacheBlockSize); + gCurrentIH = ih; + + // grab the 64 bit volume ID + bcopy(&gHFSMDB->drFndrInfo[6], &gVolID, 8); + + // Get the Catalog BTree node size. + extent = (HFSExtentDescriptor *)&gHFSMDB->drCTExtRec; + extentSize = SWAP_BE32(gHFSMDB->drCTFlSize); + extentFile = kHFSCatalogFileID; + ReadExtent(extent, extentSize, extentFile, 0, 256, + gBTreeHeaderBuffer + kBTreeCatalog * 256, 0); + + nodeSize = SWAP_BE16(((BTHeaderRec *)(gBTreeHeaderBuffer + kBTreeCatalog * 256 + + sizeof(BTNodeDescriptor)))->nodeSize); + + // If the BTree node size is larger than the block size, reset the cache. + if (nodeSize > gBlockSize) { + gCacheBlockSize = nodeSize; + CacheInit(ih, gCacheBlockSize); + } + + return 0; + } + + // Calculate the offset to the embeded HFSPlus volume. + gAllocationOffset += (long long)SWAP_BE16(gHFSMDB->drEmbedExtent.startBlock) * + SWAP_BE32(gHFSMDB->drAlBlkSiz); + } + + // Look for the HFSPlus Header + Seek(ih, gAllocationOffset + kMDBBaseOffset); + Read(ih, (long)gHFSPlusHeader, kBlockSize); + + // Not a HFS+ or HFSX volume. + if (SWAP_BE16(gHFSPlus->signature) != kHFSPlusSigWord && + SWAP_BE16(gHFSPlus->signature) != kHFSXSigWord) { + verbose("HFS signature was not present.\n"); + gCurrentIH = 0; + return -1; + } + + gIsHFSPlus = 1; + gCacheBlockSize = gBlockSize = SWAP_BE32(gHFSPlus->blockSize); + CacheInit(ih, gCacheBlockSize); + gCurrentIH = ih; + + ih->modTime = SWAP_BE32(gHFSPlus->modifyDate) - 2082844800; + + // grab the 64 bit volume ID + bcopy(&gHFSPlus->finderInfo[24], &gVolID, 8); + + // Get the Catalog BTree node size. + extent = &gHFSPlus->catalogFile.extents; + extentSize = SWAP_BE64(gHFSPlus->catalogFile.logicalSize); + extentFile = kHFSCatalogFileID; + + ReadExtent(extent, extentSize, extentFile, 0, 256, + gBTreeHeaderBuffer + kBTreeCatalog * 256, 0); + + nodeSize = SWAP_BE16(((BTHeaderRec *)(gBTreeHeaderBuffer + kBTreeCatalog * 256 + + sizeof(BTNodeDescriptor)))->nodeSize); + + // If the BTree node size is larger than the block size, reset the cache. + if (nodeSize > gBlockSize) { + gCacheBlockSize = nodeSize; + CacheInit(ih, gCacheBlockSize); + } + + return 0; +} + +long HFSLoadFile(CICell ih, char * filePath) +{ + return HFSReadFile(ih, filePath, (void *)gFSLoadAddress, 0, 0); +} + +long HFSReadFile(CICell ih, char * filePath, void *base, uint64_t offset, uint64_t length) +{ + char entry[512]; + long dirID, result, flags; + + if (HFSInitPartition(ih) == -1) return -1; + + dirID = kHFSRootFolderID; + // Skip a lead '\'. Start in the system folder if there are two. + if (filePath[0] == '/') { + if (filePath[1] == '/') { + if (gIsHFSPlus) dirID = SWAP_BE32(((long *)gHFSPlus->finderInfo)[5]); + else dirID = SWAP_BE32(gHFSMDB->drFndrInfo[5]); + if (dirID == 0) { + return -1; + } + filePath++; + } + filePath++; + } + + result = ResolvePathToCatalogEntry(filePath, &flags, entry, dirID, 0); + if ((result == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) { + return -1; + } + +#if UNUSED + // Not yet for Intel. System.config/Default.table will fail this check. + // Check file owner and permissions. + if (flags & (kOwnerNotRoot | kPermGroupWrite | kPermOtherWrite)) return -1; +#endif + + result = ReadFile(entry, &length, base, offset); + if (result == -1) { + return -1; + } + + verbose("Loaded HFS%s file: [%s] %d bytes from %x.\n", + (gIsHFSPlus ? "+" : ""), filePath, (uint32_t)length, ih); + + return length; +} + +long HFSGetDirEntry(CICell ih, char * dirPath, long * dirIndex, char ** name, + long * flags, long * time, + FinderInfo * finderInfo, long * infoValid) +{ + char entry[512]; + long dirID, dirFlags; + + if (HFSInitPartition(ih) == -1) return -1; + + if (*dirIndex == -1) return -1; + + dirID = kHFSRootFolderID; + // Skip a lead '\'. Start in the system folder if there are two. + if (dirPath[0] == '/') { + if (dirPath[1] == '/') { + if (gIsHFSPlus) dirID = SWAP_BE32(((long *)gHFSPlus->finderInfo)[5]); + else dirID = SWAP_BE32(gHFSMDB->drFndrInfo[5]); + if (dirID == 0) return -1; + dirPath++; + } + dirPath++; + } + + if (*dirIndex == 0) { + ResolvePathToCatalogEntry(dirPath, &dirFlags, entry, dirID, dirIndex); + if (*dirIndex == 0) *dirIndex = -1; + if ((dirFlags & kFileTypeMask) != kFileTypeUnknown) return -1; + } + + GetCatalogEntry(dirIndex, name, flags, time, finderInfo, infoValid); + if (*dirIndex == 0) *dirIndex = -1; + if ((*flags & kFileTypeMask) == kFileTypeUnknown) return -1; + + return 0; +} + +void +HFSGetDescription(CICell ih, char *str, long strMaxLen) +{ + + UInt16 nodeSize; + UInt32 firstLeafNode; + long dirIndex; + char *name; + long flags, time; + + if (HFSInitPartition(ih) == -1) { return; } + + /* Fill some crucial data structures by side effect. */ + dirIndex = 0; + HFSGetDirEntry(ih, "/", &dirIndex, &name, &flags, &time, 0, 0); + + /* Now we can loook up the volume name node. */ + nodeSize = SWAP_BE16(gBTHeaders[kBTreeCatalog]->nodeSize); + firstLeafNode = SWAP_BE32(gBTHeaders[kBTreeCatalog]->firstLeafNode); + + dirIndex = firstLeafNode * nodeSize; + + GetCatalogEntry(&dirIndex, &name, &flags, &time, 0, 0); + + strncpy(str, name, strMaxLen); + str[strMaxLen] = '\0'; +} + + +long +HFSGetFileBlock(CICell ih, char *filePath, unsigned long long *firstBlock) +{ + char entry[512]; + long dirID, result, flags; + void *extents; + HFSCatalogFile *hfsFile = (void *)entry; + HFSPlusCatalogFile *hfsPlusFile = (void *)entry; + + if (HFSInitPartition(ih) == -1) return -1; + + dirID = kHFSRootFolderID; + // Skip a lead '\'. Start in the system folder if there are two. + if (filePath[0] == '/') { + if (filePath[1] == '/') { + if (gIsHFSPlus) dirID = SWAP_BE32(((long *)gHFSPlus->finderInfo)[5]); + else dirID = SWAP_BE32(gHFSMDB->drFndrInfo[5]); + if (dirID == 0) { + return -1; + } + filePath++; + } + filePath++; + } + + result = ResolvePathToCatalogEntry(filePath, &flags, entry, dirID, 0); + if ((result == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) { + printf("HFS: Resolve path %s failed\n", filePath); + return -1; + } + + if (gIsHFSPlus) { + extents = &hfsPlusFile->dataFork.extents; + } else { + extents = &hfsFile->dataExtents; + } + +#if DEBUG + printf("extent start 0x%x\n", (unsigned long)GetExtentStart(extents, 0)); + printf("block size 0x%x\n", (unsigned long)gBlockSize); + printf("Allocation offset 0x%x\n", (unsigned long)gAllocationOffset); +#endif + *firstBlock = ((unsigned long long)GetExtentStart(extents, 0) * (unsigned long long) gBlockSize + gAllocationOffset) / 512ULL; + return 0; +} + +long HFSGetUUID(CICell ih, char *uuidStr) +{ + if (HFSInitPartition(ih) == -1) return -1; + if (gVolID == 0LL) return -1; + + return CreateUUIDString((uint8_t*)(&gVolID), sizeof(gVolID), uuidStr); +} + +// Private Functions + +static long ReadFile(void * file, uint64_t * length, void * base, uint64_t offset) +{ + void *extents; + long fileID; + uint64_t fileLength; + HFSCatalogFile *hfsFile = file; + HFSPlusCatalogFile *hfsPlusFile = file; + + if (gIsHFSPlus) { + fileID = SWAP_BE32(hfsPlusFile->fileID); + fileLength = (uint64_t)SWAP_BE64(hfsPlusFile->dataFork.logicalSize); + extents = &hfsPlusFile->dataFork.extents; + } else { + fileID = SWAP_BE32(hfsFile->fileID); + fileLength = SWAP_BE32(hfsFile->dataLogicalSize); + extents = &hfsFile->dataExtents; + } + + if (offset > fileLength) { + printf("Offset is too large.\n"); + return -1; + } + + if ((*length == 0) || ((offset + *length) > fileLength)) { + *length = fileLength - offset; + } + +/* if (*length > kLoadSize) { + printf("File is too large.\n"); + return -1; + }*/ + + *length = ReadExtent((char *)extents, fileLength, fileID, + offset, *length, (char *)base, 0); + + return 0; +} + +static long GetCatalogEntryInfo(void * entry, long * flags, long * time, + FinderInfo * finderInfo, long * infoValid) +{ + long tmpTime = 0; + long valid = 0; + + // Get information about the file. + + switch ( SWAP_BE16(*(short *)entry) ) + { + case kHFSFolderRecord : + *flags = kFileTypeDirectory; + tmpTime = SWAP_BE32(((HFSCatalogFolder *)entry)->modifyDate); + break; + + case kHFSPlusFolderRecord : + *flags = kFileTypeDirectory | + (SWAP_BE16(((HFSPlusCatalogFolder *)entry)->bsdInfo.fileMode) & kPermMask); + if (SWAP_BE32(((HFSPlusCatalogFolder *)entry)->bsdInfo.ownerID) != 0) + *flags |= kOwnerNotRoot; + tmpTime = SWAP_BE32(((HFSPlusCatalogFolder *)entry)->contentModDate); + break; + + case kHFSFileRecord : + *flags = kFileTypeFlat; + tmpTime = SWAP_BE32(((HFSCatalogFile *)entry)->modifyDate); + if (finderInfo) { + SwapFinderInfo((FndrFileInfo *)finderInfo, &((HFSCatalogFile *)entry)->userInfo); + valid = 1; + } + break; + + case kHFSPlusFileRecord : + *flags = kFileTypeFlat | + (SWAP_BE16(((HFSPlusCatalogFile *)entry)->bsdInfo.fileMode) & kPermMask); + if (SWAP_BE32(((HFSPlusCatalogFile *)entry)->bsdInfo.ownerID) != 0) + *flags |= kOwnerNotRoot; + tmpTime = SWAP_BE32(((HFSPlusCatalogFile *)entry)->contentModDate); + if (finderInfo) { + SwapFinderInfo((FndrFileInfo *)finderInfo, &((HFSPlusCatalogFile *)entry)->userInfo); + valid = 1; + } + break; + + case kHFSFileThreadRecord : + case kHFSPlusFileThreadRecord : + case kHFSFolderThreadRecord : + case kHFSPlusFolderThreadRecord : + *flags = kFileTypeUnknown; + tmpTime = 0; + break; + } + + if (time != 0) { + // Convert base time from 1904 to 1970. + *time = tmpTime - 2082844800; + } + if (infoValid) *infoValid = valid; + + return 0; +} + +static long ResolvePathToCatalogEntry(char * filePath, long * flags, + void * entry, long dirID, long * dirIndex) +{ + char *restPath; + long result, cnt, subFolderID = 0, tmpDirIndex; + HFSPlusCatalogFile *hfsPlusFile; + + // Copy the file name to gTempStr + cnt = 0; + while ((filePath[cnt] != '/') && (filePath[cnt] != '\0')) cnt++; + strlcpy(gTempStr, filePath, cnt+1); + + // Move restPath to the right place. + if (filePath[cnt] != '\0') cnt++; + restPath = filePath + cnt; + + // gTempStr is a name in the current Dir. + // restPath is the rest of the path if any. + + result = ReadCatalogEntry(gTempStr, dirID, entry, dirIndex); + if (result == -1) { + return -1; + } + + GetCatalogEntryInfo(entry, flags, 0, 0, 0); + + if ((*flags & kFileTypeMask) == kFileTypeDirectory) { + if (gIsHFSPlus) + subFolderID = SWAP_BE32(((HFSPlusCatalogFolder *)entry)->folderID); + else + subFolderID = SWAP_BE32(((HFSCatalogFolder *)entry)->folderID); + } + + if ((*flags & kFileTypeMask) == kFileTypeDirectory) + result = ResolvePathToCatalogEntry(restPath, flags, entry, + subFolderID, dirIndex); + + if (gIsHFSPlus && ((*flags & kFileTypeMask) == kFileTypeFlat)) { + hfsPlusFile = (HFSPlusCatalogFile *)entry; + if ((SWAP_BE32(hfsPlusFile->userInfo.fdType) == kHardLinkFileType) && + (SWAP_BE32(hfsPlusFile->userInfo.fdCreator) == kHFSPlusCreator)) { + sprintf(gLinkTemp, "%s/%s%ld", HFSPLUSMETADATAFOLDER, + HFS_INODE_PREFIX, SWAP_BE32(hfsPlusFile->bsdInfo.special.iNodeNum)); + result = ResolvePathToCatalogEntry(gLinkTemp, flags, entry, + kHFSRootFolderID, &tmpDirIndex); + } + } + + return result; +} + +static long GetCatalogEntry(long * dirIndex, char ** name, + long * flags, long * time, + FinderInfo * finderInfo, long * infoValid) +{ + long extentSize, nodeSize, curNode, index; + void *extent; + char *nodeBuf, *testKey, *entry; + BTNodeDescriptor *node; + + if (gIsHFSPlus) { + extent = &gHFSPlus->catalogFile.extents; + extentSize = SWAP_BE64(gHFSPlus->catalogFile.logicalSize); + } else { + extent = (HFSExtentDescriptor *)&gHFSMDB->drCTExtRec; + extentSize = SWAP_BE32(gHFSMDB->drCTFlSize); + } + + nodeSize = SWAP_BE16(gBTHeaders[kBTreeCatalog]->nodeSize); + nodeBuf = (char *)malloc(nodeSize); + node = (BTNodeDescriptor *)nodeBuf; + + index = *dirIndex % nodeSize; + curNode = *dirIndex / nodeSize; + + // Read the BTree node and get the record for index. + ReadExtent(extent, extentSize, kHFSCatalogFileID, + curNode * nodeSize, nodeSize, nodeBuf, 1); + GetBTreeRecord(index, nodeBuf, nodeSize, &testKey, &entry); + + GetCatalogEntryInfo(entry, flags, time, finderInfo, infoValid); + + // Get the file name. + if (gIsHFSPlus) { + utf_encodestr(((HFSPlusCatalogKey *)testKey)->nodeName.unicode, + SWAP_BE16(((HFSPlusCatalogKey *)testKey)->nodeName.length), + (u_int8_t *)gTempStr, 256, OSBigEndian); + } else { + strncpy(gTempStr, + (const char *)&((HFSCatalogKey *)testKey)->nodeName[1], + ((HFSCatalogKey *)testKey)->nodeName[0]); + gTempStr[((HFSCatalogKey *)testKey)->nodeName[0]] = '\0'; + } + *name = gTempStr; + + // Update dirIndex. + index++; + if (index == SWAP_BE16(node->numRecords)) { + index = 0; + curNode = SWAP_BE32(node->fLink); + } + *dirIndex = curNode * nodeSize + index; + + free(nodeBuf); + + return 0; +} + +static long ReadCatalogEntry(char * fileName, long dirID, + void * entry, long * dirIndex) +{ + long length; + char key[sizeof(HFSPlusCatalogKey)]; + HFSCatalogKey *hfsKey = (HFSCatalogKey *)key; + HFSPlusCatalogKey *hfsPlusKey = (HFSPlusCatalogKey *)key; + + // Make the catalog key. + if ( gIsHFSPlus ) + { + hfsPlusKey->parentID = SWAP_BE32(dirID); + length = strlen(fileName); + if (length > 255) length = 255; + utf_decodestr((u_int8_t *)fileName, hfsPlusKey->nodeName.unicode, + &(hfsPlusKey->nodeName.length), 512, OSBigEndian); + } else { + hfsKey->parentID = SWAP_BE32(dirID); + length = strlen(fileName); + if (length > 31) length = 31; + hfsKey->nodeName[0] = length; + strncpy((char *)(hfsKey->nodeName + 1), fileName, length); + } + + return ReadBTreeEntry(kBTreeCatalog, &key, entry, dirIndex); +} + +static long ReadExtentsEntry(long fileID, long startBlock, void * entry) +{ + char key[sizeof(HFSPlusExtentKey)]; + HFSExtentKey *hfsKey = (HFSExtentKey *)key; + HFSPlusExtentKey *hfsPlusKey = (HFSPlusExtentKey *)key; + + // Make the extents key. + if (gIsHFSPlus) { + hfsPlusKey->forkType = 0; + hfsPlusKey->fileID = SWAP_BE32(fileID); + hfsPlusKey->startBlock = SWAP_BE32(startBlock); + } else { + hfsKey->forkType = 0; + hfsKey->fileID = SWAP_BE32(fileID); + hfsKey->startBlock = SWAP_BE16(startBlock); + } + + return ReadBTreeEntry(kBTreeExtents, &key, entry, 0); +} + +static long ReadBTreeEntry(long btree, void * key, char * entry, long * dirIndex) +{ + long extentSize; + void *extent; + short extentFile; + char *nodeBuf; + BTNodeDescriptor *node; + long nodeSize, result = 0, entrySize = 0; + long curNode, index = 0, lowerBound, upperBound; + char *testKey, *recordData; + + // Figure out which tree is being looked at. + if (btree == kBTreeCatalog) { + if (gIsHFSPlus) { + extent = &gHFSPlus->catalogFile.extents; + extentSize = SWAP_BE64(gHFSPlus->catalogFile.logicalSize); + } else { + extent = (HFSExtentDescriptor *)&gHFSMDB->drCTExtRec; + extentSize = SWAP_BE32(gHFSMDB->drCTFlSize); + } + extentFile = kHFSCatalogFileID; + } else { + if (gIsHFSPlus) { + extent = &gHFSPlus->extentsFile.extents; + extentSize = SWAP_BE64(gHFSPlus->extentsFile.logicalSize); + } else { + extent = (HFSExtentDescriptor *)&gHFSMDB->drXTExtRec; + extentSize = SWAP_BE32(gHFSMDB->drXTFlSize); + } + extentFile = kHFSExtentsFileID; + } + + // Read the BTree Header if needed. + if (gBTHeaders[btree] == 0) { + ReadExtent(extent, extentSize, extentFile, 0, 256, + gBTreeHeaderBuffer + btree * 256, 0); + gBTHeaders[btree] = (BTHeaderRec *)(gBTreeHeaderBuffer + btree * 256 + + sizeof(BTNodeDescriptor)); + if ((gIsHFSPlus && btree == kBTreeCatalog) && + (gBTHeaders[btree]->keyCompareType == kHFSBinaryCompare)) { + gCaseSensitive = 1; + } + } + + curNode = SWAP_BE32(gBTHeaders[btree]->rootNode); + nodeSize = SWAP_BE16(gBTHeaders[btree]->nodeSize); + nodeBuf = (char *)malloc(nodeSize); + node = (BTNodeDescriptor *)nodeBuf; + + while (1) { + // Read the current node. + ReadExtent(extent, extentSize, extentFile, + curNode * nodeSize, nodeSize, nodeBuf, 1); + + // Find the matching key. + lowerBound = 0; + upperBound = SWAP_BE16(node->numRecords) - 1; + while (lowerBound <= upperBound) { + index = (lowerBound + upperBound) / 2; + + GetBTreeRecord(index, nodeBuf, nodeSize, &testKey, &recordData); + + if (gIsHFSPlus) { + if (btree == kBTreeCatalog) { + result = CompareHFSPlusCatalogKeys(key, testKey); + } else { + result = CompareHFSPlusExtentsKeys(key, testKey); + } + } else { + if (btree == kBTreeCatalog) { + result = CompareHFSCatalogKeys(key, testKey); + } else { + result = CompareHFSExtentsKeys(key, testKey); + } + } + + if (result < 0) upperBound = index - 1; // search < trial + else if (result > 0) lowerBound = index + 1; // search > trial + else break; // search = trial + } + + if (result < 0) { + index = upperBound; + GetBTreeRecord(index, nodeBuf, nodeSize, &testKey, &recordData); + } + + // Found the closest key... Recurse on it if this is an index node. + if (node->kind == kBTIndexNode) { + curNode = SWAP_BE32( *((long *)recordData) ); + } else break; + } + + // Return error if the file was not found. + if (result != 0) { free(nodeBuf); return -1; } + + if (btree == kBTreeCatalog) { + switch (SWAP_BE16(*(short *)recordData)) { + case kHFSFolderRecord : entrySize = 70; break; + case kHFSFileRecord : entrySize = 102; break; + case kHFSFolderThreadRecord : entrySize = 46; break; + case kHFSFileThreadRecord : entrySize = 46; break; + case kHFSPlusFolderRecord : entrySize = 88; break; + case kHFSPlusFileRecord : entrySize = 248; break; + case kHFSPlusFolderThreadRecord : entrySize = 264; break; + case kHFSPlusFileThreadRecord : entrySize = 264; break; + } + } else { + if (gIsHFSPlus) entrySize = sizeof(HFSPlusExtentRecord); + else entrySize = sizeof(HFSExtentRecord); + } + + bcopy(recordData, entry, entrySize); + + // Update dirIndex. + if (dirIndex != 0) { + index++; + if (index == SWAP_BE16(node->numRecords)) { + index = 0; + curNode = SWAP_BE32(node->fLink); + } + *dirIndex = curNode * nodeSize + index; + } + + free(nodeBuf); + + return 0; +} + +static void GetBTreeRecord(long index, char * nodeBuffer, long nodeSize, + char ** key, char ** data) +{ + long keySize; + long recordOffset; + + recordOffset = SWAP_BE16(*((short *)(nodeBuffer + (nodeSize - 2 * index - 2)))); + *key = nodeBuffer + recordOffset; + if (gIsHFSPlus) { + keySize = SWAP_BE16(*(short *)*key); + *data = *key + 2 + keySize; + } else { + keySize = **key; + *data = *key + 2 + keySize - (keySize & 1); + } +} + +static long ReadExtent(char * extent, uint64_t extentSize, + long extentFile, uint64_t offset, uint64_t size, + void * buffer, long cache) +{ + uint64_t lastOffset; + long long blockNumber, countedBlocks = 0; + long long nextExtent = 0, sizeRead = 0, readSize; + long long nextExtentBlock, currentExtentBlock = 0; + long long readOffset; + long long extentDensity, sizeofExtent, currentExtentSize; + char *currentExtent, *extentBuffer = 0, *bufferPos = buffer; + + if (offset >= extentSize) return 0; + + if (gIsHFSPlus) { + extentDensity = kHFSPlusExtentDensity; + sizeofExtent = sizeof(HFSPlusExtentDescriptor); + } else { + extentDensity = kHFSExtentDensity; + sizeofExtent = sizeof(HFSExtentDescriptor); + } + + lastOffset = offset + size; + while (offset < lastOffset) { + blockNumber = offset / gBlockSize; + + // Find the extent for the offset. + for (; ; nextExtent++) { + if (nextExtent < extentDensity) { + if ((countedBlocks+GetExtentSize(extent, nextExtent)-1)= blockNumber) { + currentExtent = extentBuffer + sizeofExtent * (nextExtent % extentDensity); + break; + } + + countedBlocks += currentExtentSize; + } + + readOffset = ((blockNumber - countedBlocks) * gBlockSize) + + (offset % gBlockSize); + + readSize = GetExtentSize(currentExtent, 0) * gBlockSize - readOffset; + if (readSize > (size - sizeRead)) readSize = size - sizeRead; + + readOffset += (long long)GetExtentStart(currentExtent, 0) * gBlockSize; + + CacheRead(gCurrentIH, bufferPos, gAllocationOffset + readOffset, + readSize, cache); + + sizeRead += readSize; + offset += readSize; + bufferPos += readSize; + } + + if (extentBuffer) free(extentBuffer); + + return sizeRead; +} + +static long GetExtentStart(void * extents, long index) +{ + long start; + HFSExtentDescriptor *hfsExtents = extents; + HFSPlusExtentDescriptor *hfsPlusExtents = extents; + + if (gIsHFSPlus) start = SWAP_BE32(hfsPlusExtents[index].startBlock); + else start = SWAP_BE16(hfsExtents[index].startBlock); + + return start; +} + +static long GetExtentSize(void * extents, long index) +{ + long size; + HFSExtentDescriptor *hfsExtents = extents; + HFSPlusExtentDescriptor *hfsPlusExtents = extents; + + if (gIsHFSPlus) size = SWAP_BE32(hfsPlusExtents[index].blockCount); + else size = SWAP_BE16(hfsExtents[index].blockCount); + + return size; +} + +static long CompareHFSCatalogKeys(void * key, void * testKey) +{ + HFSCatalogKey *searchKey, *trialKey; + long result, searchParentID, trialParentID; + + searchKey = key; + trialKey = testKey; + + searchParentID = SWAP_BE32(searchKey->parentID); + trialParentID = SWAP_BE32(trialKey->parentID); + + // parent dirID is unsigned + if (searchParentID > trialParentID) result = 1; + else if (searchParentID < trialParentID) result = -1; + else { + // parent dirID's are equal, compare names + result = FastRelString(searchKey->nodeName, trialKey->nodeName); + } + + return result; +} + +static long CompareHFSPlusCatalogKeys(void * key, void * testKey) +{ + HFSPlusCatalogKey *searchKey, *trialKey; + long result, searchParentID, trialParentID; + + searchKey = key; + trialKey = testKey; + + searchParentID = SWAP_BE32(searchKey->parentID); + trialParentID = SWAP_BE32(trialKey->parentID); + + // parent dirID is unsigned + if (searchParentID > trialParentID) result = 1; + else if (searchParentID < trialParentID) result = -1; + else { + // parent dirID's are equal, compare names + if ((searchKey->nodeName.length == 0) || (trialKey->nodeName.length == 0)) + result = searchKey->nodeName.length - trialKey->nodeName.length; + else + if (gCaseSensitive) { + result = BinaryUnicodeCompare(&searchKey->nodeName.unicode[0], + SWAP_BE16(searchKey->nodeName.length), + &trialKey->nodeName.unicode[0], + SWAP_BE16(trialKey->nodeName.length)); + } else { + result = FastUnicodeCompare(&searchKey->nodeName.unicode[0], + SWAP_BE16(searchKey->nodeName.length), + &trialKey->nodeName.unicode[0], + SWAP_BE16(trialKey->nodeName.length), OSBigEndian); + } + } + + return result; +} + +static long CompareHFSExtentsKeys(void * key, void * testKey) +{ + HFSExtentKey *searchKey, *trialKey; + long result; + + searchKey = key; + trialKey = testKey; + + // assume searchKey < trialKey + result = -1; + + if (searchKey->fileID == trialKey->fileID) { + // FileNum's are equal; compare fork types + if (searchKey->forkType == trialKey->forkType) { + // Fork types are equal; compare allocation block number + if (searchKey->startBlock == trialKey->startBlock) { + // Everything is equal + result = 0; + } else { + // Allocation block numbers differ; determine sign + if (SWAP_BE16(searchKey->startBlock) > SWAP_BE16(trialKey->startBlock)) + result = 1; + } + } else { + // Fork types differ; determine sign + if (searchKey->forkType > trialKey->forkType) result = 1; + } + } else { + // FileNums differ; determine sign + if (SWAP_BE32(searchKey->fileID) > SWAP_BE32(trialKey->fileID)) + result = 1; + } + + return result; +} + +static long CompareHFSPlusExtentsKeys(void * key, void * testKey) +{ + HFSPlusExtentKey *searchKey, *trialKey; + long result; + + searchKey = key; + trialKey = testKey; + + // assume searchKey < trialKey + result = -1; + + if (searchKey->fileID == trialKey->fileID) { + // FileNum's are equal; compare fork types + if (searchKey->forkType == trialKey->forkType) { + // Fork types are equal; compare allocation block number + if (searchKey->startBlock == trialKey->startBlock) { + // Everything is equal + result = 0; + } else { + // Allocation block numbers differ; determine sign + if (SWAP_BE32(searchKey->startBlock) > SWAP_BE32(trialKey->startBlock)) + result = 1; + } + } else { + // Fork types differ; determine sign + if (searchKey->forkType > trialKey->forkType) result = 1; + } + } else { + // FileNums differ; determine sign + if (SWAP_BE32(searchKey->fileID) > SWAP_BE32(trialKey->fileID)) + result = 1; + } + + return result; +} + Index: trunk/i386/libsaio/ext2fs.h =================================================================== --- trunk/i386/libsaio/ext2fs.h (revision 0) +++ trunk/i386/libsaio/ext2fs.h (revision 1) @@ -0,0 +1,11 @@ +/* + * ext2fs.h + * + * + * Created by mackerintel on 1/26/09. + * Copyright 2009 __MyCompanyName__. All rights reserved. + * + */ + +extern BOOL EX2Probe (const void *buf); +extern void EX2GetDescription(CICell ih, char *str, long strMaxLen); Index: trunk/i386/libsaio/vbe.h =================================================================== --- trunk/i386/libsaio/vbe.h (revision 0) +++ trunk/i386/libsaio/vbe.h (revision 1) @@ -0,0 +1,286 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +// Copyright 1997 by Apple Computer, Inc., all rights reserved. +/* Copyright 1996-1997 NeXT Software, Inc. + * + * vesa.h - mode info obtained via int10 + * + * Revision History + * ---------------- + * 30 Jul 1996 Doug Mitchell at NeXT + * Created. + */ + +#ifndef __LIBSAIO_VBE_H +#define __LIBSAIO_VBE_H + +#define MIN_VESA_VERSION 0x200 + +#define SEG(address) \ + ((unsigned short)(((unsigned long)address & 0xffff0000) >> 4)) + +#define OFF(address) \ + ((unsigned short)((unsigned long)address & 0x0000ffff)) + +#define VBEMakeUInt32(x) \ + (((unsigned long)x##_high << 24) | \ + ((unsigned long)x##_2 << 16) | \ + ((unsigned long)x##_1 << 8) | \ + (unsigned long)x##_low) + +#define VBEDecodeFP(t, fp) \ + ((t)(((fp ## _low) | ((fp ## _1 ) << 8)) + \ + (((fp ## _2) << 4) | ((fp ## _high ) << 12)))) + +/* + * Functions + */ +enum { + funcGetControllerInfo = 0x4F00, + funcGetModeInfo = 0x4F01, + funcSetMode = 0x4F02, + funcGetCurrentMode = 0x4F03, + funcSaveRestoreState = 0x4F04, + funcWindowControl = 0x4F05, + funcGetSetScanLineLength = 0x4F06, + funcGetSetDisplayStart = 0x4F07, + funcGetSetPaletteFormat = 0x4F08, + funcGetSetPaletteData = 0x4F09, + funcGetProtModeInterdace = 0x4F0A, + funcGetSetPixelClock = 0x4F0B +}; + +enum { + subfuncSet = 0x00, + subfuncGet = 0x01, + subfuncSetSecondary = 0x02, + subfuncGetSecondary = 0x03 +}; + +/* + * errors. + */ +enum { + errSuccess = 0, + errFuncFailed = 1, + errFuncNotSupported = 2, + errFuncInvalid = 3 +}; + +/* + * Per-controller info, returned in function 4f00. + */ +typedef struct { + unsigned char VESASignature[4]; + unsigned short VESAVersion; + /* + * Avoid packing problem... + */ + unsigned char OEMStringPtr_low; + unsigned char OEMStringPtr_1; + unsigned char OEMStringPtr_2; + unsigned char OEMStringPtr_high; + unsigned char Capabilities_low; + unsigned char Capabilities_1; + unsigned char Capabilities_2; + unsigned char Capabilities_high; + unsigned char VideoModePtr_low; + unsigned char VideoModePtr_1; + unsigned char VideoModePtr_2; + unsigned char VideoModePtr_high; + unsigned short TotalMemory; + unsigned char Reserved[236]; + unsigned char OEMData[256]; +} VBEInfoBlock; + +/* + * Capabilites + */ +enum { + capDACWidthIsSwitchableBit = (1 << 0), /* 1 = yes; 0 = no */ + capControllerIsNotVGACompatableBit = (1 << 1), /* 1 = no; 0 = yes */ + capOldRAMDAC = (1 << 2) /* 1 = yes; 0 = no */ +}; + +/* + * Per-mode info, returned in function 4f02. + */ +typedef struct { + unsigned short ModeAttributes; + unsigned char WinAAttributes; + unsigned char WinBAttributes; + unsigned short WinGranularity; + unsigned short WinSize; + unsigned short WinASegment; + unsigned short WinABegment; + void * WinFuncPtr; + unsigned short BytesPerScanline; + unsigned short XResolution; + unsigned short YResolution; + unsigned char XCharSize; + unsigned char YCharSize; + unsigned char NumberOfPlanes; + unsigned char BitsPerPixel; + unsigned char NumberOfBanks; + unsigned char MemoryModel; + unsigned char BankSize; + unsigned char NumberOfImagePages; + unsigned char Reserved; + unsigned char RedMaskSize; + unsigned char RedFieldPosition; + unsigned char GreenMaskSize; + unsigned char GreenFieldPosition; + unsigned char BlueMaskSize; + unsigned char BlueFieldPosition; + unsigned char RsvdMaskSize; + unsigned char RsvdFieldPosition; + unsigned char DirectColorModeInfo; + unsigned char PhysBasePtr_low; + unsigned char PhysBasePtr_1; + unsigned char PhysBasePtr_2; + unsigned char PhysBasePtr_high; + void * OffScreenMemOffset; + unsigned short OffScreenMemSize; + unsigned char Reserved1[206]; +} VBEModeInfoBlock; + +/* + * ModeAttributes bits + */ +enum { + maModeIsSupportedBit = (1 << 0), /* mode is supported */ + maExtendedInfoAvailableBit = (1 << 1), /* extended info available */ + maOutputFuncSupportedBit = (1 << 2), /* output functions supported */ + maColorModeBit = (1 << 3), /* 1 = color; 0 = mono */ + maGraphicsModeBit = (1 << 4), /* 1 = graphics; 0 = text */ + maModeIsNotVGACompatableBit = (1 << 5), /* 1 = not compat; 0 = compat */ + maVGAMemoryModeNotAvailBit = (1 << 6), /* 1 = not avail; 0 = avail */ + maLinearFrameBufferAvailBit = (1 << 7) /* 1 = avail; 0 = not avail */ +}; + +/* + * Modes + */ +enum { + mode640x400x256 = 0x100, + mode640x480x256 = 0x101, + mode800x600x16 = 0x102, + mode800x600x256 = 0x103, + mode1024x768x16 = 0x104, + mode1024x768x256 = 0x105, + mode1280x1024x16 = 0x106, + mode1280x1024x256 = 0x107, + mode80Cx60R = 0x108, + mode132Cx25R = 0x109, + mode132Cx43R = 0x10A, + mode132Cx50R = 0x10B, + mode132Cx60R = 0x10C, + mode320x200x555 = 0x10D, + mode320x200x565 = 0x10E, + mode320x200x888 = 0x10F, + mode640x480x555 = 0x110, + mode640x480x565 = 0x111, + mode640x480x888 = 0x112, + mode800x600x555 = 0x113, + mode800x600x565 = 0x114, + mode800x600x888 = 0x115, + mode1024x768x555 = 0x116, + mode1024x768x565 = 0x117, + mode1024x768x888 = 0x118, + mode1280x1024x555 = 0x119, + mode1280x1024x565 = 0x11A, + mode1280x1024x888 = 0x11B, + modeSpecial = 0x81FF, + modeEndOfList = 0xFFFF +}; + +/* + * Get/Set VBE Mode parameters + */ +enum { + kCustomRefreshRateBit = (1 << 11), + kLinearFrameBufferBit = (1 << 14), + kPreserveMemoryBit = (1 << 15) +}; + +/* + * CRTC information block passed to function 4F02 + * to override default refresh rate. + */ +#pragma pack(1) + +typedef struct { + unsigned short HTotal; + unsigned short HSyncStart; + unsigned short HSyncEnd; + unsigned short VTotal; + unsigned short VSyncStart; + unsigned short VSyncEnd; + unsigned char Flags; + unsigned long PixelClock; /* in Hz */ + unsigned short RefreshRate; /* units of 0.01 Hz */ + unsigned char Reserved[40]; +} VBECRTCInfoBlock; + +#pragma pack() + +/* + * Defined flags for 'Flags' field in VBECRTCInfoBlock. + */ +enum { + kCRTCDoubleScannedMode = (1 << 0), + kCRTCInterlacedMode = (1 << 1), + kCRTCNegativeHorizontalSync = (1 << 2), + kCRTCNegativeVerticalSync = (1 << 3) +}; + +/* + * The type of paramter passed to generateCRTCTimings(). + */ +enum { + kCRTCParamRefreshRate, + kCRTCParamPixelClock +}; + +/* + * Palette + */ +typedef unsigned long VBEPalette[256]; + +extern int getVBEInfo(void *vinfo_p); +extern int getVBEModeInfo(int mode, void *minfo_p); +extern int getVBEDACFormat(unsigned char *format); +extern int setVBEDACFormat(unsigned char format); +extern int setVBEPalette(void *palette); +extern int getVBEPalette(void *palette); +extern int setVBEMode(unsigned short mode, const VBECRTCInfoBlock *timing); +extern int getVBECurrentMode(unsigned short *mode); +extern int getVBEPixelClock(unsigned short mode, unsigned long *pixelClock); +extern int generateCRTCTiming(unsigned short width, + unsigned short height, + unsigned long paramValue, + int paramType, + VBECRTCInfoBlock * timing); + +#endif /* !__LIBSAIO_VBE_H */ Index: trunk/i386/libsaio/device_tree.h =================================================================== --- trunk/i386/libsaio/device_tree.h (revision 0) +++ trunk/i386/libsaio/device_tree.h (revision 1) @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2005 Apple Computer, Inc. All Rights Reserved. + */ + +#ifndef __DEVICE_TREE_H +#define __DEVICE_TREE_H + +#include +#include + +typedef struct _Property { + char * name; + uint32_t length; + void * value; + + struct _Property * next; +} Property; + +typedef struct _Node { + struct _Property * properties; + struct _Property * last_prop; + + struct _Node * children; + + struct _Node * next; +} Node; + + +extern Property * +DT__AddProperty(Node *node, char *name, uint32_t length, void *value); + +extern Node * +DT__AddChild(Node *parent, char *name); + +Node * +DT__FindNode(char *path, bool createIfMissing); + +extern void +DT__FreeProperty(Property *prop); + +extern void +DT__FreeNode(Node *node); + +extern char * +DT__GetName(Node *node); + +void +DT__Initialize(void); + +/* + * Free up memory used by in-memory representation + * of device tree. + */ +extern void +DT__Finalize(void); + +void +DT__FlattenDeviceTree(void **result, uint32_t *length); + + +#endif /* __DEVICE_TREE_H */ Index: trunk/i386/libsaio/hfs.h =================================================================== --- trunk/i386/libsaio/hfs.h (revision 0) +++ trunk/i386/libsaio/hfs.h (revision 1) @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +extern long HFSInitPartition(CICell ih); +extern long HFSLoadFile(CICell ih, char * filePath); +extern long HFSReadFile(CICell ih, char * filePath, void *base, uint64_t offset, uint64_t length); +extern long HFSGetDirEntry(CICell ih, char * dirPath, long * dirIndex, + char ** name, long * flags, long * time, + FinderInfo * finderInfo, long * infoValid); +extern void HFSGetDescription(CICell ih, char *str, long strMaxLen); +extern long HFSGetFileBlock(CICell ih, char *str, unsigned long long *firstBlock); +extern long HFSGetUUID(CICell ih, char *uuidStr); +extern void HFSFree(CICell ih); +extern BOOL HFSProbe (const void *buf); \ No newline at end of file Index: trunk/i386/libsaio/spd.c =================================================================== --- trunk/i386/libsaio/spd.c (revision 0) +++ trunk/i386/libsaio/spd.c (revision 1) @@ -0,0 +1,166 @@ +/* + * + * + */ + +#include "libsaio.h" +#include "pci.h" +#include "platform.h" +#include "spd.h" + +#ifndef DEBUG_SPD +#define DEBUG_SPD 0 +#endif + +#if DEBUG_SPD +#define DBG(x...) printf(x) +#else +#define DBG(x...) +#endif + +static const char *spd_memory_types[] = +{ + "RAM", /* 00h Undefined */ + "FPM", /* 01h FPM */ + "EDO", /* 02h EDO */ + "", /* 03h PIPELINE NIBBLE */ + "SDRAM", /* 04h SDRAM */ + "", /* 05h MULTIPLEXED ROM */ + "DDR SGRAM", /* 06h SGRAM DDR */ + "DDR SDRAM", /* 07h SDRAM DDR */ + "DDR2 SDRAM", /* 08h SDRAM DDR 2 */ + "", /* 09h Undefined */ + "", /* 0Ah Undefined */ + "DDR3 SDRAM", /* 0Bh SDRAM DDR 3 */ +}; + +#define rdtsc(low,high) \ +__asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high)) + +#define SMBHSTSTS 0 +#define SMBHSTCNT 2 +#define SMBHSTCMD 3 +#define SMBHSTADD 4 +#define SMBHSTDAT 5 + +unsigned char smb_read_byte_intel(uint32_t base, uint8_t adr, uint8_t cmd) +{ + int l1, h1, l2, h2; + unsigned long long t; + + outb(base + SMBHSTSTS, 0x1f); // reset SMBus Controller + outb(base + SMBHSTDAT, 0xff); + + while( inb(base + SMBHSTSTS) & 0x01); // wait until ready + + outb(base + SMBHSTCMD, cmd); + outb(base + SMBHSTADD, (adr << 1) | 0x01 ); + outb(base + SMBHSTCNT, 0x48 ); + + rdtsc(l1, h1); + + while (!( inb(base + SMBHSTSTS) & 0x02)) // wait til command finished + { + rdtsc(l2, h2); + t = ((h2 - h1) * 0xffffffff + (l2 - l1)) / (Platform.CPU.TSCFrequency / 40); + if (t > 10) + break; // break after 10ms + } + return inb(base + SMBHSTDAT); +} + +static void read_smb_intel(pci_dt_t *smbus_dev) +{ + int i, x; + + uint8_t spd_size; + uint32_t base; + + RamSlotInfo_t *slot; + + base = pci_config_read16(smbus_dev->dev.addr, 0x20) & 0xFFFE; + + // Search MAX_RAM_SLOTS slots + for (i = 0; i < 6; i++) + { + slot = &Platform.RAM.DIMM[i]; + + spd_size = smb_read_byte_intel(base, 0x50 + i, 0); + + // Check spd is present + if (spd_size != 0xff) + { + slot->InUse = YES; + + slot->spd = malloc(spd_size); + if (slot->spd) + { + bzero(slot->spd, spd_size); + + // Copy spd data into buffer + for (x = 0; x < spd_size; x++) + slot->spd[x] = smb_read_byte_intel(base, 0x50 + i, x); + + switch (slot->spd[SPD_MEMORY_TYPE]) + { + case SPD_MEMORY_TYPE_SDRAM_DDR2: + + slot->ModuleSize = ((1 << (slot->spd[SPD_NUM_ROWS] & 0x0f) + (slot->spd[SPD_NUM_COLUMNS] & 0x0f) - 17) * + ((slot->spd[SPD_NUM_DIMM_BANKS] & 0x7) + 1) * slot->spd[SPD_NUM_BANKS_PER_SDRAM]); + break; + + case SPD_MEMORY_TYPE_SDRAM_DDR3: + + slot->ModuleSize = ((slot->spd[4] & 0x0f) + 28 ) + ((slot->spd[8] & 0x7) + 3 ); + slot->ModuleSize -= (slot->spd[7] & 0x7) + 25; + slot->ModuleSize = ((1 << slot->ModuleSize) * (((slot->spd[7] >> 3) & 0x1f) + 1)); + + break; + } + } + + verbose(" slot %d - %dMB %s SPD %d bytes at %x\n", i, slot->ModuleSize, + spd_memory_types[(uint8_t)slot->spd[SPD_MEMORY_TYPE]], + spd_size, slot->spd); + } + } + +} + +static struct smbus_controllers_t smbus_controllers[] = { + + {0x8086, 0x5032, "EP80579", read_smb_intel }, + {0x8086, 0x269B, "ESB2", read_smb_intel }, + {0x8086, 0x25A4, "6300ESB", read_smb_intel }, + {0x8086, 0x24C3, "ICH4", read_smb_intel }, + {0x8086, 0x24D3, "ICH5", read_smb_intel }, + {0x8086, 0x266A, "ICH6", read_smb_intel }, + {0x8086, 0x27DA, "ICH7", read_smb_intel }, + {0x8086, 0x283E, "ICH8", read_smb_intel }, + {0x8086, 0x2930, "ICH9", read_smb_intel }, + {0x8086, 0x3A30, "ICH10R", read_smb_intel }, + {0x8086, 0x3A60, "ICH10B", read_smb_intel }, + {0x8086, 0x3B30, "P55", read_smb_intel }, + +}; + +void scan_smbus_controller(pci_dt_t *smbus_dev) +{ + int i; + + for( i = 1; i < sizeof(smbus_controllers) / sizeof(smbus_controllers[0]); i++ ) + if (( smbus_controllers[i].vendor == smbus_dev->vendor_id) + && ( smbus_controllers[i].device == smbus_dev->device_id)) + { + verbose("%s%s SMBus Controller [%4x:%4x] at %02x:%02x.%x\n", + (smbus_dev->vendor_id == 0x8086) ? "Intel(R) " : "", + smbus_controllers[i].name, + smbus_dev->vendor_id, smbus_dev->device_id, + smbus_dev->dev.bits.bus, smbus_dev->dev.bits.dev, smbus_dev->dev.bits.func); + + smbus_controllers[i].read_smb(smbus_dev); + + } + +} + Index: trunk/i386/libsaio/hfs_compare.c =================================================================== --- trunk/i386/libsaio/hfs_compare.c (revision 0) +++ trunk/i386/libsaio/hfs_compare.c (revision 1) @@ -0,0 +1,421 @@ +/* + * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * HFSCompare.c - Functions for working with and comparing HFS nams. + * + * Copyright (c) 1999-2000 Apple Computer, Inc. + * + * DRI: Josh de Cesare + */ + +#include +#include "hfs_CaseTables.h" + +#if ! UNCOMPRESSED + +static unsigned short * +UncompressStructure(struct compressed_block *bp, int count, int size) +{ + unsigned short *out = malloc(size); + unsigned short *op = out; + unsigned short data; + int i, j; + + for (i=0; icount) + { + stop("HFS+ Unicode tables are malformed\n"); + } + data = bp->data; + for (j=0; jcount; j++) { + *op++ = data; + if (bp->type == kTypeAscending) data++; + else if (bp->type == kTypeAscending256) data += 256; + } + } + return out; +} + +static void +InitCompareTables(void) +{ + if (gCompareTable == 0) { + gCompareTable = UncompressStructure(gCompareTableCompressed, + kCompareTableNBlocks, kCompareTableDataSize); + gLowerCaseTable = UncompressStructure(gLowerCaseTableCompressed, + kLowerCaseTableNBlocks, kLowerCaseTableDataSize); + } +} + +#endif /* ! UNCOMPRESSED */ + +//_______________________________________________________________________ +// +// Routine: FastRelString +// +// Output: returns -1 if str1 < str2 +// returns 1 if str1 > str2 +// return 0 if equal +// +//_______________________________________________________________________ + +int32_t FastRelString(u_int8_t * str1, u_int8_t * str2) +{ + int32_t bestGuess; + u_int8_t length, length2; + +#if ! UNCOMPRESED + InitCompareTables(); +#endif + + length = *(str1++); + length2 = *(str2++); + + if (length == length2) + bestGuess = 0; + else if (length < length2) + bestGuess = -1; + else + { + bestGuess = 1; + length = length2; + } + + while (length--) + { + u_int32_t aChar, bChar; + + aChar = *(str1++); + bChar = *(str2++); + + if (aChar != bChar) /* If they don't match exacly, do case conversion */ + { + u_int16_t aSortWord, bSortWord; + + aSortWord = gCompareTable[aChar]; + bSortWord = gCompareTable[bChar]; + + if (aSortWord > bSortWord) + return 1; + + if (aSortWord < bSortWord) + return -1; + } + + /* + * If characters match exactly, then go on to next character + * immediately without doing any extra work. + */ + } + + /* if you got to here, then return bestGuess */ + return bestGuess; +} + + +// +// FastUnicodeCompare - Compare two Unicode strings; produce a relative ordering +// +// IF RESULT +// -------------------------- +// str1 < str2 => -1 +// str1 = str2 => 0 +// str1 > str2 => +1 +// +// The lower case table starts with 256 entries (one for each of the upper bytes +// of the original Unicode char). If that entry is zero, then all characters with +// that upper byte are already case folded. If the entry is non-zero, then it is +// the _index_ (not byte offset) of the start of the sub-table for the characters +// with that upper byte. All ignorable characters are folded to the value zero. +// +// In pseudocode: +// +// Let c = source Unicode character +// Let table[] = lower case table +// +// lower = table[highbyte(c)] +// if (lower == 0) +// lower = c +// else +// lower = table[lower+lowbyte(c)] +// +// if (lower == 0) +// ignore this character +// +// To handle ignorable characters, we now need a loop to find the next valid character. +// Also, we can't pre-compute the number of characters to compare; the string length might +// be larger than the number of non-ignorable characters. Further, we must be able to handle +// ignorable characters at any point in the string, including as the first or last characters. +// We use a zero value as a sentinel to detect both end-of-string and ignorable characters. +// Since the File Manager doesn't prevent the NUL character (value zero) as part of a filename, +// the case mapping table is assumed to map u+0000 to some non-zero value (like 0xFFFF, which is +// an invalid Unicode character). +// +// Pseudocode: +// +// while (1) { +// c1 = GetNextValidChar(str1) // returns zero if at end of string +// c2 = GetNextValidChar(str2) +// +// if (c1 != c2) break // found a difference +// +// if (c1 == 0) // reached end of string on both strings at once? +// return 0; // yes, so strings are equal +// } +// +// // When we get here, c1 != c2. So, we just need to determine which one is less. +// if (c1 < c2) +// return -1; +// else +// return 1; +// + +int32_t FastUnicodeCompare( u_int16_t * str1, register u_int32_t length1, + u_int16_t * str2, register u_int32_t length2, int byte_order ) +{ + register u_int16_t c1,c2; + register u_int16_t temp; + +#if ! UNCOMPRESSED + InitCompareTables(); +#endif + + while (1) { + /* Set default values for c1, c2 in case there are no more valid chars */ + c1 = 0; + c2 = 0; + + /* Find next non-ignorable char from str1, or zero if no more */ + while (length1 && c1 == 0) { + if (byte_order == OSBigEndian) + c1 = SWAP_BE16(*(str1++)); + else + c1 = SWAP_LE16(*(str1++)); + --length1; + if ((temp = gLowerCaseTable[c1>>8]) != 0) // is there a subtable for this upper byte? + c1 = gLowerCaseTable[temp + (c1 & 0x00FF)]; // yes, so fold the char + } + + /* Find next non-ignorable char from str2, or zero if no more */ + while (length2 && c2 == 0) { + if (byte_order == OSBigEndian) + c2 = SWAP_BE16(*(str2++)); + else + c2 = SWAP_LE16(*(str2++)); + --length2; + if ((temp = gLowerCaseTable[c2>>8]) != 0) // is there a subtable for this upper byte? + c2 = gLowerCaseTable[temp + (c2 & 0x00FF)]; // yes, so fold the char + } + + if (c1 != c2) /* found a difference, so stop looping */ + break; + + if (c1 == 0) /* did we reach the end of both strings at the same time? */ + return 0; /* yes, so strings are equal */ + } + + if (c1 < c2) + return -1; + else + return 1; +} + + +// +// BinaryUnicodeCompare - Compare two Unicode strings; produce a relative ordering +// Compared using a 16-bit binary comparison (no case folding) +// +int32_t BinaryUnicodeCompare (u_int16_t * str1, u_int32_t length1, + u_int16_t * str2, u_int32_t length2) +{ + register u_int16_t c1, c2; + int32_t bestGuess; + u_int32_t length; + + bestGuess = 0; + + if (length1 < length2) { + length = length1; + --bestGuess; + } else if (length1 > length2) { + length = length2; + ++bestGuess; + } else { + length = length1; + } + + while (length--) { + c1 = *(str1++); + c2 = *(str2++); + + if (c1 > c2) + return (1); + if (c1 < c2) + return (-1); + } + + return (bestGuess); +} + + +/* + * UTF-8 (UCS Transformation Format) + * + * The following subset of UTF-8 is used to encode UCS-2 filenames. It + * requires a maximum of three 3 bytes per UCS-2 character. Only the + * shortest encoding required to represent the significant UCS-2 bits + * is legal. + * + * UTF-8 Multibyte Codes + * + * Bytes Bits UCS-2 Min UCS-2 Max UTF-8 Byte Sequence (binary) + * ------------------------------------------------------------------- + * 1 7 0x0000 0x007F 0xxxxxxx + * 2 11 0x0080 0x07FF 110xxxxx 10xxxxxx + * 3 16 0x0800 0xFFFF 1110xxxx 10xxxxxx 10xxxxxx + * ------------------------------------------------------------------- + */ + + +/* + * utf_encodestr - Encodes the UCS-2 (Unicode) string at ucsp into a + * null terminated UTF-8 string at utf8p. + * + * ucslen is the number of UCS-2 input characters (not bytes) + * bufsize is the size of the output buffer in bytes + */ +void +utf_encodestr( const u_int16_t * ucsp, int ucslen, + u_int8_t * utf8p, u_int32_t bufsize, int byte_order ) +{ + u_int8_t *bufend; + u_int16_t ucs_ch; + + bufend = utf8p + bufsize; + + while (ucslen-- > 0) { + if (byte_order == OSBigEndian) + ucs_ch = SWAP_BE16(*ucsp++); + else + ucs_ch = SWAP_LE16(*ucsp++); + + if (ucs_ch < 0x0080) { + if (utf8p >= bufend) + break; + if (ucs_ch == '\0') + continue; /* skip over embedded NULLs */ + *utf8p++ = ucs_ch; + + } else if (ucs_ch < 0x800) { + if ((utf8p + 1) >= bufend) + break; + *utf8p++ = (ucs_ch >> 6) | 0xc0; + *utf8p++ = (ucs_ch & 0x3f) | 0x80; + + } else { + if ((utf8p + 2) >= bufend) + break; + *utf8p++ = (ucs_ch >> 12) | 0xe0; + *utf8p++ = ((ucs_ch >> 6) & 0x3f) | 0x80; + *utf8p++ = ((ucs_ch) & 0x3f) | 0x80; + } + } + + *utf8p = '\0'; +} + + +/* + * utf_decodestr - Decodes the null terminated UTF-8 string at + * utf8p into a UCS-2 (Unicode) string at ucsp. + * + * ucslen is the number of UCS-2 output characters (not bytes) + * bufsize is the size of the output buffer in bytes + */ +void utf_decodestr(const u_int8_t * utf8p, u_int16_t * ucsp, u_int16_t * ucslen, u_int32_t bufsize, int byte_order) +{ + u_int16_t *bufstart; + u_int16_t *bufend; + u_int16_t ucs_ch; + u_int8_t byte; + + bufstart = ucsp; + bufend = (u_int16_t *)((u_int8_t *)ucsp + bufsize); + + while ((byte = *utf8p++) != '\0') { + if (ucsp >= bufend) + break; + + /* check for ascii */ + if (byte < 0x80) { + ucs_ch = byte; + + if (byte_order == OSBigEndian) + *ucsp++ = SWAP_BE16(ucs_ch); + else + *ucsp++ = SWAP_LE16(ucs_ch); + + continue; + } + + switch (byte & 0xf0) { + /* 2 byte sequence*/ + case 0xc0: + case 0xd0: + /* extract bits 6 - 10 from first byte */ + ucs_ch = (byte & 0x1F) << 6; + break; + /* 3 byte sequence*/ + case 0xe0: + /* extract bits 12 - 15 from first byte */ + ucs_ch = (byte & 0x0F) << 6; + + /* extract bits 6 - 11 from second byte */ + if (((byte = *utf8p++) & 0xc0) != 0x80) + goto stop; + + ucs_ch += (byte & 0x3F); + ucs_ch <<= 6; + break; + default: + goto stop; + } + + /* extract bits 0 - 5 from final byte */ + if (((byte = *utf8p++) & 0xc0) != 0x80) + goto stop; + ucs_ch += (byte & 0x3F); + + if (byte_order == OSBigEndian) + *ucsp++ = SWAP_BE16(ucs_ch); + else + *ucsp++ = SWAP_LE16(ucs_ch); + } +stop: + if (byte_order == OSBigEndian) + *ucslen = SWAP_BE16(ucsp - bufstart); + else + *ucslen = SWAP_LE16(ucsp - bufstart); +} Index: trunk/i386/libsaio/libsaio.h =================================================================== --- trunk/i386/libsaio/libsaio.h (revision 0) +++ trunk/i386/libsaio/libsaio.h (revision 1) @@ -0,0 +1,35 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* libsaio.h */ + +#ifndef __LIBSAIO_LIBSAIO_H +#define __LIBSAIO_LIBSAIO_H + +#include "libsa.h" +#include "memory.h" +#include "io_inline.h" +#include "saio_types.h" +#include "saio_internal.h" + +#endif /* !__LIBSAIO_LIBSAIO_H */ Index: trunk/i386/libsaio/spd.h =================================================================== --- trunk/i386/libsaio/spd.h (revision 0) +++ trunk/i386/libsaio/spd.h (revision 1) @@ -0,0 +1,156 @@ +/* + * + * + */ + +#ifndef __LIBSAIO_SPD_H +#define __LIBSAIO_SPD_H + +#include "libsaio.h" + +void scan_smbus_controller(pci_dt_t *smbus_dev); + +struct smbus_controllers_t { + uint32_t vendor; + uint32_t device; + char *name; + void (*read_smb)(pci_dt_t *smbus_dev); +}; + + +/* + * Serial Presence Detect (SPD) data stored on SDRAM modules. + * + * Datasheet: + * - Name: PC SDRAM Serial Presence Detect (SPD) Specification + * Revision 1.2A, December, 1997 + * - PDF: http://www.intel.com/design/chipsets/memory/spdsd12a.pdf + * + * Datasheet (alternative): + * - Name: SERIAL PRESENCE DETECT STANDARD, General Standard + * JEDEC Standard No. 21-C + * - PDF: http://www.jedec.org/download/search/4_01_02_00R9.PDF + */ + + +/* Byte numbers. */ +#define SPD_NUM_MANUFACTURER_BYTES 0 /* Number of bytes used by module manufacturer */ +#define SPD_TOTAL_SPD_MEMORY_SIZE 1 /* Total SPD memory size */ +#define SPD_MEMORY_TYPE 2 /* (Fundamental) memory type */ +#define SPD_NUM_ROWS 3 /* Number of row address bits */ +#define SPD_NUM_COLUMNS 4 /* Number of column address bits */ +#define SPD_NUM_DIMM_BANKS 5 /* Number of module rows (banks) */ +#define SPD_MODULE_DATA_WIDTH_LSB 6 /* Module data width (LSB) */ +#define SPD_MODULE_DATA_WIDTH_MSB 7 /* Module data width (MSB) */ +#define SPD_MODULE_VOLTAGE 8 /* Module interface signal levels */ +#define SPD_MIN_CYCLE_TIME_AT_CAS_MAX 9 /* SDRAM cycle time (highest CAS latency), RAS access time (tRAC) */ +#define SPD_ACCESS_TIME_FROM_CLOCK 10 /* SDRAM access time from clock (highest CAS latency), CAS access time (Tac, tCAC) */ +#define SPD_DIMM_CONFIG_TYPE 11 /* Module configuration type */ +#define SPD_REFRESH 12 /* Refresh rate/type */ +#define SPD_PRIMARY_SDRAM_WIDTH 13 /* SDRAM width (primary SDRAM) */ +#define SPD_ERROR_CHECKING_SDRAM_WIDTH 14 /* Error checking SDRAM (data) width */ +#define SPD_MIN_CLOCK_DELAY_B2B_RAND_COLUMN 15 /* SDRAM device attributes, minimum clock delay for back to back random column */ +#define SPD_SUPPORTED_BURST_LENGTHS 16 /* SDRAM device attributes, burst lengths supported */ +#define SPD_NUM_BANKS_PER_SDRAM 17 /* SDRAM device attributes, number of banks on SDRAM device */ +#define SPD_ACCEPTABLE_CAS_LATENCIES 18 /* SDRAM device attributes, CAS latency */ +#define SPD_CS_LATENCY 19 /* SDRAM device attributes, CS latency */ +#define SPD_WE_LATENCY 20 /* SDRAM device attributes, WE latency */ +#define SPD_MODULE_ATTRIBUTES 21 /* SDRAM module attributes */ +#define SPD_DEVICE_ATTRIBUTES_GENERAL 22 /* SDRAM device attributes, general */ +#define SPD_SDRAM_CYCLE_TIME_2ND 23 /* SDRAM cycle time (2nd highest CAS latency) */ +#define SPD_ACCESS_TIME_FROM_CLOCK_2ND 24 /* SDRAM access from clock (2nd highest CAS latency) */ +#define SPD_SDRAM_CYCLE_TIME_3RD 25 /* SDRAM cycle time (3rd highest CAS latency) */ +#define SPD_ACCESS_TIME_FROM_CLOCK_3RD 26 /* SDRAM access from clock (3rd highest CAS latency) */ +#define SPD_MIN_ROW_PRECHARGE_TIME 27 /* Minimum row precharge time (Trp) */ +#define SPD_MIN_ROWACTIVE_TO_ROWACTIVE 28 /* Minimum row active to row active (Trrd) */ +#define SPD_MIN_RAS_TO_CAS_DELAY 29 /* Minimum RAS to CAS delay (Trcd) */ +#define SPD_MIN_ACTIVE_TO_PRECHARGE_DELAY 30 /* Minimum RAS pulse width (Tras) */ +#define SPD_DENSITY_OF_EACH_ROW_ON_MODULE 31 /* Density of each row on module */ +#define SPD_CMD_SIGNAL_INPUT_SETUP_TIME 32 /* Command and address signal input setup time */ +#define SPD_CMD_SIGNAL_INPUT_HOLD_TIME 33 /* Command and address signal input hold time */ +#define SPD_DATA_SIGNAL_INPUT_SETUP_TIME 34 /* Data signal input setup time */ +#define SPD_DATA_SIGNAL_INPUT_HOLD_TIME 35 /* Data signal input hold time */ +#define SPD_WRITE_RECOVERY_TIME 36 /* Write recovery time (tWR) */ +#define SPD_INT_WRITE_TO_READ_DELAY 37 /* Internal write to read command delay (tWTR) */ +#define SPD_INT_READ_TO_PRECHARGE_DELAY 38 /* Internal read to precharge command delay (tRTP) */ +#define SPD_MEM_ANALYSIS_PROBE_PARAMS 39 /* Memory analysis probe characteristics */ +#define SPD_BYTE_41_42_EXTENSION 40 /* Extension of byte 41 (tRC) and byte 42 (tRFC) */ +#define SPD_MIN_ACT_TO_ACT_AUTO_REFRESH 41 /* Minimum active to active auto refresh (tRCmin) */ +#define SPD_MIN_AUTO_REFRESH_TO_ACT 42 /* Minimum auto refresh to active/auto refresh (tRFC) */ +#define SPD_MAX_DEVICE_CYCLE_TIME 43 /* Maximum device cycle time (tCKmax) */ +#define SPD_MAX_DQS_DQ_SKEW 44 /* Maximum skew between DQS and DQ (tDQSQ) */ +#define SPD_MAX_READ_DATAHOLD_SKEW 45 /* Maximum read data-hold skew factor (tQHS) */ +#define SPD_PLL_RELOCK_TIME 46 /* PLL relock time */ +#define SPD_SPD_DATA_REVISION_CODE 62 /* SPD data revision code */ +#define SPD_CHECKSUM_FOR_BYTES_0_TO_62 63 /* Checksum for bytes 0-62 */ +#define SPD_MANUFACTURER_JEDEC_ID_CODE 64 /* Manufacturer's JEDEC ID code, per EIA/JEP106 (bytes 64-71) */ +#define SPD_MANUFACTURING_LOCATION 72 /* Manufacturing location */ +#define SPD_MANUFACTURER_PART_NUMBER 73 /* Manufacturer's part number, in 6-bit ASCII (bytes 73-90) */ +#define SPD_REVISION_CODE 91 /* Revision code (bytes 91-92) */ +#define SPD_MANUFACTURING_DATE 93 /* Manufacturing date (byte 93: year, byte 94: week) */ +#define SPD_ASSEMBLY_SERIAL_NUMBER 95 /* Assembly serial number (bytes 95-98) */ +#define SPD_MANUFACTURER_SPECIFIC_DATA 99 /* Manufacturer specific data (bytes 99-125) */ +#define SPD_INTEL_SPEC_FOR_FREQUENCY 126 /* Intel specification for frequency */ +#define SPD_INTEL_SPEC_100_MHZ 127 /* Intel specification details for 100MHz support */ + +/* DRAM specifications use the following naming conventions for SPD locations */ +#define SPD_tRP SPD_MIN_ROW_PRECHARGE_TIME +#define SPD_tRRD SPD_MIN_ROWACTIVE_TO_ROWACTIVE +#define SPD_tRCD SPD_MIN_RAS_TO_CAS_DELAY +#define SPD_tRAS SPD_MIN_ACTIVE_TO_PRECHARGE_DELAY +#define SPD_BANK_DENSITY SPD_DENSITY_OF_EACH_ROW_ON_MODULE +#define SPD_ADDRESS_CMD_HOLD SPD_CMD_SIGNAL_INPUT_HOLD_TIME +#define SPD_tRC 41 /* SDRAM Device Minimum Active to Active/Auto Refresh Time (tRC) */ +#define SPD_tRFC 42 /* SDRAM Device Minimum Auto Refresh to Active/Auto Refresh (tRFC) */ + + +/* SPD_MEMORY_TYPE values. */ +#define SPD_MEMORY_TYPE_FPM_DRAM 1 +#define SPD_MEMORY_TYPE_EDO 2 +#define SPD_MEMORY_TYPE_PIPELINED_NIBBLE 3 +#define SPD_MEMORY_TYPE_SDRAM 4 +#define SPD_MEMORY_TYPE_MULTIPLEXED_ROM 5 +#define SPD_MEMORY_TYPE_SGRAM_DDR 6 +#define SPD_MEMORY_TYPE_SDRAM_DDR 7 +#define SPD_MEMORY_TYPE_SDRAM_DDR2 8 +#define SPD_MEMORY_TYPE_SDRAM_DDR3 0xb + +/* SPD_MODULE_VOLTAGE values. */ +#define SPD_VOLTAGE_TTL 0 /* 5.0 Volt/TTL */ +#define SPD_VOLTAGE_LVTTL 1 /* LVTTL */ +#define SPD_VOLTAGE_HSTL 2 /* HSTL 1.5 */ +#define SPD_VOLTAGE_SSTL3 3 /* SSTL 3.3 */ +#define SPD_VOLTAGE_SSTL2 4 /* SSTL 2.5 */ + +/* SPD_DIMM_CONFIG_TYPE values. */ +#define ERROR_SCHEME_NONE 0 +#define ERROR_SCHEME_PARITY 1 +#define ERROR_SCHEME_ECC 2 + +/* SPD_ACCEPTABLE_CAS_LATENCIES values. */ +// TODO: Check values. +#define SPD_CAS_LATENCY_1_0 0x01 +#define SPD_CAS_LATENCY_1_5 0x02 +#define SPD_CAS_LATENCY_2_0 0x04 +#define SPD_CAS_LATENCY_2_5 0x08 +#define SPD_CAS_LATENCY_3_0 0x10 +#define SPD_CAS_LATENCY_3_5 0x20 +#define SPD_CAS_LATENCY_4_0 0x40 + +#define SPD_CAS_LATENCY_DDR2_3 (1 << 3) +#define SPD_CAS_LATENCY_DDR2_4 (1 << 4) +#define SPD_CAS_LATENCY_DDR2_5 (1 << 5) +#define SPD_CAS_LATENCY_DDR2_6 (1 << 6) + +/* SPD_SUPPORTED_BURST_LENGTHS values. */ +#define SPD_BURST_LENGTH_1 1 +#define SPD_BURST_LENGTH_2 2 +#define SPD_BURST_LENGTH_4 4 +#define SPD_BURST_LENGTH_8 8 +#define SPD_BURST_LENGTH_PAGE (1 << 7) + +/* SPD_MODULE_ATTRIBUTES values. */ +#define MODULE_BUFFERED 1 +#define MODULE_REGISTERED 2 + +#endif /* !__LIBSAIO_SPD_H */ Index: trunk/i386/libsaio/Makefile =================================================================== --- trunk/i386/libsaio/Makefile (revision 0) +++ trunk/i386/libsaio/Makefile (revision 1) @@ -0,0 +1,89 @@ + +DIR = libsaio +include ../MakePaths.dir + +UTILDIR = ../util +LIBSADIR = ../libsa +INSTALLDIR = $(DSTROOT)/System/Library/Frameworks/System.framework/Versions/B/PrivateHeaders/standalone +#SYMROOT= + +OPTIM = -Os -Oz +DEBUG = NOTHING +CFLAGS = $(RC_CFLAGS) $(OPTIM) $(MORECPP) -arch i386 -g -Wmost \ + -D__ARCHITECTURE__=\"i386\" -DSAIO_INTERNAL_USER \ + -DRCZ_COMPRESSED_FILE_SUPPORT -D$(DEBUG) \ + -fno-builtin -static $(OMIT_FRAME_POINTER_CFLAG) \ + -mpreferred-stack-boundary=2 -fno-align-functions -fno-stack-protector \ + -march=pentium4 -msse2 -mfpmath=sse -msoft-float + +DEFINES= +CONFIG = hd +INC = -I. -I$(SYMROOT) -I$(UTILDIR) -I$(LIBSADIR) +ifneq "" "$(wildcard /bin/mkdirs)" + MKDIRS = /bin/mkdirs +else + MKDIRS = /bin/mkdir -p +endif +AS = as +LD = ld +# LIBS= -lc_static +LIBS= + +VPATH = $(OBJROOT):$(SYMROOT) + +SAIO_OBJS = table.o asm.o bios.o biosfn.o \ + disk.o sys.o cache.o bootstruct.o \ + stringTable.o load.o pci.o memory.o misc.o \ + ufs.o ufs_byteorder.o \ + vbe.o nbp.o hfs.o hfs_compare.o \ + xml.o ntfs.o msdos.o md5c.o device_tree.o \ + freq_detect.o platform.o dsdt_patcher.o \ + smbios_patcher.o fake_efi.o ext2fs.o \ + hpet.o spd.o usb.o pci_setup.o \ + device_inject.o nvidia.o ati.o + + +SAIO_EXTERN_OBJS = console.o + +SFILES = +CFILES = +HFILES = +EXPORTED_HFILES = +INSTALLED_HFILES = +OTHERFILES = Makefile +ALLSRC = $(SFILES) $(CFILES) \ + $(HFILES) $(OTHERFILES) +LIBS = libsaio.a +DIRS_NEEDED = $(OBJROOT) $(SYMROOT) +#GENFILES = $(SYMROOT)/saio_internal.h \ +# $(SYMROOT)/saio_external.h \ +# $(SYMROOT)/saio_defs.h \ +# $(SYMROOT)/saio_table.c + +#SIG = $(SYMROOT)/sig + +all embedtheme: $(DIRS_NEEDED) libsaio.h $(LIBS) + +#libsaio_static.a: $(SAIO_OBJS) +# rm -f $(SYMROOT)/$@ +# ar q $(SYMROOT)/$@ $(SAIO_OBJS) +# ranlib $(SYMROOT)/$@ + +libsaio.a: $(SAIO_EXTERN_OBJS) $(SAIO_OBJS) + rm -f $(SYMROOT)/$(@F) + ar q $(SYMROOT)/$(@F) $^ + ranlib $(SYMROOT)/$(@F) + +#saio_internal.h: saio_external.h +#saio_table.c: saio_external.h +#saio_defs.h: saio_external.h +#saio_external.h: saio.def +# $(SIG) -d $(SYMROOT) -n saio saio.def + +#installhdrs:: $(INSTALLDIR) +# cp $(INSTALLED_HFILES) $(INSTALLDIR) + +include ../MakeInc.dir + +# dependencies +-include $(OBJROOT)/Makedep Index: trunk/i386/libsaio/ufs.c =================================================================== --- trunk/i386/libsaio/ufs.c (revision 0) +++ trunk/i386/libsaio/ufs.c (revision 1) @@ -0,0 +1,534 @@ +/* + * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * ufs.c - File System Module for UFS. + * + * Copyright (c) 1998-2002 Apple Computer, Inc. + * + * DRI: Josh de Cesare + */ + +#include + +#include "ufs.h" +#include "ufs_byteorder.h" + +#if !defined(MAXNAMLEN) && defined(UFSMAXNAMLEN) +#define MAXNAMLEN UFSMAXNAMLEN +#endif + +typedef struct dinode Inode, *InodePtr; + +// Private function prototypes + +static char *ReadBlock(long fragNum, long fragOffset, long length, + char *buffer, long cache); +static long ReadInode(long inodeNum, InodePtr inode, long *flags, long *time); +static long ResolvePathToInode(char *filePath, long *flags, + InodePtr fileInode, InodePtr dirInode); +static long ReadDirEntry(InodePtr dirInode, long *fileInodeNum, + long *dirIndex, char **name); +static long FindFileInDir(char *fileName, long *flags, + InodePtr fileInode, InodePtr dirInode); +static char *ReadFileBlock(InodePtr fileInode, long fragNum, long blockOffset, + long length, char *buffer, long cache); +static long ReadFile(InodePtr fileInode, uint64_t *length, void *base, uint64_t offset); + +#define kDevBlockSize (0x200) // Size of each disk block. +#define kDiskLabelBlock (15) // Block the DL is in. + +#ifdef __i386__ + +static CICell gCurrentIH; +static long long gPartitionBase; +static char *gULBuf; +static char *gFSBuf; +static struct fs *gFS; +#if !BOOT1 +static struct ufslabel gUFSLabel; // for UUID +#endif +static long gBlockSize; +static long gFragSize; +static long gFragsPerBlock; +static char *gTempBlock; +static char *gTempName; +static char *gTempName2; +static InodePtr gRootInodePtr; +static InodePtr gFileInodePtr; + +#else /* !__i386__ */ + +static CICell gCurrentIH; +static long long gPartitionBase; +static char gDLBuf[8192]; +static char gFSBuf[SBSIZE]; +static struct fs *gFS; +#if !BOOT1 +static struct ufslabel gUFSLabel; // for UUID +#endif +static long gBlockSize; +static long gFragSize; +static long gFragsPerBlock; +static char *gTempBlock; +static char gTempName[MAXNAMLEN + 1]; +static char gTempName2[MAXNAMLEN + 1]; +static Inode _gRootInode; +static Inode _gFileInode; +static InodePtr gRootInodePtr = &_gRootInode; +static InodePtr gFileInodePtr = &_gFileInode; + +#endif /* !__i386__ */ + +// Public functions + +void UFSFree(CICell ih) +{ + if(gCurrentIH == ih) + gCurrentIH = 0; + free(ih); +} + +long UFSInitPartition( CICell ih ) +{ +#if !BOOT1 + long ret; +#endif + + if (ih == gCurrentIH) { +#ifdef __i386__ + CacheInit(ih, gBlockSize); +#endif + return 0; + } + +#if !BOOT1 + verbose("UFSInitPartition: %x\n", ih); +#endif + + gCurrentIH = 0; + +#ifdef __i386__ + if (!gULBuf) gULBuf = (char *) malloc(UFS_LABEL_SIZE); + if (!gFSBuf) gFSBuf = (char *) malloc(SBSIZE); + if (!gTempName) gTempName = (char *) malloc(MAXNAMLEN + 1); + if (!gTempName2) gTempName2 = (char *) malloc(MAXNAMLEN + 1); + if (!gRootInodePtr) gRootInodePtr = (InodePtr) malloc(sizeof(Inode)); + if (!gFileInodePtr) gFileInodePtr = (InodePtr) malloc(sizeof(Inode)); + if (!gULBuf || !gFSBuf || !gTempName || !gTempName2 || + !gRootInodePtr || !gFileInodePtr) return -1; +#endif + + // Assume there is no Disk Label + gPartitionBase = 0; + +#if !BOOT1 + // read the disk label to get the UUID + // (rumor has it that UFS headers can be either-endian on disk; hopefully + // that isn't true for this UUID field). + Seek(ih, gPartitionBase + UFS_LABEL_OFFSET); + ret = Read(ih, (long)&gUFSLabel, UFS_LABEL_SIZE); + if(ret != 0) + bzero(&gUFSLabel, UFS_LABEL_SIZE); +#endif /* !BOOT1 */ + + // Look for the Super Block + Seek(ih, gPartitionBase + SBOFF); + Read(ih, (long)gFSBuf, SBSIZE); + + gFS = (struct fs *)gFSBuf; + byte_swap_superblock(gFS); + + if (gFS->fs_magic != FS_MAGIC) { + return -1; + } + + ih->modTime = gFS->fs_time; + + // Calculate the block size and set up the block cache. + gBlockSize = gFS->fs_bsize; + gFragSize = gFS->fs_fsize; + gFragsPerBlock = gBlockSize / gFragSize; + if (gTempBlock != 0) free(gTempBlock); + gTempBlock = malloc(gBlockSize); + CacheInit(ih, gBlockSize); + + gCurrentIH = ih; + + // Read the Root Inode + ReadInode(ROOTINO, gRootInodePtr, 0, 0); + + return 0; +} + +#if !BOOT1 + +long UFSGetUUID(CICell ih, char *uuidStr) +{ + long long uuid = gUFSLabel.ul_uuid; + + if (UFSInitPartition(ih) == -1) return -1; + if (uuid == 0LL) return -1; + + return CreateUUIDString((uint8_t*)(&uuid), sizeof(uuid), uuidStr); +} + +#endif /* !BOOT1 */ + +long UFSLoadFile( CICell ih, char * filePath ) +{ + return UFSReadFile(ih, filePath, (void *)gFSLoadAddress, 0, 0); +} + +long UFSReadFile( CICell ih, char * filePath, void * base, uint64_t offset, uint64_t length ) +{ + long ret, flags; + +#if !BOOT1 + verbose("Loading UFS file: [%s] from %x.\n", filePath, (unsigned)ih); +#endif + + if (UFSInitPartition(ih) == -1) return -1; + + // Skip one or two leading '/'. + if (*filePath == '/') filePath++; + if (*filePath == '/') filePath++; + + ret = ResolvePathToInode(filePath, &flags, gFileInodePtr, gRootInodePtr); + if ((ret == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) return -1; + + ret = ReadFile(gFileInodePtr, &length, base, offset); + if (ret == -1) return -1; + + return length; +} + +#ifndef BOOT1 + +long UFSGetDirEntry( CICell ih, char * dirPath, long * dirIndex, + char ** name, long * flags, long * time, + FinderInfo * finderInfo, long * infoValid) +{ + long ret, fileInodeNum, dirFlags; + Inode tmpInode; + + if (UFSInitPartition(ih) == -1) return -1; + + if (infoValid) *infoValid = 0; + + // Skip a leading '/' if present + if (*dirPath == '/') dirPath++; + if (*dirPath == '/') dirPath++; + + ret = ResolvePathToInode(dirPath, &dirFlags, gFileInodePtr, gRootInodePtr); + if ((ret == -1) || ((dirFlags & kFileTypeMask) != kFileTypeDirectory)) + return -1; + + ret = ReadDirEntry(gFileInodePtr, &fileInodeNum, dirIndex, name); + if (ret != 0) return ret; + + ReadInode(fileInodeNum, &tmpInode, flags, time); + + return 0; +} + +void +UFSGetDescription(CICell ih, char *str, long strMaxLen) +{ + if (UFSInitPartition(ih) == -1) { return; } + + struct ufslabel *ul; + + // Look for the Disk Label + Seek(ih, 1ULL * UFS_LABEL_OFFSET); + Read(ih, (long)gULBuf, UFS_LABEL_SIZE); + + ul = (struct ufslabel *)gULBuf; + + unsigned char magic_bytes[] = UFS_LABEL_MAGIC; + int i; + unsigned char *p = (unsigned char *)&ul->ul_magic; + + for (i=0; iul_name, strMaxLen); +} + +long +UFSGetFileBlock(CICell ih, char *filePath, unsigned long long *firstBlock) +{ + long ret, flags; + + if (UFSInitPartition(ih) == -1) return -1; + + // Skip one or two leading '/'. + if (*filePath == '/') filePath++; + if (*filePath == '/') filePath++; + + ret = ResolvePathToInode(filePath, &flags, gFileInodePtr, gRootInodePtr); + if ((ret == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) return -1; + + *firstBlock = (gPartitionBase + 1ULL * gFileInodePtr->di_db[0] * gBlockSize) / 512ULL; + + return 0; +} + + +#endif /* !BOOT1 */ + +// Private functions + +static char * ReadBlock( long fragNum, long blockOffset, long length, + char * buffer, long cache ) +{ + long long offset; + long blockNum; + + blockNum = fragNum / gFragsPerBlock; + fragNum -= blockNum * gFragsPerBlock; + + blockOffset += fragNum * gFragSize; + + offset = gPartitionBase + 1ULL * blockNum * gBlockSize; + + if (cache && ((blockOffset + length) <= gBlockSize)) { + CacheRead(gCurrentIH, gTempBlock, offset, gBlockSize, 1); + if (buffer != 0) bcopy(gTempBlock + blockOffset, buffer, length); + else buffer = gTempBlock + blockOffset; + } else { + offset += blockOffset; + CacheRead(gCurrentIH, buffer, offset, length, 0); + } + + return buffer; +} + +static long ReadInode( long inodeNum, InodePtr inode, long * flags, long * time ) +{ + long fragNum = ino_to_fsba(gFS, inodeNum); + long blockOffset = ino_to_fsbo(gFS, inodeNum) * sizeof(Inode); + + ReadBlock(fragNum, blockOffset, sizeof(Inode), (char *)inode, 1); + byte_swap_dinode_in(inode); + + if (time != 0) *time = inode->di_mtime; + + if (flags != 0) { + switch (inode->di_mode & IFMT) { + case IFREG: *flags = kFileTypeFlat; break; + case IFDIR: *flags = kFileTypeDirectory; break; + case IFLNK: *flags = kFileTypeLink; break; + default : *flags = kFileTypeUnknown; break; + } + + *flags |= inode->di_mode & kPermMask; + + if (inode->di_uid != 0) *flags |= kOwnerNotRoot; + } + + return 0; +} + +static long ResolvePathToInode( char * filePath, long * flags, + InodePtr fileInode, InodePtr dirInode ) +{ + char * restPath; + long ret, cnt; + + // if filePath is empty the we want this directory. + if (*filePath == '\0') { + bcopy((char *)dirInode, (char *)fileInode, sizeof(Inode)); + return 0; + } + + // Copy the file name to gTempName + cnt = 0; + while ((filePath[cnt] != '/') && (filePath[cnt] != '\0')) cnt++; + strlcpy(gTempName, filePath, cnt+1); + + // Move restPath to the right place. + if (filePath[cnt] != '\0') cnt++; + restPath = filePath + cnt; + + // gTempName is a name in the current Dir. + // restPath is the rest of the path if any. + + ret = FindFileInDir(gTempName, flags, fileInode, dirInode); + if (ret == -1) return -1; + + if ((*restPath != '\0') && ((*flags & kFileTypeMask) == kFileTypeDirectory)) + ret = ResolvePathToInode(restPath, flags, fileInode, fileInode); + + return ret; +} + +static long ReadDirEntry( InodePtr dirInode, long * fileInodeNum, + long * dirIndex, char ** name ) +{ + struct direct *dir; + char *buffer; + long index; + long dirBlockNum, dirBlockOffset; + + while (1) { + index = *dirIndex; + + dirBlockOffset = index % DIRBLKSIZ; + dirBlockNum = index / DIRBLKSIZ; + + buffer = ReadFileBlock(dirInode, dirBlockNum, 0, DIRBLKSIZ, 0, 1); + if (buffer == 0) return -1; + + dir = (struct direct *)(buffer + dirBlockOffset); + byte_swap_dir_block_in((char *)dir, 1); + + *dirIndex += dir->d_reclen; + + if (dir->d_ino != 0) break; + + if (dirBlockOffset != 0) return -1; + } + + *fileInodeNum = dir->d_ino; + *name = strlcpy(gTempName2, dir->d_name, dir->d_namlen+1); + + return 0; +} + +static long FindFileInDir( char * fileName, long * flags, + InodePtr fileInode, InodePtr dirInode ) +{ + long ret, inodeNum, index = 0; + char *name; + + while (1) { + ret = ReadDirEntry(dirInode, &inodeNum, &index, &name); + if (ret == -1) return -1; + + if (strcmp(fileName, name) == 0) break; + } + + ReadInode(inodeNum, fileInode, flags, 0); + + return 0; +} + +static char * ReadFileBlock( InodePtr fileInode, long fragNum, long blockOffset, + long length, char * buffer, long cache ) +{ + long fragCount, blockNum; + long diskFragNum, indFragNum, indBlockOff, refsPerBlock; + char *indBlock; + + fragCount = (fileInode->di_size + gFragSize - 1) / gFragSize; + if (fragNum >= fragCount) return 0; + + refsPerBlock = gBlockSize / sizeof(ufs_daddr_t); + + blockNum = fragNum / gFragsPerBlock; + fragNum -= blockNum * gFragsPerBlock; + + // Get Direct Block Number. + if (blockNum < NDADDR) { + diskFragNum = fileInode->di_db[blockNum]; + } else { + blockNum -= NDADDR; + + // Get Single Indirect Fragment Number. + if (blockNum < refsPerBlock) { + indFragNum = fileInode->di_ib[0]; + } else { + blockNum -= refsPerBlock; + + // Get Double Indirect Fragment Number. + if (blockNum < (refsPerBlock * refsPerBlock)) { + indFragNum = fileInode->di_ib[1]; + } else { + blockNum -= refsPerBlock * refsPerBlock; + + // Get Triple Indirect Fragment Number. + indFragNum = fileInode->di_ib[2]; + + indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1); + indBlockOff = blockNum / (refsPerBlock * refsPerBlock); + blockNum %= (refsPerBlock * refsPerBlock); + indFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[indBlockOff]); + } + + indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1); + indBlockOff = blockNum / refsPerBlock; + blockNum %= refsPerBlock; + indFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[indBlockOff]); + } + + indBlock = ReadBlock(indFragNum, 0, gBlockSize, 0, 1); + diskFragNum = SWAP_BE32(((ufs_daddr_t *)indBlock)[blockNum]); + } + + buffer = ReadBlock(diskFragNum+fragNum, blockOffset, length, buffer, cache); + + return buffer; +} + +static long ReadFile( InodePtr fileInode, uint64_t * length, void * base, uint64_t offset ) +{ + long bytesLeft, curSize, curFrag; + char *buffer, *curAddr = (char *)base; + + bytesLeft = fileInode->di_size; + + if (offset > bytesLeft) { + printf("Offset is too large.\n"); + return -1; + } + + if ((*length == 0) || ((offset + *length) > bytesLeft)) { + *length = bytesLeft - offset; + } +/* + if (bytesLeft > kLoadSize) { + printf("File is too large.\n"); + return -1; + } +*/ + bytesLeft = *length; + curFrag = (offset / gBlockSize) * gFragsPerBlock; + offset %= gBlockSize; + + while (bytesLeft) { + curSize = gBlockSize; + if (curSize > bytesLeft) curSize = bytesLeft; + if ((offset + curSize) > gBlockSize) curSize = (gBlockSize - offset); + + buffer = ReadFileBlock(fileInode, curFrag, offset, curSize, curAddr, 0); + if (buffer == 0) break; + + if (offset != 0) offset = 0; + + curFrag += gFragsPerBlock; + curAddr += curSize; + bytesLeft -= curSize; + } + + return bytesLeft; +} Index: trunk/i386/libsaio/bios.h =================================================================== --- trunk/i386/libsaio/bios.h (revision 0) +++ trunk/i386/libsaio/bios.h (revision 1) @@ -0,0 +1,105 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Copyright 1994 NeXT Computer, Inc. + * All rights reserved. + */ + +#ifndef __LIBSAIO_BIOS_H +#define __LIBSAIO_BIOS_H + +#include + +typedef union { + unsigned int rx; + unsigned short rr; + struct { + unsigned char l; + unsigned char h; + } r; +} machineRegister_t; + +typedef struct { + unsigned short cf :1; + unsigned short :1; + unsigned short pf :1; + unsigned short :1; + unsigned short af :1; + unsigned short :1; + unsigned short zf :1; + unsigned short sf :1; + unsigned short tf :1; + unsigned short _if :1; + unsigned short df :1; + unsigned short of :1; + unsigned short iopl:2; + unsigned short nt :1; +} machineFlags_t; + +typedef struct { + unsigned int intno; + machineRegister_t eax; + machineRegister_t ebx; + machineRegister_t ecx; + machineRegister_t edx; + machineRegister_t edi; + machineRegister_t esi; + machineRegister_t ebp; + unsigned short cs; + unsigned short ds; + unsigned short es; + machineFlags_t flags; +} biosBuf_t; + +#define EBIOS_FIXED_DISK_ACCESS 0x01 +#define EBIOS_LOCKING_ACCESS 0x02 +#define EBIOS_ENHANCED_DRIVE_INFO 0x04 + +#define BASE_HD_DRIVE 0x80 + +#if 0 +/* + * ACPI defined memory range types. + */ +enum { + kMemoryRangeUsable = 1, // RAM usable by the OS. + kMemoryRangeReserved = 2, // Reserved. (Do not use) + kMemoryRangeACPI = 3, // ACPI tables. Can be reclaimed. + kMemoryRangeNVS = 4, // ACPI NVS memory. (Do not use) + + /* Undefined types should be treated as kMemoryRangeReserved */ +}; +#endif + +/* + * Memory range descriptor. + */ +typedef struct MemoryRange { + unsigned long long base; // 64-bit base address + unsigned long long length; // 64-bit length in bytes + unsigned long type; // type of memory range + unsigned long reserved; +} MemoryRange; + +#endif /* !__LIBSAIO_BIOS_H */ Index: trunk/i386/libsaio/SMBIOS.h =================================================================== --- trunk/i386/libsaio/SMBIOS.h (revision 0) +++ trunk/i386/libsaio/SMBIOS.h (revision 1) @@ -0,0 +1,63 @@ +/* + * Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 1.1 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +/* This file is a stripped-down version of the one found in the AppleSMBIOS project. + * Changes: + * - Don't use pragma pack but instead use GCC's packed attribute + * - Remove everything except the entry point structure. We don't need anything else. + */ + +#ifndef _LIBSAIO_SMBIOS_H +#define _LIBSAIO_SMBIOS_H + +/* + * Based on System Management BIOS Reference Specification v2.5 + */ + +typedef UInt8 SMBString; +typedef UInt8 SMBByte; +typedef UInt16 SMBWord; +typedef UInt32 SMBDWord; +typedef UInt64 SMBQWord; + +struct DMIEntryPoint { + SMBByte anchor[5]; + SMBByte checksum; + SMBWord tableLength; + SMBDWord tableAddress; + SMBWord structureCount; + SMBByte bcdRevision; +} __attribute__((packed)); + +struct SMBEntryPoint { + SMBByte anchor[4]; + SMBByte checksum; + SMBByte entryPointLength; + SMBByte majorVersion; + SMBByte minorVersion; + SMBWord maxStructureSize; + SMBByte entryPointRevision; + SMBByte formattedArea[5]; + struct DMIEntryPoint dmi; +} __attribute__((packed)); + +#endif /* !_LIBSAIO_SMBIOS_H */ Index: trunk/i386/libsaio/smbios_patcher.c =================================================================== --- trunk/i386/libsaio/smbios_patcher.c (revision 0) +++ trunk/i386/libsaio/smbios_patcher.c (revision 1) @@ -0,0 +1,703 @@ +/* + * Copyright 2008 mackerintel + */ + +#include "libsaio.h" +#include "acpi.h" +#include "bootstruct.h" +#include "efi_tables.h" +#include "fake_efi.h" +#include "platform.h" +#include "smbios_patcher.h" +#include "SMBIOS.h" + +#ifndef DEBUG_SMBIOS +#define DEBUG_SMBIOS 0 +#endif + +#if DEBUG_SMBIOS +#define DBG(x...) printf(x) +#else +#define DBG(x...) +#endif + + +// defaults for a MacBook +static char sm_macbook_defaults[][2][40]={ + {"SMbiosvendor", "Apple Inc." }, + {"SMbiosversion", "MB41.88Z.0073.B00.0809221748" }, + {"SMbiosdate", "04/01/2008" }, + {"SMmanufacter", "Apple Inc." }, + {"SMproductname", "MacBook4,1" }, + {"SMsystemversion", "1.0" }, + {"SMserial", "SOMESRLNMBR" }, + {"SMfamily", "MacBook" }, + {"SMboardmanufacter","Apple Inc." }, + {"SMboardproduct", "Mac-F42D89C8" }, + { "","" } +}; + +// defaults for a MacBook Pro +static char sm_macbookpro_defaults[][2][40]={ + {"SMbiosvendor", "Apple Inc." }, + {"SMbiosversion", "MBP41.88Z.0073.B00.0809221748" }, + {"SMbiosdate", "04/01/2008" }, + {"SMmanufacter", "Apple Inc." }, + {"SMproductname", "MacBookPro4,1" }, + {"SMsystemversion", "1.0" }, + {"SMserial", "SOMESRLNMBR" }, + {"SMfamily", "MacBookPro" }, + {"SMboardmanufacter","Apple Inc." }, + {"SMboardproduct", "Mac-F42D89C8" }, + { "","" } +}; + +// defaults for a Mac mini +static char sm_macmini_defaults[][2][40]={ + {"SMbiosvendor", "Apple Inc." }, + {"SMbiosversion", "MM21.88Z.009A.B00.0706281359" }, + {"SMbiosdate", "04/01/2008" }, + {"SMmanufacter", "Apple Inc." }, + {"SMproductname", "Macmini2,1" }, + {"SMsystemversion", "1.0" }, + {"SMserial", "SOMESRLNMBR" }, + {"SMfamily", "Napa Mac" }, + {"SMboardmanufacter","Apple Inc." }, + {"SMboardproduct", "Mac-F4208EAA" }, + { "","" } +}; + +// defaults for an iMac +static char sm_imac_defaults[][2][40]={ + {"SMbiosvendor", "Apple Inc." }, + {"SMbiosversion", "IM81.88Z.00C1.B00.0802091538" }, + {"SMbiosdate", "04/01/2008" }, + {"SMmanufacter", "Apple Inc." }, + {"SMproductname", "iMac8,1" }, + {"SMsystemversion", "1.0" }, + {"SMserial", "SOMESRLNMBR" }, + {"SMfamily", "Mac" }, + {"SMboardmanufacter","Apple Inc." }, + {"SMboardproduct", "Mac-F227BEC8" }, + { "","" } +}; + +// defaults for a Mac Pro +static char sm_macpro_defaults[][2][40]={ + {"SMbiosvendor", "Apple Computer, Inc." }, + {"SMbiosversion", "MP31.88Z.006C.B05.0802291410" }, + {"SMbiosdate", "04/01/2008" }, + {"SMmanufacter", "Apple Computer, Inc." }, + {"SMproductname", "MacPro3,1" }, + {"SMsystemversion", "1.0" }, + {"SMserial", "SOMESRLNMBR" }, + {"SMfamily", "MacPro" }, + {"SMboardmanufacter","Apple Computer, Inc." }, + {"SMboardproduct", "Mac-F4208DC8" }, + { "","" } +}; + +static char *sm_get_defstr(char *name, int table_num) +{ + int i; + char (*sm_defaults)[2][40]; + + if (Platform.CPU.Mobile) + if (Platform.CPU.NoCores > 1) + { + sm_defaults=sm_macbookpro_defaults; + } else { + sm_defaults=sm_macbook_defaults; + } + else + switch (Platform.CPU.NoCores) + { + case 1: sm_defaults=sm_macmini_defaults; break; + case 2: sm_defaults=sm_imac_defaults; break; + default: sm_defaults=sm_macpro_defaults; break; + } + + for (i=0;sm_defaults[i][0][0];i++) + if (!strcmp (sm_defaults[i][0],name)) + return sm_defaults[i][1]; + + // Shouldn't happen + printf ("Error: no default for '%s' known\n", name); + sleep (2); + return ""; +} + +static int sm_get_fsb (char *name, int table_num) +{ + return Platform.CPU.FSBFrequency/1000000; +} + +static int sm_get_cpu (char *name, int table_num) +{ + /* round CPU frequency */ +// return round2(Platform.CPU.CPUFrequency/1000000, 10); +// return roundup2(Platform.CPU.CPUFrequency/1000000, 100); + return Platform.CPU.CPUFrequency/1000000; +} + +static int sm_get_cputype (char *name, int table_num) +{ + int cores = Platform.CPU.NoCores; + + if (cores == 1) + return 0x0101; // <01 01> Intel Core Solo? + else if (cores == 2) + return 0x0301; // <01 03> Intel Core 2 Duo + else if (cores >= 4) + return 0x0501; // <01 05> Quad-Core Intel Xeon + else + return 0x0301; // Default to Core 2 Duo +} + +static int sm_get_memtype (char *name, int table_num) +{ + if(Platform.RAM.Type) + return Platform.RAM.Type; + else + return SMB_MEM_TYPE_DDR2; +} + +static int sm_get_memspeed (char *name, int table_num) +{ + if(Platform.RAM.Type) + return round2( Platform.RAM.Frequency / 500000, 2); + else + return 667; +} + +static char *sm_get_memvendor (char *name, int table_num) +{ + return "N/A"; +} + +static char *sm_get_memserial (char *name, int table_num) +{ + return "N/A"; +} + +static char *sm_get_mempartno (char *name, int table_num) +{ + return "N/A"; +} + +static int sm_one (int tablen) +{ + return 1; +} + +struct smbios_property smbios_properties[]= +{ + {.name="SMbiosvendor", .table_type= 0, .value_type=SMSTRING, .offset=0x04, .auto_str=sm_get_defstr }, + {.name="SMbiosversion", .table_type= 0, .value_type=SMSTRING, .offset=0x05, .auto_str=sm_get_defstr }, + {.name="SMbiosdate", .table_type= 0, .value_type=SMSTRING, .offset=0x08, .auto_str=sm_get_defstr }, + {.name="SMmanufacter", .table_type= 1, .value_type=SMSTRING, .offset=0x04, .auto_str=sm_get_defstr }, + {.name="SMproductname", .table_type= 1, .value_type=SMSTRING, .offset=0x05, .auto_str=sm_get_defstr }, + {.name="SMsystemversion", .table_type= 1, .value_type=SMSTRING, .offset=0x06, .auto_str=sm_get_defstr }, + {.name="SMserial", .table_type= 1, .value_type=SMSTRING, .offset=0x07, .auto_str=sm_get_defstr }, + {.name="SMUUID", .table_type= 1, .value_type=SMOWORD, .offset=0x08, .auto_oword=0 }, + {.name="SMfamily", .table_type= 1, .value_type=SMSTRING, .offset=0x1a, .auto_str=sm_get_defstr }, + {.name="SMboardmanufacter", .table_type= 2, .value_type=SMSTRING, .offset=0x04, .auto_str=sm_get_defstr }, + {.name="SMboardproduct", .table_type= 2, .value_type=SMSTRING, .offset=0x05, .auto_str=sm_get_defstr }, + {.name="SMexternalclock", .table_type= 4, .value_type=SMWORD, .offset=0x12, .auto_int=sm_get_fsb }, + {.name="SMmaximalclock", .table_type= 4, .value_type=SMWORD, .offset=0x14, .auto_int=sm_get_cpu }, + {.name="SMmemdevloc", .table_type=17, .value_type=SMSTRING, .offset=0x10, .auto_str=0 }, + {.name="SMmembankloc", .table_type=17, .value_type=SMSTRING, .offset=0x11, .auto_str=0 }, + {.name="SMmemtype", .table_type=17, .value_type=SMBYTE, .offset=0x12, .auto_int=sm_get_memtype}, + {.name="SMmemspeed", .table_type=17, .value_type=SMWORD, .offset=0x15, .auto_int=sm_get_memspeed}, + {.name="SMmemmanufacter", .table_type=17, .value_type=SMSTRING, .offset=0x17, .auto_str=sm_get_memvendor}, + {.name="SMmemserial", .table_type=17, .value_type=SMSTRING, .offset=0x18, .auto_str=sm_get_memserial}, + {.name="SMmempart", .table_type=17, .value_type=SMSTRING, .offset=0x1A, .auto_str=sm_get_mempartno}, + {.name="SMcputype", .table_type=131,.value_type=SMWORD, .offset=0x04, .auto_int=sm_get_cputype}, + {.name="SMbusspeed", .table_type=132,.value_type=SMWORD, .offset=0x04, .auto_str=0 } +}; + +struct smbios_table_description smbios_table_descriptions[]= +{ + {.type=0, .len=0x18, .numfunc=sm_one}, + {.type=1, .len=0x1b, .numfunc=sm_one}, + {.type=2, .len=0x0f, .numfunc=sm_one}, + {.type=4, .len=0x2a, .numfunc=sm_one}, + {.type=17, .len=0x1c, .numfunc=0}, + {.type=131, .len=0x06, .numfunc=sm_one}, + {.type=132, .len=0x06, .numfunc=sm_one} +}; + +static inline struct SMBEntryPoint * getAddressOfSmbiosTable() +{ + /* First see if we can even find the damn SMBIOS table + * The logic here is to start at 0xf0000 and end at 0xfffff iterating 16 bytes at a time looking + * for the SMBIOS entry-point structure anchor (literal ASCII "_SM_"). + */ + void *smbios_addr = (void*)SMBIOS_RANGE_START; + for(; (smbios_addr <= (void*)SMBIOS_RANGE_END) && (*(uint32_t*)smbios_addr != SMBIOS_ANCHOR_UINT32_LE); smbios_addr += 16) + ; + if(smbios_addr <= (void*)SMBIOS_RANGE_END) + { + /* NOTE: The specification does not specifically state what to do in the event of finding an + * SMBIOS anchor on an invalid table. It might be better to move this code into the for loop + * so that searching can continue. + */ + uint8_t csum = checksum8(smbios_addr, sizeof(struct SMBEntryPoint)); + /* The table already contains the checksum so we merely need to see if its checksum is now zero. */ + if(csum != 0) + { + printf("Found SMBIOS anchor but bad table checksum. Assuming no SMBIOS.\n"); + sleep(5); + smbios_addr = 0; + } + } + else + { + /* If this happens, it's possible that a PnP BIOS call can be done to retrieve the address of the table. + * The latest versions of the spec state that modern programs should not even attempt to do this. */ + printf("Unable to find SMBIOS table.\n"); + sleep(5); + smbios_addr = 0; + } + return smbios_addr; +} + +/* Compute necessary space requirements for new smbios */ +struct SMBEntryPoint * +smbios_dry_run (struct SMBEntryPoint * origsmbios) +{ + struct SMBEntryPoint *ret; + char *smbiostables=0; + char *tablesptr; + int origsmbiosnum=0; + int i, j; + int tablespresent[256]; + BOOL do_auto=1; + + getBoolForKey("SMBIOSdefaults",&do_auto,&bootInfo->bootConfig); + + for (i=0;i<256;i++) + tablespresent[i]=0; + ret=(struct SMBEntryPoint *)AllocateKernelMemory(sizeof (struct SMBEntryPoint)); + if (origsmbios) + { + smbiostables=(char *)origsmbios->dmi.tableAddress; + origsmbiosnum=origsmbios->dmi.structureCount; + } + // _SM_ + ret->anchor[0]=0x5f; + ret->anchor[1]=0x53; + ret->anchor[2]=0x4d; + ret->anchor[3]=0x5f; + ret->entryPointLength=sizeof (*ret); + ret->majorVersion=2; + ret->minorVersion=1; + ret->maxStructureSize=0; + ret->entryPointRevision=0; + for (i=0;i<5;i++) + ret->formattedArea[i]=0; + //_DMI_ + ret->dmi.anchor[0]=0x5f; + ret->dmi.anchor[1]=0x44; + ret->dmi.anchor[2]=0x4d; + ret->dmi.anchor[3]=0x49; + ret->dmi.anchor[4]=0x5f; + ret->dmi.tableLength=0; + ret->dmi.tableAddress=0; + ret->dmi.structureCount=0; + ret->dmi.bcdRevision=0x21; + tablesptr=smbiostables; + if (smbiostables) + for (i=0;ilength; + stringsptr=tablesptr; + for (;tablesptr[0]!=0 || tablesptr[1]!=0;tablesptr++); + tablesptr+=2; + stringlen=tablesptr-stringsptr-1; + if (stringlen==1) + stringlen=0; + for (j=0;jtype]+1); + if (smbios_properties[j].table_type==cur->type + && smbios_properties[j].value_type==SMSTRING + && (getValueForKey(smbios_properties[j].name, &str, &size, &bootInfo->smbiosConfig) + || getValueForKey(altname,&str, &size, &bootInfo->smbiosConfig))) + stringlen+=size+1; + else if (smbios_properties[j].table_type==cur->type + && smbios_properties[j].value_type==SMSTRING + && do_auto && smbios_properties[j].auto_str) + stringlen+=strlen(smbios_properties[j].auto_str(smbios_properties[j].name,tablespresent[cur->type]))+1; + } + if (stringlen==0) + stringlen=1; + stringlen++; + if (ret->maxStructureSizelength+stringlen) + ret->maxStructureSize=cur->length+stringlen; + ret->dmi.tableLength+=cur->length+stringlen; + ret->dmi.structureCount++; + tablespresent[cur->type]++; + } + for (i=0;ismbiosConfig)) + numnec=-1; + if (numnec==-1 && do_auto && smbios_table_descriptions[i].numfunc) + numnec=smbios_table_descriptions[i].numfunc (smbios_table_descriptions[i].type); + + while (tablespresent[smbios_table_descriptions[i].type]smbiosConfig) + || getValueForKey(smbios_properties[j].name,&str, &size, &bootInfo->smbiosConfig))) + stringlen+=size+1; + else if (smbios_properties[j].table_type + ==smbios_table_descriptions[i].type + && smbios_properties[j].value_type==SMSTRING + && do_auto && smbios_properties[j].auto_str) + stringlen+=strlen(smbios_properties[j].auto_str + (smbios_properties[j].name, + tablespresent[smbios_table_descriptions[i].type]))+1; + } + if (stringlen==0) + stringlen=1; + stringlen++; + if (ret->maxStructureSizemaxStructureSize=smbios_table_descriptions[i].len+stringlen; + ret->dmi.tableLength+=smbios_table_descriptions[i].len+stringlen; + ret->dmi.structureCount++; + tablespresent[smbios_table_descriptions[i].type]++; + } + } + return ret; +} + +void +smbios_real_run (struct SMBEntryPoint * origsmbios, + struct SMBEntryPoint * newsmbios) +{ + char *smbiostables=0; + char *tablesptr, *newtablesptr; + int origsmbiosnum=0; + // bitmask of used handles + uint8_t handles[8192]; + uint16_t nexthandle=0; + int i, j; + int tablespresent[256]; + BOOL do_auto=1; + + getBoolForKey("SMBIOSdefaults",&do_auto,&bootInfo->bootConfig); + + for (i=0;i<256;i++) + tablespresent[i]=0; + + memset (handles,0,8192); + newsmbios->dmi.tableAddress=(uint32_t)AllocateKernelMemory(newsmbios->dmi.tableLength); + if (origsmbios) + { + smbiostables=(char *) origsmbios->dmi.tableAddress; + origsmbiosnum=origsmbios->dmi.structureCount; + } + tablesptr=smbiostables; + newtablesptr=(char *) newsmbios->dmi.tableAddress; + if (smbiostables) + for (i=0;ihandle)/8]|=1<<((oldcur->handle)%8); + + memcpy (newcur,oldcur, oldcur->length); + + tablesptr+=oldcur->length; + stringsptr=tablesptr; + newtablesptr+=oldcur->length; + for (;tablesptr[0]!=0 || tablesptr[1]!=0;tablesptr++) + if (tablesptr[0]==0) + nstrings++; + if (tablesptr!=stringsptr) + nstrings++; + tablesptr+=2; + memcpy (newtablesptr,stringsptr,tablesptr-stringsptr); + //point to next possible space for a string + newtablesptr+=tablesptr-stringsptr-1; + if (nstrings==0) + newtablesptr--; + for (j=0;jtype]+1); + + if (smbios_properties[j].table_type==newcur->type) + switch (smbios_properties[j].value_type) + { + case SMSTRING: + if (getValueForKey(altname,&str, &size, &bootInfo->smbiosConfig) + ||getValueForKey(smbios_properties[j].name,&str, &size, &bootInfo->smbiosConfig)) + { + memcpy (newtablesptr, str,size); + newtablesptr[size]=0; + newtablesptr+=size+1; + *((uint8_t*)(((char*)newcur)+smbios_properties[j].offset))=++nstrings; + } + else if (do_auto && smbios_properties[j].auto_str) + { + str=smbios_properties[j].auto_str(smbios_properties[j].name,tablespresent[newcur->type]); + size=strlen (str); + memcpy (newtablesptr, str,size); + newtablesptr[size]=0; + newtablesptr+=size+1; + *((uint8_t*)(((char*)newcur)+smbios_properties[j].offset))=++nstrings; + } + + break; + + case SMOWORD: + if (getValueForKey(altname,&str, &size, &bootInfo->smbiosConfig) + ||getValueForKey(smbios_properties[j].name,&str, &size, &bootInfo->smbiosConfig)) + { + int k=0, t=0, kk=0; + const char *ptr=str; + memset(((char*)newcur)+smbios_properties[j].offset, 0, 16); + while (ptr-str=2 && ptr[0]=='0' && (ptr[1]=='x' || ptr[1]=='X')) + ptr+=2; + for (;ptr-str='0' && *ptr<='9') + (t=(t<<4)|(*ptr-'0')),kk++; + if (*ptr>='a' && *ptr<='f') + (t=(t<<4)|(*ptr-'a'+10)),kk++; + if (*ptr>='A' && *ptr<='F') + (t=(t<<4)|(*ptr-'A'+10)),kk++; + if (kk==2) + { + *((uint8_t*)(((char*)newcur)+smbios_properties[j].offset+k))=t; + k++; + kk=0; + t=0; + } + } + } + break; + + case SMBYTE: + if (getIntForKey(altname,&num,&bootInfo->smbiosConfig) + ||getIntForKey(smbios_properties[j].name,&num,&bootInfo->smbiosConfig)) + *((uint8_t*)(((char*)newcur)+smbios_properties[j].offset))=num; + else if (do_auto && smbios_properties[j].auto_int) + *((uint8_t*)(((char*)newcur)+smbios_properties[j].offset)) + =smbios_properties[j].auto_int(smbios_properties[j].name, tablespresent[newcur->type]); + break; + + case SMWORD: + if (getIntForKey(altname,&num,&bootInfo->smbiosConfig) + ||getIntForKey(smbios_properties[j].name,&num,&bootInfo->smbiosConfig)) + *((uint16_t*)(((char*)newcur)+smbios_properties[j].offset))=num; + else if (do_auto && smbios_properties[j].auto_int) + *((uint16_t*)(((char*)newcur)+smbios_properties[j].offset)) + =smbios_properties[j].auto_int(smbios_properties[j].name, tablespresent[newcur->type]); + break; + } + } + if (nstrings==0) + { + newtablesptr[0]=0; + newtablesptr++; + } + newtablesptr[0]=0; + newtablesptr++; + tablespresent[newcur->type]++; + } + for (i=0;ismbiosConfig)) + numnec=-1; + if (numnec==-1 && do_auto && smbios_table_descriptions[i].numfunc) + numnec=smbios_table_descriptions[i].numfunc (smbios_table_descriptions[i].type); + + while (tablespresent[smbios_table_descriptions[i].type]handle=nexthandle; + handles[nexthandle/8]|=1<<(nexthandle%8); + newcur->type=smbios_table_descriptions[i].type; + newcur->length=smbios_table_descriptions[i].len; + newtablesptr+=smbios_table_descriptions[i].len; + for (j=0;jtype]+1); + + if (smbios_properties[j].table_type==newcur->type) + switch (smbios_properties[j].value_type) + { + case SMSTRING: + if (getValueForKey(altname,&str, &size, &bootInfo->smbiosConfig) + ||getValueForKey(smbios_properties[j].name,&str, &size, &bootInfo->smbiosConfig)) + { + memcpy (newtablesptr, str,size); + newtablesptr[size]=0; + newtablesptr+=size+1; + *((uint8_t*)(((char*)newcur)+smbios_properties[j].offset))=++nstrings; + } + else if (do_auto && smbios_properties[j].auto_str) + { + str=smbios_properties[j].auto_str(smbios_properties[j].name, tablespresent[newcur->type]); + size=strlen (str); + memcpy (newtablesptr, str,size); + newtablesptr[size]=0; + newtablesptr+=size+1; + *((uint8_t*)(((char*)newcur)+smbios_properties[j].offset))=++nstrings; + } + break; + + case SMOWORD: + if (getValueForKey(altname,&str, &size, &bootInfo->smbiosConfig) + ||getValueForKey(smbios_properties[j].name,&str, &size, &bootInfo->smbiosConfig)) + { + int k=0, t=0, kk=0; + const char *ptr=str; + memset(((char*)newcur)+smbios_properties[j].offset, 0, 16); + while (ptr-str=2 && ptr[0]=='0' && (ptr[1]=='x' || ptr[1]=='X')) + ptr+=2; + for (;ptr-str='0' && *ptr<='9') + (t=(t<<4)|(*ptr-'0')),kk++; + if (*ptr>='a' && *ptr<='f') + (t=(t<<4)|(*ptr-'a'+10)),kk++; + if (*ptr>='A' && *ptr<='F') + (t=(t<<4)|(*ptr-'A'+10)),kk++; + if (kk==2) + { + *((uint8_t*)(((char*)newcur)+smbios_properties[j].offset+k))=t; + k++; + kk=0; + t=0; + } + } + } + break; + + case SMBYTE: + if (getIntForKey(altname,&num,&bootInfo->smbiosConfig) + ||getIntForKey(smbios_properties[j].name,&num,&bootInfo->smbiosConfig)) + *((uint8_t*)(((char*)newcur)+smbios_properties[j].offset))=num; + else if (do_auto && smbios_properties[j].auto_int) + *((uint8_t*)(((char*)newcur)+smbios_properties[j].offset)) + =smbios_properties[j].auto_int(smbios_properties[j].name, tablespresent[newcur->type]); + break; + + case SMWORD: + if (getIntForKey(altname,&num,&bootInfo->smbiosConfig) + ||getIntForKey(smbios_properties[j].name,&num,&bootInfo->smbiosConfig)) + *((uint16_t*)(((char*)newcur)+smbios_properties[j].offset))=num; + else if (do_auto && smbios_properties[j].auto_int) + *((uint16_t*)(((char*)newcur)+smbios_properties[j].offset)) + =smbios_properties[j].auto_int(smbios_properties[j].name, tablespresent[newcur->type]); + break; + } + } + if (nstrings==0) + { + newtablesptr[0]=0; + newtablesptr++; + } + newtablesptr[0]=0; + newtablesptr++; + tablespresent[smbios_table_descriptions[i].type]++; + } + } + newsmbios->dmi.checksum=0; + newsmbios->dmi.checksum=256-checksum8 (&newsmbios->dmi,sizeof (newsmbios->dmi)); + newsmbios->checksum=0; + newsmbios->checksum=256-checksum8 (newsmbios,sizeof (*newsmbios)); + verbose("Patched DMI Table.\n"); +} + +inline struct SMBEntryPoint * +getSmbios() +{ + const char *smbios_filename; + char dirSpec[512]; + int len; + struct SMBEntryPoint *orig_address; + struct SMBEntryPoint *new_address; + orig_address=getAddressOfSmbiosTable(); + + if (!getValueForKey("SMBIOS", &smbios_filename, &len, &bootInfo->bootConfig)) + smbios_filename = "smbios.plist"; + + sprintf(dirSpec, "%s", smbios_filename); + if (loadConfigFile(dirSpec, &bootInfo->smbiosConfig) == -1) + { + sprintf(dirSpec, "/Extra/%s", smbios_filename); + if (loadConfigFile(dirSpec, &bootInfo->smbiosConfig) == -1) + { + sprintf(dirSpec, "bt(0,0)/Extra/%s", smbios_filename); + if (loadConfigFile(dirSpec, &bootInfo->smbiosConfig) == -1) + { + verbose("No SMBIOS replacement found.\n"); + } + } + } + +// if( (loadConfigFile("/Extra/smbios.plist", &bootInfo->smbiosConfig)) == -1 ) +// loadConfigFile("bt(0,0)/Extra/smbios.plist", &bootInfo->smbiosConfig); // TODO: do we need this ? + + new_address = smbios_dry_run(orig_address); + smbios_real_run(orig_address, new_address); + return new_address; +} Index: trunk/i386/libsaio/ufs.h =================================================================== --- trunk/i386/libsaio/ufs.h (revision 0) +++ trunk/i386/libsaio/ufs.h (revision 1) @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +extern long UFSInitPartition(CICell ih); +extern long UFSLoadFile(CICell ih, char * filePath); +extern long UFSReadFile( CICell ih, char * filePath, void * base, uint64_t offset, uint64_t length ); +extern long UFSGetDirEntry(CICell ih, char * dirPath, long * dirIndex, + char ** name, long * flags, long * time, + FinderInfo * finderInfo, long * infoValid); +extern void UFSGetDescription(CICell ih, char *str, long strMaxLen); +extern long UFSGetFileBlock(CICell ih, char *str, unsigned long long *firstBlock); +extern long UFSGetUUID(CICell ih, char *uuidStr); +extern void UFSFree(CICell ih); + Index: trunk/i386/libsaio/smbios_patcher.h =================================================================== --- trunk/i386/libsaio/smbios_patcher.h (revision 0) +++ trunk/i386/libsaio/smbios_patcher.h (revision 1) @@ -0,0 +1,57 @@ +/* + * Copyright 2008 mackerintel + */ + +#ifndef __LIBSAIO_SMBIOS_PATCHER_H +#define __LIBSAIO_SMBIOS_PATCHER_H + +#include "libsaio.h" + +extern EFI_GUID gEfiAcpiTableGuid; +extern EFI_GUID gEfiAcpi20TableGuid; + +/* From Foundation/Efi/Guid/Smbios/SmBios.h */ +/* Modified to wrap Data4 array init with {} */ +#define EFI_SMBIOS_TABLE_GUID \ +{ \ +0xeb9d2d31, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} \ +} + +/* From Foundation/Efi/Guid/Smbios/SmBios.c */ +//EFI_GUID const gEfiSmbiosTableGuid = EFI_SMBIOS_TABLE_GUID; + +#define SMBIOS_RANGE_START 0x000F0000 +#define SMBIOS_RANGE_END 0x000FFFFF + +/* '_SM_' in little endian: */ +#define SMBIOS_ANCHOR_UINT32_LE 0x5f4d535f + +struct smbios_table_header +{ + uint8_t type; + uint8_t length; + uint16_t handle; +} __attribute__ ((packed)); + +struct smbios_property +{ + char *name; + uint8_t table_type; + enum {SMSTRING, SMWORD, SMBYTE, SMOWORD} value_type; + int offset; + //union { + int (*auto_int) (char *name, int table_num); + char * (*auto_str) (char *name, int table_num); + char * (*auto_oword) (char *name, int table_num); + //}; +}; + +struct smbios_table_description +{ + uint8_t type; + int len; + int (*numfunc)(int tablen); +}; + + +#endif /* !__LIBSAIO_SMBIOS_PATCHER_H */ Index: trunk/i386/libsaio/nbp_cmd.h =================================================================== --- trunk/i386/libsaio/nbp_cmd.h (revision 0) +++ trunk/i386/libsaio/nbp_cmd.h (revision 1) @@ -0,0 +1,85 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +#ifndef __LIBSAIO_NBP_CMD_H +#define __LIBSAIO_NBP_CMD_H + +#include + +/*========================================================================== + * NBP return status codes. + */ +typedef enum { + nbpStatusSuccess = 0, + nbpStatusFailed, + nbpStatusInvalid, +} nbpStatus_t; + +/*========================================================================== + * NBP commands codes. + */ +typedef enum { + nbpCommandTFTPReadFile = 1, + nbpCommandTFTPGetFileSize, + nbpCommandUnloadBaseCode, +} nbpCommandCode_t; + +/*========================================================================== + * NBP commands. + */ +typedef struct { + UInt32 status; /* return code from NBP */ +} nbpCommandHeader_s; + +typedef struct { + UInt32 status; /* return code from NBP */ + UInt8 filename[128]; /* name of file to be downloaded */ + UInt32 bufferSize; /* size of the download buffer */ + UInt32 buffer; /* physical address of the download buffer */ +} nbpCommandTFTPReadFile_s; + +typedef struct { + UInt32 status; /* return code from NBP */ + UInt8 filename[128]; /* name of file to be downloaded */ + UInt32 filesize; /* size of the file specified */ +} nbpCommandTFTPGetFileSize_s; + +typedef struct { + UInt32 status; /* return code from NBP */ + UInt8 sname[64]; /* server name */ + UInt32 CIP; /* client IP address */ + UInt32 SIP; /* server IP address */ + UInt32 GIP; /* gateway IP address */ +} nbpCommandGetNetworkInfo_s; + +/*========================================================================== + * An union of all NBP command structures. + */ +typedef union { + nbpCommandHeader_s header; + nbpCommandTFTPReadFile_s tftpReadFile; + nbpCommandTFTPGetFileSize_s tftpFileSize; +} nbpCommand_u; + +#endif /* !__LIBSAIO_NBP_CMD_H */ Index: trunk/i386/libsaio/memory.c =================================================================== --- trunk/i386/libsaio/memory.c (revision 0) +++ trunk/i386/libsaio/memory.c (revision 1) @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +#include "sl.h" +#include "saio_internal.h" +#include "bootstruct.h" +#include "device_tree.h" + +static long gImageLastKernelAddr; + +#define kPageSize 4096 +#define RoundPage(x) ((((unsigned)(x)) + kPageSize - 1) & ~(kPageSize - 1)) + + +long +AllocateMemoryRange(char * rangeName, long start, long length, long type) +{ + char *nameBuf; + uint32_t *buffer; + + nameBuf = malloc(strlen(rangeName) + 1); + if (nameBuf == 0) return -1; + strcpy(nameBuf, rangeName); + + buffer = malloc(2 * sizeof(uint32_t)); + if (buffer == 0) return -1; + + buffer[0] = start; + buffer[1] = length; + + DT__AddProperty(gMemoryMapNode, nameBuf, 2 * sizeof(uint32_t), (char *)buffer); + + return 0; +} + +#if 0 +long +AllocateMemoryRange(char * rangeName, long start, long length, long type) +{ + if ( bootArgs->numBootDrivers < NDRIVERS ) + { + int num = bootArgs->numBootDrivers; + + bootArgs->driverConfig[num].address = start; + bootArgs->driverConfig[num].size = length; + bootArgs->driverConfig[num].type = type; + bootArgs->numBootDrivers++; + } + else + { + stop( "AllocateMemoryRange error" ); + } + return 0; +} +#endif + +long +AllocateKernelMemory( long inSize ) +{ + long addr; + + if (gImageLastKernelAddr == 0) { + gImageLastKernelAddr = RoundPage( bootArgs->kaddr + + bootArgs->ksize ); + } + addr = gImageLastKernelAddr; + gImageLastKernelAddr += RoundPage(inSize); + + if ( gImageLastKernelAddr >= (KERNEL_ADDR + KERNEL_LEN) ) { + stop ("AllocateKernelMemory error"); + } + + bootArgs->ksize = gImageLastKernelAddr - bootArgs->kaddr; + + return addr; +} Index: trunk/i386/libsaio/bios.s =================================================================== --- trunk/i386/libsaio/bios.s (revision 0) +++ trunk/i386/libsaio/bios.s (revision 1) @@ -0,0 +1,184 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Copyright 1993 NeXT Computer, Inc. + * All rights reserved. + * + * Harness for calling real-mode BIOS functions. + */ + +/* Copyright 2007 David Elliott + 2007-12-30 dfe + - Enhanced code to use specified DS register when doing BIOS interrupt + - Fixed movl %ax,new_es bug which assembler was interpreting as + movl %eax,new_es which was overwriting the next word. + */ +#include +#include "memory.h" + +#define data32 .byte 0x66 +#define addr32 .byte 0x67 + +#define O_INT 0 +#define O_EAX 4 +#define O_EBX 8 +#define O_ECX 12 +#define O_EDX 16 +#define O_EDI 20 +#define O_ESI 24 +#define O_EBP 28 +#define O_CS 32 +#define O_DS 34 +#define O_ES 36 +#define O_FLG 38 + + .section __INIT,__data // turbo - Data that must be in the first segment + +/* Saved registers: + These used to be (and in theory ought to be) located in __DATA,__bss. + The problem is that the larger the binary grows, more of the BSS gets + pushed into the next real-mode segment. Doing it this way we waste 24 + bytes in the binary that our loader (e.g. boot1) must now load. But the + advantage is that we relocate this data to ensure it stays in the first + real-mode segment. Therefore, depending on link order, quite a lot of + new data, and possibly a lot of new executable code can be added to the + binary since with this change the BSS and most of the DATA is now only + accessed from protected mode where real-mode segment limits don't apply. + + With this change, plus the earlier change to respect DS (e.g. use huge + pointers), the binary can grow much larger, currently up to exactly 63.5k + which is the maximum that the first-stage bootsectors can handle. To get + more than that more changes are needed. In that case we would have to + play with Mach-O segments to ensure real-mode code and data got stuffed + well within the first 63.5k. Furthermore, we'd have to adjust the boot + sectors to allow them to span segments. + + Since this change alone only gains us about 4k more than where we're at + now (which is not anything to scoff at) it won't be very long before we + need to start using Mach-O segments to force the linker to locate certain + bits of code and data within the first 63.5k and modify the loaders to + be able to load more than 63.5k. + */ + .align 2 +save_eax: .space 4 + .align 2 +save_edx: .space 4 + .align 1 +save_es: .space 2 + .align 1 +save_flag: .space 2 + .align 2 +new_eax: .space 4 + .align 2 +new_edx: .space 4 + .align 1 +new_es: .space 2 + .align 1 +new_ds: .space 2 + + .section __INIT,__text // turbo - This code must reside within the first segment + + +/*============================================================================ + * Call real-mode BIOS INT functions. + * + */ +LABEL(_bios) + enter $0, $0 + pushal + + movl 8(%ebp), %edx // address of save area + movb O_INT(%edx), %al // save int number + movb %al, do_int+1 + + movl O_EBX(%edx), %ebx + movl O_ECX(%edx), %ecx + movl O_EDI(%edx), %edi + movl O_ESI(%edx), %esi + movl O_EBP(%edx), %ebp + movl %edx, save_edx + movl O_EAX(%edx), %eax + movl %eax, new_eax + movl O_EDX(%edx), %eax + movl %eax, new_edx + movw O_ES(%edx), %ax + movw %ax, new_es + movw O_DS(%edx), %ax + movw %ax, new_ds + + call __prot_to_real + + data32 + addr32 + mov OFFSET16(new_eax), %eax + data32 + addr32 + mov OFFSET16(new_edx), %edx + data32 + addr32 + mov OFFSET16(new_es), %es + + push %ds // Save DS + // Replace DS. WARNING: Don't access data until it's restored! + addr32 + data32 + mov OFFSET16(new_ds), %ds + +do_int: + int $0x00 + pop %ds // Restore DS before we do anything else + + pushf + data32 + addr32 + movl %eax, OFFSET16(save_eax) + popl %eax // actually pop %ax + addr32 + movl %eax, OFFSET16(save_flag) // actually movw + mov %es, %ax + addr32 + movl %eax, OFFSET16(save_es) // actually movw + data32 + call __real_to_prot + + movl %edx, new_edx // save new edx before clobbering + movl save_edx, %edx + movl new_edx, %eax // now move it into buffer + movl %eax, O_EDX(%edx) + movl save_eax, %eax + movl %eax, O_EAX(%edx) + movw save_es, %ax + movw %ax, O_ES(%edx) + movw save_flag, %ax + movw %ax, O_FLG(%edx) + movl %ebx, O_EBX(%edx) + movl %ecx, O_ECX(%edx) + movl %edi, O_EDI(%edx) + movl %esi, O_ESI(%edx) + movl %ebp, O_EBP(%edx) + + popal + leave + + ret Index: trunk/i386/libsaio/msdos_private.h =================================================================== --- trunk/i386/libsaio/msdos_private.h (revision 0) +++ trunk/i386/libsaio/msdos_private.h (revision 1) @@ -0,0 +1,351 @@ +/* + * Copyright (c) 2004 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Written by Paul Popelka (paulp@uts.amdahl.com) + * + * You can do anything you want with this software, just don't say you wrote + * it, and don't remove this notice. + * + * This software is provided "as is". + * + * The author supplies this software to be publicly redistributed on the + * understanding that the author is not responsible for the correct + * functioning of this software in any circumstances and is not liable for + * any damages caused by this software. + * + * October 1992 + */ + +/* + * Format of a boot sector. This is the first sector on a DOS floppy disk + * or the fist sector of a partition on a hard disk. But, it is not the + * first sector of a partitioned hard disk. + */ +struct bootsector33 { + u_int8_t bsJump[3]; /* jump inst E9xxxx or EBxx90 */ + int8_t bsOemName[8]; /* OEM name and version */ + int8_t bsBPB[19]; /* BIOS parameter block */ + int8_t bsDriveNumber; /* drive number (0x80) */ + int8_t bsBootCode[479]; /* pad so struct is 512b */ + u_int8_t bsBootSectSig0; + u_int8_t bsBootSectSig1; +#define BOOTSIG0 0x55 +#define BOOTSIG1 0xaa +}; + +struct extboot { + int8_t exDriveNumber; /* drive number (0x80) */ + int8_t exReserved1; /* reserved */ + int8_t exBootSignature; /* ext. boot signature (0x29) */ +#define EXBOOTSIG 0x29 + int8_t exVolumeID[4]; /* volume ID number */ + int8_t exVolumeLabel[11]; /* volume label */ + int8_t exFileSysType[8]; /* fs type (FAT12 or FAT16) */ +}; + +struct bootsector50 { + u_int8_t bsJump[3]; /* jump inst E9xxxx or EBxx90 */ + int8_t bsOemName[8]; /* OEM name and version */ + int8_t bsBPB[25]; /* BIOS parameter block */ + int8_t bsExt[26]; /* Bootsector Extension */ + int8_t bsBootCode[448]; /* pad so structure is 512b */ + u_int8_t bsBootSectSig0; + u_int8_t bsBootSectSig1; +#define BOOTSIG0 0x55 +#define BOOTSIG1 0xaa +}; + +struct bootsector710 { + u_int8_t bsJump[3]; /* jump inst E9xxxx or EBxx90 */ + int8_t bsOEMName[8]; /* OEM name and version */ + int8_t bsBPB[53]; /* BIOS parameter block */ + int8_t bsExt[26]; /* Bootsector Extension */ + int8_t bsBootCode[420]; /* pad so structure is 512b */ + u_int8_t bsBootSectSig0; + u_int8_t bsBootSectSig1; +#define BOOTSIG0 0x55 +#define BOOTSIG1 0xaa +}; + +union bootsector { + struct bootsector33 bs33; + struct bootsector50 bs50; + struct bootsector710 bs710; +}; + + +/* BPB */ + +/* + * BIOS Parameter Block (BPB) for DOS 3.3 + */ +struct bpb33 { + u_int16_t bpbBytesPerSec; /* bytes per sector */ + u_int8_t bpbSecPerClust; /* sectors per cluster */ + u_int16_t bpbResSectors; /* number of reserved sectors */ + u_int8_t bpbFATs; /* number of FATs */ + u_int16_t bpbRootDirEnts; /* number of root directory entries */ + u_int16_t bpbSectors; /* total number of sectors */ + u_int8_t bpbMedia; /* media descriptor */ + u_int16_t bpbFATsecs; /* number of sectors per FAT */ + u_int16_t bpbSecPerTrack; /* sectors per track */ + u_int16_t bpbHeads; /* number of heads */ + u_int16_t bpbHiddenSecs; /* number of hidden sectors */ +} __attribute__((packed)); + +/* + * BPB for DOS 5.0 The difference is bpbHiddenSecs is a short for DOS 3.3, + * and bpbHugeSectors is not in the 3.3 bpb. + */ +struct bpb50 { + u_int16_t bpbBytesPerSec; /* bytes per sector */ + u_int8_t bpbSecPerClust; /* sectors per cluster */ + u_int16_t bpbResSectors; /* number of reserved sectors */ + u_int8_t bpbFATs; /* number of FATs */ + u_int16_t bpbRootDirEnts; /* number of root directory entries */ + u_int16_t bpbSectors; /* total number of sectors */ + u_int8_t bpbMedia; /* media descriptor */ + u_int16_t bpbFATsecs; /* number of sectors per FAT */ + u_int16_t bpbSecPerTrack; /* sectors per track */ + u_int16_t bpbHeads; /* number of heads */ + u_int32_t bpbHiddenSecs; /* # of hidden sectors */ + u_int32_t bpbHugeSectors; /* # of sectors if bpbSectors == 0 */ +} __attribute__((packed)); + +/* + * BPB for DOS 7.10 (FAT32). This one has a few extensions to bpb50. + */ +struct bpb710 { + u_int16_t bpbBytesPerSec; /* bytes per sector */ + u_int8_t bpbSecPerClust; /* sectors per cluster */ + u_int16_t bpbResSectors; /* number of reserved sectors */ + u_int8_t bpbFATs; /* number of FATs */ + u_int16_t bpbRootDirEnts; /* number of root directory entries */ + u_int16_t bpbSectors; /* total number of sectors */ + u_int8_t bpbMedia; /* media descriptor */ + u_int16_t bpbFATsecs; /* number of sectors per FAT */ + u_int16_t bpbSecPerTrack; /* sectors per track */ + u_int16_t bpbHeads; /* number of heads */ + u_int32_t bpbHiddenSecs; /* # of hidden sectors */ + u_int32_t bpbHugeSectors; /* # of sectors if bpbSectors == 0 */ + u_int32_t bpbBigFATsecs; /* like bpbFATsecs for FAT32 */ + u_int16_t bpbExtFlags; /* extended flags: */ +#define FATNUM 0xf /* mask for numbering active FAT */ +#define FATMIRROR 0x80 /* FAT is mirrored (like it always was) */ + u_int16_t bpbFSVers; /* filesystem version */ +#define FSVERS 0 /* currently only 0 is understood */ + u_int32_t bpbRootClust; /* start cluster for root directory */ + u_int16_t bpbFSInfo; /* filesystem info structure sector */ + u_int16_t bpbBackup; /* backup boot sector */ + /* There is a 12 byte filler here, but we ignore it */ +} __attribute__((packed)); + +#if 0 +/* + * BIOS Parameter Block (BPB) for DOS 3.3 + */ +struct byte_bpb33 { + int8_t bpbBytesPerSec[2]; /* bytes per sector */ + int8_t bpbSecPerClust; /* sectors per cluster */ + int8_t bpbResSectors[2]; /* number of reserved sectors */ + int8_t bpbFATs; /* number of FATs */ + int8_t bpbRootDirEnts[2]; /* number of root directory entries */ + int8_t bpbSectors[2]; /* total number of sectors */ + int8_t bpbMedia; /* media descriptor */ + int8_t bpbFATsecs[2]; /* number of sectors per FAT */ + int8_t bpbSecPerTrack[2]; /* sectors per track */ + int8_t bpbHeads[2]; /* number of heads */ + int8_t bpbHiddenSecs[2]; /* number of hidden sectors */ +}; + +/* + * BPB for DOS 5.0 The difference is bpbHiddenSecs is a short for DOS 3.3, + * and bpbHugeSectors is not in the 3.3 bpb. + */ +struct byte_bpb50 { + int8_t bpbBytesPerSec[2]; /* bytes per sector */ + int8_t bpbSecPerClust; /* sectors per cluster */ + int8_t bpbResSectors[2]; /* number of reserved sectors */ + int8_t bpbFATs; /* number of FATs */ + int8_t bpbRootDirEnts[2]; /* number of root directory entries */ + int8_t bpbSectors[2]; /* total number of sectors */ + int8_t bpbMedia; /* media descriptor */ + int8_t bpbFATsecs[2]; /* number of sectors per FAT */ + int8_t bpbSecPerTrack[2]; /* sectors per track */ + int8_t bpbHeads[2]; /* number of heads */ + int8_t bpbHiddenSecs[4]; /* number of hidden sectors */ + int8_t bpbHugeSectors[4]; /* # of sectors if bpbSectors == 0 */ +}; + +/* + * BPB for DOS 7.10 (FAT32). This one has a few extensions to bpb50. + */ +struct byte_bpb710 { + u_int8_t bpbBytesPerSec[2]; /* bytes per sector */ + u_int8_t bpbSecPerClust; /* sectors per cluster */ + u_int8_t bpbResSectors[2]; /* number of reserved sectors */ + u_int8_t bpbFATs; /* number of FATs */ + u_int8_t bpbRootDirEnts[2]; /* number of root directory entries */ + u_int8_t bpbSectors[2]; /* total number of sectors */ + u_int8_t bpbMedia; /* media descriptor */ + u_int8_t bpbFATsecs[2]; /* number of sectors per FAT */ + u_int8_t bpbSecPerTrack[2]; /* sectors per track */ + u_int8_t bpbHeads[2]; /* number of heads */ + u_int8_t bpbHiddenSecs[4]; /* # of hidden sectors */ + u_int8_t bpbHugeSectors[4]; /* # of sectors if bpbSectors == 0 */ + u_int8_t bpbBigFATsecs[4]; /* like bpbFATsecs for FAT32 */ + u_int8_t bpbExtFlags[2]; /* extended flags: */ + u_int8_t bpbFSVers[2]; /* filesystem version */ + u_int8_t bpbRootClust[4]; /* start cluster for root directory */ + u_int8_t bpbFSInfo[2]; /* filesystem info structure sector */ + u_int8_t bpbBackup[2]; /* backup boot sector */ + /* There is a 12 byte filler here, but we ignore it */ +}; +#endif + +/* + * FAT32 FSInfo block. + */ +struct fsinfo { + u_int8_t fsisig1[4]; + u_int8_t fsifill1[480]; + u_int8_t fsisig2[4]; + u_int8_t fsinfree[4]; + u_int8_t fsinxtfree[4]; + u_int8_t fsifill2[12]; + u_int8_t fsisig3[4]; +}; + + +/* direntry */ + +/*- + * Copyright (C) 1994, 1995, 1997 Wolfgang Solfrank. + * Copyright (C) 1994, 1995, 1997 TooLs GmbH. + * All rights reserved. + * Original code by Paul Popelka (paulp@uts.amdahl.com) (see above). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by TooLs GmbH. + * 4. The name of TooLs GmbH may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Structure of a dos directory entry. + */ +struct direntry { + u_int8_t deName[8]; /* filename, blank filled */ +#define SLOT_EMPTY 0x00 /* slot has never been used */ +#define SLOT_E5 0x05 /* the real value is 0xe5 */ +#define SLOT_DELETED 0xe5 /* file in this slot deleted */ + u_int8_t deExtension[3]; /* extension, blank filled */ + u_int8_t deAttributes; /* file attributes */ +#define ATTR_NORMAL 0x00 /* normal file */ +#define ATTR_READONLY 0x01 /* file is read-only (immutable) */ +#define ATTR_HIDDEN 0x02 /* file is hidden */ +#define ATTR_SYSTEM 0x04 /* file is a system file */ +#define ATTR_VOLUME 0x08 /* entry is a volume label */ +#define ATTR_DIRECTORY 0x10 /* entry is a directory name */ +#define ATTR_ARCHIVE 0x20 /* file is new or modified */ + u_int8_t deLowerCase; /* NT VFAT lower case flags */ +#define LCASE_BASE 0x08 /* filename base in lower case */ +#define LCASE_EXT 0x10 /* filename extension in lower case */ + u_int8_t deCHundredth; /* hundredth of seconds in CTime */ + u_int8_t deCTime[2]; /* create time */ + u_int8_t deCDate[2]; /* create date */ + u_int8_t deADate[2]; /* access date */ + u_int8_t deHighClust[2]; /* high bytes of cluster number */ + u_int16_t deMTime; /* last update time */ + u_int16_t deMDate; /* last update date */ + u_int8_t deStartCluster[2]; /* starting cluster of file */ + u_int8_t deFileSize[4]; /* size of file in bytes */ +}; + +/* + * Structure of a Win95 long name directory entry + */ +struct winentry { + u_int8_t weCnt; +#define WIN_LAST 0x40 +#define WIN_CNT 0x3f + u_int8_t wePart1[10]; + u_int8_t weAttributes; +#define ATTR_WIN95 0x0f + u_int8_t weReserved1; + u_int8_t weChksum; + u_int8_t wePart2[12]; + u_int16_t weReserved2; + u_int8_t wePart3[4]; +}; +#define WIN_CHARS 13 /* Number of chars per winentry */ + +/* + * Maximum filename length in Win95 + * Note: Must be < sizeof(dirent.d_name) + */ +#define WIN_MAXLEN 255 + +/* + * This is the format of the contents of the deTime field in the direntry + * structure. + * We don't use bitfields because we don't know how compilers for + * arbitrary machines will lay them out. + */ +#define DT_2SECONDS_MASK 0x1F /* seconds divided by 2 */ +#define DT_2SECONDS_SHIFT 0 +#define DT_MINUTES_MASK 0x7E0 /* minutes */ +#define DT_MINUTES_SHIFT 5 +#define DT_HOURS_MASK 0xF800 /* hours */ +#define DT_HOURS_SHIFT 11 + +/* + * This is the format of the contents of the deDate field in the direntry + * structure. + */ +#define DD_DAY_MASK 0x1F /* day of month */ +#define DD_DAY_SHIFT 0 +#define DD_MONTH_MASK 0x1E0 /* month */ +#define DD_MONTH_SHIFT 5 +#define DD_YEAR_MASK 0xFE00 /* year - 1980 */ +#define DD_YEAR_SHIFT 9 + Index: trunk/i386/libsaio/table.c =================================================================== --- trunk/i386/libsaio/table.c (revision 0) +++ trunk/i386/libsaio/table.c (revision 1) @@ -0,0 +1,100 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Mach Operating System + * Copyright (c) 1990 Carnegie-Mellon University + * Copyright (c) 1989 Carnegie-Mellon University + * All rights reserved. The CMU software License Agreement specifies + * the terms and conditions for use and redistribution. + */ + +/* + * INTEL CORPORATION PROPRIETARY INFORMATION + * + * This software is supplied under the terms of a license agreement or + * nondisclosure agreement with Intel Corporation and may not be copied + * nor disclosed except in accordance with the terms of that agreement. + * + * Copyright 1988, 1989 Intel Corporation + */ + +/* + * Copyright 1993 NeXT, Inc. + * All rights reserved. + */ + +#include "memory.h" + +/* Segment Descriptor + * + * 31 24 19 16 7 0 + * ------------------------------------------------------------ + * | | |B| |A| | | |1|0|E|W|A| | + * | BASE 31..24 |G|/|0|V| LIMIT |P|DPL| TYPE | BASE 23:16 | + * | | |D| |L| 19..16| | |1|1|C|R|A| | + * ------------------------------------------------------------ + * | | | + * | BASE 15..0 | LIMIT 15..0 | + * | | | + * ------------------------------------------------------------ + */ + +struct seg_desc { + unsigned short limit_15_0; + unsigned short base_15_0; + unsigned char base_23_16; + unsigned char bit_15_8; + unsigned char bit_23_16; + unsigned char base_31_24; +}; + +// turbo - GDT must be in first 64k segment +struct seg_desc __attribute__ ((section("__INIT,__data"))) Gdt[ NGDTENT ] = { + /* 0x0 : null */ + {0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00}, + + /* 0x8 : boot protected mode 32-bit code segment + byte granularity, 1MB limit, MEMBASE offset */ + {0xFFFF, MEMBASE, 0x00, 0x9E, 0x4F, 0x00}, + + /* 0x10 : boot protected mode data segment + page granularity, 4GB limit, MEMBASE offset */ + {0xFFFF, MEMBASE, 0x00, 0x92, 0xCF, 0x00}, + + /* 0x18 : boot protected mode 16-bit code segment + byte granularity, 1MB limit, MEMBASE offset */ + {0xFFFF, MEMBASE, 0x00, 0x9E, 0x0F, 0x00}, + + /* 0x20 : kernel init 32-bit data segment + page granularity, 4GB limit, zero offset */ + {0xFFFF, 0x0000, 0x00, 0x92, 0xCF, 0x00}, + + /* 0x28 : kernel init 32-bit code segment + page granularity, 4GB limit, zero offset */ + {0xFFFF, 0x0000, 0x00, 0x9E, 0xCF, 0x00}, + + /* 0x30 : boot real mode data/stack segment + byte granularity, 64K limit, MEMBASE offset, expand-up */ + {0xFFFF, MEMBASE, 0x00, 0x92, 0x00, 0x00}, +}; Index: trunk/i386/libsaio/usb.c =================================================================== --- trunk/i386/libsaio/usb.c (revision 0) +++ trunk/i386/libsaio/usb.c (revision 1) @@ -0,0 +1,168 @@ +/* + * usb.c + * + * + * Created by mackerintel on 12/20/08. + * Copyright 2008 mackerintel. All rights reserved. + * + */ + +#include "libsaio.h" +#include "bootstruct.h" +#include "pci.h" + +#ifndef DEBUG_USB +#define DEBUG_USB 0 +#endif + +#if DEBUG_USB +#define DBG(x...) printf(x) +#else +#define DBG(x...) +#endif + +int ehci_acquire (pci_dt_t *pci_dev) +{ + int j,k; + + uint32_t base; + uint8_t eecp; + uint8_t legacy[8]; + + BOOL isOwnershipConflict; + BOOL alwaysHardBIOSReset; + + if (!getBoolForKey("EHCIhard", &alwaysHardBIOSReset, &bootInfo->bootConfig)) + alwaysHardBIOSReset = 1; + + pci_config_write16(pci_dev->dev.addr, 0x04, 0x0002); + base = pci_config_read32(pci_dev->dev.addr, 0x10); + + verbose("EHCI controller [%04x:%04x] at %02x:%2x.%x DMA @%x\n", + pci_dev->vendor_id, pci_dev->device_id, + pci_dev->dev.bits.bus, pci_dev->dev.bits.dev, pci_dev->dev.bits.func, + base); + + if (*((unsigned char*)base) < 0xc) + { + DBG("Config space too small: no legacy implementation\n"); + return 1; + } + eecp=*((unsigned char*)(base + 9)); + if (!eecp) + { + DBG("No extended capabilities: no legacy implementation\n"); + return 1; + } + + DBG("eecp=%x\n",eecp); + + // bad way to do it + // pci_conf_write(pci_dev->dev.addr, eecp, 4, 0x01000001); + for (j = 0; j < 8; j++) + { + legacy[j] = pci_config_read8(pci_dev->dev.addr, eecp + j); + DBG("%02x ",legacy[j]); + } + DBG("\n"); + + //Real Job: based on orByte's AppleUSBEHCI.cpp + //We try soft reset first - some systems hang on reboot with hard reset + // Definitely needed during reboot on 10.4.6 + + isOwnershipConflict = ((legacy[3] & 1 != 0) && (legacy[2] & 1 != 0)); + if (!alwaysHardBIOSReset && isOwnershipConflict) + { + DBG("EHCI - Ownership conflict - attempting soft reset ...\n"); + DBG("EHCI - toggle OS Ownership to 0\n"); + pci_config_write8(pci_dev->dev.addr, eecp + 3, 0); + for (k = 0; k < 25; k++) + { + for (j = 0; j < 8; j++) + legacy[j] = pci_config_read8(pci_dev->dev.addr, eecp + j); + if (legacy[3] == 0) + break; + delay(10); + } + } + + DBG("Found USBLEGSUP_ID - value %x:%x - writing OSOwned\n", legacy[3],legacy[2]); + pci_config_write8(pci_dev->dev.addr, eecp + 3, 1); + + // wait for kEHCI_USBLEGSUP_BIOSOwned bit to clear + for (k = 0; k < 25; k++) + { + for (j = 0;j < 8; j++) + legacy[j] = pci_config_read8(pci_dev->dev.addr, eecp + j); + DBG ("%x:%x,",legacy[3],legacy[2]); + if (legacy[2] == 0) + break; + delay(10); + } + + for (j = 0;j < 8; j++) + legacy[j] = pci_config_read8(pci_dev->dev.addr, eecp + j); + isOwnershipConflict = ((legacy[2]) != 0); + if (isOwnershipConflict) + { + // Soft reset has failed. Assume SMI being ignored + // Hard reset + // Force Clear BIOS BIT + + DBG("EHCI - Ownership conflict - attempting hard reset ...\n"); + DBG ("%x:%x\n",legacy[3],legacy[2]); + DBG("EHCI - Force BIOS Ownership to 0\n"); + + pci_config_write8(pci_dev->dev.addr, eecp + 2, 0); + for (k = 0; k < 25; k++) + { + for (j = 0; j < 8; j++) + legacy[j] = pci_config_read8(pci_dev->dev.addr, eecp + j); + DBG ("%x:%x,",legacy[3],legacy[2]); + + if ((legacy[2]) == 0) + break; + delay(10); + } + // Disable further SMI events + for (j = 4; j < 8; j++) + pci_config_write8(pci_dev->dev.addr, eecp + j, 0); + } + + for (j = 0; j < 8; j++) + legacy[j] = pci_config_read8(pci_dev->dev.addr, eecp + j); + + DBG ("%x:%x\n",legacy[3],legacy[2]); + + // Final Ownership Resolution Check... + if (legacy[2]&1) + { + DBG("EHCI controller unable to take control from BIOS\n"); + return 0; + } + + DBG("EHCI Acquire OS Ownership done\n"); + return 1; +} + +int uhci_reset (pci_dt_t *pci_dev) +{ + uint32_t base, port_base; + + base = pci_config_read32(pci_dev->dev.addr, 0x20); + port_base = (base >> 5) & 0x07ff; + + verbose("UHCI controller [%04x:%04x] at %02x:%2x.%x base %x(%x)\n", + pci_dev->vendor_id, pci_dev->device_id, + pci_dev->dev.bits.bus, pci_dev->dev.bits.dev, pci_dev->dev.bits.func, + port_base, base); + + pci_config_write16(pci_dev->dev.addr, 0xc0, 0x8f00); + + outw (port_base, 0x0002); + delay(10); + outw (port_base+4,0); + delay(10); + outw (port_base,0); + return 1; +} Index: trunk/i386/libsaio/device_inject.c =================================================================== --- trunk/i386/libsaio/device_inject.c (revision 0) +++ trunk/i386/libsaio/device_inject.c (revision 1) @@ -0,0 +1,459 @@ +/* + * Copyright 2009 Jasmin Fazlic All rights reserved. + */ +/* + * Cleaned and merged by iNDi + */ + +#include "libsaio.h" +#include "bootstruct.h" +#include "pci.h" +#include "device_inject.h" + + +#ifndef DEBUG_INJECT +#define DEBUG_INJECT 0 +#endif + +#if DEBUG_INJECT +#define DBG(x...) printf(x) +#else +#define DBG(x...) +#endif + +uint32_t devices_number = 1; +uint32_t builtin_set = 0; +struct DevPropString *string = 0; +uint8_t *stringdata = 0; +uint32_t stringlength = 0; + +char *efi_inject_get_devprop_string(uint32_t *len) +{ + if(string) + { + *len = string->length; + return devprop_generate_string(string); + } + printf("efi_inject_get_devprop_string NULL trying stringdata\n"); + return NULL; +} + +uint32_t ascii_hex_to_int(char *buff) +{ + uint32_t value = 0, i, digit; + for(i = 0; i < strlen(buff); i++) + { + if (buff[i] >= 48 && buff[i] <= 57) // '0' through '9' + digit = buff[i] - 48; + else if (buff[i] >= 65 && buff[i] <= 70) // 'A' through 'F' + digit = buff[i] - 55; + else if (buff[i] >= 97 && buff[i] <= 102) // 'a' through 'f' + digit = buff[i] - 87; + else + return value; + + value = digit + 16 * value; + } + return value; +} + +void *convertHexStr2Binary(const char *hexStr, int *outLength) +{ + int len; + char hexNibble; + char hexByte[2]; + uint8_t binChar; + uint8_t *binStr; + int hexStrIdx, binStrIdx, hexNibbleIdx; + + len = strlen(hexStr); + if (len > 1) + { + // the resulting binary will be the half size of the input hex string + binStr = malloc(len / 2); + binStrIdx = 0; + hexNibbleIdx = 0; + for (hexStrIdx = 0; hexStrIdx < len; hexStrIdx++) + { + hexNibble = hexStr[hexStrIdx]; + + // ignore all chars except valid hex numbers + if (hexNibble >= '0' && hexNibble <= '9' + || hexNibble >= 'A' && hexNibble <= 'F' + || hexNibble >= 'a' && hexNibble <= 'f') + { + hexByte[hexNibbleIdx++] = hexNibble; + + // found both two nibbles, convert to binary + if (hexNibbleIdx == 2) + { + binChar = 0; + + for (hexNibbleIdx = 0; hexNibbleIdx < sizeof(hexByte); hexNibbleIdx++) + { + if (hexNibbleIdx > 0) binChar = binChar << 4; + + if (hexByte[hexNibbleIdx] <= '9') binChar += hexByte[hexNibbleIdx] - '0'; + else if (hexByte[hexNibbleIdx] <= 'F') binChar += hexByte[hexNibbleIdx] - ('A' - 10); + else if (hexByte[hexNibbleIdx] <= 'f') binChar += hexByte[hexNibbleIdx] - ('a' - 10); + } + + binStr[binStrIdx++] = binChar; + hexNibbleIdx = 0; + } + } + } + *outLength = binStrIdx; + return binStr; + } + else + { + *outLength = 0; + return NULL; + } +} + +void setupDeviceProperties(Node *node) +{ + const char *val; + uint8_t *binStr; + int cnt, cnt2; + + static char DEVICE_PROPERTIES_PROP[] = "device-properties"; + + /* Generate devprop string. + */ + uint32_t strlength; + char *string = efi_inject_get_devprop_string(&strlength); + + /* Use the static "device-properties" boot config key contents if available, + * otheriwse use the generated one. + */ + if (!getValueForKey(DEVICE_PROPERTIES_PROP, &val, &cnt, &bootInfo->bootConfig) && string) + { + val = (const char*)string; + cnt = strlength * 2; + } + + if (cnt > 1) + { + binStr = convertHexStr2Binary(val, &cnt2); + if (cnt2 > 0) DT__AddProperty(node, DEVICE_PROPERTIES_PROP, cnt2, binStr); + } +} + +uint16_t dp_swap16(uint16_t toswap) +{ + return (((toswap & 0x00FF) << 8) | ((toswap & 0xFF00) >> 8)); +} + +uint32_t dp_swap32(uint32_t toswap) +{ + return ((toswap & 0x000000FF) << 24) | + ((toswap & 0x0000FF00) << 8 ) | + ((toswap & 0x00FF0000) >> 8 ) | + ((toswap & 0xFF000000) >> 24); +} + +struct DevPropString *devprop_create_string(void) +{ + string = (struct DevPropString*)malloc(sizeof(struct DevPropString)); + + if(string == NULL) + return NULL; + + memset(string, 0, sizeof(struct DevPropString)); + string->length = 12; + string->WHAT2 = 0x01000000; + return string; +} + +struct DevPropDevice *devprop_add_device(struct DevPropString *string, char *path) +{ + uint32_t PciRootID = 0; + const char *val; + int len; + + struct DevPropDevice *device = (struct DevPropDevice*)malloc(sizeof(struct DevPropDevice)); + if(!device || !string || !path) { + if(device) + free(device); + return NULL; + } + + const char pciroot_string[] = "PciRoot(0x"; + const char pci_device_string[] = "Pci(0x"; + + if (getValueForKey("PciRoot", &val, &len, &bootInfo->bootConfig)) + PciRootID = atoi(val); + + if(strncmp(path, pciroot_string, strlen(pciroot_string))) + { + printf("ERROR parsing device path\n"); + return NULL; + } + + memset(device, 0, sizeof(struct DevPropDevice)); + + device->acpi_dev_path._UID = PciRootID; + + int numpaths = 0; + int x, curr = 0; + char buff[] = "00"; + + for(x = 0; x < strlen(path); x++) + { + if(!strncmp(&path[x], pci_device_string, strlen(pci_device_string))) + { + x+=strlen(pci_device_string); + curr=x; + while(path[++x] != ','); + if(x-curr == 2) + sprintf(buff, "%c%c", path[curr], path[curr+1]); + else if(x-curr == 1) + sprintf(buff, "%c", path[curr]); + else + { + printf("ERROR parsing device path\n"); + numpaths = 0; + break; + } + device->pci_dev_path[numpaths].device = ascii_hex_to_int(buff); + + x += 3; // 0x + curr = x; + while(path[++x] != ')'); + if(x-curr == 2) + sprintf(buff, "%c%c", path[curr], path[curr+1]); + else if(x-curr == 1) + sprintf(buff, "%c", path[curr]); + else + { + printf("ERROR parsing device path\n"); + numpaths = 0; + break; + } + device->pci_dev_path[numpaths].function = ascii_hex_to_int(buff); // TODO: find dev from char *path + + numpaths++; + } + } + + if(!numpaths) + return NULL; + + device->numentries = 0x00; + + device->acpi_dev_path.length = 0x0c; + device->acpi_dev_path.type = 0x02; + device->acpi_dev_path.subtype = 0x01; + device->acpi_dev_path._HID = 0xd041030a; + + device->num_pci_devpaths = numpaths; + device->length = 24 + (6*numpaths); + + int i; + + for(i = 0; i < numpaths; i++) + { + device->pci_dev_path[i].length = 0x06; + device->pci_dev_path[i].type = 0x01; + device->pci_dev_path[i].subtype = 0x01; + } + + device->path_end.length = 0x04; + device->path_end.type = 0x7f; + device->path_end.subtype = 0xff; + + device->string = string; + device->data = NULL; + string->length += device->length; + + if(!string->entries) + if((string->entries = (struct DevPropDevice**)malloc(sizeof(device)))== NULL) + return 0; + + string->entries[string->numentries++] = (struct DevPropDevice*)malloc(sizeof(device)); + string->entries[string->numentries-1] = device; + + return device; +} + +int devprop_add_value(struct DevPropDevice *device, char *nm, uint8_t *vl, uint32_t len) +{ + + if(!nm || !vl || !len) + return 0; + + uint32_t length = ((strlen(nm) * 2) + len + (2 * sizeof(uint32_t)) + 2); + uint8_t *data = (uint8_t*)malloc(length); + { + if(!data) + return 0; + + memset(data, 0, length); + uint32_t off= 0; + data[off+1] = ((strlen(nm) * 2) + 6) >> 8; + data[off] = ((strlen(nm) * 2) + 6) & 0x00FF; + + off += 4; + uint32_t i=0, l = strlen(nm); + for(i = 0 ; i < l ; i++, off += 2) + { + data[off] = *nm++; + } + + off += 2; + l = len; + uint32_t *datalength = (uint32_t*)&data[off]; + *datalength = l + 4; + off += 4; + for(i = 0 ; i < l ; i++, off++) + { + data[off] = *vl++; + } + } + + uint32_t offset = device->length - (24 + (6 * device->num_pci_devpaths)); + + uint8_t *newdata = (uint8_t*)malloc((length + offset)); + if(!newdata) + return 0; + if(device->data) + if(offset > 1) + memcpy(newdata, device->data, offset); + + memcpy(newdata + offset, data, length); + + device->length += length; + device->string->length += length; + device->numentries++; + + if(!device->data) + device->data = (uint8_t*)malloc(sizeof(uint8_t)); + else + free(device->data); + + free(data); + device->data = newdata; + + return 1; +} + +char *devprop_generate_string(struct DevPropString *string) +{ + char *buffer = (char*)malloc(string->length * 2); + char *ptr = buffer; + + if(!buffer) + return NULL; + + sprintf(buffer, "%08x%08x%04x%04x", dp_swap32(string->length), string->WHAT2, + dp_swap16(string->numentries), string->WHAT3); + buffer += 24; + int i = 0, x = 0; + + while(i < string->numentries) + { + sprintf(buffer, "%08x%04x%04x", dp_swap32(string->entries[i]->length), + dp_swap16(string->entries[i]->numentries), string->entries[i]->WHAT2); + + buffer += 16; + sprintf(buffer, "%02x%02x%04x%08x%08x", string->entries[i]->acpi_dev_path.type, + string->entries[i]->acpi_dev_path.subtype, + dp_swap16(string->entries[i]->acpi_dev_path.length), + string->entries[i]->acpi_dev_path._HID, + dp_swap32(string->entries[i]->acpi_dev_path._UID)); + + buffer += 24; + for(x=0;x < string->entries[i]->num_pci_devpaths; x++) + { + sprintf(buffer, "%02x%02x%04x%02x%02x", string->entries[i]->pci_dev_path[x].type, + string->entries[i]->pci_dev_path[x].subtype, + dp_swap16(string->entries[i]->pci_dev_path[x].length), + string->entries[i]->pci_dev_path[x].function, + string->entries[i]->pci_dev_path[x].device); + buffer += 12; + } + + sprintf(buffer, "%02x%02x%04x", string->entries[i]->path_end.type, + string->entries[i]->path_end.subtype, + dp_swap16(string->entries[i]->path_end.length)); + + buffer += 8; + uint8_t *dataptr = string->entries[i]->data; + for(x = 0; x < (string->entries[i]->length) - (24 + (6 * string->entries[i]->num_pci_devpaths)) ; x++) + { + sprintf(buffer, "%02x", *dataptr++); + buffer += 2; + } + i++; + } + return ptr; +} + +void devprop_free_string(struct DevPropString *string) +{ + if(!string) + return; + + int i; + for(i = 0; i < string->numentries; i++) + { + if(string->entries[i]) + { + if(string->entries[i]->data) + { + free(string->entries[i]->data); + string->entries[i]->data = NULL; + } + free(string->entries[i]); + string->entries[i] = NULL; + } + } + + free(string); + string = NULL; +} + +/* a fine place for this code */ + +int devprop_add_network_template(struct DevPropDevice *device, uint16_t vendor_id) +{ + if(!device) + return 0; + uint8_t builtin = 0x0; + if((vendor_id != 0x168c) && (builtin_set == 0)) + { + builtin_set = 1; + builtin = 0x01; + } + if(!devprop_add_value(device, "built-in", (uint8_t*)&builtin, 1)) + return 0; + devices_number++; + return 1; +} + +void set_eth_builtin(pci_dt_t *eth_dev) +{ + char *devicepath = get_pci_dev_path(eth_dev); + struct DevPropDevice *device = (struct DevPropDevice*)malloc(sizeof(struct DevPropDevice)); + + verbose("LAN Controller [%04x:%04x] :: %s\n", eth_dev->vendor_id, eth_dev->device_id, devicepath); + + if (!string) + string = devprop_create_string(); + + device = devprop_add_device(string, devicepath); + if(device) + { + verbose("Setting up lan keys\n"); + devprop_add_network_template(device, eth_dev->vendor_id); + stringdata = (uint8_t*)malloc(sizeof(uint8_t) * string->length); + if(stringdata) + { + memcpy(stringdata, (uint8_t*)devprop_generate_string(string), string->length); + stringlength = string->length; + } + } +} Index: trunk/i386/libsaio/device_inject.h =================================================================== --- trunk/i386/libsaio/device_inject.h (revision 0) +++ trunk/i386/libsaio/device_inject.h (revision 1) @@ -0,0 +1,77 @@ +/* + * Copyright 2009 Jasmin Fazlic All rights reserved. + */ +/* + * Cleaned and merged by iNDi + */ + +#ifndef __LIBSAIO_DEVICE_INJECT_H +#define __LIBSAIO_DEVICE_INJECT_H + +#define DP_ADD_TEMP_VAL(dev, val) devprop_add_value(dev, (char*)val[0], (uint8_t*)val[1], strlen(val[1]) + 1) +#define DP_ADD_TEMP_VAL_DATA(dev, val) devprop_add_value(dev, (char*)val.name, (uint8_t*)val.data, val.size) +#define MAX_PCI_DEV_PATHS 4 + +extern struct DevPropString *string; +extern uint8_t *stringdata; +extern uint32_t stringlength; +extern void *convertHexStr2Binary(const char *hexStr, int *outLength); +extern void setupDeviceProperties(Node *node); + +struct ACPIDevPath { + uint8_t type; // = 2 ACPI device-path + uint8_t subtype; // = 1 ACPI Device-path + uint16_t length; // = 0x0c + uint32_t _HID; // = 0xD041030A ? + uint32_t _UID; // = 0x00000000 PCI ROOT +}; + +struct PCIDevPath { + uint8_t type; // = 1 Hardware device-path + uint8_t subtype; // = 1 PCI + uint16_t length; // = 6 + uint8_t function; // pci func number + uint8_t device; // pci dev number +}; + +struct DevicePathEnd { + uint8_t type; // = 0x7f + uint8_t subtype; // = 0xff + uint16_t length; // = 4; +}; + +struct DevPropDevice { + uint32_t length; + uint16_t numentries; + uint16_t WHAT2; // 0x0000 ? + struct ACPIDevPath acpi_dev_path; // = 0x02010c00 0xd041030a + struct PCIDevPath pci_dev_path[MAX_PCI_DEV_PATHS]; // = 0x01010600 func dev + struct DevicePathEnd path_end; // = 0x7fff0400 + uint8_t *data; + + // ------------------------ + uint8_t num_pci_devpaths; + struct DevPropString *string; + // ------------------------ +}; + +struct DevPropString { + uint32_t length; + uint32_t WHAT2; // 0x01000000 ? + uint16_t numentries; + uint16_t WHAT3; // 0x0000 ? + struct DevPropDevice **entries; +}; + +void setupEfiDevices (); + +char *efi_inject_get_devprop_string(uint32_t *len); +int devprop_add_nvidia_template(struct DevPropDevice *device); +int devprop_add_network_template(struct DevPropDevice *device, uint16_t vendor_id); +struct DevPropString *devprop_create_string(void); +struct DevPropDevice *devprop_add_device(struct DevPropString *string, char *path); +int devprop_add_value(struct DevPropDevice *device, char *nm, uint8_t *vl, uint32_t len); +char *devprop_generate_string(struct DevPropString *string); +void devprop_free_string(struct DevPropString *string); + +#endif /* !__LIBSAIO_DEVICE_INJECT_H */ Index: trunk/i386/libsaio/dsdt_patcher.c =================================================================== --- trunk/i386/libsaio/dsdt_patcher.c (revision 0) +++ trunk/i386/libsaio/dsdt_patcher.c (revision 1) @@ -0,0 +1,393 @@ +/* + * Copyright 2008 mackerintel + */ + +#include "libsaio.h" +#include "bootstruct.h" +#include "acpi.h" +#include "efi_tables.h" +#include "fake_efi.h" +#include "dsdt_patcher.h" + +#ifndef DEBUG_DSDT +#define DEBUG_DSDT 0 +#endif + +#if DEBUG_DSDT==2 +#define DBG(x...) {printf(x); sleep(1);} +#elif DEBUG_DSDT==1 +#define DBG(x...) printf(x) +#else +#define DBG(x...) +#endif + +/* Gets the ACPI 1.0 RSDP address */ +static struct acpi_2_rsdp* getAddressOfAcpiTable() +{ + /* TODO: Before searching the BIOS space we are supposed to search the first 1K of the EBDA */ + + void *acpi_addr = (void*)ACPI_RANGE_START; + for(; acpi_addr <= (void*)ACPI_RANGE_END; acpi_addr += 16) + { + if(*(uint64_t *)acpi_addr == ACPI_SIGNATURE_UINT64_LE) + { + uint8_t csum = checksum8(acpi_addr, 20); + if(csum == 0) + { + // Only return the table if it is a true version 1.0 table (Revision 0) + if(((struct acpi_2_rsdp*)acpi_addr)->Revision == 0) + return acpi_addr; + } + } + } + return NULL; +} + +/* Gets the ACPI 2.0 RSDP address */ +static struct acpi_2_rsdp* getAddressOfAcpi20Table() +{ + /* TODO: Before searching the BIOS space we are supposed to search the first 1K of the EBDA */ + + void *acpi_addr = (void*)ACPI_RANGE_START; + for(; acpi_addr <= (void*)ACPI_RANGE_END; acpi_addr += 16) + { + if(*(uint64_t *)acpi_addr == ACPI_SIGNATURE_UINT64_LE) + { + uint8_t csum = checksum8(acpi_addr, 20); + + /* Only assume this is a 2.0 or better table if the revision is greater than 0 + * NOTE: ACPI 3.0 spec only seems to say that 1.0 tables have revision 1 + * and that the current revision is 2.. I am going to assume that rev > 0 is 2.0. + */ + + if(csum == 0 && (((struct acpi_2_rsdp*)acpi_addr)->Revision > 0)) + { + uint8_t csum2 = checksum8(acpi_addr, sizeof(struct acpi_2_rsdp)); + if(csum2 == 0) + return acpi_addr; + } + } + } + return NULL; +} + + +/* Setup ACPI without replacing DSDT. */ +int setupAcpiNoMod() +{ +// addConfigurationTable(&gEfiAcpiTableGuid, getAddressOfAcpiTable(), "ACPI"); +// addConfigurationTable(&gEfiAcpi20TableGuid, getAddressOfAcpi20Table(), "ACPI_20"); + acpi10_p = (uint32_t)getAddressOfAcpiTable(); + acpi20_p = (uint32_t)getAddressOfAcpi20Table(); + addConfigurationTable(&gEfiAcpiTableGuid, &acpi10_p, "ACPI"); + if(acpi20_p) addConfigurationTable(&gEfiAcpi20TableGuid, &acpi20_p, "ACPI_20"); + return 1; +} + +/* Setup ACPI. Replace DSDT if DSDT.aml is found */ +int setupAcpi() +{ + int fd, version; + void *new_dsdt; + const char *dsdt_filename; + char dirspec[512]; + int len; + boolean_t drop_ssdt=NO; + + //DBG("Enter setupACPI\n"); + + if (!getValueForKey("DSDT", &dsdt_filename, &len, &bootInfo->bootConfig)) + dsdt_filename="DSDT.aml"; + + // Check booting partition + sprintf(dirspec,"%s",dsdt_filename); + fd=open (dirspec,0); + if (fd<0) + { // Check Extra on booting partition + sprintf(dirspec,"/Extra/%s",dsdt_filename); + fd=open (dirspec,0); + if (fd<0) + { // Fall back to booter partition + sprintf(dirspec,"bt(0,0)/Extra/%s",dsdt_filename); + fd=open (dirspec,0); + if (fd<0) + { + verbose("No DSDT replacement found. Leaving ACPI data as is\n"); + return setupAcpiNoMod(); + } + } + } + + // Load replacement DSDT + new_dsdt=(void*)AllocateKernelMemory(file_size (fd)); + if (!new_dsdt) + { + printf("Couldn't allocate memory for DSDT\n"); + return setupAcpiNoMod(); + } + if (read (fd, new_dsdt, file_size (fd))!=file_size (fd)) + { + printf("Couldn't read file\n"); + return setupAcpiNoMod(); + } + close (fd); + + DBG("New DSDT Loaded in memory\n"); + + { + BOOL tmp; + drop_ssdt=getBoolForKey("DropSSDT",&tmp, &bootInfo->bootConfig)&&tmp; + } + + // Do the same procedure for both versions of ACPI + for (version=0;version<2;version++) + { + struct acpi_2_rsdp *rsdp, *rsdp_mod; + struct acpi_2_rsdt *rsdt, *rsdt_mod; + int rsdplength; + + // Find original rsdp + rsdp=(struct acpi_2_rsdp *)(version?getAddressOfAcpi20Table():getAddressOfAcpiTable()); + if (!rsdp) + { + DBG("No ACPI version %d found. Ignoring\n", version+1); + if (version) + addConfigurationTable(&gEfiAcpi20TableGuid, NULL, "ACPI_20"); + else + addConfigurationTable(&gEfiAcpiTableGuid, NULL, "ACPI"); + continue; + } + rsdplength=version?rsdp->Length:20; + + DBG("RSDP version %d found @%x. Length=%d\n",version+1,rsdp,rsdplength); + + /* FIXME: no check that memory allocation succeeded + * Copy and patch RSDP,RSDT, XSDT and FADT + * For more info see ACPI Specification pages 110 and following + */ + + rsdp_mod=(struct acpi_2_rsdp *) AllocateKernelMemory(rsdplength); + memcpy(rsdp_mod, rsdp, rsdplength); + rsdt=(struct acpi_2_rsdt *)(rsdp->RsdtAddress); + + DBG("RSDT @%x, Length %d\n",rsdt, rsdt->Length); + + if (rsdt && (uint32_t)rsdt !=0xffffffff && rsdt->Length<0x10000) + { + uint32_t *rsdt_entries; + int rsdt_entries_num; + int dropoffset=0, i; + + rsdt_mod=(struct acpi_2_rsdt *)AllocateKernelMemory(rsdt->Length); + memcpy (rsdt_mod, rsdt, rsdt->Length); + rsdp_mod->RsdtAddress=(uint32_t)rsdt_mod; + rsdt_entries_num=(rsdt_mod->Length-sizeof(struct acpi_2_rsdt))/4; + rsdt_entries=(uint32_t *)(rsdt_mod+1); + for (i=0;iLength); + + if (!fadt || (uint32_t)fadt == 0xffffffff || fadt->Length>0x10000) + { + printf("FADT incorrect. Not modified\n"); + continue; + } + + fadt_mod=(struct acpi_2_fadt *)AllocateKernelMemory(fadt->Length); + memcpy(fadt_mod, fadt, fadt->Length); + + // Patch DSDT Address + DBG("Old DSDT @%x,%x\n",fadt_mod->DSDT,fadt_mod->X_DSDT); + + fadt_mod->DSDT=(uint32_t)new_dsdt; + if ((uint32_t)(&(fadt_mod->X_DSDT))-(uint32_t)fadt_mod+8<=fadt_mod->Length) + fadt_mod->X_DSDT=(uint32_t)new_dsdt; + + DBG("New DSDT @%x,%x\n",fadt_mod->DSDT,fadt_mod->X_DSDT); + + // Correct the checksum + fadt_mod->Checksum=0; + fadt_mod->Checksum=256-checksum8(fadt_mod,fadt_mod->Length); + + rsdt_entries[i-dropoffset]=(uint32_t)fadt_mod; + continue; + } + } + + // Correct the checksum of RSDT + rsdt_mod->Length-=4*dropoffset; + + DBG("RSDT Original checksum %d\n", rsdt_mod->Checksum); + + rsdt_mod->Checksum=0; + rsdt_mod->Checksum=256-checksum8(rsdt_mod,rsdt_mod->Length); + + DBG("RSDT New checksum %d at %x\n", rsdt_mod->Checksum,rsdt_mod); + } + else + { + rsdp_mod->RsdtAddress=0; + printf("RSDT not found or RSDT incorrect\n"); + } + + if (version) + { + struct acpi_2_xsdt *xsdt, *xsdt_mod; + + // FIXME: handle 64-bit address correctly + + xsdt=(struct acpi_2_xsdt*) ((uint32_t)rsdp->XsdtAddress); + DBG("XSDT @%x;%x, Length=%d\n", (uint32_t)(rsdp->XsdtAddress>>32),(uint32_t)rsdp->XsdtAddress, + xsdt->Length); + if (xsdt && (uint64_t)rsdp->XsdtAddress<0xffffffff && xsdt->Length<0x10000) + { + uint64_t *xsdt_entries; + int xsdt_entries_num, i; + int dropoffset=0; + + xsdt_mod=(struct acpi_2_xsdt*)AllocateKernelMemory(xsdt->Length); + memcpy(xsdt_mod, xsdt, xsdt->Length); + rsdp_mod->XsdtAddress=(uint32_t)xsdt_mod; + xsdt_entries_num=(xsdt_mod->Length-sizeof(struct acpi_2_xsdt))/8; + xsdt_entries=(uint64_t *)(xsdt_mod+1); + for (i=0;i>32),fadt, + fadt->Length); + + if (!fadt || (uint64_t)xsdt_entries[i] >= 0xffffffff || fadt->Length>0x10000) + { + printf("FADT incorrect or after 4GB. Dropping XSDT\n"); + goto drop_xsdt; + } + fadt_mod=(struct acpi_2_fadt*)AllocateKernelMemory(fadt->Length); + memcpy(fadt_mod, fadt, fadt->Length); + + // Patch DSDT Address + DBG("Old DSDT @%x,%x\n",fadt_mod->DSDT,fadt_mod->X_DSDT); + + fadt_mod->DSDT=(uint32_t)new_dsdt; + if ((uint32_t)(&(fadt_mod->X_DSDT))-(uint32_t)fadt_mod+8<=fadt_mod->Length) + fadt_mod->X_DSDT=(uint32_t)new_dsdt; + + DBG("New DSDT @%x,%x\n",fadt_mod->DSDT,fadt_mod->X_DSDT); + + // Correct the checksum + fadt_mod->Checksum=0; + fadt_mod->Checksum=256-checksum8(fadt_mod,fadt_mod->Length); + + xsdt_entries[i-dropoffset]=(uint32_t)fadt_mod; + + DBG("TABLE %c%c%c%c@%x,",table[0],table[1],table[2],table[3],xsdt_entries[i]); + + continue; + } + + DBG("TABLE %c%c%c%c@%x,",table[0],table[1],table[2],table[3],xsdt_entries[i]); + + } + + // Correct the checksum of XSDT + xsdt_mod->Length-=8*dropoffset; + xsdt_mod->Checksum=0; + xsdt_mod->Checksum=256-checksum8(xsdt_mod,xsdt_mod->Length); + } + else + { + drop_xsdt: + + DBG("About to drop XSDT\n"); + + /*FIXME: Now we just hope that if MacOS doesn't find XSDT it reverts to RSDT. + * A Better strategy would be to generate + */ + + rsdp_mod->XsdtAddress=0xffffffffffffffffLL; + printf("XSDT not found or XSDT incorrect\n"); + } + } + + // Correct the checksum of RSDP + + DBG("Original checksum %d\n", rsdp_mod->Checksum); + + rsdp_mod->Checksum=0; + rsdp_mod->Checksum=256-checksum8(rsdp_mod,20); + + DBG("New checksum %d\n", rsdp_mod->Checksum); + + if (version) + { + DBG("Original extended checksum %d\n", rsdp_mod->ExtendedChecksum); + + rsdp_mod->ExtendedChecksum=0; + rsdp_mod->ExtendedChecksum=256-checksum8(rsdp_mod,rsdp_mod->Length); + + DBG("New extended checksum %d\n", rsdp_mod->ExtendedChecksum); + + } + + verbose("Patched ACPI version %d DSDT\n", version+1); + if (version) + { + acpi20_p = (uint32_t)rsdp_mod; + addConfigurationTable(&gEfiAcpi20TableGuid, &acpi20_p, "ACPI_20"); + } + else + { + acpi10_p = (uint32_t)rsdp_mod; + addConfigurationTable(&gEfiAcpiTableGuid, &acpi10_p, "ACPI"); + } + } + #if DEBUG_DSDT + getc(); + #endif + return 1; +} Index: trunk/i386/libsaio/fdisk.h =================================================================== --- trunk/i386/libsaio/fdisk.h (revision 0) +++ trunk/i386/libsaio/fdisk.h (revision 1) @@ -0,0 +1,89 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Copyright (c) 1992 NeXT Computer, Inc. + * + * IBM PC disk partitioning data structures. + * + * HISTORY + * + * 8 July 1992 David E. Bohman at NeXT + * Created. + */ + +#ifndef __LIBSAIO_FDISK_H +#define __LIBSAIO_FDISK_H + +#define DISK_BLK0 0 /* blkno of boot block */ +#define DISK_BLK0SZ 512 /* size of boot block */ +#define DISK_BOOTSZ 446 /* size of boot code in boot block */ +#define DISK_SIGNATURE 0xAA55 /* signature of the boot record */ +#define FDISK_NPART 4 /* number of entries in fdisk table */ +#define FDISK_ACTIVE 0x80 /* indicator of active partition */ +#define FDISK_NEXTNAME 0xA7 /* indicator of NeXT partition */ +#define FDISK_DOS12 0x01 /* 12-bit fat < 10MB dos partition */ +#define FDISK_DOS16S 0x04 /* 16-bit fat < 32MB dos partition */ +#define FDISK_DOSEXT 0x05 /* extended dos partition */ +#define FDISK_DOS16B 0x06 /* 16-bit fat >= 32MB dos partition */ +#define FDISK_NTFS 0x07 /* NTFS partition */ +#define FDISK_SMALLFAT32 0x0b /* FAT32 partition */ +#define FDISK_FAT32 0x0c /* FAT32 partition */ +#define FDISK_DOS16SLBA 0x0e +#define FDISK_LINUX 0x83 +#define FDISK_UFS 0xa8 /* Apple UFS partition */ +#define FDISK_HFS 0xaf /* Apple HFS partition */ +#define FDISK_BOOTER 0xab /* Apple booter partition */ + +/* + * Format of fdisk partion entry (if present). + */ +struct fdisk_part { + unsigned char bootid; /* bootable or not */ + unsigned char beghead; /* begining head, sector, cylinder */ + unsigned char begsect; /* begcyl is a 10-bit number */ + unsigned char begcyl; /* High 2 bits are in begsect */ + unsigned char systid; /* OS type */ + unsigned char endhead; /* ending head, sector, cylinder */ + unsigned char endsect; /* endcyl is a 10-bit number */ + unsigned char endcyl; /* High 2 bits are in endsect */ + unsigned long relsect; /* partion physical offset on disk */ + unsigned long numsect; /* number of sectors in partition */ +} __attribute__((packed)); + +/* + * Format of boot block. + */ +struct disk_blk0 { + unsigned char bootcode[DISK_BOOTSZ]; + unsigned char parts[FDISK_NPART][sizeof (struct fdisk_part)]; + unsigned short signature; +}; + +struct REAL_disk_blk0 { + unsigned char bootcode[DISK_BOOTSZ]; + struct fdisk_part parts[FDISK_NPART]; + unsigned short signature; +} __attribute__((packed)); + +#endif /* !__LIBSAIO_FDISK_H */ Index: trunk/i386/libsaio/dsdt_patcher.h =================================================================== --- trunk/i386/libsaio/dsdt_patcher.h (revision 0) +++ trunk/i386/libsaio/dsdt_patcher.h (revision 1) @@ -0,0 +1,20 @@ +/* + * Copyright 2008 mackerintel + */ + +#ifndef __LIBSAIO_DSDT_PATCHER_H +#define __LIBSAIO_DSDT_PATCHER_H + +#include "libsaio.h" + +uint64_t acpi10_p; +uint64_t acpi20_p; +uint64_t smbios_p; +extern int setupAcpi(); + +extern EFI_STATUS addConfigurationTable(); + +extern EFI_GUID gEfiAcpiTableGuid; +extern EFI_GUID gEfiAcpi20TableGuid; + +#endif /* !__LIBSAIO_DSDT_PATCHER_H */ Index: trunk/i386/libsaio/ntfs.c =================================================================== --- trunk/i386/libsaio/ntfs.c (revision 0) +++ trunk/i386/libsaio/ntfs.c (revision 1) @@ -0,0 +1,311 @@ +/* + * Copyright (c) 2004 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Copyright (c) 1999-2004 Apple Computer, Inc. All Rights Reserved. + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +#include "libsaio.h" +#include "sl.h" + +#define BYTE_ORDER_MARK 0xFEFF + +#include "ntfs_private.h" + +#define FS_TYPE "ntfs" +#define FS_NAME_FILE "NTFS" + +#define MAX_BLOCK_SIZE 2048 +#define MAX_CLUSTER_SIZE 32768 + +#define LABEL_LENGTH 1024 +#define UNKNOWN_LABEL "Untitled NTFS" + +#define FSUR_IO_FAIL -1 +#define FSUR_UNRECOGNIZED -1 +#define FSUR_RECOGNIZED 0 + +#define ERROR -1 + +/* + * Process per-sector "fixups" that NTFS uses to detect corruption of + * multi-sector data structures, like MFT records. + */ +static int +ntfs_fixup( + char *buf, + size_t len, + u_int32_t magic, + u_int32_t bytesPerSector) +{ + struct fixuphdr *fhp = (struct fixuphdr *) buf; + int i; + u_int16_t fixup; + u_int16_t *fxp; + u_int16_t *cfxp; + u_int32_t fixup_magic; + u_int16_t fixup_count; + u_int16_t fixup_offset; + + fixup_magic = OSReadLittleInt32(&fhp->fh_magic,0); + if (fixup_magic != magic) { + error("ntfs_fixup: magic doesn't match: %08x != %08x\n", + fixup_magic, magic); + return (ERROR); + } + fixup_count = OSReadLittleInt16(&fhp->fh_fnum,0); + if ((fixup_count - 1) * bytesPerSector != len) { + error("ntfs_fixup: " \ + "bad fixups number: %d for %ld bytes block\n", + fixup_count, (long)len); /* XXX printf kludge */ + return (ERROR); + } + fixup_offset = OSReadLittleInt16(&fhp->fh_foff,0); + if (fixup_offset >= len) { + error("ntfs_fixup: invalid offset: %x", fixup_offset); + return (ERROR); + } + fxp = (u_int16_t *) (buf + fixup_offset); + cfxp = (u_int16_t *) (buf + bytesPerSector - 2); + fixup = *fxp++; + for (i = 1; i < fixup_count; i++, fxp++) { + if (*cfxp != fixup) { + error("ntfs_fixup: fixup %d doesn't match\n", i); + return (ERROR); + } + *cfxp = *fxp; + cfxp = (u_int16_t *)(((caddr_t)cfxp) + bytesPerSector); + } + return (0); +} + +/* + * Find a resident attribute of a given type. Returns a pointer to the + * attribute data, and its size in bytes. + */ +static int +ntfs_find_attr( + char *buf, + u_int32_t attrType, + void **attrData, + size_t *attrSize) +{ + struct filerec *filerec; + struct attr *attr; + u_int16_t offset; + + filerec = (struct filerec *) buf; + offset = OSReadLittleInt16(&filerec->fr_attroff,0); + attr = (struct attr *) (buf + offset); + + /* Should we also check offset < buffer size? */ + while (attr->a_hdr.a_type != 0xFFFFFFFF) /* same for big/little endian */ + { + if (OSReadLittleInt32(&attr->a_hdr.a_type,0) == attrType) + { + if (attr->a_hdr.a_flag != 0) + { + //verbose("NTFS: attriubte 0x%X is non-resident\n", attrType); + return 1; + } + + *attrSize = OSReadLittleInt16(&attr->a_r.a_datalen,0); + *attrData = buf + offset + OSReadLittleInt16(&attr->a_r.a_dataoff,0); + return 0; /* found it! */ + } + + /* Skip to the next attribute */ + offset += OSReadLittleInt32(&attr->a_hdr.reclen,0); + attr = (struct attr *) (buf + offset); + } + + return 1; /* No matching attrType found */ +} + +/* + * Examine a volume to see if we recognize it as a mountable. + */ +void +NTFSGetDescription(CICell ih, char *str, long strMaxLen) +{ + struct bootfile *boot; + unsigned bytesPerSector; + unsigned sectorsPerCluster; + int mftRecordSize; + u_int64_t totalClusters; + u_int64_t cluster, mftCluster; + size_t mftOffset; + void *nameAttr; + size_t nameSize; + char *buf; + + buf = (char *)malloc(MAX_CLUSTER_SIZE); + if (buf == 0) { + goto error; + } + + /* + * Read the boot sector, check signatures, and do some minimal + * sanity checking. NOTE: the size of the read below is intended + * to be a multiple of all supported block sizes, so we don't + * have to determine or change the device's block size. + */ + Seek(ih, 0); + Read(ih, (long)buf, MAX_BLOCK_SIZE); + + boot = (struct bootfile *) buf; + + /* + * The first three bytes are an Intel x86 jump instruction. I assume it + * can be the same forms as DOS FAT: + * 0xE9 0x?? 0x?? + * 0xEC 0x?? 0x90 + * where 0x?? means any byte value is OK. + */ + if (boot->reserved1[0] != 0xE9 + && (boot->reserved1[0] != 0xEB || boot->reserved1[2] != 0x90)) + { + goto error; + } + + /* + * Check the "NTFS " signature. + */ + if (memcmp((const char *)boot->bf_sysid, "NTFS ", 8) != 0) + { + goto error; + } + + /* + * Make sure the bytes per sector and sectors per cluster are + * powers of two, and within reasonable ranges. + */ + bytesPerSector = OSReadLittleInt16(&boot->bf_bps,0); + if ((bytesPerSector & (bytesPerSector-1)) || bytesPerSector < 512 || bytesPerSector > 32768) + { + //verbose("NTFS: invalid bytes per sector (%d)\n", bytesPerSector); + goto error; + } + + sectorsPerCluster = boot->bf_spc; /* Just one byte; no swapping needed */ + if ((sectorsPerCluster & (sectorsPerCluster-1)) || sectorsPerCluster > 128) + { + //verbose("NTFS: invalid sectors per cluster (%d)\n", bytesPerSector); + goto error; + } + + /* + * Calculate the number of clusters from the number of sectors. + * Then bounds check the $MFT and $MFTMirr clusters. + */ + totalClusters = OSReadLittleInt64(&boot->bf_spv,0) / sectorsPerCluster; + mftCluster = OSReadLittleInt64(&boot->bf_mftcn,0); + if (mftCluster > totalClusters) + { + ////verbose("NTFS: invalid $MFT cluster (%lld)\n", mftCluster); + goto error; + } + cluster = OSReadLittleInt64(&boot->bf_mftmirrcn,0); + if (cluster > totalClusters) + { + //verbose("NTFS: invalid $MFTMirr cluster (%lld)\n", cluster); + goto error; + } + + /* + * Determine the size of an MFT record. + */ + mftRecordSize = (int8_t) boot->bf_mftrecsz; + if (mftRecordSize < 0) + mftRecordSize = 1 << -mftRecordSize; + else + mftRecordSize *= bytesPerSector * sectorsPerCluster; + //verbose("NTFS: MFT record size = %d\n", mftRecordSize); + + /* + * Read the MFT record for $Volume. This assumes the first four + * file records in the MFT are contiguous; if they aren't, we + * would have to map the $MFT itself. + * + * This will fail if the device sector size is larger than the + * MFT record size, since the $Volume record won't be aligned + * on a sector boundary. + */ + mftOffset = mftCluster * sectorsPerCluster * bytesPerSector; + mftOffset += mftRecordSize * NTFS_VOLUMEINO; + + Seek(ih, mftOffset); + Read(ih, (long)buf, mftRecordSize); +#if UNUSED + if (lseek(fd, mftOffset, SEEK_SET) == -1) + { + //verbose("NTFS: lseek to $Volume failed: %s\n", strerror(errno)); + goto error; + } + if (read(fd, buf, mftRecordSize) != mftRecordSize) + { + //verbose("NTFS: error reading MFT $Volume record: %s\n", + strerror(errno)); + goto error; + } +#endif + + if (ntfs_fixup(buf, mftRecordSize, NTFS_FILEMAGIC, bytesPerSector) != 0) + { + //verbose("NTFS: block fixup failed\n"); + goto error; + } + + /* + * Loop over the attributes, looking for $VOLUME_NAME (0x60). + */ + if(ntfs_find_attr(buf, NTFS_A_VOLUMENAME, &nameAttr, &nameSize) != 0) + { + //verbose("NTFS: $VOLUME_NAME attribute not found\n"); + goto error; + } + + str[0] = '\0'; + + utf_encodestr( nameAttr, nameSize / 2, (u_int8_t *)str, strMaxLen, OSLittleEndian ); + + free(buf); + return; + + error: + if (buf) free(buf); + return; +} + +BOOL NTFSProbe(const void * buffer) +{ + BOOL result = FALSE; + + const struct bootfile * part_bootfile = buffer; // NTFS boot sector structure + + // Looking for NTFS signature. + if (strncmp((const char *)part_bootfile->bf_sysid, NTFS_BBID, NTFS_BBIDLEN) == 0) + result = TRUE; + + return result; +} + + Index: trunk/i386/libsaio/nvidia.c =================================================================== --- trunk/i386/libsaio/nvidia.c (revision 0) +++ trunk/i386/libsaio/nvidia.c (revision 1) @@ -0,0 +1,748 @@ +/* + * NVidia injector + * + * Copyright (C) 2009 Jasmin Fazlic, iNDi + * + * NVidia injector is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * NVidia driver and injector is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with NVidia injector. If not, see . + */ +/* + * Alternatively you can choose to comply with APSL + */ + + +/* + * DCB-Table parsing is based on software (nouveau driver) originally distributed under following license: + * + * + * Copyright 2005-2006 Erik Waling + * Copyright 2006 Stephane Marchesin + * Copyright 2007-2009 Stuart Bennett + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "libsaio.h" +#include "bootstruct.h" +#include "pci.h" +#include "platform.h" +#include "device_inject.h" +#include "nvidia.h" + +#ifndef DEBUG_NVIDIA +#define DEBUG_NVIDIA 0 +#endif + +#if DEBUG_NVIDIA +#define DBG(x...) printf(x) +#else +#define DBG(x...) +#endif + +#define PATCH_ROM_SUCCESS 1 +#define PATCH_ROM_SUCCESS_HAS_LVDS 2 +#define PATCH_ROM_FAILED 0 +#define MAX_NUM_DCB_ENTRIES 16 + +#define TYPE_GROUPED 0xff + +extern uint32_t devices_number; + +const char *nvidia_compatible_0[] = { "@0,compatible", "NVDA,NVMac" }; +const char *nvidia_compatible_1[] = { "@1,compatible", "NVDA,NVMac" }; +const char *nvidia_device_type_0[] = { "@0,device_type", "display" }; +const char *nvidia_device_type_1[] = { "@1,device_type", "display" }; +const char *nvidia_device_type[] = { "device_type", "NVDA,Parent" }; +const char *nvidia_name_0[] = { "@0,name", "NVDA,Display-A" }; +const char *nvidia_name_1[] = { "@1,name", "NVDA,Display-B" }; +const char *nvidia_slot_name[] = { "AAPL,slot-name", "Slot-1"}; + +uint8_t default_NVCAP[]= { +0x04, 0x00, 0x00, 0x00, +0x00, 0x00, 0x0d, 0x00, +0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x0a, +0x00, 0x00, 0x00, 0x00 +}; + +uint16_t swap16(uint16_t toswap) { + return (((toswap & 0x00FF) << 8) | ((toswap & 0xFF00) >> 8)); +} + +// Known cards as of 2008/08/26 +static struct nv_chipsets_t NVKnownChipsets[] = { + { 0x00000000, "Unknown" }, + { 0x10DE0301, "GeForce FX 5800 Ultra" }, + { 0x10DE0302, "GeForce FX 5800" }, + { 0x10DE0308, "Quadro FX 2000" }, + { 0x10DE0309, "Quadro FX 1000" }, + { 0x10DE0311, "GeForce FX 5600 Ultra" }, + { 0x10DE0312, "GeForce FX 5600" }, + { 0x10DE0314, "GeForce FX 5600XT" }, + { 0x10DE031A, "GeForce FX Go5600" }, + { 0x10DE031B, "GeForce FX Go5650" }, + { 0x10DE031C, "Quadro FX Go700" }, + { 0x10DE0324, "GeForce FX Go5200" }, + { 0x10DE0325, "GeForce FX Go5250" }, + { 0x10DE0326, "GeForce FX 5500" }, + { 0x10DE0328, "GeForce FX Go5200 32M/64M" }, + { 0x10DE032A, "Quadro NVS 55/280 PCI" }, + { 0x10DE032B, "Quadro FX 500/600 PCI" }, + { 0x10DE032C, "GeForce FX Go53xx Series" }, + { 0x10DE032D, "GeForce FX Go5100" }, + { 0x10DE0330, "GeForce FX 5900 Ultra" }, + { 0x10DE0331, "GeForce FX 5900" }, + { 0x10DE0332, "GeForce FX 5900XT" }, + { 0x10DE0333, "GeForce FX 5950 Ultra" }, + { 0x10DE0334, "GeForce FX 5900ZT" }, + { 0x10DE0338, "Quadro FX 3000" }, + { 0x10DE033F, "Quadro FX 700" }, + { 0x10DE0341, "GeForce FX 5700 Ultra" }, + { 0x10DE0342, "GeForce FX 5700" }, + { 0x10DE0343, "GeForce FX 5700LE" }, + { 0x10DE0344, "GeForce FX 5700VE" }, + { 0x10DE0347, "GeForce FX Go5700" }, + { 0x10DE0348, "GeForce FX Go5700" }, + { 0x10DE034C, "Quadro FX Go1000" }, + { 0x10DE034E, "Quadro FX 1100" }, + { 0x10DE0040, "GeForce 6800 Ultra" }, + { 0x10DE0041, "GeForce 6800" }, + { 0x10DE0042, "GeForce 6800 LE" }, + { 0x10DE0043, "GeForce 6800 XE" }, + { 0x10DE0044, "GeForce 6800 XT" }, + { 0x10DE0045, "GeForce 6800 GT" }, + { 0x10DE0046, "GeForce 6800 GT" }, + { 0x10DE0047, "GeForce 6800 GS" }, + { 0x10DE0048, "GeForce 6800 XT" }, + { 0x10DE004E, "Quadro FX 4000" }, + { 0x10DE00C0, "GeForce 6800 GS" }, + { 0x10DE00C1, "GeForce 6800" }, + { 0x10DE00C2, "GeForce 6800 LE" }, + { 0x10DE00C3, "GeForce 6800 XT" }, + { 0x10DE00C8, "GeForce Go 6800" }, + { 0x10DE00C9, "GeForce Go 6800 Ultra" }, + { 0x10DE00CC, "Quadro FX Go1400" }, + { 0x10DE00CD, "Quadro FX 3450/4000 SDI" }, + { 0x10DE00CE, "Quadro FX 1400" }, + { 0x10DE0140, "GeForce 6600 GT" }, + { 0x10DE0141, "GeForce 6600" }, + { 0x10DE0142, "GeForce 6600 LE" }, + { 0x10DE0143, "GeForce 6600 VE" }, + { 0x10DE0144, "GeForce Go 6600" }, + { 0x10DE0145, "GeForce 6610 XL" }, + { 0x10DE0146, "GeForce Go 6600 TE/6200 TE" }, + { 0x10DE0147, "GeForce 6700 XL" }, + { 0x10DE0148, "GeForce Go 6600" }, + { 0x10DE0149, "GeForce Go 6600 GT" }, + { 0x10DE014C, "Quadro FX 550" }, + { 0x10DE014D, "Quadro FX 550" }, + { 0x10DE014E, "Quadro FX 540" }, + { 0x10DE014F, "GeForce 6200" }, + { 0x10DE0160, "GeForce 6500" }, + { 0x10DE0161, "GeForce 6200 TurboCache(TM)" }, + { 0x10DE0162, "GeForce 6200SE TurboCache(TM)" }, + { 0x10DE0163, "GeForce 6200 LE" }, + { 0x10DE0164, "GeForce Go 6200" }, + { 0x10DE0165, "Quadro NVS 285" }, + { 0x10DE0166, "GeForce Go 6400" }, + { 0x10DE0167, "GeForce Go 6200" }, + { 0x10DE0168, "GeForce Go 6400" }, + { 0x10DE0169, "GeForce 6250" }, + { 0x10DE016A, "GeForce 7100 GS" }, + { 0x10DE0211, "GeForce 6800" }, + { 0x10DE0212, "GeForce 6800 LE" }, + { 0x10DE0215, "GeForce 6800 GT" }, + { 0x10DE0218, "GeForce 6800 XT" }, + { 0x10DE0221, "GeForce 6200" }, + { 0x10DE0222, "GeForce 6200 A-LE" }, + { 0x10DE0090, "GeForce 7800 GTX" }, + { 0x10DE0091, "GeForce 7800 GTX" }, + { 0x10DE0092, "GeForce 7800 GT" }, + { 0x10DE0093, "GeForce 7800 GS" }, + { 0x10DE0095, "GeForce 7800 SLI" }, + { 0x10DE0098, "GeForce Go 7800" }, + { 0x10DE0099, "GeForce Go 7800 GTX" }, + { 0x10DE009D, "Quadro FX 4500" }, + { 0x10DE01D1, "GeForce 7300 LE" }, + { 0x10DE01D3, "GeForce 7300 SE" }, + { 0x10DE01D6, "GeForce Go 7200" }, + { 0x10DE01D7, "GeForce Go 7300" }, + { 0x10DE01D8, "GeForce Go 7400" }, + { 0x10DE01D9, "GeForce Go 7400 GS" }, + { 0x10DE01DA, "Quadro NVS 110M" }, + { 0x10DE01DB, "Quadro NVS 120M" }, + { 0x10DE01DC, "Quadro FX 350M" }, + { 0x10DE01DD, "GeForce 7500 LE" }, + { 0x10DE01DE, "Quadro FX 350" }, + { 0x10DE01DF, "GeForce 7300 GS" }, + { 0x10DE0391, "GeForce 7600 GT" }, + { 0x10DE0392, "GeForce 7600 GS" }, + { 0x10DE0393, "GeForce 7300 GT" }, + { 0x10DE0394, "GeForce 7600 LE" }, + { 0x10DE0395, "GeForce 7300 GT" }, + { 0x10DE0397, "GeForce Go 7700" }, + { 0x10DE0398, "GeForce Go 7600" }, + { 0x10DE0399, "GeForce Go 7600 GT"}, + { 0x10DE039A, "Quadro NVS 300M" }, + { 0x10DE039B, "GeForce Go 7900 SE" }, + { 0x10DE039C, "Quadro FX 550M" }, + { 0x10DE039E, "Quadro FX 560" }, + { 0x10DE0290, "GeForce 7900 GTX" }, + { 0x10DE0291, "GeForce 7900 GT" }, + { 0x10DE0292, "GeForce 7900 GS" }, + { 0x10DE0298, "GeForce Go 7900 GS" }, + { 0x10DE0299, "GeForce Go 7900 GTX" }, + { 0x10DE029A, "Quadro FX 2500M" }, + { 0x10DE029B, "Quadro FX 1500M" }, + { 0x10DE029C, "Quadro FX 5500" }, + { 0x10DE029D, "Quadro FX 3500" }, + { 0x10DE029E, "Quadro FX 1500" }, + { 0x10DE029F, "Quadro FX 4500 X2" }, + { 0x10DE0240, "GeForce 6150" }, + { 0x10DE0241, "GeForce 6150 LE" }, + { 0x10DE0242, "GeForce 6100" }, + { 0x10DE0244, "GeForce Go 6150" }, + { 0x10DE0247, "GeForce Go 6100" }, + + /*************** G8x ***************/ + { 0x10DE0191, "GeForce 8800 GTX" }, + { 0x10DE0193, "GeForce 8800 GTS" }, + { 0x10DE0194, "GeForce 8800 Ultra" }, + { 0x10DE019D, "Quadro FX 5600" }, + { 0x10DE019E, "Quadro FX 4600" }, + { 0x10DE0400, "GeForce 8600 GTS" }, + { 0x10DE0401, "GeForce 8600 GT" }, + { 0x10DE0402, "GeForce 8600 GT" }, + { 0x10DE0403, "GeForce 8600 GS" }, + { 0x10DE0404, "GeForce 8400 GS" }, + { 0x10DE0405, "GeForce 9500M GS" }, + { 0x10DE0407, "GeForce 8600M GT" }, + { 0x10DE0408, "GeForce 9650M GS" }, + { 0x10DE0409, "GeForce 8700M GT" }, + { 0x10DE040A, "Quadro FX 370" }, + { 0x10DE040B, "Quadro NVS 320M" }, + { 0x10DE040C, "Quadro FX 570M" }, + { 0x10DE040D, "Quadro FX 1600M" }, + { 0x10DE040E, "Quadro FX 570" }, + { 0x10DE040F, "Quadro FX 1700" }, + { 0x10DE0420, "GeForce 8400 SE" }, + { 0x10DE0421, "GeForce 8500 GT" }, + { 0x10DE0422, "GeForce 8400 GS" }, + { 0x10DE0423, "GeForce 8300 GS" }, + { 0x10DE0424, "GeForce 8400 GS" }, + { 0x10DE0425, "GeForce 8600M GS" }, + { 0x10DE0426, "GeForce 8400M GT" }, + { 0x10DE0427, "GeForce 8400M GS" }, + { 0x10DE0428, "GeForce 8400M G" }, + { 0x10DE0429, "Quadro NVS 140M" }, + { 0x10DE042A, "Quadro NVS 130M" }, + { 0x10DE042B, "Quadro NVS 135M" }, + { 0x10DE042C, "GeForce 9400 GT" }, + { 0x10DE042D, "Quadro FX 360M" }, + { 0x10DE042E, "GeForce 9300M G" }, + { 0x10DE042F, "Quadro NVS 290" }, + { 0x10DE05E1, "GeForce GTX 280" }, + { 0x10DE05E2, "GeForce GTX 260" }, + { 0x10DE0600, "GeForce 8800 GTS 512" }, + { 0x10DE0602, "GeForce 8800 GT" }, + { 0x10DE0604, "GeForce 9800 GX2" }, + { 0x10DE0605, "GeForce 9800 GT" }, + { 0x10DE0606, "GeForce 8800 GS" }, + { 0x10DE0609, "GeForce 8800M GTS" }, + { 0x10DE060C, "GeForce 8800M GTX" }, + { 0x10DE060D, "GeForce 8800 GS" }, + { 0x10DE0610, "GeForce 9600 GSO" }, + { 0x10DE0611, "GeForce 8800 GT" }, + { 0x10DE0612, "GeForce 9800 GTX" }, + { 0x10DE0613, "GeForce 9800 GTX+" }, + { 0x10DE0614, "GeForce 9800 GT" }, + { 0x10DE0615, "GeForce 250 GTS" }, + { 0x10DE061A, "Quadro FX 3700" }, + { 0x10DE061C, "Quadro FX 3600M" }, + { 0x10DE0622, "GeForce 9600 GT" }, + { 0x10DE0623, "GeForce 9600 GS" }, + { 0x10DE0628, "GeForce 9800M GTS" }, + { 0x10DE062A, "GeForce 9700M GTS" }, + { 0x10DE062C, "GeForce 9800M GTS" }, + { 0x10DE0640, "GeForce 9500 GT" }, + { 0x10DE0647, "GeForce 9600M GT" }, + { 0x10DE0648, "GeForce 9600M GS" }, + { 0x10DE0649, "GeForce 9600M GT" }, + { 0x10DE064B, "GeForce 9500M G" }, + { 0x10DE065B, "GeForce 9400 GT" }, + { 0x10DE06E1, "GeForce 9300 GS" }, + { 0x10DE06E4, "GeForce 8400 GS" }, + { 0x10DE06E5, "GeForce 9300M GS" }, + { 0x10DE06E8, "GeForce 9200M GS" }, + { 0x10DE06E9, "GeForce 9300M GS" }, + { 0x10DE06EA, "Quadro NVS 150M" }, + { 0x10DE06EB, "Quadro NVS 160M" }, + + /*************** GT2xx *************/ + { 0x10DE05E0, "GeForce GTX 295" }, + { 0x10DE05E1, "GeForce GTX 280" }, + { 0x10DE05E2, "GeForce GTX 260" }, + { 0x10DE05E3, "GeForce GTX 285" }, + { 0x10DE05E6, "GeForce GTX 275" }, +}; + +uint32_t swap32(uint32_t toswap) { + return ((toswap & 0x000000FF) << 24) | + ((toswap & 0x0000FF00) << 8 ) | + ((toswap & 0x00FF0000) >> 8 ) | + ((toswap & 0xFF000000) >> 24); +} + +uint8_t read8(uint8_t *ptr, uint16_t offset) { + return ptr[offset]; +} + +uint16_t read16(uint8_t *ptr, uint16_t offset) { + uint8_t ret[2]; + ret[0] = ptr[offset+1]; + ret[1] = ptr[offset]; + return *((uint16_t*)&ret); +} + +uint32_t read32(uint8_t *ptr, uint16_t offset) { + uint8_t ret[4]; + ret[0] = ptr[offset+3]; + ret[1] = ptr[offset+2]; + ret[2] = ptr[offset+1]; + ret[3] = ptr[offset]; + return *((uint32_t*)&ret); +} + +int patch_nvidia_rom(uint8_t *rom) { + if(!rom || (rom[0] != 0x55 && rom[1] != 0xaa)) { + printf("False ROM signature: 0x%02x%02x\n", rom[0], rom[1]); + return PATCH_ROM_FAILED; + } + + uint16_t dcbptr = swap16(read16(rom, 0x36)); + if(!dcbptr) { + printf("no dcb table found\n"); + return PATCH_ROM_FAILED; + }/* else + printf("dcb table at offset 0x%04x\n", dcbptr); + */ + uint8_t *dcbtable = &rom[dcbptr]; + uint8_t dcbtable_version = dcbtable[0]; + uint8_t headerlength = 0; + uint8_t recordlength = 0; + uint8_t numentries = 0; + + if(dcbtable_version >= 0x20) { + uint32_t sig; + + if(dcbtable_version >= 0x30) { + headerlength = dcbtable[1]; + numentries = dcbtable[2]; + recordlength = dcbtable[3]; + sig = *(uint32_t *)&dcbtable[6]; + } else { + sig = *(uint32_t *)&dcbtable[4]; + headerlength = 8; + } + if (sig != 0x4edcbdcb) { + printf("bad display config block signature (0x%8x)\n", sig); + return PATCH_ROM_FAILED; + } + } else if (dcbtable_version >= 0x14) { /* some NV15/16, and NV11+ */ + char sig[8] = { 0 }; + + strncpy(sig, (char *)&dcbtable[-7], 7); + recordlength = 10; + if (strcmp(sig, "DEV_REC")) { + printf("Bad Display Configuration Block signature (%s)\n", sig); + return PATCH_ROM_FAILED; + } + } else { + return PATCH_ROM_FAILED; + } + + if(numentries >= MAX_NUM_DCB_ENTRIES) + numentries = MAX_NUM_DCB_ENTRIES; + + uint8_t num_outputs = 0, i=0; + struct dcbentry { + uint8_t type; + uint8_t index; + uint8_t *heads; + } entries[numentries]; + + for (i = 0; i < numentries; i++) { + uint32_t connection; + connection = *(uint32_t *)&dcbtable[headerlength + recordlength * i]; + /* Should we allow discontinuous DCBs? Certainly DCB I2C tables can be discontinuous */ + if ((connection & 0x0000000f) == 0x0000000f) /* end of records */ + continue; + if (connection == 0x00000000) /* seen on an NV11 with DCB v1.5 */ + continue; + if ((connection & 0xf) == 0x6) /* we skip type 6 as it doesnt appear on macbook nvcaps */ + continue; + + entries[num_outputs].type = connection & 0xf; + entries[num_outputs].index = num_outputs; + entries[num_outputs++].heads = (uint8_t*)&(dcbtable[(headerlength + recordlength * i) + 1]); + + } + + int has_lvds = false; + uint8_t channel1 = 0, channel2 = 0; + + for(i=0; i channel2) { + uint8_t buff = channel1; + channel1 = channel2; + channel2 = buff; + } + + default_NVCAP[6] = channel1; + default_NVCAP[8] = channel2; + + // patching HEADS + for(i=0; idev.addr, 0x10 ); + regs = (uint8_t *) (bar[0] & ~0x0f); + + // Amount of VRAM in kilobytes + videoRam = (REG32(0x10020c) & 0xfff00000) >> 10; + + model = get_nvidia_model((nvda_dev->vendor_id << 16) | nvda_dev->device_id); + + verbose("nVidia %s %dMB NV%02x [%04x:%04x] :: %s\n", + model, (videoRam / 1024), + (REG32(0) >> 20) & 0x1ff, nvda_dev->vendor_id, nvda_dev->device_id, + devicepath); + + rom = malloc(0x10000); + + if(!rom) + { + verbose(" ROM malloc failed.\n"); + return 0; + } + + if (!getValueForKey("VideoROM", &nvFilename, &len, &bootInfo->bootConfig)) + nvFilename="NVIDIA.ROM"; + + // Load video bios overide + nvBiosOveride = nvBiosSize = load_nvidia_bios_file((char *)nvFilename, (char *)rom); + + // Otherwise read bios from card + if (nvBiosOveride == 0) + { + // TODO: we should really check for the signature + // before copying the rom, i think. + + // PRAMIN first + nvRom = (uint8_t*)®s[NV_PRAMIN_OFFSET]; + bcopy((uint32_t *)nvRom, rom, 0x10000); + + // Valid Signature ? + if(rom[0] != 0x55 && rom[1] != 0xaa) + { + // PROM next + // Enable PROM access + (REG32(NV_PBUS_PCI_NV_20)) = NV_PBUS_PCI_NV_20_ROM_SHADOW_DISABLED; + + nvRom = (uint8_t*)®s[NV_PROM_OFFSET]; + bcopy((uint8_t *)nvRom, rom, 0x10000); + + // disable PROM access + (REG32(NV_PBUS_PCI_NV_20)) = NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED; + + // Valid Signature ? + if(rom[0] != 0x55 && rom[1] != 0xaa) + { + // 0xC0000 last + bcopy((char *)0xc0000, rom, 0x10000); + + // Valid Signature ? + if(rom[0] != 0x55 && rom[1] != 0xaa) + { + verbose(" Unable to locate video bios.\n"); + return 0; + } + else + DBG(" ROM Address 0x%x Signature 0x%02x%02x\n", + nvRom, (uint8_t)rom[0], (uint8_t)rom[1]); + } + else + DBG(" PROM Address 0x%x Signature 0x%02x%02x\n", + nvRom, (uint8_t)rom[0], (uint8_t)rom[1]); + } + else + DBG(" PRAM Address 0x%x Signature 0x%02x%02x\n", + nvRom, (uint8_t)rom[0], (uint8_t)rom[1]); + } + else + DBG(" %s Signature 0x%02x%02x %d bytes\n", + nvFilename, (uint8_t)rom[0], (uint8_t)rom[1], nvBiosOveride); + + nvPatch = patch_nvidia_rom(rom); + + if(nvPatch == PATCH_ROM_FAILED) + { + printf(" ROM Patching Failed.\n"); + return false; + } + + struct pci_rom_pci_header_t *rom_pci_header; + rom_pci_header = (struct pci_rom_pci_header_t*)(rom + *(uint16_t *)&rom[24]); + + // check for 'PCIR' sig + if (rom_pci_header->signature == 0x50434952) + if (rom_pci_header->device != nvda_dev->device_id) + // Get Model from the OpROM + model = get_nvidia_model((rom_pci_header->vendor << 16) | rom_pci_header->device); + else + printf("incorrect PCI ROM sig: 0x%x\n", rom_pci_header->signature); + + if (!string) + string = devprop_create_string(); + + struct DevPropDevice *device = malloc(sizeof(struct DevPropDevice)); + device = devprop_add_device(string, devicepath); + + if(!device) + { + printf("Failed initializing dev-prop string dev-entry, press any key...\n"); + free(rom); + getc(); + return false; + } + + /* FIXME: for primary graphics card only */ + uint32_t boot_display = 0x00000001; + devprop_add_value(device, "@0,AAPL,boot-display", (uint8_t*)&boot_display, 4); + + if(nvPatch == PATCH_ROM_SUCCESS_HAS_LVDS) + { + uint8_t built_in = 0x01; + devprop_add_value(device, "@0,built-in", (uint8_t*)&built_in, 1); + } + + videoRam *= 1024; + + sprintf(biosVersion, "xx.xx.xx - %s", (nvBiosOveride > 0) ? nvFilename : "internal"); + + devprop_add_nvidia_template(device); + devprop_add_value(device, "NVCAP", default_NVCAP, 20); + devprop_add_value(device, "VRAM,totalsize", (uint8_t*)&videoRam, 4); + devprop_add_value(device, "model", (uint8_t*)model, (strlen(model) + 1)); + devprop_add_value(device, "rom-revision", (uint8_t*)biosVersion, (strlen(biosVersion) + 1)); + + BOOL set_vbios_prop = false; + getBoolForKey("VBIOS", &set_vbios_prop, &bootInfo->bootConfig); + if (set_vbios_prop) + devprop_add_value(device, "vbios", rom, (nvBiosOveride > 0) ? nvBiosOveride : (rom[2] * 512)); + + stringdata = malloc(sizeof(uint8_t) * string->length); + if(!stringdata) + { + printf("no stringdata press a key...\n"); + getc(); + return false; + } + + memcpy(stringdata, (uint8_t*)devprop_generate_string(string), string->length); + stringlength = string->length; + + return true; +} Index: trunk/i386/libsaio/ufs_byteorder.c =================================================================== --- trunk/i386/libsaio/ufs_byteorder.c (revision 0) +++ trunk/i386/libsaio/ufs_byteorder.c (revision 1) @@ -0,0 +1,171 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Copyright 1993 NeXT, Inc. + * All rights reserved. + */ + +#include +#include +#include +#include +#include +#include "ufs_byteorder.h" +#include "libsaio.h" + +#define swapBigLongToHost(thing) ((thing) = OSSwapBigToHostInt32(thing)) +#define swapBigShortToHost(thing) ((thing) = OSSwapBigToHostInt16(thing)) +#define byte_swap_longlong(thing) ((thing) = OSSwapBigToHostInt64(thing)) +#define byte_swap_int(thing) ((thing) = OSSwapBigToHostInt32(thing)) +#define byte_swap_short(thing) ((thing) = OSSwapBigToHostInt16(thing)) + +#if UNUSED +void +byte_swap_longlongs(unsigned long long *array, int count) +{ + register unsigned long long i; + + for (i = 0; i < (unsigned long long)count; i++) + byte_swap_longlong(array[i]); +} +#endif + +void +byte_swap_ints(unsigned int *array, int count) +{ + register int i; + + for (i = 0; i < count; i++) + byte_swap_int(array[i]); +} + +void +byte_swap_shorts(unsigned short *array, int count) +{ + register int i; + + for (i = 0; i < count; i++) + byte_swap_short(array[i]); +} + +#if UNUSED +static void +swapBigIntsToHost(unsigned int *array, int count) +{ + register int i; + + for (i = 0; i < count; i++) + swapBigLongToHost(array[i]); +} + +static void +swapBigShortToHosts(unsigned short *array, int count) +{ + register int i; + + for (i = 0; i < count; i++) + swapBigShortToHost(array[i]); +} +#endif + +void +byte_swap_superblock(struct fs *sb) +{ + u_int16_t * usptr; + unsigned long size; + + byte_swap_ints(((u_int32_t *)&sb->fs_firstfield), 52); + byte_swap_int(sb->fs_cgrotor); + byte_swap_int(sb->fs_cpc); + byte_swap_shorts((u_int16_t *)sb->fs_opostbl, 16 * 8); + byte_swap_ints((u_int32_t *)sb->fs_sparecon, 50); + byte_swap_ints((u_int32_t *)&sb->fs_contigsumsize, 3); +#if UNUSED + byte_swap_longlongs((u_int64_t *)&sb->fs_maxfilesize,3); +#endif + byte_swap_ints((u_int32_t *)&sb->fs_state, 6); + + /* Got these magic numbers from mkfs.c in newfs */ + if (sb->fs_nrpos != 8 || sb->fs_cpc > 16) { + usptr = (u_int16_t *)((u_int8_t *)(sb) + (sb)->fs_postbloff); + size = sb->fs_cpc * sb->fs_nrpos; + byte_swap_shorts(usptr,size); /* fs_postbloff */ + } +} + + +/* This value should correspond to the value set in the ffs_mounts */ + +#define RESYMLNKLEN 60 + +void +byte_swap_dinode_in(struct dinode *di) +{ + int i; + + di->di_mode = OSSwapInt16(di->di_mode); + di->di_nlink = OSSwapInt16(di->di_nlink); +#ifdef LFS + di->di_u.inumber = OSSwapInt32(di->di_u.inumber); +#else + di->di_u.oldids[0] = OSSwapInt16(di->di_u.oldids[0]); + di->di_u.oldids[1] = OSSwapInt16(di->di_u.oldids[1]); +#endif + di->di_size = OSSwapInt64(di->di_size); + di->di_atime = OSSwapInt32(di->di_atime); + di->di_atimensec = OSSwapInt32(di->di_atimensec); + di->di_mtime = OSSwapInt32(di->di_mtime); + di->di_mtimensec = OSSwapInt32(di->di_mtimensec); + di->di_ctime = OSSwapInt32(di->di_ctime); + di->di_ctimensec = OSSwapInt32(di->di_ctimensec); + if (((di->di_mode & IFMT) != IFLNK ) || (di->di_size > RESYMLNKLEN)) { + for (i=0; i < NDADDR; i++) /* direct blocks */ + di->di_db[i] = OSSwapInt32(di->di_db[i]); + for (i=0; i < NIADDR; i++) /* indirect blocks */ + di->di_ib[i] = OSSwapInt32(di->di_ib[i]); + } + di->di_flags = OSSwapInt32(di->di_flags); + di->di_blocks = OSSwapInt32(di->di_blocks); + di->di_gen = OSSwapInt32(di->di_gen); + di->di_uid = OSSwapInt32(di->di_uid); + di->di_gid = OSSwapInt32(di->di_gid); + di->di_spare[0] = OSSwapInt32(di->di_spare[0]); + di->di_spare[1] = OSSwapInt32(di->di_spare[1]); +} + +void +byte_swap_dir_block_in(char *addr, int count) +{ + register struct direct * ep = (struct direct *) addr; + register int entryoffsetinblk = 0; + + while (entryoffsetinblk < count) { + ep = (struct direct *) (entryoffsetinblk + addr); + swapBigLongToHost(ep->d_ino); + swapBigShortToHost(ep->d_reclen); + entryoffsetinblk += ep->d_reclen; + if (ep->d_reclen < 12) /* handle garbage in dirs */ + break; + } +} Index: trunk/i386/libsaio/ati.c =================================================================== --- trunk/i386/libsaio/ati.c (revision 0) +++ trunk/i386/libsaio/ati.c (revision 1) @@ -0,0 +1,777 @@ +/* + * ATI injector + * + * Copyright (C) 2009 Jasmin Fazlic, iNDi, netkas + * + * ATI injector is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ATI driver and injector is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ATI injector. If not, see . + */ +/* + * Alternatively you can choose to comply with APSL + */ + + +#include "libsaio.h" +#include "bootstruct.h" +#include "pci.h" +#include "platform.h" +#include "device_inject.h" +#include "ati.h" + +#ifndef DEBUG_ATI +#define DEBUG_ATI 0 +#endif + +#if DEBUG_ATI +#define DBG(x...) printf(x) +#else +#define DBG(x...) +#endif + +#define MAX_NUM_DCB_ENTRIES 16 + +#define TYPE_GROUPED 0xff + +extern uint32_t devices_number; + +const char *ati_compatible_0[] = { "@0,compatible", "ATY,%s" }; +const char *ati_compatible_1[] = { "@1,compatible", "ATY,%s" }; +const char *ati_device_type_0[] = { "@0,device_type", "display" }; +const char *ati_device_type_1[] = { "@1,device_type", "display" }; +const char *ati_device_type[] = { "device_type", "ATY,%sParent" }; +const char *ati_name_0[] = { "@0,name", "ATY,%s" }; +const char *ati_name_1[] = { "@1,name", "ATY,%s" }; +const char *ati_name[] = { "name", "ATY,%sParent" }; +const char *ati_efidisplay_0[] = { "@0,ATY,EFIDisplay", "TMDSB" }; +struct ati_data_key ati_connector_type_0 = { 0x04, "@0,connector-type", {0x00, 0x04, 0x00, 0x00} }; +struct ati_data_key ati_connector_type_1 = { 0x04, "@1,connector-type", {0x04, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_display_con_fl_type_0 = { 0x04, "@0,display-connect-flags", {0x00, 0x00, 0x04, 0x00}}; +const char *ati_display_type_0[] = { "@0,display-type", "LCD" }; +const char *ati_display_type_1[] = { "@1,display-type", "NONE" }; +struct ati_data_key ati_aux_power_conn = { 0x04, "AAPL,aux-power-connected", {0x01, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_backlight_ctrl = { 0x04, "AAPL,backlight-control", {0x00, 0x00, 0x00, 0x00}}; +//const char *ati_slot_name[] = { "AAPL,slot-name", "Slot-1"}; +struct ati_data_key ati_aapl01_coher = { 0x04, "AAPL01,Coherency", {0x01, 0x00, 0x00, 0x00}}; +const char *ati_card_no[] = { "ATY,Card#", "109-B77101-00"}; +const char *ati_copyright[] = { "ATY,Copyright", "Copyright AMD Inc. All Rights Reserved. 2005-2009"}; +const char *ati_efi_compile_d[] = { "ATY,EFICompileDate", "Jan 26 2009"}; +struct ati_data_key ati_efi_disp_conf = { 0x08, "ATY,EFIDispConfig", {0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}}; +struct ati_data_key ati_efi_drv_type = { 0x01, "ATY,EFIDriverType", {0x02}}; +struct ati_data_key ati_efi_enbl_mode = { 0x01, "ATY,EFIEnabledMode", {0x01}}; +struct ati_data_key ati_efi_init_stat = { 0x04, "ATY,EFIHWInitStatus", {0x00, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_efi_orientation = { 0x02, "ATY,EFIOrientation", {0x02, 0x00}}; +const char *ati_efi_version[] = { "ATY,EFIVersion", "01.00.318"}; +const char *ati_efi_versionB[] = { "ATY,EFIVersionB", "113-SBSJ1G04-00R-02"}; +const char *ati_efi_versionE[] = { "ATY,EFIVersionE", "113-B7710A-318"}; +struct ati_data_key ati_mclk = { 0x04, "ATY,MCLK", {0x70, 0x2e, 0x11, 0x00}}; +struct ati_data_key ati_mem_rev_id = { 0x02, "ATY,MemRevisionID", {0x03, 0x00}}; +struct ati_data_key ati_mem_vend_id = { 0x02, "ATY,MemVendorID", {0x02, 0x00}}; +const char *ati_mrt[] = { "ATY,MRT", " "}; +const char *ati_romno[] = { "ATY,Rom#", "113-B7710C-176"}; +struct ati_data_key ati_sclk = { 0x04, "ATY,SCLK", {0x28, 0xdb, 0x0b, 0x00}}; +struct ati_data_key ati_vendor_id = { 0x02, "ATY,VendorID", {0x02, 0x10}}; +struct ati_data_key ati_platform_info = { 0x80, "ATY,PlatformInfo", {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_mvad = { 0x40, "MVAD", {0x3f, 0x5c, 0x82, 0x02, 0xff, 0x90, 0x00, 0x54, 0x60, 0x00, 0xac, 0x10, 0xa0, 0x17, 0x00, 0x03, 0xb0, 0x68, 0x00, 0x0a, 0xa0, 0x0a, 0x30, 0x00, 0x20, 0x00, 0x40, 0x06, 0x6e, 0x06, 0x03, 0x00, 0x06, 0x00, 0x40, 0x06, 0x00, 0x0a, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x10, 0x06, 0x92, 0x20, 0x00, 0x03}}; +struct ati_data_key ati_saved_config = { 0x100, "saved-config", {0x3f, 0x5c, 0x82, 0x02, 0xff, 0x90, 0x00, 0x54, 0x60, 0x00, 0xac, 0x10, 0xa0, 0x17, 0x00, 0x03, 0xb0, 0x68, 0x00, 0x0a, 0xa0, 0x0a, 0x30, 0x00, 0x20, 0x00, 0x40, 0x06, 0x6e, 0x06, 0x03, 0x00, 0x06, 0x00, 0x40, 0x06, 0x00, 0x0a, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x10, 0x06, 0x92, 0x20, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xee, 0x02, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x31, 0x30, 0x50, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x32, 0x32, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}; +///non 48xx keys +const char *ati_efidisplay_0_n4[] = { "@0,ATY,EFIDisplay", "TMDSA" }; +struct ati_data_key ati_connector_type_0_n4 = { 0x04, "@0,connector-type", {0x04, 0x00, 0x00, 0x00} }; +struct ati_data_key ati_connector_type_1_n4 = { 0x04, "@1,connector-type", {0x00, 0x02, 0x00, 0x00}}; +struct ati_data_key ati_aapl_emc_disp_list_n4 = { 0x40, "AAPL,EMC-Display-List", {0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x00, 0x00, 0x1b, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x00, 0x00, 0x1c, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x00, 0x00, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_fb_offset_n4 = { 0x08, "ATY,FrameBufferOffset", {0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_hwgpio_n4 = { 0x04, "ATY,HWGPIO", {0x23, 0xa8, 0x48, 0x00}}; +struct ati_data_key ati_iospace_offset_n4 = { 0x08, "ATY,IOSpaceOffset", {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00}}; +struct ati_data_key ati_mclk_n4 = { 0x04, "ATY,MCLK", {0x00, 0x35, 0x0c, 0x00}}; +struct ati_data_key ati_sclk_n4 = { 0x04, "ATY,SCLK", {0x60, 0xae, 0x0a, 0x00}}; +struct ati_data_key ati_refclk_n4 = { 0x04, "ATY,RefCLK", {0x8c, 0x0a, 0x00, 0x00}}; +struct ati_data_key ati_regspace_offset_n4 = { 0x08, "ATY,RegisterSpaceOffset", {0x00, 0x00, 0x00, 0x00, 0x90, 0xa2, 0x00, 0x00}}; +struct ati_data_key ati_vram_memsize_0 = { 0x08, "@0,VRAM,memsize", {0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_vram_memsize_1 = { 0x08, "@1,VRAM,memsize", {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_aapl_blackscr_prefs_0_n4 = { 0x04, "AAPL00,blackscreen-preferences", {0x00, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_aapl_blackscr_prefs_1_n4 = { 0x04, "AAPL01,blackscreen-preferences", {0x00, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_swgpio_info_n4 = { 0x04, "ATY,SWGPIO Info", {0x00, 0x48, 0xa8, 0x23}}; +struct ati_data_key ati_efi_orientation_n4 = { 0x01, "ATY,EFIOrientation", {0x08}}; +struct ati_data_key ati_mvad_n4 = { 0x100, "MVAD", {0x3e, 0x5c, 0x82, 0x00, 0xff, 0x90, 0x00, 0xf6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x3c, 0x80, 0x07, 0x20, 0x08, 0x30, 0x00, 0x20, 0x00, 0xb0, 0x04, 0xd3, 0x04, 0x03, 0x00, 0x06, 0x00, 0xb0, 0x04, 0x80, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x90, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x31, 0x30, 0x50, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x32, 0x32, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}; +struct ati_data_key ati_saved_config_n4 = { 0x100, "saved-config", {0x3e, 0x5c, 0x82, 0x00, 0xff, 0x90, 0x00, 0xf6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x3c, 0x80, 0x07, 0x20, 0x08, 0x30, 0x00, 0x20, 0x00, 0xb0, 0x04, 0xd3, 0x04, 0x03, 0x00, 0x06, 0x00, 0xb0, 0x04, 0x80, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x90, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x31, 0x30, 0x50, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x32, 0x32, 0x32, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}; +//const char *ati_slot_name_n4[] = { "AAPL,slot-name", "Slot-2"}; + + + + +struct pcir_s { + uint32_t signature; + uint16_t vid; + uint16_t devid; +}; + +// Known cards as of 2008/08/26 +static struct ati_chipsets_t ATIKnownChipsets[] = { + { 0x00000000, "Unknown" }, + { 0x10029589, "ATI Radeon 2600 Series"} , + { 0x10029588, "ATI Radeon 2600 Series"} , + { 0x100294C3, "ATI Radeon 2400 Series"} , + { 0x100294C4, "ATI Radeon 2400 Series"} , + { 0x100294C6, "ATI Radeon 2400 Series"} , + { 0x10029400, "ATI Radeon 2900 Series"} , + { 0x10029405, "ATI Radeon 2900GT Series"} , + { 0x10029581, "ATI Radeon 2600 Series"} , + { 0x10029583, "ATI Radeon 2600 Series"} , + { 0x10029586, "ATI Radeon 2600 Series"} , + { 0x10029587, "ATI Radeon 2600 Series"} , + { 0x100294C9, "ATI Radeon 2400 Series"} , + { 0x10029501, "ATI Radeon 3800 Series"} , + { 0x10029505, "ATI Radeon 3800 Series"} , + { 0x10029515, "ATI Radeon 3800 Series"} , + { 0x10029507, "ATI Radeon 3800 Series"} , + { 0x10029500, "ATI Radeon 3800 Series"} , + { 0x1002950F, "ATI Radeon 3800X2 Series"} , + { 0x100295C5, "ATI Radeon 3400 Series"} , + { 0x100295C7, "ATI Radeon 3400 Series"} , + { 0x100295C0, "ATI Radeon 3400 Series"} , + { 0x10029596, "ATI Radeon 3600 Series"} , + { 0x10029590, "ATI Radeon 3600 Series"} , + { 0x10029599, "ATI Radeon 3600 Series"} , + { 0x10029597, "ATI Radeon 3600 Series"} , + { 0x10029598, "ATI Radeon 3600 Series"} , + { 0x10029442, "ATI Radeon 4850 Series"} , + { 0x10029440, "ATI Radeon 4870 Series"} , + { 0x1002944C, "ATI Radeon 4830 Series"} , + { 0x10029460, "ATI Radeon 4890 Series"} , + { 0x10029462, "ATI Radeon 4890 Series"} , + { 0x10029441, "ATI Radeon 4870X2 Series"} , + { 0x10029443, "ATI Radeon 4850X2 Series"} , + { 0x10029444, "ATI Radeon 4800 Series"} , + { 0x10029446, "ATI Radeon 4800 Series"} , + { 0x1002944E, "ATI Radeon 4730 Series"} , + { 0x10029450, "ATI Radeon 4800 Series"} , + { 0x10029452, "ATI Radeon 4800 Series"} , + { 0x10029456, "ATI Radeon 4800 Series"} , + { 0x1002944A, "ATI Radeon 4800 Mobility Series"} , + { 0x1002945A, "ATI Radeon 4800 Mobility Series"} , + { 0x1002945B, "ATI Radeon 4800 Mobility Series"} , + { 0x1002944B, "ATI Radeon 4800 Mobility Series"} , + { 0x10029490, "ATI Radeon 4600 Series"} , + { 0x10029498, "ATI Radeon 4600 Series"} , + { 0x1002949E, "ATI Radeon 4600 Series"} , + { 0x10029480, "ATI Radeon 4600 Series"} , + { 0x10029488, "ATI Radeon 4600 Series"} , + { 0x10029540, "ATI Radeon 4500 Series"} , + { 0x10029541, "ATI Radeon 4500 Series"} , + { 0x1002954E, "ATI Radeon 4500 Series"} , + { 0x10029552, "ATI Radeon 4300 Mobility Series"} , + { 0x10029553, "ATI Radeon 4500 Mobility Series"} , + { 0x1002954F, "ATI Radeon 4300 Series"}, +}; + +static struct ati_chipsets_t ATIKnownFramebuffers[] = { + { 0x00000000, "Megalodon" }, + { 0x10029589, "Lamna"} , + { 0x10029588, "Lamna"} , + { 0x100294C3, "Iago"} , + { 0x100294C4, "Iago"} , + { 0x100294C6, "Iago"} , + { 0x10029400, "Franklin"} , + { 0x10029405, "Franklin"} , + { 0x10029581, "Hypoprion"} , + { 0x10029583, "Hypoprion"} , + { 0x10029586, "Hypoprion"} , + { 0x10029587, "Hypoprion"} , + { 0x100294C9, "Iago"} , + { 0x10029501, "Megalodon"} , + { 0x10029505, "Megalodon"} , + { 0x10029515, "Megalodon"} , + { 0x10029507, "Megalodon"} , + { 0x10029500, "Megalodon"} , + { 0x1002950F, "Triakis"} , + { 0x100295C5, "Iago"} , + { 0x100295C7, "Iago"} , + { 0x100295C0, "Iago"} , + { 0x10029596, "Megalodon"} , + { 0x10029590, "Megalodon"} , + { 0x10029599, "Megalodon"} , + { 0x10029597, "Megalodon"} , + { 0x10029598, "Megalodon"} , + { 0x10029442, "Motmot"} , + { 0x10029440, "Motmot"} , + { 0x1002944C, "Motmot"} , + { 0x10029460, "Motmot"} , + { 0x10029462, "Motmot"} , + { 0x10029441, "Motmot"} , + { 0x10029443, "Motmot"} , + { 0x10029444, "Motmot"} , + { 0x10029446, "Motmot"} , + { 0x1002944E, "Motmot"} , + { 0x10029450, "Motmot"} , + { 0x10029452, "Motmot"} , + { 0x10029456, "Motmot"} , + { 0x1002944A, "Motmot"} , + { 0x1002945A, "Motmot"} , + { 0x1002945B, "Motmot"} , + { 0x1002944B, "Motmot"} , + { 0x10029490, "Motmot"} , + { 0x10029498, "Motmot"} , + { 0x1002949E, "Motmot"} , + { 0x10029480, "Motmot"} , + { 0x10029488, "Motmot"} , + { 0x10029540, "Motmot"} , + { 0x10029541, "Motmot"} , + { 0x1002954E, "Motmot"} , + { 0x10029552, "Motmot"} , + { 0x10029553, "Motmot"} , + { 0x1002954F, "Motmot"} , +}; + +unsigned int accessROM(pci_dt_t *ati_dev, unsigned int mode) +{ + uint32_t bar[7]; + volatile uint8_t *regs; + + bar[2] = pci_config_read32(ati_dev->dev.addr, 0x18 ); + regs = (uint8_t *) (bar[2] & ~0x0f); + +if(mode) +{ + if(mode != 1) return 0xe00002c7; + REG32W(0x179c, 0x00080000); + REG32W(0x1798, 0x00080721); + REG32W(0x17a0, 0x00080621); + REG32W(0x1600, 0x14030300); + REG32W(0x1798, 0x21); + REG32W(0x17a0, 0x21); + REG32W(0x179c, 0x00); + REG32W(0x17a0, 0x21); + REG32W(0x1798, 0x21); + REG32W(0x1798, 0x21); +} else { + REG32W(0x1600, 0x14030302); + REG32W(0x1798, 0x21); + REG32W(0x17a0, 0x21); + REG32W(0x179c, 0x00080000); + REG32W(0x17a0, 0x00080621); + REG32W(0x1798, 0x00080721); + REG32W(0x1798, 0x21); + REG32W(0x17a0, 0x21); + REG32W(0x179c, 0x00); + REG32W(0x1604, 0x0400e9fc); + REG32W(0x161c, 0x00); + REG32W(0x1620, 0x9f); + REG32W(0x1618, 0x00040004); + REG32W(0x161c, 0x00); + REG32W(0x1604, 0xe9fc); + REG32W(0x179c, 0x00080000); + REG32W(0x1798, 0x00080721); + REG32W(0x17a0, 0x00080621); + REG32W(0x1798, 0x21); + REG32W(0x17a0, 0x21); + REG32W(0x179c, 0x00); +} +return 0; +} + +unsigned char * readAtomBIOS(pci_dt_t *ati_dev) +{ + uint32_t bar[7]; + unsigned int * BIOSBase = NULL; + unsigned int counter; + volatile uint8_t *regs; + + bar[2] = pci_config_read32(ati_dev->dev.addr, 0x18 ); + regs = (uint8_t *) (bar[2] & ~0x0f); + accessROM(ati_dev, 0); + REG32W(0xa8, 0); + REG32R(0xac); + REG32W(0xa8, 0); + REG32R(0xac); + + BIOSBase = malloc(0x10000); + if(BIOSBase) + { + REG32W(0xa8, 0); + BIOSBase[0] = REG32R(0xac); + counter = 4; + do + { + REG32W(0xa8, counter); + BIOSBase[counter/4] = REG32R(0xac); + counter +=4; + } + while(counter != 0x10000); + } + accessROM((pci_dt_t *)regs, 1); + + if ((* (UInt16 *)BIOSBase) != 0xAA55) { + printf("Wrong BIOS signature: %04x\n", (* (UInt16 *)BIOSBase)); + return 0; + } + return (unsigned char *)BIOSBase; +} + +#define R5XX_CONFIG_MEMSIZE 0x00F8 +#define R6XX_CONFIG_MEMSIZE 0x5428 + +uint32_t getvramsizekb(pci_dt_t *ati_dev) +{ + uint32_t bar[7]; + volatile uint8_t *regs; + uint32_t RamSize = 0; + + bar[2] = pci_config_read32(ati_dev->dev.addr, 0x18 ); + regs = (uint8_t *) (bar[2] & ~0x0f); + if (ati_dev->device_id < 0x9400) + RamSize = (REG32R(R5XX_CONFIG_MEMSIZE)) >> 10; + else + RamSize = (REG32R(R6XX_CONFIG_MEMSIZE)) >> 10; + + return RamSize; +} + +#define AVIVO_D1CRTC_CONTROL 0x6080 +#define AVIVO_CRTC_EN (1<<0) +#define AVIVO_D2CRTC_CONTROL 0x6880 + +bool +radeon_card_posted(pci_dt_t *ati_dev) +{ + // if devid matches biosimage(from legacy) devid - posted card, fails with X2/crossfire cards. +/* char *biosimage = 0xC0000; + + if ((uint8_t)biosimage[0] == 0x55 && (uint8_t)biosimage[1] == 0xaa) + { + struct pci_rom_pci_header_t *rom_pci_header; + rom_pci_header = (struct pci_rom_pci_header_t*)(biosimage + (uint8_t)biosimage[24] + (uint8_t)biosimage[25]*256); + + if (rom_pci_header->signature == 0x52494350) + { + if (rom_pci_header->device == ati_dev->device_id) + { + return TRUE; + printf("Card was POSTed\n"); + } + } + } + return FALSE; + printf("Card was not POSTed\n"); + */ + //fails yet + uint32_t bar[7]; + volatile uint8_t *regs; + + bar[2] = pci_config_read32(ati_dev->dev.addr, 0x18 ); + regs = (uint8_t *) (bar[2] & ~0x0f); + + uint32_t val; + + val = REG32R(AVIVO_D1CRTC_CONTROL) | REG32R(AVIVO_D2CRTC_CONTROL); + if (val & AVIVO_CRTC_EN) + return TRUE; + + return FALSE; + +} + +uint32_t load_ati_bios_file(char *filename, char *buffer) +{ + int fd, size; + char dirspec[128]; + + // Check Extra on booting partition + sprintf(dirspec, "/Extra/%s", filename); + fd = open(dirspec, 0); + if (fd < 0) + { + // Fall back to booter partition + sprintf(dirspec, "bt(0,0)/Extra/%s", filename); + fd=open (dirspec, 0); + if (fd < 0) + return 0; + } + + size = read(fd, buffer, file_size (fd)); + close (fd); + return size; +} + +char *get_ati_model(uint32_t id) { + int i=0; + for(i = 0; i < (sizeof(ATIKnownChipsets) / sizeof(ATIKnownChipsets[0])); i++) { + if(ATIKnownChipsets[i].device == id) + return ATIKnownChipsets[i].name; + } + return ATIKnownChipsets[0].name; +} + +char *get_ati_fb(uint32_t id) { + int i=0; + for(i = 0; i < (sizeof(ATIKnownFramebuffers) / sizeof(ATIKnownFramebuffers[0])); i++) { + if(ATIKnownFramebuffers[i].device == id) + return ATIKnownFramebuffers[i].name; + } + return ATIKnownFramebuffers[0].name; +} + +int devprop_add_iopciconfigspace(struct DevPropDevice *device, pci_dt_t *ati_dev) +{ + if(!device) + return 0; + if(!ati_dev) + return 0; + printf("dumping pci config space, 256 bytes\n"); + int i; + uint8_t *config_space; + config_space = malloc(256); + for(i=0; i<=255; i++) + config_space[i] = pci_config_read8( ati_dev->dev.addr, i); + devprop_add_value(device, "ATY,PCIConfigSpace", config_space, 256); + free(config_space); + return 1; +} + +int devprop_add_ati_template_4xxx(struct DevPropDevice *device) +{ + if(!device) + return 0; + +// if(!DP_ADD_TEMP_VAL(device, ati_compatible_0)) +// return 0; +// if(!DP_ADD_TEMP_VAL(device, ati_compatible_1)) +// return 0; + if(!DP_ADD_TEMP_VAL(device, ati_device_type_0)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_device_type_1)) + return 0; +// if(!DP_ADD_TEMP_VAL(device, ati_device_type)) +// return 0; +// if(!DP_ADD_TEMP_VAL(device, ati_name_0)) +// return 0; +// if(!DP_ADD_TEMP_VAL(device, ati_name_1)) +// return 0; +// if(!DP_ADD_TEMP_VAL(device, ati_name)) +// return 0; + if(!DP_ADD_TEMP_VAL(device, ati_efidisplay_0)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_display_type_0)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_display_type_1)) + return 0; +// if(!DP_ADD_TEMP_VAL(device, ati_slot_name)) +// return 0; + if(!DP_ADD_TEMP_VAL(device, ati_card_no)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_copyright)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_efi_compile_d)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_efi_version)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_efi_versionB)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_efi_versionE)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_mrt)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_romno)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_name_1)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_connector_type_0)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_connector_type_1)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_display_con_fl_type_0)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_aux_power_conn)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_backlight_ctrl)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_aapl01_coher)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_efi_disp_conf)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_efi_drv_type)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_efi_enbl_mode)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_efi_init_stat)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_efi_orientation)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_mclk)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_mem_rev_id)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_mem_vend_id)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_sclk)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_vendor_id)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_platform_info)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_mvad)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_saved_config)) + return 0; + return 1; +} + +int devprop_add_ati_template(struct DevPropDevice *device) +{ + if(!device) + return 0; + + if(!DP_ADD_TEMP_VAL_DATA(device, ati_platform_info)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_device_type_0)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_device_type_1)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_efidisplay_0_n4)) + return 0; +// if(!DP_ADD_TEMP_VAL(device, ati_slot_name_n4)) +// return 0; + if(!DP_ADD_TEMP_VAL(device, ati_card_no)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_copyright)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_efi_compile_d)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_efi_version)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_efi_versionB)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_efi_versionE)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_mrt)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_romno)) + return 0; + if(!DP_ADD_TEMP_VAL(device, ati_name_1)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_connector_type_0_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_connector_type_1_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_aux_power_conn)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_backlight_ctrl)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_aapl01_coher)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_efi_drv_type)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_efi_enbl_mode)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_mem_rev_id)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_mem_vend_id)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_vendor_id)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_aapl_emc_disp_list_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_fb_offset_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_hwgpio_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_iospace_offset_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_mclk_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_sclk_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_refclk_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_regspace_offset_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_efi_orientation_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_aapl_blackscr_prefs_0_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_aapl_blackscr_prefs_1_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_swgpio_info_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_efi_orientation_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_mvad_n4)) + return 0; + if(!DP_ADD_TEMP_VAL_DATA(device, ati_saved_config_n4)) + return 0; + return 1; +} + + +bool setup_ati_devprop(pci_dt_t *ati_dev) +{ +// int len; + char *devicepath; +// volatile uint8_t *regs; +// uint32_t bar[7]; + + char *model; + char *framebuffer; + char tmpString[64]; + char *rom=0; + uint32_t rom_size=0; + char *biosimage = 0; + uint32_t biosimage_size = 0; + uint8_t toFree = 0; + char romfilename[32]; + const char *val; + int len1; + uint32_t vram_size=0; + uint8_t cmd=0; + + devicepath = get_pci_dev_path(ati_dev); + + cmd = pci_config_read8( ati_dev->dev.addr, 4); + verbose("old pci command - %x\n", cmd); + if( cmd == 0) { + pci_config_write8(ati_dev->dev.addr, 4, 6); + cmd = pci_config_read8( ati_dev->dev.addr, 4); + verbose("new pci command - %x\n", cmd); + }; + + model = get_ati_model((ati_dev->vendor_id << 16) | ati_dev->device_id); + + framebuffer = get_ati_fb((ati_dev->vendor_id << 16) | ati_dev->device_id); + if (!string) + string = devprop_create_string(); + + struct DevPropDevice *device = malloc(sizeof(struct DevPropDevice)); + device = devprop_add_device(string, devicepath); + + if(!device) + { + printf("Failed initializing dev-prop string dev-entry, press any key...\n"); + getc(); + return false; + } + + /* FIXME: for primary graphics card only */ + uint32_t boot_display = 0x00000001; + if(radeon_card_posted(ati_dev)) boot_display=0x01; + else boot_display=0x00; + verbose("boot display - %x\n", boot_display); + devprop_add_value(device, "@0,AAPL,boot-display", (uint8_t*)&boot_display, 4); + + if(framebuffer[0] == 'M' && framebuffer[1] == 'o' && framebuffer[2] == 't') //faster than strcmp ;) + devprop_add_ati_template_4xxx(device); + else + { + devprop_add_ati_template(device); + vram_size = getvramsizekb(ati_dev) * 1024; + if ((vram_size > 0x80000000) || (vram_size == 0)) vram_size = 0x10000000; //vram reported wrong, defaulting to 256 mb + devprop_add_value(device, "VRAM,totalsize", (uint8_t*)&vram_size, 4); + ati_vram_memsize_0.data[6] = (vram_size >> 16) & 0xFF; //4,5 are 0x00 anyway + ati_vram_memsize_0.data[7] = (vram_size >> 24) & 0xFF; + ati_vram_memsize_1.data[6] = (vram_size >> 16) & 0xFF; //4,5 are 0x00 anyway + ati_vram_memsize_1.data[7] = (vram_size >> 24) & 0xFF; + DP_ADD_TEMP_VAL_DATA(device, ati_vram_memsize_0); + DP_ADD_TEMP_VAL_DATA(device, ati_vram_memsize_1); + devprop_add_iopciconfigspace(device, ati_dev); + } + devprop_add_value(device, "model", (uint8_t*)model, (strlen(model) + 1)); + devprop_add_value(device, "ATY,DeviceID", (uint8_t*)&ati_dev->device_id, 2); + //fb setup + + char tmp[10]; + + sprintf(tmp, "Slot-%x",devices_number); + devprop_add_value(device, "AAPL,slot-name", (uint8_t*)tmp, strlen(tmp)); + devices_number++; + + sprintf(tmpString, ati_compatible_0[1], framebuffer); + devprop_add_value(device, (char *) ati_compatible_0[0], (uint8_t *)tmpString, strlen(tmpString)+1); + + sprintf(tmpString, ati_compatible_1[1], framebuffer); + devprop_add_value(device, (char *) ati_compatible_1[0], (uint8_t *)tmpString, strlen(tmpString)+1); + + sprintf(tmpString, ati_device_type[1], framebuffer); + devprop_add_value(device, (char *) ati_device_type[0], (uint8_t *)tmpString, strlen(tmpString)+1); + + sprintf(tmpString, ati_name[1], framebuffer); + devprop_add_value(device, (char *) ati_name[0], (uint8_t *)tmpString, strlen(tmpString)+1); + + sprintf(tmpString, ati_name_0[1], framebuffer); + devprop_add_value(device, (char *) ati_name_0[0], (uint8_t *)tmpString, strlen(tmpString)+1); + + sprintf(tmpString, ati_name_1[1], framebuffer); + devprop_add_value(device, (char *) ati_name_1[0], (uint8_t *)tmpString, strlen(tmpString)+1); + //code for loading bios from file, in form - rom_devid_vendif.rom + if (getValueForKey("-useatirom", &val, &len1, &bootInfo->bootConfig)) + { + sprintf(romfilename, "ati_%04x_%04x.rom", (uint16_t)ati_dev->device_id, (uint16_t)ati_dev->vendor_id); + verbose("looking for file /Extra/%s\n", romfilename); + rom = malloc(0x20000); + rom_size = load_ati_bios_file((char *)romfilename, (char *)rom); + if(rom_size > 0x10000) rom_size = 0x10000; //we dont need rest anyway; + if(rom_size == 0) printf("file not found\n"); + }; + { + if(rom_size == 0) + { + if(boot_display) // no custom rom + biosimage = 0; //try to dump from legacy space, otherwise can result in 100% fan speed + else + biosimage = (char *)readAtomBIOS(ati_dev); //readAtomBios result in bug on some cards (100% fan speed and black screen), + //not using it for posted card, rading from legacy space instead + } else { + biosimage = rom; //going custom rom way + verbose("Using rom %s\n", romfilename); + } + if(biosimage == 0) + { + biosimage = (char *)0xC0000; + toFree = 0; + verbose("Not going to use bios image file\n"); + } else toFree = 1; + + if ((uint8_t)biosimage[0] == 0x55 && (uint8_t)biosimage[1] == 0xaa) + { + printf("Found bios image\n"); + biosimage_size = (uint8_t)biosimage[2] * 512; + + struct pci_rom_pci_header_t *rom_pci_header; + rom_pci_header = (struct pci_rom_pci_header_t*)(biosimage + (uint8_t)biosimage[24] + (uint8_t)biosimage[25]*256); + + if (rom_pci_header->signature == 0x52494350) + { + if (rom_pci_header->device != ati_dev->device_id) + { + verbose("Bios image (%x) doesnt match card (%x), ignoring\n", rom_pci_header->device, ati_dev->device_id); + } else { + if(toFree) + verbose("Adding binimage to card %x from mmio space with size %x\n", ati_dev->device_id, biosimage_size); + else + verbose("Adding binimage to card %x from legacy space with size %x\n", ati_dev->device_id, biosimage_size); + devprop_add_value(device, "ATY,bin_image", (uint8_t*) biosimage, biosimage_size); + } + } else verbose("Wrong pci header signature %x\n", rom_pci_header->signature); + + } else verbose("Bios image not found at %x, content %x %x\n", biosimage, (uint8_t)biosimage[0], (uint8_t)biosimage[1]); + if(toFree) free(biosimage); + } + stringdata = malloc(sizeof(uint8_t) * string->length); + if(!stringdata) + { + printf("no stringdata press a key...\n"); + getc(); + return false; + } + + memcpy(stringdata, (uint8_t*)devprop_generate_string(string), string->length); + stringlength = string->length; + + return true; +} Index: trunk/i386/libsaio/sys.c =================================================================== --- trunk/i386/libsaio/sys.c (revision 0) +++ trunk/i386/libsaio/sys.c (revision 1) @@ -0,0 +1,956 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Mach Operating System + * Copyright (c) 1990 Carnegie-Mellon University + * Copyright (c) 1989 Carnegie-Mellon University + * Copyright (c) 1988 Carnegie-Mellon University + * Copyright (c) 1987 Carnegie-Mellon University + * All rights reserved. The CMU software License Agreement specifies + * the terms and conditions for use and redistribution. + * + */ +/* + * HISTORY + * Revision 2.3 88/08/08 13:47:07 rvb + * Allocate buffers dynamically vs statically. + * Now b[i] and i_fs and i_buf, are allocated dynamically. + * boot_calloc(size) allocates and zeros a buffer rounded to a NPG + * boundary. + * Generalize boot spec to allow, xx()/mach, xx(n,[a..h])/mach, + * xx([a..h])/mach, ... + * Also default "xx" if unspecified and alloc just "/mach", + * where everything is defaulted + * Add routine, ptol(), to parse partition letters. + * + */ + +/* + * Copyright (c) 1982, 1986 Regents of the University of California. + * All rights reserved. The Berkeley software License Agreement + * specifies the terms and conditions for redistribution. + * + * @(#)sys.c 7.1 (Berkeley) 6/5/86 + */ + +/* Copyright 2007 VMware Inc. + "Preboot" ramdisk support added by David Elliott + */ + +#include + +#include "libsaio.h" +#include "bootstruct.h" +#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 +# include +#else +# include +#endif +#include +#if 0 /* No OS X release has ever included this. */ +#include +#else +/* copied from uuid/namespace.h, just like BootX's fs.c does. */ +UUID_DEFINE( kFSUUIDNamespaceSHA1, 0xB3, 0xE2, 0x0F, 0x39, 0xF2, 0x92, 0x11, 0xD6, 0x97, 0xA4, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC ); +#endif + +extern int multiboot_partition; +extern int multiboot_partition_set; + +struct devsw { + const char * name; + // size increased from char to short to handle non-BIOS internal devices + unsigned short biosdev; + int type; +}; + +static struct devsw devsw[] = +{ + { "sd", 0x80, kBIOSDevTypeHardDrive }, /* DEV_SD */ + { "hd", 0x80, kBIOSDevTypeHardDrive }, /* DEV_HD */ + { "fd", 0x00, kBIOSDevTypeFloppy }, /* DEV_FD */ + { "en", 0xE0, kBIOSDevTypeNetwork }, /* DEV_EN */ + { "rd", 0x100, kBIOSDevTypeHardDrive }, + { "bt", 0x101, kBIOSDevTypeHardDrive }, // turbo - type for booter partition + { 0, 0 } +}; + +/* + * Max number of file descriptors. + */ +#define NFILES 6 + +static struct iob iob[NFILES]; + +void * gFSLoadAddress = 0; + +// Turbo - save what we think is our original BIOS boot volume if we have one 0xab +BVRef gBIOSBootVolume = NULL; +BVRef gBootVolume; + +// zef - ramdisk variables +extern BVRef gRAMDiskVolume; +extern BOOL gRAMDiskBTAliased; + +//static BVRef getBootVolumeRef( const char * path, const char ** outPath ); +static BVRef newBootVolumeRef( int biosdev, int partno ); + +//========================================================================== +// LoadVolumeFile - LOW-LEVEL FILESYSTEM FUNCTION. +// Load the specified file from the specified volume +// to the load buffer at LOAD_ADDR. +// If the file is fat, load only the i386 portion. + +long LoadVolumeFile(BVRef bvr, const char *filePath) +{ + long fileSize; + + // Read file into load buffer. The data in the load buffer will be + // overwritten by the next LoadFile() call. + + gFSLoadAddress = (void *) LOAD_ADDR; + + fileSize = bvr->fs_loadfile(bvr, (char *)filePath); + + // Return the size of the file, or -1 if load failed. + + return fileSize; +} + +//========================================================================== +// LoadFile - LOW-LEVEL FILESYSTEM FUNCTION. +// Load the specified file to the load buffer at LOAD_ADDR. +// If the file is fat, load only the i386 portion. + +long LoadFile(const char * fileSpec) +{ + const char * filePath; + BVRef bvr; + + // Resolve the boot volume from the file spec. + + if ((bvr = getBootVolumeRef(fileSpec, &filePath)) == NULL) + return -1; + + return LoadVolumeFile(bvr, filePath); +} + +long ReadFileAtOffset(const char * fileSpec, void *buffer, uint64_t offset, uint64_t length) +{ + const char *filePath; + BVRef bvr; + + if ((bvr = getBootVolumeRef(fileSpec, &filePath)) == NULL) + return -1; + + if (bvr->fs_readfile == NULL) + return -1; + + return bvr->fs_readfile(bvr, (char *)filePath, buffer, offset, length); +} + +long LoadThinFatFile(const char *fileSpec, void **binary) +{ + const char *filePath; + FSReadFile readFile; + BVRef bvr; + unsigned long length, length2; + + // Resolve the boot volume from the file spec. + + if ((bvr = getBootVolumeRef(fileSpec, &filePath)) == NULL) + return -1; + + *binary = (void *)kLoadAddr; + + // Read file into load buffer. The data in the load buffer will be + // overwritten by the next LoadFile() call. + + gFSLoadAddress = (void *) LOAD_ADDR; + + readFile = bvr->fs_readfile; + + if (readFile != NULL) { + // Read the first 4096 bytes (fat header) + length = readFile(bvr, (char *)filePath, *binary, 0, 0x1000); + if (length > 0) { + if (ThinFatFile(binary, &length) == 0) { + if (length == 0) + return 0; + // We found a fat binary; read only the thin part + length = readFile(bvr, (char *)filePath, + (void *)kLoadAddr, (unsigned long)(*binary) - kLoadAddr, length); + *binary = (void *)kLoadAddr; + } else { + // Not a fat binary; read the rest of the file + length2 = readFile(bvr, (char *)filePath, (void *)(kLoadAddr + length), length, 0); + if (length2 == -1) return -1; + length += length2; + } + } + } else { + length = bvr->fs_loadfile(bvr, (char *)filePath); + if (length > 0) { + ThinFatFile(binary, &length); + } + } + + return length; +} + +#if UNUSED +long GetFSUUID(char *spec, char *uuidStr) +{ + BVRef bvr; + long rval = -1; + const char *devSpec; + + if ((bvr = getBootVolumeRef(spec, &devSpec)) == NULL) + return -1; + + if(bvr->fs_getuuid) + rval = bvr->fs_getuuid(bvr, uuidStr); + + return rval; +} +#endif + +// filesystem-specific getUUID functions call this shared string generator +long CreateUUIDString(uint8_t uubytes[], int nbytes, char *uuidStr) +{ + unsigned fmtbase, fmtidx, i; + uint8_t uuidfmt[] = { 4, 2, 2, 2, 6 }; + char *p = uuidStr; + MD5_CTX md5c; + uint8_t mdresult[16]; + + bzero(mdresult, sizeof(mdresult)); + + // just like AppleFileSystemDriver + MD5Init(&md5c); + MD5Update(&md5c, kFSUUIDNamespaceSHA1, sizeof(kFSUUIDNamespaceSHA1)); + MD5Update(&md5c, uubytes, nbytes); + MD5Final(mdresult, &md5c); + + // this UUID has been made version 3 style (i.e. via namespace) + // see "-uuid-urn-" IETF draft (which otherwise copies byte for byte) + mdresult[6] = 0x30 | ( mdresult[6] & 0x0F ); + mdresult[8] = 0x80 | ( mdresult[8] & 0x3F ); + + + // generate the text: e.g. 5EB1869F-C4FA-3502-BDEB-3B8ED5D87292 + i = 0; fmtbase = 0; + for(fmtidx = 0; fmtidx < sizeof(uuidfmt); fmtidx++) { + for(i=0; i < uuidfmt[fmtidx]; i++) { + uint8_t byte = mdresult[fmtbase+i]; + char nib; + + nib = byte >> 4; + *p = nib + '0'; // 0x4 -> '4' + if(*p > '9') *p = (nib - 9 + ('A'-1)); // 0xB -> 'B' + p++; + + nib = byte & 0xf; + *p = nib + '0'; // 0x4 -> '4' + if(*p > '9') *p = (nib - 9 + ('A'-1)); // 0xB -> 'B' + p++; + + } + fmtbase += i; + if(fmtidx < sizeof(uuidfmt)-1) + *(p++) = '-'; + else + *p = '\0'; + } + + return 0; +} + + +//========================================================================== +// GetDirEntry - LOW-LEVEL FILESYSTEM FUNCTION. +// Fetch the next directory entry for the given directory. + +long GetDirEntry(const char * dirSpec, long * dirIndex, const char ** name, + long * flags, long * time) +{ + const char * dirPath; + BVRef bvr; + + // Resolve the boot volume from the dir spec. + + if ((bvr = getBootVolumeRef(dirSpec, &dirPath)) == NULL) + return -1; + + // Return 0 on success, or -1 if there are no additional entries. + + return bvr->fs_getdirentry( bvr, + /* dirPath */ (char *)dirPath, + /* dirIndex */ dirIndex, + /* dirEntry */ (char **)name, flags, time, 0, 0 ); +} + +//========================================================================== +// GetFileInfo - LOW-LEVEL FILESYSTEM FUNCTION. +// Get attributes for the specified file. + +static char* gMakeDirSpec; + +long GetFileInfo(const char * dirSpec, const char * name, + long * flags, long * time) +{ + long index = 0; + const char * entryName; + + if (gMakeDirSpec == 0) + gMakeDirSpec = (char *)malloc(1024); + + if (!dirSpec) { + long idx, len; + + len = strlen(name); + + for (idx = len; idx && (name[idx] != '/' && name[idx] != '\\'); idx--) {} + if (idx == 0) { + gMakeDirSpec[0] = '/'; + gMakeDirSpec[1] = '\0'; + } else { + idx++; + strncpy(gMakeDirSpec, name, idx); + name += idx; + } + dirSpec = gMakeDirSpec; + } + + while (GetDirEntry(dirSpec, &index, &entryName, flags, time) == 0) + { + if (strcmp(entryName, name) == 0) + return 0; // success + } + return -1; // file not found +} + +long GetFileBlock(const char *fileSpec, unsigned long long *firstBlock) +{ + const char * filePath; + BVRef bvr; + + // Resolve the boot volume from the file spec. + + if ((bvr = getBootVolumeRef(fileSpec, &filePath)) == NULL) { + printf("Boot volume for '%s' is bogus\n", fileSpec); + return -1; + } + + return bvr->fs_getfileblock(bvr, (char *)filePath, firstBlock); +} + +//========================================================================== +// iob_from_fdesc() +// +// Return a pointer to an allocated 'iob' based on the file descriptor +// provided. Returns NULL if the file descriptor given is invalid. + +static struct iob * iob_from_fdesc(int fdesc) +{ + register struct iob * io; + + if (fdesc < 0 || fdesc >= NFILES || + ((io = &iob[fdesc])->i_flgs & F_ALLOC) == 0) + return NULL; + else + return io; +} + +#if UNUSED +//========================================================================== +// openmem() + +int openmem(char * buf, int len) +{ + int fdesc; + struct iob * io; + + // Locate a free descriptor slot. + + for (fdesc = 0; fdesc < NFILES; fdesc++) + if (iob[fdesc].i_flgs == 0) + goto gotfile; + + stop("Out of file descriptors"); + +gotfile: + io = &iob[fdesc]; + bzero(io, sizeof(*io)); + + // Mark the descriptor as taken. Set the F_MEM flag to indicate + // that the file buffer is provided by the caller. + + io->i_flgs = F_ALLOC | F_MEM; + io->i_buf = buf; + io->i_filesize = len; + + return fdesc; +} +#endif + +//========================================================================== +// open() - Open the file specified by 'path' for reading. + +int open(const char * path, int flags) +{ + int fdesc, i; + struct iob * io; + const char * filePath; + BVRef bvr; + + // Locate a free descriptor slot. + + for (fdesc = 0; fdesc < NFILES; fdesc++) + if (iob[fdesc].i_flgs == 0) + goto gotfile; + + stop("Out of file descriptors"); + +gotfile: + io = &iob[fdesc]; + bzero(io, sizeof(*io)); + + // Mark the descriptor as taken. + + io->i_flgs = F_ALLOC; + + // Resolve the boot volume from the file spec. + + if ((bvr = getBootVolumeRef(path, &filePath)) == NULL) + goto error; + + // Find the next available memory block in the download buffer. + + io->i_buf = (char *) LOAD_ADDR; + for (i = 0; i < NFILES; i++) + { + if ((iob[i].i_flgs != F_ALLOC) || (i == fdesc)) continue; + io->i_buf = max(iob[i].i_filesize + iob[i].i_buf, io->i_buf); + } + + // Load entire file into memory. Unnecessary open() calls must + // be avoided. + + gFSLoadAddress = io->i_buf; + io->i_filesize = bvr->fs_loadfile(bvr, (char *)filePath); + if (io->i_filesize < 0) { + goto error; + } + + return fdesc; + +error: + close(fdesc); + return -1; +} + +//========================================================================== +// close() - Close a file descriptor. + +int close(int fdesc) +{ + struct iob * io; + + if ((io = iob_from_fdesc(fdesc)) == NULL) + return (-1); + + io->i_flgs = 0; + + return 0; +} + +//========================================================================== +// lseek() - Reposition the byte offset of the file descriptor from the +// beginning of the file. Returns the relocated offset. + +int b_lseek(int fdesc, int offset, int ptr) +{ + struct iob * io; + + if ((io = iob_from_fdesc(fdesc)) == NULL) + return (-1); + + io->i_offset = offset; + + return offset; +} + +//========================================================================== +// tell() - Returns the byte offset of the file descriptor. + +int tell(int fdesc) +{ + struct iob * io; + + if ((io = iob_from_fdesc(fdesc)) == NULL) + return 0; + + return io->i_offset; +} + +//========================================================================== +// read() - Read up to 'count' bytes of data from the file descriptor +// into the buffer pointed to by buf. + +int read(int fdesc, char * buf, int count) +{ + struct iob * io; + + if ((io = iob_from_fdesc(fdesc)) == NULL) + return (-1); + + if ((io->i_offset + count) > (unsigned int)io->i_filesize) + count = io->i_filesize - io->i_offset; + + if (count <= 0) + return 0; // end of file + + bcopy(io->i_buf + io->i_offset, buf, count); + + io->i_offset += count; + + return count; +} + +//========================================================================== +// file_size() - Returns the size of the file described by the file +// descriptor. + +int file_size(int fdesc) +{ + struct iob * io; + + if ((io = iob_from_fdesc(fdesc)) == 0) + return 0; + + return io->i_filesize; +} + +//========================================================================== + +struct dirstuff * vol_opendir(BVRef bvr, const char * path) +{ + struct dirstuff * dirp = 0; + + dirp = (struct dirstuff *) malloc(sizeof(struct dirstuff)); + if (dirp == NULL) + goto error; + + dirp->dir_path = newString(path); + if (dirp->dir_path == NULL) + goto error; + + dirp->dir_bvr = bvr; + + return dirp; + +error: + closedir(dirp); + return NULL; +} + +//========================================================================== + +struct dirstuff * opendir(const char * path) +{ + struct dirstuff * dirp = 0; + const char * dirPath; + BVRef bvr; + + if ((bvr = getBootVolumeRef(path, &dirPath)) == NULL) + goto error; + + dirp = (struct dirstuff *) malloc(sizeof(struct dirstuff)); + if (dirp == NULL) + goto error; + + dirp->dir_path = newString(dirPath); + if (dirp->dir_path == NULL) + goto error; + + dirp->dir_bvr = bvr; + + return dirp; + +error: + closedir(dirp); + return NULL; +} + +//========================================================================== + +int closedir(struct dirstuff * dirp) +{ + if (dirp) { + if (dirp->dir_path) free(dirp->dir_path); + free(dirp); + } + return 0; +} + +//========================================================================== + +int readdir(struct dirstuff * dirp, const char ** name, long * flags, + long * time) +{ + return dirp->dir_bvr->fs_getdirentry( dirp->dir_bvr, + /* dirPath */ dirp->dir_path, + /* dirIndex */ &dirp->dir_index, + /* dirEntry */ (char **)name, flags, time, + 0, 0); +} + +//========================================================================== + +int readdir_ext(struct dirstuff * dirp, const char ** name, long * flags, + long * time, FinderInfo *finderInfo, long *infoValid) +{ + return dirp->dir_bvr->fs_getdirentry( dirp->dir_bvr, + /* dirPath */ dirp->dir_path, + /* dirIndex */ &dirp->dir_index, + /* dirEntry */ (char **)name, + flags, time, + finderInfo, infoValid); +} + +//========================================================================== + +const char * systemConfigDir() +{ + if (gBootFileType == kNetworkDeviceType) + return ""; + return "/Library/Preferences/SystemConfiguration"; +} + +//========================================================================== + +int gBootFileType; + +void scanBootVolumes( int biosdev, int * count ) +{ + BVRef bvr = 0; + + bvr = diskScanBootVolumes(biosdev, count); + if (bvr == NULL) + { + bvr = nbpScanBootVolumes(biosdev, count); + if (bvr != NULL) + { + gBootFileType = kNetworkDeviceType; + } + } + else + { + gBootFileType = kBlockDeviceType; + } +} + +//========================================================================== + +void scanDisks(int biosdev, int *count) +{ + #define MAX_HDD_COUNT 32 + int bvCount; + int hd = 0; + + // Testing up to MAX_HDD_COUNT hard drives. + while(!testBiosread(0x80 + hd, 0) && hd < MAX_HDD_COUNT) + { + bvCount = 0; + scanBootVolumes(0x80 + hd, &bvCount); + hd++; + } + + // Also scanning CD/DVD drive. + if (biosDevIsCDROM(gBIOSDev)) + { + bvCount = 0; + scanBootVolumes(gBIOSDev, &bvCount); + } +} + +//========================================================================== + +BVRef selectBootVolume( BVRef chain ) +{ + BOOL filteredChain = FALSE; + BOOL foundPrimary = FALSE; + BVRef bvr, bvr1 = 0, bvr2 = 0; + + if (chain->filtered) filteredChain = TRUE; + + if (multiboot_partition_set) + for ( bvr = chain; bvr; bvr = bvr->next ) + if ( bvr->part_no == multiboot_partition && bvr->biosdev == gBIOSDev ) + return bvr; + + /* + * Checking "Default Partition" key in system configuration - use format: hd(x,y) - + * to override the default selection. + */ + const char * val; + char testStr[64]; + int cnt; + + if (getValueForKey("Default Partition", &val, &cnt, &bootInfo->bootConfig) && cnt >= 7 && filteredChain) + { + for ( bvr = chain; bvr; bvr = bvr->next ) + { + *testStr = '\0'; + if ( bvr->biosdev >= 0x80 && bvr->biosdev < 0x100 ) + { + sprintf(testStr, "hd(%d,%d)", bvr->biosdev - 0x80, bvr->part_no); + if (strcmp(testStr, val) == 0) + return bvr; + } + } + } + + /* + * Scannig the volume chain backwards and trying to find + * a HFS+ volume with valid boot record signature. + * If not found any active partition then we will + * select this volume as the boot volume. + */ + for ( bvr = chain; bvr; bvr = bvr->next ) + { + if ( bvr->flags & kBVFlagPrimary && bvr->biosdev == gBIOSDev ) foundPrimary = TRUE; + // zhell -- Undo a regression that was introduced from r491 to 492. + // if gBIOSBootVolume is set already, no change is required + if ( bvr->flags & (kBVFlagBootable|kBVFlagSystemVolume) + && gBIOSBootVolume + && (!filteredChain || (filteredChain && bvr->visible)) + && bvr->biosdev == gBIOSDev ) + bvr2 = bvr; + // zhell -- if gBIOSBootVolume is NOT set, we use the "if" statement + // from r491, + if ( bvr->flags & kBVFlagBootable + && ! gBIOSBootVolume + && bvr->biosdev == gBIOSDev ) + bvr2 = bvr; + } + + + /* + * Use the standrad method for selecting the boot volume. + */ + if (foundPrimary) + { + for ( bvr = chain; bvr; bvr = bvr->next ) + { + if ( bvr->flags & kBVFlagNativeBoot && bvr->biosdev == gBIOSDev ) bvr1 = bvr; + if ( bvr->flags & kBVFlagPrimary && bvr->biosdev == gBIOSDev ) bvr2 = bvr; + } + } + + bvr = bvr2 ? bvr2 : + bvr1 ? bvr1 : chain; + + return bvr; +} + +//========================================================================== + +#define LP '(' +#define RP ')' +int gBIOSDev; + +/*! + This is like boot2's gBootVolume except it is for the internal use of + libsaio to track which volume an unqualified path should be relative to. + This replaces bootInfo->kernDev as the carrier of this information. + */ +static BVRef gRootVolume; + +void setRootVolume(BVRef volume) +{ + gRootVolume = volume; + // Veto non-native FS. Basically that means don't allow the root volume to + // be set to a volume we can't read files from. + if(gRootVolume != NULL && ((gRootVolume->flags & kBVFlagNativeBoot) == 0)) + gRootVolume = NULL; +} + +void setBootGlobals(BVRef chain) +{ + // Record default boot device. + gBootVolume = selectBootVolume(chain); + + // turbo - Save the ORIGINAL boot volume too for loading our mkext + if (!gBIOSBootVolume) gBIOSBootVolume = gBootVolume; + + setRootVolume(gBootVolume); +} + +/*! + Extracts the volume selector from the pathname, returns the selected + BVRef, and sets *outPath to the remainder of the path. + If the path did not include a volume selector then the current volume + is used. When called with a volume selector the current volume + is changed to the selected volume unless the volume selector is + that of a ramdisk. + */ +BVRef getBootVolumeRef( const char * path, const char ** outPath ) +{ + const char * cp; + BVRef bvr = gRootVolume; + int biosdev = gBIOSDev; + + // Search for left parenthesis in the path specification. + + for (cp = path; *cp; cp++) { + if (*cp == LP || *cp == '/') break; + } + + if (*cp != LP) // no left paren found + { + // Path is using the implicit current device so if there is + // no current device, then we must fail. + cp = path; + if ( gRootVolume == NULL ) + return NULL; + } + else if ((cp - path) == 2) // found "xx(" + { + const struct devsw * dp; + const char * xp = path; + int i; + int unit = -1; + int part = -1; + + cp++; + + // Check the 2 character device name pointed by 'xp'. + + for (dp = devsw; dp->name; dp++) + { + if ((xp[0] == dp->name[0]) && (xp[1] == dp->name[1])) + break; // found matching entry + } + if (dp->name == NULL) + { + error("Unknown device '%c%c'\n", xp[0], xp[1]); + return NULL; + } + + // Extract the optional unit number from the specification. + // hd(unit) or hd(unit, part). + + i = 0; + while (*cp >= '0' && *cp <= '9') + { + i = i * 10 + *cp++ - '0'; + unit = i; + } + + // Unit is no longer optional and never really was. + // If the user failed to specify it then the unit number from the previous kernDev + // would have been used which makes little sense anyway. + // For example, if the user did fd()/foobar and the current root device was the + // second hard disk (i.e. unit 1) then fd() would select the second floppy drive! + if(unit == -1) + return NULL; + + // Extract the optional partition number from the specification. + + if (*cp == ',') + part = atoi(++cp); + + // If part is not specified part will be -1 whereas before it would have been + // whatever the last partition was which makes about zero sense if the device + // has been switched. + + // Skip past the right paren. + + for ( ; *cp && *cp != RP; cp++) /* LOOP */; + if (*cp == RP) cp++; + + biosdev = dp->biosdev + unit; + + // turbo - bt(0,0) hook + if (biosdev == 0x101) + { + // zef - use the ramdisk if available and the alias is active. + if (gRAMDiskVolume != NULL && gRAMDiskBTAliased == 1) + bvr = gRAMDiskVolume; + else + bvr = gBIOSBootVolume; + } + else + { + bvr = newBootVolumeRef(biosdev, part); + } + + if(bvr == NULL) + return NULL; + } + else + { + // Bad device specifier, skip past the right paren. + + for ( cp++; *cp && *cp != RP; cp++) /* LOOP */; + if (*cp == RP) cp++; + // If gRootVolume was NULL, then bvr will be NULL as well which + // should be caught by the caller. + } + + // Returns the file path following the device spec. + // e.g. 'hd(1,b)mach_kernel' is reduced to 'mach_kernel'. + + *outPath = cp; + + return bvr; +} + +//========================================================================== + +// Function name is a misnomer as scanBootVolumes usually calls diskScanBootVolumes +// which caches the information. So it's only allocated on the first run. +static BVRef newBootVolumeRef( int biosdev, int partno ) +{ + BVRef bvr, bvr1, bvrChain; + + // Fetch the volume list from the device. + + scanBootVolumes( biosdev, NULL ); + bvrChain = getBVChainForBIOSDev(biosdev); + + // Look for a perfect match based on device and partition number. + + for ( bvr1 = NULL, bvr = bvrChain; bvr; bvr = bvr->next ) + { + if ( ( bvr->flags & kBVFlagNativeBoot ) == 0 ) continue; + + bvr1 = bvr; + if ( bvr->part_no == partno ) break; + } + + return bvr ? bvr : bvr1; +} Index: trunk/i386/libsaio/load.c =================================================================== --- trunk/i386/libsaio/load.c (revision 0) +++ trunk/i386/libsaio/load.c (revision 1) @@ -0,0 +1,343 @@ +/* + * Copyright (c) 2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * load.c - Functions for decoding a Mach-o Kernel. + * + * Copyright (c) 1998-2003 Apple Computer, Inc. + * + */ + +#include +#include +#include + +#include + +static long DecodeSegment(long cmdBase, unsigned int*load_addr, unsigned int *load_size); +static long DecodeUnixThread(long cmdBase, unsigned int *entry); +static long DecodeSymbolTable(long cmdBase); + + +static unsigned long gBinaryAddress; +BOOL gHaveKernelCache; +cpu_type_t archCpuType=CPU_TYPE_I386; + +// Public Functions + +long ThinFatFile(void **binary, unsigned long *length) +{ + unsigned long nfat, swapped, size = 0; + struct fat_header *fhp = (struct fat_header *)*binary; + struct fat_arch *fap = + (struct fat_arch *)((unsigned long)*binary + sizeof(struct fat_header)); + cpu_type_t fapcputype; + uint32_t fapoffset; + uint32_t fapsize; + + if (fhp->magic == FAT_MAGIC) { + nfat = fhp->nfat_arch; + swapped = 0; + } else if (fhp->magic == FAT_CIGAM) { + nfat = OSSwapInt32(fhp->nfat_arch); + swapped = 1; + } else { + return -1; + } + + for (; nfat > 0; nfat--, fap++) { + if (swapped) { + fapcputype = OSSwapInt32(fap->cputype); + fapoffset = OSSwapInt32(fap->offset); + fapsize = OSSwapInt32(fap->size); + } + else + { + fapcputype = fap->cputype; + fapoffset = fap->offset; + fapsize = fap->size; + } + + if (fapcputype == archCpuType) { + *binary = (void *) ((unsigned long)*binary + fapoffset); + size = fapsize; + break; + } + } + + if (length != 0) *length = size; + + return 0; +} + +long DecodeMachO(void *binary, entry_t *rentry, char **raddr, int *rsize) +{ + struct mach_header *mH; + unsigned long ncmds, cmdBase, cmd, cmdsize, cmdstart; + // long headerBase, headerAddr, headerSize; + unsigned int vmaddr = ~0; + unsigned int vmend = 0; + unsigned long cnt; + long ret = -1; + unsigned int entry = 0; + + gBinaryAddress = (unsigned long)binary; + + mH = (struct mach_header *)(gBinaryAddress); + switch (archCpuType) + { + case CPU_TYPE_I386: + if (mH->magic != MH_MAGIC) { + error("Mach-O file has bad magic number\n"); + return -1; + } + cmdstart = (unsigned long)gBinaryAddress + sizeof(struct mach_header); + break; + case CPU_TYPE_X86_64: + if (mH->magic != MH_MAGIC_64 && mH->magic == MH_MAGIC) + return -1; + if (mH->magic != MH_MAGIC_64) { + error("Mach-O file has bad magic number\n"); + return -1; + } + cmdstart = (unsigned long)gBinaryAddress + sizeof(struct mach_header_64); + break; + default: + error("Unknown CPU type\n"); + return -1; + } + + cmdBase = cmdstart; + +#if DEBUG + printf("magic: %x\n", (unsigned)mH->magic); + printf("cputype: %x\n", (unsigned)mH->cputype); + printf("cpusubtype: %x\n", (unsigned)mH->cpusubtype); + printf("filetype: %x\n", (unsigned)mH->filetype); + printf("ncmds: %x\n", (unsigned)mH->ncmds); + printf("sizeofcmds: %x\n", (unsigned)mH->sizeofcmds); + printf("flags: %x\n", (unsigned)mH->flags); + getc(); +#endif + + ncmds = mH->ncmds; + + for (cnt = 0; cnt < ncmds; cnt++) { + cmd = ((long *)cmdBase)[0]; + cmdsize = ((long *)cmdBase)[1]; + unsigned int load_addr; + unsigned int load_size; + + switch (cmd) { + case LC_SEGMENT_64: + case LC_SEGMENT: + ret = DecodeSegment(cmdBase, &load_addr, &load_size); + if (ret == 0 && load_size != 0 && load_addr >= KERNEL_ADDR) { + vmaddr = min(vmaddr, load_addr); + vmend = max(vmend, load_addr + load_size); + } + break; + + case LC_UNIXTHREAD: + ret = DecodeUnixThread(cmdBase, &entry); + break; + + case LC_SYMTAB: + break; + + default: +#if NOTDEF + printf("Ignoring cmd type %d.\n", (unsigned)cmd); +#endif + break; + } + + if (ret != 0) return -1; + + cmdBase += cmdsize; + } + + *rentry = (entry_t)( (unsigned long) entry & 0x3fffffff ); + *rsize = vmend - vmaddr; + *raddr = (char *)vmaddr; + + cmdBase = cmdstart; + for (cnt = 0; cnt < ncmds; cnt++) { + cmd = ((long *)cmdBase)[0]; + cmdsize = ((long *)cmdBase)[1]; + + if(cmd==LC_SYMTAB) + if (DecodeSymbolTable(cmdBase)!=0) + return -1; + + cmdBase += cmdsize; + } + + return ret; +} + +// Private Functions + +static long DecodeSegment(long cmdBase, unsigned int *load_addr, unsigned int *load_size) +{ + unsigned long vmaddr, fileaddr; + long vmsize, filesize; + char *segname; + + if (((long *)cmdBase)[0]==LC_SEGMENT_64) + { + struct segment_command_64 *segCmd; + + segCmd = (struct segment_command_64 *)cmdBase; + + vmaddr = (segCmd->vmaddr & 0x3fffffff); + vmsize = segCmd->vmsize; + fileaddr = (gBinaryAddress + segCmd->fileoff); + filesize = segCmd->filesize; + + segname=segCmd->segname; + } + else + { + struct segment_command *segCmd; + + segCmd = (struct segment_command *)cmdBase; + + vmaddr = (segCmd->vmaddr & 0x3fffffff); + vmsize = segCmd->vmsize; + fileaddr = (gBinaryAddress + segCmd->fileoff); + filesize = segCmd->filesize; + + segname=segCmd->segname; + } + + if (vmsize == 0 || filesize == 0) { + *load_addr = ~0; + *load_size = 0; + return 0; + } + +#if DEBUG + printf("segname: %s, vmaddr: %x, vmsize: %x, fileoff: %x, filesize: %x, nsects: %d, flags: %x.\n", + segCmd->segname, (unsigned)vmaddr, (unsigned)vmsize, (unsigned)fileaddr, (unsigned)filesize, + (unsigned) segCmd->nsects, (unsigned)segCmd->flags); + getc(); +#endif + + if (! ((vmaddr >= KERNEL_ADDR && + (vmaddr + vmsize) <= (KERNEL_ADDR + KERNEL_LEN)) || + (vmaddr >= HIB_ADDR && + (vmaddr + vmsize) <= (HIB_ADDR + HIB_LEN)))) { + stop("Kernel overflows available space"); + } + + if (vmsize && (strcmp(segname, "__PRELINK") == 0)) + gHaveKernelCache = 1; + + // Copy from file load area. + if (vmsize>0 && filesize>0) + bcopy((char *)fileaddr, (char *)vmaddr, vmsize>filesize?filesize:vmsize); + + // Zero space at the end of the segment. + if (vmsize > filesize) + bzero((char *)(vmaddr + filesize), vmsize - filesize); + + *load_addr = vmaddr; + *load_size = vmsize; + + return 0; +} + +static long DecodeUnixThread(long cmdBase, unsigned int *entry) +{ + switch (archCpuType) + { + case CPU_TYPE_I386: + { + i386_thread_state_t *i386ThreadState; + + i386ThreadState = (i386_thread_state_t *) + (cmdBase + sizeof(struct thread_command) + 8); + + #if defined(__DARWIN_UNIX03) && __DARWIN_UNIX03 + *entry = i386ThreadState->__eip; + #else + *entry = i386ThreadState->eip; + #endif + return 0; + } + + case CPU_TYPE_X86_64: + { + x86_thread_state64_t *x86_64ThreadState; + + x86_64ThreadState = (x86_thread_state64_t *) + (cmdBase + sizeof(struct thread_command) + 8); + + #if defined(__DARWIN_UNIX03) && __DARWIN_UNIX03 + *entry = x86_64ThreadState->__rip; + #else + *entry = x86_64ThreadState->rip; + #endif + return 0; + } + + default: + error("Unknown CPU type\n"); + return -1; + } +} + +static long DecodeSymbolTable(long cmdBase) +{ + struct symtab_command *symTab, *symTableSave; + long tmpAddr, symsSize, totalSize; + long gSymbolTableAddr; + long gSymbolTableSize; + + symTab = (struct symtab_command *)cmdBase; + +#if DEBUG + printf("symoff: %x, nsyms: %x, stroff: %x, strsize: %x\n", + symTab->symoff, symTab->nsyms, symTab->stroff, symTab->strsize); + getc (); +#endif + + symsSize = symTab->stroff - symTab->symoff; + totalSize = symsSize + symTab->strsize; + + gSymbolTableSize = totalSize + sizeof(struct symtab_command); + gSymbolTableAddr = AllocateKernelMemory(gSymbolTableSize); + // Add the SymTab to the memory-map. + AllocateMemoryRange("Kernel-__SYMTAB", gSymbolTableAddr, gSymbolTableSize, -1); + + symTableSave = (struct symtab_command *)gSymbolTableAddr; + tmpAddr = gSymbolTableAddr + sizeof(struct symtab_command); + + symTableSave->symoff = tmpAddr; + symTableSave->nsyms = symTab->nsyms; + symTableSave->stroff = tmpAddr + symsSize; + symTableSave->strsize = symTab->strsize; + + bcopy((char *)(gBinaryAddress + symTab->symoff), + (char *)tmpAddr, totalSize); + return 0; +} Index: trunk/i386/libsaio/nbp.c =================================================================== --- trunk/i386/libsaio/nbp.c (revision 0) +++ trunk/i386/libsaio/nbp.c (revision 1) @@ -0,0 +1,145 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +#include "libsaio.h" + +/* This NBP code is pretty useless because it just blindly calls INT 2B. + Presumably INT 2B was implemented by some first-stage bootloader that + is long gone. + + One good reason to disable this is that nbpScanBootVolumes always + succeeds. The scanBootVolumes function thus never fails because + it always falls back to NBP. This is a problem because there is + other code in the booter (for example, in open) which needs to + fail instead of attempting to use this NBP which will often + hang the machine. + */ +#ifndef NBP_SUPPORT +#define NBP_SUPPORT 0 +#endif + +#if NBP_SUPPORT + +/* + * Convert zero-based linear address to far pointer. + */ +#define GET_FP(x) ( (((x) & 0xffff0000) << (16 - 4)) | ((x) & 0xffff) ) + +/*========================================================================== + * Issue a command to the network loader. + * + * The 'cmd' command structure should be allocated on the stack to + * ensure that it resides within the addressable range for the + * network loader, which runs in real mode. + */ +static UInt32 nbp(nbpCommandCode_t code, nbpCommand_u * cmd) +{ + loader(code, GET_FP((UInt32) cmd)); + + // Must re-enable the A20 address line, the PXE firmware will + // disable the A20 line control. + // + enableA20(); + + return cmd->header.status; +} + +/*========================================================================== + * Unload Base Code Stack command. + */ +UInt32 nbpUnloadBaseCode() +{ + return nbp(nbpCommandUnloadBaseCode, (nbpCommand_u *) 0); +} + +/*========================================================================== + * TFTP Read File command. + */ +static long NBPLoadFile(CICell ih, char * filePath) +{ + nbpCommandTFTPReadFile_s cmd; + UInt32 ret; + + strcpy((char *)cmd.filename, filePath); + cmd.status = nbpStatusFailed; + cmd.bufferSize = TFTP_LEN; + cmd.buffer = TFTP_ADDR; + + verbose("Loading file: %s\n", filePath); + + ret = nbp(nbpCommandTFTPReadFile, (nbpCommand_u *) &cmd); + + return (ret == nbpStatusSuccess) ? (long)cmd.bufferSize : -1; +} + +/*========================================================================== + * GetDirEntry is not supported. + */ +static long NBPGetDirEntry(CICell ih, char * dirPath, long * dirIndex, + char ** name, long * flags, long * time, + FinderInfo * finderInfo, long * infoValid) +{ + return -1; +} + +//========================================================================== + +static void NBPGetDescription(CICell ih, char * str, long strMaxLen) +{ + sprintf( str, "Ethernet PXE Client" ); +} + +//========================================================================== + +BVRef nbpScanBootVolumes( int biosdev, int * countPtr ) +{ + static BVRef gNetBVR = NULL; + + if ( countPtr ) *countPtr = 1; + + if ( !gNetBVR ) + { + gNetBVR = malloc( sizeof(*gNetBVR) ); + if ( gNetBVR ) + { + bzero(gNetBVR, sizeof(*gNetBVR)); + gNetBVR->biosdev = biosdev; + gNetBVR->flags = kBVFlagPrimary | kBVFlagNativeBoot; + gNetBVR->description = NBPGetDescription; + gNetBVR->fs_loadfile = NBPLoadFile; + gNetBVR->fs_getdirentry = NBPGetDirEntry; + } + } + return gNetBVR; +} +#else +BVRef nbpScanBootVolumes( int biosdev, int * countPtr ) +{ + return NULL; +} +UInt32 nbpUnloadBaseCode() +{ + return 0; +} +#endif Index: trunk/i386/libsaio/ntfs.h =================================================================== --- trunk/i386/libsaio/ntfs.h (revision 0) +++ trunk/i386/libsaio/ntfs.h (revision 1) @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2004 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +extern void NTFSGetDescription(CICell ih, char *str, long strMaxLen); +extern BOOL NTFSProbe (const void *buf); + Index: trunk/i386/libsaio/nvidia.h =================================================================== --- trunk/i386/libsaio/nvidia.h (revision 0) +++ trunk/i386/libsaio/nvidia.h (revision 1) @@ -0,0 +1,129 @@ +/* + * NVidia injector + * + * Copyright (C) 2009 Jasmin Fazlic, iNDi + * + * NVidia injector is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * NVidia driver and injector is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with NVidia injector. If not, see . + */ + /* + * Alternatively you can choose to comply with APSL + */ + +/* + * DCB-Table parsing is based on software (nouveau driver) originally distributed under following license: + * + * + * Copyright 2005-2006 Erik Waling + * Copyright 2006 Stephane Marchesin + * Copyright 2007-2009 Stuart Bennett + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF + * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef __LIBSAIO_NVIDIA_H +#define __LIBSAIO_NVIDIA_H + +bool setup_nvidia_devprop(pci_dt_t *nvda_dev); + +struct nv_chipsets_t { + unsigned device; + char *name; +}; + +#define DCB_MAX_NUM_ENTRIES 16 +#define DCB_MAX_NUM_I2C_ENTRIES 16 + +#define DCB_LOC_ON_CHIP 0 + +struct bios { + uint16_t signature; /* 0x55AA */ + uint8_t size; /* Size in multiples of 512 */ +}; + +#define NV_PROM_OFFSET 0x300000 +#define NV_PROM_SIZE 0x0000ffff +#define NV_PRAMIN_OFFSET 0x00700000 +#define NV_PRAMIN_SIZE 0x00100000 + +#define NV_PBUS_PCI_NV_20 0x00001850 +#define NV_PBUS_PCI_NV_20_ROM_SHADOW_DISABLED (0 << 0) +#define NV_PBUS_PCI_NV_20_ROM_SHADOW_ENABLED (1 << 0) + +#define REG8(reg) ((volatile uint8_t *)regs)[(reg)] +#define REG16(reg) ((volatile uint16_t *)regs)[(reg) >> 1] +#define REG32(reg) ((volatile uint32_t *)regs)[(reg) >> 2] + +#define NV_ARCH_03 0x03 +#define NV_ARCH_04 0x04 +#define NV_ARCH_10 0x10 +#define NV_ARCH_20 0x20 +#define NV_ARCH_30 0x30 +#define NV_ARCH_40 0x40 +#define NV_ARCH_50 0x50 + +#define CHIPSET_NV03 0x0010 +#define CHIPSET_NV04 0x0020 +#define CHIPSET_NV10 0x0100 +#define CHIPSET_NV11 0x0110 +#define CHIPSET_NV15 0x0150 +#define CHIPSET_NV17 0x0170 +#define CHIPSET_NV18 0x0180 +#define CHIPSET_NFORCE 0x01A0 +#define CHIPSET_NFORCE2 0x01F0 +#define CHIPSET_NV20 0x0200 +#define CHIPSET_NV25 0x0250 +#define CHIPSET_NV28 0x0280 +#define CHIPSET_NV30 0x0300 +#define CHIPSET_NV31 0x0310 +#define CHIPSET_NV34 0x0320 +#define CHIPSET_NV35 0x0330 +#define CHIPSET_NV36 0x0340 +#define CHIPSET_NV40 0x0040 +#define CHIPSET_NV41 0x00C0 +#define CHIPSET_NV43 0x0140 +#define CHIPSET_NV44 0x0160 +#define CHIPSET_NV44A 0x0220 +#define CHIPSET_NV45 0x0210 +#define CHIPSET_NV50 0x0190 +#define CHIPSET_NV84 0x0400 +#define CHIPSET_MISC_BRIDGED 0x00F0 +#define CHIPSET_G70 0x0090 +#define CHIPSET_G71 0x0290 +#define CHIPSET_G72 0x01D0 +#define CHIPSET_G73 0x0390 + +// integrated GeForces (6100, 6150) +#define CHIPSET_C51 0x0240 + +// variant of C51, seems based on a G70 design +#define CHIPSET_C512 0x03D0 +#define CHIPSET_G73_BRIDGED 0x02E0 + +#endif /* !__LIBSAIO_NVIDIA_H */ Index: trunk/i386/libsaio/ufs_byteorder.h =================================================================== --- trunk/i386/libsaio/ufs_byteorder.h (revision 0) +++ trunk/i386/libsaio/ufs_byteorder.h (revision 1) @@ -0,0 +1,56 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Copyright (c) 1992 NeXT Computer, Inc. + * + * UFS byte swapping routines to make a big endian file system useful on a + * little endian machine. + * + * HISTORY + * + * 8 Jul 1992 Brian Pinkerton at NeXT + * Created. + */ + +#ifndef __LIBSAIO_UFS_BYTEORDER_H +#define __LIBSAIO_UFS_BYTEORDER_H + +#include +#include +#include +#include +#include +#include +#include + +void byte_swap_ints(unsigned int *array, int count); +void byte_swap_shorts(unsigned short *array, int count); +void byte_swap_longlongs(unsigned long long *array, int count); + +void byte_swap_superblock(struct fs *sb); +void byte_swap_dinode_in(struct dinode *di); +void byte_swap_dir_block_in(char *addr, int count); +void byte_swap_inode_in(struct dinode *dc, struct dinode *ic); + +#endif /* !__LIBSAIO_UFS_BYTEORDER_H */ Index: trunk/i386/libsaio/acpi.h =================================================================== --- trunk/i386/libsaio/acpi.h (revision 0) +++ trunk/i386/libsaio/acpi.h (revision 1) @@ -0,0 +1,82 @@ +#ifndef __LIBSAIO_ACPI_H +#define __LIBSAIO_ACPI_H + +#define ACPI_RANGE_START (0x0E0000) +#define ACPI_RANGE_END (0x0FFFFF) + +#define UINT64_LE_FROM_CHARS(a,b,c,d,e,f,g,h) \ +( ((uint64_t)h << 56) \ +| ((uint64_t)g << 48) \ +| ((uint64_t)f << 40) \ +| ((uint64_t)e << 32) \ +| ((uint64_t)d << 24) \ +| ((uint64_t)c << 16) \ +| ((uint64_t)b << 8) \ +| ((uint64_t)a << 0) \ +) + +#define ACPI_SIGNATURE_UINT64_LE UINT64_LE_FROM_CHARS('R','S','D',' ','P','T','R',' ') + +/* Per ACPI 3.0a spec */ + +// TODO Migrate +struct acpi_2_rsdp { + char Signature[8]; + uint8_t Checksum; + char OEMID[6]; + uint8_t Revision; + uint32_t RsdtAddress; + uint32_t Length; + uint64_t XsdtAddress; + uint8_t ExtendedChecksum; + char Reserved[3]; +} __attribute__((packed)); + +// TODO Migrate +struct acpi_2_rsdt { + char Signature[4]; + uint32_t Length; + uint8_t Revision; + uint8_t Checksum; + char OEMID[6]; + char OEMTableId[8]; + uint32_t OEMRevision; + uint32_t CreatorId; + uint32_t CreatorRevision; +} __attribute__((packed)); + +// TODO Migrate +struct acpi_2_xsdt { + char Signature[4]; + uint32_t Length; + uint8_t Revision; + uint8_t Checksum; + char OEMID[6]; + char OEMTableId[8]; + uint32_t OEMRevision; + uint32_t CreatorId; + uint32_t CreatorRevision; +} __attribute__((packed)); + +// TODO Migrate +struct acpi_2_fadt { + char Signature[4]; + uint32_t Length; + uint8_t Revision; + uint8_t Checksum; + char OEMID[6]; + char OEMTableId[8]; + uint32_t OEMRevision; + uint32_t CreatorId; + uint32_t CreatorRevision; + uint32_t FIRMWARE_CTRL; + uint32_t DSDT; + /*We absolutely don't care about theese fields*/ + uint8_t notimp1[88]; + uint64_t X_FIRMWARE_CTRL; + uint64_t X_DSDT; + /*We absolutely don't care about theese fields*/ + uint8_t notimp2[96]; +} __attribute__((packed)); + +#endif /* !__LIBSAIO_ACPI_H */ Index: trunk/i386/libsaio/ati.h =================================================================== --- trunk/i386/libsaio/ati.h (revision 0) +++ trunk/i386/libsaio/ati.h (revision 1) @@ -0,0 +1,51 @@ +/* + * ATI injector + * + * Copyright (C) 2009 Jasmin Fazlic, iNDi, netkas + * + * ATI injector is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * ATI driver and injector is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with ATI injector. If not, see . + */ + /* + * Alternatively you can choose to comply with APSL + */ + + +#ifndef __LIBSAIO_ATI_H +#define __LIBSAIO_ATI_H + +bool setup_ati_devprop(pci_dt_t *ati_dev); + +struct ati_chipsets_t { + unsigned device; + char *name; +}; + +struct ati_data_key { + uint32_t size; + char *name; + uint8_t data[]; +}; + +struct bios { + uint16_t signature; /* 0x55AA */ + uint8_t size; /* Size in multiples of 512 */ +}; + +#define REG8(reg) ((volatile uint8_t *)regs)[(reg)] +#define REG16(reg) ((volatile uint16_t *)regs)[(reg) >> 1] +#define REG32R(reg) ((volatile uint32_t *)regs)[(reg) >> 2] +#define REG32W(reg, val) ((volatile uint32_t *)regs)[(reg) >> 2] = (val) + + +#endif /* !__LIBSAIO_ATI_H */ Index: trunk/i386/libsaio/sl.h =================================================================== --- trunk/i386/libsaio/sl.h (revision 0) +++ trunk/i386/libsaio/sl.h (revision 1) @@ -0,0 +1,67 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +#ifndef __LIBSAIO_SL_H +#define __LIBSAIO_SL_H + +#include +#include +#include +#include "libsaio.h" + +#define SWAP_BE16(x) OSSwapBigToHostInt16(x) +#define SWAP_LE16(x) OSSwapLittleToHostInt16(x) +#define SWAP_BE32(x) OSSwapBigToHostInt32(x) +#define SWAP_LE32(x) OSSwapLittleToHostInt32(x) +#define SWAP_BE64(x) OSSwapBigToHostInt64(x) +#define SWAP_LE64(x) OSSwapLittleToHostInt64(x) + +// File Permissions and Types +enum { + kPermOtherExecute = 1 << 0, + kPermOtherWrite = 1 << 1, + kPermOtherRead = 1 << 2, + kPermGroupExecute = 1 << 3, + kPermGroupWrite = 1 << 4, + kPermGroupRead = 1 << 5, + kPermOwnerExecute = 1 << 6, + kPermOwnerWrite = 1 << 7, + kPermOwnerRead = 1 << 8, + kPermMask = 0x1FF, + kOwnerNotRoot = 1 << 9, + kFileTypeUnknown = 0x0 << 16, + kFileTypeFlat = 0x1 << 16, + kFileTypeDirectory = 0x2 << 16, + kFileTypeLink = 0x3 << 16, + kFileTypeMask = 0x3 << 16 +}; + +#define Seek(c, p) diskSeek(c, p); +#define Read(c, a, l) diskRead(c, a, l); + +extern void * gFSLoadAddress; +extern cpu_type_t archCpuType; +cpu_type_t detectCpuType (); + +#endif /* !__LIBSAIO_SL_H */ Index: trunk/i386/libsaio/platform.c =================================================================== --- trunk/i386/libsaio/platform.c (revision 0) +++ trunk/i386/libsaio/platform.c (revision 1) @@ -0,0 +1,93 @@ +/* + * platform.c + * + */ + +#include "libsaio.h" +#include "bootstruct.h" +#include "pci.h" +#include "freq_detect.h" +#include "nvidia.h" +#include "spd.h" +#include "platform.h" + +#ifndef DEBUG_PLATFORM +#define DEBUG_PLATFORM 0 +#endif + +#if DEBUG_PLATFORM +#define DBG(x...) printf(x) +#else +#define DBG(x...) +#endif + +PlatformInfo_t Platform; + +void scan_cpu_amd() +{ + // AMD + + // TODO: Retrieve cpu brand string + // TODO: Retrieve cpu core count + // TODO: Retrieve cpu mobile info + +} + +void scan_cpu_intel() +{ + uint32_t cpuid_reg[4]; + + // Get Number of cores per package + /* + Initially set the EAX register to 4 and the ECX register to 0 prior to executing the CPUID instruction. + After executing the CPUID instruction, (EAX[31:26] + 1) contains the number of cores. + */ + cpuid_reg[2]=1; + do_cpuid(4, cpuid_reg); + do_cpuid(4, cpuid_reg); // FIXME: why does this only work the 2nd time ? + Platform.CPU.NoCores = bitfield(cpuid_reg[0], 31, 26) + 1; + + // Find Number of Concurrent Threads Processed (HyperThreading) + do_cpuid(1,cpuid_reg); + if(bitfield(cpuid_reg[1], 23, 16) > 1) + Platform.CPU.NoThreads=Platform.CPU.NoCores; + else + Platform.CPU.NoThreads=Platform.CPU.NoCores * 2; + + // Mobile CPU ? + if (rdmsr64(0x17) & (1<<28)) + Platform.CPU.Mobile = 1; + else + Platform.CPU.Mobile = 0; +} + +void scan_platform() +{ + uint32_t cpuid_reg[4]; + + build_pci_dt(); + + calculate_freq(); + + // Copy the values from calculate_freq() + Platform.CPU.TSCFrequency = tscFrequency; + Platform.CPU.FSBFrequency = fsbFrequency; + Platform.CPU.CPUFrequency = cpuFrequency; + + do_cpuid(0, cpuid_reg); + Platform.CPU.Vendor = cpuid_reg[1]; + + do_cpuid(1, cpuid_reg); + Platform.CPU.Model = bitfield(cpuid_reg[0], 7, 4); + Platform.CPU.Family = bitfield(cpuid_reg[0], 11, 8); + Platform.CPU.ExtModel = bitfield(cpuid_reg[0], 19, 16); + Platform.CPU.ExtFamily = bitfield(cpuid_reg[0], 27, 20); + + // Get vendor specific cpu data + if((Platform.CPU.Vendor == 0x756E6547 /* Intel */) && ((Platform.CPU.Family == 0x06) || (Platform.CPU.Family == 0x0f))) + scan_cpu_intel(); + else if((Platform.CPU.Vendor == 0x68747541 /* AMD */) && (Platform.CPU.Family == 0x0f)) + scan_cpu_amd(); +} + + Index: trunk/i386/libsaio/freq_detect.c =================================================================== --- trunk/i386/libsaio/freq_detect.c (revision 0) +++ trunk/i386/libsaio/freq_detect.c (revision 1) @@ -0,0 +1,291 @@ +/* + * Copyright 2008 Islam Ahmed Zaid. All rights reserved. + */ + +#include "libsaio.h" +#include "freq_detect.h" + +// DFE: enable_PIT2 and disable_PIT2 come from older xnu + +/* + * Enable or disable timer 2. + * Port 0x61 controls timer 2: + * bit 0 gates the clock, + * bit 1 gates output to speaker. + */ +inline static void +enable_PIT2(void) +{ + /* Enable gate, disable speaker */ + __asm__ volatile( + " inb $0x61,%%al \n\t" + " and $0xFC,%%al \n\t" /* & ~0x03 */ + " or $1,%%al \n\t" + " outb %%al,$0x61 \n\t" + : : : "%al" ); +} + +inline static void +disable_PIT2(void) +{ + /* Disable gate and output to speaker */ + __asm__ volatile( + " inb $0x61,%%al \n\t" + " and $0xFC,%%al \n\t" /* & ~0x03 */ + " outb %%al,$0x61 \n\t" + : : : "%al" ); +} + +// DFE: set_PIT2_mode0, poll_PIT2_gate, and measure_tsc_frequency are +// roughly based on Linux code + +/* Set the 8254 channel 2 to mode 0 with the specified value. + In mode 0, the counter will initially set its gate low when the + timer expires. For this to be useful, you ought to set it high + before calling this function. The enable_PIT2 function does this. + */ +static inline void set_PIT2_mode0(uint16_t value) +{ + __asm__ volatile( + " movb $0xB0,%%al \n\t" + " outb %%al,$0x43 \n\t" + " movb %%dl,%%al \n\t" + " outb %%al,$0x42 \n\t" + " movb %%dh,%%al \n\t" + " outb %%al,$0x42" + : : "d"(value) /*: no clobber */ ); +} + +/* Returns the number of times the loop ran before the PIT2 signaled */ +static inline unsigned long poll_PIT2_gate(void) +{ + unsigned long count = 0; + unsigned char nmi_sc_val; + do { + ++count; + __asm__ volatile( + "inb $0x61,%0" + : "=q"(nmi_sc_val) /*:*/ /* no input */ /*:*/ /* no clobber */); + } while( (nmi_sc_val & 0x20) == 0); + return count; +} + +/* + * DFE: Measures the TSC frequency in Hz (64-bit) using the ACPI PM timer + */ +uint64_t measure_tsc_frequency(void) +{ + uint64_t tscStart; + uint64_t tscEnd; + uint64_t tscDelta = 0xffffffffffffffffULL; + unsigned long pollCount; + uint64_t retval = 0; + int i; + + /* Time how many TSC ticks elapse in 30 msec using the 8254 PIT + * counter 2. We run this loop 3 times to make sure the cache + * is hot and we take the minimum delta from all of the runs. + * That is to say that we're biased towards measuring the minimum + * number of TSC ticks that occur while waiting for the timer to + * expire. That theoretically helps avoid inconsistencies when + * running under a VM if the TSC is not virtualized and the host + * steals time. The TSC is normally virtualized for VMware. + */ + for(i = 0; i < 3; ++i) + { + enable_PIT2(); + set_PIT2_mode0(CALIBRATE_LATCH); + tscStart = rdtsc64(); + pollCount = poll_PIT2_gate(); + tscEnd = rdtsc64(); + /* The poll loop must have run at least a few times for accuracy */ + if(pollCount <= 1) + continue; + /* The TSC must increment at LEAST once every millisecond. We + * should have waited exactly 30 msec so the TSC delta should + * be >= 30. Anything less and the processor is way too slow. + */ + if((tscEnd - tscStart) <= CALIBRATE_TIME_MSEC) + continue; + // tscDelta = min(tscDelta, (tscEnd - tscStart)) + if( (tscEnd - tscStart) < tscDelta ) + tscDelta = tscEnd - tscStart; + } + /* tscDelta is now the least number of TSC ticks the processor made in + * a timespan of 0.03 s (e.g. 30 milliseconds) + * Linux thus divides by 30 which gives the answer in kiloHertz because + * 1 / ms = kHz. But we're xnu and most of the rest of the code uses + * Hz so we need to convert our milliseconds to seconds. Since we're + * dividing by the milliseconds, we simply multiply by 1000. + */ + + /* Unlike linux, we're not limited to 32-bit, but we do need to take care + * that we're going to multiply by 1000 first so we do need at least some + * arithmetic headroom. For now, 32-bit should be enough. + * Also unlike Linux, our compiler can do 64-bit integer arithmetic. + */ + if(tscDelta > (1ULL<<32)) + retval = 0; + else + { + retval = tscDelta * 1000 / 30; + } + disable_PIT2(); + return retval; +} + +uint64_t tscFrequency = 0; +uint64_t fsbFrequency = 0; +uint64_t cpuFrequency = 0; + +/* + * Calculates the FSB and CPU frequencies using specific MSRs for each CPU + * - multi. is read from a specific MSR. In the case of Intel, there is: + * a max multi. (used to calculate the FSB freq.), + * and a current multi. (used to calculate the CPU freq.) + * - fsbFrequency = tscFrequency / multi + * - cpuFrequency = fsbFrequency * multi + */ + +void calculate_freq(void) +{ + uint32_t cpuid_reg[4], cpu_vendor; + uint8_t cpu_family, cpu_model, cpu_extfamily, cpu_extmodel; + uint64_t msr, flex_ratio; + uint8_t maxcoef, maxdiv, currcoef, currdiv; + + do_cpuid(0, cpuid_reg); + cpu_vendor = cpuid_reg[1]; + + do_cpuid(1, cpuid_reg); + cpu_model = bitfield(cpuid_reg[0], 7, 4); + cpu_family = bitfield(cpuid_reg[0], 11, 8); + cpu_extmodel = bitfield(cpuid_reg[0], 19, 16); + cpu_extfamily = bitfield(cpuid_reg[0], 27, 20); + + cpu_model += (cpu_extmodel << 4); + + DBG("\nCPU Model: %d - CPU Family: %d - CPU Ext. Family: %d\n", cpu_model, cpu_family, cpu_extfamily); + DBG("The booter will now attempt to read the CPU Multiplier (using RDMSR).\n"); + DBG("Press any key to continue..\n\n"); +#if DEBUG_FREQ + getc(); +#endif + + tscFrequency = measure_tsc_frequency(); + + DBG("CPU Multiplier: "); + + if((cpu_vendor == 0x756E6547 /* Intel */) && ((cpu_family == 0x06) || (cpu_family == 0x0f))) + { + if ((cpu_family == 0x06 && cpu_model >= 0x0c) || + (cpu_family == 0x0f && cpu_model >= 0x03)) + { + /* Nehalem CPU model */ + if (cpu_family == 0x06 && (cpu_model == 0x1a || cpu_model == 0x1e)) + { + msr = rdmsr64(MSR_PLATFORM_INFO); + currcoef = (msr >> 8) & 0xff; + msr = rdmsr64(MSR_FLEX_RATIO); + if ((msr >> 16) & 0x01) + { + flex_ratio = (msr >> 8) & 0xff; + if (currcoef > flex_ratio) + currcoef = flex_ratio; + } + + if (currcoef) + { + DBG("%d\n", currcoef); + fsbFrequency = (tscFrequency / currcoef); + } + cpuFrequency = tscFrequency; + } + else + { + msr = rdmsr64(IA32_PERF_STATUS); + currcoef = (msr >> 8) & 0x1f; + /* Non-integer bus ratio for the max-multi*/ + maxdiv = (msr >> 46) & 0x01; + /* Non-integer bus ratio for the current-multi (undocumented)*/ + currdiv = (msr >> 14) & 0x01; + + if ((cpu_family == 0x06 && cpu_model >= 0x0e) || + (cpu_family == 0x0f)) // This will always be model >= 3 + { + /* On these models, maxcoef defines TSC freq */ + maxcoef = (msr >> 40) & 0x1f; + } + else + { + /* On lower models, currcoef defines TSC freq */ + /* XXX */ + maxcoef = currcoef; + } + + if (maxcoef) + { + if (maxdiv) + fsbFrequency = ((tscFrequency * 2) / ((maxcoef * 2) + 1)); + else + fsbFrequency = (tscFrequency / maxcoef); + + if (currdiv) + cpuFrequency = (fsbFrequency * ((currcoef * 2) + 1) / 2); + else + cpuFrequency = (fsbFrequency * currcoef); + DBG("max: %d%s current: %d%s\n", maxcoef, maxdiv ? ".5" : "",currcoef, currdiv ? ".5" : ""); + } + } + } + } + else if((cpu_vendor == 0x68747541 /* AMD */) && (cpu_family == 0x0f)) + { + if(cpu_extfamily == 0x00 /* K8 */) + { + msr = rdmsr64(K8_FIDVID_STATUS); + currcoef = (msr & 0x3f) / 2 + 4; + currdiv = (msr & 0x01) * 2; + } + else if(cpu_extfamily >= 0x01 /* K10+ */) + { + msr = rdmsr64(K10_COFVID_STATUS); + if(cpu_extfamily == 0x01 /* K10 */) + currcoef = (msr & 0x3f) + 0x10; + else /* K11+ */ + currcoef = (msr & 0x3f) + 0x08; + currdiv = (2 << ((msr >> 6) & 0x07)); + } + + if (currcoef) + { + if (currdiv) + { + fsbFrequency = ((tscFrequency * currdiv) / currcoef); + DBG("%d.%d\n", currcoef / currdiv, ((currcoef % currdiv) * 100) / currdiv); + } + else + { + fsbFrequency = (tscFrequency / currcoef); + DBG("%d\n", currcoef); + } + fsbFrequency = (tscFrequency / currcoef); + cpuFrequency = tscFrequency; + } + } + + if (!fsbFrequency) + { + fsbFrequency = (DEFAULT_FSB * 1000); + cpuFrequency = tscFrequency; + DBG("0 ! using the default value for FSB !\n"); + } + + DBG("TSC Frequency: %dMHz\n", tscFrequency / 1000000); + DBG("CPU Frequency: %dMHz\n", cpuFrequency / 1000000); + DBG("FSB Frequency: %dMHz\n", fsbFrequency / 1000000); + DBG("Press [Enter] to continue..\n"); +#if DEBUG_FREQ + while (getc() != 0x0d) ; +#endif +} Index: trunk/i386/libsaio/platform.h =================================================================== --- trunk/i386/libsaio/platform.h (revision 0) +++ trunk/i386/libsaio/platform.h (revision 1) @@ -0,0 +1,100 @@ +/* + * platform.h + * + */ + +#ifndef __LIBSAIO_PLATFORM_H +#define __LIBSAIO_PLATFORM_H + +#include "libsaio.h" + +#define bit(n) (1ULL << (n)) +#define bitmask(h,l) ((bit(h)|(bit(h)-1)) & ~(bit(l)-1)) +#define bitfield(x,h,l) (((x) & bitmask(h,l)) >> l) + +extern void scan_platform(); + +/* SMBIOS Memory Types */ +#define SMB_MEM_TYPE_UNDEFINED 0 +#define SMB_MEM_TYPE_OTHER 1 +#define SMB_MEM_TYPE_UNKNOWN 2 +#define SMB_MEM_TYPE_DRAM 3 +#define SMB_MEM_TYPE_EDRAM 4 +#define SMB_MEM_TYPE_VRAM 5 +#define SMB_MEM_TYPE_SRAM 6 +#define SMB_MEM_TYPE_RAM 7 +#define SMB_MEM_TYPE_ROM 8 +#define SMB_MEM_TYPE_FLASH 9 +#define SMB_MEM_TYPE_EEPROM 10 +#define SMB_MEM_TYPE_FEPROM 11 +#define SMB_MEM_TYPE_EPROM 12 +#define SMB_MEM_TYPE_CDRAM 13 +#define SMB_MEM_TYPE_3DRAM 14 +#define SMB_MEM_TYPE_SDRAM 15 +#define SMB_MEM_TYPE_SGRAM 16 +#define SMB_MEM_TYPE_RDRAM 17 +#define SMB_MEM_TYPE_DDR 18 +#define SMB_MEM_TYPE_DDR2 19 +#define SMB_MEM_TYPE_FBDIMM 20 +#define SMB_MEM_TYPE_DDR3 24 // Supported in 10.5.6+ AppleSMBIOS + +/* Memory Configuration Types */ +#define SMB_MEM_CHANNEL_UNKNOWN 0 +#define SMB_MEM_CHANNEL_SINGLE 1 +#define SMB_MEM_CHANNEL_DUAL 2 +#define SMB_MEM_CHANNEL_TRIPLE 3 + +/* Maximum number of ram slots */ +#define MAX_RAM_SLOTS 16 + +typedef struct _RamSlotInfo_t { + bool InUse; // Module Present + uint32_t ModuleSize; // Size of Module in MB + char *spd; // SPD Dump +} RamSlotInfo_t; + +typedef struct _PlatformInfo_t { + bool Mobile; // Mobile Platform + bool x86_64; // 64 Bit Capable + struct PCI { + uint8_t NoDevices; // No of PCI devices + } PCI; + struct CPU { + uint32_t Vendor; // Vendor + uint32_t Model; // Model + uint32_t ExtModel; // Extended Model + uint32_t Family; // Family + uint32_t ExtFamily; // Extended Family + uint8_t NoCores; // No Cores per Package + uint8_t NoThreads; // Threads per Package + uint8_t MaxCoef; // Max Multiplier + uint8_t MaxDiv; + uint8_t CurrCoef; // Current Multiplier + uint8_t CurrDiv; + float MaxRatio; + float CurrRatio; + uint64_t TSCFrequency; // TSC Frequency Hz + uint64_t FSBFrequency; // FSB Frequency Hz + uint64_t CPUFrequency; // CPU Frequency Hz + bool Mobile; // Mobile CPU + uint32_t BrandString[16]; // 48 Byte Branding String + } CPU; + struct RAM { + uint64_t Frequency; // Ram Frequency + uint32_t Divider; // Memory divider + float CAS; // CAS 1/2/2.5/3/4/5/6/7 + uint8_t TRC; + uint8_t TRP; + uint8_t RAS; + uint8_t Channels; // Channel Configuration Single,Dual or Triple + uint8_t NoSlots; // Maximum no of slots available + uint8_t Type; // Standard SMBIOS v2.5 Memory Type + char *BrandString; // Branding String Memory Controller + RamSlotInfo_t DIMM[MAX_RAM_SLOTS]; // Information about each slot + } RAM; +} PlatformInfo_t; + +extern PlatformInfo_t Platform; + +#endif /* !__LIBSAIO_PLATFORM_H */ + Index: trunk/i386/libsaio/freq_detect.h =================================================================== --- trunk/i386/libsaio/freq_detect.h (revision 0) +++ trunk/i386/libsaio/freq_detect.h (revision 1) @@ -0,0 +1,77 @@ +/* + * Copyright 2008 Islam Ahmed Zaid. All rights reserved. + */ + +#ifndef __LIBSAIO_FREQ_DETECT_H +#define __LIBSAIO_FREQ_DETECT_H + +#include "libsaio.h" +#ifndef DEBUG_FREQ +#define DEBUG_FREQ 0 +#endif + +#if DEBUG_FREQ +#define DBG(x...) printf(x) +#else +#define DBG(x...) +#endif + +/* Decimal powers: */ +#define kilo (1000ULL) +#define Mega (kilo * kilo) +#define Giga (kilo * Mega) +#define Tera (kilo * Giga) +#define Peta (kilo * Tera) + +#define bit(n) (1ULL << (n)) +#define bitmask(h,l) ((bit(h)|(bit(h)-1)) & ~(bit(l)-1)) +#define bitfield(x,h,l) (((x) & bitmask(h,l)) >> l) + +#define IA32_PERF_STATUS 0x198 +#define MSR_FLEX_RATIO 0x194 +#define MSR_PLATFORM_INFO 0xCE +#define K8_FIDVID_STATUS 0xC0010042 +#define K10_COFVID_STATUS 0xC0010071 + +#define DEFAULT_FSB 100000 /* for now, hardcoding 100MHz for old CPUs */ + +// DFE: This constant comes from older xnu: +#define CLKNUM 1193182 /* formerly 1193167 */ + +// DFE: These two constants come from Linux except CLOCK_TICK_RATE replaced with CLKNUM +#define CALIBRATE_TIME_MSEC 30 /* 30 msecs */ +#define CALIBRATE_LATCH \ + ((CLKNUM * CALIBRATE_TIME_MSEC + 1000/2)/1000) + +extern uint64_t tscFrequency; +extern uint64_t fsbFrequency; +extern uint64_t cpuFrequency; + +void calculate_freq(void); + +static inline uint64_t rdtsc64(void) +{ + uint64_t ret; + __asm__ volatile("rdtsc" : "=A" (ret)); + return ret; +} + +static inline uint64_t rdmsr64(uint32_t msr) +{ + uint64_t ret; + __asm__ volatile("rdmsr" : "=A" (ret) : "c" (msr)); + return ret; +} + +static inline void do_cpuid(uint32_t selector, uint32_t *data) +{ + asm volatile ("cpuid" + : "=a" (data[0]), + "=b" (data[1]), + "=c" (data[2]), + "=d" (data[3]) + : "a" (selector) + ); +} + +#endif /* !__LIBSAIO_FREQ_DETECT_H */ Index: trunk/i386/libsaio/disk.c =================================================================== --- trunk/i386/libsaio/disk.c (revision 0) +++ trunk/i386/libsaio/disk.c (revision 1) @@ -0,0 +1,1900 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Mach Operating System + * Copyright (c) 1990 Carnegie-Mellon University + * Copyright (c) 1989 Carnegie-Mellon University + * All rights reserved. The CMU software License Agreement specifies + * the terms and conditions for use and redistribution. + */ + +/* + * INTEL CORPORATION PROPRIETARY INFORMATION + * + * This software is supplied under the terms of a license agreement or + * nondisclosure agreement with Intel Corporation and may not be copied + * nor disclosed except in accordance with the terms of that agreement. + * + * Copyright 1988, 1989 Intel Corporation + */ + +/* + * Copyright 1993 NeXT Computer, Inc. + * All rights reserved. + */ + +/* Copyright 2007 VMware Inc. + "Preboot" ramdisk support added by David Elliott + GPT support added by David Elliott. Based on IOGUIDPartitionScheme.cpp. + */ + +// Allow UFS_SUPPORT to be overridden with preprocessor option. +#ifndef UFS_SUPPORT +// zef: Disabled UFS support +#define UFS_SUPPORT 0 +#endif + +#include "bootstruct.h" +#include "libsaio.h" +#include "fdisk.h" +#if UFS_SUPPORT +#include "ufs.h" +#endif +#include "hfs.h" +#include "ntfs.h" +#include "msdos.h" +#include "ext2fs.h" + +#include +#include +#include +typedef struct gpt_hdr gpt_hdr; +typedef struct gpt_ent gpt_ent; + +// For EFI_GUID +#include "efi.h" +#include "efi_tables.h" + +#define BPS 512 /* sector size of the device */ +#define PROBEFS_SIZE BPS * 4 /* buffer size for filesystem probe */ +#define CD_BPS 2048 /* CD-ROM block size */ +#define N_CACHE_SECS (BIOS_LEN / BPS) /* Must be a multiple of 4 for CD-ROMs */ +#define UFS_FRONT_PORCH 0 +#define kAPMSector 2 /* Sector number of Apple partition map */ +#define kAPMCDSector 8 /* Translated sector of Apple partition map on a CD */ + +/* + * IORound and IOTrunc convenience functions, in the spirit + * of vm's round_page() and trunc_page(). + */ +#define IORound(value,multiple) \ + ((((value) + (multiple) - 1) / (multiple)) * (multiple)) + +#define IOTrunc(value,multiple) \ + (((value) / (multiple)) * (multiple)); + +/* + * trackbuf points to the start of the track cache. Biosread() + * will store the sectors read from disk to this memory area. + * + * biosbuf points to a sector within the track cache, and is + * updated by Biosread(). + */ +static char * const trackbuf = (char *) ptov(BIOS_ADDR); +static char * biosbuf; + +/* + * Map a disk drive to bootable volumes contained within. + */ +struct DiskBVMap { + int biosdev; // BIOS device number (unique) + BVRef bvr; // chain of boot volumes on the disk + int bvrcnt; // number of boot volumes + struct DiskBVMap * next; // linkage to next mapping +}; + +static struct DiskBVMap * gDiskBVMap = NULL; +static struct disk_blk0 * gBootSector = NULL; + +// Function pointers to be filled in if ramdisks are available: +int (*p_ramdiskReadBytes)( int biosdev, unsigned int blkno, + unsigned int byteoff, + unsigned int byteCount, void * buffer ) = NULL; +int (*p_get_ramdisk_info)(int biosdev, struct driveInfo *dip) = NULL; + + +extern void spinActivityIndicator(int sectors); + +//========================================================================== + +static int getDriveInfo( int biosdev, struct driveInfo *dip ) +{ + static struct driveInfo cached_di; + int cc; + + // Real BIOS devices are 8-bit, so anything above that is for internal use. + // Don't cache ramdisk drive info since it doesn't require several BIOS + // calls and is thus not worth it. + if(biosdev >= 0x100) + { + if(p_get_ramdisk_info != NULL) + cc = (*p_get_ramdisk_info)(biosdev, dip); + else + cc = -1; + if(cc < 0) + { + dip->valid = 0; + return -1; + } + else + return 0; + } + + if ( !cached_di.valid || biosdev != cached_di.biosdev ) + { + cc = get_drive_info(biosdev, &cached_di); + if (cc < 0) { + cached_di.valid = 0; + DEBUG_DISK(("get_drive_info returned error\n")); + return (-1); // BIOS call error + } + } + + bcopy(&cached_di, dip, sizeof(cached_di)); + + return 0; +} + +//========================================================================== +// Maps (E)BIOS return codes to message strings. + +struct NamedValue { + unsigned char value; + const char * name; +}; + +static const char * getNameForValue( const struct NamedValue * nameTable, + unsigned char value ) +{ + const struct NamedValue * np; + + for ( np = nameTable; np->value; np++) + if (np->value == value) + return np->name; + + return NULL; +} + +#define ECC_CORRECTED_ERR 0x11 + +static const struct NamedValue bios_errors[] = { + { 0x10, "Media error" }, + { 0x11, "Corrected ECC error" }, + { 0x20, "Controller or device error" }, + { 0x40, "Seek failed" }, + { 0x80, "Device timeout" }, + { 0xAA, "Drive not ready" }, + { 0x00, 0 } +}; + +static const char * bios_error(int errnum) +{ + static char errorstr[] = "Error 0x00"; + const char * errname; + + errname = getNameForValue( bios_errors, errnum ); + if ( errname ) return errname; + + sprintf(errorstr, "Error 0x%02x", errnum); + return errorstr; // No string, print error code only +} + +//========================================================================== +// Use BIOS INT13 calls to read the sector specified. This function will +// also perform read-ahead to cache a few subsequent sector to the sector +// cache. +// +// Return: +// 0 on success, or an error code from INT13/F2 or INT13/F42 BIOS call. + +static BOOL cache_valid = FALSE; + +static int Biosread( int biosdev, unsigned long long secno ) +{ + static int xbiosdev, xcyl, xhead; + static unsigned int xsec, xnsecs; + struct driveInfo di; + + int rc = -1; + int cyl, head, sec; + int tries = 0; + int bps, divisor; + + if (getDriveInfo(biosdev, &di) < 0) { + return -1; + } + if (di.no_emulation) { + /* Always assume 2k block size; BIOS may lie about geometry */ + bps = 2048; + } else { + bps = di.di.params.phys_nbps; + if (bps == 0) { + return -1; + } + } + divisor = bps / BPS; + + DEBUG_DISK(("Biosread dev %x sec %d bps %d\n", biosdev, secno, bps)); + + // To read the disk sectors, use EBIOS if we can. Otherwise, + // revert to the standard BIOS calls. + + if ((biosdev >= kBIOSDevTypeHardDrive) && + (di.uses_ebios & EBIOS_FIXED_DISK_ACCESS)) + { + if (cache_valid && + (biosdev == xbiosdev) && + (secno >= xsec) && + ((unsigned int)secno < (xsec + xnsecs))) + { + biosbuf = trackbuf + (BPS * (secno - xsec)); + return 0; + } + + xnsecs = N_CACHE_SECS; + xsec = (secno / divisor) * divisor; + cache_valid = FALSE; + + while ((rc = ebiosread(biosdev, secno / divisor, xnsecs / divisor)) && (++tries < 5)) + { + if (rc == ECC_CORRECTED_ERR) { + /* Ignore corrected ECC errors */ + rc = 0; + break; + } + error(" EBIOS read error: %s\n", bios_error(rc), rc); + error(" Block 0x%x Sectors %d\n", secno, xnsecs); + sleep(1); + } + } + else + { + /* spc = spt * heads */ + int spc = (di.di.params.phys_spt * di.di.params.phys_heads); + cyl = secno / spc; + head = (secno % spc) / di.di.params.phys_spt; + sec = secno % di.di.params.phys_spt; + + if (cache_valid && + (biosdev == xbiosdev) && + (cyl == xcyl) && + (head == xhead) && + ((unsigned int)sec >= xsec) && + ((unsigned int)sec < (xsec + xnsecs))) + { + // this sector is in trackbuf cache + biosbuf = trackbuf + (BPS * (sec - xsec)); + return 0; + } + + // Cache up to a track worth of sectors, but do not cross a + // track boundary. + + xcyl = cyl; + xhead = head; + xsec = sec; + xnsecs = ((unsigned int)(sec + N_CACHE_SECS) > di.di.params.phys_spt) ? (di.di.params.phys_spt - sec) : N_CACHE_SECS; + cache_valid = FALSE; + + while ((rc = biosread(biosdev, cyl, head, sec, xnsecs)) && + (++tries < 5)) + { + if (rc == ECC_CORRECTED_ERR) { + /* Ignore corrected ECC errors */ + rc = 0; + break; + } + error(" BIOS read error: %s\n", bios_error(rc), rc); + error(" Block %d, Cyl %d Head %d Sector %d\n", + secno, cyl, head, sec); + sleep(1); + } + } + + // If the BIOS reported success, mark the sector cache as valid. + + if (rc == 0) { + cache_valid = TRUE; + } + biosbuf = trackbuf + (secno % divisor) * BPS; + xbiosdev = biosdev; + + spinActivityIndicator(xnsecs); + + return rc; +} + +//========================================================================== + +int testBiosread( int biosdev, unsigned long long secno ) +{ + return Biosread(biosdev, secno); +} + +//========================================================================== + +static int readBytes( int biosdev, unsigned long long blkno, + unsigned int byteoff, + unsigned int byteCount, void * buffer ) +{ + // ramdisks require completely different code for reading. + if(p_ramdiskReadBytes != NULL && biosdev >= 0x100) + return (*p_ramdiskReadBytes)(biosdev, blkno, byteoff, byteCount, buffer); + + char * cbuf = (char *) buffer; + int error; + int copy_len; + + DEBUG_DISK(("%s: dev %x block %x [%d] -> 0x%x...", __FUNCTION__, + biosdev, blkno, byteCount, (unsigned)cbuf)); + + for ( ; byteCount; cbuf += copy_len, blkno++ ) + { + error = Biosread( biosdev, blkno ); + if ( error ) + { + DEBUG_DISK(("error\n")); + return (-1); + } + + copy_len = ((byteCount + byteoff) > BPS) ? (BPS - byteoff) : byteCount; + bcopy( biosbuf + byteoff, cbuf, copy_len ); + byteCount -= copy_len; + byteoff = 0; + } + + DEBUG_DISK(("done\n")); + + return 0; +} + +//========================================================================== + +static int isExtendedFDiskPartition( const struct fdisk_part * part ) +{ + static unsigned char extParts[] = + { + 0x05, /* Extended */ + 0x0f, /* Win95 extended */ + 0x85, /* Linux extended */ + }; + + unsigned int i; + + for (i = 0; i < sizeof(extParts)/sizeof(extParts[0]); i++) + { + if (extParts[i] == part->systid) return 1; + } + return 0; +} + +//========================================================================== + +static int getNextFDiskPartition( int biosdev, int * partno, + const struct fdisk_part ** outPart ) +{ + static int sBiosdev = -1; + static int sNextPartNo; + static unsigned int sFirstBase; + static unsigned int sExtBase; + static unsigned int sExtDepth; + static struct fdisk_part * sExtPart; + struct fdisk_part * part; + + if ( sBiosdev != biosdev || *partno < 0 ) + { + // Fetch MBR. + if ( readBootSector( biosdev, DISK_BLK0, 0 ) ) return 0; + + sBiosdev = biosdev; + sNextPartNo = 0; + sFirstBase = 0; + sExtBase = 0; + sExtDepth = 0; + sExtPart = NULL; + } + + while (1) + { + part = NULL; + + if ( sNextPartNo < FDISK_NPART ) + { + part = (struct fdisk_part *) gBootSector->parts[sNextPartNo]; + } + else if ( sExtPart ) + { + unsigned int blkno = sExtPart->relsect + sFirstBase; + + // Save the block offset of the first extended partition. + + if (sExtDepth == 0) { + sFirstBase = blkno; + } + sExtBase = blkno; + + // Load extended partition table. + + if ( readBootSector( biosdev, blkno, 0 ) == 0 ) + { + sNextPartNo = 0; + sExtDepth++; + sExtPart = NULL; + continue; + } + // Fall through to part == NULL + } + + if ( part == NULL ) break; // Reached end of partition chain. + + // Advance to next partition number. + + sNextPartNo++; + + if ( isExtendedFDiskPartition(part) ) + { + sExtPart = part; + continue; + } + + // Skip empty slots. + + if ( part->systid == 0x00 ) + { + continue; + } + + // Change relative offset to an absolute offset. + part->relsect += sExtBase; + + *outPart = part; + *partno = sExtDepth ? (int)(sExtDepth + FDISK_NPART) : sNextPartNo; + + break; + } + + return (part != NULL); +} + +//========================================================================== + +static BVRef newFDiskBVRef( int biosdev, int partno, unsigned int blkoff, + const struct fdisk_part * part, + FSInit initFunc, FSLoadFile loadFunc, + FSReadFile readFunc, + FSGetDirEntry getdirFunc, + FSGetFileBlock getBlockFunc, + FSGetUUID getUUIDFunc, + BVGetDescription getDescriptionFunc, + BVFree bvFreeFunc, + int probe, int type, unsigned int bvrFlags ) +{ + BVRef bvr = (BVRef) malloc( sizeof(*bvr) ); + if ( bvr ) + { + bzero(bvr, sizeof(*bvr)); + + bvr->biosdev = biosdev; + bvr->part_no = partno; + bvr->part_boff = blkoff; + bvr->part_type = part->systid; + bvr->fs_loadfile = loadFunc; + bvr->fs_readfile = readFunc; + bvr->fs_getdirentry = getdirFunc; + bvr->fs_getfileblock= getBlockFunc; + bvr->fs_getuuid = getUUIDFunc; + bvr->description = getDescriptionFunc; + bvr->type = type; + bvr->bv_free = bvFreeFunc; + + if ((part->bootid & FDISK_ACTIVE) && (part->systid == FDISK_HFS)) + bvr->flags |= kBVFlagPrimary; + + // Probe the filesystem. + + if ( initFunc ) + { + bvr->flags |= kBVFlagNativeBoot; + + if ( probe && initFunc( bvr ) != 0 ) + { + // filesystem probe failed. + + DEBUG_DISK(("%s: failed probe on dev %x part %d\n", + __FUNCTION__, biosdev, partno)); + + (*bvr->bv_free)(bvr); + bvr = NULL; + } + if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) + { + bvr->flags |= kBVFlagBootable; + } + } + else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) + { + bvr->flags |= kBVFlagForeignBoot; + } + else + { + (*bvr->bv_free)(bvr); + bvr = NULL; + } + } + if (bvr) bvr->flags |= bvrFlags; + return bvr; +} + +//========================================================================== + +BVRef newAPMBVRef( int biosdev, int partno, unsigned int blkoff, + const DPME * part, + FSInit initFunc, FSLoadFile loadFunc, + FSReadFile readFunc, + FSGetDirEntry getdirFunc, + FSGetFileBlock getBlockFunc, + FSGetUUID getUUIDFunc, + BVGetDescription getDescriptionFunc, + BVFree bvFreeFunc, + int probe, int type, unsigned int bvrFlags ) +{ + BVRef bvr = (BVRef) malloc( sizeof(*bvr) ); + if ( bvr ) + { + bzero(bvr, sizeof(*bvr)); + + bvr->biosdev = biosdev; + bvr->part_no = partno; + bvr->part_boff = blkoff; + bvr->fs_loadfile = loadFunc; + bvr->fs_readfile = readFunc; + bvr->fs_getdirentry = getdirFunc; + bvr->fs_getfileblock= getBlockFunc; + bvr->fs_getuuid = getUUIDFunc; + bvr->description = getDescriptionFunc; + bvr->type = type; + bvr->bv_free = bvFreeFunc; + strlcpy(bvr->name, part->dpme_name, DPISTRLEN); + strlcpy(bvr->type_name, part->dpme_type, DPISTRLEN); + + /* + if ( part->bootid & FDISK_ACTIVE ) + bvr->flags |= kBVFlagPrimary; + */ + + // Probe the filesystem. + + if ( initFunc ) + { + bvr->flags |= kBVFlagNativeBoot | kBVFlagBootable | kBVFlagSystemVolume; + + if ( probe && initFunc( bvr ) != 0 ) + { + // filesystem probe failed. + + DEBUG_DISK(("%s: failed probe on dev %x part %d\n", + __FUNCTION__, biosdev, partno)); + + (*bvr->bv_free)(bvr); + bvr = NULL; + } + } + /* + else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) + { + bvr->flags |= kBVFlagForeignBoot; + } + */ + else + { + (*bvr->bv_free)(bvr); + bvr = NULL; + } + } + if (bvr) bvr->flags |= bvrFlags; + return bvr; +} + +//========================================================================== + +// HFS+ GUID in LE form +EFI_GUID const GPT_HFS_GUID = { 0x48465300, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; +// turbo - also our booter partition +EFI_GUID const GPT_BOOT_GUID = { 0x426F6F74, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; +// turbo - or an efi system partition +EFI_GUID const GPT_EFISYS_GUID = { 0xC12A7328, 0xF81F, 0x11D2, { 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B } }; +// zef - basic data partition EBD0A0A2-B9E5-4433-87C0-68B6B72699C7 for foreign OS support +EFI_GUID const GPT_BASICDATA_GUID = { 0xEBD0A0A2, 0xB9E5, 0x4433, { 0x87, 0xC0, 0x68, 0xB6, 0xB7, 0x26, 0x99, 0xC7 } }; +EFI_GUID const GPT_BASICDATA2_GUID = { 0xE3C9E316, 0x0B5C, 0x4DB8, { 0x81, 0x7D, 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE } }; + + +BVRef newGPTBVRef( int biosdev, int partno, unsigned int blkoff, + const gpt_ent * part, + FSInit initFunc, FSLoadFile loadFunc, + FSReadFile readFunc, + FSGetDirEntry getdirFunc, + FSGetFileBlock getBlockFunc, + FSGetUUID getUUIDFunc, + BVGetDescription getDescriptionFunc, + BVFree bvFreeFunc, + int probe, int type, unsigned int bvrFlags ) +{ + BVRef bvr = (BVRef) malloc( sizeof(*bvr) ); + if ( bvr ) + { + bzero(bvr, sizeof(*bvr)); + + bvr->biosdev = biosdev; + bvr->part_no = partno; + bvr->part_boff = blkoff; + bvr->fs_loadfile = loadFunc; + bvr->fs_readfile = readFunc; + bvr->fs_getdirentry = getdirFunc; + bvr->fs_getfileblock= getBlockFunc; + bvr->fs_getuuid = getUUIDFunc; + bvr->description = getDescriptionFunc; + bvr->type = type; + bvr->bv_free = bvFreeFunc; + // FIXME: UCS-2 -> UTF-8 the name + strlcpy(bvr->name, "----", DPISTRLEN); + if ( (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)part->ent_type) == 0) || + (efi_guid_compare(&GPT_HFS_GUID, (EFI_GUID const*)part->ent_type) == 0) ) + strlcpy(bvr->type_name, "GPT HFS+", DPISTRLEN); + else + strlcpy(bvr->type_name, "GPT Unknown", DPISTRLEN); + + /* + if ( part->bootid & FDISK_ACTIVE ) + bvr->flags |= kBVFlagPrimary; + */ + + // Probe the filesystem. + + if ( initFunc ) + { + bvr->flags |= kBVFlagNativeBoot; + + if ( probe && initFunc( bvr ) != 0 ) + { + // filesystem probe failed. + + DEBUG_DISK(("%s: failed probe on dev %x part %d\n", + __FUNCTION__, biosdev, partno)); + + (*bvr->bv_free)(bvr); + bvr = NULL; + } + if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) + { + bvr->flags |= kBVFlagBootable; + } + } + else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) + { + bvr->flags |= kBVFlagForeignBoot; + } + else + { + (*bvr->bv_free)(bvr); + bvr = NULL; + } + } + if (bvr) bvr->flags |= bvrFlags; + return bvr; +} + +//========================================================================== + +/* A note on partition numbers: + * IOKit makes the primary partitions numbers 1-4, and then + * extended partitions are numbered consecutively 5 and up. + * So, for example, if you have two primary partitions and + * one extended partition they will be numbered 1, 2, 5. + */ + +static BVRef diskScanFDiskBootVolumes( int biosdev, int * countPtr ) +{ + const struct fdisk_part * part; + struct DiskBVMap * map; + int partno = -1; + BVRef bvr; +#if UFS_SUPPORT + BVRef booterUFS = NULL; +#endif + int spc; + struct driveInfo di; + boot_drive_info_t *dp; + + /* Initialize disk info */ + if (getDriveInfo(biosdev, &di) != 0) { + return NULL; + } + dp = &di.di; + spc = (dp->params.phys_spt * dp->params.phys_heads); + if (spc == 0) { + /* This is probably a CD-ROM; punt on the geometry. */ + spc = 1; + } + + do { + // Create a new mapping. + + map = (struct DiskBVMap *) malloc( sizeof(*map) ); + if ( map ) + { + map->biosdev = biosdev; + map->bvr = NULL; + map->bvrcnt = 0; + map->next = gDiskBVMap; + gDiskBVMap = map; + + // Create a record for each partition found on the disk. + + while ( getNextFDiskPartition( biosdev, &partno, &part ) ) + { + DEBUG_DISK(("%s: part %d [%x]\n", __FUNCTION__, + partno, part->systid)); + bvr = 0; + + switch ( part->systid ) + { +#if UFS_SUPPORT + case FDISK_UFS: + bvr = newFDiskBVRef( + biosdev, partno, + part->relsect + UFS_FRONT_PORCH/BPS, + part, + UFSInitPartition, + UFSLoadFile, + UFSReadFile, + UFSGetDirEntry, + UFSGetFileBlock, + UFSGetUUID, + UFSGetDescription, + UFSFree, + 0, + kBIOSDevTypeHardDrive, 0); + break; +#endif + + case FDISK_HFS: + bvr = newFDiskBVRef( + biosdev, partno, + part->relsect, + part, + HFSInitPartition, + HFSLoadFile, + HFSReadFile, + HFSGetDirEntry, + HFSGetFileBlock, + HFSGetUUID, + HFSGetDescription, + HFSFree, + 0, + kBIOSDevTypeHardDrive, 0); + break; + + // turbo - we want the booter type scanned also + case FDISK_BOOTER: + if (part->bootid & FDISK_ACTIVE) + gBIOSBootVolume = newFDiskBVRef( + biosdev, partno, + part->relsect, + part, + HFSInitPartition, + HFSLoadFile, + HFSReadFile, + HFSGetDirEntry, + HFSGetFileBlock, + HFSGetUUID, + HFSGetDescription, + HFSFree, + 0, + kBIOSDevTypeHardDrive, 0); + break; + +#if UFS_SUPPORT + case FDISK_BOOTER: + booterUFS = newFDiskBVRef( + biosdev, partno, + ((part->relsect + spc - 1) / spc) * spc, + part, + UFSInitPartition, + UFSLoadFile, + UFSReadFile, + UFSGetDirEntry, + UFSGetFileBlock, + UFSGetUUID, + UFSGetDescription, + UFSFree, + 0, + kBIOSDevTypeHardDrive, 0); + break; +#endif + + case FDISK_FAT32: + case FDISK_DOS12: + case FDISK_DOS16S: + case FDISK_DOS16B: + case FDISK_SMALLFAT32: + case FDISK_DOS16SLBA: + bvr = newFDiskBVRef( + biosdev, partno, + part->relsect, + part, + MSDOSInitPartition, + MSDOSLoadFile, + MSDOSReadFile, + MSDOSGetDirEntry, + MSDOSGetFileBlock, + MSDOSGetUUID, + MSDOSGetDescription, + MSDOSFree, + 0, + kBIOSDevTypeHardDrive, 0); + break; + + case FDISK_NTFS: + bvr = newFDiskBVRef( + biosdev, partno, + part->relsect, + part, + 0, 0, 0, 0, 0, 0, + NTFSGetDescription, + (BVFree)free, + 0, kBIOSDevTypeHardDrive, 0); + break; + + case FDISK_LINUX: + bvr = newFDiskBVRef( + biosdev, partno, + part->relsect, + part, + 0, 0, 0, 0, 0, 0, + EX2GetDescription, + (BVFree)free, + 0, kBIOSDevTypeHardDrive, 0); + break; + + default: + bvr = newFDiskBVRef( + biosdev, partno, + part->relsect, + part, + 0, 0, 0, 0, 0, 0, 0, + (BVFree)free, + 0, + kBIOSDevTypeHardDrive, 0); + break; + } + + if ( bvr ) + { + bvr->next = map->bvr; + map->bvr = bvr; + map->bvrcnt++; + } + } + +#if UFS_SUPPORT + // Booting from a CD with an UFS filesystem embedded + // in a booter partition. + + if ( booterUFS ) + { + if ( map->bvrcnt == 0 ) + { + map->bvr = booterUFS; + map->bvrcnt++; + } + else free( booterUFS ); + } +#endif + } + } while (0); + + /* + * If no FDisk partition, then we will check for + * an Apple partition map elsewhere. + */ +#if UNUSED + if (map->bvrcnt == 0) { + static struct fdisk_part cdpart; + cdpart.systid = 0xCD; + + /* Let's try assuming we are on a hybrid HFS/ISO9660 CD. */ + bvr = newFDiskBVRef( + biosdev, 0, + 0, + &cdpart, + HFSInitPartition, + HFSLoadFile, + HFSReadFile, + HFSGetDirEntry, + HFSGetFileBlock, + HFSGetUUID, + 0, + kBIOSDevTypeHardDrive); + bvr->next = map->bvr; + map->bvr = bvr; + map->bvrcnt++; + } +#endif + // Actually this should always be true given the above code + if(map == gDiskBVMap) + { + // Don't leave a null map in the chain + if(map->bvrcnt == 0 && map->bvr == NULL) + { + gDiskBVMap = map->next; + free(map); + map = NULL; + } + } + + if (countPtr) *countPtr = map ? map->bvrcnt : 0; + + return map ? map->bvr : NULL; +} + +//========================================================================== + +static BVRef diskScanAPMBootVolumes( int biosdev, int * countPtr ) +{ + struct DiskBVMap * map; + struct Block0 *block0_p; + unsigned int blksize; + unsigned int factor; + void *buffer = malloc(BPS); + + /* Check for alternate block size */ + if (readBytes( biosdev, 0, 0, BPS, buffer ) != 0) { + return NULL; + } + block0_p = buffer; + if (OSSwapBigToHostInt16(block0_p->sbSig) == BLOCK0_SIGNATURE) { + blksize = OSSwapBigToHostInt16(block0_p->sbBlkSize); + if (blksize != BPS) { + free(buffer); + buffer = malloc(blksize); + } + factor = blksize / BPS; + } else { + blksize = BPS; + factor = 1; + } + + do { + // Create a new mapping. + + map = (struct DiskBVMap *) malloc( sizeof(*map) ); + if ( map ) + { + int error; + DPME *dpme_p = (DPME *)buffer; + UInt32 i, npart = UINT_MAX; + BVRef bvr; + + map->biosdev = biosdev; + map->bvr = NULL; + map->bvrcnt = 0; + map->next = gDiskBVMap; + gDiskBVMap = map; + + for (i=0; idpme_signature) != DPME_SIGNATURE) { + break; + } + + if (i==0) { + npart = OSSwapBigToHostInt32(dpme_p->dpme_map_entries); + } + /* + printf("name = %s, %s%s %d -> %d [%d -> %d] {%d}\n", + dpme.dpme_name, dpme.dpme_type, (dpme.dpme_flags & DPME_FLAGS_BOOTABLE) ? "(bootable)" : "", + dpme.dpme_pblock_start, dpme.dpme_pblocks, + dpme.dpme_lblock_start, dpme.dpme_lblocks, + dpme.dpme_boot_block); + */ + + if (strcmp(dpme_p->dpme_type, "Apple_HFS") == 0) { + bvr = newAPMBVRef(biosdev, + i, + OSSwapBigToHostInt32(dpme_p->dpme_pblock_start) * factor, + dpme_p, + HFSInitPartition, + HFSLoadFile, + HFSReadFile, + HFSGetDirEntry, + HFSGetFileBlock, + HFSGetUUID, + HFSGetDescription, + HFSFree, + 0, + kBIOSDevTypeHardDrive, 0); + bvr->next = map->bvr; + map->bvr = bvr; + map->bvrcnt++; + } + } + } + } while (0); + + free(buffer); + + if (countPtr) *countPtr = map ? map->bvrcnt : 0; + + return map ? map->bvr : NULL; +} + +//========================================================================== + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +/* + * Trying to figure out the filsystem type of a given partition. + */ +static int probeFileSystem(int biosdev, unsigned int blkoff) +{ + // detected filesystem type; + int result = -1; + int fatbits; + + // Allocating buffer for 4 sectors. + const void * probeBuffer = malloc(PROBEFS_SIZE); + if (probeBuffer == NULL) + goto exit; + + // Reading first 4 sectors of current partition + int error = readBytes(biosdev, blkoff, 0, PROBEFS_SIZE, (void *)probeBuffer); + if (error) + goto exit; + + if (HFSProbe(probeBuffer)) + result = FDISK_HFS; + else if (EX2Probe(probeBuffer)) + result = FDISK_LINUX; + else if (NTFSProbe(probeBuffer)) + result = FDISK_NTFS; + else if (fatbits=MSDOSProbe(probeBuffer)) + { + switch (fatbits) + { + case 32: + default: + result = FDISK_FAT32; + break; + case 16: + result = FDISK_DOS16B; + break; + case 12: + result = FDISK_DOS12; + break; + } + } + else + // Couldn't detect filesystem type + result = 0; + +exit: + if (probeBuffer != NULL) free((void *)probeBuffer); + return result; +} + +static bool isPartitionUsed(gpt_ent * partition) +{ + // + // Ask whether the given partition is used. + // + + return efi_guid_is_null((EFI_GUID const*)partition->ent_type) ? false : true; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static BVRef diskScanGPTBootVolumes( int biosdev, int * countPtr ) +{ + struct DiskBVMap * map = NULL; + void *buffer = malloc(BPS); + int error; + if ( error = readBytes( biosdev, /*secno*/0, 0, BPS, buffer ) != 0) { + verbose("Failed to read boot sector from BIOS device %02xh. Error=%d\n", biosdev, error); + goto scanErr; + } + struct REAL_disk_blk0 *fdiskMap = buffer; + if ( OSSwapLittleToHostInt16(fdiskMap->signature) != DISK_SIGNATURE ) + { + verbose("Failed to find boot signature on BIOS device %02xh\n", biosdev); + goto scanErr; + } + + int fdiskID = 0; + unsigned index; + for ( index = 0; index < FDISK_NPART; index++ ) + { + if ( fdiskMap->parts[index].systid ) + { + if ( fdiskMap->parts[index].systid == 0xEE ) + { + // Fail if two 0xEE partitions are present which + // means the FDISK code will wind up parsing it. + if ( fdiskID ) goto scanErr; + + fdiskID = index + 1; + } + } + } + + if ( fdiskID == 0 ) goto scanErr; + verbose("Attempting to read GPT\n"); + + if(readBytes(biosdev, 1, 0, BPS, buffer) != 0) + goto scanErr; + + gpt_hdr *headerMap = buffer; + + // Determine whether the partition header signature is present. + + if ( memcmp(headerMap->hdr_sig, GPT_HDR_SIG, strlen(GPT_HDR_SIG)) ) + { + goto scanErr; + } + + // Determine whether the partition header size is valid. + + UInt32 headerCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_self); + UInt32 headerSize = OSSwapLittleToHostInt32(headerMap->hdr_size); + + if ( headerSize < offsetof(gpt_hdr, padding) ) + { + goto scanErr; + } + + if ( headerSize > BPS ) + { + goto scanErr; + } + + // Determine whether the partition header checksum is valid. + + headerMap->hdr_crc_self = 0; + + if ( crc32(0, headerMap, headerSize) != headerCheck ) + { + goto scanErr; + } + + // Determine whether the partition entry size is valid. + + UInt64 gptBlock = 0; + UInt32 gptCheck = 0; + UInt32 gptCount = 0; + UInt32 gptID = 0; + gpt_ent * gptMap = 0; + UInt32 gptSize = 0; + + gptBlock = OSSwapLittleToHostInt64(headerMap->hdr_lba_table); + gptCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_table); + gptCount = OSSwapLittleToHostInt32(headerMap->hdr_entries); + gptSize = OSSwapLittleToHostInt32(headerMap->hdr_entsz); + + if ( gptSize < sizeof(gpt_ent) ) + { + goto scanErr; + } + + // Allocate a buffer large enough to hold one map, rounded to a media block. + free(buffer); + buffer = NULL; + + UInt32 bufferSize = IORound(gptCount * gptSize, BPS); + if(bufferSize == 0) + goto scanErr; + buffer = malloc(bufferSize); + + if(readBytes(biosdev, gptBlock, 0, bufferSize, buffer) != 0) + goto scanErr; + + verbose("Read GPT\n"); + + // Allocate a new map for this BIOS device and insert it into the chain + map = malloc(sizeof(*map)); + map->biosdev = biosdev; + map->bvr = NULL; + map->bvrcnt = 0; + map->next = gDiskBVMap; + gDiskBVMap = map; + + // fdisk like partition type id. + int fsType = 0; + + for(gptID = 1; gptID <= gptCount; ++gptID) + { + BVRef bvr = NULL; + unsigned int bvrFlags = 0; + + // size on disk can be larger than sizeof(gpt_ent) + gptMap = (gpt_ent *) ( buffer + ( (gptID - 1) * gptSize) ); + + // NOTE: EFI_GUID's are in LE and we know we're on an x86. + // The IOGUIDPartitionScheme.cpp code uses byte-based UUIDs, we don't. + + if(isPartitionUsed(gptMap)) + { + char stringuuid[100]; + efi_guid_unparse_upper((EFI_GUID*)gptMap->ent_type, stringuuid); + verbose("Reading GPT partition %d, type %s\n", gptID, stringuuid); + + // Getting fdisk like partition type. + fsType = probeFileSystem(biosdev, gptMap->ent_lba_start); + + if ( (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) || + (efi_guid_compare(&GPT_HFS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) + { + bvrFlags = (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ? kBVFlagBooter : 0; + bvr = newGPTBVRef(biosdev, + gptID, + gptMap->ent_lba_start, + gptMap, + HFSInitPartition, + HFSLoadFile, + HFSReadFile, + HFSGetDirEntry, + HFSGetFileBlock, + HFSGetUUID, + HFSGetDescription, + HFSFree, + 0, + kBIOSDevTypeHardDrive, bvrFlags); + } + + // zef - foreign OS support + if ( (efi_guid_compare(&GPT_BASICDATA_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) || + (efi_guid_compare(&GPT_BASICDATA2_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) + { + switch (fsType) + { + case FDISK_NTFS: + bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, + 0, 0, 0, 0, 0, 0, NTFSGetDescription, + (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); + break; + + default: + bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, + 0, 0, 0, 0, 0, 0, 0, + (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); + break; + } + + } + + // turbo - save our booter partition + // zef - only on original boot device + if ( (efi_guid_compare(&GPT_EFISYS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) + { + switch (fsType) + { + case FDISK_HFS: + if (readBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) + { + bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, + HFSInitPartition, + HFSLoadFile, + HFSReadFile, + HFSGetDirEntry, + HFSGetFileBlock, + HFSGetUUID, + HFSGetDescription, + HFSFree, + 0, kBIOSDevTypeHardDrive, kBVFlagEFISystem); + } + break; + + case FDISK_FAT32: + if (testFAT32EFIBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) + { + bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, + MSDOSInitPartition, + MSDOSLoadFile, + MSDOSReadFile, + MSDOSGetDirEntry, + MSDOSGetFileBlock, + MSDOSGetUUID, + MSDOSGetDescription, + MSDOSFree, + 0, kBIOSDevTypeHardDrive, kBVFlagEFISystem); + } + break; + + if (biosdev == gBIOSDev) + gBIOSBootVolume = bvr; + } + } + + if (bvr) + { + // Fixup bvr with the fake fdisk partition type. + if (fsType > 0) bvr->part_type = fsType; + + bvr->next = map->bvr; + map->bvr = bvr; + ++map->bvrcnt; + } + + } + } + +scanErr: + free(buffer); + + if(map) + { + if(countPtr) *countPtr = map->bvrcnt; + return map->bvr; + } + else + { + if(countPtr) *countPtr = 0; + return NULL; + } +} + +//========================================================================== + +static void scanFSLevelBVRSettings(BVRef chain) +{ + BVRef bvr; + char dirSpec[512], fileSpec[512]; + char label[BVSTRLEN]; + int ret; + long flags, time; + int fh, fileSize, error; + + for (bvr = chain; bvr; bvr = bvr->next) + { + ret = -1; + error = 0; + + // + // Check for alternate volume label on boot helper partitions. + // + if (bvr->flags & kBVFlagBooter) + { + sprintf(dirSpec, "hd(%d,%d)/System/Library/CoreServices/", BIOS_DEV_UNIT(bvr), bvr->part_no); + strcpy(fileSpec, ".disk_label.contentDetails"); + ret = GetFileInfo(dirSpec, fileSpec, &flags, &time); + if (!ret) + { + fh = open(strcat(dirSpec, fileSpec), 0); + fileSize = file_size(fh); + if (fileSize > 0 && fileSize < BVSTRLEN) + { + if (read(fh, label, fileSize) != fileSize) + error = -1; + } + else + error = -1; + + close(fh); + + if (!error) + { + label[fileSize] = '\0'; + strcpy(bvr->altlabel, label); + } + } + } + + // + // Check for SystemVersion.plist or ServerVersion.plist + // to determine if a volume hosts an installed system. + // + if (bvr->flags & kBVFlagNativeBoot) + { + sprintf(dirSpec, "hd(%d,%d)/System/Library/CoreServices/", BIOS_DEV_UNIT(bvr), bvr->part_no); + strcpy(fileSpec, "SystemVersion.plist"); + ret = GetFileInfo(dirSpec, fileSpec, &flags, &time); + + if (ret == -1) + { + strcpy(fileSpec, "ServerVersion.plist"); + ret = GetFileInfo(dirSpec, fileSpec, &flags, &time); + } + + if (!ret) + bvr->flags |= kBVFlagSystemVolume; + } + + } +} + +void rescanBIOSDevice(int biosdev) +{ + struct DiskBVMap *oldMap = diskResetBootVolumes(biosdev); + CacheReset(); + diskFreeMap(oldMap); + oldMap = NULL; + + scanBootVolumes(biosdev, 0); +} + +struct DiskBVMap* diskResetBootVolumes(int biosdev) +{ + struct DiskBVMap * map; + struct DiskBVMap *prevMap = NULL; + for ( map = gDiskBVMap; map; prevMap = map, map = map->next ) { + if ( biosdev == map->biosdev ) { + break; + } + } + if(map != NULL) + { + verbose("Resetting BIOS device %xh\n", biosdev); + // Reset the biosbuf cache + cache_valid = FALSE; + if(map == gDiskBVMap) + gDiskBVMap = map->next; + else if(prevMap != NULL) + prevMap->next = map->next; + else + stop(""); + } + // Return the old map, either to be freed, or reinserted later + return map; +} + +// Frees a DiskBVMap and all of its BootVolume's +void diskFreeMap(struct DiskBVMap *map) +{ + if(map != NULL) + { + while(map->bvr != NULL) + { + BVRef bvr = map->bvr; + map->bvr = bvr->next; + (*bvr->bv_free)(bvr); + } + free(map); + } +} + +BVRef diskScanBootVolumes( int biosdev, int * countPtr ) +{ + struct DiskBVMap * map; + BVRef bvr; + int count = 0; + + // Find an existing mapping for this device. + + for ( map = gDiskBVMap; map; map = map->next ) { + if ( biosdev == map->biosdev ) { + count = map->bvrcnt; + break; + } + } + + if (map == NULL) { + bvr = diskScanGPTBootVolumes(biosdev, &count); + if (bvr == NULL) { + bvr = diskScanFDiskBootVolumes(biosdev, &count); + } + if (bvr == NULL) { + bvr = diskScanAPMBootVolumes(biosdev, &count); + } + if (bvr) + { + scanFSLevelBVRSettings(bvr); + } + } else { + bvr = map->bvr; + } + if (countPtr) *countPtr += count; + return bvr; +} + +BVRef getBVChainForBIOSDev(int biosdev) +{ + BVRef chain = NULL; + struct DiskBVMap * map = NULL; + + for (map = gDiskBVMap; map; map = map->next) + { + if (map->biosdev == biosdev) + { + chain = map->bvr; + break; + } + } + + return chain; +} + +BVRef newFilteredBVChain(int minBIOSDev, int maxBIOSDev, unsigned int allowFlags, unsigned int denyFlags, int *count) +{ + BVRef chain = NULL; + BVRef bvr = NULL; + BVRef newBVR = NULL; + BVRef prevBVR = NULL; + + struct DiskBVMap * map = NULL; + int bvCount = 0; + + const char *val; + char devsw[12]; + int len; + + /* + * Traverse gDISKBVmap to get references for + * individual bvr chains of each drive. + */ + for (map = gDiskBVMap; map; map = map->next) + { + for (bvr = map->bvr; bvr; bvr = bvr->next) + { + /* + * Save the last bvr. + */ + if (newBVR) prevBVR = newBVR; + + /* + * Allocate and copy the matched bvr entry into a new one. + */ + newBVR = (BVRef) malloc(sizeof(*newBVR)); + bcopy(bvr, newBVR, sizeof(*newBVR)); + + /* + * Adjust the new bvr's fields. + */ + newBVR->next = NULL; + newBVR->filtered = TRUE; + + if ( (!allowFlags || newBVR->flags & allowFlags) + && (!denyFlags || !(newBVR->flags & denyFlags) ) + && (newBVR->biosdev >= minBIOSDev && newBVR->biosdev <= maxBIOSDev) + ) + newBVR->visible = TRUE; + + /* + * Looking for "Hide Partition" entries in "hd(x,y) hd(n,m)" format + * to be able to hide foreign partitions from the boot menu. + */ + if ( (newBVR->flags & kBVFlagForeignBoot) + && getValueForKey("Hide Partition", &val, &len, &bootInfo->bootConfig) + ) + { + sprintf(devsw, "hd(%d,%d)", BIOS_DEV_UNIT(newBVR), newBVR->part_no); + if (strstr(val, devsw) != NULL) + newBVR->visible = FALSE; + } + + /* + * Use the first bvr entry as the starting chain pointer. + */ + if (!chain) + chain = newBVR; + + /* + * Update the previous bvr's link pointer to use the new memory area. + */ + if (prevBVR) + prevBVR->next = newBVR; + + if (newBVR->visible) + bvCount++; + } + } + +#if DEBUG + for (bvr = chain; bvr; bvr = bvr->next) + { + printf(" bvr: %d, dev: %d, part: %d, flags: %d, vis: %d\n", bvr, bvr->biosdev, bvr->part_no, bvr->flags, bvr->visible); + } + printf("count: %d\n", bvCount); + getc(); +#endif + + *count = bvCount; + return chain; +} + +int freeFilteredBVChain(const BVRef chain) +{ + int ret = 1; + BVRef bvr = chain; + BVRef nextBVR = NULL; + + while (bvr) + { + nextBVR = bvr->next; + + if (bvr->filtered) + { + free(bvr); + } + else + { + ret = 0; + break; + } + + bvr = nextBVR; + } + + return ret; +} + +//========================================================================== + +static const struct NamedValue fdiskTypes[] = +{ + { FDISK_NTFS, "Windows NTFS" }, + { FDISK_DOS12, "Windows FAT12" }, + { FDISK_DOS16B, "Windows FAT16" }, + { FDISK_DOS16S, "Windows FAT16" }, + { FDISK_DOS16SLBA, "Windows FAT16" }, + { FDISK_SMALLFAT32, "Windows FAT32" }, + { FDISK_FAT32, "Windows FAT32" }, + { FDISK_LINUX, "Linux" }, + { FDISK_UFS, "Apple UFS" }, + { FDISK_HFS, "Apple HFS" }, + { FDISK_BOOTER, "Apple Boot/UFS" }, + { 0xCD, "CD-ROM" }, + { 0x00, 0 } /* must be last */ +}; + +//========================================================================== + +void getBootVolumeDescription( BVRef bvr, char * str, long strMaxLen, BOOL verbose ) +{ + unsigned char type = (unsigned char) bvr->part_type; + char *p; + + p = str; + if (verbose) + { + sprintf( str, "hd(%d,%d) ", + BIOS_DEV_UNIT(bvr), bvr->part_no); + for (; strMaxLen > 0 && *p != '\0'; p++, strMaxLen--); + } + + // + // Get the volume label using filesystem specific functions + // or use the alternate volume label if available. + // + if (*bvr->altlabel == '\0') + { + if (bvr->description) + bvr->description(bvr, p, strMaxLen); + } + else + strncpy(p, bvr->altlabel, strMaxLen); + + if (*p == '\0') { + const char * name = getNameForValue( fdiskTypes, type ); + if (name == NULL) { + name = bvr->type_name; + } + if (name == NULL) { + sprintf(p, "TYPE %02x", type); + } else { + strncpy(p, name, strMaxLen); + } + } + + // Set the devices label + sprintf(bvr->label, p); +} + +//========================================================================== + +int readBootSector( int biosdev, unsigned int secno, void * buffer ) +{ + struct disk_blk0 * bootSector = (struct disk_blk0 *) buffer; + int error; + + if ( bootSector == NULL ) + { + if ( gBootSector == NULL ) + { + gBootSector = (struct disk_blk0 *) malloc(sizeof(*gBootSector)); + if ( gBootSector == NULL ) return -1; + } + bootSector = gBootSector; + } + + error = readBytes( biosdev, secno, 0, BPS, bootSector ); + if ( error || bootSector->signature != DISK_SIGNATURE ) + return -1; + + return 0; +} + +/* + * Format of boot1f32 block. + */ + +#define BOOT1F32_MAGIC "BOOT " +#define BOOT1F32_MAGICLEN 11 + +struct disk_boot1f32_blk { + unsigned char init[3]; + unsigned char fsheader[87]; + unsigned char magic[BOOT1F32_MAGICLEN]; + unsigned char bootcode[409]; + unsigned short signature; +}; + +int testFAT32EFIBootSector( int biosdev, unsigned int secno, void * buffer ) +{ + struct disk_boot1f32_blk * bootSector = (struct disk_boot1f32_blk *) buffer; + int error; + + if ( bootSector == NULL ) + { + if ( gBootSector == NULL ) + { + gBootSector = (struct disk_blk0 *) malloc(sizeof(*gBootSector)); + if ( gBootSector == NULL ) return -1; + } + bootSector = (struct disk_boot1f32_blk *) gBootSector; + } + + error = readBytes( biosdev, secno, 0, BPS, bootSector ); + if ( error || bootSector->signature != DISK_SIGNATURE + || strncmp((const char *)bootSector->magic, BOOT1F32_MAGIC, BOOT1F32_MAGICLEN) ) + return -1; + + return 0; +} + +//========================================================================== +// Handle seek request from filesystem modules. + +void diskSeek( BVRef bvr, long long position ) +{ + bvr->fs_boff = position / BPS; + bvr->fs_byteoff = position % BPS; +} + +//========================================================================== +// Handle read request from filesystem modules. + +int diskRead( BVRef bvr, long addr, long length ) +{ + return readBytes( bvr->biosdev, + bvr->fs_boff + bvr->part_boff, + bvr->fs_byteoff, + length, + (void *) addr ); +} + +int rawDiskRead( BVRef bvr, unsigned int secno, void *buffer, unsigned int len ) +{ + int secs; + unsigned char *cbuf = (unsigned char *)buffer; + unsigned int copy_len; + int rc; + + if ((len & (BPS-1)) != 0) { + error("raw disk read not sector aligned"); + return -1; + } + secno += bvr->part_boff; + + cache_valid = FALSE; + + while (len > 0) { + secs = len / BPS; + if (secs > N_CACHE_SECS) secs = N_CACHE_SECS; + copy_len = secs * BPS; + + //printf("rdr: ebiosread(%d, %d, %d)\n", bvr->biosdev, secno, secs); + if ((rc = ebiosread(bvr->biosdev, secno, secs)) != 0) { + /* Ignore corrected ECC errors */ + if (rc != ECC_CORRECTED_ERR) { + error(" EBIOS read error: %s\n", bios_error(rc), rc); + error(" Block %d Sectors %d\n", secno, secs); + return rc; + } + } + bcopy( trackbuf, cbuf, copy_len ); + len -= copy_len; + cbuf += copy_len; + secno += secs; + spinActivityIndicator(secs); + } + + return 0; +} + +int rawDiskWrite( BVRef bvr, unsigned int secno, void *buffer, unsigned int len ) +{ + int secs; + unsigned char *cbuf = (unsigned char *)buffer; + unsigned int copy_len; + int rc; + + if ((len & (BPS-1)) != 0) { + error("raw disk write not sector aligned"); + return -1; + } + secno += bvr->part_boff; + + cache_valid = FALSE; + + while (len > 0) { + secs = len / BPS; + if (secs > N_CACHE_SECS) secs = N_CACHE_SECS; + copy_len = secs * BPS; + + bcopy( cbuf, trackbuf, copy_len ); + //printf("rdr: ebioswrite(%d, %d, %d)\n", bvr->biosdev, secno, secs); + if ((rc = ebioswrite(bvr->biosdev, secno, secs)) != 0) { + error(" EBIOS write error: %s\n", bios_error(rc), rc); + error(" Block %d Sectors %d\n", secno, secs); + return rc; + } + len -= copy_len; + cbuf += copy_len; + secno += secs; + spinActivityIndicator(secs); + } + + return 0; +} + + +int diskIsCDROM(BVRef bvr) +{ + struct driveInfo di; + + if (getDriveInfo(bvr->biosdev, &di) == 0 && di.no_emulation) { + return 1; + } + return 0; +} + +int biosDevIsCDROM(int biosdev) +{ + struct driveInfo di; + + if (getDriveInfo(biosdev, &di) == 0 && di.no_emulation) + { + return 1; + } + return 0; +} Index: trunk/i386/libsaio/pci_setup.c =================================================================== --- trunk/i386/libsaio/pci_setup.c (revision 0) +++ trunk/i386/libsaio/pci_setup.c (revision 1) @@ -0,0 +1,90 @@ +#include "libsaio.h" +#include "bootstruct.h" +#include "pci.h" + +extern void set_eth_builtin(pci_dt_t *eth_dev); +extern bool setup_nvidia_devprop(pci_dt_t *nvda_dev); +extern bool setup_ati_devprop(pci_dt_t *ati_dev); +extern int ehci_acquire(pci_dt_t *pci_dev); +extern int uhci_reset(pci_dt_t *pci_dev); +extern void force_enable_hpet(pci_dt_t *lpc_dev); + +void setup_pci_devs(pci_dt_t *pci_dt) +{ + char *devicepath; + BOOL do_eth_devprop, do_gfx_devprop, fix_ehci, fix_uhci, fix_usb, do_enable_hpet; + pci_dt_t *current = pci_dt; + + do_eth_devprop = do_gfx_devprop = fix_ehci = fix_uhci = fix_usb = do_enable_hpet = false; + + getBoolForKey("EthernetBuiltIn", &do_eth_devprop, &bootInfo->bootConfig); + getBoolForKey("GraphicsEnabler", &do_gfx_devprop, &bootInfo->bootConfig); + if (getBoolForKey("USBBusFix", &fix_usb, &bootInfo->bootConfig) && fix_usb) + fix_ehci = fix_uhci = true; + else + { + getBoolForKey("EHCIacquire", &fix_ehci, &bootInfo->bootConfig); + getBoolForKey("UHCIreset", &fix_uhci, &bootInfo->bootConfig); + } + getBoolForKey("ForceHPET", &do_enable_hpet, &bootInfo->bootConfig); + + while (current) + { + devicepath = get_pci_dev_path(current); + + switch (current->class_id) + { + case PCI_CLASS_NETWORK_ETHERNET: + if (do_eth_devprop) + set_eth_builtin(current); + break; + + case PCI_CLASS_DISPLAY_VGA: + if (do_gfx_devprop) + switch (current->vendor_id) + { + case PCI_VENDOR_ID_ATI: + verbose("ATI VGA Controller [%04x:%04x] :: %s \n", + current->vendor_id, current->device_id, devicepath); + setup_ati_devprop(current); + break; + + case PCI_VENDOR_ID_INTEL: + /* message to be removed once support for these cards is added */ + verbose("Intel VGA Controller [%04x:%04x] :: %s (currently NOT SUPPORTED)\n", + current->vendor_id, current->device_id, devicepath); + break; + + case PCI_VENDOR_ID_NVIDIA: + setup_nvidia_devprop(current); + break; + } + break; + + case PCI_CLASS_SERIAL_USB: + switch (pci_config_read8(current->dev.addr, PCI_CLASS_PROG)) + { + /* EHCI */ + case 0x20: + if (fix_ehci) + ehci_acquire(current); + break; + + /* UHCI */ + case 0x00: + if (fix_uhci) + uhci_reset(current); + break; + } + break; + + case PCI_CLASS_BRIDGE_ISA: + if (do_enable_hpet) + force_enable_hpet(current); + break; + } + + setup_pci_devs(current->children); + current = current->next; + } +} Index: trunk/i386/libsaio/hpet.c =================================================================== --- trunk/i386/libsaio/hpet.c (revision 0) +++ trunk/i386/libsaio/hpet.c (revision 1) @@ -0,0 +1,103 @@ +/* + * + */ + +#include "libsaio.h" +#include "pci.h" +#include "hpet.h" + +#ifndef DEBUG_HPET +#define DEBUG_HPET 0 +#endif + +#if DEBUG_HPET +#define DBG(x...) printf(x) +#else +#define DBG(x...) +#endif + +static struct lpc_controller_t lpc_controllers[] = { + + // Default unknown chipset + { 0, 0, "" }, + + // Intel + { 0x8086, 0x24dc, "ICH5" }, + { 0x8086, 0x2640, "ICH6" }, + { 0x8086, 0x2641, "ICH6M" }, + + { 0x8086, 0x27b0, "ICH7 DH" }, + { 0x8086, 0x27b8, "ICH7" }, + { 0x8086, 0x27b9, "ICH7M" }, + { 0x8086, 0x27bd, "ICH7M DH" }, + + { 0x8086, 0x2810, "ICH8R" }, + { 0x8086, 0x2811, "ICH8M-E" }, + { 0x8086, 0x2812, "ICH8DH" }, + { 0x8086, 0x2814, "ICH8DO" }, + { 0x8086, 0x2815, "ICH8M" }, + + { 0x8086, 0x2912, "ICH9DH" }, + { 0x8086, 0x2914, "ICH9DO" }, + { 0x8086, 0x2916, "ICH9R" }, + { 0x8086, 0x2917, "ICH9M-E" }, + { 0x8086, 0x2918, "ICH9" }, + { 0x8086, 0x2919, "ICH9M" }, + + { 0x8086, 0x3a14, "ICH10DO" }, + { 0x8086, 0x3a16, "ICH10R" }, + { 0x8086, 0x3a18, "ICH10" }, + { 0x8086, 0x3a1a, "ICH10D" }, + +}; + +void force_enable_hpet(pci_dt_t *lpc_dev) +{ + int i; + uint32_t val, hpet_address = 0xFED00000; + void *rcba; + + /* LPC on Intel ICH is always (?) at 00:1f.0 */ + for(i = 1; i < sizeof(lpc_controllers) / sizeof(lpc_controllers[0]); i++) + if ((lpc_controllers[i].vendor == lpc_dev->vendor_id) + && (lpc_controllers[i].device == lpc_dev->device_id)) + { + rcba = (void *)(pci_config_read32(lpc_dev->dev.addr, 0xF0) & 0xFFFFC000); + + DBG("Intel(R) %s LPC Interface [%04x:%04x], MMIO @ 0x%lx\n", + lpc_controllers[i].name, lpc_dev->vendor_id, lpc_dev->device_id, rcba); + + if (rcba == 0) + printf(" RCBA disabled; cannot force enable HPET\n"); + else + { + val = REG32(rcba, 0x3404); + if (val & 0x80) + { + // HPET is enabled in HPTC. Just not reported by BIOS + DBG(" HPET is enabled in HPTC, just not reported by BIOS\n"); + hpet_address |= (val & 3) << 12 ; + DBG(" HPET MMIO @ 0x%lx\n", hpet_address); + } + else + { + // HPET disabled in HPTC. Trying to enable + DBG(" HPET is disabled in HPTC, trying to enable\n"); + REG32(rcba, 0x3404) = val | 0x80; + hpet_address |= (val & 3) << 12 ; + DBG(" Force enabled HPET, MMIO @ 0x%lx\n", hpet_address); + } + + // verify if the job is done + val = REG32(rcba, 0x3404); + if (!(val & 0x80)) + printf(" Failed to force enable HPET\n"); + } + break; + } + +#if DEBUG_HPET + printf("Press [Enter] to continue...\n"); + getc(); +#endif +} Index: trunk/i386/libsaio/cache.c =================================================================== --- trunk/i386/libsaio/cache.c (revision 0) +++ trunk/i386/libsaio/cache.c (revision 1) @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * The contents of this file constitute Original Code as defined in and + * are subject to the Apple Public Source License Version 2.0 (the + * "License"). You may not use this file except in compliance with the + * License. Please obtain a copy of the License at + * http://www.apple.com/publicsource and read it before using this file. + * + * This Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * cache.c - A simple cache for file systems meta-data. + * + * Copyright (c) 2000 Apple Computer, Inc. + * + * DRI: Josh de Cesare + */ + +#include +// #include + +struct CacheEntry { + CICell ih; + long time; + long long offset; +}; +typedef struct CacheEntry CacheEntry; + +#define kCacheSize (0x100000) +#define kCacheMinBlockSize (0x200) +#define kCacheMaxBlockSize (0x4000) +#define kCacheMaxEntries (kCacheSize / kCacheMinBlockSize) + +static CICell gCacheIH; +static long gCacheBlockSize; +static long gCacheNumEntries; +static long gCacheTime; + +#ifdef __i386__ +static CacheEntry *gCacheEntries; +static char *gCacheBuffer; +#else +static CacheEntry gCacheEntries[kCacheMaxEntries]; +static char gCacheBuffer[kCacheSize]; +#endif + +#if CACHE_STATS +unsigned long gCacheHits; +unsigned long gCacheMisses; +unsigned long gCacheEvicts; +#endif + +void CacheReset() +{ + gCacheIH = NULL; +} + +void CacheInit( CICell ih, long blockSize ) +{ +#ifdef __i386__ + if ((ih == gCacheIH) && (blockSize == gCacheBlockSize)) + return; +#endif + + if ((blockSize < kCacheMinBlockSize) || + (blockSize >= kCacheMaxBlockSize)) + return; + + gCacheBlockSize = blockSize; + gCacheNumEntries = kCacheSize / gCacheBlockSize; + gCacheTime = 0; + +#if CACHE_STATS + gCacheHits = 0; + gCacheMisses = 0; + gCacheEvicts = 0; +#endif + + gCacheIH = ih; + +#ifdef __i386__ + if (!gCacheBuffer) gCacheBuffer = (char *) malloc(kCacheSize); + if (!gCacheEntries) gCacheEntries = (CacheEntry *) malloc(kCacheMaxEntries * sizeof(CacheEntry)); + if ( !gCacheBuffer || !gCacheEntries ) + { + gCacheIH = 0; // invalidate cache + return; + } +#endif + + bzero(gCacheEntries, kCacheMaxEntries * sizeof(CacheEntry)); +} + +long CacheRead( CICell ih, char * buffer, long long offset, + long length, long cache ) +{ + long cnt, oldestEntry = 0, oldestTime, loadCache = 0; + CacheEntry *entry; + + // See if the data can be cached. + if (cache && (gCacheIH == ih) && (length == gCacheBlockSize)) { + // Look for the data in the cache. + for (cnt = 0; cnt < gCacheNumEntries; cnt++) { + entry = &gCacheEntries[cnt]; + if ((entry->ih == ih) && (entry->offset == offset)) { + entry->time = ++gCacheTime; + break; + } + } + + // If the data was found copy it to the caller. + if (cnt != gCacheNumEntries) { + bcopy(gCacheBuffer + cnt * gCacheBlockSize, buffer, gCacheBlockSize); +#if CACHE_STATS + gCacheHits++; +#endif + return gCacheBlockSize; + } + + // Could not find the data in the cache. + loadCache = 1; + } + + // Read the data from the disk. + Seek(ih, offset); + Read(ih, (long)buffer, length); +#if CACHE_STATS + if (cache) gCacheMisses++; +#endif + + // Put the data from the disk in the cache if needed. + if (loadCache) { + // Find a free entry. + oldestTime = gCacheTime; + for (cnt = 0; cnt < gCacheNumEntries; cnt++) { + entry = &gCacheEntries[cnt]; + + // Found a free entry. + if (entry->ih == 0) break; + + if (entry->time < oldestTime) { + oldestTime = entry->time; + oldestEntry = cnt; + } + } + + // If no free entry was found, use the oldest. + if (cnt == gCacheNumEntries) { + cnt = oldestEntry; +#if CACHE_STATS + gCacheEvicts++; +#endif + } + + // Copy the data from disk to the new entry. + entry = &gCacheEntries[cnt]; + entry->ih = ih; + entry->time = ++gCacheTime; + entry->offset = offset; + bcopy(buffer, gCacheBuffer + cnt * gCacheBlockSize, gCacheBlockSize); + } + + return length; +} Index: trunk/i386/libsaio/hpet.h =================================================================== --- trunk/i386/libsaio/hpet.h (revision 0) +++ trunk/i386/libsaio/hpet.h (revision 1) @@ -0,0 +1,20 @@ +/* + * + */ + +#ifndef __LIBSAIO_HPET_H +#define __LIBSAIO_HPET_H + +#include "libsaio.h" + +#define REG32(base, reg) ((volatile uint32_t *)base)[(reg) >> 2] + +void force_enable_hpet(pci_dt_t *lpc_dev); + +struct lpc_controller_t { + unsigned vendor; + unsigned device; + char *name; +}; + +#endif /* !__LIBSAIO_HPET_H */ Index: trunk/i386/libsaio/pci.c =================================================================== --- trunk/i386/libsaio/pci.c (revision 0) +++ trunk/i386/libsaio/pci.c (revision 1) @@ -0,0 +1,203 @@ +/* + * + * Copyright 2008 by Islam M. Ahmed Zaid. All rights reserved. + * + */ + +#include "libsaio.h" +#include "bootstruct.h" +#include "pci.h" + +uint32_t pci_config_read(uint32_t pci_addr, uint8_t reg, uint8_t bytes) +{ + uint32_t data = -1; + + pci_addr |= reg & ~3; + outl(PCI_ADDR_REG, pci_addr); + + switch (bytes) + { + case 1: + data = inb(PCI_DATA_REG + (reg & 3)); + break; + case 2: + data = inw(PCI_DATA_REG + (reg & 2)); + break; + case 4: + data = inl(PCI_DATA_REG); + break; + } + + return data; +} + +void pci_config_write(uint32_t pci_addr, uint8_t reg, uint32_t data, uint8_t bytes) +{ + pci_addr |= reg & ~3; + outl(PCI_ADDR_REG, pci_addr); + + switch (bytes) + { + case 1: + outb(PCI_DATA_REG + (reg & 3), data); + break; + case 2: + outw(PCI_DATA_REG + (reg & 2), data); + break; + case 4: + outl(PCI_DATA_REG, data); + break; + } +} + +pci_dt_t *root_pci_dev; + +void scan_pci_bus(pci_dt_t *start, uint8_t bus) +{ + uint8_t dev, func, secondary_bus, header_type; + uint32_t id, pci_addr; + pci_dt_t *new; + pci_dt_t **current = &start->children; + + for (dev = 0; dev < 32; dev++) + for (func = 0; func < 8; func++) + { + pci_addr = PCIADDR(bus, dev, func); + id = pci_config_read32(pci_addr, PCI_VENDOR_ID); + if (!id || id == 0xffffffff) + continue; + + new = (pci_dt_t*)malloc(sizeof(pci_dt_t)); + if (!new) + return; + memset(new, 0, sizeof(pci_dt_t)); + + new->dev.addr = pci_addr; + new->vendor_id = id & 0xffff; + new->device_id = (id >> 16) & 0xffff; + new->class_id = pci_config_read16(pci_addr, PCI_CLASS_DEVICE); + new->parent = start; + + header_type = pci_config_read8(pci_addr, PCI_HEADER_TYPE); + switch (header_type & 0x7f) + { + case PCI_HEADER_TYPE_BRIDGE: + case PCI_HEADER_TYPE_CARDBUS: + secondary_bus = pci_config_read8(pci_addr, PCI_SECONDARY_BUS); + if (secondary_bus != 0) + scan_pci_bus(new, secondary_bus); + break; + } + + *current = new; + current = &new->next; + + if ((func == 0) && ((header_type & 0x80) == 0)) + break; + } +} + +void enable_pci_devs(void) +{ + uint16_t id; + uint32_t rcba, *fd; + + id = pci_config_read16(PCIADDR(0, 0x00, 0), 0x00); + /* make sure we're on Intel chipset */ + if (id != 0x8086) + return; + rcba = pci_config_read32(PCIADDR(0, 0x1f, 0), 0xf0) & ~1; + fd = (uint32_t *)(rcba + 0x3418); + /* set SMBus Disable (SD) to 0 */ + *fd &= ~0x8; + /* and all devices? */ + //*fd = 0x1; +} + +void build_pci_dt(void) +{ + root_pci_dev = malloc(sizeof(pci_dt_t)); + + if (!root_pci_dev) + return; + + bzero(root_pci_dev, sizeof(pci_dt_t)); + enable_pci_devs(); + scan_pci_bus(root_pci_dev, 0); +} + +char dev_path[80]; + +char *get_pci_dev_path(pci_dt_t *pci_dt) +{ + pci_dt_t *current, *end; + char tmp[30]; + + dev_path[0] = 0; + end = root_pci_dev; + + while (end != pci_dt) + { + current = pci_dt; + while (current->parent != end) + current = current->parent; + end = current; + + sprintf(tmp, "%s/Pci(0x%x,0x%x)", + (current->parent == root_pci_dev) ? "PciRoot(0x0)" : "", + current->dev.bits.dev, current->dev.bits.func); + strcat(dev_path, tmp); + } + + return dev_path; +} + +void dump_pci_dt(pci_dt_t *pci_dt) +{ + pci_dt_t *current = pci_dt; + + while (current) + { + printf("%02x:%02x.%x [%04x] [%04x:%04x] :: %s\n", + current->dev.bits.bus, current->dev.bits.dev, current->dev.bits.func, + current->class_id, current->vendor_id, current->device_id, + get_pci_dev_path(current)); + dump_pci_dt(current->children); + current = current->next; + } +} + + +void lspci(const char *booterParam) +{ + if(bootArgs->Video.v_display == VGA_TEXT_MODE) + { + setActiveDisplayPage(1); + clearScreenRows(0, 24); + setCursorPosition(0, 0, 1); + } + + dump_pci_dt(root_pci_dev->children); + + printf("(Press a key to continue...)"); + getc(); + + if(bootArgs->Video.v_display == VGA_TEXT_MODE) + setActiveDisplayPage(0); +} + +int check_vga_nvidia(pci_dt_t *pci_dt) +{ + pci_dt_t *current = pci_dt; + while (current) + { + if(current->vendor_id == PCI_CLASS_DISPLAY_VGA) + if(current->class_id == PCI_VENDOR_ID_NVIDIA) + return 1; + + check_vga_nvidia(current->children); + current = current->next; + } + return 0; +} + Index: trunk/i386/libsaio/stringTable.c =================================================================== --- trunk/i386/libsaio/stringTable.c (revision 0) +++ trunk/i386/libsaio/stringTable.c (revision 1) @@ -0,0 +1,777 @@ +/* + * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 2.0 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ +/* + * Copyright 1993 NeXT, Inc. + * All rights reserved. + */ + +#include "bootstruct.h" +#include "libsaio.h" +#include "xml.h" + +extern char *Language; +extern char *LoadableFamilies; + +int sysConfigValid; + +//static void eatThru(char val, const char **table_p); + +static inline int isspace(char c) +{ + return (c == ' ' || c == '\t'); +} + +/* + * Compare a string to a key with quoted characters + */ +static inline int +keyncmp(const char *str, const char *key, int n) +{ + int c; + while (n--) { + c = *key++; + if (c == '\\') { + switch(c = *key++) { + case 'n': + c = '\n'; + break; + case 'r': + c = '\r'; + break; + case 't': + c = '\t'; + break; + default: + break; + } + } else if (c == '\"') { + /* Premature end of key */ + return 1; + } + if (c != *str++) { + return 1; + } + } + return 0; +} + +#if UNUSED + +static void eatThru(char val, const char **table_p) +{ + register const char *table = *table_p; + register BOOL found = NO; + + while (*table && !found) + { + if (*table == '\\') table += 2; + else + { + if (*table == val) found = YES; + table++; + } + } + *table_p = table; +} + +/* Remove key and its associated value from the table. */ + +BOOL +removeKeyFromTable(const char *key, char *table) +{ + register int len; + register char *tab; + char *buf; + + len = strlen(key); + tab = (char *)table; + buf = (char *)malloc(len + 3); + + sprintf(buf, "\"%s\"", key); + len = strlen(buf); + + while(*tab) { + if(strncmp(buf, tab, len) == 0) { + char c; + + while((c = *(tab + len)) != ';') { + if(c == 0) { + len = -1; + goto out; + } + len++; + } + len++; + if(*(tab + len) == '\n') len++; + goto out; + } + tab++; + } + len = -1; +out: + free(buf); + + if(len == -1) return NO; + + while((*tab = *(tab + len))) { + tab++; + } + + return YES; +} + +char * +newStringFromList( + char **list, + int *size +) +{ + char *begin = *list, *end; + char *newstr; + int newsize = *size; + int bufsize; + + while (*begin && newsize && isspace(*begin)) { + begin++; + newsize--; + } + end = begin; + while (*end && newsize && !isspace(*end)) { + end++; + newsize--; + } + if (begin == end) + return 0; + bufsize = end - begin + 1; + newstr = malloc(bufsize); + strlcpy(newstr, begin, bufsize); + *list = end; + *size = newsize; + return newstr; +} + +#endif + +/* + * compress == compress escaped characters to one character + */ +int stringLength(const char *table, int compress) +{ + int ret = 0; + + while (*table) + { + if (*table == '\\') + { + table += 2; + ret += 1 + (compress ? 0 : 1); + } + else + { + if (*table == '\"') return ret; + ret++; + table++; + } + } + return ret; +} + + +BOOL getValueForConfigTableKey(config_file_t *config, const char *key, const char **val, int *size) +{ + if (config->dictionary != 0 ) { + // Look up key in XML dictionary + TagPtr value; + value = XMLGetProperty(config->dictionary, key); + if (value != 0) { + if (value->type != kTagTypeString) { + error("Non-string tag '%s' found in config file\n", + key); + return NO; + } + *val = value->string; + *size = strlen(value->string); + return YES; + } + } else { + + // Legacy plist-style table + + } + + return NO; +} + +#if UNUSED + +/* + * Returns a new malloc'ed string if one is found + * in the string table matching 'key'. Also translates + * \n escapes in the string. + */ +char *newStringForStringTableKey( + char *table, + char *key, + config_file_t *config +) +{ + const char *val; + char *newstr, *p; + int size; + + if (getValueForConfigTableKey(config, key, &val, &size)) { + newstr = (char *)malloc(size+1); + for (p = newstr; size; size--, p++, val++) { + if ((*p = *val) == '\\') { + switch (*++val) { + case 'r': + *p = '\r'; + break; + case 'n': + *p = '\n'; + break; + case 't': + *p = '\t'; + break; + default: + *p = *val; + break; + } + size--; + } + } + *p = '\0'; + return newstr; + } else { + return 0; + } +} + +#endif + +char * +newStringForKey(char *key, config_file_t *config) +{ + const char *val; + char *newstr; + int size; + + if (getValueForKey(key, &val, &size, config) && size) { + newstr = (char *)malloc(size + 1); + strlcpy(newstr, val, size + 1); + return newstr; + } else { + return 0; + } +} + +/* parse a command line + * in the form: [ ...] [