From 49f0ffaf2c80f08bc5309c4dc465dfa98090e59f Mon Sep 17 00:00:00 2001 From: Matt Ranostay Date: Thu, 17 Aug 2017 16:11:03 -0700 Subject: binding: radio: update build system for standalone binding Radio binding is now standalone so the qmake build scripts need to be updated to reflect that Bug-AGL: SPEC-832 Change-Id: Iab9cd5d18536e416d22d91c492ef489159a62d0d Signed-off-by: Matt Ranostay --- COPYING | 339 + LICENSE | 54 + agl-service-radio.pro | 3 + binding.pri | 6 - binding.pro | 11 - binding/binding.pri | 6 + binding/binding.pro | 11 + binding/convenience/convenience.c | 304 + binding/convenience/convenience.h | 142 + binding/export.map | 1 + binding/radio-binding.c | 493 ++ binding/radio_impl.h | 76 + binding/radio_impl_rtlsdr.c | 254 + binding/radio_output.c | 294 + binding/radio_output.h | 31 + binding/rtl_fm.c | 1267 ++++ binding/rtl_fm.h | 70 + convenience/convenience.c | 304 - convenience/convenience.h | 142 - export.map | 1 - package/config.xml | 19 + package/icon.svg | 14329 ++++++++++++++++++++++++++++++++++++ package/package.pro | 19 + radio-binding.c | 493 -- radio_impl.h | 76 - radio_impl_rtlsdr.c | 254 - radio_output.c | 294 - radio_output.h | 31 - rtl_fm.c | 1267 ---- rtl_fm.h | 70 - 30 files changed, 17712 insertions(+), 2949 deletions(-) create mode 100644 COPYING create mode 100644 LICENSE create mode 100644 agl-service-radio.pro delete mode 100644 binding.pri delete mode 100644 binding.pro create mode 100644 binding/binding.pri create mode 100644 binding/binding.pro create mode 100644 binding/convenience/convenience.c create mode 100644 binding/convenience/convenience.h create mode 100644 binding/export.map create mode 100644 binding/radio-binding.c create mode 100644 binding/radio_impl.h create mode 100644 binding/radio_impl_rtlsdr.c create mode 100644 binding/radio_output.c create mode 100644 binding/radio_output.h create mode 100644 binding/rtl_fm.c create mode 100644 binding/rtl_fm.h delete mode 100644 convenience/convenience.c delete mode 100644 convenience/convenience.h delete mode 100644 export.map create mode 100644 package/config.xml create mode 100644 package/icon.svg create mode 100644 package/package.pro delete mode 100644 radio-binding.c delete mode 100644 radio_impl.h delete mode 100644 radio_impl_rtlsdr.c delete mode 100644 radio_output.c delete mode 100644 radio_output.h delete mode 100644 rtl_fm.c delete mode 100644 rtl_fm.h diff --git a/COPYING b/COPYING new file mode 100644 index 0000000..d511905 --- /dev/null +++ b/COPYING @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program 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 2 of the License, or + (at your option) any later version. + + This program 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..31c692a --- /dev/null +++ b/LICENSE @@ -0,0 +1,54 @@ +Apache License + +Version 2.0, January 2004 + +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. + +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + + You must give any other recipients of the Work or Derivative Works a copy of this License; and + You must cause any modified files to carry prominent notices stating that You changed the files; and + You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and + If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. + + You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS diff --git a/agl-service-radio.pro b/agl-service-radio.pro new file mode 100644 index 0000000..f8d104a --- /dev/null +++ b/agl-service-radio.pro @@ -0,0 +1,3 @@ +TEMPLATE = subdirs +SUBDIRS = binding package +package.depends += binding diff --git a/binding.pri b/binding.pri deleted file mode 100644 index 3448a56..0000000 --- a/binding.pri +++ /dev/null @@ -1,6 +0,0 @@ -TEMPLATE = lib -CONFIG += plugin use_c_linker -CONFIG -= qt -QMAKE_CFLAGS += -Wextra -Wconversion -Wno-unused-parameter -Werror=maybe-uninitialized -Werror=implicit-function-declaration -ffunction-sections -fdata-sections -Wl,--as-needed -Wl,--gc-sections - -DESTDIR = $${OUT_PWD}/../package/root/lib diff --git a/binding.pro b/binding.pro deleted file mode 100644 index d8c5a93..0000000 --- a/binding.pro +++ /dev/null @@ -1,11 +0,0 @@ -TARGET = radio-binding - -HEADERS = radio_impl.h radio_output.h rtl_fm.h convenience/convenience.h -SOURCES = radio-binding.c radio_output.c radio_impl_rtlsdr.c rtl_fm.c convenience/convenience.c - -LIBS += -Wl,--version-script=$$PWD/export.map - -CONFIG += link_pkgconfig -PKGCONFIG += json-c afb-daemon librtlsdr glib-2.0 libpulse-simple - -include(binding.pri) diff --git a/binding/binding.pri b/binding/binding.pri new file mode 100644 index 0000000..3448a56 --- /dev/null +++ b/binding/binding.pri @@ -0,0 +1,6 @@ +TEMPLATE = lib +CONFIG += plugin use_c_linker +CONFIG -= qt +QMAKE_CFLAGS += -Wextra -Wconversion -Wno-unused-parameter -Werror=maybe-uninitialized -Werror=implicit-function-declaration -ffunction-sections -fdata-sections -Wl,--as-needed -Wl,--gc-sections + +DESTDIR = $${OUT_PWD}/../package/root/lib diff --git a/binding/binding.pro b/binding/binding.pro new file mode 100644 index 0000000..d8c5a93 --- /dev/null +++ b/binding/binding.pro @@ -0,0 +1,11 @@ +TARGET = radio-binding + +HEADERS = radio_impl.h radio_output.h rtl_fm.h convenience/convenience.h +SOURCES = radio-binding.c radio_output.c radio_impl_rtlsdr.c rtl_fm.c convenience/convenience.c + +LIBS += -Wl,--version-script=$$PWD/export.map + +CONFIG += link_pkgconfig +PKGCONFIG += json-c afb-daemon librtlsdr glib-2.0 libpulse-simple + +include(binding.pri) diff --git a/binding/convenience/convenience.c b/binding/convenience/convenience.c new file mode 100644 index 0000000..517dc4e --- /dev/null +++ b/binding/convenience/convenience.c @@ -0,0 +1,304 @@ +/* + * Copyright (C) 2014 by Kyle Keen + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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 this program. If not, see . + */ + +/* a collection of user friendly tools + * todo: use strtol for more flexible int parsing + * */ + +#include +#include +#include + +#ifndef _WIN32 +#include +#else +#include +#include +#include +#define _USE_MATH_DEFINES +#endif + +#include + +#include "rtl-sdr.h" + +double atofs(char *s) +/* standard suffixes */ +{ + char last; + int len; + double suff = 1.0; + len = strlen(s); + last = s[len-1]; + s[len-1] = '\0'; + switch (last) { + case 'g': + case 'G': + suff *= 1e3; + case 'm': + case 'M': + suff *= 1e3; + case 'k': + case 'K': + suff *= 1e3; + suff *= atof(s); + s[len-1] = last; + return suff; + } + s[len-1] = last; + return atof(s); +} + +double atoft(char *s) +/* time suffixes, returns seconds */ +{ + char last; + int len; + double suff = 1.0; + len = strlen(s); + last = s[len-1]; + s[len-1] = '\0'; + switch (last) { + case 'h': + case 'H': + suff *= 60; + case 'm': + case 'M': + suff *= 60; + case 's': + case 'S': + suff *= atof(s); + s[len-1] = last; + return suff; + } + s[len-1] = last; + return atof(s); +} + +double atofp(char *s) +/* percent suffixes */ +{ + char last; + int len; + double suff = 1.0; + len = strlen(s); + last = s[len-1]; + s[len-1] = '\0'; + switch (last) { + case '%': + suff *= 0.01; + suff *= atof(s); + s[len-1] = last; + return suff; + } + s[len-1] = last; + return atof(s); +} + +int nearest_gain(rtlsdr_dev_t *dev, int target_gain) +{ + int i, r, err1, err2, count, nearest; + int* gains; + r = rtlsdr_set_tuner_gain_mode(dev, 1); + if (r < 0) { + fprintf(stderr, "WARNING: Failed to enable manual gain.\n"); + return r; + } + count = rtlsdr_get_tuner_gains(dev, NULL); + if (count <= 0) { + return 0; + } + gains = malloc(sizeof(int) * count); + count = rtlsdr_get_tuner_gains(dev, gains); + nearest = gains[0]; + for (i=0; i= 0 && device < device_count) { + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + /* does string exact match a serial */ + for (i = 0; i < device_count; i++) { + rtlsdr_get_device_usb_strings(i, vendor, product, serial); + if (strcmp(s, serial) != 0) { + continue;} + device = i; + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + /* does string prefix match a serial */ + for (i = 0; i < device_count; i++) { + rtlsdr_get_device_usb_strings(i, vendor, product, serial); + if (strncmp(s, serial, strlen(s)) != 0) { + continue;} + device = i; + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + /* does string suffix match a serial */ + for (i = 0; i < device_count; i++) { + rtlsdr_get_device_usb_strings(i, vendor, product, serial); + offset = strlen(serial) - strlen(s); + if (offset < 0) { + continue;} + if (strncmp(s, serial+offset, strlen(s)) != 0) { + continue;} + device = i; + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + fprintf(stderr, "No matching devices found.\n"); + return -1; +} + +// vim: tabstop=8:softtabstop=8:shiftwidth=8:noexpandtab diff --git a/binding/convenience/convenience.h b/binding/convenience/convenience.h new file mode 100644 index 0000000..1faa2af --- /dev/null +++ b/binding/convenience/convenience.h @@ -0,0 +1,142 @@ +/* + * Copyright (C) 2014 by Kyle Keen + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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 this program. If not, see . + */ + +/* a collection of user friendly tools */ + +/*! + * Convert standard suffixes (k, M, G) to double + * + * \param s a string to be parsed + * \return double + */ + +double atofs(char *s); + +/*! + * Convert time suffixes (s, m, h) to double + * + * \param s a string to be parsed + * \return seconds as double + */ + +double atoft(char *s); + +/*! + * Convert percent suffixe (%) to double + * + * \param s a string to be parsed + * \return double + */ + +double atofp(char *s); + +/*! + * Find nearest supported gain + * + * \param dev the device handle given by rtlsdr_open() + * \param target_gain in tenths of a dB + * \return 0 on success + */ + +int nearest_gain(rtlsdr_dev_t *dev, int target_gain); + +/*! + * Set device frequency and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param frequency in Hz + * \return 0 on success + */ + +int verbose_set_frequency(rtlsdr_dev_t *dev, uint32_t frequency); + +/*! + * Set device sample rate and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param samp_rate in samples/second + * \return 0 on success + */ + +int verbose_set_sample_rate(rtlsdr_dev_t *dev, uint32_t samp_rate); + +/*! + * Enable or disable the direct sampling mode and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param on 0 means disabled, 1 I-ADC input enabled, 2 Q-ADC input enabled + * \return 0 on success + */ + +int verbose_direct_sampling(rtlsdr_dev_t *dev, int on); + +/*! + * Enable offset tuning and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \return 0 on success + */ + +int verbose_offset_tuning(rtlsdr_dev_t *dev); + +/*! + * Enable auto gain and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \return 0 on success + */ + +int verbose_auto_gain(rtlsdr_dev_t *dev); + +/*! + * Set tuner gain and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param gain in tenths of a dB + * \return 0 on success + */ + +int verbose_gain_set(rtlsdr_dev_t *dev, int gain); + +/*! + * Set the frequency correction value for the device and report status on stderr. + * + * \param dev the device handle given by rtlsdr_open() + * \param ppm_error correction value in parts per million (ppm) + * \return 0 on success + */ + +int verbose_ppm_set(rtlsdr_dev_t *dev, int ppm_error); + +/*! + * Reset buffer + * + * \param dev the device handle given by rtlsdr_open() + * \return 0 on success + */ + +int verbose_reset_buffer(rtlsdr_dev_t *dev); + +/*! + * Find the closest matching device. + * + * \param s a string to be parsed + * \return dev_index int, -1 on error + */ + +int verbose_device_search(char *s); + diff --git a/binding/export.map b/binding/export.map new file mode 100644 index 0000000..52c1b4a --- /dev/null +++ b/binding/export.map @@ -0,0 +1 @@ +{ global: afbBindingV1*; local: *; }; diff --git a/binding/radio-binding.c b/binding/radio-binding.c new file mode 100644 index 0000000..12ed966 --- /dev/null +++ b/binding/radio-binding.c @@ -0,0 +1,493 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "radio_impl.h" + +static const struct afb_binding_interface *interface; + +static struct afb_event freq_event; +static struct afb_event scan_event; + +static void freq_callback(uint32_t frequency, void *data) +{ + json_object *jresp = json_object_new_object(); + json_object *value = json_object_new_int((int) frequency); + + json_object_object_add(jresp, "value", value); + afb_event_push(freq_event, json_object_get(jresp)); +} + +static void scan_callback(uint32_t frequency, void *data) +{ + json_object *jresp = json_object_new_object(); + json_object *value = json_object_new_int((int) frequency); + + json_object_object_add(jresp, "value", value); + afb_event_push(scan_event, json_object_get(jresp)); +} + +/* + * Binding verb handlers + */ + +/* + * @brief Get (and optionally set) frequency + * + * @param struct afb_req : an afb request structure + * + */ +static void frequency(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "value"); + uint32_t frequency; + + if(value) { + char *p; + frequency = strtoul(value, &p, 10); + if(frequency && *p == '\0') { + radio_impl_set_frequency(frequency); + } else { + afb_req_fail(request, "failed", "Invalid scan direction"); + return; + } + } + ret_json = json_object_new_object(); + frequency = radio_impl_get_frequency(); + json_object_object_add(ret_json, "frequency", json_object_new_int((int32_t) frequency)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Get (and optionally set) frequency band + * + * @param struct afb_req : an afb request structure + * + */ +static void band(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "value"); + int valid = 0; + radio_band_t band; + char band_name[4]; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + if(valid) { + radio_impl_set_band(band); + } else { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + } + ret_json = json_object_new_object(); + band = radio_impl_get_band(); + sprintf(band_name, "%s", band == BAND_AM ? "AM" : "FM"); + json_object_object_add(ret_json, "band", json_object_new_string(band_name)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Check if band is supported + * + * @param struct afb_req : an afb request structure + * + */ +static void band_supported(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "band"); + int valid = 0; + radio_band_t band; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + ret_json = json_object_new_object(); + json_object_object_add(ret_json, + "supported", + json_object_new_int(radio_impl_band_supported(band))); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Get frequency range for a band + * + * @param struct afb_req : an afb request structure + * + */ +static void frequency_range(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "band"); + int valid = 0; + radio_band_t band; + uint32_t min_frequency; + uint32_t max_frequency; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + ret_json = json_object_new_object(); + min_frequency = radio_impl_get_min_frequency(band); + max_frequency = radio_impl_get_max_frequency(band); + json_object_object_add(ret_json, "min", json_object_new_int((int32_t) min_frequency)); + json_object_object_add(ret_json, "max", json_object_new_int((int32_t) max_frequency)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Get frequency step size (Hz) for a band + * + * @param struct afb_req : an afb request structure + * + */ +static void frequency_step(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "band"); + int valid = 0; + radio_band_t band; + uint32_t step; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + ret_json = json_object_new_object(); + step = radio_impl_get_frequency_step(band); + json_object_object_add(ret_json, "step", json_object_new_int((int32_t) step)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Start radio playback + * + * @param struct afb_req : an afb request structure + * + */ +static void start(struct afb_req request) +{ + radio_impl_start(); + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Stop radio playback + * + * @param struct afb_req : an afb request structure + * + */ +static void stop(struct afb_req request) +{ + radio_impl_stop(); + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Scan for a station in the specified direction + * + * @param struct afb_req : an afb request structure + * + */ +static void scan_start(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "direction"); + int valid = 0; + radio_scan_direction_t direction; + + if(value) { + if(!strcasecmp(value, "forward")) { + direction = SCAN_FORWARD; + valid = 1; + } else if(!strcasecmp(value, "backward")) { + direction = SCAN_BACKWARD; + valid = 1; + } else { + char *p; + direction = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(direction) { + case SCAN_FORWARD: + case SCAN_BACKWARD: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid direction"); + return; + } + radio_impl_scan_start(direction, scan_callback, NULL); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Stop station scan + * + * @param struct afb_req : an afb request structure + * + */ +static void scan_stop(struct afb_req request) +{ + radio_impl_scan_stop(); + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Get (and optionally set) stereo mode + * + * @param struct afb_req : an afb request structure + * + */ +static void stereo_mode(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "value"); + int valid = 0; + radio_stereo_mode_t mode; + char mode_name[4]; + + if(value) { + if(!strcasecmp(value, "mono")) { + mode = MONO; + valid = 1; + } else if(!strcasecmp(value, "stereo")) { + mode = STEREO; + valid = 1; + } else { + char *p; + mode = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(mode) { + case MONO: + case STEREO: + valid = 1; + break; + default: + break; + } + } + } + if(valid) { + radio_impl_set_stereo_mode(mode); + } else { + afb_req_fail(request, "failed", "Invalid mode"); + return; + } + } + ret_json = json_object_new_object(); + mode = radio_impl_get_stereo_mode(); + sprintf(mode_name, "%s", mode == MONO ? "mono" : "stereo"); + json_object_object_add(ret_json, "mode", json_object_new_string(mode_name)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Subscribe for an event + * + * @param struct afb_req : an afb request structure + * + */ +static void subscribe(struct afb_req request) +{ + const char *value = afb_req_value(request, "value"); + if(value) { + if(!strcasecmp(value, "frequency")) { + afb_req_subscribe(request, freq_event); + } else if(!strcasecmp(value, "station_found")) { + afb_req_subscribe(request, scan_event); + } else { + afb_req_fail(request, "failed", "Invalid event"); + return; + } + } + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Unsubscribe for an event + * + * @param struct afb_req : an afb request structure + * + */ +static void unsubscribe(struct afb_req request) +{ + const char *value = afb_req_value(request, "value"); + if(value) { + if(!strcasecmp(value, "frequency")) { + afb_req_unsubscribe(request, freq_event); + } else if(!strcasecmp(value, "station_found")) { + afb_req_unsubscribe(request, scan_event); + } else { + afb_req_fail(request, "failed", "Invalid event"); + return; + } + } + afb_req_success(request, NULL, NULL); +} + +static const struct afb_verb_desc_v1 verbs[]= { + { "frequency", AFB_SESSION_CHECK, frequency, "Get/Set frequency" }, + { "band", AFB_SESSION_CHECK, band, "Get/Set band" }, + { "band_supported", AFB_SESSION_CHECK, band_supported, "Check band support" }, + { "frequency_range", AFB_SESSION_CHECK, frequency_range, "Get frequency range" }, + { "frequency_step", AFB_SESSION_CHECK, frequency_step, "Get frequency step" }, + { "start", AFB_SESSION_CHECK, start, "Start radio playback" }, + { "stop", AFB_SESSION_CHECK, stop, "Stop radio playback" }, + { "scan_start", AFB_SESSION_CHECK, scan_start, "Start station scan" }, + { "scan_stop", AFB_SESSION_CHECK, scan_stop, "Stop station scan" }, + { "stereo_mode", AFB_SESSION_CHECK, stereo_mode, "Get/Set stereo_mode" }, + { "subscribe", AFB_SESSION_CHECK, subscribe, "Subscribe for an event" }, + { "unsubscribe", AFB_SESSION_CHECK, unsubscribe, "Unsubscribe for an event" }, + { NULL } +}; + +static const struct afb_binding binding_desc = { + .type = AFB_BINDING_VERSION_1, + .v1 = { + .info = "radio service", + .prefix = "radio", + .verbs = verbs + } +}; + +const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf) +{ + interface = itf; + + return &binding_desc; +} + +int afbBindingV1ServiceInit(struct afb_service service) +{ + int rc; + + freq_event = afb_daemon_make_event(interface->daemon, "frequency"); + scan_event = afb_daemon_make_event(interface->daemon, "station_found"); + + rc = radio_impl_init(); + if(rc == 0) { + radio_impl_set_frequency_callback(freq_callback, NULL); + } + + return rc; +} diff --git a/binding/radio_impl.h b/binding/radio_impl.h new file mode 100644 index 0000000..79e91a4 --- /dev/null +++ b/binding/radio_impl.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _RADIO_IMPL_H +#define _RADIO_IMPL_H + +#include + +typedef enum { + BAND_AM = 0, + BAND_FM +} radio_band_t; + +typedef enum { + SCAN_FORWARD = 0, + SCAN_BACKWARD +} radio_scan_direction_t; + +typedef void (*radio_scan_callback_t)(uint32_t frequency, void *data); + +typedef void (*radio_freq_callback_t)(uint32_t frequency, void *data); + +typedef enum { + MONO = 0, + STEREO +} radio_stereo_mode_t; + +int radio_impl_init(void); + +uint32_t radio_impl_get_frequency(void); + +void radio_impl_set_frequency(uint32_t frequency); + +void radio_impl_set_frequency_callback(radio_freq_callback_t callback, + void *data); + +radio_band_t radio_impl_get_band(void); + +void radio_impl_set_band(radio_band_t band); + +int radio_impl_band_supported(radio_band_t band); + +uint32_t radio_impl_get_min_frequency(radio_band_t band); + +uint32_t radio_impl_get_max_frequency(radio_band_t band); + +uint32_t radio_impl_get_frequency_step(radio_band_t band); + +void radio_impl_start(void); + +void radio_impl_stop(void); + +void radio_impl_scan_start(radio_scan_direction_t direction, + radio_scan_callback_t callback, + void *data); + +void radio_impl_scan_stop(void); + +radio_stereo_mode_t radio_impl_get_stereo_mode(void); + +void radio_impl_set_stereo_mode(radio_stereo_mode_t mode); + +#endif /* _RADIO_IMPL_H */ diff --git a/binding/radio_impl_rtlsdr.c b/binding/radio_impl_rtlsdr.c new file mode 100644 index 0000000..4364fd5 --- /dev/null +++ b/binding/radio_impl_rtlsdr.c @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include + +#include "radio_impl.h" +#include "radio_output.h" +#include "rtl_fm.h" + +// Structure to describe FM band plans, all values in Hz. +typedef struct { + char *name; + uint32_t min; + uint32_t max; + uint32_t step; +} fm_band_plan_t; + +static fm_band_plan_t known_fm_band_plans[5] = { + { .name = "US", .min = 87900000, .max = 107900000, .step = 200000 }, + { .name = "JP", .min = 76100000, .max = 89900000, .step = 100000 }, + { .name = "EU", .min = 87500000, .max = 108000000, .step = 50000 }, + { .name = "ITU-1", .min = 87500000, .max = 108000000, .step = 50000 }, + { .name = "ITU-2", .min = 87900000, .max = 107900000, .step = 50000 } +}; + +static unsigned int bandplan; +static bool present; +static bool active; +static uint32_t current_frequency; + +static void rtl_output_callback(int16_t *result, int result_len, void *ctx) +{ + if(active) + radio_output_write((char*) result, result_len * 2); +} + +int radio_impl_init(void) +{ + GKeyFile* conf_file; + int conf_file_present = 0; + char *value_str; + + if(present) + return -1; + + // Load settings from configuration file if it exists + conf_file = g_key_file_new(); + if(conf_file && + g_key_file_load_from_dirs(conf_file, + "AGL.conf", + (const gchar**) g_get_system_config_dirs(), + NULL, + G_KEY_FILE_KEEP_COMMENTS, + NULL) == TRUE) { + conf_file_present = 1; + + // Set band plan if it is specified + value_str = g_key_file_get_string(conf_file, + "radio", + "fmbandplan", + NULL); + if(value_str) { + unsigned int i; + for(i = 0; + i < sizeof(known_fm_band_plans) / sizeof(fm_band_plan_t); + i++) { + if(!strcasecmp(value_str, known_fm_band_plans[i].name)) { + bandplan = i; + break; + } + } + } + } + fprintf(stderr, "Using FM Bandplan: %s\n", known_fm_band_plans[bandplan].name); + + current_frequency = radio_impl_get_min_frequency(BAND_FM); + if(rtl_fm_init(current_frequency, 200000, 48000, rtl_output_callback, NULL) < 0) { + return -1; + } + + if(conf_file_present) { + GError *error = NULL; + int n; + + // Allow over-riding scanning parameters just in case a demo + // setup needs to do so to work reliably. + n = g_key_file_get_integer(conf_file, + "radio", + "scan_squelch_level", + &error); + //error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND && + //error->code != G_KEY_FILE_ERROR_INVALID_VALUE) { + if(!error) { + fprintf(stderr, "Scanning squelch level set to %d\n", n); + rtl_fm_scan_set_squelch_level(n); + } + + error = NULL; + n = g_key_file_get_integer(conf_file, + "radio", + "scan_squelch_limit", + &error); + if(!error) { + fprintf(stderr, "Scanning squelch limit set to %d\n", n); + rtl_fm_scan_set_squelch_limit(n); + } + + g_key_file_free(conf_file); + } + + present = true; + return 0; +} + +uint32_t radio_impl_get_frequency(void) +{ + return current_frequency; +} + +void radio_impl_set_frequency(uint32_t frequency) +{ + if(!present) + return; + + if(frequency < known_fm_band_plans[bandplan].min || + frequency > known_fm_band_plans[bandplan].max) + return; + + radio_impl_scan_stop(); + current_frequency = frequency; + rtl_fm_set_freq(frequency); +} + +void radio_impl_set_frequency_callback(radio_freq_callback_t callback, + void *data) +{ + rtl_fm_set_freq_callback(callback, data); +} + +radio_band_t radio_impl_get_band(void) +{ + return BAND_FM; +} + +void radio_impl_set_band(radio_band_t band) +{ + // We only support FM, so do nothing +} + +int radio_impl_band_supported(radio_band_t band) +{ + if(band == BAND_FM) + return 1; + return 0; +} + +uint32_t radio_impl_get_min_frequency(radio_band_t band) +{ + return known_fm_band_plans[bandplan].min; +} + +uint32_t radio_impl_get_max_frequency(radio_band_t band) +{ + return known_fm_band_plans[bandplan].max; +} + +uint32_t radio_impl_get_frequency_step(radio_band_t band) +{ + uint32_t ret = 0; + + switch (band) { + case BAND_AM: + ret = 1000; // 1 kHz + break; + case BAND_FM: + ret = known_fm_band_plans[bandplan].step; + break; + default: + break; + } + return ret; +} + +void radio_impl_start(void) +{ + if(!present) + return; + + if(!active) { + if(radio_output_start() != 0) + return; + + rtl_fm_start(); + active = true; + } +} + +void radio_impl_stop(void) +{ + if(!present) + return; + + if(active) { + active = false; + radio_output_stop(); + rtl_fm_stop(); + + } +} + +void radio_impl_scan_start(radio_scan_direction_t direction, + radio_scan_callback_t callback, + void *data) +{ + rtl_fm_scan_start(direction == SCAN_FORWARD ? 0 : 1, + callback, + data, + radio_impl_get_frequency_step(BAND_FM), + radio_impl_get_min_frequency(BAND_FM), + radio_impl_get_max_frequency(BAND_FM)); +} + +void radio_impl_scan_stop(void) +{ + rtl_fm_scan_stop(); +} + +radio_stereo_mode_t radio_impl_get_stereo_mode(void) +{ + return STEREO; +} + +void radio_impl_set_stereo_mode(radio_stereo_mode_t mode) +{ + // We only support stereo, so do nothing +} diff --git a/binding/radio_output.c b/binding/radio_output.c new file mode 100644 index 0000000..a49687b --- /dev/null +++ b/binding/radio_output.c @@ -0,0 +1,294 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#include "radio_output.h" +#include "rtl_fm.h" + +static pa_threaded_mainloop *mainloop; +static pa_context *context; +static pa_stream *stream; + +static unsigned int extra; +static int16_t extra_buf[1]; +static unsigned char *output_buf; + +static void pa_context_state_cb(pa_context *c, void *data) { + pa_operation *o; + + assert(c); + switch (pa_context_get_state(c)) { + case PA_CONTEXT_CONNECTING: + case PA_CONTEXT_AUTHORIZING: + case PA_CONTEXT_SETTING_NAME: + case PA_CONTEXT_READY: + break; + case PA_CONTEXT_TERMINATED: + pa_threaded_mainloop_stop(mainloop); + break; + case PA_CONTEXT_FAILED: + default: + fprintf(stderr, "PA connection failed: %s\n", + pa_strerror(pa_context_errno(c))); + pa_threaded_mainloop_stop(mainloop); + break; + } + pa_threaded_mainloop_signal(mainloop, 0); +} + +int radio_output_open(void) +{ + pa_context *c; + pa_mainloop_api *mapi; + char *client; + + if(context) + return 0; + + if (!(mainloop = pa_threaded_mainloop_new())) { + fprintf(stderr, "pa_mainloop_new() failed.\n"); + return -1; + } + + pa_threaded_mainloop_set_name(mainloop, "pa_mainloop"); + mapi = pa_threaded_mainloop_get_api(mainloop); + + client = pa_xstrdup("radio"); + if (!(c = pa_context_new(mapi, client))) { + fprintf(stderr, "pa_context_new() failed.\n"); + goto exit; + } + + pa_context_set_state_callback(c, pa_context_state_cb, NULL); + if (pa_context_connect(c, NULL, 0, NULL) < 0) { + fprintf(stderr, "pa_context_connect(): %s", pa_strerror(pa_context_errno(c))); + goto exit; + } + + if (pa_threaded_mainloop_start(mainloop) < 0) { + fprintf(stderr, "pa_mainloop_run() failed.\n"); + goto exit; + } + + context = c; + + extra = 0; + output_buf = malloc(sizeof(unsigned char) * RTL_FM_MAXIMUM_BUF_LENGTH); + + return 0; + +exit: + if (c) + pa_context_unref(c); + + if (mainloop) + pa_threaded_mainloop_free(mainloop); + + pa_xfree(client); + return -1; +} + +int radio_output_start(void) +{ + int error = 0; + pa_sample_spec *spec; + + if(stream) + return 0; + + if(!context) { + error = radio_output_open(); + if(error != 0) + return error; + } + + while(pa_context_get_state(context) != PA_CONTEXT_READY) + pa_threaded_mainloop_wait(mainloop); + + spec = (pa_sample_spec*) calloc(1, sizeof(pa_sample_spec)); + spec->format = PA_SAMPLE_S16LE; + spec->rate = 24000; + spec->channels = 2; + if (!pa_sample_spec_valid(spec)) { + fprintf(stderr, "%s\n", + pa_strerror(pa_context_errno(context))); + return -1; + } + + pa_threaded_mainloop_lock(mainloop); + pa_proplist *props = pa_proplist_new(); + pa_proplist_sets(props, PA_PROP_MEDIA_ROLE, "radio"); + stream = pa_stream_new_with_proplist(context, "radio-output", spec, 0, props); + if(!stream) { + fprintf(stderr, "Error creating stream %s\n", + pa_strerror(pa_context_errno(context))); + pa_proplist_free(props); + free(spec); + pa_threaded_mainloop_unlock(mainloop); + return -1; + } + pa_proplist_free(props); + free(spec); + + if(pa_stream_connect_playback(stream, + NULL, + NULL, + (pa_stream_flags_t) 0, + NULL, + NULL) < 0) { + fprintf(stderr, "Error connecting to PulseAudio : %s\n", + pa_strerror(pa_context_errno(context))); + pa_stream_unref(stream); + stream = NULL; + pa_threaded_mainloop_unlock(mainloop); + return -1; + } + + pa_threaded_mainloop_unlock(mainloop); + + while(pa_stream_get_state(stream) != PA_STREAM_READY) + pa_threaded_mainloop_wait(mainloop); + + return error; +} + +void radio_output_stop(void) +{ + if(stream) { + pa_threaded_mainloop_lock(mainloop); + + pa_stream_set_state_callback(stream, 0, 0); + pa_stream_set_write_callback(stream, 0, 0); + pa_stream_set_underflow_callback(stream, 0, 0); + pa_stream_set_overflow_callback(stream, 0, 0); + pa_stream_set_latency_update_callback(stream, 0, 0); + + pa_operation *o = pa_stream_flush(stream, NULL, NULL); + if(o) + pa_operation_unref(o); + + pa_stream_disconnect(stream); + pa_stream_unref(stream); + stream = NULL; + + pa_threaded_mainloop_unlock(mainloop); + } +} + +void radio_output_suspend(int state) +{ + if(stream) { + pa_stream_cork(stream, state, NULL, NULL); + } +} + +void radio_output_close(void) +{ + radio_output_stop(); + + if(context) { + pa_context_disconnect(context); + pa_context_unref(context); + context = NULL; + } + + if(mainloop) { + pa_threaded_mainloop_stop(mainloop); + pa_threaded_mainloop_free(mainloop); + mainloop = NULL; + } + + free(output_buf); + output_buf = NULL; +} + +int radio_output_write(void *buf, int len) +{ + int rc = -EINVAL; + int error; + size_t n = len; + size_t avail; + int samples = len / 2; + void *p; + + if(!stream) { + return -1; + } + + if(!buf) { + fprintf(stderr, "Error: buf == null!\n"); + return rc; + } + + pa_threaded_mainloop_lock(mainloop); + + avail = pa_stream_writable_size(stream); + if(avail < n) { + /* + * NOTE: Definitely room for improvement here,but for now just + * check for the no space case that happens when the + * stream is corked. + */ + if(!avail) { + rc = 0; + goto exit; + } + } + + /* + * Handle the rtl_fm code giving us an odd number of samples, which + * PA does not like. This extra buffer copying approach is not + * particularly efficient, but works for now. It looks feasible to + * hack in something in the demod and output thread routines in + * rtl_fm.c to handle it there if more performance is required. + */ + p = output_buf; + if(extra) { + memcpy(output_buf, extra_buf, sizeof(int16_t)); + if((extra + samples) % 2) { + // We still have an extra sample, n remains the same, store the extra + memcpy(output_buf + sizeof(int16_t), buf, n - 2); + memcpy(extra_buf, ((unsigned char*) buf) + n - 2, sizeof(int16_t)); + } else { + // We have an even number of samples, no extra + memcpy(output_buf + sizeof(int16_t), buf, n); + n += 2; + extra = 0; + } + } else if(samples % 2) { + // We have an extra sample, store it, and decrease n + n -= 2; + memcpy(output_buf + sizeof(int16_t), buf, n); + memcpy(extra_buf, ((unsigned char*) buf) + n, sizeof(int16_t)); + extra = 1; + } else { + p = buf; + } + + if ((rc = pa_stream_write(stream, p, n, NULL, 0, PA_SEEK_RELATIVE)) < 0) { + fprintf(stderr, "Error writing %d bytes to PulseAudio : %s\n", + n, pa_strerror(pa_context_errno(context))); + } +exit: + pa_threaded_mainloop_unlock(mainloop); + + return rc; +} diff --git a/binding/radio_output.h b/binding/radio_output.h new file mode 100644 index 0000000..2192811 --- /dev/null +++ b/binding/radio_output.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _RADIO_OUTPUT_H +#define _RADIO_OUTPUT_H + +int radio_output_open(void); + +int radio_output_start(void); + +void radio_output_stop(void); + +void radio_output_close(void); + +int radio_output_write(void *buf, int len); + +#endif /* _RADIO_OUTPUT_H */ + diff --git a/binding/rtl_fm.c b/binding/rtl_fm.c new file mode 100644 index 0000000..1c6a6b2 --- /dev/null +++ b/binding/rtl_fm.c @@ -0,0 +1,1267 @@ +/* + * rtl-sdr, turns your Realtek RTL2832 based DVB dongle into a SDR receiver + * Copyright (C) 2012 by Steve Markgraf + * Copyright (C) 2012 by Hoernchen + * Copyright (C) 2012 by Kyle Keen + * Copyright (C) 2013 by Elias Oenal + * Copyright (C) 2016, 2017 Konsulko Group + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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 this program. If not, see . + */ + +/* + * Note that this version replaces the standalone main() with separate + * init/start/stop API calls to allow building into another application. + * Other than removing the separate controller thread and adding an output + * function callback, other changes have been kept to a minimum to + * potentially allow using other rtl_fm features by modifying rtl_fm_init. + * + * December 2016, Scott Murray + */ + +/* + * written because people could not do real time + * FM demod on Atom hardware with GNU radio + * based on rtl_sdr.c and rtl_tcp.c + * + * lots of locks, but that is okay + * (no many-to-many locks) + * + * todo: + * sanity checks + * scale squelch to other input parameters + * test all the demodulations + * pad output on hop + * frequency ranges could be stored better + * scaled AM demod amplification + * auto-hop after time limit + * peak detector to tune onto stronger signals + * fifo for active hop frequency + * clips + * noise squelch + * merge stereo patch + * merge soft agc patch + * merge udp patch + * testmode to detect overruns + * watchdog to reset bad dongle + * fix oversampling + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "rtl-sdr.h" +#include "rtl_fm.h" +#include "convenience/convenience.h" + +#define DEFAULT_SAMPLE_RATE 24000 +#define DEFAULT_BUF_LENGTH RTL_FM_DEFAULT_BUF_LENGTH +#define MAXIMUM_OVERSAMPLE RTL_FM_MAXIMUM_OVERSAMPLE +#define MAXIMUM_BUF_LENGTH RTL_FM_MAXIMUM_BUF_LENGTH +#define AUTO_GAIN -100 +#define BUFFER_DUMP 4096 + +#define FREQUENCIES_LIMIT 1000 + +#define DEFAULT_SQUELCH_LEVEL 140 +#define DEFAULT_CONSEQ_SQUELCH 10 + +static volatile int do_exit = 0; +static int lcm_post[17] = {1,1,1,3,1,5,3,7,1,9,5,11,3,13,7,15,1}; +static int ACTUAL_BUF_LENGTH; + +static int *atan_lut = NULL; +static int atan_lut_size = 131072; /* 512 KB */ +static int atan_lut_coef = 8; + +struct dongle_state +{ + int exit_flag; + pthread_t thread; + rtlsdr_dev_t *dev; + int dev_index; + uint32_t freq; + uint32_t rate; + int gain; + uint16_t buf16[MAXIMUM_BUF_LENGTH]; + uint32_t buf_len; + int ppm_error; + int offset_tuning; + int direct_sampling; + int mute; + struct demod_state *demod_target; +}; + +struct demod_state +{ + int exit_flag; + pthread_t thread; + int16_t lowpassed[MAXIMUM_BUF_LENGTH]; + int lp_len; + int16_t lp_i_hist[10][6]; + int16_t lp_q_hist[10][6]; + int16_t result[MAXIMUM_BUF_LENGTH]; + int16_t droop_i_hist[9]; + int16_t droop_q_hist[9]; + int result_len; + int rate_in; + int rate_out; + int rate_out2; + int now_r, now_j; + int pre_r, pre_j; + int prev_index; + int downsample; /* min 1, max 256 */ + int post_downsample; + int output_scale; + int squelch_level, conseq_squelch, squelch_hits, terminate_on_squelch; + int downsample_passes; + int comp_fir_size; + int custom_atan; + int deemph, deemph_a; + int now_lpr; + int prev_lpr_index; + int dc_block, dc_avg; + void (*mode_demod)(struct demod_state*); + pthread_rwlock_t rw; + pthread_cond_t ready; + pthread_mutex_t ready_m; + struct output_state *output_target; +}; + +struct output_state +{ + int exit_flag; + pthread_t thread; + rtl_fm_output_fn_t output_fn; + void *output_fn_data; + int16_t result[MAXIMUM_BUF_LENGTH]; + int result_len; + int rate; + pthread_rwlock_t rw; + pthread_cond_t ready; + pthread_mutex_t ready_m; +}; + +struct controller_state +{ + int exit_flag; + pthread_t thread; + uint32_t freqs[FREQUENCIES_LIMIT]; + int freq_len; + int freq_now; + int edge; + int wb_mode; + pthread_cond_t hop; + pthread_mutex_t hop_m; + + void (*freq_callback)(uint32_t, void*); + void *freq_callback_data; + + int scanning; + int scan_direction; + void (*scan_callback)(uint32_t, void*); + void *scan_callback_data; + uint32_t scan_step; + uint32_t scan_min; + uint32_t scan_max; + int scan_squelch_level; + int scan_squelch_count; +}; + +// multiple of these, eventually +struct dongle_state dongle; +struct demod_state demod; +struct output_state output; +struct controller_state controller; + +#if 0 +static void sighandler(int signum) +{ + fprintf(stderr, "Signal caught, exiting!\n"); + do_exit = 1; + rtlsdr_cancel_async(dongle.dev); +} +#endif + +/* more cond dumbness */ +#define safe_cond_signal(n, m) pthread_mutex_lock(m); pthread_cond_signal(n); pthread_mutex_unlock(m) +#define safe_cond_wait(n, m) pthread_mutex_lock(m); pthread_cond_wait(n, m); pthread_mutex_unlock(m) + +/* {length, coef, coef, coef} and scaled by 2^15 + for now, only length 9, optimal way to get +85% bandwidth */ +#define CIC_TABLE_MAX 10 +int cic_9_tables[][10] = { + {0,}, + {9, -156, -97, 2798, -15489, 61019, -15489, 2798, -97, -156}, + {9, -128, -568, 5593, -24125, 74126, -24125, 5593, -568, -128}, + {9, -129, -639, 6187, -26281, 77511, -26281, 6187, -639, -129}, + {9, -122, -612, 6082, -26353, 77818, -26353, 6082, -612, -122}, + {9, -120, -602, 6015, -26269, 77757, -26269, 6015, -602, -120}, + {9, -120, -582, 5951, -26128, 77542, -26128, 5951, -582, -120}, + {9, -119, -580, 5931, -26094, 77505, -26094, 5931, -580, -119}, + {9, -119, -578, 5921, -26077, 77484, -26077, 5921, -578, -119}, + {9, -119, -577, 5917, -26067, 77473, -26067, 5917, -577, -119}, + {9, -199, -362, 5303, -25505, 77489, -25505, 5303, -362, -199}, +}; + +void rotate_90(unsigned char *buf, uint32_t len) +/* 90 rotation is 1+0j, 0+1j, -1+0j, 0-1j + or [0, 1, -3, 2, -4, -5, 7, -6] */ +{ + uint32_t i; + unsigned char tmp; + for (i=0; ilp_len) { + d->now_r += d->lowpassed[i]; + d->now_j += d->lowpassed[i+1]; + i += 2; + d->prev_index++; + if (d->prev_index < d->downsample) { + continue; + } + d->lowpassed[i2] = d->now_r; // * d->output_scale; + d->lowpassed[i2+1] = d->now_j; // * d->output_scale; + d->prev_index = 0; + d->now_r = 0; + d->now_j = 0; + i2 += 2; + } + d->lp_len = i2; +} + +int low_pass_simple(int16_t *signal2, int len, int step) +// no wrap around, length must be multiple of step +{ + int i, i2, sum; + for(i=0; i < len; i+=step) { + sum = 0; + for(i2=0; i2rate_out; + int slow = s->rate_out2; + while (i < s->result_len) { + s->now_lpr += s->result[i]; + i++; + s->prev_lpr_index += slow; + if (s->prev_lpr_index < fast) { + continue; + } + s->result[i2] = (int16_t)(s->now_lpr / (fast/slow)); + s->prev_lpr_index -= fast; + s->now_lpr = 0; + i2 += 1; + } + s->result_len = i2; +} + +void fifth_order(int16_t *data, int length, int16_t *hist) +/* for half of interleaved data */ +{ + int i; + int16_t a, b, c, d, e, f; + a = hist[1]; + b = hist[2]; + c = hist[3]; + d = hist[4]; + e = hist[5]; + f = data[0]; + /* a downsample should improve resolution, so don't fully shift */ + data[0] = (a + (b+e)*5 + (c+d)*10 + f) >> 4; + for (i=4; i> 4; + } + /* archive */ + hist[0] = a; + hist[1] = b; + hist[2] = c; + hist[3] = d; + hist[4] = e; + hist[5] = f; +} + +void generic_fir(int16_t *data, int length, int *fir, int16_t *hist) +/* Okay, not at all generic. Assumes length 9, fix that eventually. */ +{ + int d, temp, sum; + for (d=0; d> 15 ; + hist[0] = hist[1]; + hist[1] = hist[2]; + hist[2] = hist[3]; + hist[3] = hist[4]; + hist[4] = hist[5]; + hist[5] = hist[6]; + hist[6] = hist[7]; + hist[7] = hist[8]; + hist[8] = temp; + } +} + +/* define our own complex math ops + because ARMv5 has no hardware float */ + +void multiply(int ar, int aj, int br, int bj, int *cr, int *cj) +{ + *cr = ar*br - aj*bj; + *cj = aj*br + ar*bj; +} + +int polar_discriminant(int ar, int aj, int br, int bj) +{ + int cr, cj; + double angle; + multiply(ar, aj, br, -bj, &cr, &cj); + angle = atan2((double)cj, (double)cr); + return (int)(angle / 3.14159 * (1<<14)); +} + +int fast_atan2(int y, int x) +/* pre scaled for int16 */ +{ + int yabs, angle; + int pi4=(1<<12), pi34=3*(1<<12); // note pi = 1<<14 + if (x==0 && y==0) { + return 0; + } + yabs = y; + if (yabs < 0) { + yabs = -yabs; + } + if (x >= 0) { + angle = pi4 - pi4 * (x-yabs) / (x+yabs); + } else { + angle = pi34 - pi4 * (x+yabs) / (yabs-x); + } + if (y < 0) { + return -angle; + } + return angle; +} + +int polar_disc_fast(int ar, int aj, int br, int bj) +{ + int cr, cj; + multiply(ar, aj, br, -bj, &cr, &cj); + return fast_atan2(cj, cr); +} + +int atan_lut_init(void) +{ + int i = 0; + + atan_lut = malloc(atan_lut_size * sizeof(int)); + + for (i = 0; i < atan_lut_size; i++) { + atan_lut[i] = (int) (atan((double) i / (1< 0) + {return 1 << 13;} + if (cr == 0 && cj < 0) + {return -(1 << 13);} + if (cj == 0 && cr > 0) + {return 0;} + if (cj == 0 && cr < 0) + {return 1 << 14;} + } + + /* real range -32768 - 32768 use 64x range -> absolute maximum: 2097152 */ + x = (cj << atan_lut_coef) / cr; + x_abs = abs(x); + + if (x_abs >= atan_lut_size) { + /* we can use linear range, but it is not necessary */ + return (cj > 0) ? 1<<13 : -1<<13; + } + + if (x > 0) { + return (cj > 0) ? atan_lut[x] : atan_lut[x] - (1<<14); + } else { + return (cj > 0) ? (1<<14) - atan_lut[-x] : -atan_lut[-x]; + } + + return 0; +} + +void fm_demod(struct demod_state *fm) +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + pcm = polar_discriminant(lp[0], lp[1], + fm->pre_r, fm->pre_j); + fm->result[0] = (int16_t)pcm; + for (i = 2; i < (fm->lp_len-1); i += 2) { + switch (fm->custom_atan) { + case 0: + pcm = polar_discriminant(lp[i], lp[i+1], + lp[i-2], lp[i-1]); + break; + case 1: + pcm = polar_disc_fast(lp[i], lp[i+1], + lp[i-2], lp[i-1]); + break; + case 2: + pcm = polar_disc_lut(lp[i], lp[i+1], + lp[i-2], lp[i-1]); + break; + } + fm->result[i/2] = (int16_t)pcm; + } + fm->pre_r = lp[fm->lp_len - 2]; + fm->pre_j = lp[fm->lp_len - 1]; + fm->result_len = fm->lp_len/2; +} + +void am_demod(struct demod_state *fm) +// todo, fix this extreme laziness +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + int16_t *r = fm->result; + for (i = 0; i < fm->lp_len; i += 2) { + // hypot uses floats but won't overflow + //r[i/2] = (int16_t)hypot(lp[i], lp[i+1]); + pcm = lp[i] * lp[i]; + pcm += lp[i+1] * lp[i+1]; + r[i/2] = (int16_t)sqrt(pcm) * fm->output_scale; + } + fm->result_len = fm->lp_len/2; + // lowpass? (3khz) highpass? (dc) +} + +void usb_demod(struct demod_state *fm) +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + int16_t *r = fm->result; + for (i = 0; i < fm->lp_len; i += 2) { + pcm = lp[i] + lp[i+1]; + r[i/2] = (int16_t)pcm * fm->output_scale; + } + fm->result_len = fm->lp_len/2; +} + +void lsb_demod(struct demod_state *fm) +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + int16_t *r = fm->result; + for (i = 0; i < fm->lp_len; i += 2) { + pcm = lp[i] - lp[i+1]; + r[i/2] = (int16_t)pcm * fm->output_scale; + } + fm->result_len = fm->lp_len/2; +} + +void raw_demod(struct demod_state *fm) +{ + int i; + for (i = 0; i < fm->lp_len; i++) { + fm->result[i] = (int16_t)fm->lowpassed[i]; + } + fm->result_len = fm->lp_len; +} + +void deemph_filter(struct demod_state *fm) +{ + static int avg; // cheating... + int i, d; + // de-emph IIR + // avg = avg * (1 - alpha) + sample * alpha; + for (i = 0; i < fm->result_len; i++) { + d = fm->result[i] - avg; + if (d > 0) { + avg += (d + fm->deemph_a/2) / fm->deemph_a; + } else { + avg += (d - fm->deemph_a/2) / fm->deemph_a; + } + fm->result[i] = (int16_t)avg; + } +} + +void dc_block_filter(struct demod_state *fm) +{ + int i, avg; + int64_t sum = 0; + for (i=0; i < fm->result_len; i++) { + sum += fm->result[i]; + } + avg = sum / fm->result_len; + avg = (avg + fm->dc_avg * 9) / 10; + for (i=0; i < fm->result_len; i++) { + fm->result[i] -= avg; + } + fm->dc_avg = avg; +} + +int mad(int16_t *samples, int len, int step) +/* mean average deviation */ +{ + int i=0, sum=0, ave=0; + if (len == 0) + {return 0;} + for (i=0; i len2) { + tick -= len2; + i++; + } + if (i >= len1) { + i = len1 - 1; + tick = len2; + } + } +} + +void arbitrary_downsample(int16_t *buf1, int16_t *buf2, int len1, int len2) +/* fractional boxcar lowpass, len1 > len2 */ +{ + int i = 1; + int j = 0; + int tick = 0; + double remainder = 0; + double frac; // use integers... + buf2[0] = 0; + while (j < len2) { + frac = 1.0; + if ((tick + len2) > len1) { + frac = (double)(len1 - tick) / (double)len2;} + buf2[j] += (int16_t)((double)buf1[i] * frac + remainder); + remainder = (double)buf1[i] * (1.0-frac); + tick += len2; + i++; + if (tick > len1) { + j++; + buf2[j] = 0; + tick -= len1; + } + if (i >= len1) { + i = len1 - 1; + tick = len1; + } + } + for (j=0; jdownsample_passes; + if (ds_p) { + for (i=0; i < ds_p; i++) { + fifth_order(d->lowpassed, (d->lp_len >> i), d->lp_i_hist[i]); + fifth_order(d->lowpassed+1, (d->lp_len >> i) - 1, d->lp_q_hist[i]); + } + d->lp_len = d->lp_len >> ds_p; + /* droop compensation */ + if (d->comp_fir_size == 9 && ds_p <= CIC_TABLE_MAX) { + generic_fir(d->lowpassed, d->lp_len, + cic_9_tables[ds_p], d->droop_i_hist); + generic_fir(d->lowpassed+1, d->lp_len-1, + cic_9_tables[ds_p], d->droop_q_hist); + } + } else { + low_pass(d); + } + /* power squelch */ + if (d->squelch_level) { + sr = rms(d->lowpassed, d->lp_len, 1); + if (sr < d->squelch_level) { + d->squelch_hits++; + for (i=0; i< d->lp_len; i++) { + d->lowpassed[i] = 0; + } + } else { + d->squelch_hits = 0; + } + } + d->mode_demod(d); /* lowpassed -> result */ + if (d->mode_demod == &raw_demod) { + return; + } + /* todo, fm noise squelch */ + // use nicer filter here too? + if (d->post_downsample > 1) { + d->result_len = low_pass_simple(d->result, d->result_len, d->post_downsample);} + if (d->deemph) { + deemph_filter(d);} + if (d->dc_block) { + dc_block_filter(d);} + if (d->rate_out2 > 0) { + low_pass_real(d); + //arbitrary_resample(d->result, d->result, d->result_len, d->result_len * d->rate_out2 / d->rate_out); + } +} + +static void rtlsdr_callback(unsigned char *buf, uint32_t len, void *ctx) +{ + int i; + struct dongle_state *s = ctx; + struct demod_state *d = s->demod_target; + + if (do_exit) { + return;} + if (!ctx) { + return;} + if (s->mute) { + for (i=0; imute; i++) { + buf[i] = 127;} + s->mute = 0; + } + if (!s->offset_tuning) { + rotate_90(buf, len);} + for (i=0; i<(int)len; i++) { + s->buf16[i] = (int16_t)buf[i] - 127;} + pthread_rwlock_wrlock(&d->rw); + memcpy(d->lowpassed, s->buf16, 2*len); + d->lp_len = len; + pthread_rwlock_unlock(&d->rw); + safe_cond_signal(&d->ready, &d->ready_m); +} + +static void *dongle_thread_fn(void *arg) +{ + struct dongle_state *s = arg; + fprintf(stderr, "dongle_thread_fn running\n"); + rtlsdr_read_async(s->dev, rtlsdr_callback, s, 0, s->buf_len); + fprintf(stderr, "dongle_thread_fn exited!\n"); + return 0; +} + +static void rtl_fm_scan_callback(void) +{ + struct controller_state *s = &controller; + uint32_t frequency = rtl_fm_get_freq(); + + if(!s->scanning) + return; + + if(!s->scan_direction) { + frequency += s->scan_step; + if(frequency > s->scan_max) + frequency = s->scan_min; + } else { + frequency -= s->scan_step; + if(frequency < s->scan_min) + frequency = s->scan_max; + } + + rtl_fm_set_freq(frequency); +} + +static void rtl_fm_scan_end_callback(void) +{ + struct controller_state *s = &controller; + + if(!s->scanning) + return; + + rtl_fm_scan_stop(); + + if(s->scan_callback) + s->scan_callback(rtl_fm_get_freq(), s->scan_callback_data); +} + +static void *demod_thread_fn(void *arg) +{ + struct demod_state *d = arg; + struct output_state *o = d->output_target; + fprintf(stderr, "demod_thread_fn running\n"); + while (!do_exit) { + safe_cond_wait(&d->ready, &d->ready_m); + pthread_rwlock_wrlock(&d->rw); + full_demod(d); + pthread_rwlock_unlock(&d->rw); + if (d->exit_flag) { + do_exit = 1; + } + if (d->squelch_level) { + if(d->squelch_hits > d->conseq_squelch) { + d->squelch_hits = d->conseq_squelch + 1; /* hair trigger */ + //safe_cond_signal(&controller.hop, &controller.hop_m); + rtl_fm_scan_callback(); + continue; + } else if(!d->squelch_hits) { + rtl_fm_scan_end_callback(); + } + } + pthread_rwlock_wrlock(&o->rw); + memcpy(o->result, d->result, 2*d->result_len); + o->result_len = d->result_len; + pthread_rwlock_unlock(&o->rw); + safe_cond_signal(&o->ready, &o->ready_m); + } + fprintf(stderr, "demod_thread_fn exited!\n"); + return 0; +} + +static void *output_thread_fn(void *arg) +{ + struct output_state *s = arg; + fprintf(stderr, "output_thread_fn running\n"); + while (!do_exit) { + // use timedwait and pad out under runs + safe_cond_wait(&s->ready, &s->ready_m); + pthread_rwlock_rdlock(&s->rw); + if(s->output_fn) { + s->output_fn(s->result, s->result_len, s->output_fn_data); + } + pthread_rwlock_unlock(&s->rw); + } + fprintf(stderr, "output_thread_fn exited!\n"); + return 0; +} + +static void optimal_settings(int freq, int rate) +{ + // giant ball of hacks + // seems unable to do a single pass, 2:1 + int capture_freq, capture_rate; + struct dongle_state *d = &dongle; + struct demod_state *dm = &demod; + struct controller_state *cs = &controller; + dm->downsample = (1000000 / dm->rate_in) + 1; + if (dm->downsample_passes) { + dm->downsample_passes = (int)log2(dm->downsample) + 1; + dm->downsample = 1 << dm->downsample_passes; + } + capture_freq = freq; + capture_rate = dm->downsample * dm->rate_in; + if (!d->offset_tuning) { + capture_freq = freq + capture_rate/4;} + capture_freq += cs->edge * dm->rate_in / 2; + dm->output_scale = (1<<15) / (128 * dm->downsample); + if (dm->output_scale < 1) { + dm->output_scale = 1;} + if (dm->mode_demod == &fm_demod) { + dm->output_scale = 1;} + d->freq = (uint32_t)capture_freq; + d->rate = (uint32_t)capture_rate; +} + + +void frequency_range(struct controller_state *s, char *arg) +{ + char *start, *stop, *step; + int i; + start = arg; + stop = strchr(start, ':') + 1; + stop[-1] = '\0'; + step = strchr(stop, ':') + 1; + step[-1] = '\0'; + for(i=(int)atofs(start); i<=(int)atofs(stop); i+=(int)atofs(step)) + { + s->freqs[s->freq_len] = (uint32_t)i; + s->freq_len++; + if (s->freq_len >= FREQUENCIES_LIMIT) { + break;} + } + stop[-1] = ':'; + step[-1] = ':'; +} + +void dongle_init(struct dongle_state *s) +{ + s->rate = DEFAULT_SAMPLE_RATE; + s->gain = AUTO_GAIN; // tenths of a dB + s->mute = 0; + s->direct_sampling = 0; + s->offset_tuning = 0; + s->demod_target = &demod; +} + +void demod_init(struct demod_state *s) +{ + s->rate_in = DEFAULT_SAMPLE_RATE; + s->rate_out = DEFAULT_SAMPLE_RATE; + s->squelch_level = 0; + s->conseq_squelch = DEFAULT_CONSEQ_SQUELCH; + s->terminate_on_squelch = 0; + s->squelch_hits = DEFAULT_CONSEQ_SQUELCH + 1; + s->downsample_passes = 0; + s->comp_fir_size = 0; + s->prev_index = 0; + s->post_downsample = 1; // once this works, default = 4 + s->custom_atan = 0; + s->deemph = 0; + s->rate_out2 = -1; // flag for disabled + s->mode_demod = &fm_demod; + s->pre_j = s->pre_r = s->now_r = s->now_j = 0; + s->prev_lpr_index = 0; + s->deemph_a = 0; + s->now_lpr = 0; + s->dc_block = 0; + s->dc_avg = 0; + pthread_rwlock_init(&s->rw, NULL); + pthread_cond_init(&s->ready, NULL); + pthread_mutex_init(&s->ready_m, NULL); + s->output_target = &output; +} + +void demod_cleanup(struct demod_state *s) +{ + pthread_rwlock_destroy(&s->rw); + pthread_cond_destroy(&s->ready); + pthread_mutex_destroy(&s->ready_m); +} + +void output_init(struct output_state *s) +{ + s->rate = DEFAULT_SAMPLE_RATE; + s->output_fn = NULL; + s->output_fn_data = NULL; + pthread_rwlock_init(&s->rw, NULL); + pthread_cond_init(&s->ready, NULL); + pthread_mutex_init(&s->ready_m, NULL); +} + +void output_cleanup(struct output_state *s) +{ + pthread_rwlock_destroy(&s->rw); + pthread_cond_destroy(&s->ready); + pthread_mutex_destroy(&s->ready_m); +} + +void controller_init(struct controller_state *s) +{ + s->freqs[0] = 100000000; + s->freq_len = 0; + s->edge = 0; + s->wb_mode = 0; + pthread_cond_init(&s->hop, NULL); + pthread_mutex_init(&s->hop_m, NULL); +} + +void controller_cleanup(struct controller_state *s) +{ + pthread_cond_destroy(&s->hop); + pthread_mutex_destroy(&s->hop_m); +} + +void sanity_checks(void) +{ + if (controller.freq_len == 0) { + fprintf(stderr, "Please specify a frequency.\n"); + exit(1); + } + + if (controller.freq_len >= FREQUENCIES_LIMIT) { + fprintf(stderr, "Too many channels, maximum %i.\n", FREQUENCIES_LIMIT); + exit(1); + } + + if (controller.freq_len > 1 && demod.squelch_level == 0) { + fprintf(stderr, "Please specify a squelch level. Required for scanning multiple frequencies.\n"); + exit(1); + } + +} + +int rtl_fm_init(uint32_t freq, + uint32_t sample_rate, + uint32_t resample_rate, + rtl_fm_output_fn_t output_fn, + void *output_fn_data) +{ + int r = 0; + + dongle_init(&dongle); + demod_init(&demod); + output_init(&output); + controller_init(&controller); + + /* + * Simulate the effects of command line arguments: + * + * -W wbfm -s -r + */ + + /* Set initial frequency */ + controller.freqs[0] = freq; + controller.freq_len++; + + /* Set mode to wbfm */ + controller.wb_mode = 1; + demod.mode_demod = &fm_demod; + demod.rate_in = 170000; + demod.rate_out = 170000; + demod.rate_out2 = 32000; + demod.custom_atan = 1; + //demod.post_downsample = 4; + demod.deemph = 1; + controller.scan_squelch_count = DEFAULT_CONSEQ_SQUELCH; + controller.scan_squelch_level = DEFAULT_SQUELCH_LEVEL; + demod.squelch_level = 0; + + /* Adjust frequency for wb mode */ + controller.freqs[0] += 16000; + + /* Set sample rate */ + demod.rate_in = sample_rate; + demod.rate_out = sample_rate; + + /* Set resample rate */ + output.rate = (int) resample_rate; + demod.rate_out2 = (int) resample_rate; + + /* Set output function pointer */ + if(output_fn) { + output.output_fn = output_fn; + output.output_fn_data = output_fn_data; + } + + /* quadruple sample_rate to limit to Δθ to ±π/2 */ + demod.rate_in *= demod.post_downsample; + + if (!output.rate) { + output.rate = demod.rate_out; + } + + sanity_checks(); + + if (controller.freq_len > 1) { + demod.terminate_on_squelch = 0; + } + + ACTUAL_BUF_LENGTH = lcm_post[demod.post_downsample] * DEFAULT_BUF_LENGTH; + + dongle.dev_index = verbose_device_search("0"); + if (dongle.dev_index < 0) { + return -1; + } + + r = rtlsdr_open(&dongle.dev, (uint32_t)dongle.dev_index); + if (r < 0) { + fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dongle.dev_index); + return r; + } + + if (demod.deemph) { + demod.deemph_a = (int)round(1.0/((1.0-exp(-1.0/(demod.rate_out * 75e-6))))); + } + + /* Set the tuner gain */ + if (dongle.gain == AUTO_GAIN) { + verbose_auto_gain(dongle.dev); + } else { + dongle.gain = nearest_gain(dongle.dev, dongle.gain); + verbose_gain_set(dongle.dev, dongle.gain); + } + + verbose_ppm_set(dongle.dev, dongle.ppm_error); + + //r = rtlsdr_set_testmode(dongle.dev, 1); + + return r; +} + +void rtl_fm_start(void) +{ + struct controller_state *s = &controller; + + /* + * A bunch of the following is pulled from the controller_thread_fn, + * which has been removed. + */ + + /* Reset endpoint before we start reading from it (mandatory) */ + verbose_reset_buffer(dongle.dev); + + /* set up primary channel */ + optimal_settings(s->freqs[0], demod.rate_in); + if (dongle.direct_sampling) { + verbose_direct_sampling(dongle.dev, 1);} + if (dongle.offset_tuning) { + verbose_offset_tuning(dongle.dev);} + + /* Set the frequency */ + verbose_set_frequency(dongle.dev, dongle.freq); + fprintf(stderr, "Oversampling input by: %ix.\n", demod.downsample); + fprintf(stderr, "Oversampling output by: %ix.\n", demod.post_downsample); + fprintf(stderr, "Buffer size: %0.2fms\n", + 1000 * 0.5 * (float)ACTUAL_BUF_LENGTH / (float)dongle.rate); + + /* Set the sample rate */ + verbose_set_sample_rate(dongle.dev, dongle.rate); + fprintf(stderr, "Output at %u Hz.\n", demod.rate_in/demod.post_downsample); + usleep(100000); + + rtl_fm_scan_stop(); + + do_exit = 0; + pthread_create(&output.thread, NULL, output_thread_fn, (void *)(&output)); + pthread_create(&demod.thread, NULL, demod_thread_fn, (void *)(&demod)); + pthread_create(&dongle.thread, NULL, dongle_thread_fn, (void *)(&dongle)); +} + +void rtl_fm_set_freq(uint32_t freq) +{ + struct controller_state *s = &controller; + + if(s->freqs[0] == freq) + return; + + s->freqs[0] = freq; + s->freq_len = 1; + + if (s->wb_mode) { + s->freqs[0] += 16000; + } + + optimal_settings(s->freqs[0], demod.rate_in); + if (dongle.offset_tuning) { + verbose_offset_tuning(dongle.dev); + } + rtlsdr_set_center_freq(dongle.dev, dongle.freq); + + // It does not look like refreshing the sample rate is desirable + // (e.g. the scanning code in the removed controller thread function + // did not do it), and behavior seemed a bit less robust with it + // present. However, I am leaving this here as a reminder to revisit + // via some more testing. + //rtlsdr_set_sample_rate(dongle.dev, dongle.rate); + + // This triggers a mute during the frequency change + dongle.mute = BUFFER_DUMP; + + if(s->freq_callback) + s->freq_callback(freq, s->freq_callback_data); +} + +void rtl_fm_set_freq_callback(void (*callback)(uint32_t, void *), + void *data) +{ + struct controller_state *s = &controller; + + s->freq_callback = callback; + s->freq_callback_data = data; +} + +uint32_t rtl_fm_get_freq(void) +{ + struct controller_state *s = &controller; + uint32_t frequency = s->freqs[0]; + + if (s->wb_mode) + frequency -= 16000; + + return frequency; +} + +void rtl_fm_stop(void) +{ + rtl_fm_scan_stop(); + + rtlsdr_cancel_async(dongle.dev); + do_exit = 1; + pthread_join(dongle.thread, NULL); + safe_cond_signal(&demod.ready, &demod.ready_m); + pthread_join(demod.thread, NULL); + safe_cond_signal(&output.ready, &output.ready_m); + pthread_join(output.thread, NULL); +} + +void rtl_fm_scan_start(int direction, + void (*callback)(uint32_t, void *), + void *data, + uint32_t step, + uint32_t min, + uint32_t max) +{ + struct controller_state *s = &controller; + struct demod_state *dm = &demod; + uint32_t frequency = rtl_fm_get_freq(); + + if(s->scanning && s->scan_direction == direction) + return; + + s->scanning = 1; + s->scan_direction = direction; + s->scan_callback = callback; + s->scan_callback_data = data; + s->scan_step = step; + s->scan_min = min; + s->scan_max = max; + + /* Start scan by stepping in the desired direction */ + if(!direction) { + frequency += s->scan_step; + if(frequency > s->scan_max) + frequency = s->scan_min; + } else { + frequency -= s->scan_step; + if(frequency < s->scan_min) + frequency = s->scan_max; + } + + rtl_fm_set_freq(frequency); + + dm->conseq_squelch = s->scan_squelch_count; + dm->squelch_hits = s->scan_squelch_count + 1; + dm->squelch_level = s->scan_squelch_level; +} + +void rtl_fm_scan_stop(void) +{ + struct controller_state *s = &controller; + struct demod_state *dm = &demod; + + s->scanning = 0; + + dm->squelch_hits = s->scan_squelch_count + 1; + dm->squelch_level = 0; +} + +void rtl_fm_scan_set_squelch_level(int level) +{ + struct controller_state *s = &controller; + + s->scan_squelch_level = level; +} + +void rtl_fm_scan_set_squelch_limit(int count) +{ + struct controller_state *s = &controller; + + s->scan_squelch_count = count; +} + +void rtl_fm_cleanup(void) +{ + //dongle_cleanup(&dongle); + demod_cleanup(&demod); + output_cleanup(&output); + controller_cleanup(&controller); + + rtlsdr_close(dongle.dev); +} + +// vim: tabstop=8:softtabstop=8:shiftwidth=8:noexpandtab diff --git a/binding/rtl_fm.h b/binding/rtl_fm.h new file mode 100644 index 0000000..f5b2a86 --- /dev/null +++ b/binding/rtl_fm.h @@ -0,0 +1,70 @@ +/* + * rtl-sdr, turns your Realtek RTL2832 based DVB dongle into a SDR receiver + * Copyright (C) 2016, 2017 Konsulko Group + * + * This program 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 2 of the License, or + * (at your option) any later version. + * + * This program 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 this program. If not, see . + */ + +#ifndef RTL_FM_H +#define RTL_FM_H + +#include + +#define RTL_FM_DEFAULT_BUF_LENGTH (1 * 16384) +#define RTL_FM_MAXIMUM_OVERSAMPLE 16 +#define RTL_FM_MAXIMUM_BUF_LENGTH (RTL_FM_MAXIMUM_OVERSAMPLE * RTL_FM_DEFAULT_BUF_LENGTH) + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*rtl_fm_output_fn_t)(int16_t *result, int result_len, void *data); + +int rtl_fm_init(uint32_t freq, + uint32_t sample_rate, + uint32_t resample_rate, + rtl_fm_output_fn_t output_fn, + void *output_fn_data); + +void rtl_fm_start(void); + +void rtl_fm_set_freq(uint32_t freq); + +void rtl_fm_set_freq_callback(void (*callback)(uint32_t, void *), + void *data); + +uint32_t rtl_fm_get_freq(void); + +void rtl_fm_stop(void); + +void rtl_fm_scan_start(int direction, + void (*callback)(uint32_t, void *), + void *data, + uint32_t step, + uint32_t min, + uint32_t max); + +void rtl_fm_scan_stop(void); + +void rtl_fm_scan_set_squelch_level(int level); + +void rtl_fm_scan_set_squelch_limit(int count); + +void rtl_fm_cleanup(void); + +#ifdef __cplusplus +} +#endif + +#endif /* RTL_FM_H */ diff --git a/convenience/convenience.c b/convenience/convenience.c deleted file mode 100644 index 517dc4e..0000000 --- a/convenience/convenience.c +++ /dev/null @@ -1,304 +0,0 @@ -/* - * Copyright (C) 2014 by Kyle Keen - * - * This program 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 2 of the License, or - * (at your option) any later version. - * - * This program 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 this program. If not, see . - */ - -/* a collection of user friendly tools - * todo: use strtol for more flexible int parsing - * */ - -#include -#include -#include - -#ifndef _WIN32 -#include -#else -#include -#include -#include -#define _USE_MATH_DEFINES -#endif - -#include - -#include "rtl-sdr.h" - -double atofs(char *s) -/* standard suffixes */ -{ - char last; - int len; - double suff = 1.0; - len = strlen(s); - last = s[len-1]; - s[len-1] = '\0'; - switch (last) { - case 'g': - case 'G': - suff *= 1e3; - case 'm': - case 'M': - suff *= 1e3; - case 'k': - case 'K': - suff *= 1e3; - suff *= atof(s); - s[len-1] = last; - return suff; - } - s[len-1] = last; - return atof(s); -} - -double atoft(char *s) -/* time suffixes, returns seconds */ -{ - char last; - int len; - double suff = 1.0; - len = strlen(s); - last = s[len-1]; - s[len-1] = '\0'; - switch (last) { - case 'h': - case 'H': - suff *= 60; - case 'm': - case 'M': - suff *= 60; - case 's': - case 'S': - suff *= atof(s); - s[len-1] = last; - return suff; - } - s[len-1] = last; - return atof(s); -} - -double atofp(char *s) -/* percent suffixes */ -{ - char last; - int len; - double suff = 1.0; - len = strlen(s); - last = s[len-1]; - s[len-1] = '\0'; - switch (last) { - case '%': - suff *= 0.01; - suff *= atof(s); - s[len-1] = last; - return suff; - } - s[len-1] = last; - return atof(s); -} - -int nearest_gain(rtlsdr_dev_t *dev, int target_gain) -{ - int i, r, err1, err2, count, nearest; - int* gains; - r = rtlsdr_set_tuner_gain_mode(dev, 1); - if (r < 0) { - fprintf(stderr, "WARNING: Failed to enable manual gain.\n"); - return r; - } - count = rtlsdr_get_tuner_gains(dev, NULL); - if (count <= 0) { - return 0; - } - gains = malloc(sizeof(int) * count); - count = rtlsdr_get_tuner_gains(dev, gains); - nearest = gains[0]; - for (i=0; i= 0 && device < device_count) { - fprintf(stderr, "Using device %d: %s\n", - device, rtlsdr_get_device_name((uint32_t)device)); - return device; - } - /* does string exact match a serial */ - for (i = 0; i < device_count; i++) { - rtlsdr_get_device_usb_strings(i, vendor, product, serial); - if (strcmp(s, serial) != 0) { - continue;} - device = i; - fprintf(stderr, "Using device %d: %s\n", - device, rtlsdr_get_device_name((uint32_t)device)); - return device; - } - /* does string prefix match a serial */ - for (i = 0; i < device_count; i++) { - rtlsdr_get_device_usb_strings(i, vendor, product, serial); - if (strncmp(s, serial, strlen(s)) != 0) { - continue;} - device = i; - fprintf(stderr, "Using device %d: %s\n", - device, rtlsdr_get_device_name((uint32_t)device)); - return device; - } - /* does string suffix match a serial */ - for (i = 0; i < device_count; i++) { - rtlsdr_get_device_usb_strings(i, vendor, product, serial); - offset = strlen(serial) - strlen(s); - if (offset < 0) { - continue;} - if (strncmp(s, serial+offset, strlen(s)) != 0) { - continue;} - device = i; - fprintf(stderr, "Using device %d: %s\n", - device, rtlsdr_get_device_name((uint32_t)device)); - return device; - } - fprintf(stderr, "No matching devices found.\n"); - return -1; -} - -// vim: tabstop=8:softtabstop=8:shiftwidth=8:noexpandtab diff --git a/convenience/convenience.h b/convenience/convenience.h deleted file mode 100644 index 1faa2af..0000000 --- a/convenience/convenience.h +++ /dev/null @@ -1,142 +0,0 @@ -/* - * Copyright (C) 2014 by Kyle Keen - * - * This program 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 2 of the License, or - * (at your option) any later version. - * - * This program 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 this program. If not, see . - */ - -/* a collection of user friendly tools */ - -/*! - * Convert standard suffixes (k, M, G) to double - * - * \param s a string to be parsed - * \return double - */ - -double atofs(char *s); - -/*! - * Convert time suffixes (s, m, h) to double - * - * \param s a string to be parsed - * \return seconds as double - */ - -double atoft(char *s); - -/*! - * Convert percent suffixe (%) to double - * - * \param s a string to be parsed - * \return double - */ - -double atofp(char *s); - -/*! - * Find nearest supported gain - * - * \param dev the device handle given by rtlsdr_open() - * \param target_gain in tenths of a dB - * \return 0 on success - */ - -int nearest_gain(rtlsdr_dev_t *dev, int target_gain); - -/*! - * Set device frequency and report status on stderr - * - * \param dev the device handle given by rtlsdr_open() - * \param frequency in Hz - * \return 0 on success - */ - -int verbose_set_frequency(rtlsdr_dev_t *dev, uint32_t frequency); - -/*! - * Set device sample rate and report status on stderr - * - * \param dev the device handle given by rtlsdr_open() - * \param samp_rate in samples/second - * \return 0 on success - */ - -int verbose_set_sample_rate(rtlsdr_dev_t *dev, uint32_t samp_rate); - -/*! - * Enable or disable the direct sampling mode and report status on stderr - * - * \param dev the device handle given by rtlsdr_open() - * \param on 0 means disabled, 1 I-ADC input enabled, 2 Q-ADC input enabled - * \return 0 on success - */ - -int verbose_direct_sampling(rtlsdr_dev_t *dev, int on); - -/*! - * Enable offset tuning and report status on stderr - * - * \param dev the device handle given by rtlsdr_open() - * \return 0 on success - */ - -int verbose_offset_tuning(rtlsdr_dev_t *dev); - -/*! - * Enable auto gain and report status on stderr - * - * \param dev the device handle given by rtlsdr_open() - * \return 0 on success - */ - -int verbose_auto_gain(rtlsdr_dev_t *dev); - -/*! - * Set tuner gain and report status on stderr - * - * \param dev the device handle given by rtlsdr_open() - * \param gain in tenths of a dB - * \return 0 on success - */ - -int verbose_gain_set(rtlsdr_dev_t *dev, int gain); - -/*! - * Set the frequency correction value for the device and report status on stderr. - * - * \param dev the device handle given by rtlsdr_open() - * \param ppm_error correction value in parts per million (ppm) - * \return 0 on success - */ - -int verbose_ppm_set(rtlsdr_dev_t *dev, int ppm_error); - -/*! - * Reset buffer - * - * \param dev the device handle given by rtlsdr_open() - * \return 0 on success - */ - -int verbose_reset_buffer(rtlsdr_dev_t *dev); - -/*! - * Find the closest matching device. - * - * \param s a string to be parsed - * \return dev_index int, -1 on error - */ - -int verbose_device_search(char *s); - diff --git a/export.map b/export.map deleted file mode 100644 index 52c1b4a..0000000 --- a/export.map +++ /dev/null @@ -1 +0,0 @@ -{ global: afbBindingV1*; local: *; }; diff --git a/package/config.xml b/package/config.xml new file mode 100644 index 0000000..13e54dc --- /dev/null +++ b/package/config.xml @@ -0,0 +1,19 @@ + + + agl-service-radio + + + This is a demo Radio application + Scott Murray <scott.murray@konsulko.com> + APL 2.0 + + + + + + + + + + + diff --git a/package/icon.svg b/package/icon.svg new file mode 100644 index 0000000..b49b495 --- /dev/null +++ b/package/icon.svg @@ -0,0 +1,14329 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + HVAC + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + HVAC + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + NAVIGATION + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + NAVIGATION + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + PHONE + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + PHONE + + + + + + + + + + + + + + + + + + + + + + RADIO + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + RADIO + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + MULTIMEDIA + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + MULTIMEDIA + + + + + + + + + + + + + + + + + + + + + + + + + + + CONNECTIVITY + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CONNECTIVITY + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + DASHBOARD + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + DASHBOARD + + + + + + + + + + + + + + + + + + + + + + SETTINGS + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + SETTINGS + + + + + + + + + + + + + + + + + + + + + + + + + eJzsveluHcmVLvoE8Q77/mjAddDazIiMHMK30cCe2KcOPMFl93HfxoFAS6wqHkuiWqLsdj/9/b4V +Q8aQm6RKNchuMsApdw6RMazxW2v9w//zm6+e7V7e/vH6Wb/tNuof/uHw7vrq7vbdzzdydPPlq1cf +3t+946Gf/faLjZ62HU7afTk/Dyf+6/W79ze3b36+MXrbyYeXvPpnu9dXb15ebQ63316/+WLzsy/w +we9u7l5d46P/+csvn+/evv3F1Yc3L769fvf8t1cvb26ff/nm6sXdzZ+vt+///M0XsSO48/HqDheZ +To/PtH5m7Gb4eT9tfvNLnnL15s9X79/f/BdO0GM/9zi2v/3w5uXNm2/2t/+JqzbPTO/QtX5jLD78 +nze/vX5fnrHth24Yp27AD9wc589bN099Z8d5GnCp2Y7W2d44yx8b08vHxg3a9b2dcNfj7YsPr6/f +3P3m3e2L6/fvD7evbt+9//nm8NerN5tfXn2DT642/3b96tXtXzb7V1cv/pRdcnn75g6n/vb2j7d3 +t89+e/3Nh1dX77LPf3V9/fL65Zmzdl8Ozy9vXl1jwF9f3W10z+HffanN8/2Hm1cvf/Xh9R+vMRXG +9DzcP5eO/f49eoTO8W8enp5/+RpHvrq+u8OY4Cmcwt/+yz5/GRyU9rN/x7NvZDlgYv7PF+G2727f +vr569ydc+2ww2wFjOE745X/yiD/vd9ev377CZMq4644fPvO/8n/CuXgtOe+Znjt+Zscev3o38MZT +F89bhv76zzfXf/n55le3b679yOze3X3lV4a1Xed/+k9+++HV9bvfv7nhmBoecn5ofnn78voVzk/X +X766khGRppef/oTfXb375voOC+r21Yc72QJzfAKG/hdXf73mKtCjzMn0fI+he4MHvblDf5/ffP38 +z37nPP/m7ud68k91z3/99vrN727/Vd7lmZ70dnbD2A1Gu8lurLXbedZuGFxnTDduuu04jrjWmnkz +W/wxSyfHje1Tr/XyM/Rk9+ru+t0bzETszY/36NObl88Dxbh+mT9+kMfz4XHgxvA1hd9Ylr/BQv31 +uxuM48+faeew3Lrer+F/eXfzclnCk9nM/odM1xbzwi+tnekc9vAjjzj5mkY9zHjNxxzxA4llc4f3 +CisJ2/Hwy2x7ddtffoV3wUgcbl9z7b4n1eLiwJZ7dfuN/yz9LZ/g8g9v1b+r3l38x4fbu+v3uNer +640bL755d/Xn640288Xu5c31O3zy/mL3Dh9fHF5cv7x59erq4nT14sPd9cWv7kATri9+HU9TF79P +V1z5U67kbhdXL27eYVt9/er6Py+ulnP89Vdy8xfx5tdypbq49pdeZ5dep0tv/O1v/Dk32Tk36Zw3 +cnt1cevPvfXn3mbn3qZzb31XPvhTP/hTPyynqosP6dyXV998c/3u4iU6eH198QLjffEey/8V3+L9 +9Qtu3Is/fnj16vru4u3VO47A228vcAXZ1x9fYZTeCcnD3V5evLh9+1csv2/vLkACX16T6F34PqTH +bd/c3r28/vpid7r49ftXV++/VenQW3DS1zdvPiwnxd9/vX5z8fpDfVg158Xft+9efn2NW928uebf +r6/ev/jwiv/EE65wPDz9Pz5cv+dLvrz9y5uL6/988erqtfyJ1XXz4uoVLkhXfQ0aePOm7cY34Cav +rl/fgnt/fbf850cCfO3mLd/8/durF9cXOz8Zu7DYwq/TxS3XCASC999eXL+WX7KQMcRy0/iPv6f8 +txz3B1/e/PmGCyQNWhrzf0t/ff3uys/o6cO7W+mp7JTUb/lPbqcuvr7BC4flgSdfvMVzbl9ygchc +L/vsj1fvr1MH5R+cevft7Yf3WCLqYpct0VP2986vjFPq3MkPzZf++Jf5cv0ynfSlP+nX/qRfZ/eL +7/1rf8bv/Rm/z2/ze//RS84UxKKL7Go/Ea+vXrzjege3lNOuXsiG8Fva72h18e2HN99cvfvw+tXV +hzvsQ1DqP128uMJ16ncnIdXD/3r+u/dguwu37T13O715cUvJ6ueb56WsUosu/35RnXBRne85yO/+ +P39z0MN4683v3n24/t1f316rf9ejDtsaYml/geG5/o8PV6/wz3hx8+ZrbI+7v2abjkMiJ4BmQrLE +ePMfpWfNvYe9f3dz9erlzddfX+DdXouEc/H23e3LDy9AGW5wxzvSONx+dhe/fn39zdVGgR1egBBw +H23AJS+u3uKC/wy9cPPF8foVRD+jbVi82HT/df3mm2sIox1PfoXl/Pyrv77+4+2r5xf+d/HmQxAa +MMy/wRyRg6hfvVUifv/m1Qd89C/vbj+8/fLN17fqZ15e/wXIwMZ/tpEPIXvLMbzfX27f/Qn/fvny ++moRG7dXN2+/uPeWX/3p+u7Ft/VNw9Hvftt/BfEFvfmv65ebX//x/+If3oOiKKYYHOjNN/g/nfPw +7Y7XX+PBoZe41B89vfnz9avbt9fLcX/ew/f7zaurN1iI8XXj6ILZ/uYKU7HckCde3/3h4TtCLHiX +dUT+jb8f0R8IRW+vRUOqp+LBE7KPHvGgq7tvoaeAWL9P9/b/Ln3nOPhjD9/vcAUOIWz15sVm/+7D ++283v7u9fZXuvfJ5ek7+mXzEKx+xYl9QAHu39rTyo/SgcPgze8Zv5II3v37j56R9UjihfhJUF3/N +Z/qsdM3ac/Dh38ozPMm+ef96mfrsyG/IUl68uv7qrxAfH0NxwgBDYgDRO7PJ7z3nq79cgSb/4uaP +925LviS440us0K8+3NxdLzvx9vVb2kY2X3179fZa3iCe+VW64SA6XMaRnj1TZrN/k/GrfyFPhFzx +883PfnX9l038d+O7t6EUvTFfqPs+BAvETV9C5fknNfehmaLprJX/6bnzbbqUdkI7pnZQ0wFtX7RD +avtpl5qTNqcWv8ayKfxYDg7SbNZ6NBOaTq3zbbys2mk8Kf4Yj9IOaPtxr/5ZdRiLgz2Yg95f7k/7 +w363d/sZvR/2dt/vzb7bXe5Ou8Nuv9vtZvR/3Nldv9Pu0h3dwe2gp85udIOzrnd6vpxP80HN+3k3 +z3i5cbYyjJ0MFkdhlpdi97V06yg9ceMMZXwY+9GMeuyG03AcDsN+cMOM9x7VMAz9YAZtL+0J7WD3 +dmdnDMNoB9tbSD79ZX/qj/2h3/UO0zr2tu9703fm0pzMwezNzjgM1WgGY41RRptOX+qTxntrvI2e +w1jgkb7tirYv2qFox6KdyqaGy7yNXdF00UzR+qLZ2JT8GopWf5UraS6aKxqmU/FHaHvfMBb/pC4f +/jp9TFMrB4+f0hR+HD6x7fOmyn/lEEdiusS+Jz3osZwHDOKExe2wxPfzYT5ixV+6zmlnsAMsls6I +/U0Tzs7tsUOO7uQud91O7wz2jcViGhW20bxz2FB7bKwjttflvttrbLYem27ABEzYgg5bcY8NecS2 +vDx0B41N2mOrDti802E+uMPusD8cDsfDSR0uj91RH82xP1oswhEkaT664+64Px6Ox+PpeHnqTvpk +Tj22zwA6MJ3mkzvtTvvT4XQ8nU6Xl92lvjSX/aXlKlWgcHirS3QMg4SrLy8xEnbzD8/30LNUt7Wm +wwp10yDjIVa6beeMBQ0YsOu6fvDHrHZjN82216BWw4AjLv5jXYcPNxo0WW/GzdBtdNfxCV+pf3j+ +Az5h/x79Bylx0zjOnSFF8nfiXumGbhyNc3iMHOv9PeIDaPrbWjd3vTN6wG4ytObHu2e9/4Huj77v +j4lhRja3ziV//+bN1WvoQd9EZjgNYI9rRwu+qIUP+pXu17pvc1jzXPV7Wfl+7WP1x4Zd0MlOiA07 +QmFT+GZTG1aaLX7b4rfNf6vsRo9p8fEmtaV/0luV/bPSltdr2qn6LzS1/Fm0Y9MOK23fHlNy+GPb +7nxTxb/uTLv/a8qbKv/9xIZ1r+bx+21/wzcUHtRptO/xS32fN3u64dMN//vd0EvJJ4hIDiqWhTZx +giy1h1w1Q76ykLY6SKl7SGETJDIL6UxD5DxBZNtDdJshxI0Q53qIdV3QvfZ7pyD3DUH50kH5OkJK +dEH5GiBCGihfpzX1S7gVGc2ifw0KnLwXFewSKtgpKKNRDaNOSf3Ra4xeGaMi4BUyqmRWlBGvoHRe +ozmK2rMXxch5zXTgl4WSRjXNDBBzRFWL6hoVNqps5MjoT1JmBqpvChocdThjNVoHXe4kulxsB2kY +D+h2bF5xpwJMzWjq5am93KSXLwXFzzfNBhXwUtTAsh1D24e2k7b8tROVUZoS3TG2XEsbsmards+X +Cr9126CVnm+n1YZPVHbS8ZPawTcV//i+2o93w6DJyyZwcRvILjBhH9AY4feBCzthEJOEt6R0mWEi +7gXI8kpUbRtsFNwMl2KnOGZ7YZa9MBa7QafdcLKgAsteUGEzTGkr2HIn9Jdi1TilXRD3gBMbx7IH +wg5QYQOkld93YgCJq9+v94OYQ5Z17te4t3/lCxxdV2lVxx1VLtuObWVxVmtJ72NTepfaIofnVrbM +llUaR/RQNOubin/ovmmru+vMVxebWv5cWnf5yHZqm1o7+EA73tfU/R9/fPvxbigcU4xmoxgxpqDg +ODFm0JyxF5PGQcwaR/BKtkuxbnRi4dBi5TBi6aCtA00Fy5s3bUaLrNewnLSdtH1ocudj/DpJCyYl +P/pKbCW+RW7Rp2ZDW0x8Y2hTaovS59iU/3XaZW2ftUPWjkUrv5LZTPHHyvprOYZZaX3blBh+zrXh +3tbYmtlUc2j66FZo1+q8Gv4dGgQoxR/fZ/sbvqHsS6wADVJvwYcmcKYdGNURc9+BD/RgZyOYmxPb +90nM2DRQD2JrdmI4PmILXIJqGzClgb4LBda6Ey/IsTCglubTjzCeKm89DcbT2nyaG1AXE2o0ogYz +ajCkelNqr8SaOiRS5IJNdZ+Rn8tgWtUF0RkSrYlURiiMSgQmkpZEVDJqslCRhX7kdCMjFqqiESVV +CNSg2f5rWz3sZVVs53P7c2W7ZG2XNxX+aCznYjk+3+616id6/EktfD3GkfFRXz/eDUubO/UqSEVQ +LCBo9pPYj3UH6VTP1k4a0p71VvKhyyzIPS3i02inbphnA4HUWbGId96mPJotdKjO2R5XQcjKTNg/ +yuO8Nb4bIJhb3NjpfrS8acc/LSVnEAWCYh1OnyGOQq5zk6CBtxCZ80fTxJ6s/mJRxxGT90SbYEzX +4xYawQTRHCInhOnCdP8ZdOZBO3+N3jL6rLf88kogbl/96a9fqPyfxeqPrrp51NA4oK3owU040rsB +OhEUH7wEFCNoVGhbyNk6m1xxpBSTzXuVs5+v4Ooxm+YxHqhWP2bTPGbTPGZZYoUX6Ud7oqzjH/Zp +rZfpR3rex3idfv3u6s031/8YQlOw4qoDuN0QfU3dkLXoE4//0xA0rLRx9dhI0IPiHyLLNG7T6DRN +LtOgT5jCX1p7S5O/VJE5y53Flre0ISkf/Gmb1hfNZJ/466C9UIURC/8PYbeUOxcqxQ== + + + YaXtV9pupblMn5E7e8tIZhaJRhFvEgnwDTGGiCFEzCDHgN9wCcFhxeqBhaxo8PDS6GG17R/ZdnVT +8iPxUwy37cQ8IgvNhv9s0ZaFWP5t1xap9DqItw6i7TEItlGspVAbRFoItEQCeEnWS7FehvXyq5dd +RW6NSy5fdFHDHZtji7bL35RM45n+7/D/D7PaxBgepc1c3SwV0txYUspr+VdYrHLTZNQ+PGDRW7fn +ldY8iC9B2Sna6Ww7nm3FwixWlreL9c26WvvL/xePLc3fQf5S6U+/XJeT5HL/PlM/Q3TYo18nHNPY +UF6Rm7HR9thyJ8j9WlQ5i+1IVAVBTUfoAFpUOVuocpdq6jB2PUZxxIg6jGyuxvlnBvhMlOVL6f5U +HaOTZIKa4dUO/uz9akhOk0kFPWgEzeXYa9zhGMw1O1m2NOuuPG3ROBbFJFdYFkUmV3IyS8WiEeVm +D28ZEZMVXTVDcNbo4K45isMmwuXGBJhbvDaEzOV+mx5arN517lIF980+OHCm5MIhOsHvpe4ADnWC +UtdprY3uwcNp9xwhks/a6Z3eQ4890vqPpaKNMb2xZhDL7WRm48SXcYDSeoIa2PWaTpG+h9wtPhO/ +XHZYMAcumf6yWMAB+UCwYwQUhpb/Pa7y4qEgjn6FVnS1prM5BT7XTN5U+e+5VhM6mnJ7odh8Eb6e +63bdXmyLJ3xowjhbGeUJo7yXUeY4X8o4d951Q0v4EAabRnMnwx3dR95A6ZV9r4XHt4hmdJu1QQXz +fWzTevOsYMZOOGB3adkhEcm1YLkWE0E0DeQmgT4z52VmuilT/+fwPQXFf15T+s/r/DWE7oz6H/fy ++a/vpPK3EMNPAhiWxoj7TgvMj8yuC6zsKHLVTrzBs1C1QWw+PZYFbUGdXHkSS9FB7EaecUe2PapM +qPTCoxE7lCxXGUUvvXkK6b/2oe1Cc1mbVQUrmtab5yf7AKSdxL3kwbTiURJf0jH4kHbiOZoCsHYQ +R5F3EEXHkHcGibNun9w+0dGzOHYWD07up6ndL5mHpPYxHNZbaUHpoLHPBBBSzaGK7rrJmamD7DoP +1PTnXk9DD2qsHZ3Yovt32LliEegnUetdhi3sCO3bmgJvSAifMVNmDpjOQBw/j+6I5trp2UEn7Cyu +Gw1tFSA50zyjc2MPzsNnz5iinmICaNQ4O9+b0XYUeDWuFsMIDRuLbkk04wLORId4JJg/wllu6c08 +b3EsG5/PqFNhlDBbI0bTQeexU9CjwTjAl8GEaQlCh6zBjHEfdHbwKE83FD3gdYWyrc/ahmgyG7cz +FkE+LD9hL/w4dBAVOzy7wzRYrlSjIUD2WL/zDPFSCwp3HJ3t3ITFilXne5BQrbIcOaE51NXKCj/X +AzNvOyhR2Tj8lL3w49CPzBDCIH3dzX6UZzuK1tsNk5t767M7rIy9yTdpN4cnmDm37/xA9/8Ye85X +H94ypOf26zufZmTzrzffvLm+u7v+Qt3zGZ7VJ9sidAb0Qxuo+sxm0G0xaz1fq3eT0VDIcMRy5Wpm +SIF+ohVJ36ihTKPvWNzOcrBzGjbS0lhNEo/kBledbI+fRSdWxmLTdGPTdGPTdGPTdGNlwTbdiObK +ERcbtxmmLc0umS3xs+uaN6n+tN3a4gYGFGHc9Ho7j12/mdx2mvTnM3Dne/hZjJ8b1qzyn1GnPimk +Qq9FVGgauW00covtYBQ/sw0WBBNwUV2wJJwya4JvTtocLAvetmC9fUEJkKoTI4M3MxwlOm8v5oad +eMZnMTpMYngYJYDNSuvFBCFGCJohxApxVEFB2Is5Yudzz4hRYpIYMYnLEKUAV3a4xsNO+YGHnJ7E +LpeC/QRnusfVk1jhaIE7hSA/2oqJJw0Bfgo9m4dRkHI6mIZ3gg5lUJ8WIChNvktAnw7hfF7voM7R +SyQf4/h2elbQKQbRIbRoCwe+plgxBjEvmGSpfNCeSbC9kZ/UQIx8G7EfmGR66xdbhpIn0B4yi4WE +xoWdmBf8T//XPv3cp58HMUDEn0mdUeW/3kYRfp74clSLghpt90U73NNWXBSpJWiTWv5M7T540H1W +INHu1KBXWwGf9Q6FUQIWvR3yEEAlXYCVWA8sCQZJjyw53R+cp1YAJvfG5j0UmqceE5vnfVCd7FQj +1y64FG/dj9iUBZ1yFDJwKVqrR6j4WyaIigpwuRylEnEqESKnQxDgOkolouA8QOWkMnyKzpApOSZl +zu2C3owQLARiFMJGLLZT+080QfvZnXziLa5bkvws8q1fHiPWDdoyvI8J8zH6iOMYCBP2Z7WR/eOg +/IJ6QAz2D0woJX8rmVBOaYWsmA3JBnFOfdd5Obsj+zHkLiN2vI/g61vFoQw1pAqfR+/Ni+Lg5i3Y +z5jhDH7Eh3pRYIYqiH+HAefKnUBUu3kee3rgRquDt7jUlsln7aaZrkwzNFCwC4Hoh31O8LR3hKLw +F3iFSBCmn8ehGyeHu8kRrImpx3roSZUn7Y/ouYcqRSO5Fi2ptgPYQhPU93ZIb8nlcnf859MpGSVa +2TqC0EEUB3nYOExkpPMEQXEa5elmwMTg5py2OZiYaJMSgxxNB1uzSFSYL6rHfbMEx7LPa2iFz6I3 +nybudavyXlcIfAHUvhMrp//Lhb9bkHsJeJ8Sa4yWUasHVSLeV+DuJnyfh70X4HdVY94XC+sK3L1E +pkfD6j7IMtJUEHNcOlSF0BbNO5TmxpU0JnjHqFZ8ScMZZ1F0tvrv4qUWt4/qVoMnPSOT0F8J5j2m +wNk5eJlHiYLuY26QLO/HPqXxmETS7SWSCjtYyYudQjjVQSQZJ4GcgfsJWKJPAVWXKYZkiSKZJa9D +iCJRIahKi7h1CggKH0YSI0hiDIkNMSQ+jsq7tsvIEbyMCoEj9Db1i2U/2PZPKSpqlyJDpmDdH5J9 +Xwf7Pj2QIRRnHyz8c1rXY1qusvjSevLmei8JL57GuASCxzBOrg7SeAIZ0EtrQrTdIXhY6F3pQ8Td +KXhUvD9lEjcKXSgaj/XRdy6PvlMh9ckxeXPHIv7uWCQ/GZIX92wEng/XXnAKAaUQkqAcAkphDAiF +LiAUPD5hTjpSTINyHPYqQWl8VFEJpSGQZsoCiPJkKN6LM0mQXPDh0A+oggNncd9E14133Jwkdmcf +5tLTIU9aMIlpBvdhq+PFlEydDUqWKeYr7NC1uJr19sDX33DE6Od+Q+9jLoJhMvS6bqJiysiYPDom +w7erKkymDpaZqjwJLmu7tZgZ9VFhMyUkfDVaRjWhMiU86Hw0zJkQF9Vg6M/i5+/xl1d+6DVo+z/7 +TFa2yNbhM3W4kKmjyNMRsnOYoA37JBtjCLrwaYd3SixBh6Aen6THnYTsGVGTvaI8iGlpElNTDMbY +i9P5KJN1uQRlqHs14H2hAV8mDdjrv33Sf7MgDRWCxdb033NRGilGIwvPSMqvCrlx+rBqk/abFuGC +rTiFbDldWDR9QlXEJTD7SJs4uYcUyuDna4HkFIicCo8jIC4TYFyjaNFOoFyHAObqIpxLSXDOJOE5 +OwnQOYYQnYjsGj7OqqIeNqt8XM4j9RjDysfkPFJ+0o/fW84jJdN3T86jf1KCsUpBr1ng6ymEvh5F +FvJhrzH4dZ+EIoyVtwqtCxmnYMN1GKYHRIyYdmABuESKkMNe9gkFx33v6VOEuMlvz5tbDNcaGMvU +AKwKY1UGZFbRmGUc5r4IkUpBUou15r7l+qAJ0G+wmM0vy/mTxfTvUsS/b4eshdjSfN4DIiwqZV5p +i4qdb/sMJ3YI6+CUEGOd4PPQPLWOeyfuHO6bXcIFayGwQ4YM9lsl3yhhm/h1MGXsZc5mfDm+y1b0 +qUJYZVirJcvMemvnvkChVmh9D8NPkKdeRAWBPSXgUwt9ysBPNfbJj91jIvnP4n5zpLpfJ/kq2J1p +7kwrskYW1sSsUEEW+FSb/+4/y6MLnDPToJ3VHXHlgteY5r53Y9cNYy94IMZQUf/sO5w2TWIwIRSk +A9MwA4EK3XZuvGRDgxnSbWzL1gYAjNlyw2WohM+rXzJWUF+JhrCmG2ctQKGeC6QDzSBREdTH0JkB +2xjcspcjHej5PGJTgwWPgqOZCxTQuGpayo2xXe/uMQd+Rn3y62kaGLeHPjgGB3G8JZMeLsTdsMdl +3kA29QiGM4/QB71JzhJe06OrrhNsUZWfjqGCNcBKFx1atwd+Jv35NIugXbUIWiJgkkUwaFc6BAUM +CYDsAgA5uvcWsHcfQMhzxl4S2FsVeO8p8LqI917Ey0XAXEDfUcyMgqaImkqMNF7a9PIm2yzpenbB +b5icgMFvx0ACK6LnKElPRAEJmVIPKiVGPYmF6zJkO415TWMK05isdA7sPuYgPQjbPwZl8dLHI3TB +SGpEbO1FGrAhM65Pdeq/fBY5l7WdyApLQl5wGCVGvEUJzaOfK4NllQYY7ZwLueaY0V1cuIqDLTMZ +O2P8mgrw+jl9z8mC2rqRvev4EH5G7/Bl8A5finc4dEQLtF3LyjLBQEx7zhAEGxtszWMScBYxZwpv +LKhdFSTZfSX1xN+HkPYly0sUZSD81rksJCtY0vDqlFcmZplZciktzuE831KehylnwyFR05rMd04S +LNr5WY3fOsECarlIZ5JylIrkWyVxOp/85ffQ2czEvYQzLgtjDOTC/zWpZC6fU2zGslZdWDRzZnx3 +K39ni0sVK81l62z5ndv34xkus/QX1v/cHbDvSpfArmgunbWvPtmFo/vlhudO2J+5PPYmhRqcJGxo +L0LyHIKR7D2o/YjZzxH7ybasAlh/MS/3gs/vAi7/GNK87ZKxeYkgijFEMYpIkD8qQH4WwE8fwon0 +CtYn4nymYJQeAr4nQ/eoCPCp0D1zhe2JSVJjatSY8zSmLI1pSfcqyxa6ZACNPpJBrFC2yKqe5U1P +5DUS3ESD8yzpS9tVzZUt2FKC8hIDwvZhdl0K9opqr01hiSEIMYUcxphYiXlVIcjVh2xMwn6GTItZ +12OiJrPoMkmbUVmw5lCoNEtAh04BHW1IRx7O4bztKw/eGBO2LOLLbAhIjCptQpoFtNllWHcRdXZU +opHHyJH4taugaBGOFls+V2PWwPxVkSvdrrYzUbvLrF5elhE8dahfGeZXh/eNhcFjUGVIXxaf2sSl +rkSjtoHTe7USJb0YrRdT9iJf5KbvPD18sJSrbIUt6yy20vheZgqrQ5FCZ1Uyhrdfh5W2P9N2sanl +z6K5h1tpRyuMirOESq8ZFCNQKwVNB5NitEBH67NTwfCc5wHqk61kLLIA0fTXNWbFmPonJP7JjYsL +mmpI1uS5siSH7GHBMdIXZmQPoQqpA4LlyduZfFigERmdUjr9c6NE/zHmyomzNkrpSU4Pkb1BTFci +pU9BSvdhvkFOl6SDRuIJKaUvEvouCOaX6F0Xsjj1QRSfGc7v5W++6qVIFyYJ2ZNQXu74I8l4SBRu +Q8j7JGxhLxzjUvhIz+TfwcyYgx+95Lqwd//zkH4eKkgkpVuvIkVJ96AyUOTyM/7lLw== + + + WB60Kx60S51xCx6zlDByycYFF2f83/81JVTDFCR1L7sn2U2FhADfh7Ou8ND9LdzQF014RCj+o5NH +9INRj8kfEfAO68GLeejijrrCnAqCBNd3iFdMNUEy57d3fV9mrm8XQAsRWqzjm4vYtia4HQqI9j2i +Wym5qUZwW8Q2L7QtIlsU2PZBVoty2pgkNMhmKgESLoMJ9Rikr10wpM6hIs0QZq8PZWZiaZlTqCKz +9ylS1eidG8mGO2diTy74rIo+Z4Wfg2rlnzPiTyv6ZILPIvQoL/MkgScXdnIhZxFrcimmDyJ5nF3M +r8qhpP+kgofJNSnbjtEXnXkOc99h6U5OAdmlfd9lTuP8O7qO62jseGYUlXZ0TK7Kxx4INYg7Ygpc +l4vu6DmvkMXo/R3EPTHJGuYXVzXXN9Y517sEJ3B8eiVcOHp9BxlSDq1LPDkioHcyFfw+yvdBsmGf +ZM4uybP9t+JUhu94EH97QjsEQjx3PqQ/4tli6oRoS+PmPoJTd2J58CY02g44qzScBaOZEn4c3bIH +by1LTtnaJUt23wWW6xlu45FV6y7ZdS5xv/Nlcbvk6Y9iNgNGPVfJI+IYjKKQ+VFYEkdYsanMIp4c +IcF4z7QNwghf/qhE+vDJIfnWklFkKBDYbVfP+YfyXBJTmrXMHlFq91F5ibEQUfTNAIvymjqZuExC +Q6YcwSWuUuxb3uXoKmzeGLI8e4xeTH3eCW+6FJn9mPKfR7yeR+xNvlJVhO0tydB1SgGdJ4GOaaCX +pOhTBuNKmaBVSopeJIMOEQbCXE4JohYjf6p0IyI835NvJObXUQ+m2DmXNPsMZ1frrP0+dxnN8n2/ +JSwx8xXce1JIITjajtPPiFnJ2qfHwWBWDINnjQSZMUJn6CB1W0yoB9zbxgc15cBqicqfqwSHSyyw +22Kh5SkTf8JOyCg4ZoMbO8cZNk5cITM6YrANHemZBM1p592X2hAmvYZAZ5+KjHH9eci53joIV5vR +bvE+mffrp++KH5FRvEfYTB0oLp1M09DPzO0yTZwCJw/oLKmxNSMTDtDFppldgbWaMH0et189ss0Y +gKuqIOyyW0UE5OfVrU9zgY2rLrCRoPi+cIEZYQJTZNHCnK0wpZ13bzG/DnbJKCl19sGTRXY8Ztmt +SA+typJbeeZrAuP1TPeQpbYag3PpkMGechTJATp9t9glxsIuEa0SNsGccpDTqQkeo1wkBgnVgJxq +i8ROZJ0l7ivHvNkiQ7rAntTZiK+IelvSCrbom12Dvkk2ohLv2eY8X8t2vgreVAV20zUpBQ/3QDbX +8p2f1BqGczXz+blW5UNXj0yR/lArEqd/r+3v8IaLlJgn4JrF/uKTb12K6NaLhEbP404IgpdRtTBO +ClJzkNMPAmEX2bIX/3b0ay/WsssKOunJxGWRA29MWfBEg2RZm1OS0Icit/k+0A4tBrFeBJ8x+Jh3 +ooqKAznVzhMsrhIpKlrFDgJt7kJKyD4Bb+dk5dwX2lapb4nGpULBNq90HSRrJGS/ICd7hdSrqF5p +9db5aL2P9vxo6Q/a8Cmpj7Fah0lJDfPI4TG1PFmUK9pOpcRTS4Bq/lUanVN1h9X84ELYVG4lyKrU +mEe3KsZZ3RcA/WAb2qbWDn5K+zu84ZqOG6N4TaXdRtf5WjbWxVuOn22MWJ4heOxKfMWUHcm10MzN +rrKPc5+8rf6q0xCXN/Z9lTdRSR8ukQNd9d/67+XKLv5VhtIYn84A47SEzZjsb12M9nr8W6G7t+aH ++0wSqy0HkK7BhcvTVzI7NvDiVcTpx7R7b+jbejbKR2aoVN+pV/e0v8MbLhiMY0gEK+lfIcuF1K8S +vRfzve4gso4+Yg+cgKZgXy1vCLXyYqjerEKZcrPXCULvLeve/OGNH97wEc0eudGjTils1YPmjtrg +kZs8ojsjOjTMqFWyG5EORpuRyyqFjYWx6EFTkcpsRXndsMxiFKqH6bBiKYGVyYzzTNo+L3YoKRbL +isXSYrG82FJibCm0l4rtpYpjoamqDFexEhpJui7Klxfmi2D8rG7Z+bZ/ZCPO6zwE7KNagpSpFXz4 +J7W/wxtGYIePTJmlYGYkAT6IdxI4hA/h9WTAhcKZMXTXkwK6gEZPDJQAqTyIKiZiztMwl5ZR2kVL +q2hpEwV5UJVZNE88vtCJaBntMz/aKRCMQ+lFU4JLrd1oOrnRIg1JrrTCID0VBmkxSauAhAxW6UBf +LoN2fgx0JtqnvYV6l8psB6RWqNkp9EelUPNot47kqE8W7NiWzD15wFAZH9lkD6ql6LW0RGdgQj5r +lbK71fb4IuBz2VR94KPa1Da1dvBT2t/hDRe8Xo7CrHGYEYkZMXll/uSIxjQRgKcCxOmQBfzPAZUZ +I4gWf3OeN/kYEJr75FoWt7JqvMr9Ssq2CKFbXMlnHcnqjC+59CZHf7JOcNbotl0QZsGEpxYVewHp +7fIvl7W80HuJqBxjU+GPoWpre66tqxFTymVNZf/oB9t55G5qqgDnfA+V8NTKwdOnNPVpl/+3uOHi +9etC09KyPFxuYLKrmYEd88j0V8z5CG48jR2+Q85HrUcJWzZ6dNqXINNjns95LYPSmPvThmHjY4JW +UlP+dF3Yv1c+M9a40f3GJrdieTCetZ2mKqCqPvxpTp151akzP8U1PcU1PcU1PcU1PcU1PcU1PcU1 +PcU1PcU1PcU1PcU1PcU1PcU1PcU1fcrX38QNn+KanuKa/hvHNbmQgjOvMnkKKMs8pimvMLkUksxz +XR6UiD4JeXpPHchHft1XSvI73pA93K05KLw0tR4yJRA+We5c9jYw9FlgwS4kyDylQCktWD0boqOm +vVNFQFSABsc4J5n8PpQzzwHCO2H0s7D6/PtA0LDH3Xmk3UmYvyzM8Jf/7kUg8EJB/K88ZoLQQERe +WNWlMH+Qb8KUUzRWrIKyF74lBpxUypbNIz33EfotphSTGf84hAcvKaqAAx8ECb5gPZdEmTne00mE +UojLylNlSuVjictSC/AzJMxcUmYuEVqjGPBK813IR5iQ5F6MmFSQI1wwyR1FmkgFk+ezNd7vy7W3 +2FxssqyNyZw208aRgWirWsGjVLB1+RAn+6pH2PvhZchbH6LdnPLxXtQlQhHpUeCztJRS+urFMurt +oSeRs6yMkqDrg1hFZCxRsSd0ETR5ANndBenJivTLdIcx2eEjxYlHoc/WcGj3osvOtu8EeXo8jCyr +iXy2cM56eFpEF50LTWsD0xaY0cBcsUVQWoUzWgLS1pPKmyoW7cjAwEOQS3YBPhRBQ0OCCK2ll4/l +Y30G8qyErBID6ZkqspRglsi3ywzfURfaXkN5nIt9g3yhHiwv/5HRbyoJgI8QAR8jAaq+zOneCIF/ +L0F1/bB1w08cUxf68BOH1M3DFhNtPoeQutgVPyI9g4BxO2aolJK76I9GF7RUXjW+Ii12GtYv1j74 +Yqjn18/gMDOmzEezdZVDFDPbFbVdeGQu8l/eG1L3WXXr07yvbtX76r6QjRq8rwnYsZgvl+LeUV8K +Wksw3MVk9IVXxIWCNSqlhjeub5pN6eJjG7M2hZ+xiUKngl43p7Z8eWq8AFW8GX8vokHWWuEgx7ev +8fdzDHlMfqdBpfIzkxg8XOGvKYPOD1kJBF0EmccA8yFW6FmK+LjUIqxnCVxZuhq/hB17bYLawz6M +hZOxGwKv6r0LQ2ZRnBZgU2OoLkI25VVesigXGBQYjPIFRkSzPQpnmkSAEJYU6s7shRmxBqNJVRgP +WRXG3mpwnqOvwqikDGMswujLME6+CKOUgjkwflWqvhipE3IUg8KcjAm+aBvdVsGZPU/L15hahCdG +6FifNPUIn9Rx9oJF/KQSlvIYpPR9QlTuwiqdK1yll6YybGUmVRG5XYhWObayRlYumMoxq9vjJf7k +xFi0+aX1VcsRzTpr2XJURYqPU+7xSO3QuD3ucXyoyu9R+DwqV8fi0ihgaz45ty85sSvKThxT2Ymu +KjuRF53YhYoTizUcSotKYbV58YAsJ3pVQGCthEBRREAVVQR8/YiPLCNQVQ20EGkhIXK546cwVq59 +bFMwBSipegqiSM4/pIJfnuXakv0OReLrVBF52oKO2Txp8o/5UOH2IySHru/HAdutF5apoWd3mEsz +OzPEEnY4rYfCj01A0YpR500O5rGp9zdXR3jWtALK+gn78El83KzWBza6CI3PvPFr9atociTl6cUO +oxOENTriczd8n0DxobLwsbAFcptNApEfKrtfQp4mzOlxgZiqDFeaI0kX2OgCDc1xJxm+s0RZqmAF +jpbg6MePvvylCvFSiTh69sfg3y/w3So5+6PD3yS3f966upVFegI44ER98JRwAmU7rLb9Q03Nu09t +np34omWsWMYgKBfinzqJftqFUqlGop72MnqTDAxf9JCKNAt4ARothAXlJQWwVy1Cwj5UIRuFJ3ox +4VLY3i4Vax6CCYE6Kw0H3mgwe5FBidIqQUhiJTiK42In8oOPLvLGgRg1FIOCTkmkWKrOUWMZlQhI +vRR61plJ4DKZBGKZlaXq4hyQXrH2HCW1gBnrLpU4xGM2oRZn01YtrGsUVqVSFihU3daNSw/at74H +31Ws5uHDG33SjX3AYhrByI0inh7ELNgnTFrIAiXd1yG43meB2vcnlXy1Riyt85ILKthZbYqsn0Ia +jn1IxbGYVoeEjXRKwJFHH11Piyq+exH4onN2TJjHiHUMoMYEYDSh/pVUwFIiElPOc5k8sihJiypU +KESZSqRzlcgZldShXP0Zm7YoPgvZyvWd9KUyBahth6atAQ9KFekRSIUHWpDJZbp9OaqIqnUZqjbh +arNVYBavfYDXcuYCwFaJ736f6o6nQuKpMLjJfPlWxOaIuvVefT/cu4C+3atkrj8GmfwyYXC7kNnL +JCxuHwR7G8T8MaFyIzJXgAFxCneZnX+x9R+CTrGAdgNwN6XqS4okCY5KSqApWl+1NjxmWGnopsrU +orI9/mvOmyr//fgWsExnEmmcKz12rvhYquik0jaPRZ2Wsk4RVxPLkMVCZPtFxyg0DEHaqJCuJ+7J +XUjbc4hpNlYL2+Wl7ZbidqJ5REDOIUCEQpW7BM6Jxd5NkKtsSn44hDXlFawoEjhV5OWIX4vyFtW5 +RcnLCwVmOmHUE1XK4FG3WtFs83ustlJ7/Q4tLJZKOKxCf1aDcFpatyiuO5WRzFxQXFqOqRwLwTFv +ZwTIWoz8DsKkqiXKqrWC5f0CpuTme6SsmYoY3y9O3vux+/imvstFeSvxdMGDfQz6edTO56CZe73c +F/cb4yKLddMOkhVHh0w4xMrtZD9digPdHsbHOB0LeHxgkWewOatuGe/AW0cBrTqB/FtcpmC/Glgz +B50raVw/qjliq/sVzfzHfKh3PrBgFm/l+g6jJzcaZovNixE2dvI14+3kIL2aecI0+Q4YSZ9XVBNj +V5e6UXaITjDTbyczz3zs4lz4UR8rb0rjqAXNwnWQ1sV40c9O4yEGC63rR++/25qisg== + + + lTzQ1cFoY3UOz8KvuiLXj/fITzKr9MOaWQVHcWNTBafl6tXyd77Hq8+XbRs3bfTaxgLcJnhrva92 +TtQACu9Sm9N/eaD3qcE4nRL0+xg+P17uY0RHWxd4rSZwUw7Yk4/76qzeU2VVLo6FSkOE1BQip4YQ +UdWHGCsfc9UJbFACs0o6hNGkVwWrZjCdJKk0EN5oihh7KOCOW93NIBLYNfSljDTfbaRAXr2GupxC +aLs4aKdx24HQZrXkfsSHcnfKkp+gL3d04EyjeGOdGw2WzQSBdXDe0VqUprM8aaycznQvFh7HLLVr +D9oBgrE47H/Eh37SDl2timcL92XaefcFj94XOpoFjhLVpDLk2BI0ulZp+aFayz5CFOprKLW8kjVw +yRv4EbWWVVW/1pX1ax+TCdx7OON37uMcQlrFLPCSTWVhl2UYXIxi897OJVb3GJB6XUiurXWXRVha +FZyeNoVWTmFWYl3cOURS7kOy9boirg6xkkZCJI2SyEgboiGHFPbrxBD4qODFPPn44hHWDTwrBauq +Bq1Vp3orU7uFEMX0M0YppghFVYQhllGHc6UmlFj8+F1+tldFsGLC8ydc/0cE/50P/SudDc5HdcWw +vyXor/Y0xHA/XTgZYv6dGOMnGXhUAdIqIVrn0vCspiaP2KwHagCvB8/tiuC5JXQuBs+VoXNF4BxV +UZWFzeVBc1keklTQOA+Wq8sZL8WMH5WNZEpunaFKQ9Il32/w9qrMwTNnsZbBzfO44LP7Qs+qwDOO +nWrCzoqQsyrgrAw2K6PMgsavquCyMqjMFpFkZQRZGTOWAsRUERVWxn1hzT0EmCtE43Of/2QwuVIL ++4k68GkywqpzFEc/SkrwjKtFPs8B+VzICMaqQkbYxSTjS92PrOjHvm/wRzr1JE92EGtvVEkvkvSi +A/MMvVOhg3MlyhxDUgGd+WNGM69nT104Xhmcv56p1MfZL1kYJDh+YTj79L1EnCVJgN/fF78puM1x +Uh/HbcoUUnUvHgp6PxP2ripf+1rYewxzQK8e4jDngrPL0OyFv0jv1Bn+sgRkF8HY3x/lMv0AbZ8x +ldb0VoAV+M8ZbHWIxJP2+pBj6W0ItgZLp/dZZqqSAjQdlIhIUo780HCGdP1kPfg02mVWaZehBWJJ +jxNdwDEH6j+p4NF0Ivd7jT2lSZYo3LjREpsVVivgwAgKFPlIDoV8nwGUnxtP/UNjvOI4Ddmj5BGs +QJHrvXwAAzM8vN779aobmsapnbu573N8912es9jEeIolJ69A+im6ROExT95YZ3T18iJlxSgpxmyu +e0iIHuHQQ50KsiElw7Brl0QKU6AZY7ZLF/rlM1LukiwSt2QnFOwkuLCQKiOlmvvho2L9O5wtbbBa +yaDNxl9la1RZ9bEQcrLmpsvV1l2hti4x71PyyxVx7yoEvgvcz8eLG4Fz2JD+Js/zVGZ66lIUua2U +96i+iwKvkg4PaaeyRXng2DxR8rGUZ6ybrO5peLcgMhSMZnREOm8stHCfzcsNhflSkPa1TcWck4zc +vAWnz41TP2UvhM4zY9kwzUTr0hvBHgyQCGb2glcKEA7UZB6xg6aZ5g7fg8aq29VpzUxu5tXj0oHR +bHGgz4fhp+uEH4UOHAT0EgxGjwL+k9A9yFigIr3U3Jl7CE+OXcREnXn80Bwx5xjNqLfYMVNup/yp +uhBGAItwBgsSswntgJORDuDRYzfL2oSWTQu3s1QW3OihlXhITzcHZkVMqWUACV9D54tVVJC++FqT +TT6X/nySLLDqjBieEuU9Jcp7SpT3lCjvKVHeU6K8p0R5T4nynhLlPSXKe0qU95Qo7ylR3lOivE/5 ++pu44VOivKdEeU+J8p4S5T0lyntKlPeUKO8pUd5TorynRHlPifK+ZwDeMG4nq8efFgUYO/GUKu8p +Vd5PkipvWEWRDrqIBVvyrz3YVmA1uRvLN1X4sdrWp+RuNrXakRWdWGJEUSHkITqn9slQdAjVj70l +8DKYjbxjN+JihiJng+BjVGFBKm1Ia4kb5sKMdBCJcMnUYKh9R39vEAy9n1c0u8tCGhRLUkipsE9u +3CgFJjSRCo7aGlCkk13JJ/KoYEU+UG18dJse01T4o3Ty5tHeS8HKVKkzyz1zKLyfB31SHs7rWbJn +zcH9mVyfye+5LI8pLQyXBcFwNexUEASWpXAKS6ETkcGkBdEXi2FKWkBhTRQ2iaVgwmKwwkGHkL/D +L4ODcNlj8Pl7a+ISBTUkj7/zGoISpu3DofJEHLYIiNrl8DIuCj+fj/+6Z9ctTYU/ylLkNmtLKeN2 +qcwpjWPEaDuVnN67yt3Nn6dAOU5BO1vimzi73q+dBzgR1J2mmYLdXjSMvYh7J7ENc3ZPCcOhRXbJ +U7PUyVkgXx5F7Flys1Ai8plVppCpZydSk5/TUzOnNsypE7lrpzCpHr9xGVS+UuHzgW4uU/lkTv/7 +Gj1/mhue14lLFU30qAVdMDVBFHW4pfUAJG/WOz26nf/KvE1qxeW07lNaEmNMhUVxTLBpUclUYVh8 +jGlxX0RbuWRTDPZEtVL9uct89kvV512IfFtshjG5XmEDVo33Pk/okGliSRdbouJybSzpYyp56Gt9 +7Gx0nBSkl/msnYbn26NmWq06Ftdn91FzqzKD8eNn9pBmdpfF0cm8qnuqendNQN3+nni6AMpQmXH/ +lBn3W9N+Muwns34EY0SLvkf0BwzGEvS4pmk3MyvzWTiO72/mbMtczOpBT/PaMqjnPY+1y6b7YceA +qea4nGGZX1VP8JnZLed2bc+GHasavE05r7tiXu0SwbqyX2VWVWY+WQtlPWM/qXK6QNQiFnrQdh4N +VS7bO0h74NZiURSka29pW4GmDwlBdHzcWPCVEzHl1NzsmH9Ru7NNBg/b5EFdjTT8TDok2jV0/KHr +ma9k7GYBBs+QZWYmRNDj6JM5jIPziuzEoBDR6OcmF83cmEDmVR1/6rdd3085gvkn7MOn6c2rKRpw +9CP05gf15FpJVtk/j9WQM3Bnqx6rQj9+tHZ8XjmOQGhTpTWMAnTMaHhM+rGu4NBRPXbebaKSSnRe +Q649JUvETR5zE5RklXJf5lrySvhNSmqps6TbSzY8QdU8Rpt+lAadK84q05vnpDfHZPi7pDc3WnNS +mk/Rnu2VZpWWzEfpzGGhrKjMKuhVuc5sM93KZzxttOYMg2MKBWtUq3pz1LF0gcRZcoi4iJZfgPLR +s6ZSqtSh0p89OueU5Z+sQ7QWu0qwrDxGx36UXp2r0yrTpsekTU8P69JJlT4UdpSjSrr0R2nS4hNZ +VaRVIgsnulQSWfCEIdekSwvJyVtIMryV8TOtRJeexM/n0kyfwkxrmeklmemYSEGc5dJ/quMsx6Qx +ZeKYQ9SpQ+BDzJYZgx6mImFmnOWfSg39u77hfZ7nXMsuHZVjiPEJyWFaPbvUtGOwzy4mzKm80D4z +8+Ex+viD+netnKkV/ewhzfte5UwV2tmjte7zypl6pHa26N3d/aB5leln5yT56AdtdO9CmC8y09Ty +fKN/B3/oA4i4x2jpj5v7wupyv0b+mPnu8/lW96DX79HFzyprWq3o4vV8Tyva+DLfp3K+1ao+Xs73 +OY188X1nKrk6o7+VWvm6B7yZ8cfo7g/q6rWiru7V0u/R0Svk3tTaYj5KQz+voKuH0hmdme8Vq5qf +bdVs77HS0vWZuZ4ylEOGc1D3aurrlrWzWIdSox+17ZyDJAJxcRCXvEU3ZguJgDlTg+bbdbPDKSOE +9UnSoE7MwzlrM4xQGPvNWsJN2zhjbe547cYzKv1n06OfSKdnWlL7E+v0qQ+fpNPPayr9TI1+8Bp9 +FyVEnXIYjQJlz/Mt6lQgYspAcccgjXv5O6IOIZKoKl3D4n+sEzVcpiwNXrcekzC9aNXQq1WQprX4 +pmzwTY1FDIPLJGqRqbMaAEsFgJD3X6W0/3mm/32KcziWWf1DNv9YaqxO2Z8l5Z+bSOM8YG0Jaztm +7ZS3GLSpzkca5/GtqfVn2hCbWv7M2vjo1nyp9tCjv75D+vHvUh7n7/OGi1bn9+wobjvu1pNEdfdY +8rPfo1JT0O9OJ+Yx70AOgNWIV8UW7FXYfbtQvMUrr15pdalki99MEd7rfJUW2RGLrWEXjFJhqVoB +sRZhXakugxVQqy/IsJRi8GUYYgmGWHphVrs5VXs7pGpvXSiyEAsrxKIKsY7CXrDgsWJCrJKQ1UZo +ayL4uAGve3gZpcy7vwu14nxbJNuT8kJPrCMUosV861MbCj9lVkykkbadagLnareob2vRe16kq75U +fSB8Pd6ZW7VS73y8D/Fs+xhH5N/QDZeI8/h1Wmnnrj6caXtV5AQv2+6B5taaWjnYVER7sGWZM1T+ +z0e1cb2pcx9813buhsN3beq7X/p0w8/phlk+gWORI+I7Z1MuM1yuZYeIeS7z/BC28l1Xdi+1AjdZ +qjlmtRwzbEJWy7Et5aiKSo5eaS6rOa4V6zlXpmfPaMXzlRzXCvQ8WJ5HpTo9bVnqukjPWqGepmCP +amv3rJSCPN+acj6qPfTotloFSN1TIOg7tb/LGy57ljuWWR0H7FWNfXrErnGSubE/aexL7komaxyl +kKqWTXiQzTfJpjNSUfMkm8ypkIiyl8Kal1Jas0xDaZKpeDEkrSUtD9gdVZiF7zceJfNRMiAtYbYx +wmlUVYBTGd50XA1vKgOcpEB1inGS2GodshBdpmCnU7DxeyF5n8Kedqlu1pwCoGIQlG/iKhtCRJRN +cVF9iI6KrYDk5lFfTd5KSfJYtuNqO1PqTMKBiqbOpCDZfdemin9XaNXHNvV93ORzu2GeC6QLTUv7 +6IMSvrUdetlA8zyYUapNbedJCkP309TTZ3wmg2KTP9g0tkkGULUG0x/zmfv3SmyLOKJ7Bs10oDWx +JyufxPO344APRr2la3/T2+2oB1tct35Gef2Eu+INN0YqaU8r19dnpOunqcr1WB/+NENnv2rp7IvU +8YVXKAdoVkUoEigzD3usqflpPkSsDEllH1JCGBYUDkn3jiFxyT6l6osJQYaUAK4PWQEXZ/M/l4ri +p3wlxTIW/y3bp7rFpepnCvd4oPDNI9MH+5pVS1XNaOiJtTT7zNQzhdpV0dQTS2RGQ0+07/i016ux +xPqRzbSt8uK42WBy8U3e2ouLYMJa6ezoOmxlvfEl6S1Gpps7cGgr+Xt7WwRSchs1ToOzGX2xSSdS +m8Vz81P2wse9WlaKmwzInOt7v8ed0yPkHZK2CXeTY0MTUVqUxONZ5zPYNsW+ftSnfhKhcqsoS2fP +V6r7uK9VRIpaDbWv4+bHLEVCTJNQ54F0MZ/jPoFXDsHNfBnSKHShwoVuEGI2A7ZEhGAIplOp7kWO +ASzhozExaJ+gfgvQb8nhGQB+qgiIMxX+s6xnXaI+l2rWOod8KrGPz8k7tdSwjsFwEdI3hEQPefrb +6JLSgTpi/6mQ6nZJdLsgP0/J6bSgPyPJnAooXyCcQjqTb6iP1c8DDnRKXpe92LCPsQ== + + + 0HkyxS851iImFE2lquT7rEhyTLumm0LJZankpVxy/NrXBZNTyeSUtDOGUrZlk2Ph5MXGD+KvfN3k +rC1ZCvPiyQvKpSqd/H1C5FZSaOgm6up8zot6G2abURU7sc13ekh50I4Z7iPfkHFThi2pih05pLpt ++a5sQ1vLqm3LpjS+Zlu7L0v47ZKLOo9Uzbemx2DK5lSZu3i3sj9rUPZYOY+z8vIyrMbn7yhTVEfI +7ZLQZoFjLq7jBaI9JXlGMlzlWW0iWrspY57AtwU0c9m1yaXbq6yoeSxrnhc2T6XNMxx3LG4e8yOm +vUtUd9y/fmu0hc67rNi5SYpquZPHbCfPaql9Hrd01Q4rLfNU/X1ut5rz1ehoq7JNNlYA+Xyrldwv +32p5jETvS1suW20JhnArGPdlq9VREEsExKxCFvj70O39gm4PW20OOI2VVPAqoZ5z3HOJbz+mRPAL +W1zCiT9iuy0BEkPSK+YsTCLqF6cso4BWCTZhM0Y5pbCJuO2OwSybbzsd2GYfzF7yaio5s12IqNhl +225hn3Hz6WzzrW2/QYUdOBY8Neetnr+6c9vyCQD+d3/De2mgaehfTvOmFPO9ELdDJGlLpYBYe2JI +kHRXoMBOSQqwIRN/AKanFGnC4lWRgU7iKUIsxRCiqfJUab0AvHxy2phQhPAtj9iiNeFSCfAkJqH1 +OdN6QZs47NqT4Ex6yTHoQtI0E3IKMpvgUbII9pI90PmEgUryBNqQG9AJyEMSAIZEf1by/fpcv/uY +5xeDpSW7L8T7+0w3j/H3F7792NSqz/6B9NZVdusit7Uq0lrnCa3zUpxLBus8b/WSqzpLf66W/OdF +5dOILl6qn0ZEcZ7+PNVAXSDEqqqCWtdBjejhRwf31i7Sx0UGtCH5KXRbVVjxPDqgNBiWePEyQiDC +iEfC8zLMeIMaX3DjLXJ8iRZY4gXEIdTmUMuzqJV51MpMamUutZBNTWUJddfyqZ1Lq7sPieqavLoq +S6z7HVLr3m8pfdpuT9vtabs9bben7fa03f5mt1vmXpqsY9LOUXLySU6NcWJSYIwTRsJKrspx6vDZ +yIwazseWuE7bgf6fQfej1iFr6XrQzw/2BLqFqnyp9FGP49ZCV8G9/c+NcVsq7mZwbsRd9blkq4+7 ++GOcNP/725u763/c7F9dvfjTF6r8d8Utc1/RvvWCfYvCdEhhM9pbcYaQUNotpcfFX9Gn+qZtyu48 +XfduST4xdCqlbhtSSkaP3F+8shG7X+QNOOeXVVkaxphgYqnuWiaYKJNM6GQdWcySjibJ0iqy2ENK +Q2S0gpQGyGjkiBRsn7sUDo1j4eT5SuFawCCXVhEd5nMJfxozrTjTiIv47CEVxAszq/JqjFWYtgv5 +2I/JGqerGY5zfAiKMZ6gQhJG73VyWWRGnpN9sWLvGx98zBcRvPBqXMstogtbdUwgkCzU9827mneZ +gSyfeFPYpJcMI7vGEB1dSTJCKk19aX2ei8nf5abm7zKXcYfGSPsh7dJghVVpJpeA+0HsrHGfHrKS +mvlMTqmYZpFiX2VbNqZdbPPrj1lyiEMxlzoZSG0MYJsyr2GRPjPbyjYzhroMaLHqe6g9Dy4zgB4b +A6hZ9Tx434PMtaomOzN+njN//q1bK9eTQfTZeiyLEIRVqeKyXClCEBflQlmWaMsQ0ZX4xRCiuvZM +LH8qbGuedsSYrmhXOxVWNbGpJZNaKkJAg5qS2C3a0xizNUm9jmOypzEsq7Gm5dD5+wssrsPnVwH0 +6pgXV1zA87GwYiyrGIsq6gCXP4YA8lhLcQjCsVYPY8GqRPjrafBTbLg6mwS/TQDwqCJI6vtJgS8y +rUi16nGVkHKR9lPncjUUQn2/M7nvVFHU4BPncUnf8fA8PrqUlfpeZjHTTNTj5zCpJf9t5rKYTfXo +XfnI2VTf055Ms6k+Zkf62XwIgAhVDr1188Ty8VL9Yexn9NtAhdN6EpjfJMUPHERNdF/S9XtscsTJ +8YjJC6fLgeyEXp9LIvF59GdF+2yKzp/7/D4dEgee/+r2zW/e3by5u3nzzbNnmWqZf6B+9Zaf9P6T +31zd3V2/ewOd8/L21c3VN9dQN+NfGyjfW+ptrE8xQeXeaD1vsS43g+u3Gtr5PIi2PW76ad5CLsRb +Wyx5cAm+xE5+/uEv/p9r/Pogf0al/A9/lX//F/78vzj4FwzP5pebf/8/3ealv/K3BGXXfagftXmN +sx7s0OYXa2fF9/nF2oPu/XD1/m/wfbF7d3e8eXF3c/vm6t1fNz8XXPnF/vb21eZnuy/DcD8/vby5 +u333fA+FHlPy/Hc3r66f//b6xd0Xm3/EBf8vvutB+7Ws4VlDqBomByEf8poWKL6BSGc7HJl033s4 +LTpp8IL9xOoqclaxZrn2B1evWpPiAHie3vzhikNmWCsEIttIEX6cN3qetswKIqPes4oJhnE228nR +BANShhM26OS2E+ndDjOExI2eLM40nRuGWffWyRkzQxRGS/KHe4x2O5p+c5D7Tv6+uGoG/eFVlC83 +g8XL9RBVQZYmkDT/5ME/udd4DVC7LQuW4cX6DroLzpi3ILLhvvN2MoZgYddN2FfzsLUzbjz0UsJM +emVZeETsSw5XTw4HOpByO04aB/5VbtNLRZoZg9sbxzFB32eeBcULw745O2r/hsu/5i209ifgXXTX +zxuDrhm+CMiRxovJ8GrDkAfNpC0dKDhOMluD/xxtdq63m0FP2wnCPDQvgyneGDNtsS5wAlQzdBEd +sVssFQzwJBodzrBb6ncgagYLSPtxMXo7duDf48zqM+yN3uLe4F8MJJD7sCsQ/0dwJqw/6S+ZAvo7 +OTvghDGMyQS9A+sQBHOLUcXmwNR1bgoPGrbYd7yNoZaH24yESuMWHdjIxPtg6sFwZvA2MBzfFYwQ +M+3iuh5ncBAgvWD0Byp8eKVxi0vxSjQJdHEJ0RSIh4wET6/eRrM2jOUJ+JtvhL5hawxSN4krE++E +wcWbYP9AWaJ6CW44h/ubMMMDtCi+L+43jryjtuDcXEtui4WI+3DBYlNwcshN0U+qzFyr8xZLG7On +yUDRSc4D5h8D4DhBmxd80qj9KsDOQVdwH223mqGidoBcgZGF+r0lomEesAIhFGxMN2xHSXo0g6/N +eNkRq4vrBOLCADa4wSMwXRrnM30SniTvhC04DVhFHRZnD4Xbgs7wANbltu+wqZhgSPd8wCQLxkGh +xxsNsjEhJ/BloY/h3QwW+ATJxNlx6PA2/lVAUTusESxXSBO4jR5ZYocLyHQgpGByDiNiGCLA5Myj +LFdNUQpLgtx68+DGOWQ7DGtIeBgHwY297rAH/M7q8GAQQoYiMCX0BtLRllZkvJ6DQIS56awQFowO +lyfoKsaAQhAoaIc97eQM3xMzQFjDGSM240jhgiscu1NeuevxijzBjOQcoASgtJgYUBQIZhgp67AK +8DHLFllSa6FKxk6kStB8R5yBpQrBZeaG9GdgwoXeGtdPYWt1hhFenE68Kqd4xgygT3gQlorlg7DA +wffmyc4YVxCl0W0p5aDD2FBYoaB42BOgj9Ta8dY4o9tahijgwSMOy5OsM9jEmt3ByuvwpHHYsu4U +emQGbkAscUhSXPQYpGHyfdFm4kuDyxi7sTiAnlMGxqMYBYIDntRzpzkbnoTLsOz54mAN6CuWNaaM +BHriTewWYiduQqPS0EtH9MRXpmg6syOdXwQDtx6IEbqLofdUD6OAR4JkTCCEjn3AWRYDwbNATjFi +oP6YNksEDwkqztBbbGPch4sSL2Y5hIb2KQ1Ggn2kByzYwMYguW9ny089Q5ZVZmWCwKr41nxA54xU +pp7IhXEXbFTyX9AIzUkD43CQT+eJrGRoT/Bvwql2NJT1Hbg+zrJ+B1N8H7F6LYaOmcAwqV3XgR1q +UicQYUcLoAZVsdPoh6rnqFjxqvTg1eEBIxh8z5EGIwJF0BYs0MpSm0ZsY+wGcgzaZvq+G6SjkxxA +Ryfu3c3ZDckH7P8oclIbh9IPX2yesSYc9g09LZrhgORCWBFQmSRkcZJ4IC9VPtMbaFwjAxkhVGBB +kS9Zro3N/hs845npsXWgVEH3GbCSxs0zDDAoNJQ2CP3g8ui6wzKbWZkNNAmbcvNsEDZL3xP2O14P +Fw0cUSxXKAqYOrthETfsdGZhw9oBQ/gDCc0zvDmIetcxWxkItEEHwclJAnCE6/0xT4MGCT4JQQ+r +mh4m0F8Qb2wg8g3MSr/Zk9bg1lvxfhqaQzFEm2dYjFg5JPN69jv6Ue+GjQVOSrurAZHlu5ECzZr8 +UArHfX/v9oxC9ZaL22lI5ZBp0fGRSejASCAIYonLy30tUvB+vy5iX+T/by5+dXsHafr23UsspX9M +Yahn18bFb6+vXv3y6u7dzX/i5M3PDrsvo271u69v3732HwXZHGL8y9s/Xj/ffemeoyNf3f0Vsvvy ++EqChxj9Mq5v8z2s7/hTFnMYj3Hzsy82f/jfi8bwPz7IOx/lCE+EKAC5GdICtjrXEnQbSnwGQ4zn +jqAHnFBMFYQC/MR+BYnFLgebh7DXUWWigLHB7oCoBbLDWDQIARtHlQRcd8Ru0MJYRNLEkhEx3JMn +0OotXQUz9WqSAC4vLMjNSMZBsQQLgu4G3s6Qy+PxW+ImwUVBYCCcQXHD5aO/XX0ViCiWuMPtQAYh +JIEOQ4YCNcX/WLNWui1iMlYmTd9S2g9ELt2u7/ksTZUIunYPBYqdgNAEXsdqixC8QMEmLhcwejA9 +UEMSWwgx4E4bqBjYii68LC6nRds4DC7elX2Y2AdoQEaLtoEt4zaTwaxzSKftbEQalvR/7DTYqpce +8M5bDjOUGmy1aQOqucWu0+Sz0A42VmPCQLGwweVmIOok0r4jc+9FMrpeDKYYghJIOE6GuAgBAd3X +o9g0QMsddRvOv0jWPekhdIPBMaumF0NHy70MiQu8aLYYJoypk4uwWTE+mKpuonCCqZodHgfWE2aD +jAOMBJRkSx8g2BnXoCf8kEdDZ0ayNMz0IG+MR3npucdggDRs8DYg2Zgda72iwXUBzQZjAiarw0oD +b5kwwbgbqCWe6SSectxAG8RZEEwhf0CQMhtIKD3ndDRUobEhIHmKWAZpmMY7fzvQr4HSuwUx0xC0 +3BRvNzFCFbfDgnFY/1gBUCgxmww9BevDS3NsR3Yb+y4sXAizlrKgNSDjkC/IVXErTDkksw3EKojC +XABauoJRhi7puA0xJripY+B+N3jpZaT4OWn0bcLOxDjgSVhH6AKEalHmrKW8KtAE0FjsBsrSEBln +Hh/SYZlcUEJZhNCOqPBl18x+QEGCRlJ+7ome4f/1B1NHUT7erv7Qa7+QmradJG7FB8tBdAvKKg5C +PcFQEjgx92kCIEBuJlGUuDWxCLkC8XadAZOdqeWNffvBSEkWVF66U3+IdW0op/K1wZhmrh9LSRtk +B1qElY5SP0afwIZmzU0J5dGEaez9HFOWHakJQDdmflmI3VsaPfAcLNmRZoCt5Uhbig== + + + 5pAReyoHms/FW9kwj9h9/Bt7T7M2Ddg7aG7HPA3UGzRpFbeM7CdZPdS6oDJBuEUfB5NGnAwWb2Ks +SL6UFzhNoHQW3BkHGYrMu0EbH8UQQa4AOrWxJGfYetJPvLT0E4QXwidmhpsEe7yTzUhpFnwdsp2D +1usfjbVCQR/kBHqwptSM4QHNJsXTkFBA8SAgYY/h9h3pDybekHyiS6AgoFpYbGYcE6/osWKo1WnD +mxhRq2fqn6Sj+GCkgA2KT6qPzoKsTxhlfjAFZYgEH+SExJY5g7WPCOd6njsxbNAmwUnamAGvTFY0 +kYZLpzAbYrECHYokHXqBkO6ZeSOp62P+eA0NA5BjekKlsHxAFSgiy3hhZbC4kOYlG0MaZcLmwHCD +53I1gq17pJAnv5C8WaOIi5TVjzc9lw+6Qmoj/BOLCVruyFeFHhcIKP6hG5/incbqZtlnPHSQTuC2 +1ERBH7CoaTsbZG9TY+bdNQ01ngdKed3ZczROFZNncCOIFYdREhONPU7mhQY96WwPAZ+dBYOTu7u4 +/0HBZISxyqVSErUFTbMxNh5I1sxKSngKxhxiJt6868L5NB+CWoKHpBWBLbOl5QnrDqQXywWjDi5O +qglpYaZQI9OJnQJpxZDd695bTKDFzKJAW5o7Y98mefvOTyHvMTA3CJ0p6Egf9MVtYgFgjpb8E5wQ +Q7yhHYnDS6kVV1pJIe3k1ZhmhK9Grwxu5ffzIdidZ6rYULC5gniV49PxONofQXww7yBI3OKUS5oP +aDfDAf8G9Ye+t9iy2JRYZRTqROOR5bRirO9Cp7QXbwaI4ehoOh0yB2gqTqdpmGYCf/v6cN6l5sP4 +IgNtBSOjYCh3kaT4Nx9oD8WSgBQDtsSNWQxX2FcDpBCy2zTIIAaYB3R54GrPJoNmYEntCjWis9n8 +4dXCvSjp62WqB2ru8gElhbQg+AiRWvAIbMKpWDtyM+isvBnI8bLiOJaGhmXWN+dt4hoFOwjvD6GG +puJiZWMQaIvkIEC8GtJ+gMQfrsKjNNhP3D8D1hGoHzQqAiHKTTeQvE4ka1DAwS3TVhWjq3ODGF1B +DtPmpjlOc7pGx7eyBUmgAVWkhZGAn4V6DKT9hu5HWmZIqQO9GcBVNY0+eC280FBQKek555s9B/dK +tI32+oEiwUgDNjhspIZ8fkd+AqkeZG0oaCjuv6UFKxJccJ9gJdGQrewQKfRAO6VkwQbN77ohp+pY +9nTv0MJn6MRJrIAqLGQc3gyjAnYdmQefyiTxM62a8kHGcsDXIfNYrEuMucPByKhoxeeqwAe4aOwT +a6OxE6x4nKk7UFDL+SCvMuJM6fA8bhzPPAeKpGK2xijTyBi5LcerJ7MhtzSDLXj0QCFDs+cQv2lA +iJx9iNI7iERPq0WUBWgLtrRNYy12IGhJcPCzOXnDNXYqV0+UNnAI00AOApbQY5yjiPJn6YMFEQRD +hPxE7pcEGy5cbDfyBKxdLvMgCvleT77X2GKF3MR1OGs+HiqztknYwnYmThhbEcSFLqIonXHD401o +JUcvqJFlMt0w0n4tOegsdaYkCQ7UKMiyQL1nZ3SSHZsPcomz+TDKqTTV02yOTkxCqaJkS7ojuhcG +giCpQgxm13uKDAMTaYM/BtGZ80BaVv+bieLxWJTbuUtpUKBvDjrKIulz3EwHiQQK/0SukusH7ABp +NTrQYXktygMJb2cG0jcMeaaFDDQAkOhgnjSUnHUlBoIulEUS4WGSlDhRB6LTQ1YS7ckWSyuqSgNX +DacXHenpV8gVLL6cOP+wdyExuKSWcdjxYpx73B3TGxU5cZ0I4xhJIId1PZBjQ8GMa4rqdVQe6eLh +4EYtE2uTxGsmCca7l7oppCXQF25QO1IxSxotr8LA0ysJkRFsIKjA3E0ixkCb60AvVvXnIcjwUeum +B3OC1kIPZid2Sa+mg5Bv6SIGecDpti90ezCn0AP6b5I9gL4LGU5wLk0xNloQaJfvBzpGaO+Fhprb +HSB+YEnQn2HRBd4uGCnoMKEYR1dIr81i1SD1xuSA1unB9GNhAaHVmI4q0EF6vedoNiG5pYV7Fmsi +SFC0s3huRzAqud08FMYZ+ktZCpQcDxNnkkmHHlDvsKYhYuiTEYjMAEInyTrmtTAc0bfq52eyZBXJ +3MSbaXaWlhTukmigos9RRH9iZi14Wm7Waq6KxjCyAvALvupoMB7JfMZxIzfLbW0cL3KdaJgTf6os +yZE4oRWb3iC+Ee4NTjp91bVt0PcOs9pT9ODWm3ASiLbTA2VN6jH+pSnMiPmIq5i6NYcMG991eC/M +NcZu5PKmWi3TaylFi+cCHBXaND/s0CPxe0AqFb/HLJwbixEqJvrdT1OHDW9pOKP5baKllM4ZbF1N +gOokSVhM8Fw4EnI8nTgJ2UWj+CBxH6giwxBkh8HLDpodn0Te1TSZGi2VArTAQSDjWSwDUhauncim +ZxoPsdWwrQchc5DxDW9PDw1uD+JAaw/oHl27fgI0Yat0V6NHf5Zugj7PlB5GTL319ihKc3wZSynK +itaM8yb6jzVnYJSZFeW65xnkwpapw+jYxbrwAJYx+KLqy7HnRX5onmwo1YAQSeANoRrNG0DU8K5Q +LHt0MmzUeiR67d2hI04j5W4G1IxbyMsk5h0EIyc2iWY26KiiQ5PKH46ww/WM8kFgS3yQYRXedmXw +lXqQeHQHSpwLK6NeYT1dtXxx8mFD72G1ONGlLc2U6I/Dvl9Z2zyjhziC3naWc/Ai7ux8a2jLHkP+ +wxsRo7BpdhdIC/7ACM/U2PTKJsXg0e2Cv4nOntMmLTd7L9AfziWIAfoXyQOdcFgIPY0kE32rkZZA +HUPXIFAOBNybZZUXFEgPlK9xPiVcjzOpiBfdf2D2lu4/Impa2kcfZYeVgcEcO+qrq0SQbnf6Kxti +q8nYpB4UIY6EIJSUml50KHrQhHo8xS5Al4LME2E0EUM+DOKq3DQcgg4Zqq50yOARumUwmG1QlKQE +FFwJg45eWtyaIHtOZM3P6LOeqPNVTFBT1wSrQc+o8QYwQcVBNeQl7inHWtdEOzXMV3MNYwbcIHvM +tLwb62Xbj0KR2PHwIjXr51nctaRb08AFU8oMmgIIEUm1nEGnPY1XbqBLObxHLaRwkAVoEqQZupch +UlquDREza1EIKhleBC9HRjUGDayWo7gZB+9pdrNMbi2C0VtPwybWcUeYZyvB4XYBuAaCTknei3Iu +ubJxZ8NdNGJzbmpBUdzkHV3zYFqGOl8jb9JwO0Qxs5JShfbJ/UnhRcKvBFyuPVAALl1NIEorH/MV +aYvkK3ZJHa/FayITnAwoZXyao2vJXNNRw53eCPZiCXQkv9g8cxihWi8gxeCL4AGaxdw2jUqhqbY4 +fDTggp7aZK2RNGe8CDJ/odC09wkqEOEuPTVv4h4ICVw+IBax4xxTZZwKxYkQGLI1QmBmkWdqZaw9 +o9blSAzJ1ByB2omo1qogSR1nDveh72dFxdTU1sFdQU162h3aE0Y6XjDvxH5yPa8qo9ySHvyFPWRl +pCvtV2CVDK0d+gC8rJVnkifay0GesDKj8Fnr3iTCRIPgPoYp7zaN1s4zBKkC/oB1NrZKPwk93QV4 +EkhjeFBtMiBOkyueOE0jdLa2NhAzBXFvJGbKzf3cGiuIFLUk/CBvjiChuAwKU4d2AmVqDSR8E8hL +BJN2ZsS7ijhT21dIj8UAWltksJuFxBH+5pi8tjHo8AxSDp5hadjzYldlD9KOaIJNYz/CjbGeOdDd +MIoqU5ufCPvrBBqKRQKBIbH+wnoF8cP7q2p7Fz8QmCRLaBkxVVXmMp7RYauSh3T0j/kHVNY2SERb +jqETpBSJXmOoo3thwjDR7zGKjF2Z+XCiYDkPSaLMbYPaehXfCj553CRrIkZkFk6IAeqHNRsk76UJ +8pyIoAsqamPCRHeEF9ZGT+IyafXGwyG/9a3JlCM0YhgokEy5pauwuGIUoCBzomYoGQJZLW21mA+P +I+VgiP2jtvQKQrTnzMwMlF/AubmdmLfBy2LBMWjCDZvGxOwXA3UKJxpVa6GWrgy+K2CRYcRq+zbh +qD3LV2JRdpS6GtM4euFtXLVBXcRII0i0kXkBkm+jsMcTm+mBjBMGhoSoNuULLtNIfVEoeVPrCKCE +oyknYEt08UUqJwJn3i+tiSx303ofqLRxXVtxTzWOCyKAKU0QAYzOBMtA7fYw0GGZAgGPoc0Db1N7 +TDjsPZdg7WfR0+RXGOhz30e6XXtpSKU8oL8zTGO94v3pyOPoJ54pkemVM0iBOmJPR3mXdUdR88K1 +WwqsWtyYOAFj71pvFlYqZMeeAGAGEYY9UzvD6tu0Hra6I+0Zay/UntUMTO38awe39h2emSRxOMaZ +bRyTzaKIzszVNRUdn9V6DN7Reh03HtW1zdD4Y5stVXtym13ZOILP7O7SjRxpQ+N2bshK47VeJU+N +07shc42/vCGVwcm+Rmcbx3xDrhuffkPxG0jAKudoEAU1A2qxCIF1tQiGNc7XAiBqDtpCJ2rm2wAv +ct7dwjVq1t8gPRrxoQGKrIohDc6kEWciMiUKQA2MZVV+akAwjRzW4GeCBNeAblblvwaz08iREeUT +Jc8GEtQIroc1QFGUexsYUiM2/1m6VaGYGvE74p4ayb1BS60pAA3UqtEjGpRWo4s0IK9VnabBiDW6 +UQMva/Sr9ow1Pa09q1L3IhquURRrCN2qvlmC7xqltcHsPeaMFb155axK7W7Aho3GXiEVV/X+BubY +3qVGSDY2iBZpuWbL8OjMaP9oQJyN6aTBgK6aYBoIaWPKadCnjTkogVczI1KDdG1sUA1ItjFjNRjb +VStYA9FtrGkNuLexyLUg4TXLXoMxru2DDTg5GhQbSPOaObIBREdjZgOhbqygEXi9akSt0dqNLTbC +uxszbgMKX7MGN4jyaEquIeiNEboBsGcm7Ab13hjAG8B8Y0Rv8ParxvgGrt+Y9Bukf/QGNPEBq86E +9vLaKdFEJjSOjSawYdVB0sRFNP6VNraids20MRprLp6Rsi4W2swUT963VbmK5K0pHfOte9l0lbeJ +UpVMMQNze9lOK16rkTolw5wYciTSeu39gviypejF4kT0NTcOtIk+DUkNxAxEblh3xOG/LdNPzIxu +1a07T2RI2uQpQzLquXEJ4swgrZKs0yVTuxb9JEHi8NsCQxUdh5mHcpy9sA5tbXK9bv2cItm4SQRh +vB860w2tv3QSwxpjEDta3hZXK1iMaKqcTrFE5Q7a9qrav9s+ufYRNy9Qu5pfrA5D7bJuh7N2fQt6 +vJ4W7zevZ7N2t7drYs1t3yyt2vvfrM4IHGgWdw43aPZGBCm026rGNzwcQsV++yi1LPBqZJi4pdqG +Z3dzmnKJt8I4ewkfW8+R+kBEY9y+o+RsqEWyeKGEslKgovYPWURTWsZkQMkgBh2skbzLuI5ZAtoz +5L3ByJiHkmGx3dyt3YdxppQt0QX6oNgFwwjXkRgVeoyztbqcDI3E9ZJST0vURfMc5g== + + + DbDkta6D6m9X+luf4ddo/d7NfZqxoyzEqHgsQMjvDHs5M/TLPH2jAtgYYhdNZ8wMIzosKT7UGwg0 +WNGv18+yYhenbGwlCL+xSxE2sWKvorYvV+Lt9RSD/M9ePQpqbmYeBayMtec2Z1T9fxGNR8VZNN8z +bN6OXcdcGOwBg4FppmLKCZwxSIYOaOpghAQpNH3EkBODQeURJH9KtkRLazUIvPjjVu5Tj2Xbl4fm +5EU5h8YWG4tOkV6wFGC+5FTN4hjQKYi/0Erd3InIVy8wukcGepMZ6U6teHWhMuq+pz47Ucygkl6f +xfB+y0yVk2U1CNtuGsbTT5JmgD4zU8J22qur/dn2oN7a7ZuskYh2RJr7NKNak6t8HupdVq+/mQYt +GzZX9WFPWJzEWNRZfUYy/pVNRUg7r1jdS8tV1bJanlOvt9C7F6tbnzSOgVntSqeSpFe2/AT1PMJA +230Wr6qHKD3nzNjFTUBjiCGSiZiobhhKJmPmYOWAiMM8LPFDMRpMVBRBSgahoL3kQyDgCZKDj0Lp +qXbZid5PypraM0UoLzIUwgw6QnOxQCRDjpbbeH0YEjNl85HQItGyx75nWgVNRxNpGAQVLB4rUTiT +WDNpdqGWtion4kGCgYICabTxsC4mtMRZI/TGXjT+jgA45jQYDJ80edozeouNGJhFUYQIPhrnJUUO +DyXFOXLx9sWZ7cWyPz5/rQzNTM2QarKwRyqykhmCqTH6IVgfAtaLWVdG69V6/wDtMQR2FqEKl8/e +PUFOJa42B1mxH+ka4rRT+R+JSKVNgVk1eUZwpYMNzIw1oTjridxIMF9w6oGAiH8Y48/UHqI6exMH +c8MGxjUM4ivD2hGP2iiUwDEBj11lYSNNdBBNMdRD7kQSb+dAV+kwrdwHYsMsQ1J3IeRoWn+DefSW +2UFjsei1kaBlj5atASp0P6+NJuEoHAXCURxV1rVZ4VmDoGsgeHgFoZpU7I6tz55RrQd2YQL7oluS +q2l9XfEBeO+BD5hkIOv1OcwhwdWAjU7IS73ECb+R1CqD9e7+tZ3C3BT0RszMyeJEfKp23ECrKy2G +tHRqKnf1rk2vurbnBeFCo73o6aLiVLSDKYM8YMSh+8NCdgYJPRE0CpaOXVCqHm1x7qrmgZqA94HS +tzGTRJSF/lLcYK6mqZsgG4aZbV6XIodg6TFRkPU37ZAR88gUSMyhNhMnXI/8mt7SzB95LzPUMsnS +0PswunIJMOUR9azJMGfu2lIiZJBZkibuARd2W3xdKG8QDdCLXrK9bdpF3BGKRT5Oi6Ub283gqP9N +cbdVe4nejoF4l2YbgoaJ1WeytAFnuxh02osFIHGk9/6+fu87puwRXlxRC8ISV1MLMgdcRCXWpGq5 +qKJyy2NqIrnauYbY1u/WEOw4LJHM52PYMod6CloGU09jy6jWVkHL8OrV1DLNekW2zHdVIW+YeL0/ +Gjmg3mLtS69t1VYsqXf6eYnmnBxE0iIZWGJizf23aj3d0Nx/keXefExCIRq9WLyc9m2yRH9xffDZ +xFRUM3Ta0TKARHLqDIRid6CCtFH6nDpZlpv/8Xv1t5vqphjotbw37UDfn9lmkHyDTGRoO9LgNiuf +aBIMLx7JXHpBvUhuwB77n7kBDVNKQmSAzE/cD5YI814Zcq6ZVmGsdZAQyZU3doLC7YlLEGBFFzn4 +xAC1qUWlMCiBxlUoCdOsPWyFuEE82HGbtBAd02Ob0esvXsDIqGbqKiPxOpPkJGNaQWaZYyZGa5m7 +YiL8lKnxaUgGHzJca/TNWN31EtYrRm3CT61kxQ9ZIQN9n6jV8e2oShNfg8tNT1evZubIXjihR/72 +TARlJcMec4c5WrOZmk1YgbyKxhUjMySCFjD3IRiGAXFKQghIyMj79I4JFi2fhFv0BDIRnDSFFIyg +//TtyJyK0IS1y6RpmIsJkiJBWCOJoJUMmGJ0wxuLzuVhpzY8iSnSZidZJSfJCEl+NQhWUzAGHOhO +UjoyDgCMrCceTrs2QNBAeLUE5mK2+/gYE2ZQqgoM8tpz72F8Yjwk1NGI5gaFjxrzqEPaxRlLg8At +iW6WJJEucXJ6JSXnaEeIpfFXS85DrPReQq57n35xxOt1VDQZcy3YBI05Jyruwd1xUI9IsoZxw+t0 +G9cxFTLkIEhKzxJBGeisBJcjbK3Nq4bLiy+zecZQgG6c6bvGnTAez4ZBoFAO4ySOqPqiXgilZAIc +mFuXiTqZHG/LgAqmpcXyConVikt7smDcndaXiRZqvPowfLfncY1jj9DLR1HDhdxq9aUaQ0KIMV4M +lJ7iiP7O70fvC8GrEFlAB/Y/7PtxFxCyNhD+b+L7fVJ6tYfWyGeQX21taT8qoxpGVEPKAK+gX7A3 +kigZUguoBLQBTWWio/sE6wWEH3IOkT9yV0g/Pv+3T6rMySnSglufYZkgBMYIF0abbhKCClmKwMFe +jIaSF4SCpCPaEFLeqMXc2E2EMYGpdKQEEHiZInimE11c7ozTYW0sKqv0ckWB14MnsAQGUf80+Be9 +iNDyJM2DGB41Bd4Z7MFbhyAqioYHIdVnPJmJkqNAxwzYVDKxHcIDJrkf5W5JSSv6pWRWp4Fx9pZt +L1FjB3Viq7ExjQlBJURuMo5HXhHMaqZFNcVS82JSXEu/tg2GHppFqUh3g9xFSCakLQm9pS8PN8AJ +eLxl9oHGqNH7BJjRloHhoXZijVC59vLOzwRZ/NiNKz3QonITx8pIqDPv0QVtC0/rpmUQiKmiIEP8 +Z88osWb4wIOhbHaCnyZcLR98umdoYhyYz3Jt6hhNL7E3mhGQbmX6Ic9oLpCBefDpqlxdRoxEJsBh +AM8auUyb5cgMqowSgLRCA3VcyJRRJAEvfQIzXdCZ2XjlolncdlAUtID82gdDlWAEAFWJyZsD6hfQ +Aek5QQifYrxeMxCikjCHcUekiwdQF2NJ9cSKXxB6j3SlmgjoRdTeHbFqjLz3z6nnk0oNNre4AJw3 +TZcLAbdx/jYs8DCvrCft0Q3oKrMVLKlzymVJRCbd0lQIiY5ul3ZHfxRfmQhAu2buI7CRuZ+lXEIM +IWt2WHufepO2fan3+vo71ZSiHZua2jTDW9Oq1VlqaF4z2Q3dbNZLQ3/X1l1Lx+v1u8IBqj1Q843o +cDmjNq4UIfjy/fPfXr+9vrq7fklOW3BWV+cUZUpRCLFbZoUlsmWWmL215NqU0b30TZSMhCBWybVp +Sm3yaTP/Oi0VEHsh8DJp9Fo+bZ4lrn3L5TvrNp82RV+5DLL9JAuzzqeN6wRoycTTk+RlXsmnTR2C +jmrqEATCtfm0meEeD6PWQ6CVbfNpS1cYxt4L2luv59NG18TBhEczofbc5tPGPvVR23UabcPE7NO0 +nj2brzmQZBMh5WhvqfJnm2HwENw6bbYhHIzz3GM5Dno9fbaRLL3QTCFaUiNr02fT/kCIPrY/My33 +bfpsM9GDPBVZsw16IzoSQdOCuKqzZvO+kIE73pcicZsUG0qoQMtYmYNY9PW02Rw9qsy4D9N3923a +bD7J34fQdN1mzTbMEyIjRS2LY7mWPtsMgWD1hDVNbfZsSWIvqrFjBpGV7NkPb71HaXgPpxl+pL7n +02gzJQDf1YQs2oZmSM0A6BF3kOTPQ4dNQ4vMFJI/G+ZSpwkMZO8Z2QduRAI5z/24ZNFm4AmVLFH2 +iPTE60PiliABdnKaCfimmdJQBnjc08autxILAzFIxBPikYn9pCuWtENUIcmibWgAJd4bEr/Pog0i +ZFnXzlKreuS79RINgR1PzN+SRhtLzDIFwv77fDlCYbg4uSA0C1DEPNogEIR8m/8eit73lEj7x6+0 +w8gYz/8ogAhRXyrtMPyG2VUYfoOLdVtyxzDai7IXZWo99W3JHYmM0WWlHcaseHAONVzB4FYldxju +ImyPzGXigbrkDqOsBF86MJCarD0ruSNBMb02EhQzmJWaO+w4bVeMYQbRndZr7tAIa0iJrdR6Hdua +O2fHL9bcIQn1J0DuIEh3reYObaXetEa7iphpq5o7hjoOtiLD6aCRDW3RHSKeCC92DCsYGRC8VnTH +SEwukVxgqYbVUOqiO0ZwIwweI02lUbkqukPglB8UqGQdFtJq0R2pFyP2RL4qAwLrojsSVaVpVQU7 +1+PYVsthXBhnkAVfZindslZ0R1apVLiZDKWvtfvMEjXOM6BrjqnqDufXkhOuGS75dD9zE4sQ6bbY +DuFyEsJd19jR4nZhSB6GwIVoyKbGDiUjeSomzUmYWVViRxM0axiwM+pRultV2EG3xO3qiAcw45kK +O0S40zTaVNihAGcZtTZYCatsK+xwH1oxHYN/2TBpTYUdvh1DAJrKOrQ8gzCOtDwzoqitrPPg9ogK +BjvvlzdUHNKiVVcMIyJYN6fxwDCUgVZhQvINM+A0HhiOJQ3tjnVgrYAhFw8MtQIfljSR5raRvYxl +gJ4tcTTW9q0nRgJtOvFmGFrk1j0xIFYQ/WjKwKuZqW89MSLME0FNYX6WVVl5YihYWwlJmllnaCo8 +MUKG5S1n21FvqR0xvL+4RweKsUPrh2GwgpYXAUvSrDO45ofRUYYdCB9jMGnth/HRaDZEo4UJLfww +mvAL8DnMCKiA1et+GIkDkSdRrOLUVH4YWf4MxAFdZCHh1g/DB4lSAXXByIi1fhgfHc1xGcicXfLD +UBVkxgyqgowyTH4Ybm+/ORl4atb9MGRMM/nQwAI2s239MIzfYcoPbOleAgYaP8zDW+M7+2Ee541+ +jBfGOw264DQwq04DnChpNSk8ktOsO2GKK7kONs8wkYbR2CzhhmX9nR5mWUIO720kDscNXnB9jAPm +O77aiv/lB3q1H8D58nk4/H8Q38uZajZ69pBn7FSsEePWq9mIUNMLqpwu26HNfGkEO9eRJICE+Iyb +wulEEqNuDVLPNFpFhk3ScIrPMQsn5ThmRXJ0AIFdpbydZOGUcxzr7BLIlWf7bK6KOUIpPHqaAgGm +czplFSXN6uQKLNPeDUUuUt7OS/8QDZiDJuYvpUAg3NAKw12K2IiIQ75EqZAxX3meVDJtmxWv4Uh5 +QRMkj7mrQxZWke9ouqKRdGbkX5a6VUS7kQYYCSozKd8r6TXEv8EXnNQpQSwNVuC1tMH9/+y9S7Im +y3GdOwLMYTcpmVUp45mZTeHMQDKjGZuyavB2IHVEjF/+LY/4H+GxsYtHBRCXoijCiNr55zPCn8vX +YtbzjVVWroTKsKgMnF5bXLQWk3qNrWpI+6lmw/e3EIA6eKuYi1fGW5IOgF2wBCRqYIMm144XRQUx +kgXUTzUbxuo9QrQ3ejPht2PjVdCjm7FTlweTL1e7yGXAl13XU8yGWRAfNH3yBBPKEnPe5A/FNZbE +Lozfk+bSYB/2mLR5TFquPXVxcKiT+Rhn6VmbOSwaVpMrOen/oGKXBfd6Y1jmHuiFiBILncfJy0wM +4cEK/M5mdyaTs8KcBruAGU0V2XZE0NQOmUm+oYJjEnvySFNTpW9l57XFn5981dwJ3A== + + + FkQBVeTgL3zVPJzWpUUCV35yWWM59G5ZEQcz1oMWO/zhlUM7/tETSybO4eWhxlrZqvPfoTVR2HfC +HVreuLz1QRIjlJYswg8zGcAZOmZPTarw+d9fecXnv00ScqXKBy/XFgQ8JJO2nFvj2gzDX8zhvZKd +8+r8C6Nwmp8CNnA83IpoLQM9aNM5p7oGl4vmjM2vwE3xQsQuXgl6h2jUXlCnD/p2MiCN21vk1UTq +NAjfWWG+iLLwtG9KNiqzi+2hImXYJ7c8sWNRIgcLRH5XsuELkaCbRzhdGGvQ2OvOqdFz50zZTuJ7 +JoqKtuSJiXhjy2euySNxMHwpPTj2Mf1KXFnhOpuT8me6w7KliX5lfWPyl78wE3HTrzgsSp/8/xhZ +5XP2/Q625lQMICGiO8QMfYMF51VnADeAWqz9iqjuKW1DMErZY8oYEKJrOrRSa9KaeGgfcMOK1BmO +pXUx9BK4cjvwmRasSkl2CCzwulBOttel7sWbGgMfWlWDId0gQhFAqDBnsX6m2APbEtf5qgzBmoOo +jzVn7/qpX8MlNVBul+wwvk4FijzUiu3zHIme7Ktshbs1EnPcWnuKXYhkB+limH6IvKY8huJ+upLc +re3HV00NdUa0ja5M320KcZAcQm9CckhoMYU71Me41OAwW3e/C9nQgwDMpvydBGOKhCQwiZV4BjFi +mohDVgSCDWV8pEuUfV/FSLTFlQaZqyLFHwomOpv+nVktsc654gk2Vvw0Fo1a3tReVFKUVB/M51uW +hXzL0FUJqfJUYkmyDIrPAUmfb/otSQ0tZuAAvbnAFMwzzmdyOp+JLaWHSkz4w6u2TPij37Y6Ot2J +JWrTcJLr17hUex9S7f0ecjf0drwsAIkEnZp5vG1WUMNMBp5iYvTzr//8dk/rHx9PYjHOnbnZktxC +jEfHIIEWgo4OiOL7+xq7rltycZan3g2gjgvqyS46rKfejUZg6AZRg0rl9UvC9qNzQVhBoW5+feAn ++gNVS255LBdYBghsYBkwB/G2xOxkEC1xMuKr58LkqCs/VzDRmB4bMrI7LeveCZ0emwSWah18Mo5S +H5sK0jEzaoSxiRDvdScyxQ0Ibu5aec37sbupvjFM8moKruIfeNoNYAzwkwFjsLfxVK4RGOCWBjAd +1/vdPnFXfDkxIZ8PW3ZL/vWpV6MoiYLmq9QXuwfrOnXBLCYqT/kwXHJ/UxrDr6uOMFXJ7DXeTxN/ +HnI370pn/o4esmj0uv2/u34antou8qax1r7D5Tm91ym+pfvh5RScXm8e8RZF1cN5phklnwyG5vp0 +t0ynUn8220g3+001hixNxWnnWHqoxiRGKDRmYd62vmnG3JBvaFzXIwefhHyGGLqv8z0csa9sTk1g +lSqxvxHDpK75/UH52p9BT84i9GFjnC4f9hIqMcQAW/GMqwjOMfy2UW1V5Gcktv7hLWxb//iI8Yg0 +CHawbuaIn8GgrQAlLySMWLe3EJIZ46fsC+9Vdp3OPqXnT//9NaZd//iIhAHXwL0OhREjWI/YGRqk +jirvQdulvwfcuXgzA2azdFzPX4HqoLjbhZp+CewHZ9E+HcjVS8+QngK6fGQTTClrrRx0Vs9n/nG0 +8XkL+f67Low2eNIGF4Dokerw+ultYa+pwT6SI1Bqsq83aItP5EG5GcgsAe2ojzczM6J0GHtn5kYa +SC38Nc2zD0rDYmaCt7iq0swYyS7l+U9Yg4G57NJNj3rrI0llxOAA4uvJ7CUmzfyW+FrOqOs8NF5I +9I/8lHapbgRec+9GWZXoYwq5nN81hP9QpbWsQYRbr8q1ILsQ+Rwqt52mS34UFLTOz7eag5nwzJec +BYqzCt70UOOtcGSeb1WPE5qz2h8lEmhlKdPMWopFdsSlr3WXechTadgc9/2s5ugZrvquX2x3gpWb +5SF7CH3OUFDCLqpXegJia59IqVClZmUGihHurZancAri8+T7b3opXDE9ZVIABG3oUYqANp+QqzBO +UIFVrtws8k9TAIWqqPo1O92TDoXlWTZyJzTOev5E5SQxF3dF4hrlTwK5LZw3xxu87XHY1C6Z5wuS +JfMudkolj3tf6H8eD7zTJRmvJqqRzHe5shY9vsBWe2R8tqg44p83Co2MtbBlahrrJvA8PRbaShEV +1+mOauqxzANT1dgPkeRqbJ49R9bYaYFia27JwM41tu+W2+vxo8EINk1B5BAbdmNLQTZsTCAwm7Yo +cJ8Nu/XGl+aWLZKsDQv4YGUbVnIr7DEsaiCCm6Y3yngMO71X7xhGPdDVTes/Ce6mh9ix4k1nMqn0 +prNZufeiq9pR+E3/FhgAhx8M3IHTZ26pB6eDDcyFwSUH9sPo2l/IE0NAECgX11AisDaGQGTL/hji +mMAiGUKgSUD5CJx2XJUh3AqclyFSC7yZIdDb8m+GOHFzniXEDEygmyM2jKKboxZm0hkQb/6whNFb +ZtQQhQeC1RDAr9Ss8YAdw2s8amWKnflGIJkNWcqWrDYkOYH0NqRHgTh35FQ71t2ZfgXO3pmnBZbf +JbfbSmyEvHBSDYdsciuxEZLRSXQ8ktZAiDzy2y2d8syFHxzMnilH0uaRVu85n0cO/mSK9hw9UEqP +fH5PSO2pf1TDmCWCwIQ9yglv/Nmj4BBIt2dhYuXrflQxdnTfj5LHIAlfSyMru3ioq2xJykNZJpCd +z0JO4EmfVZ8dy/ooEAVi9llICpzuofy05YYPxavAMT/LXZOVPtTGtpz2s6IWKPFDDW5l1V8LeDtq +/lD8Wwn+Y9lwEQZYK45bUYFQrwyaBKHUOeUMQoF0q4EQyqtBSyGWbVc9hnjETtchHrU+cCgoRyDa +UojeKlWEOnY4TSiOhzsJR2yfKBwV3sxat49vdy37f/KVlq7B4yMvbYa4PNYWxX6ZhQ7HuljX1khY +7mtjZbtp1rZM2HlrQydu3rUftN/7SzfpYTnW7lO0NUvvam+y1s5XMH2haRasZui57Uxu6NgFgx2a +fcHWzxbh3lWsjcXgcWYncnio2Lbc+bXY9VzdYuyXrh41dFtf3fCjNbv67NDMDe4+9IK3wUJoJYdQ +I3ShZ3ASetfbkCZ0vkNEFJrmI4RaG+3bsCu06UPQFjr8M8oLuICtnEVAFTxizBWLsJWzCFCGGOiu +KIgQIwcQxS7CDgiMEJ4H8EYM8Vfsxz5VWKEjMeUYYJOYpMw/bHOc+cc1Q1pxLzHJWmEz+2RtBd3E +pG+F6/zMEbu8Mx615q8LzCimwCtIaZ9KrxineJ4VHhXT+gCz2pYHVpTWo6iw4rpiPWKFhe3rGiuq +LNZHVkBaLLGsuLbXAs3AwIWyTkDNxdLQwNptC0oBoRfqUSu0LxSyIkJwVwcLAMO1nBaQibP+FvCM +u6JdQEPOSl/AT4ba4Iq+3FYWV+hmqEsG0GcoaQbM6K4gGgCns4o6kamh3BrwrC812gCCDXXdgJ8N +JeEAv90WlAN6N9SjA/B3VrADXHhb944/X6vmE58c6uwB1bwt0wdQdKjyR2D12iCIAO1df4EsheFJ +O4/Zd7GULn0KPSyBMQ9bN7rpCqz0YQ/GUvK+P5LFN8ucNwpO10bJIqurqFkCs4s1NmYyLUZ4LsD+ +09bftnWYmxfDSoH9+y6xK6RA8iScMxsvn7I2lIijPGRFwOfctKNmwKde1dLD0oyQ2u4b6QqekhPb +7TXRYoS+WVZd63402DJpUcJMsszLu2LF4+C1aRevs/b7Hre5E6h4PNvaW4yvZqdLEV6xtzPjt1m7 +n/Eb75qnYamsrdew2mavNizW18buutRnEzhukrVr/PU0BLe9ClNgqFSLgKve4R1P+iletMfs1ZL6 +thGmYHoQLnimB5OUnle2eD5DlidKotrYs85TEinYfWj5lCCH89QkMUYLWqTvFBnwszy9LbRyqkX6 +ukTjjxfy/XgDK4F/fJCdEEB8IeE84aWuogSffpPnB9T4y1DO2wpVPP+46ETEapQrTIR/3+pTfP5r +V1+n1JNoxW+uG47YaDnEo1ZNCPxcyToCPa4r6krEe9zpUxDxnpfIxxPa2LvzjFcYb+GTF//j7fsA +v2r3uyIFYsLO17aqlFxoZG+WnSjWU/pEdoKFcl4b1QrS3PPeiEx0lyB449l6HLxqSszTB5WYeVN7 +kZnxKOsfHw+/WpH1Ta3rfF0TL5oR4Y9TyyGsgqn+EP7wqhnxF37l3/x5+rEGXjQYHv82BBs2S8wl +HuJeexGG2Czw+av1PTyu88kLmuuRakLP73oQVEK8OkAb+3quiCSu1VPp99nbhtOdlL7L1R4EwW3P +DU+2nchTUAhXnrJSyxN9e65qbj73O9LTk82mARIMURblUSdiuuHc2OhAiK+I1EWJF69w5dn39O72 +9K5cn+hAxAdeef+5kgjLAANIa2+VDPDUHbWCg/JU3UsPcD8636pcQBTvvHt27Xpu1A8gVVJH1zL1 +pJLWTkWBoxDMu8mpoRwKIgyK81Xbd63eqN8Ql+9OB4Kj1BUEQdHrRgeCN6BSYa92K+ne3QtlMFRV +qsXqA14VnwlktwgRKh2LzatBR7n62/Qrh9cLXkKvBQ6/+okwBEepaqyvnjcfuQBa5H6bZN7jOoFi +gHI2KdMn6hA6a9us1VKceKBDOJrTZr1nwmnuz6yBqAm2+8beoTjvUOsE6xi3nd226k723SAT3mzd +9UG3FoDznnq6fPayMSTism+Dy76+2CDm59UxhtOoPrWQJk5g/6v1eitjfLjrHfF8fPiVwD6+wJUD +P36IXQoRP+jKyT+Xwsrmvy6jnSZAeNhVWiCs5lWdIGyKV3GDsKemEkLYjauGQtzUOy2GYBymlEOw +K1P8IZilF8WIYNQeP1rt4eMywZxu7zKY5fC0w6I/Xs/qB95eanAj4ZsEVxQ+a3Bp29URXGNYY8G9 +htU5vfN2cQfnHjZJCBDCRgsPu92wIWAJ+/7TWGcJjDAv/9YCEZa+at/ySBm10P8QiPjXCET89Ym6 +WfbnCbvtZdHFuYTVvEqsX6OQVvokOqZOLU4a8FY+2bNQJDs7Kt4AyEf9hLE7iUISjKLth35tGLuT +0rkU2Z5FE0T/335q7+adK1qUnE1WA9bBDVG3Oji9T2pqQA/azjBpCjy94bXmN6pamYU5vYfzzo5N +siMCL237DT13jDVf6LlJsMSWZaab9tru52W89nKeIpULN1CdIKsXi49oMG8fowxfV6Rs83wH9BPk +hm1R5Hvz0ijrFneGlcb+2zunKqVMjwJ723wxsQYRmFUZ4c3HrvAXsxyq2fzyCT93AnBEt8bOYUtt +w8+tLuHNaxgkYnPZQgYG36CAI+ldlHLzo4WbOF545TeOD7DjSY4vYuVbDu9ypWyOX2JH/Ry/6MIg +HZfCSkIdV9SOzDouzJUUOy7ulVg77o0dQXfYYvE06yaNt7Lu9f0jDQMR3kiwLetLDZZp+22mYQuf +NtjEsDqCbd2usmCjw2qN1n1d8Z85h1nT+ivSckf1lwZuD1bilsStvddGcvJlO8pCYA== + + + i0U22khnYXS62xGWbqJ6ELSRmImD7jir1TPmBadI0mkfzqKMG7Bmvq6NShJAh4umjEWvyNtGlSSF +zZyjAuCYYnKrSlJnOD9vxJE6WAIaABbhkBtGcaR++xOUhCb1kPELKknAsUm5Ye+3fblRSWqnN/IK +ULZrp5LUWCJ0jihPtM9Uktq8UoN/sm9UkoiOcRf2dU/oEaNKUgcn2GGlzpkXrysFlSTicAuNbl7N +yWhlkEmC4swWsV0JZEbZyCTBzQ02qHQzB1OxMwglAYOkIlwsoaSlEBWTSDood1iGRPllI50Eip6y +sb199aV1paCdxHmamQTOc8PYH7STBKwXYzdvuG20k9bd89sf/u+0k8SWnA9nS4awU/is9hekk5yz +LzHUfthzRKGf8Jut0s9524e4AQiB2EifKCdxe4eDsSytVgH5913vGwhBkS3Yv0jP4TPpJBH3YeAP +VEDLRhnqZx8QUI4ZduZvzRztpZN+2QNC3Q3FtnyoJea/jlH7syXy67Oxf/hW3ItafvVf/rv9+n/+ +88c//PGP//XHj3/503/7X//7f3Dw31xj6W9Ott0sHKfEdJnZOolVCkUOgMgZedPsHtOyCoAIRYGH +WYtsRuZAY5VCc7sE/b3AsJY8yjXpgiD11hEUcS9UACgmFirCYPcslGhmj9x8WZisC2Rn4sBFSz0W +70oTWVdmCM+ujIG3IzSXjjnDNt5235dLM2QLR8ZIARYNnISdhmExO0tyWHqGJxbqC0qEMpuIbFqY +VSwsUkXcvKlIP/5Rp7GQ9wTgbK4di1sYK8C4ZkufOzJFX73FSb3dknPnIoxit3lJuKIzE1SquYE8 +1Bvt/IB+LzA+uSX5sQ5sqNiLkPpxOoViw2skWv84bxBDOO+zQfZRhzE/7VUB6jiZWMDJWUA2CVDa +QLODYSu6HUa2kgUYxSFfdh5u5RSBPAGq37AlLdwwztqO6OPtwFYKkgBCkTwGcFWR7vzcvFd2KYwC +ANV8bZY8FHNEMIl2isDZb0FigvCNE6BQvr3RRSFMk5tOTvz821yaRFIWzF5vvx7BAqW2QjgB0o2a +mArCcEtRfNbKBD8sJ79xd9yFf1lMJ0+HJomCF9IsrSEmhiye6SxYpr86g7VFAs+CkVIaFUgLnLNC +OKiyHVuLe9enbvCOE2pewIOJ9EjDCBE6cOlMqOGaPvlmTixDpCzzpWDUQwSyw8vW+UH20ACpmWcf +yHUFNcAnAazbm7+zcNJJCtWKDJhGSsAvLuC9NK3NJ9x6Evto6PgqawKLwkQ6eKksWYHxKBbogyO6 +gNeD/0ECGrSvhZe2S+1NUWG1PJjOud1J15o8iaCADYEj/np7PDvje0rUDjrRdvtlAQP8IB/2Ub5b +0sWcSEEgxGXlGkhu+89CeMwbg6aFt2dRWRWNF98KZBHwKYC29uQ0m+2kqOAUO+AS9uHyLQZdW3Wx +GpB/bQ7FK8o2i5Dvrv5XIX2+NFmXM2jk3j2TREKggRnkQlB5tKrxbAt0O7o15lxsYXTYookFx8j9 ++ttyeQxvVuImr+jd9V+IxBNAM7N71Af1fDIgrEZbj7KNiWyW4n96sFs0VT+4gLkTt++Zm77Egs9c +vxC9FkJ+p8lvD58Ta71Dtn3b/RfGxy1jttdqeQL81hkg3Ti/8ir7DugGYf+hwUbNI0HJDXsr2g12 +HU0L2He1Cw3lHLoVlsf284RGB9tC8RviK7twSwOIkQWStuf7zj4w3wBtDGATn8VAVogZinIM02Jb +sAJG7mDV4HVFT/vk6c3d1uGtOsOhbAezEkwJ6igkpe0Dm3HLCJDY7hOdB8TkOCWg/qBcEHvCqJWi +pWSvHeQh6ldKqs/BGXO75nVB0ZrXXhiAAjjPnoWuk6ECJKQZuSMEKPRhbKt2Gmb64HCfwyIIOLHa +xz+kxD2JXNq4UY3bsbgqnB92gaOeNMvs8m7VLEfrTr3FmPvB3kYi2z5NrW73WZ0Z5hyUeeT7CVTa +oNiqXYB9uxLgjOL7CB+cGBcQvqdoHO8Cy5jZi40meGahm/3hYcEKsXdYdVLo6MxfTJnsW82Pi+g3 +wYfbul/ATFcWVOdUC/pCTeImlrCVmLE6ao7A9gKtWKonjVn7bF3PStxxQ4N95TlCXNV1vWhE2e63 +o5ivYUOaUzPD+dHhC7DrJ3f9FhsII4Q+mSuGN+quGBteNlC8U0UmP730021v2/s3X5xlKRhe44VT +b7Pz9KG5hjABpi2PAR80+0h3uUXmEi4OaPHvWlvmrrVhaiKiOHdnufyT1UQ+y4c9zUfZizaTL1MU +jwD4bMsPzYxjtJE2B1Gts3yfkckLerHTpf4Q5dn81Z6lgAG19Lnz1S4vKyQmG8vj29u+lNljIupm +bJBswRahhM0uCMpBfRVR6B2IzGE96+YIYQkYpDldWUjPEI6y7SrPKu0wMa6BT+XjJlCuI0bup57O +xdkBYF9JhskWtS1dKP7HR7e1r5WHjBkoq6LBOMY1zEwS+SHlToB9wX7ClFsRqBX3zSY3i9SrRvXt +CEaf2GEEdXobF57Md+EAb3FTOFsExGRfaxLa1n5s8cDJEQeMe4S2tcMsh0HRskeB44Sr0gLtxtZk +RrxMlitGUxheNGeJEIod1eCIIhynlGhXonJvASicgLZXb13pZoATyJaFroNd6Nb0t/kDeOZst1S8 +TPantLepp6y8B6RQmEHK2cfsMImHLFbNqGnpCH1z8Pt5zIBiom2F4DItmsMvHWhDndxoJS6Ry8FD +XVk4bvuizOVTkoHxjEEdfA7zauZzSN2LQipbl/YoFnb3+W1Pak88it2oLlCF+rCfZ9WjmbM6RSou +YLYFnpmpZDMQvYu3yx7W/PNJeZCRHbOfHNEm6RkuXO38TLUd2N1doAQrfMmCT+/XISEdNHBYPorb +mIclbrOkKSuKUaVLklvmR/IJTz/w3kPaWX6h83uVExZ0oChG7coDr6Z5CYufvdBl7/zQVOzFcB5+ +E9+W/eswJIX6H2exIy4vY2WMyl2G40OkhrgMRDdc71IvVVmV6SFzoEVspf3S+A6DBMiB0u7Kqt26 +vVfIVckyr+4fgEXPvJZFuYNV4hKbgF3JPgqDDWLWq7pRkFEsI3sHVUtRUXu2nUwGRPCD2hFhuL4a +y29QO3rYw0si7FGwbokZFUhbg42GXJcykV3eQocienZuj9oi66PIHWXh5vWIqvhxB6QcQLpIXfSq +sBSyL42RcA/6hXbPzKWmSxqdlOYvpAdZx5Zku2NClYjQ06IeP4VYCrpCTK1juaE0JYCbBrUudY5u +7MsNgRUaNqdYIg/RVlxV6wwTwpRluqDVs/fIEcVzHPuOl2ykhUUqAIOjwCX7A516rQy8am0RNF+n +n5/81ZMHPoRK5h2dLzEzVx+OBCDQhr4Ql2SGiEtaHHWqPs/nRUNVH4+hVNYVRREIvpkmRua8kogS +A5hvGaayiBDP30VRtYxagVA0BI5eEam2XYrfFape9v5slZJV3pa6K662UEPPE464qk+PIs92jNmP +eNT6mGjG3odZU2AeABZil2HVr6UorDDSQhdbzfP7Jo/lLb89qfDHZkUWldTVMOWwFYRbCUfsHike +tb4aJHnpX9mtkCKX+HpRIVbTplEDUClm+5nW5kn43FRDGLJrDQPwsj4Y/s2StT1vprZ3q6sxqKfz +gxRJm8XZUEDVEUS9m1XNDShOb4zw53O/J3Sho+lC5og3e4uvlylxNYYN2rXuTosdxiu1REi1q+0e +vyC8KCRDnYnUaCtoF/l51MdJG3PTmBy1JzKzQja2N1utOj3AZdkWsKdo/lQyuuGaOO3ByhlNaJNg +HFU7Iqla96aYypCCYfzGzo43pqqFVGBcUp7aXQBNmaQheIsUQJRtPYiel6XI854419UTUaOkF33R +V2aWMngz7vEgDLE8/QA/u/WKdg+u6bY61QaJg700W8EMKbbomBvqaZYYs8Y1hrzz741YzdbeZS/8 +0PTbGiZYvOeC0CcvHLqKNdTgHml8QYTR/YhNyNIAuCFobkbBLNMZQx9Kn6xkOwIEQonhE1Ukhz8n +McDuoy/OkyUIeUCOUmIU10gcVSG8kPKrMRLk69AOZwUlWPa2ESWNtZZ4cr6q+MSXyLTNZN3eOtSA +MbqlNoeg1kWRoZPtrMGxr7jTC4pm31j8MchuDKs75dlFrTcG63/WHVeRj1A7J9aKQT+7lALMxcy4 +JQ0xcfCnPv2pGejfZB1ssAu+F5LHVDe5Cw1SDXQ63UCL+Q+G1N4I1U98QN2mUY2iMhwuNKALqflI +whrVB0KgTk07p5i/xSN2eWA8as0nqdKCrqEhLMcRclIsvjfcacizmjYZLY8riXdMKh2KNS1mDaiO ++Om/x0z88bc1j8fQMTdDA0fidaEWwAcCa0wH+2QdbmsK3DUu2e76ANW7OQ8UErnhhoD6b6obIA0O +zD5IA1TEtlUSy1UH2qCdamuHagsFdW0BBMMh6QhlmgaJOosOVhLQN9tyD+9GDSYzeiBwY9koYADW +ypMq94oluqiT9gUsXjEJDXuA9kEof9Fg8NLxUjlr4MhtQ+JL7c19UoFrCMXLitVO3ShW8jiPfWPa +ZHYGvP9aDcSuKILvBwxZ+6JiG7n7LEXSXDvN19JcO05tiaWK2Wjv26o0A2s/rGVfDW0g+nR79B9i +TbVBFMGXEvseqeUox9K1LrB0AIQokijYVHMrY57IvUMEeegCSzG4HTQf0dLNNB839WQcMSeGqSKr +MvcsQtPTINAyT8Rqv0IJG6cIsw2qghi2WAX3kOjsHhJdbV9MpydoyQ6UPUnzDKEoT7vP27UUfluZ +5Xzcu6a9zwMGo20rgIaiL4ETAqP26CRwUrYOJy0M64YmBL04ZfUdyEFpu1ZGPIu3QfDj5kp5Od38 +QYoNFN49shHb/gsvH4T+2r1R11Fbx750z5sGEEazaHcTa9PSXRtJftunVJ3hX2PmupwDV3rg5/Tp +kkfWKvlrb9EELOh8mj2yl8Nw/2EPftqWBxvI5uuDEKeKaBRon/llyFf4YybGRSUUCnZ7FXbfFn0Q +5BHgFXjiLWi9ae0A4Kx0SGjBnGRjrO9Ov4/pf5kltxL18pDEzpOzb/HmxAkHFHWEywo2mwebSU/S +PTXC3NGsI6KC4YTMGEYVvbJKOnPAUzHjZub2MRpmEoD960pabnYlIQIaI9WU2E8ALbS++Dj4ZPs4 +wJecQx1+KljPcTHw8PBcUgaAqxcAWz2d7A6CtwyZUVE6RUkAKhdbuxXlDcsGLmZNYMmw+/pOtnAf +gje6K4jnUWeTMMzcB0wg8V6u0ye9DvOeDLfEZ7puib382L6S+/B80uJO99Th1VqIblEdFwAAq+Jp +/EIiP7vtUlgE+0LxKwNbxNIT4GaJnayrhSchmj1AE6SxWNZFR6WBqOM4HMYWFm5FXx0yxZteD3oh +67qvGnljHVyC2P2YVuF191RKVsAfYTnsxG/rBryqk1nY09lTtM0+FpFY5wgoLdNjHw== + + + v9sDOoT6gLAmXB/TkFh4Dl3aRaJgr6c/zE9lANCe4xKyYZ52tV4VZIctQ1SboS+M1pML9L4xmhXh +C1bQTdng7HuzWamiEfyI/gfBltVuV7ywfX37q/nMO1j/CnybLv1FP2EmbqvnqBDDYNtXp2MbXfWH +C6FiyGqD86q8scHofZZWH5nhmxOsDM9nS63paaSBDXjzoxWWHJCUls5RVQpeuGp879CTpmlSgzOv +gLMT6S9Znp12jQcss8IThWiiiqzeAj8aWLMytMYiHAR+ewliKjEScfcFDRNFtjUUqpqCupJro88S +2hpS8bbR/ZWevSIqj8FYLGaS2UzUkVOM4NACAdmNm7pmBLcGguxJe6GFPZmUyq7BpD25LUByajKW +K8egtBKUkq9TbQMb5UGpx7TaTifTJqeHGms0XA9GLABnA6Fom5jabJFKHocKXAO1E0JzLKGug7Ej +YlvDe1YlZRgnbxJUckkTeFQGYy4YB80ujCst6UYVrxnb1AzuIaD1krJUqD6bGEft5nimkPrczFDy +TOatZj6yZlB682boefPEiR8hC6uio7p48wVgc8zmwhE/RubzlhXG84yEkk8LlpgpD3Nw18sfuqA/ +l8+BvKehlcKLbYLrHhMvIemNR6y5s61+0dRqxiLX9vjqbzk4xlDuDrZWIoKQx1fxxBNrCxWZNkfI +M1xoBLAL7n09gN3KDDy7tdB8DCWJyr5ojB2YP8stFjawVrKkF7x7M3lbCyRYZ4rYyKhBHP0Riiwc +YWYK0aKTKC+Waip8fBfDOQeQi3GlteRTAU9SkVurRdUSamJQHETOPcWqU2XihqUJPNGM7OPzv1Wv +KpoeCTI8vYEWq2BcSe7TrtSY0lKUs1bTKh27KqgMKJLyESpyZke/yw7YBgebGyt7FY48b01CBDDu +eK0QcpQ8F5y4RBuhymhrU7kPwuaM0MdqZe3Urx7RwVuts7bLi6jCTFCBXOulHGEBNQ7MOYlC3ZUj +RLwKCKROOb21fluZTCAOuTRF8BFKwJVhC2IUW1sHrHyhkmw5gbgfuJRt2uHG14q0LVGVPCzc1nr7 +mMXsyvqX90z2I40fLLVw8wLfGfwgbAS2OXbeUlOvjEPIkyKHOPsQr3V5ey8afbmQvqAmFur7eu/3 +o2b51hSojElQiFzaCay6S0G7/ZqIPHQluO6V2aq5iUXoAYh97W5wHnoml4A/nGftkOjuGLdhVfCt +1kaLbgXQg2orU0hn6dcQccA0bE8tPvWP0POpMK8pLDXzrdB27R0pBGXjIwFofuTRP3zrQGH84dy4 +YGHLvO+1i1XLLSwyVpXoJnbDaoM3pCsOEGnwLDO+NtXs72Nt2X87y/kR+nKVf7BQ7jqlL5NCe88C +LPuFFrHFgfds7y3NwQrnJkZ97Svy5oXdtZxPN7C2JysB25S0XJqbxJXyTnY7h0Z01gZp7UnMlZcw +LeXeHHEmwampS6Q+C2bhqPUp155vRfWNxXye9uWpqa2tYxI6oGdExczKjUdaWtDhPKGNHW4lHrF7 +pHhUeDVraz6+3rXF//ZxBAtYv2eAEcyVMMEH2/UzEAth8Q2EQ1i2AR+xXf0BZxF30YrUCDsxID4+ +2dHvwJFgGAL2JBiXgGHZ2agAhVktXUDTBGM5sDhbUxuQPMFkBxDQNPYBQ/TiIQICKfiXgGIKPiqg +oba+LqCqgs8MyKzgbgPAa+u2A1AsuP8ANlsjiIBZ2wYiAfsWApoJmwuxUEDdvURSAbMX4rCA+wux +XMAPbmPCgEMMseWEMIawNCAgQ3j72w5JGcLkgMgM4fafdaMLsjOE7RMUOgP9ACTd5gkBkBryjQBq +DTlLwMZuc58ArV1TqIDODVlYPGKXzcWj1qxwAo1DQrmilLd56TvQOSS3ASj9E0fs8uvNUUt6HrDf +IbNfEOTb+kDAocezrFj2UKuImPhNycPx9KFcEoD4oeQSAP3b0k0YDAgloDhbsJaRHqMJuypUmGxY +i1lhOCKUw8KQxbaaFoY1QlUuDHyEyl4cHNlVCMPcSSg0htmVtUQZRmC2lc4wShMqpmEKZ5Za5+zO +rj67Dv6M2u4cFFprwWG6aFtSDkNKoTK9zjmF4nYYl9oWycPYVSi2h4GtWacP817bMn8YFwvNgjBy +FhoOYXBt27iI5xl9jzAxF1omYfJu23oJA3yhcxOHAJeeT5wl3LWO+qRwKLYavWO2tKD0rMTTPGvR +5lu6WMRf+rBQYRZtq9gM62SfRLdw0Ci8X3tqFn59J0azULjRHA5tuZMOCb0Nux1GLrfdPbMQllfY +AmQeNcUWoYJOKvwKOHjgtc3YkTdTeAufHniFpVvpH6iIvAc8LEI/senZL5fWsriaEdFHy1ThzX2K +u9EetYPNjR3XU5U3JMMOSnObrq3ZWNGMI8WgYtW2+xvPs3aR472snejwJGtD+8f2hayN8fhe1wa7 +ZmjC91kb9esXXlv9cZnsIANhta3Ig7BgA3ohrPtX8EPYNit0Iu68FX3x9TQwD7JKAnTUQi3CMysI +sdcV14VmiEnq5HTtD8RgrAuzmpny9nGSXpJE8RoVlNHWx7Zp6oZEVNjogwn/xx/02BdUs50sKivJ +e/zqOqW5XRC+4uFw0GBbdqv2eTCKE/bliaooesTTX8l1G45Cabht7m49wlfr+nDhPPEF3WMVoVTH +LMyXL/r5ef75DwPXb/kBSZ1IdkmbC89xQcOQnYFwc5Q5oHpvilq2gASYsMhfjntzRNdPVVb7iZ9L +F5js0eIfYBCPK4c/LDf+Yxah3o460XqzHWvfKRNtcQt31xHotXBEE9PzZaHxfWm+Zb1Je+m2HPHI +VDzToxZZqXJboOYtvnie9SXGe/nqY/x4/3i57jcSbZYi/Aa8G+DP1nXSEAknMDeTc2iuel1rtFka +neuTunj7ZM3aYpZCyIXAHyxo4Siz6N+rlzkP0sG4f8xcfT9PwQDstvIniKF4Gt+z8Q7G5o4P8GIS +4vPPX8VXt9ig7Vtfd9Wy7JgzoAr2p+0f7/x9u9BsOSkKQEgKLozdEbd+ut1Mm58v6+t55fUP435/ +7Da/GajvhPsWJFfL1vpHWPsW9yilIoy+NjZAIxMwchR4c0p7TIK97cRwlvBSw3188trntqHSQpzJ +aulH24QnfxpZv9dSEpQdZzxKNYqTNNQMdVOyKmXCi4oLhB6qZheyOjMD/Ez7wh1pAU8zXMoBRNKW +aEW8Jek0SQliyZRXOymLcnp8K6ALpsCowiSYZYvErI4LDOcu6rSzC6dV0VPLDjzTYNCRqTNWVRWO +Q/U0y5/ypSNEc39IOdQHGpV7WjQPAZziTkvzOEdPaT7G+rDM7ZSDugD5aNHrEK6ZzFselj4Hne3j +GE5UBQ6HowHJJpBPaQzUWerocAb6DicjxhpxgkQUCbLRiSDwu6o+PnWFJhzuPXr5ltNdB6EmU2my +hIlS0OxVXN6WpsqbgJwcWbUTygreuLuJJNWSO5qDyuw9oH5o7mrrCOFd6lJkNktVnk5CjdRGO5bq +13IWvqJewnr5ixJh/eTuYQOkAtxgRkrPZ2fmiCKZ+RYqEJu3BgJG/H8SIE37t89RTcCeTJXwjh+v +sfyvzXfnFk5YNxvLEjToZvk0qUyBhbP9yrsLq7Bdg7yq2a5mZGJdyOB9uvrP1QePNtsBOkSEh5mx +gqrnsZlgdoSFHTq2Ey7ndRs+Hm+3hwWkEbOhWqRntAWwATkuhdtpG3sCr5HaTlDWHXUDmnW4x5fn +CfdCleTCGzONAeR4PsrZxk1a6MEkoT/K+iIUoTCUAFiGJmZ4h7QWz80H2KU34TNK5BV1jk6D7SMu +BLozFJUPuILBI4b1JDluclQKGnU8x3xI2khM3FFo0dhBWMlQQTL8edDJyHFDkCCJlskSpCfiIGws +ddlOW263vdgyCDrftmQ/HNw5NzKkWooqhCI6HzOjbH/GPTSnkw5GRT+C2ShUJ5m6AJ5EHT+YH6D7 +YB3smv2469PDvhmxzXkWQxhvZbWn2wcJ1ng8fjTk65ubfmD74qMbWb5f9ETrEogObbeComNcV2J0 +rstiji56m/EHDz82VAgN1q0YH3W3pWOkslqEn4h2voyasE7/1hoHlaKarZVumQIlTLPTTfgKSUGY +j/gPjYO/RJQJFlwjcW3UJs07q06qlOWg3EXyJYo8Bucs0qbaykQp6eRRpWd3KY3Dc9ABRZ001Voa +Hpp9LR46+kync16oFMcat/830knEUTkAYvFeNZ3v49fHgeYtaSAlXvDiVSxddt8SwM7wfNNnv3HS +aJ20ecQxTpGa1Id/G3nrRWZ9otRKpRr68YzOsG1ResR303lVFadGy6inmPXMKh1MwlbAL2YjuRWy +fA2QOk8AGcyo/5PcouREcotYs2bVRMKcLGchPa7uOM1+maXwG/EJZACKDu8pwhHSRxKfUPs+J394 +WFB1PGz2YT/xGCYEUJKjkJgMBgNzQmKpq3cmFXvSQM99jCFXWuzjpPAlardfhyiw+WM9T0m01wPM +pAUKaKVeIgjA3SNLl4SmUEPgorkOQRUNcFGTwgs52ONBVDhwxVlXtZpEIppQ/aHNSomArh6B8aHR +tcsZNBDqSkKZnQMVCT9oiwf4g9jDamQGvAfOqtEtZG4FJkaQG2Ar+ci3YzKKJGwq7ui01XAJcaT3 +Y37k8dIvQE7enc/MiOMkpcZtTvI4wMQdyUFPTPI33Z7X2T/dZb/94Sd4oGsCpX5I5E70oU1sIKiK +gC6HRH/s8RfbxHAJSxsW/UEKnQvcDrbybN3Z260fJzrSzH4f9lkkHUzHEYLZbF5FmYnIUdE0P8zJ +Zwyu6MUryLADBnQMrgYuDhowtiacERrybqYai9rShxS1gF3dqrGLN//LazGZ2JHbRGoTLMo3Cx+A +cJgjk39tgw0a7PBNm44BZ/qeDKawQhrcKxmi/595MEHuiCpoflw8GDNeuYILslsZVNC/4sm+Ia/8 +3V5XSkT25baLyWMfZgFO4Gu/gAf6Ly+Kv5HD+kvkzj+/rv9tVXqAWCBVsa8aCadiIX+lrFi9iQDc +yo4qoLYsYmPehGoVJAc9KZ/0phZhIgS6Fl1nmFqxJiKRxNBiJnlHbQiPNVHvCDra4HH1vJTsSDXS +RHR95aKZyWyWqikVvRmD4acX+EDCRu6cHFimHYf5yJTpvh2KkZ0fVyktrAF2HsGhWLUex9vzHyoc +ldEQy7eGgcytgUgDxyq6du5R/EUHiIpJv8FpaDdBzg+sVpl/dSYmEehiX/rts53XNtG50eU4JOlh +H7o86iwkFPYHIEPl5eeHfwIwbNDFPC+YpFfIqZgW++x+j5H42dmPc/PYTK3SCmrm8CCfj2/OnAfS +d4KQn/WTD4B3oxRqEUg/d98RF6TBJOgg2v1cAuLDQaMtJYl971cQFg7MRsvkPGWzEvkZYxKWalBY +j6u5icaJNQhYlzhrVxPfnOd00uhD+wQurPVe0NiD5gZ1ssT8W3wmR76qJJ/aowj2/g== + + + RkiHCn1J2ySnikjLS7UwRJzMBziHXuOnsVRMCsgHY0Azhw5fmIQKcglw3zV5Mf19kZxZYwx2BFi8 +ullsIDRVz2pgNtNzsb2t1T4bJ3b7AMbjMu9935Yj/xZVD/CHayqRhE32+Pm6LeOV1+29f4LVSsQ3 +sVqa+DZXi7X9KsHyhY8bjGZYH9H4xmUWbfi6Wjd+YFnxn7qR2UT6K+r5uLAqipANjVf6Yi7hAx0R +c/vQ9CNDIfUrs32oX9krb07QI3lHYO0SzII3Qtg+6dQ4fS9v0OJ4St5VDj37jBz4NF92xMIgtyDp +AQYlvS4Q/+h18TW0DsH7SoCLtWIROQTu+oOkNRD+SrfL1fpPWZeDtQPUhJSZmJ2DXECqpK4rinxv +VXEJNIcF7MfQiEPsBU1zu020ZgjQQRYToFeY8ZELyz795rK7uhLyUXpgOwzt8gJoWlpxCWyLLgRZ +P1gWRiqkfWaRtrTPDj0R65QnMhPaDxfOldJDBzQ8YJucxt4495saKDXE4jCJTFXVU2y89vlQH052 +GmRd+MiC5ohehxyruqqU5LAOv1cGn6HuJ8wZ3yaNCxXIbE6p34F5ttPYpSlk6pvAhkRMK9HBrgoW +I7R3y85DJO1MFCGalLaPoYcKvHtoeYrShAdPcMcVPVHjqsgnteTZNFhly5II57NuhVKWoKTiPCmn +UBVsRGDRkoZDewI5t8tS+3EhH9NmvAgf6ueBmSkR1R+si9RhMeKN+L7oqNhRfNhslp/K1P4Kij0X +8KKCdPFTYWZug63CzAki8sTCWZhvgQVcZN+BoPDlzJPvJXvE7wDpHYhne80MOPy+632rlEMBP9I4 +L39ZsEdI1hPFjPL7Hw9dwYbM6QU6cSvY8+sezzJMc7KsKdUbr/8Q7Pklgj0AfVVJvFUBLHtvRXdV +0yk3SNOcNt7qvn0e+QYad5eNt7IYpkpum2S9fOKsqI9hVw8zG+m4Ns7qLBoRI2LJaHxFr0Xpnn4S +HJkspr3XEgbSnAQYSDvTxmtdRRwxFqQzdNc3XsuCU8awbpgoz/yJ01IcLJnxG362jde6KEEIZ2mG +/agbt2U3W/VIxHJX/8RtcZ4jKTvq57lzW0Sw5tHstTj3RHBblGHxArYLzfS3T9zWPdqS982w3LVx +W/fl7ZobS4PyZXBbAo+Aqb5RNsp7t6UGOVAXGuR2oui3wGab84vuSthiRjjAFjNBsHVXFeFr+JMQ +FMvlfrgrRlgo4dqSv21/pOiuvt46v9t3PUtIthwfJaTFdf2E53qXRvvM0BYK+MWynvyZ13r7XRY/ +JeNu6MMxyHZCVPmvvtS3QszCbF+Dz7KebtJ/wmP9rsfaeKu/ymP9FRzVX14O/2/4KQv968GIDYb+ +lBKVyFpp8aLrKjfFAORtGSg7/kA98zqcUS8ju8ZkfxsKkQxrMsaVhVypMBJrWE5HdDq4NGgt2nX6 +XoTJoE4+RuMM4KzFWSwXBty65NKkr0k2Tv+8qoNBb4b551a9j5RoHB1g27vwqOTidlY7goZWcmoi +O0KjK7JPVBKYMjE7XwFM0oCzi6kB1/RISIZ2Jpc1gurkkZS14YiUkKtupXP7GZRNE1X4USc1HJNX +WVTmArHTYjmY8GFUB1mzi3Ad30CHPTOHkRASa2qVdcoeAKTL4ey4DNdLnS4fs/2UXBnv8EFn1Fbh +fjjl7roubO+tcuFCJ5/34p/6kOy0faOuGXb7Rs0c5/AMfFr8B2N7Ej+jtIhvYzQYlIj9pw8xmyu8 +DhjSL2bHKSfgRNV0HMPxDIJdorfGHiE7dhVk8B7EghmM+EkMcl8uC3Yd4kqvGpSlLHnlwpWKAy4h +hS4CJctRMl97o/Uw/jDbZQW+GjqNd3GNXuRzKWOhp6l2ov+c7rq0a23Zie2g+yuy75xBVWTRmdor +YiTtGNJ1NNOyJpbMW9pxLgJcxTygMQ1m4JLuifL8TU1Ve+SLrfaLmmffHq39xgijx98RkKDumb1t +s9ooqJoNVvsMojEy0Wxr6pt3fpod4arIlmPQ+kHejTiB5tA3i/0swDM/TSPW9uwHo2r4BGAfxaJT +d3UNJT77LXP46ip9S9IKzYpKLsR1f+pyjbDGFjzzpSpWMEKCajDkDp0JEfkFtdCYvIMQBo3Ab+qh +nRQVEAEu+aef7lDkRtkQ4A178nuV5CnjVcPj/aqnOwWkaVSwUzrpRl4EP7cEe82rp1+Xnn26Pv4d +ddL+5qKpaB/gde5cNPQs4MfttOJmQE+vUdoCZrLyFixUDiq7unrWTJ7LiFqQj3cFgtHFK9wOUBkF +mD8/KS63btv3Rogec59lYls3Q+2WCrZzvxKZFmm4ncc9CbDXOlQjum6PSrTfCt1Gu5Vb6lvErYA5 +E6AY/eRyVKk9dU4zczEXWw84/WkQwaUpdAf4hIPRkKwbTtSvGOM76H4wPZdRAkl3QZj6H3Uee/mI +V5sLqqo62xOYeS3EGWi6fnz5hqegqgQTdKBlQeKyN4dO2dzsx3HOdifCC8qfbMuRKwqKJ555CIgT +ygm0FyjP2YstuTu7bSeqsXVAuoSAgMbTbF1qgM2yevelRAw6LldkcKtOrhQV/ql2DemJWwoWxRPF +PvRu4bLWi7B3I005nBjM0gdMd96Y4F1oEhg5AdB2FJYVYB7AcHRr1SfBOlGhfXcoEvztX14YzuK7 +91ryYF5OqLWOC5xO3B1/Puq04nfqDgQlcNJE4sV7TIcgqHzJi24MzRfvRFr0AV7ZL3CPj8TC4DGp +XjSx2ZwFTAefl5legreM6qlmFlnCzCye/CQ3wX2ZwwejLuZ3QBI/Rn1W3xcWIjGh1zJ0UkqSaoRI +zxNAJkjjkpNj64aht1NdVoEMF6piZbOtQDU9P0rNtGxI7Cwkc8U7RRuMChNmgWH1Am1jWDmp4JsF +nbJQpaHMAg0EW0GVDAkREsJ0VacJEvUoCuhoXWZIZpjPq3AS0YHIIAirAjrRemewlKcjehhJgjE+ +S1Ply03x28v2gQPhhrLFvuk+MyCwM6eWbhHW2DsPmQHTL6oO8E0LWmRrZqD5GN0TdY907TMDTtyB +M4CNcgGLJTPQDaogviQEuQN526YByPMwuICoEdFpTANQok0MrRZmj+8a0wBdlxHmwqyYhMeeaQCR +pXSa1zQAMSXbIxYq03/LMQtA4BbQlRlH+K7OfRbAs2kUotj6Eb+0pwNAZJBPuiHYyRITW9IBfqkP +XFg91z4bQBeqUSwu4B9Tj9lAbqO8Zx+dobyYDdh70pwhb/igGLDNBjIY7pzpIJ4MVsRsgCtpMduV +QCM9gn7XwC5ZGtiK2l+yAV6jkN9mIaBriNlAVleKL9zM1ILTGtlABjSuNwT4hpW6ywZyh1gJ3ZxC +Pe+c2UBmxuAWpvzMniW85wNf77Bfiqb7CqA84XQwlSPfPBMCc1egsS2OLhMJBlWQ6Ge+DSTYcQD7 +qge/uXBK/YaXxJby/UwHoEk3B/UA1N0S0La3z6RHtfvLGpzgejK4P3G1jOn7TovPVm5DE+iA4MTe +wQmrmW2rN0AdI+cJPq6RDXRCwCrx9J98NP7Nohiyw6M8c4ETVuPjiaj7BY9mV6OxxyplQj7fj1SA +wZMGMfGvKoD9W4PA/11mAmKcUr0LDfuStpmAxTOOe6ZvLtzImglUNRIIqcyGYKZDJsDXygypoA9X +ettnApXGBnAOfEJrIRGoufhME+J+SXHXkgjA9SeaaXueW0nLJg+gdm9+QgbkhpY25AFiHlRjIEPV +mfd5gFnj712dkIRtTTEP+PL9zjygiq2bA9WMyPs8AC61KgKxzp2mmAfAkibqKqD09xXTALGl0bdg +FuCg777LCaAqE7Og2N96ijmBeZHvlRRvpAKQUepdACLHB+9SAV5Hi/G/WHogj4elp4NuWyN5KLrE +22RhVYdRcpsIaKGexBm2UMu5yQg4gsBALww82ZoQ8Ek1TCX1l4HGCgkBt6OvRUju0t5LQsBKFVsq +flSc6GtCUIEeCyTSoNRLbwmB+HP40PcFZq1tEoK7+3TWjTe8XhICYjjah/h+TcNtEwJadDBD3RoF +2yQE8JZZnlLgLasMlYSEgL6w6L/M8BMA7RMCVqRAXJoyTDUmBFBjSeRmzQO+3hQzDwjduPDZto1s +QZOAeSbmXZjAWxvZmjbQNAZ6BXrv741siRTJwFjEzNDMtpHNJgNWE/rXwixBmAb/jmSJ1v61Rt3m +ede2tUb9WGMH9fJaYttarDZ8I1htTg3ivret3UJwsduH9rZtaxSzLkH84JdMZ2xbc58N0cWDQgH/ +sLatAROe2iSdbZL3bWteANQt/CY1lv7atubb3uL0sgc9yErWvjV3Cw0gu5zH3PetsUMFGwLThIzK +2rfWuGLlXXUQtZu+NQ9pjyMyJd7Uvm/NM0H5B1AhifN99K1dtgmhtLMwMxj71oXc5pABx0jPCyx9 +a52HrcN5IFILDWxeiW+ICxr8TQN7a+n+LxrYX4XysYP9zVvYCFrYXqP6vTRgf6L/esKLejLpUUHm +7RrY9la/MbnZafXirljg/+ormRFgDIryOt+qfta//jYa2Fg0C8j777iUPRQUBchpXpLy2PWvf81T +2SJCms0sNWy0Z/9/Inz/vW3pv4fSfUK6mcTeTCUmZF+7t1hZs/gWa4Bgb7F2n6CVAd7U0LQCMB1q +94MnQ5OIU3s31O51nhvKM25+VL7five6F4YN7V66SkZr8T4x/tBTV8037Uv3CeojRsYadvCMlft0 +eWC6LdgnhIb7pk4fXuenhfoEN5vtM/NaaKCe+0I9uDJRA3RxUV+xUO+wMRkslLKyCvUA31Se6uQS +g1A4FOo5uZxybxAv3bFQr5ukXtWRJOGrrhX7lMcMAM8/uQtCyR5clHSOe8c2nI+SPbOCosRjZD1T +JV5L9gILCh1mKUIehN2zZL/5+VKyT9IRk+D0eYiKai3Zb4FXoWTPu6KBSfJly6jHkr3d8/ebwdKO +ykNusWRvCZaFA0AJC3LEbV+7N5Mg6lNoX0g7Y+2eMkG/JBGalIWsNfxEDDTGq0Lp3iIK8dJZMESc +HCv3dqyTI6iDTz9trdwnok7y3S6Gx7Sv3CeyTaYwe5aHiZX7JLDTpmAfNsdvDy+i6Yj//C9yDE/O +Qrh5xPN+W07IQ9iq8BDOA8o6KhGWrjWys4MldX5YlufxdD1EdKKUwUwP8AV7ofY1MhSzhy34at84 +ARmEWp0RKFFsURtmKVfZNVv3g5K4aiQB/AtUg/bWzZR9hzbbtghLSGTeYhkEm0Mh2haazmvHQMoM +OXXSxia2xzbardjCsJjs5mL2z49M+/08x+0wUvvYhSxLJP9SSTDjC5gS8QuUrC2JqojMSm5Bp4A7 +nB1xwZ0O1JK53DZyb6Bt1GiQI+i3W/xuLw9LXY/L6dx5L7YGK2F1Jpaozm/M7NnFG+I50qVJI5gP +4cEcpx+J89WR+7E1ocEbdqodSWVQ2ZwqBCx72opHkryDBIU9EaxCIyUN2usJNd8yQA== + + + V5a3wBV3Qd1sIa49y/dCIgOVLbwICFMcaBBczNpiWs9hemDvpVwCGunEsFwHFMHspcuVzCFmmZNU +oK7YLq61YJ6Poxojzc0CMVHOo/4sTJXA9gnmU9oBzZzWebhClajy4YK11WBf5JamsB7EIp/COBfy +u8wxZnipcBcV9m+EHiDcABei1MncFCtHM+9VPH+nSIW9PoBumznVXFz+iiLYyYz2byPf1W3SCiBH +y8T8gJHYC9QnKdyJi5h8qiBGP3QM7atZJA4KCYXGBvW55Zp2oH0cpr9s4ZGCplEu4v7IYGkKiLXO +dh2ZFLuuiK75OJySlVG0i/ZFLhI7s1sBuZ1HQYMBMgoatpUzQyu0zmBBT2O7hAQs53NcyVlaVbfw +CuB5M5yWmbWinkHPjCVLzIWPtV1t3x7sjxmu9kAEJ9f6uaVwZDYvdeG0buKBqmTU014oEw6zQKgi +QKCBkgiSOUqdT5R47U0J2GWLQZ0l88AE4yPtTdLvE7vVBc4q8Qqd81hO/rB8vrNEmetrdup2lNv5 +qA8RF4U/eOGojC0UftXGJ6J8Bzz8vpz3q/oLj0dkvhmFGk0m5jYuEI4aFU37L6mT99/Fe3gHw358 +gXjEMUsQGfsj2ynIOwJME6IPoWKBKZ5KKRAHWH0plaDp3bUJhgoJVD2U1DIyYVI6XP7As3aaWhWO +t+aaPPEoKiNnGYRwdRDC5RGxnjUpesaSUwSSC7ZI00IObKklDvl8ZP++0C6GW6uCTU3q4ZKhMIU+ +XRw/9l/5/zrCXTqiLPdQEGxiJT9sOV4y1tg2hNOhhhnbzkLHjHu0JYToCDGviDmYsiyHS9/AMMHE +8S2r4Yu7YRJuBdpTzYYPC5+HfVg4xe2pARAipAtKkaOLCJOpTVDU1IMlD8rNKEkF4Z90nu78+BZG +E7XZeVysjizBDOQ99CGO6g/Hheyu+TaWIOOhVKXtskoHu7/qCPaW1xOL69cgZ3zp/GYB7N2gjcD0 +txRHaKxi/ikfkt/ADKJCo6aoL9S1LPAilIJp3gz7rRrsb6MULxVRlDMr4xZUHY+myPe4JEViy7VI +MwXUnLsRhaBmeS3YzBJmlnwiGQ17XkcwE9yoJY4qjvntbmYL7neE2eygqobczc6iNo8EgEaLzTAe +YB0J3KDjwoaZfUwSABAhq/l9e0zmO82MHpgoqHGmI2gDSnpJGuNWjCrz0xOzAn7Dkp/CpmfWvF2a +up5dKcMcJKcEXiBBOw9UwtJkZAXHXuJoAjPMJCuaspVc4n3CXEbFSqPpzL3Y8rU02cuSBJL0UzBc +CrhuFpyc7ukZagO7OWbpJTxQ2Vt28kYa2F15Ta/6FOP/UIGBU5zOU0LYhwFVixIq+i5SDiBLgmAr ++SiS2JMaXEL90agQt/7lSjZaxJnOuS0DolyXhWA0HW0Igmzd7+2j1cxK+yNDkHpLWaf5nVx+J0wi +ePoAR51MSbp82pTG/MFbsC9YVRG2LI/K4cHkOZHV4XQ8ZgjNdWlE/xzngNgMHEcuvq7R76kD/HaS +MFNotWUNu1xi2NsyBDbeIUVvzLSQ2eYWCDRR2DOLcOO479PttlIdCDEL6x7dIpKqxmI4HAOD/fcK +Nsx1N1/g8MVGoUAlXq6kI2xNF4ai0AhqOHraKaLsPhx1cKAjwlccAiCkXmfJL/Ni+dQFfBFARZt3 +Q2DnIfooe/VQt196qYi78FIt0U6K0IbpRHJmjokBj29aSxYRVp3H6yidgn/VjSatwybVQ3j271Ms +EuMPUOvR7LKlAlHO+Ojjj+tT8ZGU2ccpbTg1TiVWotiz6MRs8Qgm+jW6Ckqd++bnTYxTqiIzwLS5 +cjhie+PhqPDcQIkIE8ObYg4hM4BPcVc1mN0bD0Pn4ctVaK9oX9J073nz9e0mgbBTKYHf8pPF0/KY +iT4QUk2bRVhH9RQ0hsbhwkKGaQobQO6gmGy7IVoWWwZXwhpsNhZNVBwpQmkH7Ebr3kT52N7qdmN3 +9DQLzY5DQX4wDzQW9UlWy8LgXk2fGKZEo/ikbmdu5EjRwKlKBCiN+qmAN6uRdDwZRTl8M+wDG1tr +cYrHs6uhpnEJiwSpEb2haOxpvkGQydg6MJm909BjsvISXJR40dX52JoQxdotGrHrCu6Le4RXzlI2 +EPV7JwjBN5AkytwCXgUfmtHRAAOGMBBNveCHMwQttFAtJ9KU6dafZ1GrAh60hXvfm7ggXxPGBTBH +bnCJLbKZaVsEdgSofR0RQxRAggwUMoZdRC+wRjqUfjQiaj8lD4/REg/NSAMPrdLONuriPDcTwxnQ +GlOla/QmhnWVBhtN/jsGfhQP7QpIOlZV0Z5RY8kufwu+ClHDGHSWkXTbWjobtCshbqUSl1QPtBWm +tGAJf32x1VE0bFWcKjGMzqdIUeE2RDH2EYX/WfdpDgDtQ2phSDiN0L1Iygsbwmvsm1Dfn/AcT1j6 +PmVgT7koHMaTlb6mHvAPygwm6OlUr1/SF/EP1q6OOdTFb9kPKAHBKpNgOXWTPGHD1AlFe4MAfuRd +8Q+7tC0cNbM+IBI4DkqcN8pdIWGEt3DwjBCY3Pu8s0JXwm7LVPrSJn21T6zgxHZdAWHxM0dsUulw +VEjJoeVQKQO0LXpfIa0XswfyZcBVksozm6qAOB8ZSoXzEQRiPA/UwOzrY7L5z3oErCun8Mxmoo7P +yhn1HNQrGULjXVnEbtRXPf10zMJSWGFEV8sOE1TrvjyDwfdWEaBFikSjuhN4UEJdSFV4ogKq8CC8 +t+Wlgqom2JRqV7HHj2Uqblt4WAiZQECvpS4cJxLZql9CSb6rmNF/azJVyXY7ONu18CaOIDCjtqlh +bA21uyKgJY0H8aO3fQ2wjHTcbKJK97GWSOesghq3/UKrKNYjafaAvlLB8sSNv5QzMcu6z9z4cC1W +Q4Gv66MBSa6pxHpqRj6WJlTJ0oLb12WBLFNyC2Vdgbn70A3p9CXW0jA+SPgsuxcaCvsSMz7IFhae +iqpKiRVqgeZhTIB1075urHJ7UHR6UGTLd18tJzBquoBK7MwSeDdWehpXqM3jzguV5l1lvxxpNB2L +1GBjh4DzCxPG9k+A0pcmA1078vebchKKptteRTzN2vPgDV4aTAAt1XpomxDf+HjDdZQEOHrXfdH0 +BU2/LBe96eIIYMomywW04aYTJFJ2WYQGI1GJHSV/d+DqDsFSmcO2o/J3WsSwDNciPtTTw2seGotD +V5C8qFIEYwkQjAk8CtslyzFDdoYTKkmEzVpbtPSE8AdYpjfMgyOCW8DtVA0IVITTijQF7YnGvrT1 +xd74yLRH8GdF0dUtE6abNxNGB3Ug/SHRhfjDNjwhcC4u3mZvpp5AwjwKbSMKrW4qSY8qPV8NvTcH +G0Llaq/KXoptMPC0hc7NIwi9JbrMYKjeXIF+60avuAofwCgBvOFUC5Mwv3wjRpap+yE49WfdL5hf +W65mPLF2eqoujK/F3jTps8p2toDIeWwf2u10tzDFNpomo4kJaJcrLeLdVZpmkGOfEoL1GYv1NOpv +omhnm1mrN9xKczJ2xjIaAMT4SJYoaE4IuXh7I8OOLG/Gsh6NClE0rHz78ILFXUAG2woKd/+ksyyf +qd8a3AZccWjUP3xpUKg3T11uGgubFcMDZVENnnamsa3Xhdcx4E2zIgx5fMS1i/QFRQAonQAkxT3A +3P+hgSTEPoenWHbSye1yd+IUuz/iZrT7t/CA4YMzKVEOm5pxG9IP+t1lRiPBONAR9++I8oJLLr0b +GIvSFV+jtA5uJxqqm/EMAL3m1o7SHlnLu72THok0TaHnqRvTi5QWEIRiSSKLN9pe83NdyxDFxl4+ +sb1I9gI8paTRCZ9XN1Dw4wjEZE8mH14EMI1irWxmysLAxwXefBBvEYiwNLnTyObltKSoCXICFWam +b4PPs4yGWgs1OPh4Hrnku+9EniZrlsveM+s3+F/bJ4Xk1xbCcWgKb/HjPOMJY02Wt3oM4b2FAyRV +SPfOAAJgh9yW687kGH8QW93tOX33Fr4QqiI8SahamAwLIRA5iiwLrU6Rlq8RFKnqpTxfIOwySi5r +JGaO3IJjKgr2/IrE1mjOHsn37qHcdRMViopkTlovMSVjg5rlgk77dFjYe1jK6KStU5CHTZDYNboF +leSjHhWMygxv1yj5dJbJGGCzHtfQXEOFif6t2ZQ+cTBrhN/vcco1J4AG9yTxIPCAuzDkFlB2oNVi +dutJ1RUyFFtHmocOyQ1svKCjbfWVE3aXkCQBQOYDoUd1z1gj5Fh2G5omROXeKwxLnlbIGy8ButC3 +6jHfC0d4ZrnkjZvzrBkqWg+q9IhGou2OAM/N3oMaOF/7HBbfh0Y0u7yK5zbk0/GINS2nn6FVCH/u +XFIhvWcy8ZLthae+x/oBeCXgaxTlRFgQDtAUBLil2hE42RcYMNAaoLCkFpGZj1Dj0BhSd655Whax +RMLGLRKa0OXSI9t8K7WAptQStBSMQaqPUK7hCI1pWNxMEBrLPjI1qB1kCvIjrV2rR8DjvJYm8hEn +UHirO+EjFJ5midWmWLYqGrVKIs3r9HHnengrf3F/yELcSYCMWEXjQtrXImbq3kQOxTj7St5OSODD +ILNbC3o8I3XDpQjIP1ctLtutFlc8cta3UiJHyWHxTwVMzlqOxGfI8ibmKe8rljWd+/Ry7tNr9DNC +eVRKLIXib2cCKX2EEivWSjh8AWC5l7VSyxHMkM9U6a3QW4qZcMALtgRu4AehWFzGcBeIQrKcWHSG +kFdjUSmhLD6TsqV4zY5UBQX9aQXqawFcWiZKL9/L51gxDTWYqUUUdOy7pQjPNnMvWoGt+YzSWyFf +0EcqK3TzsdRrP0Bv+9Y3uWSpZw30ra/AaRhwxIhZ+uBuVtpgcqYp9jE0bIXkdILip04eiqUfwqLt +5InprLaMro/QU9H9VU1dOVZktmR05SGmOfs3GCY+IoMg/Rp8xm+dHy1aZirtaik9u0YElEwnFab3 +ZmFo7TkRANKXC+0qcRhoVt42C6z5oe3Fp9OwCUTcbd722j7DK/l6ofUiOpKlBafRsEuzWBb1tNjJ +41W0poWJYshw3GtHkAsx/oz7OzVHunYV+TK3lhbjuWXTncSM+GB8BtU7G633+BLdWwMJJCJWZu2L +Iv3DsDXSP92fdT3CduEp1LXlkQClt/3V8MCh1/sYLRsd4iLGhM7Ah33yOe43+sqPg0cDOp5+/mF7 +d/OP4eHWPnl8QWu/ff9+w/Bb+E6j1RA/8YoY2C+VFXkQVtwKXoiLdgVB7Bf/CqaIm2jFYzz2X0Bz +bLdvQIWsm38FlgTzEQAqr0Yn4FuCqQoYmWDuVqTN1moGwM40ugHrE8x0wAxtzf0KPVqdRsAuBb8z +oU9btxWQU9PpBdBV8JcBvLX1uwEEFvx3AJKFGCDg0V5DiABnCxFIgMSFKCZA67bR0ETmhWAqgPpC +QBYwgdvAboUWzqAwgBJjPLmCG0Nc+tsOJBnC24CxDGHyn3WfwmWGIDsgOkOgHpChuw== + + + eD8ATEPaEECqMfVYMa7bFCZgZUMqFGC2IZ2KON5dWhaPWrO7ABgOCWLAHW8TzYBfXhPWiIH++ohd +8rw5aknCJ5w75O8TBL5P/1cMeUz/A/w8lCICjH1b0ghw+LU0EgH1o6oS8fi7okxA84faThgImGWh +ME+wqyrFuQQcYxhnGNWrMAyxLX7FoYq1iBYHM9ZCXBzweCnjxfmQtQoYZ0zWSmIYUdlWJJdBl1DX +DKMyoTYaRm5eS6thYidUZsPUz6zlzlmhXQE4ThqtdeQ4rbTWouPU066mHWem1tp4GLsKZfUwvrUt +z4cxsFDdj5Nka4cgTqTtOg3xPGvHIg7HrV2POGS3657EYb21CxMH/tZOThwc3HWE6tC3gVCleiNs +6SzpqcUFd6Ea3WJ3SnGYvrU9/9X7tsfFigaDYS9wRPVrqwxW6AJdjxlRQBKx3VZpcmBLd8069Fwl +Q2Zmw+K1Fpt+vHt6iR53nndsHBKXE8+uXccZomXfGRkbF5uXtUMSRtTK0Hvb9EAV4Zw0iwgqIUBp +JfZSqwpotmROpPjo9qz92Ja6ZtLB4FGl23V141nW5nC8k7XBHJ9obVT/2L6ZteH9eK9ru1xzMeGz +rG33+GnXzv1jZewa/3FhrQCCuDhXDEJc4zssQ9wrKyYi7rcVVvH1wC/P5CPDL2PChbHuSix8XChZ +rUviT8NpKVW4KENDvl0to7SoAaojnss+1KlGoIVZPm1eWDqQMjVom/B35uUPHPx6hG/yQ5Q5PH6m +uRVOA9cjoSiy9wQVdj1pLhfuikACbKkq+knp7H5ph7Pc3igueCjCiPU+zJNABGIHiGBg8zjrEf45 +x9sIP48v8nbcgogboJn56ns8P+I//2Gg+xmLP6gFCShpCxnBTIvKLXx28op4EPStqvWcSWXNUekq +h28gc3/lytfzDxQi9AO7R/qxP0btbv8roRvICsAji9JpuV484P2uf4zS1ftBtTg1nYWFZjTahkzI +ggf0PVHws8zmft4/liaR4CezFeVRepSaz2FfXC29+Ov1vYU7+Or1/3j/WgfLyywMpBwJkMRms5HY +wAYJlOVQ93VdI1k4ZMgkuuL/dZWRxyV1z88TCfT9IiXw16CJ0MDg18N5kFsQRxJcTCVuF/wgYsX4 +QUtmzz1KKJxl2brxRtbdHx9oZ0TW1xLOEl/sYsW+/D7L5ltXKEMMqqd1CFMu50qOR/UiHQkwuALT +PEaREI4krKDmWHN//oExEP0CgtVS3rbf5lfLotxccD1ivfEfO7PBbEUTB0WCesZ5w962UKJETPbW +E+61Pp/AYgiqGgxdFHPPj2Gwt/0bfx7f8HoLX36DuQWhBzTTlal+oimy83PmQqnQUIyyeCF+f9U7 +gCYzQEWECgTOgm5okCkoVgkW36SMRyU/tQPScNNgpgfm+ipeaDso2jbH46mZgCyDSgS2KlExJfRW +UR5ct0qtloEAi7Yjkjmovg9pJdtMpe2AGhR0VhuTRohSuNTa4eQtFqVCKKojZPwgiT7BATELYhtC +iJ/Lb0UccRA+P8Ce69NaaEuhzULbK8vwUpvI0qG+BGbozXGFKEEjf+t1E7joLLmFI00E2bxiwY0H +SzQ3I8iDfVKaX87tfTtbXIWf2s4reG8Rm3iTsK36/IhPiUaaoTZZUXL0CYHBNolWsFHy8M6A12SS +1/zZeeqy9Ho62MxeQ3t6FowOoSRpGPHcw7WorWrmpnnCN39VVZWVpLYAhuv1OnXGIvpM2tef3Day +q4TDShYlZLM+PmNhKrldNGbr84Whx6Qn1nfqn7zv5ho9tAmb5yzrd1PayI1CIHq0zafvk6LvgkT8 +sxXUboeeY/6Rs4wLsQ26q4PKKjs3LOaWnVM9oSckcvLdpqBThxVE9qaeabO5WneQO6dB7/axL8PD +7na12YpL0rKJLL5tbIPE/8CwtIqidDQvuY5uO0HWHf3pBIT85bOEG0E7Er1gCVX3a/M8hD5y5Jbq +lFFLiq+D8IdxiILaueZC11dapXaXVJc4dKX10+wSrfiJC60xFoF81kdcJQUSRzJbBs7qvVltsGTR +t+Q90ISaq+39wWETG83k9wVfkoOjzG1A1r3ZOLl5o7OCbR6dn7jv1ORjhCSDKbk+4t61K6l8Zele +B+oWbQDgM+IU2qNlMpcGU5Jdn4vBGqC+0QhJlFV4veRYuGnDjsHASlWXwGg653fLF34ejOd6B8EG +bx9kmvDwHoLRD+8yOI/tN1l9UPi0qxebi2J1gdslFTxpWJrBG6+rOzj17SYJwUHYbCGuCBt2fdLt +vg9Bzmo/voyTvoi1MGPikDw+/H/++P/9YU+KepX/NA5JP0mCiqosAwXd3i+aX/7j9R9h6YQtuhwq +fJrxP6/i5V9L788+Bb5eeDr/8ye69v+/IOt8e9E75s74ov/umDoD9fuWqTNw6wemzsCtH5g6I7f+ +jqlz5dYPRJ2BXD8Qda7k+huezkCtv/J0Bmb9V57OQKg/eTq/fpmfEulveToDkX7g6VyJ9ANNZyDS +33J2BiL9wNk5ifQDVWdg1N9SdTqlfuDnDJT6gWkzUOpviToDpf7mPO+U+oGwM1Dqbwk7A6V+IOwM +lPqBsDNQ6m8JOwO3fiTsXLn1A2HnyrH/Rti5UuuvhJ2BWT8QdgZm/S1hZ2DWD4Sdk1l/8nR+vTl+ +e9lGbzKgmS4T08cWSTD2sVfchev34AjUo0VgtSrugmexhcng6VlajYq7UJ94V4Ug7Lj2irtJCk9m +BRq4Z/p3q+Iuhkc98sbgaN8o7qYJgrDtjLr0KLovkrsJ2LOFb7ammH6rUXKX+W693aC0C4xYLC58 +7kebZkjuHtmrUSSXGcu4Su5aPjSYI5iUxv6ukrvcm9twy3yOwQczJXehVfBFmxlMzxvxXW6BAClo +7h4j8AJSniaBaNDclbYZFfaOfmndaO7CsUuiX/URNpK7qI/KU/VE33dcaJXcTd1DPFtWttPSRnI3 +sT5402YKSNaj9u56hF9pFeHFxOKczAR2qScHEV4zXhJWM0/XBXIMaryl+uxCxfJO8xbUeMk+mKms +BHQYr0WXl9FqIOe1sr43wrzrjvztD79SmPdNdxX4dmNuq+91eW1DvsnyooOxKslaHPkmJNteVHmz +EJASki3QsqDGQJH+XlV57RVW0XlN2doMHjPK1u4u9tDkPZDUsnzom709Bk7BfeKIrp0oL474VZO3 +9Z9+NJfkrbZyj86TYdfMZJm7Bcn0x1/3ZA893qa5POR/kYtR8RpfkH+dHu9ny+LvgMX/14hwRb27 +neeLipKr54uKkqvnC4qSW88XFCWD55uKksHhDUXJrZsLkpLBzQVJyenmopLkzs09JCVXN7dKSgYv +FyQlt14uSEoGdxfFJYe7C5qSO28XNSVXbxc1JRdvFyUld94uSkqu3i5KSq6+LGpL7rxdFJlcvV0U +mVy9XVSb3Hm7qDa5eruoO7n6u6834i9yeNMevFQ8or+LupNfyU6Wj3e1RIvPn7KTlnDV03Xa3d9Z +zkcQHmQn7VahfXkoMzaAy0GZcXOtF9FJMKXt41uVikyhfgbhUf9MdfIr0clPHsxFJ4nZLCt+urtK +pz1qTv7u53ooTgJhtMOezg5k9wEv4a+SrPlsSfy78XVqv+yE0sQTUBmBvm1Z5LoRSqvH99IZEqzU +mPNGKM2sn2jjLN0/xSK1VUqrloACB7B79snKxzjbIAwIAmlhlu9VIM0MjzgkLVA2C3tuBNJ4EqrD +9iRdCpFBIE3oVo2jm/U6p5T6qpDGyL8eLzkHRhBI48bFGnDADrjRR6O1oge5MrHdJ/poMsmZ+00+ +xhX00eqQTEkZlrt7o49W0dpkXtOyKs2wbfXRahpXotpXzo0+Gvp+atUV2+Mt7SBNC0nDVh9NJAaa ++7Qd20qURysDPgjq7Jir4U0njRktl0wBnNvLXifNh5CaDyEBOg86aQwIuXjKTdZdok7adpP8lOvZ +yUp9exTYX+Lojczxz4ijfZvqXnMn7OW9QKgTyJjpuj4RSHu/HJUpTs5sZGJIy6JLi1d/1+U6lZTv +luofGkQaxjk83k4m7fc+3kYq7a/3fH8FvbSvlsjfgfv5/YJp9qmxkRb/N5S81Dy5CCXtBR6ADz6w +190Mg/n5ZJ7mTH5Wtj+efjRa+DivfRnzL66PhhKRnYy/OJfZBjhF51H47MNSGPF8MUHObIeZLjOh +wIku6TOCnOj91hBsdsBUGcKYzSz14XBHipegDMlEHk1iH8CqmrFxBIZwh53o9vRuNG1hi2KoaCuw +pu7IZFERZRCNZnu6m0rjffjIAhOekHnZ+5tQo+otZMat8EOCcdyOavV2NMEzaWIbwmPAZ/BqjITD +Bn3Y26Z2DaASUUm7gwLcf5x/THYc0PmCh2wTD0lpobsPkAU9LATLkOtQQWWss5A03C+N+w4rDZ8i +n3TAh8e+VAzHLW5/28eHWC8LETGZAF6cxsT+9uU3brf3XejT5S1A+SbfflLqL8/3BwqxOfChMFO7 +f/0kXnKAgLCPtvmMpEJ4H0p3SSjrdSnYLZxaLKSK9ycrygK9w5ssTF9dm5VJYEOf3wIb8N6bRc1P +ND9NCeoT/OvmNFClEblb7HLridZbIdLjJZtZLCKTCU/kc+UzQnt/HzT1EUamqd8U4K3vlPi+aHag +5pOwI3wbhqwa98h0xYQ6hE8LMKDoPi1SUBi0ro4KVYrOY1aGWdWwyirhKaO9FnzdpT1X2eFICSao +QUqIemFZ3DT0nHs9p/aKylPvizkPus2Tjirsq/DzsDfD9cMe395+MBXhNQQrE15lsFbbTxKsXvi0 +wXKG5REt8MvqmnY7LMlo8tdl/ZXnmK0xgBX306W5oB16drDFquQHva7b4u5dWdt5mRwA50MZjRn4 +fIrJgm67OdPuROEiLrLQOuvR+b56hQkKIhe0UVWnqX7QfdqwVU0b5jJKIhCwM0RkQQkohqKKm6jC +zXnaK6OXfTv1RM/maP1WRLVcAOlJfuJ2hhwgEnhbgRh1iqqRVL+QiGJoZZu9YG4W2CVVfHQSNI5K +peviRTDiZv9BPYhpbclGgKu6VUPFFLEVeJLCaOmRx5PUoQgAYeel05ywlFsofjmRP89/a3C2F4cF +3xS87DYLRpHWrqqPnYQEEVPSS8ZF4TtitNevsyhIYMX9Qo1ybBcfsdYpXqOOT2tuoPBpTz4FHeAM +ZLzBDlp9YLegKlrUDB6v7BwQRBgs9G06QBT8RYVB0VXtBL9qjUqHV/+cp7rhs4r3mm+tAqRQT5+b +Y/rcbHoGYepXOv0TWjhNE1lPztgzwKlD8PVr8ttXjW35bCUMecxW9urE9I5FUfH2VOXUcizCdKqE +45mu5riHBk2/sNd2Hvn5quEzsY3XJioCs0g6TxkbAxyLJG2+2jq/O+N61nK4jVnLqcDgKI5/pkXt +2Rb4PdCi91BSPoaScv4IKQzZgX0BqOPM9Z+aO2IwkVGQxNi9Le2tHDXpLYkl1Jz2pQ== + + + bK/n33e1b6IVURU/J77rZ5LUSrUul+NtRBi/9+HgNiuQ8xcK1ztV6l/2cOqLUYuC684inl9a5dut +jF+fZv3Dt+IMOuU/ffyX/26//p///PEPf/zjf/3x41/+9N/+1//+Hxz8t07IPpFjBXelSk8TH8Ct +KJ/BVCo9lF69C5aSOVX6B50uZxsBFaBPM5aa/YJmphxYjyyDQb0PZRxG28QUWyxCIZi09+I8LKV+ +z2BhEs3wY3Qu4B7MPlOnAMdMmrnOJHJ1Bhxv8kW64k5N5ho4lZVy2smFh87OCcsI8Ogghd9SlsIH +gVO64CYVAxHdMG7ldpbEQwzft5AeQHvNbULkYp4Z6Bwz3mmQxXCBruVaz5brkJlJamTI/Vb5+tMr +o4xVmEdNmY5UGkxHzIcRTVHjU/8kZXqI4/zZociU5Q7REhWme7PeuiaoquUPSRLByZHM5mrEK1so +G3MH9r/ig4TGZjA/aayZflB1gLkYC244HWCYETmiaixYNHulcL4wiIYTYxCtKzy8XBnFQqcqHl97 +1SeaL7XR6fDbL0TN6M6bpy2D/SQNqMZZs1pBl4p9iFYfhDmF3lQX6z5kPbDuV2GfedUMeyaBtFwp +xM7qeke2ZJJI9QDFXc78lAGMIR3ipPEdW5hUxVakdd3+5VsGfjzGQyq1UAHDhueTAeRGmfVuql2z +cG2RITmCWyuDHx9GZTHnWahdDuqrFhoQKkHrXFz+4iBCSpJgGoLf9l6FzpJIxuGrW4JQtnug35WK +DQPh3HcDGpiokeYhwgBzEiIMxRMZepckMmlOtIVIgkq3zn9A53MpRBBjLUCD4/Bas7lmCGozJWB1 +XQ+pu4B7qi52Td/nBtNtjuERjIhS0IIAC2UuJ4XldZrHOvqQhPBI7mTgrjh9W8cO0FSSrlD13iTB +oMRRpGjEOB8twRn8KlCV5FJq8j4wmIBvp591J9cDFDMbsIycnQ36rqItA0DhL1WzChY6sVjiEYKJ +QIbHHgLkkcvmNCjriJqs4gqdXs2+Br22XKSbE46wRNAMFCakm2sc1wkHdefzhH75ck06jBbjllVW +aj2gnyPYBilODwTCXcJkCHdrea4FWyqsBR5C1lCUNPYOTtebHSxo5iFJ7akSXBKrm3/A7ICBwBLa +svfbn39MZFMAsIkmNSV6u6QDXQ2n/DKj1318lPsUsPA4nWMri2ML3pLzsaJ83VlecUogyYwqM5Vm +QeHQkQjGrSSEJgKknhgNsfCkzOyDwlJNEMOgJ9keuGX0yBfOy7e47QgoICzNBQstWRY8oN3MVZTs +3E5yZ0c4rwUC9bbXLfQjV+u+R3z1Z6rhzvje2KlQfZH6+XeGcfHSdz5VrjkgMxXf1lkpJUnV5BDd +odkzPTMcfdS6EUyzsOmfxnpR+6qBHxclze1aKhkMZnERIbPUSc/dBvWPPTtUMnY3ybEqRXZL4kjO +qcsnx4vD7yjzymchJ6rVfyXWVHHfAIoFyZFPnzZkR/uFkkuMKfvvo/IhR2cG6xhMPbYsmWvKLJen ++6eTXc3IHGRxZjWLroRplwqz5c7Y4Ury2F3xRPkDWLL7HliHLOW8Dg536HrkoUbQB2rFHLtP9YiA +Pol7976wJOReVBtK8ZqNZT10tsG5QwIt9R3NhVfh6avIbMi2ILOZIHyeV/kf4/ZOeZ9d/sTOd18D +F9gck2EfUCTWrHR8J/4t+8eBUck+Dt/wFlJCWVnGrgzmJpZl6k5e5r4TRDbKN9co8MH5IgZ22ygN +4HhWHcKtvqph91jqmHZbS2NDJCd7abhUFBgsxZE8xeHEdNxWJ0Jk3ZEAQGZ2iAOE7SUoED3j00mp +RLGTuxDlI2qqovzx2Ee6b7e5SJGXZSTU5DPVjzWXJL4Z3SgpMsuhyCs1H7PmGcXfS89L2gZs77Hh +qA/KztC3pfV32Lc44EBjsdJDb/gyEPHYQG86uk+qrrKXWvVTUBEWVa79QsvXrDgpub+yOuSOOkCP +y6k0IUu6eQs+8C4WFstA+PDSmNIULUPjmsSwuFrDVNQEsKxSytADiQHCge0ynEr5RV9a9e19cVmY +dkt1t4wjoNSSfAABhTDmxNNNkoWHGBcP8rXmhG4ntD2H7eGSnyWmQ0P89GNVh2INxLrRzT+w+ujc +4BTtBdWUVTO6z9GAHfYU1ZURWNXTZTRBdZyDwC7pScxQ2Ce28wDRt09OgtglZ1id1McsWtOzhiOu +6k1ckBL2Uf2dhaPW5+Xrab4RAahW666cNigNbNGePr9+e5yJ1lutcxXUUXQzByqVg3AeRitgSLL/ +tXWRNvcSjtg+UzgqvBvCL4i6O9eWYV7fbz2E57HosMIj+dl3GsaqM1ArJYz1e0PodgBZpiaBpZ5L +hRa/+KVtr2NGtusMtVudn4nko2/Wq6VUfgQ15Zo2a95cg0J5y/4KSdh267Aj6Up0pWu7LVir41GW +vWtRkr/JKubhzywAWOCyMSCQ4ennFprls25sEJhlhGGU9Z7n3pbdcMGAkVstIdKS7Y42VI2BoTAS +TPAlMtYzWvCE/6Y6f9YK2e3D+CfoCqmcW2By5XZ/4jt4FhYVzwIUdPU80F9KjWd1WheSDLnvXR26 +sRqCXj0ltF6S8ll8LA0scSpuPLQmq88S/btKlpuAAH3iq+3DCcql96B2fotGKH9Pzue3QIY0E4j5 +Ng7qYtnahFGaPrruGIHZezvrtY/f7sFxvwZ/aSbFFsXYoqybANJiYPGomskBCRQDUX1tCD51VBqy +BSGghQqRiWUzHdITXsJieOSoCVwwlq5RtXg/6yYg13Od22AeLlJ6pojfZIpNISWwbW/b+IAY7nIV +xjWtyAOrJIL1XvfZSSpqQz1SGhJ57DOj0EJkhWwoHLFNpsJRIRfjbsgi8GgWYW7SOLjaqJ2g3ok/ +22aD2ecuQyppr0PhAfS5k2r/iwM2KW04KGTGiH/SGzjNUvJWY3YNPTPAMns9h3g1t0l6LuIQh4Mc +i7w5T0EbHMsvRp5dwQBK08GGEusNuX6Hvu9GvwBAS6xbwOapRX6gynVuah/Mp2vRFQqp9yc1FExs +kok1B3FtSjHZ57P49MXZLJZqDtTRcrmYoqElEItCCagnoQwlv55ibYmMHjHMUI0ym5Wd3ntTzLqG +dMJaAbPYpEgYZS2epWPo9QEWwVlua3Ce7dZH5e5muVGLW2t9zGPcOe9LhWcZN7FWGhslVtpBozZJ +/xz9yW1FEwF5j86XeqgF1Q3Kx1BJFQtN7m/1V1tmlxClS9GW1s5NBLKWe+Xjz32NGBJT10tYSsyQ +XaRrlqSZXGwctqtjn2KC7o/q96kJ9SvWy6+mlHNTa3/8xMvzuL/JkfdWz2cGrg/umdAFQKYQf7T2 +EFDIPidW6LX7gCcTUcsJJAf459rF0Ao6vruUHPOhJ+g0XALvtXrQBu5bbPgiaf8gQuiquVpUnQc5 +uSZ3fBFrOtpObgaAkWRbNs1BxnBxADKWFoC+bdMWhPSVLUhSNmahv0v1VdQq6CUAlmf9KKBxQLJi +ZTY2xK0n3RoCA0qBhLVHrzCZ+muDjU5qMc2/rZ3NMufzg+SVb+zwFUAujGnbTTlDPSPQAwGDUqwG +j0W4TBnWkb3aKgelbRgVhJqjZ3of4maaqjjj+GvI/5mpsxCofDyugBYjDAEASQCpPO7LTIalI74p +5kPY/lYCcCT3FI9Hv8ZUEpQYZq0phc3XdVPMh3cEJ8SEw3y/ImtGgiMRZl3Pr8ItERMdzC6P8dfx +Je/i/gz4eIYCc3x6xsoJUGA8PRlsmutE8+ZY//tS//7H2A+1OIu7lAJsE6BE9FiLV3VyQPP1lvG3 +zVK+msMLDlK9Ebw+dsKFsBg3mUSNP3cOMggJZmfbzwdDiHO/QWwOuA3khL2BNMNN7VK4yAGQgShB +UuBhADgdrN1j30NWj0eyp2HQtb/tfFQ2mFi8VNex2GhaFTEVZMHVD2D+D1sk9RDklixquduIqIfZ +ggGd3G2aN3QTRD8N6y+py7CJlcHI4Z81dDc2hAypBEYQKIQCgxxvWl5ILEAeEFyLOHOaae61IG1i +95rm3p/GnQHdjDKBBY4oqE1vgMoHzzk8R9Xx0BFDfuMWdnoZ/oYA3nRHzO+zZ+zTAAe5Hk5M7OSV +YWAQEyPvn65P0i3kU/YfUKVPF8n3MWvBQkzSzY4e1ha3RjQwgNfwsNNBs47N4xXWcSJRGB7dnsL2 +JqkICau91xkGVMKAG0EGe4QypJ1n8KCleDLYcbqnCXEH0hJoNyAtwVB6DF/gNyevYwo5D960GAWx ++3UhqaH0jzWQYo1cSMNYEi6t8RCP8YTMoFx0G2xPPeKkt7iuKm9i+ZuNQV8gxIYQPzTJaaOgwCPN +0PJOTtgCMHrGe2tgqvecEB9oHc//EYJbODQS0/n40/PMMUgOR/wYkeVbsL05zxKw82lhjbqkn3Jc +uyOoyIvf1BL1/kng73ot4teD18HrOSJ8iX9Y0paKgFRnqsVuOw82lJD+YHbIXS9NDR45JlpVKR/x +lAstbo6gSJNE9MLav/epmChqYPCndA+N/0wCoYBB1wK2bALRkEFiVRiuuiRCMcLlkIliDqmqXVAR +VIbn1myWI8yNFY4gpJiZMFIP9WLq4bCANPv5Z/osGhtbXTPPhlSECAari9DLmqRDFt1ZhUgjl5Qf +3/Ut1YdfB60Y+HXgX4slAyknILsCKSLaEupdraUHGEaoS4o9B/qlUbQw2/cdZgcG4sG+zEIHug50 +NRBAtrv1u5vVEf4oZ8B+xTPPeorUCmjjolYAU9qswogM5OkMqdjAV3LqJPaSoI2bNR6nOmniBEHi +axaG+He1Du3fy6RhG8WkKk0VyE8EqPuYxScoPBiBhooIAd1HxaqiRZwZQ+VPg6NnlLmgjyebQ8mG +T/0x62LV/o9DHic1WLof1TQYR8BQELbAhOleZNTgoDlx32MxUJqVyJfqHXQngDqhJ2+k9qEIqHd1 +P0ovb5XDyiuwjGfWGvnSriJiv2KKc1YouYzlwHiWBte5hwFe1uRHGdZIWx4FjPSsg+rKoET5SjRp +1yqqLlezLgfHgxcLlmKs6NPhTYdoAcaIWceFCKspGDIzRxwVysCKhdhF0OEfY2Zw1pDFgVWIttBa +4c2t5Wd41c3eS+4DDx+q2BINqXDDtxPCm/EASzEcwn9fEjmBXP0IBXV4SdAjsm2LH0uhLg9FirkF +VlxFAHOY2aWqX0H8Y/PWhgDvuWkV2XriBta+AixXc42sXYmqWc3EV1RfNfY/IE2pihHBz5Z7cwR0 +A4TYcAn0ke7Ho9anDN0aiGAK6xMmkAoD0dr1qUAF4ByEbDyfs0OydI/iedYOVLyXcMT2mcJR4d2s +XbX4ftfu3NvXWXp74dMuTcHHmlhbivsltbYm48pc25txda9t0v0uWdutcbOtDdu4YdfG736/L/3j +aDbWFnS0OEsne2u31n74av1CSz3YzdCa31rd0OIPRjugA6aZn5iCV5ewAhGiQxkYhg== + + + 4IoCBGLryQKUIjjCAMcIPjSgOrYeeIJCgt8OeJLV4wdYyjZcCPCWEGwEiEyIUwLU5iW4CUCdEBEF +sE8IplbM0DYUC9CjEMgF+FIIAQMMKoSSv+3gVDEkXWFZIbT988DRvMG7YoC8QsRmSB3wZdtAPODU +QhgfsG4xFVghc/uUYkXchcxkYPViKjP/sM2E5h9DIrVCCmMytiIT90ndCnCMyeGKkfyJI7b5aTxq +zXMX1GdMlVfw6D7lXkGo8TwrkDWm/wEQu6sirLjaWINYsbmxjrFifPf1kBUrHOsqAW4cSjMranlb +4RmY57U+FNDSscQ0wNbbwlTAaoe61gr3DgWxiBrf1dMC6DzU5QJwfa3oBfz7th4YcPShnBgg+LMA +uQL4d0XLdQpg1DnD+MBaFw3DB9uqaphhCEXZOf4QyrhhemJbBQ5TGKGGHOY3ZtU5jH9sS9VheiRU +usMESiiShzmWbY09nmcU5ufcTKjgh7GbbQMgTO+E/kGcAFo6D3GQaNe3yMlVhKE97OqyrP0PPSKh +NI/IUl47JwrB9DlpuxI3bNouWfQ06Esit8u6Xps2jNWLHqjgs2ps9yAcQrCCcEiFRWvXK5IGFnPf +RePEJXaaFHnCvmef3FH9a5OKiMtjXLsPouG1wzUDQ3W/1rYYnPy3NAe8h0Yow7P5ULSmhe/Yecsq +fN2xVwfqSeSFcIerp7Zr9T1+vrYG45XXruLjftde5I/Xp1w7mPEdrQ3Qf/rDAF2/veu1fxq/19p5 +jZ9917gNq2dt+4YFGBrGYR2/tpnXXbC2puM+WnvaXw/28Ryr7CKm7BTvewMzccXPr3HAfIwMwAwl +BOisA1H8WXgCh5T0Jgtv0Q6waNd1j7LA8xDB4KrSBR7v8Qc9tTk36UJU6JuB+sxfwUeFnZFYhlal +RcpiXuziBzZLrk79drHGH6PaIuoBWPT7R7wuXPZFuubmlUvb3PZ6hC/f9anDeeKbu8fqglmSCbov +v8Dzu2mAk4WmApkt0xPPRE/MltGf3v5ozkRVu7WU1W5tEMsLLumfbo7o+qmC2Z/4+S1eOmpHiZ7/ +88rhD8v9/hilp/ejYKyocHkj0S6id0CMOuJEulj8zwdJlAW55iLq5gnsFcPOiUQCr/lRghRzCVgZ +2uyb84x3F2/hkzf+4+3DINICane7g+yc5udT/PxdyfxmBcI6J+DSbuHBGyr6jvWPcNeJ+25d8jBi +lfTJ6nr+ynfZ4/RjOz7u5WXvPm58/NvzCRfT8Ol7Wdf1shQA/VJg+tP2jze3tPn4iCvibW9qKL2c +uyNu/XS7wDc/94//vOD47+PufrzsOriDE/2RbLlUZiJnXXRiBhYu2uKSzeYTbhlSwQL/1WBxCVsg +nCW8uXAfn7zbuYIpVfS8cf5/GgUXr0HQXL82a4hsX+SAKFSAaZbUEPypSA2BqExiWiRjPAith96e +/Be8M9fMaQ/JPNzomGj6lydRmgXFQHW5BmXGpH39VjipUnSXis42ZpMIQxKVJtIvVQcJS39kKnZV +Kbk4LwHoo6nBERgHO0JCUCoLK3HrkI4w6YesPKy+B9pE4/bDQwKDR8n9AMUMILSdTiIFPuFUeGf5 +BezPUCqwT706UIuqA5lq23EIi0k8nNIcOSF0AJCnqQDpWSAskESLgnCDaFEqYGkwG0mKlmopW8Kb +IOogrnRDlCikjAS8gYm+OMoSeTKwoTdDJu51bfyv+ggU0y6XYIJuGrXnrcPJFqegx2vxFWyhY0V3 +bzgC5PC0ZjlL8ppkt5BP0Jp4H0lC9XZEIh785HkAUZPVo7gkFIy/jHJ52cmytyz0ZniNSlx5EZAj +Yfu3X4FaHHgT+3CaDw0fs3QX1LKEyGU71/WAAhc9F5Kse7+oCsZ4syILvd5uP4Vfb6zZ91Wdiby5 +Pdv6tXyyOYprpjjxEg5i7qhibpBY1T7QkZUOLXtxfbjtjkYIjSo7fVfIPINhsDxTmAnbN02o/2Bc +lO7RfK6FIm48YgIVvjjPeiuQMKG8coi8/44PRISgex3M7/6+1teicAHssp280fYLb5Sm3rn7HrtM +I35XMRQ1pxq7XT7ndObSg1LtIaHwFtaSmmqkgNQH6rz75RFpzDAIQ9mCilVY0j2p+wUlHNomYWOQ +qNDMI1F5tJPiBlPf6oTcFuWc+hF2Jmy+QMPDvu5thBMW0AEI9H292Acw4kLwp4Pxq49gYKD+Farb +Nq/ZoU2TF2CydKLMih9TgymYu3ie1WSGWwmWd/tEwW7PFzItfXiDq6PYf4ngcNYPGnxWWBLB9W1X +VnChYX0GN7wu7OnDt9sieP65q0LMEDZkeMTtxg4xTLAPX8dBn4VRWKi/kdDgvRMavMW75OqOPCST +YsjeCNagF2f+4j+EBv/OhAYpdxfXi7g0S1Zo0zOClBN4ca/N0IwhdEGLU9MlFMk1FGkf9ejOVePV +7qvRItZoiE/xXFDauX6GynBw+NOUQpP2mGw+VFKLui+ELT5ZQgUOVRNtaHaEM3WAnaCcapYhST+r +js4RrO3F+TGKaA1tx45gkPMfNAIQm2ia40nOCJuh9mM2+Cgu+lwvADenJgObSErhfbRF9Y86Tx99 +BbTCKOoggABbXYYWVTIeX7zPKTVIedwPpFt8uHJJv6Q4YjbOnuxPo7fubQC4pamZq28naYWEHMZH +5k1Bs0fcJloiyBA75IKWn53Nqz9Ojye8UpY4C5AVO8IO6c82gPDAcIKS0MHHSAMeVu2K5qM9wHd0 +ue08iK80v2MkQ4SS0ZXKeD0W4h4MorZsxqo+qRnArVKZL1KYOQREUtPgOLwxhagg/YBb9BO4MWZw +j3PIhJg7K5rkHjNSJYGyGS0TVqlZAVYp02MvPx/8i0O8XPVYNCVvRSm3i9BIl3dHHMjV/Uuh/CZC +yuZD1PZmrvZ/2Hu7XtuS6zzvF+g/7JsAUgAfzfqeM3fiiWIzoWFBFmILRtBgmm25E5FNUC0K+vce +zzNqrn16rd1qCqCRm1gSzbOr1vysWTVqjPfDwaMStY9+qDERX7Igg0KZdOp6Ixe6oX27IVeYmFjv +6/iSSDQ+2ZdXiFkQZa1ntqxn8qZhW+OBC9uafCGKnqmwSBxFJBXfmMRQ67i7PKImpCS0semqcNoA +8MMHiK0Caw3rrsTphgsBu4PL+7gS7N6vfMzwml3/q6YRWymrlpRNNe8fU32NA1T4/PVKM8euO850 +4C1Yh6SThgiXn/oIPn/xuYgsBEd7lDRasCgSmxhLNH4uMbmsGPMXSXHM0FFpp8Z9Qb8lEyq5D5lX +bMYw58GLh4DTq4jQFp1eaPqWCkpEDSAqM5GM8iBgngOYTJHln8zwQ0eKCjpxKlpcIGo7yVjHr1gn +rCyMTnO9qyydMcqxD1GGpdLEA810J+hYx2GlUPAOKcx5EbekDq84GOAhAI9gwPpcC2hytZmPLN4y +/7aeqk4pPBCD7VFjFNLHUFoRpsJ2aCWVS+Or2k7pBkvlpl4fHNKXRL2Xv988MW6N6iW3FnuXLlPS +0cqLGM4W41PqqJV0Y4Cyq6X7lW82YgZFfPF+uY86tjlUw9Ubf2nQdhqFWLNZTiL91KwMiEeTIIs/ +dwrkyhg9XW4wIn/YS+0dCLL70sv6zOWgsJVoaf8U3xTKqgVHAXnO6m3EwAIhYVVK9FejWk2w+Nwj +byCGrSWbGDHCLED1EbLCzmeGvNVj40RVIisxLkitWCxqSdnafDwYOPH89Kq8n08squwDI5S/Ziq5 +IYKqj4oTcIx13H0vOJZTv48s6f309/T5T/4/cAQcZtRjItiOgBdlWnBEDys7gAE95rOyrewuVj1c +0dH9PMGVkcMc8b1Vwk/46zG7U+GKqGQbAvZLtWY0cZv+qyd1ZWAmJ/Lxf9C5JvC0T4gg4/8Yq+q/ +waolDoOIw0mJ7QeGgDq7FEklaQgYc8/BVFv/0DsDYIJpPbbd3BmyCjFaccmNcfOzP96d4Q+KWOrE +2h61D+3DDegZw/+/H+Af7pH0P96ygg3tirXkYqVIZ4aP0utskpKy7l/TooKN6UHBW8GjkXrOkD50 +5znLLrLDtL/SH1g9bQLR1rP+E8+EKkw5UX6/Ucti0zCpY/SYsnNrXmStxJqVIvIYQmnEjMo2AOSp +wVA3O+gcTzrhPcFeUrV/OqYzVah4RRxHvKUQ85kNWZ+PUc2Wv0NOMoSJxb5kQSv9eOIKH3ojFPEp +fscHvW70GHUqKiPRi7pGOj6dlHY+Su5EfHWKGOb/3UBSBOiJsWY85gEN/vHztp83KR72G4/zARkF +VdjSVPlHLrft7FfDQ/384K4BKJmpK1PO+MvzwgC7ZXqsgy7++LlT6LYwBIZnfPD6+rF5hN2ky/sL +7zUV8OdGUX48XrSw0zi4Hro3vYy7xoopzHIcwj9exi5RJNtTcezlg+ztnVV9Os7KXUDE5GD03l6v +ZfWU5Yn931EA8b3eUyLqrUSWO6H3/ERUZQclEfsz6CAvDxXKrvZfYKgUhnp+NxHqT6r3YP76I3P4 +/I7X9ng/JKZkJfGHwwRfTo8zgCn2D4bb6jvFP0CHl8dw++FonXftdy7pKq8Dfc6P4QFkHdUfAlx1 +3mL9z1/Z49fPn+XriZ8/749vYE8OL/f/Mq+8PMOX+enDd3FPby+v8mVCfBkNrxPrB4PqZX5+GZuv +c/zz+P7JteLebf1IVq68/fnPvvvu72PF/flf/fL777/53W+++vk/fPXX3/z2m19+/82vWH1/sNq+ ++1z8yPHGkUv9lwf8y199+/13v4sF/Ndf/dU3v/s61uSv/o9v9ire3/7857FGv/bm//vl/x3r/ufv +fvvPX/3iu6//gN9w2d9/y+V89Tf//Ntvdm9M3uuPXtVf/OP33/3H3/7y629/83df/Z9/tlORL8/k +i87/9nff/VP2Q6yrFO0d5HP86Dn+5tu4j//07a++/2/5w/FjN/BXv/vm999+809xz3//Dz91LTzO +eDbffvMP70/mx3v/4pv/+v1X3/7mq//td9/95vuf6vw33/32qe9WMFxbwbD8y7f677759u/+2/d/ +4L3+9Xf/9A//6jf17z4clX/5J//TX/y8ffWXv/nV/mn++2ff/N23v9l/+V/e/vSvvvv1b3/5q+/+ +8Xd/9idf/HcRpUxWZMvAf74VKpdTB+Rl5og6qz1IgLiLHkf2KGxHZzde/Av/8z//05/8wAvmDiuj +5Z/95/8e//X/iT/+01s53v7923/5v463X+Uv//pO3X15Mc+n2r5lP3FBb7/4qNfLjf3iozP+Yb0+ +PONv/uC5Zr/an/3y6/+X1+roiW3F908h/heP8d2f4Hj7D8bjwIRQQZkt1sOILigzxayOewqLykmi +/LS0XlC7G5CfIC9N1I8qxhcRPbEJMKt+tJ1lfwOC90i282d/RdEsNl8TZYQrA3ZIKsQ3kFTMGF8z +FTJ+vRtZu06gx2T278ZuBrRBbo8IM5YpTFHwWKYB2TsbWK4wozgTwdUxnY4tPesQ5A== + + + HznWsfdAq4GwIZkuZaY+gtzHecbVQlSLLaAUIFZpckEUe5Txm7h+9H0C+G0SXFCxoLrd01MKM0x5 +r3QA+Y9XKEpM9MjFFO4jbAoPoe3TKXKZHpuC4EWM/JN8gogQ+lItgXLBqVfUoaYgPVxkJxZN2YMc +Gz2Ia7IH0m30mBuWBG6dLbTMgH40Y03yRMSI81SBCVt0WCCk9biByvNVSYIrqsJKCGdOouEDIBTq +fDATISXgzPrZV3EYM4DtOOWhcYHCtuY61gbLkFIAXIK2g4F1xjPz0yXQGX5uz5ANuEuEWpPMRgol +sUsgJ41xHOkoIx54DJOcXUlUaAbWnuS0umsqaoLfrmnqxw4GvO+sxi7nJ8AgYEZR8OSZ6TNrkXim +ma+dKsyi6MSNEB7tv5/Tamrsn7dlYKKJC/gzO5gIHBrRrcfhBxqdxCVwzOmlcVkMXKsE9hhD+kv8 +97xKJeYY2uWOz8iAE59deaI+9+FHagUKmG6574UYRRYtE3Srp6fSMRImTWiq4W4MjYPTQntVuNe/ +e9TRU3sS3HoTDJe/Idl2KucXw1bk1ZF29eRXy/iwR08SEwm9ti/6tdPaCIoDlbSdVUyf4z3cdVGC +rcEeo6ahcL6tp4a8/iutt15+NRNZxefbAOfzuGAWxZlzx6EDVX6IBTIU4S56mBHMxgXdY4ZexaTm +AfvVXgUDrAn3mn0JPRpPl/HG6BcMz3xTGIwJVqjWNdhgn4mKcBc6H7Qf+sDSpM+CsytyomoyxhQ4 +PEoMK26IMlZ2iMXLDqtnh2F0rs9yzR6nqIlJ/L9PhHnZdPYBwOsmITdasWZqDYze45jqPQ5rQqS/ +FTc4VtEX4rXHmXyvGMcY7u0zPfci/TsbrO8xtMoeW1uZZOKgQkwBMKn0CAd1VSXFdUHCaOyZnnvk +KIt3QpKd/G8qiz8fh+mdwtFE8ocF5ASh0d4bPhq8dxuEr6KbNCsCGLYTBg+bbnRKY6fcoOLIWGCs +xLcUIyshU7vDNIXmdMeH1HPFsUjJ0lCvzOQ7buI9xAtuKVoBo2zG1p6C7O+915nIF6UzmF3xPaz5 +a0oAvMWLtw8FGxg1BtVuu/iy1U+kMsc8Gz2SHQbXo5b9LFfiOqIX5RB7+Z1EL8ReU4Azp9B6Ip1j +j44oACZx0w7U5ugw0TzxROKN4hDxQvaX27ZAK1CaniuYZZdYwU6oWAyPTNjQ50pQn5ThyYcz0qnb +8g45j0FK57mHZzrnJscwhD46Duwy2Fuwyyi8o9ojph394AxRcJ8eGaIcewmmMSZvGgUL6fY281fc +mWReBHgIheaVDR8GUA+gsdyTTkIMiD0s50RZn7n7hcEd33MGXOeZ1MSV7HaBPLrNEWrA6eoIo0Hk +JIEyr/x4VI1TXAEuf6yd5dqeJFvRkbb4D9pm1nKv5N7E2ozZef46lTzIlzR7aMQePQ6ZiSgcwPeO +Hu2oefwIDSkYA1lq+0zTkUavA19PeonViF5w+t/ogcRF9Ijlg9WDHhQyo8fyRFMsFB26dGdOFFdB +B4TOt0hlccqGpNjQ5KPYgcgsTHo/vQ7yFWL5wnudWAmYl56UZ6/4FXbI3lSdVhwZEjKLRXpAQgXO +jCBKKFgNxmH4KrfhJELbSMo0tVJOrS2jBy6wuUSPgit5hYfFS4vHXZUxRye9d6Uc8zaYDq44a8RD +J1EQxVTIWkh0oOtoj52IzTWKqSCCZBo6hPc4aETT+VOLe2wmUO2+TyAfdaHmMkzBAe2jk8bgdKh9 +2OGUFU4Phxw+bGdegWy+RcjJos2JYNRxIiRF8kQQVSNEXyM5f2L4IQLHU5jSHFGzp2i02IOBLqNI +S3BFNf/kzf/UN3InhJC2YJGJK+ZVwkP4hNZefkToXhwowRwdyB+NEfJVBTHEPEdDofxUydyiHbBa +crBixeu3CuqCMQ0L+Yixd0AgSGBX18kUXYwD9nf+HUA3IDz/CVc/j4HSJ2H2WZFpIL4CQFWkIB9m +Wj/BY1WHwbg+nnFHU/1u8CgFVEKF/99KhrT7V0cSJUVoA1OqCN4ym8eIlKUMbLeAIIgv9RHS0niA +645G9pPtE0TG7q/8pKKhau3DSkWJ90oidRPece6jLJ086XwOKsVACUt2JvJHnKWoPxpR/drAfYVc +cKhFhqMpnnRf1PBTBEdewJCixuwePb7RWBEKnNX4mlBlYZAnJXah2ATmBWgGeqfH3qkhHY+zPUXr +i7YTaYYidxglemjwpHvflHiCDPzcMIC1rT2pvTTGN3pyDeAlBqT5mQXdeK3AqnJRELy/sLFcj4a8 +unjiMVOc7MwRJnr/FYgaufPagoNCRRfn5e+HkMs81g+b4oNRu4WHw8QDXIu5AicGP3vCT6Wsvlzz +gMGw5z3x1IBa/6krMUNDW/7Kn+BXnsfypk+kl950J95i6MoYSH040cGBa095OS+gS/o/EWe8bFhw +0g62uOydT7aPnhw9kT0qLl8+PGKEX7yfJcUjHS1O1FYA1vJI2vyoAXrBY5A9NUbgONUJjIs4OxRy +PbgXFLXYb0/328D72D/Eg6uPhtyux1KMbzMQ4Qthu/tXFaweDzS+MxhoAHkb6pzPDWNLoObhnhrj +XR4skOBIR6p7VPnK1N6l8Nduja6T7dncCY7SWQ5Ax6hT0vYbIF7z84tjUgZ6vBoYxbFonAnUGIoA +88g8nErBuKfHnoPFblAqUvuobskcpkKWOAomVaGulCUi28QfAApcW3YYoBuViBMxUriPV07bUCjx +rYBujLACr+2ABIxaki6/Wit3Bau96pxelxXCU+RzTTXrVfJXwLWj4VygVmjwg53AC/Lf926TvxF9 +0DlW9OkpvCUalAlxWVfRENWvbFB9J35Bjs6UQ9lzT0QZZJoRm+rsWwaodkY8ca2Vj6r0HZPSqj0X +lA8XszuCHKB/lA6IhzqYzoHOjfQtHWQTWARUf9H5iW1S3EbE4oD8TuDpWgAD6BkE+nzTMfMPjbEY +ZfsDobGwA2BZ15L0BAd/+ivTYsxbXf8hcB3Ibs+MCiePomElRkbh3Iebe0VEOikPQs4y+kKZoYGw +zgZVkeK063JZpiS6jxFvA1JzfICzaqr2SRv3AUCIsRQvmlwD9z2oAMe2SL2IBqq0l00eVdMK1Y5Y +wKZLaGGl5yhVxSYQhkhW7QUhYuCc5SYKHTBhY7XZsSdtMCJoQ5uNxpOPwgYUz8hrKaMrXmxkA3sO +64nMcnK6+/vhDic3aAHZmSdGZyqGPJ6xDw9kkobV1c5TPOZ+dSZXZ9Hmm2FnbDPUSak8J2HarDaV +Zf+lYUPU7uf1gzagmAeo9n6osnBicoPADmKUCtUAtvbqa89FIy6xg+h56eEJEPOFiszjYB14PQ5Y +KbK3i2LykVK2SBaQGJ5sJWOyjDuJjdKCOjb621VyUH62lneqxq/ozEitVcCVMZHucPcAfjDTBgjA +9oIp0LmBmupF8ySNvF57eANIG5BZmkzN/YPDYL2Rb/EUvINCFzv0l4aF+kc9H2PhB43xIi4il4HQ +DKgC9tHd3AAapNEAGhOZlZghWn3/u0eLOGjE9u5UaJ26/f0j5IVU5Yq3eJK3Z1o/P2jAjr3U+3DP +jVhuxAw2SDpfuAodzBpD44UJco7LPR8N95snX8CbZ+P4xa9i+YylAd2oxZ1AvEcQbAASYw1C8IYw +Ha3GcY9UEWR8p+SMY5iwYaaYbIMfC3uriGYHPGNHwJW1i2iYnU99UnI/H4ez4kH2vsSmlsZjFH+l +IlpcIVAJG9qR5zFEmCTS8+pcIfNw8YQqYwks23n58QF8GIjjKL5xNbbTNFzOhX4Yc38YLFW7IQ9X +BXS/d2axZddAANiNdjrJ9dcGQs5yX9RzI3EM91qYX9jqHqgAOPG4QnG16ICiJXcqV7UbPBwq187Q +KIC19x/VaVISsYhK+p6cJHPeSwO8r+N+Ys+Ni1wtiy96a2x3py4oJ6r4SbQ5rtTxWTEKWsrl23AP +2dy9p9jU3UYaRY2pFWMRcHicZrz+leixbmeul0amQgdUnMOXvBqlGPRwIhwYvGTQ3sIkJNA9GvJG +wR/TuKpi1I9fwWOKcCM+nZq2Zqy1MQ8NwMbE0LE1rsnME0mf0xFBW3xs0Qb9zzb2DjQAWD7N85B/ +24+zXRn0Y06lYdUA0bceR4OzQWMR/9LvWejS84WGgy1L67m1zl+cNqTJYawC4742RiXfeudLRNNq +P7i2JA+fiDCyTU2N5zha75/4nFA3PBAgvRtyijxNebLSxZD88lfXHoiF9Ed7o1h2Mq5fGsgLt/4I +MH7YSKJvRyWxh0KulaQ/1J4MIrk6Nb2nvA601D5NdiV5uH6v0biTZWPEg/5K9b2JiyLrGYnQ5t9j +y88/r0e44t8MMGDAwGfKTa8HWaw6aFjFqdmCdAOMvu8CSaLZbFj3UBsldxaT8xdfACp6b8SO7izI +x7q5Rlvs/KiB1edeo54bu7CvjCjUAwXfHJuMN/Gm12iGiSTz4/IO1RMfLY8BEistA6SCFnz/XcNg +UUHNw9RHKRnhxwxgUe1EPr8qP2b+Idd+WEqnWUlSz+SRcpvFXM2qz1w9SVmeOwUxqGdzBaSEI7J5 +NHx9p25Jiy+UmuJruBvJ+Kinciqn6cc1Ynv92vDl9PvSiHziiX4XcG1qMgvZrHiuZ8wrrFwxa+K+ +MgnJ2ReQJG73lor6YKapYmKOaTc1kYgNY3pK6ZYDdq2VRpJg88oN90nIzZY2Jqm18aHsw4rM30qV +1NQEUW830uxowiHZ2u+/a66DjjhTDzMwPKz7NwQbS84pRKPJNG8MyU6UsiThaoHnwY7p2oVp2uqZ +baSybGPnb4PilYPYIhv63dCzgXyEDbsMTaPi0lhFrUOzpoNNkg3Wv2A4ponh4aujoQy3yegA06AE +bB7u1BrwlJC73q0PaZjmCQpqwuNNuej8u/o5F3nSmMgm6fH72poVlZOH01iArIur1Oih0CyPfc0a +exQcOzuKpCdKUNSVv8wpofvE38iD8G/WQ3JMSJ3ZAAnI5FNXVuJQIov6+dhJPRrd2ERjP9NZE22v +t2ygjkrSM5aRaLiACXg4yyInGgkTTZxj3niMiMERvkPDHUwkqy8hhyqHM8X44h1OrYKggqnc10zc +AS6O468rJ+PPO99SkXCM1ayxp4Wh1qn0OMeiJtrAsb8BXfb7fPr7pS70Tlc/tRWutUC1hNfaU1cz +IS4xjzZqs1q2xK4BRGihfIAbIbEFnEQZbBWtDTLeZxMz4VW3LaeInB2bRQpnnim+I6WLmTUQ8CQx +qpAsvzATcks+InOgzjJScJYZrw1s6SrNJjrl2sqUwCfrFkegho04AtgCejSqQFxKURTkSm3J6BF7 +qjPFw0dXPJy/5Iku6+8n1iuPM6n8rWZhL/tyij83fkS50xUTIbySx3X48AuAPjTEwFzJpdo6suh+ +nv3gDsAxZUlPpb0YK62pFVx1dzzReLN4yHc3gOKsLpkFfC7+w7Hsk2hIAQpku6IDJA== + + + 8DxR36B3G5u/bqKXyEeRzThxqVNA40zhgugBJV7hZYuHJ/pGW+HCOtlURnsPfHo1tIijFxKj9Mqx +I6++5ZlW8Th1jduYMe/ADfZJAajmLXbMU+OnPNzHKzAEQb0YKqP2PD29pCxvS7ItA+AW+njvDQfg +JcDyccfjBh7tRgSfLpMghHmKIxO7XhpbdNLllO4j1Lr/nQmvQyjHo89kIPKxZdEl/xmrP6EFSvyo +mu/z7rZybD+NykauKZ6uGC3Uy1PJFJTLKhKYfLOpGQ6vKIJELJbra498D+lve8b/FUxYPzjOsVVk +402NlZ6fFgkXVER1Zp97ECssHIa4nfN6f+M/7LVVbWNoVWZmROYMDM8INJD/pXxnWvDInNvZKPpO +3xBBMW/o6ne5k17xNOgF2ZNOFbFItuKpTZ9iQHRQEPzYfk1ufFYqpHffKXPTuXswpXOINsvjPLmY +x8/gnno1GvPAf6DMRQ+2OdGjM/nQQwFZ+P8sYHQg6RAdWCrTmQt1CpAER38fNeYSqMdBH7quvTOD +Y8kCjErDuXTgQp7asZd5WnY57fH3/KKf4pPHj2RIYCp1Vt3wqHZiwPDSkK+179d6f2cvvdgdXNwL +jHZNfUoq73lVpybY8t9RwumskHOrgMePYh7+oMfXu/BvCnRNaqXjg+PwgEAmxJM9YI7yWK2v+qgx +mcDDjFxmrGcxZY03CDTkvj7v8qyGwoeqplZ9l/tiMuQr82NjvDawMFJGv6Ci3BvE116ViTeCzjPz +hgtH7+00bhUC2gGDPE5yJoCTCAlRoYiYHxUVzDYdxGMWlGXsBQNYBfeVJhjYvdCjq1SoNBB4lzgO +j9cehTQ7LA/2cxCl0aOMLckiBrzPlGvYYPLPXpj+0qtrpEEPJsATOrtQlrmheXFxfWYP91xcy7HV +lJL7gSj53IHGuLL0dpJXuVLvR5fyOCiou3SE0FygUqztlr1PBBbY/jY2WC89sEOZSQMsx31PL71i +b8A3ClKLbU06LSggv32/mToL8Stb2qW9+dS876XH1zuUgTFlRF/IjL4cR41mVnDGC0s4CvKgrQch +yKgf9Thu3OJr2+yJHhrKmDdxtKo7XEDAZuIHN0gtpjlE7iFNQU1GDlr1wucej/kCpG28kkKG8vU4 +JD61k4n3wKm9TvkskIV6mospPo9HDkWmfNw9H3e5S9EWU4e92NPRSV17Jrui98RIGAcdBA+v7dbD +l+KY50TGHDE9qYKzMqSkB2nFx4ly2r3z7suMDjRW8RQeh8mFHmiMiJiBxakOB8suXHUmEHEqV2Jq +jjWLh6gb48WTyRNNjebRhVAshZvoLT0iJRedsb0kRQpESRfq2Fscmly89thq/1p7byuY117UgtLz +pxUhXvDJLr0jIJ2lp5VuvRNp93QisHJ26dJ0vnTIYdedZJCRKHIMno9STs2IGVJLG+xetxR519UY +noEkdV2fRMIC4bn3tKVvRER8JCdXSbAAZhJGP6oB7PkSqsarYMlUAktELTN5Ar9NASBJNQkAIEqP +vZNE5ySJW6cmiyzyJvVLZl3w7GE3X4zDGze29x4Hi/nUWUNM5UuPrJt3pzDAGZeiP8+9lAQnnj+A +fJSECIneBK1kNe61x7WRbRGP9X5X6J97AfBF7hqAr2bKqpXyyC8AMzVh203QIbzm03vaWukKgtqj +PPASMSCItvRVPHejsKqIzdYG1eRoiG+vbzx3op2Og6pv9si9NaNhJP5ZQkDsq46d9bSXYyPm1IcJ +hhD7Qzyox5n6g2Aetc2l0uzzKFPjIl4PyDLIgZo+0CMiM3osip03oCfCBNA+2GHPbVLlQ6OunNCb +vOsLNP6Z9OrptaBN8GEPbFvbA+vz1Ehuqanzbr3z0v2x+VLR/eGlzsM7KLsHC+1WT/5Bj3xWPWO+ +a8XcfXx4nLkJC/FMKf6pHseWdMaAzIzHuCkpw0AMVE2+WPIcezOO6KYYCzZT53jt9Yt9OXJ5L0JT +qQFXOhcMeRfpcgEpgFzM6cRD4qxgPBLjCuriBz2I/5ltl0CL97TND3phZ0iwIvqYDx89JdGqraV+ +JpiY1KaaaYKiX8Ohhw9P47XHvdUCMU7ab4nMfTnOuakvMVXFApry6gdQZWw5psjM5x7P63OGss+9 +Rk/85jT3mlFiN6GKZdZWvAYfKWCykohgTXETcDTRp8y41+aeAtu0whzzH2BcZ11GOqRh6EBv1D1j +SqD+G/s8SBNtbkTmSFAapS49thCsKMbt26Qdf9uty0IN2VByIbriZh9La0DRwN2PPBGPJ3rgqcw2 +tKfozoqwjATZ3+6yHSTcE0Na1r9CBQTyBjUu1MiG6WvqzSe6O5fhf6KZqaOSCIdR9PLnTMf3TDZM +lN35NJ5/S8YXaMAAG2Ct/Uz99VVHgmqee7AbGXsP9NJIUECBHjit8bEvQ/luC6/YbXG3sX1jkrSE +XY7bHPqQhUOKo+hkFUsrXiBxNnfVcbQ5tOXJHPePYl9ucIySfT+k1oG3psRQv2QtmkTX6QqCBXOM +ZUe8qpDzufHXu/YfnS69NtXD4btG3Yj9HocBVbOkphV7CNbGA4adBD2Ea1Jq0S5u3l5/yKY9cLlr +18iJ1ngpov0kdsTAIY1+rPQ5YT9/wRvqpBTIpsbH4zAvm+8WuxqB8hVsTyXZpRPGo2Z8oCsanZSs +o5dT1STS8yCi2EhcnzPbNetl57msmlT1xRi+59rnUZ9FZdz1fh5EQOkFtDx7JdOBDFxebr+EXlDA +zT0uumqWtano0QCeyhsRiM3COO5Kf0Q5COLFJ4vTn1SNFE6NaJlwcGBGlJVg6RxupFIFgPTEuISM +JDOEFbJtG8f7c4cfiqXNBG3Y9rquk+lxYFoTn+mVdmkkryuTKMpNGqrFt8sCODDjBFzLYoVUlxsg +UKhYaN0qyqBoGtN+REcEA0qnUTJHkEswA9GjfyVKQVANVqjQpqzLkkdyNxE/OGDf4PJ3zUe5T7jq +ZLpxv3Am6k3uEBiSQxCJDWw5hmoBwwLhYd4TT1r8y+O4xx2c2UukfTQKfqYusfLnpoQAcPLFZw/W +SzhrtovFIYCtY7cD3eXwx10FZE+WG64YZAReMdGkrxhRx+hZZFZCFmR6SZKCCA5WB2EWFRjnUvEu +KUFxrHsnTo1Ux7YI3XEU0QOrK317AfRZFoot15h9QFpMBbupieKwOK+nJfAMhM2w0IkAp7V7Jp5Z +MVZDEAE+QlH8/5AzwENlEAMCWRqpkK+LFzX8ISCcrc4V65/V4Z5ibYOr6XfldcPESS8UJo24z8pM +jqQXZXcfNUh/iIw4H+N3pi7DqJpBOcbc2EJolGJCWYQ6wWAnvKGV9GKlo9ckPUevWAbREIwdmaXo +c+OOCjFNdiB1RofRih1QrWM91ZjGE00M8ig63LVpqvli6ci2sitFMBwaKFvgs+SJtOJjXWbwRAd1 +YWJ/gDJMdgCZwiEAjdJDzDiZzHkvkz3HJN9WMa5/tkwEC2hOCBoU5Lu4qH1LoBaBP1jHZZo8VEja +jqbsW3E0fQyDM+GhfKPVqno3B4DbEGrvsajFIrb8etALhtWeiNILdV7ylgOI6aQWP2W9xD0h98fV +Hp4rz7SOXNM4thKHRq4Y7pxNdCdn4rVxJryhFAQ9yIxx1O5yDVa2owKFthM2WBSEi8Zz1FYeUE4T +rHPnlqpAqfgAmZ+BElAM04YW1cIUz3Ruj8BFAO8cuIhWPxiNJNHUBFvzeaPpLqq7MfsJ763H+JRa +a/peFpEAeFeBBABC/obzXCqkTj98a9H0kr7Fvsp7yaS3kEJBj/Vy0acDiaTs0aTUnDnBs/+kGQZu +nsXbRFH0hmHVK2OS6Yp57mu5DCgB39hBdAK4NWQBqXCQa+9pW5Y9wHcxTLuYmCMrbX2aOt3AiJIV +xkm4xFOn3Mon1OGv83G0Iznp5G8Pkj0gbK88gWQOamekbcuVNSmmClwy9p2QmqfgvnxvLjkRfyDy +Sc4IcFPLUi2ew5lNO64lSRrcrdGOJrPohUkcAwCOrtFAXXRDRjIm6jsmShUz90K4fuyYyYWVqGrM +fRTNEyOuFgT/U+HbHQ9+oN3wp/8Gfn4swvXP3v78P37/u29/83dvf/qzn/3F11//46//+rvvf0nf +H4g2JGUv0XbFeAUttDcYQVB7fr2DhQW6Ad85jA/Y3jneN/49XlmPb1nsP7c4esKS2SjOe+4rG+vW +2MRW23DDpAECMw3Q420oTnUlMQAwwtErADz5DpUue31rFP1OPWwo59mQwDEMihsNa7oW6HjnvxlN +Oea20eQkO3MmqD4/nZ4qB2r5M4sxc9eEDcYccAgbxEGTUH7uoj0xWc8d0kGV+c1X33Z4K6uMN36J +yVcTnRgtGY6VKOt6oPoTz9c3v7DygG2LUeIwJXHC3+PRe9XkCLNBM8OIV+M/aXiHhbP9Xh6FVcvO +JvoWEgqNv1PjyINQR+TohgHIQN+L8gFnk6UzYvLDF0w93WjUvT1Zf0ppkBISZvkj4+rzH3EIk5pZ +YA8vgm/W59JT13/xvyvNs+jlLvECn0oqK3pJJmNh4tpM8YjhiJE0a+5wL10nCM8zB5ROkxc21Fl6 +PppnUe/1weTJlAqz5JmVWAQO6BXzVPqnCsHiOGxK6VFZn9k4Q4toN1eSS2EGKOClwG9A3X6kkubG +dcS7Muqooqjcs89Ei9RtXMxNXFnkT0df0DwHyw7Cn4mgcK0EZnH7UJGQSahPQxB1uQdIRYiziPkv +JXf75ju4ztOwMK1YSGHF/mCY9rh6KhTDOHiIE0SvgqI2Uo2w1u1Fpgtw+Syp7JfSeSjEGu32ZHPj +b31u0xfWDXqcYLvoodZd9KjHfOfcsd+xV9sW5U1XRHLh7eEdc3UjRkPRuFD/3jRVYfLWKb2bcrXH +uDl4uPUNsES9ElcQwfgiBqxDUUDktOE14b+uJ223uMdhIk65dDHVfJqsGBEKudBHDQd5fRN+FWA2 +9YyZWekI0wC8iuXKFCyh7rIOQU6zt22XTFYS8ZiSn2a9LITcpGl089gOApUDCUYGT7/DYUI6yw+7 +MIOIzfI4UmexmT/Eo3SlzcEOxpUW19eK1A/Z0DHvM5GNNSGmqHEWiazhkg8h5cwGh3Eu1W+kM7OJ +cuZoRNrE3rCtPnU93Zs+cn0x4sa93lMdo1J6KtE7cgdV4B5HiECe2WeTecLr3KreV2rrR4+40MT1 +4XDv3vO04ZT8+CgRXirsVEMhe8V12eukRAgHlkk0ZhyI+nt3qtfyOawO0YMBw+70kGB+Um98nOAQ +iRbbXqpN7iWZ19hLNn98aKQs4L57/duuPGF1nHbt+wJiOEjS3OQttK4pcKBFDhggVki0qN/6Lgmx +/FUrPShM1WTuJrRpgf6v/hQUE2lBsCCPcjNCyCp3FKueEFwVOye7ms7wFgNOmM9Lf2lnq0HiD1hX +DLyyUjWvf3FYOTLnMJdT0sWOhAWRe45Q2d9gSs08sscx8VEUWBIXlBUgZPnW1hdUiQ== + + + PsbtcVcx8YZM8mAzXzF6OslajaJaXlOxmo+RUpHCBcQ5oByXhSsi/iMjyE5SRdmnG/UJBI7YGDVa +L2Lcsgfkebtl41RuIgi05tJ2LTAuswqS28ttPF8MS1PHsCjIEjHv+Y4vPQEYgLXuW9aokEGJz/7Q +3SuuJWGZdbiqAG1I0ZbFdqNqbCy/HAcDQryYJYyMSNXMs54PeGeVVnkri1SldckWbbRZ3Tsvyt1w +fQCXxDnmBYjFwQWnTVnsCP5FKeB9zF0Ta7R7Imy7IIs2h4gHA4yaP3eaQ30ElBhLH6NOyRe4vNGj +59/b4ws+toF1qRio2KiegmOA5be0dAyjARnnxQOXTA0aHYEvmErxTjwuFggAg1e5ea43wJXHDMgQ +Lgx+CCkeLatakgFvzhQrTrFnxiL/ckzzx9wEaP6lRTG32OUxmqo2cGL20DAeUU/oWNiIHOnaSqx9 +obA89Cj7dKjHTq4KHF8E9OROkxi7oY82ds7VSSzYaEGFhlSX6hCg+aKTJEgD++WLTflg/Luvn4/D +nWm5meg4VW72RRDg0oDGu+fp6g1c5gxtmE7TiHJs+RjguVc6KC85vRoTNa2VseclC0yM9AYsESMy +NoWxNDMHL6n+J5YfW6wI5ZYYEFB+uMJknigQ0My/YDBPGPjmZJy6BF2YLdOSNbFP7SbM0ai0xgUc +S54zykfVX8kBjoaDuJyGkzdEgxFijGWiOjFe8/1wS4gLcRB+7n4xxV9JBqbsnFCXxNnbkEIItVWD +FvIS+2M6SopiXMlggHfqfkXzca+OAjr6jFjkcFgoCrhMx3x3M15YtZMxwLZbi90szyAjgW4ITvZD +x2/IsleysDE66e8sHDCVScyuS5weuSwUzQAondKP22kIgPH1uaFthMF4VpUbgx3Tusk4cAYC6pue +DCCLTDHPDYhnOUPj4NRMnTzBJ7IGD1imZe1oqKlnYa1HnDNAL2yqkNZAcA9IF+UyDLHnF9IaVHJB +BKHurG3m9WnT5RyBMZZExR2UiClatXd6kxgCtrjXxZLa3ljtu+J5XbsP5bpO6mBkoc4EaEiAy1z0 +CdiVpWdPaGWLPfB/EfWdxUIYuBI5foyzad2sHMoD1C2EgasSqQMYDHcEQiVwJgIeiyD5B5QwWXVU +er/iQuIkunGrmdhTT4fgmO3yrEmM+HpDT9D0oxGk2qORG7oMnnFbGTVZmIx3GtyGxbshtpcR0m7Q +PNNFbTYizQNtX8kAD2eeIla15UXl8GbT3D18f6CjSzqfk7UuO19wufQW8HMn8DtQVx0qhwAonE1U +nFATjTD88WmUW+4ABWQe15V8VU5i1ZLtRotoEpm+uS+VdPepBRgch0q5635eG0V7MdBihdFYzZGx ++ZqoPCESQJ5MiiQWTJISANrGMokmQfkC1uA1LHOwVkgJb1DCbESTDM1+SiZN4HXcqbTouFO0CZEA +ue6Jk8jEzQSWOahhgFCU59C2eBM4kVh6yMwoAQBDAUdBRBRuSqp0HW57kmBL+kEyYZBeiVF4QoWS +u3IkCPzyxi4Q3f0BQD9m5pUv7QAGgFtmU3XjWaMx3JRedJnXTB38lDpEzLC/scXZzErEIjXRIm3A +SoBR0ry2F25risSLbAGtcWoNmjeGVAXiT3mUU74RpgSCvQUYkcKgQaVJtsuCX5MJTEPae6Z3DQ0C +ze7DSYQQhaUqht8hN0hsz98JAG1oNRX6T4y+4s6JiTzanVVDNRP47ZjJ9UZHD9Q3ORPg2tpepMBh +ynWf5KMVCCnQdjwGoE/PTNIxBQMk4TTVM9SCrLWkVMvSrY/sPwIl8WnnGshSez+vmQUcPAfnEkiC +nWHV7DBOj6Klflb8iqlPtfLUBKX6VS3e9xv2YaPegdQqu1I0wxcfDZUQPeZ0RKhoSFmhVXcaAUsV +RchyRboPRyGLxogpq41FEfxqBe6SvHXZoGJDNtRuAy/zxKh+fXE0Rhheikfy3dNzMoUtqHSTBJfC +N7cyo0EyLxpUDVaCbX/YbWx0G0nsiSjqJSRC05qmkgpYeJ+cnAgEMSG0XvqWk69E9WZnStDCTDMk +JvQEUphOaKqVxB8PJh0mt54Lpablh8jwhaKFicqxBctSb3SlHnxjFo1Pdel8eu6AdkLuO5kCTMXy +i+owQdIsCVSxNGzwX5wLfRH2h12lBioVmNctnAA3NmuDqmJyIvUA37K5SyG5N90E5lRS1Vp+i7/v +fQwaNeVmoeQSHg810zRU7GBOkUsHDEiG8DDY6JueEmMZKbqLnd4NhuSTUfsl9laH/IQjzTwX+JKe +gFsWsViYliaXBzxqQrEmQfktswBDnIwAg2XNde/r2B+pph+PYMgp2YqRC5hFyQSJHAoiXDOEWD3o +WuaufCZtEqTAMqxdJ8xsyVLrkK91+bGCEpDwQHi5lXZT/TE2VWQCe99RZBzg4N4AUiVcEtWp7Znx +cS9MnuzV9mFmdujH3UHz9DmnQNvN36VHAvTowaZYBY7+fiLWaUr/wLjoBf2UXkJYet/wCAqxDD17 +6JWBIh9zGj0Smc3klB1mXmtfdxTaiQSbSA/YAwI93CdPgjcgZoiptMSUgI6xh3Nk9GgI69LDjPSp +mHFNNbqit0OEv8fco6mp00yoGved/gl6ryIVq3LY3HBTGDMnZxKxJFgwnqUMoit1ShIlLZI8Ps2q +mth13YSEy2+QTlD/7JWQaBBArFpjM1NJuyzdlI4k2lrSOP1pgvel/q7HcY0oorFkvuzY2AvI0Xl1 +IitPaSRn/pqdBh1wC+xWO8gwWX3dxzf5OGG09Mf+wpjmZKVdqQyr5FhEGzBCZHVZwosdSDP//Qy+ +ZNtyup8Bzdc+ULv1nbCqATk7CVBv6V2JFDdtjUXlSpMfI3E8OND34qo5TFH5/UZipWYwug6MW+GE +sB8BaKAwICcmWS3klVfKvIIvROaVVO7bOEoqGSzdvQBRtW0zgmTIBoIPbR0tXh1Kd5r2WlN7bnai +r4AupCCgnKgmNVSvudhPTCjOK9W9Y5GCYctzfpdYUZBy7niQXikrfF2nxH96dKFOECWqPXJCpuyg +3EbPwnI5t0Y7dcYbDWCVqGdjGTaSyfJXblLiRDDzs4d/liU82XHthA5M1sXae1fVDyhEqHGWanop +dkIohgKSHGfZVTgFL1Fb5fmVjc9axGLCu2pKZ7AQyYKjFtNNNTIRbHwGknNLrUXWljRkj7iP9eoC +4+1xxLbEvAzIxB5ZrcKilfLikcYt9EB/O3uwK6LHzcih15G6nyXFu0VFGB5emA7lwLE8GQOHMMdr +EZspkyg7kAyjQy6/RbfDPP6RFBQWNlFDFf/XorLp6eKDB5vI/7JLWSRZmTQIrSGDLJJ8LeVzb+XL +qqs9AgUdHgHoWbDll76x6l2VFFFCb0XVYYwuyVBPqsZyo849WbGz5ZMBx0yGF6PFs92T3tissJ6i +OkXHVlOKwC3zTMnTaj0CnS6PtDXW844DJDoH9EA6jjIhMQLB6b6RK2F2JFCRiLzWLagwsja1JPwZ +IgyScvzzJPF6RkgDWHmRVqQ0Zb4mvn/rSzePmK2Aww2tK4fbkV/j4p6ZOc6xEcQLmZ+sWVppiuOe +VfwrsADG4ExTWIrCx719Z5MG9NXgZeSHjIkuI74SEfKuTMrGuzqUG7G6yXEKHgJDVQnWcubVYwt2 +PRaHNTKppcnsSBKk73GZJFpv2aPvHkeyX2WmsIDX9fHxk0CLmeXNtl8bhrRQPTvOzbacm21ZUvwC +C1d6DFhx9sjg60zqNUIIKnpdKvJlDxLqHONO4DEcVHw4sQ313bJxm4Sa1CFZZHKfCBzqID5m0BlW +xaCD5+064rXEhnaJRwUZSmEyHnsEIffL2QJ0EeHEXHY6xKfA2uuQi81Ns7Ci7Kt498yjxCpZJzUp +tsRCbwW1XILQj+KqgQ3DzbVsie9evIeZE2N37jg2FqKpHuCtasC1mHN4e9fU2wlqGdfELv3o73JG +qrgsiBAxttyQy9/uWeCGgqgABQS9nuz4HVkP5QKwSuRwd6AkTI6cHnP8OhM20m99QsbIqKkQkYHT +lVDFE3eK0zTYu+YKizLTAjLXK9NdLdEhcY9C+4nC4hMjNw12Rr04goKlB3Pzk9WhMKb567E00osg +DZgA7yoaLXvRwMxJg2OSWPlEMBH/bieeuUHzKKmtx9ES0Qz0qeU5jawJcNhfSiFAuwwKQVFujsSJ +rGsW4JE99hUZDESD+dlcaEuspzIH0LEsb6TCU8lm6TuGftginD2vrfwFRFlcEiLLMcjOvcl7Rwgx +hbM+XhcKGgqTqhXJDBrhXUVdBYkZkWwkLMBRgMNCg1BeO+qMLA3HTugOYsiqBiVmp7miLrSvlxgG +hLSGSYA4TkyVAk3QYBiqLLkAgmd1c0KyF8BqLPu4A+8LrykEO7cuDZGRCS8I7+yxgC2ZmgR3N688 +jrs6ym0EqagMSaGbeFuurB4ZkhPHX8etRZSe0IzxiJeLu0Mhd3E7x4ZMiaEmZT7lraN86Y1ghI1c +FDLz0rPBsFqYK/d9LAv7dMKLx17dCpZK5qnPmUJahWlg07zRyaAHWxufGKVWdiCY49gj4uMLfe7j ++AJXq5Cg3jrVXlrvcn58C+zBwkmPA1Re9MCwgx7xqlee6Ups7lR96QBuFhEDC+F53LDqkVVGvGcR +SqGEApdQ6TGV8eLVAdG7RuY1FG8aKpzFQkXycCX+KiGJNwoXzA6h9KHOmrqPW8BvbIktAMot8w1C +Ssm5KN5ZNiOOaVGO6rNNzuNMXnic6ZKTzigzisFoCRxnU+KezNDpQ6RUAVwbOVW1Cie8z7RQjDke +qBCwhB3vYyYkcpkQ+dzsSqmEsTaIrjTTwHE6mjap7DLxNIwephulCjD9AEBAFG9Cmj/eYbOQlpCK +w7E5e6WZVQfCppilCybJImlfbG7klpNC5k6G2SJKkUVZf2Iy0xB4EvYb8ZqyByhqFQHLFJiEdYji +7b5T10zWBkv47vZAxkQ8IR6urf1l6WGdvh2J7ziFnO3R1LbAaEWStSRWVPwJySMG5diKrbHIzU0R +xTgYMI4ocDB62+E1l1vle8vj8JYLyQfLFEDRRPciMVDL47hJi5ms1jM9WXIi4c73mfYVLEgd2UP6 +WkFj//1M4lxgtAu1UTsl5T8FChtApeUjDkSXErpbH/TM/mRCLr2+HvJyyYPTxrEt4Q9TaorwUoVv +ElYthRh4DhTiNvNzxA9Mxb9TXuwwiZ7T3pLGwN/EJONyY2WC8gCQSM6S+JDEnwDsTn59TTegqS/G +XhB0WUFxLtbrTK4gIKvtZpVazgnhQDPy6zQTRFlnaNCGZ7t3lCsZzLqR1p1KqkyZrRtfai8kdz3M +yl7MYvQCKP6LP0nqR80jIDRuWuJQlG9rbs+U4slfa5YKYqlvmWEpIUQ+fj7pydrUOtwMuZW76UEe +Xe9fZKwYEL3hn/U21spFHg0peLBoSKlturJQy86k3dyLOTSTWX0LozLiD2DCYGuaBQ== + + + sEqalllIIc+Ji9hppKbUdIYOZ3p+sOGDGoIrQjxakwy5NySqi5AK/NWpnu61Nz1o1sdS/KV+iJRK +4urFNjQCAaJE8D1X+n4CXQM2S8VqqXCEca50Leyhq1Ln69bEEvI11fsn1LUswsoF71OFdnQNEKyl +Nk2Hv93bOTkyVp3QG6yJGAYbTt6cIEG1MsAZp2qtF9AxyuLnnWYgF6QKdXx9Q4DosRXmvMIiByeG +U0wsolJORSdcb+DsQH2hGnkLz7DSiH6Nb4J8x652US/M+ioCr6DczqxTq3d/SQtHElM9a3WaP29E +phkOHZtREt0O5FaqSOVQqfJXPUslPwpS+WMiYf7nH/FL/Vcf6EfNEP9X//PY5uX8j+aET8aTckDq +pRrkEhd6bDPb+KJ42YnMhwPiNz2LScDnTpI8nNKYPEv2YEtsg4tlzGXFXWrdMT9ZuHI+1kLU3kD1 +YlQwFM1kBdWLzQ/NOhqqyCKjNczJsma7d8Q0RlQNYB3QZqOxZsIHnwW+whh9+OIBAKBclr9Y+xfN +XzyKeZ5L++n4sikYqkJPfA1OQnMaZN3blTX1kodTSWdhK1lVYVSrPCePbVwyE+H3xjdab5XOlT6U +i4fjVF43b5KFP44AKqjeOtxt5g6GuMXTrCzZMvWqeUHWVWXuLaIP41d2ODY9RJ0sU8iMergxtOMy +hhI3eaXnwlDk4eLjhSopMCRfzyQ8rWLwGhsufAy/nGqNRPUU69nI0Ugxy9OLKWuAkzq20jWlafJa +0TCtV6A6f0tbW7fm4sCzaruxL44G8S4ywE+lg9XoVyfy8t+PPChaKBSG4JSq/tNzEoAi7Ywaq4nl +V4qIh5iXscmDeInC+N4NHg6VxBOCG9HK9f4jk1dEcwVtLsvYGgQ8/x1phi3o+NJW9pISK4UKgqOm +gwhxLiGfwqWAmGsqxe6/eywQzOAOBl6awr/yN6igSh/vCZkiYiP9wA+E2Yxts4Qs/q0CThsUZdAs +q6YyvurcNBB0RsPCc9RRp4Dpygh+QII8bXhA1Gg0s6Jld55KCcWB+aVmC93V3QbJ2nhkEzBEA6Jo +HO1W1xvoAlFei+8J5jZV4eTlrJ3ZiRGoTSKxL1HJy9+PrJjn0Z4a2dYuQ4l0zzYWA0qG05yiwadW +ZQe1mhjOJRtuLwOAG9f736bbzZhIOhB28Ivzk2XUl4YvB8ZLI/AvRZSx7+nor6PNsqxtkxtjZDCF +MyoXGQPG9qbAMMowrKfmuyBDMpc5M1yK0YN3PLUUnxdZhp7Uvyt5HjQyEdIoiMQGyjA0UCSnSiTf +6FBjhL8PMJfkue7BSVupHmwBekeFfO1LAHYM5JIPmL+r7nzlj/l32+qDfBVV8cHaYz4YTH3CWxhe +wp3lRTU1Zhsyz/A5ZQaNZAg/GjLJklS/R2dibHf4g1RnAXZmAk/R5FMS44FeWS5jVKpYxo5btp1e +csnVGcpe5ETpBR/F41iSxMwwUxEVwMl0JZ03KfNfXJD/xTCkiRa+/nWsPCuy5hP53NBoPxKxoX4D +chIW+iaCNYIxjR9TINDC8+HXQthVlKIqmcIj6nM79mWsCAJSkcIkM6rZDYrRBuoKNJDoR002wZRl +qyyyQEmNSUno+3BZ0EfVcioBPo5UNlQLgvSbLKztwKPcphp0kzVt2nBtPQQr5RhgYXyg5Hf/5EYb +soh+bSdEyalIuwAQ2Cjpf7ZIAqXjCCts1tS3kxTjVfA5kGTZMrdgtJ6qyDWk24l6rZIL4lydDcRI +Fd8bs+ouAzFX+JGIeVHAsYF5n19dphhzqpabwtZU912U0QHi34KDwKjZt8NuQRaVRkJ9aMekL+Lv +MNX9+6kQasoWYqcEdMWGByy3b2scNgHOuDg7X44S9yWnlXn0XWKOUw3uRwbd5z/i+BahazakakBh +nV2VJgvgZQ9x0JJSSSo6AAkU6HyVA535K+vs2hrSo4y6AQdtAw4QVwF9phZpxARm0NaNWWCirO8V +/aIVHOHX3JCEM4ELgzKINf82dgPMqGiAmkdDgitQ4+z7p1TGOcF8VFC23zWynsQRUOlIhFx4hTI+ +TxAwFoVNwe6006HDaOpcA0ok0xedBM6/9Mhw9so6yEwizGsvwtQusZb3u5J8lJw6coME0oCT5cU2 +ADaXfDYNpLGobse7c4Lk1clnRjr7Gon8il7QXT2On+289V6vkbny6NGBN9MjKfNtNZXD6MHuE+7/ +dUcVxEtuc6Ba5GE2A3yglJPpV0Ll2dSyy8NQjoXeqNGVnLHLREa8nDwRdXp6xInvTHLNWYPce5X6 +tKn/RD5gPsmuyBqYhFpgTM7ESJFCgdhlFilNXzqDlPzhmSK3CCLN8b4kkQKCQziTS34kEmOIQZ1y +kGWbz8Vt7nwVbsMEWO53XnqI9jSjU9d127y89hq7Ph7jGeiFPiQp9QLr4FSBytL93Iu2i1/mgGOH +JJXoqcfXO0WbPPFRBq7mHxxno68mEXTJazFGsoGaHw0zUU5S+iYz200/fumFcqUOn1SiXcfvfDmj +QzfuelO88NEphhJqlE5K6i3ZVUYMTDtz3WfqKUjEOL7MvEJhkWFV0h2KHib2o0ffKm2XCFr8KU87 +5FOl6LstmhEZUvXovGETpBYr4wBu1Np0s5G9hl4+iqqTEtPVNjXGqOuNdkNfOoiBtZlq1FIKQLD7 +BOcesJAv9gNhgqHQoayCOzdLF12lSR+9QrTxfLouTi89WtrYWu247nTtcy84DNT/J3bk+9EPc3iZ +Po4ex5Z+nFBN0kdHodunv+fEdru5xevsQg2ff0291KwBonPK4bLGXR80UHnqlB7ig3yI8rz00gBQ +YtYSPSnNfWUaXiwQhuJN06C27SxuxuW4dYMQBiu3xtqVfAPgBoiowhv0VR8gMrL+ChDXum6qZz4P +Bmq5mck4DgIUHXpl7MUEhWq98c21gfrosJaN90tdR7070+FYOjU5BWUYa7KngWFkSiYe6yxpO++S +Cz2RCPvzDdbIFYYS8Z55lvlqprhLGJoSeBF1pH09W3vhmjHplF0Th0chK5HySnzUV39X8DP131EP +JYndqQAmXEEERkweOERmD5Rf6WGch0e0yq/xZtbcxy8qnM5HNVvYw5k/h2PJyc+1cXVpQXzsJL7E +x5UNaoHHqEq552P7n0e0dMv6y2Q9U4xLqFplxTx1KEloImpbrJXzyKI8oTi5ip+OiP6Y+wsw+hDD +IlzER74q6igmx6U4nmMy/2IUC0wHTkKScJ43LbzD0nyLxnx5+muvTfq2FDbRVLkUQ032YBEBYQ9x +/wPtx3LLbh5J2o9ex0w5MPQ87XSqzXCYESQuX6K8DKhAKOEtAVj+2vo39Oht67vUPMZ690U9tpd6 +QeQ9w8FL810eN0+kmKu8kaWCR5kF7KHxvVjUYUNvGyaYLI0qVQL7KyWU4XGCrpLDABOZWj0UM+xF +B1CW2LCcQ+J+dEBLrku9V3RirBvJQeZbuO4BRg/hqMmqJu6Wn1UJGVTakGYtgj4MFo4MFjqkMZQk +OyQkFOlmLgQJ2ywKVu7H09IEInpB9M5ezhyggUYyF9WahG12jV0UU5quIA68exAz0UNqLHk4No8M ++HdT5SZhyF59Xw+TFr1aVW2D8qjKDkP8NCsX4SVLOchOb8niXr2riuB494s+L1PXRTJF11ebgNwh +C5EQ1j5QM6MUFmRklQ9Zky896h2MUIS/7pfShVZmr+smCwABhCwwmvq9mlteWhF3PCfYYJUNCSAg +7GP/1elDPAhcqdZByd4/AOeiGoIxDKCDqdNxaykeoGx93bL167bcScMPTDPiRaUrRaLlKPnWZCqY ++L5Q3olVDE9sgnL4ZIKXI/4m0/1o8Bqf7XHuRpSTSXLDV16Tb7gcZhQuymgYkGaPmT3IMKURyK0F +8tyoCbPQZNF1ST+z0BVxtx/KENQBGDhZOHUn5yNAmG5bsmywe9wKFJLnhzrZmMHZqZ/ZSVET6sPp +HTOK6iyqIuM9gqqXwhHPPaBvVOOJdrujfdDp2OL86uTx/urWrD5iSVspu1+ZG+bWxu7GQwyyXQd5 +6XEPmyTytoj9P+pF6W5J21ROs4q9YN8F9uLU8xXKpdy+jnjY5VeRrAd58DcpcmN6oteiYKNWrXLQ +kI9JyJSV3ySVfei/U7vK5HSeFgNjskgh3JYkKrPFe/fKhVrQutihsuIALdDZJ763Q+Lkmeag8KgQ +oLaHyHoyMzUlzHP4YvrlrbQd/aDYeUueiJtJ7fzJTO1mhXR63epr6jUZQJQ0n6Dc0W+OrlbdfKaz +vfbIt9LTwwN6SMovlI3jotfMtytUH2VcHKC4UGoOxNVdf8nXHuPTNu3QgWWf6aUXRWHeLi7J8sFb +qm+hTKF4NcbB4jcxPFnJxb7cSqHXPftrj3xoyMd3dVnavD48zpEFAC7EtzxyEodg0JQkeuogX14z +CiAie0Q/d2IGhCCCksxoaXeVHusdGYGm4kTyfJAFOtKOLBV3CuJO87XH/ZGi1clH2tC8fT0O9sWy +YhbgklwMFD0BP1s/7MH2SEgEO/mbbts3aM9eZ84qypNAOWjQkYH1pWANuo1DUVCUO1COOIkVGHiI +E5A1FJr/0iMfXkk0BMkNIAGvx7k1vkBm9DuW6kfGUkWF9F2b78oqF5NfMHpO6jp3KLVyNzTTj4l/ +L9KQyK+o4E5DRVkGU66WPdJBjWDRDFZP3StFtY/34+r+chFmXnkcY3nOXmsep3v9hKsbgJV5wYj8 +Fdham1t8bZMBBZyXJl71QVkuSfugROGLGFQ7U3tDr3XkubQQuXZsDJdFjfnqZxBrFWqJu0PdHXaG +p53pxwensiGC/tJL/rAxY0UTqiiNqYZI7AbRB/6oR6rHI233CGlfO6EfqEwAuZC4ACrZxVSViZ+I +OmCueR8IM8IEOVwwUdoQShCLQHuodNWc0mnUYoUVAvtlPLRSeCDfEwIeAqMi8q8IPWiy1YYdbiEi +KOz0iOj1fBw/hToOvqhpr2Z6ryOTsk+UUemaDvvLbK1KTriG5wup+ULG1hwyy0GPm9LflDhgD1Hh +LC7ffIfrM6B2yfo9M+ZHzVEJf+jappNjOmfC+6DHKWIp3hlV0JtI+txLXbGRumLnOY0xUyANUXSF +XJ806mMeFsf1ocK9VBqkAE6ZqrvX0pCnZ61+pe4XsOQco2dupVPYoykAsdzOrJ1MRYpsbd4ZIp4s +v1a7VSNrQs9ZNhuqodh1nUfK8mYeNfqCVCNazWvD+sFCzlOPr+/Slm5To2sl/Xocin9JsosPueQO +Fa3WhBn21w4fro3PnTTDZG7Gd/skX6BmePLGgNpN8EhAEbRkgWwTC5NM0bKpgORegP1/3iWKXThQ +cVdyC7KVUGQjoiRxMNMWAp23JXEpbkTpKOqt1MQm6GTZFeCiLwlKuh9OYqPj/ML9dNZ0P2UniW48 +tUjGRYUg80wkeOnx+50cctp+boRzRqIERuvhHhKqNxsa9G6gpaBjqeNKxEULBTLJgQ== + + + sYZKDiwbpWinlp3WuDvxsuk01z6MeTBcqsbusbLHga+4PVb2AJ6XPQjh6DHvM2135KWFyNpcxUOu +4hJSpyunf9/mijHRzaQqSPuKX7L/yR7Ifc35jjg+ti70Ii985Wu5StIYRO6hi3ma6Yw9EdlbfLdF +6B/x5HjnC3DV3PaOqpXh21BvEfZb4BPf0ns/pKWOlh1ZAzCUjT+sKtL/TkOnwZYG2kM8EoWYdE3I +pCgGvjfwobWNM+dFH2mbsBCnmFRHexpxA1cmdb8JPByHDNaiELTs4XQBJOx8Py7zMr8yxxdtaiFN +KuQMmA86aPkxqbxRjOSo1t1RuJ5bDh/WF3L4687M8tFCe5pSLk4JDxW4BzsfYEKx7T8Ov9HLKh2g +Lllvpvp7xnV1Wybja8c4n4pXTT/ZfkF7OAauSDJOskYgezjlv5juEPeqMDdee8Amk1fJ3PTApa4t +nkyvriur1hmMoBRfRa2xYv0qvKynZR/FEhD/FVwsW+09HlMmAi7naunj3qoUzi1pT3RB8pV4aaD2 +dJ0uMphgNdQE5pHAO2dGNu6+2170xaHxkFB5pl1hNJzkMfRjRNqAsNALiBgKuBK/6DdBkGiw5d+k +Vl1rc+WADxWPknJJdGRM0AAKHw/FhyiN1ohl6fxXVRpOq2LWT33nEcoT/Zu7ynNHlBHl8Z3QQKD2 +4CwqTgCjAaFoG0f+qks0nRo90DAUGCIAA05Cw/Ist0iHTbjt4E2L5h5VXklfHKykcMFc6W6s7omn +J/2zEIP07EIF76clhD0eQnwKU6MRPeyPnlo+ixTgpdWojiI2JCh5nEAFri/kcl5+JSGsI7YndWf5 +1JXCh8uk6nTBAE32Z1YuFqZ1958zmb2Sy4+HTvIt8yfUM/XnLBoIb4IjWJkK9qm89sAApLQ7t//U +eF6J7SR5bon21AxJTLZsJj104kn779tqEFUqXyHUxWO9d+Y9xZaAoNiE/v737dH6eJdLJLraMdTe +ly6l5Bje+o2wW8SY8aGBGzu+eCiFvyhS3de6CyFZ47rSMIYCifrU8V3Gt+QhbgAfbdJ3KcGQnOHf +aOirTAp1d6PcbBC9TnE5bUAjVJqPC3FOjDODE+PqFyVVbma4tunjlbwrdJRImw1VTc/UE3tpyJH5 +HES8/JyRtxVcl8V2yJlDNBVY9eu1hw//cYKnRnxoxBN5WQOsrRLFCP5rjKviqWRKspl7N31tOMVE +lbY/GoXcyBDI9M2bMPNLgRWpKCeWE6oJgAGWl3+tUW/5kLoBO9BWR1plm3klMa3hHyAcLTfFuvcP +0qrPPS427esd24Oxpo3tUMNraBOO4kXKQYjQEmCk0CTMBGPFeCEiq1syy3Igb1+iWOxPvF0Q5BYr +Eg08XBqQrOJHfhw98bZLn+8ztcrujBix/hY6mwrV9zQIWEvet7hFrsCjpNzyYGCqmzZuzS3oHxoO +I1IIpNnVxNfp/BlDfZEuB1ak4+Bzg1Cr+2BPbXAB1HKEHzFE8FwprjLuJa9uEuowUXT/PWfJzBQa +4DaFW7NROYasAGI03N4IK0S1P//9ysXtLhf/oPHWdqRGqxU8rtVVFcaEtLK4pblrW9hmPRoe3126 +4uKaXd5/FTO0Sh8LoYkmw0N0F3ggcsI+k3tjeCHOsfxb8VvdcvjEj/4Y9eojG05XurH0JassL7eX +NI1GslmhUNxPla+yuSwDiQePpnBe18gE5OmID2d5TXXenpPn3EdbfHkFpsdIkwPwFhBUSbOC0VSs +4fnvK28lD1V3QMPioU7GVoe0mkSsHuMQYPcnU8GWy9XXjw0yg+puyOgsharICZ94ED1+Vc5UMKba +KC965joBRzKRF4kFNyqTCQ/hgLKkr2VjlCG468+x4NupOZYIebjxbCxJvUgfQnty7SCvbsnoiPhP +aFs9vdJFRkAejh9pRY1QjVhDaJWHKJB2lfQWWHPrw4JnyjC1qhH9/qu+RR9i14aIeCITgdM/N/TN +SsrDPTe2FBqUmZZ8u4ruiSju49qkT/WwO7wMYfT1SziPdQsufZ3ZKJId5MiVCLWqVGBq+vn3Ja2y +uyUHlP/gN9BIVQyNjJowN43VKbcgCCBrkEjqmYgKfeJ4YJjw6xP6hnzDlGhVjsTErcSyzbbvXUW6 +1wasnG7bi5fGMwVYxw0ojU8cTXees+qLoHp2A2mO9mjIw9Vc23XKSd29/atjU09GrK3CFUFbND06 +kgA0AKlTJMtn7GCj0bg1GoFyd43rN4+wgW9+s1AEAYM9JCVe9pAxiQKWr6JuXhqQ/LwN9Z4bC4xb +ETNjA7eZvycWdqi/QWa5asITcRECGH48wkYZIUwLsR7Fn/vYLKFTdxVSWcmeyQZ2RGSLkjfwEAx+ +aYzvMuVoweyYkkpbH7C/RpQsnmrEwKQcK4Vfb4m0vnUtsAGXCd7BjUyZdKoWIDXsVqZuKDFzI5Ra +JXnjatVKbeNRtXWBRjkmoncIi3jtpXo1ey+qMwSjrPw4ksgWjBkVYi+lpgJenoy2WshlS5pc1Nhj +dgVWccn9gVOrgFhs5eZ8NNxwgyzFIgoVL+1uRFUPwV7kNCK4fPxbqR/qTQA66i3MfDdyvyRQQOwh +so5AYSo2D7+M1NzRey4+l3gyaipjrMWcle4U6Nihacj8wg7988awIMMBhuVMCaw0fG+LPZPKuqMf +2tpuBwHsaIeigj8Ff/ljgm3kFP4or/BfebADs8fxJVXQ//Kr+C/z7U//7O0//6cfP1l5+/Offffd +37/96V/8/K9++f333/zuN1/9/B+++ve//PY3X33+7rf//NV3//Wrv/zVt9//299994+/zZN+/Iu/ +/ua33/zy+29+9VWc4gcXdz2u4Cfoj/+B/5QhiNd2TI4FHQsWjYicVkyraFHGikvGtaJTEKFkMvHY +FMgSh9d68UGpbHAwjaBXFaPsDSQPSeLHn/3VQIUiAhBwLNeHpMtYU1I9tUGBIHSfoNoSDEWjCKQ4 +3kK17m6kwaxXA4UIImICSr1sYHdiQ4n1DTzIFgau7DSAvwjM7ClmlOJjilhE0CVQc6icpljT1IWz +v1U4QhFZXIh0gDshLXmauyxafHh8UA3IZkYnvM3McCrADxM09ipv9uiXPSJOT6W3EpEdPQ6Sc3kM +8qNxjF52lvTax9+aaThkCACYEZcgyz3TOokfgRnMHlM84dHISNJjEc63xmQxs0fvHoN3nScYPSUB +GhRAcn4oVlAIQbECSGXF45D9ZmOzpu7Wk/JFhRiBhX2juHimGJuVUBfYnViv5D7hwfP3SS25le1e +jTJRLPExylIMNoKYoURWYv/eqohOasXguUqiHFNioZGozomqblP0mEKFzSXqEh/VWUGL4cxWc+Bp +iGFdfaUz4GSbVYdud+xMIXkD5k+EKbdJt52xoRNqgXRC6Tc7YYZIJ24E0e+atWfYm/x9rjw6Ait4 +6annq9O4gn+XFJXH4Z1wUSJRlWqc20vmQghuHwc0ZoeXtg3FqeVa5GbscgFoh0SHI6UbCIj24dOC +WPdp9K3BsBWhW8eJIl38GiIjPsdrzoTULPP7JEbE4B+Y2bX77xy1mATkTqpKQI/fnFvLYQg5Siy5 +yEX2bGV82IP75+WKfN6Hf+m0PqluO2EB6ncIKVdZ8higQtLJ9lqen2rCU5oTofDc4AkiHBKQ+vKr +Kxf9uOlVtV7EEeXiCz+mVLgr7dcE1hVB8ll1z8O2XdgsMWn27JUwmgIy8cyfp1dmPPEzBSpzngGD +6BW0RGVoZDhTHMSZacrZvc/TdHssWytISpVSHwBnh0ch3qNHw7ynZODleRRBp8eA+THQKukfSGXm +mYYYF7klqe7SMgca27NtC5gpXBSF2GknjhuxA3DcsgVee5zuOBi/ZOj2mZ57gd2d1O2RJGPOu+qG +rxZVzLVjOoETS76u6ZOJz8FFHkaw+XMPz2RsWOPAWEXz1b8cR1FngOagVpijkb3XDpZUkuaBzz0+ +GsYvnYB/FYvDLhJsqUC6A6lXAXjq2i5kQXjlQOYN3BCGU9lhqr302a+kJXRWPyUALhOpzwQEbH/d +obYQ3Nw0Uq6m4H/vU9ho8HqZCqNRxVT+XrV9Anu8sriraPDC6XgjHvRnRnGWF43u8Q7vbDwPfYmy +oIqlBDyo6DWtw57Hru33ngbY9AACAfXHonrKFtNBfRFPdJTiIcqm4GGKVixtVxSacinTS57sOqSU +IsSCj1vG2cw1XV9zPiUtZ690TQUc0tp67eEUWtJ6DqfSOT86TgRPidLEFEXf6Ng08V0SrBwZrGA8 +lrHKJq/ZxixOGyUMIpwx80fssGmAxGVMxBz3o5HUHVcnwbXdxfK4vaYkKNyTtUTrFkpZwtDxiWAQ +mgMDkccOLC2TeC840mxpEHYhCuLBAkAunqo+Lvas3RTURKDsDcpWjaFtVL7aJYEVsAdJ1Ja/BuBS +AC3y4oDAXOQ+epy6THtcsRrSo+hrRClvauSFJepGt8PJIzDxCbYc9kpBIy5IcYweOFvQY5D9swcV +x+ixPNGlWwMd2sr21R2aQ5FTz0PyiDkcyHwlw8/8AQ4DtQq+t1aTKhofqByPBEYJC4mJlYx3bLBk +VF5Eyq0m7DoNyoseQLn34kPAdS++Fw3R5KEIKI3Zo5G2U4WVC4aTl/rYA3yDnmKY1rStYR8zb3wW +IyW/d6rWxokKllFQS/qIBfqYeSnS2EOiRr/hn2Qghw06XcM86yN/ekBaYJvR5vsJsH6ilwV5sZdS +yVrCtehBToseCYKjh6OO9PiZl1CSH3ZceSUbZjqRwN2vZCVBoqBbWzI0SawoPA821ZosQhID3eb1 +nhlmTfNQbz/9kXzeH1VDuIhlp1bmZBVyUF/Nr4iSIA7sFQr1UD2Hgpg/YpDHj/B+p0GVHhqMooGb +7+WcvyGORufOQ4nGwYdPA3ofNKRnMQ2x6EZcRhqJg9wQ8ojuBJ7H3N0tR7PxAIRcVRbQOYh46a3q +nd5hDQ0Fy+6G3CCURPI02K1Hff8Vcx4q/uBUSfrWkoIGMX7iI8PhXJ+S+IVMjD114j98+R3HOIrF +hLwOYZUNDLD43nF5bqpFxsViR4xzExovGx/L31SuQ5ojwp43A5eSnXMLEB8eJQH1L2f+PWYE/l5I +NjXcaTewr6J5BUKHZCcxPz56FIsqgF/dlGtshGBYANQZbHi66ca4dd3/cBW6K5cVR3m0BT2ZJh6g +HpirR/phNUo9JNNbuky8NESEfNRdmnltFMoZ12BGrCAfHtvNrk0RtcFcE6pEEEiq5dGQV5cmSqxL +FSfux69az+mnswlAISwL5S9/P9zZ5LF+2NQF4+XDwUQDyQ0+ALiiV0qHDtL8iDs+lryWgrbq2pO8 +hwXnC0OQPX8EVWKkVKvH4qbRnDDBhgDnzsJXjTaGjVdqHaS1Cw2gmC+EvClI04BmDg1NbHrEsqjl +SpPdSIva6n77ESxQnuaGYB1UhR7Q0kbkAvWnI6uBrw0jRRdylD01TuajlveEwASXXQ== + + + oUzPMwsYbLz1sIlpoyBCdjfkZ9mS79VYnMf1/itwHmYTcFXBPaikIOtLgzIVm1f10iiTccThNDKO +xa9F6FVST6bGehBBjng+sjV4mXzeBxF22npmO9Ur5AUg0cLnB5+aYuXjzZAP5Hk0rRc03+GBeTRB +OTFVQtcvKsFneSKG/ydEga7YfIN6VrCJJEC90o8MWheQt/TDu7LmTKOb14rwaMmEP5N2JWYia8lO +WggWGz4mj+NI8gY24l2llrzqnKEPwcvR6LPchtL8GVk//qw9BQ18rjRoJgbC/kZ2I0NKWMu8o6xM +vNIz+6LwQqQFpYkGUaE2FEXKSazUh8BVTvfAhghTMCXRwDql+1gHFGCsVFxkE8bK03Mx+XAdu6NH +mF8Aq6CG9cYqA+17jG30XLaLS2G/eFJZVIEKLh5SGMhDVyIOlE3RgcLbD2oxpn8dAnw93+WZaUz7 +oggg8XB0VqZOfR7bTwd1rliGadDLxk1N03nwgLxI0FV22dhGDwI0KA9iEjseKexzIIBTG8GsB9MA +BtIF9UbPkiDHXQphRzawFqaHmfOmUDfOU4kiBgwyq3hjqmMER7clOM8jUcqU9bsrqI+bo1RF0Ft6 +jtwrgnlzDZs7gH3osrHetC98n9CMP1JLjUYrHpmoP7qJel1FZ8qv2cCegwbsagDN1P5+tDR+2iaQ +Saa75Gr1nPXGPnrC3FPpVD2s4/3dJckQpt506GVsc05tLlQvB643Vkp4vzSAAXtQCp/aQPgD06Tg +cEp90yS1iogCNAJFs3v1mF45woj7xMw89fAERn7UcTV2bh8cB+1dtCyLGsCJvVG1YUXMy1aytURt +XfAV8Ya64SeG7RRMgT/AYaYKCBYYQbrGQzPYrUitFLWvK07Fi+WvcwesTcxa0HTaBz2y6MM7L0qg +pcn6y3GgjvseB96Xym/rq/DScOPo7tHwg0bFFjDWQrhF27RYuXntrv2E731bfgF4RQflbsjof2uT +FqQOYXTcvwJ5DW8EcWvVXUpiLF8axpHme3m458YzYTWNBPSVhoMchIWTbFIxKd8eDffLn27e2OLN +8v6rkXK3mEdJ1B0UfdmejsS64LSl03lsiy19ezga+VTZduK+wJ6ZWrkNfC/8avj3dIgb28iUtBVR +3oBueXM0oPCy+y64SzXNLwWL0gApk1Cw4GNIAyOrydY9sIBWE8Hz3MZ83BJwTqwqqjrXoOrmqasY +FDqsswquAGRTnQ79NGZ+GuSC74Z8dAloe+/cFYvVpgZcOhoG5NlfGzDquznoL40bXNKU2eXcfJun +U0+uUwwCSj2x9E1SpHdD3uMQxEAymEn6i19dmag8fDZehCakLw0TV8LHI3tqRH4NXExTK439bokP +hGrtvSWT0Oj9QNitj4Z7yOYGHlG4CJwfv8KHB8XDwqKEuUGsIK9/JYKst6fhc6PK3Awp0Om+5iFq +9g1vNCrnDZDMpVj8EidyN+SdnskbPtj4uG/bv5pTy5sLrxYemAvuWG9peTe3gd6GYh33qlQFAWuV +1yElbaQtDaq7oBaTjnb7gSr2yboeY4rzix64/VQpXkMTicYI/5g590SEfeaBq47U/UpD7q/9BbFK +/AIlifZuVEuNvBMaHYR/AKrKfnLKG+MeCZEZtG+MwOUSvVJjiT0L2YG7IReoIiGC5Q5Zo/dfYX6Q +8UKC8gqpfB7USwO54Qdf6rlxIWSUsYmMsDuGXAxtbI77AAirRNzNg/aKc32m/p+NYPhoGOnsh56R +im9LihUsAje11yNUWZtZQN94qPXIDa/HQNyOg0PVh7xrFkgYItfOc0Ih8sitVd5Yz02FevWnj/1K +RYGyhRaYBNlYnwmIeW0o6YT59Q44f9DYtSbJYCJWWgMGYpd3kIue2iT2I0pDZuS95TEs5kAxGjX0 +L38HONOQDSMGfdR3fI+6q+Fi7MUJdsmZkih02RfBzwVeuAmRQcodFpM0Ki1MKXxyb+dOPzQKnFxB +LCBQnc4v0hLmoygqko8ibHv8CHNBpkhwOoCe2fcCiXtp+MG0+9yI9ot+4PBvKHnGEgHZEq1dLY1a +SXcLvB0gfOrg0fZ2qh3rzlDBdSvAi9O8+tjCFRWWBCAZdLpMgNXcbGMZQXYbzXEQfLk7m7Ku2ISp +jgmUhCK2pYG4qop1h5Kt/v33bhBbTjl8v+3RFBvQNG2Nj+kkqp5Hho/sQkW34CQvnrYrSZJb15pT +qG3XbiP1boMF/kV1Phv63dB3w5WSotddisZ0lRoiSeR+KscZy3PzVz7saKg9BZxlXtgA47QRMg4b +ClN2Hi4+HIZ8PD/M3GmU5EHDNEUAj15xT6yq+XPjHWiXcirvDvfeYxEgsOmMQTlQoWMKtDiO1aLH +Worn8eIcB7XtxGhXW0Z00/wyoQSamb+ZAwEOqK8ynrWY8hJVsQsl88SXAwwWBgnY30c+b29puigU +G8++8mjOOzTgDR4NogE9GhUR8lgwkrAAmjcoAwdvOJkEBaAAkbE1oadPbCOZVsxiuLVkPQBOVqCw +gsQ9ZAo5BX/eqRYVU+L7Listbk7AokBHZnIXIMEOyBB+oS8NV0mcZmZunhoBvyOTc8nT6N3Xl0gX +cohUrBHppISGxj9VzIrmDmFFw/eCOR1Z90K6+wTxtTMoc2WGFgy84qD1yjPBP0fyHZ0hdL1afFyW +GVlm2TwyXQMKjPvOqbUV0oUtyYriW+An7RwlrACRJkX+CoKFakmgt9uWB5FV2IpiTdlDYEZX49ke ++hDDtq46l16o3lOER6j0epwHfh290qfDiyn+fObjgADf0vi05HEdP/yClbWdG6HWedU796U58cHl +x0x8ZjVv8xgjtAJhtIZcywvnFeuG5NkVDFsde/aK9jBSMwp1+6SBjZhTQD9jn4iBs+ZubP66iWCK +BjMZkPT5rhU/gImN+AGU0Hq2LBtC/RFHwBWQR0cr57ZBt1ejSqL9TIoo5MBZEEdangm8N2dChTy1 +YfIO3FsjeN2uuUmS5UiS5Hx/00Yg8Tz196mpSVCZYEQougPAvZFaV3tvOMAvNayCZr1VrO9Gienx +cVdjO0pvyLDFxaHHBDmjUsXnc93/znRXqvLcf2N5gTFU7nKL/4Q2UvXe6oXy5F4Ksw3yNeFv3BHq +mm9k0IAyXxaEVjKxdGEhyV1PcoXMP6QEqQn5ZT71yNcw1X24YtxQCfrgOOeWSuF1Nu00y7a4QyYN +LsBLD9lfbdvbbUmaD3qVNDSBf3ZaH9rqBKmOorlUNynYMt1WIZ3PfEPKZ1KU7zvXZC9UgSrrhXrN +aE2o1zwXoQU9LJii9SXOhB5gANDdQv2YHgqG1Yyk7ZB2ZVbvHydyLa96+6y8HPLkgGRY8uxxupk+ +5dTQA0cZCFOYm9mBZEPVAiBNrC72S4AIjv4+bMwhVAepfC43ZDwoJR+qwPcFo6kjFV7PvrO0pz6K +j4Z8AU/xyeNXrJ5U0VtMUKwAMk7Ly9/ztfb9Wh+f2VOnsoMt3AWbOzKuae1rQqqhrpRgMs6nIn8g +JcrjogpFZfe5x9e75G/2U8nnDzpZ/gWSUJRPSWMwiVpa+16WVc1hogWQ/MCHwQtFWdJ018YLU+ld +FrPJjdfMio3x2pBKW20rbd1bwpdeVFQIU0umCyvmaqoC9tSfP9MKFDao3rjUlJBfiYD7eNRREKtw +/Mb6pX4XvZTllEK0PAxakFjeNG2UrVmBcsF7gVVmW3LSQ2YhPVKCCk284/1Mrl44Win60ECcKsmj +wo7HgWZGDxwJBPkkMg9w/8webrfSmSAlqHR1xQ9sbNJmvZKOEkMZxqkSBL4jNCvGrlKY5osY6HAP +SO1OCc6KyF//oAcxyRShFdPLcZepn3vhS6B2ydBvxwlTOeczpXDAYTHbxneQQlgXCsAuis89vt4R +jHqFzUi7fnCcaeLYwhUYhpSZUYKG2INC6WuP40YtvraplFO3Ug6pFEVxVOyt2OkKENxQtZjfgIzC +UKbg0kAwMAc/93hMFOBsYRc1paGejwPVFtxfZfoaqYx44PGOXiGp+GrySNcy0hVtP+6ej/u2O6NX +h9TBsCnqG/Vt+42TIFVyepDKcmCJyGErXexRHfOcyXBDFORpD0PJAV3qfjv0csa9s+1rpEpojPO1 +9hWDvriEwLZUUmIPLNKOFBI9NIIFkHWtxNIcYGQ5xq2uzrPJM52w7DhOS6NFBBwgjFbAnQSdCFlt +JKDA7IG9vDHWc4eyn8pV+thiYi+dVPgaXYUvcV1r7tD8QI5rm+gpho3a3LKiacksIsez1/bSIbcA +W0qoYdqkgsjTUUbSia6ms9oUJzipfVJAQL9LkvCR7mGJgyVwuXez5ECBQbDwYQ8E6FbkJKhe8r1s +9sSntZXvQW83BS0YFiNh3+7+m4jqKeKW7ylPkALCiNmfXZ+500CZzDv5lobNzBbAc2fHrOCWA6YS +Qp0dF7freu2RxfK1MQN8986Vz8dBoYNIHu1kZvtynxqAEiW4D3pcG84WoVjvd1n+uRfwXgV042Oe +nmmDETv2yIQmgLabSENSUaf3lLFdYXeVPcoDJdEkLnLD7hptTIt6c5j+fJnVV164bCFEUekH5d7s +kZtqkCkJfpYNcJBRqo8TqXCqApnXuTa+niCU+iiXQkwAAl8VtuiRssSH0i75dkCT8XaulsdQXo2t +LwXOG8Oj9kjfpB/FleZBLTmxNpCHgL/0OlPaWIXdmGpUwPigB+m29sD2PDUeEpWrQDZmQqyOW36c +JIgVQz68+r57xImExT/3yBOsDPTic6EK99FxUOAaJK3BH6Z2OW70CMa1zHKcNxdlZfwFjiZfqpuX +zXg4N6gCyuy4Xnv9Yl+Pe6Z+6CzsyiA4f0i3KyY7SPmTgFlOOjDBVTWG2Mos+tqDWgrzLEnH6wbb +PPeCgUacIsiYjx7sg+jUgUDe+SqLxboNIPsioIDL+KFwFjssMOPk+qZQ3BfZrbJJL9XU7JIGcABJ +HvEcplDM5x7Pa3NmSZ974Rao0q662BkfdsPA0nKV0mGJmaKuhhgOOIgM/YFJOlOkJWYGsTNLyuQl +Seaq69+YiigfcitwN0tMrggO0IGklRDMQXJmWNhSNTjmBGGobpsJGaZOuY+asUEkBuGHCkCHukh6 +V4wjz8PTIVsfC2O6DUcEAZfpkEDzt7tIp+4zeaF2bPdjsAqT1G+lzhKfScPMHMkMPpOYbRO9vERg +xmAAvPv850zpr8wwHOwCP+iUZoQA/84W29WUdkjDuzoQinztwZo75q249tS4UuhDpUENY1jxZXla +ZD1XshxiMa3AgMeWcfm80SuybxA2LiMBavjwIBjMVlopVaowcJn50H4U73IDYqQYvhLtqBzULxlu +bUv7EuuBAFaHnP2xedey8dZll/rppPnBvD1PWHSpVHKYdoeMhqdHMprAToKXa2orEEbD4ax5DL1K +ETyfDxTusQviFOhaehtsxXNcwIeFCIwYKET0BS2F4VhTRbU6yvtmusXWXekfJaTQWQ== + + + xArtbO8l4mPrWjlDTacR/ixaLX58qAbMRrOxJsTyrsgh0DtClgJkSP1PnYSmPR4aiT2tY+nV+9q9 +kshAui0vE2cUesBp90JAolC7pmYXfyjasnL54q1jC9Y3sJ8vlaWaLxVRW3kYl6rbMc1Xq4rtrvY2 +SbUKBzRdHK7lLndlxst1sTnXw5LIIYktU+wjKMi72bSUTgAFJHjFG9fMDPlwao9MnJNNrHPAcSp/ +MS9tp64D9kXZupr4XbDk4QzriXCMZKo/MOgpqdJOUfwsG1nU1D7w73CGoUNAChXBlJVXts2U4Ijh +SS4N+b+36mZPWOrBLOMG4RTf5s8Vq6zqUNhAWYYGuRcH9gQtf2HdNY573OGYvY7dmISVGF0rf276 +50DUl+yOPZbilEwQJB5UHOGltt2OaBiHv70nRKARSFHNIIlWzOyi/AOfjjqzrOllHRtzpmQyiMni +RaBVgd5bTyXFZAAVtB5uONVK8tah9ifL495rxTEmiBqqvdZm4iLxQHurKNuwswacZf0dLXswGDF8 +BhjdehSdlPMOLmvCFfwh+taUJTpzxXXoLxmjpp6WFa5ldb6J9ganXLDRnopkWkdFSOIWiUBYXwz4 +QZ6UeRsZfubt+IjbOvMNqCCMFCC+h/Dp8OmNfSF6xsvB5Q4WqL8EEuoeyW1Dp+WmvZdc1yChHmf2 +WqTeMWy3zo3PL5gi9DaazLSSkpP0GIi2oBeqomojldPyTAqRUld41J/RBqCaHZ+Dvtvqp8AaYbdf +8kzUd+nRpe8CagTWiU7euXYP9sEcg1FLQgMwJdnK+VgVS47F+KoOGMg8mpzJIyY5CULOlAa8DPzI +Y8x9R/CrwTWcM5d/5oy6+YwyPWJyoSr4KIELAI0gDUSS/DY3+4PoivGLaj1yc5e+5ckc8ycxtgaZ +yQ6IFHtlQPvuVrB5whwDi5aHcOjRtrr3GZtTkgZk8A1TYx/PVpQz8do4E1mtN/i36t4mBnU48iYo +OnQXI7gsFHzhVsGUvg0d1pUJ1GOnkOBWaQXFpAxWgFIXyxm5XvMkYAKY0SNKEZ6LPBnykHwm1d3q +lX7lnzdSjpQuSDmzM/VAnZblcV3gqaz1I0ROrV8OQUHv7xAJCL3dWjOdpGYdYkiHvcxqs0cU0Qgh +UNTMicJ1HidWjrERhTrT49ZwUgqbeRrvM0Z6uxFWgMINQGIK7XIqjpzHuZiZh0n8wakLpB3Mpkt9 +5aHTgy1K+kZzegyY9hehSxtTy8k45Wm0/G7imgY2RdyohHOSs+n9BWw2j+ve5YjTYsfBBGEoGCOH +gtMGFaVI9wWVNUWxqVSupjtIF6w0swYrWZUVCHTzteRAY5tpTIOTFjHNIR1sgq1spMqA256PwL/h +4krkozbvLDu1RHJmx0aupUZPhBQcB0bmoOA5covxL4Zpd9z3x3Cq3lQ8MXSCBeNFxwKxWvo6/HqH +Bzh7AUFsgD/ZxTnUN7D9IPkG0pG9Are4Em48k4KcH1TfADby9oc2qDGXDPvyJXp/7P7cRIqc6lnf +P5iMjsRRPiDQNJ75q4V5wtzFOhsSDFZPNl4TR1BWgbX1zdCKLjcAK53uDFpOoZUJAxazcWaSAnNN +Mh8UIgjEAOaABewzRdHEa+dWqWW1OKYV9MV88W0HsRLFGnrrVat3aCPEZMlbjOUpRvUDrp/B8dqs +wc6XPGwEP9/US4n/KUpxiv8nC5gN+F8ULcE9zzvam0328hTDMaY00+W5L2TKyPsSGXgUUtkcntAV +5OFjOWZLoqq+UIVUnOsik1vu4UvLaC9mwZnoyR8ZWJ//iGOYHAy4VBQ+uAK3oEB/lfcjd/Lr3Qsl +XTI11Qx00SHcXrgEZC5HvZx4np3JhOMgqmlAnskeUewke5jnLKE2z8KzvHEjda9JypR0eyFhQK/C +4LcHAXZ3x5DCm0rhIwqGCIaXQuW1Y86rsvRIGx0Mo9cjaXRt0MYFBDONELrFG8ourD5sPKjhIy+o +sRF0BDm6SF3hlrIquCtBCxoCoVvcbpbd2ECeYRbQuD81HyKcUWmu57Y+Fri1mKqIIFh1OQ1xWuxk +m7L0sGAyvIsF7pasgIMBryF6Ta+CXqS0wIyDwpUFB0YtevAf9ki7ykM5KHs4wdJDrnTP4szYuOjH +idjh0IlNN72aVWZsMVpe73FLtZeUasdTkIZcdytwlJ49Lt0w0dt6cLygA8G8K/oOXSPfwziQqzl3 +3rpl3tqArWf5Dtn1QgAwtp0Rya/UXJ/no0zDp2xir3fwjeUmW2CF1DaIzCyr3jcMqHmZu6wUHCRK +USaq6gHkCyTBfmtv8FHydCIKPFCVJU+3nb5Ee1hgSDGbOBjp9iKIB8tLfLDBmoDRBJxUZUjPtJVA +2YcKyS2/RV0FnJ1HTSOvrqcMFZyxSCqzofFzYqtW11aox+gHW+ue4J8JqbbFN4vmnZu8ohJAfJN3 +rh4AGRjGhsBFzR1TrBTKrDaUV3k0ZgObbnq7B1FM9Oh9JGavW6qiXmRD8p0fRcDrUuiSxTF7Dd0C +TjR//bkwhQgzj773ojwyohrKErTXdGAlxqABzvPj8IcYocqKWXLnqBhqP0XmIcWAyhsJrH31R98n +5U1x0r7visRq3NUoNysLJQkdTkvW+UfcJy+JoWDJB7UUUw1ns2hgVY3roao2KQ6dJfFJMTVg7/Ko +JsNypBKM1WOqNBBIotLAvk/khwiAGN5ASoogK0plS4Pb+CkvKW1H+hfHlfkSN5wmENRDlFQ/CNpz +hErpjhF6mmBEYtRMR1FASdCPNZ5W5/DJQFZMd9B2HHedEp3TJAWO1MHXV1NBEmi1Xe5hJ9fc2AtY +jZjGOWAYlc1pmM6uLLk6zavrtItg4NsvzWGRo0gZki1nsJDFtjKc0kzUxbMMkdU+ZLxBv8292MZl +IqzirWp77AbwfMeOngz0BkBQ6Rusjai2dXxcud5zYy4ZAiOBeKnOspjxoFMeyRpvYMKIm2vNyGjy +v/V8YDerdMlbJiRWoet0s72RZHNvuSKAMN0AdIREWHzoMUfUpFwOBTHjroUhqM+J8EPcf7vnwbkL +rg2hD5HsVT16G8RWNuRxUrPdBJjSLlDuDNVSy/3xBbc9ZHgXJVW42KHlGLiqY+Ao+aua4kjw2E97 +KNxGerO7xNc0b4keZe34kgeT3yLBqHEJyUm0KI52Sr5umWyKjfip7XM5835+MqL5Y+4B2AIbiMYT +wxNddQBS0oZNcWfxDbDx7ATvkAjVxGQrZ6jtwyOeResXJiTPnixcx3wQgdj2rr5tI/4wwP4RSOYR +CGngVaoeRX0AnnRP7h8NE6wMkpgqdvZ3PUca0Yqnsat5298vwgAXE3V8CDlPNx9QszRNAzFH2tnu +WlRpeizhSTjl6pKY/O+snd2qNDmWnq/A9/Adjn1Q1r8Uh3ZhzMAYG5/Yc1Q03W0Y8Ew34/aA7956 +niXl/mrnrikaqgqK2illRGSEQlpa6/1pXN2RUmGuBCuHtCcQQ3aFkF0bZsqyI0JlPo6GlRDidrTO +56VECYVf90UcxIAhC1cOtYE2fOySsDSkLjeqzFEfaoBrcfVC36j4Hbm9jQTM8nN8DP08sLrMNsWG +q0xKo+XkBnB7RCMpLBrEXLQc6uftAOhtCHEDUyI2vIAQ9TjVUgRHnQ0aIpsVAlQnT3a3FHVgpBL/ +ADcmH02i/BJYWLLlAiiPS2QXFRiEIXRkhKdaxTsi1hDMaqTi2wenBrBkkK2PvidkA/TFQR/pn73n +osKOH6D8OqA1MIQ4c+aLrUaVngQcmxaB8iyCgRuSLj0O0J3FDN0CZC+Y6NDmGFeigoRpF8OFpJ43 +xXqO6GUE4yqFe/KGOWDBvQnEFUR+gYEUa5dMRJIj+56wf5UZ5/DbA8m8dgNISWGqfrCVhAiwvYX3 +vuOrbyz2MWSgERGYULei1kXyaQX+QkpbnWjVVWCsrDtnNmtHwQEYzX6dyZjCo4a+B2uPyRK1H8E0 +QB9Zo11KlcTLcDvaixdOuc+pHL7ykjyQ2Qqx5mhVirs0AmDs+7FnEGRCQhaQCdtlUltPuyJFhEMA +oqYiVq9GftJj6DyH2EGJlaNEgwEi4k7Z/EK+ZlHl+LXZOH3+Med5NPtCIveaYnwjlp1nSKq/VB5X +pIMrSb7IFjwuvOJ3FnAZqvdadohvUhnQ5Xa/sFOCRH+9Hf3KGIBP5YY9wUHlNFUxyYnrysyhysyl +muWmfoYtMVyE67TBwlOZNvd8XzHDAuPs0ECmY4WcpfISYaObfZNNkyIn1MjTEBt/h13wCp5H71Pp +JIQyTBJU8tGcJ1UxDqQaRQXfdOH4yoe87CwIS9xJYKzOJWhCy2ZzHEGmqqVoIy0jtR/eATEDqddL +MpWGs48MdZhlhi8HxUWPUC0i9jSw3HgFvPvsQMi1v5DlTPOOOdKHom/R7d3vXZKt9pjNHCaRQ71w +z9tMgGxrDkGSBLRRgPFJY6Ar/+CqC3nZyDiFIoryEyV+DjepH6tCP2Ob0UTz2Ng6OYtytlk0EOYC +G4FEWBS+Id1BsqLYIDf3Hi4tjTYzukM0xttH6MZmfzesohyFTDc+X8Q3aHLP0J4uN4+GECaIWh6v +Wy0dPxAzw5SuO1mlyOiH93NiC4rTDmDqK0nYIntGFMjLst8sOTVZIQxTvgCaByod6rFTw5LdYApy +KpOSXvcrnWJN0zYXn8YfSO+bWqZUR2oZ1QW+hfCTGXgBFPt+JHQQSJBcPIeNMBYAbpdQlek++NRD +8m037JUABfsQ7qch8gYLuXelS152MjRatNqNSHzaSOaUBtX59gQHgd/zqMZjA6v/wsRKKfG6XtKc +EK80rQyuHLx1iUogYVNVAHrygVo0R3ZRqgvyjghTBdrnqlrOozuoWBc1FdEObAXD+nq/quxTye0R +DVMUCh1uEuj7FYIvXk9uhKJTE0iJxLwYCR0sitIjIkmLmUG0yFweKRFQ0icWpMRHarIf6bGQEAVO +tjd5GATsKVKnFx54xLBPUPX2i2/6tYj8Z5is5puD/Uu+WQKqIeyKG/t7shbaOO+hq43zQV0dtBQ5 +/IC3tOrGhB873PadCSRRcvi2Pz9blwI5PH9wVNjXMC5IzFCcA7panBqzDIikjsyMwxVEEJM4dS0Q +IjA5m1EgPUu6ATfr0X0FaypBtM3NCzqR1fM5BNA+rEiMuPUPfpcYAlxb1t2dstCBytlbIrKG7lgU +dJxUwnLkRILeCDublCCZyiwtiY34CBIkcIAp9emZHcBDVcTF6f5hFmJ+js0niI8jnhvyjRXmB3me +EzsG8uERIRUYyB0Ioo3gFX/ZSw9XetVzmHE6zNvBix+EGKeHoG8SDOv0YB+sA1L7OBGLM680nib0 +WvrNlaGoTpkHA2GRLrRm1fmjQzXYfS7ausVrSI8R18rnrxNRGGL/2anJAebA0Gf3AoHUpZ9GeAqr +pNnBp7Y7VKVy1/G5J50kg455hDTgIJucxhlMI5SXeVK6OaLaAE0HFVhnnedASOG/gA== + + + bmAfH87zbOy6UbV6IyxBKBWDDhcnCcDjObAMe8lDGygPZnsFynngr/d4nBo0l9zDTTQFbRY/AOq9 +pAmWCcNkrHSPaxixGxMmhlmXLdAVO7zNcXlCJosarzW+rTXugE4Y2wIXeEgJ9R7fdON+hV/TBJqv +w6l/QaYwN6Ve4A4xkCqVpBU1OwfZeAdVsllZ7mJQjBMS+EnH1mfCogauD854uaq6kiMOC23vtZCD +4nOxZmmGvyKhuTq9SeFwyzU6lqAdshCkDgPpFa7qe1yUEDGUpZKxF7pWi6AGxzg2tXAvicbEpkJi +LDX2rtjvjAPtBgToln9vDuGqyvxE5I4skeWEL4BaELBYtlYkAlGh4faY5kBdhGTIIzUTp9/6IZQS +ypInCNS6U8Hg51nS+OlxPD1jGt7vJPtDT0AROa8jtk498Vb8eRVnHA7sLI2krPyW+xGkkq370sOP +dSzdH+MSGh8PLaX2cvHSJoGBSUF/T22MJmCPwtmgpq186m0KeGCzCc42H/DVVLmGgl8P4YvcpX/K +yqsuRnulvuloeqkNQOZg+PP1U9FmC8C2xwlNnD0ZNbSBgSxYlsqPhtL0UJqRlFvPpwe5H3q86DX1 +0AZ3L8qMdgKjj/8DiAeHjIVI1nOSwFyKYEtJQdEBtYzjZRy/6CpGCPbmxva9oslLZfbIapNiiMb6 +LoUmKzLKSMT8nMwUEbW8jj2mu9ai7LgO9rdr+gnaFJfQ8J0gc4M2X6GGQuEIFaS9oI9JpYckHEU5 +1MaZ/qQNxSzVUoxy7GPJhSKFWi+jal2CV4ji5Fxv9hAAZZwpOFddIxL5oLWyjjdl1PZb3XRCfNCH +qMGPBA1/MAYl0BdM1eg84u4XmOIVZaggJHSjg86oIQFOmI+QbFfygd9AtQxJT4AQVpOuako5eANM +7pnUc4oXcT+ySYTDiQIV/CDUE9VJy0rgFQgCam7iPXDXnJHxhKV4ma7P4YcSNNV46fT9pDRPJZan +FRBTqLApEr1htLbD1qYM3opVfB+D5JuUxbsw0BhSdfuCZyhp+ST3hmKGWMXSGsUOpurTcU6d1A7n +Lxw/uLCF1El7nSiWDzYB67ohjkOczKFjoSYgPK1yCLMRdi051HQQIlg0Bj/cS7LnU0zhqbwfA8g9 +IKA4F4NMyHeEb2VKrTw7xKJ/zOOwM6CaVCNaLCFxKfiq6AJJggLOawpz4jjTEZEr9XDr9bjiNVD6 +LO4MCjnFYKfrvOBhBlYMqfkeYovDnJECyk3x1zUDU4XL8hyB1MnosBKRlmwlSEEtMQNEHVJmHzVV +pIc4aaIYIFYcmfBH08TUPvSIDHX2bkwrZ7fiZF1w3WQfDp6Q0FjCXQue+wmq+UKBLfpwuBskqcdL +Fg97kbkCJFKu0CBWZ0R35FeUyTtOrdxmitjfLMFe+RSWZN55tKpBkBJwCwbBEkS4fsWvoioCoboi +om/c3YzTBQUjpHwfSRn7dK9lMYdfCJ5nPCxSTmOGZlxR0u1A+3ZDRe+UBmYWG5ycgTXN19ECrly1 +EI1OBNW7U3EjKRAb9bHK6hwdgj7NRqFHh3NBBgL41uY7g5GxbbIBHt0dgaOGJE3SNwkFMKJdRPZC +uwsEMqPbBPN+YdfZ3n2ggXRSd65DCkP4r5qPVDISxQGe7FK/9xt41YATk0ynhgxDnYQAda50MrhV +O0GN5SFixFI3p/IljFlKHsAGVJtkq6MkxpIBkGIJRHrQXQl0BwrfEoKfi2LqgdpMR16GmAjFUWIi +nD+FVZuHTJQsRxzH7RylNSWDccYiVmNv9fTArMhBJIJ/0tUUolwq3nAkAeh7ghVhhxLgQUeJj4Yz +UcMNlew+P2Q0NRSx8w36eqVAMBXwuoqUKar4DC0Ey+nVLFfh5PWEyGboYO3f16JDRe+CDs86d4yq +KrvuCliVHigWT7w10nfYWZUAKzSs8CcFbUUvDQfswcoJMlbeC76PoHNA+xXxwCkywuhkqaKUaigt +swyudCHTKyqKeyKYVOkNzEtAsZ1G0p6dcOV+eiQ0FGHqCpSFTP4MqFUAEA/Qlhpy9Tam0GOelF3U +YFxHmI+cpwXQFrjR/dY055V++G3omnbLrJ8cb15nEqKVmGyfcM4ZRjFYKKF0NkKkHiCO95DCBJBs +EGtsF8jAwZmDbUFAD0O7Adb88QylACfvaBPVMkmQ8gLbXhZEgz4HPielvdnDCt7uYZZRHsA8NFWK +SgMCfPrAxkpD2vH9srytohw1BHKwKdQo3UrhKCaPi32NRPGadQTAuIMsUdL8J8xkIv2w7/BqF9aa +Qr+AF5zdEEjMQHAI1W0+UlfMhBx+C8F8bWLUg1gh1RYvFqrwTIQiagFzLLFlZzCNIxFKXM+WfhyF +A7fovH/raK4aGwTfs4RVmUr46J4GGOCsBpSdUs+vw5scVGL1WKSEEdFeZkI6fcT+DA3qJG32ziP7 +ydVzpnMFatpHD/loSNN/dyYhLaQ9TPXS6+h6krADLC1NjOusWQ6uZVE6EB/1HCkQXbxeInE9LD46 +7iVTpMOQdyKQVC+3vTLoZtMCiTMk8cXbqNMXcn0GnNy4O1tgIMv2gvHCPItzzQ5cnDQl7FCbDyhI +YE1Ab7sL7MfYZyC+fJcDbVIQjpsYfo6gaOLHAm49y8Y4hOaE5T0ZIAo4XQkxTEj9QbGMwZPm0qjS +mHKRqnqQpPZCMrfD1yjRi7FML4QL/u7fBKnDfBdFFfa/Sv8157fQt0OzU0bqCD6+rJZ2dIKD7JHY +rvv+IGrB+7OuKwyIfPfRBAqZgdBAf2HImWJpz0dHFf0nYOEtRT2W/cg15gSPj/nL/kmhZ8pIx1WF +/NEUS1yqBKIc+pu6T4SRujrRManlY9ax/0FFcR4P1uqLXzUeZKUlOpuY1RJOxUZndwGc/TMFEKiR +S4o9lZFF6plAG2UQF+m9hk1mREibihIyF5sd3OEswwEF03n0rGBy4ou7F/a9czxlEBasakxETgj/ +2yS+WDfVvz+bOPkvBV1XiiHloIJzGGFTOjPSAn+h2M0O6ImuAem88gtIBBudAqbXjf0IxMnAUFGJ +d+lbFneyFI5wmalmgOY3IvWrGqPFE2nHgVQ6sdupbrWzYsrXZpNpKZqMwyOzu5vtR/gEeeUfD+DS +tMY+0EDkDSWwIvQBt0hQIw1jJl2Eo0D/SyCU3xLp8u9+0YjxrzzQrzgcxr/Zf7/yGpTdUR6VHFFj +MQMg42u/TqR6A3gv5L3Z6zG7+rmX/A0nsgXn0Q5rBu3DFZLPl/vScqJ8cm55vRZA0KpgdpGX4zVT +xiFDU2y+ZhbNUDK2hoOYELv4IRj5REqVUhQU4kZhYNEYxh40gBDMVEVRL8TzHlaR35jnG8lvvCp3 +novcNbq5zCqkWs10AoUw89caeZKomuc4nFja3YCXmA3PzYG2YzeSweEirzgND0JhE83JHTip+cr8 +zRWWEKNgIjOKv+rZ44k9CxO+Z5lRnmW+VbSC6jo1kyt/D2+3RQJD6J42ywiIebi1wjorZaHT2gUg +/wOZKoYGMEoql/k8nWdZZUWc8/vZVQPax7ypbR5jybrjY3zv/FxJ6mcZStHQgZFhUvnSoH7CF5BG +YlR4C+scDSQhn5OVVuFXSX1O0/R7/piRnjCZ3z+6GP8AfFZ0/QkSK2WB1Ch37wkueW3LmZA9TaIQ +dRtchHKEeuQNdem+XzJFRT6xCqDiKQNTePt8D4V8BBjf2nIsIi1PrS6ohovdIqDl96s0SiwNaJeV +NT6P60o6MlKUMa91v4NsaZlKHrYp6ow0k2umGfonDJHAjRy1K5sQTqLyBacTnAslMhswQ9dPsikw +LayCBgJ1Gvb8YcMLdEYj2RM40siL6by0tz0Nt8pe/HzH3yrld2b5ZnYlxBP3lr55tCuG18iLJTZk +WGM9Vt+FcLQU2RtmFBndwOggrb99nr6zuf/cSEqaBF1DLQvWp6UnBdyuh/Fj5UUzlDVWNBwduCaX +4fVRw92MpNE+PObCAKkaeZy3hp+Nis+NHdwMAxefnQapWkVFqUPkXxgW0+elvpWYn3IYLa2Eb8MC +lV8MLJwKGsUO9m1PZV+qzO1kKvgXv1RldyrkSJDP/mno1l2FRNsApplsAAOENAG1p+eYtxJ23oFZ +wnKRtlGog6fwP2pmnsSgpMADpcA70UBoPnVzu2NyWrFb4B0Zi4S+IBcZXXIHkakgxc5KEJ7SIYS3 +4EcD27wNsW0P+t79zEjabTxmv/t2rBw5OhWOl3xE0iot1i3SG6xb6Yqr08vszaIIFL2wBqcXu1qP +Y8Vx9xCRzMI5FQh8vLW/vgD/q2HHX2nbHCQ7661mDEkeZV2LLAMLsxVOTx1vT6VIx5IPJFgMLT+r +yuHVqWOP0lEtknSEeO65vgsMRTUqKLi30KRMkdcGmWgDMfZuKEj8Isht/MXhLDDuBYIxm5/Qb76H +q6E2uDdt5GofUwbiEUigo4ASVlQB1UIaU824ff+xwrLucH0KKYOjmILks+rc7Qc303A/RJjxc3JT +RT3AHXMelzIWtEdwEMy/lyOPSb4dDCdXgiZHdR5h54oHBB5ROQxJFFYV9r2nGj3se8jtXgyqGwo0 +++A6YnyBQKUN4sf2t7hoFvMAMhwY9G7oMKzQFUoXgjnPJpqyEfql3SpdKOWSoNifpxJHw989oGzN +8wf2pX+Hsp3HwWbPBoZNxOtE0GTf3ICYuZmMqyWo/pcG3I+/4dgWcWsio8E5ixq7wkqWtvMZ3g/V +NiKaUMa0V+ONBGzSnqigaz3ITvMp80AJ6oESINAErEzRUDDnKaToAo5ALbp81OrxRqOXjGfBBisg +CZ0qh9X82k8DLKfdgHFHcePKVov6Szlf1QJ0n2C8CiTHm3oPk708BimOTMeDnSfLDoUXZTBTQAgi +r5SsFitHjVWjXJe9LRQE/9Yjdr3lVDlyEsTxdhggoFJkkTPqwREKcpxCu930SDBcoTHPMEvuUwwe +E/uHrYFbr0SmXvPgC+jak35Tlf94lqary4rfLpnwriZNGCoE752yJlOujryPZ8Le93WmyE0oxdqD +5R/oPlBl4eYQcfFe7jWj5jjAhncPeDXRA1IHCdhVA1doKR7Xg/nyjOkxZZAMJmLM6zD4CXpWDqeB +pKAFUgVubNMxkm5klLppIk1ZoMtkKd8r1Gj77Cwbr9XIJI9Fghx0bVEW3UBzyCeWOp4UTw3Oj2B0 +QquwZfncQxinOZs9Xb58WN569VMBr6DXSpiIKNQiLiGcfC3OY5sp1nzUm+Sl+lzee/z+5GClfKcd +pIQU59txDqxqD02q2F6L5UEb2Cci0VwDviQ9bzCxXSbxWy/gzTpwUmh2CT8JcW4+tRbRSUHXwucm +G0Uox0dhSd2/GrECs86Y90QzJIQg04UBN2wUyVI5/JukRJq333s/Rq72QvzW/YQMSg4CJKloNUKn +CHAfOkXrwiJIHaJXAbjn4Z3uhxQxwP+siHrMiewe0MKix4hxJqZlN5S8yuGc5e4J0g== + + + obpU1xLvOBuMSJei1c4NGaok7P36KU3sO1ePV6iqsQUhweerHjWcZiln9efOB597QUmgvD/wED+3 +vputAxJuESAdocbBLjF8bngmnz+PcXwc13BcKWIIP3/b6EfhpyrigBrF1NzncwO4nUZtYb+QL0Gd +t1669JEBxlEDJg6/20fZA+4DQKx65hE48Xz5k/1q/jyrriu/hhRbOGSoYBocQB92AnAR5VWpZ5Rt +Q+zy83CwKmLaIj+RLb70uz1DEdB5JszdUKTN7IIOlC9kGAG11XAhzoK7niObSIUCh6j0RP6lkON/ +wiPeNReqIWCEHy8YIxKRLEdn6pmmpJnjHiFmcrALUifANdjTC8Tcs04+Je/HWSKF3+3eNT/tQ3TP +5D420uAnBnIGM+AIgbCofUffK3rAAKPHw0KaytFprR1RjTh+VpB0fBSrgTWskDRFppyTr3kgc2ES +nE6avuHQNqNB0e7aB/DDbN5EWbE9s5QXYKip2wwd4RF9mUwSsdMRdbg3nZIiR4qaO3wu9Dl+PST6 +LTcXoO8VAWiQKRnT2FeCuQHkQUASND5cboCc82y4XbgsBMe7lSbF7ZgVt75n+3YY3Ba7Bhopj9ql +6qXB6kRshx6B6IfkcSxd6CUBvx1PZnux2tFLR0T3r9BS9v0XyXWjXs6kQHM56uz0kJcfPBSPMT/M +S+sxPGf1yxEQPlrkskFsXgJ34qJGBYYKq/Qi2TOJM+02tHptRyVgFEkQ4MNC85gkto4XJopA2UVA +QGyNnm/I26yjdgqFXIftEQoS+5Wvl2M4AqACP7WCE0bDJlC1aa/JRbKF1TSyk+e9XcDDCBeaLLAR +KxLQn1RjbQxQZlZk8vyMEXYNVE2TarrlVGqB+/TgIVoIgj4GQce6l8JyZBBuD/WAIJitqIypQzFy +QL9eZ4IARK9yrsdZCylKmIz22As9PZhaY/EixGQ1B7bpbwL5S0NUDgHp3iddzFTndrKme0Hr4m73 +oJUbiOxwLxHOsCjvVzkneZBvPcqNRybgx/tQZsAn7aXJwnG9lwiAxKhppsY9By21vglqVmDD6EES +3v4gPo56SjtcenTS1+sb5JHcr2oA0EEWDC2J91hRD0Cd+XJ05uf17snhzoGTCF7EJCwCEUdiqQQP +wUx3BXlVOKxKK/DDhCaz4o72+txL/Oxk8/pSmZHUbtS0mHpJ/DQFM8HdjtNjnB7P9ey4wh6fG/VK +FnksfC74ZArFIv0ARswiAPE59H0YNP0k4/fL3d27RJng9LgEYMnwXWVr05n2ait6qVHC5Bs+L9N6 +pjrGeahjLPPnc4dGAt+Qol4fs/c+6WjpK3fHw+tHY7pK+jFmUvGDZ6jehBER9cRT9XjrcQfNVFt+ +3775VS/KdILnK7Gf9jFPbL0wZddJHQplWAONZigKDFlCAyC3l+PPAe1ItHxirxD6zVUN0jjOE0Gi +ClV4G8lQI8NA6Q/0UojXHsgeeqDt0pLEGJCJHCqD2SsseGC7q0CQgwK3e7B5jh6i5iueBSE5HoN3 +dO3GPJNz2F5BbkLQyqVOOBBngbXqftgk9wU/E+CHEUQOpwjqHO2SbsEGGArU9d4jTjDDbaOijrNO +UXyu02vE0xWHD56Ack2W20+sUkHa1q969B+OvwY2FfdMb70gi/J0S80mnMDvIKUFRFvFaSxCBWhi +TTKDXP1I48Vzrz7vPTwTwHboYkCp2vjqOJi5a2BEELYCJ+AsDn+gKi/0uYfVO90jcIo9Y/qtF0Et +QxhpmF7DmkoPR8VhWMnLSdpAaiMqZf6jGMMGkM3Ze4/7mhbvDTnv5/niOAiSSHrBpSTHcqCOCRjZ +8mUP9goCIKwbXT7XQebZazirKDeiIwn8YpL1IUCz1ETEPSWrgo5o3nTkqTWw51lyd+894t61gD7g +sTaUkfl8nKvYBb2ttH6iqZYimsoKm0ctfs+N8MBBMSl73VnS7xKLUbbR4zFPqvCw4UMin1BPQ0H/ +AP+sGj3Mu+we+zG2I4XdjxR2+jiuXi271xBupncFyeh9dgqc9BBss3vMdlBWkRvc40W5rBQRN4do +I04UbhoLfME5Twt2B8KzPgispI6WhuKZiG0xKZAJivi4iJvcS1mPN6Fh+6EvCD3K6dHHKwYRNQLS +Au7QWy9ZwRE3cp+GKpeqguwt4Uy9ftWjBbatkya/wc5bJ52huAAzIo0AgCcCRpioT5gQ82nBFAZ6 +cyH/15TfUW1nT8q5vlS3ekzrNGqLglQkiq6lXzUBmNndHm7zwfWBL7AHSw09rrqQrHRm/fKs1wlC +e4NwhXd1PofD21A+OWeK0HT/8hJnMmuLOhOM+3gm5TyTdXqopdpQDbj8zRUb/R1sJ+yhePqNOa+T +edXcM0fkT8ZF9X1EWk0rM+tB23vvcSBKe8wp2P/7s3/6eS+VwnoohSF1VKyZoR6HKM9XIvXoqz9f +S9M7ermPDT2jfjpNa4xN7iCbY4W8EAAgs7Kv0v00AjTSD0mRuKWZJ6WKttg8vLI9hymrs850sseb +8HKWzgrfDYyo2+jnvNXcQBYP4tUnvCZJeLx3+P2tbSnmPoeGz++Hedbl0IHs7rFNNX2EIizhxluP +LxfIt157MVFsHOVphFzK018EMEHee9KWCRA+KrBq9g2UCpoP2W8KZc/fmX62MP3s8qSO0+TEvpHV +CncuRFAKruZSlDC5ILGyACMWyRipS6JQ60kmEhLjmPctUCORepnHXpRJBHQ3+oogkRkYEBrf6AJv +Pf7l5Iicut++rlMT3sxdzQNF/piLEfmTfAKyC0gbVnP4Xsr/2/OL/L98hS1TRFd2KvN04nHTacxz +GNNhmJQ9p8eMHntxOz3m6VFuD+I4eox7pmNhvHt1UzfSEZN0xD1zRFotBU3xeCFChw8+gvSuDMl8 +xA8hYKLHC1ncjsYzFkwAKeSH5SAriNSDKTM0eqw/dImcA+zeNO9IQRo77bAMwo1RATIMF8pNC17R +TkqId0+kDw52hStKAcaz6BuKaC03HU183sPmugtB2vMqWcFymEl4YaR6lUvHEW7ec+EzQ1B+3yCk +uybqAR4Hyzh64CN8jkMea04ZpOb4dXSYP1wIIJ85LyeEW0bI6as8qDIbI+arHmp8DEpwoGQ4rrX3 +HRVc1X3ZXWjaz5fLcQkHq7TD5yr3AaJK0QdiytUGvzqDU1FlkD6H3ZbRWojYrhzf334Sg9nagK+s +ljN71Z0SypBIe8KsPSFeq2AXie+ZB47AX/SANCaBktnphURNIYVsrx2oPiaWg6YTgqpVXjBerYEp +wyCOkBSDOEyqZ/sBosxBoh4hCLidOfzW1QSHIqkuPbQV3FcJmjp3oeZYZfb0ycSFj7Bou8DO5Sj3 +5RGqmzSCEqdBf8HdAE3nm57QYLuIDb0AuAiazpd2aYA1hWQuZ6AOQkRIwjaj1bk8iDJIdmRMZHZD ++9vgCm9mRa8+9vV49cHYwV5TX2iGlv7wzPFdy193l9APg1orhVwIi5RhD7cb1R+Av7FjQ9t6fKnJ +KRUKLpyFSNQG6354E7RwFn4JcdjIhsbiTvZwUwngcjLCHI5tocRxKEWcnzQQmui89/NgBO8dE6++ +bwTvrD4h2s3XGRo9eU+KFFDWcQSxIaDIE73Pb893Sjhv35L6hRmMrCymPUNnfJRGxOQQMSlv8M5Y +xVAfst/PPSqwMjn7eUjqvd9BQUOgseK/63AZAc3g4wnQ8nMPdV6uCPznRjS0xEdCNeJKsDUCwweW +ROoSFjh5xt/XqYAXNx268b7hH515UlPZHiEh9+/rrPp6mlP8uQoxFOJncJkaF3KAdvzwDHAUNZ/0 +3U3xkxCfzukWRfadakOCoTbiT+hO4zZb4hAXx0cbqzAfkafxbyTuKcQSRzwH7GYDCwQNBGXo4qBs +cy/EebHwvux4bF/9tFyda1TuS5pkAKUthWGormvFQpAR3OeGuDefI4m3r+OZo7M7kgyOthQZuT2j +wJl87+HNf53gUyOsSt6zuKwOyBadkypjK1s+YRz7+bq7anY6YiuQFthR420UfkMsB/wGx9x9zwL7 +kiNVjnHA00Mokfy8Qom9XJGQfsA7O4ZoSrQILieb2R6N+qgvsKpgXZ3K80V69XOPhzPPD5yPlpg2 +TsW5ut7eCFuEdh2Rj4CepDFwnhEw571TFlJdg0YWgyB8hXjTmSqR2RbwgWxm9kuIRKiN1n2TZoBu +TVc/NWTIbrUVeGu1L4LzdjboVc6ye+ZA6HIUkGYIpoIRByrQS32NS6tMBcYkYOYl5bbKBxw+zkGa +C4wReNO3BkTCrljB5zZIAOzpZEUYN7OFolh/Vj02tsboE+h3ezXENDkiaZiDsfrxLdKe5IxQXyBT +VvIPIQTx+fMnVrhbO/5Z4xVtrNp6syRDBVsgfkeg2cGjqGbwUG97Nbxeu7Cy3Q+Qt+F+a8/Q6nlQ +dQXNzi5GxmVpSvN6S26wVBDhmH6WfVWPyj1P0S8DBUzRYLnGTY6ieXt5WfN1FFPl+ZQq2I9Klikt +YE7uhKqHM+igQbHaLCZRpB5EmzMinnM4BOQrBQh0MQBNQ4ijavI4QH6Qxvz2+YzfEofqEdTY+AhU +U/pRzQcj9v3YiQ1A7st2V/ncpQY2yXo1xCM88KW8t61QHl/fgrej89wewsxJpFJdKZTw7ahFCgmP +mLKHRSJihhR8kDxz/sZDSdeN/eqSyG/tAOX7E/tL0vJAAdmPrXlCvX7UoIn8gWm2sDgXKPGocoVh +T7Ansf6FPYnxng3zYkD6gbww1HP9+NY8wg5YM/Ml0ImYpn36vB0KUhzsU1sN5UDpZ8Gp2xc4gwiQ +nkPsBFu2L62jFgO3/HtEj4WL3ahYUMsBkKRBd+DEZq121ckAYtow5U4Ot+MA8l/MBhqHnY3oPTzL +BoX8Gej9fbzyzjZlL5cujgl/Kf2DUB5S5lQdR2mDgWdbJX66YnNvn+PD9LKw+NS2Qk+1XjwpMtgU +r9sTWorAek7DyuRdb0P8vgPEg1rKVP3xrXp4Jmwk993A/EsSmrQWuD47HlhDaVZvsKOLxiXMaRHe +2Eja7O/OuR6nHsMMN48DtdjAOoOTF/j03rB/cR13w/apMUOpFTGzToC9t7wA9FAkw7zRWVt84p61 +F5jw9IoUg00HZ2ZPecnMjIgAJCanxmBBlYkGoBT7U01H+nfiv58bWzvqsk8Oj4xy3HnA/mZTTOME +UZ0oqoSS6xU/m0e2ouJfCtkE0DOcNYxOpoLbFG6zbiNCidnNQ5pVJ3rPBEqf1v6q2Loo77icGBpu +ot6kSlGz56pg6/ZVAcnGXuTv/02oX0rdrUgA7i/NIEJQxVWxpIJTYuOTA0sPDe8RBJEQ6s2vhos1 +iDpsJ6uzPr5Fgmr/kicRmz2vvxXzodo05VReucLTyPTPHI5BJDUNXYuYqzAzg3aoqI7OcZ28ROgj +Y46FhIoGD/hR1GQdGJ2wI+r3hMbGHvZDbauwZi97u4MH/P6cPXg4lRq64B2LrMCvYw== + + + X35LpI3swV9kEP6VB0u4M/bvSYH+zx/2/4xvf/Nvv/3P//HLJ8vf/v1//NOf/ve3v/kPf/vffveX +v/zxn//pp7/9Pz/9l9/9wz/99OOf/vz/fvrT//rpP/3hH/7yn//5T//3z3HSr7/x3//45z/+7i9/ +/MNP+xQ/u7jndQW/QnT8r/xXLqBAlKoS6TfWi8TaAXX+odJLnrWQYvZ9ZIcNBFASOB4pZEC/ATBA +7BJRLrAfzCQVr6v5+thvAUDKVIJkxH9Fr5w7okVgFOlQNnr/GJ9VrNPuZ1CIqZ7jugnmGb3YzC5t +uFth3LBrICusyvwTKv44OaGXnMNm1DkQXZt9Pdmd5yOUjcTiMvuYez0v47N+CBhORaMcrhM1mf3G +0tCeaFCylZINqTS/0U66MzaqnEHKdoWuQbF+pIbg/KNnUfRtEFl2QyVf6G54xtGV+6NhHED23k4X +oBSqRJABQiVCAVt2cyCnPotMUFyc5tatQoKtHiefPeSZq8sVDs+I/ezOHdZXnRdm903wpLiCdmQK +kKc7/qiKPB7/Y01FBypRWeaZD5VJQLs8bA3YBLGxEBwEUpOLpPUmO8jhjYPiZHdKmws9TPXu5yak +9+djhkb3PHbYYon3588LkE9lccbBwkTlIU8R3+oHWmKtk9GC2vk+SytxZWc3pp9uD50Cd4z75iHC +RpCVRw4fYFjeSjqW+2dMwzFCz0cozyseBpoWmN4g1de/b2ghJjuE93qMj7Z5DNpZtzT2+0HxDjwr +AHSj19401gB41/t7Q6AVfug6pLx9i1Wshcs2HpL6lusEAVY14F8axKH3+LIDYh9Xjg6lKBA04CD9 +oZTcQz0iXquMlAOS0OAIjkpiEtQ9ygUG/SDxSNqPghOAOwHqkEwMTEToBuYQS2OgB878ky5jhBpQ +RQIbbgZuwF7Hi9cEYuCIpYMmHSc+Pl8R47KtaXcjdtoIK1CL6BQ7qHN3VOCG5j2I/O4XPePqSTSU +pHd/bvAVBneU+ntjElkYZqBLfjIffTEoUgCEsoT/mIiO6uvQgvtbkYkTWKTz+VBthxcW/8S2zowk +iBayKkfZJ1+W53p44QIynFas9GBwAn0iC0LxmPJtubPOc8RgJy61BBZEIAc5wkDDPOWu7zSKQkLw +XiKxNQ+KTKS/TwOV7t1AyCpB5wnDE9Wb+UI+NKvMJu4JYVs5LxCp4RtYNu+naqS5NKONLRzSXfn9 +c44msKV80YhBU5+hsNub61F6rT+HasRnwJxZo/aiGeZpK9YwuAyf17kb7ATfkBkU/Rtm0HLIAGgN +65QxQmLA4YDy7dDKaQhkP3Y0baKlI7KdVDzG7SqSsjMrR78UQWQgAHd2UafDly2Qq1MSIcV2Elj1 +vFzxoroTE4SgZRTolqM788iGpmCiGe4TekXIGo2zG2GKAN7JFLEkf8wnxHZ7O27mzjDccGaYHFAF +qQ7sanNgVMkH0qG0Jzro0d6FnJdzIkhn3ER0XKfwG6DODwVERznAJFCtiOCOg29RKBBwynDWemC2 +ucbgWRWXJhyP6zvK1qKAU4jKCLHYT63WEWiY1AFHLyyagvIQTu7qcwcBLbCvzUqZ181nWgjv0ERY +262H7qmHbLgdmuX3DFaHDgd6d2DbQ2Mi8D4llUD9JwDjRHl1fJwGqAidCkLiwt7k8exoUNd65CCa +sKHSe0D8dA6jA6AV6XMN0tp+y54Vl3ogfjtAPLxmQPZIm3KqFstioPTAYbcwhBrH+dq9xEDWOm7n +v/YS/HhfGXbH+C2NPX4LDHQFq2e8JcjbJjGB+3qqy5tVB7/lcG44ikOIDQ0UGpDL4HDwT2kY7SxN +NJLZ1fuAPFFB2WJdEz4GBjDDUqIBphDy2V0wCPfJb7w8QpiosgK6e/bjVZDQDdZgaU9rGKI2FRyA +opzrxHb31eAyQoFRIaj4DOC68Nkc/HGVr0jJCXiPyQ3fVrlaOxwib6iPKzJHquyZWX4Ud0Mp48AO +weuSCN+fOWeJAiHXoEygJhkTVkXFp/MgotAGIkOFggFZdTCSQ68/RmSBnT7Vhcyvgg6G2VA7wCPi +A6J7WtLtR0H9+zeCg+WkpV+fCWNTQn7szhozUGpluiXauH97aTjAzPn6DFc4kjOC+/L6+HsvoQcX +fj9iRz/9xlRNfyLoqRENyDfV9e9CMJTcbHzWvEmI0UUf1SP5DldqjHxyhUM9Yj8zdTpAZhpG77lj +8WdV5aN/VHx9mfd95VJAPuMqqJ5/ivrD6+8eNG+/cz7D4Fd9f+CU+w3lkkiKTv3oPv52rEGWauv1 +2cNDocidQ7fx/m269pAy7mfSn5CMhMuAKAb476ZMfmrKWfzA/OSLrQDLML3nLaACx9i6t+Qh/YvL +wqGtOw8DyiGCJyJ5qrxx05WK1BaMKfHxXeb5zECCb0gtLA1TO1IYLM8eDnhE6sIjmkk+tb+JbxKw +1FmV9KAsNI5iMfx3YCU7qpsM9Xw9ymlsZK/GnmBhAF7DWBp24EnoxayXbdCftPIaEfjsMKGMsJi9 +wTuNaGM+SqPFa5WlhNIABmU3IE9Pg2AxG+CRH4WbOAoIgqb5zr65jnSFu5iWFgQyXJvIBjI1tpjk +vpxpb/QCE2QwPbZCxhfwxg/Q6oLHRKmjk2XYD3JZTT0mMBl/k4XfCcwR585wrslKROInkcGRuTd5 +YS0zgHP9rrF282JUcdUJLIE5VZ9z2KBvhWGt1tbu82go+YLTaGSeRkmF1Y9tnDBzDlem51mSPVY4 +B3sBDUkOiDA9pvwXqg7j2CV3BUD8sFDVTauhMdb1m0EYBICspkYZkI/cojCbLh8WwEVtUtBBezWO +AkyWyJFV/jNHqMTKnSJNrgkcm8iYVjLRJk1/f3N25HfIwpi/HicnajLPP6FO+Sf1UvTSQHrioPTi +6tO477KNFKXZ2er5ltR0GWYEyQMzI/Vz9IFZI6flsSCWkz6eJZqQaJaQxmAkuhjzyxGWZmgg3cdk +HRq+nxvAhtyt7ec2+ONAuMhKLgzmARXXkHymksyEofIJ0MfJgOvQEdcXPXxvFn5upK/3E3KH8HYc +kEIptEJ1cpu4RhzthDKUJdivAPuDU4p2wpngUjk7AgSPG4owb0BIxEBs/yJ1AcnDU0iaUL5aAF93 +wJWBlA4lQD73iP2R2rDgV3e8oH7qp148pBRPDzHTjuwuxNT3houquYPhZ43SsEHAATPBYBx5WHYV +ZMMABXAL8UghIiSd/2rwMpEaQBmecLc/H41Q8siu7TV2h9VrRT1qfdFAGjrfPeZb44oSu2j7sJRg +mOQwGONwrHzIKey3moXpfn4f/mBX0TlBWx9fWkoRYqVTtTfulIXYOOGxw4TTgf50S5cWxuJwPd5U +GhPT/IhKmg28Lrth789NxYm1yRq1smupgjSw8OwHvk3bnkgp4YSpB40aMizKtGxkQDcuqydWoGjY +w4tvkPzyGy8nLn5SQx+zs0rsqUEIJPuYpS4+17DHMVeN8wFUCV+NHq9Gma/P47HqkAlonTDyo5Hb +jV4ct3v6k3pIR783VCxKzsW9NZ7Ks/vS5PwSqxZWeA0iJxHSeF4N8RMJZHiccIKf8vGtRwsBUNDA +2D23roNvDQNtsnvHPjcizUStPKujRAOOoo9RbWwcpjgkd6X9u8/vyCWqffVlcDStc/2vSLn3T4nx +ynN3258aVeSViDHOs5Ul/G3vPPC1CMYCui5aWc3n1RA/Dxd5GhHrJdd5v6UHkgoXg+pQrLnQjPTL +iuJfuusPMShl6R0JFWv7EXDTMNhO4tJDwh9Ti6zzFxrYTW+twpphKfEK9VDJIterNnxID4V/4G6g +QE0DdTEa3Pr5jTFteARLfOdCmahkQyh54rVD/VtTtgTuj2Ld2tdGhp+4rRVNr4BU3r9jBWr83KoG +F3vcj849hhv0BDmPpExwynxrINn34kp8bmRaPSEIOBLOAxiTbZXRIxcFUh6H13FUn8aLEZnTWYlx +8ibX8wSGh4aOqW3DhGfYMOVZ7On0kYEOR1hNqOcjOEkxH9Eo5yfF1s6joaixGxIifCqsjX7uGD8H +YDSJ3RQbmzgcktY86x62PgX2uyzjxrYBYrkFx28G9eurhhzOd78/QefPGpt+BBFA5L2NJUhoiHK9 +at/a5spf2Q37+K+G1/gYPVDOIANerbrdEaQRA2oIfCJ8ScKEic9CzYEfxP45lvxHabf9qmTstuAR +xL6JeRnxe+blhvPIOpvqTPWLC6AUx456fbfbNmUCJYGUCYK2r2/h8EvIAthUBEcPibC3hp9NsZ8b +IcapScrC2ykct6JHM65VU96HmvYkacgbqtpf736KOknkTiD4DmCGGtSSm9ZMaoCYBgDMgmmOhrQ6 +iX7qWDi/jsDxxPaMVEw30UyqhAKzQv9kji2Dy4y+n5u7xtGAmQf/hbP19zsJeKkSq3sFH8KjDRgf +S95FMcDjl8RHeyTFR0M0oxvVcWYd/27n71MYAyW69tqi/noWTopFuX/PgJfutfxRZRW0jt/xeIPP +RGpjmOtmvGsfu/+spEKJbVacxSj3EYhu1Q3WFd+AdcizGabTHsqA47scyKLIyWemCVCow3kDiM6j +nuFAS20Cv7tpILcPAhJWO4BJ6M77b5E4fIdUN64a4xRh0JDWYBbB0Ec/20G5BxocpWCd/fbSzDXX +46aGAwRetagr75WEeOgJE0CH9P37yQFxMjtxPgMkmvC3mFhY7Rn+aVEyVvhaxMND5oYAv0XuFpVj +pTeXaj4noQD9MiNh2ATMMOY8LvRMvQD2uxw29TiRRwl3vyHI7azHWWCvNU4zqDElSw3PKSHvZeQI +rdBpz3ts5ZpZOdOM0q3Rb6f+ivcg6fkJJIU3sD5hA7l7oKdgD7aB9KC8Gid6LOutkQ7NgF6dNCUU +EJ2kvJwcrhLX7S/H4Zy86YgJGg0B4ECm4MC2RSLv1wxM69CuB25NsHtqVWEFr8JxvAotBJL/VExn +tkdTRtb2AkVrQiu1wwMPEOP6eWKGrJisjmCTYOn0qh5G/2Z6uLnfPRKoX9nB2dxO064HZkliP4ub +gOLyXAoFDOQkrvWvvaouYnsqOESgGDLYBFM2ED7FfM3La9Y28IBeJNtL9staCskhyik4ROPjYbs0 +kys1dipB232oNaQA/O93jiugFFE/GhLAgcrdHuXKvN5GTLKfYw/yJGBLMIqLfIWw+qQUSdVAuuWq +rwYvijrtnrKBQ1Qmjde3qkh7WOHLve5F7b81ALsu2tS0LM47VpDPvUDry6EqoKqrAlJgyfnV6i1O +iKO8AyBlmaj3nop8/HuPeFwsSbxO5MzL+OI4PnZenTQEuZFLDzsoNvkUIN56SJ+oxwrqyDt80SuH +AcD0fvawW0pOLsn9JEGxTPYRmap9czHtjUkHMTqKne2Wq4oGDUkvpirMH9a2yqdjsiTTI8peSJDk +mLwsqSJhU2DFUSLn4aMBNs6ZSpj7WCh9ncllcIDMQRWK64FgRsm+UbQQOkKiD+zPGQ== + + + ehQkVIDMx8CELTodhiZFFEmX6HbFi++J3HmDSyHjB/vSjUwhx89TY82tpnf3nFgcpCY2p3FHeTXE +E/i0tL++hRGX0Pqi1Bfn8QG8NcSTbefJvt7Iz72Ir6GKTe6PToVc1ozLeg4xTkETE8cSKxHn446N +8ID53OH3p2RrxhCPFufot8NQ2mMlpLSnIiF4e+kOVX53uGSQ89sbioHm9vf2CJTaojKIANESJAgc +z0re7BbqFMAhsdT72+ehX1OPfs3ZYL11Qsa2n1pfiaIikYp1yueYPxqE7tVn6lJDzEKemTjhWhVD +8XUw78hKsmA9tHEQ+cqlZcXhWRn2x655PaAqHKcfP0cyxtpBdrPp/Wi7IDaVPs4Uax75SsAG4C6n +ShcU5Y5zJDgLegjIkJcAxAfc7GjHkZI3JCWF8O1xdKTJU53xTvxBSLrvlFUukNSgTNkA9JPuN1M2 +RlgXEjCH/01BPqt90WOw4xCHUvJ1cnzvNY+7MoqO2pPAH6iWEvF8iTSIYhNkIISEZLVm3ht+f0Kf +MnUnRqH0ee+1dy4x54BzVdGBSGXv+z4a0sU/vT5SZqIcmYml/+GOm4qF9gO2od7RHfc7GmLcz0f4 +6ecerxmhASuHSNe/OAyktBV5Vw2rO+Ys7SwCIvrRWF7n/rW4f9f8h05tdjtVgnl6hfvtnsVyDtCt +lfbdI7xRsePCZAtVnBjFObLoHCMxaWN5Rolm90j13m7XpLFiTWKszx6KenvkznkueLBTnBmpoBKJ +owRCqCOtEVac4YQFEjEyS3uOyB7iKhFzQ+JEqB3y9GcN0zFYzhTIYfNmkJqD4vsIdJL+r32Ca3u+ +6nF0jbR+yHfy/9xLORxijFJz0cHyiczBhFC2rjTTOtJMgmfGM9fb5w4plDbyfGtDJYElG1wUQnek +zs28QwgQNgeU4mzmkF8WsdiP+88IBwn2IQHxwbVICjc6L11wZUFwGHDJPNbemkfz7NFWwjtgZIEy +FlBTiZi/Y9PJG8q+AUD+Gu29wf1ViiryW6PuNAI1WghWgfeAafHR8BwE0A6A2pm+X43g+ZR+3Lsy +Zd7BHhy8JPcEki9IeBKDiqR0ynCn8I03YQ785PFGTiQONXHX5bNfbUsc97I/0Z2kcEXRrkDzT5aN +Rh8Kd1G8aco61HAetyG7IRQx93RLWVzWfA0IqWI+uwGnjwtmeAKiBNrOn4hqoYiEkY9qryqOe9Hs +TIYfDVVP9wNvOJ8l6W5Cc0JTE2lkNDWRkEU/9YuP3eWSWwU6+blxambt2bAmxiWrst2e+WxLP1tO +O6xylM3fGv8uTrXX6Zg4QXBTXoDCrgNBLBuUR1X0QSGkfteAIxXzhryP/MoD2LhqSAKIHuzWf8S2 +vUmf6CyL3jd72zz71+IoLLWA5oj/u27yb8dpK6q15I2TaT3yBrDIG+4r44sen1eRSH197oUagZKK +vNIrApZmXFKPXoo+GrxHe0tZRrxxEZZGZjR01Y5wrEDZGmuLju9KOFfez/0sw6IcjlI1NgiUF+na +GUg5NJwQwOmxs9EmDzJG76/an6EM6w9gDCQSVLxgLlDLZFKg1nm9ogAtX3avdaw9SbD2358iy/4t +6PUgb3PsK3WYxwyD2XvBS9lf61BsDggi8I37aFjQJ4PGhm8LOl9vHSKvmmKbvOeZbC3181H0mOJJ +JCMGY8vwMSodObD3HtQw+7iqOp8aZ9C4FZQiVGOTiZ87YhTo2hXU/0n2t5KRN+qHpv/jgSVAKlHk +kvxQOwZVKEM29pg76qtYecFZ4y36RSDDRTpIKHmnVWRoDt/zGXJIODIsiRm6krN6daIelg+Us53q +7YCjQ914XH37ByfMFnnVKlIcRYYayrXkf9Dw8v7D5RL5sW+v8OmRwnlObc8X6K+eyiaKSCFXfbRt +9xCysgBhmQlgz1FuEbSLDbm8EqNcMgSrYTpZDlxviiIh6E6+in1mG3avEpDiGfPRAG4Xevf7dVDv +ngyjWyES51qdGt/gLD3tMdyEuVlCqkeL0I/z1Cd08/e4D1GTFKBlskhxvRZIYD+uFsM5s75RVmM/ +F7TI+B1iO/feoB0QMK9uUfSG4Y286p47DF7wU4y63Z7X2lEb7lXF7kjlE3Oy5WC3AlwjlqfqRA42 +Ol58fDhQDOg72h1PrAVBxBIrEcL/+0VFaH9fWYpdG4scBe1F7rkkZGgVyguzd2Ny+OSIYIHW9i1I +lHYXhJ/98NX2YmfxjWJVgEWgjI7Q9GUPs8eAZCCxKVFi41E8cev2j4hS7ku0NktMYEqgnNHtRWLY +rxMQtajB20DenYZpoRHRuRINj2OLEuAt8EluRwWu741gi7OHrjd57RnHMV2BM6NuvPaYapIxaeQZ +wApqSquE2wLa2p7nSo+LNsIGTMG1E0BrLLMfcYM0G6S5aeUyrTOxN/E2HG+/jU3NWXEkgd7PcHxv +FS9BgbAg1BT1Iyy2woW1CBq8AD8ALKFgwJZv312q6aFeTFld/E8K0l+tdyoupwhY2T2cCRxtU0QZ +G1qaiFyBOmlVhIa4DMqxRbwpJMOKMExIo6lwjDTa5Qcjqiz4dK+uMvP4eYWpHPHWueIB4FFINV0b +xg5hB7Qt9Sx/MwUGljfsmualODaWOBu1Ysd0N6qXLdAhyoHzDtODjA09es32yGRnmsSNcwI15siK +v2qJqv3z3PF/HPaSgMQOTT1repTHHtU6Pd7gSA72HbaseXowCJqyK3G1Wj+jZTPucpjJ+zvC2FtN +70TM4HvFWlQp84gsRJOmyr06tt5gnmF/8pANAZCoNie/jmQfatPP62m3oCxoEymgYN9DBmelrsNT +gi/B67cXelVMOohh5RRBN4KYSxoShYUHOgCUWl/INTjFrFikmqeDu0U+WsgzSK7q8/JMrKpxj1Az +5B41V2NQjS0AatP6NG6EtzheIo3XTu6CHy4NOVAanpDtAKV2BfQo6AIGSykQllBpx6HCarTcdP09 +ObCHGihF7OcIhPDWqv64f03I4AGrIGOhKMSyIF1Lsu4NazGKhQ+FAFJxmJuWUwVX2XzvnkYO9xJ9 +gfftU1fEHtVfts7dBSnK3R0tDhC/c4/yenMMWKAQaYCJi3edi8HgEJHQOIz1YzxSRhTpTeli5SWf +kA7KBQNAb3EEKz+Iq7SbYdCCZ4hj8EVpBOTsIPD3QZllr4WY6PnBMXahZB4nkEjRUVrSKyppBsf7 +v5/gRcWxE6m4tKSgw6GsAuWcXFxofwK7LdKcCIiCXoHDPBY3IREMNOsxoYC6LfFPaqeUHxFOOO5E +4gO69wl9XCANjkrkI1Q93j3go3771SjshnW/hcHoofCIdsJLALQT4lU19Ln/8Sz6WFHx8hbgeu57 +R8zL4JEJmsizA6vmJ5Z00aEzLHnCC+ZAEmZgjkhVkc6kDZwZDU8SBcrQLzZkATAzmBXA4MiI6lZ6 +338aVzDllVi18xBBPnydKJo3kJ9kPx8bGEjxZV2LNIssins8gddkyCxK+Rq87w/IF8xSD89IjtCo +pLGg2I9TAibIsqgJRxOenY++njBV5gk+U+HP2wxMUlCe9puAhtYLZx2xXArmEcgHip809kPOU5pn +N4yShW7XGEjMJWiSEoCI2n6BciXtzWp4t5dQAdq6xttgSEr99PE0SF7H0ahVERCu0A25ayz7v954 +ttjmZJ/VULUfA3KiNtIfFGv0vBkR1345wH78DccyaIOnxl7z2VtStZnIaPxjNI5pKkA7VxsXLCn5 +SSrPt7BQMKg2o9LUn6BGVz0UOYt1GQyR0ciSikjGY581/ZbkZKRmWFInXmld+ASSBjZobIC3zry5 +mHKgAEVoivto1LyBIOzFMCrIlCsWOiPpKGxqxACD53CxRAem4GkFb3gHF4jNTXbZMxZxkB1I+9WI +n1LET1HV8JfhGEcdkEbSP2SUkUF0ljNcbMf8i2mZd88Zzs/148AqMI0XoyajnExjRQWMlx5sDlDe +1Y+6bQ51W8AEAxNwSHKCIDQQW+Oo/WNfhLIhU7x3qSO3AsmGPCf5NnAnWN2gSEtuyx9sdFFDBXSv +bevm459y8lnY2pO6xCCiBpAmEn5wJ2eYGmPth1wVkji7YZ4brE70qXKkEXsjDpUhl5IGDOcTC/um +kCO7voMb5MizTk1dSiQDzDxVA7e3A9c0WzifFMQOMEC/eiTkztU02BH0YJU101/N+e4xRfWZEJ/5 +DnSoKsLzKFog1ltbQD0QWQUysZ9+7FO0q9hvaH8tkxRKwW9N3ERdJp89ZbLWNcqvoV9mzmyiVdhP +D5SoOtYkPfBKjVG2p+9avRbGqT0W1kIfJRzchSnhFJ8K0Av1k8GQLI9jyXkqFDXPjo27R3QgfCMF +LgBdG+dxtm7J6Xq/RHdiRW5OsEg72u3ysYrHYXzTTvqJ9nZ+0YHHCz7m/Kp380vhrJEoy5emgkVo +ZVONagLrPa/sdEef4VUqriigc9aUjFhWNXVtWcULy+T1ul9VMr43NH9uFYkMQbKMOMwjoxBPhLZn +5JZMkRXy0p3KfhY6sqcXIR/MLjCgHU6RmmzfHVYSAIl39WYRiC4xaGVeTpw7NE5JIXwukqirexj1 +AUwQwjitAiyIl2wEFSqsxqTBJ4xtgICAUwre71DGcUatApov4xAZjANjYyOk7kG/pOH9lqPAWA+R +vNdTrcEAe5/6GSdF3I+5o1ug9ULFLfePYPxIDGDzJCo2f/C1g8w/CbQFmDTF9YECIAIlmKCsC2XD +ZNTbu98kPQBE+Tyxr6AeP4tPbL/KRTpYt0Sc4bIxXnHtvLOSJa8nxECCg82D9W8zNvL+d/QgWVu2 +ZXlVBYKwHaqzJTgZRe4rf6+qEl9VURMPlyM5onL8VKsy4qJ1sHhceEHkBjF1uI2DMHSdCnSg+75c +b3/LAJU6HBz7crKgrOXw6hBLrUdmC6ovsG2yeEPaXTsczJdmJ5+1rFG2WXhYj7qct2ACIeVGfbm1 +D90nXCjMs7bXca3WcQwktCjSMWuHt92xnka5YP8/iUjYT9CQyPDWRyQkWwYU9rSvOBlaqPtT7eA4 +NaGZJotDp2te0qF/8t6Pnd0F1O+izFjjQvaf+414/JuUFX+TPW8lpMPOV+ZciqI0khLD0q8CXuJa +FfYaIV12668DNhQO8zNCT/w7kxKuoX8F7DfpTfvDC03OkiEchtouCZP9ygTTAbMsfHjwWUQtT0js +Eyn9vVNvKk8jttk+EO4Arg7ncW/fp5lyVXVBLyzZfXulR895lMN4ML2mMCew4+Cw5huilxIZFNWA +R0hPlsAfBH+R2KsEsaUYkGETisD4szecWTKt/sYXztW7qBBA+0V9FhLy4ih5i5GIosRcszhFchzU +qbA5vKxqCmcUSBAWh4bL/EuCl2JjbEmWMsP1g0Qw3LZUg0Eev4LGlCRIHSzrwQ1LOWatZ3wI8MAp +XtkKBDkxJOYty++fRQKIaRqn18u4pPTCTCRvfu8nFoJxSR9yQOQWq8mxI/7xnH0GEA== + + + WTbL9zPWJmIseUdILGtW4r4pX3MFHU4IMGu8zX5nSWRqKB6vFKNOsdEDfMRcgdoDzG9m7qXLl4OY +b5SgKROA3XG5DkeXXwjZihuB6BL3f8RZB5BPgMBXU3oCYSuCg33hIWZjHxQmcSEpu+PE/Zq0/FFU +5agUeuDb4g6LWAN17SdQ5MBHoW2/5JdJ4uHHpWsaUUs62hUos5egwUo9FR/HKKWy14IE/kF/Ai6+ +BL3hyLsvPen4mw74HZdVpE4XerB7YC0m8yWnr120J8qDPFFy+ORmMTp9iqMlsfNuT4gKEW4eyk67 +tOt+vOTBAu/xqgolQppecpf63I97Dp8BixUAAO2XBGqWHi1prCtPJfFZPN/5TlrBbHYwUjFDDNTz +FeeFdb5yt/ethGgQ915JbdhN2FmboZcyy64Ib6jxXFtuJkfZWKLDpU83Z/qj9MzM5GqR7q/RIoAZ +v0Fqj2mbwgQrCvrrrEp1H4up/9Z/+Ux+00Lwy5WrAEzAdk7V1hW7IP5+aYjreORHUm7Rn2jKe8qi +9e/yTZHEqyO1UBm1TljBvlcTJ006xQiJIkzGmbZksEVOJFAg7C+1lEbT1x8cCNslfQhJk3o92DK/ +azHkFRaGIw5WmjWKFwkjLQZYl+UbfAEFq6awC0W2W6zxVKlImLjelBZA+7MV2YfRpCcM83IJw7yA +KwTygOx9NZpiLy6R1hFOBBthFiKrR75GYHO8SyAwWoDWZ+QHAkZvmDnExSbXiBRY5UHpYz/YJ4Wy +rAsLIMwkmrplMSHsIpKQtGkeEOxVy2KmyHh7vv00WCd3D+GMJVJV7BzyAYpaxQONvm4oPI5eVz7S +SdjEmRlN6dBFGrgRafEQt8Hc7Dh+HE5JCXTkvgJz0CLowQiDLQzsLCcgrMEWOgVQMiSSKo7cEZjG +T93b1+coiQVWp+ypbh3+zJe9dMgqsW3JV4dmhto/nwtDvIym/c2ljp099KtFIql9HJ9kwu41Djxi +6eBR9rb3Ocd/hHyAepzRA+UeeugWRFAceDzgWCH2gg4BPQRN3BMN2AF7oEZmB+zG8jjk47skHoOK +HaI0FYvaCoPvQZrFQF8DUX4SfiZxDCtXO9bYW9pxzsS6jSfKg37vcaIGs82km9S4Eu0k0rkFAvc6 +0z8tMS3KDBmipWuYjetun4+7/Sl+2ot1iF6rh6FpYOKG3CaPUwPzXPeJroFpsWEPYyKlPWWMci1P +X8eVaz7MWWlZkPU8tVoP4LSFy+kKJjPck4jlLNGARJXJN49fDhW2OwEQCmKb8qBvPdh2iKQi24PX +qkSUdBLnewoQM/MZjESoqRekhEpRcJ9E2HwQTPOAZwb7vxYabs9B7MYU0M9Y7RFOaf3L/mL/Pl4/ +9535whhih9tUtlItg41EmFSiIBHSRKKT90XnJmAXO4Kq74yWX2aKstUIhJZCfCecWBfuK+tkoNFh +SGJ8m/JFPBBqFjic5tq/wkOwtQU8vNdI+QWLXSx15IaPQuz2Ho2JH6/v1E/yEYs6MYoIaWXucBN4 +InkRmArUqdJBSDsNp/1oZRmnU8vBnkNWzDr6l+T3TwGOXpG5bgQ2cSattEmAOPEDjBRy0Kr7Pnv4 +sVL1CMKOOD/3Rdz0etG8SXdQONoHRDwXBBKMCRBI3OnIg8uFJiwfTrwiHiYqAcLVV7CJO9SdGiBa +rpepfr7yW+jgSLikuuSPVbea5YqyR/Y4oTIAISU6RGoZBwfx70v9JRu68koBoLjHJ1S1EQwowrpa +VDJyoipAbjtWIuvhU0h4dIB5zNCqcYR6X2iRjBhK7/m9uonDWzabpYEODb6sEDHxzkRCGmZLvX6S +4OgB0B5rqjv/GP+Ai9wB7yKLiJ4vUi+odJq3Ad6CiAQwna5TUokSNYUlZSaAjMcMZW7NS0uUGQce +5leHUjSA8H6kBHIwLiMTAlgpzmSpG8bxkL1GcGPEjKlGE03DXEoilEI7EQFIz1Pn64FTQVCIAPiZ +h1yKKympwoHO8eFt4tlu0mwda2KsmDFB7oqEphE1SJPRl0xGpJvE6e4I5CDhfR/BMl7TeUvx+mmO +4GSZnp6odM9YYy26DgBJ4TQ2I7HTc7olIqyncjgal2A/rfBTomCmnly9uC7dv05OSvOKvNflFPir +CScRMjJqSVBYXqsD1kWCvjCIZDqNWiAEjjDbjh7NBoHMk4LC/IXjBi1Km9/2OkGsI3smZsWXPzMO +fyYHE7iT2sVlMM3DsIkQawXtDm14oBHgPU3AJ9E4xWPcXEoON51savyCw6FeEKqVeazLJOliKOYE +jhZkM2fP5i3WkrgWZoTu3cahiLvdZrqMtKO/MzqEzJOO4G/SEWEiq9YA90W3dWJ6jgIvy7BWeVuG +DxIzZocp+rhwIJt7uT5PACQZmc1gN0fKWMouKwoRh9SpR046wXSL+ZENs4kbFPnDwqZ96DnIZ99X +MsiQu3GUqEfKAqQ6RZ/2TfJFi+LYCaMfJJtWY+zXV3jUkTYawKmm9Nyo1l6ppj0TaH7GFt5wKVyv +2PJ/kM5ZjJeJnxo1WBwiRd6H9BRiOFOfvJQs3uKF9DAWqZPc5Y9eVLjp5WyXRjyYiZL7jJJM6ZTP +gAuM6OE4nLqxZ3tUFzbgqz3OFJjTqhrnPVHgAbWpiuqBYfTuVNjUBRb3kcOxVGCkR7DoDj+IHl5s +X1P4EamCJyoQEuTiTCSckHVVYaciCn3I/WrGUDsLOPreV4XgiUZD4AJYPXYct8727aMwDxKJVXFo +06PmmvpZawK8G9BDZd0DHQEZFri9ithzD8oi+gTT2PkcV4cW8D17iq5nmZzoU86MYCDuqNQWUe5q +yhRIo9ZNOtdYCZvcjxFoYwBg+MBc5zXQcRU5sRZM/UhbmvKH4zbFuz28bihrlB6HcSdH3l/1f5A+ +6ArgtxYRQQvaClH889J/BWIs9GcP+Cd2oIJdKMkd6IJARLDDxY3oIjPL78B1/mnDWmLQ7rqVR5JP +d1sOJ4kHAPvBDW4lz8Thl+It6lgZCFsnnHEcKNN+b5071tzwCg6MHlq41R20pO+AawoqgXHpcaZC +BYSaZKoHlsYKCuRKEZ2EX/bjcXoReocIU/EY7XRILDKshit9eKMKO2js6LK65RCHQ4uF6QQgJrHU +0yMXoZxFV+klrDGeGbCHiCwPyK3jTnOMqJa/jgz5CA/XkDViSbSu0gLDhRShU8ySzaHyxQya9icd +89eZxEtQtZJkWBhkav4OcuF6/Br84QjLZEDQkcqttreotj+xQu2lmsp/hTZ5YGTrIAOxID3id12G +S5vqbRezC0uZHHCK9tghD0vqNKMm4pb5CD1TRHYkKy1ebeiQ6QOwVqC6sTcRDqBGD/wAdqQp1L3c +YwGr7Om4ecsarFmlX9CPLaTJI/ew15d1Of9ojIgwQw8mh+5t1IGFzTWfqQtnYzquIYSrMDmG0W2F ++k28WTvcMDkAPMg68BL6cV705+ir7QUF0UuhWlausRicIvlCsG6Aszls1jCDUPIWbTgx2qQQXXT3 +gEmH6h76dCXiQMXnM3Zq06+7SSPFsFpoFcf8geLKOUGceM/j6p7QQ+4HZsPfncB6+O7Vx1E0TkcV +jYR6g3xX43PtgobdowOZ4iYCNy5RNzR9Eq7uDtmnLIhrx88zhI7xcKfGCsnrwLwQ2mHV6oHPt7AP +/6yOeC8BASiFZBGTO3inDeYSKuU7vKp1xe1dakRC3l4HNww2CYel4i+JgjXYSveEe4FiufLaNEne +ofS8SrPFFBziPELHIhaqKJcP/HsFi0JxYgxTKOh65IIJ8Ke5tO3wUYNLekifH/K1noNRn3oU0MZk +Rhu6yH/3bwI/rVwbHgmq4KlUyAYZRQH1i+rRDlKzvsdxYHUKKW9HfTGg1ruz1wkyhR+w15mrqg5Q +1o12Q9R+RhRd9ZEHkApmvtUIACpUAcUJGMHQspkyZng6W4LDTcUS9fywSAJBW1Dzb6CV8YppISLn +C5IIXwb7asl4sUsEO6TaGRnQ8K7MZ309ztApnKH3azePF5ZgDbeUDQVnhcSmM9XssU9i3weY6Gck +8lkiFAcvRVF9KGxnZkz48P7VpuEhWCmIgZLjDjvQfJ1XOoWKIz9kVJ0rgqOYgmM1zShpAlKjHDcO +e4kqAHj0UVU7ISseuD6yewojFzOGlFQN1dSDZQNUYaAUygvrlYloKZQ7R0Nrhk2eTjeA1UO/A22l +fUmW5F3JBmY5aAcfyYGlnMv6lk+5ZtYovuUVpUVSEI9FDeUqfwx8FrcVzXm9+Si9AHJuUXf4XHz/ +LQv7/+4XHW7+ygP9inVM/Jv99ysTFwHWaPACsK7G4SWYFGFAdVhPAKx5W3evZWL1cy8R1CIpE2W8 +k9CfAVeLBXE3jEgwRJxP4u0SkNUdTpJR8oxgerpfWwhrEKVUA2aeqnUmCTEm6si6F+u09bUVxoBp +Kby11+QmmlH7XhuapXHhNUOLmaDXhBjjgKnQlXu6JS5PZQyO+O4QPPCY96R6ahpw7DUytKfWzHG4 +Edso5Nn9/Ln50BU64oeeEPpgyPQvdm6aGbPGi6Xb8cyOgqwB634b026JnQrwTI49o7TIhFpjQd9b +BwqqRz4YfpxcSlyDoRn2Hq5fHq2IWgbPj96zlUrFouEuOC7aXp3whGCvzRNhPuwx4ZIHQaTwZ3Nl +BJxA6fDsS9aGZSFIasmYDKlsqKwnDbI4IcYhMdPQoTtgEhulAqKgWzxaXBsNFSoMdLqiTqLixJwm +pmqMsPz8vrcF625qP61AJJgULH3n4RU6I+JTwH0UioChGAQ3aq2nwaOoJo5ZDbHJ+Ggs5qkg7IBB +jPsYushvDXBCrt/JW2OO1aDAa8b7vTKAKvVISj9FyTaWsh1vwUo4n8elUQPe0TphrgXf+50cLFOs +SeAgIDxMtoEv7GHBF8LxgGL2leWlDULfbiM9rQAwBTIbCC5p4LXDIYBSPw1G6rthv3Oqm78wPjSa +R9mNT4lTqZVVIO2SvMC11dIyNF9inFbMhXGUK59UdEgcAUQC7V5P2sbApytADmTo/fP0YRX61liP +X3ARC5VZH8IKjkeLWEF1HavRcHWZQfA+r48KUFmcSWtWFpkqeCNz89bws6f/ubEDjCFEBdNO3Wmv +xyhSjqLoVNFVYd/0Gog5LWUPiJyRZPReB4rNgqDi7QfLAxNk/6YC4gnZON7+f/FbIxhUsFHB2QCH +J41rA2b08HlJFQ5RKX6uF2CFK9UjdXUHoKq32YM5a4Hvn+cS9jzul1YJ03DhLzQQtPB3XdfrCL5a +0Q5qJZX9hYUxhODPEsVZu2W+D2e+o39EmbrN/GqIPfMhzDQdVL/7Vkpn146yJcX2fHJzlJiXTKD9 +Q5/QytKjivUqXbQzvbo0G1RWYj3UEnaClKQaB/iQIuNeMUukFwqoiuGKOS616V9def/VeOOvNMI7 +TJf8nGThniLY0oNmBQzhIk+ehjIeOzPIV7yDy9pRvcVkhG+6MVQu4apjfm5aTtMq4g== + + + I6TTcgdwZaopeH8BHrMBpxa+1bwTB9XG4dRDg/ORPJzKl/dwUZrHV40k7RMpgnwEoFm4ZSwcmwEx +AqEU1IrZCoxYL1dYSGi2Pr6HpTGfu2dgB/qk7EdFVV/BWbVBZYRRCd/TulZiUpw/7AxM60XyeQru +UVA6HVlMxAApV2iUVY59uMDiCvBXL1nlFS+K0M3AbpTq3U0MR27JSZ5vcdk60KbQ4AEEinhGumJQ +CIEVzbCpaKkchjg1CpdXb6yFZhmesTa8tGfS0fmfaB0xULJO4AwF9wqsf3DOWagCvv0LI+vH33IQ +g4fsEs/3pqWGVpBiIdZ/8hnHhcmKzAqw3sPubrx6HencJ0rlegURBYYR6gFKixMwgwQSSCVBaMZR +tg+sASXn8lGUh1ZLr6wjIUiCFXiDLm9bY2Y2Q8BtjtJSkE3N14eontHlAM2fzjGSuvORsL41F9Ea +JIPWkQkjqaGfz9miV/jOA3YoadFx8sdkjhAwAQ4Q+HeEmQl6P/eI8LSfgga0d2sgn3rJeJaRtpY4 +WPUBRvD6H8A3JD4OsywPtd2eY8Mb7vAfYtDyv+jVDkdTQ2noleDa6eFL2q4YH9wUst27RwNCSo+g +ma49MmswMFWpgcj5vHJF/eQaSIORlZLuKW2SmTd4pxEG75VEQQCOAxaUxRQFQXv0pQlrMzPO1XJX +oHLOl7r+ikkC2NMUB3D4skQ1Er7ZnkoPJ19umV6wzA7J4HKY9VGzXpaDNnUrBAj3dZXRP9YfCmes +P036ERt+QBVEAGLgkZM7WbtVSd2kve+WgnoaxBu6Td8TzRWlfzX2U8/e0z1obMXSRRmg+TpUW7HQ +jsuVmpDPuJna/WaaP/3U4/cnfyqZEs1yFR8/95KVmMLC1qDHvwMzJEFnIHp32e63EQ8B7bCoDFul +OKlrjJRVwgBMFOwMtLSyAYD6b8Cr+flUml3nmUfGvCdIIbGxh2NWUA+k5ZBRkY9PRbo59vCltmJN +xQxpGzyk0sFn7BMtVTS7TPeijsdK43UihOjoNQTIkYvo0QvOpccRiYGjs9xfeoxjMswutOFEMS7Z +BI3mfYL0chduZ9wtmPphj5apt1A8B0JHBjzKCCDlqS1xy1X527e8jeerHjXM3ig99ee+1597Afhm +z8B9mufew6DinlUpbRRERxREn6vorxZpz2b53zrEVHUsZ5DoFqj0dhjKm27rOxv+YV1BPaC3BsBv +jXoAcJ2riPTWS5cicrR5/w5xYSO0bkkDzOPEKTwHh0pLEcqTWUQ5vKl+FTHQr7yCRcpXdIE4zcI7 +MbOPH+23EfXSzPxDzRW5yLcBQi7wJB1qICPa5fHsuYf745nYTMywaAsRMGSvbp5clETG6i8UykLX +i/ICsYyZPBAbOw4WogkhiXUVQhKJwx8vkMK8oGn+8IbjAamwhRmcuT6RH6QqXLuACwChBLV3StfP +c1QfTY7DVeo6wFH7PEtijxQ9cDQyIB4XVATHDffefnATWLjkAKqp1EePR7W3Hkp9A2twpjFOlJWo +Gx9laMAKlAwAKyBCYC+Mz4aqFwfOQFJksHrUIFdFsh3JwR7CmiHT6nZkXJtexHoU97vIoNblaifU +ZINkL/qssHSGN2hgDDupshEYSLXDnoY8xLdfj5F+y21Fu9Tdz47gEpXIky1XsMMEbcgWhPuH0VI+ +patBhcLEs45lpuPM+qFvdhTusUGZz2lkRaMRYRD3pDNSgiqicjhDahV2Z6gblPjGvFAIzVtK3B7m +f45ipSIQneI2ede1X5GPKAa027C/WV5gfqUN3QgXWQyyAeHdDJiDMxgQ+ZJqR9Cs9yt71kRt0QD1 +QGwJNOueqHFwqVSyylnCUyzh4GAgozdhluWgILPiaXFF6KKtsPeNGiiAmh68++vIKeoH0ZjnNKzj +5VkjMdLzNRKkUXfu7rzB9GCx12/1g9IlaGNhJVDm4kLfs9y6G0jXc9MJxFJ4DwxFWwsqLJMhUcVU +MXvMgGGRMfpoKHf9n6AC49bZKKiP3XzJgYoPUk7HC5tlpH+TS4tqt39ZKwDqPG+7hA+w7vAN9or6 +PMeMWYndciR2Z3mJ/Rvqp4v+Ir1SBIaQ2SF3S2iKa1KOKn2+bKcrv38/w7sg3GlZENVbg0k2omEc +tfJD/z4faUYoelbslywc0b6mrIk091gBRbvWIZ9HLvs0nHBAhmgLEWMMXGzs+aAgQr0egaqrFsnG +jh3Ter7o0cg0u3bW61vyRad05H6VO4r7FIKbA/o6k3SfcKp5JuGk/qnhPLg5zzz4s8al2msU9qti +eBTyQ1Nd5Vy8l4XRA7G8HgSCRFZoByp8Sc5nNb/kICZxqY8zUv5TFphuvCY0WdPIg56t02rHR55U +qI4Ae5+dlrLPwUSmIcxfd6xRFEB1jHi48GLdl3jCG7EVNV6JTIZqBBHMAqemrA0touDVXQXjnzX4 +oMmNH+BEAHloHN7m2vR4JQe91IYGwftdQ//hSG/vSzvi8x+NlN/1z62ZBAQIjpgP8sHoAcecsiRR +fnpv8Dey1a1ffAtT0LML2EetYsUr3Kvxsj7Y70sslPOAJ26bCX3lEHc4UXWfaEelMSgY7FyTvhwa +r7w13AFcUGoB66PF7edepJAU0YGbGV4I0tXBN5Yv2omVrUuzQbua+/mgqezTQrRVejlI8DpuoU0N +AgBly9C1Ab/ZM/9iacFkQ2zv5wbvCWHtV42hb/KcRbOlWDTDTLYf23TFPzF6uKLouMrOHtyDEn5q +M4gYFFN0H+64dqqIEp7JLXRAlP9Mr6MQLccpiLk5RSl+q3lNkH7N1yxJT3whjNnbka9eVsI9GBoS +1uLmuXEdcrSUvMZmQ2yRkUmJDTUauo45G8ppOBvrfuxf3hp7PRrGsLKgjO+ofLJR+GhogQTaC88r +xni1MaeRYLNozabf3XVv+3aFy11oSULDZN/Y1bWLYc31OhfRqGw4ilbk9VaQY5XlEfgBth565UKL +LNy6G2nMbt5n3cOF6PKU3UfmAYJ7HM7AAWGHHXcocgEwzBuWw4LcHaN7t0NflUFi8EXuNnn/0c2x +0uHaDFnV1Fpjf1u/a4D2R56rUOI5PLfbqDJKD2WUtUwnFmFKn0Vp8bkTGvqVpq3o/3Elcae4LXXK +9IHn3Uc0VxtxMDePtYgZ0d48KSJS1TO2aXMEnfOgOHqgOGphIg/B8CedpBDg//0okB2LC/jU8Pub +jQeaz+5Ez/vPveAVBOsHsw+1RFnO9BMfZWrI9LnHV9P2ey+4nTAo9yRZtGUsRwR09+ohor+A+kBm +NLGmRHgOiXBpS/mwlHbMAuPwO6OneoyeHqH2iNORg+8WCODlFWGlkx3OXlSbWfwKRlJIIJFRDm19 +cDWYaLK7i71lOj5SHM1oCOHlGYD1osZyAJzfGv7l7H1jt772qp2fL74+FDUhbC8m9VQaIrJEaUiI +PLCSkUVII5QXZCV5a3vxyVcLq4aTjp3y7cTGk05jnsOIUEAndZ4eM3ooNGKPeXqYu2ih4mOPcc90 +3Ot2L6VlpU4lqVOUV8wbmLwl2eyIatf1Z8fXIxDUslF2h0JB1B562I8P3OM88o+wWHKAqkUGIdHm +nayU54j290415GnwdgmTIQVVUF4uV0f1insxvZ/B1xR8n4FhV7XS44NqNRK+eTdiuFCwDoNitjGH +yBK5n/2Y0vVp0cRkmkhaSgWBAkhVugvpYI8Da1MMulOwx2HHvaehaSHvOaCCR3ZOUGbWxwkWO1hd +WntI55IJ5OuPVKGveijbDWyl1ZjRdFXiBFejF+IJ2rbzpqLwHdMLOYWiETBvWWSoqzyWX6jMqcht +YnhPxqEUwZ08t72ewY3vi0omgPuBXKc+pbisGklRdNyu7Eolwbc3jkUi71sPWCwSuZiOXii3eoQS +6YVrmnmz4BcESqhTGlARISAvo0e4RZ5lfwuUHSj+k7MK8jeJjLCQPVq0QOuBcBJI9MOJLN0sBOqx +nX2UuB8varSoSnRwscndVxiujnZNZwFWVxryyqHLTgKDjte8nc/kKesqgfoIp1gnA6LP6sIe3D1c +iGjwjQDo7hB3/ySMX+4OVhMZsOFgC3cQpEmcoFe/HqLRE5M6ZS5mCNNL7EPkn+Sp8vJXk2M3hl3Q +HiDw32zs8a0mUSHrOqwdaX6iwXo32jw8Is5zSfc2dr1Lp1wTjiL9dR9lR0cvZ2HPq8cJRrvZBhFL +95aF2+7epqAwNo+JqJmpx7yMmW12VwqB2xCwRqalSaj+Eox4+5YcFUiDE9NepjQDyfCpms/JayQz +3VnR9/g8cIf1MIb3zilIXfEdSPkrzNmDgyWbSgOMPbZyfu+BaGeuNzf5qXE9gSdj42IZCZ4B8ySR +A6wJFe/z0ChiT/0RUuRrVkM52adXiqIkr2+FJ4IPpENOmadY/enz6wT2eqjft81Qd8gaj0tpfIBO +y7hoKXYugoG4RwBdH43CPu6fpmHwCfcuFf1R/SBbvfDQhcuyxKgVu9knOAoXbMRHLsu79/6R0TaO +LwhcoedAdPybapXj/wkzRozE7pU4Q46KZjZXP81qiW723inzFDV0xPhm3SftAQCP9G7GJq6994jb +diKLt6+jTwq+jsQv1qiKH3SxIBBLnvcePo573M+N4gPTOJfV4rJGaLPo2UTqo4b8ysuGG71FyfwJ +GaPxagzAgHZhk4DRgNQ6fguYPPlQeVOAPx75wc/sd8VI68ANQPTkyIgtLa5KCPYKKtDWCXdp5szP +abG3HtdG/UIUMjudecypyZCZYYeBH3JJSsV301TrVPqc/R5nHvaGr6P1YzjAOgk7z23oCD46iWQa +9qKsAE9fUTcUFLg/106lBizxHsyJfsg8gzE3LO+lUAreX6GkLAirjKO1BkhmN1RynIj89CtPAwbd +uLjCEHeLBj6MZ8kEy4VL5jh/16mtSUwl8RGg5Kgs9BMp1xrKDv0sfuwipcIhJCixIRpilD1HFxiN +bem351tQwAnhmEpDOln5qffPn1jnbmHsZ41XvIsaVJLqswfsHIIQhd4dUc4Ropzj9fnrzdJqLUGt +bB9fgnOh4MC+NyWJzROhksMMFk2BXESEcnNuqIQovzNpypRdbVQvvIc6LoRJHaI4ikvfns9JocKp +XteskEY2rNjdsLXDCGRdHxzR8mm/uvBVCJeP94sINeziVpynjHoPV87hMjZ1Fcj5seC1MlrcbH8T +LVK++HzGT4ixtCLIsXFPLy8zdXP1yvWaXbQgqMDuvgoyYLchHuHRsrmdVwthRTTK2SH2cZaF9Ryy +ZykhiiRCNQJKRpzgBjBUgl5jolZ0Gt1OpulH0KvIXeq67iI7cuRdwCumN4dcdSQuCUx66APJwn2c ++CwGo9BuiWEc7X196fbeDOMhP5+33r1OfZ8Bf4omfikf3jkwQjLeQqhWfW9oh+0QQMLPjTWEs2TB +SPJB5nwvL4JUn0M5e/yF5Xu8wtTHm4JqVycvYLWpHJttfUNCtAiYmA1TMtd02w1C+A== + + + Bbem0YrowtoxLFGApHmeGjJ8A8z2Z/obYO5ULzoGrx3ROhWXCgkbOQWMZwb8JuXzm0MX6q2B6vVL +4vpz4woZvnIRb2ymYBVhgI2uGACGaMAFpPVXQ2x8Vizf8N2QQriNAE6CsQv1b6g1WOYxTDhMhOS6 +uX+PNznG2Dwl/UCH2Igz+d+dcz3hpjOJUy0llEgt8WhZeAOdcP7mLl9jyvOZhrNa+OWDI4X2vp/k +h/k4rxz4KSQ3AKymV8gIDj25t5OMgPVt1/wjAPvR8EQDdPQ77fr9z437nQt4FuasLplK9BchiAaP +wJeNjCDE5Bmyf0dpSdkocC0gVZgUOymuYbhoPnyUADKyU39C603686mRIWZI4Q0svmKd1ToIZXbp +Q0QBlHxJ2wK3XqF9QG0XfO7e8aEH//r7FErdjJyPyBjppsui35/X32qALK1Hn1zO3Xk1MimjRA0u +DU1TrZKZctHg0MqlwwJTaQwUmuvtvm8W3BCh8AcirlaOGR0Fuj1S0BuJJUXn5b1k9IDQfl0f/y2L +8HKJfpFP9FceLGGL1L+nCPk/fyCb+u1v/u23//k/fvlk+du//49/+tP//vY3/+Fv/9vv/vKXP/7z +P/30t//np//yu3/4p59+/NOf/99Pf/pfP/2nP/zDX/7zP//p//45Tvr1N/77H//8x9/95Y9/+Gmf +4mcX97yu4FdoT/+V/0oIwk4R21MiAabmhHUOS8JDaY5grsBF3hNggYzMr1ddOmP1QWD+jdosInOo +8lDLHt8AVJB/fX3st3TZyDPIcl+SrRqLxSh6RyIM9q0QVoKNwZKcI//j6bXff40fF6H4Wy96kGXS +GpL0WFGJH9R8DfQdPbpawxga7VewGPKeFylZ1O+BPQHSSQXhkflb2SbuICagZQ+YdWjrHdlYtF+z +Vt7rQch8v081aZSzbwF2S7FWtlo0oaQT4uUVgBo26ua4WMPoIO8/YWzR7IERJj0Q54geBPwcAlQG +PcpzDg8UOT5qssxr4FCbtKDFl/bXECSlB4D63cOJremGMgWIMldGDziP9FgndGglCMH4uZCG37fh +lBZw6AA5ux8zLjvulveeFTHXGrx3SvFInjagqzh87KVJlaKyTgFuTxsPVRunEcCDrYMpmmvJMVkB +Xy1NP5o9sRBJ7ecBlRWv+8qjR1MVOWKFWUka7/Cz5sO0JgGzDi69QmuAMgLlharvDsrCi6wwHaK1 +iGkWwjjJk6Aq3MJ3Z78De0jsDszMIIogJu8tWi09iuV7qM908ET02lvMQi9m3eiFsxB0vnaOM07D +QgOKryNQQYPg4DTAi1R7iMTcT0ra6T0B9BF6qcxHL1GF7F/ZgkjG68PDgOmmA4RyOgwy9V4BHJnd +A5qKPc5ub4dUO5RlTwesagftFeFeECqZFz1xw4FbwkDQqGofji30Pg1ipyB4MSyrqmS266Vbe/Mt +3JvLxhry+g75HKpbCKgjolFZ4skR7hBEm573HoXfzwfUIc6L/EWvFs6pxBxAeCooIAZqviO+jDBm +zvu9Jn1R4Rb4XD41xA+gtFi++Ba6N4y2/QZXV0CdrdBoWFTzUPlNgQpP6LCzFUT6hJwulKp07xC9 +uM0AAlH8pZcYiSxZrMZxQFPQAyRJRZFthelQXl5LioJ/QuOPuI0eqKvsHnUdyA+9pCeRvYBiSi/h +kbCvZlxwo1alvVqOdjTdZGdN23vF8Zypj5tCB9Tz8tNuhZz7sqMjJ6BOgr6iOk9yknQBQJRqsppU +F3YEq3rnyFYTQLiZ/aJHD6vkzMp19F3fe6FBhjEuMH1SFTw8gXLo+Xc+UE9pIB7yIKlWFVZoDJ/9 +BjFaPnWIMVbCwXY/hEkN5e0oxlaMrCeM1PJgPV3fNXw1dG9jgku0x3tzSXhAVXc+AK/sMAZDxvyB +vIIvJBqjKMsiXxA99nJxjFgrdeIWa47oShYHNaiRInfUFKJjplql5rHlAMlTrRDaC/ohEas+nB37 +oh5fJ5mXGWit2ENFK/JJGJnUpk/bogdlU3tgYUQP4pBzN2cAh3avjOxNCdy8vVZmHodqGbNoiTSC +avWz2WOsbg8MD+ix94pxLXsTZW5r1kNFqDACZW2gKNViFdOKtSgKMRwfVCX2+ABYlGMxx/MMI3dc +yPY4CluyNGtVlP1zD8+0hFKyPabE/sVxmhI9e21+uNM7oGEnwDq6F7MUUUpeuhcapSQjndwOXsRe +tYiSmRSLjXZw5SPaQZmdHvxWcTQw54yYmDKImNAg+vXI6wbkQZRrlCL2ZS8dvVkPqAvs12+/+mSg +W0RqqDcRyEzXVNacGhYNewVe1LsbOQ0G4dyrC0KVvD1DPWRYrJNEALDd6Qg7i5Ft+z+07QWr2NZR +dN9hqgBkeywT3RjGVXuAKqJHBtRED+IMelTYmPSYqAWi5bNOIq+t4XCkFzkteykTu3utrOAyFnOd +M2WUVqIHJUF67JfLHvtdHEtcQo13RTfffS3pmnPuacF5HZJcpRLivILUpN6lhEx6ZyIyxSrCKgnT +HGwGtUegTw3DC8RnSbwz84SYFjP4Hi4Hf950jANId0AvhDxa8/G+oRDQkAvCCmc2FWtclTUBLkls +ze6heg0SVysbWdV696Bs85991r1KL7Xtc1TLy54GNCp4zpKZ4wcTj1Gtb1asByyXVeCXGLABiy4K +Gr0Or/7XJB7lylKIvGKUqwA/LzFSH4QasMXswYijx4587MFzWADXqIx7HsCFhSRruidqAur3rcwR +YGPwuCKqX2pxIwQA6oHkExFJ7hGA4QmSfO6/9or8eF6phmgDtbnFBfXgg6l9BC0BqZx/PL1aAg+F +itUxyxMyinKEW3KOw+gkCFf97DmKMLC0yPQgUf+U48NXgpt1Cy00Zp4ZsB6JdrDSSB0Q3QI6atoM +7CVKesY4HYIm9pCPb0jhj0P9CjPBeaWb9iwC/ndPCXvgaPDApmZYHNuzAQMcT9kVnomYwDza8pBw +I3/GdkJVHzNin3p4gqxrMGIJ2F/OL44jRagkthM59LlQVSQDXHhCpOMx15sqriXLdJZ2qVqTELnB +8KMge7bXOOh2dLTpRTGEDr7MD6ISBxvvYko0pF7B/CHMhVD9VANyL6uHNVkjByfTUhMOe1Xh/sQI +2a+zbdk9rit3Cs0+4kA03OlQodTy09JzSJNZWiVz4jlRd7549rqcLcWzaTJdU8MXFDFgM2vMg1IU +0NXr7LCR3GTNodpbQpPjFj0bHkZ5itcuQELIeQqkgGCIyWoD14ncvoTSFT6PygHt/Wg4Arz3wHF4 +ohInSuE888+92JsCqASyucwH82hyXYfIE8IdUzU+pDZbLH2lujgiPv7eI35T/QHmzyKhAazgi+Nw +aqYIKozZSzH+wlUcaNRbh4ys0k05fG7rqsN4n5/QyFNCtBFGJM5G5oypjxi9nrw9oQEZ+DnvYZFM +IU+AaBI+imiyInq6x3sxMijuS+kQx1Cb2OID6yhn8e5hYTPtUPBp53Wh0H5PQj2LffsefFEpYJnS +FVVIo5RYROQXxgBP9CChQQ+eW1NWl9zEDukwOPFMDZbcnn0B+saAfRyXCA/kPK53riKFaKTw5lGW +IbB9GJ7hlyyiGBid7gFvPYrOGjxI7Lzvmd56PaFeRk14ngeABAm3RqpmkSuV1VpHS80syA7b0BxG +qK2894hsCuUpFR0oRLcvjgOgymRPQdSSQb5Qy8TRvSAN9t5BFzAkXWHjnhrrF73QFYcxCQHFXL+C +rITk7Ie6byWi62hANLAbDXnYFq6bFS38RtyWT7YGbBdLtwucEpLpjoM9aIkbKJI6LeF/ozvy55FS +rUQPlSotsuA17NPpKLDHotlQOdy/YrG9rOwlmPsLqn9tIXi31xLqFoiesl4VDyP8zYReohqSI8fG +PpRqp7916FW7J5kjmU4vkhe7FxonIbrmytzwCyMTR5y8l4q1rJMWh5POiHsXAQ+mYcNCpoykkk6/ +iPD6m8veCN+Hg0vMXmPplXqJXmE3XHaEtzeC9NjR0X5H9peLo2Ccqa4s7e3poUc5DYBHG80Hh0wj +smp8vUjY1t9j+fUR9SGc0QuXQNRX7JFqtQfy29EDcQeOkZxte2j4kyGc9f+z9m671izpmdYVcA/r +EDgwGbuMyEMoIdSSEYgT6COrVW2klnC71RhL3D3xPG/k/GvNMe1FS9Ulu8v/+GbmGLmJ+Dbv5v0p +gJH2U4RifFx+ZySpMVrlXadq4i3eB0FoOPOyeoQAtXj6w4TorUaGFgcLJG+TguTMD0ddviVYfFKn +wUiJjZ9HW4QTW+xlYrTPuMBPwJV9vCPhrocQd01s6X8b6vvsZXLv9vpGEyHrZ0e8VicEFarSHbSE +bbq/whGAQbqfnmENjMcpteyTE8U1+Jq0JXfEnbJENcYW0n84gJd2DOdM95tnWWMDegRM6fHpy98o +dV/5mjuZU4SXtcIIdHD4jvNJhqiSC2aZr/TpUNjt4kugK9WPWIvGzr3ikTJEeZAT4XWsqMhkVubc +cMlLg7FyHyAqfd0u/ellETQ5hPvPmZUlVTPLh0uBqjonqI8R7Cr3Z4IwgIywNeH7UaNXC2eQHfJp +66UfNs07CVpK1xWVQ9SaZd7rYbAoJ8LBtRFPdlqWKAOowQmY95G9RcNDqu34dZ6rvA7rLQ7rc+av +9z3yryELuGONfIELkKm/g/92Q2yn41E0Rfp6pJxEoNPh1Fy3QPZvtFzxzYEFuW/TitpvNy/RE7Sn +tv8hQjnH+XUnfv8hPE/EUNt5ovaNpjMBPBnASgUOvVMlZCr4Sr8NzNF8NXYSJN7je4TnsTpCw2x/ +a1Bcn8e5tJjEsPbugllY8JAkoPfWVUzhl92w83lW+a4rbw+1xnPMgzjOPghYFER1bWRIkWp0QypU +035KxP1uYuFTsVbAKbTB0bn5SWQn2KevS+bYR4Q/CQt6GrYAjvk2H4cB4pd7v3TBqri3sbc1+qR1 +/hABsGkxpt+/Z8xfD9fvo/AaMp3eLz8iVqNBPmgo84KZDmSAIZQa04A7wL/dC2Dlgpr7/XNPg+73 +jbjzXnjsQn0/CLi9DgKoRVJQNQ9aHVgU8TU+AhAsQlQaHPt8/b0+ohgzTN+mK7xkhkP732Fqw3Xt +8uvRBmIMdkNT5Jeuz4j3UbspvvRS4J3/PA5GWjt5oN3l5ajQMKgt9vO1lP/c2R4Jxo2KN/m3hirs +qbwX6+X2PGcJWgAAi1GdhxVMMe+yEb7cNESobeuRyGYNpiQnwlElYjaAR4kAPUkEZilfZ3LkybRu +/3mieNh2Wl0Y3hBRIX/h1NKVNWxxENkRupMTYTqKhkw7vylJk3O89zdhC8azvzcApAVcT2gJ7vXE +zsdgFgN/8ubN9HEEQHFZd8/zsO1Ldd51E5LfB+Q8lCvthz8mL6PUpxbqSc8p6BlVMFz6KeKYGO3X +++XBfgYhg6XqM5YD/AqWXfmkUFuyMCcJ2e/d7a/Er2nRzGI5/va5J8FvwX0Svnr7OA== + + + BEMhdkhkMeudL9rdOY707g8RM7NDAEfzvSUfUY1Eg8zvugQ98WUfmSGPTavfaj+tG3k3e9keyEFX +rsd+XBvl6/eI99VMb7DdWsB9D6Jdu5foQrsWXIBfZfzwz9RU+72xpurtbXF+j0LD3pdhAhm/XUB8 ++HZORddVoFzkAIr65/uX3ljXrqVygC2ubxG5YkO+OJjupivXx3EazbTB4q0Pw8nExsnEuGLtSc0K +HuVeUdq5DsthKKB+C1a57iOgnmIfVehW/XNEmhBi/tLt8Z4p5lkMsDSHV8x39BB001Qd+NpkHnlm +RGHo4qKctZ/uikdBwofP8YY+YDEVeUJwyRGWEVAojHgNVIceGKySuswdeXZuCfqFuNeORvKOlE8v +Aa5LI0a9WVlvEqSuLBW0jkvk//eIbGLL8Q+ZzH6rfjzOc96mworW4ry9lLueWhx8RqxySK0qnbav +7PVbVD8KUa3rvUhWxfx3UbvCdKG9FRpuper2J+2NlZyvPf7oHaAcPt7npb77cn8zN/RjTxQZy8A9 +FTE7MGYgPXZEV+JPy/nmB5CB+L8facf73SyjfR03W0KlYhqSmNJ9q5P8IsfFxYMzK2a2ZtpDSKVw +df1uXoQKHbElgo4L6k7juJ6SpNsSuPmSJbf/kWlF/QiqbcSKjsrpSicQLeilPhWlzw8RyJ01lboZ +N7955kdUiVPMuEHopAJjREAmeouVvh0YWhIxYN0/BSey8vXB1wO8UzQe4Iqq9ddfNbUvcCi47Abz +tSyoIVKgT7h/gHCHhXuOx2VaZZu1oiAaJNv+U8U5F4kBcygd2+mt4B6KVSz76iUHnpNxqUF/22sd +N7pse1mb+ZJM8Vq7PyP+/I7UmGlOGHrz+Yyivc48ehdYe3+5s6g496Krrpb4R8QPe+NnENg+GhiM +F3jcO8a0zNx3Wo0l+N4I9K3qKPwv+Jkdxja26Pux0S4V5RIUgdvIyNHuCZCQTBTQ7QDxDWJ0l0eg +/Gm1dsVk6CUUpv/K2uI0zngGn5nfOhqw9AUXVasZsmQboGTX3g5Pl4bJxV5V9k9QtoSkAoBTd1aM +xgTm6rN/ffDPNpGurOFsijdD7fevdGdCbmRfWWtPKInURLg+0cijjwVehdKsiN0Fc/X2jPiQTYwP +1Xf1Q9WdY1+WCBplRFD+tndRB/3e3oieCBuvRlyaXlh1vmeidCdqZwvsxjXup51d/slxWsATo3G5 +jPCJ2e9a1+AbmbthS24/5cUIzVc6Rg71be3tdQGuObNGEHBE7Q/Rnq4KKBBx2+yEjcPVBP2LpzlO +utxiSFOcUUeC9eJEm6N63EXvGA085HrAfxtTWpRVPerAZGP5gORBXLvcZOZ1nSkbbRaocBUG2ZSG +jbb5r+79oqHJh02xZ2Xv+HcyIrr6cPATAL212W4qRrhK0Pe3Idkw5pnh3gBPfo9vnwHlMmx8iVIv +DZpwBvwu2CqbkQ7orFr9PB7Cl7TFnKe+6s0QvNuT/D3ngRczljZ2S+7GOGU00o3cT6qfm92uI9Q5 +fXXZpB50VPW9BwjtdKbtt585GQssf9FgWJZzYy7ljOhKYyXlq6uAYqMZyqtLaWNrsNmIqMj20RED +yFC0LP8esGKEAaDgpSR9BMF93A8eVkFgVnh6guTE83kAjbgz5qjIwvIAtJWcdR8iRZgCOUxq7xiY ++HtaP6M/3OpWUCOeaGf/lYFD13GNsvBRYUqIjKsiuwFt1F00ZYdCXbsLorkPcJMGyikKiHKEuKM6 +3XmiBGhBg2KSQQREdSIKO4gRgg73zjftgjMLZ92ieAFUwJkEoPL2zf51puE4VsWPcr5P8c+tbTBH +Ib/ZF1OHef+CxzBipMMPxGPvJQ4s+znuVKmFK/pQGoFXkRNfX+F4SIoeH+oznX4mvnS16mhsWDtC +0jY1dqMfacSjcSeqCqf7RBSo0nxIoU3/2RM8aYPCae88F8y69wUigrLytz6uQGN2RGE47VcA4VGZ +UZ7XkqCdGBvEo0BQnh6UKcqTE2ElzImA5BMBJsOvRuNrfzDsL/JBEcJKbre+boGJ4mJlfPgluqHs +K92Eb+1cLNWrbaL5Fx9gmsBPbntjmy+y9v1QphLYToQlS+4oMCSuOEwQBfAHnJeG3+3FwKNkMvP9 +g7TkLzGMn391P3oWoW1C0YCJBF4477/z/5HsYTc+j6LM+9mc6Q5VNwba+jQCWUyrhEp/u75EoCgw +xehIO1La4Qaphvz3iNw0+qt7R9r/U/QJ+jzOJWLD26q4/lxBwsAIY2r6GYBiDuJtF83i/uvp+F3U +vWLj08Sk7MPcSfCXLhSAom7Tdq9n8GdTV0PuZpbQQi9+/rrq+2IQxRZJkHMZ9FlRASJAZNAOKOgC +EwAiDi3V4cfdmw5Ua53P2UQ4wFj311mSxoBqZGueWtYb9YhWJ4JyeunM1IzARIlvW4UoEUHrb0ew +ye8IEGqI+ysH277OZOMOiEkTM3+f9gD8GEZIOOOQTKBmj+pNvaslPzqmF082j2nGUNTO7TMgy8L3 +tO3jMKQBqKOAJgEAwVdhePOgvae9wkeEj0DPI1De9/cjaiVltekzxvm+83zfnX/gXUR2vjenwniA +mdjOHslgH9yoPyP+fIBwjl0mRH/m8B/HARYFiG9CtCdCjr+P1K0FPYgjRyITUCZSyJgUASPktj4H +4AlwabgOTJk3AqKmLR3GhvP0w0dPP7z/FDEDNHuQP5qHFf8ZxYR8XyAsoxkgBP0fnD3VFBNYy5l9 +shUqBAkhCH/cFPq7QktRvBnkqsZnFKK6FTYbufZQttVRL05XiRA3ihJAb4ko3FM1o5oRLmda0bVf +Z8puiZJXS9RDKllb7EeNYIVd+NUAGsSHsMh+SPXkmaiq+S6UaEasSA5fryXBvuyBZqwWMZaGTiJ0 +jp1dFYuamYb+QhuzdpFheuBVWOROlb9HVFmCQJz3Uvj+pI+oXiKBlcRmueIyyAf2+wQIv287byod +DvI7us5c5o+IP5+sCY9dK6G9RP5wnOosie1P4X+BymqQFa0r5w8RO704nc0fPivB4GL4I2QLYSYA +qE+5WGVE2h+sN2/zbyQrk3nKsr3fPwK+FhQYKwtCBhyE70eBpwaec8mbb/mSNNH2SktBKgZtxCKw +a8uUa91zrds7ZYcMN/Va7dTNBE0Q0dj6WtgRQKeWADk4mhoXI7wRnsjERipBM4LUlQh5zO+JsmKf +qRtwUbuHJUgmj8NaQwRpf3DqIzh1+pkETNYTUZxPEKcXM1wO0Q9Muo93a1DTeQddMSsVUkU2Cz+i +AZHY5Tk0UhC80JsoXfeu1n+IQKvUq0IX98gVf0YVcBID1e5SRUn3lloADjAjDrg+tDb3e1UBM4oe +EQ0AeuSGLfE9Ik9dd4nZ7yOqPu2H48BcYIq8nykUcUXhM/bvRbstOrT7KrKICEC7eHPpmZ1qmTmA +8Ly9XqHwDX0l1INdwzMy6eUFfB95TjgA4lOKqFuxQ/ZXkK++AdnypU9Pir/mlheGhWDuH5VeAjii +U6bg7ZwWBLbJgcLADUZYnD7VfsYxjPsICPSpu3yBCnyKC+Xvg9pzlM0usIclCFopEKRN/JjPgDuw +77qzqVdn5TOqyv6uUmQe3ZuC7Ie2sl/fGuYTYGLuCv1efhCSHPygfecSUb4wdfS+4FjxwKzzodwZ +Rog11yNPAqJ6hxMlFnhHICZhQPoDPAcjBKKQu6iZ1teJpk8FPHu/Zw9NDWxGEV5/KVwokc3SEdEF +uhTIoAjv0f+9iWIs2MgbQauizGj2v8hTpLPE49QaQtNVvWZ0wAMNzY9+gOYur6pQ//2zboS0f4ig +Vdq+sKe//7BEaqMJ+Yaw91wTxT7uaaNG2fd0tivwxkQs3SM/I3KtIgMJyWjvJj8e5z6kv1nVhOb7 +iagqyplXyYOH3jnEZgPF9L4uvvrLHRwH7qZm2viM+tvzdeBm7Kh1yHVnFFxmsL22jqqsqF2L8zJj +asIkp+wXFr2qHyJaMEh7y4Ru8KsF9bso1JnV7y7hLAAck+zRWkDCO6eVVnmxE1A7Ihg+UM+YyFb/ +EPHWZxDxaJkytf3hOOuwR/ca1YabEL0mVINAuNJB+Ij4vjEnq/0ehTiKzIalHgnJYbelzZDDJatL +HJBJAMUQpFcqhr0uCuC8HhlGyWVboCWToUWfrrYi0sijaP6AWWgIIk5ABvCQaLRJVWjpBjHnvbRZ +vULYsEJv8EDvnX4c4UpAI6aQk54+FQcypg+kIiymQQRcQKMB3pdHqbYKdRQobCX13yvzvz1TbYTZ +F4pxg34i8zTYj0xzwawMyF7k9UAuoQxTCYQMtB8YSo6xky565d//PWOUnoaGJgfAiT7++pimkU+T +rpjN6yeJEid/8hnBzqtn3T78od5/BmlbsL+/GrPkyN6ZITAWwQ2+GlDkpW+DwIErWyOWWe2MBIbG +qwATdWe+A3ReUgrBgO7jNyt1/f64DNfKYAGdFwCXf4z4e7GB0v4/ye8FMvrvWOeqz/JWQWdkSXIK +P1gDcN4Zh8t0QEGoIRY5nzNORTT5LaQ4Dh1+ZiJ0bYiQ+IQc7T3y4klRYNgGJNwIeqI7or3lwzMP +yoXMDiK3QHKx/wsoA+Mk4NfYkoN1s76g3HhQd/e1KIdhjjAWzypSzprK4t95v0gPWOaVZ9XhmVEu +bLt23Hv/8DBCk+norzsREECtWpGHJKKS6cCzn+dMCHamrr1+nak9znQQkTxR4RbCy81xsMYhovlU +aWx++8FgbMwHQk6fHk7T/im0fM4JEJlCvWWXQ1NmO6/FfujQLCd3HECRg3+QQWnJBaQYC3qMtkWX +hY3JjtrcJvpxDwQUs/cM8RX7708aQNVN+nI/QMbgHe2HiN47coR7+fkb2lHKCIB6HaijQBphb+sS +GZX7gLSG4uQZN+KLwS5xo2zCJoqSN6PvdaBG+x/zryLJ9ldEJo5BbmACdKssPNBSJuOk3/S+1JiU +sXrfrE6WFkPEsH9OV4c/99ujKw6KAV8Gih4kVenD8sH+xXxpdFp/jZGlgPMhA44igClfy84TkH7W +hESwu1adVYwQrUeuW8eJAFLMCd4ES/htqrNp+671YwVYACWh8QTKgT7NjQpZCeEPONUgUjxTBa1P +CTtDw92v1HxLdsblsF8Zl3PevWemTgMgONcVdIJjLNsU8q6fVOQXzQIeIDQehT1d+8qwW+Go/IIS +kIsCckBPlwZxA/DNMO/ab7Hj74kFLN00xBaLLGcH2bKiKItwBuUBvYujdB6S+eZtO/0PRQohW5x7 ++ZmVZR+5OrwCvdKw5u54LUls378XatT+j7CIlSIYBQHZmkxsQi3vL2yr6xLdJUPRAyQGkzgVIy4R +r+tADZm1zwTQQ94BU1hUh3R1iQTZL9/KadDNdjj0vtLgRUTuMpekfgVB8Hh5dj3bciKKKSKkZirV +NTkRXaYTAHyLQ9DtJiK0JhkJ6+tEj09gaU7ZuS5Z1y8daoEi2zgir6FZAHPYX7STtQ== + + + jkQwd97sYd95h5KoCoRSyVDuBW0rIG7ndr9avKOajCOpWvRfHGjAIaqLIu/SerWHXrx/r0C6AQAf +e/odaibcVBna3/VatKhOkjCv7Gf0K8BZNQ2ai8IO6Ix6Jm4aZ2LT/A0dDBXX94VtwvAGG1NHThlt +uX0MzKSAT1yOW37h0G3U3m8Dat2xc7sEzpDMrDCP95WSJ64X3m2SIyviRmhKKvVCZgz9iv3AlrPu +IqfMoHwvfWWphYHlJvM5pjggxvQhBJ8MN4KVeU408PZxOujd5aifKBnSyo3eBtFZJ4hWh8v3IxwM +ee37RMBVIqKyF+LGDs/jFjJUciJ/6o4fr9o7LCGSk9sNc52vgzZD92d4nKBOwJdSozNHoal/0aDi +0hPB7eZJZWEhwuHfjqDHf4AvJWPP23ErUdd5ixgy8n60KzowNHwvH3h6FB5fciIiCKNnRSSpfBDr +OZaA+7n5GzAjUEO4c+44BbgWIB46FoOBNWXGrtHutN3EYrNC0xol1+kzLtxFCjYK6iAJCxTzg3VK +RtRPRmRMmlTs0ydjcl8lp6L55VEUS6ADsFKq/OvZ25sP/jXc5MN+D3i1mK4UNK+wXi6g0IVvrMM6 +KfgRg3lnDIsKEXWhD//hHvHwMU+V0AX+QCtcaRphTwBdLi84k16iMNBG76PmQxpkyHyYr9EphCF8 +I3FegqAupqf7aZzC+UvQEgi1dL2g0V2z0bUsKd8zZTfct7eJST7zyI46wjxnCjgS6/lmhDzZLsU0 +ZxJxwQeAmLo2QefZvVGaBrSFe8AhO8lZAF7XQypQqgjemeB6GjNTrHLhFNZ17Drid2mg8EukuvSC +a+CbuF0ZpGOAtyRf8YA1aFUIvpYk08JJeL6esKeWHEiyWLYRuClKFFRyu+eTmhXobD9KAWT6PUHs +v/wkjO54Xx4F/QUL5Efz5hJRXRqIAAsFLgRJOZ3p5c7QhD/a4UStmRPopEcVKxBP4V1+CbVmM0AQ +9g7ooHk9PoNVvgFZNxF6RnUaLS+ijoLLtvEuy688guDluK6NDtOQFOiVT96697IoDfWLBKn99sev +x5/+iq8knSnwL3SmcHC3Mn/YUqnE6Cj9w4mi409Uw3KAKGnglXk49HyFCYbHudGY9DiAhncEGjJG +gPYgwpXSyTSIQXUC+kvffk5LiTxjZX7NxJco2hI5DnhAjiMlkDWMlINEFUBEe2UU+C4obK1jPcaC +/GIfbZSJndk3lESKpoXgqIqa8aFZO2pG6BNgCSAGh3NUPzxqKgOsgFRMAICytFfnqx5IV6sMJq1p +IimFE9OThrPtDtBtF2svqRF5Ceehhbc36WHjB7plkta9cb/iRtDsBjnw3lhvEhWi6PRd6n0Nj0MO +TsQD7pCIqCaJIr+NYB8kQhdGInxdrkPd+DrTLuCMou1AFOWnj3EfOdP5nuTAjw2akl+yMwe64Rjo +9kSgAk36vcovnvVF2vLgBUSGcR+c2oWopJMDGvpdLWWKLI/DXNNarzEVxEDpySROHwsyv3eAxUpg +x7NC8mCaE8DZzs7qdR8cX3rQJO/TKQzFQWcaU3ysVaJSdejcRM0ZzzjpSoEL0BIUIC1MPQkBRiDj +318aHFRE5npNRBVSLrgyIMmqQjtF+iRvL6YMruqs4PN5z7Sv521PkC5gBmCTgXYJLi/gIoW6aQsh +EYXpzRXJQeZFwTfRJ1iiBE8dW1QfQlvpC8WE5B4xuIxYEdI1pPZkruelSaMU88vnREC7wd2O+Qnz +TzIIq+nlB7+MghyOPqr0kTeemhsTTsbhwBl7VO6BPLfCCpx6e6gAd9OqMoLHhXr7Unzm/sIDowAl +ZvBCtHCmNGZdozSGI2yEgnlSdbo/AKSA5+XF5bzz/LCi3ufOoV5MJDpVjHco+wBGMDPT1l4rOmC7 +SLsplHU5VHHoKHxsQiCq/qmeXmbnL6qGVo7lh92SSEPRaUEaChsrYTVCJlAR4El6ArkaND5BztlU +Wzad3wSOw0oPXNzSjDWEYZZ9FBTXeECVhgG0TOuVyYXkALRRdtkj9CrTL1J2R8VXTI/pwdd3hNuu +l6PebMBg7EMaxPUAfMSrSBP+0Z+nqmlEjgaWdTqyY/J9JSXuaRLtyuJ6MbvADJENAOnml6ivJNJO +VAAX1XnUH0lrnTmdPM9RgUDEswPv//tuaunM5I/7p979i46/kzaQFU+JVhRjTnMfBFjw8eC7BH27 +n/c5A4pU8o3WudrEsKDIKB9tWtnLHhMzq7LrpeNDNZO0f8TJ2IhkbgghZQRcTznpzaADqB+h1bks +An4S7b+lhBMJJW5eTn/hko+vW+MsGmUvgB7qcrLPtets3dxGYHg4e9ndg8/BpM/s0H9/WyZdhsDF +VYRwGZXPejQI7OPyBOxLlQ+gFgOjnyURiMYSwfaf4+J6Rgr/vHyn+oKXm75y/mjE2J6qneBQnET2 +zqNnclEF083hD3Oav2ZRQ21PhstyEXHm5zTlURa6d8ZiBoW92UAsoVcdODQNw0sJQoV96KmAPA8/ +2n5FYj91OAo8ijFxW8BQMgup6jYc10uYyteX1uSOwqgNvy2klYgKPwFnQBIR7rtalh0ZEMh55fCu +6cixFk99i4jYjyR3qJwOB2CS+uqJzEf0EVEBJEobtF7bD9+VM5FUE8GTmO/Cq7i/8RV5zsemqhFC +xMyPl0IS/TqrSsPSye6Vg7jqXOMeqIqTAzARXhyYsfvOT7oe7bcA+kYhDQKT3j5aPqrpNAcedDPO +4BaRuV3w0nm5lVyVTsYPDnheUR/6WNDOST0jOK5YEC1mHzb9AfcH8ArQF5kU479Ej9T82lHWgESp +3Ciw5o54kgoVD7Om60TQD7azwUpPxJGTWPTRjeCWEdG/9I8Qeb2MokucKN5mos5hVgzpanemdx1e +CV+4MFchIhJKFR+ERNAW2hG11JcVUCLy9YQlpAxBira9q1G4kGLbXtqvBXtAdA5oYqBz0JCzh/0D +s4uRBqkSIgVfiElQRDJtdDMfMQsg+cIsAEmgMbHxcK4DAE6lhQKKedeTEcgmTQR/X36x9vrdj3ZJ +BZVwh+XTqc87qcFvINCW+hlo5ziLew7zdF8DXLu6nfmh2MwEl4ASHcalrufjTmcVcEl4JSQATThZ +CL3tsD/aoNh1R2d0zF7Mes9UD1UepnqIgX4Be4U47Ih69Lky2luOPAKwH7gq0GtQYGwFt15LcOKS +JOwq8SS/ZdAIkxhuhAJIs7tlNDwqD/3YF2m/AEw5IEY+tzPNY3dOJ/Klpws6oTnxPLH5qeRHPOdN +Mum+uuqKiRlAMJABKl1J+NAK53bhPZKH9auHHwS+jCLJgX/7Cx1lhaf4HwDTNNfBVOqlQUcGvdPM +Xnmu2RDaY4pQj7xXY6Rwy+DqCrFEJfY9fHZLcBYlnB1k8mD2aPzK7g4JCGWWm/PTDAL05qlBRAJ3 +ok+M12paH89LVOKlORQOslAgetzMtj6CuBqPxcvoYl1DyL9LCPlvhAXxfjLIT33gWI1w01r1PRE9 +SeakrJstrYlsQDx7clKasmr2gnBcpheEKjTfMe8x7Y+er2B9BsDrftk1+6l1MvGMUt6ekmMmv7dX +TJMjOLwgBbu8LHW61I02UWJEQKfPwomMjk5cDv/qI/FWeEPuI49wxU2RL+DUHTmWBmC/AWyHMvRM +n2l+ISMZniw2vNCEJN7RvjujXfIKgeUYJGNzRpS7lgMWysLrkPjR+1QOqK1I3jQYJ5zpug8DaFqY +2eb5BWbpRyF9OkcICmBMFxj477+hod4oInjT+ooeQXqI+wZfUCRQdmJx3JdsmkTVkslchyPU3qd4 +pKqUWqLk13MEoUAMkHe3o/UJdApHAnqFivvgZecLSyHKQsDQQcED2jf1V+kbc5tjZc0AT2BjOyRI +5fHoplqf0MVitg2OBoQDiftzSld4FJ3p6F6j6hdKhn3cl2hWSTeg2SvWF+zn1enLNNt7VCi7At62 +48/5C2DT1Y78NgLbsLGKPOLs/JEZI3HQ7YL3PEpWELbpN5HfNRa+FtSY2nVKULV2OwJY5wpxT4Cl +Ayl5fbv9kIqPHoyEDOF89HQHxJCWP1ckvUSfnojIXAyxuUYoaH7B7ayJiDzFXonGGZERJekJn8oj +/pUVa/ACFK8UKBwCHnH0RCiFhqGjcypUrDoGRhfuXTnRlS+73toddXhR8jyUZjpow9AdwQSR6oJR +zAwnFH6rKubVrk+MqFEck2VhSXq/GtrFdrPdo+foAUnzkzlHKa1cmGro+3E/kntT/8t9/US7MZtD +Du6C4HZFCU+qAApkXxKUd6asjMtuTDDJD/BpIHO9MsHaaSgJ815JSjKIGpQIG5MKrPCA1c5nYl2D +xenm2Tu3bu9+SBSKzBei5D3ShJoh7CiLLSIqkH1kQqEAVDmIbAAI19K1m/U00Xj9VcoYJ2EZSG9+ +nUjP8gvpbJZHhVyaX4eOLQEM2B/5rE8Cogk1gNG+EbUb4UOGXbXif+Kg/+I8vC8AkK8jY6NLgCtd +dzYPrg2kIwOw8KwhzHB1ZNpB7UExlyeRsYkmQaqU4Lt79hPmt5EGVzd3mdIDomp6pylyB7cw90Zi +1s7DfYeZICOqgC69vrQ1BqY8b4yVn3OCYUNamNU4YCx1QPddfUTDqwm3P71Y591zykm6yqBX73AR +tDY+CeAEHBvshMGxQTuiwbEGYLaOqIL73vFZVoWIuet+IFNDYlQnU7el29BWBoZNdhMP9o0AXRij +DQH5vZ6OdgihDl5Bu8NDi1DUDKcZVt998KEH2LmfUTygYOSzb6RVVuzEZF3eV6bYJ7jTTNiVswT8 +JOcnPeThZEsECABFlLEceGTZXmB9efGtBkY/LLx96dBvYp3GNPOh8keYIdlzGkaAZrqDGB8n+u8K +4qWPRoHLIzkLBS7vGFO4hqbDldak07M5gmNqNrTPCUh7EF8TOSRB7tWCR4pSp48eThjVIJ17tM1Z +G+DoaJn0z6cBKKUH8Gvc1Y7K3s7O6ZiyNdofspQ6HhoRdQdzyc7aT320//7C/7YJfYenue8Qvh5+ +4R+j2AF3FLTtc5w7EShwJILOsyo+9URIWNlfU9wwEfSqiLieX2fSMx6Z5TuyzWgLGKXIcD8wLCAf +6oES0RStZNSf73LIIlU5eQLufFl25K8T0bZnTDaFAyCmuXIYoeXQrluQa6DwDHDlr2DUVDWemRMt +bUpqFKRFOF/OOc/T1HRgoWgaSvsi40SixkaKsYc0QfvlDaH2EVDhI4S5qtUwnuimydsYclvUhCgU +w28aRJCE3Z0AVlZ1iDWSNCCqWOQdpQCUBaYjhhm9hPHoJbAcEvJDtGecX8c1y6ODahebvrwAr84F +TLEq3psHJC4LMyAPFE2KVLInGVRwHucETgS6+8xXVWzGuUhEZgwfVMhlhSbfJkKowIIkWMsnJJxq +e1mPgzJunx4W3hJ2aDnA1Cqvn0YJmzbrA1sdV7qcgm7G3nzxpS+9UaYGQsF7xgiEgQ== + + + Fk+tKGep9vjjggOCexeOHdnpjHsDsGem0qh1/jbgqpMlz6Y3wn7hAS0xz7uxu2wH5Xzbflt2XpdM +eXcL7J7b/QNsFAIq/LfbRj3KeQ9F6f3gRhLTHpU9GUFfryoWbwJl/v3m44jxs85XPHKr+mACTwnQ +K2KN0+tFD+49EWv/OqlGBZB1LCL40AE4HzIAp6FBM5EPLGcRFxn9RPjPKivcVPSnxwp/v4KmeIE7 +2GzAW+ONIMnBuhH1/arlbc3wXHl6mIBcvHUgoHsZKUUAaY2kFNtS6Lwrasq4sr+ZJ1Hq0hCl9CW6 +NCTC2O+iNkKEALq9JO+0bBmR+fHe8ZCvQ0qKF2bCE24ngJqYgJccSNQVjf6iH49RUIxqNs48NOIN +GnzMmq9C+2tHXKjoGkF/mohsxjzQ5z7IWME4fi/pS647S0jRhmC570D1R45FQwEexj41PEDqRlEd +ZDR4UxFmP7syWyFagetK+gGiH7YLjbxLhQsGvOg3omMWI5EngL2a6jqsx9CQa0SzsJd25rIfuZ3C +fBHOQlDtRzFvXW+bv+hww5lCGW27uJCHTBKG/QbteiDfmiqh/nvZn7ohjBcJ0Sgenl/0BNLLcAOp +9Hr3o2HCNeIXrZHp8Zw66ZAwKDa41yckR3CQGCgM7eviXL8i1Q8Yq5X9vV4xhRXcExykboN2Ht3d +Cl2PdWSNw3LgMTmwAmfBVZV/vgm4I8YNx46vMtq931tzhy+vc/PIi70zFF4Sipup/JCTk4XGDBAl +WvmqDSp0orAQ2zpr7HXURL92iv2ZXV1IibahZ8993dvmUg3GiH4irtD6Zc01JWd+OrqyAIjLrLcL +Mw/2cQfVfq1DDL8PMZzsabLqVCO0ajIiWViUS4iIxuiT9dcIBl4NoPMpzHk4lOfBDMT+2ryj0gUi +gPlVv1NZg8G8TKvXdRIsiWHuKH6VtQsF4e+LFhWGF9Nl8ZzoqPEuEKkUp5hTiOTfv35e58qwxWLK +oTtPO4cZIm55IW+R/qLoHlkyV3H/6AjAnJ2qhX0yuQl3VkneZyU9Bfw0BVT8pSGZX+A5oLfTUuYt +UQs8lP7rpX6yWYFRmBC1eLBsbyx7IjgVu3MLRYElrQ6QJGL6cBeU6qpex8m6B3rmsuMZVT24GyK7 +8mZTmHTYgnYz6CMYBY3r7jCmlYpemmcdHR6z9wdtiOzyAqlX0WPANp7KN/1S7fDXrr40zUM8M83V +aOsXcansOEvqEtmcmo0z5KaGvr5qiMubhPLG/rD52nc7KDgSvdstUUAFZzu1iCtNBHVZjvlAuDLD +WZwC+KApitFeZhCv6Pg6XJgYgDZbTmquDhYQ5XS5UozzpgTfOxHKUiAGDUKMiPOVzC+ai/Ur/AlH +TIoUCTkiIyOCaoqhcALYslNja4QzmprEFte7KtbXXraFyMo7gn11vMUmRIW/AEwmXWFDpi2MMiDN +ouaRj+o3a/eNI8t9ZMwgpjTkIwm4w6tgScesXIkQquO2S6D20h8gB6sufu/lMFv6XmJVaYAg9hvo +fDok+zB7aRZ8to8rjnJmCwaz35yvr4DywePNL6HBGtuD+9U3exhdO4W/IYBILrE1DrRYT286aVSU +tHBVmxzhE++MZSFMLfxNz0aS0kP2RhJvDoHKCCoWC1Mz7J2KwAsKrFOmCOOlOxogi4IFg6sxIq4I +7BZxxeHwHJ9Rbh5r3MGeqMAomq1wBxNlK7yRCpcorke2ErDZOnoYDJrRw6jROpcMuQP2O9YTQM+x +YfbX/oJGoHZyYTmqRu0Xlkdt6opmBFs4ESiHEGEfvOFVisQ2Z3pCRbg1lpmAZsldRLq/FJIRDMJe +JZZKVZYJlUcFXtKIJKgCvA2U0uMamPcDuVVUzwXYqUq6X0hbxT05bgN1P1+Q+UtIWM6UzBcU7YRW +AI1MCWSVKaFqtLRIRNczkmqKAR8iMcv1lEj4zaHz60z+pn0mtHd1+rxNtXbeJu+p6ZpFm2zJKmGo +B20FoK0ayzdE+SJJTYl3Jp+g2P90HrhwOPZvRH9UrrlmTPulF2ZuJ4TjdJTIIrqlFGeterPKmKLT +BYk/Erl0Vn8RCCB7IvOKB1aiCilLJVGJ1rfbOC0w2bJUX9HiYOaCSO+w94WYbNEprNa0SaDKXl83 +ZUbr8OahHQGqBw0moeHx5rqXs0GJ/IFTWyLoTGtZrdW8fkdaskk6ABa2j/pqTCAHHkn2ijh+CWje +afGkluUlHUc8Hzvuw6z3lWlBlaKGX1fqU9MA1BPrm9eriF+jiC9jqqx4WRZxHpHEt468VRuNFaSr +zY6QtUnE+QYAY08EnVkirtcGgBYhg1Q0QIToERVNfjm7N0BOrhTfk5cN2AytYCNW/oCigg/ou3wt +l5TjdEpY58FNTUl6ourVJGPZaVFdENen4nBoZLgWK8q71BOoDkayOk75XPyb5IyCtDH6nkyKQF7z +mARYFuAaLBe7sOX1ISWxe5VL+/GC2JlA2j8o798S4VnLfRxQjeDRr7etKqaKvH3XFC3BD8o+CCUZ +DhTjQZpDOwIg+uEUlnjt3h5mJooVjqidRvztfxUGXM0B8ODhI4D1Ln6RiI1IWv6YmcyOEEWnF4TM +ONIv3x8dCvb7Awbs0IlnSv7BsAJYLTkI4HckcRqs5F2smDOsqNCr7+dNmwcAQdXE3WyClM6zeg/t +LEkYlXins73GeQUuyBIKbmUi67rPK0t1wQJlb/G+2eCTUlouIT55f4nJr1gNUjyqntwZLSsvuS95 +C0k21e6FJ8NtSmljkoHb0rfgOeWb8NT+s3CTVHaqhUmpTarRfFp/Q9FJ0tf+7WD7nZPaY+0t8xaq +ttBf9wPp4AREJzS/XZejD27qS1LCFYGxaOOB2dd1OfvihZCLr+cRIrUaAECFcHwSUPi/PdWsdETn +mWyX5Tl8Cf31qoQcZxFMgDNWAbZI+fbkdZ8Cwh7BLgdmVu8XNIcvhBn6fvwuPclm1FPHMH3osuaK +hMi+1AleQdUNiI6UAlw4JS/tnyE13cLDHvsLXq86iDa5bIjw8rvnceZK5a2e3XW2fW42FDCkjwWY +7JW8k5dqWvWo+4GGdnxSjt/ePs/hoIAgt3P0PDZedhTeREQVnEbPcJRWGal9jlMyHoM8KE/8DxF6 +f0084H/7L9jX/xcf6A9M6POf4n9+soOX3FcfNZynLmg0WMFj7LtyXSW+iJL7XKFuHHs+g6TuuTzf +SigZQdfBD9z70VemFXA/pyICb3squaFvVrHGmD23SGMG1gbFgOJtnbXB7Ki5zXeNLCSM6DF6RvPy +OIA0lC9DDKaUGPNhJCamYz8gEYonS50eR4Gxic4Yg0SgPHcEg0fakyMGER6j5RiZGhfWof51JkcO +O6rcz5Em1rAChDDUNMBUen/iY9SeA3ApnKmDzDVCPbZJilajfRzDHByM3j24HLfHOwJGYC/MpCLW +vSsbYZtq4FtbU98tc6QQ7cmQ2A4skEiRZ7uPaDApoRXkjdF5Da4jqIULOa/4LCmvREfdCdl3oypU +JFQmgf5pTs9GT82WEfQ50xh6Ku+l5gZeEBsxvdkGXYOq+rmPKLBK7Wb2xuZTsh+InaaGazvc+iZc +jaHrQUxCUHE5QoRyf8n8BzlcP1HUQVQR8sJ3vQzN1A90S5lZG4hQQmVH3ECDiRj6nUwWvPvrBBHe +gIBw5wT5KQjror9PhOg8xUtW7BnE0Uz6Bj3fRTDlPJod+2L3V+H9Zle6mfZe5qogElzmOgU1mfp9 +VBr2Xn/wBnuHcAfCs4mdEvVfue49TLKPCM+0qqdfyOGX54fD2AklDS+IRgYkQlYENgOqymfAfoQL +OJMb6sJ7mm9BdEbY+TtlAfnZ6s5pcC+IuSLFC5MAxdHhVdWI3b8feNgJQGXvToPZMmvC+1eIriug +0g8aFcsre1z7PqFYyZ8KGBzHmFczqdfJiQ+R4gBkp5MT4L0gbLhaNX9OeTGwDbpjaRLQFhAtFsQ5 +U7QNoGsrEYEaDwgHv36B3T7UYub5GgMZvB0FQn0f584ofUcADk9Elc8E3r8YYSt3CDPIiWBBcKJ3 +ojdo79K6HdiC6fFVD4bspl/EYU5HciBkeiwHwTR/fsDj7opJw/qVQPmMqkddHtQXhQzylncxeadJ +6BYvMWrgyEC3Csq7+qykgLOciHYiDitmHOLdx4c31t8U3ft7qUkGxtWhW7ezMX6I+Olp/YyqIAU1 +1hmkfb8NTF3xYxnsPDNgEaQoeFzZXnmfpv0rCBCv9InOEtwoRC1WACRZSkvXs+VJ5wZMBP0326F2 +v9ip7oM1MGqSSe/XWu4pdf1RlrgLuykRqOsQMejp0dNCFoFmF4ieodfck97v+zbxIfKAdCz7iIOW +lr57vYbw5p+zm8MCuO441gRaypKxbwkB1zquOvJlGfC8uhoriHAGE3vdHO41gdVfsjl9ZyT0SDNu +EdBveh2CGaDsnkd/d0Td4zMiXcTQ9T//nDPawoIkRNe9r9Mdn6xMPV4XS22CC7nS5DGUT+Qx9VVp +IUqNGCYmd6KYPBBFy8TjiAEQQrZOKqVKfdEJ4rc/zsj+1Ty0yZp5/svI9iIg7MizXuh0Ow8aa4h8 +jTyTVLSuBwf4PcuPFC/3M+koRlVY5Adw25ZsXU7hxfzolBaKWcuqju3xYSHSUn/nhiXmQjSFyb00 +dbk1TcGf7Q64XgprKLsxhjGf3y/ZpWhmOdLOZBY9Z9LJg+bferGvoxz8DYLad+xjxpU/VyJKA9Ey +8oF2lCSQemkXkZSCkAaWI84QhxGQjQ729VbVjWRu6BKDCz2jZpwrCsrQQM/BcC20Fe74CwX4Be2x +Rkk2puOTqv14IGqVNmBP/3JstdPOmwSXUAyplmsYyaxInMfpAwkDXlRK73i6kgx0pV6XDL/9fXBe +0GqVOm//rbDTl3NhPU4hr+oCbn4MS3X0eCIZ6w7McdydyP1ilcaVToTyBiB75U0jooiGBtkhpMac +KT0tWahKxFdn+7EkIDdSg/s+f75U48M4NRFILNPCB+mWiOB+FAM/t+eYklIML1OqpT83j7K1PG0J +BiK8Ekstgf5MqKx//NL86a/4okpIURy36lEnQCeik32SAPmG3gzySWRAcxyEEVkyQX2KZOr6kRuB +AU+QSi1IJVV4geeqyL5TP8mr7cU6MVfsv5BAutaC8xELS2N1iXiiQTw9jmox7dVwkxYWEfuAshAe +7+dPgdQAg/piIgBlFCKGosoTZrxm4GjDAIfsDHIvESVBKKUdDNToPndov2qyXXeQLLePiNRRT+am +d3itn1FUQ11JD270DJdYinwB4GZLM2IbjZ7RI5QZGxuKVtTWzubwROTi5k0GoncfACpTv1nih+Za +cR/NeyLc5y+F+HKmaPogIjSjTqQMKhHlbfriQWG5DnMyhznyNK3TYXNMQtF1g+Y6EQDlicDELBE0 +bW99DHIiID7PoXj8mpo5qqrYtUJjfsWJoJejNdjpNaGRQVosw3oGowdKXhO310oSkg== + + + kKpuIzr/u95iav+1sdKW3Rs0uKMo0AjgKlOspHImspbuXUmNt4XcAPGxZ/3wufh5m6wXdN3TiPiI +OhS/nRGC2oqfYFToyHCWaprB/OCZPs4GnrHMrsolBX+L+PMZm0S5ZiBhOn46zgFs3hRAJd/FZNIP +gAfwwR1gpNz8ejk0Oif4iMIiy0nEXutKy6V3hNUxvCjBPYasDcV0mhcps34Law1P2qzHlt31nqlH +LJHJ4eMsBMopa4qek8mvMnTr8DaiN6vXkjrSV8SqcllRz1YjsESNRqpa+9XQR4trMTko8zDHR6IA +EHuc2DTSUZ7RS2V2z48NZK4DNZqHdA7CHLDi8z5n6zyucBHPFbnVsYKallHYGTBiUjdz7RXT39f+ +1u34I+KQVfeujfvPeXO+R8G7EycEWfJc+2HzfJd3gN8qusE+IBA+6eejf1M+/z2L2uumjXC68OTv +f23ypsRlEbrEWNER2ccHoAHpMgPf/dIL/IzCqZaRzROrU0VsZiZjDlhJlKGuD5W5UbN8tRPqK2q4 +l70vj+EnfDV3pRUJgNxpRZEC3XCsBIKv/PQsOMa0jXZdpDu88nLvy4OJyUmbnkPCQk6+HIywAtUg +9kgJwXQpjEJnyh3o4f+BYrpPzxDrTr9CPdvtrovul7oPpiubC9jss/Ioi+OEu4td1d5uv5etO2Ni +nATE+xiECXt9IscOnZYF67pfzv4dPV8+lKGNDfnyb4Rq4dBURzTY5WLWGpYLEdGvL04RcviiSnv/ +cjAUILXy54glPIx1nxjYyHG55hmqVd2G84FmKKU5PGk22hRPpSgcXyjEjnYajBghdBdFUtOwLnBm +9MnYJ+uhAEC1mswn/igX+mtWSPCYGM/s1Acpqqo4tcC9ctsgOMx9XB3ZyxGngYeP11XUXSqIrd8a +tifcuku3zaPd4mwa6gwjTMpo2f9F8JMRjq0LLLB2CCnPdcR3MNCJTmlzn4O/zXSQen2/eOT4MzIy +yYQ9kWq3z3W0+XCoa0d5ruYYq/X2dSLyNGuF1ZMI8th7gpsrUuypv2B08eZBa/MdIdwLXx9+MEb/ +C66bXCb6SwlSnlDbsVtChQ8Yl1DBM3QymPLtsynAsyMQue1K6CgfVQYD3MMQW+2IdwLuRb8INT4T +WKB6M2TA6FMyGhXOT65wnVwBihuy2B2GKunbnY1AsHehuV1fGf8Wx6wdhWRLotS2hyeyIgigcDZ8 +6GecMXXPFnuVN8KM6VLyyAjnF+UJgvTrTGhCEdXP92HVIqr35zCvhyJNI5yLR3Ccezn523Nko/j3 +zPmbgIBcssf5SytpxrOZkaH50EKepxB1IkyW4hQYtDAUke8ByF8lF9kP8n06Z4maJ+p5GUc0GFGv +gpBg0w6y7LN0Za6SJZTXMnNg9EjPPv/sAgJjXfpr2+8cBLHzJ/TcbClorCRI6BYSChgTdOF+auQF +asJTjwnPM3/ZMF6tBhX5xKBLfG3cGUJ9cu4ClI7UkhNEeg3GA1NYrOCpwnaNz5zlM8Lv/2FY+D0K +mwhmLAiUTOyKuWz0RR77Q4owEHEnQiNMvdXeleLbhySQTdZDiWyaBGSHxUiSdmssgFr0wAoyirDg +HRaBn7KyeWdeRrztGsVyhrkcFqkG9ZUgkaOsz7HjGwW6cEwgOAA45NJ/iCgjU6l6mQ9/NR5+H6Wt +yIytiITieuw5duWl18C+yJU1pCo3NNQW0jvwOVO8j4j32Yo+Bm/XT1HMtqfKArTNKaQBFyBIi7/J +6of6L7ubqb2UkufQqfZFeZ3YykHp0YJh7Kg4P4y4CsTuenIYX9wr5Gm88Ir/vByM43Su7n8Awnwu +mfydwDu4Ra+XwThRcUpEHxSdHXE/kLM6MOacR8IOEWiDEZGnmTY3v6NcJ0Ha36S+8mai3eIRdLuc +a4cezbXoAiAAaZKx4rqFWBweUHmR7/Mi3+0zIrekx9YMxHW0ltZBaBJFQoLaY5eDoEmdX5TxEpn3 +mPo/fETUAHdF0ryqYJ9RSBJwa69CIqUMFVgctYju5L7JUJA1uJqSJZKAWcfxk/+IyDUj4+42P5uC +15/HuTKe4Xt4k2tWeX4ySdlHgONnfhDCmfPFYfw+CA0qhlx7jd55La9NOUbsIH0Ls6J1ujmwuMhZ +WRajrbc3LRfP7xHv+wm7cgmBrP2H46BUJteO96Blv1DfDKhh/ynC+qnE+mbV8qut+oTfyTgsK0qk +yCa9kym/84jTITs9FDRX6hNWF8Czrug/dtl7bSvjh4hcvBJ4ErgVIDWfx3lFP6FJ9zff6lfyLfbi +Z77wFCSKQ5vTLgSM3KvTS5T1Uou/Jf/3pIGJ1pp2NXxQ4Sbv2lqhXmo6DW3JKHkztRAZsRB5i2ai +tL17UPZ7chzzfYHBI8fp/gAoXAc2mToGxvyTXxAhieeYKcFxlm5zsyK+Eo0lcsjI7nsvqlDEqHFO +XYboU9kmMoW+IHdoqVN9Ex5nzPcJqCdg1a8spalMzc+jX/E9SpUHU8uKAGRR3lvRMLRpKV1/iChB +q0LdfhH6n1FdQ06+AR2Tx6SFNAxCgWmhovbNH4Kw9P4h0ZNFmk/UTIE69aXKWbOm86FmctVppH9+ +9HNyq/ptE4CAgWuoAewyBLy6g3CyHid0LyveKJB6+NEofninuV545b0j9U1d5+2jf9vPVbkRW+vc +kZo7Mo7GYFohFcbOSTHgHVprcFzaGChU4kFb0G1E6n0XRtYGuzBaWhahTW/DGRkTdryPiBFg4YP0 +1nzLno8oZURHZEQVQXSO2DXSQwbh05Sn4Uvz/AuWPjL14LYtWfEnSm0bXuNbsJoynw8tRx/SkXq7 +AEVjIkQHhbJHNU2v9pLz9aezCFsYjqwnPHB70Znurw3Z872/7sIuvgJptT6wpbsZbb4bJFtEXL9H +/Pkd4mm0Ca5KldPvx7nHS9/tTfXQK4MmsraLXON7wI/b47cgdpOm4/AAKUVbocYnl4fjviSlyjmK +/xxUvrFzNMllh2RM+5gf9qczxDijBU0DZMpB/KGmshfdMUWF/b5oqelHjTsYYtKAmhw+wDiQrjWp +xqQ/6igNDRF0Ujoz/ZjaX+ipd1OK4dR1P38wqT8oRh8R/3xaSK7c3z8culsurJpYtI4GMHUPGsB4 +LKONTXtvKXdDQQXvuDNHQEWpvN5JM8kVUXO8UbRymozlcxzbZTc84RMxT0SZJ2Imgt5UIkjjkKt+ +3rYbCWMIUWg5Hx70FR60ZA790f33GFZbjtT8O6xSJOHXk+9YaVuwQO814+v44jnnLtnnkxvzyINd +QcYycF82RK+/GSou7CpFAg6lJ3d9giS8j2c2+qR4Zh/Fa5jIoclhNv8WRLoHjjbtRdfDUL/n8Gfz +8Nit3g9PjaHCGewhSAX8FUOc9E73I1WP9TBRoYgwbb3iEzURDwKphAcpETANqNQOJZDjPGqB7sNV +I0R74Si76tdxNce9bWL4mdqEFZUqHpkfAtQ8IydgROtRxRgM9u9j6COJlK3qbeAiJ8VI7pZRteQz +Vc0LMNRkBoKiJG8p8Bth2Hc4tI4EerK7Y2ZPv9kn/XZ0cPvSKl1SEcjjXUBA1VlCpAki6GlfnMIC +GN9nBHbXFMfI3rwjGqM8U4UdoCKUjef9uIPm9FGKSrvWPb/Vfh8I5C6ilXPAaJc0dYJFEVVa/oYG +DjvmGq9P0BWxHGjkGouCXvELd3CI8guPdQ9JyLiD5DTd6PiloO72LPckXmU1qmudB3e6v/b1ysg9 +K/NDXviMqsFRANVCdRxgBfTurpoJhUiOYzOWCPQbSDH9sjurFdnGIQRJVgSBznnmMQzgSyCFQ+9M +f+J5WL2AyUoOH/VB9FTIcflTHjoi1GUBsqvIDYX/fH21nnC1cViucWOA5IBMVpXMzcMM/GIOgONe +0hvUPVQsNERhWJvSzgPIIwIINxe9vPQsohRfgRGlT7NRI1EAr4jo0upvjbOMUJ4Fdb8pUzvmIkbM +fBPwI/tzFYre89BBIUZ6NFFTLusD6bXnPCXqLTe1a1VZAwIkbK7zTexsTUAn+aqB26psVb7ujLSZ +fXknI3C94Fj9ZNj3WCSoWze5Z0+M5hUlgraoYQQRYTfwaNH4OmJvDVraO7L9OA6MV9uEDCTOrdaj +CHEAygwo7LqN3GdsM0ub4/3n9PJn5E+AX0hKP3+CYpH27GWmRScRHLQT+m+Y9X5EqA4GT7VFMjgp +x/co5DNpRjQV65q0eOfV60LPNASQKB9hbCMvfv0Nqu354M4HXz71rFY+LvDAr/nDn/MowOgdPTmT +nTUMX78+WGlF7UUVYaVfD9AMs0YJsl03IT8ueGHG7d7q1z47z9MLMZ2qHN9Rsrv+4jIX/0mpcdJT +HaLnfCdM6PwlQjgPIFFvpWKnOVr5orQna/HfADPswwFL9q90UZqUlaopHMgmanpCn4iQkPOMSEmj +3SbTHcDcNb6+rjsMCHml7/avDc+5Ihe/vArDnAG0yhWOahjzEBjB+ayjPPr9g7w13wngH3+Od+NR +wp8AHRSKosPZyAeQgfqI8D6O3Mfx9gM/ouDCu1xg3OfbMY7a6xP7B0mwyCTRxRshuaOe9aD/+wWj +oa6MuC/K//0zSiSV7Kn0z7zUASitMPgWlmUqxUASIMVFY6W/ulD1ALH297jV6TqsFvSDo8FIPXYL +5qp19B8a3h8RY8WIiGb1C1lOVHcXhYohuHTYE7k0Roy6UZR/RAAGXKYkG+DT/RP2aVPCzH1HQ+a4 +XrG1/Yvenuk6/pg7FV4klvqnqCtXZqNhRwS3iQjlIDmMLK4eAD1J9JDkcR2kP9zf+uv469U+JTGE +czFa/lyDqjnVAAmKV/w9S8U6J45NxpDdosoqQ2mkDta7KkDEo8LhMexupkOlhi6R+3b0OZ2TACkL +7Hs/i+pzfI9AJvTVQv7+oSQnFaf1mJjyw6yLqHMv1ZJrMpahbwy5UT3SA0MB24+AbCIt/lbUNQg/ +fEQp9nPrfkFnvu2Ipbjy5wc0I5+sUHvlfSUSvkV9SG0z3DcLQ4ArnI/7RZ9TgN1mefdQWWdONV++ +R3ytIZiFIQ3lFObjOHvfU3IKguvdwqkTSDiuoLvAmTFKyOXeiTWXe9+0cwJ0o2Y+pLcrUf+g00RA +UofkuCXaE6TtQ5Wf4myQCBXPiEB+g4hRvtamkunLzIiMIO07be6uHCa0xIFKUU4UOl9xSmyEAOv9 +QpU680scdwxb/K+R2H1ONFlwiiy7EXcwOA+oHtDgR8C7HZbi7z7gWfUSoHfyvE1Do3Q4Rkxt+swr +4N2hNc9oHVkyjipjciSF6MjYrQPzsIhVkLF9RqRsCNgODikKzz8cB0rno7YVk9nA+6Mbustk6KtD +G4qhFnhoKuAo5iGXYuWDxBk7ESIeqqLOwG+BR1l5xiJvAsePoGj4QbuGRH0ERI8NElqIgmLpKEjm +3EUIg+k/HZBaON37dl0tYqBqxDDbQuti/3mfx5+K9h5Qazy9QvW/REExYD7+VFgsOw== + + + Qr1fnYV6CrGq7ckPx+lHLil4n3HwvUtwLT33HyLKy3RFevK9K59RV9SYsRacz+Ffhy5eb4Wnr+Pn +i68jNC5/0zPkcJNreNGqnlv7rbnGW1bfmejxy1GwMkpE8gTEnOOAaQPlWa/YIkfKGAvQFkCe/lYE +2L6CrhSaGdq2v5zXZFlz68Roz52NlPz5JCNAT0R9HjVcwmM77rW/k2GQ53apyY8I/Xt4KFJiTRFX +usMBVqEbSY4ZcOcMivRu7zWNQu6tQ/dPEXi93irkXkhKvijSb1HjOAmwg0CLe9Hi9GdknJT7ODfw +kl9Bd54IkGPtMyJnClxW2YZXUPjbca7DR2S+qupvC0KKrKDYSimHgYqurjyj572/cIBfMYwS1BpR +TQeIHUWHkyhYAn97vs8T1phJbXfYl4bOgKlEy4fxHEQiJzKwpEsZnxEYeEw58equ/0Xr6HdRC7mL +fRw0WunqD1V1WQjYpllqFTitbs9CkTE1BWNe7l8lksw/1toBIUJZykNZlT3OFkOPHEDxUFaxngh6 +GJ05UvncaNNa/h5VSjwaOloU6keuWO+tmJDKLCAp6mqC0rNtuceL9HbMY3AwYnAwX23Ro5G1pqYS +8vDFljFOa/oxlQgXARu1xQDB2LeUVkd0/R+nwqtIkVTYX41cORdfIA/zQCBBRVsARGDLfky45EyK +SQzppzC+pf6iINRKeu/YTGzC1Cdvu5XzQ6oeLm0P6msvhdqzAAVZYRgiPFwVgZd71LA2QKN9X/BH +L7v9roU99S3iBTUFy0Fpw6P3PQp14EsO9aQQWQrmCnB4P0Cc0Cn2I3Aox30/ZMOnI7ur06pzLjaw ++rYM14CIBCrGiMy00B8UmzUkaDG4K0f1ucIFafPIGt/KgQGfWxHsnCJU9pr6NwH37kwZWlOrrwcZ +AGxgxH+IvPtr4vxk5P+LrPz/woNdv9Ga/kuivf/l3+//cv/2X/83v/0f//u/fLLy23/3P/zjP/5f +v/3X//2/+V//3T/909//5//4d//m//67//nf/Yf/+Hd/+sf/9P/+3T/+n3/3P/77//BP/9N//sf/ +5z/lpD//xf/29//p7//dP/39v/+7fYrffbnn6xv8gXjA/8L/BowGO0heAI0xsARITO5NSd7B+g1p +vGo7pdewzhWAip1cFfb5mypHuN8CLAGQ/hvFFbI0X//sXw2bhfuJnru4/lGyAAkAlfARC9S4FMF3 +8LQt/WwBmQoFLNtsdVYr/29RyoxQ5O4IoL9GBLOBGRxELHwLyuUxgKYZMU7eysIiJE+weI8QY5RU +YTRVLUvMFp+zuIMLUvjv7kLMwHlNGQSXXRoGJfeZLoAFUzN8xwAldpqiGh8OMwiOGNEfI3ZaFsXa +MvHSPFStHINZzD4GlmVOZJ5z/Mi/8k8KcFcF2KKcqfvY/qPHSTERtwsyPP51elnz9LKAVRPRu8eg +F5MTjB7ZoAYVnfECulaqoXWFAF0rkSvdZ8Xz7/nUx2KNAwxIq3TniNGVFXoBV3CdKZ6WvzoY0JMg +69XcaD+blfRhxIJAFf59V8e96gtIdvdn1wILOoKQK9FhqggtHDHiquC2mv10v3uA4IidkCwpwAYz +I1pOjQvjWqaTOqTOJ65HtGEQZYFZFMg71x2O4XUqOaJQPSYKG4dEVbCIc5ek5zi6HNZIDfjnz8wH +Q78X1FVn/jRMDZp6Bw5mFIsximWiTxHe0qlSvdIchh0dv6DhojwEjwiraff5Bs4U0Kx8At4/S7EJ +LRYakA6FjwIfBE+Krp5C8GDI2U/7/kGB+eGzpNaKrKCBQOjd3n/nqMVm/0Vhrcrg199g2gUAYIhw +DMElgOpHJtYPEfj16Gxt72ic439E9XTWGT7u505VGjyGHnSVyHawHcRRQ7N6KNF0NzSZ/P6BJ6BM +Bij/8VdP0of9q2c2XUyHyLxQ7qX3WJ4YHwr3LXJ32v16u/ohrXL62KMnKlrbj29z/pzJ1KAJuaK1 +7VKjMZBfoQUKpvv7HRUxF6cik3J8nanhu0QvfBytscOk6Aw5CCAtJaDVFbyb+R8BzzSAhqu4ttU/ +Vb9zmiGuDsWdHhm4K7MJbOShu9laIA0al02bkEs0q1hQg++fIoZVG0/wrl7fW/I9irzyBihEI9Fe +Tg2sniaEyElLZ2YMHWCxqTR0q4d8TwLMtwDPM0fsKTTP4L3/fhTz+r3EDRrjrNFgPRjaFAQMk8d/ +j/jpIf6IooNWIrnELgEUGqk9WD4xMpBwzu+YwXyjySTE6GpvRFe+8U++JC2IftZ6qRwN4V60o55w +d/YTjQYhaBDlPfc6t6ht/tnLEIYKH9LfBSpimeAH7AEDJA7NH3prqvOOQi20v95l4SNmceijqaDK +eXWvIxfV1aYxyllGdeTe/XOxRDsHn9o/EkECL41sDSNggBMRcbHnuNnsiL0ornMmOjNEoZ5esp3B +1WQ7Y0P2gWEYzLv26C/Cto4EWRXwEDPHpXsZeM82PyNcREu8rZFaue+fjkNjXVh417FiqJPuNoTZ +WvIVlXySrlymPNqT/vkkRoHeA3tk8knaM26jMAE6VuLLw0A1TeoEvYbUCRLnH6dgb2YefYFmPe/C +hERkOFY03CEaYA0UDg0PNs+qrVaQwpSI8W2Fcz9DAjO/Qcl15p0LQnfZI3TVYqIvLO6QD46+nEtR +JaPpRwgAH9RFAuZahG2xHb0VXB4WgXiT3v1dN9tZN68cH1FOgH9MNM6ZnkCwvbgt4DyNL3YUY7iz +jg/ZF0ypEgGmgIi2wttABuBxvJeA2W/xgwq7e6LvpgpgUkvQYcPXEg5zOD9TfloAm4LVblqly92I +Nj8phNwZv9tyTeceHVcauDN4f++36tbxgTYeX153qCdYUVJUV84VO5AB6qrqyBPito5B+73d786I +xUk7SEs+vB/9zt2ypL6JGtrv/91CJnD33B8cXPrhPdU8tpBmRbGSu1F7VzVQvw6PAS1BzcSJXhg5 +fqXdQ5GJEFhX9uMKNpcIHjoihHS26DPoZJTvcdDvHcrQuSGHl1dQ6i/JXwJhv4YcYI3eIbcihe+3 +HUnF6nmJ//gd+dN5p2QasDXVysIdpTrVUpkYoiL1DycKX2H5CPeInB3zaSZJgIA8DE/9PgxymEYc +aT1mPwaA7OLfTfkGQ7qT1PAhYqz8dee6EaX6CmnunP343c/jd9/GiSDV3hFLcsb4mydfX8tJjr/O +ZJT1tWhtSWWhIlY5qSPLgSswi//JSO2vQOO94qDgpgLoQcnp7xEpUEpgi+1WSvCH48AuG3oHLr+v +WR7CNxhqtRldNvxfHo2KyU/mFcqalOs3Ld5RGo7SQWCiQdTNUBCAIjtOO4/2fiALcoswINlDtffO +EJHWt//ORse/j4OH4sP01eHSlpIoU61bdqx/nvplf3SNBDBUxSOtxQkSq0s+12bDX8EOyKDwVciu +iHnKV60CfHfU7SCa4QAYFAaaBQwPe6Uv4gDz7+i720neF1LDdE1HX1ADE+8oK3N+0AZQGDS9Qste +PdAR+9/G5JVhIEMCTcmAqFH9fEbgCuvsBQLSOdNHVD1w+a7K/K2hFhaTIKm6FnQstFB+cfGDeurO +V+XnIR5QPiPym2LWyg5dEX77PA7O9iy2jJ48TEnStY/ZkZz7CAD29t6Kj8/G3wTD1IWVq1kG4w0S +ZFXnaTjQ0YLW0RZmaBq53tU1OYeNgwFRgjro503V5Zzf+3nLUbTnq0dt/96bDrMkzsLV68q4jFMW +TyPkr71nsW3YIXw776vHKfFWAMzjwEZ5sHoRPUMEnQ0inpUzNblGe4+xpaI0AqOUGzvek0m1eh5M +wOgKtHAXpiJqyv/TPJ6as6LWRIOHqyySYGgU+UOEbHYaYXCP3pztM+qJ6jFo43nuANxSvdLBMHux +nP1d+NZV2yF6TO4f4FDxIyKrVgtHuAEGHc8Px7kvxT8ebQcV1lmR5O/wwscPAQ4+eT2RBjgUgh+i +oOwxA6SFwoKM7RQI1MZOenThgFejz1x4fsYMDhyCOO5eZODsqH86x5e30Pppe8M7y2OwH1qeC1BH +LEtYWImS+HhQ7ibMQ2eUdaw1vTcjaaknAuSNxgdaMZQEtbxzvY7E0YjHStXliDcmo8oM5pA/p9n+ +xA0arnHRHUBT9UcD8sq8wDMBxNV+DA37coZdigQPZahS3VypboB7BgHjuJMGd1qBIRHuK6phDhNh +f3NViOrsvZd0GqDRT6a8Vb0oOF9XgNEoRfP5eN4IF7qKkMwwIr7NMMGqYJT95vavw9Oq58+dpPEd +aHf1GoyjASL+m3RdI/TViO94voGlDodgzvShDpo9HtBq17SoWXmUow/d9YG0yFIGvDLypLV3kaI4 +cAN/Ean6fz0XeisRCNDghiFI9wY88top2aXHOyyBkawJDIbeiIVGxbKfYME+dhUKZgGaurr2F9Cd +mbRG8vzema+lP+ql9gZG9L0Jwzls1x3Rvpgz13FBhaY38sU1QSEIbWz97LXI1Hb1SYT79sUUHubM +k6qEiFWSqdkB07j4dXwlKse3skaatCp4fCkDzTd4sJMkot8KHqNqX41Q9f5CXPTkkChGE1HKeMnd +1B4oXjVQStFvFJePbG6YOU3zHKx1O8mvFu90K7F4X7AVVndoTolsg3dX1LXN9wT3of4g5tmTqZX0 +IHmcuieoGha1WAV+ZAjOktib9gXt3EYGyJNeKYKm7WWYMazaSRRRqOoaleki5vJUOzPUE8dZ1b22 +HWlesuyaAGpwArRphxxI0x4Y9vh1mmNdK4GIVwDHED9wwY1RaXaskfOj1JPfIQMt5gGRIL3m1zMV +lQDI9nfeJzN6Ohu+uaRm9DDhSHdRMD3mPD21/Q8RAKPr/LoTv/8QvSfcE1oeqRnfBGZ6Q/NflE3A +ALL4Mq6Gk2SL+4KLKvz4W4Tn6Uu64UMOOlr74Tgg9lGDL4BOZoCdQt0aKcORPgOTjCbIo1Ptd9Si +9W0v2kw9SJVoBXwfHYVGO6RGsCoFYtUiT38awfkwXEH9wwNzVI91hZYu3yMyaaXSL8rVarDweRyE +Yrz7+7UYM1Y5+xpRbjfNUD8jvqPN38fr91GqLWkjC8TqiQWzbtUY01yRHBR2SpXODtKP9zHMlgww +fh+Q4vqJj8B+FxVl/DgK8P8uXx4xrHYgNcomN8ctHwEMh7VrH3KJznm+Rwnd8oXaK58SdYvBVkzv +Obz+ayGiOiEpTtHaZ8T7tN12U+i53OWH44y4WsDZu1FUY8NzyrG3nFtS8Ahs8lHW50j/B/7Dq3Gk +VI1iFZIPylNLh0sEEUo3rC9E8H47BktAXL7RJKYo3wFOLdlwqmi3vfbBbmGhRjP9PZHTz6Kt1kqU +jJKGXvXwOEg/UBDh3J2IKDTeF1KBRJiQUpqW85OSOLUoPOVMRUYHvns73+lZUayJaR7S+hgI1uAy +WvbC6OOIraOyuWWeh03Tad52zai+BeQmHSD4xx93PSa05rxLEvTYRO93RhroZ8QVcw== + + + VjBb611xvgd9QyHaErQRxrq0sjQnFRkYfPAr0Y7ZP2InsKt+/zzXaogwY7jUx1F1/t0xnsw/Lq95 +vml389hPeuk/RszMETvZyNc9+R6F7q7Ay/2EPne+7WPzbCd9Ipn66d40taxWOorVC4JISf2MeF/N +tAfRDq7jh+PwhCPuXcg0KBMg4vzwz9RVVS4YFhtvn/N71HVsmNBLL7bv2nn8hhydnUFckQRCDXG5 +UwDIZ/XY/5A217eIXLIVZRUITSTen8fRqlq5cQZj/aRj46Rj/FRdz+/jrv6Clq83tahSlp4jppoP +g3VhOYxXvAp6KPKplowJaeCyKkEbYYGuWWM5x8i4lpHD83Umabd2HklBoDanoWJrfH+O4ygbxgPZ +jc/tDHbkha64zUOq9ghQlFWkfRt/N6BH8hEKHdDE+KlxT3axTgK7//zSKRcX8odRTTFpmYAIG0ru +OqJH+bIr3/kZkWyjyEUlnaE1+MNxMNdM6hkgfaH1B2wVXnc3F/8esUq0CbRfa+0rhf0W1SNCOTDh +vpMK01qht2UlNeKKxy8Bgc4vmf7WdbyzBmveK0nF703WdmMnmiiB+RW3j+VxRjzisWyOmLBIAsza +nzTVHjLjoXBr+zqumwF/RfsRYSs7bxWCXf6a19cTT7/eTGto6Ct1boU/nVuB+joRNFt2xJcGHPm5 +3QB9xFZuOh27HYXh65RbH9UtK6HHobnISsSHpyoY3yMApNGY2DsfyO2c6TOqxOdy4NBwpwBjNkAS +SrL8hY2k0HHYShMD/4X3g6/H9h448zAJ/ou/cnRF7bArBfrAfC3L6YGuPhMBBaQog3YKTauCH58O +617M0P4xk7wvDXfBRF32gldJW2W8VmOjKvPHosxa8xvT4fRZQYOCtgCSxJfcKcJjK/dbwJ/fYZqg +EAqX0X84zK6SHU3b5KDxddVMvChaVGj6iPhpT/wIQlKFsoe5QpnHYopu/t76Ue/QSyS+uxMIX+Qx +MUVELGxokYz9I7zRNjJt9Npd8x0m8EoU6VXtkX7HfhV5TIXUoBIJMAWjLgmORqjjhpqeIBZUzjWx +oxJ/TzlWT4vmlvHvbFcte0CHEhaZE4Mscu7zfH3wz7aQWtZu1rT26zNqDjJ+WDzLsrPOlEMAWycz +hftAIhtksx7Hqa9+ER9GoVOQ0/nw1nIGfnf+3CYZ2kx0etu7lBeJNiein4jneAdAIiGCgvM9k8op +LXr2sa5p3O5dP7Unx/FO7ojaj43Ooe62aXuPiCK/ZxcwIxGaOPYjUpkzcXrWnsb8fRoVJnHZi4Fe +pEXlUyKeFqV+DGX498YdBiRWVuzEruNHkzrzSZ1px1/5cJk0ykZJ8k77dKoY7QOSR3Hh1Rw7BAds +XX3FQHHV89wnvPpftO5D/lrpBPNt4M2B3t8Xi5b+Xpp6Am69zDQqNMJlAqrOCnpt0gbZ13e9uqyS +4ugwdBGTiVJcdUfdhzTHgs3n8woaOP4Az60UvqeJh8J+aa9QBpW2aE8S98w6ivQoxpYXeRiJWSpo +3A5LLA5uoPL7kVjVKzgj9b7XVlAEUl0xRwLCBx4n15hdsaFjW86daREi3OsfgBJfXZWZmQaLoqSk +CZsV/ZjhcW2HAWJQqP4zYoXjAZrgOWzPzyisbCCt7IUKnApPUACdPJNqVN2ZcmB057xulqSrMDKs +v/AJK5f4bWRSzzM8M/eDx2gXCGdlTsQsR2OfvZkMaOJtLxb0g4HFuDKyIdBHxdXVTYofCP7Vaaj4 +zSr7ID8JM2+hlOgHGRNxtl1VMsXgcyU6WqEreidiZOo6JAipohr3WBynch5RqPtn1MOXJwqtCqLi +Vum3OeazuSCltXVGsgxX+QueQ/6CzsP+9yi17GNCtc1hr8NeBtKwAlWJKEhH+6p7ixAuwY57DaU0 +Rkaf+7lhxwpTHH1HbZO82CAjmfPbYT5nwo9o3udDtDpwMdfMt6YFSlJWKXQZcyNshJ6YjaHVAorB +FwKUnF+BcWxlPnleyxWXmqfqwhpZsjw6o+2b++REsNg4kSZRT0hXfjV6XtgCuZSqOGL93iT2vHfA +PHH/arn5T0S+oESLv1+nalXWY/7FBxOArr7NXUBUhjPnw/HErKdhMFhyPx8RHDvF0BZpALyGS4aM ++xWskMvI9w/SkD/KmN8/ZHNlW/7OcX///T4smv3yrZep9H4GaV007nNYv4hNiPDo2pT52zUurbBa +EOyAGUmnfO8550X+FpF7diu79pDroo77eRxvPVANXLnZ1HdqJwhGXb/5UwD6BC1G9a84wGcUDtV0 +/JtYlHjBk95HmTCOzbZHRWj6tO80+M7dzApaaMPPX1d9VQHiTQ453geaamIU4kPdAgpCJWDUEwEa +rin9wOcK+taUU36sXXjRWPPrNGYxO4jxU76MO9hOdr0RHwDsCSqSxR0V45UTxTpU67c4QsPWIGK8 +RFGibNjRl/KWI9hkV6AG3ssVi0ewdLoM+6z0yWPyQvQzhNolqPvt94jcmu9p28dx5gjksEEvHn4V +Rmn7qyAtMz8DfAR6HoHy9fp+C6I+NGHdRcMY59vO8235ByaG4zoTQ+VBcQXg2tKDfdpnxJ8PBC4+ +wxCbfwgSDSUeG6pBdBHEGWE2iLycbrqMQuCbHyGLDyNU4Eq258fh4gCCmqK8GBjW0wVXOoTp7k8R +iue2I557/I8+o/D/GQczhT5XiQmhKK8ngH5rmUrJvFxPJmgMiCBXf2/yCBVpBz1I8hql5j7yH1eU +xlB6hxfQqvtkDdS64oqhoOUINH1HqGlBRJRjm0q+X2dyn8RbUrE2yFkkkdX19fE4aA8QMZzBSYWX +/JDKyTM9qp7hFBfpWAafRFxzvfCmUGwflDBWdMW8bShSW81c6eHvzAzpaAup45mNVuXzQ0RdoWeW +fW3q+UWfURg0KznocrJcbPVpoSWogfLOBOyVz+jXKs6mvNn3iD+fZEk58mYVUn84zi6MIX+CJND6 +R3lItSMBdolA/R6BJHj/wiF8+6wEeIsIZBxFuzIjKMb4zIBsPIhvXmTfEefLDYwfD/O3gK+VBL4K +eDu+9sdRkIiRpcPKN6J6Tp31QOTEOcfdZUgAovHVzrXuudavtzhRUJeJksNPFErCREVnigias0RI +wem0QIoR3eedM5nTPND1lhGmrLqvvrfG3W6e3Y63op92YWmqGHocDABAyj0Kc8qWBH3e7KcaMX0u +6XTOIE0vRrccox90NNcmZ9KcYdjIWAqcIjpLJgt0ztQWh/eg6eU37US82KT8HlDXuSpQc46A1UeQ +wryABC/kL7kw9ykBLhunRyB6RSBabMd9YAD74Vy9ts+I1BpHAJTFYan79/04I3xjZKD0owBwj2Ul +ZRRJ8gNqZVxx65ZOgg5Mfetk7KXA5O3i+hJGW+YhIDxP4Ij9oLzJ+vp9nNRvPVOm5CXsxHWgk5p0 +y1uZpxvFX9dQYhauWKBk9M9kIkaPDFG2fmSrLUhBwGit16LC37FMf56PgOCd5sGT8dJf6/MoGl+X +GF9XrWVKzkvGJEDqI+AO1nvXtOOeL67qe1SNj+JzOm0CrYTzgzRAJ0veE9klTb6mSy9CdIDlCjVc +IsoXkq4p2sCvXWTzfugsEKXumuthc60zsS7lSJdL7WJRSkAaA6D/wx4Ks4tiaX2dR+cCgoZfs4ej +BiCjtHSr1ImFxYZ0MhFxG5mPZDDvDEBr7szTcgxbFAUB/tM/tf+DK24/lFrVUCFDyM5ob5sPWOQd +x5I4Z+zyDBvDHyJ2hvEmdh8f8nzNWCELiyBd14QCjxMqEzxOdMzFzsaIi+S8f0bkBDN5YXty8X44 +zn7NwAXvGh/fPb+fECr9LZ60dQ6vc5qLfaDlfUHaOvg2SBXj+Yz62/N9MkzcuaTL3zv43Rfgir8y +Y/2YbE5XHBR/1PC+2dqfnyJagEcYP/XygoS/R40rso4ocYGuRG1WcsdAYGN9ytiyYUNoguC9EDf4 +UeiWlKbQ98GWRGedD5nccnij1Ub6dIR23Q5o137xyg8R3zflNKq/R6EsKZeBVm4WhW725xjgDnfA +Cm5fnv6ka5I6QauLEnn8o4oqn67lXtDviFkXMDRyKPo9IBQaMt3oUhGA5YLchJ0rBOdwxwlkLwi3 +wodK41iYBN31gkRMHgtFBVUGsm7QTXYNgbGIJ3qGkt9w46diXOqq7C1LDuq/PTPs+LmQJF/Z9ARG +MbrFqha9arAe6FU3/DIpAEL+GcwVkSXGxevz3zOlmeliXFSPP0UhNuCw9sEJrkUOLHbsCL1g//cR +AbqFQTgIhVcP4iOoR3BOnXANJpkuB2CLViDfTL7ghbOI0OujXti7/bpcZ5R+NJbZNU8ZB9isC/YA +86lLCOU5LiG9tkioRIVy4sP6/PbHKL8XDyjf/5P1XmCh/yXdvB0zD9JCuDTaEVGFYz13o9D7DydK +DBBR8UB7bQ95m3sSeHGDppcq1s+wiAvSxccJKULKKCrUHMM2KK29dyjD8mJayiy5xeDsYP0Xoqyk +XsCtmSH1yVgaVm6NT0LzreiHW05HHslz9WGBeKMAcR3MpFFHtNb1bOdEFyN+zQ+BIGN+yDDJIpWb +QJGqivmOoPrhOZ9Dkf/jV2oZe/06ATKaRHUBz0SFOjiLPkV9aBZLhIo8fJU79ouDwfD+d+Rp8gN0 +AhgQvM9wlBSICgPPhiGTnbehOc+6yRZbby/GoSlxoY6SOpjoU/Wk+Fc5+2hzb+jHtRngC9YoAF8s +SgWmdOUr9iodE8iqhxCDbhZaZGWQjeLF6a7gj3a5Ox5PoSOcr+md1JUzWJzAbhgr7p/2lLg1gQXZ +S0wgjU0pKP9duJiyt1NQZYAAVNdCITD8Yzmstq6/RruyIi4WpZqrDvTKP1eLvir45QeMvfhApuNV +VQXwA4f9BSjh/DUy9jD9NXcTpZSvZZdp38FdtvUTMdWef3RfQgZQbTluajsRagLvE7w5lTBbEi9G +OoDuKU00Si4gj+C8qWEyxVzg0xpWIG0G2tJM3vBKEuk6Zli3+02ab43OaFyy9E4zSvbTkcLsQgXq +Cv7AmdX+kpcQELQTqcEv6O08QYwgwDbtx2cIWbix6/plu6QNAGs687pr4oCnfdYEunjxhqpk3zOr +lvIEh4b2OiX5/U7LF8TM97CH/7RvWsxrxtRhe/+6OYAfeIF1K6u6sAphXDcP3k4x9JpgeO1vh/Ah +yJF52Dh24l/4DHfBCwrVSsxkFHAxZdJoqwRGiOQYWl1G0Chm7CTkaSFacYnxuDS55DzI7zn+eV9l +kCDichuM3GKUhEHT+pYzUTYR0YNvW8HIX7J7TgQVM8cQ07fCDokT2Po60RNVw4HvkBcmy/hV6oEy +2yG66LDz4LT8INQ7wf1xw80VLnOMwOhCmGTu9mKy0ewDH78vN6hBEYZ2BYpM/X2nmU0CSOM55WXe +mYF/UfCIvtANurxlUtOsa3B53WWpLq97Qzk7dTvmPXvlAkHVmCeQ0e7s9YZsx5m4aQ== + + + nIl8JRdquLvgClV86m6wtkiqj4CtwUcAtp79F8jcRuz19pnW6wQLXVcEdgmDmoZy5TjAP1jN7xnO +A/q7Kr8DjKWovfDfLWe5vW89EIDPponDy60bCHMadlx8A2A9XJgSFZEtyjTyZvL2/7OHaWE/XwLf +R/A1euH1eyhMgL6qOK8FMDfHActohF9cO11+2mI4d+dM/tb97o+XRYFhrpnIXkPlKvt9WMcxgblz +nOBKEFwZweLYtr+QOuPKE8GthcXPUG9/gDzBOUHPMJPQxSWHVuirw/CQlwI7aPZRurnx/3U03hQQ +vhQ73/t+lr8kjg/964OIiw8P/1aFuCLwegn3tUEQ8rViawhDcIuhgYCw3qtYjVPU0E7XDbUdWjKv +PllR+TK+Me/pyXu03qjrdKEYpp7MyK3U3MnSd8UMq1Dkr1Qk/3qW9uZ9P8o7od+5993/v/JOh9Uu +JFUo777Rax7iPG1QsBnrZIajaPQLdrj102GR138fUtG+K3upeELUQs8Doha2afu5iZRgHIXPi9YP +tpMxAA1+PqQHhqCH+dmkAcHSPVTxSIRpKNKTwvR7kBAXDOTrAKfhdaByBEPrPVO2P5BgIo3PtNF2 +8jxnCuBxF8x8F3hw0F+73NGcab00OrsoGDGe+eAd12yznxVMdagIIOd6uAJKESFEVGskO/UERnaT +4XGY/I/k+P1SRZBXCkvfyfh1n6Wjt8zI97V1qu7jhUo/FBPdfa4gL0v06vwqSubR5Ij5+DzCA3tT +XFRu3zlXyc3n4f8DGlSE/87Gy09SfUNTKlJAlfoPeVZXeZSyWBSIwHAPGww7pzsilJgaR6GcCUpM +vobeuhSrguwUw3z8opodEhG4yM6yZcC3MzblKwCeV9xTucydZc8XLtfRYkBXRXjI0ViGa4nGclO5 +oKVhUbgZPSxftYT6hQNq++2P348//RXfSXFEj88whXqxBIe/oB42raN/OFG3VFLg6pL/9nk041Wd +PYClCPZhhQTwmeOABN4RUx1MIE3C4ArJzRlgN43IQjH88zlTWkeKoAWqwDyXKHKDHIeKoVsBBQsh +uLQq5h6IlfPqbnt7GSH5GCbeC220JSYwBkpjiXub0Kc6seUOdptJMiuvjq1gFJy/ddRERfRUEH7h +7N+Hs/8qeY0D2Br2QK1jIho10ENOU9m+xt6092O4khU9edPO848HQTFfvZKvruvVMfJ9RBVrR91+ +C6Jo6cH/FjTotoHCSzwpjFDn5UK0yEbD2TKIMIcoxyUXc46n/joRJVsXt5mvo8InfjF95ET1es2l +SsylaskvMZnoyB9SZgs2oqOx78QqvxjUsEwhuocBcx8Q2q4B4/9h076laU8WChqOySUCt7EROD6t +tP9iE9Vfy2TgHuls9r3cDV9Bu+57Ybvug9GzzaxbZ8/LTlkAQMPr3piQcQv7ewsV2T7zopbLs1Pb +nRoNG5XHw3iy5jteiSDeBe4gx1Eso+y7TCZBDxK9JNAe7AGh5rCqI+Ywn/dM5N7gIp47FsXMwGiO +lEDuAhzi8jaqzzqPp1YkBRkIBbo0BMbszPw5dSvrGKp04z3RpS0S8ARfIF3MJgkILbEStXvboU2T +8BPhCB6XHqeT/KT0PeR0o1ZXn/Vr/Pk8CrmzySdKJZDKS9P8c9EddBz7qa7taezMjkeOz2uaGkDz +9It8kSdglEVhVXb7kkKYNY1CWCAIERCXG3in8/VFS8wDh+Ss/fwskgA6ne1do/aPVyKUZYAm6l46 +6QtpCuK4C8G1cUg8QvWYKfKNmCne7Ix9BQOGfth4ATNDJW1G4BjYe3LUIFC5GdV17Mm0Y1+kOnxQ +n4Omor3JiIebNGKV+KZvHFfS3/69ca1jHATEsmDaNvKAqveCuTIdVgYUsSJ8cGIKNMf0dSerwwuD +P+ljBA6A74VpL/d8xLgLYAbFRdFJQeRVp9eOZtJ8pYlYWfEkdCqHbv/MsLmnLzRAhxzU5FJw/ZF0 +2aNjdqSOWGUfZ+KRd+y4H+VrkuY5EGiRXHL/3V9zSIVBu0BjPWQQv2j2OFvf+vfGbxqoNckPtY0d +b+pgobU8ASNoR3u11SbsFA2mkgzSFSaqoHeEWtMGeXn2g4kjEJmjNMatlIsBPFSs3n3qyP223/IS +aRFVoXkyBNSrUvgc5TGVXJBRYL4LTXx83RpnzYhasTKou/mqXQl53eVvnTGYSjtP1YVX4DPGU+9E +S/T/daStSlQ869EWsF3LE0B56QcQhgHDx6nmiMLSrKXX43ExQahuxi9q9cUlkyO3AJsU3995xd4+ +h6Ijds8QgBJEL8Yk+cG/ntH8NWsaxApMcbvkmhLBoCUdfOA4mvwJDYaBIs8d7wMY25EfhwT9RJzF +osDrqYw2jWQmyviJRTdEfGS/6Zr1I6YwFY4ATZTrRlTn69z0URIV8sF9yxZRw0TyE7MUhUTKoVPT +gbujGyIXB/FxFdXLaW0gUlZfmRA8dS/FO/crwSJClF94R7H4GfE4caxlepzr6JPfkA+OgLrjDFCD +7T5iGEuBiH69q0ppGs4iWq49jYKZXk1SAAZLsMUZ2KBDUVc8K0THU0mr0YEFneLw4zheLWwyz9OM +dhwg1U7YfAlif6HmbcHgP1QUWR4lzJdjbGRefdhCK0VWHmbxPh6Yka/hsvM5GS3DIPUZY2ETQSSV +JyjgrgisIipigNzPdhxJKBmACxmhqPxEF7J/nccxf4dDcJ+ooRT+tc5hRMT0cmySrkMY4es6OlLp +XVkkO1KJMIPbj2X5OtHLr78gJ0RMKhnrol1WnTe78NO6YiKndgGJNNoFYjqh9Vy8L7ueJ09CeOAL +CjmvcGh0ddhBe+l0mjZwDY9zJUn5g7IBPeYiQ4Xc6TIJiWkgUujlFwcPCG30SF49dug7Akl6tfDE +3lVZjF05d1m5z2GS7kug8ohd+BFRHxDwSAPtv85avr+l3VQKt/BF2P4zHo1uSDusDqS/e/ZzBI8s +G9giEC8DCa6E15vo0wwfAvn23t+Paq3jO2B7V2DnhSkSNfHObFWKEo9O+5OKaD+uaoXtHWV8XQ5m ++Sv0cuUgScX6caWYVxjHvkXU9csSYucCzi2vIKIkObzKYPU0JlCmGUDkSI+0SJtUKOPY1lXN4jAS +8BnAuQFuAvm66B3pwG2iGdyyicLtcabf/kIkWTWpvR1OjQiX81LwR3Km2XwUWBSYpdo07iVPtAHM +UAbMkNBPugorqBCsr+Nnr6Rxv1LcFrWSEQps2duh9+AiN4S50QoC1UYrSANN8Ew09cEzpfXxvByk +9bzYYrgjEiKmAqQfQVyPx9JlJ0eK+cixV5wJbY8TYaqOTmdJU+pwOdDMe08U32+jjrZZth/NJ+c5 +Uf6aNc5OkIj+Ps+LjE9Omcf7CesHNKG+eDMr84hGm/l0lJ5YmGEHOuP8taS47dMe00fXpP4c8TAW +thkCk4UTCR103dySV/do35d7BUASyQMrnTxtTWHxWV3IVhxR2jPzUMNE54a2KFmFACSljt7dGd+S +VTR2tb2ZN5DmRLlnOVaZefZNaMhyXENp8AprBws1jpeZXndP1AlYLn8BVubRPwewNtIe3M+xS8x4 +DkUvTzsqcgfzZf9wJ814X3LFlPnYV+wO8f84FvJvvb0P8UpJuV/7Ehmv58g8AQtg17mPfidM065t +xIhoD7K2vrAA4pX060fCYK8To/6qe10+9iWzqdzWrTUaxw0prtIjifmfuXxTB2pZrYdvsddS7K79 +siZzPRDFt0HjXKxF61hlK33wGnadEeiQzTNOn5+zlhJFqyhqh/arU+l81bzLUQwz6e2+3BGlkgtU +/WtlPuh+CobXOUi5if1MgI6o57qgnKWELrnHsRTxQ4raLnQuUX3QxR0QPY6Ani3bznr+GBG5ioFm +yTIi0m00y2oiIjOxl58x1teZLlAjqN/ZbeSbu04NHvtscAJsOrrs7fy0en5aDYF1ab26H795PGSU +8SWf/SrXdxIg8J1H0ewGkRdNs1BIYOx+BdDPjgFR+zmQHegaNw2OskKa6Oj73K8+dk+HmerFVWPf +mljuDNXJ4hl2qX0Juv02Y4y51K6jqVbY6SRCORKY0bQT+7+fuPalJXmdiary0awWiKliV7jfhEvi +JgkdOXKHrfLkOOI/8Dbwx5OQq9a1QGbdSS5NrQfmOe+lGmczZVs/KoP6G3R8l05inyu8SqTndkSs +09CgVXhznJxrQRiOiFzylIGG5teJHEaTyRYT+3HmIGBJh0dR8LpjCfXkPFF3Gupqnwjy0l2vSNDT +P0cdPyzi+q8Tadu1DlsZ+jLcS6dqvN/XOwchhZhBD43bA9PDLVFUB7SDojpFNilM2rxrr8lnF5FD +r+y3ZjvNNB58FDLaCHMhGj5UxKaIidgT0nG3tPn49dAuYUVBEJg/6V1VmHOCvcwIykY2ODir45NI +bZRfghHhI3x/JWNOqlXGtVKmCQKigFJlk0FBurCp8k0EVftnwaDedLNrsT/1VWwRBkrZ+BxGNaCa +GO5kTJiUup6Uuq3DK13hlbaX3bm/T9YWemzQi5l5QlGGpHcf5OdBbDKaCcbOEkiJCJ7Qcb+r8cXc +3HaQ/YP95a/WfpEu58k13QfXwc5Xt6kS9hYDJ158awA6GdKrJk298GY0sqPYv463lJwgVfdW3cdc +6c2pv4OJ8p3mmTUtwP6wd2qet/071339f6yd3ar1SnaeryD3sA6dHOyo/lTSYbIJweCQkJPERxvT +dsAQu43TMeTuU8/zlub69pqrvWloN276WxpT0tQsVY0a4/1JNdJ+GeVPoEpCGh7IKrWKwwnFYn64 +fOKML+BbuWKI6hR3WMEwZHYQdCtZobMDO5qSPsGDnCF9QmKu6wt7W22XhACWbVuMqLIX9DCGpY58 +V/FVt8hNd2wYtOMg5g1/G8XCt6Kmpqhzy0sbMZ8Iis2o8Vx1R8hCoe537QjKU0Qc9+eVyL2YanDS +JOrStv7QgCrlm0NwbD+3iYTS3NW2/q7vhADSR6SigU/lZlmRXxeiUE9haNj7B+R65TzixVHVc+t0 +K/tkc1uI5xqiDrvriL47xXe5w8xmQpcPO5t7MJ3bUwWbqmN7O9Roi19addwb1w6dDxSVmHzRsFW1 +JqjNgIiCyQqpRvB2YQf85D5ESb89UQovRoV3wYvI1u7evH82lp3OBIkf2QVWZFoBrIdEAuyB53XG +80LtiLXTqyWfCoRLgZNsUQVyry3qjH/CDKADfZLizrcmbdIt+LmAPYDuMvPaCzeZGWsavXqwyEp8 +ozV6SyedGxvgGDvfod7ssS934SRBx3xzp/AnYYEGbozsSH2sMkrIsZkemqKe/F3QK7qnaL6yxdN8 +Y2oIZH815WJoeu0UN0SNqTtO1nZjRHZczlzBChds8FECZq4YvDKEab6QGAuY92scKe4g+XdvpomV +9WJTug6ZNvw0rBWVSs35HRyUei9j7zx97J1CLuMVpNvYrD0I6XT7jkfcCj9ideCfJA== + + + HNoe0zy0PdqGBPRN1rOoC0T0OT/7mGsnGOrsbYsHDrqgcbAo0npNqQcwaKyMrsUebIkR/pmmJH9e +E0jUXcdp0wAw5IM9pXEgVLAreQ0SW8jsmgEnd2mbXIWsNaymy8TGd64X2I80ZIrFWCjzFnaxgshr +en9lnEQpL0NZTfHKuX0n13dfP97peaK1N5Szi1GbjeI7SLUVoBT6CqCrkADKhgS8mH70HiOz39y8 +CK8KG6Cho+FwEVmgd0h4Zta6VgSvYCJQhiq64eRCzwJtMxB2G962Y4b1rOhjjRk463+jJMOLkiZy +n1oWhKblDFfqOCI/ez8scVqmTGN08o7Yj6Ahi9LLoVAF4F4EGCue3uKN72DyKhtpMgwojJmiehSv +qF9RwaV+hahAqk/XwzXdinfX8VT0dZr0SqF/Dq0OXY4bolYr6BSSoj+S3ihr1dpM79O6zHrnjudR +oYxNa4b5Gr1zKIrRIsEzvWTqsFFcGFI9fTzlAlm5j5gxDLWC+FJs32nOgr6iOTsfPU52RQ7BS3dE +GSC+mFDvdBnYjkwkrMCiABDY+K0q9WcdBGIGhW+mLdGQn9g/zv14HVBnylu4cpNmxzEWJg+qnSTs +SDdG9/CqYono8yzoGkaEX/2sEhyMkDAy2ZH59JdtKpxFYOgSGkZTa4agLwmu0WH//uwiJvh9rnK/ +LpOFhO3K1TbH+9wc7xaMvPrPMEjr1gFI/hUBEgKEJCMAcu8LIcFKBNvvfaEenZ3KUJ7pRyq3RfPf +duax99RV88nbQZjUSqKXi0nuhMrqGeZyCbfZqXFfaCvq1hZ5kRRgRwqw89hPZqg3QtYT6n7OM1ws +YmIGNwTHV6kmYDNcPfT22iPsDDKwgOsiM2XnwTutOg/LCumHSgDnpowfYDeqTkaHXBZcBGAwnVWX +82f9M+nBZS0+nRQ2LvtdBXwnq7awE5DMJsuSgpWnhyId2M1OuDlFlZMJAFVOJkivJ5OK0Qbq4xYa +R4oW2tCdYUCr+bwS7BfHLIk7lL8tf+EWlcRonim2KmHTD+UKP9d05g3cacbm0kUhv1yBn681XjpS +w9EuXFF34g2RfHq4yNryIxVM8SiRzRZPcJb5z6W2xFlwtr0NMQMNudua4dyoZMSojpbzOl1xIHSf +rPXP6UKzWF8/BhotaXoDu3psIrPqpuhx5cJTfYkD0ZOSgH1H5hbrABKF+/xd8162AIdZ/7mbWaI3 +OP84dHVFIvSUlL52cu6q2+DNbiFT8N7Yp2EiGM82c6VPxw/gSGc/ySZ8X2qylImoyTLPqt6NEelB +r88xM+K10ZBkI+DepAlaXHeKi+6L29r8tP1WkLuClEF2my6oNGm2+mtHvkHUAInUEWfxUIrokgh1 +ZBFGornYS7+CvAd6N196gWNj0x+ZMttEV9pEAnjOO3XwAxTDmfO4laTbDmoZEDU4hAO44QiMTUo2 +X79s4jaMhjlEVZ+HFBtQNWf0hKD8BMEpC2RNFafulSz3Ev4HrmJ+JRC2WGd3cyk0KXS5L7A3+out +IcIHB+ppP/1I3buRB5fIpkd1klcqAY2mMtIWNXrl0huPpnVvAnQOKVhf/0AVUPyY2ioL29SMlJE2 +tTMLvh209hrul5ilI0JmrWymNVe6QzcYcrHp4h3qNAFof+ghV/AGa06bqtTwMKFRNWkrI4qeTGFr +NaOu6gyY14MUDZIv0oJDUdHtxdWT5Taw9fORc92cg3LsLdm5VVAbQAKZL9dWDdYf8PLHFkIPWKop +5rtpwbAzh9TAL1ovryuJ+lxXiiXnneri2spNioltbN+rA5rEGVLVOL5B5LEAKdJOoxPM+s97vIWm +sVLisfX7hxkG2R1f5dzYEuRxpBQeW1ATJxWx8M2pTEY+JT4Y+YznhyUgffNAf1Chq/kQSE1TwnRh +q1eY4Uvo+VtY445DHgyULnOEWToultF4W+P7eH4U5B6F969J4KyBtgf4JWvh9rd1JT8w2Oqx4Io/ +5WlJWcB+3j7MyMEzg7AWA3ZimbSv5MIKyhjhLXn+10aoTTaxYVJE/t6cJTR53hjgelJegPrytCle +u7zc0Uh8zm/xVEn7bXamLWUR0hFNe7eQsLgOix57slkRGIAbse9Ao6xEhLS70rVHyJ9siLYpjTPR +eERFVD8sHMS3+r5P3jUQMpSAjbiSz1qkKYjdvKR1R/bhBetETeDWiywhoke2+4AAqBhx2RC+SxZp +FHXZW5BvyrTgyT1kIOYX0HG1xoWiIEwMAY++EHgQYD3BkAWkBpWFzSp3oqWoe4tHgHRuO4epjUao +7TSpWFhVomCWQQJi/VG530L/kJfvmEIj+D5ZBFGW4M5WhEJUtDyg/Py8F0Fdc4lC084oBjNR69f7 +q38TbpsFOVpyl4cOTNOY+iL0iny4RP7trrsi2H7FzCGct4OCgi+QJgPrb+C9Nu/ocLOvQij4dtDW ++NmtNyiZAmmZkiGi5e6PfmycA3ulJoZ15fxPFQDDKJJCZA2p+lHJvsYe+vg7HuDwQq5wtudNveVL +lwh7H3nxohxZ1G28kKbbE1/ZHoHr/1Q8Rom1qg25Ju0W9Gd2uWSJXAkgJ3VIZfS3ukq2bCsWZZTv +pZegpKfKRT9sQ2bOEFZCwZtlMqPSFAsIhhaYpcQeQitg30ufGmCbNAD7Rfc9FwAnwhOpID2fXtdx +RESjbfE/3YoqHpjHuWERdECC+v7rvYeValiRvLfxdW9OhLZ48acTQQKwJl0UkImh4UfPbP3kp+6+ +54Mk4+HtHcyM+0jFD7o0nUoVPx3DpIF6S4/gnk3tIiuMpBUOI99rDRQXPWaIU/HnFkL1WPd3PAof +LHyXntw4DY04olJlYrutOFnfq73FQvovsRRtuEPGjUqWI3g33Fv4Ntsmjwb71nJdc7LlonWN89Ds +c00kRhU6qLsTigMg+VvOU9ILgxWo5ddvIvD+nHi/f/dHve7/xBP9hol8/lP8z3d27tL21osAI+8c +JGyktiAu1mS/tq7bzRDenvMSNUOBz1+iZOU5KV9xKyORmJsWOT1/w0XUA9kDgad99m7aXZXA7zES +i8hAEiflfAok9J6ZwZRIha9z07Etj0KR7BHXlaQBauElhrGimhXlTofmMqpG2p3MdHqeJpKaZv8d +UZVyRux3pCZ5bVcHznHkHGkRF2ah/rqSDQY8BvrcssKaTGACewaTLw4LdB1Y80BYgGQWDM5jqCEt +gSa8NUkitLkpMUDNxm57NBYUaFQ37iHeKrRNg/AOgm4Od9Nb/O0c4Rkc4G66u2CWATA35/Woad/Z +M4ri8Ab6Rigc6HHFHkl9JOr4dsO+WkyhBdFTl3JCEA5mQ3Zzn3MlKr+gCI8ieyWYCx3VBmWCqnB5 +RihbIh0KrwySTgo8w6Ed2+ksdh7rC5+PKyxUXnr1d5IBg5iG6SecFI9ujc1zQFuTmQmBCJJXIsYh ++g05d/1TmOPO1/lRzSDK3cEx9/2vUS7lnADUeO+0LuKi4IOdVAd6bkWM5Nx6GxP7w2ftpbUHz3Rt +UMtG0Tq1dfbNJE13lBbWBbCiKulZu+TgrrTWxi4yT7dLSKfXe4RJQ0luTv89yIWvp7HeiQNnC3iV +GZP8B/AF9JP3AHjW4EiwXt3IpbcganviAsj/VyLWUTXqIoDpcQ/b9zTzumrmbJAGC0R/Hcjdg0BB +8oeUjHng+ZSuN4DK0IEOejgMs/UzoTDJJ+0R3bHQFdizK30eQ0kQrDjaBRo+BUDDT1Xz6UEh/GwW +3ogIEGvwI04j2JuZ7wB7JiLg4QGF4PP+qejxmovO0si3CS+iOb6+x22jnAB2g4mo8pMA8BcjLr/a +2kdrPMmFoDVwoadj1xmglGdv9MXvc+OrQYWcFIU4T6qOWDpXs0WebevfHOBczpFUpTf27ZuouqXg +mQzWfqULFYcjeQI3DT5HqtPAP+FgDNy2FfWYBNqciLYjNtOlV42H3o51eFeURtctDIhvoHLsqaEV +SNb8HvHtUH2LquBftb9ZOxpkACCQ9qpy5I0KCFAQKodd++BLQNFpStsOD/y8XwGN78G61SShmTvX +9F540Zo7PnWB5pb+t8C1Xu/r3EACo5AAoLx9jC11tSUiTgrtRpy0vyiAK1Z+qn/PAdJgDqy7j0XN +8bxJmh4Vz3tWalfQb6e/xQHIy4/TUSJiYyDnBosyX6wtMBHiXDgQuXRS9baH+rTrjbDQretX6xsn +f0jO9JVhPPIyT616WNT1JQQRUBmjKaBciJvILPoakXJUKPhvB90OWqealieFfaYArkR/jzGFqgKU +2zY4JNSilbjUR2ZFb3a5/PRdN4SEj62oaucdJsuQYljl5ZA5qSiPXvsjnPCvZmD/at65WTB/Gnde +fIM1d/oKJf62QVoNsaxhm1CztIO+6aLsNbJTOe9J0TACwHY5KxS/ZOdyBI+Wtgb7COZr9hEUF3BS +SVbNW/MwEoHDK1nMlFzi0CKAfYDlUeS5h5wEcpOiuB4u5u/oQqtx2bcK81p9gU4Toe3GgND7wFmv +HnDNipKybdSRj6vshJDatlEW5spATYO7ByUJ3EenZyJ0IKp4Vj3wpjtSbPKUcBkhfaGdPLR3DrhI +UC+Po/QYAAXUhSBMjfRrrMHJTe7gGa2p08SFfRksTE8tfe3ljizGXU80HF+uiJHryNFwkRNBeG03 +xQ5DPJXiS/aVUnhn/FC3QxKtqBeHwq032aMKCrWmFxrDpii8XgJ113mmdmf1MTO7VI2VCNosJo8h +AxrhQ32KqVqXBwlcUrWim6yWO1FzS2VTE0S3u+4LNFZznCRE1oMwVg+5bDhd3dBHHmR5BPO3d+ia +DZPAAyEZ6QJm0279dPo6XOoC9Bvd/o/ffmF+/jO+pBJMlLLFd6cHnBOdyDXht+zJIAre0jzXPbaN +HSIlJqhHvpqa1yVPBdbHxiC1YJDE74O7VTqdhe+Iqm5gTKkHvjA+xbw+vMWglC6xTKcnFgXUxj5A +Y12KV9TmA7eiW1v3Rw+BHef10AqoYgf81dgjheOuYTc/EzhH6mCaT1ZkfKjG1N0Xst5Li6r2UFfX +dCFj7S0ilaa6u6LlEP31dhokpBTnQJ5xhPMbqFClZ0jJMrIZa2BTjWaDi9sMrTEpeald1tQSDvoN +NWpksdy6KF/Frcx54tja9ES4xB+2L3OlCPPw0lPlJYI3jojyKurWXTFEU7g98jiqzTRfBdsg7rBW +IoXssOfpivDQp42xGU6dNkqulk27KB6kce6X29XIrET3BiYhzYiskFDFIV9T21Ftq8cBADSQ6Lu1 +36SAQuVWq8eDnlPZ2JoWUAywqteaauHV7l7ZtTnAWdTm7EUhnI6wzaEmfPi7Eq4K69U3xwXGW0YF +6vI0dt6iNl2PoptQMpz81JATz9TUvwyqp6ixmMU7fRdQK/U94ne7L6IIzZo1u/JM7+fZSMwDVvqV +eyFdzAFKG+vA2YJ4lGdfD7tC+wJvURC5bTVcB2bYPno90PSFOYNoDPGaiXmaEqkqvA== + + + 9mb6ZcGKOO27sG18LjQjbwgv/rwTdZ1NDExnVTQiPbX1q/NjaH+qcLJvnRF5qhMwzRkNRXX3eJDt +s2AfPa1JKbmHAz4SNY99pTt6cLhhROBUtvi5sXBU1UHGhz5e1PVHF3GP57JH68nuMA0MCz5hmqXX +tRuI69HtmmuU76H16Uf8FrGJp9V16JkNvkZBoxMG1Kgb5NkPy+Q6n234hQMEQC0v7RqKtbz/PQN5 +O14Xns9Zv/k00AdLV4JnL/uG9sDeDgC7pZwMMPel9fcexZ46wCa9SJWj8aes6aCSI48ZiVdJPOVR +QqiPIOE8x8sGuIZ8hnSgbQM2GPmtt7w3mAumKJAZCna/jQZkWFIzY/mJpLVE+nKzi9hXYnuGqn5h +c7nhv8FYHWC2gw2Lddq5BaBv/u/ynbVAuIbU0Iwa0QDXWzle+wJgtlK4ZyXaU48KN7aw0zlVTQWT +b0t2FHQEb28nLxGtzhKYoDaL9Mf5qMxysATeKt2a02zrBqFYbKD9wwy3kgq/5qVIsQoDbAO9r5xe +1ugGYzynH1d02QuPmsbtHauZYUdp7rbZ2ku6vPiBohvE2lvnrgNMRvihP3eNdmOkxLoQOQTJauwZ +glReaz68B4HUCjjzDoo3/I1k6M+5PWKHo5jPykaqbcJ2BJhXTosDm4ZPSfeyWDAsU7fxSLWg63xt +/9oW/1pnQYRY7D7DiZkx/FXHtTcoSCn6Rp4YflfbqRe2wJd5LPvhqIw2VzoI2dta2Kr0ijgjCnMl +FeZKonnqtqchQnmdh2mIlFx7xP31Qq7apK8fMqkg494LIAvcqWrt568hPNC6fsUludphn6HXrAPK +rOe8JVCczpR/bneJKx2tSN1TcD+TDChfhuzF5bbn2rLtHYnaGFarBVUYCE+LCfJc0cWXB1Js4xdz +WMB424DbBjcV8f3iXuBKzRZqOnCuSGhwCdji3oY5UZ2PVKt9Ojd261dCW8YotejZE16h99ucpZOn +MDWd6J5FVv2P9PrKpkBf6VXbrSj6nbXPK0HuJKru+8m0Rcf73lRqfNKRSCt1L16i3+726JYpZMTf +08tfae94zl9/Cvp0JDVEFtri+Bq28uGxTrB4zXQ2Xc94Zd8DkLJKOgJA6SGnGjV31KybTUR18TgQ +uwxjivpLZ28qlRM4s21dswdZ4prT+ff0EvtWxcFo8/r8jHxONsK4OYjmhebGbrNuFbbzjLGWrjl1 +u+bc89MzUYsvstszFRoxtDFUCLHJRksDr1k9f4TU2Ei28MalOLAIA8b8GuDtv3kLvp0G/0p6Kp3W +MVMf/rGWRe4LY7Idce6I+7FBe+aKLwcFQktqoEZ/xatQ13EYxRa57GAxOtaeFlVE5cYVoRq0e56I +Y0c85RrFb4YuHqMKXQdbeiVKcOg8Huu84Pm1beAEa1TgP/AWUEa6UFU1zfEqPfwqSBuQGRuQc/8Q +2mk0WY6uJup7IXgmwc+0CejY7tm9RTwja+qisx7f/C6KPra8nEaCqCPfmd0ZfiTwXqTyx4kRf9/u +qxOm1Hoij2na2DA8+f53NhTaVVRAdJRxxrHf2yNs6Eqm4p+pp/PBkGh2u4DjEP9f3XbbtO1072ZU +HFuQ+1RuqISTvCLWdmUmgi0ZEQIV6bg6ls+hv61XCgr9RNr1s6+vs+DJDzSzo6l9A0O1jlUPIxAU +6n2MqlMphh48j/nCRn//KiIXmDEgW6ef5vBEzWtHyQa/w+8BAwQYiRtlz0juPUQ8v0fUAHPFyjwq +X+9R4KTa5ku0aErpWTZKi7vGtVOUNZS1bx8rJ1NuAn/pdr9HeCEoMzBfgUYqV/12nt62HyR52hVw +j9M83/khyf864qHvwqRCCydX+hJVbRHyldZboKLL2Gbp6sBZ3dwlHaR61KVEwo/0piF4oSXcl4jn +DY2fG+Jm9/3NeeYdIdsqdScrhpJlAAr7dxFuokrcaq5aPgurd9ibCN87o0RabK6NxPWUzccum2dr +o3InkO+LTjjGp+j/NDtq30Tk2fVgkXDQ1dLt7TyPhCd82trHzri0n1hLV4uKR+Ao66UamlWVmHwU +5LzHp52Le6a2zShJNUncOipHbR+ooPTXBnsInjpSl0EFFIPPGH+MGH8cr4XmiEldRwj4DCVPiFBR +ljDnESCH9kbf2MhsZchF73wD0/IuKDdXimvYyZz4CC72KBwjnO9vUcUbRltzinlYMwbYOd4h0uj1 +A1yKaWEUdKirel8ivIyoO+Kqr0RFuBYgJSBWb1FqNyS95EmdKnUrA1bWRFhNNd4iSkCpKA48KPz3 +qJ4Nd62pm3RyA7H8M0UiPGMR6+WbIAnON7ldMlEIORVeXdnZS2VzZF7noAZw1XZkxDIiigNMfqvq +dv3ZENjYchosNUQ8YoKKmMBRGI90ilGgPMhktrmKJfbCS68Mz3jyV+BVuZJ1XdQYU2/f9Q1/lGtH +WBJZiUF58gzZmew4IJhRzuh0Xg5//lsZjlKyQ6Aso9sQui4WnmlUluubiDGCJEROaz67n7cohUFH +hEHLLsNXeDaQ18/vXHlqF2n5nRePw5fnyO5aZXGCrMLwIp/RJ1K3E70YC48jm+4C+Kyk8Ql0I/qY +PuxLYtfPexrWxvAN3rj+0GDSgmRytz02bZJpvp6Bqt+xHme78x7wu6eLd1raB1k4vznNfT3sXIgd +I9tZakxsZ5kl3yO+XSO/RrGgxCxlgI6K7e5DL5XAUTfEPKZx1G0nvkC3SW28jNcYA0Xz825mpMWA +lDlLIZ1b6vCVGs7DpUdKDC5914x4fRVsWiv99RoX6GPIylLbMR6Nck/RvW7tB7N7am+8+zBZIZ9R +moFb1h8tyR+JRG8R/7IrSc7ebx9vZ8oqKD3cQdC790HUF0tk9K5vIKQ0xtkMSS3uTTeP2R97JaPa +jtpfL3zmFdX0NzyeqhkmrveOmDtCy5Bj0w6axj47glyusT99qm9kjWE9jdR4SlSdoDrL2dDOPOw5 +/aXdktT8nd4HNvaiaInQXBjLjfHp3ySEsyA5s90178d6sfggTkawB4aKCuuNlGeDsRE/+hpkcUjE +4hrJUSyur+f8j+43XcpnU6Tl34BSlbfHnBZ5/EPO2a5ar7FT1c4/d38P8vTZt+6bJVQU/7ZVcNNI +F/sJ2BgzljgTt5oVNTQOhZCKEdGKYLOzzxNu+2lyQy9Agl1XZvI5rzPzgabYGUsgpYYr2lM6jXwT +oboTiQGtWs8rzmAGrihxV7Ioq9VTyT1r3DqPq59txBmy6qSBGOitwQV8QTuetvRwH5MrW9CZSYa3 +3eeVpXWoaz8ck060STDplJ+6AuwpFJyazy3+aX3cctL9XcS6EXrH6K7OV6vmiJuDUQrS7QI0sqll +U+CivN5oe0SnK7hH1u0aRr+pKu64UygpwEIa5HeqFAGI73waWrkrDNVGpSSRgqMz07b/DjVTodKk +V2of0dwum2nCokRWRpmBnXnApuu+j8ezo5V0EssZdW6j0CYmaxAp3kqMnFcEoAojLMoSwapAnunN +nqxtOYPISOt4+zLH9gDgHpC6oYBmznekYlxQ/b5y9q3wjVZ0NcJBV07V742Iig3Q9fmI4deQsvFE +PlqE1+i8IIRVpW174ov3oV7ShBXwm8IMgafZI4psACDGM5Ajsk+d/15MrBWlvgrUMLPMuXF0B8pF +MSPsMuhllAR+pAALe5gJARg7xcty2HHq3c2tACNZEYoQPReykmKPquRKU9Lq7Y43V6LIzZXYxKrH +hqQVemxj34sVLrxozporBWerfFV5/TpyZNYjPpXZYcZjClxTb9dRk/HHsy1rHpD5MLZ3G6UAfSCI +CKcBufnq1k0dN8bVq337dh64rdYL6U3sn1vV9YKOXgtbfd67REnepsz1eP7uWUE/KnNSYKier8+g +SyQJQaeDa3O+gT2h7abW/dcIDFWKdTge48NT+Bo1ztSj8J4m/WYDnEIt7tNKM5atb4TBr2Va6EE7 +65K3tw487vIanzJkuHsVb94+rgNn1OdMnRwZrfxw4EpVqrFfPH8YQjN8GoXG1svswgKSYW4eJ7tg +Su6abG2kKU8SpFDKmscPjzl/UkWcLFWX5HI83aYwwSR5Xyk+6R5SZW/uj77o60ld/BuDb51uHruI +o8sRzW6zsHMjNymt2oonourxOKMRzYIiqR3g3DFet+sqU5kTBP2fm9KsmMy1yVXKCE2qrsEQeR7o +ijMyLlY8vh7I0/3K9X77OAY0oM/X4xqaLYP4Y5pCzH0e/ZsIf8eR33GURynma5SoeyaMiQPpvW90 +yzXqkdmeHGiL53Hgks+4JrsHU4PZhJCXNS9eoHm/RvmVyKRBVfU7P2HQSiXtDMyn7hFhaqYUhaln +f9SfxgZlrbVEPtTcdJZ2tOgrgqpiSV8XKNBq3wvfbxHjisUQZesHuZwotp1EzWhqgkax0i0ZBBGj +yOySiQaeZb1YNt188Ap2W68jLI7jkVRb3+gh8ZX4W6KxPo+nHqLK8Eq3rGauebp4GrSCdh3jihC9 +KHoaQwqMKz/aLaWsAf55/mvXbxrpIWSL0fLxSB+tIWAhHjSvIHymimtfGSQkrLnsDI+tbVxQYuuv +F8P2IurD1RV1KMrAoHFeqWR3M42WDf8+aCF+E3F0zX/zRn85KLuJ0t3QPGJubIuVYAvKRSsT5BF0 +g2nW0yIyMCGl9PeIrCLn1m6KYME350Hbh7oh2j5USxHLsy/5doCiJBnJGu5r3DxqCF+i3jS0afQf +sqSh9V7i/DcGnU3YuQ1S1NFZGygmh68RrylEGu+Fo9v5zXkgtNI3lXpaQqQTVIiK5ND8s2vgkKc9 +qk97/Wb7AuhDzRykyisnfyPVxNwopeV5S1QmVnJDnSXnNUuZ6o4Y0RA4Jv0pr6mppwtTdq+MKH04 +LfJeOU/AdisLBWpghCy+tSwcJfeiE0IR4Ru4qp2PYbX/sQi795Vop63FG3rdiOsXBOp6NPPNIgyw +vh9QyFBL+Atrz2eVGEmTjbrLbpqfaZozZm2DTqUNze94W0wiOlJN1wZ9JDeA3He9R2RMbVFHrEPK +7N+cB64oWEr8/5zMa9v6oIj9XQG7KfpRNzO1g6qYm1WKR0+Jf+Np1Qn10xkwLnCpbfEG5g5FpCMF +sNCE1g5Uf7qxG7W0l4TIUlig4trRQq6bXjq2nQmz8HVE6VtBGBpd9+77nrGkAgkTRv8BXoJSwdyG +U3gjE/EarGtxCPiL97q0b84ztySSL2vbGN9LhC2O2O8B5aG1sq9+foq3oCPyypgEio6ZW24K+vSc +m0/FqgimUBNLvtA95GkPYDc8qKqD1lwbgfFsqe+09NAHQqDPKDHJa++ue8nJ2AnS83DWlyjEjI2X +Zwso75yxE03pCqpSCGYI134aqYXlckVDCuX0UfLxSSIAXGZuppM1BfwGrnetBYlthzL7a/CUB+CJ +S7c+bQV7MPm+Sm6jujGD75xBkvrC6o7g4F7TmniItwDQVmqPKj70wpH+OmhsYwDw2g== + + + utZtsPhhqyG/b1wYdFwKunNHrIE9rveIPK6x8bKTOvj53XnaJh9S1NHeoQUgRSJQrKH0TTadyI7H +f2D/uPB9H7WLnjr1wRdDNogoSptE0V//q30/d2Z/89hOq+9KJQecgbWei3eavI7eQKd7WcZ7BGYc +U/b7TWngh5rRr6Iu9CxwmFhZ9zlj/5M9Kc4DzK5qFaRpLha5zLjnlPNzVxQqOvxLyBBKiG16Ki8s +VfiC1QmI4kHX4Kw7Qhkr8Nnn+9qazPRr1JqqtFzobDFUhiyx0avbS9SOAIlQV+2zWh5Oej/I7+t2 +LBhxLJiPauiWwFpfp2i6U0uwZfTSFFTDo1E/26ZsTjwQfUWpcUSnH90LTWKYVdXpV/1WxsUL4GHu +1yAizfixwdld3+k6hTjhTNMUiANd090E6gS9xhDNGjn5Jr8IczSUkKtmYoK+kLGBMA4MRLm09c6C +FFTSXdrR2ghMl6e2rizI6kDlvbxHPIimADkGZeHrm/NQ6pYvTUKs/jg1t/Z5APlBe9i3sKGc9znI +Gu/yfAaBiDSzawTisYIgUQFUbXGtWcH9oNNEx3AMPeLwh2mH0JJJpe/nDZ5T6wtVhJ0TK0u+3i2x +vR0vMXQ/6uMmNlWv/vht2N2fE+Qn9/6P8u//xJMdONaPHyn1/o+/Xf/j/PiLf/vxP//HH79Y+fj3 +//H3v//fH3/xH/7yv/3NH/7wd//8j7/85f/55b/8zd//4y8///6f/t8vv/9fv/ynv/37P/znf/79 +//2nX130fp35N+j//5X/BmDWBbY11eI/MIJCGhLuG9Pstf6y1krrIrzQa6X5ULYphm9VLOcHtNlB +/kJVYaDlxi4Je+TXn/3UsPLH7A4p8TvRgQm6psYzSmws9k+c8B9ykObE+0G12NTvb8G287ZivYzq +mfAJiAM7uWSze5e4UEXV1BbeB3J+pwJMexYGvsP++0ZkWtzssSsnpAmZb1HUFPDHCwS/VsHtNTVy +oN85oM5+3cQpP9F3yyQpFhewMLj+pL51baIMuLK6Uh6A9wePHODmzWZ25uxRI24wivMyUIVXcB6N +KIXFuop6Hwh5aHnyVWIKitS0QSecgTfx2k0xuhY97UIZJpW1eGVSFNuiMymm90Octuikkqmwknhv +hV7gLdpPKm14WVJbWVz5UPGv1r3ZuOzw3AonUaEogYQfaq+slOXZ3UzW0o0XTwFGYBWfOkVd0M6m +qyVrTz9caCPTAyEuUNV6iD8Y0c2cLtaLc9oVQPhzA9QETQAn0cGcunDNzfWHIM8mJipFFjzKJXXg +A2PVU9mlrvsflm7sePPPTL0ZovtPKv6rtDQ3Kvi+1j7h/jxQS0T3Aak/Y/rzYE8FmO3hYUrxk0gB +NkzQR9SCV7iODscY7wcCfFqfKt8cxO5Tj2/8e8gN4PpSEKvsgWbApjplq3f2fEUqA3VLZVsiuB3g +fqptNVTfLF1nuI6gpK3kfGidB5/vMZr7qW2p1o3i77w92PmphPakHPydFgsU8PN8k45ORgMpLUwU +K97YjU8bu6yzIS3An+Ku1MJ7/j6S/xdmyqcGtY/Rm0EtqlCA0oMIrdp4DKvuUPSI+Chwotr99nff +YdCLx3g7dohhtoRPXZenenw/JI7ADMtHOZ6Z6BGll1/MtuSnrbHangNdIT5eWbap/dpzkph9WsDr +RWeLcCWNQ2VipXEXw5fGt15rzqAP+mBgUTb8TCaec2uqjkKK+4Hv2lE2Co2BVvUOy4/DQQCNIgAo +RtNasv4EeGLsAyRhHMC2WCrgHadEDTDADLQtqSjc+Q5cIDxc20ggW38KjYj5HVmoSk9achA17/e/ +czZRcvWbg6dmO/EAYIpbS9DxuQTF0BAqY9YiTO/LXriAhbFwrR+ST62fZi91571tEJsr2vcL5JMG +hca9hstPEdJab+OmJ1F1WHk95ioupwUTKuSu0XaKfl17vC5hNs8154C9gOW1fkaV1XGWR9EJ3Iom +o+czBZZAWUgSz2Dp+yZZ4wG+FpR8CD+xU0xaMEQnlmorgkaiEbeSGnRi1U/cqobAsa6t21Jgal4H +rm9rLanBM2kZsKIuRjQRKxHhSqPLqSSCVi0RYNSIoPxNRO13ItaeU2iW2ti5EiRYnuIKRX2eTQRi +5Jh0+TIAhQRojzjvuQF1yhwDhnNPN5Cspdm2llR3qMyQl9NWQ3Ngv23sTiI9J6BL1eSbfR38bgQs +1tsnjkLxD+mua2KniHhqsRIriLaXA/5GvrCez7Sn8oAvChKdPR/CCnDAoZ8GbKxvX8ujx/FwWcch +tGVVZ0NTVY58XYRqIDEVxxVRtmRf+DAjpENERSJmQIEMotiuLgF06Aigd0cA8jK5ThDFHRrGvpD1 +clSWXY9RUREUfKBusp4wNbzQH6MnrDXH+o1/4x34+XljmmLiA6srGZHIe6krSbcFGZ5/2FGoXLD5 +QW4wImA09yjDg6LwPI5vHDKUGhuPINl6ls0AmNFcCOa9AScPdNDq2IsvUXQxdN4aCpysLzaUBV/r +2eyeZ30ASPQFlXJHaGK0hhlF/iZ93SvdQBO8Eq0ZrnTtTlPRdG5bxcD/oWtWnePR6OiIQcKB7KnS +6r4DSXLlNQWeEzjFlYbWMb6JcBUDcKnIypeDJxr+ijlc0Q/BdIj97BruldZqQYHTYvP6aR+PJdrA +dFQ4eNJAGQoX8SGrBPzdRYlFfv2OJ4L1DAT+TmeYv48NHIGoQOnDg3jEcxDHbWpMJKseoM+ERd96 +Z/g7NDRvjcWFN+wRBkbMkKrlyjjtxA3lWaNW4YszwDyvOfYUBD11lXp6uJN1ZmzrUA18LnSj68fE +x+KIaWl8lU7ERMYPB8ghrCZDrtinew7WDQGmaEItzKoKlWFsNiAw4jYGkY5FpbbyfsCvhoD5nO8H +cdi2xAZJ1w17B3VQPg9gfPw8oNffhupvPIf4LPUIseM9j5gKbGSFWTBg0ubqxIxin0Xt9BjIqhPf +T9uI/L3tD0XY+8TH6fqIRnS8tqqlbYruu7R9YuDXczDua8hmrVTppJgb+aN4pLGiXZ6tqeQlBVtX +WeBteW+dDoFw8o1mLADVDodUH8OouXuSeJmtqfp1QGos+++WicPTvQ7ekUbttjZ9QBd+oFSM0ic4 +ui5fU2fxbw74Kp4/KcPydpC9oGa/6B1o3AZtdHz+HS1LDW5hDG9I8edByDv0AtbLANGP7o/KJbKd +u0a8a21oHzdZaIkuVMO8p4Oa2WbY6sGdKVDvH2INhvWW3JgY1G9+IcVk7jjp5dHh0bGZtkX6KlZU +VfFov0Pq92uXhKFGQa628kod4FlSsk4BHi1j6qZVJ1ekm26MiLYZ8q1xcKU06JWqMgaYszsszqwb +621cO401VeC8eAB9n6B180sfNjWaJYV1cbhCaISi1DRtruSLAkh7XMuack5EVVSIjdL/sUPtYCFp +0DqgRq7Zem42Yd79Cg5iGDGPSW0ChlRPBCDZTtwmyxKFBvsNC+fcbEJt1brauM3zXLRtVgQmTEbE +tE6hu9wLafOb7F8uAC6ta0kKSt6XQtXXrpfbR9ErcU252O5CSDhYQ62t0169P357tX4yYY3TWEjX +bq/JooPnfGjNvKbg9VBk7KIOMnz5atbOe4vwjWNdkadNxtbo+K03ZpxZbmXJ4kl0+SUUt2WiKGhA +GSGpbYC5fCDrDSdDg87Wc+O6GRB0auOoliYYZbotZyJcgmD/l8xvJshEDJY83pBip5xJ4qkS16z+ +tHEwbNIskX3XEM5eciXsf5gDGN1EIPNCBO+/EeRgRAzU5M0xkJZeEbgB7CutJ3FJ+lxfoJ/p3IPC +BWgaGD4b2OGL1Y7t0oy9LC7NFwzMolAcUwjvoq0Sq1BrqNY2n+uoGUqle73k6Rqbia73GfGZtFXv +GX9LDa+/LpkWksVdTyT+m99w4jKDhmF7aCUUqqfu2kBB89OmrzB0sf5IKTt/v7Nukbn556KL9THt +UOAYrrGzxOnPsx9x3Z6Ckyj66IxOyquvIexX6u1rRENhdzUZuT4CTPkeh17Kx3AXjO7gMV9jDAV1 +7+oceb1MQREXmU6xOMc4naOJcIYGYfE3W8xvIqyrzdcP8euDSL0cUqccWAfsY1vTMwwupLHA2iLR +g3gW2HxeFfby4/omwmnioqLBYOvFbfb7eSZJXyT3hbM0NAFWMkh6tvZi5nPXFNz3BZnkxB2XGJSo +YxQocVX4HltwtrgImLl56chpxm9CEG6j18cmyeQVWeOqPuJ7RMoONKboYK+4ctT3KH7RI785VbMR +C2lyb6xajzq/ifiKKX1G16+j1FeJN+tU9wy5ptaqbg3i4SlCU9alusQ6culierDRoj33FuA3QlgI +T4AReOz7WVZ6fwDBGWCkrmv3z5VHbZP7eAugH6TXMoSJvXt4jxKc4fuEHxfZthdGao3BWLZ59XXE +vJpKAEkROkvYmpbxHvCMtpNt/hptEAu/Oc2lYD1Ypsbi4ap3q6lWkbO6Yw/KnDxwahnBiaTpz5ux +BRSNYhIi6jij9RDcQIuTsxGHMtcFCnhEFnTuxdeQXeSlSctJRD+2xgIwAiBLQCqfC60li31HTAaN +EkLeEKgdnqYOUcBYk6YRu6XZVipRc6H1FnCONXj2V0oa1aLtkit1INxE4bNbM6EUFkPcUdmgXyhV +sJdb/3/5pXFsUytzva0ZdTwj3/Y6345n0IF5Qeijs217D1I+HAQHfIM8l7oNYFH1OsZ3EUeMF0Fs +XPt1fQv6Aj0qGE0emXaTmFg740uidH9r6n3eX4/nUV1sg9nt8hLWt3Pgqwg1SoOb7Z3cXUPWiC/9 +24iZBkmvaE/sn+QtCq1NQVZrYN1n7va2vtMghkQ03xpDWxMPdaaCFmH1OWBw8h7wvKHuNN8+PZQc +nJhBTGu4dFO++TM7nyrlI0WVVN2+Rh3bVgVZ5GJh6dxjjj39dFFR/QPxs0uJRjS8gz0ETPoekedU +EFHoINpwDf7mPCQjh1JgJ6SPnZGNnZGJxRrZKwKYOJ4kAkvEM/v4WuNWnB2ymK04PZ8UvthT2dI8 +6v6FIvWavHeoUL9+3mOfgxqPiIy9uNieH+RfVPS3YmSm/Es8AwayOKWt4+whPW7RqqO3e8Qrmsze +M8hZQXPy6QNR/G/mYpmMGMH+EiRzB80V4AAlidhFvkIB5DwcNy0yIABbSey/Hkg60Xlq5j8w0r/7 ++Mg7Q58pNgH0ipjRqcNtk+xfRyR5aEkeHjr6e1SPwNzAOfdMRgfs0nxwrXHWbtxD0bZWMxlaoU7I +oHMiEKoDzsCC+iU6c+z8jN6jM/q5AbcV+f4nNT31u10TZSLUlcdq+VY8CG2X6IjexWkVk/n2uoDz +P1HD+XXuGhOKuPs8Y2pQHpCyttcUWVCnrdfzo/A01v1D3DCCUseKeCk+iTR2PzLi88rPH5dnNo5X +JmGmRTZPoDuyqlQXysrW55sI8CfUGdZyhyV2rvQeVWJaNwTpZROGTwmJp2XzBwplaQ== + + + QGby2d167b+/xu85Ql4Dd/YcFK/LfmJLdHJTbqiHJdNmee50+3NfiHj51VMmXFPZSsiTRd6qHQOr +xbH5duhZLKF9SmtC1wqcqXCtADrMvJrqIdAvsFiAF7hHsBW2Sb5G/O7p58BLpZZtq+TtPA1jn5Uy +Q9HReRD5LclWqGn27yK+W//egtQ04Ec5AKGuK0PaHKCB6HMzPfe5TTTxdmI67lqc1XWzA9surdx4 +zoiL0d3y2dEaT5l7bQNcRNbG/pZewxq1TkPvE27FCWaOzURHr5Lklv6JhXBaqxdwjKuYTuEyI7q2 +gEDaNRrq6WtonyDwkn0APCu2EfENLOruvA7YytT+6sR5Stz756egmU4k0m27hRvnBggQGzBMdtKa +GiDdvetE/M33zr8p/wB/+TTYyld75u0iWj4H+nOAwlQxBXxO16I3UWPF3otPgU/pJu6BEO0a8lUe +gHCndcURCwwV5Txd59pntBmk+eE4vLJcGKqpKKILevHvpkWcHpN5vNe9e66Q2HQGxMJnjVCcv/0w +KhkOjwutrosOaVwE9LLQymdlLp/V5gssrwcplq6DzHwgZqlS+fdTlyCdvzhwqj3cqA1PvSGvR//w +dDcfmJzahY3614d/PvLnKG7fJ3Lnnsy2Kx2WU1hdcmHr6gA0aHXgy+xelGLcerhsHxQLg25M37LN +8yAvWpNq00sUsQTWmobyY7CHLC5CBe8omDbVNycwJBwwo0lCCQndJxaXzwNXYM/yqDbt6XVwUnjC +VPFAZfFDtrDYnjPVdFydaLQUKihH0E4VsfSV3lwUyVJApVGH8C0qx7uj72kxNT3YPRwgP08oLZQN +AlFymmB65IdaE24mbADRyjDCdhcitSab80mJsaldswpR9naIii4RJtcU2w5qV9eh5fKp/uAuScKy +YdksKgjyIq8X55CKdsZJaEWgEve60qBpBk0a45LcT/Hjp754uJVd/tvVk8Bw38aWJaiQcneSitHr +mjdgE51zRlIgFPiO2AsP4IKm34BZTkuZ9OAo5VT2dnA36EgOgAPHxBHCiBu5jKqAwr6SHZOBpfys +ujsYxQZiANHonseqIBbZR43kgvTcqt3mWnUKvx93i0p92/dC673SmNpbrGKvahB0nZstn0Ez0A25 +c6HJWrcuZFnmDsfAe6TsQ/FLI1+J9kLMmpD25ycwgZrefAxe0be56ZEfoY+6Zauw7eYPB4C6q8S2 +Mrq5i4Kvg+OOS0XDSKvkF0UHhOt0+48DhCJUS/g8bAXpm9H/VqaE+/0a4f1S/K6kBKAKmMrezoNF +uKVKBNBreWd8vkecG2reGO8byv8ehQ2ceLs1jg/r4tTNio9IJfR6RUm5sA9mlTophaqr/yUivy2s +T2w1bt23vzmPQ4T3jGm1xYVcKAPrOMnfewDE3Raz5oc1+x5FC45ieRNbsO63Jj+mxWPNhs0cpWxh +YnQYLxKaKxxDZ81C3Xp+/iYX/YcrJAf13auuCStxo1YDPkxoB8J/urKXgIuapGiOd0YHwrvnvo6Y +Nc4wNpSGKBOAE/gqCw9348JDA588qDql4ieEhUYGKd1y7rcKMqlnCmVEyA1E7L5fsibHQ6EiyjIX +bTkaEFUtiUvr8tNmOKqUeqKQdrToGnbPszJSXt8iCxHqj7lbfY/Ib/M143k7DzQWOZKAXy16nlvF +C9UudoBvEY6Cvi27X2/616irx5VzjbtjjH3DMzd8b00K2dtoA1NQp40ECojWmLSorwG/2xAmuxQ4 +mzL1v58GpAuLMEgXzRpQDpTsuv6oCR76QrQOsMPUAuk7e0BAKEHMUIy5ArAHwi7IZQ4xLBK8LCRL +sW/YM74HKDXZttTkdgt5C6LBCYSlp9wOPpsUTSQPHR2Ake4H1vwwz9iTTxr9oKyP/vzgF+h9Wnm3 +0h1GKVMNSZ6NUNFPjCVo/fmKwrCQT9SCJ12qSNGdROChY0SkFht6gp9XyupKe+OOpvA9deZmTr49 +zwBPTYTQxqMFK7si3H54JTalsGUlxBNxSWbpNDf368LKRTq/ntQ54gAv1QMnSzcFLWVw4YkbGLSN +ZCu96m8i6hVKEzyq+nyltyhQvgp0mQhdTr3yQvTdVV3+iP7betOkvJai9OP7gd/tLKtSI2ArQVn8 +LerGRVTdsL4l1tjKrrn4dUDr9aclv/9UAm8EZAfWBuYl9Q3AvBuzyvv6QQYz+QknGT/MjS8Brymj +w1ID9TbeT4JIwhXzBjYpSDGwRRMgNCQj4tpy7YfX8/AeB12CqOkRREM8uj+oEaL7wzbICAqVs8QX +XTUXQKLsXzKCSxpvnEPi6orADYuIMp5nTRRT8dxtJ/WDJC0hS7xv+GQvP9ftikmXMTRUGJpWsDDw +ZKLAB3TGV/Sglckp+oMyLXvOn8fQCwilJe29S7M9v0YNy9qIh+l1BuN7HDzTtZmY5HNvEeCUfSyM +/P6sG1+jVKcE0Xkg/0bqfKdShHPSfT0qqVdUUsd6mrcd8uv9gCNKnNN8P3jBsbviVYA+NZ0y5D+b +AOBDx+ZR9+YSA5Vg/+eGRd861LI/jM4P3r+nLgCQeYGxoHITivIutGCdg5+MbHvcXZjSgDXQ3jlq +NhdjRp1gzWwAzKTWf/27m8IjCKOvxwad6hJVELVjSVjW1/z8+xl4bF1Z57kn7tdBEPEwEUHEU1IC +0dk35QDoZZmTt/rDbOcMhPypGUKy0PSCvwmQRx62+jXWZDi3SK78CDbX/r0oNtMffoQqJ8/Zpj8H +D5AcksY/jPxTjMvpgQjYM/sceVoPa91NN7aRT23upM8y83sc1W9IWVWg3Fm2xUZU1y/sXusPB1A6 +aQ/cLn/jF1x/E7UaCXxtTEDPHULHvvuz228kh2RGfDmIR0mPrI7YGvXNVw40S/a+3Hie6koZSfYd +USUIpreDf5VLrQU6U6ZdvkIraL0KVCdcCpBwUJ/1DFD580ALxETfpJ3dvw6OI8pcWqhdH9cVaPib +BCHLBpuBm+3zI0L2JlLIpgFZADYNYxznN+fpVwAlNC8OMdnUNRC7WF8XluF7xNflI9XHr1FYIIuW +RtS8mKd005G2ZQt1IOQdOqQ9CttJDpu6eHRotqIdIOmAAsDOovqEJkVTTAYLVoqia4yVbQog/Lmt +d8K2343kCRVXGD7uKPGZp0gKavBp9pvC4J+CjzJCZerOsZ+eYjpBzOAwgYefQkYlVPi1d5Xv9Ne7 +B0lOTpWYJq602QsXG1pv2AtSRl8bXuSS10bgSFobegC0dB0rD9JGLL3W5c75HpF6+JGtOEBqcRRv +59H9mB8DD3V3jGO7564Hd+m4/TUCBW86mbSaH0rvW1CPTFDkUS5lXrsq1mDZZkAFFw+hd2DcUVF1 +1l+3Sptj2y5jONiiZm9hqmyNGZRLNYW92TwiGMZqUEOSV0GMCgKtqt+Ebz1AL1mb7xzHAufwR3Jh +iRg7w3iNBNdVuqdDa+8TeMA/7ChhHSdM2C0HFOsq2w936tsAwtTkcGqc4bUVZCdHXrwmSq6urSDF +r7q1CvCueDJZHILEJqBkGi+aDUNea1w6A8i7aZvNYkeme9YIXbe8FdIPq9bcKbvgQVpV9pvHxsIZ +5dZlHFG4uXtmr7WHOfDjtieDshs9GYupbKP4MdhGoUWbBsk04mxU0e9tPOdG6/i8EjwNolrdWoRH +aEKzmDJP0KSiahAazPAvdKSpNrAXjHxDvoka6eOkCrHPT+3klsoEvEBrTTOdeT7d6jUR9u0mMtQv +Q1akCwtCx2TlT3JZ9nLWnPj7dt+0J4gyFT3B887SIdsZ9Y3zwdt1wYbnvI7o21MhwQtUAKOd3Pu2 +T6vumcm7HkZ0gbaYoKIC9VJUYAJf0Bw6qIKg1JC4OOPZIRaoYE++/edG8JJgYXUhOyG247r0MqQQ +VanM+q0qDFFWvE2g0C8KrMYD0vABitku7/hC5QDgf85bnmzHKFCkHXBkz9Xj2SMEJfdnVQT3u664 +DxFTKeH73IhPoVd0Fa8aHzWBolzpSWKEVGIfDaRy7mxb70ucgK55b2r6tMt+qPEHGekO2ggTR1Zu +GOooo8iYg+b0bCPVwmDjItNFqyh+0DSc6fDRKGbwxfftjNbHqVcC5h7AVcQislqJC/800EgXubHV +aBo4dZo3x8TXKPox4NN6E6elZIWNTEkXAn2QXYyksfYl66/zyaMA20u8QMxibsezOvRbXDupI79A +h/Qz6OxHeuYoj7mwkja0Vsa2g3314RvjfR1a311hhUvBLsCFFNL6eubAM42gfIlY/dzww4LJG3B3 +dAo9PWpJ9iiu9rqAhqpkZody3VcYvyzeR8uV2MUJBSjqjl5RCj8kMMwHLJlzRNQY7WGwsgLGr9eV +7gwvdmHT55Dpm0pKEKmWKizxKMLc8pVoIR56PN7JF6gCUUvBGzC0LBo+D8qWjmDZCkETYysAbLHs +PSFjwIaQRTt6tPPW9zzTdmo/sUtWD5W0QWc+Hc0uaiGPhPqZ1YrCN6YF6r1QHV+pKFg0r0QvmivJ +EW7ov6HagTfwPLYrMUsYECz627ANZ/+ECUeG6SlwXI9tH2R1MbNgJCDMXl3hcNYJ1UGOwNbp+Zp7 +n1ckfw7MEsueTW961oqe+DooN8PigJIMJR7b8IXKzlC269InUB0tnHspe9uLpflkCe/AOa0ZpW0R +wPyrB5sMcVcqFmp0RuAYRkQEsOzhgHwcTasonVSL4P5zPPUIuyKil5H2fe4HJYSOdu/YjC1sYmFs +dQOsHa+rH9dD6ZKODkOr5xQ2o0CVnU85QnfNU+mcvCv0uiSVwR+afLx27S0pJ8a0UXSd2HOxiuiP +MvmoH8UEdoOz3kAzHBEaaI4j9HN8nYDV4OtkrU1pInbz03zIrY4oWTKSYybJUToazjfALqQnH4OC +5Ddx0kyNhKbfTnxcH02NakoXupUUpo8rO45/PQl70rpvNTgKTM81yf5JpsYBD2IVBniQgQ34QIMd +mu3XTvwuZDy1tVxbWvC8bObITe7NBSF/An8mVwZBUrgymtocD4gdWeWtAlg2So6DwvEodaH77UEK +NQBWWGuJuA+x6QC1aiJMNwv3WxKhPOzKCrRmB6IKHL9Dzy3tdaX72mI4+rbDcp77Amx86h1aXZe+ +lvNelDCpa54jebm4EuhGW8fKlMYZjdZRDyskmHGATz3wOoSdAc7d1IxUL5xCRYH1DPdpY0JiXLNN +344VMg7WBuNCeTs7tTOtXHYo6uQ4wFBQhgsAoIakWMooP0AMui6r8uSid8iBcpbJbUUufiXLJJM8 +wiFeUXaDjWIZ5Svhxl00DcGABZH5EmpO0/kX3RPmAiLWBEoEtVACwlzQl+1J8mEuNPPOC+pttbEU ++bTYTKtadnnDYPCy8dEZvZIC7gvRvCN3vbaSm7JmdS2pG+vEJneArhkuEBlDYJmUwKRew8PFuwFs +XbWl1XoUL3DWpfj/2+/Jz3/Gd/ME5d6y18b+QZFSlpl/yMETWWYVTDVJVCl3WjjSAQ== + + + i0+B1ax0NtbuiERONS46m039VJwh+kPOs6LDQT23q3by1U8pcAJilCwBR3CUVKRQy+OvsWGDAPUA +yyg5uau9NvSpAgMIYxOOq/1v+jTgweqxpf41kF3ZVNs6LVfQNVGlJNNGlfK2qNl0ZyExudc90r9s +SQiPJIRxXfebYYCN7AUHKX9BHQVKyb9vq0vlMaKdtMk4IPue06qDd9mPf52tqlBXInq2Dh4IcxOs +Fao+GyU+G7jYE1hYujlwq812AlZ8GJYHguokOD4nPJuhtVnk1fe3xJuTlwNVZKGQJk3b4KuIyExB +uu6CXm8p3K4ZADLShzzrGXkCEuUCVpZ5Z01aCBeqzL4fsYns7r+c2e15Ku0L2+PVOJk5LaCnt7DG +ytDBoYfBjj1Vg3kNGNO9D3JXPV6NTo3Yws376Y6Vn5RMmkznpA30Oeisl0CcAhZhAsZtPb4ojxAW +BIcZPA1uD8BSoPNmS8csUJDZfr4S6lxDVEpz4Qd5RINHHAMwQeZyFn6+ITQuI1Q7xYeAPj8VKkbZ +mnzWtNGzw7yMgPr4dHiPnzCht3lV/VG4P41caKw3z2OnfioiOvcelIe3bpj6jRHcF5p+Z0kEmKpb +Qez+upBGv7PHR8rtItMF20Wxq0RQCiCi769EY9cbOIo3oJEQX5VVtWCN0J/zY/mIUzrSSy2ieza0 +MaXkF2ScCJHGtwoLJM0NuDBNJW+NGoKmOFekuwuipE+Pi4rHYf/0jKgfKV5Ti2LlplcQEXa6EV7l +DpAaAFUD/J9HDgd9t/aeBInTliOOlcLe4PGx32bMKsuASari7ezILXTc0Qq8790bqcfj84zd0W4j +nj9ts9UStzaKUes1593TC7pqa/1xkUjYpUEBxArJqBQUBBQCDlM6qT6CIqPD0L/b1qKpOwOyFr4u +fZ+7RF4eH/qVi/aHHkyJ4ty2tCQD6E2sV+cD7dtH70UpIErC6ApAxtDD5tpCmtVqTX8Qi1Xu8DWD +JMc/ExzVnc0SWIW1HqKiLYQZqZvjihvZaX8Nz8DxPC7B+IqJwabGoQmM4Lx3/Qno+MpbkMShd6bN +xd7LA0I+71hf1JCaqzwn/g0zkTLNLB4ofUuWKamsU9OmS1wPzhJRR4TxKH2s/T10/1vG4DW8tz+6 +3v45E2400O+SQpn1XrZkzPQs6p0CdIscZpRKYVCub74mdNPTA81rlCLWvIF6lm4t5+ZeT5H3oCa8 +Yw4iP5tKDgDlU5jDh2QUKaxlkyup3qzxwww15z6guCXcrU3fd+qp+6D3sA4Cr+cA3c6apow3ofio +BTLrEtvZG677sd8jpiBTcWq2Q/1CaLv3B2+/ZfPjFFPLbKMdjEQSq9sYXWWEoDKEvNSbHOfQhbbK +v7hoCPafutklb/8lf5V92Us3QyoF7WC/wEpFgS6vv5/HDAERIooHqPpwABs8Dyj1igrtI5zBLukK +EdUhzsF8SDSstyBXduKsXjygyCgHqhTZtew+Z4Ndxa949J1/X6BFK1294j4UwjD7TwjDkCJA1AP7 +K9SWWcXAD7zAVGhZUWGnsUNFi62wTY/1BLgZpE1aQMLrDZuR7kZdleoCa5zM/7UXB+RFI+d2RMyX +OMvxyAIUSgLB0HcrrSxHH8BTLunpZEfS4e7N4VpffaJeYoWUyZTFhGoK7sZAcBEeQtkhqPWacpje +KOdWjYeVp3I3u7ULUtKmEIrabgOeocvJyvUF2NGCpKIJwYfWC2bmL0AgXW+ajLcF4KPv/gvl4SM4 +WCwTgOaqEggnAoDsRQfXVlaLpsyaPMfzgOir2kBb4/5QvmNlRcyWVOEs7HP/a9wD2lSXFCc1gBh4 +pj7Uz9MNZ1M3NU4kazWj0ES9REccKnLInq8RQYIImqB3wVuwY2i1iML8VERU34SyxXpzb6wpqTkK +8QCzTqdrrU8I0qs30SCYgT1av9kul9Hac6pXNYctM12Z5mIzo+l6BAPDlpz6AbgIsOsMgQ3uv+6N +L7zIWc76dgwvSwHbUlDPEgrqPnBuh0ZX7XWgX3uHrgOmFYtjT6z0dxHAvCOB4267xjQBIyjuzdcr +bgdwjtAs2Uj3C83KI4UKa+64VVKeYvd0pcTJK3/Vra5C4syryCLPfXiSR9SDZym3F8WBle9cbC1K +EPsqfPOqMkRYXwVKg76XL0JlY3exJqjOGmi+07DF5fXaI15z1UjqqsqAfq7YEBxKirvcpxOvF0hJ +gQTPcl5KKv0fE/GWM2zbVE5Ara9f/oKg2KJAbBOBunvfxGHU+XWP1u67WDDu8h+PLXWGZ1jdYhiK +SuCweIq+krW/ZgHEdFhF1m2GXEtdon5uUWS9zqaGQW8pprXr1KiD68jFmTTnRSX2pGONttyan2CQ +HVdY8J12TkOIeb9mKHs7QPXJLjFzodaRjecQ5GjxEpcfECr9jtAlDllzC2j2l+5M3QophS5nJdh8 +VuUgRU3woFjbweF3H7sUD1GNIvaWsB5qU98exLsRSYcCr3koVBDNlzCiR5MXDgjUWgEiEDKY6cHv +Mj00imuLs+S1HTFfGVBgW1TGJaSt3070/ADAuc925PrXs+1ZE4bKmI4T19mmLeiHBbsjrpKTyeDK +Hh7pGWHDa82XyGZBDehoS+8kguzjgeX/JA+F0nxMBnBdFVrFEhTlIfGtHdLLXt+bPZriQoVSL6kL +Ze0PCFShNtY0jhHHVUPtwnNgRsvd3GmIfMjprq27iKAaP35HXp9WI8IFRz4VPwxE8ChUXKkBeMDF +ELr9+Zyt7/5/SqasOoOPwHHIRdTpWK8s/TEP7DZcPALGdT02XxcOC8EKaGdoSV3UCsXQHs4bEGy+ +lCracEXU1eibDI6m2mOMegQ8Rip2KKKOx0sesjD/lVIdQ7q0FFZec5qPvOZgJnYXhSe4fetjS0MW +6j2tfHQ6WWZhLW4jeIfZH1vmg39Ima9tIUC1ZacTqo5Sije4dU1azQywZcxTyG90/2o8qGJOtZbi +tllBHT1HfjB6EPDE4HqcgUxFv4n6FLMaFZi2nheNA6cLeLjsdRoIpfZJ1pmZs6rQ6Qoqh3oL41i+ +0CGKOph+wQZ1ms2xlZWSkR/0dmbR96P1CHCY9MC1P6SRrBmbxF++5q01E3pfwYOyVIIHnfzAs6YO +vr7eJZzb/XzPfl7F+TkCFmjWuvaW8owQL5umaJ9e4CYuiwYh/vXTKYrdcrljLgrg6F92zUC09roD +ptRwh2A81PV9YYvS3hePv17SfgS3HeXTAt2YL1L3V0UqYSsECyBcQ/UCN5AH8l2UJtq2u859nucA +VSuaZEAiHl7s+qj1mERorNXRtvi8AF2JFXVu3NalweehYH9OcwtFw/NjJgKxzWpvLXewIcJn15qT +iDP3yMrxutCJ6gH0YgquIDQoVRLFS1iUJAJDgDikjk2D3+ikxM4Ww4j1ovCNcDvNKWyQu6loZV+I +TBAhghs3lJj1mBfAG21m0EIwJW4o9SI45xbmZ1+ZHF4JGapecGNAN0uUxT6hPmszUeQGCi9p5T03 +SndtH5uZuKxLeBttXec2QhIpQiaF/H3tQc4zF7jmfJ1X7Rt1RZregIAjqMbNbDBsuSoBo7ff2RV5 +Ammq6OmlnGoiLCF2Z+vXBgZP1Rt8EFUCikqqdqLGdvOqYmBlg44t5NXeIZLskC73UG4rxpu0sr8D +SxaYvpVW4dMaLecSzlSmgjW1CuAvycphBDe29CdZ1BGXgHI+CteKAHelaC8xojXESblAI2KiciXg +S3bpA5SmW8xqC63Hc0asYE2RFyB1zF6HVfn1//cGLIMF7GBnVp7WrSMgasfMXnGDOb9DXWEuycq0 +nuiMdNB9IcrVcR5MBUaRM1o+x0sNpGxp1ydHxCCZKRxhLpI7AsRtgQk4ItCeAhRugM+F7BYjz8a+ +5dpLdgXx8OgoX8duQXWyyFzIFhT70aqSEf7yoJp6S8GFCP+sMRrGDmeuP3RNxgnl6ZmLO0RHZp1Q +zQn6GojkVliCdOdpXyk2wgbwdM6NhcQancV194rKxvoqA5FjqGfKODqYn4ozKBs5+2tqRuuSKNM9 +JhUY5EREvQiSRgLS7JE86nH1TgN3q/79RfegV0HiIcYBEDtJNxMpoyZtPmySeq47NDpe37BEckCV +DcZVyymeJbiIrRZ6tAYYyz7lRwoRQ8MSMa/VZBBnAAcj5umUf8mfYSSsfKXU7Vp9P4RBkrSTl6ig +zh1fDnadaxkjVfclVb/qpPcspu8ODgbBYmBQ0lcyPdHxK96apS/EHY7zmebKwzQisSHqeKqTOvN4 +JQE150Qhf0pxbOiDqK9Me1gtfXQQEQkjIQWK7sbbkb0fVR/BxJ1NS1hNXsIcbyizFvWhD6r5Jw4m +PGnw4kPgG6+sss7oiHLZUf2pW4AP6C3Nh1FL6s94Y07XSW5uEULWHzZEXEgEEJ0cer312j06+6ci +nmdwHitBv8+4ks9UXxvU5f2NasiQSFZI67zGdl6mmQneoz1QUp3Cd+EYqkuVlK7aAo6enOJSmG/2 +z6VCMkz1/Kcy/Fgk8xs3Zu4esYbLevQ2rV7vCSP2u7NK9lzH27V38Ea5opDTzk31OzfVjxeqU+gX +hLlexLnJgMm1wk0nQrAfMsdWdCK8Rip6Qsnco1mf2mLrCto66aeCJU1IKPDxHtmF81TH11GYhEoW +g6tKboXpYfikMRXWJe9FpW5bjHDtQoG+MeBNQmnKzmM/F1R3TssxscrIaYZYNt5JtrDocNwBeNOT +dQnBwe6hJd6Bb4+bp9ucE32lkTSzwU7qISP03GzBg+Yts43daz7KA9q+rQ/lZ5yRSWF7V9wOsA1n +LdYn+HbxPul5oZHAXCVBDFGhA3Jclam9U2xyUcmON2sXFjDw7Z8cargKge2ckTywq6mRyBnqm6qZ +a+5Yq+KZmo2ZOo9mU6Pd+MFusjZyqPH0uZpfKWpGr7cI92IxATSpkgL4f56EUuLI/cFTHHCHW15s +nRFpAL2WVKKA4RBVnYnb3mWYakY2sCIUijrwcSZC8B8aHkfLlZqrJSj9kSttYH0oaM+VgmPWmfpM +lCWUg6HUPkI6QBCO/auTDMaB1fOMLh6jBzS0IqYOz9jVqFS4nkV7OJxrbmJE23b2DTpHNGakw3Ol +C6OES9uwQXcETUY3uyD6aa+IWp7R7oTPuCKebeTaZR0/4JRMW+h+zjOGtkoCQ9kT4RLteord52Gd +FGUX8N1rD9kUpq0bnQyhmD9EgBl5RoQHN3ASP1GF2Q7Iqa6XEzuyygqqVSFoA+tpCusoX3FtvzfX +Yp4a+yEZGIBcwcE8YtyWB9CQ7Vvx5YaHZBcwOxTKBBZc0ayqI6dxF0krUPWtEgUbiTwsacBQ9NLB +bezlKIHkiABHBlf2w6baa7tX7g3sCtwaEkXNxhhJfa2+xtYRhch491OcQfjJGoKCqt1NarWplKBd +A3u48z5SVG1AO8rWKTUfF0Mwcx7aa02f5zy67v5bebMEaHpd8Av8AaerhiSz/MiFKg== + + + znUNJ40tb32wlrPvOo+4EVt1bTg7nRFWvRWoQmU6AQermx6W9SmblMCVOttKZAtoT0JdaMD+NV0c +mcpoTWHFyUyY16MBOegRaRqqs21bQTpdJLYNmOsj/HFtvO+o6IHG71kRs0a79IpqUzQXWaZ5mZHB +pOgH9sItoynrVMZpplD3xULpdSUhWBWz5RkHptOUa00pTD+2zUVyoh8xZDIMBal6tjdD6bYi10OF +W9pWwEZ/3gMuGOmbkvkZCqN+CVXSqSNbIN4a2QJdiFCjDCM6buk4M73hZjjOze6k0Aa7k5H9QHel +d0NVFESkBB+JC6lgjfipe0AgDAOIDfuxsKxzb7rb9ngiRQ3iwtnzQdq2qD9Z4JU/eW34iAji2x/X +Bb1jnNFirRFHJOYkxhUEZl+/lQNZvAD2KHyEWkZ7/JXurUi7FrPRN2bVVt9kUzssm0Y7GBmLGXej +mkamLhoo7cJVYaNqMgA3qO4cLHrA1YMaXxV72rvdKgdjwkCJy5GTDKuzluy4Tnrh9QLOY0fAmivm +OefrAuJoUC6Pl9Sll9SxmW8dxnLL3/WJpf3fSiSPD7oHfUbbhwitxc0gXiJp7MvFrq7fFoAKWiHN +LRRtxHujW3XHVJUvlF0RQRey++FizL5VuvsILKU+iHwsqJtF2XVfV54vTpmMCLzhnW7lDcEjqVLR +g3QBaO7WFY+fITGQ9NinDNJon//YstmiY3sYojRbMK02/aIrbAmMPhXv4zHtZ/PNXBhXWtvkojAd +UyxaR9BN3mQdonKMiY5ja9H4q38TGokKtNizndu+nsyRoKPaPW5bRG8ttAjrexoaEZUN3Exn4grj +ZAV7mzWizesHBKCy6QAt1YCOl9aM7oF4VDDJTf/5lnyiXeSWPaJPJzgzTc/ureTMsr/mj7JtNJWf +Jdeau15Awbp2W4KUSapZpnK4VLHVtuWNOYYAii7lprWsErzhJE0255VRVeA86mBF2a6VLb10d3ss +g5AXUnuybwtl+Jsgtii1ZJPcsZCJ0qhFzLaWkuuOnp47vnW0g1z8Xr2DQjUvHr03sTyQNMhjzyNU +jPXUKIKZeliG7XSJKE70KedMHwTF/TU52vXZTrdnsGXVhi99oeOwL3Q2EteGcBnVtB7LOQHLNjaC +BP3rvfOV+nM2pa5MtIJq1iinipoXNLDyGeGqYCnSAQFARcDYujhN/p+4hg3AqeejrEqv3byevpKC +uKrRUciCcAhzKPJOqBWmYBJTcKhFa/dww2I8NgobwiMo7GOnXayR1xXNZZuG7MzJ6mdLT1sxxEtt +Yyyh9NkQo4HYSXxy1sk2FPxExWGL4lYPFtVQ7fZdz/LCVgrVnLWV+qPIoz8nvOnf/VFz0D/xRL/h +zpn/FP/znU+mqBVKBDBnGq+kcHVWZPzay/YsgjnD3LOiLgrZb1E+LMHnFI2Ur1FpPwdc33mKqelk +FwRu79nG6QNyyDHEhNF9xcQYhVWB/bNOw6zWo7ll8BU3JWpWEaP02S2WrslQ6HTbgOuVFhwvBvrE +5l6VTLQCm1E1arlkptPztC6kZkLREqZxRlFxuLP2FNJpZ9b99vRSC7NJf13IJgNYj6qkeMlqqGub +TNUS5Azl67qFHoWoo17NvRFxZrN6ur8hQK8ATByeGsG1zZfQyru3TikDFo0iJo3hZpp9XKA3QpU7 +cmA0bjtFSXJhrDAfTmnNThEYvJftu7sOBrvHX6IlFYILd75bdEhhqIKVIFXe8XJna6YJ8rEvxPLP +M6OIEnHWc5vKDKoE0QB3ePa14Gvwh4F5j8H5OWeeychyZgGQNXYbqNOYuV4rURJ8cM5013UbPcN8 +k0RZcJiNRHSk4WdmA595iZpyu9iVHBhPqEHPpHW+LhCaeqEInwvkm0z48PvHbYAN4OGH6RMgx6Rc +0HMrWS17jLDmJrpPNZH3lhcHVDrHFaLbzApaA0FsygDUey8zQAD40ZAhVl21ZG1g8T33JvxXEV6g +m46jMLlSyfObqGrRc/pqjrl/NPti4B7Asn8T4TNEjxgB6H2lt6jjyqLdSftrtPTWUgU261R/TRBL +F31VzU9WDt2O+3UgXwDUBTXjC6ma64dPlYguYGiuzyfqxpa01g9lEalrX8VH45EnJfUxrOgtxPV2 +2SQJozUgEX6mmo8ri3CNcDcgwwoOQpSRsdlbNmcrYiKCJpNWMBCNj+PzG1jbw9u07tsYxb30BdhW +uJlt8jUg07RXJUOCA1DjqC9YruUCJLxc4GndMXVGeb5ujBJFSKVPd7mxWfeOAPQlwefrgfDUjvDU +NrLqm6i6VXQvVMJP/czpB7CeSJAYSIHBmsJGEWmgZl7SdkTbEePxf9Xq+O2YfYLbUoeGJebpNtIQ +kYqn69eIb4fkWxS016Y3wDgUj8OPjRYsfvdStW6FJxmSaC/w2gxfb5qfWw3AIhkbxXbitDKyFDhd +gsbedTZImMwUQl/bmULWmumuc4MFjILHjCCEiEeq0Jt9fdo/JIJZkXqdZXQ0l0mrMVe5hF/VVGMo +5z5vzNAH1/NmTUDlfwpaXJtgfn6rrPbggTe0RIgdZGagw4KN87UPSDnjDXyo5gP/cgqWgOcv15OA +kA/JU74Xcgyx/lFYgqVbJye6/zUPJGoAR4Xu/h6RWtAmveItXb49D1s8y1Lab2UuSeF77R+vEhhv +uyT4rid2R2fTbQ8JS31k9ogasmdpKyQhQk2EKMof28ComjJV62ikTGoE45r7kJb/1dTrX004/0QT ++U1gZdtruV1LoYgoBOi0FcxN9wBe0ECn4ABzxdqHew1Uvrh3XJ2C5sBAZST1lmJ00BnaewCLiPa2 +42CYdBpb8BehacY5YfKxI0r1AQNUHEXPoJzxPeU8/U5E8nXqRbS3uZIqrTAwj1xJwfIBB+/ZI5a5 +kTRrtR2W4s5UzMp2diGZ02n12lZwA/NaoSu8LCoOdpn5RmjegPDo00ktYh8FuDTxLHdJ13hAakbG +01LchaHCOQOLLxudhYRpjcyfzp+o23bt5LY6ijby89OWzuo5JaQTkFXR6IJS6so4rwjXqmdOu9oV +Q49rjetgaHZF+y7ZPWhMm7HVaE737S//oODdNq+oWUvq8rZBu0IREf9zueU8o8aJY7u/UMBPRCjD +OOXiO7Hechy9coGeZjkH5Yx11c78N/psuHWDIxPmCjUXoJ4zMRHB66zRVR4x5e2wtl7tI8Nb/1LH +q/trspox4hZ2ScLtCO7z6H/rzfj5z/k2gsqmmw/8nx4OGJton60pvu1dl5BuOPBrSOHrSRB5L0Fd +Zx3J25csgkEBLACjFoCR8ongSVXJhTZ/B+4TjBJaAP0TzFM0XUELoG4I0iVQie3L9DyRqJxuAnYE +86zklwgLu+E54eYd+xwH2l4rwXoA5nRoBXlRo738TjVuoOWkLUbrlKIbKIB2IKq1K7rAhs79U6GY +Kp0NRxMAOl8jsi8auwHa6tA1+GsU6UmXC4/JIjU3ah8wXNdEdsQycNPVC+6xsk/R5od9eoz2adIi +T5wojH2IWieBo7qGdIm1izND34LERLi8H+DCZq4UHYwLyc4IeSi5R0R5FXDHrgBSnKZUjNxHNB0a +ihZpdbihunDzunOeXhUEQfo1EYMFmg/WXAmyMBE0KT4bX2k3Ia0IU/FR9LidJ80MD7VreKHXk5vB +2JUqHZeZTScsGYt61o9oMJMeYXz1rKJ02Vk0hF0AoBOLtYbu1AMSRNSupK+5GAJgtyWw/yyC2xIo +xM2nJfAc3FwnpBYkzGBnJDqpoPSrclwQOuvXEwN5n0/zZL2U9jS+RPxu9zSUd9Cc5PomSp0DsZQ1 +2aH/Ds5Qpi1e2K/s6HWQUW1TIH6UeYZUntkmjdTTN89ybRg1zTkiYQt0iTwPOqS5Cq1k2i1PWVv5 +r65wdaLWRrA6aFtJVrT7XzSCQ6vULAK8oDiuYwO7QPiyC1ZjTDEqCOHts4COmC5R2LWG/DkSBX7X +8wjhUosX1CARZ6yjBbGJ4j0f3ij6rDjZ7nShulwokAX9OiboFmfC7ElbKs0+uGVo4fLMVSo+vLPv +IjbtrvJ0HkOhtyhISgJ3Gv6kefiDynSX7UCTbgYaU3m3mHupOPLzoR5A4/5rQKapbfk51k/EfPx+ +GrAM1pvgVdO3OSgW398cMG+jR8e7/ag7vkdJKSBDjvuaeg4YA1CNmj1vm+1PMt4xI44oPWQ8DOj6 +yHWtVf9lhTjCGV8X6lLYofjm11/j9drgCyYfYBVouLyND+rru+LV6JHHyL7aabqVJfZK0ExmnNjj +8n6AZQmuqwimAmK6pVajUHrfviEgqazurUEDZCnUYtfUC8e1fQHFC0/hO0ewv3Q7becEXmUFXIAY +NTAbPgUR5goYRkMU4amYMK1RY3dY1jGdyYqwzeb9GlX0/jzRazNKsmlN5RxOnwArbChVzZ6hudUa +4kbRiBl032AzVXKdosxuf1kwCWuihQesSYUkoihQUaW74y9gHe1k4WghSaf5xfAEv+gpeBxusU4j +elFGkK3g84VEKHGeAzX9KOiJiWMj4IM5Ny55UO49A5tWBJVXWIOh38iO/pwbo74lOJrGCGa/lgVC +NO4/5dh4BB3WwzivD4j7wzzp2r1k2AhreI5tj80Bu8sUQkpLmjUQkLn3QVczeK/r/K6uMyJ9Srpz +OnSjhhYDM7pLNZ+42q6ai86peTqMbc5i6zAgcKHenfeO6yorIGx8eIB39EWTUp3ZkkD9APkoq5+R +h8QPRHg6ZKM84hgtgimFgb17Nv2OX3fTJIn0EiTclAF2PBT+CyynKzjsqDtsxyaBdI2zQul47+TB +tFKS86B6xRArLvnKVyaxOwBBIFllH1Amj3olJShwTW0vgRp7ILEG7mjaF2/2GzkwNrSflI2VdW0p +uTfFQzQLsxPecEDLycjCBCqQbFHxPpg+KoOC1Mt8wDYnKNp1B8/f0XLJ8g8UctecPCgYGKQadbi1 +9R+4G1WKXNOS03rIU4jK9fzTPhly2vMVATbrkjMDsB/ADnDDdaM3vAUBaGhO1m0YcM+XZxMZP8UH +8aLRsZbBY1vhHFu5p5GVVFiXtWycza8OcEsvQ6SvB88jIt18TSBea6K88GbJgXMbwOQ12X8ie2oC +86ktrz0rPEx5BPZb+FXONX2cJ2zbiM08jRgP7JxBSQdAFxzsVw6KYAROEEMgntMjjs0HUZIr/ZsI +fGuqC6yp3muT/Osodc5ndM7XaKLnEm3xhlgNKyg95PGhZdJs7wf2rzudLL4eVFWiBZEDYI6f6wZW +AnKYSeS4Nz9nfc0NbRBUzPuEWDJ8qgpWa+UQV3tG+hFG6HqO6226AB/M/FV0Es95b6xgOql4XY7t +sISc23r1NEIkeyxHeB4cQGuO3h1DxtO5Xq+L1J0AiYhqeWsg819nCMXCEqgXVXHJTbr449PwqwP+ +yge+JYE7BaJnGtl5xjArvfba45Ck4656/XCgBrgpSGJX3T4PUvnkGR/rFWqqlWTCuA== + + + 9pJFy3K94xAzoI2/HfArIoDfvvmUJpUZ6XpGc8+M8OfvSjlwayiObXfmfQypkgpJCCD8XKPs2v6h +196547NCLo/+LUZ/bweesVuRlJvoil7ffJyylhKA26aUdm7XF2Wd9f24yXSJ5j2mlK/S2B2y3Yrp +0aePlMxc+aPlnfroDYEcvVRpVQMN3g1GNHhTqrP69YDPhG3jdwcjeHbvhbUfWVhXAnu2oAIAgyl1 +Dv/uUSVEKhFhghYAC8FTfhf/xmYXOACOEIjRg5GI2PmI2PmzGzoRgSr5lBCLovmvn+q5qbJTT8i5 +tzclR5wDsek4eem3BNaktj0iA+yzq4K7VB6brMtrmTeBWc9prYRrSbz2sPNA3Qe2Qf3Y1n9vB+m8 +mw9ABIWvu3YlF5uJzwMlEL6C2s+eBF8HO6I4iDSI76Au4B4c2gLqgmi6qoXd8RAgoaGqtztf3LCT +EQc1SFGg9uJTajxwAEF6DsD+8wCdKyV7qapiWDE2LdeDJN5WlBCP4l1ZT4wDZhfoONGzRjyKmp9P +zG9x7m0l6pN7WeJrm6ShUY+52voBGNEfXSJFV7WpWHxDDACS+3MAZyArYStTmDsZfB1UCG1ECI26 +qN0S5tevKvxDK69v5Pmf4YFKQg6qzcBQPwHNHGZm6ybcWBTAMfhjsKW/xlYI8/FcUlJ+ziwjs94f +O/JppVBFW9N13FHg3Vo34r1dPwXSqd7A1wO/e/oOp24bgH36exQ0v/AJMUljUSQfpzhOPo4G03vE +dzP3W1S1VcOMNABwYBy2ZcxXFK0w2HLnIVvu0tVHP5QS+Jgg97n5j5hg0/H/eRdnd8m0hTEHLJrT +sF2lLdFQfBAzjpg71MAxraRS0oc7ckLhLbKx9IhEjArwRHagxzYbJeFnokLWnr0nvomI4D7Uh7cD +/7J3yNnSX9fo5f7m42tqBGtzc1OoaagsSAKKsqBef8Ct4HKu3Tpb4/AgmeopsffHcsGotqPKE2Wd +4IIvtc8j5OYQOpyIuSO0Qm8bFU2EFY4S0T4isPHNlbbHM1ofTAbSMo/QMkGUG8CYGnQ0bgPipGi+ +WRMA2W0FVGZiI9ieMf+RIj/XUcOaWpVG0T3IO2Rm8yyPn4Zc77WPJ8Oi8oH+IlJ2SKjh3Lg1LqE+ +hqgDgf7aTod624w1OktKnNJkNe02Fd7luTViKurJmofTmqCuIfj/3iQsoIz1MbSDYK4cNT4AZ5T1 +aasRNaJQdP+EpKJ0FGVZPA8L5TrPYdPy3hgUFNxrbNDGVV8XuNSSWDmdah+agrJf4BdhxHwXoX4O +qyVNJS/AGscFHp8BeWwsEk/FCpPZDuflOAM/hSdZNcWYvmpMcUNzdll86G3oQY4+z2ZvX20P77Z2 +mYqXwfNBKBtYu/3IluIpMrGP1FqzDki7H8Wo94j1ROltocs0n3KzUXNHiWXY9bWGsMDm5wQbN2gk +VG1cA8tag1FaAK5tTD6UaAachY5+5gXM9bjG1vqX3ioTauZG+drjihu1mvuwbXS4YBJk7V5v6RAE +f0JXAsAHxl6CzdywtwqF7GHG9jQ8xiXiMlEoLbJGi0JFY16ne+6WInXdZSQi6M6SWLX9SXFaeLrv +ZPNsUVRY71FROM+bYLxUi9h+2mrXiqiMKCKiSYVuA68w52CIcQ4R45BGVcVY8zty/rnSCE8U3PEl ++qo9PsalyiQ9QQizFoEk60EunGjLrDlfhDjkTknLOCpZ36X7Jjh8ZTYvUsho295xnfcaT9RIFFQj +Irp0qZWbnDUGxypBoBQ1JYm2QA5OhL5AvaneAQKI9ef+vJI7ZdpqUuhuuHY9F1AEYF2g1XwVNWVW +BG0gI4YOdHz5koig/hSUKa+fR3Q+atqNvQBVUOa5Nb92ttBFKlDRW4QivggtLVtQz9cTU1NE8dFM +sqAettxRgwbzqH6/nQcSntUXKqz7Z+5XXEp5E4EHaRW+dk9CwfL3YJHbFlnAaeDur88gdSKQmQLt +HJt1CgADySMYem8RjH8SuCZZ7eF6fo0C60KVAetDclpKnvbUaMoUNZLK1lCBVS35Vumorq3R5AU1 +4kxE/cGbPSNFFs79zXkYA9AYGCkS9HpypDbkX30T8MVG9jWSfgxCia8oi6xeqi1YSiA3QrfzipOo +uz7YZhD2y4OG46EL3D/tdXz+IprQNjAH3YPqpZKYamfY24NTX5lvS4SwBJBtm6L1IO/4m7nMiocv +nIO0adfp5iHBveqg4E2AN6MhI3KDA+AXfJHvCFQpR9zA+zz2vL1lvTnbFKaH8ZkUzEpOc/k8hiR5 +FALO+K+GygunCtzCKLu8XhQreI/Ig99s1bePr9nIQjyV9ykBbabE1UgT6NG8RfjLjvyy4xFzfYsC +zO5MojDuvW+050bPrZGmESguERsDqGEw+c4LH1DGlmZB8LGe71HBgdyaQNp64kkHedHDLgKPIH0V +BiSwC1RD8QQPpOXaMBIgaCW1StFC7WhboUyvIQEgt0TFrwXL94hxxYqAQuQLl20U9QqixN0CLYML +d+h4FLWVKDvGe6juwiFba/waC9KAbmYKeqFhH2/JpvWFHqfksY2vSGSuEiU+TfHQUUeYhghEhIlg +c7K9snoOgPKlSXdcW1sPUDJsxPp5flfTM7xh9Vho2Rcq1TmJThX4mvQWhb5AhZlSrlwfDwAimgbY +7Ug7Dj+B65ktYAO50WnIot6R5O/p47ggAZQJPPWwB/A6cHQt+jKL5m+yLehhD7Wxp3yTbIealuFm +deYuQ614Jr1rE6CRiYai8jUiQ//efha4w9TxzXkQGCGBZ8mxEYVK46jfHKC2Rl6yhnY55sPU/hL1 +pqVK8/KQtrlerHkGerxRsmy8TvM8Gn0MiMEI/RrwmiX0Ij4g9PdvTrOWwyjfrIGsbR57XMBQ64YF +pgCRUYyatF7Ans9dZsBg5O8rQaY6jaK3nygKlPKGN9QG8JbEAgABqG4MVUfIMRhdR9Goj4iGkOZA +QeKZj4ii7b6irBoQpRuXRcsr5wnxCUExER9lU4WKMtZGCA7Fl/na92JBfFhFfoQA6r5SkY9r833E +JISu/Un+yAKJi+3mQf3qAIPVr476wn09K8OVtNko2heABaWKIp8wI75yx6bC3GL9bnKMbWTrHnGy +Fp3vERlTWxDu7eNXj9j3QAODKgZuT26t1r6YSr56tJL+q2CRuhlv9EvXre5NEG8OpDQUwjdUP4Ds +taFvM0CaWOKwPG4Oa3gLa/PZZ56j1ZCBcNQITN/iJK57rAU/b8yNSRJjZ2zNP4Uq6HFgY8XM0I5Y +fswzthVFqVGYxtD31xR7znMHzAQ8I1X1Y5EuvN1H+eY0ZSu2gCAeZW4g4iVAcKgz/BZRHgYd0ifX +gyF+izqiLoqTkPnlsQVxOpZFZ7xP5HPi3tTomfGV7jyqqr/G2oMe40GWaPAKRgvbjig7BzGJd/jI +x/Wv7loDbplC0ZvI8bcAjCj6G2GJCu5EWC/0LT7tVmImc+Ebv60RRZOuEZ/5p/6UwX+loIC49PVO +/pZ1cyjRvIbPg5ZHCjEF2jbEdR+PGjc6ADNwtBngW+TUlb52nEOdusp3ETQCTgUrD9TrHuDbl6ix +9aTHOC+f4YazUrxQ1xcoeI+wUPRVUFI14kbhcbxHpPRwJdODLK7Y0dcogc7KaECg3yoFAj9Y+ZUo +XFPMpsIdSbFEpea5kK/sN2ZuWE4gXomqV6IwJvmrfT93XD6nWzJ7flW7v9OEmarPmQdga6JDiC7j +dcCKi4xaxL3aD7UiDl5Q6ruKHxNPARQMgn5XEqdZWsCshEVYrCTaXKKSzs/tEXyj6N1tZhwrvOJG +Vw/ra8CX2J7VIa7j3e0P92UR9ZxvUYg8kIP0U6ttZWNE9ZwaitUAnMlrunKDXOneOfsab2eZW956 +RN56btXCY6vwgGS72LlxZVlZiG/QVJ8/pS9W7w2gpqSh8LMSXgo/K6Mp0PtpqaP4LccYTuC68YvU +Se1+MmBycK7Yzk6XQ+ou8j8I70CREWrC3gn53msLL4EZIW1u9/qpaEqtkaEU1NcDG46RWsGXY9Se +zfRYVC90k8jD7azsA6iW2fC8xUl4ttdBVl7MbGgowjds2NaiB6BdCAWadUdAHmAZnz0YzPUD2cOf +VN1+DuIGDkAQj4BUMfClEVEfq5IpmPbjj0Jz/pz4H5m4f5SN+yee7MAqdvxIsPV//C0Nmo+/+Lcf +//N//PGLlY9//x9///v//fEX/+Ev/9vf/OEPf/fP//jLX/6fX/7L3/z9P/7y8+//6f/98vv/9ct/ ++tu//8N//uff/99/ykW//8R//7t/+ru/+cPf/e0v6xK/urn7dQe/QRr+r/w3KBrIAuKGSQ4hjaEn +5wqMddAHG4xqBaNTsVgvmRovMZup4sI+AEkOLOWAA6zJ+vxgn3KB5Xv+7Kd0H0T4BXb7t1Tlzrp7 +2pwA0Ht/dLY8Ct6XyiWD2AK2tjIJhKku3p+3KCIoWxMxKLh3HcSquG/Ya0aMlREbgX9Md2O2kU6H +YCJ2Z912Rqc6cNNpAbS8VpYuKBVfh9vZdU0NCLFyGjSymi5FInP6qc8agGg9cXMBgCq4wpLiD4we +LqW3CGJD+GGAUkEHft3diLU9AajK+j0ScXS9mk4gYURswRxvYuRPSOui+gNlxbsjtdyw85qIExeo +AvQoEes7Ckxnfk7EyjeIoDqWCyC6hNAqzE4K4n33Ky/swJG0Wz803qOWmNrtFzhUwSG/Fzragcxj +e3jjIrjSgD7S2V/fDjXRTN8d3HIf4BmxquJKQ9j8BUsNFnozv10/yCHdYf1YFAELboonCwgUCPbt +6xZmZFcuJjFyNS6AD6a0PmiN6wRrXoteAfA6ieoNixWk+w4vgrB50Y+UzKlouT6ZwIEznqTL60p3 +FYNDTQuF1UyxE5XTifGlhkSJ4teZ7Dyqpzn339fW3E+DSvFASAmnDHYjAIEDYUC9/3V+yHtEKSRM +FHhmojqi+UYM3FzZVZbc59pLUsQOl4A7gMZ4aJWQCz3i3BMsHJUGIJ1rnu9sTwq3eSp0vz6NMBEM +LFrWvCWqkso/kDmAizMbm/13zzq67yEQBFaR12f6I94Ciok3WIQR9SS2EN9HIAfOz7t+vutZ1r4G +3cVy9vrGmGM1/VqDN3gG/I1UEK/6qFbu6Krn5/pyIPe/cpBev/kU5c7Tnj8bhtvHxaK3bq/q0HQe +22uNPfDJUzn1B13fEG/wvMpGgUAEiRwPmFPkFVE3P70RseiFK8PvMjLjrDHVDm/lCI5ova+IxCSC +SWpSixuvC0kRReCZYU8QfW6CYNN4mk77W8vpkoCVSBBAkmvAevxHpj4eChEXukgT667nQvBezv/P +2rvt2tKt51lXwD3Mw8CBqbavOoQlhCIZgTgBjqxoJUiRSBwFY4m7pz3P22rM9Y8+4oUly5L9e/Zv +VFWvXtXat3k34b0w8+sY43X0gRAXZSo7gaXQCkYfhkVp3zpmWsjmdNlAHxGP1dLiQQ== + + + bm9b/4coFoBdXdOWUoYZri8oXagluw7/NSgyEFNc2CUecARMjoehAT7qHxF5zBTQ3l+iDbKwH45j +gsXTNR2W7EvoGlh8ffDT0/t+tmBeiuJgU3hg2YDZ30m605td+z0PZKHRA1ctKi/uZw45NQMKKipn +xQN90rPpgO12ZRfMj9/QrbIzKTlrbVOyjw4oUFNxB0aV4Yc0Y6RuCE7ig6rJXNPSiwh0N4nAAzxQ +oQv+C+Am1toJn35I/+ChPzdzBZG4owq4daJ4U4hCX9DjBGzD6rmLZSMQUSDiKYerhOwf6MyaS8Gg +gQAkbs+727AsRp+fXkd2sb2AErVfJA2zeWcH7yiAxZLdvMMaLeAvl1gcDZvJfXFZ+ojwTLc4bpoO +4HZ+OE4HYTrgZ+1vvovSPtS8ME+5kqeU+2JNNU+5zHXqK1ljFOs4dxHGq/kOapvkOzyQRPBdBeih +6GvOxJJszjSTM/3Tudebkodn3A8a5kY9b7of0PVY9PwVDDNV46kmj1lKALHjXKoV6C8JhoZ/KIJA +9uYyn7xgtM5dPHZu5eKxS+lfA0334+fFZ50deAFRrH4GH3jfS3w/2ll6HPbsB2z/tkTsCq0QgT3n +WSbbWSZrjs8SREQpZ2DHcsvDSBQ9TKM4LmQWhrNn2R7LZRuXRCPqfRkxiwF7p2EVdIyXE+Fny4nm +gV6wMWVd10GF+6BIEcV28/XsoL+ZecHugE7GcoYQ7w38AawpmxD+9iQOMGC9tNslvEg/N6PSSHs2 +ZQcRzO4igRs3E3HurJKD68UZ6Mo2PgptIrpAbnbq2KGIeRfTKrAa+RZ0HZj77KyJ3akrvM23gADE +NvicDZMq1O8Lhp71RAgMd2WXxdjRmK41J/778Si/T6BeKIJbpMHoUpHYMxCY59oqwl1kGhrDEeET +pwBjroAfAujSRSPNEzEOAdbzmht2VBYl/42S/Nq+yQV0FVXD6a60qxx6mrTtHl8AEjAkdXyH/9ob +8qfzQu2syG1oXzDy7WGhqoN44Q92h7JPVL+oJGgguyHXTH6RisCsy+P4cF6gUg43lHkQ3FDgrkQA +k5IS2msooa9ENB+aUwAVlN4LQWEXRZJh8bwiArgBEbAgEyA7FV1Sbja9vcM4VYeH3fe1uWPogV0w +rCUzIOTTK2ntQ1N7L3qs/MlTZ4ilcBX3B7RZqCYU+HvqZ4QngPU2apfyOADzfhxHbmK9qCa8XnM7 +dDCY++tR+dDPXWq0XmXFbiEcGQwFD6DdqEuCQI8bKXAOWW57y7XR8ZzH+0Ef6RBzlL8t0LpJxh8o +PWF8K73EB28+kc7h5K81yjOoyTVaIbY+y7IFigJ890Royq72Y46P/igR6sKErF2kc99vMvYMV4xn +b8ulyo9uznR3EoXL1X629iINH4vN8pIftZfDwWuPsgGb5d5QlbltIJwOPqDjg1pgS5DJ8iFOCWCz +qJJ8LekCY4OEufgDyBHaCAqAF+4VP3wOKaFSPlVk1s8z9Rl1B6YNsxW00n4u9y9T4KLVeQEpZaFd +GqiqBu6+V5s7I6n7R0C+D+LQN1/2kgn6eRSmXkyzGZ4Xr0NgDQM11M0/A3au9jKrPj6rCqt5i3na +MVmD7nNRtfEY0zWDSEyC3lKikhRQopZzSLxeaQ8ghmjt90SQnaUBXXcjkFd6IO7zseraZo71nMP7 +BilrnSp4GXC/j0/XQwmptxtVxmaU9l3KaLD+S8Cf1O97j+BxJwJ3BKxOgcUQ0exJ3ChM50rFlVFv +j6OK1ZTHZQ4OTNl7xA+woEAvIJr7FyFJ5toeHsueO8ww/kJnf/4UcKzYNDp6U7WPqGcqYOo/IOnB +BUNw485IDvdW8VLwc8B3o/mBsgnTfU3XPyLSRGEUr2gOsIr+w3EAvtnjqahf0+sYUdmmVwsY6zPi +Porf5EFfreLPKMwGhkAfJlf7OKrFjzt10PBtpHPx4Ojd6CVVio9qkd9w7LnQyGr3afeuv4lTRIV5 +VPzz8xww6th3ABWlFnrTnOjCfjwpTajEhMX3qBRwt/Pz7Lr0KD12QZN7/aCstBS4R+Zml7AHm0jV +kmKYzHAQx15Xu2Qbd7zOyUipPlGp85taPePgUgNEJoqWBdrqUHs9TnbkxvKVoqRdKW4E1vI0xVSd +NPB0/iBvwS2v2vAgZOxXvhAmOr/NXEo+EXVhUU0UA0+ihn2Hyezx1phGnyUjXOP2g0+iBDb0Ov8O +Dv3Sruf5Oj6yqTI/QLZ7FSTjXAVgDyPYNm/TvWqEivrXhWJoroAix2PQFW52rgqSX+i2vt8EJi29 +UA248gIq5MreaiJJscRLfFddT90VFiMtRJPLnfzkn86E3iJkZ4p/AwboHgpskNLsdGw/lADISGtJ +mQYjLfZ7HmxAhbQElORT1BcSC9T8BzuwI5QhBZe2MndiUGiyRu49Xis4uzo+kwjAnZyUqEIpOinm +7ly0BgdGzeZxbNayh4D3MILdmjNBcBvW3vv9mNzilv6RtONLuOahuxCV9EpDiwsj7zVzfDLPiYPI +leukwiCiQdryGnsDUrvWk8xQ+SvMetvpNwx1US8uAoVDLrMF7n7Rbd0PzxBxRI+fr0b3FRl1etYX +ixKMJOxQWMWxdYOnhdX9PM7R3G76qvvPGbklQ1O6fGcZ8DU8QX2MYE+Z39OCAVSJbWlvlMwSG8Q7 +HGb2VV/zevnOVIN7oaOcRQCWKEd7V7PWNQDzNNq6TJsNeLLDLuwLjKDuJiJegxg1QSJoNkt/n+jK +ZiTx5gJ0eeUyx/6J/HNEetyuRq6g1Pt8EdSY7AbySMC6/foCKwMINIGuJ69SEnlA4ffjg4su5x0r +gG5Cou2GYB3q6O8RHfjLAVx+fojXse8Jri6VG7DvCA2JfdfB8fzqikvy09B72hnhwL7Sl2N1bdk+ +IjwTxmsVXc0HyMdPx7m0p++Qvjvt7v3ECiC76bbThhkoQ027aQy+udrh64NNA15rrtkcZx8E5X6U +9d1Q2CXYUAZbzkDO0dKQTGkxFRpi31nHmBrvr4RS0b1vy31JRP2I8Cs1Cnw8BNky+w+HAfuaX/9W +xHXvKzuRE88KDrD+EAGQDg7eo57Q+3D9IaZhQm8OvRfVzkPaoDExegaYypCWGZAdZdJDWw2YsYD0 +w7j5hwBPdEX7+2YUyDv8eRj4S51KsUV4l2GA/IRrINX/UwTwJvjHlxyHc+c+opgvgE5AhlA1BKZC +j8UL/PqddJFF0b4h3aPByw/jFvQt4n3YKPV42DqOOD8cBxgMdtDgWGs2O4agqFfe6CbuffVvGEjt +CLwrqwMmITW79qa7fc70nHXopodejBKeQzN/5zE5ji84zRBLwmOisSP2r3wb4ZQSPXgQ1kRUSCNX +4dbdX2dy2jnjZ5AoGBuXK6eHqTRnaMVKXiKgmYkAZciJzEfRrGrnKyVrQm28vl8JcVYe/r1IqWbC +kkIrkBrnsssGPZEnUuGFasTjNnOxNuZ527fqvO3mJN8iciYEKNpPf05yZnPt5hE3qdKeZqfoYOB+ +CDh2ixeqeO+G/BnVg+kDPykLVH1+mmAXCIysz8lE2t7d0K4AucDImG6WlP/vEZ4JA3V3TPTj2w+H +AcTGbqlrxswF6/F+HSn+z4joNfBExj8jJ/oW1QOFpuVrwuwFPxosPfatrKCHCJBBP6Olo1i5Lfu5 +bX19RrzvaPqD6GSMzyBbuJ1klHkw3XeMST7/2fIK4zwknuZ825zfo2BO+VYgMNCLK4mPIXYRQKPh +kSpGQhYLM2EAcXyCRF22ub5H5I4NZSjuqR98/+E4jYYaAo9Dn6eTlY2TlXHH2pPqde59DhQnSeZ1 +huB8CBKWD3fO2fOhNT918lj+OSIdO2Iu19XH38yAfXcNsErfAXE65RA21Nhzv/abR/oqUeVBNwFg +kBvBJI0dHgcFMSKu5QjtkEL2Sw9h/VeOcRsBX8qINd5vgrAACybowztsZn+UcjH3gjEOjHgnCBNd +RxnSvEA7+S/HDWL0riQerK4LnaePiOxptxMgEpv9bv14nOe8UfvMQOtQ7KMvohsnJcEPEfehy4vc +vr9y2T9GIRylPB2Q5nuZEqPTdjPVnj5op64CEA6Wlu+Ezes+OzoG1Qgdcgqj3TcH7G8iB2LqBKnh +BtprNA8z+Kl2RCcVbnqm54NOMo5OtpoG0jjur+Nmd6g6kTvdOx24oVa8xyWb5MzKKOJ3oNrxfplw +AfXavAkoQMnc7um+UOit10WdWZPVCRdZ8vODdd1RF4nOL+oo2wOMwtINrEEyFqhh84cAdBabcyNk +ul5Bgu9RoMtAwAOaXMlqC7j6STkP9sIJaLU8YsC6vwiaz+Xrg6/Hd2drPL4V/fKvv3KCRTGBgSQN +YbzpJJzrrorgQRXwQEMxx0X6x0brhaRt0GxDBiTvxwTfsnzi7LIUSA08tYVX/3IPnlgwMRFOs3X/ +lwPhlWtkjEcl9T3gz+9ITUDIWkOBlG9BtNeZRu/yeNejMyuKOrhU/DcT1Y+InzbIjyj6mxJdHjkw +gGgGdDxmIiQd+9QlBpuI+2LI4DCjikG5ixNMFOUEB+D9dexwwOKckUKFx7sPA7qVOWdX38URNYnn +jZW0PU98FmnJTx3pfnUdQh1TI9FdbeLLZ3/8t3MiJsAOgugOrzRoRTg5KwZVxGhw9a8P/tF20pUl +nD2RpujXX+khqQKu9pNuytRHz7F+s6EFYIUyDQ8pO/4gQNMPe7KHqaxlSnZrn7Lz0FiuJoKOGRF2 +nbOmJ2K+ET0RdmCNcOhQr2MqQxCangShSfCLPin27fRJBZYbwQ9JVjDN/R55skSwGySiDFtznc4+ +EUHDoP3XDxCrcnaKHKRMVo7THWeruMxxYDp4R9aVmynV3A8gsfABusD+gtdBI6TwfE7haS4BZ446 +6MJzrCND7VHBDtPtwivLBxG1Baae1xmz4R40naUPFQHvx9ndO5FgbjvyIQJv+8PqSAxrMKZqz31B +DE3EBN29lHsxwkWC5r99LMDqZkOI4B1xaKJsOiCaeN8BuCHVSNRil04Evw3jMwaEWsE7cgfRHxTA +dEoP5pZ7imIDCm/Yxz9vy/ACLbgf2kf6STdFs6R2vs9PSh0UVfsHIL5vL3vUDeobBUEQfM0BzU5U +HbdznzGThM7S2/t4XYqp0aJudMh4fVFvVRQW+0WAkPgTQWMHKs9xaZChBI/45+fnQyLFjfZlfeGE +34P0wm2Uabu6fYZPUPCcBa8N4BEtKAikL5jbddTzyFpdfmgioJhGI/GGRH28nXitM//D/fsOcCRn +appUdq1hKRAxJboCkHRhvNEFZH7dnmxR+xhAlTMTFbsJS/Z00ohyjLijur89s1VqAgQ/GWoQgf4F +ERDWEzEyfQU5YAR+G45GOtg1ziQK9YID8XydaTiS5dfv5VxP8c8tcfBKm9eZzdpof/IY+jRwd1cV +lH3T2bsO97DDMO/XUqCACokmMLQOGtWI1/EjPR4eXTQxLdUZKIrq+ATvm0OGSa3daA== + + + TRrg+nnrLHzO05H7ez9s1Q/Z+/jAjihCGXhFEkErnYjbPtG4go3ZEbL1vQKWtX0F5S02jWqYS+2o +Iua1nmenacKTM63iceoSjltlNnlt9MD2BzIX/KAIYi03CKn3FzBLBF3MarBfTTWlOooEXGdPEbsP +s5MzH9bzAUKafuddl1zX++icDzH/ojEOqFqQk0m+YrmyXPa7hdCePK2BNwSYIWF33/49zfkrIMbv +fzMVc+K1pF7gtSzz+fpnGMM7zWMt3AvJucDz2c4thTmDyGyixegHFpVaYAn7vbEovHWPBEKxb8xD +Wae29qifEfnByEX2fnRTEc7+03EiMudPimQ++ACRMPfesxHt+yECIS5OfYM+fn4/Gn+IatrNXr7+ +lXnEmEnubz2XHn+6blZyped/I4rPw80C1HxZGw/g77u+bwdRaB0QxISGH5x11sOIDVLgfiRAQBwY +GtYNQJf+6IK1TkRe3p3pvNPe+eYx+OismqthD9NCmN/iA36NK/zkpkKdLQng7u4AdvlfLABwNG6X +8uf+OpENPFAmTdh8O90BLPz4szGVDrsxE0FLyzyG45DHQG3lMc1EitK5fQZkWfiWtn0eBiE48Yd0 +9r13lG+2k0ZHO/gzwoegn4fgRXh9RFEomrNOREDGueB1LviMEJH6YYTonH4vjTt9JIfdD275IeLP +BwvnCGYhwUHm8XEcsFHCsdG5IEKzcx8qDTLEHDkeWVML5F9gXrAw1JeLF/pPB7skxkrn7SCe6rKl +Qz99ndY4qHpa42v8ENFrwGaqjLwoiI8oxFzGAVDVKYAKI0RRX2wJ4yDc98nusCFICflZsXie57ce +0kMnM11FPo26rAl2KkJyMtSMdurbZXxoMccPScrGdIIILHJumGYjC5sr2g0tefw+UzbLAaQuUQ/J +5C5SoVV6HA5LxGQwR30iyv1GCa8kwpqaa3GjIkKHgf1cvp4upB9CNIDnXW6y4/xyUNxnxsO299nL +HMHcccUFHVaXI+bvEU84kSAAkU39GvD+IYo5CO84c5BLTscIQM8OIQvrVGP4dglfpHf0n+F2fET8 ++SRN9aZg2LVQoa31cRzUnWksPkVbE9u0dKSBtk7JYh8RyLz3L3TCHz4DgCgMF21TYVvKK5Kzo7w4 +A8U/cG/GT3lR9upO+tf5u8+Ir0UF2grQTC/84zjoPsjWUfih5TolLivrt7LVDKlA+x0p97ndPbd7 +vFP3DttbPkCfZ8YF7OvGgsjqjgC6tQRQcQ7lMYoRw2eeE5ndIAFIGwnzXZLXHcGg6OtEWbbPEI4m +Lx1Eoq5yLpj1hgh0/u0CX+QAgHtKwHXLeRxwzifI0/27FSKeL6TVePeHKdqbhgaKpTCiWKD2rRsn +w91FeruGQF5JTosmMC/K9wie59wVGDpvofYRhc4Xg3Rcr2ja9N5SDcCdZuBBl8Hm5k12GfSz2AD7 +M2Ri3wLy2PUsMruaL0KGvx8FvulDqYImRwkMHxAAxVSFjIEeGGp+fT2HVMKL9BbMpR+E3l6wsBeA +wRL2AXDcU3IF873XJOH6dzjaoKUH0jUAieyxPJMnoUhfWYe5xJ+zFOKMu/ez257RHfARrTKU5OiE +UBBYmLLGDktgcgGSEP6p9s+IAKG6KxhjiP2YtM+opiKvGLdKpR1ML6deGg3/FIFEm2Dc5QTunOkj +6tFYF2StI2IwWOL7nwcYaA0BSlgxIupMlZkaPM57SD8TUb7wdft5IFlD8GPe58OArSeSEv55HgYE +Ow8zKpjgQR8iN+20CXgYRphE4XjtlefIABvlo4HSgRdaQlfbUbPNdK8g0klos35EkIPLsi1bcy0D +/DXVZJk5hi2LvXFdby/VbtAUqFqTD0EvBmvJ7EEzHFwm/NYPGN3b22oWuRCseH6MWH/zmpb88GG0 +Xprob4h7z7WqCPj9HFOpUO8Ov0E5Ebee0p8RuVc9meKzcgN/OM485D9pNMXrA2N1rxnBHTooh+g5 +TM2+o+h9UWKqY0NnmkN/j/rbczlwNOijHJJdJsNsDkXYu1ZZEqR2Qc4b/azM4PbaC7DnM4Jh1nSx +3ZvTfAuojyiMy8hVEC4zTUKPSNaHU43mqEp+JUqqNr2wLRjIpeCB+lPEW6rByKNPSmP3h+Pch0a6 +GMA646XjZDN5Isv0GfGxPSe5/R6F8o4kB2ygWpLEbnObUYcLVzksgp3/rpJOSkqHqwFDdcF9yktb +aEGb0LbDP4xFF5QatewNIRAYAyNEuslYmZqYyVvAcWnVTH0v7ddRpjgFaTVt6Af4525e3PvAVZPu +KRWKfxTaJzkNcpSIIDQkNzr+gkBb4OHunUKuPyPuJnsOvHzN5idyCtoCfhC1SJa7WYCkJSCjJyUI +QX1GE/1vxN798Z8zR+lpaeixwnvx/W+PyyWpxpAJzCBhpIuuCe5nBNAXZnLoOvR3tvURRWpw44HR +kyYPf5PhCt12AsWlyRocNPkBEQBaYUi0H+z99c9d1kp9J9V796OZFsQzA4G9Hy16xwN22Tq+sRiR +4N2OBuSFs5NX8Ffwfy9QUPL/JwW+QEn/A/eceQbA3wWpUTYNc3gqs/2e8+7+hxMlQgiR1SLfpGuS +dmN7bgrJcZrSZ5C5ixEhFA97X0bIU2DYFjvynqbo0lr7LI/POogXEjvuvZBy2JRIXjA9RpSGViSt +A6TvqDEoOXD3xUL7F09hUrBrhpyG8hJiuk372heMAQaXGOZnBrmq4UvGcLnU4JTp6jtjom5l0qN+ +ysppKqkObPt1zoMQcCrbvzgRvViihqhooqQXejdyHJy5iGi2X6ZmP34wGBvzAQBUvwjwDvC5zxdS +Bvwrufquh5BghB+prfSuphczqoFtQRAQcij9KTBo4aeoB2kWmiabaXOHGAw3/nQAMpR41D37708K +AAR3sX5ReukVux8imu9VztbODB0378wVxvWgowZzhH0NCRhLpUUacYHOPwNHnM/ZISYaK+0RFtXB +ed4HdbT/Mf8qrAwz+e4YthykAC0roRK7WL1YE7GlPew5oiRNTNamkfvuNFT9c/Bkl4AyP7A4wRiG +mmey+858AGbzxi/zzeOM4jB8SI96oa22E2YHzLcnpEf1nIjln1+I+xAhdo9kN6CmIIw9wZtdCcdN +cbafMu7mFTvVWyfEK0AIWzU7X2qthPanCwzdasFNFez+Er0oEZcE5a3amZdLnZ5q2Vfnw5Zpc2jg +KfjAWZadCiEiMzU5Qi9YdjHDDgTqKlNEQ8Op8zWWmcEcoN5Ij9hVvnNGhgcuoPCNpqyrJ8iNkmG2 +5CjKIhyjL4BDZ5o+Jzra79ZwmFJIZGMHz/eEVkx5i9VAbjXkuRmvN0GP+wtTAEs39CmzCEZHoAiL +ZGYG6nfh9PLiHu5sjJQZtAKJwqMyYqQO7e8DPkQcbCWAbrKNZgx9UNNXb3LXQ5okcaKJ0+uqmjF/ +YUZE8zKfpIIF2YP+wuS5F14NU/AC/qzW7FBrjUtb+6vXXAkKNR5i8pwgAAkSna7SF1S133kqUVno +JXBQ1/aJcCodFIpg+kdwj4UJ48bnV9oVNmBBfn3zh/3r935AfrIrpzId72NwB1DPW1p9T+/0C6Yk +fvY/Zpj8jhj08o7Wkj+ZWhDvfwCUz8+2Q7GOdfG5UUiefMuz5q4rmxotC+BWg5EDs4i5C4hLN6vz +q2HqQ0rtvRpT7DEmfz54kwkXatCmUWC0aWRo/7h+Q9Nt2M63DRXJYxYTuInD/jjCwzsdF2A9srS3 +HpbERCVLc4qhqNvtwtrT0RwaUvGWjaLksi86Ey/wTEybhi6o4JXhSrSAdxBMBB3zsBT8o8e5QpRW +y2QGgUN7HS3qy2XhyaavdP88Ea0J75n+4k+GZVPQUMl5/J77EOs1kqhPshOfMdefflb0fTWsEgQI +PJn6zRlgXx+7dy+NCDCUsPDwRiLC8R9KhfdpzgkBZsqHqQzeOiC18gqpVJobQ+rG/4XYect+ON/E +Kmiiy9mzJCat3HnLelPAShUEmGH5y7npoPSEr/fzlGgdOGzeJdpM501s9tppZLvS1+xq4YE/OURm +rMNJrOqr552kqJ+kyJh0qbq03aRVbK2kVY5OOIqCCehFXWHX/tMJ3JsS/igDBfCD9eSfZbYdJGsx +Y8Er5fDsQW0IMwoLpeAcDwSeSeyYpwcws7R3qzEGAj38Ljra8LseHsd+2BQkg/NdD8uBgja8mGo+ +pEGGTqDQfToTrN9I9ZWgqYuYmgdTsJmILqLwQm4yOGmyU7xfXz9to9wHGjze2yQ/I0k0gHOUoCMv +VCzDsJt0LqS25Dx3S3UAjkkOXb9fP5mJFD07Jx2hw3ySwgC6boVhoFwRTqPd+1NjSapPJfmavP9H +Kj0gYb8IVafz+3qE+Ej7eko2JufD+6ymG5nY3U8qLSech+sJl+qWD0nixBYC3jZmFeR2zydPK+DZ +fuQCKr9pgmhxEDRsmzZFiQi458iX5sWVzAVh1QhmH8iuIFhHRJg0Ts1fJD1MmpxAH0+NvWeER0yy +0VZqfm4xvz9H3sqjU4ByfqoKAnSs2wH6Qfz5VMHDlvEux688fhNR0geTi5FE2hYGsw0HjjjZWj6i +9n2SwH/yzfjTv+DLKNLo8fHdT7GT+72VA6G/tSdbvodNc4wpYqnhY0IUz4QAQeojW1sia6wiU9uD +GfY4Uu/QE3poimH5kdk+DFRn06+UqVG2kp7Y2nU1ugUSoMOwchzggByHbYUIsKdEXOUKCEslBS7F +hk9MDwERoHf+RbMOcGbh3nDbrRAcxaEUw6KkAkWBsiqYUyAMjubQ16ziffJkhNs/D7f/VUID3y76 +aqdR6N5T0ERTCjnJarfZPseDog8lJxmRqNq775Ug7xobFu/acEKBOU/yVvqL7y3bb+R+m4liCUkU +rT684IHfu2nIMgOUtQwQdLHXx6Upqi/19BDorhrh4GqSIZX1+0Q4x10CPHMi9DaJKjMc23OVSYIn +Rve5AKQP+UNs0hPxuEH3V3ocCu8uP0hvGUFnF/cHmYB0+31a+l3lb6osD+Nscx+mw5DuuYPpCna5 +O+36GmHVeRqeFc7H9E20K79ErAbOlxY02fvyjaenC5bD2+4ryv7/vrJLF9N37n6lxrVTdAeOP1Th +QB/NyXB751JhtnOcCGw0fJ8yVuxiIRYXVkLq2Qs7KQNV0dfkqk0bgqicZQK2bJwUfdaDMFKPns6Q +BK6S3AsB/vUEIqXLvBSjeipZBG4WYNIXAQSSgZcNJMM1UhQWkO6Q5ymvuTfpk2LA+5wIZ/UXHfMA +QuU5UVDffvDbhcwJqfRwH7ZTdisecumm7Z8LBIHMPE9ThZrcC31OQE2nA+t3/l1Hpvf4l8DBvWfx +LFodF3s2vdpBIuJhKih1p6fV2c95eX857zpfjFRgwWN8R27766MQCntHfMTc34XfiachIzHUHI1Y +TlUcO4ohA0zD9lhiGni7t73XjaLfY/lhy8SzP7ZbLoStW/A1IicQSFk2V0VesY5N5w== + + + AHgG3zade/l9WAmDij5nriEck3GREy/cHhCJYdhu8/WOoR4zMtbkwFYcgV0U793JAuYVTBbqqzKE +mn446/r7CuAgO6IBxxvky0gTHkrO84oZMSpBytu5HaK8V5Link4R/NBy0JXUsQgJ4GjnRTyvOBI9 +9O7YPDKQJLbsWPdJ9ZZuYxFpyiwB9xA117opJF8VqMYXTPgGYPFQ1x6NRBIgcNnNTjgFsTDcOpAw +E9phI/fG7eygypSfQZGZZFWkjy1lys/1fMF5qyz+V6NsdOkbjHOD66unnGTcL/VR12EWlLD2I3F1 +3fEAFKWBWSDfmnzk1VwzioE0QlgiPhDpPNPfbOLomIHHwznQviEwvf6qgfrv77QrYlfXEbtqkfwk +f8xDwD6MRDq4Sj64nT5j7xHhAhRkiYA5kOMObu4CTfeOm18cM7d5BAaFCr5kaABkupcKfNeQ6EBR +kpT808nNv2Rdg9BB0SxNQk7I5mnN3/RkTyqFesNAQKFX3W70JEQYHJS/IgVLWwGe/qHIcdM6gZVI +p4CjSFKKoiVDG/F1THVVYnjV4IjqXE+noZIohrxEySxR/ERVy44yCKTy+7CxlRWM5gi9g8duI1I4 +Kz0OI/orMbIeYUjPddCJRnnFHW3unInkmogaxcsV6XC+ZD5/8o2uqk23Khq32hKjnt4ATHJ6OvsO +Q/WszjZ2hoKkxt7DSerhmiNOv9do9KV2RBNJz5hEO7YL+xu/SI0VFW6U/fQEVJtb1FHVb3NYZXxd +WGU9GhAqfkJYvlVl0WlEjkEXRa2Bx1BEtQEB2z+tuI939uzkbkfVvhLVcx8ozSKjpGbFo7vLiSCz +ZCrcjtBSUteHDtyJQPCdiNmfrzMtsUcoopOhr7zLRoH0JEL1CpABpUX2FYaJV9xWeBNHTKnil5EI +rDRA4bffEjzSJp+QhVQmSOUG8ZTX/JpZ/fdbQTkc6QMUyy+B91Osu46ozDXA67OG/cZpr0O5eRiN +DV1Z5aSW66qkKqhfoZp2w+2m+dzktHBXGREKt0Mgtvtgvty9PvvRM0G2H2PF+ziLwbhpKxrFt5oa +jT3gsRqHgrpvyN6yS1ZgSwAkgUS/3nUiheSKjhcWzdUbEfUrnGrxMlqphrWsgdt+rZkzZVNHLAl1 +CoTNeWyR4OWxhb71BfMV5nAjuxIpiEz4JgZmLUj7AYKPp1u1sREAO61QhobrOipjVF4vypJhP9xi +DBuVRNoPB2k9ScIhJPsqUeDfXPW+e9PR5gpwCij4014QxOlRICuJTZZlk6sKiIIVUQUTu6V2oA9B +6OXYjTLVZgIBkRhUhjgKNlK5QF13sbM9lKNCFaUhT+SvR/8ezjWvycwEtlxqUwO279EWMEtpzBVC +VwGZBomEmd3X8bNbArUo2VUwIYDkM1PJrX1j6NHg7BlwiMg3UnAmVcKe6BTvzXamAzJfyhJPzTmR +ZlBg9fgx2/0ZxQ15LGHgbox6SPpqOylfkQirY/wMetpTZmd0uCi7/3zwTw/iJUQ9LV0K9iCiGqtQ +zpT+195QWAHYe6pfJe+y/cNcQkhFTLnO4sNP4HgCK++3ueS4CVKNlAS9w/kzxiBP1k+RvPuDqGeR +TwfSg5wiiCvK/Rz+FU3qMCCDL5H3/1jv5GFz/I5NZhMQMzQqAcmSR6llMEP9NeUczYxmn9Xf/YbE +Qow5VEU2cIIen2FkeymjrsPrR/qztJwHIRy0ueV6XPPwgCCFK59ecLv7jeN5Qtni8QgWYCzXl1VC +6WtUEbxn/Y5AgS81juvY+3C7FAnB/4gUCvk0PQXZD+dRdyBHta7EWDUaYPMoROXNEb/vAJMbrTkB +Utrq/VzOyQOfB0OIs2wVEjY5xVfxa68ZE3sX/wmuNjIgIdGhk8dLvV8n8/lHFalu0S454/EGPSbU +nQkpF/uFkrlmhi3PEURWFuumsitodEfjg2SP1Ttsx3q6/kyvlFi729Hhdhf8BRtsHe6+KjP3FVE0 ++bPYtaryKodo+dekqQAthI0pZKcoFeZtShjkDim/BQsVzts8Lux+SMlHE6YpZwCgj9djlxH5s/uo +pdOmQUkQVJcE/4aCfE4AsIGIFqmQdvQqRPO0rzMJfIdffNTAWK+48MvdAGDJiBrKo7q5X62erzZC +fd2bC4NbkLAlJ7pysc9bvJMNjB5NDMHuPJQ9KtQwPGj0KfLOxnFFmMmGCeJLOt3fQ64FEmTPemW7 +ix1nHb+foxCkLQ6/KoDFpn6YWgO1lqPAp/3TTh6hFbrdgUtGquZ6E2ZdKfce2r+kKGeGrGq1YDVK +coBhA1lrmWqx7S/W0cGb9B560uFq7cugZiU1V0Kf7kwNHEcxZfLM8e6FRKHLfGES0SNTOOTJtdbX +SfF3XqXII/qsRmhrhvrmpW5nPU00LGN92urJVtCXOl3HZLX3yWrVVqtnLtJwpx4ehyG7w4jyJCIy +UZigPieAtvpQtI/P6eXRQdlJwfMX5+F12eeZ15G1AYusMSMZWHS7ADoyAAvf2hEeX4sXDIbPIEdD +ooSne5WjWELD601jod2rD06GYXXUxFE1Hf7UvGtoraWY6T4FCEsWmfaAxlCzjOV1rJF53Dq345xg +2JcWaTUOHmuokISgtIJfiMSBw2KNNwG4D1+bxGFEaUtNOPwS0nJFa4vt5ErF/6f/Ki4DsAu0CGiQ +T6+YuANodclB1dUCEvNFAclXeg1YdD5+R1LrelLrQxrFBDVk1Ost/JbabXRoeoSjeqjNYAzvAw89 +uE4Ygc3CmGqIgREyg/ZhsipXmC7NztDpJCBE+FIdkxpKyVw5jEB75nLikRUKYbMAfdbSngoVb1yQ +NVylp2ostMnK6bpAJFK4b2/Zl5yrri4c3Tj3XUgAZDAA4MtKP9MxHOJL8n3szI20QkUyIS18nV4L +PQsghQ9uTjRMx6sHT4Nl5oTywtghbd/PqTExPh240YUFDyZpWfUtmrhhii46MrwH8JDAI0nZoo46 +VhpKuyNJdKVbkq+6f4pGc0hbDVFwFem9o974UxTbH1F0ihMxE9GvNwJOBxFfZ5Kzsr+7CFYiQFq6 +XvXfZyL/knwwo96MwoDPjlrD/QCxAHxcLSrXEfamkhqn0RO2CAtsAmYuFoO09zyz+VdkiiVo2TtH +KRKgkeZrwa6lOrrjhsGYGpNaI5wW3ZqVRFlBYA860syL/3TKpfiwAIJBkAEjiKoy+Wm7zwOBhwR4 +cyYR/EJmqaBTCaqjBnHjGc400Yagk4U0yRdzqUrbbTyC06iwNDSbfDyMggE4ny5HDD2qCeM5jgJ7 +YZBPpD3o+jquOd4NjarlrwLx8twyppSHbqZw+WMqawSVhAOjxk/2FJTHObzzAJzEX+FuXB/sWbPb +rrg+RCIc+y7eXpzSS6htTSTydzw4hfZtKY4MZvvBycKfhA0a+Otd9T6LpHwJyy3LAzsdN/4+xRzi +qUjHctWq+SNM9XbL0zzmFSs8tSKcJdujKim1A+kGeXaNCW8sHIQ865wnuadEp2c1DRJsKgynenvH +3ov0ATnP0JhpuzJ84Kdhs7AiuucnbnTQ++XhIwNTP4uuLinpo7pnmH5QpmT6vXqSZURJfp50XKYf +C/0Npq5HL0zwqXoLdJnd7ngKUHO/Iton8njUY8E0QnHNCbpTcD8sqr6y53b/ymIW89vx8vr8Z/UV +JvX8abFOJwlAxQ5252KcIKiw2vDde+sEGcdYFZUGZ+gq1Vf3V9ddcaA3sEnQPageizzZP4W8XoZd +Payxr8yTKOVpiNKSAHmaJooeK5DqcUTQLSRw0fQCNeUgmQLQH7xGVH3hCdpOBNK8RJDxv2e6Ithf +4swj+ir0gb2NnCGeqAOU5ClGuRYR46hg9ATQniYg2zHP9Hv8K6S4xe4rNX+vnSNmOrdbz371lcGe +40yZq96uh93FYrd0QdUZ46xEJJzI9ABUU51hZ7KPSwZ90hZwvIqOyJnFUGQGsYdO7SVb8z5rVa8l +JLRpU9d2Vn2bFqImWfN6JPRkCqbJz3uQM4U5Sv4oVZw0jBkT9BXfbSJUUVDPoCFsVSRGAxg53+gJ +CmwpQ3XLbEzfAX39liXEATIqpLSB2MFBUoMLlJ1MzUvLEUCzN5CJLXisW2WGcyKKIx9AxDl9APt5 +PykmWEvucYgOCy2/AAwcB4PQIzVgv6MJCPNvZVCxl5rjFwg143gm7Nxl5NWuUgzGvnLWjHVw8Ddq +MyrxTN28b+V+Riix2dsfBiPSs397EYy0dZeyJuFu55fFhXFGoegWMGZCFYq/7Lnb2fvPx49KwH7e +doL0dSI3lR203937kMRnSOJmp1APmK0urGPKoZEnGYuGCRFRHn0UUU6EQ699jHL0PHlAXF/vC52I +jCmR67qTZx0LN4BiKCqZW+Njo4POVM/HncVruYugE297CTNaVuE501HpJX/opAZ2ZEc6socosJIF +35IYqGI8SoOCMI4Jmqx0LTd9jy4VBnpFGuHsWC2AQZaae2apZM1R51PwT1NLxa8q4ZxlVaWbh0YV +rwr4/Rp+PznyuxMmAYKuxcNlj4O3BqSESh89uBQI01EF6lFhefBpnRGfOMn3YA+VzvmIVu96mXxl +VVp20IR2R4DKQOVGFeVP8EpIK1B9qo4k8TDIQyEXT32D0brTf40Ezq3+3u/NnecFm5t12qvuCHuD +qkLXMR2UvkRWp35jD8GJLgfWJgrl8istyngLlUvL7lsGwOG1GjWTs+c3h69weOGuyf1gloGcQGDi +g6ZGxvWShOZbGymqKyUD6GbLOU3Z3dHr4T+jlwpjqqyABiIvA3YHQxyth3NFSTPQLznkfzAdq0uU +Qtw81oc94uKs+reYA5oe4GCWfHZsXtWIamJ5Q7sQYIkTy+nGpeQE6PYKWwpntI22n03KL5q0repz +DR1SMXCWb0Rw6IsoaQZqW00hwfkz/IrBv9Q0HOcIcBKW9kF3019RdXzuJTH7+l5mrWqCsR7DRsk+ +DtTBoZ6RsOa+sg2D3bdCgjYmSgaS2Iu8rwe8frTOMjm6z+SI1LrNtMaBGM8nh0lhORAPHEFZg1Ag +bSkrQ2X53CKfj0MW9Idd1ANQ3U9jO6JCsx+ZE8UYX8oIE6YZQRAWRbtLa0VmcXa1rKeOVmhaQHSn +rf4iUNRiVIe98BMmyl64HsvIgiKJrYAlaqL30caA3e0opp17BxpjR+y3rCeiWNcONFl/swlUVabj +Spbd0Hi3Hzb0SAsAHkB3wXpzGaEeGiA6VEA90xNGwpTJzXDvUu5pPzvjpROM4BCYhytaxd2EfcWq +UKP+6SIGuXfYVT55OCYucIOVJxwqlB5dm1aS6NIfeJ4XbP6yEu5ToLVoqtJ5HNwJdZHVqISw0dLi +EGRPV2soEXzoxNOEpnwKxnydya/EXPMo+tNspJ8AtP3XqMdEy0nzEw4WfewPuB57EALG2psD4/nT +eeDC5NgvkRoYkM6V6EG6/RCoggnuaJKFNYomJxFsryqXu5zB50eyET4/T/RLJJDxiQ== + + + nE9TLqu/pNP9o4+QPtzI6YTpCkcZFl2OJaRFlkoPvaTY/bmf9EsWZnNfv8qKjMzkqR0BrAcUJrGh +++u6mU9BtTH0iselltJDMH/evw4dNfaBgYftx2N8PdLtSLXXqcm94HnRax21viLZIqr6uwiYh2Hv +v7eATBHKl3BHL9stZkVs8T2+4/4ZW/ckqRqpCvZYHseCcq93td7xhnS92RFLuYje3ivY2W0/EZYk +C0uj8nUmYXLogYDUM+oIqoOUmuA5RUohEkHlv2/EOAF34u3ZwOL/EruneVaSOruFLLr1PKxmjAqU +sey0CDCI7uOl8GlDr2ZcCvQqV8mNe4lJrC8t9pQSPZZUkyeML0DYPCVBlwW9BtnF9AWEhijsVXSq +z+H6MYnYqUD6QE2nckqja0oWW1GQwPNu2rNirki1sHcSCmy+UXZCqMm6jl5RtMLv8ihTJAhorUdZ +CZJ/ypO1H4O//a/Chas5ANY8/DuEJRe/qMVGMS1/rQDKHTCJJhFy5KQS8P4IhydrvQ7YBvaShT/y +Q8yjFRwtJvxCPX7tfDZZAymawiP7uv3VVlAQ1k4tZnjX83YEMKHqyRgj/I5Y7503AErZBKp3RDBc +9mk8CFIFcNzd/9jhk1JaMiFFeX8pzN9xHgS1h46yVtNVsUkFTgVwWvFeaZWQUdqf3JsHjkcmeqng +8Jtij/9Jw0k2e7pfqBEfwAx57NOTEeyXG5S/8zRarY+sJFZEnCTkwe5qy+kJsE7GHPuZKAd6Twd3 +cUN4trTiUIXjOiocR0hQJyQWVm0BhEwwQzkI8f/jlLTSEh1qMje752FOVGAt4eU4kgB243AFWtkI +g9+3nQzMQSCYw0DNLoi3p5jp8TbZb/4QUEAp++j+yVgr+lxd/b7BHB793yG0DsnTYrWxHxX3PziV +N5ADkmNMcBhhvCohbIFi+/erCujg8K3opy0F7q6z7T/o32PVM2owJnvpGyL/6Og8yn8gpx0DlWPA +F0PlPx0Iuv2j53Fyoc1oNWo/+uXMYKEIOyL1OOM+Y7K9vjwS5v8aTO9fEhT43/wX/Oz/2Qf6K670 ++Z/i//zkDy/Jrz7yNXjk7cKIyNBqq4duBcfPBWoWm6/fYmTwuTrP44RGSrHC/cvODwLJgdA8BRF8 ++5d+pZlWCUy/A/7F0YWmX7kjCxSj6ywNJkeP0+LD4o6y385xznheUgfdyC+O8I5q9pqrcphG8ToT +VbWvIQKw9Y7gCgLmmWJsVOdNBLMaj9FyDLXm6COUl5HP9TB52FHFqSmtcpdUxK2fIPcFabGtz/Yc +gEtRphikgxHSF3YE3aNEkJcTcb1bcDnejzNKRuAvQtNVt3vtPy0BpqzxZCWBK0uGFMY9+RGvOt1g +kTwjdrjJ6WZKyNlFXER/xi9L9wAiGX0UM6TCqfqngRVyEqqTYHCqVDgb/U5UGevi4pYz0QpGDI7d +Vkdj+iTMcbAXY9OA2esTCuSkj+DQlm52jAqvEG6HO98CMTF0QIhzCICBIyoq/5fMf5wMwagyw9eV +H773m3Fc12OhMrI0EGFGi3BB0z4enXjNWtpqB3BmlBIc0BBmTpCvso8qb50I8XlqmNyxahBMM6y+ +cy0CKvtZewY+zu9OzARwFyHjhpAb1GJWub3ZMbNH48N9itZVYAc45bIF1R45BkF8QgTJJ9pnhGc6 +4iE3gs7l+eEwdkPJwmGWBHASn69Wi8zX7wELfjbIkY6v4Xua70HDnZ+hMLimfZSeec2or+ciLIP9 +kyuVDsuqHt3784GHBSMMtmgwYmZReP9Kjx2kVPoLSUW7tdtRrvLT17GuHMepV/zP+8rxIdNOZmc6 +RJEWBGYDo+jOn1NdwOth1SAC4BYR0/ndWinahurTiQjeGDWjdxlZMeymh1bWuYxRwB7vXYmx+0DI +Rx+2zgwx1zJq8TgFNA8RdnNBfvcYqUCFIKC9o73BI8p0eC8kvQo4eQ6QDFKFhzkdyf3qwAwIAhuC +/ecH/UBTZDe93+R7FFq3C3eguZ9r6hix5STCGJi34Hg4Ak/GtF3F06dWKzkgqCMj2ok4AKEBy+z5 +4cMJXQs6Wkd5rAa+w+yNEmAf/ofPf3hWP6MesLIKX4O02D8JvNOOMdFV4ib8TFWLhybFe5MaeCQc +HbH6Tg7hn5DrD7Qt7qBInMhgQN8oD0AD07gZGNe1tENtfiEhfB/IgVFSgUlXRN+2A1Rb4qtzHHZt +IsYVbS2GbXwg7mdoQfek9fu+THosVY+718T4ahUxxOwqaEPYiB1EPMpbyev18mDZTAM0eOQDOduL +J+xs/vdR08BSV5PHq2Se9SgBkZdKUo984xYi504yBdqCyviFJoOdlVgrP58RaSKGtv/555SJNrAG +c4QwOdMcp/tj+XkdRQJEKA6KRDoSeUx/1Vo0gJf+D8TuYE34M4GidhGvIAEmoi/3yaQ0woGgQlPu +r+Vj/2QS2qTNPP88xr04CPvxrBbaDPUDyYI/25ID2s100H44phQfqV262KrjC+EEdCcp5Nyk6nLs +dqqekUdJ65uygqYDNi1uczuDuWp5YQ0lNkP0hDVIxdxlap4yLZuMEBMyHhnWGsSQzBdIxqByOFPg +RA+VtBHaepArXS/8dZQDwkFee8ZGZhwClUpRNK7hNfsBuFiAmyouAAxS1XZKK0wETkc7YvWzj4bZ +VA+zSbeY22kzGIZQn2qc05XLn7EZ0tV+X+Z+X4LRigP5op17nBE1T2tYwj9fLq422nmPoBOKItWE +DUmDK1rnMf3QT21aw8bBETjtFXnqW47fvp4uuPP5m5R4NrD6F+vCahw4/hwxpWJaStTV0v119+Uw +2Zme1zxtRo22hcgkexSgLRE7QNvggZVLTnQfjfKn9RhTPo7HVeKmWUjDHEyWHzB83n+uRJGQZKWW +qeF7rjH8lAL3+NXJP06l1MFSdQCbjIyqLeRZqh6vj46mLwQdl+fXX39l/vQv+JpKSFEgt2paJ0on +spMVIbmRF3SymtNdqPaujAKRRhRlvCO+y9emgpSqB63UglZqDkNBVV6eabinXS/gqQ7bhC8eqGjC +jsLzPHgmQWewatgjQAy1cT5g26493cd5JCGBfbj2EmHTBL3+r2lrOTgxXpMnHPmioieP1LRB1i4h +JWYcpxMM3oh+U4lspXTXHSTJ7SMiRdSTmekMsfUzSjEqdT34oVe6UcEUqR0R3ZyIbjRaRhGiGTa4 +6OS+eBGiELuYvMojNXPcvaBp9DijuVbMo39PhNv8dMB5GxFhH978FX0ipVCJ6H9pomax3uSgR16H +Ti/yOlcOY8mFrkg5ESxZRCzPLAk8Zjb7a+ZEQfmoRfSKmdSsTAzN1MGqrz4RKr3z6Oso3EVSLMu6 +H6TeLibULGqvvWSHANyCvpFYyjDs+r2x2pSd+JX16NAEx9XBv051TVTEmUzb3w4yA7S1zx3bwI8I +UPRdEWQai6cV8T1qheinJibMLm0DI0gHoe9WUlPgz4LrcR/dpMxl2GvWZ8Sfz9gkEja71gm24uM4 +B7k5+aYl1xKFsxm2th/MQCTD0b/Ry3576R9RMMCdROyfH22w9s6wtJ4pAUBK2V5lP1/VzEjNdQbT +Yi8hU2hRNX3hv9rsqiaChNDeB5oAqTsinqMlw8rUbUf0Izur89LCS1BNthdeBseQZhBsBVX8Jko0 +6+tMEeSiR70OgXwYNe96zhTPRlrKK6qpDO/5skHOofSuuNEd2hfc83GYN8NNx3u+k+RzR/hvPGTV +fqLNmQnjzslPL1adY+79o4fc94hDWb3tKH/Z9n1EXQcsVArAJL/JsHu+k9ByH4SGaBwlfeKEqXL/ +t3/Pyvb6bO/fU1rdx1+DjrChhRsaa/OCjvH88AEwXWyXgOl+KQd+RlFcB/6kA6qKNiuTMSesC1zv +sQqNE9qRUEAaOvKGuzCvx+gsSoTjKBHeUQLITx3xcGEZrFK0OiIH/v1hQMwlnbSLAtx3Xgr+wpP6 +zZ2eQ8VCWL4ctHCQWCY6gZAVp3TtCEsrbtl8Z9M2pJ1Z4iaRPZeh0gGtA+zKDgNI+6w8S5yxZBwn +pnrdoR2gvQSNHbHexy9M/OuTSEm1yFa/bgJ8VgKFvQRjwWOoxxoCkA2WDnVEj11CJhFtxfQhSvbF +OUKOX+Iu9+VmKETqzp+jmeDJBcTwAWAnQLgKUe7bBs8hf6F9R1uxr+gHx3zp3/aFRuzKsOIB9Cgz +1sx5qecENiMKyjznOWSAhauoqMS/lhL9S9ZJlDowq6FIN+eIzwqAb2+bWOsdBj+tXjg2gOXYaK/6 +Cr3I0T6muS2muX0dGRfH05Wfo/mI09Iq4p/SdPZ5ZfhyPA01I75NZvt1+sXNra7iaRg7Y2U3oA9H +T2YkH9a39U4E5ZERvR0JuppjIIj7dSKSNQuGuycbfI6r8j6QZse01V9UusDzwbvpNTI9Fcc+/GCu +9ZuIFlJTeXTdtN1QQz6U3YX1qAjZGvUzTCiLJcBQiYeaZVdzXVicalL716A/mMM3sW6UPgVELy94 +MYntSCKGEsjwm4FaHmSzhetkCyODObYjNbzqzEYg6nulfXhuUNM/i6iiKI30ydsoGKYZ8C21kTpK +X5lT92yx/HxnBFjCmnbiRbeLCcaOaC8u0Kin2ALfF57ryaIF1LJGlgxvduXVWkbzgcetAJT9Ss7b +5zvoLwxczz17MoKRFtZhZFy8uz6yUOgpbHSTdTVb7mZrPxvzh4h5shHzr9M+S9Q6Uc/LPbI0ZnOM +1N2gC0NPawk5A/HstNfc4RmmjOefXUCgrUuD3Q/+IkM6fyIH1L7CCJgIStyUdRbWUIt1l5Y8Vd4C +C95vW0YsxB5qxSeWXUHZ7m+soSbCI4rotzSQOH6E2BTKDNVcPsROLC6JI98jvPwP98LvUXpkDtYc +dCtY9zCotTcC4mK9ETMRkuN1Wnu1Hr5/CFo6/AduxRMassktcso9fAiQWisCLRExZ16Ep5V2Xe/Y +i4in/Nb1MS9DM6efwzAtN2gGznW8+UZRnU03iKJHw6WhwUfEXTOY2g/bX1ro/TFIh5F1HEben0Kv +Dh69Fbehyhqyd2zh6yZNPIlnjvc94H2wIpLRen9+CGKyLYPnoWtOxbtaarMbheZ1yP8SvPcTYqq6 +5mFVPWO0v2Cs51Z3LApTTcQDgwaRdo8rry0jAcU5nw5U0g9uJ+N7PZFz8w4NdsR6Xoh0uTO6fahi +9SxcMYNZKGe2oHih4FGErmvkTOHuPHDoEpGnGQSTX2W9UPW9Gr1WVuLd4hc0Wc4taOoLHZWLSKr2 +BJhyR0uKxCjyE9bBvMcHIP6HiPwoPS5n0M8iuTQC0iTqEe03QwZ6KlPdpN4OmPYdBDL/U8QT6K5Q +mtfF7iNKSkU7lIoRGqSKochRxbFjnAwFPGKNasWjSEXDg6R/RuSm0f7oirE1ZQA+j3NlQsOF+Cs/ +rvO8XCzDPwTUg56+5ttP+R7imJCHFRehOxerKztY32J783R09mZYnCag/KfI3s4AXQ== + + + O79HvO+nhnGILSil8XGcPiN+i85lbdkt4orZkGv/KYL6KTimfbP7787qE6Ln9Yize+oRJNuZwV3e +xvlI45weLgUFWl2YMGG5HmdVVK8fh2o/ROTmleCTHvLN+vxwnFcBFKvn/qZb/Uq6NY/KReApOwu6 +Q6DTNAQDqfvdg5+VeumJ2SX//yJrQ3EtrjWMewHx98JzHxFRzW1JJ21y3dG8xEjkLZqJ0gNvRy0B +pJzdeg77qpXjCJ5TC/nAJlPGdKBSBkRN4jm+SlCdJWXuB+YVXFG18I7+vr8E+N12fI2XGAgmT0G0 +kj3PBXBsih3gLQA78NjNaYH1EtBPEyhdXlBQBa/28hml0oN5ZUUHsqjwrWzYLgcfCtfPCMBnTPZn +HoJzpo8oC22ugH4JGGCwzLaz0hwiEVaZBVc9ZoKQmOkFIicy1Wyt7f5S5qxHjrIdWznG6voA1VdB +xx9KLd6+4tgYnaGq9LkBr/igiieMNla/v44fUS1UqY9LC/11Cu6DXalv4ooxVjQM6ejugIFKa36R +ml9kHJ3BNEIYH59ZgCMECw2oZ4rYMnZh69jfH9ymo1TTPg7OJA0FGFrOpC+l9x8iaj24wvvCjexQ +1z+i7jyyjN/a6cBHFBVvNI0LvhnzIDfB6/ujrY9kPZRjbrnxJ0qV2v3PQM0RM4JB88Ar9yGtKbcn +QLQeo22wG9HU9G4vaV9/OkuwNeEH2nH/Q6On+kDNuGIvkF7rMmU1m821lYZEyGfEn98pnqaboyMg ++cNx5nhpvPvdKylikRlA2AbJ/I+AH/fG70GobkAr2093l+o+azxzYaaK+3yB5+MgjLGhk1PSD9nY +ztAsf2E732M7v2qsaVXWZl+pL+MeLywZ91Ij9xfRA3av+c+IxfQ1ZGste3I6OspKrehcv32Zfgzu +0fWC0gEtjTWL2e9UEP0bxegj4h9P/8h1+/uHsFptpiwHT0cQ2JpnZ9ARaIWaWeQfLYog6cdgCFCm +eq19DGoJWuMNoo1DkIaJ622VTUzeT8RKxOjviVYiRMgaQSZNRHm+rJquK3SoKV1HNvR12NB3iE1X +/vo4VyNGvfLvlMb7L211GKF1cVm/SdLH3wIpCcVmYaa6M9/BxRKqntJk5F8cwSi5qYEiv/kCRziP +dzYKpUwwIBJ5gvJqhaNJ9RZDqPjqLn1eHVPZ/U7vX6X77Niq3s8OfZB2BnsTuMoMSzVtU/QB/6J3 +H3oIw9YrblGL9HpHTX1k4KpC/QCsGD4gxwn/nWaPEavH+mf8xXH14572L/wstoxQFsH3/RCgzdkN +Xf7O9esQjvKyKg3weUVcIijz9m7rE/fPKZsqTpOVgSB1D/ixyYvCD43lhEanMyRapwE9iV0t566v +POZTdcoZy0/0yW6RSNFdzhhBhGCEIFztMhjsP0XsK5G4vZPD553OGOWZ8I9r0Vil54zGajvEuIi1 +I9VclfMK/nHvo0o6gPxkJVlIuAspBV4oIFWkzHlSTw69ACG2YFq84AdAPy441/HvIQOBcwVsx1wD +0vHqh3oiPxOFLTs0XdAp1TiiJofFeGd6uKOGo2qirmHHqNhcfe4YRKN2BumGiHKnF1RjmrRsPLKQ +F2FtHEOE5E6q5njFENZxDuAyAKnvy5BJzz4gqRcoWckJIj8IcosElz/lsSMCACoRURaETvkqdaOv +nt7BfR3XRYjKKGU16UMeF6cvDNPuo/RHXrj2YtMiGeyWtdhTD2Fgb2ZE7O3g1X3cUUqwwIfSsdko +TQ0zs0FaAV791D7Lz5VoQR33WceUkUElEUdxsF/KrS22i/cszToLEYce3NOSx0oqKxFkpadNB9qq +VXkN2I/LgQXXSUNrkSXkMoO03QvlnL89ySTMLBxovWtPFGdQIwTzbGcbMbi117vQH+L/RklfI/px +aA3jllxXo/RmA+trWPtxFJiuSNbxCLfzIyvPDkdUO5COSu7pR+ohWWTl55/TwF9RP8EJMYT0/AmC +RZq0l5W+nAzwGo2APusPEbiuFLtuYLBeJc7vUbUdzDWqRTJhaibVDN+ksJBOKXzUdWWLSSJfzw9m +Pviyqwcl46NiirN++HP9O7u1YjSZWodk+RcfjHSgEEudf/HsrPBplnaK15Pd5L68Pyzj1LyRtbXC +jdsbQ4ajOA8A/usmF/8pjiP6Bt6n3eNYKYQw+d7OWmZMRpY0zhztxbDyockK/8bvwTNRT7dGN6TF +UkneVQPUtInq0J0IeTjQOo/NvJDIB7XhVr4u171lX1ZRF5AtSUG+vaCtw24SHyFM5QoeiBUcQA9y +YzZBHDh9/yBvzPek7OPPcak5MvhLjj8AP1Ym1IzQLvuM8Fcc+RVfmMtHkJB71olu3Xuuc6SLyqZF +lzBJTxT1/OAWg7mry/e4GFP0GFygJvAZ5TcydU7LLCWAyKQ7rD2KozDD2e+6FDfUQA8YrB4E1r6O +qUbXgXPfLqsHQqW3u7Sb/kOP+yOijpgQPegDvIqzRpGsP0heRHBTv1da2l0BredI8DaBfwGVKcfG +w3y9sASHqrOEwrFeobWxn4Lz3N7HHnNnwHtFOAYqaCHQ+4CARAQ/ExH9SQCgb/+dJJLceZTT7UCT +Xw3I/vv496t4Sj6418iiCsf9KiItxT8C3oV8hw4OatmeIA4ZKE62aKsOfX5tBny9F6ozLxSe3UOr +8gw8NG40N3KRTNf4qmK9heisHyJW0Tc4x/3+IcQmoCmuOf2FsKTpry5X0/gE4REc1zRtr0dwYL/p +DH2+B2QHaactXEWhf0Yp80OPEJkfB5FDvcUfPqABaQ5y1/obT/At5pvENtP8SwsdumFXyAAHcA4I +sxwrFRV1sCVYnxFfC4hcXvry4Ik/jgOtFfToQuyohUYX/OAdSBfwMhsp3mwmtg8SBm+mhWTUyocF +IDtKUgeUJvCR4sPjIoXBGBRatB4BHNfMZCwtfYmg9CXiS4+LoOo03IkYMbRutMbRokZhTVVEGP3l +PNL3mErW4+ospnq/TYVc1AhEny9b+qedC/HQEy1WmyKt7vixwnJA54A9rwn3qz98ALHUOzC/uCUJ +Urdk7+plnan4zFRcFKLDTurEUYV7V5MHmmqjXQfWoXFUQQ+3fUakWIjMo74i7Xl+OA4s0UdJq4uu +tlPrCIbCCitBtFG40xEMMWW/8PSMLBJw8ilxeVw2mBBDXcHcrikd68w4sX/zcVn3YQR1RDVvITz2 +RKaDoZCbnMfh8XQfX3qOExI3fuUtKqCqwjDM0hoI05NjTkVHjylwnf2Q+y9hTw3q7YmIUH3dj8AX +lC/ll4Kg9w/H6UckaZd0RRl7Ub23nY3FSOyHiJfc2nBgPL/KRxTo/qmM/bQl0o8AFVRqpaZXrHyh +lUzFAvhKLPoTO6QV2lDVcIv1+BXQAqGvVVGn2XeihCEL3PUwXBvITq5OpVLx0EzwZ86juRUBbPfS +k0IrQ6WifJ1HPzl+OGHZulznzyG58udMJGNKMOWtIVA/PoUXZLYpQjzQMn9PgMu3+FL0lGZYvxpD +dFrBK5T6IEdne+9ppHH3aqam2WcE4CqVSfez3t4zfY/iMTNqPxMX4NcXIj6dL0TSOHYN7bqYlAGz +OxEoDrTPiJypHogsRptHR/jbca7DQBw7B1Pu9xIShcdDazZQyiGdDrTJi/clP3DHqfWVvyiBqRHV +NH7YUfU+UXuN+ttzPU94YiS0bASrpd2C2od9nsIbToKH8AnGzqdd9McA1NIYlF/ots2/aBf9Iaqj +brEPUxRtue2KBznLDs1Cq3JBdWcWfrx3Zm122pcm4x2mHystKBE+oI2TghW2uPtLCeWSkV3ErcZR +zFIoqXzusuklf4/a61aMGfa+KcJz3DHdu+M96iSgCI4aQVfCwloxu9m3cx1Pg3E8DV4L+n5EsZjt +NRl1t0gy98QRdRaViiCEX4prT1kLaN/vVWtGzR8ZDE0vuAnK+SuOu9/RNb9AHSaB++Lv8sTF7cHd +ArSTUD4cbGiiMK2l9qIU1EYaOjuUV7n59eh0kAU/ABAYdkl3QwQOAEI5Imrso5NNEXiWdKOlWKGU +9kcvu/2uhTD1LeJFMQW7AQ2PquZ7FFQRnbUrqTEP0l53LoWwzwdIEgZ9tV/cA9X4+pANn736xhBg +Ku8cr5bhEhBpQCUYWb1qrFL2k8IVteNv9yj2zHzgps/3p4OV06Gc3l2UOruAFF6uJ9YTo4uheF7v +sbF3yx4nkn8aZvcvCeqTgf9fZOH/Mw92/YLY9ZfEev/j3+7/mL/+1X/963//3/7LJyu//tv//u// +/v/69a/+u3/9v/ybf/iHf/ef/+Pf/ev/++/+p3/z7//j3/3p7//T//t3f/9//t3/8G///T/8j//5 +7/+f/5ST/vwX/+u/+0//7t/8w7/7t3+3T/GHi3u+ruCviAX8z/xvwGe2ivEBRukK7MDeSHZig3wP +qwiyFhUe/n4uwjNX+QN1bWQl4C3+UtboYjl7agGA/gvMIDI0X//sXw3EqQC5rms/JD9JFOy9N/r3 +DTqYxeoV/KzOUrsC+w8nStAjvdX6zM+oqrYb6rP4kQm3ugKI358OPOqIoCQ3AgarxldHQr1SRNN8 +ERzeo74Y/VQnguNXRTlwRhT4sSTamxYF/s6ghJTtjesS+8bc485wZK1TNVR0PC99sc10MsWitL/J +vfcqbER/jOj17bOR498StEYixJruY/RyxjDPOf6Rfd3/pPT2vRO3sgstPrjtNextVOlpInyr0Re7 +EwEjYEdQoc9EiNEooTV7AkYC+2fcSckKbggpKwXQanmo7Cs6Iztk30JERJ5PSawKcwuLP7207+jJ +CraQtj8yp6pMV9DNVW2fEhfaPB0UeCicutIoRH9/p4hDTc8AkH9VUeUPqkvPCCTuPspLiCuchLsC +y6HlvB/7vbz2o9542yjcv8b+Kqoaqt7Uli6gVlRgogaV+P4t6AYPVPlvVFaeoNyFdg01UXPT6Co3 +Zy4aJSSqRmwWjg8B2Bvy76oL0N0gIeIDVNn2Xza9GIgIN2MwdLq/ju9yjEiZYoDU+npU0qwYuU5s +dIjYtV4PkoaqZWlolStgD9wBl5pOJCXzHP6OdUYPRFckrR0hfhcMvSomtWyofd+24PqwaP5VMP/E +rWFXc7PM9v47Ry12+GFaVpUFv/5GE4W9Aw0hjekdBT+98/T5cwTGWvy8wNPLOfz3IAv2y4IaYZ59 +GBQldNzZD+oT1V3M5ClJJwKBBa5BnZ8feALuoKOb73/1JH3YX3pnFi3+hNCNAB4DvNmLU+wOgfcq +zL/fpNfR1Q/xbEC4zGEWUF5bMktdtPw546hBA/KOynZ6wQikeAWBfj26vs+ohgl3RYf7Gl8naqjr +QHkdR1rs8CZw5BgehryUiP23aYWqQ802sb+mEQMG2kDFrP8g+J0zDXF0WOb2CL+tjCWQvMO1qTyZ +w6BDSNMmdBKam1As4B1/RojCoQ0x9q1u72/yEXVH+msxJBncvCqO/kFNTTUHGPSqhQ== + + + 7R0Fk8Rydx3HHjI+VRi+R3gmZPiwptivD7/1D8fRBIMChMY4yzSOTk1v9o5R5Q8RPz3HH0FATPcN +WfG4fAA/k9vB7ImLwYWowC/eL1DevF+XXdp1nQD8Ie8sgoV2Rs8uE+4GqIC92haKRz2N+1B3kFwf +UU/2fjCL/+hdOKyU+eJSauzu/IBNYP9118yI5pqSvIC0Li7vSvFDl5DXB5hiOXJkfnjrVj6C2pgt +kwwmhPhFE6FU+17flraPREgYZoZYDID2TUAExWZcbMScjKPUWcTJE1XPPG++ZO5dkAKjLOK4AAbq +FjGzryM7dsdRd0c8DlUeJcrb+oxwES0xt37QGp0/HacijQ0OvNuDjEAXLyYZy5WMpc3XqfOO6Wal ++vjzSY1oQxlUbe7j3j6N2s9o9zB0KohoGu8pZfCc5Gkmefqnk7A3N4+oQCtT1M4u6RGFTG9wMU5a +N0OvMGawUONBtdMKMpgiMXathT7Ar1aPKBd1DAK9vEv0Bxo4qgc1xof+TrByLy3jYKz4bFSk2EvI +/+LoMNozAqBdATwNggYo3sN1XDb0jHhuKuednt5Xjq8MJ+If5eDEG/xh3GC8ty14vJD14bbQxS6P +Fm9EDJrNRsgGRCOiGAD1nwA4QJ6nTxGDyrl7HhqAQLAKvDNknChyUdBfpflOthrK+37HpKMFocng +mZrQpkOdsr9llAkgZ48RkI4n/UhF3pgLYvkNtEivB7p4j9DnpXcqFfngeoXDuzUP5Z+pNKni2vEJ +Kqzfyrjff/OaQvrhhDhArqRu9sEJrYg15M/llN0vCh2FveEHPLTYoxSdjsncpFfRCy6/T4DrLFHN +vIle2EyHAQMEj0ODkYiAcYnwoWOI2HIJJVTW68mVHLR7pVY+v8gKlavQ6ClJXwJZv+U87PtN/xk6 +K5rmEiRrlLExIaGv/ddekT+dN6ohXMjGtF/pQs8DZbpH+cGdkSEb9R9OFG7C2Jg/NCQBVuv9uh/j +SvtS/UNI6nvVv7DWg6gTKb0GUdeIqklTTcYXZ5mDv8WtEwHu/efdzt6OiuAKEB06tQxoSBnB4vGL +J6Kr3rYv/94Rwz4bx9dmkjr/NDyq9okkt7uwAPGj7RGZ4/6ivKa/qjoyMRKd9FcuqOP7rasw79hS +GCDEfutbROqTIlJxv5eDlvQPx2lNUSW9FR0sAFl05o4lx0VE2a/zZLbNmJOnaUlRg4W+XgcxorQZ +pYUA+IAovCUfAYsUai3+KHAlivqKyy2UgMq7uLO1GC3yARsdH5wEg89srCND1ZhbEESuhWEFnH8i +Ur/s5YBJWctIlQBa1wnYX5mAArnY74GRWzHtzXnQ70SFhvY3FUzrzTF0hR8B33Xn+UX339F8FREG +1eO+Quem7OtxStd67UU07OVcMeXH09NZgrLwOIDbCfnOvPb7GdvfZmrfMiXQjGzv1e2Hz83MljMk +mspn3/uICjxeJz1axtX+I8rA9057erxMEZrQu29nn257pMsNrREc2r4F5PvEnZXduepa/P0ouNkz +oNvPVdHm7Tbd4joGBM3PgBR9Ofr3z6rait5ifdqKngfowRRL6OEsByrHcKqFAZq+rb28z2fMCgjp +jqUeDRqIUL/RgJZjcFekjT1+DrM65+C+gf5/euYJ1alSl/X2dRobhv1ySGxUnBF7ZbzqceCdPFi7 +gJgxYg0N+XZK241okoouWhFxng62rePL9v4C9TyQxSQwN2Wt2DZOEiU0LrRiRZmJcRC3GL1FtF/2 +mvpDwHOsMNlw3lTtI+qZ0Td+VLt6vGB0kvjSlRSGdi8zP9q90CnsgmgpuRfjItbie0RWqxYucNsp +ukCEj+PQPLHZg8+gFtFD9X3eIeCOP0SgW8t+Sh40D13ghyi4eQz/9o++8+ZflbEvgNPW8Tw6Jtxd +k+5BLbWzyL9JBxcWtmaEXXzWn87x4ShA7rLfzZ+fxwCY5k4uJ8YmjRSKpv5PD4pSUujDtTBf7qPH +JMf3nAc8N/hulGGkFtzvRI9Nbn8NpKzp9FXadU8mlJnI0ZfbC9F+4FM57S8ElPoYqD9XDNRrANlE +2bqoaNWXM+NyP24sX/tM+LVeGB4OZTmCenHKybiGFfm65AvSaCz44zBxzVe+0BY8TI7rkjnz4IGU +6W5VHOqi+To9CpLQfD6eN8IVjgnVbUA8min7nX3vXealh16XhDr+2gEal4CEr21IHm4C2DH3is1T +Z8Slth6ehz0XYIHDIe5ZP2VAs7UDUO2caGdLLS8f02idrpBZrE8Ev8mwMshe5CZqcGoT8uuvJ0Fv +AaLJok4h+yls+o7C2xlaTO7tIdkS+kB6IRb6E7cYhkhxLoyNJKOjDoXkpUU754vE5b4lNAqdSDbH +/dQgtxGXDyVqeG9CuqNierrLlDFy3ZdbGVHuStexxEQAVThFFWrlmWbP+mwxQsRdkqBVgQpO6F43 +0edNriindVPtChtfyj1zBY90L1DxU2HjfX908g4ihgjoAUncrmYEufX5JvsGEIJ66nUMV8Hgg4pp +4eA0XXJ4Dzopr4bu9CivlU6bq64nmLZ1dSSZ13uCeUg+qHb2JGjFPFR1zuNrG7fHmAN+ywucILEv +7du5C6DhNwMUzJz/mi+TjBHV4h+jnmtUpNCaxW5mWE6SaQnkp0bLjABspBJB3U2Efuw7XbsVj7Zr ++vs8x6kWppCKbf3KZQ5X2y4NN9vVyAUAbM0XkWoWj4BIjX4x4a4jBgCjfuZ1SiK/C8vsXVNbOx5e +fCXCfZpuZu4gnxGCoOv6+iH++CHKTpdMSWyzA726JabrY1pF+IqOt1EPRAVSjm8HpFMBx98iPFO/ +JRbu9ABWdPvhOL0oY0SxW58VMOdUXpKGbU32CwqZ5PYR3fkdqmhhq4HUvh4USfD+lbM+HAnrObLP +tE5hWFFQK1rRVKEY+5eg1ZRyAPMftNDaDxGZsDKiLmIAWlMN+/tx0FDw90fzbMUWB10ZcM0PRIzP +iD9iy9/H6w8x+jc/8W/GtyaGy1pTI111RV2QebzWxlUo4PE6hsaCANpHRIrqR8OAfYcrmcsPx9mV +EyQF0MSI/R80jQrJu7woP0UwFy6yLJX4O2f6HiVoi32AxZBFpznRisM9hIxHG3a15fXALo7P2mfE ++7xNGym0Ww4194/HGXGw2BGU/xHocLzBGn3xro+gJSkhdoYXaEOgPwWczGtQXLMUUWhUcaPXQQ/R +smHHJ+JStPJRSEOlVSb++68W6zSzL54IetKC9FBVGax2Jdjq90QOPgvrYIs6Sxgkrp0eRlOYvdEV +jAcNiCCjIsRGmJFSkpbzjZI5lWg55URF+gZgkl0D9ywqRdvxSD/ivYzrPW9UuVSnwMbRB5/VMc+b +LtNFh9X2GZFfKfjvH/686yihIecsSdLjDY0rS/spYGnICpd3Jyrv8T+ivkEQGy60tsFYnO6s0MlH +0E4g/YDk1CcWZzvZv+tnRO7ZEGTGdKmPI+T87ThPJiB6HrRccXcrqVpY/xABMP3i17nMUM6ZvkWp +tquBMr+8vteXLHSE8TsdQTAwNHBQVlnqE6FGWr0v6JLUz4j3HU2LEMXgo9Dyx+NgJ4aidxEfWMLA ++fxnSyzpujhQzbfX+T1qxXtJkXTkmLmAPIiaRzX3mkds0XPwkUDsH5f2NW11fY/ILbsVUwHzqkfl +53FIUy41xndc7Sc1Gyc1e5KnWsFqrP7Clr8Mt6tMJS3Tuzji5xT+1MojPvGq5qHCp335fPzVjFCm +lURYXvOABXiOYVMNxNa756yQbYlCWdEVOnvBJJ+Nvztuo4Cx8E0xIv3Byd2N1zxkZo8xxtGiPRIS +/HdvIt/g2j3uhf4qLCqNpgd4oQJ4EZ0Y0m6aK1QBRUONFFNi0y6dmOdnRJKPIgnVVErk2MdxEClK +Inqg9DR6wK4WW5/lp4hbTYLkGeP+Smj/GIXsbxNshv/MSvr4RIHYsqoghzCDsASGzldZftkRzyzk +f8e7jPF9k8QxzjhBQPOhfTzjbWvNk76uqAgHBrwXgSeNtYc8GexDe4Ui/ND8Vd/eNvrbfRtII+Sw +q6h9W7xjO8IeUUGb/To/hV+dn4JNgwgaLzviS/hNJoKVCYzTOz86XTv8gUhxXKGjtcUedZ3NBngl +m4275/cAQGnNkRFDy/N0fUTtXR53S3yt8ZhtDuNUGugja0AAknYKGLbugqNpunA++HpoJ+/zzOzx +668YOVpp3DWtYMyMqKzBD1sw4xZhSbRms2mxv3p6rDvtRIbYpBKXTxD2MCFtB/c7DZb9nE1rTwxt +KH8wtOl67dTTaEWsreub4zXunRa7zO+f//kdpoFEZFJgufH9INfIYBpIKJQvFgnlrin3LRE+In7c +GL9HRdrkVrOLX2If55YNuCPKpfJu6cdvl14V70qJD+LOjRgIjXg+NmaJjWnjmTNd650mNORNJFe1 +R+Yd2dg+znWk0yoMW45zoVtLN56ui/OGmt4grlPONXGgkrLGsPp4mVTV3/bigBFQH3lmkSWpzon3 +UfdHqP1/ffCPNpNalm4WtPb7swrvfAFtgbhMBWozSHMSUKHLZhaoSJpZV+hAt6p56YXVbF1++Lwf +Kg1Tgfznz+2WocZkxzkreSLmG9FPxHMcA6iGiJjz60SqpTBU7HdE8y9Yk9re1jTd/CUhpPdjnRO+ +bpR/E1GGbbkWnZYnto3PkaXMmXaSxku7f4qC/I1yLxVBqf1arIvjFLVOLdpa1PnRKuHfG78wILFy +x0HsOuiDnRFnSL/fIJ1Cpc/qkoLEwaSPOk8fdakT7QOSRxFzG6c1Z8LWFVQMFlcBz2ftH3e+44gp +9csPZZQtbE+Gf76ACPf9jhQNE0ZI/Pw5MGg7/6wSPXKcBCyToIVM5fw6vu2GLmgyUeqpspuxNyei +VCO4Y0RoC4CZKT4inogXmRGDxHxmbVM0cHL4DDyKDKnHHUaH3ppqGpQC9t6V+ge4/H4qdj5TY4mr +WDtTzJ0FgOJrZdGbXEBypNCryLzTHkQoz6/TlB98JIgf51cVmQXW7YcSMOQMnRXdmBG1JU18G7fs +p4ARz7ynxgQ6bfDvUZ0mG6NnlBSe4VMUWCfjJJWpWjAQ+rTwGNBGImFFUppSDIAmYpeQEvme5zle +Gf7BZHxmYCM5E6a4zz4RIHhknyvDvuAkXRzRPKepuu9Idqn9no3ow7YD4dwv+wvbIaqKpixyplcw +W8ToosznSHPsz2mRzkQMRVkZH+Y8HWujHYHRVM4jFPVKw+Y9jwg+oFxaVHo1xT+fuR8UrE0WtV12 +/oLnkL9QHK0egRaYcUeDr2KF3S8uf+9ad9AqRwwEJNI+ylCv5MF1NLCY6vQTFQ6eucqcG0FHrZJm +JGNcP/ednq/ldnXONc+H+nbRwXv8c7uhZGSS2WbUjIi4hUbeLaiYCgCzJ0J4x76C8laZRjVG/Fqv +RoosD04roj49E0Q2zjRUyAnvymuj/YUXUITza+w6FRo5jlPVHnbhcSgS80eEveqcBw== + + + n5/iFQLQpC/49QGUH7/ygyr+eWzeD+vUoQdvlYH3QDWzBz+CZx5XWXA10r5kYH5YGY72+vHvac0f +Kcxvn7G3yjr/I7v9/ecWEo3m4C9R6f0Ml0uxuMxcC2P7JRHqkcS0ohIQZ4epDeWO2FvIYhhCn1dh +zm8R+b2mMmsPItSFCvfjOP7u+83hd29A12gkKIm84vb7QwTKBC3e9K8swGcU805XDLTYmN+/UmCR +IoxJMy+e95N2/65EBg0mKdLt2Dvff3nX7x1S2d/0gbmdz+hYgfgCEcKCZCPVEyEYTre7YYQavjXF +lAFRMqnP/U56n5PGKGvbD69bHRoMq5hNE3HbgrqlR+u7MeO7wRcwgOZf1e4t7PT9tksNny9VlCgb +d/SnZBqpkUNTYD/6+9+9ZUitKWU11al4LPRp9oFW8znNPOoGstQ/I/LjfEvbPo8DTw88WUOLc3gp +ar44lgRT/T3Ah6Cfh+Bguz6CKA5B2d5seUxXvdx1Lhey0ixRp7jR7aX9deEEwL0F56Aq0reIPx8U +nNMXbWJ+CBIS1URBPVSNqqBK54dSTzMUyTR2eVBKR8Xiw/4UxJKd+nr4OOCglkgvZof1NMTVDUGf +afwQoV5uUy93PQf98BnFrHb/dSkZItTiIheoF6ALEMdUM5V6+Y5MOXKJ8LfqfH/lETrSDhK0aRS1 +ClLljTz7jk0iMmpNwgcRviFgpOedCMDpOyKSFvM5arFYDIzfZ3KbxDZawQr01EkjZUb3zI3z4mns +Fn3yyB4UoImJsJyOPVxI/aAEiPhSla1PWLb7DUBORcEwqWuOLWaGwnb09y55OXdhn4lRNtYz/YeI +Z0jRREYHZd+vwe4fopBFitIgIkNsCXvFja7TinQl0CA4/HVFtpY1RLmDj4g/n1xJCfJmHVJ/OM7E +JXkJKgDqF1VIFSN3RV3d7L5HIAPevyAJf/gswpY1wpZCtaCcdz049g3uQegf0DcAzv16LiBOVC8A +/Vgnvkd8rSaQVqBRNzXfvh8HjZib7Yvlb0Ts/NK8r7IsLuFnY7Bu8eM+7dzuntv9eooT1aFx8lOX +V/UMFVYKNAs7ImjQEsGwUjUrrBAXgMd6zmRi80y8NY3QBnCRsN2/z5QV+4zeVE+Dz7CjrnKuGN1/ +NptHSU5JkyQA1DslkLoVSMuYzwri9ILGvhgJvAir+90bIPD4GyIyhbAp81meA3gSMBIQnj2YeuAF +TOIQn/0I4IHOXenBBOc834LU4x09erwAxtY8RQD+As+xqlemkLyyCiARFLAfHmbaHwEpNo7wJ+zR +W72/b0cZ4RwD7d3fd4q4nwCimB0iTA+AZVyx6A6lBCbMWypjLAUsrwHKfaJNEg4CGNyamlagN2oQ +fR7/dF1hJrTJIXrI9kqTnhTJiPXylnocQdiZ7q5myUVGzmyMJlnDNvSoVVOSYkRtuxLko5qUIDkv +jSa+RQT9tA60rAre/OE4tVkxPAALIolzR48b2ClP/WcE75fw26U14DnTR9QTD8W9eDgXBokFqH9f +y863SCdA44skHoNEye+kpD4KgOqoPIw3XmxaU7yBL3z3cT4Ub8xcpk//3B5bZ4JdypEsl+FFAyI3 +7fQHqK9DIwrBay88R67IIJ4MgkY/4hzkx9Be0VHxUsgSYLMpmrwjYjNCW7DmUvDR8deB0GIErQr0 +IN4mKphSNB6ffsi1KKHezBlo5oP4tN+HvhGIAu5oHDMmU8kfI5Cxer/Gx4ddDZoq3BtXAijmLe+m +cwg0tYZX30/EBTOtf0bkBCvpYYOisn48zs65AQjvOh+dFq8PUBXDz53CLtmDh+G5kpE95f1Rd559 +nR7cjgre7TlCbt+j/vZcj5PFfrFkZmNgDszGUAC62zeqiruU5ZqD7o/a3R332P4ZMcRrsW7tjWm+ +FMCPqLKi6kjuidDNfpwPywNta7UrvmnYVjHsF5K+C8z/zyq3VGiF7g9G06v8cByat2KRqv30FeHH +9JBPH/x7xMfWnI7196i9joXWsNcJR7lIBZsFOg2YIRJQzUEkcD5+zVMwQCZwLZlSipLNzsBL6OnC +aVLlCIojKkdQAQEtMC8EtHAbcIWogKkMsrzMeHUB2WvCZM+zPm9oZfaD9AM0YgaJZsFFDkF3jMcG +DBh+Hpzl0WWaiTyvZr/VVwGg3XadoGwA4wV8XEQCtCtKDTRV0KcZZ/wywA4UFNt4R+iqSgFqtFF+ +7ecBesv3f86UZqWPgW3U/CEI5KjT2gcR0BY9sLiwC9+eP0Rg+zBUr9+Xdpb/z6grinOR2rqtjucV +kQakArkyaIPMGOqc0d9mV+QfrnH0bXUu0U1mVz3lTO9ift2AB8ZI1yL9eVQriNiK+pOD2rr/+quY +vxccKOv/k/te4KL/Jem8HQcPskIYNZGMuyjIOpzjY/lTDiCIKHUxntfwcJDljExD2ptdmsn2wyQe +NryMkJZQ0VWoOYZ9UMaf5ZVtwFROeAvj5BZfMybR2pdBGmOQhAsbgySay5YXEF/QI+5iafphmJdd +urYnBWtV53CnIC+OgKAjWOtiRleA+TFzO/DI+48vPT4oUxnrIEqqerkzNGh+4CUlu8WpNIXsXxyf +ritRXfQzUbIHlZHOcXCJJQJhHq/EL4i+cpVwxoAilw+BaV8+G9k5/lQYhbfaUSfkxwfHnV0ZL8h0 +zJMPyuG4e9HUa+gRKlIFnsxGm1uojgIPfco8rHQBKqBkkOaHOgzUdrFmHYRA1TmIQXeJ4uzjOJkH +qWTEj08uo3lo1imNtLpDjf1I0KpFU33Ed1ZUYtF0oIKBODb1oPx3sWP7CFiBx61ULAAFNoZuKGGh +iIIv/Zd3kRBc4KwsSZQSpQYqbPIIaKwq++UHyviDMiTRuaqMKz9g2o/CVn0zN6Ou86GebrRPavBe +Npr2T7gLt34iln9+aboEIkx5OYXoT4QWQcBJ302Mio2si7kOYMcYxd3HKO4aR8pkCbuI1BPcQHXz +6DyA594HoxONsJa826l/7YuliDqD6knZS8M8g1jyXEcJxcHVBQN5HpfQGakorJ9iZQXO6YLNo5sf +PIb3GzzR/9+JUe8qRGF+NqI/NlW/qQjrqHHkvFrmE0yaXQgOqvJ6OzBH/v5+HR+hlUiD2r+arjWq +XbPO7+dk4tDpHdairOrAqoj9PaNh5nfVJd4vD/0DdzGmMown8O5t9QU1F7dBosA1GrV0RVjUYEFD +CSxEewy3GyNoGdtNvsuhaLjKA+VtORMWA3Op//8bDSJWd78Q9S5GqbMw19EJJAJhAvR30M0gQruJ +HTFEpoi/VToKO1UDYIsQcH8hUXfQE23DwSjVW+NS7iy2hS1go+ii0c7Dc51vtAuIoIRnsgVWDeDP +2MvKnURpu70wbSbJQOZ3RgeKMDJ0NK70I+P53RnVRBP64WFFDKvmTyhFl3ZEwO752WCpNX/H5xhj +7v3yqGUzu49tz03Zj5zVnXnDVF2jeyJ/tYeeOk8k+qIYWniUGkziBH17+dtjoQ5MApwZA8Uv3LkN +2evtNo3XB/aSd8j4DSI1XeXKUdhKWNB3TiMHAgVeZN95SdCUu11Q++lbzqn9AXBa+zjIlNH6ZEbt +PAk0R5FKuJMNvieW2RXMCiVviUo/QZKgL5Hwwygtwif9H623qzs8hIKKPocR8qF3PdgPo/ISWc98 +buZEftF9iPWyKpw13fIul5RlLwcfI2Aqz2FXtsOu5EGipKdzP+uo16E2TH5VcIp6siiYeN4IPZpZ +Wm5H/oqy5b2hNpu5Hxqx0NDV+ZdbfL6A4EDQa7wZEShkZUML84UtjRjwPIAuY3gzdPjWHJCtqKl5 +h+gaEhFKiLcgrtfOvshvSWrw0SWpuVpJWydEvK6t5VeVsFffpD59xX45bajuuCHpE7up6ZOV7zg2 +WMhrsZv/1UTtTf1+1HkC1cFC8v9T5+mQ28WnCuxllLI0B4lxmxii5IajaPALkLgJFqf487E/JKP9 +A7Ymlnlowy1v65G+elgSFJSvGePqB9/JKIAvzof0wB6gk8M/Eq/LIxyY7zqK0Q8KlTMRXZDg/l2v +A6JWZpiZTft9omx/Y79NK8Z8GThiEpejBPFY8Wzyc10aHzkrOU+0dKcdFLlx/cgoCXBcXQhkuwOv +DjMB4NwKVFM5IsSIao1uJ3Ipj6IPJGgILwHSRKxiHknePjOde5izpHZrGZLvO6tcrc9WgzyFfPRJ +mKV5I6sGeItCRJojeVINuTfqA4yXrv5JwEpqvo4IQN+HLXFa5BE1agg7mxEditlKyF5NQ/kL3dkT +gcseBhhz5lpCkHEi/qLjIcjkMkaJOicAAf/dnNqKO1dgzb4DGC96eEanXMDVjk6okpkXBfabOiPH +gOCf6JCjsdxvbZ/6OFBMWxWl7XqXUvMqURPi6Gim/NVX40//gm8jvScg7yiIcUkW31AZlMOmn/of +ThR2H3SobEEqmo10BRSDYQcOzQH4sLto6PQKOA62orfi8gbE4aaQ1JwRdouGN+zvLxZqWkbKoHWj +CvfvpjlqEw7mVfdSFgwNtcBJMnbEzgdKLgWuUMfxjOJdleWHY+z/v7581+egYhAELPFrE/rEsR5J +pnsBBiSB+PaYgUA4fQOhqJ/jqiL8AIUMvXuhkp3uKLB1oVXD7udRVibVpzFd7Sjb0Ni79YKrYDKk +Ei0mPEzIEaTgJeiUUJpx3TFQwin5lTQiqqCO1bFKa0ls7entKCCzctDBT2pIYcp+v+7qiDUVI9gz +jFAT93Y2RUAfZf0+D2UbQfQYiHKkjUgks0L+6np9pUp8pXrLBSj9vP+SeXMiWC+JeOdVmIuDCUPn +eaj8e6Bok5yn36dt39K2Nwe9Y029j9IHwIHRjinYsbik+fc1pRrPaWz2veINrbXtuy/RqIHq2WXW +pZN0+2r2bitocam7TMmqviXnh+TnO71XAEbcnZ3YXk0jvOt1Lh4DAYP68t3aPlgkvcsRzWgyOexA +Ipv0UBY/WrEMF3Zd8K7ynmnfzQk8wj0pIy7nR6IUkaKhRqNr36g/6zp2WhHCuYCaCV9CegMsT3lO +5SrP9tpp2DurUL5yCFPyRdLBbJGBoLDaHm+N3dCmO/iJUBhcHcyAPeEuRUraD5Cab79noM+jnLvI +EaPw5gbZWZ2BrqA8dup89VNgc8v2ZT7nY93ZSCtVlukK/71Hv4RiUcNowFaztFELY0hmBFTmHYE7 +nJd/9XNWfirO2s/XIg9YIOrftYpRuII1I9CHiTkKkEaYfbAAEF4bdoCXUxOnilwRU8WJ7DBKp7hY +KN7/XrcM8+LMneXTsz92Vy4cW1ugM4Ii5r43PqrzgKrYxRnyLIB9cUns5fdxpQFWUpkRy2ahlgyE +QOPxiKr80nglrgzX4kO4op0LgsohV6uT5d4BAhNBBgj1VbSD1Bou+ohpF7NHsiMabU2Zx/0y0mvf +L+NY5qSXaRqQ1eVoDvn+lYlzT3MI3mc50Mlb6fX955jeRNDsiB61gQgu0+/oPPZ2HQ== + + + o5lMO/dlTnCG82zD1KV0CPmqZJB8Vf2yXgjwTVrWeP/0c+tRxkW9s4CXQlxejC2PwAjkUZ03Ev/F +jAOWE0mlKkNwK8fRrHZ6vJ4vrG6Vnf8Kjo0uIeP/Y+1fdm1ZsvQ88An4DrspqRFyu7s3VQGhIICC +hOqU2EoQSQoQUKkkVCwC9fay7/vN1z5nzZUMJBA8QDL2sjHd5/SL2bAx/gtWb8HszbOP3DnGlM9I +dry3+TfCtUOtgp3TqIEOvOOKDyjmZchrjldbzSiKNQ2KMxBFcsHT3zV32QN7lYzFlFU97QLo5ylE +Fuupt6klDYBHhntRIulJ/piHgFSygb/LpyrYPqBXzN91HoXYZtWy57j4P2Fp9RrYcGHyLpIrk6Ag +yIyi7c7k9wqiAImEGewjhdOPmt/zN1Obv+e2puJsQqK7r9gNGt+triX4vRdma24iVWgKIM4DEpeK +4HyVyNl3kiftdcm9gZfzCXuJHej+jRfETHUzAUrqZnDp/7gODakHnPWP50x7B0qjj0pKooDaWpOj +4VnLkRbq9FPUFrkPyVr5wMcIGTkIkUdd/T5S1yiHvsohTr7qeO7bJvP2Pt94R62WM5lc8xOt7fFd +1CrvbBKqEzOAkAnSaR51jFvNCCT2z3maXrOYt88oSyCh0pWbp173iwi6NkpT1DvmFcLkyxHt2IdT +mTqcs3E4Zy8kBxE5sKqIejL5fCh7o9qDhf2Dx/JUWf/aj0lXjKjrjFRCM2UmVY60hzbzdpeV9eol +/QAQF7kKbMwijaQWBUx9dgIE3CHRP+1oJ82gtJn9QnKOvHyXXP91nqXTL2SCQ8bnRTZKDCeS7sM0 +O25Jft/HW8/WZSUiAkmWpBKhfwcZ0m9dHTn3/bpVa6BOlW0bVFLe8fakrkTxalq570cGXUT9FMNO +q6DRwwCITxPhN/76CplGfwf4lzMkU5TMSVPQsyI9Rxu3W3zV+/KxRtVtaNMKqjFJfZl4wGmjUfKK +s8PkAU+CjSVtN3Bmt1IZewPdJepOKaX2zy7eHmvxw76fG6HnRtf3AOHRKqGgyg4u1BEygIDGIiZy +HX842qLzoGERQEL3C7owBXLePJh1V39zfWriQ0jfXv57Lni6eBPFzRb8PH0U9sYI8MPCcv81ulhw +ntgIh5FKr3czdIctvN8olSH33r2b0pNvhYTsewRw+nYXwSalxdJVmVfem1clrJ76BGI1wEgQdM+U +AmiAhwsWI6sA3U4OQ5X3Nq940D4VxCM1eD+LO/lvgqu7JJ/9IJdjl6xcstJSe3VbOsYPu6agkGRR +s/YotSg4i77rBEbfxQOo3gW8TSXrC0aspV4Srfl1gqyV8lVDzCnA0vYjNt3FDUwWoMKzmerZ8Att +IwPvQB/BNYHzB9eUCsh82Ug8OOdMnVSU9GjFe/sjikvyuIFR6n0d3v20OCXL1wjzdTQ7S4pTJmfU +t67jtlGP7bdRK4+mBqX49DgLeaJ8umu2h8UY0/j+jnmZcc0p69hAwRaK0cE5/p2mRKPYfEpLNpew +7gaQVdnTEy+B6xg/qsfVn6MlxuS2wmYamDY+WLH3dyf3iiHtOzPvmIdL5ufWkfXyFZo64zvVKFKB +8EeBc+RTTVrEHaXV22UTzfRhn9W/VpsOehyC8q1pikGPDzHivGyiEDa7I4auYhbnQd7mJr1emfws +deEE0kG37B1fL38A6/gdH2rpqRHu59gZBk1XxNJVOVAQ+HHKuJV3gxmzchkV/thXa9r1veNaaPNq +zley786mcr/zJbpe8+g+ARE0UztKnnt652WLtbU6Phf16CL7x3xyf/+mc8QNKfb3zlenuXKlrLy/ +jA5pHDfsuMq9iQGguTy5HPt+NuyhXQykSuKQ1mmHPnvoS3QQTxVfoLg16qqnG15Bf3s/lxZOmrBs +a/30fBo6buV0k3ZOsFifcCpdh4OPQLmJpSlv99W+1Wu9A2czo4MgRQnUJQqQk/pS+IRxB2quS9pa +CPQ0kaVnFiyhOXbBc4naqRd9uGJ6boQGAZ3JPNo8ka9oiMLnBFKKcWLNqtCO7oQwnfZ1JqHsO6pb +dATbiTDv1WKixxUSYgOqqkZtS8wQ7RxeEQJujMgw8lnHTQY9X070fO3X9ywK/t1HMWLrFTxesUyO +gi9Yq5Hl4opWtzWSvYWJJzpb0Klo1XzWK8ndU2R2+7bSno/1Dk+PqtJT73VWj8uWGq7aajdBHNk5 +cnnu0KHsCaxI3F3eEVaPN/+6TkMVYVUNXyyloBTQoeYgCE/5mqwH1sqT42hvcKmTvx8K6L3Id8Gv +U0PrPnXNC+W195G9zjqKCEM9ioMwDx67NLV4HK8vJZui9kU9DmoNE4FqRKpmdwk4hAiTFJSi3jIj +kAba0TsKiGui7ISwC1REfyh7DSkYlHy+i4JPGGg9J4C0dE+f8r/pzcd1ClWz5/eJaGdzon6cljDI +Jvteft/LTsij4N0KfmjYsON3zRlpdcTRkFZH8JXsJdIjFLnO+oGydrS/td1pJvEAlBDTViaQQrBy +tqgy6oOI/YWq1CPqCOS6CAwz19F9hPN+vb4/6M53Udk77WmBWh2zRKruj78EN8JHCL+r/n3o18yR +vE/MdcCA2D1hQW+3gEfmippTskBV/+my3e2C+sVyFgdUILL7MFc5e8YnvGrm0GO8kzYhh6g+2GSd +QEP3ux531b2AzZfhWa7MLJ0SG4Bmup5N8XvKEAF+HsAm3Zlg7DT8ZePodxnznYtROKd40N7iwUPO +/ZuPpyPpk9oo7yo4PsXvAfOAGAbAK66spSTlcStk3CvkmamoCvf3eEyRTZtagDO8pVB1Jd7ANrjY +AuzvFhTYvDe/gY232yZrapFykHs9YCU0gq+XYd2iN7gfAkr6VhEi105NRQuPddjq6JjorztjeXxj +jLav4X85NT+ZOuhoDJBVKxJ68DuLjGdARxaEmHmPO4ba7ADPKMevsyUKwuoRtRlcNkJpb4nrxyhW +PeFh6MOuIzNtxHojMEsm4utMElEo+t0nQttY5of++0wkXcw0umneQCVI1OnAsIyug7aibHGsJKLQ +Tedi5KscBkgfKkYTMfNlcU16z0P/mZLQuEdAY9edwxTpzKjsuWuiq9AN4KaBKqNKZIAq74hfSx9m +KitKoSAack50T51V2CTB8YrHA3kZHg8W2p8Da4fSN+OqjZM5cMGK9CrbP/XQWJ5hCkJYAbtN7YqO +6RcZyZcTZ6UL4XGcSCRegCKjXPoc+n8NGsQINRDQ5GKzUb1KsaB+2WwMmthVjGFKPhUQl+eWBKXM +836e4qHQA+dAFokEkwhTJmhS7T28HYB9n14TzKpRqysUe+7gkCP0jSsFLy9GrSIDfMTmJ86b7fXt +BpwESJTyN48KbwnrM1BjpEfqa5nBFH4d4m1tinzyd2GvFy2cPbuyvbtjEFtOfVxBe+XF9ux9ae76 +hDhPvRz8Anw6eXMFO1y2f6Sihcoi2Rb99dajtCNcnux1LCs7e/VATTSzEshkK22ogCEJBOvdpeJu +qV584kEHzunw2o4xApJ4XJ5HnbYROx6EO/dFwjb6EH9FDaGBfXJwojQDuUHN9ch+CSqFze+0jBT7 +Fc09TYlGPV5KqGCfKiCDGqYxWIaDJAt+yn0rPiiiS4jwzxh88Gc4A/kzIgn7g+vdG6mdohzantiQ +vu5qdOHG1AOKs1uuUJbEnOZ8Gyu0/aNNH9AtFmeBCtQhGqOQrFn0m3ESpcoMZbWpSGIsKDWEsYAK +4En5vb3owwDXss2OMbs97/WIKvqOoK2QCNR1iSDTf890RXO/gR4wiKK/gBxqIDwy4gsAAQB65asI +AbdtmQDkoYq+ODlPexmq8k+4sBBbFFCYfyHzBoWPJTgZQKNAhRFTusl16F6AdI0KOZV0GxotMgsv +TZGuKTMZvbwrNiSPcwUlUdqaT48k417g5xJ0PAPKA9gJYFMiYyapfuUpn9Zv4T+xlfrijx3KaSTw +OnWN1PMv9/mcKSzQkWoAFPedy1IbWytvNRFFm6jZDuV7WpZBh+mVHCo1sF2UYjUjp7hqmUHuztRZ +wl5x4ZECAwA/Bpi0AH4x448eqcwsU24S9hwAsG41Fl6dtCtwtaKwjmlTXk2U6plIyvFmImcVGdVP +Ex8DMxkQpYsz69SB0pWQMHHuznNI8KRVLa9hlTZArYjK7PVi26t6v+m56CK+9u3RUOB2VecYlK9l +Wv82FLiPunB5fMt6OfcWr/AZraFbeFhh+xKyvmQ4GBqsbD8eP4T//czRXnhPlAVFk5d2+N4zfG+1 +Ii96ctUIypUGJA2LFAkBQpMxsn3Oibodrn2I8ipyXj2iO5XHWaWDpu7WnQwLPeazr65aUT4+iDG/ +mQrzuKjkq2CyCModcUaQAveQJHjOdJR2aztKI2MmMUX098kvUjaumvwMrdZyGGXVhm8m3pv7zQRj +1KW/0PHk4tKBOE/ZDLmkAPEiQ92zJc+kSp0CfUhDyEPABo0YOy+n0UodGU4L6ylEb/7Q29c6qOLX +3j6u2HZS3aDQBiyCfgjgI0ocIJpNmuUHR3MC+IAqHCfv5hBV3vsjFr3rSPKVUUk/oOyMD2HXug0h +mgEkKnOIWtA70V4N5D8lNfP3fataxDDcp1Ku1TQLFqtaNrf6eb+XduYOvGpU2CNFsUgPgRBYFhaC +vmENBG6L+g77COobKh6jdgupvWCRR3NY00IfeRgC78JYYjQIgs2bDu+6RizXomE/0GTBZDPHdc5i +IMyf+W6LVMaVb7F/vexagm6lJCZIBj8dxVP23DnvchyYDsJQvpgZSIqxv9A4VH7UNrHyZSdgQaeD +gopIOE3lW2XKS0AfezXSATQg1Xpq+meHVcF7Y6+GqaC+m00N6V8kck+6AusEy1ZUiVDEv9nVo16m +5Q2tOZp9iiHUWFeJllixtQ55gjYXD61WBwFJ9nGquBQZJ4AZ5LhZyFktF+ByxPRuTc3BE6kvznZL +USIh/ghF16Del1sjmGBAuW/sDV7hwADUrU64tR4wMe267xe9pTxhHfwCyTBzmOwoByKAR8gXMAIS +vapjgXrTjZHq3DG5osGyhuBqwNrTnalgYvVKxlHflA6ypwo861n2mBMtK60VkcTZlaNmAxeBkDa0 +NsYo+/mibUhJv5rm8EZZ+KaxcvWjwq3+5P6pPQGN4rCdl3au3VCuXyvfRBSoQ/sH9je/kw/QjVI7 +iygQoGpc9aPUat0HPoDUQHCeYNlQMJ13BNFtV4CYYWnvcoJgogJKHS9R5A7m4KJKV/NgL/hUzAk1 +3W+nsGvPNPWJoEmqNVCX9bgZmYQRRdCZqyTVpS7wPK+06yEeFBrcXuAoosIHGTYmkfVSSpgqua/w +HSQ9yO6hxO8hByNSNCQJfrPe/DqTCNALwscTC89pviVQ3iam1nzXk1keetVQUrFkYxPzrin9jK0H +6hZMCAfMPw5ZY19LlBFkkEOqvmXQhR0V+O8ci8oZEfTxiWBxjUv3OhT/G63mC+bcbw== + + + tgAcTqaWW2iM6rFMeRcqLRHxdtNXmOJLqPpHZGPdwnVH1DIA2DxWfe4ndZJ9k3au+uL8rygYitGt +gbgH/yV7oXtzXcovHLd6PLliV9npEw37mXn9Zn4bRoDBgnX8A8+Z1jxi6/urLin/4wDV9lIya/y5 +o4tP1nLo8jWW6NptycMSSjSSBYBMH18ytTM1VOXuj1VjPFHFdcQ03b3kpYToTMSlOVRfltyxVc83 +0DgrEdJ5IUG8Cv9rBhFH60x0K1FHEJ16JPwRebZ8T/rmC5jsCSBzw8Kj61kGyGZ9TZdaDSIQ1ZY4 +qVsunjh6Laf3j9VW8z5APl4KnjZKgmwwUNc1FebCvdyjfXdY/vsdcwpuf1fAkB05kBCQPQGSBakG +o8UdK1Wc2wvIIvUi39fxeVjwrWYY7vpC8gDos3MpB8GzX7TdpIMIDHO/cFMcQz/LICoTfrUrwlQ4 +WB6ViQTRZgH/KlX0OoRSHqy9L/63/yYsNytzNOZux5AhceqL5iuIN/n81xEzuWUKxeUh7LeLyoIv +EPYDOgZfB1ijlqM+bkOouyI3gypMuZIrjEC5lOnjbsWBoGfHxG3MG/oqxN4xo7zuo9eO1G66IJo9 +XmyGQ7Jwsn+ssRxoRo/gwqPP7HX2SehI3q8uPMIeWgbu/zdGYOt0DHYU4CZrJdnpkiRyItCclCMR +Uy41wq3ZtTWQTPe/oMJE7ZktAh4m5BeSvfDgqMs8YCfaZTmhwphfimPL+3C3JrN1/97iRAjWUgeU +fahysPXw6hcXhN7YfPtd12W/aykoes14GFUIY1coGMJlrgMB/3dnIyvlsKKDX8NuCzuigl4J80Zy +AeAaeykU9RyoR92slCYVH1hh0GTQMl+t2RVbkj1JtPtot9Ottxw1ZwS2euT39nF6qiUNRo22vEsR +IJc9bBZ0hSQhpkkDpeNV+mDlIync36LXckTkaWeVBrMwtt8BJ+BjqWIv7S8Ue8F7aUH1qOBBDebx +5xzfPHh8ubHgxC0a7XNMREwRZK9GqTx7+qFk1PRDPY7rDD0x+ugUIf4mDO/vCfr77/4FP/p/9YH+ +hqt8/iv+95O/u6in+ijGjJCfpRcxF/slZ1fzTycokycuIOrh/TnIS+WcvC9VS/1G8TT+vp5zCVlC +UHV1CwRt/t276YFV3FasDq+OjE496xJhnwIbvWdiMCOiBA/1FalqO3KI0ZnHPoexgZ7zF+d3R+17 +qjwWe2yjaFoQVTWdIaLr9DeqGuDAdaYgmjJTl7yP0wPHuHIMleIoHZSXYC/LszLDDKT3Ig/sfGqZ +pHgcgVgg7BCLCYSlKDGMJZoRaqvRiNexhghycSKud93tx7GRBuZN8+VK8hTNbRSkkYNjuhlupnnR +YwUo2+CCStLdBD9CdZiOjmpzUxSOSwxg8fLYwhRgGg32dixUSiXhrtDa82k9JYcqtam943FKpQGG +jxIIhXqI9uQEIAmvIpclrmC3+xlrboFO+ICCa6/hkS896AYzRS7gOP5n8fgI8exr6SLH59o5wWhF +P8O+neiqP9qcZ0Cvk5H5wKtO7srSeR0G31i6quws+ADJjMIZnntzn6zH7z/AdacDDBCcgG7Zeb1e +V8NNdr7KyS8y32B6/CXOvvfvtA2BLZYDpM3Mtpe38gTuxcrEjuXyIaB17ZpTJV1l2b75Clon3J8R +5gwlqTlteAEMH4ex5gmlsQXBChRET66GI/r6DFhcQV/MxqYwp/kIOugANgi4QILXw8MPUEqHD9OE +CXUhepRk2ZE+QyGSDOTbA0ORkYc2evn9KTTTQdXv+aqvI8/fNfzS18qUyF7RE09dqfHnJXOMZuYe +G4oYwKwPigY6zp1P73nTT+vCBzt/LDn8NOHSmZ/OeHtPOBMRBDEqRGfiEANFArff86vnRBAZlAIo +I3Ivis3tgP3bYkq1lykPI+eHiNufNvdP48XgRIP8GsW007pjCkV/mCm02mZiByY6DJaEx0nVUUzb +PH4Ld+s/DfSDPJGv9DLfv0fZ+YbcDy7d7A1JAMAME8Bpc03nCKzpymGA6qS/qPPkPe8T0U7Ewf/0 +Gjei72N2Dx5LILgmF1N7Wmsk+hz9c/ynB/UjCjo+uq1XAUfRFANuKv9VSqLh3Fo3LEOpOV6lKXWT +buhpDVo86wLoKGFnhRA+SsuSxhn1NyoF1N/W8QGwvoXe733wBEYhtBCZqseooND2PrVfp443NYW5 +qpwc/ASeDNiFRF0VGonF3fdFYpA+Jgy4qrB714ZXJXO9MC21in27DgiyH7Aol4LtZ23ZMDLQFJbj +AbvPk77sfYPHffQCu0raVo9iDnmnwOrzLi99e1jUn2BnwVz4S6yfPFLs+2dEilGh4n8Muhm0SrVY +7GdumPVvuu8tzxSlMj0qeJdMXOblJDr7K7dClPXKm+ZrovSN52XvbR2XPhWZq9wcEqel1PAsGsr+ +rfzrv5p0HhrMv45AL8rBijtdhRLpl8CtYMO25Hzgc7RSpWR7nTJBNipd3NSxcBDcwfyfl5TKtKk5 +drHuIZit2UNIBRhnL1L2Jqm+9FBOr3oxHytxahHADkgF5pYRWoSjCktGhJdL171rQqfMmUQDIAdf +ciY9OCimXS+i9e5B2OwouYpGXYHkK/CEltqxVBbpCihz9KPiHfnn2nR9JgJ1zh2xen3F5R/V2ECz +9Bi73HaUKb1Xxd9HzM25GqXHB2jJaUfK+jA54xNOYvLMUy8V0wgz7/lyW7WUvpOkKytx1yVt76ja +FVVyzTka1nKWd8cxWQQey74K+onsqz0FV6WNHr0I2PFSD/9iUbjxJlPpLaZRNEOJQgjLAJG60MSE +qj6vvRmaNcUIWUk7YoyZCDGZtLswrsyJSnrotJP1ACNKYmGJ0uQeuOo5QbvV2ZnNDSQQ4+53DKCO +AOkmhe3eiz47hqJ7Kkz2DowENh+VcXfs1k5XFJhUB6hUVIj4W6/LX/+Or6gEE+Vs94uD/Sj4myhF +CjkaeTmF+JMQQ5M6+CGgZkSNR6AS9a5bogqkj4NDasEhcYWJKKqoK+YRad1gmXa+W9dvpA9W40RF +lwWkkmgyWDKjehzVjK9XfQ1zlhHp+WCu6NXW81HEhTjB9dVM7QcBtu/ftcJ2LwpwAginT06hDnAA +OlVkdM9pClHqBfHXENW2vH5fEtY+IlJlqqcjyiu7fjjMRMqc2Rx9xhHWr5nbUgYi2laRzxjR8IFp +PqxkUal98SBEUUi46DYg4bKjFBukjPkcf13nievo1BPhCj9BjT0xZY86D6CIPhPBzDq14viDxdkV +ezIk/KNEpOjMjrquHCf7K0nG50ywVXbEEockofvReGxv6KJmBJCH30T163dTLI0oTO2h0L8yQyQ6 +MyTBS9Et5JSAnpV+MHgX2JA0xbR/ZBWlaz9QxJQk2rQs/FpTKbs+NvdKJGWC0eoAW6caJcrbXM/J +wSkR0zxd9C/rjxEkNV3JYqiF54H4HrVC2lPF8iqpIgl1ukQ1NUUwhfbsFKuIvZ7tbbyAXamfEf94 ++iKq0VxImivw+3GcA8lEdQAJ7y4w8j4DpKbIiLVgH8O3xyfuFR/7jOKVsNUwi85X8zSpuPhY2wlt +lH699lpIiXEefWHcpdUxXsl40OMuLyKBIK3Alig5o25ydmQ3R0tudZpqe9dIyqMxqiLKi7XTiFzV +hTHbjJqiEnxzUdT+OhM4pkfhAV5qqODDqLnXpJzJot+O6HoaEDHzoAmJw1Cp3PWwyJHy3unLeEUd +XXK85GwP08Gw5IPJq1JONL/SQdyXzlp+jQw+1/7R6+17xKGf3taOX1O9z6jrYIH2XFTPtR/WyckF +yLEprgq2keYRp0puyve/50E+XtiF6yMA+funwT5YvBJGe9s4NHP4GDDtg7xzk3u/xq0fUTAMaMqs +WJSqTeOtfNJCXQJ2o/MqlaccQQSEnCNNuKe1+hqSgbyOD1sbInxg9edmQ4ItwWZwzcFmRL37++NA +8zxls/KkgXP49DD8+smcwMXonVTYXh4gcISlSXTuQMSKzah2hKCVpgSI8qRGuJ8poStqB7jooiJ+ +eqyqslq5Zzk6U88SQkxu9QhQVVSlIsjGtpqKjijuY+wltNVZApIshdMYXGW5rGm3rS7jmrF+1eBh +g8baG2mFZ4mAtUaEVqZXPbrzO3kdPT1cMm4iftsOAoG6I9G+x4Yn961iwJ5ST+MMBTSNFf0EjNc2 +9jqZ7w1EmYhR1otoA7p0R/CTDtByT3BrNRfMcmtVlYPnwPz38yfJ72/nRH/PTRJUJeV99lta7RRq +oQNHuFd5j6Hjl53WAoidHRV/F7Oj2iJb4ldFugOllD4wNDqaLDagkcFRi11N173jq8jYjyucJ8Zx +NT0MrRazB43OZhRHm4tdxX6weRwL0ztiRh1mxCgE7Rf9JuoxqyFCnZ2Xboim3DhVeKNI1yi6zZJ8 +kHKBJ0AiuFPXOpdfYXBA47ycfknEAcWoDwfmWr85ZoJxgEc/81hNoLIA0lLZe2ruM/mAWmYLGRuo +TuU+8u0ANtajNI7SUPt77N3EobDMgNngqTdIBnoOimPb+d0Vlp8Nbmri5729QZeaL8hhm1mRADZe +LYujmG5yu1e0VQqze7sKbrUlyqkjRLWQnJdCR/6ItKJ7FtnS3wjqCtKg7zSr7VfsiPbi/oyC4UlU +Pd+HWYuogU2NEXulJ4KpNYsXOSbLOahvfxMdAM07bearC3NOUNNxuZMesqDdwvYRQKJhg4/CqMln +bPku9BgkMH2PmCchMQV7ZdWNWidKMGZXATK8IgQJSJ2pwXR2qABkK7BmtbPMH+SK88vy93QT+5HH +AXhz//4MADW3w3g7iOqF5zBt9wN6RHwm1lboA1c9dJj0fnsoYjKHHduaKdIESbt/M3w0lUQUvwex +WT18ZNWuu9GNhTYs24FVWJembwF++w+jwY/D1JWuSqd7zAzdUxpx8ZXnbMQ8Ec9rivbqeX0fXKxY +0hueK93UJ27k8IpvnQoe0Vi3MlDwGMfpD+1JYOit9ba5xI+V3zo9Jmdo4NDWNQqUQoxPltv+46O3 +RCLo31C0VaB+8BmA3Vs18bj+6Hb3pxgdQdZxBFFWZhxvjSbd0cyqWse38KFcUOz+Ttfue8D7WC0N +dYD3/RBU1cvhNaXYrTdfc3uGblth0yqZP5aMmAt335sQpvaVbn/gn3uBpPw/2U/EtIL6kL6M8Tzu +7qbAsNCNqRnQ2JKugnyaFeFDItj5frXbbdQ2G+TNKP0NIRwOVYdKqMk7Yu9XViLk5ezjsN0jIs8y +H/CnrJMhQdB8PUKEtAHdJPcBs8GWpoaZHao/jlRmGSOGWeth+3r0JABYmi60+zMiJ1jxI0M62ySe +qHUniuSbeyvTBxSQZplow1ykdVANmCU/I55AcwXLvIZzH1Ea3LQRg5sRhqMwEEggsdkYJ0UBcVhv +tUgeVScwm27PZ4RngjoDBRZwZJ8/HUe7bViCJGp34D1M9LxaTMM/RQQfjc7Bq1LyEQ== + + + QxmaHhf9++fO99U5XT04STynrLPXwwIKmFmRbhuaMWzfPiPeN7R6ZXDPeJ4fjoMXj5w6rNpK1guV +y9AvnT9GsIkKaolC6u/a6hMaJxr4TigRGBuRvYBgeTTnbpWdMaQtbOf28leQRcCpGxWgfR2o931G +5Nr1gJEw1AU/83mcV88TXm3t4yRc/UrChZdUuw4cZSfOypg8d6w+dpbB7vGsB1f2TM9xpmzAHyCI +o3TUzkCFo9gLT35MYuBY9aI24LH/GLH/qF/rzBXHuh0ldMGzu6frlL5ynO4vKEskrGJv7mTg8VQD +zMk5RJ85UQzE0Fx/RYl6lI5R0PdOgCttkc+iNaXQJnMCxSIz6Ik9q6oCIy9Cx+nMwlULeJeIfq2v +LEW4FhAlSoEfUeo3JLcEgjwV61YIbOdNzzDN+B5RTltfL9y3cP8ZpZcT38CqSScxQCETzoCJIZxq +5lN00+ku71/yWBIsMRS6mYHuL6XNcfQl27GCo6kuLGm8sjiIcQwjqAQQgRtyIqgEEvEqCgKtJgIz +lK8TRCeLNAYNTKumuI5hZdrOmZK9PkM5cZQJn67avxILuSn13JT7RFgQ0T7jLJZcP7cbndSqevs7 +6/G+CmCpfrE1crdLUQbLIbQKC6VnchhUPD8j8FCkMjxRGni3Pp9Rd4CdrLF0DqqtxK5tapk/OfOg +wf/87Mfj44sYTGfeHCdI1dn9V3YF/TrqnejFKKJas+eeQM9IK9sSuRGVTC/2ktv11zMJV70YbicU +iwLr+Jg1lMxBMrHVRgg8Fddlzmo++8SGnJrIZ8A/vm28aXF/tqIM/ffD8N6HpetGJzvZFR3kQenh +M+LHBfIjir4nynuI8iIVVZ/xRTGFwHELE7r7MZiDt0czSBbZoRNbIZrlDy7xPS7xvLVw4gAewbG/ +7e89T2ys9lVlKpOUsfRs7U2GRbOLLClLfUe5jpp035BnxlueWceP3p3vY1YxmLdo/+qS851I9BHx +X04Zybn74+N7caCmsndvUa5Z7ex7LiROqijJhz4AjXG0fmQYdx48CFKv9dGV7Mqguk4QxRyCaFb0 +662YIdj/nIiVCOFQRqwTUd8I0P5ElOfLZOm6wnkalnckPF+H8HyHvXSFCH2MptelhBN/Z+fLRKjf +ORFIW0IxeXnQ/XhV7AVsX80eBqo40BIcLGKdqmhRAlVWoQT6TE2Q1vuOiE2iVteIjrIYQBfKCV79 +b9qU74YIQRPNoFuaAeazyLCIQx+nZI0OWVdH0f4e9Gkk63G2SfWU7eQfSvjxn1iBhxG1pxIoHG2K +l9oRmJAQsffk6xzniVd6FQwwnS4YGH84rtPyhabYjC1Qj1sxeUD59WOEDmU368GdX6CGzYXz3bEP +ClkUyZi3iDtrTDv3Jn02eU2wkKv2V0spCCbxFbqUnhvobEuWLUjNJLmrB+k8rvOcU8MKixWQLizW +R37q/oPtBAsf82h/VtP8GjWzz4h9SWVoo8b51aW54uhgFJlqPbVn2MLt8N8iwC70fF+g0g7oca+k +AhNwySVLxSV3iSNFkVpMlnCZgw4/gjjwygueg5QZ+cYP2H1wSu2Y8EBfw5wW7I7pxqNGKyjpkhWp +4D8G6Q0SNeC8S4PaF49a0kekhR1o0Y66QGpdocYRoaMziKYiSijlWCJq4eaQY/pt99MHrk22NrDI +iwXtwLxJMTUD4FugdwNec+XTVosLwt93jh9ZQbBbvN58tLjl79RKjIhgIKTJ6xXFr+Fl446MsYfM +g8WEcluNEVrfWfqBFcgSps2MY+6zFhq8v+BSRzkACOMM4ojck+tev3hY9YrKShEaeoKGQTSVKhAv +KPSySYI9UoQFaeUH9u+OENIDaVS/C0V2bJ0yS/4+jTUU21Ml55G7+qwYFnom4FCcye2rGhrAwGgc +OW5hq0gNyHkCsd2z5Zy/LcVkxyCPO6W9PpGVQWdQQwQZePQ8OhLLRWCkrqYRM3M8ZIZ9bKpSNSJu +HvOrcftxFDitrG60Xdu50ZoOFQT0WpjqPFBg8OzcKHI93r97VFCPqpwUqKnz6zPIEkk+aBFHDdm7 +RhHAntpHBO8CyeHDJP6yYj+iQJQJQEabiNXhGmlbY1fJ9AvhI/JGXVO1eByWdQZmBl6TefjXPi58 ++/uuP3ycB2FFei7KS5SQmG6+BkaKUch0zT88PSssmqUbIsyfA2JYh77J3hewpRoAwZdyHQuVdBXq +rj9c5PwpTiL7Lg5/2PW2mHhUZqjd+lM/MQ+p0DbO0V4oK4NmLPxNOGpBRKT6KakUdLhNvmrwmqrk +AX4yguWVCNX86hP9fqfKVr6+rutLZS4Q699SCgAttsiN2NsoObGvQFshmTKNA1SCEGrvzebT94Fc +3O+Z2cfH91yjHsK+XAO0g1pQlDfRLHo0a/8e4V0cuYsH8/IZBDXEmaK7AT7fc4iIRbuKHhapDz2s +Z7WQ2AXC7X/NLyzNXQ/UhZ0QRaLvUcKpABQCp0ILgisdmFJJC8OJdUSRmolARWq+Y2Bh46CxrlZE +uvZQWG4BF/eBU7GWi7iozw+17o+IOmIvhKjQC1dOFJtNkRvrIDIfkROdioECRtHXJQENLutSc42H +mcQGYVaNWZ47HGScLCOnNoSi5LGKveWDToVkiBX3XWxRcAMhYBUPg1DQOIaYPQPLqRwDm3ZERwGu +sob338fPEgm1hHnoARnz+HENpwoKtSNfD+Q9EQNxJU8AALI8QmqimkpPGtOf6/79GttPrJDaXUir +Sgw8NC41lbRuHZM+Md+oUKrB8T1iFX1/80J/H4TRRLnOOYcTwCJzS8TuuJjPka1AGdEnvlG8UFoA +Rifpy/eILCEzxlUlMgU/HAdVH2qFqPpc4h6HksmfAxQiTUTuWn+DC77FfNPOprN/SYyGyHsHdRHY +OVbExfxuDvVzHgWMPiK+5g/aqKg/La2Svh9nL3nWlundy81hoyuW8A6+C6gZ2UWu9dAG4P4i1WFo +KH71tqqrq/A8ADUxkDxNHheeDmiAi8oS3BKOa3LCVhl6Ie4ACDlErP3r+HZdymmNEUT9hiCNZ4gQ +zUjuqVerrrpdAGrgk7XHAKGI6g1EVW+Uy+r+ueXlOWfC0agFfnL8VGFMV6T1eMLmzpDhtHwMrHIu +wfwimCRIkySE+QKkVJP7oiQFWMS+51LTsMSTsZo+IPUw2nVAHskKYPPdnxF5pI6aI0TFsvoPxxkl +Thl7RrvkUeL+qDAohDByfXp+Mza64afUYI+z+xkxMC+ATFcUWsNx2JPClIm1juPdntzm4cqGGNQR +z7y9pJZG6CgJjKWWYM4w9mR9TOU5TkjbTIxX1L2VgKGz9UQ/Ek8O9CPr7IfDr4cK5YF17KbmSgTQ +mRfQF7QXL3VpPxxnHSEkW1ztIHtvcbXrKj8FvEzWhpXii7L6FgT9ZipMP50M1xGZgi+91iFQUUe8 +FE8u+T2PZsK05OM/XLXPYhZ+9YygrNHDA5ky5okSiDy0IdWT+Am683LCp58kJJoe/syJ5lIPYFqr +kpoUQtl+TN9ZhKiZjw9x2QM7qXwcRqukuXWYTaT2mgwI0fmuriCVDaXJy2LRS9PHm1uZ9b3/jwR/ +fB7oP7OlhDYf9OhdzyWN6q09zvlDAJ0Rpf4vyiRf2NE/BfFcGbT3ANeRexchfu0MT9sy6BQ9+69L +wi/yz4m4wXx9RuSCjWR9CDHI5v48Tjt0Qwo5R6eliqDDa8TKST/80p1Qmk+L585FEaziu0LULTjx +JqFOVL1P1M7R/+35Pk8mf3JYJv+o3aPWABJ/NZgg/n66L+4WT53ozwGUXZqAyQaW7Xed6E9RHfkK +ljepRLdyIdmHwgdtURTUZxYJ6+4Gfd2SWt55H90queewyi7rEFZW450D+MI1pYRfuac07PhOBLCp +PRzvw28La5LS71EIq5hQu1ZOFZo00KvHQlQyAQQPOtS2YdDBNbFni9bqMSkYx6TguMaDwQ+y4yqq +5UL+bDIh3UrLKFeJqIl5KzE/VDUc/XXEaKnlPcqA77xLXfHnlb3dL+iaX4AOEz8A1Y/i/nRnsS0e +07xDOxqKJw08rtzCOy7QYCcguP67fxMBdJQ4aEGLTKfRJdENjTfgB/1opO131guBjnuYRks1Qunr +j6CqfV8Bx3xEvBCmADeGleAfjkN1W4q03hEQURYbkt8DiA4GezXaemEa7yBrPCRFDdynus0uEZ1O +KZJa+nWJg78qGwdsTwY/vbMDnPYFervkJd2U9/56kHKKe3XlWQI6ZrOC3j0Vko6HGFJBz+siNnQg ++PW3MXZ/T0SfXPt/kW//rzzYhVn9+COF3v/xH/b/mL/+m//21//2//6XT1Z+/ff/j3/+5//Pr//m +f/if/td//5//83/8v/7Pf/if/r//8D//+//j//yHv/7zf/r//8M//+//8D/+h//jP/8//69//v/9 +p5z050/8v/7jf/qP//4//8f/8A/7FH/6cs/XN/gbsgD/C/8X4Jn1YXgt+3b8QqnkYhlGNgdz+V+o +V1T6VL75+878UuGjKFuKpON+mS5Ui0hzKDzgVb3/spcGNrTvn/0UUMdCP1kxnJ/ECBZupOKrrmBm +cZuHtf1PGURt7HNwIclLCZpClkpTBRJM+6W6kSqQ119ec0V2yE+JQ1U0TxfZ9PilvrzuWZmvEWrF +IPQXHhTiaWecyUnT1zop/3P/JVBAIOfsxvcgoo+/GOhPBtg5MAAowoGrn35KdoicQSmX/ScVsO+d +YaGW8mjGmtjuu1eQznFAd1gHevcTko053A3XlHI68lFqjsFI238gT9AR5bv6FAyqZfNOoAM6TNwi +3nGaGn7bEfqJ9DcsJyH5Yr8WrO8vAdwCl+6jXoRWwUligb2sFSw0CiFCqkXajXPD9wShr/ie7or1 +6UUhowQtLkAKH8GvDIl190DJa8RYl7s+JGyGf5eTv1A6Zh1ZUEqWA6E0jFG+eEF7UIlrZOU0Z8Qb +Qt75X9IRA2lCC2/ZAPI0MP74+1lEu7udCBgV8ZQTdw0ot/upUpDJJhp2llyU88/M0echzZ/wu1EB +9e4HLIyzwZ8GbkX5byU0c0G+xlipFfPHnXMflFUt8A06Ii4OVQMs1FDqGJ8DAUTtT5UfBrUH9TtQ +7UVsEnwJnnkg5gNC1UsbEOqXyyjVg3q0tNNiQrnr9lMoh6nozIu172GjlgSokzTVgUtjPdVrz9Gg +X6oVHWw/YoPkDrQMgrtS/ZhJDOlNfLfCd/mmLp3kB8paOCoWxVVXI8e2CxA6wzVsVndLVOfvPCvw +YuC8PG+l6h271ZECbUPf6Bf9KvacQ9lQsCN1oX7+q4Dxw7vy+4BvMcDGa3wOXgKcLfQv9Of3Fbx+ +fCqugBDLr3KduWi9yvXo9LMKwwgM3DF/x9P5zjtbpLKfSUkwP9Zpe7Igl7qFAKjdyCoAco2uuGZs +yts1K3vgA/QwYyAzTzuCq6Bz9nyFMRv5oQA1HjUAauXITjEo1PGQrBgEJcOnNFNwAA== + + + OI1tovJLzMsTJ0XVZvff73HUFgvb7Sfq/JDv9mC9NNQAmzNOaxrJqDt+pzshpzD++XeOJn6u/jA4 +qY2t2AQg+ET///cidLls7fQzv1BwQDlLF3LdLF177uBT+86cxU5SP4vddLH7eYl8E6ZwvAu7jp1x +ooZRD3GJkv7eIoNw/CcnDbDFoHUvVp8p5+ZYYRY2ZnvKAZZhukv2XXwW2bAVBLs0IW3vDFii4UU2 +OQXZC2SiEUiGh4GZEXtzYASCrIKhHl46JviZwz6KbdCnvR8jeCOJKOWgdUskojCF24tFDdQppgLI +fU7OVPHN4kx7YSiBTIWVtSP27yCAEvmju/eTgAUJlhPN05ovQ2FKs33YiQAB5R+t0vIm0GYHgI/a +/zxAOwWQyc256TuvhIW7H/bnxjA3M6SwYOT3xzivGlK6kaRjawNhCXxAYT80cNHZD7EIC0VBENcl +0+9EaMASp4hjreffAPzuq7N8uw8sA5QwDUwD8AlkJWbTsgMOAhjS0jAAesUOqFcNQemS2oLGTfl9 +GpA3BFUsWUTfSjl8on1GRMVfecCNDNI4rsX0bFq+SFFhFEegO1/1II0rO5VzIqlgi1P1LJ0BC2tx +Mfc1ptgXYiS7ER0d9urxN16Bv77vC5pwOL3ODtOpqVn1KOx2N5/CfzpR/VJ8Zd0RdqjHOfNuuDv/ +8jg+3myjpHTWV6iswY00AqEqzlRMSyYshWrE/QpzE0WrQ2Muy4KTFjuin6AinsfjKI42QUbXeiK6 +yA4e2B2BHNrjmdIy5Exa992Kc54zVVgNlnFo4yKoCEVmz9ba5qASCTmyp5qLNsYFf7ftCNhP+xY5 +V4/xQ4RLWAclVj4HJxL/FsrHX9LZvCq66b8mSY8oqiUTiNVkvSZME5WRO41vrPhoafO08KnUE8jY +Jg2fDlp/D6h3MjIwVPda9ayvquLNtNn3jhm/AYxKJx8yWXXgUfALnxuPtuCn+eVQoypIlJyjsdGm +ioal7H7HgJSrxjearw5yiUxXv+C+qnHBy3EavYt1Zhxr0cd+xHNBsl64zl4xNY3vEpasv/+MKEVd +1s/veXRxfw8GGkxxhc76L6svFJAR1Fox/gOhslqyre9/92dhLbnWxxhILMtwMHdpNqByjiXk7wHk +JM+1+fpbVRSOSyAEDKElBNOvfYf3YzdtqdypK2slubeLOYJy6qk4Ix3PyN6EDj6y2vlIUx6xM33n +WP5YaNTWvoVsjPdwI4Kez3Fl6/tW7HWCVKdFEUnvNKA2dS87QOIi7vUcjE1nUj7XaJxbzc/B8vaC +3LNXfnlRWkl1O5bsIludf/j7c+z0oIKfvOJr8JkRS30U1Xn4DjeWdV0WJ8JhmETvTy0dx38Y8BXE +9RRezPfBB+ETEUxDkW4eONBSvwfuY3zL8j0PzPj3IGwemgVNz65fj2469djvdu15B3fmIfcskYra +t4xqexfA8dccTgpj8zd4I8AH118Ptfv6wx16SGh1IjsCLXumB/nrMgq20+ewAtmN6Ekq/EzDe4ou +4Ol5kS6ALqlop0LfLnnNO5ciVYbBxLt2pK/ojWmQXIPOJGovDTt9AOJqOdv1ovHS7tOAjrCNtMDv +5kZf9jwAFFysBNKHcO1EvGnZfMnvvCbouDM/q/BEFLnLMEpXyAuJ2v0kFU0whAzVveqURPjSX7al +CFga3aGdrBktb7uNsH3uwxsjClm7B1KOranXbk2DmvvxODcYSRQsZknXSTO7C5RUz1chWf7QAcwJ +wKp1XUprq5keaPsjsjKLV4TldEzElbS0pDth8X0ga57F87++TL8JMMRH7GmhaWKXmL7OZQNJ0Vfp +u0iGDIpejXZ0OplR5dv3VOqp3S78E6ceZpwvandcCDgS7EKaTm7ogQ0jLp9JTHbKy05tGBwapbOk +Uc7lRMHfdQ8E3k3N+ZkIFh7ONDWjrMmLiRhCTavFARb8Z7xejkSx6NNYowQVwKcaViDoZ85Ul9/l +9ukGKztVOO1Nf9Nii5yeM9ifk1pgzXdROr5fcie1ZimgUxpeVK6WXf0WYD5K2kP7zHYd72YKY5cA +wyJyf05Ju7yLAeGWLggX/OE5D5ClRSG8j9NULuZLKvc9nmbnINbNIxP354XSMrOttYXif7OxBFwQ +feVrvjQTytiUPClMpkF1HbGk5p4rde78+cl6tfCO8e9gZDqUxno08m+7NNaKfh8ecV+idKag0qNZ +elsNdU0jaApTR7fVxFIy8gWAu+WHXLhC7q/oM4IO4fv92d2wxsNc0RDi7ifzxAhdN3bcZGAEdRQS +puu50hBXcU34jIge9Pq6D38ehBGOkiQacbITL+jIOj0szZ3BhoMGspa4f1Ghvc7LMtQU+CHCeUJJ +Q9o0+/a6u/44DqoEV0T4p5JzVLt2ZJGyyVZ2xgT3A7bkzE21Em39gZzQk1259DrdL/ZNLrQe3bR0 +jHBjQVHtz+4FcrGKQGlYWgGhz/58RqTaAILigjK5U2BNDL5FcU+v3HW2rUM7DPQmwDg+ALM/I/6M +NH2frj/FNOVWut4XGFbEYnXvUTRvYGeuOcWt8/d+uveukcuOwyL7K/p3nxH+oqVbBz00lNd+iCoT +9ydNV64hhtIWu4qp4Gl+iqBlpL8ZdfuvHd/3KOEbrAZMifi6UrGmaTl8IMtxtAaqzaaFGgApBepL +A+G18RnwPm+TN2Q/b7X0+4fD3IrY4wuqB5wL36PU2oXKVY9zKNPygP4+giQJMIAk43qtSUdmIqIu +F+LrYAuKVs05Dq/4joAUbkQsfffax4akJCObROhE99CJYrIrWnl8nYgKBUEzaLjrQMudOj0KKkkE +oCaZgCi2wcbPeQDoPZIIzy9KHlWi9pITARjnNWBhZ3pkTkG9ij0CKje4ru7Ji++730l/M41k34Cw +/vK+j7zvdX0G5LkDa4n0B2DHn6K414gtc6+XVwZhFt1hMWhoPwUsTRkfxHzKW9H4jPqGTyoYUV6Z +fZOdsEMnEVOAb7/WYlbm8xmRSwYEiMcNqZOn/nAcGhRwp7S/qfmi3RUFOXcqqR8RT7dDgkAwBZEz ++3yLUolT61RxB8Vv/FjjQXXiiaQ+ZQYk9Wmw7x+LEoCXA/eTz4D3VbV09fHpgfIFZYzL/xs8/uef +3QRVhfZZvd7K2/eoFc8VNZMRaOW8efpW3MrGUhgEnNuNP2kBa/swh0AkAMzzPSLXiSItUfg9ykn5 +fpyHwo8yYbOq/md2Nk52hs6LPsoHXfHa6mKMXCAA3wAdYxmUjTKb0RE3aN11ulpIRwEsiLllw4II +DASJqG4ShG9Q5gG+8fSvM92DXAyfrqMomfmf3UmNizOpLxF3FPTvU7qaXNM4SodSu48hrcUN9/tT +UCuWj3PmJSxcuBflArdftb6mbo3T8G36Iv18QcgBGbs0PZZk8n0g2YXwl6YcbPwqPz4+8t50hOUk +j9ExgjmEqQVUzc+IW04yD7sM7Ddv/XOUYgjU0NmtAY8Wpr9Tyw5AkbsyzoaqwIvGFqFg7qVhMuyV +SIjikEPRZbQ36b9OuranQ9Z6g4DmFvpnaCMicbvTWFRu96SZiPVkAESKA/AjGXjIjGnJtpc6bhR0 +vB01eDbgtqfOtLMZxBE4AcppO+JSLHtHWG0p+rG8N4Wrsb++6oZEUPbYEV9yUCTqw93JiB8st18v +6EJhG949kBSXjiYWRA8HUVelUG7/IQCsSrNtQQH/Nb3/HtVuLe1A/UJwqjZwllmostkvboqNT5G3 +PN0qvn//enrnCLtNiNoZ1BmevYXW24/fyb01iEI0QDCGn26FaFayJd0/PIXCnXJyJUwo3bizAJai +ODIPnmUTtI54XVhNr6wgYCiixZbyIfpNpLQtXxF4RQBifw74x7efA2eVYna86r4dZV8tAL68Dk21 +MjzUl4DICQzqh4gfF8HvUYpG2+Xbz9K+Eb8KlM4BbghnFT1l+jHZBNu1l7XSdT/DWGFgkK3Pmybo +je7WaXrQGk+de+8HXELQ25aBQwJGbxA1JZYF2HYtEujTejH4eyvhtFb3TgpQAVmVBjRSV+hXHjcD +6jEuFBO0XtIQQGrFNiKQyqIiz9eArcxrZganKPyWQP2Up0Dreu8P3HM+3c3Qo4X9nusf1gNx/rf6 +WVa6ELm/379NzR6A+RpsCezJtJ2BeQb6OwDrC+uZ+R6NU8WCAkKU7pXVulkbV1wwwsLDb3YvTgyw +Y9bW4oo9hlpzHg6dL/a9rHX7QtwIrACQR4gt1D90MG/+LbZMkt/pE6vm+4QsqUwwNA2WZEt31iWf +83gghU6R377MI8hNgb394pR5GFRCZMFwMCjNY89NdE9A1xYRFSOs2kdm6mRg9hZk3TL7oN51pBF9 +CWoAdcoasqCwKubtyICC3HtAwzoOZ+cVGfspBC9pscV1TDBpFevPI8NU7s4vNhKz5l1ARdmUFrHL +W5O8R06qWqf7NUfdLddOVS+ffBVOweXvjSlYpL1a3HLP4nTZKIv94e8jnlJI69YX9vMOwpsukDrh +HT+DuxZ8FJLVdKDxfKLbUkgKr0CeUIPD+vVBhyrVVDRMCk6OnWfdpnqOiy3kfvnwBHlm0aZTkAmZ +BzMFssAkGgWZOWZsVE8vOun0u0VJ7e3GF3hFWbxFHafb3+k2vwfChV0jUSKAYD4q5KpqlPqkEWgq +FsUFeZUb1aM7ZxLedYGMeb7OxCNIlIWXfJ/ix6eueQAYbv/t4kngZeuyHtUCqCJHnapckvn44ku1 +Ownqocg/MPv3JYXF3/BeWSJdaMPBD7ox5WIGkibTsLmK9wVFTa3dmpLDOY/GHAPb+UU+fqI01KGI +9XgcC4ToT8ArVGMHMfQdcdNq3A8RMIRqxdS5lK/C7GBf+t1qEdWQbsCB8JDp88jAJ+s9Z1qsdRd7 +vHL0x5YDVoAohWnzKw9fkFlBJvvrDpg90UjTa3RE+4b56rrCMdV79EZ2Zt+irwGMdfzNgIxPgfBr +UN4IVeBKcWl6A5GS4jydFiTcWQAzSoXcNDDZ6xWuKflG+wjw24JQAiw0QSdp5fHtKNZ0NHm4U6/6 +xgn9DGhBpOuj+yL+P6N6Dy8Q9Bca5xTQpRXCyMfXj1o5zf0Cs8i+Jb7BCLp9j8h9hRjKDPxYD/vh +OD4ft9O+oHTwxPFyRrd4zyI/REDtbfFxfnm1n1E4uDq5PNga7+NEUud6QnMr0kR5Q73aReVvOFK3 +t9wp844cwu97ctOJ2KljEw5629HgwWBu9TgBdyBHAzCBCLFFj9rmRnSeDkR55zlTjR7A3i6fpiNR +ZgATCCsrD99HPQfUosmEiBCJAkj2PKTUpokgdzeANYwA9ikwVvf8QCsSOtj9dSLLXTboVoiz2UxT +jqD9Unmde9QKWAighXaO88AppHAgWdFlu5oafETk7nzLeD6Pg9W2VMoKZOX2uyCdcNu4W/WHCJ+D +fp6DF6TzEcVWi0z6Rl0A8JvfeOUbP0e0Qor3TUViZ1y0lAAC0SVTuu97wD8eFJMdCw== + + + bE+d+T8OA9yFNZgFQ0FxifM+VwNsjggS2wh7MgVt9LN5IDiUwGYASdzB4veDp9kpijAWhSytKcvD +LyiyfgaoQtlUoVzPabV/BAE32J9FN5PaOxhtkjThPBRwsNt2R/Dgm4vcCEka8F2qvfO94zdIf9p6 +T7Q9iCLhxwq7geUquo2xBvHnlghflwKa5U4EVsI7AmdhIyLDuF9PKPHvmbK40usQtQeQmqmOKlJP ++xVYtRFAG8EdipblVWby8kxsSWHVKsVCxO2KWr/kGgvZj/n8vlLT1dn7pzJgRWGWJ8eiOGCQerBB +x2UWW4f+QwT59gTR2ck/51dj9E9R+3k5+l0F3f3m/CuHRFdeRH4RaVCjCgu4m6unMuTnwD+eJKsu +DXumVeCPqEfEXY/ImgJsmBWzML4DGrO/3Xn/FFW4GlU4Fnut0BHWICKwVQB3+0JdCrORw7K7m58R +X9NGh9WGSsT44TCoKdwxeLhIljEndq/It5a7iLHLfa5fz/V7HXYJ2rfQIAqdRgHgQSxMZp4RFCsR +Zsenm4gb8awdMfIUl7TiOMbOUo3QLmsVHZq+zuR8vE4XCkifGtlMiOV8YZxYADZhWhHQ38WiX5Rj +MoLEkIj93uUQi0eL4vgB4XBBcqKLYjKHWfH/3p9i5tkPDqUnMIpg1GZwvrTb0Q1GpPEzgkc0lwW/ +z7Nf+oxSvHL0iFdSyGD/Ra0I9f3nflVU76OiWsFUTARSvv/dRwpdvLI+xjBJobMIwhjtarpmWntB +NRSBDgT+7C9pugb+3w8yGvRjdYsYrCyFce0Q9hZx78jAtFR2KADa1yERLJUxhkdhqdlHYZoX/3LV +bC4GuSfMJipxMPFoO3wMuDG8Ajb6GBx0roUzisBWhLJSHfkaoNYvjHHpbBU48Nfgo28syHi3q6AG ++mEeCMLczwN1KOrXSBoyUF6g1KQeEyZCAJnDKY5gTDSOiK40CfbY/sRsimmJhCYRDY9zuOU94SJq +wTvA1FU+Nd3u7IEo3FP0q55nYFHoAJvvvR5db4FuduTEck8uRDgpZIPr3AvVLMeGI6rsk8bWHwcQ +g24v7O78ratkIIA1Ivkk8Kh7Db7J+vHP7sHRJZKE8G0QIxMqB/cSbQM3Eggs7JbsfwGx5bLCH0xh +RgP13j8H/21OtZfpzJs0/ZjwCrhbFsCsGittlb3wFvSU3wGEyqfTxt73zZPnfw0ijs36OePd9gsU +HXDhD51CFg/2BQ+baHgxPyoZsn8o01L4zjtgGnwcp9/BmNDDuERnU92wMDgbZaWPiI9FJGXI71H4 +JAucxny9JV/ppiUt4oZilrUi3wmZjc72nGQ21fGIIB+OKIDp4ATA0V5PPFlaU0vnlgeDM47v5xUs +9E1jrKY5h+Kqol8rO8tG+7i/sK3Vk8eY3LDY7dwRcbpbaNPIsWmIsY/A0EWVFajz0NobVcB/dxqS +JFhw0mnpKqRGYQD5dQSh9pelUrwPA2P2SmobkgA61ZA2Qdqrt7BPNtdHQAriVzbje70sgiq+H0Vr +ZG4DFX23jfWY695IdcwfIvZGgo4m+5PR327FR9QVPSFVYEnYUMa5bUlTNB+Kqt5cgX1GXHUCOqDa +vx/naxwRQzXqZ4vW/aN112uo3IB9DTXgRd3udLBpcw2pXo0xhJb5Cn8LzPWivuR4fjIdC8zDP1IM +S5TaeYL3Y+CqSv+UrcJ+mXlT/+lEifGY0GbBmzyvudVgkR6pcYMP4zhS8SiWym0b1m+MaGLm0Nqk ++vX04wQ/KP2eFBMKizgF5rFY1dBe1KoGOjbtATTgaA+gyW62C8weycluGW9JQgTqcJ3SCyalVfm/ +V4HWIHcv41IMhyCnrv1asgARAF2Cp/qxnspGiqr9Dmj8wqJPyTJiNngBM9Z02Wr94UTtsQD6tHrk +Cp1qbiVDcxw7bNxFHiu/ij/1xo2vHbGH/A7IEvt3sK6c4+Ps/UhmerBW2JvIBfGmKEBuv3rPgf04 +jYyG3rIaJECELl3Wl3yWs5IpIc3fUpMF10Bz8FFF+MmyIah/MX1VWsLwGjAGJF27In7/2EDcCRdU +/Iqx1d4DPYqdMCGTeOpwhOT10RsENIWx+GMug2YvVUzAc/2g1hDEmDH0EBiELXh/onubpi93Qrli +iipkVsDDXmZ/9OKYQGhPDaPICP04VIUeiI0DCjcjaGTHfM/+V80AaLsb+f031zEKUGmHwtVz9lj6 +IPJRY31iYWRH7M1UPRHL41w6bqD9BBCLtuJd47WmCypnejMYIZbYSwOxXCfZ1hwTaT5wo2GyLxvt +JDihJAFoI/8HILCXbbZLQwkeEJeaF768e/B6++QIVkO/mkNXP/vJjdZTByg2WFFntoezC8mNeQnQ +FaGJyI3bi3otT+ppIzd2Gizse1XsCrHifDN0TFnA1XoTuLUjSpqZci+QAqDkPyN6jL0Josf36/eF +p4r8C1imkSbuf4H+x3Zs5+O5Bfh+oVnMRoZrTfrp0+VejV00VXakjdtrsFFcER3EaUSYQLPH2gMR +Q40cwKYRFDKtdt7FCHA/RDwgOD0B6tH7BCrgfDX7xVqOtLOIkvk7ebiFw0JqeIxolMCJ0OgWOJN4 +g6L1UY4R4WMg+CCTF0aj/etMT54wlRe9Ek7h6irjtVBmKhZdTQqu1XV+082f4lBjxkAxiEbBAJH6 +iDVlRnvvdhf6jNAz3nfgxStp3Z71/4I56F4/qYwN1cmR2mMnxZfYEXj2gg6+9FCNgV8d2vONo4CK +3rxLFvVvzAGHJvM7u9qPiTaEVblB+fVdB+RBnoZMuUdBOKOCqdjHxyqMbbWwt/UbORzhprfMMV5z +P71vqza++Aft3Td3lv69CJUrMHYEMEi9eQeQCLqdLvupmzk7AnV4fCF21P6N1LkoadkGQf4ZGPtQ +5Wv/wN6V3bqnjqCRXCbqso534fPZjAIXQRTAWSdm3WlZX5GuM6Jxuyo2TQbgMEBA00iKE/lD9yHW +W4+AEkHOAdKWJkW+Dv0ETD8fDyM0YAdA1mTc8jEr/SWMi0cfpAc8rZ4j2I6iI36/xR8NOJlb1nlR +yLNmrseD/t9eDLFA3xHXsXUEn35+iNTEAfye2af2mG5PDNPeds6NZQI9wHrJQtf36VpN3ycLbooZ +VZY/UyJ3OqJmQR6B3CaLUV4ahW/wJ/trYVfytR1ox28zRZIutS/ZURcXOswu/Lj8ZM1G16+/nYe9 +md2Poh304pkw/lXGx0ES4iTWnSh/4YUeAx6RH0n9AE9Tdd+bqCq8l60c2clzuCEkUKRvUmeokdKD +0vPmekHtOwt/jmJgef1MrhVIHqUu0FsOUqh5wL0NPw3AFT7NCjBzHeFP6Cjg94loYr12PgQsTpNX +FKWeBYfw60TPfcRzbIpR3Tsfnv5Zk61HikGOipI0R907yCcRsKcfy7cvil3rU6WMa4TX2oGQg3ta +gXjfgDGGfLAVncMlMhFkWnGHttcUrv9sfR5BxpneEK44Z5s208tFfKFLjhlq/OzjIP95UmJ5o1z+ +6Ve5ZX+R/ewVgkxP4vJ++xCw/WTOJJO8QiQGldCvSKDxjBqF9FjRUuQpZoe1hKfTNAe+0A08EXvu +JIIXk4DwGOzfvnhmeAzNxPNGzI+oUaK1doMrVeLs9vsCwTPAzfkFaGnkNCJsFulSxNqUQNsT2VPf +zBhCN0/eUHYvUpkdRM2+4lRquLQ4O2BJVCNPUaJ5Qc2ZJfBvviJ//Tu+lWiKPC277AcEM/MbdcF/ +yiBAyAidQnTfSyLzsRWjeGPd8YLjU5D3EMFYkS+Ggmdvs72wknEqOXsQQ24Gm8UrUu6evqlOKnvg +2jtZTzM1LHhi0IbcYD2MCEpNYi3GgT7xSQQY2drcNS16ujQ3Wm7XsQEYmiaScx+JhzvwGvYPUR4h +ya1UNFs1r9EMCq1fRLrHL/ZDYPnICa/khKoQvhTUQh/VQepfe5CiIduvxwz4jooC3lNAU/gAyX+9 +dRjk730cFxzGKisGiiXM6chr7ZmMbwAVLVYcJVYcLOpo0heWbgYeHZFh7b18ywsc56gHCQRdja6/ +ZV4sRKo9KL4a1Ivn1z1DEbVSpncGTJPTjoAMoKO1EEdKQyLyBDlZ8KSUTr1x5wB/EdS+5y2Ih3ug +vBe6wqs7PZiZDd8+FFhDa3fHyXFPQWVZQU9zYedrgwxmHydMdsj5PU2eDhh159IwmGIJhGo4lkDX +u9cvCPdDoCUJJXGg0cH7S0YGClTECJMwBoqxTnmVs7TBDdIFRwigKTsByOYrfsBgpd+VH9AemML9 +RDVXfuBHi+V7ZwkF7j3z+VTrDM7/ieh0F9SODNCtY3+y4FL5XWooqaQ0o76Ijp1Q0najg1W9K2Bc +mls9ACgex479UnV0nW0oV49c7QQAs0ADEIkpt6OXsg8dQP3XibwGq8dpyh0jswY7RvxajHhqNaKf +n0QK4xegvYN+cju+NiyssMLG20i53APzLfb6zg4HVR362jRHuIU8KMKkV7vAc/p0Wjpxd395X+lY ++VFlvoEYrPcHFDVfbaNOCul8jcf6BM3O0QKNsOEtd4SnaAZcg+T8xFoQsHtqs738PqyMKDoPwN/o +PCDWw1OrQAPeE5dOkP34NC3E+h+wNWmQ3OtYQU8sXvKSzTBwY52MpMXEIG3A9AUQFofePSNw2rRq +gLFaJmExzUqhrJOiDc8rLdLAwdK9jCTNfZIgTk3yoeLfHQPr2NXbtfhCUSJZFW9ayh3gLlCwecpv +4RdlgVA232/9L3o1mIF1GjRWRtk0rueFLqKM5SwOnHzP4sFTPdksdW3/0Icf8M8GX27YIu+Qs1ki +2SS/05ItvyfKYmmrDbGCfaYMBU8NhbGHf9PIwhDjbMEorIJZ5G8kQl5+9fPRC6E9BZCiSYAu/eiX +6TyBm8Yrm3+/kEukIFHTuzGBn790GRRtVf1q/+LC+/fMubtqKSGrpup7U+3K6s4OcrRoaEbclJ2P +4IxkqQuNbPUn9qtAjW3g6jIPIXuVELKPUBCDXTvuJQJRJVT6VoCYJEWoSkZ3WZUnngdA+2dASUwS +4MPo7+wS6xn0S/DENw9n19PzqGDaVV9h26kwa8y/Jb/Xs5vc9+kyHadsu7+LarBFJxxc76JmvSxX +okgceVeMLVCB0PvA/iIEuFI/JTzRZZaeTFuMfiO+76SYqMYCL8FAZ/1W0Bg1irI9X5/cXNkNn3sH +blVVwThlQNn8NY84rH2b5z0arbcMDlRs2cs86nHg/pfv8HjV0Q1fDqi5wYCy2ihwfqlEwH6R5Jsk +HOrWfkQW6H6+HN9eXVJhtxM0rOi/RobDMkal9zfWswXHTqeekpZ6zpC50OJlnUTlBB9MCqtNkWhK +8SCpr3snJ6z7FUE5gFnMmAp0/ObFAMk7UgGIlKQHIjMSRj9dEnAqt5R1eBIy5KZkrn2VbpR4xUAN +hFbA6Q+6wTggC5a7oygU/HpNRUwPlXlk5mvAJ2H337CTDqlQExdkV+cB2xXRAhjORQ== + + + gwOiDyq/V39L9tQyhyAhKELVe5A2zCzAmIPkZXZDo3OgaI6I7v7/92+mpe3jF4EZUu6DzVraHEUq ++VLQY+h6iTg83w5IPU/+oB4kvn8FjYHg/nNqqdN9JwDNEYk26j/7ReWEt8hOPq2bHxK2D6CCrtE4 +FVCh9h34V94AtBGVlrPAO5CnqDgNREcW9PoEoNtpySr2Av1Bw+BH+aj5HsWpXjQ9cJb91Ewy95tX +2S3rChCGjTmbFfARBRIJpZ3A/LnP53DkLbN+DgKmeOo5HBiTJxIsDsyRDbQrNzWE6yhUa5TJmwTs +p/hSzsZr7uHucGG7hjQUavf93l8gr5gGCewzQU6f11xZkyv1CmvvcAXYve9HqUjOvZV1wUoayRXq +JQP99gdH0uN8ex+lDy8nKw6XEyIUak7qcQK5ZteC0u9+RmBaCpkGhi93ZPV3SmX2YH5m7PGRWNFF +QMpGT9vX3/xZWqztKUQgBGSg8htF8JRUSbA1552ENr4sJYd9eyvEw6u7/LUgtZW8eZyeKdYdIvHD +gaVrziNLAk4HGuR1RM/Qta1HHyM6E2ANFefD+omiF6JiJFb7I03RYyrD/fcmRRLszj3ZlSPp5ywJ +5UmI/CHlgMSdghNL0jE9q/ftu8kB7vDiOy2dvatrb8MCtQ0eT61ftGwpiGDunRmsNE24TwGT+jAy +Fv05ipdsYQ4ZtB8lGl6LW9G6/V9Xd/Mv5rPKCClzUtBQpf7Kbx+Rc0GgCaU1ZERd8/pfhLs3ATcF +0Yai/QwD1jdAgMgKbciferhCzUA1finNAgfae7jrPnotvLR0oem08hsfPQ4YUAqnMV/TFvrL/R7t +yvmfd9/TazQyfU5cZ9nCKBwJ6D1z26Vkpnv5pr6siifMsqmpLdbN0Ikj4I7fEoqRcGpMW55jStCd +5n814VARIrq8XnCEzurebNEUVykke0lb9imhrO7dyMzh1MfFeXX5pfAoWNF+N29qe1I8zwSDYehW +lXIZ7PSaAEtTWGAg9hmwJKQzpwbggCshYiCn2GHP4oxZNG1IXXPrcZqNr0GkOwBcPvl79c8tpgIk +8s/XseRP87YChsPjh38DoWuxQBgW6/l+dCpY+yFxgQWSGM7e/O2vXAGQkYip38NWYRx/Aw1rkC2W +Mx0W642uLujs2q/21W76i4V95pPjYXMfUTJ4FstpMiS4p0W8skU62FqfLMR979FSY81XY3Y5l8Z8 +CiwY3MHk1Lz/R/Y8hfyGNWKNW1VsrHa+Mw8zqPP+AB+jC9HUZ2V/JGIq4Cdyz5aSH8s8m7pMFlBx +s9F5VMHJXDSSdrBAuk9Cm4d6Cy03KUOXUOpA+4Gliedo2cjKy5h0VsnDa48BNt547ej4kxbZD6Kf +LFBN0uajjRPzvHjQ7rwv5txvYCEcOQoh3e7me3bzuocjUCxcAHXA6xDf5pHjHa8w6sS8qFkyCPuv +6zSJZqhmcjfGE/vK/ZdTMRCxvdiAqa8aSSJYQkXFPzr8ovLbnnGugLfVP8X6jy6I1FWLq/RnoxMc +/CCmYGcX/XMU0zRR5S7nOO8A3ikMfJ2A4kuB7NBOBAKUvu799wnoSuyoeTBbN5kDz4mKgOUAGnBC +Ar9ghJqbN6K0+QYHIzz3rYlOI1JRRpT5dZ6J9MF+ylJ1RUfszmEoPsnJNNdFBwyxByIa2KqFRJ7S +g0j3+4uaRlPqPlIMRfcR+Zu/npS20/raUy7AuKgPkxKgPmzJrorAlLyhn57wnEeQ36WNJPm7kjIU +vfZ+UngzhFn24rW/K3PVRbMZBXmAqMB0wWrQLqySL2FvtE7tgQippCzFhdz9ZgHLCb6IDTTGJeLe +NR8JPMITC4HXebynlYqKBKlNSeO+io0vM/DwFBBrX6+RUFFVlm3BUgbMglK0O2nf8KK267TngFnc +7RMfyebodvvkfmJ8Cix7H1ixwPNNUAA9+sxqjLbD0Np3bAriv5ORwwtu7Ob377NTSCWovDU0TXm4 +YlfMv4AHSp1cQPvh3O2NiXyJAWVNN1dWpXb8bC+aLStyBQOxcdLCgToktfkd/xrXAgXsgGcGJWmt +jZ9M7EyubD8/YVf7OB2czE12QVtHOSiUWIGgt9RfkD3DHnm/WYdnhByUKq8nRdREmTn8BpLSI5MS +7NaOcCIf9UzLCK1eUS1KxxirTbYtox55ewQxXz1lBKzsQ3WyyJyJPpS3ratthAU90KbeeqihFdWO +W4dOvqLJsX/VWhn9nbdtjpmNwjIDCe34y0ICAxZ5kwPZxVJzZPmiMu1GLpXUljdFAXwa+GtfTLZl +fajrCAvtK/UiKtR9fK75sT1WPwqVg18uehUjaISXVALS9WFz4TNwK33qANeMATLV9/huL4Q50HNc +XrA8OWn24azUc2IBl3CRewKQ2uDRajlCe99nwdXoiqCiy0y8n2WyTCCvNJaAvFbSQbT20yuqQzFi +yP+KDMy9ItRjbf12L0zTwApiGiUi/2LTCDlnv/ZwIeuKotWk/SywbwYIc+9kGiiUJJZMUDT+il+N +whcwewEhmZDKSzhCOIgS5Hprk2AicyYBNXPBW1yyHXdqSD1jpSSiECtiG4PfVs0QpvtuFNtOvlL6 +CDBu6hlftNPMvhQBXH7TsOQzMdJuItZ3hoDoEklZReK1+AKgQbCPpilAv4J9uKXnvkIzLYgRpvVL +Mls/byhFbeaTUQIBotUtTqGfZt29U0txx30F7DErYGqdkFeKrwWPvPOTaniRSFdI8Rz1WDTzrAP6 +aC+gFD/x59SNdWZcVWEphBcWekrs+cDNwLz7Wi7436JNO2aFI2bK3mVa8jO6Dbf16Nfe+qaA+i8c +N9zPPfuQH74nyMqy52YyAGl/M7Q/Vbf5FO2X/U62ax1iYFKusNSJEPSH6LE1nfyheoxSXrFIfW2L +/as6koSiXHInr0LVskeCYVK1ZCLp68jKT5UQXF3yXZgjhldb/419tdcXr7odkcI5oKf71JuLIpf4 +5AcpwDMtZsQ3I0dpQHiHLyZmvahyPAK9cQwqLiUVuut5yJ4AucfD5W1OjLZ10Dmz2U4KoqlnC3OQ +5SwzZqWXzUexADhWr719LYYqpuykdT+/z9mLU6GhmQokA5NhOl8IJjBfyRUL+ZjCpaztk2k/CGVB +fHyEenZlxr9yqYFs5ATkuaJ+YHOTTnZ7MoGopjldsmaqNibsiAOEKN21Sm5H0OBWfuj3on6nrOlk +jwm0oqCYtfitejgAe3K6VBan/wOGacAkbnm5qSrcYmRf/XaigOMQVZ2Or3ODmVVq1ATroCM/cOlL +hAhAWtF15kzNJRO4/siZDsZ+fm2IUBUU0KyH9UzQLaF4dnVlpR4gEsdS5jyD3WD1MGo2GuGXHbcG +gkQk37inteGcaUG3IMpSz573bIYLPoDIrq7XJcaGZ7RHq1GwIAV9OizClwU4XULMd8S7mQQYdmo5 +QREBsmQpnvHARShY9NGzIpBKNtgBoesTW+MIgcrLJca1HpRyWwj3hQs+glfaOdUBFulBCtS2oQya +xXqh9MCFogwP2BUA20N6htcHQhaCaGmgViGnj05lEjEAu+472F6Lj8tqCOJWqr+QpbFxIUsbU2CU +5mB6+7Y6cpRsJgEAAhTFfw09G6zhk5bcYfMB02xf/hI0B8Q5WiN1UyquTwI7oOfrxV1Dp6jZHzMz +WpFZK/pTEw33PoUbhKs8dI7Dg/D5gkUvtWkniKdulFVVbio4VSVBTcyFEqwc5wloCl+3XLvuPvzR +OM0IbLKR8enjPVM/6pJ4Co+caWcvVXw/ViFGsKLTV2W3Q4QKM4CVKJd4JrWqcEFLwHXROdoTVx1v ++aQEu9TZX6Jj0CDMVftAlCrUS7utqQMhjzNyCi2Aa/sTwaahUlvcCMkazG6pCbw28uU+oF+QhuVY +RN/ag0NlJhtSFFLMGrTk6d0W1coVdet4S4VT0mlFTOObodLXmYRjMRdL8pnW5SgiACX9Veydk6YC +kJbaARsNAGjPNmdo7FrkfCDfCMOZGeEAa++DlAbhJzUcWBnNaoRrDw9BSF6HybfCkUSsjAhmAIVb +nd/6UgoiRM8bZ/r9CvBovxDeygQBZfFROIWLxjR44Y0ZUVR3g6ibDLndz8u4XrdYOjiFPRZJFkkW +ktTvXUFGS8gtympM+WArRZGIJO7eXVf0jpNGi9dGDJJ2/ONb2s77BxvQLes8MJLu/H2mg+co1e7V +bPSDXRX30rGf590pR1R4gvmL2xF/BwUk7BwMXs+O1XQAzdvxJTj2xJGD7qQ+WDa2lx93Qwmt7e6x +PXKa2REQYo3IiVecZo2QOrdgSZWvEwin0ZWgxNjoOnKy9H061OWWv+Mvy6fBIRhAC6HLSchXBDlN +QPnS+gWBVMSw7lwfXhONg7ZEaCBrclCubBdZB0coS8EF8Xb42A2UCIbKhUIguIIvAwBwFjgbxK8R +t2CQeZQHYqddj9OtDCLE2Kq/JHAX8ObuX0EZ22q6SZG9yCxg74R/HT1tcbI9RFEdlGhP9tsnJbUw +OlUAvdhroCe9f5pLI6USm4tsfK0a7cfosJkTlCHZXDxhe3X7t/8mhBJ1aaGUqx6sZvRtlNAgZsPo +6U1SmZHjSIn3sYyo9R3uyQ7ma9IFwHdce8aDUYA5YE2gW5CKCALQVEUQqHjV3pJRNFY6plT0n1B7 +Qf/JO9lOf7vRcOS7sM/iXtMkf07VAHJBRUSpI7nEmnTdRyQX0cM7Lwxs/g58D2+o68oiwU20PPn0 +o6xKgT86xu6y0Aq7v8R4exyEQKKiF0E7GOdlNYV6Ci7ZKHcMZSI6ai1zrzQYNZgwuukb1EV4N34U +8oBBygZjBwnnoTSPvQ4KH7Ix9jXj29vrW/rQyoV43OuBt9QcQfF5SjYHFgv1Fb4/un+duoS9oeuy +N7TYV0N9XVbV9EBM7T+WyQcW+u/O9lcK0GyqXtlwCL65glwIeF7cgLyGA/awDwLZw4BxVHL2q4Yk +X9PuRBDOtV6/ckpt6sHPPhUm7GrTIcvYsTimDt8j9tR0BW3yOzoiEA1rbYQlJmJMjcwawwBYKodL +xCJpR+RwH/YY0lDaMqarHSMn7Ke1s9Fm4zl2wDHOKaUfVPgUcRkj8urgfspLWogFRXM81+05+TTP +X/8i/OjviXH67/5FV9F/5YH+hl1n/iv+95NxpgwaxBdh0OB8Q+XFZj1mWvtV/6cT5MQIgIJ69vcg +6THC0OGnqmQzLTA44Oq+B2bqOtkEQVF9t3Gag1xyDWPuWC0m7iwHFXveHjwNAd6O5p7BN9yM6NH8 ++VHX22bTgGtXg7AQff2gPvuy0BcWUCpmgq5oRrHuE4XqpMdpXVDNnknvADWmyIoy3Vh7CFm1cNZG +FBPRk6CAUL64rCW9BtAeVZnxO4shFTYd58jYLN7u61CP6KNw9Ycq38xPmtmrKsxqgMZMGGSeVRe1 +YuuRVxKl6IEiznu7l96vLHvpPaVDrtlHELC8877BEdgfP+I59qW8juoluZ9bRVYWiw== + + + A8UWO1B/HY5ZiVoyoXIJXvhu3QH5Wi7/fvchpsQCHovpi357PTTWSoUMmne/9EnSVUWn+2a9TQFY +n06KQVcJIGjpozOYAEJgG1nNqH6p93yc16FZtK+FKAm+zIc7URhU02SQTFm6vHcH1IsfmQyIUHMA +Jv2t4wyGFCrTi5D+OkEI64VSfE6QX7KfWJWIiWiwM2Hkx70+aI7hFjtfJYtljy9WP7MPYOwvqVv8 +UOGOVvhuy459JjVWaoiH9TnrDA1EVpDa5TBXDRGwtsauBcLJ9whPIGfiyYu35g9R1cIn5M696qxz +02Jv0iAirh8iWH4LuInO+nzO9Bk1XLTp+CppWMeFcdHcS6pSdnTZB8x+RWJJT3YK3bRqykB+AIUw +sIk3kjX3Hz5Vor0A6GOsGPSwE6V+jCmIac9+ZvloTPM003izWwahsO/BrhEG1gdBikw5oEawiyDC +GQiE0oA03GKxS4Sbsx0Bgt2IADZbhInfM1nb21FPPV9jFKD1bQoFq3SkKZo1eYNx/dgpn8dhQjGC +iq0nIOHVqfkFHLDkXjGrClAJ1DWfaqfc2Kx9x10JaOgPA/0AOOJqfl6C71HzUVMXyGkBRlVZ0JkM +sQBFc/pi/wxrGlvF/b6QPfWp1w0R7US8qBc4JM/nWMU586HJW3QyEVNIP42knaN/jv/0QH5EPfSu +eANx6YFzizcbfdidmCg3/uh06gOJBAMvzfDlfpYDfz3PObvE/dMuS7+uBOIC6YmQ2KNZDxdzpzV1 +iGhrqWOh9HgfzIBRe79F1BXMYztYKTpKPIBETB5RfENWaqbICDPAnp2B1GKo5r4vzNAX1+NmTYCz +i0SbCwem7FZZux/HpScRYgcxGGMapetzn4GmthHP1dm2QRwmkW5oHtwuJzapHtnSeXEG+08cgeqT +RTke9nuXQNMaHnNUAa4K6/0zIpWgQ35lJiw/HocNnkUppMsp6SGjat2bxjDkFoAdtzxfM4ckLBg/ +k7D0V3FP6J8k2vakibTTHdjAwGogNRFhb39nTDVltBm1YDKmQkb/txKv/2q2+a+0nj8sVqANFtu1 +GopNRdBOENjaSfYKuym4T9cD2sQ9QrYaXUSTQIqD6QDGNJJ3F3VHS9GfUwQtJUQb3HEzdDVDa7Ee +qpggZuQrdxRo/UjZTxXXZ9OJUw15nH2vJolQOXyS9YKKC/BFzqReqzCvnEn18h0hbuU9U+A0aHWh +YE7UFRy1IirkcnAAHQCHWdLLjt5rtAdxkjsR2DjsiNXPuimIBZwA7utISrGroHFM27YqFHzHsZTu +jMB4nBIklqIad5hg2oAic9v1mItIim5PMLjcKlJDoHiOVDnGA2IctZXZayRq6Goes/o5g7AC6nit +mR0b5Eftvlt+T6NX2WIzB6H0sir1CnG2bJrhFup5AEnkUgQjLi3XWWo5jL+ZJC9+MEhDFCPkZCj1 +3fUrxK7qHL/bLHdQ1lFX8Mx/0z7ewU0JW3CumOXudGsiB2GEJIACh/DFlh3btQW2zod7aKjJ0+rm +mjUIGRye+lsqbqUuQsTfei/++vd8F4H/s9sE/o9cDkCbqJ/VnQrtTMi3sAK5hge/nygsPokCQEbU +0GyH4/BusFFBOyYgoxaQkaYzQEoVzEV44wnoJ0Alp/rfkJ4CO2IiCFAPDEmMGGQGnK0A/ShVSTnl +KEdG06hiZRSVYbc7E3redY6Bdgdnur7apitIL+uz45G+qmxvWrK/CtQkNFl4+21iPKfvQzEX53ec +lcNnQygDwMH3iGyKxml+tqrQ3EcUe5wuIR5jY9ROwKlRIF/Sr6MPc2jr++9YWNM2sOpEVXa8Rc8R +vrgszBKmqnJe1CWfHpMXZ4Z+xImJcHXfEXgkGhExDATJWqQ8lN0jov/RGOaKqctNnVjBD6UdML2+ +cpxsp/Y9YeH2OFAQdsSiB2wEtERaIfQR/Lbs2NiCltcihL5Xmk1oLELZfUU9yHJm1wDkUsIGG8R9 +7fpB2u0JePS0vZQJkbWogX2NIPOinXX9XkVpsrOKUt8WRxdIVn90g0cYoJ86+o1J1kJVo/5xABx3 +V7ISqtU57hlcYTwpACdpBilFMUpFv17k44TpABoE6umanO7JfjPtaXyL+MfT01DnAT+Wev8QpeSB +oM0nCaL/DuAwjNubCem93O8gBCybApO95rmKeMGwTxopqIdtucqekqv5jHq2sInI9CBFmq2gsVpe +OTiitD/Zqa0CwXBvyLsRqAM3ZEQaYA2fZSO0jlgUIDT6OfAumblWwG8lGoi46tfbgLpbN2qKroUD +OozSlMbjCOTaEU09aiJmHhmxbB17vfnSRxFqBRV1uBfVNYMHj8xxxRXd8gy2dl3HxXm6fSuTu9cc +fWKuOWW9z4hDvrut177eQp9R10HvMEueiz8oTcNEW4qR9QOPUd0inlyqsw8m+vszIHPVMQMd+xaJ +c/w4DGAGK06DotS02UfV83MA5CxeFSBnXymsH6IASdE2WTFlU9wBmwDqUavnfbP/uSZGEFFIlCQy +DhEaPdEIdw0qwAeyuc8k9gYwuhiD53pvP0zCEvjFEJZAA+uHB4QS+yl6NY11tbav9prY/Txfvvf6 +X9yvrOn+MMVcQFdFSFXBICiaq1EqVcsNbE5NgW8/NV18NwxjF1YEZk+DFNCVhXQbbzMTzRIETJb0 +CDbVnGdSBFNEFo07FW7ijyJOFT+m/dR021X+eIwIAJa/kKWRphlgVsCxBF0iqOAI1MBdg7HCnxJ4 +FhEwnYjQ2A1whCC/kZfVExUld+uXHZPAJpp4AJuQSjIKMWO+Tpk5k6W0yerRQpa2/XUDQAPG6DG4 +IG6zphHQiIgYZb2mBDcgJY5zYRgcOT2aNgvZb1OXeRDKg5LvDIK6RCQRaMGvv50k/T23R/0V5dj7 +dgF4cK74ORKOkX+7XcKOtoMc1/0Hntw7gg22kyt3YxzfbP7cfG6Z6I4ZE8BNdbjM0UsGYbe5Q18R +7FPgHfUHNgFDw4EVAaaaTyDy+B5O1wcx3hwWmEC7XzS4mO/BezcsVBzUN8YLqESs9UVvYvGPBvdN +YhFyP79YvZ+dbj1Fpb1XJeOKfsq+ViTUMkWe2HjTOi+mmDvRQ5YOG/uXyH+D6HQNhyP1hPHYxVXY +ZMXYOLMiyFbeEQd9wSn+X7KW70xiMxBB5pV+BoR83TN1/z3QXiAdg3IF45tDvlB4WfzUOBh/sjZW +Vko7fDkFyxlIK3zP5idBws5L8xAZSR2iwt74qu4BL7ibENjnZPOkCOA7ME8CYDZzCk8OigkGMiNU +n+WooQA9ml4LFBNQiBFEcv5pp0xK+1cE+KxbRA40KjoFFy4lyDWUKgQNqkXVPkCeulQWXSDTsglq +FEwItMwnnYVWj44PZae90lP4LAdo86cBvtGXO9L3wXkdxe6O1pDIZ6CFZ2AeO5jDDz9/YtUJRJ8f +8sjGDKWAzI67ggQKYjl3RGf624th4ClfghS3JRgG6Wk4SCsHQEHcgVDbfFWyi7LWbHR/iLhrGib7 +7v7RzefPQUqeryN5jm7D/QqNYzWMEVLRk4D8QAXYb38/t3Ytp+k/j+nQ3ALIAb2CLtDOqMMgZklc +89B0WM5/k2jtpyiYrNo3VQl8odp5znEwVWWNdKY6QH/Bv4sdwOLxbK8QY5f8hYB6C7IFwArfzVab +A1I+gilhII8Mh/N1VtNvfbV7Z8tbQ+HrnuEUi0vAbWM97IVCGX9dG/404F2mY34AT6L0GCTfe1jv +mYCQXriQ2d03EK3R3wNPoJuiJI4dzdegovhtRBR/SHBbmTLGWbIAm+33h3KD7PHvA/5G1PDbD59C +Bf/sFHSTZqahSvr1d/apwEqveXbR78i0WwHWH+695+9HmjoI0r20okH4QO7s9XPgfXarbb2GOsIP +H6eypRQgYgXxmVKgZs/lYLg/xkmmAyZBJfZ3dewJ627H9OjUR1Bm785vtmZAKSM7ZJ6gXityaGiG +0hXm5quG8THgNVkAQH4YjPrZc9bVfmVd3bv52YIKAAym4PnerrBHyPzTok0gUmx/XcqbIXrRbWPn +0QvPmDr1gCQieT4ief7uhmxTlHyqmZVDjFl+ikZfxHjMPDseofxdojh/j2NHB5+dgy1q2yN6wF45 +gJBNRZYOBoxNurkL4E1mz3HnkctAzUA/e+9xfAA/BqnAmgxAB1XI+LYY/nsAXxgAfHrLnfLn70EE +R5FpENwxhHiytF87KSQxQa0LMVHQqqj5azp0Gl984Uh3tWOVQs8RoMYdlQcGRtfJpGKR4cBDclgU +CWDagy9/v4dTcoVBio9oNlUPcye3UMyJDvXCRJmKyv3+inY2lbTNTjl0QMfXjaUgDMQNwCWKBY1c +qyvdhK3trY283NgzUNkGgm6/oUXncL8H7wDR2LRQGrVbsj/9ocQ/KPw+P0j0v4+HeaSDKtvtwZ1l +wUwmL+NLuK+YQGN2TrDY0N/j6IR5eZaslL9mjpFd781WRQ2abdw7YpIC+9bC0TLPIPXIF/g+8I9v +4wHyDzuYR7Hab1Gw/cIrxDFNUfQV/jLiDRU75Y+In6btz6gJVqHKUe8YoZV65MyF5IYyNwFTMgnC +4dYWpcQWRZB7PzxId8Oz/MEZtB1n0EfqDiq78IBv+xKt6kOx79rSY6yjqFVloFwD6ggcH3bAc8Ut +8q7sr9/953WMR7E4NRUi50Sj62GrHJdsE+TvA//lbI+zoQ9i74eP6xmNz8XS9TQygyafO3+ScgPY +CsG3vVVXSk06ZOfZoh76GiO0+BQaVN4gNqcWTe9zGBE39DLWiViJGP090ToRJHFGAEYmojxfFgx6 +PSP1IXD6jkRJSqvhW9CNI6BpdXi/loqLXDEBFpMm2NIcQhEwuJxf5M3IWMuTg2y6/y3uDqlZryT+ +IhK+S3CaFD00aoBHn1qRxG+Pdr86obDo7+N5iOag1oYthUzZsnLEpRCc2tyNN2ZMxGlNUNEQ+D9f +DhZFpz9UJKNHDaF3Rl+fphpR8Pw9DiVBqSjaEnicJ1af1Y7lc/AnT4RBiRh/OIGZE1xKS5ETaxTN +9fYULfbohwitSiDT01PyBKxvnOD1GhALhjjEW6zCbrYDYrhmkKdypDXGWL5nzG9Dk3ZpfGPPxfLj +2cWed/Nu59neVyjiZXB8oFOIjqhSXaybIhb7Kq21akpJR6P/FAEdmeft1tH8q3YXvWeiwF3XU1oD +ZtwOOSfAuHHLyMTNNZgszEZ6aMdmYBRnsBECJBtHQfvoh0k170OD6vmiD+BhmmPzCO9DtdHmgmyD +hRu6o/j3CVUJ8B7wekV8upg37EIRTzgk0552xwADf8WcuF5AR/Zs6Xs6e8wGsYoBWUVEEeN07T0l +N4Wkqp2PCtLi1pwCAYPqKiAtXrQg5msgkrG/Rln5uJUuVbfXNCKiVAhU8wpzDB4y5cmBle2IyE3B +8rpe0dwRqiig41u1n+t4Gt+WaoXrdiT+Bav3ABdIw4AVT4zooXfKW8ZWyeIu7TeaLw== + + + D0CPl3xgsxie/1417vFGDaNYawYqFnCldkY8a6yOfdMRhnwkibbgDSZiQfDI+CY8tQ9go/L7PK4C +dNWkz6FqT2+TE6gDsE/Qan4IojJElBx+aEO3v6DsiOsF/C0I/L+dRMTlI6fdJOE9UbVA06qvyCJr +9KIHDp27OETQ4iIxdjzAaKZXChLROtp/oy32ygx/PwrkO2SYaAy1c4NdFDv1F6m4MQzfWyate/L3 +QJDb0VhopFX96zMonQhgpi67xqGb1nCSFUn/iGglmRvf7VVE/IzCX0EYJEIozPztTjcNXAjypGDG +I6HS9VCJpRE9aiyNlAE0Yibiy/kU51qfkr11UAfy4zijhWvDUyIzrxxxl73BB7n1GfBnN9mvh+iP +MUr/W1sBSJbuK/MSPQGIICGZsdcDISZf+WDguOTC9avOar/vh1a0DbBBdzAi5FiieDXai05HMzoR +yuaAZzvErBdvx99MYRBpmvMMchP34dCg8VOYJ/gldG4v9B1S4Re44Av8RJtKKeIdsXPU8vV9XWkm +2rbLH+vGF4jLkpVMe9LbAqojFqxM7JDyEBuy2ZCSeiF57p8Rue4nU/v4+LxCi6fYvqSd9ZS1kFcB +I/IZ4X0dua9v//4jqKD0edklYwd5vmfP95xHGk0nUPwhNECfcQ3+v5l70yc7jmtP7LsjQHTffau6 +VXffb61Zlb3vDTQaC7GQICUKgkhIgkSQehT1FHreYiL8/Gm+2I7wFzvC/+r8TmaerIvuBjUTdsw4 +1AKB01lZWZknz75QiIWNCwhTU5eFGGckbo/SASCqGwSVjtX4oEMuEp1RRM1WdNIqKWOJ6hpMGSMm +lCU38SMUjRBq82Su2qtSGFFuQkJU/9CYNAdx20Z5e0SU6jYEFHVto7HVKLJR0CiSjwIKCpXKMaxK +wahKK7qko2o9pCJiVAUnwmCSb0iGUCpMqDqVqxg/U64JvD3mnrKm7xUJGnmo6+/pZvRSlx2hEVmo +54nSUBfio/hU9QsK7cUvdBmwTBcRVrXTkmJ+xUSFyhZWec8kLEo6WsUPAt2mQlANr1jX5aP4YBqR +Ul1TGkEdAGhErGpgUiFA8sBRr4AgLy6zUOoNVdRSjDZS2eOEMcSJVISMikmlqm5kS+VfZKHqzqdJ +qIGR2i8p+JsIjbqhqVGCYtUz3ItVqXSqeRBmuvcpPaLSnqlCNIk1N0do1JemmQU1hqF6kbfmoXhx +EtyJ3+Qq8Es1Tr/jF2RPU+JIHkWF5/TGmBs1VENVbJakL+pkIHS0sQmMFVRKVol35NsjdCAv9q0B +lkSoVsTYFaqmcnsaqv+iit5Qy7pAh9DqGKhcR6NQZIyqQg1JieJNzK5TCT8VScxlcIhvCzWKvPl6 +FJVPpSZuwkTYqJitVBWdVr9QHZTUC5SoEoSqPx+NIIWXRtj6QDSIIgBU8d1QDyILi1T5qIFep851 +CkKhiqepdnuJipQja5AaoeJBtZqjl0ImcJpD2t7XpLirN1ESpzpZuTLd1SgKm/qlkL5PxV8pJvf2 +L7LQfLmw4e96kOpSiEFU15JM2vQUZYSomCrlStItKhJVeS8AMwuM41oVGaUelrG4PUKjlKkEd+tx +iv6gaBlwRkmGC4o+1hX81HWOVc6vLkoQkWObisbqcPlI53xq1YdOk/LQIopC1MH5OgQb4pVQelpg +euEQa5Q6OF9nKiQkKOYqakEZQFJqCZTqwHwVREO5PbnpqUrzKPEopethiv2p0hRS9S9QQQ9RHOh2 +H9SdlarURZRzpnKLKWGfMkMzYQZkegAO3gYh6dCWTJVIvGOa0NRpoaBhUvB1+GGuwgIzcpXcMYKT +5qgKaMBhwzdHUWKAULWMVWKOSttUSanUqojC1zPdjk8qw4jKv8UXSb1TkUoxIVqbcSRJRJ4cCsui +Kvu6nrMOk6RIbh0dpHpXJ6opoClOqAI2yfUp9PxUJVaNIJuUypXQWS6UOBPaF+kmMuTSF6Ynogog +hTZE4ThqKbGpKC1UFg3VNE5vp3urPBuqdheoljP8AtLHVEgcrmSg6zfrGtyqHWWm83e1RUYFBOh6 +1wrPyYoRiLtGUEVaVSAamB7zm26OIuxSoygRSHW0MTGsZLLIVW3J2FTWjqm2VqYiivQI0g6T9PYI +bXDItZRH2eFU4+jWKAoK05UzyLhMGUC5ar1Nd4ragWWqv4/JflMtbdS+6BNOqNMMJ91nJg5Hx3Tp +UVFuRkFKvzbrkbrBZ0aqWKzcfBHlCQllviRTj8LBQLkiKMUhM4YiBacSTWSSDIBridiwD9EvE8qg +x0OhqguRq4oFOtw9oTKYWLmqlxgp/qviI0lcUxH3tgBcovOLYm0qValwxNxTFb8d6iwvSF7UnMeM +kHoE8bFbHFTNeWsU9ZJRUjIlTqjidIlupyNUH7FIxzTrpt/UNIDqQ0ojrQPbRJiZitapqWjNTWID +U3aHmgvlKno6VyEuitGB1qlyybnudZSrUrpUVRjCL9npVOEuVe5Z1c8UqvqFcaGrHmCJ9nNRroVQ +UgSV7Sbxl/rXU7AcpbjSLJSsSy0kKU4oIY+OyqKhulHYktxUW1JhoYmqa0yuIEpylaoA1M1fmPgL +bSG48Tt1noEuw0tFBsmOr4xi9hcq4VfFhFAEmj4R+8tUMc2MqhJRnQhovLlKv6RSYar+GjW6VlFa +VNZNx1zihFQaQ06mtlMdXpNGpot3otpEUQXwVFUG1BUGcXJUtfaTcTj/Xwb7qMzbT2bf/hdOFlCX +2HQzoVb95TtyyXiTqff6y0+/LPTWJz/++L03OX747O3PP7/76Yc3D//65vHb9z+8Of3xL/948+Pv +35x/9/7ny59+/Ntf9EvvfuL5u7+8e/vzu+/e4BUfLU7+0xUE3vr5u7cfTUiv/PGnN2fvP7x59u6n +b9/98PObR+/+oedNvPXDH36+YzT95+3vvn+nF37947fFM2SgNL1TdUTep9748j2e//L9dz//UT+Y +fuplz35696/v3/0d7/r+r5/cl43PwJrev/vrxoo+Ofr63e9/foPtv/jpxx9+/meDX/74l5tjoQf9 +4tc9ePf+D3/8+T/z857/+Pe/3nmc5/eGxw/jN+c/fGeepH+n9O83T3784RmQ9mfg7XKpwSfv/oBV +bvzi3pO/0G9y/ZuTn/721z/yPJNXP/zw9sO77zwxvRd4x/j/67/fU1nlfyv+c3bvoxTywLvCX/4E +0N+9xHvs/eqbwPuOnnx+b5mo4jye+c8HACjJJdR6uoJdfwwLlAU4UmB+9i6YefaHYlVP75FeC4GU +Yn0p8h8KSkA9NKkzJfVjCkjND1RvNMqoFSQmg9BTxT3qmCpJwiOfP9YSqzKkgXLk5PQQ5UyLnGwe +KWUAmaZDPCBWmfX6O8jYRKEGQVZ8rqqzFOnAvszTQJ27QAKVCk36eBPATXQVVA1OVG0rNZZqwJkJ +pAoMI3JP2SG33n567/fqcdW0QcEpLjGPzLIAVgWraDhtjzkIMtBJoUcnlDx1ffck12b2dKV2yPwi +SMzsFP4UhBqsFH4NJJuVBgbQTjz9wjwOzMwqkuvUrIOiBM06SP7j5YFRSL1q5T2/Nq8LLJgMOOZ1 +mWoboOoUUQX0O9fL26SqLZvNp/Iq5kNIjIsNmDxyngaq7ApzImlmgNAoUjOBVClDBpzq76OgbmAK +A3MGJsA5A6Q2gBoYxfb5UPknNBRfbIAykgwU/PyNLyg+7eOJP5iTy5VBXQ/nDyu+loJzf3FdH0MZ +IaipRGbgyvfC+5ir2DQCQ16LzMGpPjbmHpCQ5ukpIqrQroFxbGChSjwlWERNyE7N2yjV0wzlM6Ya +kLxlpPd4d67r1C44JXlS3yQSbT4YcEwomuj8npwXTOa2xNwyqlxm5k4obFYDA3Oct+YtjkM1SlEr +kVTs4p+8kDyBfNFjnjuiJEsFTCnrxXxhFpsbrZJQeIug2xn6Q0XXeSzFnpnPsAh0Y2HFijP7OorQ +tWdqZDZF2QK+BqqptH4dhc6YkZKXlubpxt1Q+cAEpgp6jNtZaFCCymx5d67g1NKfUPIlJyeSpT+k +dhGYgsayzNKJLMl5NNlcGZynkaFW5DYzlAJMJtJAYXbo1tt4GXLjQqpuHh8MOAoZTBWDPA0M8tRs +cx6aGy0pLd7gFXW4MDuUm8BVNTa29A56QCIMhmekiJk1kAFS30jKp7xzYcWKb7yQV5zoZh50plTh +9ZpHq1xoi8wGmPAUqofCJz7E3rOU954qGVskkmbVhMqZtGivwsQ0nQ5iC70xh6E6UaCvgaYDhGof +DFiHcKqsISY6VFomCM2mpllcgG/MwZOrhgFmPIh1aCanUgR8XcjH6WmgasenhBbVV8lMkOfxhiRz +aibIDGOPddcIDaSoI7Nkg/5RRF4xpojUYZQnkFHOKyBd2swaipApJbb2zk8wpxJFG79QSPPBgGNV +bVYjbibNKqJYGqAqUvULS4tMC0BN2DP+DDIwmgkys2O3VnBqzzQIc0Yv6jfOZxqovjCbxJaAUrN1 +kjy0aBGRjMSvUzWlT80Eqp+HmTeQ9vjDsKC/+k7RvCILGZjG3p0LK1as8kGMCJYUWPiJF1J4jgGT +4KeBuFJMxKkllQFS2IYGqmweHiolDw14KHWhuTXpjXUVRIApPq1MRpYIkDtpgxWZrw5YYFRf/Ymt +4LGJWYXCGTsrryK1ROvGCnhpFBQpzMz0cR8MVOWbakGPMhkNjTPfLLRYrUdmAZMKqlBvCSqFrpix +mZGbKeyUpVtKxvfuWsC3ds8o2NDA4zgpCGfMK4NgFVrCydhNzRVy3gloEeY80zRmSk2hMoYZxikL +wrded12cnUwMX1eVzj98arwZrRpEqQRgacX9W5MUNE+1DddkPM6EpXnSAFV1RUMAYsZuPmt103NW +eoS0RIGFuJScdEzvVJNNnQOdMxEUOa82lllq6R05j3lWzYUiqjfOV1RJ4Hcuv7iiUlqETUVsvyuw +JxIKJqRBFN+8XwDGvGFhHmR2ZZD1WBRiohtsbC6VNvXuXACvTNXR5yko3uEDgwO+IJERyaPkI+0v +zxmYR+YbyHRmlkbg2yMzXgNVRbXANGTObx++sagCP0TKdEpFn/M+6qYJGrMlbyTVSDFjifkYoP0u +SoSwG5lECQsa1NfEHHHKuxvLf4IiVCiE38XML7OUi5yHd66/YIjSCkxK4mKGaDqgqfApc8AUfsLf +EAQRM7nMyHyka7K+RGDJUp/UV54mFbFh1RnViLtzAad2ywPVpEFNTMqxRV0rRAepVkYJSH0qNTDJ +LO6KJGNgXGwZxWiYlZGqzUArhcviRny8gn+6tNDqAqGVhaI4S/lSyPSXkSEKEuYYucWmMORPY3vK +L1zL1IJJ2+e9SfiuB0n6y59G1Ub1BaKWLTK21zI3OmZGJRdic4WokrUGRonWI1Tzu4hHZiHTQsq6 +CM1Y2hANo2hyw4eyKP4n19qSgJRJ1iZQkKdKA4Xg6yepChlPkBp9U1gVMFLhXrkGJg== + + + IU8apolZFdUDts+LRBgLDcWimrHAQGM+Ur3+NDAzchjVBEyKL0hlzBOEZgKqABcbxS1MtLkkMiYu +BcxFXhCnG2dwzWDqp6nA9laluludAlKjUe/Os+VDJzMTo4iyJXwwYF0ZVuu2qeGtkaoGZNmSeSHV +IQ2smGpuIKUcBUZMJYdwcZYGz+myhRGfZcosLIxzC7xNpClpyJJHipW+vvsjri2JU15o8xlxaklc +nvL4TBhtglLMWH5hgUuRKGGxJClk/lSFbiqDm7GVURPZPDKKXEBRxBpIRRBZ7Mgi+yGhlRpkoR9E +ActhbACjT4ik/bYoL1aQZ9bmIllA4VupkmN51rsFFEpcuMHGKTjA0os0ZLXnU1TeLjbI+WNZ3SSY +5A8Q0g6UsthCIe201m7xETgMAmGnsKpCEN4FTNJiXhFZQmgXJlJLnmUg7XllVj6RWTGBZbehIRb0 +rk21hD/Wvoj6Nxb7wrNaUSjauCIU0e7dRs6w2BjV8NpQ/cjurO5Xqo5LRv9kBQaWZMXyC1NelvyT +/SvGUswSA9P4jlO542A/SToi+wWxZBocZExOFG7feWc37DhGrqCCa2mhBjBTz1ZsoSaYYFgkYgvU +FyFTK2CtIzQ8I6PaYlbPypk2U2Ez7873FwuLzU5S24dE2oXFhsOQvTLhmVlTz6wgFXLKugImfEfJ +9mUMRqpwm/2KiGn+hm5596dRQIkZarAuVO03zKRBntpPy5kZUoH6Ym9iay2kQ7GanpFcVfp1aKYo +NMsokWwALKyQFKVp5xVGGiT/Qs4TUKq0WUNqLYg3tnZTDmOeToIyi2EUDGuYMllMrg04Nu4mw8At +WGZmNHU2s2Aqd2sWYrxQUbiheadCWPnqo0VsKDg5a38U13RLwSGBQGSWixfESamV13dPwkxNXXZr +g2f/DYFj9iVQdR0zjcoxMoyYCg5Z8I1JzOyCshcVDae6VyHb7IU0yb8EpsBxPQ1VQEhTA1alLwxQ ++wMImGqB7fa8ZrOox5zGcvpFwjxat55Tn0+9C3NhXphbAUJqw7cBRrw4drfdnte8kPIUEmveSdng +osrSs4OGird4GlioKJG+QQQT1oxHfYBPzfN5HlmGKMwOqWktTwwkT5sKq06R7HPnusyCU9Xl1tAM +SrrWC05VWwJDuZStVQNTydQwp9q9BpixYJ6z6YqgxhJA0mPCQxMjt1GotpAGGMuCxOb2+SSLzLKo +VhK/ytitadUhT3rjA4ovY5cocCZmZKNyksYxIikkJ9dbSV3DjHhCAUCaQlAEb64NcNLS79vzmhdm +VFeWMSWxHikqM6AtYAArAf3agGMRWbD6FsBSbfALA+38vHNa876Y8kSsNGBNHdTwN2ZPOdX98TRQ +BGzQVC1/NBCEn4EBqyQ0gbTSseEC9DJr7GD58fYKinvHjqN0w5FDMWtWdU6MhK4SaEMzljJ1GWjX +q1SwU57XmlSFESB0OBdbS7RgeXsBvGnJhpMxCFJzQWMqimQV10TfJALGbAQMspCBkQysuMLKByU5 +RSwzM5mI4w3LhHIF/uKuSyNbJjqt3sxq5EVFQYR35yfob6M4TdATQwZD6hPygcFJbumo8mgpYKbC +2QiYK4OhAmqplYDCOBgVWBMqRZ/tUMFDjdh3xwJ4ZdJ6kMicatR/dQMzdu5mPLMkM3vIQHWeqnFO +LI3gSpUlzcqkvbVWU9fdeayqox1qd6zAGKJ1d3jmYezAi6iaGvuPlIvSDDUQsvHe9fDpnVMyc83I +xGAkIVWu+wODjV2OSIXRQIissoU9Y/sMkc2YHaeFEYPCrDnaJGPbsaKbRmOkrHDvzhWYXYjJYi8M +aVb7+4HBWRhvgBnIsqpFysIJbYCnPEFsJzC2JwWUPDYzBObWCk7tARWCfBhaK0K+oeWalUXUj8qS +Prbm5Nb1bzzhfEiRNWoFRh3N7XXbnPPG64t1hTZQhHqh2HUF5jTJxGkxJwgyJgSsoVAHWRYKZBpG +9jRlwkSDsgXsWJYLqA6Ud+cKiqWlNjBGJhxORBUyCnIUx7w9ccZhHqr17C/uWazyy/RYu0EccUGz +huKXL0Zmh1KKilmVDV4BIefnb3yBQdQ8t+5iQ+I/GHBsgijIqa9Vn1zliEoDNN9LwChnYGi0EWpv +ZWwxRhMzQGNFkxo571wAi36qdr2RC4T1iShwkDJYIxoBDbJLylIWDEwlT6Abv/HYLGRwYCcwoVoA +am8NwUx0B8HYh3x7XYYcUaSzsfBRNLs0wjF17TE6NjnjJM/N6iIJ4Kn85RfKXOMq9X2URrO7/Tpa +h4o7nP1NSURUpS1nlkLi3QcDNvonwCkRk2sDpp4NnophDA19y8ikFhpOxUZ4mldLmCra8fTudxGQ +YrFTE1IZCy2REzDImHsGHDKVqZYGZlXKqH5twFnAHDDKNMoQUCfyhqoeGwOpo4sBJmx7U0XKIsOX +pdSCt+rCEJiN5oVBRGJjEClKiSEfShdKBR93zjIWWwaoPJb29t+lNRnRyWI9VdqxylGBspmOUhIU +xa7lOXKMRlb00pnrBOSrTxqT0SCp2vKGyvUJTSyIcovz2sdJBRpMMCNVQddOLZFpPqbZvv2GzFoR +NjaMYuEzfj7UUXL0fM4jqe25nYCD56R2eVwbsMoGNddAkxn1Mj4dxZX5ZamZlzpJ2Hlj7VcmrE0k +TxCbyAapozQJSGUZA4PKykGjJyAbCuMd4e21gRonAE2ba8OiEKbIn0IlwmECUmfXyFwGqu1oplWl +baWZIBa8hCxhdYQKJdtZQz5IKsfK6wrDKGRUCBPzMsUBNVAGvAI2olIrNpHbFRivNL2M2ltrYCwZ +SD0RDNB4npQJIC4+QWk7hfKktybZ+Ig00HI1Ac0uBNoap4GpSM1qc4sJiY0HJKMAP26cUXQIqWYs +whxKnrG1lTJLteOODiDTEZSCCluo+Wj1mdlpyhIOEn6JKCYwhhQV6WwuHSX9hQaNWZYQkY1aI2Jg +7wH1XArN9VIMQ49VYYbmqLRWSxNoWYJ2JA6knUAX6TMknvEttAZ6qe+fAZpALGllPQImrEIXTieq +epPxWGGiAmhsxJjBTk1RxIdJ7ZjlCYCRqWEyqcEMuhK84Rz1peqZ8vWMdNqlBjMtSIR2UaTShtHS +ojS+EzBgoLRut5TCBJlwKRzVQGpqY04h0VIa5QWb91PLYjbAftoOkZq4LMXiEzMFx0/lbCm6y+6h +wZmVw1NjEiKThWQXH1NOMm4YwYRiWxnfyR5j0ItizoWx6VHRNONlIDNnyFNQGW89Bbs+PmnQiY1W +R2G+Ka+LY7cyjmShOTM2LMfEXfh5aNXWIBSaoaykZdola+Y0GgclO2eiMChZJyUzfAIaRy8J6II3 +9m6DFjMPmlbTaLWvkTkXyqpjoKXmSmrkCfLQSqgy4gmyODCzykjyFwij2aiyfMUXCGNopgn4XdQ2 +nsXWmHeQDdXEu1QPUQMWIuXbZU1yqSaaqjUtP58Y3xVJyFIWJ2jkfHPnLWJIFi9V7LgGiw3Zmdp5 +GnBqndhyFRjrvC5NZbZGFbAgYMLcS1kQM0MSATYmMjoHHhmHfOKpYRIEjFg0UaTTPm6czLkN+aZm +49b2p2QADRRGuaLvEryLqXW8qBhfM9RwKcXRdHwEgIngfclDFgBoAQlPq3yj1wzO2KiYmZgw+oaU +15UaSx412wwZmAcisvNG9sOUUEZAcpdJswlK/NLAILUjOUgkja1nX2p/nwaqUu96AWHIk6Ym90Ol +KGbFBBlb6zmKlootmNBao25rIMf45QWfpWLZlvBRdrIZKgIG5mnIk4qEv0qFqvEEscm5yYstDKlL +Js8qzNGE+gWG9HKOCfVCDRNmP4KjpVUqLktysdHHqUSSYEFQURkN5Ggo6pZsNoagiTB7QEnk/HzK +WmFi9FVVd8neMG1qWCp9KskEm4KoTd21Aac2Ikb1ydPAMGElK4o0lfm0YsnWJGnNRgmpbCmjl5Gc +k8yG4EmV5MLPF5iYSH5/ZCkq2+1pYMQnwww0ybRtTq9Ual6ZEJEUG8q5hkXG9EEv5xDUJLMhoYXQ +TGMTq3oaRpeobmYG3wpNKyEfKY9VJdfN2JilvSTTSEQj40zwPbQTCJ0Ioj+L7vq1AadGNsqtaENj +hSUbkRaPE2FzSswB8LyRsThJtmcnqqsyn1Wqo+8ATALW1EVidya1XiGpRXx2FsnAXubCLyRDZss5 +bxiRGMlAwRJTQoHwqeF2xo5MQKr5yseoCWpCAToR+01idvkmsQ00yAm3EjM2jBMjbwhtskuIQkQc +ihxxhA4VXZc2GFl7LQlMrUc1UMnA12Zs4VAPjChGdbNiS/qEFvCoaZ6lyCkJ5LzYyN5QFUCogYlg +uZc6yPKsIVN6aUOOk4iT91iBM7Na9T4xVI4KaGnxjICEHDxBnIYGXMjeBJbZDfE9CXUEtAFqdz4B +TWgYIQKziiTijD4lJcd2WtUKxzA27VqhXcyYtXKYAfX/jCOWsKxqm5BCy2Td2AZ1xThGBKMAEjBl +2VsV+OXnY2HtTkzPAoooYCk5M4augEq/RLfQK7QXelPkwGhzdZSvViuASWBdO8Rt9IfFdND24iUs +ucXSRv5RGIHW2WPJBs4wsNsVWzOLsqiwSSYmvGK6zgGNNGvERvs840nZFEp1xaxvSdpMvCIFM85t +mFimbewaGKfstk1skGKc6+AqfXMNH49Jv+DrzGYLmtVuQSw4qILAEauB6pKZl5nkIrKE6sMlYMGx +s6yYQAVHap4dJ3ZsxnJTYpA2Vg2TGGkFe8AJbMJYcuskiUnryJkDRZrUxoqQmWWpCBKeILETKMZp +gIGVqSNNEKh9ZFrIJxwTHWdsXwhyjgWi9ispx0Ny2H1cpN5lOpGCXSGhDTfhXJ5YWD9nxumjd3lC +CKzKm5rnMyNyxOSLEuarApNzFyfWNZKrC84eyuIuRwbjKbzSfJGhJLEqB8NilNUrldeS5W5FjDRQ +iJzZLXt3YovEdL6xfZ5TA3Kb0UU+TxOORhzUrkmETLWUYZcnSE08TG5NGXEhteY2gzcuggpzLbDp +CSJrC8m0Rd0s1mS+FmpdHFtSmGuTkd2CLDaHbVIZyQMeWtnMBHbEkY7P1/dVsjmIGlennKPNSUXU +3UMyq5Ox/YKgCFcKLSFSNm0eK3TkGJXcjAIOaUu0KYY6Edp0QGUH1/4X0hhsOnhuvNzBhhbN2lcc +2FRwuiIysitgTyPFCtuX5TETncBkudGyRMb8N5fFJ2Q2o1SFYV/zlxntPKMo3NRMwcJcZi3ZcWiN +rZm2wPLehgG/jtNdIxUrZCZIjVMnytlvEKj65dYzRTWQWeQJ2DOlNEe9gMxE4uY2NWzDvEGzBixu +qNbF1wbMCfxEPST7tgLrxd1ww7FSJFRpKZ420EEiKuZbsGeXkyNVMDED2WujstrZY0dHGhvfMnUz +NOvKbKC/sPcmyqzor2zPiQGq3G8zUhXJ0eBI8gSxcShEgp0fRbQk9a83ViZBFYM4wg== + + + V5BMJVjCkxw1R42XOW9FGjEZwMCGokY02VLFmBkHDgV4CHbLRKku+ZAoP2lq8qDSjQ1Th6OB0rA/ +UzuCJ2DjSWo93rS5NjYjyzXpVV/LOTKZzaWnrU3YR5pL683fSD/nxMrM5i6oJuChnSALOcU+59yd +bCMKnUqJGeCnHMi5jQoLA0ZbRoS0SIilG8CZaCoNv8C6kCOSIztU2HxRQ//v8o3zWA7HVSUBP0bl +VBuYDbDILIk52V7Na1OijTFCAW2yvZFF1RcIniBhUZC2wOYlqdBODcwzjhiIk5DvTZ5woFGSbtCD +IinbZlXkVOyN62ME1n2dFynWNq1D6lhyBbWZQ7llIKlWu8zzkrPxVMwzT8A570Kbva8ZnHDwkKpO +Ych6xLl7Nl5fbiS8BFaYVT1TI0aOSCSWAHO+eaKzUzQwKeprGPoXBxbtCT2tfAYKHnMYQWayN4iC +53ZhRuGLVWCrDVq03DXcyJtQT10zWHDEtzr1a8PMheV6qkqDYeYR30g+tE/Ha6U2/zmKtD2bpKmA +70OcapMGyV2xTbiNLcehJJGA96HgZKk1yyfay60lujjg+gOcukcVeE1IJpEqNrNSm3QT60w12nUg +IgnwNuVbxCHL3ywoJVp8ZlFb2XgMVYiN2hiT3F3EpViNh63iFPCSM1CVcDP0lu1rpB1lnNmtMg5Y +veJUqzxnnY3zr5SBQhqlz8T4EpBkTdbZWEVNrb+cFER7jnEUsjIbB4zPRfpTQn4rDinZUFs5TJC6 +mmoaTNYHmxOZRBw8RbYK+7UclKoayHElnDS28bqhZU5JyCkRieq2zV8W6qwIAsYcxKbkp+VHdpW0 +iKRXQznzl4Vo9S5mWbGJPyOgzapQI61dJivSWCNeANtl0sIQeEcUsBkrbEIyG5cSGzKQWqWTgLFd +gZVsaQKbJ0l9JMzY1N7zhA0ClLBl8+1sPvmn45tzyUjD7o2kSDdLtRvWAG3Qq0oiYVMYG5cI6SO2 +pRVBg7EJY05UnJNgMmy3hsbaPPDMPF6EF3KRhITiXzkJB9y3MMUlEWejc049gKygUjZDzIZH1mTS +jWSwRGgVSL8s1PJMktnqS0U2PIChTU9IRV5YOYtaKyaTN8lsTpywvjgaaIQkoVVZfj7OOI9BFSLW +QBHkRakAtpKy7ZYom7Veq/4vvF0sGJNN24qrEDpjC84i/ogo1/lJVPI8FVzwSmjRhYzXKTPoVLKp +JZFW0BI2UZsimmzWvjX7SRtBJTaK6RA4EVZJY8FU1ftkMZa/mPpNRrwNmZEyVHlztuEkAQdYpDa2 +iPArTdm9Ic19pM2N2cET2XBmYXOn0tiWeBAGE9PE1p6yaXLp5k0qIvfSxNrACWXUyFQHeugdNCmF +aWIdNkRL7MtTq3ybykMayCdrenAtld+vCKRWFP+U3YFJkZCuL22qyrZy+DjvH1m++FVKCuQJYiun +sfiYkqmdpaHYOP6Edd8aifBb87ywGSwyj3ix7FlJ2N2QFpWXiFYlhfczSDi/JjfCIzmgbei6KPzf +rE8LXbCGJzDoE4aFB1/IjLmU9WnzplIwMGMP8X9OG2I9UJX75tJKYWqdv+xmJrmReQRNkPC9sC5W +ZY20gdI23oFjsukGWfe1ip/mxaZaFqRC4dKWAREcA8FCstjwtghyCnJSdmz8kwAyOxHWMCoC6xqj +kezAB1gETIgUo7824MKqYyN5Qsu+xcoogRRxkvK7qGZuEYhiq+mlNlVURBvpW4Hx8wolorIybcrx +USNam5atNNlTM0Fmr3bGxWoodieOOS3G1PqiboU2QY4TIEWykRNmEgL1WOZzgmoJ2hgnjlbLrMJF +MU6W4nANCAqSsmpcZK1zgu4UIzJndorEZiQU3FckOsApMfqDtBMIQ6MTLRuZCSzzYpqnegrxpc+D +sFiBEMxVE2MfpJaMob20HOqU2nIRyUY+oRDWwJgUqSFiIw2EEzBEEfWhmkxxRFFmg5NTnS2ogUX6 +uIpP1MDUpE0TcjCJoE5nBeswqeYi1zG3er+M103IDWavgpP0BHJDM8qDjUwYBip7LAPvSI+RG+IG +Zy1kFODK5qYg0kY/aiBkyxYk1I5VTUBRrRFHlHMSShZt1A2IjI2TgLbsUmZ96Fm8YejIbYIugW1O +mnL7MjjPWfDkXE3Vc50xTCb6llE3OcPqxMqmM1PTdOsZj/RtyhLrlSBpQetPBExtSnzOWjrVj89u +FnqgmvE2SYk3nDrq2mzVwuxIhcdDtsiqACLO7eKaUsI6RakYvq1MyNFtWW49nXTkTOwIbHWVLA3t +WKup8HXKKPo+2eTMeoIi3UVwUjm1zrWZCZEJU8lDG+IhKKPXLCCnuD/mF4ng+NecOuRwtQphSBXG +ypBtr+zozKmeUGQoXWqrpNBYYxchK6b2pVFJ+pilPhPZRG3pIjZVq0oT9vmU2YgqqHJtwHlQcD1t +esxjCiLmZBdTM5SAAdPlIniEmkEHtr6CUYRVA3TWoVJjxMkzK7OpVpCGj+TZRqXVItF2IwVB6Mpe +DE6EfZ3hnDmFIXABChPTT/24QxbS1Jmf8rQR4yjXjMzJ3cWoaDMgMsnXRinC+nFpI10LFYbWVNgo +g5yzJbj6a6o6HfHzLE2QbsjGqVwlCbDSS6LJtRld1KrR1upcWnVJ6KR0Dcxivs1ByIFFqs+GLVZr +uG5OEbqs73GFJBppaZLS2u0EAZsjObxLKl+wrXCkTTLUiqOYNQyKCXJb1UbZLq4NmCPEhM6pZLAM +pRWgdJi5DCk/kgmQtK+T1t2rLoMSVTE2CdmgwMkhsohSELb8hlR1Zix7Y6VRFgYBweUQZJEqLHRQ +CAFJBmDyFdvQVKlUaFZhUh5K/VGMiGEMj5L2M+faAtHG8xyQlyoZlmDCMhFl94oNUORM0RKrNUvl +UrA1dcwGZJsKuollo9ZOttRPaosbSNXFml8Wa2mExsrAcm2tw1B9/Nxipn44t9EFqtiAGkYBzWwR +x7tpRVEQ2MjgVFd3pOcV2NaoMJl7BMyspBvoYrpqZMZOlIhLAlEWZVGKLTYaKEEzez3VXhmgFdYT +HQFLLUhUQQe9AClzM220YX0ycSMELBQLU51NjbTFZiIOvdTFjG3xDV1l2AjTTJAjk2xJMRW2qliY +8wpyK8KrYP/MjM3tpTU5zzpI4I50z3xDXjB+GDU2YcU41NdFAUN7BdgHrINjcltH0PBrna3Kekyc +6WRYnUHE9k7tGqbsiEKPio3DhIZmKTvJotxEDuoUD7F5PZYmkp+dkkamVUATobcRcqAjR60jX4eu +6EhfznMwmphxtXM8C9sWlVM75HA2apNsxnJuvjSBAMr/HhVpMCZwREcKcKpAoMmsjiHhxZr6Qjp8 +ITexHKo0jp4g01xLv4tMixqZjRBlRhtMEJZOSy7zq+tNcARRHicWFRlpTJjKtQGnsY2q1PmFukgq +pxqkuhyYrnNtQ+fY3KeKxUbs+TcZG0olijhOUujyZzoNk0NqlKORJ+AUS3LKmJdFGyEVuj6zajFk +3AdS11q3l1TyYu3eFrqk1IKlBlInKv5WUUwQ2XSFjOy+1wYcSBvXQwHMTFTykCOTksBsWLgSNuPF ++IIUUH8YhTZFG6nh7MOkDJ9UmLHGYKcSzlObcH4zN5yJXWrAKraOKSvvuJQ5U9DMZuyFYW6f55Rd +qenPtSHCzK6KrEvqUCRt4pC2tygOYvc2ZqM+9RJMOXEmCtntpBiWNPiRG2sodbgpYjuNl4vauJva +XHK1yRmZ/lD8WGTEQZluBOhymIBMN+JIpSnrTRw74aQ/xUd4Xq6yKjUnMSxf2rBVY/Mh3h5y2kke +FhIDswy6T9oSJKk0HS+WVXKZ2ITuXHui9ASxFZGklj6vDVgYAYF8p5kRWthAlNuYQADDnAPFma4q +oSfjeE1TH4DaolH3S7MvOhNVqh5+TA8y9qVhqDHQqpwybZ+jXjnGkmjjFCVV6+EsQtWmiQU/1UJO +v98omNSWzSbAcVacDK3HiRbFMWM01jBCCjuJ+GV89XMtb5oVGIq2GVRJK5Acn6SscRrI8Z/sAs6l +NbVI7cWyom/KQZ0mgkbBGC0MF1aSb8x5IBt6hkrx47w0HR1FyoOdMw60LTMvai5IXS2Q9RSZ270y +VaZJpwgZaBir6reXciqNZAZE88Y2Rl3ZOK2mIXi3ONyV9Kec91WjVU4JOjbCTbA1mnS4lCMXRZSz ++hXa6H2V2Li8O9tbgwMbWau8BGbWgKPhmDiQXmiDUm24kdIWma9yOj+t38Z4g23zwXKkjtRl7nkB +ecTBxVxNj75AWprDiniunZJ6ZKD6UvEX2MSf0GiQKpmWQ5ZNRkCe2cqbUvcy4U9gA6VJsLs2YCji +m+kpWpHObVKBQcNc2MrScsOBk4uNWiNRwP6XnAItmX8Jk12SC+4JQwHSJkwkT5kjUV61rWmYC5ZP +CCwzHsveDk0M9cBIMi1WMYn6eVPJUB+u6f+Qp9qSrCVAEyxEvblEYoBKPWILg7C0KDXqR55y1QxF +oMyRq3gkmyjP+V+5LfSpEkcNeiVsb1MipJ3AeKRVyisbq/KYbUI69jznCYo6MCYLgjr32bzdzMbf +A2yEOdpDvvnUGJ0RlLtP5LHVIIhGRJGdILQBvxCz2W4AKik4RZcLfQG4QXszg4uRrVpryMGpmSCx +KSK5ZatkQ4qZUin9msFhVGw6twjJi1rGFD6uzzKk+E/mllLHyeUh96JR+cdBYZoKU75RnAVGBjMb +zcxBS3lgvWlyozhkXlSyL8KhyWjHiTcmzAWgsLhNCaeNUDNFmz2Um4zYnLoecZmeiGfk0pRSJ/fy +44Wgzbn8ecDyYVElSAG17PxRZjp9lQ5NIqzLYl5rYJGW/bEZEYzUAtnJqPpXpjyvFPwyE5ikCiro +4D/agdAWXwg4vDVT/ctZ4LFBmJm0apjJNzBji/QOE+qTqabHfBkKKy/R+KIunGYtmbRBbnRHcjbR +5laqt947guac3xEY1CKgYHrAZSBpVdEGPSuMwSLlM+TE9iznoIuN65xZ3Sw07Tk00Nh4KT094TyQ +LOOasqTVmkz0zPo5N1KoyZ4tmKKyS5GAVqDnljqZdf8q3DAmebKj2DoCOdcGylS8G9MuUwYos/1i +lFJtDosy80PeAVsygDwFlleoRFX2KpiSDjSFCaqnTrO2MggnIJD/IeEk0YyFJnJW2JR1zhGlSS3R +iI1RC8DE4qHSWHmC0Kaha5lP1SBhwqXMrBpoeKUqt8VOjYiyc63QarYlIrHcFkKQDLxRxIRK0YTe +mfGHscuFRIzAFMoRqqYw43Icck0HETHDYMGBqj+EnHoj06LOQ2rvWGIqQIsiyHcjm//WArgwn7CB +WLlG8w8GnJt0QrpFOXvzi1yMLLEO9pBFxbRIsCbJITPyG+dZ0qTCCvuJDTG4sQAuDqdkqc1Ayg8W +zAa12LQa2gibN8XWDdCGiMUbsZFJbCvcJhxgT+1dNYyL7t5+/6kqkaMONCpqmOoydw== + + + HxhqY0A4DVIB2dWkjtsAUxt9ZiVJAkt2jXG5H4oSjbjzCGeGRJIplgpRYrlERZ8y2AbeZ9btaotN +31z/BrLKYCPg17YpIaVGcCBz4UyUSjA0X8f1rZUCw8fBjtpb09IrZ694RylWIkitNp4LW/uSrepF +upYCcpagSqpf/lKqP4cUSutNV0Cbfp/YAgo3VrBRS9JWf4m5NJOCMjdX4XcGmHJBEWOb/jTFtrIe +O+kzGwNDQHPUd9WcvGtVppIUJXKFrCJAtzf1xmJiXCxem5KTpPLbhMDUZqJ9KukssRmJpjQ+TZCz +8ZJdxrffz4XQSOrnfnfCduaJxEbgvIr95+yDLLfebyPfEjDKOJyWS97fiCbi2H9y43AXp9z04YvE +RicpUzjp9rqKkvlsrMy0nmNL5occ4CGilCtcxza5RGSmGnlMQiQDbfs6Akfsjo3lRsn9JLNFOUyt +utjWqs1suuPtdRU7HNmWlkrS5x1mw7HS88xHc3690NUOljphQ7BfqohzIbCNzku4cUa64c3kLJAi +lPLjp2Pun8JpfSqNxIZLhSkDbyyfvyu1Ye5Cu1u4EDJnDwlrE6NcFBNLLgoanNqMIrpMNjlDEVkO +DeC6juQ/Yvd1wnXxbq2gqO6X22hb2yQkt4UOUlu/loCSA/izmPMNuORIolWaU/M8FwJJtAXNkGzb +H4AtiDdfXyAC13bN9OVgRAhTLoGugmL4qhWlytOkgN6Y47qoAWlRPcrC1FbO5OAak+7K2U1cYSqj +AB/OoBGhzco0+YOqSCbflshm4FMKjl0dB0+rNXDuWxjZrJqP13ValPr8eGJesKK7GmzTUiKbqR7F +OaelREUDj1QUC2NzVGYD22nShC9syHTgji+zJNGWr1fkjs+Jne90wbkcu8ofY7evKjFwffckzAki +W6nO1KX/YMBGZaQTCXmauDDlZtYUTOmbNv2Vs/Yo3yPgYheptafT6yQXnE9MibOYmlJwPqLyddy5 +MJb5QqvHmYoVHww4tEVwuEsfAU2rglx3VdBAk9JP5lxmlXFoiziYLOTru99WbBxnbptSQrxxsTVg +cvBDXPQ2krbaW1xUVTFCB+9QURXFliC2FYGVqTPmCW6s4NRydyk571VxQObuec5nmkt7psqBaYhh +nrFSdnsSrkJJ4bScSK/iRbliehyxsWojLaMoEMaaPOUkpIUFq8hpKMyTynGkgSLmYhWZMSZQnkLI +yksqoiItI49sNThjeU9MYxktaJiik7e/oCgGf2Nm/rTEemVstkZihUNbdsT04tVAG0mukji4nlli +KnER0JbiTKNPfZcqxqzMM7YTC6WKfjBgGXJXHVl4xotGHtZhdccU12buUCsziQ0y+MBg264Nf+PZ +TWNyClYURWPyIvQN0rX2xYeaZCc2aPTOd3H18ZSLO6hihtyNk8A6C4s+lRjqNYOttzI36TMiZZWN +bAjaBalCV7WXiIAZxzzefl3R7iDP2RIsrMomJAstysyT2m4HpmaKMhLloQXfmMNMnsVc/pN2LOAa +vwAbx6XeyNzYKdh6oKrpsUWDLS1hEaTxyQlMWu2Gpf32Cmj/X92T3mTqvf7yo78Njx/mb85/+O7k +p7/99Y/P3v7887ufftDAk3d/eP/DR+DJqx9+ePvh3XeegnoAe+GUCsXi/6//XnSqD71A/e/1P/CP +K/zlTwD93QsD77H3q28C7zsa//zeMg/ymGr95YEyz4WKfkG8T3RqaQG+/hhMlQdJ/7jenOJOYDHB +D3jn83tkngTLCKh5HLRSzEYVYGUCvoUXhCqhkVAQ4lAa5ylkYbA0T9nfgXVknUpS/MYjax2U+yxK +wRxD8i8qDQ/yQE5adRoAL5XFARNQ1gfwBzfn9THU6ivsxZ888glgSxLvMS2XmlrGkfoKqiuv2/vi +H5SPnmyCr++9KLZZ/4cqlMbkSwQrC8ifRFSZlhniCQiOYHW0ugg0IoQMgqXkVCIuIF+hpJbDZpH0 +BdlHC6YvUJ8S8KfRF+BB7+/mPFRCC1YntAflg9n6ANd2A/z95qKf/tde8dtbOGgWr+ySWGVKKTIW +81QNOwv9GO2E7sx+E6g+8tsbKGrq0X48KTVuDxjI7zdAPYFpnvTx2FT31ft41gL40Qo2wXa1xayb +n/XxBnz7EYkw50XnSTKN/qaNncpJ74UYvDmlvYnFmzdAxRotsPiajemK79548+Ye5dQELU5vjY0S +Ed6YtQB+9P5NsF1pMWvxQTc//dtPklFF7r67Jz7ePvuf/x9QHnVvLcGJtBCHL6Oway0NKDBEnFiD +E2ob9L0hT8pACHoakFIRMgJhswEk5xMZZXRpFIqV152d1WYTR4f4S1OS9Evq70f0jopNQsL46ga9 +M2BFzDOqa5qIj6cgVxU5e4vX/StTHwoP5lUJVVQ+/HjpmemhWXzm6T0NVlJEsSm3KNd/0zN8e2+T +ghG/z7Jsg/PpIwx1AIMCZ+TMJCA5TjQim4MnYKIVLwVM6Iy+NTiQJkGqd0Hpp9+beQVFYqq7AImC +gSqwQ43NzVVUwZUJvyyV6hxur/ZT9CZTWvGt76JTTsWN7yLfkZDJx99FchJpeze+i7JHKBXyxneR +C4wEYP1dZPhnsAq7/ujLMsrvjOTHX3Z7vf/ZVOL/tfQFBnlb/gq947/8FwlhqmBCQjuTR8qkasSP +nFR7qLabv7i+8QtKnjTQYpo7gRtTkCy2scaQ1oiPTt9cvP/+3Y7+q/r+52//ik+/h93CWi/vrc/e +/ev7b989vzzxXj+59yuSERI1w1L9TV1/+/pvPPL3hoGgZ//4z0fTb/gJ/m/uxVhdmKmFQi+gQfeG +Q7W2s7c/v93xyBYW3nv98L/zerLlBE436g93B6P9wWDP83c77p4/OBtOL/z+Ybebt1prv7+zWD4c +T8+GkyPHE00nxFOuL7o96fd2HDccjXam85MgvpoHV8PZ5QDPjk7H8+uWE9Xqg1qt127NeoN8PD+d +B4+n6yej+VVveuL0skZ7tQ4vZstj18un86vV+lmUftmfnLvdvcH0gdc/6Dhps7Xu9vZ6o5PB+GSd +PHMHe+XatOUkbk+2naDRXLqumM0v4vTVdH01mB63nNDtZW4vHkxkw1n0xjuBeBHJb7LD38+jF3i8 +1U2aDljo8/zot9HOV2H2Rbr7Zrp64o+Pmm7YHx36A2xCUm8uavWJ4666fjQYyv5ot9aY4F1db7fR +jpqduOWm3mC/PzrxB3vD8ZHf33P9/Sz7dRh/4fYOG52o2ljUmsu2Ey5WD6fz82Z72WwtRuOTyfSi +NzhotsJ6fdFxosn4WMrXnW7idtPh8KhWn5fKA/y23Y7bHfyk/eFZf3zu9U+8/lGlvqg31wA6bu66 ++WB43OsftDuJ5+8121G1Pmu7accRrXbU6oTj8elseoG9bXdEtbHaLg/wU6lOajV8SNTzsz4QoLVu +NGauE1Qq/e1St1ofN1qrVidqtuKut9/t7mC2egMrX/eGB20nrlT7zeYKi6xUxp1O6veOut5hv386 +mlxMpqdnZ79J5eNWe+p08/H0chU/mSzOG61loz7ttBNM2Budub39eiuqN1aDwcF6fb1cXLoOiPqj +wfiw3Y2BEk5XDCcXo+llv5+vlsf1xgQ/QM7F6tlodu0PgV2XQM7B8MDv5c3mvOuLRXCd7v1qGT+f +LJ94o5OWl3Z9+etv/qeD029cP3W66WzxJN97H4rf+IPTtiuAJK1O0Oqsm+1Vs73G93b9nd7wpO3m +bTerNRaV6hTLxgBgeH+03/Gybn9vtrwWO789On339Iu/dIdJu7ueLC6D/Kvds/fRzje96YPe+Awn +8uUX//bw6Q+dfl5vrWarp4dnP2T73/XGl/74otPNm60VttFxU0xea8xLlWGjFbQ7IQ6iXMHpjNpO +4gHhhwceNtyTne5O291x/P3uAIiHu3CIPQQGYhgebLYDIGq1Nmq1V74vcBmbrWW9Pm811u1WAAQD +IrlOtiO+FOnLcnlQLvVrtWm5Mtwu+ThEfKzrH/aHl6533HEPxqNHk8lVrb5odyLHFX5vH0cGgtBx +QR/Ol+unjpdulb372w6QEzRlNns4nTzAZaHZavNmMyyVe1vbTqXsu52o1zvqD469blYq97EMx0mq +tXG9MQUuNVtJubpqNKNWO+x4u/3pQyIsjSm+ooJNqAwdRwThF1H8VRh+ORydZuLlv/79/3z+1YfP +7teni6uD0z/mR28G07N6c0WXqJMC4WvNebU+B6TtpPP1g9ni3AeG+/LFi58WwYN6e1Wuj31/V8g3 +UfZrvyc9P6rXcRHixfIBKEzH22l1d/zh2WL1NMm+nMzOnc56sTjL9l4v4qveZK83PsbOj2aX6+jZ +o8ffr6Nr10uBlqvwxTJ+1Ruftzt5t7ff6RK+AbvK1UENX9RZ4wJ2fdydXb93Asrm+0euJxqteddL ++6Md4LzTk+vo5dnVvz549rfjq3fOIOmNdubBg1l4NQkf+ZPzIP3q6OxP+e6vLi5/n+19AQrsuuli +fR1mrybLR27/2BviE47crgR5AWpVahOQgmpt4Xp7+GejscABVWtTt5t3ulmttaq2wxaOtXvc9c8W +4Zfd4V61McY+T5dP6s2gUpttlUagMx0nabVBwQKQqXaH/mw117XqpFIeVis4ymWrGcxn56PRMTCq +XB5WyqPt7R6hWaXfaK1df28yezwYPRqMHi4WL2azJ80WsGIfZA30oePgCE5c/3g6f5KIX3uDva1y +t1IdOG6CS+f39lw3AynAspvNoN2KtrZcoFa9PnY6oecdOV2Q0LTVSnq908n4tN+X49EuLkKpOq/U +QlBp18twcTr+aQdEu5tg2lLZJ1rnZsPhMQZ4Plje0Wr99PD098vk0Wf3G+PFSSSeT5cP26B73j6o +gdOVNcUIcK2wA14PE2ZtOuJsMT27fvx+MN5vdoKun2Oq0fSB42Mn5yAgnpfP5xfL4KrjpsPpkTfc +94dHLu714AjraTYXcfzk8OztKn4Upo/m0cPe+Gi8uJwF1/jTHxx0/d08/2IeXFYa42pj5jj5ePLQ +8w9woKAhQPJGG+QL139Ra6waLdEfnGOrh+MLf4Cdyf3ebm+wO5ocjedng8npbPV4LV7Po2fdwV6Y +vgySp6PF2SK4HCyOxd5vHn/+j8Pz99h/3BEQk8XsDBS1VBkAhWbza7n3DqczW1yPJ6eevwOyA9IK +ygbaValNgQOdjgAD6nogUym4Xgsn6x263ml/+ChIfosr03YhYb6YLB9XG8tydVauzsGtMAmIXseN +wMW83j7ue7OxAnVq1Bf4IRyrDDvga95Ovb4qVyaV6rxeXwIT7m93q7VJq5MMRqf1VlirYyXregMk +VAxGJ9htMESgDfan3g4cb7c3vMQ5gqb1+3sdZwH6A8RutkGOYlDILtiok25v92vVebU63tryWq1s +OLrogt56B81m0u8dROGj9eqiVOlj8dU68b5GE7h9MJw+W8evFqtHIG7bpV61OgLt2g== + + + Lrmlku97+d7OV5P5Q6d3UGuucCPazsTzRX94hDOaLJ44/kGnCxSVEAZGo712e+q6odffH0weLFaf +r0Mc5YHbjcEcj87+2HEznDW4BpjCYHQ2HJ1hHlyu+eJRIl9C2inVxiB6ILaj8Tlwe7G+mq0eZOmL +f/+f/6/Xv/uH0087ftyfQCR7FMSvRP71zv43g8kxfQVmbsdu92A4vp6tvpgtX03mzzDM7Wajwe58 +dVVvJ2DWjVaCnZzOH03m18PZVZK8/OLLvx+f/bbRWfn9/VX0Qh78bufonTz6bhFeR+GTf/v5fw92 +ryvNebubOUAG/wDiwXR6CfFGSSkLMJdefw+XCDPjp0mMAPLPjuPJ7bJTq+Nz4jZd271Kbdlopu2O +nM0eTGbH2xXQllmjJYeTZ7Pli9ny2WB86XR3gQ91EktmtdqwUsFZDOvNuQfO0j/ECTod0WgEjQaY +y7BWG4MBkQBTnZbK42ptCToJ1AIHAcmqgIBUeve3WpDBqtVZvb5utSIQChwBcAZssVQdVBrTthsD +aSez6/4Ql2If244b7XnAnGNMDjoDllcuj8vlSaMRuh1Zx1fUFk4nLpd9ELGt7R7YFsZ3OtE2UctR +B8JeG/xo0fWxLdL1d4eTS2xar38MGczpgHZ5eLDVwlOiUh9vV8fblQm+7vT499X6AHIpZAbQ9o6X +O97+ePYkzd+k2W+Wy8vxMJXZkyR/2RsdAcEgNvvDncXiQuav5cGbRiucTo9Gk0OIiyR1DM76o8vp +/Jnc/y7OIcdmEEuWwSN/sN8jorS/DJ6mO6/PLt/99Lf/7erFe7cvhrPTyep6sryGyjCaXszWT/zh +CZAchA73Yjg+na8ez5ZPBqOLyewKvHK+fPzo4feXj3+st9NGO/V6h+PJ2XR2iWfHswdx/OLw4Jv5 +6kHHS3v00kPIgWH6Ot9/O109CpPPf/jLf8wOvwDCNzsRaN1o9gASOygq5GFQgFYnxd/BMpxOhFdj +SaBLxEq8fa93VG8s6nTcI/zUaqDnoBUnIJtZ/uvx7LRcHQFPOk7ecmTLBaPc9fsn/cFJt7vfagn8 +drvsVWsDyKKt1gp0aTI+Gw6OBv3D8ei81U5Bo9rgqu2oXJnW6pDBFrXaDDhWrU5xsl1P1ptLcLdS +qdtqhZXKbHsbHHPc7oAZ4c5CSF6DcbhgW90dYJrv75P+5e0BzehovJ1+/wAyM+aE/IY5sX6gFoSu +KuR50KXqhKT36qhUGgKdiB1XRppSAX98fw/sab68hqgG8R44hmlxoG5X1GszyGyYsIur6oQlbIIn +vf7eYAQ8jKu1IWg+6RqepLOYPMp33+2f/nmxejIY7E5HO1cPvj0+/223l/dHR4Px0XR5HsaPd/e/ +nq0fVGrz2fxsMjuFjBcnr9bhl+vgK9zZRfjKHwLfgmF/b/fwq0Z7CWnc7x3s7n93+uDPl09/uHj2 +/Ti8GE6PTy7+EIhXDQdYveP1D4PkVSJ/k+68Gc+usKTJ7KzTFc123HJATPaD+EWS/er08vtIftXo +7LqQtfwdnz4EJPdkvrqeLa5Io+xKbOxocgKx3/VlmLw6v/phnb5cRE/l4VeOn1XpDu5AioMmAs4L +PgKRfjA4xYvAOMqV8aC3G8VPofwCJXAiEO1mi2eD4VmrjtutKE99iRN3nAwiWX/0EH9CMPbcHezD +dnlYrk7AtrA2/LPZhGwmK9UFWG25iiPrt9pr6OA4a0iq0/GFSL4cjS7qTejRS6WR7QE96jUoU0G9 +MccjjSaUNejIcaNJ0j5eWqtBJF41wBPrS0j+rpIWQB77wxMcOvQFYMJ09gB/QkDCP/Gi2fwh2AeY +ODhgvTZvt5NKZVoq9UDHSKirTEAJ25DYyxOiijWoY+DFswoQrDbFi5xOBlyCUNd1xHh4UqkDo3xg +Y2m712wFYMcQSsF2y7UxNq3jBuWy89lndUiwPkTuVtjvg36e0vWfX3T7O01iyulsfHx49JtV/BjT +zhaPIHt3B1l/LBerw+EYPCskW0HyChJvlv9qNH0I1bjtymoz7rg7kGOD4Ol0eVFrzbw+MPNgtnww +mp2OFhfu8NDp7wbpy4vrvwTiRRvEYXzmDYG3j5bRy9n68/H8MdRtjG9COOkKYELLicazh4vgi9H8 +WXd44UFX6h9DkgGxHUIi6u+0OjEub70JYWZ3sXzh9SRke9ATMGt8LyQuFxett+8PDperJ2n2VdOJ +mp01xH7IRdD6QTFK1SlEC5zgaHgcho/buIYlH7I35ldKd1SH8FPFoYfQ7EBA8KfnH05mz0fjx1C9 +PXevSrcY+juOrLddgoLm1hthp70HCZkOvRVUqtDrl0BXUCQghtrzY7e7W2uEkJ2AJIPBCSRzz00m +g/1OZ7213QY2Aq86nbzdBp/KwaA77XQC5bo5v7/VrFSgSILiBV26UJBLgWbz6fThdHaF0wEPhcxM +cr4r6Ya2w3K5j2XjFfQJxMu6+AEBbDWTdlsA37AwCNhg/cQ6q+NKZQziBrENNwJsdy9/+dXLn7cr +/c/utzFV18nnkJYXB467pMVUwdOXpbJz/7NKpeSArLVwQWpTiJGQMHEc9eYEmj6E6unkYj57MJ2f +41ihPk/mD7zRXq05cv2wP8gm0wPQq1B8MVtdNTrr0fxB28sqjTnOGggWxq+i9OVoelprLaAuOb4A +f2w6gdPLoMGNZlf5/u/Xyevx4mHHF0H8OdAMZ91x48H4IpFv987+PA0/7w6hL4TAK6eX1zsrPLWI +vp4FX0+AOYPDpgNcCuLk5Sp6Cr2D9LjGHBcTXAmLxz9xUritYI7QLkeTsyj/eh4+90fHXXB2fwea +3XR+MVk9qnfC7eoQkMHwCLcPewVxCzQcyOa5OV6xTUfQwiFCImq31p6b4j7ixHG1QZkbrQW2FNiC +c3ccXEkBnNku9UnwBtVqr8FhSyS3TMBfSGqqTkHZwFXBAbte3iSdMSbO29/HyDqpohC0RsCrZmte +rfTHQyhHp4pT4xvn26VRo77GmUI729qqu07Y82UTqn1jXQYDJSIzH/RP5stnoMnEhesTfA5oDsTI +TieGbgsyBVS5v9UolV0gHhTergvWNsE9gkIK8kXUppcvoSx7u8r64d3f6oCC4Vu6fgZFCXsL9jcc +ynpjWCq3S6VmudRuNhbDweFifuG6q3ZjtFocQcIEyW02lyTv9fIa0MBd9Qc5Dgv8nTYHynV9Ssa3 +6XlvfNhszWbLE2+QA0KGGgioLSIdYuftZHEFqSAUT5vOEhuOx2tgN5BafREmz1bhk9niLNl92Zsc +eYODweQcOmkDmODl+e5v5eHvHB8ceT8/eBtkXw3nD6F2NToxuGSUvo53vwLRg5w2Xj+sd4JqfVnG +KTQhq++F0XNQWnzCdH4KNICsQtJvY91ux8H68yz/uj8+bLeWO/tfTqOzanNYacyq+LQO8cqTsz+c +XP1Lb3bhdNMweer2wHcgjYwg8eIowbbS6OVkclau9hqNUbcbl8pd3HQcNxAAiEdWEQcstddxQ2iR +zVYE0RrcqlKZlys4rz0oaI3mrE4/ZBark/RCeLhdGmDwcHgBIQEaR9sNG+0FDnFriwSeeh3saeh5 +SbMx63lJmjxsOSB00BpCRdYOW82oUQflnJXLXs/PnfYahAs8q9WKcbNIBGqsmmTRxf4IvL1SG1br +Y5CgahULG4NDQXyqVPEVw3ZnpUQsf2vLAR0GjVI6wmK5ePDjT/8HGce2O9VqH2IegMBbsMIqJm+F ++/tfHhw+B1I1at2+t+p7MdRPhS1rUCqvKw6OfgVdDNoo8FZRvACiF7BuMT9VppVRrbpst6KOg49K +B8MDMj315NmD3w2m+1ulXgW6J4nEQX90vLP/2+HkbDG//Ort/1BpDMjG5UCPznxfjsaHQK3Z4mJ/ +5+UXb/4xXp1XFGKARPv+wTp4+fDJP3ZPfu/29oajo7V43vKSRicE5+pDjF8/lQffhvJ1Gj1+94f/ +EO08uV9yFX0GkScBYDp77A9OoM4fHL+F/FwuTyEz4J/47XxxBTUZJLfXlQ+u3/dn2dZ2A7QCSAUS +OhgfXF7/+fLZv4wWl8vZ2eNnf6x3Zlvbze1tx/NzUDCIEOvVYzAsXBOvlzpuqNiTXyeSQnoxsL3r +J+3OfBWBbgfa0L1dgq4HDXdvDBmsC0Eoni/OeoPd+1vO1lYHejr4iGI62Wh85ZP8ELfcoFLrK3oy +As2BtgUKiZsOcWs5P4nFVaUxVmYxKBoQ8CJiUpVZs77oeflyftEBCnnpcHgItQ6EtFYHUxvjFR0n +Pjj42u/noF24EUBFpyMb6tJBOAdG9f14NgWOAbV6IMjVCoQuehBsHRrl56/+pdaaVMu+1wmhgIB2 +bW/T4mt1MJc8zV6sgstK2fGced9fd1rQLKCnzPzeznR2DnI3GJ9CTKqCmdam5TL0l3kHB9HLx5ND +kHSw4Hpt5QBD/IQuJmFjHgXPjs7f9kd7IPIOWf9wwUMlMIs22UvPv3zzb/XO3Pez8fi419sFHfN6 +O64nXC8+2H3x9v3/sowf1UgcTXF3JuOL5fpJtv+rwfS0rrj5YH5cac16wx2Rv3B7ux0owp7sj08u +L97+h3//f86vfov39v29LmhaawUU7fUfzFevposnkfym0z+GOjabQEIDpQV/T/BeyLGjwfEqfNzo +LLDDYxKc9lqdZdtdgfZ2B7Lby073vvz3//X/bndX29udrhtEyTUoLc6oVMbdmUNUW4cPofKA5jhu +0OksHTcGU8DM+PBwdfX+p//Y9qCt95VPKsSfjiPA/kBqovjRm7f/49mD78BTtrfb1aoPTABzKVVG +oL04o/7wAMQBch34KagNZONK2S+VPEh0s/H5evVwMN4r1yfgmKCTWyUfHARMedTfHfX3ZpOT9fqh +103j8KrZWoDsbG21G/hwkpMF7mkiPh+MpCaDtdpQqYcj0hPBvp1wPttbzI9Ai5SISJgDBINAiB8c +EDZwu+RAo1lML0EeP7tXLW1jciiDhyC20BqgQpbLfoNEqSFejb932glol3IiTDsuZN3FVskDjQJn +7HaFC03cSaGtlMqEwBUiXCO3G7luPB4dZeKLyeoKQj5ODTe3RR6xueMlQKrB6HC6uIAKOZwcO162 +Dh+H+Qt/AOV9dzA68PqyP9wNwof98UG5AXa2IJG7sWiSHRI0dgJePBwdYJ8xf8fP/cEeiGGljsnz +5frx7tEbcfR2Hj93B/v11gqEl5TxxqTSmPqDfWijXu9oMHnU8Q7XwRfr8DmEq3prhvPCCrFvtTq0 +rZhE5ea61gTCuNulNv7sYp3Ri1R+kWbXcvcphBxIOBMcZdUplTv4J7ZiNns0GF30htA3I4jKHSeo +NUZ0m6D/jg+AqHH8pTz+bYVcTmNcqHIZm4zb7VUqfqMxHU2P58HVYHxC1qf2ol4bVKs9HAROv0MW +M1lvxhDye72zVfC16++SStiAxIXjmEKwrzfIdtcbnsfZN9AmiFN3cHbjEkhEZdhpzg== + + + m/V510mS6DGQodEIQJOdDvjjtNlYQR9ptMgvNh6fYswWxOxSH+9ttZbgjyUSHfuk7YJOktemB8oz +GR2SDkI/ffw0mkvPPwCSgGQ5HWijC1w96Mil8pBU1CYtZjw8A6OvVSaz4cnWtnfvHuSuHuQTEk5q +YP0+kVAyaIzAjtv4Uv8IZBPEk4weFaAWBIkllgR8BqslXjN/MBodtyGxuNFkduT1s2YnanfzlrPr +eMdR8s3O4R+jnV9DYen1d8FGQUaAwyDRYIKNdtLqCHBtvLTrpJPxUaOzHI52x+PD0eQiEl+vopdu +fwcqPGR1Hxq0nzmemAW/CuXv5/EXDrTFTup4e12yM4h6e9KCcNg/3Nl/N1s9dbr7jXaMq931JWgL +rj++q9OBFHfRG5w73Z0aGYjGpIPXp6C0/cm+20+7g9z1oJFJkqtbdBkdN3L9pNkGfkbQLKCxuv4+ +uDB5FbsZmDVETXyRUu0PB+NLt7vndXdx9OCnjTq2sbe93QT3bLRDyJNtN/dI7lqCpOBAwSAq5T6x +IeiJLUy47/WAe3mjnXv+8XBw0u4sCT2UsRRn1OnKLt4OydPbnc+uGxB4yj2nHTgQGqujRg0s6aTj +yE4nbTYhbQJhIDAL4K3rQYA/Xi6u59MLkIhmfVWrju/fb9y7V4EQVSGZp7+1jYtGptQaKb8J1I0m +6Rrj+9seqGi1uqhWsexVFD7CAQGru+2o0yJHKoghPgRPgbV5zkG6/hLK5vY2BLYhVOPP7ndAwBuN +JRnowG2hPDZBS3eGw1OQFLD+amWGB31/t06mjH6N6Ezc7x0vl4+xw1jAcLAnss8dPybDuysH40fL +4Kts57vp6gkUMexGnDyHTlFrTHHcg8HedHo+nT3qD47ALCrVydDfz9KX9TZI9Bi8eBE8Ozz/c5R9 +DfxptML5+vPB5AHdx+YqEG8W8Wu3f4DD6vp7i+D5Ov1qNIYknE2XZ15vb7q4artJtQ6eDk1/dzg+ +dVxs1ADyHgSbejOtt0StGdUa4GhyMID8cwg8waVw+6I/gmR12YZ+1w4qlUG9OhsTJUxKlS6Y4Hh+ +PpydNtqgV2QwnC2eLNfPm0Q5523yBoLt7kK7d5y8WltCTnZxg5rT7VIH+le1scQPGDdtXTPsOmAK +olZbbt13cP0hfkMaKZPVCzwoHI6v1uuvFsvnZCkannQ9LMAjLa8xA1X3SKDam82vWs25014Me7Jc +crehu5WGA/8Cj4Bj0t2H9NtcQ9hod2LITuBNrWbiubv4021LXLTPPquBu1XK5J28f79z716rTFon +SEcAYlIBbekI8Ov7W77r7nY62L0dx9kLgsejEWRasZxedtqRFh1rlTGwzmmn0Fm6Tra97ddI0+yB +fNVr8+XqBXZJmS8muMhAsyo5GsCXFzU6pqTdhqSalrDI8gicCKdcq5EzAsJYHfLe8Hy+fkLBJ42Z +3z/w+4ftbgqVZLvSAz3E3QmTz8HmGhRYkrQd8FAgJ/jCzPPy4eB4OrmczCHV+x13iVMeTA/9MbmK +RhDgF1fjxaM2GYsg24CAzDFtpTYCQ4RA2xtfdIdnrbZ8cvqHpy++r4Hx1efAZLCwKcUCgZ+GFfqi +mcye18iRt3a949Hk0iNH6oHfO2k5Avv/za//+69/8w/oaBCrShVo4ku/m/b9nXT92OvGbVLkd8Cv +typuqTrsDY6W66dR+tVs8RhS1mAoB6PdUqW3RSwgIbrhCPpphxSK04n6ffx2SF7+1go6PkS+Yf/U +dfbq9RB31mlHteoAqhmUMqxKRQWQdatUhT6YyPT1ZJzXaqCf61oDCxtVqmC1GDx2O8G4l83Hh2BP +NQj80ImAolWwWsg8PsnALjbwDIQFKme7Gfbc/T5I6+DUdw8a9fn9+837hNgDYAL+Ui1PoRRAiGpB +nccetpPh6AHYSq2+wp91kMHqcrsCNXOhHBCHy8VjsC3om/gi/FAcDojVlksrgQiHb6f1APkjXL0y +MdyF58YQqKqgTpUh9MdeHyIH2fxBWzAtlGV8e4POCIzYr0DCry+UyQLXbVkuD8HsWk68TaEaLpmd +gQNNPLUGcXOggfp7/dEp5JxKxXMcLABMPO3gdcoRD5kzjj8fzg63Kj64wHh6Np6cAE/qzRDXudGM +mkSo+25n2e+lWHCtuQaFGY4fzBbXu4ffreUrCF3An/H0ApID2WFwncs+FuB2M8/fq9XXjrvTcbIy +EB6nU5u2WpHrZWHy/OLRH47O30AjcB0y+4DpA6OcTgzxtdcVAy+fjA+xISA7ZJKFqFYnxJ7OzmbT +k+H4EDisxOCJMu8nwHwwBYhS2CIgDCgVZMLl4gL6FDazhc8hQ3pQKgMTcC7rZnOlmMUE+3z/s/b9 +z1qV8qDVjMA4BmD37XWzPhsNcRA9UgHAXuvYrjkk50ZthmNVbH1cKjn3P6sDSwFs1pe+k41GR0ok +mw37uxAdwZ2h20I5xSuATtvbPbyCvAbEBPHe2vZ9TN7vdSPfjdvttNmWjTa+8XK7MtwC765Dl0+B +/IPB0WJ5NV08bHXIo0FG5pL32WdVsNp2c9lqzEsloDc+DSoh9sFR1tHM6abt9ppIYguCQeb3JMVH +OaT3Aceg87bJlhuRBYwuIJjvslKZ4KZj/UBUx007XlptLrCBwDc8gsPC3yFVroPrNH+1jj5vk/lx +CbEN6mezPWk70I8S4P8EMmoIgX+/1sLjE5F9MRiROYjiWEBCyQuMIwugEs7nYFu5ss9DdIGAd+R6 +O2T/7O1SxF1j5XoSlArnC/IISZ4QiYjGChd2ODoD58I5QtrBgeIiQHn0hwfL6Ml8deV2D/qDMzwL +CaQM5AfB6e212xHQA3sCStJoZxCJcY6dNjYqHo0OyIvt7vb7pz1vr0leACx+AHajfM0jqD+QWuut +ADsp88/PHvzuPihbHXJvpmKlhuBT5Qok/6XyLgU4lHIJ17+PP8mjt93b2vKr4GWNFfAEPA7EoQ1Z +tz6GLIeLDBaG42tSABhQC2wIoktve6u5vQXk7EOXL9OXrrPky14//uyz8v3Pqo0q4RIWBrIAjllV +/kTITvgVlA78BZPgLS4FnFwOx+cQ1UDG75cG0JFJ/VG6A5gdVttsg63LrrsLWQXUz3NEu7nYug8V +uEciIrCoGUJwGowoCqU33Ieo43RFt3egPMXkvBvNTmbB1WT1oEqqKETWiCTJ3i5+6JhqwNvQwVOk +iK0bnTVJ8i7JOWMKodx3u2I4PFgsThars8nsots77A+P+mSJOu36URA9DONnUJC73QzHVGnMK40Z +5POHVx/G0wNo6E43KtenW/RpyzqkBXLon1Ak5+CwS2Eb4VZ5sl2edFySlKBbgXqDk3Z7+6Ppebcv +t0oOdOdKdQSaCTbt9Q4hLXe9IyBzvQENYggO3u3tHZ/96eTsz+PJtd8jHyIuDoWg1Ml1okI9xyrW +Lne6e1CUoLCD9OFm1Yl6rFvtfDS8nE7APlIgHpkdVLANWbC3e5UyRXvi0+aLi+nqAc5IWTJXpKeX ++k0ohs2s0YSGQqEmdbKCrsrlydaWBy6m5GGg1qQGyadNJtCum44HB63muFoBWYvBT6HBgde02hRQ +6vt5rdL77B5QqF4u+aDAwH/Ifr5/Av2LFIpSp9+l8AYwr2plrCKHgwb5wfGNPj5ZOaf6kFVapISm +bSejj2pS+EeN7PzDe/ca9++1aFXEwlK3u+NR9JrEX/pAiW4EtCzR9Zlr1Gp35GT+MMperqIny/Bh +mD3rj6HFn43mDyeLh0H6IpZfi/03Tu+oQ4ElUAChCB/jcMn36uLW77keqNmKyJGfAT8nc+jpRzhr +nO9kDob1cDjeXyzPV8Hjwfh8OD7rkdP8cDZ/cHHx/uDwt/PlJRR5sj51oJHtQBaCkAxtaDA8hNpe +70DwmODuA3Mcb2c0u5gsH40XV1DWII0rn+9CRboee/39BiRkb3cZPhe7v/bHZOUG66wruleqTqFO +ThaPx/Nn4LDbZLQEZQuny8vJ4gKrrdSgiCUdl+JXx7NzcFVol6DkwC4Q4TaF90ABuca3dzwJZIO0 +M5kc9gfHXe8ASAstr+UCSaAFpDUyVhNNIIYIxu2mfn/fwYJbSdOJ6y0KYICc2YGm3MRVlbVm3O0f +TucPIbXWGyHZGBtzFXswgNQEsRaKp+vm/d7+oLcHvMJ6GuRDJ75DrqUuzncHmniV1F7wXJARiCuD +RgPaWQiq6HsgL+Dv+XJxWqsPQXiHo70weYaLAPoJtOyPjiHutkg5ymazQ4ptbixx0DhBf3Da7R+1 +KIA2LRHFA/KQ2xEMhciIE4NQrKLnUfI8Tj/HcUODbjUJXckV205wjsMpdvjB/tmvQ/k5tKEgfTZa +POgDJYKrbO/rwwfvk71fj2aX5OR1wzj7fDg9B33okWVgD6czXz8Yzo5X8XV/uD9bXkbyxXhB4Xnj ++YMwe7l79Jt8/8tV8qw3PgULWwdPQ4hV45PB6FSNOZ+tLvZPfjNenLU9gQ8ZTK8my2ez4PPR4rqL +sxvsTxeXyc5LEKIoex3v/GYwvXR6u4PJRR+IOjoGQVB+yazdTbyBxM90eb4MH4fii3X8YjS9HAxO +/N4hWGeTTBb7LgUuriBXtyFb+jhZ8GVIFwm5UfxdTIifwRiPUGx8ywGdWQxH+0Bgx8uGk3PooYPR +cRg/XUEZn531h4eDyUnHl1XwNWCgv7uMns2D625/9z+R9B5edlRXvvA/8D2QOt4cK+d8q+rmnHPq +2zlndbdyRAEJSSSRDQaTjG1wxgkwNmB7HHGOYGODwXg8Y+M0nnnvm/e99da3S16rFotu9a1bZ5+9 +f6HqnF3WHDkE6xlowPTDaXGggDIn14NEKoDF4Tr9qA4qwhPQSTbHCBUoPbgMHxKFLwJ6hQR2ODi3 +i/d6wEYJKBJH0SQKQQtC2AGEozAiSFcbKFKHAB+BH+Ffea4CZAFQP2YXrAU2dgkYHNwKjicFqaRF +WmKowiv5bG1ZUFvW+h9XKIhlELzgR5I4mVSkgiJX/GjU4VVhZu3WMjAKzg/DsUjNA3qJdLoYTsx4 +fBKK6QSVBAkNPg4MO820rIVzFETPBE0C3Of26kFrgopKpEPwRV5rKWaXEgq0ANgVY+V8LDcbKywy +UhlygBMypcYmxRd9oA/pHJS8oDZZuUpwOZK3vF40PpmtrKBk0gUQROWlUBvyKhTta9EplC6jZAWo +NoCoviDMsgb4IGkNQaszUgWyxe5RSb6MUimETOJMgRIagj4pGZNqeJpT2gybK9V3JWPC5laCeFrW +J2UDft/j5FYQj3uDOqRKwFobLwHbYngkHJ9M5BaN2CAcn+LEOqCKzSnjdB7Bk05rBaN8fWkED/YN +xPb1h7+0tbnDFwoiUZzIymqP4ksYnaK4rKjVMTrh9is4k4Uhw8FIdQiUGZ/Rwn1BbwTIxBCYd4+G +ESmSLTJSA/5rDZDJSVqrUNs0UtOkVFEjE1p0UrWWcNfM1LQabkJ24VQkkuwm83NquA== + + + ff3J/j8X20eDRJzl8r4AsCEFxHd9R0CS5qvAJhahaC0rS7G4HwM8h2DCB6OcWMsUVlPFVZTKAdT4 +0Tg4dOuRvZv3B3ROKkXzc4nScrm7M71+PlZYRagsxoAWSo3aQAilMDInSvVsfjWSmocBEkzefv2G +gNerIHgM1BFireBNa2YnnJxSwx1ezFkbdvyQCaUgmnJbS9QSvNKQzTbJA78UrS05SCSIx2ipRIk1 +Vm7KRjeWW0hXljklx8oZNdKUwy0p3NLifU6thGI9RqkSfB5nM4AkKBnHmRQtFOFTkfhcZ3CiM30s +nJwUtAbOFWEuBKUiarVwal6NLaVKByEm/iC4D0APNYhFeLkMdCyZExhbRpliJLMiKHVWLBAsJHZG +1CdYpUOLTYqvm+Fue/IYrzXHnAJMXCg8LekTFF+l+AokOfwxSqU5ueH2y3YXDdkrKAVJL+sxayxa +dACKMYDHGbHs8MheC3ItygYEgBwD1MLItMPaEWP6g2G3F34j65HpeG45kp0Pp2bggHDBMKGC/FgM +ZdKsUmOVeiyzaCZmYLJYuWxzcj6/hmEAJgZOFUSlAxVqJqazla2plUuJ0gqENxSbkvQeTH154lB5 +cChWmBe0WsisNSc2W1N7+cYqpAogIS1WCL4AXyGqVZJJJxIDgFBILUYow0GyFpUUGtup0qpitPOV +hVC06fTKPiTMy7VwYjpWWI5DdjE5l0+XQ3U/ZozZ0CBmKAZAVi2WXWhMnZjauBTJLcUz0wvrN4lK +0+GKsHKfV3uC2o0m5sudo2pkBnJ1ZAz3eORgIMQKOSMxkMN9PT5T7h5OlTdgHvVIq1xdxKisyw3a +DDR2jKAqsjEVya5nqwd5pZVIz0KBgKFD8IRkDMKplWLj8MLWHXvH3z+7eGp+/ZQabfNqJV6YjxcX +1Wg3np/vTJ+c3rhFi08gZDxIhHEqJusNAKhsbbPY2tZjE4tbl8u9bYRLI1RC0iqhSCteXFLi83pm +mTO7XKgZLyz5EMXuInEqbsQms42D2fbhdHMv3dgz4rOtwaFwsi1o+XBmVjYnAKmU8CCRWyj3duGD +rAi5Wnd4RT9m4jDLYllUG2q4nyxu5Gq7GJ0kmISoFHyIhNMmJ+XDqdl0dT1dWS83dzqD4yDhGLFC +C1XAWxi+Fh6EEzPZ8lahcTCSWgGkBa70BnSaK4QiE5HsnGx2ea0hGm0zOcUolSCdpuUaq9ZFoxvN +LEKEy92DjFD0BxQUNXweMAICgmXU0ER9cLjY2crVtyoTx5KFxZXtcxAZYE9aKGXq64PVsws7F5d3 +L03OHdXMmiAXE7l5jMoQbAGl87zWbk6eLrV30+XV7vRJKHyXVya4NKCoEu5nyuvNqaP1qSPl9tb2 +sdsaEwfEUDWAhUlrV8vASM0VunuJ4poZny53DvqwsM/P62aVZpM2O04yiUx5dWrzlqn1C1tHb7v/ +g8/LobagTLTnLsbz6wiRx6gSr3Vxpuy1li1JgFQujwBUGIrUjUQ/mgV8WFcjgwCeyOTnnvnM1/XE +5JidUkP19sQx1YD5AmDc1RMLALxrmxcROmVz8iwoq+hkrrpTqB+qD04Umlu7h287evP7GbkSTc72 +5k5PrZydXD5dHxwcrF2Y27m1P3n8oSeey9QAfuPhWDtb3Sy1D1Z7hzpzJyfXL1Z723NLR9eP3QrE +2hpsz25eSNcOSJFBY+r4/O61fO+kYlSj2RYfygcwgxarcnjCzC6amblcY6vQPqDFWtX+SqKyIIbq +itkm+Iwabumxnh7tdWcuJAvrCBWmpUw4OUGLoKyKFg4bPTU8iKSXio2DpfZeKFLVI3VeKWvRXqKw +GMvO56qrtc7m1uErc2tnAS0ZIZ8qr9S6u725E9XObr62nShu8HJzYuLY5OIZX1AjmDikRLG1l61u +xAvLEwtnZ5dvvnD10UZ/z4tGIee16AykvZmYk8PzemKr0j3N8aVAwMDIFMGk4tkpJdKOZme0aDec +HBTqG7xSBxbTIhOcVIilJwv1tURuTlKLBBUDNqz3j0qhViwzA1fLiKV4djZbWzVSUyhTUiLdcns9 +VZxlxUy6sqSa9UR20BjspcvLRrxXbK7ecf9H4FScVOzNHp/ZuFSfPpGprUfTM4xQB0FbLG9sH7o7 +lZ/1I4KsFcqNlYnF45OrJ9tzp6c3rohaW9UnKa4wZsNBHoTiC92FS63ps/HCZry8FbNERT9fmivX +Fzx+0eVVQGlzoY5skfsgkpy10FXKVptrsfQU2HMh1DezK1piLlleCacmHV7B4WJBfWGELshlzZyI +ZRcztY1i+3CudQh8X8johVMDI1HPVGaSxflIdtqItwe9jWc+/Uqpve5DNCPaHsxfHsxf6c9fmFy9 +EM7OVmvLjzz04Yc//iVQKd3ZYzObVzrz58r9YxPLFwYrN6vhibNn7n7fk5820q0xB8OKdSM2k6lu +9BZOrh26vdrfnZre+9Azn8s31yAHKq2tbHUVUm75wNVTFx/dOf1EJLky0duaXTgB6cHLJcWEpJpI +5Fea06eWD91z4MwHahPH19ZPzy4cpISMFmnr8YEYasp6K56dWTl4bfXYfcALergLiUcwSTgDK5XB +fvrQtBdJRZOLjcFhlAiRbEwx6jDFIC0kAyRoq9E+cO2+p/szhzAmVZ88W+wcS5fXByvnC72TUmRR +MqcIKh2OTKNkIoDq4WgnkZudXT+7tHNLe+4EDeqFzjWbB26/56OMkIqlus2JQ83BCUFvw7XFswvx +3CKI0nB8woh1XT4BwXUAZxhUNLM0s3zTqUuPAJivr51e3zrDidlospupLOVqm/35U0fP3Xv7Ax8C +DFldPnLPQx/qLx4HTxQkEmAWwC+ni4erE+dqE6dDZmd9/djJU7dEYxUUJlqrC/pAjc1F00sz63eY +yQU/YmrhNvAplICoAuPX9OScFGqm8nOX73pi6/DN3qAKogslMtn6brKyKZt9lMjxQvXEiTvvuf/p +kN5k+AJkVKy0lqoc6C/eTLBZb0BF8bA3oPgDkqRU9SiU2CZMU6511EyvYFii2zmoGkVPkGbEeDI/ +X25uNXqbtfbyxMwuK2dtLkpS84XKVr66kyqsAYuJRq1YXTxx5u6VQ5eCuJmrrWbqm9H8Yn3qZKq+ +pcUmYZZPnbzj4h0Pq5HKqJ0RFECkgRJuQ9I2Jg9D0Obmj3zp5W93pg6KcmFx9ezBmx6a3r66cODK +7sl7p9avCnLzphO333zLIxiVVPQ2fGm+upkurhYam+3Zk5X+ISFUP3b86tLaCZJLpctLueaWmZyN +pOZKzZ2Vg3e15y/o0anpuVMElxkewwDzBQVsXQ1nK+A1OLmTLiyk0u1KbQElwyIQemwCOJFTapHE +THPyqBJpEWyqPnVK1BskByqihvPFUbdm85m0UI9n1tx+FfRkNN5TjXpzsNObPxbNL+AgJvFMsbhy +5dpTslFMF6cnl8/U+odDiWleKQlqGaXTGJuDUZixQQDTeCWrGA0NqsbshCLNTGEehNPszN784lFQ +PtX25sTiye7cye7s0f7cwWZ3zTDqDz345De+99O13ZudXhUlEhRbgLRJFncSRYj5FE7Er1553yc+ +/WK+MAESrtw5AqVR7p3ozN8ysXwVRCBBgfY6la0s2609xRLJ5XP1A8nCcnvy6J0Pf3pl75IZaxWq +ix6fgrM5TmsSbB7oJlde3z546+rmBV7IVxpL6fIsziaDeJJiK6HwIF3azBTXAohhhGrhaBchIhA6 +NWq5M07pUEzOMFt+RHa4CZqLxDL9zuTe6t6VTH0N/MW4g7U5KYTQMDKk6NV4ZjFV3qr0d6aWz24c +u6YDYXHpQm1JDBV4Lb9x9L7ZjVvyja1cZbXc2gI88SJg6mXJ6KBUDCMjkfQ0pEFjcLA7d6Q1vSOF +qyihGtFaIj+dbaxX+ofz7V1B76FELBprRuJd8AKCXNHNDsukgkFN02rV3m6hvR2Kd0vtA+nKKsWn +oqkJSAZGKrByhVUqKBVx+WR/IHT82O3W7p4RJIhEoNwsncOA0sgG8QRKxiLxVqm+DBSQLy8tbN9W +n7hJjy33p86W+4dFs1mqrZ697QlKzP5zZweCpxmhoSdXSxM3h1OLdreAU9FcaRE8VLq03Jw+1ps/ +t7p1+/L65Xx1O5FbkqTs4WO3NrrrLp8YpBIIESc5wN5ZLTYLgBCKDSg2urN7LpebQsEnitVEdl6P +zQBzhaLT2ep2JNKZnj+RKs5D6gLkkkwSQFKWy6XKYq21QnHJIBpG8Qikt2p0QrFpQWsn80vR5FQ8 +MRmNtFk21env5Zvbotll5dr120qmH4lzYmNm+WbZaHgCIeBHMdSq947U+odqvYPN/mFermeyU6fP +30dRYVaqpmvbUBSV3pHFQ3fOrJ1NgVAkEhcuPzA9v+uyDGkkFJ6j+QxCGi6/CN5KlKssnwdFSgs5 +PtRJFFZyjQNQsNZCTcRkuYwZrtqdhMcnWPuphZqg9XCqSnMgaWp2J42gkmYUjERDj7cTxUWwRaLe +SmTn9EhXkrOV0uzi1rlofpoW87RQ4JWqqvekUN9ILKQqWySfATrOFhbK7e1Se6vU3aXVqp8IX0/X +ST8mJ5OtvRP3bp94oNg+JGqNAArRMMGbW7t+3PLoKOJy0jSTBGrW410l2jZSgyAVAVTpTh+H2aS4 +TCw9U+sfA1Qs1JYVvUSyEZdXsNlpl1sYtyM2B6mb7Xp3r9jcq06c0TPz4IV9iCyp5Xx5IxSeRMk8 +iHaSTyNkuNpaq/W2PYgCF2CYA4yIBVGdEku4WAMMtO5XqFVZq3v8SqG6NbN6SyK7nCvOt/o74eQM +TJyulo4evTWWqNk9rJmey1R3mlNnB/MXQ5FpgisjZEKSC8eP3pZK9QJBI1NYmF48U2vvJLJLiewq +yRZisX5v4jCChsOR7vLW7Z3ps5H4rKK21FCb4oow0nRhjhNTMFMEGQ0nBnq03+ofml45z/Alp4NW +xeT973sqFKp5/SGCyfBSmZeq0eRCe/LkzNJ5UOyZdHdm9QwjFb0B0R8QUEz3+UIejxYMRJCgdW9z +YelMIr/o9oOnlrzBkMcfcnlNiq1ycmvMxty4zwNeW1Z7I6MBa22bVwDlyckVmssJbGZj7Xy0MOlB +pQBhBPEIZLUc6spaiyDDtnEMx6Kq2eND7UgKCmcmiKWBgt0eiSAinJCkaCOR6inhlqA3jdRsubNj +RNqxaOvA9vmZ5WMkF8ZIM5GZ7E4emZg9lbHsxgSv1oNEFOKZyc0BoTM88MX27Orl7vSJzb07V3du +4+R0MdfZO3olU54FunFbjw6tG2vh2Ew8BZ497fKoFJ32I6rLRTFcotDcnFq90J48DPZq+/D9g7mz +iUR/bfWmzuRRViqQXBoCAufxIYYid2kq57IeaLIkHZG0IihqNT4dILMYkwPDDiXAiIUAplNsutLY +i6UsHGZ4S0U4nEwgqAlCwTYWGBlxWygR7mVLa8X6ZgzkNxFD8Eilsd2ZPA6FgFFRkA== + + + AenSRiwzb7VPYWLeAMQ8Fk72GTFHMOnr4j9vxKZL9a3e5EmGK3h9MoqahtmEWoZ6Z/g8aBUwy6o5 +oOm83xciqDgvVzA6i9F5xejVe4dnli9OLt6cq2wAF9gchMfLur20P6gQdEqL9pO5eYiDLOVVrTQ2 +TsIvoXwA1TmxiBNJgkzRdNbvESfay6fP3edH5aEhp8uB40hIAZlktAIB3W6jeDb58r/8YH7uwPh4 +MBiQjCicYd6MLqSy66ncqtUsYhwPhzugo8bGMQisD4QW1B2X5OScFiqtrp3INKY8KIezZijWUCI1 +ToUZScEA/V4pGulpZgu4DCFMiLnHLyOYiZMJXioxVtCi2zsX8rUFJVwjxSzKRDHSkNRsBuyeVgwG +RUXKlmpLhfKcHCr5UXXcSQP8grmLZ1fC8QFUiqjVMpXNifkTIFSy5VnFLPsxsdOd3zt5WVDTw2Mo +QZc4tavofVEuQ3xcPg0kayq/yikpj4cQpWSptd6ZOTq/fq4/f7LW3dIjjWi0durU5cOnbh9zUCiR +5KSGILfM6CTL5P1+zQeTiOkYbsAsQG5zoSYjt3mtly7t5GuHUCrpcNOKlo0meqyQgPGCLqWZDE1n +aDLt96rjIz6nLYAEZYpJKKEGODVQFx6fyotlJdQSlLLTwyXz04nSkp6cJPkkmCZ/QFW1cqWxBfZw +3IbbbATFZKF4Y8npYmUjHB1c3wJDYHgkk18YG0dpLqFHWqXWFh9q4kza7RVdbg54MIgbPkRXwv3G +4GRv9nRr4kgqv0zQBbfPgMjA9bg9lM/Pk3TcTAym1y82ByfN2AzN5+DkASxECSlaSLJCVlGb8eRM +MjUvgIIiIxyXHB1HRkf8bgfu9zAEZrqcrLWY0E5JQu7E0cupSHVsJEDiEcVo01yeZQskmUCxiM1G ++31aOjVLURmayzhchNcPNWuaccvyN2dWs83JTGOiPphfPHBk7ejJ/uqOHC/ScsqMdVS1Zpodkorb +XaTPzxGEJkqpkFkxYjVJz8lmPlXsnL98//z2iVSlRwhRSkqGk9Vqf9Es9T1BHv4+l+2ZkYrdgdAM +IA8oHyFTWCp1DmuJGYSOCnIsVe5piaqWKFFK3EeqpBgOpTLNhYVMdwYTwxhjWrfHmbjbx4+Mulwe +GhI7npmp9/Y4JYYTPCuaarRE8oagJZRIgVGSZqLan1me3dwNpSsBUlOMZijcv75PQRge9owMez1u +LpWZjiVB5ED5qFDIieKSGh2AS0KZpB83UdqIpCu8FncjrBcTaSlVbG7gZMpup0eHvUEvzxAmTUYR +RPN4BaeH9yOaqJS1+ABjM0AcKB7aOXJ+eeeUnqyMuxGnn5eNth6dwMj4yIh/dDRgsxNBJIRiYbvD +6oTgdIksD5TaiaZm9XBfkPK7Ry+sbB/LVCdwNmxzE6AQ5EiVUXMeRKA4M1OZZ8Q8xecgpYGjMTLX +6JwYzJ7XjKbdiUNq0Ww8kuwJapaTC4JckpSirBcLzcVCe8mIV+PpbiIzl84vR2KTtjHixhts+/d7 +SCph6A2Pixra7xgZ9rkcgiiUSuXVTHaJonPj4+TYKIKgKitl9o94h0a9I2NBii2lctvxxBJNZl1O +QdHKopTI55tLywe2to+duXD1voc/8OjTT3/qhc9987vffuutd/72H//57r/9+dUf/fz2ex5tTmzB +tY1fXwNGYJEsaN1sq1YeNDsLg8mFtc3dUzdduP/hD9z54COX7rv/+C1Xzt927fb3feCuux/+8otf +ef6VV9YPHNk6cKpYnQIlgOK6HCqqRoXmo6qaLFe6M3PLaxvbx8+cunzXHe977ANPfvITl+5/8Oxt +91576ImPfe4zL3/ja1//3g+/8q3vfugTn1s5cFxUUwimeLw0jsphoxxP1CTFjKcK/cmF5c3Ds6sH +WpMzU0trcxt7O8fOPPHUR37+2i9++7t3XvrmNy/dfs/E1EYi2fR4eI9T9HkUHDUT8V65vEQQpsNB +8lysO1hr9Jdy1alksZerTx04evHytffd9/Bjz7/00r2PPH77Ax+49sgTWqQCUgrgzu1keCYt8EVJ +rgliHieMcKySzNaLlVajMze3dPDYmauPfvDpJ5566lvf+/6v3nzrK9/69oVbr80tHipXZjgh4/Nr +Xp8EEEQzcVCzcEKXi0fRcCwxqLbXE7luItc6ce6WD33qU49/7KN3vu+B+z/w5B33PHj1rvseeOyD +X/nO9z767LN33Xv/8Qu3sWLG6+U9boaiTEWrRqITklhKJLuhUCEebzaaC9sHT0/Pzhw/ddNNF69c +vv3OF7705T/86S//9t5f/vTen998++2nnvlksTgxMoqOjpJQdOHwVDa76rDzdhse8PECnyaptD+g +BwIKSYVpJppON/f2Tl24cueJ81fvuO+hxz/89JHjN/dnj9W7BwQxa61l/R8ejjK69amNlZ3Tx05f +vXTxQ09+4OWXXvzVG79+5/e/e/3Xv3zzzTf/6x//+N0f/vUr//L1pz/+ya1DN5Wam76AGfCFIuDK +pUQynO6Ahdg9efammy9fvfXxxx9/5Wtf/+q3vvPZL734zLOf+vq3v/3ab3774stf/d53Xv3HP/7x +0tdf/dDHP3/83G2JdC9fnO0MNvLVKc3IZjPlxfm5m8+ffOiBuz72sQ999guf/tb3vvXWu+9+77Wf +f+XVV7//s1/8+c9/+T//9//+5T/gSv7wvZ/+9IHHn2pPbpjRJgAmgYtRI1Urt9fW1uHY2d27evvt +H/7o08+9+PlPfOEzT3/2M8+99OJPXvvZr3/zqz/+++//+3//91u/e/eZj3/qwqU7c/kJkS3QeCZs +9nPF1SBiIH7RUFIA3Hu7h+6489rDjz3+8FMffujJp1762jd//IvXfvr6a3/5+1/++h//+Zvf/u53 +v//9S1/5xu6hS5ncLMcVQ1qH5fJmvGdE6q3m3PLy9pGjJ+9/332PPfXBjz372Rdefvknr//yV799 +67U33/zNO2//+a/v/a//97+hWn/8818//8WvZ4vTDhcDnOh2c05rhaRCkHFFLeayna3tQ/c99OB9 +jz70iS88+9M3fvn6m7/5xg+++/I3v/bWu2+//ft3fvHGa3/685/+v//zv3/37juffeG58xdvTWVa +NA16G3U68UBA5NlYuTg9Pbl+9PCZu+5+4OHHHvvyV1/62a9++d2f/PDr3/327//0x7//13+9/e7b +b739xj/+5z9+8Ztfve+RRzv9tXx5WQk13W5r8fP4GMaSYZ6JhI1SpTIDmqTbmz147NR973/o8899 +/rU3fvXOH/7wte9865dv/uZ//fd///nvf//8i1985PFHb7/zXsNosGyZwdVBa3pzefumoyduu+Xc +vXfd8uSj937za1/893/7HWT0W2//+pe//NEXv/SpW2+9sLa2lsk3zFgbQUy/T6KJEE+phqzXcqVD +B3bvvnb3gw+97+FHHvrUJ5758U9+9MMf/+iVr7386qvf/vNf//qzX73+wovPf/HLX7zltruX1o41 +O8uynImFq/liL5OtJ5Ol+emVrbWNg1ur91w5/y+vfPHrX3/pO9/9+ltv/+ZPf/v7a79587Vf/+rd +d3/7H//5t3f//d1vfv8b9z9yz9L6gUiiLsoZQUrIglkp1OdnV06dPHv82PFjhw7efcfVl156/o03 +fv7mO7/90WuvffO73/jVmz//1z+8/fY7b/zuHSiW17/00otXb7tWbc7hmIGjRkirxhJTJBFjKSOi +peuF2u7m6hPvf+Brr3z51e9/97kvP/+z13763l/+/Pf//Mcbb/38vT/9/vU3fvbCC5967oXPHj55 +XjPLIIcArGS1ZEYbkWh1MDE/Nz1//OixDz312Gc++8kvvPC5L375uZ/94if/8T//61/f+9Nrv37t ++z/42p/f+8Pv/vDuS1995YnHn2y2VwLBEBg3p53yuPiAX+W5dLU8V8x3Du7sPfHBxz/9hU9/7ksv +/PT1n7/3tz+/9/e//eT1n7759hvv/fnf/+2Pv3/tlz/+7W9f+8VrP3jqQ49dufW2VLrBC1GPF4fU +UrWcoedj4fLq4uaDDzz4la9+9aev/ex7P/zOu//69nt/fe/td9/59W/f/Nvf/wLn+eGPvvmTn736 +i9d/9NRTT546f+vawYu8XBgdxbxuyetm0QDndqAkKvU6szedOfu+Bx94/stf/OLLMJtf+MlPv/+f +//M/f//HP/wUyu4XP4GJ+uxzn7x06ebN9T0z3CyVN3Qx3ix3aqV6MZ2dnOotry7OzvQPbM5eu+PU +ww9fueP2UxfPHy0VkyFVoAg6EKCQAO+040475nZiRFCIyvFSvNSptCc67d3tjZ0Da0vzvTOnNu6/ +98wjD95y69Wbb7vjttMXzg1mZs1wSpSyZhS0d9HnYQJeBkc4EmVAuBw/dHZ7+2A2kWzlUoc25m45 +f+SB+y4/8cS173zjS78EuHnz9bd/98tnP//0uZtPTM5O6UZcC+VIsK5BEUEkkTOPHjxz9uzVenOy +XG7MdDtbC1PnTmw/+7H3f/fVV9586413//Wt737/la++/NkvP//RT37kvsceuHRkZ7vVmtLDZY+H +xXHdF5DH7eBrUIeD8LpJhVGK8ejB1cVH7rzllReeffmrz7/04tM//8m//OUvf/jC5z9824VDR7cX +uo1msVjFMNblRClShwNBFThIQmEIPqonGqXWxtzS1dOHn3rs3k9//NF/efnZN9748b/98Z2//u2P +r//8a5985qErl4/VqwUUYZCgSuARpwMkjbVEeXw0iAfkqJaPa+mZiamVxfmTJ4/ecvHcHVcv3nfn +5Rc//8x3vv3yl1749HPPfvgzH3v0y8994tF7bj29t5NNVUhK9foZv5/HUI1mIul0L6Rl8CAbN5K7 +6wfuvvOuZz/x0Y88+YG7b7v1mScf+9EPXn31Oy9/4N7zH33ojmcevffms8d21pf7zV4m02n3dw2z +NTaG2sZJFAn7vLzbgSE+Ohsr7q1t3H3rpS+9+NmXXn7+mY88+tTj9z/37NM/+sEPP/OJT9xz9crW +ylqlVGUpBUVkj1dyOSiXPeD3koifJlBO07LJZLPdmp2bX6c4MRAEbcl4fYzHQwcDIo6HXC5yaL/N +MR5EfBKOqkEfTyIyZR08Q4lRM2uEkkEfGvAFg36MoQSaljk54wkoNgfmdtGotU9Bc7ixkVFwtQgW +FAJeGg3wkgImxWRZRRUUMogIJJWJRoq59NRE79CRY8trq/F4HObR4URtDgRMB0hlt5t3OGmnixKE +hK4XGMbEMIljtIgWBjsa0UKZeDQVTxSKlcHUnKmbyXCkV6/XshmdlVAfA64ZRUM0HTOiHZJJ7tvv +BLWjSkWJTRtirJEtleKpVEhLaKGtpeV+PVdORyZa9USswDIKyxgkmQwGNIcNt48HbWO+8VHP2Kj/ +n52saCoh87lydpCOFEvx3LWrt5w8eKCaig1qlXquMNdpzrcr+UQh6MOHh8ZHhz32cQ== + + + dHi/c3jIbRtHAbsCPpnCTEXMhMFmRTPJeE5g1aA3KDJKwijoUjyfLE00p6daUwrHp8yELkRIRHA5 +qZFxfGSccHsVUSzKcoGmzYCfDfqgcsORcBWKWuDS9cbmwuqFyeljshhFPF5TlNNmQuNDWBAAE4Ms +EqRio3tMDXVtNvKG/2cUhCiGhj1ulkQUFpcjSiQdTibMaCaWB/nOBnEeY1U+qUk5QyuaRsPthkqR +zEhLkCv7bnBAqoyO+pwOPOBlCSLGcZlifnLv2G2egOT2gLZMMmyO4wvgK3E84vXJEAEkYN0rGxpy +wDEy6hsfQxG/RBFRTa0KQp6jEyQVtRpJOQm7E/UjIX8gDDFnyCQaDI3bAm4P6fHxIGxwRPJ5aZeL +wqk4LWZFtSDLWZ+P8PsIEhdRhCdJTZDSAVQB74/hMSilfdbmPi9oXb9fRVEdwzWSMlxu2umkfD7B +bkfdbsLlwnFUA48sCjmKijNsGkFUVYrxgjE8Yh8Z8vg9MkXGgNZJOqeZUziRHhvDQAP7fdz4WGB8 +xOu2+Z3jXue4J+ilQnKWZ3QCFQg05HZL4L5tduqfW8udDh5FTJ9HsI+hLmunEm93Ch6/7nRLwHEE +YeRz3b2dE+l4wTHm5DFZIMI8YZAwHMCoIffYaBALhsdGAzfeMDo64sMQ3eGg4YCS9/oVuB4GMj/c +CQZVuCpVK6ez85pWM9UCGVT8HsbvpiY7GwxpANzBqRAii7MVhq9KcgXFI26f5IWKvt78VlZbqjmZ +yG5kimvNiZNaeMJmA47jC+lu0C/tu9E2bnW0kDSlMZg80WgfxonU0H7v+Igvn5pAEX3/kBdm0+lk +kEBIliqp9FwsOumyU6NDbswPpMk77KTPI/l9IQSNgWuGr9P03vBwYGTUMzrmHhv3jI95/eBbiThj +3bieJIh4IgpaaIrlMzSTCQYNBI0Q1rJ2NYCEPX513z7b0JATvtRuo3DEZKkUy2Yg/Yq5hXJtc3jE +PzLigUknmZSkdgS5DqcN+GWeNhv1eZpLjY76x8Z8NlvA75fiqcVQdFJUazQdTyQqupnz+lj4rMMB +gBnyBSK82Mjkd4MwEWNBnweMdBNO5XCSNjsKWecPhnixIPBlm9UYjQAoQxANEDIYDEHE3G4Bx2Ja +qE4wsdExn9eryHJDUWsEmfQGTJzKO1zS2DgO6ed0EvusnQtO+5jfNuZ32lEc1aHcggEVQNLlEm+8 +3u7D45F9PtPjsXoOEETSHzAcdpAKmi8QsjrpjZFjdg5iZYTb8XQ/iGow0vFRP4kYkIFD+5xD1l51 +DMy7z6uGQwO/1xgbQ+Cw2bDhIY/NTkKErQUGWCxkDPTIrMer0HRYM2o4nYDcdo6TI9b69gAWCFUL +qwwVGRvxUUSYYotub8jpVlxWt6iMok+IasvnD2GYDial0joUTS2gWBIjUk6XNDoaUIRMv3cECej7 +97kwIkaSKZ7JaHIxGAiBet9/o8Ntx+anD+F4dGycxIl4AI3gZFpWOqnsGs9XbWOkfZwIBhQojdER +r9/Lk0ScFWqs0JC1HssVrRaUAVkQo7QYGx0P2B2M1QWUL4mhuhmdqHd3k7lpio2zYp5mc4rekvUu +weQ9gbDz+v5WKHaP9/oe/6EgjkZRNBoI6gKfl9Ta8EjASoOAiJJR2ejgXM7hEeDHRLS8vHqMV8pj +EEOfhKCQ6jp4Ipgat5sFfjy4c3J2aRdSKwCwhicoKkeSWY6vCFILsp2lo3qo5POxw8MemItgUCGo +OCfVzPisog0wNJZKToaMGozFomAPhyA6AAvHFaAS/X6NQvVKcZ6kkzCDY6PI+Bjl9Zlur+H2aEak +D6Jr/5AbHAoB1O8g3C4y4JfGYdKtFpEhkkwDCLg9cFVxJBj1+kIjYwG7kwlgKVXvprIzDJ91ugSr +v5nP8PhCIO9JKg7VMTpGsEyBIpL7brAN7QP9oSlKj+MqPq9u9V4eJcBNsEwcrsfvlZwuznV9IYrX +p1otTRCITHh69mi1tRTEdLhymsqSeILEkwSe9Ho1+BSwqt/LuVwAm9ZibF8wFk+vLW7cU2rsuX0a +BIHl0whqNUwL+OPWBiutpofKklAS+BKORVxOaw2q3Ups58iwb2wkODxkMZHXw2taOYiYkKssl7GD +/HACxfDW1rN98JeI3x8K+EM3/I9RuAAsKGOoMTbOjo7zI2PsvqHg/mEUZOTO1rnZ9TMjdtzm4kiu +Kpkz0fx6urIZik+yQn6itXbiwr1BKmL3sHY37w1Eg2iS5RqqMW93K4AJfq9y3VDIFJWiqRSGQUCi +QSwGSIKRGsVHcTaFUHFKKAhaGaPiJJeTjX40tcJLVYBuhksEMGsjmAxSRymghO5HNWBeHLcwamjY +PTTsdTgZSD+aTol8niSBbTHgFIBo4HHAdrcv5EdTBF1lhaoglkW5CsMMh6seL2uzIXAqwBAMTxBk +yghVD2ydY7nkyGhgfBwJBkyCyNB0gWaKGJmE0IHtPXb0cjLdtVJ3HPF7BNBUHF+CMvR6JABVUSnj +ZHh41Dc6FrQ7CI9PxMiEHGoEUJ1mU3OrpyW9duN+9403utwuEUHDGBZTtXo0NuF2CeMjAQLRKCax +f8h//QjA4fdHNK0VCXc4PiOIBY9PGh3HHC7G7RUxPAlfXaxtT62cpznIMbHV2SjVNgMBfdxGjY7i +tnHK5xVJXAfGHBn24kQ0npqPpuaDWNzafuVVWaWWq+91Zk4KcgnAiqAKEHOKSbtctMfNOGzk9Y1+ +GvD7CKg+O2ltMHELSFAP+BS3kxu3+k7QXn9oeeW8ImVvvNE+OooCiipSC0fTGJr0eIAu/S4nCycc +2m932DHQKlAUHp/GyjWQKMlkTw1XxsAfBbUgGcfYTCgxTQoFlIorWnVz4+ZTVx4OkmEENyWtboan +IuGpRGJOMnrD4wRNRKf7h0SptH8/wAgJmYyhiZDeHcyeK9W3YrHa0RNXaalA8plYdjpdWcvWNgrN +nXz7sBDqYFQsEak//thHB4uHoST9ftHnl/1Bg2aLkdg8L9ZdVjd4DUDDbzXPSaF4JohlCLKghXqa +2XV7hdFRL2KtCLJ2Z/iCBorF4aDprCAWc4UlQciaRkUPdwKIwQkl2ehySi1IJt1+ze1V4WpBNV3f +hKvSbN4I92gyCUJR0/MBRA4GZJIIQ145HWwgaOBEDOQTSkQJJs0IOaBgqGK7nQD1bhvHKDJBMynV +aNWmTiJMetRmdckAkAwiGmgzSD+3VwbGoUBtIlDa6I37PEPDAUgPr0cjiALP10Cf8GKVE8okk0GI +GMVlQdx6rcZTYYbL8UrF7eJ4OnLl8gOilAbQGB0N+nwK0DFFxnHcBK3lcrEsk2KYBEGE4WLi6alU +eVkwW3pyihEKGBEN6Q0UDY+OILZx2u8zMCzFsXWBb3s8xriNxRAzEumC8gEtDeMaGfYPD/nh8nA8 +FzL7yfQ8WAwb2BZrNxkX8IWsTWF2wes3eKkSjg9A04p8UtXidoff7sScLtZqIBO0HrwCbbl8IiMV +MDbpRXU9MSWZvUhiptU71po8HS8ssGwymeybiR5BQiVqQVQB3B6x4XDOWnWdl6w+OcGATlrRi4li +oVBZjSQnstnJk2fvpuUco2SL7c364Ehj6kiusZkqr5NcnmRi/fbyS1/65vGb7/L4BRTReL4giLV4 +ciVbOMBwFUWpWUWKhK2NwGiaFduKORvP7tS6N5nJeR/4TUTR9VoAMR1uwQ4OFI/wUgk0G8lkVbNb +qSxevfWR6aWbXB7wPgUjMa3FZjitq5rTZnQBlInHJ5Ns9noXHdPa4+AJuexW6wCfV07G+6KYh9y2 +2WgSj2hqmeZynFSVQs1SfTNdXAliptsDqIjZbQToOkmtxHILmcYeKVZYuSppHdBvDgduPSs0mvDB +cGw6npiFVBmy2rkH4VsAARwOsCp5lisxXJFirYY2tFDm1RYjVaGQ7deb4aN4AkYkq2XTqE1ObKCo +DPkMYCXwIBVSkGCjY8jwsJfnshybhG+02xCaNBOpbiTVI/msFu7TfIlmciG9RdEpq5OV1TU3EQiG +r3cD0BxWE7m4LJbTqWngBZ9XCgRUJ/D4CEISKQxPkXQGYB8wDWjF4xVvuGFs2Oq0A+IqxXF5US7B +2IFwI+EW+PLhYbvdDkwhwqS4APPRKHglMzZT6RwNRXpmcsCH6pLZliPdSGZWDLVBXQyqK/ff9dTE +4lHQ52BeAmBS/KoglVW9pWgtu5PyOCkMi7rc4tgY4fXxINTDiUGqsJzILxC0qWjZam/TWmws5ay9 +BtF+prjc7OxOzZ3cOXqNEWJ+hNf1htU3VSjDVQUgbfCwEe1Hc3Munzw6hoWjc42J083pk5HsAskW +/FjcEwAsKmQLC6JWJdg0xaVZAeRrTTEbwONqtBHNdOrdlWh2gGFKo7U+tXKx0j/BSA1ObsLhcEv9 +zuat1z6YyQ/G7SToTwQtoWgxkVjOFg7GkguWiuMySqgKMmYchKiTMuJTMwtnT55/pNTcQfDI2trJ +mdkjUOMcn8pWl4vdvVLvyOTSpZXdB/PVw6BCScoUlDxGR0HFAW9iVM5hNb4QHU7a2h4+hvp8QP26 +x2tt4QwSKVZtxcpbenolSKSDmKZoZU4qAo5RbIaXCrLRyJSXtXALNAxgC1gzu532WCscaL9f9vnV +sXHMbgd3rDhsQQ94aiIMLK9HB+HkHMmVCKYgh/rl1pF0ftPhFIaH/UEkRrMljEjzQgmxpHKMpCFV +yoCEJBmz26ynmVbHHh+YuzTD5HWjDQb2hhtGbWPI+GhwbCQAUAbOgmHBiadpJk/gMZcDOFpwWHiO +gMwjmTQnllKFxWR+aWry6O3XPmzG2jSfydW2o2mYuFa7d6Q3OJ6pbDh80tgYSlIJEngTMQW+SNJp +K53GIaUzmcIsRkZhvDyfUc2WER8kistaZEJRSpMTB67e+xGPX4IQJfMrBavwlwqNrXx9K5ycCSCa +JAEltewOsPYkhkchwWKpxcUDt7ZmTvhR0+mgcDLiCWh2FzdmJwBkeKWZKm4vbtwWjvXMaDdVnEMp +c8yOILihR9tzGzdduffJM1ce6c4dZ+VcOlbZOXhJCTdG7RRCxhO52WRhgVPaqfxyf/qAEsq7PWqm +tGNEZwkqJ0oNXq55/AoQbrG8VGttwlWBAQeJLmk1OVRnpYLDI3r9Sm/mULYy70UlI9rszh6ZXDvd +nNoptbejmTlWLjBM9OOfeun85XsRQgNxaETni50TueZhSe3Z7CzMUbe1urVz5cZ9YFpDgtZN1Q80 +Fs62Fy+E86seNBLSy09/4osHds+P20hwtXpkUOke2znxYGvitNU4btglsFGKSoyMoeN2CjKW5qqc +1AJ3BjbB46IIXCepmC+gQRUXWnv1qZMLu3etHL6/PXWKYfP79we6vT3d7DqsVqsofAVEAGiiPX02 +nl70WN0/BNCrHAveRwFnAXrM4TFA0AZQqws3qPch0D+jKBY0An6VwOMgs4OBCHCl3w== + + + B3peB/DEcRWm0gnJ6ZNQ0gSPE0lOFRurKBVmxUKxtZepHoikl5q9o2Z8xmqHa6cwRBGljD8IkZdc +VgNP0WbjvN6wCpZTKABgCmzGCFcDqOQLiteXgaXz1fX+wk2D1Qssk+h2N0uN1SBpgPqKZmb1+CQt +VPKVjXrvsBmfAJXCcoVkZj4cm4jEB3q8z0g1PxJlWajc+NCIf/9IwOfXUpn5RHY5nl8zEzM4GQOw +ypYXBK3kC2qCXAECqjZXDp+87czFBxY2bqKEVKuxcNu1x5JZq7N3rrx1+PT773jos1Nbd4nmFELG +YGpoMp3JLdmtPm9Y0OoTaLg8EorHNLNv9QewOnKzwWDY7RH8iImQSUlvmvHpdHlFNeuN9uLhE1dV +vY5TkSAm42wa47KsnM9Xlw6duS+Vn7RujyB6vX8SaFTWWw6X5HBxgYCSSU50ujtAiwgSpvg8LeQo +vqiYk0p0Ilma788fv3Dtg93Zo8OjRBCLhiIDSWsTdBo81MgIBZAiiwVByNy4z+lw85I+iCTXZX2g +6BMgh8Brk5QFlUFU3zx85dwdj64fuXWwdN5IzALUj4yB96Gv3PnRbHERpGYwGNWMbiAYo+h8KrcI +3hbqyOflcrmByKfANt4IHnCMJPlaOLsRy20ksmsYmvb7dEVpBP3G8H7X6Ah2vQkqAV4SRJHLZe0A +6g42Qc3CtVmDRUOQG2p0RjSshcGQWqJRx60lamlB7bIy4FgZR8MsFSEJE1IIAwhFUiRRgiOIZIJo +CmDW6WQrxaVUfmB11RtHwAtzYrXYOFAfHM3WFg0td+H8A/MrJ72IHM/OLmxenV65XG4dHsydnVg8 +JxmtMRuhhppgdYNAuEEJQopTRVHuQj5wcnEYQNh69004ZDRJNoNSSYoroGSal63dkRSfpfmcEenR +bFLgE/XOemvqcGPqUL6+uLB6ZnL+uBKqGZF2rbNb7x5oT+1o8QkPErPaPruFiNHO5hZHx4mRUYzl +S4oxIWsd0EucUANA9rhFgoj5rRaUGM0VIsnZ7tyZSudIPDOrKPndvTPv/+AngTchhghqiGq31Ng9 +eOLec7c/1Z47Banr8nLRVCcU63sD2vWXDeHjDjaIhMGYBIKmx8OzfDZg9SXG3V6NFRvx7OLOiTvu +euTTZ+98OlZctblEhs9BKLyBEMwUsBiGpgShxvE1MDhDwz6AJj06S1qd4SUwQTB3QNYyiHY8DAgw +Mb3bHWwlMpNmYpYWWwRXovgyUEln5gJCpOwOQQtPilrN6q5gZz1ezepvP4wEglq+uBTwS/tvHN13 +w5gbImBtgp5ipXoAjQyN0C6vAa5qbNS6A+Z0CC6X7HLL4KEQJGK10cYi6fIyhYUz6QkMN20OEoYQ +y61rsQVJ78eL61BHwLaidZ+qgdNZGB1ofoBKl5NzOXmvWwLbAmH3uATQpZDq19sScrredFntqnww +ETYnC1dC83nRemVGJRKt11sbIb3OsqnJ+ZPTq2ervW01UqPYKEqG/Yjh86mKUsFR3e1iQBlK6mQ6 +f7DSPDm5cDloNX+maSoRMlsgjZxuFuy5HyyD2tWMPqhfVsi1e5uN5hpJ6FhQyhVmlrZvOXT2gaNn +77t630er3T1BKF88de3eBz7Iy9kAqgfwOA2WIbPSnjg5u3gRQdP7hvzDgCF4UgtPKFDISBSq2z5O +gdgGL+ax3nkkyqGWarRlUHdUEsNjAp/NFecG62dJvuDxqMXSZqN1Ip1dnFk4Obd2lhELLjcf0gp3 +P/yMGumNjJBen8EKoMn7JFN0exWQ+kAfRqQLDs7hojm+EE3OJnIL3enDJ26+b2XnEiNXdL116vQd +4Ps8PkXV2/HUbDq7lMyssHzTeh+Wg6TICAgt4LXhEdDPoVRhpdrfSxaWQKEhqBaLt11u1uFiILWg +CDaO3TdYvVybPEGw+X37g1gwcvymB0k+BYwACe/2hX2BhKROZIs7udLesHWPy+l2EQQZGR4JXH+5 +m+AFt04XtfAMJzbgGx02NBiUwCY77EwAiRA0+Nn63Pq5k1ce9cCImGQgEAoErNVritFSwn09uWik +VzAmg2ORQn6eZsF6yxzgPJcTxBLPA1KlvB4JvP/QkGN42DM05Bmzup0T11uWCV63iqNRDAm5XRTP +52S9HstMxXKzpfaOHpsALxyJ9YxoBadVktFI2uD5NCdkVa0RDk/6QNa6OZowETTkdFEgUFkmTZBW +iz+/32CoLDhr8ERQ7F6fBOAJhDVuY4CaWa6YTM+qeg1FVQJTQ2ZeDedixX5jemdi4USxspzPz69v +nMtXZgg6Go71s5UtXmtFUnPp0qZizPj9iUAgIkkljs+AuHKCN7Qz18VDiCJS4C8oqoAiJqjr4VHX +viG7zyfpRjcSmy9Udhd3bgcNpiqFzQMXjcQA4Mvl5nzXN3dQVCYc6ZUa6yPj1NgowTElQEW7kxka +8cHhdHMsnw+ZXQRS3c9D6ZFk1O3mQch5gorPWgWabXUOzSycAM8liNlGZ5ei016P6LDRtuvNvR12 +kqIiLheF4rrXHyKprB7ui3AxZpsRS6xcbvV3OSHHsPFmZ73W24bfIFTGEwx5A6ooV80YOO51q9EQ +GECtacbmjch8IrcsKk27Q4Xcc9jpdmNpZnrbahM3hnp8KqfUEqW1cvuQHOoMDQeNUDWb7YyN+vbv +cwIagDAIR7uinIdCcNppr1eDg+NzrJinmAT4slRpI5Ffbw7OpIobWqTjQyQtVGm092StFkQjLncI +TKvLelkeabPh4+PY2Dj6z/cy/LMbHo4mEX+YCIajofL8whGciTJCqjl96OiFDxy75fH2wlklOkky +CV3JLM/tLCyclpSKxye4PHzAetpookgobFRRRHG7CVXOyGIGDAuKJfzBpMOpXk9gzGk9syNGRgAb +UUBRcDe8UOe4KvgIP6KyXKLWWZpeOLC8fWb98OWNvUu7x2+fXjqdrm2gVLRcmtneOsfyca+f56W8 +pDQppiopPQRJeL0qcDGYa79XCfgNBIkjgYgXJJZPgiCzdJqXijQblZVsEFUxIoJTKYxKcUpFM2q1 ++vKJ03eJakkQc+AsaDYrqeVobFpV2xSdBTEcCdfLxQWH1Qfba3dwPr8hiFWWL7JcHsfCul4B1IV/ +BR0FljyRWWoNjnVnj2/u3QH/D7Xfbq+ubZ3/Z3O5YEBFraU4VMAnMkwMQ9RiZZYXMwBikHhQboJa +ixWWG3Nn13bujMX766vHvvqtH4ejfZtdopgaeIp8ee38lcfO3PKEGOrtH0Kgani+AN8CZTVq9Rik +HQ5NVnohcyArlYBfBuHkdrFuN+dwsXY3N2rnx6wXeSia3uKlrNNNgYl2OAibDbVZa89YxFrOAbwf +w6ksr4AzqoDhypaXItnJWG4u3zxgpucFow0KudXe2Thwp2o07FYLbqv5CUNlUDTq86pAiMCSVmdy +6+VolDV2j+Zzy1hACxvFdn9Fj9SrjaWFA+eztflsbSmaX2SUFkomzVB5a+3M8uoV5PpLNNweliAS +HF+mmLQoFgkyLgqZXG4Sx3Xw2j5AD7rCsDWSzjmuN3+2ZsFOQo0DrVx/Gi74/DrFJnglD/Nbqy99 +5KPPP/fK96YWj8JvADaj6Zn24HC5vj7R3V2YO6xpWU0tKGpFkiuK1sKJnMMuDQ9Zr1gaHQlAarmc +7Lj1DMs3POQeH0Ps4xiGGKFQs9vbXVg5ZXfRoGoC1ov5DEGrpPIrmeK6EmpguNHtbpQqi16rSz+H +YaBIrUdgYMyz6X4xPzU67B8bQTA0Av4uGNDGx0mXC2pKYZiUbjYgMazbg0RSlIvR1EAxGpxQYPky +QHe3sz6Y3LXbGbgMiowCk3pcXNAvkbgZDMjRWJMBjzziRQKgeUxOLMhGUwMAkYoYqmZTtbNnbwd4 +ZLharrCXL+3qeieZHETjPZzKgAiXuGwhOwVlNTTsuf7OgiQvTCws3zW/foeoNEZHcbAMwOxeN3Pj +Pvs+6yUanNOl43gWDBdKRQKY5vHy+/c7/wluNJeJ5xfA9IHXjuVWwskFis0nM9NGvOkjZCVSL3UO +tCePbR26dubS4xfv+Mju8fsYPs1yKZAZgQC4ztC4DR8e9o6NBjxuQFSapJIuq08OA1TidXMEqqKY +ImipZnf1+Nlrg6VDPvgRyDG3XGocBtRVtKoZaQtKzeWVCCaJkRF/QAVIp5gCL1Qr9Z1GB6x622bn +UGAWGlC9TJA5jzdkcyo2l3L9BX8ihoehVN1uBurF6+PMaGNp/fT6zoVSY2lp7fju8VvUcInh4ma8 +p4WbyxtnOoNDKB4JBEVVTa2unshkevApcNBeb8i6lxiI0VQq4FP9XmlsNDhuNcqzmj3CGMfHgiAJ +ItF+IjUdTw4EMbW5dbHZOYBQYS5ULXWPNqfOJPLLmt5cWD5dqS0DTEFAYompWGxK4AtAjg4nNTrq +v/EGu9vBIAELk4eGHaOjiN+nBgIq6CWH9cSEJ7CY0/Kqfn8Q+DQFOiFfWgmFrKdXcD0kHlXlgtXD +bdgHcOp18xii46j1jNs2HnQ5MBIznE4AdnR0HAM5IXIJgQ2LQoJhEpFY55bbHts5dNXrUzEswfNl +4PR0fhkULI6IDKVf7/yM4XjMuh3KFDmmYJigwxMOGyHy0bBeAoVzw412r9+iOVA+Y9absFCbnXB7 +BeCd0RGf3Y6BUAGUA0fj9SmU5bbiGBmj+QKUXq6yqhn53aOX5tduqtTWuoO9ufWb+gsn47l5hkv/ +/yS993dl13kl+A+MyAoIL6ebc873vpxzxMNDzhkFFFCoKqByjiwWWQwiixRFUaJEUVSgkiVbwUGW +rFa0pGlZtnu67XHbnjU9PWvN6p41v825pbWwsApAvffuPWd/+9v7nnO+L5sbyFrx2c4cGYzAyRPu +jiMMdiuDqSqwLblaYzOGmCMjsUiYI+lUpjy/fe7huZtvdsZ3b99+/e7j98xkHyWSOJnFiDQn1qzE +TLVz1Ju/baSmGDbVaG7l62ua3RHVBhDSXp9b31hR+sB9HDsRPHY8eHIEw5kaI4+hZOFZmT6BprKZ +wgJB2UBPpjJj+wc33/7Ml85efpiuLmiJAcOX1rbvLG3dEPUShCm61esNTperi4bRyGZ7gpAA0wGc +L0GmgZ7x+d0eo273nLDqVm9AgDFUThx3WSvop0ShqGo9ki6jWNqyqsurZ5PpNsFYVro/tXZ1/cyD +7uxRuXdW0LvBkJhPTVy49gpC6qNeJORuTgY23y2g5xulobAqsbmZyZ31zWvHjwePH/OC9wdJULMH +YEBQLAG4q1KeXd24CrxwDNIJCoRznCTjKKRqGmD1OKBxhjB5IRvwk36/u3PGM4KCT4mEhVhEHB4K +QDGOYeLADQGkFUoTC+vnZ5YO47n5WmsLMBXDZuZXr5BkJhAQ3Pr/XtrvZaMxk5MaJJUCMTUyHAVM +CHAbDQs4amIw0D8o+NCRoRiQwQwdP/a859jzI88/N3LiuA+gGuRoicvSuFGrziaAcQ== + + + 8GGymA1HJZrL8VrTiAOlvdQaHNY7WwuDtT//q1/unL0NPKOo1FKFGTs1CW5cNSdxJhOOCgzpLC9d +ghBz6KR/dCQQ8CN+HwGYEKhKoGZ5IcUJGQS1Ga6oxbv17mpv8lS5Mn3/3ku3Hr5uJJoEm09mVxKp +xVprb2n70dTC1fHp85rZTTrd0/s3BS0ZgoG1tGJwGuQpWe3xUicc1X0BDpgy4FBG/eKo2wgMBRYJ ++Cw7MWc4U8Cs7e3eGBvfENWikRjLVtbrvbPTSzd3z758+eH7tf5Oo7187tIDMzWlWy1ZrVN0Bvhi +oIoBH8pSOxwVvT434qIxQxS6qjoODD4EWT6vW5OZoXIeDyCZKBCZsVjSrZ8ZVdzlIS6vWU1aSJNM +HIxVFHZEtTm/fHkweRpgo1KbxGmTE5KGXgu6kyiFQlrAL4YDKoE49fJir7t14tlDJBiWgB6AsTgl +VCihDEKvP749ObXL8TmWBYmyoupVQSxQVFzW3MpIOGZXChNgHn0+1OtBAKIwGASCEQkJ3hEMcJpl +lFNJ9zwOS1q9iY3d83d2jx4bqTmcLsXgxMrKhT/74U8KmT4QkD4vSZEpgasJQpsTGqGwCGSGLBXG +pg4su+n3YQBO3mE06COhiIBEJVXMEIQOiJ2hsqMjbpXdEyeAm2DgqBry8VBEA6k/7nQfPv5UIEhh +hEXxWUFvmpmpdHkpW5xanD319rtf6Q02QaJvdE6BtOikpwG0KB4kLyAhGFstv/b6VwWj+vzzQydP +eIZOhkbBHflokFlYyhmrTx1eui8blShQBUKBkXJmop0qDFoT66X2AsEmnMx4sbEpyA3D6hvOgObz +ilbnhYpljlUbS6KWSuQagtoIhlWQFGDM8AVF4HxJMieITeBwETw16uePn4wB0RWBLVnvUmyeY7Ob +61d6/XVZr9jpyUpntzdztLR56+zFxxPLh052YmZu70vf+gvF7gJ1BKiMEytWoq8aE4I4Jik9GDUk +uVRvbfFiyX1KE5D/WBEUfOF4lmbKI+5yNj40HAUYC4UlcBmsWE9kF5pjZyQNzEt6ML5dLC9STKbb +3xifOsUBlxSVUNwBDkjgCz4vC9QgeNtwWI+EtIifA1ke0MXwEKaqNUnO+0AW81Ci1unOXsw3NlWr +G0PtKKQ3WitWvI5gFkakLGc8U5g37YHAg/xoAkQF/BRJmMEAFXAX2sxoRPa62yEk8tnJNZArRSEP +3txKdmdWr6zu3t3Yvbdz5uHOwf1Bf57CgS3VSCLh7u0Muz2bMCzl7tbAHNNoF4oLpl4NeHE4ImGQ +EfSSaEzBIDUcID0jMEnkLGs6AlIeqbkNpI7HQn7e7wP6JA2EK8+XHLuBoCpB2iiuc0IunpucWDi/ +fXBn++DhxNoVhHQpd2LuiFNrGIgUKoviKZLOMUwa6PPB5AZwjseeHw14iGhIDfrBbdKhIBOLMJV8 +Y/vMFUpKhmHNyc0pVhu8c2NqL9PaoqWyIGQuHN5d374ClBUMA94o2PGpqZnzi0uX4skpXqo0K+Of +/dxHrfHTzz/n83ixEGASyLad8UZrVzXHI1F5c/ummegcH4qMeokIyDKoW7NOUGrx9KBcnl5bOzuz +dC6KKrwKhrSj23VBK1SaS/uHL1y48ylKAEl/Pl9fx5lCDDYRPBGOmaGou66dyc9ni/ORmHByKEaS +KdNwPSMci4dC+tAwNTxCRKLiyZFQIEQiqKHbg3hhudDYLja3gWvOpfpP3/ro3JUnwZCgmnUnOzBS +A9XqAd6OQWokIkhipdM7QzOlkRHCfV7tPhtkTpyIInBC07oT45v3Hj6l2SJQkrLe4tVWFE0DnZkt +r6/svqA7rdm507fvv9Ue2w6GZHd7ZNRyC+8jNo67633RMEtiBhDSgaBbIntoGPcFxAhka9ZUubaZ +SHYGE1urp2+fufbqmWuvbJ+/r8d7oZjCcJlyfaU9OA0AIKsl4HYxPImgLlH7PEzAxwW8FKCpYmZa +lavHnvMMD0XDITbkrhczoRBQhiJN5zZ2bgZD0ic+4R8exoFOFuWObg3AfB07FgmG2BgsQ6hM0I5o +VMrdrZnNm+3pi5ze57Sqk50qtTdRPG4YvURm3snMJnNLstWBCXPU5xZEDfq5SJD3eQjAiidOhgES +IFiNIXowKvnDrKSXZaeKsVaiMDG5cqXYXC/WV5pjO9UWMFMFoJ8h9wBLgQXuG4/jRJxmU7yY7bQX +rl5/0bBbJ44HMMxS9SYvlmOw9axqXxwlnFR2guLTgEC8PiAgQWKyBLkM0AtEYCnf2dw805tYhRA5 +X12e37y7c+6Vrb0Hkwtn+zP7drqfdFrvf/SdR2992W0uhtj1zu7C6r1SZb9U2dPMfjgqj3rgZKLJ +CzkwR8dPuEWeRz1iMGyhRD6Znrx+58m9x28D0+oNsMGYAuEJXqnV2+vNzn6lcw5l8gB16fIc4GqE +cHAyg+LJKAS4V+8Mzolaw+OnYdQCfvyZilMBhgEBAsmK43q2MA5kVTAo8kq12Fhvjx+snbo5s3QB +aE5JTN299fg7P/hRu7fo9XE0XQIsyrJVGHHAtAaCPMfmcNweBS47zHHPxooRKqXWzvLuC/nS/Pry +/hc//PrS2uHC1rW1cy92Fq62Zy8u7jzcOH1re+9mqbFSqc798K9//fpbX0QRTRFLktQADEYTSVNv +qWItGtaOH4eBYwVCaOik65ePPec9eTziGkkoKWk9Qa7nC3OSUqb5gqi3ObUpGj3VmQyGBV7OpwuT +7f62pFcKjdWx+aO5rZtz23cn1m7lWjuy3U/GBxcOX9o5c5/i8zRXLtQ3MuU1QZth+fFIxPJ4CGCj +/H4QL9TIs21sETBruAMcX6ownSxOVJqzm2dubx3cObz+0uLWlWJrg5ZqCB4HQoXlChCkBINUJKqx +XLXZ3etPHiWzcxQHJDoXA3knJgNjBYIRB2wptDRzPplZFpQqmFl/kMFJOxBk/AGSYhKy3kjnp0q1 +OfBdNeoUZZXqS63+TrO3kchMZ8uLucqCotcSTuPM2euLGwcwqsVTk/naQjw7rpgdRqgFQhIIDSQm +nj24VSrNgPzl9fKRSDwWS8egdDhqZnOTN2+/MpjcGh1FSTpjpKaTpZXe9NG1e59+8c2P57ceokS2 +XZ87d3iHE1IAY7niytj09eml+5XWBd3uRyEZislXLj2q1tfcPcweErhpCIkDh54sLFZ7+8CqdFpL +k1PbgM9xIsmIZU6u5YtzkwsXat3dRKoPaDOfH8hqZcTt3ot4PBRO5SW1qxv9cFjx+ShRqZRbW5xY +AmqcZFK0kIUQVVXLpcqsKOfGZ88eXH293t/NlGZ5uQiukCLjptU8e/HFtz77jYWVi8BYqVqfpgvh +kBgJUd4ReGTILWg/PEQZ1jiYiOeeGx06GfOMEgEvsAwGyZTB9cdiuqbUQDpGiUR1bHfz8MnZm++M +L14F1qPaWl/fuXv1ztvTs2eu33tzdv1Cqjo9vnQEFFO8vGYlQYq5eeXG06nFI0GtG85EqbmeKy/L +1hSMpf/YbWHoZBRDLRTVQ+5OWgrFbUYocFLJyU4mcoOd/VtX778RL/QLzfnONIjuU5nKWr17bjB7 +I19Zj6EajKq8XCW5vGJ0NGdS1Ce0+BwrtTEsHXHX3WicTOBMPgRZMJ5zS9FSmYDb2iCu6TXYfbJK +PDt4Pt6ZOD+5eKnQ2KS4kiDmehPbmeIAp6xEfnZ2/frRjafb519KluZVu45RKsvaC0uHsp5DCJWV +SyRXdGmTSZGYXSpM2HYT6MaQWxXfbc4CCDMSNeLJQbm6wLDuqQQMA4q9LqoVSS2Vm4tz65czlSUY +s7aXz7z+xmctq4TjVnvsXKt/vlTdMJ1pv/t8BgMW7+a1l9qdtWG3yaxbQ1XWe+nCSqN/ttzeoan4 +vTsvX7l+z+vDQKzlKuvTq7eu3H/v3K1344XVSMzAUPVLH31je/uiPyT+scOIakw6qWWKLg0Pw7Go +2O1tFutrox4iElEg2N1vwEkVOzltxAc8n7l17/XHr33OcboxSBOkqpWYKFSW105dv/7w0/3pI5qr +kmRWlJpBt3l0+PnnPeA2vR4asCtOFIJB/fixYCwiZFITwE6ODgP7wMQgB6TFQFChySzQdWD0ZKNZ +aW02evskV5WVYrt/ujt1AFLG+cO7L7/5fmuwYab7h9c+effJR5tnX11YvfPq02/Or99W9HYpN7t7 +5gU73fUF2VBEBWqNY+KxKBdwuxHJSaveH9viuHQoxEKIxsvlXH2t0t+dXbs6sXykOfXlzaOxuYNc +cy3bWDfSM7zWoMSiYDZztRUjPYjiBsamIXB3Rj9V3YbZaiBiIWSOVRtOdhZnsqxaYdQmzlRYoUoy +RZJ27W0oLIDQIygbo3QA+MXtB4s7D/pzl2q93WxlGUx9PNHaOLhj5waJ/NT8qfu51inZGZP0GnCs +K6uHCCYHgnSmsKSaYwyT0/QmBJnBIEeStmE2GbZ47Fh4yF2bE1k+XayuqUY7EtECPsa2WggCXouG +w1SttXT74Vt3Hjxd3LiczU1pejUSYVBY4rkscFsjbi9gmqQS5dpSuTyfTPb9fvLEiRBwPRDk1jDB +CZPlMjhpkbhWLQ90IzsyEgHafnb9ytbho4nF88n8HE4Vo1GDZeKffOvTc/N7/pA06qHcwjJuewj3 +CQyQcxiqV2tzqlZ5/jk/8KEEnpaUhqi2Ra3rrqpb9ZeevHn/haccB7JnanL2emv8fK68CMjQio/D +cNzrHgFg250dAneGhxEUdli2RlNZArOhmHH8eCToJ8a7yx98+KeeEeQkQJ2XBopCVjtOfCbh9FhS +n5haF6UsyFkkU+e0Po6JlcZia3y3O7nbHNtI5Sc1o1Zvrqzu3VreudCd3MgUZ+MZwCRt4Hkts9Ef +nJLVqruVhc0xdJoiTAAttzJAVAD/Zpmk348H/ARQhqbTnV25ev7mp9b37vdn9pbmt3/y1z+79+Kb +arxjpqfKnb1UcaXY2F7aunvx1lvzG9davc1Hr7+vOP0QZNrZ2XL3dL1/4dThW6cuvjG1dqPT2fz2 +n/3s/a/8IIravqD8rEeeDBNpyRxPZhfrjaXbd17c2L/RmT2YWLnQnT2Trs6Nzx/MLl84f+Xl2y9/ +Oluer7fXbj5898U3vrh38fHY7JGTmWKEEsNVBLkTjABupECYRyHgj9K8UNOMFs3mGbEWihgcX4Zg +yR9EYFfUNSW9LYhVFI2D9CQrhcnZM4pRSWWajeZ0rjSn2VMUVyPJAkmkgfP6YxdpAIlYTEGxeDAo +DA8DK80QeBKGDJDuSTJOUnGKTohKSdGaQJWNerFwhMOAfYOAeRclJWvH2/2p/bmVK6pex0kzhrhn +Op7tuMMi7sYqk6YzmtWFYCMU5AI+FjBtwM/5fVQU+D5Iq7TX51Yvdif37NQ0RmX8AVaVio7dQVEL +wAxFE8DuaWqDIpNhgE8i/sdTWtGQfPJ47MSx0InjQfAjCqs44q6gEYRz/Hl/0E97PQ== + + + uNsecSj6bAmGDvgIjkvhhA4iJZmbSRWWeNbIFSbKjcX2YKfU2jbjfVHMA+eYLU9xksXwimLkBbmQ +Lizla5vA6wXdDa66LNVEqfTsjC3mngEM8zjmhAIsuNmR4Sgwwjhu4oQlKMV4brrW2pieP7u6unf9 +9gvzK/ut/tbu0csrOy+cu/LG9v69anNRtyqW3axVZ48uPTASwC9MTyxcXNm+OTZ7WKgv2umebJXz +2d79h29cu/8qhFlmfEo2+ons4qnzr2+df7VYXZwZX//e9//q9uPXzWS3UFvsTO9MLO7ffPGtL37r +L775F7/47Mffu3j5xY+/+t1PfvqjeH42npvVE9P56ubs8q2jG59Z2XlC8xWByw6m9kEQhSJKKCxi +pAPMoxaf6c9cddJTQNSNjS+JYkHV21Z6XLaaQEwKSqPd3z9z8TVOShtWwXQarFxrj58dn7tupZZh +JI8Rec0eSHoHeDdFzgA8gNwaDmn+gOSuKXgZis6Wa2ucUIjEFKAHppeutyZOK3ZHBCZRKUIITzAm +jMnRGENSOiukOLHAywXFqLJCLhRmOCm7eupquTYHtB8vVaGYCtJHNKIKQi0Wlb1eHJAAgFYEkiku +rTqDYn1XUNo0k+WZBM+61lJRq8GAMDpCUFRCMxosXwb8BmRkBFiMEzG/jwU6BwaIDUkIrPu8JNDV +7s7AAE/iDvjR6yFA7Ix4qGAEqBqb4rIEkzScZqmxBKNO2imls11OTNmJtuGMq0bfsMYy2ZlUbpLl +TUmyVLNAUJZmdozktGR0QBqi6bxjDZLJcZ+XCAdZBFKiUaBJ2OGhyLOaQhE4pgPfhyA6y2cYId/q +bp7au7N/eK/aXeKkpJ2ozy4fpvP9Yrmfzo0xfAaAUFFqqlq37DYI4VxputpaltQixRcQ3MIoW9Hy +llnOFyecVNstAlkFeJsAUTA1d64ztp6OlwetwePHT2aWt3SjODWze+Xeq3dfefvFp597+MZn7r72 +9ODqvfnl7YePXjq6+nh69uylm29OrdycWb2zun13ZvEImFaCiifsxstvfji7djQ0gnq8BM1mRK2V +qe60Jw4ZPi3yyU+++Z5hVIFAiqKWDYxza3vt9KPTF59Ord3mhfTR+Ztvvv1BZ7CN0RlBa+NcheSb +Y5MXzlx+uzE4QDDj9u2XW701X4BzW6IHJAhJEHSx3QM65IKq1ScG2wtrVzvj+9XuOq9VYCzOiiXZ +bFS6G4xUDEdZcF80l+CELEGbwIAQdEqzWxOLFx88/Vp/5owslw1nLOYeEqHcJd2g+7wLWIZ6a53j +86KYTmXGRK1dHzunxacIGlgnQL9VQayDdBYKKQSRtOKdZHbAS2UEc9w2eaOAkaJgolHMARzrHiAa +cTezjbjbCN0Od0DMnzgRg2HL7T81hIQhQ7W7VnpKT/RVsy1prWBI1aQUSVv+IIkSGitkk9nZbHk9 +XQIGsCpK6VS6qVrVSJQ37W61s1dsnKp1Tj8rSunW3/N5UFMp2WDAg9TwcHh4KAxIDHhhEgcJOs2Q +mWZ7DadtQcyYAMntVTXe5ZSCZrWqQLKyTijkbgSiuUomv5IpbahmH0EsGFJ0q0Xz+REvGY0ZNJ0G +0eSk+qJcRlArGGK9XowiLaAKAkF3JwmBqSpvZe1iPtMWhISupJuNqbHJpebYVLbQU62Knmqly1O1 +ztz0yl6xvjg5uXn1wdOZjStgJFW1SJMWAotIlMo6lVM7V0uNeaCfDb2XSkxb9pikNGEMZHxMEZTd +3bMYbtFszUrOVVs7q6cfbJ97OL953UlPSFz8pUev/Ow3f7d9cIvkS5nqRrF7dnLz8e2Xv7RzcK/W +mrOs3Duf+cLu2TuhiATMnWJNZmunupMXDq+/my3OpZzWK6985uaL73oDPLAn4ZjGCdWVrbuX7793 +8dH7Tm6+2Vh4872v11or4bAYiYmiWq139rfOvXTr8Rcm568CY3Xt5ieL5fkTbneemNfLwHACoCJf +mJ9bvizyuZvXH378J3/BC3mSq2vxWfDpRnJh5/CNo7ufq7b34Zhx/+Hb9176VCLdG/USw6Mo+B4O +SyiSYLnmkNtrlTg4ffXWjceAQI4d8x573vvcJ3zHjsXCEcew52FIn13Y741vAFsqaYD3CggWh9CU +PwzmLgNMFo5phlGCIDEG/k0lVLuXKS13B7vLp26Y6XEUVfL5aTs5cHueRmSgGz1e2t0eSVqykIIi +dMgPM6QUCiCBAIEQCZTKADuDExmUSIUinKqWgIRrTu5vnX+0uHOnO38lUVjzB2k4xqtqJQa5j/6e +OX02EpJYJpctzlNsHkREMjEGLikSE8Boe/wccItu+T5Il/lCwN1PwmcLs0DuykKBJhLRsITDKiCf +dLpLMUYgAJOkCQhHMcv9mdMbp2/MrRyadiuVatuJLoabHBuX5SxDORgsM7hGEeAl9MgoCrwVTWZA +yGOoAkNqKMiLbIohLBIzgCUHAc4yWSCYMdygGIem45KcTzn1bmu+3lwAGQFc/PjM+Vp3M5npSEpG +FOO6GrfUuCym3bV7D8nSaRFcMJ1AUS0W5WNhBqSneHKMV9uBoJzIzKaLi7rZmZg5s7B5udJZw3Gj +nG2e3ruSL0ziaDyVmUpkJnS7JSp5VS8CVw6crCAWMNwZedacAmhF05qIJ+dkpcHQcVWwa5V+f7Dm +nlIsryaKq/XBYb1/kCnOOJlJik4SMLe2erB+6oog5oEU1PQ2TgD1FZeEot9L+D2YKRdffvyp1954 +F3gZt7+qh/NHbJwtZ0pr6fyCoWQ/+OhrT15/x+8lTxyP+H0cx9dy1d3+6u1gkA/5SY4G89jAUA2Q +BkhJYPCB9usOtoEQIsHosc7i/OlqbTYckWJRDYhYismAwYGidNAH+0YjUBgRGSEWiUIRlGETpfaO +5kxK2hjFFRnKmB5f29m9nsiOS1rFSQOzvIDguXCYpzBV5BLhIBUJMhhiEqjDUhnT7AJfBsFxEksq +fEHmsu3a3NzCYQTWQFpBUCMSlgKA9v0ETxn5/LjfR48OI24L5lEChjQwJgyTpBkHAMOJNwUpDaOC +FW+WG2uJzJxmjrV7e/HkBAyrndZStTobDrmVSWIQsOrxQNCG4YLA18ElBf2QLiUMreIDvikk/nEF +MBLR3ZP4Uc3vZ1XdjVCCzBhWzzKbJGGHQjyQwRQVR2A1GCAo3N2RiKMqAC0CK+GIPOohQEQQqOz3 +QO7pbD8VDlAMbtBkkuVLKJ4MhehsYZDM92MxYFENScmzXFIWs5aWEzknHCAENp7JtKAYCCscQ2UA +b1kGF5wFt+P3U8EAi+NONKIgsIYiBhglOMJLrMmSJjAUsahU7W5IapUkEySVRGAD6CWOSalylkCU +oB8bGYqA2MRR/eSJ8PDJaMCLUCjDU3LSrJTz0yBOT56MjgzjsVgCp4sYkURRkyQlGpiWate2SidP +xtxzYfZEd+LczNrNicULwGJgAE6YjsA8BvNudoAlcF+8mLGdhuU0AfIVIa7JSYrQwERQOPCkKRTT +MFT1e1EMEpAIjcVIiRUJBONokSJVJ91kpByMGhAk6WJya2Xv8Oi2qgGRlkimp5vtg3hqAcNMOMpE +AnjQh0FhHoUVKMrDUYHADJJMCWKDpbJIVDbEzLntCw+ffBpC1XCUQxA1BogrphII+JIDfsw3ioSB +sPQDNyRGY+qzIg9cJCKydNKyGyRl4phcLE/ny3OJzJSVGOjmGAsoEVIto2ZZDfCfwSzEE+PpzCqG +N2AoHwqK3pFoOADLvClwznG3jEwYABjDMiRRRNBEJKJBkBFP9hk2C4QKBNsgj7u/RGwgjAExugVA +hqLRIAUD7zwKu1URRjAEBRSXxhEdQ0TvaNSQi5nEGAKpcESEoyqBASWgRiNModh3EjW/H6UInecT +NGWxlE2gEhTGIwGEIdRsuhz2h6BQDEdArrFI0gEf5/eRw0NR7ygKpO+J4wHPCAxH5ZCfjoH5gmUk +DNgDwEzojW8qUjYaoinSQREbQw0QEWAePcOR0aFgwIMQsDLqVqiAgD3EIN02iqYGojuDxvTjx4Mg +FZ444WrpZ8dgMb8PEziDZ3UMFbweCLhFhsnKSs00G/FUV1Yqfh8eDoF8GjtxfDQaRFAETBDH0nq1 +PJ7JdDStiCJyJIz7fNFQgCKwLIYYGCJlk5362OawB3BFxDMS8o6ECJjmCNHUUm4lIifHSYmQS/VO +pzZVACqIcxCISycahl4EmQhG9dFRLByko2FOAuZFKqCIBAInFMCjIRKKCoDTfB4SiaqWmq+Xx8vl +PkVIhpamSBNoVPBCJCZAYeH48TCgrFjYvbWhk35fgI/GbIYtK0rbMHuaXoVjLCCfmdldUQFmJA5U +nChV4/GxUmnOtNwnh8EARVEmw1gA6u66mNuAEoOB94f4cAj3joaD3igOcXAEXCrj9wMZY8lyledc +oohEhGcmqwk4h2bqtrPoHnKBtaC70AZ4FR8dDkZCNLA5FJVUlRzLxJ+VVggEPND81Ob+/k0C0/1e +JOwnoCArMnFwU3CUDwWI0aEwCgsMBdhGCAVINMaSMEtjPIEKcAwOev1YFAY/gkjk2AxDp9x1ah8e +CTFgjo4/7/GPoH4PMgpgcMw/cjzkG8WgiMjgpsyngG7JJgoH+1eAyATJLuxnAKtEQ3wsxFGIDuDn +HYFso+lYY3BExkGOCHGeYfjYcz7vKJgXCXziiWMeElM4Jh70k0EfGCIU2DfPcBSLijyZwCEtGmQY +whH52tBw+Phx77Fjo+CWcVRWZSC/ZVuxz569YFpFn58IhzgE1UgqRbNFnEj6vZAuWIenr7775e+H +YuJznxg6ecIfC1EiY6tywrYyEqudP7i4tn0+CnGjI9Fni/LuujyBqyyjSryWsIDCnOLZPElYQOPF +Igz4PQYRLMErfBKOMVAEg0I4iUqOVaUpPRYBIxAQacq2ACaZYAQPhWGQESQuKwvtSEgBmWh4JHri +uAeKiRyXpGkbck2rCkE6BisynyBRORYhFSWbLc9DCPhEPhJy92c++2tKV/M+Pzo0FAJuOhIUKMyB +IoLfh8AQk4pn0qYjkELID/l9MAyLpt0oVOYBokJBBlxRvbkUT/TcrtDDUQAnKMphbgaMS3wJRywA +pLTTyCWbsTAGKJ2nFAIWCESkED4aQkL+CHj/84eHOMKOngx5h6Mnj/mGjwdDPtIt80gZzxaCBSii +x4JYNBD1jvhHh/yRQNSW5ErKruUSuqSWq11BcjyjwEMFR9wphpCIGAmwwyeCx58fPf7caNBL8UyO +o1OxIMPialzPJs28KucCXhQKc2gM5BreC4jlmGfouN87HAn7MI6MozHBPxoFCPd5APJpHLZQyAn5 +uaETwaHjPolLAUAOnwwCHIK0S+GGIeUoWAt5mdGTcDQAIosYORn2jiLRICBPNuCFWJLhSFzm8HLS +6HYbNMtBwCDpyXKxEXfSNCPGojEsFrOBaSy1E6naiROBkaFwNEhrfNyR4yJJGTzdzA== + + + JZaW5uLpXDCMen1INAJyqMJzSsI2cmk7nzLX5/uPHtxtt6dHR8OjI8GRYT+D8xKQR4qkcjwSiVkS +n4sbIgMQ5YkF/RweyzhCNWecPzVzcGZ5Zq1froM3E1QFiA0RCJhnphgFV6LwiqlJqiyYms0QhiLk +KdwCssc/EmVxvpgt15pjipLIZZo0raMwi0FcJEgMnwwfO+Zzn2VhbrkYMHQhHwzUb7PSm5meUQUJ +DmN+L4zCMlAFtlVgOYcgjXJ5XNNyipLjuETAj8fCNMAMifESo7CkjsQ4kLJZOsNSlkSLMknkHdVW +NInlDVHkMIQDICOhfjO5ONfhGcCKBBxhoSCFRQUcUkAiA/AAHEIChRlhooEAFPTHAgGd49sZc67q +7EwWru11Lu+Ov/HK1d3N6ZSukbgIRVmQ+xhEBwB7/hPDJ48HgsBlB5ngaAwPExxKOaJsCpLGiSgI +3iAkMRxHkSTgR5JhMF6kbEPOR8P08En/8eeHTxzzAniA5DgMXOcwcfxY9Nix0MkTEf8oDsAf9kFQ +CE7HczhE41FS5x04BDQ/QaEOT8cDPvjkCa/fAxNAw4TQmN/PYSFHghoZZrplLU6XGjW7kJV6VfNo +tX73wvz2WrtdNlpFO2k5qmShCHfy2IhvJICEIJ1mHRZXsEBWhlZ6iUbFNDRaVznT0EWWSplcvSAt +dfVXb2+8+sLuw6tzL9xcrpZSoyOB0eEwEgWC1VFZ3uQIm4UdDhqU1JV+Yrws5nSoXxBOTaZevbP6 +6t21737u6Lc/fusXv/rwi1+8vbGQT9uUxDMkGYchB46aAqnnHb1T1idbiUE9FZeYnG0KNB8ORGLB +sMnzrXK236+uLc+9+sYb9XYPgpFgAAYXMHQC8BUtK22SzLiP5o6doGE4YxiNfK6YttBYGAlDsRAk +MGK7lLt8eDDW65qGubY2m82mEJiIRHBBcBjGAcqNArwUA0RAg6+c6VTSeZAICyZXVJGdufz5rcFU +I9lOi9uD1IvXlz/5YOsLb557+sLO3csb84NqxjLwCAQF0YgfJ2Fd5LIMJjAwplBoNc6Ml5R+SZ1r +G+fmrAc7+U/fmfny0+2vvnHq73/5td/+/CvvvLB9Zn3QqxU0VsCiOBwmIiGKJm2OMPEwBEx1URVa +CbVsMFMVfXksNdvObM+171xav3ww/fDa0tsv7n/y4eXLe6d75UrWsVSeQsJhoL4iAco7ggA4eUcw +wKgnj3k9w8GYH4b8YZXE84bUq2TiEqfTeD0Tr2bTKc1J62k8Rp847gUBG/GjQGwpaNjCfU0zemZC +efGgdmuv9vCo++FbB998/8oXXl/94FHv99+/9U+/ee8vv/HgvdcOdhZ7eccB9iHoDUa8o0zEl+Ni +k0l4Kh1cKscuzKlXT+UPN7JH69kbe42H55tv3Bq8da//xcdTf/dXr/6n33z2O58/c3cnVdSRsM/v +90ZpXGJwgYjCEhzqGbH9DnU0yT05k/nw5fnP3O+/c6f1xSeTv/juzX/67Wd/8e3Lv/qTo//ys1f+ +x3//+V998+7b9+YvbdcKCRuPgWhlbEHLm2IrzS41lf0JfSYHz5WxXhpf6pir/fh63766XXn/yeYf +fvcnv/r1Nz764P6Tu+t7G+MKjwe8vkgAhWLC8HDwxLGhmNcTZ6MZPlaQoTjji7OBfk6YaxiLXX1v +Un/n0cY7T/Zfvbv51Xcv/OSH7735ytVGyZyb6s/O7Sxv3VW0Ehr0mxSU5OCOiZ4Zlx+fqz/YKx6M +869eqPzi+49//sNXP//C/JceDX73o5f/7T995b/+4Qs/+fLBv/zq5b/55sVzC7ZFReCAW5OQhAQi +hvJQIMkE5/LYvc3E9z6///MfPPqTz5//7IPuNz459aMvH/zhb578zcdHP/5w519+88o//OjqFx6U +H+zndmeyeVspxEGuTBpKRiSZFB/rOdBKib65En/7xsQr50pPzuf+9IPzv/nx0//6n7/z+1+896vv +3f5v//DO//f//t3f//qDJ4fVb7+z9csfvvDe442sIQU9EEiywMayhIyEQjhI+RGvhgcMbHQ2T1xe +TF5azu5NaEfz5ssXO3/21Xsfvr7z4dNLb790NWc7UJQBDCyheFmhplLodp24syh/cLv1vXf3v/vu +3k+/dvM//+Tp//j3v/r9zz/94y8f/N2f3/uvv/vcNz5zdGoqmwUOkhJsNS7guEFCLR1dzEPn+8TN +Ofn1vcR33lz66Tdu/uALZ7/59tpff+ngP//1S//tP77/r7995zc/uPm771/+zZ9ee+PadNV2kyAQ +ISF/FA0jcUGtqNJCinx1S3n3YuLz1/PffXPmt98693/+4a1//Pkrf/mlvd985+iffvbwH390+8cf +bP70w/VffWv/zz+/dX0r28w60QAMh0kqiq2Mlda7zkpdvL6kfeVx/8dfOv3tN2e/+XTh9z959Vff +v/9nn9v94WfW//s/fvA///uP/ulvn/7+e9f+j79/+/sfHmyPAyz4R4dHwgEIcLtJM9M5rmeEu6rv +8jj5aMu8v2W+dqHw4ZPpH3x+61tvL/z0m1f+/T995Xd/+fIffvzKv/3Dl/7mW7cOFsszg36+0EVg +OWs6NUvsJ4jtCnppnPzi3eYvv3742+9c+d5769/59NpPv375X3/37i+/c+37763/h4/P/e+/fuM3 +37jwrUflL97MHIxxgFVEkvUOB08+P4J4fUk6OJWInOsy15eMJ+eL7z+Y+tmf3P7nv33zf/vp47// +0aO///GLP//48Ocf7f7lp6c+dz1/aVoaS+ApEXXLiTIajetxvdCvNVd6qaksNZeGLw7Iz99r/dl7 +Wz/66OAvv7Tzi+9e/MNPX/yHnz355Z9c/uVHm//ww0v/8qsXfv/DK9/+ZO8zF+MvH5QaKRUK0zyb +Yyhb5eRWVm/Y+FgcPTuQ763JL+/on7qYBaPxH//i9q++e/Hn3zj8v/75a//3v/7pdz61/t3Pnnty +a41FKTTKJAQxxeFZLtqzkaUCdjQuvnqm9K03Vn/w2f2ffPHcv//mM//zv/3kH3/8+McfnP7g0eKp +2XxKoVgUx2Fek9KGlLbFuMPSBRGaz3OHU+m7W/mXTid++OnV//V79/7w43e//MryR4963//Uwk+/ +cu4bb288PFs5M1ds5Us6iCk+Q6A68GIMruSMdNWy8wI27uBnxs1zk+bVefOz1+o/+sLer7977wef +P/udT21+6cXlpxc6b+xX7qyl1rpyM8MZAhUNUwKdt7WaSPAlUykoZFnG5ov8w1PFb74+/9cfnPrb +717+7Q/u/uGvXvrnX73zs69f/PmXd//lZy/+2y9f/fVXNr/zJP/yfmquxNNQKByATaWUi3c11jQp +rKnjHSU2bwdvTLOfPMy+fbn8tSfz//77d//ld2///kf3/8uvXvu3v//8T791/RtPV95/cXZpLGHK +GkOa4HZquZbOsimBWG/ZgwQ8l4zst8gH68mnl7ovn23c28h+4Vbv19++9tOPr3/7jdUvvzDxqUu9 +i9OJ+SLIqbCAcySiACUzejJCQ5QAheJEcMzCNlrm/mRudyx1ZTH/0pnK21fG3rkx8/aNmbM97VxX +OegZ8yUrwQkywfA4CzS/yCZ4OqkKWY13qslU2ZBKCrNStc9NZA7HzbcvNb71xuzffuvMP//i5b/5 +8uHXHk9+7WH39W3z0YLyZDO7VhZMLETHEIlPG3qXwGxgA/EowUbDDhFpqOhamT3bJV9Y11/fT330 +sPeHv37h//n3j//p16/99vsPP379zMX58kTBUTglGlOQGIOGwpS7rwvLK0zDpCfS/EpNPZxNX17K +vrBb/urLy19/6/Q7d6dub1emKhpHQZGA3+8JR8JcKt6tV5eTdlemNRUnWnH97EL/6u7MII0dTSiv +nGt95c1Lt0+PXVku3Nos7Qzsfk5JqwwwODRuuuUKYyZOpICRBw46Ha87siXCiEkSRU0qGXzNYpcb +1uFM4dpq89JSeW8yO11MTGUSYBrTCsfiKBTFQyEqEGApPEXActQfgfxBOhI1SWo8m97oFQ6nnTur +zocvDH7wuVMfvzL/ow8v/OgLh997a+27ry1+/MLM+1cbl2e1OBcFpl2gFbf0MeYQqBkChihCVqxE +N2ln6FDfip3uSBcm9RsL5nefrv3rf3z/n3/3mf/wzevfe+/cG9emrm6WFjs28MaymDbNNknYFGkg +MVaitU62mhXpkko0LLYkkXWNm8yag6Qym6IvTCfvbo+dn8r3TLqqCGleVAmWhOign/GMkEMngAJE +FS7BwTgTiYgQnFGUctyuxeMN28xLdIYjCxJbM3mHjAEtmGSFZr4j0DZwJQhQ8pCQzXRxVA8HgNjG +kTAhk1LZKSyOr8y3Bk1DXCooN5YKW1Xh0mzuzCC9XpI2yvJCTpnL6jWFjQBZMBKBIjJDFeEYsIFh +4DS9QwEs6A5sTuSaplAUoMkUvVLkLk+bn7o2/plbs4/3u2f65TRN8xBpyLl4ZqY1OKKJuCIkGVyi +UTAgisYrMi3ovNzM5ysJvWjxRYuLS5Qhspoo05SAYAKw6qOjcCwmC2KGpG1fgIxGBJ6ydMHMOrli +qkxGIgmWasTNShJwmiERnEiwwFDEQiRwUpEQ7fPiHg8OI4lkZiGdX3C3kElZhtQomNWFOB4DaZrU +GGO8NjPdme9VBgnFUihO4xzTtTD4ySGvP0DGkATF1AShqkoVGtdGh3zeYT/w9RpvW1Lcloy8oTYz ++kIrfriQ3+6Z52ayRwvN1UZ6IqP2U2bVNKBg7ORJTyjonm0f9SAnTgaB3yTIXCY9Wy0uFFMdiaRs +Dq0ZdFFECwJ0qpN+9cr2a7fPXFibXqyV05Ig4BgO4zRjw7AJwYY/yKtmr949qDX2c4kJidIXJxau +HN2kYA7MF4tKjpQuOOVqupY1shIhQz4CDkleYEtPRAGoIlErGNSCARmGLIFNRX0QFgK5HvOOwu7j +ryAZDXNITKEwi8ZtHOJC3jASIqMBJhpiWXfFSqfwhOQeZhkLhURge4N+Coc0GjMMtSKLDRA4ZIyR +SbGdqyD+cFxwMmbZ5Ew6SlGQSCKy3600HoIhk8RTPg/53P8ycuy5EeA3cUgyRcuWEyREEVFMIXiH +l92zuGjMIBGDomxWs9hUcBT1uQVhOsXmrh0f142xTv+UlagiKE+QlqrV86WVVH6OpAwMFVTBGevO +eAPw0HDY62dYsaHZE6oxzrqVtdICl+0PTol6zRuSEdw9lIHiyXBERSGdQtWgDxk6GQj6GBxxeK5C +kjlAUzHIiERUns0AWeLzc76A2+oIxeKqVjWthqoUE/EG5275cBfaEMQEf2L5siBWJKWiW23NrAt8 +QpQKMJYIx7QYpEeiOoLFEcQOhQQEVijKlOWcIKRkuZxIjNlOU1eLFMLxlKCBieVTHk84FEBhSJOk +jplaQciMz08ODUVPnAwDYCBYTlI77oFEH+H1Eihq07iDRSksgqmMWswCXtIgWEIxiw== + + + eVYrD4LdgufgtaMgUmBNFEu54grDV0JhMxyWYpBqO/14csI7SoYCYHhtQSzIWjMGO8GQEo3qPFfl +uHLAz3tGaYIoFMobmtkX5RaMJUc9ADmMRMdlPgE8Gs2VrPRMsrRYdjvSTj7rNi6ShNXqbLFu9XLN +MPuJ1Hwmv+pkljwB5cQwfnIYDYc1n4d6/rnRkWFYlNvJ0kamtKaZA4Dek8cjkaDg93LPPx8aHkYw +Iq3o4/HUqmYMQhHDF5CHR9xlKYa0AZiH3KdknuGTkaCPxBBdFUsSm/CORIJeCI8JOCxjYLpDgntk +KSRFESccs57/hMdIzuJsluWT66tHnYlthEpQQgGj0rxclNSqYXY6E3shWAzHRIrN6IkOSmeiSDyG +JgW122jvHV5/q9BYHvKQwSjgiVk7s8mrA5zKR2NqIMSimMkJZYA3CLFhLC0oY5o9BRhRkms8nw+G +lUjMiCEGyRQVs+ekJ0S1juIJy+4Vysu8UFDUGsUVeK2TqZ1KlNbtzJxm9zgh35u6wEv1KKSIaoHi +8orVY6QaQuUxOq/b/XZ/f3nrBkomRrxEMCxRbNHd4EemCdY9wmNq1W5vW9Zbkt6gpSZClnC6zkuD +YBjQjhOOunsC/UEyFhNFsSjIfYIshQJcOMhJYoV9dqJBUJrp0nKmvE5yDZKrx9BEBDJorkBQmVhM +5dhcOKoFAjJKJCm+hFJFT1AdGiYJMh6OsB6PW0gWQhyWr1FMkWFLKJ4m6QLLV1Sj5/ML0ZgNoRmM +LEJoimRKKJEeHsFGhjFFabJ8IRBiQhGR4Io4V8aZkmx0ecndlgmjFkJkvUElEDUgImdlVyRrykwv +GomFk0OEx8PQTIEXi5GYDsEg9hPhSByQM4qlIhF9dJTEqaxpD0xrPAZZbu/RkErxdU7qamoNiooA +lseOhTwjWNBHhUMCjMRD7vlfPRIBiDJ9IyigNQIzdWtMtSckc1wwxjGqcPIESostWqgmUoODc49q +3ZUIqiFUEibiZmLcTE65FcO0FuNutpmwU2MhWPKE2EBEp7h6rXu+NriUb+4SfD4Kq6xYU6wpxZ7B +mCpEZMH461Y/kZlV7TFAL6GIKqrdeHbbSCyzUgcjMxASBxfAyy0INSJRmRUrABWZ0mqxtpUrr8XT +s6n09MbuHU6tkWIl396bWLk1v31veu1WobVTHzsry41Mcmxp+1oY0REyAaClOLPp8la9f1jtnU+X +VxEizggFUW0yfA2n8wCfnN7llcbk5MHG3iNBqQ15sBBkOJnFYvNspnRAsu0oko7ADoQnnu2FE6Mx +cdTtwiy7tX9RBydzUThu2AM7NY1SFoRbYBJpqSuabodlPTEFMBYOK2P9Xd3sgvv1+BlAiQRbIbmm +oA1ooQzBajTCa2pV0duAiqMxQIC2pI056cVkbjmVXfT5RUFqiUqfEzvgs8Kw4wvrQx42Ajl2co6g +8259e8yhhYqg93itTwu1YEQBwFascRhkDbcSWh2lC3pilpXbij1Jy50w5IjaWDyz4A0AWMoAWjhR +4sWOZo2DO4pBTgyyFWMMJGKAwFEPFYkqotJM5pYoruHWbPGQ4KqCYQMw24lj3mPH/MeH8BCUFJWu +Zg0Yvur3MsEAz/MlBoQwbIMvt3gmmpDVLit2ipWtQnVVs7sYnWDEkpEcwFScFYu80gIg5JVmIjNV +624pVisQlXitgZJZGEsRbD6EpmNEDcKLf9zDH4rpMTQuGmN6YqbeP1o89aQ7ey2Gp2DYysX7i4uH +YdT2R61QNI4SZdmYzNR2Ms1d0Wi6jdVyU7RUEfUmJ9c4uS7onUR+0clMkXzWSHRPHb28fOZOfbCb +rqwrzgzAJLiRVnNtefsGGDFerhQbO+XOYXPqUqm7J1rjEJm3U5OzqzcLtfVgSEukZhc3bk4sXOxO +XVjbe6TGpwCJAfxwUpXmcxBmYFRmeunO5ML9+uBGorSNYhkEd0S1yOuNIQ/jD4iAuxRtRrPnncxK +prQC46qoVeP5FSO5CPihPn44vnAtU17T7EkgtCS9E0VMXi4LWldzBiAvCPpkIOoedjOt3vTcEUml +gmEwy5ZmjmVrYAQmOX0CZ2qBkFYqrznxgScgxtBMOOogeE6PLzr5TUGfCkPJdGZy/+y9sFvZjxrx +8oC4WEChlc3lM6+zfP3ipcdf/voPi5XFYQ/nD+u81qvNXJzYvN+cvqLFp4MRLVNcAKHh9YlDwzhM +pKMo4NVGvnraSi75fXIkrPBCCcSUx4sC7hrycN6QwgAIJZbyzYPnj0dHRmAI1sIxMxyxACYhJBkM +WxE4qTkzycIqSNC+AB929UkSJbLx3BqCpTHgsJgCIBPJGNQ65ydWb9NS3k6OZavL5eZ6rbuZKswq +ZhMMpqDVav09MGtu21yxZibmS82zpfZZIz4DbtMflWEyDmgKZFiSK3MqiKwpgm2q1mRn4nxz/BTs +7j0eqHZf1Hu00JCsCT01Len1uYVzm/v3NKeLuFXls0AJN8YPBut39fS8Fe/MzOy89e5XG4P1MGZR +YqvQ2GtNXO7PXS0211DC9vhpgsnidBYiLJzPhTGHU1v9uWsLm48qnX1ObYPU2Rg7y0h1hMqKxkSl +d9bKLIpaH/CVnZ4c9kDBKOFkOslCX4/3olgGpaqyNkjlF9dP3do8fWfYQ/qDAss1uv0rsxsvmtlT +JN+kmfzDl75Yqq6EowZgxZmV6w9f++DhGx8u7j2UnUmgFlSt/fanPjacsREvF0MyijWXqZ7pztxY +3Xm52jmgmEx/cjdfmvEEqDBsUmInXtidW3/cm74wPnMkuIXyCvnqujuJUUPUurI9yaljJNcq1k5P +zF2AkASQyoCiRb0v6G13UytZBJptbfva1Qdvs1IZwdN2ct5OAQM8oIQGQZeAGmH4en3swEkvDI2w +gaCmOeNObi5TWSt3dgAv+T3ApU+NzxwCATw0QoBcr8VXBL0vmQOcraFkZXiUTSV616+/quu15z4x +OjqCokTKTCx1pq/tXnyz1NgKBOUrN57aifFQVAsBdS/2YkA4wQlwL1ZqpTF2dffwndW9x6pWO719 +pd1fB4pLNZp2crLa3mj2T7cmzqSqS7xULFUXK91djMqySoXT6hhTAYmVU7t6YrrQ2Ca5PFBrnNzK +Vfdr49fac9eK/QNWqcbt7vrO/URhEsBAj09mKhtzqzfOX3zl/I23+7NHTmJ8rL/dHd9RjXamtNya +PJ+pbJWbW/Or13eOHqfLg05vY2b+quZMUHwF54solQRKjOabRmKelRqKVu3P7gl6PYo6ujMJkoJo +TnB6vz11aXbzAcCkEZ+KF1fnNq8vn3mx0DsHfFIQsiOQqVqtYns9CDGyVSWFGiv3spWNVGlVMnvg +LkY8BE6mJa0laGVWb3P6jJpYsDNLiewcjLndrArlecWss2LGzgwa02fT1aVMeSlf3ciVlmHMBvRo +p+ftNJjlvpWdBUJaiS9q9nSxccpIDIIRsdbe6Ewdqs6kEZ/k1YZktEm2lEzPAFQzfIGks3PLF669 +8N72hScTq9ervbOG02eY1OnTN+8++kIwasB4wklNdqaO2lNHzcmzjclDINKuXnt1bu4sglgknapP +nJ1avTtYuNkYv9Sbu8uInVGvQDGFKGRYqWkrM6+nZlitBcRPuryeLm4PDTMxKJ7MLVJsdXgUHvFg +QyMkBKfBOAMjoKndYFA4fiIE5Csr1EgXdUWCLgfCOqCyzd0XU5lpoFdhLA6QAJIjTuZBmgaKy0rN +5mvrIJY5LrswvZMrTyCYoaj1IqDczburOw8a/X0z1RfkwthguzN9PgBEHWHJVjtfPdUeXC209nL1 +7WRxUVLqhcqiarb1+CBT207WNiRnnBIqhdL6zNo9MzOBkE6tezpXXhmf3j9z+GBu47qdnpDlyuz0 +mcHMPicWc8W5sxef7B29tnTqwezm3UrvtKpnj87fOTj/AoQBEgb0VZWMLsBAurytxudJtprNTl29 +/zSeG8B4PFNc0ZPzZna1On7+9OU35zbuxBMzO/sPJ1cuM2rFKS7J8QVa6evJpXR5tzZ2yKttUcpd +vfVJwAlh2ILxFM5WCb7OyA2KLRTL6/XW9vrm4eTCOYJrsHIHEHIYiUNEQnN6E0tXXdqknHRhJt9c +T5UWK52deH4JwnIIkcnVN5LFpShis3IlVVkrtM4U2ufaUzeLrTOqNeCE0sVrT/YOX+CVGhBXBF0E +BqHaOZ3ML5nxMaBgaTYzu3hhfuVCMjvQ4l2Adic5UazO7519YXXjOvALitYezB7Obd2xC0ucMfb/ +s/deTZIl2ZnYO4nuqszQV2utVdzQWmZkRGpdlZWlRVd1V7XuGfTMYDALgMAulgAXKw3cNSPX1kgj +X/jAB/4DvvAnkZ9nc5dLPvGBZkxbS+/orIzIiBvX3c/5hMcNP35+Avn6/Y9/NZ9fiEIUJcudwy/m +m9fdwQXSzU1PaKFdqUVRvJLV5vHjH7749T+7+vBXo/2vJnvvR7tfeMl5pZZAx55dfOP5C0mCeW/w +QtOA5klPXH8tiu1iURPEehBuAErFssNyTS849MKjRud5e/gcvoxiAySUovXhGmxnQjaQ5yOMgO5M +ksZxd/SEZEdMlGcQjMN4tzO8RDJG2Qby2A93BrOXcfu0CPLVGgit9fE36+Mf4taJ7o5pIfHc8cHR +V0m2cr0hgO7y1e8x/s+++MunX/z1/uNfB409xWgfXX5rOpA0bZLyyTqp74+n15PFMz9ZGmar3d70 +Buv56qo/e5T3zl3IsGQ8nl42OgcgEddf3NataEpmI2kft4ZPuwRGrjvjE1mrp9nip9/+83c//G1r +8qw7eUq+NN3ci+PF06ffP3nxayAtdP7i4Kf+4v308CdgiAktykXD3vHX3//FfP10u6Ro1gTwMt58 +2R4/RWr3Bxf7mxf/5u//+7/5u3/LSm1B7VneptF/fvHyz9//8b8+fv7nfrT++PF3/81/9z8v1y/g +0Zzk3I4hoS8253/87Ju/w6xJSqMFW9Q7M13E21Czx7o19sP14Bad3n71u8Hk8tHjb5vtUy/ehdcQ +1R4tZBz8ZrTe2XyV5vtp4yDrnNrh4vjsm6unP/fGzwybFE6aLZ72BmcWZq37ZAjtun7fnb0Ks0NM +MWzCYHqjm6Nb0xcCDKPm4/7yY2/+1vLmutnbHL9+8u7XQX1VwhP4xPJ3Jrtf4iW9wVWWbcj+YEY2 +GF2p2qBWC4tlF5xI0ZmqDcfTdzvr74NoM1vcTGYvZKnJsTGkfoWKEGlhctQZvlC1UZQfBNku8g4p +YHlTSHQ32oT5iWJNBbWjWd0wWXBi4seL4fJ5d3zT6l2vDn7YOfnJTtecnHYmj+r9c1bKdHsCm+bC +za3eZvkJnuaGS0XNV/vvVscf+vObtH3qZruK09fcSX/6dLzzGuAAhx6m6yjZDMdX0+WT1uCM5iPH +7bX7R5pd9/1uUl/XW6ezNazlIzgj05sJUjPKjv10jxX9MJv05tfrk68un//++PpnRg== + + + CAVyKf786PKj4U9hncjG4P7u6vCLzem79fF715s6zjTO4L865ZqJLOiOHr949w+gMZrdC5lsTmhW +KBs+2nT6NdoEbuSdw9n8crO5ef/hN6PJmSC3s+ajvH2TNc+DbB+WAfjW7FycP/ru5uUfy3pHVPut +0ZvZ0a+78y+y9lm9e2V4ZMP/569+u9x9CrMsKF3Dmc93Pzx9+1+cXH2/2gN1Pt5dP/37v/8fTs+/ +EfVJZ/ZqvPfVaP3F/PArDLiq967O3v9P/8v/+oe//jcQq/CeYf2sO3493/s0XLzM2ydZffPFuz/5 ++se/tfw5gFR1Zm60V29d+MmRbu8o2rDXOz57/Mn0JrIxlfQJwzdoJvGC2Xz3+dXzn1Sj5bqTKN5t +dS/Or391+fg705lRTFypOmmyfnz9K9uZFgpGpeJ5wWbv5Ifx/K0fH8rqpN06/hf/6t99/c0ftrdF ++AJWGurWqj94Nhw+rdePXLuP7lv+RNZaspKnjT3LnbvJoeosIbMH07fd4cvO6AnGHMqz2T8LyIb8 +u5o9Ua2JHe4Ops/Pn/0u65xUKAvn48VrK5gPFk/RC7CtanTJVm87r7x4AZhqdC96i5eLw2+On/z+ +3Xd/sz77WjF7XjQl4cSGktSEs7DcpWpOITsRorLRaLV34bMYIYUKxYCwYh1vUe88CvMz0587/uj1 +F7+Jsh3LHSFPYQoQ4Y47ns6fP3n3B5GU2BtEydpxZxBv/elVa3guKo3bjZ1XstZkWN8NZ+3uwf7h +i0Z7v1xxihWX5jLVGuetU11v2FY9zXfGO9cXT747vflxsLgW5AwqJakf3e4OYSMvIJVPH/365t0/ +ilrXrNCtVINO56Q9uOCVOkIUXp7hct1aZu3H+eAGWSPJ9cOzj5CIMlkN7klKGwg8nb9c7X2aLD7w +UldU+p3xc4iu21WFuijXBZ7sAvf+018cnH9pWO00P5jtvt2cfGqPriW9D60IPXZw+H42v5GUPKqv +8/41MvHs5reDxVtW7FBU2GoeHJ590K2+ac2C9CBpXtj+ptN/tDn61B1cqWrz5vqb48OXttUWxFgx +OvXO6enNry6f/04zxoLYYLnU0Aa62qfpSBDqNIvnkIpXWb476B+YRrdW8+P68WD2nhdyuuZUy7rI +Ra7Ztv2V5e2o5gQQ3R6cJfXD8fILnxSyOVmf/Ag7lrbOWCERhMRxR5iRrHXsJftxfr4DzXD5q73z +7/xsU6lZrj9Xzb5s9r18T7WHPHjWnfbHjye7byxvFKXL1eGXrdHjvH/RGJ73Fo9AZAgtP1nBxTBc +4ngrWNSIfFNjLetDCB5E+2r9AuZU1LuGtxDkHgRhlMKoHqJrpjfHGR4//omXG6433hx9mK7eQWak ++XFveD1ZvYJD98NZFO8A2GWlE6T7URNIOJa0pma1NLPVbO43Wns0a1KMUaXtUtkSlQE8V2NwbdlD +18gvj19ePvooqnWknhUudW/uRaso2Xf9JcMGUTztjc7qrb127yhuHIrahGLgytvz5eu8e0Kxjqyk +qtpl2MyyFxgulRReDB1n+PbD7xWtXSjILBtLaiepH5xe/Xx89du48Xi75NSYGNNRo73bLWgiRW25 +zjhN9rqD66h+EITT/ujUctqKniFNVHMcpQft3mXWPIWdFKV0PH00Xb3CbAb1Izver7F1WekHwQZP +k+Wm7042Jx9WJx9VYwwtpBkj2DqejZ49+ebo4JnrtMN43B0cz3afHj36BgqNYpJiyaxRoW1MXGuy +vaVVq77tL4Glq8OvssaRIGSViqOo3d7oSdY43toWS0WyQyBOOE03WfNiuvtNY/A27z+1/ZGspo7f +t90hUtJN1qYH9JhyygD9xZDyfNAbPepPXnYHLyBvwICi3mOlFhyrbrQlpQ52Wx582j35LmtdBvF+ +3jlzo4UXjnd2X6yPvpSNlqQ3JaMFt/jm019+8/M/PXn6G7h1XkxhQoFpkt6jmIiXesCuRvvi7Yd/ +cHT+vtE9Pr76xrCnrFBHwECHOMFu1sJpf7l39VvNHLtOb7nzuNneN2yIN0R1w/Z3kuw0y49Ne1iq +GCbIOtwN4fLyQ7A8xUey2prNn4NKikW+WGRrtA0DLqoD2ZqIeh/TamjNbuswThZV2vWTg7hxAbPQ +Gt5IWoeiQ4TW7u5Nf3wsSAFIkxFy1Zi2ehB1V5jWKu1XanajuW/Zo1LZptlU1qdueDSavt1ZfxzN +XoA+NK2zWr/MW/tkJ3AuYvlMd+Zhdmp4O7ozZRjn+OiL+eJGkOowXKLcRgxUa57rzVrt4xrZgFFW +yV5AIx1dNvu83KoypNBPt3/R7V/yQnZ0+d27H/+rwc4rDJRpzxCllYphaPVGY4WY57hENydeuN/u +X3vBnHwnjvMcp3vx6Mvh8MC2ci+a8HLH9nfb/ceev6trwzLZP8Qeji53Ni+BxjQdVCp2oaArcq/Z +ucpbF6KYM7SLXLadsSI1qZqH1A7THZsokxZo3bDGUP6i1JSkVohMz4+jnChSw9vToL6kDBCkaB3I +Nl0f2O5O0oSBfRs3TnkloVhT0eFZFn4wJpXjog0cYrP/GGZwc/aDHa5pLnT9MaBsvn795NXPz979 +tje7NoP5zuG745sf8+GjMu2Y1rQ7eBnEe2njNMjWYbpstY8Ozr4R5SZFe/X22XDn42zzVZgdW/6u +rI9EpWmSOk0jWY5UpRHEB+3+zfHlT+vDT7AGSO1KzbGcBcyX5c1WR19uzn8NeoqyQ4CbpPRoJhLl +nJdSlosanaud42+Xxx93T3/oLd5LxhTWBly5d/wp75wDIrz00A7WUXZyW9MEid8YDo6+/fEv8XuF +DjVrZrpL+KBW76YzfBMkh5AritpP0mPH23X83bRxgSeUa/b2NinatVi9tP2xiGQRG7Lc9oOlbo04 +BAkdiGJ8fvVhNLvgxDiu74+Wb1v9x3F6YtqrSs3f3pZKZc33JsWibJjd7ujR5vS7H/7s3129/gf1 +9glwQ+a93c3LRhtiHvxFNhtB73ghdaBk1E6lapINech+41ml6m8X1Crl4a+G0Qn8nqmHQdDxghGI +j2bInt4PH3IPHtC1qmNopB4WyzkUbWhGh2ZSjm3CjAQRnGOnXDJNvWkajVpVKReUSskybXAo+b6q +orSD6DBvXdvBHi+3OSG3vaVmjQSlDcjyo/3u4Fl/9iZuHdN8UijqgpArGvzyQHfITj6twZWf7OpW +m2M1nlFVNQ6iGXzlgnxG8/v9q59EfQTe1PQ4jQdpCiSHNpvDdG+Ov/nix3+yuvzGSjcQD1Gy8sOx +JKdOsNrZ//j1j//yq+//1ebsd2SjMD7KG/thdqCZQ8SeFx044dFk+WWzcy2rHZ5zkwRgtecGU9wk +tVeu+jSXuMneYu9jo3vlBNPF5mVrcCEoLSCbrA3i+ulo+aEzfoGBiuPxzes/2bv4TrGHZrjy8lMz +3Ljx+uD869nOC8PqNZt7i/13fnKY5Fd+emr5yyjdnc5vDk++NMk3+4a90c1g+qwzvMJoKMYISrhc +sQx9GIc7DGPBr0lARW2Yty8texnFB66/otms3b0MwhVF+aLU0u150rrqTl+Nl+8MewgsxYltjr/0 +oDzJzofzGpOjRxyfqGrbtrrlkhz44073IMmW7d4FzC8pSFEzIn+UJSuISZ7PAN1esGvZU0mGBWiA +98tlPU52bWdRLjtILsgPwyZ1x2S1S1FmtSLk+bLbP6fZ5I/IXn8mwwDxHJ6rs4i0mlsqK+PpxcnF +J9D9wy0FT4DW0rWRpnRZ2sfBt7Y4hg44NlONXrEo3X5sGoF8NWtpuCtIdN1dBdkpfF+N9R1/2Wyf +r/c+7Z39nPavaLFeZRLNmLI82dxVN9vzndcvvvrH67OfvWRTo1Rd9gw9NS3EZD+qb+q9y7AJZjyw +vZlp5YYeampg2u0g2QmSVW/0GIYx6V34rdMwP07yPd0EZqYwy93x5c2L3zx59Yes94zjG4besZ2h +KGfQwM3Oo6R+FmXn7dFLPz7mBPjfIIlIPa9qTRHEyPF2eL6pG6N696LeJns+O25/tnNt2H14YWSN +H+3NNx9Hu18F9RPMexiOJsunUX2XEeKgfrw5//7Rqz8AvnYOP7nBAh5nMYOHvWb4uuPvT1df3bz6 +k7cf//L82W864yeikHRam5vnv5rMrjkhImXpmFBWe3G651gTQ21RNa3RWK8PPjjBjm4BLjBudcvZ +UfUpeoE5hWiZz18uN++D9BD+TjVGNVKBwrXt8XL3paJjJKeINz87UUwC1BD5ZLf8smabLdduWVZz +OH4U54eK3gMG2g4YMC4UVZbLBDGvAjyVtu+vDGuu3O5GGMcrSe5Wa4hnHCpDFLFCA2+qWwPL6bW7 +Z63OJYb0swdsjYow8qWyU61FrNjkJLiGKYxSPT8Aq3JMIstdnsvxs0rKeZiEBaRmnO4LQqPKpQ+2 +xUpFR5BYzggwPpi8fPXhH7/66p+dPPnzrH1FMYFhD0JIpmDuxgdOehLULwbzj+vj35B6Q2KYZLO4 +vtPsX+nBfplvl6pRnhyulm+6g0tRjnWzYTjjMD08AMuMnzC8U6UV8GaYQZCTEkUIad8fz9cvd8+/ +9fIjxRrzUgvdhF6S1CzPd/L2Ud5/gjEHJ9IMZs01LQI4ujXl+NiwRs3es9bgtRue6Ga/UlW2C4wg +Ja6/rlFkt1vTGmOKSb2SfJNlK1XvCGKGIMfsGM7Ujfbbwxfj5Qc/OSdQw7pA+5tnv0GY2cFYNvqs +1OXlrmFPeiPI+x6c74js4Pdx9+DlfPXcS3ZZuQktUa/vj0dXcbKsVA1INSg3WR0ZzgwCabuglcpG +lq4WO095ISJ7GvCJG6wOz74/vvgZgqdSdQ2j9/z1bwCAgFPNnJj2st66yDsXEVmhalarVprvdUeX +otbcLhs0V5f1CRSg6+1qSm5peRKOzx99ShqHNJ9vl2zFGHNSV1AGje41EUUlJYuXk/Gz2+1xvK0t +qVBQBKmtGUNBapRKBjIrb58M569Gi3eWO1O1AYINFA+YNawdik4tc5K0H3XmL8P6IbmOiEtqVReB +5BjTfve0UlHIx9YPJU0ZalqPh+kTEygxEAdDLm6pA/NtdzCYXO/svd45eLN79L45OAf7a/rA/+Wb ++O5wsnxzev2nm9NfTdYfoVigE8iGHl5X0vIgOah3IOwfJY2X8+XXu5tP9eYJw3t4ghfBPLYVYs1G +ktqK0vWjp3/66qt/Ak6pklqNnuP1NXjVYCduXyrWbDh/vzz4znR3YNVXq+t295CTcga2l6vDm5vm +fLb8MFl90q05lAAvhI67AHARj8YlvJhD9HaH1yfXvxGkriK3HXcGqa9ZE3go6AfDmjgu2QCwShlI +LtiN3YP312/+oDs7xYpdpRzD6tTzfcTA7fUYGwTt9eu/unz2pxaprWNASU7m15P5Y0jfZucyblw1 +h6+hNjVzhoQtllRSPyVaVSpmqaTzYlPSRlH9sjt6/8uFRtWqzvO+5w2gWEQpkpQGBA== + + + vGMvHWeFFCBXqoi5AzssNSS5ifxChNSYzDDare6BG4whrlx71Olc9sfPQfGi1Bb4SJWSwB+EYU+W +A9fpI8J7g4v++KkbbmR9vF0walVdkxNdbQBARClXtX4U78XZkSS3wY8PHwqOPZjOHhlGs1jSwHE1 +pm6GR63Z17ODj0m2Zmmz29zd2byCW/zsc75Ytit0IhsLL73Km9cMBe3Hh8H09PTb7S3p8wdMqWRr +5jxrXwhiHVksqw3d7IXJMkkXcKBe0FVIaYxQlvM8P+oOH4fprm52wmSn0T003QH6jpGUFZLObrSj +Wl0vXKWNMz858dNzqE0oB8QDsixI9/LOY0AQ1HLeOXUDUqy2Pbhw4nWFjSuUp2rdvHXkh8t252q6 +/mQG4OKFoPVqLBA415yJYg4rFEh57ccnUAWKOsTgwHZBSiG2EbFQF7WayYkJJ9Sj+Nj1971woxgT +io51YyDI7QodKeYMRB9mZ3BwiDFSZaYiI4Qsuw/gVY2u4a2tYOOnx43BdZXxt0kNRA+mRlTg9Htu +uEaou/58vnrdHT7x45Wq5LBjEPDwZRSblaouy6WAxyA+gd8vldRa1ajRLsvXTWcVZReVWsRwiSg3 +VLKe0KdqOsc6sEVQiY6/A0MEcQtIEeUOHAfsA3Spoo/D5Hi8+ArjD+1xW8bLOTt6P+wfS2LE0D7g +UZYy5fZWq0iG7B6sLv/FP/9vA79fo7waFdBc7gQIoa4okG0oaFpP62vXHVOUh7OtViHMfIgowyBF +samaAYun6RPL27X8jaROy2WD7J9WMzyna9mDB1tipeqljfOwcdYe3gTpaakSfv5AhGazLbJCQlFu +o3kYZ6dAXYYltgvZZJht15s0WscmLK0G6kx+2TlBketBuEzrh83OKdDGC6ZeNBSVpEbK59mGMSLl +Y4K5YXeguBxSonfhp4eS3CP78PirrHV+cPWrkye/z3vXmHrbG2ESBYScnHNii1cGprOTNU6bvbMw +XtXzwyg7YsS6Yo4FQLG7qnefhY1LcBaUiWFNLZdc1EeugaRjWBte6ITk0q9hYZuvlhXHhXIODXMh +ysNKDWeYymofAclJPbzECQ8Md20H+xSfPSyqWyWlRjuWNZTERJUT5KafHsWNMzvaF/VBlfEYPpYh +lZ0J+AsBnNRP28OXre712dXP7d4V9J5v95CGgD5SZRXkYs4b7Uf7xz940QnLNcplk2VDmgnKt5cl +W+5Ktxdx/Syu469RsajStKdoLVlrV2mfl1uwujCYQXyUt65gRQtlsoe8rPQ0ox8mMMtnFVLS1Hf0 +Qb9zYuoNTDdds8nuzZRTKRuVss0xXhoMR93D5fy8ViUbYZH6GmoXlhnDVSoBnWieD5vdK8xmqahq +ahfIAAOr6X2Oq29vi1sPaV3NLXvOcFmtFtCQE3RIwzySmm4ZQrFYNC1zNF8+BxDRjI+7haIjiB3d +mGIuikWr1z34s3/4r9vto4cPpa0tR9EHgpgyrEN2oVHItyFUpYmopmh4xlzTWqrWtN1+GM9df6ob +3ZQUrLyAJCNLLmQHj7qk5JwQsJwvy5mqk2sJOCFTtVaUbLrjm9HiWXfyyI0WqoHx79BsUKNc2GFd +HyraxHAgpzcID0XvkJplHFlFHC2+zHuv651XcePGcPDCriw3NKMLEscvzfbTJL/2ggPc4OVpLiwW +ZIENAw/yOAzCgyS9Mqxd4FuSn8XZBSs0HbuHnBKkliD3dAfBNlKMWZafZ/UzFtGoZKenby13BPlh +uBvNIZXrk3zj+FNehMvTPX+eN89EUv0cwdCnGPggFbymqBlFW6qWg+wUDd0ZIoaLZbdSDRV1lGan +yDuoLIoKJLmDYVH0kaSA4NxSxVWNaXf0otm91PT2l9/8xaNnf6yaM0kZqNaUEZtlinhbRetRBPd8 +ZJxhr6AERC6plM2HW8L2tmZbE2ARQohcoq6Ns/gwjfd0fVAmO/WpNVJxzy0W+XJRAaqIKk5vBGyx +nDnNpNvbys7Oc+Qp6BIWr1iyGSrQlUYSzXCEzx/wDx6KPF8HKpZLTmFbK+MJTN22FmGwA9YuFOVK +xYCagiqD1hXFFk0nHBd323vr9QtRbJZKvunsE6MnNGgu46QWJWTbFaOI0aB925rlrRMvJOYIkoki +tWBMTauDvLqj13n7qWZODXOs6v0q5W8VpEJJZ9hUUjqwyRgNUY7IzkJaW7enqgF7OzadMcXHODiM +jyw1BQFJbclK3SQVsef15jEpT2P0car19kVUP4JAIvufB4skP2h2rlRrVCZFuDyYJrJLktxAKmkq +jM+kRT5H20OQV6s2OqjDJckgyrZhDk1zDE7Msj3DHJB6ZEzaHb9JGo+98CCtH6v6CPTkWb1O55Bi +PFFp1VtXSeMS74VeMHxSqKgQoqo+VpQucAbigaJzimkgVSvVoFjSacZttvc1s7ddVKq1wAkO4hzi +4TxtXMCOlW+3Z+TFBt66VLMgiR1vnXYuZmuyGAIdi3Sup/Nf/fHfnl99Cd8nAbucpWrNRLXrQ2DU +D1k20fVmo3NcrjjlioXcgRCStGmQXmWtm2JRc/Te/u5bUUgRSDUGAiOusXmj/3Rz/G0QLQvbnCpm +kpAhnTHs0N4QV1sFkxN6Uf0CMFgsGjzXQO8wqhgKTW2Qa0qFPGue9cYvKhWHqoW4iTzGeQ/BzLEp +5Fal5sLTQUc9eMBVKq4gNl13AXYzzRFL4hY60zOtOSfCwe0qxhw32ZjWuLRGB2Q52hxDF4lKx7QW +UQKDPIS/kJUG/KkfrAfjV/XWI17qM1ybYlq80CtXgxodQ04IkBN633Zn5IJtvYPjQ12TC1DVdqP7 +yPZXELcc3qWGAFZlOSS0q9Qtfxzl++PFq/bgqUI+XMuBkJbZ6Q9O5zsvmoMnkj7A436w0LU21BFE +qWv1dK1umRkpGSOnEKXkwyatLQhxtWKC2dNk7TpjTWtbzkTSBrzcAwvLeg8nyXChafVxnlG2D7lo +2jMEgGmPwmTNy7AMGTRwa/AsbV8gWjRzeVsCEjDSgcJEBgESbW8fR5O0jhfvVpnw888pAGBWPzHt +CQxguQo00AE7y82Hnb2vELScEDfb5zhDIKFqdCo1B6Ki0T7ZPfxw+vS3MMvo3XDyGiqRFeoUGyNO +AG7FkqXr3Shd1m595W32TQG/vAh155RKmoDIVzulogx1R/N1UYXkWMb5iXpbUxu2woLj5lIgjO1A +La8VZQLBgAg3TbLoVC7pLJ1sbQs0UtKZNftP8t7Nzbt/+N3v/m138PzhQwVohluxoEOYAd+qVYix +0WD0bDR/aZELqp315n0Qrlm2Xq6FZabOK50k3794/MNf/M3/SHY4FNucALE6zRqPLWeFIESyIJAk +pY1eWBbk6wFygeEw+BPLneiknMoUdq9Kp4o+d4NTLzipUgm56IKJOSGBLvKCDTAHWGE4E07MWYEs +oLUHj+wAx8cEgUwzVUW+4JdQkmLLG4b1zfr42zgHQE1Nd6ooDUPNHKtpWiAy8tlNu/+o3jjlhTrH +hY49sswuw1qlEg11yrA+JmW8eAMooNkQ6WaQL+N0GdqGGlGUlheu8+6TuHkOcKhSLiYaocUKkWYN +RLVHdE4GwDkM0z08gVx9ESxag+usdQHmQtJBStnuBt6NZUE0puvtdAYvdXuiGD0r2ClR4YMtnmMC +xxlRlFWtqJWygve1nVlv9CxrnNyWY866w1PHg1JNDeCSMgTXQzAcP/7x6uWfNHuIuunB0UfkDoLc +T/Z1e450VpQB7DzDevDCtjP2/CVUHOIEKo4Xcknpy2oPKujhQ6ZYVEAcpYpTqXmcmJH04TMYgbx9 +JcttyPUwPFK1qUgmN67V7O0tenubY6hQFnuAX1nvt0fPz1/8+fL4+/HqHbRltRo9eABaJF8NgPVj +mciyx0l2NBy/hMEE+8NxQJUdnX6bZofVWsgILad+tTr9/uvf/NPf/Nk/++LL31NcLIgNyDn4GstZ +AGQQVLfVRVeWt1AM8F1YqgYVUjyuDTuM5MI5w76JahvIKdyu29OECtuISU0fQBqxQiJKTXBWSkps +PNfMEcUmqt6rMR7FgigHqjbXjAVyX1KHvIAAaxvkE+06kE3WJ4PZ68HiFTL9tl8xVBzLh8AZTkgZ +DgA1crw9x10BPeDjymVZU5sSqXiLkRwZ8AXNR93RF6raq4LcC5JMeLMhSIlidFR7ZHg7TrBnOguG +D6s1ndSNSvcnq3f95RvNngtKlyx08JGiN2WNXNUGOwkfMVx8NVp8JcitQlGqVCxJbglSStEOlAMv +dU0PAdlTNcxyvLXFVcoqQ76woJMvshmAkRFeaLojP5oJcmq5g3b/RZI/ivNjN5zCAYlaC1Dp+bNm +54RmfY5Po+zEjVYAPY6tV8pOsaRQlK2pLbjCrQc0SN9xZ6Y1o7lmsQLlZhNFx0CWyFvbEoSuorY1 +HbJqRzdnstK+rcoK2PELBblWdRgmrlFkk0OYI1UZ+f4hZsf2l1601kzQULxV1LeLniCNLGecZuDl +nXIZw1i37ZEoN0GphbIj613Ln9veKk6PgD+AL2i5ODuP032yL72S16oWI7Rldaxq4woJIQc3iolc +bwG/A2x0M7JeVKWgkexiGXIr0a0dOzwyvbVuLzERDMSe0EBAsnxWpQLcwHeaQfb4FcSEYV1e9Pnb +JCLfF9O6CEX4cVg5KNvx9O3ly380O/4B8hUCGJEjyXhtRzFalj/rzd+l3Rs7Wkt6HzBbg8yoeRgQ +EB/EsCQNbffYC6/i+pWoEPAvlERN7/UGz5udG9vfY/imoPThghv1A9seQOPBlvZHTzrjV4IypNiM +l1qQ2a3uozDegfDDX11/uX/87eXNb01/TgsxxQe2D1u6A25C7xRtkDav8+4LNzxCthaKYrVmQH0B +ZJAjeDuMpOGsZX0KsefaQ+CMLDfT+mZ18Lo7faZau5zQLVdd2DrTGtwWznZZzvWD1Xj5xXT3w3T1 +npc7CINazQXqIpwARJWyS9OZ488EKauC4Aoy2fJRbopkmz6+WNTLFd92lr3pM4pPCyWtVNEB2hwP +r2Tj+WTZakthbxMfyQ56Zcj6ecewxrd+JK3UQpptiMoga16gp9sFDbax1bludp/5pOxFBH1bLCsV +UqejTVedhw95iopa3YuLZ9/3ZpeiPmaFFsOlLJeH8T6p6is27GDTm7xerr/nRJiXkaRORaVP+L1q +lyoYk1avd73a/3bv/Le92YcKFRVKFjkxNmMBa3JL1Ia2fxTVz+P81HTmwEYiDMp2jYZn7Hr+MaTa +7e76RD2Wq9ZtSZ0QiAdnLWlDSUWOd8JwlTdJsXtQbRAdt7pP/GAXhpQTfNPuJ81DxZmqziztPNq/ ++n3ee0Y+lSvrpLg2F7j2PEnPYCUsf237G8tZev6OKJA9xqs1p1J1gcD11pkX7d5+4D4Q5b7rrWAT +aD5nxY5p74wWHwaztwhCAA7ZcFiHVBtn+W5/+sSOdrvTF4uDj4uDb013jaTG1DSa5w== + + + vfFLxVhy4kA3J7qJXrQ4kZT14QXM/u5o+f7s2Z979VOKIXJClKAHJobdM5x22tpzoiNZJQsjSCsk +V6kMH0fWB8gW6NHMj9deuA8JZJgzQ59UKl6hqFKUz3M5+SmkSEyAv+0tdWNG0THQ6eEDytJ7CiHE +DAkOpdEePB5NXwDQapTGck49363nRw8e8gB/QWpU2YSXYFH7ZGm3eLsHpj52/f0gOsT76iZYoFWt +xo6zgcuuwZpti3gmxooVe6C/GpWWSvb2tiSysWm0yYcaSsfw9yabbw8vf24BBMDgchPyfr55l+SH +IP0yoIBvmc6eFx8BfKq0j0iQpGazedjrnfWGTzC2pUpUpVJgF7ClUNZqbCCovSA9b/SfBPmRas9k +9Jdr3Mr49NZitBQNgLwSlQnLt4oVUucIoKRbw6R5Gjcv09aVaU9lpQWdwAlkFiwXwngXcAQQtuyh +ZrRpPgDkIh/3zr+7fPtXbnKI6C0UtSpZwevpepsh6xgOuCZMTwHFnr8ulWC0VVhyhg1ltW7YA1ZI +gWk+WUeFSZzRTAzY1KyFbs39aCMoPbgty9u3vR24Bt2E4O8ljcPe7Obsyc8nT/447z/hpAHF1qFd +PW/ndiVqYvsHjfZVkB6Ieh+et0ywKw2jnRRSLTsQjQmv9DVzFiV4011ehkvqT3efme6SopMalVTp +RDXmMKcEqLmkVJIEMcqb+2n9yI9BLj2KhqFLeL4RhJsw3KsRQ90I4wMn2MjGiGWbhaJTKJocG9v6 +kKEDUu4Hnq511hs9ibMjiOca44bRajh6EviLzz6rQogGyTrrPPbiC92a0nS0tSVVa16SHlv2jGUj +hkmhJG1ALvjR23fcXcBdpWwJQg7VUQJiUBGvID0HPJdJXCrCO2g9J1g3+jf9+esk29P1kUKopF5v +7C13n7NMAESFGWHFlmLNaly9VPUoLqO5uq4NBDEW5RhMrRsrWdnhuF6NrlfpqFjRRbUj3V6tx0iZ +bI4b/ee7539ozd5B6iCuQD3Iyjg5GU4+uPH57ecvOdAMiQNUvy0xPzO9DaYbWo4gs9KuUV6V8hCW +ij7I2+TL1zSbILsnixfDxZUTDWSjC9CO649ARpKc6XqrRjtVynKcAV4Loq+QheWQrGYLeaNxLBtN +2+3sHr8P6jBcDUntk2+aV9waHbrhjm5DpaQMn0LA2+Emqp8R6cUhL0L02vFGQTxwvJ6otkD6O/s/ +ps0nmPTbUkeu5c1lvcMICStmcfPw+Or7zcnXSbZrGi2oEddbDuavZIMkFMXksDmWtztavM6awAGX +gsDmcgSn4a4Va15jMeBQSrqmd+JkBfujW0ugou0drPZ/COMjCGBJapcrUFl905yJEux2k+NbqrZU +9ZXjbmg6frjFV6qWbowqNR82SlAGnenTfPS6M3qrm/OtbWVrS8bIw3ypxpAWmjgC0iqIT1wQhNqH +KdguKoLUAauq2pBmUic8skKATAc0yjEJMLNacW7V+KBcdktFq0ZBz5DP/SEkZLXJsNF2QYZ/NIyZ +7czJxx8ikDZsNk4EyDzarQlplU0ZoYksVrRFnJwxbKxqXQORoA8qtXi76FaroNRWEB/EzVNJ73Jy +nXx9wF4MJq835z9lvWvoDXIdC5+RWRPrImSV0DGcI9s/N92NakBgJLdrsL0kO98/AyZcQ1RDhpUh +8FjocFhyxFgAJV9vPe+PPwTZHkcuA7M5PpLUrmIOGSEtV3WaS7zowHQXstp6uC2SK46qpIYaGB/U +wKBrQo4ED7Jj2Rpvl0xeaCHvqrVYlNowgCA4WR9nrWtY9ULFAgiHyUFcv4TeCOKV6494MfKcQZZt +yLqEOy9T0XbJKdcCQI1mDinOK1N2XN/sHr49e/LD7fXbTqkCIRp67qLZPufFHI4mig+z/CJtXHjR +HuLnwYMqRbmaAQOb0EJuBcf1zpvB/GvLW5HPrZhwuyDRjI8pU4gKCgrQ0gUFMOt4K9ud02wEhG91 +LuDvtgpGqRpRXHOrZGNqoGyDcM8nV6ecwSAzQkbxnWItLVRiSZl3R68a7RP4C46LwFP7p99dv/qL +Vu8xvNh20dguWhzfALoSs1bxdGv26ut/uTj+SbUXhZJTLJiGOW13nkDl/tF/Xv78AS9Kvc3jP9+7 ++JUf7uI8wTgYB93qI7ArtQhSQdLWzf4X7777+zh7ZLjLGo+TyYEtjAirAt01V4wdZEcY75pOl2JM +zHilGvNs17H3Jot3RrCoMF6arY8vf+TkjqT1RaNbhYYRepBtyFPV6JOq0EIGTdsbfRwvvk8al5C7 +kEACnzrwsMnai3CQbLsChdzzvPNm663jHxdLEJ8+OtgavEyaTwStV2aC8u01IWS0S3KhqPB8FmeX +efcZzrxKe9tFlRhtNoEEhS7VnGXee3pw8aez/e+d+KiKtyiYitwrl73tbfLpCYaUE9tBcnr9+q8n +q48UXJI1bHSv6q0njr+BPSzVnFLN041xSAoxx7APZDVMHdSbl/UWZqRP1mEEggOK3hWUBiviblOQ ++6LcVdQOsUIVm+Hgp6YQ+TQb426lavN8ahgj25mQC4+tkRcfNwcvs9YVWLJAlsSh3n0of4YhWyFB +rhcLKi/kngervob7K1Ugn8Ik3UCcFwq6Ya5Wp78K83PTWqvqBGMS+dNB/4DnnYdbrKhOTfckbb0c +z7+1vHW5Zm9tiWmye379g2bBStifb4nFiuf4+1DLwAqYdMiqiHyv6tANdkpVC/nIigNVn49nH/ZP +f+aE5oPPyeoovIxijSFLHj6UYQEQNqqJ0TuDQatC3g+eYVRn66/D+kWxkvzv/4m0J/9/n8D/V+2+ +I3et3XfkrrX7jty1dt+Ru9buO3LX2n1H7lq778hda/cduWvtviN3rd135K61+47ctXbfkbvW7jty +19p9R+5au+/IXWv3Hblr7b4jd63dd+SutfuO3LV235G71u47ctfafUfuWrvvyF1r9x25a+2+I3et +3XfkrrX7jty1dt+Ru9buO3LX2n1H7lq778hda/cduWvtviN3rd135K61+47ctXbfkbvW7jty19p9 +R+5au+/IXWv3Hblr7b4jd63dd+SutfuO3LV235G71u47ctfafUfuWrvvyF1r9x25a+2+I3et3Xfk +rrX7jty19uR/+0+krYX/RNofqerkw/PxzTc3n53NP1MHi/Qa9w9uvv7mxafP1p+p1/7g0zfjN8++ +efPlh5tPPwpNPBR4USL4By9uvhCMX54p4EnC5tObV28+4MHDZzdfvDAFB09t4f/Pjslxc3Lc4adv +v369d/MNXvLhlweHL/Ca/9vDxvGHDzfvXzwXbh8V8LAQRan5WSAM8P/Z9+SXF599i39CIbj97+xH +3Fnil7d46HshDIRd4fJRIDwnzz/4zM2DPBFuf7wnd+LUq2e/3F/9x/d/+Xf1H57//7x/+/wP/9fb +45+P/+EsQnIWt8M3ffPFi+Yvv9527v8cS8MkZzr7zB+/+O7NsxcHs6Fwtv7sUnBvR/O2I+SX/+h8 +6pEX1+thJjwSoiBEtzJyhNf/b19D/vzvX/fv/82FGGca1m9POhFuj/GZqt6eJ4mBppDFjSj87Gzx +nwkSKVrC8pGsthSto5CqLC2Ga4vKWDWnotzjebI3vyg3HXehm2PV6LNCVmNDvIoTM15qkCrKXKhp +TdMeBvHSDkiFLgWv1Ua6vaLYqFxRymWJpixSWsoe2cGu6a81eymZQ1aqV2nPD6eWO+CE3LSXnr8X +paeyMeH4tmLOBbnLsGmN8nmpLWlDRR/6yR6ntAtlk2ITTmrQbFCtuRyXWfY0To9Nf6mYA4oNOanO +SbFiNKqsI+nNIDuMGo/qvZd2dIiXU3xSY6MwPsj7T6LmeVg/SVvXprcW9X6NC2WtJyoYhKRSc8oV +g+U8XowUtSFrrXLVwHvxQqtKRzUmprhUICXdhqLSVvW+KLc5sVOvX4XxCSf1qkxUqjrlmkuzoeMt +THtSo90a5Wj60DCnpIweRYoaMWxk6ING44zhE44UleqXK/Z2QcFfaTqmGdxSWR3L+kSQh4LcL5Jy +QD4eZLmc43JFHUhyl2YSQWzX6IjsSM2lDJtRdEQxoa6PLHNKSu4wWanqbRUU3Iolo1xGRyJJrMsI +AMqvVi2ODYpFeWubL1X0KuVRTFSjYl7o8HwTR6tUcea+pHZpNi6W5FrNw0kWizrDpKLU54WeLI80 +Y2qYo/H4cdrYpWiT5XPdnHnx2nAmVcqtVkyGTnBASRtzUqdCRZWqpyhd31+5zoxjkyDYUfQezccI +CZbPVGOqmTNZzj13UKkauCE4HW9Ps1aiiuiaIThJQW8pr9VsXsycYJW2L92YlN8UtCElpLzYuHr0 +c3f0iBNTlk8tZ52334TZY1EZ0VxGkULlAcX4pCI97aO/pPavOqS5nObq5apTLJk4bTyB1CbSOoxQ +5+W25a6y5pP+6MXm5CteTWjeN5xZkJ+3xm+i5iPJnEv6GDNyevLTYvOBkfMK5Vnepjf+UO88l/SZ +qE8ZPq9RHoaR5VJShrFqbxfVKhWQEtyUXyhidjSaTQQEvNoVMOBCg+GbNNdkxQ6vtEgZT6mHMUQE +4ml4YY0OEKilskYqrJL6mWGNcisVm6r6NBUgwBBIHFtvZqdZelQoKIVtuVw2C0V1a1vEJKKznNiT +1RknDBiuq2s7hrEsVxxSFoPLRKmDKQMgMBzwYeL6G1ZIHxaEB1ssghOYYlkL05gjWcjRynatRnY0 +f7jFFgsix0SS1JeVgcDXtwsyToNlk1JZr1RNxFKNSgolr1qLKJqUmZLNBQGWqoleFDEIRZVlsyA8 +ieLzMDxVtVE9O/ru+787OH//+YOK6SxJlcX+tWKOyVbiSCKG1M0o12yyN3YNw5va/txyJiIiXGwc +Hn5ygnmF9goVXRRbWeM6ql+JUkMQo0rFuK2PNAfCMEKT4puiOna8TVI/NawJy/iOM663z5x4KRlt +SR9g5DVr5kd7O7tf+NGKE1KEpRceuvGxpE9oJuelDsOTeLvdX1wpo0eMjwTkReROS5SGQDZR7HNC +VqVsUvNEayLmWanhR0fj5XfzvW8Hyxeskkha0w7mVrg0wh3RmATpeX/8Nm9dTmcv6+0TIDDHpY6/ +CuvHhrvDyQNBRRf6HN8AvJAaqmUDUFAqO5zQvq3u62CCSmWT48lm+WXKK9EhhWnlB7w4dsJTXm2X +qjrG2XTXlVpQLFsPtzXgDMMmFA0ECwBTNEN+UjW/XDKKBbVUxFS6VC2wrYmmDRBRhYJaLGi/FEIv +FOUq5XNi27B2FW1H0RaOc2hZ6xqFqOjQpJBRzrCYgiEnDkx7nWRXgtJ+WOCLJYXlSEEwUWpzXB1Q +gNO+rRMbPXzIIbQqFZ1lQkHoszwgNKWoRJJGhj6S5YautZAI2yW7WA6B0hypQN5kxBED0OYTHHa7 +IBKs4+qqOsATBBGU1/f8TW/00k12Pn9Q1Z1hlJEiAzQpo9QBGrB8o3xLBEgrjIAg4Q== + + + gHWaTHHdMcer3TeK3qkxAS/mCqlbMmdFjKQNABGE3LanbrBkuFQ1+4LaEdU+h7xW+reVb504XvfG +N168E6Y7drSQ9L7uzKxghZ+i0uXFVp6f2MGsWNVLVYtlc91YCGIXEwoMITUTaMAX0t8pV70qlcnK +BEOt6qTGEcZWlFqS0tKMvm6PFYNsou9nZ3a0xyvtMD0Kko3mjJ1gpjiDrP14d//H3uQNxh85AjBx +rDEQdbuoIIQse9Vov8DsWM5KN0aC2ATskK33KQ/YVSybiAGGyUBAvACYSsF6FGZW6HHCSFZ3guQJ +Uobmkig6NNzdUtUtlKxCyQZb4SAAPYaLwGKC1EG+16oe0KlacXAjMVZUGfCa0LytFGQUS3al4iIS +HmzxtxXMEkUbVaiwXMGZ+JUqIDRTtCFGG4RIioABGOmAFVqSOsM8AtNkuc2wDvAHgV2jAUcxEJIH +jbLp1pZcLtmlkv7woUBRdVWb8sBboVurJbLUjcId35tuF2WcfKlCuK9aQ2x3VXPPj48dbwfgtrUt +lUoasGtrm9veFkUhbzfPDXvBSt1yzUNG0KxxW1y9jzkynDUrdhmeVJmGGNC0Nk2bHBcKckcx5o63 +74eYyi7HxyDH/vg1w9Ux12ANUhBDI0XScBwkl+3sJI0jqJ3tsg7QA9hq+gSx7fhLy5vX08M//OZf +nj39kZVTRoxlA5JsJ4iPs/yi2XmkGAPSCxyZjjm+q+oryzux3GPD3sPTOL6uKS3bW1boBGRdpRKM +pGnvGPZKtZZJcnRy+v1g/KTKkCrlXnTY6D5t9l80+s+dcBWF65+++ZugtSrWbJqUZethrCAPTHMG +eXOrUhyQi3RbgQ1Hxq1GiAD6p8kKja0CWybVw2KapG27WHartZRmGpY1N6zBVhHYYlWphmrsWe6h +5e4p+uy2qAsEG6bGKpdVUvqppFZqtgBmkXuYQZbJqtWgWgW5qOWyDgIiAqZkbhf0UtkFTiK0wCCA +rCIApCg9eEhBg5VKVqXiU1QEoMAUIGZAi9slpVg1aS5G0BrWSlaRFB0MOzJaEBA5AxwcOAPKKxT0 +QsGoVkOOaVTQi7LDMnGhIALEHm5JoC08n2GiLYKWGgOxR4OPHF7EsDQ4saUaMwyaJA+gwVgG2CXg +hRSFV2XFir5V0reKBno3GrwsVRToUmgGUghFyFmho1vrNL9O649dd6araaO+TvIjSesjwCCbRbXp +ONNGftboXlep0DT7mtGDXCSqQxnL2sy09xqd53EOHVuHLHGDHVHpSASUOm6wSZtn49mLT9/+l8vD +N5ycqdbI8FaGu4Jl+KVYmagOEeQAOuSFqo9sb9dy14o2NawluNJ2d3cWX8x2v6zQaZVOBamnG2PT +muG1ujWP48Ne95HtzRmBFEyWlB50YJie5Z0b09sJk/0PX/1VvXeCgK8xEbBOs+ZQ7EBU6GEgAMWk ++B2UwTIRqWBsToFLhEqEjiD1K1WnQqZbw61cBp4DK4aAzXpOCg4XShrihGFzim2Q6iV8S5SHsjLk ++Q5FZfjrVkEolRVoUYrygEuGPlaVviL3dG1C0Skwigar0lGhaJYrpHReuWwhxkolEzPLC41KzQW7 +bW/zFBUWi9bWFhhTpxmQEXIWItkHcXCgLb6JSBPFDvFfQhthRqZGaMpyF5oZx4R+wzFx/ggtiK4S +9DxwqWQQ9V7StrdVhBOh46L2C1IhfkSxDXqy3RWkGuQ9YgyHxYRyfFYpW9BsOCApl82G2xgEoSHI +bUVDHMalskqKxwIkhQaZC2Mnb73ojN453lpRWqbWXM6fDSZPeCmXtb6i9013Esa7rc6F5c+LZduy +x4Y1gsaLk2M/PPWDc+SsEx6LKuItUOV2q3depV2ocVHqtjrPR/N3s82H6d4XejhVzcFw+irIjqts +/bYiSi9IjpPG47R5rVtLnJJhjUlxUTqmWIBJJ4gPk/rlaPZF1DivMi0OWktsiqQjgNyh7a0sZ0kc +Jd/AwGrGELKfExthcjxZfvDTIyfaNHrnrFgvkRxsQsXBiYB5wSOQ9IoywhuBOApFXZFaUbyB+UVI +YEYg7SxnT1HHVAXZfYs8FRczzpLqRn1ZW+AnhLHANTEOWwW1UDJAWzg33K3VoM0axRIpJVQoYcpk +ivbhwTHXUKqmPs2SU02bVmrw0e6tI2sjPCplmKmgUrXxkmoNZg0eOa7WiNonBYHLkMReFZxYcaH8 +uVu1AHiU1SEmHX4BkWBac/yEQMJdvJFlL0AfIHEwYKVs03RSLJrb2xJwjIi6ogEkpClSWIagYhl2 +DFxsFRFgZRNvxDJ1xBJEHc9mujosVhBRIqJxe0uqkdLxXYhS0G6hrGPQGC4oFNjPP69AwYqQ3FQo +y8DPEUl/e8rLzRoh5dTSB73+Yy/exWEtZwfam1fqst5wvJ6qg7NCslaQHEPx1vNLzVzAGtNco1SL +Ga4JHRsEG9OdlilLkBGZXcuda9ZIc6ac2mPlVpAeTVdfBdkhDXDQx4KKuN1xoyPL39ftXdhtPL8G +ccJniASKjXRr4QQnmr3Hq1MBXkkeQMkAbG+LtTYpJkbyVmoQMy3HPSR1CCkbeAKyRn+huDhSJ7Yj +Kj3XW6f18xob1Rgfsp8mFX0hsMEpJqQFZlBTB2G4SyMNt0Vobxz/1nRHFYifEiY9hLMDgOCnIPYM +60DTd2G9Ba5dIllMCroil7e2YdC4SjVk6DYUMpl0itRjh59FuAKREBi3Yz7g+Fa5GkI7IUgUZQhl +LnCJoXQYxn+4RSMaEVcMk9M0eCoHQTN0asBc1+wHD2tFUk0XiBfwJKGgSxFmtmkuTGuJ2QGHQjMT +nX9b2BCPFAoyThtvQbpAuIzHDQBI1RKazhBvODEIbFA/oc6STmqKlm3INmQEaLedH50ffbNVlD9/ +QONQPJvbUMtOl+VccjIlcLq7XWAffF4sbrOANQoJUjYhI6EwMR2VmgGnD1FtGlPbmpv2BNMK+2zY +c0Frl2saJ4ayUjfMLvAqzE4sb1llfM2e00K9SKo81RFgYXwcpUeaOSpTDuwSK2bgxxobsFIdDk6z +lnnnpZ+c6c6CEbMg3keYYa5JpWh9mjRu2uN3ZrjPq6SELOKKlfIK4+FVTnRhBRcGIkfp1VjEUhAn +R160ge8gPq5qIzHBSjh53MVMIVtBjnCXmjGO8gs7PBBJlXVSgw7OzrSnhrdTYcKtkopHFLWP7MNY +SaT2MqlgL3A53mKLTAGFSYQioilf4FLkI2YcqQ1krlIOhhTRgnlnWaRkhpjZ2paJ8AZq0T4Ydpvo +FgP8QlRTyQSygVXBgLyQ14hnjAnzkkKyiDdYUQgtDXFVo+xSUdZVmKPRLVOjj/bWtlat+JhTuLOH +DyscG0pio0aqhPkFECgBGVuRh7a7B0wmLFwxfqm+S+qCMjG8LWAKofLgYXW7wCHwYHh5DtRmII9g +SAFfBG2k3IVZFlq3qx/CA1JhW0NfeLEOo0SqI7KhqjYqVXW7QG9v1wrbdK3qqErPsacc59FVzXP6 +UJiA3FrNJXpPyssIA86TlRyTBX4ngwNzXTHJ4ps5kfRejbIsdygoOR4hCzUQqBSBjqx5YzhLqIIw +29RYFwNeua0iW4VqFbMw2fPCteWMk9aRZPQFpasYE3jSKiJByPPWk0bvKSuCkTt59yaon6v2Arar +Supz9qL0LG6dA/Sg03R/UWECUvmzTKqugQ3D6ABIiy6Y9ghhAK1C1G/Vp+k48Pfr+YWs92jKbXZO +zWhcqqnFqlVC1xjClcPxq+Hyo2RNWT4Nkw0ngXegRjQoXkwlaCuNjgxjXChJ1arG8/F2gUemY7oR +AKSuKZ9SLChVYrgQLrJGRZDWYKti0S4UMV9tGLRqzaqQG1kWqxD1QuJwa1vBk1V1CpEAx0FzYZV2 +MIkPHxLBU6mAnlRBSGpVSxKSNFlQLIAOriG8hbUeVYuqFSCnVSgIkpiztA/gAmdRVEyTMrYZqVFJ +VnQxPhnevVhWSxWdlF4v4cR0MBTkU7GEXqg0491KLPHhQxY4DIy69QiO68y//PS3ZHFsiymVZMg8 +PIi4BRWWcHAq7HROu70DBFW1zMuCJwsx7OdttPhAKoHPuv1LeDG4UcTtLeIFJVIE2HPs0e3SilYu +uTQVMaSocqqoXbL0JDXG86eK2Xm4LRXhPYkkDmRt0Ow8UY2xY8/Ob35drCpkjYuFj66LYkPTewgt +y5l2mkcn1z/q3qR4GxiAaFHs+sHRYv1ja/iSk9qq1vezA0pIqkwI5pIh4/1No/ssbJyl0e6LV7+L +musH29wtPpPa4EhG09oVlSHsfHdwA/1cKJjQDLiLv9rOEjaZlHPnG/PVG9mqP9yqAitIAXmprujd +2erdbO+j5sxca7y797rCWA+3altbrCDmpNim3PW9XRAW0kSQUpYLb+lJrBBIIb4Y0c6LCc3YXgTc +Dn5Z6N7ahteDw23r0GA8hFBsO2NJaT14yD58yMCng0duSaeu6UuR6IeY4oJiWb7FEw2YA7cFhESm +Q2659jDOlsWqfrssBqMBgRcRkipatYojCblrTxmEkJCqag+2DkBKalaDyEDcbNztXohyDuxCRiAU +WaZRvU06iHNElCzGlokYQ2hJAORSEaKLvBC0Dke5f/yxTBmlgigwIQwIsGtri5x8uQJyydP6oRfM +igVWYG1Z9BkKzgI+xRKlpmlNAHeKPoJMKoFMy2ahAP9iM5gIKdeNHiAdFFwpeywiRExIYpJozKNg +rz+5kbU2QJ4lq39I8PBWMGc0WS+dnF7/VGFsUazr+kCSWsAxQWpyQsYJcbd1ePPmT914p0zkaIrc +MfSp66/rnUvFHFVu2VyxB0XKktRmlh9yUouBERYasj6cTW9+94f/erJ8gveVxTYPTKM8hKgkz23v +2HTWUeMRIw9gxywDCg1IC35P8L7QsZoy8MLdKuNghHUinNoU49KcB+zllQYv1f8Pkt7DS5LizBf9 +Bx7MtClflZXe+8zKqizvva/uau/99HhvYJjBDt4LFoQTkkAeOYSQQGZlkbcgIYFAaLUrIbfS7n17 +3z33vC9b5+TpM6YrMyK+7/uZiMioQnLqppvfGwjLIyPBMKLqZhOQFmI0Oga1I4BUU7QaWB7AnBCi +BoNSCDGAFODO0HFNru8cvyOAglsn9takNPgZCllAfwA1utFYWrm2WF0HThkZCbhcGGQCkMvoOA3Y +CzEiqDSAA+g64FNAG9DG42PY6CgKio5nSopcI5nkmIcFxgSc3D+KAYMAKdNEgiaSPJtXlBoajhha +3ecXAXb27w94oeOOTragTk2rR9L2P2HQ7ab27CHt+ESg75Am8ElRyO59FzdIRCdzIMFAEMIFAYIB +HBkNgaMRuQrA49VXuUZH4OZgBjMAtuAawEKOjWFeR0pR8Gj4czBgAnbtLSJwQQS0rrh/FAWMAmYM +hy0EnHgoAm5ldMxJ4HEHuGgkrCOIwdDZqDVk5TqIfOc7NoOq31kRE0KoCUlF0hlOLA== + + + g4Wk2FwIjSpaS4sNMBLMe4Kk0yhhE1RC1WoEkx7zAp2JjuT2is6XDANDeVngYopOwzjD/YNYDCOT +AIbjHrh5TFJaieySlV0RjD5Cpjx+GYDXMeNedtzLYWQK3CiKZ0m2EUQzijpUtD6IK4+fh3hBC2Hc +3B5wW4YjlX2K2wcJg4yMBuBnGNqpDyL2MBJt2okOiBxQOCyE0hUaHQvCX2EoeL5B0mWcAr+pg1QO +hlS3l3aqCfwvk4ZENYwpO7c87iw5MVBQY2MwyFDd6Pg45vVyNJcT1DrJ5J3Zp4DocZMuFw6BgOgH +nRkz2+MzQOTjeFFWZxEs4VhCLyguCAcHwt7jdebucKpkRBfATThMvfcN86MAEeNU0Cf4PEI4ZJp6 +C5LB61UBk0NB4EfO55XBj3j9zroYwxTgd/aDzB4l4Ll+v/PdyKOOdCQctws46aza4IA8LJ1xPIhz +EXB5fRKKpSFJALJCQXCjIpQeeOTRMcqxqD6nMQxVBKJ3j7M8ld8/gl51Fegu5+u1HXHiBurHHAh1 +JjRooOMA9BTLAmwCeDqTHuOQWqbzBc5+SCQVqNbhGqFK07kAKBZEZ/ksSkR9QT0QjvlDiRCa082F +eGZbj8+DYcGJBNAowAjkMEA0kKA3YPqDFrA2PDQcirBM1huUKDrBMBmaLevWrKxPIEQcLDxodQwc +NBYNoRavzmn2pmAMQ+AWg5EQmgw78wyWJ8D6QRwSmXhqg5c7oXDKGzCgtMOYDdgC5Q/9CgZBxZVx +55ve425ngohxPLiHA6Ql2BRCRMJkDEHBkdmOrvY7xRhCdAQzfQHITx2cBThWBEsBCzuriuEokDVI +TejRnrXPkEwFCSfRcML5uvuRkNcDw4iPjPiAPb0BDfRkAImhju6SAFIgoEAQ42OEQ0PgE/1wwxSK +Q+7FvIEYiuUoMh8ISk567E2WQoyCYTsMTwfliSYEvukFwTOGhwJqCESji/a6gZLywZAdDEZ8PlCb +kDAgmC3IWwQFAZ+TxKbAlQEifB7Z7XK+MPmqq8ZBRI07mofYPwKF5kyluh3za4Ld8Dleg9k3ggKK +ulyiywXNlnWtAQGCrA4H9KDfWUgFMISOwKeA2tBQOqJMgdkcGQHBRoE1vnpfEADc65WcCTpgWzCP +PsDSOEUVAFKA+l3jPHwQwxIeZyqDcDs4YxB4TpJaMMLQAIpMWtFeCDOciXfEJpmGpM5E4+uc3AYj +BqNhmH1671uLIdwkmeS4Esc3CDILZDHuYiksFY1MeAIA0Qxwsah2M6VdPToL+eP1a4LSI9mqU48+ +WbWWRGMaIdIQrDCWFNW+EpmhGVDCUU4qoniSE+sBxHS+IjgETj9BMYUQAgNFgt4DYePxRTx+y+3T +3V5gNJskQf9kIE+gKBDCImhQVpUA+LuAOj5Oelw84yChOToeBhJkhBLFF7wBwCtnwpAX25LS9znI +KQSc1UCg3QS4+1Ao5nJLoJMRqCAfNzIaBP/lfH069BRYA4bOp4VDQAqW2y3t3xeC8gf5DWpkzJn1 +Ag7SKKauKDOi1Hdmiqh8GIUGoI7L8/KA6qgjqJK8UPf7hFBApHB7bBQZAe82SpFYGT4CjOnUPqhf +nwJiIxA0QDsBN/l9Jook4CcSsKHQrr7aDew2PuasTu7bF7zqKv+Y4zoBOlQAk3HAlqAFfL1vP4Yg +iWAQRi8eCiVVtUXToGktiasEA/o/paN7nIGsCwUi4FnCoejICOZ2nCYO8OVxC5I8gFHam75goZAh +zVzOQgPwsuh2wmQGAqBUI6PQyDEamAii7HY7ixEgxjyg96iSoLSdzSdeHiPSGJEJhCNgSUbGccBD +qB3N7AHNeZ2NJWYgBBwKyQm8wKNojCJzHFthBVD1WBCRIMokl8EYZ6mIBgEv1hmxEXAmi0DbAIAI +cNtxNw2ECIIWZ8phqugP2O3CVmdw0A3E5xEgk4HCOGcvEPCpNu70iLejfbezkKcgaI5mK6izkJrG +8Lw/ZMH4L8xfmF08Bx4NZNXoODhxCQtHCCweUVpo2Ag4Rj4OfL1/HBl1UTiZlZSOHpnhxRaoLJKy +SToxOo7vdyjAdHAjZDlXQHO24gR1goD/pZxVfr8MHh8kH0UUkFDS49GgZkMB3e0iwZqBKYNW7e0K +cGa3Rl3gB007Ms0yMbcb8FNxe6Fh9LgLqBZ+mUGCKoNHBSYD9OQGwQ+eCFLUBVQLmgdzNDACA1gE +YAHLGfBpOJIiAFrJAoakvR5h3z7fPiexScgE+INrjANTACLKD3YexjBgUnQVaMXtkeGnB2DQJY2M +g80U9xYgMpLYAtoCvwk9gsvZhwNgtR9xWgISDvrutAeSX4fSG3MIV0Sdr3YHKuFhNMA/4gRIDmfO +H7AFbgtmGfrudWIERIyNg8L3iHtTFlBu0tgYBWTnd75SHjIWcaadIQd88CkFwC0EDhRLEnQBdM74 +OBoKQQOAxCNBeNzeQjxoTsPoUXxm/zgGLMBwRYbNQ554fBqUs9en+xygJpCgROARaLDbpwDCUEyV +F5uJzLpiT4LogvxhuDIoB2ceBsp5DIMGIOEoiiXdHiWExIOh6BgkPETHzfn9OoJGNbNfbmxlS0vg +CJCQM+0DpA8ZFQoaIF/xsEWiMZbJwIAA7DhTsiDVPE5ic3yR5/IUk4Ec3pPB7N70vgmZD6QAUgqG +CBIGkAo0oSSWwU/BYPqhO85EujrqfJs6xEXx+eQ9smBhnPddHdh3tX98jPT7dCAOEug+oPg8PE1B +IHDHAgC9emC4BFDOXjcPYd2jdWZ0NLTvag9kKfyjzyNhoShNZ/ckGU8RCZCOwM7gbcGcwiMgnUZG +cHiEs2rgkCA81z2yD25O4GEdQ4xAIOIL2N4A9LEyMk7tB+72gJePQPKTZFaU6pxY8wedFQ1nknkU +vfpqF1BtwCf5vcLoKKQ3dA0sIYxDaG92NBoKRwIBxYFEPwiDKIbbzv6okOP7IMfA8wacuVzdmQFz +ChDIVxofZ6HSof2QqCEkEkQjLp8IAwj5Bh+BYMGfQVUqajMSm1T0XsCZfpRAtoH99AXYQAj8kQn5 +z4JG1UDwp9x++DhrRYck7UwHOftYAEKdVWAImQqWUBCAtmJ78/MgXUDgZRE07sx/4glnx51XRlAb +kAriC/AISt5JJAc0ZChYii4Cc0EcQe1AQKEQwDxiVFrS24JcR8JpgizCZ0GBjEHyA+DgyUBAh/SA +MQEk8QaiIIkhjsEADJRB02lnFRtJEEQBR5M+ZxUAGk8C3eytNdNgf0C1evwqjKQd6xWrq/sA2Tyg +e6N7e6Uo4KmxcVD+0t7qkgpBGRuF8ifgp7OiN4Lv34+5gMu8MuQJcByAQwC0rocBLQeFDBQG4fM5 +G8AgtYCGQLrgI/t9I/shOQnw8mNOT5WoOYUTxtVXj+272uV1ObkEDQNYAMZ07a0ngnaC/wLTAX+A +m8BTEGfDSYViSiDVAMb3jZLgkR37s+cdgOygtb4A0LodRhKgVQD90JAV8In794EFxh2JCFnk00A4 +kbSzCwWnUiB1QmErjKf3VoqdxTuaz/NqnZWrLseKgmTVHSWJJ+BywuSGvNVC8CnHiCneoOIoecTR +OYyzhTKFhC2KSotiXpSLLF8O4xmCyhLOTFQhjOmqXtOMLhjkcDgKYRr3CuNeHvR5rX6I4dLg0ENh +fczD7Xe6JnlALTgL+nlnJyeZCTvbNrT9Y+zIGBtEHKUE3grQG5g0jKdorhQm7P2jIfDO4y4aMBNo +GsUzoJbDaBaS2eMFB0EBg4fxZK54IF/cZdgmhjtriFA4zhYUj7N0srfVk9nbaxcLhZNglMCwA/RB +ZXkc9FD8gRhNVTgW6CMCiedMO+xttnFmsEfw8TFntyd0TRDLnFyFGO3NZMqOTx8lfGAMfVGvDxyK +s9XE48yCymNj7P79KLDYnh6G1GLdoHwCzhRoGIkwZNrvY1zjAGsG8Ck4OOAaf8DZUIphMfc4fvVV +kEKesVEMEBjyH7QfhuXBfzmGYjRIhJ3tDUBernFmb+ew6nXWwaGPGHR5b3GKAK3id0xoJBCKOp3y +Ods/3M48P3XVVd59V/mdVjkUFkHCcdTZvWbDHwhIibAOaTnqlI/wz9QKBG1WqOnRCVlvS1pNi3YJ +Blx8kRZqrFhTIwPDnrVSSyE8G3Q2loABBCOcg+A6a68IVH0SQQHNZAeOsCjkJyuAT89CrCG+rACE +VaOYlCiVZLVFMiWKKeLOonmGF6rl8k46syxIFTDyzuxTEBxZHLQQiGRwQySVAdvuCYLwYKH2IXNC +aJzmy6zUYMQ6mDVQ43trvuLeTtccSqS8oJDRhKT1rcQ8xjiz3ECdnj3cG3VxYCdZscUIXWDYEWfS +EpBN46QKK5ahteNuMGJmEHH2rzJ8CVgV3CUgOWQXgHDA2d4DBqQJfQ+iNiQbqB2WzRBkLoymIWnB +5fkRSBJwARG3M1ntYIJDiEDcSAQjUiFosN/0hQyP39nAADozCE7ZB6Vqu31GmMhwQg1Uq8erOXOM +XmFv7wEJqglkLRhPBIkReIrEk5BX0B6vs4bu8I6ztBSG+MbBibsc2wucCzACcoX0esGdaYCKGArw +Avwek8SC20MB8FJ0UjO7UAiAn5CWBJ0Duet3zFGU5zPO3mavBIGGCGJkIUxk/c4G2siog3iQPM6y +IxCKAyMhA4BC1vu62TciPQg3OGi/z0lXZyk2YEIcKQ5GuJoqzmt2D9yQGunSYpWAlFDr0eRsprpj +JudpvuIs8iKaEe1RXAnwAXdmBpIQHUGpUnxONpoEleKlim4PGNHZnscIVS06kcguxlJTstnFmQJQ +mKJ2NJBVTJ6kC3u/U+Llciq/yIjFAGpBR0iuzkpdXu3RYjMMsSNTnFgx4xMARHp02ogvklwlhCdI +tkxAotI5AIS9dcloIGyipA0XJ5UkraVZQ8UY0FyFJPMYngHq9DlTFinE2bgog64OgLbEILLAy6Au +TGcZBUvADeEiGfiIszfeHwKcESk6BQkcQqMUWwIfStI5zejIYMb5IkFlSDYfxGwX8BpkIJaQ9K6g +NsNEwomRX3XWQPE4BrdlgAIastEh2DxOZ6CdGBUDFYHgMU4qi2oTSg+agZIpeBDQKySw3y+HgkoY +ARulUmSGonIUDBoBww4gnIIeQbp6QZH6VfgI/BX+V5GbQBYA9W6f6myw8enA4OBWGCan6nUr2dei +TcWslNrraqTv7P8JRgm6SDJVjMwxXM7Uq6bRxKiUPxyByPqcbWA83B+645AaAnqJCwRFWSsiqE7R +MZbPgYQGHweGXRD7zsY5HkYvDpoEuC8UjhFOgGpmcoJVaorVN+OTvFoVVMCutGRU0uXFdHVV1BuQ +A7JarHcP8EoNBX0olKHk1UhPMlqsXOYUx+ulMrOl5gbF5YIAQXxFjw4gr6KpKSs1RwkNimsC1eJk +BCUgyhbgg251Vasj6k3IFh8S4ZQGxedJLseIVV7tqrFZ3Z6NJOZlcyBK5XrniG5Pew== + + + QybBFIzYrGHDvw9lo08wmTARg1TBnb3xOrAtzSQTmdlsedVOzyQyc7LWAVTxBgxGqJBMLuDsYDT2 +tkYoYN9AbO8t/grOyx1olCBTDFsyIkNeqdNCnpdLmtWhhWwIMxmxBF2GS9Q7MFDxzIKVmFJjXZzL +joJ5RyyazXNSTdS78NPpoFjWrX61fcDOz3N6M5KctlKzEWcLdzuen48kepBdDJ9M5iZzlaVIYrC3 +sv/PzfYpgs1IcgXFgQ15IL69NwJygtICNnEIxeo7WUpnMBrwHAYTPpiStXaxupmvbVJ8GaAGozLg +0J0l+5CC4TFZr6cqS9n6emPy8Pz2pXR1k+RLtAhaKO/yghDK01xZ0zulymYyvwwdZMWKb29CIBw2 +SSYN6oh0dvAWrPhEIjcXSUwoWtl5YQeDTKgTVD7kbFHLKmbXiA84Bfil5rySQyYJJi3odV5rS0bP +sCfT5ZVCc102y5JRjCR7RqKvJ/pWZkqONKPpoWi2WKXCSEVAEorLMGJeUGvwqWRmaWLm7MT86URu +VrW6jFyDWKhmU7PaifxyJL2Wrx+DMcEIcB+AHhGCTipGA+hYj0/TUoMSa8nihmp2JK3KSpDYRS02 +LZkTgtbjlU48MTmYPa1YPXdAhcBFE/N6bJpXWrzShCSHX6b4gmx0Q5jhCwqQvapZ1WONWNrpi5Wa +AcWIMxlRa/gRI+xArkPZgACQY4BaNFfwO2/ExDEiEQrDvxix5HymvJ4sLSfyC3DBcEE3oYIwOk2J +BclsS2YnXVyNZxcgWJLR8AZkFLNoGsDEZviqZk5Ahcaz86Xm7tzGjdn6BgxvND2nx4YQ+sb08cbM +8XR1WbXa0Xi7N32gP3e00t2EVAEkFLQmq1ThEVqkxYmFbHYGIBRSS1QbcHGSQyXV7sF8fdO0B5Xm +SjTVC4QNlEwoRjuRnU9X1zOQXWI5iMaMaAejbbeXImjbtAGy2unSSnfu7NzOjcnyWqY4v7J9rWb2 +/MGkZEwpkaEamUxllxsTpyLJBcjVcTeDIAaBRyW1bGdnjMRULLPQmDyRb+xAHGPJfqO1SvOlYAi0 +GWjsNMs3DXsuWdoutY4pZj9bWIQCAUNHMlndnknkN2rdEyu7dxw98y+Lq+eXt89HUgMl0sxUlzO1 +1UhqMlNZnpg/N79zk5WZJrkMwSYYPm3EugBQpfaBWv9gLD29untzY3iQlAskn9WtZjTZz9TWzMxy +rLguxyflaC9TXUNJ0xfkGD5jp2dL3WOlwYlC72ihe9TOLPZnjidyA9WqJIqLRnwakMpMzGTLK43h +EfigpEGudvxhDaPjDERZa2iRbiQxlavtlNtHaCHHilnNrKKkzghxWa8k8ouF1nahud3oHZ6YOQMS +TtSagtoCvIXuW4mZRHah1Nitdo8l8xuAtMCVYTwmyNVocjpZWjLik4rV1exBPDcnmk1CKAhGW4p0 +NHsyVVyFEW5MHhPVGoabFGWjCBgBlaSLkeh0Z+ZEbWK33NltTp/OVVc3Dl4HIwPsKaj1Ymd7ZvPi +yuEb1o/cOLt0yoq3VaOWLS/TfJGVqpRQUaxBb/ZCfXCk0NicnD8HhR8MG6xcABQ1E1PFxnZv7lRn +7mRjsHvw9G3d6UNatIXTCc55q2XGzi9VJ49ma1vxzHxj4hhKJ1BMicVbgpTz+hhOzBYbm3MHbprb +vrx76rYH3vc5IzpQzenB0g2ZyjbJVmi+rliTjNgIO9uWdECqIKICFUaTHTs7lSoBPmxHkjM4ky1W +lp795Ndi2Vm3j49EO4Pp0xEb4gXAeCSWXQHg3TpwAynkvQFFAmWVmi23Dlc7xzszZ6u93SMnbjt1 +/b+IRjOVWxwuXZjbuDi7fqEzc2xm6/LS4VunZs88/OTzxTbAbyaRHpRaB+qDY63h8Ymlc7PbN7SG +B5fWTm2fvhWItT9zcPHA5UL7kJ6c6c6dWT5yV2V4zrRbqVJfiVZw2ha0lpGYjpdW48Wlcne3Ojhk +pfutqY1sc0WLdsz4gFWKkUQ/lh7GUsPJhcu56jbJJwS9mMhNCxooq5qDw/YwkphJFtZq3WP1wdFo +shVLdhSzYaWG2epqurRcbm22Jw7snrhlaesioKWoVvKNjfbkkeHS2dbEkUr7YLa2oxi96enTs6vX +oITFihlIiVr/aKm1k6muT69cXFy//vKVx7pTR8NUCnLeSi1A2sezS0ZiOZbdbU5ekJU6jts0l2fF +fKY0ZyYHqdKClZpM5GaqnR3F7ACLWclpWa+mC7PVzla2vKRHaiyfBjbsTJ3So/10cQFaK2r1TGmx +1N6083OUWDeTk43Bdr62KGnFQnMtEu9kSzPdmaOFxrqdGdZ6m3c88EG4lazXhotnFnZu7MyfLba3 +U4UFUe2AoK01dg4evydfWcRI1bCqje7G9OqZ2c1zg6UL8zu3aNYgEpvl5arby4A8iGZWJldu7M9f +zFQPZBq7aUdUTFXqS43OCoJpwbAJSluOThgOuc8kc4sOuuqlVm8rXZgDe65Gp+KlDSu7lGtsJPKz +/rDqD0qgvmg2phoNKz6dLq0W2zu1wYly/zj4vqg9TORn7Gyn2FzI1ZaTpXk7M5gZ7jz7iS/VB9so +admpwczyzTPLt0wtX57dvJwoLbba648+/IFHPvIFUCmTi6cXDtwysXxdY+r09PrlmY3rI4npi9fc +856nPmEX+m6/KGkdO71QbO0MV85tHb+9NXVkbv7o+5/9dKW3BTnQ7O+WWpuQcuuHrpy/4bHDF55M +5jamh7uLK2chPRSjbsYhqaazlY3e/Pn14/ceuua97ekzW9sXFleO8WrRSg5imRkt2jNi/UxpYePY +XZun7wdeiCUmIfFYMQd3kPQG2E+UKoTJfCq32p05QbFRTkqbdgdCDNJCt0GC9ruDQ3fd/8zUwnFa +zHdmL9YmThca2zMbl6rDc3pyVY/PsXwhkZynuCxOxRKpiWx5cXH74trhmwZLZwVQL0K51zt0+70f +EtV8Oj/Zmz7emzmrxgbQtkxpJVNeBVGayEzb6ckgqpJMDMAZOpUqri2sX3v+xkcBzLe3LmzvXiNr +pVRusthcK7cPTC2fP3Xdfbc/+H7AkM31k/c+/P6p1TPgiQg2C2YB/HKhdqI1fV17+kI0PrG9ffrc ++ZtS6SYFgbY6amwmkl5KFdYWtu+I51YwMm4lBsCnUAJaBBi/Hcst6dFevrJ0891P7p64PkxEQHRR +bLHUOZJrHjDiUxRbVtTW2bN33vvAM9FYT1SqkFHp+la+eWhq9XpWKoXxCMUkwriJ4bputmIpKLED +EKZy/1S8sEHT2cmJYxG7hhCCqGVyleVGb7c7PNAerE8vHJGMkjfI65FKtblbaR3OV7eAxTS7XWut +nr3mno3jNxJMvNzeLHYOpCqrnblz+c6ulZ6FKJ8/d8cNdzwSSTZdPlE1AZFmzMQAkrY7ewIGbWn5 +5Bde/tbE3DHNqK5uXjx27cPzB6+sHLrlyLn75ravqEbv2rO3X3/TozSfM2MDeGildaBQ26x2DwwW +zzWnjqvRzukzV9a2znJyvtBYK/d247nFZH6p3ju8cezuwfLlWGpufuk8KxfH3DRgvmqCrWszUhO8 +hmxMFKor+cKg2V6huIQGhJ6eBk6UzXYyu9CbPWUm+6yU78yd12JdTgYV0WaUmitkedG4oHYyxa0Q +FgE9mcoMI3anN3N4uHw6VVlhQEwyxVpt45a7njbsWqE2P7t+TXvqRDQ7r5h1NdKghAItlaEX8fQM +TluKWTLtrgVVE5+IJnvF6jIIp8WFo8urp0D5tAYHplfPTS6dm1w8NbV0rDe5Zdudhx966uvf/cnW +kesD4QjFZnmpCmmTqx3O1mDM5xg2c+WW93z0Ey9WqtMg4RoTJ6E0GsOzE8s3Ta9fARHI8qC9zpea +6z7nnWKdkyvlzqFcdX0we+rORz6xcfTGeLpfba0iqMlIZdnqsVIF6Kbc2D547NbNA5cVtdLsrhUa +i4yUI5gcLzWjiZlC/UCxtoWTth1tJ1KTJJuEoYukHHcmmxO8WLbjfYw0/CFWkJPp4tTE7NHNo7cU +O1vgLzx+yRvgSdaiuagZa2WKq/nGbnPq8Nz6xZ3Td8WAsORCtb2mRauKVdk5df/izk2V7m65udno +7wKehEkw9YZuT1B8muaSycI8pEF35tjk0sn+/GE90aLYiJ1qZyvzpe52c+pEZXBEjQ0pNp1K95KZ +SfACqtGMxSckMU8QlmW1W8Mj1cHBaGayPjhUaG7ySj6Vn4ZkEPWqZDQls0nxySBqYHj0zOnbnbd7 +xkmCTEK5OTpHBKVRIpgsxaWTmX69sw4UUGmsrRy8rTN9bSy9PjV3sTF1Qov36u3Ni7c9yWulf77Z +QTIFUe3Gcpv16esT+VVfSGX4VLm+Ch6qUF/vzZ8eLl+3uXv7+vbNldbBbHlN10snTt/andwOohrB +Z0k2w8mAvYtWehEAIZqe4aXU4SPXlctzFPhErZUtLcfSC8Bc0dR8qXUwmZyYXz6bry1D6gLkcmIO +QNIwGvXmaru/wcs5gkpQTBLSO2JPRNPzqjXIVdZSublMdjaVHEhSfmLqaKV3UItPSkZ7b1opjpEZ +WesurF9v2F0EjwI/atF+Z3iyPXW8PTzWmzqhGJ1iae7Cpft5PiHprUL7IBRFc3hy9fidC1sX8yAU +2ezlmx+cXz4SdAxpMppYEpQiydlBTANvpRktSamAIhXUshKdyFY3yt1DULDORk0yLsnFeKLlC7AI +qjrvU6tt1RoyfEuQQdK0fQGBpHTLrtrZbiwzyNZWwRZpsX62tBRLTupGqVlfXN29LlWZF7SKoFYV +sxWJDfXolJ1dyTd3OaUIdFyqrjQGB+uD3frkESHSwtjEXrrOYrSRy/WPnr3v4NkHa4PjmtXFKRiN +OHhz562fkOFykcGAIIg5oOZYZtJMDez8DMEnAVUm589ANHm5mC4stKdOAypW2+tmrM5JyWBY9fqE +YEj1+Eivn4vFB53Jo7Xe0db0NbHiMnhhlDT0SKPS2IkmZimuAqKdUwokl2j1t9rDgwhpQgPs+AzN +pgkqxmt1RmsDBjrzFZGWYXUQzKy2dhc2b8qW1su15f7U4URuAQIXi9RPnbo1nW37ECleWCq2Dvfm +Ls4s3xBNzrNyg+SyulE9c+q2fH6IE3axujK/ek17cDhbWsuWNjmpmk5PDadPkFQikZxc3719Yv5i +MrNoRvqR6ICXa9DTQnVJ1vIQKZZLJbIzsdRUf+r4/MYlUakH/EJEyz3wnqej0XYYi7JiUdEbit5K +5VYGs+cW1i6BYi8WJhc2rxH1WhjXMFyl6BiKRhHEIvAkSThzmytr12QrqyEMPLUeJqIIFg2G47zU +ko2+2yvu24+A1zYiw3EX7uxtC6ugPGWjKchlVSrubF1KVWcRSsdZm2CSkNVGdNKw+iyX8Hpohk5F +4kMlOkjmoXAWCLoAFBxCdJZNymqOF+xsfmgm+mqsZ+cXGxOH7eQgneofOnhpYf00Jw== + + + J2guni3OTs6enF48X3TsxrQS6RBsCsazWF4CQhcV4IuDi5s3T86fPXD0zs3Dt8lGoVaeOHrqlmJj +Eegm5CwdOhNrifRCJg+evRBEIrxQwMhIMMiLcrbaOzC3eXkwewLs1cETD8wsXcxmp7Y2r52YPSXp +VU4uwIDAfVDSNo1JgS8HnQVNiROSulUDRR3JzONciRbLYNihBEStitMxXio0u0fTeQeHRcVREf6A +iBOWqla9bnx8POSgRGJYqm/VOgfSIL/ZNMkkm92DE7NnoBBoPgUyoFDfSReXneNTxHQYhzFPJ3JT +olZmxcKe+K/Y6fl6Z3c4e06Uq2HUoKi4He9BLUO9i0oFtAqY5Uh8RhAqGBpl+YxiNGmhRAsV0x52 +hicW1m+YXb2+3NwBLvD6WSQshcICRpiskLdSU7nyMoyDoVciVt3t4eAfoXwA1WWtxrA5lssLQglD +tOnB+oXr7scoY3Q0EPQzDBk1QSbZfRyP+by8IuVe/tfvLy8d8ngIAtftFNxhOZ5ayZe28+VN57AI +D5NITICOcntoGFgUhBbUnZyTjbIVrW9unS125xBKZqR4NN01k205AhHJQwexsJ5KDq14H7iMZOMw +5ghmkHSc4bKKXhedQUsdPHy50l4xE21OK1FiiuZsPVIqgt2zagShmXqp3l6rNpaMaB2jIp6AAPAL +5i5T2khkZqBSNKtdbB6YXj4LQqXUWDTjDYzWJiaXj567WY0UxtwUK9TlyKQZm9KMBoxPELVAsuYr +m7KZRxBW03P1/vbEwqnl7eumls+1J3djyW4q1T5//uYT5293+3mKzcl6VzX68dSsJFYwzEIhiHSM +ZmyIAuS2HO2JxkCxhoX64Ur7OMXn/CHBtEqp7FBSs9Bf0KWCWBSEosAVsHDEM44GvDhJGLyYNaNd +cGqgLhA0omgNM9pXzUYAkXOV+Wx9LZab5ZQcmCYMj0SsRrO7C/bQ42W8XpYXS1C86dx8rbmTSM3s +vQLD0kyyWFlxeyhBzsaS/Xp/V4n2GLEQCmvBkAw8SDA2SsbMxFR35txw8UJ/+mS+ss4K1RBqw8hA +e0IIj2IKJ2Ti2Zn57Rt6M+fi6QVBKcPNcTrKq3lBzUlqyYz0MrmFXH5ZBQXFJWU55/KQrnEs5Gcw +RGTpeDAgOZsJfbyuls+eujmfbLnHcY5JmvZAkCuSVOW4LEUnvV4BQ61CfpHni4Jc9AfZMAY1G49n +HMvfW9gs9WaL3enOzPLqoZNbp85NbR42MjXByMfTE5FIOx6f4PiML8ihmMyylqbno/GmnW7rsbIR +r+RrE5dufmD54Nl8c8iqKV7PJXKt1tRqvD6FEAr8frk0jCebPj8piIA8oHzUYnWtPnHCyi6QQko1 +0vnG0Mq2rGydNzMoF+G0RDRf7K2sFCcXaC1Bi3FnelzMhFBl3BUMIgIkdqa40Bkelc00wyqSFo+k +6pxiq1bWTFZFMxfPtqYW1hcPHIkWmjhnmXYvmpjae09BHRtDxsfCSEjOF+fTORA5UD4RKORsbS2S +mgGXRIk5jIlTgp0sNBUrEyKlMK0Jer7W22G4vM8nuMbCRFgR2bjApUjSQsJqAFEw0tLMhpWZoaUi +EAfFRA+fvLR++Hws1/SEyACmGPYglpqmucz4OOZy4V4fS5BRik74/M5JCIGgJilAqROp/GIsMaXq +lSOnLm8cPF1sTTNSwhtiQSEYyZYYKSOkysvxYnNZ1Cq8UoaUBo6muXJ34uzM4iXL7vkCDKSWIGWS +uaEaKclGVTXqulkzYrVqb7U6WLMzrUxhMltcKlTWk+lZr5vdd7V3ZATh+Kwd6yJBfnTEPz6GBv2q +ptbrjc1iaY0Xyh4P53aRJBWR9OLIeHjUFR53E7xUz5cPZrJrAlcKBlTTamh6tlLpra0f2j14+prL +V+5/5L2PPfPMx1/49De+860333z7r//5j3f+/U+v/PBnt9/7WG96F9rm2dsDxtLJEmjdUr/dmOlN +rMzMrmwdOHL+2ssPPPLeOx969Mb7Hzhz0y2Xbrvr9ve89+57Hvnii1/+3Je+tH3o5O6h87XWHCgB +iokZ0VrEbgpKKhLJNZqTC0vrWzsHz1xz/ua773jP4+996mMfvfGBhy7edt9dDz/54U9/8uWvf/Vr +3/3Bl7/5nfd/9NMbh85okTxJm0hYYCgjYTcy2bZuxjP56tTsyvqBE4ubh/qzC3NrW0s7Rw+fvubJ +pz/4s1d//pvfvv3SN75x4+33Ts/tZHM9BFGQgIYiJkPFs5lho7HGsnG/n1Pk9OTMVndqrdyay9WG +5c7coVM33HzXe+5/5PHPvfTSfY8+cfuD773r0SetZBOkFMBdKCAqYkFVarrRVrUKw9qJdDNX6tSa +/e7E0tLasdPXXHnsfc88+fTT3/zu9375xptf/ua3Lt9619Lq8UZzQVaLKGaFUR0gSBAzoGbhhsGg +QlGJdHamNdjOliez5f7Z6256/8c//sSHP3Tnex584L1P3XHvQ1fuvv/Bx9/35W9/90PPPXf3fQ+c +uXybpBXDYQUJiTwfN61WMjWta/VsbjIarWYyvW5v5eCxC/OLC2fOX3vtDbfcfPudL3zhi7//45// +/d0///HdP73x1ltPP/uxWm163EW5XBwUXSIxVypt+n2Kz8vgqKIqBY4vYHgMx02OTwhiqlDoHT16 +/vItd569dOWO+x9+4gPPnDxz/dTi6c7kIVUrOXtZr0Jk3p7szO1sHL5w+sKVG294/1PvffmlF3/5 ++q/e/t1vX/vVL954443/+vvff/v7f/vyv37tmY98bPf4tfXeARSP42g0Ca5cz+YShQmwEEfOXbz2 ++puv3PrEE0986atf+8o3v/2pL7z47HMf/9q3vvXqr3/z4stf+e63X/n73//+0tdeef9HPnPmutuy +hWGltjgxs1NpzVl2qVRsrC4vXX/p3MMP3v3hD7//U5/9xDe/+80333nnu6/+7MuvvPK9n/78T3/6 +8//5v//3z/8JLfn9d3/ykwefeHowuxNP9QAwWUZL2fl2Y7C1tQ3X4SNHr9x++wc+9MzzL37mo5/9 +5DOf+uTzL73441d/+qtf//IP//G7//nf//Pmb9959iMfv3zjneXKtCZVBaaYiE+Va5sEaZOYZpt5 +AO6jR47fceddjzz+xCNPf+Dhp55+6avf+NHPX/3Ja6/++W9//st//uPXv/ntb3/3u5e+/PUjx28s +lhdluRa1JiS5Es8M7WSn31taXz948tS5B95z/+NPv+/Dz33qhZdf/vFrv/jlb9589Y03fv32W3/6 +y7v/6//9H6jWH/3sV5/7/NdKtXl/UARODIXkgLND0mS5jBmplUsTuweP3//wQ/c/9vBHP/vcT17/ +xWtv/Prr3//Oy9/46pvvvPXW797++euv/vFPf/z//s///u07b3/qhecv3XBrvtgXBNDbVCDA4Lim +SOlGbX5+dvvUiWvuvufBRx5//Itfeemnv/zFd378g69951u/++Mf/vZf//XWO2+9+dbrf//vv//8 +1798z6OPTUxtVRrrZrQXCjmbnz1uWuISiphM2PVmcwE0yeRw8djp8/f/y8Ofef4zr77+y7d///uv +fvubv3jj1//rf/7nT3/722de/PyjTzx2+5332XZXkhoiE5npzx9YP3jtqbO33XTdfXff9NRj933j +q5//j3//LWT0m2/96he/+OHnv/DxW2+9vLW1Vax04+kBScYxVBfYqMJHbCPWLtePHzpyz133PPTw +ex559OGPf/TZH/34hz/40Q+/9NWXX3nlW3/6y19++svXXnjxc5//4udvuu2eta3TvYl1wyimE61K +bVgsdXK5+vL8xu7WzrHdzXtvufSvX/r817720re/87U33/r1H//6t1d//carv/rlO+/85j//8dd3 +/uOdb3zv6w88eu/a9qFktqMZRVXPGmq8We0sL26cP3fxzOkzp48fu+eOKy+99LnXX//ZG2//5oev +vvqN73z9l2/87N9+/9Zbb7/+27ehWF77wksvXrntrlZviaFthrKjViudnePYtMTbSavQqbaPHNh8 +8l8e/OqXvvjK977z/Bc/99NXf/Lun//0t3/8/fU3f/buH3/32us/feGFjz//wqdOnLtkxRsghwCs +jEg9nuomU62Z6eWl+eUzp06//+nHP/mpj332hU9//ovP//TnP/7P//6vf3v3j6/+6tXvff+rf3r3 +97/9/TsvfeVLTz7xVG+wgRNRMG4BH48EFRyLKHKh1ViqVSaOHT765Pue+MRnP/HpL7zwk9d+9u5f +//Tu3/7649d+8sZbr7/7p//49z/87tVf/Og3v3n1569+/+n3P37LrbflC11FTSFhBlIrYpXtWCWd +aGyuHnjowYe+/JWv/OTVn373B99+59/eevcv7771ztu/+s0bf/3bn+E+P/jhN37801d+/toPn376 +qfOXbt06doNiVF0uOhzSwyGJwuWQn+IofTixeO01F9/z0IOf++LnP/8yRPOzP/7J9/7x3//43R9+ +/xMou5//GAL1qec/duON1x/YPhpP9OqNnZiW6TUm2vVOrVCanRuub64uLkwdOrB41x3nH3nkljtu +P3/DpVP1Wi4aUXlWwHGexJWAjwn46FCAZgk1ZWTqmfpEczA9MThycOfwoa215eE153ceuO+aRx+6 +6dYr1992x20XLl83s7AYT+Q1vRRPgfauoYiIh0WGlDlKBOFy5vjFgwePlbK5fjl/fGfppksnH7z/ +5iefvOvbX//CLwBu3njtrd/+4rnPPHPd9WdnF+didsaKljmwroRGkromx08du+bixSud3myj0V2Y +nNhdmbvu7MHnPvwv33nlS2+8+fo7//bmd773pa+8/Kkvfu5DH/vg/Y8/eOPJwwf7/blYooEgEsPE +UNzw+MDXUH4/Gw5xpmjWMqljm6uP3nnTl1547uWvfO6lF5/52Y//9c9//v1nP/OB2y4fP3VwZbLb +q9VaNC0FAxTPxeAiKRMujjVFVknFst16f2dp7cqFE08/ft8nPvLYv7783Ouv/+jf//D2X/76h9d+ +9tWPPfvwLTef7rSqFCmSRIRlkgE/SBpni7LHRTC4kbIqGauwMD23sbp87typm2647o4rN9x/580v +fubZb3/r5S+88Innn/vAJz/82Bef/+hj99564ejhUr7J8ZEwJmKYQlOWICYLhWHUKjKElLFzR7YP +3XPn3c999EMffOq999x267NPPf7D77/yyrdffu99lz708B3PPnbf9RdPH95en+oNi8WJwdQRO953 +uymvh6PIBBpWQn6aRIVSunZ0a+eeW2/8woufeunlzz37wceefuKB55975off/8EnP/rRe6/csrux +1ay3JN6kSAMJ60E/H/ThWJgjMYGlZMsq5XK9QX9xaXmblzWcAG0phlERQQQC1xgmGgxyoyNev4cg +UZ2hIgSqcKTBO5ci8loqXrKjOQKlcJQgMFrkVUEwZKOI4KbXT4eCAuW8p2D5Q/S4Cw== + + + XC1JEyoeFihc0U0wKXFJMiOqyRGkyvHFVLJWLsxND4+fPL2+tZnJZCCO/gDl9ZNgOkAqh0KKPyAE +gryqZmOxqijGaVqXRStpJcCOJq1oMZPKZ7LVWnNmbikei+cSyWGn0y4VY5JOoSK4ZoqKCkLaTk1w +Ym7/SADUTkSv6VLB1tLdUr2eyeejVtaK7q6tT3XKjUJyut/JpquSaEqizXE5Arf8XsbnIbxu1ONC +3C7snydZCXzWUMqN0kwhWatnyndduencsUOtfHqm3eyUq0sTveVBs5KtEigzNupxjSE+DzU2Ehgb +DXk9FGAXjho8HTe1YgJsVqqYy5RVKUKECU00s3Y1pmcqufp0b36uP2fKSj6ejalJjlSDAX7cw4x7 +2FDY1LSaYVQFIY5jEoFC5SaSiRYUtSoXOt0DK5uXZ+dPG1qKRMJxzSjEs5YSpQkATBqySNVr3cnT +keik18td/f+4QIjSVAIJSRxpSoyRNJOFRC4bTxXTFZDvEsEotBRRcpZetq1a3O6GQlApejzZV43m +/qv9kCouFxrwM3hYYtm0LBdrldmjp29DcD2EgLbMiVJZVqrgKxkmGUYNGAESd+bKRkf9cI27UI+b +IjGdZ1NWpKWqFVnIcnzKOUgqwPoCFEZGMTwBYy5yOYqIerx4COEQVAFhw5A6GhaCQZ7hM4JW0iJV +wyihKIuhLMdoFKlwnKXqBZwywfvTTBpKab/zcl8YtC6GRSgqRjMWx9vBkBAI8Ciq+nxUKMQGgwxD +WeCRNbXM8xlRKpBkJKKnFdUeG/eNjyIYYvBcGmidE8pWfI5hC243DRoYQ2WPG/eMh0NeLOAJBzwI +EeajRkkRYyylslQ0FNLBfXt9/D9fLQ/4FYqMo4jqc1NB500lxRdQESwWCOnAcSxrV8qTRw+fLWSq +fndAoQ2VTSiszUF3AKNGQ24XQRMJtwvfd7XLNY7SZMzvF+CCkg9jJrRHhMxPTBBEBFoVsRqF0rJl +teORKkeYGCJiIX52YkfkbIA7uBXJlhipKSot3WhSTDKE6mGo6L3Db41IPxKfzZZ2irWt3vQ5KzHt +9QLHKdXCJIHp+/d5Pc6JFrpldmdmz3YHJxg2PzoS9oyjlfw0RcZGRsMQzUBAJPGooTfzhaV0ajbo +412jIRoD0lT8Pg5FdAyNklQaXDM8zooNx8bwcRficofcHsTjDmPgW9mM6Excz7JsJpsCLTQnKUVB +LBKETVJJ1tnWHsHJBIJF9u/3jo4G4KE+L8+QcYnPS1IR0q9WXmm0D4yNY+PjCASdE/N6ZEI1OnBb +HDMUId7tLAty3uXC3G7U68UxTM/kV6OpWS3SFoRMNtuMxcthVILP+v0AmFEUTypat1g5QkAg3ASK +gJHuwa38Ac7royDrMCKqaFVVaXidg9FYgDKStAAhCSIKIxYKqQydtqIdVky73Gg4bBpG14y0WS4X +xuMMX/EHdbeHgfQLBNj9zpsLAZ8b87qxgI9iqBiUG4FHACSDQW3f3nEfCGKgaBxBnDMHWDaH4bbf +B1LBQvGoc5Kem3P7ZBgrOzHIFKYIyoKeelwYR9qQgaP7A6POu+o0mHc0HElEZ7Cw7XaTcHm99Ngo +4vVxMMLOBgM6HbVnYslFJGwKQsKy24yQhdwOeLhxZ387TuPRVnVT5JPucZRnE7xUC4WjgZAZdE6L +KpqxaS3SR7EoTcfApDT7x1P5FYrO0Ww+ENRdLtxUi1PDkyQeG9kfpNk0x+UVsWgZNQKPgnof2ecP ++ejl+eMMk3J7OIbN4FSS4QqGOZEvbSlKy+vmfB6WwE0oDdd4GAsrHJuR1Lakdg1rKMk15whK3FC1 +lKClXR7c5xedU0CVuhbtxFPTnckjufI8L2UkrSJIZTPWN2KTrFhB8ERg7/1WKHYkvPeO/yjBUCmK +SuFETFUqeqQ9No47aYBrFJcy7AlGLvsRFf6aTTXWN08rZsMNY4jqJAWpHgNPBKEJhSTgx2OHzy2u +HYHUwgHWmCzPlzmuJCtNVe9DtktCKhato6g0NoZALAjCZPmMrLfjmUXTmqGpdD43G7Xb0BeHghGZ +JGMALLJchUrEMIunYs3aMifkIIJuF+lx82E0HgrbIcSyk1MgukZGQ+BQWKB+PxsKcjimeyDozhGR +UY4rAAiEEGhVhiRSYTQ67sZ9ARGn85HYZL60ICqlQFB1zjdDbQSNgrzn+AxUh8vNSmKVZ3P7r/aO +7gf9YZnmUJabaDjmnL3sYsFNSGIG2oOF9UBQDu5tRAmjEedIExJGJjG/eKrVXyPoGLRc4Esck+WY +HMvkwmELPgWsioXlYBBg09mMjRLpTGFrdefeevdoCLVgECSlQFLOgWk4lnFesLLasWhDV+uqUmfo +ZDDg7EH1OYkdGB9D3ePE2KjDRGFEsawGQcYhVyW56AP5EQCKUZxXz/bDb5IYFsWx6NVXuaABNGHQ +lO32SC6PMu6W9o8SI2MUyMjDu9ctbl8z7mO8QZmTW3p8IVXZLjQPRDOzklqZ7m+dvXwfwSd9iOQL +KWE8RVA5Se5G7GVfyARMwMLmnqEweD4v8HmahgFJEXQakITmLF5JMVKe5DO8WlWtBs1nOLls2FOp +/IaitwC6RTmL086LYAZIHbNKsTGMsoB5GcbBqNGx0OhY2B8QIf0EIa8pFY4DtqWBUwCigccB20No +FKPyrNCS1JaqNTSjBd1MJFpIWPJ6SbgVYAjNZFkub0dbh3avk+TcuAv3eEgCj7NsURCqglijuRwM +Hdje06duzhUmndT1kBiigqaSlTqUYRjRAVQ1s8FwiTEX6nITPj+LoBrNZY1oF6digpRf2rygx9r7 +RkL79gVDQY2kEjSdjlidVHo6FFQ94zhLWryYHRnF9i4cLgxLWlY/mZiQlaKqVRFUd3lof1AMhTWa +ycGja+2DcxuXBBlyTOtP7NTbB3A85vHyLhfj9fBoWOOYGDDm+FiYYVOZ/HIqv0zQGef1q3BEMtvl +ztGJhXOqUQewYvkqjDkvFoJBAQmJfi+396KfBfw+DqrPxzkvmIRUkojhqBkKyB7n3AkhjEXXNy6Z +emnfPp/LRQGKmnqfoQo0lUMQoEssGJDghqMjPr+PBq0CRYGglmS0QaLkcsNIoukGf0RYBJehpWI0 +O8+pVYrPmFbrwM715295hOASJBPXrU48MZdMzGWzS7o9HPOwApuanzqu6fWREYARDjKZprLR2OTM +4nX1zm463T519oqgVzmlmC7NF5pbpfZOtXe4MjihRidoPp1Ndp54/EMzqyegJDFMQzEDI2xBqiXT +y4rWCTqnwVsAGphzeE6eYooEXWS5qhUdWvHJUFh1ucKksyPIeTsDJWyKzsAlCCVVq5Wra6paitvN +WGICJ21ZrRv2pGy2CS4XwqxQOAKtBdW09xJuRJAqdmIocDkQilasgpMGgRscm4C8CvglnLAZNg3y +iWJTrFgQ1TJQMFSxz8eCevd6aJ7LCmI+Yvfbc+dIseDyOqdkAEgSpAXaDNIvFDaAcXhQmySUNrVv +PzI6hkN6hBGLZauK0gZ9omgtWW1wYpFk07xcAnEbdg6eSohyWTGboaCsCMlbbn5Q0wsAGi4XgaIm +0DHPZRgmDlorGJQkMS+KWZZNQGMyhbl8Y12N92O5OVGt0mwqGutSVMI1Tno9AobaNJ2XpY6qDBDE +9nglmownk5OgfEBLQ7/Gx7CxUQyaxzDlaHwqV1gGi+EF2+K8TSbjaNR5KcynhjFb0ZuJzAxoWk3J +RayMz4/5AnQgKDkHyBDOwivQVhDVRL1KS7kwFYtl5/T4MJld6A9P92cvZKorkpTL5abi2SHLQSVa +BGUCbo97Gbhnu7Wt6M45OQQe45zRS2tatdrcTOamS6XZcxfvEYyyaJZqgwOdmZPduZPl7oF8Y5uT +K5yYnhqsv/SFb5y5/m4EUynSUpSqqrUzuY1S9ZAoN02z7RQpmXBeBKYKkjYw44uZ0uH25LXx3DIK +fpM0Y7E2Tsb9IdUHDpRJKnodNBsnliLxyWZz9cqtj86vXRtEwPtU7ey8lV6QrclIfD6eWgFlgqAG +J5X2TtGJO+84INGgzzk6AA0bucyUplUgt71egWOSVqQhyGVZb+nRXr1zoFDbIOh4CAFUpH1eFnSd +HmmmyyvF7lFOa0pGS7cmQL/5/YyzVmj34IOJ9HwmuwipMuoc507AUwAB/H6wKhVJrotyjZecA20E +taFE+qLegkL27R2GTzFZ6JERacTt9uz0DkUZkM8AVqoCUiEPCeZyk2NjYUUuyVIOnujzkgIXz+Yn +k/khp5SsxJSg1AWxHI31eSHvnGTlnJqbxYnE3mkAlt85RC5jaI1Cfh54AQ3rOB4JAI+Pkxybp5k8 +JxQB9gHTgFaQsHb11e4x56QdEFd5Wa5oRh36DoSbTPTBl4+N+Xw+YAoNghIEzKdS4JXi6YXmxKlo +chjPzSjRjh4fGMnJZHFRiw5AXcy0Nh64++np1VOgz8G84GBSsIiqNyKxvmn1fQEeCfA0nQqGNLeb +DaMKCPVEdiZfXc9WVlghblql1vCAs9lYLzvvGqSmirX13sSRuaVzh0/dJappjFRisa5zbqragFbh +kDZMwk5NpcpLQdRwuelEaqk7faE3fy5ZWuGkKkZnEBywqFqqrmhWi5UKvFyQVJCvbTPeBR6PpLqp +4kRnciNVmqFps9vfntu4oTl1VtS7stGDyx/SpyYO3HrX+4qVGY+PA/1JUnWKqmWz66XqsXRuxVFx +ctGMtkDGeECIBng7M7ewcvHcpUfrvcMkk9zaOreweBJqXFbypdZ6bfJofXhydu3GjSMPVVonQIVy +fFw1K7SQAhUHvEnzZb9z8IXmDwjO6+FuCkWB+mNI2HmFk2DzUqSfbuzGChsEWyBoy7Qasl4DHOOl +oqJXDbtbbKxbiT5oGMAWsGY+n4A4OxwEDDNQLOL20D4fuGPT7yUQ8NRsAlg+lppJ5JY4uc6KVSM6 +1eifLFQO+APq2BhGkGlBqtNsQVHrpCOV05wAqdIAJOS4tM/rrGY6J/agYO4KoliJ2QMwsFdf7fK6 +SY+LcI/jAGXgLEQJnHhBECsskw76gaNVv4PnJMg8TizIWj1fXc1V1uZmT91+1wfi6YGgFMvtg6kC +BK4/GJ4czpwpNnf8qO52Uxyf5YA3ybiq1Dih4KSTB1K6WKwu0lwK+qsoxUi8b2dmsrV1KzltmvXZ +6UNX7vsggukwRLnKRtUp/LVqd7fS2U3kFnDS0nWgpL7PD9aeo5kUJFg6v7p66Nb+wlmMigf8PMMl +EdzyBWW3jwWQUcxevnZwdee2RHoYT03ma0sUH3f7SJKxY6nB0s61t9z31DW3PDq5dEYyyoV08/Cx +G81E1+XjSS6TLS/mqiuyOchX1qfmD5nRSgiJFOuH7dQiy5c1vasYbQQzgXBrjbV2/wC0Cgw4SHTd +ahvRjqRX/YgWxszhwvFSczlM6XaqN7l4cnbrQm/ucH1wMFVckoyqKKY+8vGXLt18Hw== + + + yVogDu3Ucm3ibLl3Qo8MvT4JYjTZ39w9fMu+/WBao6o1me8c6q5cHKxeTlQ2ESoZjTWe+ejnDx25 +5PFy4GpjyZnm5OnDZx/qT19wDo4bC6pSiuez427K4+MhYwW5Jet9cGdgE5AgzzIxjk+juAVVXO0f +7cydWzly98aJBwZz50WpMjKCTw6PxuKTfueoVQoeASMANDGYv5gprCLO6R8q6FVZAu9jgrMAPeZH +bBC0OOWcwg3qfRT0j4uiCRvHIiyTAZlN4EngSgwFPR8D8GSYCIQyAMmJ6hQXB4+TzM3VupsUn5C0 +aq1/tNg6lCys9Yan4pkF5zhcH0+TpqYXMQJGXg86B3hqXq8cDiciYDnVKgCmKv3/JL33l1zXde/5 +D4xJdO7KVTfnfG/dUDnn0FXV1TnnRqMbaDSARgaISIIgSJCimEVSokRRlCxawZKt4CBL1lO0pLEs +h3nPHj/bs+bNm7VmvTdrfpt9obV6caEBdte99+z93d/PPefsk7OcOoIrYVR+sgwsW6xv9ZevTG/c +4LlUr7dTaW2gtAXuK55bMJMzrFQr1rabk4d2cgpcCi+U0rklJzEVS06byT6nNCJYnOchc5ODw5GB +YSQcMTK5pVR+LVnctFPzJJ0AscpXlyWjEkYNSa1BAaq31w+Pn738zCvL21cYKTPRWn724dvpvNvZ +u1DdPbz02oNPfzK7+4Jsz2J0AoaGpbO5wqrH7fNGoG6fQMsfVHAyYdh9tz+A25GbR1EnEJQimI3R +acVs28m5bHVdt5utzsrhhXu62SSZGEqoJJ8lhDyvFov11TOXH2eKM+7rEcxs9o+hjKrmhNeveP0C +gmi59FS3dwrKIoY5jFhkpQIjljV7RotPpStL/aXzNx6+11s4GhqhUCIejU0rRodis8BQw8MMSIoq +lyQp9/QJnzcgKuZ0LL2lmtOaOQV2CFibZlypRHFz5/DutQdvbZ29P7163UotgNQPjwL7sHef/zBf +XgGriaJxw+ohaIJhi5nCCrAt5FE4JBQK07KYAWx8GhhwlKbFhpPfThS2U/lNAs9GwqamtdCINTTg +HxkmnjRBpYAlwRT5/e4OoN70DrhZuDb3ZvEoxIYen5ctd2EwhJZsNUl3iVpW0nu8CjpWJXGHZ2I0 +ZUMIESChWIamKvCFYjkUz4DM+nx8rbyaKU67XfXGMGBhQa6XW3vN6aN8Y8UyCjeuv7K0fhzC1GR+ +YXnn3tz6nerE4fTi1amVa4o1MTpO6dE2oC4KBRdV4JGSTFlWexAPgloeAhF2z75xolab5nM4k2aE +Ek5nRdXdHcmIeVYsWLFJlk9LYqrZ3ZqYPWzNnik2V5Y3Ls8sndeiDSvWaXT3m729zuwpIzkVxBJu +2+eAFLM6+cLKyBg1PELwYkWzplSjC35JkBogyMGATFGJiNuCkmCFUiy90Fu8XOueTeYWNK24f3D5 +tfc+hroJzxDDLVnvVVr7py+8dO259zuLFyF0/SEhnulGE/0QYjw5bIgc8/Io5gCYIKgdDIq8mEfc +vsRkIGTwciuZXzl14cELb3zl6vOfT5Q3xv0yJxbgUYSQKIwUVDECz0hSQxAbADiDQ2GQJjO+QLud +4RWAIBg7KNYqmHbSAQWYmtvvTe+mcjN2aoGVJyihwohVKCXd+RsYlfF4JcOZkY2G213BwwdDhtvf +fghDUKNYXkUiysDTIyeeGg3AE3A3Qc/yShPBY4PDrD9kAVWNjrhvwHxeye9X/QEVGArDYm4bbSKW +ra4xhJPLThGkPe6l4RYShS0jsayY/WR5C/IIqq3svqdqkWwe7g48P0il3yf4fWIooAC2wGMP+iXw +pRDqT9oSCqbZ9rvtqsIwEOM+Hq6EFYuye2RGLRZvNie2o2aT5zMzS8dzG1frkyf1WIPh4zjtRDAr +HNY1rUbiZsDPgTNU9Jls8XStfTyzfAd1mz+zLJOK2hNgjXwBHvA8Asig9wyrD+6XlwqdyZ1We5Om +TAJVCqX51ZO3z1x95ejq43uPP6z3DiSp+szFhy+98p6o5hHcRMgkC8iQW+9MHS+sPIPh2RODkSHQ +EDJtOFMaJDIWh+z2jDFgtoHFgu6ZR7IandCtjgrujkkTZEIS84Xy4vTWVVosBYN6ubLTmriQza/M +Lx8vbl7l5JI/IEaN0qPXv6DHJoeH6VDY4iXw5H2aKwdCGlh9KB9WrAcE5/WzgliKpxdSheXe3OGF +m4/XT93i1JppTly89AC4LxjWdLOTzCxk86vp3Dovtt3zsLw0Q8fAaEFdGxoG/xzNlNbr/YN0aRUc +GoYbiWTHH+C9fg5CC5Jg+9zj6Y07jZkLFF88MYASaOz8lVdpMQMVAQI+EHbCSErRp/LlU4XKwZD7 +jssX8FMUHRsaRp4c7iaFgNbZsuHMC3ILPtE7jqOoApjs9XAIFqNY4Nnm4ta147tvBeGOuDSCRBHE +Xb2mWROa0zfTK1Z2neByJBErFZdYHtBbFUDnhYIkV0QRlCoTCirA/oOD3qGh4OBgcNTtdk49aVkm +hQI6iccJLBrwM6JYUM1mIjebKCxUOqfMxBSwcCwxacVrJKvTnEGzlihmBSmvGy3HmQmDrQ0ILGVj +eNTnZ8Cg8lyWot0Wf5GIxTF5IGtgIkj2UFgB8YSCNTbOQWnmhXI6u6CbDRzXKUKP2kXdKSTK/dbc +qanlC+XaWrG4tLV9rVibp9i4k+jna7uiMRHLLGYrO5o1H4mkECSmKBVBzIG58gEbergn5iHKUBng +C4Yp4ZgN7npoxH9i0BMOK6bViyWWSrX9lVPPgQfTtdLO3jNWahrkyx8Qwk82dzBMzolNVlpbw2PM +6AglcBVQRY+PGxwOw5cvIPBiMWr3MAj1iAipR9PxQEAEIxdEtbC7CjQ/0T0zv3wBmEuS863uPsNm +Q0HZO86OP2nu7fXQDBPz+xmcNEORKM3kTacvw8XYHU6u8Gp1or8vSAWOT7a7W43Jk/A3GJMLotEQ +ostq3U4AcW+5jYYAAI22nViyYkupwpqstT1eHWLP62E7rdX5uZNum7hRPBjWBa2RqmxWO2fUaHdw +CLWi9Xy+OzoSHjjhAzUAY+DEe7JahETwedhQyIAvQSzwcpHhUsBlmcp2qrjVnr6cKW8bsW4YU4xo +rdU5UI0Gisf8gShAq989LI8eHyfHxojRMfz35zL8vhseiaexiEOhTjxaXVo+S3JxTsq0584c3Xjz +3O13OstXtfgMzaVMLbe2eGp5+ZKi1YJhyR8UEXe20caxqGPVcUwLBChdzalyDoAFJ1IRNO316U8C +mPC5c3bU8DBoIw4qCnQjSk1BqANHRDCdF1KN7urc8t7ayctbh3e2D27tn39ubvVStrGNM/FqZf7k +7jVeTIYioqgUFa3NcHVFm8SwVCikQy0GuI6ENCRiYVgSQ2IhsFhhBR4yz2ZFpczycVXLo7hOUDGS +yRBMRtBqhtVoNNcuXHpB1iuSXACyYPm8olfjiTld7zBsHsxwzGlWy8tetw92yOMVwhFLkuu8WOaF +Ikk4plkD1YV/BR8FSJ7KrU5Mn+stnN85eAB/htzvdDY2d6//vrkciui4uxSHQcIyxyUITC/XFkQ5 +ByIGgQfpJumNRGmttXh189TziWR/a+Pcn/3wl068P+5RGK4BTFGsbl6/+/bl25+Ro5MDgxhkjSiW +4FMgrUbcHoOs12uo2mTUnla1GhJRwTgF/HwgIHj9vCcgjHjEUfcgD80wJ0Ql7wswANFeLzU+jo+7 +a894zF3OAXU/QTJ5UQMyqgFw5aursfxMorBYbO/Z2SXJ6oBDnuic2t57XrdaHrcFt9v8hGNyOB4P +h3QoiFAl3c7k7uFojHvvQSMcUAnEcKxyp79uxpr11ury3vV8YynfWI0XVzhtAqfTdrS6u3l5beMu +9uQQjUCQp6iUIFYZLivLZYpOylKuUJghSRNYOwzqwdY4vkGzBe+T5s/uKHhoyHEoK09mw6VwxGT4 +lKgVYXwbzdUPPvzmN773k9mVI/gbkM14dr4zfVhtbk319pcXDw0jb+glTa8pak0zJkiq4PUoQ4Pu +EUsjwwiElt/Hj7lzWOGhwcDYKOYZIwjMikbbvcn95fWLHj8LrgZxD+azJKOWKa7nyltatEWQVq+3 +XamthNwu/QJBgCN1p8AAzPPZfrk4OzIUGR3GCDwGfIcixtgY7fdDTmkclzHtFgSG+3qQSstqOZ6Z +1qyWIJV4sQrS3etuTc/sezwcXAZDx6GSBv0CGlFo0kYRNZ5oc8DIwyEMAc9jC3JJtdoGCIhSJnA9 +n2lcvfocyCMnNAqlg2Jl3zS76fR0PDlJMjkw4YqQL+VnIa0Gh4JPzixIi9LU8toLS1sPZK01MkIC +MkBlDwW4p094TriHaAg+v0mSeQAunIkhhBEMiQMDvt+LGyvkksVlgD5g7URh3UkvM3wxnZuzku0w +pWqxZqW715k5t3vm4eVb7zzz4IP98485McsLGbAZCALUGR0bJ4eGQqMjSDAAisrSTNrv9snhoJSE +AgKF6zihSUam3ds4f/Xh9OqZMHwLxbGwVmkdgupqRt2OdSSt4Q8pFJcm6FgE0UHSGa4kSvVa81Sr +C6jeGfcIOFQWFlS9StGFYCg67tPG/dqTA/5kgnQgVQMBDvIlFBbseGt169LWqRuV1urq5vn987d1 +p8IJSTs5aTjtte3L3ekzOBlDUFnXMxsbF3K5SfgpIOhQKOq+S0QSLJNBwnokpIyOoGNuozy32SPc +49goCpYgFu+nMnPJ9LQkZ3Z2n2l39zDGEaL1Su+oPXs5VVwzzPby2qVaYw1kCh5IIjWbSMxKYgmK +o9fHjIxEnn7KE/ByGOJq8uCQd2QEi4R1BNHBL3ndGRORIhI+l1UjERTqaQZ8QrGyHo26s1dwPTQZ +19WS28NtKAxyGgqIBGaSuDvHPT6G+r0ETVg+Hwg7PjJGgJ2QhZTEO7KU4rhULNG9/ezbp87cC4V1 +gkiJYhVqera4Bg6WxGSOMZ90fiZIMuG+DuXKAleybPDhKe84JYtxx6yAw3nqaU8o4pY5cD6j7klY ++LiHCoQkqDsjw2GPhwCjAioHRBMKa4xLW0mCTrBiCVKvUNswrOL+0a2lzSu1xmZv+mBx60p/+ThZ +WOKEbC4/rUVLT1bmaPAEhgbdFUck5nYGMwzAlny9uYvg9ugoEg6JDJfOVpb3zj84f+v1ztTBnTuv +3nv0vp3qE3SKYnIknRGVupNcqHUu9pbvWOk5Xkg3WycLja1orKMYTTDSHq/b31jX+0AfJwYDJwYC +Q6Mkxdd5bZJgik/a9Mkcm8sWV2g2Bn4ynZ08PLr11ntfOnf1Qaa2Ek1O81J5a+/u2slnFLOMkrrp +9HrTpyu1Vctq5nI9WU7CcAD50kwG/IzX554x6p6eEzLc7g04gKE+OOCqVsDHKnLJiPYYrkKQGcep +rW+eS2UmaN5xMv25revbZ5/rLl6s9M7JZjcQVArpmUs3XsYZc8yDB93FyYD5bgM97w== + + + GIeGDFXIL8zub+/eGBgIDJzwwO+HIhiNTcMDIcgkaFe1sri5cx1YGEFNmoV0TjBMgkCNaBRUPQEy +ztO2JOf8Psbnc1fOjI8S8CnhkIyElZFhP4qIPJ8AGoJIK5ZnVrYvLKwdJ/LL9fZJUCpeyC5vXmOY +rN8vu/3/PZzPI0QQW1SbDJuGnBodiYASQtxGQjJF2CQG/oeADx0dRsAG81zixNPjJ54effqp0cEB +L0Q11GhVzHGUVa8tJgEcvKSm5EIRlRPzUrRlJcBpr7WnjxudkyvTW3/2lz/fP3cHmFHR6+niQiw9 +Czdu2LMUnw1FZJ6Jr69dQXF7eMg3Nur3+3CflwYlBFcJblaS06KcxYkYL5aiiW6ju9mbPVWpzj97 +/8XbD161ki1aKKRyG8n0ar19Zm3v4dzK9an5C1G7m4p3Tx/ekqOpIAZo6SBYBuqUZvQktROKmF6/ +CFAGhDLmU8bcg8AIQCTgrFhyyYrPAaydOXhmcmpHMUpWcjJX3W70zs2v3To499LVBx/U+/vNifXz +V56z03Om09aMBstlgYvBFYMeaupEKKJ4vG7GRRBLkbuGMQWAj6KO1+P2ZObZ/Pg4iEwETCaCpNz+ +mRHdnR4SC1GnxckZhk/As4pgccVoLa9fnZ49DbFRrc9SnC3KKcusB9xBVIPBqN+nhPwGjccbldVe +9+Tgk5dIGKaCH8DIBCtXWbkCqdef2pudOxClvCBAoawaZk1Wiiyb0KJuZySKjFWLMzCOXi/hGcch +okgMEsEKB2XPKAma5liVdMrdjyMwTm9m5+DC3YOLj6z0EsWVESy5sXHpT7//o2K2DwbS62FYJi2L +dVmeEOVmMKSAzdDU4uTckRNr+bwkhJNnhAh4GTQs4xHVULI0bYKw82xubNTtsjs4CDTBYxEj6JXQ +cBRKfyLeffDobX+AJWmHlXKy2bKzc5nKWq40t7p46q13v9Kb3oVC3+ycgrIYz8xDaLESFC+wEHzM +qHzq1T+UrdrTTw8PDY4PDwXH4I68HFQWgY1PNuaOrzyrWdUIuAK5yKt5OzmRLk63Z7bLEyu0kIxn +p0rNXVlrWk7fik9zUkGPNiS56tiTteaaEk0n803ZaAZCBhQFjLS8AQXIl2HystICwsWp9JhPGhhC +wHSFMUczu6xQEIXc7va1Xn9bM6uxzGy1c9BbuLi2e/vc5Ucz68fx3MzC0pkvfePP9VgX3BFImahU +nWTfsGZkZVLVexhhqVq50T4pKWX3LY1f+31HUPiiqBzHV0bd6WxqeCQCMRYMqXAZgtJI5lZak2fV +KIxLZnpqr1RZZflst78zNXdKBEqKqAQVBwKSpaLXI4AbhF8bCpnhYDTsE6HKg1yMDJOGUVe1gheq +2DirRDvdxcuF5q7hdBEiFkHNZnvDSTRw0iHptBOfyhaX7di0LEF9tCGi/D6Woe2An/W7E212JKx5 +3OUQKvNk5xrUSkUuwC93Ut2FzWubB/d2Du7vn32wf/TsdH+ZpQBLowyddNd2htwzm0gy7a7WIOO2 +NVEsrdhmze+hsLBKolbAwxCITqJGyM+Mj2IMnXec+TCUPCbqHiA1gAR9ks8L/iQDxlWSyvFYEycM +mokRlCnK+UR+dmblwt7R3b2jBzNb13DGldyZpYuiUSchU9gcQaUZLs/zGfDn07M7QI4nnh7zj9OR +oBHwwW1ywQCPhPlqobl39hqrpkJYNJ5f0p0J+M3NuTPZ9klOrchy9tLxve29a+CsMAx0oxhLzM0t +XFhdu5JIzUlqtVWd+uznPm5PnX76Ke+4hwyCkqCxWHyq2T4w7KlwRNvdu2UnOwPD4TEPHYYqQ7g9 +62S9nshMVyrzW1vnFtbORwhdMuCRdsxYQ44Wq621w+PnL919m5Wh6C8XGtsUX0QwG6eSIcQORtx5 +7WxhOVdaDiPy0DDCMGnbcpkRQxLBoDk8wo6M0uGIMjQa9AcZnLDM2HSiuF5s7pVae0DN+XT/jTc/ +Pn/tcSAoG3Yjnpu20tOG0wPdRlAjHJZVpdrpneX48ugo7b6vdt8N8oODERxLRqPdmand+w/e4IQS +OEnNbEtGO0JkwGfmKtsbB8+b8fbi0uk7z745MbkXCGru8siI4zbex2MU5c73RUICQ1pgpP0Bt0X2 +8Ajl9SthNBZ15ir13WSqMz1zcvP0nbM3Xjl74+W9C8+aiV4Q0XkxW2lsTEyfhgDQjDLQLkmlcMIV +au847/eKfg8LMlXKzhta7cRT4yPDkVBQCLrzxXwwCM5Q4bj8zv6tQFD9gz/wjYxQ4JMVrWM60zBe +J06EA0EBwTSU0GgurljVSvfkwu6tifnLotkXo7V4bq48sUtQCcvqJbPL8exiKr+mOR2Mtse8bkPU +gE8MByTvOA2qODgUgkhAMQPBzUBE9YUE1axo8RopOMnizOzGtVJru9TYaE3u19oAU0Xwz6i7gaUo +AH1TCYpOcEJaUnKdiZXrN1+wYu3BAT9JOobZkpQKgjlPuvYlCDqezs2wUgYExOMFAwmFyZG1CkQv +mMByobO7e7Y3s4niWqG2vrx7b//8yyfPPDe7cq6/cBjL9FPx9gcff+vhm192DxfDY43Owcrm/XL1 +sFw9E7X7oYg2No6lki1JzsMYDQy6TZ7HxpVAyCHoQioze/Pu4/uP3gJo9fiFAKKjVFLS642J7Vbn +sNo5T/AFiLpMZQm0GqfjFJMlqFQEBe01O9PnlWhz3MdhhAM8/sTFGRDDIIBgWSnKzBWnwFYFAoqk +10rN7Ympo61TtxbWLoHnVJX0vduPvvW9H0z0Vj1ekePKoKKCUMPwOAyrPyCJQp6iYmNA2SFRfPKs +eLlabu+vHzxfKC9vrx9+8aM/Wts6Xjl5Y+v8C52V6xOLl1f3H+ycvr135la5uVGtLX3/r3756ptf +JPCorpRVtQkKxtEp22wbSj0Sig4MYECsYISGh1xePvGUZ2gg7IIkmlKjPVlrFIpLql7hpKJiTohG +S7F6Rnw2EJIlrZApzk7091SzWmxuTi5fXDp5a2nv3szW7Xx7X4v1U4npS8cv7p99lpUKnFgpNnay +lS05uiBIU+GwMz5OA0b5fJAv7OiTZWxhGDUqDsSXLs6nSjPV1uLu2Tsnj+4e33xx9eS1UnuHU+s4 +lQCjIohFFNUDATYciQpirdU905+9mMotsSJYdBGBuoNoAFaQjBSopdyO2sup7Lqs12BkfQGeYmL+ +AO/zMyyf1MxmpjBXri/Bfw2rwbJOubHW7u+3ejvJ7HyuspqvruhmPRlvnj13c3XnCCOiifRsob6S +yE3pdoeX6/6gCqmBI8q5o9vl8gLUL49HCocTCJJB0EwoYufys7fuvDw9e3JsjGC4rJWeT5U3evMX +b9z/zAuvf7J88gFB5yYaS+eP74pyGmIsX9qYnL85v/ZstX3JjPUjqIYi2rUrD2uNLXcN8zgDNI3i +CSD0VHG11jsEVOm012bn9kDPKTrFKxVRqxdKS7Mrl+rdg2S6D7JZKExrRnXUPb0XHx9nKbagGl3T +6odCutfLKnq10j4pKmVw4wyf5uQcihuGUSlXFxUtP7V47uj6q43+Qba8KGkluEKWSdhO69zlF978 +7NdWNi4DWBnRPscVQ0ElHGQ9o9josNvQfmSYtZwpGIinnhobHkLGx2i/B5DBYvgKXD+CmFG9DuWY +oJO1yYPd48fnbr0ztXod0KPW3t7ev3f97lvzi2dv3n99cftSujY/tXYRHFOisuWkoMTcuvbMG3Or +F2WjYcVnyq3tfGVdc+YwMvP70xaGhyIk4RCEGXRX0rIEFePloqiW47nZZH56//D29WdfSxT7xdZy +Zx6y+1S2utXonp9efKZQ3UaIKEYYklZjxIJudaLxWcWciSaWBHWCJDNhd96No5gkxReCqINRebcV +LZv1u0cbJKJmHXPfrNJPNp5PdWYuzK5eKTZ3WbEsK/nezF62NE2xTrKwuLh98+Izb+xdeDFVXjZi +DZI1BCG2snasmXmcNgStzIglVzb5NEPGysWZWKwFvjHodsV3D2cBwQxHrERqulJb4QV3VwJJgmNv +KEZVNcqV1urS9tVsdQ0jnb31s6++9lnHKVOUMzF5vt2/UK7t2PF5n/t+hgTEu3XjxYnO1oh7yKzb +Q1Uze5niRrN/rjKxz7GJ+3dfunbzvsdLQq7lq9vzm7evPfv++dvvJoqbYcQiCeNLH39tb++yL6j8 +/oQRw5qNp9dZrjwygiERpdvbLTW2xsbpcFhHMXe9gahWY6l5KzEtSdnb91999KnPxeNdBI3Kas1J +zhSr61unbt588Jn+/EVOrDFMTlFbAffw6NDTT4/DbXrGOVBXii4GAubAiQASlrPpGcDJsRHABx5B +41AW/QGdY3Lg6+DpaVar2t5t9g4ZsabppYn+6e7cEZSMC8f3Xnr9g/b0jp3pH9/49L3HH++ee2Vl +8+4rb3x9efuObk6U84sHZ5+PZbregBAMG+DWRD6BRES/exqRlnIa/cmTopgJBgUUj0paJd/YqvYP +Freuz6xfjMYb67sXJ5eO8q2tXHPbyixI0SarlGS7la9vWJnpCGWRQgaFu7P66doeJtT8YQdn8oLR +jOcWKT4nGFXeaFF8VZBrDF9iOBdvgyEZUo9mYyRrQsCv7j23uv9cf+lKvXeQq67D0CeS7Z2ju7H8 +dLIwt3zq2Xz7lBafVM06EOvG5jFOav4Aly2uGfYkz+ejZgtF7UBAZJiYZbd4oXTiRGjYnZtTBClT +qm0Z1kQ4HPV7+ZjTxnH4WSIUYuvttTsP3rz73BurO1dz+bmoWQuHeQJTJTEHtDXqngXMMWyyUl+r +VJZTqb7PxwwOBoF6UNTtYULRtiBmKcZhqGitMm1audHRMHj7xe1rJ48fzqxeSBWWKLYUiVgCn/j0 +m59ZWj7jC6pj46zbWMY9HsJ9AwN2jiTMWn3JiFaffsoHHEpTGVVvKsaEEu26s+pO48XHrz/7/Bui +CNUzPbt4sz11IV9ZBTF0ElMYlvC4WwCEic4+TcVHRnACiwtCnWNzNBlDEWtgIBzw0VPd9Q8/+pPx +UXwIos7DgaPQjE48sZCM9wTGnJnbVtQc1CyGb4jRPkUq1eZqe+qgO3vQmtxJF2ajVr3R2tg8c3t9 +/1J3didbWkxkQUkmgHkdu9mfPqUZNXcpi5DnuQxL2xBabmeAiAx/FviUz0f5fTQ4QzveXdy4fuHW +29tnnu0vnFlb3vvRX/3k/guvG4mOnZmrdM6kSxul5t7ayXuXb7+5vHOj3dt9+OoHerwfRO1YbrHS +Pd3oXzp1/Oapy6/NbT3T6ex+809/8sFXvhchYt6A9uSMPA2jM6o9lcqtNpprd+6+sHP4TGfxaGbj +UnfxbKa2NLV8tLh+6cK1l+689JlcZbkxsXXrwbsvvPbFM5cfTS5ejGfneLnMi1VZ6wTCoI0spHkE +BT7KSHI9arU5ocAr9WDYEqUKiqm+AI65pq6lmhOyUiOIBJQnTS/OLp7VrWo622q25g== + + + 8+WlaGyOFesMU2ToDJDX70+RhpBAEJ0gE4GAPDICKM3TVApDLSj3DJNg2ATLJRW9rEdb4MrGPGQo +LJKAbyjAu6LquVhioj93uLRxzTAbFGMjuLun48mKOzLsLqyyOS4bdbooZgUDot8rgNL6faLPy0aA ++9BodWJ7afNyd/ZMLD1PslmfXzDUUjzWIQgHwowgkoB7UaPJMqkQxCed+P0urUhQGxpABk8EBwcC +8C2BGRTuzqDRdHzgaV/Ax3nGKfd4xOHIkykYzu+lRTFN0SZkSiq/kC6uSYKVL85UmqsT0/vl9p6d +6CtKAcgxV5kTVYeXdN0qyFoxU1wr1HeB9QLuAldTU+uKWn6yx5Z09wCGJIqMB/0C3OzoSARAmKJs +inZkvZTIz9fbO/PL5zY3z9y88/zyxmG7f/Lg4ksb+8+fv/ba3uH9WmvVdKpOrFWvLV688pyVBF6Y +n1m5vLF3a3LxuNhYjWV6mlMp5HrPPnjtxrOvoKRjJ+Y0q5/MrZ668OrJC6+UaqsLU9vf+e5f3nn0 +qp3qFuurnfn9mdXDWy+8+cVv/PnX//xnn/3kO5evvvDJH37705/5OFFYTOQXzeR8oba7uH774jPv +bew/5qSqLOam5w4hiYJhPRhSSCYO8BhNLPQXrsczc2DqJqfWFKVomBNOZkpzWmAmZb050T88e/lT +opqxnKIdbwpafWLq3NTSTSe9juEFki5EY9Oq2QF207UsxAPU1lAw6vOr7pyCh2e5XKW+JcrFMKKD +H5hfu9meOa3HOgpAol5CcYnmbYzUIgjPsKYgp0WlKGlF3aoJcj4Y4kU1t3nqeqW+BN5PUmsoYkD5 +iIQNWa4jEc3joUAEILTCqMaKGSM+XWocyPoEx+ckPikJLlrqRi3gl8dGaZZNRq2mIFVA38BGhgEx +BhGfVwCfg0HEBlUcM70eBny1uzLQLzFUHL71jNOQO6PjbCAMribGijmaT1nxVrm5hhHxTLycyXVF +JR1LTljxKcPqW85kNreQzs8Kkq2qjmEXadaJ2h0rNa9aHShDHFeIO9Op1JTXQ4cCAo7qkQh4EmFk +OPykp1AYQ0zgPhw3BSnLy4V2d/fUmbuHx/dr3TVRTcWSjcX140yhX6r0M/lJXspCEOp63TAaTmwC +Ujhfnq+111WjxEpFnHJINqZHC45dKZRm4ukJtwlkDeJtBrJgbul8Z3I7k6hMt6cfPXq8sH7StEpz +CwfX7r9y7+W3Xnjjcw9ee+/ep944un5/eX3vwcMXL15/NL947sqt1+c2bi1s3t3cu7ewehGglWYT +yVjzpdc/Wty6ODxKjHtoTsgq0Xa2tj8xc8xLGUVKffr19y2rBgYpQjgxAOf23tbph6cvvzG3dUeS +Mxcv3Hr9rQ8703skl5WjE5RYZaTW5Oyls1ffak4f4aR1585L7d6W1y+6R6L7VRRP0lxpogc+5JIR +bcxM761sXe9MHda621K0ipEJQSlrdrPa3eHVUigiwH1xYlKUczRnA4DQXDoaa8+sXn7uja/2F85q +WsWKTyLuJhHWndINuO+7ABka7W1RKihKJp2dVKITjcnz0cQczQE6gfzWZKUB5SwY1Gk65SQ6qdy0 +pFZwMu4ekzcGihSBgSbIOGisu4Fo1F3MNuouI3RPuAMzPziIYJjjnj81jIdQy4h1ncycmewb9oQa +bQeCRlRNM5zjCzAEHRXkXCq3mKtsZ8oAgDVFzaQzLcOphSOSHevWOmdKzVP1zuknTSnd/nveccLW +yzF44AF2ZCQ0MhwCEQMWZigo0BmeybYmtiguJitZGyJ5YtNIdEW9GHXaNbCsQjwYdBcCcWI1W9jI +lncMu4/jDobqptPmpMKoh4kgFsdlIJvi6b6iVXDCCQQFj4dkGQdcgT/griShScOQnFysVMhOyHLS +1DOt5tzk7Fprci5X7BlO1Uy3M5W5emdpfuNMqbE6O7t7/bk3FnauwZM0jBLHODim4BE2F6+e2r9e +bi6Df7bMXjo578QmVb2FkVDxSV3WDw7OkZTDCXUntVRr72+efm7v/IPl3ZvxzIwqJl58+PJPfvV3 +e0e3Gamcre2Uuudmdx/deelL+0f36+0lx8m/894XDs7dDYZVgDvdmc3VT3VnLx3ffDdXWkrH2y+/ +/N6tF971+CXAkxASFeXaxsl7V599//LDD+L55VZz5fX3/6je3giFlDCiKEat0Tk8ef7F24++MLt8 +HcDqxq1PlyrLg+7pPIjHw2NYEqKiUFxeWr+qSPlbNx988sd/LskFRmxEE4vw6VZqZf/4tYv3Pleb +OMQQ69kHb91/8e1kpjfmoUfGCPhvKKQSeFIQW8PuWav00enrt595BAJy4oTnxNOep/7Ae+IEEgrH +rdgyhpqLK4e9qR3AUjUKulfEyQRKpH0hGLssQBZFRi2rjKIKAn9mk0asly2vd6cP1k89Y2emCEIv +FOZjqWn3zNOwBr5x3MO5yyMZR5PTaJgL+jCeUYN+3O+ncTpJsFnAGYrOEnQ6GBYNowwWrjV7ePLC +w9X9u93la8nili/AYYhkGFUEdV/9PSF9IRxUBT6fKy2zQgEyIpWchEsKIzI87XGfCLTotu9DTU0q ++t31JFKuuAh2V5OLHJ2MhFQKM0B8Mpkuy1t+P8YwNgiOblf6C6d3Tj+ztHFsx9rp9EQs2SUpWxQS +mpbj2TiJaTwVZWn4EW50jAC24pgspDxJ6BhqBAOSIqR52mFIC5AcElzgc2CYScpi+TjHJVStkI43 +uu3lRmsFKgJc/NTChXp3N5XtqHpWURKmkXCMhKZk3Ln7cUbgMgpcMJckiCgSkZAQD+UpkZqUjAl/ +QEtmFzOlVdPuzCycXdm9Wu1sUZRVybVOn7lWKM5SRCKdnUtmZ8xYW9ELhlkCKgeSlZUiScVHnxxO +AV7RdmYSqSVNb/JcwpBj9Wq/P73l7lKsbCZLm43p40b/KFtaiGdnWS5FY+LW5tH2qWuyUgArGDUn +KBrcV0KVSz4P7Rsnba300qO3P/Xau8Ay7vmq46IvHKOESra8lSmsWHruw4+/+vjVd3weZnAg7POK +olTP1w76m3cCASnoY0QOxrFJElEQDShJ8PDB+3Wn98AIMfD0hPjq8ulafTEUVpFIFEwsy2fh4aAR +LuDFvGNhNIQrvIyEI2iY4IVkeWI/Gp9Vo5OsWOJZa35qa//gZjI3pUar8QzA8gpO5UMhiSUNRUyG +Amw4wJO4TRNxgc3adhe4DMUSDJnSpaIm5ibqS0srx2EsCmUFJ6xwSPWD7PtoibUKhSmflxsbwd0j +mMdoDI3CM+H5FMfHITDiiZasZjBCdhKtSnMrmV2K2pMTvTOJ1AyGGZ32Wq22GAq6nUkQFFA94Q/E +MKwoSw24pIAPNdWkFa16gZuCyu9nAMNh092JH4n6fIJhuhlKM1nL6Tl2i6FjwaAENphlEzhmBPw0 +S7krEinCgKDFMT0U1sbGacgImtB846i7O9vHhvwsT1kckxKkMkGlgkEuV5xOFfoIAohqqXpBEFOa +knOieUWMh/y0LCSy2TaKQFpRJKFBeGsaXHAObsfnYwN+gaLikbCOY1ECt+ApYWFJFWyBsQEokIha +6+6oRo1hkgybwjEL/JLIpw0tR+N6wEeODochNynCHBoMjQxF/B6cJXiJ1VJ2tVKYhzwdGoqMjlAI +kqS4EkmnCMJmGJUDaKl1Y055aAhx94XFZroz5xe2bs2sXgLEICGcSBPHJBKT3OqAqXBfkpKNxZtO +vAWRr8uJqJZi6SgMBEsBk6YJMkoShs9DkKiMhzkSYVRBoXFS5BSWMeKZFq/mMcJCUdVUUic3zhxf +vGNEwaQlU5n51sRRIr1CkjYW4cN+KuAl0ZBEYDoakbCITJMWw6RlpSmwOTyiWUr2/N6lB48/gxJG +KCLiuIGAcCEGjcOX5veR3jE8BMbSBzSkRBDjSZMHMRxWBC7lxJoMa1OkVqrMFypLyeyck5w27UkB +JBE1HKvuOE34n2EUEsmpTHaTpJoYWggGFM9oJOTHNMmWxfiA20YmBAFMklmGLuFEMhyOoqiVSPV5 +IQdGBcViUMfdv8RjYIxBGN0GIMORSIDFgJ3HMLcrwiiJEyBxGQo3SVzxjEUsrZRNTuKogYUVLGLQ +JDgBIxLmi6V+PFn3+QiWNiUpybGOwMZoQkVDVNiP87SRy1RCviAaRCgcao3DMHH4OJ+XGRmOeMYI +sL6DA/7xUQyLaEEfh8B4YRoeAvWAMJN7U7u6mosEOZaJE3iMJCzICBjH8ZHw2HDAP47TmD7mdqhA +AQ9J1IxZJTsK2Z0lEHNgIAClcHDQ9dJPtsGSPi8pi5YkmCQhe8ZRoEWez2l63babiXRX06s+LxUK +Qj1FBgfGIgGcwGGARIEza5WpbLYTjZYIXAuHKK83EvSzNJkjcYvE1Vyq05jcHRkHrQiPjwY9o0Ea +40RasaNptxNRPC+qyaAr9fFOfa4ILkiM46iYSTYtswSVCCPMsTEyFOAiIVEFeFGLBK5C4gT9VCTI +oBEZNM07zuARwzEKjcpUpdJnadWKZljGBo8KP4gjMhqSBwZCIFlIyL214SGf1y9FkBgvVHR9wrJ7 +UbOGIQKIz8LigaIDjCTAxSlqLZGYLJeXbMd9cxjwsyxr87wDoe7Oi7kHUJIYsD8qhYKUZywU8EQo +VMTCcKm8zwc2xtG0miS6QhEOy08gqwWaw/GNWHzV3eSCRQPuRBvoKjU2EggHOcAclk0Zel7gE09a +K/j94+jy3O7h4S2aNH0ePOSj0YCg8Am4KSwiBf302HCIwGSeBbWRg36GQAQGEzhSogkZQ7CAx0dG +MPgWMlEUsjyXduepvVQ4yMMYDTw97hslfOP4GITBCd/oQNA7RqJhhadsTUqDb8kli0eH18BkQrEL ++XhQlUhQQoIii5sQfp5RNGa14s4kFtYoqBFBcXwEO/GU1zMG46LCJw6eGGdIXeQTAR8T8MIjIgDf +xkciZESRmCSFRiMBnqfjilQfHgkNDHhOnBiDW6YIzdDAfmsxPXbu3CXbKXl9dCgo4kSUYdOcUKLo +lM+DmrJzfPr6u1/+bhBRnvqD4aFBHxJkFT5maMmYk1WF6IWjy1t7FyKoODYaeTIp787L05Qh8IYq +RZMOOMw5SSgwtAMeDwnz8PckSgu0pEspDOHRMIkGKYZQ406NY00kDE/Ar3BszIGY5ANhKhjCoCKo +Yk6TJ8JBHSrRyGhkcGAcRRRRTHFcDHWh1UBRk8R0TUoyhIaEGV3P5SrLKA6fKIWD7vrMJ/+aNo2C +10cMDweBpsMBmSXjaFj2eXEM5dOJbMaOy4wc9KE+L4Zhih1rFqvLEFHBAA9X1GitJZI991TokQiE +ExoRSbcCJlSpTOEOBFIm3synWkiIBEmXWJ3GZBpXWFyKBPGgLwy//8LxMYULY0NBz0hk6IR3ZCAQ +9DJum0fWejIRLKNhEwmQEX/EM+obG/aF/ZGYqlXTsXo+aapGpdaV1fj4GDBUYNQdYg== + + + FA8rYb8wMhgYeHps4KmxgIeV+LzIpZEAL1BGwsyl7IKh5f0eAg2JBAK1RvKAsJwYHx7weUbCIS8p +MgkCkX1jEYhw7zhEPkdhDoHGgz5xeDAwPOBVxTQE5MhQAOIQyi5LWZaaZ7Fo0MOPDWERP2QWPToU +8ozhkQCIp+D3oALDiwyliVQlZXW7TU4QUQAkM1UpNRPxDMcrSAQhESQG0FieSKbrg4P+0eFQJMBF +pURcSygMa0lcK59cW1tKZPKBEOHx4pEw1FBdEvVkzMpnYoW0vb3cf/jcvYmJ+bGx0NhoYHTEx1OS +CvZIVw1RwsOIo0r5hKXwEFHjSMAnUkg2Ltfy1oVTC0dn1xe2+pUG/DLZ0MFsKGBgnkAxAVeiS7od +VQ1NtqMxnrZ0ucBSDtge32hEoKRSrlJvTep6Mp9tcZxJYAKJiuEAPTIUOnHC677LIt12MfDogl4M +3G+r2luYXzBkFQuRPg9GYBq4gphTFMQ4zViVylQ0mtf1vCgm/T4KCXEQMwwpqbwuMCaOiFCyBS4r +sI7KKRpDF+JGTI+qgmQpikjiIgQZg/ZbqdWljsSDKtJYWEADLBmRKVSHQgbhARrCgMMM8xG/Hw34 +EL/fFKWJrL1Ui+/PFm+c6Vw9mHrt5esHu/NpM8pQChoRoPbxuAkB9vQfjAwN+ANA2QE+MIZQIVok +2Lii2bIaFRUCkjeAqrwosgwD+sjwPCkpbMzSCpEQNzLkG3h6ZPCEB8IDiuMIUOcIPXAicuJEcGgw +7BujIPhDXhQNYplEnkI5KsKYUhwLguenWSIucQm/Fxsa9PjGMRo8TJBAfD6RDMZVtJnl59vO6ny5 +WY8Vc2qvZl/cbNy7tLy3NTFRsdqlWMqJG6pD4OLQiVHvqB8PoiYnxAVKJ/05Dd3oJZtV24pypiHa +lqkIbNoWG0V1rWu+cmfnlecPHlxfev7Weq2cHhv1j42E8AgY1rghSLZIxwQsLqLTZWOjn5yqKHkT +7RflU7PpV+5uvnJv69ufu/jrH775s1989MUv3tlZKWRirCrxDJPA0DgWsWXGLMTNTsWcbSenG+mE +yudjtsxJIX8YCYRsSWpXcv1+bWt96ZXXXmtM9FAMD/gxuIDhQdArTtMnGCbrvpo7MchhWNaymoV8 +KeMQSAgPoUgQlXllopy/enw02evalr21tZjLpXGMDocpWY7zfBycGwu6hIAQcPCVt+PVTAEKYdEW +Swa+v1S4cHJ6rpmayCh70+kXbq5/+rmTX3j9/BvP79+7urM8Xcs6FhVG0QAR9lEMZipijidlHiN1 +lqgl+Kmy3i8bSxPW+SXnuf3CZ+4ufPmNvT987dTf//yrv/7pV955fu/s9nSvXowKMhmhsBAdDrIc +ExNpmwqhANUlQ24njYrFz1XN9cn04kR2b2ni7pXtq0fzD26svfXC4acfXL165nSvUs3FHUNi8VAI +3FfYz3pGcQgnzygJijp0wjM+EkB8GOoLGQxVsNReNZtQRZOjGtlELZdJR+MZM0Mh3OCABxI27CPA +bOlEyKG8LTtydkZ/4ah++0z9wcXuR28eff2Da194dfPDh73ffvf2P//q/b/42nPvf+pof7VXiMcB +HwKeQNgzxoe9eRGZTWFzmcBaBbm0ZFw/VTjeyV3czj1zpvngQuu129Nv3u9/8dHc3/3lK//0q89+ +6/Nn7+2nSyYe8vp8nghHqTwl0xFMxYI9CznssBdnxcdnsx+9tPzes/137ra/+Hj2Z9++9c+//uzP +vnn1F3988b/85OX/8d9/+pdfv/fW/eUre/ViMkYhkK18TI4WbKWdEdZa+uGMuZDHlipkL0OtdezN +fmK7H7u+V/3g8e7vfvPHv/jl1z7+8NnH97bP7EzpEuX3eMN+AkXkkZHA4IlhxDOeECJZCSlqaIL3 +JgR/Py8vNa3Vrnlm1nzn4c47jw9fubf7h+9e+tH333/95evNsr00119c2l8/eU+PlomAz2bRlIh1 +bOLslPbofOO5M6WjKemVS9WffffRT7//yuefX/7Sw+nf/OClf/+nr/zX333hR18++tdfvPTXX798 +fiXmsGHM7/YkZFCZRggJ9af4wFKBvL+b/M7nD3/6vYd//PkLn32u+7VPz/3gy0e/++vHf/3JxR9+ +tP+vv3r5H35w/QvPVZ47zB8s5AoxvZiAWpmy9KzC8GkJ6cXRjTJ3ayPx1jMzL58vP76Q/5MPL/zq +h2/81//8rd/+7P1ffOfOf/uHd/6///fv/v6XHz4+rn3znZM///7z7z/ayVlqYByFIgsYK9AaHgxS +UPLDnijlt8ixxQJ9dTV1ZT13ZiZ6cdl+6XLnT//w/kev7n/0xpW3Xryej8XRCA8KrBJURWfn0sRe +g767qn14p/2ddw+//e6ZH3/11n/+0Rv/4z/+8rc//cwPv3z0d392/7/+5nNfe+/iqblcDgiSlWNG +QqYoi0HbJrFaQC/06VtL2qtnkt96fe3HX7v1vS+c+/pbW3/1paP//Fcv/re//eDffv3Or7536zff +vfqrP7nx2o35WswtgmBCgr4IEcITslE11JU088pJ/d3Lyc/fLHz79YVff+P8//m7N//xpy//xZfO +/OpbF//5Jw/+8Qd3fvjh7o8/2v7FNw7/7PMnb57MtXLxiB/DQgwbITcmy9vd+EZDubkW/cqj/g+/ +dPqbry9+/Y2V3/7olV9899k//dzB99/b/u//+OH//O8/+Oe/eeO337nxf/z9W9/96GhvCmLBNzYy +GvKjoO02x8/nxZ4V6hreq1PMw5P2syftT10qfvR4/nufP/mNt1Z+/PVr//FPX/nNX7z0ux++/O// +8KW//sbto9XKwnS/UOzimJaz43VH6SfpvSpxZYr54r3Wz//o+Nffuvad97e/9ZmtH//R1X/7zbs/ +/9aN776//Z8+Of+///K1X33t0jceVr54K3s0KYKqKIzgGQkMPT2Ke7wpLjCXDJ/v8jfXrMcXSh88 +N/eTP77zL3/z+v/240d//4OHf//DF376yfFPPz74i8/Mfe5m4cq8Opmk0grhthPloxxlJsxiv97a +6KXncuxSBrs8zXz+fvtP3z/5g4+P/uJL+z/79uXf/fiFf/jJ45//8dWff7z7D9+/8q+/eP6337/2 +zU/33ruceOmo3EwbaIiThDzPxgxRa+fMZoyaTBDnprX7W9pL++bbl3PwNP72z+/84tuXf/q14//r +X776f//bn3zr7e1vf/b849tbAsESET4pK2mRyomRXgxfK5IXp5RXzpa/8drm9z57+KMvnv+PX733 +P//bj/7xh49++OHpDx+unlospHVWICgKk6JqxlIzMSURF7iigi4XxOO5zL2ThRdPJ7//mc3/9Tv3 +f/fDd7/88vrHD3vffXvlx185/7W3dh6cq55dKrULZRNySsrShAksxlN63srUnFhBJqfi1Nkp+/ys +fX3Z/uyNxg++cOaX377/vc+f+9bbu196Yf2NS53XDqt3t9JbXa2VFS2ZjYRYmSvEonWFlsq2XtSZ +ikYul6QHp0pff3X5rz489Tffvvrr79373V+++C+/eOcnf3T5p18++NefvPDvP3/ll1/Z/dbjwkuH +6aWyxKHBkB+z9XI+0Y0Kts2SLZPq6MhyLPDMvPDp49xbVytffbz8H799919/89Zvf/Dsf/nFp/79 +7z//42/c/NobGx+8sLg2mbS1KM/YcDv1fNsUhLRMb7dj00lsKRU+bDPPbafeuNJ96Vzz/k7uC7d7 +v/zmjR9/cvObr21++fmZt6/0Ls8nl0tQUzGZEhlcByczNhTmUFZGgwk6MOmQO237cDZ/MJm+tlp4 +8Wz1rWuT7zyz8NYzC+d60fNd/ahnLZedpChrNC9RAnh+RUhKXMqQc1EpXkulK5Za1vmNWuz8TPZ4 +yn7rSvMbry3+zTfO/svPXvrrLx9/9dHsVx90X92zH67oj3dzWxXZJoMcgqtSxjK7NBkDDKQitBAJ +xelw0yC2KsK5LvP8tvnqYfrjB73f/dXz/89/fPLPv/zUr7/74JNXz15erswU47qoRxAdR3giGGLd +dV1kQeebNjeTkTbqxvFi5upa7vmDyh++tP5Hb55+597cnb3qXDUqsmjY7/ONh8IhMZ3oNmrrqVhX +46IGRbcT5rmV/vWDhekMeXFGf/l8+yuvX7lzevLaevH2bnl/OtbP6xmDB8DhKNttV4jYFJ0GkAeC +ziQacc1RMNxm6FJULVtS3RHWm87xQvHGZuvKWuXMbG6+lJzLJmEYM7ooUAQaoYJB1u8XWCpNY1rE +F0Z9AS4csRl2KpfZ6RWP5+N3N+MfPT/9vc+d+uTl5R98dOkHXzj+zptb3/7U6ifPL3xwvXl1MZoQ +IwDtMqe7rY/JOE3YQQCiMFN1kt1ULMsF+w5yuqNemjWfWbG//cbWv/3tB//ym/f+09dvfuf986/d +mLu+W17txICNNSVj2xMMHWMZC0cElYt2crWcwpUNuukIZZVpRMXZnD2d0hfT3KX51L29yQtzhZ7N +1XQ5IykGLTAoF/Dx46PM8CA4QEIXkyJG8eGwgmJZXa8kYvVEohmzCyqXFZmiKtRtKc4g4AVTgtwq +dGQuBlSCg5NH5Vy2SxFmyA9mm8JDtMaolXhxdWpjuT3dspS1ov7MWvFkTb6ymD87ndkuqzsVbSWv +L+XMui6EwRaMhtGwxrMlDAEMDAFpeob9ZMB9sHlFbNlySUZn09xGSbw6b799Y+q924uPDrtn+5UM +x0koY2n5RHahPX2RoxO6nOIplSPggehRSdc42ZS0VqFQTZolRyo5YkJlLUWIKhrHyjgpA6qPjWEI +oslKluFiXj8TCcsS65iynYvnS+kKEw4nBbaZsKsp0DRLpUWFFgAokCADJBUOcl4PNT5OYXgylV3J +FFbcJWRqjmeiLCaYcoJCoEwzUd6aqi/Md5Z71emk7uisGBXjtosw1NCwx+dnEDzJ8nVZrhlqlaOi +Y8Nez4gPuD4qxRw1EVOtgmW0suZKO3G8Utjr2ecXchdXWpvNzEzW6Kftmm2hAWRoaDwYcPe2j43j +g0MB4E2ayWczi7XSSindURk2JhJ1iyspRFFGT3Uyr1zb+9Sds5e25lfrlYwqyxRJYRTHxzDMRjHL +F5AMu9foHtWbh/nkjMqaqzMr1y7eYjERxksg1LiaKcYrtUw9Z+VUWkO9NBZUPYClgxEIqnDECQSi +Ab+GoY4spCNelAxCrSc9Y5j7+ivAREIijugs6XBUjELFoCeEB5mIn48EBcGdsTJZKqm6m1kmg0EF +sDfgYyk0ypGWZVQ1pQmJwyC8xigT+SruCyXkeNau2KLNRVgWVRhc87mdxoMYajNU2jvOPPW/jJ54 +ahR4k0JVW3FiWpJBWTpC6rQUlzR3Ly6BWAxusWxMiDpCOjBGeN2GMJ1S6yCWmDKtyU7/lJOs4YRE +M44RbRTKG+nCEsNaJCEbcnyyu+DxY8MjIY+PF5RmNDZjWFOC21krI4u5/vQpxax7gg== + + + Gk65mzIIKhUKGwRqsoQR8OLDQ/6Al6fwuCRWGSYPMoWgVjhsSEIWbInXJ3r97lFHBJkwojXbaRp6 +KZloiu6SD3eiDcdt+CdBqshKVdWrpjMRtRuylFTUIkYmQ0gUQc1wxMTJBI7HgkEZx3SWtTUtL8tp +Taskk5OxeMs0SiwuSqwchYGV0uPjoaCfwNCoqnbs9AbOZL0+Zng4MjgUgsDAybxqdNwNif8/e+/R +JEmWpIndganKzAjnbpxzzs2cc+7hHh4enGSw5KwyszKrqot2T1fz3ukdTrAjAFYGu4IVCPaAAy44 +44KfBKhFY/Yylz1ABCEj8dorOyPSzN30PdVPv8/8mWpJLBZFjksUocKTMk/wnur124BLPs3YHB+r +N7XyaCYteA7n5iFSGN+yBp3+lWqMMDzCcZuivaSyrtb3i3kJQ2B6E9PqOf6cYioo5pJkYOhjXR8i +ZaOQV0Sx1xs+8aO15WwxfD1fAM9RbaXqGDXQaIo+iJvH9cH5MO1Ie3DTbdySxHhr+UxLq5f7YbSu +Nc5a3etK66KAuBtZYTPL4bhfKsj3Ps3nsozlLOqDJ63BIz/aA+/dfEAQqFku6vfuYdksy4tNN9it +Nq79cA8jwhLiZHPp11KqlIAzZ9K7ZIXsJoGWJJ4NPGtga7VijkCLtECZAuPwsNyYmT6yhNkkW8Gp ++N4nhbB+Imhtzag/vv5iuf+clWuy2ePlpuH0bW8cRsvl/huMsXDKkrVWUFtySotkqxRXN73t2eLN +x+//rje7zBQklAScOElaTw1vT5C7JOUhmMbxkW4Owd9oNmH4punu+MkhIKLtTAyji+IuQYUUG0pq +341Wlea+5U05oRYnq97w0jB7rjeR9Z7hL1uTF7XB46R16icr3eyuDr807ClJu5bXk/WuG69Ue8LK +XV7pBsl6sf7s8tkPnFTLFUUUt2Wtn27wk5qilj7CE/nj7dVzJ9iyg5liz1lpIChTw95DcYCdCk6m +ewLLqERRlmX1TWctSgMM0XFUt62RdvNEg+nOm4PL1vCxpM8kfUpxNYIOFb0nyi2K8nStg5M+gjic +WJeNASf3C6iXyUqiVMUJrVBIC8nSbEUzJrLaV7UBJzQlpacZIy9clcomSSU01+KlPs01JHXAic1s +js9lededa0YPwVSMsES9L+hDQR044bZhp9syGS5mxXYRdREypMVO3L6y48OoeR7WHm5mxEJBVdSe +YfUJKqAZiP0aTlQBnDm+QRBBPi8JcjtK9qJ4l6LjtPco5snGVLe3fW9Ckxa45f37WCHHoyUZx0yG +rWLp878BQYBHRaUcB7Am8lEQ73jJvh3tmuEuL/c2NzjF2lLMca2x9+7z3062rwjOZ+U6I1aj2m5U +P0wrhvlbarrZZj9p7GCMXcA0hAhkfTrZ/jDZ+0l3/ko0uiTjadbEjQ/d5JhXx7TYhvkP4nWtdeIl +OwAvGOFZ3na1/TysXWr2kpdaNFuFCzCcLZoLCdLRrBF4RWtw3Z886wwfVZsnjebRk1c/172JZI26 +izf7Vz87e/6Lo0c/6229nO68d5xZq75z8fw7nA1YqQau5VZOmsNn0/XH8epDc3jNilXV7FneXDUm +gtIF/9SDbcOdHRy8e/Lmt6Y7yRR4jA4rrfP+/H1r8E7SFiTbJJgKLdRu9sJZJGXl0y7MTlr7l6sI +UodkqmGylzSOODmmhRgWUbG3rSjtsBzUDsHHcNzdWb8Kom2wt1BWARJFbSTpc9PfU8whzXgkYfje +2A0WAMUkBQCY2P5OpXle71w22uelsmXaW5a71q0lfBbOVEp4kCloBF1J6qei0k3r2/MVxRyZwcrw +14o5QQkXHNuNdxnIGmkltCmn9ILaieYs3ORAcZY4XbH8nWrrYREBt3TAtQRxYFhLP94Fiyi6QtGJ +G+5AIgYPzBdkgnQtd17vXMj6LK3ZUpDgqlA8BGTbuF+8f7/8ICNgdN1yt/14TzXG5aKKIoZhDFQI +YSaBV1o8k6s53rZmLfujZ73xtZ9s80pNtQZhfY+Rq5rVN9wtcELDnddah5PtZ268hZC24c84qc3w +DVHrYlyTEie00P/jHn6MCiiuaoU7Qe14uv7i/MUftk++o4QGw8Sd6vr8/CPOJWUyxsgqJw6d8KA1 +edmav7LCedpYrXOo2CMrmOvORHemZrCsdc8rrUPJaIe17Rdf/Nnl259P9141R4/dyjH4JBiyNX90 ++fwHmDHDGfVnL4fLj/PDnwy231jxLi11k8bByfVPe5PHKObXGifnT366//Cr7cMvH735rVc9BBAD +/9HtsWJ0aD7k5dbRxc8PHv5yuvdDbfCc41usULG8vhHMMgW1jFiAXa5/7CdnldZVa3DFCJ7lj6vd +q7B+Dvgw3f24+/C71vCRnxwA0bKDJclGhjM0/W2/sgd5wQwOEDJ92C2KV0enX0hyA8VhlWM/2mlP +YAYO9GBfUCcI5g+GjyrVvQJiUVwLJyus0Amq55XuUzM4xOl6s3Xw2ftf4GllPzlXNAC4NIDQ0dPL +t3+pGdOvfvL7//Sf/4/+6Dxb0Mt4YPiryfFX+09/OT/6xq8eoYTf6j+E0CiWrExWYMQmyQGuzrrj +13H9olxyCNw1zAHEVKHIAXZlCnoRc1VwodpFd/7u3gMyl2NoxsepCCdi8EmaraN4TDB1v3Jc711D +gi4hBp7ykzontqudRyzf5EFhqT0AEzvcmyw/7F//qWJ3k/pOe3w5nD+ebD9t9E7caA6TafqTyfoN +rFraNteaRLWzwfz9YPE+rB6DmWXSYaQqwBRkWEkf6h5E1qGozb34YLn/Yb77gkn3Hu95ydoKVoo5 +s+P9oHFkB9PTh58//ewXfmWbTavKt4EJz3bf7T3+MWiexdXl8fHLv/vH/2W29xjnY9na6s3ebO1/ +vT79tj9/xIlJoayIaltQ2rQYC0YH5yu6t7U+/e7h09+Olp/p3gJS52znvWpPWblthfuj1fu4dW75 +a8CrpHmQLdAoKVZay3pvHVRXJN/i5LHj7zW6549f/Ozp659nC1IZNTV9tr3+5uTJ76L2C8mYK2r3 +1//mPwzGVzgZAioeX33/67/4n3791//x/M2vncoBsAXPX/z9P/yvYWUnV9QptuXGp63x2+3jH65f +/tl4+U5WW+uDV93BcQGRcSaSrWW19+r08e9XR1/uHn9hpoXyet3x43QRydDyt53kQPd2JH2rP3m9 +f/olzdaAKgNEW8HaDBbpplapD5zt0fPvvv3V32v2kBWaSf0saYAA3pPNmagMgI2oxnS6867SfJjJ +aQjq+5XdSue0NXo0XL4EXCoXQKUf7h5/BAKcyYmQ6/3qlRms7WhP0CacNMrmtUZt9f33fx4Ek08/ +yedzHCc2otrF8ui7V1/9zWD2DEGdb37426S2i5E+BuzeWlFAnJga2BI3rmY73776+N9dv/m9509e +P/9msX4MjMsL50n9YLx4Ml+/3tp/2xhfGHZ/MD4fbb/i5bbmjnR/yqsjSKy6tx3Ujnqz55LeBbam +O1ud8WeT3e8Wp9/11+80d1xNth+//GWtdwBuEFQPWqMnp9c/fPjq33744e/XJ19Uars76+fbuy+9 +cNEaXG4dfGiNng3nz86uv3/5xe+bw73l6snx2bd+ZV82RoLR5+Q6MDHFmIe1M82euf54ffLGDKYk +VwkqB5AUrGhfD9aLw5+cPP0V+GRYPaz2r0+ffn/59ne91eegk1A6IejIi7f6i8corTrxWDInmrNq +j540Btd2tAIrcgVRkJq2v2X6Qy1Y6MGxV3uYtC5q7VOGT7tZ9YZnbjTVrFbS2psdvW+OL1rDi+74 +SWdwyfAJwGPSPEuasMrruH0CRNqtnvvJUX/2IqztoYQ1WTxZHn70Kgdh9cDwZna4kLRBvXkMXq0a +PUlpn15++d1v/vvnX/5h//r78ep9WFmrauP165/++Nt/QsmQEWqVxsHy8IvF4Rfzg/ezg49A0r79 +7s9PT9+zbCwpjen++8PrH/ce/nS2+5PV6Y+qtcwXTVntkXQYN47i1lnQONb8LSA/zeHjZv95JqtS +dLXeOZe1cTbP5Ap8JifRTBPmGYSA722jqPlgAwP6qpkTKfW6vqgMETwAKHv66neN1hHwVYavgidA +chSkLqRpYFxx46Q7eQyxrOvth0cvO8N9lg9db9oHyH364/XLX83Wn0WNten0dvaeL48+IEDqxNiJ +F93xi8Xet72tN53p83r/3HanvdG5Fy2C6l5r8rw+eWJXdmVz1Bs8Pn70i6i1z0qVyfbrzvBq9+iz +tx9/dfrk+6S57zijk6O3e8ef6Va/0z99/9Uf3nzxFxcvfnXy9MfR6rUXtL/48PN3H35D8wDCAF9j +O9wGH2gOn3vVM0kbt9uH3/7yb6udPUaotvpXQf0sal+Pdz+8/vpvTp/8vFo7fvnZrw+uvla9UaV/ +4VQfKu46qF80h68mOx8Nb2HZnW9/9leACTgTM0JD0MaiMVWdmaz1+sPH063nj59+PHj4uajPNGcJ +gIyzVVqs+ZXV/sW3KWzKlWbvuDt/3Bicj5Yvq90Lmu+wYqszfVLvX5BsojmjxuhRb+ttb/H54vCn +/a23Xrynm4OvvvvDm4+/MdwJkCtR6YNAGC9f17sXUXUHGKyitU7Ovzy7+rLe3vOr2+Dtlfp+f3z2 +5v1vrp98D3rB9Rd7Jx9Pn/086V3o4Y4e7AB9/fzjr/v9fZKwLGc4Wj7rzx5VG/sQbqq7UyaSfNGy +7DHNRqvjD8+++qvDF79ubb3qzJ+3Js80Zy9fdIDH7u6/1fQBRYF4D3EiEoDzuDuqPiXJJJPhCNI3 +zBmAUianoFikGUvN3A4rF0nzAnRZCTUgoBiuDqpBVjppAXncghnglY4Trqqt0zQ67JR5GkbbtCeV +5gEEo+XNgB7r5qjRu7KTdQaSLxeCa01Xb6erD3a8w6vtMuFoanux/crxxqrWBKA7uP4B5v/82a8e +Pvvd1vFXRjhnhGT74J2oAKVJ0pB3po6/1e6edAbnujMUxDhJZrXGtD8+rPeOgtqeCjTMabe7B2Fl +AUlE1Qc3fSsiSgydZBU3H1ZTGDmptHdozne9wRff/vXTD3+IO+fVzsP0oelobtuDhw8/P738CpAW +eP5g8UV98Ly7/AIwRAQuilnN2uqzz3/Rnz7cyDKc1AF4ac9eJu2HENr1xv7W7PIf/+E//tlf/HuU +Sgi2JmmzsH6xf/Xj85/8u9XFj7o1ff36u//hP/xvw+klaDTF2ZNtoND7s72fnL/9C1g1igljkEW1 +XVEFf2tycpuX2ro5bdyg05NX3zU6B0fH76JkrdkT0BokWysTHgZ605qOZq/cYMsNF15lLZuD1e7b +w4df19rngpw2TuoNHtYauxKsWvW0Cdx1+rzauza9JSwxyIRG94wXWzeizwQwtKLj+vB1rf9E0vq8 +WJutHp0+/crwx1k4AHckfdSZvIRTao1Dz5ul9cEEr9E6ZLlGsWhmcirkxFLZY7lmuw== + + + +3Q0/dywZr3BWad3SVMRhtpA9fMlCzzNdLYrzUuWa1nBwvAmEHcQApLWBYquWjMz2GGkLsFWOKlq +OgOMdHR70BxeVNtnce1kvPgw2vlCdqcY7VY6R359D6U8Xu6ATFNBzY2feMEOHKaaQ4YNxltPx6sX +9f6Zm6xVb8IodU7t1LsP26NHAA6g0E13ajmzZvuwOzyNG7tl3FLUWlLf5mRf16uOP/XjdW8K0vII +lJGo9QgqsryV7s5RUje9Tq1/Mt15dXDxw+rka4QwiXQrfn/74LWgd0E6pYXB9cl4+Wy2fjpdPVe1 +rqJ0bQ/0VyVXFCEKqq3jy6d/Chwjqu7TaXFCMV+SQUeLSr1YFgE3gsqy1z+Yzc6ev/im1dkl6MSL +joLkzIv2DG8LJAPgW1TZ3zt6f3b1E5qvkGw9bj3ubX9V7T/zkl2/eihoacH/i+tvh5OHIJYJpioo +/f7kxcMnv9w5/Hw8h9R5PJk+/Id/+J/Xe29JvlPpXbfnr1rTZ/3lK5hwlq8d7j7/z//7//mz3/0j +kFXQnqa/W20/6s/fNAdXQbLj+bNnT7//7OMfJL0PQMoqPdWa+/G+7mzz8ojhmrXaavf4jah1aKFL +8R0ED8uIoxm9/uTi8OILVohVtWPZk7i6v3fy5cHxe1HplRA7X1BcZ3p88qWsdDc3hXxe04zZfOdD +u/9Et5c020ni1d/83T999vZnGxsk6AKUavLSuN44bzYf+v62KtfBfEnv0FxMM4EbziW1rzpLVhkC +zW50n1SbV5XWKcw5MM+ovmukBfknnNxhpY5sThrdi73z77zKTr4kwfVo9lQy+o3BQ7ACsi0rVNNS +b6NrzR4ATIXV/drgarB8uzr94en7P5vufsaINc3qpu6EmhQVgbKQ1CErdoF2govSQhgnE9BZCOEC +C4UJQUkfPsKvHJnBrqj3Fb316Nk3ljeS1BbEKYgC8HBFbXf7F6dPf0amLfYaljNV1B6Qt3r3MG7u +kUx4U9h5THMRguqq2Uuqi63lZZhs5fJKJq+WMY+V2kG85vlQlnw3GLVHJ/un79dnHxuDE4L2gKU4 +/vZNdQgZ4gKo8vroq7Onv7XiE5So5gtGpbKTNPZxxgcXBS2PYAEvDb3kOGicQdRQtL/cfQ0UkU7v +BtcoJgEE7vavxvM3ncELnKqSTL3SvgDSdXNXwSdpn8DTKnDP3/xisfdSkBI3WPQmT2Y7b5LWCcXX +gSsCH1ssn/f6ZxQTWP40qJ9AJO6efdsYPEHJSqlkxtFiufuCl+qi1DPchRPty/qsUj+abb+pNg5Z +Njo7ebtaXslSQpA2I1T8ynp99uXBxXec0CbIEMVcgWvwbL1ctgjCL6NwTNrxygsmjfpCFKrFom77 +q0bvOU4E5aJSyPEkZqliIutjSRuxYgcgOmnsOv6yPXymp41sdqY7H0GOufEuSjgE4ShqC1bEi1ea +s2UHeyPgDAdfzvfe694sX5RUvc+KdVqsa8GclZs45Fm1W28fdyaPJa1lucPx8mXcOg7q+2FzrzY4 +gkQGrqU7Y1AxCOYo2hgkqpU+qTGl+SYQHvD28fQSxCnJVwVtQNA1IISWC0J1CaaJWh+ucHX8BU6H +qtaebb/ojp8CzXCDVa150hlfg0LXzZ5ljwDYaaZiuFtWBEjYpriIk2JOjKNoK4znZVQsIUKhLGdz +Esk0QHOFjRNJbqpCcLC6Ojh6TbI+hJ5kDnmtr1ljy9lS9SGCGpbdrbV2/Xie1LbtcElynRICqjzp +Dx8F1Z0SqtCMy7JVBPUkeQDTxaaNF01FaT558QPDJZubNIraFFtx/MX68OvV4bd2eLyRVYqIDctR +LGs3JWgsho1Vpe0682rjxPIXhtmtt9aSkjC8B2HCim3LXSS1Ay9ag5wkKbfdPeqOr2E1DX9btreK +qE8zdcOYwWE0HelqZ7bzYrzzmhXawIU4oQWyDket89O324tzVUlMu11trHqTh9tHb4GhlRAnkxWL +JVMWOqrU2XjAFQq6rA8BS8fLV164TRBePq8wbLXWOvXC1YMNMptJKwTCBbvuzIv2u5O3YeNJUH8o +6y2adRW9LqtNCEnVmYoaoEcXYxpgL0wpjhu11lG9c1VtXAK9gQxI8jWUikGx8kJCMT5kt+HizWTn +vRcfGPZWUNlVrYFmtkeTy+n2S1qIKT6ihBjU4uM3v3r79V/uPPwG1DpOuiBCAdMovlZCLJyqAXaF +yf6TF3+6vfc8rK5Wh28FuYsSPjgM8BDFmHgxXPbL+eG3nNhWldpwdBwlW4IM5A28OpT1keOtvWAl +ys1sXhAhWZsTE1ResIQsX8Itmo17/QtIJZkMnsmgxbIMApxkG7TUIfk6LKvARdV4aTuDQlnVnYUd +7oNYiJtnFFcplU1wrcnkrN5eEZQBSRMhAlboxjUgdYewrIWyni/KYbQlya1sTi6jLs13VXO71X0y +mr5u9S4hfXBcZTy9CuKttBI4ZqG4xyt901sL2ohXugiirLaf9QdnBOWD4CLpBHygUNRUrRcnq2Ja +gJFm01pALR5MFus4HReQtNFPtb5frR/ghLd98P7px3/bGF3DRIlyD7w0nxcEzg/DMfg8hjm82NHM +raR+ohn99Jk4TFOU6v7Ry2ZzIUuBZnVwuiLrk6R+rOkTnmvm0vohcrN1MJpdARqXy0Y+L29u8gxd +iyqHQbxPkgFSViGWZaXNUFGpqEFom+5ITplJDGldkNrA/EkqoqjYhEgPVlaQMlJBm3PAvigPIIjh +KkDbeL4hqyMnAgH7xA7XOOOUUJHhQbMMdKOddo6zZqAQo/oxiMHZ7gfZnJYxU9XbAGX96aPT66/P +n35b652IRn+0fLo6+xg0j3JlRZS61caVYc/dcG14U9Mdxsn2YvctSUelsuYnu83R697slemtJH1C +8y2SicS0T1OLpi2WCQ17kdTPVgdfTJdvQBpAaOeLiqQMQHxJWm+8/XK29xWkJ8tbArhRTK2MWCQd +4JSLYlZYORyt3g1XryfrD7XBc0rogrSBXDlfvQkqewARmruUjanl7dz0NIHAD5uN7XcffwV/z5dN +TuqJ6hB0UFw7qzQfG84S6ArD1h13pWgTRZ+44T4ckCvKGxtp067B+ErW2yQECxnSdKIbQ15qYeAk +ZYMk7b3DF63ePkbatr/VGj6J68e2uyPK43xR39igsjlO1zqZDC2I1WrraLZ+/+Hn/3T46E/9ZAdw +g8a1yewqTIDMQ/5Ki42AdTjhKsBk2Eq+IKYFedJ6416+oG9ssoWSBv8qCBVDr4m8aRgVzWhB4isj +aU3v+/exe/fKxYIicGk/LBRTSmWBEyplxMXQCMSIYYFyrOSyoshHohAWC0xuk8lnJVGGHJo+r8ow +iWEtg/hENuY4nWBEIGtDTmoRTAKQpVtb1cZ5vffYjldl3NnM8AQRMBzo5QavpJV84sah7kx4KcFQ +DkdYlrUNqwe6cpB+R/PD1uEXJN+CvMnxtms3XBeQHLhZH0T3bPX22cc/Hx+8ldwZkAfLGetmm6Jd +xRiPtl5/9vFvX33+d7Pd79JCYbgVhFumt+DEJvieZi0Uc7szfBlVTmi2gmOq4wBYzVWjCy+KreUK +ehlzVGc+mL8Oq4eK0R3MruLGPsHEgGw017D9dWv4otK+hImy7fbZo+/n++8ZuSmaYy1Yi+ZMtaeL +vc96o0tBqkXRfLD1VHeWTnCou2tJH1rupNs/W+68FNMn+5q11lmje15pHsJsMEILmHAuLwl80zZH +CCKBXqMAFblmkBxI8tCyF6o+LqNeUj0wzHGppJNUzMt9Jz6sdq/bw6eC3AQshQubrV5qwDzTyof9 +IhKARRjusGwiS9Vcljb0dqW6cLxhUtsH8Zs2pCgKlt7ynDGQSRz3ALo1YyLJXYoGCRBC3s/leNuZ +yMogl1MguIB+CHLad4xmq6WSWMgTQTCs1vfKqPMnaa0/EUEA8RQc81HwtKKazTHt7v7O/htI9/cf +MHAAcC2ea3FMFS3r8OYPHmBI2cBQjxVqmQx187WpBcmXk4aCOgaKzqtjw1uD7iuiuqIPo2RvOn8z +3/3arR+WSb+AOJzQRfG0uCsvJv3Ro8tXv5/ufq05s2KJ5WlN4F1RAp+sW/7Mrx2YEWTGhaz1RCkQ +eJNjDVFODGdkOONa6xgEo1Pb1+O1GaycYM6LgJkuiOVq++Ds8pvT6595tXMMDwW+IitNkvaAA0eV +I8fftby9pHWl2yuMAP1rOFbaz6tQZAjSUrQRjke80PKr+36S1nxW1HpvdCLIddDCEDW6Ne/PXrcm +rwx/B9bdNFud4UPLnyCEbfir2d7nR9c/A/gaLd+oxgA0zqAHGvYEwX1F3+qOX51df//k9a/2zr+p +tE9JwqnEs7OLLzu9E4yw0rZ0iEmzNdudK1JHYONSkQvD6XTxQjFGvARwAfPmS8qI5btgBawpkJZ+ +/2o4e264S9B3rNAqph0oVFluDydXDA8z2QV/070dRkyBGkh+Wi0/x8lirMqxJEXN9pEdLBm+Bhgo +K5AB7c0Mi2IeQQYFAE8m0fWxIPWZm2qEtj2m6GqhCP4Mb+WBF6FECB/KSw1JqSXV3bhyAFP6yT20 +WLJg5rM5pVC0UDLCKFANXRBKfrCArIohDk1XcSyAPwtpOw8xzQJUZLtbBBEWMPfeBpnP8+AkktIC +GG90rq5f/P761V/tnP7oJYclxBDkhgmUyeir9kJxdwx/v9F/PV19k/YbIk3H69n+KKof8sZWDk+y +BStwluPh42rjgKRtXgwFpW26ywVkmfYpgiuFMgN50/SAkKctisCldb3dn15N9t5pwTYjtXEqBjOB +L1GsFwSjINkO6qcw55ATywismipKKeDwUhfDbUFqRbXzuPFINXd4sZ4vMBubCEE5qj4tltJqt6LU +hiVO+5UEM88bs3yFID1wclgdQemq1lbSvGwPX+jOXgo1qApof3b+DbiZbLRpoY5SVZyuCnKn1gJ6 +XwPl20or+L2eLK764wvNmaB0BFzC97farUPbGeYLAlA1YG402xKUHhCkjU0umxM8dzwYPcQJK61p +gDuqMV7ufr7a/xoIT76gCkLt4tE3AIAAp5zYEeWhH+8HlX0rvUMVFQqSG8yrrQOSizZyQhnzab4D +DFDVJhwTSFzgmO29ozdOuCzjwUZWZoQ2RlUJphFWT1JSlGU8e9hpn9+Ux9EePKA2NxmCSjihSVBh +NitAZAXJTrN/3Ro8ldQeyzXA2SDFA8wK0qhUdiWx4yRHlf6V6S/TfUSYUyyo4EiK0K1X1/k8k35t +fZ/imCbH1XAQfaQDTAwSB5JubvEB82W10eicjOaPRovHk+3nUWMPsj/HN/Q/PomvNjvDx+uTn87W +X3amr4GxAE9IC3poVYoLDGfhV4DYHznhVX/42WT2xo92EFyDAzQLxGPCpNKsRbGx5U6PHv70+tWf +Q04ppL0aNUWrc6BVjZGdHDBSr9l/Ply8F9URSPXx+CSpLjEqQED2Yj5oc1Hs94YvOg== + + + 4ze81AcmgBOmog4AuFKNhjk4GQDprTZPdk6+IagqQyeK2gOqz0kd0FDAHwSpo6hpAcBCSYDgArkx +WTw/efwzXhll8nKhpAhSxQ+2wAdu9mPMwGlPHv364PynUtpbRwAm2emfdPrHQH2jyoEdHkbNR8A2 +ObEHAZvJsmn/FGucz4vZLI+TEcW1LP+g2nr+x41GhQKP47qmNYCxkJRFMSEQeEUeKsoYQiDdqUIG +CshhKqToCOILPKSIeIKQxNWFarSBXKlyq1I5qLcvIMWTVELgFks5ht4wzRpNG6pSBw+vNfbr7Yeq +OaP59samUCzwHO3wbAgAQlIBy9Ute2572xSdQH68f59Q5Ea3dyQIUSbLQY4rIr5obse9z3qL1443 +RctiNZqMZtegFj/5FM/k5HzZoYWB5h4G0QlSAu6Hm0Z3vX638YD69B6Szcqc2PeSfYL0IYppNuTF +mukMHXcAClQzqkzaGsOk6SAItqvNY9Od8GLFdEZhdSmqDbAdZpJm0nBWrRErVTVz7Ia7urOju3vA +NoE5gD9AlBnuPKgcAwQBWw4qa9VIm9UmjX3FnuZRO1/SWK4axNu6OUwqh93pG9GAXDwguFoRBQQO +OKXDiM18CZLyVLd3gBUwbBMmB2QXUCnwbfBYYBfFooiRDkb4lr1S9S3NnDFCp1S2eaFB0Em+bDFi +DxK96e2CggMfS7vM5GlwIUmuA/CyQlXQppIx091V2DgpIPpG2gNRA1FDMqD0a6o5BVdX9X5//Kja +PNXtMcsEIMeAwIMuK6FetqCimAvwaNg7oPezWbZYEIplFcV9URlb3n6+aCGYQ9Ihm95PqJeKPIYq +IIuAJSr6CAQRkFuAFJKugOIA+QC8lOHbprNqD17B/AP3uGnjpexuP2/WVxRpIWUd4JGmPObmVcxT +Aq0uxgd/89f/o6HXiyWtWDLKWKAY4EJVkkjLUJTLvOtPVbVdKmlwtYUCEDMdSJQgpE2xS0UBJB7H +dyRtIukziu3mckJaP60oaEpVkhv3HpD5guaGe2a4mzTPDHedzZuf3iOBs8lSeoekVFLDaGl7a0Bd +BE1lF0STICaq1gnjlQiSloPU6fyxcgJD+4Y5dP1lVFkD2mhGV7OaJOMU0/Z5siC00vYxRl+QK8C4 +lLRF70B3lxRdS+vw6GMv3lscfrlz+kNQO4Gll7UWLCIBLkcHGBnjTENURl64jmq7pj32g6XlbSOk +z4htAqBYHfvVczM8gJwFzESQupKabupL90CWbZA2OFEx061fzc0NvJBjFBWYsymIA5Ju5otwhS7N +1sEhMaoGpyjmQlCnsrFVwr37GfZBlimWFUlqUqTD0g7Epu5u2+GubG2RfKOAaAhu00CVlQ7kL3Bg +x18nzau4erJ7+HVSOwS+p8s1CEOAvrTLKiQXsR8mR1urD5q1g2JhLieiqFlGjNzNtmRJHfPywPZ3 +bR/+1cpk2HJZY7iY5pJCWcfpGKQuCEzD3g7iQ5Cim7m0hjzN1DihbjoglnfzaUtTXeEb9cqOyIew +3OWinFZvLin5nJDPyRiiuUazVV0O+3vFQloIK+2vwVZBMsN0ZbOATmUcN6PqIaxmNsNybBWQAQQs +x9cxzN/YIB/cL/NsIMl9BPOKRaMMdKJslkE8pj3dPHDFTEaUxFZ/eAFAVEZ0+HEzoxBkhRe6sBaZ +jFSrLn7+m3+XJNv371MPHigM3yBIF0GVtAoNkz4NwTIReHWpDJox4LiY5SJZrZt2X9W7vFB104aV ++0DJ0lsuaQUPn2ICjDBQTKdpj+XTvQQY4bFcbDmzavusNTivdo5Ua8AKMP+VMmoUSyrIYZ5vMlxH +UIBOz8A9GL6S9izD0ruIrcHLoPbIr1zb4ZmgwIlVmg45oQpJHP4SJQ+d4EQzFvACLV/GzMwmTaCm +oQE9Ng1z4biHgjQBfHOCXdvbR4lIkWsQUwQVE3SNV8DZWozQ84I9z99FwRsZb71+IqktoB+COuOU +tHO9E8wUvYuToPJ4Te8H0S6Zdj8HZ6iXENBBLOQ1hvVKZYnlAkh2DAfmNMGHMzk1XzAZtuV6a4g7 +YFmlkkHRFZgWhm9RDCQ4NZtXWaFbbV1G1QOOT16+/cXR+U9YsUcxDVbqImSUK6XaluFqpRT3dIg4 +QR4DEyAxJ58T7z8gNjY4WeoAFoELpVvUubZnL117zvONXFqpjy2mHffUTAbPZRhAFZKFy2sBtkhK +v4y4GxvMaHQBcQrpEiReJisjJYNnQsfqwTt8eg+/d5/EcR9QMZdVNje4HByA+LI0MI0RZO3NDJ3P +C8CmgJUB1yXJuFx2MMyuJvPp9JIko2xWF5WtVOgRYRnzMCouEd5GXsjAbJR1WeoF8Y5mpuIIKFMp +7QUjcpwPyavaehQkDzmxK4htlq8XSvqDTWozyyOoSzEVkMkwGyRtpZWFuISXu6wA8rYtKu0SbsOb +g/ChqYggIKglmvHFtCN2349WaXsaoQ6X6if7lr8NBCmtf24MnGARVQ5ZqZVLm3BpIJrSKkl0CKHE +sSB8OnH6PdocnLxQkMFAHlQSDYkyEcSmKLYhJ3reXBAbaT8yxK22HzvhsWYuXH/F8i1IT5pUq1SW +JUQjmdiPD53wAD4LrEBwZzPPAhFl+TbDVAFngDyUykEJCSFU8wUjk+XLiBolW5xY28gwhaKhGAs7 +APKw54b7IMdyN+UZcTKEj84WJaDEijZ1K/u9aXozBHgshLPv9r/8yR/2Dl+C7qMAu5QhK/VItqoD +wfCXKOrwfBRWVrm8kstLEDtAhCiua7iHXnyWyXAKX9uaPCEJFxypiADBsItoENYfzlbvDGu4uYGx +pEcRHoQzTDtwbyBXDzZFjKhZ/j7AYCYj4FgI1sGswlRwbJjuKSUCL9qttS/zeaVUNOFF4jDPc3Bm +DHWBbuWLKmg64FH37mH5vEqQkaoOILuJYgtN/RZ4piZKfYwEBTdhhD68aKFbxNxi2UhvR4tt4EUk +UxGlgeWAQG6CvqCZEPSpbkwb7Ws/PsKpOoIlJSTGiVquYBTLNtAJAugEX5fVXrphm6/A+wO7Tjeg +sklYPZL1MZBbDD6lCA7M0rSZpl3Gl/S2FWy1B9dJ4yGTfrkWAEJKYqXeWPdHl1HjlOIb8HvdGPBc +AuwISKkq1XjOl0QvbRlDu0BK0y+buIQg7EJehMzuOlNVaXNcIikdimvgdA2yMM3X4CIRzBSlOlyn +5W0BXRTlHjiAKLdMZ4rTIBk84MBx49xN9sFbOHF40wISYKQCDBMiCCBR1rbg3SiuotmTAmJ++mkJ +ANDzd0S5AwIwVwA04AF2hrMXo/krcFqMsKNkD64QkJAVKvmiAqQiTHYmyxfrh9+CWAbrmp1HwBJR +wi+hNvgJgFsmK/F81XKHxRtdeRN9XYBfnAR2p2SzHAGez1ayGRrYXRn3SRYox9AOdtibntogKyRQ +3JgLCCMrwJanDNMBwgAeLorpTadclkfLzoMNogwhqfSi+mlQOzt7+pv33/37auPi/n0G0AxemU0e +iBngW6EAZKzVaJ23+ldSuqFamc6eG+YURf1c0cwhPs5UnGBr//jDL/7sP6UVDskEI4Csdr3wWFLG +4IQQLOBIFJOAFZIE9HUBsYBgMPkdSe3waTuVLsi9Qtll+L5qrDVjp1By0k0XiI0RDvAizZgB5gBW +CEoHIwOUSG+gJY0j2YD3hwWCZOqxLMQL/MWkKFvSmqY/m67e2QEAVFdUuwwTCqynSJEoQSJLv7tJ +6kd+uMYJH8NMRW5JYhVBpWy2DOwUQXVYlPbgMUBBGTUh3IT0YZwqUpaBjTBMrJnToHpqR3sADoWS +CgsNroUSFic1SLaW8hwPAGdpunM4IN19YQzixokX70PmgqADKiWrM9BuKAqJRlS1UaVxxcsdRqhJ +xihbMu89wDHEUJRWqSQV8mw+x8Dnykqv1jr3wp2bdsxetblWNGCqrgC4xDQh1wNhWB1/PLz6PqqB +13UX268hdsDJdWeLl/sQzgzTADmPoBpoYVlpa/oQWBz4CbA4nAgopk6zNWBB9+8jmQwDiSObV/JF +DSO9NHxwD4RAkBzSdAJ03TS3Wa5LpotrF4vyxoPyxgaGlEyarAH80nw9aV3sXf44XH3eHj8Fblko +WPfuQVpMHw0A6YciliS3HW+72b4CgQnZHxQHsLLt9TvXWxaKJkLEin84Xn/+2Td/+c3P/+rZyx9K +mE2QIdA50DWSMgCQAae66S46lrQBI0C+M7MFI582j0tADkNwwTWDfCPZBJCTuLlvX05TYQI+yfEN +oEYo4ZBUBDnLTVtsXHBiq4Q6LF8rIloJhUTZYLk+Jwwg9im2iRPgYImQfqPtA7LRfKfRe9QYXEOk +39hlA4tDcRNwBiNcBAOAainaXFHHgB6g43I5mmMjKu14CzPZEkAXREfV1jOWrRUguW9SdJo3Q4Jy +GKHCyi1BGynGXFQGCG4WinzaN8rd6oyf1oePOblPMNX0RgduMXxEc+muNpCToCOag1etwSuCjjcz +VD4vUXRMUG6prABzwKmqqIFD1lgOVtl+8ADL51gkfWCBTx9kEwBGWnCiqLZ0q0fQrqQ2kvqlExzZ +wUo1u6CASC4GqNT0XlTZKaM6hruWt6NaYwA9DPXzOSWTZUolmWNjUIUP7pUh6StqT5R6ZSzK5IG5 +ySmjQ4CW0A82KCC6DJtwPNCqES/2aCa56coKsKNvbtLFgoIgdrGUFjkEccQyLV1fwurI+lCzppwI +ach+kOE3MhpBtSSl7XqQl0e5HEyjL8stko4gpW7mFJqvSnpf1sa2uw34A/AFXM729mx3K61LzwTF +goQQCc22Wa6dT11IgVcJsVRtAHoHsFH10vtFhRJwJDmTA7rl8NJINrdFbcrLQ1gIBMgeEYJDorhX +KBnwgnzHCWmNX4J0EFTFSR2/CaL0eTGuCq4IehykHDDbdvfJwdVve6sPQF+BAIPnUDScW2GEWNJ7 +tf5Tt3omW1OKrwPMFoFmFDWYEEh8QIYpqimrK808tP1DkknBfzNLcnyt1riIKmeyPkfwiGDqoIJD +fyHLDeB4IEvrrdNK+5pgmiXUw6kYaHZcPTLtERA/+FdVH26t3h2cfSvq/TJhl3BD1kGWjiA3gXUM +13Cjk6B6qZrbEK2bGbJQFIB9AchAjMDHwUwKypTmu0D2VLkJOEPTkevPxotH1e45K00woporqCDr +RKlx0zhbRTFVN8bt4bPu5EV3/BynK+AGxaIKqAvuBECUz6nlsqfoPYLyCpDgNum05CMdkWmZPjyT +4XN5XVaGte55CXc3s1w2zwNoYzhoJRmOT29bPWDQm8CHYIf0iqT3zyuC1L7RI26+aJbRkGQaXrQP +lm5sciAb48pJVD3X07YXFvDbTI7Jp306knJBuX8fL5WsuLq/f/55rXdA8m2UiBHMRbHAtLfSrr5k +KBuzWufRcPo5RoJ4aVFsl2TqaX4vyNk8zElcq52Mt97N976t9V7kS9ZmVkovDPVQgA== + + + NTomuaasb1v+nh2sRaUP2JgSg5xcLINmrGr6CqjaTXX9lD3mCtJNSx0TEA+UNcU1KRZivGKa4yBK +m91DqjWsVVw91Y0JCFKM0EW57kRLRumySs+tHG0d/hDUztNv5XJ82lwbM1S577i7ICUkfSrrM0kZ +avqIJNIa44Wiki+ogMB+vKtZk5sv3BskXVe1MciEMh6gZEWUR63Bi0bvCTghAE5acJgHqtb2gkm9 +eypbk2r3crB4PVi8E9UpBDUsTRjt1dpXjDDEyAYvdngRrIgxMm3rgxOw+pPW8Pnu+Y+avy4hKZ0g +KeADHUGuCUrixnPF2qbZ9MYIhBUEVzYHOi69P5CWQLd6uj3VzC2gQILYE/hOPq9tZthSScexIP2T +cCEwAfxlbcgLvVLZBnS6f68k8TUmTYgeBDgwjaRx3OpeAqAVSxyKKX4w8YPte/dxAH+CCguog1Mg +Uevprd3MTQ1Mvq3qW4a1hM/lRcgCcaFgK8oMVHYRpNkGCUfCXKFkDdJfseRms/LGBkWitigk6Zca +TEXQ553Zu+XB1zGAAGRwOgJ63589dYIlJP0cQAEei8pcs7cBfAplHTyBoqIoWtZqu7XmKcxtNm8V +Si5gF2DLZo4rogbB1gx3L6yfGsE2K/dosBcLb2i8eyMxYoYDQB6TTAfF40w+7XMEoMRLTSda29GB +Gx+KcpdmYuAJGJGugqQCMZ4AHAEIS3KTE5IybgDkQjzO994fPPm16izBezczXCG9g1fj+QRJ72Mo +kGtMdw1QrOnTbBaENguSHEFNmvUFuYESLmCant5HBZHYKyM2wCYnDXipr1szgqmB2pK0LVkbgWrg +RSD8NSdc1npnu6df75z+JKifYlSjhPrAXTVtdHMnqiPrizA5NNwFyddB8+ZS7HJNa+QCVfMWpNDB +mTon9iwHPnSC06CS6t3JuagOS2WnWHIKZYcV+iBOU6DGnGyWIkgriLZcf1u3IbnUSmUQdA6Oh4Y5 +M815MRXUoWkvFGNGCy0UjTYzymZGxFBb5ptI2Ujb/YCmi3drrVPb2wbyXERU0xo3W6eGPvjkkwIQ +UcOZepVjzd7npW65bD14QBWKmuOuJLmHohaCuMAkZYBcyI/alqJOAO7yOYkgAmAdWUCMkoUzEJ4N +HPMozCVBO3A1xZiG9bN6/5HjzXm+xaSpxPfD+XBygSIGICqIEZSMGalXxPxsQSthXhnzea5BkDZJ +25CpeWFMMyMMqxXLfqFsZfI8yVaom916COXRYjusX0z2fhb3ngLVAb+C1ANRaTs7zc4L1d67+f4l +ADSDwAFUv2kx3xO1GSw3cLkUmZmkWNIKJQ3ckuEbQZI+fF1GHYjuzuCyOThUrAYtVAG0bf8IkhFF +ezwfF8tKoSQpSgPOhUSfT28sm+ndbCIIwxUtRLJamayeGz4IrpBi6+mT5nm1WDZVc8TLwFJcBHeB +wMvmzPJ3U+qFQVyYYLWitQy7oWg1ko0h6Y+2PrrRKSz6TasjVdL6NF9BCAclPTtarg4/n+185ngT +UYiBjajasNG/poU0oEpIADJH0iatwSMvAhxQS0CwsQCcU1CnjNQvojDhwJR4jq/YzhjkDy8NARVl +bTHe+mDa20CAKSrJ5YFl1UWxR1IgtyMMj1luyPJjRZ2Vy/b9B3i+IPFCK1/UQUYRTKPSfRi0HlVa +T3ix/2CDefCAhpkH8cUKzTIRwTtAWBn2jgoJgq2DKNjIMARVgazKcs0y4irmtmQCyFQgjWKIA5hZ +yCs3bLyRy6nZjFQsAZ9Jv/cHIkGzEYJaG5s06EdB6MlKP/36gwSkNaNwhwCaV1aLhFtAXYSIIIoZ +bmA7uwhqs1xVAE/gG/mivZFRCwVIqbFhL+xoTfFVjPbTxwfkQaPzaLb3hVc7Ab6R7mPBvXTVSJ8E +WkVUBGVb1vdEdcYKQDCcm3uwNcfb29oFTDgBUg00LAcEDwUeDpIcfMwAJu/HF/X2C8ObY+k2MBnD +LYqtMmITIdxcgS9jjmYtRHVAs/H9DTLdcVRIe6hBxofUgIBpRAABbngrWmpvZEWciCHuCkWbpBIQ +gJDgaL7txScg1TfzEoCw6Sxs/wD4hmGPVb2Fk5amNDxvlt6XUPu5krWRVXJFA6CGE5slTMuVZNuf +TZZPdk8/3OzfVrJ5IKKmpg6iZA8nA1A0lr30gn033NesOfjPvXuFUknlBBCwTpkIJGPlVx43+p9J +2jj93goxNzapMqLDkjEpCzI2gUtvMgCzijaW1X4ZtQDh48o+6LsHm0K2YJWw6EFWhqUBZmuYcz3d +nbILAhkhvBJeyRTdzbxNMf1q6zpMdkBfYJgFeWpr/f7k+hdx7Ri02EZG2MhIGB4CuqZiLa/xUu/6 +s78drL5g5cFmVslsioLYTSqnwHL/5L/NfXoPJ6na7PjH+f6XujmB64SMA/PAS3Vw7HzRAqpAcdOo +/uzp+3+wvSNBHRZxuJgAsAUhQaoA7+ozwgiiw7QnolItISKseL5g42hVkeedwVPBGOQRzfWmq4OP +GF2huDopVAvAYYga0DaIU1aop12hCQ84ba31uj343AkPgO4CBSJwVwEN60w1C97E28gDQ65p2l4U +P1H0VSYL5FMHA+PGlROdElwthxi5mz0h6Wxn6c0Mg+Oe7R0E1XO48kJZ28iwqdBGHaCgwEs5ZRjU +Hi72f9rb+lyxtwvwEZsiQ9dyOW1jI/32BKYUIxPDWZ88+l1n/LoEKklqhtVDPz5V9BnIw2xRyRY1 +XmibaSNmG+RDejeMbfjRgR/DitTT+zBEigMMXyWYECXhx4ig6yRdZdhKKoXyMoKBnuoCyS+jNvyY +L8g47gpCS1Y66cZjqaXZq6hx5cWHkCU301viwN51YP4IkpZCArqe2WRxItA0kOpTUH/ZPNAn03Fn +QM43N3lBHI/XX5rBnihNWbYDc2Lp3UZ9gePK/QcoyXZFdceNr9r9d5I2zRXlBw9I15nsnXzgJJAS +8qcPyExeU/QtYMuAFSDSgVZZ6XNVS9UYZQsSxCNKNli+3+692Fp/jRHRvU/Tu6OgZRipDbTk/n0a +JAC4DSvC7O2CQCsAvW+cw6z2pp+Z/n4m7/zf/0rG6f/fF/D/1bgz5LaNO0Nu27gz5LaNO0Nu27gz +5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaN +O0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu +27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz +5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaN0//rX8mYEv9Kxp+wbOfFRfvs +7dknu/1P2MbAPYGfF2efvb1888n0E/ZEb7x52358/vbxyxdnbz4SEfzK0CyH0BeXZ88I4Y9HEnAQ +MXvz+PrxC/jl8vzs2aVIKHBoDP99YhAmYdz8b/fjJ2pg2J5muqbjmYYRhA4RGI6vWUbo+17gB7ZH +PE8P8i3N9n3Ls0zTdYJ/edCz9KA//i6E93E9wyL++SzT9s3AMZ0/HvQvPu6/6qB/8XGPPll/8uKT +rU9CQhCJ3TVY1bj85PV/Mc5MjbuZv+7jZ5fRH//avIQZ+X8nE86CCeh9orcv3z8+v1z0msTu9JOD +9OR0Pv/4B/FfjEpNtl3N94gjwjJMwjS89PxH/3VnpFf0z2f98/8HhA1Xafo3F+wQ6bnGJyx7c42p +A0SEZ4eW+cnu4L8hqLRjCYpbNBszXIVJW7LECJaQTJsVuyRdw/G0MD9JR4o64MU2K9RRwiuiJpyF +kR5OhWkLZczkuEiUm4Y9lI20PRcD53ItXh6XUCuXZ3I5qlyS0r5Scks2JqI+5eQhJTZRyi+UNd3s +SmoDIwJRHmr63HLXtNDB8IQR+wRdRVC3WNJxKqG4JsM3dWeOMclmTiyhDkaFZdQoFFUM8yS5a7sr +UR8yYqOEmhjlY5TNCGEBVSg+MrylFR75tSvZWsLpJdwpopZpL4L6qRXtmf6OG5+I2pTk60XMpLka +ycAkOPmikssLKKbhpMWwIc3FuYIAn4UTcaFsFRG7hLlE2s+tSTIJy9dJOsHIiu8fmvYORtUKiJUt +KLmiWkZNRRuIcqdYVoslheObgthNe+iV0o5GCGoJfCMMdxHcwdKOUvVcXt7YZOBfy2W7jMDLpdk2 +zXcIuknQ9UzaC0iHX6JYgGEBwzYoulpGHIJMimUrLUeNuQjqlcpWCTF5viWJ3bTfDuJlC9qDTQZe +mayQy4EhFkX6NDhASS8UJAw1Mhn6wQaezfOFklZCrGLJxokKjkfwbvkCXLlOsdUyameydLGowUVm +MjyCuCRVx4kaTbc4oSuIrXb72A0npbKI4gEv9jR7KiidQkkt5EWk7MAbUlwboyr5kpUvaAxT1fWx +qvQw1DGMEcPXyrgNLoHiHit0ObFH04GmNvIFAV7gnIo256QxyYJ39cA5027eVFAsyjjpKcbYTQ5U +O+29SXDNEuHiZHh49HW1dYSRLoq7kjINksemd0wyrTLmldIu5UYJ0dN29GUd7E0b/7LNMhaUMT9X +UDJZES4bDkgbE3EVhPBxOpHUsRed1luXs51XOOuUcV1QekawF7cfW9ERJfYpvg0rst75YjB7gdBB +vqRJ2qzWfuFXLii+R/JdBA+KJQ2mEcXctAdjQd7IsIWSkfbfLumbGVgdrow6BDg8WyVgwokQwaMy +FqFkBWfitIcnVYM5BA+Ew+DEYtkAR83muLS9ato80yyW1HxeLhX0cskABwNHwlA/8taeu725yWxu +0LmcuJlhH2yQsIhgLEbWaLaHEQ0Eq/LcSBCGubyS9sTAPJKqwJIBICAY4ENH1Wco4d7fJO49QME5 +AVMkaSAKfQiW9N1ycrGYljO//wDNbJIYYlFUnWYaBO5vbNJwGSjqZHN8viCCLxVLzmZWKxStUjnt +MUWLgxRYCiJYkYFJyLAo6hnmjmXvmeaa5Vq+t/3+879Y7D3/9F5eVIZpi8X6CSO20zriEERI2jQj +V5TTwthFmF5X1vuS0iHBw8lwuXyjGP18WdvM8yQZe+GJ5R+SVEiQVj4v3DRH6gPCIERUwiOSbSva +zPHXgtRBEV1R2n6yq9hDSkgovgEzz0k93ZqPJs90a4wRLrilZi5Ve0XxnTIS4FQFwVN/uykuzuTA +IkSHAMRJiJ2YpJqAbCRZxwivUJLThidcBD6PUqFubbeH7/vzd43hJco4FBfJRl8yh4I5IoWO4e7V +20+C+KDbu/KTHUBgDHMVfWz6K0EdYXSDYMGEOoaHAC9pA9WcAFCQzSkYkdy09lVggbI5EcPTSvm5 +kpYtmyVYVryBk23FXONski3wMM+iOs0XjUxOur/BAc4gqFMqA4IZAFNlJP2zVNRzWQ== + + + IbPJZjOwlGqpaMhSh+Ma4FGbm2xmk/tjF/TNDF0o6RiZCNKE4UYMN1CUpSRNiyXwiko57WIUICgs +QRMjG6I8dbxDgknub+KZLINiaTcwkkowzAcogMu+aRJr3b+PgWvl8zyKmARRR3GAULdUciiqJfAt +mg55LoZA2MjKmZwJKI2l7ccjhGwhANq4A2+7sUmmWIf5LNuAAwgSUl5d02e11pXqjD69V+CVpuWl +HQbKaQ+lCqABioe5m0Tw/5D0HlySXGW26B94qMukz4zIiAzvMsOk995nVWV577q62lT7VlvZlveA +DGgkhMQIBjN4KwQSZrDCWwECCYEYZkDCDDNz39x3111vn2KtXLW6qivDnG9/25w4WQdthRFgIjhg +KkhKnNKVen9wlJcK/pAZZtM82bSkTbEYSQ0EwjBpTWsaZjdEJwSlzAgFVijT6Gu+vL/tre44E6X6 +VtTpWYmeZnciUlnSW6rZx1eWL4bZXDo9r5ktl09y+1SKSktyh2GLKCg4hGyYEAR9of11jy/qCyQ5 +voGhFiSywRHGlo3kInxOlMuSVudl8hf0Y8lFzZ4K83krMWvGJ0W9rpstXq8k8+uD4eVS4yjGHz0C +MtHVOhh1zMUDQqrWz+QPoTqq3pfkGsNmQTvk7+4HouAul0cBBkKhJAQozICmElC9ACrLlGimxgk9 +M76JlgnScduekY2B22eMu9Vxtwa1wkFAeiHahooxkQL63e+Lgp18Xh0vgjGXEIKuMdn9bYJkl1vz +eg0g4cBoeH/7sjgv1rwBy+PFlcS8PlBokherGG0IItkBDMQYNCkmFxFaqCM4jePyIUoH/wDY/iDo +yAFDhiGjVGJ0lPO4NbdbGhlhAoGUIDbD4Fum6PfHuUjRtnqxaHPMxeHi3V6ifT4/sF0UlKmYM6dH +eyC30bGI2y2Cu0bH6LExlmXS+eySrHWoSNHjj6IjgpS8v7N6GTWS9QmKLYbCZItpmAFRzAeDCk1b +DFfg5bYeHcYslLJIhx2IY7l+JESnUGuoBtkNQyQ7pOE4aC5N78Uzs3A7Yx4JpAeyFaUGsK3Humq0 +nUrM3H7T44vblykuEWIdToYl65nOXDK9nC2s8XKF3AWOHHTocFGQ+mp0XjXmZG0Kv0aHUyKf06Jd +bzAOsfYF4hhJRevJWl9Qu/H47PzCxUp90xciW5RH7ZlMcTtbPpQp7+hW37Ymrlz7oJnru/xakOzJ +VsJYwR4oSgv2Zt+l6BCXyP72azgyXn4iBPA/WYrJjI5THrJ1mBMkbZt3eQyfPxEMZVS1LauVURe4 +RfUFMoI8pRozqjHFS639HV1g2FAa1eMRyL5PbsHr1xgoC1dCBalQ0uczfT6Ii+DxSBAgYmDcyti4 +5PYY4ElACwoCynKBQFyRAyMBeDC3W/V6Y4GADaJACYAZyOKYm3f5lCDtALSy2ucENEUBw46OZhgg +p4KDg2cgeePj0vi47PNZdCjjxV14dCrkjI+zILGR0QhkC78fCtmjhC3FEMxeEHqkh1kMS4Zmc4Lc +wqBFuAo8GBUCdzF4YyCAdyVdXmnULY26ZNxdrbLr9vLwpfAMZBcUJk0xBUmdSKQ3Eql1w2hJQiKT +moinZyNiGQCDbWaFrK43M+nFTHHDF7AUpSzKJdhF4jr4Oie2FG0qU9hx0vCxKdgSw+yxfCFCSKlg +mJOJ7GK9dejs+bd2Z47SXFJQa3K0Lxt9RIa/71TGClWAHESHvhCkmhYdqMYELzZltQut1IxBr3O8 +NTjlDSZ8wQQTKUlyXVFbeK+kth1nplRc06LtEEN2S47wJfhAK7GYLmwp0Z4VH548fV+qNA/A+0M2 +uE5U23DsYFT4YTBAIJTAvyEZVMgm2xcrTfASkRKmwETKXp/uJeUW8fJ4wOfgiipoM5Umuw2Pu0Xg +JESlA1SGbF0SzrFcleOr4XAhEEjif0fHGbeHhxcNBKLgJVmqC3yZ50qS2AgEE+CoIFQ1aI+7FI+X +7Jvn8ajAmNutoLJhJuP1G1C3sbFwIGC5XOroKBRTCoYgRuhZmOQYhIOGbIWzQBrLFkj+YvKAGSkN +k+W4Ijwzjgn/hmPi+gEtmC43/Dx4yS0T9+4Wx8YEwInIsUv8O1MBPyybhzxpRh9WDfYeGMNhUVA6 +nPR6VHg2HJDslU1ZYxgEJsNweV4EDh23RyA7x4IkmQyphdxL5w4Vant6dILnc4qY7bYPVhqb4Uia +E8u8VFaMhuUMcoVlNdZ2eTRVq8tqDR7Pic/FrIWYuYSe1a05VgDeTIHL50pLvqABN85GirnCTq29 +15o82Zw6LllNQalUm4fN5JyPSu1vh1Iy43PxzHoiuyGpXVySrNbJzqJBJ0CBTAqmMxNPrdRax+3M +ki+Uo+G12CxLbgSUW9WifVXvkkQZzmBgRbkK20+zGSs+1+iejCVmdXsyU1qi2JSb9GAWLg5JBMoL +HYGl5/kaTgThGHdJfCRnO5MIv4AEKgJrp+pTvFAPeNHd+8zjNVBximxtVObEDr7CGDN0FuMwOi6M +u2XIFq4N3/r98GYZl5vsIzTuRsm4QDCGDI5aw6kqUjMZXxDFptePHG3sJ7I84OH1IEyZXp+Gt/j8 +CGvIyI7PT9w+2Q3YA0sc9UETvQacP73vFkCPnFBF0ZEXgARFbeMrDBK+xYlUrQP5gIhDAb0eLRiM +u1zK2FgEPEZMnUsGEwYDZFcZwooexDFoseoCwDwKTkSFUsASTF2YSkpC1eUFoligcWw04if7xhdh +SiG74x4JgxaizfFx6pprvHCwLCx3wOI48GeNtL/WDHNZPxHlhCpVSuX1qDPAYVW9B+8d5lOclNGj +JUGCZllkriA+B8ebSq+ISgfROEhn3H4nRGfhY01zUjGanoDKcEBmUTXaoloT9SYtlCguZyZmm/3T +ZnImCHKQ6owA3PYMe1aNDSVtgLiN3/fDnISTQEKAsiW1o5vzojYVFpoMshJXgZMB2e7v1JoNhBw0 +r9cPM5PTjRmyCWFAA59ArHG/cFw02SS2wPIlIzqRSC35KdsfisH2B8l2vjDY0BQF1gIVFIWKZQ2C +aMMxFt4bx98P3bYX5seNoltIdiAQfGXYkqxOi9IA0Zuh827SxWQ3V/Ty6BgCGu31WaFgHg6ZFD1A +NmNHngVcwUgAxv6YV+hwzuOz4J0AEp6vwpkzdFzmC6FQbGQ0CDQCV6FQOhiETqUh0KFgQka49msH +RvwuspUuGM8Mk4aCLwXMNEXpKGoX1YGGwjMTn7+/qyF+Mj7O4bJxCnILRMvCeIEAA/54MJgE3nBh +MNiQfiKdbolsKOrRYNvQEZDdfHp2afbaURd3zYEgDhWm0hrcsl6kaINcjBuaboyNUweucbnGKNBa +AA3iUWAj4TBRDq9fRtKHqVbkpqa2Fa2BsiI+y1qbEfMev0izFsenZKUIvrKS82q06wvFRK0dZFIu +ssVTCgCznDk7MSsqNU9AR1yi2CT00U+ZVCSFBCeq3XRhNxZflPROiE2azhAwQ63JNtFSM57Zytf3 +FGsYFsj+scAVFUl7Q1G8S7eXVXNZBnL4kp8ClkwnPhu1J5E7SI7zaWhMqBIuHt+iUuhWiCPSpSjX +7fSyZk2zZIt1sgEdkp2iNeVozxuyRt0CfsILZXQfxipCNl4m29czdBqnGCUlCKCIcETBQIyhE+hH +VBytDWb2BXQMKdCCulMUWjIJzIyOccR4g7WCMSjsGPEtMvSFuCa3AmaDqkIBw0zaTzKjQ5SX7CIL +vCGKwmiJwJU/oLldnCQgHNX2lRr3qI2OiT5vDDVFOhsZ8dKUFWEzfrJFWGwcAkpIRuO5qmZMgZOJ +Cnvlv2+9SzYFDTnItqApQOXAiG9snAbwEHjDNKRNRh8hkIK+CNtE0gbCMpPbn/1gDpDttUXcS5hN +ISiRrREpSxAyXp8wNh4cG/OPjwX9Pl3gS7rWpOlo0CdG9TIcJijX7zeI34ukPYABHeX4NIoFfSeD +g3DtVcjkm9KISCV/QFWNKsOn8RMyUQODGiDUkcxuyXoXrsBKTvopAwPu3d9C1gfXyiat+FTUmlD1 +ejw3G5HLDF/k5QYyqQ9IYNLp3GamtE2xUORCurhlppYErYPY5SObc5bsxKKTWwLpwadJsY43ZJJt +Pz1kyzWooWVPg2lxC4pWAwzgVYj79cWCQceMDVPpZU4qBQNGtrCg2HW3X3D5VDduLUS0slo/XO2e +iahNKpyw4pN0BLoDNyLC8aKUkK2EPSvL9XF3xOcTw2FnbDyMTke5AQCyqWk4EaAgqZEQbSFF+gM2 +rDXUyuXSxl2oVx4BzedXveRFpsW8xL0QHI6O8fhlQWjCJCBxBGnLF9RRxJERYni8XsiTwDBxv0+N +MPFEvBOgQHRIDdY+rZUCftvnBXOq4+NMhE1TwRiIC5oVCDhBsodtkmxQSWZ0MT5JnN3lEdxeiey7 +7saFSVAo2CeXG3chBEPRfYvFjoxQ4GFw1H5G0A29fersQ2RybDTkdnOwefghcAspdOPgAatQWCiW +pgEqnyfMMVGOcRA/99ESA1Mx4WSxvIIshjQK3O4znukmOwBHda22P7UietxGMGCHyI7KCV4okqmn +SKbe3uaVwshYxIXsSSyxyYmVbGFTkOu61lraut7l48kcF4UcnWLZjCiVAC1Vbxays/Mbl6Vow7UP +DFA0yxZj5mxn4nKuuktH8oJYjiWnA0zcF7KgXBxsfGwyUzxoZRYT9uDQ4at2duLAGL3Pz2RjcDSj +og5Yvoo4X6xswT+PjyvwDPgW/6vpXcRkspd7ONPuH+XU1MioD1xBdo+PpHip2OrvtabOiHrLUOuD +qSPekDoy6h8dpRg2TXba5Iqx6ACChTZhIgmKtvblifUSSiG5GGgPs/FgSIva4G3z7xPdo2PIeki4 +eQkeLAwj5Gh6PcLnDoxQIyMh5HToyL7opESpyxL/4ARo0+Xh9vlEBOcgbYEh0emwW4ZWdZJdl0/a +nxZD0IDBs4lIuVS/V48waUNrhgAhJiEIJcQ6ECnZsBpCBuGmnGJxmeXS4C50BKBIhTK+/aaDOQei +ONZRFWAM0IqAkN0umC7yRsg6EuVw7ownILvHWSZkIYCAu0ZHycV7vBCXdCI1EzVbrnGKoTSOjYUC +SBbIKSobySpqA3THSzXYJDfE1KOMjyO/aCEUIpKW5BIoHRLs9UQpIISNk8YkaEzb5lS5scWJeZA8 +RWb/0ODWvmFOBsl8aWNh44o3pLFsSpIqkUgOPMZEsjSTpBmnmJvZOnqb4fQ8xI4m0Duy1DRiE6nC +Cq/UvPtqzmsVV0CNCNlkeoaO5EIIwkyGk6qt5tbV259sdDdxXo7Nh8FpgSggGuHaWnRO0SfszFqI +qyCOqTIcGpgW+h7HeeFjRb4StQa+kI4RlohxygdCRpCOgnvDfCYcSdXyC7ff8Y5gODo6GgrTph3v +g2lRo7Fx9I4GqxazOog84ByKNkMhg6IdiAKOjBu3ot2jZ+8LMkjr3P4zKQtfKSoJ+Q== + + + A9XYTm9j64Z6eweaMjoadLtZIAHiMuYSwb2oEScUQQ7wddBTsA28sWucHRtj4OhUqRGLdngpP+6V +oZjgyZExFgoCURa5nMjlVbkai3WYcMKxuv6ADtoZGQn6cOPEJyfRp/HkkBczf6dBj0fYj4ciyYmQ +b8rS1Lyulfc34oZFJMgBwGAI8UKBMICjYxQSja60QI/XvMk9NoqDIwyWQLZIDYiQ4+Osj1gpAafG +v0PBOLhr/yGCEqLhdfWRMQYcBWUMh5M0kjiVQFoZGycAdhHiEumwTdOOJJZTyXk52oXJJxtshswA +eSKmUUwcoOLFkqI3ESEFuUIxqZg1sNIzLI/wnuPFIsNlOCFnWh1OKo77IGc6sdw+newwDIXyydBi +QSxinHH8EJtm+TzI0OXFwdNGbJArbyTLW5ozTfMFbyAK4iVh3Ce7fArLF5BGmUiZl3shphQz52PW +NMyVN6CiXrhCjJvHi7TlEKvsj3n8AAw9OhbE1zCu055JZOYTqX4mNwmTA4cjo5Ruamw8hG8xFKra +48VmREDetGGVQ5Tp8Ymkm5B/pSKA6jgLmcqmizxyktBQ4+MYZHQ343KxPp8iKhXN7PJSlcw+BXWv +h3e7IygEqh8iM2YZr9+ByY9E6lFzmWZzJBL64LhQDgXG3usjc3cRoeGk1pAmiFLvby8/BopwCSG/ +5vdqYSoetwcAg89ngpOpEPRR8fuiyCO+AHkuJkk1/M4IbPYYh/MGAmRj5DFiHTmSdsGT5KlNBMwj +iyWSQciLw8vnNxi2CJCAsqgQ0qiO1kNGHhsXSET1k4uRhDqE3uOSVaE6Msq86U3wXWRvbWJOPJB+ +llAomdAQIcdB3ClbBm2CPMmkhwvQipPdmwMAkgmpJVqjtUWxEoRjoW1ZLTNcyh+yg+F0gMpRTMWO +r2VLR+zsKgJLhMtBRkEjwDAoGiLoC8YDoSRUGycNUwlZKvtChiDmJKkkyk07uRy1Z2kuiwgPr84i +QbMpikmq5oqV2dWceQppMZSgmHyYzDMkvUE5AHPIlbKFQ2p0kgoXfEEHrR1mM+AWtD/uKxSCi2tG +yDbvWQ+ZIJJIBvcqYFpOLtBcIsynaQaJLEN8dYA0I0XbNBv3B4FPG8kCiZVmC1Bh8lQxnIJYw2ri +jvajfYmXWnQ4z4RzZK/7UcrnxTBGRkf9UE9f0IKfDNJphvguA5SCgkIgXOMckSHkxAAOWGAiwF7a +F0wzbEXgq8GQQeCxP1mKGoXCmTDODufJ5DS174PhGY9QQZOCaXSLPg8kqRqiMqFQwu+H2wRgYJiT +wC3NwMBXDL2vKU1QhN8b9bjJbslvepMLJspFPA83MopGI1OpHhJ+44gbfpI1pAOjDFjU7dbdblx2 +1LZ6KBBQHQ7aoQB5kAoyxI3gXZA2hiomYgsIm6OjMGwCovE1B0IgcJ/PIBN0UFuERz+4NCsINVAK +pN/tUvFGls15yVQG5yE843CRimEMMMK4AIHPJ1NDinXIxDud4aWeYS6lsjtKdAJBDKPhxKfF/S2L +UW6ezytKQ1F7HF+GWLjcssAWUolZbxAULUGLdXOq1NizU8vAjy9gabEhL7dJP/qjZnJDdxZprohi +hdm8bk7HEkuiBCecUow6E8krejdIx8n+wBSSfk6QahSNgeLh92BsvP6EN5D0+G2PD4qW4Xn4nxJw +gqaguSQnwlm1gsh3QdPl4r1uVSJMGB9zhSGCktYQ1JovCL4iE4aqPmHEpv2EObUgeRoI2c0h3VNU +2u0x4JNpdJBfGR0LIX+RvdNxp1ANDJ3fClMQhaTHY4wcoND+sN9wI+Nk1gsaZAlSNxZb0o1pMlMk +VMMMLoAhKc+ngtUZYqjyqtYN+DUqqAuRzPgYPYrsNibwbBNvgWKS3of79cdgNoIhB94J2hTwxxk6 +h690MINGu+YaD9TNNU6eTh44EHrTmwLjJHWCOkyQiQvcEkpCrw+MsDSdC4UwelmKypvmQBThaZOG +0goF7b9bR49LAuqoYAKZJUylRkdZD0maEdCX16MZ0RmM0v70hYxGBszc5EEDdFn3kDLFg0E41cQY +LnJchBKhyh4PeRgBM+aF3xMaWmyCLD7xqSxXZLlSMJxAJBl1RcCH6B0rPoTM+cjCkniQgoYCnNAF +lWHSAl9R5JaswdWzIdpAlXmlxErkUZEIA693Jb0XJJNF8DYgEA2HdXlECCIMbURqhoV6IJiZqB2e +nDnugfB5NSAZEqaQtUDQU8tF7kjNpKY95EFejGYqotxiyIPUIhupBqgkxn9t9brl9cvIaLBVYy4k +cYMNJzg2m4gNmLATJEE+C70ecdFjbiHCl43YpJ1YUvUBXBYvZHgxN+aKjBAJiBPeoJLkFbTIUpyQ +zXH4X4E85Q9EkfFh+QSuRlN5r9dCz1JB2+PmEc0QynBV+6sCyOzWmBt5MJ5JLMpS2uMBf8Y8PlyY +6HJDavHLEh0ypUhKk0qQJw8MPzIRIOqG1MLzsMQD0xjAOogFkTPotyJ0gQO18jWWLvq82oED/gME +2DyQgH+4xxWEApioAOI8xjAYF8Q2ZMXjjeKrFzToNkZdiJn6/gOIkqEPIFvIm7gjvMg6HJDVCE2u +BBYO906uB+C30XrjRHB1huzrDilRMRrIjxEOloPM+YNbcFiEZdy7j9QIQsy64PC9+v6UBdrNGB8X +IHYBsp88EEuTaWdgwI93xUBuFBIom+fEGnyOy8VQFC4AIp4I4XT7D+LhOR1nKKilERcLFZCUuiRX +gROv30I7+/y2nxA1R4cMLpLABXv8MTCMILVVvZ8r7cQyczBdwI+kNOEcyDwM2nmcxQXQ4RTD5j3e +GEVnQ1RqHIBHdTxKIGDTTMqKTzd7h8uNDSQCmiLTPhB9IIoKObCvkXCSZ9KyVMKAgHbIlCysmpcA +W1HrqlIVpBIwvG+D5f3p/TiQD1GAlcIQATBgKnhCQ28iT2EwA7gdMpFujpGt1FGXmN8f3RcLGeN8 +4JrggWsCrnE+4LchHDzkPhjze1VRQCEiJAJAXr0YLg3O2edRUdZ9WZfGxqgD13iBUvzQ7zVYKiWK +5X1LpgpcDtYR6oxsi3CKUwBOo6MRnII8NSAiiPN6Rg/g4FwkbLO0Ewwm/MGML4h7bI26hBFotxdZ +PgHw83xZN7qK3gmEyBMNMsk8xlxzjRtSG/QbAZ82NgZ449YQCTEO1P7saIoKJ4LBGKHEAIxBio1k +yPooiuQ+YAyZN0jmcm0yA0YaEOJruFwyOh3XD6BSdCLEJNx+HQMIvOEtKBb+DVcZM/uJ9FzMHgbJ +9KMB24b46Q/KQQr5KA78y/CoFgx/wRPA2+Vkap4XyXQQWccCCiVPgVEyE5FQ0yBb6f35eVgXGLwy +zWTJ/GckR1bc+aI0kwFTob6gRzh5AiRCGlE0rCDWoVyoI9wOCopGQHhkhaJhT2jRLh0ucnwd74UD +GQf4QTiRfDBoAx4YEzCJL5iCJUYdQ0EMlCOKRfIUm85xXC3C5P3kKQAunofc7D9rFhF/4Fq9ARMj +mUkP6+3tA2A2L3xvan+tlACdGnfB+Rv7T5dMFGV8DO3P4St5ojcaGRlh3dAyXxQ4gcaBHILwul4J +Xg6NDAlD+fxkARigBRmCdYmMjvhHRwBODll+nNxpLBVfiHDONdeMH7jG7XMTLOHCQAtQTPf+80R4 +J/wXQgf+gYPgLDRZcNISpAasGmj8wBiPjEziz352gNjhav1ByHomTOfgVcB+DJUM+vWRA4jAEWIR +gSK/BePEi2QVSkQowOpQ4WQ4Utx/Ukwe3olqVTW7crTtJlEUltUmTjKSw4uUyQPcWhTeRYJYzBeK +ESdPE58jkSWUBTqcFISirlf1aF1Wm+FIiRPKHJmJqoVZ27Q7ljOFgBwOp1Aml09z+VT48073hKQU +kdCpsD3uVUbIrRleuAXyQL9KVnLypTBZtmGNjMuj43KIJk4J2QrsDSUNRwqi0ghzmZExCtnZ5RbB +mZBpJlKCWw4zZYDZ60OCEKDg4Ui+Uj9Wre9Jcp+NkGeIaByyBMVLHp3sL/WU9tfapalwHkEJgR3U +h87yEvaIBYJpUWgpMuQjAeCRaYf9xTZkBns04honqz1xa5reVKJt1Gh/JjNKcvoY50cw9Kd8fiQU +stTES2ZBo+Pj8sgIAxXb98OAluyB8wmSKdAwnZD4YsAvuV2gNQd6igQHrQkEyYJSlk17XJFr3gQI +ecfHWDAw8A/vx7JV5C8SKMZCXJgsb4B4uV3S/sph00eeg+MeWdzy/sMpDl4lQEJoIkilyE35yfIP +D5nnF970Jt+BNwXIVREJS9DhLENWr2XwDw6QCNuA5RhpH+3v0AqGMrLWsVOzUXvCsDpWaoqTkOLr +otaR9Y6ZmHEyy8nCBhUph8jCEgRABOEKikuevdLo+jzNgM2ihI7YFPApa8jpZdQa9ZU1CFZHkAq6 +0YiaA15qCFI9Qh6al1St3WweLZY2NaOFIE9mn0JIZFl4IZhkpCFeKCG2e0MwHjJ6H8ihmKyoNmWj +J+ldhDW48f1nvvr+StcKwxV8cMhMzrCmk7lVViKz3JBO7z7vjbkVxElZH0jaFBR2lExagtksxWjJ +ehNX6/IgiMVDNFm/KqkNqCrSJZgc6AIJB8nyHgSQPu49xGQANrgdWS5xfCXMFAFapLwADZAgBSQ8 +ZLKacAIRRAg3nWC5AoULDsT9lOMNkAUM8JkhJGU/WjXj8TthrqRoHbhWr88ic4w+bX/tAQ/XBFuL +4EnTaS5S4CN54ArX4yPP0InukEdLYdQ3iyTuJrEXmgsagV3hfT6kMwusyDKgF+h72tBrHq8A4hXE +vBWfQiOAPwFLTqzA7gZIOEqpaomsbfYZKDQqyPK1MFcOkAW0iTHCeAAPeewIQSE0Qjkgiqg9bcen +ncQQ5UaCDvgJXMmj2GAcdRQUjHC7UF+1MkOkITMxJeptDpAwu6n8cql9NJ5fFdUWechLW05qKCgN +8EOEzAzkUR0t1hbUStTpc0JBNVp2ZkbSyfI8SWtbqdlceT1dWIjGpyJSDRIWMyct2Cqpyou1/d9p +qNFmobou6fUgk8SN8EpXNqZUcyjq/TBqxxcUvRXPzoKI7NSik13nlRYVyfFykwNQxQoIYf+5ZCoY +jjN8Bi/FaBjWwErOx5wZUWnxfJWNlCCdfjJlUaDJwsUofHUQ3pJFZaHLcBdx8hiFzeGAePES3kLW +xgco8IwuiAUAmGJSgtxADuXFiuVMRhHG1TonlHi5GmIzbugaEMjmDHtKM/thLkdqFDDJM9BIlsVh +JUhAL+pMcnI1IpZwnayQhougI2nFaOpmH62Hy2D4Ak4EeQWAA4EoFYqFacQoU+BLglARMGgchh0k +XMAdAa4+ONKAibfgW/xvLNqHWIDqPX6TLLDx21BwpBVJqph2N5mftlL9WLzVmNgxE9Nk/U8oxYl1 +XmqzfEVSKnG7HXf6rFAIhBOorJ8sA1NxfNwOETUafkkJhvSoVacZWxDTslqBhUaOQw== + + + YNf0abJwTsXoZeFJoH1UOM2RAnXi+Vk51oklp+PZOdVsaya4q2g4rWJzvdje1u0eMBA1692pY2qs +w8Afak20vJkYGs5AjjaVGMl6hdJyo39IUCohUJDaslMzwFWqsJAsrAhaT1D6kNoIn2A4VDkJfrCT +U2ZyUrf7QIufTiixnqBWeaUi6W3VnDLTy3ZmOZFbjcZndKPZnTxlZxZ9VJyTak562cng5/NRZ5qT +SmEuDahEyNp4G2orSvlcabnc3M4Ul3Kllag1CVbxBR1Ja/FSJUhWMDr7SyNiiG8w2/sPfzXy4Q4m +xfEFSW44iXk11hW1qhptWMlJUStTbFzSG7hlvHR7EgOVLa0lcwtmeiqilMcQ3umkKFcVo6PbU/hK +blBv2snp9sSxTHVVsfuJ/GKysJwgS7gnstXVRG4IdElqPl+Zq7Q2ErmZ/Sf7f19sX+DkkhFtMRGo +oQrh2/9EQEWLDaAmRFCS0wSlYokVwecYTLyxELUm6u3damdXUJugGlYoIaGTR/ZUjI2ko3a30Noo +d3d6cydXj9xcbO/yakPU4YWqbh+MUFVUmpY92Wjt5qubuEFZb/n3JwTC4TgvFeGOeLKCt5bMzuYq +K4ncbMxqkg/ssEBClxOqFFmiVo7Fp5zsjBKDvnTIR3L4PCcVNburWhOGM3Qyc8XmVq2/E403Daee +yA+d3LSdm06WFqKJfqo4r8cHcqwlGXUwiaCUJL2qmR28K1/amF26NLt6IVdZNpNTUrSDWpjxvpWc +yFU3E8WD1e4ZjAnLIX2APRKcmI85PcixnV0UjZ6gd/L1Q2Z80rDasgFg1630ohGf1ayhGpvM5uZm +li/EkkNP0EThUrlVO72oxgZqrA+Q45cFtRZ1pijW8Yc0oNeMt+10L10k95IsLMExRqSSbvUCtBMm +lEskGwwAjIG1RKUWIJ+IybJcjgrjJ046v1pq7uQbm7nqGl4YLtwmOogVi4JeM+ITRnyyWN/OltdQ +LMPp+YJRhk2KIsgkI6ltKz6LDs2WVxv9vZVDt5W7hzC8qeKKnZ5H6XuLZ3tLZ4vtTTM5kcpODBeP +Ta+cbk3tAipgQs3qy7E2TmElBopeK5eXQKGAlm728FIMIiXtqePV7m48M9Pqb6UKw2DYYfhczJnI +lVeL7Z0S0KU3Q0zaSU2yYsbjEzgxE8+AsiaKja2plUsrR2/LNw+W6qtbR26w4sNAKG84C7HEvJmY +K5Q3e7PnE/k1YNXlkWja4SIpw2xmyktObiFdWuvNnav2jqKO6fx0b7Atqo0QBW8Gj12U1b6TWck3 +jjQGZ2Lx6XJtHQ2CQMdLZTuzlKse6kyd29q77/TFf1jfvrJ55EqiMBNL9EvtzVJnO1GYK7U2Z1cv +rx69PVla5JUSJ+ckteikp0BQjYljnenj6eLi9t4dvfnjfLTGq2U72U/lp0udg/HSZrq+E83ORVPD +Uvsgw8f9IUVSS5nicmPqTGPmXG14ujZ1OlNan146m6vMmMlWrr7uZBfBVPHcUrm51Zs/hTcaFrA6 +GQhbrJiVUGWrZyWmErmFSudoc+KUqFVkvWzF2wxvS1o2ardy1fXa4Eitf6Q3PDm7dBEWTrf6mjkA +3+L2k7mlXHmt0dtrT53JVw+BaaGV4Uhai7ZT+cV8Y8PJzsWSU1ZmJltZ0eN9TqtpzoSRmLQyc4X6 +Nka4N3dGNztsJC4IGYZGEDB5sZ5ILU4unevM7jUn9/qLFyrt7UPHb8LIQD01s1ufPLK0e+PWyVt3 +Tt22vHE+mZ0wnU65uSmqddloC1orlpwZLl/XnTlV6+3OrV5G44fCjhytgUXjuYV678hw5fzkyrW9 +mb3jF+6ZWjxhpQYRMaeQT7UsZaob7bnT5c7hbGm1N3uGEXMMG0tnB5pR8fklRS/Xe7srx25fOXJ1 +7/w9D//jZ5zUjBlfnNm4tdQ6wsstUe3GknOS3guTZUs2mCpEm5DCVH4yU14oNMAPRxL5pYhUrrc2 +3vexr6TLyx6/mkhNzixeSGRQLxDjqXR5C8R7+NitvFb1BWMGnFVhuTk42Z48O7l0qT3cO3XunvO3 +/IPu9AuV9fmN61YO3bi8c93k0pmlw1c3Tt69sHzx0ac+XZ8A/ZZyxZnG4Fh35sxg/uzsxuXlI7cO +5o9vHDx/5MLdENbppePrx67WJk7Y+aWplYubpx5ozV+OZwaFxnQs1YqIGc0aOLnFbGM7W99oTu21 +Z04ki9ODhUPl/paVmoxnZ+RYPZGbThfn04X5ubWrlfYRXs1pdj1XWdQsOKsO4eHMfCK3lK8d7Eyd +6c6cTuUH6fxkLN5LFubL7e1iY7M52J2YPbZ37s6NwzeCLXWzVe0dmpg7Nb9xaTB7qjVxvNw5GnOG +i4sXlrevZ7ikrJcAic706cbgaKm9s7h14/rOLVfvemJq4XRYKADzycIaYJ8tbzi5zXR5rz93XTTW +jUQyolKV9WqpsRLPzxQaa8nCXK6y1J48GotPQsWS+cWo3S7WltuTh8vNDTvRkdUi1HBy4bydmi7W +13C1utUtNdYbE7uZ6oqgd+P5ud7MkWpn3bDqtf7BRHay3FiaWjpd6+1kSvOd4e59D/8TDhW1O/Pr +F9eO3ja5eqk+caRQW9PNSRjaTu/o8bNvqbbWWd50ku3e1KHF7YvLu5dnNq5bPXqnlZxJpJfVaNvj +k2APUqWtua3bpldvLLWPlXp7RWIqFlrdjd7kFs1aoXAcTjuamnWIuC/lK+uEXe3GYHi4WFtBPDdT +C9nGoWR5o9I7lKsuB8JmIGTAfYly2nR6yexisbFdnzjamTnXnD6L3JfKzOeqS5nyZL2/Vuls5hur +mdLM0vzR933kC92ZIwyfzBRmljbvWNq8c2Hz6vLu1VxjfTCx8/ij73nsnz8HlzK3fmHt2J2zmzf1 +Fi4s7lxdOnRLIrd44/Vvedu7PpKpTXsCumFNZopr9cHR+a3Lh8/eO1g4tbJ6+t3v+0RreBgY6E/v +NQa7gNzOibuu3PrEyeueylcOLc7vrW9dAjxiTjeeBagWy61Dw9UrO2ffeuL6d0wsXjx85Lr1rTOq +WU/mZ9KlJSs1dNLTpcbaoTMP7F54CLqQzs0BeLJewREMu4f4yQi1MF8tVLanls4JckoxivHMJEoM +a2FnYEGnp2ZOPPDQexfWzop6dXL5xs7shVrvyNKhm9vzl+38tp1dkdVaLr8qKOWIkM4VZsvN9fUj +Nx48efvMxiUN7kVrDocn7n3r+3WzWqzODRfPDpcumekZXFupsVVqbsOU5kqLmeJciDF5KQ1yxk0V +6gfXdm64ctvjIPMjh687snd91GoUKnP1/sHmxLGFzSvnb3rw3kfeDQ7Z3bn2rY++e2H7IjIRJ5cR +FpCXa51zg8WbJhavS2Vnjxy5cPnK7YViX0Chk5NmeilR3CjUDq4duS9b2WL5bDI3Az1FC1gJKP5E +urJhp4bV1sYdb35q79wtYS4B0yXI9cbkqUr/mJNdEORmzBxcunT/Wx9+byo91GNtIKrYPVztn1jY +vkU2GuFIQpBy4Uicjdh2fJAuoMWOoUzN6fPZ2iFRLM/NnklkOjSn6Vap0trsDfem5o9NzOwsrp0y +nIYvpNqJVru/1xqcrLYPQ8WszERnsH3p+rccOnsbJ2WbE7v1yWOF1vbkyuXq5F6yuIwqX7l83633 +PZbI991+3YyDkZbiuRmAdmr5HAZtY/Pazz3/jdmVM5bT3t698cwNj64ev2vrxJ2nLj+4cuQu0xne +cOneW25/XFQr8fQMTtoaHKt1dttTx2bWL/cXzpqpyQsX7zp4+JISrdZ6B5vDvWxlPV/d6A5PHjrz +5pnNq+nCyurGFTlaH/eI4Hwzjlg3IRl9ZI2oM1trb1VrM/2JLUHJWRD04iI0MRqfyJfXhsvn4/lp +2ahOrlyx0lNKFC5iQop13FTSx2Q1c7JUP0yxCfjJQmk+kZkcLp2c37xQaG1JMJNSvdM5dOcDTzuZ +Tq2zurxz/cTCuVR5NRbvmomeoNVEo4m7yBaXImIyFm/EM1NJdE12NpUf1tubME7ra6c3t8/D+Qxm +ji1uX57buDy3fn5h48xw7nAmM/no29/11W//6PCpW4LhhCCXVaMN2FQ6J8sdjPmKJJfuuvNtH/zI +s632Iixcb/ZatEZv/tLs5u2LO3fBBMoqvNeVRn/HTz5TbCvRVnPyRKW9M7N8/v7HPnLo9G3Z4nR7 +sE0zccloRpND2WhBbpq9I8fP3L177GrMbPWnDtZ665JR4aSKavRTuaVa91i9czjCZzKpiVxhjpfz +GLpEgaSzaHxW1ZuZ7DTLOwFK1qL5Yn1hdvn07uk765OHkS+8AcMXVHk5KSqpeHpQqm9Xe3v9hZMr +OzcevfBAGoIVrbUnDlqpdizZOnr+ofWjt7em9pr93d70HvgkzCPUO3ZmVlCLopLP11YBg6mlM3Mb +106vnrRzA0FOZAoT5dZqY+pIf+Fca+aUmZ4X5GKhOMyX5pAFTKefzs4aepXjksnkxGD+VHvmeKo0 +1505UevvqrFqoboIMOh223D6RrwvqPkQ47CR1MUL95JP97h4js+j3YjP0eE0GpxUFpRivjTdndyB +BLR6B7eO3zO5eEO6uLOwcmNv4ZyVHXYndm+85ynVavz9kx28VNPNqXRlt7t4S6667adMSS00u9vI +ULXuznD1wvzmTbt79+4cuaM1OF5uHrTtxrkLd0/NHQkxFqeWebmkRMG968niOgghVVxSjcLJUzc1 +mysCcqI1KDc208U1KFeqsNoYHM/nZ1c3L1U7m4AuKFfRKyBJx+l1+9sT04fUaIUTcoKUB7wTmdlU +cdVMzlRaBwuVlVJ5uZCfMYzq7MLp1vC4lZ0znIn9aaUsy5ei1tTazi1OZoqOpKCPVmp6cv7aiYWz +E/NnhgvnYs5kvbFy3c0PqWrOsAe1ieNoiv78tdtn7187fGMVRlEuX73jkdXNUyESSPOp3IYWq/NK +JsRayFaWMzBiLThSzWzGUrPl9qHm1Ak0LFmoyWeNaD2bG/iDMs2Y5PPU5oSZnJfUgRaFpZnwBzVe +sJOZdqY8lS7NlDvbiEVWerrc2Ejn52yn0e+ub+/dVGitalZLM9ux+CCRnrdTC5nyVrW/p8TqkONG +e6s3c7w7s9edO6UlBqyc24frMis6lcr06UsPHr/0SGfmrJWciggYjSyyOfnUD+W43XwoqGl6BdKc +Ls3FCzOZ6hKn5sEqc6sXUU01Wi/W1iYWLoAV2xM78XRXMfKhsOnzayHK9Pp5X0BJZ2cm5053hqcH +i9en65vIwgzv2Ileq3c0lVsWlBZMuxKr8UpuMH14Yv44zcdxAZnskigXOSGtWl3JmgAHkvmKxMBJ +TtJsvD3YW9u9vdzYaXY2pxdO5iprKFw60T1//u5iecJPG9naRn1wcrhy49Lmran8qhzt8UrZdtoX +z99Trc5HuEy9vbW6ff3EzMly42C5sasY7WJxYX7xHC/kcvm5nb17Z1dvzJfW44npRA== + + + akaNdnCntfZG1KqiUrJSyJWX0oWF6YWzq4du1mPdYEBLWJWH3/Z0KjURZlOyXo/ZvZg9KFS2ZpYv +rx28GY69Xptb271etzvhiMVGTEFMM0yKppNcJM9zZG5z6+D15dY2xSJT22EuRbOpUDirGoOoM+3x +6QdGaGRtJzHvckfI2rawCecZdfpatGka9aOHby60l2nBjsgZTsoD1U5qzklOy0rO5xUlsZDIzsdS +M/kqGmeNE2uQYIq2ZTkfNSuqlilX5+O5aTM9zFTXe7MnM/mZYmH6xPGb13YuKNGcqGTL9eW55WsX +16/USdxYjCUmObmA8aw3NyDoegx6cXx994651UvHTt+/e/KeqFPrNGdPn7+z3luH3FDk0SGZWMsV +10pVZPZaiE6oWo3lE6GQqkfL7eGxld2rM8vnEK+On3t4aePGcnnh8O4Ns8vnDbutRGsYEByH4TNx +Z05TmyHyQNNQtLyd7MBRJ0qrEaUh6k0EdrSAbrUjYlo1av2p08Uq4WE9RlxEIKhHuKRptn2eiMtF +EZbIzTe6hzuTx4qw33KRl/L9qeOzyxfRCKJagA2odY8W65vkz6foxXAEY17MVRZ0qynrtX3z38oU +V7uTe/PLl/VoO8w4gpDNZIfoZfS7HmvBqyAsJ7JLmtZimZSslmJOX9QaotaKZ+Yn58+t7dy6vH1L +s38UWuALyHTYoMIay8VlrZosLFSamxgHx24lkl2PV8EP0T5g9ajVkeSKrFQ1rcHS1uLMznU3PcQK +zthYMBSQJD4Vh03KTEciab9PjRmV5//lu5sbJ7xejovYmQKOsJktbFUbR6rNXfLHIrxSLjcLH+Xx +ihhYBkYLfRetRJ1mMtXdPXypPrVCC1HJyKaKU/H8RDSBilRxg2zYLuTnk9lpaBkvZzHmNOvwYlZS +yjG7q5NBKxw/ebU1sRXPTShWQ9ALopKxE4064l6yw3FW3G50Jw62extOqssKCW9QA/0i3JUah3Kl +JXSKlZyo948tbl6CUWn01uPZHitas3Obpy/fYSZq4x5B1rrRxFw8vWA5PYxPiEnCslZbu9F4laZl +y650p4/Mrp3fPHLTwublibm9dH6qUJi4cuWOc1fu9QRUQa5E7SnTmc4Wlg29xbJJBkUU06KUQRWA +7WhqqDszseR8rXuyNXFWUCsBSosnG4XyvGGWcb/wpZpe17S6ptTYcMLrYoK+CM85ql6Op6aQ1OAu +aCYRs3rx1LQZ7wXpaKW1Wu4eTFeWlVgFoYmNJBLJXn9qD/HQ65N8PlnVG2jeYmW10z+aKyztfwRG +FqV8vbXl8QpatJzOT3en92KpoaTXqLAVoqLQQU7KMHw6nluYWro8v37d9OK11daOrLUpJoORwfVQ +tMqwMUUrZctLq0duHS5dzhbXtFgTB4+IKdWsambFMBvxxLBUWatUN004KCUfjVbcXt7tYqmAxNK6 +LGZDQYMsJvSrttm8dP6Oan7gcUUUKR/PzGjRlmG0FaUsiHmfT2OZZK26rqp1LVoPhOQwi57NZksk +8g/XdhvD5frU4uTS5vaJaw+fv7ywe9IpdTSnmi3OJhIT2eysopb8IYVho7KctOxqKtvPFCfsdNPJ +tqqd2ZvveHjz+KVqf142C6pdyVUGg4XtbHeB5mL4/WZjPpvv+wO8poN54HzMevtgd/ZcsrzGawXT +KVZ788nyIFnuqvESoyQUK5eq1odbW/W5NdHKiXqWTI/rJYqJudyhEK0B2KX62uT86Wi8KMkxw8om +Cl0lljGT5Xi+rccr2fJgYW1n/dipVK0fUZLxzDCVW9j/nII5Pk67xsM0Fa3WV4sVmBy0TwKNXO4c +TBSWkJIEvcJKWUHL5Gv9WLJE8UZYtDS72hkelZSq36+5x8NcOKbLWU0p8HySDptBOsbySSveS5aW +RKMO4RCk1Mlrb945eSVd6XspPsjGnMxMurAoKiWXi3W7Iz6/zPEpQcz5A+QvIQRDlhGDpM4Wquvp +3IJpt06dv3ro+IX6YFEycj5KhkNw8gM90aR5U41m6/1N3WqpsSYgDY0WlebU7KWl9ZuTmaE/KAFa +mlHKV+bNRCPqtE2na8c7TrrTHm63Zw5mSoNSba5c36i1dvLFZZ9HPnCNb3SUVtRyJj1Fh9Sx0YBr +nAkFTMvsdnu79cZBVWt6vYrHzfNCwrDro67wmDvs8nCq0a02j5fKBzWlEQqa8WTPssut1vDgzom9 +4xeuv3rXQ4+944n3vvfDz3zia9/6xiuv/OYv//Gfr/3bGy98/yf3vvWJ4eIers27vwZMFvMNeN3G +9ERvaTi7tbS8dfjYqSs3XH34sXfc//bHb3vo4Yu333nzPQ/c+7Z3vPktj33+2S9+5gtfOHLi2r0T +VzqDFTgBQUo7qU4i09dihUSi0uvPrW3sHD56/OL1V+54831ve+c73vWhD9728NtvvOfBBx596gOf ++NjzX/3yV779vS9+/Vvv/uAnDp24aCWqvBinw5okOLlMr1SesOPZUrW9sLy1c+zc+u6J6eW1lYOH +N46ePnnh+qee/qefvPjTX//2N8997Wu33fvWxZWj5cqQpmN00GLouCRky6X5Xu+gLGcDASUWLc4t +HZ5aONgcrFQ6883JlRPnb73jgbc99Ng7P/Pccw8+/uS9j7zjgcefSub7sFKgOyqox/SaGevYzoRp +tSQ5kyv2K43JTn96anZj4+CZC9ff9cQ/vvepp5/++re/84uXX/ni179x9e4HNrbP9vprUbPOsMkw +Y4OCNL0EN4sDhkIxQcgVy0uDmSPl5ly5OX3pptvf/eEPP/mB99//tkcefse77nvr2+9680OPvPMf +v/jNb7//ox9984MPX7x6j2HVw+EYTemqmo0nB/nCom11y5W5VKpdKg2nhlvHz1y3ur528coNN9x6 +5x333v/M5z7/+z/+6d9e/9MfX3/j5Vdfffp9H+p0Fl1uwe1W0HS53EqjsRvwx/w+KcLEzFhNUWts +JB2JxBU1p+mFWm14+vSVq3fef+nmu+576NEn3/Peay/esrB+YXLuhGk1yFrWN9FRNTM3uXL00Mnr +Llx31223vvtd73j+uWd/8dIvf/O73/7slz9/+eWX/+tvf/vt7//1i//ylff+84f2zt7QHR5jItkI +k8ojldvlSq42iwhx6vKNN9xyx113P/nkk1/48le+9PVvfvxzz77vox/+yje+8eKvfv3s81/69jdf ++Nvf/vbcV1549z9/8uJN95Rr863O+uzS0dZgJZlpNOq97c2NW26+/Ogjb/7AB9798U995Ovf/vor +r7327Rd/8sUXXvjOj3/6xht/+j//9//+6T9wJb//9o9+9MiTT88sH80WhiBMWbIKmepEb+bw4SN4 +nTx1+q57733P+9/76Wc/+cFPfey9H//Yp5979ocv/viXv/rFH/79d//zv//nld++9r5//vDV2+5v +thYto61J9Vx2odnZ5fgMz1qZeBXEffrU2fvuf+Cxdz752NPvefRdTz/35a/94Kcv/uhnL/7pr3/6 +83/8569+/dvf/u53z33xq6fO3lZvrkejnVRy1oi2sqX5TH5yerixs3P82vOXH37bQ+98+h8/8NGP +P/P88z/82c9/8etXXnz55V/95tU3/vz6//p//wfd+oOf/PIzn/1Ko7MaCOnQRIqKBskKybislOKJ +TrMxu3f87EOPvv2hJx794Kc++qOXfv6zl3/11e9+6/mvffmV11599Xe/+elLL/7xjT/+f//nf//2 +td98/JlP33zr3dX6tKbBbwvBoBSJWDGj2Ousri4fOX/u+je/5ZHH3vnOz3/puR//4uff+uH3vvKt +b/zuj3/463/916uvvfrKqy/97b//9tNf/eJtjz8xu3C41duJp4YURRY/ez2ioeRiej6X6fb7a/Ak +c/PrZy5ceegfHv3kpz/54ku/+M3vf//lb3795y//6n/9z/+88de/fvLZzz7+5BP33v9gJjNlGD1d +SixNrx7bOX7D+Uv33H7Tg2++/V1PPPi1L3/23//tt0D0K6/+8uc///5nP/fhu+++evjw4XprKluc +4fksy9ianIqpiYyTnmh2z5449ZYH3vL2R9/22OOPfviD7/vBD7//vR98/wtffv6FF77xxp///ONf +/OyZZz/z2c9/9vZ73nLw8IXh7I7j1Iu5QaszX29MVirdzdVDe4ePntnbfeudN//LFz77la88981v +feWVV3/1x7/89cVfvfziL3/x2mu//o///Mtr//7a177z1Ycff+vBIyfy5UnLqZt22TGz/fbk5vqh +K5dvvHjh4oWzZ95y313PPfeZl176ycu/+fX3X3zxa9/66i9e/sm//v7VV3/z0m9/g2b52eeee/au +ex4YDDckMSMJmVRyUCyvKHLRUDP5ZG2yPXHq2O5T//DIl7/w+Re+861Pf/4zP37xR6//6Y2//uff +XnrlJ6//8Xc/e+nHzzzz4U8/8/Fzl29OZnuwQyArJ9HNFqbyhcHS4ubG6ubF8xfe/fQ7P/bxD33q +mU989vOf/vFPf/gf//1f//r6H1/85Yvf+e6X33j997/9/WvPfekLTz35ruHMoQiXQnAL+lU6FIuw +iVi0NuhtdFqzZ06efuofn/zIpz7yic8986Of/eT1v7zx+l//8sOf/ejlV196/Y1//7c//O7Fn//g +179+8acvfvfpd7/zzrvvqdamYmaBDkuAViLZzKRbxVxvd/vY2x95+xe/9KUfvfjjb3/vm6/966uv +//n1V1/7zS9//fJf/vonHOd73//aD3/8wk9/9v2nn37XlZvvPnzm1pjTdrvFMGWHKUOIRKmAoAj2 +/Oz6Ddff+La3P/KZz3/2s8+jmp/64Y++85///Z+/+8Pvf4S2++kPUaiPf/pDt912y7Ejp7O5Ybd3 +NG2Vhr3Zie5kp9ZYXpnf2d1eX1s4cWz9gfuuPPbYnffde+XWm893O5VUwlRlLRJR+Ugs6JeCfpEK +ijJnFpxSt9Sd7c8szs6cOn705InDBzfnr79y9OEHr3/87bfffdct99x3z3VXb1paW8/mqpbdyBbg +vTsMrUfCusRHFUGHcbl49sbjx880ypXpZvXs0Y3bb772kYfueOqpB7751c/9HHTz8s9e/e3PP/rJ +9950y6Xl9ZV0ppRMNRVEV87ieduKZs+fuf7GG++aHC73elNrc7N7Wys3XTr+0Q/8w7de+MLLr7z0 +2r++8q3vfOFLz3/88595/4f+6aF3PnLbtSePT0+vpHM9mjYkKc1EHK8fuUYIBOQwpcT1eKdUOLO7 +/fj9t3/hmY8+/6XPPPfse3/yw3/5059+/6lPvueeq2fPH9+amxp2OgNRNEJBQVXSePFCHC9Fjuty +rJAuT3Wnj24cvOu6c0+/88GP/PMT//L8R1966Qf/9off/Pkvf/jZT778ofc9eucdFyYHbYHXeS4h +S/lgAJaGLFH2ujkp4hSSrVKytra4cmh78/Ll87ffetN9d9360P13PPvJ933zG89/7g== + + + mY98+qPv+dgHnvj8pz/4xFvvvu70yUa1r6iJMKuzbEwUkpqer9XmU8m6xBmlTOXUkRNvuf/NH/3g ++//pXe94yz13v+9d7/z+d1944ZvPv+PBm9//6H3ve+LBW268cPLIzsJwvl6fnVk4lclOezyCz6sI +fI4Jx6iAyDNao9g5ffjoW+6+7XPPfvy55z/zvn964uknH/70R9/7/e9+72Mf/OBb77pz79Dhfndg +qHGBd+iwHQqoIX+EDSs8q8lCNJlsVCrDmen1jc0jatSKcPCWepjRaVrjIpYkpUIhZWzUF/ByPGNL +QoJjYgrvqOQV01WrkG1kUhWOESIMx7Girpqa5kSdOh2J+wIiFdIE8jmFZIASXW6kWl7kzEhYEyIx +O46QkjWMeMKMKxxvKmq9kO80ayuL82evvbBzeLdUKqGOgaDgC/AIHbDKFBULBLVgSDXNcjrd1vWs +KNpRPZlP5hBH88lUvVSolsrtTn9pZSObzlZy+fnJyYlGPW3YAqMjNQtCStOKmcKsoldGRoNwOwm7 +Yxu1jFWcanS7pWo1lSwnU3sHdxYmm71afnF6slxsG3rc0DOKUuEiyYBP8ns5n4fxummPm/37X7LS +1LITa/YaS7V8p1tqPnDX7ZfPnBhUi0sT/clme2N2uDnTb5XbHCONj3nd47TfK4yPBsfHKJ9XAHdF +GEcVs3GrnkPMKtQrpaZpJLgwZ+nxcqadtkutSndxuLoyvRKPxqrZctrMK7wZCqour+TyylQ4blkd +x2lrWjbCGhyDzs3lcwM0tRmtTU4d29q9urx6wbEKPB3OWk4tW07GUiIHwhSBItPuTM1dSKTmfD7l +mv/HDSMqCjmaMhQ+bkhOPp6v5SrlbKFebMG+G5wUE41ErJK0m5lkJ5uZoih0ip3NT5tOf+SaAKDi +djPBgBQJG7JcjEbrndby6Qv30BGbouEtK7rRjMbayJWSlA8zDkaAj5C5srGxAF4uN+P1CDxrq3Ih +mRiYZiuqlRW1QP6QVFD2BwWWT7GRHMZcVyoCl/L6IhSt0EwMxkbibSashUKqpJY0q2El2o7TYBiZ +ZWRFsgQ+pihJ065FhDiyvygV0Uoj5MN9YXhdlk0IQlqUkoqaCVFaMKgyjOn3CxQlh0KSJCSRkS2z +qaol3ajxfCJhF2NmZtzld43RLO2oShGyrmjNZHZFkmsejwgPzDJRryfidYUpHxv0hoNemgurKacR +09OyYMpCiqJspG+fX/37R8uDgZjAZxna9HuEEPmkUswfNGk2HaRsaJwsZ1rNudMnL9VK7YAnGBMd +U87F5IyC2wFHjVEeNydyOY87cuAat9vFiHw6ENDwQsuH2TiuRwfyc7Mcl8BVJZK9WmMzmZzIJtoK +F2dpnaXU5dmjupIB3eFQvNyQjL4eG9hOX5DyFGOH0dH7f/zWSUwnssvlxtF65/Bw8XIyt+jzQeNi +7docx9ojB3xe8hct7GR8amn50tTMOUmujo2GvS6mVV0U+PToWBjVDAZ1PpJy7H61tlEsLIf8qnuM +ElmIZizgVxjaZpkULxSRmnG6ZHp+fDzictNuD+Xx0l5PmEVulUs6mbheluVSuQAvtGLE6ppe57gM +L+Rlsqw9EeFzNJsYGfGNjQVxUr9PlfisoVYNow74dZpbvYlj4y7W5aJRdEWv2olZ05nEYSOsE9Oy +U5ObWrTqdrMeD+PzRf5/kt67S64ruw/9BCI6VQ435xzqhrp1K+ccuro65250QKORMwGQBAGQBMOQ +Q1EkZ0YTpLFG0jjItvxkW5at5Sf7Dy2/5/XeP+/bvH171qqFhW6gqk7Y+xfuOWcfDNML5X3bX9cy +fUEoFItdJ1tHUAneG48DYNoonlO0YbVxScBEhAk0DUZ6BB8VT3DRGAVRhxG2ojVVpRMNCqOxAGUk +aQFCEoQNI5ZKqQydt+wBK+ZDYRRBTMMYmpk+y5UQPMvwjXhSD0cYCL9Egp0LTi4kYmEsGsYSMYqh +HEg3As8ASCaT2rWrch/ptIGi2XQ6qDnAsiUMd+MxkAoWittBJb0wF47JMFauNylUZgRlQU8jIYwj +XYjAhbnEQnBWnQbzjiIZz17DEDccJuEVjdKLC+lojIMRDjYY0HnbXXNy22nEFATPcvuMUITYTkS4 +pWB/O07jdq95LPK58BLKsx4vtVKInUiZyaBaVNV0VrXMGMVsmnbApHTHd/zyHkWXaLacSOqhEG6q +1dnKPRJ35ueSNJvnuLIiVi2jReA2qPf5a/FUjN7dvMMwfjjCMWwBp3IMVzHM5XLtuqL0omEuFmEJ +3ITUCC0hGKJwbEFS+5I6NKwVSW4FJShxQ9V8QcuHIngsLgZVQJW2Zg+y/upgelmqb/JSQdIaglQ3 +nbHhTFmxkca9xNX5Vkj2NHJ1xn+BYCifonyccFSloWf6i0t4EAa4RnG+4S4zcj2eVuHHot85PH6g +mJ0wjCGqkxSEugOeCKYmlZKAH2/ffLx9cAmhhQOsMUWer3NcTVa6qj6GaJcE37HbKCotLqZhLgjC +ZPmCrPezhW3TWqOpfLm0brt96EtAwWmZJB0AFlluQiZimMVTTre1ywklmMFwiIyEeQTNphA3lbbc +3AxE1/xCChwKC9QfZ1NJDsf0CEx6UCLS5rgKgEAqDa0qkISPoPZSGI8lRJwuZ5xpubYlKrVEUg3q +m6FuGrVB3nN8AbIjFGYlscmzpbn3ogtzoD8s01yR5S6KOEHt5RALbkISC9AeDNETSTl5tREFQTNB +SRMSRsbb3L7fGx8QtAMtF/gaxxQ5psQyJQSx4F3AqhgiJ5MAm8FmbJTIFyrX909/0h7eSqEWDIKk +VEgqKJiGY4XggJXVd+yOrrZVpc3QuWQi2IMaCwI7sbSIhpeIxYWAiZC0YlkdgsxCrEpyNQbyIwEU +owRHz+bgf5IYZuOY/d4fhaABNGHQlBuOSKGIshSW5haI+UUKZOTN8xfbJ8+WYkw0KXNyT89u+Y2T +SvfMLqxLamN1fP3RB18TfC6WlmIpBcF9gipJ8jDj7sZSJmAChphXhsLg+bLAl2kaBsQn6DwgCc1Z +vOIzUpnkC7zaVK0OzRc4uW64M798pOg9gG5RLuJ0cBDMAKljNinWwSgLmJdhAoxaWEwtLCLxhAjh +JwhlTWlwHLAtDZwCEA08DtieQm2MKrNCT1J7qtbRjB500/N6aUSKRkn4KMAQmimyXNm1exfnLyS5 +tBTCIxGSwLMsWxWEpiC2aK4EQwe298H916XKNAjdCImlVdBUstKGNETSOoCqZnYYzlsMoaEwEYuz +aVSjuaJhD3HKEaTyzvFT3elfm09du5ZMJTWS8mg6n7EGfn41lVQjSzhLWrxYnF/Arl44vDAsZ1nj +nLcsK1VVa6ZRPRSh40kxhWg0U4KvbvVvbBy9FGSIMW28fNrun+G4E4nyoRATjfAoonGMA4y5tIgw +rF8o7/rlXYIuBMevkIxk9uuDW8tbj1WjDWDF8k0Yc16sJJNCOiXGo9zVQT8L+H0JVF+MCw6YpFSS +cHDUTCXkSFB3QkAw+/DopanXrl2LhUIUoKipjxmqQlOldBroEksmJPjAhflYPEaDVoGkSKOWZPRB +opRKKxmvGwZ/RFgEV6Clql3c5NQmxRdMq3d2+uGTNz8QnEcyWd0aZL2NnLdRLO7o7spihBVYf3N2 +R9Pb8/MAIxxEMk0VbWe6tv2iPTjP5/v3H70V9CanVPO1zUr3eq1/2hzdbEzuqvYyzeeLucGf/uJ3 +a/t3ISUxTEMxAyNcQWrl8ruKNkgG1eAtAA0sKJ5TppgqQVdZrmnZK1Z2mkLUUAghgx1BwekMlHAp +ugAvQaipWqvePFDVWtbtOt4yTrqy2jbcqWz2Ca6UwqwUkoHWgmq6OoSbEaSG660IXAmEouU0cNIg +cINjPYirRFzCCZdh8yCfKNZnxYqo1oGCIYtjMRbUezRC81xREMsZd9zfeEyKlVA0qJIBIEmQFmgz +CL8UYgDj8KA2SUht6tpcemERh/BA0hbLNhWlD/pE0Xqy2uHEKsnmebkG4hYJCk95olxXzG4qKStC +7s3rbzW9AqARChEoagId81yBYbKgtZJJSRLLolhkWQ8aU6hslDuHanbslDZEtUmzvu0MKcoLLZHR +iIChLk2XZWmgKpN02o1EJZrM5nJTUD6gpaFfS4vY4gIGzWOYup2dlSq7YDGiYFuC02QyjtrBobCY +imCuone9whpoWk0pZaxCLI7FEnQiKQUFZIhg4RVoK4lqot6kpRJCOU5xQ8+u5Ipb45UH4/Wnheae +JJVKpVm2uMJykIkWQZmA20tRBj6z3ztR9KBODoE7XDB6eU1rNrvHudJqrbb++PlXglEXzVprcjZY +uzfcuFcfnpU7J5zc4MT8bHL49//pnx5++GUaUynSUpSmqvULpaNa80KUu6bZD5KU9IKDwFRF0iZm +drtQu9mfvp8t7aLgN0nTcfo4mY2n1Bg4UCan6G3QbJxYy2Sn3e7+209+3Dx4P5kG79N0i5tWfku2 +ppnsZtbfA2WSRg1Oql1V0ckGZxzSdjIWlA5AEaNUmGlaA2I7GhU4JmdlOoJcl/Webo/ag7NK64ig +s6k0oCIdi7Kg6/RMN1/fqw5vcVpXMnq6tQz6LR5ngrVCdwRv9PKbheI2hMpCUM6dgG8BBIjHwao0 +JLktyi1eCgraCGpHyYxFvQeJHLsqhk8xReiRkelk3f766ilFGRDPAFaqAlKhDAEWCpOLi4gi12Sp +BN8Yi5ICly2Wp7nyCqfULG8mKG1BrNvOmBfKQSWroGpuESe8q2oAVjwoIlcwtE6lvAm8gCI6jmcS +wONLJMeWaabMCVWAfcA0oJU0or33XngxqLQD4qosyw3NaEPfgXBz3hh8+eJiLBYDptBgUpKA+ZQP +Ximb3+ou37dzK9nSmmIP9OzEyE1z1W3NnoC6WOsd/fTL36zu3wd9DuYFB5OCZVS9k3HGpjWOJfh0 +gqdpP5nSwmEWQRUQ6l5xrdw8LDb2WCFrWrXeylmw2VivB2cN/Fm1dThavtzYeXzz/heimsdIxXGG +Qd1UtQOtwiFsGM/1Z359J4kaoTDt+TvD1aejzce52h4nNTG6kMYBi5q15p5m9VipwssVSQX52jez +Q+DxjD/0q8uD6ZFfW6Npczg+2Tj6qDt7JOpD2RjBK57SZ8tnn3zx62pjLRLjQH+SVJuiWsXiYa15 +O1/aC1ScXDXtHsiYCAjRBO8WNrb2nj9++WN7dJNkctevP97avgc5LivlWu+wNb3VXrm3fvDq6PK7 +Ru8uqFCOz6pmgxZ8UHHAmzRfjweFL7R4QgiOh4cpFAXqd9JIcISTYMtSZpzvnDuVI4KtELRlWh1Z +bwGO8VJV0ZuGO6x2Di1vDBoGsAWsWSwmpIMdDgKGGSiWCUfoWAzcsRmPEmnw1KwHLO/4a15ph5Pb +rNg07FlnfK/SOIsn1MVFjCDzgtSm2YqitslAKuc5AUKlA0jIcflYNFjNDCr2oGDuKg== + + + othw3AkY2PfeC0XDZCREhJdwgDJwFqIETrwiiA2WySfjwNFqPMBzEmQeJ1ZkrV1u7pcaBxvr9z/7 +4s+z+YmgVOv9G34FJm48Wbm3svaw2j2No3o4THF8kQPeJLOq0uKEShBOEQjparW5TXM+9FdRqpns +2C2sFVuHVm7VNNvrqxdvv/5tGtNhiEqNo2aQ+AfN4XljcO6VtnDS0nWgpHEsDtaeoxkfAixf3t+/ ++GS89Qijsok4z3C5NG7FknI4xgLIKOao3Lqxf/qpl1/J+tNya4fis+EYSTKu4092Tt9/8/Wvnr35 +cbrzUDLqlXz35u1XpjcMxXiSKxTr26XmnmxOyo3D2eaFaTdS6Uy1fdP1t1m+rulDxeinMRMIt9U5 +6I/PoFVgwEGi61bfsAeS3oynNQQzV7bu1Lq7CKW7/mi6fW/9+tPRxs325IZf3ZGMpij6f/Uv//7l +669J1gJx6Pq7reVH9dFdPbMSjUkwR9Px8fnNN9fmwLTaqjUtDy6Ge88n+x94jeM0lbOdzr/467+7 +uHwZiXLgap3cWnf64Oaj78arT4PCcYtJVfJ5vrgUpiIxHiJWkHuyPgZ3BjYhneRZxuH4PIpbkMXN +8a3BxuO9yy+P7v50svFElBrz8/h05ZaTncaDUqsUfAWMANDEZPN5obKfDqp/qKBXZQm8jwnOAvRY +PO2CoMWpoAo3qPcF0D8hiiZcHMuwTAFkNoHngCsxFPS8A+DJMBmYygQEJ6pTXBY8Tq600RoeU7wn +ac3W+Fa1d5GrHIxW7mcLW0E53BhPk6amVzECRl5PBgU8tWhURhAvA5ZTbQJgqlLV9Xo4paOEdrUN +rNLoncz23l87/kASi9PpWXt4THAuqC+/uu0U1gW12+ieDlbuZguroFIkuVmq7nr51VxhzSnMRL2P +kb4kQeYWFpaw+SUcxaxydbdYOyw0rmeLWwyXB7CqdfZUq40Slmp0gYB6o6O7jz999tG3e6fv82p5 +PNz79ItflGpBZe965/zu0+/f/cnfbJx/qWU3SC4PUyNwlWr9IBbUeaOJoE6gm0zrFJO3srOgPkBQ +kVsiCC+VVjEyS3Il3RllC5uVzlEmOxhO9u8+eptxBgyfI2iDkSq0XJOMRqN3cOfZN+XGevB4hHQG +s8dAo4Yzjif1eFLGcbNaWl2e3gRaJEmPVxqCWueVlpldN/3VUnt3tvvwgy9+Pd2+vxhiCdq3c2u6 +NWGFCniopSUeIMXQmqpavTaXiKcU3VnLlU4MZ810VkEOgdfm+AAqCco5u/vmxbufn9z7ZO3gpVvc +BqhfCoP3Ed58/rtaax+kJkH4ljvFiTwvNMr1ffC2kEcoItfra5pSBtt4DTxgmOOUvlc7zddPi7Xr +NFXBUMc0hwTmLs4nQ0v0VRFUFrwkiKJkMjgBNF07AzULbQs6S9kQGxl/S3ODjcEQWpo7YIItahU1 +M5UMwLEOQ3kSn+PYLIQQDRBKljm2DS+CrBJUGWA2kZC6rYNyYy2oqhchwQvLWq81vBis3a/1912r +/sHLb3ePHiOkUaht75293Tx63RnfXdt5vrr/QnfH4SibsUdgdQkgXEKHIWX4lmZMIR5ko7UIIBzc +fePZ7oiTqhRf4uUmxVUUIzgdySs1Qam7uRVBKqlKcbB8Mt64O9y40xjs7x0/W999aNp9NzfpL18O +pheTjZtWYTVN5oOyzyk1505q9f1QhF0K0ZLSNt1Vw1oGvSSrfQDkdEpj2TwWlKCkBbmZK21Pd551 +l+8Vqtum2bi89ez7X/8eeBPGkKRcLTNtDy9vP/r6xWe/mew8gdBNIrJfXrbzMwS3ri4bYiJxiSA9 +MCY4kU2nFUmp4UFdYiaFWJI2LNT2bz569+WP/+r55/8i3zqOJjVRqcNQILgNMwUsRlNlVe3LSh8M +zsIiCtDk+NtcUBleBxMEcwdkbYBoZzxAgNXNy+naebG6ni1uC9qYldu80gEqWd76gGTLsbhqeeua +1Q+qK8SkNGIF9e0XSZywGq0DHNPnr4Xm3gunYASCQ9Abkj7AqdzCkpBEXHBV4VDwBCwRV5NJI5ky +wEORZC4oo03nKp1DnvaqlVWayUbjHHQhXz+x8nu6Myu0TiCPgG214DnVkBFq0DvQ/ACVyYScTChI +SgfbAsOeTqqgSyHUr8oSyo4zSgblqlCYiGhCgpYISkMLrszo5vzBYHxqOwNJKq/vPt48ft5buZHJ +9XnJpzgPI10UzZhml6GcVFIEZahn1iuN293R4/W910RQ/FkQ+KKdHYM0SqQksOcYWIbM1HJnoH4l +tT5ZORuOrnOsQxN6vbl1cOPjO8+/vf/8m7ff/K43vaWqnY+efPH1t79WjBpOOThTEMAyVI8mq4+3 +9z8iqcrcArYIGMKULG/VhEQmfcjuWIQHsQ1eLB3ceaQZ9jjjTgxQd3yJZvKqUqu3dtZOnnNKM53O +tNpnw/GjSm1/a+/xzvXnotZMphTban71w19kcitLSxyCupIKmnzGia0UYoLUB/pwc1NwcPGkICtN +v7RdrO9NN+8++vCbo5uvRKPrOOMnT9+B70ujZsaZFMrbldpBqXokKaPgPqw4x3M5EFrAa4tLoJ/t +cvOoN7tVah6AQiMpK1+YJFNSPClCaEESnD74Zu34dX/9ESs15uYJmsg9fP87TikDI0DAp1APxYt6 +ZrXWullv31oMnnElUkmW5XKLS/jV5W4qAm5daFnelqwN4RvjUYogdLDJ8ZiIkzlWAD872Dl58fjN +z9PQI7GE4zaOB7vXTHdsejOntO9WjmixytC5ZmNXkMB6GzLgvFxXtbaiAFKVkbQO3n9hIb64mF5Y +SIeDaufsVckyFUllGMqnSTuV5BWlbjiDfHUjX99uT246+VXwwrn8iut3GSHDiRYnuIpSkdVaxhp6 +3joKsjYlC2yWpOxEkgeBKokVlgtK/GGYK/I1cNbgiSDZEVQH8ATCikRFoGZJbpUq2xmnT1EZls7Y +2UbGq+dbs+HmzdW9R63uYaOxe3L6otHdYgXfy89q3XPFGufKO5X2meluYVgRx3O63paVKoirBHjD +mHglHmyeLYO/4PkmRWZBXS+GknMLMRTVHXeay+82u5f7Nz8DDZYxm2cXH7nFNYCvZEpGrw538HzV +y620hydLET4cYmWxDagYS4gLSyi8EilZUhp2dkpCqGMKpB7H+amUAkIuTZhosAu0Nl6+s7X3CDyX +qtWGy5e8UEHSWjwqRK+Ke8djHM/nkkmeYhwEszm+5ngzDRqTnYhaWzI649mlrNZFqTBaPumv3IDf +kHw1TdgIntGMXjYPjvskKDQEBtAaZfO7bm63WD/UzFEsnoHYi8eEyfBga/NGUCYuTKXRjGz2i+3r +nckdw15eWCRcu1erLYdD6PxcAtAAhIHnTzWjAYmQiAkIYsFLVuqS1uDFIviycvu02DgZrT0rt06t +3DJK6pbdHU5uGVafoHLJlA2mNRlclsdFo0wkQocj1B/uZfhDNTyGKpGYxxKeb3d29+4xoi+q5dHm +nfsf/OzBx3862Xtu+uucWHTM6uHOzb29p7rZTaNqMq3gwWpjliJtz+1RpJlKsRmjamhVMCwUXcSI +UjyRuQpgOhGs2bFLS4CNFKAouBtFHchyD3wERmYkudhfPtjcuzi88ezk7uvTW68uH362efC00j+l +eL/T3rpx/kJSCgimKHpDN0e82NPNFZIsIkgGuBjMNYaYOOaSZIHEcwhILFSHQZaEiqK3BMk3zBpB +ZWg2x/Blmi/LZtdy+/3B4aOnX2qZtqrVwVkIUk3PdPz8ZiYz4YUaiOGcN+i09uJBHWwkFpdRzFW1 +nqS0JLnB0J7jdAF14V9BR4ElL1YPxmsPptsPz269g79D7k8mx9fPX/6huByBZ6hgKw6Po5oo5mky +0+puK1oVQAwCD9JNzfTzzcPhzvPrNz/PF2Ynxw/+2//4354/i8Z0XuyDp2h0rr9884tnH/9Ss1fm +F0jIGkVpwrdAWoWCGoNCPG4Z5oqdXTPMLo4ZIJxSSSmVkuNJKZaSQzElHFzkYVrOWNFriRQPJjoe +Z6NRKhrsPZPIYDsH8H6e4WuKCc6oC4ar1jnI1dbz9Z3G6CJb2VXdCSjk8eTm6cXnGXcYC0pwB8VP +RL5KUT6KZIAQgSWDyuTB5Wh80Pe0haYMGrc8tzWZHTm5QW94sHfxstbfrfUP/Ma+aI4prpS1O+fX +nx0evyGvLtFIpSWWLcpKhxcrmtZiuYKmVuv1dYZxwGujgB5CV5T6nFCPXxV/DmYhxkGOA61crYar +KObwUlExGzC//cHBb3/3H/72H/55Y/8+/AZg069sTdbudgYnq9PLvZ27llWzMk0z09WNrmmNGbYe +j+mLC8EVS6ElHEIrmZAiwRoWuriQioTJWISmSde2R9OVy72jJ7GkAKoGDy7mc1WrW24cVVsnpj2k +GXc6PW1395GgSr9M06BIgyUwMOa1yqzV2AgtYuElkqZy4O8I3IpEuGQScsoUxbKTHUJgBI8H2ZJm +tPzymukOZbUpKR2A7unyydr6ZSwmQjN4zgcmTSdlAtM5Jkvghp8fieCRlxASB82TlbWm4Y4sABC9 +RVOZWrn//PlnAI+i3K83bzXal46zXCqt+YUVhq+CCNflWrO2AWm1sJi+urOgpKire4df7p6808xh +KMSAZQBmR1LitbnYXHCJhpxIOgxTA8NF8TmcttKIMj+f+AO4CXK10NgD0wdeO18/8kp7vNQoVTfd +wghlDTM3aC9fTNYfnN/54tmrP/3o3W8vH34jKhVJLoPMwHFwnXYkyiwuIuEQnk4BogocX0oGdXJE +oBIkJbNUhqJN1SqPpscPn3+xdnAHhR+BHOuH7eFdQF3T6mVzE9XsJxGdFUs0l8PwDEA6LzYVtdcd +3Bwug1WfRGMyBcwiAKp3WK6eRuxowowmzasL/jSa8SBVUykR8gVB5aw/PDh5enLzg/bw4OD6w8uH +H2e8tigXsoUVyxsdnj5bXrtDMTmc0DKZ8vHxo2p1Bd4FDhpB7OBZIp4X+DKOZjBED4eISFAoLyj2 +CH2MhAmQBDl/VixvFkprqlY+O/9otHxB8p5s99rT+6ONZ8XGoeWM9g6fdvuHAFMwIPniRj6/oSpN +IMd4gg+FsGvvxVJxkcQDTF5YjIdCJIZmcDwDeikerJgoLJ1PBF4Vwwjg0zLohEb7yLaD1StoD8f4 +GaMZ1HBbRAFOkZRCkw5DBWvc0QiRjNMc7SYSAOxUKEKDnNDkoip5mloUxWIuv/zxp7+4eectgmZo +uqgoHeD0SuMQFCxDaiLvXFV+phkmHzwOFVuy2HSzoMOL8SirKb7ntEHhvHcthmABzYHyCQc3YVHR +GJtCVOCd0BIai9EgVADlwNEgqMkHbqtAc3lBaULq1bvHltu4vP9q9/r73f716dqtnZP3Z3uPC/Vd +Ua5Ua2um3bzamWPCCCwuBDuOGDKoDGZZYFtqvcE5TmXDYRxFFF4sVdp7Fw/fPXz1ww== + + + ZPXW69ffvf3qN9nijOaKLF9luLKi97zCdnfyZLr32i1tSnJpMLxR75/YuYluDUBIx+JBfeNMZgbu +Y24hNTefWgwzrNSTzBWab1yV6dNEoVpp7HNCDvRkqbJy9/6rn//6rx88f1fu7tuFNUltnVy8Obzx +ke60CCbjeNPp2u1298B1B9XqVNMKMB3gfDm+DHomngjuGA1uz0GsoHoDBcYwszAfoFYqIeha07Kn +vNimmbLndY+uPyiWx5zkeeXZ5snL03ufLe88aU8faM5yKq3XS+tPP/gpxTuRGJUONieDzQ8K6MUj +IoFYhlzb3rg8Pf9gfj41PxeDzwcStHNrMCA0UwDs6rR3rp+9BC+MEw4nQDrneT5PE5ZtA6rnAcYl +Lqtq1WSCTySCnTPRMA3fgiIajuqhpSSBK5KUBzcEkdZore+fPto+fJyv7fVGNwCpJLmyd/0Fz1eS +SS2o/x8TEzEZw7OKMeCFEuRUOIQBEkLcYojG0lmGBP1Dw5eGl3CQwZKYn7sWnbsWvvZeeGE+DlEN +HG0oVZF1e92dAhiHOGPqVQQzRKWm2kM3D0r7cLT2uD+5sb928t/++/91+eA1eEY90ys1tnOlDei4 +ld1gpQqCaRLvHx2+T1DZpcVEJJxMJqhEnAMkBFUJalbVSopWoeicpDTt/HJ/+fp042a7s/XpJz/5 ++N13bmHIyfVi9bhQOuiN7hxefLG5/3J165GdXS76y7fvvtLsYpoEa+nhZBl4yrSmqjFBMCeeVMCU +gUOJJPRIcBEYDRYJfFausOv6m2DW7tz6aGX1TLeabmGl2jntTx9sHb669eDr5+9+25tdDsZHD9// +LFvadLyRafUFsQK+GFQx4KFpjBFMj8WDjMNwV9eWLWsVDD5BePFYUJNZEmrRKIAMBiITx4tB/Uws +EywPKXXbG4pamZfyMFYY6evWcO/o+drGbYiNTm+DFbOKVnSdXiqYRCOdtpMJHUlaHOX32wfT5RsL +Vw+RSNIAPUAyeUHrCFobUm+2erGxeUtRa7IMRNmxnK6mNwQhb9pBZSSWyXUa6zCP8Tgdi1IQUQwJ +ieCiaS0WZgDTPLddKgbncWTem66f3Xr05taTr9zSLiu2cLJwfPz0P//X/9mozEBAxmO8wJc0padp +Y0UbpBEdZIZpNFY273u5YSLOQDjFQnQqzhOoRmGGpVc4zgFgl4RqJBxU2V1YADchkZiVjqsEagP1 +5/3ld1/9IpkSGM4T1KrmDLOVzXL7sNrcPNi5+fNf/avp2jkQ/WByE2jRL29BaAkqkBdICClntf/4 +u3+tud1r15YWF6JLi+kI9CguArPIgr/S33z8/qem28FAFWgNyahlC+NSY220ftoa73Nywa+sNgfn +mjlwvZnrr4lqPWP3Va3jZVe6g0PdLhVqA80apBALSIFk3HhKB+fL8zVNH4LDpdhSJKHOL+IgulDS +M51lQa4rcvX89MV0dmo6nVx5ozO5Nd1+cnj+8YNnX60fPfar69u7d/76b/8xk1sGdQRQpugdrzCz +3HVNXzEyU5J2DbPVH91Q9VbwlCZp/qEiKLxYtipK7XCwnM0uhTCIsTRiQDNkvV+o7g9X7hk2zEt5 +bfWi2T4QpMry7Gx186YCLgkzaNYHB6SpjXhMBjUIH4sgDpq20YQCLA9wEVpiLKtnmPU4sFhU0O3J +8s6z+uDc8pZxOocRzmB07OX7FOMxXMnzVyuNvWxuTVOBH7MQUcmEwHPZVFJIBgttWQw1Y8F2CIO/ +OrkGXKlrdfhwr7i8ff3F9Vtvz259cnnv3eX9T9dmewILttTmuUKwtxMJ7mximFKwW4Pxs+640dzP +Ot1kjCVRgyHcVIyn8QxDWEiSj4ZJnqt53hYKlMfbwQVS83g6oSbioE/KIFxVteXnBhRtcXyOZh1F +q+VrG+v7jy7uv7m4/2795AXFB5C7vvtEsXoMZIpQpdkSL9YkqQz6fG3jDJzj3LVIMsphaSuVgG6K +6ZSEo1KnPri490Iwighp+7XdjDeGTx5s3qmMbohGW9MqTx+/Pb14AcqKJAE3Grn85ub2o4PD9/PF +TdXoDDurf/bnvx+t3r72XjwaY9KAJEQu568ORres7CqKmecXr7KFyfwSGolxKLAMHdSs0zK9fHmt +3d46OXmwffgQozOqBUM6cXJ9zW50hod3H3/+9M0vBA1If6/eP2WlBk5mKbaA4Nk0FqxrV+p71eYe +imuLSzjPl7Ju4BlJPJ9OO0shIRTmUExfDKeTaZ6iXSe3lm8cNQYXzeEFuOZaafbjz37/8MU3qbRm +Zft+dc0trVneFHAbJywU1Qy9M5neE6VWOMwFz6uDZ4PSwgJGkQXbXl5fPf/k3Y+i3AQlaToj1Rph +dBl0ZrV9enzrc8cf7ezefv3pz8YrF6m0GWyPxLyg8D6VY9lgvQ9DZJ5xQUgnU0GJ7KUQG0/qKJGz +vc1277xQnKyt37h++/W9D76998FPLx596uSnaTwjKZV2/3i8dhsCwLRa4HYZtkjRAVDHo1IyriRj +AsBUs7Jlmd2596KhJQxJy+lgvVhKp0EZ6qJYO7t8lUobf/RHiVCIBZ2smxPHW4P5mptDU2kZJ02C +NjnR191Oe/nG9vmr8dYzxZkpdtevbrbG5zSbd91pobLnV3aKtUPTm5BcNhIPCqKmEgqaUuNRDlBx +YRGBSCBIC6ecFGYkENlw2qbfZWSv0FjfOH7RHJ42+8fDlcvuCMxUA/QzERxgacjgvtk8y+VFuaTq +1cl4/+WHX7q50cJ8kmE8yxmqehsnvauqfXma80vVdUEtA4DE4iAggZg8zWxD9IIIbNUn5+f3puvX +Ccqsd4/2zt9ePvzpjTufbew/mG3fzZVnRX/029//3Rc/+5fB5WJUrj+5tX/9k1bnbqtzx87OEMyM +RMliYahqNZij+YWgyHMkqqcQj+bqxfLGh2+++eSrn4NpjSXlFJ4h2IKa6fXHp8PJ3c7kIS3VIerK +7V3AaorzWb5Cs0WMAOx1JmsPdXsQTYgk7YEfv1JxFsQwACBIVpZ1qo1VkFWplK5mus3B6Xj1/snN +V9uHT0FzGnrp7cdf/d0//J/j6UEsrohiC1BUlrsk5cO0JlOqItdYNhcBl40oytVYSVqnNbo8uvV5 +vbV3enT3L//q3x6ePN6/8cHJwy8n+y/HO88OLt+d3f744s6r1uC40939r//0v7/72V/SlJ3RW4Yx +AAQTuWLWGVl6D0Ps+XkSHCsIoaXFwC/PvRdbnEcDI0kUDXuqmf16Y9fItEW1oTtjxRrq7tTyN1KI +ppr1cmNjPLswnE5jcH1l78nujVe7F2/XTz6ujS7N3KyYX3v6+CeX9z4V1LqotBv9s0r7RLO3ZXUV +Rb1olAMblUhAvgjhq21sKMwa64PjKzW2is31znDn/N7rG/ffPP7wJwc3XjRHZ6LRo9g8CBVZaRBE +JpUSUMyWle5w+c5s40mxuisoINEVHHgHN8FYQTKygJbayM7uFStHWqYLM5tISSyfS6akRJIXpILp +DMr1zVZvF/603L4geK3+4Wh2OZyeFSpb1fZBrbOfcXoFf3DvwYcHZ/dJ2s6XNuq9/Xx1NZOdSFov +mTYgNShcf3D/41ZrG/grFlNRNI/jZZwoI1i2Wtt49fqnaxs3IhGaFytuaavYOp5uPfngk19++cPf +7N14R3PVcX/34eM3ilaCGKs1j1e2Ptw6/LQzeurkZhhhErj54v0vuv2TYA9zlAc3TVB5cOjFxkF3 +ehesymR0uLF5AXjOckVJbytmr97c3dh/2lu+VSjNADbr9TXT6oSD23upaFRghbphLTvuDEEy8big +Zzrt0Q1Fb4Ea56WSqFUJyrKsdquzo5u11Z0H919+15/dqrR2VLMJLRT4fNYbPnj25c/+7N/tHz8D +Y2XZM1FsIGkdTQuxMBleCgrah5YE11uFiXjvvcjSIh6NcMkYWAaXl9rQfhx37EwP6JjmCt2VW+eP +v3nw6k9XD16C9eiOTk8v37588/OtnXsffvLDzunTUndr9fAJKKZ8+8QrAsW8evHRj5sHTzSr7/rr +reFprX1kepskU/7DbQtLixhDezTtpIOdtALN5iStoRgtv7pRqK1d3v345aff5xuzxnBvsgXZfbPS +OekvP1zb+ajeOcVpm6Qt1ezySj3jTmx/Q3fW7fyubIwZpowG624iyxdYqZ4mPJKtBaVohUoyuNog +bzs9Mniyyl0dPF+drD/aOHi/MTgXlJam16brF5XmGit4hfrOzumHTz768eLRT4qtPSvXZwRLlnP7 +h49Np0Zxlmy2eKUZwKZU4plcq7Geyw1BN6aDqvjB5SwAmCjm5otr7e6+JAenEhgGFHtftzqG1WoP +D3ZPn1c6hyTjXRzd++77P/O8Fst645WHo9mjVvcs628lguczDFi8Vx/8ZDw5CQWXzAY1VE1nWm4c +D2YP2uNLUch/8ubrFx9+EoszkGu1zunW9Y9ffPqbhx//Kt+4juIuQ1t//ft/d3HxLJHW/3DDiOVu ++KUjQWyFQiSO6cvT82b/JBLlUDRDkMF+A8Xo5Ipbbn5NVSsff/LdV3/8576/jBO2ZnS9wnqjc3Ry +88MP3/1ytvVEVLo8X9WNYSq4PBq5di0K3YxFRUBXlmukUs78XApHtUppHexkJAT2QcIJH2gxmcqI +fBV0HYye6Q47o/PB9C6vdM1Mczy7vbx5Hyjj0eO3X//w29HaWbY8e/zBn7z95vfnD77dv/7m2x// +/d7p64wzbtV2bt37PFdejqfkNGqBWlOkPI4pyeA2IrPo9WcrNxSlnE7LBGWrZrvWP+nMbu2cvFw/ +emL7/aPzJyu792vDk+rg1C1vq/ZA0JtadljrHbvlNYx1GblMQO/cWal7QcrdJOpRfE22Bn51h5Wq +stWRrCErdWSty0tNXgzsbRrRIPU4IccIDgT8wcVnB5efzXbf701vVTtHMPX5wujs/ptcba1Q39y7 ++WltdNP0VwynB471+PpjijGTKbHSOLSyK5JUs50hQWRTKYXnc252KMnNuTlkKVib02W13OyeWO4Y +Re1kXMp5I4qC99IIIvRGh6/f/ezNZz8enD2v1jZtp4uiEk0aqlIFtxUO7gIWeaHQ7h2223vF4iyR +4BcW0uB6CCKoYcJyWVmpsLzHs3a3vea41XAYBW2/c/rixuMv1g8eFeu7rNDEMFeW8n/ys1/u7t1J +pI1IVAgKywTXQwRPYEDOMbTT7e1adufaewnwoRxbNjID3Rrr9nKwqu71f/LND59+/qOiAHuWNnY+ +HK0+qrUPAAy9/CpJ5mPBEQB5PLnkWD8UomjSl+WeKFQ5Jkfg7vw8mkpwq8tHv/ur/xQNU4sQdTER +FIVpTfz8dsGfyryzvnmqG1XgLF7qK/aMZfTO4GC0emt549Zw5axU37DdXn94fP3Ox0eXT5c3zirN +nXwFkGQMntfLDmZrN02rG2xlkWuSWBa4LIRWUBkA0+DvslRMJNhkggNlmPWXd45fPg== + + + evWL0zufzrbvHO5d/M9/+udPvvzByk+y5c325E6pedwcXBzeePvs45/tnX0wmp5/8d1vM/4sTWRz +1Z328u3+7OnNxz+7+ez7zZOPJpPz//Cf//m3/+ofMDoXT5lXd+SZJFc2sqvF6kF/cPj6zZdndz+a +7NxfP366vHOv3N1d3bu/c/T00YuvX3/9y2p7rz8+efXuV19+/5d3nn21svPEr2xKWktSOpo5SaGA +jQKkOUaAPyqrWs92R6Jcl/ReGnUVtU2QRiJFkYGoGxrOWNO7NJ0HejIzjY2dexm3U6oMB8OtWmvX +zm0KSo/nGzxXBuf1h1ukISRwPEMz+VRKC4XASkscWyQJF+ie5/O8kBfEgp5pZewhqLJIjEFQhQH7 +RoB5141MNZcfzzbv7h6/sJw+y2dxKjjTcbXjjkGDjVVZUazY3jJBuumUkozLgLTJhJKICxj4PsLu +jE93rz9b3riTK20xQiWRlC2j6ecmNO1BmNF0AeyebQ0EvohAfHL5P5zSwtLm4jy+MJdemE/BjzRp +sVSwgsZx/vy1RCohxqJscD3iEna1BCMm45yilFjOgUwp1rZLjUNVdmuN9fbgYLx22RpdZPMzXa+D +c6y2NxXDk9RMxq1rZqPcOKz3zsHrpYINro5p9HSjdXXGlgnOACIqy/jppAydDYcwMMIsm2U5T8s0 +87Wt3uhsa+/B9et3Pnz9+d7x3dHsxq0nXx9ffv7wxfcXdz/pDg8cr+Plhr3uzpP3P3ML4Be21vef +HV+8Wtl53Ogf5MpT02vXq9NP333/waffEoyXzW+a7qxQPbj56Lsbj75tdg+2V0///r/899dffZct +Ljd6B5Oty/WDu6++/Nlf/u0//vt//F9/9jd//+z5l3/zr//jn/zy9/n6Tr624xS26t3znaOPn3z0 +6+PLb0S1oynVtc27kERpNJNGdIb3wTza+e3Z9ku/vAmibmX1UNcbljP2yqumNwQxqWUG49nde8/+ +WDHKrtfI+gPZ7I1XH6zufuiVjkiqznB1O7dmOBPwbhmzAvEA3Iqk7UTSCNYUYpIgVtu9E0VroHgG +9MDW4Yej9duZ3EQHk5hpEpTKSVmSMTFc4gVH1kqK3lDNRsbtylotjUiKUb1+82W7twvaTzW6BG4B +fWCopWk9HDNjMRZAAEILJUxBKVv+WrN/S8uMRamqSgVVDqxlxuqmklokzAlCwXYHstoGfAMZiYLF +WMATcRl0DgkRmzYo0onHeNDVwc7ApMqzPvwYi3KQO+GokEJB1eQEpcpJRdcftgaHJO2X/Va5uqzo +pVxh7PqrljtzvZVKdbtU25DVrGF4VrbBCZ6dnbjFLcOdAA2JYt331orF1XiMQ1IyRWQwDDSJHFpC +r2oKoSTugO+jKEdWK5JWHy2f37zz5u7jT7rLh4pRzBX6O0ePy/VZsz0r11YktQJBmMn0LKvv5caQ +wrXWVnd0ZFhNQW1QrMcIuYxd97LtenPdL42DIpBdiLd1yILN3YeTldNyvr02Wvvqq2+2j244bnNz ++9aLT759+9Off/njn7/7/tdv//jH+y8/2Tu6ePfFT568/Gpr58H7r37YPH61ff3N9Yu32wdPwLRy +Qr6QG3z9w1/tnDxZCtPRGCfKFd0eVbqX4/XHklrW1eKf/PAb1+2CQMJoLwfGeXRxcvuL289+3Dx5 +rWrlJ49e/fDz303WLhixotljVunw6nBl4+m95z8frN2nGPf1669H05N4UgmuRE8aBFXgxOZ4Cjrk +qWX319cu9k9eTlbvdpdPVbtDMnlZb5nZQWf5TDKaCCZDv0SloGhVTsyCAeHEkp0brR88++zHfzPb +vmeabddfwYNDIkKwpJsKnneBZeiPThW1ruvlUmVFt8f9lYd2fpMTwToB/HY1vQ90lk5nOK7o5SfF +6ppqtCnGD67JiwAiYTDRNOMDxgYHiMLBZrZwsI0wuOEOxPzCAk6SXnD/1BKFEK6VW/bKm05hZmXH +hj1KpS3bKPGil0jxNGfLWrVY3am2T8stMIBd3SiXykPL66KYms0tdyd3moObvcntq6KUQf29eJTO +Zlo5GPCUEAohoSUEQAy8MM8CQZclvjIcn7BiTtMrWYjk8XUrv6xkGrY36oJklf10OtgIJCqdSv24 +0jqzsjOK8kgi43gjUa2HYzyGu6JYhmzySzPdbFO0l0rLsRgj8B6ogmQq2EnCMZaletVcs14Za1rB +yZSHg82VjcPhyma1MbW8jlMaldubvcnu1vGdZv9gY+P85Wc/bp+9gJG0rKbIexSpU5hQ9Ts3L1+2 +Bnugn11nWipsebkVIzMkGWB8JqNlbt16wLCeKPe84m53dHn99mcXD9/tnX/ol9cNJf+TL376z//P +/3dx/2NebVW6Z83lBxvnX73++q8v73/SG+16Xu1Pf/0Xtx68SaMGmLuMt1Ht3VzeePr4w19Vm7sl +f/TTn/761Ze/iiVVsCcIbita9/jG2+ef/ubZF7/1a3vDwf4Pv/m3vdExgugorutWtz+5e+PhTz7+ +6i829l6Csfrg1Z8023sLwe08eCwmkWQBoqLe2Ns9eq6rtVcfvvub/+MfVa3OK307vwPf7hb3Lx9/ +/+Ttn3fHd0nc/fTdzz/5yS8K5WkkxoUiNPyJIAZNFWRluBTctcrdv/3y44++AgCZm4vNXYu990fx +uTkcQX03t0cSzs7+3enqGdhSwwbca1BMnqBLCQTmrgImi2Vs120RhI7D34WClZtWWkfLa7eObn6U +La/SdKZe38oV14I7T1ETdGM0JgbbI3nP1EoEKqYTpMQb6SSVTHIUV6CFCtgZlqvQXCmNKpbVAgk3 +3Lh749EXB5dvlvdeFBoniZRI4qpldXAiePR35fRlNG3IUq3a3BPkOmREsbACTUJxDUY7mlDALQbl ++wjHVBvJYD+JWm3sgNw1tYbIFTDEYEkLwKdcXhYkN5kkeT4LgJPJtmfbt89uf7R7/DibG5VK41xh +mWGzipw3zaok+AxpSqwtcPAWMRyhwVuJfAVSnqEzJGGlU6oulyTO4xkXLDkkuCxVQTAzrCtIvijm +DbNe8vvLo73+cB8YARq/uv2ot3xerEyMTEXX846V96y8qZeDtfsoL4tlHRosFmjaxjEVRySgp3xx +RbXGyZRZqOyUmwdOdrK+fW///HlncsKybrs6vH3nRb2xwdL5UmWzUFl3ciM9U7ecJrhycLKa3mBY +P3x1OQVoxay3ni/umpmBJOYtLdfrzGZrJ8Epxfb1QvN6f+1xf3a/0tz2KxuCWORI5eT6/dObLzS9 +DlLQdsYsB+orb2jNRIxLRJms2fz6q1/88fe/Ai8T3K8aVRJojpXbldZJub7vZqq/+/2/+ea7P03E ++IV5NBFXFLVX696aXX+dSqnpBK+IMI8DhrYBNICSYPBB+y2vXYAQ4mH0ZP9g73a3t4OgBo7ZIGIF +qQKDQ2BiKk7GIyiBULqk4ShGoLQkF1rjS9vfMOwVQWlKgru1enJ568NCddWwO34ZzPI+xdYQRBUY +S1cKSEpAUxJDZTnal4VKNrsMvowg8zxTzKgNU6mOe7u7+49R0gZaoWgXRYwkwH6CUwW3Xl9NxMVI +iAquYI5wJGHDmEhSUZR8CAw/P9SMMklrXn7YHpwUKrt2dmU8vZMvrpOkNRkddrs7SDqoTIITYNXz +yVSOJBua2ocmpRKEYxRcuxMH35TW/7ACiKJOcBIfsxMJ2XKCDOX4iutNveyQ53LptAoyWBDyFGml +kpzABjsSWdqCoKXIDIKakSgHGcHRZiJKBKezEwKSFCTWFfmirLZotphOi9XGWrE+w3GwqK6RqctK +0dSrnl3TFR9Jcpqcr1RGBA5pxTK0CeFtmtDgKnQnkRBSSZllfQzNUKRNUy6MEomqhpyV+SwYChwz +ustnhtXl+QIvFCnSBb2kSCXLrHJUJpVgwkso5CZLO4sLSGgRS8YogZZUwSxmO+36FuTp4iIWDrE4 +XmDFJsMVaTrL84YIpqW7nPNai4t4cC4st768/nD75NX6wVOwGAyEE+NQpMqQasAOpAH9UvVKzh94 +/hAiP6PlbbMocDZMhMCCJy3RjM3QViJGM4RGoSKD84ascxSjiLrAW355KBk1knYJwnD04o3jO4+f +vLZsEGmFYnlrOL6fL+0zTJbEJDTJpuIMgag0mSEwlcQ0jnF5vqTpA1moUpjp6pWHF0/fffNLgrYQ +TKEoCwfgwi2OgpeZTDDxCIWAsEyAG9Ix3Loq8qCgqC6LRS834IUsy5jN9la9vVuobHqFNSe7IgMk +Epbn9jxvAP8ZZiFfWC1XrjPsgCTq6ZQeC2NIkjTVrKb480EZGQQCmGEqPNek6AKK2gTh5oszSa6C +UCHIHPB48EsqB8IYgDEoALKEYSmBBO8cIYOqCGGGogHiyizlMJQei2Cu2awUVijCIlGdxCyOASVg +YajUaM78Qi+RoAXOUdWCKHiykONog0BYNElJnFUtt5FEmkjjLAVc4/G8D1+XiPOhJSwWoUH6Lswn +o2GSxMx0QsRhvkiTQgA9IMy06ep5xqhiaVHgfZrKMbQLGQHzGA2hkaVUMkpxZCYSVKggwB4yhJNz +m1kbsrtC4878fAqocGEh0NJXx2CZRJzRFFeVHYbWYlEC3KIkVc1ML5sd5EvLZqaTiLNIGvgUX5iP +YCmKpmCCFFl0uu3VSmVi202aMlGEjcexdFLgmCpDuQxlVIuT/sp5KApYgUbD6Vg4zZGiwulZuxRU +IvJrilFIB1DvT3qbDVBBik8RSrkwcJ0mMBFJO5EIg6REDFEMMC9Gg6YMSJx0ksXSPIFpgGnxKE9h +lmfV++3VdnsmcIZrlwU+CxoV3kjhGoFo8/MIQBaOBF1bWkzEkyqG5yS5ncmM3ezUdrokLgP4bO/c +0jNgRvKg4nSjm8+vtFq7WS94cphKCoKQlSQPQj1YFwsuoGRI8P6EiqTZWARJxTCWUEgUmiolEiBj +PNPsqkoAFCiqXZmsIWCOKPVz/kFwyIW0U8FCG+AqGwml0LQINkcQilamJkv5q9IKyWSU2Ns8v3v3 +Fcc4iRiFJDgiJetSHjpFYmo6yUWWEJrUJAHQRksneRqXeVIWGZWjNRInU7EEg5HwI2SiIlcksRSs +U8dZNC3BHM1fiybCdCJKRSAM5hLh+XQ8whCoLrFZUy2BbqkWGvfvvgCRCWSHJCRAFSyt4mlFoBwI +v1iYyLlD31shUZMFjkgr0RA59148FoF5MeAbF+aiPJNRpHwqwafiMEQ02LdoCGMwXeULLGFjKUni +fF3tLYWQ+fnY3FwEuszSpmWC/DZzmdyDB0+zXjOe4JC0QtE2L5REuclyxUSMcDTv8e2Xv/qX/yWN +6+/90dLiQgJPC7qUs8xCzqsYsv3o/rOTi0cYoUTC2NWifLAuz7GWLFmGahc8UJibqlznOQ80Ho5K +8HuG4GROzahFEpcIlCHSLE8bvtcVBQdHYQSSuijkPIhJKYWyaYQERjCUqqmN0XQGmA== + + + KBTGFuajBK4rSlEUc0RgWi2CcBgyY6oFnjZxlM9kqtX2HkHBN6poOtifefWvJceqxxP00lIa3DSa +0gTGJ1AtEadIQirlK+Wsr/FaOkEk4iRJ6tncoNHZg4hKpyRoUX94mC9Mg1uhQxiEE4EpTMCAeUNt +sZQHgVT2B7XiEEcYgHRVyHCkxlG6QKlYmkonUPj8R48fs5QcWUzHQtjiXDw0n0rH+aDMo+BeLQRr +BOrgKQZLYrFwIrKUQJNYzjA7pVyvVnAMq91d1gw/GgEPlQoHU0xQqI4m5dBCav5aZP69SComqFJN +EUt4SpJZK+9Ui9m6ZdaSMZpAFBoHrlFjACxz0aX5RCyEInFG4fM0riUiGER4PAqRL7KkRxN+OqEs +LaSW5uOGUoKADC2mIA6BdgXWdY2aQNrpmBRZJLEkZBYXXkRiEQpLAXjKyRgh85LCs6bCtovu8vJA +lBUCDJJTbDcHeb8sSjqO4QyO58A0tsaFUm9hIRleQrCUaKt538zrvOCq4rBWODzczZdrKYSOxSkM +BQ7NqEqmkHNr5Vy9lD3dm33x2dvxeCsSQSLhVDiUkFjVAHmUMSxFpVDcM9Ra3tUliKgonkooLF7x +tW7NfXRz+/69o+2TWbsPH6ZZGRAbOgiYK1NMQ0syaiZrG5apZe2cxLkZrS6wHsieRBiTWbVZbfeG +K5lMoVYZiqJDkzJDKGiKCy0ic3Px4FkWE5SLgaFLx0lQv8POdHtr29IMEmESMZImTVAFOa8hKz7H +u+32qm3XMpmaohSSCRZHRIgZnlENKSPzDoUrQNmyWJEFzxB1k+fqvpXL2IasurquMJQCQcYTs2Hx +YHeiSoCKHInKREpgMI0lMkBkEB6AITwoTFTCkkkilcCTSUdRx5Xsbte/3Gh8cGfy/Nbq9z99eet8 +q+TYPKsTmAzcJ1EOBNi1PwotzidT4LJTUiqCswin0IKvm1nNsBWdhuRNEYakKALPAz7yksSoupBz +zTqGiKHFxPy10MJcDMIDyDEErjPEzc9hc3PpxQU0EWEh+JE4QaTJcr7GEiKL8Y7qk2nQ/JxA+6qY +T8bJxYVYIkpyoGHSNJ5IKEzaN4hBRdoaeQdbrUEv16ga0272yfX+26d7FyfjcdsdNXNFz7cMj6aU +xblwPJyk0oQjyr7MZphk1SSOp4VBJ+vaomMpWdfRZaGUVfoN43DZ+fb12bef33r3cvfzV0fdVikS +TkZCCIWBYPUtWc0qXE4mfYVYa1nHs8JqW685xKyh3dwoffvm+rdvT/7jnz/5f//Hz/7X//1Xf/mX +r8/26+WcYKgSz+dJwiexrMY7dd+ZtJ2NUWGtX8obUi2X1UQVSaJ4Csmq6qhdnc26J0e7337/fX88 +JUgqlSShAUsLgFeimRnz/z9J7/kkyXmde/4DV8RMm/Ims9J7bysrs7x33VXV1dXe97ge72cwmIEh +AMIKIOhA0IveSBSNSInmrkRR4hVFUiRXFGVWV1q5jdVqIzbu3dhve3IUUTExwFR3Zb7vOc/5PVmZ +57CV8NLcqTkexyuOM6jXmuU8mcsSWSyXwRRBXW7VHty5sTIZu4575sx2tVoicAZBaEUpCEIByI0D +XcqBEPDwqrmFTrkOhbDhSk2TuLRTv31htjEoLpfVk1nptacPP/DShc9+6Nbbr1x64cG53Vm3kndo +BMPSJJKkWdxWpapAKQJOGRzZ9YXVljFtmTvLzq2d/EuX6h97fuvLb5/89gcv/vVPfucXP/7KR185 +uX52Nuk1LFGhUBrPMkiG41lPYlw6i4GpbprKUmC2HWGjYx+ulLaXKyc7y88/efbBjc2XHx2889q1 +D7z84MHVK5N2p1rImzJHZLNAX0iKi0cICKd4hAJFnT8Vjy2mc0kcS2ZNlq472qRT8TXJ5ul+xe9W +yyWrULbLdI6fOx2HhEWSJMCWQWbzdGLootfXjNdu9J672nv57vgLH77x9U8/9dn3H3/u1cmvvvvc +P/z8k3/4tZc++b4bl/Yn9UIB7EM6nkbiUQFJ1KTcehHfKKcP2rl7O+bDi/U756p3z1afuTp4+fbw +g8/NPvzi9POvb/zVH731dz//1Lc+c/2FS6WmTWQTyWQc5WlNoBUGxTU8M3Fy10bc3XXpzeuVL7yx ++4n3TD/6/NLn31z/828/+w+/+NSff/PBT3/v7n//s/f+j//48R99/YV3Xtx98qTXCDw6B9kqeIpV +d9WlsngwNK6t2Vs1fKdNTcr0wcg9nvpnp97Dk86n3zz/61/+3k9/9rUvfe49b75w9uq5VUOmU/EE +kiKxnLK4mJ47tZCLx3wRrci5ho75QsIXU9OasjNw9sf21XX7o6+e++ib19564fxvf/zen3z/kx96 +78NBy93ZmG7vXDq88IJhtch00uWwooSPXPL6qv76rf5LV5s3VuW37nX+/Luv//j7b33mld0vvjr7 +5Q/e+Ne/+8o///qzf/LlG//00zf+9Ov3b+15eQ7BU2FPQhZTmBwpY6mikN6pUy+eD77zmWs//t6r +v/eZ2596afy1D2z84Ms3fv2nb/7pV+/+8AuX/unn7/2bHzz87Evtl67VLm9V657R8KFWFh2jorJC +Sc5NCthRi3/2yH/nmbX33mq9ebv2+5+7/fMfvv3Pf/+tX/35J3/6nXf/+9989P/7f//qr3/2uTfv +dL/50Qs/+f4rn3z9XNXR0jEMiizYWJHRiUyGhpKPxC065VDR7TrzYL/45GH16pp1d9d94/7oD377 +xS+8/9IX3n7ynd98WPMKGCqAAmsk3Ta4jRJ50mee39c/9+6l73z82rc/fvVHv/Ps3//J2//j3/7o +Vz/+2A+/fOOv/uuL//zL3/raJ+5e3KhWwUFyimf6Ck07LLZkk/t17PaUeXZHf//V4FsfOvjR1579 +3mdvfv2dM3/8xRt//8e/+e9/+el/+cVHf/69Z3/53Qc///1HH3y02fXCIggQkkmiZJbwFbNjansl +9q0LxsfvB595uv7tD2394hu3/s9ff/hvf/zeP/zi1Z9/6+4//NnLf/uDd//wc+d/9IWzP/3Gtf/6 +mQtPX6gOqwU0heNZlkOpo5XW2XHhqK8+fWB95fXpD7945Zsf2v7623u/+pO3fvrd9/zBb13+/ifO +/sfffu5//scP/uEv3v7Vdx79H3/9zne/cONkFWIhGV2MZFMYaLvLC5s1aeJkx2biwSr76gX3PRfc +991rfOHNze995sI33tn70def+re/+8ov//CNX//wvf/6N1/80288d2O/vTWb1htjAterbqGXV6cB +c9Ihn1xlP//C8Ce/e+cX33rqO588+62PnfnR7z74l19+/CffevTdT579b1+99b//7IM//9q9b7za +/vyzlRsrEqiKyorxxfT8ExEinijy6Y0AuTUWnj5w3rzd/PRLG3/2e+/+x7/40P/2o9f/+gev/vUP +X/vxV+/8+EuX//BjG7/1dP3JTW0loEsqGbYTFSyetn27Me0NjyaljSq3U8bvz9jPvLj0B5+88IMv +3fjDL17682/f//WPXvubP3vzJ7/34CdfOv8333/yn376yq++/9Q3PzD5xH3/jRutQcnEsrws1gTO +MyV9qWoPPHrFJ2/O9BfP6G9csj9yvwqr8Zf/y7t/+u37P/7anf/rH3/n//6X3//WR85++1O33nzu +jEhyJCoEilqS6KqETjzioEHdXVXfut76xgePv/epa3/y+Vv/9vNP/M9//5O//eHrP/zclc+9un9x +u14yOJGkaVy2tLKjlT3VL4h8Q8V269KdjfILF+q/eSX4/seO/9fvvPjrH378y+89/NKrk+9+ZO9H +X7n1tXfOvXyzc32nuVRv2ZBTcoUhbfBiAm3UnHI379UVarVAX191b627D3fdTz3q/+CzV3/27Re/ +95mb3/rI+S++dvj2vdEHr3WeP1M6M9aHFclRODTLKXzds3oqI7dco2GwbZ3abcovX2x+/f27f/y5 +i3/x7Qe/+N4Lv/6j3/zHn370z373/o+/fPmf/uy1f/3JWz/7yvlvvVl/41pppyXzWCabwl2jVfPH +lui6HDW06ZGR2/XSz2yKH7hTfedB+3fe3P23X338n375zq9+8J7//tP3/etff+ZH33j6a28fffq1 +7YOVwNUtgXXhdHq1JVsUSwpzdsmbBfhOEbm2xL50tvj2k+M3bg5ePFf97HOTn33z0Y+++vQ3P3j8 +5VfWPvLk5P5msNuEmoortMQSBpBMdB7hMU7BMj6TXslT55bca+u1yyulp/brv3m9885TKx99Zuud +Z7ZuTqxbY+PGxNlt5QNJ0RlBpkVgflUMZL5oKlVLLnSLpbajtQzhqOvdWqvcWXXfeXLwjQ9u/8U3 +rv/jn7/xp1++8zuvr//Oy+P3n7iv7hlvnq+eaSsuleFzhCaXHXvMUB7YQBplRDRbYJCBSZ5pizfH +7Ctn7fdfK33p5cmv//iV/+ffvvoPP3vfL7778lfff/3+bnutUTAkA80ZRE4gM1kuvK+LqhvCwOXX +yvJRz7yzXX5wUH3lcvu33zj83Q9f+egLG+8+6Wx0LInDkFQyGcsiWankj/vdw6I31nnLpJkl3765 +N314eWtWpu6uGe+9tfSVDz357isrTx02njvfujTzpjWjbApgcHjaDdsV5lyaKYGRBwdd9vsFPa/i +hMsyTUtrOXIvLx4O8ne2Go+Oh08etK+uVzebwUYlgG0sG5JIkxhKZzJcKiVydInBdTSJYMk0j6Au +y61Wy+cmjTubheePC194Zfa937r41ffu/uAL937w2Tvf+fCZb79v/6uvbH364eDBtuVLKJh2hTfC +1sdUgSHdDBgihO3kg3HRq/CZaT53ZaTdW7ef2XO//faZf/nLT//jLz/x377+9Hc+eeuDjzYenm/t +jzzwxrpadt1llvE41iFyosZbo2q3qvItkxnkxZbG9i1pverOisZ2ib+3WXzhZOX2Rn3i8l1DKcuq +yYgsxqeTQizCLswBAZKGFEg4LSCIiuEVw2j7Xs/3B55b1/iKxDY0sefKBTYHLFgUlWF9pPAeuBIC +SB5TqpUxTdrZFMA2TWQZndXahcb+6tHu0mzoqAcN45mDxoWu8uR27fqsfLalnWvrezVjp2r3DBEB +LIggGKILXBPPgQ3MgtOML6SodLiwNVUaukpTwdZL/FFTerDpfuTR6iee23792vj6tF3meRljHb3m +V7aWZnd5xjeUokBrPAkLYliyofOKLevDer0T2M283MxLvsY5qmipOs8pBKWAVY9G8VxOV9QKy3uJ +FIsiiszlbcWtFmrNUptFkEDkBr7bKYKmORojqYwIhiKXYcFJIRk+EadjMRongmJlr1zfC28h06oC +a3G4aCs+nYMyzVqCs9rb2hztTjqzwMgbnGRJBTe0MPT8QjyZYnNEwAk9RemaWoenrehCIr6YBF9v +yV5e8z3NqTvmsGLvLfl39uonE/fWVvXu3vB4UF6rmNOS23UdLJ2bn49l0uGz7dEYMQ== + + + N58Gv8mwtUp5u9vca5ZGGst5Etlz+KZKNhTs4qj81lMn73v39XtnNvd77bKmKDRF4zQveDjuYriT +TMumO+mPb/QG12rBmsbZ+2t7T919lsMl2C+R1ApauVFod8u9qlPVGB1LMHhGi4MtnUMhqBA0n05b +6ZSOY3lFLKEJjMpArafiUTy8/JVm0axE5AyOyvO0R2NSJp4lMiyaEtCMKIbfWNkcHWjhwywrmYwK +tjed5GjM4inHMTu6OoDEYXOCzqrLtQ6RzPpKoeK2XcnlUY7DVJbQk2Gn8QyOuSxdSsTYd/2XyKl3 +RcBv0pjmqnlPD1iMY1DKYOSCrIfP4pI5hyUcjvNEKy+W0lEyETaEGTWHlz1/1XZWRtOL+aBLkDLD +5k2rX28dleo7LOdQpGIqhZXxVjyFLyxm40lBVAeWt2Y6q2LYWausSNXp7KJq9+IZnaDDhzJIuphF +TBKzOdJMJ4iF+VQ6IdBEQZY6LFsDmcphDoKYslgBLEkkpUQqHHVEUr5pdd38wDSagT+Qwls+wi/a +CMKFfxLltqJ2NKNj55ctt6/Igao1cCrI5qwcZiOoTVA+QXiZjELgBse5ul5TlJKut4NgxSsMbbPJ +EZLMKRZsrFyKxbKZFIljlqaN3NIRwVYSSXZhAZ2bz0JgEFRNM0fhA4kJJh5nSNLj6QKFchRCmYLZ +rIIuWRiukVReeNwrD8PDhufws1HIFNxS1VateSTInUzWzWa1HGZ6halfXItH2UwKltdT1IZuDXN4 +IZ0xUNSWpa4ktVNJORblGabRaJ+z3KmqL+FUMRqDyBE03tflADwaL7Xy5a1ia78dTqRdfzxtXGWZ +/NLoghh2L7ccdxqUdiv140LlIJYy5hbp+UUym7USMe6Jd0Uji7iqLxdb5yqtM5Y7g+idP40gaSUZ +l554IrO4SFBM2bBX/dKx5cwyiJNI6YuR8GspgfUgmBfCq2SxxXkknWApwjbVliYG8QiSjmN0TqFx +nYLtzijhI0sZDSUK2Vz+id+IOcVtWqyKcvHs8d3R2gnBBZzSoLiyrDc1s+u4o9Ha1QyuZnMqJ1bs +YETyFZTwc2RRMceD5at3nv5wY3C4EGPTKOjEtlc5L5szmqujOTOVEUnKlZQ2xBtGeDhVVowVy9sA +RdT0nizX01kDyTk5wmGFpuFOCuU11eyTdJD3Jo32oaw0DLPHSQ3ZGlV6F4PWWa+yY3kTSalPNu7J +Wh/FDNVscFLdyE8ErUdwdYqv2950eXrt8MIzJBtE4kw6q3FiM7zBjy0zYvgIj2t1x5MT3V7S7AGv +DQm2RfN9WZulsyA7hSwa3hOYTLO5nKqqTUWfMmwrk5KyaUlTO+LjJxoUY1huHVbaZ1lpwEr9HBkg +mMNLDYar5HKmJNayqJVK6SRT5OQWyTVjaXNhkWVYP4uIsVjYSBYjCqLc44SmILZIuszyDVHumM4k +kVTQnIeRFYptYmSJFVokU16MUJFFyjCGotxIZYQMojJSk5batNDSnbGshbdl4mSeYKrxtJFCHYyp +5atHWn7DLe87wd78AhOLCbzQkNUmkrMxHHI/yCI+iDNJlRDEjkZZmqu63szNr+awfDh7NGNycl/S +xpbZw1AVwvLUqUwsQqUTXDaj4ISfCZ//tREEIspNREiQNYZy7fyK6a1p7qrirFJcY36O5NUlXukG +pdmNW6/2xkcIaRFcEWd8N1h1ixthxzBrSQhvtlnzSisZXItlxBRic1K/N77dmz1ZH15m5DqKm6La +M/IbhrdFCV2MqcL62/lpUNk2vRWQlwxiqubYr544waGojSi2ghE+HICsL2Gkg6C6qHYgKiqt42bv +Qq19xi9vl8qb5y4/L5k9Vu3Ul6+uHT23e/Li5pnnGkuX+is3dX1QKa4cnDzKEjbBBhBaRmG73L7Q +n97pTm6X28cE4wtKQzWHgtyj+TrEp2SPZWOwvn7j3NVXFaO3EKMymFOo7DeHNyutG6y4jBJlBC9g +dPD4XjgVzanRcAqzHvb+JQs0W0Nx3/FmXmmT5PIYnYdN5LWx6oYTlu1gA2IsmzVWppdtdwznG0sK +IImM2GGloWLNeKWN4SaKyJbZNexlkGI0BwLoadZKobxfrB2WqvuJpKpoS6oxldQRfFYWLySy9kJM +RLCCV9xh+HrY354q8EpHsSeyNeWVXhoxILCN/CoOVSPshNYn+YYdbIv6suGt8/ooixVUa8Wv7MVT +EJY6hBbNtGR1ZOVX4YxyWCGHeYazAoUYIjAa4xDUUI1hsXbASYOwZ0uMhaNKZx1QtrlT8VOnkqcX +6AxWVI2xlZ8JcjcZF9IpWZZbAqQw7sErbJ5JBro5FtVRs3Oh0T22vDHFB4LacooznPNFtSkbSxCE +sjEMKhu98QUjv5RCNdkakGwVp0qMWM+Q5RzTw+jmf97Dn8nZOdJXnRU72OpP7+5ffHO8/ShHl3A8 +X/On+/t3sqSXRPMZ1CeZtu6sV3qXKsPLqjMMB6vVNnito9pDSe9Jel+xR0F9v1DZYOWqE4wv3n3j +8Prz/dnlcuesUdiCmIQTWRqeOTx5BlZM1jvNwaX26M5w48nW+KqaX8XYulda3z5+ttE7m85YQWl7 +/9yza3v3xxv3zlx91fQ3QMQgfiSty8s1jHIorrJ58Pz63nv6s2eC1glJVQi6oJpN2R4sxIRkSgXt +Mqwty9stVI4qrSOcNlWr69ePnOI+6EN/9c7q3qNK+4zlrQNoafYIJVxZbyvW2CrMoC4o9noKDR92 +c/OTzZ27LFdKZ2GX85a7Uu3BCqxL9hot9FIZq9U+U/BnsZSaIytZtEDQNdvfL9TPK/ZGFiuWK+vX +br6YDTv7cZG4DMIlgoR2zh9ef78o9+8/+fqXf/f7zc7+YkxKZm3ZmvS27q+df89w8ynL30wjVqW5 +B6kRT6gLizTOlFESdHVQ717JFw+SCR3JGrLSgpyKxUnQroWYFM8YAoRQcFAf3njiNBqJ4BhuZXNu +FslDTGJEMZ3NI3jRKmwVG8dQoBMpORvySZFkqn7tDEGVKXBYQgPERHNmvdHtteN381rdK65Uu4ft +4dne+HypsW24Q1hMxer1pldh18KxuWrPDXZbw5ut5ZuOvwWnmUR1nPVBpqDCslJbMiGzNhhxaObX +R2u3h6sX8fDe45npTVV7wisDLb9mlzY1u7+zd+v8tRetwpgIu8pXgYQHqzdmZ1+wy7t5f7S1denD +H//twexslspz6lJjcHVp7cF052FzeIZkvFiSZ4QqzVcxJk/LtSxVkMyl6c6jvfOvdkbXJHMZSudg +5aag9QmuqjprncnNfGVftaagV155fTGGpVGmUBkVG1Pbn6BUheS6ujUr1ffPXnzu/JXnF2NsMq2I +0mA8fWr73Gtu9SIrD3mh/vJvfr7VPcqiDqji1tHTL7/vcy9/8Av7V1/WC+tAC6a1/M5HvuoUViJx +KUdUjPxOpXt9vPXM8aU3uqMbnFCZrl+ut7ZiKS6Lu5w68huXd86+Ptm8t7p1Vwkb5TXq3bPhJqKO +ao11b10yV1hpqdm7srZzDyMCQGWQaNWeKvZyeFMr2wRmO3Py6OFL74ham6DLXnHXK4EBnnHKgOFb +QCOC3O+v3CiU9xYiYiptWYXVQm2n0jnTHl0CXUrGwKVvrG7dAQBeiDBQ6y3/SLGnmjujxR7Jdhaj +YimYPP30W7bde9dvRKMRkmRKbnAw2nx0+f6HWoMLqbT+1DNve8FqBrUyQPfqJAfghAdwLvnS0WDl +4eU7Hz2++rpp9a6cPLU8PQvEZTpDr7jeXT43nF5ZWrte6h7IWrPV3e+ML1NcVTQ6ktWnhA4UVskc +28FmY3DCSnWgNUlfqnWv9VYfLe88ak5viEbX98ZnL70naKxDGNj+eqVzbuf4mdv333v7mXem23cL +werK9GS8esl0liutw6X125XOhfbwwu7x05fuvl5uz0aTc1u7D63CGid3aLlJckUgMV4eOsGuqA0M +qzvdvqrYfZQs2IV1KAqquybZ0+WNJ7fPvwQx6fgbfvN45/zTh9dfa0xugU9KYx6CuWZ+qbl8No0J +er7LKj1Rn1Q750qtY82dwFlEYgzNljVrSbHaor0s2VtmsOdVDoLqDk6F06wa7V3D7YtqxavMBps3 +y92DSvug3j1Xax3ilAfy6JV3vTLs8jRf3QaQNvx9y9tsDi46wSyNqL3lc6ONO2Zh3fHXZXOgOcus +2CqWtyCqBbnB8tWdw3uPXvnkyb03146f7k5uOoWpIJSuXHn2hVc/m0YdnA4KpfXRxt3ljbvD9ZuD +9TsAaQ8fvbWzc5Mg8ixf6q/d3Dh+Ybb37GD1ycnOC4I6isYVTmigmJMvbeYru3ZpS7SWAH7K7bPl +5snCopDD/GJtnxO7i1E8EqMWIiyGl2GdwQhY5jidVk7PZQBfRaXHhlHXZPh2KmuDlJ2//Fqpsgm8 +ilM+RAIUR5qtQ5kG4sqXtuu9s5DLklTd27xUa68RlGOY/SZI7vkXji+9NJhec0tTRW+szE5Gm7dT +AHVMXs8v17sXl2cPG0tXa/2TYnNfM/qNzr7pLtv+rNI7KfbOaYVVTuk0Wme3zrzoVtYIttAbX6m1 +j1Y3r12/89LOuae98pqud7Y3r8+2rklqs9bcuXn/zat333dw8aXt8y90JldMu3r39vM3br+CUSDC +IF9dzRlDDJTbJ6a/y4rdanXj4Xve9msznPYrzSO7uOtWj7urt688+NDOuef9YOvStZfXjx4IZqfQ +PND9Pd6Y2sWDcvtyb+WObC6rWu3hcx8ATcjieZwu0WKXkfuCPuDERrN9tr90cvb8nfW9W4w0EPUR +CHKW8DEmsAqTtYOHoWxyhXJjqz48W2rtd0aX/PoBRtUIplLrnys2D1DCE/VOqXOmsXS9sXxreePZ +5tJ1Mz+TlNb9R29evfOKbPQArhi+CQahO7pSrB+4/goQLC9Wtvfv7R7dK1Znlj+GaC8U15rd3as3 +Xzk+9zT4BcNanm3f2bnwvNc4kJwVyV4BfL115+Vmcw1FVFVvd0YXmoMzfmkN0k0wVpKIF42rqtbF +CHeydfvC/Q9sXHy5snS5Njyp9C6I+iwa14FjV9eui1IrlwPz7mQRlwbmMVYEqY+i3sICiaCWrAxA +lBYifDrjivJIVMZO4cArH4AvS6RlSCicLIJr4Pha2EA+q8IKUHxNdyZ+ZSfMDi0kT1muKlqvUF6H +ZFTNAeCxpHRKjSPNmy5A8SUdCK3+5Hp/clvLr1BCNYnoolBdHl/Wza4glkHo1o+fgfXfv/DS3oXX +lrbuy84Qp73x+g2GB6TxwpTX+7q1VK1v11r7kt6mmbznDYJSv9ndKDY27WAmAIbp1Wp93SksQxER +pNbjuRVujnF0b5Iv7/mhjGwXqisYaRlm6+7DD56//Wa+tu/X9sKHpt2hprX29m7tHN4HpQXOby3f +LbZO6qO7oCEMsGhGLQeTa7debPb35hZxkq2BvFQHl7zqHqR2sbS2NDj8+Ee+8Mb7Pg== + + + nc55CBGw4sApHqwdvXDy5McmBy9Iav/KlUef+vw32/1D8Gi8PuM0QOi1wezJ/evvg13L4U4ebFGw +yggQb2WSq1JsVVL6pcfqdO7yo1JtfXPrhutNRa0HXgMlgiRiZsBvqv3O4LJhLxnOslmYckprsnp9 +Y+9BUN2nuXBwUqO1F5RWWdg1f6cM7No/8RvHijmCLQabUKrvUkzlselTQAxVd6vYvhI0z7Fik2KC +weTMzvn7stVdhDdkdVbq1HqX4EeC0oZpDsL+YLRZqmwQZCkeVxYiAtTERNIkyHK1fr7TvyWrg0Zr +t9Y4xHJuJq0B6kcTKkSaoo8L5UOCrKj2smz2IO8gBVixDoguqAPFXsHZOkIUSNZX9FYG1SWtVW4f ++NXdfLDdXb7dWbnLGf0MZhRqm1Zxls6ZFFcDmyaAm+ueM+0VeJugtHHC7i6d704uFpu7hjcVzB7O +F0mhVqzvVTtnQBzAoStGX9UH5epGvb2TL60msyovBF5xTHKWJPm61bfy00YfrOUmOCNGbCA5VzUn +kjFMo5Ji1oLmdn/l8vrBM5PtBylEQcJb8Zvj9Su0VAfrFDYGl3rd0YXB9Hx/ciKIdZ6vayb4r0Ik +zkAW+JWtw/PvBsZw/TUsbE7IRBMc+GiGL8aTDOiGXRg1muuDwe7JxacqtVUE80x30/Z2TXcmm0tg +GUDf3MLabPPm7tGTGFVAiWK+crYxvu83L5jequVv0GLY8P/g+GG7twdmGcF9mm82exf3zr1nZeNW +dwilc6vX3/vIR740nV1HqVqhcVwdXq70LzRHl2HBCSrYWD353d//0XOvfRxgFbynYq361TPN4dVy +68j2VkxrcOH809fuvMlKTRBSgm8I6tDKr0n6mOI6OFkOgsnq1lVGrGF0PUfVUlknmdJFudHsHWwc +3CXovCDUVK2X99dm2/fWt24yfCOR0qIx3tD7W9v3OL4+P09Ho6IoD4Yrt6vNc5I2woial5986MOf +vXb9ubk5FHxBOlem2G6xtF8u71nWWOCKcPqsVMPIPIbbhjNkhaagjwi+DZhdqp/zy0eFyg6sOZCn +W1yVw4b8PZKrEWyNU3ql+sFs/5FZWIkmWDgeUeuzcrPU2oOzgGpL0H7Y6q1zLGotkCnHXwtaR63R +9cnOM+dvvtFfvYYzgajWw3BKK7mcC86CFdoEUwfshBDFaCfv9cBnpRADKBQWJI1a8BFWYVOxVxmp +yUuVMxeeUs0OK1QgT8EUQITzQrXePNg5/xwajtgrqXqfFxoAb8X6Rr48Q3HncWPnLka6qbQkKA3P +X14aHTreUiTKL0SFZMYk2Kqdn1KUw7GWYXeqne21nZvT3Tul1jaCmUApujV+3B2Cg7wAVJ5u3t89 +/6qa304jfjQmFworXmkti1sQouDlUxmbYtumt2WXdiFrcpg1Wr0CiIiFV4ODHO6BAtebR93h1Vrr +Yjbno3ixUD0A6Hp8VcFCMQvJhl3gTq6+uDy7RLOeYS83eucGK1e9ynaOKgIrAo8tj04azd0cbqtW +3y5uQyau7j4stc6l0UIioeTd5dHqRYotMmxDNpZ1d42TBoXi5mB81S9tEIS7u319MjriWA9BNZwu +WIXpdPfe+sEjkq4iqJPOGDRZoohiMqkiiJVMw3vCiVem3SsVlxnaj8clzZqUGidZxE7G+ViEQjOq +wHic1GXFDsHUQKK90qpujartC1I4yGalv3IH7JiRX00jOoLovFCBHTHzE1Ff0uxZB5hh/d5wdlMy +B9E4K0hNgiliTFG0hwRXzkKdFerF6latd5YVK6rR7o4u5StbdnHNKc+C1iYUMggtSe+Ci0lldF7s +gkVVwyc1+hhVBuCBaO/2D8GcopRPiy0ECwAIVQOM6ghOjRGbcISTrbtZzBHE6mB8sd49D5hh2JOg +vF3rHoNDl5SGqnVA2DG8IBtLqgtKWM2RLsnmSSbvuktOfphMM4kUHUtyixEWxUvguZzSNsuVBdpe +nxytb15BCQtSj1XalNgU1a6qLwlSO5WWVa0eVFat/NALxpozQslaIgWu3Gu2z9j+SiLNY7hBEH4q +bbJcC5aLCAcvKjxfPnfxGZz05uexdFrLEQXdWp5uPJhsPNScrblFPp7SYDviSfFxCxoVJ/ICXzX0 +oV/aVq1lWakXK1OW93DKhDQhmKpqLHvBuulOwU6iOaNa36x3j2E3ZWvMaUvxtIXhRVkewNswzJWE +2mDlYnflCkFXgYVIugK2LptW93euj5f3Bd5TtKpfmjR6e+PN60BoiZS+sMjEEwpH1wS2NneajMUk +TmqDlnZHl01njCBmNMrjhB9UdkxncnoOXVwIOwTCARvGwHTX6r3rTumcXdzjpApGGLxU5IQypKSg +9xkR1KOewUtwvrCk2awcVDaLtSO/dAh4AxUQpYJ0Lg+OlaK9HG5BdWsvX+2t3DTz67K2ZBdWBbUl +KtVO77A/voTR+Rzl5ug8uMWzV1+6/uD9K3tPgVvPogaYUNC0HBUkUmo2F4B2Od7auYvvHs9OHH8y +2bhOc/U0YkHAAIfwcs/Mw2FfGm48JJmqwAftzpbrLdEcwBtEtcNJHd2cmvaE4cqLUZqBYq30FHB5 +9giqfCKrYkS+0TyAUrKwkF1YSMeTHBhwlChhbA2lirCtNOn6+ZGmt2JJQdKXNWcNzEK+vJsjC4mk +AqHV6+0WqxMkJ0PRTCE2QdfzAUDdBmxrLClF45zjLrFcZTHCJdMGRtUFZVypn+v0r1Qah1A+SLLQ +7R/Z+aWwE3hGTWdNim8q5pQWOxRfT6X4yfhCs7WL5CwwXCjmQQzE4qIgNvLeJB42YMSIsBdQhYJT +ZopZLB9LhYN+/OKaX1zPIuZ4/eb5O+8tdY5hoRiuAVEajdI0aTlOF2I+k9EppiYqS15xW5Sb4TNx +GZHn/bXNS+XyMsfaolrLYgVO6nnFLVHqUWQ5EvYP4cqV9c7gCNQ4mZSjUW5+nsKxwC1s2Pk1FLVT +SQFymeOreM5NxEVIbcXocCGZ5KGs02wVyB/NublcXoFMtyeqHRIpLQ5JoK+cCRKEkwXANooqcUJH +d8HAntOcaRbXE2kGp8CztCS5Gk6OUwfgEN3iFpjBweptTuknM4ogVUHKmv0zO8cP9s8/DBrbjNzs +jM5Pdu/Y5c1IkmfYul86krWh4Uxls68Y7bw3Xl69jmJuIila3mq5c6UxuKyYE1bqYVQFxV0mnNNU +wTCVwB1ZW/aKu5P1u/3RVbAGkNrROM/yLTBfrNjoji8NZvehPKnmCMQthwfJlIpidjZnpDOqU9jo +TG60J1d609tB6yRH18HaQK0cTq7ahRlIhGiMOLmvmiuPZ5pA4jvl0vjGnZfg79GkQrINRmiDD8oH +u4XyWVkfAa7gRFE3JrzY46We4azBGyJxbm4uHNrV6h5xUhWFZEEdDPMkuU2xlQwESVJGUW22cbHS +WMugmmYtVdrn8sUtzVhhuG40Ls3N5RYjpCTWFhYwmvH9yuZgevP285/dOPNuy1sB3cCyYm9w5HgA +81C/wmYjcHZZxOCBZIhCNMaEDXnCfuNmNCbNzROxhAj/StMFWQoYSpHlgihXoPAlU2FP71OnMk88 +kYzHeJoM52GlM3wiSZN0IZkyMmkXzIisgnMsRBYZhnIZ2onH8Mg8Hl1kGQ5qaPi8Ko57sjqy89uc +PMxiXgaxObFNshUE90CyJHXJL+0XG2e1/CSZ1ecXKASxcRL8coniw04++dKGpPco1sukyWyKIAhN +VhvgK1vhdzTPLG3cRakK1E2S0gytZBig5MBmTTDdg8n1C3fe6q5fZ40BwIOqdyWlmsMMXu52lq5c +u/P25VsfHqw+ChuFZVXbWVLMZZIpQ+yJ6jKvjGvtS25hGyMK2Yyg6yBWQ0GuwytHBJGYlMzogj5s +Da84/gYv11uDo3xpDcHzoGwYWdKsaaV9sVA9hIXStOrumaeHazdxrswoXdGeMspA0PrLs2uNziHN +Bq47bC2dl/SRbm9IxpSV2qrRqzd3RyuXmPDJvnJQ2S3V9wvlDVgNnK4ACUeiLE2VNaWTSrHg13Kg +imTZ9tZZrq1qy4LUTaZNz1+XlW4iIaG5PMU19fyGXz+uts/TXBm0FA5sMLkkAnmGnQ+b8ZQNZ5TJ +6gThcawfWcRkqVrwl3Wz7QVrYH7DgRRxWpUqpt4FmMxmTZBuUe6xXD2HgQVwoO5HIpSm9zi+FYnw +kFyAHzQXzh3DCD+RYGJRxLbbfnGWTOv/Jez1x6RSoHh8NmOlIdLiwmIEr9bXVtauQrk/dRqHNwBr +UWSFxP10UoJffvp0JpWUM2mToIOFhdzjr01VKL4k26aFLiA6JXRlcwq+L56WeKnterP+8Opw9YFR +3EiiViylk3Q9nQ2bu1KM1+ycObz8en/1gagP4gmCwkSaMhgWYrKoWgMrWFdcqIzLnNhgWJumFJKQ +Gc6T9Y6sd4PKFhhGPViT8lPFnuj2kGJAMw0wy351fffwqZ3j58xgP5N1aKrA8WUUM4GB3cKmbq2q +5syrHEnaJIOA/5V1NZznFYvjCKryYiebdSm6Yvlrlhf2fOaFYqOzTXNF8MKQNZI6bA6uVHqXZWsF +9l1RKrX2nmr1UogmW5PB7Nbm8XMgX53RVUFugcdpNcDDbqeyFi8t1buXd4+fPnflpdn+U4XqDoro +hfxg9+BerbGdQdRwLF1KwYhAM4Y8W6OJfCJOOk6/v3yRlzsUC3IB62axfIeg6nAWsKcALc3mUXtw +Ihsj8HcEXYmHEygEjqu2e0c4BStZh3iTzBWcCYUaID/slh8hOSYvcHmWdcvVTc0e4VQAGsjxUAG1 ++QUinTER1I6BeOKeJHVptok/7kaoad0c5sfiEM/wq0yIojTiwIdSbInlA89fzRfWYUl/44l0PKHC +yi9G+FhcTaNuJgeuoQ5GybKXoapmUjqG+dmMDX/GwnEeTFgFcq5mLCGIE8sYT8yh0SgFQcLyFZDx +Uu3o+OLrx5c/sLLzgultJFIyzZUUQCa5KWjLvLEiW2ul5pX+5Klw3hCq6GZDszpucYOSlyJZbzGm +2vqo2z7rl9ZRTKMYh+arijFahipT3Ull+VgSh7qpmADk4YgiCGlJqjb7R73ZDdEe42w1m8vDaQIv +5QjTtju2N7aLO7DmUBOTKdg1gWFDwaHYeiar0WzFDfbzpTOCskIxxWgMn5tPITldkPrxRNjtlmGr +sMXhvBJ7YJpdgiogqAlBDrtD83VBXfLKh9X2RUmfhVKTFkDtd/efgjDj5CpGF9M5P4v5NFcLKoD3 +ATjfStjB70pv+ajZPRD1XhpzgSUsa6la2dD0djRGA6oBuWFEheYbAEhz8+RihDaNbquzl0XUsKdB +Vhfk7mj11mTtAQBPNCbQdHBw5ikQQJBTkqkxXNvKr9mFNTW8QuXGYqxhD/3KOkq6cxE6mbEwqgYE +KIg9ErdZ0taV6mzzqu6Mkll7bpHD6Wom5yN4yfG3QyhaxE2tXavuP26PI54+nZufxw== + + + kZxH0mUk5ywu0pBZtrdSbh5XWudZoUGQJQg2KPEgszTbSSQNlqnp3maheaRYo/A+oowejwkQSDxd +L/rTaBQPv7Y+lSPxMkkGWTB9qA4kBoUjFd7cYoHmc0KpVNvuDM90ls/2xiduaQbVn6RK0n8+iS+U +a+2z0+1nB9N7tf4VIBbghLChh+jnSFvWl60CgP2m7hw129d6g6uWu5LKivAGUQXz6OGhNavkiLxq +9Df3nj2+/BbUlFg4q1HkxSIJXlXuaN46zjbKzZP28k1G6IBV73a3PX+UydkpsL0ZC7w5wzQb7Yu1 +7lWKbQIJZBGFF1ogXKFHy+hZ1Abo9cvbK9tPITkfxzxeaADqk2wNPBTwA83WeCFsABhL0JBcYDd6 +yyfbZ5+j+M5ClIsleJotWPYSxMDj+zEGELTbZ15e33+WDWfr0ECSteZ2rbkF6OsW1jVnwy2fAdok +mQYk7MIiEc5PUbvRKLO4SGVRN0dWVGvdr5z8541GsRiVzUqiWAJiQXNqDncA4HmuzfNdSIHwThXU +5sEO55wc5kJ+QYTEUyZNe3l/WZCrAFcCVykU1ovVAyjxaM5DsiqR02WppCgBhskCX4QID0prxeqe +oAwwqjo3T8djFInpFOGAgKA5myCLqjbUzHEO86A+njqF8Fyp3tikaXdhkYQaF09ZjDLON641lq/o +Zj+dZHy31xkcg1v8jXdlFyJcNKljdEs0Nmx3O5UA9ssqcn06vTF3OveuJ1KLixzJNE1vDUEtyGKM +cCgmUPS2brTAgYqyj4ejMRQMs2177Je3FKNHMQVF7zj+iBFKcO6wkhgeprOgdgjWF5Wu4axK+opk +zIA2gRwgHiDLZGNoF7ZAgoCW7cJUkMNhtV5pjdf60bQWTYgE6dv5saS0vcJGvX+VkaEWtxAyiKdB +gW2Sr+FMOZqAotyXtBWgApwow+KA7QKUgtiGiAW6iMeZDKpnEEvVJoK0JCoDnK4lkhpFlxDMiyZV +nGlAoVfMVXBwEGPhlJkoBiHEckUQXoL2abHPygPJmDil7VhKmgtnIIpgalAcnH4gKH0IdUFqNrtn +/PKOpHUJ3AY7BgAPviyRNhdjQjpjgDzK2gr4/cVFIh6j40khnbUYvquaa9G4msroKOYQ4fWEYiJO +ZdI82CKgRF7qgCECuAVJQbECOA6wD8ClOFVV9Em1dRnWH9jj8RgvfnV8Ui5OcqiaSkogj1jOxB+/ +4tEcjQnL3fUPffC3ZKkYT4jxhJzM2LwMIeSjSNiGIpmkDKsvCNVEQoSjjcUAzCSAKJoOh2In4jRY +PJKqsWKPlQY5oh6J0GH/tDgt8j7LlZ44jUZjouHMFGfVK+/KxnQxqrzrCRSYjWPDKySJhOC4I82c +guqm0qHtgmyiGU8Qa05+woClJaF06v/ZOQHHLFlpG9bILUxBbUS5LqplFNfj4fg8jqYr4fgYuUlz +BSAuPhzR25KMUQ4Lwj48UtfMz5Y37q3sPGMH27D1nFiBTUQg5DA7g+azeInhO6YzdYNVReta9kg1 +xynUwpkqAlIsdC1/X3HWoWYBmdBsnRXCm/rCeyCTGlibLFJQwlu/yvNz2VgE5wUgZ4VmWihWjsbh +CA2MKEJAZnIB/AivLNNCn5OXElnz1AJxehGPJ3mWLedQncB0yE3JGGvOKqcuoVQplhJTWQ0DVOZr +UL8ggHVr6pWP8v726sYDL9gA3pO4ANIQpC+csgrFhWk63ubS5LaorqQzTiTCpNNKMiVHHt+WzApd +imtp1qpmwb+qCwtEMiniZB4jvVhSymJ5sLpgMGVtbOc3wIrOR8Ie8hgekHRR0cEsr0bDkaYST5WK +hRWGcmC7k3Eu7N6c4KMROhrhMinRkMsVf9RuzuKxsBFWOF+D8MEyw3ItLoI6JbNZxfU3YDcXFwiS +8EEZwMCSVDGTsebm0NOnkhRhs1wzlTHjcTkJOJFUkmAew5luJoTiwgLDMpVm+wCEKJmS4D/nF3gE +LVB0HfZiYYEN/OXnX/mY541PncqdPs3jVAlBjVSaD7vQ4OHTEATuQlQnkuAZbZLME6TLCUVFawpS +naJ9IxxYuQZIFl5yCTt4WDncziByOiNhmElQ4b0EGcQkyLyqD/zqbqW179c2BbVF0LD+hWRajicE +sMMUVcbJGs0DTg8gPHCqEM4sy4RXESutS3Zwxioca84uzcMP+hjmkLQPRRz+4np7ur0tysvwAi+f +zCgL8xiSVmQR8FiRlWXd2KDZHuibbq9q5loacXkugJxCcnkECygegq2C0w3TnpnWahqiETen03Os +UAH8oIUByYeT63V7wEv1LAoujxKlpu2uouH0cwiGYiIFPoiAuoYTZiLJEqQNxQ4n4XTKEMMLESEa +U3CiYphTyDugrERCzmEFWBacquRwKHDCYlQg6LpfOXT9dZLyLl1/cXP/SYJp5PASwdZTqBtJhN4W +J4NEqHsSZBzNdYEE0IwejTCnTiNzcyTH1kCLIITCW9TJqqmNDG1IUaVI2KmPiIcT94SFhWxkAQdV +QQk4vApoC8s3kyljbg7vdA4gT6FcgsVbWORSCZnCHV1twG941xPZJ06h2awFqhhZ5OfnyAi8IWVx +bEuRO1C15xewaJQGmgIqA9ZF0XwyqWcymu8N+/1DFHUXFyWGXwqNHuIkM2Yml08g5lyUXoDVSEoc +27DzK6ISmiNApkQ4C4YhSQuKl185Y3t7JFOnmSpBFWMJ6fR8bn6RSqWNHF4AmwyrgWJq2FmI9Ciu +TtBgb6sMX01kNfjlYHywnIsgkNQshltMOBG7abmTcDwNXYRDtbw11RoDIIX9z+WWbi+7hQ2CrUTC +IVwimKawSxLmQCqRBBifWj78Hm0IQR6LcXCCFLgkDAqlRzNlhqlCTTTNIc2UwnlkKcOvntWdLVFZ +NqwJQVWgPIlsUCiMEikRxfNWfkN31uGz4CxSWX0+SgCIElQVx33QGYCHRNJOpBxI1WhMXlikkinB +9ZZIJphbwGNxmZeXNRvgYWY4a2DHIo/bM2ZRBz56Mc4CEvNi3yisNfrhxRDgWEhny2jee/LN2cYl +8H050C6+TbANlPAlAAxrlE7rFOU6hUkkykeiLOQOgFCOrMvGhpnfXVggeSpY6p1DEQMCKZ4CwNDi +adsp7g0mN2S1PT+XIVAzh5iQzrDswN4AV6fnmQwSqNYayODCAp3NOHB2sKqwFCThhPeUIrbprgbV +w2iUT8QVeKFZWOchBHMmbQBuReMCeDrgqCeeyESjAoK6gtCC6sYwlXQYt8CZIsM2Myg4uB5ON+GF +0fV4xogn5fByNFMFLkLxAsO2VB0Mchn8BYY74E8luV+qHlv5zWyumMp4iVQ+iwSRmBxPaoATCOAE +VeSERnjDNlWA3w90Hd6ASniOv8lJXYDbDHxKHAKYwDAlLLu4xUpV1V6qto690h4efrlmg0KyTKFY +mjY7h25pJ0eV4P9LcosiPaAjgFKBDSjSYhkzHBmDGQCl4ZdNpIcgWizKQGU39L7AV0nSY/lajixl +sQCqMEYFcJCpjMKwRThO1VwCXGS4BgQAw1UUvZ/FwDKYwMD50r7hrUG0kEz78QhIkJECECZkEEgi +Jy7Bb8uRBVHrxVLKu96VAAE0rRWGq4EBjMRADSiQnfbgYmd4GYI2g2iuN4MjBCUk6EI0zgNUON5K +b3RxuvcQzDKcXbl2BigxjViJtAZxAuK2sMhSlK8a7fhjX/k4++ogv1kU6I5fXCQRiHyisLiAAd0l +sxZKAHK0NXuFeDxTG2wFC447Y4DCcDzQch/HawAMEOEME150iixS6aR+eg5JQkryDbe4Ywe7u+df +ufno037p4NQpHNQMXgvzFIAZ6FssBjBWKVX2K80jNryhmu8PTmSln05bkbgSSVlZvKDbS2tbt198 +48thh0PUyyAAq3XT2WL5LgQhJAsEUg734CxYFvB1GXIhlYHFr7FCjQrHqdTB7sWSBk41BXkqyiux +hB7edJHSMogOXCTKA9Ac0Aqar2VQO42EF9C80iYnw++HDYJiahIE5Av8RcnlNFYsK9agP7mh2SBQ +dUao47hDEybPugwLhSz87sYrblrONItYmYzCcxWW8VNpdnExCXSaSkuwKdXWWZCCZFqBdKPDh3H8 +VJIDGsHxvKj0bX9Hc2cgDrGEABsNoZVGVJItoUQQco4JgjNSjCG8Ibz7Qm7lS9tmfg0qFyQdoBQn +DMC7pdNQaBhB7BRKRxRXw+mAlTuLCeWJ09lMSub5SiLBxqJENILD53J8I6jsm87K43HMpl+e8iKQ +qkGDLuFlqPUADJOtOxtHT7sBRF19eXwFcgeCXNKXKK4J6YzjJbDzqbQIXpjjq6LUBoqDOAGKyyJ2 +Di9iRAAUdOpUamEBh8KxGOWjcTGDmmH6ZE0wAra3gWEe4LqijAmyjoabq8Xj3Nzp5NxcJpVQMDQA ++cWoolc5mB2+0J7cqnbPA1vGYuoTT0BZDB8NAOuXTqksV9XNcbl6BAYTqj84DqCy8fSGYY5icSWF +5Hlrozu9de2p9z/1/AcuXHomkdEQ1AGcA1/D8i0QGQiqx9NFu6zYwmmod8piTI6Gw+M8sMOQXHDM +YN9QwgPlRB5ft0+GpdCDmCSpEqBRGtHRnAs1ywhHbByQTCWR1gkqiKfERBoKZYkgmyTdgtzPEeUs +AgHm0eE32hYoG0bVSo0zpdYxZPrj89KA4tJZBXQmgxipDAhUhReHvNAF9QAfF4lgJOHmwom3sJIV +GnyBu+lXLhBEEIPiPp/DwrrpIDkdpwsEV6HFDi8PGb6VyiqxOBXOjTKWat3zxfZZkmsiuB9e6Miq +OOViZHhXG9hJ8BHl1uVK6zKC5ecXctEom8PySM5IJHkgh2zOZ0QIyIAgYZe106cz0QiRCh9YoMIH +2WiQkQr8ICNUJLWBYAYrlLzioW5vavZEUOrggFAyD1IpSg23sJJMS5msoZorgtoF0cukrWiEX1jE +EwmOJPLgCk8/kYSizwsNhm0kM+5CFMiNC4kuBViCnZ7LAejihEdSgFUdimlguPd4KivIjjQ/j8Vj +fCqlxRNhk0MwRwRekaQR7A4ntUW1TzJQhrTTC9TcgojkKixfNUyoy51IBJbR4rgKirlQUucjPEb5 +rNTkxK5mjEF/QL6A5TRzphlLYV963I7H2BTiYUSVIKvRMIR4eCVSqiC2wO+ANgpmeL0olgBG4hYi +gFs6xXY4ZcyIfYprw0akAPYQBwIynTVjCRleUO9IOuzxi6B6Ki1kUSn7OInC58VIH0IR/DhYOSDb +av3c+tGrjcltwFcAYIicHAY/W8DpPCs1guZ5w9/l1H6OKoLMxgEz4iIsCBQ+gOFcrswJE1HZ0KwN +FA/Ff34RJakgKB24hV1OGqayLoIXwQU71jLHlYDxwJYWKzuF6jGClxNpM5vLA2bn/U1F6wD4wb8K +UntpcmN99yEjNZOIlsjKnAS2tAO1Cc4OJ0uGu237h4IyhmydX0BjcRroC0QGcgQ+Dg== + + + VpLm+xhVB9gTuDLoDIa5hjXoLp/x6/sE28sgfiQmgK1j2NLjwdlCOiNIcrfavlDvXax3T7JYAcIg +HhdAdSGcQIiiESGZNHmpgeTMGBS4eSxs+Yi5aNimL7uwQEWiEse3g/p+ImvML5KLUQpEO5MFr8TB ++8PLVqfx9OPEh2SH8poKr58XaLb62I8Y0biSTDsoXjLdNTjTuXkSbGO+sO36+1I49kIFvl2I4NFw +ToeXjPGnTmUTCTXvr63t3woa6yhVTSP5VMZIZ2xFWwqn+qIOJw+C2pl2/1YGBfNSyRF1FC+G9T3G +LUZhTfJBsN1dujGcPQwaF6MJdX6RDQ8sbaZB1rA8SpY5aaxaM82eMnwTtDEEgwgXT4Jn9EVpAqj2 +uLt+SI+RGPt4pI4CigfOOkeWcwTkeEFRurYbDruHUiurk7y/I8k9MKQZRGK4ou6OcL5O8A2jsLm0 +8Ywd7IffykWocLh2Rha4pm6sgpVgpT4nDVi+LUodFAl7jMfifDQmgAJb+VVR7T3+wr2EYkVB7IJN +SGbtNFpguE6ldbHUOAdBCIITNhymANWqpt0r1nc4tefXD1vLV1rLNxihD0kNW+O4s6B6hNPtDFqi +mBrFwFnkM2g41ieLwO73Ku2T1f0XRGuaSIU4geaAB2o0F9C8Z+SHvDrGiPDCCKQVJNdiBHxceH0g +bIGuNiStLypLgEA006CpWjQqzi8QiYSUzdjhn4gBiQniz4ltim4kkhqo06knEiwV4GFBNCHBgTS8 +0lalfgiCFk+Q6Qxv2T3LHj9xKgvij+ScWFrP5sCiFsNLuwuPe2BSVUFaktURfC7FQBXIx2Iazw/A +ZcfBms2h8E5YqzQaQPmLJ4zFRW5uLoemNYb2wi818AItDWuDG6P1B3kQAajgmAt43xyc1+0RFP0I +SEE2z/BDURuD+MSSEkRCLue67igIVoPyDqztYlSNJQzQLtCW+QgZT8sIEcjGzCnuyPaY4BoYnG/G +eYzxxmOLkcdJEOQuitfS2fxCNJxzBKJEsWXdnWruupHfYLg6hueBEzJIuAusAGDcAzkCEWa5Mkl7 +yawMkgv5OJzdXD/3sqCPIHrnF8hYeAUvoCgvFV7H4KHWKMYUpFiU+ouLYLQJsOSptIIRFs2V0ogB +miaF11HBJDaSKQ1kk2RbFNuU1AGCB+C2WHGJEzvgGigGgD/QnVHQ2F3debCy86Rd3MnkSom0Bewq +ip3HV6JqnLTseBuysYxSRfC8kVC7DEXtGIBq5jJK17J4kWQaqg4f2sti4JKK9d4+I7QTST2e0GNJ +naCbYE5Doc7oi4s5BFVtd8mwxpIGxSVIJMHQ6dmsI///7L3Zj1xZmh/2bovFzNgj7r7vN+4a+77v +ua/MlUzuLBaLLLLIqu7qrt6nu2dGs2g00kj2yJItGTYwMAzYgAXID7YBPxj2g/8g+3eiLFkSbEAP +BpwQ8nZ0VmYw4sY95/u+33Luyfz8Ld/fzhNDXfXDXdvbkvQ+w9SSKTuZMlgmtLQeTXmk3Q88Xf24 +3b8KS/sQz3na8YNFr3/lFaf37uUgRL1oVWpeuOGpZo4oKtjcFHN5N4oPTGvMMAFNx1CSFiAX/Oju +2M4ScJfNmDxfgepIAzEKASejPLscWxLZWIB3UNu2t6p2rjuTZ1FpW9P6MqGScrm6PVveMLQHRIUZ +YYS6bI7zbDmdcwtsiWLLmtrlhVCQQjC1pi8kec6y7TxVzlFBKqsJSlNc79ajxZJkDKqdm+XJL+vj +l5A6yCtQD6oyjA57w9dOeLK+/1IBmqFwgOrrFvNjw91CuKHlCDLLjXzBzRVcpKWsdSsN8svXFBOh +uofTx73pmR10Jb0F0A7L5yAjUSppWj1P2bmCadtdvBdEnyULyz5ZzeYr1eqBpNcsp7k8+Nwrw3BV +RaVDftM86+Qp3/HnmgWVEtNcDAFv+VtB+ZhILxZ14WPUttv3wq7ttgWlDtKf73yKa1cI+rrVkWO6 +E0lr0nzECKWwtndw9vXW4buotDT0OtSI4866k6eSTgqqQFdgc0x32Z8+K9WAA04BAputIDl1ZyWb +kzyDCYdS0lStGUYL2B/NnAEVLXd3sfPRD/chgEWxkclCZXUMYyyIsNs1lqsr6kzRFrazRVHhxiaX +zZma3s/mi7BRvNxtjh5W+s+a/ReaMdlMyJubEmYe5kvRexRfwxlQVl546IAglA5MQSIl82ITrKqo +PYqObX/f9AEyTdAoS0fAzFzWXqvxbibjpFNmvgA9Q+77Q0hISo1mgkRSgn/U9bFlT8jtDwFI69eq +hzxkHuXk+TjHxDRfQxXL6jSMjmkmVNSWjkzQutl8mEg5uRwote6Fu2HtSNRarFQmvz5gTbvDZ1sn +35Tal9AbZB8LVyJRE8oCZBXf1O19q3hiOFuKDoERrddg21HpZOcYmHAJUQ0ZloHAY6DDYcmRYx6U +fLl+0xm89krbLNkGZrFcICot2ejRfJzJaRQbucGu4Uwlpb6REMiOoxzpoQbGBzXQGBpfQYF7pQPJ +HCTSBsfXUXe5fCiIDRhAEJykDUr1S1j1ZNYECPvRblh+AL3hhQun2OeEwLW7pdIWWZdwJplCkEjb +mbwHqFGNXoF1MwUrLG8t914cX31c79+201kIUd91prXGCSdU4GiCcK9UOY2rp26wjfy5fz9XKDiq +DgMbUXzF9A7KzefdyTvTXZD7VrSfSIoUXUTIZKKCvCS0dFIGzNruwnImFBMA4evNU/i7zaSezgUF +traZthAaKFvP3y6S3SnHMMg0XypwzVQ+TmZDUZ60+k+rjUP4C5YNwFM7Rx8un/5BvX0BL5ZI6YmU +yXJVoCsxa1lXM8dP3/3V9OAbxZom03YqaejGqNG8gsr9W/9h5rP7nCC2ty5+s336bdFf4jrBOJgH +zewgsbP5AFJBVFe1zquXH/6jsHSuO7M8h4upAFtoAVYFumsi63NUhx8uDbtVoA1EPJsLOaZlW9vD +6Uvdm2ZpNy6tDh58YqWmqHYEvZWDhuHbkG2oU0XvkK7QfAmatt3/cjD9Oqo+gNyFBOK52IaHjVZu +gJOUElko5LbrntTqL+ziQSoN8VnEAOvdJ1HtilfbGdrLrPeEkNlOS8mUzHGlsPSg0nqEK89RbiKl +EKPNRJCg0KWqPau0H+6e/mK887Ud7ufwEUlDltqZjJtIkLsnmFJWaHjR0eWzPx4uvizAJZm9auus +XL+yi1uwh+m8nc67mj7wSSPmEPaBrIYp3XLtQbmOiHTIOgxPcEDWWrxcZQT8WOOljiC1ZKVJrFDW +oln4qRFEPsWE+DGbszgu1vW+ZQ/JxmOz74YHte6TUv0MLJkkS+JQ70Uof5omfwoJcj2VVDi+4rqw +6iu4v3QW8smP4i2I82RS043F4uhbv3JimCtFGWJOguKo29nlOHtjkxGUkeEcxvUng8l7011l8tbm +phBHy5PLj6oJK2F9timksq5d3IFaBlbApENWBeT3qvYcb57OmahHRugq2mQwfr1z9B3L1+5/RlZH +4WVkcwBZsrEhwQIgbRQDs3cMg5aDvO8+wqyOV+/88mkqG/0f/54cV/9/X8D/V8fdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HVf/278nx4r/9+T4W4oyfH0zuP7q+t7x5J7SncaX+Hn3+t1Xj9/eW91TLovdt18Nnj/66vkX +r6/ffuJreMpzg4gv7j6+fsXrP7ySx4v4rbfPnz5/jSf3Hl2/emzwNl5ax//vebzPe+v/HX+651S8 +cuCG5XJQCnw/jip8xauEbhTGcbkcVoO4wn/+//iiqOwGXrVcLlXKlbDEvyIv+uG5qudV4pIX8P/y +XX5Y9iuRH/2/vOjf+rhX/y7X9Ores3tH917f27lX5XWDPz66d/CvfYd5q5B56719/+7Z9vVXmJLX +PzzZe4w5+Tee1g9ev77+/PENv36Wx9N8EJQMzFIX/z/+mnzz+N77f3PWPH6Gb17gqa953+OX/INz +j78hr98lV1+J+PWX9cyFsVsu/fDz4l//+Yf/Lv7V6//tn9evf/1/fzz+8+W/ugqfXMU6PUbPXz2u +/fDtenD/V65gKnA143vFweMPzx893h33+OPVvQd40lnnyw9f8dN6ruP4h0hE/DkfeD7GVCJvf/bv +9AZyPf/yTf/yvxU+xDX65fXlRjx5o3dPUdZXSLK7xpcQSP/e8fQ/4EXSjoXhAkmpy2pTJv1m6jTb +EOSBYowEqc1xpOuAINVsZ6oZA0XvMHwpz/h4FyuUOLFK+kOzvqrWDKvnhTPLI73HZLxX7WvWosAE +maycyYhUwSRNs6y+5S2N4kq1ZqLRY8RyjnKL/sh0uixfMayZW9wO4iNJH7JcQzYmvNSimThfKHJi +Q1R7stYrRtus3EhmjAITsWKVYrxc3mHZkmmNwvjAKM5ko1tgfFYss2Io69UcY4tazSvtBdXzcvuJ +Fezh7QUuyjOBH+5WOldB7cQvH8b1S8NdCVonz/qS2hZkTEKUzduZrM6wLicEslKV1Homp+OzOL6e +o4I8HRbYmCfN6nqC3FC0jiA1WKFZLp/54SErtnN0kM7ZmbxDMb7tTg1rmKecfMFWtZ5ujEiDwAJp +10Qzga51q9VjmotY0i6rk8laiaSMf6WokKLxiCVlIGlDXurxUidFGh0V8STDVli2IitdUWpRdMQL +jTwVkL+1zcY0UypQQYH2Na1vGiPSTIgupXPuZlLGI5XWMxkMJBCFsoQEKBRzOZNlvFRK2kxw6ayW +K7gFOsgXQo5vclwNZ8vmcOVFUWlRTJhKS/m8i4tMpTSajgWxw/FtSeqr+kg3+oPBRVxdFiiD4Sqa +MXbDlW4PcwUnlzVoKsIJRXXAis1sIcjmXFluFYsLxx6zTOR5c1lrU1yIlGC4kqKPVGMsSRXX6WZz +Oh5ITtvdVs2FoCC7xkhO0qpcrOTzFieUbG8RNx44IWksyqu9Ah9zQvXs/LtW/5wVYoaLTXtVaTz3 +SxeC3KfYUoG0YPcKdDFPuXmqiPGSrsZKj2IrFFvO5OxU2sBl4wWk65LapPkyJzVMZ1GqXXX6j7cO +33BKRHFF3R57lZP64HlQOxeNiagNEJGjw2+mW69pqZItuKa71R68LjdvRG0saCOaq+QLLqaRYWPS +YDJnJVJKruCR5uKFYjKF6KgUE/FIeKXFY8L5Ks3VKLbGCE1OrpMGpWIbc4gMxMvwxg== + + + POUhUdMZlfSOJZ1B/XzByWatQq5IFTwkGBKJZcq10lEp3k8m5WRCymSMZErZTAgIIgbLCm1JGbN8 +l2ZbmjrX9Vkma5OGH2xJEJsIGQCBZoEPQ6e4xfDxRpK/v8kgOYEppjk19AmKhZwtY+Xz5G+1b2wy +qaTA0oEodiS5y3PlRFLCZTBMlM5o2ZyBXMoXomTazeWDAkUaaEnGlABLzsAoUpiElMIwJc8/DMIT +3z9S1H65tP/h67/YPfn8s/tZw56R/pGdS9kYkD+SjiKiSUeQTN4if/U7j+mNreLEtIcCMlyo7u29 +tb1JlnKTWU0Q6qXqZVA+E8QqLwTZrL7u/DQBwtB8rcDVBGVgu1tR+Ug3hwxdtO1BuXFshzNRb4ha +FzOvmuNisD1fvioGC5aPkZauv+eEB6I2pOgKJzZpjuTb+i+nyxmMiC6iADkBtVMXxB6QTRA6LF/K +FSzSzUWtIecZsVoM9gezD5Pt993ZY0aORLVmeRPTn+n+XNCHXnzSGbyo1B+Mxk/KjUMgMMvGdnHh +lw90Z85KXV7BEDosVwW8kO6wGR1QkM7YLN9Y9y22EaB0xmA50gYgU3DTlF9AWLkuJwxs/4hTGumc +hnk2nFU276Uy5kZCBc7QTFSggGAeYIqiyddCvphJ66mkkk4hlE4h71nmUFW7yKhkUkkl1R9avCdT +Uq5QZIWGbi5ldS6rU9veM81VvoCsaFKkRVOFZhCCHit0DWsVlc54ubGR5FJpmWFJqzNBbLBsGVCA +y153wA02NlikVjarMbTP8x2GA4TGhUIkin1d60tSVVPrKIRE2kplfKA0S3qr12ihTwO0uQinTSQF +gnVsWVG6eAEvgPI6bnGr3X/iRPPP7uc0uxeUSPsEijSIagINGK6aWRMBygozwIs4YZkiIS7bxmCx +fC5rzTztcUJFJh1ZJoyAmbQAIDxfsayR481oNlaMDq80BaXDoq7lzrqnrx2Gq/bg2g3nfjy3gqmo +dTR7bHoLfBXkFifUK5VDyxunclo6ZzJMRdOnvNBCQIEhpBsEBfhC+duZnJsrlCR5iKlWNNK9CXMr +iHVRrqt6R7MGsk7aAxRLx1awzckNP973oi3VHtjeWLa7pcbFcudTe/gc848aAZjY5gCImkjJSCHT +WlQbjxEd015oep8XaoAd0lSg4AK7UhkDOUDTJRAQxwOmYrBeAZHl2yzfl5S5F12hZCg2CoI93Vmm +c04ybSbTFtgKJwHo0WwAFuPFJuo9n3OBTrmsjQfJsZRCg9f42roHkp5KW9msg0y4v8mte7NFstrP +FvxMFldSzOYAoSVZ7WG2QYikvRmAkfIYvi4qY8QRmCZJDZqxgT9I7DwFOAqBkBxolIk3N6VM2kqn +tY0NvlAoK+qIA97yrXw+ksRW4M+L7iiRknDx6Szhvlweud1SjO1ieGC7c4DbZkJMp1Vg12aCTSQE +ga80aie6NWXEVibvoiIoRl+3je8gRrq9YoQWzZH+2RADqtqgKINlfV5qyvrEdneKPkLZYrkQ5NgZ +PKPZMmIN1iCtPlTS/g3nQXFZ9jyq7kPtJDIaQA9gq2pD5LZdnJnupBzv/fInf3X88BMjxbQQSjok +2dwLD0qV01rzXNa7ZBQ4MxWyXEvRFqZ7aDoHurWNl7FcWZXrljvLUhHIOleIMJOGNdethWLOomj/ +8Ojr7uAqR5P+626wV209rHUeVzs3tr8I/NU3X/2pV1+k8hZFGs61MVeQB4YxhrxZqxQb5CKue8vh +zHjkCRFA/9QYvrqZZDKkL1pIkbJtpDJOLh9TdNU0J7rZ3UwBW8xcoaro26azZzrbsjZet6uBYENo +zExGIU2t0ko2b/FgFqmNCDJ0KZfzcjmQi5LJaCAgImDSRiKppTMOcBKpBQYBZKUAICnx/kYBGiyd +NrPZYqEQACgQAuQMaDGRllM5g2JDJK1uLiQFRdHEtKOieR6Z08XJgTOgvGRSSyb1XM5n6WoWo8jY +DB0mkwJAbGNTBG3h9TQdbBK0VGmIPQp8ZHMCpqXKCnVFH2PSRKkLDcbQwC4ebywU8K5SKqttprXN +lI7R9btP0lkZuhSagbR44SsM39TMVVy5jMsXjjPWlLhaXkWVfVHtIMEgmwWlZtujauW42rrMFXzD +6Kh6G3KRqA55IKljw9quNm/CCnRsGbLE8eaC3BQJKDUdbyuuHQ/Gj9++/5PZ3nNWKilmX3cXurOA +ZfihDZug9JDkADrUhaL1LXdpOitZHenmDFxpOcv59NV4+UWWinNUzIttTR8Y5hjv1cxJGO61W+eW +O6F50gpalNvQgX58XGleG+7cj3Zev/l9uX2IhM/TAbBONSdQ7EBU6GEgQIGO8T0og6ED0pvZGAGX +CJXwTV7sZHN2loRbxSOTAZ4DK3qAzXKFtFJOplXkCc1UCkyV9GXh6oLUk+QexzULhRL+dTPJpzMy +tGih4AKXdG2gyB1ZamvqsEDFwCgKrEoFyZSRyZKmgJmMiRxLpw1EluOr2bwDdkskuELBT6XMzU0w +pkbRICPULERyEcTBgra4GjJNEJrEf/ENpBkJDV+TpBY0M84J/YZz4vqRWhBdaeh54FJaJ+o9rSYS +CtKJ0HFK/QGpkD+C0AA9Wc4CUg3yHjmG0yKgLFfKZkxoNpyQNAJn/AQmga/yUkNWkYdhOqOQtrgA +Sb5KYqHPK/XHzf5L213Jct1Qa7PJo+7wihMrktqRtY7hDP1wWW+emsVJKmOZ1kA3+9B4YXRQ9I+K +3glq1vYPBAX55ilSo94+yVEO1LggturNm/7k5Xjr9Wj7leaPFKPbGz31Sgc5przu9dL2ooOoehHX +LjVzhkvSzQFpm0qFBQZg0vTCvaj8oD9+FVRPcnSdhdYSagIZCCC3Z7kL054RR8lVMbGq3oPsZ4Wq +Hx0MZ6+L8b4dbFXbJ4xQTpMarEHFwYmAecEjkPSy3McHgTiSKU0W60G4BfOLlEBEIO1Me1tWBoUs +qnuNPFkHEWdI36aOpE7xFcKYZ2uYh82kkkzroC1cG37M56HNqqk0aZKUTCNkUoEqwoMj1lCqhjYq +RUeqOsrm4aOdtSNrID2yGZgpL5uz8JZcHmYNHjnM5YnaJ62OM5DEbg6cmHWg/Nm1WgA8SkoPQYdf +QCYY5gRfIZDwIz7ItKagD5A4GDCbsSgqSqWMREIEjhFRl9KBhFSBtMwhqJiBHQMXmykkWMbABzF0 +GbkEUccxJU3ppbLIKAHZmNgU8wUPdAxRCtpNZjRMGs16ySTz2WdZKFgBkrvgSxLws0/K3xpxUi1P +SDk2tW67c+GGS5zWtOfQ3pxclrSq7bYVDZzlk7WC6ACKt1x5oBpTWGOKrabzIc3WoGM9b8twRpmC +yUvIzJbpTFSzr9ojVmkzUt2L90eLN15pjwI4aANeQd7OnWDfLO5o1hJ2G6/PQ5xwJWRCgQk0c2p7 +h6q1zSkjHl5J6kLJAGzXbWhrBTpE8WbzEDN129kjHRYLFvAEZI3xQnGxpANuU5DbjruKyyd5JsjT +Rch+ivQqhsAGpxiQFoigqnR9f0mhDBMCtDfOvzbdQRbiJ42g+3B2ABB85YW2bu6q2hLWm2cbaVLF +pFUtankzAYPGZnM+TTWgkEnQC6TTPPws0hWIhMRYz3mX5eqZnA/thCSR5R6UOc9Gutyk6eLGJoVs +RF7RdIWiwFMVEDRNxTrMdd66v5FPkT7BQDyPIwUFXYo0swxjapgzRAccCs1MdP66ZSOeSSYlXDY+ +ggyBcBmHBwCwkI8oqoR8w4VBYIP6CXWmNdItNWNBtqEiQLuNyv7J/lebKemz+xROxTEVC2rZbjGs +Qy4mDU53Eknm/mepVIIBrBVQIBkDMhIKE+HI5nU4fYhqQx9Z5sSwhggr7LNuTXi1kcmrrOBLclk3 +WsArv3RourMcXVStCcWXU6R/VRkJ5ocHQbyvGv1MwYZdYoQS+DHPeIxYhoNTzVml+aQYHWv2lBZK +XriDNEOsSQ9sbRRVrxuDl4a/wymkOS7yihErWdrFu+zg1PROdWSO3M4zyCUvjPbdYAu+g/i4nIXC +BCvh4vEjIoVqBTnCXar6IKicWv6uQPrHk+56cHaGNdLdeZb2N9MKnpGVDqoPcyWSrtJVJBvPVvAR +myQEBQQRiogqFHk2Rj0i4ihtIHOuYGNKkS2IO8OgJEvImc2ERIQ3UIsqgmETRLfo4BeimtIGkA2s +Cgbk+EqeeMaQMC9pkYt8gxWF0FKRV/mClU5JmgJz1F8zNcZobSbUXLaImMKdbWxkWcYXhWqe9D8r +JkGgBGQsWepZzjYwmbBwVv+hrzDpeEqH8LaAKaTK/Y1cIski8WB4ORbUpqOOYEgBXwRtxIoDs8zX +16sf/H3SO1zFWDihDKNE+j4yvqJUszklkaQSiXwyQeVztiK3bWvEsi6VU127A4UJyM3nHaL3xEoG +acC6klxBsMDvZHJgrrMGWXwzhqLWzhdM0+nxcgXPkIUaCNQCgY5S7Vq3Z1AFfmkrzziY8Oy6P24O +qlUo+dG2669MexDV90W9w8stWR/Ck+aQCXylUr+qth8yAhi5WWlde+UTxZrCduVI59F2EB+H9ROA +HnSaVpxmaY/0NM2QfnJgQz/YBdJiCIbVRxpAqxD1mytSVOgVd8qVU0lrUwWn1jwygkE6r6RyZhpD +owlX9gZPe7MvRXPEcLEfbbEieAdqRIXiRShBW3Gwr+uDZFrM5VSOCxNJDpWOcCMBSMdWLi4woFSR +Zn24yHwhgLQGW6VSVjKFeDVg0HJ5M0seZFksS9QLycPNhIwXK8oIIgGOg2L9HGUjiBsbRPBks6An +heejfM4U+SiOpgUGQAfX4K9hrV3IB7kskNNMJnlRqDBUEcAFzioUQoo06C2R7ptkRRfzU8KnpzJK +OquRpvJpXJgGhoJ8SqUxCoWi3bXEEjY2GOAwMGrtEWzHnnzx9s/I4tgmnU5LkHl4EnkLKkzj5AW/ +2TxqtXeRVLkMJ/GuxIewn+tsKQKpeK7U6jyAF4MbRd6uEc9Lk/bGrm3110sraibtUIWAJu2iY1lp +kaUnsTqYPJSN5kZCTMF7EknsSWq31rxS9IFtjU+uf5TKyWSNi4GPLgtCVdXaSC3THjVr+4eXnzR3 +mFonBiBaEFpFb3+6+lTvPWHFhqJ2iqXdAh/laB/MJUHGF7eqrUd+9TgOlo+ffh/UVvcT7BqfSddz +FKNhLgW5Bzvf6l5DPyeTBjQDfsS/WvYMNpk0queqk8VzySxvbOaAFUgqQKistcaLl+PtL1V77JiD +5fazLG1ubOY3NxleqJA2olKr6C5BWCgTXowZ1l/Tk5AlkEJ8MbKdEyKKttwAuO39sNC9mYDXg8Nt +aNBgHIRQaNkDUa7f32A2Nmj4dPDImnTKqjYTiH4IC6yXykhrPFGBOXBbQEhUOuSWY/XC0iyV09bL +YjAaEHgBIamUmc/aIl9xrBGNFOJjRWnD1gFISTduEBmImwlbrVNBqgC7UBFIRYau5g== + + + 1kUHcY6MkoTQNJBjSC0RgJxOQXSRN4LW4Sh3Dr7MFPR0UuBpHwYE2LW5SS4+kwW5VOLynuuNU0mG +ZyxJKNIFOAv4FFMQa4Y5BNzJWh8yKQ0yzRjJJPyLRSMQYkXT24B0UHA24zLIECEihUmysRJ4253h +taQ2APIMWf1DgftrwVyiyHrp8OjymyxtCUJZ07qiWAeO8WKN5UssH7bqe9fPf+GE8wyRozFqR9dG +TnFVbj6QjX52zeay1U0VTFGplSp7rFinYYT5qqT1xqPr73/5Hw9nV/hcSWhwwLSCixQVpYnlHhj2 +Kqie01IXdszUodCAtOD3CJ8LHavKXddf5mgbM6wR4dQo0A7FusBeTq5yYrnfOPrlr/4BxbmbmzTH +ekG0ANIiRokkaseCVCv6U1geYA7DejTtMGwIUsCZMXDfnT1/+3uKh1uX1vekfHxlmBLoD1AThPPL +6x8PJjfglM1NKp0WkAkgl0RKBfYiRpLSAjhA14FPgTbQxqmkkEjwUHSmNiy6U1lrJLM6GBM4uZEQ +wCAgZVWqq1LD1HvF4pTn4tCf5Qs2YGdjg8ph4EQnl1CnUWlHVqs/wGAmo6ztoUp8Iuib8S2zYVud +dZdxSESSOUgwCEI8ECBM4GaCgaOxjTHg8bN76cQmTg4z2AbYwjXAQiaTQo5IKQUfje9pKgJ2rW8i +GDQLrWtvJHhgFJiR40osnDgTw60kkiSBUwS4VJYLWDbU1E65dKi7M4h80j2U9grkjpjF8BGSSlbb +hj2ChVT0LsOXi/7Sr+wJMsx7XVZbvFSVlLrnTyWtlcyBzmwiuXM2aZ8Mhsrp4GJFbWGecX5aqAhy +A2CYyuLkFae4rHcuS51rK9xl5Wa24AJ4iRnP6amcIchNuFFe7Mj6nObbRe+w6O9CXGULJuKFK8S8 +ZbJwWyGRyvliJo+EYTcTFL5yuM5gL64exuVFtb4FkQOFoyOUaSaRpPEjpsI057I6EhX4zQBSmWa8 +TE4l1QT/q7WQqGF4VO1epcgtJw0FlUxiklHdfCol5HKGanQtbyZrPbL6RNnZjJxOiwgEok+TFbNq +Nh9C5IviwPVOWaFOLGEOigvhMCDsszmydicqw7B8DjdBmJpG7LQEICKl0Hkrn7U4JoqCJZIhl/OA +yQwNfjTyORd+JFcg98U0rY/XbEBmJyR8bqFAuj4niHSUiNsFTpK7NiKQR1fbxIOQh4RHLu/wQgtJ +AshiaLhRG6UHj5xIKsSi5snFaMoARJ9J6abS29jk792D7iKNw4k4yYD6BQKhZEFDBR1TGKnQAWwC +PMmiRwqpFZHW1AUkkgeqJVxjTVS1S0GxsIFudnipnKcDiqsUmDrDd4PovNZ+FtTOYFhEqQ4aBYwg +hwHRIMEcFRXoElgbH8oxsa51crSjqHVNa6v6KCidusE+K9Vg4aHVBThooczwJdN74FefWOEhA7dI +xwzf4Mg6QylL6QWIQ6ldaz423S2Ga+aoEKXNCVVgC8of46JpqLiRSHrY1zJkgUgjHjxrAGklvclK +MSdXWB6OrEp0dYEUI8MGrBDlKeRnAGcBx8oKTbAwuavIlUHWkJoY0drat2VtzHINnqsj9ODTXBbT +KG5u5sGeOcqHnqTYCk90lwNIQUBBEKmkRGgIPrGAEzZ5EblXyVEVXugqco+iHZIe68VSxIjmqhw+ +HcqTr1vmIgfBkxQZymMgGtNqLgNK6tFMlabjfB5qEwkDwVxC3rI8BHzXsReWMQJE5LNuJk1aQd+7 +l4KIShHNI21sotDIUmqGmN8IdiNPvIZ2f5MHiqbTdjqNy3YDf44AIas5KqAL5EYqwBADwbtAbTzT +iotHMJubmxBsCqzxZ/dpAHgu55AFOrAtzGMeWFpTlD4gBdSfTpl4oyDUs2QpQ8oQnAklses4S8ww +LkCRG6XyDiOEZOGdrcra3PFOyrUbw13BiGE2wmhXXfdjRrhluWEYQ8OcS3IHZJFK64rQLMf7WQoQ +rYGLbW+7PXwZlE+RP7mCbxV3ZH1C6jHveqVLOzxmpRaCxQkN29stxieqBiVcNpwBLzYMe0axEWl+ +zMDp1xWtz7CYKBl6D8Imm4+zhVImH2RyYLSqLEP/tJEnKApWKkkqlNWYgr+jvFRKzqZNjSBhlEhx +IEHNGipmP0cBr8iCoWmvnOJuniCnRZG7gaDdOtw9w1TSGQc6mUUF5Y3NBA3/RRrDY6RgDUxd3ucY +kEIpk3E27jMof8hvqJEkWfUCB/mKNisWT2xnl6wUKT2OxwXwxOXlTKA6TwRVw7RmhbzFULYiVpMJ +dhPeLaHIwghvAWOS2of6zRchNig6hHYCNxXyEc/W8ZWlqii0zz7LgN1SSXJ38v59+t69QpK4TkCH +BzBJAVvoEvj6/obAsnWaxuzVGKbheUtVhaYtOcaYpoIfpGMmpSHrGCqGZ+GY8uamkCFOUwR8ZTOW +4+5hltbLFzoKGWmWJjcawMt2hoQpoigo1TiBi0yqYCJEOZMhNyMgxrLQe8rQKq7I5pOcKUgtQWpT +XAxLspkSgYeoHT/aAc3lyMaSiGLAoUhO8ILJ8xVF7hr6WLeg6gWadRBl2WgLGrlVpELA2zPNnlNk +sQjaBgBi4bSpjApChKAVtRGnDApUddV/urX3KgPiy1rIZFCYQfYCgU/9FBmRWS3vZsiNvCLLd1V9 +zJMbqS1B7BWYEub//Ozb04tP8GiQVYkUnLgjcLEk1OLikudCihj5Gvh6I8Um0oood5ziVhCfmPYS +KktWqrJaT6TEDUIBEcENpkQelE+24tCBJOFfFXKXv+DC40PyKVKfZRrZrI+aZaggk5ZhzWDKcFXr +XQFkdSuRhh+MqvGxrlUyGeBnMZPDhampNKgWL9ZY2tPEsqW1QU8ZCH54IqRoGlQLzSMQDcxiAgcA +FlhOKu+LbFMCtMp9gW3lstb9+/n7JLFlZAK+SScNmAKIqALsPOaQihR1AlrJZF18zQIG085mCjbT +Xt+AaDv2ErQFv4kR4UH24QCsNlhyJZBwGDu5HiR/gNJLEsK1edK0HlRiYjbgH0UJkoOs+QNbcFqY +ZYw9R2IEIhZSUPhZe71kgXJzkkkFZFdgwk2yVYMly87IgTzeVQS4MXCgQkNS+9A5qRTPMLgAkHhM +4+PWN+KhOcNwRzHbGykBLKAZA03vIU+yeR/lnMsHeQLUEks7khjjgjP5IhBG0Samvai3b4rVA4gu +5I9mjKAcyDoMyjkp4AJYrswLjUy2yLA1miknkfCITsYoFAKWL/vR7mj+tDO8hCNgGbLsA9JHRjF0 +CPkqciWZr+haGxMC2CFLspBqWZLYhjkwjZ6itZHDaxmsr5f3I2Q+SAFSClOEhAFSQRM69gh+CpNZ +wHDIQrqXIH3iEZdiPu+uyULHPN//jLr/WSGVlAv5AMQhg+6pYj5rqgoCIRILAHrNYrosKOdcxkRY +17SuJRLM/c+yyFI8mc86AlNW1c5akpmKVId0BDvD28Kc4iOQTpubIj6C3DUgJIjPzWzex8klkQsE +NqSoOE9VcxTGON5MKRvg7iy8fIzkl+WO7cwMe1qgyR0Nssic4D/7LA2qpfJOIWclEkhvDA2WEPPA +rFdHywwXU1SRQGIBwqAsiFWyP4ohvg85Bs9LkbXcgKyAkQIE+TqplI5Kx/UjURk2pvk4nbcxgcg3 +vAXBwvdQlUVvEVcOisEORZYfHcg22M88pVMM/FGE/NehUX0I/mamgLfrpfKhrJLlILKPBRBK7gIj +ZB4soWWBtirr9XlIFwi8DsvXyPqnWCc77nIuy1eBVIgv4BFKniQSAQ0XBauoAzAX4gi1g4CiEGAe +BaXlBCvLnbFcS5IHeC8USBLJD8ARGxQVID0wJ0CSHFWGJEYcaQoTFapqi9zFZuuS1Bf5Rp7cBcDF +y6Cb9b1mFfYHqjVb8DCT1crOYPLwPpAtC91bXu+VUsBTyRSUv7O+u+QhKMkEyl/CV3JHb1Pc2BDS +4LKcizwBxwEcKGjdrAYth0IGhSF8ebIBDKkFGoJ0ETc38psbSE4JXj5JRlosR0eiFH72WfL+Z+lc +muQSLgywAMZMr+8nQjvhn2A68A1Ogk9hyYaTsaINIdUA4/cTMjwysT9r7wCyw9XmKdB6lWPr0CpA +P54pUXl74z4ssEgkIrIo70M4ySrZhSIqTUgdhitxYmt9p5jcvFPNnunNdHeSJlYUkjUgSlKs40HC +lEHe+gzeRYxYMUcXiZJnic7RyBbKJsuVFKVl2z3bHejmiBPbktKRyEpUnxMCL5j64TYMMseVEaZU +zkrlTOjz6exzzWjBoTNckMwaG2RoThZqgdzQ75GdnHKbI9s2/I2kvpnUaZYoJXgroDeYlBObqjHk +pOpGgoF3TqVVYCZomhfbUMsc30EyZ3NwEAoYnBMb3cGL3uClpi8EkdxDROGQLShZcutkvdVTW++1 +qzBcA0YJhh3Qh8rKEvQoFqiKqowNHfQRI/HIssN6sw1Zwd4UU0my2xNDs+yR4U4Qo/VKpkt8ekLK +wxjmy7k8HArZapIlq6BuMqlvbPBgsbUeRmrpGSgfiiyBcmysya1CXkunAGsh+BQODlxToMiGUkGo +ZFLiZ/eQQtlkQgACI/+h/QShB/9FDEWCljiyvQHklU5p653DXo7cB8cYBQx5fXNKglYpEBMaU0yZ +DCpPtn9kyDq/cu9e7v69ArkqQmExy9V4snutim8kpAQXIC0TpHysH1KLoqu6NQ3K+26wcvypX96W +NLj4gWpNdXvqxXth9bTUvGTEDk02lsAAwgh3EVxy75VF1TdYHmjmEjgSyshP3YJP7yDWiK9ugbCm +ita0naHrLWVtqGgDkdw0b5vWZDR63mpfWc4YRp6sPtFwZDVoIYhkuCFZacO2Z2kIDx21j8xh+Jpq +jnRnrtkzmDWo8fU9X3u907XLS80cFDJfd/zdUv1M0MgqN6gzu8a9RNqAndTtpWZtg2E3yaIlkM03 +nLFuj3C1qQyMWESzZP+qZg7BqnCXQHJkF0CYItt7YEAWGDvNV5FsUDu63pbkLse3kLRweQUWSQIX +EGfIYjXBBEKIIG42FqQmgwsuRHkmzBbIBgboTBpOOY9SrWbyISe1DWsK1ZrN+WSNMWet9x7IUE2Q +tTCeLFuRxKYsNpBXuJ4cuYdOeIfcWuIQ3xqceJrYXnAuYARyRc7l4M58oKLAA17A7xXH7meyCoBX +URt+tI1CAH4iLSW1C7lbIOaobJptsrc55yDQiKAg9zmpUyAbaOMEQTwkD7ntCEIhMMKEAAo32A2i +3TDeQbjhoAt5kq7kViwVIY6KgRmeNAdnfnUHbsiLt1V7IiElvFm5cdqePI8aZ6o5Jjd5WT8s7yjG +EPggkpWBBqJjFSeK2XXDhaQ0TWccVPc0m2zP06yJX96vdy4qzSM32ha1Piis6G35kFVaT1b769cM +TXfU7F1o9oDiSxiIbMx0Z9v0dlR7wSF2ctOwx1FtH0AUlI/D2oVsjBmxLusjCYmqdg== + + + AQjr+5Jliot4uYqH4Qwdf+mXDovhnmqMZbkniG1QZ54sWTRZsnHRha6moC0FRBa8DHURkdsoQh0n +xEPW8BayN77AAGdsRW0igRm+rOhD+FBZ7frhlgszbg4kpS3rPVqopsFryECh7gTblrfgpDqJUcEj +90DFmoDTaqCAuRtuSXpPVNu4TkGpQEWwYsVwRra3QOnhMni5iQ8CvSKBCwWXoYscCxvlKXJbUboK +Jk3CtAOEmxgR0jUHRVrw8Bb8iH8tuguQBaA+k/fIBpt8AAaHW9G0rhfMSo1dv7woRuPh6saLd8n+ +H7osqQNZmwhyVzO6UTCJwoWgNAtcjMjmyTYwE+fHcAipsdBLBkXbrj9g+UBRK7rZhYSGj4Nht+xd +snHOxOzVoEnAfQxXkUiAplFjXy9Oi6XdqHZgehPLA3a1nHDcGl20Jg/tYI4ccL3BbPuFWZzy0IfW +CCXvxTtOuNTdkVEkXq/ZPh0uHitGlwYEmeOgvIe8KjePSs0HijVXjAWoVpRjXkKUS8CHoLTtlbbs +YIFsybOxUZwrZk82upo9Mb1tr3IaVE/j+pkb7dnOaLb1RVA9zjGRpPXDymlYxfOHbrgraW1OqiBV +RLI3PgDbqlqj3j7tjB5WWyf19gPX3wKq5KhQs8ay1qXIDsZwvTWiCPsGsb2++WuRX+7gy5Lc1PRh +GB+axZlq9Ux36Je2VKvDCJFmDzFkPOxgCxNVa5+X6kdeZVs0OgmYd7ak6j3DmdrBNr6SAdqjoLQ7 +Wb2o9s6MYBE3jkvN05hs4V7VemdxfQfZpZmNRvegO76M63vrO/s/bLZvSnrbcce8CDY0QXzr3wjo +WsUl2IQQSmmXZKnaFlTgOSYTb2y6/mowedKbPlHMEaBGUNpw6OSWPVMUxIobzJrjy87sZn7w+uzZ +T1uTJ7I5VG1ooV46ByHUU42RH2wNx08avSsMULfH+fWCAMdFstaCOpLJDt5+qbZf7z6I6/tFf0R+ +YUdAJswkpceQLWqdYrQd1vaMIvhlSn4lR25IWssKZqa/csKdsHrQGl33FzduNHLCQdzYCeu7QX23 +1D5y40W5dWhHS7041pwBkEQx2prds7wp3tVoX+6ffNw/+1Dvnnqlbc2dIhZetPBLq3rvKm496s2+ +xJwIEtwH0COW1EYxnIOOg9qx6swVe9oYPPaiLcef6A4Se+BXjp1o3/J3zOJWrX6wd/qhWNrJUB4C +V66fBZVjs7g0iwskOV6smH033GaEME9byF4vmgSVeaVFxlJqnkAxilrb9ucFNuQI5BLKBgIgx4Ba +qtEvkN+IqQlSneHwTFhpnLVHN43hVb13jgemC8NEBQlqS7H7TrRyoq3W4GGtc45gOeE8R7m8UFJV +gElVMyd+tI8KrXXOhouXDx7/ojN7jOkttx4ElUOEfn78dn7ytjW58kqrcm21c/xi98Gb8fYTpAqQ +0PIXenGCj/DjpWH3O50TQChSy/bmeBgOoZLJ9qve7ElU3RsvrsvNHYoLebleDFf1zllrctNGdtkj +mq+E5S1BrWZyiqRWoyoga9UaXm8/+Pjg+S8ao0ftwdn1sx/70U6BbjjhUTE+9OKDZudqvv8+bpwj +V1MZjWVDSSw73qjaOQnrR5X2+fzgXW/+HHGsNHbny4eqOaQZaDNo7JZuLsLqg8bw2XD5ZTHa7fQv +UCAwdLLWCaon9d7j6fa765e/f/P137t4+M3Vs2/i5l4xXrQnV+3pw7h50B5f7Z99Onv+y1L7WDba +kl7XzFZY2QZADVcvpruvKq3jhy9/NT98Jbt92ewEpUW5sduePoraV5XBjVs7cMs77ckjXo7ytKGZ +7WrrdLj95XDvXX/nTX/7TbV9sXvytt7d80rj+uAirB0DqaL6SWd0PT/8Am90fOTqVoHzBbWmIcr+ +3I+34/pRd/p8tPpCtbq63fGjCS8HmlVzg3G9d9FfPusvns13Xu+ffA0JZ/sLy1sCbzH8Uv2k3jkf +zl9Otr9s9B4DacGVnFix3Em5cdwYXoa1g2Jp26/u1boP7GghWX0rXDnxll89aA4eYobnB1/a3lQQ +I0Wp8iyMgCerg7h8vHXybrr/crT1cnH8oTt5+PjVTzAzYE/Lmw22np08+e769c9vvvjF6eX7Um3l +hdPO6Eo1B7ozUaxxsbS3c/rtbO+L/vzJwdknFD7NhbrbB4pG9aPB/NnOg/dbD76a77189eG328ef +++WlqNYN8lstJ9Xe5eTgTWf6tNY+m+9/yat1XihWakvL6ebymmF3BvMnD1788sGz71++/+2f/yf/ +bVje86Ljvcuft8fPZH2smrNi6UCz5xzZthQAqWjWAxWWG1vVzlFzCHx4FjdORK0zGF/+s//qf6x0 +TjN5My5v7R1/iKuIF4Dxi0rnGsD79MXPZauXo4oOlFXzdLR8Pdl6u3XycbLz8ot3v33/s79nh4tm +9+Lw8tsHj787vfl26+TLk6ffX77+g6PTr//yr/+bwQrw26639obLF7O9L5eHb/cvP50++/ny8NXl +o/fPPvwBiHX35NXFi+/7q8+Dxsn2g6+vvvij8eGnqLpsDneL5bGoVi1/GdaPa8OHtcHlaPvlZO/z +Umt3efS4s7j2y1tRbU8vDuL6bqV1WGkeHpx/3508k826FQzq3WPLh7KaEhyuHsb1k0b/0XT7y9ne +m3JjWWlsFaN5qXnYmTxsDa9Gyyer/Rcv3/368ul3QEvbG/fmj1cHXxxeflzufzFevepMnxfDnePj +D6cPf8RLJd1uIyWmu2+Gy+ftyc3x9XcXNz/7/jf/cPvoDac0kfOl5jnSvta5DOtXlc7LxcG3bnEm +ilXV6Ol2rz18EDX2msPzUvOg3j2ZbD0vRltgsVLj2A0mrf7pZOtpZ3QZxFPdbIENt47eB+Xd1uAc +V2v7s/bwYrh6Uu09UOxZ1DiY7z3rTS8cf9BfPIprW53hyfbJm/78pto+nO48+f2f/2c4lRtMDy++ +Pn/+i62zj4PVs2b/3Pa2IGin8+ev3v7t3vhCkL2wNJlvPz5++PXpk097l9+ePf+1X9qLK6emO8nk +NMiDcvv64PoXu2fftScv2vOXLSIqjsazy/nWNSv4NBdBabvl/ZCQ+0mje0HQNRgud562+g9gz73y +UW34uNS57M4f13unBc4r0A7Ul6pXvHBeqh23hg8Hq+fTvXej3bfwfeXqYb13Uu1sDRbn3elVY3hW +be+dHD7/Z3/z38/2nvFyqdrcO7n61cnVr4+uvj998n19eLFc3fzVX/6nf/+/+OdQKQcXH85f/Hr/ +6ifzow/HN9+fPP5ZXD/+7kd/+y/+0d9U+7uZgu34W9XW+WD5/PD609O3v1seffHg7M0/+Wf/9Xjn +KXJgsftyuHyClLv5/Dff/Pwfvv72rxvdx8eHLy+uPyI9iuEsqiGpjjvjxztn39y8/ZPPf/QPVsdf +P3327cX1l6Y3KDX2Ku0Tv7wTVnbbw/PHX/7Rkw9/Bl6o1A+QeLrdxRmcYA77ySt9Tu41uw+3T94p +etlwWlF1CyGGtAiqkKC723uf/9Gf/dOj87eq3ds6/W66/6E/f3by+KeTw09B42FQe6Cb/XrjTDE6 +olKpN/c7o4uLZ989ev3LvcuPFtSLNdrZ+fx3f/Kf216v1TvYOX67c/LRq+zh2trD6/boIURpvX1c +bR3QvCdrFYAzBtUcPDq/+fE3v/grgPmzp98+e/kj1x82uweDxaPR6sXR1Tfvf/Knv/s7/wQY8uTm +qz/5y39y9PBreCJJ78AswC/3p++Wxz9ZHX9bru0/e/bh0ze/bLYWCgJd2vIqJ3Hrstl/dP7s97Xu +tSDXSvU98ClKwI/B+KtK9zIo7/TGl7/6479++e5nnBRDdCn6YLj1RXfxIqwdKfqo6C0/fvzDP/nz +f1qu7NjFCTKqNXvaW3x+9PBnujPkxFjR6pwYCWIQRMtKEyX2AmEa7b6v9R+raudg/8u4OmUly/bb +3fHVfOfl9uGL1d7N8fkXTjjM0WYQjyeLl+Pl697kKVjMr66my4cff/S3H7/9haTVRqsng60XzfHD +rQefelsvS61TRPmbT7//+e//ftxYpPO2FwGRTqL6HpJ2+/QdJu3y6qt//i/+5/0HX/rh5OGT7778 +8V+evfrN9ee//uLTnz549hsv3Pnxx9/97Jd/pZrdqLKHDx0vX/SnTybbL/YuPi2O3nrlrQ9f/+bR +04+G2+vPH412Xta6F43e5Wzn9eMv/3jv6vtK88HZ5Te6O0hmVGC+F8HWrTRnAa/hhvv9yXWvv7dY +XStG3Qeht47BiW60anTOd07fR41d3eltPfjGr2wbLlTESitO00wpx9csb6s9eMoIMfRks30YV7d2 +Tl4fXn1ojq81iEltMJ0+/vUf/eOwOu1Pz05vfrQ6elfunBWjmRfPFauvOiOMotY6EdVSMRpG1e0S +qqa2X27sDCZXEE4X52+uHr6H8lnuvTh++Ong8tPBxfujyy93Dp5Wq1t/+Xf/0f/0v/zvT7/4GcXF +it4xnQnSpjt93Zlizh9oevs3v/6L//Jv/rvx5BgSbr7/FUpjfvhx/+qXxze/gQjUTWivb4aLmzz5 +neLAcMejrc+7k5u90/d/+Pf/5vGbX9Rau5PlQ5aPNGfklnZ0Zwy6Gc2fvfryD568+L7ojRfbj/rz +C83pSlrXdBbl+kl/9mIwfSrK1Wp5VW8eyHoDUxc3iTtzo33THlVru4IcFhjdchutwdH+6Zsnb349 +2HoKf5EtODnKlPWSapSjyrI9eNibv1wcvX5w893zD39UAWG5/cnqkV+eFEvj5+//7OL5L8fbL0eL +J/Pdl8ATToapD4PqvmK2VKPR6J8hDbZPvjy4/Gr37HVQXyp6XG2uOuOz4fazxdG78d4XXuVQ0VvN +1k6jfQAv4IWLSm3fsXuSVCqVVsvDLyZ7r8rtg9ne5/3FE7PYa/aOkQx2MHHChRMtFLNB86Eglr/+ +8Dvy2z0pWZIbKDeic2wojaGkdRSj1WjvzrZuQAHj+aPrV7/dOv5xpXVz9OC7+dE7v7YzWz357rd/ +bfrDH36zQ9b6trdd6T6ZHf+s3nuYZzzNbI5mD+Gh+rObnbMPh1c/efLydzfPfjVevuqMHgXB8N2H +P9g+eEbzvmR2ZL1tuMDei1LrAoBQbp2YTvP1Fz8ZjR4o8In+sjO8qrTOwVzl5tlw+arR2D+7+tib +XiF1AbmG3QVIhuF8tni42n1sul1JqStaA+kdV/fLrTOvtNcdP2p2H7Q7p83GnuP09o/ejHde+bUD +J1ytl5Vqgtx2/e3zm5+F1W1WLIMf/fLu1uFXq6O3q8Mvd47eFcOtwfDBtz/9M9OsO8Gyv3qFolgc +fvXw7R+eP/2uB6God77/1d85u/qCJoa0Ua5fWsWBbFRpwYe38sOlUxxDkVreqFje70wej7Y/R8GS +jZpyzXEHtfoyT+ks75Hfp/ZWXulQM5eWC0mzylOWrASl6qTa2a609zrTh7BFfmW3Mw== + + + vKw0DoJwuJhdPHz5k+b4zPLHljcpRsu4chiUj6qd697ipVEcgI6Hk+v53qvZ3svZwRdWvBT0+jpd +TwU17HZ333z801cf/850761f2hYVzEYN3pz81g8TptMyTVmW3QU1V9oHUXOv2juRzAZQ5eDsa0TT +dAet/vnq6ANQcbK6iSozw2nQnJfLWzTjZfNyrmBUantbB2+mO2+Wxz+qDK7ghXk5DOL5eP68XD9V +jDFEu1Hsy0Z9uft0dfiKlSNcQLV2ouotSamY/kzzV8BAsl4RL8PSFitEk+XL8ye/7AxvRtOr3aPX +9e45AleJZ+/f/0Grs8qzTq1/OVi+3nnw3cnVz8uNM92dy0YnCCdfv/9tr3coStXB5Prs4Y9We687 +w0ed4RPDmbRaR4fH72SlXm8c3Lz83f7Zd432RRTvxuU9051ipP3Jpev3ECndaNY7J5Xm0e7R27PH +P7WLM6pgxX73z//iH5fLK04o6/agGMyLwbLZvd47/XT+6KdQ7IP+wfmTH9nBlBN9QfQUtcLzZZYt +SWJDlsja5vWjH3XGDxkBnjrgpDIrlGmuZjpLN9zN5Oz7Gyy8dhgfptIi2dvGeVCebriw3JHnDJ4/ +/WlzcsoqgahXJa2BrA7LB2FpVzfquayqqc24dlgs7zV6KJxzSe2Dghk20PWG63VNq9rpHUb1Xa+y +U+1dzPdfVxt7rebu569+en7zwXDrqlHrDE4PTr86vvhmQOzGcTHekvQm5nMwugSh20XwxauLJ786 +OPv44s0fPnn9WzfsT0f7b97/ejC/AN0w5NYhWVirt87bPXj2Ps3GptUX5JimTdvtTHZePHjy/d7p +O9irV+/+/OTyu07n6OmTH++fvneCieH2MSE4Dy9Xo/DAMkc0uaHpGFYjKE2hqOP2mWgMVXsEw44S +sP2JqFZMp7/YftPqERy2i0RFFChblEqeN8llxFSKIShRPxzOnk63XrQgv/WWrDUW26/2T79GIahm +EzKgP3veGlyRP59itzgRc96qd49sf6Tb/bX4H1dbZ7Otl4enn2x3wvGhotSqtR3UMurdLo6hVWCW +49qJZY0Fvqyb7WK4UK2hao2j6uHW4bvzm5+fPvzZaPEcXJAr6CznMJwlSJFu9UrNo+7oCvMQBuO4 +NMtkDTyJ8gGqu/5U07u60bOsocD6x3s33/7kzwQlTCQouqBpcjmCTKruimIlnzOLTvdf/A//69Xl +59msJIlBtYkzXNWa173hs97oCfljEVmtXt+HjspkVUwsD6GFunO7bjgqlWdPnn4cbD9gFVdzauXW +dtRYuTEi0sMABS5oNg5LtV1wmazXMOesEMpqTTM6xWBmk0lrvnr9/Xh1HdVXhj9U7KZqVIN4OIDd +K00lyY+C4Wz1aDK/DMszQYmzlAX4hblrDx/X2yeoFL+0GixeHF99hFAZzi+i2lxQ/f2DqzeffuXF +/WRG0a2ZGx9ElSM/nGN+aL4EydobP3GjHsvqftCd7T7bP39/9ewnR1efVgcvK43tZnP1zTe/evfN +7zIFU9G7brDthbu15qljjwWhxCOIakXVqogCctst79jhXrF02J+9Hq/eKma3wFhRadjsHDpeB+OF +LrXsgWUNLKMvcHE2xVM5UZZC0+5E5W04NagLlo+L/jwq73rRnGLd7visM3tU6Z4axS5MkyDGcWm+ +2H4Je5jNabmcbtpDFG+rezZdPK83T9a/AqOrWmMwvs5kFcvtVBq7s92XxfKOZvcZzqcZFzwoaVVe +rkT1o+2TT4cX3+4ef9Ub3+jWhOGrmBlcD8OavFA0rHatc3L27Oc7J59qrXOrOMLJRbVsej3L6zre +MIp32t3zbu/Kg4IyGq7bTWfldEpgCprA2rpaoymHbCbMm4E3+vj+V73GMpMSDa0RVfcsd+w4E8Po +KGojl7MEvtTvXZjmwHIHBVrnBNRsrdYmln/n/Mlw53Swfbx1cvXw86+evv909OR12J5aYa/W2o/j +Va22b5jtPG3wgqvrJT/olWuLamsVVEZhbdyb7v/0V39+9epjb3Goe00z6Na7y+XRw9rsiJWKeP1o +eFhrLPIF2bKBPFA+3mDyaLb/rtQ5l62mF7Z688NSZ1nqzMyozRux4dfLvcHO9fXg4Fz166pdI8vj +dpvhi6k0TbMWErs9ON86fONGLU0vOn4tbs6MYtUrdaLGxI66tc7y6Pzm4sUX5f5CNEpRdadcP1r/ +noKXTLKpJMcybm9w1upC5KB8YhRyZ/oobp7AJSl2V9BqilVt9BfFUpuRHU71raA33XmuGb183kon +OYkr2nrNMpqyXGI5j2KLglzyo3mpfaI6AxCHopVff/XTm9ffVLqLLCNTQjGs7lWax6rRTqWEdFrM +5XVJLitqPV8gfwmBon2nCErdb/YuKvUjLxh/8f77x68+DJbHmlPPMToUQthY2vGIlT3TrQ0WV7Y/ +NosjpDQ4WjVG2/sfTy5+Wqru5CkNqWU57Ub30IuHbjjxwlkQTcPKdLLzcLL3qNpetvsHncFlf3zT +aJ3mMvr9z3Kbm6xhdqqVbZY2E5uFVJKnC57vzWbzJ4PhI9MaZbNGJi3LSuwEg80Ul0hzqYxkOrPe +/0nSe3jJcZV5w//At5Y0M93TOVRXzlVdXd3V1Tnn3NPTk3PUBGWNJCtZ2bJkS05Yjhhsgg3GgMEG +2+Al52zAYGMwyy6Zhd332/d7z3u+p8Q5dXQ0sqe7qu7z/ELVvb+b2xtPzDNU1mEXFbUsyYl8vjm/ +sLG+9/CJM5duPvLoY88++7HPfvIr3/zaO+/8+q//+Y/3/v1P3/jej+++77Hm6Dqc2/DtOWAkHsmC +1s22auV+szPbH5tdXts6dueZ+x959J6Hbp27ef+R8xdPX7l294OPXr/3kc+/8oXPvP76ysbB9Y1j +xeo4KAGMCPmDxYBWYYRoIJAsV7qT0wvLq3uPnDh24frVBx9/9Knnnzt3/0Mnr9y49vCTH/nkJ177 +8htf+tZ3v/DVb37guU8ubhyRAikUV1xuhsD8ulaOJ2qyEo6nCr2x2YW1A1NLG62xyfH55enV7c3D +J558+pkfv/mTX/3m169+5Svn7r5vdHw1kWy6XILLLnlcCoGFE/GRcnmeJMM2GyXwsW5/udGbz1XH +k8WRXH1849BdF649ePORxz/z6qs3bj1x9wOPXrv1pBqpgJQCuHPaWYFNi0JR9tdEKU+Qmh6rJLP1 +YqXV6ExPz+87fOLSY+9/9smnn/7qt77987ff+cJXv3bm8rXpuf3lyiQvZjxe1e2RAYIYNg5qFj7Q +4RAwTI8l+tX2SiLXTeRaR0+d/8DHPvbERz58z4MP3P/oU1fve+jS9ZsPPP7+L3z9Wx9+4YXrN+4/ +cuYKJ2XcbsHlZGk6rKjVSHRUlkqJZDcYLMTjzUZzdu++4xNTk0eO3XnnXRcv3H3PZz/3+d/94c// +/sc//+GPf3r73Xef/tDzxeLokAkzmShoOl0fz2aXbFbBaiEQjyAKaYpOe5EQgigUrTNsNJ1ubm8f +O3PxnqOnL129+fATH3z24JGzvanD9e6GKGWNuaz/4uJprVsfX13cPH74+KVzd33gqUdfe/WVn7/1 +i1//9jc//cXP3n777f/6+99/87t/+8K/funZjz6/vv/OUnPNg4QRTzACrlxOJPV0ByzE1s7JO89e +uHT5iSeeeP2NL33xq19/8XOvfOiFj33pa19785e/euW1L37r69/4+9///uqXvvGBj37qyKkrifRI +vjjV6a/mq+Oqls1mynMz02dP7zz8wPWPfOQDL37641/91lffee+9b7354y984xvf/tFP/vSnP/+f +//t///yfcCa/+9YPf/jAE0+3x1bD0SYAJklIUS1VK7eXl1fg2NzavnT33R/88LMvvfKp5z79iWdf +/MRLr77ygzd/9Itf/vz3//Hb//nf//POb9770Ec/dubcPbn8qMQVGCKjh3u54pIP1VCvpCkpAO7t +rf1X77n2yONPPPL0Bx9+6ulX3/jK93/y5g9/+uaf//bnv/znP375q9/85re/ffULX97afy6Tm+L5 +YlDtcHw+HB/RIvVWc3phYe/BQzv3P3jz8aff/5EXXvzsa6/94Kc/+/mv3nnz7bd/+et3//SXP/6v +//d/oFu//+NffOblL2WLEzYHC5zodPJ2Y4akQlJxJVDMZTvre/fffPihm489/NynX/jhWz/76du/ +/PJ3vvnaV95457133/3tr3/y1pt/+NMf/r//879/896vX/zsS6fvupzKtBgG9DZmtxMIIglcrFyc +mBhbOXTgxPV7H3jk8cc//8VXf/Tzn33zB9/90je/9ts//P5v//Vf77737jvvvvX3//77T3758wdv +PdbpLefLC0qw6XQak5+HzThH6QIb0bVSpTIJmqQ7MrXv8LGb73v4Uy996s23fv7r3/3uja9/9Wdv +//J//c///Olvf/vUKy/feuKxu++5oWkNjiuzRKDfmlhb2HvnoaNXzp+6cf38U4/d+MobL//Hv/8G +Kvqdd3/xs5997+XPfezy5TPLy8uZfCMca6No2OuRGTIo0AHNH6rlSvs3tu69du9DDz/4yK2HP/bc +h77/g+999/vfe/2N177xja/96S9/+dHPf/rZVz7z8udfPn/l3vnlw83Ogt+fienVfHEkk60nk6WZ +icX15dV960v3XTz9r6+//KUvvfr1b37pnXd/+Ye//u3NX7795i9+/t57v/rPf/z1vf947yvf/vL9 +t+6bX9mIJOqSPyPKCb8YrhTqM1OLx3ZOHjl85PD+ffdevfTqq595660fv/3rX33vzTe/8s0v//zt +H//b795999dv/ebX0Cw//dyrr1y6cq3anCZwjcC0oFqNJcYpMsbRWkRN1wu1rbWlJ9/3wBuvf/4b +3/7mS5//zI/e/OEf//ynv/3j72+98+M//uG3P33rR5/97Mde+uyLB3ZOq+EyyCEAK3+gFI42ItFq +f3RmemLmyKHDH3j68U+8+PynP/vJlz//0o9+8oP//O//+rc//uHNX7z57e+88ac//u43v3vv1S++ +/uQTTzXbi4gvCMbNbqVdDgHxBgQ+XS1PF/OdfZvbT77/iY9/+uOf/Nxnf/jTH//xr3/649/++oOf +/vDtd9/645/+499//9s3f/b9X/3qzZ+8+Z2nP/D4xctXUumGIEZdbgJKK6DmtFA+ppeX5tYeeuCh +L3zxiz9880ff+u7X3/u3d//4lz+++96vf/Grt//6tz/D53z3e1/5wY++8ZOffu/pp586dvry8r67 +BH/BZMLdTtnt5DCEd9owCpNHOlN3njj54EMPfObzL7/8Gozmp3/ww2//47//8dvf/+6H0HY/+QEM +1IsvPX/u3Nm1le2w3iyVV0NSvFnu1Er1Yjo7Nj6ysDQ3NdnbWJu6dvXYI49cvHr3sbtOHyoVk8GA +SJMMgtAoItithN2KO+046ROj/ngpXupU2qOd9tbe1c2N5fmZkRPHVu+/ceLWQ+cvXw== + + + Onvl6pXjZ071J6fCekqSs+EoaO+ix8UibpZAeQpjQbgc2X9y79592USylUvtX50+f/rgAzcvPPnk +ta9/+XM/A7h5+6fv/uZnL3zq2VNnj45NjYe0uBrMUWBdfRKKyhIfPrTvxMmTl+rNsXK5MdntrM+O +nzq694WPvO+b33j97Xfeeu/f3vnmt1//4msvfv4zH37+mZuPP3Du4ObeVms8pJddLo4gQh7EP2wF +X4PZbKTbSSmsUoxH9y3N3brn/OuffeG1L37m1Vee/fEP/vXPf/7dpz/1wStn9h/aO9ttNIvFKo5z +DjtGUyE4UEyBgyIVlhSioUSj1Fqdnr90/MDTj9/4+Ecf+9fXXnjrre//++9//Ze//v6nP37j+Q89 +fPHC4Xq1gKEs6guQRMRuA0ljTFEeNvkIxB9V83E1PTk6vjg3s7Nz6Pxdp65euuvmPRde+dSHvv61 +1z732Y+/9MIHP/GRxz7/0nOP3Xf5+PZmNlWh6IDby3q9Ao6pDBtJp0eCaobwcXEtubWyce891194 +7sPPPPXovVcuf+ipx7/3nW984+uvPXrj9Icfvvqhx26cPXl4c2Wh1xzJZDrt3pYWbpnNmGWYwlDd +4xacNhz1MNlYcXt59d7L5z73youvvvaZDz3z2NNP3P/SC89+7zvf/cRzz9136eL64nKlVOVoBUP9 +LrfssNEOK+J1U6iXITFeVbPJZLPdmpqeWaF5CfGBtmTdHtblYnyIRBBBh4Ma2GOxDftQj0xgAZ9H +oFA/bRwCS0vRcFYLJn0eDPH4fF6cpUWG8fP+jAtRLDbc6WAwY52CanPiQyZwtSjuExE3gyGCrIBJ +CXOcEhAVyoeKFJ2JRoq59PjoyP6DhxeWl+LxOIyjzY5ZbCiYDpDKTqdgszN2By2KiVCowLJhHJd5 +Vo2oOtjRiBrMxKOpeKJQrPTHp8OhcFKPjNTrtWwmxMmYhwXXjGFBholp0Q7FJnfvsYPaCchFmUtr +UqyRLZXiqVRQTajB9fmFXj1XTkdGW/VErMCxCsdqFJX0IarNQliHfRazZ9jkMpu8/0yyYuiEX8iV +s/10pFiK565dOr+zb6OaivVrlXquMN1pzrQr+UTB5yEGB4ZNgy7rMDa4xz444LQMY4BdiMdP42FF +yuhgs6KZZDwncgGf2yexSkIrhOR4PlkabU6Mt8YVXkiFEyExQqGiw04PDRNDw6TTrUhS0e8vMEwY +8XI+D3SuHtGr0NQin6431maXzoxNHPZLUdTlDkv+dDihCkHcB4CJQxWJcrHRPRwIdi0W6o7/xwRC +FMd0l5OjUIUj/BElktaTiXA0E8uDfOd8hIBzASGpyjlNLYa1htMJnSKHIy3RX9l9hw1KxWTy2G0E +4uZIMsbzmWJ+bPvwFRciO12gLZMsl+OFAvhKgoi4PX64AyhiPCsbGLDBMWTyDJsx1CvTZFQNVEUx +zzMJio4aQVJ20mrHvGjQi+hwz1kqifmCwxbE6aJcHgGEDYHKHjfjcNAEHWekrBQo+P1Zj4f0ekiK +kDBUoChVlNMIpoD3x4kYtNJuY3GfG7Su1xvAsBBOqBStOZyM3U57PKLVijmdpMNBEJgKHlkSczQd +Z7k0igYCckwQtcEh69CAy+vy01QMaJ1icmp4nCDTZjMOGtjr4YfNyPCQ22nx2ofd9mGXz00H/VmB +DZGYSGJBp1MG922x0v9cWm63CRga9rhEqxlzGCuVBKtddHlDdqcMHEeSWj7X3d48mo4XbGa7gPtF +UhdIjYLLAYwacJpNPtynm03IrjtMpiEPjoZsNgYOaHm3V4HzYaHy9Y7PF4CzCqjldHZGVWvhQIHy +KV4X63XSY51VltIA7uCjUDJLcBVWqMr+CkZEnB7ZDR19O/zWH2gFwmOJ7GqmuNwc3VH1UYsFOE4o +pLs+r7x7l2XYSLSQVaXRHzvaaB8gyNTAHvfwkCefGsXQ0J4BN4ym3c6iSNAvV1Lp6Vh0zGGlTQNO +3AukKdislMclez1BFIuBa4avU0Mjg4PIkMllMjvNw65hs9sLvpWMs8aD6zGSjCeioIXGOSHDsBmf +T0OxCGlMaw8gqO7yBnbvtgwM2OFLrRaaQMMcneK4DJRfMTdbrq0NDnmHhlww6BSbkgMd0V+Hj0W8 +foEJN+ozDJ8ymbxms8diQbxeOZ6aC0bHpECNYeKJRCUUzrk9HPyuzQaAGfQgEUFqZPJbPhgIs8/j +AiPdhI+y2SmLFYOq8/qCglQQhbLFCEYjAcpQVAWE9PmCcMecTpHAY2qwTrIxk9njdit+f0MJ1Egq +6UbCBJ23OWTzMAHlZ7eTu42VC3ar2Wsxe+1WjMBC0G4+JAAg6XBIu27Hfbhcfo8n7HIZmQMkmfQi +ms0KUkH1IEEjSc9Mma083CtNb8fTPR+mwpUOm7wUqkEFDuy2Dxhr1XEw7x53QA/2vW7NbEbhsFjw +wQGXxUrBHTYmGOCxoNYPRaZcboVhdFWrEUwCats+TA0Z89sRHAlWC0ssHTEPeWhSp7mi0x20OxWH +kRaVUUKjUqDl8QZxPAQmpdLaH03NYngSJ1N2h2wyIYqY6Y0cRJHQnt0OnIxRVEpgM6q/6EOCoN73 +7LI5rfjMxH6CiJqHKYKMI1iEoNJ+pZPKLgtC1WKmrMOkD1GgNUxDbq9boMg4J9Y4seFXRzi+aERQ +In5RijJSzDSMWG2skQIqlKRgPRwdrXe3krkJmotzUp7hckqo5Q91STbvQnT77fWt0Owu9+01/gM+ +AotiWBTxhUQhLwdqg0OIUQaIhFFRv9Yh+JzNJcKPiWh5YemwoJTNcA89MopBqYfAE8HQOJ0c8OO+ +zZ2p+S0oLQRgjUjQdI6isrxQEeUWVDvHREPBksfDDQ66YCx8PoWk47xcC8enFLWPY7FUciyo1eBa +DAp28SgaAmDh+QJ0oter0lioUpyhmCSMoNmEDptptyfsdGtOl6pFeiC69gw4waGQQP020umgEK88 +DINuREQGKSoNIOB0wVnFUV/U7QkOmRGrnUXwVCDUTWUnWSFrd4hGvplHc3mCIO8pOg7dYTKTHFug +yeTuOywDu0F/qIoywvMVjztkZC+bSHATHBuH8/G6ZbuDd9yeiOL2BIxIExTujD4xdajamvfhIThz +hs5SRIIikiSRdLtV+C1gVa+bdzgANo3J2B5fLJ5enlu9r9TYdnpUuAmckEYxIzAN8caNBVZqLRQs +y2JJFEoEHnHYjTmoVqOw7UODHvOQb3DAYCK3S1DVsg8NQ61yfMYK8sMOFCMYS892w/+Jer1BxBu8 +419McAK4z49jmnmYMw0LQ2Zu94BvzyAGMnJz/dTUyokhK2Fx8BRflcOT0fxKurIWjI9xYn60tXz0 +zA0fHbG6OKtTcCNRH5bk+EZAm7E6FcAEr1u5bSj8NJ1i6BSOww2J+vAYIAlOqbQQJbgUSsdpsSCq +ZZyOU3zOr/WiqUVBrgJ0s3wCwY2FYH6QOkoBI0NeTAXmJQgDowYGnQODbpudhfJjmJQk5CkK2BYH +TgGIBh4HbHd6gl4sRTJVTqyKUlnyV+Eydb3qcnMWCwofBRiCEwmSSmnB6sb6KY5PDpmQ4WHUh4RJ +MsMwBYYt4lQSbh3Y3sOHLiTTXaN0h1GvSwRNxQslaEO3SwZQlZQyQemDJo/J7LPaSJdHwqmEP9hA +sBDDpaaXjsuh2q49zl27HE6HhGI6jscCaj0aG3U6xOEhhERVmk3sGfDePhA4vN6IqrYieocXMqJU +cHlk0zBuc7BOt4QTSfjqYm3v+OJphocak1qd1VJtDUFCwxbaZCIsw7THLVFECBhzaNBNkNF4aiaa +mvHhcWP5lTvAKbVcfbszuSP6SwBWJF2Ae06zaYeDcTlZm4W6vdBPBX4fAtVnpYwFJk4R9YUQj+K0 +88NG7gTj9gYXFk8rcnbXLqvJhAGKKnKLwNI4lnS5gC69DjsHHziwx2qz4qBVoClcHpXz10CiJJMj +Ab1iBn/kU31UHOcywcQEJRYwOq6o1bXVs8cuPuKjdJQIy2o9rI9H9PFEYlrWRgaHSYaMTvT2S3Jp +zx6AEQoqGccSwVC3P3WqVF+PxWqHjl5i5AIlZGLZiXRlOVtbLTQ38+0DYrCD07FEpP7E4x/uzx2A +lvR6JY/X7/VpDFeMxGYEqe4w0uBVAA2vEZ6TwoiMD8+QVEENjqjhrtMtmkxu1JgRZKzO8Pg0DI/D +wTBZUSrmCvOimA1rlZDeQVCNF0t+rcsrNR+VdHpVpzsAZwuq6fYi3ADD5TV9hKGSIBTVUB5B/T7E +T5E61JXdxiE+jSBjIJ8wMkqyaVbMAQVDF1utJKh3yzBOUwmGTQW0Vm18B2XTJouRkgEg6UNV0GZQ +fk63HxiHBrWJQmtju3a7BgYRKA+3SyXJgiDUQJ8IUpUXyxSbQckYzWdB3LqN4Cmd5XOCUnE6eIGJ +XLzwgCSnATRMJp/HowAd01ScIMKgtRwOjmNTLJsgSR1OJp4eT5UXxHArlBxnxQJORoOhBobppiHU +Msx4PRqOp3iuLgptl0sbtnA4Go5EuqB8QEvDdQ0NegcHvHB6BJELhnvJ9AxYDAvYFmM1GY94gsai +MKvo9mqCXNHjfdC0kpAMqHGrzWu143YHZwTI+IwXr0BbDo/EygWcS7qxUCgxLodHIonJ1sjh1tjx +eGGW45LJZC+cGCEp6ETVhymA20MWAj6zVl0RZCMnx4eEKOPuxSSpUKgsRZKj2ezYzsl7GX+OVbLF +9lq9f7AxfjDXWEuVVyg+T7GxXnvh1c995cjZ6y6viKGqIBREqRZPLmYLGyxfUZSa0aSobiwExtKc +1FbCU/HsZq17Zzg54wG/iSqhUA1BwzanaAUHSkQEuQSajWKzgXC3Upm7dPnWxPydDhd4n4KWmFBj +k7zaDYQnwtFZUCYuj5/isrdTdMLGGgdX0GE1ogM8bn8y3pOkPNS2xcJQREQNlBk+x8tVOdgs1dfS +xUUfHna6ABVxq4UEXScHKrHcbKaxTUkVzl+V1Q7oN5uNMN4Vak34RT02EU9MQakMGHHuPvgWQACb +DaxKnuNLLF+kOSPQhhHLQqDFylVoZOvtMHyMSMAV+QPlsFYbG13FMD/UM4CVKIBUSEGBmczo4KBb +4LM8l4RvtFpQhgonUt1IaoQSsqreY4QSw+aCoRbNpIwkKyM1N4H49NtpAKrNCJGL+6VyOjUBvOBx +ywgSsAOPD6EUmcKJFMVkAPYB04BWXG7pjjvMg0bSDoirFM/nJX8Jrh0IN6K3wJcPDlqtVmAKCQbF +AZiPRcErhWOTlc6hYGQknOwLwbocbvsj3UhmSgq2QV30q4v3X396dO4Q6HMwLwiYFG9AlMuBUEtR +W1Y77bLTOB51OCWzmXR7BBDqeqKfKiwk8rMkE1bUbHVkzZhsLOeMtQbRXqa40OxsjU/vbB66xoox +LyqEQg0jN1Usw1khUDaErkV70dy0w+M3mXE9Ot0YPd6c2IlkZymu4MXjLgSwqJAtzA== + + + SmqV5NI0n+ZEkK81JdwAHg9EG9FMp95djGb7OK40Wivji3dVekdZucH7m3DYnHKvs3b52vsz+f6w +lQL9iWIlDCsmEgvZwr5YctZQcXxGCVZBxgyDELXTWnx8cvbkzulbpeYmSkSWl3cmpw5Cj/NCKltd +KHa3SyMHx+bPLW49lK8eABVK0WFRyeNMFFQc8CZO52xG8IVkszPG8nAz5vEA9YdcbmMJp49McYFW +rLweSi/6yLQPVxW1zMtFwDGaywhywa81MuUFVW+BhgFsAWtmtTIuY4YD4/X6Pd6AeRi3WsEdKzaL +zwWemtSB5UPRvp6cpvgSyRb8wV65dTCdX7PZxcFBrw+NMVwJJ9OCWEINqRyjGCiVMiAhRcWsFuNt +ppHY4wFzl2bZfEhrg4G94w6TxYwOm3zmIQSgDJwFy4ETTzNsniRiDhtwtGgz8BwFmUexaV4qpQpz +yfz8+Nihu699MBxrM0ImV9sbTcPAtdojB0f6RzKVVZtHNpsxik5QwJtoWBSKFJM2ymkYSjqTKUzh +VBSuVxAygXBLi/cTxQU1MqoopbHRjUs3nnF5ZbhFyfxiwWj8+UJjPV9f15OTCKrKMlBSy2oDa0/h +RBQKLJaam9u43Jo86sXCdhtNUBEXolodvNlKAsgISjNV3Du3ekWPjYSj3VRxGqPDZiuKEloo2p5e +vfPijadOXLzVnT7C+XPpWGVz3zlFb5isNErFE7mpZGGWV9qp/EJvYkMJ5p2uQKa0qUWnSDonyQ3B +X3N5FSDcYnm+1lqDswIDDhJdVmv+YJ2TCzaX5PYqI5P7s5UZNyZr0WZ36uDY8vHm+GapvTeameb8 +BZaNfvRjr56+cAMlVRCHWnSm2Dmaax6QAyMWKwdj1G0trW9e3LUbTGtQVLup+kZj9mR77oyeX3Jh +kWCo/OxzL29snR62UOBqQ5F+pXt48+hDrdHjRnDcoEPkojSdGDJjw1YaKpbhq7zcAncGNsHloEki +RNExD6JCFxda2/Xxndmt64sH7m+PH2O5/J49SHdkOxTu2oyoVQy+Au4A0ER74mQ8Pecy0j9E0Ks8 +B95HAWcBeszm0kDQIpiRwg3qfQD0jwnDfRriDZBEHGS2D4kAV3o9oOdDAJ4EEYChtENxemSMCoPH +iSTHi40ljNY5qVBsbWeqG5H0fHPkUDg+acThWmkcVSQ54/XBnZcdRoCnZLHwbrceAMspFgAwRS6j +6VUEkz0+6fY0sHS+utKbvbO/dIZjE93uWqmx5KM0UF/RzFQoPsaIlXxltT5yIBwfBZXC8YVkZkaP +jUbi/VC8x8o1LxrlOOjc+MCQd88Q4vGqqcxMIrsQzy+HE5MEFQOwypZnRbXk8amivwIEVG0uHti5 +cuKuB2ZX76TFVKsxe+Xa48mskeydK68fOP6+qw+/OL5+XQqPo1QMhoah0pncvNXIecN9Rk6g5nDJ +GBFTwz0jH8BI5OZ8Pt3pEr1oGKWScqgZjk+ky4uBcL3Rnjtw9FIgVCfoiA/3E1wa57OcP5+vzu8/ +cTOVHzMej6Chem8HaNQfatkcss3BI4iSSY52uptAiyiq00KeEXO0UFTCY0p0NFma6c0cOXPt/d2p +Q4Mm0odHg5G+rLZJJg0eamiIBkjxSwVRzOzabbc5BTnUjyRX/KG+EhoFOQRem6INqPRhobUDF09d +fWzl4OX+/GktMQVQP2QG78NcvOfD2eIcSE2fL6pqXcQXo5l8KjcH3hb6yOPmc7m+JKTANu4CD2im +KKGmZ1djudVEdhnH0l5PSFEaPq82uMdhGsJvh6CS4CVBFDkcxgqgbn8N1Cycm3GxWBBqIxCdlDRj +YjCUlqTVCWOKWloMdDk/4FiZwHSOjlBkGEoIBwhFUxRZgsOHZnxYCmDWbucqxflUvm+k6g2j4IV5 +qVpsbNT7h7K1OU3NnTn9wMzijhv1x7NTs2uXJhYvlFsH+tMnR+dOyVrLbCEDwSZYXR8Qrk+GW0rQ +RcnfhXrg/cVBAGFj7xs9qDUpLoPRSZovYFRa8BurI2khywg5LTLCcElRSNQ7K63xA43x/fn63OzS +ibGZI0qwpkXatc5WvbvRHt9U46MuNGbEPjvFiNbO5uZMw+SQCeeEkqKN+tUO6CVerAEgu5wSSca8 +RgQlzvCFSHKqO32i0jkYz0wpSn5r+8T73v888CbcQxTTpEC31Njad/TGqbufbk8fg9J1uPloqhOM +9dyIenuzIWLYxvlQHYwJ4gu7XAInZBEjl5hwulVOasSzc5tHr16/9fGT9zwbKy5ZHBIr5OBWuJEg +jBSwGI6lRLHGCzUwOAODHoCmUHSKMpLhZTBBMHZA1n4Q7YQOCDA6sdXtrycyY+HEFCO1SL5EC2Wg +ks7kGZRMWW2iqo9Jas1IV7ByLrdq5NsPoohPzRfnEa+8Z5dp9x1mJ9wBYxH0OCfXESwyMMQ43Bq4 +KrPJeAJmt4kOh9/h9IOHQtGIEaONR9LlBRrXM+lRnAhbbBRcQiy3osZm5VAvXlyBPgK2lYznVA2C +ycLVgeYHqHTYeYddcDtlsC1w210OEXQplPrtWEI+FGo6jLgqDwyExc7BmTBCXjK2zKhEovV6azUY +qnNcamxmZ2LpZHVkbyBSo7koRuleVPN4AopSIbCQ08GCMpQDY+n8vkpzZ2z2gs8If2YYOhEMt0Aa +2Z0c2HMvWIZAV9V6oH45MdceWWs0lykyhPvkXGFyfu/5/ScfOHTy5qWbH652t0WxfNexazceeL/g +zyJYCCHiDFiGzGJ7dGdq7i4US+8e8A4ChhBJVR9VoJHRKHS3dZgGsQ1ezGXseST5g62A1vaDuqOT +OBEThWyuON1fOUkJBZcrUCytNVpH09m5ydmd6eWTrFRwOIWgWrj3kQ8FIiNDQ5Tbo3EiaPIexRad +bgWkPtCHFumCg7M5GF4oRJNTidxsd+LA0bM3FzfPsf5KKNQ6dvwq+D6XRwmE2vHUVDo7n8wsckLT +2A/LRtFUBIQW8NrgEOjnYKqwWO1tJwvzoNBQTI3F2w4nZ3OwUFrQBKuHb/aXLtTGjpJcfvceH+6L +HLnzIUpIASNAwTs9ugdJyIHRbHEzV9oeNJ5x2Z0OkqQig0PI7c3dRDe4daao6pO81IBvtFkwn08G +m2yzsggaIRnws/XplVM7Fx9zwRWxSQQJIogxe03RWoreCyXntPQizmYIPFLIzzAcWG8/DzjP50Sp +JAiAVCm3SwbvPzBgGxx0DQy4zEbaOXk7skx0OwMEFsXRoNNBC0LOH6rHMuOx3FSpvRmKjYIXjsRG +tGiFYAIUq1KMJghpXswG1Iauj3lA1jp5hgyjWNDuoEGgcmyapIyIP69XY+ksOGvwRNDsbo8M4AmE +NWxhgZo5vphMTwVCNQwLkHggGM4H9Fys2GtMbI7OHi1WFvL5mZXVU/nKJMlE9VgvW1kX1FYkNZ0u +rSnapNebQJCILJd4IQPiyg7e0MreFg9BmkyBv6DpAoaGQV0Pmhy7B6wejxzSupHYTKGyNbd5N2iw +gFJY27hLS/QBvhxO3nN7cQdNZ/TISKmxMjRMm00kz5YAFa12dmDIA4fdyXNCPhjuolDqXgFaj6Ki +TqcAQs7lUzzGLNBsq7N/cvYoeC5RyjY6WzSTdrskm4Wx3A73tlkpmo44HDRGhNzeIEVnQ3pPgpMJ +t1mpxPnLrd4WL+ZYLt7srNRG9sK/oHTG5Qu6kYDkr4Zj4LhXjKAhMIBqMxyb0SIzidyCpDSttgDU +ns3KtBvzkxN7jZg4M+byBHilligtl9v7/cHOwKBPC1az2Y7Z5Nmz2w5oAMJAj3Ylfx4awW5l3G4V +Dl7IcVKeZhPgy1Kl1UR+pdk/kSquqpGOB5XVYKXR3varNR8WcTiDYFodxmZ5lMVCDA/j5mHsn/sy +/DMNj8CSqFcnfXo0WJ6ZPUiwUVZMNSf2Hzrz6OHzT7RnTyrRMYpNhJTMwvTm7OxxWam4PKLDJSDG +28YwhgZ1rYqhitNJBvwZv5QBw4LhCa8vabMHbhcwbjfe2ZFDQ4CNGKAouBtBrPN8FXyEFw1wfKLW +mZ+Y3VjYe2LlwIXV7XNbR+6emD+erq1idLRcmty7fooT4m6vIMh5WWnSbFVWRlA04XYHgIvBXHvd +CuLVUDSOIhE3SCyPDDeZY9KCXGS4qF/J+rAATkYIOoXTKV6pqFqtVl84evy6FCiJUg6cBcNl5UA5 +GpsIBNo0kwUxHNHr5eKszcjBdlttvMeriVKVE4ocnydwPRSqAOrCfwUdBZY8kZlv9Q93p46sbV+F +v0Pvt9tLy+un/xku50MCmDEVh0Y8EsvGcDRQrEwJUgZADAoP2k0M1GKFhcb0yeXNe2Lx3srS4S9+ +9ft6tGexyjRbA0+RLy+fvvj4ifNPSsGRPQModI0gFOBboK1MRsYgY7OpfmUkGO77lQri9YNwcjo4 +p5O3OTirkzdZBbOxkYeihlqCnLU7aTDRNhtpsWAWY+4ZhxrTOYD3YwSdFRRwRhUwXNnyfCQ7FstN +55sb4fSMqLVBIbfam6sb9wS0htWI4DbCT1g6g2FRjzsAhAgsaSSTG5uj0ca1u1SP048jqq4V273F +UKRebczPbpzO1maytflofo5VWhiVDAfL68snFpYuorc30XC6OJJM8EKZZtOSVCSpuCRmcrkxggiB +1/YAejAVlqtRTM52O/zZGAUrBT0OtHL7bbjo8YZoLiEoeRjfWn3+mQ9/5qXXvzU+dwj+BWAzmp5s +9w+U6yuj3a3Z6QOqmlUDBSVQkf0VRW0RZM5mlQcHjC2WTEMIlJbDzg0b77A8gwPOYTNqHcZxVAsG +m92RrdnFY1YHA6oGMTbm00S1ksovZoorSrCBE1q3u1qqzLmNlH4ex0GRGq/AwJhn071iftw06DUP +oTgWAX/nQ9ThYcrhgJ5SWDYVCjegMIzHg2RS8hejqb6iNXixwAllgO5uZ6U/tmW1snAaNBUFJnU5 +eJ9XpoiwD/FHY00WPPKQG0VA84R5qeDXmioAiFzEsUA2VTt58m6AR5av5Qrb+dJWKNRJJvvR+AhB +Z0CEy3y2kB2HthoYdN3esyApiKOzC9dnVq5KSsNkIsAyALO7neyu3dbdxiYavN0RIogsGC6MjiC4 +6nILe/bY/wluDJ+J52fB9IHXjuUW9eQszeWTmQkt3vSQfiVSL3U22mOH1/dfO3HuibuuPrN15CYr +pDk+BTIDQcB1BoctxOCg22xCXE5AVIaikw4jJ4cFKnE7eRILYLgiqqlmd+nIyWv9+f0e+BHIMbdQ +ahwA1FXUajjSFpWawy2TbBKnIl4kAJBOswVBrFbqm40OWPW2xcpjwCwMoHqZpHIud9BiVywO5fYG +fxJO6NCqTicL/eL28OFoY37l+MrmmVJjfn75yNaR8wG9xPLxcHxE1ZsLqyc6/f0YEUF8UiCQWlo6 +msmMwG+Bg3a7g8azRCTG0CnEE/C6ZbPJN2wE5Rlhj3CNw2YfSIJItJdITcSTfVFKrQ== + + + rd/V7GygtM4Hq6Xuoeb4iUR+QQ01ZxeOV2oLAFNwQ2KJ8VhsXBQKQI42O20yeXfdYXXaWBQxMHlg +0GYyoV5PAEECoJdsxhsTgcRjdsOrer0+4NMU6IR8aTEYNN5ewflQRDTgLxgZboMegFO3U8DREIEZ +77gtwz6HDadwzW4HYMdMwzjICYlPiJwuiQmWTURinfNXHt/cf8ntCeB4QhDKwOnp/AIoWAKVWDp0 +O/kZJ4iY8TiULfJsQQuDDk/YLKQkRPVQCRTOHbusbq9Bc6B8zMZOWJjFSjrdIvCOachjteIgVADl +wNG4PQptuK04TsUYoQCtl6ssqVp+69C5meU7K7Xlbn97euXO3uxOPDfD8ulMtq8EC7dn5ihwBwYH +jBlHBGokg6kq2JZstb6OYGGzGfG4BZpNpkuzG0euHjn3SHt0+8KFhy7d+3Q40cOpBElnCColyFU9 +PlVpH+vOXtCSExyfrDf25morwUhbVusgpK02I984EOiB+9g94Ny9xzloJkiuyikjOJ2/HdMnsUwm +nZ+jmAjoyWR65MChc4+9/7nDJ6+mKnPBeJ8TiysbFxf23iWHij4iENK73f6+UmVe0+qZTFeS4jAc +4HwpOgV6xmY39hg1ds9xq0Z6AwbGMDCwx0Atp52RpYIa7NJsCSdSul5ZXD6cSLUoTtdTvYmV06sH +7+5MHyt1D0uhjtMl55Jjx8/cj9GhYSvmMiYng803AvRsw6zPrfr57NT41ur6mT17nHt2W+HzgQSD +kT7cEJyIA3aVS9PLa6fBCyO+EMVAO8doOob71GAQUD0GMM5RYVHKOOy03W7MnLGYcfgWj1tCPLJp +yOFDBI6LgRuCSssXx+ZWj04t7MSys9XmXkAqjk/PLp+i6bTDIRn5/1bWbuW9SFjw12kmCT1lNnkB +CaFuvW6JxMMECvoHhy81DyEggzk2tnuXZfcu8647zAN7bFDVwNF+IcOSWrUyHQfjYCMUOeP2+lkh +KwYbWgyU9kKzv1Nr753rr3zxS9/dOnwBPKMcqCbzU5HkOFy4Gh4nubTbK3F0dHHhTh8WHhq0D5sd +Djtmt1GAhKAqQc2KUlKQ0hge4YRCMNapdZa745ul8uSVy/edv/qQFm9QfC6RWYon56vN/Qsb1ybm +To9OHg2GO4loZ9+Bc1Iw4ULBWuoImgKeUtSu6G+7vSGbQwBTBg5l2C4PGxuB4WCRwGdF4jNadALM +2v7tu0ZG12S1oMVHMuXVWvfw5MK57cM3Tl59ptrbqrcWj9x5dzg5EdKbilpj2DT4YlDFgIeKv+X2 +ylab0XFeRJOljqqOgsH3+XSb1chk5pisxQIg4wWRiSAJIz/TGzBeDwm5oN5gpRTNxeBeedGorDZm +F0/2x/dBbZSr4yQbFqSEFqo6jUH0u1xBh112O1QKi9ZK893O3oHbD5FQ1A96ACVijFRmpBK0Xm90 +Y3xiWxCzPA9EWVZDFUnOM0xMCRrJSCQRKefHYBxtNtxqwaCiCBQaQfO4JKuZAEzTtVIyYazH4Wm9 +O7a2ffTi9rF7teQMyRYRNL60dPzzX/haPt0DAWmz0gydlISqJLUEqe5yyyAzFH9+ZOKQHmnYbQSU +k9WEO220zyNhXr8qpykqBMDOMZlhs5GyOzAAboJDvarLJvo8QaD+WLRz9d7HHU6GoHRGzEihRjg9 +kSotZAoT89Objz318W5/HYi+3t4EWoymJqG0GBHICyQEF1FLDz70gqRVdu0aGhywDA26huGKbCww +C89ER2oTO3deUbSyF1SBlOf82XC8lcz3m2OrxdYcxcej6dFCfV1S6pre06J9VswFgjVRKuvhkUp9 +QQ4m49m6pNadbhVIASU0m1MG50vTWUlugMPFyOSwXdwziIDo8qC6EuowfE7gM+urp7q9VSVUjqTG +y+3t7tSxhfXzh0/cO7a4E82MTc3sf+6lNwKRDqgjgDJBLuvxnqqNSfKIP9BFcc2vFGvNvaJcNJ7S +OJR/JoLCQZIZliuZjdfZ5JDJCzXmcvvhNHi5Fs/MNUYO+oMwLqn+6EahNM9w6U5vbXRiUwCX5PXj +ZBQckCTmbVYe1CB8rNsd8riCHrsALA9wYRoiVLXqV3I2YDELIwfbnekTufq6qncQPOL1herNJT1W +wwidoJJ6dDSdnw1H+pII/BiGinLYGZoKOx2Mw3jRFvZ6FKsxHcJP3165BlwpSzn4cD3RmVo+tbx9 +aW378tbBq1uHrvR7swwJtjRIU3Fjbqfb2LOJIJLGbA0iGtZa+cJcOFRxWEnU4yd8mtNK40iA8Klu +B20xozSV1fVJD1AeHTQ2kNqDuOyi3Qb6JAXCVRSL0Ugdw1WKjuBkSJCysez42NzRjUMXNw5dHVs5 +hdEG5I7NHBPUKgGdwmRwMkmzWY5LgT7vj6+Bc9y9a9hhobwu1WmHy2RdTg7xcOVcfePgKcafcKPB +aHYmoLfgk+sT+9PNvay/JEnp4zuXVjdOgbJCUcCNfCQ2MTF1dH7hzlhiQvSXG+XRD3zw+ebovl13 +2CxWwgVI4otEoqP15rYaHvV4lfWNc+F4e8+QZ9hKeYBlcCOzTgpUY6l+qTS5snJ4auGIFw+IKtzS +dihSk4L5cmPhwM49xy8+zkhA+rO52irJ5RE0jJFxNxJ2eY332uncbKYw60GkwSGEppNhzfCMKBJz +uUJDJsZkpjxeedDscrhoDNdCkX4sv5ivbxQaG+Cas8nerUefP3LqptMlqeFaNNPXkn1V7wJuIz7V +45H8crndPchyRbOZMp5XG88GuYEBL4bGg8HO2Oj65au3WL4ASlIJNUW16cVToDMzpdWl7XtC0eb0 +zL4LVx5tjWw4XYoxPdKrG8H7WIQkjfd9XjdPExoIaYfTiMgeMpE2h+zxRYL6RKm6Hk+0+2N7l/dd +OHjmgYNn7t84eiUU67qQACekS7WlVn8fFICiFsHtEmQCww2gtlk4h01wWBmAqUJ6UlUqu++wmIa8 +bhfvMt4Xcy4XKEOZZbNrW+ecLv+//IvdZCJBJ8tKO6T3Ybx27/Y4XTyCKj5codiorJVLnb1T6+da +kyeEUE8IVqKZiWJrHSdjmtaNp2ej6elEdkHR2ygVHrYZgahOu+BxijYLBag4MOiGSvChKoKFnF6/ +3c37QyUlWiF4PZ4fG186VWisFmpLjZGtShPMVB70s89YwJLnwX2TMZKKsXxSlDPt1tzps9e1SHNg +j4MgdDXUEOUSguq3U/tiOBVNZsYYMQUAYrWBgARi0iWlBNULIrCYa6+vH+yOLfswJVdZnF2/tHXk +/r377x6fO9ybOhBJ9RLR5jPPv3zt0Y8Zm4thkVp7e275crF8oFjeHwz33F5l2IIm4g1RysIY7Rkw +Qp6HLbLTreNULpEaP3vx5uV7HwPTanXwTiTgI+NioFprrTbaB8rtIziXg6pLlWYAqzEqStJpnEx4 +fYC9oXb/iBysW+wsiuvgx2+rOBVqGAAQJCtJhjL5UZBVTqcsBiqF+mpr9NDK5rmpheOgOf1y8tL5 +e19+/cut7rzVJrBsEVCU5ysoFoVhdThFgc+SZGQYXLZbEG7fK04qF5tbi9v35Iqzq4sHPvLRTy6s +7MztPbNy5Hp77nRr+sT81tW1fec39p8r1pfKlZkvfOX7Dz36ERwLBuSi318HBGOpRDjUVOWq1x3c +swcFxwpCaGjQ8Mu777AO7vEYRtKX8Ae7klLL5Wf8gRIr5uVQS1AbstZVo+NOtyQquVR+vNXb8IfK ++fryyOyxmb3nZjYuja2czza3lEgvEesf37lv6+AVRsyxQilfW0uXVqTgFC+Oejy6xUKBjbLboV8Y +8+1pbB4YNTIKji+Zn0wUxsqN6fWDF/Yeurhz9r75vacKzTXWX8XIGAgVXsj7fAGnk/F4g7xQaXT2 +98aPJTIzjAASXUCAdxAFjBU0IwloKTWD4dlEelEKVGBk7U6OpCMOJ2d30AwXV0L1VG6iWJ2BP1Wt +xjB6sbbQ7G01umvx9GSmNJ8tzwVC1Xi0fvDw2fm1QygejCXHc9W5WGY0EG5zUtXh8kNrYIh8+ND5 +YnEK+MtqFT2eGIKkEF/K7Q1nsuPnLtzfH987PIzTbFpLTiaKS93JY2cuP3n9kRdn917FqUyrNnNk +56IgJaHGsoWlkcmzkwtXys3joUjP61N8iHLqzmuV2ooxh9lCg5v2YTFw6In8fKV7AKxKu7kwPrEB +eE5SCU4uCUo1V5gZnzte7WzHkz2AzVyur6hls7F7L2axMCST86udkNZzuwM2GyMHyqXmXkEughqn +uSQrZXyYqqqlYnlaVrKj04cPnX6o1ttOF6dFpQBnyNCxsN44fOL6ox/41NzSCTBWarDHsnm3S/a4 +GKsZNQ8ZgfamIUbTR2Eg7rhjeGgQsQxTDitYBo3mSnD+CBIKBqpAxzgVr4xsr+/cPHzuidH502A9 +Ks3V1a1Lpy8+Njl98OzlR6ZXjycrk6MLx0AxxUoregIo5typu25NzB+T1JoWHSs2VrOlRUWfQInU +P3dbGBr0EriO4yGXMZOWwckIJ+UFfzGaGY9n+1sHzp++8r5YvpdvzLYnobs30+WVWudIf/quXHkV +wYMoropKhRZyAa0djI7LobFgbIb3twgi5THeu7EkHSe5nMuno2TWiKJl0g5ja4NYMFRFjSer1O2F +56PtsaPj83fm6+uMUJTkbHdsI13ok4wez01Pr549dtetjaP3JYqzaqRGMCrPR+YWdpRQFqNUXinS +QsGATS5JE5FifiwSaYBudBmp+MbmLACYHq8WS/RLlTmON1YlEAQo9pqslv1qsdSYn1k9mS4voIS+ +sXjwofd9QNeLJKm3Ro40e0eLlbVwdNJuPJ8hwOKdO3Nfq71iMjaZNTJUlVA3lV+q9w6XWlssE7t8 +8caps5etNgJ6LVtenVw+f+rK00fOPxXLL3sQjcDV557/1MbGCbtL/ucOI6o2Hk0uMmzRZEIRr9zp +rhdqK8MWyuMJ+FBjvoHgL0cSk1qsL4rp85cfuvfBD0ajHcQXlPwVPT6WLy+ubJ49e/XJ3uQxVqjQ +dEb2N5zG5tHuXbsscJlWCwvoSlJ5pzO0Z7cT8Ujp5BjYyWET2AcO8UWBFh3OAEtnQNfB3VO0Rrm5 +Xu8eoIWKEii0evs6E4eAMo7uXLrxyDPN/lo41ds58/Clm8+vH35gbvniA7c+Pbt6IRBqFbPT2wfv +iaQ6Nifv8qig1gQuhngFh7EbkZLQa72RvYKQcrl4HxYUlVK2tlLubU+vnB5bPBaM1hbXj43MHMo2 +VjL1VS01JQbrjFyQwo1sdUlL9b2kRvApH1yd1ktWNlC+4vDoGJ3l1Xo0M01yGV4tc2qD5Mq8VKG5 +As0a9tbllqD1KCZCMCEo+PmNu+e37u7N3FntbmfKizD0sXhz7dDFSLYfz03Mbl7JNjeV6Ig/VAXH +urS8gxGKw8mm8wtqeITjssFQw+cLO50CTUe0cIPjC7t3u4eMd3MyL6YKlRVVa3k8QQ== + + + h42L6E0Mg9/F3W6m2ly4cPXRi3ffml87mclOBEMVj4fDUb8oZMBtmY29gFmaiZeqC6XSbCLRs9vp +gQEXuB6fz8gwIakwL6RJWqfJYKXUD2kZs9kD2n569dTenWtj80cTuRmSKXi9Gs/FHn70yZnZ/XaX +f9jCGMEyxvYQxhMYkHMEHqpUZ9RgedcddvChFJnyB+qy2pKDHeOtul677+YjV+65JQjAnsnx6bPN +0aPZ0jyAoR4bRdGY1VgCwLfaWxQZNZkwHI3yfJVlMhQR8SHanj0ep50a7Sx++KOfs5ixQag6KwuK +QlHb0dhUPNrl6dDYxKrszwBn0VxNCPZIQi7X55uj253x7cbIWjI3HtSqtcbS8v7zi1vHO+Nr6cJ0 +LA1I0gLPq4frvf6molaMqSx8lmNTDBWG0jKSAbwS/J3nEnY76bBToAzD0c700umj5x5f3X+lN7V/ +YXbja1/51uXrj6ixdjg1UWrvTxaWCvWNhb2XTpx/dHbtTLO7fu2hZwLRnssXjmSmS519td7xzZ1H +N0+8b2LlrnZ7/TOf/9YzH3/di0dsTuX2HnkKSqX84dFEZr5WX7hw8fragbva04fGlo53pg+mKjOj +s4emF48fPXXjwo0nM6XZWmvl3NWnrr/vI/tP3DsyfSyanuCkIieUJaXt9AA2MtDmXh/4o5QoVYNa +k+VznFx1eTRBLPlQv92JoYaoa/hDLUmu4HgM6EkJ5MenDwa0cjLdqDcms8WZYGSCEao0naepFDiv +f+4iDSWBIAGciDmdkskEVpqjyATq04DuaTpGMzGGjcuBYiDYAFU2bCXcHoEA++YD8y77A5lIrNWb +ODCzdEoN1Ug6jGDGmo7bM+4IjzGxKsyy6aDe8aGayyk4bDwgrcMu2G2MF3yfL1hurc4sn+iM748k +JwkmbXfwqr8QjbRxXIcyw/E42L2gWmfohBvqk4r9c5WW16UM7kEGdrsG9jjhRxxVScx4g0ZR0T27 +7E47a7WQxvaIQ97br2BYh40ShCRJhaBTEtmpZH5B5LVsfqxUn2/1t4rNjXCsJ8s5cI6Z0oTg1zkx +ENBykpJP5Rdy1XXwek5jgmtI8Vdlf/H2GlvCWAPoFkki6nLwcLFmkxeMMEmGSUqXAoVYdrLaXJuc +Pby8vP/shXtmlw40e3u3j91Y2rrnyKn3bRy4XGnMh/SyHmlUK9PH7rxbi4NfmBybO7G0cW5keidf +m4+kuopeymW6V66+78yVB3yEHo5NKFovnpnfPPrQ3qMPFCrzU6Orr772pQv3PhROdPLV+fbk1tj8 +gXPXH/3IS298+o3vfODFV0+cvP7iC688/OTzsdx0LDsdik/mKuvTi+eP3fX+pa2brFiWhEx/4gA0 +kcsTcLllgo6CeQzGpnpTp6OpCRB1I6MLspxXQy09NaroDRCTUqDe6h04eOJBwZ/S9Hw4WueVamv0 +8OjMWT25iGI5gsoFI31/qA3eLaCkoR6AW92uoN3hN94pWDmGzZSqK4KU9yAB0AOTC2ebY/sCkbYM +JjFQ8GEixYVRQvEiHM2EeCkpyHlRyQe0Ci9lXW5O8GeWN0+XqjOg/UR/xYeoQB9ejypJVcSrWK0k +gACUlsenMEJKjfYLtW0p0GK5jMjFRd6wlgG14nRIw2aKYeJBrc6LJcA3kJEesBgDiN3Gg85BoWJd +fgwN2aw06GpjZqBDpMko/Gi1UNA7Zgvj9ICqiTBChuISWrRRrC+geDQVLaYyHUFORuItLTqqaj1N +H0lnppLZcV4M+/26Gs5TjB4Mt7XEpF9rAw2xbC6q9xOJUZuVcjt5zBfwekGT8KYhz+1MIQ+KhMD3 +YViIF9OclGt21jf3Xzywc7nSWRD8iUi8Nr24k8r1CqVeKjvCiWkowkCgqqo1PdKCFs4WJyvNRb9a +YMQ8RuoEEwkEc3q4lCuMRZMtIwSyAvU2Bl0wMXOkPbKaipX6zf69996cWtwb0goTU9unLj9w6f7H +rt/64NX3vf/Sg7cOnb48u7hx9dp9x07fOzl9+M5zj0wsnZtavri8cWlq/hiYVoqJxSP1G498dHrl +2JAZt1gplk/LwWa6stUa2+HElCwmHn7kaU2rgEDy4noEjHNzY2XftX0nbk2sXBCl1LGj5x557MPt +/gbBpqVgixTKtNgYGT9+8ORj9f4hjNAuXLjR7K7YHIKxJbrD78PiFFtodUGHHFeDtbH+xtzK6fbo +gUpnVQyWUSLGy0UlXC931jh/we3l4bpYIS5IGYoNgwGh2GQw0hybP3H3rU/0pg4qSkmLjiDGIhHG +eKXrNJ53gWWoNVcFMSfLqWR6RA62aiNHgrEJigXrBPBbkeQa0JnLFaCohB5rJzJ90V/CiKixTd4w +IJIXBhonooCxxgIiszGZzWxMIzR2uAMxPzCAoKhu7D81hLl9mhrp6KmJULynhlv+YNPpUoP+JM3q +dieNU0FeyiQy05nSaqoIBrAi+1PJVEPVKx6vGI50Ku39hfpmtb3vdiilkb9ns+DhQDECN9zJmExu +05AbQAy8ME0CQac4Ot1orZBsRJLTYajk1rIa6wiBfFBvVkCy8lGXy5gIxArldG4pXVxTwz0M01Ff +IKQ3WTFnttJeRGPZFHRTNNmTlRKG604Xb7USDK2DKnA4jZkkFKGqop6JFHLpliTFQ4FUoz4xMr7Q +GJnI5LuqXg4lm6nSRLU9M7m0v1CbHx9fP333ram1U3AnVbXA0jqGypiXyUTLm1uni/VZ0M9aqJuM +T+qREX+ggRLA+ERACmxvHyZIneWremKm0txa3nf3xpGrs+tno6kxvxC779r93/rhzzYOnafFYrqy +VugcHl+/98KN57YOXa42Z3Q9+8T7P7R9+KLL4wdzF9DHM9XNzvjxnbNPZQozyWjz/vv/f5Les0mS +7LoS/AMDdFWq0OHhWmvt4eGhtcyMiIzUujKzRJbWVV2iZTVaogWARqPRaDR0QxBakBAzJAgQA0kA +QxAguRxyqdaWO2u2NrO23/Z60SysrKoyIsPfe+eee477e/d+/IkX344lFbAnCGbLamf/zIM773vn +9gufylW3B/2dD7/z1e78PoJoGUzTrE5veOnMtfc/+dJnVrfvgbG6/8SHGq3tqbA7DxaLiQSRB1TU +6ttbJ+5oSvWJx577yrf+i6LWOLlnB5vw7W5h59yN128++GRn4RKBue977s1n3v/RfGkcibGzEQr+ +RBCdIvOSPJgJe62yVy7ce/Lxl4BAjh2LHXsk9t73xI8dw5BMzvW3CdzZ3Lk0XjoFtlS3gffqJB3g +VDGBwNqVwWQxtO26TRzXMPg7n7f8cbl5YrR8/sTZx73SEkWZtdq6X1gOe55mDNCN0ZgQbo/ksoZa +xDNCOkGInJ5OkskkS7J5ii+DnWHYMsUW0xnZspog4Qarl85cf2H33NOj7bv5+mEiJRCYYlltDA9v +/T10+lImrUtitdLY5qUaREQhvwiXlMFUmO1oQga3GJbvwx1DqSfD/SRKpb4JctdQ6wKbRxGdISwg +n1JpxItuMklwnAeEY3qtycaFUxce39q/4fnzxeKCnx/RjCdLgWFURD5HE4bI2DwLHxHmIhR4K4Er +Q8jTlEngVjqlaFJRZLMc7YIlhwCXxAoIZppxeTEnCIFu1Iq53mh+uzfYgYwAF7+0cb07Ol0oD3Wz +rGmBYwVZKzC0UvjsPspJQkmDCxbyFGVjqIIhIqSnoLCoWAvJlJEvb5Yau443XNm4vHP6Tnt4yDBu +qzK4cPFurb7KUEGxvJYvrzj+vGbWLKcBrhycrKrVaSY397A5BWhFL7sSFLYMsy8KgaX63fZksnwY +nlJsHeQbB73lG73JlXJjI1de5YUCS8iHB1dOnr2rajWQgrazwLCgvgJdbSRibCJKe0bj5Zc++oHX +3wYvE/ZXjcqJjM9IrXLzsFTbcc3KZ7/w5Vc++FYixk0dzyTisqx0q53zk4OnUiklneBkAdaxT1M2 +kAakJJh80H6j5SMQQhzMnpTb3b7Q6W4iGR1DbRCxvFiGycFRIRUn4pEMjpCaqGIZFM9QopRvLpyz +c6u6vcjLDZF315cOz51/LF9Z0u12rgRmeYdkqgii8LSlyXkkxWdSIk16LJWT+LLnjcCX4UTA0QVT +qRtyZaG7tbVzI0PYkFZIys0gehJoP8EqvFurLSXiQmSWDFswR1gCt2FORLEgiDkARi4YqHqJoNRs +MGj1D/PlLdtbXBhfDAorBGEN5/c6nU0kHVYmwXCw6kEy5RNEXVV6cEmpBO7oeddux8E3pbX/eAKY +yTjhSXzUTiQkywkjlOXKbnac9QYc66fTCshgng9IwkolWZ4JdyQylAWgJQkTyRiRKAsRwVJGIoqH +p7MTPJLkRcYVuIKkNCmmkE4LlfpyoTbBMLCorm7WJLlgaJWsXdXkHJJkVSkol+dxDMKKoSkD4G0Y +cMEVGE4iwaeSEsPk0IxJEjZFujBLREbRJU/iPDAUGKp3Rqd0q8NxeY4vkIQLekkWi5ZRYUkzlaDn +ZjIQmwzlTE8hs9NoMkbylKjwRsFrt2rrEKfT0+jcLINheUZo0GyBojyO0wUwLZ2Rn21OT2PhuTB/ +ZbRybePwiZXdW2AxaIAT7ZCEQhNKmB0IHcalaGU/18/mBoB8Uw1so8CzNiwEz4AnLVK0TVNWIkbR +uEpmBBrjdEljSVoWNJ6zcqWBqFcJysVx3dEKZ/Yv3rj5lGWDSMsXSuuDhStBcYemPQIVM0kmFadx +RKEIE0cVAlVZ2uW4oqr1Jb5Cooarla8d3XrulY/hlIWgMklaGBAXZrEkvIxkgo5HSASEZQLckIZi +1sMiD3Imo0lCIev3Od5jaKPRWq+1tvLltWx+2fEWJaBE3Mq63Wy2D2+GVQjyS6XyAc30CbyWTmmx +ORRJEobiqXLueFhGBgEA03SZYxsklc9kbBx3g8JElCogVHDChzwe/ifpgzAGYgwLgMygaIonwDtH +iLAqwhxNUkBxJYZ0aFKLRVDXaJTziyRuERmNQC2WBiVgoRmx3pjk8t1EguJZR1HyAp+VeJ+ldBxh +MklSZK1KqYUk0ngaY0jINVmOy8HXJeLc7Awai1AgfaeOJ6NzBIEa6YSAwXoRBokAewDM1PHSaVOv +oGmB53IU6dOUCxEB6xidzURmUskoyRJmJKxQgYM9pHHHdxueDdFdpjDn+PEUpMKpqVBLPzwGSyfi +tCq7iuTQlBqL4uAWRbFimF3P6wfFkWG2E3EGSUM+xaaOR9AUSZGwQLIkOJ3WUrk8tO0GRRoZhInH +0XSSZ+kKTbo0qVcKw97i6dkocEUmOpeOzaVZQpBZzbOLYSWiXFXW8+mQ6nPD7lodVJCcI3G5lO+7 +TgMyEUE5kQiNpAQUkXUwL3qdInUInHSSQdMcjqrAafEoR6JW1qr1Wkut1oRnddcu8ZwHGhU+SGIq +jqjHjyNAWRgSDm1mOhFPKijmi1LLNBdcb2w7HQKTgHw2Ns9rJpiRAFScpneCYLHZ3A== + + + 8rLhncNUkud5TxSzAPXwuVjYgJImwPvjCpJmYhEkFUMZXCYycKliIgEyJmsYHUUOiSKTUR+arAFw +jiD2/NxueMiFsFPhgzbgVSYym8qkBbA5PF+wzKokBg9LKySTUXx77fSlS0+wtJOIkUiCxVOSJgYw +KAJV0kk2MoNQhCrywDZqOslRmMQRkkArLKUSGJGKJWiUgH9CJMpSWRSK4XPqOJNJi7BGxx+JJuao +RJSMAAyOJeaOp+MRGs9oIuMZShF0SyVfv3LpLohMSHZIQgRWQdMKlpZ50gH4xeZw3x3ksotExmAg +R6Tl6Cxx7L3xWATWRYdvnDoW5WhTFoNUgkvFYYoosG/RWZRGNYXLM7iNpkSRzWlKd2YWOX48duxY +BIbMUIZlgPw2fNO/evWWl23EEyySlknK5viiIDUYtpCI4Y6avXHh3ttf/F4a0977npnpqQSW5jXR +t4y8ny3rkn39yu3Do+soLkfm0IcP5cPn8ixjSaKlK3Y+CwpzTZFqHJsFjYdlRPh/GmclVjGVAoGJ +eIbG0wxH6blsR+AdLAMzkNQE3s8CJsVUhkkjBGQEXa4Y6kImbUImmp1Dp45HcUyT5YIg+HhoWi0c +d2jCNJQ8RxlYhjPNSqW1jZPwjUomHe7PfPjTomPV4glqZiYNbjqTUnk6h2fURJwkcLEYlEteTuXU +dAJPxAmC0Dy/X29vA6LSKRGuqDfYC/LjsCv0LApwwlGZDjNgoCtNhswCkEq5frUwwBAaKF3hTZZQ +WVLjSQVNk+lEBn7/9Rs3GFKKTKdjs+j0sfjs8VQ6zoVlHnn34YNgFc84WIpGk2hsLhGZSWSSqK8b +7aLfreYd3Wp1Rqqei0bAQ6XmwiXGyYyWSUqzU6njj0SOvzeSivGKWJWFIpYSJcYKnErBq1lGNRmj +cESmMMg1SgyI5Vh05ngiNptB4rTMBRSmJiIoIDweBeQLDJGl8Fw6Ic9MpWaOx3W5CICcnU4BDiHt +8ozr6lWesNMxMTJNoEmILHZuGolFSDQF5CklY7jEiTLHGDLTKrijUV+QZBwMklNoNfpBriSIGoZi +NIb5YBqbC/lid2oqOTeDoCnBVoKcEWgc7yrCoJrf29sKStUUQsXiJJqBHGoqspn33WrJrxW9k9uT +F559sLCwHokgkbnU3GxCZBQd5JGpW7JCZrCsrlQDVxMBUVEslZAZrJxTO1X3+tmNK5dPbBxOWj34 +ZaplgtjQQMA8NMUUXImpmJ6tW4bq2b7IuqZa45ksyJ7EHCoxSqPS6g4WTTNfLQ8EwaEIicblTIqd +nUaOHYuH97LosFwMTF06ToD6HbTHG+sblqoTCJ2IERRhgCrws3VJzrGc22ot2XbVNKuynE8mGAwR +ADMcreiiKXEOicmQsiWhLPFZXdAMjq3lLN+0dUlxNU2mSRlAxuGTQWF3a6iIwIoskZHwFE+jKoOb +kMgAHsAhHCjMjIgmk3gqgSWTjqwslL2tTu7cav3+xeGd80uvv3rv/On1omNzjIajEuQ+kXQAYI+8 +Z3b6eDIFLjslpiIYg7Ayxec0w1N1W9YoCN4UrouyzHMc8CMnirSi8b5r1FBEmJ1OHH9kdupYDOAB +yXEWXOcse/wYeuxYenoqk4gwAH4kjuNpohRUGVxgUM5RckQaND/LUzlFCJJxYnoqlogSLGiYNIUl +EjKdzul4vyyuz2d315v9rl+v6OOOd/Og9+DW9tHhwkLLnW/4hWzO0rMUKU8fm4vPJck07ghSTmJM +Olkx8P1xvt/2XFtwLNlzHU3ii57cq+t7I+e1p0699vz55+5tPf/EiU6zGJlLRmYREgXBmrMkxZNZ +XyJyMr7ctPYn+aWWVnXwSV09u1p87emD1x4cfueTN3/zo4/8/Jfvfu5zT53aqZV8XldEjgsIPEeg +nso5tZwzbDmr8/nlXjHQxarvqYKCJDNYCvEUZb5VmUw6hye2Xnv99d7CGCfIVJKAC5iZAr4SDHOB +48rhrbljUwJBlF23X6s2SlkKQ0gEx9K4KmoLzeqdG1cWxyPP9Q4PNyuVIkmwmQyjqjlRzIFy44GX +MCACAV5VL9cu1SAR1j25YZHntmrXzyyv9QsLJe1oufjiYyc+9OyZz3z42hvPn3tw59T2cqecdZkM +jqeoTILhCEeTKyKtigRt8lQnEJea5qRpbS2417ayz56rfezpjS++cfRHr5/9wy++/Juffemt548u +n1wed+u2pNIoQyBsJs0LnC+zHoPgYKobljqft1quuNZ2TiwWNxfKR1sLTz968s6V9efu77354qUP +PXfnzsUL41a7kstaCk8iCKivTJKPzZEAp9gcDYw6fSwWnU1hCQJPIBbH1Fx93C4HuuwITK8cdCql +op0rOSUGE6aOxyBgMwkKxJZJIVkmPvDQyyvmi1e6T17sPndz9O5Hrnz9U3c/88GDz74w/t33nvyH +X7/zp1979p0PXDm3O67lcmAfUrFUJhYRM/GqjK0WiLVSaq+F3dqy7p2t3ThVuXmy8vjF/nPXB68/ +ufyRZyafe2ntr//stb/79Se+/enLD84VGw6JxBOJGCowusioLEroRHrsYpeG/M1V+ZXL5Xdf3v74 ++yZvPT3/uVdWf/6dJ/7hN5/4+Tfv/PJbN//7T1/9n//jZ3/29QdvPrP96FG3nvcZDKJV9FW75mnz +JWlvYF5acTaqxFaLHpeYvaF3MAlOTvx7R+1PvXL697/91i9/9bUvfPZ9rzw4efHUkqkwyVg8k6Rw +TJ2dTU0dm8Fi0UBCywpWN/BAjAdSclJVt/ru7si5uOq89cKpt1659NqD03/09q0f/+CdD796r9/0 +ttYmm1vnTpx5YNpNKpXweLwgE0OPurxkvHSt9+zFxpUl5bVb7Z9/76Wf/eC1Tz+//fkXln/7w5f/ +9e++9M+//8yPv3jln3758l98/fa1HT/LZ4hkWJOQw1UWoxQ8WRBTWzX6mdP573760s++/8K3Pn39 +E8+OvvahtR9+8crv/+KVv/jKzR+9e+6ffv3q3/zw3meebT17qXp+o1LzzXoAubLgmmWNE4sKNs7h ++03hif3gzcdXXr3WfOV69Y8/e/3XP3rjn//+27/7+Tu//O5T//43b/1//+9f/+FXn33lRuebb535 +xQ+ef+elUxVXT0VxSLJgYyXWINNpBlJ+JmYzSZeObNbYO7uFR09ULq7YN7e9l28P/+SPnnn3g+fe +fePRN99/r+rncFQEBtYppmXya0XqqMc+vWt89qn577596TtvX/zJl5/4+x+/8T//7c9+97OP/eiL +V/76Pz/zz7/95Nc+fvPsWqUCDpJXfStQGcbl8HmH2q3h1yfsE1vGBy/mv/3hvZ987Ynvf+bq1988 +/PPPX/n7P3//v//Vp/7lN2/9+vtP/PZ7d379x/dfv7/e8cMkCCIknUAphAxUq23pO0XutTPm27fz +n36s9p0Pb/zmG9f+z99/5G9/9uqffv7ir7998x9++tzf/vCpH3329E/ePfnLb1z6z58+89iZyqCS +Q5MEgXA8Su8vNk+Ocvs97bE9+0svTX70+Qvf/PDm19/Y+d2PX/vl9973J588/4OPn/wff/vZ//U/ +fvgPf/nG7757///4w5vfe/fK0RJgIRGZnUOSOHC7J4jrVXnsIiMrfmeJe+GM974z3gdu1d99Zf37 +nz7zjTd3fvL1u//2d1/67Z++/Psfvfqvf/P5v/jGk1d2WxvLk1p9RBJGxct1s9okzx61qUeXuM89 +GPziqzd+8+27333n5Lc/dviTr975l9++/Ytv3//eOyf/61eu/e+/ev3XX7v1jRdan3uifGVRBlbR +OCk2m5p+ZI6MxQtCai2fuTYSH9tzX7ne+NSzaz/91lP/+Jcf/t9+8tIffvjCH3704s++cuNnXzj/ +px9b++RjtUfX9cU8U9SosJyoaAuMEzj1SXewPy6uVfitEnF7mfv0M/N/8s6ZH37hyp9+/tzPv3P7 +9z958W9++sovvnXnF184/Tc/ePSffvn8735w95sfGn/8dvDylWa/aOGIoEhVkfct2ZivOH2fWQyo +q8vGM4fGy+ecj96uwGz81X956pffuf2zr934v/7xy//3v/zxtz968jufuPbKk4cSxVOomFe1osxU +ZHTsk3t1+uaS9trl5jdeP/j+Jy79+HPX/u3XH/9f//7jv/3RSz/67IXPvrB7drNWNHmJYhhCsfWS +q5d8LchJQl3Dt2vyjbXSgzO191/I/+BjB//tu8/8/kdvf/HVE194Yfy9j+785EvXvvbmqeeuti9v +NeZrTQdiSimzlANeTGTMqlvqZP2aSi/lmMtL3rVV796294n7vR9+5uKvvvPM9z999dsfPf35F0+8 +cWv4+qX204fFw5ExKMuuyqMIrwo13+5qrNL0zLrJtQx6u6E8d7bx9Q9u//lnz/7ld+785vsPfv9n +7//HX77106/e/tkXz//TT1/811+89qsvnf72K7WXLxW3moqAp5Ek4ZnNajCyJc/j6YHDDE1s2089 +vi596EblzTutL7+y/W+/e/uffvvm7374vv/+yw/86x8+/ZNvPPa1N/Y/9eLm3mLeM2yR82A43eq8 +I0lFlT057y/nia1C5tI89+zJwhuPjl6+2n/mVOUzT45/9c37P/nKY998/eCLz6989NHx7fX8dgNy +KqEyMkeaoGQi0xkB51U8HbCpxSx9at67tFo9v1i8u1t7/+X2m3cX33p8483HN66O7Wsj88rY3W5m +87JqsKLCSKD5NSmvCAVLrdhKrlMotly9aYr7Hf/aSvnGkvfmo/1vvL75l9+4/I8/f/kvvnjjyy+t +fvm50QePvBd2zFdOVw5bqkenBYzUlZLrjFjaBxvIoKyEIjk207eow5Z0dcQ9f9L54KXiF54b//7P +n/9//u0r//CrD/zme8995YOXb2+3Vuo5UzZRzCQxkUojfLivi66ZYt8TVkrKfte6sVm6s1d5/nzr +j14+8dWPXHjrwdpTR+21ti3zeCaZSESRDCIXg1Gvc6LgjwzBthh2PnCu7kzund9YLtE3V8xXr81/ +6cOPPnVh8e6J+pOnm+eW/UnVLFkiGByB8cJyhZjHsEUw8uCgS0EvZ2Q1gvQ4tmHrTVfpZqUT/eyN +jfr9g8Gje62Lq5X1Rn6tnIdlLJmyxFA4yqTTfDIp8UyRJQw0kcETKSGDehy/VCmdGtdvrOeePsi9 ++/zy9z959iuvbv/w3Vs//MyN737k8Dsf2P3K8xufute/s2kHMgqmXRXMsPQxnWMpLw2GKMO1s/lR +wS8L6UkWuzDUb606j+9433nj8F/+6lP/+NuP/9evP/bdd669fn/t3unm7tAHb2xoJc9b4Fif51wS +k3TBHlY6FU1oWmw/KzV1rmfLqxVvuWBuFoVb64UHR4vX12pjT+iYaknRLFbicCGVEKNz3MwUKEDK +lPMywYiZjIYTZdNsBX43CPq+V9OFsszVdanrKTkOAy1YkNRBbagKPrgSEpQ8rlbKIw== + + + hnKQJIhthkRYg9Nbufru0v72/PLA1fbq5uN79TMd9dHN6uXl0smmfqpl7FTNrYrTNaUMyIK5DJ4x +RL5BYGADEXCasZkknQontqrJA09tqPhqUdhvyHfWvY/eX/r4k5svXRpdnrRKgqDgnGtUg/LG/PJN +gQ1MtSAyukDBhJi2YhqC6ijGoFZr551GVmlk5UDnXU2yNUPgVZJWwapHIgSGGapW5gQ/nuTQjKrw +WUf1Krlqo9jiMpm8xPcDr10ATnN1VtZYCQwFlubASWXSQjzGRKMMQeYL5Z1SbSfcQqZXRM7mCclR +AwaDNM3ZorvU3Vgfbo/by3kza/KyLee80MIw0zOxRJLDyDwvdlW1Y+ltgbEjM/HYbAJ8va34WT3w +dbfmWoOyszMf3NipHY29axuVmzuDg35ppWxNil7Hc/EUNj0dTafCs+2RKDk1nQK/yXLVcmmz09hp +FIc6x/sy1XWFhkbVVfzssPTa3aMPPHX51uH6brdV0lWVoRmCEUSfIDyccBMpxfLGvdGVbv9SNb+i +887uys7dm0/whAzrJVF6Ti/Vc61OqVtxKzpr4HGWSOsxsKVTKIAqg2ZTKTuVNAg8q0pFNI7Tacj1 +dCxChLe/UhyKyCRm8nRWYHwGl9MxhExzaFJE05IUPrFyeCavh4dZFtNpDWxvKsEzuC3Qrmu1Da0P +gcNhosFpC9U2mUACNVf2Wp7sCSjP4xpHGomw0niawD2OKcaj3Hv/09yx986B32Rw3dOyvpHncJ5F +aZNVcooRnsWlMJcjXZ73JTsrFVMRKh4WhBk2Buf9YMlxF4eTs9l8h6QUlstadq/W3C/WtjjepSnV +UnOLo41YkpiZRWIJUdL6tr9iuUtSWFmrpMqVyfJZzenG0gbJhIcyKKaAZCwKd3jKSsXJmelkKi4y +ZE6R2xxXBZrCcDeTsRSpDLIknpDjybDVEUUHlt3xsn3LbOSDvhxu+QgftJGkBz+SlJaqtXWz7WQX +bK+nKnlNrxN0HsFsDHcyqEPSAUn66bRKEibPe4ZRVdWiYbTy+UU/N3CsBk/KCq/asLBKMRpF0kmK +wG1dH3rFfZIrxxPczAw6NY0AMEi6qlvD8EBinI3FWIryBSZHozydoS3RalSAl2yc0Ck6Kz6slYcT +YcFz+GwEIoWwNa1ZbeyLSjuNeAiiY7jl5yZBYSUW4dJJmF5f1eqGPcCIXCptoqijyB1ZbiUTSjQi +sGy93jplexPNmCfoQiQKyBF1ITCUPHg0QW5mSxuF5m4r7Ei7+rDbuMax2fnhGSmsXm673iRf3C7X +DnLlvWjSnJplpmcpBLHjUf6R90bmZgnNWCg0T5Wbh7a3DOidPp7JpNRETH7kkfTsLEmzJdNZCooH +truczrjxpDE7Fz6WEjkfwDwT3iWLzk5nUnGOJh1La+pSPjaXScVwBlMZwqBhudNqeGQpraNkDsGy +j7wn6hY2GakiKYWTBzeHK0ckn+fVOs2XFKOhWx3XGw5XLqYJDcE0Xio7+SEllFEywKiCao36Cxdv +PPaRev/ETJRLocATm375tGItM3wNxaxkWqJoT1ZbgDec9Am6pJqLtr8GjKgbXUWppRAzg7kY6XJi +w/TGudKKZvUoJp/1x/XWCUWtm1aXl+uKPSx3z+abJ/3ylu2PZbU2Xrul6D0UNzWrzss1MzsW9S7J +12ih5viThcmlE2cep7j8XIxNITovNcINflyJlcIjPJ7dGY2PDGded/qCPiC5JiP0FH05hQDt5BA0 +3BOYSHEYpmlaQzUmLNdMJ2UkJetaW3p4okE1B6XmiXLrJCf3ObmHUfkM7gpyneXLGGbJUhVB7WTS +oNgCrzQpvhFNWTOzHMsFSEaKRsNCsjiZk5QuLzZEqUkxJU6oS0rbcsfxhIpiPk6Vaa6BU0VObFJs +aXaOnpulTXMgKfVkWkxnNFZuMHKLEZuGO1L0cFsmQWVJthJLmUnUxdlqtrKvZ9e80q6b35meYaNR +URDritbIYA5OQOznkUwA5EzRxUzGiUQ4hq94/rKXXcLwbNh7NG3xSk/WR7bVxVENYHnsWDo6R6fi +PJJWCTJIh+d/nUwGEOXF5yigNZb2nOyi5a/o3pLqLtF8fXqKErR5Qe3ki8tXrr3QHe1nKJvkCwQb +ePklr7AWVgyz58Vws82KX1xME3o0LSUzDi/3uqPr3eVHa4PzrFJDCUvSumZ2zfQ3aLGDsxWYfyc7 +yZc3LX8R6CWdsTRrFFSO3PwJSR/SXBknA7gAxZjHKTeDGpLWBlSUmweN7plq6zAobRZL66fOPy1b +XU5r1xYuruw/uX30zPrhk/X5c73Fq4bRLxcW947uI6RDcnmAlpnbLLXO9CY3OuPrpdYByQaiWtes +gah0GaEG+JSdkWL2V1evnLr4gmp2Z6J0Gndz5d3G4Gq5eYWTFlCylCFyOJN/uBdOQzEtEnZhNsLa +v1SO4aooEbj+sl9cp/gszmRhEQV9pHlhh2UnvwYYQxBzcXLe8UYw3mhCBEpkpTYnD1R7WVBbOGGh +GcW2OqazAFSMYkCAvm4v5kq7heqJYmU3ntBUfV4zJ7I2hO9CiFwccWaiUgbP+YUtVqiF9e3pnKC2 +VWes2BNB7aYyJgDbzC4RkDXCSmg9Sqg7+U3JWDD9VcEYInhOsxeD8k4sCbA0AFoM21S0oZ1dghFh +eA7DfdNdhEQMCIxE+QxqauagUN3j5X5YsyXKwVWlEBeYbepY7NixxPEZJo0XNHNkZ5dFpZOIiamk +oihNEUKY8OEVFs+k8oY1krRho32m3jmw/REt5EWt6RaWCT6QtIZizgMIFXOQL691R2fM7HwS1RW7 +T3EVgi6yUi1NlTC2izON/9jDn8YcjAo0d9HJb/QmN3fPvjLavI8xRYLIVoPJ7u4NhPITaDaNBhTb +MtzVcvdceXBecwdhY7XqmqC3NWcgG13Z6KnOMF/bzZXXOKXi5kdnb7584vLTveXzpfZJM7cBmISB +zA8OTxw9DjOmGO1G/1xreGOw9mhzdFHLLuFczS+ubh48Ue+eTKXtfHFz99QTKzu3R2u3Di++YAVr +QGKAH1nvCEoVp12aL6/vPb26877e8uP55hFFl0kmp1kNxenPRMVEUgPuMu0N29/OlffLzX2CsTS7 +E9T23cIu8ENv6cbSzv1y69D2V0Fo6c4QJT3FaKn2yM4tQ15QndUkGh5287Lj9a2bHF9MIbDKWdtb +rHRhBlZlZ4URu8m03Wwd5oLlaFLDqDKC5kim6gS7udpp1VlD8EKpvHrp6jNIWNmPn4spQFwSUGj7 +9InLH5SU3u1HX/riV3/QaO/ORuUE4ij2uLtxe+X0+wbrd+1gPZWxy40dCI1YXJuZZQi2hFLAq/1a +50K2sJeIGxnEVNQmxFQ0RgF3zUTlWNoUAUL5vdrgyiPH0bk5AidsBPOQTBYwiZOFFJLNEAU7t1Go +H0CCjicVJNQnBYqtBNVDki7R4LDEOpCJ7i53h9dXDp4S9JpfWKx0TrQGJ7uj08X6pukNYDJVu9ud +XIRVC9vmal0vv90cXG0uXHWDDRhmAjUILgCaggzLyS3ZgshaY6WBlV0drlwfLJ0lwr3Hy5Y/0Zyx +oPb17IpTXNed3tbOtdOXnrFzIzKsKl8BJdxfurJ88oFT2s4Gw42Ncx95+4/6yycROstr8/X+xfmV +O5Ote43BIcX60YTAihVGqOBsllGqCJ2TrfnJ1v2d0y+0h5dkawFSZ3/xqqj3SL6iuSvt8dVseVez +J8BXfml1NoqnUDZXHhbqEycYo3SZ4juGvVys7Z48++TpC0/PRrlESpXk/mhyd/PUi17lLKcMBLH2 +3Ps/1+zsI6gLrLix/9hzH/jsc6+/u3vxOSO3CmrBshfe/OhX3NziXEzGyLKZ3Sp3Lo82Hj8493Jn +eIUXy5PV87XmRjTJI4THa8Ogfn7r5Evj9VtLGzfVsFBevdY5GS4i6mr2yPBXZWuRk+cb3QsrW7dw +Mg9SGShacyaqsxBuauUaoNkOj+7fe/ZNSW+RTMkvbPtFMMDLvNpnhSaoEVHp9Rav5Eo7M3NSMmXb +uaVcdavcPmwNzwEvJaLg0teWNm6AAJ6ZYyHX28G+6kx0b5mRuhTXno1Ixfz4scdec5zue98TicxR +FFv08nvD9fvnb3+42T+TTBl3H3/Dzy+lUTsN6l4bYyCciDyMJVvc7y/eO3/jrYOLL1l298LR3YXJ +SVBcljvwC6udhVODyYX5lcvFzp6iN5qd3fboPM1XJLMt2z1abENila2Rk1+v9484uQZqTTbmq51L +3aX7C1v3G5MrktkJ/NHJc+/L11cBBk6wWm6f2jp4/PrtV68//uZk82Yuv7Q4ORotnbPchXLzxPzq +9XL7TGtwZvvgsXM3Xyq1lofjUxvb9+zcCq+0GaVB8QVQYoIycPPbkt437c5k86Lq9FAq5+RWISlo +3orsTBbWHt08/Sxg0g3WgsbB1unHTlx+sT6+Bj4phfsZ3LOy842FkylcNLIdTu1KxrjSPlVsHuje +GEYxF2UZrqTb86rdkpwF2dmw8jt+eS9f2SLosJtVvbVtej1JK/vl5f761VJnr9zaq3VOVZsnCNoH +evRL234JVnmSrWyCkDaDXdtfb/TPuvnlVEbrLpwart2wcqtusKpYfd1d4KRmobQBqBaVOidUtk7c +uv/8O0e3Xlk5eKwzvurmJqJYvHDhiQcvfCaFugSTzxVXh2s3F9ZuDlav9ldvgEi7d/+1ra2rJJnl +hGJv5erawYPlnSf6S4+Otx6I2jASU3mxjuJutrieLW87xQ3JngfxU2qdLDWOZmZFDA8K1V1e6sxG +iLkoPTPH4UQJ5hmMgG2NUin1+FQa5KukdrkQdQ1WaCURB6js9PkXi+V10KsEHQASIDkyXA3SNCiu +bHGz1j0JsSzLlZ31c9XWCkm7ptVrAOWefnBw7tn+5JJXnKhGfXH5aLh+PQmijs0a2YVa5+zC8r36 +/MVq76jQ2NXNXr29a3kLTrBc7h4Vuqf03BKvtuvNkxuHz3jlFZLLdUcXqq39pfVLl288u3XqMb+0 +YhjtzfXLyxuXZK1RbWxdvf3KxZsf2Dv77ObpB+3xBcup3Lz+9JXrz+M0kDDQV0d3R4CBUuvICrY5 +qVOprN173xtBdZlggnJj3ylse5WDztL1C3c+vHXq6SC/ce7Sc6v7d0SrnWvsGcGOYE6cwl6pdb67 +eEOxFjS9eu/JDwEnIESWYIqM1GGVnmj0eaneaJ3szR+dPH1jdecaK/clYwiEjJABzubt3Hhl715I +m3yuVN+oDU4Wm7vt4bmgtofTVZItV3unCo09lPQlo11sH9bnL9cXri2sPdGYv2xll2W1efv+Kxdv +PK+YXRBXrNAAg9AZXijU9rxgERSsIJU3d29t798qVJbtYARozxVWGp3ti1efPzj1GPgF015Y3ryx +deZpv74nu4uyswjy9dqN5xqNFTSjaUarPTzT6B8GxRUIN9FcTGT8SEzT9A5OeuON6w== + + + Z25/aO3sc+X589XBUbl7RjKWIzEDdOzSymVJbmIYmHcXyXgMaB5zUZR7KOrPzFAZ1FbUPpDSzJyQ +SnuSMpTUkZvb80t74MviKQUCiqAK4Bp4oRoWkEc0mAFaqBruOChvhdGhh8pTUSqq3s2VViEYNasP +8lhW28X6vu5PZiD5Ui5Aqze+3Btf17OLtFhJZAxJrCyMzhtWR5RKQHSrB4/D/O+eeXbnzIvzG7cV +d0Aw/mj1CiuApPHDkDd6hj1fqW1Wm7uy0WLYrO/388Veo7NWqK87+WURZJhRqdRW3dwCJBFRbj7s +W+FhrGv442xpJwhpZDNXWcQp27SaN++9fvr6K9nqblDdCQ9NewNdb+7sXNs6cRuYFnR+c+FmoXlU +G94EDmFBi6a1Un586dozjd7O1CxBcVWgl0r/nF/ZgdAuFFfm+yfe/ui7L3/gUynMz5B5Tuq7hb2V +/QdHj35svPdA1noXLtz/xOe+2eqdAI8mGMu8DhJ6pb/86O7lD8CqYYSbBVuUX2JFwFuJ4is0V5HV +XvEhO506f79YXV3fuOL5E0nvgtdAyXwiY6XBb2q9dv+86cyb7oKVm/Bqc7x0eW3nTr6yy/Bh46R6 +cydfXOJg1YKtEmjX3lFQP1CtISwx2IRibZtmyw9NnwpkqHkbhdaFfOMUJzVoNt8fH26dvq3YnVl4 +A2JwcrvaPQcfyRfXLKsf1gdjrGJ5jaSKsZg6MydCTownLJIqVWqn271ritavN7er9RM45qVTOkj9 +SFwDpKnGKFc6QVJlzVlQrC7EHYQAJ9VAootaX3UWCa6WIXMUF6hGM40ast4stfaCynY2v9lZuN5e +vMmbvTRu5qrrdmE5hVk0XwWbJoKb65yynEV4m6i2CNLpzJ/ujM8WGtumPxGtLiEUKLFaqO1U2odA +DuDQVbOnGf1SZa3W2soWlxKIJoh5vzCieFuWA8Pu2dlJvQfWch2cESvVM5inWWPZHKRQWbWq+cZm +b/H86t7j4807yYyaCbfiN0arFxi5BtYpLAwudzvDM/3J6d74SJRqglDTLfBfubkYC1EQlDdOnH4K +NIYXrOBhcUI2EufBR7NCIZZggTec3LDeWO33t4/O3i1XlzK4b3nrjr9tecuKNQ+WAfjNy60sr1/d +3n8Up3MoWciWT9ZHt4PGGctfsoM1RgoL/u8d3Gt1d8AsZ4iAERqN7tmdU+9bXLvWGUDq3Oj2dj76 +0S9Mli+jdDVXP6gMzpd7ZxrD8zDhJJ1fWzr66h//5MkX3waxCt5TtZeCymFjcLHU3Hf8Rcvunzn9 +2KUbr3ByA4iUFOqiNrCzK7Ixovk2QZXy+fHSxkVWquJMDaOrScRNJA1JqTe6e2t7N0kmK4pVTe9m +g5XlzVurG1dZoR5P6pGoYBq9jc1bvFCbnmYiEUlS+oPF65XGKVkf4mTVz44//JHPXLr85NQUCr4g +hZVorlMo7pZKO7Y9EvkCDJ+TqziVxQnHdAec2BCNISm0QGYXa6eC0n6uvAVzDsrTKywpYUH+LsVX +Sa7Kq91ibW95976VW4zEObgeSe9xSqPY3IFRQLYlmSAs9dY+kPQm0JQbrOSb+83h5fHW46evvtxb +ukSweUmrhXBKqRjmgbPgxBbJ1kB2AkRxxs36XfBZyYwJKhQmJIXa8BV2bl11lli5IcjlwzN3NavN +iWWIUzAFgHBBrNQae1unn0TDFntFzegJYh3EW6G2li0to4T7sLBzB6e8ZEoW1bofLMwPT7j+/FxE +mImIibRFchUnO6Fpl+ds02lX2psrW1cn2zeKzc0MboFKMezRw+oQPMQFSOXJ+u3t0y9o2c1UJohE +lVxu0S+uIIQNEAUvn0w7NNey/A2nuA1Rg+H2cOkCSEQ8vBucxwgfGLjW2O8MLlabZxEsQIlCrrIH +ouvhXQUbxe0MElaBO7r4zMLyOYbzTWeh3j3VX7zolzcxugBaEfTYwvCo3tjGCEeze05hEyJxafte +sXkqhebicTXrLQyXztJcgeXqirlgeCu83M8V1vuji0FxjSS97c3L4+E+z/kZVCeYnJ2bTLZvre7d +p5hKBnVTaZOhijRZSCS0TMZOpOA9Yccry+kWCwssE8Rism6Pi/UjJOMkYkJ0jkbTmsj6vNzhpDbJ +VoGi/eKSYQ8rrTNy2Mhmsbd4A+yYmV1KZYxMxhDEMqyIlR1LxrzuLLdBM6zeGixfla1+JMaJcoNk +CzhbkJwByZcQyLNirVDZqHZPclJZM1ud4blsecMprLil5XxzHRIZQEs2OuBikmlDkDpgUbXwpEYP +p0sgeADtnd4JMKcoHTBSM4PnQRBqJhjVIQyNlRpwheONmwjuilKlPzpb65wGmWE643xps9o5AIcu +q3VNbwOx40ROMec1D5iwglEexWUpNut58252kEix8SQTTfCzcxxKFMFzucVNji+JjLM63l9dv4CS +NoQep7ZoqSFpHc2YF+VWMqVoei1fXrKzAz8/0t0hSlXjSXDlfqN16ASL8ZSAEyZJBsmUxfFNmC4y +bLyoCkLp1NnHCcqfnsZTKR0jc4a9MFm7M167p7sbU7NCLKnDcsQS0sMSNBpBZkWhYhqDoLip2QuK +WiuUJ5zgE7QFYUKyFc1c8POrljcBO4liZqW2XuscwGoq9ojX52MpGycKitKHt+G4J4vV/uLZzuIF +kqmAFqKYMtg6JKXtbl0eLeyKgq/qlaA4rnd3RuuXQaHFk8bMLBuLqzxTFbnq1HEqGpV5uQVc2hme +t9xRJmNFIgJBBvnyluWOj0+hszNhhUC4YNPsW95KrXvZLZ5yCju8XMZJU5ALvFiCkBSNHisBe9TS +RBHGC1OKIEq+vF6o7gfFEyBvIAOidD6FZcGx0oyPETZkt9bCxe7iVSu7qujzTm5J1JqSWml3T/RG +53Ami9EexmTBLZ68+OzlOx9c3LkLbh1BTTChwGkYnY8nNQTLA3e5/sqps0+Nlo/cYDxeu8zwtVTG +BsCADhGUrpWFyz43WLtHsRVRyLfaG54/z/Ag3gDVLi+3DWtiOWOWL81GGBaStdpVweU5Q8jycUTD +yWy9sQepZGYGmZlJxRI8GHCULOJcFaULsKwM5QXZoW40owlRNhZ0dwXMQra0jVG5eEIFaHW724XK +OIMpkDSTGYdkatk8iLo1WNZoQo7EeNeb5/jy7ByfSJk4XRPVUbl2qt27UK6fgPRBUblOb9/JzoeV +wNNaCrFooaFaE0Zq00ItmRTGozON5nYGs8FwobgPGIjGJFGqZ/1xLCzAiJNhLaAyDUNmCwiejSbD +Rj9BYSUorCIZa7R69fSNV4vtA5golq8DSiMRhqFs1+0A5tNpg2arkjrvFzYlpRGeiUtLghCsrJ8r +lRZ4zpG0KoLneLnrFzYkuUtTpbmwfghfKq+2+/vAxomEEonw09M0gee93JqTXUFRJ5kQIZZ5oUJg +XjwmQWirZpsPlUkW0jrDVUD5o5iHYVkVIt0Za06oSBlpQIH6wiygIILKgWyj6SIvtg0PDOwp3Z0g +hBFPsQQNnqUpK5Wwc5zWB4foFTbADPaXrvNqL5FWRbkCVNboHW4d3Nk9fS9f32SVRnt4erx9wymt +zyUElqsFxX1FH5juRLF6qtnK+qOFpcso7sUTku0vldoX6v3zqjXm5C5Ol1HCY8M+TWUc10jCVfQF +v7A9Xr3ZG14EawChHYkJnNAE88VJ9c7oXH/5NqQnzRoCuWFEPpHUUNxBMDOV1tzcWnt8pTW+0J1c +zzePMKYG1gZy5WB80cktA0VI5pBXepq1+LCnCQS+WyqOrtx4Fv4eSagUV2fFFvigbH47VzqpGEOQ +KwRZMMyxIHUFuWu6K/CGuRg/NRU27Wp29nm5gkKwoC6O+7LSorlyGkCSUFBUX147W66vpFFdt+fL +rVPZwoZuLrJ8JxKTp6aw2TlKlqozMzjDBkF5vT+5ev3pz6wdPmX7i8AbOCJ1+/uuD2Ie8ldYbARG +h2RMAZQMmYtE2bAgT1hv3IpE5alpMhqX4KcMk1PkPEuripKTlDIkvkQyrOl97Fj6kUcSsajAUGE/ +rFRaiCcYisklkmY65YEZUTRwjrm5WZalPZZxY1FibpqIzHIsDzk0PK9KEL6iDZ3sJq8MENxPZxxe +alFcOUP4QFmyNh8Udwv1k3p2nECM6Rk6k3EICvxykRbCSj7Z4ppsdGnOT6coJEmSpK5odfCVzfAZ +zePzazdRugx5k6J1Uy+aJjA5aLMGmO7++PKZG691Vi9zZh/Eg2Z0ZLWC4aagdNrzFy7deOP8tY/0 +l+6HhcIQzXHnVWuBYkuAPUlbENRRtXXOy23iZA5Ji4YBZDUQlRq8MDI/F5UTaUM0Bs3BBTdYE5Ra +s7+fLa5kiCwwG04VdXtSbp3NVU7AROl6ZfvwscHKVYIvsWpHcias2hf13sLypXr7BMPlPW/QnD8t +G0PDWZPNCSe3NLNba2wPF8+x4cm+Ur68Xazt5kprMBsEUwYlPBfhGLqkq+1kkgO/hgErUiXHX+X4 +lqYviHInkbL8YFVRO/G4jGJZmm8Y2bWgdlBpnWb4EnApXFh/fE4C5RlWPmzEkg6MKI0YJOnzXDA3 +iytyJRcsGFbLz6+A+Q0bUsQYTS5bRgfEJIJYQN2S0uX4GoaDBXAh78/N0brR5YXm3JwAwQXyg+HD +vmM4GcTjbDSScZxWUFhOpIz/FNb6Y5NJYDwBSdspQFpMnJ0jKrWVxZWLkO6PHSfgDaC1aKpMEUEq +IcMvP348nUwo6ZRFMvmZGezhY1MNki/FtRixAxKdFjuKNQHfF0vJgtzy/OXe4OJg6Y5ZWEugdjRp +UEwthYTFXWnWb7QPT5x/qbd0RzL6sThJ4xJDmywHmCxodt/Or6oeZMYFXqqznMPQKkUqLO8rRlsx +OvnyBhhGI78iZyeqMzacAc0CZ5pgloPK6vaJu1sHT1r53TTiMnSOF0ooboEG9nLrhr2kWct+eV/W +x+kM+F/F0MJ+XtEYkUE1QWojiEczZTtYsf2w5rMgFurtTYYvgBeGqJG1QaN/odw9r9iLsO6qWq62 +djS7m8zoij3uL19bP3gS6Ks9vCgqTfA4zTp42M0kYgvyfK1zfvvgsVMXnl3evZurbKEZI5ftb+/d +qtY30xktbEuXVHEyr5sDgasyZDYeo1y311s4KyhtmgO6gHmzOaFN0jUYBawpiJZGY7/VP1LMIfg7 +kinHwg4UIs9XWt19goaZrAHeZGuRYEOiBpEfVsufo3g2K/JZjvNKlXXdGRJ0HjiQFyAD6tMzZCpt +ZVAnCuRJ+LLcYbgG8bAaoa53MDyIxgDP8KssQFEq48KX0lyRE/J+sJTNrcKUvueRVCyuwczPzgnR +mJZCvTQGrqEGRsl2FiCrppMGjgdI2oE/o2E7DzbMApinm/OZjBtNm49MoZEIDSDhhDLQeLG6f3D2 +pYPzH1rcemD5a/GkwvBFFSST0hD1BcFcVOyVYuNCb3w37DeEqoZV1+22V1ijlfk5xA== + + + n41qjjHstE4GxVUU12nWZYSKag4XIMtUtpKIEE0QkDdVCwR52KIIIC3LlUZvv7t8RXJGBFdBsCwM +E/QSRlqO03b8kVPYgjmHnJhIwqqJLBcSDs3V0ojOcGUvv5stHorqIs0WIlFiajqZwQxR7sXiYbVb +lqvAEof9Spy+ZXVIOpdBLQA5rA4j1ERt3i+dqLTOysZySDUpEdh+e/cuwIxXKjhTSGEBggcMX82X +Qd7nwfmWwwp+F7oL+43OnmR0U7gHWsK25yvlNd1oRaIMSDVQbjhZZoQ6CKSpaWp2jrHMTrO9g2S0 +sKYBYohKZ7h0bbxyBwRPJCoyTH7v8C4QINApxVZZvmVnV5zcihbeofKiUc50BkF5FaW8qTkmkbZx +ugoKUJS6FOFwlGOoleX1i4Y7TCDO1CxPMJU0FmSIohtshqJolrD0VrWy+7A8jnT8ODY9TWQwn2JK +GcydnWUgshx/sdQ4KDdPc2KdpIoANkjxQLMM144nTI6tGv56rrGv2sNwH1HaiEVFAJLA1ArBJBIh +wsfWxzCKKFFUHgHThxqgxCBxJMPNLTZwPi8Wi9XN9uCwvXCyOzryisuQ/Sm6KP/HSXyxVG2dnGw+ +0Z/cqvYugGIBnRAW9JACjHIUY8HOgbBfN9z9RutSt3/R9haTiARvkDQwjz4RWrMyRmY1s7e+88TB ++dcgp0TDXo2SIBUo8KpKW/dXCa5eahy1Fq6yYhuseqez6QfDNOYkwfambfDmLNuot85WOxdprgFK +AMmogtgE4go9WtpAUAdEb1DaXNy8m8ECAvcFsQ5Sn+Kq4KFAPzBcVRDDAoDROAPBBXaju3C0efJJ +WmjPRPhoXGC4nO3MAwYe7sfoA2g3D59b3X2CC3vrMKAkq43NamMDpK+XW9XdNa90CGqTYusQsDOz +ZNg/RetEIuzsLI2gHkaVNXs1KB/9x0ajaJRGEFmSiqBYUEzDCBcEvMC3BKEDIRDuVEEdAeww5mK4 +B/EFCIklLYbxs8GCqFRAXIl8OZdbLVT2IMWjmJ9BNBIzFLmoqnkcV0ShAAjPF1cKlR1R7eN0ZWqa +iUVpCjdo0gUCQTGHpAqaPtCtEYb7kB+PHcsIfLFWX2cYb2aWghwXS9qsOsrWL9UXLhhWL5VgA6/b +7h+AW3zPe5GZOT6SMHCmKZlrjreZjIP2Q1SlNplcmTqOvfeR5OwsT7ENy1/JoDZEMU66NJtXjZZh +NsGBSkpAhK0xVBx3HGcUlDZUs0uzOdVou8GQFYswdphJnAjDWdTaJBdIasd0l2RjUTaXQW2CcgA8 +QJQp5sDJbQAFgVp2chNRCZvV+sUVQe9FUnokLpFU4GRHstryc2u13kVWgVzczFD5WAoY2KGEKsGW +InFIyj1ZXwRVQJAlmBywXSClANuAWFAXsRibRo10xtb0sSjPS2qfYKrxhE4zxQzuRxIawdYh0avW +Ejg4wFjYZSaCA4Q4vgDESzIBI/U4pS+bY7e4GU3KU2EPRAlMDUqA08+Lag+gLsqNRucwKG3Jeock +HLBjIODBl8VT1mxUTKVNoEdFXwS/PztLxqJMLCGmEJsVOpq1EolpybSB4i4Z3k8oxGN0OiWALQKV +KMhtMEQgboFSUDwHjgPsA+hSgq6oxrjSPA/zD9rjYRsvYWl0VCqMMVRLJmSgRxyziIevWARjcHGh +s/rh1z+pyIVYXIrFlUTaERSAUIBmwjIUiQRt2j1RrMTjElxtNArCTAYRxTBhU+x4jAGLR9FVTupy +ch8ja3NzTFg/LcZIQsDxxUeOo5GoZLrLqrvkl7YVczIbUd/7CAqajefCOyTxuOh6Q92aAOsmU6Ht +gmhiWF+Uqm52zIKlpSB1Gv9ROYHAbUVtmfbQy02AbSSlJmkllDBiYfs8nmHKYfsYpcHwOVBcQtii +tymbQwzPh3V45I6VXV5Yu7W49biT34Sl56UyLGIGIIc7aTSLEEVWaFvuxMsvqXrHdoaaNUqiNsFW +MkDFYscOdlV3FXIWKBOGq3FiuKkv3AOZ0MHaIJmcGm79Kk1PIdE5QhBBOasM20TxUiQGV2jiZAEA +mcby8BFBXWDEHq/MxxHr2Ax5fJaIJQSOK2GoQeIGxKZsjnR3idfmUboYTUpJRMdBKgtVyF8AYMOe ++KX9bLC5tHbHz6+B3pP5PIQhUF/YZRWSC9tw/fX58XVJW0yl3bk5NpVSE0ll7uG2ZE7s0HxTt5d0 +G36qzcyQiYREUFmc8qMJGcGzYHXBYCr6yMmugRWdngtryONEnmIKqgFmeSkStjSVBbpYyC2ytAvL +nYjxYfXmuBCZYyJzfDopmUqpHAxbjeVYNCyEFfbXIAOwzDBds7PATgkEUb3/n733+pEsS/PD3iVW +VYa/3nvvw3ufkd5nVlZVlq/qat/T3dMzu7M7OzNryOWK5BIUqSWllSBRBASIEARID3rQi971J0m/ +EyNKgCABfBCgxCLvROdkZkXcuOd83/cz556Mb3CLaNaquqEPgAwwsIY5EoRmuSyXdlhTbznuihMK +mo5YyAk2ZmEeSU+3AqlYrdqOPV3tvgEQsVyIHytVT5L7prVALKpVZzg4+bN/+Le93tnOjlIqeZo5 +luSc4z3yKTQa+WsIXesgqxkWnrFlGF3d6Lj+KE5XfrgwrUFOGlbeQJKRJRfyCR5NRWsJUsQLoaoW +ukn2EghSoRvdJDsczF5O168H82d+stYtzH+f5SOa8WGHTXOiGXPLg5w+RHpoZp/0LBPIKuJ0/VVr ++KHZf5+2X1oeXjhQ1bZhDUDi+KbTe5W1XgTRCR7w8qwQVyuqxMdRAHkcR/FJlt9azj7wLWtdpcUN +L3U8d4iakpSupA5ND8k21axl0boumlc8slErLi8/c/wp5IflHxoe6VyftQ69cCHKcHlmEK5anSuZ +dD9HMowYDj5IB69pesGwjm60QHaageFMkMPVut+gYk2f5sUl6g4qi2EiRe1jWjRzqmggOL/W8HVr +MZi+7QyeGmbvq5/9xbPXf6jbS0Ub686Ckzt1hnhbzRgyBPdCVJzl7kEJyELWqNs7JalcNlxnDixC +CpEt6sasSE/z9Mg0x3XySX06TTru+dWqWK9qQBVZx+VNgS2Ot2K5vFzWNps3qFPQJSxeteZyTGRq +7SxZ4gyPn4hPdmRRbAIV6zWvUjbqeALXdJ11HG3A2pWq2mhYUFNQZdC6stxl2UwQ0kHv6ODgrSx3 +arXQ9o6J0ZParFAISpeRinLDqmI22NB1lq3uRRATcwTJxJBeMLZhNEFeg+mHVu+VYS8se6abI4oJ +SxWlUjM5Ple0PmwyZkNWE/LJQkbPdBe6BXs7s70ZI6Y4OYyPqnQkCUXtqFrTJh2xV83OOWlPY41w +qc3eTdI8g0Ain38erbPWSad/qzvTOmnCFcA0kU9JUtsoJUOH8Zl3yX20IyQ5RbkYoAmXpIIoe5Y9 +se0ZOLEojix7TPqRcflg9jFrPw/ik7x5rptT0FPgDPv9U4YLZK3b7N5m7ad4L4yCE7NKQ4cQ1c2Z +pg2AMxAPDNtiuDZKtUFF1ZrJcn6nd2zYw3JVo+jIi07SFsTDdd6+gR2rbz+eUZTbeOsa7UASe8FB +3r9ZHpDFEOhYlHMzX/3yD//6+vYr+D4F2OXt6s5S1gchBEbzlOcz0+y0++f1hldvOKgdCCHFWET5 +bdF9Wa0anjk83v9MlnIkEs1BYKQ032qPXh2efx8lu5WyoMuFIhUoZ0w7tDfEValiC9Iwad4ABqtV +SxTaGB1mFVNh6G2yp1RqFZ2r4exto+ExdIyHLGKej5DMAp9DbjVoH54OOurJE6HR8CW54/trsJtt +T3mSt9CZge2sBBkObl+zVnio1oIWcpqNyHK0PYMukrW+7ayTDAZ5An+ham340zA6GM/eN7vPRGXE +CT2G64rSsE5FNJtCTkiQE+bI9Zdkw7bZx/mhrskGVL3XHjxzwz2IWwHvQiOBdVWNCe1qTSecJa3j +2fp9b/xKIzfXWkBIx+6PxperzdvO+E4xx/h9GK1Nowd1BFHqO0PTaDp2QVrGqDlEKbnZZPQkKaUa +Npg9zw58b2YYPcebK8ZYVIdgYdUc4iI5IbadEa4zKY4hF213iQSw3WmcHYgqLEMBDdwdv857N8gW +w97dtoAEjPShMFFBgEQ3OMbZFKMfpPsUFz9+zAAAi+aF7c5hAOsU0MAE7Owefrk5+hpJK0hpp3eN +KwQS6la/QXsQFe3exf7pl5ev/hhmGaObzD9AJfJSk+FT5AnArVpzTHOQ5Lv01lduq28B+BVlqDuv +VjMkZL7er1VVqDtWbMo6JMdu2rrQtz21YSscOG4hB8K4HtTygabNIRiQ4bZNFp3qNZNns1JZYlGS +3rIzumsNX7789A9/+PW/Hozf7OxoQDM8qhUTwgz4RlEQY9Px9PV09c4hG6q9g8MvoviA55t1Oq5z +TVHrZ63jm+c//4t/8t+STziUe4IEsboo2s8dbw9JiGJBIilaD6NwHMjXE9QCJ2Dy544/N0k7lQXs +HsXmmrnyo8sguqCYjGy64FJByqCLgugQmAOssLy5ILd4iSyg9cbP3AjnR4BApoWuo17wTawoqRNM +4ubhwfn3aQsAtbD9haa1Lb3wnI7tgMjIvZve6FmzfSlKTUGIPXfq2AOOd2o1FuqU40MEZbb+CChg ++RjlZpE/xhlwrAs1omndID5oDe7SzjXAgWJ8BBqpxUuJ4YxlfUh0TgHAOY3zIzyB7L6I1t3xi6J7 +A+ZC0UFKuf4hvBvPg2hsP9j0x+9Md65ZQyfa1Jj4SUkUuMjzpgzjUA29Udfwvq63HE5fF+2LbTvm +YjC59AIo1dwCLmkTcD0Ew/nzn27f/UlniKxbnJx9g9pBkofZsemuUM6aNoad5/gAXtj1ZkG4CxWH +PIGKE6WWoo1UfQgVtLPDVasaiKPW8Bp0IMgFKR+xgBFo9W5VtQe5HsdnurGQSXBTmnbLJbZcFjgm +VuUh4Fc1R73pm+u3f757/uNs7xO0JUUlT56AFsmfBsD68VziuLOsOJvM3sFggv3hOKDKzi6/z4tT +io45qes1b/cuf/zuj/7jP/qzf/75V79hhFSS25Bz8DWOtwbIIKm23UX3nGCtWeC7uEZFDdI8rgc7 +jOLCNcO+yXoPyClt1+1ZQoU95KRhjiGNeCmTlQ44KyctNt4Y9pThM90c0lzA8CDKsW6sDGuN2lf0 +iSghwXoWuaPdBLKp5ny8/DBev0elb8eVQsXxYgycEaScEwBQUy848vw9oAd8XL2uGnpHIR1vMZNT +C76g82ww/VzXhxTIvaKohDfbkpJpVl93p1aw8aIj21tzYkzRJukblR/P9z6Ndj8a7krSBmShQ0w0 +s6MaZFcb7CR8xGT99XT9taR2K1Wl0XAUtSspOcN6UA6iMrADJORQNxDltFQSGnWdI3+wYJI/ZLMA +I1O80PanYbKU1Nzxx73R26z1LG2d+/ECDkg2uoDKIFx2+hcsHwpinhQXfrIH0BP4Zg== + + + o+5VaxrDuIbehSssPWFB+p6/tJ0lK3SqDSg3lyg6DrJELZUVCF1N7xkmZNXGtJeq1tt2ZQXshJWK +SlMex6U0Qz7kEOZI16ZheIrouOFukBwYNmgoLVXNcjWQlKnjzfICvLyp1zGNTdedymoHlFqpe6o5 +cMKVG+yl+RnwB/AFLZcW12l+TD6XXmvRlMNJPVWf6casQVLIw4PhEj9Yw+8AG/2CrBdRDDSSW61D +bmWms3HjMzs4MN1dBIKD2JPaSEheLCgmwgN8Z1jkM34lOeN4X5RDcVtE5O/FjAFSEX4cVg7Kdrb4 +7Om7v1qe/xzyFQIYmaOoeG1fs7pOuByuPuWDl25yoJgjwCwNmUEHmBAQH8Swokxc/zyIb9PmrawR +8K/UZMMcDsdvOv2XbnjEiR1JG8EFt5snrjuGxoMtHU3v+rP3kjZh+EJUupDZ3cGzON1A+OFf/XD3 ++Pz7py//2A5XrJQyYuSGsKUbcBNGpxnjvPOiNXjrx2eo1kpVpmgL6gsggxrB22EmLe9ANRcQe747 +Ac6oaidvHu6dfBgsXuvOviAN6pQPW2c7423jbJ8X/DDam+1+vtj/crH3haj2kQY07QN1kU4Aokbd +Z9nCC5eSUlAguIpKPvJR7cjkY/rEatWsN0LX2x0uXjNiXqkZtYYJ0BZEeCUXzyfLViWN3xY+ih30 +ypH1877lzLZ+JG/QMcu3ZW1cdG4w0nLFgG3s9l90Bq9D0vYigb6t1rUG6dPRYylvZ0dkmKQ7uLl5 +/eNw+VQ2Z7zU5YScF1pxeky6+sptNzoczj/sHvwoyDAvU0VfyNqI8Dvl1hqYk+5w+GLv+Puj6z8e +Lr9sMEml5pAL4wsesKZ2ZWPihmdJ8zptXdreCthIhEHdpVl4xkEQnkOqbT9dn6jHOuVsW+rEQDw4 +a8WYKDpqvB/He60OaXYPqo2S8+7gLoz2YUgFKbTdUdY51byF7i3z/rPj29+0hq/JXbm6SZprC5Hv +rrL8ClbCCQ/c8NDxdoNwI0vkM8Yp2mtQPhC42b0Kkv3tDfexrI78YA82gRVbvNy33c10/eV4+RmS +EIBDPnDYhFSbFa390eLOTfYHi7frk2/WJ9/b/gGKGqFpd66Hs3eatSvIY9OemzZG0RVk0tZHlBD9 +/enuF1ev/zxoXjIckROyAj0wt9yh5fXy7pGXnKk6WRhBWaG4anX4OLI+QD4CPVmG6UEQH0MCWfbS +MueNRlCp6gwTikKLfJVyFCbA3w12TWvJsCnQaecJ45hDjRBigQKH0uiNn08XbwFoNGPwgtds7Tdb +Z092RIC/pLQpPhMVWNQRWdqtbj8D05z54XGUnOJ9TRss0KWo1PMO4bJpWLOyjGdirnh5CPqjmbxW +c8tlReZT2+qRmxpa3wqP5offnz79VRcgAAZXO5D3q8NPWesUpF8HFIhd2zsK0jOAD8WGyARF6XQ6 +p8Ph1XByh7mtNRKKyYFdwJZK3aD5SNKHUX7dHt1FrTPdXaoYr9Deyvh8azG6mgFA3pO1OS92qw3S +5wigZDqTrHOZdp7m3VvbXahaFzpBkEgUHB/CeB9wBBB23Ilh9VgxAuSiHo+uf3j62V/62Smyt1I1 +KLKCNzTNHkfWMTxwTZxfAoqD8KBWg9HWYck5Plb1puWOeSkHpoVkHRUmcclyKWDTcNamswqTQ0kb +wm05wbEbbOAaTBuCf5i1T4fLl1d3v7q4+8PW6E5QxgzfhHYNgs12JWruhift3m2Un8jmCJ63TrAr +j5NNDqlWnMjWXNRGhr1MMrzpvqjCJY0W+69tf5dhM5rJKDbTrRXMKQFqIavVFElOWp3jvHkWpiCX +IcPC0GWi2I7iwzg+oomhbsfpiRcdqtaU5zuVqlep2gKfuuaEYyPS7geerns1nN6lxRnEM835cbI3 +md5F4frRIwpCNMoOiv7zIL0xnQXLJqWSQtFBlp877pLnE47LoSRdQC74MTj2/H3AXaPuSFILqqMG +xGASUUN5jkWhUIRchncwhl500B69HK0+ZMWRaU41QiXNZvtod/8Nz0VAVJgRXu5qzpIWmjUqYISC +FZqmMZbkVFZTMLVp7anaRhCGNNuk2KTaMGW9r2x363FKodqz9ujN/vXvustPkDrIK1APqjLNLibz +L/30env/pQU0Q+EA1bct5pd2cIhwQ8sRZNZ6NBNQTIC01Mxxq0f++JrlM1T3fP12sr71krFqDQDa +afMZyEhRC9Ps0qxHMY7njfFaEH2DLCzHZDVbarXb56rVcf3+/vkXUROGq63oI/KX5g2fZmM/3pgu +VErOiTkEvBsfJs0rIr0E1EWMUXvBNErHXjCU9S5If3P8U965Q9C3rY58J1ipZp+TMl4u0s7p+e2P +hxffZcW+bXWhRvxgd7x6r1qkoBiuBZvjBPvT9YeiAxzwGQhsoYXktPwDzVnRPCYcSsk0zH6a7cH+ +mM4uUNENTvaOfx6nZxDAitKrN6CyRra9lBXY7Y4gdnVjVzf3PP+QZdOdktigHNOaNugQNkrSxv3F +q9b0Q3/6mWmvSmWtVFIx8zBfujVhpQ7OgLKK0gsfBKGPYArKVU1S+mBV3ZiwXO7FZ04MkOmDRgUu +A2ZSDW+rxsf1ul+rOjQDPUPu+0NIqHqH45NyRYV/tKyl663I7Q8ZSBt32hcSZB7r01JO8TkndVDF +mrFOsyuOT3VjYCETzHGDTstVn6JAqd0oPUk7l4o5ENQm+fMBdz2efzi8/kUxfAG9QfaxiAWJmtyU +IaukvuWdueG17R/qFgRGtl2DHWbF9fEVMOEFRDVkWB0Cj4cOhyVHjkVQ8s3um9Hsy6g4Esg2MFcQ +E0UfaPaEk/I6ZbJCFiQntr9W9e5OWSY7jijSQw2MD2rgMDSphQKPinPVmZVrtih1UXcUncpKDwYQ +BKeas6L7Ala90nAAwnF2kjafQm9E6Z4fTkU5CbxxURySdQl/VWeScs2r0xGgxrAnjBDUGTdtHu6f +fnZ19/Pt/m2v1oAQjQN/3eldi3ILjiZJT4vWTd6+CZIj5M+TJxTD+IYFA5uxUsuJzpv9j+PVd06w +R+5bcXG5orBciJBpRAVFFWjpigaY9YI911+xfAKE7/Zv4O9KFatGJYzQKdVchAbKNoqPQrI75QoG +mZMKRuxX6bzSSBVtNZi+b/cu4C8EIQFPHV/+8OL9X3SHz+HFylWrXHUEsQ10JWatEZjO8v13f7M+ +/4Xuris1r1qxLXvR699B5f69/7D++IkoK8PD539+dPPLMN7HdYJxMA+mM0JiN+gEUkExDjqjzz/9 +8J+mxTPL36VFXEwL2MLJsCrQXSvN2qA64nTf9gYMZyPiDSoV+YHnHs3Xn6xo3eCCvDg4f/qToPYV +YyRbAwoaRhpCtqFOdWtEukJLBTTtcPrNbP1j1n4KuQsJJIm5Bw+bHQQJTlKUG1DIwyC47nQ/88Lz +ag3iM8QAu+N3WedOMoZ1Lqpv94SQ2a6plaomikVaPG0NXuPKKTYoV3VitPkMEhS61PB2W8NXJze/ +XR7/6KVnFN6iYmvqsF4PymVy9wRTKsi9KLt88eE/mu99w8AlOZP24LbZvfPCQ9jDGu3V6MC0ZjFp +xJzCPpDVMH3c7DxtdhGREVmHkQgOaOZA0tq8jB87kjqS1YGm94kVaricAD+1gMhn+RQ/NihXFHPL +mrrenGw8dqZBet4Zvyu6t2DJClkSh3oPofw5jnwUEuR6taKLUisIYNUP4P5qDcinOMsPIc4rFdOy +9/Yufxm3rm3nQNfnmJMkXIxHJ6Lo7ZR4WV/Y/kXefTdbfe8EB3XaLZXkPNu/fvFzw4GVcB+X5Goj +8MJjqGVgBUw6ZFVC/q7q1I82NcpBPfLyWDdXs+WXx5e/EqTOk8dkdRReRnNmkCU7OyosANJGtzF7 +VzBoFOT9+DVmdXnwXdy8qTay/+3vyHH3//cF/H91PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7ttx97/+HTkOpL8jx9/T +9fmXb2Yvf/by0dXqkT5e5y/w88nL73729ttHB4/0F+H425/NPr7+2cevvnz57U9SB7+KgiSTwpO3 +Lz+XrN8/U8KTpMNvP77/+CV+efr65edvbcnDU7v471EkxVK0/d/VT4/8VpQ1g7SVFEkry6JWIbWi +VhoUUavZTlrtZhpLX/w/PqmZBHkepXka5VGSSp+TJ5HfZe12q9XMiiKT/t2r2u242Y6azf+XJ/3f +3u7zf59r+vzRh0eXj758dPyoLVm2dHWJUY3fPvrm/xxcTAa3nb/Fx8/fdn7/7eQtZuT/mEy8ChOw +fBTO3v7w8fXbk+VEujp49FTaziY5g7/9DtfS+r9Ggm+fSUkUS3FUkJd/+Pd6AfnHf/eif/f/LSnF +NcbN7eVm0vYMj3R9e4Uk/B2pSNtJ/Ohq/R9ICulXwouJqnc1o6+RhixdTujJ2ky3F7I6FEXysfyy +2vH8tWnPdGvESwXNx3iVIBei0iYNlIXYMDq2O4nSXTcizbk0vNaYmu4ewyf1hlavKyzjkK5S7tSN +9u3wwHB3FXvCK02KDcJ44fhjQWrZ7m4QHiX5pWrNBbGn2StJHXB8TjOhqPQUY6KZkzA7ErRepW4z +fCYobZaPKNoXhMJxF2l+boe7mj1m+FhQmoKSalab4j3F7ETFadJ+1hy+c5NTvJwRM5pP4vSkNbpL +Otdx8yLvvrCDA9kc0UKsGkNZwyRkDdqrNyxeCEQ50fS2anTrlIX3EqUuxSY0lzJCLpFubhNZ6+nm +SFZ7gtxvNm/j9EJQhhSX1CivTvssH3vB2nbnNOvTjGeYE8tekA56DOlnxPGJZY7b7StOzATST2pU +b7jlioZ/ZdmU5fDIVX2mmnNJnUjqqEo6AYX4JS+0BKGl6WNFHbBcJsk9mk3Ih1ELOccXDJswXGya +U8dekG47XFGjglJFw6Nas+p1DCRR5KaKBGBCinIEPqpW1VJZrDVMigkYLqGZVJT6otjB2RoUrjxU +9AHLp9WaStMBLrJaNTkul5WRKA1VdWpYC8uezmbP8/Y+w9q82DLtZZAeWN6cYnyqYXNshhMqxkxQ ++g0maVCBpg3CcM/3lgKfRdFGM4esmCIleLHQrYVhL1W1FfjjBmXhgeT0giPD2ZN1ZNcSyUl6eSst +mnZFufCivbz31E9J503JmDBSLsrt22e/GkyfCXLOi7njHbR6H+PiuaxNWaFgSI/yiA== + + + 4ULSjJ4NMV7S9lefsEKLFZp1yqvWbFw2nkDaEhl9TmqKas/x94rO3Wj69vDia1HPWDG0vGXUuu7O +PiadZ4q9UswZInJ58Yv14Zec2mowgRMcDmdfNvtvFHMpmwtObNFMgGnkhZx0YKTcclWnmIh032bC +ShXRMVg+k5Dw+kDChEttTuywQoeX+6LWJR08lSHmEBmIp+GFNBshUWt1gzRXJa0zY5rxGw2XoUKW +iZBgSCSBb3aKyyI/q1S0Slmt1+1KVS+VZQQRgxXkoaovBWnMCQPT2FjWbr3hkY4YQiErfYQMgMAJ +wIe5Hx7yUr5TkZ6UeCQnMMVx1ra1QrGQs9VdmiYfZr5T4qsVWeASRRmp2lgSm+WKisvg+axWNxuU +jVyimaxSCyg6YVjSYUq11wRYKBujqGISqjrPF1F8kaTXcXypG9NmcfbDj//s5PqLx08atrdLGiyO +Xmj2jHyKOIqIIy0z6rRLPhabxvTmbrhyvLmMDJfbp6ffetGqwQaVhinL3aL9ImneykpbkpNGw9q2 +RloBYTipw4gdWZ95wWHWvLScOc+Fnjdr9q68dFexeoo5xswbzjJMjjb7n4fJniDlSMsgPvXTc8Wc +s1xLVPqcSPJt+9HiWh0j4kIUoCijdrqyMgGyyfJIkAqKcUm7E6ODnOeVdpiczXZ/WB19P959y2uZ +YnTcaOXEu1a8ka15lF+PZp+1uk8Xy3fN3gUQWBByL9yLm+eWvxHUsaRjCCNBbANeSPvUugUoqNU9 +QeptG/t6CFCtbgsi+Zz8OhPU2JhBWMWxKM+8+FLUezXKxDzb/kGDjqp1Z6dsAGc4PmNYIFgEmGI5 +8pWhw3rNqlb0WhWh9Bk6cp25YYyRUZWKXq0Yv++BXqmqFBMKcs9y9jVjoxlrzzt1nAOaQVb0WdLD +qMXxCMFEkMe2e5AVt5LW26mI1ZrGC6QXmKz0BKEJKMBlb1vEJjs7AlKr0TB5LpakES8CQnOGyRRl +aplTVW2bRheFUK651XoMlBZI8/EOJ085gLaY4bTlikywTmjq+hhPkGRQ3igID4fTd362efyEMr1J +UpD+AizpoNQHGvBiu74lApQVZkBScMImS0Lc9OzZ3v5HzezTXCTKLY20LFnxMmbSBYBIUst1F360 +ywm5bo8kvS/rIwF1rY22TW+9ND0Yzl4G6SbON26yVsyR6S2daA9fZW0gyt1W68KNllXKrFEOz7dM +ay3JAwQUGELaJbCAL5S/V6cCiilUbY6p1k3S3ghzKytdResa1sh0Z5pFPj8/LK7c5EjUenF+FmWH +hjfzoqXmjYve8/3jn4bzj5h/1AjAxHNmQNRyVUMKOe5eu/cW0XG8PdOaSnIHsEM+dZ8JgF3Vuo0c +4LgCBCRKgKkcrMcgstJQkKaqvomyO5QMK2RJcmr5+zXKr9ScSs0FW+EkAD1OSMBiktJHvdNUAHSi +Gh4eJMeqOgdekzrbJkFWteY2Gj4y4UlJ3DYvyzRj2mDiegNXEjYoQGihGRPMNgiR9P8CMLIRL3UV +fYk4AtNUtcfxHvAHiU2zgKMUCCmCRvm8VFLrNbdWM3d2JIZp6sZCBN5KA5rOVGWQxJswWJSrKi6+ +1iDcR9HI7YFuH4XpuRdsAG6lslKrGcCuUlkol2VZavU615a75pVBnQ5QESxvbfuqjxAjyzvg5QEn +kgbTEAOG0WNZWxBiSe1r1soLjsMYoRwIYgpyHM0+cEITsQZrkF4YBumPhvOguFxvk7XPoHbKdROg +B7A1zDly2wt3nWDVzE9/90d/c/XqJ17NOTlVLUiyTZSeF62bTv+ZZo3JKHBmNhXEgW7uOcGF459b +7hGeJohNQ+u6wW6DzUDWFJNhJm13Y7l7urObZWcXlz+OZ3cURxqUB8lpe/CqM3rbHr3x4r0kPvjF +z/5J1N2r0i5LOrINMVeQB7a9hLzZqhQP5KJsm6/hzHjQhAigfzq81C5V+DppHJaypGx71bpP0TnL +tR1nZTnjUhXY4lBMW7eOHP/U8Y80c7nt5wLBhtA49bpOuj7V9AbtSmAWdYgI8lxBURFFgVz0et0E +AREBU7PLFbNW94GTSC0wCCCrCgCpKk92GGiwWs1pNEKGSQAUCAFyBrRYrmlVymaFFElrOXuqjqLo +Y9pR0ZKEzBnj5MAZUF6lYlYqFkXFAtduYBR1j+fSSkUGiO2UFNAWns9xSYmgpcFB7LHgI0+UMS1t +Qe7q1hKTpqhjaDCeA3ZJeCHD4FVFtWGWamapamF00/G7WkODLoVmID1QpBYv9U3nIG+9yJvPfX9p +6nm7eZC1zhRjhASDbJb1juct2q2r9uAFxcS2PTKsIeQiUR3aTDWWtnvU7r9JW9CxTcgSP9rIWl8h +oNT3o8O8czVbvv32+3+8e/pRUAvdmVrBnuXvwTL8vk+ZrE+Q5AA61IVuTt1g3/EPNGNhObvgStff +36w/X+5/1WBzis0lZWhaM9tZ4rWms0rT0+HgmRusOIn0Sla0IXRgnF+1+i/tYBNnx19+/ZfN4QUS +nuYSYJ3hrKDYgajQw0AAhsvxPSiD5xLSvNheAJcIlUh9SRk1KK9Bwm3gUa8Dz4EVE8Bms0V6DVdq +BvKE41sM3yaNS8SurE5UbSKKfYYp8K+lilSra9CiDBMAlyxzpmsjTR2axpxhc2AUC1Zlk0rVrjdI +17x63UGO1Wo2IitK7Qbtg93KZZFh4mrVKZXAmCbLgYxQsxDJIYhDAG2JHWSaLPeJ/5J6SDMSGqmj +qgNoZpwT+g3nxPUjtSC6atDzwKWaRdR7zSiXdaQToeOq8XukQv7Icg/05Pp7kGqQ98gxnBYBFcSi +UXeg2XBC0imbj8uYBKktqT3NQB6mtbpO+sYCJKU2iYW1aXXf9qefvOBA07q20dldvR7P70SlpRoj +zRzZ/jxO97v9GydcVeuu484sZwqNl2bnYXwZRteoWS8+l3XkW6Srve7wmmJ9qHFZGXT7b6arT8vD +LxdHn5vxQrfHk8X7qDin+Oa2Gcowys6z9vO888J0dnFJljMjfUXZlOEBJv0oPc2aT6fLz5P2NcV1 +BWgtuSOTgQByJ26w53i7xFGKbUysYU0g+wW5HWfn890vw/zMSw7bw2tebtZIDXag4uBEwLzgEUh6 +TZvijUAclaqpKd0kPYT5RUogIpB2jnek6TOmgereIk/DR8R50thopBprfIUwloQO5qFU0Ss1C7SF +a8OPNA1t1q7WSBehSg0hUxk2hAdHrKFUbXNRZJeGsWjQ8NH+1pH1kB6NOsxU1KBcvISiYdbgkVOK +Jmqf9AKuQxIHFDix4UP5C1u1AHhU9QmCDr+ATLCdFb5CIOFHvJHjrkEfIHEwYKPusmxWrdrlsgIc +I6KuagEJWYb0lCGoWIcdAxc7VSRY3cYb8VwTuQRRJ/KFqU+qDWSUjGwslxSadI0fQJSCdit1E5PG +CVGlwj9+3ICClSG5mVhVgZ9TUv7uQlQ7NCHl3DHHw9HzIN3HaR1vA+0tak3VbHvBUDfBWTFZK8jO +oXibraeGvYY1ZoV2jU45oQMdG0WHtr+oM46kIjMHjr8ynKnhLQR9yKvdKD9b7H0dFacswMGcSTry +duMnZ054bLr7sNt4Pg1xIhbIBIZPTGftRReGeyTqCwleSR1DyQBst31aOwyXongbNMRM1/NPSQtC +xgWegKwxXigugbSI7cva0A8O8uY1zSc0F0L2s6SZLwQ2OMWGtEAEDX0cx/ssyrAsQ3vj/FvTnTQg +fmoIegxnBwDBV0keWs6JYe7DektCr0aqmPRyRS2XyjBoQoOKObYHhUyCzpBW7PCzSFcgEhJjO+dj +QezWqRjaCUmiaRMoc0nILK3PceFOiUU2Iq84rsWy4KkWCJpjcwvmmnaf7NBV0kgXiBeJpKCgS5Fm +rm2vbWcX0QGHQjMTnb/taYjfVCoqLhtvQYZAuEzEAwDI0BnLFsg3XBgENqifUGfNJO1E6y5kGyoC +tNtrnV2f/axUVR8/YXEqkW+5UMvegBd8cjE1cLpfrvBPHlerZR6wxqBA6jZkJBQmwtGgLTh9iGrb +WrjOynbnCCvss+WuJKNXpw1BjlWtadkD4FVcXDjBLsWFhrtipWaVNHhqIsHi9DzJzwx7Wmc82CVe +LsCPNB/xShMOznB2W/13YXZlemtOLqL0GGmGWJMm0eYia7/szT7Z8bGok+6xyCteaTW4AK/ykhsn +urGQOdqQ5pFLUZqdBckhfAfxcZSLwgQr4eLxIyKFagU5wl0a1ixp3bjxiUwarJP2c3B2truwgk2D +i0s1Hb/R9BGqD3OlkLbLpHm9JLTwFiUSAgZBhCJimVASctQjIo7SBjJTjIcpRbYg7jyPkiyQM6Wy +SoQ3UIsNwbBlolss8AtRTTUbyAZWBQOKUosmnjElzEt6yCLfYEUhtAzkFc24tapq6jBH0y1TY4xu +qWxQjRAxhTvb2WkIfKzIbZo0CAsrIFACMq6mTlz/CJhMWLhh/b7xLmkJyqXwtoAppMqTHapcEZB4 +MLyiAGqzUEcwpIAvgjZKy4dZlrrb1Q/pCWmubWAsotyEUSKNEflY19sNSi9X2HKZrpRZmvJ0bei5 +C0EIWMoIvBEUJiCXpn2i95RWHWkgBKrWQrDA72RyYK4bNll8s+eKOaQZx/EnktbCb8hCDQQqQ6Cj +6Ly0vF2ogrg4pHkfE97YNpCloFrlIs6OgvjA8WZZ90yxRpI20Kw5PCmFTJBare5de/iKl8HI/dbg +ZdS81t01bBdFWnMOk/wq7V4D9KDTzHDd4CLS9LNOGq6BDePkBEiLIdjuFGkArULULxWybBqFx83W +jWoOWcbv9C/tZFaj9Srl1DA0jnDlZPZ+svuN4ix4MY+zQ0EB70CNGFC8CCVoK0/OLGtWqSkUZYhi +Wq6IqHSEGwlAWpqKOcODUhVOiOEiaSaBtAZbVatupYp49WDQKNppkAdZFmsQ9ULysFTW8GRdX0Ak +wHGwQkyxHoK4s0MET6MBetIlKaMpR5GyPFszPIAOriHewtqQoROqAeR0KhVJkVs8GwK4wFkMk7Kk +g21B2lOSFV3MT4F3r9b1WsMkXddruDATDAX5VK1hFDrLBVuJJe/s8MBhYNTWI3i+t/rq278mi2Ml +rlZTIfPwS+QtqLCGkzNxv385GJ4gqai6qEqBKqWwn9tsCYFUklgMRk/hxeBGkbdbxItqpP9v4LnT +7dKKUa/5LJNwpJ9yrukDsvSktGerV5rd3ykrVXhPIokj1Rh3+ne6NfPc5fXLP6hSGlnj4uGjm7Lc +NswhUsvxFv3O2cWLn8xgXt0mBiBalgdhdLY++Kk7eScoPd0YhcUJI2UUF4O5VMj48LA9eB23r/Jk +/+37XyedgydlYYvPpC04itF29mVtAjs/GL+Efq5UbGgG/Ih/db1d2GTSyV1sr/Y+qk5zp0QBK0jv +eKWpmYPl3qfl0TeGt/Sd2f7Rhwbn7JToUomX5Bbps6kOwmAfhIUykZScF+ItPckNAg== + + + KcQXI9tFOWM5N0iA29HvF7pLZXg9ONyeCQ0mQgilrjdTtO6THX5nh4NPB49sSadpmLsy0Q8pI0TV +urrFEwOYA7cFhESlQ2757iQtdquUuV0Wg9GAwEsISVUduuEpUst3FxxSSMp1fQhbByAl7apBZCBu +Ph0MbmS1BexCRSAVea5NbYsO4hwZpcqpYyPHkFoKALlWhegiLwStw1Een39TZ6xaRZa4GAYE2FUq +kYuvN0Aurbx5GkTLaoWXeFeVQ46Bs4BPcWSlYztzwJ1mTiGTaiDTul2pwL+4HAKhtExrCEgHBTfq +AY8MkTNSmCQbW0l0NJq/VI0eQJ4nq38o8HgrmAuWrJfOL1/8osG5stw0zbGidIFjktIRpEKQ0kH3 +9OXH3/rppk7kaI7ascyFHx40+081e9rYsrnmjquMo+idonUqKF0ORlhqq+ZkuXj569/9Z/PdO7yv +KvdEYBoTIEUVdeUG57Z3kLSfceoYdsyxoNCAtOD3DO8LHWto4yDepzgPM2wS4dRjOJ8VAmCvqLVF +pTntXf7uT/8lKwalEicKUZLtAWkRo3IFteNCqoXxGpYHmMMLEcf5vJCCFHBmDDwOdj9++5esBLeu +bu9JxfjK8wXoD1CTpJsXL/9wtnoDTimV2FpNRiaAXMpVA9iLGKn6AOAAXQc+BdpAG1crcrksQdE5 +5jwM1prZqzQsMCZwcqcsg0FAyobaNdSeY03CcC2JeRrv0owH2NnZYSkMnOjkAnWaFcea0f49DNbr ++tYeGsQngr752HV6njvatuGGRCSZgwSDIMQDAcIElso8HI1nLwGPjx/VyiWcHGZwCLCFa4CFrFRk +ikgpHW+N7zk2A3ZtbyLYnACt6+2UJWAUmFEUCwFOnM/hVsoVksBVAlyGICaCkJrGqFlcWMEuRD5p +r8lFDLkj5vJShqTSjKHtLWAhdWvMS80w3o9bp7IG897VjIGktlW9G8Vr1RxUKNCZRyQ35ZH+wmAo +ygIX68YA84zzc3JL1noAw2oDJ2/54X539KIYvXTTE0HrN5gAwEvMOGVVKVvW+nCjkjLSrA0nDcPo +IoxPIK4ajIN44Qoxb/UG3FZKpDId1mkkjFAqs/gq4jqT07x9kTf32t1DiBwoHAuhrPHlCocfMRWO +s9GMhaLDbyaQyhwf1SmDVBP8rzlAoqbpZXt8VyW3nEwUVKWCSUZ1S9WqTFG2YY/daFczJ2T1ifUa +da1WUxAIRJ8jK2btBp1C5CvKLIhuBLlLLCEFxYVw2BD2DYqs3Sn6PG0+g5sgTL1tLl8GRFR1jnbp +hivyWZbsIxkoKgIm8xz40aapAH6EYsh9MdOc4jk7kNllFe/LMKQtcplIR5W4XeAkuWujAHksY0g8 +CHmoeFC0L8kDJAkgi+fgRj2UHjxyuaITi0qTizH1GYi+XrUcfbJTkh49gu4inbWJOKmD+mUCoWRB +wwAdsxipPAJsAjzJokcVqZWR3s0MEikC1RKucVeGMWahWITEckaS2qS5hBVbDN/lpXGSPesMPySd +WxgWRe2CRgEjyGFANEiQYjOGK8DaeFORzy1zRHG+bnRNc2hYi6S4CZIzQe3AwkOry3DQcpOXCid6 +GrffuekFD7fI5bzUE8k6Q9FgLQbiUB12+m+d4JAX+xSborRFuQ1sQfljXBwHFbdQSJP3Tp0sEJnE +gzdsIK1q9QU1F7WWIMGRtYmuZkgx8kIiyBnNIj8TOAs4VkHug4XJXUWxCbKG1MSIttZ+qJlLQexJ +Ypd0ui/xVAPTqJRKNNiTYmPoSVZoSUR3+YAUBBQEUa2ohIbgExmcsC8pyL0WxbYkeaxrE5bzSXps +F0sRI05si3h3KE+p6zp7FARPReHZiIdorBlUHZQ04fg2x+U0DbWJhIFgLpC3ggQBP/a9PddeACLo +RlCvkV7Jjx5VIaKqRPOoOyUUGllKrRPzm8Fu0MRrmE9KElC0VvNqNVx2kMQbBAhZLbIJx5AbqQBD +DASvArVJ/CAPL2E2SyUINh3W+PETDgBOUT5ZoAPbwjzSwNKOrk8BKaD+WtXBC2W52yBLGWqd4Eyq +KmPf38cM4wJ0rVc0j3k5JQvvQlszN3503ey8sYMDGDHMRpqdGNuGxQi3pvVse247G1UbgSyqNUuX ++838rMECok1wsRcdDeefkuYN8odiYjc81qwVqUc6iIoXXnolqAMES5R7XnQS5teGCSXctP2ZpPRs +b5cVMtIdmIfT7+rmlBcwURr0HoRNg84bTFGnkzoFRmtrGvTPEHmCohDUQjWgrJYs/B0bVatao+aY +BAmzclUECZruXHemFAu8IguGjnfghyc0QU6XJXcDQbtduHueb9XqPnSygAqi7VKZg/8indMxUrAG +po6ORR6kUNTr/s4THuUP+Q01UiGrXuCgWDd3w/Da80/ISpE+ESVcgERcHuUA1SUiqHqOu8vQLs96 +utKulIUSvFtZ1+QFXgLGJLUP9UuHEBssl0I7gZsYOpOELr4KbBuF9vhxHexWrZC7k0+ecI8eMRXi +OgEdEcCkCmzhCvD1kx1ZELoch9nr8HwvivYNA5q28O0lxya/l471qoms49kcnkXkm6WSXCdOUwF8 +NequH5xilrbLFxYKGWlWIzcawMtenYQpY1ko1byMi6wYYCJEuV4nNyMgxhrQe/rcDQ/I5hPKkdWB +rA5ZMYclKVUV4CFqJ86OQXMU2ViSsTw4FMkJXnAkqaVrY9taWi5UvcwJPqKs2UPZJLeKDAh4b9f0 +NixZLIK2AYC4OG21boAQIWgVcyHqM4ZtH0zfH55+XgfxNVxkMijMJnuBwKdxlYzIaTdP6uRGXihI +Y8NaSuRG6kBWJgxfYP6f3f7y5vlP8GiQVeUqnLgvi7kqd/JwXxJTlhj5Dvh6pyqUa7qijfzwMMmv +HW8fKkvT25rRLVeVHUIBGcENviAPNiZbcbhEVfGvOrnLzwTw+JB8ujoV+F6jEaNmeTap1zRYM5gy +XNV2VwBZ3SrX4Aezdn5lma16HfgZ1ilcmFGtgWrxZFPgIlNpuuYQ9FSH4IcnQorWQLXQPDLRwAIm +cAZggeVk6VgR+iqgVZvKwoBquE+e0E9IYmvIBHxTq9gwBRBRDOw85pDNdGMFWqk3AnxtAAZrfqkK +m+ltb0AMfW8ftAW/iRHhQfbhAKx2BHIlkHAYO7keJH+C0qsQwvUk0tUdVOJgNuAfFRWSg6z5A1tw +WphljJ0iMQIRy1Uo/Ia3XbJAufmVig6yY0g3eWSsQJadkQM0XhUC3Hg4ULmnGlPonGpV4nlcAEg8 +5/B22xvx0Jxpeqw7w52qDBYw7ZlpTZAnDTpGOVN0QhOgVgXOV5UcF1ynQyCMbq4cb687fBO2zyG6 +kD+mvYByIOswKOeKjAsQxKYk9+qNkBc6HN+sIOERnbrNMIkgNePsZLF5P5q/gCMQeLLsA9JHRvFc +CvmqiIUmtSxziAkB7JAlWUi1Bkls25k59kQ3h8jhrQy2tsv7GTIfpAAphSlCwgCpoAl9bwE/hclk +MByykB6VSSN1xCWk6WBLFhbm+clj9sljplrRGDoBcWigezakG46hIxAKsQCg1wamy4VypuoOwrql +dbNc5p88biBL8Uu64ct80zBGW0nm6GoX0hHsDG8Lc4q3QDqVSgregtw1ICSI962XnuDkqiImspCy +bE6zbYrFGJelqr4D7m7Ay+dIfk0bef6u7a0ZjtzRIIvMZenx4xqolqV9hnLLZaQ3hgZLiHngt6uj +TV7MWTYkkMhAGDRlpU32R/HE9yHH4HlZspabkBUwUoAgX79atVDpuH4kKi/knJTXaA8TiHzDSxAs +fA9VGUZ7ees8TI5ZsvzoQ7bBftKsxfLwRxny34JGjSH4+3UGL7eK5oVmkOUgso8FEEruAiNkESyh +64K2Wtv1eUgXCLyRIHXI+qfSJTvuqECQ2kAqxBfwCCVPEomARoCC1Y0ZmAtxhNpBQFEIMI+yPvCT +AzfYFcSBqs3wWiiQCpIfgKP0WDZBemBOgCQU24QkRhw5FhOVGsaA3MUWuqo6VaQeTe4C4OI10M32 +XrMB+wPV2mAizGS7dTxbvXoCZGtA9za3e6V08FSlCuXvb+8uRQhKpYzyV/GV3NErKTs7cg1cRgXI +E3AcwIGF1m2Y0HIoZFAYwkeTDWBILdAQpItS2qFLO0hOFV6+QkYaNrNLRU0fP648eVyjaiSXcGGA +BTBmbXs/EdoJ/wTTgW9wEryLQDacLHVzDqkGGH9S1uCRif3ZegeQHa6WZkHrbVHoQqsA/SS+YGlv +5wkssEIkIrKIjiGcNIPsQlH0PqQOLxaiMtjeKSY37wxn4kS7VrCqESsKyZoQJal08SBhqiNvYx6v +IkYspLiQKHmB6ByTbKHsC2Kh6wPPm3jBzHIWojJU9ZFKVqKmopxEyTpOj2CQRbGJMFUpt0o50Ofr +3S9MewCHzotJpWHvkKH5DagFckN/QnZyakORbNuIdypWqWJxAlFK8FZAbzCpqPQNey6q7Z0yD+9c +rRnATNC0pAyhlkVphGRuUHAQOhhcVHrj2WeT2SfT2pMVcg8RhUO2oDTIrZPtVk9zu9euxYs9GCUY +dkAfKqtB0CNk2JahL20L9JEj8ciyw3azDVnBLinVCtntiaG53sIOVojRdiUzID69rNIwhnSTouFQ +yFaTBlkFDSoVa2dHAott9TBSy6pD+bBkCVQUclMbMLRZqwLWUvApHBy4hmHJhlJZbtWryuNHSKFG +pSwDgZH/0H6yPIH/IoaizKki2d4A8qpVze3O4Ygi98ExRhlD3t6cUqFVGGJCc5ZvkkHRZPtHnazz +648eUU8eMeSqCIXlgtiRyO61Nr5RkRJigrQsk/Jxf59aLNe23HXSPAuSAz9ex80j1YSLnxnu2vLW +UX6atm+K/gteGXFkYwkMIIzwGMEl914FVH1PkIBmAYEjuYn8tFz49BFijfhaLghrrZt9z58H0b5m +znVzppCb5kPHXS0WHwfDO9dfwsiT1ScOjqwDLQSRDDek6UPY9gYH4WGh9pE5vNQxnIXlb0xvF2YN +anx7z9fb7nQdS2qfgkKWun58UnRvZZOscoM6G1vcK9ds2EnL2zfdIzBsiSxaAtli219a3gJXW63D +iGWcQPavms4crAp3CSRHdgGEWbK9BwZkD2PnpDaSDWrHsoaqNhalAZIWLo8RkCRwAXmdLFYTTCCE +COIWclnt87hgJqP5tMGQDQzQmRycMo1SbdfpVFSHtruGam1QMVljpNzt3gMNqgmyFsZTEFqq0teU +HvIK10ORe+iEd8itJRHx7cCJ14jtBecCRiBXNIqCO4uBirIEeAG/t3xvWm/oAF7d6MXZEQoB+Im0 +VI0x5C5DzFHTcYZkbzPlI9CIoKxNRXXEkA20eZkgHpKH3HYEoRAY4VMARZCcJNlJmh8j3HDQDE3S +ldyKZTPEUbcxw6v+7DZuH8MNRfmR4a1UpES02+zdDFcfs96t4SzJTV4hTpvHuj0HPg== + + + KGRloIfouOFKd8ZBuqfqfcdfJu1T0yPb80x3FTfPuqPnrf5lkB0p5hQUFkaHMWSVOdGM6fY5cydY +9CfPTW/GSgUGotm7ln/kRMeGtycidlrf9pZZ5wxAlDSv0s5zzV7ySlezFioS1RgDELb3JZusmEla +Gw/bn/vxflxchOmpYS81bSIrQ1AnTZYs+gLZuBhAV7PQljIiC16GusjIbRS5ixPioZl4Cdkbz/DA +GU83+khgXmrq1hw+VDPGcXoYwIw7M1UfataEk9s18BoyUO76yZEb7Ylql8SIicg9UKUj47QmKGAT +pIeqNVGMIa5T1ltQEYLSsv2FF+2h9HAZktbHG4FekcAME/BcKAqwUZGuDXV9rGPSVEw7QLiPESFd +KShSJsJL8CP+NQz2QBaA+jodkQ02dAIGh1sxzXGU7Ba9k7i5F2bL+cGbKD8h+3+4pmrMNHMla2PT +HmfJKkv3ZL3PiDkiS5NtYA7Oj+EQUhOgl2yW84J4JkiJbrQsZwwJDR8Hw+56J2TjnIPZ60CTgPt4 +saWSAK2z3pkVrsPiJOucO9HKjYBdAz9dDhbPB6tXXrJBDgTRbPfoMydcS9CH7gIlH+XHfrpvBQs7 +JF6vP7yZ773V7TEHCHKWSfMUedXsXxb9p7q70e09UK2i5ZKKKBfAh6Q4iopDL9lDttBCbocb3Zlo +9tj0Vk50FLVukvZN3r0NslPPX+wefpW0ryg+U81p2rpJ2/j9RZCeqOZQVFtIFYXsjU/AtobZ6w5v +RotX7cF1d/g0iA+BKhSbmu5SM8cs2cGYbrdGhLBvENvbm78u+eMOqalqfdOap/mFE+4a7sQJ5nFx +aLgjXs5Mb44h4+Elh5iozvBZ0b2MWkeKPSrDvAuFYU1sf+0lR/hKBugtkuJkdfBZe3JrJ3t576ro +3+RkC/dBZ3Kbd4+RXabT643Px8sXefd0e2f/95vt+6o19IOlpIANHRDf9i8Cxm64DzYhhFKckCw1 +hrIBPMdk4oX9ID6Yrd5N1u90ZwGokfUhHDq5Zc+HstIKkt3+8sVo983m/MvbD388WL3TnLnhQQtN +ahSE0MSwF3FyOF++603uMEDLW9LbBQFRzDRzAHWkkR2806Jz1h0/zbtnYbwgf7AjIxN2VX3Cky1q +ozA7Sjundgh+WZM/ydF6qjlwk10nPvDT47R9Pli8nO69CbKFn87y3nHaPUm6J8XwMsj3moMLL9u3 +wqXpz4Akuj00vYkbrfGq3vDF2fXPz25/6I5vouLIDNaIRZTtxcVBd3KXD15Pdr/BnMgq3AfQI1eN +XphuQMdJ58rwN7q37s3eRtmhH68sH4k9i1tXfnbmxsdOeNjpnp/e/BAWx3U2QuCa3dukdeWE+064 +hyTHk3VnGqRHvJzSnIvsjbJV0tq0BmQsRf8ailExh168YYRUJJBLKBsIgBwDahn2lCF/EdOR1S4v +4jdpq3c7XLzpze+6k2d4YLowTFSQbAx0b+pnB352OJi96oyeIVh+uqHYQJILwwCYtE1nFWdnqNDO +6Ha+9+np29+Odt9iepuDp0nrAqHfXH27uf52sLqLioNm5+D46rOTp18vj94hVYCEbrxnhSu8RZzv +2950NLoGhCK1vGiDh+0TKlkdfT7ZfZe1T5d7L5v9Y1ZMJa0bpgfd0e1g9WaI7PIWnNRKm4ey0a5T +umq0szYg62Awf3n09OdPP/62t3g9nN2+/PCHcXbMcD0/vQzziyg/74/uNmff571nyNVq3RSEVFWa +frRoj67T7mVr+Gxz/t1k8xFxbPVONvuvDGfO8dBm0NgDy9lL20978w/z/W/C7GQ0fY4CgaHTzFHS +vu5O3q6Pvnv56S+//vFfPH/1i7sPv8j7p2G+N1zdDdev8v75cHl3dvvT7cffFcMrzR6qVtd0Bmnr +CAA1P/hsffJ5a3D16tOfbi4+14Kp5oySYq/ZOxmuX2fDu9bsTdA5D5rHw9VrSctozjadYXtwMz/6 +Zn763fT46+nR1+3h85Prb7vj06hYdmfP084VkCrrXo8WLzcXX+GFfoxcPWTEWDY6JqIcb+L8KO9e +jtcfFwdfGe7Y8kZxtpK0xHQ7QbLsTp5P9z9M9z5sjr88u/4REs6L99xoH3iL4Rfd6+7o2XzzaXX0 +TW/yFkgLrhSVlhusmr2r3vxF2jkPi6O4fdoZP/WyPdWduumBnx/G7fP+7BVmeHP+jRetZSXT9bYk +wAhEmjHLm1eH19+tzz4tDj/tXf0wXr16+/kfYWbAnm60Ozv8cP3uVy+//M2br3578+L7onMQpevR +4s5wZpa/0t1lWJwe3/xy9/Sr6ebd+e1PKHxOTK1gChTNupezzYfjp98fPv3Z5vTT5z/8/aOrL+Lm +vmJ0bfJXLdftyYvV+dej9fvO8HZz9o1kdCU5bHX2XX9M0abtjWabd08/+93TD7/+9P3f/6f/xf+Y +Nk+j7Or0xW+Gyw+atTSc3bA4N72NSLYtJUAqTohAhc3eYXt02Z8DHz7kvWvFHM2WL/7Nf/e/tEY3 +ddrJm4enVz/kbcQLwPhVa/QSwPv+s99o7oRiQx/Kqn+z2P9ydfjt4fXPV8efvvru73//J//CS/f6 +4+cXL3759O2vbt788vD6m+v3v37x5V9c3vz4z//2f5gdAH6H3cHpfP+z3dNv9i++PXvx082H3+xf +fP7i9fcffvgLEOvJ9efPP/v19OCLpHd99PTHu6/+annxU9be789PwuZSMdpuvJ92rzrzV53Zi8XR +p9XpF8XgZP/y7WjvZdw8zDqnVjjLuyetwUWrf3H+7Nfj1QfN6brJrDu+cmMoqzXB4fZF3r3uTV+v +j77ZPf262dtv9Q7DbFP0L0arV4P53WL/3cHZZ5+++7MX738FtPSi5WTz9uD8q4sXP98/+2p58Plo +/TFMj6+ufrh59QeSWljeECmxPvl6vv9xuHpz9fJXz9/8ya///F8dXX4t6n3kfNF/hrTvjF6k3bvW +6NPe+S+DcFdR2oY9sbzJcP40653258+K/nl3fL06/Bhmh2CxoncVJKvB9GZ1+H60eJHka8sZgA0P +L79PmieD2TNcrRfvDufP5wfv2pOnureb9c43px8m6+d+PJvuvc47h6P59dH119PNm/bwYn387i// +6b/GqYJkffH8x2cff3t4+/PZwYf+9JkXHULQrjcfP//2H02Wz2UtSovV5ujt1asfb979dPril7cf +/ywuTvPWjROs6pQJedAcvjx/+duT218NV58NN58GRFRcLndfbA5fCnLMiRmUdtA8Swm5X/fGzwm6 +JvP94/eD6VPY86h52Zm/LUYvxpu33ckNI0YM50N9GVYrSjdF52owfzU7+Lg+/W5x8i18X7N90Z1c +t0eHs71n4/Vdb37bHp5eX3z8N//2f949/SBpRbt/en33p9d3f3Z59+ubd7/uzp/vH7z5m3/+X/0n +/83/BJVy/vyHZ5/92dndH20uf7h68+vrt3+Sd69+9Qf/6J/95/+2PT2pM54fH7YHz2b7Hy9e/vT+ +23+wf/nV09uv/8t/898vj98jB/ZOPs333yHl3nzx57/4zb/68pd/2xu/vbr49Pzlz5EeYbqbdZBU +V6Pl2+PbX7z59h9/8Qf/8uDqx/cffvn85TdONCt6p63hddw8Tlsnw/mzt9/81bsf/hq80OqeI/Es +b4wz+MkG9lPSp6I26Y9fHV1/p1tN2x9k7UOEGNIiaUOCnhydfvFXf/1fXz771vAmhze/Wp/9MN18 +uH77x6uLn5Leq6Tz1HKm3d6tbo8UvdXtn40Wz59/+N9Jeu93OaozXfQfuIOkvXfnXF05p67u6pxz +Drt375xzUtaWhAIoIYkMhiFjbOOAbZwwYAO2xxHnCDY2GIzHMzY4jGfm3Dn3POe5X8nPUz+AQNVV +a33fG6rWeuvMwvbFzswJBtQLk2+1tq7d/TFWTMfTvdbYodbghBjqwLUlcnOJ/DyI0khiTI/3nF4R +JUIAznBTsezC1OLNJy88DGC+unJqdeM0L+ViqV62upCvr/dnTx49e8+1+z8EGLK8eOTuBz/Unz8O +nshPJsEsgF/OlA7Xxs7Wx04Fw93V1WN7Jy/G4lUMJlpriKFBID4TyyxMrV4Pp+Z8aFiLdIBPoQWk +ADB+PZSakYOtdGHm0p1PbBy+xeMPgOjCyGyusZOqrivhPkbmBbF24sTtd9/3dDDUYoUiVFS8vJKu +bvXnbyG5nAcJYETEg6g+RJbVWigGLbYO05RvHw1nlnA82eseDOglt59hpUSqMFtpbTRH1+udxbGp +HU7JWZ20HCgUqxuF2na6uAIsJun1Um3+xOm7lg5d8BPhfH0521iPFeYbE3vpxoYWH4dZPrl3/dbr +DwWiVZONFVVApIEa6UDRNscPw6DNzB750svf7k4clJTi/PKZgzc/OLl5ZW7r8s7ePROrV0SldfOJ +a7dcfBinU2qoAz9aqK1nSsvF5npneq/aPyQGG8eOX1lYOUHx6UxlId/aCKemo+mZcmt76eCdndnz +odjE5MxJks8Om3HAfFEFW1cnuCp4DV7pZopz6UynWp/DqIgEhB4fA07k1Xo0OdUaP6pG2ySXbkyc +lEJNigcVUSeEksmlWb1hRmwksisuXwD0ZCwxGtAbrcH26OyxWGGOADFJZEulpct3PKXopUxpcnzx +dL1/OJicFNSyGKhgTAbn8nAX4fgAwTVBzal6U4OuCXeD0Va2OAvCaXpqd3b+KCifWmd9bH6vN7PX +mz7anznY6q3oeuPBB578xvd+urJzi8MTwMgkzRWhbFKl7WQJxnyCIBNXLn/gmU+/WCiOgYSrdI9A +a1RGT3RnL44tXgERSNKgvU7mqos2Y0+xTPGFfGMrVVzsjB+9/aFPL+1eCMfbxdq826sSXJ7XWiRX +ALrJV1Y3D962vH5eEAvV5kKmMk1wKT+RorlqMDLIlNezpRUE1fVgPRLroWQUhi4QM9wZr3ZpNq+H +2z5UsbtIho/Gs/3u+O7y7uVsYwX8hcXOWR00Smo4FVRDtUR2Pl3ZqPa3JxbPrB27IwSExWeK9QUp +WBS0wtrRe6fXLhaaG/nqcqW9AXjiQcHUK7Lexeg4TkWjmUkog+bgYG/mSHtyW47UMDKgx+rJwmSu +uVrtHy50dsTQKEbGY/FWNNEDLyAq1VC4y7Fpv1/TtHptdKfY2QwmeuXOVqa6TAvpWHoMioGVi5xS +5dQqRkedXsWHBI8fu2bs7hlB/WgU2s3QOSwojZyfSGJUPJpolxuLQAGFysLc5tXG2M2h+GJ/4kyl +f1gKt8r15TNXn6Cl3D92dqBEhhWbodRyeeyWSHre5hIJOpYvz4OHypQXW5PHRmfPLm9cW1y9VKht +JvMLspw7fOy2Zm/V6ZX8dBIlExQP2DutxacBEILxAc3FtnfO5vMTGPhEqZbMzYbiU8BcwdhkrrYZ +jXYnZ0+kS7NQugC5FJsCkFSUSrk6X28v0XzKj0UwIgrlHdC7wfikqHVShYVYaiKRHA== + + + j0U7HJfu9ncLrU0p3OOU+o3HSmEfmuCl5tTiLYredCNB4Ecp2G6MHqn3D9VHD7b6hwWlkc1NnDp3 +L01HOLmWqW9CU1RHj8wfun1q5UwahCKZPH/p/snZHadhSKPByAwjZFFKd/ok8FaSUuOEAihSRswL +wW6yuJRvbkHDGgs10TDHZ8ORms1Bur2isZ9arIvaKEHXGB4kTd3mYFBM1vSinmyGEp1kaR5skRRq +J3MzoWhPVnLV8vT8xtlYYZKRCoxYFNRaIDQqB/t6ci5d3aCELNBxrjhX6WyWOxvl3g4TqPnIyI1y +HffhSirV3j1xz+aJ+0udQ5LWRDAYjTB4c2PXj0sxmVCng2HYFFBzKNFTYx09PfDTUUCV3uRxmE2a +z8YzU/X+MUDFYn1RDZUpLur0iFYb43SJFhtqtVOhcKfR2y21dmtjp0PZWfDCXlSRA5VCZS0YGceo +Aoh2SsigVKTWXqmPbrpRFS5ADw9wMu7HQrRUJqQ6YKDxvCJQU7SG26cWaxtTyxeTucV8abbd346k +pmDiQoHy0aO3xZN1m5sLZ2ayte3WxJnB7K3B6CTJV1AqKSvF40evptOjiF/PFucm50/XO9vJ3EIy +t0xxxXi8Pzp2GMUikWhvceNad/JMNDGtBtqBYIfmS3CnmeIML6VhpkgqFkkOQrF+u39ocukcK5Qd +diYgpe77wFPBYN3jC5JsVpArglyLpeY643tTC+dAsWczvanl06xc8iCSDxExPOT1Bt1uzY9EUb/x +bHNu4XSyMO/ygaeWPf6g2xd0esI0V+OVttnK7tvvBq+tBEZHTIixts0jgvLklSrD50Uuu7ZyLlYc +d2MyQup+IgpVrQR7itYmqYjVghN4LBAeFYKdaBoaZ8qPZ4CCXW6ZJKO8mKIZPZkeVSNtMdTS09OV +7rYe7cRj7a3Nc1OLxyg+glPhZHa8N35kbPpk1rAbY0Kg4SdjMJ7Z/AwQOisAX2xOL1/qTZ5Y3719 +efsqr2RK+e7u0cvZyjTQjct4dWg8WIvEpxJp8OwZpztAMxkfGnA6aZZPFlvrE8vnO+OHwV5tHr5v +MHMmmeyvLN/cHT/KyUWKz8CAwHm8qK4qPYbOO40XmhzFRGWtBIo6kJhEqBzO5sGwQwuwUhHBQzSX +qTZ342kDh1nBUBF2B4v4NVEsWs3IyIjLQInIaK68Umqsx0F+k3GUiFabm93x49AIOB0DGZApr8Wz +s0Z8Chv3IDDm8Uiqz0p5ks3cEP8FPT5ZbmyMju+xfNHjVTAsrIdb0MvQ76xQAK0CZjkQHjBMwecN +knRCUKo4k8OZgqqPNkYPTy3eOj5/S766BlxgtZNuD+fyMD6/SjJpLdZP5WdhHBS5ENDKZgsFfwjt +A6jOSyWCTJFUmmFyPrc01lk8dfZeH6YMDTmcdoJAgyrIJL2NICGblRa41Mv/8oPZmS2Lxe9HZD0G +Z5gNx+bSudV0ftkIi7AQkUgXdJTZgsPAekFoQd/xKV7Ja8Hy8sqJbHPCjfEEFw7Gm2q0zgdgRtJw +gz6PHIuOauE2cBlKhmHM3T4FxcMElRTkMmsMWmxz+3yhPqdG6pSUw9gYTulyIJcFu6eV/H5JlXPl ++kKxMqMEyz4sYHEwAL9g7hK5pUhiAJ0iafVsdX1s9gQIlVxlWg1XfLjU7c3u7l0SA5lhM0YyZT7Q +U0N9SanA+Di9GkjWdGGZV9NuNynJqXJ7tTt1dHb1bH92r97bCEWbsVj95MlLh09eM9tpjEzxclNU +2uHYOMcWfD7NC5OIh3BCh1mA2uaDLVbpCNpoprxdqB/C6JTdxahaLpYc5cQk3C/oUobNMkyWoTI+ +T8Ay4nVYEdSv0GxSDTbBqYG6cHsDglRRg21RrTjcfKowmSwvhFLjlJAC0+RDAgGtUm1ugD20WAmr +laTZHDRvPDVZqq5FYoMbW2BInIhmC3NmC8bwyVC0XW5vCMEWwWZcHsnp4oEH/YTuRUNqpN8c7I1O +n2qPHUkXFkmm6PLqMDJwPS437fUJFJMIJweTq7e2Bnvh+BQj5OHkCB6kxTQjpjgxpwZaidRUKj0r +goKiojyfMllQ04jPZSd8bpbEw04HZywmtNGymD9x9FI6WjOPIBQRVfUOwxc4rkhRSQyPWq2Mz6tl +0tM0nWX4rN1JenzQs+FwwrD8ranlXGs82xxrDGbnt46sHN3rL28riRKjpMPxbiBQD4e7FJ2wOSmv +jydJTZLTwXBVj9flUF4JF9Kl7rlL981unkhXR0kxRsupSKpW68+Hy323X4D/P58bDUerNjvKsIA8 +oHzEbHGh3D2sJadQJiYq8XRlVEvWtGSZVhNeKkBJkWA625qby/amcCmCs2Hj8TibcHmFEZPT6Wag +sBPZqcboLq/GCVLgpHAgVqYEXdSSarTIqqlwstafWpxe3wlmqgilqXorGOnf2KcgDg+7R4Y9bhef +zk7GUyByoH0C0MjJ0kIgNgCXhLEpHxHGGD2aqQpawoVyHlxi5HSptUZQaZuNMQ17/B6BJcMMFUNR +ze0RHW7Bh2qSWtESA5zLAnFgRHD7yLnF7ZOhVNXiQh0+QdE7odgYTiVGRnwmE2K1kX40iOERm91I +QnA4JU4ASu3G0tOhSF+UCztHzy9tHsvWxgguYnWRoBCUaI0N5N2oSPPhbHWWlQq0kIeSBo7GqXyz +e2IwfU7TWzYHAaXFcIloalQM5HilKCplWS0poVKxNV/sLOiJWiLTS2ZnMoXFaHzcaib33WQ9cMBN +0Uk91HQ76aED9pFhr9MuSmK5XFnO5hZoJm+xUGYTimIBTs4eGPEMmTwjZj/NldP5zURygaFyToeo +ahVJThYKrYXFrY3NY6fPX7n3oUceffrpTz3/uW9+99tvvfXOX//jP9/9t/df/dHPr939aGtsA67N +cmMNGIlHc6B1c+16ZdDqzg3G51bWd07efP6+hx65/YGHL9x73/GLl89dvePaBx65866HvvziV774 +yiurW0c2tk6WahOgBDAipARLAb3KCLFAIFWp9qZmFlfWNo+fPnnpzusfeOyRJz/5zIX7Hjhz9Z47 +Hnzi45/7zMvf+NrXv/fDr3zrux965nNLW8elQBrFVbeHITAlolcSybqshhPpYn98bnH98PTyVnt8 +amJhZWZtd/vY6See+sjPX/vFb3/3zkvf/OaFa3ePTawlUy23W3A7JK9bJbBwMjFaqSyQZNhupwQ+ +3husNPsL+dpEqjSab0xsHb310h0fuPehx7740kv3PPz4tfsfuePhJ7RoFaQUwJ3LwQpsRhRKslIX +pQJB6pF4NZVrlKrtZndmZuHgsdNXHv3g00889dS3vvf9X7351le+9e3zt90xM3+oUp3ixazXp3m8 +MkAQwyZAzcIJnU4BwyLx5KDWWU3me8l8+8TZix/61Kce//jHbv/A/fc98uT1ux+4cue99z/2wa98 +53sfe/bZO++57/j5q5yU9XgEt4ul6bCq1aKxMVkqJ1O9YLCYSLSarbnNg6cmp6eOn7z55lsvX7p2 ++/Nf+vIf/vTnf3vvz3967/033377qY9+slQaGzFhJhMFTReJTORyy3abYLMSiFcQhQxFZ3xICEFU +io4wbCyTae3unjx/+fYT565cv/fBxz/89JHjt/SnjzV6W6KUM9ay/pObp/VeY2JtafvUsVNXLtz6 +oScfefmlF3/1xq/f+f3vXv/1L998883/+vvff/eHf/3Kv3z96U98cuPQzeXWuhcJI95gFFy5nExF +Ml2wEDt7Z26+5dKV2x5//PFXvvb1r37rO5/90osfffZTX//2t1/7zW9ffPmr3/vOq3//+99f+vqr +H/rE54+fvZrMjBZK093BWqE2oem5XLYyPztzy7m9B++/8+Mf/9Bnv/Dpb33vW2+9++73Xvv5V159 +9fs/+8X77//5//zf//vn/4Ar+cP3fvrT+x9/qjO+Fo61ADBJQorp6Xqls7KyCsf2zu6Va9c+/LGn +n3vx88984TNPf/Yzz7304k9e+9mvf/OrP/777//nf//PW79796Of+NT5C7fnC2MSV2SIbCTcz5eW +/aiO+iRdTQNw7+4cun77HQ899vhDT334wSefeulr3/zxL1776euv/flvf/7Lf/znb377u9/9/vcv +feUbO4cuZPPTPF8Kal2OL4QTo3q00W7NLC5uHjm6d98H7n3sqQ9+/NnPPv/yyz95/Ze/+u1br735 +5m/eefv9v7z3v/7f/4Fu/fHPf/3FF76eK03anSxwosvFO4wVkipJJdRAKZ/rbmweuvfBB+599MFn +vvDsT9/45etv/uYbP/juy9/82lvvvv3279/5xRuv/en9P/1//+d//+7ddz77/HPnbr0tnW0zDOht +zOEgEEQSuHilNDk5vnr08Ok777r/occe+/JXX/rZr3753Z/88Ovf/fbv//THv/3Xf7397ttvvf3G +3//777/4za8+8PCj3f5KobKoBlsul7H42WLGOSoisNGIXq5Wp0CT9EanDx47ee8/P/j55z7/2hu/ +eucPf/jad771yzd/87/+53/e/9vfPv/iCw8//ui12+/R9SbHVVgiMGhPri9u3nz0xNWLZ++58+KT +j97zza+98O//9juo6Lfe/vUvf/mjF770qdtuO7+yspItNMPxDoqGfV6ZIYMCHdCVUD1fPrS1c9cd +dz3w4AceevjBTz3z0R//5Ec//PGPXvnay6+++u33//KXn/3q9edf/OILX37h4tW7FlaOtbqLipKN +R2qF0mg210ilyrOTSxsrawc3lu++fO5fXnnh619/6Tvf/fpbb//mT3/922u/efO1X//q3Xd/+x// ++dd3//3db37/G/c9fPfC6lY02ZCUrCgnFTFcLTZmp5dO7p05fuz4sUMH77p+5aWXvvjGGz9/853f +/ui117753W/86s2f/+sf3n77nTd+9w40y+tfeunFK1fvqLVmCFwnMD2o1eLJCYqMc7Qe1TKNYn1n +ffmJf77/a698+dXvf/e5L3/xZ6/99L0/v/+3//z7G2/9/L0//f71N372/POfeu75zx7eO6eFKyCH +AKyUQDkca0ZjtcHY7Mzk7PGjxz701GOf+ewnv/D851748nM/+8VP/uO//+tf3/vTa79+7fs/+Nr7 +7/3hd39496WvvvLE40+2OkuIPwjGzWGj3U4B8QUEPlOrzJQK3YPbu0988PFPf+HTn/vS8z99/efv +/fX99/7215+8/tM3337jvff//d/++PvXfvnj3/72tV+89oOnPvTY5duupjNNQYy5PQSUVkDL66FC +PFJZnl9/4P4HvvLVr/70tZ9974ffefdf337vL++9/e47v/7tm3/925/hPD/80Td/8rNXf/H6j556 +6smT525bOXiroBRNJtzjkj0uDkN4lx2jMHm0O33z6TMfeOD+L375hRdehtn8wk9++v3//O///P0f +//BTaLtf/AQm6rPPffLChVvWV3fDkVa5shaSEq1Kt15ulDK58YnRxeX56an+1vr0HQ== + + + 108+9NDl69dO3nruaLmUCgZEmmQQhEYRwWEjHDbc5cBJvxhTEuVEuVvtjHU7O5tr21srC7Ojp0+u +3XfP6YcfuHjblVuuXr966vzZwdR0OJKW5Fw4Btq75HWziIclUJ7CWBAuxw+d2dw8mEum2vn0obWZ +i+eO3H/vpSeeuOM73/jSLwFu3nz97d/98tnPP332lhPj0xMhPaEF8xRYV7+EorLEh48ePH3mzJVG +a7xSaU71uhtzE2dPbD778X/+7quvvPnWG+/+61vf/f4rX335s1/+4sc++ZF7H7v/wpHtzXZ7IhSp +uN0cQYS8iGKxga/B7HbS46JUVi0lYgeX5x++/eIrzz/78le/+NKLT//8J//y5z//4Quf//DV84eO +bs71mq1SqYbjnNOB0VQIDhRT4aBIlSWFWCjZLLfXZhaunDr81GP3fPoTj/7Ly8++8caP/+2P7/zl +r398/edf++RHH7x86VijVsRQFvUHSCLqsIOkMZYoW0x+AlFiWiGhZabGJpbmZ/f2jl689ez1K7fe +e/ulFz//0e98++UvPf/p55798Gc+/uiXn3vm0btvO7W7nUtXKTrg8bE+n4BjGsNGM5nRoJYl/FxC +T+2sbt11+53PPvOxjzz5yF1Xb/vok4/96Aevvvqdlx+559zHHrz+0UfvueXMse3VxX5rNJvtdvo7 +erhtNmNWC4WhEa9HcNlx1Mvk4qXdlbW7brvwpRc/+9LLX/zoRx596vH7nnv26R/94IefeeaZu69c +3lhaqZZrHK1iqOL2yE477bQhPg+F+hgS4zUtl0q1Ou3pmdlVmpcQP2hL1uNl3W7Gj0gEEXQ6qaED +VrvFj3plAgv4vQKFKrRxCCwtxcI5PZjyezHE6/f7cJYWGUbhlawbUa123OVkMGOfgmZ34SMmcLUo +7hcRD4MhgqyCSQlznBoQVcqPihSdjUVL+czE2OihI8cWV5YTiQTMo92BWe0omA6Qyi6XYHcwDict +islQqMiyYRyXeVaLahGwo1EtmE3E0olksVQdTMyEQ+FUJDraaNRz2RAnY14WXDOGBRkmrse6FJva +f8ABaicgl2Quo0vxZq5cTqTTQS2pBTcWFvuNfCUTHWs3kvEix6ocq1NUyo9odiths/itZq/F5Dab +fP9IsmLopCLkK7lBJloqJ/J3XLm4d3Crlo4P6tVGvjjTbc12qoVk0e8lhocspmG3zYINH3AMD7ms +FgywC/EqNB5WpWwEbFYsm0rkRS7g9/glVk3qxZCcKKTKY63JifaEygvpcDIkRilUdDroEQsxYiFd +HlWSSopSZJgw4uP8XujcSDRSg6YW+UyjuT63fH588pgixVC3JywpmXBSE4K4HwAThyoS5VKzdywQ +7Fmt1E3/jwmEKI5F3C6OQlWOUKJqNBNJJcOxbLwA8p3zEwLOBYSUJud1rRTWmy4XdIocjrZFpbr/ +JjuUisnkddgJxMORZJzns6XC+O6xq25EdrlBW6ZYLs8LRfCVBBH1eBUYARQxnpUNDdnhGDF5LWYM +9ck0GdMCNVEs8EySomNGkJSDtDkwHxr0IREYc5ZKYf6gxYq43JTbK4CwIVDZ62GcTpqgE4yUkwJF +Rcl5vaTPS1KEhKECRWminEEwFbw/TsShlfYbm/s8oHV9vgCGhXBCo2jd6WIcDtrrFW02zOUinU6C +wDTwyJKYp+kEy2VQNBCQ44KoD4/YRobcPrdCU3GgdYrJa+EJgsyYzThoYJ+Xt5gRy4jHZfU5LB6H +xe330EElJ7AhEhNJLOhyyeC+rTb6H1vLHXYBQ8Net2gzY05jp5Jgc4huX8jhkoHjSFIv5Hu72ycy +iaLd7BBwRSQjAqlTcDuAUUMus8mP+yNmE7LvJpNpxIujIbudgQNa3uNT4XpYqPxI1+8PwFUFtEom +N6tp9XCgSPlVn5v1uejx7hpL6QB3cCqUzBFclRVqslLFiKjLK3ugo2+E3yqBdiA8nsytZUsrrbE9 +LTJmtQLHCcVMz++T9++zWoxEC1lTm4PxE83OYYJMDx3wWEa8hfQYhoYODHlgNh0OFkWCilxNZ2bi +sXGnjTYNuXAfkKZgt1Fet+zzBlEsDq4Zfk4LjQ4PIyMmt8nsMlvcFrPHB76VTLDGg+txkkwkY6CF +Jjghy7BZv19HsShpLGsPIGjE7Qvs328dGnLAj9qsNIGGOTrNcVkov1J+rlJfHx7xjYy4YdIpNi0H +uqLSgNMiPkVgws3GLMOnTSaf2ey1WhGfT06k54OxcSlQZ5hEMlkNhfMeLwd/124HwAx6kaggNbOF +HT9MhNnvdYORbsGp7A7KasOg6nz+oCAVRaFiNYLRSIAyFNUAIf3+IIyYyyUSeFwLNkg2bjJ7PR5V +UZpqoE5SKQ8SJuiC3SmbLQSUn8NB7jd2LjhsZp/V7HPYMAILQbv5kQCApNMp7bsR9+F2K15v2O02 +MgdIMuVDdLsNpILmRYJGkp6ZMtt4GCs90klk+n5Mgzu1mHwUqkMFDu13DBl71XEw715PIBIc+Dy6 +2YzCYbXiw0Nuq42CETYWGODxoD4IRafdHpVhIppeJ5gk1LbDQo0Y69sRHAnWisssHTWPeGkyQnMl +lyfocKlOIy0qq4bGpEDb6wvieAhMSrV9KJaew/AUTqYdTtlkQlQx2x89giKhA/udOBmnqLTAZjWl +5EeCoN4P7LO7bPjs5CGCiJktFEEmECxKUBlF7aZzK4JQs5opm4X0Iyq0hmnE4/MIFJngxDonNhVt +lONLRgQloohSjJHiJgtis7NGCqhQloKNcGys0dtJ5SdpLsFJBYbLq6G2EuqRbMGNRBw39rdCs7s9 +N/b4D/kJLIZhMcQfEoWCHKgPjyBGGSASRsUUvUvwebtbhH9NxiqLy8cEtWKGMfTKKAalHgJPBFPj +cnHAjwe396YXdqC0EIA1IknTeYrK8UJVlNtQ7RwTCwXLXi83POyGufD7VZJO8HI9nJhWtQGOxdOp +8aBeh3sxKNjNo2gIgIXni9CJPp9GY6FqaZZiUjCDZhNqMdMeb9jl0V1uTY/2QXQdGHKBQyGB+u2k +y0khPtkCk25ERAYpKgMg4HLDVSVQf8zjDY6YEZuDRfB0INRL56ZYIedwika+mVd3e4Mg7yk6Ad1h +MpMcW6TJ1P6brEP7QX9oqjrK81WvJ2RkL5tIcBMcm4Dr8Xlkh5N33liI4vEGjEgTFEYmMjl9tNZe +8OMhuHKGzlFEkiJSJJHyeDT4W8CqPg/vdAJsGouxvf54IrMyv3Z3ubnr8mowCJyQQTEjMA3xJYwN +Vlo9FKzIYlkUygQedTqMNag2o7AdI8Ne84h/eMhgIo9b0LSKHw1DrXJ81gbywwEUIxhbz/bD/4n6 +fEHEF7zpn0xwAbhfwTHdbOFMFmHEzO0f8h8YxkBGbm+cnV49PWIjrE6e4mtyeCpWWM1U14OJcU4s +jLVXTpy/x09HbW7O5hI8SMyPpTi+GdBnbS4VMMHnUW8YCoWm0wydxnEYkJgfjwOS4JRGCzGCS6N0 +ghaLolbB6QTF5xW9H0svCXINoJvlkwhubARTQOqoRYwM+TANmJcgDIwaGnYNDXvsDhbKj2HSklCg +KGBbHDgFIBp4HLDd5Q36sDTJ1DixJkoVSanBbUYiNbeHs1pROBVgCE4kSSqtB2tbG2c5PjViQiwW +1I+ESTLLMEWGLeFUCoYObO+xo5dSmZ5RuhbU5xZBU/FCGdrQ45YBVCW1QlCRYZPXZPbb7KTbK+FU +Ugk2ESzEcOmZ5VNyqL7vgGvfPqfLKaFYBMfjAa0Ri4+5nKJlBCFRjWaTB4Z8Nw4EDp8vqmntaKTL +C1lRKrq9ssmC252syyPhRAp+ulTfnFg6x/BQY1K7u1auryNIyGKlTSbCaqG9HokiQsCYI8Megowl +0rOx9KwfTxjbrzwBTq3nG7vdqT1RKQNYkXQRxpxmM04n43axdit1Y6OfBvw+AqrPRhkbTFwi6g8h +XtXl4C1G7gTj8QUXl86pcm7fPpvJhAGKqnKbwDI4lnK7gS59TgcHJxw6YLPbcNAq0BRur8YpdZAo +qdRoIFI1gz/ya34qgXPZYHKSEosYnVC12vraLScvP+SnIigRlrVGODIRjUwkkzOyPjpsIRkyNtk/ +JMnlAwcARiioZBxLBkO9wfTZcmMjHq8fPXGFkYuUkI3nJjPVlVx9rdjaLnQOi8EuTseT0cbjj31s +MH8YWtLnk7w+xefXGa4Ujc8KUsNppMFrABo+IzwnjRFZP54lqaIWHNXCPZdHNJk8qLEiyNid4fXr +GJ6Ag2FyolTKFxdEMRfWq6FIF0F1Xiwreo9X634q5fJpLk8ArhZU041NuAGGK+iRUYZKgVDUQgUE +VfyIQpERqCuHnUP8OkHGQT5hZIxkM6yYBwqGLrbZSFDvVgtOU0mGTQf0dn1iD2UzJquRkgEg6Uc1 +0GZQfi6PAoxDg9pEobWxffvdQ8MIlIfHrZFkURDqoE8EqcaLFYrNomSc5nMgbj1G8FSE5fOCWnU5 +eYGJXr50vyRnADRMJr/XqwId01SCIMKgtZxOjmPTLJskyQhcTCIzka4siuF2KDXBikWcjAVDTQyL +mEZQq4XxeXUcT/NcQxQ6brdusXI4Go5Ge6B8QEvDfY0M+4aHfHB5BJEPhvupzCxYDCvYFmM3GY94 +g8amMJvo8emCXI0kBqBpJSEV0BI2u8/mwB1OzgiQ8RsvXoG2nF6JlYs4l/JgoVByQg6PRpNT7dFj +7fFTieIcx6VSqX44OUpS0ImaH1MBt0esBJyzXlsVZCMnx4+EKGP04pJULFaXo6mxXG5878xdjJJn +1Vyps94YHGlOHMk319OVVYovUGy831l86UvfPH7LnW6fiKGaIBRFqZ5ILeWKWyxfVdW60aRoxNgI +jGU4qaOGpxO57Xrv5nBq1gt+E1VDoTqChu0u0QYOlIgKchk0G8XmAuFetTp/5baHJxdudrrB+xT1 +5KQWn+K1XiA8GY7NgTJxexWKy91I0QkbexzcQafNiA7wepRUoi9JBahtq5WhiKgWqDB8npdrcrBV +bqxnSkt+POxyAyriNisJuk4OVOP5uWxzl5KqnFKTtS7oN7udMN4V6i34i5H4ZCI5DaUyZMS5++FX +AAHsdrAqBY4vs3yJ5oxAG0asCIE2K9egkW03wvAxIgl3pAQqYb0+PraGYQrUM4CVKIBUSEOBmczo +8LBH4HM8l4JftFlRhgon071oepQSclqkzwhlhs0HQ22aSRtJVkZqbhLxR26kAWh2I0QuoUiVTHoS +eMHrkREk4AAeH0EpMo0TaYrJAuwDpgGtuD3STTeZh42kHRBXaZ4vSEoZ7h0INxppgy8fHrbZbMAU +EkyKEzAfi4FXCsenqt2jwehoODUQgg053FGivWh2Wgp2QF0Makv33fnU2PxR0OdgXhAwKb6AKFcC +obaqtW0O2u2gcTzmdElmM+nxCiDUI8lBuriYLMyRTFjVcrXRdWOxsZw39hrE+tnSYg== + + + q7szMbO3ffQOVoz7UCEUahq5qWIFrgqBsiEieqwfy884vYrJjEdiM82xU63JvWhujuKKPjzhRgCL +irninKTVSC5D8xlOBPlaV8NN4PFArBnLdhu9pVhugONqs706sXRrtX+ClZu80oLD7pL73fXb7vhg +tjCw2CjQnyhWxrBSMrmYKx6Mp+YMFcdn1WANZIwFhKiD1hMTU3Nn9s49XG5to0R0ZWVvavoI9Dgv +pHO1xVJvtzx6ZHzhwtLOA4XaYVChFB0W1QLOxEDFAW/idN5uBF9IdgdjbA83Y14vUH/I7TG2cPrJ +NBdoxysbocySn8z4cU3VKrxcAhyjuawgFxW9ma0sapE2aBjAFrBmNhvjNlY4MD6f4vUFzBbcZgN3 +rNqtfjd4ajICLB+KDSKpGYovk2xRCfYr7SOZwrrdIQ4P+/xonOHKOJkRxDJqSOU4xUCpVAAJKSpu +sxpvM43EHi+YuwzLFkJ6BwzsTTeZrGbUYvKbRxCAMnAWLAdOPMOwBZKIO+3A0aLdwHMUZB7FZnip +nC7OpwoLE+NHr93x4XC8wwjZfH0zloGJa3dGj4wOjmera3avbDZjFJ2kgDfRsCiUKCZjlJMFSjqb +LU7jVAzuVxCygXBbTwySpUUtOqaq5fGxrSv3fMTtk2GIUoWlotH4C8XmRqGxEUlNIagmy0BJbZsd +rD2FEzEosHh6fn7rtvbUCR8Wdthpgoq6Ec3m5M02EkBGUFvp0ub82tVIfDQc66VLMxgdNttQlNBD +sc7M2s2X73ny9OWHezPHOSWfiVe3D15QI02TjUapRDI/nSrO8WonXVjsT26pwYLLHciWt/XYNEnn +JbkpKHW3TwXCLVUW6u11uCow4CDRZa2uBBucXLS7JY9PHZ06lKvOejBZj7V600fGV061JrbLnc1Y +doZTiiwb+8SnXjp36R6U1EAc6rHZUvdEvnVYDoxabRzMUa+9vLF9ed9+MK1BUeulG1vNuTOd+fOR +wrIbiwZDlaefeWFr55zFSoGrDUUH1d6x7RMPtMdOGcFxw06Ri9F0csSMWWw0VCzD13i5De4MbILb +SZNEiKLjXkSDLi62dxsTe3M7dy4dvq8zcZLlCgcOIL3R3VC4ZzeiVjH4CRgBoInO5JlEZt5tpH+I +oFd5DryPCs4C9JjdrYOgRTAjhRvU+xDoHxOG+3XEFyCJBMhsPxIFrvR5Qc+HADwJIgBT6YDi9MoY +FQaPE01NlJrLGB3hpGKpvZutbUUzC63Ro+HElBGHa6NxVJXkrM8PIy87jQBPyWrlPZ5IACynWATA +FLmsHqkhmOz1SzeWgWUKtdX+3M2D5fMcm+z11svNZT+lg/qKZadDiXFGrBaqa43Rw+HEGKgUji+m +srOR+Fg0MQgl+qxc96ExjoPOTQyN+A6MIF6fls7OJnOLicJKODlFUHEAq1xlTtTKXr8mKlUgoFpr +6fDe1dO33j+3djMtptvNuat3PJbKGcne+crG4VP/fP3Bz05s3CmFJ1AqDlPDUJlsfsFm5LzhfiMn +UHe6ZYyIa+G+kQ9gJHJzfn/E5RZ9aBilUnKoFU5MZipLgXCj2Zk/fOJKINQg6KgfVwgug/M5TikU +aguHTt+bLowbj0fQUKO/BzSqhNp2p2x38giiZlNj3d420CKKRmihwIh5Wiip4XE1NpYqz/Znj5+/ +44O96aPDJtKPx4LRgax1SCYDHmpkhAZIUaSiKGb37XfYXYIcGkRTq0pooIbGQA6B16ZoAyr9WGj9 +8OWz1x9dPXLbYOGcnpwGqB8xg/dhLt/+sVxpHqSm3x/T9B7ij9NMIZ2fB28LfeT18Pn8QBLSYBv3 +gQc0U5RQj+TW4vm1ZG4FxzI+b0hVm36fPnzAaRrBb4SgkuAlQRQ5ncYOoN5gHdQsXJtxs1gQaiMQ +m5J0Y2EwlJakNwhjiVpGDPQ4BXCsQmARjo5SZBhKCAcIRdMUWYbDj2b9WBpg1uHgqqWFdGFgpOpZ +UPDCvFQrNbcag6O5+ryu5c+fu392ac+DKonc9Nz6lcmlS5X24cHMmbH5s7LeNlvJQLAFVtcPhOuX +YUgJuiQpPagHXikNAwgb376JBPUWxWUxOkXzRYzKCIqxO5IWcoyQ16OjDJcShWSju9qeONycOFRo +zM8tnx6fPa4G63q0U+/uNHpbnYltLTHmRuNG7LNLjOqdXH7eZCFHTDgnlFV9TNG6oJd4sQ6A7HZJ +JBn3GRGUOMMXo6np3szpavdIIjutqoWd3dP//MFPAm/CGKKYLgV65ebOwRP3nL32VGfmJJSu08PH +0t1gvO9BtBsfGyIsds6PRsCYIP6w2y1wQg4xcokJl0fjpGYiN7994vqdD3/6zO1Px0vLVqfECnkY +Cg8ShJkCFsOxtCjWeaEOBmdo2AvQFIpNU0YyvAwmCOYOyFoB0U5EAAHGJnd6g41kdjycnGakNsmX +aaECVNKdOo+SaZtd1CLjklY30hVsnNujGfn2wyji1wqlBcQnH9hn2n+T2QUjYGyCnuDkBoJFh0YY +p0cHV2U2GU/AHHbR6VScLgU8FIpGjRhtPJqpLNJ4JJsZw4mw1U7BLcTzq1p8Tg71E6VV6CNgW8l4 +TtUkmBzcHWh+gEqng3c6BI9LBtsCw+52iqBLodRvxBLyoVDLacRVeWEirA4OroQRCpLxyYxqNNZo +tNeCoQbHpcdn9yaXz9RGNwPROs3FMCriQ3WvN6CqVQILuZwsKEM5MJ4pHKy29sbnLvmN8GeGoZPB +cBukkcPFgT33gWUI9DS9D+qXE/Od0fVma4UiQ7hfzhenFjYvHjpz/9Ez916592O13q4oVm49ecc9 +939QUHIIFkKIBAOWIbvUGdubnr8VxTL7h3zDgCFESouMqdDIaAy622ahQWyDF3Mb3zySlGA7oHcU +UHd0CifiopDLl2YGq2cooeh2B0rl9Wb7RCY3PzW3N7NyhpWKTpcQ1Ip3PfTRQHR0ZITyeHVOBE3e +p9iSy6OC1Af60KM9cHB2J8MLxVhqOpmf600ePnHLvUvbF1ilGgq1T566Dr7P7VUDoU4iPZ3JLaSy +S5zQMr6HZadoKgpCC3hteAT0czBdXKr1d1PFBVBoKKbFEx2ni7M7WSgtaIK1Y/cOli/Vx0+QXGH/ +AT/ujx6/+QFKSAMjQMG7vBEvkpQDY7nSdr68O2w843K4nCRJRYdHkBsfdxM94NaZkhaZ4qUm/KLd +ivn9Mthku41F0CjJgJ9tzKye3bv8qBvuiE0hSBBBjNVrqt5WI/1Qal7PLOFslsCjxcIsw4H1VnjA +eT4vSmVBAKRKe9wyeP+hIfvwsHtoyG020s7JG5FloscVILAYjgZdTloQ8kqoEc9OxPPT5c52KD4G +XjgaH9VjVYIJUKxGMbogZHgxF9Cakci4F2Sti2fIMIoFHU4aBCrHZkjKiPjz+XSWzoGzBk8Eze7x +ygCeQFgWKwvUzPGlVGY6EKpjWIDEA8FwIRDJx0v95uT22NyJUnWxUJhdXTtbqE6RTCwS7+eqG4LW +jqZnMuV1VZ/y+ZIIEpXlMi9kQVw5wBva2BviIUiTafAXNF3E0DCo62GTc/+QzeuVQ3ovGp8tVnfm +t6+BBguoxfWtW/XkAODL6eK9NzZ30HQ2Eh0tN1dHLLTZRPJsGVDR5mCHRrxwOFw8JxSC4R4Kpe4T +oPUoKuZyCSDk3H7Va6wCzbW7h6bmToDnEqVcs7tDMxmPW7JbGeuNcG+7jaLpqNNJY0TI4wtSdC4U +6UtwMeEOK5U5pdLu7/BinuUSre5qfXQT/gSls25/0IMEJKUWjoPjXjWChsAAaq1wfFaPzibzi5La +stkDUHt2G9NpLkxNbhoxcWbM7Q3waj1ZXql0DinB7tCwXw/Wcrmu2eQ9sN8BaADCIBLrSUoBGsFh +YzweDQ5eyHNSgWaT4MvS5bVkYbU1OJ0urWnRrheVtWC12dlVtLofizpdQTCtTuNjeZTVSlgsuNmC +/eO7DP9IwyOwFOqLkP5ILFiZnTtCsDFWTLcmDx09/8ixi4935s6osXGKTYbU7OLM9tzcKVmtur2i +0y0gxtvGMIYGI3oNQ1WXiwwoWUXKgmHB8KTPn7I7AjcKGHcY7+zIkRHARgxQFNyNIDZ4vgY+wocG +OD5Z7y5Mzm0tbp5ePXxpbffCzvFrkwunMvU1jI5VylObG2c5IeHxCYJckNUWzdZkdRRFkx5PALgY +zLXPoyI+HUUTKBL1gMTyyjDIHJMR5BLDxRQ158cCOBkl6DROp3m1qun1emPxxKk7pUBZlPLgLBgu +JwcqsfhkINChmRyI4WikUSnN2Y0cbI/Nznt9uijVOKHE8QUCj4RCVUBd+K+go8CSJ7ML7cGx3vTx +9d3r8M/Q+53O8srGuX+Ey/mRAGYsxaERr8SycRwNlKrTgpQFEIPCg3YTA/V4cbE5c2Zl+/Z4or+6 +fOyr3/pxJNa32mSarYOnKFRWzl1+7PTFJ6Tg6IEhFLpGEIrwK9BWJiNjkLHbNUUdDYYHilpFfAoI +J5eTc7l4u5OzuXiTTTAbH/JQtVBbkHMOFw0m2m4nrVbMaqw941BjOQfwfpygc4IKzqgKhitXWYjm +xuP5mUJrK5yZFfUOKOR2Z3tt6/aA3rQZEdxG+AlLZzEs5vUEgBCBJY1kcuPjaLRx727N61JwRIvo +pU5/KRRt1JoLc1vncvXZXH0hVphn1TZGpcLBysbK6cXly+iNj2i43BxJJnmhQrMZSSqRVEISs/n8 +OEGEwGt7AT2YKsvVKSZvvxH+bMyCjYIeB1q58TZc9PpCNJcU1ALMb72x8JGPffG5V743MX8U/gRg +M5aZ6gwOVxqrY72duZnDmpbTAkU1UJWVqqq1CTJvt8nDQ8YnlkwjCJSW08FZjHdY3uEhl8WM2iw4 +jurBYKs3ujO3dNLmZEDVIMaH+XRRq6YLS9nSqhps4oTe662Vq/MeI6Wfx3FQpMYrMDDmuUy/VJgw +DfvMIyiORcHf+RHNYqGcTugplWXToXATCsN4PEimJKUUSw9UvcmLRU6oAHT3uquD8R2bjYXLoKkY +MKnbyft9MkWE/YgSi7dY8MgjHhQBzRPmpaKitzQAELmEY4Fcun7mzDWAR5av54u7hfJOKNRNpQax +xChBZ0GEy3yumJuAthoadt/4ZkFKEMfmFu+cXb0uqU2TiQDLAMzucbH79tv2Gx/R4B3OEEHkwHBh +dBTBNbdHOHDA8Q9wY/hsojAHpg+8djy/FEnN0VwhlZ3UEy0vqajRRrm71Rk/tnHojtMXHr/1+kd2 +jt/LChmOT4PMQBBwnUGLlRge9phNiNsFiMpQdMpp5OSwQCUeF09iAQxXRS3d6i0fP3PHYOGQF/4V +yDG/WG4eBtRVtVo42hHVutMjk2wKp6I+JACQTrNFQaxVG9vNLlj1jtXGY8AsDKB6haTybk/Q6lCt +TvXGB/4knIhAq7pcLPSLx8uHY82F1VOr2+fLzYWFleM7xy8GImWWT4QTo1qktbh2ug== + + + OziEEVHELwUC6eXlE9nsKPwtcNAeT9B4lojEGTqNeAM+j2w2+S1GUJ4R9gj3aDH7QRJEY/1kejKR +GohSen3j1lZ3C6UjfLBW7h1tTZxOFha1UGtu8VS1vggwBQMST07E4xOiUARytDtok8m37yaby86i +iIHJQ8N2kwn1eQMIEgC9ZDfemAgkHncYXtXn8wOfpkEnFMpLwaDx9gquhyJiAaVoZLgNewFOPS4B +R0MEZrzjtlr8TjtO4brDAcCOmSw4yAmJT4pcRBKTLJuMxrsXrz62feiKxxvA8aQgVIDTM4VFULAE +KrF06EbyM04QceNxKFvi2aIeBh2etFtJSYhFQmVQODfts3l8Bs2B8jEbX8LCrDbS5RGBd0wjXpsN +B6ECKAeOxuNVacNtJXAqzghFaL18dVnTCztHL8yu3Fytr/QGuzOrN/fn9hL5WZbPZHMDNVi8sTJH +hREYHjJWHBGokQymaWBbcrXGBoKFzWbE6xFoNpUpz20dv378wkOdsd1Llx64ctdT4WQfp5IknSWo +tCDXIonpaudkb+6Snprk+FSjuZmvrwajHVlrgJC22Y1840CgD+5j/5Br/wHXsJkguRqnjuJ04UZM +n8Qy2UxhnmKioCdTmdHDRy88+sFnjp25nq7OBxMDTiytbl1e3LxVDpX8RCAU6fUGB8vVBV1vZLM9 +SUrAdIDzpeg06Bm7w/jGqPH1HI9mpDdgYAwDQwcM1HI5GFkqasEezZZxIh2JVJdWjiXTbYqLRNL9 +ydVza0eudWdOlnvHpFDX5ZbzqfFT5+/D6JDFhrmNxclg840APbuF9Xs0hc9NT+ysbZw/cMB1YL8N +zg8kGIwOYEBwIgHYVSnPrKyfAy+M+EMUA+0cp+k47teCQUD1OMA4R4VFKet00A6HsXLGasbhV7we +CfHKphGnHxE4Lg5uCCqtUBqfXzsxvbgXz83VWpuAVByfmVs5S9MZp1My8v9trMPG+5CwoDRoJgU9 +ZTb5AAmhbn0eicTDBAr6B4cfNY8gIIM5Nr5/n3X/PvO+m8xDB+xQ1cDRipBlSb1WnUmAcbATqpz1 ++BRWyInBph4Hpb3YGuzVO5vzg9Wvfv2HO8cugWeUA7VUYTqamoAb18ITJJfx+CSOji0t3uzHwiPD +DovZ6XRgDjsFSAiqEtSsKKUEKYPhUU4oBuPdenelN7Fdrkxdve3ui9cf0BNNis8ns8uJ1EKtdWhx +647J+XNjUyeC4W4y1j14+IIUTLpRsJYRBE0DT6laT1Q6Hl/I7hTAlIFDsThki/EhMBwsEvisaGJW +j02CWTu0e+vo2LqsFfXEaLayVu8dm1q8sHvsnjPXP1Lr7zTaS8dvvhZOTYYiLVWrM2wGfDGoYsBD +VWl7fLLNbnScD9FlqatpY2Dw/f6I3WZkMnNMzmoFkPGByESQpJGf6QsYr4eEfDDSZKU0zcVhrHxo +TNaac0tnBhMHoTYqtQmSDQtSUg/VXMYkKm530OmQPU6NwmL18kKvuzl04yESiiqgB1AizkgVRipD +6/XHtiYmdwUxx/NAlBUtVJXkAsPE1aCRjEQS0UphHObRbsdtVgwqikChEXSvW7KZCcC0iF5OJY39 +ODwd6Y2v7564vHvyLj01S7IlBE0sL5/68le+Xcj0QUDabTRDpyShJkltQWq4PTLIDFUpjE4ejUSb +DjsB5WQz4S477fdKmE/R5AxFhQDYOSZrMRspu0ND4CY41Ke57aLfGwTqj8e61+96zOliCCrCiFkp +1AxnJtPlxWxxcmFm+9EnP90bbADRNzrbQIux9BSUFiMCeYGE4KJa+QMPPCvp1X37RoaHrCPDbgvc +kZ0FZuGZ2Gh9cu/mq6pe8YEqkAqckgsn2qnCoDW+VmrPU3wilhkrNjYktaFH+npswIr5QLAuSpVI +eLTaWJSDqUSuIWkNl0cDUkAJ3e6SwfnSdE6Sm+BwMTJlcYgHhhEQXV40ooa6DJ8X+OzG2tlef00N +VaLpiUpntzd9cnHj4rHTd40v7cWy49Ozh5557muBaBfUEUCZIFciib6mj0vyqBLoobiuqKV6a1OU +S8ZTGqf6j0RQOEgyy3Jls/E6mxwx+aDG3B4FLoOX64nsfHP0iBKEeUkPxraK5QWGy3T762OT2wK4 +JJ+CkzFwQJJYsNt4UINwWo8n5HUHvQ4BWB7gwjRCaFpNUfN2YDErIwc73ZnT+caGFukieNTnDzVa +y5F4HSMiBJWKxMYyhblwdCCJwI9hqCing6GpsMvJOI0XbWGfV7UZyyEU+sbONeBKWcrDySPJ7vTK +2ZXdK+u7t+0cub5z9OqgP8eQYEuDNJUw1nZ6jG82EUTKWK1BxMJ6u1CcD4eqThuJehXCr7tsNI4E +CL/mcdJWM0pTuUhkyguURweND0gdQNwO0WEHfZIG4SqKpVi0geEaRUdxMiRIuXhuYnz+xNbRy1tH +r4+vnsVoA3LHZ08KWo2ATmGyOJmi2RzHpUGfDybWwTnu32dxWimfW3M54DZZt4tDvFwl39g6cpZR +kh40GMvNBiJtOHNj8lCmtckqZUnKnNq7srZ1FpQVigJuFKLxycnpEwuLN8eTk6JSaVbGPvThT7bG +Du67yW61EW5AEn80GhtrtHa18JjXp25sXQgnOgdGvBYb5QWWwY3MOilQi6cH5fLU6uqx6cXjPjwg +ajCknVC0LgULlebi4b3bT11+jJGA9Ofy9TWSKyBoGCMTHiTs9hnvtTP5uWxxzotIwyMITafCuuEZ +USTudodGTIzJTHl98rDZ7XTTGK6HooN4YanQ2Co2t8A151L9hx/55PGz97rckhaux7IDPTXQIj3A +bcSveb2SIlc6vSMsVzKbKeN5tfFskBsa8mFoIhjsjo9t3Hb9YZYvgpJUQy1Ra/nwNOjMbHlteff2 +UKw1M3vw0tVH2qNbLrdqLI/0RYzgfSxKksb7Pp+HpwkdhLTTZURkj5hIu1P2+qPByGS5tpFIdgbj +mysHLx05f/+R8/dtnbgaivfcSIATMuX6cntwEApA1UrgdgkyieEGUNutnNMuOG0MwFQxM6Wp1f03 +WU0jPo+bdxvvizm3G5ShzLK59Z0LLrfyT//kMJlI0Mmy2glFBjBf+/d7XW4eQVU/rlJsTNYr5e7m +9MaF9tRpIdQXgtVYdrLU3sDJuK73Epm5WGYmmVtUIx2UClvsRiCqyyF4XaLdSgEqDg17oBL8qIZg +IZdPcXh4JVRWY1WCjyQK4xPLZ4vNtWJ9uTm6U22BmSqAfvYbG1gKPLhvMk5ScZZPiXK2054/d8ud +erQ1dMBJEBEt1BTlMoJGbqT2xXEqlsqOM2IaAMRmBwEJxBSR1DJUL4jAUr6zsXGkN77ix9R8dWlu +48rO8fs2D12bmD/Wnz4cTfeTsdZHPvnCHY98yvi4GBatd3bnV24rVQ6XKoeC4b7Hp1qsaDLRFKUc +zNGBISPk2WKVXZ4ITuWT6YlbLt97212Pgmm1OXkXEvCTCTFQq7fXmp3Dlc5xnMtD1aXLs4DVGBUj +6QxOJn1+wN5QZ3BcDjasDhbFI+DHb6g4DWoYABAkK0mGsoUxkFUulywGqsXGWnvs6Or2henFU6A5 +FTl15eJdL7zyjXZvwWYXWLYEKMrzVRSLwbQ6XaLA50gyagGX7RGEG2PFSZVSa2dp9/Z8aW5t6fDH +P/G5xdW9+c3zq8fv7Myfa8+cXti5vn7w4tahC6XGcqU6+5Vv/viBRz6OY8GAXFKUBiAYSyXDoZYm +13ye4IEDKDhWEEIjw4Zf3n+TbfiA1zCS/qQS7ElqPV+YVQJlVizIobagNWW9p8UmXB5JVPPpwkS7 +v6WEKoXGyujcydnNC7NbV8ZXL+ZaO2q0n4wPTu3dvXPkKiPmWaFcqK9nyqtScJoXx7zeiNVKgY1y +OKBfGPONZWxemLX/n6T3bI4su64F/8CIXQYuke5mXu+9N+m9d0gkvPcooACUAcr7qq7q6u6q9r7Z +ZLObTdv0LdE8SRQpPlqRHFGkpNGTRm5iNG8iJt6bmG9zshSBQBRQmch7zll77bXuPWdvwgWOL5Gb +jucnSvXZzYPbW2fuHF5/fnHrSr6xwcgVlPCAUOH4HAyrwSANRXSOL9fbe93Jo3h6juaBROejIO9E +FWCsQDASgC3Fhm7Nx1PLoloGK+sPsgTlBIKsP0DRbEwxasnsVKEyB75rZpWm7UJ1qdHdqXc2Yqnp +dHExU1pQjUrMrR2cvb64cQbBdC8xma0seOlx1WqxYiUQkkFooFHp7JlbhcIMyF8+nwBBXjSajMLJ +cMRKZyZv3n6hN7k1PIxRTMpMTMcLK53po2v33nn2tY/ntx5gZLpZnTt3eIcXEwBjmfzK2PT16aWn +S40LhtONwAocVa5celiurvX3MI9QwE3DqAccejy3WO7sA6vSaixNTm0DPifIOCsVeaWSzc9NLlyo +tHdjiS6gzWy2p2iloX73XnRkhCborKy1DbMbDqujo7SkloqNLV4qADVOsQlGTMOopmnFQmlWUjLj +s2fPXH252t1NFWYFJQ+ukKY8y66fvfjsG5/5+sLKRWCsNL3LMLlwSIJCtG8IGRroF7QfHKBNexws +xKc+NTxwMjoyTAZ8wDKYFFsE1x+NGrpaAekYI2Plsd3Nw8dnb749vngVWI9yY3195+7VO29Ozx5c +v/fa7PqFRHl6fOkIKCavuGbHQYq5eeXG61OLR6JWNd2JQn09U1xW7CkET/5nt4WBkxEcszHMCPV3 +0tIY4bBijpcLbnoylunt7N+6+vSrXq6bq8+3pkF0n0qV1qrtc73ZG9nSehTTEUwTlDLFZ1WzpbuT +kjGhe3Oc3MTxJNR/7sYQVIxgsyHYRohMvxQtnQr0Wxt4ulFB+ndWyScHz8dbE+cnFy/laps0XxCl +TGdiO5XvEbQdy87Orl8/uvH69vnn44V5zanitMZxzsLSoWJkUFLjlALF5/u0ySYo3CnkJhynDnRj +qF8Vv9+cBRAmFDG9eK9YXmC5/qkEHAeKvSppJVkrFOuLc+uXU6UlBLe3lw9efvUztl0gCLs5dq7R +PV8ob1jutL9/fwYHFu/mteebrbXBfpPZfg1Vxegkcyu17tlic4ehvXt3Hl25fs83ioNYy5TWp1dv +XXn6vXO33vVyq1DUxDHtC1/8+vb2RX9I+s8OI5o56SaWaaYwOIhEI1K7s5mvrg2PkBCkwkh/vwEv +l5z4tOn1BCF1697Lz730WddtR2FdlMt2bCJXWl47df36g3e600cMX6aotCTXg/3m0eGnnhoBw/SN +MIBdCTIXDBrHjwWjkJhKTAA7OTwI7AMbhV2QFgNBlaHSQNeB2VPMeqmxWevsU3xZUfPN7un21BmQ +Ms4f3n302vuN3oaV7B5ee+Xu4y9unn1xYfXOi69/Y379tmo0C5nZ3YNnnGR7NMiFIA2oNZ71ohE+ +0O9GpMTtandsi+eToRAHo7qgFDPVtVJ3d3bt6sTyke5WlzePxubOZOpr6dq6mZwR9A== + + + Gi3lRaueqayYyV6EMHEuCYPRmd1EeRvhygHIRqkMp9Xc9CzBpjmtxGp1gi1xYpli8xTTt7ehsAhC +j6QdnDYA4Be37y/u3O/OXap0dtOlZbD0XqyxceaOk+nFslPzp57ONE4p7phsVIBjXVk9RHElEGRS +uSXNGmPZjG7UYdgKBnmKckyrznL5Y8fCA/1ncxInJPPlNc1sQpAeGGUdu4Gi4L1YOExXGku3H7xx +5/7rixuX05kp3ShDEIshssCngdsa6vcCZig6VqwsFYvz8XjX76dOnAgB1wPD/RomBGlxfIqgbIrQ +y8WeYaaHhiCg7WfXr2wdPpxYPB/PzhF0PhIxOdZ75Y135ub3/CF5eITuF5bpt4fo34EBcg7HjHJl +TtNLT33KD3woSSRltSZpTUlv95+q29XnH7/29DOv8zzInonJ2euN8fOZ4iIgQ9sbRxDP1z8CwDVb +OyThDg6iGOJyXIWh0yTuwFHz+HEo6CfH28sffvTHI0PoSYA6HwMUhaK1XG8m5nY4ypiYWpfkNMhZ +FFvl9S6BS6XaYmN8tz25Wx/bSGQndbNSra+s7t1a3rnQntxI5We9FGCSJvC8tlXr9k4pWrm/lYXL +sEySJi0ArX5lgIgI/s2xcb+fCPhJoAwttz27cvX8zbfW957uzuwtzW//+C9+eu/Z1zSvZSWniq29 +RH4lX9te2rp78dYb8xvXGp3Nhy+/r7rdEGw56dli+3S1e+HU4RunLr46tXaj1dr81p/89P0vfz+C +OaNB5UmPPAUhk7I1Hk8vVmtLt+88u7F/ozV7ZmLlQnv2IFmeG58/M7t84fyVR7cfvZMuzlebazcf +vPvsq5/fu/jc2OyRm5pixQLLl0SlFYQAN9IgzCMw8EdJQazoZoPhsqxUCUEmLxRhRPYHUaQv6uqy +0RSlMoZ5ID0pam5y9kA1S4lUvVafzhTmdGeK5isUlaPIJHBe/9lFGkAiGlUx3AsGxcFBYKVZkogj +sAnSPUV5FO3RTExSC6peB6ps2IeHIR4H9g0G5l2S1bTjNbtT+3MrVzSjSlBWFO2f6Xiy4w6H+hur +LIZJ6XYbRsxQkA+McoBpA37eP0pHgO+D9VJzfW71Yntyz0lM43TKH+A0Oe86LQyzAcwwLAbsnq7V +aCoeBvgkvf88pRUJKSePR08cC504HgQ/YohGoP0naCTpHn/KH/QzvhGi3x5xIPLkEQwTGCV5PkGQ +BoiUeGYmkVsSODOTmyjWFpu9nUJj2/K6kpQFzjFdnOJlmxVU1cyKSi6ZW8pWNoHXC/Y3uBqKXJHk +wpMztnj/DGBYIHA3FODAYIcGI8AIE4RFkLao5r3MdKWxMT1/dnV17/rtZ+ZX9hvdrd2jRys7z5y7 +8ur2/r1yfdGwS7ZTr5Rnjy7dN2PAL0xPLFxc2b45NnuYqy46yY5iF7PpztMPXr329IswblvelGJ2 +Y+nFU+df3jr/Yr68ODO+/t3v/fnt51624u1cZbE1vTOxuH/z2Tc+/80//caf/vwzH3/34uVnP/7K +J6+880UvO+tlZo3YdLa8Obt86+jGp1d2HjNCSeTTval9EEQhSA2FJZxygXnUvZnuzFU3OQVE3dj4 +kiTlNKNpJ8cVuw7EpKjWmt39g4sv8XLStHOWW+OUSnP87PjcdTuxjKBZnMzqTk82WsC7qUoK4AHk +1nBI9wfk/jMFH0sz6WJljRdzUFQFemB66Xpj4rTqtCRgEtU8jAokayG4EomyFG1wYoKXcoKSU80y +J2ZCYZaX06unrhYrc0D7CXIZjmogfUQgTRQr0Yji8xGABAC0IFih+aTm9vLVXVFtMmxaYGMC17eW +qlYOBsThIZKmY7pZ44Qi4DcgIyFgMU5E/aMc0DkIQGxIRhFj1EcBXd3fGRgQKMIFP/pGSBA7QyN0 +EAKqxqH5NMnGTbdeqC0hmJt0C8l0m5cSTqxpuuOa2TXtsVR6JpGZ5ARLlm3NypG0rVstMz4tmy2Q +hhgm69q9eHx81EeGgxwKq5EI0CTc4AD0pKYQhEQN4PtQ1OCEFCtmG+3NU3t39g/vldtLvBx3YtXZ +5cNktpsvdpOZMVZIARCqakXTqrbTBCGcKUyXG8uylqeFHErYOO2oeta2itn8hJto9otAlgHeJkAU +TM2da42tJ71ir9F77rnHM8tbhpmfmtm9cu/Fuy+8+ezrn33w6qfvvvT6mav35pe3Hzx8/ujqc9Oz +Zy/dfG1q5ebM6p3V7bszi0fAtJK0F3Nqj177aHbtaGAIG/GRDJeS9EaqvNOcOGSFpCTEX3ntPdMs +A4EUwWwHGOfG9trph6cvvj61dlsQk0fnb7725oet3jbOpES9SfAlSqiPTV44uPxmrXcGxc3btx81 +OmujAb7fEj0gw2iMZPLNDtAhFzS9OtHbXli72hrfL7fXBb2E4B4nFRSrVmpvsHI+HOHAuBg+xotp +krGAASGZhO40JhYv3n/9q92ZA0Upmu5YtH9IhO4/0g3273cBy1BtrPNCVpKSidSYpDerY+d0b4pk +gHUC9FsWpSpIZ6GQSpJx22vF0z1BLqK422+TNwwYKQIWGsNdwLH9A0RD/c1sQ/1thP0Od0DMnzgR +RRC7339qAA3Dpua07eSUEetqVlPWG8GQpssJirH9QQojdU5Mx9Oz6eJ6sgAMYFmSk4lkXbPLUESw +nHa5tZevnaq0Tj8pStmvvzc6gllqwQETHqQHB8ODA2FAYsALUwRI0EmWStWbawTjiFLKAkhurmpe +m1dzut0oA8nKuaFQfyMQw5dS2ZVUYUOzuihqI7Bq2A1GyA75qEjUZJgkiCY30ZWUIorZwRDn8+E0 +ZQNVEAj2d5KQuKYJdtrJZ1NNUYwZarJemxqbXKqPTaVzHc0uGYlGsjhVac1Nr+zlq4uTk5tX778+ +s3EFzKSm5RnKRhEJjdBpt3Rq52qhNg/0s2l0ErFp2xmT1TqCg4yPq6K6u3sWJ2yGq9jxuXJjZ/X0 +/e1zD+Y3r7vJCZn3nn/4wk9//TfbZ25RQiFV3si3z05uPnf70Rd2ztyrNOZsO/P2pz/YPXsnBMnA +3Kn2ZLpyqj154fD6u+n8XMJtvPDCp28++64vIAB7Eo7qvFhe2bp7+en3Lj58383M12sLr733tUpj +JRyWoKgkaeVqa3/r3PO3nvtgcv4qMFbXbr6SL86f6Hfnifp8LILEACqyufm55cuSkLl5/cHH3/5T +QcxSfFX3ZsGnm/GFncNXj+5+ttzcR6Lm0w/evPf8W7FkZ9hHDg5j4Hs4LGNojOPrA/1eq+SZ01dv +3XgOEMixY75jT/k+9Uejx45Fw5BrOvMIbMwu7HfGN4AtlXXAezkU92As4Q+DtUsBk0XgumkWYFiK +gn/TMc3ppArL7d7u8qkbVnIcw9RsdtqJ9/o9TyEF6MYRH9PfHknZipiAISbkR1hKDgXQQIBEyRhG +p4CdIcgURiZCEK9pBSDh6pP7W+cfLu7cac9fieXW/EEGiQqaVorC/Vt/T5w+B4Vkjs2k8/M0lwUR +EY+NgUuCoiKY7RE/D9xiv3wfbChCLtDfTyKkc7NA7ipijiFjkbBMIBogn2SyTbNmIIBQlAUIR7WK +3ZnTG6dvzK0cWk4jkWg6sTZOWDznKUqapV0cUVhCp0nwFmZoGAPeiqFSIORxTEVgLRQUJC7BkjaF +m8CSgwDn2DQQzDhh0qzLMJ6sZBNutd2Yr9YXQEYAFz8+c77S3oynWrKakiTP0Dxb8xQp2X92P0Jx +TFICF8zEMEyPRoRomAXpyYuPCVozEFRiqdlkftGwWhMzBwubl0utNYIwi+n66b0r2dwkgXmJ1FQs +NWE4DUnNakYeuHLgZEUphxPu0JPmFEArWvaEF59T1BrLeJroVErdbm+tf0qxuBrLr1Z7h9XumVR+ +xk1N0kycRPi11TPrp66IUhZIQd1oEiRQX54s5v0+0j+CW0r+0XNvvfTqu8DL9PurjvB+yCG4Yqqw +lswumGr6wy9+9fHLb/t91InjkH+U54VKprzbXb0dDAohP8UzYB1rOKYD0gApCUw+0H7t3jYQQhSY +Pc5dnD9drsyGITka0YGIpdkUmBw4wgRHkdFhCA6jEitGoQgMYSwXKzR3dHdS1sdoPs/S5vT42s7u +9Vh6XNZLbhKY5QWUyITDAo1rEh8LB2koyOKoRWIuR6csqw18GYx4FB5XhZzCp5uVubmFQwjRQVpB +MRMKywFA+35SoM1sdtw/ygwPov0WzMMkAutgTlg2zrAuAIbr1UU5iWCi7dWLtbVYak63xpqdPS8+ +gSBaq7FULs+GQ/3KJFEYWHUvEHQQJCcKVXBJQT9syDFTL40C3xSS/vMJIAQZ/ZP4Ed3v5zSjH6Ek +lTLtjm3VKdIJhQQgg2naQxEtGCBpor8jkcA0AFoUUcOQMjxCgoggMcU/AvdPZ/vpcIBmCZOh4pxQ +wIh4KMSkc714thuNAotqymqW4+OKlLb1jMS74QApcl4q1YCjIKwIHFMAvBUFXHAaDMfvp4MBjiDc +CKSiiI6hJpglBBJkzuIoCxiKaEQutzdkrUxRMYqOo4gJ9BLPJjQlTaJq0I8PDUAgNgnMOHkiPHgy +EvChNMYKtBK3SsXsNIjTkycjQ4NENBojmDxOxjHMoiiZAaal3HbswsmT0f65MGeiPXFuZu3mxOIF +YDFwACfcQBEBR4R+dkBkMC5BSjluzXbrAPmq6OlKnCZ1sBA0ATxpAsN1HNP8PgyHRRRi8CglcxKJ +4jwj0ZTmJuusnEEwE4ZlQ4pvrewdHt3WdCDSYvHkdL15xkss4LiFRFgoQARHcTgsYIgKRwQkIpK4 +SVEJUapxdBqNKKaUOrd94cHjd2BMC0d4FNWigLiiGomCLyXgx0eH0TAQln7ghqRIVHtS5IGHIIlj +4rZTo2iLwJV8cTpbnIulpuxYz7DGOECJsGabFduugReDVfBi48nUKk7UEDgbCkq+oUg4gCiCJfLu +8X4ZmTAAMI6nKDKPYjEI0mHY9OJdlksDoQIjDsjj/V+iDhDGgBj7BUAGIpEgjQDvPIz0qyIM4SgG +KC5JoAaOSr7hiKnkU7ExFNYQSEIiGokDJaBFIDaX77qxit+P0aQhCDGGtjnaITEZDhNQAGVJLZ0s +hv0hOBQlUJBrbIpywcf5R6nBgYhvGAPS98TxwMgQgkSUkJ+JgvVCFDQM2APATOyMb6pyOhJiaMrF +UAfHTBARYB1HBqHhgWBgBCURdbhfoQIG9hCHDcfMWzqI7hQWNY4fD4JUeOJEX0s/OQaL+0dxkTcF +zsAx0TcCA7fIsmlFrVhWzUu0FbXkHyXCIZBPoyeOD0eCKIaCBeI5xigXx1Oplq7nMVSBwsToaCQU +oEk8jaMmjsrpeKs6tjk4ArgCGhkK+YZCJMLwpGTpiX4lIjfDy7FQn+rdVmUqB1QQ76Iwn4zVTCMP +MhGCGcPDeDjIRMK8DMyLnMNQGQROKEBEQhQcEQGnjY5QaESztWy1OF4sdmlSNvUkTQ== + + + WUCjgjeiUREOi8ePhwFlRcP9oQ2c9I8GhEjUYbmiqjZNq6MbZSTKAfKZmd2VVGBGPKDiJLnseWOF +wpxl9+8cBgM0TVssawOo95+L9RtQ4gjw/rAQDhG+4XDQFyFgHoHApbJ+P5AxtqKUBb5PFBAkPjFZ +dcA5DFt13MX+IRdED/YftAFeJYYHg1CIATaHpuOamuFY70lphUBgBJ6f2tzfv0niht+Hhv0kHOQk +1gODQiJCKEAOD4QxRGRpwDZiKEBhUY5COAYXSExEokjQ58cjCPgRRCLPpVgm0X9OPUpAIRas0fGn +RvxDmH8EHQYwOOYfOh4aHcZhSGIJSxESQLekY7kz+1eAyATJLuxnAatEQkI0xNOoAeDnG4Ids+7a +YwikECBHhPiRQeTYp0Z9w2BdZPCJJ46NULjKs17QTwVHwRRhwL6NDEbwiCRQMQLWI0GWJV1JqAwM +ho8f9x07NgyGTGCKpgD5rTiqc/bsBcvOj/rJcIhHMZ2iEwyXJ8i43wcbon14+uq7X/peKCp96o8G +Tp7wR0O0xDqaEnPslMzp589cXNs+H4H54aHIk4fy/efyJKFxrCYLeswGCnNK4LIUaQONF4VY8Hsc +JjlSUIU4EmVhCIdDBIXJrl1maCMKgRkISAzt2ACTbBAiQmEEZASZTytiEwqpIBMNDkVOHB+BoxLP +xxnGgfumVYNhA0dURYhRmBKFKFVNp4vzMAo+UYBC/f2ZT/43YWjZUT82MBACbhoKijTuwpDoH0UR +mE14qaTlipQY8sP+UQRBJMup5UrzAFGhIAuuqFpf8mKdflfowQiAExzh8X4G9GShQKA2AFLSrWXi +9WgYB5Qu0CqJiCQq0agQCaEhPwT+/vnDQwLlhk+GfIORk8dGB48HQ6NUv8wjbT55ECzCkBEN4pFA +xDfkHx7wQ4GIIyulhFPJxAxZK5bbouyODAMPFRzqLzGMQhIU4AZPBI8/NXz8U8NBHy2wGZ5JRIMs +R2iekY5bWU3JBHwYHOaxKMg1gg8Qy7GRgeN+3yAUHsV5ysOion84AhA+OgKQzxCIjcFuyM8PnAgO +HB+V+QQA5ODJIMAhSLs0YZpyhkb0kI8dPolEAiCyyKGTYd8wGgkC8uQCPpijWJ4iFJ4oxs12u8Zw +PAwMkhEv5muem2RYKRqJ4tGoA0xjoRlLVE6cCAwNhCNBRhc8V/EkijYFpp6JLS3NeclMMIz5RtEI +BHKoKvBqzDEzSSebsNbnuw/v3202p4eHw8NDwaFBP0sIMpBHqqzxAgpFbVnIeKbEAkSNRIN+noim +XLGcMc+fmjlzsDyz1i1WwR8TNRWIDQkImCemGANXogqqpcuaIlq6w5KmKmZpwgayxz8U4Qghny5W +6mOqGsuk6gxjYAiHwzwUJAdPho8dG+3fy8L75WLA1IVGEaB+66XOzPSMJspIGPf7EAxRgCpw7BzH +uyRlFovjup5R1QzPxwJ+IhpmAGYoXJBZlaMMNMqDlM0xKY62ZUZSKDLrao6qy5xgShKPozwAGQV3 +6/HFuZbAAlYkEYiDgzQeEQlYBYkMwANwCAUUJsRGAgE46I8GAgYvNFPWXNndmcxd22td3h1/9YWr +u5vTCUOnCAmOcCD3sagBAPbUHw2ePB4IApcdZIPDUSJM8hjtSoolyjovYSB4g7DM8jxNUYAfKZbF +BYl2TCUbCTODJ/3Hnxo8ccwH4AGS4yBwnYPk8WORY8dCJ09A/mECgD88CsMhJOllCJghIpQhuEgI +aH6SxlyB8QKjyMkTPv8IQgINE8Kifj+Ph1wZrqXY6Ya9OF2oVZxcWu6UraPV6t0L89trzWbRbOSd +uO1qso2h/MljQ6NDATQEGwzncoSKB9IKvNKJ1UqWqTOGxlumIXF0wuKrOXmpbbx4e+PFZ3YfXJ17 +5uZyuZAYHgoMD4bRCBCsrsYJFk86HOLycK+grXRj40UpY8DdnHhqMvHindUX76598tmj3/zojZ// +8qPPf/72xkI26dCywFKUh8AuErFEysi6RqtoTDZivWrCk9mMY4mMEA5A0WDYEoRGMd3tlteW5158 +9dVqswMjaDCAgAsYOAH4ilHUJkWl+rfmjp1gECRlmrVsJp+0sWgYDcPRECyyUrOQuXx4ZqzTtkxr +bW02nU6gCAlBhCi6LOsC5UYDXooCImDAV8ZyS8ksSIQ5i89r6M5c9vxWb6oWbyal7V7i2evLr9zf ++uC1c68/s3P38sZ8r5yyTQKC4SAG+QkKMSQ+zeIii+AqjZU9drygdgvaXNM8N2ff38m+c2fmS69v +f+XVU3/4xVd/87Mvv/3M9sF6r1PJ6ZyIRwgkTEIhmqEcnrSIMAxMdV4TGzGtaLJTJWN5LDHbTG3P +Ne9cWr98ZvrBtaU3n91/5cHly3unO8VS2rU1gUbDYaC+oADtG0IBnHxDOGDUk8d8I4PBqB+B/WGN +IrKm3CmlPJk3GKKa8srpZEJ3k0aSiDInjvtAwEJ+DIgtFQvbxGjdihxMqM+eqdzaqzw4an/0xplv +vH/lg5dXP3zY+d33bv3jr9/7s6/ff++lMzuLnazrAvsQ9AUh3zALjWb46GQcmUoGl4rRC3Pa1VPZ +w4300Xr6xl7twfn6q7d6b9zrfv65qb/58xf//tef+c7nDu7uJPIGGh71+30RhpBZQiQjiIyEOmZ0 +v0UfTfKPD1IfPZr/9NPdt+80Pv948uef3PzH33zm59+6/MtvH/23n77wP/77z/78G3ffvDd/abuS +izlEFEQr64h61pIaSW6pru5PGDMZZK6Id5LEUsta7XrrXefqdun9x5u//+23f/mrr3/xw6cf313f +2xhXBSLgG4UCGBwVBweDJ44NRH0jHhdJCdGcAnvsqMcFuhlxrmYuto29SePthxtvP95/8e7mV969 +8OMfvPfaC1drBWtuqjs7t7O8dVfVC1jQb9FwnEdaFnYwrjx3rnp/L39mXHjxQunn33vuZz948XPP +zH/hYe+3P3z0b3//5X/5/Qc//tKZf/7lo7/8xsVzC45NQ0igX5OQgkUyiglwIM4G57L4vc3Ydz+3 +/7PvP/z2585/5n77669M/fBLZ37/l4//8uOjH32088+/fuFvf3j1g/vF+/uZ3Zl01lFzHsiVcVNN +SRSbEKIdF14pMDdXvDdvTLxwrvD4fOaPPzz/6x+9/i//8J3f/fy9X3739n/87dv/3//7N3/41YeP +D8vfenvrFz945r3nNtKmHByBQZIFNpYjFTQUIkDKh3w6ETDx4dkseXkxfmk5vTehH81bjy62/uQr +9z56eeej1y+9+fzVjOPCERYwsIwRRZWeSmDbVfLOovLh7cZ3393/5N29n3z15j/8+PX/8e9//ruf +vfOjL535m/9y719++9mvf/ro1FQ6DRwkLTqaJxKEScENA1vMwue75M055eW92HdeW/rJ129+/4Oz +33hz7S++cOYf/uL5//jr9//1N2//+vs3f/u9y7/+42uvXpsuO/0kCERIyB/BwqgnaiVNXkhQL26p +716Mfe569pPXZn7zzXP/5+/f+LufvfBnX9j79XeO/vGnD/7uh7d/9OHmTz5a/+U39//L57aub6Xr +aTcSQJAwRUfwlbHCettdqUrXl/QvP9f90RdOf+u12W+8vvC7H7/4y+89/Sef3f3Bp9f/+999+D// ++w//8a9e/913r/0ff3jzex+d2R4HWPAPDw6FAzDgdothpzN8xwy3tdHL49TDLevpLeulC7mPHk9/ +/3Nb33xz4SffuPLvf//l3/7Zo9//6IV/+9sv/OU3b51ZLM70utlcG0WUtOVWbKkbI7dL2KVx6vN3 +67/42uFvvnPlu++tf+edtZ987fK//vbdX3zn2vfeW/+vH5/733/16q+/fuGbD4ufv5k6M8YDVpEo +zjcYPPnUEOobjTPBqRh0rs1eXzIfn8+/f3/qp9++/U9/9dr/9pPn/vDDh3/40bM/+/jwZ1/c/bN3 +pj57PXtpWh6LEQkJ65cTZXWGMDwj163UVzqJqTQ9l0Qu9qjP3Wv8yXtbP/zimT/7ws7PP7n4+588 ++7c/ffyLb1/+xRc3//YHl/75l8/87gdXvvVK59MXvUdnCrWEBocZgcuwtKPxSiNt1BxizMPO9pR7 +a8qjHeOti2kwG3/9p7d/+cnFn3398P/6p6/+3//6x995a/2Tz5x7fGuNw2gswsZEKcETaT7ScdCl +HH40Lr14UPjmq6vf/8z+jz9/7t9//en/+R8//rsfPfejD09/+HDx1Gw2odIcRhCIoMtJU046kudy +TE6C57P84VTy7lb2+dOxH7yz+r9+997vf/Tul15Y/uLDzvfeWvjJl899/c2NB2dLB3P5RrZggJgS +UiRmAC/GEmrGTJZtJyvi4y5xMG6dm7SuzlufuVb94Qd7v/rk3vc/d/Y7b21+4dnl1y+0Xt0v3VlL +rLWVeoo3RToSpkUm6+gViRQKlppTqaKCz+eFB6fy33h5/i8+PPVXn1z+zffv/v7Pn/+nX779069d +/NmXdv/5p8/+2y9e/NWXN7/zOPtoPzFXEBg4FA4gllrIeG2dsywarxtES43OO8Eb09wrh+k3Lxe/ ++nj+33/37j//9s3f/fDp//bLl/7tD5/7yTevf/31lfefnV0ai1mKzlIWGE4l0zA4LiGS6w2nF0Pm +4tB+g7q/Hn/9UvvR2dq9jfQHtzq/+ta1n3x8/Vuvrn7pmYm3LnUuTsfm8yCnIiLBU6gKlMzwSYiB +aREOeWRwzMY3Gtb+ZGZ3LHFlMfv8QenNK2Nv35h588bM2Y5+rq2e6ZjzBTvGiwrJCgQHNL/ExQQm +rolpXXDL8UTRlAsqu1J2zk2kDsetNy/Vvvnq7F998+Cffv7oL790+NXnJr/6oP3ytvVwQX28mV4r +ihYeYqKoLCRNo03iDrCBRITkImGXhGoatlbkzrapZ9aNl/cTX3zQ+f1fPPP//PvH//irl37zvQcf +v3xwcb44kXNVXo1EVTTKYqEw3d/XhWdVtmYxE0lhpaIdziYvL6Wf2S1+5dHy1944/fbdqdvbpamS +ztMwFPD7R8JQmE947Wp5Oe60FUbXCLLhGWcXuld3Z3pJ/GhCfeFc48uvXbp9euzKcu7WZmGn53Qz +alJjgcFhCKtfrjBqEWQCGHngoJNe1VVsCUEtiszrcsEUKja3XLMPZ3LXVuuXlop7k+npfGwqFQPL +mFR5jsDgCBEK0YEARxMJElEifgj2BxkoYlH0eDq50ckdTrt3Vt2Pnul9/7OnPn5h/ocfXfjhB4ff +fWPtk5cWP35m5v2rtcuzusdHgGkXGbVf+hh3ScwKAUMEUSU71o47KSbUtaOnW/KFSePGgvXJ62v/ ++tfv/9NvP/1fv3H9u++de/Xa1NXNwmLLAd5YkZKW1aRIh6ZMNMrJjN5Kl9MSU9DIms0VZKqq85Np +qxdXZxPMhen43e2x81PZjsWUVTEpSBrJUTAT9LMjQ9TACaAAMZWP8QjBQpAEIylVLQ== + + + ek7F82qOlZWZFE/lZK5iCS4VBVowzon1bEtkHOBKUKDkYTGdahOYEQ4AsU2gYVKh5KKbWxxfmW/0 +6qa0lFNvLOW2yuKl2cxBL7lekDeKykJGnUsbFZWDgCwYgmBIYek8EgU2MAycpm8ggAf7E5uR+Lol +5kV4MsGs5PnL09Zb18Y/fWv2uf32QbeYZBgBpkwl46VmGr0jhvRUMc4SMoOBCVF1QVUY0RCUejZb +ihl5W8jbvCfTpsTpksLQIoqLwKoPDyPRqCJKKYpxRgNUBBIF2jZEK+1m8okiBUExjq55VikOOM2U +SV4iOWAooiEKOCkoxIz6iJERAkFj8dRCMrvQ30Imp1lKpxHOED0iCtI0pbPmeGVmujXfKfViqq3S +vM67Vt/CECcHfP4AFUVjNFsRxbImlxhCHx4Y9Q36ga/XBceWPUc2s6ZWTxkLDe9wIbvdsc7NpI8W +6qu15ERK6yassmXCwejJkyOhYP9s+/AIeuJkEPhNksqkkrPl/EI+0ZIp2uGxisnkJSwnwqdayRev +bL90++DC2vRipZiURZHACYRgWAdBLBgx/UFBszrV9plKbT8Tm5BpY3Fi4crRTRrhwXpxmOzKyZxb +LCcraTMtkwo8SiIh2Qds6YkIABUUsYNBPRhQENgWuURkFMZDINfjvmGkf/srSEXCPBpVadxmCIeA ++ZAvjIaoSICNhDiu/8TKoImY3D/MMhYKScD2Bv00AesMbppaSZFqIHCoKKtQUjNTQv1hT3RTVtHi +LSZC07BEoYq/X2k8hMAWRSRGR6hP/S9Dxz41BPwmAcuWZDtKjIJpMoKrpOAKSv8sLhY1KdSkaYfT +bS4RHMZG+wVhWvn6ruONG+ZYq3vKjpVRTCApW9Or2cJKIjtH0SaOiZrojrVnfAFkYDDs87OcVNOd +Cc0c5/qVtZIin+72TklGxRdSUKJ/KAMj4mFIw2CDxrTgKDpwMhAcZQnUFfgSRWUATUVhE4I0gUsB +WTLq50cD/VZHGO5petmya5qaj3k1vr/lo/+gDUUt8F+cUBSlkqyWDLupW1VRiElyDsFj4agehQ0o +YqC4h6JOKCSiiErTlqJkRDGhKMVYbMxx64aWp1FeoEUdLKyQGBkJhwIYAuuy3LISKyiVGvVTAwOR +EyfDABgonpG1Vv9A4ijp85EY5jCEi0doHMI1VsunAS/pMCJjuM0+qZUHI/2C5+C9wyBSEF2SCpn8 +CiuUQmErHJajsOa4XS8+4RumQgEwvY4o5RS9HkXcYEiNRAyBL/N8MeAXRoYZkszlihu61ZWUBoLH +h0cAcliZ8RQhBjwawxfs5Ey8sFjsd6SdfNJtXKJIu9Ha4vrVy3XT6sYS86nsqptaGgmoJwaJk4NY +OKyPjtBPfWp4aBCRlGa8sJEqrOlWD6D35HEICop+H//UU6HBQRQnk6ox7iVWdbMXgszRgDI41H8s +xVIOAPNA/y7ZyOBJKDhK4aihSQWZi/mGoKAPJqIigSg4WO6Q2D+yFJIjqBuO2k/90YgZnyW4NCfE +11ePWhPbKB2jxRxOJwUlL2tl02q1JvZCiBSOSjSXMmItjElFUC+KxUWtXWvuHV5/I1dbHhihghHA +E7NOalPQegSdjUS1QIjDcIsXiwBvMOogeFJUx3RnCjCirFQEIRsMq1DUjKImxeZVq+MmJyStihEx +2+nkisuCmFO1Cs3nBL2VqpyKFdad1JzudHgx25m6IMjVCKxKWo7ms6rdYeUKSmdxJms43WZ3f3nr +BkbFhnxkMCzTXL6/wY9Kklz/CI+ll9udbcVoyEaNkesoVSCYqiD3gmFAO2440t8T6A9S0agkSXlR +6ZJUIRTgw0FelkrckxMNolpPFpZTxXWKr1F8NYrFINhk+BxJp6JRjecy4YgeCCgYGaeFAkbnR4La +wCBFUl4Y4kZG+oVkYdTlhArN5lmugBFJislxQkkzO6N+MRJ1YCyFU3kYS1BsASOTg0P40CCuqnVO +yAVCbAiSSD5P8EWCLShmW5D72zIRzEbJtC+oBiImTGbs9IpsT1nJRTO2cHKAHBlhGTYnSHkoasAI +iP1YGPIAOWN4AoKM4WGKoNOW07Ps8Shs93uPhjRaqPJyW9cqcEQCsDx2LDQyhAdH6XBIRFAv1D// +a0AQQJQ1OoQBWiNxy7DHNGdCtsZFcxyncydPYIzUYMRyLNE7c+5hpb0CYTpKxxHSs2LjVnyqXzFM +b7D9zTYTTmIshMgjIS4AGTRfrbTPV3qXsvVdUshGEI2TKqo9pTozOFuGyTSYf8PuxlKzmjMG6CUE +aZLW9tLbZmyZk1s4lYJRD1yAoDRgzIQiCieVACpShdV8ZStTXPOSs4nk9MbuHV6rUFIp29ybWLk1 +v31veu1WrrFTHTurKLVUfGxp+1oYNVAqBqClurPJ4la1e1junE8WV1HSY8WcpNVZoUIwWYBP3mgL +am1y8szG3kNRrQyM4CHYdFOL+frZVOEMxTUjaBJCXJiIPdkLJ0Wi0nC/C7PSr/2LuQSViSCe6fSc +xDRG2zBhg0Vk5LZk9TssG7EpgLFwWB3r7hpWG4x3xM8CSiS5EsXXRb3HiEUY0SKQoGtl1WgCKo5E +AQE6sj7mJhfjmeVEenHUL4lyQ1K7vNQCnxVG3NGwMTDCQbDrxOdIJtuvb4+7jFgSjY6gdxmxEoRU +AGzVHkdA1uhXQqtiTM6IzXJKU3UmGaUVhl1JH/NSC74AgKUCoEWQBUFq6fY4GFEUdqOwo5pjIBED +BA6P0FBEldR6PLNE87V+zZYRClxVMGwCZjtxzHfsmP/4ABGC45La1u0eK5T9PjYYEAShwIIQRhzw +1S+eicUUrc1JrXxpK1de1Z02zsRYqWDGewjtcVJeUBsAhIJaj6WmKu0t1W4EIrKg1zAqjeAJksuG +sGSUrMBE/j/38IeiRhTzJHPMiM1Uu0eLpx63Z69FiQSC2Bmvu7h4GMYcf8QORTyMLCrmZKqyk6rv +Sma931gtM8XIJcmo80qFV6qi0YplF93UFCWkzVj71NGj5YM71d5usrSuujMAk2Agjfra8vYNMGOC +UsrXdoqtw/rUpUJ7T7LHYSrrJCZnV2/mKuvBkB5LzC5u3JxYuNieurC291DzpgCJAfzwcpkRMjBu +4nRqeunO5MLT1d6NWGEbw1Mo4UpaXjBqAyOsPyAB7lL1Gd2Zd1MrqcIKQmiSXvayK2Z8EfBDdfxw +fOFaqrimO5NAaMlGK4JaglIU9bbu9kBeEI3JQKR/2M2yO9NzRxSdCIbBKtu6NZaugBmY5I0Jgq0E +QnqhuOZ6vZGAFMVS4YiLEhnDW3Szm6IxFYbjydTk/tl74X5lP3rIJwDi4gCFljaXD17mhOrFS899 +6Ws/yJcWB0d4f9gQ9E5l5uLE5tP16Su6Nx2E9FR+AYSGb1QaGCQQMhnBAK/WsuXTdnzJP6pAYVUQ +CyCmRnwY4K6BEd4XUlkAodhStn7mqeORoSEERvRw1ApDNsAkjMaDYRtC4ro7E8+tggQ9GhDCfX0S +x8i0l1lD8SQOHBabA2Qim71K6/zE6m1GzjrxsXR5uVhfr7Q3E7lZ1aqDyRT1SqW7B1at3zZXqlix ++UL9bKF51vRmwDD9EQWhPEBTIMNSfJHXQGRNkVxdsydbE+fr46eQ/t7jnuZ0JaPDiDXZnjAS07JR +nVs4t7l/T3fbaL+qfBoo4dr4md76XSM5b3utmZmdN979Sq23HsZtWmrkanuNicvduav5+hpGOiN+ +hmTTBJOGSZsQMmHc5bVGd+7awubDUmuf15ogddbGzrJyFaXTkjlR6py1U4uS3gV85SQnB0fgYIR0 +U614rmt4nQiewuiyovcS2cX1U7c2T98ZHKH8QZHja+3uldmNZ630KUqoM2z2wfOfL5RXwhETsOLM +yvUHL3344NWPFvceKO4kUAua3nzzrY9Nd2zIx0fRlGrPpcoH7ZkbqzuPyq0zNJvqTu5mCzMjATqM +WLTU8nK7c+vPdaYvjM8cif1Ceblseb2/iBFT0tuKM8lrYxTfyFdOT8xdgNEYkMqAoiWjKxrN/qZW +Kg8029r2tav33+TkIkoknfi8kwAGuEeLNZIpADXCCtXq2Bk3uTAwxAWCuu6Ou5m5VGmt2NoBvOQf +AS59anzmEAjggSES5HrdWxGNrmz1CK6CUaXBYS4R61y//qJhVD71R8PDQxhGJqzYUmv62u7F1wq1 +rUBQuXLjdSc2HoroIaDupU4UCCckBsZiJ1ZqY1d3D99e3XtO0yunt680u+tAcWlm3YlPlpsb9e7p +xsRBorwkyPlCebHU3sXpNKeWeL2KsyWQWHmtbcSmc7Vtis8CtcYrjUx5vzJ+rTl3Ld89w6llz2mv +7zwdy00CGBjeZKq0Mbd64/zFF87feLM7e+TGxse62+3xHc1spgrLjcnzqdJWsb41v3p95+i5ZLHX +6mzMzF/V3QlaKBFCHqPjQIkxQt2MzXNyTdXL3dk90ahGMNdwJ0FSkKwJ3ug2py7Nbt4HmDS9KS+/ +Ord5ffng2VznHPBJQdiBYEuzG/nmehBmFbtMiRVO6aRLG4nCqmx1wCiGRkiCSsp6Q9SLnNHkjRkt +tuCklmLpOQTvd7PKFedVq8pJKSfVq02fTZaXUsWlbHkjU1hGcAfQo5Ocd5Jglbt2ehYIadVb1J3p +fO2UGesFIanS3GhNHWrupOlNClpNNpsUV4gnZwCqWSFHMem55QvXnnlv+8LjidXr5c5Z0+2ybOL0 +6Zt3H34QjJgIEXMTk62po+bUUX3ybG3yEIi0q9denJs7i6I2xSSqE2enVu/2Fm7Wxi915u6yUmvY +J9JsLgKbdmLaTs0biRlObwDxkyyuJ/PbA4NsFPbimUWaKw8OI0Mj+MAQBSNJMM/ACOhaOxgUj58I +AfnKiRWqj7o8yRQDYQNQ2ebus4nUNNCrCO4BJIDkSFBZkKaB4rITs9nKOohlnk8vTO9kihMobqpa +NQ8od/Pu6s79WnffSnRFJTfW225Nnw8AUUfait3Mlk81e1dzjb1MdTueX5TVaq60qFlNw+ulKtvx +yobsjtNiKVdYn1m7Z6UmUMqttE9niivj0/sHh/fnNq47yQlFKc1OH/Rm9nkpn8nPnb34eO/opaVT +92c375Y6pzUjfXT+zpnzz8A4IGFAX2XZbAMMJIvbmjdPceV0eurq0697mR5CeKn8ihGft9Kr5fHz +py+/Nrdxx4vN7Ow/mFy5zGolN7+keAuM2jXiS8nibmXsUNCakpy5eusVwAlhxEaIBMGVSaHKKjWa +y+WL69XG9vrm4eTCOZKvcUoLEHIY9WAyprudiaWrfdqk3WRuJltfTxQWS60dL7sE4xmUTGWqG/H8 +UgR1OKWUKK3lGge55rnm1M1840Cze7xYuHjt8d7hM4JaAeKKZPLAIJRbp+PZJcsbAwqW4VKzixfm +Vy7E0z3dawO0u/GJfHl+7+wzqxvXgV9Q9WZv9nBu646TW+LNMd4YA/L13OGDfH4iAg== + + + SZJSLLW28rU1LzEBwo1Vx/yQM+yTJLkMo1Zn5vzWxVemTj1INXYz9e1UZYtTesM+BejY8YkDji9E +o8C8m2HIIoDmUcdYvhqJOAMDGBTRBbEGSGlgiAmGLE5ocWLbdJec5BLwZaNBAQQUgsWBa6CZTL+A +fFgCM4AzGcXseKm5fnTIfeUpCGlRrrjJSRCMklYD8pgXS4nciux0B0DyxUwArWrnoNo5L9tjOJv2 +QwrHppvtXUUrs1wSEN3k6g0w/4tb9xe2nm3MXBTMOkI47ckzJAMkjdMPeaWq6I10djZTWOSVIkHa +jlOLJar58lQ8N23EeiyQYUo6nZ003SZIIixfeNK3woqSpuJ07OSC16eRWTc9BmO6qhWOrr66ef6x +nVn0Mgv9Q9NWXZYLCwvn5pYvAqYFOr/QPIoXtrOtI8AhJNCiISkZ6+yfu5evLpwYRDAqA+glXdtx +0gsgtOOJiUZt+d23Pnr00vvBqAOhMYqrmfGliZW725fe6Szd5aXq6dPXPvP5bxWry8CjMUqPloGE +nqj1Li0evARWLYqYNrBFsXGSBXhLYnQap9K8WE08YaeN3WuJzOT0zBnL6XJyBXiNCBrzQ1oI+E2p +WqrtqkZDNZua26XFQmf8YGrhciy9SND9xkm5wkIsMU6BVfPmkkC7Vre93KqotcASA5uQyM7jZOqJ +6RMBGUrWTLx4OpbfoLg8TsZqnbW5zYuCXh4ELwgrFF/KVHbAW2KJKU2r9euDEVoiNYViCZ9PHBhi +QU4c9WsolkxnN0vVc4JUyxXmM7llOGqFgjKQ+sOjEkCaqLTd5DKKpSSjKWgVEHcgBCguCyQ6K9VE +YwyhshDqYpQnKoVQROHlQrK45KXn7dhsuXm+NHZEq9UQrLqZaT3eC0Y1nM4Am8YCN1fe0Iwx8DJW +LCKoUW5sljun4vl51emyWgVh4hibiWcX0qU1QA7AoYtqVVJqyfRUtjhnJ8b9YYlhY068jdE6z3uK +XtXtbq4KrOU0cEYkl4OilqR1eLUejPCilonlZ6tju5NLNzqzlwOQCPW34ufbk6cJPgusU78wOF8p +t7Zq3c1qZ5vlsgyTlTXgv9whHwmiwEvNLG/eBhrD8ibgfnFCcniUBj6aZOI+Pwl4w3BbufxkrTa/ +fepKKjMOwY5mTRvOvGb1BK0BLAPgN8ud6E2fnV+5BONuBI3bqfVc+6KX39Kccd2bIrh+wf+l1avF +ygIwyxDiEUw+Xzm1sPH02NS5ch2kzplKdeGtt77Y7R1E8IybW03Xd1PVrXxrF0w4isemxre/9sc/ +ufXsu0CsAu8p6uNeei1f30sWVgxnTNNrW5vX9w8fU3weECnK5FiprtsTvNLG6RKCJWOxzvjMHsll +YCIbxTOBsOkPKJyQy1eWppaOUMJm2YwkV2xvojd7YXLmLMnkRgPy8AijKtWZ2Qs0kz15khge5jih +Vh87n85v8HILRjOO3XntjQ/2D26dOBEBviAYTeJUOZ5YTCYXdL3N0nEwfIrPwJgNI4Zq1ik2zyot +lCkCmZ3IbnjJFTc1B+YcKE8rPi70C/JXMDqDUhlarCSyS73Fa5o7NjxKgevh5Col5BOFBTAKkG1R +wuuXeiutcnIB0JTpTcQKK4XWQWfuxubZR9XxfYSMcVK2D6egGI1awFlQbBEls0B2AojChGk7FeCz +ApAKVCiYkGBEBx+hu9OiMU7yeYZPrW1dkbQSxaZAnAJTABDOsOlsfmlu81ak32IvISlVhs0B8RbP +TtnJXgQxnxR2LsOYFQjyrJhzvGajtWw6jaFhZmCY9Yc0lEobdhfHTZrSVaOULs1OzJ3tzh8mCrMQ +rAGVoujtJ9UhaBAXQCp3py/Obz6U7Nkg5A2PCK475iQmwogOIAq8fCBk4FRRc2aMxDyImiist8ZP +A4kI9+8Gx6KIAxg4m18p1/cyhVPhqBdB4m56CYiuJ3cV9AisQ+F+FbjtvXvN3g5BOarRzFU2amN7 +Tmo2iseBVgR6rNnazuXno4gh6VUjPgsicXz+aqKwEYy4o6OibTVb46dwKk5SOUFtKtYEzdfc+HSt +veclplDUmp896LRWaMqBIjJCuLrb7c5fmFy6hhFpKGIGQyqBJXA07vdLEKT7g+A1/Y5XmlFJxJsk +4fl8vKx3ErntMGT4fczIEB4JSSzp0HyZ4koomQEU7STGFb2VLm7x/UY2Y9WxQ2DHVHs8CCkQpDBs +CqyIZnc4pSEbvRLQDJMX6r2zvFYb9lEsn0fJOEzGOaOO0skwyLNsNp6eyVTWKS4lqcVya8dOzRjx +CTPZixWmQSID0OKVMnAxgZDCcGVgUaX+SY0qjCeB4AFoL1eXgTmN4B7BFSA4BgShpAKj2gJDI7k8 +uMLOzFEYNlkuXWufypY3gcxQjU4sOZsprwKHzos5SS4BYocRV1AbkgWYMB3FLIyyMdK2rIZp1/1B +cjRAjPjpwSEqgiSA5zITsxSdZAljsrMyOX06guog9CixiHN5TipLSoPli4GgIMnZWGpct+tOrC2b +rQiWGQ0AV+7ki2uGNzYaZGBERVEvENQougCmC+03XhQZJrlx6gaCOSdPwsGgHEVdRW92py53pq7K +5syJQcYXkMFy+PzckxI0EoLaLJNWlbqXmJX0piBm46kuxTgIroEwQcm0pDad2KRmdYGdjETVdHY6 +W14FqynobVpu+II6jMQFoQZeBsMWz2ZqY6fKY6dRIg20EEakgK0LB6XFuYN2c5FlHFFOe4lOrrLQ +nj4ACm00oAwMkr5RkSYyLJU5cRwbGeFpvgi4tNza1cw2BGnDwwyCerHUnGZ2jp+IDA70KwSCC1bV +mmZNZCsHZmLDiC/QfApGVYaP02wShCSrVEkOsEc2hCTAeMGUhsNCLDUdz6x4iWUgb0AGjOCxYNQG +jhUnnCiig+xWbO5Vxs5q9qQgNwx3nJUKnJguVZar7R2YsKO4FSVs4BbX9+4fXH55bOEKcOvhiApM +KOC0KB4bDUjhaAxwl+lMbJy63e5tm16nM3VA0NkgpAPAAB3CCBXNBpe9U5+6ipFplokVSzOW0yBo +IN4Aqk2aLylaVzM6JJ0cHCZIkKzFighcntECWX40LMGoncsvgVQyMBAeGAj6/DQw4BE0AVOZCB4H +y0pglme3ZKUw4md5pSmbE8As2Mn5KOaO+kUArUplPp7uQFEBJM0AZKBE1o4BUTcFlnXEzw/7aNNq +UHRqcIj2B1UYz7JiO5XdKFVPp3LLIH1gmFuurhh2o18JPCQFwxrO5EWtS3AlnMkGAkynvZUvzENR +HRiuCOwADIz4OJbL2U7H1y/ACKP9WkApHAyZjIdheyTQb/TjxSe8+OT/z957d7eRbXtiH8CPtyUm +ZKCQYxUqBwAECIKZYBApSlRqioJIiS0GNUWqu+/1u/fNC37vrQmeZXvWzHi8vPyPvfyXv4o/kr33 +PgUGFLoF6HaTALvQaok8qLT32eG3wzkV4fTHLz5/+Ol/qa+8A0Zl8wsgpR5PJpMyLKsJMh8Oq+ns +nCA9qkzvCuIirokLC4VC9fmr05mZzXzOFOS5SHwqX1ytTH8rFFfTqZlJ3D8kP9N4sbJ+ANY4EBA9 +nvzYWDoRr5WmXprl59GoGQzwoMv5wmwiVvL7BFBtSVvJIzIpg1vP5GYB+UdjpVisLIGmm9uyiYg0 +I2ykAH3FdDBBidQUwLZ0up7nV9QSBLDfKdbTSEL1h7KJNMQsS0VxFt8cJ69DhFia/haCwfWdH/PS +WiAs8cVZMGWLa+9fv/tz68Pf1RZ2s+LiytaH7b2fzJlXk4FCNjdfrR+IyoZmPRX1NUlbLlceb+6c +R+Mlf0AwKjszK98vrH+U9O1ccTWebkQTpSy+p6kRj8vJhCUqm5Xpve0Xf1zbOoPQAFTb4yvkCksQ +fOWEhebj0/Vn/z24J1nfAuMWS9QCQTkaNyMxLRSWramXK9sXy9vfrz79sbZ0HMvMQ2gDvnJj+8yc +egYmQtC28uKarD+hd5qA4lsz9ccXP/1b+NkTkFK5hSy/DHFQubY3NXMoqlsAVxLJaVXbLgirheKq +Zj2HAyZ9+dFRfGnXUvMgX5yNgrJErXi8UhSX07lGGIQkIEajyrOXJ42F5+GoohiPGsvflae/VbQn +2XzT4yuOjsYmJlNFYW58PJ7JVquNV+tPP//4z//3y/f/g1F5AnYjHhFW1w+sCoB58F+42QhQF+G0 +AiCZ5JTHm8UNeXC/cd3jLY6OJb1+Ab7NZKbEYi2blkRxShAb4PgCQdzT+8GD8DffBHzeQiaF78MK +hQv+QCaVmQoEtXCoBMGIKEPkODU5kc2mS9mM5fMmJscSnolcNg8+FNerJhIVUd4yy7t5cSMSr4Q5 +My8sp3INLlEBk1WUH1XrremFQ6W8HYioY+NpjjMTKYiX6+kC7uRTrr8sqqvpXCUcSkWCyWRSEeUF +iCuXsEbzD49e/jGaboDfTKUVTalrGlhywGaLEHSvb58f/fSfmi/Oc9o6gAdZbRal2VhcK4jNlUff +f/rpv3384X9b3/k3uFFYRDatR5K+mcrOgOwJ8mZBejy3fFqa2o0npyJhXlXBWG3w4jz8iSVrk95i +IKzy6sbSxvdW9WVBnF9aPyjXn3OJMli2eKquGE8byydTs/vAKEWZ3Xv/9xvPPyfyM1mpKZhPs9I6 +r6xtPvu0sLKfydVKpY2lRx+K6pZqvixqT3PFZVlbnV/c23pymsWVfTO1xl59vjU18xK4kcg0AAlP +enKZ9IwirQSDOYjXYmAVUzNm5UUuvywrm3yxGQjpleoLUWr6/cVorJzOL6rll9X5d7PLHzL5GbCl +8GDr26cCIE/c+XDRFzSBonBETSYr+Vx1ciIuFmenqpuqvlypPYfgF19I4cvIxYauNgFMRiI6mG5B +XM3l52NxCAEs8PuTk2lFXc0XliYnC6BcAD8yeXzvWDxZ9fuzXg9nmsvV6WeBkPo3uNdfNhgEi1eI +hI0QSJqPn5hMzM4/f/L8DNz9g4cJOACwVjrVSCWqoUARLv7wYTgYEMMhPZmpjY/HqGwqg/NN5ZYz +fBMgeppvivpTiPt8oWKhuFyqPFvbONvY+bM2/TIQNbxBNZWZD0Vwc9d0trK48n7/439c2/mzoK77 +/Ml0XMiktWwOZHJaNtaN2gupBJ5xMy8sZHNmJi2lkmI2XxHVFVFt1hrfQsCo1p4Xy08lc1s1N9JZ +sJkaBMvV2Rd7+395/e6f9ForHLEy6al8YSYa1wEDl6ZeqcaOrD+rNA6KynaYg/hXVGV8n5fXl+Ci +ckFYiURK6UzDqD43Krjnc4GfXljZzeSnIRYGrSnKG4vr3zdWP4rGE5h3SWrMLb+RjdUgp4jG9vqz +H169+ycwXytbZ7y4BDHO0gLEsLvBiFEoPppvftx79/ffff9vn7X+MjX7OsqpU+X1vbd/mlvYDXMy +vpYuKMWTNUXbKOTmMsmy35eyrLW1zZOCuJLOgbkAvhm5wkoyPQ9UwJwCaFlcPFhePw== + + + FrUtiO+SmYYP30DB5/Ozy6sHiTRwch7krag/SWTRUAPIx93yJ1P5bJnPl3O50szsK8XcSqRrYAPz +BfCAyth4MhTWuajpBeOZqBSLzUxuMUG7ESpKMxaven0gz3ApHaQoxFlw03SunivUKtWd8tQLYOnI +NyGfXwbOT0wWvD45FC2FYxA1zEOgZJib4FXDQTUer0bCJvztxdd5ZNELxEqK9ojjLG9Y+2Y06vGk +QUhyhQaY8frcwbuT//ju43958vpf9MpLf1DM5OsSQCZxkVc2C9oT0XheX/x+bfsv+L6hqKTqC4qx +Upp+mRYfTUYqE17ZVLeay4fV+otoXElnrUxhVtK2NsHLzL4ORgreQAL8pqQDIMdXFIFIF4uzi2sH +q88uBPNxIjcbiZWBTMBLsaRumitm5bE5/Rp4Dj4xEIRZ47M5NDjp3Hw4omRyjVKtVa6/56Un6ey0 +x5sYHQtyMZUvrvn8uNttNjcLU4zvKzHXdb2ZTE9xUR2EHGYnU5jn5UeVmf3Z5ZOi+gxNTYgHa7/X ++guIWV6cjWemQ7FqJF7N5OdqDYD3NYh8G7iD3/ermweLzbeCuhqKlwBLGMaj2cZLRV32eDMA1QC5 +xZONTGEBANLoWGpiMqNrzaWVNxFOxj0NIiovNrd2fth+/mcAPB4vn8nU3r7/CxhAMKep7Fw2v2yU +n5tTz2XMUJW83pxmblQbL6Kp0uhkJhA24uk5QIC8sJpKmLmUqUqzz16dqdZWIGKOTuQTmdlwrMol +6lZ1F0HRREJXludmW7Q9jvDwYWxsLMHFKqnMDBezJiYyoFlm5cnM4rvG0occv5BM1UHYwMWDmc3k +VvwBLZedUyuvphYPJGML+4jCqs/LgyAVMvPT1aceTwLL1g9iqcRMKlWLQNAXVQGJgeMIYnOLATY/ +z9frc7srG+9XNg9XHx+X6s/A+6fS9SJbic/PzC0fPt39x/Wnf5pb+x4QC+AE3NBDqMZSpqhuGlMA +7F+p1sHi8qfV9TOj9CQYEeAAQYbgsZLA0KwRS5Zlbe3Vm3989/E/gU/x4rsahYIwnYJYVVxRKi8S +uYWZxePlzc9ZfgVC9WZzt1LdCsfMIIS9YQNi82x2cWH5ZK55ls4tAhKIcFKBXwLDhTFaWI1ETQC9 +1ZndJ7t/4WLVRLxS4BcA6qdycxBDAX7I5OYKPG4A6PVnQLkg3FjdPN49/Kd0YWXck/f6C5nclGE+ +Ahmgfox1ENrd9//uResfc/hunQwgybnF3bnFbwH6lqZeKNbL0sx7QJup7AIo7PhEEt+fIjc9nuzE +RDoSLcVSDdl4UW0cs0YjrzcdiRQFoQ6IJRqTYwkLAHwhv1woNEEFsFMlahYgHI5ZsXgJ9AskxBfU +M5lKubrJi7MArvh8Y2rqxfTsW3Dx0ViFi8jJmCoW65JUi8dFvjANEl6rP5+efcNL6/H07OhYxudN +p+JqOmmBAYnGzGRqWlY2FP1xLF4B//jgAVfI1+cXXmUypfGJFPg4X9DISo/LC58WNr9X9bVQIFst +ra6sv4NoceQPkfHJvCegxjNLgvbSLO0G/YD9IpI4//TpxejD2B++CU5M5FPZRb3ynIsaoMXxpJXO +1iR1WdWWIAIVxGoCX40hxeOmaT6uznwraavp7JSkrljVrSxfB9qBk/EEqjMvryRzVUFqatZOUX1S +1J4B2gTkAPIAWiZqG+bUt2CCAC2bU095EV9WW6k/LyhrnpDi8QvJVNUsPy5Ky5Wpl/NrZ1kRfPES +l6r5QmCBzVRhLpGd8fjBKa8VlSeAChLJGWAOhF0ApUC2QWIBXfh82XBUDXOGrGzzxUeCtJ7IzPkD +SjpT5+IVT0BOZBfA0Uv6DkRwIGP4lhlPHEQol58Gw5vMVDPCWk5cL2rbVn3XGyyO4jsQBQhqogmI +9Gu8tAaizhcXF5vvqzOvi0ozmTAhHAMAD3GZP6RPePlQWAPzKCpPIN6fmEj6vBlfgA9FjGyhKevP +PT45GFajcSuJ+YRpvy8dDhUgLAKUWCiuQEAE4BZMSjQ+BREHhA+ASxPpWUndnl36CPwH7EGv8Srs +PD6emd6OReVgoAjmMR7TE/TH54ll4vxm88X/+l//T7E47fMLPr8YCJsFEUSoGuVwG4pAIK0Zazw/ +6/cL8LReLwCzIoCoTAZfiu33ZSDES6XncsJqrrgeS85PTmZw/zRfRihUc/n6Nw+jHq+gWc8ka6cy +sydqTyc80h++iQJmy+cwQ+L381ZpS9GfgtUNhjDsAm3KZCu8MGeVt7MQ0qbAdaps54RE3BClZc3Y +Kk09BWsjiPOCPBNNqD58fV4+k2ng62PExUx+ChBXAV/Ru1TUtmLxGu7DU2zq5WebL//05PU/mLVd +mPq80IBJ5EDk4mY4Wo4k6tnCim49LdV2JKVpmFuy/jgYNRLZWQ5MMd80qi3JegE+C5BJJjef47Gp +D3sgAwqENhFuSsLWr5mx0Yh3MlHgATlLmexSND7j8cETavHkNAhkOFaDUwrSZoZfy4uP/BH9wXjy +4UTCFyjkcjOxqJqMq6CbRe2xYu3k5UfRdN0bFIIRJQ5QuTAH/gsEWDWeVmYOytXdnZd/rtReAt4r +5mughmD68C2r4Fyyi1bl1aPtHwX5SShsTU5mQyEpEBQnqS05xzfT+SXF2FEM+FYeH08GAkIiVY6n +Kt5AMRIvQ6gLAaaoPDbLLyEUHZvEPeTjiVoqMy2pECzvePCVpsVCuj499SSbtmC6A7487t7sL3gm +M57JfDgoaOJMo7q1vPjM58WNsPD9GskqhMzArokJsE6BSEQqVV/CbE6MJ1PJKlgGCGBT6elw2Bgd +jT58EEgnzVx+MRjWfT4xAHAiIAUgeMR3uukgiuPj2Vy2sbj8FgxRIFiEX8fGC1x0Kp2Zh7kYH8/V +qpv//O//j0rl8YMHsYcPC4l0nYtqwVABd6FJ4GqIZKIEUu0PQMxoplLlZKqU56clZZEvzqczVQ1f +WPkcIBmmXHAHDyOWMMOcGAoX43E9mcZegjCnJ1NlWV2vzu41llrVuVe8vJTMAP+nAiHR5+chHE6n +ZxKpuUwB4PQ6iEciPYXvLAtjFrGxdGrW3htT7xRrL1OAE6vxuJXKVMGJww+lyhvV3BXETfgDsXwg +LI2PxbmQJAoAjyVR2lS1l5ncKtg31dxR9OchrlTI10CnuFiZi9fSBRC2RiKzoJvPdGMnBNKY0J8+ +/S7HNwB+ZPj1VAHfXK+a64XifCQKUV5aKC6apZ0ovv0chGHaH4Q4KAl+LZHU/YFcMmWCs0ukgJwZ +kOHxSd7jlRLJhqY/Bb0DlOX3i7H4FLAlkW7EEuDg+AkPn8zMVxv7peqLVLpyev6vr1p/m8wuxBL1 +ZG4+GC1N+jG2TaRqfrR7RdC4TL4JSCAaVj2T2QcPudHRVD43B7YIRAhb1FOzurKlKRvpdH0Sd+pL ++vCNe/z4eGRyPAFWJZqEx2uAbckVFgNBbXQ0sbLyFvQU3CWEeOMT+aBfTCcsVV6AK/zhm8g3D6KR +iAFWcXKiMDaamoQDgkY+tySJK+C1x8bjHk8G0BSgMsC60Wg5EFDDYaVa2Vhb249GSxMTxWzhEQZ6 +nBUI6+FY2c/po57MOHAjUMznFszyE0HC4Aggkx/fBZNNpQxwXtXGe7PyJpWdz2Rnk+lpr7/4cCw2 +NpEOhrRYYgrCZOBGNC7jzkKpSjo/n8xAeDubLcz6IwpcHAKfeKzEcaDUuXjCyOIbsReN0ja+niYz +DY9qVJ7LxmMASLj/ubikmpulqZfJXGMSX8IlQNCEuyTFLVClVBICn7ky1tE2QMi93jwQmIYoKQ6O +spLJzmSzs+ATdX0jk63j+8iCWnX2ULW+FaRNzdhOphvgnoRcbWpqyx8UoomyUX6pWi/gXkBFMKKO +eZIARJPp2USiCnYGwIM/YPqDFqiqxyuOT6QDQb5UeZTK1kbHE16fWBA3FRPAwzPNeg7h2CRtzxiJ +WnDrCV8OIHFBWNOmni+sYTIEcCyos6Et/ulv/+dnL08h7ouB7SosJ3ML0WS1CADD2AqF1HS6ZE1t +T3oKk54c6A4AoVhqXtRe6uW98fFUIV17tPpdlNNAkHxBABiKL2Ra02/Wty9EeXlsNJyM6jFOB3UG +tgP2BnD1cCwb5mqy8RzM4Ph4JhK2gDrgKrAilbSwp5Qz9dJObXbf4yn4fRL8iUaAzxsgzOGQBnDL +4+MhpgMc9c03YY+H56Ilnl8C75bNNkIot4AzhWxuMRyFCG41kVmEP/HMvC+s+QIipqOzs4CLoomp +bG5JViFAnoH4Ip6wID4timv12XdG+VUkNh0MV/zBcoSrTXpFX0ABOMEBnEhP5/kFbNhOT8H1AV1j +A2qyYlVf5YtNALdhuIsPBDgZj0vodhNGrjgrm49ml95V6m8SWFwzwULmslPT9aeLK/ul+utYug7j +RXEpnaoAOgJQyudq6ZSRy+r4ypi4BqAUi02pCscpXk8WPLumrvGF2VSqkivMxVL1SLwGXjiersFD +BsNSNjcNzynrjwAuZvMLIADZfENS1yJxCBl0wMDlekurPAdpSWWX6RWQYEamAGGCBoFJzAuP4Gqx +1JSgrHqD0h/+4AcDqBtPsvk5CAAnvWAN0mB2ltdPVjY+gtCGOaVUeQZPCJYwmZny+AoAKqzKk9Wt +k6dv/g6CZaBuZu49oMQQZ/hDCsgJGLfxiVw6XZW1ZR/FlaR982B+I1FAd4WJiRQHkp+cmhiPA7oL +RIxoEiDHsmI+SdI7tSGsyEHEHdbAwuQLgJbXEok5AAwg4dksJp0mJ9KhgPpwlAuAShYWStOvzdre +3od///nf/F/V+tsHDxJgzeDP+FgagBnYN68XwFij3mg1Fg9y2FBdWFs/FqW1UMiY9EmTQSOSmFLN +R8+//fFf/6f/B3c4jFbCHIDVed36NldoghCCsoAgxRIVoCKXA/i6CboQDAPz53L8XBpfpzIP4Z43 +oCXSi7z4VBCfeP0qNl0ElTCnAi4SxHWwOWArMoW5cNQMcZhAq9Rf5UW4PkwQOFM9mQR9gR+kWEzJ +CTOSsb62faGYYKDms/x8ImFlknohV8rmwJFh7aYy/cqwnkY4IxyWCvlGLlsNhnITEwFAp8FQESZl +dukQTEEgJIG6ZXAxTjUYyAMaSSTKgrRmVl8rpWdgHLx+HiYaRCvEyalcPZqsIc7RweBsSdoGHIDd +F+JSub6rl5+D5wKlAyiV59chdguFwNFkeWFlqn6Qzs8lMrWcuDLhl755GAkHxUKh4ffnvJ6kZzIB +980XFmqNlm49odcx69WZpwUBkKqWAbuUmAFfD4Bh+9ufXh78fakGUje/+fh70B0Q8qL6KJ1fBHVO +JOoQzgdDAsTC+cKsUFwGFAdyAiguwpmxxHQ8WQMU9OBBcHw8AY5jwlPw+IRwVEf1iegQCJiVl/F4 +BeC6JD1OpuajOLmKz5cffRgYHQ0H/VI8WgPzG09PVxpvn+3/y/L2D7PND4AtvV75mw== + + + b8At4tIACP1CQTmXn1X1xzOzBxBggveHiANQ2eOnF5q+5fVJQa5cMF42n/7w6S//+S///F+OTv/B +H1a4qAVwDuKaXGEJjAwIFb1dtJkTlhIZ8HfShFf04MvjKhAOg3LBM0P4Fk1WwHJylLcPoCusgEym +0nWARiFOjcZK4LM0fMXG21S24Q+pyXTNFxT8IXCU9WRqMZVZAt2PJWciHAhYJYMVbQMsWzw9V194 +X196B5pOdCmA4kIRCexMmNOCYTBQjYKwUeCbYD0gjpucjKeSpRi+8RY42chAXFB6VW0cJZM1Lzj3 +sVgc/abFxdREZiqZb2SElYK4kS0sBSOS15fG90Zpj+aaH6aXD1P5RS5RxURHRE6kS/EUdrVBOAlx +xMzSx8bSRy5eHhuPeTy5WLzMxTR/oADIIRKrZgUQyFoyBbOsPHwY9kwmg7hgIY0L2TJgRhpwYpZv +FOUFLq7l+Hplel81XynmNi/NQwQUTZXBVArFhdLUk0CoGI5osv6El5tg9MIhwzNZGJ9I+P35VLIM +UeHDbwLg9Av8Qja3EAiXxj2A3PKI6IIAS+IPR2MAdBPJSioNsGolnV2IJyr0VlYwO8WxsbjPWwgG +FZ8fNzmE4CiZaBSLWzA7+eKyIK+lsuCGlIfj6dFxgYs1coVZTQe/vDI5CWw08vlGNF4Clzo2WYin +q7niYl5oKtpjsD9gvgDLKfozRXuE+9InTJ83F+Qq8eRsMjXrQREqwB9/UOaFJYh3wDbyOuaLvH7A +SPnxSYBbajq3kpceZ4W1dH4ZJiIIYI+zQCBDEd3rF+EP+LtUBvf45aJqMMRHosUIKRGuF0tVQRQh +HodQDpDt7Px3Lw7+w8L2jwBfAQCD5MTicO5UIlPOFRdqix+06l5eXoulp8HM+gBm+ARgCDg+AMOx +2Eye3xakl4rxMppA4z82EU2la7X629LUXr64EYyUuMQ0RMGWsZnP1wHjQVg63Xg9NfuOS8z4Q3ok +VgaYXa6+kpQVAH7wLV9cfrR98WLv77LFxQCn+CNivghh6Qr4JqAukaprpV2zus9Lj0Fbx8ajXl8G +0BcYGdARuB1wMlNYi6fnAezx+RmwM/F4STPWm5vvq/OtZG41zFUnvTyEddlcnV6czYfCfFFszi4f +za+ezDePI/EpEAOfjwerC+IEhsgzyQcCeqG4wMV0Lzi4sThu+RgvRXGbvsj4eHrSU8wXlmvzLX9E +G5tITXjSYLTDEYiV8nA8pq0eJkKk+KDs4F6DmD+fyuRmKR7RPD4pELKiibpeeg6Ujo6lIGwsT+2W +qq0ivvZCBnw7Ppnw4Hs6KgFv4cGDiN8vl6vPn7d+qC28iKZnQ1w5GNZCYVNSHuFbfaNWXlyvzb1f +XvshHIXgpRFLzkcT0+jfvfkJD/CkXKvtNh9dbDz7u9rCiccvj03k8MFCegjMWrwcTc3ki49l45li +Ps0WFsE2IjCYzPsCEDNWheI2QDXaXR/R46Q3R6/UkcDiQWQdS83EkqDjU5LUNEv4sntwtaK8Xa6+ +LoqrEJCGuWI2P62WthKF+WRhQZt69ejlP5i1FlblJtP4cu2wyOcXVW0HQolccS1fXM8VloXiSpTD +Pca9voLHy4MFNso7grxKBfd6ND7NC00IEwIRMxSdyuZXGksn9YXvQAjB4OCGw2mAarO6uTo9/zov +r1bn95c2v1/avMjya6DUMDVW6Vlt9iCRWQ5H6+nsXDoLVJTDUXytT4SD2V9tLB/vtP5FMJ76gwgn +ojHAA3OZfC1TqGjljYL8OJ7ExAioFSjXxCTEcZgfwC3Q5YWisiZIjwACZbILmfScxyOMjSf9/mIk +bOLfnAaKCcY/LyynMwv+gALW6cE3/ly6lkCHqIOCA9Ko1L9tzO+DQfP5U6FwwTBXDfPxNw8iYPy5 +mOUNqZEYhKjTmNodpz0w07N88ZEob8F901nwAmWvVykU1iHK9kFoNhqFI4FXoWgN3J/Pr01M5EdH +Y9GQks1UsKiRmMoUN+bWL7Ze/LkMRgA8eLwE8H5x/YNqboHTnwRTEClnCxuC8hiMjzdQBEmIxUql +0lattlObeQ28nfDIXr8Gtgtsy9hkyhcSuWRN1J5Z069F83EyvxAHesMWwXiNQoxyIgUGuRlNzIUi +5XEPvucIjFI6N6OWniqlF1r5ZTY/H0+UASeEOZyFHA/AeBXMERjhXH4mlakEIiKYXNDHjWefX3z3 +73h1C6R3bDzlxQxeLZ2uBDGPUQBfI2lPwRQLxbWJCQi0kxCSB0NSPGlk8vUQp4FNK2IeFYLEhUBQ +AbOZyi2lc4tFeZ1L1CDaygmP8sIKRA3pLAD+mmpt1Rb2dl7/+cnrvzWnX4djdX/IAOwqCCuUiZrL +FzetyktR24ympyHmnUTbpUnyigZQTd+MZuYiielUdkFW4aarkThESdPzq60sv+wPqD6/6g2oycwi +BKdoqMPqxESMi8pm6ZFmPC4q4Fxq/gAEdGokYonSuiRt+DCgtiRlsyCuxzONUKg0Nl4YG8+GQ0o+ +PRMMiPi6H4jpyju1xmtFfwzg2RfkJbk503gtFpdGRrwAREV1TZ/6VlCep3PzgYD88GHM6xNUbTuX +XwiF5GBQAySZB5ML/lF4VOBXwdx5JnMcZwLqmACL4ZcjCVDPeiSsx8JaFGKHVK0grlnTe9OL71V9 +I51uJNCVGIa1sbz6NhQUwaJCMBKKlhO5BV/YmPAK/rAeCBvpVJ2LKtG4Ap46nWnGEyvhcM0XMLwB +edyTjianYtStF4zp8eysNf129dk/lRc+ANQBuQLXA1qpqE9m5k545RnVX0ywZqA4YNXpFfMLWWEd +phuwHFrmRMXnF7x+AcQyka6bFVx8HQipoN1zS/szSy8Lcj2eqYLRVoxX4IxicT2dLvsCBa8/VyjU +4Vxw9B5MLEuYzeZMy9qOZ0p5fmp1+1g0IOCyYslpXGnu4X0BiZdW0nlAKVowogGAz0vrsrGD0CsM +eiEB1QWhISr1glCLJsvg9Fce/aSVXsOk06uO+JywGE9PBTk1FNWV0tb2yx/Wn3xS9dVspgxohBeW +64vv4hlUKH/QhDAnJ6w2lt7rJbADvB8AdtgE4czwa4ncoi8EDAeklE6lpxS1CeFPOrcMVjEvbDYf +/SgpjwEAx2KVSQ+grOlsdiEag3C7FI6Uk6nlZLpZ4NcDAeXBw4jHm0tnGh5fEcIoLlGfmn9jNt5P +Nb5LZxcfjiYePowD5yH4SmZmAlwJrgBqJSpPeHAQyWkICkbHE1xsCrxqMjUTCGoF6XFOAiMzBW40 +HFTBZno9BULj9clJfmI85/MDnsG6PwCJeLIUDMmjY3GIHzOZhXxhEcsfUbC0Usl6wgHMC/A+TvOG +tCBXAi1OpJYUdScYUpKpagYkIV33+JTRcd7rBZdaFpVNpfQ0lq6G4wYuH8gv1eferz/7o17bBbyB +fSwRHWctakQBVnFTmcLjfPFZll9PZgBgqJSDran6s0c7YBN2AVQDDJsEgBcCHA4hOciYCEjeKL+d +nj0R9Y0wtoHlwxE5lqwmsjNBTpv0pgNhVZA3s/xSPFl+MBrFjiMvvkMNPD64hiCQxpmg4KK+Hc/N +jk5kI1wZ9M7rU6KxCgSA4ODi6Vm9vAuh+pgnB0ZYUjcV4wXgDVFp8sVGJCoLhbqur2Negl+c9Muj +E4VJnwimJpWd8YeFSX9eMdZXt77bef0j9W8XJjwARCWBXypVnkWiJkQ0srKlm88167kgb4D8fPON +1+/nUxkIYNUAZ+bEbWPqsL74KSc0sW4VlEbHYoFgEaYsgShIHAMsPZYAM1sQmnl+MRCSwcKXp55D +fPdwLDPhlf3h0sOJPEwNIFtR2ihid8oOBMhBTvdHpsZ92phHiSUWq413VuUJxBfhsAx+6tHTz7vv +/rVc+xZisdHxzOh4LhyxwLpisOYR0rmFd5/+29L2H5P5pbGJwvhYNpOdr0y9BpT7N//d5B++iURj +tfVv/2Xj+Z+K0io8J3gc4EM6Nw2C7fHJABViqbXS9NGHz/+7or/K8Mu+CDyMCbYlGIVQBXDXYiKz +AtohKavZQtUfzMKMe7xKJFQt5Dfmlj5kxCVPUND0te0XP4XjU7HUdDRT9QKG4WoA20BPk5lpfCs0 +pwOmrTW+n136QbVeANwFCMRFtALEsOqaIMNF9FEPIOSaIDwrlb8rFLfHJwB8FoHAcv1ALb3mUrXJ +oDhJPSHI7Yn42HgiEtEV/YVZbcGTewPC6HgSA+2QChAUcGmqsGzW3mw+/8eFRz8UlMdeuMVYNhGv +TU4Ko6NYPQGWhqMVUX26+/5/nGt+74coKTdjVV8a5deF4jqEhxO+woRPSGdmJXwRswLhA2bDknWj +9MIow4xMYx6GQzuQSFe5hBWKwq8lLj4djVcTySkMhTz5YBjiqXkA+YGQAr96vPlIRMtkGvnCHDYe +5xqCsl2qH+jll+AlxzAlDui9CMg/GMStkACuj48lI5wpCBCqr0H0N+EB+CSp2jqA87GxdCbbbD79 +k2Q+y+bWksk54IlcnK9Pb0YihQcPQ9HkfJZ/opUPZhcvcsLapC//8GFUU1ef7f6YykEokf/Dw+i4 +RygUHwFaBlsBQTrAKhnXVW3x4sqENwf6GIrWk+nF2YWTR0//HOZK3/wBs6MQyyRyswBLHjyIQwgA +YpPMAvd2IEDzAryvt4CrC2ufJOP5uEf9/+7J5/VdP8Cv9XEJGbSPS8igfVxCBu3jEjJoH5eQQfu4 +hAzaxyVk0D4uIYP2cQkZtI9LyKB9XEIG7eMSMmgfl5BB+7iEDNrHJWTQPi4hg/ZxCRm0j0vIoH1c +Qgbt4xIyaB+XkEH7uIQM2sclZNA+LiGD9nEJGbSPS8igfVxCBu3jEjJoH5eQQfu4hAzaxyVk0D4u +IYP2cQkZtI9LyKB9XEIG7eMSMmgfl5BB+7iEDNrHJWTQPi4hg/ZxCRm0j0vIoH1cQgbt4xIyaB+X +kEH7uIQM2sclZNA+LiGD9nEJGbSPS8igfVxCBu3z+v+9J5817p58/iaZnDt5O7t3vjeysziSrC9p +u/D75t6n8/2zkbWR5G6xfnY+e9g6Pzw92Tv7iSvBkCjIKlfc3N874jLsSA4O4tbPDt8dnsDgVmvv +aD/LFeDQMvw/InISJ9J/Oz+N8Kao6IIiq5JpyvCPzJmiIQuaJiqaImqirHDHeJBqCIop67KpqqKp +Ow86woNwTLUs0zRUXVe59lmWJRmWaBjsIMftejrIcbv3I09HTkYejVhcJsvtPB3ZvvYT8M1Evs2c +XXx6v7F3Diw5uWTm7trpycbZ4cn54ck7nmfDM/vAqutfjKx9xG8kkX219WRh/vAI56B4+SPwvriz +2lw7fbuPP96YlJ/9osxlfjw+OoGveHiss8M3F+f7n3BuYF7P9jqOaL0/PHp7tn+C38tccenk/Oo7 +/Ov8p480r5n60m796OP7vV0pyxW3Tw5b8OUWXP3k3c0TPu8dXbAzDt/Ckd0OOdk7pg== + + + I+Ax8JjCbZNy+ua7/db5zOnFyVt4tpnTH3ul6IAmBQ49//TLp1yj8MY5t06qmOyVti8w4RpFPw40 +HT/1TMdPd0CHJPZOyfv9w3fvz3smp334QNP0w+Hb8/c9k2QfXejhwQfFTJ5fnL25ONo/ae33yhJ2 +ao8cad/nlqmSeyXm5OJ4vXW+93m/dwN5/ZRbJwynq1fazvY/XRz1ro/tw2+dppPTrfPD89YX1OyK +rk909OPDoz4m7cY5t+8NBFHrlbo3e5/258/2v78AnezdN3Sc1YsF+hlCpF8gpDs8uoY39h/3aE6u +Hv0XJmOAdevw5Asm5jpmxGNvXeYOT3ql5fTj/tne+elZzwRdnXDrVG2dXpy19hfO9j6+P2z1Pll9 +zNUdKk/j9Pjj6afD8z5057d4DgoAen2E4uz+AVce8BBQdUNANwQcXDrcEHCQabr3IeDB2R7EM0dr +p4ef7lUQ2LPVd4NANwi8jSCw50y0GwO6MaAbA7oxoBsD/hox4Mz+5/2jrfd7b09/uAfFQF6+LwFS +P5QMeIik3sMQqQ+a7n2IxFwOJZN+M4czqNHRp/O3s/ufD/fwgfqA2tdPunXi3hxdfMF7/QoR0h0h +hIW9i0+fDvdOZr5I4yAC7H5mZtBV6PTg4NP++ZfnYfii8Z6Nw9veHfPbu/DMvRPSO1Z6++Mdav86 +ydzw6b0k9uxvPu63Lo72zuZ+/Hh6sn/Su7Y4T7x90NQvkY3Tk0/ne19B5NWJA+1cB92EIzvXL77A +/uGz30cYNGAvb+v06PSs9MP7LyYUruO9n456z+3bR986hT3303y6ODvYa+3bDd+9UnXjpGGKVCCo +hk+vzPljzxz5410kCLQ+SBnwXIfUz7T0me24IyiycXp4ct7sJ5vx2+Qq97dsn9i0rd7woaOvyi+4 +1Ye7qD70iRhcAHSnyZKvKKcMik3oW9AG3R7snR2evz/eP++9aDdMduF2qpK3Hkecb+wdfik8Hb74 +qGck9uELCaRrxOChA0zIF1IT1wmRBjlz8qF3M/fhLqxc74QovROi3BMXOjxxdP+5/WHpMFndP3u3 +j5wcPkjUrzu6x1Py2z2H23j0azUeNU5Pj2bO9vf/2HPudWC7jn5H6094LXlPco59dPC4/VW3TpPk +9lddMuPt4dFe7xWq4UsL3KvOsZ4JGZZsQO8z87b3mbkLLy0JPW98cbb39vCid5fcPvzuIPLp2cf3 +p0en73r2VIMTttxf63ZvbNq9W0/X+yom16a5Nu23lK9B1/yeE7ZDo/r9LXIaYN3nf7s+5DtS+WFt +3+1DpgZc3+/rbgc9N0QO224Hb3r3/8NioHumaNAN9O9h14aeJ8vdteHOai09p7kb7/dOTvaPtvaP +9lv9xNjOE29dEjd7rkp8LZHOEwfZNA58v9v9wUxvvtCqMoQuuGeKBt0F90zIp/5WwPS+9OU3cUez +h58+Hu219o/3T85X9z4On0/qQ8IGXPuP9+BSPRf8hyFWetNzXmFo7Fl/W5wOsD0TufZ/nONH6caP +vVJMP/Ueb7QPv8OGy6PTs9UelG4gzV7vgjjgZq/3tdzDuEFKz+miobGAPVPUtwUcnj4a7Qtm7lrC +vPfNY9ixd7D25GR/r+fua4CrrdXT3jtor51w65Sd7RO07ZW0vbdvD88PP/dO2tUJt98QcPTD3k89 +CyEYi/O9s76MCzv+9lFJzzS9wXej9Z79Y0ff/rLPnn3WNTls336Nnr9XYbx51uDWRc5Pew9bTgcZ +jxycnR733mtNB99BFa6ftviDw6OjfrrHj+6AopPTk94teqt1cXzx5aaw62p07ZQ7ikz2Tg6P+3jk +32iNypBvf3dfoqPWvWub6Z2iQU+h8KbbNjMY6t6HTA24vt/Xtpne9yUctr6Z1r3rm+mdokG30L+H +vhn3lZeD75/cxpn70jjTh20c+MaZ+4OaWveucaZ3igbdB/ccJLmNM4MqYQOu/fevcaZ17xpneqdo +0O3ZF7pl3MaZATd7buPMMDTOtO5d40zvFP0GjTPDUCIanvafPqayXxtyR1M5xJsV9tGQ5k7G8G5U +Mjxz8ds9x90+w33aMnKWtgra7S/Jcs+aWO/vdkn3co/43lOcv4PteVz71pN901375tq3IbFvPcuq +a99c+zZ3BgO/b/i2jyxwrduQWDcXvbnWrU/r9rsGb651Gybr5mI317r1bN2ul412+2sLuGdGrmfi +f5UK7lBVCV0l6kOJjN+zEvVMvKtErhLdVKKNwx/3jzaO9n7a7W9N4iC2pf2O3hymiZzWc3Mde9TN +Pvrrrp0xTHZQ6n3vjMHflObTR9yWpld63E1pBmJTGomTyrLISRr8LXLwfxl+hn/L8AX3mzfDujvw +uDvwdKGnR/s/7NvvnO0fn37JSrgbvfzsRi+3TNvhydv9g8OTL77s+7oB+bi/dz7bh+O+dsawbGQz +KFDqHr5M8naj5NtuAe7j9fHDslygH5p+pwsGhqNyM+irwL9kuYazzNaX+gy47W6dHn88/QRgYf3i +C4brVzBzd2QaGm0ah9Uu9IkWBt0q7J0dnr8/3j/v3dINk3X4Go0aJitx7zYN7Dnd++ELNdVrxOCh +A0zIF+bwOiHSHRDSs4h96N3UfbgLS9c7IV/o4btOiHJPXOnwlD++yvy5qxC/4jnc+vOvX3/ub8dF +t/7s1p8HzgDfq/qz+1KUIaw/k15iBVoWy33pqFtzdmvObs35K0yJW3N2a85uzdmtOXcnya05D1mW +1a05D5pVuE9lzLeHBwcXvb/VZFiUpk+yBn1725530/t0cXYAgeRWf7t23zhpcHP9TJr6o+3GObdO +2k/7R0enP/RK39Hhu/fn8D3fwr18eyax87TBnUBbKxunJxDUnvRuRhznDVUKzn0vsZuCu9MUHLNC +5Xdn+/snZQAv+2UIOw/fnZY/H54e7Z+Xz/bflk/P9k6+VEVyc3MO3+Lm5n4ls9K753MTdG6C7vZo +cxN0XZ54cEJxvedy0v4R/NJXLuvaGbcPqc2eCdv74+HxxfkX3qZ4XZ3ax99Z9mf2kGB8E43+HffO +zLLIomn7n+FTAKn31MDH/RZY0bO5Hz+Cve4j+nKeePvq0LM2tB+27xjTeeJgZ3oHPK/YZudtrI4Y +XJUbwmwcBIO3nq9ykzluMsdN5vQckGDqhiVz7MwO5XTcZE6nN3GTOW4yx03muMkcN5kzHLHs0ZcT +AsNTsnczU25m6q95lC07gB7e1NS9XIJ/Pzfm+IpsjZuAcrfnuL3+vIG3C/d7a457+X6Mo8Pzjb3D +L5UIhi8/fW+25eh9E4gB35aj9xkZ8G05eifkd7gtx+ADHNeN3q0b7dfjDIsHdXe2GlQX6u5sNWgu +1N3Z6q9i+aB4375Nn7ur1Vc8x90+w33a1Wrr/d7b0x/cVypt/zVbWg2PebqHGxf0vBubu3HBYKWp +3cX+g6JCpwcHn/bPcR7O9t/2ZRyGJXDr+eWtb3t+dzAdOsCEfMEBXifkxzu0Auske7+rGOHr1e0e +BwuDMjm3U9Iannlxg7ihCeLcfYmHaF9iXtKSvVLXuyv/ccAp6R1d3QW4khSxZ0re7/fTDHh5+O3T +pPZO0w+Hb/toy7SPdtMfdxq76W76w01/uOkPN/3xSxSa9yX90TshbvpjUJ2wm/4YYLvupj/c9MfQ +pT/O9/poDHSTH0NdwW79dp01t/3ikbO91vne0drpYe8LXtjJPVLVvtPAbsp0cnG8Diz43McuE9dP +uXXKWj1nWIclMOidokFfV31yunV+eN76QvrqejoEj358eNSH8N045/Z7doWeN5h6s/dpf/5s//uL +/ZNW7xFdx1nD5BXc7Zd6Jsrdfum3IO2+bkLUhyUZ9j17RKHndyCdn/YOwk4H21UcnJ0e9x410MF3 +YDfc3ZTc3ZSGfDel3yST9Pji7M3FEdjmoU01uvvADMEC1T7CxCFJBX/F6jQ3DfvLadgrW7T7hSWK +bjLWAULusBOt9/6gwe5D652OAe9CE+9hF1ofNN37LrTzHkHbcKX9e27NGLasP07Xfcv7/x6y5eLg +pcvdGNCNAYc1BuzHDLpRYF/PcU+jwJ7trxsFulGgGwW6UeDvKgq8r+1fPe9Q4MaBbhx4G3FgzwLp +hoFuGOiGgW4Y6IaBf30Y+PT09O27s73edcCNAe8+BuSl+xIF9kPJgMeB2j2MA/ug6d7HgffyHSo9 +Y253V4rBCAT72s+h36VAdwTr3B02BsUc3P8dNk572MdheBbTudul/hIh92K/kNvuIO7nnd/DovR9 +ETXoOn9wBCE7ezd76c3RXutDmWNDpx/3WofnP5X6yKR+Ov/pqPdChX30nenUPJI5fCr11+yj4+ZO +72QZRV/2wsV0d2zeP9G2uo3f1MgPT8Z7UMzefYqL+nzd8bAoTr9vcR5wZNRzH9uni7ODvdb+Vmuv +H/Rz46Tbz8X2J3z90XbjnFsn7Yf3faxBPsJcOHzP9+Ckr1HYedrgzp+tlI3Tk0/ne1961+j1cLfz +vGFKrtP03Js9jvSed9baP4Jf+sqpXzvj9mVY6dnE7v3x8Piij4LQ5fF3BrVmD0lvmv2U5n6j3QJm +mSo3bZs1fNiv963l2m/Bnvvx4+nJfh/mznni4Jr09rP2bdOdJw52wWnAYfxXvHJ9WKD8vca+dwMQ +hww9ueDJBU8ueDrY37KN/PCiJ7fLemgqBV+BKFyQdOev9BnirHq/KduBtwt7Z4fn74/3+3gxwDDZ +h3vZNHp0eL6xd/ilMHb4YqiegeeHLzRYXCMGDx3cxMSHLxx5nRBpoGekdzP34S6sXO+EfGFLvuuE +KK4LvTXM5rrRu3Sj/Xoc14O6HvSWCBlwD9o7FBhwD9o7Ib9DDzo8qWr3pZIDjIx+czc7PFPy2z3H +8InFPXwb+33d1On+vtOv121zhg803/+9ndwtfofAyvevYINu5I/34FI9bwMzDOZ9AU799OXOneGz +gRIn2v91++lypFey6aferWP78DuMBY9Oz1Z7ENdBNBz3EB7e621RbnUp4B0p1HBvKXIr6ZFbpmn9 +3i9D5XsGuYO+GwfvbscxIJbg67Vm8EuW97MjsG+IPuiGG+sUKICPb2Nb7XtQixmC6Rl0kZN6fy32 +MALw61PW85rXYVOp4Ubg99KK7xzsn80fnv32yaPhKUef773pfY6HIUMocz1XgIj2J/1lym6cc3cb +gV2ctDaHz6jcO2ETDE7kfh/ituCK292Lm/R7MW4zd9yoQvEQ7qrw+Gzv5NNB72+7GBzp/8qVN27S +5C6SJl+DTocBcTMhHBDM7WZObk4QdePVj44GYGoGhSVfJ7NuG+hXPMfdPsPXvMIqWV+SxN25k7eX +r7LCIQ1HdtdOTzbgErSBCs+GZ/bfHZ5c/2Jk7SNdQ2Vfbf10/Ob0aCSzsH/2BhxPdkTk6vD/zg/4 +w/7IxchVB8jOT/DLMvzwHQz9wKncKvfilci9xcM3R3hZFixTUjlZEURLMrnjEfzJ1A== + + + rcuR5uUIDz9IqqnC0OV53cauzjy5ep71EVEQJUuUZEOxTFMyDYUTBcMwRUM2DFWVRFk1YUSXFFPT +JFORZFVTZaRBsGRNhTMtXTRMVQHKBMW4MYQjmm7qsqFqomWKisXt7I3wkiYYEvzM6wIMGwZQx8ui +IGuGyfGGoMuaBT/IkiCrosyOkiyNe0ZH6YpucLwmqJYhwg+SJeiGCT+ogiGaogQjpqBpookjommY +FteAO+qCJGscrwiWrplwTUkRFFE1cERXDLyOJKiaJOOAYimaRmcB4yQdL6QoCj6SpAqqAk+Ct0dG +OSlpjBxczYskSIZu6Dh5ogCsVHFINxRT4SRDMDT81bA0i3syAg9oENXAVZNuJuFV2IgiSoYGI6Ig +6SqyWZJ1S1PgZvCEuj0EZIlwXQ0GZIlD3iF/4D70r4yTzE4BhqFgAL0iToisCrKs6ngfUddgzhyP +jzShkJi6pIuiBrKhSDi1miVZBsy4BNIlqhaOyIqha5Yswf+GZAuJKsFl4CE005QVjY6SrgkFh6yB +C15KjoQyYggiih4ejXMoAQ9hSFN1vI1uifCc8LtNu2EplqrhgKHIKgyYlqHCdRpwDvIFn0Kz8MpN +GFGJfDhLMgwDL2OKpsaeXlPgTqYgWZaMJylXlzGJq/CoiqnCNBuCpqsqEqMCwTpeRREVA4/QgFDN +opM6SGjafLxVZUNBw5vzIAEwJRYwEhTEAh7gEPAdfpBxplEJQN6BPpA0C74Rmb5YkowsAAGFyddJ +9FUTuAy6IMoi6YKsyZaCQiwzdtNpCmgOSKyqKXRzy5B1GmBaLgumpqrIJpBzFUSIHaMAK+FOlgHH +wgCorOP5URpNAR4FJhHUTgXWKSQdMkojPo4uSYoC3IabKTJIKpkU4Dkqh4iiywN5IvAMLy5ZpJY4 +LyqKOjAHpo1GgAYZWWGYGrMYsgYTC+fIqBwyKCw9DlxVRjXBISIOjjRVjdkUQwQBeoJEgsBoNKRI +wCy0PzqSBQMiGDwwbg6iLuXFBJMn491Aj1BeYGrB6Mig1zARBgkYCBXMuwxiY+IxJC83NI9k17rS +PBIg0sjL48g244zBrzJZVgnYBrwFhYJD0ewCraYqmnR5mbEF5lzVUBNAV0RLReaiCiAvrx0Fl0XR +hkkBjUGlQsItYBL9LSqMv7Kmg6VS2ISDgMkmCD9wGG4qofmFiaRHA65oQDxKBWirKJMlVW1RA7p0 +FS0dHGYaYBtoDHSc60Lcs7vQSdAPuJmqEo2SpaL84phGJAGPwc6SFsFlSNZ0UDXmviRbXsFdMNMM +Y6puki8B7ugauT0YMckRoqriiAXiobARXSGPiO6SdAFOM1EiYQT00GRsBlWjEfA3qPNwOwUMP7td +x6PfiZTCE1qkYfDwhors08nvSTSkaTJBBFFH64aSBWBBQvahxbfV3SIRBbMCaogKb4CvNywDARPi +JPQWIMom88o4OYqtroaCM4B8kOyrK7opM960pQtEV0GegiUAr8wmVTZxdh08bY105bxzdjrmEM4D +ZdTR1KF8q5KBlsMEBiuEnUhj0NvJpkXyjmatgazT2qwDdupIr2FrLPEO9ISGwKRb2rUH6GD53SgO +UMH0Hr2QoiC0gjFDJosCGE836ZkRMiE94EkkJhRgCkSRoUuwVsQINNOWrNOXcCeNIUcdXZqE3NaY +MIEfU8nMiaLaxpIWOSw4D8CPQVMpSTL5FQ3hHRh8EgG4gIlSLzLDb0qShk8giaADJFwIYJAWE2SJ +EKeDvjvRLqDHNIhtID7oVIHLKC74kDBmwnSrxC1FZaiBUfSMQg3gt0VGSCNJBC7rqFZwlGGaooUs +gYuLhC8tcq1Et45e+wqSIHMRjCJQAP5pPwPQHSjegfM7g4EWPSRdGv0LPZEM3FYMdhqTF0REzKsA +wiQ7AQpk6x8JC7u07dyA96bJ7n6Tb3eBnHnCWPStruuiZOsIw18wxuIE1BoRLo8jAIdBZmFEVUHE +aIRcKc0L6LVC58H0yGxeAPUR0EWcy4yphqEPPA1ySCVudT7DnWDfrqxwPG6TAj1TtvC6okWCAOZa +wQGEEIjT1K6T200EHGLSIUoof0rblAoaQVpeRixt0VkSyTGcpGg05SAQYMiZAEIYiFNhAAiSGCyA +GQMsKUgmxj/M6iiaQSGQZlMiX54mg3nknDxBISUYijqMcTUC/mN7CEQFhpgKEVSF+2joWyzt+oBi +wJTaITPBO4iLbTSjwn0sCwYsFjHrDPiSolp0joyxGERQBnpd0kZdBbsMsscws4wPAtdCrw1Rln2K +iXYZuG0inwj1IUJF9qsKsQL4ZeIRsoqhCJlyPMIUDBvA6OTUYUAj5jeIfbpiYnjHrC+Rg8+q6DSn +HUxq3JFxvvHYzDZ3kNZBewd3UAYlJigSRbnIQLTiYFUp7kEzi6YchJuTUJIV3eY6CTfKlEYRD9ht +xPyIijCWZmzXFTCqeB0I8chMSugTLYIbWje+34lpAJSNeSPSGJCyY9JmxQJohlKAyJYUDJE0ZllU +it4UMhrENU1uuyAQQDakoivCAYzecEAhe6GwqIXCUYXcHfCWzAvBC4vdyUJYgvkkU5aJkfijRBkd +2WKYUpNEemDwEW2MIaJmIhRXNPveqDJ4S1NkA6RUFLzqpi3jCmWKwNkpmPfp5MSzu5BqgO8ymhDT +VnqYDpNyB8RITTUsUj8ZgQPG2VJ32hz0OzjUwcUWKRRlbDDDoVnMsSN44eBfg8AMBfR4J0DFwCK6 +k0QGjvJtdCewVrIKMwfHGhqG/PD8IPYySY+o6BRhaKRJaIFxkpFoW28Z7GgQH5DryAcw6Qp3nTGG +nQ29yam7UR84U6EHRK8EVyX9AXODwNhsm3rQDPSY8LtsGuQ5GY/g0dGeUvSlUVoSswhoJBDIgQum +CQM2EJCkpCT5Op3O0Rg+wcyMaciE+0XCNJjnFhUG7Ay0MGjCdNWOki0Ns6lg9zRdIqjHYjUMnQyY +lCcUvjE/AxCdOVjQQCRAQkfN0AA51TbNjS58OMIEMBCuyGTgMG99PAIBnkmioLILQXgnkd1ksRR8 +TREF2k7iC+JRdG+IHUBJ4UqyhYYIXSOKMfwugk7h94pIaQCIXhUFhdhkwmbYYSZaD8yJPoFrSiKo +IRkztG6gNRKGhhCzgOBwsp02A60jpNhAKgjgwYgpgaDJDPHh7+T9Oqi8C2doIXtQo4APIFmY25RY +9C9hBI15cHDgBqgs8gWeCYwbJe5UxikyH/A7cgj9lISGHF2+TN/DY1NKUEV4ruL0gH2kDCCoDckS +QjHksSLiPcGxiQZLaeo68V4yVXo6zDlz7Qyi1ZYGeGqTsiqddNxVppiyHviYWJQ4xswmiRtaYFBl +SlqiRAABlLN8QrlPYpaE2XMVWUDgGq0gsd9AVaRksamRsUIniwaOsqYQo2N+VZaJiRjdcJ1PcRch +lKMCgOnljipBlzrCzVJDC4sPikSHYPmNChTwqPSsmF2QEGeKlJYAXCnpTI1ZKC3ZAPTqd5aIwpoH +orR2mIw3EcnIYkwL0TRgVQtmFI8AUybT7+RFwVlCAGyxTL4ky1dGqMmKT/A7S4AhKJEJ5UoMIhos +na0xFExTSKGNRhCSUuRkAjFmwqlEq4WmFWYYtBVvKcsMAqlkoOkMsvIyKRDCHcxqaSqSobIKREfd +6vOIo7LlKH05y2OWnRQWyQiS5zHIM4j0qMDyLsWegxFHleKYhlSVyhCmatiVDDQbOED5kGcj4KIk +ltoDD2VQak1v56ZEOyEB06FQWIin20IhKpirA8lC9KkwKaA0Lw5RPg+0iGqBMAByAijAUW5CQXCU +pDqKVg5aWyMOfjg45uBqa6RLZdJZvbxR32yNtIUIMQDhGDKiMssCXSq+XZVCD0aCBkOiSDwGFTed +taDPIx3FIkctyVlvYuYEfpEleHpwaTpjo2SIIO9wG5EVGeEAsAoyGBBTJdNB5uSaXVWYL7thPuwJ +ueao0J4AZCMHgKUy4vIxemNyt5ghNkE0QFYwX43OHocorocB2bAHqFwF6sMylgrVnhhS0ChKwNIA +JTYBDJFA8KhJItzLIZWNEYfsNrvL9w3OfR5xVvMc9b7OmiBNPAvrQWQVtHUy2W6WiGDYvJ1HxADJ +pGQHTjyWTlmyQrachTqyBx3FvM5yn6MkSNZSpggZC/iY9dKBA5QYRmOGZDrm6i4cEEy0QckarFhg +tq2rwDgetdmthuioNDa7ViNvViw/I+ixp0ChtDq5cpbrgvtKOnnwy8wYWTISLNNEGC9pLJakpHE7 +nQssBEsPkRilbrDqQSaxifCYlQ5VW2zANbF7oTxhc4KDIXeBNmXM+5uM3wrq4fEI4y3Jk0hJDXg+ +ZrJUO93hIBfNewdTmghbKTODmQERgZTZLmdiAhvx+ROcbg2hGk8VaA1TaoAKRZatJJXCYxgaoMAX +4wBMhCPfsEzKPG4HDXch3s5aMdaYdcRGMtWsCCSIFPQYZE2YvXmGTwqehymwJYsWsA4OYyEzDhGA +wdkEH6uwEbR9iJMJwmOthbAKGCawFmQ5sfxCsAV0h6pgGismyAR+6RyFChYYEhnMv2i2AQbjCEie +YlAZUTnCLAD3FLe3b4TGmmqHFntklRKvsp2tkTF92i7Yaqz8RwGg3XWAsFJFX6CT70Z5oBvBQ7E7 +IxpT2DmSXY+R2DmOSjpodWe1vbMc7yzZN7pMV/MuvKiz5GpXzTsLs53FW0eJt0WJB6YoRrtoCNxi +RSB0mCJlTW2doYyDXQUC2TRJ1ACkAr7gRcpuy0z6bOTUIaLIwE5JbnaV9042fx7p1mfR2YvRpauh +W++Do0Hi8wglZDCCxTFWNMeMCSI6KikrJvFFp+oCXpwsEaVtrEvrpOrMLnd0Jnwe6dq/4Oxx6Ggn +aLF5ZmV6sF6yYVw/SkEQo3Upv7fuotSGSSS7HZFcKwkkBmwkDwoVXpCBbTFSLWoClFlFyLYzxE+F +QBeaESIOO/OoemxXUR2dC1T97+xvcPZAdBTtG90L+zer/58xdSlSTocaElRWxrarvximy6Ql1mVV +CKGGnby0WNkE2zQR4+l2Jg4LvBIGI0/wuWWqPMKNTWaBVRvB4eHsK4XKOxLjoqbbKTyDOlrxAhS4 +YrJQsu08i7QdE0K1LfhWxcCKp4y3Ru2mMCYrdoebzDCUJGqslGxJWLDCS1DFGEdIQalrxvbBqsDC +I+rnoPq2arcl4lNRfvKyZYOe3eYMXtTurDM0ibWSSqxQ6KCZOkM6OePknoPHLZxAW+ZINjTbPtpV +a8oDEK6jlCvG+0wMUQdZnQM7S6h8LrHQnnyVSjUHSbDnWGHghUYk+1YmKwJZl+0rEgqXxXozSOG1 +tvdzzMqdhGYo2ZrdhXGZyAbZZuZasTPZwA4q8vDkNYGeZ9R8o2E+Fc2cZvsEXVRYlxZhuOsjooqo +kGWvWW8K2K22L8Goh4kza3jW7HYShPoqmxqUV2qaaAsjybx9IebVnBxtjXThu3NuOg== + + + J7BFZVwEzMwEqwprgMFmI9tQ2y3U1BtAIxrruMPUAHETgw0mHZ2dN59HuvTnOHt4HJ0wJNVmG9fZ +ttVsF43Rn9CVHPN5Jz0Yjh6XY7S8LDNHHTSKSNiDNQYYZGMxV0Q1K9BdVthBKMJ6M2Ty61T9sX0q +ABgGc7oLWRdRdEjrTZFudJF7BzPJN1jU/4uWiJAoBuC6wVCxxiCNo7WpNdKlAcrRItXZRtWimqzN +FZGhqctaNgWvmsbathjQw6o3dmE0qCROyQ7kOtl3R6f+55Eu7fyOhv/OpqPWiLMzydm81KXF6WDE +McEkE9clwCkhjgu1Rrp0VHXpuurszWp07eDqbGn5PNK188XRHdPZQsO40tEX5Owd6tZhZNrIBsZk +E6vvMCIjDqYRgwEUCxOXlwOEYmAyTbqSHbQZqJhUEtE0qspQwsmi9Ptlf4dBSVdqBMZsF+M5SzBj +6pJdoYsi3kmHq2JZlBCXKaFAwqLSOgeYP8IH1wYUJomsDwTvQdUKmhgcU2myDFYCpREMHWHE7h81 +bBckssmwgSK7ODYOUT4ZR6huhe2STL0NuyR4OXl0HosXfnb6yIZ0TLFTChyy0hrp2rPW2dfmaG9i +3qyjB8rZJtXRS8VMD5arOawYM4XHmArDanYI9dAgZ69ZUBlbeeEO6MGxh4kCK8xuq3be5QnpIbBT +o9SMYjLThhl7KtFQ8s6wgaN8GXdiNt2inARVBFgvASsEqZLEkp435eWuWg8pKsOWFctkTRwWBdPA +cBYwo8ggolWoCo1lE5QrFX9U2tNj2IUlxMgik1jK8eAAFbWYKlPOE4ZUargDt2KiO8ALk38yaAEc +XlanYIidRHKnsOfDG5GJwnUvsk6xuEK9Z+1aN+uXpq4gLIfbXpvidKqYk5PtmC5mDG/OqGPOO+WC +taWKYKCxu4w8Frapst/t9gmUP5RaXaCCEes/BEdPIywW6OyuY07uZgOeo0Ovo4uPPX+7oqcxV43e +QKSsk32jmzNt+zdWcWhfiJC0QT2EKrZaa2RbLXLaIA/MZxt2WwJgXVpyRByXNITwGBCRO8XyF6I8 +hVWTHOLArFynyDiE6qbgNboIZwdVDKqacLDW7gBELyFRByCrjnS2BDJrc71n0NFS2NH+xixNR4uc +o4muo9GuRY12mt2/YLc2WQKVWxG7i4bd+2ywdj1qoGqQd6enwVYqk9J+MrYTYU8CQZAnDN6I1ObB +WlFNu7sGcBMtv0MARcizXVUh4Mh0RGMtISgJBj7KZetop2jcTazXrefP0Q3X0VX2eaSz78zRl9bZ +kUVhF+Jv6nRiC+l0O4ECAywjo9viaDInzLgoUhoP7YmdZdYow2MwhUfETSVYvZ1YxKjOQi+p2wBW +t9dEgrKjTcIBhdKAGiuns5iCHCtcXCK3rlN3C8o4dkbJzgmmyKtDCDqlpEOOmBoQFXbWmzLOEpNp ++5SOZkrWitfRcOloyeyYwjtxcwCzKctk2MbsmJbwUOhkXCV/TKrmY6WeONZt8m5Or2P+O2WEBEuj +cNq0AyuSNMz0XEYKnU2FZBw7Gg8drYkd3Yts+pjxMNmicdQU8hvYKMzmRmQTTAUIyQbzTMrRDVE7 +PJYKMTTEmAWNFKX/AJgi0pJINJFT1FKD3coEo6johwJpXvaPEMcxLQ3ixgAjDoDh5bDdjQBR55yQ +R1JsA4/5TJEBEsxnqNRSx1Y7U6xLvwNg00zn3SkL1/GEDho66WQpOMqI04JSlakMFRhkWWBQFVwC +AXLsn7HsAJxVHHCFrqQ5mh8pp97RH+nooOzaZGnbnnZ0zxKGqFtEcieb7iLgwSY1AvcA/MmvYUkQ +wYaM/ZYsrkbxZb9LtIge2xhIuSy7h4bqHuBU4IFxjDVCoJmWLXYUYeYubZyOTk9HL2hnv2jrKvuP +GmGxNghW/JPt3jW8LIOK8A0rnYjkXUSmNQZ15+jMLmCXoYk9dSJLPqjMb1N01R4QKSLlHLy6Cyvo +aHIFwdMwg962VriWhbUyM8yL024Aqch3wG+MGwpLYlssg4iEETMsBsAchLZGujGjk103OYqlXpYk +oP5t3HzBLpxjaUxTGI7EJ8ZVkxatklQF1niFpVTU544O3c8jzg7eGw2+P9Mbe6twx9kca9mmDUGr +SRaCYC9iXNQek9UyGWcpmNdRNlTq4KZ+ZM3GrAhmsdah2nVA/bK7SrVrd+ByKBmp2BlM9CKy0a3N +uKMPubNNubORuQVUyG3WG7QgH2YNO8kINEumo4G3NdKtxbezBfh6k3DD0UbcycvPd6Bw2NJDPGcp +7+PLZg+tzTmWfdVp25Ruk9M5fZ3T2ykA2B/I2hUlypTQiiJq/ZNwUZskOVqZWyOdzc6dvdA3e6Vb +2MBnkvYa1NPO2gBFajdSFLb9A6IOWmdBmkRVSuo+AsY6GoypI/BmC3Jni3JHEzOJBwXNpu0XEe/j +vyh6dhRGxkBH6yGjlzGZemtoDEQEfayLg9Actg8gE1W766DROXF3saS3swsYhcfE7hAMh0UE8thd +hKlcrGciFmi3Dap2Oq8xcm3EYtKjUt2pTWgn4dhtd40vHTzrZGqLGvpQtsx2G7Fst92LBI9o1S5O +kqEzp43WGvM7up0f6ehT/jziaGS+2ebc0QbdcDDpTrrw0exRa4VmJyWOseuI9TrAkN3Yw7r1sAKD +jrRLU1dn35ejMczRPNYC82D3QkoUPnJauwGKCjOSQg3drBkF16ZRVUGzxYUuw6xQRzMT+sqOhqfO +jqguTVMya3yhAJasF9BMHc9YUqLajINR5GRxW6vcxYjEzWKHDaAyEYwAGHVLI7yoGwikMRGmwWNS +vhmCJRGUBUs4gAJwehXwO7olQ5BjUMONdHPicKTTXEsdk/2zOxgpJqW9cd2vaXHt5n2RwmrTdDaD +t0acHeNdmso7WnzxrI42YEejsKOZuIVtpyytrtjpZtWuOuGA3c3Y0YeJJzl6NR3dnB0tkNQTd7NN +0tFI6ZBplIlOsXfoRYdI4Dk6JcyovxfRKQyQDPK2mXB0+eE5NxsBHZ2C3doJuzUdOhsTO1rDWiNd +GsicTWadjWjUv2bX1OwhGrAZyLZCuNlkRKd09iE5e5U6+2dYlMMkSbPryxSDUi1Zo15srUvLCwXN +nY0xzuYZR4sNa2uiBBnuzmGxdhhJtCvVLKXi6I+gs5xNFM5Gi45KOeuP6Kind6u536wHUkbFUTXs +Wlu8WYG089TIO4SKVHgybLHDohrhEmcxzi7iOUt2zrKes/jnqBA6aog360bsZsRn2U7W0jNSqYmK +xI4iCTuls5DSWWm5WYyhc4AQg1qmUXTpGIq1lfYy9s7aAM1XR/2gS4XhZqqZTmL2UbMVC3wKLTXR +bBzcmSWlUzoSqZ2Z1o50Hgl8R8avS07wZo6KtMuiTLlhr0+l/BRaAYMWjWnO5IzdIHkjgdOZ4enI +AWE6z7kW9+ZiXcdC1tZIZ57kaKRrLqUj3+JIyqBtlJnhxCG0Spcx+7WBm7kBDNpvpg860wsdITaa +bcf61I71qzdDT/RCN4PTzuC1M4JCiHQzxuoIwTqQfougP4o7CyM1rt1brNpFyk6U3Rpx4vBOnH4T +pBJAuLHir3NFYLc1g52rCjtXHd5YlkjLZgg8gECw9WLXBhSjy86LdIpjd8bO7Rtv4iPs4M1tt3cm +lbj6R/gZYRwEM3BxHaI44IBOIY8EIE0DQcElKhatsLSA4wA3NRxjvSoKeBQVG+HAu1I4dS3kxuCI +YFgnIpcQh1+hOxY7sRyVZPsRXItjUfcyiqBMi2ww302dABbVfXExF2mixhIKuMSFpWk1XO1KDeCK +3XarUwEKd4dsL6sy7Lonbpanm2hOzfbGrZe9NHAMRbNNynhi+Qk5qpEyNalPXabKgiUB0KVNYEEr +0CAbdiajSUl16oRqOxwaMlTUHZ0t/8MhEG0To2Ms/WJfTXPkshlVtZdiNq/ssmLHzDRk2j4BO5YV +NqRTFN9mJTuKrKZI8mzaZ9pwBBcyoPrQY+isP1cW2HpbGmM/4h54bDEI0sSKWO1d8Ih0hhupq0uU +GH/Yijoy2jrxGhueWJqfwI9E03bFXDxSRSOBsyJRny2iHdp9BqcOfLfCrsem4LIvQbXnEGXAxrj4 +uGiEUUxYRpvAmUEM1+2lnZg8JuBLC71YN5dILpgYgjOkKxTTyPYy3k5BxfgV9Unkdt6O6Fwmy+08 +tXf8Be5iwAFYHs5G/QHnD8JjoHVTDFJsCIjAfgIS0ABBmzQ/EogXeB7ThiLm9RQVbQqp30hUKpSc +uHkMLW5jxWKJlb2OLwfQ06F0gKiqiIh1Wz6vJqE9QmjWoGzB5UEgunRM+yqXA/Z9yEOzEXR+Cm2T +Z18EMSKD+Ffz3R5Cx8Ke53Ko/cDt63RQxJYiQMQMVhd4COzQaamug+ngG8ClyWCWTIVcJzL1ekKA +FusaVxxFRtKMX0vviLq9No0tyWwztT2g2GYXd6jCsFlt9yFcUqpeNdjiRpsK5UjsgxTbDrSvcjlw +xdT2CE8JDoaT2VV4yV7efY2r7SH07+yBLofaT3x5oQ6aWiy+/3jn4sva2XATUoaFaH8PsvtoQyh6 +aV4dhhUlZjch/mDA8GpIt2HytRMvj7q8frPLPVG3FcpqY8KtvYgO0Tb61LbxaV4eg7xUaQNk1S5V +Xo1oNkC4Oqt9jHq53qvzXiw3BgeZJC4SdUIdo72UWQyu0HZICvks+zCZ1UbQgIrUVnxtQLt2Qvvr +9mWbzjvh7TF0ltjCLmrSsXS2bVnbA2C4duki20diqteUdHvdIMsEXB+jYEK6fvLVcZd3aXa9Nz2T +3DYN1BxPu2jgailqJCRsj6ivee04TD+yVbB4T3tfwmtDrDhy/dT2Ye07NLvctcnWvWh29xn4a1Vi +y14sZsokO5HTvHaYbHcFkBvVZdLlG2OSYenWjXMvj7Nv0XTe1X4UhbbPkG0y6FHYAhhspxQJEV0e +hZuX2rBFpXUIyvUhxWbntRPbR8lXXOq8o/0YbH/rdraJOtQUE9ME8pW0tI+S2MyyISwUSteHVDuc +uHEiO6p9+abzjvQYWC1kiWm2VJH6RyyioN153rw6SrG74Yl0jXY7uDFEqa9r57UPal+96bwhPYVE +W5vSEmGq5ZDusLxfO0fYvDqqnQwg2Vc7x0TywvRkl2deHta+QdN5T2ZGaI9aiQpjtFstlv5FWWLb +q0is17h5dRxPBVBGh9ReOXdjzLBYZHF5bvuwy1s0u9y2SVs3sdyNYusglrXb4RVTneblMSiADNkp +Nja+PsLKFFdntY9RLrW7817s/jJ7UQBmpikipsI6A6uSvVK0eXWYbK+XwetLsr05xtWQ1rZm7RMv +j7q8frPLPRlytGzIuD2S3C3Wz85vvKwluVuG/y+PuXqRBnsFRpeXYiwdHV0cH57sne+/5dbP9k7e +7Xd7P8b14G/959+XIYk3X5iB7S/YDYAeUrTfKdEeA/hMC2XxX4xR2Dhcyv6B9evRIg== + + + PHuE7zyVd16f9UixwfbpVz+0vxKvfqTY3mQrVuwhxwW63WbmDfAjs32CLy95y70723t7uH9yzqly +lhhjIY8Yl9p/z7wjhbz+keg9DxIYQtkkn2Lf4toH+8IAdrIHANQqYW6b2zl2XAtMr9HftVQMgsDD +zrS6PBjuNAGYF4JAzKP2+XgzxxjgCDIARgAmmBGwMN/Y61VMTO3o7XvPOGnFjJkGKgHmVgcA1vN1 +DdQzQwPpkeRu1+2fhxZmIE0EYRL4wRmGhmdmfoeSL4mu5NuSj/klLNFR9u3rhR5dkA7IUZZ0pXch +t3ApsA7uTVSN31jIKQ6+8gS/P5k3mcjzvco83xZ6/pdZr1sgTBDpA+t19jBdxZ5vT2Svl5NkBUtC +Jgk+ZcpkGQC5jLFE349EIopZMw2gC1xE7+cauKJLhX8MyRZS+6024C8srQ/+gEk3ZA0QpWmJandX +QWtcVVGSLdSLPi6N0bXaPq2rIvU9AZdm4lKHrkOs3IWdSrF1SqL/sA33JuBiS7V1XbW3t8C0Npbi +2q8cuf7tjV94jdUzMQ908wtb1llMTVtGXX2JJ1HAe/nb1c3YgVR3x4uKnQNsNcTPn8D/wp34X3xE +/mcp43+JH53ca4zMs76US4ugsnz98aVFaj/pja87f/3FYx2PfuNr28DJYpcr0ZEabQ9EFbnOgYZt +0Gzm3vzyl27zy0/4S8Rdv2EHJQ4mNpx8bbKCEqXABf26WN/IiF9VmrhN6veSNAUXk0IYK9NiU1Uz +VBEXDehgTmizRFOWRck0VFnTJcXuy3Mkaa//TtGofL36JJncTv2muskY13Cr99m7fYLZaIdvnfOQ +3O1G+NXol0lP7n4d8XBev+Qnd7+OAcndE/Tv9ZPTk1+KrdtvNIUoWtnYOz/fPzuZ+/Hj6dn5Y/tt +mMldkSvOnJ4e3TzmBF/3vXBx+Ja9e7T/IH3j7LS1/+kTt7nfOocQ/ejnY3Sx7xidXvQAGmFZGm7w +KdOWjaqkYsgG6FNT7PdAmqKoKrgoBxfZOI5hy2D1m1cBeyyqoqyDxVGt7oeArb+6SGPEeQzfeVDz +Zw7qcrMbT8x3e+SbhDsOaYzQMSIM4QZcbGFuxzFNOgYvAvEoLvt1HEGPq3Vc4+bjdj2kgzeOY5yc +6XaI40bXn7XLo94k18mRL8tL82dDxD4jRDTpRJ+s0P6XKu4WIpmWSU2nrEBz8yTctAC0+7p4IOhS +sOmEvjclrRuWlnAxkAmUa7hugJaefe3NVAuXMeAkmOLPhpgyLjNSdQj6sEvzV6OsnXdRwDNqpmFJ +qmxo1ldfHUJS9LK6aMEz07Wx5wzCQFXBZaVY5PwrLq1jF4RuAJd+Brj/alNiYf+BYimSpOJmhFfg +27V9ru27Jdsnu8avbfw6WPYr2r7f7F7mLZioaw/akWPTrkE512S5Jus3MFntlNPM++7Izcpey0ld +GS+QTTRfuBTexNcXGCa23rGonvaTkrCP2VLh+XDZE+gRagPoCwTo8ChtxeqeT3ZF3RX124pM9L4z ++Z3+me/N9MOhtFOHKLLWLYfp7+qgeYej+drbSfh2TPDQGu4lbKrdXTRuHmko+Ew6zAY18/5K1P1s +hl7VdDxKg8ubf8XtTFwP1b6f9TO3+9WY6cAgP5vWFwwwkKpJvaEWbamn4SoGQ9ZMSaUdn5k5VaQb +/fCY5+xoK8VuuGv9kLLuKBDYqnKZ/MYlRIpl1wquf3nzu2Zbgf5/9t6EQY7iSBv+/oD+Q3vX2NKC +RpVXZRX4QAfCgGS0CDBe7OVtzbSkNjPT4+4ZsPzrv3ieyMzKqu45hAHBWj5gJiYrz8i4MyJbai/5 +883p3y8Y90Gysk+b4EVHmdqO/qu/J+ra9m3tH6gasBBmN/rc84VLDijc+nM1QaUe1d93LX7852nn +9dS2Zzbe1+qPd6dHMloz+63cAaM/c0rDh/WEJn8arbT+265DHP1x0mk38nJMZ3Pe2d696OArh0Am +vdvugM+mBs2pkRp2T5hf78FOy8HSwmmtzieQQA9q0M0Blj/cARogxVQ8MzH8JM3FnyyfPFkdX2Yj +hlvlFb7Fvr3bRI1EobNvZ35ipCYdZNUlOFCjlm/slPEKCC+u8SowHWjHiD88StOsucgx4Jn8AL7g +2OoDe7oBLOJ6GbOHqo4ieFg84kGmebydD8ye4ZDaNBWsV9kDT/hcKrCAcFMAPB9BNZqiZp/12GyH +2EuFOLwsaJnkj89zLVNvIxEGUl/hQYNHIu3IexQbelIsguSRVAqBiMh2goICSOMlkhK9PZYPnFhe +UlMqNAEZGQ3jG/noVZOZcdc6r29y9dkrQAiaxbshlCRjjg/fWU3yjTQpkOrTw0vmag2MjWHSYQQy +xK5htUWNgsS22VYrBqY0+W64cyljAeqnOoRoamglAcwT1jBxqo85ubTRtx7pRbPDy8ROc6Inghrx +UCDlSWj1EaoF60+1NZC7hz4gZ23KkoZH8LI0fQjFnHbw/9Ez55zNSfijvhUPyBuhyOa4jxPsg89s +552//tGN2a3Hp+vl8bPZ9cfP5yeLO4eL4wO52s+HW3/99oMHO5s9nJ/uP/90dWfxdLXObe+c2+EH +91ITvGTGgVct79y5vb9/dvTJ6nSO6VV0xOyJiM0iH+k52hFfMrFmq4BEzOhYD68xWoWAST97ZHdJ +OSZSBgQkdgpWE4brTUIRCuaYQBKXPiK8SPZaawKnR79AiS6liEctOFbzbdGLIBiDp5EeswOTxJNT +ltRAtsGOwdRaXMQis7lmFAJJmlk+THNMOtMyzYJl/RkWakW5FaaOMYFFmxm3j4RDqFeCmlmeT7KR +pB+bwlxETJDkGhGVcUmiZuTc65FvGAAmfdOX0jL1CJAWvkAsiHfMfsP6r8jfx6dtSJODGsZ6kUQV +Zko/reWAXSMdQHIto4EkMRX/iiFdI2kamQcoNOkasVshanwFzZSiTAiLt822TbfIOc1WF1BwTXru +WWSE10LuDMZCYkeGMOO9NN//QDb29NFavGgwWjRAOLeWtjF90PQl3qZbFEPKDyCXn6AOtQ00+wDJ +FZBKTpYvvsaIh0uEPFOOlFTf7As2dgiLhqLpNGkOXlVqSWFkJfJJ9XNWC9YI1uAAWTlJKyMwKQqQ +wuNFvkHdOZBbpKNPmXZFQwiKjEKNrGYbxwtwgy3WJ1IN9wybaCKeK2iKLhbOEyKJhCr61Jg4DuKJ +l8EduEmP7GbEYj5/Nkh44FkFOQYmezTBskI1U6fhWTBwBScg+gczdzSs5UIm1uIiBFQLAJqhgB43 +lhmInRYs1ayGooQQoqkt8gEBwfVU8PTKM2On8Ckls8zAwBSFvTGKDQ5MjamcjKKi0G86zHtNJ++4 +MSAPnWIEbq+h2aZLeQ6R4j7wPmvQ+j5Ta2tmCxaNYPWiDiWHNA+vcCzDa6Bpm6Ge9k4JumG3zLms +tVRoV0ioyHfMuISaDsLwEGPKcaGYh75Cp9kXVWJ1hvlVZ1toB1xE6UIbFfFESwtaYNRE1rpkXl/D +7GytUdQ3OWWv0RLm1nK9SFrb+BTUgOcUltXCNPkOwx1wE5vQDusRXETG4pRN1qasZwEvZRuinhLG +JuijP6s5XnBQoMVtSsSMYLTQk8y1yMZqUYkHFrF+Dw/xgI2NsnFB0wZvvFiawbFSaINE2Ex2Qgww +SnxsInvcyZbhbaotKCHsNUsJ34s5LcCQSjFYPPLp+RyLAkU0UYdRguL7qHUpXaqeALtgy9Sd1Ntv +cs8c7wmFExyA6TzvPh/1KzaaNjAtdJPoolYpabR4j1ZcMKbVWlVdehqJbUspk12Lv2HfbF8JEyCC +IuNq9mYmSdqn/qeFgGA9wKtDWZZtbaJLxmnRHzmIhI08Rb7ENIns4mowLWCTEqWgVAbz903wDsgI +B4HBGy4HS0R0WkW7d5G3h6U5WM+jlH/qNduoFpFBYQxmmdVsi7rpfL5uWdDVp6uHuOIeL9dI1QML +mxIZrUlPopk6gQXF+N6r0ZS1EZmC8PBPE8BqQdEWORqQB5g8WXihLxVCUQsDj0mN1rcjUxf6ydrp +zEDXIcFQRxTB630kDhEeT6HUB6YuMMiaEZkekNmsrabtASJqPVakMujlXLBh+LdyW8uAZ8jrUTOm +C/Z6oJU3ziQRMSWWtum5LZK4OmbPS6XCkBlEBG4WYuqUGLSuHfJIKy6Kloh3RPrMi8jIgNBU9o+V +vTp9Em3wqiyhovSoudNT0RBe5lTjqw1aRsRBywI5FJHIJ+aOJ8oUwylGwdbOF4E3mWjPaxafGNuU +5R7v3/g8W7eIFeJoT8Dtiir49cxZNcE6oCITELLUghBB5xn4hjR+GNfi4AzV48hXiH4vBSL2nW5v +SiyjlcVVhxIS1JMha4pqi/B2GRCCFzLHpBRWjs/D9Mkoa1qxSHngey617kalMznhEdMWtoaikmHG +LWAXyDf4FFRFGDesLNOmpKT8IiKpL/adaTxaS6wVrNGUN61mKI2KtqqaaXlcTeeObEdI7AwCzlwD +LHtjSeRbTXR5M8lytksZkpA7T7MF55JfrWG+S1SN4AeBz26Zji+S+qHgjicv9i6fT9fxwjE5qqIg +cyjnoqUm5fZjyiQTVJoXlNKaVExbosm9o1eJXLkIWXEfuyRWkjnjJlBItyi4Y9J3InxEYqws3Kn4 +y1exhklFNPtzUAIVswJwE+Ylvr1g91bzzllrFAmblO6yxjagICS+jmpmn2v6GaYFSjHYzCOK1Ay+ +T6zY8U6LnKy10KJR8S0gUYsqgiw8hEFikxwskHZck9SakIRCIiIyytPMAZEGzBA6SyraRL1DEyMw ++TWRykDi7VNKCrmlBglRBP24UhQJAFEmJ2mtzst0hi8zmIEHWpZRzFNERrSMlvvNMh+LgydJwaf0 +ZRr7CJmm6VOx0IDHvH3m52QVWIxlyivdG9WRIMD2io5MPYXMnH3C33YvpVvVHGa9ZpnHnWeBI7J+ +lshAWreEi0FtRTYlScMsITgjzVfXJoIouMyYzqbpXBpIk673mpqABM70qcAUeKuyZCb4t04LTKX7 +EkIKx++YbkoW3KSai6l2odD9VmXWRi0GLMGpScBRmc9rNr5WGXHXaTGBMdoRFy3UO5WPA4L5j64x +hTHfPyAnuGVRgqgSHl57OquZwdOZQAFWWuW1coFB9ieV3lvWdtDcJLgPTZMLdDIPm2O2M1xxi3Ke +EG9Cx5QvTP1imHWIWX2YJ5uIFW1LsQm+VqS8RmZkyzQmZOxCVqKy4TZJrzIWlfeg1c071yvLp6CM +CYAo8BL4lJ9CX4FTZNUCRJ76gWNpHyXympoHGoWKRdgyyIQWufOjaqUd0vZgAqySSVtTyyy3sesy +0YmyMuSEJdfBQbGGbpdKnVOe750tyaMVF3O1Lt+pGQmMxGnqr6BveFOeW9a+a/NNKWUzZTGeCCfI +pZy4tZ1KnByeNNOm75zqREAPVlBgFTxWA2IWXfp3QVtMUpes1cLHJvQJP/EIAumAHQ== + + + Y6O5i6qHjfGOyAjSElSlYiZ0QcZeZRxMShPVu4x7SN+odpBkqYG9UrERWfHaZMQQtkGrBnkFUgHh +cqnAz6QCQTERRs1kyWM6faZq0/xlOCjHXGhaM1X5f9SEv0grChYsbF6zsjMVMTMO98QHETLVVNvz +dSeye8eBGXeaWBpKhlZWSXyO8k0AJcEWss5TnyrUgkA5q7lOKbvbdHAqSyG7C65AZ5PwnO2vqQpV +yAbYnqmtFXsdFKeYC/PirkKRjbn8ntPKvjObKpgqImpuFdT4jDYpuzHlNjLE+ZY2bK0j6mMWBliU +iGJDy4NlsSvVU0wbkv2GairMmrY8HSBBl/0jDIJnscPKjdWU+6msKg0WnhqfdU2v7BkvZZFcWsbS +uwYf7WwL5YCHyTKaHJaQRI+uqWG+1SxNUbV0GDU0F2hKK6OmebUI0qmqKzZN22fmlG3zvZqd9S7T +zKzcP6dVVOu8EgFmJ1fzfDY0a14mketip1vfaTVOGujTaTAJDS30umBW7qSJ3qmNmwVQqEhzXjTZ +K3UPWZqFu5w2+o7l9gzziFLjgZpHezs3iFb6Lg5FbocttFoZhLes80zzFXiPaEqJMNBarYzQqhDU +lzSEpJodpUmmiVMDvaOfgyyNxm1KGqhVgi+Y8bgntYaRG9Z5r6ZZPlqjcZ4VfbO5fl8rXtiGslAk +x6Vp3lH4SEUatXINB3JZgw6yjJka6rNZPihls5BU1SoPc7Oml9frKXI2VqxpwpJNHmp/qoK5hXnn +G+cvsbvffnq6WCeb+tXs+Jfb5qGmiqLbXck2n72cJj2onX277Qf9XrI+fLpeHs0eztdfb2Z/uf7t +8vT5rL/5+HC5v/jLjW23YXqKddWcD00z61k7RUs5Vb8+0F/5jwfXJj8OjY5TOrQo7MaKZif/9sI3 +6ZzsjSi3wnPkHtLP2Ip6JzQGRWL6wDyGIjjLvRZygZy5Jk/6+pefyPo3p2tu+V9vcJO/+Oe1mxQ9 +mJvrphas75BRU70WDX5UFW34kRn/kB9F6BcmCA+j65lKTKQ3YdQQJGxIz81EkmllXqIYibrMso1I +Sd7DPYmXePHc6e2ZNEEtqsoJ5vHHs2KD6scyQahRSK7VybXWZH6iaDtcMNSq73TKIp/LVEQqE8mm +1byPDvWNgqyjt5r+bPcEbZogX1vpBPP441mxQfXjMEGm1xZBPyJHtabWd6LzybCxb5lCDHuHJJPC +W8GMtPSIsHtRRAwl7HOn59L0qGro9PLo4zmxQfVjmR6S7gj/wEsKpIJjIK7BZQY7dpq/LKA4IGbj +4V0g7cZLY5kkCnwzXue8Cfo0QWfKBPP441k5M/5xmKDMJgi+C5L5hinv5cC9l8mIbGORY3YXRGZs +kSkqNI23+k5y9wRDmqAZrogbrkg1K9OPfywTFCHMIKIPLv/I9G6i0CNNKBK8toqTcuCmQ3gBMpgx +mgCcDPpOROTZ+Rd4r81XuEzPDBekmlMc/VQm50QTsghsEH3Gs4CL9b5hsEsT21YhAWq4yFZGy5Y2 +588m6myGyzDchTKBUP9QJiIkTWhcgOG7gcgIA1ljRGJHpk5RTxg+EWRCInuICK5Vf8+fSKcTMWVb +CtaX4U0c/VRmIjsiew+DkuyMmqpF9BYxUJqwsgIhEfaBXmRz1ui7YCa9zsQW/DFlT4YZ2H70U56L +phSUre87kdPklEIguhiPlDJMjedCCYxHnu46Ts5oDtxRUAprDTrEeGpWLdoZDHEFPwpFPUwNqh/7 +lA2L0TI/PEP6H9xq4frfcaKbKo/Aj8VBDacLYwyrZXeBOVM5cetSfUAAVd8FiNY/gLy+IEctGpc+ +1UIECqStHcA2f2kTgLW/AKGltYDSh4FlAsbtEB6jfbUJQpUqzyJ/SWMAZ2vTmNoo9F07+t2nkqwF +4kP6wEOd6sKey4ujqNvBS9WWKXr6JwFM9hGAWgWZbvgyg/phWwaguhU4ba9jqg4JiElbwMiEPFGq +wIiQ1ahzblXUdppwVbeU9UUTKJ9FiHbSjnnWOYQG1AADmHIfqzK+fBoZfACgp4gPEDU/gNomZlCn ++2hzIVUAUTmHe+nzcdASRFDfewV1IeETrd/pUxZHBIyWUULyltO8ICC/B1tBgfBD5E4O02Y8SfZP +VRLVpKPRNVElSV8GpDjV1Sva+eT+xLYF1oIdQJ5VSfOnBdiGPARyOBCUIpk8kwwTkqK/0tysfmlb +m0bQIg4AaZa57OwtoPQp8yPW7ZAn2+oQeQnYyATR5Oy6463RuWlNB4JoM+A8XD7SQKz0e7lgI4EM +0MMimnwTtXwBQBqrR3RrE0iNEgqk7wTArs+XsWt0XVowgCAooQVUMN/baTvWI0ZvrBquNyttnMvJ +F1w+aZ8j2ACigxogtwVpYtmkAkylmdlZ3t5g+zymTydju4EMmTZtJkmqXlSvn5pC07TiRKdWnbJJ +fdpfptnULW9Tb0npxmkx8zZA2aGIk2ZID1/o2IS/+lPHzDwJL+laLaCMhYaoVLcL6WRYbUiRnEVJ +RkuFAywhiVYmNbSoRD2G5KqsQbTfpk8TMNCwnTpzSgc1maIO6vPl7ct0IZormVd3nE0nR1Dv/Jg6 +tL3zw51xftQMFZ2sDtoWuk2/tDKgpmB+59rUjrSUJxNzb85n+jZiojn5PkrftFEwW5Qib6lZ9sih +LLJRj+eWKpg1PrYNnhPgbpnZznJXM8ZGjgoXFrmIFchGMgbr38YiY1Q/5kJcr0QueumJvkK5yCf+ +GK2e7VGNDXg+goDdwwRkiCXflJSbymI5Md92ZYEQAACy/UBXSXajyxWaSWrhOwJIQ2EoesUKVAiV +6wdgmoqnP230sQZMcAiX6K8yYU6lK1NB2YI05Uz46DbkumI/gYS+UMwCs5lns2QyQU2ig8iYSghL +k+UVwB9AYMwCEMUxQDS+kQS/rUCZ0iJspgDz2skH5MDoRc7AdhvEqKMM1AlrrSCUJM/yoDpxACq8 +12l1cwAZcq4gclCAMmMcINVBF2Cj3iLN6KaDavQyQS5BgiusQZ1RALrO5FNIfXEbdE3BDaCMXP0A +yqhKg/jo0w5iybh/xkrrPEw3iGZRYW3IJNTGBFJXcQ2q1z4A25Clk7RDdIfokDadVGPLdqsveHQs +6a7Vh8do3gLKaydBnpy8SjHRqbP+MPGGNAaZSoaZhDchhsxAGZMBkGadt3RC6mZSQs+shocJoFHd +w6cISYKaxCyNT8slKH3KsmbjdtZM+rK6BFt8Zyo69pOp0c2sC2jTAmDKHBaahd+Q6E+9I/pedLR3 +Xi/uFpCe1uo0IJe1IZ2ZL4J4ulxNJXqEggLKfv1w44zWNxyBbCU7Z2BGO/TWtCPkxKDGTHA4SysV +rnsNaa5vhNdgvvFl8uqHGl8nP2Dt8HG5JmUEETnaya326aEHL38WtBijzWVlpSND6tUXWJs2XB9/ +VDQJ6SHbKe3yGv9fX6Ysio2OLzGu+jL5Pa0LMzl7Fg0f02DUH2ziFpBRjzVVRzSzjyPSnzxyYxYh +QAbHDZykbPnAbmpQ4Uo1MDEvdJbYUuZwGLTPTLmSUFH7tuaYXp+TVGwVG5VWMPDkcnNqnuw1im/8 +sWr+FdvXnPIT8cAjDGgkRXhVlmtZwzMx/Nbyx9LLgyKQCmtuW9c28G7l2qrOdfAB9hHSlFc/1nad +7EHgbGOR45LExgjoUIS36sc2vkKB86Un+koNcXzR3CLWzMYsb6p8mIEK0kipphBYx+eACqqYZ9s1 ++unAZFvGDADUbkEqSbAAm67LSmvujM7i8aDUT4vVKE2OZXEVxAB0gGyXRQ4WMM2gjOtt3S7fHVu3 +VBCe3dRDaGH68Uz8nhbSrWbsk9pYrasCmer+D8A2f5k7y3vpWTZ7vOU+RaFXR+P12UJ9gLjC0Q2g +moVn2OEYJug3EFjKNS0e3ntTgBY8dAokzcpApVkUXwHKZI2sFIDYDpSTwjCAfebDSibb9ApjAqr4 +6wBMZozMNwXUmsyelPgDZItBQZ8nAkbJSClsmpxalJW9YOYZtD/ZEgLT6rWCyxSICpnjHlk/XUGZ +1uPldJregBOWFYm4jEzEWZFdF5s5zACqNmUAls1j6NR4i9X2MTmKlMZ1ODAVm0aHyrp/BVQYR7uN +JsYqKvKAs0jcZZQoDbOWOwWiJH09dDY9lemhrE7jJ4twWoG+XixAsRttSQ2qdY4CLJRI35nwILI9 +pidPbPlkq1I6uvHBVivIx+9S6NgIobKmPsIdGCg7vwWkZW7UoRYdHg2rOjnxadCJ8JRNV+FGKlyF +TjWo2pMBWPYudzZscBmzPogyt3xcvp+QCKfx9WNsqtZeYxOfLpM8wTA2BQ50bMLYiijSCyNFHYjO +5CKTfYvUGj0ej1nX6KtsD899g4QzrbdqLeuNgzPR93ibuV1kEo7Z6Sv2aWnKIsqEUCSEJAvgR++K +WFD9GMIrFGVeeqKv1HbW4jXyTd9XPkXUrY8KSy5Fnyt09cWl6Fk/XEHFpYiyWNDlAMy+HY25BSRm +pw0fvBVQ5sh8VzVu1+S5ZQ1Kjfl5GpmCokyRTtdmQZu6iu+LW7EGFc9iBfShfGkU4vI6+UIfkMG9 +mF1FACb3Iose62wHPXkA9cMWDcDkXsQQUVdgiuRBMz8gxb2YdREBZvcidq3RXWuKkqF+rQwq59L3 +k3Zt2tzsXfTJeIlFFe8iCvZaPazsXQSo18ll7yI4e5rv4F1EIGnUIbJ3MWudACXvot/TGnE4Az+4 +ATotEtcX9yJKhqQtz37D7PTLIH4aNOh93E6riHII9f7BW5EQenAwwuns+rQBioPwSxvtLTsYC6ir +HIwVMDsY2RshySmEMbmVXeVfTM+QAMz+xeTcJSj5DYOaRgoo2wn6cTOt26yg4iHt6MsDyFaCo9OJ +ZPciZFCIUpyGy2dKWRWg4l7MIpzvinvRJyUEIFucQnymBFAYpD/K/oAl76JPzxCwRU2+CoGqQgYV +xG+7STtVwtFbX/TyNm1b8S76fMxd8S5CCfe6Ic5tQYp3sQJm76Lf82V3Q/bfqSrE3e0qgtSndk0W +/fDwkyAzUDcK3gAV76JPb64F2BSxnM9ICCqOapYtJsi21ZVxOuHBu8gH8Td9LF7DkHSsDMpXhj7/ +UTsfc2/J6hWSD3201iAXOqa9S+7FkELwBZTdixVocC8WYJ/diyE5Un1f3IshyY68un2Zr1qnQPGT +iB+SzRSg5DesqEPtX2QdwLqdZwVnBRXCzdBvZUbNYGyiY4AML+Zb43NvLquRY4ZaF/cWBq+ynE14 +WrurlAqDalXuKqM73lfuKn1ByKVncRQBkgqqpNb0PrCv3FUNzXCcv+4an5BWIH6KTAB5d4tpzKaI +ktHHmS9m+dmywnmaST5mZOMI+bBM+jKzniw/V5BiGKtgyXyIrmKm9yaPGF3iE92wAJPIeDZZWshU +Ckl2TZt01gxKX6ranYF56VTPiffZpprTJUyAGhuQgQoKLlPkkEZWqWpEy2HqT4Qq2w== + + + hlFf0ynBTAbkGlJOugJmfxVAfaIPMR8WX3YTVEzbNp0cgMkEbpPo1xUzuc3cvhs5rJpCgAaPFV+/ +19/iFU7TjwZw+lpdJzJoStbkdsVlpc8Muazssiqg2mU1ALOljIVZASjWNNZj1x0frG4mk9rBZWUG +CpdVQm5XAaV94wvR8eG7FO1D0WZQO8k6KRaYwfXraLkHgUw+K7grvW5ydgy5QTAYfFaoptqmdibH +yykDJCjHenlEwhdQ1ikzRR/a4cnLpDc+GNZRXRk1SzLD5DQCkEto0xI0QU5eavqyy5JXvSmaa2ay +fTFmplkDiwhSDiQJqV1tVM08uHitYK4P6aqUoJE242f2WtWgCqMKcMA8JaIj/EQJ7i08Zm6gMb7H +gsflVmhUyuhG+aQNjK6U1yej9ce+uirFbcWMD+O77ZO4XjHwZKXkurLbKkNqt1WBZflOw90q0oQR +0x2rxVEmgqgvlOezzNH5wcVqqyNNn+ocR4cPC4W1E2LsB75WA03jw4i8w6vSxREP8IzwnvAKr9m4 +KpZS9ryv3FYDqPbbFGAxKprMnwa3lWHg7Ygl5iQXFetMFr+Kvfp0SiPeXK5OPwol4Zu6+uOUDWzM +/jVXxURMiJRkR+IE33OOhY5os+5cBZOMxZjBb9XgpYENIm1g52E9wjsDua2i5DZ8sd5HpkN0vWhq +eDHOTLBdJ5842/Yd7Un9kJEVqVphK2r62n7ESHVTJ3MdbEXeFRNMMrZorrlid6l+9O4V2opeeqKv +0FaU80e5thJcs1TsYiW4Ik4QVwLAYm7g20iABg9pZOoogCryI1wqtSsOVy3mDFC5HMwZVEBFZWNa +tDjy6aIg2+RjR+syhyixEJqdL46uqaN3mVPO15n5hXRh+dIPoIo4DMBCRDRyCaBMaRgc5OKIHjl9 +CRwrupXykcSKumncQwYVLdkOsLx66sRyZONYEBCbCdBBkM4whYCBAFLIuTMJAUZkv9cPK+5AWwJA +hYUUSM1oMjALrl4T9AESh7DRVuda8zbNJglg4YHCs1O7wildJBK2IzarIUgZWMIe+My1/rhjLNdo +CI1x4lQqPxqNGQCWeBbNlcV15aiXAhrFhxRgdl521KEBKc5LjbXglg/ey472tNHRpBtXnx8TQRRQ +NjCQ303OXo06Lo5iizTtkWtH4VZIW0tgFl3DHvPcEJSkw5CCeF1bia54kexTuyRshpR6h6AmGQ+M +CRUofcq30ZN2XcLhoTe1tnBUN5g2NPFNPTs1enENbVqDGnTyWrNJjx7t0a7gSXQz3T/YI5p+G8go +nupEgkjvCb+z7ArzXxvT+Q72GNUGiAcqvIbh6mXhtQbZypyYgRn5Qnr5XaEoRnXdBJUxO+NGKI83 +IDGMLgae4VgzuVUw5YTqqqUNKKg7fDzcljJEr0me6gsuQGtSf8X61CsVbIv0WoHqDRiAbdp19X1W +FErmQevziJAJMHb96FZlE9XoDBMfq2+VAMPW8WsWhRE5Dvr8fwtI+0JF32VcE/2IC2AqiaUO3CLs +aSXGgaeUTR8YTw0qDKoGJkYWUjRBxe6QTNFkDl3Z7TSV3sA+QwqxqphsSJFoIw5dbk/NoUN6KDL6 +WB0ilRAAvAuZQw+HrQFVlVCBrHOZQRezO43Gk/WPZZkHO8x0xlaHelRb1Sp8cCmtSIU1MA9YO8Eu +JCdNhGgw8PSZbBQDzwCpDDwFmH03VWdNq/tTDcpY12ymyZNrGNmmS0gErLLSmKZif0UziFW7omk0 +bvJxBwv/eIhykeqppBQnw5RdinOsFlaBRlHJBZgDt0tnQ3R3Zkx1ELg+XKvOJj+jGp1g9MZObnQy +eYyu9ACjRTPB+oS7RM+so2rmpAmQ5pEMJMiYhJjKP1RtTReON6CYBlxqVx7/qFoJnC4y1gAKQ7DS +AOxywLEaGkZSrSrLE+nXaC7cWkpWv+NIlm5oCBpd82FTaiW1RRLKLSD9RFWHeB3putHVd4lPj66+ +0xzo9dV3icVzsTkGZQCVTamBBaH0mWa1xfnp2+goXDK2VkeWLU3VwbpBniKoXKgJTiAaRG9nh9xo +2Yw4wpNiWs3MpAYyCH00sMoVo+kxrfJ0GTYR/2G1tjVxsicDqNq7AVjubBKecBJd7s1l4u8qIy+t +CKOTLUsYzj9lbh0jlLo4Rshjka3UbQGZhqvqEKb/wq4yrVRnBqfXFDIbm7wK9e5ky3eFTzWo7EkN +LIQ8d5Y3uBpzOIdqbvm84G2Y0AmbpZAanarV1yjhaAkCiYIXegqsadmIuxXjTWc7ES9kuc4hHAMh +md7KWnrUaXBNpwW/HfKy2Ni1npCmQQ0ExDjFjkkymJaltta4HXV3irHGDW/w3fAG3wwP76sf3atM +FvDSE/0JBPbYsB3YY8NWYI8NW4E9ts4VkAN7bJgG9tiwFdhjw47AnnG7Js9tHNhjw47AHhu2Ants +2ArssWFHYI8N08AeG6aBPdD++iFQRgN77JA3IAfs2LAV2GPDjsAeG7YCe2yYBvZQ0a0eIzCwx4at +wB4btgJ7bNgR2DNq16bNnQb2MLIkTAJ7bNgK7LFhK7DHhh2BPTZsBfbYsBXYY8OOwB4btgJ7bNgK +7LFhR2DPqJ0G9tiwFdhjw47AHhu2Ants2ArssX5HYI8dMgekwB7rp4E91u8I7LF+K7DH+q3AngzK +lqF+3CwH9li/Fdhj68QBKbDH+q3AHuu3Anus3xHYUyxuikjELb8V2GP9dmCP9VuBPdZvBfZkUEH8 +tpu008CeYgkdjJjWbwf2WL8V2GP9NLDH+h2BPdZvBfZYvxXYY8dv6TWwx/qtwB6Iy7E8JGDojvU7 +Anus3wrssX4rsMf6HYE91m8F9li3Fdhj3Y7AnlE7dQNbvxXYM1prDuyxfiuwx/qtwB7rdwT22DAN +7LFhK7DHhh2BPTZsBfbYsBXYY8OOwB4btgJ7bNgK7LFhR2CPHRIH5MAeG7YCe2w4P7CHMpX1OywG +GXhzUMp5l8cWgxEVyEq+9VsWA+p17RSyZTGwOZfEqLOpxcD6HRYDACcWAyLl2GKQQSOLQQaOLAaj +j9ViMBpCLQaTqaiSX005WwKqhVWgbYvBsE9VZxOLwWjPs8WgOptsMRidoFoMMqi2GGTY4RhG3Kkt +BtmgNbIYTIEx88+JxcCGLYtBtpmNLAYATiwG4F4TiwHNclOLAYATiwFv5dhiANCWxYBC3NhiwKs1 +thhk0P54U7YtBlOgMqCwZTHgsGOLAac3tRhwGWOLARc7thiMNqUGTiwG1RZni8HoKLLFoDqybDGo +DjZbDDKoshiMcCJZDECytiwGk4Yq/E2BsY+TgZNIErYsBpNl0GIwWq1aAkZ7MoC2LAbc47HFgCcx +thhk1WRkMRidbFnC1GIwQSi1GIyQJ+vME2BMMu/UYlANm7V3Tm9iMSisbLAEVPhUg7YsBtXeDZ1N +LQajc6jmNrUYVKdqBw68bTGYoIQaB7J4OwVuWQwyrFgMInLidN70VpinR1RG65ldUuQi0ximpAzC +aJAYvkF9ociko4j9iCISolKOYR7IUSiH2w2ZFOotJgQzpKsxQ7qaKkVNraK/OgPCS07zlcZ6sGwf +MrUP5oOg5VYITPaDsKe6jSvmA4hHXfqymA9CotHGZfMBUldTHnD6ZlZB6hRMoPwlYxRH7TT6gZ0l +/5NK63kaWZgMLnWXzAchCfoogNBnr/EAKuaDCuhD+VLzxWbzQdJqARnMB1kTZK0jE3M7o6DBmTuA ++mGLBmAyH2AF1OJcNh+ElErIuMp8kL1lxhXzgVYgVVBxg4W0gMF6gLOyYdJM87obV8wHIQXbYFHF +fACgfpmtB8W+44r1IGiZJ4KK9SCkKHFWx8vnon5R44r1QEB9q70N1oOQnigD2MXsF847nq0CbX6B +7irrQfEU1e00RxCHUDbUKn/FPIrxoM002hXdu00v27FvyXhQQLYyHlTAbDxoy1vQbD1o9U0oMrQX +40ELayn3oRgPhliAYhVoU0S/sSM3dh919ysjQ6+3tbJ+KC8AqBgP4MXV+1SsByGlGNQSUulMY6N/ +rKwHISlHLKCR72R+Hl6sByE9zgeoWA9CEqQATOYDRF5ooEIxCwChu24AFcTXMJmqXeaBxXwQ9lIp +bTuYD0I6Z1usByEVmwLIbUGK9aACZusB+kq7m4wHGDHNq1aoU1VDW4wHYU8bmYEABqVKleUARFej +o4rlIKSiQKyzma9t1D2uDAe5rh+ATZ6ZpqBB4Y8kZrQ5OYOpDAdtvsJ1O1ZlZW/JcNAm29honSg2 +kfAjGw7avY6yA0qVJbWtAg2GgwJ02XDQJhsJ7l4yHLRZjHRKHdOX3qfbnQ0HbT4OVwwCFWEYDAey +JTTbVu0Qk9IpwWsLydZ0XGRDTcF6ta0ZVwwHIddqcMVwMGWl24YDn8JsjB0FVqZqnW4UWNnojrsq +dWOKlXPpCYkZDErjDDWska08sqjTWsSzzkHX6/vycQK7VLJ9nMBOZdjRxy2Fc1MnsNPEw2acwC49 +wq8T2BW2M7ypH0BV1PEALDnsUs3eKoddm+ts1Tns2i5xLLWAcV02kfshiZ3G5mdQXn9CwjqHHQvV +KO7X7xUyBa2AavozdSK0NpHGwcrQNr6i7lntTCp4ZbTIMWuDZWOA1LpuBg5J7BIHqnLYtU2j06iT +2LUmf1meMCSxr05Fl305o9jKJrRVuxKbnzjZEFtpEnZUsZUm71EdW6nPdkydK0xfD5k6o1gB1bGV +AzDHVqriaGwVW6kPAowdxVaaTG6H2MpmIHPFrsHYQGNHFqA+YdHo9Pt0FevQSs35ZsaZ7DJDqTLZ +2T6dfygW4iIY1JnsUu32Ovuclik2dYY63/QVqNjR0x5U7WI6xqE3zedqxrnsiiQzzE59faZOZpfj +LkfJ7LosedW7oslmzCR3WbDbsCKBlPNIImqdyy5RinEyu2xwqHx5bUZQfawyBlUoVYAD6mXFv0LQ +TPZHiNyG4CYI3xZELtdCbc6jO1Uch6PAShPSQQ6BlcNVKYGV1C3GtzsUpK6s/1lTqQIrC6gOrByA +WcLLe10FVprEQ0cSqYm2H10p+Cbd+EohGLg+6vRp492UygZmFpnQ4zCwtxEwJgY3hFYak0qQZTaQ +StaP2UVg1c+aq5Rtd1Vo5QCqQwsLsIRWmtCMGV5QEW/MGINWs64ZKFzCXdK5S3Rk0xYNu7pSenvG +Ce30kWv1MTIEmsTLh/cVaTtHzzBsKq44SBWqV9Sih2aoHy1/KsxsR1baQWAufhKbPLkVQtiU8KlC +GwjdGUcqPwmrJNZoCFE8oU0xrw2Qyk9SgIOfpHQ2+EnKoINzoppcdmLYFFRdXUubkumOrnT2p4zu +dPaojHisSamKKj+JaROhr/0kWjKxmrJjSbTRwipQLSYMwCxNlM4GkcNkmaaSTIzP4kqRYPRl+kjM +aTI7qB/Paqz46EpXwNpTot5LSvqVwdIk/B0Bldu5yrCdVMKcfZkgvljj1R8M24kBug== + + + yrJdDEeDZXsAVZbtAdjld7GaMW4k2Xqmt5pIwKk29ijVMwvxjeTpVEB2LIyXXamN2H02AY2ANhlk +BtO2Jtasbr/NWmJ9/S1q4o2vf7Ypc7XZtj2AKtv2ACyXrwtJaB+M212m1pVtu+uzhJ6OzCYXbnWw +VmvnFlC+U36CE8gCQIQaPCV2giYJ6Pk8YAqMya45jJvqmNazS4xgvIpU8LZerNYWGG3JAKq2bgAW +eqRZvngQXe6tKHLFVQJZzU4PtqxhOH7NSDZCKMuCX1u4o09uJsCiFpcOM1srgzYm22aLowRGhLwG +lZdM8j1XyFSDyo7UwLRzQ2fD9pYx62PIGFEOa5AFypEaNQy7kZukrLzGhyI3Dm6SClhTshFzK24S +pOBsYsN3r6FjpTgU5XR4TyWyQUvbPSp2oU6X0A4t7RxdL+ShFywLkYW7zKTiUsPC46MEamZSkGAo +PjCk9M++B0RNIBFdcjtMfr35KhPCfrfZvtKIS6XpdFPBTJ3MOGpkLtCiAUKqK1CFMWG4piTNsXGk +TY0Wny5KjL48byodxjDHSqNlkN0EhgJf1Xt3hTZ9iYM0nVaqbdoSt6im4wZKTBwiBpWxMzVxU7Kc +o0D4TVZ9tX1SIB2LuxZYlihpLCvQ8vTShOn3nQvTYfQ5ZkNdxgzvIEnPUXDP2hzUgNrfXF8JVE2Q +8T5kYLVhubdhWzV7xXT7O2fM9Jxir9tQn6c+by6wvA1Umqb40OrydgCRyhHC3mH9+RRID3AG6iTV +6A76V8q+sCYNE02GIWBQuT8TUrpqvzRp5QRCzlNvIFJg+hz0p/uH8uVFQdZjM8w+M3zpFKaZLwck +MOQreUPVtJpAWbUgYmVgvkrEwNHHSQIlWxphNDN7dpWBKWh/pqSy1fvBNKZ53wqoXn4BDtE0ijbk +Szkxh9rpyZfKIiwfuI9OxvIF4Oj8kuiXQPs1hZkcfiY7XU8DQo67UnWwburSC78pkBG5E2AqzD7M +CNatthvN26XXwFgfVKRsBVQ5CSlLTbaWqaVoL6Rdq0H1phagxoNpb+l0TbFQ9wkzhpN0Wf4dThyW +7HTiGS9SzbIRThXBosYpl4OT629TvMWAti57iWvshriv29QO2WNUJBiuygAZFj/ABp1DFQdUS8kV +qXwwdoJQJTF/fTAh7Vp1fBqbP0Iol5M/jxFKn2Ajr7x1Q37vxiWoTSZybjHJY6e5e4hMKOMqoNij +LH0eRssKIFgkCdF0HwTyRaw3p+Oh72FMMPMBjWmj03z7Nb3FfhmFmZCjinyTWGpTF8zT+jlMEV6w +RYtQMJF4k/XFAqs4xwAtHAYdKpse+FCybE44liuXdeBtOVtTzQJdekswZqFQC/p2ykKdhmCMP1cH +S8rKm0DMVwQQgyNTjxpUgXzsQ3Et/QnygAav0rHR6NE0HdeVvo7TjYhpLvXO6hvlRpQvCzdSvrCN +Mluv9ySTnVanE1qtWaGmduWNrc8GUgRRN0YRirJ/Md0ru0ZutiZTZVpBG2aKLoIWI9IaVjPzYUxc +8XSJLoAJdU2IVsxZP55M7Gbfzvzs4bVU2Tv4XPQ7lXJ9fI1Agkp4EYt+p7/UtcLlj0MZ8Mfajwkg +qliCaZDYOfcvMo/CRT+kRxRfVJMYzaGawmgG4wlMxz9n+HNHz6Vwz9kzo3tmRCZIddOpReLUU52G +7NHqQhj/lBrxp31qFFna4J8yjUnN9Ve9lxqRUppXP7ncp6uckNX3ZrY1jjS/K1qMwNth1nqFYzox +7TEZTmONBQyEySstmR5yjE15q1NWmu5xN8S9z1SVqprrr2ml/HloXn7KjfhTMmWPvvezrXHSSn+s +W2RVtfx3QYYfX/39uaHefSXiVyIoBX3yaEfVkuuDaIaDkD+Twumn5fyPro3RJ525HEFsNIcPzr7C +vtRSGghb9uolR4MaeQu6oHmNSDs+ltErPNwxPBqM0LjMHchY8A8LaYcdqDBxhIjVlo3PNx2K6YGd +XaqaMavQI7WMMnfnQlLJZ2PsKoeA5vVJ7/hYRq8QZcfwaDDCszL3H51Q/duiy49Lt/6PIOd3IGUV +wS4dVefSlHMZk7GETG0S2ORQEEyUmGnCgBG22tSyFU0s6DBTYM1gtz8geuV+iYyTwRPXTWM2irrB +jrC6SZ/03tk+YeEWtGbKuz4xu8bYtR2FZ+/cKNNtwwsL2RJ6EzsxLqQvAhyGfhD4dh+GzxjcKgrl +5EgJL/v8iQm9K/sxgdYMescnxNitMQjddUJNwnrsJrC+taMLkVWAro1Bw87jNrRm77s+8TvH2LFH +r0bwfH1vfhr35hXIxq9v6Xe6pd9VRj9/u89FoOlEMwJNt3Qi0+8Yqb56W/LS9KLuvthbctj2ZwPZ +2HmXVLLbunjbHU8v7DlXfHshWx/uIiY7tyjLhTv3bsftz3LJjkt+7h0/Bwt23octaWvr0M+5eVty +3I4Pd9zxnZioMuLWzdgxxARRz7mDOxY1/XDXbd+5b69E/Xl9s36aN+vH19Be3+Pv7R5/R03x3BM4 +D5+2uem5zPSza298dev2+vTech/jz9cvZm8LKMxufXB8Ort++wPjHs1PTxfr43qan744WdyYvSUN +TR/hYvJ9aBojG2udzN80CMPrWGhArvUsRi711ieL+eHD+el6+Q/5ctR5//hwub94vD8/XB4/e3+9 +PPho8UIHkM/urFaHbB0eLf+xOHy0WD9d7J8+fnH0ZHX43vH8yeHi69zabM/7vX+crNan1YyrDksb +9vL+2fJgsdFW78j/r/Wz6zdmX/zp2hvStPnqveMDHZO/+6/uyIYcJ8j1z2VGq/VMpn60uIEwKPn/ +F99qPNTZOCxq9uwaK4fzv1+8kF8+lB/+JiB6mmZf/rWZHcj1++ITyN3pjWTXwoemluZGX0R1pbpG +SFmVOhQsTMH0dA7nr+5CnEoPSgTW+/R8SP2TAnEaNTod7e61pzKRe/xaTbhtpzV5qRPs2Qg3YRsR +TypqT88y9EYhGqHdaNx6C1JmYC25iVp+dEO3LfL+y4wiH18btrId63jvqRO55UsafoZnYEhVBFjv +mPJqz6XRcqY3BPHp85k2VX65i5IY9JlzPB+EWNoULiSTpFsaubzguWxRMs3iG+awgvoUG0wkzphz +DW2i0VeveA/cwVkqANaGvnutRcwlNjgGTeOD2BgGAsQWaZS6GZ7Y0zMae1Xx7l6zrJeMw6QTWMiJ +7KnlWbq9ptW4HKtpcTqvYaY4TKZUC2yVXmrLpjCndJfeicv29PpyihDb501k2vuOtXCRgxL7hL3r +mOFOmrOuNcIIqvGQpI8u8Q5FyxB/EGWNfJEjkMDcVx0zEJnReH2BIXMlHfsmvfyQPdDKCjlY9Wbs +FA3vErV6rk+2ThMAGbwNhJMz4jkUv8ObIDwDi/DXB/0OeI8YDTkWZ116ZMx4g9gkV/gWKgPJPd5M +IWQrRmH0HbygPqRCXjIHltNmdUYecKex0qiIaIEVnUwXHP4uPuqYAl62hS/nvU2xYB1ChOTMfX73 +MCwXg/NVfOz0bZrPVcoiSh5F9jKeHuYM1NOqzEC4iJerAPUsXo1MzK1QXpvmDAAKAw8fCfbLdbp7 +TTZGI3gJkZm1uUwpfsCTXfwhsr52L2fNB85tSKWq8LXMp3X6LZoIyrQ2pcXBriPETa6HSfnb2l4z +nqFIPB8a45M+9LPQ7ekYXS/Cyd1roUtZ1WR83OWQq5PI70hXI7/3Fpje4skt+GsAuWBhba/7Bt+2 +UXIgwpXF7wyRUPLATxA+AmxvrYICsD7qN03vCLCs3YNFiYilHzH2FZWeOTObXpm2QDvhxAAwjhmL +9F6nhsDjmwFEW84qpESRodVC3QFVEKQHLApPIuSLqOGnAVEUQfqMIvZhkGA184B0pYQsGI2K4Tf6 +piQ0eAiEXjWoC2Uem3rPPA9Qz0VTFnirJZ9aPN7HpgUEp3mgg5Y94rgYBZeLoWzSvbdCp6NPef/l +yLxzRLvYsz42UuY4opnTd57Y14BHNjHnAmzTyy8ADKLLW6+PwfmRxra3TF3JjvWZTYuwvRE+p0uA +m8GySJq8qNesB8KuAqpbM9V/k4rFhfw+VyBaninkUu3OaGoG0D6X8vBbFOFFp6Eh8VNIz7JO0/F4 +P9sUZSU0k7mp5H6WxM26P0IU9Kk/0jlgDwhgcRnEAPJMhVBqNlJke0HhL/TLB214YNZJm62BuAcO +IbCCaEZD8WQHkLAdkZYCirk2BB6KBuSdY2b5qIGPAY9XoiXH6BhfBpBjsuhe3/8FxA4xLzwqWgmF +SrRCPvGIXRMkxKZ0rI3ZKOZi3zgwaCCYHCt8kgjd9HgNpf1oLirv9LhY0Iw11xD1KTfVR31chI+i +Phdg6VQgtYgd4KteiJ3Ws+tJKXzQguz4pNeUJR6ZBzAOJoVoNt/qxQOAD/OlswY0FyiQ0gH4XC0i +pHSz0ptG8MrF46NaLX9L3hc6pcWBqSNIG2JoScZMBx4FmQgsAkjXUD8AlWZ+tpDLQYBQiZghv7uO +ApHTd25CNlgHAt/IFYMYFlKh7lYTdQrlEY3H6W3CHcK9Do1+gnjERkA+PWlDH8BDGV+kGUcAq6VA +AII6iY8aZT2REpXSNhIKyES8tyBIQN6IVz3Wp03gk1jwIRKIVulPtOmJlgACsu9FljkjKgStNBCR +pJbXNGqZuIgCJhiYAEGJGJVx4Bsk6pB9kasQQqd01CMej73wnK02jkxbqwM1mohFPvIMvwZyIOBM +OlZcEKRguGU1km819TKFOlbIo5aOflvWvAu6Y9U4wFyIsxGZOFkW0Ct+slvH+9DF8SiJQAx33WlF +G1BELS9KM2h0vJa4qL2+LgOEFUmFkni5/6DNWpui066i17KtermZRYa0uZ8Nv+fTKd8In1MMZckf +ubrgCk0qk4PgxMiEabLxieyAUPcdsY0QEfhjk8iUa/XRU2yGIkwoxiV9epX/nFdhqUUKd/baat7K +NmUAycOAJ4OW4xunmWLAgxum1uySoOGUM9wUfZl1WNEihvQN0z216ZmlS1W0A6oO2WE1mYiCsJIC +QlzBOA7GGtlqSBUQLmBWISlrKQQwuYtvVRmCUKAMFFIiiqCBJYkY4VPYMfCxEfo4HYHkvEweeQl6 +2tSZekBB0TDjplHVCLxQc/j0msUbilWkHHLTNgzebZkw1DGlHB81tEi1yVThk4E4OrAbT+YTvsng +gpkcC4eo4jzFiGhToS5wMqdsvu01D1TXaGICfIo7CukWChK5oqNwywhUcLxInQqyPZNYdSxbGCn+ +NxDPcJfQhd0zyJgRUzYRfJKeDAOpmWcoIvFN5NSEznYEML0u6ZThfYtIUuzYhkoybg1IApbDcnWT +DSAitJqZBVI7pW8gKfIvyWQN3qZ5yAn6O/PngDGCDeF30ZCACI2m6YmQH/qZoB/q58hvLd6OTQbA +mMhng1wDXYdk8lBT+PZeZJAusYwcstthotB2rYpZHZCsp86ZNMsupZG2ibFC6ccz6A== + + + 6Rh3+QqNdozQpXRJQHlQuaMKZJTtP7gmBFzDwqG2IG49FCpmFaMHMdRkJAuIcu5UNoDIHPCUFZqt +3g7ewVTc22ZkDiYlD/CNyqihyWXIhDz5jkyczBEtWNZL9rwdaobILB3ua+ATb5dSEAPAusOuZK8A +iO+BYC6G9ZEiBZMUd0zt4nNWahs139PdaxCdtNIHtAG5n0iBBAMDrxiQyfTpqQBIFTVt2+TiYEaz +FliTnjc7JHaTAXmeLA0XVCPmgWq2DZbnkgUAJ7pcAhLx9LZUiulVd7h7zfSZGksbTkXzj8nAVDUN +bDEkvQ01E/nCpbev2BaR5WfGaOYBADiVnsH0lmSzaxoca5/q0rpeE+iD/2dsMUIskcZCj9DzUbJs +tUxZyxun1XjyYJ/EOyDsXp+qLkcU3uMWULbSNqTglsWpFMC3EIa0xbPbzpKqGmAc5UavkhieK2t9 +bFiUupnNT5OAyImbNbipNERBrKVJotWshN4py4PRq2FWtbSmu7TZaeU2sHrsugimNJLwSlBn7VOt +zHy11GanKSQElWTbHI0e+nJQ9o8y1k2DGsuNSuaQQ/BZn5L6SyPjmIo49Yk5uo7Jo0uNemh5Ohyz +jDQqw6Ts6NASO5WMiJaCqJrYK2AfSMMAc6nYMZN1yA3INYZp6EA+PRoD887vp6Gg/EFc6lPKeX0P +xg3BRgxTBPHX5Ae4DlqMps+JGgWPO6O8G3lNCUkF0dq99CC5T9zDpaT7N/lQPqocYVKeV6IJcLlL +YjKuMosg8xmFXhWrqZJbKj3EEybp79TupNqP5g2yNBvly5Ay6XZcGS63pjN3UCySJEIeaPEntilJ +z2DUVXKlRknTalZ2FfpSqrhWNXFA1EpgupR3LitbN03Um41J2vxGKeTK300q0WFwWo0qdr0mwBRJ +FmKJSrIpI52nXYO3S3MwdunlPaQcTaMyDBdyyl1MCocWIHdFBRgIG4BYTY0iHQUdLbikAZherQjo +KCUu7ZO0UoazjRZiVnVNc2FBHuJDlxBy5mKnCe/RhhKmliRRI2dUuQ0n5x2NMX16ji6YoCkyYL7h +0xqn7jQqRiYl8cOxEpehGVl+12Ncq7YjLYLRZyEQsJ56kwNX9Gra1usmvev7elHIeq14g9dq3BWa +6TqFaeIj2MM4HEg1lCja32nDgcvH0pxE0zXfY8HaQVG9KG4WWhrNi04L+Fn0qOolBB8uRU4qGDWH +psoUPfJDGMp+mrelugaxT2IBqAGLmEBhUg6ZhOwiU1U8kwZfzUbvkoIuUqGWUrWNEuFhPPhNkVIB +38X0vBAIiS0QQEqhCoWsMYN4CSsxU6Po6hKS80o6bkHPTF3CKQ03I7qUxwU6SPQ2bWbP5DIQJmj6 +oiMAVEfQvmU2Gdg+mS4MTDg6Pbw+lYptkTKSxq4u0Xio/swKBT8EsAEWQ6v3vA2pnG6bnQGCdB3r +I7fM+27V9qa+lmGagtL6Kg04YxptpYVGOyZF8IPpQhZsnDJGqOA69Z6PaA1vkBr+e74ZU+Ofcoue +r4Vdunnp7VejRku0UkMxfEvUw/PFgyegUdSEMUnT70IDIi9xOYunSXJWIUcda5Rk45S+lEVlXEqc +Akk5sPa0UGr6CtIGxCkl0NRgLZK5dWr4pCvDwH6CI/Epx1T9USpHbfiQz5Dy05bVkCOAPmfFv+FW +mzZbGIDqMAszczhs2MK3Z55kr7J/9LB19222f6C8Lnxn9IaFpC6anI8EAChZxqtwmHYedlADzxsu +AoYW4XtG9oEjyTZKIYoiTqmVARZ2ORzohERG+DyQcQbyAisbJQZnQSmaNm0f8RyyayqzZ/HSXgZu +c3VKvGY1KVUOjsmkBblUrdqoEEoWFZVGwEeHPmMX2iRUMB1pySQH2gayhz/QQGqoOzun9bTxSa8O +BfxFzbOdOvik++CwkTZqPQDmRvIk+sxUCgkZMrrRHPAkfTbfZ5uKZ1R7YNVeYnO+O7SFsRayudb+ +MHwFOcsvqFVyYXpKSj4qgfRIao3fGxMHcQczwrGrIEfXJQWHlJ6IRnTIZcZVzjMH74pSULkx1G6d +VY8ipEheNAeHS1QfHOUaADrdOxi8ICE5m4q6RniiREPz0LowXziFaOGENJOmZ9Tm69UTq95eDt1p +Ou/io8NFxS2GLAYdV/ZKbqZw1F7lG+AaOtbnsrDhCboDO0PydzpNz+HBkFv1K9NTFuAvhdjREQ2s +WocdbQcsStOoqVpJNKprACAcpWt0vpw4DJch7x2k8rZJ9bLBKoxRa2pMyeFEGIqwIQmtyJPjPGHg +TQkJe7wdp2clJe0jqYVR1esdl4E6vM2Ebcr6XskqPMwt3PTwDiKrhOxGa/WRMJiA5higYSbS74MU +FfJDy1TGTNIMu03MSgdzWwv9aqE96BkaesVhvHNu2DQIAr5Vg8teYIllMioQ1sbDRCe/qnMb3ksa +UxoNPsBtYBEUGgk1AxqSCne0peiVyq/xByMNcuvQ+Rm9+twt/SJeXRky1ewqB3+GARDudRdhRIHx +qIcvvWfWA8gCMtosn22E+7Cl4tmQg9CxLlex29M31ipOdKCuHqFktPXSe0wRQOYbO5XLDN9bw3AS +YUfKmeBgSLGqDjNrnvzOJIFIuUczZwe1EIFB+ui7GqBVLg47L8JkolYKiklSBxVG4oPhA8i00Kdj +p7cSvyNUAYsG1oMktZW5zCJlghwsVoBoC0hMcCzDgISNT+2H/q06zwBhe6uyD+MT7IxJB/k1nWLS +HqV0cLIgqPIXmhVgSGvJC3L7VFb97jUIyT75BzvSZdh3gY4IAYBtlaiWygnSYsIthLdPjsqT4lpg +tJHThl2GsiG8FKrq+lSmA95t2tfy362RZcPmA0UQESOedxWaJNxs8A93dKtTd2xT6mAYJXhzy0WF +HQlWNYGIhAN1Cx23yWLkIDc3Tk2ljDZxrTqP2pTe18HQ5fhF70GnhZ+GWN1qpzNpYa2Xs3FB9wjO +HFEFYAIk7YZwJ0KkjkCdBCJaKz27VJALUoORuTsU1xY9OrCeGD4IyaZtVVhiDXMRWAJMWjJp6JVI +oEAbt0VAHtVc9fEpc4FvWvYfxBasPi0Cfw42L4I+NBgqA1eJFMue29OVg4ZZIeo2Wc19AZlJ9Hlw +Ipa9hBWtJ6fqELQB6yCt7jQxNHrCQijUkiYo5pExosOvSBvvoEaQjCETOLRgxzgdWjihf8LPYMFi +kVNbbhq2BuMQs1V2gKG8JeNm8hyXkiJkA5pz6sSj0Y1jBkUdiEO9rtUijKdTy+cgnpjIUB9AmKcb +v0PhdYn/G4hejdfzpOcZYV0Q6LHdMGB5tZg5lheM/B3kYzwEijQ6RIFEkgfEGGCzcUvLGoxuOldN +zRVyEdDRprz9TJNjuQsMjrCNugf5BWQj/A564dXhB8olSAsbCixB+JXRMDmnPkNqHUUbB5eoTIye +dIyLHHDyO7Prk2J4FNfT1LtEPSbuZ7pboF6viACJUbgdvog0T1qVqCEeuk4PzHkM3dOuApuJoanf +RlYVgeEDnJ4dqSmWSoFiEswSLWU9qKbgaiaoDAmlF6dggjJuBAo0ZA59q1bfXmmiobt0Rt8fXm9E +TWeVrdgwrzoiEuIL4GptUygYqyeLYChToDnCJROLSSxyHyRA365bZKQxvAaUWW9yMg0lsp6GFlgW +OoYRQMthZhmGu1kSrxx70NFYkAeqFE+QM6wWIXoOWSTh7Weu40gXHn1XqsgMahnsopr836jZ30Pu +568dyYDXABBIh41qgN6pWkR7FK+5WnxNSmmcKTnUe4rrXA+VapqCKPn5lC2TErzX+IOQRO3k/gfJ +YiYjmwLFgsmGkpSdEfFA1J9giAs5qihJ9XDgwWZdzKPQEeDfEH7IjOSW4YH4pk8J75leSpqAB5lO +zYIegVeQ/Hwy41irIk62iuHGwn8HVz4fEsGDAJ9tm7CaZstA81ORMhktDtZjsmG/17qlW04bdejc +E5Gqg0xViNrRNZi5YGx0rPvSzXryYZAsuRu95pcZiKbQOJ4aqCw8z3BEOTagPDPtnv6rTrNt5Qt2 +dM2mKCaBRNBB/N4pEYmgxEIRWDkOKSQDeTKtTBRmWqEuMxbCkLkaunza2XQIDPtZCeXVaNaslnAp ++j4paoZKYLxt1NrEDJTg+TFZZhlRQKbUhKSfUU0AVSIWgcyAHLg42ElHI6krV4VXKgxwjhwRlJ3X +qcigYe58BmP11XRaGO+CmqfhvpQNAIgRMiwcAmmoSQ6t6UB3NX3OzojvZoicbmb7q6OT1dnxwWzz +fH6ymB2tDhZVWPS/GjMOro087Xhq4RsPc7nQaMdXFYI6TaevQYQ5wuwCmeWnEz3efC/R4wG/fvXH +1fGj9fL4VCZ986aCGVNe/+HaH0/wl07/8ujwTP758ZO/yQquXb99sHqymN1Zn22ezx7Oj+fPFuvZ +x+uDxfrGxX+b6R/vzg8Pl8/W85Pny/3U8lNZ2q1ZmJ2c7s0+AQLc2m57Y3bz2vXxB+biL8aN3eyE +XcgHH38zP7y0vfY9bcouLmh//3B+eknX7OKW/Hi2/3xHm/y1IPrHx3LSz0ej3H0+X++v2MX8cHZz +dn8hLRbriz+6t/xGcKQ0OsDf2MW42cPVSW6SMGxXX4vj5dHs8WJ+dOvGbE9xRJBqhCHfM6Yd6PjV +Dl67LnOVfzYzlhVEzlz8wzn9SUSWWTu7/cFXd9ZCBg4X/PLB8olQjK/uPpaW4SvgDLfg4Kv78+Mf +ayW7jkeWoYdan6cA7ezW7LPj4/nR4mDW3prl/wpJusWnUrdmfLJjZsOjDlN+ari2mbloYS8/z4RH +k8lpE2k9M5Np4ky6lKDYMTXxjIoTJweezjU0O9YAUyP+d+ECvs+TOQ/hseqC8ecu3FqzGxzG4HTp +9G/pUEXSrg5012akn3+srTiPbF27XtNb/AoCjP8hb1uTZ8z/f0e8O39oV6gxB5ZNEwFsBu8Jp5C2 +7HsfdiDqHDYApeW/Pf9XrtoPMmhZKwY1HPBmC70948UPNO5wujrwcLY/1HrP44ScRDPDS8RqFvby +Wbz0bej1L0L2Hp++OFxsrt366Hj17TF/ERnz+u3jlfCIW3+Uiyxy1q3bIn9+s8h/vXU3Sa33l4dC +Q9BeCPryeKYNFHpDZcnU5C3RB259vtwsRX5Dh9s9PD6d73/9Ej3cmW+W+9UEVscHZ8vTq3z6zrXZ +rUfz9emOXh6frldfL64+C8s/HH68Th9Kj7WsLhu4Ov1ksb8SefAAf9RmaR9nml0T8reDHUC0Dssa +wV60vQaPmtquwVsf+Dat6MqiA4ZWBHrMaC8nvtdM+XiGXP/e0GGaiwqzmHA3++L27veQFkkky3vI +Bu8h0eqLA1nN4unsndm12fVq5pC835lxobN6L/91rJichl6jtLUfP326WZze4PzP+T5NUlvuzZci +/t7SmyLtFwmXr4/6mz0QvJ699xSairT+dHn6Xc61vHStJ/DB8Wap2tz1/CPOX+7gTA== + + + 5IrNyeH8hf564xzMqFiiOffszF73/ZzeZO/vHC5EK7360V2I9uxsWJvg6u5HuchkWq9jWMDQwznz +/0EREbjwfe0F+hq24uPzXyhPN4PZAg6u3Xki2Hk9y1jCPg6WC1GlO53SzX6QofI/7+AZ9J071W6W +OWAzi6L92Wbx3jeL448PDl45joB6xR8UR35+J2yaG1kU+9FO+GewLd7+8NvyiujkFffnpW7AtVvv +/WOxf4Y58A/8dpf0NzMx/DtIgP++UktzidTy8dnpdxFb8I7S+c7E1ke4lBBM6gPE0s4IuHeK1QgK +lBZFQoXcm0VV/oGFoYYCT8xgsUsKMnItNIeLaG8/JzEok6vXQtD3xiLb11LQaySpkCTrUHee78aX +/kalZA3YAgv7zxRfwg8hNPyc5UNrXovNu1D/tdT8g0jNITaV1Px4eXRyWKRmPb6RVWf+0ucpk1oe +n54/izuLbxaCfKunpz8r6f3HtrxeedP/ZRHyJfSSC5fwo5hcfwaUK4B04ek9jIiGMVCN7dvQ9QhC +QpQcYvh+HEKvut79s3/+88Xs4Xzz9cWKHtup1naunpfd4YNWd7HlOYXrzK5/IttztnkVMp9uQtJM +4U2+eBe0Idqduwmjvq62ETHvw+rp5vSGEgiGGP3t+PQEv/vc4OhwefR/h48Hn1QerxfhR2Hn/26c +/d56dTJ7/Hx+sPr2NVP9uTHVV3K/v+tOfP+itlLnEQZfRJ3RUNudS53Ht+FqbKrNAZ+cjfLA2Xv/ +OJkLsbizeLpaL2afL9abJaIOiIdKq5+v1v8EwGXAk8OzNbcGUW+Z4p/M92/oQjjG/mbN37dJ7qst +T//Skn7Bis3+4TqtUBHibLN49PjBnbQZBXwyXxIQilRwMF9/Xe/Nk8Pjg9EOf7NYn75yw8WrJO1n +kNpe0/SfL03/v64DXWLD9NSG8CwB7/Y1WA5PHPsfVwf6dD0/3ggdP7qYvZRm53KXqqOr8ZYy89P8 +ZQpt3YzWtdmfHy4eLI8XY/B68fRQeNGfE5FUosi2n391f45U8/xL00z+9mix3pftT30lzWL1zeIP +Xz063Wx39oeqs+nYXyT1hAT6ZHn8aLUsHaeGwiZXR8t/LkbDrVen89PFV/cWz9aLsip2cnx2dHd1 +sizAUXsoivPjzdbMPy8znyz2D/ViXyPEa4T4bgjxCq0k9mpWkh83Bi76H0Dmec0WM1s0N1CmgoxR +/u1QXAK7jlfUrxnjazr4mjG+RoifCEK8Ssb4E+OL7gcxBPx7MUWDqjmdiX3wnUGmYXMejwzKIpGo +7SYyZ0erymPf/cgOtNck8TVJ/MFpi+HLqtfk5QcMp+uSzI0MipC5WfoSuXo795qgvCYo/xcJyuv4 +3B+SoPiRhOJQexUExSFf1M8+vJtxxvYHxZ8f9fT/1cDG1/GmL+e6vL86XM6fLb56//FrB+bP2YH5 +I17SjDM3ylVtyn+/pFEadBY87aYNyPnasTp6h2KQof3r7OTHv9U/Kg1DGam+R3n73jL9JUvw2dA2 +rneiTVukZ+j7GDrUdhd25DvFMFQnrP6DHXxNAn94Esh3kJ+o4Dr74jUZfE0Gf4axea+V1Ssrq2aX +suq+D2XV/B9XVl8hkX4kpHN+sDpbv5ZUf+Yk+mdljhjwbqe0W5kPvke51vwE7QzmB7n6r0hAb1GY +qY38B/J+N0jPbWPsbR+8R9gjl8r8zCN5HAU1xunRuhKvLdK9td+jwH51LPh34wXMtTi7u1ofL9ab +mZ2d/KCvVHeKW6MpXCxysem54tako5f0uK8v9Lj/7HnZJ6/2tcV52fJ2IPn3kCXmp67xvLbO/viU +7kuBzs8OT//6sukAfk43Z3dGAuaXfe/4YMgue2mK2keiLInmyf149IRJpPpojZdl974nn29Rx9Oj +lE/rtfxjGxuPCgY2dH1o8QACFWZCNDDOudbkZVz/si6P8Ncb3O8v/nltCr/2aH/7QK7/6fnydKF/ +e7XvxwQ1hQWkmfDNe2NDY1kdDlZJG1tsWYyh4bCygZin62UaniIQSj508omzshDKQP2QbwuJuDBw +kofSfACpW7jAqdx9+OePZp8sDvJsHOyfrpX+G1SEgQTWO9c1rQt9xMl5vYuoD1bn9Jo1Q3d/Xhwe +rr5NPXa28zLXrnMOFWQbFAeysel7VCxErStmwJWFeFl313pCZFOCjIjKhV1D0ywExnpBbkfisTKB +99eLxXE5aRQa80EahMDPjG+C/FfONrhQ0uyg+FCdtoxrnBxvGeDui3nuvxdkjoIUnZHz6flViyxp +fexgV+bhNM4b2c+mbzxWzwX63jhMxPeh53HVh+WJXP0Ul8JoOm6Yz53Ds0XBJ9k02bvWeG+ZT7iX +WyTzk6vlA0p8cfTYNsji5hrBbj3lCZ7SqTk54zLew/mzxfHpPA2Jgs2t7LL02KFsDjfByDa3cswR +VZ6wHOmllVtjAirLWV4nPzpSLHkrldwYkI7gtybMHv4WNpo//7ZvZh/Jj/nOozS7IK9QliDz4Wrl +zqA+tnNNY2LTJ5yeXtzx8gkZzSbt9m+FdGLMP/+2CzLwMG7se4/cFb6V/e55kZ3gtJAwEDbeG1zb +pjcheCPbGXg2W1tQZ85D6TiUHRgliB6m0XH91TQwgFw223VR0KBjXINQrB7Vd1ohRCRrvVxGlDQI +ch+9TYffjlQoHP02Oo6JXTWPgHngNOr9cILY1olG18S+0WOQX51FqfTYdukYKk1OumVYf41xjgcz +vvfDuELCxsewx2XaFvjocGQcQ2hJwBn2rkGhNMImWLWTfva79h2IV9AuD4u4KCHZnexUh2riPAik +PDQB/+4Cl4qSn8EAGbgh3JJ69dyk0Z3od7AYnYZt0jxG2y6nHeS+ydWzQrATygmNFT4hxNx6E5S/ +NG2wKH3qUCaKF30L6eLWDtn6d2PzfuyeSPTCRXpQsMbnPOey6cJHGjDPjtxz+zrYHYkjay7W8W3k +GEN0HjHsnEfXGpRwbqKcjCf7MW1wprUO9TDl0EishP14oVYxolR4r9PdvgBTS4QO3CkpKiNnUsRq +51EuWwy+MSCoqJNnjAkoMdvrWvooZKP1bSeEueF6bYvVIe9mY9kGd3g7IfwIORMnB07KpShEwZXD +CIIEkKMaufidLm+a25M7MyUCcYR8zOy58zKWzY/1ZYxd7JxsqJxBHxwFkAZl3WXz5bRRLg9FzEUQ +wFK9YAK51ZZoQ9Y/pc1tzRmbfCu6Jp+FH02ksR0qgHpIctw/E+AEFsHGgiCl0C9UCZ3cgnbL+NRN +hIS0ARwY5GiEfLLv8EKLUGl6bl8AykdhiA6ZVHOOQlNn948tt7kGsErQTjJA5CP5rccVTmQbwbMG +zKhVQaYRCUQEMZFWHG9zgwpwnRFqCanOKaVArT5hVbJSpYBbCLF9P8OITOT9wFV4CCz882+Hg6D5 +ErUCHSS70It8TanGyphWuJRphF2oJXAqWwoVHP0H/UxYRz2wSgYWQ9tQKJIQGpG25HLJaShFFhCE +EsFKE1UuErWgFcwQucV0SqKscNMuOCtXB2H1e36HUIJtGG9VdS90MvX5CHbLZQ8oX8fyyaz16UTc +F5rpYqAYIPqP86ACQtBDopZCO2T2aNUpNk3EwV0YHHYysWbnvOT8QZlELBWJDtXmVRyJsn6R3Lzj +jZXb6UDXhQR1NtAeOyFGO5QgN742aRpu2B4XatIptEAwQXhh0wlmEIHlsDyiBXujPQr5EllLiJII +N62irwgzQBz5d6AS0W1RjW2VyO3aHjNsTxgLNXJrrZydXF2R2gOlE+FosiOivNikBlFhmiCrmdwS +zH8XHSm3xtbnYoMVsU5GFsLZc7FWNlaIiKhpco8srwOUHPB60/W8qzOtQDuqLLLNTKe1RpJ0gYOx +mIcf4QcuhVAHBzGXFbFEnRB2LPghfL7hRfWoBWllDOyIUppWVi/yuAjHoSV6bBc4CVOE8RM5SOfl +sT8+5HPJVxs2AmG2HaQ+w1ORb0UHEHYu6NwQGXDTgjBA6Q0TJC2LQPVOlGvfO2VGYwlHL7ubiOjV +FSLlbZuazAShsQY9C36oBB5E8BFWKScNiYBzEUYk6pagtwWh5unJPkgT1yK3tlXxeUICp3JPw9LS +NZdIM8PhtZwZLpUvWCSLjTIBUF6rReeEGQhhE/xrDaXlvdZFwTS5Q7IEb4zSITliIYCdfEwc2mIK +7UhQInJP2ESFVb5MrGBVA74srEcU5o6Clkd5S9kIYZrR4bkvjEhWhIQWxglqayinI22iKCUyBJGq +npUhE524hWAw2KXCuHKUcUSF5Ai9IIeQF5keUVlwSYTXaEWjAdaDxsixtcFAug4ta/7I70I9jSgD +HWgCEGBbx9tmrCO1r68JJI+yGyEZNTqY0Gw5OA+JNsiUEeBGTaKTQVDu2oFEkNYFuVUQhwWjUWl7 +l5hhRwSStHwXheRFbEPWg1yemAgZcstFpLTQ8jGNFjQD4kePW6YyL9QA2R/U3nVKC0U2FxFdqL1T +1dltax9bkkdzPomIgzgeCtMVAiCYHBvpx/D6iIImCmF0VFEj0Qzz7p0QBCOyj905/elJbZvVwCN3 +EfdQpsbTjDozTQdI2+RbMzUMVpbL4tquIuPHjYc+Pl7Pj58JPJnfLutl0nzo5/78AEUCHn/94tI+ +qqbp+2x21YcAj89OFmvmsNXZzj5fPjuGffjSns//EgNdGP46CQgobfnhS8USVK2H7fnj4tvZ+/lh +w+Nv56f7z2f7q5MXM3vpoi74VAXk6/LXF/RlPnr2yq3UKo5kIVGuU7aoygX2HhZNGHZZsUwINwih +qHp9Z5L5KIrAKLPFtfOkNcLbGoHZNsl0OyxuWybe3SyunldfpuVQWTyCocvtJecNIrcbVNwWtdsS +Ijyk8Q1sy51TrhqDiGiiksmF77pd/H4XL3ZjeX/HtLpCd9QALpqYERLNnRDe1UJ+iwZGb0BaOSpR +aT0YDoUGmGYNNDOZmX5UczeK3SP1p1FpbGxO2p5VLLMStUa0UwfBzBl+bGGnFMlNOEZU06GIUK2c +nuAaOqUoBy4nkmYHgyLVv0ldD4peExl7Itxtz6ot5iuR5ERcE2QWIYTallMTsug1LVUSHAYKXws+ +4GyV2spHojlC7ISFg4rRln62ZWgMO8179bTCoBdB/QR+YWZk1yKlwXZpYc22RF0RLzsY+0SuMzlF +ybbZYktIaXdysXoagwAnWNJC8GjghqFW3MOn5kVL9DClESK/Ap2ClRsZVA3Yuv7bhvc4URy3p1Gs +SZCF4JESLh6Tcm4b0Qs8XHhCBxQi9z7CXyVyY6+70W2pid0WTncTnN6ehi06YifSjJA+kWpxG2c0 +/vZy8YPIjUGlGUA8REbIkcnivIWw/cj6QsP9RE3aRQzzLGSXRZGIIvS3asKU32H0l6vciWDIeYlQ +IT0KVojMmDZj2+6/5U/bguzA0Mw27qyXz56fDozjVTsVfzto0GN7LFwwUaToNtAFQQ== + + + XBS1C5RRiDeH6CHHYhNls9ShJhNzDi4s34Fi7twst1VGc2oyGiYWw/a8DJBJsBWWYVK/BtbLRgRt +D78n9xAYL/+TZkKKYvKDdpPanNBNdhmoi2ly5LCREWW5ogRKp41XzUaGlIPphV/2pGa9HF4bBZek +nUumIDk80TjgU6VTh3LAlB2MD29kMjTbJ9MLT5JLHGAHp9rSodBTlGvtYDsngrhGblcHtUMuvLo5 +jFy/Dp41b9RdsYUy20x9qjCObIZbxjJhR5gCogNFZcDE4G+NgsheLp9RB8a2K8FvaTJTB8Z5PKDd +MY9Hd0roQ45weJmyvA+Wm9M6kmSce3dnNN3Wm5hRRYiU73T0dnASoL0VvcFJfJcaw6bRPz1+cfRk +dYhu/j8Za73aX2w2MsH9U1EkDkW+vv75AvH9IuIuj/DrB4eHZ0fL4/np4mCm2gZKJssfZw/n6683 +s79c/3Z5+nzW33x8uNxf/OUGNmL55MnqWH54f7F+sljPb6TxZcb16OevIm38vdX+2ZFI2ffmp/Nr +b3x1K/8+e5u/VXFH8nsJ9b9zuFgcPFg8Pf18Dof67C00/uLhgz+uDhY7v3xndv0fR4fH8ueb89PT +9fLJ2ak+OJCmt9ciy+tXP3AX30P/Vav958vDg/XiWNvk7Pv5r/jH6YuTtDnXf3W8+eqb+XrzTlVc +rm76zbCRhG/OaYf34toszWQz+u1nujvHq+PFFTbmcLX/9eLgKjuTW35PiPld1/VkeQy931xhbYIc +jxenf+QiLl9f3fp7Ov5/cSfMhTtxpfUv508OF1dB/EtP9ed00d/+5spXHU1fMUZjeftnm9PV0aul +ZD8cHr69mSNmFQxRrthV0fEHvxePUVT1JzOV/wu3dPP0258wN37F12ADSfNnfsrlUdJ5i3yyOhVC +Bjn24/VShOGrnPL2N6+WIneiv2Wx/FwUvhL6vuqVWN/H5rKlvLjKUl686qXcdDa27WVreb6AMeoq +C8otfw6r+nZ5wCJmly4qNfwJ8HwSu8ers/X+4g4MDK+c6QtretVTOFqczg9EBvpX59H/i/P4z4Nk +kbgKSlWNAcn5+G5/YMysWDZEfDk7mT2YHz87mz9bzB6tTs5OtH2Lhw7lm342X58+Wc3XB7P91eFq +PTOzJ2VelzZdZ/UzWG+781vaoeWlfT7jc40xb+PaHq0Xm8X6m8Xs08U/TmfvHSxP50+Wh8vTRAhN +6zpXOs4bcXd+/M188zhlihh26+56dXJ7vZjr49RtqWVCcspMPtjcThNO5rtBPe0aZ/bCLP2LBISJ +K4AB1z85O1ysa2aaJ3JvuTk5nL94mCo6CTLkAVDM99Znx8t9QYCMFMNoJZvGo9ufJLrWRhn3pv5r +GP6TxeGnq090aE7l0WqzxNr4V5uoXrDyEf9x1S/N5GbkaXMTt88vzh6fnZysYSRkxMLs428W65P1 +MqNx6PouX+dHi/XmZMGTeX+9PPgKgsidgpUg0PGclvcPV6v1JxnX7FAxa9rwD6v18p+r4z9UPMeE +8xrfXRwe3hWamad6bq8c/uOT+X7BSl+h+v1DpGE5xkH+99kcmDt7ACPu9mY1s6fadrGerc5OD5fH +i9mG71czw5jKnyMG8nhx+If5qVwBGXqx/uDepjqTc1o+WO3PD4Fdddu6wadQijBqwlLj95q9pqJX +X9/+4P7Z4WG+eKnum/y14HtZXlstb358upzJZszTyty5m4tTGF3kC7frVIjEmElIQ/vV45PV6V1Q +modyqy47TgrAo9M8F0U+AR7dn+8vbtP6fSmisv37A6k7fxJsOZrFpRdguCuhu3Bx7/3jdIuP7Bz/ +zk6esLPpcPvOafVppbuYKZ2cNn6MfDtlgpVh/g5VlMo0f8FSOa96rf78tp8vF98KPgtZPp0f72fS +Dtdjh+dyl033dF4I5MXbKoT9dNjRCwjfsJ+tNf6ChhU2nY+naDhBUx+6eF6/RKeq40soHwv8JgLx +5cPFwfLsaPbJYrM6PEtPdKf8bJfQcr/cZXL801nF9IZrAoL6cLF5PvtkvhEit/wnN74aLZOT0Rcf +n52enJ1e8k0zEjuytDVbSqu5MK4neEous99NicvHR6z8UObA7T04We6N+YJIPYlAuqJ0nMwPDiY8 +YSNkazI5oZmDIeb2B7PbZ6ersrDFlPRNBa0LV/r18Wr/ayGkIoutsthYNe1nJ3PE422WR2eH82Hf +LhUCK9Hu0raDFGqrZsxodjIXwXv/hXS3PJBJ/HMnffh0dVIRh/HfSA9q0pH/+v7h6sn88JPFydnh +pixrh/pZHIryl1vv/eNktT4Fe7y9EXTdfLR4cfHVxx18dDg/XjD5AUVY0I3FxV/xhp3/WddGIVGg +U5eQqLT44+XmuSDxFShVJbp+cHyw+Mf95Xpz+pJ0kYNy8kq3q2FjH6QPZ9rL+ijbBkGgpuZXnkXp +YWsSV13748X+6vigGjb2L7N4Qcp65dFc7cjUCb19YleeQVn4eALniZwnWdNaZRl9k+1w7mpnNSx5 +elhxUP5GY65JuW5+o0EDcgsH7nveNPcPlydCL+DI+IcomM/kjm7ycd4MmfBfMMkFqNc3C96sl7oR +ZXU7r+I7GLikLpkQkGlmk5dX4C/pLtP8W4OR6dbfVk/2eI7zw8NMaTfjNU6bb75enjyRJX49tWFs +9SvT03COC/tbi6az3iwwz/WNK0304v6ETxyWHb++LVlM2+dlV1N9pxgWkOjkw9WTD46frmaDjnPF +c5uO9GR5ejTHFZoKFcpj6uYnz46+3nsClrR6+nRPre5JKDy3+RGiZabNd+3luPOzzUJwi+xvc/43 ++0d7R0Ux2rXAk83eocGdm6dNcuc0GhTbXd08PT7d25w92ZxeeXPWlaK+o8PN6eHegVpkiD8ZyUYJ +ey5AEaDTgqc9SJuXYBWGPDk5wH4dHtd2mQsnd3Jw9c51IccvMyF1W5dRdh7hyTo1S6hm7M7tl2aV +9XonhkmTtK7My8/tqrbuh96f12x5JOSkPuwYzu1S29bX4Loctij/B7MnL2b31kKu1xfvGHoZtncn +Fu5P9uH8RvUKTXfxpA+FIV/a36pSpy6Y26TZ9p1GKwrOY3l6J919klwDFxG4g8Vm+ey4EvyvQH6r +C3LJ1pyuTi5Yy+F6rwglT/R91EVtRVqT1qdQny5ZFHtcPV1mrTjanX2uD/ZWa7zYmY9I+87BL6ak +6OqpSDDPV+t/XmFq843ylaKx7OzwJFloL0IaLuHZXr7XzbmtmOt470K8T319c8W+vrl4Ozb7J4f7 +Ly6gXOAIi2OoWgeXzUqO/XB+ctGI7G2TU8Jdoa/nV8J2divHdoq8kVf/QinygH8IlT6XKwrRhZFz +TJZ2bumpCKfZVHHuJlDnfjJfX3BFtN36orvJJusq9dolTcnaL2kD4XIpUtmVhaJLCOtYpiik5god +X0iWIM4cHJ6sn66KqnSFLi8RabTTERG5bEGj1e8Sy44Xz+aDw2snT9+IAAuR98J+hK6eMpz1wjZH +9PcUTNgpcPLa7x9vpuph3egfJ3sjhfCcAYULQjk8ljErc+Gu3p5NpXOzc283e5P+dveWmQwdNOfP +cGi57ZuYtjtcnkxth5Mm6x0Kxq528K/QvXIhGZCGq5P91SUNDs4uabBZVLPeuaGb53NRALMba7dW +KUraZiSh7hqPjUa8YOcZslk2GeRzvJpterK6K4vhHHJ+fLy64CrqtM6O91OPn+093pv9afFkdnfF +BxJ/uf74Tx8/+suN2Tf2Er3lSMSDSmzZJdzJ5DfJ9/otXK+Zkp2jAGbrz/7Ri4ukq6HhSmsTnze8 +tIQeU6wqY7X7dm5YKd55Yg/mm9PsVv7g3ne2fsDx9+jefThnjg+kqwvIKSaGpuXtx/k7JU09mmat ++vytyuN/up6fnFzSkKPTQXmn8ONzRmfTiRf9oqa6puXxBYeam96XjRdshC8sIeinz+WsZ/P1YiaH +PUtK30woLh7bbGbfPl8czzbzb4Cf8+MZ3vpQClitZ8DN2XwDsGbqlgGKq2Fv9tmGXco/x529WJ3N +ToTmz1bHM7ms+AuH1u6eIWP4cjTQWzMZrHx6LGudna7Qxf5itjxF4/nscP4Cbg05hsPlvjp/Nmf7 +zzG9D47vUa0ZutHRjgVFzmR2q6fD8MvN7Oz4a+QF3rv4duaTl67318uTSyTz0UF9crFwMKCKMlm5 +Jpcf6yeLZ3xrddU53KlU68tbf3qRhJRbPhKB7oMi0F3U8tP18qia7fUva6T67kadXfaqejMFK0ZR +RRc0R3qGe4IEGkv/0TI7BsxOnp2/enz2RDD9vghQnwADE90M7SUDfSqItx3GtAvZ5EaRtH56iehf +Lrtyx08r19oV1g4LvLCqT5+fHT05ni8PB7H3wmXcHYTCYcPOmd1FYSIX4pjazYA8dazB+TtGenuX +stmG3nuhDi8uEOML8aXl5f56dSTX79vV+uuBY1wiI+SRU6bqF1c2OlYU5XSpNpg/Xmh73PFBvb4r +Dqd+cyTEr80L56io0xv8p8ow5neK5PmLh6vj1XCjPoA96PaT1UXqyohl7ryM4RzKdaXwgZeXFCe3 +Cg4lRjEMp3TRFUmYuOOO7NZldpOi6SrO2bir+dK+G4Z8cCDcffl0mQXDl7tHV2Z+491KUXWJpNpd +quTuDZtimr8ER/efy1wXu8/pQsKkAvPt/fXqyfz0wfzFYn2RueDc/Sms9uJFTi7FdJUvdbIyiJzo +I9U1rkZyUuMPjveFcU/ozhVQcmfg4zmX4OIIwIu5K3dpzF5f7jTuXOKIO4f/jbD1HI35yjFLF407 +YOy5BPKqKPQyw2Zsr+S291SQvzs/0dDt5WJTLf+lFjCdyU7D0UvFGJyLx+dcgBqdRaeVlkrp7xap +c4yy0ygCDT1nGEFSbe8ss1p7+/HdDz7owr0FLif+6H//8a++fPM3f/rtr9+Zf/HWh+5XH9+88+76 +/aPnbz87/sWH93/x1vVf313O9za/bD/7w3vtf7797mfv/+6h//3bD/7y64fvrs/24/337MPuDeP9 +fzbN5t7f7j17q/nlu+/8795/vfubt042724+sreuvfHuOw9+sS6Nzt79zeHqq3t78deLN++s+v99 +8zefHzwY+vnd8Rtv/b83f9f+59n9e/6Xf7rzt8NfPxQp4/e+e/z3o49uf/rh2Zuj/j48vfPsD//9 +QEb5jf/7/7z7m6/v//Xdtzd7R2/ee+uNs/vX3z94yvXd++ijx3+++/zL3/6iP7y/enpOZ//vV/fm +x+//6f7dpx9+uWvQa2/saPnVe/N5eHJvb+/Xz6Y79svYP317effe8/v3wv/Y2P336tGdwzfefePN +9z7/4g+3P3h8+lxW+stf37/39a/+fv/unf5X3Pdrb9z/xX+99cbd55uPOfnrdw7jH/5+78Pr1+/3 +j9549oXOwTS35u3nn/3187eX//vhgXT7+1/fXD8/PLv17M3w1rt//MsvP3/3N7//9Q== + + + 12/e/eWnXzR/tG989Paz3/3FNQfX/3SyZ/7wuZy+jH3jb3cXv3r4+P2zWx//x+3j/V8fvfnbj+b/ ++e5vlqf7777z6d+Wb/7u0X/fYHNt/NQ9WQ7j7f3iV/3nbfvh8ln76c0//4997xc379x6fnww19V/ +Mf/64bU37j1dvPfk3c9/ff139542f4Y+/Nbp+yf/8eT2u7+5Gf/j3oe/vruPRd648/Hpl8/b/2mf +/UWO6Td/f/fvv99fcKX4q5dv3/w7ut3k1f95de/p45v2nSdvP4/X3rjjv/jw/rvr9fPP/NsP//R7 +INWXXViu2/fe6v/rrQHRpLP3PkI/LX79axpA/tA8+Y8PvDb53cd3An9SXERX77z527Prci73Ds2d +ZvEo/v/svdd28kq3IPoEvMOHyVkBRM45GAMGG7AxJjlhG0zo3X3Tz35mlbKQhAhr9M3Z/9jfAktU +mDVzqBklamXikx0nxUxXAKzdDeDJbi+OSDqTnRA3YikR5KfP1YTpX7iX+xsz+ls3+Of/zOJzcVvy +n8nUCHb9ShRng02oUN71d+hAfxHs0iVnddIs25blXaRrd9wWPc3VLnu/7z5irJWBqDhH9BAvvY7v +lnBqP/bia9hpQfTCDRaMzX+Wr+yRDZn5sDgmPQ8InrmizzuNBm47z1l8QhKKuGswuVKi+OwXTsgf +n381X/If4SGZCudXLLTRXnhgyrc+OoTTIigMFg73Rot64a297QY+vWSEqBX/8uwx0dTNUyEwSdhL +Zs9wg8eDWSTAVJylBPL8wee9RTjVxy9aBU6pwrvPlWaPs02nXrPd2ztH/sMzyJtsgc9UMsYtRQmO +ynOhnmMcgG2uacXSScYJKl128CTOHucM84jwQ/vpOdvN/lbCD9+NbvauV68UFu7COz4Bk012Bou7 +QilbWAhjd7JdauLidiVfQ6vy/RCvbldv+c/tJ1N48z21VNeK3jPZpG+ChACSy8OwzO2rCkwaAIS5 +BxAoFS3kGoMlUXrO0MKufrLdR6u/UPNYnlgm9OvtsotDtO+oANGEqH3+49kci7bsuUH+dVmeUrbo +TwQPAWfZ9JZcO+88T/Z+tojzRWDSxy8eId+fi1MiEeIlUqdUGrvMH+yuEHmYbMUZqDyY6Se8g3Q5 +G34xb7NEah8W3yxOA0/WbMubfkLgv5ULB/6p7/s24bV89rPdrt0rkQskMd3DLI7f1pMAkx/lELPQ +70JbEAw77om24CEjrx44kLcZ2svMEsqR+++n7P1rLc89j2ZfM4lK3g8vvT5ku4WGPUcO92NE8UHx +qfDyT2Yzi9mxzPGkHyZ/PJ8KDBLpu/yvyRbuvL07yelLL0vbzdYi5bK+5MlyvpFBn1LA28gksZjG +0qTXmU8Lf0vJf8G+h/+GvuaoQvo9j3+GvwIm3zeoNnqeZH/NT5BHf8uxg2UTvlI45Ct0qPFwXUSv +JPDL6GtBmCqHXmmKo7CzoPlMNvkQGWHxKeE3cfwKWk0LL0nYbpZdCNoku120pHCrcttFf4vjoaSz +4CGUIOKXrJwUfxVGvJeDEv8ijp7ibaTxACab5HW0PLx15vc93haAcI/hKcySUDm6lO7BpmCWqxwE ++wsELHFsvA0MJZNNDo4k3pX4FQ8mzFxWWUNGE+XwkeCXWRxTHAm7ZPxJGJGdVP7VMFpIzoVFDPR6 +Q9iViCwnASvJ7hRTDksvElLh57tTgJVFKjmlCgBMqmwSQySmPJe0fD158df4qWJS/LJId5Kzkp1p +SsRZDscQJLIqpBIX1tgS2AeLpvgBhiIeVh/QQJVqDEIXYzDQMRSFsVNq7A9vDZMmQOz4sAo0ZI9E +pCF+hR0mQrru8CcW+MJOgSfDf4aYhYfMucIYSRV3tvtQ/y1lHItuoTp/oyTWFnD53yxw8Ubp9XYQ +A6np/0C7ivCy2WdNeNaFZebR0nvPf76MM8XZ8s9usrHiaN+JLkpO+9qV/wjtWqJuohRbkvcYz6OW +ceWW6EytqusZ5P40uLjPBYc+b/Zn1djyahBhQXZANP+x7wzBIPvLSTeUGy+ynd/CXeb+ZTPNfWd+ +SJmVxP62jDTdOVawTDbF2Lnv70mWeXwaxQq1pNmq2Es4Put1suFnb0W2XYk64SlUn7p/2bv3WaO8 +K3yN8PpB55eucfoOqlqxA4pHbao+xKzTygUfqTirg6YYBkzhpd+DzRRNIwXk/vXMFE0jBVniVzNT ++K2xGCExL2AvyMBQMy/Cm0/rK68xu+ulgmtel8GJHSyVW7oYH+ebQHsmR5bbq+j86D1qQFUzm32f +8KTKdReiz7BgdyQURgw7S+N0I0YgYZ+oE8qoqTNEWq27sNhsvIgnt5Jx4bTkcNK3LCRgy7DW3XBu +ceXfP4pbDuOH1CNeCJyLsJToclEPSaiWP40Wh+c9ZFliEkAWSHlpW4AB0U4AVX7TxFvscaVcpmB8 +mGw6RoVk2F2r5Gp9x1kdNVV+9XGvvN98oEnrhUC/koYHbS9tbz62uacrOxFe7qdIijXq07XoAFCj +rDiRjr/mvn8fQCmd2Arc6e8HtuzdOlfJBfc5gvT2tmaeQEZ+OJenl2w0XvfhByy3FNA99RoOd90L +OKZlUOQhzG7tb8u07G44E68PbgD33/8EzIoh2+gue1+ef4HdnNxQmZ45ipdpsiW81sBT0rmnFrlK +1/7GPkp/bPcYypFv/6aCJF8Uwzu0/e3kTp8ZuKXK3CfNrGX5h0svI7elVPzdv8K5YPkjjB0Jzxq1 +XLuVAeE4+GlKzqDdvH/AKMc9EMxxyhdb5auF7z7gRtuX7eZ7veLk9d0jyhxElY9JOpOYvvxmHtse +e+zDc/8J4i/KGo0SQ+uAzVR8hdrG/arKZihzMcW+h0DAyUrZYFJazLUzT+5c2zbaIUbiERkJQTFZ +OycB+7VGOTuukZh7JXyvpRWsoe4vVL/CE7wJZCPzskTfMyBZyKGp3xFMfVocD1F5HtvuIMWw9V4e +hN9g10WKoMrBW+WwbbPrWaRzUF/q3/iVGBkxN0uuQWuXrQ/IOYttyXpzXpj/RL08HjhvsL2fJgr5 +ioXlm76VOeVnvYeczyUZzHY/+u5wfNgogYnunLGDiYKefy8UW7zaFxw8K61A7tvfIWH6+1/EYXih +Hmv2IqPi+MX2BNt8N2f+ci9Owfv0IbCCBvKyIpdHtAr49PIO9v7wU64fYH7+hO10DAygl27j/SP8 +eLu+R+Z6FOtP4pvhBF1cFF/upmPQD+JRmODNVZx5iOds0BltA+o+RtgNcdPTSCD27IXqz+dTLvTQ +92fb7tY7zNLpekplW3kUzi3J+UaqWLHiJhkAtaThBs0l0sGvAC0m7tUWH+narfelscU+QNz3O/cd +sXoLNafLKfXAcwL13bYE3InexN+s9x8qkwZBLnS2RY+beZMqJehM1+PcS+bButsJMzcAGd6BWzK7 +RqmTC3X9Ptkjh5moPpUT3BCcEsEuOXb79fYW+3S0b0H182ZLhUHFrbY18T0Esd+QJz5aPT1rvgSv +PLjDzVn8TvFKfPHiWmLhGGu+xz+L3tWQBGYWIrP3odKo/LNzO9B7XyYby/QPsMiyzNI7dwEmuC0U +p2/jpEQHFV8BFLgD2US0i7PHTEQJfGLrHWJEM9miXxtHXxURb0q3dsSk8oWa+Y1QnSU03N9pD5Dq +BYvZUPqtAbTvrJejolMW/fMsrgeOO12VHFgqydDicQv8vCGqUKLvrTibDBcgC9MR7LWu+5kh8zXL +dgtfHuBK5qXwOlgyt1tfoVrtWzFyFhaJFzAW2sNmtv6Yu5WiZjT7g8jHilUDIdYwzN5P12+8B55K +LnKSvUrNmeSQScXuQgfKObcQL5x+yZe93ztvYGzve7bbtT1KjpiVyNyj3hfSBd175IjuRJeZr0Zp +vLO8iZqLuG5O4eNnKbx1n1/ht5U1tnMOzy+0AW4JzGBbyi9yP8Bcvhmw5GzRwzcTzszGF91n72KJ +Tv523rDkm/kHUpOiI9FVYFacrio+/J4O7QO/eByBaK3e5H48dlJ75la62Ycz/ZRE+xRDYYjhg5LF +trhxyjtEKt8g19x/QG3Vpnh0LP7a9+sF1seIGujQEqsFv/LjjKyA/Re/Tbbc11crA6Zwe4ejYYlK +YVzNPHSrk1L2e4LRxl3c2atmfubavuDvzH2ZWPNrKSeALlDYbz7buLf/SXnbxjLHkZGgF/jzeFbK +z35IKTOr7XfazGw+n3VjzZfpvvT6Qv2U8m9pWoG/Ivay2gX3Q+TaZiFhI5ZPQBF9Z+HNvrYwu/ou +WRp/+wOSl1nULGzd4diL5z73HW57lOdCu35pYB5B4DDZoMOxipKP9UA2Ut7ucr7Ilw8Fj/qZrat/ +U6jXRn8sLUoP7DVYymff1sDlngNMbHpn1/8tuhNf+uso0pQqQCojH/ZdZDvfa7dEfvIKJiNRXjEd +4wBzctZ/AsWpAFy8m/kTsUmwxRjLFljO7TYTK9kmTJrplxGmpw8E9OfsSTDHdwdU8GIxYxZdctbS +jWjlubTDjIKfBUW0gMXVmXjdmn0rvFtGwXBs7c+DjfHpPhjsbbECii88JVxW2xix7QRSMdaaUhr4 +GMjpeyT8n4svX7sZiiNHDikQUU7O7YzdeugnFJUwn8S2hb3I+L3gLUATVCxw0qP3Uj5TBX3b2w0B +ig9rEuJbZovdbDjaeY8GX3M/sMkcoXgFpJjwUvxt35ogt5SLiwJxoKSz3Yf0MpNIrR/BICPsKrMs +ckvHrpYLDm56leRz0KHYqYReZHuVUSA3jtP/nPteVptAG8WV5JgoJrNCtFjjw1K0BWhtGJXuRVXX +5RQZucLLrswJmv7d8l3JSFavHyFW8T0UnSGwxD3N1VfhLVr7Lkzdn7Zo43WTABb2e4M1XKVeg9hD +rJkPgPFRTwRYI5xq3/tKRfLNWYplOzf8cT46wW7uBphkKZsCbsnY1qFCdfJ9IAOo75YLoDNCjqyh +v1Cv3uQV5JPw7luDUobYjeHMf6coLAcyh+ihX0QpoBz6lZP7Ur7jdrpY1T7cDb9IRMKhghkHRvKT +jX48Ny2lQuv2vmRbB98yscfFe4bODYOi0MaCFWEyd9JFzGaJpbk0BkSr72VOwNYw3B1XGJxKIPdR +MswfGS2BRCbemdSfu1aY5SfLgvszMBOJS9iLQFkCoglq0LMsSQXN92rZIOsOmMIL8cr8EdvP/FfG +L9H6CKoFCJ8tzpnitJt9BLn/Hhwti7PQLiPxLbIv3TlGRR8T/gQou29Y5whPKkWpfBntP0AMVh0I +GZ6z4dHAklsWHF/F4WzK+pDBEpeNuALcqfhK2Y55w+V5yIYF26jeLbld5RomAOXTRcwel8Bu2l90 +QBSnKiZbuTsGC5v3f2Io90GnWHuA6a9i4R6IKOnhvD6SuW8f2S0PI91etrNqvKIRi5xqUJpt1eDO +8rFn+eFweSBU27lDMinB9FrzAEj7nlfukmUyCV/JwmzalTSyTu1IH/sA/GUmmd98+w== + + + tjD6HFgwwXH2PlBbbpZtWZgHEX8jXesvUwgUv2ylYqRTEUgFvVycJzzr+FdpnMqCBvDzXVZzpItC +G8f312x+lcy/3QYeeVtylG0lRwin9SQmb28LuekpGQflEt0rbQNhFDgXW8k3BEUmty+5NtWoFBvb +zxawCHKR7N2aKWdXf9tAtmWd3YmQUEwVq00ebgXYSXRZrPOL6678wOsTON8IGCd8TkBIiuLfO2tx +NvXOkUROc3/7ubEj+2SMOFFCBpFRGEjKt0eWeD48Bit4bgfbwTfJrrKLEmN5mQ9Zgy3FjF/i1btK +h4n1e1P8FNB59Fq2AX1zvKZGvKMUCBegxbNPAgwmZhkx8YdRBmZhyeI2Hgj/PCc/w+HA9o3ObmZV +0rOMkTYyFB17ireeaDbi83gBLbrb4ixVgcF69rU12iv2sc6QtDd7TdGJkoovArCX3cqX+hk/bxFV +tp2foFvGP4DVUxFisctEiFrpwU9nm3SGqFVmqZA57yZBYP7cgDTsTXGWj5X+vymhyI1Ct8r8u8OF +P9t/BXzTMJdtyN5odHB/4C9f4R+OMpKbkuQDiYmqTrGkik0+RJXnK/Y1yd2cByMcJvCiTFPF5UPr +yS9/h8sZV+F8/i6/tzv/TLw3lS/8q/4u/6HOTZKKP0ITIB+r/6l8zhcKuAHmTf7X4nb/vftcfy+y +B1caCfdFhcRNtT7/9+Ibxn9bHMyarVKE3ouyewcBlNmq2Ll18jvnKgn0rh5kf9RAecmwWvwjfI3x +QUKtbCbyX7F1f/JU7K+OzyWFE17eHZc53ZXWJ6u/cq9Iypbc7YruIkTVOllZ1XFYhs3wDpvPHOC6 +hOW0LvzC7+ZRdUKeq07oyKoT1As0ZIgPA+jdKSm7AxFB7uge5a+J0JLDAb1zBBDsQDqQOL49dghj ++4v++12Jd7qhkkhU8YGuDDlgBvweFRfAHQJL+2hIxYGrjIWf3z+UUTUcuoH4MLEcHhZ/pos5CyPF +IuAhuvWyvtgoMRqe9Cfrw9db72/ypGz4W6FbUF3QYe0YGmCzmH1uD0kIHnUXAAThSjJa/A3utyeO +Rkm29jtbiVeJkrLB/vfu7rc1kVy/pMv5st/f9wuUdi6pLxaBhIQEvtx5PVEmvHObZasSdyprAYn0 ++IGqI1Dunvbj2xUq/h1vF++IhyrRRfnaGjYm3F56IE7iQrdCeec+hHRsRz8EHv6ZCdcJSP+imkHv +SYVew570wzRABDy3Pk/6Y0ejT1Qw0Y7RwoO28Ak/iNPp7i4HBmB5iUK6E5QZnRKegs7fYT7Mrte3 +iNlT/gMt2+zL0kOzbUHWzZ6ZP2/21aJ9sye1rPnpRhQ+lM324Ja2tvH0wfTda4qovNbSaHFcluVi +k9sXPbeNRzD2zPf808LSH9iGKtHXbjkJVuljbtHJBLbvidiodRstDAvpj3iajPhzrh/7fX5U/S4U +n149E9KdDf+CluJqc5OesDWAGLs5upI0+wKODtpGwuxqDqNm78cn3rXf7NnH7s3e237B7CNuKSKQ +HDjx1rhJqe0tXjzeKZ1DLVWHzM8Qx9fCjzQxx+fCPScq40V+s0klp1nvulnL1KPbVKSSePSXVsPg +Q3HzPCQKw9KgW0pmkzPl1vI+d56YO57yPFCdP+jpGq8GtDlYWZA9stxq22Q/ceBobDebYOGTCPSX +YeUrCASb58lTEM4vsufOj98VHEmkTO0Hr1P4Wv6GWeb2QUE6bHzb34xchVsiELx3Ss8cdgq/9QyD +N1TMDT8j8V7uJJOOekxBbVKTDU8batPLDZ5WZdLXzehv19OYND9lOhMfpTrpNvJI4knRuRzstRKM +2rJL9UkTN/atw7paq0262b/6rc6ptfOsmJTDMU+CaqjuFSZlLJaHYTOkPmlwMCRKOeZOdac3pa+I +9ZeOt/C5HOyVKL3NKpqT2qngoKg16ZwolzcDxaQwCwvg0l+PynenaNLg6uBUHT8xbtKWw6FAJXrz +gGwQmBSwe1qUn+nTZlR4QHuBaV2HpxocBXf+nk990nWlpjkp0yTiFsWkaBZu2tnmJUL21SdtFt2W +P2Z/qzbp1rLOlbQmraSpX3KIaV9lr0HXwBP/7jXVJgVUSrrcmUf3RG1SohQtphSTchwGn6r1/mET +15h0MCJKo0pHdac3pW3ctgw83KtOWvbum0CV6ntlLI7Fe+ZOfdKEOQDmTsuKJnUfgLddcqfDGTMC +b3iNJzXZJNM2wrkBN+nA51RMytw3lg/spMXnZUm202GGaDwVQ6qT3lT+wPYNLy1tRpxWMumte/Op +OWlmOc5nNSZ9chH3scVWnBTXtAnT1n3P9fnCu1Od9H6cjmtO2nyu1HJak+YBkx8c/Yj6XhuW/f37 +dB5RnfShQa40J+2VA+VvcVLAMdm0deJhTWc0Jk27Hl4eX7Oqkz6mp27NSUEzGmd3jxp7fQ4So7uu +S33S5t37V7+QcKtOOtr52+KkcC7yaX9aHntfa9ISMW7/JdQnvcu4Nk/ZbV5tUjiX4peP0dhrpGJ+ +bBINdtLJza4sJ5r0Zv/4FESTeg6I5s4Sd73sf8YwaXJjsin3+uruWLlJl1G3bNLQh5245SQN5Ug5 +K/JJ/Zvte82CJvUpJjXZgEE0/OZnC1OCaTPbA6n6vIqyk6adRa8CvOZs6c7BTjraxWpyRtjzxCvJ +Gpo0gHBMyQp7pC/csH/BpKW9ctLNZ9rFTRpr++U7rfRyNnsCT0qne42GOKnJBnu1PG1D06cWmpY4 +ZPpR+01/167CpNQBd95kp789j41OqD/NRRyDXuO5hiXy4fP9xJwgqs+encZTR4qcbFsWtadwAiWv +2ZazFtBTNQ5Tmf4y4ZKVRM8P0Oam8rFmfh0MrfH0dxO+G1VCak/R6Vd2uwiZGobVf121mzN3j8W2 +xtNdvF6tWbbqT+vEqOHxhPYsxFSeM+NmJrV3aDytv7Vi4Qef6tNIc0i6nOmnEXrqVYFYg7AKZ6nE +eXjK2HuTp2JK42nC+ZBPPGbUniKINXLuR+vmM6fx64p3nGe6z+pPb7Olr6SLdqk/bXY+vrbjooeF +mMrz/tcPvQ1QGk9//la+5SKi/nQwavG6M/dUDrGR+wnjt/qvx38PPD9UeTrpU8kbb7ikBbFFv1na +3dwt1H/9Row+HF/VG9Wntsf2/MFpbqbVnm42yXGbzrSdThZi/sPnVK561879oKeBQ4of/2zNI0dB +fJpauxJrwQpcYzaTilasX5z9AsZZK48Mtg5wpUZYy/TmjGt3PU6avYXOo9n78AK25njeNTufXHv0 +qYVsUjCy6+OQxHpLJVdLvJf7DJ5RnDtwG/l1gCnY3yOO7gT2+JYQJrUEPpNTF+hoN8VtpBWQc77N +DeVItnysaovsHJk+lrLQiIXXfrAYQZbOUmS40kmDrmftSW9KLz61STkrCVs6Ei4vnRRUW7B0xhqT +Dl50Ji2bQwpMlu4VWzrCpLRs0kgFaf/P/KTlbzl4R9JJg/dWPKnJxgG4nelI9jq32y3ipFj715g0 +9IG0/7X6pMHBAE8q6GP8tDyA3wnNSbH2rzEpY0Ha/1QxKfYqsNNO1PbKA5iIaU6KdQrNSZFG0RP1 +MSWAvTqTlqp2BSqRXtAW8PT4E3cMzf384PTV37yzLIyMeHOXNGu+B6cvvLnZj5c2Cb9Au5Y5xKSE +C7/2OiVuGfiURxpcFYOFhyxH7yZbKlq+6wCUb73cP2miKprrnNco6O1Iqall/5H6jyadHCwztkqt +nfOukjHB9DmTLfCxKOB/LMIEbjXnF6zmqUC6c18l9Aot8z0B00ulijbJP6wji9OY2+j0pZ67Nlro +H/8St2FxyUQtZLPhfxAyyEwFbl13wg4KntSUrnCeqwPIl3st+GpHTo29W7EolSVt9ZcU+LTEvCb2 +PyxEVT2hLNAbe02gCyDH/3SkVjW/P54n4x2myXpDgiKq+8P/TPoF/fOj0w/dW/H8RItPfoLeWw5j +WJtGdX9xt9Hz4z0k2idYvv89DVgqQ8Es3GAP2uh+ErITb46/vgLunB/mZMxakROro3KMcni4o1l0 +IB+4DuVg7+h0ezawFKxn4P1Vsp7ic34NfEwygbD/E0/jpUgWR9uyMACtAKCJB2G5bueUMhXYFZ/v +drqrwTLAi/55krpNVaiyiKzguhrj1qJKl+bWaGu83hC3pkWVR7b2bDkOaDtLQ6ysVFsKsZiMe0d3 +5bLjXakj+8C7FsUECzHlaRnbUMEvw3OBDGV4TixafjvCMam2fic5plT5+e8kwKiC5S3m5D29h4C5 +awtoI0ppj85gef+T5lCsdqE3mILuptRKSXeTm8aRPZsM0t2kJLyiSnfAs4pe9h/urEhJPEuOyVP6 +xsiBon846YPd0Cq4Mbm5JcWhZOeCngc+Vp7k4cpif+oIO6X+qNwwWlPfpDfnxOqXySbXwvSOZBlZ +K44Eftvb6HJalvWwp6/KfITXywgwJQ2F4LjGKEYT4PV5Wc5XDwWT3vlKX15G9gqxJOhjMv3JgPYE +i5+a9YGF9seKQUlcTGVR0RtNWSmuxsCS8Ol/WLQWlRFp1sj5aSl0WOdHbHa8d+ifoHh+CpXOwPkJ +nP/gBDeCsLoYGTboXByT4nUG07Q7BLl/ymAnY7wOxI7pdSdBTM5rLxpMztFOhhjn1+IQjcr1Bz65 +4VpBpFLUtEpMNuPa8S6l5BzaCq0WH3uvGFew1TWFitISv4Aq3yvUaJ+rn2AoB1daOLZL286Ejrga +kUfwGuwZ0Cm3foyaCpp7SW2PMQUjC3kQrKTjS9FcyDEuwC9EW7esHOiWZy2Eg5hR2xDpUS5VqZnr +j4P6qGI6sA3ZsKTg5Jbmc8VwmLsjdWw7CzsDuGiSTiB3awjQqSIDt3zMqSFhHmzCggSAOLsDL6qo +LeNV7WHtJR0yALm9b5gBfFVPYgAmm9oOhf3Zr7M/RC+x9u0lQBfxQFNTMNnUsVZDl6dG2w/y9P1x +ceSDEywP1qf4M7Rs8q8q8UbeDOSWxfnA0pfrppOAFToTGVieLCfx5O6AxMna3oCRpuldknhIakoS +P92XAHqyVW01SLs41aigrTG//bgjQOJlxFEeVVKqKTX4s7bmFGn/mINDSwTVDsSyhnvDZNNzcPzU +iMV2+Xjhhmp7gJiul86A34e2Rv+C+hhoMgiY8eYUz6PSXyNyfoCOjsdGjRXIPA1yVRqlKxOiKs16 +retKZfrYBBqqNLB3yzF6OQ67umZMSl8MqnkU13W5INTACJkmrLW1K9BLXSkBtfDcZNPB9FjbLBd/ +5+B5umdDnl6DHk6ds1KIPC1fn66Hc13H8u4SBsBqF+Zj7kJjuiyCTtgQJhvTZV1Ojzx/A3bVv9ek +OsHiM2rCAhM+nfPJc+HQrhaTsU8fI4xKOzRUwBi9HPe3osGIy3lyHuCZ2V/ii8fngs/NkNDTw3g8 +ijxSKImKnjjOMQpUG0WaocqPc3GkAo8ilXsyu9Kg5JMNJo8Pagwl8VzpucXL979KfQ== + + + E/3NaIRB5JZafi802KXihrcr8WpR2OeUGJ8mKLsKUGqfizTMrcfR3CocrafgaPL8sdM42sPKKEdj +z0VVyiG1MnAdjoZuLd0uSSMC0whH2y6pyzWlPBgI9zeX037vKhytp+Bo2jh2fBzjHE1iiauMczlH +62GOJs8ikIVeiMWuF+CwSF0XkB9YnNC0oJGmJAkdqmspHDJwC3GAAZxyK5K6cOKD5sZPyrnqP5xp +Rstjr3CglwRylUMJTFY3vn9cq0eDKbIf1IYyHVGmUabOEaPRADEj6/W54Ll4HDSKthpnsp0yjuEU +CMUoEj8MHucIEza4GiXlHER4dVVyxWCGvX58/pieNPSqSMPHk6xqLCs1peHz38WeDWRhkccsPsP6 +PQxGG8MxA9IQBjuDfGR1SfhUJzcL66X8/lEhC8+VYo+a+v1pUuzxTP3+cJTnPyO5cMfHGWsmkrCy +0GQzLA0nN7eUJhnqy0KTTU0aoqRwr0IaHuS+nJAEqNSU+nrSUJqHJaZhaO4e1vWyl0cSpSuTKRYi +QWp4LJCpoKpRSm1k49QdcxoiSBXaPvQqwGAhA4MZwBeA2K9NG2InGZd9Azqv6Wj8FIhBz3VtKDNP +9PTiRWmrrAZUTYVY8otiSTLL4EruXmRSKsSSXOvjc9d0MtekRzIQc+n1QSnNUtNGllx/qW8bGc+2 +RYP9GRAt2gn1sqF2tit5SAaG/MlwkqLc18pChLM0lHzLoYWqigF7ecv7A/JsKdVsRjF/7siSVNzC +IiYfJy/OAyRqlGxSuMp80mo5Z8caNtnM3o+ve1Qb1zD7Ir7xmTV0+hV0uFL4CjV03HwaFXQcxC6u +odOvoMN3qlyhhk51UqGCjrf4Lq2h06+g4+9UubSGTnVSoYKOt18uraHTr6DjqwUvraHTr6DTrBY8 +sYZO/z2T7To1dPoVdCqVXGfV0OnnQwvxygtr6BQJyQp5LZfILfvagNkr1eu064Ayf3IpdsKi5Eva +HCt7S06dkiw17Yqp6+SvIm7ZshvJCTVSK+DOtlRzySVRHoNwchzJMxPhJL0fRg1OSkGvTC1CMt5Y +EZ5HEeO7BJ/iXv39mVR3qLo/lco5o/uT+pTQovynA119SbJQDs5PPhfo2g7k4/RirGhOX21WoKtW +tu3Au7nU61cUWasoKw0lgxyewUvRQGzOZMxtPPAZKiXS2hpL+0WjySD6xW6aqSDyTMhjxW5HAv9G +PL3Fa7iqUH2ans5vHDA6AQcNM0Qbk9cGKrS0bRp5ChboY5ObskeuRJSO2eQG2cPkpq/jUzJi9kqW +dLzE1GSwyHRS0otlH3OcKT29Jd3EACOOM7nb0MNxGJn/fl6+XgGRpLBfflfnqXVggGNPO31N8JQ6 +Prm75VAiHWGt0jq+o7rX7Up0WuksaZeuKZYksfeNFBdKlqSdAy8cnXB+R+r4rMdk7gl1fL+aweST +6LOsWRMj1S1PGOzILQjKoYSbWlUHO3ILguF14djrkaz6UzapXjFzJsS0QyFnQOzIVQj665I4fjFP +Dm8OUp12qaP3ixjRZd8r2OerWzEkELvmEMfKFrkBNONi75WjDKdLsv8c4c67tNVkpMTNgLGncO0q +DlGIJnBqgqoqRuUGN3aDpr6GDxYVYhm2WjRgcqxQzmTkkJWREW2LR6PAzRDtH4Nnf6wdYjywKzXB +cZJ4U4tJsBymYoDOjeqR1Gg79cu1yCp747R2XeyBHqld6fOrXQKvxGTd8qNj5XFyriNRIBWx16/q +lcqTYUk2HX3sNIof7ZxGyNV0tL7AWXScCSdFfvJX9UT3zqmVcfLqp6OL4srZTvLIwJKEO7sOFkVf +DCduSco7Vc6H05GiOKXnSrYouUcmTda2Co8MbY2u9dPWlTimVZ5D1i9yW+DCJgSxs8pzDs/gp6bp +kZH7LgyU55B1x+lbU9qVtcs9MqgMTeGROec+JVSGdiSdQ7Eh1YrU2jU8Mqj+jPfIaHnhjAHGaHEO +n6ekWZ4D0GEuSCnhT58n+8z+oA411jYfy5Qzoiyv69eoSUz3SP3MLYvk1iZ9q6V+yb1hCom8rhvI +nT26taRLsTWJR9Eghq7rp98bdngnJDpzndQF43V1QYV2cWZdnfHcdU0rCdXVGSgh0SodlcMGWRaa +TtCjxXWKRD2Y2eJQxFFxv5kjOYrGYmVH6+EM3dd3cT2cLD9ZqIi7dj3cuTh2Wj2cdobqNevhLs9Q +NVIPZ6Ai9Qr1cGK14GWV4LIlHbi9VbmlxmDn18MJVWmnlWqcWA+ndw/J9erh2HNRVsRdux6OnUVZ +EXdmWAd5UlQ50en1YiX9Pat6GVV1y/zBJcPn50TiLInLab9nQH83HQ0dAhu6+BpS7IdB41x6rQUe +RWE8a9SJGxjnrBp7RSUXGsdYKO84R+uJRKh6m9bpGc8eBRlyJWw8EWpnERgiQzgIIxVRpuO1TJdd +BCzxKKLBHsxXIsPi80CZMn26Ng7wPtmMVrmhHaT4FW4DxqPwRHi+9YrH0SLDE+7uYMe58KoLPArK +tb6Kas8uSX7BzOHdgydcMYP251H4sNDfjtYkGjOpUQ3SNSpSn/+uVpEKQ12vIvX57yoVqeSNkaKb +oxWpk5tb78XjoFG0+eYJFakwzrmVpLKKVBjnyIUiBlejvA9AavEZqOVWEIjmpamKJCONag4lGcac +3gMyjDmPCDCj2bbXKoXjpJhYDHdmRo98k0rf6dl3QZ9UCmc6Wuh6jVI4EWK/J/U2OK0UTseu1GBc +55TCaXsVrlkKx+r8kmI4YZajpXBGFcO8X6+2+sQb4VFdnSxBQhEZOb2u7tSIjfa5DK7WeKKP7rc0 +cpGhER1mupVfRK4ZSzLAifP+gGZSreY1wQfV6CjzQFvInCgcUFUdwghJ1s1ZOaicB6jN9oxTRWcx +4w43uQy/Pb2FC8PSw30msMs1ipuX5DjZLSzJfC5QeyxYFrX7Qtpz302uXj0MfCq34D1HvtR/Ls0p +R+qmwAoj7O6V+JMFn5Ks2K2ZllZjKYrdLA+DltR9JSsAS8XyTwO1qjNUYRd09TXrzjb71xipOSlR +Ity3GpMyFmu44xppVtgNdCvs1rT2pGXLsKc2KVdh56hO/e9a1VgunWK3VoiSTCovANs6wvaNRFNS +FruhJpffGnVnLp0Ku5vSxK82qdCPr54QT/Wg2C3YLLxqFbuN9drFWRmZB15RYVduW4Yak0YqtrvP +24nWpB3dfnzN+oMmgIlisVeSn6qVva6A/8RV4u3dyYDaewjHFG/SecLAiMSrO5Y18J4nttoVpff0 +wq4HQaUqKoRwVMRpXi/nXppyq3GXmlyDBaCGXPIYUeGk9Cb9PlZJA1c1H2n6hZfEzqJ3mbjh0p68 +dj6pWs7VZZ3k1LTfg9sbLu4kJzk6QdZrdcozDCf5pWdHc650+qIRWveIq+b16fZ9u0ITOX6og+Rp +pTZuFA9WR5uNSPeHb6DSXNSRXgOGl2Sgz8gxoPNL0kmlPI1eVsfuy1dLdgVlSqb1XaWaTiuacN1q +OjVt22S7djWdmsNLxdN7YTWdWi2d1s2T51fTqSWAqOcoXlJNJz0rPox95K6bM6rpTvZan1VNp43J +16ymU6ulO8yCvrSaTu0EOA5zxWo6NbtZrYL7smo65boQG9WOvZ5bTadWS6dfM3JONZ1CuQlIOuRe +sZpO7XSV9v7l1XQisERa0+qXdH41nYAlklo6iUS+UjWd2vkJOSRXq6ZTq6U70JQurqZTG4rLubpi +NZ12hPea1XRq9TSXQOyYTngSxE6sptOH2LWq6dRq6dBerltNp0ZX0r4816mm08yGumo13bGaketU +06nVfh1YrxdX06nV0qnEki6splM7IUWu9RWq6QzR/sXVdGrAkEfer1FNp1ZLZ+AOIq3wAVqSQQNQ +HhlRFO84Cxtl493R9v2IiqFWRqeSne4smk9hONqFTyK3MKRdnNSvTk3hMaBdnNivTi19QtKP70i/ +OqNwUutsq8iDNQino4qFAgU07iFBrdw0O9GeuiSUQXQ6XqouSVf6mE5Z1DENQHNJMg6DW95pp1Kc +BqfFzjCH6WhZRCqR55+aXCSoxSsNucHObXMnh5hGo7vTVXJFmztjfUYubXOn2y2Lb3R3SdEjJuGL +85MNtbk7mp+MCukuLikz2Qw0ujMGGJ3iBtVOE1ppCme3ueNlZV6v0R1fVHW2V0iq9dHpnsdyITKs +61ers0jH2oaKXwWVG99wqK50w9Zizou3hkWnVq6C8UI6I912juRa10+6hl9zQyjb1lj2rw7hovpC +rbQe41VpCDCXFL9KMyHrBotgDNYTtX5EQ1nsY9X60RR1pwg6VK7mV57kGdnp99fMhrq/XjbUvcFs +qCOZ4a0fzUSo0yofXSeFQhSj8PY+Gufimlp2FBWRJ+eWBsfRpUDDfRJd12k0yQ6FdNXj3NJgYa3K +BcXwt+TmSrcCosHy+sUrNpPhihMYjDLUY0jiLlJ0AJEC82vhNlSjLDEk9TKoQVtzoUiiPIca/nqk +SZPBQoaeqLpfUpnysLpiB8OH1RU7GD6sLr4gAEFbtdHQ6ZWPcffp6u5hj6GDe4rPKh2AUSQh4rMr +uA8vKNYZBdkvOuPICyuMN+I5sCwwgRgtZTBUyOD4cyuIkNXHjhyEQTLU7nB3Un3l2R3u1GvfrtS3 +Wuhwd5k2brTDnYHKxyt0uGM75V2cY3Gkw91pnfKuUpek0uPu9PoQYShSwWFOG+yMDncqWTdG6yfI +G8MA1ONjugkbJ6k5uPZtbKC5qqHC2snNVNVhcFqv58cz76c6qHy8RmEtGkXmzTov5wqNc4pprXVH +Nx7n8sJaNIrevXCn1bc/6gaiM4hbnljf7lMhw76+X8tkM06GMafBkpWDIiY1KTbe6FhbJxYx9bHZ +LjuXsy+eg8F0zXbhVnNDhnv/zCImdYjpW+/Gi5hiTj9HLyeVMSkYF8DzQZsxixhhMrwogxihqhgK +nb5F1TDv9x3UuOb9R3t+6ymG8k5512v3mOt/mLUjI6fWuOb92v1XxYgNlwt3rMY17zdULK6VsyHL +iIDBLnJPSiEmy964sFOesUuqLFy0WkM8oCZ5F7Z7FC0LvKgr1LiK1EsESmOfeg4JX2i2yG82adLG +Ful10+FBYVgadAvD4iaTrTDdWj7nn+XzuUAdpXHer3nBY/uWL47zLqHKKUwvfB+23vr7Sb35W8L8 +pNPmrh1rSbFSVg/nic/ubuWZ9vI+bLaEeaXVcU678m97U5oHFJPi+/mF2r9urq0xKWORVYkpJ33V +a3Pni8o8V8o+bDHPVphUWZoW7H804hqVfzdORWkae+usUOVIqpbhsQBOxH+0O87p9NYLDp5MNr3a +vx/tgkOitOp2NSe1NxYfc3FS2Its2oVOlWOz3deetNh8KmuC12STNS9U7rV9cKpAmtz0+BOH5zH9 +9xAf496MGxox+Nww9p6rxb7H1yZQDUZF7eRJt7T/VopOwU+sxo7UpJ2yo4FcW/Uc3g== + + + L9eyr05Pm1TvYnYsFUbpIdGu/vkTb5+7JJcTlnQ8EdNkOx7qKhhNrTLQmeWpcHFqFQ8nhzIBTScT +Uh9OaqlVZ1alnZRapVuVdixH0zg+rTRR87TcnsIp7Q8kS1KxLNCijGYJH1vSWBFLOh/oBrK0DNKL +LE9LYWazqzm0c5Q3hPhXB+xq4F1fw8f8UlT2TDnDB2v01jgjvZ+KF8etRQ7zUrw4ygNbe77cP/ZS +PNOvJfePwZlfHLJW8ywfcEtjVYAnXkKrJitRFeCVrmxEQ+X9T5p+GMMtuXmlekqtlDWzk5vG37Fo +tSEOM6X217KRL3YGS/z8Jd2sudMcAegSMkrh5z/15iG5T4W9GUKWQFA+9PNfUN2mo7cZuSNC8voy +sru4kIyLIx/cP3ZJjdWh8ibvX6nwxmpXty007zkwpI1LF6Xg91qlgAbOD+WOSvn9BaWcUe3GW8Kd +kIZLAR98pyODRpcZGOxoBy3j65LcRHH5YNrxwTMgptrf51yIHS0MMr4u+poQC+pATByHG0xDP7yk +o56k/uWMKkCjNYAoXnl+FaDRGkCT7ZIqwHP8yadXASpRQKsGULUDu+EqQE07QCsb6qwqQKM1gEKm +yllVgEbhycvK86oAFZSjiW0aNrLBKkCjNYAqNrJ+FSC3moNdKbQneVM+FseqJ91adXpTPlVM1q3a +Oqcpn5plcf2mfDpeOMOFw8eb8mE/vxE4XdSUT9T6/sumfEe8cFdqyqdTM3LFpnyHt5r/F035VO8b +14NTI/ispTv3jN0NdUFfP30rl60auLyv3xXvhtLp63fq3VDn9fVTbu0Kd0Op9PXT9wqp68mn9/VT +P6tr3A0l7eun7y7Tr6803tfvWObwdfr68USq3tVP55bmExy66/oV+osZ6Oun73OQVXJdqxDpoKvf +Wf0rVfr6ne63PKevn2rVneBx0u3OcEJfP33C1c5QPa2vn+YJHeYonnlxNoKOfsWM6Qj9Gu3rp4/n +Cn3s7L5+hqvSLurrJ3lZpaufhp//uN6q6Ot3Lo6d1tdPK2Hq/jo171xfPyP1Ypf39dMfRezHdzEF +6nT1U0aszu3rp5/mpncLzSl9/fQtNc1c6xP7+umVp9z/GuxkdLSvX0q3q5/yXM7t65fS7eqn4ofR +TbheaPT1O70q7Zy+fmrMQ7zw+Yhuabiv3+W0b6Svn8F+fJfXPeh09Tu5H99ZVwqo9OO7vO7hoKuf +IsZ3dl8/tdiVGOE0GdTlj/X1U984T4RCX54L+/oZqEq7Ql8/vn5LvaufHh87pa/f6dr4OX391MoR +RSK8sB/f8ct0DPbju/RmD74f3zX6+un7v4TKlAv7+p1zo87pff30DWrFDYdn9/WT7fmgq5+K9XpW +Xz99Ncd0pb5+x25tuk5fP/2ufqf14zuXbyr78Z1bPysfRWk+nZFzpdLX71gxPNIurtHXTz87h4sm +XNzXT7cYvn/YzeSSmietrn6sFLu8r5++2c7eA395Xz99s521Xy7v68dDTL2r3xl2pWpfP027Uisq +elZfP70lPf8ZvG3ekGKo3dXvSK2o4b5++uWPJhWBck5fP/2CWFV97Iy+flrnwnb1O+5RNNbXT78g +9iQdRqevn35w4fB2oPP6+inpU97VTz/f0nhfP32MUHhHde9KaQT9B8KhEdSp6mblgtAvSfMSUwdt +jS4DCteubgxTNfFe2l9MXriozBKW+7DsMrJ3/kgdXpgxCw1BUJGAWCnciEjd3XJbFFWEmZ1Prr3Z +F3Dc+ulG1Mq/0thuNtQ2a3a/b9oBny1mpx9vQ9kQ49l+VAOr/cRRWUSiJps7/WQd3pirO5c5W+oE +bgYvTMx6/2gp2Ja/9w3H4mPtY+4bf+Pwct54zyxfmx/1xX002nyu/D3ck+v62/1H+/O7Vw7c7h/G +ZZdzPM57XF+D0NfdT8sTf1t7hpmdybax3Tsdmw1tNd+sFquAjbB+xF3DxuzBE/XcOlN/1p8GMbf9 +FjabdKxldo/Kt2Yqd/ftic+CGaJEpFNEqftYIsqWVZMo3zU/NpvPtG+z/0g5tg5vc4o2bub68Xni +qb+iJxlpPqEjMeOyN6L4EB5vtu81CxG4W6jydu5ccHVparsrDEvZRimZTc7EFpC4VNNkczlyfx11 +YH2TwfuPnvVvk/llmubHZt2jvdP9q9/qttv6LWsk/p2zte7LNcfrfTUZjNpvGbEiNfQBB/Vc9IUb +9i9ADE9pe1Oq+sybz1EAFXB2QLTcbeTUlJeSz6vtW+ZZRcoE523NIarkNyfKHykk0mFHzL6igsXH +3N9DJrBzFzzR4DSQK1KVDPzttpZ563Wb2Qrz2vREQ8l0KWrtzPOjmqWCd0rlBp4ip/WxvfBS5Ucn +irA4PQWvbV9yVqpVsvgSS+Q/JwESHc5vcbb8ixKB/tJHjStzLxGY/PmQjLeijAgf+i0IzORqSad7 +N34crBFvnbU4sDFEBEJBF/4KEMus4GvMg78COXf+4GvGx34dbRde/Im2JhKvpbHrqU68vWTeM/GG +eQOrrjs9xYd+JVt/fBwRc6czZrJxC03F3NmfVWOLH0l3kMp4xQcgthop/kHJL3nwYqbHeD7Su86L +85EYLCYbC5hy7g85b5tuCbDKPeeUf73plT54D86FB35cHElWrBkCw46s+Eo0ekBi2JGVdIfG59KW +jj199yBlpO1lX5pZwzEObYABYowhZ74kiV4JoOqnH3KWrkbQV27YWbuHZmmjstSEBUHWg/MuNjb2 +BF2+ILr+o+sTJ6Vc6UwczRJH9912ct/+d3e2NXtrFOpV871o7xP8rYB5ueOI9R5Jogk5ylUpJS4e +UTpeu5HE45lsaMRcaNeyLsqjYeQ9e7+3fhaH8xaBdkUKyPIKVvdLhjv4wQtdKlK3CE7doGTjhXR4 +xh/Yow8DkCq08wF8Lo8B1pCGTzD2dORCn0hOvIcesXRaoU+08CnIDlGM/zDwdciNOJ7hgx8G+N8O +CSEqGhqSkvW8Ui+f/HqGtPRBYWnlqHL5FeL3MuQqcwmXNUJQ3/e2ojfqesnEiQeryEYwVTq5S1XZ +DYn/cMEVTl6nQiO/OCltd90hoI7gn8GjE30ihU+U9L3b9yDeyyiosp526fVhkC94Iq5SqXj7EOFE +9e4nRCymMQZzE4H2h1LFASkEklLj5NqGLAuec2LGdiLfDAUT8ClRywS26zRmnoX9pHWn4JtgWWDO +qWg8zB1e7Ye1xUCyuVjCntzUMKvz8K88/CHE9iMYI2A9b9HTgICazzgRHOX0hkgn5sm4kSh8DbtZ +ljm5uQ/isZFR+McdPLBMXKGOVLEh8IOHDXZBwD/hBCtz3nqxJw2fErDUZ+Xpowek1/ERQGzPJWFC +3ugOucrrHunfGh7EN+osTpPe92SgUEusCMxVTTaRryIN7zv3ffNbIn3W6ofAD10YN1gWVm7c+KmC +78lDBMoZDzq1W9xMmpMV5RIWDi5OVpQbASI0rbP1L02CY59MQxybYv82fbH5DOh/rMaIzkXUYEXX +piTfckJWMo4isMz3oiftiqfRkpOUK8NEEHL2uGGTg3sJNYkOuNRgRAQ+p08VAmQKSZbzpShtfxze +amV2SdyqP0Oq6GaKRG35VDtn5vJ3AJj6GvYCpsaCBoR1pqjCTyWmapJIVFtXJEpn3b4ysVj2COr1 +8bMX+HizJZCwesW4j9dKunPzAot83H19gkMMtvmSorPNdg0lGgfZmYvmROjYzJQ9BMrGT5qcZdIx +tZk5L5xibnFmQPGvAkzfAONk8Ab6yipZoFzfLxMdVRPl5NiLiUbg05JPI5wOg3zJBVYNojZolDhX +K9e+OKgip3Cw44b0fjiAwsh5Fd3pzhiAttBnhKJogDeYbrVBRwJv2v5pnWvCW9xz4HYURtYimYHf +mmM8jj12DOAYYHe50YAfJuD1NBWgYFhPms4m0sxJ2A17AfwOUM73nyLp/YsawTFYfL5AFelunLYn +GNRxLw9U4rQNT8exjyBaBRzjxr04dtJmphb4LHeK6KQjCFUiaME1zrMK58z6kzVP2o5oowCHM4oB +Y+4USG/svaHuaJcTc+HHXaJcHV8NAxrv5RRQAzmT0z/rLb7a0eh2AZPtiVwp8DmAhYJaGVTbsAHE +JmdP0QbyWNBqM6vcDoRBfd2ZUYTX2K6BDh47QEMkvDzeAhlWaThuZy/Nua/0ZuayCEAD/MkSbw9E +E1TonIP0LDug2jd+gkcRO46Yp7lAvTZfk0CG9TtAbE+SqG13AxGxUZ93TRaWn6cAYttbkHw1LzCF +cIbOgppyHMeeETHH6ezr6x3gWASsV8RXMlQhY6YM4Zgl4SCnjU6WGj/5goHbN2cUQL6uIcXhRRPk +XC4cbaejRdhrqUBnb19iJwEdHzex2HUSZPkPqCTXv/cpNi7lY1Jvz0EohPPIKFsoY3UwGfjCTitk +z1eIxU0oIO4F/81kswWbhTbnA0luPFJQ4yES6XvJENVnr18+xEeqN3aj0qzODvl9erL7dlhfkAXf +dBTZs14j+5CqSVCJvVsocScO0T4cYm+RDlCxV0RPGIKIg5OVWH8CJbFJAdNIgdLmrXjQJ7/wt4Dw +N9CovPegZ+2cG1bVJJz+oURn4veM78h65a+CSlJYU7r9xY+cU2vnGfTWYFl5SxRnfKANBV0j7CYS +74vi/UOuAXpg4bxH372mCBZcM2L/4c4l56oLbpnKyH/z1cMeGeTKQeppa4VX43Kmn75l3ryUm4UY +Hb5bcjcdUXsSTXqDH8As6IIw5P644dcjuSzJLQHC04ae8kCIkSIIXPnh/IUHgd8nA0HwD4PAZENj +v0iBQL23BSAMpUCA1Ui9RrvU3zEQTBJNDALAMbQe+umbjCiLyiSTctc9jUQg6ILAL+J+37wKFBEf +Q0DY5AZPxvAA59JjxN6bRRCYg9snuwCCvgIP5De2oQwjHpWetVBJOYRsgMFaDRfh9A1iI3u763lr +4KPVOBp22TamW02SMtmMbePjjNNQUOWzCMyzcLo1/lMfgIcDSy96kGgttke34bZKBkjn/1ayAVZm +fKOOziqOgbK1ueEHGPyIAxCV28FMDrHBs4C/A8nBE6VRRaUJzmU4hvN3L8GxxU5zAAmO6Q7xbb4Y +xx5+L8SxwUp/ABbHdIeYbo4jyFAPQT52Ehw76zRay72BAbB2oTXEYGyAXPXWMJhKpdhZ2xgsNEB5 +eJxCLElxGoOP4xSvv4alBLFZiJ28jd/9SVjJaReyITYX0QYMsL9RrIGHmGHaGFosx9ZAbZ/FAcyO +h497uUSeTi+UAdPFn9oaTDb9VciG+DCMVIo1CNxyutxeRp/T350mKEVuqSuJpn9GSFyXW073ZumI +M8uN7KvdIvvqskq/Lj/+ZF+XG9nX360cYsu/nez5bi/9+m2RLeTbLlvIt0u2kG+vlTViUqGKE2u6 +bDZUVBZgdwfN3vG8b/b+rRtm723/jlVP4TeSUBbyjQcEY6ijFav/MjvW3Rbg2E0+ew== + + + gwKdYSHfoKlqUqIfSkP7YGixvn93NuLgbC3W999aceGB/tKDXwE9uZz7Y2Cc9zs2kpgqD4PIPZlF +EZYAWX7BpgsKGCbX+MLVGPeJjcmUvylHylkRchFiarkIii7MyFQMFj7xKnBAQgxF46wbyvnecYtx +Xdoa3YXRnV1BfhtdvySUQwYs24SnF9+YbLH3X0evlCgGVxwtrnt2s/fjq2u2FiJms/3rh0b26U7M ++OBSq8r9Npd3K/4jZuBSjSiVe3K/4HisyUYVZncUhqMkrH4IiZDoAwGTo+zlIix9wqL0EMjDSFxl +PesNkUSsWjcDEWJ8VOk14kkxlJcIhPz4pO2G/eVspgqOox+O+BBB4H+UTv+6KsMZ9LcHD9z1LEoB +dZFeMh+n7Y8jZOdVvEAqnxT16m7G2TshO9zhWdKOwKe3WqLG3w0ce/YEPlsvZS4HSjH2574iobXU +MrIGnA7/olVP2PgKC8pU0Ml6FcRr3XBwt8SfL84V2+BwVJYqunMMnU04kMvutSUuFLmi+vj6OrBZ +WwyWpCiUwyY+SnMVeGDd/lIF309eOHg2s0JINszR1nixRr02u53AZ6iURgwAZt6MKlThKdGkRjtb +ivRZt1Vy+jLJIR9dhvQs79LIBzvoY9fYM75dhbYn2lVyFjbn8G+owtxaJCvh6B36TRx+0yjS9s/H +CBzyN0w1uEui8NaY5VlCZA9gF3CKIMAxvrAbdrCGsYdPNAq3uSSOLBaTuZDmWuuBVo7MfBX6nqxn +JlukEmee4fPXBD415zH7cgxAF29elwW4FONszSNHgY91lr857pUcOFkGV3zO4mwRt1DDC8NyL5Vj +LjF2R8ztlBeIwVoGsLkBY8p5rxjF40K2/aeNQPEhbKRI3VeTv4gko/sYJ8axdSEIzMVoW29eFkm5 +0P3zlvSOzUHk0gpwCRDpTJydJS5LJZh+5b4jlghCfAvSOCZI3HThn9nQbO9PIma797Mo9TLyV1/z +UVjpP/gQuYwIIjDok3zIHqUSlNuIAbbyYn4Dgp1bFpusOGS+p9oPO4D0F5J6MT7+zVYC4bgu8jHj +Q6ZzEToSmw/TAy6cKmcAZNURxw0kVaIlDWAjZAKlMyQlcbEsZiTsgaqyK8THckO6Ik4fz3UebrEb +T/EgWhnsUa581o2JBjg/IhsgmqRXJBoWyjj3+XZkC2Gq5AVvxEO9Ftsdjn3IJx39jGuSIP7ia+HE +vI3lyUrudhJvI73OlwzlYrY1IJB7v2QNjrS7jFYdxrHXZRSrhuR0TRLoaxh/pVxWPyH0fx4cyPPS +OBD4LFdz8jyIPL75S2R6+IRQZIQ/IxnbcwKnSkRrpPfPXBTZnpzp1Yi68ytHlvP9AqwmnJEyPcqL +JBtdo4qJGYojn8L2zmR6Qr7lEbbX+Uw8lgszpplpF0/ncly2rSafuw6XE3OtEZ9bRt2GElf4dSNX +6h+7BoyVcl886e09JbBGwXXKQ657gip890ghIw859hc5Xtlw1SLtaKRcyrbzTzgFC1abrAAok9NC +2nPfLaSd8yFlWbUjRPXZs1MkaLFVA3kxDKpSbJujXMN7M5epMu0TxGIaZGRxowM4IK4T5G0faoX8 +yfmnoSQLSJ5jzIPI88sbC7UfmUbVGkggJqPjIstQEf9RVKTqpniwnPgeKUQhv3zEtrpCx2t6Ik/G +jwoUzn+Uca8QwpgFwXIOLTaDMVAgpIliUoTJzCCKuaU00AA4jdfN5eQgdRjnUbICU8Yjw1+OSkoo +5LiRKJjpuNdPzjr1JuZjv+QBi7OGaZTiEcaeCO5CDRDgcvEdQqofieo6EpJ0HFxxwKWBOQdYi8bx +SlGPnrWBATZKVNE1idPZZrdKZ1+LFVTPGoOvdIWolcM5vBoQRs36Ef1vun7KwSuzOySRD1hhl5g7 +OwM283SxXTrkWrZbVF55MQGSW1dvk2SpaYWL2WjgLzJDZ2bnPPCMPk3Qp7nZlbh1yNLID3POhRwS +iZ0XZjP/jWepKTOyvIgUUOi+ieJLTTYDFVmv61hAUNC8ekqLYGYa4MScKhIRfBcwGYwY4rS0XH/s +5RKNW59glYbGO25Dgzu/iL9MLxnLZ3v2+C+f9Xi/xiGq0Pd0bsddiTzRYMRMDVvNZ3n/Ss2cSHnx +pCypdIKLHtEKaTEkjWtiBM2L65lylmmKC4gwlRw1TPFepKYpinG6DCdUsWs4apgCjl1qmhowTFFO +rwHTFEc0zudtqKOBuMbWIxX4TOXTdPZhHpWax/3lA3aNocTtEDC4PwY7GNmvjuQ4iD1lWMMTbVZR +mnMxcTWbFSmgD1K2pzwhCdNLkN4Pd4G205WaGtPDEGvWFTq6Qv8D07vboIrmdu9Mpoe0vhPYnkGm +t0YOuBnicmPsfmO18f/QAYfdb9jiO98BlxuQVX0HHM/H/lsHHHa/mWz/sQMOu9+4jDulA04GibO4 +HK5j47kcDzGDDjg0i1vG5fQSKAUuZ7L9xw44zOUED8klDrhd6k/TAYdVW1YbN2KkgjJ1l0A5xMi6 +CwYVGhyqBCGRFy7A8rvpi81/qhcOZfNJDVJZKi3PjtI1dP12jPQ2einS+/JVlnnh6uSWEQ1SWMU6 +R3rX27zUC5chUOJkKAzc8j0PxvMXIZqj1Ovtevb/1Av39Rfx7oszky1m/xmNcRKZTk3XoYnHl7cG +7GxVFscAbn85Pna3cLM6kSN57+Yyu9hxWMQoJ93Em/M9R7z1tnVksLn5NPqqn2XbuCJB8DghXPXp +621SK0lfc7tEbzPZjGpul+htMIue5uY70+0mHiwmCq7O4mS3m+/A7SanIXkyOutVuLrbTeF0A03p +em43wIgBWy0oVuJxlY8sGR4w5pBPS2ckUdZ1HNQl361KSKEMhxMPCOpZhEDNuNhbAoy62MTQUuI4 +O2JQvizKMPaFpP4xniGNdygv94Wo5ycZUNTcFcT2kvCbpxydLRbDtL1Zb4IWEs4Sta9fCmD3WYX3 +rHzZQYh08k7jigvDAfv6WEgE0H1DJCdVujtSKDI9opRJH0ir5CValslmdr0uxmYn8zYwu4r3TgO2 +6OmWKMvHTrNF9SzRzFYRSJDcd/EfBhLUahKvH0gQIolGAglySIDOxPNNco00rm/so5M45eQHy1am +eAWy6MmVjTumvbCmVK2t5iSdJNgOJ9J72lBgLZoFbvF4j9SACBgxHlRlY98MmwK1RdWYFOJezUO3 +m6o/DmFJxSPnFgE2i4BGVFJBZi/1n3A0rh6ZRd3TOVptV0W+qTe1IGkZBHmNxnk6iCf7kkHM0y7g +aIrTCMPMxVuQL6UM4k4x4GPjqhlUw3kxiipzqqiSAuxTJj/iOZqibMgboW1zukR68xOklL2C7Ap1 +SkhZRlUfkzRRd06KXBkAz9GwbsnxtP+Oo/GRRGwl/Wccja0ZOde7ZpSjIao88K1enaPB6csqwf8b +jia9c/i/42hChR0HIt/5HC221eRo2DfO8bT/jqPJ5f5/xdE4H6xCS7s2R8P3W3I87b/jaDi7g+Np +/x1H4yq4FVratTnaYYdclqPR5V+zy539RkGDqdmZ/u6hTw9nprSxGUSn+dRO96iZJD415A4N//9R +0cMsGBmDY7PUjihtbHnO2QwuuWO5pcjiUGLAPEMVftJV5EqOXofBKT1XqkrbxQwOZaroZX9cIfeD +vIvh6tpEQT37o92LAC/6iOA8WMTlaNoas4lMj4Kn870BpsffcaeR/SGtZvZ+ECU6m6CLoIpMQ4gL +Vmj766MW05MWJSMOI2N7tJ2u1+FIwhkUTg1rKnInMT0uG+oS09QA0zshf+y8QAJmeuxNFGcEEk5i +epwP1ijbO5Pp4XvhjLO9M5mevNfAUbZnkOkFFExPktd3nO2hcsSzmB7S+q5rqaoxPb6/2FVS3q4Q +TcBs70ymx1qvhtnemUwPeeFOYHtnMr3/B9ar0/f6ggKmH4jjdc2uzd+n2U04l/BpY72khoG3Xv8z +hY/XYDHvAxBF/xOFj7Mr/2OFj7uf/xoK32Ctz/lMtuO8zyGE5M9I9sWFDLJbzdNUAKWbJZGT20cp +r2UxmC+iFkeVR3j1I6l07k47mnlyLhzu91D7Yd0yfIlQH8GT4QLxCuh0fAkNfTNFkJ5lJo09il+0 +bBX3a1jty0iMOwDy+YM4Kw5dWxcC1jTg037bjbABe1fQlHguiLPrpFxQfruKjAtG6OxjNAcQe+zi +y2bQDY45cgYoJomylt/nCaTBuhM1QO0yJXUDUpEQSoKMU66feuyQjZ6Y9nuK1nckzpqfx3JB7yeO +sjLNvGMWqcRnS/hn9GmyJbvZnyfPlUseFKnApquUPMhp/9Crp27vXydSIXr1TLb/LlIhevXYexQ1 +Sx68EhQ4L/aK9Wku3/KMci6kH8nv0RmR05c7YFH5r7ziUizeb3leRrDRfGCkwxS7t2hEQjUvl0VJ +qWNtIF9Ih2WogphAiYEehWuPiyOf7NyjKBczT1MuH+qYfeDcK4LC5wyy2SSIEeIYX4ASFMIgl04H +X9HNm4Ra/pxHM3sON1iRZs9x8gpVC2KJRRdbgc9pL4OuYWUot7lSgmPcNlldvk72EvAeUxOThnXZ +KPzCeRcnart3/s4uOSO9etKwpNuvfv7cHKUKv6IkugcUzHhGsY3pSUogW/N+kQFsQAk0aRjAkzFz +RSUQZRFcaAAbUAL5rhkXGMCHSmDrR6EECn1GjBvADrZd0ylKIFCloAYivuM0fIXZKUogzPLfJg3j +ZDo2LqabNIxuUrmwIAJpSlzScEDItk0cJA0j5x7KEgb28cBe8IDqvAKo7CvEPtUtksCYLC+TwI03 ++LtKUaRiikpZM6Bsde9RBkqSGlcdRVD46mHQ5egKLK6UBeTrxKhCx5ejc4FRg20+xN7oBaeL6yyE +822OuogBljHLhCP5ApFAVvOYASK6KoLBTbAsE8nKH/4m2qBLIbskLgEEWRxLWivLII4ogSo32+GE +MOZz1GjHh/XUO0M75qPQ92Q+Zj6fhiWT7T9W+LC6x1LlBQqfnM41wrgyD/x/ofBhdc9k+48VPqzu +4Y45qgqf63KFT3AinFW/D792ywvA5CQVYaTXJrI1if+twoeJhvOQnG72qhi9Tk2jF+tjp5m9Hph5 +nmILFA6N3hdcv48uew+iqC5bGgF8DHNB+APDd4E6SDBl+QUwqSBfzMemqN8rg7uo9gtVqTaQGhen +c/b2LfE2tlZwzMJFU873pwJwqm0QWHSzAfrfT4mcVe7GvMNPn2Wi6gmLH0zm8VdCyTKRw89k+4+D +u+q0b3Z9LufIzbdD0Y2Z2dmxvF18VQm+r++/dPNx+hioXY2GcIzatRKXVErgmIWhWolLKiVMfKfA +o7USapUScjhoV0oItwSo1UqUn//OrnbFFxVKKlOw58eb78dJn41A1N0Kozuzs0Bevdx1ElfYTEj9 +EEf5YttW4iEJXM3DFyewYoQNPEkWtMDs5k/4sivkw2O4OjBcNbEmKTjQzvaUsEZd5A== + + + cqrnwoh8Dle4wGr9SeBZj3ENLqe4/lfO5YrpMvJarzIlHDRR43PX4XKHXZmORHPP4nLSyMh/Z8ey +EV5tPncdLidI5AsrwvS5HHvn8OUVYfpc7oK61/J4Y5TLSSK8Ap8bK1KOL+dyklnODOQa4XJcfeVx +H95FXM50hM9dh8uhHEU9PncdLoeq0fX43HW4HEeVZ2hzrB8m+5z1HG+3JfSxOr/hFnG83RbWlC5r +uGWg3Za0/8uZDbcMtNtiefJFDbc8x9ttCTccnt9wy0C7LQmH0W6PxSKQRnusQ6fjYc8tOJfLh+Vb +b2k23sLncq3WWx6txlvi/WNXaL3l0Wq8xfbkulLrLc1iRX4vV2m95dFqvAXW62mtt6hGWOFeN+Ap +4zuzIJ4FfxigrlRBJ3LD+zHjFriug73EfvG18HBMGF3rD6zXw0nSwYrlbZQjYx5xjCnvR61sW6h7 +6WifqAY++zs/i6afXtDJkKTBMXG1Zss4ynPgtHLOe1yZUirsknA0/mawVNIj+evkprqGv+Ux83Si +O/SXbG8r70t4IbAwOKbwQyX/uszOYdJ1jsN9ZbA4Qgo3gvacEUEB5WtB3oN+XulE7Mqa4Ttsle8I +rNDCTt+z/Ng9Ch8Ewd+I1A6u/m/KFCEiwX/4n0Bn/73Y3G0+3z9//3lNcVMgWyXJ3u98VdosFt3F +/94VVrP9z+J39y/2L5C9z1erkVBhMVvNF/+87PUiIjb4ONTh1CxaS99lmUThLVpeViyd5KTwRgxS +Sr3fse7+IRW1YrKZPTO/DTkhn8xeqnRvdla2XvR1wN5/K+rcB85hrB66LYXFJrcvem4bjwomh13H +0dduOWmyFR9zi04msH1PBCrZYb0wLD3cZwI7YsXrVRI/5VoIc2iZIDgMt7ObXYlmEPV8fYB1Lguw +F1C4A2avK5NBf62ZPe2bJtpfEz1Im31Zeo7ura2Y3X+WjbSCGjtZ7RRnm4AGEefOuDQe8yjWWokB +dVBHve/vKY8k5rW88fNWw89OdASjII+T+/S1cHNkhyq2JWSHv8aciHgrPu7SH3yPLteBrhfb8X7/ +KiGSBtgKuygv5+WUJO5AQUzWfJJ/kPfJlIbcsJfmH1UD0m5yIsqn7kjhwQun+ZaTolbyIp25nGeb +gLLl3y/SuVFdPCqTp3L9Zw/rvh9tv/bwoEOydJbumeFrKyOOPYZfBEGvapWw8uTmQ4qFJerJF2GN +nwjuBAsvgREJMtYLE/xZ4WsPD+tmDyfQeqIDt/dLJJe6HonSMLf7QVgMGj5h0ldZ4HIIECsEJgm7 +YPJ9aZh0QpNtvtO2aNLBCn/z4ohq47HuSMMj8mEVWXA141h0C9V50nwYH+hS0garlOt7bOHQazAJ +ClufSNFreofZr5dLZZ32AhzaT/sEOW1UXfDpieTE0PSFSkWrFJzVdIIS6LnP8yAegjvaZQeP6MON +sOFrP8D9evlE8J9eRGybSpXa5ZyWPEBKLewFG8mvt382XlX4YSSG5eLF9Zb/YEp3XPjleICFFWJi +gGXXlzZZnHHIsnshyDKZQdJ2QvKf5pT4Hqf8776CB6sJ7R5KblcqHn7w3dyWXm9tUa4sHzXOCqPk +5xDSLBiFBS/11wtBGUl6g64zBLN/96gEp48EQN/sfXgpAlN87JtdzaGT45v7WAux1Arw0nTX7Pr8 +Tpl9v+1nxEuj8tLNI0qKypW1/4GSgrglr6b8d0oKy8dGHAn8V0oK7EVQU/4bJYVLCNbokb1Wi/4p +wrpsFFQUyxiprMWXkKJtlvwyJmrrkzbOmkXqkgQb/Dfzzil0lti2DjpvBd1lf7CS5RtRJVdurkRH +1iIM3UzBt0minNEBLWsRxljMtpy1wA8xk/WjxwPkApIByFK/TEpcqzmO7Nl8htvfwGeqV8TKAUK0 +FMZz/m8Pf/zfBpvA592vRzT3McrJoiwXNcPALIxtp56kPELPdHfm0T3hm3ORfo/QnMtkU7bnwvao +bnsu3c5ULhFiuDMV7kuFmpQY7kxFntvEQmyHEFnzQMjQEiDgjmkcEIIBEQhoNUtJc65cf+DTBAHf +2CMdW/7yQHDb5EDwCUBQtmkzBoKk2KLmvIYk6VhrZ6BJm8nm0WrThhLpXDwUcWc1NVTS6fPGhvfR +AHD6BrHxYAjyxmN0DVyjtYMhYk7vZdvI+30iSZls52yjFwuc1DLvkCq90Z37EpwmvXmbRzEABzGj +kEAZUT6jbe/EpnfSpqTI10iobsMgKNF91yQeYHtTruT4ARiLyYZaAf5J3izn/lzcm6UvUnwT3Qn2 +KsXzydhxIY7hzOWLcKwR9IsDaOKY7hAvGeJSHHN8OC/DMeLXpYFjhodoeLxHEUQ6AN6EHMdewv5L +TgO3U1cbAHDM6BDlxs1xclUfgEtvRQqfYd6nvoYXvzoo0Rrw1Q9HTwMUzKMUr7cG9sLiy04DabX6 +oMTyRW8bFV/pNNo4WAPTQIGoS2iDLSXVXcMmFSAlErkS3Pl7CckQ0xfbZTJg+u7x8BJZdxU6a1iT +2kilWANH+8pVzKxh30UYMfMl/SIoJdzyiCSSDsHkVUlccw2H3HKWrqalXyt3GenXdi8r/Tp8ykkU +TJfVH5N+9QXjUtqnXEwsIX2eziSlXyullPRru5GWfh12MtKvs35W+vX7JSeU6IRIJ9Z1xSJlDMWI +zzwLFtKecb+wn5Qb+VEtyicMhDKiQ+wZbNv5lo3KCWFWNisfhVnZS+WUgdZrh1nZWZSB1jPCrOIy +QYq9Cg/cUv8YUqKmwiNp7BNUIyH2WfdLH7wn3yRGv/gAFJkPIVrqEq53b9xMhL96pMHVF78QoWv6 +pA/WMRScagpBtSbBRkaBZyGVu8neCoqYx0QMqrU97EtAzgjJ2z7BdLGypT7wNz8XYWXyaJw24Uk7 +CxuE5/grNywgNsn5/wYlj+BK9fIXGAEmC4CR5cwYDtOJrdGVQbpuQF7OeoURCbWsHpONSfWCzWx4 +NHcelJQMnkQP36uIXpRrP18KIVWvNNZaSSL99pG7ta4wrPKBKJTXE2JJoPDdo7hP+6cXtjar6JqM +uU/UO3IHPoa4uOowg0Yc+nHrDqE0w0qN9x12bOrV1f+QhFQpaUg1Pv/iFzoMCnHjqWQvr4/mvIEI +uXZhtk0Rx6Zt+6rgCxsFWDq3U70gGzexx59C3KfC5FN4j+bee/jJShIcufXc5bujUuH7ZpbtdJ8d +xakv84hzXRA34f3JuzUjZrUjMzokuzZX/c5fk/LWXy7dv7T/xpwKOUwIjlM9FidcFdpkjI4EdVBE +Lkuwpb0ethQNB3jImwAq6/XgZHHJRQY+nOgAf837U9HyXV8IUru4cpVQKcDlpcsCADgadJBDhh+k +gpjH+3H2iJDmkorhbTgVqSOsy5JlnqlqgAhN6+kDjgYmHOdlVMaAuFuQcWlu0g2a21eK5WOSy/e4 +pGWf5Mo9lntx7tAFlio4/COOLcaA2BKr9Mf2/6ZMgAAoijou/s6lEVSTzQZ/uV/s9mv0QmicW7x/ +/jYm/2exMRH/SPw/gvtfOPqPpCL/qFAIvoTQXxpTk7PykM3/q/5OZrvP/7Vw/Wv8wu+yRZNtHMhu +doVP+PPqd7L5P/9i6E/920avWvgX+4d/NhZ/Fv/nhOURY/gNvOBCcdwxLHmMBjOR//r/Ax/wP9mF +aQ9/yK7hcwH+/w6+EP4gt8T+/4E/1eDDF6z7f/6RxL/bf08j4t8c/bxjooiInyGC4RBBUQxDRP75 +IoQ/SkUpMhImKJIKMf9+VF4i6bCfjFIESVDBSDAKMGEofzQaDAdDUYYkgzS8EqH8wFUJMhgi6Wgo +AlMz/jBNRkPBIBkMA+gOX5mZQrByJgqjRZhIkKQplZeC/kgoSoYiDEFFg+qrOXzlYFcz0+FLVNDP +MEyQCpOhUJih/h0shoJRgnQoHCaJaJgIUod7OnhjZjoAzcE7h/BVrsTAMc1MuSmcvLP3+zv5Wcz/ +vW8m80+UERANugBEfpoiGIoJBhmaIaNRhK9B2B1FUxQMDmPA2v00QYVBclHhUCgUpTlE5//NvZuo +MOUPU/z/YBQ6QvojJP8/JvyPjMJMkSjsM0rD4CF0OAAiggkBqJhIOIQ2RwT9APYQxVAhOgz046NJ +WEswGgyFIsEIFYz+6/+YgsFIxB8OhqMhgFMoEvoHxxD0U8EwYAFAE07DyFxBhqT8JIVSEpkgTTL/ +fAygCJxHFE4sGqUY2BccEYwUIgG4BOBQJAKgYCLwK8AngEYI4GNoLpKi/XQYDo2GbdEk3inhD4dg +bthyiIr+y11pW2h1QSIcZOAHMA71jwn7aXhEAYpFo0AxaFNvQOG5nAbbUXx3Tj5jseL39+d6C6wn +0Pv9RLkj97vN5+/7P/ywAUzp/mOyXsRilcnv/HuxaQKasWxJORpF0LBFQCFAfZoB9A10FpPvf9JJ +YJTF5/vHjh2A/BfIrVbKN/Lfq9nyfz63C+GlKqCz/J3q7+fuc/Ld3k/mm8kvNxyhOmHrEzY02eyy +v+/fiyMvggQ4+lpntZugXUteBBIISsiSVv1dHohysRnwv4gSEg4S0flFn/2FIeA+fs53H5zMODi/ +1mQz+dmqP5XLmYXJvUf/XZsIQephgfJuIomwP0SEEUMBhgGUD4ya8dMgDkmElvBnEBzoJfhTKArv +0UDwKi+hV0gySgcjQDWRUEj1FQaACmRIACXBX/lXSIJkouEoMDTEzSPAVJkICYSF2CaWLiGgcypC +RcNhJgLsjPITME0YyCQKtMIKjog/xDDhEDC8CBGMIBYYooCPEdEIkG04hPlsKBKBjzAQGabDMBUF +vDnMAP+OolOLBoHOkYgCjhkJR8MRYNn/glE/PIbhyRDipsDAaX80AsQKfJ+EVQfxvkFUBRk4SSIa +ih6+McPgY4BRAgSDkVBYYxQ0KUNGaFgkqfZGxE+EaZgjygAj494A/g6shAbmwWAJxfiJEAV4C3sG +xoTegS3S8PsIwZBoccBFoyCPgFED0waR5YNXwgwRIoggwaD/x6/AgYGgjFKwHoAKyIYwHYlEgJkC +T4tE/uVNBl5q4JdoGjgf8G0mFEFHSUf9cC5AJrBUgCeoGyE/kltwiuFghNFCrCMImgceSYLOxJ4F +UFMwCAoEwyAJTROhMMgMwCSEOj+mEKwzCjCiQF0IBUPBw3dgcBq0jxCwcoBvhMJSPBJEGEJEETSB +1wMGAoSJMPwfEWKiGL0YAjF+CnCADCP0CoGIBWkaBjkIsipMs/wfDgy+IqkFuA2KCRwnHAysBuRC +mNWSaApJNBJETYQjGpgbWEWYVZLgDYaK0lGahkPDCgOmPTh1OgSyGNCbewkoC9AF/sCwUISjAORi +QgQSYeqvhAAKaCLYJaXyCkIx2g+cK4LEF6I+lZewjgObImE5QMKcXgcYGGWQxoJBDkQOCAA/BSGO +lEOEPUCVWDDCfxFxElE/BfQL2Byk2FMAgAI3jgLviIK+BWoNMGngJbAdIHM4TJC4CA== + + + nCEQ2UTk/2PvXXttO48rvV/A/7C/NCAFra15v8ifKLWTVkA73VarrSAIBDZ5IjORSINmx9a/T9Xc +pLTGmOPZZ1M4NBqB1W2bPHrOusw15/vWWzVqVP2mL8/MWhHfuo11kx4vv/W3V67e5vj22h1bPWvL +tq31A9/vh+vp3bcryFm3IdxV77/vfvFtUPe37/756X/5LqD71T9/+s1n//D02Vf/+MenqWK7WqEq +tjzqpqyn4+znd3ha6vE8K2CsW6sC5+la/I66rBUg1MO21sLQt9BZK8GwVeRcK8RcfzLUt95qb9nm +jlf2fmn/o/tfW8bn/qy1zM5TrcdjB13P+1FxSIU603EO40vwWJf3eTiHY+rl96yVqH6Q51646rau +tbLXqoqUl/oJ6grUT36t4fv43CHpWotcPVR9h851Iy3nUFB/v75L6u1qmepIfa1l4woea0Hf6wKM +Y6381yLXV6hu/7F+/wrkj/lN71W36vhci1stSBU6T7Va9e/4vNTjuU91KKhwsuKsf7Xv9fMP9L3G +o9elsTbC+p8Kep/GOgoc43jU6WrqwPwhevyffv2GAPLpp3/71Td/9+6zr77+vA4eV8T0r3hzXfHP +33xaseq/1Ds//egXH//yu0flv/xfX339h5f/6k/hzseff/Xf3v3241+efbL+1Td//P273/75u0j4 +U4fsz/v5m36Q5+92uLqu9/b0ox8//ebvXwTenZaoq13hZ8u8W+5dH+/6twq9f/nl5+/+pf69AsBf +ffPV1398+Pf+ex9/2XHxF5/+U0fwLRn/6ArePv/TO3ybOPhTzmCqvaAPGXPfxb2Kn2ctgltteFPt +eLX5dDx3g6ba9Wq16rW0Y5nevu/QWJt1PTC1oW/DXhv/U91rtatUNNFb/HSdyp6n6/RT2+BS56iX +XWXpyzpUVFe7aEA+++isfXGvc+1Qe8RY7xago56XOuXVnjJ3uHiET3NHbt/qFx8FqDajunP3CjCX +ih23+upnbWn1t2p7qtBu72D2bdD9It6hca+Ho0KQ3g/raLo/1e/ToW3tWHUdK5oqpB70ufAKAvo0 +sYSLeENqJ6sLUrfl2qeWotb0OhXgXjfCPix1g2/h09yRcBHD6wxX/Fe74FBH/3O67p8+Rtc2WMtX +wb2CDbWm1VbaF3CqJ6qhuR6oOqrXkXeutfaC6iPVla5jc+3/dSa+skIdpldMUdt0r7H1qa+VZOnd +tY5nAambd5nrLD0e43Be4X6Arqe7woj6zHO90lN/5LOXzvq+te7396p1ehyGeauVu6K2l/u5HokK +xbZ64WUPSN3PdeE7GqwbbeqbLUB7hR39BWq5H+ou3sOnCcj9WwVorIhxq8i0VtY6KI1PFaDV6lV3 +V51jjut7d6RXx5x6ujroX57q8y4dOdWvUtdzn15+qs5QjdPSv91SP3q4letHr5ipIvpaJSr4i/f7 +Mj2P9TtVGLzWdjsWc38E38KcR+1ttQzV0tyHw3649qO2yL7KPXFyuj71+jz2JjPUPlnXYq/zXO2W +HWqOvb70xemwvL5oHRzqCLkmJFzkO1Tb11rng4pQ60PVNn/UZzmWqf9lOzv4/Env4HVxj85mznUC +S7eOI3WX1uPWS24dQPuQkKCxL1f9W52i61ee06cJSHgg7tDYB8ha7/s614P99HJiGca5DgX128wv +l3jts9i61cudvWC8d8N5Y/Rbi0XH+3Xn1A1V4czwdJxXIPHtf+rWHZ/7AFM39zyP9YFCarODke/+ +cx0dnirAq+tXwcm+1j1et9JeEVr9p+7YvsEr0PvJ418a9rVOJPvw8IsP9TV/Uj9tH+Lrm07zUV+2 +w9OHv1en9oovn46+YvVD1MK09XX7vm82XAfFCvvqutevXSvlUe/Zgdy/3hf7+Q/xxfq4dTxttZes +9Y3qxepJPMeHCPXlmLXva60Ex9hr77ZWRFwbU73SXLH6VIFLLQLb/nJorCeigsY7dNbL1K07nZ2M +Wra6mhU317pff6vesc70S0Lmjv3qvH6udXhfr+XuBo2d766Vpk7ztWVeq93yvOy1ANbGWDvaywpU +54ouENTS24nhl6Ws9rLaCJY6P9aG2Y9ZHUdqNz3ra9Tjs/QK3bmtin/qqFHXqpFa7uoh2/vUXJ8p +IfcnOkAVeNez2UtmLTv1dJ5zve5xrdd7f5PemmoZuPKQ9U16WXo5ztZ5vmL6Ze/j0g3paKPz8cux +1t1wLNeSeHudWk22ucKDipyPl5TgWjdEl0Pqhjg7aT7WSXntY0JdvWO/ciRLLaR1k/Wif8zX0bm3 ++zqzX3mSjriLWa7woza0vZagK1gd6+gz7HWV66HZr3pTrYn1rftQXlFbxaZ91WuP2fdpH8frzh+X +iiPqb3Z+rP5nTd/ckZdgtS730b/4dq7pda7dqzbkrVMk87Xlzkenlc7ac65DUELC7xmgzmMOXYQq +aru27q78jMtwRTV9BetSzEMnrLbOO11PRO3RdZOetU6MVw5pHOo5qqd5rj8ZKtSoizx0Rm8+r2it +Ys2XKKHuzwqvp7UznH2Vb9DtwYnQVJ+5f5p6KOrid8Lkhgx9AqiDVcUbnUR5ui8HN+TlJlyWuY4I +HZvPR3qdO1Lbae+lWx0s6umNSK1tHUDNHY/Vr3vdhA5dWbf+SkMfcutc33fhUX/Utci6C8br1qgr +3ZnqTvL3D/RtXHxUhFRxwHi8pMG7bFZXaB76l+77sG6FekjqZDxP1/H5+t3rsT3nY5srlFsiYvfP +L67ous5lc+cGz5enwqFPElRfo7PPV3xf4dX1ZrUUVjx55ePGlyWsQv169uvQsA0vT3ItyHt9o/qd +9/1lKdymjisrZusk6cuT3Mn1o8uDLx+61tSlntF16BTLdN0/N+j2cyRoO/tCn/XTVjQz1TJ7hXpD +bQkV0RxxP3nDlvPZ20KXCjfrB694d+yE/ZFCl7lTgnW16mvW2WZc/4LQ5Xxa57oJl04lnVeJ0zbd +ek4rEh0eNoGxNwHd4euzeOjSbO3wUx8c6hxaO2XtS9/3zTonfMUuS0ewtdzU9jds25tilw/2zTx2 ++SDf7Kw9frLYpZbwP8cu21WbaXlBxRhzH7278jK01mGr8KHOGhW7dLG3M8gdFuxbn/Nv0CcNdWBw +Hh1azX1GAKhVBbUpnvM4ITRXYD902qKuzIlQrdy1f9c6Nm4TQbXdVOi318Hq6GctQ2v/BlPXS8cp +XYIXqNN9c6+bR+d5MlTRWj0jV7Vsxg++V4hQR6QrsMFLcK1HFZTUkjwSc9Ta2z/L1BeKoNo464ev +cKLuCPxIXaWpK1lnvEuikKA6G1UYUPtwLa0V2xE09k551nGvPhN88IK21p6stX0ME/x053PtD7Xc +bF2KGhjqomAdIKc+TxPUJ9eKh/v8vcHvez7X1Z4qHjzqkg/w+xZU4ULLOIYRkbXPwLWPbyc9BGcn +5wuoc9JO91uvDlOtDvW81Q2Mb7a3bKMiuor5DvxJjnrqt14vlpe0WIb2tZNg09qnFILOpQUptcHU +5ph/3L3Xo/pQ9YfntMFz2dDWKfRa2eqViBnneqd6v2Ha85VspqLodb5uSoY64q4gtMKmDW7cgub6 +Qerx7TI8LHENXWXs+ve6KfNyUlDtDhXgdIC6jniV1rGTPfvYO2u+3g216qtOE1MfIAhqPVFtB53H +GvES1CJRMc/YcTOsJw3tXfidzs72IXR0IFnBda+s+NPVx2ltUy2XXe8kqLVn17WcZ/jgYysm6iXq +UDhv8Ow2VPfSXI9tBfsLQmOtSHVH1ieD57vLVNN+VHzdKo9XoHpM+sjQdTG4TGPtuLW5V/RW6+6K +r7R0AfjoTMM4wmUqqMs2tbkvl4YEoN75626b+s/zOrh3TfBKt/ZSf8KTOV7Hq4p++//P8ByMte5M +59mVwpa1EVSnvYpwe73YZvxMXQMcOvvecStBtXvVHjZ0nm2Be66z8UNvF1sdU+DdiumHZa8Vc2hX +I4BakVC3Qa3fL8WRDNXXr2NRx2ELXIE6ndQVqqNzXag6NRE095Gvop3a7SFEaahjxa667rXaE1SR +/Ni58U4+w7WcWmZYgVWn1ScIURqqz12nm/kKdAlq1UBtQGu9544XswUydXyocxvtmQ3t09nhSW35 +O16Co/6xk9gV0KwI1TGqDla1YB5XFgSgbevlsNbDYYQfeK6FZ6jwa7sEj3CdCjo769Ill2WDH3h+ +7vTP3qe7b9WnEWrlU9f5a/Whda6go9fKqbeyHX7guQVk9ZgvvZsRUs/JUSvl0ZkGuEoFHa0cazln +51AAWusOqcvUDy8tBPMlMDo6bOwcLEL1T3WY7bz7Crfc3JW6rZ6nimhOiFIK6hNBHdbOivonhrZL +E1OH8nmDu2mudWfskLDi3g1vgU4T1DKwrnXMh8u01LpTB5quc60TXculs5JnJ9nqkw3w0xV0dEG/ +pUEjhSlLrTtznQ3Wuc6scJssz/XV6rRT29g6UZRS0FGrUj0B9bgc+Ep9Hr0yGgMGfMtzb04doVyF +cYSu+60uQa0Y8MsttezUgWbo23eGg1hBnf8Zu/g70HNZTJekx7219RSkLLXqzK00r5BooEWuoLN2 +ij7QHgscVQpqhcDRD1wX0TK0Pg/TVvFVb3cHHMQaOoetbrijE9TwmdbOaLfqsPbVgxa59Xm6btwW +PlY0h1BLOyssnnOC4GLmpXa4CuiH7hcgqALwvaP5rjPCLVdQ/ddHVyZqL8fLtPYSOG6tEKCnd60/ +qvi5NpQKIBeGulRf92TFVjt+pr03wmXoKgitcgX1Vr92LnCnIGWtZafPGUsrfOm8sj63NLXlgPOV +5SXo7BLMtg7TQmexronW01L7TpcS4BJste5cS9xZywFFKQXVCXrvlFMt4vDBt9aP1a7aJe2Vziut +gJ3Po27cs25NeFgKaonuVFvYDsf6YjrDW5fqbFk2XoG1ayt1bKtz9I4fae02l7qS3csAF7wrQrXi +1N667ycFKd0lUU/w1nnhnQ5jBbWm7jr3LHQY255bXHapdNeWbxN0zrU/HVPvv/iZOoEw17JaPzCt +c3stPHU7DXVGmhe64gUdW68qdQ+M9GzutfC0qvUqqtM611Wn9ZI01gshsteuO3ewftIqt9e6s1zF +vKWFuwS1MKVWlIqcT3p8C6pgoTuTVjxn7s/dLbTttdB39xRBvQZWVFzn1Y2/XL3JWTvPOtcr4Ufa +50617VcnB0PddXC1Ey2QUG2lzVo//jj2AZFWuf35RYddZ9vephC6CoEVNEwjxUTHpeXv0/bRwi+C +xhYr1mdfO/OE0FEXYDmvABJ+lqOWnbWbAOqn2SBdXNBcd2WLs+aVbt2jm6e63l+HrPWAy3Q8L52w +r0PG0ts0QbWYdGdIRyq0yHXnRzdMdYg102HlaIn61oXdPmnD71tQi+Cu1MZOUcrR7RKdb62IBoOi +47mV7bUGdA2CzrUFHbXv1mmzfjxa5Vp2OK+17yy9Z8Ciej4PnZuvSGav4xhcp4LqQw== + + + Db1ibhMdxc7ncemjWoVY9ZngEpzP1zNwzGMLxhiqYG5piUNdBfiBz+e5NrGplWfd0kDQMtQWVT8J +HQyK2OpAM7aMeKMH86xlZ7pUEUut4vj91y721Jm+bmB6es9ubzhqyVn2LvgT1Pq1sWvj4yU2BKhi +9E4kHec6IVQPyrl3XaF+F/xMXT5duz+iPhNeybOD/S467xTwHcNzV8nGjgiX48x3XEFjhwP1Vvt+ +qTYBann7JTGkk19BUyeU6yBe/zv/vsfVTdE1rFqgTjis3KEXBU2HY/XqtZKmd8uMfWyA9AJkyC5l +gO4/CkD682bIbpQM2S0HkN68GbLHIEP2QAGkj2aG7CEH6GGtyIQtORmyxQsgXQYzZAtqhmxpBkgX ++QTdtosM2cYDkG5hGbLNMEO2rQKkG3SGbKsHSIOGDFn4kSELZACSiCgzFlplyII0gDTcy5AFjgm6 +haAAaTCbIQuLM2QBNkAaqmfIgn6A9PiQITuIZEhPNMDo0ShDdsjKkB3XAHo89mXEjo8ZsoMoQHqk +TdDtcJwhO2YDpAf2DNnRHyBNImTI0hEZssQGQJoiyZAlWzKkWRtgNP2TIUskZchSUgBpcitDliZL +0C3hBpCm7jJkScAMWToRIE1MZshSnABpsjRDlnbNkCVwAdJUcIYsqZwhzU4Do2nuDFnCPEOWegdI +k/gJupUDMmSFBYC0RJEhK3YAJFWTzFj5JUNWyAFIS0IZsuJShqxMBZAWvDKklbPMWAkOIC3mZcjK +ggm6FRgBkkplZqzkCZAWTzNkZdgMWUEXIC0NZ8iKzBmycjVAWvjOkBTQM2KFeIC0pJ8hEwdkyGQG +AKlgIUE36QNAKqLIkMkxMmTCDoBUIpIhE5tkyGQrAKkAJkMmpcmQiXIAUnlPhkwolCGTHAGk4qUM +mQwKINFTJeYmzMqQSbwAUrFYhkx2liETsAGkUrgMmaguQybPA0iFfhkyyWCGTHwIkMoYM6R6yMyY +sBIglWgm6Cb2BEhloxkyAWqGTMoKkIpiM2Ty2gyZUBcglfxmyMTDGTIZMkAqaM6QSaMzZCJrgESt +nRlVfQOj8vEA3YXoGTJJO0Aqjs+QyewzZIJ9gET5nxntIMiMNCIAog0NGbLWiAxZkwVA2q6RIWv8 +AEhbSDJkzSgJurW1AKQNMhmyVpsMac8OMNr8kyFrI8qQNSQBpK1NGbImqQxZuxVA2riVIWsBA0ib +yTJkbWkZsgY3gIZu9N63WiqhbLTtz1cKuL37Tsg33ZhQ77u/GUDv6cv75C0NnktFFRUzbxWG1w11 +nKm/cxs68qjDeh3qKzDcv3d/59k+xNtzdxeO/UbrlYuSxsRe85+29eHq7Jt3QbYhpvV31letz7PX +AbKf9zZ02fd6IL7vm43XaeBo27FadmvT727cN7R3fsAv9vMf4ovVZrtqe+fUwdWf2zu72nt0xXDp +R7tX3Pml675OZR2pXObaDa1jbdvtDdHVohuTysYZqpt23zs2Gbeu3wBUy3pd66GtkfMr7S9+iOOV +amqXO4Jqp+2a4rheBTOAtACdoc4vVTDYqcTzQOgK9DvSb1NkYNpgs5Pu07HnK9BF6vb/rG82t6kc +QlrJztB22Y8O7ZJ64hWoO+Uqu531eONn2tpQp+LKuvFO/Ey1TdQqtA29x+G1tJp4hrpGXUf1ihgX +vJb1HO5tx9lxPH65ZXw5NJ39AAHTdYm1NudeAvBSWnkdoKFLSuO2DjtfyvYVv+pza1vXElSP05Ug +O3vNBaiCrvmKT2tlxitghXqAhsuAsR7Qga/lUCHnXMHCelkUETR3xWWfrlNRho6rWFI399zxEny7 +W8kfoPagaTuG2mLhM9VGvG9tw7Lu3V6P0NwHq44+RrovKz6rk1fbStVTRRfzJh4AqK7A3s4P+6VV +yFAtJfWM129SOwJ+u3pqW/IwtAMNMp1prxer1ZceqJsKAaCprTrm+ZUnqkLGs7fMrl+MzNSjW8tc +nT72FX+ULgR1bN3xB345kzMAVDdTp1i2aeBL2RapW2+5faxHqE7oc+1y83DO+PO2Y1qdQLtaz9fS +lBEALdPcpi5tDoU3yti2TF13O3a+CYb2NOrRDnO7vhI0bUvFrXUE3ehi3jQWAHVSb67L0D5ZCHV4 +fuWrBrqYbSFeH3g7O7FFt0rbBc5d5ag/O3d8JVNrAHTVQda6gY8dv11d7qUe8LEfBWK2ij/aQKWV +H/hCXTGrFWNq/QC/kso+MtR6rVp1l/VyUCJoWrruVmvrpbbKUPtfbT2Qox5j/ExL5/Xmtv5a+Vqa +giRDc/+2W+0/9XKw0hc0V8zQHjYvnn4Zmuqf+8mrmPnEz9RVvLNlPdtVOwfoUYuSkfrZulIwnevG +l7JP4EN7K/VdR1CtABUZj5fZMCwE+1UOrH1nrQVjwR/FVC0J2lqZ2btmrxh0X17u7L3SH72TwY9S +UB9h2ry1Fgv4TFtXFvuBqs33quYDpPqYDNXnndtGcemJJQitXXjapxanwY1S0Nj+VlP9r3adAqhr +lB2FX5UVhFRpk6H1bH/N/ao84CVYLxFkr7+0+bQd5tnl1/2y0yao0+hTTxKoF8RraZIdgDq0rAXj +6FMNQXNnLNc6ZJwjX8uK9Y4KL8daeA78Vbpwurf31zHQ8eim/gFoHNow+FKfwkLQPnpdw+tnYaY4 +ZevMdRvO9QkJL3itSl1K2GrL52tpMiKAKircz/lo1zK4AnXCr7DxKrvMGz11nQZouWQdsuqS8isN +Hci0O/xG1/ImSALoKqj18rvSsX193iu6ahvguTWzCHXtsbMrw0zno/WqCneRpyuHxJiyCaCKsGup +q+PYztey/vlodWbFlxteph4L0UWXzuDzK9V5rX65rurTWfOmkQJo7mWnrcXpdLQ+t99uO4l3FIIv +NLfEaO2476TT0XrVqbfWpnb8SJCKrYBZeq7FWp9p4ktZa+XaPpDDtNPhaO1qQdfNe64UnTTXLni3 +2H3vxDr+KCbbAmjtFXy4Hit+pVoB56NnsAx0LZfnS+HZPnLnQifN5aqd191WB78TvtxN/wVQ3f/X +s1kYfqSj/6S/fUXasDovXcC4JgvVMZJO7QUtPYqkPvg20bV0JVlm6m5rg9MeATHDDV5Qj6Dr2sxJ +kVzPcqtdsPbNdT7pkVuuYv5ZH2i+Jk4QpJK0DC3d7tLbfUWz+EpLHw37der74SvVLz+3C2SdWXd8 +pZYF9BmzgkO8lKZty1CFAu2uWyvORuF8D4LrclKHqgM9cwVVyLh0xvigdXBpecE29l4/XzVKgFQl +l6H6QH20H2pF4UvZpelLOdAG/QgNneCsc1jv0hmaL6XC1qN21onO7K63y0yPDWnxzN4xCkJrKyl7 +XtNK4XxBrVutp2DpMSUEtRV6pwfqU9Mx86bcA2hoP9c60G2XUDBD23ZpIGsbu+SyAE0vKoxWROMl +aPHE0XMezoPuy5sGEKCe21Lr03hstH7N3Y1Vf1Kr/DxQOF9Q35NtXr9vfDFrFRyWWna6KQ+eOlMT +AtLigsus8+RLWT9rRRbL0fMm8LtNPeSuU5gVE+LP23KOPmN0Cgh/FNMlAjT12WGtR33kS1mhZ+uQ +6vy0UaKsoCuk6DFDeByfL2lIZyPGbaX0x03hCNDU9bUef7nQxezJCcfRtcNrouVbobWF3b3GjvUo +wrtFxj72nbl//8jYhYyM/SKJ8Z82MnaPRMZutsT4XRsZu/0T489RZORxjIQ91Ynx5SEyts4kxhes +yNjKFxlbQhPja3FkbFFPjO8OkbFtJjK2XyXGN77I2A4aGduKE2NbekQsNLgz9xgjMhasRMainsR4 ++BQZi8MSY/FcRCwujIwFmInxSDUyGvFGxCLnxHgIHhmL5RPjh4LI2OkiMnZMSYwddyJix6bE2PEr +InaMi4ydBxPjB8vI2Ak1MnbUTYwdmSNiR+87cz/DR8aSAZGxrEJiPD0RGctzJMYTJpGxzEtkNIOT +EM8ERcZSSpGx3FRiLMcVEcuVJcaTbpGx7F1kLA2YGM8nRsYSk4mxBGdELFEaGcu4JsZTt5GxHHBi +PJkcGctKR8bS23fmniePjCXcI2OZ+8RYBSAiVklIjJckImO1jchYkSQxXm2JjJVtEuP1n8hYISky +VpFKjJe2IqMlsohYqS0xXrOLjBX/EuNVxMhYOTIyVtdMjBdII2OV1sR4yTYyVvuNjBWR78y9Gh0Z +K2tHxurjifFCe2SsYp8YLfxHwvQDkTEhQmJc0RAZk0YkxjUWkTGxRmRM9ZEYl49ExnQoiXFBS2RM +GRMZk9gkxqQ6ETHJT2RMO5QYFyFFxtRMiXFZVGRMXxUZE2rdmbviKzImHUuMa9AiY2K2yJgqLjEu +r4uM6fQiY4K/xLhyMDImQUyMaxkjY6LIyKi4MiEu0oyMqT0T47LRyKj8NCImY02M62EjY8LayJhC +NzEu9Y2MaYYT4+LjyJiKOTImh74zd111ZEygnRhXekfGJOORMe15YlzEHhlTwyfGZfWRMX1+ZEzo +nxhrGIiINR5ERhsYEuKNEJGxjorEeGtGZKzHIzLWLJIY7zqJjLWvJMb7YCKj/TQRsb6cxHiDT2Ss +Uygy1nJ0Y0LvUmSsCSox3k0VGe3Kioh1dyWm7tC6R8+rE41e5xpOPi9XZpI+jrmUvom5l8zCm2XI +PnWE3tfc9qYeybm3nfpEyzUWd4zju6VHsre4790j2cNjx/af6SRx5277YKHdfZ0vuQZPf1dR3Cef +cr3tt/Hd0zV5u2+Ty2hja1/T7lv8nm9WN9vaPZJn959XtHS2veBbeiQ/3Bf7+Q/xxfahyx6v9Eje +W22Xo1Ogddis43o9yWscgXmDUtcyQNr/nCHrpAZIe7IzZN3dGbI+cYC04zxD1rueIeuCB0ja6TNj +ffkZsg5/gNQrIEE314EMmX8BQOqEkCHzVABI3RkyZD4PGTLHCIAenScyogYWmVEjDGDUUSND5s2R +IXP5AEj9QjJkziMBunuYACRmKJlRUxVg1J0lQ5P6vGTIHGMAUu+ZDJmLTYbMDwcgddbJkHn0ZMjc +fgBS36AMmQNRhszLCCB1RUrQzV8JIHVqypBaPmXGvKMAUheqDJmfVYbMGQsg9djKkLl1Zch8vwBS +B7EMmRdZhszVDCD1R8uQOa0lyC3bgFHvtwyZixxA6keXIXO2y5B55AGkbnsZMt++DJkDIEDqJZgh +cyXMkPkbAqROiRkyz8UMmXsjQCo3TNDNURIg9abMkCkFM2R+mQCp82aGROSXEXMCBUg9RTNk+rwM +mc8pQOqYmiGT1mXIXFwBUj/YDKkqDhh1qE3Qzes2QyZoA0j9dzOkRr6ZMS0aQOotnCFzKc6Q6cgA +UufkDJkHc4ZUAwaMukJnyPylAVL5VoZO9bxO0M09GyCVXmXIHL0zZN7gAIlqKjPmVp4h8z0HSBVP +GTIv9gyZqztAKlbKkDnNA6Se9RkyoVGGzEcfIHXkT9BNI5QhmxIAkM4byJDpezJkMw== + + + EACSYQqZMWVOhmy+A0A6KSJDpqrJkE2vAEjnYGTIBDEA6WyODNmUjwTdtCwA6eSRDNkMkwyJDAUQ +namSIZvOkiFTkAAkA2MyY5NnMmTaD4B0Gk6GbK4OQKrbyNChs34yZFODAFLJRYJuk4wyZDORAFK1 +RIZsTlOGdOATMKpzyJDNoMqQTbMCSDUKGbIJWwB1NerPs7oyZPqCDNn8MIB0ElmGTBqQoNt0NIB0 +zlqGrKqfIZv9BpBOkcuQFeQz9DjWDgidjpchK6UDpBP7MmSz/zJkVXCAdB5hhmyyYYasgg2QTlsM +0H1uY4as+AyQzpLMkA6lzIzVhN8GdUvbPL5Yt3ZrQHq3yPjHzpBdgAj5pbxD4UfJkP28EfIbJUJ+ +y2XIbt4I+WMQIX+gMmSPZoT8Ic/Q41oRCV9yIuSLV4ZsGYyQL6gR8qU5Q7bIB+i+XUTIN54M2RYW +Id8MI+TbaoZsg46Qb/UZsqAhQh5+RMgDmQxpRBQZD60i5EFahizci5AHjgG6h6AZsmA2Qh4WR8gD +7AxZqB4hD/ozZMeHCPlBJEJ2osmMHY0i5IesCPlxLUNy7IuIHx8j5AfRDNmRNkD3w3GE/JidITuw +R8iP/hmyJEKEPB0RIU9sZMhSJBHyZEuELGuTGUv/RMgTSRHylFSGLLkVIU+TBeiecMuQpe4i5EnA +CHk6MUOWmIyQpzgzZMnSCHnaNUKewM2QpYIj5EnlCFl2OjOW5o6QJ8wj5Kn3DFkSP0D3ckCEvLCQ +IStRRMiLHRnSqklkvPwSIS/kZMhKQhHy4lKEvEyVISt4RcgqZ5HxElyGrJgXIS8LBuheYMyQVioj +4yXPDFnxNEJeho2QF3QzZKXhCHmROUJers6QFb4jpAX0iHghPkNW0o+QiwMi5DKDDJlgIUB36UOG +TEQRIZdjRMiFHRkyiUiEXGwSIZetZMgEMBFyKU2EXJSTIZP3RMiFQhFyyVGGTLwUIZdBZUj1VIG5 +C7Mi5BKvDJlYLEIuO4uQC9gyZFK4CLmoLkIuz8uQCf0i5JLBCLn4MEMmY4yQ6SEj48LKDJlEM0B3 +sWeGTDYaIRegRsilrBkyUWyEXF4bIRfqZsgkvxFy8XCEXIacIRM0R8il0RFykXWGVK0dGVN9Z8bk +43coCNEj5JL2DJk4PkIus4+QC/YzpMr/yFgHQWS0ESEj1tAQIW+NiJA3WWTI2jUi5I0fGbIWkgh5 +M0qA7m0tGbIGmQh5q02ErGcnM9b8EyFvI4qQNyRlaNLWpgh5k1SEvN0qQ9a4FSFvAcuQNZNFyNvS +IuQNbhnSqZQJ8vGWb2Lu9b7wZhl6T1/e29o7tzpgVEjR57R29fxBRmC2jdX3nxTZtUfpglyO2wjM +qSuUHRl3uaZOkVP7K/6lEzArBGufmLlXlfrPG9o7P+AX8/bOD/HFOnqX5s4+ar46AHO9/vLUnhb1 +v6c5DcC8MalonCHr/QZIm8gDdO9GB0jb2gHS8nOGrNEeIGnYB0Yb/zNkDgIAaR07Q+ZpAJCaIwCk +LgsZMrsGgLQiniH1jwBGfSgAEj+LzJgvBkBaXAdInToyZJYfAKl3SIbMhAQgLdMDpLYoGTJ/FYDU +qCVBN8cXgLTgD5B60GTIzGwAUlecDJm9DkAqHQBIDX8yZM5BAIkDETDqZJShVTUIAKm3UobUowkY +9XoCSE2jMmRiBoDUxipD5ocFkBprAaQOXRkyXQRA6hkGkJqPZchczABSO7QE3RQWAKlBG0Dq9JYh +s4wDSL3nMmRaDYDUDQ8gcdXLjLnzAaQ2fwCp6CNDZjwIkDoYZsisEAFST0WAVD+SIXN5BEjtIjNk +vpMAqYElQI9KlIyYnSZAs/hyZsgMPgFSp1CAVNOSoJt3KUBqggqQuqlmyGxZAVJ1TIbMKBYgdZwF +SK1rM2QeuACpziZD5soLkLj7AqMuwRkyu2GAFhHsAKQGyBkyJ2WA1JI5Q+btDJBqfwBSt+kMmW01 +QGJ/nRmz0QZIRUQAqbF3glZ3CAdIrcYBUs/yDJkcCSB1Uc+Q2bEDpL7uAIk/fGZM1wTQLIb1GTLn +e4DUQh+gUbz4M2QKKYBkOEBmbMgAQDqtACAde5AhlVoBo2MYANJ5DhmywRAA6YSJDJloCyCdeQGQ +Ds9I0G0KB0AyzSMzpv4CSMeLAKRzSjJkA08A0skpAImOLDM2yQUgmQiTGZssA5COqAFIBWkZsqE5 +AOn0nQzZGB+A1sdxQMCosi1DNp8IIB10BJAMTMqMDV4CSDVyGbJRUADpTCmAdDhVgm5TrgAStV1m +bOoWQDq+CyCdA5YhGygGkOr2ABpkxFmGbFYaQDp0LUM2vQ0gVQACpPPkMmSD6QDSCXcZslF5AD1q +CQHRwX0ZsgmAAOkowQzZTEKAVJUIkE5JzJCNWwRI5zYCpAMgE3TTNwKkIykzZLMt3wRtw/Mlbqkf +a2ytV3w7gPSDJ+h2CQDSiwmQ/iwZsh8YIL1VANKbLkN2+wKkD0KG7JEC6PHRBEQf8QzZYgGQLjsZ +sgUMIF0KAdJFNUO2PAOkC32GbMsASDcfgHQby5BtiADp1gqQbtIZ0t0eGA0bEnQLQADSUAYgDYoy +ZOEVQBqoZUgjPmA0dARIg9AMWTgLkMTFwGiAnSEL1QHSoD9DdnwASA8iAOmRJkN6NgJGD1kZ0tMa +MHrsA0gPkBmyoyhAeqgFSI/HGdJzNjB6YE/Q7egPkCYRANJ0RIYssQGQpkgyZMkWgDRtA5DkfzJj +iSSANCUFkCa3MqRZMmA03ZYhS9wBpClAgDSZmCFLSwKkCc4MaaYUGE25AqTJ2wxZGhggTShnyFLT +AGmSGyBNlyfolngHSFP4AGkxIENaVQBGyxMZskIHQFoyAUiLLxmyMg5AWhDKkJWWAFqkSAWQlrsy +ZIUzgKQCB4yW8jJkRUGAtLyYIStUAqQlT4C0eJohK8MCpAXdDFlpGCAtMgOk5eoE3QrfAGkJHSAt +xmfIyvoAqUAgQyI0AEQFCwCp9CFDJqIASOUYGTJhB0AqEQFIxSYZMtkKQCqAyZBJaQBSUQ5AKu/J +kOqEgFHBEUAqXcqQiaAAUjlVhkyYBZBKvABSsViCbrIzgFTAliGTwgGkojqAVJ6XIRP6AaSSQYBU +fJghkzECpILIDJm0EiAVaQIkas/MmGwUIBWgZsikrAAtj5pYYFRcmyGT6QKkgl+AVDqcIRMhA6Ry +5gyZMBoglVgDpGLtBN1k3wCpgDxDJkUHSEXtAKk8PkMmtAdIJfsZMvE/QNpGAJA2JGRIOxuA0RYJ +gKTXIjPWtAGQtn9kyBpJANKWFIC0uSVD1iYDkDbcZMhadwCSHiBgtJkoQ9aWBJA2OAGkrVIBujdd +AaTtWxmyRjCApKMMGG1Ny5ANwgRIR2pmyDxW3wSFmt/97QDSD56h93Xnva3Fc65jbXdBd6K7wucf +ZIJnLex/waDLPl5JJ+Q677cWzzpAbU912Frq5N2Jnnr72oa+/wTPjigqnF+ep2Nor4mKM9/U4/nh +vpn3eH6Qb7ZfZi/S5dm139dGeF414HrS+yA4H3Vd0gjPG5S6rgHS/u0MWSc4QNpTniHrTs+Q9bkD +pB3zGbLe+wxZFz9AYgeQGfMVyJA5FACkXgcJurkmZMj8FwBSJ4cMmScEQOoukSHzqciQOV4A9Oic +kRE14MiMGnkAo44gGTJvkQyZSwlA6neSIXNOCdDdgwUgMXPJjJrCAKPuMhma1KcmQ+Z4A5B652TI +XHgyZH4+AKkzUIbMYyhD5lYEkPoeZcgclDJkXkwAqatTgm7+UACp01SG1LIqM+Z9BZC6aGXI/Lgy +ZM5eAKlHWIbMbSxD5lsGkDqgZci81DJkrmwAqb9bhswpLkFuOQeMetdlyFzwAFI/vQyZM1+GzOMP +IHULzJD5DmbIHAwBUi/EDG2LuCpmyPwZAVKnxwyZZ2SGzH0SIJVLJujmiAmQemtmyESOGTK/T4DU +OTRDIk3MiDmZAqSeqBkyQWGGzKcVIHV8zZDJADNkLrQAqZ9thlS8B4w67Cbo5tWbIZPcAaT+wRlS +I+LMmFAOIPVGzpC5LGdoVX0bQOr8nCHzkM6QytKAUVfrDJk/NkCniMkyZJ7dCbq5fwOkGrAMmSN5 +hszbHCBRbmXG3NYzZL7tAKngKkPmJZ8hc6UHSGVSGTKnfIDUcz9Dpm7KkM0BAEgnCiTopknKkE05 +AEjnJWTIpEQZshkOAMkwiMyY/idDNp8CoF0mXWTIZDsZsukbAOkcjwyZ2AYgnS2SIZtSkqCbRAYg +nZySIZvBkiERtgCiM2EyZNNlMmRyFIBk4E1mbHJOhkxDApBO88mQzQUCSKUfGbJZRRmyqUcAqWAj +QbdJTBmymU4AHSKzyJDNmcqQDqwCRrURGbIZWhmyaVwAqaQhQzYhDCCdNZYhUyJk6ND5ZwDpJLUM +mX4gQbfpbgAdMicuQ1b1z5DNrgNIp+BlyGr1GXocyweETvfLkBXYAdKJgxmy2YUZsrI4QDpPMUM2 +mTFDVs0GSKdFBug+dzJDVoMGSGdhZkiHambGisJvgrq2NdQJ7pIV9WE4vFtm7GMDZEX4CNmlDND9 +RwHIxAoRshslQ3bLAWSajgjZY5Ahe6AAMu1LhOwhB+hhrciEy4MiZIsXQLoMZshlVBGypRkgXeQT +dJebRcg2HoB0C8uQy/IiZNsqQLpBZ8jVixnSoCFDFn5kyEWeGZKIKDMWWmXItbAZ0nAvQxY4Juiu +Gc6QBrMZsrA4Q66tzpCG6hmyoB8gk6BHyA4iGdITDTCm1I+QHbIyZMc1gKSfISJ2fMyQHUQBsq6P +AN0OxxmyYzZA1h0TITv6A6RJhAx5F1GELLEBkKZIMuTNVhHSrA0wmv7JkPekRchSUgBpcitD3roX +oFvCDSBN3WXIWxwjZOlEgDQxmSHvBM2QJkszZGnXDHnHbIY0FZwhSypnyPqKM6Np7gxZwjxD3n6d +IU3iJ+hWDsiQd6lnSEsUGbJiB0BSNcmMlV8yZIUcgMzyIEJWXMqQlakAMmeICGnlLDNWggPI/DMi +ZGXBBN0KjACpzUhkrOQJkBZPM+RuLBGygi5AWhrOkLvWRMjK1QBp4TtD6u0TESvEA6Ql/Qy5A1KE +TGYAkAoWEnR3isqQiigyZHKMDJmwAyCViGTIxCYZMtkKQCqAyZBJaTJkohyAVN6TIRMKZcgkRwCp +eClDJoMCSPRUibkJszJkEi+AVCyWIZOdZcgEbACpFC5DJqrLkMnzAFKhX4ZMMpghEx8CpDLGDKke +MjMmrARIJZoJuok9AVLZaIZMgJohk7ICpKLYDJm8NkMm1AVIJb8ZMvFwhkyGDJAKmjNk0ugMmcga +IFFrZ0ZV38CofDxAdyF6hkzSDpCK4zNkMvsMmWAfIFH+Z0Y7CDIjjQiAaENDhqw1IkPWZAGQtmtk +yBo/ANIWkgxZM0qCbm0tAGmDTIas1SZD2rMDjDb/ZMjaiDJkDUkAaWtThqxJKkPWbg== + + + BZA2bmXIWsAA0mayDFlbWoaswQ0gnaqZIB/P+RYm1PvubwbQe/ry3tbfWXtqPbprbyhTty/+DzPC +88qM6KTLWlu8v3NZ6oY8anGuBW+qKKTNhf6SGZ59d3RPZS1AFTS0od04/VAzPPM38/7OD/LN6u8P +u/Z31un31Sme9Sd1ROzjZG2N2x6neN6YVDfOkLWBA6QN5QG6t6YDpE3uAGkFOkPWeA+QdPADo1YA +GTJTAYC0lJ0hMzoASC0TAFLzhQyZjQNAWhTPkDpLAKMWFQCJ10VmzDQDIK2vA6RGHhkySxCA1Fwk +Q2ZTApBW6gFS65QMmQkLQGrnkqCbMQxAWvMHSM1qMmS2NwCpgU6GzIoHIFUPAKT2QBkyoyGAxLEI +GLU+ypDJEABSO6YMqa8TMGoQBZBaTWXI9AwAqf1VhsxICyC15AJIzb0yZNIIgNRwDCC1LsuQmaAB +pHZqCbqJLABSizeA1CwuQ2Y7B5Aa2GXI5BoAqakeQOLOlxmz+QNIDQMBUt1HhszEECC1Q8yQGSsC +pBaNAKmEJENmGwmQGlBmyKwsAVrFFBOgRzFKRkY16QRI7T4zZMahAKkFKUAqa0nQzRYVIDVYBUit +WjNkpq8AqUAmQ2ZEC9AqlrYAqTluhsxmFyCV2mTIrH8BEg9hYNSMOENmawyQanYAUqvlDJlpM0Bq +/5whM5IGSOU/AKm5dYbMJhsg8dvOjBl3A6Q6IoDUTDxBN1tygNTgHCC1Ss+QKZIAUvv2DJkRPEBq +KQ+QeNNnxqRNAKldfobMeB8gtfAHSIcBZMhEUgDJfILM2KADgHRkAkA6fCFDqrYCRsdBAKSDJTJk +IyoA0mEXGTLdFkA6gAMgHeWRoNtQEIBkukhmTAAGkA48AUhHp2TIhrAApONcABIpWWZswAxAMqkm +MzbyBiAdngOQatIyZAN9ANLRQBmyIUMAybQiYFTcliEboASQjmICSGY6ZcaGQwGkMrkM2cAqgHT0 +FUA6RCtBt3FcAIngLjM2IAwgHTUGkA4ty5CNPwNIpXsADTKSLUM23A0gHROXIRs4B5CKAAHSIXgZ +snF6AOlgvgzZiD+AHuWEgOjIwQzZ8EKAdAxihmygIkAqTARIhzxmyMZFAqSDJwHSEZYJukkcAdKx +mhmyAZ1vgypsG9Z6EGvzO1rHFd8uQ/bBA3S/BBmyi5kh+1ki5D9whuxWyZDddBHy2zdD9iBEyB+p +DMmjmRF7xCPki0WGbNmJkC9gGbKlMEO2qEbIl+cM2UIfId8yMmSbT4ZsG4uQb4gZsq01Q7ZJR8h2 ++8xY2BCgewCSIQtlMmRBUYQ8vMqQBWoRsogvMxY6ZsiC0Ah5OJshjYszYwF2hDxUz5AF/RHy40OG +7CCSITvSRMjORpmxQ1aE7LSWGTv2ZcgOkBHyo2iG7FCbITseR8jO2ZmxA3uA7kf/DFkSIUOWjoiQ +JzYyZCmSCHmyJUOWtsmQ5n8i44mkDFlKKkOW3IqQZckyY+m2CHniLkOWAsyQJRMj5GnJDFmCM0KW +Kc2MpVwzZMnbCHkaOEOWUI6Qp6YzZEnuDFm6PED3xHuGLIWfISsGRMiqCpmx8kSEvNCRISuZZMiK +LxHyMk6GrCAUIS8tZciKVBmycleEvHCWIa3AZcZKeRHyomCGrLwYIS9UZshKnhmy4mmEvAybISvo +RshLwxmyInOGrFwdoHvhO0NWQs+QFeMj5GX9DJlAIEIqNMiICRYyZNKHCLmIIkMmx4iQCzsyZBKR +DJnYJEIuW8mQCWAi5FKaDJkoJ0Mm74mQ6YQyY4KjDJl0KUIugsqQyaki5MKsDC0q8cqQicUCdJed +ZcgEbBFyKVyGTFSXIZPnRciFfhkyyWCGTHwYIZcxZsgEkRFyaWWGTKSZIVV7RsZloxkyAWqEXMqa +IdXEZsbEtRFymW6GTPCboVOlwxFyEXKGTM4cIRdGZ8gk1hkysXaA7rLvDJmAPEIuRc+QidozZPL4 +CLnQPkMm2Y+Qi/8zZG0EGbKGhAhZZ0NmrEUiQ9prERlv2siQtX9EyBtJMmQtKRmy5pYIeZtMhqzh +JkLeupMh7QHKjDUTRcjbkjJkDU4ZslapO3Tcm64yZO1bEfJGsAxpR1lmrDUtQjYMEyAdq5mhWW1W +3wbda37h7TJkHzxC7+vOe1OX59RBw1x7z3kdR48fZIpnPRw2frJPDu+bddlHY511ed6aPC8fhx5w ++dytxfV8Tr13fN/3qhuun8faDp/7889HRyNvafL8cF/Mezw/yBfrnPwiPZ7T2PNC/9Tjea8cn3WU +qM2zVv06A5/j0x+CPZAznwSfochYsTcy5nyUGbVQiozUZyNhhk6ZUWeoyFhJNTLmVZUZNb2KjFVB +I2M2XJlRP6/IaOEyI+ovFpibUVlkrNaYGbVOi4xasEXEyoOZUU+4yJi5XGSspJcZtbuLjPnmRUbL +cBnZxMcvMmYImBmtnEXGLAoDc/M6zIxWuyJj7ouRMRvHzEiBKiJmKxkZ86fMjBaVImOOmZEx683M +aB0oMmYGmhl1FY2M1W4iYz6nmVHD1MDcyi2RMQvXzKgXbGSsRBIZc6fNjLjcRsSKGpEx293MqH9v +ZKwQERlzFM6MWhNHxmoHmVGz5MiY63Jgbun+zKgPdGTMUDoykqHPhNpbR8Z8siNjSfXMiHF3RMwA +PDKWBs+MWpJHxrzNM6Op68iY23pkzLY9M5ptDszNSD4y5kifGU0QR8Y88iOjXvsZ0ZRuZMz8PzI2 +RSAzmoaNjM01yIwOSIiMpU4jYyMbMqOzHyJj2c7A3KZRZEbHWkTGEpSRsUEbmdGJHZGxnGJkHgeI +ZEDHkETGsoCZ0cEokbEJK5GxxF1mdOZLZGx4TGQs2ZYZHWdzZ47bXJzIWH4sMzqpJzI68Scilq16 +E1PH/IrKal+tL1rfN75XZPwzZ8i+fIT8Kt6h8HNkyH7XCPkNEiG/0zJkt2yE/N6PkD9EGbKnMUL+ +WGfocXGIhC8xEfK1KkO26EXIV88I+TKcIVvPA3TfGCLkO0yGbKuKkO95EfLNM0O2C0fIt/MMWVwQ +IQ8wIuSRSoY04omMR04R8hAsQxbLRciDwgDdo8sMWZgaIY93I+SBc4YsAo+Qh/IZsjNBhPxwESE7 +pGTGDjsR8lNThPz4lSE5xUXED4MR8lNlhux4GqD7OTdCfmDOkJ28I+RH+AxZLiBCnlSIkGcnMmRp +jgh5viRClnfJjOVvIuSJoAh5RilDlpqKkOe4AnRPlmXIsm4R8vRdhDwPmCFLKEbIM5MZshRnhDxX +GiFPumbIsrcR8jRwhCydnBlLS0fI89sR8kR5hizjHqB76j5CXgPIkBUTIuRViQxpdSMyXiWJkJdb +MmR1mwh5AShCXknKkJWkImSlrch4iSxDVmuLkBftAnSv/mVIq4iR8WpkhqysGSGvj0bIC60Zsopt +hLz0GyGvIWfIitER0pp2RLw0niGrsUfIi/UR8qp/hkw+EKC7DiFDOl0oQzZdKEM2XQggnS6UIZsu +lCGbLgSQThfKkE0XypBNFwJIpwtlyKYLZcimCwGk04UyZNOFAJLpQom5TRfKkE0XAkinC2XIpgtl +yKYLAaTThTJk04UyZNOFANLpQhmy6UIZsulCAOl0oQyNMl0oMzZdCCCdLpSg23QhgHS6UIZsulCG +bLoQQDpdKEM2XShDNl0IIJ0ulCGbLpQhmy4EkE4XypBNF8qQTRcCSKYLZWaQ6ULA6HShAN2nC2XI +pgsBpNOFMmTThTJk04UAkulCmdHpQpmR6UKA6HShDNl0oQzZdCGAZpkulCGbLgSQThfKkE0XStBt +uhBAOl0oQzZdKEM6XQgYnS6UIZsulCGbLgSQThfKkE0XypBNFwJIpwtlyKYLAaTThTJk04UyZGN6 +ANKBPwnyyUFvYm7lvvBekbEPnRj/9onxyxgZ+z0S4z9sZOwOSYzfaonxezYydvMnxp+ixPjjGBl9 +rBPiy0NifJ2JjC1Yd+a+8iXGl9DI2FqcGF/UI2O7Q2J8m0mM71eRkW0vEbZ5JsT24IjYXp4YDwoS +49FFZCxMSYzHO3dxxD1wiowGYAmxOC4iFg8mxgPLxHiEGhkLdRPjMXNiPPiOjEXxifHjQGL8XBEZ +O6Akxk86ifEjU2Ts7HVn7oe4yNhpMDF2qkyIn04jY8fcxPh5OTF+8I6MneAT46mAxHhOITKWnEiM +ZzkS4+mSyFjeJTGewLkzt0RQRCyhlBjPTEXGUlyJ8VxZYjzpFhnL3iXG04CJ8XxiZCwxmRjPcCbG +U6WRsZxrYjx5mxjPAkfm9ba2t/VGrs9714wr2KtNrp7AH2ICZv2JjG5crvD8fXMiF28h3Grd8+bI +rV0+6kmsSGjoCmI/3Mf3frPvJmCuFUyetdV1ZbtWrPc3R37Ab+bdkR/kmx3tyafdkfX3Hrojx2V7 +7vp8nR5qye/lY6xrUDdwKwnGfa3g9A8v0FSftn0gh17Kb9AnF3TUZ6yjU8uxRoR6BOjatd7hFab2 +ymns576faoC27Zzaxmi71BwEdTG8C0FT96MDtHanc8U661UrAqjCpLF+va7i7gyNPaq09s7XPlPr +E2qnb6cXvpZ1whqGtT0H+zBC0Hh0/fLcXvtMbcxSz/HeAQRCFVgcWzsAjL1dEVRLeh/9Dn6ltWvr +Y7txVQh6INQOn1M7Jcxbuue+heapVpyudOJnWru2PgwtTLwq4gQNvWPVz7fS7dSGg2crAKf5tRda +23Gh3nG7LHMJGoflRUc38tv1HbL2DffKR+rpyfVELcdrLzT3YtDuJFcQAdC0zq0cGPbXXmnsPv/x +aEvnV6CpAuOWZE47X6aKQHuvXIfLfjhCy3MfFeuU3AIKelbanXSs1XAe8cFc6s/qXjraI25/BWrT +jVpTW+uMUAdR23r0pkvP3PLcJihHBx3rQLfA0qX1sc2l9tdeqSW3U2tlz5Xu755/XNvu3JESPXJL +V9bbeqU2pJWvQFu3HG0wNR58uaejXWdanL7Qr1tQHVHrYFmr6iuvVG+2zG3EtQx8wevj9KGwVoxX +XqmFuZ1MWpaRoLlWnV4GOyc403WaO6oa+iLM/JnmWnXqFmjV+HVIAGjv7amjomOjn65Nv/e2kKsz +ySuvVAtX7dXt/rfSFZ87hB0uqexwvAK1uKSA/bXPtLTO+ezk0yuvNB8d5naWZqRbvKC6Akf9xr36 +IjS1CLItJ197pbHOJnUPtHSP1p222m/xSJ+RR/7thg5R6p6rhZXugqmj27Vi8PnYcVEpaK4Vsz1h +VvrcFcj3iaAilE4nMNQOPq2WPXGLnvrUOW51HNhe+0hbv0+rZc+TfrqC6gRztofpxB+p3R/Ho5bo +K58FUIvc219omvB6T33CH/vurpWM3+46Vfb5/LVXmq68xlAb/kLPytTJi9rFzqHPOQjVaXnvPbwe +K74HWn1f0cy2Xdl7gub2plnajxyYOsNvZ+vYp+4xYKgi+K3FsifGvOPzUYvSdFxCVw== + + + ZPZ9u8Yo7AfeAmNnwNq7sTMmdL3HWnb29UUNjzv0+LxeHRqd8eWP1Ab7dW4+53mlyz3WqlO/a32/ +bcUteuxs47h19WHGW6CgqT2Jagted/5RajGpcGcbjwO36LETqV3mOJfXPtPY+cjOxr72SsPW8xb6 +AeYrMFQcW79a3Zd4CwzPXTRY9mMaLqdbgOpqdy/TUMExXYGCxmGf+7CJH2moRacC/rV9z+hyD3VE +HdtFsn4/jPYKqn/pJHn/OUItpd36vLbg0zTUolMb5li75o4bdEFText2BHbQbTl00aNdfpdtH+nX +HWrRWVuY3YsqX6bacOYrV7MPfAnGPoG1UvbqvyCol7e2oh83frs+77TJ1Y6faT6fz4pUOy024is1 +NJytFa59kbb6uf3aetEdr0cPobr717Pnssy01TfUsw+uhhfa6gvaerm4zBTpLiio9521/WAvT1WC +pnrEz1qbY9LihekdbO6BMdvIV6CPID26ZT/op2uoNtW95wpd4myApj7M1RNTe88r0OWQ2PNgKKAv +aJy37i5oDTNfgdoulrYZP1/7THV46l6P9kSmC348t6Ns7zvrihe8/qzuyLFvlAlvgvqzir6Ood0b +J7rix3MtYN0k23kSZCr8HLd6mObXPtLWvpx1kXrQCUK1U7TKe3gxBAZoqdt7qmge94JmpuOqQx+v +vVAtumPvrdPlKQtQ/RZHX6L9tVea5jpAzksH/fxK495uktO5XN67BA1breFDbXevvFJXqXrmxLzg +L7fXurN3P0CXqejmbePkupu6efO1VzranPXoyuwKK31B+1XX6DovbfYN1TLfp4xlw5tgr3Wn+yjb +U+6gK74/r92i0gbxI630DVXwMS51/D0oeVfQstV5rgcAXO0lAM1n3wO1Cc+02zc0d62gDhmvvVIn +i/tGmV57pan2+nHonCJfgYpU+rTdtUp6DvbnDuPq3Lstr7xQrRJjP5V1vxDU3vf9y9ZesFISsKC6 +jvVGPXCAvn8xtSxN69C1frrBe0TAsrfZfgWO9MNtz1sFTG34fA4UNjQ0tQJm6zoXrU3bc/1b3XJL +N8jxZ1rOvZ7gWuQnisIb6ppURfQ9KwGhCiyXzv90BxVD3XZ9dH82ZdwKqntt7QTBtr1yneqfK05b +egQRPb4FdZJha6HUyTfBcI0ZmHqcEV2n9fnsgv/aBVd8pYLGfe/K137ibr8+H+s8v/SuUoJr7kEv +dRvUQWM7KTRuqEdrjdf/8Ctt9V9XqL7MM+72PQ+njX7H7pDjS7C2V/fVAbrTFV9r3alF/rLExd2+ +bV271Flh2rzTY7fWunMlXTvlwq/UVfCu39eRhW7fnq50bj31CWOitZadtW6mVpNN/GZDT2WpxalW +MLp5ewZVF8ra1h1faXk++9NchxF8peW5Leb7rSbcxHpS19ze8RXxUN61oB5wc5z9mPMLdaRTu8Xa +Ye8boan7t4aWRNTZu/22w7sBox+boMfvD4xeyAj5T0KQ/LgA6W0C0OPtRojctgDpAwCQPkoEyUMJ +kD7eBMlCAZAuOQDp4kWQLIMA6YIKkC7NBMkiHyHfLgDSjYcg2cIA0s0QIN1WCZINGiDd6gmSoAEg +DT8A0kCGIAmJANLgCiAN0wh6jPeA0cAxQh6CEvQYywKjQTFAEl0TI2E6QBrwEyRHB4D0EAKQHmcI +koMRQHrEAkgPawTJsQ8gPUACpEdRguRQGyE/HgOkB22C5MgOkB7+CZI0AkCakABIUxsEPeZIgNFk +C0CatiFIEkAASSYJGE1JESTJLYA0TRYhT7gRJKk7gDQJCJCmEwmSxCRAmuIkSJKlAGnaFSDJ3xIj +iWCANKUMkCanCZI0N0CaMAdIU+8ESRI/QbdyAEBaWCBIShQAabGDICmbAKQFGIC0lEOQFIUA0vIS +QFqoIkhKXgBJ7QwYqcERI8U8gLQsGCEvMBL0WKkERkueBEnxFCAtwwKkBV2CpDQMkBaZAdJyNUGP +dW9gtIAOkJbiCZKiPkCiDgBGZQYEiWAhQqZ8IEYkFACpGAMglXUQJAIRgFRqApCKVggS+QtAKqQB +SBQ5xIi0ByAVCQGkciOCRLgEkCigiBEpVYRclAWQyrsIEqEYQCo5A0jFawSJDA4gFdQBpNI8gkTk +B5DKBQFS4SFBImEESMWQAKmskiARaEbIpZ4EiWgUIJWfAqRCVoJEEguQimsBUpkuQY96X2BUOAxQ +Z5D/LEEmSMTMAKksGiAVWBMkUm2AHiXfhIh0PEIuQgdI5ewEiTAeIJXYA6RifYJE9g+Q9A8Ao40I +BElLA0DaHAGQdFkQI+0aAGnjB0HSQgKQNqNEyNtaCJIGGYC01QYgbdohSNp/ANJGIoC0JYkgaW4C +SNukANKGK4KkdQsgbQIj6LGbDBhtSwNIG9wIOh9b5SK017rTLsRz/XaUcbtBUQv43s68N3V49ump +Djxbdwx2S/KHn365dfLJWxP7MHdvTaxQ+M9lzGvIt/RB1t55a/CsJ7fbIOuY1LnOrW02v/dbdRBz +9XfWIbGvRcfideO9p7/zg36vW3vnh/hePZxcuzs37e7sgnAXi9ZhbrOcp5/M15JY797J8zq3/eGl +1jt2vbCWpMuJ3ZlPXpjlqNhsmIbLuAOYx5pxRuox6+nHtbjP+DLnVnFbXYAryk/I2tmOpQ9e2zUC +HZilZ0Ms3fYevvknoe6cmbEf3HocK3rDz1Mnjn6WOgm1IFMrfp9yliuMykwtmlM/iVvnCwCR6nVm +2rynTtT1wXtjAKbdZyr6qQcefq2ORNpW/2zXbfw8y/Ti4b4MC15CLYFnZq2TbUWil00IMnX2qRux +3Ybxe7XOoA5/19wEYurpW5c6uY9HH8qBkTo6MC/2yPNy0h3fNuEdXM4V8vBvsddzs3aIOfBv0bNe ++sR6rie+jhbjganbYrn8IAZ8nXOuH6OigVoQ8Rq2odB5TD3kAq5hLaRD+0T0WYYWFq/oA3OstUB2 +tWeHz9Nm8/Uml/UE/RZbp6P6kDrPK/0WFXlVfLq1JdBIS4vLAoCpr15/1oOO8bvPPUxl2XrKMjwX +vbivdeeM53iNHAGmftFxbF1MWuQ/CdoCYOq56sN+PTz43dehFrpOsdBj2oFihVzrtnT5FZkOgpf2 +LMNvrvIEYHoiTU9V2mmR75EOPfdg62wHLM7FLD2/aRy2k3+Jve0YWi+w0CLvGgdg1n2rz9L23PiZ +63QzHbXZvtiwZeasdafzgcuGv8RZ5/u5HZOmBT6OCyWAqTPyudXXn+mn6LkgZ5dN5vq/8JH3TvMN +bfA+0bO1d52qqxR1Z9AVNLUFIEt92KO1MiN+4rrCPa386DuemLmCiDrxHC8TM4BZr6kpFWnRsuKS +jcws814BSb8bLSs9WGatHbke4oWW+L3TjbVrVdRy0nZbzHUCXbqWh59HdR+Z2frXnNtqjJaVnr3T +c6zODsjwdfYKxPr5WnfabveuunWataU//DoiHslMCyDrSNDTNvB1KqCus1GP8Dnxd6+nvKLZ2nTX +FW/niow6Flt6sg4yokBJzNEyyt4De1GA1+kJTmuv3+O5029RTN0WWxed5wmuT5tbTv3wtKgNEVGx +ZKalmD3eqJ8OZJYKIc62G5thZy+mwvyhQqR2oyNmbrepbdqGjXZbl8JkphWddRCuJ5Ein2Jq22oJ +S19FZI5aneoKXfmUjKydl6lItqMsZERPA0xHhLUo1P6GH6czvPXtK67jn6JnWnUWpJcWYmo1Pab2 +7RppjTdRDiBHT1QYW22BTN0XdXrumx6/eZclukJV8QHeqLXqnNtcHJ1gXNcDTPu4DludCOiHOJ/r +cNyqtPrAtKycnZReOtofRlriz66sViAynB2rEaPiIGB6ktnc6ypc5B5GWGe3jkMW2myL6bFhQ6f+ +6EDVPqQvQ8rOa1xhZlRgBEzFw0On/Db8OBW/13LaGhzabItZKsSqZbeeHvzIy9GK5DqhTLTAm0gJ +kG28DId76yJmu6YtLbUw06JSTJ2161atVYV/iX6k5h6OMtD67konYNZWpVQAcdVYgOlQr+KQ+kR4 +gx2dMdyXPnLiL3q0l2s9XtPBP4XKpYBpCVR3GlzessAcW/0c9ZFXWOBbUFW3xdEqqAFix2bqxxh7 +sNUGe+1NcwVM3evXM3iNkgOm/ZjnHs6Jb1VR0zy39OWA0LGZ1roP1zgu/Oqq28pMG9BWGDuNCzwV +zexTbRKtFMt3T2u2xrGHsNXZHo5TzXShoKc0jRD13LRfmWkJcxeWT1o0muljW7/KwZd5q0877lMn +bPHzbD3ctRP3J/8UKiDLTG3pdY/u7RuL71VPTbtwX9JcZCp0bNXE8Mo1rLiynqvetfn3Uh1aZjoD +UYfts8N0ZCq42juFMMOxvpmzM4rjXj8YXMOxhQBrD4ftpx6ZRzFbRlqQXf92ZZeQWXoaYM8Uw0/T +4706bdJiCWIqPLiGgu54BV0QB0yd2eYuQ82wS3ZBp9eLY6utCQKWq+hTkWWdFLudhpjWUYw9UG/g +X0JVdcCc1xy1+j1gjW9NXT3G9byvnVtDpm/As0cBwhrfurtOL9T1m64xl8CINg+Yo5PAtRucEMS3 +Mm/qIKGbzvi3qKPWsnfOcODfok5SYx8HKobC7y4CP0D2jvOXnv2HTPdY1YJRhxz+KV6Cg/pOO/8U +Zz3JnRw4LsVlYkwlCEg/Dl1jXFZ4q+n50jzVde67/o3M9bjVGnG0WfgKbwaQfOjE3L48QHoVAdKf +I0P2uwIk9wcwep9lyG5YgPTOz5A9QgDpswiQPtQZstUBIF1mMmTrFUC68AGkK2iGbCkGSNf0DNnm +AJDuMgDpdpUh2/cAkv0TGN2HM6T7OTAaFyToFmAApJEKQBryZMhiJ4A0CMuQRXMAaVgIkMaXGbJA +FSCNeAHS0DlDFoMDpMF8huxUAJAeLwDSc0qG9LwDjJ6bMmQHMID0JAeQHgkzpEdLYPSICpCedTNk +h2aA9PQdoPsxHiDNBwCkiYUMWYYCIE11ZMhyJgBp8gUgzeJkyNJBAGleCSBNUGXIMl0AScYsM5Z5 +A0hTeABpLjBDmlMERnOTGbIkJ0CaLQVI064Z0vQtMJoGzpDlkwHSxDRAmuFO0C1VDpDm3AGS3H1m +rAYAkNQSMmM1CYCktgGM1kgyZMUWgLRqkyEr/wCkdSSAtCCVIS1sAaMFMoC00pYhK9kBpLW/DFkR +ESCtRgKkZc0MWX0UIKmzZsbqtQBp4RcgrSAn6FaKBkhr2gBpcTxDVmUHSMv1GbK6P0AqIABIlQgZ +MkkDQKqNyJCJLABStQZAKvvIkOlHAFIhSoZM0QKQSmMAUo1NhkysA5CqfgAS9VBmTIUEkKiZMmOq +KIBUXgWQ6rQSdBN8ASTCscyYAA0gVbIBpJK4DJm2DiAV6QGkar8MmWwQINUfZkh1jMCoHhIg0VVm +xvSZAKnQM0OmGAVIpacAjaJhzZCJYQFSVS1AKs/NkOl8AVLBcIZMeQyQSpgBUi10gg== + + + OvUtomqAVJ2dIZN5A6R6cYBUeJ4hU7ADpFL4DJmmHiAV5wOkKv8MWbsAQNp3AJA2MGTIOiEA0paK +DFlvBkDa5AGQdotkyNpOAJL2lcxYGwxA2k8DkDbmZMg6fADSViGAtOcoQd67BMwkPVAZ0l4qYLQn +CyBt7sqQdYkBNFcUs9VaP+CP4i6lb4OCmOf2bpl5tbntTf2RfWCvDaduo9qg2ujyg/dH9pzIWjbG +rhZtXSeoo+PV/q3NfbVhex/hZn2E9Q+3Bsl96j7CrqHVcWXp+uD5/d/ruwbJbewT99CZvnrDtwzA +/HBfzDskP8gXa3cp7ZCcttXnX0rnbxtxVMzTQ0G7BfT4dv6l9hDfoE/uzcjESFczQNofTZB0WgOk +PdsAafc3QdJHDpB2pAOkve0ESZc8QNpvD5B27hM0PXoAROhaXR7cBABSXwKCxOEAIPVKIOjRdAEY +dW8ASH0gCBJHCYDEmgIY9bggSNwyAFLfDYDUwYMg8QIBSF1FIuT+JAQ9+JwAon4pBInzCkDq4QKQ +usEQJL4yAKlDDUBidUOMeOYApO47AKmPD0HiCASQegsBpC5FBInfUYTcOYkg8WACSN2cAFJfKILE +YQog9aoCSF2vCBL/LIDUiQsg9fQiSNzBAFKfMYDUsYwg8T4DSF3UIuR+bAQ9GrsBow5xBInXHEDq +WgeQ+t8R9GikB4w68gGk3n4EiUsgQOo3CNAkzoUEiQciQOqmCJD6MhL0qIKMjDtFEiSekwCJdhEY +dcEkSPw0AVLFIUBi8UmMeIUCpDJBgNS/lCBxQgVIxX0AqTsrQeLzCpBo8ogR59kIuYctQKqkI+jR +VhcYsecFRtVvBIljMEDqPQyQatYIEj9kgNRZGSCVmhEkbs8AqW80QaIQA0i9rBN0c8UmSHRdAKlT +N0Dq+U2QqLEAUh9ygNTRnKBHDRUw6rEOkLq1EyTSJ4DUQZ4g8aIHSBVLAKk/PkHitB8h1xkBpO7/ +BMkcAYBEHwSMTjYgSGYkAKSqHoBkbAMxMv8BINXiAKQzKQiS6RYAqYKGIJm4AZDO7oiQC18Iknki +AOlkEoBUrkKQTEsBSOeuAKQiE4JkFgxAOlUGIJWGECSTbgDSmTkEPQo6gNEpPgDJOCBiRIYRIZ9Q +BJCMOiJGxBMA6fQlgHSOE0EieQBoldlSAOmUKoJEqgCQTs4iSGZwAaQCA4B0LhhBMmEMIJUFRGi1 +qWcEyfw0gLSYD5DOdCNIpsMBpCV4gHRiHUH1R3+efQeQFs4Jknl8AOlkP4C03E3Qw6xBQEaZWQiQ +1qgJkjmKEfKJjABJaZkYmREJkAybBEZLvW+DWtI7tS62AvyOpNK7ZcY+NkDy/TNjFzJBt58EIP1x +M2S3SYbkdgNEb9sM2QOQIXuUANKHMkP2eAOkC0WGbMnJkC1eAOkymCFbUDNkSzNAusgn6LZdZMg2 +HoB0C8uQbYYZsm0VIN2gM2RbPUAaNGTIwo8MWSADkIZEGbLgKkMWpgEk8V5mLHBM0C0EBUhi2cxY +UJwhja6B0TA9QxbwA6RHhwzZISRDdpwBSA9GGbIjVobssAaQHvsyZAfIDNlRFCA91CbodjzOkB20 +AdIje4bs8A+QphEyZAmJDFlqAyDJkWTGki0ZsrQNQJoAypBmkjJjKSmANLmVIUuTJeiWcANIU3cZ +siRghiydCJAmJjNkKU6ANFmaIUu7Zkjzt8BoIjhDllLOkCWnAdI0d4YsYZ4hS70DpEn8AN3LARmy +wgJAWqLIkBU7ANKySYasAJMhK+UApEWhDFl5KUNWqAJIS14Z0tpZZrQGB4wW8zJkZcEE3QqMAEml +MjNW8gRIi6cZsjJshqygC5CWhjNkReYMWbkaIKl7Z8YK6BmyUjxAWtTPkKoDMmMyA4BUsJAgVz4A +oxKKDJkYI0Mm6wBIBSIZMqlJhky0ApDKXzJkQpoMqSIHGJX2ZMhEQhkyuRFAKlzKkCqggFEpVYJu +oqwMmbwLIBWKZcgkZxky8RpAKoPLkAnqMmTSPIBU5JchkwtmyISHAKmEMUMmhsyQySoBUoFmgm5S +T4BUNJohk59myISsAKkkNkMmrs2QyXQBEr1vZkw4nCGTIAOkYuYMmSw6Q4cKrAFSqXaGRPINiErH +E3QToWfI5OwAqTA+Qyaxz5CJ9QFS2X+GtH8gM9aIAJC2NGTImiMypF0WwGi7Roas8QMgbSHJkDWj +JOjW1gKQNshkyFptMmRNOwBp+0+GrJEoQ9aSBJA2N2XI2qQyZA1XAGnrVoasCQwg6SbLjLWlZcga +3ACSWZMR8qmVb4OSFvD2dgC93pn3tv7OvnVrFWgTx6kLOT9Ef2etMza8sX/8986JPKwNct33W39n +Hem2p8K3XvK2s4sHtZ993zf7rsFz3/p8O7fNwP7+CZgf9pt5g+eH+WYdBkiHZ7c5vzYCc+s8yFxb +eR1dj71ON2kG5g365KN7wzVBj+VlYLQFnKDHXvLIeFM6QdLeTpDUqQHSlnuCpHmfILEBAEj8BIiR +kjdAanFAkJglECS2CwCpgQNBUjwHSE0lCBJ7CoLE6AIgtcwgSMrwBImNB0BqCELQ/mgtApCalBAk +BX2CxDgFILVgIUjMXCLktjAEiTSAILGqAUhNbwgS+xyA1IiHIBEZECTmQACpzRBBYlhEkFgfAaRy +BYLEjgkg8XUiRgyiCHp0mgJGZQ8EifkVQGqjRZAYchEk1l4AqYCCILEbI0iMywASBzRixEotQi7F +IEjs3QgSoziAxHGOGLGuA0hEHcSImR5BYssHkBr8ESRWgQSJPASgRewLCRIjRIDUUpEgMWckSIQm +AKlhJEFiPQmQmlgSJHaYBIlkBSC16CRIzD4BUttQgsSAlCARv0TITVEJEntVgsSoFSBxfCVGVDQA +qQktQWJnS5AY4wKkFrsEiR4HILX9JUgMhAl6dCIGRi2NCRJlD0FiswyQGjYTJNbPAKmJNEGPGiFi +xNYaIPHHJkaMtgESx25iRGtEkJiIR8jtyAkSY3OCxCIdIFUtEfTo2g6M2r8TJEbyBIklPUAqfyLo +0SUfGLXbJ0iM+wmSEQAAiY6KGBlKAJCONyBIBiUQtD+OXABIFVkEyRgIgmSgBEA6moIgGXIBkGq7 +CJLBGwTJCI8E3YaBECRjRQBSlRhBMuqEoMeZKcDo8BWCZIwLQSI3A0hHyxD0OKMGGB12Q5CMzSFI +dGsA6SgfgmQoEEA6XoggGVREkCjgANLhSQTJGCaCZKATQDoaiiBR0wGk46oIksFXBMkIrQj5MC6C +HnV5wOh4MIIe54wRIwPLAJpk9BlBIvAjSMaxAaSD3QiSEXEA6bA5gkQqSJAMwANIR+kRJEP5ANpk +vB9BojokSEYOAqTDCwmSMYgAdWnzzwMVCXrULxIjIx4B0mGRBMnYSYJkgGWETAlJjIzUBEiHc74J +WtfnPt/WCWhdel2Pb0fQ4+eOjF8AguRSEiQ/CkD68xL0eJ8QIzccQHrrEiQPAUD6OBEkDyZB8ogD +pIsFQbLsAKQLGEGyFBIkiypAujwTJAs9QLplECSbD0GyjQGkGyJBjzsrMbJFAyR7PTESNETIww+C +JJAhSEIigDS4IkjCNIA04CNIQkeCJAgFSMNZgiQwJkhCbIA0WCdIwn6A9ABBkBxFCJJDDUByOiJG +jlkA6YGNIDn6ESSHSIDkNEqMHGsJkgMyQHrUJkgO7Qm6Hf8JkkQCQZKSAEiTGwRJmgQgTbgQJKkb +giQJBJCmkwiSxBRBkuICSJNlBD1m3YDR9B1BkggkSFKKAElukhhJcgKk6VKCJPFKkKRwAZJcMDGS +VAZI09MESaKbIEmZR8iT7wRJGp+gx3oAMFpYIOixQgGMljoIeqyZECPFF4C0jEOQFIQA0tISQVKk +IkjKXQBJ3YwYKcARJKU8gLQoSJCUFwHSQiVBUvIkSIqnAGkZlqDHei4wWhgmSErMBEmxOkJe9iZI +CugESSkeIC3qEyTyAIBUaECQSBYIEvEDQCqjIEgEGQCptIMgEYkQJHITgFS4QpBIYABSMQ1BIssh +SAQ+AKlUiCARHRH0qF4CRmVQBD3qqYBRYRZBIvEiSMRiEXLZGUHzg34NGBXCESSSOoJEnAeQyvwI +EsEgQSI9BEhFjASJHBIg0VUSIwJNgh6VnsCoZJQgEZ8CpDJWgkQQS5BIawFSkS5BIvclSITDAKkE +mSARMwOksmiCRGBNkEi1I7Sa6JsgkY8DpEJ0gkTSTpCI4wFSmT1BItgHSKX/BEkTAUHSjgCQNjYQ +tDy2SBAkzRYAadsGQdIAApC2khC0PjalECTtLQBpowxBjx03wGjrDkHSBESQtBMBpI1JBEmLE0HS +LBUh67oiZnps3wJI+sCIkYYygqQ1DSBtciNIZmoCpGasb4KiCsjfjqDXu/Pe1uQ5V3w9LMPZCfMu +B/wQTZ71lW3+ZAdf7511eWuFrHvPmzzPPqgcQ7cxtu1I9zTWUeL7vtl3TZ79oY92jNrrk79liucH +/Gbe5Plhvtm9ybMisVfHeG7Hc7tYHWPdSF0AjGM8b9An98ZrYqSDGyDtBSdIusoB0v50gLTTnaDx +sWceIO2+B0j7+AkaHx0BAFJvAYDUpYAg8TuI0GrOCQCpBwNB4uYAkPpCEPRoMAGMOlUApJ4XBIl7 +BkBiwwGM+nkQJM4gAKnHCEDqVkKQ+J4ApA4qEXIvFoIePF0AUW8YgsRlBiD1qwFInW8IEg8dgNSN +ByCx9SFG/IEAUqchgNSziCBxPwJIfZQAUkcmgsTbKULuEkWQ+E0BpM5VAKkHFkHipgWQ+nIBpA5f +BIlXGEDqOgaQ+pcRJE5oAKmnGkDqzkaQ+LwBpI5xEXLvOYIeTeyAUTc8gsRXDyB16ANIvf4IejQN +BEbdBwFSH0OCxBERIPVWBEhdGgkSv0eA1DkSIPWgJEgknIlxV0yCxF8TIBW6ZkYdPwkS71CATA+c +IbEzJUZ8UQFaVDadIfVqJUhcXwEyeXmG1ImWIPG0BUhF+MCIy26E3K8XIOtVAOjRQhgYsSIGxjo6 +ABJ3ZIDUZxkg63wBSLyfAVIXaYCsQQggcbYGSD2yCdI+qgypb3eCbg7gBGm/WYbUlRwg9TcnSPvy +MqSe6wCpeztB0r6YGfWTB0id6QnSJs8MqVs+QeK7D5D1wmZIZwEQJFMFInTrGc7QIZMOCJKZCQBp +Y3VmdIoDQTIPAiDrP8+QjKggRmZdAGRd+hnS+RsEySQPgMzNACCZLgKQzimJ0M30ASCZnQKQTmEB +yMwxAJLJMADpjBmAzEQEIJl7A5BO0AHIzFYAkqk+AOl8IIKGR0+azOjEIoBk9BExatyTIJ/GBJCM +dSJG7Y0ypJOmANKZVQSpDVSGdI4WQItM5CJIzbIypFPCCJJ5YwCZqViGRpmBRpBMUwPIzNcStNqE +N4JkVhxAZlKXIZ1fR5BMwgPIzPwypNP5CJI5fwCZ6SFAMnsQIJ1iCJCZQwL0MFcREA== + + + nc8IkDloAiQzIyPk0ycBUp9RYGQeJkAyWBMYq/e+Bdrn5z7e1M3X2oXa/cO7AaMfm6DH7w+MXsgI ++U9CkPy4AOltAtDj7UaI3LYA6QMAkD5KBMlDCZA+3gTJQgGQLjkA6eJFkCyDAOmCCpAuzQTJIh8h +3y4A0o2HINnCANLNECDdVgmSDRog3eoJkqABIA0/ANJAhiAJiQDS4AogDdMIeoz3gNHAMUIeghL0 +GMsCo0ExQBJdEyNhOkAa8BMkRweA9BACkB5nCJKDEUB6xAJID2sEybEPID1AAqRHUYLkUBshPx4D +pAdtguTIDpAe/gmSNAJAmpAASFMbBD3mSIDRZAtAmrYhSBJAAEkmCRhNSREkyS2ANE0WIU+4ESSp +O4A0CQiQphMJksQkQJriJEiSpQBp2hUgyd8SI4lggDSlDJAmpwmSNDdAmjAHSFPvBEkSP0G3cgBA +WlggSEoUAGmxgyApmwCkBRiAtJRDkBSFANLyEkBaqCJISl4ASe0MGKnBESPFPIC0LBghLzAS9Fip +BEZLngRJ8RQgLcMCpAVdgqQ0DJAWmQHScjVBj3VvYLSADpCW4gmSoj5Aog4ARmUGBIlgIUKmfCBG +JBQAqRgDIJV1ECQCEYBUagKQilYIEvkLQCqkAUgUOcSItAcgFQkBpHIjgkS4BJAooIgRKVWEZhNl +AaTyLoJEKAaQSs4AUvEaQSKDA0gFdQCpNI8gEfkBpHJBgFR4SJBIGAFSMSRAKqskSASaEXKpJ0Ei +GgVI5acAqZCVIJHEAqTiWoBUpkvQo94XGBUOA6QSZIJEzAyQyqIBUoE1QSLVBuhR8k2ISMcj5CJ0 +gFTOTpAI4wFSiT1AKtYn6HiU/QPUf/Sn/gFgtBGBIGlpAEibIwCSLgtipF0DIG38IEhaSADSZpQI +eVsLQdIgA5C22gCkTTsESfsPQNpIBJC2JBEkzU0AaZsUQNpwRZC0bgGkTWAEPXaTAaNtaQBpgxtB +MlczQj6h801Q1AL62xH0emfe2zo865BZ0WU7EJ5tV/o/0BjP8zbrcvEGz3nsXNsxHHXkrFi7nq29 +7tS/dIpnPXfPZ8WYcy0c05saPD/cF/v5D/LF2qHThnjWGeq1KZ5Hlzb7XD4O2xVppimeN+iTj+5N +1wQ9VpeB0TZwgh77ySPjjekESYs7QVKmBkjb7gmSBn6CxAoAIPEUIEYq3gCpzQFBYphAkFgvAKQm +DgRJ7RwgNZYgSCwqCBKzC4DUNoMgqcITJFYeAKkpCEFiLwKQGpUQJPV8gsQ8BSC1YSFIDF0i5NYw +BIkygCCxqwFIjW8IEgsdgNSMhyDRGBAkBkEAqdUQQWJaRJDYHwGkagWCxJIJIPF2IkZMogh6dJsC +RlUPBIkBFkBqpUWQmHIRJPZeAKl+giCxHCNIzMsAEhc0YsROLUKuxCBILN4IErM4gMR1jhixrwNI +NB3EiKEeQWLNB5Ca/BEkdoEEiToEILUwJEjMEAFSW0WCxKCRINGZAKSmkQSJ/SRAamRJ0PJoiUmQ +KFYAUptOgsTwEyC1DiVITEgJEu1LhNwYlSCxWCVIzFoBEtdXYkREA5Aa0RIklrYEiTkuQGqzS5DI +cQBS61+CxESYoEc3YmDU1pggEfYQJFbLAKlpM0Fi/wyQGkkT9CgRIkasrQESj2xixGwbIHHtJkak +RgSJkXiE3JKcIDE3J0hs0gFS0RJBj87twKgFPEFiJk+Q2NIDpOongh6d8oFRy32CxLyfIBkDAJDI +qIiRwQQA6YgDgmRYAkEydgEgFWQRJKMgCJKhEgDpeAqCZNAFQCrtIkiGbxAkYzwSdBsIQpCMFgFI +RWIEybgTgh7npgCjA1gIklEuBInaDCAdL0PQ45waYHTgDUEyOocgka0BpON8CJLBQADpiCGCZFgR +QSKAA0gHKBEko5gIkqFOAOl4KIJETAeQjqwiSIZfESRjtCLkA7kIepTlATPKiDCClodZY8TI0DKA +dPwZQaLvI0hGsgGkw90IkjFxAOnAOYJEKUiQDMEDSMfpESSD+QDSEX8EieiQIBk7CJAOMCRIRiEC +pEMVCXqULxIjYx4B0oGRBMnoSYJkiGWETAhJjIzVBEgHdL4NqqW4wt+zI65+GvPbASSfOzG3CwCQ +XkqA9EfJkP28AMl9AozecBmyWxcgfQgyZI8TQPpgAqSPeIZssQBIl50M2QIGkC6FAOmimiFbngHS +hT5DtmUApJsPQLqNZcg2RIBkZwVGt+gM6V4PjAYNCbqFHwBpIAOQhkQZsuAKIA3TMmQBH0AaOgKk +QWiGLJwFSANjgDTEzpAF6wBp2J8hO0AApEcRgPRQkyE9HQGjx6wM2YENID36AaSHyAzpaRQYPdYC +pAfkDNlRGyA9tAfofvwHSBMJAGlKIkOW3ABI0yQZsoQLQJq6AUiTQBmydBJAmpgCSFNcGbJkGUCS +dcuMpe8A0kQgQJpSzJDmJoHRJGeGLF0KkCZeAdIUboY0FwyMJpUzZOlpgDTRDZCmzBN0S74DpGl8 +gKQekBkrLAAkFYrMWKkDIKmZAKPFlwxZGQcgLQhlyEpLAGmRCiAtd2VI62bAaAEOIC3lZciKggBp +eTFDVqgESEueAGnxNENWhgVI6rmZscIwQFpiBkiL1Qm6lb0B0gI6QFqKz5AV9QFSeUCGTGgAkEoW +AFLxQ4ZMRgGQCjIyZNIOgFQkApDKTTJkwhWAVAKTIRPTAKSyHIBU4JMhkwoBpKIjgES9lBmTQQEk +eqrMmDALIJV4AaRisQTdZGcAiX4tMyaEA0gldQCpOC9DJvMDSAWDAKn0MEObihgBUjlkhlRXCYwK +NAESpWdmTDIKkIpPM2QyVoBUEAuQSmszZCJdgFTuC5AKhzNkEmSAVMycIZNFA6QCa4BUqp2gm+gb +IJWPZ8iE6ACppB0gFcdnyGT2AKlgP0Mm/QdImwgA0naEDFljA0DaIgGQNltkyNo2ANIGkAxZKwlA +2pQCkLa3ZMgaZQCSjpvMWOsOQNoEBJC2E2XIGpMA0hYngLRZKkHedQWMtm9lSPvAgNGGMoC0NS1D +1uQGkIzVBEi9WN8GJRXQ7e0Aer077009nlMdIee581pT3QK18P4QPZ5dQdDxk10teN+sy87qaC9k +Peze5Hk5g9TuO9aWNla01UYZ3//NvmvyHIfno3a9qeKnziu+v8nzA34z7/L8MN9s6RzTY5fn1HfU +a1M8z/m5E6LjNtd6XXdSnOJ5gz65910TIw3cAGkrOEHSVA6QtqcDpI3uBEnLPEDafA+QtvETJIYA +AKm1AEBqUkCQ2B1EyI0TAFILBoLEzAEgtYUg6NFfAhg1qgBILS8IEvMMgMSFAxi18yBIjEEAUosR +gNSshCCxPQFIDVQi5FYsBD1YugCi1jAEickMQGpXA9AmxjcEiYUOQGrGA5C4+hAj9kAAqdEQQGpZ +RJCYHwGkNkoAqSETQWLtFCE3iSJI7KYAUuMqgNQCiyAx0wJIbbkAUoMvgsQqDCA1HQNI7csIEiM0 +gNRSDSA1ZyNIbN4AUsO4CLn1HEGPHnbAqBkeQWKrB5Aa9AGkVn8EPXoGAqPmgwCpjSFBYogIkFor +AqQmjQSJ3SNAahwJkFpQEvQohYyMm2ISJPaaAImAERg1/CRIrEMBUtkhQOJmSozYogKkWkGA1KqV +IDF9BUgVfgCpES1BYmkLkAjziBGT3Qi5XS9AKqcj6NFBGBhxIgZGJXAEiTkyQGqzDJAK1wgS62eA +1EQaINWbESTG1gCpRTZBIhMDSG27E3QzACdIxF0AqSk5QGpvTpBIsgBSy3WA1LydoEchFTBqJw+Q +GtMTJPongNQsnyCx3QdIZUsA6SgAgmSoQIRcbASQDjogaHwcmQCQiISA0SEOBMk4CIBU2gOQTKgg +RkZdAKSCHIB0/AZBMsgDIJXRECTDRQDSMSURcvULQTI6BSAdwgKQalYIksEwAOmIGYBUaUKQjL0B +SAfoAKT6EIJkqA9AOh6IoEdVBzA6sAggmXxEjGgxIuTDmACSqU7EiIICIB00BZCOrCJIdA8A6Rgt +gHQgF0GiVwBIh4QRJOPGAFKVAUA6Ao0gGaYGkGoDIuQD3giSUXEAaUUfIB1fR5AMwgNI6/AA6XA+ +gmTMH0CLVM8JGh5HDwKkQwwB0po3QQ9jFQHR8YwAaaGaIBkZGSEfPgmQ1JeJkXGYAMlcTWC03vs2 +qHa+rXfQZeibPr5ZROxDZ0a+fETsIgbm9mtkRn/WyNj9ERm5zTKhd2tk7LaPjD0/mdEHMTL2RGdG +l4bI2BoTGVusMqOrXmRs+YyMrcOZ0QU9MLedITK2xWRG96rI2KYXGds9M6PbcGRsP8+MBgaRsQgj +MhaqZEZjnshY8BQZi8IyI9FcRCwqDMwtvMyMhKkRsXA3Mho2Z0TD78hYHJ8ZPRBExk4WkbEjSmb0 +rBMZOzRFxk5fmdFjXGTsPBgZO1hmRk+ogbkddSNjZ+bM6OE7MnaKz4ymAyJjeYXIWIIiM5LoiIgl +TCJjmZfMaAonMpoKioillDKjuanIWJIrMLdsWWY07RYZy99FxhKBmdGMYmQsNZkZzXFGxpKlkdGk +a0Y0eRsZywJHxtLJmdG8dGQswR0Zy5RnRlPud+aeu4+MFQEyo9WEyFhZIjNa34iMFUoiYxWXzGjp +JjJWA4qMFZMyo1WpyGh1KyJaJMuIFtsiY1W7wNzKf5mRMmJErByZGa1rRsYKpJGxSmtmtGQbGav9 +RsaKyJmRYnRErKgdGauOZ0bL7JHRcn1ErOyfGdUPBMZ1CBlRPUNkTBgRGVNYZEalGpExzUdkTDyS +GVWhRMbkLJFRWUxGVF4TGdPpRMYEP5lR5VBkVIGUEVUyBWZ2SVRkTFuVGRVpRcbUXpEx2VhmVH8W +GROyRcYUcZlRaV1kTKMXGRP7ZUZVg5Ex+WFkTMeYGRVEBuamrMyMSjQjY1rPyJhoNDOqPo2MyVgj +Y3rYzIiuNiKmz42MCX0zo4rhyJj0ODKmYc6MiqEjI5rqTKg0OzA3jXdkTCyeGVWdR8bk65ExHXxm +VFAfGRXmR8QE/pnRToHIWMtBZLR1ISPaAhEZ66XIjDZlRMa6OwJzaxPJjPabRMYaVyJjHTCZ0Vaa +yFhPTmSsuSczu3QJRcbajSJjfUuZ0QaoyFgnVWakIysi1tkVGWsRy4zMpUyMD7h8E5OkdLc3A+j1 +xra3NUh2gWWtM8W0DnOfAj94g+TWaSKfFbnfOvvCrEhvI6zzz61Bsvbu6alOw/V4r7W9np1CnL73 +m33XIFlXY1vqSalAeX9/g+SH/WbeIPlhvtmtQbK+6uMYzF9/dD796MdPv/n7+qd/99uffvz1N//h +i8+++eKrLz/9+o9PP6s/+qv6nz8xn/z8o3/38S/X3/71l59/8ukf3339k5+8/PvP3/3uiy+vP/mo +74jx23uj/199xK7o1rpa/7L2n3zy3z760X/8rx//4unjeqP/992Pnz75sv7Wx3+d3w== + + + /6e/+ZtPfv3L//D0s6frL/32u7/0V08/+viX4/Db+hv1X//46d9/91nrpequ/80/1z9c/+vjdx/9 +9/qDj/+x/vl/+6izKxU51uNT/3epSPNpqCCnDRUqXlj77Lxcf9L2ZNvSFby68+tPKm7tYkGfi/v6 +f/vlfvNpvWgnq7779z/Wv/+v9Q//d12Bf34ah6e/efo//s/h6fP+MH/3US3jdetUcNKJ9+98imoh +rAVqned2iXn6Q4Cues851W46VOBcZ/96xp87yJna1Ovo3XU8+vQ2XTYza7sW1w38XBFimz92AmgN +yGcfrZcNap1T1743OhtwgyrwqK13qRcZtm5tD5/mjty+Vb3VDZqWq398HSsWW9tR7/ZppuHKfLeb +a29K6/1L3YjPPrpdmxtzv8C3j/KGH6qfoHzD2r//6NMvfvazv/7977/4x3+q2/anv/7yi8+++vzd +r775+osvf/d0/Zef1A39q3/49B/f/exn//HTLz///buv//bTP7x7uaX91eq61x28drJtaqfgn/7d +u09///T4HvUi77743T988/L3x6ef/vyrr5z4xe+/+uz/+ecv/undn6Bf1t6gzC+//OKbLz79/X/+ +759+/vWnX377ckN8w//0RX2fT7/+5uMvf/f7d+8Ba+l4L/Z3X33zaX/pB/AYt+XxF4h/7xe1w737 ++n//7m90b/l3d8v6yl/4zctfsEub3+Lvv/j8m3/4drW5/Xr/6dOvP/3DP+X/Vlao8c/rxb+tCf9/ +WhNeIq5ff/llPcCfP/3uu6hrX3/cG3Vnrtuqc+4z2LUh7rV7t091u+5dnj9TBXHt9NZKlqNtrm6x +1osB8txWs32cmZ8qfHjex6ElOWsX8586tKjgejsvD/e2O9wr1tg6BBja+aszOB3Lt5ahDiGtQul7 +YRufj56ffvZ3Pq9Qqy7P+Ly0RqC+Xn2wp31bL2flOhSPl6XbW95rqqNrO3cvbZ55+Xu1FcfzVIeo +OnNM9Z8OSI6ugHeSZZ62FmI8TZ1tbHemOgLse33ED/S9fv6BvtdVIFjbb20+Ltf2vh86sdCipmOp +v/PnMOvfdop/2yn+gp3ipxXijv/l3b98U79oXYD/+et373795edfFXD9W/32v/zy83f/8vLvv/rm +q6//+N2/T08/7b/38Zf9y3zx6T/1LfTvP/qrjz66tp3PP9q+jeiH7wLjuvXrGgydI9/aILAOlO0c +vF3ebpdxeTul3KCpxWUVLtdDVzH1i3fPDRpbwdjpgHEb2oP1aRzb2rUO5K3TnDq1sVUQvez1Z+e6 +jHVRr3W9M/tt4H5ctf8b8tlHZz3tV95nODu/fwSoF8euGa6dh7uGHdw+zR25fatffBSgoweFzPsx +9QH/2Oqrn12LGdZj6jPe3hnct0H3i3iHrjV071karSMa96ezbatr/6pNdFynLp6NY6sBx/pS18yG +JVzEG1K749hiza0VJrUXtiP1/XWmrq9tLSpazrOr27dPc0fCRQyvM4zPe9t6tv10r859/8zPc/21 +fWthWnsv1pLcstStL+B0nsula5ha8tIZtDqPHRdUH6kf4aWN8SpUePH6XPd6nS7Ejf299r5kc4sq +rgzf/8fe2/bMkl7Xeb9g/sP5YkA24kfdXV1V3fInknIQBmPHkSxYQRAIY3IiT0INDYp+0b/PXvXM +cHqtWteZM8KhYwSxLGrm8Dr9Ul113/vee+21C3KTRaoMdx9yVtt1fc6QCiLz8N8vsjt/6IS7zJKj +GR8TYBwDPK7r/KXLRQ7XE5Xc3+/neSS22e7nhWVsf0Lmfr5KDDyByqZvrqzOCdr3IyF6lYZi7uK9 +fJqCnL9Vga7bXMB93yVaklvpxH3PuwKL2eAex/e+yK72qadrnrm5L54auDK3zvwqkm7f3n+qm2S9 +UiJt81P9ot3K86Mrkygvr1WTcdr9rrLv/E6SLD3kb/ZleQQ/hXlKhzXL0Lbpjj4erl0W1brK0j3e +jk+9SqDwVCXsMtdiv0lHLjc7ZVoux6P1nii7SUu6z0NSkHKRz5AClOtDRr3zofbHh4d8t+83/cv2 +7k8+m8rbMUTgIsvb+6PdOonMXTqPm5bc5y7pzbVB79OW5Ft8mV95aZ+mIOWBOENz61y03us6z4P9 +4RD5rhcZSUtDv7xfYqWf5U17uL5/wobzi0/JYGqIh2oIunM0I6l6vF2P4uTc3Iv01OtP93jTrbQv +KgVquJBucNXwLPe2rxM3TkD/wy9+UbHLndCW5ymFKc3Lh8d3nrtXTchQPvcnvtnlcbhlLqty9MtE +rgp/90+wePuMXywzmJ/li0ms+bAMppRGrxZvejrmPlxnJZCGbWIA+YPK41pjVCZWn8DlKVv+Y/DV +3CaHkOkEPedlNB1MZpnv+vY5I8y6P39r3lHW+Q1Z5nKvUtOojroey90Jul7ukh8umzwdjy3ueX+7 +73fVSbSjva9A25wmZi+dpXcOc+v7UjZ7mWxs5aN/OTZvjUmSjHG5zeNz1wo929JsO5cjqXlscZqb +IGndXL1VFntn5PxEF+hQda1aMmfZmafzuczrPo71WsqzI46aZeAIgu/vo1qOaGPOeU85kO8SFp8Q +RRu3t2PWhhzr78eSeHqdWU3mRLxuc6JVH4qQuSG2+wQ5c9OtOvXfJMm7aL25PQ4z97mSb9rWteg/ +lueiaENBynzR+fluRynzvZivm2rZZwk6gtWritMyC5Z0SB7lR/lufy7boYyb2FRX/XroXfZZ9Z7H +jjtxxFU69fu7ZWj55om8B6vPQ5GunXFtr3PsXrMhSwC/H4bhh4B6ecyxUorc+aIFKb9ngeaCqV9p +PSaGHFu3ZnnIBV1Rja7gXIrlIvvWbX7f/XgiZo+em/Q568Qhtp/vP8/RPM1Ss18m1JiLPBv+rOjP +I1q739f3KEFSmdl/1rl/j2jtBJ0enArd3uSWfFuOpJLitTNy0Qlgvcvsef7nu83SloMT8n4TSt19 +l4prVzn4/DpnZLZT7aWa7KLJUg2ZtU0B1KJ4bH7d4yZM6MhY6SvNpqUl+bgLNTFifgjdBdfj1pgr +vR9SW52SHvt3cfFDepaLfun79v6LKfJZLvqldR/OrXBT8U9agl3qGf3u89g+l4f0h8u9InH//OKI +rlUnn1O0Jh7dCvRlg64aEbMvR3w/4dXxZrMUPg5Vx/M9BFeIK+ftOTTMOnU8yQ8lTCaqWB5qJ9NS +uGnco2I2VV/en+Tl8I7WFI/luzVV5WO56181DO7LAp1+jgZtEmNLSTV7j1pCPhyh3kUO+etctbaf +fMKW86tPC12khl0V7141kvHRQpc5DCkuvs7XnLPNdf1HhC7PD+vyJimrLMgvl+NRtk13ntOH0lc/ +bALHkAXf4eezZOgidnb4mw4Ocw6dnVKa0p/4ZtLPHrGLdAEKGmf7U0PAp8Qun+2bZezyWb7Zc/b4 +W8Qu+/ISu2yPN206OnZf52ZTKmDRxK7Z+DY5YM8R6+8EXdUmqLBgP0SyJ+hLQQoMjgFN66IzAkDH +qJEJwJdDRNyhZQL7i9IWc2WeCGlW1mXWFgnjCZrtZkI/Dat76Fnr0Krf4KbM7zGQAqCHdDlaNx/K +83RoorV5RmYZP+JRgPYJESR7V2CDl+BYj9ajJ+lKjAS++llu2zGPokNPqTPkm/44rMwBmn15O3QI +yxV+36daNGZFmOB7zq4IaS7iLln/fCb44ANtEp/KP/5yg5/u+Tb7wyw3s6pNSMrQbDu3OUDedJ4m +SCdX6Zye10Ps26G52reJB9UGdoHfV+Plnjo+ziVFZNUZePbx7UkPwTz5moMlje5O95tWh5uGB277 +3MD4ZrumdkxENzHfA3+Sxzz1R0Xj/p4W69C+Kgl2W3VKIUjNJUrNaHPsP67qSZf5UGrPvm3wXAra +JDmXoP7Zb8pd1ap5p3k/NW0gM1H0uhw3JUOKuCcI1bAkuHEHWuYHOabIqiaEkEZ8TRh1fxxTATuk +zms10EqrgVdpVa/JMc/hBveSIBUnH5IFPeFGGWhiZfVoKY91xUsgV4PZ2RQ3w3oiaOKP2WeeyvYh +9FAgqelFGg5HkGZnzu+v3ugLXqe5ABNy6VouC3zwOQPOXnJZpK/f4NkVJJnjPLZHdwVBVw0b3iRt +hud714lk15SgRccShqQQ3jWX5gpL3EDzXvvlUKIfwvcO3W+XCQSVabhe4TINJOOF2dzv2zExq0Pa ++dWXoz/v6+BAaipZlBI7lFwEzQM10a/+/wLPwVXNHE9NBpzI+4LQnPbkGyGnggU/02PXszsHEcWt +BD0P3dhFebY73HPKxl+0XWxzTIF3u6mj42ionkXlgdAx2Uaqyf29ONKh59GnozjsDlfgpqaO5xyd +pUK+IbQcc4LmlDI7B/y+AylW1ODHfX/A7TTHvFWj/G76ZAtcyznQXlfp6bVPQ4giaD73nG6WI9Al +aJsj1mxA61WmDASpW+eilhTcMwXtt6fCk5ua5gh6LJrRdTsaNxFSO9NdC+bjyIIAtG1aDtejFaRD +yyw8FzUQSxxN69yiDo+nRntKRww/8PKm9M+u091jp6VAKckjXanTPa1zAz20Vt60le3wA89pbVVV +5a7djJC7/AJkLaPuVIRmK5A5yJw1rgitc4fMZdLDSwuB/uiQJdwvysEiNP901bS352Fj0KFZTrZ5 +niaieUKUMpBOBHNYe07Uf2NoDnDbRYfyZYO7aVG3h0LCiXs3vAWUJphlQNIXWnfus+7MgUZ1rvVG +1/KurORTSbb5ZBf46QZ6PFURne3uSmHKXT0fkiwtlxut8/c3NQHN+nQIdGEXG+gxq5JGU82dh6+k +8+iR0bhgwHd/0+akCOUojCN03G/H6G1a5e5vUpyr5Xx9LHAQG0j5H/lQXC70XN7V+zHBjPRXdwpS +7m+ahb4fIdGFFrmBntIISbxzh6PKrvFNc/vrgduucBDb17fLbZv4StvdAw5igp6XTe3pSlDDZ9KY +q/WqxoQ529Iit77djhtX+pP1ydAxMP5yX3qC4GDU3j7x0DYLKj296yw7c6RRj8BzucAtt6oL5PlQ +ZULt7gRpKuIAUgjQ07uqD+ShmXB3TXdFSKX6m6yijtl5HZIhhRr0ZDmBv8qx1a/KBe4UpKyz7Oic +cVdfPJ1X1renLtGm+es7rXIDqX1asrHbnc5iqonO0zL7jkoJcAk0rPBY4p5XzRdHaE7Qu1JOs4jD +B9/epH9cLyppr3Re0VDH5flQS/b7SFaA5lGSjcEEInCHb2/K8M6lOmzA8Aqsqq3MsW3O0Tt+JPXe +rjKemn+AC66K0Kw4s7fu+5OCFE0IvWgi7yatPl6mfTukfw/t0vjBHzcN4VOX4L7iZZq7dvanhyYB +3/AzKYFwzPw7JlxVaJ+F56bu/m1uOrriGji7aVWRhxk9m/ssPJdjLu8cMmidU9VJs+xVCYPvpiLB +7LqH99GTVrl91p37Ucyb8ItWuf1NwhSNwX3MJ4IbXMOLZ53bDtcUfKF12TVp7ippHw== + + + /Lr7m9bAiYqly+MvN2+iRjf5LUBOZqBdtmmaxHi70lFsoKcOhkoo3iGhKqWNjBKOVu0rrXL7LDuH +Ivmm2B8/+HshcIKG25ViIs0MvyknqS7PC/x0j7erHOPms2sqLUOPi/qMjgASfhaNVp/F+ZiyuUG6 +eKBFPg/79RhXiIzkyxMQ7hqSStBdCfuH3BUWenofb+qw19jliVRokRtom4DwqRBrocPK400ZWRV2 +ddKG33cgieCO1MZOUcrjTfq1ecwPLxC4nR6z7Nxl06caBJ1rB3qoZXbVdF5a5SQ7XNQFfteeAYvq +8+2i3PxEMvscx+A6DTQf6nKIpW90FHu+Xe86qk2INZ8JLsHz7XgGHosclmiVG2iCuUNnP1cBfuDn +2zKb2E3Ks3klWFSfs/DMFjU/CR0MhtjmQHOVy8lGD+Zzlp3boYq4L0/Klg6kYo+mGl53enolIJ9v +P+eUXQV/gqRfu6o2fj3EhgA91ds3EfTz8ATr0EPt9qorzO+Cn0nl0wmspKukGGUgBfsqOu8U8D0u +b6qSXRUR3g/zmQ5pMrfeat8P1SZA6mU+JIZ08hvopoTyHMTnP/vvO4ySCPc5rM6FgMPKGXpX0Cgc +k6HT7dberTPxsQHyC9ChuJQFOv8oAPnP26G4UToUtxxAfvN2KB6DDsUDBZA/mh2Khxygl7WiE7Hk +dCgWL4B8GexQLKgdiqUZIF/kG3TaLjoUGw9AvoV1KDbDDsW2CpBv0B2KrR4gDxo6FOFHhyKQAcgi +os5EaNWhCNIA8nCvQxE4NugUggLkwWyHIizuUATYAHmo3qEI+gHy40OH4iDSIT/RAONHow7FIatD +cVwD6PXY15E4PnYoDqIA+ZG2QafDcYfimA2QH9g7FEd/gDyJ0KFIR3QoEhsAeYqkQ5Fs6ZBnbYDx +9E+HIpHUoUhJAeTJrQ5FmqxBp4QbQJ6661AkATsU6USAPDHZoUhxAuTJ0g5F2rVDkcAFyFPBHYqk +coc8Ow2Mp7k7FAnzDkXqHSBP4jfoVA7oUBQWAPISRYei2AGQVU06E+WXDkUhByAvCXUoiksdijIV +QF7w6pBXzjoTJTiAvJjXoSgLNuhUYATIKpWdiZInQF487VCUYTsUBV2AvDTcoSgydyjK1QB54btD +VkDvSBTiAfKSfodCHNChkBkA5IKFBp2kDwC5iKJDIcfoUAg7AHKJSIdCbNKhkK0A5AKYDoWUpkMh +ygHI5T0dCqFQh0JyBJCLlzoUMiiATE/VmJMwq0Mh8QLIxWIdCtlZh0LABpBL4ToUoroOhTwPIBf6 +dSgkgx0K8SFALmPskOshOxPCSoBcotmgk9gTIJeNdigEqB0KKStALortUMhrOxRCXYBc8tuhEA93 +KGTIALmguUMhje5QiKwBMrV2Z1z1DYzLxwt0FqJ3KCTtALk4vkMhs+9QCPYBMuV/Z7yDoDPWiACI +NzR0KFojOhRNFgB5u0aHovEDIG8h6VA0ozTo1NYCkDfIdChabTrkPTvAePNPh6KNqEPRkASQtzZ1 +KJqkOhTtVgB541aHogUMIG8m61C0pXUoGtwAuqjRe99mqYSy0ba/HSngu6aeQL7pxJR63/nNAPqR +vrxPctfVnJGJmTe5tV41OebH3HU3tb//xP7O+ROzhV2PXNTZFnZbX67Ovp08aGeViv7O+arzefY5 +QOp5l6HLvs8D8VPf7HqcBmZhustCZTZ9deN+QnvnZ/xiP/9jfLHZbFdv75R130t7p6q9D1UM73q0 +teIu7133cypTpLLKU0vQer1ohNrzpmrRiWll4w7NTbvvik2um+o3AGkyx22diPlI3hdIZeP52Ncj +1bRp6QZoPeaEHg557ct9WQrQHXp31VuVSlS9G6Aj0FekL18/YC7zEyjpfnvs/QqoSL3JMv2ifvwb +frmoZHdo04SX2cPnKj3xCsydcpTdnhqvgpAMdSaunBvviZ9ptolZhbaL9ji8llET75Bq1HeNmHrc +8VrKT3JuTSWkLvjl7tf3Q9NTDxAwqkusGoZ3ffCljPI6QBqOoeFzl50v5QTV61Gfk202QjfNvrrK +GkobXIcm6FqO+HRWZrwCUagHaO6RdZYiTQnBV7psGnY3j9NhUUTQoorLfgyGg5/ucRRLNKRO8RJ8 +u1PJHyB50MiOYbZY+EyzEe+bbFjWXe31CC06WCn6uNJ9OfHZnLxkKzVPFV3Mk3gAoLkCu5wf9kOr +0KFZSuYZn9/kesyZA+h+SB4ucqBBRpn2ebFZfemBOqkQALrJqmNZPvJEaRamtkzVL67MrBqNq/TB +vuKPokKQYmvFH/jlQs4A0NxMSrFstwtfynnAZ7lclB154BWYM/NtmV1uuTwX/HnlmKYpQpq0ga8U +ygiA7poBN0uBphsjJFsm1d0eO98EF3kayVh4uT7xM6k6tWkK0L7RxTxpLABSUk/Ow9sxsBIghedH +vupCF3NXivCpwriqM/hK87ipyjF/dkxX7VCoNQA66iCrRlLv+O12GSXPeq9HgRjZOctARcoPfCFV +zGQsLP0Av5LLPjokvdasuvOGclAi6HZX3W2VwzO+kvyvNEtaAQ1+prvyeousv1a+lqEg6dCi33bT +lNRlhZVec541Gn2Oj++efh26zT/rydOcWfxMquI9JevZjto5QK9alI4cnrx3TULZ+FLqBH6Rt5Lu +OoJmBZjI+HqMZYeFYD/KgRoUfn8eNXiAXNXSoE3KTO2aWjHovtS08LtWeo3GesCPMpCOMDJvncUC +PpNG3Ox6oGbzPar5ALk+pkMaKCobxbsGqyKkKUoyDb2vd7hRBtKMV1lEPo/Zoh1SjVJR+FFZQciV +Nh3SCMCLCqy3Q9gD0CGC1PpLm4/sMJ8qv2oU4A0/ktLocxs8rvOCeC1DsgOQQstZMDQ3D7+cBk1q +cPos4nwtJ9Z7THipKX0P/FVUON3l/fW40PHopP4B6HqRYfChPoWFQD56quEdFukUp2zKXMtwTick +vOCzKqmUsM2Wz9cyZEQATVS4P5eHXMvgCswJX976KrssGz11SgNILjmHrLmk/EoXBTLPixzj4Vqe +BEkAHQU1Lb8rHdvXt32iK9kAa8Y3vtKu2qOyK5eFzkfrURVWkUeVQ2JC2QTQRNhPDWmWuzpB888P +qTMnvtzwMq3rewlLGXx+pTmvXTTcVmZpBIVGCqDlcUzpmt0O7sv1TX67chJXFIIvtEhitCrue9Lp +aD3q1Ju0qYofCXKxFTB3jYtb5zPd+FLOWrnKB/Jy2+lwtKpaoLq5Jn7TSVNzEp8Su+9KrOOPErIt +gI7BDZfjseJXmhVwmZtctpRwLe9vh8JTPnLPO50070ft/KE57csTvtxJ/wXQ3P/Hs6nhEQjpT/Tt +J9KG1fmuAoamIM877nRqH+i+TNCvEfM3upapJOvM3G0yON0fs7TCDT6QxmKpNvOkSO6uSsiqqHBd +nvTI3Y9i/lPjyOft8FKGJK1Dd7W7aLufaBZf6a6joV7nutNef1dNZZEL5JxZd3wlyQJ0xpzgEC9l +aNs6NKGA3HVnxdkonB/ornKSQtULPXMDTch4V8b4QevgXfKC7aq9fjlqlAC5Sq5DGlAzR/uLJp3j +pVRp+lAOyKAfoYsSnHMO0y7doeVQKsxSsswqQGf21Nt1Znalm8Qzu2IUhFYpKR9amyicH0i6VY0W +XS6U3NGEZGWTZ63cVzpmnpR7AF3k5zoHuu0QCnZo2w4N5Gxjh1wWoNu7CkOKaLwEEk88NOfh+aD7 +8qQBBOiigFfzjTdavxZ1Y82fzCq/XCicH0j35OWYZM8Xc9Hg3Vl21JQHT12oCQGRuOAw63zypZyf +VfMBH5o3gd/ttqh0LCPoBz10yyHn0BlDKSD8UUKXCNBNZ4d1HvUrX8oJPaVDumnUEt7h7yHF3CV8 +HF8OaYiyEddtpfTHSeEI0E31tcuqnha4mJqc8HiodihNKVyCM3SM+dUae51HEd6tMvGxz8z5+1cm +LmRl4hdpTP60lYl7pDJxszUm79rKxO3fmHyOKmOPYyXiqW5MLg+ViXWmMblgVSZWvsrEEtqYXIsr +E4t6Y3J3qExsM5WJ/aoxufFVJnbQysRW3JjY0isSocGZOccYlYlgpTIR9TQmw6fKRBzWmIjnKhJx +YWUiwGxMRqqV8Yi3IhE5NyZD8MpELN+YPBRUJk4XlYljSmPiuFORODY1Jo5fFYljXGXiPNiYPFhW +Jk6olYmjbmPiyFyROHqfmfMZvjKRDKhMZBUak+mJykSeozGZMKlMZF4q4xmchmQmqDKRUqpM5KYa +EzmuikSurDGZdKtMZO8qE2nAxmQ+sTKRmGxMJDgrEonSykTGtTGZuq1M5IAbk8nkykRWujKR3j4z +5zx5ZSLhXpnI3DcmKgAViUpCY7IkUZmobVQmiiSNyWpLZaJs05is/1QmCkmViYpUY7K0VRkvkVUk +Sm2NyZpdZaL415isIlYmypGVibpmY7JAWpmotDYmS7aVidpvZaKIfGbO1ejKRFm7MlEfb0wW2isT +FfvGeOG/EqEfqEwIERqTiobKhDSiMamxqEyINSoTqo/GpHykMqFDaUwKWioTypjKhMSmMSHVqUhI +fioT2qHGpAipMqFmakzKoioT+qrKhFDrzJwVX5UJ6VhjUoNWmRCzVSZUcY1JeV1lQqdXmRD8NSaV +g5UJCWJjUstYmRBFVsbFlQ1JkWZlQu3ZmJSNVsblpxUJGWtjUg9bmRDWViYUuo1JqW9lQjPcmBQf +VyZUzJUJOfSZOeuqKxMC7cak0rsyIRmvTGjPG5Mi9sqEGr4xKauvTOjzKxNC/8ZEw0BFovGgMt7A +0JBshKhMdFQ0JlszKhM9HpWJZpHGZNdJZaJ9pTHZB1MZ76epSPTlNCYbfCoTnUKViZajE1N6lyoT +TVCNyW6qynhXVkWiu6sxc4fOPfo8OtHodY7h5Mv9yEzSxwmX0k9iziWz8mYdik9doR9rbvukHslF +2858ovsxFvdax3dbj6S2uJ/cI6nhsVf5zyhJrNytDhbe3ad8yTF4+vuK4n7LKdfbfhrffTsmb+s2 +OYw2Nvmaqm/xJ77Z3GyreiSf6j+faOkpe8FP6ZH8fF/s53+ML7ZfVPb4SI/kudX2/lAKdA6bc1yf +J3mtIzBPUOtaBsj7nzsUndQAeU92h6K7u0PRJw6Qd5x3KHrXOxRd8ABZO31noi+/Q9HhD5B7BTTo +5DrQofAvAMidEDoUngoAuTtDh8LnoUPhGAHQq/NER9zAojNuhAGMO2p0KLw5OhQuHwC5X0iHwnmk +QGcPE4DMDKUzbqoCjLuzdOjmPi8dCscYgNx7pkPhYtOh8MMByJ11OhQePR0Ktx+A3DeoQ+FA1KHw +MgLIXZEadPJXAsidmjrklk+dCe8ogNyFqkPhZ9WhcMYCyD22OhRuXR0K3y+A3EGsQ+FF1qFwNQPI +/dE6FE5rDUrLNmDc+61D4SIHkPvRdSic7ToUHnkAudteh8K3r0PhAAiQewl2KFwJOw== + + + FP6GALlTYofCc7FD4d4IkMsNG3RylATIvSk7FErBDoVfJkDuvNkhE/l1JJxAAXJP0Q6FPq9D4XMK +kDumdiikdR0KF1eA3A+2Q66KA8Ydaht08rrtUAjaAHL/3Q65kW9nQosGkHsLdyhcijsUOjKA3Dm5 +Q+HB3CHXgAHjrtAdCn9pgFy+1aGne1436OSeDZBLrzoUjt4dCm9wgEw11ZlwK+9Q+J4D5IqnDoUX +e4fC1R0gFyt1KJzmAXLP+g6F0KhD4aMPkDvyN+ikEepQTAkAyOcNdCj0PR2KGQgA2TCFzoQyp0Mx +3wEgnxTRoVDVdCimVwDkczA6FIIYgHw2R4diykeDTloWgHzySIdihkmHTIYCiM9U6VBMZ+lQKEgA +soExnYnJMx0K7QdAPg2nQzFXByDXbXTo4bN+OhRTgwByyUWDTpOMOhQzkQBytUSHYk5Th3zgEzCu +c+hQzKDqUEyzAsg1Ch2KCVsAqRr1w6yuDoW+oEMxPwwgn0TWoZAGNOg0HQ0gn7PWoajqdyhmvwHk +U+Q6FAX5Dr2OtQPCp+N1KErpAPnEvg7F7L8ORRUcIJ9H2KGYbNihqGAD5NMWC3Se29ihKD4D5LMk +O+RDKTsTNeFPg9TStlzfrVvVGtDerTL5sTsUF6BCeSnPUPlROhQ/b4XyRqlQ3nIdipu3QvkYVCgf +qA7Fo1mhfMg79LpWVCKXnArl4tWhWAYrlAtqhXJp7lAs8gU6bxcVyo2nQ7GFVSg3wwrlttqh2KAr +lFt9hyJoqFCGHxXKQKZDHhFVJkOrCmWQ1qEI9yqUgWOBziFohyKYrVCGxRXKALtDEapXKIP+DsXx +oUJ5EKlQnGg6E0ejCuUhq0J5XOuQHfsqksfHCuVBtENxpC3Q+XBcoTxmdygO7BXKo3+HIolQoUxH +VCgTGx2KFEmFMtlSocjadCbSPxXKRFKFMiXVoUhuVSjTZAU6J9w6FKm7CmUSsEKZTuxQJCYrlCnO +DkWytEKZdq1QJnA7FKngCmVSuUKRne5MpLkrlAnzCmXqvUORxC/QuRxQoSwsdChKFBXKYkeHvGpS +mSy/VCgLOR2KklCFsrhUoSxTdSgKXhWKylllsgTXoSjmVSjLggU6Fxg75JXKymTJs0NRPK1QlmEr +lAXdDkVpuEJZZK5Qlqs7FIXvCnkBvSJZiO9QlPQrlOKACqXMoEMhWCjQWfrQoRBRVCjlGBVKYUeH +QiJSoRSbVChlKx0KAUyFUkpToRTldCjkPRVKoVCFUnLUoRAvVShlUB1yPVVhzsKsCqXEq0MhFqtQ +ys4qlAK2DoUUrkIpqqtQyvM6FEK/CqVksEIpPuxQyBgrFHrIyqSwskMh0SzQWezZoZCNVigFqBVK +KWuHQhRboZTXViiFuh0KyW+FUjxcoZQhdygEzRVKaXSFUmTdIVdrVyZU350J+fgZKkL0CqWkvUMh +jq9QyuwrlIL9DrnyvzLRQVAZb0ToSDQ0VChbIyqUTRYdinaNCmXjR4eihaRC2YxSoHNbS4eiQaZC +2WpToejZ6Uw0/1Qo24gqlA1JHbp5a1OFskmqQtlu1aFo3KpQtoB1KJrJKpRtaRXKBrcO+VTKBuV4 +y09izvW+8mYd+pG+vE9r79zmgDEhhc5pcvX8o4zAlI3VT58UqdqjdUHeH6cRmDdVKBUZq1wzp8ib +/BX/sRMwJwSTT8yiVWX+3ye0d37GL5btnZ/jiyl6t+ZOHTU/OgBzPf7yTZ4W85+3pQ3APDGtaNyh +6P0GyJvIC3TuRgfI29oB8vJzh6LRHiBr2AfGG/87FA4CAHkdu0PhaQCQmyMA5C4LHQq7BoC8It4h +948Axn0oADI/i86ELwZAXlwHyJ06OhSWHwC5d0iHwoQEIC/TA+S2KB0KfxWA3KilQSfHF4C84A+Q +e9B0KMxsAHJXnA6FvQ5ALh0AyA1/OhTOQQCZAxEw7mTUodU1CAC5t1KH3KMJGPd6AshNozoUYgaA +3MaqQ+GHBZAbawHkDl0dCl0EQO4ZBpCbj3UoXMwAcju0Bp0UFgC5QRtA7vTWobCMA8i95zoUWg2A +3A0PIHPV60y48wHkNn8AueijQ2E8CJA7GHYorBABck9FgFw/0qFweQTI7SI7FL6TALmBJUCvSpSO +hJ0mQIv5cnYoDD4BcqdQgFzT0qCTdylAboIKkLupdihsWQFydUyHwigWIHecBcitazsUHrgAuc6m +Q+HKC5C5+wLjLsEdCrthgO4m2AHIDZA7FE7KALklc4fC2xkg1/4A5G7THQrbaoDM/rozYaMNkIuI +AHJj7wat6RAOkFuNA+Se5R0KORJA7qLeobBjB8h93QEyf/jOhK4JoMUM6zsUzvcAuYU+QFfz4u9Q +KKQAsuEAnYkhAwD5tAKAfOxBh1xqBYyPYQDI5zl0KAZDAOQTJjoUoi2AfOYFQD48o0GnKRwA2TSP +zoT6CyAfLwKQzynpUAw8AcgnpwBkOrLOxCQXgGwiTGdisgxAPqIGIBekdSiG5gDk03c6FGN8AFpf +xwEB48q2DsV8IoB80BFANjCpMzF4CSDXyHUoRkEB5DOlAPLhVA06TbkCyNR2nYmpWwD5+C6AfA5Y +h2KgGECu2wPoYiPOOhSz0gDyoWsdiultALkCECCfJ9ehGEwHkE+461CMygPoVUsIiA/u61BMAATI +Rwl2KGYSAuSqRIB8SmKHYtwiQD63ESAfANmgk74RIB9J2aGYbflJ0HZ5O8Qt82NdpfWqbweQf/AG +nS4BQH4xAfKfpUPxAwPktwpAftN1KG5fgPxB6FA8UgC9PpqA+CPeoVgsAPJlp0OxgAHkSyFAvqh2 +KJZngHyh71BsGQD55gOQb2Mdig0RIN9aAfJNukO+2wPjYUODTgEIQB7KAORBUYcivALIA7UOecQH +jIeOAHkQ2qEIZwGyuBgYD7A7FKE6QB70dyiODwD5QQQgP9J0yM9GwPghq0N+WgPGj30A+QGyQ3EU +BcgPtQD58bhDfs4Gxg/sDTod/QHyJAJAno7oUCQ2APIUSYci2QKQp20AsvxPZyKRBJCnpADy5FaH +PEsGjKfbOhSJO4A8BQiQJxM7FGlJgDzB2SHPlALjKVeAPHnboUgDA+QJ5Q5FahogT3ID5OnyBp0S +7wB5Ch8gLwZ0yKsKwHh5okNR6ADISyYAefGlQ1HGAcgLQh2K0hJAdytSAeTlrg5F4Qwgq8AB46W8 +DkVRECAvL3YoCpUAeckTIC+edijKsAB5QbdDURoGyIvMAHm5ukGnwjdAXkIHyIvxHYqyPkAuEOiQ +CQ0AccECQC596FCIKAByOUaHQtgBkEtEAHKxSYdCtgKQC2A6FFIagFyUA5DLezrkOiFgXHAEkEuX +OhQiKIBcTtWhEGYB5BIvgFws1qCT7AwgF7B1KKRwALmoDiCX53UohH4AuWQQIBcfdihkjAC5ILJD +Ia0EyEWaAJnaszMhGwXIBagdCikrQPdXTSwwLq7tUMh0AXLBL0AuHe5QiJABcjlzh0IYDZBLrAFy +sXaDTrJvgFxA3qGQogPkonaAXB7foRDaA+SS/Q6F+B8gbyMAyBsSOuSdDcB4iwRA1mvRmWjaAMjb +PzoUjSQAeUsKQN7c0qFokwHIG246FK07AFkPEDDeTNShaEsCyBucAPJWqQKdm64A8vatDkUjGEDW +UQaMt6Z1KAZhAuQjNTsUHqufBJWa3/ntAPIP3qEf6877tBbPZY616oJWonvC5z/KBM9Z2P8Rgy51 +vLJOyHXZTy2ec4DaPsxh6z4nbyV65u1nG/rpEzwVUUw4f3+7PS7ympg485N6PD/fN8sez8/yzfbD +7MW6PFX7/dgIz6MGPE+6DoLLY65LG+F5glrXNUDev92h6AQHyHvKOxTd6R2KPneAvGO+Q9F736Ho +4gfI7AA6E74CHQqHAoDc66BBJ9eEDoX/AkDu5NCh8IQAyN0lOhQ+FR0KxwuAXp0zOuIGHJ1xIw9g +3BGkQ+Et0qFwKQHI/U46FM4pBTp7sABkZi6dcVMYYNxdpkM396npUDjeAOTeOR0KF54OhZ8PQO4M +1KHwGOpQuBUB5L5HHQoHpQ6FFxNA7urUoJM/FEDuNNUht6zqTHhfAeQuWh0KP64OhbMXQO4R1qFw +G+tQ+JYB5A5oHQovtQ6FKxtA7u/WoXCKa1BazgHj3nUdChc8gNxPr0PhzNeh8PgDyN0COxS+gx0K +B0OA3AuxQ9vdXBU7FP6MALnTY4fCM7JD4T4JkMslG3RyxATIvTU7FCLHDoXfJ0DuHNohkyZ2JJxM +AXJP1A6FoLBD4dMKkDu+dihkgB0KF1qA3M+2Qy7eA8Yddht08urtUEjuAHL/4A65EXFnQigHkHsj +dyhclju0ur4NIHd+7lB4SHfIZWnAuKt1h8IfG6Cnick6FJ7dDTq5fwPkGrAOhSN5h8LbHCBTbnUm +3NY7FL7tALngqkPhJd+hcKUHyGVSHQqnfIDcc79DoW7qUMwBAMgnCjTopEnqUEw5AMjnJXQopEQd +ihkOANkwiM6E/qdDMZ8CoN0mXXQoZDsdiukbAPkcjw6F2AYgny3SoZhS0qCTRAYgn5zSoZjB0iET +tgDiM2E6FNNlOhRyFIBs4E1nYnJOh0JDApBP8+lQzAUCyKUfHYpZRR2KqUcAuWCjQadJTB2KmU4A +PUxm0aGYM9UhH1gFjGsjOhQztDoU07gAcklDh2JCGEA+a6xDoUTo0MPnnwHkk9Q6FPqBBp2muwH0 +sDlxHYqqf4didh1APgWvQ1Gr79DrWD4gfLpfh6LADpBPHOxQzC7sUJTFAfJ5ih2KyYwdimo2QD4t +skDnuZMdiho0QD4Ls0M+VLMzURT+JEi1rcuc4A5ZkQ7D5d06Ex8boCjCVyguZYHOPwpAIVaoUNwo +HYpbDqDQdFQoHoMOxQMFUGhfKhQPOUAva0UnUh5UoVi8APJlsEMpo6pQLM0A+SLfoLPcrEKx8QDk +W1iHUpZXodhWAfINukOpXuyQBw0divCjQyny7JBFRJ2J0KpDqYXtkId7HYrAsUFnzXCHPJjtUITF +HUptdYc8VO9QBP0AhQS9QnEQ6ZCfaIAJpX6F4pDVoTiuAWT9DBWJ42OH4iAKUHR9FOh0OO5QHLMB +iu6YCsXRHyBPInQou4gqFIkNgDxF0qFstqqQZ22A8fRPh7InrUKRkgLIk1sdyta9Ap0SbgB56q5D +2eJYoUgnAuSJyQ5lJ2iHPFnaoUi7dig7ZjvkqeAORVK5Q9FX3BlPc3coEuYdyvbrDnkSv0GnckCH +sku9Q16i6FAUOwCyqklnovzSoSjkABSWBxWK4lKHokwFUDhDVMgrZ52JEhxA4Z9RoSgLNuhUYATI +bUYqEyVPgLx42qF0Y6lQFHQB8tJwh9K1pkJRrgbIC98dcm+fikQhHiAv6XcoHZAqFDIDgFyw0KCz +U1SHXETRoZBjdCiEHQC5RKRDITbpUMhWAHIBTIdCStOhEOUA5PKeDoVQqEMhOQLIxQ== + + + Sx0KGRRApqdqzEmY1aGQeAHkYrEOheysQyFgA8ilcB0KUV2HQp4HkAv9OhSSwQ6F+BAglzF2yPWQ +nQlhJUAu0WzQSewJkMtGOxQC1A6FlBUgF8V2KOS1HQqhLkAu+e1QiIc7FDJkgFzQ3KGQRncoRNYA +mVq7M676Bsbl4wU6C9E7FJJ2gFwc36GQ2XcoBPsAmfK/M95B0BlrRADEGxo6FK0RHYomC4C8XaND +0fgBkLeQdCiaURp0amsByBtkOhStNh3ynh1gvPmnQ9FG1KFoSALIW5s6FE1SHYp2K4C8catD0QIG +kDeTdSja0joUDW4A+VTNBuV4zk9hSr3v/GYA/Uhf3qf1d86eOo/uqg3lpvbF/25GeB6ZEZ90OWtL +9nfe73NDPmZxngXvNlGIzIX+MTM8dXeop3IWoAkaZGh3vf2xZnj2b5b9nZ/lm83fv+ze3zmn349O +8Zw/mSOijpOzNW57neJ5YlrduEPRBg6QN5QX6NyaDpA3uQPkFegOReM9QNbBD4xbAXQoTAUA8lJ2 +h8LoACC3TADIzRc6FDYOAHlRvEPuLAGMW1QAZF4XnQnTDIC8vg6QG3l0KCxBAHJzkQ6FTQlAXqkH +yK1TOhQmLAC5nUuDTsYwAHnNHyA3q+lQ2N4A5AY6HQorHoBcPQCQ2wN1KIyGADLHImDc+qhDIUMA +yO2YOuS+TsC4QRRAbjXVodAzAOT2Vx0KIy2A3JILIDf36lBIIwBywzGA3LqsQ2GCBpDbqTXoJLIA +yC3eAHKzuA6F7RxAbmDXoZBrAOSmegCZO19nwuYPIDcMBMh1Hx0KE0OA3A6xQ2GsCJBbNALkEpIO +hW0kQG5A2aGwsgRoNVNMgF7FKB25ukknQG732aEwDgXILUgBcllLg062qAC5wSpAbtXaoTB9BcgF +Mh0KI1qAVrO0BcjNcTsUNrsAudSmQ2H9C5B5CAPjZsQdCltjgFyzA5BbLXcoTJsBcvvnDoWRNEAu +/wHIza07FDbZAJnfdmfCuBsg1xEB5GbiDTrZkgPkBucAuVV6h0KRBJDbt3cojOABckt5gMybvjMh +bQLI7fI7FMb7ALmFP0A+DKBDIZICyOYTdCYGHQDkIxMA8uELHXK1FTA+DgIgHyzRoRhRAZAPu+hQ +6LYA8gEcAPkojwadhoIAZNNFOhMCMIB84AlAPjqlQzGEBSAf5wKQSck6EwNmALJJNZ2JkTcA+fAc +gFyT1qEY6AOQjwbqUAwZAsimFQHj4rYOxQAlgHwUE0A206kzMRwKIJfJdSgGVgHko68A8iFaDTqN +4wLIBHediQFhAPmoMYB8aFmHYvwZQC7dA+hiI9k6FMPdAPIxcR2KgXMAuQgQIB+C16EYpweQD+br +UIz4A+hVTgiIjxzsUAwvBMjHIHYoBioC5MJEgHzIY4diXCRAPngSIB9h2aCTxBEgH6vZoRjQ+WnQ +hG2XdR7E2fwe0nHVt+tQfPACnS9Bh+Jidih+lgrlD9yhuFU6FDddhfL27VA8CBXKR6pD9mh2JB7x +CuVi0aFYdiqUC1iHYinsUCyqFcrluUOx0Fcot4wOxebTodjGKpQbYodia+1QbNIVit2+MxE2FOgc +gHQoQpkORVBUoQyvOhSBWoUi4utMhI4diiC0QhnOdsjj4s5EgF2hDNU7FEF/hfL40KE4iHQojjQV +irNRZ+KQVaE4rXUmjn0digNkhfIo2qE41HYojscVinN2Z+LAXqDz0b9DkUToUKQjKpSJjQ5FiqRC +mWzpUKRtOuT5n8pkIqlDkZLqUCS3KhRZss5Euq1CmbjrUKQAOxTJxAplWrJDkeCsUGRKOxMp1w5F +8rZCmQbuUCSUK5Sp6Q5FkrtDkS4v0Dnx3qFI4XcoigEViqpCZ6I8UaEsdHQoSiYdiuJLhbKM06Eo +CFUoS0sdiiJVh6LcVaEsnHXIK3CdiVJehbIo2KEoL1YoC5UdipJnh6J4WqEsw3YoCroVytJwh6LI +3KEoVxfoXPjuUJTQOxTF+AplWb9DIRCokAsNOhKChQ6F9KFCKaLoUMgxKpTCjg6FRKRDITapUMpW +OhQCmAqllKZDIcrpUMh7KhQ6oc6E4KhDIV2qUIqgOhRyqgqlMKtDd5d4dSjEYgU6y846FAK2CqUU +rkMhqutQyPMqlEK/DoVksEMhPqxQyhg7FILICqW0skMh0uyQqz0rk7LRDoUAtUIpZe2Qa2I7E+La +CqVMt0Mh+O3Q06XDFUoRcodCzlyhFEZ3KCTWHQqxdoHOsu8OhYC8QilF71CI2jsU8vgKpdC+QyHZ +r1CK/zsUbQQdioaECkVnQ2eiRaJD3mtRmWza6FC0f1QoG0k6FC0pHYrmlgplm0yHouGmQtm60yHv +AepMNBNVKNuSOhQNTh2KVqkz9Dg3XXUo2rcqlI1gHfKOss5Ea1qFYhgmQD5Ws0OL26x+GnSu+ZW3 +61B88Ar9WHfeJ3V53hQ0LLP3PI/j6OOPMsVzHo4YP6mTw4/NutTR2GddPk9NnoePgwZcvqm1eJ7P +m/aOn/pec8PpeZzt8E2ff3koGvmUJs/P98Wyx/OzfDHl5O/W43m7al7oH3o8z5Xj5xwlZvOcVX/O +wM/rh78r9kDJfFl8hioTxd7KhPNRZ9xCqTJWn61EGDp1xp2hKhMl1cqEV1Vn3PSqMlEFrUzYcHXG +/bwq44XLjri/WGFORmWViVpjZ9w6rTJuwVaRKA92xj3hKhPmcpWJkl5n3O6uMuGbVxkvw3VkMx+/ +yoQhYGe8claZsCgszMnrsDNe7apMuC9WJmwcO2MFqoqErWRlwp+yM15Uqkw4ZlYmrDc743WgyoQZ +aGfcVbQyUbupTPicdsYNUwtzKrdUJixcO+NesJWJEkllwp22M+ZyW5EoalQmbHc74/69lYlCRGXC +Ubgzbk1cmagddMbNkisTrsuFOaX7O+M+0JUJQ+nKWIa+E25vXZnwya5MJNU7Y8bdFQkD8MpEGrwz +bklemfA274ynrisTbuuVCdv2zni2uTAnI/nKhCN9ZzxBXJnwyK+Me+13xFO6lQnz/8rEFIHOeBq2 +MjHXoDM+IKEykTqtTIxs6IzPfqhMZDsLc5pG0Rkfa1GZSFBWJgZtdMYndlQmcoqVeR0g0gEfQ1KZ +yAJ2xgejVCYmrFQmEned8ZkvlYnhMZWJZFtnfJzNmXmc5uJUJvJjnfFJPZXxiT8ViWzVJzFzzJ+o +bPbV+aLzfet7VSY/c4fiy1cor+IZKj9Hh+J3rVDeIBXKO61DcctWKO/9CuVD1KF4GiuUj3WHXheH +SuQSU6FcqzoUi16FcvWsUC7DHYr1vEDnjaFCucN0KLaqCuWeV6HcPDsUu3CFcjvvUMQFFcoAo0IZ +qXTII57KZORUoQzBOhSxXIUyKCzQObrsUISpFcp4t0IZOHcoIvAKZSjfoTgTVCgPFxWKQ0pn4rBT +oTw1VSiPXx2yU1xF8jBYoTxVdiiOpwU6n3MrlAfmDsXJu0J5hO9Q5AIqlEmFCmV2okOR5qhQ5ksq +FHmXzkT+pkKZCKpQZpQ6FKmpCmWOq0DnZFmHIutWoUzfVSjzgB2KhGKFMjPZoUhxVihzpRXKpGuH +IntboUwDVyjSyZ2JtHSFMr9doUyUdygy7gU6p+4rlDWADkUxoUJZleiQVzcqk1WSCmW5pUNRt6lQ +FoAqlJWkDkVJqkJR2qpMlsg6FLW2CmXRrkDn6l+HvIpYmaxGdijKmhXK+miFstDaoajYVihLvxXK +GnKHohhdIa9pVyRL4x2KGnuFslhfoaz6dyjkAwU66xA65NOFOhTThToU04UA8ulCHYrpQh2K6UIA ++XShDsV0oQ7FdCGAfLpQh2K6UIdiuhBAPl2oQzFdCCCbLtSY03ShDsV0IYB8ulCHYrpQh2K6EEA+ +XahDMV2oQzFdCCCfLtShmC7UoZguBJBPF+rQ1aYLdSamCwHk04UadJouBJBPF+pQTBfqUEwXAsin +C3Uopgt1KKYLAeTThToU04U6FNOFAPLpQh2K6UIdiulCANl0oc5cbLoQMD5dqEDn6UIdiulCAPl0 +oQ7FdKEOxXQhgGy6UGd8ulBnbLoQID5dqEMxXahDMV0IoMWmC3UopgsB5NOFOhTThRp0mi4EkE8X +6lBMF+qQTxcCxqcLdSimC3UopgsB5NOFOhTThToU04UA8ulCHYrpQgD5dKEOxXShDsWYHoB84E+D +cnLQJzGncl95r8rEh25MfvvG5GWsTPwejckftjJxhzQmb7XG5D1bmbj5G5NPUWPycayMP9YNyeWh +MbnOVCYWrDNzXvkak0toZWItbkwu6pWJ3aExuc00Jveryti214jYPBsSe3BFYi9vTAYFjcnoojIR +pjQm452zOOIcOFXGA7CGRBxXkYgHG5OBZWMyQq1MhLqNyZi5MRl8Vyai+MbkcaAxea6oTBxQGpMn +ncbkkakycfY6M+dDXGXiNNiYOFU2JE+nlYljbmPyvNyYPHhXJk7wjclUQGMyp1CZSE40JrMcjcl0 +SWUi79KYTOCcmVMiqCKRUGpMZqYqEymuxmSurDGZdKtMZO8ak2nAxmQ+sTKRmGxMZjgbk6nSykTO +tTGZvG1MZoEr8/G2tk/rjVzfdtWMJ9ibTW6ewD/GBMz5ExvdeD/C8x+bE3nPFsJt1r1sjtzk8jFP +4kRCF1UQ9XA/fvKbfT8Bc51g8jlbnSrbs2L9eHPkZ/xm2R35Wb7ZQ5583h05f++lO/J6395Un5/T +wyz5Wj6ucw3mBpaS4LqvE5z+3Tt0m08rH8iLlvIT9OUBPeYzztFJcqwrQhoBuqrWe/kIM3vl7arn +Xk81QNv2vMnGaDvUHASpGK5C0E396ACt6nSeWGc9akUATZh0nV9PVdydoatGlc7e+bHPJH3C7PRy +euFrOSesy2WV56AOIwRdH6pfPrePfSYZs8xzvCuAQGgCi8cmB4CrtiuCZknX0e/Br7Sqtn6VG9eE +oA+E5PB5k1PCsrV77jtouc2Ko0onfqZVtfXLRcLEoyJO0EU71vx8K91OMhx8SgF4Wz72QqscF+Yd +t8Myl6Dr5f6uo7vy2+kOWXXDfeQjaXryPFH3x8deaNFiIHeSI4gA6LYuUg5c9o+90lV9/teHLJ0/ +At0mMJYk87bzZZoIVHvlejnshyt0f9NRcU7JElDQsyJ30uushssVH8z7/NncSw95xO0fgWS6MWuq +tM4IKYja1oc2XXrm7m8yQXko6FgvdAvcVVq/ylxq/9grSXJ7k1b2udL9rfnHs+0uipTokbursi7r +ldmQVr4Csm55yGDq+uDLfXvIdUbi9Dv9ugPNEXUOlrOqfuSV5s3ui4y47he+4PNxdCicFeMjryRh +rpJJ9/uVoGVWHS2DygkudJ0WRVUXXYSFP9Myq87cAlKNH4cEgHZtT4qKHhv9dDL93mUhN2eSj7zS +LFyzV8v9b6UrviiEvRxS2cvjI5DEJQPsH/tMd+mcn0o+feSVlofCXGVprnSLDzRX4A== + + + Mb+xVl+EbhJBynLyY690nbPJ3AOS7tG6I6t9iUd0Rr7yb3dRiDL33CysdBfcFN2uE4Mvjx0XlYGW +WTHlCbPS555AXieCiVCUTmBIDj5Syz5xi77p1Hnd5jiwfewjbXofqWWfT/rpBpoTzFMepjf+SHJ/ +vD5miT7yWQBJ5C5/odsNr/dNJ/yr7u5ZyfjtjlOlzucfe6Xbkde4zIZ/p2flpuTF7GLPi845CM1p +edcePo8V3wNS3080s21H9p6gRd40d/mRAzNn+O0pHftNPQYMTQS/SSz7xJj3+vaYRen2OISuyOz7 +doxR2B94C1yVAZN3ozImdL2vs+zs67saHnfo69t6dGgo48sfSQb7c25+LstKl/s6q878rvP9thW3 +6KuyjddN1YcFb4GBbvIkmi143flHmcVkwp3t+njgFn1VIlVljuf9Y5/pqnyksrEfe6XLpnkLeoD5 +Clwmjp1fbe5LvAUubyoa3PfH7XI43QI0V1u9TJcJjukKDHS97IsOm/iRLrPoTMC/yveMLvdljqhX +uUjO74fR3kDzL0qS688RkpR203ntjk/TZRad2TCvs2vuuEEPdJO3oSKwB92WFxU95PJ73/Yr/bqX +WXRWCbO1qPJlmg1nOXI1+4UvwVUnMCllj/4LgrS8yYr+uvHb6bwjk6sdP9PyfHtOpKq02BVfSdDl +Ka3w7Iu01S/ya9Oiez0ePYTm7l+fmsuy0FYvSLMPjoYX2uoH2rRcHGaKdBcMpH1nlR/s4alK0G0e +8eeszTVp8c5oB1s0MGa78hXQEUSjW/YH/XSCZlPdNVfoEGcDdNNhbp6Y2Xs+Ah0OiZoHQwH9QNdl +U3eBNMx8BWa7uMtm/PmxzzSHJ/V6yBOZLvjjTY6y2nfWFS/4/NnckVfdKDe8CebPJvp6XOTeeKMr +/nibBUxNssqTIDPh53Wbh2n52Efa5Ms5F0mDThCanUIq78u7ITBA97m9bxPN414g5vY46tCPj73Q +LLpX7a23w1MWoPktHrpE+8de6bbMAXK5K+jnV7rucpO8Pe+H9y5Bl23W8Mtsdx95JVWpNHNiueMv +t8+6s6sfQGUqunllnDx3k5o3P/ZKD5mzPlSZXWGlH2g/6hqq89JmL2iWeZ0y7hveBPusO+qjlKfc +g674/raqRUUG8Vda6QVN8HG9z/H3Qcm7ge7bnOc0AOBoLwFoeeoemE14od1e0KJawRwyPvZKShbr +Rrl97JVus9dfL8op8hWYSEWnbdUq6TnY3xTGzbl3u3/khWaVuOqpnPuFIHnf65edvWClJOBAcx3n +jTRwgL7/MLMs3daLav10g2tEwH2X2f4EjvTDbW/bBEwyfH5eKGwQdJMCZlOdi9am7W3+bW65uxrk ++DPdn/s8wbPI3ygKF6Sa1ET0mpWA0ASWd+V/1EHFkNquH+rPpozbQHOvrUoQbNtHrtP888Rpd40g +osd3ICUZNgmlnnwTXI4xAzeNM6LrtL49VfBfVXDFVxrouu+qfO1P3O3Xt8e6LO+9q5TgWjToZW6D +OWhsTwqNBWm01vX4X36lbf7rCdXvy4K7vebhyOj3qg45vgSrvLqPDtCdrvg6684s8oclLu72snVV +qXPCtGWnx26ddedIuirlwq+kKrjq93NkodtX05Wem6Y+YUy0zrKzzs0kNdmN3+yiqSyzOM0KRjev +ZlCpUCZbd3yl+9tTn+Y4jOAr3d9kMa+3uuEmpkldi7zjJ+KhvOtAGnDzeOox5xdSpDO7xaqw9xOh +m/q3LpJEzNlbftvl3YDxj03Q6/cHxi9khfInIch+XID8NgHo9XYjxG5bgPwBAMgfJYLsoQTIH2+C +bKEAyJccgHzxIsiWQYB8QQXIl2aCbJGvUG4XAPnGQ5BtYQD5ZgiQb6sE2QYNkG/1BFnQAJCHHwB5 +IEOQhUQAeXAFkIdpBL3Ge8B44FihDEEJeo1lgfGgGCCLromxMB0gD/gJsqMDQH4IAciPMwTZwQgg +P2IB5Ic1guzYB5AfIAHyoyhBdqitUB6PAfKDNkF2ZAfID/8EWRoBIE9IAOSpDYJecyTAeLIFIE/b +EGQJIIAskwSMp6QIsuQWQJ4mq1Am3Aiy1B1AngQEyNOJBFliEiBPcRJkyVKAPO0KkOVvibFEMECe +UgbIk9MEWZobIE+YA+Spd4Isid+gUzkAIC8sEGQlCoC82EGQlU0A8gIMQF7KIciKQgB5eQkgL1QR +ZCUvgKx2BozV4IixYh5AXhasUBYYCXqtVALjJU+CrHgKkJdhAfKCLkFWGgbIi8wAebmaoNe6NzBe +QAfIS/EEWVEfIFMHAOMyA4JMsFChUD4QYxIKgFyMAZDLOggygQhALjUByEUrBJn8BSAX0gBkihxi +TNoDkIuEAHK5EUEmXALIFFDEmJSqQinKAsjlXQSZUAwgl5wB5OI1gkwGB5AL6gByaR5BJvIDyOWC +ALnwkCCTMALkYkiAXFZJkAk0K5RST4JMNAqQy08BciErQSaJBcjFtQC5TJegV70vMC4cBkgZ5B8k +yASZmBkgl0UD5AJrgkyqDdCr5JsQk45XKEXoALmcnSATxgPkEnuAXKxPkMn+AbL+AWC8EYEga2kA +yJsjALIuC2KsXQMgb/wgyFpIAPJmlAplWwtB1iADkLfaAORNOwRZ+w9A3kgEkLckEWTNTQB5mxRA +3nBFkLVuAeRNYAS9dpMB421pAHmDG0HP11a5Cu2z7siFeJnfjjJuJ6hqAX+0M++TOjx1epoDz6aO +QbUkf/7pl5uST9maqMPcuTVxQuEfypjHkG/rg5y989TgOU+u2iDnmKRc5yabzZ/8Vgpijv7OOSTq +WigWnxvvR/o7P+v3OrV3fo7vpeHk3t25eXenCsIqFq2XRWY5H/75ciyJ8+5Kns+57e/ea71X1Qtn +STqc2JP58p25PyY2u9wuh3EHMK81447MY6bpx7O4L/gyz23itrkAR5TfkFXZjrsOXtsxAh2Yu2ZD +3NX2Xr75l6Xu3JmrHtx5HCd6w88zJw49S0pC3ZGZFV+nnPsRRnVmFs2bnsRN+QJArHrdGZn3zIl6 +Prg2BmDkPjPRzzzw8GspEpGt/lOu2/h57rd3D/f75Y6X0EvgnVnnZDuR6GETgsycfeZGlNswfi/p +DObwd8xNIGaevvU+J/frQ4dyYKyODsy7PfJyf9IdL5twBZfLhDz8W+zz3KwKMS/8W2jWi06sz/WJ +r+PFeGDmtrgffhAXfJ3nMj/GRAOzIOI1lKHQ83HTkAu4hrOQXuQTobMMLSxZ0Qfmsc4CqWrPDp9H +ZvPzJof1BP0Wm9JROqQuy0q/xUReE59usgS60tKSsgBg5qvPn2nQMX73RcNU7pumLMNzocV9nTvn ++rweI0eAmV/0epUupi3yXxZtATDzXOmwPw8Pfvf1MgudUiz0mCpQnJBr3e4qvyKjIPguzzL85i5P +AEYTaTRVaadFXiMdNPdgU7YDFudh7prfdL1sT/4ldtkxSC9wp0U+NQ7ArPs2n0X23PiZ53Rze8xm ++27D1pnnrDvKB943/CWec75f5Jh0u8PHSaEEMHNGfm7z9Rf6KTQX5KmyyTL/Fz7yrjTfRQbvN3q2 +dtWpVKWYO4OuYKgtALnPh31IK3PFTzxXWNPKH7rjiVkmiJgTz+N9YgYw6zE1ZSItWlZSstGZ+7JP +QKJ3o2VFg2XW2ZHnIb7TEr8r3Ti71kQtT9puhzlOoHfV8vDzuO6jM5t+zUVWY7SsaPaO5lg9FZDh +6+wTiOn5WnfabndV3ZRmlfSHX8fEI52RAHKOBJq2ga8zAfWcjTTC54m/+zzlE83OpruueDtPZKRY +7K7JOsiYAqUxD8kotQdqUYDX0QSnVev39bnTbzHM3Babis7LDa6PzC1vengkakPEVCydkRRT4430 +dCBznxDiKbuxBXb2YSbMv0yIJDc6Yha5TW237bLRbptSmM5I0TkH4XkSKfIZZrYtSVh0FZF5zOo0 +V+jIp3RkVV5mIllFWciYngYYRYSzKMz+hh9HGd759hPX8U+hmVbKgmhpIWZW08dNvl1XWuNDlAPI +QxMVrlJbIDP3xZyeddPjN1dZQhWqiQ/wRp1V57ktw9EJJnU9wMjH9bLNiYB+iOfbHI6lSpsPTMvK +U0npu6L9y5WW+KcqqxOIXJ6K1YhxcRAwmmS2aF2Fi6xhhHN2Uxxyp812GI0Nuyj1Rwcq+ZC+Dyl7 +HuMKO+MCI2AmHr4o5bfhx5n4fZZTaXBosx3mPiHWLLvz9OBHvj+kSJ4Tyo0W+BApAbJdD8NhbV3E +bMe0pfsszLSoDDNn7blVZ1XhX0KP1KLhKBda31PpBMwqVcoEEEeNBRiFehOHzCfCG+yhjOF+15ET +f9GHvFzn8bo9+KdwuRQwkkCp0+DwlgXmsc3PMR95hQVegqq5LR5SQV0gdhQzP8ZVg6022GtPmitg +5l4/nsFjlBww8mNeNJwT32qipmWR9OUBoaMYad0vxzgu/Oqu2+qMDGgnjL1d7/BUiNlvs0lIKdbv +Hmm2rlcNYZuzPRynxKhQoClNV4h6TtqvzkjCrMLykxYNMTq26VUefJm3+bTX/aaELX6eTcNdlbh/ +8k/hArLOzJY+9+gu31h8r3lq5MJ9SHORmdBRqonLR67hxJXzXGnX5t/LdWidUQZiDttPhenITHC1 +K4WwwLFezFMZxes+Pxhcw6uEAKuGw+qpR+ZVzNYRCbLn347sEjJ3TQPUTDH8NBrvpbSJxBLETHhw +DAXd8QqmIA6YObMtKkMtsEuqoKP14rHN1gQBy1H0mchyTopqpyFGOoqrBupd+JdwVR0wz2OO2vwe +sMZLUzeP8Tzvq3JryOgGfGoUIKzx0t0pvTDX73aMuQTGtHnAPJQEnt3gCUG8lHk3BQlqOuPfYo5a +9105wwv/FnOSuuo4MDEUfncT+AGyK86/a/YfMuqxmgVjDjn8U7wHB/Oddv4pnvMkKznwOBSXjQmV +ICB6HFRjvK/wVre3Q/M011l3/Scyx+M2a8RDZuErvBlA9qEbc/ryAPlVBMh/jg7F7wqQ3R/A+H3W +obhhAfI7v0PxCAHkzyJA/lB3KFYHgHyZ6VCsVwD5wgeQr6AdiqUYIF/TOxSbA0C+ywDk21WHYt8D +yPZPYHwf7pDv58B4XNCgU4ABkEcqAHnI06GInQDyIKxDEc0B5GEhQB5fdigCVYA84gXIQ+cORQwO +kAfzHYpTAUB+vADIzykd8vMOMH5u6lAcwADykxxAfiTskB8tgfEjKkB+1u1QHJoB8tN3gc7HeIA8 +HwCQJxY6FBkKgDzV0aHImQDkyReAPIvToUgHAeR5JYA8QdWhyHQBZBmzzkTmDSBP4QHkucAOeU4R +GM9NdiiSnAB5thQgT7t2yNO3wHgauEORTwbIE9MAeYa7QadUOUCecwfIcvediRoAQFZL6EzUJACy +2gYwXiPpUBRbAPKqTYei/AOQ15EA8oJUh7ywBYwXyADySluHomQHkNf+OhRFRIC8Gg== + + + CZCXNTsU9VGArM7amajXAuSFX4C8gtygUykaIK9pA+TF8Q5FlR0gL9d3KOr+ALmAACBXInQoJA0A +uTaiQyGyAMjVGgC57KNDoR8ByIUoHQpFC0AujQHINTYdCrEOQK76AcjUQ50JFRJApmbqTKiiAHJ5 +FUCu02rQSfAFkAnHOhMCNIBcyQaQS+I6FNo6gFykB5Cr/ToUskGAXH/YIdcxAuN6SIBMV9mZ0GcC +5ELPDoViFCCXngJ0NQ1rh0IMC5CragFyeW6HQucLkAuGOxTKY4BcwgyQa6EbpNS3iaoBcnV2h0Lm +DZDrxQFy4XmHQsEOkEvhOxSaeoBcnA+Qq/w7FO0CAHnfAUDewNCh6IQAyFsqOhS9GQB5kwdA3i3S +oWg7AcjaVzoTbTAAeT8NQN6Y06Ho8AHIW4UA8p6jBmXvEjA364HqkPdSAeM9WQB5c1eHoksMoGWi +mG3W+gv+KOlS+mlQEfOc3q0zH21u+6T+SB3YZ8OZ22g2KBldfvb+SM2JnGXjqmrRpjrBHB2P9m9v +7psNO/sIt+gjnH84NUjuN/URqoY2x5W76oPPn/5e3zdIbleduC/K9M0bfsoAzM/3xbJD8rN8MblL +eYfkbVtz/qV1/sqIY2IeDQVVC+jju/mX3kN8gr48NyMTY13NAHl/NEHWaQ2Q92wD5N3fBFkfOUDe +kQ6Q97YTZF3yAHm/PUDeuU/Q7dUDoELH6vLiJgCQ+xIQZA4HALlXAkGvpgvAuHsDQO4DQZA5SgBk +1hTAuMcFQeaWAZD7bgDkDh4EmRcIQO4qUqH0JyHoxecEEPdLIcicVwByDxeA3A2GIPOVAcgdagAy +qxtizDMHIHffAch9fAgyRyCA3FsIIHcpIsj8jiqUzkkEmQcTQO7mBJD7QhFkDlMAuVcVQO56RZD5 +ZwHkTlwAuacXQeYOBpD7jAHkjmUEmfcZQO6iVqH0YyPo1dgNGHeII8i85gBy1zqA3P+OoFcjPWDc +kQ8g9/YjyFwCAXK/QYBu5lxIkHkgAuRuigC5LyNBryrIyqRTJEHmOQmQaReBcRdMgsxPEyBXHAJk +Fp/EmFcoQC4TBMj9SwkyJ1SAXNwHkLuzEmQ+rwCZJo8Yc56tUHrYAuRKOoJebXWBMXteYFz9RpA5 +BgPk3sMAuWaNIPNDBsidlQFyqRlB5vYMkPtGE2QKMYDcy7pBJ1dsgkzXBZA7dQPknt8EmRoLIPch +B8gdzQl61VAB4x7rALlbO0EmfQLIHeQJMi96gFyxBJD74xNkTvsVSp0RQO7+T5DNEQDI9EHA+GQD +gmxGAkCu6gHIxjYQY/MfAHItDkA+k4Igm24BkCtoCLKJGwD57I4KpfCFIJsnApBPJgHI5SoE2bQU +gHzuCkAuMiHIZsEA5FNlAHJpCEE26QYgn5lD0KugAxif4gOQjQMixmQYFcoJRQDZqCNiTDwBkE9f +AsjnOBFkkgeAVpstBZBPqSLIpAoA+eQsgmwGF0AuMADI54IRZBPGAHJZQIXWmHpGkM1PA8iL+QD5 +TDeCbDocQF6CB8gn1hE0f/TD7DuAvHBOkM3jA8gn+wHk5W6CXmYNAnK1mYUAeY2aIJujWKGcyAiQ +lZaJsRmRANmwSWC81PtpkCS9N+liJ8BXJNXerTPxsQGy79+ZuJANOv0kAPmP26G4TTpktxsgftt2 +KB6ADsWjBJA/lB2KxxsgXyg6FEtOh2LxAsiXwQ7FgtqhWJoB8kW+QaftokOx8QDkW1iHYjPsUGyr +APkG3aHY6gHyoKFDEX50KAIZgDwk6lAEVx2KMA0gi/c6E4Fjg04hKEAWy3YmguIOeXQNjIfpHYqA +HyA/OnQoDiEdiuMMQH4w6lAcsToUhzWA/NjXoThAdiiOogD5obZBp+Nxh+KgDZAf2TsUh3+API3Q +oUhIdChSGwBZjqQzkWzpUKRtAPIEUIc8k9SZSEkB5MmtDkWarEGnhBtAnrrrUCQBOxTpRIA8Mdmh +SHEC5MnSDkXatUOevwXGE8EdipRyhyI5DZCnuTsUCfMOReodIE/iF+hcDuhQFBYA8hJFh6LYAZCX +TToUBZgORSkHIC8KdSjKSx2KQhVAXvLqkNfOOuM1OGC8mNehKAs26FRgBMgqlZ2JkidAXjztUJRh +OxQFXYC8NNyhKDJ3KMrVAFnduzNRQO9QlOIB8qJ+h1wd0JmQGQDkgoUGpfIBGJdQdCjEGB0KWQdA +LhDpUEhNOhSiFYBc/tKhENJ0yBU5wLi0p0MhEupQyI0AcuFSh1wBBYxLqRp0EmV1KORdALlQrEMh +OetQiNcAchlch0JQ16GQ5gHkIr8OhVywQyE8BMgljB0KMWSHQlYJkAs0G3SSegLkotEOhfy0QyFk +BcglsR0KcW2HQqYLkOl9OxPC4Q6FBBkgFzN3KGTRHXq4wBogl2p3yCTfgLh0vEEnEXqHQs4OkAvj +OxQS+w6FWB8gl/13yPsHOhONCAB5S0OHojmiQ95lAYy3a3QoGj8A8haSDkUzSoNObS0AeYNMh6LV +pkPRtAOQt/90KBqJOhQtSQB5c1OHok2qQ9FwBZC3bnUomsAAsm6yzkRbWoeiwQ0gmzVZoZxa+WlQ +0wKe3g6gj3fmfVp/p27dWQVk4nhTIeeP0d8560wMb9SP/6NzIh/RBrnu+6m/c45024fBNy1521PF +g9nPfuqbfd/guW863y6yGdh/fALm5/1m2eD5eb6ZwgDr8FSb88dGYG7Kgyyzlc/R9bHP6abNwDxB +X35xbrgm6LW8DIy3gBP02ktemWxKJ8ja2wmyOjVA3nJPkDXvE2Q2AACZnwAxVvIGyC0OCDKzBILM +dgEgN3AgyIrnALmpBEFmT0GQGV0A5JYZBFkZniCz8QDIDUEI2l+tRQBykxKCrKBPkBmnAOQWLASZ +mUuF0haGIJMGEGRWNQC56Q1BZp8DkBvxEGQiA4LMHAggtxkiyAyLCDLrI4BcrkCQ2TEBZL5OxJhB +FEGvTlPAuOyBIDO/AshttAgyQy6CzNoLIBdQEGR2YwSZcRlA5oBGjFmpVSilGASZvRtBZhQHkDnO +EWPWdQCZqIMYM9MjyGz5AHKDP4LMKpAgk4cAdDf7QoLMCBEgt1QkyMwZCTKhCUBuGEmQWU8C5CaW +BJkdJkEmWQHILToJMrNPgNw2lCAzICXIxC8VSlNUgsxelSAzagXIHF+JMRUNQG5CS5DZ2RJkxrgA +ucUuQabHAchtfwkyA2GCXp2IgXFLY4JM2UOQ2SwD5IbNBJn1M0BuIk3Qq0aIGLO1Bsj8sYkxo22A +zLGbGNMaEWQm4hVKO3KCzNicILNIB8hVSwS9urYD4/bvBJmRPEFmSQ+Qy58IenXJB8bt9gky436C +bAQAQKajIsaGEgDk4w0IskEJBO2vIxcAckUWQTYGgiAbKAGQj6YgyIZcAOTaLoJs8AZBNsKjQadh +IATZWBGAXCVGkI06Ieh1ZgowPnyFIBvjQpDJzQDy0TIEvc6oAcaH3RBkY3MIMt0aQD7KhyAbCgSQ +jxciyAYVEWQKOIB8eBJBNoaJIBvoBJCPhiLI1HQA+bgqgmzwFUE2QqtCOYyLoFddHjA+Hoyg1zlj +xNjAMoBuNvqMIBP4EWTj2ADywW4E2Yg4gHzYHEEmFSTIBuAB5KP0CLKhfABtNt6PIFMdEmQjBwHy +4YUE2RhEgFTa/GGgIkGv+kVibMQjQD4skiAbO0mQDbCsUCghibGRmgD5cM5Pgtb1TefbOQGtd63r +9e0Iev3clckLQJBdSoLsRwHIf16CXu8TYuyGA8hvXYLsIQDIHyeC7MEkyB5xgHyxIMiWHYB8ASPI +lkKCbFEFyJdngmyhB8i3DIJs8yHItjGAfEMk6HVnJca2aIBsryfGgoYKZfhBkAUyBFlIBJAHVwRZ +mAaQB3wEWehIkAWhAHk4S5AFxgRZiA2QB+sEWdgPkB8gCLKjCEF2qAHITkfE2DELID+wEWRHP4Ls +EAmQnUaJsWMtQXZABsiP2gTZob1Bp+M/QZZIIMhSEgB5coMgS5MA5AkXgix1Q5AlgQDydBJBlpgi +yFJcAHmyjKDXrBswnr4jyBKBBFlKESDLTRJjSU6APF1KkCVeCbIULkCWCybGksoAeXqaIEt0E2Qp +8wpl8p0gS+MT9FoPAMYLCwS9ViiA8VIHQa81E2Ks+AKQl3EIsoIQQF5aIsiKVARZuQsgq5sRYwU4 +gqyUB5AXBQmy8iJAXqgkyEqeBFnxFCAvwxL0Ws8FxgvDBFmJmSArVlcoy94EWQGdICvFA+RFfYJM +HgCQCw0IMskCQSZ+AMhlFASZIAMgl3YQZCIRgkxuApALVwgyCQxALqYhyGQ5BJnAByCXChFkoiOC +XtVLwLgMiqBXPRUwLswiyCReBJlYrEIpOyNoedGvAeNCOIJMUkeQifMAcpkfQSYYJMikhwC5iJEg +k0MCZLpKYkygSdCr0hMYl4wSZOJTgFzGSpAJYgkyaS1ALtIlyOS+BJlwGCCXIBNkYmaAXBZNkAms +CTKpdoXWEH0TZPJxgFyITpBJ2gkycTxALrMnyAT7ALn0nyBrIiDI2hEA8sYGgu6vLRIEWbMFQN62 +QZA1gADkrSQEra9NKQRZewtA3ihD0GvHDTDeukOQNQERZO1EAHljEkHW4kSQNUtVKLquiLm9tm8B +ZH1gxFhDGUHWmgaQN7kRZDM1AXIz1k+Cqgoo346gj3fnfVqT5zLx9eV+eSphrnLAH6PJc75yzJ9U +8PWjsy5PrZBz72WT51MHlcdFbYyyHVFP4xwlfuqbfd/kqQ/9kGPUPp/8U6Z4fsZvlk2en+ebnZs8 +JxL76BjP7fEmF6vHdW4kFQDrGM8T9OW58ZoY6+AGyHvBCbKucoC8Px0g73Qn6PraMw+Qd98D5H38 +BF1fHQEAcm8BgNylgCDzO6jQGs4JALkHA0Hm5gCQ+0IQ9GowAYw7VQDknhcEmXsGQGbDAYz7eRBk +ziAAuccIQO5WQpD5ngDkDioVSi8Wgl48XQBxbxiCzGUGIPerAcidbwgyDx2A3I0HILP1Icb8gQBy +pyGA3LOIIHM/Ash9lAByRyaCzNupQukSRZD5TQHkzlUAuQcWQeamBZD7cgHkDl8EmVcYQO46BpD7 +lxFkTmgAuacaQO7ORpD5vAHkjnEVSu85gl5N7IBxNzyCzFcPIHfoA8i9/gh6NQ0Ext0HAXIfQ4LM +EREg91YEyF0aCTK/R4DcORIg96AkyCScjUlXTILMXxMgF7p2xh0/CTLvUIBCD9whszMlxnxRAbq7 +bLpD7tVKkLm+AhTy8g65Ey1B5mkLkIvwgTGX3QqlXy9A0asA0KuFMDBmRQxMdHQAZO7IALnPMkDR ++QKQeT8D5C7SAEWDEEDmbA2Qe2QT5H1UHXLf7gadHMAJ8n6zDrkrOUDub06Q9+V1yD3XAXL3doKs +fbEz7icPkDvTE+RNnh1yt3yCzHcfoOiF7ZDPAiDIpgpU6NQz3KGHTTogyGYmAOSN1Q== + + + nfEpDgTZPAiAov+8QzaighibdQFQdOl3yOdvEGSTPAAKNwOAbLoIQD6npEIn0weAbHYKQD6FBaAw +xwDIJsMA5DNmAAoTEYBs7g1APkEHoDBbAcim+gDk84EIurx60nTGJxYBZKOPiHHjngblNCaAbKwT +MW5v1CGfNAWQz6wiyG2gOuRztAC620Qugtwsq0M+JYwgmzcGUJiKdehqM9AIsmlqAIX5WoPWmPBG +kM2KAyhM6jrk8+sIskl4AIWZX4d8Oh9BNucPoDA9BMhmDwLkUwwBCnNIgF7mKgLi8xkBCgdNgGxm +ZIVy+iRA7jMKjM3DBMgGawIT9d5PgfblTcebufmkXZjdv7wbMP6xCXr9/sD4haxQ/iQE2Y8LkN8m +AL3eboTYbQuQPwAA+aNEkD2UAPnjTZAtFAD5kgOQL14E2TIIkC+oAPnSTJAt8hXK7QIg33gIsi0M +IN8MAfJtlSDboAHyrZ4gCxoA8vADIA9kCLKQCCAPrgDyMI2g13gPGA8cK5QhKEGvsSwwHhQDZNE1 +MRamA+QBP0F2dADIDyEA+XGGIDsYAeRHLID8sEaQHfsA8gMkQH4UJcgOtRXK4zFAftAmyI7sAPnh +nyBLIwDkCQmAPLVB0GuOBBhPtgDkaRuCLAEEkGWSgPGUFEGW3ALI02QVyoQbQZa6A8iTgAB5OpEg +S0wC5ClOgixZCpCnXQGy/C0xlggGyFPKAHlymiBLcwPkCXOAPPVOkCXxG3QqBwDkhQWCrEQBkBc7 +CLKyCUBegAHISzkEWVEIIC8vAeSFKoKs5AWQ1c6AsRocMVbMA8jLghXKAiNBr5VKYLzkSZAVTwHy +MixAXtAlyErDAHmRGSAvVxP0WvcGxgvoAHkpniAr6gNk6gBgXGZAkAkWKhTKB2JMQgGQizEAclkH +QSYQAcilJgC5aIUgk78A5EIagEyRQ4xJewBykRBALjciyIRLAJkCihiTUlVoCVEWQC7vIsiEYgC5 +5AwgF68RZDI4gFxQB5BL8wgykR9ALhcEyIWHBJmEESAXQwLkskqCTKBZoZR6EmSiUYBcfgqQC1kJ +MkksQC6uBchlugS96n2BceEwQC5BJsjEzAC5LBogF1gTZFJtgF4l34SYdLxCKUIHyOXsBJkwHiCX +2APkYn2CHq+yf4D0R3/oHwDGGxEIspYGgLw5AiDrsiDG2jUA8sYPgqyFBCBvRqlQtrUQZA0yAHmr +DUDetEOQtf8A5I1EAHlLEkHW3ASQt0kB5A1XBFnrFkDeBEbQazcZMN6WBpA3uBFkczUrlBM6Pwmq +WsB8O4I+3pn3aR2ec8ic6FIOhE/Zlf53NMbzeZp1ec8Gz+WqXNvj8pgj58Ta82ztc6f+Y6d4znP3 +9pwYc5mF4/ZJDZ6f74v9/I/yxeTQGUM85wz1sSmeD5U2dS6/XrYj0mxTPE/Ql1+cm64Jeq0uA+Nt +4AS99pNXJhvTCbIWd4KsTA2Qt90TZA38BJkVAEDmKUCMVbwBcpsDgswwgSCzXgDITRwIsto5QG4s +QZBZVBBkZhcAuW0GQVaFJ8isPAByUxCCzF4EIDcqIcjq+QSZeQpAbsNCkBm6VCitYQgyZQBBZlcD +kBvfEGQWOgC5GQ9BpjEgyAyCAHKrIYLMtIggsz8CyNUKBJklE0Dm7USMmUQR9Oo2BYyrHggyAyyA +3EqLIDPlIsjsvQBy/QRBZjlGkJmXAWQuaMSYnVqFUolBkFm8EWRmcQCZ6xwxZl8HkGk6iDFDPYLM +mg8gN/kjyOwCCTJ1CEBuYUiQmSEC5LaKBJlBI0GmMwHITSMJMvtJgNzIkqD7qyUmQaZYAchtOgky +w0+A3DqUIDMhJci0LxVKY1SCzGKVIDNrBchcX4kxEQ1AbkRLkFnaEmTmuAC5zS5BJscByK1/CTIT +YYJe3YiBcVtjgkzYQ5BZLQPkps0Emf0zQG4kTdCrRIgYs7YGyDyyiTGzbYDMtZsYkxoRZEbiFUpL +coLM3Jwgs0kHyEVLBL06twPjFvAEmZk8QWZLD5Crnwh6dcoHxi33CTLzfoJsDABAJqMixgYTAOQj +DgiyYQkE2dgFgFyQRZCNgiDIhkoA5OMpCLJBFwC5tIsgG75BkI3xaNBpIAhBNloEIBeJEWTjTgh6 +nZsCjA9gIchGuRBkajOAfLwMQa9zaoDxgTcE2egcgky2BpCP8yHIBgMB5COGCLJhRQSZAA4gH6BE +kI1iIsiGOgHk46EIMjEdQD6yiiAbfkWQjdGqUA7kIuhVlgfM1UaEEXR/mTVGjA0tA8jHnxFk+j6C +bCQbQD7cjSAbEweQD5wjyJSCBNkQPIB8nB5BNpgPIB/xR5CJDgmysYMA+QBDgmwUIkA+VJGgV/ki +MTbmESAfGEmQjZ4kyIZYViiEkMTYWE2AfEDnp0GzFE/4+1TEpaexvx1A9rkbc7oAAPmlBMh/lA7F +zwuQ3SfA+A3Xobh1AfKHoEPxOAHkDyZA/oh3KBYLgHzZ6VAsYAD5UgiQL6odiuUZIF/oOxRbBkC+ ++QDk21iHYkMEyHZWYHyL7pDv9cB40NCgU/gBkAcyAHlI1KEIrgDyMK1DEfAB5KEjQB6EdijCWYA8 +MAbIQ+wORbAOkIf9HYoDBEB+FAHIDzUd8tMRMH7M6lAc2ADyox9AfojskJ9GgfFjLUB+QO5QHLUB +8kN7gc7Hf4A8kQCQpyQ6FMkNgDxN0qFIuADkqRuAPAnUoUgnAeSJKYA8xdWhSJYBZFm3zkT6DiBP +BALkKcUOeW4SGE9ydijSpQB54hUgT+F2yHPBwHhSuUORngbIE90Aecq8QafkO0CexgfI6gGdicIC +QFah6EyUOgCymgkwXnzpUJRxAPKCUIeitASQF6kA8nJXh7xuBowX4ADyUl6HoigIkJcXOxSFSoC8 +5AmQF087FGVYgKye25koDAPkJWaAvFjdoFPZGyAvoAPkpfgORVEfIJcHdCiEBgC5ZAEgFz90KGQU +ALkgo0Mh7QDIRSIAudykQyFcAcglMB0KMQ1ALssByAU+HQqpEEAuOgLI1EudCRkUQKan6kwIswBy +iRdALhZr0El2BpDp1zoTQjiAXFIHkIvzOhQyP4BcMAiQSw87tLmIESCXQ3bIdZXAuEATIFN6diYk +owC5+LRDIWMFyAWxALm0tkMh0gXI5b4AuXC4QyFBBsjFzB0KWTRALrAGyKXaDTqJvgFy+XiHQogO +kEvaAXJxfIdCZg+QC/Y7FNJ/gLyJACBvR+hQNDYA5C0SAHmzRYeibQMgbwDpULSSAORNKQB5e0uH +olEGIOu46Uy07gDkTUAAeTtRh6IxCSBvcQLIm6UalF1XwHj7Voe8DwwYbygDyFvTOhRNbgDZWE2A +3Iv106CmAjq9HUAf7877pB7P2xwhl0V5rdvcArPw/jF6PFVB8PGTqhb82KxLZXW8F3Ie9mzyPJxB +Zve9zpZ2nWhLRhk//c2+b/K8Xt4es+vdJn5SXvHHmzw/4zfLLs/P883uyjG9dnnedEd9bIrnc3lT +QvS6LbNez51Up3ieoC/PfdfEWAM3QN4KTpA1lQPk7ekAeaM7QdYyD5A33wPkbfwEmSEAQG4tAJCb +FBBkdgcVSuMEgNyCgSAzcwDIbSEIevWXAMaNKgByywuCzDwDIHPhAMbtPAgyYxCA3GIEIDcrIchs +TwByA5UKpRULQS+WLoC4NQxBZjIDkNvVALSZ8Q1BZqEDkJvxAGSuPsSYPRBAbjQEkFsWEWTmRwC5 +jRJAbshEkFk7VShNoggyuymA3LgKILfAIsjMtAByWy6A3OCLILMKA8hNxwBy+zKCzAgNILdUA8jN +2QgymzeA3DCuQmk9R9Crhx0wboZHkNnqAeQGfQC51R9Br56BwLj5IEBuY0iQGSIC5NaKALlJI0Fm +9wiQG0cC5BaUBL1KISuTppgEmb0mQCZgBMYNPwky61CAXHYIkLmZEmO2qAC5VhAgt2olyExfAXKF +H0BuREuQWdoCZMI8Ysxkt0Jp1wuQy+kIenUQBsaciIFxCRxBZo4MkNssA+TCNYLM+hkgN5EGyPVm +BJmxNUBukU2QycQActvuBp0MwAkycRdAbkoOkNubE2SSLIDcch0gN28n6FVIBYzbyQPkxvQEmf4J +IDfLJ8hs9wFy2RJAPgqAIBsqUKEUGwHkgw4Iur6OTADIRELA+BAHgmwcBEAu7QHIJlQQY6MuAHJB +DkA+foMgG+QBkMtoCLLhIgD5mJIKpfqFIBudApAPYQHINSsE2WAYgHzEDECuNCHIxt4A5AN0AHJ9 +CEE21AcgHw9E0KuqAxgfWASQTT4ixrQYFcphTADZVCdiTEEBkA+aAshHVhFkugeAfIwWQD6QiyDT +KwDkQ8IIsnFjALnKACAfgUaQDVMDyLUBFcoBbwTZqDiAvKIPkI+vI8gG4QHkdXiAfDgfQTbmD6C7 +Vc8JuryOHgTIhxgC5DVvgl7GKgLi4xkB8kI1QTYyskI5fBIgqy8TY+MwAbK5msB4vffToNn5Nu2g +94tu+vpmFYkP3Rn78hWJi1iY06/RGf9ZKxP3R2XsNuuE362Vidu+MvH8dMYfxMrEE90ZXxoqE2tM +ZWKx6oyvepWJ5bMysQ53xhf0wpx2hsrEFtMZ36sqE5teZWL37Ixvw5WJ/bwzHhhUJiKMykSo0hmP +eSoTwVNlIgrrjEVzFYmosDCn8LIzFqZWJMLdynjY3BEPvysTcXxn/EBQmThZVCaOKJ3xs05l4tBU +mTh9dcaPcZWJ82Bl4mDZGT+hFuZ01K1MnJk744fvysQpvjOeDqhM5BUqEwmKzliioyKRMKlMZF46 +4ymcyngqqCKRUuqM56YqE0muwpyyZZ3xtFtlIn9XmUgEdsYzipWJ1GRnPMdZmUiWVsaTrh3x5G1l +IgtcmUgnd8bz0pWJBHdlIlPeGU+5n5lz7r4yUQTojFcTKhNlic54faMyUSipTFRcOuOlm8pEDagy +UUzqjFelKuPVrYp4kawjXmyrTFTtCnMq/3XGyogViXJkZ7yuWZkokFYmKq2d8ZJtZaL2W5koInfG +itEViaJ2ZaI63hkvs1fGy/UVibJ/Z1w/UJjUIXTE9QyVCWFEZUJh0RmXalQmNB+VCfFIZ1yFUpmQ +s1TGZTEdcXlNZUKnU5kQ/HTGlUOVcQVSR1zJVJglJVGVCW1VZ1ykVZlQe1UmZGOdcf1ZZULIVplQ +xHXGpXWVCY1eZULs1xlXDVYm5IeVCR1jZ1wQWZiTsrIzLtGsTGg9KxOi0c64+rQyIWOtTOhhO2O6 +2oqEPrcyIfTtjCuGKxPS48qEhrkzLoaujGmqO+HS7MKcNN6VCbF4Z1x1XpmQr1cmdPCdcUF9ZVyY +X5EQ+HfGOwUqEy0HlfHWhY54C0RlopeiM96UUZno7ijMqU2kM95vUploXKlMdMB0xltpKhM9OZWJ +5p7O7NYlVJloN6pM9C11xhugKhOdVJ2xjqyKRGdXZaJFrDM2l7IxOeDyk5gmpTu9GQ== + + + QB9vbPu0BkkVWNY5U9zWy6JT4GdvkNyUJspZkfups6/Misw2wjn/nBokZ+++fZjT8Dze62yvT6UQ +bz/5zb5vkJyrsd3nSZlAef/xBsnP+82yQfLzfLNTg+R81dcxmJcPP/v6i3/2n+b//u0X86XfZsub +M4BiEG2fcynUQv5YZMl3O3olh1FT+XPXmq08RzIi1L59f8wp4Ig6z4Tu3eMBWI7CzTswO9NVi/z+ +4Vdf3JX03GbLe6rqKcemOSbNbXmTH4UOIM8POlzOSVf/PHf7XIgjATwxxEO5OaX5dJZTsWWOMzLp +fe+jVgSvRtL5j0F+9cVcKh2J9l2Bw/FxbzoIrXInu8kNavlwf074Owu5TGMmNrl9uE2MqjrP8zj3 +zwfWd55f9dh5L8+tEL86rpxOBnPxjj7y/ioPZdLltajPW4jH22VfZHQlx43vXkO5qcfcIhNi6X3m +177on2+HBcpVzKac7n3T5Zo7bZZmNbPfVGmZDzOr0CAyebjpMj1mcTqQTU3zOju9GxVeZ0GWj9p6 +XbR8ffjFF58AfXlA8rNURX4Cipt+J2Vjr8usiXKve849PWHSfB2dLBV59Hvq43fmL+aGvn748y/e +f4nbbCz327zW3CYXzQaeaG9+dtV65h5e51PKI/Ymr5U5Zp2ZTdX0+9wQE9BvhyDhppb8uxwu5xbU +47opt7HLd0xWDd+bfqrycNOyvd50c2lxVcLvdpd5gML1o/qpY9ThBzv30ipT2wnbZjG/XDYFXNfH +XLG5Hle5Lcyp/f15mVVjl2/i4RcnZFOA8ZhnXYWD99tLNYRlooXtcMU4oLlGOnRoQz6u4vwSi85p +l8NSriKr6kerThfbvSC6w+a8PAHZ3CkTdynoOEHza85NN8+LfGaOCPqoAE50P8HyUbI9EPlFzN+V +a+Tt/e65ytll1VK266GZwOfttutMoLVXX10blnyAdpl/HHOB56B3uUk/8XwM8uGq7UvGmVqi5JBy +PDTrfT6K0vJ6fPVzz0OkiHrRxvx+9R6yJ7lv23EUPN0Sx+M72/nE8/uqp6oBH7/zfvEpG/KsUHd5 +Jcl5eXvKtPPyQefviZb27wzQF619koOowDJHkLlpLseW/dC3vqkqs3zQtrAeMoSJVVWhe98p/I/O +f015vSPvLi+Xp540RVnKT83J43akA48df1acOV/PzajVV255s5K/aeHatCvJHvG63d7us4+tcx/N +M6Qbcr/KLWguiJzTlRu6LnMn3Z86JzzfbXiOiO0yL7IMojrDbPgTLk0k9ZTv4mwr8/V1hY463mWR +9dAnvdXcqte3y5Gd3w+X8XWbx+p+k7Pe7TqPpTbF/2bf6uef51tdH1qWVLq4Hn4JH+Y+e5s9VJbk +E3Uut5ed/p/91Rf/5G/+9Ge/+/2ff/Or33/z22+/+t0/fPgz/dHrv3/403/929//xde/+u3vfv31 +rz/8D/Nf/7e8s/70L77+6jf/6qvf/+6b/zrv/OFPfvGzX37/nPzb//O3v/u79//qnx6f6198+JOf +/fq3//7rv/nZL59/M9/qL3//D7/5+m9++C7fUfO/XyhI/etf6+G7/VEevnM4rOu9ffiTf/rhr//d +F3DZj0/2/I758udf/JOf/XL9m3/57a+//Oofvv7dP//n7//+86//9ptvjz85vsT1uzfRP89B9cOE +f/P/L7OHzH98+e+/+JN//dV//uZvv9LbfPjlt1/N+/3nr//phy+/VZT3L+HX/+t/9eVf/fLP55d/ ++ct/88Nf1mX+5fWiKzyYXdSfzVr21/9l/uH4jwkj/9MXfzrs9d9+/V9/P699+fCn/+Pvvv76r779 +9W/nbx3/9tXfff3Lb3/99X+df58f+y9//9vf/cP3/3778Kf6ez/79vfffPWbb776+2++/dv503/x +xReXP3znv/6H+Zf/ef7h/5o/+i+z3n74Vx/+9//j8uHX+gh/8cWB/PoPl/27T3T98LP/OP/85/O/ +/8v8y+Xt/sOrHZvU/LKH5+n31tZzLtXB/Lsq3t8V6JDfzF2tcuhDsbwe1Lk7ZtNUiuH+3X74mE1J +6r/lub6HvLKFXVWq3RW2n5CJFubTbXPQnxPGPNTLrUDzdEv+8th0GOmf5oycvtXE1ydoAhzVfye4 +WuXO/OH0YWY7kw5Baevnfrnfzt/pRChUiEtzYs7XNz/JJ/xMv/puZ/2rb7+de+zXH/72+wf8eZ+n +WgXBOWYpejzsSPXE3CVHWuRmrMkaOk0sUj0qupzz+bOccWfbmGju+/+ZV5nzwKy13//PNtH57DDK +HF3vsslS8uPdtHBi/ouSPMfh4nJ/U6HvdgQSiiwnCn+b4G7Wzsf9oVrt7Hj3WRLf9llzJtSc1X79 +IFut2VN2mUtPxHr7pPe6z64xMeGcA2brWZRAmiBUGdIJJuXKOlHMbA96pVWzPhS56SA14aM8eS7S +Sq4ylP2U97rOEeLdAm6+1nI9vqkGGsx7S2Y1J5Off6avpU83EdrsNvNeRyS+S7u4a0GezeTxuuf9 ++IY3//4nX33zZ3/2L3/zm2/+49/Pgvenf/XtN7/67a+//svZamYNOv7LL2cp/Mv/8NV//PrP/ux/ ++urbX//m69/967nN3hfDfLUJjOcrrqqGTyw4t++xqX14fZN5la+/+dv/8Pv3F5iV8Oe//W0Sv/jN +b3/1f/+Xb/7+6z9Av5zb2ZlffvuNVsv/9T999evfffXtdy93qW/4b76ZL/TV72Z9/dvffP0j4GxC +P4r9xW9/f+wUL+BDkfgPj+VS/94v5qH8+nf/2/d/43l5WUEeH/kbf/3+Nz7p4v67b379+//whyAh +fr9/89XsQn/f/1vf3b5Lixzbh21BmSjZ9h+Oo1fdlvfjlBmZkluBIlWyVuQ1V3L/w9n4quPhriTF +KVtyff6QLZloa9/k9GvZkv1943hPl0wcqvk8D0yXzD/epHle9kyX3HVc/S5dsihzoYE5mC6R8uwq +WV2kS9bnmTilS+BVXtIl10ZYuuT6fbpkvvZjjpn7dkqXTMT3Xbpk02QYncs5XXKZ48Sm/8V0iQTM +8jZ7PD6SLnmBMl3yntZ6T5cMMXf8vma6hG6sH7lBIWGyfX9snT1j7iTdOpkwWe9n5jVhsr6f04+E +iXLfT13N1RMm6/eWujqnzD25Snn/0YTJHJ5U631GwmTdv0+YaEe7zlbz2DJh8od8yfJcFtX8tnO+ +5IdkyFUZvPlJtsiX3J6AvORLbgU55Uv2AnG+ZFPEsn4kXXJsjPN/P5ItuWmy1PN5JEM8XXL/Pl0y +W/YcNZVPsWyJloX3bMlx5aScPWdLnuf7wbMll3JX/fh99//hdMk1Ewv3OO0fa7if9q+nxMLjh8TC +ROrrojECni55HIvcS2JhAnkVCD7hvV7yJRM6SyX+h4TJLj3EtSVM/njf6+ef6XtFxuT2h4zJnK5u +Csz//4zJ/+sZE6tJLdp8l9k1Z1lY1Diyz9p+1b5/2xYZGyvUWiTQfXfj1+GsQLP1vWldWfXTH7Ni +dkn4J1CZz3VVT05BZoU9lIdSoU08s2rpO0FPjeyScnMW8okF5ha7Sbo2L3m7qjFCtWvNA/l/2nu3 +HruS7FrvF/A/7Bc9MhH3y6NI+TzR6APbAuyngzZPQ2pA1W109zmG/73HN2PtzNwrIis3WUmKVRUt +SBDZk2uvS8SMeRljzKYt4ZTGgPFQfvMARDUbZtHK7I5RevKySMlrcfJTHrSdUhyYHHZqsLcUUFX5 +XK/tpsvoCEjyzaG1pPgFk2jw6kR7IREsLEyygiJauUknYcHPLoxMY1s3x7hMTptPS6PCKBCjbOqg +4H4j0EHFoclZzw7GCvG9Pj4lDJlEEFf6JgUGSxkmcCSUixdf7V7SA+u7WK8qHf0ihQh6Lx4Ev/Js +rwAIeArCx6P1B4IdxI7CQCYryYSoITL9DWn2NK5CWTRDOyMc/ziwLtwaVAbDbBuPkiZ3sR/Tmigs +JMas8Uxm4t3A2djhRzN8Mlktm8loXn4lG/GLk7jwPheLuID19IwF4vRebYaP9+yYT+bhFPt56IwK +7XpiwIhffPefVkZaQcE4Kzb81IANAQwOTSWS8ORXi3W6rx5sNKZeEiw14rbJZHqVH9/NL2Ey+rQw +Iq5h3lZANFtxxsUwuorFzbmWbpG2brlQF9OC0G1c7ng/dwUpnkIIDSmCemJNeT07J3XDJBby5hcC +tayTijlNnRxu8pHvC7spdaSsDaB1iRGnwSQx9rL2iiyiAulI1SXxZbSZIMF1wj+jRPOM8FfpJ/MM +BOo2pFUxLGrjyicVQrxXmCiX2gnCdRktGR2f6UFLtZB56CL3/FStFMgUy+t/x0iHwDKh5lg8ZSHO +2u/1VB/e6KkUyysEV+pB9MtslNYVx8L+gzjrzgHE9SzzVoKmdAAnRbclj6bcrS08/0/vFHmRTzfY +h35gus8nSAMbxoIPUG396hyaTRaOaTaaHFOjPglbh8yEWunsUBrlBWYyRMrFhHQLx5TJ0hg766Be +QCFaOKakdMSGX+qPIAcXRkkLRqllNZgsnbzpjieLxYNPNpNjL2NSoQ47pU6xL04HfRUFbzXS33Vh +RLLTKdOVvlf49Iwes8mB82lFqZRUjzXmUlqdefiLDlFAsWzvfTo5ycqA/ejCjUfKZXX+KjzwcOnB +IbvS5jN8YTB5vIXR4kQgEiFlqPKitaYRm1DyhrerNJZUk/J0sipVt1lEPCWl9FgUWzGL8o7t8vE4 +zPSeQU7rdJWXL7kvD7MaCBQZCKIN3lteOP15mU5Hx2yyOKfmPbE4p2YjHYrQoPQnZyk3/kXPm/iz +UgZDx5yP1sWjnz/Ix3vez12IQf9AHVG5UgV90sPqMEtEigHsmQlS+NcPs3J2+/6SGdqnXKiiN0Bd +3xvnyBmIt1Euq0xBkS/WPi5GVw1ZoXeDY0b1S4nGOMsCJG0YomzJKq8feMlKLylshjt+iBST8UTa +KFHL2VxpRZbDBvVoP65Osm/0SB/e5pEoTlfKaFWBEFutMkYwU8RDCaL0V86xYDzOBgI8G4F+Wt0/ +LYxqsqlplRIkczsXmZDeIozfaOF/I5+yStHjf/LC5PPiXJ2MegJuDrITUgzct+luZpPFybEwMrK8 +4kzeHgCt+W56VHysTxoIPa6Qttunmkw+v5vfznyd+UNMd/P6t/p8zQimu2pwnuXkO5SUGu2zym+3 +qLUCQrnYBJez0exsGkB+YJclgrmLK5PFu56MKgojiTyjMMcwXOa7qcT+iQ+q49bV1QqaTEa6jY6D +dxSeCfbn60z5wHw3k8kqG5yNzm9nvpvpHd/xrT7f49CRxqH07KkKtLbMTpS3M+CMqZcOZv9rDl3r +7tb7MfuPPzP5qkdF2PJmdA0oeMm7FU/DXys1QdTn1bQxszvAFdRRqzWftesePXp5gMvoeakdFIxu +kC5y6ZQWwj0/VbMzDGVjpLdNx5JjZ0QZtENO1tmnf7un+vBGT6Un0CdsOptdRUHmIg== + + + Z8AATvqLcnHM4Xnu1ecl5OlnoDlkNJBukG86MKEaRy7luDLyBURGYZ5tY7jo5f0Q1Sn2VwQ4MmkP +tDI644wTc5gLjEoFkR4CsIIQIsuqw44mQ5DTHKfB2YjcPj94Q93Kv3sKYxFOnDZppB2XgM4N8Q36 +fjoEowXUika7qSmM9Ts/+cni8zttbsi5ToEXndXFVZStMBGboZxAmePiVqyIS4SuKKywjxePDYmn +GcEACSYk0haPnRO9TOgCxHXQZqZ3rCNcJw68Wwg6sPHmL/X6F7/LacBLVjpci43IDGld0ogUPLjn +YLza16LAGs4hk/5NkFMjhrQavmJtbRLIZ42sjBF4PDXCOcEq4s1Z1yvAl2vaNpz++eo0KD5qzaA0 +18uFuE3BlqOJTmvrjp9SHKjPSfWT8vZo4dIcjYDCM12QRSD4zZ7qw1s9lQF10BFh0Hi0dVRp+Ct7 +Y0b5gi7yVM44L6dAlbgGhSuZFDjJgdCoVILTQXQFwqzZSPEq0lDE1mC29WJt1rjzjI6FqTn6vsqY +uwcJYSouYMvgs3SAbwNvBmpNL8hHAE40QEvSHla0hhoZsze5TCVn7mxHY1fJnRQLjBlKCJ1YX1S7 +yentZDru2tXF2GgwLhKzr9fVjEJTlK8OYxY/qcidCyvhzHRUV7FtNqVBOmy6rNG4JhNlku1BH5iJ +2yCDAQJPRsoku2XOFRZ3tpGQcwDM+De5TaUNMV9jbUfOEIkNFTJeuh49Gz4t6t/h6wuSZcXTZkZc +iH52z4g1wvzUa+0cnfTddAleGEjAZr4geYPgA2yTSe5sHGWOERUCbZR56UwmREoR9QxHm57Ky+o6 +vivX4RMorbE67nw3gNOUB0W0D031YvFUnNIeViLT5tPy7VDlVloLbUtRm199CIWgD2mMCu3IMiw/ +qOchUD+oNgvULz+obs9k1cBGKU5cfVCq3EYvTsVF63dOaxDsgdUvyfCNZDutZboTkNwrwo+81rrY +E5iAwYPp7Yy0Ne0sgxY0gDb67B1a/mKDEmN5OHbNBleuNvroBhNxa3/Z+MvJXdzhdh4zmvmDnG+c +RFX/XJFLsUGR5GtySF15ODJzWnZ1JKrIigE788bgyzbQtiPlY6y7eT3fGowkFSBXiTbesE8myu6o +2vAqDl3I6T4WzuD8PHJOs1s5G316V2jLKmliBY3uss42YCysJe1/qrr6TB26vXyqoVdBlWlPcsBH +11cPPZl8to6UPLuREz0rbnGdzFJR+pEIwGkunm9msWfm577jY9/Hin2gsBOglqHZ90J0Q6tGLyZW +6omvN2zSOQ4w50Wgx+1SltFjylNR0vEwyCIRfSucVz0iIwPxkZeHRJSnHxANFvAY3bA3QVux8dEG +ATvOYOaEvMzrP4UooDwMyF+rCFp0g0gNKi1UJNsiuvlmT/XhrZ6qoVBB0IQOivZ2QzksgD90QB/9 +KSWqehjFzzkzTbSsEvifFkY0nHlNiE56w1WhuSM33UFQeryhaVxwB3i55FabZzL5TMVa6xZurLYP +4cpkg/JKsmRUNxCtwXC+mdlk1RGZjdA00+FSyOkQ6sGE/iTkTjmkMXTYadloTwTUm72ZICUnv0Lj +gi4P+EX+mAdXUvsUIT1lPKjtAF5bGX0yo8BHJui19vz4MVMSgapbLkAjO4JYFSGTcL3jXJhJLD/Q +Fxbzg082XmuGP8t5Bh1Y7VJp2KD/JlecK10yHQEPzuB4EaR6WX7Mk8nnIVACota6RiGtrlORaUbn +A5E4I1ee72Y2WdWYZqPzu8FEX5LWu6dPu3jBZqK0vRlilhB28TVtN3jUhZtJ0yy/phnZ9GbO9rZY +OYudd15/d2zOu7JXbkXvRql8UI4dl/5dwQxrVPGeXhB+5BX33s71ftoeqK0ZDDWi+yvv1Jl/zhxj +JFrzpaCTrffvTMTZsMWc3Z13zhOVfnh303U1ZLMOQWWHcnd653IsSunA3b36S9bCUEiBsGIfNUeF +fA/oGcfKZVbO/Vs904e3eab3IDggJzkOYiRJatFGNSKLMt3mnysd/Osj2+5fvyXv7p+/nnX3z1/G +uTuobX94x8EJiVX7CiSCXoP2jaEvybjRA0z2Nw65WoDBHfi1Q4sLAWQwBWhKXDkOf4RK9xD6fbQ7 +MMeOGjhiwjE8sbP0XSOBbDQS3dnoSluL2bHHqiUqCDcFi6ryM4acHKNusw9yuqcIXT2ilnlhYhUA +TgyyTvK7sDDKAJqN1IbnNXDQ+W5mk+mpAKufjQ7qGgu6Znr9090c/LcckHYpLc8PNVkMAPnNu5ls +5hc83codH4q98p9Pmfr9MaaOL3AXY8o/rZb8xYSp9U+8DWHqGUdq+4Tfkk94gVpbs8G/UePtvqaI +rpzORmfBMklc7LClYFQ9OMqJ9GJA7i/6AKbCnGl9dopO8aIM5KGiFKK3RFZ4QS6pOyYDKAY2cLFi +TL2hTNUm0C8ydDwwS52EjckarIWiCCKjsMAzd5OPIlmE2lwpmlFqUGDpEEgLtVFbDnf9FjSIh96R +LArQeECheaVqoPmVeFGYUejRUPVHOBKMKRplNP4QalDiaT28t3quD2/0XCZ6nBUAekJf+ofQElql +ilRbivWHItfuk+JXeVLcUGu37NiWHduyY1t2bMuObdmxLTu2Zcc2ifZtSLT3S3HF+6W4ZoUtC+T+ +sKm6m6q7qbqbqrupupuqu6m6m6q7qbqbqrupupuqu6m6m6q7qbqbqrupupuqu6m6m6q7qbqbqrup +upuqu6m6m6q7qbqbqrupupuqu6m6m6q7qbqbqrupupuqu6m6m6or3/7FtNx8peUGYyA98nL/67// +9S9/+opRmPbvvnoK5iMx9zRv8jUabayBuiP7078wi/JstJhFCaY+wKNi2mF6oro9m0VZH/Li7z+D +UA+6vvINet1j2NjJyNqQAcoEKWyOi1uYTRbzGmejaQDl+WZuR0fGeDzI9NcDKX7zEiab+U3OUydf +/SA/wtTJcufUycg/YqJZaVSjX5o6qV2rF6V9rBy8j/GMDWZBUj6e4r1TJ4n7lMyQ+dIHKjqgiA8S +sBAwn284dTIo+VWGBbFCn3aaOhmOsZO//Ll0e/KUyjKsNqfT/3bsZE4/FDPO//6ocV8ydlJr74sZ +cesrvwUj7n6odvrKqcmrycgnHt4fVly81WzBMxmvLGxuyXjFL01uBls+jij8mcGWhim6HWzpT4Mt ++zNC3hhsmW/5eKmU1+da9tRfnWtZlvMmb/h49Y65lvHVuZbt1bmW5TTX0s7yEx8vnOZaJn/m49XX +51rm88jKOtPxFjYTG88/sfFemmqZXlhVryzOF/h47TRdsOaJj9fCbHMz1dLms/78VMtjbT0bapn7 +mY5XjUh3M9QynOh4sMfOQy3TmY53pdE9TbW8rq5ndLx5ZGU+0/HiCybP6HjzwMqrAMEzOl5eGN3S +8Vp8ouO9MNUynada+vD6WEtTTHiBjneMtSQTf4GO9/JcSz8viNNYy7q2+PmF9xum46Uzca2e2WR+ +YpPFibg2jX+MZzreXeMf17/16ljLuiDkfbvn+oqxlsvfOjHyyh5r+eMx8qzFRXkyayE5JEHwrJHF +B2Dnerj/ZI03QoTO0jAjaGr6imAYtQRk9OkdH1jnp7w/R6IZEdWAZ6mhjDABNQ95N6BT2Q83TqsX +OlZrdh26MGD3dTjnx6voxKPW+xSyAHDzwHwejViQ+nS1RBA2iWZ0LnLgvti/5aRUEOY5ZwICLjKp +8YFuWo6UhcyEzw7xOjUYG/ZT9JayuWPGIpfR1NZZ70iTxy0ngk+9f0Mrm0mrD4F4rl0fXBf2wHDL +493QztM+UdAQ7beILZPBM93T/YD1y9l2UDEjhZ+KaMAxPJrQtdI21HEFjqtTpXCKQrjDWg6TZkPt +2/HkcviUI7T6tS0ejfRpdPrqpNQJqtukx5cfOBhJksPVKCpGCi5cb5quskLaNhZPOboQmcb+8Q4v +VF0dMnD+8dHPJp/f6VPQs5R/y/Wl6+g5FR2ksQSXdwOEKVjjIFzfzvmpPgJAiLQFn70fD+8iOk7n +49F7JfSDBnn9pB51HQUoBAIsQ/gb2mgAaZ9MKInrURUq2P2sTALleBO4Y50CiJiNFF00wmb6KXYd +rTjInOHpuXSoczY8fnU9VUgu3iwwHhTC4PFTH9/hkkMKz1ZPJ1PVMq3XtfwJwE32dMMf3zO4Dp0c +ekHHXq/KeOLN/fRgTkTfuY4FL5PqKKc8vkBMqi7zuCc+vqv69Ug6oAyg0gU1AkMlAPY0n9ulUp+i +gxCvu68T22uXPPqU/8nikWOswE9LLsaDiA8MmXcEnvrQ7aJgTM939Rfj9QSQH+A1xvf8v95pY+uC +6fkiHHRX8HH07lkZWoY16FeejLoibuWCFX0WvhhGWityCNqESQdNGjYoIACv0C92+oj2vgA70Gkz +E11AR4616mO46EMQgZfy9LWqcQGfPI9Ws/yeDuDmn333BvhXPmC4ZlYzWKLI0fx8icUM57mMB+tp +Xqo6KLMnSR27a2Uyr+aFUSLdlTscX+yyuBsgzQmsMg0nfmp+Km0/PU4wTzNWs5YYbbfnvjAamSs+ +XucTa0PpUHi+kRNtIId8ydilhSbazUlhJuGZQ1DmqrSW2OXRZ+inCl1o3NG4n0wLVCfvs+sAVVCY +zaPaRv7EcQKTSw79yYFDeOlKAuK4aUoM54fPtw+v5MwryXl2chkLDGxhPVbqqJ0TL7bHkws8L222 +wyZdDLN8s+J5GejRpH7dyDq5tCif3XDqhCIEI4+HJGsOVCPEATfOdSUdka17vY5euU7bDlPwOPrB +HrZbE71BJZbVPUYZOoEoaHKz9lMweHHNsdqaG/GKcrEMC+warwB/Mhkxf+zSaogQ1CWu5wBT4Dsd +rWivfZjkB6pH7qmoUUZe6tM1oElUhJWcl/Dow+CBRxPPiMejg4eiRVrj8X4+mRH5OZt3XElGiVYA +KypdjeTHtFj7OG8PIBXRXRvLeeAC4tORXA2QZSzCx08KP7A8nbcrE0A11I51jfB409N1IlFNzGks +n+XdKFLUQr16qOtTUYt6clDsgYqiQb0+Olhk2qKPB8Eng8+B58mcH+BO32foE4VizPHlgeFRTs1d +5wM+HsgHASltV3O7WMBCjabdVOxrUYJi8zUWgvHbozwLYL7rQo04Qpgt4fEENEWIpgPocTUbiB0M +4TMjQ305ioPykTQqWQj6ONTw0QSoJnugRQYV9zFORTWAOEf/Ig9yBOcQiLdsnWxMdHg4SHKmVajb +bjgo6r6PQVahZ06T4rp6PnO2P9sWZpQtcrUKl71nsCtaqM92Oxzr7suTiQ6uAqvkydEZP/Z5KPuR +CIF4Mz4dyg2O0PN6oMIIuEaFAuDVi8kVN2PnX0P0ho9o1xVWBjcr0qB/DCM6N0jR9Omp4oNlGI9n +IN5Hn6IA6rkueYO7Px3baTDF9Ocnr8HysWbvOP6TQUFJaJ4SITk66DDPj1szInd8XA== + + + GkB5cYf+mp1AmNItX0OfcTedluHT3VDJ1eJxj+5AjrhB7o9Pb9ly9acYvVriIYde7S+uPiMq7rOS +0fWm5daonz45cDZys4Lr1fFW96rPmEw+m3u69YaL62RER1x9civUycKNB9Pd6KWzsQ/3JD/DQZuu +nvmjue9GJe9xl3KW5aQU/bowPi0SVzKfrG/MW72+H2PpZfeUTer38SJPP7cwcZbUPK3CO3Lke2po +V8HuWWw0KLjJkRWr5CU3+2+MXAwZnCMbETy93E4bEW2Tkq3cmk+H7P8JXl7rpkPjAOro8/pa2rEK +BnQtkIo0GRcXoyf6Vjf24d4bMxIPNd5wPQlW9/WWAuo/j9T4UvH0gdP4Qt30M0pjy6dvqeQtn/4r +7vz/JkRxt3z6b9QnbPn0LZ++5dP3SbHl07d8+pZP3/LpWz59y6f/IHitLZ++5dM3WOsXyqfnr5ZP +/5dBEtuQsA0J25CwDQnbkLANCduQsA0J25CwDQnbkLANCduQsA0J25CwDQn7oSFhy+KU1W++GiKG +Dm57/N9nGLH/TV/1r1+h5mP/7rur+ZyAAai20IBLWeeaafOvEBw0ihAxpcm2BnAodlfYqY1YTPR1 +BeA4mawBHCejFYDj9mYW+I3zMy3xGzpvlYNZCUDRVl/iNzgDlLPor0KJS/zGrcUav3Frs8BvnG/l +js/0Q2r8HMOAnvRp0Gl2DOPzaLVG2m1I/BAPKeVOxejOjxI/KOUqeGhoPpgUTnHNPEJDGvP1nzKF +n86v6CQyNaGSGE7FaA5FBjrpvkrhZ/VTHNQdJQWHfLpJa1PbV7io1F3B/RAoe4un0s1lCsQ6FuV2 +aiLl1PkSU1XU4JCr+5GgG78rfZ/8tCd/zciN+1sK5fvK/JT+1JkPipqZdzaDRtrC6GXUyDOTG52f +R5iAN2XYiLzhGTiS8xNwJDnFfgzOutX5ce0JOVL0r6i1vYgc0Z0VAHsm2fYicoQsVzu9hxeRI2Rl +Jmr8InLkyWJCjrxwlWfIkbiyWCNHdMKAQo8/hxwxYUfUZ19GjjB5hAL/y8iR1plWUNHdfBk58szo +jBwZCJ+BHAkMXnT1DBwJL6yrV9bnC9CRRwxA4NDVjU7IEVOduTW50fkZeIUBHHEIr+d4wo0A/7/i +RpgJ06v38YQbYQE+4UboprGifgY34gLy3bWdcSNPsBHLAZDqm2Aj5QnLweyp4I4gag0buTF5BhsJ +C5Ofg408Gr0MG9FGU2oc88uwkWCpKCndBBvJj7ARR5OzjtE0a9wICsdIVIYTbiS1K26EAoseI0yw +Ee+n9XCS+SlLg59ddL9n0AjDDU6YBz/BK/ITvKLaxgvpLPJT9YluxHCq7/6u33ou8sPyfgYbaQHG +Tvoa2MhXP9eHN3quF0V+KIMEVzdu5D8fN/IYdY2R3fIv9I37ERzRV652IackyrQU0WFlYgNNYFMZ +dwjCJ4TNqGKbHjfYCvkz6tjoI15sPmtl9BkJsLPJQdVU+lFFz4DV6WbqdZsYOOMRwsKEpKkBaHRd +WZIv1iw4GyXyos6VAgdftPs5GzEYBFF0Oi5UYi8IoeugtA6rQ5QxugeEy5USBwapHeDQTMhHxw5I +8mTy+Z0eIsmh64pFp7BLC6OmYw4ACyN7qVAvbmY2mR7q47vZaHo9nxZGvGZtbiW46N4pbaQ9nhmE +qFtM12+l1RXABrRIVceAJxb/EFaX45tnRjwlhlm3MQJWZw85L8cUyra2eBLTYZgWE+MYJMQ/6qga +9zGv2IETioj1g0INF+o8uTPAro5hK8ynBpWQydl1XreFyWJhzEaLhTEbUabVSU0pheCh0sNWXE1b +XqvXFBUVITGlphCZ6ScXC2My+WzjSpmrR9nYjSh+uk6EjMFUaI/I4upmZpPFwpiNFgtjNuI1wxwp +kS4EU2kUzDAGyaM16Uy90jHfh2E+LJhcLnd4jLsCC+Iz0DPMANfKpNJL+9XgPYVNQXmD5it5iXw2 +U35mvxZJvBmxTQoVFCbJkYBD8VbtcqHTvUaeW/EX63TMwnNMbgcFo9gvGnSl2qz1wlBwgsf+kOy4 +1bqm1sWh3wiLaysWJPtwUXSnjUYelxgIH+/5IbAUiihx5GBTOPOjNmeLnbF7cujRzvzv8kwf3uaZ +tEvIrvU3gYlwYfR7tbwK44Br6DeV+JfS/z8c2b4rAzJgOPxgnUhFRfISyi2Y/KbYO3Cil8HZWxhV +cCSsxObJ0usBddE/CoxiV7C8MDEkkBKkxqR2IPgf3zG+ODkEW40+WBZGnxZGbBfPqArtModEe6cn +VRADTswJt/kbLOsu508d8CBnnB79bIIz4TRN+qQ9tVEen67D7HVteDoxpEyLu5lNFo9ujb7kaNh7 +y+VWjz4bTe/ZmvrVaBRuzAOZvtYdX/0uZ8KQHsT0lUOSx7aVM2EkIA1p3TlTmBYTOG43nmLX08ZL +jH9J1htPpdLykjNOD0F7R1lbz1zdWpVJXyUGm5xpksWeMm7MYBDoWA5/Uqn2NnIxepbae5T+lZ3K +02bGXNzzW0g/A35R2sisXwaNKduj2etovetjzA7lGz7Xhzd6rsDBlOkFKoevZBWk5hSxOhcO/m6n +0pl5p4AeEJ0BshL+qzF+WcFztApitiRf5zhgr7gw+rQyCowGgWpZKGCYzfnH7jCZf+qeoxOCKQCW +2K1kuTw6DbmgA9qDGKmLCcs3qyKeThklgRcgpzTXGZrE+SQ/8MC8CqY9MmqLeXLgf7T0qHmCaK1j +8Fah1kb7QwfQsdgV7xLtdTjDSYtCsYjWIgloVPBx128hVf2gQKTGykgdTk/9C65L2UleKE+L/Rs+ +1oc3eqwI4pzSm2I+AgGOp06mBaQlQmK7b60rGIcJFm2GZvID/5Mo9VHcIqbjAGXGRVMAT8ttjOw8 +G31aGOXKsAwrGWYmGIAWnX7uLqPFz90zX0lxM4MxKO5Rj10t+Ajij9KevhKltldjxX5ygxGiFdDn +yEgoo96xh5kHxZzZAtz5mGlVQFEH/UiFeBdcUEBeGcIVGG85VjxTP4rFWoYyyVQk8WXyIEoN7/st +ndQBUL4nrI7MR9PZlhgbY2k+1fc5Xvx2z/XhjZ5LLpRiN01phYiW9ius1MfT8lcs4MJXL3nY8Azs +dD5RsarLJT8ZrZZ8somCZKBWYW3L1XyX0eLn7lny9UGRXqV+rTfbX1/xRHc/v+LL+eC3Csfzr2Wo +nJuvhepB4/zuTmcUuFuCXEoekdqTVgLTlGzBewWJMDRdD4yMQOPBMm1muOIL7/kp8lrCSiWtCjdJ +LsEV8SbcaHsvEqRv91gf3uixAphKJvJl18dy79oyCgMaaN9Wv3q5V5ouSYGJiW60tlzuk9FquTM5 +KDE6lbJ0HXyA2XnfY7T4uXuWe1YiCnS2j0nh38fDrxdGhVMk/9r069TI8ISN9mtCjZ+Eayz4SBMR +uohjYusFigM9WVumRNl3LXg5PAClTdkPCA6rCPQH8O3KiVbh+zd8qg9v9FQBIAsgaLm7SGWVVJUE +VEmCK/cG7/PSstId8HwbOljicrlPRqvlXilKGmGOslKK65V8j9Hi5+5b7sk8nHIk3/2y+PW9AhrI +HKRwDBnTRahlMpsaCYEYUkpHukqzhAERiTli+EG9CwaYZu4g3BvPGF1IC64XG/jwnjn2gHarwcjK +G8Yzrz/Whzd6rEAJz1HA4CPpHxSDcUeQGuXeTDWQFSu1dcouI0yvRfRO6ZWile9G72zLcHo2WgTm +88/dZfSV0buyIKbtJJgtenVvsNiJPG9XhY93ecGisCrB4mIKNFxCnTYPBLzyTQ3w3RHLwIqgzOZN +MonauJ4hKJFuKQAPuSuWkW9w0IDQhanm2eGVQJkAsVSmtf4Nn+rDGz0VlZnG7XXKQH6M+YqAQgq4 +pnBv6L5YgHPovljKcyw9Gy2i8vnn7jL6ytAd+nXpCHNCaLojlnk9dk/nLkDOp89lAKTnn6v0EY0Z +DIVZ5SkZXMX7B5hWQFh0KB7NDZp7HdCxRz70AuniARSATa0v9/2WlUPgKMnjomJmwbvehYIbBcrV +zeWZb/lYH97osYI2LUFDMwYbuBpYQsgm5QEh/+oVv4je58W8CKcXx8AcmC+c9z1GXxm9661S5Wxo +3r1JNPP1rhBAtw5+YDU1MKwtBFD4+uLFN3LIozxDTJjBYHqnr5wNt6KQ1zVaGPdlkLCVodwCsZID +NBKX3GGIVEuAPtQ3dPGvP9eHN3qu6OBZau0DLNNaMPahZyBjo0v8C3z8IoCfF/Miol5sizk2Xyzm +e4y+MoDXiduMKhwVDd1Tn/l2Sz4b8DPSQOstMHotBFJIQmz9TW2Hj4/ZBgzD9kQKGhcGqtPQGS3d +G9TQ0DQVMsWAhMN6wEBvJhv5KrxhVHPHc314o+eKQBhCcgUkZ6zhghRDKPRN9aeQvsTJF2CgBU60 +CSul8KA9BGQmdsBTPxnZWbm0/pvCBlvYfFrYQNCsTmFI4b16q5lqR9LvA7KehwnUVV5ZMYQycgiA +tBQDApFfmHxExIT+EB8n92Cyi2cj5b309GycaEB1bGEz6MextAZFOS9ueLY4P/ZHMvXIwqHKhpb5 +8t0sjCIiPZ2Gl1xdNvUItBGArMPlWZosnvtkApN3foMnoyvJ2wOS6TX11ZUW6+IOk/n93OGZEjuk +JPwOo+6Xh7GPDzVSYVLk35k2/JpnOodp4JGROIEwLKec6oDGIebrEXwYOKVgpVydO5lqv82vT/Ci +gpZM0WY96mgIljR9x2bF14tCM60U7TlkFpB1fP2XcoeNK5+e8ePmO1IfZVolLIWO0eyVvtUzfXiT +Z4qBJVyTli/BqjeV3kqpGgp7+nmP9JVTEPwziqt/jeL6pWMQBsH1rjEIewLCVjvfExB+O9zI35Cu +9Z6A8Bv1CXsCwp6AsCcg7JNiT0DYExD2BIQ9AWFPQNgTEH4tZPY9AWFPQPh9MtnvlyuqXz0B4ZEr +bw2ezZfffPnNl998+c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998 ++c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998+c2X/yH48t9gRLSS +P4vOg/3pkT3/v/6P//jHn3/603//8x+/Ykr00z/+zqOi2wNMg2oooBZeGBV9NppHRYcHcJ50JnPy +qznQIHAyQEojEdjssuWoaBg4nay6HCyok5HWmHxC01kEobAsRkXPFou5yrPRalT07c0sRkWfnmk5 +Kvr0ahajos+vdzEq+tXP9J8wKrqdR0Xne0dFKxCUI4eLY1Di9aho+l9AlscEVhuqrDMi6GRo94+K +VnwDWKby0MlGRecxNDRBB7hrVHS9b1R0JBeWB+0eMP+Lo6J/8VMpcdeiUILprFrV96joH4bk+qWj +ot1z7/HFHNf4A8yKbt9jVrTS01pB29GXeGlWtI9ZOZcOiR7qwmiwAal1ddicL5koQA== + + + ol9HLvH4U+dZ0dVAy0qIZLWaFQ23vcHeyUxSbvWJY/tsVrRX3qj/VsdPZybw7azo6o1im7qrDcap +zg8D3y9GRctjMmW0MpV5PePZwvpEjhcXM54/H3jjXpJCfD1FXl+lkjw4OqQMtV3Oku4V7wPDP6wn +RWt7KNIO4AUg3S4nRet9KTDkb3x9YVI0eepgq5A7vTAp+hWjwbD1GckGjtTinxi2x6ToaAxbBxRH +r7zzr9ajol9Zns85ttGQoM70CdajoqHNGem30R+aR0X74sEm9UI2lOdR0QT2Be0kRRi1PfFrj0nR +FmRxUOlO9KYh54Uneu0xKNo0Pvg94o0E8/WJXnszKFrX5Owi/rjSWc+TokFZw+702apw6zHQZO16 +ZrKTl0ZJQzKljxhXI6AHuVYviaaaZ1UujCyGaglucIX8/USuvZkTXSlm6aAlvX9xTrTBcMhxWn4i +1x5zoiHT6m60AMC2krOc5kTD0R2kdTksvSgI/LdzoinIH9R3rRaa9b3M62VQZ/locAbrPAb61RX3 +u6bW+okZGkcxgsdwcFOC+7k50VT5Y6imvgMH1ejXege6/l0/Nai1jV3IEeAPbm3UbzXdsjsgAN/r +sT68zWNRZS8FDIGSioqf2FOifzRuLZRXfUnnUBBolE3dkUabDFJUHAMvSgsi6+yAHqMz2IEBmY0U +gnS9rIJqQNVixURnUPGQ54Kt2CQHX/TPE3QpWHEycYgYyKtBAUwWVyWt/Gp/EQCBH6SBUKBdogjU ++FxUqfXQgScvg/hj8hKe/yiMyiOCK6RPRCZwcaCLO09RqiPj8fkdDSQKr54PX5yxg7KRDzLIdKSH +5L6L/hNSrK7acyv07igKOTJEFy5VQRNvICIb0duwaBGCkcfHw/2r1YhBIAIiTMdxN7y7phdkEdyn +d/otxxtGSoUi3TDSUWEMVV6sksQH3krR8ab0wt4NgLWg2DB12865UTCgl6lVbwbAizj29Us62ziL +9aW8vgfIIx1lfbw93bBCBxeNeZtgXBpPSU8REvcLlxndjULzRlkNNZHGvwfl0MyRAOHUe4HTpfVk ++h0Q4RQryJ156zaNNeFYNhzPup0ip0B3Lhbq0mNNFHj9Cm1g2elvanrQ+3esc/mnUWpXblw5Y/Wx +Ea36/E7RTUO6ploANG5Zbw/ZKOq+cAZp+xGpU8lRlpwHs0pREucxQO2MCfJWFdEScCG8GzlMrefo +iyx6pSKPH8sgzrsjWMZI8aqu0pGjCkYGm41MMSsrWOM7eOsheJapnrPwKkcU1yCwKazC8SC2MYya +nohauuIKoyY7sOE90JAsqbxgBEu15diADnM45vjATqT1hhrKsWsqpfRMGUIm0I4UXrFQ9d1s71HX +4UGa/m6EcjpCPOTprNDSAjXdNAhVSLPN5O70WoNiZjqlbnwwbWH9l+xraMTGmEWGJ7GMTU4C5rmS +jsL2DEMYTi8VbD+YFF/T+BQK/TknUcghdiKaCmwGJUJxbD3dJq5d8WdE1jTB5mxD1Ij922Hzyjdm +Xq8CPOMR9ocIllrJk/ygvkIH5a+NpkON96mjNWKiFL1SW8zGJdXXrgOO3lB+wRebYFBDYSmZiX5B +h4hWtWJe4yTLSP91pzNoLbT3PT2Q5iFe2pBMMk5yN+0XjlItwmRG3LEepiCGA2dR8ZsObHlOPQbo +pl7MM3RCzzBoy6B5tL0hV1XccdcLpiTfEi7lkY4dE7p5XnGr+T+PVE5Gj60A9fMUXYF+OzdgJkZp +1EFPhBqdYT8abXjtRr2xeqVqJvlC7VYnJzx+KPBDify11+RHmUz/VBdJbGJecSSabvD3jLj0no+n +T0wP1eFbL6P7A6iqaa3bIvfsF4XXLHxFsvyUPBM1xWYgomiHg67DLVJK1bPaTqD97RCXLXY38vus +Dz4nClhmQnSs74n6Xx6bTt9PQbZ2utYpn5PraElEO4cINqD/y7fiBamLWnt9MuJBrSxAgqcjAm/R +aMHL347XSsWSElLBVcI9HrIBkxFbRO7XU6WoKDGZUXbkG7bNrfNm20bRj9Yzrm5tFAgdrDRgTRrU +BRRryCsVMgt714ETnj1N9UTXqYWkGNyAAocUD5pgomTZKtBRPgdafslyWOh8/eiCotdLcqolXylb +ynXSvGSt+iO2AHsQ5ZMVkl3uiFHuzGDQiNLZqPtVwmoxVHXG1E8QHFyUQ1AsHvEq2kodJuEUQul0 +1C+ydAOno63cjCiTsr3s2J6OEjBSSFbYp7Cdda5kAgb5JS2zi16UFWpBS6DdOc40T0fVxCXknpF4 +1Fp84Mzr/KBPCjaCRSRZQbazqsOrv/Re/yeaOkKhbgPFkqwXuUwtJo4eAvHv9Ewf3uaZOOy1pBXV +ewSAaFhoyVW033Sa5PgsteBqOHxPtt05h/ngQHfM59bUrWwYdPhQa9EZb8FDIWEGHwEUHcU06N0B +7EygaZxKHwBh8M86BKjCWt/bIvIKUSEDlTCQUjB5kDrE+j7dc0d34W0goKeko1l7uECUXaxlKjwK +eBSKttyMZ/PKYq7nL6/P2h50GmRidt6whV8PnE5OB408t96/QlfavZQtUe82/IayP2qN2vkK3Mdi +ztT5Ct0U6z8jlvBgeixoMsgz3vFL7xUqOvs0ERkMnA6mDyQ8vhlffl7N3+qhPrzRQynAfyisMmNe +jSNUhyM1X1D3csE3ne2vEn7/2sa1rbdf1L3+b+MKd7awtxj8Fn7eYvC/7u7nb0jid4vB/0Z9whaD +32LwWwx+nxRbDH6LwW8x+C0Gv8Xgtxj8rwaxssXgtxj87xSwYgDh+2HJ/as14YcY/EbHbHTMRsds +dMxGx2x0zEbHbHTMRsdsdMxGx2x0zEbH/KjomG8g82AoEp/taHwOl/n417/85U9gXP78j//vK5Qe +nv/z76z1gPIGg5rQsC3pLCKQ0rWTfWM0az2YdqNOg1LimHV1q9EwqvD6igShFCPjwsQa2You5BeZ +m1baLAhBl5ppMcrZXM5WE51uZraYnokS8tnoRmAhKXuebmah9XB6pqXWw+nVLLQezq93upU7PtN3 +13qIZ6WHSRPhmqM+ChWAcEDqQe9ED4M0AgWHW6mH+Kj0oPSOdoq1EkwTgREXCrIys4Tu+SkCZqvw +K61rRFQMTEOfK0SLceOs9DAJPUzqC8tfIiqU83L0/1Mt8az0UP2j0sMvfapCN05xV7Tku/iT1EMt +P1QHe61H8BttYX+p1IN/7jx+lVIPOk7eWOvhZyQfPNuFCA3YzplTny06LYpvKup3dAzDwsiKPXqJ +SuUr3fQXTBRLJOeRqWwvSj7IWTG/qBLi+KdG+jPJB2qLFZE9yn/lqZN+SD5kSt5MkqPCwtykeJJ8 +oAdIJ10+utFnIXSj8Her+dCsk550YxH8kU14uBVjSO3KqNd/qsJyTqGzxWjWRaR8tbgy4iPLqwCe +KeSc1b3wO5VxVcgzGIf9VvTh0HxQ+CYPR0+1h1vNB5pB1gBHtDCQ6tRJ80HxurW/HXktZUzqYrdy +Dv7aSH/FiEY6DRSdeCFaveCpkX5oPlgrlBWlrKMPrfTFmnl1eT7vpHtll0zuDAxEvSXgez866cg3 +KJgBydbPJH1kHDlHTCeeyQOoCZ9EH7pMwG90r/fOtLh8ln0IB5xP77PRMdCL9c866c91HwoAap0t +FQWJp076je5DoRzMwM3kX9Z9qLpF/VQavYhZ1aFQhGS8Q7Eq8wvKEKwNPdsxVHUl/EAFucOjd2gs +LozoklOpBlOu670k/FBQZyApR33hJPyQmzXSdaIzME+hJOf8WfghWmisf0/5Vt6+nXQffAiHlIp+ +VJsggmW/0X3Qlr8Ksmgtadm2UFOeV8RQHUG7PHW6+muLn195v+FOejr3nCflghd7zhRaFZvW6NOz +nvMhklAeO+moK2rVynGn0XOmCFfQ+2739betla5Dh8l+yeS2rZfurfxP5b4teunf7rk+vNFz0UzX +kUHPk07RVn/4AZvpT/yhKQj7F3PcgKYUDjXHqEbm3NINRspeN9GCKVXrzOKMjoXzeTahkzUqj3Jx +Vr0uWluKkJR8Nuv1zhZKNxkChdBSq8rOrNk1GTFAI2ZveRbTL8+3It+f6eQ54FAFPb3pgSYTPK6j +4QpICjWevjDqOikJtwohRVjey8JkfqbZaHo1083M7/f1r/T5Dvd+lLkWEPZO71LOyPXcy2CLvR8y +rKTujt55Wzwvdd2bu5C/RHv4mV184WIKWFpdXMGy9je6mw93381iAS9u7MmRXaty9l0UxSboaNFE +IGk4apXI83Swij+Be0jUapn166tFvGcjOU3wIbrNRF8v22BY65sm4g0FTAsTW2wWWvvK5IIBNTgZ +dYrANKHBS2BUOjM3Ez1nMppjmrLCYh0whC0hXTqq4bSdeiDur6MEAoyeODpka/stjPTddGxYsz8M +zXmOi0IrgCG5tDmsD0exy5Z+yAp2kZlGX08ZAGEXfd5MP4OcJ6PjfzZYPffZhsahDgO2K0soXmp/ +0HMST3c6EyPtaAyDrvaNw9Vz3HzMs8no+4PlYEZqdH15nQw0l+peNfDk4m5mk8VDzUadyjsDxxsl +U07bxDGHxFkohvix9+uZCE2aCb4B7EKkGscUomCtR30nxv8B7EP3nR7ubMQXz/KGgT5vTUfrRzF3 +pGHtRjqhlQM2VksuGYBBqe6DcXr0hhoTTVh/Ub66MloTveeFyfLRz0bTfqDLSisscnybnO95U92x +OX+Z03RJT58sm5QrKcO10ERXcKHfhIOig2Tek0zJubkN85oKT57swgsXO7zmdAW85pvdzoe7b2f+ +Tqs7O9ymnAG9qW7Da0xjcPryPy2McnzgPJULrkrUUNOvcioBCD1zahDBjxRsFAsFB24pL7782eKz +jRlwCJDTNtS5u7iK8boqsn4BYOriVmaT1WKejCgfIJLIHYLUjxAq0DpPAE6qoVQcQxsYeEIQu9rF +Tqkn+aDWP5nhehcrK3TU/4F35TaANYmpVUD5qbaEAXfRcZuUa/D83lA8mSp19bDauGHdDxG+blDP +jjDcZLJ88LNRpmYjl0KGrP89ADpKcJSodAoQ1ubmEbqJfyvnWX3Ms8lnBiPkqvwdwe1W7WuejQoY +waQlXOygX9zMZLF4psmGV0Pyn5jTqjQfKGSjEBd13ld/vF/9//JUSr+ANC6OTooj0ekBdAhrnazP +VyABqFjrhNOaMrQkerC6G91jdRZa0AV2qLtCV0jhMu8nuiT4UWpkCkEXFovH/gVusiZqpS0a2kX7 +ZriSmqmCaW03m4yZ5pcf4+kDmpfUmfho1l641OEkpwvIFb3ZzXy492bmTbC6r0ecxj3Z2Ov5wutJ +x1fmLnM+9nomdV9G9mped09u+FU55pyqvpbt7mzsB8rGwL96m1UEncMgsgaxR6k4gl2xWVuzUayU +bg30qQPIsE2zEcjZAFxehwvDm9ZG8JlTKSCl6EQsjbwjReEq1MxfuBLHtelP68CGjQ== + + + uTLq2XpPJAYu9zG+cTJqHRZdUmieegC4OBBXOp8A2iuJCfcaLX/ubGQ3nqFqR8f0tbURrwBsOpq0 +HFZLI14m8Qs8C99eMtJn0UJgIIycalobrT7wZHReKksjRQpMFDWl3HJVqIby1wPy05zxmVpu41Ap +dPMvgFJBcoOUcwYqPlt8XLiiyejT0sjx6w3Se3TH5Nvp1xY2TjFShgLbvF/ZrHYSHRAgYzrKCgnn +65vtnj7Dy64vPCQYmvBGMkTucai6hwExh6EwuK3TWq6ntWy+r7tnZvGFix2+b7oCvu/NbufD3bcz +f/DVnS1UoqZJSG8gIHUXJO6ffwkg7p+/DA63daO2RszWjfp1Q6l+Q2ogWzfqN+oTtm7U1o3aulH7 +pNi6UVs3autGbd2orRu1daN+ELTr1o3aulEb6rqEun6xbpSSrK8VjlrTmoac1EbVblTt7uNuVO1G +1W5U7UbVblTtRtVuVO1G1W5U7UbVblTtRtVuVO2Pn41tVO1G1W5U7UbVblTtGVX7uvDktxGnHBjc +PP78CMT9lz/+/d//77/+8W///SuEKR//7XdXpezOlEFbc0cnOzX9MZJzpVYOnNytEY6Hcwod5Z55 +GyVRhCugfA5x6oZYqUwQDO8WUjQ6x9pG5qzCwuSzdajtACF1890vjAhMZEFjeegAz3czm0xPpTRn +MlK6HBDdp4KlvX+ZbobGJhVEJVStrB7pbEDL+PRizibzyz3fxh3f6LtLUqJvfRKlvE8pEpAPbhwg +QDA/giilU2zaFZx2IA5DlbIrOKaxVhNDDxDgfyDddMl0ve8WpVTKbBLNJtdvqpT66GhIBRAikyrl +LEvZ7paldDYVADl5+4pKiRUpgCVQJKi/+fA2j1W6/DUADsWSSIehSkk/H1Fo3X4KPxQ+Lv2eAHL5 +2a78ObzbE0AuPHcfX4yQW7/c76xLGd5al3IWpCwPURugNiYW+GcgKRBiaL8dgpSeGANt9+z8wmhU +dhlPkSklxRdMUH2jdyQ/+Qyg12gwRRPyUzDIqAeK0ASj+RGhJwcGgrhx/CJn7FFn5LdoxRwYvQYu +NoHrU7anXEn+Vvm1Nrh/xOihC8YMHtPXQ4pOTkHHT8QjHBi9AoyvMgshXNDH1FoA0MOAFH9g5wIy +wUy3GMWJKM9DV0i/VmeLIRlIKQKRMpdeuoruW25TrjKEtUHX2k+M1SHKGxC9BOoQMUx/nIZU4QIy ++c2lA6IH6AQZvgIaWYcK40JgDUXQjQdET/fFAAsUBXHrjqEXnkE1/hF9l3n7BdHBj+/uMBqKlMwd +0l26gcS6QvS6byl0w6IkOXY9Q6YE5vJy1by6QJ9AenyKzuQDtPWvYCoGDfRMkAFIz5nyun6tga5f +2GQlUPoKWpLMFsqPGD1STpqX/aI/9wHc70yIOTB6XkccMD2anCxkJspA2tJHk1m/YvRo9AGydDZB +q+UITIexBukZRg/4ow9jyyiCUI5VYTFcFSCD3rkNkUkDZJaZ01GLFnwrpT/h5gqosZ6PfoZ+Um9R +26zWF0zABQJI6cGtrjIUKRntpCVUGam0MApA/bwBlNjB+QrR84bsK8r7zITJTTnYnIQnRUokUQHL +1kOR0g8l0qAjuT9C9LR2KU6XyyGPmduYppQPiF6SA49oax5CnB7MjbKh3g9EZkTZNNREp+KQ89Sf +FJ2kGnTZaUHY7o2JdgqBRV5b/PzC+w1j9M5gtnhCmJnS6i3CzEa+0EVSZEjLCKHxA8vGOLLomAs2 +EHooIQdftBVRWKR78aALawPprAGYdsdPGUSPHrJ2tOvWhtMetcEORe9RP7rA6H2rp/rwRk9l8wS0 +pIMp2qb+CNEDfq19XjdE78eA6D1C5RRrVacLGuC6M2bgfSHB1TdDDNcBD/7JbPRf6tzExbbDyEYL +OlYIbWWtBU/vteL1Gcgmk5DooHfTVy3DhGUsd4izNJOIdG8qnSIzOHuMqoImG0HTrAVLjMS0RD02 +yRVFv2JoVsUiWrU2V5GxhTaLkZmHaVRhFZzz+fXjNgjKjGLFMcszM3jQwPhaH2Tl4LB1jFcd/awQ +LYKMYx361DKButQMlC0TZuVlKuc21PGjxTgFNLXOE2ge1jCDj8BkLx1EfQQVNhEuKi2146UqL9XL +iJ2BA+PoYBxd5YzvkTE572vV6ddgQgWkqG3YF9MiK3dLh7/bKSUH4hL/QUXaIC2JmNaGEHV9ABkp +A1cMpCTfZLfzZZgofA2Fo6xZxzcxfKzb6A4+Fyb6B9reDHtMNpAuhmzQJ+JOa86bkT6zjnBT75YN +UH6FCwqOtS6vt3Njkx4IZRUTJyZgXfBHBABWsVBoaOX5HqLVKJ3NWqJk65jkpshzfMzJhJtpDEdj +4Cax0MoIk6iQVutY14l9mCBMrRBJd4PKukwUEzP1zHg/ZtLAIyiQYj6lffD+YDUGvfJmfSE9tw3M +9B6mibFBMEJ3WmEIS2HY6P8JTouc/t4Fi+IoixdEf8frQ1qbgT5AnYYJSP3stbAAjmECDJq5fIpD +Wjtu59YIwFQFRtJRpc/9uJ2TERMSFfFApyEFsTlxChICj8TcMzs97jICMuWZu2i8v/iCkbJlLSWv +l6JVxccgNrIheQoDLT3z2kgK+5krST3ETAjstClMlnyYMEIpa4U5SBHjuzO30OTDez/mZRb8RwSy +QNku0VY1HIIe4jpSU3l41ZPRAWGuH5wGBiQRs5a8MOGnKs9gMuXNxk6uLhMZSilX6L0hJcwkMVuU +8TLDxJiPWj/K6q9DJfGMnfjTWxslGl6hIbKufOZ4OXJtjXL5MVfSaaXGCI22HSA4OSflBYwNIES3 +cqW+BLMnuZuFxcd3LG99OuWbpoteF0byHziXnsfwB7+4GXaEN3l5BkrFuHyoAtWNbxeN0lIXLweQ +QmVWm7e8YfUZMHHUXZj6E174UpxQSmK0sRjqE5fX0bd0Nt4laKfn1bqh0sasBQZJ8CGW609GERCP +tmxI7fodbtZxoRABTY2JR7GtdsPK5LSr9FOz0bw/GZwbbO4Xk4AssbrLaPYZs9HwPkr6cWpKs4dR +oYqrM1FpT3v0YgWEZDPudbLYUkuJ4UCx+Ksv1DFHyZaZGeyJyGgEaGWR5v1wqTrsErXzgN8t5GhN +2bqyxpDN7+KbGfCpZ0tg9T5hBIlcP8WQ03B18Yq4DWwVDAjDzDOqsIziLIuDguilEXczmKQ4vzxw +IJ3L7bhkhZ/cF0aVmoRSdhudyoit6fRbWJzP0I/vhlGEY+aZRXscxuT+QfkpiabhkrMNoaX4nQbA +TU8MEgzIozfcVGZsaeiUXyDgWWTA0GbwPvrQjELWRwFLp2CfBvMRYYBl6FqomRUPkU9v2FJ3MFtT +pPLpGLORwfWGZoixKeCRiZKQzJBcTwizCJvsKoTxciyNQa+r8EtGWno2uk6btqzCuGxSNIr7qk76 +aDjzczBI4aPy7XROINKwCCo/MhecxpSjYJSp+yyi05TRJ6gw9LRlQG5ZnNtISWA7PRpVmJCKPzng +jnhZ8Z+Cb3qk5ZKYH8J2oHtgjzWi7jSmICl8wySRs3lmGoSQj+idKcL6XIpIuWcSO8ZiNWaxRb7W +ZPQJjD2SPHobjbnQ3Z6MSNVYs/oUaRgx/rLogT01w2FUWF76I/dKl0lnBFMGFXYz6dtMqJTrpAj5 +akIxm1Gw3nwYEyOd5Yw9h2ZAfAC9KTCJGeUgnIrWrlyeXH4giNHqYQQ6I2wSEPQwvhdDpBmcLhfF +V9fXsp/wVKvCWD22zAHp2998ZKq8DnNKlJ0tV8cqpNxlvSD5Iua4B4YCF06dir+ozCZHo4D0JzG8 +AcKzgsR6rdjMJh8B9EOxBWmbxojF+Tr6NHrqwPRh7YSxbYg8GTzaLdYEnWz1JPI1K+JhAkiUKbwp +Wx5VqU8zRDsRsFN/Y+PoC7BUmRhULuZB4JpSPi9xmLCY9Mo41d1j+FCP4kFcmADQjUyWsdmn1bvl +dRK1J20te8MlLu4G0DXeJXfzK2H5VIbMZu5xY77M6uVgof3JyEJlo6UvXjEmcAwZqMn5s/xUelyK +CFASGNWZVtcpymf1X4OW6bjOsXB0ajvHEqzRTLRPI/M8aH8eC5Dp0Sx4P2gKRR+iR8YgApUNx0Ju +AME9VVpvtReqQnpwyrTX3VDGBGEtyXE3iRHlhf5S78euiuwZFnOz94cRsMaS6ZGmY3dCk040ChgD +iolOETuYnTFTbI/3ZpVDuUgziQz1jvj8J19hDGkT/7JPpeyH6DZGGPx16XVeLz58evdfrIw+2kLt +geFFpNGgmw0X7Og16JVDejZSH0TTaNOusi3Gsw3g7E7IGiBWsxY7xVZ9Vbl1GyN5oTicmU9eOU5h +dHemTOt+mFeJ97AAXQcGzH54tiUcoUihVu0NWniBbaDlbImiM1B6h8yg7NRpzWQbdR+gazO6clCx +mdeuEFUBjQ5/ZtVYzsEIeoaAMbgc79O6ghMFGEyxz+QYB41F8Q3j5Ak6B4RbqwOgKTicNAaXM4M7 +kdTzYw2YerJGkW1eu2MaLwFeTzNQa+bjc8Ixr7pbtqnNXBiVrKxjxHst0b9IxEKFaoFNqqdzA367 +25DwRmeo61dB/pPI8Y71CTj5AbiHhYm8WCPJsPNeIZ21dM5Gn2CiKUiTp9YnjublJyNtTMr+hI6N +ps31lgEqM2NOcRoQau3CaKx8ts94cqqGlNk8n7wyIpqR4sqDGDV/fYNGOYmNmeAy4bKRCIU08vod +GAbUCN0iJpyZGexuD+S09j0r7xRJioRTwIUyW1phxjGf2VYGfTdGhenyPHl6sBVZaSsqjBkLLDV2 +sjeqNOPRkedTSK+P7qkFWTTcCMQI1Wq+6CUjPdJYT9mg8rbaOSD1UuFcDeA+khmGDjQVJ9s1wMIo +VnHSXHrXc+lHtCgV6NfV1nt1A3/Udr9udc984gxNgPCIwk0iM0D+yNvoXFhYge6q3oDOkrgwsvFI +2fQ5QKJxHShzzuJ1a/RcRuFSwQdbN1CfIlgkT0k2E9a1I3FFDENnczTm0HsT1MJDEqwhqqS0oypQ +oQ4Hi8cbFYOvTFWCL41FMPIDm6lwcMuC7xloNleWj8UIxB2gY/TdCWtQDHFkfHLtVE5H9HiO+xZG +JKqZYWp6QS2vroTTyNaUpjVlI8cJdZRuBoM1JCyYca1MrlLrHUPJZVzpSqBzgq+X19BG7pQi5Onw +lyQanSi40UdIdjuclqOv2nQGBcOxE2zbe1eaaEJQGaYl6iCJogImVgjTB9PBodgVh6kbgsSnxQnq +RibM+s3Kn5j6a1G6Dvhu65kp2XZA5Qdi7Ug7D5z2eIfMDQbslYnUDXqvVSE3UKE0dcL0Ik/Cmtb3 +pGXdzXHIlzsT0tH+wQEVa5QkQqSczUllphIHviD0n0g2iUwmaZk8jE1NbrAOM3paA8c7myzSwKVR +R3/BMjjdvY2wlXePTGUnLXzflcVA76KAaYWkRWp7NrFfCpRAaSCiJfLCdchiG7Gqsw== + + + 400mjdHKlT5+GSbBPI+ig8yHMBN5OtZ8ou3yEXSFNY/1F2Qa3LLTUslKHAsBWPfH19Ji07mod8Jj +yWcCJ6eJryWmhaDlrnApsSVYCuMEhNHXLe3QmUzvREejvI8dZeacqcTRSE807zNPPhutCiOzUXD8 +lZa2Yj+qaGsjwjaSOd9AJnDTWgboYCguqMXqOXpDpaN9E4v+L7UT/Rl3zmPUhcWoQAF2BjneR7f9 +bGR1Eb0LRAArv10WRqOyZo7nyG+nO16ZnJ7cVs/ZaK4QNy1dY8FAyPVj4LwVRhmgCEnaXzqzur1S +CzorY+isTCybZCakFseqwnmyIENRmJmVJyiGk4foq8vEaBUMNANbHeWw080cBeLAGEkkgZYFuoXR +vDBWRqfX7G0Irk4Y5Q29mrLY+WNZ+VwxhE2n9XX1PT9ahB0i0aKjGbRaYJ+s6UalBu0eEoHVj1Xj +yhPPJXBOq1temEwrY2G0aFVMRtM+HTct14M+IPlyX+x3Ht4kIO3I8GXhNby5VOJq70faOTmf0WBA +ikzxpY65vHJjn4ZRDiQIhRxm4Q7NxDqECcWtuHCqi0bX7JxZP4Rs0JVTsfxkvg5eVf+Tke5qfnFS +LE3OJ85sNJ1ctpqpUHnYw8YePZ9/cE0UKwKtoZ+9OkbHUiVxSzq7EZ1cHsgeL+Zs2ixkz7Q82j3R +c9HZHxCoq20RJAyjitKY96PdM8UaWhXEiom6Z7Ih0xaxhDKgbDC9uAgSo7pF8pRF4MNzUanS2Ya4 +gnWEphDqkxnpgPTg/BSqjkAMfEI2hYo6dqCeHjE8Zc/k7lM4xxts0WrdseRl7DgSc7mOkC3uot68 +iB3xLXxkeczaTIZtClXHiidr9eDOHNGjRbzUAGjpkdpYN0w7r9M+iOScU9zsRylUmzpGSkHL+NtH +j1ChFn2UNzT1iXMcjwBEZ9YuWCqw6XM2cEdW8fGe1OOTgVhGUWJR+ItA0El7E/q24PvKg+HcG5V2 +K7SdTDDQS9LST7bHKkcjnXcYm+RFZAUFkGizTugInhn3nKkxa0NbdNiVLeu9d/AUhcJWJnYwhMPA +s5IzOvkXCrsUfAwlmYEdFP0dL1dpKFq6hcoq1DDWmpk4xnp3CopUq1F9lc+skXY2joz6cdACVjCj +12/4R3IvuaQMkDXbgs3jjNXujWgpGKM3UIehgoartBXEeHQ07eBwxfl8nyzG+Q4DEW0BYH+ry7CA +aOUl1BEIVqebAadgLkIJKWTn5UOxWuWQQpUXpQexeDcGZ2B0d2FaOH2Y6Q0bAotUkNHpIay+1LFR +qd6Qq1+1cW6/+SczQlKwEqZbm31aO2ZCOumQXiB1Py+/RUX0ZDFKr9qioeHRbQeurqLXC2EuuQHd +wYJqFgLC9GAxQSkVnqzC1FHqzJyzlMQqzYmjviRrCq/d2uN4PteMV15AIF2gSuJ4AiyeYnIrsCgQ +K6Cv5YjW5tL12eTjO2oq+gB0nDLLeWFE6SjiA60RGcPibrQ5qfZSuHZAbpZPRe1fzlJvTt8u9rR4 +O2jkITiCk/DLz/C6s/l4h0PCfS1KMToz4Vkm6tWAsX561wGwQDqxfkRaGRFQWVgGyNoImJ0iWaBw +an3ZQH2JVi8iwrGPBqdRo5tBYsvwuhWFB5JsbcBs0qkyoklrO6TTna+UT2jeRDkUmxlvHQwgZ7Eg +A54voxRInOvDABLBsI4A/Yzoa50RYO8R5AJC1tR/iWjoMco/AM0imKOvwMuCY++bQajQBvfs80Lg +YYoYSKyAq6rJwDuNTU3525lYib8sypdnE462qRB6NkLfRLEtIDWFYUzbWBhRc+104AugAlOK55ZD +o5SnTwi0SSYETQosemyHBMrto4+6NpgOD3OspdVL/GRGOqHlLCh6xLb4FtwyXYxEtzmX8dnh3ikj +bCihFqsB06wwIGEOfbkyqNcjrwxP2/ujXCEL7RRPcdYj1KcnbXJuCA5baWlap3es94/3bIpP92Gm +PQIs1qCzltHAbUKZo7+bM8s5rCQS8N10yw2Iq5SqmciKPqirhsHTp0gE4oD4UrDmRQU0SBGV8EiB +NAUyE/HSjnTmY5FqIcxWnuiNBgGKuStcohOTLTksF74ZYA8tVOrL+Z6feq+rmNAzMwAUMxuKOdsE +A7L6fsyf/16P9eGNHkuRhFX9EJUuSB9U7QhjUbD7CUJuYMxvM+jnNXrxlw75eSIXf+GEnzO1eA/6 +2UM99qCfXyU79Tc0vmEP+vmN+oQ96GcP+tmDfvZJsQf97EE/e9DPHvSzB/3sQT8/iIjAHvSzB/1s +FYGlisAXqEXFXzLh59lMny1WsMUKtljBFivYYgVbrGCLFWyxgi1WsMUKtljBFivYYgVbrGCLFWyx +gi1WsMUKtljBFivYYgVbrGCLFWyxgi1WsMUKtljBFivYYgVbrGCLFWyxgi1WsMUKtljBFivYYgVb +rGCLFWyxgi1WsMUKfo9iBd9iNnq+BDZRjrfqBf/7n/7xjz//5d/+/hWz0a//9DuPRqeOIY/JQU0h +YT0a/Wy0GI0OGgjgDF8gGZdkGo1OR0L5ObNTq1V5FqPRgcxBmWvFSL8LI4C6yioaw0HT+m5mk8Uw +8dloGo1+vpl5NPrpkVaj0U8vZh6Nfn6582j0V7/Rdx+NDor6NBp9miGeL+fB3jycYyJroStv+ck0 +Gj0eo9Hl6oHCVZrciRnitM7ABBPLhbt+S+mTFQQCoVXkvKDP/kDvlL5qxCedZ6NPo9H7XT9FQQ5Q +uDLmSEPpxdHov/yxuD0F1+SiAPLSaTZ69j8UpXjPRv9ZTrF75j++fDZ6+BFmo6dvPxv9JdbozWz0 +54Tm1XjqE6H5pSHXS0bz88noN5TmR0Lz01z054RmC7HmsegvMpqfj0V/gdF8MxZ9zWi+mVf+nNGc +83os+g2juayvsmA031jcMJr9ei76c0Zzrqu56DeM5ryci/4CWfl2LvqrRmdG82CeT3PRbxjN4YVV +9criXHOa63ou+prT/MzmOacZ0sViMPoNpzkanGYejH7DaS7GGTgPRr/lNMf+xGl+Gox+Q2m+8ozP +g9FfojQ/m3p+Q2l+yWRNab4ZjH5DaV4NWL+lNBsLex6M/gKl+XYw+nNKc22rweg3lOa0Goy+pDSf +BqMvKc03Y89XlOaTwc8vvN81pdlPjNw4kX/LI/n3OkO83VKalT1HXfoZ+TfJVfe7fusZp1kPQ0nn +SmoOvNMyMtrv9lwf3ui5Tqzmsmej/3is5udx1yAem7Og4c4JYs1078lJwFDC4CtWeYYqrGWnBRqT +H2yykxEVYxwjx3m2jKgrcQHDrxzHNWgWs0njM1Qa1xRkO352Nir42R6hNHjD0s53Y/0l2hzR9WQ8 +zempJpOPi0fPphRFHxNWoYEfegRM5/kUCTzqwoi8uDqQUDqUrSkG54kyPB1dOBALk8Wjz0YgP7VJ +k6XoqV7mm7FnUD5hHDQAE4vveTbRIRO8Ha7UemFVrK4Tic2Uyup4CiaUcr6Z2WJ6JsrXxcigAIsM +3DbZfJptppVDug24g/5RjRapn9ffHev4rlOPxrbiuwYmlGomm87qMYnOKpgUeUc9AhSkVJ1D72VR +PHHWTSpKPhQnNWJs5OVAbkCnoLsEhQCVUUOOGFqWniP0Uflr0DVyW4qgYrPup5c347Ezf+mMqNea +ogMOpajDw2cDllMWuOgdKrBtZDDaJqHc81vvqeg/QJVozlD4BfQCJCAABfzSh8/f76k+vNFTUX3S +NnVE59DNkGODVEuDOYByfXYk/euLOeof3gFm0JbXs4OLMthWMgEBOroeLDlOEracwrZO6tWNR3w2 +MneSKbIboNbO/smoU0c3haACFtGuA56I5FLvGCzzyoQvAWlEiWnvo5l6tglGpXc1wQa1fnXrpAWZ +mgTSIwZnpHmjw4Ww1JcLXasAyFr7Smmv1b6KIc2U/mX62Beg+bUCngHPyOKRn0b2jm6QlktMo8/X +kdLV8Qo3z8q4hAdw/+ETFm6nZthCFVYw6P8ykpQo3+8quNfUL/TTA+0gBfn6/TBMLAPR99FxGUFD +RJBw4AsUP/XxU3p5dMNYBmkw2qiEQtDxnbUsfyG3U+09eCouMOygY4KpV0DQwwEx5HWCFjDSjCxg +eALE12u17N/DdjSgEr3SQu1VUZWDf64Pks0kGO2o49L6oNJGud8KrEr5qKGtlKDQiER6UB+XriMh +GIdeAj5AJkjLheYusCQdacoEFSEGvi0Xd4b57w/oPATbyZESJAKVo2/j0aGyhgtoTP5Av9wPxDY0 +SvB8mVLtwuhgIyOIVQBxHvSBW6ME77oYO7ixUoztQOMZPDt53cJCEQ6inU0HhJKpMlietzYg0wLg +NoXFfnSIJxvKpnrnPER2FPPn2zVwfaH1iUBYbpf5sScTfSmnKDda2taNkDvZ6Etp70FQSjp6dBe4 +08hGC1pNLPWWLyVYVJM46Cgm4XEfoE+gMK0PBksd0iXkV4/TcaaG9MBmVdgNP82ONIUaVHI8UTjU +Ql3H6cdNlRrq5cDNlwcjdwcwnFya+6EVrX+JtkU1vrs5/wIyAMERnouKOMewnLOSAt2PZ41SDEh2 +RjT438pEadi1dKxjq4knJNBMLwDEa6C9nZu+qr2e+T2vjQoqL3pDvteyWBnGB4AH72CUFHMGNKNp +c4B8BASIUdK1E7jlaM1fFmFA+cbB4IKY+gkivxwDRKt08Bg68qTJaF058Gx8Zi/PgJJhNsy7d7zp +0MDPBQB3fAu5QGcuroGGZBMD1iSRauz9AeVvkSpaAVZpRonjryPWmqJt9UwGr3de4CkfAhn5IZLP +67fAIA2+kaeZHyguZHx3VHCVAA/oUiRpcvDAoXD6AD+j6wMojNIUYZsOcoN+U8HKtaJ9QKg0jABM +gTRB/QEjlCCATcAsNV4SUZnCK/kVVCXkZ+msENcVuHHeDpP0gO6NUhQUVeKl68/wi+T3dEpejwrF +Us4EaUo8FDAA1/ENFSekYZNp9qILOzzzbHM6AD8tD22cHzhv1FmNyICRNt2gvlrtzH5METi8/NoG +sjK4B2q7mT9bgcjumlNe/5LGuhmhygEBA4BTHg8fUBAFMQ4SloPTDc1Z1A7yeIO+VM861N+gIaJV +H1Kt+tLVjWen64ZkYqNPZDF1QIe20tNHcCAf3xSRTWclWQODOjCMQNohkVm5j0q1HBIeWs7C0GrI +pwAqBwMVDhkMbWYPIMxEQriSjjyPC5JzrSYLo/VKbxH9s9YOtHWVE1RQT2vLWbHd8Whah0leb+xo +A9EXyGhG3axjBxnqgJPbYNJUuBUlaLHKd40jBW5ohaELFulCrKh/UqhyU1Mbu5moVWvKxJSGLJO1 +4vQvmymSLNyCqVZ56nlkMAdAfGUUTe+3OZNeWZ099nMsnwQmIi29md22xWP6ii7lw3niu7SfSqnp +gPkChYdKli2CxAeD7+W8Qa/YAOkVdBK0NzccedQ/94heMI/gwPjCmNdWNMp1MeZxTg== + + + w52M1NdUQoDm02XEU2WrhXMvDcrsdXmwusmyqTcY9Nbw2XrxqF+060JjqWr30Au7vI8A8iq9ax2/ ++vyW4Q1pDq3EDPf1PUw39PMcQo4j0Wbp66WToieg0GbEKi9UV6M5KnYQCpt+YGYBA7MzIxD+6k1k +yrYhVSc5/AyY+z1VfqIjWLc68bIJ9RTQ8DoC5C3oSQOid7wJ0K/JQKyTY5CRVm5XrJwK4Myl92BD +a2nbXdc+HNUpK8BERy6wTPlKu87kzfgtvHEzKk7j2c11euNSEAIMo0JVF+WwsVdB0+ipgbWyRMN4 +eI8sJ8ra6H6MjjQZiEJz4wLzCpNJXZhOSb7oONBLANvXQI+28SU4dXQ+cXSVASfWQgF5W8nIh1El +V4ss3aFQwQkFWZlyfDXVEZyQP+SCYjGutMXHWjENT2SiwciMsCoTOT/9J4vET3E2dBttTKD/Cejp +ZQrWIUJQKdH+HCUfi/kTETcND5MGzzwFdU1Ux42dZNkDqQU6SYXSYOhG5+JYiRzkPFgAC5zBb6J7 +ilF7MN0GT5JTIbJGU+DTUuVQoLUvE0efq+j166SKF2MVwynS49uvYwLdIUPXItSgICb/VnEkEZUP +GiFmBJqtGzjTWMWBjrIngczHzQRncGfeSLpY9uU5dyH/k4PooQJdryTnD+mTT2q0bEAZldBVSwMs +pOJF63tAPP6EInvupsGkF5rNpiBVotDboNsdCGqhXNIhgACyjNYGRGENMtyAl50y00hsAwWITk4a +DOfJaN5as4nO90xIZirtMlqk2wQFxQ39MrKoRdp+Nvm4iiXORp+sqoYykoNzEQ0UdTaykEkxG6RR +dGQWt7wwuX3wIfFxa8ILRDqJ4o0/XKX+ypvok8KG4ztA25PzTHj9cCHVj/bhtBx7HCYIG3SisQgq +0tvatyoMZZZsS6KDQlK8JycUhzYaPCrUvRQeVVvGtrjguCkAqjkfkNk60tR89DFZpFr8ugg4pzTw +sHLAFNmgdy9WOqeNNgPHaOsmVjOZfLYjCfUBBZge0P3C6D/eoa1ApR/lHpg0yx8LeAe8Iv24Nm65 +gHpMkNQQKU4olDEZyEG+bQtnMcRL0K0wv0wf39wOSiEexEwa34vEHPECRfvFMliO6AzG0aHjEg8t +EJYT+V5iE8MGawj7wJMkkVqYgKEl4iUjV+hnXdPJSC8eiWc5DcDYxa6jzIwmKZxiIwEhjOhwFtSq +LtwvmE5wa8m0q8xr00dNsNWGVgb6mDi37AzXbLFIgFcTUNxRbGphBnUNxLijKfDJKFhIR8vGm6Qu +5BAwGiZrQ6ZDTkf3WB6GEHiYdORt0LShD71K3eeQb5G7Q0FkqhPNBlbmwsiocSFajkfut6g2zCZT +4HhQ7G6MFjnuwuhcRJlvearELKLduexjLxGylcPHGdZ8LvtgpOVtcPTCc1BjqhSZIPmjRT/4hZCJ +fY3jIDFwMFhu/TwR7oWVkexsyhaTWb5ApbnAha/pum9QH4CzHUepzwpnWrJyYQor7GtRsAcpB1Kl +HbqMzi6CxkQf+jhyeABpjOZyreJFw49CqbuMHcqCjM6kXkctMCIcN1jx80YfNUU4gkBl+iH6Qk0j +svNNeUChLZ145GCdQu12GV6nG42yZlOslAlHJ1dK7CtzXpS4s45dSxLNAv0uRiT4q4MDcBEQ3BpQ +llub/3g3nKlerd4dvMHFL5lHptOkMySn43blsqFYUAuKl+HZeW5nmKOjaKu96sh6S7qmo3g6BSjo +uxwpdIfmEMBPDE5zQFCQxUX0Wq9lZDgmCDrJPVz4V4EuQOD4sfomtWjk6iIpgUlsng8+q2mjdeih +kw3C0mw01wYWNqca++I0P1fq72gL3Im0kNtLBhAG6hKXTacAbh79LmoThNevNJ1qOLVnwqU3GmLK ++hCbylfBnGDSQBElnWCgM1hj4BNjSWMRO+oY2QQFlUiOnlOgC6qMKxqt6KJ7hSTuafd3ZHXu+a0c +QdcBpqKW6kfXKTxQowVtBqhg6jp9u8f68EaPBZ2C0CgOIRxQUzDoBqyN+OLnmk6Lv3iL2Yuv0Re+ +dPbiI3nhC0cv7pmLe77anrn460a9/4Ymae2Zi79Rn7BnLu6Zi3vm4j4p9szFPXNxz1zcMxf3zMU9 +c/FXQ1DaMxf3zMXfMzvpC8jo+ZeMXvwfCzqUof03JWpTojYlalOiNiVqU6I2JWpTojYlalOiNiVq +U6I2JWpTojYlalOiNiVqU6I2JWpTojYlalOiNiVqU6I2JWpTojYlalOiNiVqU6I2Jeo7UKJen/Dy +tVNg/um//vHf/vR//O2Pf/6PP/3t3b/9/Y//80+XP/7lL6Bb//T/6L+5/Nvf/vT3f/z1b3+6/P3f +//r/8jf6J1fzf/qn/+UP/+Xd/w8Un1kg + + + diff --git a/package/package.pro b/package/package.pro new file mode 100644 index 0000000..3c320d0 --- /dev/null +++ b/package/package.pro @@ -0,0 +1,19 @@ + +DISTFILES = icon.svg config.xml + +copy_icon.target = $$OUT_PWD/root/icon.svg +copy_icon.depends = $$_PRO_FILE_PWD_/icon.svg +copy_icon.commands = $(COPY_FILE) \"$$replace(copy_icon.depends, /, $$QMAKE_DIR_SEP)\" \"$$replace(copy_icon.target, /, $$QMAKE_DIR_SEP)\" +QMAKE_EXTRA_TARGETS += copy_icon +PRE_TARGETDEPS += $$copy_icon.target + +copy_config.target = $$OUT_PWD/root/config.xml +copy_config.depends = $$_PRO_FILE_PWD_/config.xml +copy_config.commands = $(COPY_FILE) \"$$replace(copy_config.depends, /, $$QMAKE_DIR_SEP)\" \"$$replace(copy_config.target, /, $$QMAKE_DIR_SEP)\" +QMAKE_EXTRA_TARGETS += copy_config +PRE_TARGETDEPS += $$copy_config.target + +wgt.target = package +wgt.commands = wgtpkg-pack -f -o agl-service-radio.wgt root + +QMAKE_EXTRA_TARGETS += wgt diff --git a/radio-binding.c b/radio-binding.c deleted file mode 100644 index 12ed966..0000000 --- a/radio-binding.c +++ /dev/null @@ -1,493 +0,0 @@ -/* - * Copyright (C) 2017 Konsulko Group - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#define _GNU_SOURCE - -#include -#include -#include -#include -#include - -#include -#include -#include - -#include "radio_impl.h" - -static const struct afb_binding_interface *interface; - -static struct afb_event freq_event; -static struct afb_event scan_event; - -static void freq_callback(uint32_t frequency, void *data) -{ - json_object *jresp = json_object_new_object(); - json_object *value = json_object_new_int((int) frequency); - - json_object_object_add(jresp, "value", value); - afb_event_push(freq_event, json_object_get(jresp)); -} - -static void scan_callback(uint32_t frequency, void *data) -{ - json_object *jresp = json_object_new_object(); - json_object *value = json_object_new_int((int) frequency); - - json_object_object_add(jresp, "value", value); - afb_event_push(scan_event, json_object_get(jresp)); -} - -/* - * Binding verb handlers - */ - -/* - * @brief Get (and optionally set) frequency - * - * @param struct afb_req : an afb request structure - * - */ -static void frequency(struct afb_req request) -{ - json_object *ret_json; - const char *value = afb_req_value(request, "value"); - uint32_t frequency; - - if(value) { - char *p; - frequency = strtoul(value, &p, 10); - if(frequency && *p == '\0') { - radio_impl_set_frequency(frequency); - } else { - afb_req_fail(request, "failed", "Invalid scan direction"); - return; - } - } - ret_json = json_object_new_object(); - frequency = radio_impl_get_frequency(); - json_object_object_add(ret_json, "frequency", json_object_new_int((int32_t) frequency)); - afb_req_success(request, ret_json, NULL); -} - -/* - * @brief Get (and optionally set) frequency band - * - * @param struct afb_req : an afb request structure - * - */ -static void band(struct afb_req request) -{ - json_object *ret_json; - const char *value = afb_req_value(request, "value"); - int valid = 0; - radio_band_t band; - char band_name[4]; - - if(value) { - if(!strcasecmp(value, "AM")) { - band = BAND_AM; - valid = 1; - } else if(!strcasecmp(value, "FM")) { - band = BAND_FM; - valid = 1; - } else { - char *p; - band = strtoul(value, &p, 10); - if(p != value && *p == '\0') { - switch(band) { - case BAND_AM: - case BAND_FM: - valid = 1; - break; - default: - break; - } - } - } - if(valid) { - radio_impl_set_band(band); - } else { - afb_req_fail(request, "failed", "Invalid band"); - return; - } - } - ret_json = json_object_new_object(); - band = radio_impl_get_band(); - sprintf(band_name, "%s", band == BAND_AM ? "AM" : "FM"); - json_object_object_add(ret_json, "band", json_object_new_string(band_name)); - afb_req_success(request, ret_json, NULL); -} - -/* - * @brief Check if band is supported - * - * @param struct afb_req : an afb request structure - * - */ -static void band_supported(struct afb_req request) -{ - json_object *ret_json; - const char *value = afb_req_value(request, "band"); - int valid = 0; - radio_band_t band; - - if(value) { - if(!strcasecmp(value, "AM")) { - band = BAND_AM; - valid = 1; - } else if(!strcasecmp(value, "FM")) { - band = BAND_FM; - valid = 1; - } else { - char *p; - band = strtoul(value, &p, 10); - if(p != value && *p == '\0') { - switch(band) { - case BAND_AM: - case BAND_FM: - valid = 1; - break; - default: - break; - } - } - } - } - if(!valid) { - afb_req_fail(request, "failed", "Invalid band"); - return; - } - ret_json = json_object_new_object(); - json_object_object_add(ret_json, - "supported", - json_object_new_int(radio_impl_band_supported(band))); - afb_req_success(request, ret_json, NULL); -} - -/* - * @brief Get frequency range for a band - * - * @param struct afb_req : an afb request structure - * - */ -static void frequency_range(struct afb_req request) -{ - json_object *ret_json; - const char *value = afb_req_value(request, "band"); - int valid = 0; - radio_band_t band; - uint32_t min_frequency; - uint32_t max_frequency; - - if(value) { - if(!strcasecmp(value, "AM")) { - band = BAND_AM; - valid = 1; - } else if(!strcasecmp(value, "FM")) { - band = BAND_FM; - valid = 1; - } else { - char *p; - band = strtoul(value, &p, 10); - if(p != value && *p == '\0') { - switch(band) { - case BAND_AM: - case BAND_FM: - valid = 1; - break; - default: - break; - } - } - } - } - if(!valid) { - afb_req_fail(request, "failed", "Invalid band"); - return; - } - ret_json = json_object_new_object(); - min_frequency = radio_impl_get_min_frequency(band); - max_frequency = radio_impl_get_max_frequency(band); - json_object_object_add(ret_json, "min", json_object_new_int((int32_t) min_frequency)); - json_object_object_add(ret_json, "max", json_object_new_int((int32_t) max_frequency)); - afb_req_success(request, ret_json, NULL); -} - -/* - * @brief Get frequency step size (Hz) for a band - * - * @param struct afb_req : an afb request structure - * - */ -static void frequency_step(struct afb_req request) -{ - json_object *ret_json; - const char *value = afb_req_value(request, "band"); - int valid = 0; - radio_band_t band; - uint32_t step; - - if(value) { - if(!strcasecmp(value, "AM")) { - band = BAND_AM; - valid = 1; - } else if(!strcasecmp(value, "FM")) { - band = BAND_FM; - valid = 1; - } else { - char *p; - band = strtoul(value, &p, 10); - if(p != value && *p == '\0') { - switch(band) { - case BAND_AM: - case BAND_FM: - valid = 1; - break; - default: - break; - } - } - } - } - if(!valid) { - afb_req_fail(request, "failed", "Invalid band"); - return; - } - ret_json = json_object_new_object(); - step = radio_impl_get_frequency_step(band); - json_object_object_add(ret_json, "step", json_object_new_int((int32_t) step)); - afb_req_success(request, ret_json, NULL); -} - -/* - * @brief Start radio playback - * - * @param struct afb_req : an afb request structure - * - */ -static void start(struct afb_req request) -{ - radio_impl_start(); - afb_req_success(request, NULL, NULL); -} - -/* - * @brief Stop radio playback - * - * @param struct afb_req : an afb request structure - * - */ -static void stop(struct afb_req request) -{ - radio_impl_stop(); - afb_req_success(request, NULL, NULL); -} - -/* - * @brief Scan for a station in the specified direction - * - * @param struct afb_req : an afb request structure - * - */ -static void scan_start(struct afb_req request) -{ - json_object *ret_json; - const char *value = afb_req_value(request, "direction"); - int valid = 0; - radio_scan_direction_t direction; - - if(value) { - if(!strcasecmp(value, "forward")) { - direction = SCAN_FORWARD; - valid = 1; - } else if(!strcasecmp(value, "backward")) { - direction = SCAN_BACKWARD; - valid = 1; - } else { - char *p; - direction = strtoul(value, &p, 10); - if(p != value && *p == '\0') { - switch(direction) { - case SCAN_FORWARD: - case SCAN_BACKWARD: - valid = 1; - break; - default: - break; - } - } - } - } - if(!valid) { - afb_req_fail(request, "failed", "Invalid direction"); - return; - } - radio_impl_scan_start(direction, scan_callback, NULL); - afb_req_success(request, ret_json, NULL); -} - -/* - * @brief Stop station scan - * - * @param struct afb_req : an afb request structure - * - */ -static void scan_stop(struct afb_req request) -{ - radio_impl_scan_stop(); - afb_req_success(request, NULL, NULL); -} - -/* - * @brief Get (and optionally set) stereo mode - * - * @param struct afb_req : an afb request structure - * - */ -static void stereo_mode(struct afb_req request) -{ - json_object *ret_json; - const char *value = afb_req_value(request, "value"); - int valid = 0; - radio_stereo_mode_t mode; - char mode_name[4]; - - if(value) { - if(!strcasecmp(value, "mono")) { - mode = MONO; - valid = 1; - } else if(!strcasecmp(value, "stereo")) { - mode = STEREO; - valid = 1; - } else { - char *p; - mode = strtoul(value, &p, 10); - if(p != value && *p == '\0') { - switch(mode) { - case MONO: - case STEREO: - valid = 1; - break; - default: - break; - } - } - } - if(valid) { - radio_impl_set_stereo_mode(mode); - } else { - afb_req_fail(request, "failed", "Invalid mode"); - return; - } - } - ret_json = json_object_new_object(); - mode = radio_impl_get_stereo_mode(); - sprintf(mode_name, "%s", mode == MONO ? "mono" : "stereo"); - json_object_object_add(ret_json, "mode", json_object_new_string(mode_name)); - afb_req_success(request, ret_json, NULL); -} - -/* - * @brief Subscribe for an event - * - * @param struct afb_req : an afb request structure - * - */ -static void subscribe(struct afb_req request) -{ - const char *value = afb_req_value(request, "value"); - if(value) { - if(!strcasecmp(value, "frequency")) { - afb_req_subscribe(request, freq_event); - } else if(!strcasecmp(value, "station_found")) { - afb_req_subscribe(request, scan_event); - } else { - afb_req_fail(request, "failed", "Invalid event"); - return; - } - } - afb_req_success(request, NULL, NULL); -} - -/* - * @brief Unsubscribe for an event - * - * @param struct afb_req : an afb request structure - * - */ -static void unsubscribe(struct afb_req request) -{ - const char *value = afb_req_value(request, "value"); - if(value) { - if(!strcasecmp(value, "frequency")) { - afb_req_unsubscribe(request, freq_event); - } else if(!strcasecmp(value, "station_found")) { - afb_req_unsubscribe(request, scan_event); - } else { - afb_req_fail(request, "failed", "Invalid event"); - return; - } - } - afb_req_success(request, NULL, NULL); -} - -static const struct afb_verb_desc_v1 verbs[]= { - { "frequency", AFB_SESSION_CHECK, frequency, "Get/Set frequency" }, - { "band", AFB_SESSION_CHECK, band, "Get/Set band" }, - { "band_supported", AFB_SESSION_CHECK, band_supported, "Check band support" }, - { "frequency_range", AFB_SESSION_CHECK, frequency_range, "Get frequency range" }, - { "frequency_step", AFB_SESSION_CHECK, frequency_step, "Get frequency step" }, - { "start", AFB_SESSION_CHECK, start, "Start radio playback" }, - { "stop", AFB_SESSION_CHECK, stop, "Stop radio playback" }, - { "scan_start", AFB_SESSION_CHECK, scan_start, "Start station scan" }, - { "scan_stop", AFB_SESSION_CHECK, scan_stop, "Stop station scan" }, - { "stereo_mode", AFB_SESSION_CHECK, stereo_mode, "Get/Set stereo_mode" }, - { "subscribe", AFB_SESSION_CHECK, subscribe, "Subscribe for an event" }, - { "unsubscribe", AFB_SESSION_CHECK, unsubscribe, "Unsubscribe for an event" }, - { NULL } -}; - -static const struct afb_binding binding_desc = { - .type = AFB_BINDING_VERSION_1, - .v1 = { - .info = "radio service", - .prefix = "radio", - .verbs = verbs - } -}; - -const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf) -{ - interface = itf; - - return &binding_desc; -} - -int afbBindingV1ServiceInit(struct afb_service service) -{ - int rc; - - freq_event = afb_daemon_make_event(interface->daemon, "frequency"); - scan_event = afb_daemon_make_event(interface->daemon, "station_found"); - - rc = radio_impl_init(); - if(rc == 0) { - radio_impl_set_frequency_callback(freq_callback, NULL); - } - - return rc; -} diff --git a/radio_impl.h b/radio_impl.h deleted file mode 100644 index 79e91a4..0000000 --- a/radio_impl.h +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (C) 2017 Konsulko Group - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef _RADIO_IMPL_H -#define _RADIO_IMPL_H - -#include - -typedef enum { - BAND_AM = 0, - BAND_FM -} radio_band_t; - -typedef enum { - SCAN_FORWARD = 0, - SCAN_BACKWARD -} radio_scan_direction_t; - -typedef void (*radio_scan_callback_t)(uint32_t frequency, void *data); - -typedef void (*radio_freq_callback_t)(uint32_t frequency, void *data); - -typedef enum { - MONO = 0, - STEREO -} radio_stereo_mode_t; - -int radio_impl_init(void); - -uint32_t radio_impl_get_frequency(void); - -void radio_impl_set_frequency(uint32_t frequency); - -void radio_impl_set_frequency_callback(radio_freq_callback_t callback, - void *data); - -radio_band_t radio_impl_get_band(void); - -void radio_impl_set_band(radio_band_t band); - -int radio_impl_band_supported(radio_band_t band); - -uint32_t radio_impl_get_min_frequency(radio_band_t band); - -uint32_t radio_impl_get_max_frequency(radio_band_t band); - -uint32_t radio_impl_get_frequency_step(radio_band_t band); - -void radio_impl_start(void); - -void radio_impl_stop(void); - -void radio_impl_scan_start(radio_scan_direction_t direction, - radio_scan_callback_t callback, - void *data); - -void radio_impl_scan_stop(void); - -radio_stereo_mode_t radio_impl_get_stereo_mode(void); - -void radio_impl_set_stereo_mode(radio_stereo_mode_t mode); - -#endif /* _RADIO_IMPL_H */ diff --git a/radio_impl_rtlsdr.c b/radio_impl_rtlsdr.c deleted file mode 100644 index 4364fd5..0000000 --- a/radio_impl_rtlsdr.c +++ /dev/null @@ -1,254 +0,0 @@ -/* - * Copyright (C) 2017 Konsulko Group - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include -#include -#include - -#include "radio_impl.h" -#include "radio_output.h" -#include "rtl_fm.h" - -// Structure to describe FM band plans, all values in Hz. -typedef struct { - char *name; - uint32_t min; - uint32_t max; - uint32_t step; -} fm_band_plan_t; - -static fm_band_plan_t known_fm_band_plans[5] = { - { .name = "US", .min = 87900000, .max = 107900000, .step = 200000 }, - { .name = "JP", .min = 76100000, .max = 89900000, .step = 100000 }, - { .name = "EU", .min = 87500000, .max = 108000000, .step = 50000 }, - { .name = "ITU-1", .min = 87500000, .max = 108000000, .step = 50000 }, - { .name = "ITU-2", .min = 87900000, .max = 107900000, .step = 50000 } -}; - -static unsigned int bandplan; -static bool present; -static bool active; -static uint32_t current_frequency; - -static void rtl_output_callback(int16_t *result, int result_len, void *ctx) -{ - if(active) - radio_output_write((char*) result, result_len * 2); -} - -int radio_impl_init(void) -{ - GKeyFile* conf_file; - int conf_file_present = 0; - char *value_str; - - if(present) - return -1; - - // Load settings from configuration file if it exists - conf_file = g_key_file_new(); - if(conf_file && - g_key_file_load_from_dirs(conf_file, - "AGL.conf", - (const gchar**) g_get_system_config_dirs(), - NULL, - G_KEY_FILE_KEEP_COMMENTS, - NULL) == TRUE) { - conf_file_present = 1; - - // Set band plan if it is specified - value_str = g_key_file_get_string(conf_file, - "radio", - "fmbandplan", - NULL); - if(value_str) { - unsigned int i; - for(i = 0; - i < sizeof(known_fm_band_plans) / sizeof(fm_band_plan_t); - i++) { - if(!strcasecmp(value_str, known_fm_band_plans[i].name)) { - bandplan = i; - break; - } - } - } - } - fprintf(stderr, "Using FM Bandplan: %s\n", known_fm_band_plans[bandplan].name); - - current_frequency = radio_impl_get_min_frequency(BAND_FM); - if(rtl_fm_init(current_frequency, 200000, 48000, rtl_output_callback, NULL) < 0) { - return -1; - } - - if(conf_file_present) { - GError *error = NULL; - int n; - - // Allow over-riding scanning parameters just in case a demo - // setup needs to do so to work reliably. - n = g_key_file_get_integer(conf_file, - "radio", - "scan_squelch_level", - &error); - //error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND && - //error->code != G_KEY_FILE_ERROR_INVALID_VALUE) { - if(!error) { - fprintf(stderr, "Scanning squelch level set to %d\n", n); - rtl_fm_scan_set_squelch_level(n); - } - - error = NULL; - n = g_key_file_get_integer(conf_file, - "radio", - "scan_squelch_limit", - &error); - if(!error) { - fprintf(stderr, "Scanning squelch limit set to %d\n", n); - rtl_fm_scan_set_squelch_limit(n); - } - - g_key_file_free(conf_file); - } - - present = true; - return 0; -} - -uint32_t radio_impl_get_frequency(void) -{ - return current_frequency; -} - -void radio_impl_set_frequency(uint32_t frequency) -{ - if(!present) - return; - - if(frequency < known_fm_band_plans[bandplan].min || - frequency > known_fm_band_plans[bandplan].max) - return; - - radio_impl_scan_stop(); - current_frequency = frequency; - rtl_fm_set_freq(frequency); -} - -void radio_impl_set_frequency_callback(radio_freq_callback_t callback, - void *data) -{ - rtl_fm_set_freq_callback(callback, data); -} - -radio_band_t radio_impl_get_band(void) -{ - return BAND_FM; -} - -void radio_impl_set_band(radio_band_t band) -{ - // We only support FM, so do nothing -} - -int radio_impl_band_supported(radio_band_t band) -{ - if(band == BAND_FM) - return 1; - return 0; -} - -uint32_t radio_impl_get_min_frequency(radio_band_t band) -{ - return known_fm_band_plans[bandplan].min; -} - -uint32_t radio_impl_get_max_frequency(radio_band_t band) -{ - return known_fm_band_plans[bandplan].max; -} - -uint32_t radio_impl_get_frequency_step(radio_band_t band) -{ - uint32_t ret = 0; - - switch (band) { - case BAND_AM: - ret = 1000; // 1 kHz - break; - case BAND_FM: - ret = known_fm_band_plans[bandplan].step; - break; - default: - break; - } - return ret; -} - -void radio_impl_start(void) -{ - if(!present) - return; - - if(!active) { - if(radio_output_start() != 0) - return; - - rtl_fm_start(); - active = true; - } -} - -void radio_impl_stop(void) -{ - if(!present) - return; - - if(active) { - active = false; - radio_output_stop(); - rtl_fm_stop(); - - } -} - -void radio_impl_scan_start(radio_scan_direction_t direction, - radio_scan_callback_t callback, - void *data) -{ - rtl_fm_scan_start(direction == SCAN_FORWARD ? 0 : 1, - callback, - data, - radio_impl_get_frequency_step(BAND_FM), - radio_impl_get_min_frequency(BAND_FM), - radio_impl_get_max_frequency(BAND_FM)); -} - -void radio_impl_scan_stop(void) -{ - rtl_fm_scan_stop(); -} - -radio_stereo_mode_t radio_impl_get_stereo_mode(void) -{ - return STEREO; -} - -void radio_impl_set_stereo_mode(radio_stereo_mode_t mode) -{ - // We only support stereo, so do nothing -} diff --git a/radio_output.c b/radio_output.c deleted file mode 100644 index a49687b..0000000 --- a/radio_output.c +++ /dev/null @@ -1,294 +0,0 @@ -/* - * Copyright (C) 2017 Konsulko Group - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include -#include -#include -#include - -#include "radio_output.h" -#include "rtl_fm.h" - -static pa_threaded_mainloop *mainloop; -static pa_context *context; -static pa_stream *stream; - -static unsigned int extra; -static int16_t extra_buf[1]; -static unsigned char *output_buf; - -static void pa_context_state_cb(pa_context *c, void *data) { - pa_operation *o; - - assert(c); - switch (pa_context_get_state(c)) { - case PA_CONTEXT_CONNECTING: - case PA_CONTEXT_AUTHORIZING: - case PA_CONTEXT_SETTING_NAME: - case PA_CONTEXT_READY: - break; - case PA_CONTEXT_TERMINATED: - pa_threaded_mainloop_stop(mainloop); - break; - case PA_CONTEXT_FAILED: - default: - fprintf(stderr, "PA connection failed: %s\n", - pa_strerror(pa_context_errno(c))); - pa_threaded_mainloop_stop(mainloop); - break; - } - pa_threaded_mainloop_signal(mainloop, 0); -} - -int radio_output_open(void) -{ - pa_context *c; - pa_mainloop_api *mapi; - char *client; - - if(context) - return 0; - - if (!(mainloop = pa_threaded_mainloop_new())) { - fprintf(stderr, "pa_mainloop_new() failed.\n"); - return -1; - } - - pa_threaded_mainloop_set_name(mainloop, "pa_mainloop"); - mapi = pa_threaded_mainloop_get_api(mainloop); - - client = pa_xstrdup("radio"); - if (!(c = pa_context_new(mapi, client))) { - fprintf(stderr, "pa_context_new() failed.\n"); - goto exit; - } - - pa_context_set_state_callback(c, pa_context_state_cb, NULL); - if (pa_context_connect(c, NULL, 0, NULL) < 0) { - fprintf(stderr, "pa_context_connect(): %s", pa_strerror(pa_context_errno(c))); - goto exit; - } - - if (pa_threaded_mainloop_start(mainloop) < 0) { - fprintf(stderr, "pa_mainloop_run() failed.\n"); - goto exit; - } - - context = c; - - extra = 0; - output_buf = malloc(sizeof(unsigned char) * RTL_FM_MAXIMUM_BUF_LENGTH); - - return 0; - -exit: - if (c) - pa_context_unref(c); - - if (mainloop) - pa_threaded_mainloop_free(mainloop); - - pa_xfree(client); - return -1; -} - -int radio_output_start(void) -{ - int error = 0; - pa_sample_spec *spec; - - if(stream) - return 0; - - if(!context) { - error = radio_output_open(); - if(error != 0) - return error; - } - - while(pa_context_get_state(context) != PA_CONTEXT_READY) - pa_threaded_mainloop_wait(mainloop); - - spec = (pa_sample_spec*) calloc(1, sizeof(pa_sample_spec)); - spec->format = PA_SAMPLE_S16LE; - spec->rate = 24000; - spec->channels = 2; - if (!pa_sample_spec_valid(spec)) { - fprintf(stderr, "%s\n", - pa_strerror(pa_context_errno(context))); - return -1; - } - - pa_threaded_mainloop_lock(mainloop); - pa_proplist *props = pa_proplist_new(); - pa_proplist_sets(props, PA_PROP_MEDIA_ROLE, "radio"); - stream = pa_stream_new_with_proplist(context, "radio-output", spec, 0, props); - if(!stream) { - fprintf(stderr, "Error creating stream %s\n", - pa_strerror(pa_context_errno(context))); - pa_proplist_free(props); - free(spec); - pa_threaded_mainloop_unlock(mainloop); - return -1; - } - pa_proplist_free(props); - free(spec); - - if(pa_stream_connect_playback(stream, - NULL, - NULL, - (pa_stream_flags_t) 0, - NULL, - NULL) < 0) { - fprintf(stderr, "Error connecting to PulseAudio : %s\n", - pa_strerror(pa_context_errno(context))); - pa_stream_unref(stream); - stream = NULL; - pa_threaded_mainloop_unlock(mainloop); - return -1; - } - - pa_threaded_mainloop_unlock(mainloop); - - while(pa_stream_get_state(stream) != PA_STREAM_READY) - pa_threaded_mainloop_wait(mainloop); - - return error; -} - -void radio_output_stop(void) -{ - if(stream) { - pa_threaded_mainloop_lock(mainloop); - - pa_stream_set_state_callback(stream, 0, 0); - pa_stream_set_write_callback(stream, 0, 0); - pa_stream_set_underflow_callback(stream, 0, 0); - pa_stream_set_overflow_callback(stream, 0, 0); - pa_stream_set_latency_update_callback(stream, 0, 0); - - pa_operation *o = pa_stream_flush(stream, NULL, NULL); - if(o) - pa_operation_unref(o); - - pa_stream_disconnect(stream); - pa_stream_unref(stream); - stream = NULL; - - pa_threaded_mainloop_unlock(mainloop); - } -} - -void radio_output_suspend(int state) -{ - if(stream) { - pa_stream_cork(stream, state, NULL, NULL); - } -} - -void radio_output_close(void) -{ - radio_output_stop(); - - if(context) { - pa_context_disconnect(context); - pa_context_unref(context); - context = NULL; - } - - if(mainloop) { - pa_threaded_mainloop_stop(mainloop); - pa_threaded_mainloop_free(mainloop); - mainloop = NULL; - } - - free(output_buf); - output_buf = NULL; -} - -int radio_output_write(void *buf, int len) -{ - int rc = -EINVAL; - int error; - size_t n = len; - size_t avail; - int samples = len / 2; - void *p; - - if(!stream) { - return -1; - } - - if(!buf) { - fprintf(stderr, "Error: buf == null!\n"); - return rc; - } - - pa_threaded_mainloop_lock(mainloop); - - avail = pa_stream_writable_size(stream); - if(avail < n) { - /* - * NOTE: Definitely room for improvement here,but for now just - * check for the no space case that happens when the - * stream is corked. - */ - if(!avail) { - rc = 0; - goto exit; - } - } - - /* - * Handle the rtl_fm code giving us an odd number of samples, which - * PA does not like. This extra buffer copying approach is not - * particularly efficient, but works for now. It looks feasible to - * hack in something in the demod and output thread routines in - * rtl_fm.c to handle it there if more performance is required. - */ - p = output_buf; - if(extra) { - memcpy(output_buf, extra_buf, sizeof(int16_t)); - if((extra + samples) % 2) { - // We still have an extra sample, n remains the same, store the extra - memcpy(output_buf + sizeof(int16_t), buf, n - 2); - memcpy(extra_buf, ((unsigned char*) buf) + n - 2, sizeof(int16_t)); - } else { - // We have an even number of samples, no extra - memcpy(output_buf + sizeof(int16_t), buf, n); - n += 2; - extra = 0; - } - } else if(samples % 2) { - // We have an extra sample, store it, and decrease n - n -= 2; - memcpy(output_buf + sizeof(int16_t), buf, n); - memcpy(extra_buf, ((unsigned char*) buf) + n, sizeof(int16_t)); - extra = 1; - } else { - p = buf; - } - - if ((rc = pa_stream_write(stream, p, n, NULL, 0, PA_SEEK_RELATIVE)) < 0) { - fprintf(stderr, "Error writing %d bytes to PulseAudio : %s\n", - n, pa_strerror(pa_context_errno(context))); - } -exit: - pa_threaded_mainloop_unlock(mainloop); - - return rc; -} diff --git a/radio_output.h b/radio_output.h deleted file mode 100644 index 2192811..0000000 --- a/radio_output.h +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (C) 2017 Konsulko Group - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef _RADIO_OUTPUT_H -#define _RADIO_OUTPUT_H - -int radio_output_open(void); - -int radio_output_start(void); - -void radio_output_stop(void); - -void radio_output_close(void); - -int radio_output_write(void *buf, int len); - -#endif /* _RADIO_OUTPUT_H */ - diff --git a/rtl_fm.c b/rtl_fm.c deleted file mode 100644 index 1c6a6b2..0000000 --- a/rtl_fm.c +++ /dev/null @@ -1,1267 +0,0 @@ -/* - * rtl-sdr, turns your Realtek RTL2832 based DVB dongle into a SDR receiver - * Copyright (C) 2012 by Steve Markgraf - * Copyright (C) 2012 by Hoernchen - * Copyright (C) 2012 by Kyle Keen - * Copyright (C) 2013 by Elias Oenal - * Copyright (C) 2016, 2017 Konsulko Group - * - * This program 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 2 of the License, or - * (at your option) any later version. - * - * This program 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 this program. If not, see . - */ - -/* - * Note that this version replaces the standalone main() with separate - * init/start/stop API calls to allow building into another application. - * Other than removing the separate controller thread and adding an output - * function callback, other changes have been kept to a minimum to - * potentially allow using other rtl_fm features by modifying rtl_fm_init. - * - * December 2016, Scott Murray - */ - -/* - * written because people could not do real time - * FM demod on Atom hardware with GNU radio - * based on rtl_sdr.c and rtl_tcp.c - * - * lots of locks, but that is okay - * (no many-to-many locks) - * - * todo: - * sanity checks - * scale squelch to other input parameters - * test all the demodulations - * pad output on hop - * frequency ranges could be stored better - * scaled AM demod amplification - * auto-hop after time limit - * peak detector to tune onto stronger signals - * fifo for active hop frequency - * clips - * noise squelch - * merge stereo patch - * merge soft agc patch - * merge udp patch - * testmode to detect overruns - * watchdog to reset bad dongle - * fix oversampling - */ - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "rtl-sdr.h" -#include "rtl_fm.h" -#include "convenience/convenience.h" - -#define DEFAULT_SAMPLE_RATE 24000 -#define DEFAULT_BUF_LENGTH RTL_FM_DEFAULT_BUF_LENGTH -#define MAXIMUM_OVERSAMPLE RTL_FM_MAXIMUM_OVERSAMPLE -#define MAXIMUM_BUF_LENGTH RTL_FM_MAXIMUM_BUF_LENGTH -#define AUTO_GAIN -100 -#define BUFFER_DUMP 4096 - -#define FREQUENCIES_LIMIT 1000 - -#define DEFAULT_SQUELCH_LEVEL 140 -#define DEFAULT_CONSEQ_SQUELCH 10 - -static volatile int do_exit = 0; -static int lcm_post[17] = {1,1,1,3,1,5,3,7,1,9,5,11,3,13,7,15,1}; -static int ACTUAL_BUF_LENGTH; - -static int *atan_lut = NULL; -static int atan_lut_size = 131072; /* 512 KB */ -static int atan_lut_coef = 8; - -struct dongle_state -{ - int exit_flag; - pthread_t thread; - rtlsdr_dev_t *dev; - int dev_index; - uint32_t freq; - uint32_t rate; - int gain; - uint16_t buf16[MAXIMUM_BUF_LENGTH]; - uint32_t buf_len; - int ppm_error; - int offset_tuning; - int direct_sampling; - int mute; - struct demod_state *demod_target; -}; - -struct demod_state -{ - int exit_flag; - pthread_t thread; - int16_t lowpassed[MAXIMUM_BUF_LENGTH]; - int lp_len; - int16_t lp_i_hist[10][6]; - int16_t lp_q_hist[10][6]; - int16_t result[MAXIMUM_BUF_LENGTH]; - int16_t droop_i_hist[9]; - int16_t droop_q_hist[9]; - int result_len; - int rate_in; - int rate_out; - int rate_out2; - int now_r, now_j; - int pre_r, pre_j; - int prev_index; - int downsample; /* min 1, max 256 */ - int post_downsample; - int output_scale; - int squelch_level, conseq_squelch, squelch_hits, terminate_on_squelch; - int downsample_passes; - int comp_fir_size; - int custom_atan; - int deemph, deemph_a; - int now_lpr; - int prev_lpr_index; - int dc_block, dc_avg; - void (*mode_demod)(struct demod_state*); - pthread_rwlock_t rw; - pthread_cond_t ready; - pthread_mutex_t ready_m; - struct output_state *output_target; -}; - -struct output_state -{ - int exit_flag; - pthread_t thread; - rtl_fm_output_fn_t output_fn; - void *output_fn_data; - int16_t result[MAXIMUM_BUF_LENGTH]; - int result_len; - int rate; - pthread_rwlock_t rw; - pthread_cond_t ready; - pthread_mutex_t ready_m; -}; - -struct controller_state -{ - int exit_flag; - pthread_t thread; - uint32_t freqs[FREQUENCIES_LIMIT]; - int freq_len; - int freq_now; - int edge; - int wb_mode; - pthread_cond_t hop; - pthread_mutex_t hop_m; - - void (*freq_callback)(uint32_t, void*); - void *freq_callback_data; - - int scanning; - int scan_direction; - void (*scan_callback)(uint32_t, void*); - void *scan_callback_data; - uint32_t scan_step; - uint32_t scan_min; - uint32_t scan_max; - int scan_squelch_level; - int scan_squelch_count; -}; - -// multiple of these, eventually -struct dongle_state dongle; -struct demod_state demod; -struct output_state output; -struct controller_state controller; - -#if 0 -static void sighandler(int signum) -{ - fprintf(stderr, "Signal caught, exiting!\n"); - do_exit = 1; - rtlsdr_cancel_async(dongle.dev); -} -#endif - -/* more cond dumbness */ -#define safe_cond_signal(n, m) pthread_mutex_lock(m); pthread_cond_signal(n); pthread_mutex_unlock(m) -#define safe_cond_wait(n, m) pthread_mutex_lock(m); pthread_cond_wait(n, m); pthread_mutex_unlock(m) - -/* {length, coef, coef, coef} and scaled by 2^15 - for now, only length 9, optimal way to get +85% bandwidth */ -#define CIC_TABLE_MAX 10 -int cic_9_tables[][10] = { - {0,}, - {9, -156, -97, 2798, -15489, 61019, -15489, 2798, -97, -156}, - {9, -128, -568, 5593, -24125, 74126, -24125, 5593, -568, -128}, - {9, -129, -639, 6187, -26281, 77511, -26281, 6187, -639, -129}, - {9, -122, -612, 6082, -26353, 77818, -26353, 6082, -612, -122}, - {9, -120, -602, 6015, -26269, 77757, -26269, 6015, -602, -120}, - {9, -120, -582, 5951, -26128, 77542, -26128, 5951, -582, -120}, - {9, -119, -580, 5931, -26094, 77505, -26094, 5931, -580, -119}, - {9, -119, -578, 5921, -26077, 77484, -26077, 5921, -578, -119}, - {9, -119, -577, 5917, -26067, 77473, -26067, 5917, -577, -119}, - {9, -199, -362, 5303, -25505, 77489, -25505, 5303, -362, -199}, -}; - -void rotate_90(unsigned char *buf, uint32_t len) -/* 90 rotation is 1+0j, 0+1j, -1+0j, 0-1j - or [0, 1, -3, 2, -4, -5, 7, -6] */ -{ - uint32_t i; - unsigned char tmp; - for (i=0; ilp_len) { - d->now_r += d->lowpassed[i]; - d->now_j += d->lowpassed[i+1]; - i += 2; - d->prev_index++; - if (d->prev_index < d->downsample) { - continue; - } - d->lowpassed[i2] = d->now_r; // * d->output_scale; - d->lowpassed[i2+1] = d->now_j; // * d->output_scale; - d->prev_index = 0; - d->now_r = 0; - d->now_j = 0; - i2 += 2; - } - d->lp_len = i2; -} - -int low_pass_simple(int16_t *signal2, int len, int step) -// no wrap around, length must be multiple of step -{ - int i, i2, sum; - for(i=0; i < len; i+=step) { - sum = 0; - for(i2=0; i2rate_out; - int slow = s->rate_out2; - while (i < s->result_len) { - s->now_lpr += s->result[i]; - i++; - s->prev_lpr_index += slow; - if (s->prev_lpr_index < fast) { - continue; - } - s->result[i2] = (int16_t)(s->now_lpr / (fast/slow)); - s->prev_lpr_index -= fast; - s->now_lpr = 0; - i2 += 1; - } - s->result_len = i2; -} - -void fifth_order(int16_t *data, int length, int16_t *hist) -/* for half of interleaved data */ -{ - int i; - int16_t a, b, c, d, e, f; - a = hist[1]; - b = hist[2]; - c = hist[3]; - d = hist[4]; - e = hist[5]; - f = data[0]; - /* a downsample should improve resolution, so don't fully shift */ - data[0] = (a + (b+e)*5 + (c+d)*10 + f) >> 4; - for (i=4; i> 4; - } - /* archive */ - hist[0] = a; - hist[1] = b; - hist[2] = c; - hist[3] = d; - hist[4] = e; - hist[5] = f; -} - -void generic_fir(int16_t *data, int length, int *fir, int16_t *hist) -/* Okay, not at all generic. Assumes length 9, fix that eventually. */ -{ - int d, temp, sum; - for (d=0; d> 15 ; - hist[0] = hist[1]; - hist[1] = hist[2]; - hist[2] = hist[3]; - hist[3] = hist[4]; - hist[4] = hist[5]; - hist[5] = hist[6]; - hist[6] = hist[7]; - hist[7] = hist[8]; - hist[8] = temp; - } -} - -/* define our own complex math ops - because ARMv5 has no hardware float */ - -void multiply(int ar, int aj, int br, int bj, int *cr, int *cj) -{ - *cr = ar*br - aj*bj; - *cj = aj*br + ar*bj; -} - -int polar_discriminant(int ar, int aj, int br, int bj) -{ - int cr, cj; - double angle; - multiply(ar, aj, br, -bj, &cr, &cj); - angle = atan2((double)cj, (double)cr); - return (int)(angle / 3.14159 * (1<<14)); -} - -int fast_atan2(int y, int x) -/* pre scaled for int16 */ -{ - int yabs, angle; - int pi4=(1<<12), pi34=3*(1<<12); // note pi = 1<<14 - if (x==0 && y==0) { - return 0; - } - yabs = y; - if (yabs < 0) { - yabs = -yabs; - } - if (x >= 0) { - angle = pi4 - pi4 * (x-yabs) / (x+yabs); - } else { - angle = pi34 - pi4 * (x+yabs) / (yabs-x); - } - if (y < 0) { - return -angle; - } - return angle; -} - -int polar_disc_fast(int ar, int aj, int br, int bj) -{ - int cr, cj; - multiply(ar, aj, br, -bj, &cr, &cj); - return fast_atan2(cj, cr); -} - -int atan_lut_init(void) -{ - int i = 0; - - atan_lut = malloc(atan_lut_size * sizeof(int)); - - for (i = 0; i < atan_lut_size; i++) { - atan_lut[i] = (int) (atan((double) i / (1< 0) - {return 1 << 13;} - if (cr == 0 && cj < 0) - {return -(1 << 13);} - if (cj == 0 && cr > 0) - {return 0;} - if (cj == 0 && cr < 0) - {return 1 << 14;} - } - - /* real range -32768 - 32768 use 64x range -> absolute maximum: 2097152 */ - x = (cj << atan_lut_coef) / cr; - x_abs = abs(x); - - if (x_abs >= atan_lut_size) { - /* we can use linear range, but it is not necessary */ - return (cj > 0) ? 1<<13 : -1<<13; - } - - if (x > 0) { - return (cj > 0) ? atan_lut[x] : atan_lut[x] - (1<<14); - } else { - return (cj > 0) ? (1<<14) - atan_lut[-x] : -atan_lut[-x]; - } - - return 0; -} - -void fm_demod(struct demod_state *fm) -{ - int i, pcm; - int16_t *lp = fm->lowpassed; - pcm = polar_discriminant(lp[0], lp[1], - fm->pre_r, fm->pre_j); - fm->result[0] = (int16_t)pcm; - for (i = 2; i < (fm->lp_len-1); i += 2) { - switch (fm->custom_atan) { - case 0: - pcm = polar_discriminant(lp[i], lp[i+1], - lp[i-2], lp[i-1]); - break; - case 1: - pcm = polar_disc_fast(lp[i], lp[i+1], - lp[i-2], lp[i-1]); - break; - case 2: - pcm = polar_disc_lut(lp[i], lp[i+1], - lp[i-2], lp[i-1]); - break; - } - fm->result[i/2] = (int16_t)pcm; - } - fm->pre_r = lp[fm->lp_len - 2]; - fm->pre_j = lp[fm->lp_len - 1]; - fm->result_len = fm->lp_len/2; -} - -void am_demod(struct demod_state *fm) -// todo, fix this extreme laziness -{ - int i, pcm; - int16_t *lp = fm->lowpassed; - int16_t *r = fm->result; - for (i = 0; i < fm->lp_len; i += 2) { - // hypot uses floats but won't overflow - //r[i/2] = (int16_t)hypot(lp[i], lp[i+1]); - pcm = lp[i] * lp[i]; - pcm += lp[i+1] * lp[i+1]; - r[i/2] = (int16_t)sqrt(pcm) * fm->output_scale; - } - fm->result_len = fm->lp_len/2; - // lowpass? (3khz) highpass? (dc) -} - -void usb_demod(struct demod_state *fm) -{ - int i, pcm; - int16_t *lp = fm->lowpassed; - int16_t *r = fm->result; - for (i = 0; i < fm->lp_len; i += 2) { - pcm = lp[i] + lp[i+1]; - r[i/2] = (int16_t)pcm * fm->output_scale; - } - fm->result_len = fm->lp_len/2; -} - -void lsb_demod(struct demod_state *fm) -{ - int i, pcm; - int16_t *lp = fm->lowpassed; - int16_t *r = fm->result; - for (i = 0; i < fm->lp_len; i += 2) { - pcm = lp[i] - lp[i+1]; - r[i/2] = (int16_t)pcm * fm->output_scale; - } - fm->result_len = fm->lp_len/2; -} - -void raw_demod(struct demod_state *fm) -{ - int i; - for (i = 0; i < fm->lp_len; i++) { - fm->result[i] = (int16_t)fm->lowpassed[i]; - } - fm->result_len = fm->lp_len; -} - -void deemph_filter(struct demod_state *fm) -{ - static int avg; // cheating... - int i, d; - // de-emph IIR - // avg = avg * (1 - alpha) + sample * alpha; - for (i = 0; i < fm->result_len; i++) { - d = fm->result[i] - avg; - if (d > 0) { - avg += (d + fm->deemph_a/2) / fm->deemph_a; - } else { - avg += (d - fm->deemph_a/2) / fm->deemph_a; - } - fm->result[i] = (int16_t)avg; - } -} - -void dc_block_filter(struct demod_state *fm) -{ - int i, avg; - int64_t sum = 0; - for (i=0; i < fm->result_len; i++) { - sum += fm->result[i]; - } - avg = sum / fm->result_len; - avg = (avg + fm->dc_avg * 9) / 10; - for (i=0; i < fm->result_len; i++) { - fm->result[i] -= avg; - } - fm->dc_avg = avg; -} - -int mad(int16_t *samples, int len, int step) -/* mean average deviation */ -{ - int i=0, sum=0, ave=0; - if (len == 0) - {return 0;} - for (i=0; i len2) { - tick -= len2; - i++; - } - if (i >= len1) { - i = len1 - 1; - tick = len2; - } - } -} - -void arbitrary_downsample(int16_t *buf1, int16_t *buf2, int len1, int len2) -/* fractional boxcar lowpass, len1 > len2 */ -{ - int i = 1; - int j = 0; - int tick = 0; - double remainder = 0; - double frac; // use integers... - buf2[0] = 0; - while (j < len2) { - frac = 1.0; - if ((tick + len2) > len1) { - frac = (double)(len1 - tick) / (double)len2;} - buf2[j] += (int16_t)((double)buf1[i] * frac + remainder); - remainder = (double)buf1[i] * (1.0-frac); - tick += len2; - i++; - if (tick > len1) { - j++; - buf2[j] = 0; - tick -= len1; - } - if (i >= len1) { - i = len1 - 1; - tick = len1; - } - } - for (j=0; jdownsample_passes; - if (ds_p) { - for (i=0; i < ds_p; i++) { - fifth_order(d->lowpassed, (d->lp_len >> i), d->lp_i_hist[i]); - fifth_order(d->lowpassed+1, (d->lp_len >> i) - 1, d->lp_q_hist[i]); - } - d->lp_len = d->lp_len >> ds_p; - /* droop compensation */ - if (d->comp_fir_size == 9 && ds_p <= CIC_TABLE_MAX) { - generic_fir(d->lowpassed, d->lp_len, - cic_9_tables[ds_p], d->droop_i_hist); - generic_fir(d->lowpassed+1, d->lp_len-1, - cic_9_tables[ds_p], d->droop_q_hist); - } - } else { - low_pass(d); - } - /* power squelch */ - if (d->squelch_level) { - sr = rms(d->lowpassed, d->lp_len, 1); - if (sr < d->squelch_level) { - d->squelch_hits++; - for (i=0; i< d->lp_len; i++) { - d->lowpassed[i] = 0; - } - } else { - d->squelch_hits = 0; - } - } - d->mode_demod(d); /* lowpassed -> result */ - if (d->mode_demod == &raw_demod) { - return; - } - /* todo, fm noise squelch */ - // use nicer filter here too? - if (d->post_downsample > 1) { - d->result_len = low_pass_simple(d->result, d->result_len, d->post_downsample);} - if (d->deemph) { - deemph_filter(d);} - if (d->dc_block) { - dc_block_filter(d);} - if (d->rate_out2 > 0) { - low_pass_real(d); - //arbitrary_resample(d->result, d->result, d->result_len, d->result_len * d->rate_out2 / d->rate_out); - } -} - -static void rtlsdr_callback(unsigned char *buf, uint32_t len, void *ctx) -{ - int i; - struct dongle_state *s = ctx; - struct demod_state *d = s->demod_target; - - if (do_exit) { - return;} - if (!ctx) { - return;} - if (s->mute) { - for (i=0; imute; i++) { - buf[i] = 127;} - s->mute = 0; - } - if (!s->offset_tuning) { - rotate_90(buf, len);} - for (i=0; i<(int)len; i++) { - s->buf16[i] = (int16_t)buf[i] - 127;} - pthread_rwlock_wrlock(&d->rw); - memcpy(d->lowpassed, s->buf16, 2*len); - d->lp_len = len; - pthread_rwlock_unlock(&d->rw); - safe_cond_signal(&d->ready, &d->ready_m); -} - -static void *dongle_thread_fn(void *arg) -{ - struct dongle_state *s = arg; - fprintf(stderr, "dongle_thread_fn running\n"); - rtlsdr_read_async(s->dev, rtlsdr_callback, s, 0, s->buf_len); - fprintf(stderr, "dongle_thread_fn exited!\n"); - return 0; -} - -static void rtl_fm_scan_callback(void) -{ - struct controller_state *s = &controller; - uint32_t frequency = rtl_fm_get_freq(); - - if(!s->scanning) - return; - - if(!s->scan_direction) { - frequency += s->scan_step; - if(frequency > s->scan_max) - frequency = s->scan_min; - } else { - frequency -= s->scan_step; - if(frequency < s->scan_min) - frequency = s->scan_max; - } - - rtl_fm_set_freq(frequency); -} - -static void rtl_fm_scan_end_callback(void) -{ - struct controller_state *s = &controller; - - if(!s->scanning) - return; - - rtl_fm_scan_stop(); - - if(s->scan_callback) - s->scan_callback(rtl_fm_get_freq(), s->scan_callback_data); -} - -static void *demod_thread_fn(void *arg) -{ - struct demod_state *d = arg; - struct output_state *o = d->output_target; - fprintf(stderr, "demod_thread_fn running\n"); - while (!do_exit) { - safe_cond_wait(&d->ready, &d->ready_m); - pthread_rwlock_wrlock(&d->rw); - full_demod(d); - pthread_rwlock_unlock(&d->rw); - if (d->exit_flag) { - do_exit = 1; - } - if (d->squelch_level) { - if(d->squelch_hits > d->conseq_squelch) { - d->squelch_hits = d->conseq_squelch + 1; /* hair trigger */ - //safe_cond_signal(&controller.hop, &controller.hop_m); - rtl_fm_scan_callback(); - continue; - } else if(!d->squelch_hits) { - rtl_fm_scan_end_callback(); - } - } - pthread_rwlock_wrlock(&o->rw); - memcpy(o->result, d->result, 2*d->result_len); - o->result_len = d->result_len; - pthread_rwlock_unlock(&o->rw); - safe_cond_signal(&o->ready, &o->ready_m); - } - fprintf(stderr, "demod_thread_fn exited!\n"); - return 0; -} - -static void *output_thread_fn(void *arg) -{ - struct output_state *s = arg; - fprintf(stderr, "output_thread_fn running\n"); - while (!do_exit) { - // use timedwait and pad out under runs - safe_cond_wait(&s->ready, &s->ready_m); - pthread_rwlock_rdlock(&s->rw); - if(s->output_fn) { - s->output_fn(s->result, s->result_len, s->output_fn_data); - } - pthread_rwlock_unlock(&s->rw); - } - fprintf(stderr, "output_thread_fn exited!\n"); - return 0; -} - -static void optimal_settings(int freq, int rate) -{ - // giant ball of hacks - // seems unable to do a single pass, 2:1 - int capture_freq, capture_rate; - struct dongle_state *d = &dongle; - struct demod_state *dm = &demod; - struct controller_state *cs = &controller; - dm->downsample = (1000000 / dm->rate_in) + 1; - if (dm->downsample_passes) { - dm->downsample_passes = (int)log2(dm->downsample) + 1; - dm->downsample = 1 << dm->downsample_passes; - } - capture_freq = freq; - capture_rate = dm->downsample * dm->rate_in; - if (!d->offset_tuning) { - capture_freq = freq + capture_rate/4;} - capture_freq += cs->edge * dm->rate_in / 2; - dm->output_scale = (1<<15) / (128 * dm->downsample); - if (dm->output_scale < 1) { - dm->output_scale = 1;} - if (dm->mode_demod == &fm_demod) { - dm->output_scale = 1;} - d->freq = (uint32_t)capture_freq; - d->rate = (uint32_t)capture_rate; -} - - -void frequency_range(struct controller_state *s, char *arg) -{ - char *start, *stop, *step; - int i; - start = arg; - stop = strchr(start, ':') + 1; - stop[-1] = '\0'; - step = strchr(stop, ':') + 1; - step[-1] = '\0'; - for(i=(int)atofs(start); i<=(int)atofs(stop); i+=(int)atofs(step)) - { - s->freqs[s->freq_len] = (uint32_t)i; - s->freq_len++; - if (s->freq_len >= FREQUENCIES_LIMIT) { - break;} - } - stop[-1] = ':'; - step[-1] = ':'; -} - -void dongle_init(struct dongle_state *s) -{ - s->rate = DEFAULT_SAMPLE_RATE; - s->gain = AUTO_GAIN; // tenths of a dB - s->mute = 0; - s->direct_sampling = 0; - s->offset_tuning = 0; - s->demod_target = &demod; -} - -void demod_init(struct demod_state *s) -{ - s->rate_in = DEFAULT_SAMPLE_RATE; - s->rate_out = DEFAULT_SAMPLE_RATE; - s->squelch_level = 0; - s->conseq_squelch = DEFAULT_CONSEQ_SQUELCH; - s->terminate_on_squelch = 0; - s->squelch_hits = DEFAULT_CONSEQ_SQUELCH + 1; - s->downsample_passes = 0; - s->comp_fir_size = 0; - s->prev_index = 0; - s->post_downsample = 1; // once this works, default = 4 - s->custom_atan = 0; - s->deemph = 0; - s->rate_out2 = -1; // flag for disabled - s->mode_demod = &fm_demod; - s->pre_j = s->pre_r = s->now_r = s->now_j = 0; - s->prev_lpr_index = 0; - s->deemph_a = 0; - s->now_lpr = 0; - s->dc_block = 0; - s->dc_avg = 0; - pthread_rwlock_init(&s->rw, NULL); - pthread_cond_init(&s->ready, NULL); - pthread_mutex_init(&s->ready_m, NULL); - s->output_target = &output; -} - -void demod_cleanup(struct demod_state *s) -{ - pthread_rwlock_destroy(&s->rw); - pthread_cond_destroy(&s->ready); - pthread_mutex_destroy(&s->ready_m); -} - -void output_init(struct output_state *s) -{ - s->rate = DEFAULT_SAMPLE_RATE; - s->output_fn = NULL; - s->output_fn_data = NULL; - pthread_rwlock_init(&s->rw, NULL); - pthread_cond_init(&s->ready, NULL); - pthread_mutex_init(&s->ready_m, NULL); -} - -void output_cleanup(struct output_state *s) -{ - pthread_rwlock_destroy(&s->rw); - pthread_cond_destroy(&s->ready); - pthread_mutex_destroy(&s->ready_m); -} - -void controller_init(struct controller_state *s) -{ - s->freqs[0] = 100000000; - s->freq_len = 0; - s->edge = 0; - s->wb_mode = 0; - pthread_cond_init(&s->hop, NULL); - pthread_mutex_init(&s->hop_m, NULL); -} - -void controller_cleanup(struct controller_state *s) -{ - pthread_cond_destroy(&s->hop); - pthread_mutex_destroy(&s->hop_m); -} - -void sanity_checks(void) -{ - if (controller.freq_len == 0) { - fprintf(stderr, "Please specify a frequency.\n"); - exit(1); - } - - if (controller.freq_len >= FREQUENCIES_LIMIT) { - fprintf(stderr, "Too many channels, maximum %i.\n", FREQUENCIES_LIMIT); - exit(1); - } - - if (controller.freq_len > 1 && demod.squelch_level == 0) { - fprintf(stderr, "Please specify a squelch level. Required for scanning multiple frequencies.\n"); - exit(1); - } - -} - -int rtl_fm_init(uint32_t freq, - uint32_t sample_rate, - uint32_t resample_rate, - rtl_fm_output_fn_t output_fn, - void *output_fn_data) -{ - int r = 0; - - dongle_init(&dongle); - demod_init(&demod); - output_init(&output); - controller_init(&controller); - - /* - * Simulate the effects of command line arguments: - * - * -W wbfm -s -r - */ - - /* Set initial frequency */ - controller.freqs[0] = freq; - controller.freq_len++; - - /* Set mode to wbfm */ - controller.wb_mode = 1; - demod.mode_demod = &fm_demod; - demod.rate_in = 170000; - demod.rate_out = 170000; - demod.rate_out2 = 32000; - demod.custom_atan = 1; - //demod.post_downsample = 4; - demod.deemph = 1; - controller.scan_squelch_count = DEFAULT_CONSEQ_SQUELCH; - controller.scan_squelch_level = DEFAULT_SQUELCH_LEVEL; - demod.squelch_level = 0; - - /* Adjust frequency for wb mode */ - controller.freqs[0] += 16000; - - /* Set sample rate */ - demod.rate_in = sample_rate; - demod.rate_out = sample_rate; - - /* Set resample rate */ - output.rate = (int) resample_rate; - demod.rate_out2 = (int) resample_rate; - - /* Set output function pointer */ - if(output_fn) { - output.output_fn = output_fn; - output.output_fn_data = output_fn_data; - } - - /* quadruple sample_rate to limit to Δθ to ±π/2 */ - demod.rate_in *= demod.post_downsample; - - if (!output.rate) { - output.rate = demod.rate_out; - } - - sanity_checks(); - - if (controller.freq_len > 1) { - demod.terminate_on_squelch = 0; - } - - ACTUAL_BUF_LENGTH = lcm_post[demod.post_downsample] * DEFAULT_BUF_LENGTH; - - dongle.dev_index = verbose_device_search("0"); - if (dongle.dev_index < 0) { - return -1; - } - - r = rtlsdr_open(&dongle.dev, (uint32_t)dongle.dev_index); - if (r < 0) { - fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dongle.dev_index); - return r; - } - - if (demod.deemph) { - demod.deemph_a = (int)round(1.0/((1.0-exp(-1.0/(demod.rate_out * 75e-6))))); - } - - /* Set the tuner gain */ - if (dongle.gain == AUTO_GAIN) { - verbose_auto_gain(dongle.dev); - } else { - dongle.gain = nearest_gain(dongle.dev, dongle.gain); - verbose_gain_set(dongle.dev, dongle.gain); - } - - verbose_ppm_set(dongle.dev, dongle.ppm_error); - - //r = rtlsdr_set_testmode(dongle.dev, 1); - - return r; -} - -void rtl_fm_start(void) -{ - struct controller_state *s = &controller; - - /* - * A bunch of the following is pulled from the controller_thread_fn, - * which has been removed. - */ - - /* Reset endpoint before we start reading from it (mandatory) */ - verbose_reset_buffer(dongle.dev); - - /* set up primary channel */ - optimal_settings(s->freqs[0], demod.rate_in); - if (dongle.direct_sampling) { - verbose_direct_sampling(dongle.dev, 1);} - if (dongle.offset_tuning) { - verbose_offset_tuning(dongle.dev);} - - /* Set the frequency */ - verbose_set_frequency(dongle.dev, dongle.freq); - fprintf(stderr, "Oversampling input by: %ix.\n", demod.downsample); - fprintf(stderr, "Oversampling output by: %ix.\n", demod.post_downsample); - fprintf(stderr, "Buffer size: %0.2fms\n", - 1000 * 0.5 * (float)ACTUAL_BUF_LENGTH / (float)dongle.rate); - - /* Set the sample rate */ - verbose_set_sample_rate(dongle.dev, dongle.rate); - fprintf(stderr, "Output at %u Hz.\n", demod.rate_in/demod.post_downsample); - usleep(100000); - - rtl_fm_scan_stop(); - - do_exit = 0; - pthread_create(&output.thread, NULL, output_thread_fn, (void *)(&output)); - pthread_create(&demod.thread, NULL, demod_thread_fn, (void *)(&demod)); - pthread_create(&dongle.thread, NULL, dongle_thread_fn, (void *)(&dongle)); -} - -void rtl_fm_set_freq(uint32_t freq) -{ - struct controller_state *s = &controller; - - if(s->freqs[0] == freq) - return; - - s->freqs[0] = freq; - s->freq_len = 1; - - if (s->wb_mode) { - s->freqs[0] += 16000; - } - - optimal_settings(s->freqs[0], demod.rate_in); - if (dongle.offset_tuning) { - verbose_offset_tuning(dongle.dev); - } - rtlsdr_set_center_freq(dongle.dev, dongle.freq); - - // It does not look like refreshing the sample rate is desirable - // (e.g. the scanning code in the removed controller thread function - // did not do it), and behavior seemed a bit less robust with it - // present. However, I am leaving this here as a reminder to revisit - // via some more testing. - //rtlsdr_set_sample_rate(dongle.dev, dongle.rate); - - // This triggers a mute during the frequency change - dongle.mute = BUFFER_DUMP; - - if(s->freq_callback) - s->freq_callback(freq, s->freq_callback_data); -} - -void rtl_fm_set_freq_callback(void (*callback)(uint32_t, void *), - void *data) -{ - struct controller_state *s = &controller; - - s->freq_callback = callback; - s->freq_callback_data = data; -} - -uint32_t rtl_fm_get_freq(void) -{ - struct controller_state *s = &controller; - uint32_t frequency = s->freqs[0]; - - if (s->wb_mode) - frequency -= 16000; - - return frequency; -} - -void rtl_fm_stop(void) -{ - rtl_fm_scan_stop(); - - rtlsdr_cancel_async(dongle.dev); - do_exit = 1; - pthread_join(dongle.thread, NULL); - safe_cond_signal(&demod.ready, &demod.ready_m); - pthread_join(demod.thread, NULL); - safe_cond_signal(&output.ready, &output.ready_m); - pthread_join(output.thread, NULL); -} - -void rtl_fm_scan_start(int direction, - void (*callback)(uint32_t, void *), - void *data, - uint32_t step, - uint32_t min, - uint32_t max) -{ - struct controller_state *s = &controller; - struct demod_state *dm = &demod; - uint32_t frequency = rtl_fm_get_freq(); - - if(s->scanning && s->scan_direction == direction) - return; - - s->scanning = 1; - s->scan_direction = direction; - s->scan_callback = callback; - s->scan_callback_data = data; - s->scan_step = step; - s->scan_min = min; - s->scan_max = max; - - /* Start scan by stepping in the desired direction */ - if(!direction) { - frequency += s->scan_step; - if(frequency > s->scan_max) - frequency = s->scan_min; - } else { - frequency -= s->scan_step; - if(frequency < s->scan_min) - frequency = s->scan_max; - } - - rtl_fm_set_freq(frequency); - - dm->conseq_squelch = s->scan_squelch_count; - dm->squelch_hits = s->scan_squelch_count + 1; - dm->squelch_level = s->scan_squelch_level; -} - -void rtl_fm_scan_stop(void) -{ - struct controller_state *s = &controller; - struct demod_state *dm = &demod; - - s->scanning = 0; - - dm->squelch_hits = s->scan_squelch_count + 1; - dm->squelch_level = 0; -} - -void rtl_fm_scan_set_squelch_level(int level) -{ - struct controller_state *s = &controller; - - s->scan_squelch_level = level; -} - -void rtl_fm_scan_set_squelch_limit(int count) -{ - struct controller_state *s = &controller; - - s->scan_squelch_count = count; -} - -void rtl_fm_cleanup(void) -{ - //dongle_cleanup(&dongle); - demod_cleanup(&demod); - output_cleanup(&output); - controller_cleanup(&controller); - - rtlsdr_close(dongle.dev); -} - -// vim: tabstop=8:softtabstop=8:shiftwidth=8:noexpandtab diff --git a/rtl_fm.h b/rtl_fm.h deleted file mode 100644 index f5b2a86..0000000 --- a/rtl_fm.h +++ /dev/null @@ -1,70 +0,0 @@ -/* - * rtl-sdr, turns your Realtek RTL2832 based DVB dongle into a SDR receiver - * Copyright (C) 2016, 2017 Konsulko Group - * - * This program 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 2 of the License, or - * (at your option) any later version. - * - * This program 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 this program. If not, see . - */ - -#ifndef RTL_FM_H -#define RTL_FM_H - -#include - -#define RTL_FM_DEFAULT_BUF_LENGTH (1 * 16384) -#define RTL_FM_MAXIMUM_OVERSAMPLE 16 -#define RTL_FM_MAXIMUM_BUF_LENGTH (RTL_FM_MAXIMUM_OVERSAMPLE * RTL_FM_DEFAULT_BUF_LENGTH) - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void (*rtl_fm_output_fn_t)(int16_t *result, int result_len, void *data); - -int rtl_fm_init(uint32_t freq, - uint32_t sample_rate, - uint32_t resample_rate, - rtl_fm_output_fn_t output_fn, - void *output_fn_data); - -void rtl_fm_start(void); - -void rtl_fm_set_freq(uint32_t freq); - -void rtl_fm_set_freq_callback(void (*callback)(uint32_t, void *), - void *data); - -uint32_t rtl_fm_get_freq(void); - -void rtl_fm_stop(void); - -void rtl_fm_scan_start(int direction, - void (*callback)(uint32_t, void *), - void *data, - uint32_t step, - uint32_t min, - uint32_t max); - -void rtl_fm_scan_stop(void); - -void rtl_fm_scan_set_squelch_level(int level); - -void rtl_fm_scan_set_squelch_limit(int count); - -void rtl_fm_cleanup(void); - -#ifdef __cplusplus -} -#endif - -#endif /* RTL_FM_H */ -- cgit 1.2.3-korg