diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 31be92c..0000000 --- a/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2022 Pusheon - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..aab650f --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,340 @@ + + 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. + + {signature of Ty Coon}, 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/PresenceClient/.editorconfig b/PresenceClient/.editorconfig new file mode 100644 index 0000000..bc332e4 --- /dev/null +++ b/PresenceClient/.editorconfig @@ -0,0 +1,4 @@ +[*.cs] + +# CA1031: Do not catch general exception types +dotnet_diagnostic.CA1031.severity = none diff --git a/PresenceClient/.gitignore b/PresenceClient/.gitignore new file mode 100644 index 0000000..62e4e8f --- /dev/null +++ b/PresenceClient/.gitignore @@ -0,0 +1,352 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# JustCode is a .NET coding add-in +.JustCode + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ diff --git a/PresenceClient/.idea/.idea.PresenceClient/.idea/.gitignore b/PresenceClient/.idea/.idea.PresenceClient/.idea/.gitignore new file mode 100644 index 0000000..3db81ab --- /dev/null +++ b/PresenceClient/.idea/.idea.PresenceClient/.idea/.gitignore @@ -0,0 +1,13 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Rider ignored files +/projectSettingsUpdater.xml +/contentModel.xml +/.idea.PresenceClient.iml +/modules.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/PresenceClient/.idea/.idea.PresenceClient/.idea/discord.xml b/PresenceClient/.idea/.idea.PresenceClient/.idea/discord.xml new file mode 100644 index 0000000..d8e9561 --- /dev/null +++ b/PresenceClient/.idea/.idea.PresenceClient/.idea/discord.xml @@ -0,0 +1,7 @@ + + + + + \ No newline at end of file diff --git a/PresenceClient/.idea/.idea.PresenceClient/.idea/encodings.xml b/PresenceClient/.idea/.idea.PresenceClient/.idea/encodings.xml new file mode 100644 index 0000000..df87cf9 --- /dev/null +++ b/PresenceClient/.idea/.idea.PresenceClient/.idea/encodings.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/PresenceClient/.idea/.idea.PresenceClient/.idea/indexLayout.xml b/PresenceClient/.idea/.idea.PresenceClient/.idea/indexLayout.xml new file mode 100644 index 0000000..7b08163 --- /dev/null +++ b/PresenceClient/.idea/.idea.PresenceClient/.idea/indexLayout.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/PresenceClient/.idea/.idea.PresenceClient/.idea/vcs.xml b/PresenceClient/.idea/.idea.PresenceClient/.idea/vcs.xml new file mode 100644 index 0000000..6c0b863 --- /dev/null +++ b/PresenceClient/.idea/.idea.PresenceClient/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/PresenceClient/PresenceClient-CLI/ConsoleOptions.cs b/PresenceClient/PresenceClient-CLI/ConsoleOptions.cs new file mode 100644 index 0000000..1d79d47 --- /dev/null +++ b/PresenceClient/PresenceClient-CLI/ConsoleOptions.cs @@ -0,0 +1,17 @@ +using System.Net; +using CommandLine; + +namespace PresenceClient_CLI; + +public class ConsoleOptions +{ + [Option('m', "ignore-home-screen", Required = false, Default = false, HelpText = "Don't display the home screen")] + public bool IgnoreHomeScreen { get; set; } + + [Value(0, MetaName = "IP", Required = true, HelpText = "The IP address of your device")] + public string Ip { get; set; } + public IPAddress ParsedIp { get; set; } + + [Value(1, MetaName = "Client ID", Required = true, HelpText = "The Client ID of your Discord Rich Presence application")] + public ulong ClientId { get; set; } +} \ No newline at end of file diff --git a/PresenceClient/PresenceClient-CLI/Icon.ico b/PresenceClient/PresenceClient-CLI/Icon.ico new file mode 100644 index 0000000..06376f7 Binary files /dev/null and b/PresenceClient/PresenceClient-CLI/Icon.ico differ diff --git a/PresenceClient/PresenceClient-CLI/PresenceClient-CLI.csproj b/PresenceClient/PresenceClient-CLI/PresenceClient-CLI.csproj new file mode 100644 index 0000000..1b37265 --- /dev/null +++ b/PresenceClient/PresenceClient-CLI/PresenceClient-CLI.csproj @@ -0,0 +1,20 @@ + + + + Exe + net6.0 + PresenceClient_CLI + Icon.ico + latestmajor + + + + + + + + + + + + diff --git a/PresenceClient/PresenceClient-CLI/Program.cs b/PresenceClient/PresenceClient-CLI/Program.cs new file mode 100644 index 0000000..635e17c --- /dev/null +++ b/PresenceClient/PresenceClient-CLI/Program.cs @@ -0,0 +1,145 @@ +using System; +using System.Net; +using System.Net.Sockets; +using System.Timers; +using CommandLine; +using DiscordRPC; +using PresenceCommon; +using PresenceCommon.Types; + +namespace PresenceClient_CLI; + +internal class Program +{ + private static Timer _timer; + private static Socket _client; + private static string _lastProgramName = string.Empty; + private static Timestamps _time; + private static DiscordRpcClient _rpc; + private static ConsoleOptions _arguments; + + private static int Main(string[] args) + { + AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit; + Parser.Default.ParseArguments(args) + .WithParsed(arguments => + { + if (!IPAddress.TryParse(arguments.Ip, out var iPAddress)) + { + Console.WriteLine("Invalid IP"); + Environment.Exit(1); + } + arguments.ParsedIp = iPAddress; + _rpc = new DiscordRpcClient(arguments.ClientId.ToString()); + _arguments = arguments; + }) + .WithNotParsed(_ => Environment.Exit(1)); + + if (!_rpc.Initialize()) + { + Console.WriteLine("Unable to start RPC!"); + return 2; + } + + var localEndPoint = new IPEndPoint(_arguments.ParsedIp, 0xCAFE); + + _timer = new Timer + { + Interval = 15000, + Enabled = false, + }; + _timer.Elapsed += OnConnectTimeout; + + while (true) + { + _client = new Socket(SocketType.Stream, ProtocolType.Tcp) + { + ReceiveTimeout = 5500, + SendTimeout = 5500 + }; + + _timer.Enabled = true; + + try + { + var result = _client.BeginConnect(localEndPoint, null, null); + var success = result.AsyncWaitHandle.WaitOne(2000, true); + if (!success) + { + //UpdateStatus("Could not connect to Server! Retrying...", Color.DarkRed); + _client.Close(); + } + else + { + _client.EndConnect(result); + _timer.Enabled = false; + + DataListen(); + } + } + catch (SocketException) + { + _client.Close(); + if (_rpc != null && !_rpc.IsDisposed) _rpc.ClearPresence(); + } + } + } + + private static void DataListen() + { + while (true) + { + try + { + var bytes = Utils.ReceiveExactly(_client); + + var title = new Title(bytes); + if (title.Magic == 0xffaadd23) + { + if (_lastProgramName != title.Name) + { + _time = Timestamps.Now; + } + + if (_rpc is not { CurrentPresence: null } && _lastProgramName == title.Name) continue; + if (_arguments.IgnoreHomeScreen && title.Name == "Home Menu") + { + _rpc.ClearPresence(); + } + else + { + _rpc.SetPresence(Utils.CreateDiscordPresence(title, _time)); + } + _lastProgramName = title.Name; + } + else + { + if (_rpc != null && !_rpc.IsDisposed) _rpc.ClearPresence(); + _client.Close(); + return; + } + } + catch (SocketException) + { + if (_rpc != null && !_rpc.IsDisposed) _rpc.ClearPresence(); + _client.Close(); + return; + } + } + } + + private static void OnConnectTimeout(object sender, ElapsedEventArgs e) + { + _lastProgramName = string.Empty; + _time = null; + } + + private static void CurrentDomain_ProcessExit(object sender, EventArgs e) + { + if (_client != null && _client.Connected) + _client.Close(); + + if(_rpc != null && !_rpc.IsDisposed) + _rpc.Dispose(); + } +} \ No newline at end of file diff --git a/PresenceClient/PresenceClient-GUI/.editorconfig b/PresenceClient/PresenceClient-GUI/.editorconfig new file mode 100644 index 0000000..011e3e6 --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/.editorconfig @@ -0,0 +1,412 @@ +root = true +################# +# Common Settings +################# + +# This file is the top-most EditorConfig file + +# All Files +[*] +charset = utf-8 +indent_style = space +indent_size = 4 +insert_final_newline = false +trim_trailing_whitespace = true +end_of_line = crlf + +# Microsoft .NET properties +csharp_new_line_before_members_in_object_initializers = false +csharp_preferred_modifier_order = public, private, protected, internal, new, abstract, virtual, sealed, override, static, readonly, extern, unsafe, volatile, async:suggestion +csharp_style_var_elsewhere = true:suggestion +csharp_style_var_for_built_in_types = true:suggestion +csharp_style_var_when_type_is_apparent = true:suggestion +dotnet_naming_rule.private_constants_rule.severity = warning +dotnet_naming_rule.private_constants_rule.style = upper_camel_case_style +dotnet_naming_rule.private_constants_rule.symbols = private_constants_symbols +dotnet_naming_rule.private_instance_fields_rule.severity = warning +dotnet_naming_rule.private_instance_fields_rule.style = lower_camel_case_style +dotnet_naming_rule.private_instance_fields_rule.symbols = private_instance_fields_symbols +dotnet_naming_rule.private_readonly_fields_must_be_camel_case.style = underscore_prefix +dotnet_naming_rule.private_static_fields_rule.severity = warning +dotnet_naming_rule.private_static_fields_rule.style = lower_camel_case_style +dotnet_naming_rule.private_static_fields_rule.symbols = private_static_fields_symbols +dotnet_naming_rule.private_static_readonly_rule.severity = warning +dotnet_naming_rule.private_static_readonly_rule.style = upper_camel_case_style +dotnet_naming_rule.private_static_readonly_rule.symbols = private_static_readonly_symbols +dotnet_naming_style.lower_camel_case_style.capitalization = camel_case +dotnet_naming_style.upper_camel_case_style.capitalization = pascal_case +dotnet_naming_symbols.private_constants_symbols.applicable_accessibilities = private +dotnet_naming_symbols.private_constants_symbols.applicable_kinds = field +dotnet_naming_symbols.private_constants_symbols.required_modifiers = const +dotnet_naming_symbols.private_instance_fields_symbols.applicable_accessibilities = private +dotnet_naming_symbols.private_instance_fields_symbols.applicable_kinds = field +dotnet_naming_symbols.private_static_fields_symbols.applicable_accessibilities = private +dotnet_naming_symbols.private_static_fields_symbols.applicable_kinds = field +dotnet_naming_symbols.private_static_fields_symbols.required_modifiers = static +dotnet_naming_symbols.private_static_readonly_symbols.applicable_accessibilities = private +dotnet_naming_symbols.private_static_readonly_symbols.applicable_kinds = field +dotnet_naming_symbols.private_static_readonly_symbols.required_modifiers = static, readonly +dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_other_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:none +dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion +dotnet_style_predefined_type_for_member_access = true:suggestion +dotnet_style_qualification_for_event = false:suggestion +dotnet_style_qualification_for_field = false:suggestion +dotnet_style_qualification_for_method = false:suggestion +dotnet_style_qualification_for_property = false:suggestion +dotnet_style_require_accessibility_modifiers = for_non_interface_members:suggestion + +# ReSharper inspection severities +resharper_arrange_redundant_parentheses_highlighting = hint +resharper_arrange_this_qualifier_highlighting = hint +resharper_arrange_type_member_modifiers_highlighting = hint +resharper_arrange_type_modifiers_highlighting = hint +resharper_built_in_type_reference_style_for_member_access_highlighting = hint +resharper_built_in_type_reference_style_highlighting = hint +resharper_redundant_base_qualifier_highlighting = warning +charset = utf-8 +end_of_line = crlf +resharper_suggest_var_or_type_built_in_types_highlighting = hint +resharper_suggest_var_or_type_elsewhere_highlighting = hint +resharper_suggest_var_or_type_simple_types_highlighting = hint +resharper_web_config_module_not_resolved_highlighting = warning +resharper_web_config_type_not_resolved_highlighting = warning +resharper_web_config_wrong_module_highlighting = warning + +# ReSharper properties +resharper_autodetect_indent_settings = true +resharper_blank_lines_around_single_line_local_method = 1 +resharper_place_accessorholder_attribute_on_same_line = false +resharper_place_accessor_attribute_on_same_line = false +resharper_place_simple_initializer_on_single_line = false +resharper_use_indent_from_vs = false +resharper_wrap_object_and_collection_initializer_style = chop_always + +######################### +# File Extension Settings +######################### + +[*.tf] +indent_size = 2 + +# Visual Studio Solution Files +[*.sln] +indent_style = tab + +# Visual Studio XML Project Files +[*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,projitems,shproj}] +indent_size = 2 + +# XML Configuration Files +[*.{xml,config,props,targets,nuspec,resx,ruleset,vsixmanifest,vsct}] +indent_size = 2 + +# JSON Files +[*.{json,json5}] +indent_size = 2 + +# YAML Files +[*.{yml,yaml}] +indent_size = 2 +indent_style = space +indent_size = 2 + +# Markdown Files +[*.md] +trim_trailing_whitespace = false + +# Web Files +[*.{htm,html,js,ts,tsx,css,sass,scss,less,svg,vue}] +indent_size = 2 +insert_final_newline = true +html_space_before_self_closing = true + +# Batch Files +[*.{cmd,bat}] + +# Bash Files +[*.sh] +end_of_line = lf + +########################### +# .NET Language Conventions +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#language-conventions +########################### + +# .NET Code Style Settings +[*.{cs,csx,cake,vb}] +# "this." and "Me." qualifiers +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#this_and_me +dotnet_style_qualification_for_field = false:none +dotnet_style_qualification_for_property = false:none +dotnet_style_qualification_for_method = false:none +dotnet_style_qualification_for_event = false:none + +# Language keywords instead of framework type names for type references +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#language_keywords +dotnet_style_predefined_type_for_locals_parameters_members = true:warning +dotnet_style_predefined_type_for_member_access = true:warning + +# Modifier preferences +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#normalize_modifiers +dotnet_style_require_accessibility_modifiers = always:suggestion +csharp_preferred_modifier_order = public, private, protected, internal, static, extern, new, virtual, abstract, sealed, override, readonly, unsafe, volatile, async:none +visual_basic_preferred_modifier_order = Partial, Default, Private, Protected, Public, Friend, NotOverridable, Overridable, MustOverride, Overloads, Overrides, MustInherit, NotInheritable, Static, Shared, Shadows, ReadOnly, WriteOnly, Dim, Const, WithEvents, Widening, Narrowing, Custom, Async:none +dotnet_style_readonly_field = true:suggestion + +# Parentheses preferences +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#parentheses +dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_other_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_other_operators = never_if_unnecessary:none + +# Expression-level preferences +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#expression_level +dotnet_style_object_initializer = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_explicit_tuple_names = true:suggestion +dotnet_style_prefer_inferred_tuple_names = true:suggestion +dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion +dotnet_style_prefer_auto_properties = true:suggestion +dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion +dotnet_style_prefer_conditional_expression_over_assignment = false:none +dotnet_style_prefer_conditional_expression_over_return = false:none + +# Null-checking preferences +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#null_checking +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion + +# C# Code Style Settings +[*.{cs,csx,cake}] +# Implicit and explicit types +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#implicit-and-explicit-types +csharp_style_var_for_built_in_types = true:warning +csharp_style_var_when_type_is_apparent = true:warning +csharp_style_var_elsewhere = true:warning + +# Expression-bodied members +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#expression_bodied_members +csharp_style_expression_bodied_methods = false:none +csharp_style_expression_bodied_constructors = false:none +csharp_style_expression_bodied_operators = false:none +csharp_style_expression_bodied_properties = false:none +csharp_style_expression_bodied_indexers = false:none +csharp_style_expression_bodied_accessors = false:none + +# Pattern matching +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#pattern_matching +csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion +csharp_style_pattern_matching_over_as_with_null_check = true:suggestion + +# Inlined variable declarations +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#inlined_variable_declarations +csharp_style_inlined_variable_declaration = true:suggestion + +# Expression-level preferences +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#expression_level_csharp +csharp_prefer_simple_default_expression = true:suggestion +csharp_style_deconstructed_variable_declaration = false:none +csharp_style_pattern_local_over_anonymous_function = false:none + +# "Null" checking preferences +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#null_checking_csharp +csharp_style_throw_expression = true:suggestion +csharp_style_conditional_delegate_call = true:suggestion + +# Code block preferences +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#code_block +csharp_prefer_braces = false:none + +############################# +# .NET Formatting Conventions +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#formatting-conventions +############################# + +# Organize usings +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#usings +dotnet_sort_system_directives_first = true + +# C# formatting settings +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#c-formatting-settings +csharp_new_line_before_open_brace = all +csharp_new_line_before_else = true +csharp_new_line_before_catch = true +csharp_new_line_before_finally = true +csharp_new_line_before_members_in_object_initializers = true +csharp_new_line_before_members_in_anonymous_types = true +csharp_new_line_between_query_expression_clauses = true + +# Indentation options +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#indent +csharp_indent_case_contents = true +csharp_indent_switch_labels = true +csharp_indent_labels = no_change + +# Spacing options +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#spacing +csharp_space_after_cast = false +csharp_space_after_keywords_in_control_flow_statements = true +csharp_space_between_method_declaration_parameter_list_parentheses = false +csharp_space_between_method_call_parameter_list_parentheses = false +csharp_space_between_parentheses = false +csharp_space_before_colon_in_inheritance_clause = true +csharp_space_after_colon_in_inheritance_clause = true +csharp_space_around_binary_operators = ignore +csharp_space_between_method_declaration_empty_parameter_list_parentheses = false +csharp_space_between_method_call_name_and_opening_parenthesis = false +csharp_space_between_method_call_empty_parameter_list_parentheses = false + +# Wrapping options +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference#wrapping +csharp_preserve_single_line_statements = false +csharp_preserve_single_line_blocks = true + +# More Indentation options (Undocumented) +csharp_indent_block_contents = true +csharp_indent_braces = false + +# Spacing Options (Undocumented) +csharp_space_after_comma = true +csharp_space_after_dot = false +csharp_space_after_semicolon_in_for_statement = true +csharp_space_around_declaration_statements = do_not_ignore +csharp_space_before_comma = false +csharp_space_before_dot = false +csharp_space_before_semicolon_in_for_statement = false +csharp_space_before_open_square_brackets = false +csharp_space_between_empty_square_brackets = false +csharp_space_between_method_declaration_name_and_open_parenthesis = false +csharp_space_between_square_brackets = false + +######################### +# .NET Naming conventions +# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-naming-conventions +######################### + +[*.{cs,csx,cake,vb}] +# Naming Symbols +# constant_fields - Define constant fields +dotnet_naming_symbols.constant_fields.applicable_kinds = field +dotnet_naming_symbols.constant_fields.required_modifiers = const +# non_private_readonly_fields - Define public, internal and protected readonly fields +dotnet_naming_symbols.non_private_readonly_fields.applicable_accessibilities = public, internal, protected +dotnet_naming_symbols.non_private_readonly_fields.applicable_kinds = field +dotnet_naming_symbols.non_private_readonly_fields.required_modifiers = readonly +# static_readonly_fields - Define static and readonly fields +dotnet_naming_symbols.static_readonly_fields.applicable_kinds = field +dotnet_naming_symbols.static_readonly_fields.required_modifiers = static, readonly +# private_readonly_fields - Define private readonly fields +dotnet_naming_symbols.private_readonly_fields.applicable_accessibilities = private +dotnet_naming_symbols.private_readonly_fields.applicable_kinds = field +dotnet_naming_symbols.private_readonly_fields.required_modifiers = readonly +# public_internal_fields - Define public and internal fields +dotnet_naming_symbols.public_internal_fields.applicable_accessibilities = public, internal +dotnet_naming_symbols.public_internal_fields.applicable_kinds = field +# private_protected_fields - Define private and protected fields +dotnet_naming_symbols.private_protected_fields.applicable_accessibilities = private, protected +dotnet_naming_symbols.private_protected_fields.applicable_kinds = field +# public_symbols - Define any public symbol +dotnet_naming_symbols.public_symbols.applicable_accessibilities = public, internal, protected, protected_internal +dotnet_naming_symbols.public_symbols.applicable_kinds = method, property, event, delegate +# parameters - Defines any parameter +dotnet_naming_symbols.parameters.applicable_kinds = parameter +# non_interface_types - Defines class, struct, enum and delegate types +dotnet_naming_symbols.non_interface_types.applicable_kinds = class, struct, enum, delegate +# interface_types - Defines interfaces +dotnet_naming_symbols.interface_types.applicable_kinds = interface + +# Naming Styles +# camel_case - Define the camelCase style +dotnet_naming_style.camel_case.capitalization = camel_case +# underscore_prefix - The first character must be prefixed with an underscore +dotnet_naming_style.underscore_prefix.capitalization = camel_case +dotnet_naming_style.underscore_prefix.required_prefix = _ +# pascal_case - Define the Pascal_case style +dotnet_naming_style.pascal_case.capitalization = pascal_case +# first_upper - The first character must start with an upper-case character +dotnet_naming_style.first_upper.capitalization = first_word_upper +# prefix_interface_interface_with_i - Interfaces must be PascalCase and the first character of an interface must be an 'I' +dotnet_naming_style.prefix_interface_interface_with_i.capitalization = pascal_case +dotnet_naming_style.prefix_interface_interface_with_i.required_prefix = I + +# Naming Rules +# Constant fields must be PascalCase +dotnet_naming_rule.constant_fields_must_be_pascal_case.severity = warning +dotnet_naming_rule.constant_fields_must_be_pascal_case.symbols = constant_fields +dotnet_naming_rule.constant_fields_must_be_pascal_case.style = pascal_case +# Public, internal and protected readonly fields must be PascalCase +dotnet_naming_rule.non_private_readonly_fields_must_be_pascal_case.severity = warning +dotnet_naming_rule.non_private_readonly_fields_must_be_pascal_case.symbols = non_private_readonly_fields +dotnet_naming_rule.non_private_readonly_fields_must_be_pascal_case.style = pascal_case +# Static readonly fields must be PascalCase +dotnet_naming_rule.static_readonly_fields_must_be_pascal_case.severity = warning +dotnet_naming_rule.static_readonly_fields_must_be_pascal_case.symbols = static_readonly_fields +dotnet_naming_rule.static_readonly_fields_must_be_pascal_case.style = pascal_case +# Private readonly fields must be camelCase +dotnet_naming_rule.private_readonly_fields_must_be_camel_case.severity = warning +dotnet_naming_rule.private_readonly_fields_must_be_camel_case.symbols = private_readonly_fields +dotnet_naming_rule.private_readonly_fields_must_be_camel_case.style = camel_case +dotnet_naming_rule.private_readonly_fields_must_be_camel_case.style = underscore_prefix +# Public and internal fields must be PascalCase +dotnet_naming_rule.public_internal_fields_must_be_pascal_case.severity = warning +dotnet_naming_rule.public_internal_fields_must_be_pascal_case.symbols = public_internal_fields +dotnet_naming_rule.public_internal_fields_must_be_pascal_case.style = pascal_case +# Private and protected fields must be camelCase +dotnet_naming_rule.private_protected_fields_must_be_camel_case.severity = warning +dotnet_naming_rule.private_protected_fields_must_be_camel_case.symbols = private_protected_fields +dotnet_naming_rule.private_protected_fields_must_be_camel_case.style = camel_case +# Public members must be capitalized +dotnet_naming_rule.public_members_must_be_capitalized.severity = warning +dotnet_naming_rule.public_members_must_be_capitalized.symbols = public_symbols +dotnet_naming_rule.public_members_must_be_capitalized.style = first_upper +# Parameters must be camelCase +dotnet_naming_rule.parameters_must_be_camel_case.severity = warning +dotnet_naming_rule.parameters_must_be_camel_case.symbols = parameters +dotnet_naming_rule.parameters_must_be_camel_case.style = camel_case +# Class, struct, enum and delegates must be PascalCase +dotnet_naming_rule.non_interface_types_must_be_pascal_case.severity = warning +dotnet_naming_rule.non_interface_types_must_be_pascal_case.symbols = non_interface_types +dotnet_naming_rule.non_interface_types_must_be_pascal_case.style = pascal_case +# Interfaces must be PascalCase and start with an 'I' +dotnet_naming_rule.interface_types_must_be_prefixed_with_i.severity = warning +dotnet_naming_rule.interface_types_must_be_prefixed_with_i.symbols = interface_types +dotnet_naming_rule.interface_types_must_be_prefixed_with_i.style = prefix_interface_interface_with_i + +[*.proto] +indent_style = tab +indent_size = tab +tab_width = 4 + +[*.{asax, ascx, aspx, cs, cshtml, css, htm, html, js, jsx, master, razor, skin, ts, tsx, vb, xaml, xamlx, xoml}] +indent_style = space +indent_size = 4 +tab_width = 4 + +[*.{appxmanifest, build, config, csproj, dbml, discomap, dtd, json, jsproj, lsproj, njsproj, nuspec, proj, props, resjson, resw, resx, StyleCop, targets, tasks, vbproj, xml, xsd}] +indent_style = space +indent_size = 2 +tab_width = 2 + +[{tsconfig.json, tsconfig.spec.json, tsconfig.lib.json, tsconfig.app.json, tsconfig.e2e.json}] +indent_style = space +indent_size = 2 + +[*.scss] +indent_style = space +indent_size = 2 + +[{.babelrc, .eslintrc, jest.config, bowerrc, .stylelintrc, *.jsb3, *.jsb2, *.json}] +indent_style = space +indent_size = 2 + +[{*.coffee, *.cjsx}] +indent_style = space +indent_size = 2 + +[*.{appxmanifest, asax, ascx, aspx, build, cs, cshtml, dtd, fs, fsi, fsscript, fsx, master, ml, mli, nuspec, razor, resw, resx, skin, vb, xaml, xamlx, xoml, xsd}] +indent_style = space +indent_size = 4 +tab_width = 4 \ No newline at end of file diff --git a/PresenceClient/PresenceClient-GUI/App.config b/PresenceClient/PresenceClient-GUI/App.config new file mode 100644 index 0000000..b187512 --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/App.config @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/PresenceClient/PresenceClient-GUI/Config.cs b/PresenceClient/PresenceClient-GUI/Config.cs new file mode 100644 index 0000000..3338e3c --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/Config.cs @@ -0,0 +1,7 @@ +namespace PresenceClient_GUI; + +public class Config +{ + public string Ip, Client, BigKey, BigText, SmallKey, State; + public bool DisplayTimer, AllowTray, DisplayMainMenu, SeenAutoMacPrompt, AutoToMac; +} \ No newline at end of file diff --git a/PresenceClient/PresenceClient-GUI/MainForm.Designer.cs b/PresenceClient/PresenceClient-GUI/MainForm.Designer.cs new file mode 100644 index 0000000..c6971e7 --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/MainForm.Designer.cs @@ -0,0 +1,341 @@ +using System.ComponentModel; +using System.Windows.Forms; + +namespace PresenceClient_GUI +{ + partial class MainForm + { + /// + /// Required designer variable. + /// + private IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm)); + this.connectButton = new System.Windows.Forms.Button(); + this.clientBox = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.linkLabel1 = new System.Windows.Forms.LinkLabel(); + this.checkTime = new System.Windows.Forms.CheckBox(); + this.label2 = new System.Windows.Forms.Label(); + this.stateBox = new System.Windows.Forms.TextBox(); + this.label3 = new System.Windows.Forms.Label(); + this.smallKeyBox = new System.Windows.Forms.TextBox(); + this.label4 = new System.Windows.Forms.Label(); + this.bigKeyBox = new System.Windows.Forms.TextBox(); + this.label5 = new System.Windows.Forms.Label(); + this.bigTextBox = new System.Windows.Forms.TextBox(); + this.statusLabel = new System.Windows.Forms.Label(); + this.trayIcon = new System.Windows.Forms.NotifyIcon(this.components); + this.trayContextMenu = new System.Windows.Forms.ContextMenuStrip(this.components); + this.connectToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.trayExitMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.checkTray = new System.Windows.Forms.CheckBox(); + this.checkMainMenu = new System.Windows.Forms.CheckBox(); + this.addressBox = new System.Windows.Forms.TextBox(); + this.UseMacDefault = new System.Windows.Forms.CheckBox(); + this.trayContextMenu.SuspendLayout(); + this.SuspendLayout(); + // + // connectButton + // + this.connectButton.Location = new System.Drawing.Point(88, 302); + this.connectButton.Name = "connectButton"; + this.connectButton.Size = new System.Drawing.Size(75, 23); + this.connectButton.TabIndex = 13; + this.connectButton.Text = "Connect"; + this.connectButton.UseVisualStyleBackColor = true; + this.connectButton.Click += new System.EventHandler(this.ConnectButton_Click); + // + // clientBox + // + this.clientBox.Location = new System.Drawing.Point(78, 73); + this.clientBox.MaxLength = 20; + this.clientBox.Name = "clientBox"; + this.clientBox.Size = new System.Drawing.Size(100, 20); + this.clientBox.TabIndex = 3; + this.clientBox.TextChanged += new System.EventHandler(this.clientBox_TextChanged); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(78, 18); + this.label1.MinimumSize = new System.Drawing.Size(100, 0); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(100, 13); + this.label1.TabIndex = 0; + this.label1.Text = "IP or MAC Address"; + this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // linkLabel1 + // + this.linkLabel1.AutoSize = true; + this.linkLabel1.Location = new System.Drawing.Point(78, 58); + this.linkLabel1.MinimumSize = new System.Drawing.Size(100, 0); + this.linkLabel1.Name = "linkLabel1"; + this.linkLabel1.Size = new System.Drawing.Size(100, 13); + this.linkLabel1.TabIndex = 16; + this.linkLabel1.TabStop = true; + this.linkLabel1.Text = "Client ID"; + this.linkLabel1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + this.linkLabel1.VisitedLinkColor = System.Drawing.Color.Blue; + this.linkLabel1.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.LinkLabel1_LinkClicked_1); + // + // checkTime + // + this.checkTime.AutoSize = true; + this.checkTime.Checked = true; + this.checkTime.CheckState = System.Windows.Forms.CheckState.Checked; + this.checkTime.Location = new System.Drawing.Point(40, 331); + this.checkTime.Name = "checkTime"; + this.checkTime.Size = new System.Drawing.Size(117, 17); + this.checkTime.TabIndex = 14; + this.checkTime.Text = "Show Time Lapsed"; + this.checkTime.UseVisualStyleBackColor = true; + this.checkTime.CheckedChanged += new System.EventHandler(this.CheckTime_CheckedChanged); + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(78, 219); + this.label2.MinimumSize = new System.Drawing.Size(100, 0); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(100, 13); + this.label2.TabIndex = 10; + this.label2.Text = "State Text"; + this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // stateBox + // + this.stateBox.Location = new System.Drawing.Point(78, 235); + this.stateBox.MaxLength = 128; + this.stateBox.Name = "stateBox"; + this.stateBox.Size = new System.Drawing.Size(100, 20); + this.stateBox.TabIndex = 11; + this.stateBox.TextChanged += new System.EventHandler(this.StateBox_TextChanged); + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(78, 180); + this.label3.MinimumSize = new System.Drawing.Size(100, 0); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(100, 13); + this.label3.TabIndex = 8; + this.label3.Text = "Small Image Key"; + this.label3.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // smallKeyBox + // + this.smallKeyBox.Location = new System.Drawing.Point(78, 196); + this.smallKeyBox.MaxLength = 32; + this.smallKeyBox.Name = "smallKeyBox"; + this.smallKeyBox.Size = new System.Drawing.Size(100, 20); + this.smallKeyBox.TabIndex = 9; + this.smallKeyBox.TextChanged += new System.EventHandler(this.SKeyBox_TextChanged); + // + // label4 + // + this.label4.AutoSize = true; + this.label4.Location = new System.Drawing.Point(78, 96); + this.label4.MinimumSize = new System.Drawing.Size(100, 0); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(100, 13); + this.label4.TabIndex = 4; + this.label4.Text = "Large Image Key"; + this.label4.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // bigKeyBox + // + this.bigKeyBox.Location = new System.Drawing.Point(78, 112); + this.bigKeyBox.MaxLength = 32; + this.bigKeyBox.Name = "bigKeyBox"; + this.bigKeyBox.Size = new System.Drawing.Size(100, 20); + this.bigKeyBox.TabIndex = 5; + this.bigKeyBox.TextChanged += new System.EventHandler(this.BigKeyBox_TextChanged); + // + // label5 + // + this.label5.AutoSize = true; + this.label5.Location = new System.Drawing.Point(78, 140); + this.label5.MinimumSize = new System.Drawing.Size(100, 0); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(100, 13); + this.label5.TabIndex = 6; + this.label5.Text = "Large Image Text"; + this.label5.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // bigTextBox + // + this.bigTextBox.Location = new System.Drawing.Point(78, 156); + this.bigTextBox.MaxLength = 128; + this.bigTextBox.Name = "bigTextBox"; + this.bigTextBox.Size = new System.Drawing.Size(100, 20); + this.bigTextBox.TabIndex = 7; + this.bigTextBox.TextChanged += new System.EventHandler(this.BigTextBox_TextChanged); + // + // statusLabel + // + this.statusLabel.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.statusLabel.ForeColor = System.Drawing.Color.Red; + this.statusLabel.Location = new System.Drawing.Point(28, 258); + this.statusLabel.Name = "statusLabel"; + this.statusLabel.Size = new System.Drawing.Size(200, 40); + this.statusLabel.TabIndex = 12; + this.statusLabel.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // trayIcon + // + this.trayIcon.ContextMenuStrip = this.trayContextMenu; + this.trayIcon.Icon = ((System.Drawing.Icon)(resources.GetObject("trayIcon.Icon"))); + this.trayIcon.Text = "PresenceClient (Disconnected)"; + this.trayIcon.Visible = true; + this.trayIcon.MouseDoubleClick += new System.Windows.Forms.MouseEventHandler(this.TrayIcon_MouseDoubleClick); + // + // trayContextMenu + // + this.trayContextMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.connectToolStripMenuItem, + this.trayExitMenuItem}); + this.trayContextMenu.Name = "trayContextMenu"; + this.trayContextMenu.Size = new System.Drawing.Size(120, 48); + // + // connectToolStripMenuItem + // + this.connectToolStripMenuItem.Name = "connectToolStripMenuItem"; + this.connectToolStripMenuItem.Size = new System.Drawing.Size(119, 22); + this.connectToolStripMenuItem.Text = "Connect"; + this.connectToolStripMenuItem.Click += new System.EventHandler(this.ConnectButton_Click); + // + // trayExitMenuItem + // + this.trayExitMenuItem.Name = "trayExitMenuItem"; + this.trayExitMenuItem.Size = new System.Drawing.Size(119, 22); + this.trayExitMenuItem.Text = "Exit"; + this.trayExitMenuItem.Click += new System.EventHandler(this.TrayExitMenuItem_Click); + // + // checkTray + // + this.checkTray.AutoSize = true; + this.checkTray.Location = new System.Drawing.Point(40, 354); + this.checkTray.Name = "checkTray"; + this.checkTray.Size = new System.Drawing.Size(102, 17); + this.checkTray.TabIndex = 15; + this.checkTray.Text = "Minimize to Tray"; + this.checkTray.UseVisualStyleBackColor = true; + // + // checkMainMenu + // + this.checkMainMenu.AutoSize = true; + this.checkMainMenu.Checked = true; + this.checkMainMenu.CheckState = System.Windows.Forms.CheckState.Checked; + this.checkMainMenu.Location = new System.Drawing.Point(40, 377); + this.checkMainMenu.Name = "checkMainMenu"; + this.checkMainMenu.Size = new System.Drawing.Size(175, 17); + this.checkMainMenu.TabIndex = 18; + this.checkMainMenu.Text = "Display Home Menu as a status"; + this.checkMainMenu.UseVisualStyleBackColor = true; + this.checkMainMenu.CheckedChanged += new System.EventHandler(this.CheckMainMenu_CheckedChanged); + // + // addressBox + // + this.addressBox.Location = new System.Drawing.Point(78, 35); + this.addressBox.Name = "addressBox"; + this.addressBox.Size = new System.Drawing.Size(100, 20); + this.addressBox.TabIndex = 1; + // + // UseMacDefault + // + this.UseMacDefault.AutoSize = true; + this.UseMacDefault.Location = new System.Drawing.Point(40, 401); + this.UseMacDefault.Name = "UseMacDefault"; + this.UseMacDefault.Size = new System.Drawing.Size(178, 17); + this.UseMacDefault.TabIndex = 19; + this.UseMacDefault.Text = "Automatically convert IP to MAC"; + this.UseMacDefault.UseVisualStyleBackColor = true; + this.UseMacDefault.CheckedChanged += new System.EventHandler(this.UseMacDefault_CheckedChanged); + // + // MainForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(256, 437); + this.Controls.Add(this.UseMacDefault); + this.Controls.Add(this.checkMainMenu); + this.Controls.Add(this.checkTray); + this.Controls.Add(this.statusLabel); + this.Controls.Add(this.label5); + this.Controls.Add(this.bigTextBox); + this.Controls.Add(this.label4); + this.Controls.Add(this.bigKeyBox); + this.Controls.Add(this.label3); + this.Controls.Add(this.smallKeyBox); + this.Controls.Add(this.label2); + this.Controls.Add(this.stateBox); + this.Controls.Add(this.checkTime); + this.Controls.Add(this.linkLabel1); + this.Controls.Add(this.label1); + this.Controls.Add(this.clientBox); + this.Controls.Add(this.connectButton); + this.Controls.Add(this.addressBox); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.Fixed3D; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.Name = "MainForm"; + this.Text = "PresenceClient"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.MainForm_FormClosing); + this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.MainForm_FormClosed); + this.Load += new System.EventHandler(this.MainForm_Load); + this.trayContextMenu.ResumeLayout(false); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + private Button connectButton; + private TextBox clientBox; + private Label label1; + private LinkLabel linkLabel1; + private CheckBox checkTime; + private Label label2; + private TextBox stateBox; + private Label label3; + private TextBox smallKeyBox; + private Label label4; + private TextBox bigKeyBox; + private Label label5; + private TextBox bigTextBox; + private Label statusLabel; + private NotifyIcon trayIcon; + private ContextMenuStrip trayContextMenu; + private ToolStripMenuItem trayExitMenuItem; + private CheckBox checkTray; + private ToolStripMenuItem connectToolStripMenuItem; + private CheckBox checkMainMenu; + private TextBox addressBox; + private CheckBox UseMacDefault; + } +} + diff --git a/PresenceClient/PresenceClient-GUI/MainForm.cs b/PresenceClient/PresenceClient-GUI/MainForm.cs new file mode 100644 index 0000000..ed4bc6b --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/MainForm.cs @@ -0,0 +1,374 @@ +using System; +using System.Diagnostics; +using System.Drawing; +using System.IO; +using System.Media; +using System.Net; +using System.Net.Sockets; +using System.Threading; +using System.Timers; +using System.Windows.Forms; +using DiscordRPC; +using Newtonsoft.Json; +using PresenceClient_GUI.Properties; +using PresenceCommon.Types; +using Timer = System.Timers.Timer; +#if DEBUG +using DiscordRPC.Logging; +#endif + +namespace PresenceClient_GUI; + +public partial class MainForm : Form +{ + private Thread listenThread; + private static Socket client; + private static DiscordRpcClient rpc; + private IPAddress ipAddress; + private bool manualUpdate; + private string lastProgramName = string.Empty; + private Timestamps time; + private static Timer timer; + private bool hasSeenMacPrompt; + + public MainForm() + { + InitializeComponent(); + listenThread = new Thread(TryConnect); + } + + private void ConnectButton_Click(object sender, EventArgs e) + { + if (connectButton.Text == "Connect") + { + // Check and see if ClientID is empty + if (string.IsNullOrWhiteSpace(clientBox.Text)) + { + Show(); + Activate(); + UpdateStatus("Client ID cannot be empty", Color.DarkRed); + SystemSounds.Exclamation.Play(); + return; + } + + // Check and see if we have an IP + // If we have an IP, prompt to swap to MAC Address + if (IPAddress.TryParse(addressBox.Text, out ipAddress)) + { + if (!hasSeenMacPrompt) + { + hasSeenMacPrompt = true; + + var message = "We've detected that you're using an IP to connect to your device. Connecting via MAC address may make it easier to reconnect to your device in case the IP changes." + + "\n\nWould you like to swap to connecting via MAC address? \n(We'll only ask this once.)"; + + if (MessageBox.Show(message, "IP Detected", MessageBoxButtons.YesNo) == DialogResult.Yes) + { + UseMacDefault.Checked = true; + IpToMac(); + } + else + UseMacDefault.Checked = false; + } + else if (UseMacDefault.Checked) + IpToMac(); + } + else + { + // If in this block, means we dont have a valid IP. + // Check and see if it's a MAC Address + try + { + IPAddress.TryParse(Utils.GetIpByMac(addressBox.Text), out ipAddress); + } + catch (FormatException) + { + Show(); + Activate(); + UpdateStatus("Invalid IP or MAC Address", Color.DarkRed); + SystemSounds.Exclamation.Play(); + return; + } + } + + listenThread.Start(); + + connectButton.Text = "Disconnect"; + connectToolStripMenuItem.Text = "Disconnect"; + + addressBox.Enabled = false; + clientBox.Enabled = false; + } + else + { + listenThread.Abort(); + if (rpc != null && !rpc.IsDisposed) + { + rpc.ClearPresence(); + rpc.Dispose(); + } + + if (client != null) client.Close(); + if (timer != null) timer.Dispose(); + listenThread = new Thread(TryConnect); + UpdateStatus("", Color.Gray); + connectButton.Text = "Connect"; + connectToolStripMenuItem.Text = "Connect"; + trayIcon.Icon = Resources.Disconnected; + trayIcon.Text = "PresenceClient (Disconnected)"; + + ipAddress = null; + addressBox.Enabled = true; + clientBox.Enabled = true; + lastProgramName = string.Empty; + time = null; + } + } + + private void OnConnectTimeout(object source, ElapsedEventArgs e) + { + lastProgramName = string.Empty; + time = null; + } + + private void TryConnect() + { + if (rpc != null && !rpc.IsDisposed) + { + rpc.ClearPresence(); + rpc.Dispose(); + } + + rpc = new DiscordRpcClient(clientBox.Text); + rpc.Initialize(); + + //Create a timer that will be enabled when we lose connection to the server. + //Once the full time has passed, it will clear the info it had of the previous game + timer = new Timer + { + Interval = 60000, + SynchronizingObject = this, + Enabled = false, + }; + timer.Elapsed += OnConnectTimeout; + +#if DEBUG + rpc.Logger = new ConsoleLogger { Level = LogLevel.Warning }; + //Subscribe to events + rpc.OnReady += (_, obj) => + { + Console.WriteLine("Received Ready from user {0}", obj.User.Username); + }; + + rpc.OnPresenceUpdate += (_, obj) => + { + Console.WriteLine("Received Update! {0}", obj.Presence); + }; +#endif + + while (true) + { + client = new Socket(SocketType.Stream, ProtocolType.Tcp) + { + ReceiveTimeout = 5500, + SendTimeout = 5500, + }; + + UpdateStatus("Attemping to connect to server...", Color.Gray); + trayIcon.Icon = Resources.Disconnected; + trayIcon.Text = "PresenceClient (Connecting...)"; + timer.Enabled = true; + + try + { + var localEndPoint = new IPEndPoint(ipAddress, 0xCAFE); + + var result = client.BeginConnect(localEndPoint, null, null); + var success = result.AsyncWaitHandle.WaitOne(2000, true); + if (!success) + { + //UpdateStatus("Could not connect to Server! Retrying...", Color.DarkRed); + client.Close(); + } + else + { + client.EndConnect(result); + timer.Enabled = false; + + DataListen(); + } + } + catch (ArgumentNullException) + { + //The ip address is null because arp couldn't find the target mac address. + //So we sleep and search for it again. + Thread.Sleep(1000); + IPAddress.TryParse(Utils.GetIpByMac(addressBox.Text), out ipAddress); + } + catch (SocketException) + { + client.Close(); + if (rpc != null && !rpc.IsDisposed) rpc.ClearPresence(); + } + } + } + + private void DataListen() + { + manualUpdate = true; + while (true) + { + try + { + var bytes = PresenceCommon.Utils.ReceiveExactly(client); + UpdateStatus("Connected to the server!", Color.Green); + trayIcon.Icon = Resources.Connected; + trayIcon.Text = "PresenceClient (Connected)"; + + var title = new Title(bytes); + if (title.Magic == 0xffaadd23) + { + if (lastProgramName != title.Name) + { + time = Timestamps.Now; + } + if ((lastProgramName != title.Name) || manualUpdate) + { + if (rpc != null) + { + + if (!checkMainMenu.Checked && title.Name == "Home Menu") + rpc.ClearPresence(); + else + { + rpc.SetPresence(PresenceCommon.Utils.CreateDiscordPresence(title, time, bigKeyBox.Text, bigTextBox.Text, smallKeyBox.Text, stateBox.Text, checkTime.Checked)); + } + } + manualUpdate = false; + lastProgramName = title.Name; + } + } + else + { + if (rpc != null && !rpc.IsDisposed) rpc.ClearPresence(); + client.Close(); + return; + } + } + catch (SocketException) + { + if (rpc != null && !rpc.IsDisposed) rpc.ClearPresence(); + client.Close(); + return; + } + } + } + + private void IpToMac() + { + var macAddress = Utils.GetMacByIp(ipAddress.ToString()); + if (macAddress != null) + addressBox.Text = macAddress; + else + MessageBox.Show("Can't convert to MAC Address! Sorry!"); + } + + private void MainForm_Load(object sender, EventArgs e) + { + if (File.Exists("Config.json")) + { + var cfg = JsonConvert.DeserializeObject(File.ReadAllText("Config.json")); + checkTime.Checked = cfg.DisplayTimer; + bigKeyBox.Text = cfg.BigKey; + bigTextBox.Text = cfg.BigText; + smallKeyBox.Text = cfg.SmallKey; + addressBox.Text = cfg.Ip; + stateBox.Text = cfg.State; + clientBox.Text = cfg.Client; + checkTray.Checked = cfg.AllowTray; + checkMainMenu.Checked = cfg.DisplayMainMenu; + hasSeenMacPrompt = cfg.SeenAutoMacPrompt; + UseMacDefault.Checked = cfg.AutoToMac; + } + } + + private void MainForm_FormClosed(object sender, FormClosedEventArgs e) + { + listenThread.Abort(); + if (rpc != null && !rpc.IsDisposed) + { + rpc.ClearPresence(); + rpc.Dispose(); + } + + if (client != null) client.Close(); + } + + private void MainForm_FormClosing(object sender, FormClosingEventArgs e) + { + if (e.CloseReason == CloseReason.UserClosing && checkTray.Checked) + { + e.Cancel = true; + Hide(); + } + else + { + if (timer != null) timer.Dispose(); + + var cfg = new Config + { + Ip = addressBox.Text, + Client = clientBox.Text, + BigKey = bigKeyBox.Text, + SmallKey = smallKeyBox.Text, + State = stateBox.Text, + BigText = bigTextBox.Text, + DisplayTimer = checkTime.Checked, + AllowTray = checkTray.Checked, + DisplayMainMenu = checkMainMenu.Checked, + SeenAutoMacPrompt = hasSeenMacPrompt, + AutoToMac = UseMacDefault.Checked + }; + File.WriteAllText("Config.json", JsonConvert.SerializeObject(cfg, Formatting.Indented)); + } + } + + private void TrayIcon_MouseDoubleClick(object sender, MouseEventArgs e) + { + Show(); + Activate(); + } + + private void UpdateStatus(string text, Color color) + { + MethodInvoker inv = () => + { + statusLabel.Text = text; + statusLabel.ForeColor = color; + }; + Invoke(inv); + } + + private void CheckTime_CheckedChanged(object sender, EventArgs e) => manualUpdate = true; + + private void BigKeyBox_TextChanged(object sender, EventArgs e) => manualUpdate = true; + + private void SKeyBox_TextChanged(object sender, EventArgs e) => manualUpdate = true; + + private void StateBox_TextChanged(object sender, EventArgs e) => manualUpdate = true; + + private void BigTextBox_TextChanged(object sender, EventArgs e) => manualUpdate = true; + + private void TrayExitMenuItem_Click(object sender, EventArgs e) => Application.Exit(); + + private void LinkLabel1_LinkClicked_1(object sender, LinkLabelLinkClickedEventArgs e) => Process.Start($"https://discordapp.com/developers/applications/{clientBox.Text}"); + + private void CheckMainMenu_CheckedChanged(object sender, EventArgs e) => manualUpdate = true; + + private void UseMacDefault_CheckedChanged(object sender, EventArgs e) => hasSeenMacPrompt = true; + + private void clientBox_TextChanged(object sender, EventArgs e) + { + + } +} \ No newline at end of file diff --git a/PresenceClient/PresenceClient-GUI/MainForm.resx b/PresenceClient/PresenceClient-GUI/MainForm.resx new file mode 100644 index 0000000..4721b5c --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/MainForm.resx @@ -0,0 +1,3384 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + 112, 17 + + + + + AAABAAUAEBAAAAEAIABoBAAAVgAAABgYAAABACAAiAkAAL4EAAAgIAAAAQAgAKgQAABGDgAAMDAAAAEA + IACoJQAA7h4AAAAAAAABACAAtikBAJZEAAAoAAAAEAAAACAAAAABACAAAAAAAAAEAADDDgAAww4AAAAA + AAAAAAAAAAAAAAyOAQBolAAAM48AMnKUBZKVgAttkFAWHXGmlQ6Ko5cSi4aDEH47ZASnXHsAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA/wAALs8CAAD/AABLpAprhqAP9pKbLc6qyaHDt+PPyrnMtMeqqsqibVVwV24g + BBF8RSgAUAAAAAAAAAAAAAAAAAAAAAABAAAAAAAkCy8FqG2SFv2QnyD/qMN//8X13v/H38b/r6+7/3Ni + W/ltQi64ShAYM+1FXAAAAAAAAAAAAAEPAAAAAgAkJlAiwm6ER/+HjiL/iIIg/11yUf+f19f/rbPJ/3lb + Z/9lQ0X/ZT5C/zcQG9MAAAAzAQAAAAAAAAAAAAAJDDAKo3mpa/+emVf/hoMl/4GNX/9lkdn/aZXy/2qP + 6/9ojd7/Zl+e/1svVP88Hy7/EwkKuAAAABUCEQQAAAkCRiE0FPJudzf/gncw/39xNf9xg6z/Z4X4/2aA + 9f9mgfX/Z4r3/2eE5/9EN2v/Tm0m/2JUFfklBQ1t////AB5dMI+EkXb/e2c6/3pkN/9pOkv/WESO/4F5 + xP9tYs3/Xky9/11Sp/+Fca//TDJU/19/H/9jZB//PR0SwwAAAAo2flC5o6Gd/3hZQP90Vj//ZUE9/2Fu + b/+gmav/cV+6/1pCm/9XWnH/lpaj/1AvTv9WdyH/bG8g/z8jEPEFDgMUI0Eqx3l7af+JaV3/dFJL/25O + RP9oWWf/XliG/1900P9gZ7z/Y2R7/36Zvv9wbZv/WHBA/3mBFf8yFQ77hsWFlaGjg/C1t5H/yruc/7KT + g/+Pamj/fVpm/3J3o/92j87/iJ+3/6e0pP+twKD/o7+v/6utxv9cOET/CAEA7WvOe0ypxJPMx72b/8q0 + l//FrJL/xrqa/8jAm//M163/0eK5/9ruuv/K0LX/Y1fM/yQX4f8wJ/v/NhWj/wMAFrgrHCYAIUUlQEBP + P+2dmZr/lmOG/3hVcf+rvZr/2t+w/9LLov/T16b/d3fZ/w8B//8OAP//DgD//w4A+f8NANWYAAAAAAAA + AAUCCguSVXt5/7LI0P+OVJX/cGJ6/8bYqf/Vy6T/xbKa/z8x4/8NAP//EAD//xAA//8QAP//EAD/xwAA + AAAAAAAAAAAAGQcMEK5BWV/+i2yh/2Qobf+Eg4D/yMii/824m/9RPtj/DQD//xAA//8QAP//EAD//xAA + /6wAAAAAAAAAAAAAAAAAAAAXAQIHiS4ORudQEmj+Uxdp/1xIXf+NlnD/k3Oi/hwE6PYPAP/9EAD//hAA + /80QAP84AAAAAAAAAAAAAAAAAAEAAAAAAAUMAxs5JgY7iSkFOL4PABHTEysWw3xgW7o7BpBfDgD/chAA + /3EQAP8nEAD/AOAfAADwBwAA4AMAAMABAACAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAA + AADAAAAA4AAAAPABAAAoAAAAGAAAADAAAAABACAAAAAAAAAJAADDDgAAww4AAAAAAAAAAAAAAAAAAAAA + AAAAAAAADogBAACKAgUzigBXcoICh5VzBVSMPAggjgABAooIAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACJgBAP//AAAbowAaUKoGlYil + DPKXjg/Ul2MNeHChijqWtZRSoL+vVJi4sVSkm4pOnHGZLGQVZAr/4f8AGgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANogQAAKMCF1KlDsiSpxP/lJsT+5C+f/G9zaj7vu7T/LXk + 2/zCy6T6u8HU5np3vbVoOjFjaxYQFq1YPAA/AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALAAAAaCRqC+SIoBn/kJsV/5K0Q/+90Z7/xfTW/7zy6v/H1K3/ytrY/4WPyP90Xjn6ckQswmEa + IEgUAAACOwACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEBBwCSECQJ90VzFv+Klx7/jZYc/4eJ + KP+Pr3b/xfXa/8358f/IyLj/ro+E/3VaYP9rUTz/bFA+/18pLegfAARiAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACgASAJExbCX8lLN8/5mQN/+JjCL/io0h/3RRH/8qVkb/h83J/7PU6v+ejbb/aExc/2M9 + R/9iPUX/Yj9H/14tPf8dAgrtAAAAWwAAAAAAAAAAAAAAAAAAAAAAKAEAAAAAZiBeGvec2Z7/r6h8/4qF + J/+GhSf/h4ou/3aUoP9imej/aZry/2qX9P9okej/aJXm/2l4vf9iPG3/XS9O/10tTf8wDR3/AwEC3AAA + ADEAAAAAAAAAAAAAAAAAAAAjAAwA1UWFOv+hn23/iXww/4J8LP+Efin/gY1j/3CZ8f9qjvr/Z4f2/2iG + 9v9nhO7/aZT5/2yi/v9rf9z/WSxn/z0sQP9ARzL/PSkc/xMCB6AAAAAIAAAAAAEZAwAABwF1FyMN/jtK + Gv9xcy7/f3My/4B1Mf9+bDb/b4Ko/2qK+f9mgvX/Zn/1/2Z89P9lgfb/Zob3/2eL9f9nju//UD2G/yY5 + NP9oohj/iogP/0cbFukGAAJBAAEAAAAAAA0LRBe9fqOB/4xrSf93azb/fGw3/3xiOP9qKlH/VCh7/15V + pP9xZsn/ZmnW/2Nu6f9hVsz/XUmz/2Zaqf91Spj/SSJc/ylQMv9+mBX/ZHMf/1xCGv8dAAmPAAYBAAAA + ACgnfT7kstfN/5RpWf92ZDr/eV48/2w6N/9XM1H/UkWH/22Xqv/Sr9f/gUGR/1tMxP9WIG3/UTiD/22c + rv/Qt9f/cyRT/zhQMf97iBn/TUwx/1hVG/8oAwvOAAoBAAAAAEE1jlX0vsPL/4paUf9yWkD/dFtC/3RU + Qf9mQjH/W19G/4StnP+mgp3/aGCj/2Nq6P9aPX7/UEdZ/3OXhP+ch5X/UilQ/yQ6Nf9unBr/dXQk/2de + GP8mAwvwAAUAAAAAAE0jUjH4gXd2/35dUf9zUUj/cFFH/3FTSP9vUEP/aV9d/2FXe/9YWID/YXfd/2V4 + 9f9hY8L/WUhi/19off9ohb3/YEuf/ywnPf9KhSD/krIJ/3VTFv8ZAAj6btmEGkteRHE4Pi36YYdb/728 + nP+wkYL/iWFh/3RLT/9rR0n/a01W/2dRl/9ZWIr/W3CZ/2J36/9hbn3/c4CU/5i+0f+y4ej/u9fc/6+z + v/+AcHP/XmUq/0QjG/8GAAL1ac14rr3JofTKxKD/y8Og/8/DoP/Pw5//y7ea/7SMg/+UcW7/hVdg/3Vh + bf92i8j/eZLZ/4Ge4P+ctrT/tL2n/7Gyiv+lrHL/lq58/6bPwP/IzOn/g0Bn/wwAA/8AAADcNs1ZNorM + jbnFyqH91Maj/86+nf/Mt5j/yrKV/8u9mP/RxKL/ybWW/8fPoP/P37D/1eq8/9rwvP/d7rj/3Oax/8LB + sP9qXMn/KhnZ/x8W6P85Nv7/Yyy//xMAFv8AAACkT7hoACfISBdbkl2jjZp2/7eqkP++oJD/souH/6OK + g/+0r5b/yM2g/9rlsv/Y2az/1NOm/9bhrP/d8rj/0Nq9/1BH5v8OAP//DgD//w8A//8OAP//DwD9/wwA + o/UCACZZAAAAAAAGAgAAAwA5BhAJ6UplYv+uprf/klWL/2YoYv9iNmX/hZ+G/9Tos//Y2a3/0sqj/86/ + m//Q1aD/iIzS/xEC/v8QAP//EAD//xAA//8QAP//EAD//xAA/PgPAPZiAAAAAAAAAAAAAAAEAAAAjRcz + Mf+Uz8P/y+Xl/6R/r/9tH2//XEhs/6rTpf/a3K//1M6m/8+/nf/ItJX/UETa/w0A//8QAP//EAD//xAA + //8QAP//EAD//xAA//8QAP+kAAAAAAAAAAAAAAAAAAAAGwAAA7wfND3/gbmw/8Pw6P+5b7b/YRtq/3GB + ev/F3Kf/19Gn/9DBnf/Jspb/TTra/w0A//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP+pAAAAAAAA + AAAAAAAAAAAAAAAAACwAAAHDEBQg/05ccv+IVJ3/YSFr/10uYv98hH7/w86j/9PGof/OuJb/dF/D/w8A + //8QAP//EAD//xAA//8QAP//EAD//xAA//oQAP9tAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjAAAAoQwF + HfVEEWD/VxZu/1gVbf9WGWv/Z05w/4+Zfv/AuZL/tpmc/zgj5f8PAP//EAD//xAA//8QAP//EAD//xAA + /7QQAP8WAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAACwIDCVUZBy62OAlV60QLX/xGC2D/MAMz/wkT + DP9Ba0H/rpOB/24fc+MNANnAEAD/4hAA//AQAP/hEAD/lxAA/yAQAP8AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAwAAAAAOBwESPhACGXYOAhOfCAEIuQAAALQAEQSSVmlPp4wmPGUAAIwMEAD/KxAA + /z4QAP8oEAD/BhAA/wAAAAAA8D//APgAfwD8AB8A+AAHAPAAAwDgAAMA4AABAMAAAADAAAAAgAAAAIAA + AACAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAADAAAAAwAAAAOAAAADwAAAA+AAAAPwAAQD/AAMAKAAAACAA + AABAAAAAAQAgAAAAAAAAEAAAww4AAMMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGnAEAE4ACAAmH + ARQ4ggBndmwAaotYADmELgEVYgAAAnEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGp + AAALkwEAAJIBByWgAE1XogTGjqAI6JaJC8eUYgyHlSsFMaAAAAIMYjcDLGhhBkA+PQYzPjIGQFFIBkU6 + WQUrABEAJgARAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAwAAAOKgNAA+xBjFTrwrSkq0Q/5eiEf+Yewzeg4JMiX3EtZqrupGxrM64sqPQ + zLKluKuxsKaLqamRr3p/R5hBRxhIEgAAAAASAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArQAASpwYABWhCGtspRL8lqYU/5WjEv+Pqzf/odW7/8vL + nP/D9dX/uPnv/7vZy//J057/x9nc/pWU5fBmXonBaioXbmgOExsAAAAAQQADAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAzADECsEyVEv2SoBj/kJwY/46g + Fv+Zyn3/xMqb/8Tzz/+7+u//veTc/8jMnP/N5s7/pLT//3B6kP94Xiv7dEEqyWUZHlhAAAQITgELAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAWgAAANsBKwL/VZMX/5Ca + HP+OmRz/jpgX/4+2Xf/B0pz/yvTX/8L67//D7ef/yc6m/8/Mtf+ejLn/bFxa/3BaNf9xVzn/bDw08k8J + FYUDAAAOFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAGkEFgLtKU4Y/1x3 + LP9/kh7/jZIf/4uSH/+OjB//a00g/1yTWP+19dT/1vvz/9fz8f/Boqf/lmda/29JQv9oSUD/aElA/2dK + QP9pRUH/SxAe+QcAAJMAAAAPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQBgAAAABZBScD7EiX + Mf+p1aP/tp1i/4yLIf+JiyT/h4wj/4x0Hv9LJiD/FlVG/23Fvf+oyeP/psPi/5Fwpf9dS1//Yz5O/2E6 + Rv9iPEf/YTxH/2E9Sf9VGTH/DgAC+gAAAIcAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMgAW + ANo5jyr/qu22/7y5pf+SiCv/h4cn/4eHJ/+HiCX/h5FV/2aYzP9loO7/apzy/2ib9P9ol/P/Zpjs/2ma + 7P9phM3/ZlCJ/18vUv9eMU3/XTNP/14jRv8gAgz/AAAA8QAAAFoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAsAAAClDEgK/4XSgv+9uKb/lYI7/4WAKf+EgSv/hX4q/4SGMf97n7T/bp3//22U+v9pjfj/aY/4/2uG + 9P9nheH/aZv7/26k/v9soPf/aFKq/1snVv9TKk7/SSxE/zYmLf8hDxf/CAADzwAAACIAAAAAAAAAAAAA + AAAAAAAAAAAASwAAAPEQRA7/bohB/4l8Nf+CeSz/gHku/4B5Lv+DfCv/goxg/3KX7v9qjvn/aIb1/2WB + 9P9mgvX/Zn/0/2WG9f9nivb/aZP4/2uh/P9slvf/YDWI/zYlO/8sOzf/UXkp/21bIP83ERb+CQABfP8g + /wAAAAAAAAAAAAAAAAYABACiESgM/zkuE/88XB//enQz/39yM/9/dDL/gHMz/31mN/9sgaL/aY/5/2qI + +P9ngfX/Zn70/2Z98/9levP/ZYD0/2aE9v9nivj/aIz1/2aU8v9bSKH/Jx83/y5nMf+Buwz/lqcG/3ND + Hf8mAQ7OAAAAHwAAAAAAAgAAAAAAJgQ1DN5lqnX/pHVi/3ZqNP97bDf/fG02/31xN/9+WTr/aRtT/1Qf + cv9XQJT/YV2//2Fm1f9kdOP/ZXry/2Vy7v9kaOH/YVzR/2BRuv9iQp//XTGF/0omZf8iITr/OIcp/5Wc + D/9odCD/bXcY/0UOGPUEAABdAAAAAAANAgAAAQBVHXkv+aru1v+3goz/eWQ2/3loO/98ZTv/dlM4/2ku + O/9XMWT/UzeN/1FCgf+FobL/v3nA/3kvif9aZ9D/Xi2t/1cWbf9TF2b/U1B8/5m/w//MjcX/dR5c/zEi + O/9Ajyb/knsU/0Q4Nv9LeR3/Vx8Y/w8AA58AAAAAAUgJAAAOAH8znFL/vPHm/655hf93Wzr/dGE+/3hf + Pv9ySzv/ZTI0/1Y3Qf9RSW7/WHOR/53s2P/uu+r/kDV4/1ls1P9fMab/VDhl/1NUpP9SZJ//i97L/960 + 3v99JUn/PiA1/z2BLP+OjRP/WD82/018Iv9dKRn/EgAE1AAAAAAAAAACABIAmj2pZP/K2uj/pGRt/3VY + Qf9yWUL/c1pD/3VbRP92VUL/Z0Iq/1ldNf91nXv/oK+0/5VXdf9cYI7/Ynvy/2Ve3f9XNGD/Tjc+/110 + Vv+VsJ3/jmZy/1IxXP8iGjb/J2M0/4GuEP+BbCX/a4wZ/2EqF/8QAATuAAAAAAkAAQYADACnL3lH/5yH + mP9/VE7/cVJF/3FUR/9zVEj/cVRH/3JTR/9vUUP/aFpP/2Ffcf9YTV3/Vl+M/2F56f9ld/P/ZHf1/2Fh + x/9aSWH/W1lZ/11ic/9egbr/X0a2/ykVOP8fNzP/WaoX/523B/+Pkwr/WR8a/woAAvgAAQAACwAABgAD + AKYQHA7/N1Uz/4mngv+qf3j/g1dZ/21ISv9tTEn/cU1L/21NSf9uV1P/aVWf/15Blf9WVW3/XXOa/2V6 + 8f9kdt//Xl53/1pGb/9jbaD/gLXr/5rL+P+jpdf/i3+a/2NLZv9FZDL/baES/4FpHv87DRj/AgAA90/K + cEaTvYp3eodo1np8Y/+Hn3H/wdCm/9fRqf/PwKH/s4+G/49dZf9zR1H/aUNL/2lES/9rTl7/aGu5/1xl + rv9aboL/YHft/2F3z/9qh3P/jbW7/7LSzv+/4cv/v+jH/8T01f/P/Ov/1uPo/7GApf9XO0T/OSAl/xED + Bv8AAADpR81ksrXNofvUz6z/1s2o/9TIpf/QwKD/zLua/8u8mv/OwZz/zbCZ/7SLgf+bfHb/kV5q/3hM + V/9zbHj/epTa/32X6P+CnuX/j7LW/6/Atf+3tJz/rKN//6GcaP+bmVT/jJhT/46wf/+t2tT/0uL1/69X + if8dAAf/AAAA/wAAAMkMzTMiYs17o7LMn/rTyaX/0cSi/86/nv/Mu5z/y7WY/8iwk//Hr5L/ysSa/9LD + o//Mr5X/w8aZ/8rXpf/S57P/2O+8/9zxvP/f8bj/3u62/9zptv/b4K//w7+v/3Zoxv80Idb/HhHe/yMe + 7/9ERf7/hkvY/z4DJ/8AAAD+AAAAjRbKUgAAzzgQUsJle5i9iezIxJ7/0MKg/868m//NuJj/y7OX/8es + kv/FyJ//08am/8zAmv/S5Kz/2+Kx/9fbrP/W3ar/2euz/93zuv/e8rv/4O24/73Avv9EOen/EAH//w4A + //8PAP//DwD//w0A//8TAf7/FgCt/wIAG+0AAABJAAAAAAFzDgAAjgAEEj8djTtaO/93gWj/ppCH/6p9 + hv+WYHf/hExs/3hjcP+ZkIf/s8GY/9bps//a37D/19as/9LKo//Qx5//0dqm/9rxt//U4bv/UUnn/w0A + //8QAP//EAD//xAA//8QAP//EAD//xAA//8PAP3/DAC5zQQAPBkAAAAAAAAAAAAAAAAAAAA1AAAA5A0e + Iv92pqD/v7LL/51fmv9wJ2j/WyJe/1wkYf9nfHL/veqv/9zhsv/X16z/082k/9HCn//LuJb/ztWc/5ul + yv8WCP3/DwD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP/qEAD/PgAAAAAAAAAAAAAAAAAA + AAMAAACGAQoL/kSDd/+9+Oj/1Ozs/7Sewv+FM4L/XRtk/1k0Zf+IxZf/1+S1/9jZrf/Uz6f/0cWi/8y5 + mf/LtZH/Y1vP/w0A//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//4QAP99AAAAAAAA + AAAAAAAAAAAAAAAAABsAAAC+BxAa/1GFhP+u79r/wv/p/8S11/+TLIj/WRVn/19kc/+t3Kb/2tus/9XQ + p//RxaD/zbuZ/8qyk/9YRNT/DQD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA + /5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADcAAADVBwkW/z5caf+TyMP/yvLs/8txw/9nG23/XzBi/3OR + eP/B3ab/2NSp/9LIo//PvJr/y7ST/2hUyv8NAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA + //8QAP/9EAD/dwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADTAwEH/xgZMP9QUHj/ejeQ/1wg + av9cJWP/XSpi/3SDfP+70aP/1c2k/8++nP/Ot5X/l4Cu/xgJ+f8PAP//EAD//xAA//8QAP//EAD//xAA + //8QAP//EAD//xAA/+QQAP81AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIAAAC1AAEE+iMM + Q/9TFGv/Vxhs/1kYbP9XFWn/VRpn/2ZRdf+WnYr/vr+a/824mP/CpZH/VknV/w8A//8QAP//EAD//xAA + //8QAP//EAD//xAA//8QAP/9EAD/hBAA/wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ABUAAgJ0DAcd1y8NS/1MDmz/VA5y/1QPcv9WD3X/SwhS/x8SI/8wXzj/j6t7/82vkf+nW47/JgXB/g8A + +v4QAP//EAD//xAA//8QAP//EAD/9hAA/5UQAP8READ/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAkBQIOchkEMLsrBkLkLwdD9zAHQ/0mAyj/BAAB/wADAP4SQR33fJZz+KY1 + YOgoAC2IDQDbaRAA/6gQAP/JEAD/xxAA/6IQAP9PEAD/CRAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADUAAABcAAAAggAAAJwAAACeAAAAigAB + AGMmbTp6iUJLlbIAAA2OADUAEAD/BRAA/xAQAP8QEAD/BBAA/wAQAP8AAAAAAAAAAAD8D////AAP//8A + Af//gAB//gAAH/wAAA/4AAAH+AAAA/AAAAPgAAAB4AAAAcAAAADAAAAAwAAAAMAAAACAAAAAgAAAAIAA + AAAAAAAAAAAAAAAAAACAAAAAwAAAAOAAAADgAAAA8AAAAPgAAAD8AAAA/gAAAP8AAAH/gAAD//ABDygA + AAAwAAAAYAAAAAEAIAAAAAAAACQAAMMOAADDDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAABp4BABV3AgANiAIHF3cBK0ZfAEVuPAAyZRQAGFMAAAVcAgAANwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAasAABGAAgAFiwEFD5MBSzaYALxxigDajXoCwZV0A46MTwRmgB4GM4oA + Ag5OAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK0AAACTAAAOEgEAAKIABQ+tAC8ssAOncLEJ+5ys + C/+XnAz7l30N45NWDKqUIARSmwAADJMCAAAAAAAAAAAHAQAAEQEAAAMBAAAAAQAAAAEAAAEBAAARAQAA + EAEAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJUAAAKt + BQAAqQMYIa8HoWywC/2Zrw//ma0Q/5ihEf+YdQzumToJmW99YUJGtZdqiKuPk5Ksh5SZsJ2Wk7Osloyy + r5aRpZ6VmJuGlJ59eoeZYIJRdSuBKFUAGgknAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAACfAAACrQEAAKsAJiapCMyAqBL/lqkS/5aqEv+XpxL/lpAS/IWqbvCE4OH5wsSt/8fK + j//F7sf/vfTt/7fy6/+22dT/v7qX/8bOmf6+z9L0q4nN2ndUq6dVNGtjQgQZIi4AAAQ/AAIAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqgAAAP8AAASiB3dPpBH8lqQV/5SkFP+UpBT/k6QT/5St + KP+V3rr/xMi0/83LkP/D99H/u/vu/7X67P+35eL/xsak/8vdnf/K9t//xrvx/4Sf9v9qcrP4ajsq0Goc + E4NkBREpRgAEAlUACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAOwA9AbQwmA/9jaEZ/5Kg + F/+SnRf/jpsX/4+gEf+Q0nL/tMqz/8rIjv/F8sH/vvrv/7n67P+57On/w8uz/8nLkv/J77z/y8zy/46s + //9th8D/eGw2/3paK/x2OibSZRUacVMACBaABBsAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABxAAAA3gAq + Af8vkxH/i50c/4+cGv+Pmxr/j5ka/5CZFf+Nvkn/qcqk/83Ljf/I8sj/wvrv/7757f++9O//xM/B/8rF + jv/L8L//19f6/5mj/f9rb53/dGIy/3ZmM/91XDX/cT8w92YaIq9HAAo1AAAAAScAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAA + AJkAAAD1AAAA/wA+Av9Clxb/jZge/46ZHP+PmBz/jpkc/4+WF/+Jrj7/os2j/87UlP/L9dL/xvnw/8P5 + 7f/D9u//xtnS/8vNmP/Nz6f/xqO3/4ZynP9qVlH/blU2/25WOf9vVzv/b1c8/209Ov9WCBbQJAAARQAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAiAAAArAAFAfwGHwL/H0YM/z9yFv9ylRz/jZMf/4uSHv+Kkx//i5Mf/42SH/+FUBz/S4BI/5K+ + f//A9NH/z/z1/8747//P+u7/0djn/7mqlP+0hXX/kEtH/2RJOv9rTD7/aUw//2hMP/9qSz//aExA/2lH + Qv9eEST/GAAB2gAAAE8AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAABwAAACsABUD/RtZDP9eojX/p8KM/7OQT/+NkB7/jZEj/4yOIf+JjSH/iJEh/46E + Iv94GRH/Ew0B/xJmIf9v8rn/3/n3/9328P/c+vD/4s3u/69JcP9ZRzj/bUND/2VDRP9lQ0X/ZUNF/2ZB + RP9jQkP/YkJD/2ZDRP9iGzT/IQAG/wAAANsAAABJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAJYAFgL7H3QP/3TKS/+y78X/z7y9/6mLNf+IiiP/iYkk/4eJ + JP+GiiP/h4wi/5BiGP9XJBf/Ey84/x5hWf9Ktqv/jbXW/4ux1/+KsdX/jZzR/3palP9XUm7/YkBZ/2E2 + SP9fN0b/YDlJ/2E7Sf9gOkn/YDlJ/189Sv9jJUT/NwIQ/wEAAP8AAADRAAAANQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAbgAMAPUSYgr/a8ZJ/7D6yf/D3OD/s5JZ/4iJ + HP+Khyf/hYgm/4eJJv+JiSb/iYki/4yMTf9jlbb/XKXl/2mn9f9uoPT/aJ70/2Wd9v9nm/b/ZJ32/2Wi + +f9rn/H/aY/d/2hssv9lQHT/YDFM/10zS/9fM03/XjRN/101Tf9hLk//TAcj/wgAAP8AAAD/AAAAsAAA + ABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4AAAA3AI4Av9HtDH/rfe7/8/g + 5/+zl37/j4Mp/4SFKP+HhSr/h4Uq/4iCKf+BhCr/h40w/4Gqrv9yp///cKL9/2+c+/9ulfr/aJX6/2uY + +f9ulvz/bIDl/2aT2/9ooP7/bKf//26s/v9sl+v/akuh/2AmWP9dK1D/XC5S/1stUP9dLlP/Vxc5/xsH + Cv8GAQP/AQAA+AAAAHgAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAACjAAkA/xBs + Dv+A3YH/xdLL/7CTef+Neij/hoAp/4V+K/+Cfyz/hH4r/4R8K/+CgSn/hZRg/3Sg6/9rmf3/a5b5/2uP + +P9oi/f/Z4r3/2iM9/9qi/n/anbo/2aK4P9ol/r/bJv6/2+e+/9rrf//a535/2lFrf9dJFf/VCdQ/1Ep + Tv9CLUL/PDM6/zgxNf81Gin/GgMM/wMAAd0AAAA2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AE0AAADtABAA/xtyGP98mk7/l4JF/4V8LP+Feyz/g3gu/396Lf+AeC3/f34t/4Z8Lf+GhS3/f5er/26Y + /v9sj/j/aIz3/2iG9f9mhPT/ZoT1/2eB9f9mgPT/ZYX1/2eI9/9njPb/aY/3/2mW+f9rn/r/bav9/22I + 9P9lLo//TiJG/zEpPP8qLzf/NEg3/0hsL/9kVCr/TiIm/x8DCf8CAACWAAAABwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAADAAAAKYAAgD/AwcB/wwkBv8tXhj/aHco/4N2Mf9/dDH/fncw/4F3MP+BdjD/gHcw/4N4 + K/99jV3/c5jq/2yR+/9ri/f/aYX1/2eA9P9le/P/Yn70/2aA9P9nevT/Yn3z/2WE9P9ngvT/ZIj2/2eQ + 9/9rk/j/aaP8/2ur//9sUc3/RR9G/yMmNv8pMzn/O5Er/4S3C/+WoQX/fVsa/00SI/8UAATfAAAAMwIA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAOAADAOQHLQr/PUkd/1UpFP8rVBr/X3My/4JzNf+AbzT/e3Iz/4Bz + M/9/dTT/f2wz/3xdOv9oe5X/Y5Lz/2mO+/9piPn/aYH1/2V/8/9nf/P/Z33z/2d78/9lePL/Y3zy/2Z/ + 8/9mgvT/ZoP2/2aL9/9pkPr/aIvz/2Wa8f9oWsr/OR1F/yAhN/8lUDj/Ubca/5y6Bf+XtQT/kZQI/3kz + J/8xAhP9AgAAfQAAAAIAAAAAAAAAAAAAAAABKwYAAAAAdQAnBvwznEj/oJWB/5VlPf91bDT/em44/3xr + Nv97bTX/fW42/3xxN/9+bzb/fTw//2UTXv9THXL/VjmP/11XtP9latL/X3fp/2N+8v9of/P/aH30/2Z8 + 8/9mevT/Zn32/2d69f9levH/Z2/p/2Rd0f9cQ7L/VSSO/000gv9TLn//Lh8//yEgOP8lajX/asMR/6Sd + DP9+dh3/ZKQR/4RjGf9RDCD/DgACvQAAABkAAAAAAAAAAAAAAAAAAAAOAAoAsg1vHP+A8qz/2MDm/61m + W/94ajX/e2o5/3lsOP9+ajn/e205/31vOv9/WDz/cBdJ/1cRWP9TEF7/UQhZ/0skXf9eT4r/dkKc/2s7 + oP9eTaz/X2nR/2J58v9jXeX/YEG4/1wypf9YJJD/VRh3/1Y/d/90YI//ilmP/4Ise/9bFlr/Nx4//x8h + O/8ldTP/dcQN/6VjFf9QJTn/J30n/2V8Ef9nGiT/HAAG5gAAAEMAAAAAAAAAAAAAAAAAAAAnABoB2Smp + Qv+q/9v/zcfn/6pnYv91ZDb/d2Y7/3pnPP98ZTz/eFo6/3BAN/9kKjv/VyA9/1NSfv9UULb/VEGM/1RR + lP9zyLT/3tnq/+OAzf+YD3b/UUJ7/11x6P9fH7T/Vgdb/1QLV/9TDlb/UB9a/1FthP+N5s//6Pf4/+iW + 3f+aHGn/RR4+/zUgPP8udzH/c8EP/55ZFv9LKzj/L1o0/1SHE/9wLCD/KAAL+AAAAHsAAAAAAAAAAAAC + AAAAAABHACoE7z3FZf+3/+X/xcLc/6VhYf93Xjj/dGA8/3VkPv96Yz7/eFU7/28/N/9iKjP/Vigu/1M/ + V/9SSof/U16X/1pss/9w2rj/3v/9//i+9f+/G3z/U05//1117v9gMr3/VRVQ/1RLdP9UXLH/VGuy/1Vq + zP9lybT/zv/6/+uq7P+gI1v/TCQx/0oeN/83ZTT/Z8QT/6FsFf9bNTf/OFU4/1CQFf9xNCH/MAAN/wAA + ALEAAAAAAAAAAAADAAAAAABiADoI+1DWhf/G/vX/0K7W/51XWP93WkD/dFk//3FcQP92XkD/d1tB/3Vd + Qf92Uj//bjkv/1UxH/9RRC//WExG/2Sfc/+h+eD/3eb//9FsvP96M03/U3G5/2N4+P9lWOb/XiFq/1JN + YP9PS6P/UDJo/1BZW/963an/zOT2/7xkm/9qIi//PR4v/yYcNv8iUTz/VMIc/6SLDP9yQC//R147/1yV + Ef90Nh3/MwEP/wEAANUAAAAAAAAAAAAuAAAAAAB4AToJ/lLYiP/L8vr/0oe0/4xVSf91WUX/c1hC/3JX + Qv9xWkP/dFpE/3RaRf91W0T/dlFB/2hCJf9WXij/Z5Bg/4m2oP+aqbL/mmCE/3IyOP9QYnf/XH/o/2d5 + 8/9mdPX/Y0S4/1MoNf9NKh//UVUx/2qidf+cuan/mmlz/2xRPv9WRob/NRlF/xYcM/8gOTz/Pa8j/5q1 + Cf+VcR3/aoIr/3WaCv91Nhz/MAEO/wEAAOkAAAAAAAAAAAAAAAIAAACFAS4I/0W4bv+0ttH/qFp1/3ZS + Qf9yVUb/clZH/3RYSP91VUj/clRG/3FVRv9yU0X/cFNF/3FRRP9oUD//YFFO/1ZGOP9RPy//TEU4/1Rk + h/9geuf/ZXn0/2Z28v9kePP/Y3Dy/2BXq/9ZP0f/VUgr/1lPNv9aSzf/VmJY/12Nvf9mYOT/SBVZ/xwe + MP8iJTr/Ln4q/3fECf+ltgf/l64I/4uSBv9yLSP/JwAK/wAAAPS3AEgA/wD/AEwAHgUAAACJABkF/yxa + NP9yUFr/ZWBJ/3plWv97UE3/b01H/25QSv9yUEr/cU5H/29SSf90UEv/b05G/2xQR/9tWUj/bnyh/2ds + zf9gWKf/WmCm/15xwv9jeuf/Znn0/2V18v9jefP/Y3jx/2Ns0v9hWKn/XlCQ/1tpov9dfND/ZY/u/2ub + //9wXN3/Xh9q/ywfO/8hHzT/KUgx/0ivHv+RvAf/mLQD/414Ef9kHCn/GgAF/wAAAPX2ABgAAAAAAGwA + BgIAAACCAAMA/woRBv8dLBP/NrRg/7vFqv/HnZH/o2xv/39MVf9nREf/aUpJ/29OTP9yTUz/b0pK/2xO + S/9vTUn/bVhe/2Y6nv9hLob/VDZe/1FPO/9Yblb/YXvT/2Z79f9kefH/Y2yV/1tNMP9WN0D/VTZt/2J4 + mv+Bwev/n9jw/7Dj7/+50eb/ur7S/6miuP+HYIf/XDRK/zdeL/9UnRb/g5IU/3tLKv9FDB//CQAB/wAA + APElzF4NRbdmJ2avcU9Ra0quSVY//1pgSv9hdkv/hMaI/9LXsf/Z267/2dmu/9G1o/+wfH7/h1Jf/3RF + Tv9rRkz/akdM/2xHS/9rSEz/bUhM/2xbbf9sdsz/YGbS/1lcgv9XaDT/Xnev/2R5+P9jd+r/YWZc/11x + Sf9vp7L/m9bi/8Lv6v/R+uv/0fzp/8786f/O/uz/z/3x/9L88//X7vL/1KjN/5VIdf9COjv/RT47/0If + K/8eBgn/AQAA/wAAAOIjy1Opns6a0LzInvPGyqT90M6p/9XMqf/UyKb/0sWk/9DCof/NwJ3/zcWd/9HT + pf/X2Kz/1buk/76Eiv+TV2b/ckRS/2tBUP9pP0//ZkFO/2pFTv9rZn//Zn/k/2N49v9fddT/X3jq/2B2 + 9f9ggfb/b6HO/5XIx/+2zM3/uLmv/62sl/+gqIH/mqx2/5q2dv+izIb/seOq/8P31v/S/u//2f31/9u6 + 5f+dNXL/NxUj/xUECv8CAAD/AAAA/wAAAMgSzTeIes6I8M7OrP/Szqv/08yo/9HHof/PxqH/0MSk/8++ + n//Mupn/y7eX/8mylv/Is5L/yrqW/865m//KppH/tpuG/66WiP+rcnv/jk1k/3RGVP9uV1b/eIWQ/3+d + 4v+Cn+r/iaTk/42s4P+YwNL/sL+1/7y3nf+zqYv/raF8/6eccP+il2T/npJX/5mMQv+MhTL/fok3/4Ci + W/+azrH/wOrv/9j49v/ei8n/bAYl/wIAAP8AAAD/AAAA/QAAAJ8AzAALH8xKc3XMi+rDzKn/1Mun/9DI + o//PxqL/0MKh/86/nf/MvZ3/zLmb/8u1mf/IsJL/xq+U/8eqkf/FupD/zc6j/9O/ov/PsZj/x66R/7/K + m//G1aT/z+Sq/9bwuf/Z8rr/3/O5/+D0uP/h87j/4vG3/9/zuf/f8Lv/4Oq3/9zhs//a2az/y8Wt/49/ + vP9LNs3/JxfZ/x4Q4P8gGuj/MzH6/2Bm+v+oj/f/rRxs/xcAAP8AAAD/AAAA8gAAAGMA1A8AANYABhjN + UVZjynrTtsqd/tTIp//Uw6H/z8Gf/82+nf/Mupr/zLeY/8u1lf/Ks5X/yK+X/8ixkP/Hy53/08yq/9K+ + ov/MsZb/ycyW/9TqsP/d5bL/2uSx/9nmrv/b7rT/3vS6/9/0vP/e87v/3/K6/9/yu//e7bn/3eW1/9vg + sP+tqr3/SDzm/xQG/f8NAP//DwD//w8A//8PAP//DgD//w0A//8aCf//TAjC/xwAJv8AAAD/AAAA2QAA + AC8AAAAAAM0DAADlAAEMwCszSbVdrpG/ifjJyKL/08Si/9DAoP/Nu5z/zLqZ/8y4mf/MtZf/yrKW/8is + kf/DyZv/0NCs/9TCo//MuJn/ydif/9bns//a4LD/19uu/9bUq//T0qX/0t2o/9jttP/d9Lr/3vO7/97y + uv/f7br/3+i0/6amxf8sH/P/DQD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8PAP//DgD//w0A + xf8DACn/AAAApAAAAAsAAAAAAAAAAACaAAACCxMAAEIHIw9GHs0/dEj/f5lw/6aqiP+8p5D/vaCN/7mT + jf+vgob/o2t6/5BScP98ZXD/jaaF/7u2mv/Dvpv/zeWt/9vntf/b4bD/2Nuu/9fUq//TzKT/0Maf/8/J + n//S3qX/1/O5/93xvP/g8Lf/wci//zUq8f8NAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA + //8QAP//EAD//xAA//8LALf4AwAsXgkAkQAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAIQAAwD9BBYI/yY0 + PP9vZ3j/kXaP/49HgP9wJmf/XyZc/14mXf9cJl7/XTVi/2tAbP93iHX/q+2n/+Dnt//b4bL/2duv/9bV + qv/Tzab/0cag/8++nP/Mupf/zNSd/9Txsv/e7br/bWne/w4A//8QAP//EAD//xAA//8QAP//EAD//xAA + //8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP39DwDxag8A8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AC0AAADXAAMA/wwiLf9ftpv/xfTu/9jU5v/Ai8H/lDyE/2sgYf9bJGD/XSNi/1weYP9YQl//dNSQ/9Ls + t//b47L/2N2v/9bWq//Tz6X/0cqi/9HCof/NuJf/ybOT/8jTmP+6zr3/KyD2/w4A//8QAP//EAD//xAA + //8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD/vRAA/w8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAB4AAEA+gIPEf83e2r/n/ba/9n79v/Y9fH/ysne/61lrP99InT/XR9i/1sh + Zf9cHmL/XIt0/6jssP/c4rX/2d6x/9fYrP/V0aj/0sul/9HEov/Nupn/yrWW/8y0jf+Ljrn/EwX+/xAA + //8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD/6RAA + /zUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaAAAAtwACAv8MFiv/SI+A/6nx3P/T9vD/wfzh/7vr + 4v+8gcf/jRx9/1waZv9ZGWf/WTdo/2/Hjv/I5Lb/29yx/9fZq//W0an/08uj/9HDoP/Nu5r/y7aX/8yy + kP94YsD/DgD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA + //8QAP//EAD/9hAA/08AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPQAAANsAAgT/DRUt/0yG + h/+Y68//wv7l/8H+5//C8ur/z33M/5AYe/9XGGn/WRNp/1libf+M3p//19+v/9nZqv/W06j/08uk/9DC + nv/NvZr/zLaW/8y0kf93YcL/DgD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA + //8QAP//EAD//xAA//8QAP//EAD/9xAA/1IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAA + AGAAAADrAAAD/wsLJ/87XXD/hMu9/7/66P/T//H/4eH0/80+rP9mFW3/WSho/2QwYf9kk3D/quOj/9vc + q//V06j/082n/9LGof/Qvpz/zLeW/8yzkv+Ebbn/EQH+/xAA//8QAP//EAD//xAA//8QAP//EAD//xAA + //8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD/7xAA/0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAcAAABuAAAA7QAAAf8JARX/JSZI/1d3jv+Vu8X/v83d/71Gu/9oGW//Vy9h/2Qs + Yf9iNl//a5V3/67epv/Z2qz/19Gn/9LGoP/Pvpz/zLeX/8uzkv+lj6b/Hw/2/w8A//8QAP//EAD//xAA + //8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD/zxAA/xkAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAbQAAAOgAAAD/AQAF/woCGf8hGEX/USl3/2EW + dv9WIGv/WiRk/1wjZP9cH2T/XChf/2eAdv+mz5//1dmq/9TGof/OwJ3/zbqZ/8y0l//DqZT/SznZ/w0A + //8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD/hBAA + /wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAFcAAADSAAAA/gAC + A/8YDTr/TBRp/1cYa/9WGWn/Whpu/1kZaf9XGGj/WRVl/1YbZP9eUXb/iqOH/7vIof/QxKb/z7ua/8u1 + l//Kq47/mIGm/x4T9v8PAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA + //8QAP/UEAD/JBAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAAwAAAApQAEBPIQDS3/PxFh/1MUav9TEm7/VBNw/1cTcP9VE27/VBNs/1QTb/9XEWr/ThlY/1RZ + Xv94pnT/sb6T/821l//JqY//xauL/3Voyf8WA/z/EAD//xAA//8QAP//EAD//xAA//8QAP//EAD//xAA + //8QAP//EAD//xAA/+kQAP9QEAD/ABAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAADwACAV0AAwPBCwUh9iwNS/9KDm//VQt3/1QNcv9TDnL/VA90/1UO + eP9WCl3/JAIa/wYCC/8EKA7/MIJD/5q2hv/Pt5T/zI6O/6sveP81BZr/EADn/xAA//8QAP//EAD//xAA + //8QAP//EAD//xAA//8QAP//EAD/1hAA/08QAP8BEAD/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAYQMBC7ITBCvnKgZI/DoI + Vf8+CVj/QApb/0MKXf9BBkz/GwEQ/wAAAP8AAAD/ABID/xtqL/+CsX7/yIWR/5sPSPcfABjICwBnhw8A + +JwQAP/dEAD/9xAA//0QAP/9EAD/9BAA/9QQAP+HEAD/JRAA/wAQAP8AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AA8AAAA5AgAHcAYBDKMIAQzJCAEL2wcBCOwGAAb1AgAB9wAAAPYAAADwAAAA4QALAcwWay7LgHd67K0X + RrMwAAAiAAAAAhEA/wMQAP8fEAD/RBAA/1QQAP9TEAD/PRAA/xgQAP8CEAD/AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAAAaAAAAMAAAAFAAAABkAAAAbAAAAGgAAABZAAAAPAAA + ACEAYwwnOXtFk6MeMnnAAAAH/wAAAFEAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD/gf////8AAP+AP////wAA/8AMA///AAD/8AAAf/8AAP/4AAAP/wAA//wAAAP/ + AAD/8AAAAf8AAP/gAAAAfwAA/8AAAAA/AAD/gAAAAB8AAP8AAAAAHwAA/gAAAAAPAAD8AAAAAAcAAPwA + AAAAAwAA+AAAAAADAAD4AAAAAAEAAPAAAAAAAQAA8AAAAAAAAADwAAAAAAAAAOAAAAAAAAAA4AAAAAAA + AADgAAAAAAAAAOAAAAAAAAAA4AAAAAAAAADAAAAAAAAAAMAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAADwAAAAAAEAAPAAAAAAAQAA+AAAAAAA + AAD4AAAAAAAAAPwAAAAAAAAA/gAAAAAAAAD+AAAAAAAAAP8AAAAAAAAA/4AAAAABAAD/wAAAAAEAAP/g + AAAAAwAA//gAAAADAAD//gAAAA8AAP//gAAAHwAA///wAD//AACJUE5HDQoaCgAAAA1JSERSAAABAAAA + AQAIBgAAAFxyqGYAAIAASURBVHja7P158G1ZlteHfdbe+5xz53t/85vHnLMqs4burh4YBBJYZupmELYI + jCxkIqwIh2TaVgDGtgzGSEQIExB2hIQJJNmKUCgIM7XVIAlkIYRp6IGmq6sqa8zMyvHNv/kO5+y9/Mfe + +9zze/myOquyqnKot1+cd+/v/u7v3nPP3Wv6ru9aCx6vx+vx+oFd8kGfwOP1PV/SOUw6uj93HzePeE53 + jygQvsWhnefoQ88HsIBLt5J+D4LSY8WfI5RX2JpVfGr7gB8fn/CUaxiEOzvB/7PfYOb/5Lfq4RvPHu1r + 77UjVi8F/Odh8Y2Knzte8u+yy+cQvIDqLX7xg77uH4nlPugTeLy+ZysLdlfoXOd+PkzneY9SBPm13k34 + /SNum85tPrIS8Om11goAlEDgb6L8UTyCCUIFDA0yslqo0aJoMGoRK3BfCAWsjHAqjoYpnwOKpLhM6Lz2 + 4/Ut1mMF8PFaWegdUAI9YAAMO0c/Hb30nJJHK4auhwBnFUAW9q6gr9IxB04fcZvvL1krhOhhKMoS5b8F + /d8SgmAU+lZlNvSjzbLZrdRvDE+0sivkziEcCcu+cNsUvEmPL4syMFBXYD2Yeo//sd7i73zQ38eHfj1W + AB+t9SgLnS17wVqgB+kYARNgCszS7SQ9npVBxTuVwMMhwKM8gK6Fr4mCPQeOgcPOkX8+APbT7Tz9fXxt + QbnCit+OD0dsMWbsgrFDP2SzvlAM62sjbfY2H4S+PcYuHDhh2Qhv1ZaXguF1EdQpximC4puG+x/0d/WR + WI8VwId/ZUucBTtb8lHn565Vrzo/5+dlRTDq/F1X+AvOhgSPiv/hnXF9VxGsgAXR0h8DJ53bE+CIqAD2 + 089ZARggIDQsCHLI0Dp3eVCPtjabvXKvvlmMVjcHS79XrbSvBWDQGlarwH4deEPhjsIsQBECjXoWnPLN + D/p7+0isxwrgw7m6rnwFjInWewvY7hxbRMs+IQp1160vHjoq1l5CwVlr33X1v92VlYJPR52OVbrteghZ + OSzoegDxVdSsoH9izLQaFduLC6O91fXZufqJUa+5PDz0m+aulj49FSUYWJqaU+CrqvxQo0n4V+wHpfmg + v8OPxHqsAD4cqxu3d633OB0b6dh56NhKj49YC3iO37sW/FE/f7dWN6NQEJVQVgp55Z+zclhjAA7DBLG7 + mOEIdoP1l+fT5aXTy/X5+Q271VwaEGbulBIQEXAO+iUy9Jh+wJgDYMUv6IDrjecUzzENJx/0d/qRWI8V + wAe/LNF6z4hWfS8dWcCn6chu/Jh3xvGOD1dK91HhA6w9mvUn3wJ5EtN/Bs5fFa4Nhnqt2asvLa7UW6vL + DMKWW2olMbZXcWhvgGyukD2QzQXaWyEnoHrKyx/05/7IrccK4Pu/uqBdnyjIW8B54DJwJd2eB7YExoIM + BEoBBxJdd4nuuyAdQXuUzOkj8mGCqqbfnn1u93996PHvwvLtYVBGiL2KHb2A23vOmOs7I27qRbl4eKPY + dNfcoDmHCX3xAWlUUEQc9CvqvYr5zQXz2yuOTwKDV+DkmDUombMU3/GJK7MfBv7V9OO/0vnVpW/xZ693 + 7v+1dPufC/s//926gN/t9VgBfP+WEF38KWsrf451LL9FtPrngF0DWw5GhUhRYI3DYCSG7IJBRIj/DPLQ + P8g+d/7XlQSJKJ4qXpVwRsxjOr7RQE3A4wlnZOm7oAgMSg9lCy2uwcbz6MVnRa9eGnOlf5W95XNM9RNS + ynXhZEZzaGiCor7ESIUxVOqPdz13n2m4bQP7e7D6JnAbuA/cSbdHRKwhvJfT6gj8v0JUvvY7+HRd5fBH + 860y88BbRKXwoVIIjxXA93ZlV9gR3fUdooV/EngauElUBGOiha8sDJzQK5CyJ9b2cQykoJQCR4nBIWIx + 6d/Z+1EhAK2QR6HWlnInIhFyD1HQvWpr8QOBlXpOpeZEa051lRL0K9b8nfexLMaMceYC1j0BG8/CletG + ntobmcv9K2yaF6jKT2HcDZr+JloVsFSaxiB1hcMgMncNh9MFt6uaO7uBo+eguQu8CbwKvJyO14nK4ISI + O7zDI0hC/yeB35y+g+/VskTl8EeJCuEI+G+B/8sHrQweK4DvzbLEWHdItPgZwLsAXAOeSMcVgQ0L1gGl + GCox0sPRkyj4Q0qGpkclFQU9jBQINtl9gxGDwXaEXzr0OgUN6b6AGERMUgBKE0JSEvEZgYa51jzQmtth + Qa2nNByzzvS9j1UAM0QuYXtPwcazwqWbFU9sTrlZXmYnPEfpP0NjnsZX2/iew4YGnOK9Q3wPJ2DtXKRZ + lnBSwunY0pwDFgp3Fa4pchX0CvBNolK4BzwgegRHwFyZ/evA/5Fv7c5/L9cY+EngJ5XZ68CfFvb/Hx/E + iTxWAN/95YhCfw64ClwnxvTnOIvez4CRATcQYSKGkZQMpcdAevSp6EtJXyp60qOUCic9jDgE24Hzo9AL + AhIFPQu0QTs5PkHEomJRDEEgiKKtZx/w0nCsKwq/Ys6CI3EstEY5fX9XpATZBLkG1bOw8Yzh2pUBNzf2 + uFpcZ0ufo9TnIDyJmh3UlECNmi5rWBIZQugjDKOOFU/PBoqBx5/zmHGD7nn8DUXvALeIocFbwGv/mNFn + fgT700Tc5cOyLgF/WZn9eeCvCPs//f1888cK4P2vLue+RxTsy0Q3/zngWaIi2AGGJhLWHYgxIqYvhi1x + 7JiSDRkwkhEVA3rSp6SklBInJZYCY6L1R+Sd0F6y5AEFAZF1btG1SIFFEo4QjKAIEiKMqMCShqArClli + BETnrMsBvsMr0wOzCeU1qJ6D6XOGS1eH3Jhc4DpPs9V8kkI/QR2uEthE1UBoEG0geOJZBgSfUgjCmJKG + EX2mNMzwNFKzrGqkrAmTmuZCg194wkEg3PsTlO7/RPmCPQOYfujWmBge/FvAv/n98ggeK4D3t9IWZwLs + ErX5FaLAXwNuEJXBJlAZkD4wwFIaR2krxqZkR0p26TFlQMkYI0McPawUGGKMD0JIljsj9K2z396s7f8a + EIzik38ybSgc/QMr8R1qhGWw7Afhfmg4CR6vS/hO438LjMDsQnUNpk/B5lOWc5cnXJ5d4op5ls36Rcrw + PEGv4pmk81whrEAb1u5JVAIWoYcwkhJhyIoZQbfwKCuW1CANwTU0bkXdf5bV9D8mXL3w4Rb8R1257BH8 + i99rjOCxAvjOlyGm8XaIgv4s8AkisHeeGPePiTl+B1AgjMWybUombsDQjRiZAVtUbISKnvYQhnh6KCUZ + iI7wXATtGgIhZcVF429Fs5AoRmKeABW8GHxLtxccitP4d0EFrxarjgLLAsfdILwW4A1f80BPWXFEJO99 + m/G/AYbgLkLvCZg+C3s3DZf2JlweXmNPP8G0+TTOP4/XSwSGKAFhSQTua9ZaLbonoooNUCmM1VFID68j + lBkeT82KJqk/j+fP8Ca/ATUfLnrEt7XGwD9VZr8k7H/2e/UmjxXAt78KolBvEUG9q0RE/zngmfTYWMDa + lLQ3gBPDwBRs2x57dshGMWJYTBjIgLGvGDYFzpd4SpQCj2Pt1MeUXEOgUSVo19Jrm/gTFKdEj0FiFqBB + 8ElJOAkUBAyKV/DB4gh4LCcauB8st0LDHV0xTwV8ypLoAbyHlfMdU3AXYPQkbD5j2Hui4tK5TS72r3JO + n2W8egHrn8dzOQq/NMT6oAVIDaJgEu9PBfEgtWJXUNWGQEGhFQ09PBWBXgoQLDeZ86f4Ov33lv37KKzP + KLNDvkfewGMF8N5Xdve3iUL/DFHwrxNd//Ppd31iCE6P5AKIpWcrBnbAzI3YLMaMijF9O6KkwmmBYmkw + BLWoCFnwwaOJORsBvezMZ/c43s/3EEEkpgUD0lbrZEaAJHAwOtWKT0pmScOKQE2NpwZ8+mt9b86/I6rF + TXCXYXgddp4ouXh1zJXdPS4MbrDF0wz9s9hwk6DnURmgeNAFsVSgbrMWqIkYhYAmj8eKUIlgtKCSilor + aqrkMXn+AK/xW3nz/aAWH9Y1Bv6xMvtL322Q8LEC+LWXEFN6I2LO/ibwCRE+BTxFFPyxsvbZjUTh30DY + wTEzPfp2RFVM6BcT+m5E5fo4UyLeRcHPlAGJgq+Si+4yeQ5EYsyuqYJ2TfJJIYCCEcFIQgGzb6ARGMyv + JkpUFNbEUAEIGrDqGeqKKZ4lglKg2sOrTVwC35KFNKknTXWKMgV3DsorML5h2LpWcf7CBpdmF7jYu8m2 + PkO/eQpprtLoFp4KZYXqEmEBuoqfVySG/wHUKxjB9xWdBcyOUvagDBaRPr4ZU69m+Bp+1/IL/Cb/5ge9 + V76XyxJBwhvC/k99t170sQL41ssQte8FYpz/JPC0CE8bww0RdoC+ggSN9tgKDC1siuGcVOzpkKmMqewE + 48YYO8RJD6sOEwwoeFUaATXZtdckpYpoaFH6YGKqTwDR6AeElPozKEYBhCA5Fo4hdOstaDoSZ0BSSlAB + CYGBadiyDS4oS0qCjlFfEbwnqKehxrOikZrGNDTW0/QDYQvMZRjeEDZvOPYujdjd3mJnfJktd4NNfYJh + fQPrL9CEDTQ4lAbVFegSDXXCMaKWigkAjfhjofjtqAzshuA8FNbSkyFusYMcKH/oH/9Nxv4HpvjnJ5XZ + a8L+5e/Giz1WAI9euf5+g4jqPwe8ADwPXBdhxxiGYuL1S1gcBhhY2LaW87bHeZmwqRsMmCIywpsE7qmN + G50AISRLKklY21ds43uDoBIFe60ASHl/UhSQrf261M533GcIiIakBCIj0BhDMJagAaMwUkUCjNSxDAO8 + LyDEMCDQULNkJUvqcsGqv2Q1WtJs1YTLgeIJx+yJPhcujrk822GnusRIrlP661T+MoRtgg5RDYjO47ng + 0eAhKBrW5x+CEhol1Ao90PMgm4FShaoURn3LREaMjuFf/N//n+nVPzDCn9el75YS+MhCpN/DVRDTeueJ + bL1niQrgKSJzb8tYCpsq6XNSzRKT/FvWct71OWcmbLPFkE0MYzwVdULlYxIuutyS8/e6hvPWCoA27kei + EtBUA0Aq5gmyjv+Npi9UU+wvEn8vHtGA1YALisMipkBtkTIFAa8NgQaPZ9U0zGtPvYraxPjo/teyoi6X + NOMVzfaK+twKf8Vjrhp61/psnp9ybrrN+fIc03AB11xC6z3wGxB6qDdoEwjeoxoIChqEkPSShOj6hybg + fWIpFiAVmD70hsJ4LGz1hS3gR37zH6S4fe+D3i8f5Hr9/SqBxx7A2VUS0f0bRIv/aSLYd4noDQw1Kogz + Kwv/trOcsz3OyZRNtujLFsiEmh4NhloDnrjLLYqqYrP4tjF7C+fBOiBoqb+qWRG0jTFamC5I8gxIOQER + VDSBaRFRV4ntd0xOjSc2oIhQiKVUi6NEvLJKdXUWRVzADz1h6tFtRS+BXBfsDUt5oUd/Y8yk2mBqdhg3 + O5R+E9NMCH5A0DKFGoEg6XxDbN0ZUlSSb/GgPmEABrQEmQrFNgy3hK2JcL4UPv3UH8T9YAs/fBc8gccK + IC7LuljnJvAi8ENEJXCJiG+3qFpIIXoB9A0MxTKzjm3bZ1vGTNmg0k2UMTU9arFk+6oaO2lpG+dHll73 + tnXt0xIEUZLlT1x+WecJSKm9nPFvgwcVVEwH/1/z6lqakEb8QFWQxqHewFKQOlp+JCBVwMwUu1ci5y32 + gqO81KN3dcjg4pjedExlRhSrKW4xw4ZpAg9NJ4fgUaOEEN0UI+vKxcxrfEcZsgGxgqkEOxKqmTAawaeu + /kHcm3c/6D3zYVnvSwk8VgBtW4ozZJ7niIDfBWJa78zKm7UU2LKGPVeyaUZMmNHXGSUT0AENZULePSEH + CxKFLiEAra23RCssyTLnLHYbo0mk7cYTSAw/o/hWkAPS8gOkmwSAlPhTkfS6mRUomJg7JHhDsxKapaGp + DcGA9AIMFdkW5KLBXS8orlT0LgwYbk+Zbm4xGe1QmSmsejShpGl6qPZai494pGUSpvy+7fQhizDIGrMw + kNDMM72GTKqYeurf+Y8o3ngs/A+tS8rs//qdpAh/0BVASaTpPgV8lmj1nyda/QmPcPe7yxmYOsOeK9iW + Ib0wQ8IGypAGF91aPEqI6bmOhQdJ8X+m+3Qa80nK9HcZrCGR4jSHBfl2XSyTwUHtWtGWJyB4WYcUKooj + YILBqBCC4AOsjNL0PTpSzIYiO+AuOdzVgt6NPr1LQ/rbYyb9TTbNHlO/i12OmK8sx01oP/MZoe+eSkrS + 51oF0XV6UgWCoQOGnl2bv/hlLv2Fv/FB75kP6/qjyuzb7jXwg6oAcnrvIjHGfzEdT6fHRrxHgDQLoFND + X2Nbv5WWNBgaAkiD1VyVF5t5xPjdtDQbT4zfbXzBKBhGkkeQhNpEIQ2S290EVBURTYokiZx0+PMaqwii + 4Mc6Ai8Bo4rBo15x3mJCRDS1BD8I+FmD2Qu4i4biYkl1cUDv/Jjh7oTBdMxgMGEsM6b1FsN6iq8rlrUS + wio1EGkezb7veCVC5Eso0eCbEK9Bfk7OrHTXb/lNf5TH61uuf8y3KdM/iArAEQG960SQL1v9q8RKvh7v + UfhXAfa9cpuaUhYUzOkxx0qBUCZWXqzVt7msR0xr8WP/Kn1IaNepP3JIINFNbkTwBryGGJuv6UMoQiMd + BEDXGEMMFyRxBhQJAQmK10AISgFID9yWUF2E4jLYy4bqUkn/wpTB1jbD4SbDYsaQMf1mRD8M6DUDrC9j + 2lHeA/W2I9CaeBOaWhZk0A9oMdFWCSj8/t/1v8KEjw2993u1rDL7xW+nduAHSQF0qbxPAJ8CPsca6Bvy + Xmtf06ZcBXjQBFRrgjkhmH02jVCYBmREYXoIBVaKtiQ3NsFPCEDbly+Jbeb5J/NockyQPAAvQq0xexCr + 40LL6lMkVQpKBPY0qwLTCr/PplUF8ASrUHhMH4otpX/VMHjSINdK7MUe5c6U/sY2g8EeA7boL8dU8z7l + qsL6Aq9Co4ElgcZEWF8e8vjXMUc6t/SYBvCB9jO/o/9g+izawAt/4++y+8Wvf9D756OyPqPM/sh7LSf+ + QeEBCFHALxKBvh8CPpPunyMqhm9rmYRiiYGeEzZsxXk3YK8YsenGDO2E0mzEntf0Ug+faPu9hsi411jg + gxqMmpTqi9ZPhFTZR6TrKtQINYqqx2hSAB3UPxAxgjU7SNp0YCC1CEsmV4zH9DzFVOntweCqYfREQf96 + n+L8GDvbxPZ3Kco9StmiqMfYeYlZWMzKROojgZA+xyootQevtLlIySSJEFN7QePvVTX+vQ9oo3gfi5NU + NHopAbyHUEdd9Sf+8O94bP2/veWF/fdk3H8QPIBUnMplorX/HPAjROBv9p1eg9DpMDf3seW9yCliPKWp + 6duA1QJDH9WqzdsHibnwRppUdBMwanFaYHAEsW3NfyDH6xr/vqUHZ7DPnOEPxLy64DEpBRdrBloWcIjh + B2VAhuB2lfJioLouDK+VTK+OGO9tUI13MMU5NOwiyy2kHsHK4WuovSeEgGpEInJ9gBJxC6vrDIZ2eAlC + jPM1nWMIIZKA0Oj6JzzDAMGlSsCV8Pv+wp96LPzf/rLK7G++l5qBj7sCsEQhv0YU/h+Btohnxvtqd8Pa + ugGNBlbBs/IrfG3BzFGzwMuChiLmvgioCQQbaFyDd00L4plgUhmvJRjTdutVjWBf6yK3hYCp+WfCCEyS + NgnSkoVC5g+keiJVIZSCTBR7SaluKqMbwuhKn8m5GePtHYajPQq3h7BFWE7R1YCwLPArxQefypFzWjMi + /THQkNadlEALcOaKfNF4LkYlUn+zokhooWRNYRSxEi/XHJ78/D/9oPfQR3X9jvfypI+zAjDE3nxPEFN8 + P0oE/a4QUf73XTVqEJwKlTcMgmWCYyiOwjjIFFsaGpYoNppAE9BCCVUy4w6MKCI+lcDa6M6nll2tS5+U + gEjOo3U7/ZIUybrNV7eTt2aucgkyU+xlpXpaGT9vmF6tmG5vMehfpFddxphzqG6goY8Gm86hiYxDPSv0 + Z0b/SHL506Ea8/oZ0LMm05WjxlQSDVikRQSFEPVaAcHD7/tLfyo+//H6TtZ78gI+rgrAES38w8J/jRgO + fEcrN/6LUzksJY6BOoYUDLVgjGNiLD1xiOkRQoE2sWAgltA2qInmUawgwWJzBx9SRC0eLylnLzFm16BJ + W0X2XDSincIgSJZU1xY1gDTJiyhAx8BOoLgY6N/0TJ4SZjd7zHY2GPUvUXIVEy5Bs4WnH1mEGqd4qTSo + hIh5qLb1Cy3IR4tnpimBUag1VziKIKJYAbG5H0ECPwMtOSmxpFrV/MQvP7b+73P9ml7Ax1EBOCLS/zQR + 7Psc8EkiADj4Tl4wNtcUSqCHoUdBj5IBPUb0GVEylJK+c/QGQjU2lFWFW02R4wl60qNpAl5rPLHXnSTQ + z2j0AJSAF6UxntpqtIx0QHtJDBmJJcTakb72OR2SUc4zagE6Bb0G5VOB0c3A7Kphdq5isrHBoHeeylzD + hIvANkH7EVtIEi0SU47GhBhCZJaOxpqCruSvlVSUY8lc/5b/FLCSYv22ujGGBppqFTIu/VN/+k8/tv7v + f/2aXsDHTQFkt/9JYrz/Y8TY/yLfCdJPFnxDH8MQxxDHQCoG0mNoBkzMgFHRY9ir6E0K3I7g9gxuVOHq + Dez9DeTWAP9AaU6W+FWNlybG0U2DlxpvamoUb6ICaCTEwp7E/UdMavZh2orAzO+PwhZLgkSj66xNKqhx + Ufi5HCg+oQw/qWw+4dje7jPpz6g4j/UXwV8ksAVaJdvcRDwh2+asV9LKAUBuL5D1jqZrlnP4kot7JM7y + jdTn3IGAqAjJ5U+dgqgAN3/+sfX/Lq1v6QV8nBSAI3L6nyJa/R8jWv4LfJvCn1vb9RD6WMYUjCkZUzGU + in5RUQ169Ed9xqM+k8mA0axHf7uiumipLjncxhDHFvbeDvLKGPmaIXyzwd9dsprPOdVjjueHnNSHnJYN + oVC88XhZN/nIbbEgFvUgZl0WnFkyIdcExvSaNjF9FgyEGcg1pfiEZ/RJ2HzGsXt+zOZgm344B6sL+GYX + DZuo9CCzFFL+TpMSarGIbrmytqF7G4bk1CWdn1sMIrn60ulLkpUIJBAweS+f+C9/9jHy/91b9lvxAj4u + CsAQY/6nWQv/i3wHwg+SGvwbpjhmFGxIj5n0mRR9Bv0+5bSi3OlR7fYY7wyYbA2ZbA8Z7fUZni8ZXOhR + bY4w5TZyuIN8fYr95RL5Z4HmqytObh1z//Aet1Zvs7KK6opgVynO1hbok/b/RCEyZk0SILX6IkS3PHQE + y0msZLiuuE/C4AXYeMqwuztku7/LSC9jmgvUfgcfRqjmgb0PzdTMpbohuv6hG+jnRiOZcJgISC3AlxVB + TgV2XovER8hKLH8kSaXKL/6dn/2g99PHbf0vgY+tAsipvqeAHyYCft+25Y9W31BRMKBgiGOCZcOVbA37 + zEY9xtM+g80evb0eg0sDRufHjHdnTDanjDcmDDdHDDf6DKY9ysEQMRPYniLjEdaVEIRV3fDg9ITF4QhT + F3gPvqgJugCzxERQoE2smRBZfbGGQFBjUpFQssLGRNDNR0qxpoFkckkpXlB6n4Lp046t3T4bvS2G4QK2 + vkyod1E/QoNN8t60xcXx5SNrJ/hYwus522HIKpgg6zBApVPXn4qcMiEoKyYf+RMaUgghoc0SiEkFTQF2 + X/7aB72nPm7rM+/2i4+6ArDEar6niTH/jxPz/N+W8Of+X2MKNhgzYUCfgp4YxqOCzSs9Zlf7jM6XDPcq + JheGbF6csrm7xWS6w3Cww6A/o+qPKcs+hauwpkQoEVsiswKuW5pDgduKea0gSMlKHUuUWk9Q3cdyAkYJ + TtAkECaYmNbLtf1tM5AkMEkC1QKFwgjkErhnAtULMHnGsHmux0Zvi0G4iKkv4pttfDMieJvahOUUX6ci + PykArWN/Pq+KTwwka8D4aPEDacpwSCzAkMMHTWBnpwRAQUOy/qKpWxEYE7MEAjz3X/+dD3pPfSzXu4UB + H2UFIMR8/g0i2v+jrAG/6r2+gEtPnuDYpMcWI6YyobIF5cQwvGbZemHAxnNDxlcGjLaHbO5M2N3eZHOy + zbjcoTLbOJnizDD2ryJOA4hpQ0VKxW8ozQ6EDcFXBbUZsSSwlCMaRqBFLIMXRVx04zX1AJBg0VQnq51z + T0wa1EoE/EYgF8E9o/Q/AeOnLBvnemz0NxmE89j6Er7epfEjQojCb0Kzbs+luboxmfJ0aLbqoi1QZ0z0 + AITc1itx+jsVPB2mQvozXdc25OdKpCjnsOb5v/tfftD76uO6HhkGfFQVQC7nvUl0b36UdcxfvtcXKIER + wpSCTQbMmDAtxgxHA3q7BYPrjunzBTsvjNh8coPp7hbj0Taz/iab/RmjYkzFBGGM0AcqglpCLmsz66Lf + EDTy20Oy5EZjkY6J1lw8SLKqgiTw38TxIsGCd7FlfgbHOkU26gQ/EsJFcE9HxH/8pGHrXJ/N/gYjPU9Z + X0Sbc3g/xYcC2t5AETyQIJ0OA+m2S+NNmcV1iV5HGZ3FBtfnxzorCYBdZwsIkmjBMe+voniB2VtvfNB7 + 6+O6nnzUgx9FBZALe66zFv5PERl+78ntF6LwT4FtLDsM2DQbjHsTett9eldKhk9XbHxiwPZzQ7ZvTtnc + 2WHav8jYnmfAJn0Z4ChAHR6Xim1qgjaoJrwuN+paCM09WL4tLO4Ki9PASlcEdwT2AOEYCQ3SKJL68LU0 + OmOSwpBkhdfMuTguQNAh+HMBngm45z2jp4SNvT5bgxljf55yeRGtz9E0U0KoUELM76/7FHWsdXrN1LxD + Qmx1ngn+GZv3gXU6j3UGQDVnDFgrgTVbqeUItDXRIXYBVkCdUs7nH/T++riu8aMe/CgqgB6xsOdTfAdo + fx5gM0HYpGBHhmz3Ntjc2GB4oU/vpmPwjGP6zIitJ7bYurjJ5uYm03KHkZyjxw4FY6wWsWpNY129pyGo + thx4h8HhUC3g1NK8KZx+A+69Zrm9r9xvlszNA7B3sHYfWIAHqSX2wVOJcb0JaUx2Ssl1gmrFoA7COMCl + Je7JFaMnlc3zPbZ6fSZhm3J1Hl0my69la7tVY1VirDU4m84j30//SXb9k/VfA33JtTdtAjEWJCHta7Zu + geRUX6oPCOtDBdTCv/BX/vIHvbc+1utRbcM+agqgT6zd/yTR8v8w0RN4d3pvxz11RNBgB9jGsWXHTIeb + TM5tMHlyzOR5x/SThtlTPTYvbDPbuMi0Os/IbdFnQskES4WqUmuDhjS2U/OsnGjW4lva1MzToSdQvwlH + XxduvSq8dj9wuz7lyNwnFLcx9gEqS/CK1BaLQeuoANR4sBCsJxiHqEkxuaAlhDFwoaG4sWB0Y8nmBcv2 + aMKG36Bq9vCrPRo/w4dE8pHchiyCcT6BckBE9snEn05Cv/1Jc1+ypAvO9u6LqTw5A/y1mICuW5Pml8r5 + QhHtJh8fr+/j+igpgEzxfYbo+r9A5PaP3vUvckMNAacwCrCtwnkcu27IZDqjf2mT6ukJ1Yt9Bi9atp4p + 2bswYbN3nrFcosd5KmZYegg2Fb8uEugV3ya7zdFgJqQ8oXShVsIDoXnTsHhNOLjluXO85L4c0hT3cO4+ + xpyg6lE1mNqgPrn+BrCxglCMjSSgYFA1UIBuBLjgcU8t6D+5YON8YGswZMoW1fI8LPbwzZQmVKmQKLQ5 + uZYz0GHzhZT+i/MForBLF3jUlHWAdxCBlNSeLCuCh5WArguIcjkzdJSGKJd/9fMf9B77uK/f+PADHxUF + IERqSwb9PkMU/nfn9qfKHbGxs+eogW2EPSnZ643Z3NxgeGWL8tkJ7sU+vU9WDG72mOxM2OztsCEX6HMO + xyaWPhI7+aN4vMYBGnFKr2AwGEkW32hEyAGtob4LzTeF+jVDcztQH9eswj51cRd191F7jEgTgb7gELVI + yIw/bZWYBEUbJTREL2AjIJMa99Sc/osLZk96tmdDJuxRLK8SllcI9Q4+9LsVA9DG+vFfLFJer5bmC63A + aupWlKaQt8LdKo/OX519l/WXF+t8Ut8CaPnFJtGEjcBgf/+D3mcf97X78AMfBQUgRADjKtH1/zTRC9gm + 9dF85F9EI0plYBJgS4Vd49juj5id22Z0Y4vxc1P6n+hRPFfSvzFgtjllXOwy4BwVuzhmGKq0vX1bEqtp + Yq+mAFbFRdpsbuIJ0AjhnuK/KixeMhx/Uzg59CzDIepuI+UttHgAZple38WvQ3NRTGqKkdJwrMCsYq/+ + UAVMP2Au1PSeXjB9umbrXI8N2WYwv4Isr1GvzqNhlCx/6tDb6dclxCBFxbQNR0Iyz5HQk2YNpvttfb+u + Pf81eJgRvfVsgjOVgmsN0LY2F4ggI4IxCdz8gWlQ9eFZHwUFkEG/F4mW/xmiJiuAMzRSSNsw/VwpbAbY + DYZd6bE1mDK8tMngE9sMX5iw+dyAzeslwws9qo0pw2KHGReodBejU5SSBiGz5JQ81KNJM+1D4ueDSoid + e5OQyEmBfDNQ/yqcfN5w/1W4e7xk3+yzcG8TqlvgDlGJfa9Cdlc0l/WSuLMSC2pq4hy9CsyOx9wI9J6q + mVxTNrdLNqsZ4/k5iuUFdLVD8COUAmEVPQy0w+fX1irn4qKQOheHDqU45D4EHYZfqwhYU34lTR/O4YEk + lmAOk3Kr78RnjN5Rfn+jYGPf/+GD+x/0Xvu4r/MPP/BhVwBCzNY9TQT8Xkwfos31G4mb56EW+jjizO5d + D5dMwfZ4g/GFcxQvbtH7sTGzT/c4f7XPpdmQSW9MYTcxukuhuxQ6I6TKOKVJR+524RN87VPMmxSDrMtj + dW7gTYGXlMU/hwdfCrz11orXlwfcsbc4Kd7GF3cx5jR1/kmpvjPAW7qTu/mgaN/DToN5GorPKsNPBGZ7 + JZt2xGS1F+P+ZpsQhrSDOVqvRVus4lFoW/Y2jEri/2S3P2MGGeLUjAN2eYOdryu9T+r7Jwk3zOXNAcVq + 5wSytyY8LgD63q93eMwfZgWQXf/rxGk9L6T7bT4ze405FZVn41UBxgF2vLDjCmajCcNL2/Q+sUP/c1Nm + n6s492SPi5MZF8w2k7CBaWY0OsMzxkuZHP4VSs26SCa14pYoXrk5D7kvngJzg74m+C8Ylr9s2f+S8uYb + c14/PuBt+yYH5RvU7hbGHiE0eO3OCtCzubiWEwAYRYcR9JPnAvZTQvmUMJj1GTYzeotd7GoX9VNQh4pP + 3XY9uff2GUHtuOcZqG/Dl44HkAt2o9DnKkBdt/VOgICEOFlYdN2lJL+e5MnFKSWYwVM6nhv1Y/f/g1gf + VgWQQb8niG7/i0Thn/BQoNj2v0ihcxFgI8Cewo4rmU1mFFd2kBe3KX9kzMZnKi7e7HNxMuW8uchUL9Jr + NsH3MepYGkdjAl7qjgJY97oSYrqMXLySHWIFPRV43eD/ecH8nxbc/2XDG9+see3kmDd5kwP3DWr3TcTe + xbJIouWSUyzvDIGj3EZJK2I7L7moyM2AvSm48yVFMaA43cCtdjD1Fl5HCC7V8ofUdjsLnbZWO76VyW/T + ovFI6uCT25OnzypeY9Whpty9rseSahorbjrfhyTWnw3rz9KqIKNtDBBbiQksPugt94O5PqwKwBHbdb9I + LPJ5llj0c6aPX4aeckBaBBh72AlwviiYTMaUV7bghW3sj04Yf7bi3I0eV6YTzskeU3+Jor5EaKYxDjc1 + yorAiiCryOprzXCURNP+vz4VUYPOBX3D4T9fsvi5ivu/UPD6NxpePZzzFrc4qL5BXb6C2Ds4OU3tvi0h + 9RaXh/3yPEowEB23SSzyMU+Au65UO4aqX+H8FNPsYJotJIwRLRNKH0OT0CoAWV+oWEZIniNI5xqua/s7 + SgDiOUpKfWbFlN5FU9EPmRhErlyOFGcbmxXE1t/Jm2iBAAVtgPljD+CDWB9GBZDj/utEBfACEQR8JNMv + JBe2CjALsBuEPamYjCaUVzcxn96i/NyY2acrLtysuDyZcE7OM2suU9Tn0WZGCD1UAkE9uSOO4iOwp2ur + 2SqBFk03sWnHqUHecOg/r1j8k4q7v+B44ysN3zw44k1zh4P+N6mLb2LtHaycpJl4seFm7rpzpu1Op6En + hpjsPA/yHLhPKf2bymRiGIcR/eUetr4IYQd0kDrrZMlan3m+Xbvl3YuY36/j2rf0PVpFoB0vRSUBfd2U + oLRX5SylkKjITAcQfKjFUFQCj9f3fX3YFEA35fdcOq7xrcg+Gkk+E40uw7nCMRtNKK/uYD61Se/HJ2x/ + tsfVaz1uDKdckvNM/TVcfQFSvNxa+C741mleFWUlJNRcSUyZmK+fW8LrFv18yfznCu79vOG1L9e8+uCQ + t7jNYfkavngDY+9g5TQGDZHjSx7noaIoHSQz6xoBrUC2QG4o9gXofUKYXHRsmgGz001G8/MU9XnEbwA2 + 1djnScG0QzijgV6n4MSQG/xGq57LdFvEf604WllOqVVyz0EMhJCQ/jzSjLYf4BmuQCcU6H537a2DIOZx + H8Dv7fIPP/BhUwA55fdCOq7yKOHPIJNJRT0Ke0HYcwWzyZji6hbmxS16nxux+5mSazcKbg7HXNRzzOor + FM0FQrNB0IKM6sfmFSHm5CWyiARSA4zophujEa1WA3ODHDp4u0Rfcpz+ouPuL8LrXznl1fuHvBluc9B7 + A1++hbP3sDJPU68dAZfsq08eQGTCaebb50IfAzoRuAT2SejdgMmuY6MsmS42Gc33qBa7GD9DtIdKg0lZ + CWtoET5p6bvdEIBWIZg2vbcm/HRLg0N+ahv1aMsjkDhmNHEkNCdI2rbgZ9mStHpWM6ySlUClnMw2GT94 + PPr7e7jeeviBD5MCENZtvX6YqAD2eBTZR4Ai9pqfBrgQYM+VbExmlFe3kM/EVN/upwueuFbw5GDERc4x + 9dco6svgZ6gWXZ4ba1JrbgWaOt/k54hNwm8xpwZ92+FfLtGvVsy/YLn7hcArXzvl1f37vBXe5rB6C9+7 + hXUHWFkmX6IgqIvWPgfcHSJxV0hQCCXoriJPQvEkjHctG0XFrJkxXF7E1eeRMAMtOtmDFKK0YHwaCtqx + 6t3OXt0ioIjqS8vzb614nkEgnUtEBv3ivEOfWoZJUGhSwtTEYabtXIAQAT9NGYPsFagDhprQ1cfr+7k+ + TApgSCz0eZYo/DeJ4cBZdCh38SjAmQj6bWHY7PfpX9rEPL9L+cMTtj5bce2G46nBkKvsMW0uQ32JEDYj + 8p7IMWd80mQtTYi+rhWTevSBiEG8gxPBv2Gov2xpvlCw+pJw8I2G19845dXDu7xh3uJg8CahdwdXHuJM + jZGoVDwFua23JBuaYcWcScj1NhQk4E8pnlKG12A2dmzUI0arXYrlRUR3UenHikFdtWlEzWh+ovqK5gRm + l/+/Ju3ky9qmVX3ngui6cw+sC4XaWyJTsB1XltmDrBWOdKDbECAEgzYpfWhBnMI4MN+eMb5774Pehx/n + dfvhBz4sCqBPLOl9Oh1XeJTwG1rhNwVUAj0DvbKgPDeken5K/7MzNj455PLlkpvDAZfYYVMv4/QSK2YE + KWMVfDZBrWlLsFcAF4RgDGItxqZ2VQ34faF+xbL4kuHo83D4knL4zTl37x9z6/Q+t+wtjspbNMVdbHGM + MR6DjWi/uDanbjLFX9P0XlI3nWxxY1dSzJ5SXPcMbijTC4bZsGSsY3r1Nhp2CDIlmJJM9onKY92Lb129 + R+oevB7QmX8wumbwtVdCSB5QakvQIShlTMEkLkEUaGg0lkbT8iNiXYTNz5e1vxWnAieA0QXMQHGTwNs/ + /jy7Lz2eAvw9XP/g4Qc+DAogd/R9ksj1v8Ej8v0d7xxTQM/CyEBlHDIboNdHFC+OmH1qwJXrfW6OBlxh + mw2uYrmCmm3Ulqj4SKlt815rZFs0N7skUXAtJlgI4A+E1ctw9Cuw/8uB+1+uuffmnNtHh9wL9zks77CQ + uwR3gLVzrBGEAtVYvRdEUh5cMQmgMyrxd3moZxM/Z+gJugXuqqd/PTC84JnMSka9HtVyhmWTYCYE2yeI + TTX9oePid6x7GsIXWoQ/k3HihJ+gZxt7xEudUH9Z9/AP+SuQeN7Z2gcPTWjzJpEkZSM/wmaWXzofj6Th + pQn5sIrpK2bksSOP/TDsxh+w9WG45I5Yov8U8DwR+Ht0lV+q8HMGhgYmhTDsF7i9AVwfYZ4c0r/eZ2Nz + wI6bsME2Pc6D7NHIgGACSt0CVhF8k2ixTCrnDRpxwQZ0bmFuaO4ZTl+HBy957n5hwd2vnnDvzUPunexz + jwMOy33qch/sIVaWUYDUItrp40+sFyBZe5OsswRATGy7nVJhfiSELUGuBLjkcZsNVVVRmCFGNkE2UEYE + KWJardNmu1UCXR+8k8iEJMgdlL8L0Lcc/SzMunb1M5q/ThUSwwNyo0/aTEnGBtrQoJ0MnPACAVso0lOK + kacaBH71z/4bPP+X//YHvR8/tuvhZiDwwSuAPMnnCtH1f5JOoc+7LQcMBaalMN2oGF4c0rs6orw4oNro + U7kRFTNKNjHMUAYIBbAib902hjXxaJPjqce+nwvNXahfE+Zfhf2vBG59Y8Fbb+5z98EdDha3OTb3ObUn + rNwSNUusrFJ3W+licvnqR2WQrJ8nldum7rhJmmIPgB5RJV5W5JxiRiBSQpiAboFuoNpH1baWP36mThqR + Lsie+v3JWvBzd2GMxjbduq52yF8M5DZfCUdI7n5mFYbEwMQkryl/VFkr0zbS8mlqUUiuf6GYvqcYRuHv + 9aB0lmbUxx0/bgv2PVhHj3rwg1QAQkzxXSZSfq8TUf/ykc9M5DsjUGp0EcZVwWSrz/jKmNHlERtbFdOy + YsAIxwYxsuiBxll3mW0nNm5SYwxGTIzTPejK4OdKfagsbgeOX1FOXvIcfrHh7jcWvH3nkFvLO+zzNnP3 + Nr44QE0dL6KkCntNSYtOxUzG+fMZhBZzB7L1JAbL0gO7oRTnA9XFQH9bKMoS8UNUZ4QwAx2hWibALZnk + Nm5Pw0PbYH6tgdYKKYGFudOn6BmrzkN/2v5da8U7RcAZdDTSMoG6jULav8uESlWkUKQfsCNPOfL0+kKv + MBSm4OTGJaa/8tUPcFt+bNcjL+oHqQAKosA/TSzxvUgEA8+uCJaDAymgstH6j8Qx7A3ob08ZXpmycXnI + +VnJRevYZkCfGcI0vaS0rD4xgjEWYyTlsS2mtuiJwR9a/D3l9I3Ag5eVu1/xPPj6ggevHXH//gF3lw/Y + l/vMyxTru1OMBIy6eJLvoLh1P4S0tXLdVD/EJpoqgvYFNjRO8L3iGZ/3TGeWYTGk9FuI30LDlKA9Yv+A + nMmgI3Hrh+RMmlExgdSXnzPWPj+3nc7VPe3snOjaExCNqTzNHkFINF9ZtwLPn7edD5j1lFVMPyCTBjdr + KCZKWVkKKSm04vU//HuZ/q///Q9wW35s13/4qAc/SAVQEYX+eWLqb/eR55PTfiU4B30HQzUMTEWvHFJu + juldGDE71+Pc2HLJWHbpM2SKzR6AGAQfB1Bgo/VPKLbWhnrf0LxtWL0ZOHo9cP+VFbe+uuStb8y5e/uI + /fk9juU+x8U+S3tMcCc46xG1qfu/eaTw50g4l95ox8ZGY2kiGu6jW6wj4IJgrwcGV2o2tpWNQcVYZvSb + HVzYRP0Q1YKgIG05Tnq/zmiufO2yFTZJ6nNxUOQ+xvOycEaPtOnIjqJoP55Ed19yqJRr/umAjOmpJnsM + eSKQiTG/HTfYjYZqGij7FmcrHD1sqHjzD/1enn+sAL7r68M2G9AAG0TA7ymi+z/joWKfdOZtdZm1UBro + BaFnHGVRUgxLillBfypMC9jAMKaPY0pMJlQIDVZCbNulFmpLWAmr08Dinmfxhuf0lZqjby558OYBd948 + 4NYbJ9y+dcz+4ogT+4BV74BVcYqaFdY0SYm4lEJ7RykPuTdOaOP+dS1BgtiiC66xYAYr6FDgPOgVxe01 + 9IcwthUT3aBgBwkbsW5Bc7LeI4nPux7RRWvaW+COdTuvsx19InEnhHjbqqcEKgbNbTwVjKzTlx3Xwa+/ + ItpK4AxuevA1hEZoRPFlQMYeN2soJ0qv7+i5koIKGypEHaLC4QvPMPmVlz6grfmxXL/0br/4IBRALvW9 + REz5XSdCXt8S+Et7ECdQGqGyQmktViLarsGkWfQ5ZijSx1tXwamCzg3+gWF1Vzm+5Tl4fcnByyv2X16w + //Yxd/fvc+/0Hg9ODjkKJ8yLObWbE9wKNQ0i4YxD/2iXP51yCwPomk3XpdKlYF09aKkRDr2oyOUAWwFT + FhQ6pBe2KHQHr1NWlCkl51Onn7DuEtzqGG0pAEEfKvzJX0LyCqIrr+uqwYd8/kj5l5Z6nb8HiPMCrIlq + SFNqUJA1HbiG4IVaoCkj2cdtNJSzwGDgGNiSHj0KrTBpmpICr/1rv4/n/zd/5gPYmh/b9R++2y8+CAWQ + ST9PEhXADu82ykvO3o09Mg3OWkpnKbHYI4d/q2S+XXColgc9xZolPT3G+QOEkqANKx9YngrNfUP9Osxf + bzh4bc7914+5/9oJD94+Yv/ogP36AUdmn7k5oh4tCMaDaKwMkNxIM5XSqpxxwR9e2tbzCu283y4xJ8Su + wV7AD4BdpbwcqC6uKGaC2D7SzDBhBxs2CDqIgGbqEiK5Gcf6DeO7PJTfC0oaOxYVpCRAVLKQt9Y+exGd + fCKKproEn6sDO4WLImA7Kci2EKiJCqBRpSmFMAG7pZSbymBkGNqCfuhRhB5Gi/wNo8Drf+j38Ny/82eR + xx2CvhvLv5v7D99/BZCR/6tE4O8ajyL95GfaeIiJhSdODRaHsyWuKLC+QG/3WH5xwH4z5O0Hgtn0HBf7 + 9P0bVM0C5yv8ynJybDm6a5i/razeqFm8ueT41jEH9w/Z3z/gcH7AiT9iYU+o7RxfrsA1yfiZiB1o7vUf + Z/atK+bezQtQ2jm/ajCx0X8curn0hCbgg7Lqgd9Syss1/Ws1kwue4aSHCzO03sM3u3g/Q7VM0pU6EKXg + vDugQ0Ii8SSOU1dBtN1807lx5lbO/t8yfUiMPyWY3FcwfjVnlEWqC07Nh9YkywKYKGYbyh2hP3YMCkNf + C6q6xGoBIZZGx5qFCCTe/i2/nr3/6h/weL3v9f/5Vr/8fiuAnPe/RkT/L/NuQz26mFoA6ujmBjF4Z2L0 + u4D6LcNqXlDfK9C3Aqe7S8bVXXp1Ta++R9n0aU5Lju6X7L9lOLnlWd1ZUB+csjw5YV6fcKqHLMwhTTWH + ssYUSmFJvm70e0XXokNrLd8F9U+CEQlBIdYXSDxaZN0r1IpaxQ8tYQ/cpYbReWU6M4yLAWW9hYZdar+R + XATTNiPVoG16s+0iTLLOaUxPLgnm4TBAMhVXW16/oYsN5FdL4YGPLxBMIv7omhmYuQGZ5NOqExuLfEwf + yk0w20JvaulXjp5ayqbEpDxMmyLtKNRf+n/+Bf7l8z/02At4f8sL+z/1rZ7w/VYAfWLZ/nWi+7/Luw3z + zPFssiSNKMvGswiGualZFCsWssKdLqnvL9A7JadvKg+2VlTFKaU/oWoqnK8IpyWn9y3Ht2G+31DPl4R6 + SdAljV3QFHMaN0eKBucUay1GIof/rIef/eizQvLOJWen64rGbkM2IDYpjCaCd6ay2M0Ku2PpbxYMhyUj + a+izQcEGEiaE0McnfoGmct/onUv79uYhxt+Z5sI8wt53cn4mIXiZRhzOvnR8Wq7ck/V8UkkfMef3cxNj + bOIz9AQzAbspuLHQK4QelsJbJFhIVp/UaUjXvgoQHnsB73MF9Ncctfz9VAAlMe9/LR3n+Fbz/BLt90xe + wBiCMzTOsrSGhYEyBJplQ1M3rE6Fk7cVawNGF1itMXoKC0NzpNSHHr9sCHhwHjWe4Dxqm8gzwETefJNq + WLVr3dfJvLPHmaekm1gQIyLpMyiUoIUHZzBqMI1DgsX0K+y5IWa7YjxSBtZTqaHUCc7PsNrvkIvWHX7P + MnfaIoAzOXslUZvPevNrdmBiPrb0AW15QevUn4nWPXsI+bVDR7ms8VAFp0gPzFBwU6EcG8qhoXCG0huK + xkIwsSIws41MSCCmOUNd/qX/5M/zL1/8kcdewHe2vOXg9/9aT/r+KICYDJ8Q8/5XiIpgxLvF/g6kAjsA + UwnWWQpbUNmScdln0O9RDAbYYgOnM2w9oWgmaSx37OfrUZqsPAqP9BtEGoogYB04lzzogPp4EAIaAiop + vdVF17oF7GkEVgTEpKUPa0j0WgdagpRgSkF6BtuzmMphygJnSwotcVJB1cdvDpDdkmFl6dWCOzHYXg/X + bGC1wohBdJ3z77rz64Zl8V9E8qWVx3ycFX7aMD9/A11Vlr2HNjFoUtPP7AVo53lJQWiqp6CnyFhwM0M5 + NfT6hr6zlGqxTRx1rpqKgTJiyDrU6nIQAG7/S7+Ovf/6v/++bNOP03qD8HNEcH35rZ73/VIAFmVGTP1d + Jjb4tA89J55NBTKCcgrDDcNgXNLvD+mXU3rFlFE1ZtIbMq2GjIoZPXawzTbUI0JjCSGgoVmn3lSh8ci8 + RhY10oT2DdUrYekJ8xo/r2mWDbX3eA1JhQSEJlYG0YA26TEitJdq+1vfV4kC0VdkCmwIZlZQjkrKQY+i + GlAW8ahkQCEDxFU0A0eYGorKUi0L3JHFeoM1vTST0HQKlh+CHWXNsgsPMfyyl6/6CE2b44RUxKOyhhTa + hqSdFt+xwCdP/01n0Zm9CAKFYkZCsSGUE0M1MPScpYehVIMESwiWJmVPNDKK0mvnNMKaKamq/Pxf/fP8 + 9iufe+wFfBvLo3qJw/87EWA/5izp88z6/iiAAsuKGcolohKYITixkd5rSjA9kKEgY0OxUTDeqtjeGrEx + mTIebjKotuiXM/rVlF45pFeOqOyYkilFmCG+B96gGpt75j74GhTqAAuPzj2yVKglztlbevx8RXOyoD5e + sJqvWK0CtQ+E4NFQo2G5PvySkEqJW9hNoxeBUaQIyFBhG8w5wZ1zVNs9+pMR/f6MXjGl58b07CgqAO0T + MKyMpy49OIdbVZhThxHFVAYxDiQQaDJ96Czjdw1LrBVATvvBmaj6DGKRLS1RsQST3Pu0VUyHNHRm92Rl + YpLCSMpBrWIqcBNDNTH0+pbKGnrBUGJwIYF93YGjnRBLSVGXdqoL08n+yr/3x3nxj/3Z78tW/TisP8ni + y8QBOpvAPeBdq6u+PwpgE8s9pqy4AFzEMZMhtpwJvU1Dfyb0JobeuKQ/mTCabjGZ7LAx3mEy2GLY26Aq + x5TFiMINcK6HtT2s9LDax4QeElwnHs7lvkkBeGAJulBkJbBKgzZXnma5opnPqecL6mVDvQC/EvzK41dL + wmpJs1rgVwua5ZJQr1DvUd/E27oGaqRfYzYb7F7AXQR3vsDt9ag2ZgyGmwzLbQZmg56MKRlQhArjLU3j + ISxRU6PGIb6HNAXiA6IexBNYJtNrWglu4+fM2+GdqEQ3V5+9gRYU7DAEwyP/bk1fXvMD1q8TSAqg1Dbc + cX2hPzQMe5aesxQYnApOJc0hjO3KTPsZzgJ/oXMC3cLGb/6B383V/9f/m9mvfvn7sl0/yuuXaPTPsVwR + MbZd4G1iGax/1PO/PwpgF0fNmCN2EHaYMHAXjIyvVGxf6rO5WzGd9ZiMxkyHe0z7VxgVVxi4i5RmE2cH + qYDHYoxDxCIJpdcQx2mfaSb7UDtsPEhhkCrx7hNqHYKn8A2NryibGl8rujCEhcUvAs28ppkvqedL6tMV + zbzGL1b41SpmERYL/GqO2jlma05xdUV5raa6KJRbPYrJjLK/Q6/YYWC26DGl1AGuKZDaRNxB/ZnJu11H + P5YK15HuKwUiJdKSZt5ZwQfrJiCdIsD2pg0J0hNblmJ+nU6jzrZDMIkdmAr+JLn9piBGmD1B+mD6hrIn + DErL0MZUX64xOOOx5BHiROHPOESuS8iZ1bZPQ+oq+o9+9j/jt117HAp8q+VRPsuxEl3/c0TC3RvEUuBH + egHfWwWgwB+hkK+zYwPnij227IBhsY0ZXbLsXply8eI5drd22BhvMKk2mZR7jOxFKr2ACbvgR2hq3a3E + dtcZ+Ip080DQQAihk57reJd5M9k4xltd2mgmtrUyEm+9FqgXWFlYOPxSaRYN9bLBz2v8osEvPH4ef64X + S5r5nFDPoT/HXDilfGJB72rNYEvo9fsUdgMrOzjdomBCEfqYEN9Hm0CoA00d8KqxLsBA0ICnpkERPBYf + +/qhtGWRmLZpxxo0lw7xZ530044lzdPG0diBKKieGQbaKqJM/lHFp47JYlIlpUjsw16BrQzSM5ieYHtQ + FkLfWCq1uGDW4UWnACqIRsAwdxVKv2i9isxZyN9bAjFU4P/3N/4qP/GT//Pv6Zb9KK8f4xiibh0SFcAV + 4JvALeLspXfkrL83CuBnEOY4/iIDHOdkxPP9MU/NdtkZn6eYbJVsbGyyt3GV89On2OrfYFRcoGc2qGRK + wQgJA1QHBFOkQZUGVY8kixntQBxmmT/1meq1NT8m1uPlyRQqhCRsIgEjsWJPVAhWYqrRClIJZugovFA0 + FvEB6kBYKs1pYDX31IuaICvMeIm9tKC8uqS/6xlWQt/3cc04diAOIzRUqDc0QXIDvfQ5DIQiovxe8F6p + vU959UCpIWVEcyuRdXvvXO7bAfPpSFVbf7DO/ed2XpGnELy0dQAZdDsz94+18BsD1ki0/D1BeuBKi3MO + 5wzWCc4IBYJR0+IRPr1OJk230887IUXLZQg51JDWc+iClwcvPs83/vC/yo2/+p9/j0Xpo7f+Agt+Pnr5 + QjtKhhvAy+nY5/uiAP464hqGRjhHyWVG3Ch35JmNqX3mwlPV7Nz1oexMN9ksLrFlnmBmnmKoNyn1AlJP + 0OAiCh+aOKlHm7afneS+Um1Diohii9e21HWdi89pquxep6abqSedEotZ0BA3YWpXHUKIXoVTtIwxqxVw + Khi1aC3UC8EtoPYKZcBu1BS7DeVOQ3+g9L2hqkvcqk9o+tShYOWFJkRwEa9RoWgUDckFTY2iK6hXsUZA + vcYqyITySWvuO5b/IYQ/9/Jb/6MN2o3JNQGpUlHBq0nMnvVQkKCpsagJiFPEKdYJtgRbJpe/ZyitpRJH + oa6dLiysh4omziKqBslOvqzFOicP4lBRktexxgZa3dCCg/CF/8NPc/5n/z79t2/zeMX1OoGfPjtcMRPu + rhJT71PiTIDVw3/7XVcAopQVXBo4PltNeNFdctf6W/1z27PZ7qVre9OL5y/a3cElnYZLMvQXqJrzmHoH + 8TNCU+GD0ugKrw0htZHRVgHomdw10Jr8lnhH3CxdcksWhe7cDdXIb88p/tC+Rogz641i0tx6l/k8QVBr + UCOEKj4og4CbGappQa8SeiqUjcU1BaYpkMbifczjB43183FsdieTkM+2SS6zg1ARpwLZaFkt0WOJmi4G + 4ppHeHfYABlW6+b7lUwPjnF15P8Itm1UGj/3mUGLNgq+KRVbCq40FKXBlhZbGawzlMZSqMMmcDIE2g4F + aWh6p9/guk1aS1nOp9g5YYnOUQxPHtpb+TP9vX/0M/xLP/E7HysBovBf5vDhhzPl/kI6toiku++NAih+ + 0UizCqIHFHbO+QF8asfJb5rNih8ajaa7Q90rNntX3N7kZrWrN+3G8hqDsIv1I0LjaLzF+2jxfcgz+pq2 + 221b3gqpIi+xx7vCT25QmZ6T0eqWEbMOCdo5d0oqhxVCp0O4iGLSPACjUfAlNcALPqHVRUCqgAw9plIc + hnJhKNRhGkto7NrzWM/dOSMEsAa9yCW0PmEBFTR9ZVWQWmtr6j6UUTp5xwSfszy/+H/mAGRQME4+Yt1i + LSvUtgdYxEsowFQGUwqujO5+UVicszhrsRhsMOnUQwq/1soon0Vn6kF6RM4ogfh9aPtA17OJqc3154mk + qzha6L/5H36G3/ITv4P+rTvfC7n6SKx3Ef68CmIacI9YcTsFTngoG/C+FMBf/u93+eOj+/ZEwwCYWsfe + yPH0RrA/tuuGn92rtp7cLC/2J/a6Tsz1MDXXZVxfkcHqIk4naDA0YUkdFjS6jBupQwXLFr/LPDtb+prL + UJO7aDIXR9uZ9CY1tcjjrfJrmJALfDLtVVqE2uS0mZe2AYYG8D61v5JEYjGRTqwo4g22EWzyKkJYi0K2 + sgbaEdywnjmc8Qx8UgIihGVspCEhYm6FpEHi4hHs2gtgndKT7EcnBZhIfOthHdnrSX39cnFPpDVF4TRG + EGcwlWJKsIVgnGBdLMO2xuCwEXvRDM2GjtDHlYs54/WVjgJ454jnrreSFXD+7uURr5s/89/9hz/D/+jX + /04GP4BK4NcQ/rwqouDvEJXBA6ISaC/p+1IA//5gXxRGClec8OTI8txOKc+dD+NnzhUXr54rn+jvVk/L + 1N2QgZwzVdiI46xDRQiSrH0EoVA9Yz8MazILEotGumWt0lot3rGJstUzIVo8L8S+/CaKjA2kkV9J+HIp + bbb+5NkAtJY2pNvORIH49meS65y1XhK7/IZUHGTX0tq+Th5B0Fo+L7GRRq1oLUgDjVN8av999o3O8vva + 0EejMJN6AGZPp+XxB43TkE2qWTBgrMR+/s5gXIz1bXosVzKKMViJpc2icQ6Ax3es9Nn4vksSDJ3Hu0CN + dq5XG++zViCPKrfqXoGf/Qd/m9/2G3/XD5QSeI/CD+1gefbScYuYDmy9gO9IAXzu5+EQY09oxqJ6taf6 + QiXyQ9uFe/Eikxvn9eLWjn262jbPhy19RibhoilliKjFIzQsCNrgVdA0nHPtHNKmsrKxVCGmnyB6Bqxd + 2cxEazcTDznDCTwLRvAarbuVgCHjCtLSYCXPsWt73gkh1f1nhl1Ibby7o7za/Zx97cxDkPi+rRvOmkST + 1xmUPv9pAG0ErTW20m5fsiMxjyxEXKPnLbsn04TbUCmdv1XEhVh3YSWCfE6wRbT21glWTNvLQDpvuwZh + 18i+0dQV+Yygnzmzs/eTR5I/UpeQ1IYGdCYbp5VhitxtCYGf/Qd/ixf+vb/IU//pf/GdbOeP1PpbOH6K + g/f6dEdstXeeqAAmRGbg+1MAc8EF1R3gqT76wgA+sym95/fs3rXzXN/Y4Um3YZ5gbK+HkVygYorFRn69 + eprQ4EOI1V/JHRaR1m3XlL9uoz9Zb5ozciedzdERflK+WQwxdu/Gv2gKGTovFGU99vnr4ATJjJ/h2Ocy + /PXk3S7dtht/d6L+dPISQurKq63zYs+e/totaIideHKcYLTd9DEejjhFzunnhqBnNEoHIMxxv0gENnGC + KaK1N1aw1sTDmWT5o/AbNXFWYvayOicaXzLb/cQROMNC6IKA2vEP8vV6iMHYUQgPP7e7zoQMxA/3z//4 + vw0KT/xnfw3zMSQLeYS/xHl+mlN4b9Yf1grgIutsgAPq/AT7Xl8pr+ufx7rAhlF5rkR+Yob8+ov0P3uN + vWtXeHZ63nzWbplPMbNPMDC7lDIwiBDwEeRL5JPcPCIPkYAEBpG/4DToIv9eswvc2TTvxL7SC63prxn5 + OxOHara2sq6eS38QEwBpMm4LtEl7vhlrwCgUipSKLYg5cLHYDkIfMvLoiXl/ry263W3iGbv7xNZbGlJc + n8g2pgeuhMIJTkGCQYLJQdIZ4ckeUA5LukU+tHUXMZ1XVBHVL1wE96ICsO2shNaSd3zzR7U/iyyKpCza + 6qB4m695xGG1g/6vA4FuwPBwU9MziqG7B/QdXzeiwu1f96O8/RM/xuW/8/ewdc3HZZ3Q47fxB/iPEOJ8 + zyPehdn78MpfRgPcB14npgPbCsH35AG4z0PoY8vAcLHk/ACenSKfHVP+0AaDZ3bZObfNzd5UXmQon6SS + K1rKREycFkEIvgWKfOKEI7nkLNuPuNb8sYeC+7QJ18LfQuDxV+ZMENF++uxWi67n3QVVmrD+XdxkeRx2 + 6nGf1VAGpuhgDx1XRLygTSQXNRJHfdqsUDodg3IeO6T8e0hxeasEJFL9M0WXBmQFNPEz16I4fMQ1fPxe + VWyrpELIqYTItJPUv3CNo9D2WDDJwjsjUdjXLKLEiaBF5HPdf6tdHtpf3eud24V1rhDdZOf6e333nZqc + rnZa0dmlbf5QHtob+e6DTz7H3/wnf48f/7f+GBf/v//wvWzvD/V6zTzH7wn/AV/lHwJf552VG99yZVLQ + LpEXsEHkCLQxxHsLARwOZQPlCYHPDJAfPkf13CU2r+xwfjblRtmXp+nxDI7LGNkQkQIlDeIMaeNLclcB + yTOq1uY9ZaE0qQ3IdNH4jWtrHFrUuw3y42l27FbrIrTeBLSov2oUcuk8Nb9wpq5qVhgmbtrsNXQG4MTw + ojZgFS/CygEm4NIGzZYphwEhZbFCHpUVMt02gXyp77Y2gjQS26B5aARqpxTe41BQm8g+MYhQ0fi3EKce + FVHA82czuhaceH2j4Nts6Tsx98P4YlbH777D8hM7yu6hLdp+h91Htfsa69vQeWZWzO3TO8SB1PWsxTjO + zEEU+Ed/6c+x8atf5Cf+7T/B4PZHDyBUN+B/uPjX+C9uf5Jm/pUk9rHw7NtQALDmBOwQ+QAjoufv4ddQ + ALOfR2pLtWrYdPBEH354qvzELtWnLrN7/ho3qk2ekIonEa4AFxAmRDvoQX2kuGoeixXdyJyuElk3mUTW + MWLuDwd0mlN0e++f/bKzIOe21Nmtbl9Xo2dxhhrbMUSthVNtE1rrJBvr9FT3+UHRmpihMEKdOxglE+o0 + E3eiec+xeFA5MywjoASblE57KTS3/Y9ek0vEIzUYY7DpzYI4UJfew4AxiA3YQhC3rg3oClLO+YtmcG+N + WHRvWrRN1kr0kRs1o7Ttl3V2nbH/rQ5IauXh8K1bsviwA9jx5LoPaGJ4ho5yzwrs/iee5Wf+m7/J9b/2 + t/ihP/sffDSwAWPg9/8x7p7+z7j7zzaoG0/sQrEi0vlXnIWR39MqiII/JQ/LgFP4Fgpg9gsYhaEo5yrP + k5Xy6R347FVfvHiD7YtXeKrckU8z4GkM5/BMCTIkUKw3XOaVt9Nxk5uekfy0GbJAZi5Ka6kfchezFc9K + RLp7N8f6Gfjq+JR5P1mRs5sq/ZmGHHpqUkQd7aOdsLQFBtOtj8w+FRAXHzdE4o7rEBba/LxGhRe8EFIt + gJpEdpKzIpYFJ3pLghQxRi8LR+Er0IKARTUny2KFpJiAWG2r9tqP0nGnNfnZmroYyZnGotp1qlqk/V3X + Gb3xbpZp3aGo/ZzaPac1IBJxC4nKLKcyO5pC06u1dQtBW0+qW+Kc90ZQ+Mrv/p289JO/kyf++t/mh//i + /43i9EM4fHQ8gD/8k/Bv/DTN3xZO/g6cHHoWzZyGI5QjYgo/D7j9tpYQmYBTIh9gTMQB/CMVwOznER9j + h8tO+UTf89ltbz91merJJ9k6d1WfLHbk0/T4DHCFwCC6zmLTDD5pe853LW7rYnY+Qhcxf+e9s59AMzko + l7UJyZLRcvnzXtacXUDW+ECrYKRtNhpUaUTXQ7Ykd/PNLDY5E3W18EUedxXAG406tojxtTPgc1fgMzh4 + nsQrZKKsEDAmvo9J7Xm73AJp0le1FKSMQm5d8pMkAUFq1ldJIr1POu6K0tUFSamZxL/oEBHi9yPra5Qr + L0V5tB7Q9TVJcGD2xt7xDeewrdX8ayFuDUU23iaObVeJ05NCCGdbHeWIJntmObrJWZL2/WMvOjVxOvLX + fu/v4uu/93fx5F//GV74K//xhyI00Iu76L/7v8D8kZ+CRtBfNpzuW+7fF/ZPlpzqATV3CdwjNvf5jhVA + RcQAtolewAHJfzyzNpLwK1w2Md7/sV0tP31VZzdusLdxRa6VOzxLn08iXCUwS+75ihxBn0kFdTS+ZMRb + W5xpPYG2oynOTrzrfgppyTdqtHX7cw46dL2L7mXquJWSRnF1O96gOcd/1s0/G1rED9N6IRHQQOsofzqP + rQZqVWyVMA58JBytW+ekVw8xPBAfn2fSDEETxx9LkudQKxwHuBurEFdVYO483nmMqxFjo8uYzzZKT7Se + xrRAoLbCFLVL/DmhHeuJISl8Wt/mK7FWfl2hVmIhVcAquFRb0LY+f0h9t55/Ctqz9V7fD2uEP6Uu1MZQ + 0ASD+vScPOrIpFRo6ijcYgV5P2W9oxC8piO+/au/+3fzyk/+FJu/+kWe/0/+U3Z/4Rcp5qffRbH+1ktH + A+p/4YdZ/e/+ddznnqfKNdo1NIeWw33H/QPhQTPnhPvU3EG5T1QA31F2I3sAG6xpwbd42AOY/AISlL6B + yxY+3YPfsI390au6cf1Jrg+v8oxs8gwVNxHOowwTZJat2aNQ4DMfvXWptSPMJrv92d1Os+slg2/yEAi9 + NjNtWkmMYNPzbFvZ1yG+ZMVBUkRpqq2muD9IfK5p9/dZ/nruitvGzJ1eWbrq0HmJMkgVUhltnEloxMUU + m41Ql4a8Uw1GoiuvaqIW8hobla4UnQf8/YamrFmVNcelpyjBlYJJNN3W4olBTIG4ElOUiLUYG5WBcRZj + bbw1kur7E0k5TxXBohg00wNzNiORd3V98bNkrbMMkFKIa7z/4R3YZjggFSbJmlwhtnX3MwaUC7vWPQ3S + eaRejxlZMWffav2G6XtWjQrAq+J9wNeKbwJvXX2KN/7kn6GpAxtf/BLX/7u/x5M/9w8Y7T9INRffnaVG + 4Pwm/vf8Zha//7ex+OFPIkBhO7FWAB7A8pblwb2SW6dwhzkH3GXJ23juEUOA7+i8sgLYJCqAjfTzWgEM + fgUJNX0DVxx8egA/vo357BUd37jJxeFVeY5tXqTHkwR28FTpa859BtLk3U7ut70A621z9sKkU1M9yw9v + U4Ky5uVrlIv29buv0SaXuoCg5MxBR0DSZgtR2gk+pehl3QY7n3sQaWvnpf3Fev6etpsrHaL4Mm17Gxl1 + mkaROzFgC8Q7jJPYb1CFkDrkEgxam5hOXAb8ieLngdWyZrWsWTYLVpzSuFMo59iqwVWKLSIHwVhNsb9B + XIWpBkivh+kVuMpSlYZ+6RgWjl7hqAqDsUTwURSVlFIUB+LifRNHMsXHbUoLPvQtZiGMxotaTft5ojKP + aUmRgDEhnWOITook5oBJ05o1KqqsBHzKlYbWkghrKFVb4tP6+8gl0trez9yK0Ci+VupVYLXy6WhYLT31 + yrOqPS9vnuMf/vb/CUe/9XdzuJpz7pUv8+t++eep8fyWL3y+fecLh0fvKmVv744pRCgMPPg9n2bTFZT/ + 09+E+8ynqf2QhoomdXhup7GkMmoOFH1VWLzquHevx5srz1vMecBt5ryJ5z6cLfn9dhVADgF2II/NZukA + 5MtIWNK3whUb+Gxf+I072B+6yeT6Ta70r/Acm3yCiqeAPZQqXY6cknhHlNmmadq8fSeXnjV2S+tM97ss + vJQSjzX7so4P24rVFiVec9zXWiXd7XgYGqR1A4MPLXIcvcLcQTi/bub/r0OT3MpaH6XdMoaWpuFoW6sT + N7V1sa5YrMMoBC/41BhEa9BGYA7hKNAcNKwOV6wOVywOl8wPl5wen3LaHLGwBzTlMRRLjGtwLmCKEIeZ + lAFTGKSsoNdHhn3suKA/skwHjp2eY1YWzKqCUWGwVmmMUhsIYlDjUCnSrYu3xqA2KgM1JimK7EYJIgZv + DLUY5gEWXqhri69t7HqksauR2AbrPLZsYnlxAdZYrBZYChwOi8MS+yKEoDRNoPEhfmcJ+yGFDd5HBRGa + 5NqH9J1qnHQcfLT0wQcar/hGqZvAqg4sVw2LVcNiWbNYNaxWDctVw2ndcNwsOdEVp6bmpcsz/qsrv5la + PH/iJ39j7FGRQr8gwqIQlkMIU2GwKVzaMjy7Yfn0rODTgz7PFEOMTCl0gg9DPGUKUUNKc5t1nNIAtxS+ + Ipx+peDW7R6vNKe8xhF3eYM5r6cQ4H2Rm3IIsEv0BPrA3PEVSgIlwiUDn6rgxyfBfO6cjJ+4LlcGN83z + bPECRp/Cs5uE36ez7sSEXbc8P6QP5XTPWOPk8id3v32ZTg7dsAandP3ySXtErRBaNPmdfqCY9cRavMa0 + mo+bxLMuH153DhKMlzYcyf13sjJRQGyqqXeKreLGNAa0jI0DxBvk1KDLSN5ZGlBpUu1BjXqDb6CpoVkJ + YQHhJOCPGpqDFcv9BYuD9XG6v+D06ITT+oi5PaR2JwS7QKTBGI9xAVcEXKGYStCqIPR7yLikN3NszCzD + kaWsHNOyYLuyjJ1gjFKjrDQqAKwjmKwALGocmBSHW0PIyqCDuKkraFzJ3FmCCEsvrJaGxbygWRWExsV5 + AtIgtoaqiaFREduLWTXYOO0RJwVOHEL0ipqg1D7OTsxaV2CtALpHR+h9um0aT9PEDs+11zgc1nuWjWfV + 1CzqhmXtWTUNy6Zh3tSchpql8TSFJ1RKKCAksDRiEERspQA3UswM+huGCzPHs9OST45LnhuUXK36zGSC + 82OaMKShxEtKgbeNUfKOC7BUuA3N1wwH37C8cQ9eaZa8wV0OeJ2at4j03/cVlhRE8G+DiAEMgFMHnBdh + Yg2f6gk/Plb57FYYXdmTS/0990m23GcY8Cy1P88q9HI2u6Xtdp33Fpltf8403mjGIyy2jrtz++eukmj7 + 1pGaXSTgbZ2u1patFt1ofTRomPZpiy+Qm0xop2+Ats/LDT9sKsFVCagNEeHPrhqRNWed4orUGNOkL9IX + yKrCHxQsF4ZVU7O0c06qOUW1oLAeq4I2Br90+GVBs3A0J1AfeZrDJavDBcujOauTeCxPFyxPFyxWc5Z+ + zsrPafySIDVoGlVuAtYq1ipSCE2l+IHHNQucWHoibNaWvcKw5ywbztA30RI1QamDRmtkTLL06RDTZlrU + gFohuAhSRmqxQU1JU5aM+gWjvmHg4P5KuH/imJ8MYTHBrPrQCF5XLG3DwnmWpqbRGnwN3mM0Fh45cYix + BGvw1tAIbaZC0DTCLGZffNDUPAZ8COnntQLw3tP4EAU/KMug1BqoNdCop05Ho4EmREXR+Ph9B6PrWQuS + jIVR1AquZ+lNLdOZMNuAC1O4OXQ8PRhysz/gYtln0/aowhBlgKfAt9WsSZElt9SIx/gA+xDeLLj/muOV + t+FrRye8Em5xl9dY8QZwl1jE922j/w9JBH3WXIAhcOoEnrWw3YNfN0V+bEcH1/fC+cGOfUbG9tMU7gWE + i6iWoE1iyJmORV5r52jBz3oFXQQ9utW5QxxnylezJc5oQo7zuqIdeQIdBRA6rvmjLo6kMR4duF+NtiFK + N1NBCk3S/N9YK18oUmgccilxLLgzhqIQilIxVRqXU1vsUQlHPZa3CxZ3AyeLFadujh/cww33KYsFpSqy + cvhFiV/08POC5tSwOmpYHS+o53Pq5ZymXuCbJU2zxNsVzaBGabBpJLh2CmWlS6BK4L2x0LfKtnguB+F6 + HbjaCDsIQ5NYdD5QNB7rtXXpSWm3FKS3pKaYLYhKQJ2kvqRCEEcoS2RcoJuOrRGMCfSC48hP8PUudrmJ + X5TMa+UwCKfBcOqF+aqmXh7R1HOCb1rFrlbwhaUpDd7m7MFDULJmBiU05LLkZFjyQVRwq6CsfPR0Goi8 + CxuFPKRbTQo+AskRH9H0uFowJhoN0zP0ppbtXcvFTcPNsfBkr+BGNeBiMWHTTRhIHxcqRAu8pOlTLWdF + 2/jWqOJqxT5QwiuW/ZcdX3vL8sWDE75SP+AtXmLBV4E3iej/e+L+/1qrSII/IXIB5s7Ap5yyPQp8cteb + axfCbHSB62yb5xnaZxF3laBDgl+iPtLTNAF+Z7H+5CqTM96cqV7L6cEzubf2Lzp3c1eYLpjYwQFymICs + 8/qm+75tzL5+LINVMb/POrwgIcotf57kMghSCq5v0Z5BCsEZS0FBpY5CY+MPrZW6UeoTYXXfEN72zN9c + cXhnzoPTA47MXer+Xcxwn9ItKELA1I6wLAnLirAq8AtDfeqp5yuaZkHQBUGilVfbQBFTdWLA5TY+Z3m6 + sdWYAS3A9pXBOHBupDwxUJ4u4YbAuaAMfMTRQ+xNhmk8NryzhTg5a4mmjkxpHHlmOLn43ICBwmIbhysK + hqXgCqV0htNqhYpBSqh7I47rHv26xK0K3KLiaCWcBs+yCaxWSlPX1E1DHQILlKVRakmCnXJNuaIkaMza + eIHGplAuZXo0XSI18W8ahdoLTUiDSF0ibRW0PSOxkRptjMMaxRYGVwlFT3C92BXJFEJvaJhtllze7nFj + WvBkz3HNlJyzIyZmimME9PDB4XO42+16ms7PiOKA8sRgXnGc/GrFGy9VfPGthi+c3uW18CVO+CXgi8Ad + 3mfs312GiAVkVuDCGeW5Qtma1lw6V7v+pbDBnr3GZnGTnjuPMb3IWpMGTBPdsS7LpCP4UTuv03kQn6uZ + vENMW+dKvFbmu6fYsmCk8+qd/WnWm99IBlGjpc9tvbrKIOMDydGN/QAyZUUENYq30RrkRjumEGzPYPqC + 6UUGXiGOSgvKpcOeGPRYmT8ILA4CR/sNy/0lywfHzB8ccHjwgMPFfU71gMYdI8UCa2qsKhIEbVw8fGwy + GlZKaBqC1gS7Qm2NmkhWiKQYi0hWWZ2cf7oOaiGUghnAcKScGytPjJVn+3DTwZ7CgHV3pZaBl33qh/H9 + 9od0DUOnmZnSVgiJhtjg1CkcKa60jPtQmIDvncLgHsF4VnbJMTOmTcHWsuRw3uf4pMfJaZ/TxZzFYsFi + uWKxWHG6WHK0WHK8XDGva+rg8QRWBAJh7bYT6ye8gZCHyOba1qwEWgNkWo6COJBE2sLRKjQtJE42qgz9 + yjLsOSZ9x3hYMOg7hn3HdODYG5VcHlVcqirOuYqpVAzpUdBDKQnqEv0oe6Upb5V5KMTOTkUtmNsl9UsD + 7v1Sn5e/BC/dPuIbq1e5zy/T8EvEZr5HrIPU9+0FCHFI75iYCVg6gSsusDFq2NisjdmRoc6KLem5DYxx + GnSpioqYBmuNRAu9vroRzcyxjbbKoWvoRdYufczNaiR6dLsAtQSOdV+ZkIGfhzC+nJo+01c+ZVYeDgdC + ik0iu1SxqQjGplkB6sC6QCgVSsFUBls6XOliDzzjcMFiVwa3tMiREO4py7c9x297HtxZcX//hOOTQxbL + +6zqO8yXd1nWBzR+Tpj71g1ay1W9/j5CwkmMxvZitgGXCEIibZ8EacuM8wXJMaoQCsEMhMEU9ibKEyPh + 2QqeKOAcQj9hRz7P/kMQG2IRr7Z65KE76+/Qa57P0QIx63g2KGEhmH0wHnrDOBOQvof+MX7oWQ4b+pUy + tZYmGFarIfN5VADzOcwXgcWyYT5fcXwyZ//wmIOjY47nC1ZNTU1gqZ5FaFhqw8r7GM+TWJzZjbeghaIu + hm1xuwnqTSRu2VgjYUpirUTHG6ASTN9S9B2jvmOjV7LZr9gaVswGBdN+yWZVsFs4ztmSiVRU9EBLFMsq + e5SqCSTvsGJkbdecQNGAfWDxr/TY/+KI175U8PLrh7w2f4v77qvU+mUKfZ2gx9HT1iE+WEJYptc+63V/ + mwrAEQHACbBwopRGMWVgMQis+mLFYaqgXpbhKHiZq1VrjRRlYa2NJagmTcLNzS2i8FuTLHzaqJnQ0RYD + 5QrgoG0/+szdDxkPaIU+tPTfTBVt9cQjiQW6vtCJuAMtRhfbaxfS1r1bYyKJJo21ogdSGkzpsNbF5FTj + sCuDHAt6oPi7nuXdmvmdmqN7S/bvn3L//gH7Rwecrg5YhQM8h3g9xOspGnxq6mHQrgaQ0OInQswsxLS7 + JvdVEjtQ1p+k6w5lwTTgSzBD6E+FvRncHAvP9uAJE1vA9EN8u1yF2aZG2z4MktsVtC8fsZDsqZk0RGTd + 2ahVABIHtchC0WWAQ0EGIFPQGQSp8YXi+3Hn94cNVe8Ey4SmnrFYjFksByxXBXVtWK2U0/mSw5NjDo+P + OJnPowLwyip4lr6h9oGVb1g1noX3LENDQ2hjem8Vb9PPkihqqZBDcsejUnCFiZ5eIanxqaHsWfqVY1gW + TKqCjapkoyqZViWT0jF2jjGOoTqcFgQtaHA0mo3OmjSer21b4GVIlh/cA4t+w3H0pYLXv2r42tunvDp/ + g333ElJ+lSn3mAQQ4lCcemWYL5YsVqfUukiFQTXrxnLf1nJEMHAEzB3wmsDQwr5TgqDW62rQ+AflXFdW + CEWh5ahkPLE66ImWEue4m5zsRiT2jxMxGCNtnlPbipxE7SSRHnw8QuorF/k52T+N3UJCmwUI6dBHflbN + 46ltwrFaZmzO7QntENJKMKXBOYMrbNwMhcGWxO44xmHUISuHLCxyBOEw0Nz1LG+tOHljwdGtEw4P5hwu + jjlcHXA8v8d8+YDan+CpyZOERQxistC16GbLiOvqZMkNRiQLvW1/mZuidFlKGh0oQhL+wVTYmwk3J/BM + T3jCwjmNRljaqsMOIzrtVY+yJEJMc6CWKPh9YKiROXLGjGXlm9qR5zBAakVWCqHBV4bVwrBcGhYr4XTe + cHxyip82DDcO2droMR1NGJRb9Hq7eL9B0BEa+oTQY9X0mK/6HK/GLFZL6sYTmpBSe+vbVdMwX62YNytW + oaGRWFZdS6ARTyMhlllrajVrFOOi4BeloSgMrsw/C5VzDJ1jYF2caGwsfRvHnA2so28shZg4G0ItjRqC + mrbh68ObM2eZ8nQjCxQrwd03hFccJ58veOOLga++echXl7d5q/wSde9LjPpv0JcGwwwrsaX84lQ5DCsO + 61NO9ZQVxyhzIjHo21YCNpo7hsDcCfycQCnxe/egEnQ1XPh747l/c7aqH2zhzbnSb4ZSN6aOQWUpjdFC + rJQ4KSltRVmUCCWII9g0OhubUGqbMABBYmfOiNAnAC/TcDWBU5pYONoOq0u8g7ZSb21Ns6xH4ZfogZh0 + PzMCHWgJ9ARbxTHcZWkpnI1TbUSwwWBWDj12hAPL6l5gfnfF4u6SkzsLjm/POXz7mIP7RxwvjzmVQ5Zm + n5U+oAlHaAJq4mc1UYhtxBjOemtrn1tJ+tEqYiPrSGIX0bW45ngnxd4aIvrtC6LbPzHsTQ03R8IzFdy0 + kerVz+CrUVQktTYnNjDxSu3hKMAdlLcE7hphYaEvwo7ABVG2gV6CfHO5dsuG1I5SV9JkI2W5Chwcw77C + /lK4u6/cqQKr0ZKNLbh+3nJt95CNyTGuOqHo7YPMgOg29Bky0B6T0KMOPo1792giBZFy/3XTsFgtmTcL + 6tBEmq8oDUqtvs0MeDxBAmoCxirWReEvnMG5SKUunKFnLAPj6InBYbAIDqHAUKSfCQavhiYdKbncfq9n + xNCENpniEMraYO4bwssFx1+oeONXha+8fMqXD+/wTfs19odfQHvfpF8dI1JgqbDi8B7KENBVTWgKdOkg + GGpsBGFZJm/gPXMELFG3D4CBA/47Wq9PvBHrQXorPdp6UL965f78azeW8+WBXW0e9P3uZk+m454Z9Soz + 6JVmUFbSd6UZmNL1jSn6SFFhbNEO87RisdbFn8UiajE+ct4zLUJlzbLTtMk1uVWSqIO5ccWZrj8p5FCb + 8qpJAVgrrSdijESQzIFWBlsZytJROYcTE4k/NXAC4UDxdzzLWzXHby85uH3Mwd1jDvdPODw45fDolJPl + MSs9JhRH4E5Qc0qk1GgHHM2mPZ3kGfe9ow26xIcMZMXAvhUwIV6ziLcE1HhCoZiRMJgazs2Em2PhmZ7w + pFX2AgzzpJ2c0ct4TIBQw2qp7NfK6z7wNQJfsfBGIZw6YWzhpoHnkke1DZSibVORjKnQ9njQiKwbwWtE + 8B8ovH4aeGMBryi8qspxqWzPlNv3YH5pyZXzczY2DxmMRhTVFDGbIDsI2ziZYcyAMrY/AR6aD6HgQ8Oq + say8o9FmPZBE47zIeD9dM/FoKryKe0TimLNUeGVEIoWXKPzZS4q3kWuibd2ItLTxh+x9+zW3WSrAqlA0 + YO5b9GXHya8WvP4rhi99dcEXb7/N11cvcaf4AvPiVXAPsKIYLCa5skagKIVh3xJ8Gd9hKUiwrHAEToml + /cv36gmc9QCIuYZ4mUWDwahIZVY6nx01b925u/jawdHxwV2ZT3f6fm8ycpuTSbkxGBUb/Z6ZDOahGHpv + Jk1tx1qXQwn9ykhprHO4Is6OK5zD2XhYKTBagjo0TbxrwRojaGEwBRQOKgOlWArTQ0wv+vGyBqCQiACr + JRErJOIQbYfbeF9MpG+SyCaFt7jGIQuhOYb6MLB80LC6t2J5u+b01pyj20c8uLfP4dERR6enHNdLTv2S + FUtwc5w5xZlVJONIRJzauK+TVtNupUoLjOYce7T6mfgEScBs3HhGE0deTbRmTtFCKIYwmhh2Z4brE+Gp + nnDTwHkPgzq6/Z2XRAM0daBewGIO95eBN2rPV9XzRRP4ioM3VDj2wtQJBw4KhIkVBiguWcNu2rGNKVKD + UUy0iCuvPKiV12v4Uq28tIRvrJRjUTbuK/uHyvHRknsHS66cO2Fv8wEb0/v0evex1T7i9hGzg5UZypAI + Wtu1m5dCSo9L28HgNBK6pbXDXbc8F6tFV1m6rmO+TJ2vqKHjsWUSWeadqIA0qRK1038qGyZZ80WMOKy3 + 2FNB7wjLVywnLzneegm+/I0lX7h7m68tv8od86ss7FcQ8yB6aKsCFcGbGswqlrUXQjkQRmqQUCBesU3c + I7WR9pOhK1oG07svky5qH+i7xTMsF8DfB/4+c+Af8tf++b/JW6tfPKi1/uYyLE9O6/mrrBhrcH0r9Pti + S2zPeYrBoT+Y3T58cOHe3aPrq9vcdIe9C4Wv+rZ02L6hqBxl4SiLgtKVWFMhpo9SkUdexhJPQfsGNguq + Hcts4tlxyqYZU9iLWHsRMZmJWLcKoFvIk8MBY2LzS9MH20s53pXFLix2aeO4rlNY3FOOb3mO7tQc3V9y + vH/C6YNDTg8ecHr8gNPTAxarU5Z+yQrPygaCDYhrMHZFMB6DRGJOdgk7ace28CE3O22HnGaRDxgJMU4M + Fq+Ct/GzWJPCkoT6B6c0FZihMJkIl2bCjYlwfWC4YmC3gV7O6edChhBrH1aNcrRS9ueBO4vAa3XgG+r5 + igu8bCLV5J4XjgPcC+CCsIfhEoYdI4zQtj14iNgfmdQiNiLpsbRBWAU4VrjVwNcW8NIC3lgJK1UeLAOL + VeD41HN/33PvNlzbXHBhc8nmxpzp5hG9yX3M4A4Um4hk1uooea1t7g4weCkxktNjIfmTnX7orZbKeFXW + wg85ZESw2acJRxnnOJOBSh5pEI+aBlI/RUukM4tIJ3QosKGPHFXUr1mOvxh48JJy62V49dYpX35wm68s + v8It+VUW9qsYeRunK0SrGAKaQDCeYGvUKYLDmQoTHKZxGA2RTxGUuQgLKai1Qv0JNPNOlumRS9KF7JFC + gHesJQtEqEXkngiHYnBixEpwVprCsipACq2DL+8c3Nv6yltff+qNV9/+oeWrzaC4U26Vq7JvS4sZCq6y + 0eUuHIWrsK4HdoBKFavMFKhTI65NBzdLxkPHpWlNVcDM7OGcUNhtMDPO0n6ifHnyCLCUhbDE+NvGNFnk + 5ztk3xGOhdWJ5/RBw9GbSx68ueTB7SUPDk44mB9wsrjHqr5DE/YJegJuhRYeNSaGM8ZEV1IAiUBQnDiy + Tn8SOlRjG9bVT2rSnAETeQkSS6g1jR1TMXhJgKau2ZIqntrCqgr0BjAZwaWBcKMSLlvYCtBrFFkqYRlz + 86EJrJaBkyUcrpS7q8BbK8+rtedlAi+XgdcM3C+EuYGVxmGnxwHuq+GetRxYmKuJhVrIelpPNqI2Di+N + Y83j5KTGC3UQjjzc8sqtAPOU8Zh75a1DaE5h8UA4egvuTeD2RsPFnWMunpuzvXfIYOcudjpByk0wsZWd + yBikj0iFUKEUKaMu+ISRrEnpac5EpqCfMYjrdF13RX1p2se7MypaNppEPkycChV/aZCkkhJ2oA7TlOhx + n+U3++x/Xnnj5095/Stzvnl/wWv+Hq+Fr/O2+QKn8hXgbUrm6fUbgqxiExQbCEWTSEqAsVgKSvXR8Cwc + tgGjRRwpr/04SN5HEPpbhANnPYBHPeMPvviH81UMtDSkU+CVdMT12/613y5v2VePX7//Zu/+W/uX/Jvh + UO5LY+qUY+0llL0wFNZQWIexJWp7qCkAG4VlGQGM5oKBYcH0usPYhr2yoJETxO4h9hoim0jyHEjssBSO + rrkBFowDMQatheZUCMeWcM+id2C5X3O4P+fgwTEHt444uHvMwf4JB/NjjpsjFn6fRg4Qe4wtlljrsRbE + xPAFcWeTjCE18shuvSbUH1JjDiLIlzIjJlhCsGlvCUE9IZUcZwc1e50+TfYJAk2INexmBb2FMC4CI4Fq + KaiH04VychrQZayCW64Ch3PP3Xng7ipwqwm8qZ7X8LxeKLdK2LfCyppIH/ZxbgFEfeaDweeOQC2ZRc7W + becET+si02m5Hj2CGkkwiGJqJSwNR3XgdQx1Bff68OZIuTwL3Hmj4dLego3zR/S397GjB9hyH1vex/Rn + uMEYV/Sxce/SyBBv+6lkec1xWGeoUlZJHx5V+s6VnaZuKNdVBPG7CTixqQU6uLaW0WGDQ2oDx476fsXR + WyVvfw1e//wpr3zpFq+9dZu3lve4V97mgXuVE/kaQW7hzBx1SlMIoQgE26T9ZBAfrb5KD19WiLOoi5WV + pVHC3OFXhlWQmB4MK/TX7vObPYAKqN7XaLCX/vFXeaBvcrKcazgJyimqy1TLnXoY1sa36TmT+Naxvjyl + ugLoSlNWQNAbhnpl2JLA3PXx9FBzh8B9hK3WFYVUlWcV63JLbdqYNywVf6I0DwR/Vwl3PKu7DYf3T7l3 + sM/+8X2Oj++zmO+zWB2x8KesWOLNEjE1xjZxQKiRM2B8LoZrXcM299hupXXTEJFYo986CPGzi9iUV4/o + nzehZYvllJGEqACajBsslXIV6J0o7giakXDcN9xz0dqGpVIvAk3taXzDcV1zd+l5axG43QTuaOCeDdwr + PAcOTkQIYrHkeom1zXASswFDEarEoNPMnGzTu+3HTfyOWBlZCPQF+iamlkyuC1coAvRW4BYw9/DGqXDv + CN7ahzdvw9uvKZcmyu52w3h7SW8yp+wf44YPKLcmlFsTitGAsuhTuBFlf4brT7Guj+DSeWVQyBLRyYDS + pJN8WA7WN1mfZaFf08XzFw5iLNY4nAguCMYbTGNiB+eFIewblm8r915d8crLga+8suIbr9/m9btf575/ + hSP7Fku5T633acw+4ub4fmAxgjCCph/rIKDELiqK4wHFvE8IZZpK7aFcRtnxHrtSCjVUTaD2EEJBE1zi + vL4ra7AbAvTelwJ4/RuvU+vcqGqJUgIF+pAn1qHnhs69R/KbT5PSqNPGF4/IPir38NyFsIfTCkMPY8y6 + N6CJWj+shLBQmtPA8tCzvN+wvFOzuuNZPWg43V9wcHjE/ZN7HC7vsgwPCBwSzDGhXCEECpHYwcek7jqS + aUWG2EHNrEtis5C3wpBBqvWPuY8hklmOqXlHGu4R26ULGI9JLdElXaE809AEpVoqg+PAdNVQODgcGl4b + Gu64GGGEmlT+2rCg5kgb7jYNt5vA/aAcinJaKHOjNEGwGgeN1Co0pLnRIvRF2LKG886w6wxTE5/XJiay + Msh9FROxK3de7gtsWNhzcL6AV0PqPunXbeBswm1OvHLshZO5cByEw2C4YwM7Q2U28fSHC6reCjecU2we + Uew+wG71qGYV49mAva0NdmYbDPtjxFZ4StSUYCqQHpgy7ffUC6xt+CDrbZqdNdIEZk3hTptxko5CMFgc + xjtYCv44sDxuaI4bVvsrlm8FHrzseePlhi+/seSl+/u8uniD++EbLMtX8XobkWOMaTBVQMfKakOoN5XV + zNIM+vhiiIQBxcmI3oMJ1f4AmTuC9wQW2LDAlkuk9JgiYEUp/YqyWdFoQaDCU6y17qMVgCOGAe/PA2ia + Bl03hO9UqXy7K7m+QWJt9FzRJRBq1B0R5B4a7vH/Z+5PlixLlvRc7FMzW81ufHsTXXYn81QDFHBBDkBO + +AQc8Q34EnwQPgQfghOOOKUIhJfEFVygCnW6bCPCI7zZ7erMTDkws7V3ZJ1TQAnyVHGnuHhkhPtu1jJT + U/311/+XsEXjdbq5sbysEkfBD4LfGsaPkdNHz+HhxPHpSLc7MhzSaG3XHTn2ew7jE33c4TmC7REZEeMT + ock4rEkBIIMJ5+Whdh5Plhngg6JEmjaGnQEj1Tz0rMl0JFmOp0VoxBBzMqkzRfdcX0eTAoBYqAPcdPBy + H7h+CtQx0i0M+5UhumzgEdNY7Gg8XeU5uIk9kYMmyshgE++iilnzIAiTCoMmOkkErozha2f4t7XlX1eW + r5xhQ3InjpfS7oVtJYXVCYkKnk7/lxb+0sG/q2CbSUgf09Akp9zJMrP/QQr4h1HQATovPN0bboxhYQOV + C0g9YBcBc9sR3jiqry2vv6n5n75+YPN6w/V6jWmWqFsQqyVaL6FegSzAfFqy6QwiQhk8KyvJpqbr7JRc + 7M7SXZJEAuor/M7SPyvHB8/+Y8f+45Ht2yPb73o+/uHET+8PfHd64gf5wEN1T+c+oPKE6B4nE9ICLyz+ + DfSvI8eXhv66ISxuiO4OEzZUxyvGuyvqhxbzKOjzhDl11LGjkQFXTZhmompGmjHig8FrRWBBZMglz5/0 + EPinB4D/I/93rLESNcioW/1/8n++fOZ/nJwsF98veqRkKSgXKqzWxGAZDx7z2OO3E8cbZdf0LO2Wdnqg + 8ntM8Jhg0Vjjw8gUI0PvmfYwfFC6txP79ye2j1sOx2e6accQ94zhyBROTPHEJCfUjhhJxqTFbttkCa+k + o5dTSE0LRtWcU/+M8EspeMtFmBmSMrMXIwox6QOq6kUQMIgU3PhCNjtTfKc8oNI0sAnw5aT8ysJmUoZO + +dBHHk/KwcJY6LyijHWkW0SGJjLamIZlDFgLNtO0fa53S/yqRVlY4Qtj+He15X/XOP6mNry2hoVmDwOV + BJIV//SLO696bmc6gRsD31Sw13N3+r8qPGhSSx4FKpPSxSpKMlLJ4inbAP5k6E4VrTfYLCtmTITlyPjZ + gNtBPwmfxT1T/4S9WmKXS3y1RNsVLFboYgXtAlyTMjkqlAahRqUqveOz4lM0hJhnBi6JmkoWlhHiaBi3 + PYf3yu79xNP9kaf7LQ/vt3z8acvDDwce3u14Om3ZNh84Xj/gqyPWjEgMSfqsrTAvgK+F+FVgeGU5Xjf0 + q2ti9RLMayReM26WjDct1bVDVoqYQOUbZFjSmB5bDdB00B6IfYcfYaRiYIkwZWLanwQDLVnH+p+QAVQQ + nYOxigz6v+X/Mv4d/zcdGf/RzS9ZKF8rhVoS3945nK2pTEMdGprTknpsUecY9hPy7oDeb3n/pufqTjDV + njf6wHLaUgdPPFUM+4bjPnI89pwOJ4ZdT/840j307J8O7PdbOr9nZM9kjng5ErRH8RnFl4zf5nS2JPpz + qm5Rdai6dL1mlKkMNJwDW4oJc3RL9XAscw4pJkhMSsBpxuGsjDTrJ5QeO8lsaGwSzbdZCq8V/tIIf9kZ + 1qNh+wxhVHajso/KgNAZYaiyzJdXfNb7i5ljEQtUkfv21qY6vbHCyhk+M8K/cpb/TWX5d3XKBNaZQehJ + oGDqg2fA06Q25mx+csGEawReW/g3VQkwcCXwe0nSFpMCPs2O2NK2dWmzxQBDb9BoGEaHI+KIVBIwEtBT + hF1EHsGsPRImZD0giw6pTkhzSBu/XUDTInWNVDXG1eAa1DapAxUdEkxyXxoFP1r6oWKaLNEnvYQiMOIj + +KD0XeDwPLL90PH8eGT7eOD5+cDz457Hhz1PDwd2uwMde8Jih7gTxvhELhIHrUVegvk6wl8p8oUjXtX4 + 6gpvX6L2JSJ3oFdoXRFXhnEFWqeZkIU6ahpUaqz2GC+YcQCXbOkcBkNDKu9rEsH7jwKfBQdw/90BIBFQ + rQVtUjd0wLH0I8+XTyr/4GWsQAOyEszaYFcVdb2kdVcs7IZFuGJxvKI+LCAYfOeZ3h8Ibx+5/2qLuZ2o + NLAcdlx1z7jjkeFpYntf8fB+Yvt45Lh/YOie6bsDw3CiH44MsWOSgSAj0QwkjtpI4tdXGKnnZC8lI5Kn + GfM8oVo0ZuON4mIsEcmMsjTgWMgx55OfPCSDnKcAz6zAixpUkqjHWQEpncpeYLQwLWB5rdys4StR/qox + /JWxLBp4/hiI20g4ReoRHlXYWuFUgW8MWgvRCsEIoxG8I8lb1UAD1UJoG0NdG64qy+eV4S+s4V85w19W + qf7f5FNvQhLtVSW9uUL+mYcSzrarCnkOLvWYPrdQibIywksDXwj8IQoPE3RZnpy8+Z2FugJnBTMK5piC + VGOUdhlZrpIYh30RWFxHPjfKyyNJ3ahTqDzGDuAi6ibUdVBVSG0xC4tpHbQ1WjWoaSA6ZBSkg7AXhm3F + ftewOzpOI4zeM3pPPwX6KXIcAvuuZ3vcsj08cTjt0ijzONINA8d+4ERPvxiIdsQsApXVZOYqJmHuLxS+ + Bv5aid8I8bYlmmsYXyL+FYRbjCzBVKgz+DqiLk8bBItES4vFSxrOstOEcxVYyySOiiplTDNnwuYs4B88 + 5qPgn5ABjJyZ+3PVPm9zzsXyOQgIyYe+BXslVDdCu6pYVkuW5paFeUmjd9T1mqquMb2gJjDuOg7v1vTf + PfNoTrxrDZs+Yrtn2uNP9E8NT+/XfHzXsXt8ojt9YAyPTLJnko5gB6LxZ4KmZI6+VsnuWhsMda5lz8ev + mNTxTnNJhhhLce7z5o9gY9b8T/X+TOxRM29yNZE4q58m9FyyLr+KEMWkGf/CaYipdTcGoXeG3gmyjKzW + kTdr4RsxfF0bXjcOtzJUt4bwFGl2kVed8hxhK3BwMFkhmkgUGG1kcDBW4Gsl1BBbxbaGujVsWsvryvIr + Z/jaGr6yhhdGaEkHh4/gs5FJMQ+5kOmFrO0kpgSAJLwhmkqBlSi1U5ZWuTHKa5RfBeGtt+wijJJ0qTVA + JSlzqMc0pi2VSS3PVllfK+sbx/pGaa+U5Uq5WyhfGrgehSpkRWHSZ1emRP81I1KTdB2WBlqHVhXqUglg + BsEcwH8UTm8dw7uKx2fHx0HZqecUJ07TxGn07MeR3XBgN37k4D8wxB2eKSlHCXiJ+DbAIqaJ06rC2kRU + kkrgOiJfBvhLJfwaxtc1Q7XGjy8hfoYZb4ElYuqktnRB/dZW4Ubxg9L3hmMPZhAWvaWuapxraeyC2oNT + wTAQZ9LUn5wTMKTY+9/3yIO9AegFo47lMHGcyaAXIeeTAEANLMGuYbE2rNuKK1mw1CsaucHKLaZZJuS9 + ViQoJjToh4bx71bw2LGtPd/5luO0px5/x3Q4cHhes3uOdMcTftoSzI7gOmKV5LMkCmgSmcTYXMdZTAQb + 06kuJgNwEpEYL0aYTR5h5nyaF0lrC8WcUuahHXPO/k2WMrv4fUFz5yABfxSBD6OYGIkhiVycsPTWEBu4 + WkReLwLfNMI3GF4bQ+NSNrVYw+tbYXk0vOmVkxdOETpN032juoTsW8U78E4JVRog0lpxtWFRGa6t4aWx + vBbDHYYrTYCjxlxBxuw6nNoRWVtxbpgnebIL+DdbBSBBCAKVU1qrvJRII8q1wpfR8CiWQwW9hzHr+4mk + IOCiIBuBN+ka1zUsV8p6DauVsGhhUSlLk8qKJWCztntVQpOSMBiJyEByWe5B6gm1I1SJu2G8YHbAe6i+ + FeR3wvDB8DAp71xkaydOcWAIA8fQc/Q7TvGBQT/izTEdBs4iziUpeCs4axBbYUyVB9EEXSvmtUe+9sSv + YXhTcVwsOIYben1FkJdgrkAzHqQgnpQ9GBKPwUXiQunXsFsp4RgJJ1hXFW29pmlgESqaSXB0qSNCxX/D + S1D+CQGgAowXCJaF/kf+r2qTp8lcT/yDAJBaqrultgAAgABJREFUmsgCqgUsWsO6taylYhEqKl9jvcNE + B8ahTRrfFCs0B0P9hxp5v2JynvcozzpQxZ/APzOOS8axIkiEqgfXZ8ZeTKaX3qQJIHFgTerHi8eEmLjy + GrPibWq6aTYJ0DzmmfreuY+ZA0Cx3U5iJHLufZQkIgOcZy/EMpVTugQm0YazJbeQR6I1MorSVRAWwtUK + frWEf9PA31jhKzWsbFKQ1UWaYFssLdWoXE1KmMD7xMMfoqWPMcE/VpPOgE3vOdg0O2EstEZYYVhjWGKo + Y2o3RlEmSYljyCe+BD3Tf8/E+FnrrsAfJeOKhX0XwWpy77kysHCGV41hMJapzuxDVaZ41iOIpEojiXCC + q6CphKYWmgqqSqhdViWLEILMLMB/gE+W2BwyGjkCJqBVSKeyApNgR6U+KvVTwH6AcTJsG+VjM3KSExNH + BjkxygFvnkGOWBlSpmIlex5kJyZJ2aCGtLa0BrmJ8MajX4xMrwzdcsGRK47THVO4Q9mAbVNslVAmmhBv + MeUgCRNqI2OTsrjQeqgVVznqeolthHoSqjDiYs1ERaAmN2H/ZBD47w4A/w/+T5cr4NPY8MfagHnzswC3 + hLrNdefKYNuEfbddYLn31CdFtGLAcLKeTkZkjNjJIXtDsIHJBDozYekzytmj2iS/+6yOSwb2hDwTXGyz + Zm/vvDCKyMg8h1/+vvD1z/t57h2rmTMEyuCHOU/FyNwmM/NCVknqyaJF26gclXlsJSaAacQwVDA1wmIT + +ewK/qdW+PfW8jfGcasWgjAqDKpMJhJrAZc08dUnAwwJio2aYSChMcJCzJnMIwnJmW+PChUyTwsGmLHj + QIl9miWBLu50wUrmkbnMYNI80KVpviN5H5h0j4zQWsPCZU6FO2/4oCkT6INyVOUoysnCZDVp/jkYRTnM + AGueafWShIc0gZm1gcoK7mIsHJjnIorRQ7GhT7dEEKc4G2gl0kbB+QSaDhLp3MBkjozmgDcnooz53ien + J7FJydiIzepNCcCMIilRaiJyE9GXgelW6ZaWo205jVeM/oYYNgjLBBKKzxc9zucOWekqaUDEZD7TKKZR + +loYK0uoK2wVMLamMhUuOgx1DgAuR74//vgf4gH8LAB8+shTx2YBdpEEFqtWqG4s1StLuzDcHpUXH5Sr + jw45rjj6ho9x4EH3nPBp7xlJdNvM8CNf6MQEjBdGkAYJZZOd+9Tn6JdTcfJzalFrydTRC82CQl3NITnT + DMthnsQwokk1miksv5AlZEv6P0MkxQCTWRtRJA/qRPBqGK3FN0K1Vm7Wyq9a5V8Z4a+D441aTBQOY+Rh + mHgYJ7oQ53HUmL0RQjE6kYAxgdYoGxFusshIK2nCr863JysW5GGmJKxZFHbPZ0XKXGb34Hw/kuHqRQu0 + HAlSdA3IHgwQfRqWEsnS33kUtzi8CKk1OEXY+8iDVx5C5JlIb1IAwKXMJbjUHg02La91gOsobIxwVQnL + WlghrIxh6YSFS30eE3NUu2T9lLShUliCuzK0G1itHCutaYximVAi3oxM0hPmzV9hbYUxkstLc9ZsLPZu + ImDTc8e7iH8B3dpyMC0nv2EKt4nToitSAn15hhYq2NyjzO9XZg6fNkKsBe/Sl3UpG7GSZgYMSZ9D8+DU + n2IG/g8FAP1TtUVBBiqQJolwmDqd/M2NY/NNy6tXC74ICz6/X3Dz0xrz4Y7t05LltsN08DFEjnYgmDDL + chuTN2Kup2earoJESXV/TKFfreQQmmVx0AzUZe4+xfcuRW2JMjvLptr20teogGAlz41z71ulyO1kOm0O + AJCJTbM3gubR4Uwi0uyma0AaQ70SVsvA62rijSqbIQmGPivsfeCHfuK708C7buAQQnpXRrJaLmejExup + XGBVwQsrvDKWF9ZyYwzXYrgyhiWCVTBqctDQrK93ThTT4Sg/00/P8XKmY19IDRXeVFYwTsMA6RrEzD+Q + i2ZJ0HTiH4LyOCn3Y+TtoLwbIh98YBsig1FKJRetpoEoC94qTmCtcCPCxsG6Maxa4aox3CyEO2t4UVlu + nLBRYWHBhZyi5/mMFACABZiN0l4blpuKRahpgmKtRayiNg3gRNGsIVBO/7wOi+BfoNAloQZtId4q0yth + uHOcFpaONeN0Q5hu0bABbS5azPlCzpVWknNSyZ2ALFgrDdAIoTJMzjBZcFaz4rDBkTKAc2X+p/l5/4MB + IJRl8Q8DwLwoJM1t12CXwvK24vVXK379l7f8enHHF9sbrn98ifnuNbvfr7n+tmNx73BDzU96ZCdJJrsS + j1DSziK5TE7zmfna8yqdC8KSaKYVmgZHSi1QTvVz9aIlBZtJPoWiVzKLHEvy6RfL30pm/2VuZAGj0Czs + Wbzx5nuRRB+cE5pWcE3kWiJXo2JH5ZHIf1bP6IV3Q+D3p4E/nDreDwOnEFKiMrv8ZqMlUdRFbB1ZNsqL + RnhTO95Uls8qy5eV4ytr+cw4brBJ8itnACEbYOR1NmcHmCzcUjj95d5Hc/6QQnJFsknyuvxgYQ6SC6NE + e0o07yevvO0jPw6B73vl+y7yfRd5N0aeY6DTZNIRsmR7ie1ekh27EWhFWVhoK2haaFvDuhXuVoaXk+XL + aPhqkbocbyrDrTMsNRuYXmrKZ7m4qhWaxlBXZjYHTVrEniCeKCGVPkWz0RRaeDp8UgafuM5SK9xGpjfQ + vRG6u5q+bZn0huhfEP0dxCskVucTXjhnkbk20hCyP4Fm/p5CC3EhhEaYKsPkhNoZsCaPKKfZRKHMBfzZ + AsCMDM2H0LxjyjUuQa1RuILm1nL7csHnn635crnh81cbNjcbXHvLS3/NzdGz6FoiKw7sObgd3m5BDhiZ + mFWJ50AjWQI6kW+S02hOlzIyJFoS3mJ7lVIsye88qQ1dDPRcDo6UzOw8/ZN58Can4ZpNS1M2oKYs/Hg2 + McnZS5EqI7+eqs01a8TFSNUHhlH5aYo8hIiPwvMEbzvPD93Au67neerx0V9c4BmtSO/HBaSJVG3kqhVe + NJZXreWLxvFN6/jLpuKvqsivXMUrY1lmmqsrWcsFxylRHXIgnYPrJXmWApxAkHnkvtTYyb47gYt2EqxE + xsnw0Cu/PSn/5RD4+y7wbRf5sY+87SPPPtIRiSYFYc3sqBRrznwDyW1ZYyNkWzTXCu1CuF4aXqwtX/SW + b9aGv14Z/qqx/No53hjHlViqSxsrk7BiVxtcJek5ZbYbyUFW5z8XHKSUMHPET/3AFAiXCneR8Br6O0O3 + coxuRRiuUX+D+itU25RRSMjPm8tRk+ZENKRJz7lcNSEJ2C4UbQRfG3yl+CpRwo3NI+vJwoY/hsv/fAv/ + j2IAJdyPnMXJ9HJ95PIcXQA3YG4N9drSuooFFa2tWC5r2s0Cc3fNzStDOyzpqyvejzse+MgkpKeW4sed + mXnzC2RQqnxWIad4eaPF1AIs7be59i8WZxfovRSg71JA4pPPo3MAQE22GSuAUiob0hbJvoHKLBCaNAsz + VVgsRIMEkEGRyXOcPLtj5A+9MgWlj7Dz8DwEdoOnGz0heIj+ZwSji46EizAGxiHSd7CtAveN4V3r+XHh + +G7p+X7l+Zul5183FV8Zx2101F6oomQcID3ixUc+1/nn2JMhgqRlEAWmXEaZsyNwFSNuEujhGODHKfK3 + nfK/HCP/6eD5Qxe5H5S9Vw5eGSPzJC8ZK5mPl1k4tgTpXN7ZmHqItXBshOel4X4ZeL+3/HQNP10LP14Z + 3i8d/6qu+drVvBRHKzYH/3RYWCe4CsQGVCaCTnno/FOYa6aDz7lvkbzPZ18Vk/L+S0XvIK4F7xxBl8R4 + TQxXeUNkvTaXuBSlJNWQjVjLdS1UcZP7tA3ENgWAySneGYIz2Z49SZSYPNnwj21+UnX1P/wIFwEgkY8v + sYuo6cRdgNySrAkXnEUycuvE1Qa3qag/a/iSiqem5dunJfe9ZYoTKn0am9WQhEVjSe9TDCqsspmMM0dp + k8vzyxMrv8miNkw89+8pJ41ckHvip99j1gHIgKBKqtMwpe1XDomSBOfyg0QuUhVikASQhYS9+zCyH0Ye + u8B+yK0xAY8waUyfvRLEFvOy/Cp6/q5oEtAc050IPXQ2MQH7RnlcBH5cKd9Pgbd4tpVnsA1/LXAnFZWU + Uz/OGjvEPN58AQ7MlGJSTNasQaEhB1HRrG1Hkq46wbGH70f4j1PgPwyB/3gM/P4UeRgjfdZMMWSJmgq0 + yuVj9kVIlzZ/jxCD4kMxEE2CpDqkjkgYhOMBxp3yvIvc7yM/3sFPN44PV7BfGv6mMnyO0JRrKUWCPZUd + g0yMTPgsvz37IFxun7Lx873WnEnolaIvFH0l6E3ibojWENdo2KCsUXF5TDyVR5d2d8RkRgoZM0ETwalk + RTVQJ3anr4TJCcEWZW5Jfg/zZvijJcCctf8SAeBCtpfcxzj/balNyXJWbg2u0TRTTUWlLcbUsDLwOvXb + W2d4GRu+OsL748QpnNjWPZOJuHikydJPszrgnJlfolXMm2NOWjVegHTFKaegWCkFm2uYwnuX4s6TL/7l + hsvCpsWO6oIdVPLU865RM9uCe5++go+EacJPPf14ZDcMPE2BU8YrqQUag22EhYNWHAu1uX2XesREIfok + FjKOgbFPdteDD0yiiRJcCf1g6PrIUxd5GEa2OjEaj64izqYNe2NN7mrkW6gCwWEyYFmCQIJMdIZFSmzU + i3kIq0oVFfrIcSd8v4f/ZYj8v4Ln/xMmfj9EtmNk8ok1mD6q4BpgGWGtuLWwaC3L2rK0loVYFtHSTgad + HMfBse0t+z7S9yPDOM6fvR8Cw8GzPUwcjpHHIZVVjxJ5tJFHG/gbG/naRG6N4qLBjBU6Jpvzg4kcmRjt + QJQeIQ2PpS11HiKSnAmIgDiBFegrJXwe8a8hbCxYh/FLJN6A3oBbIWRprxBxvSCjwCAwKSZ6jHiM9aib + mOzIICOThjRBaizqLOoEb5PF+2TAZlDaSMRoUQW4DAJzylJGBadfIgDM7VwKDjA3wvOpZFM3wC2gaYVF + JazEsWbBKqxp7BK5NsRmwqwSrrfZCV/9INyPCz6GW57twGDHdCM4YQhEMXNzTz95O59Gacg69jNDLw98 + FgpAMeowZyOTs+dBuX6ajzs516azWnEJFpyxhJIiFxntmIZ0hjHSjzB68CEw+Z5hONJNB7o4MNiI1tmS + bGVorx1XVxU3bcWdq7ihZk1Nq44qGmQS/BDoO89pP7F/9uyePVsf2YVIp9nDLyh+8Ixdz3bo+TYGrE5Y + D9USpAp8XSXr8ELtlZhALr2UKi8LPwc4KR0fl2p9FUnGl94gHXQHw49b5T9tI/9h9Px/mfi9jOxjpFJY + SZHOhsoIpoK4UsxLWLwy3N0ZXl3VvFjUvKxqXkrFXWxw04Jjf8WHU8vHHTw9d2y3R7a7nufdwHY78Hzq + OewGhqFnHwKjCDvreG/he/H8qIH/vZv4dyHyarTEbsFwMhy8ZWciezsxygknBww9gmDVZRJYXuS5+yTW + YBpBboTwuRK/DEyvYFo7om2R6RoJtwg3iFsgYnE+UJ+U6gnMs8AeTOexsaNuT7jrHr0Z6RYjqhM+mCyl + t0juzA6CVSajjBJxOQsViViNeZVn8tmncwElax9/CQzgEgQsAeBsAWyAWpGGxFbKGuwLrViGBW1Y4qQh + LIS4mHC1RzphdWV4XQmfqeU6rHDxmhj3RN2CKiZroWpRjIV8HJ1lR9KSzak+59o+SUyfTTfSbH88g4rz + SaafkIjmdo9e1MAXrbGEMehckksQCJK8631kmCKnMXIcI4NXxjgxxo7BdoxNDwvP4sqwvHKsNxWbjeP2 + uuLlpuHlYslLd8WNrFhrS6MGFwwyJiWg/jhxePbsP0a275SnB+XpEHgaA/sQOfiJvXbsZU/vYa8932nE + TR53o4R1oLeWX4llY0kgWbSp5AruZzhISVUTH0DSRz+XPSNoB93W8OFZ+e0u8r8e4W+nyPfi2RuPiLIE + Ws24S9lTgHFK1QrtSlhdweZGuNsY3lw5vlzXfLlsuTZXMN2x2294fG54eAx8fOz4+HDk4/sjDz8duH93 + 4v554P1h5DmM9PS8k5GdBra9MqwCVTuy6gN157BdxWGIHL1wrD2d7QmcMHQYRow6jOT0WnPwz+eCZCFa + 2QjxhRBfKNMGfGOJcQFhjQlXiFkiktgYZgy4LVTvwN5HzDZgTx113NNc7an9Ca1GrBuZXGAUxyRX5wlV + EaIpfgi5IyV5ujKmUuAfjukoORIMwPBLlQBTjijnEqCcgpm4IIt0gZwTarHUOCrNNOBsNx5dJCwEcyXY + DSzXwqYVroNlpTWnmOa5Iza551LwmyL7nXLncwBIzrbzqv2kTMh/LsN+5rypRS9W++Xpnn/GFJ++WKLd + BXPQCMbqnDTEALEXxsnQeeUUAl2Y6OPEqCNT1eFXI+5O2byq+OxNw+cvF7y5aXm5bni1rHi1aHlRb7h1 + d6zMhoYqgYs+gFfCqExDZNjD8NFy+slx+EF4/snz7r7nu23H77sjP4U9Ig4nluHgOOnA994jIeBVmYwl + GMfXJs0JODHnZVMyIdIHkxL9Yi6xMtvQjMAJhh08PSnfPit/f1T+MEbug9JrzN2Bs2SFyBnSkQncAJwU + fVb66Nl2I65LwiT1Rlm8siyuR14x8Nkx4g8tu8OKxy08PAw8/rDj4WbP2+rEt3Hi7z94/rDveNBHJv1A + Nxz4cBX4dg2v1nATQY6G9Sg8xshJApN0RMkTpOoLwZlPMkzOiYBowizMQpAr0FUi6kRToXEBrFDahLtP + Bpki8gxyL5h34O49bt9R9XsatjTTnqrtiFcTsZ0YJeBtzVEsEzUqjiKrN+PhWc3KisNQZVas/XkrUPM+ + /UUyAPgUBPx08sCm/r+0IK1iKjA2IZVWbdK8l4yYly1rBW1BN4q9g+VH5TrAjQqn6Jio8VIBHnMm5mJy + EJk3+AXYV2paMhmlUEKzsuN8uif80GaSy2XEPAcEufxeXmpOGpJKrljNDQFBR/C9oZ+UTiO9KqNMTDZN + LbIcWbxWNl/WfP5lw68/W/LN3ZovNwteL2pe1hV3Vcum2rBq7mirDbV1WAISfQK/oiF6g/Y1ul8Q37f4 + bw2H30y8/d2R//rjns3zjlW/571fsdU1+37LKWw56oFvXQ+1x1XKwiRZsKZJQLblTI0+B8HCZmTe/KqJ + CGN68Ds4PCo/PSm/O0R+P0XeR2VAqTKYlwhIktX8z8i/yV5llcCwjzy7iWMTeNiM3H818FOo+Wk98ldX + I/92MfEXdeT62nHtl7zor/hyu+Hw6ordzZH3ixNfVZE7Ua4ejvy2b3n/ONFPE8O253EV+d2VpbGG09bx + YhK24tkaT5Aeq1NBNDgzntIemkFYzLkMdJnX05AUT4xFaVAWREnuweoN6hUOit6DvlPkfcQ+D1T9nto/ + UbOlcifsccQcAvXSs3AxDXeZHi8DqvV55+ebM0uWUWddgOypMK/juSb+swSAnrNjYdlvc49VclvyEqWU + XIdfJuzRJKaTXoG9URYb5eak3HTC1jt2tsZLDSkUnLN2SrtELxiKF72rouMXYS7+reTsqCjyJCEQc7bp + yf6Epc2TMg3JNX3Sidczj+iyNe+FMArTaBlGofeRHhhMYLITwQ7IYmB5G7h+Y3j9uuHzzYI3ZsFNX7NU + R9VbtBGGNrJfeaZmYFn3bJqKKwN17sMpDmKLhBW8WMHdAm4td1ee2/WKzfWKq3drXj10fPvc8eNhx9vh + nvvpLdsqcBwH3nvPd1PkzWh44wwvnWFjoFLN7sCFgHVBkMpEJ+bPDNrDtIfDM7zfKj/0yk8oTy6BVY0K + TRACgtczQKsxTxIO+cp3iZ3YqxKMImvh/nlgMVq+145304nDVz3DlefXFm6s0DawbG+4WWwYN0teXQ+8 + vvK8aZQvftvzxZPl70Lk+6OwHT7ysT8SeuFoLR9PltdjIIrn3o54mfIqqEhX+mcA8+VDMr/DKVonwFsr + ycO2DZEFkQVKhQYDnSLPEfkY4YPCk8ccB1w8UsUDjgN26LGnQDxGbBepFpG6EayMCANJ9MPNQSAtaZPF + yc+n/5/oAPi8V3+REiDkzd9zHj0qrfBPX7a0Tua/0n/4IwLUillDc6tcXcPtE9yeHB9CzUFaRtsgDKiG + T343CLOhaJGDBogFzefi5J/BvTOZRkkuPJqV4WZdP41nW+2cByfLqYwNWM0NA8kceMEPhvFk6Aah8zDG + QJCJGCeinRA34RYjV2t4uah4pTXXzzXyUdgNExOBj7WhXgju2mJfnKhfH7h7ueKb2wV/say4y05LwhKk + SQtuUUFtkw9i67i+WtC8stx+v+Cr75S//33gvwwH6uM6lV3jSOd7Qgg8T8k74F3l+CLAizk7i8ym7dnF + uVizSzkYMxvEd9Ad4HmvfDwq9155cMreKpNVKpPeostdW5fhlxhzHekhTKkDEYIyxTT8FA7KcQR64eEw + 8rwdOQ6e/b+OPF15/oKRN4xsamjuXlJvlrR3Nbc3ni8XgV8van71O8OrJ8v/PFr+doKPGjj6ga0RHkbl + 1TSxEM9kPAMRS4WyQGbwLGvsnW2Sz7hR2uuJpNOmVp1al0C7HACiNqi3Sfz2SeFjxDx57GHCjT2VnKg4 + UmmHHUfMKcIBTBeTfZ0GkDFFSUbIwz7l3iSlqYvvl6Xsp9tsKnv2l8IABpL+UCkBpLyUelJfOs+Yakyb + J0rpwadTrEhpK4nvbJdKs4H1lXJTG67VsfA1mDTqSC4ApOi+5zQ05hskWkZWTY5Gpcj8+caHouhTxD1S + e1DnT6fFqFQNKko02fTTaqr3M72cCOINoTf4znDqhNOkDOoJMmLocdqjYUSDp/aRdhDqnWIGGMbAuI/E + nRKnNHDkGyVslPjaUn9d8fKblr/+uuX+zYJ/tW753C5Zx1uMX5AthRIZaJMJJgtY3FR8flNz1VhWg1Af + VrC3TL0ndJ7t0cNROFYdP1n4ro58NQVei6XViEmWE+gF+3Fe/GT81IMOMJ5gf1CeTsrTqGwVDgKDpl51 + 08BVpbywcCvKJgr1CH6EwwCPAzyMwrOHYzBpBMOSpwsVv1f6x0B/GOga5XinnFpPcAGnQkOFsxaxN1Sv + KiprWUXlCkdl1vjfCt0HpRuT1fiTf2IrHT6MnMLAhkAtZFJYjbBiRnrS1FdaMlomItPJTyPoQmEZiYvU + yVFbUPtl+iIpEekpErcRfQqwn7BTj+NEZU84emyYMD5iekVPaWfppERShsLP9P7OZnnlSL38+qP79RcN + AJqfLIt6X2QAEXRKaaHm8KBBiRoIBILEs4rWvEmTo49ZKs1GcwAQrtWwCBUSK4Ikv9bCCEumDoZP9Rzl + 4k+SIk9O0dVcbv60sAtSqnmq7sw6y0DibDCRnkSLDEomc5koqDfE3uBPlv4knKZIF0cCA0JPpT02DlRh + IvqA9RF6oX8OPNmR/RSJJxiPkWmM9D5x4oc6Eu6U+p1ls7P81lf8hoZ/z4L/w/qavxFlKdcZlDO5r5Z6 + 6Umo32Aqw9pbvj4YZLcgbF/QnZRpl06MoxiOfOCddHxbe75shNcSWOJZaZrr1+gSJaZQfXMmZTJ4N52E + 0wEej3Dfw8cJdkbpNTegaqiukszZX7bKX4vwhVeWHYx7eIzw7SD8xoNOJp23zlBn5+QwJq+HuE8k3cc3 + Hvtlx3opfH7V8hU7fPUBFZM5+9ewqeEbQz1GrnvDl/uWv9m+wO8jtXf8xlV8rN4x0dHhac5NYpIGxjln + TeuznHH5UBBBnIFWYaXEVSAuI1o7sA6lIeoylwA5A+gUnkGeA/Y04kJHVR1xVQoAoj7Nr/Uk7/aTopOm + jFemnAGUarvi4rzNzMXz1x/RAdD8ITqyOegv8ZguAsCZDkw6GRghDMo4KoMPDOqZZCKKRyVARoTLOKox + kaoO2GWkXpGmvJywFEslacopisNnZZ44R77youZMz4U5bS2DOjJrAOgsL67ZPy7GmB1ySlTK1LOMeIkR + 1CXJKrHJwBMPOghxSE5Ewwn6ITKGkSAdSIdjoIoThInJR3wQ4s7QG5hcYGsGBJ9GaKdI8Mo4Rro+MMaI + +aC0e2Gc4APw1loOrmbteu4Wjq/cNTZcM0swkRvsbf6cUzpRrk7Crw6G03bN067i8OQYveJlZDQ9Rzvy + oR35sYEvTZLnblVoMSlzy65GJcaKKMYL0gvxAIe98uEUeTcGHkLkKEmcRFzELZXlS+HlnfBXS8O/B349 + CYuTMi7hwcILERox2MmwMoaxBtukTEuzUIH2cHwMbH/w6Lee3bXn8bOR3epI7x5ZI5kL30LdwEuHjJF2 + G3j5wfDXD1fUu4p2bAiTZTCBo5lAPMaUoTPJ9tvFW6CIuZwQGTEaz4rBRlIGsIroWokLiJUhiCPGhkiT + AMBoYFIkm7tUR6UaPc72ONdh3QnREUwgBoOMgnaKdor4gMnrOEkcjeli5NLW5HJNVYmlbL0cKT4fjYFz + xn76pQJAyAEg+RQLQdJEQhrICzB5OE2BvZ84+ZEpjkQ7oHYkisdLZNDIJBGHx7iJqo2wNFRLw7JRVoOh + NQ5rKoI4plwGzB/xkgBoDGjMs+zlUsi545Av2Cwho/mgL/p3krXubAZ45JyqFCUYIbnCxAH0KPgTTKfI + MEQmP6E6YE2HkZ6aCRsCwStMQhgtfpI0f29AbZ4WJJcTQVGvuEmpPCwmYYMgLvJcBbaLkd+vJv7XK+HN + oqY2Da/E4qKCvCEZalqQAE2Em/Sc4pVFZ3m9XfDN04qno2PfdZyen/DuAVc949vAY6u8rxxfVJFXmdob + czc0au5AuVxcDWBOQtgJ+0Pg3Rh4GyYeY6QPaQKyaZTFdeT2Dbx5Y/h6Ab9WeDWB9KDXsFxBcyW0O+Fm + MNybZB9m6jz02Se+vh6U5yD88Kg8vo2Yzz3P1x0f1pbPjHITHE7v0j2zDTQG8wqWfyG8elaarWV9WCHj + gsfB8XE0xMomKRn3DDrkQ6V0gxyi2f1PHFaOWD9hgiahgtqgTtBWiSsIC/CuZtKWSVsiNahBfEROEbsP + NAdYdMIiKLULWAYIA1HHvBgTwKdThNFjp5DmKggpMzEDmAEjVWbVKk5JY+1RLibzLlh5nx7WB5KM5C/y + 0BxV0hMLoxhqMcloAc3Gk96zm0YOfqSPQ2qD2QE1E57AgGUkZtWfkegisbXYpaNdGFYDLMXhpGISx2At + oRQOSp4GJNXnRs8cxdz/j6UrUXoG2aosY1spQwi5/suafbgk93QeLc5865Bkx+KgxCP4fcQfUj9+9J7I + iKXHyYBjwhJngYzgLTFYklSGYjWjYPlUNSRlm8YqTWu4Al5E4U4sZqs8/DDx8dYjr+DHNxP/+faZtVUW + ErgxQrJ+vyKhUh5MIOfxANjOcf2x5sufGh4fDB/612y7D/D0jqr6SLM4cVpGPjaJNnsyyqpQfk2eDSj8 + kkgKaHuhe4bHY+S997zXia0GfEz6/7WDqyXcbITrG8t6kSZbJZPIZQ3tEl6vwR6Em1HYGwg1mCwvLh1U + LeiT8KCG34yW3z/Bdhfo44nHKrKzwuSvaUdJPeh6Ac4iS0P75YQ7wtXW0D7BcdvwVVfzh6GmU4PaHrUn + gunP+BRJ6EVIlvYiBqOC1QETNM93SBKCbYS4CMRWmGzLFBf42KYujSqMHnNU6oOyOCrrSVgo1LmlG+OU + AkApoiG1RoLHhYCLio0Rkzg8IANiapxYak16iuUQC0ieYCibIMJ5cK8EgP0vGQD8xROfUJYSMUnnGvyo + 9FPk5D0nP9KHkakaCTJh8AQNBCIej6pnZEoyXy6iNbjWUldQaRp5VLH4LP1lyUCUnNOdRNXNkcH8TLyy + jIIW3SjJ6r9WyC4VmcKsqcc9U/7IQB/Jz3AIxE4Jp2RH5ruInzxRR8SMWBmx6rE5XfQRCMnyu3VQWWhN + MscQlfT5HagT6go2DbxYCJ83hi+D5fVYYb3wNAR+vJ/46e1E+Fp5+1nPj1XgKywbucFwyrelqMH49G2h + 8EIxn1csP7e8fGV5c7Xk5fML7ocv0O4DdvdA/dQxrTqeGuXeRj7UkcZEFhJyEpQZlFFggHCEbq88HuC+ + j3yIgZ0JTJrAw0VMwp2LYKiCEKPQC5wMrBy4OiVdIaRF1KzgpQgv6qQJWDtJJstHcAuIS3jshMZZbC/8 + 0KcJyWAHJhmJGnMWV+UIYsFGzLVQfwXVvRB/r7z8g+PVQ82LSXiSPb35Cex7ojGXfi9I5oaYnEEm8lOT + Y3YCnqOdiPWA1hPqDNFUBF8nXz+1ad2MAekitoN6hCZALfHM6Yg+aVOqgIbMLfEIHkPAlRgeC8EtIMTc + uFasQpgl7coxBz8rAUoGsAN2v1QAgBS3OmCHctDAjQ7U2qUTUk5K6JVxSky4kw6cdGSQKTn0EEmaued2 + XVbqwrgkbmkMmAvZr+JTV+p9NRm0m0d8s0BQou9hpGABmf532SfN2IBW5NM+AytF5SVm4otX6APaBbSL + xF4JYyROgeg96JTaRurT59EydJQ2TmWyGUcLt23qX68yrtMrHBsYFlAthbs1fHkt/MXa8g0Vr7qGauc4 + nJQfjhN/e9/z/YeRaTuxXUxsbc8rBhalPkQugkAOhgvgxlDdCFdruG0r7twd18NX9P6RcPpAfN4zLgL7 + WnnnArc24JznNbAQTQBstJgphfvhOU3dve0ib73nicBg0rVuI9ggmA7cM4wfhKdK+GlM+FxwKTnxHfQn + OI3JxkyulMUVbGqhNfl5lufMQ3fCSwyvJDKEJIm2zjo4xYxmbtGVxVAZuAa5g8U1XC+EW2u5pmalLUFb + jNZ5nDacg8B8lhhUEvsk0maGpBBtQN0AlaJVTKWRSN74Ln1Ib9BRMl1O0xi4Bgw+1f1582u4HLuUhD/Z + mGv9DEcFSRJ0oTDQLilKn7bWzwHgk316BLbA8y8dAE7AFuXAxKhG63gEOYIkdIA4KUOcOOjIgYmOgMvT + fY5IqYLTPHM4k/BM2pha8ngt7m068+9VPol0KZBmRVxjYgoAWjz+ysbI+X8Z7jE5EHhBR0ldjCnD2D6i + UyB2nnDyhD6gvvANPMKUFo6EvN/S+wpl3tykcdebRvnsCr5cJwedTS/QGY4q7BZwWoNZw90GfnUr/Hoj + fGEN153Dfmjw7w2vh4l2K9h7eP6ojGvYXQl7E6iYcHPvutzinApahYVBlkJdC0sHK6lZcIvVV4zjCzi8 + R55OdG3Px2Xgh5VngbCUBHZbDBoV2xt0C+NT5HEPb4fAfQgcsjxVI4ZGkhQXR4j3aeDtoVf+cJ3o4fsK + rhTiCY6HpH9wWimmUjZXwpsK3lRwq4Yl4DJ+baZEKlo1lmuXFI2ucLQ4jLVpvFApqeH589cJGLVN4iOs + XGBlAgtReiyqFSa4NE03lwHxgmaWM08yRdwoOA+NInWfBnRMyTKzU3Fw6OjQwaJjHl0mouJRHSGOIBMy + d5sAkmr1XGpZzoNZwYHPIonZ+y15NurPOgAXRLjzIvA5ADz/uQLADthrZGRCdUS0TzeNHsIY6b3nGEf2 + jJwILDTgCDgpXUyT2YJxvs5SNmcZ1pG5acgsnZrlq2a3qjnV13wsXAjYfcKPvsgCJIt4RkUHQU+gvaJj + gCkQp4kweMIQiFMgWY0FjPEJRS4utJmEoUaIVeLpVAt4sYBfr+GvN+n7GwtXoxB74aSwb6BfKbKEzQZe + XcObq6TlZ48GJofbWV5PhsMp8vAYiA+B+CKwXyi72rNkZMWYr03RhMuFpQCtpPFsl6sewGa/yOBbtGsw + B8twhO2gfIyRlxLpJEFjSewk4VDxkKm/x8jTGNjGJHEueaCoVcFl5H56ShnV8QDvVuAb+OhgmRvJfZ/S + x/1GUR+5Br4KwmFl+LyCOxU2EeqYUlxTCdUiOR2ZCqwYhBqRFkyTdk0BiMpmsKk1Kg4qozSitJKsrZ0a + NHtJWPWpw3MBopVmYMQSM8dejCKVIrVBG4jZni3MASAbMkwOeoP2go5Zt0FTANCQplzT/HwJAAnd0iwY + MuvTxKzv7ksQuLRrL5/zLIT7s/S/cHYOpAxg+0sGgMvIsgMGjagGRL0mDsCg+DHQ+YmDDhx05MTERgOW + kAgnYtNIaXbTwSSl2TL7ID4DdIWLL1DUPNOeSy3AyxquOPcqRbn3kud/0T6cL2JM4hZ5qi12CkNER49O + EzrlnFPTaZ8mxVI9VuYTUudBiMYQrWBWUN/Ai2v4iw382yv4qxW8tEIzpRbiycPRQF8psU5WWSun1KZQ + bTXpZ4+pneRGoT0JzTG14YagdAQmPDqz9wqtucRo5pGx0jlJp0WH0CFxhCmggzIN0Hk4ROVEEg2dr1bu + /csJ9JgMS0+TMkhSKTYxwSmOZC9eWnjBK+GQis/ewn0OQOITBtAb2K+U8aSsT8r+tdDfwb5VXnvDi0e4 + 2kpyFF5FhjvQW8UthFpqHGuE65RC5T7+p60wmTtARpMkutXkqOM0ZZgiBqsJ7EtqX2dcKVHBleLvKCZC + FaAJxCYwVZHJCd5kNWStwFfoWJ35sqOm9UMqGUsGAB6J4QxccxYwTWrLJgsjmnnzpxZS4QHouWX9yYDu + P9ijO2DPLwgCltV1uAwAlLdWeuU9+F4ZvOekIycZ6dXjs5aIIWBIM/5Inks3itik/SZZgXUe1hGZT/q5 + XCsH/KWAZRa0SDjezwd9/lgQyI9cQya3loywekF8VqYh2YmZmEUYSk+WNDvgBQJKcIIuwF7B+iad6p9d + wcslXJlU/6sV4hGGUYlD2hzdoBy9sh8iqxBZPEXsO0+4V7a95wc78hQDo40sbHYepnxGe/FZy/9n75zR + wOAI3uAjBE3FfMUzC56JcY/GkRhjijd8ajBVdOqZAwCEXvE+nVTOgo2CEzmLJGXFNu0hDskWbNCLJDUv + Ym+UUwdDr/SHiDwLegOHpfCgyt1e2JyEuILnjbD9AvRz5e6q5s6s2fAKx2fAHYkE8QkKnh5RIXspJMej + lG+6mLwaTJlXKQpRszZgnDe/liEgo0Q3EZqe2Ez4OhCsI5psRa4uZQCjQ/uYMoAJiDERfnREdICYiT0x + u6TMsmjMWpKGvPZjdngJucSYmZnlsxZ9nkIW0hIFu7zxE1D/CzEBy8PnJ37IQaCXsyhsygBO4E+Bbpg4 + xJEjEz0enyOVlcgl62rOAHL9L1njr9T/58VdbkrezJmjX1h7mT3BBQ/4j7z9y5TBIE6SAOPy3DEQqXJA + mJJyi6aFa9Rm3DFlAEZjSr5MQmUvA8o8r22Zp4zxgh6ge1Lu98rbIfIUlbEFuVEWK+E2Bm4ePPWPcLxX + 3onn+83AY+uxV5GrNaycZUVNQ0ty+KsuPmvWUeyA94L/IBz3cJgCgx6BR1o+4PiAZ8ukfR6AvUwxLy5j + ueMD0Ge6d8wmnz6HIbnIvi/Yw7nCKrhqXudJVyAq2DSciHTC6RneL5VTAw9OuQrCqgZuYHijyF8YXn/p + eL1a8ZW84o6vqPgKeJkDwOXmTwcRvRD7lOF4T9aRVZwGiCGTalLWFAlJ8i2nMCoROxNyUorunSdWA1qN + qAtoQazF5gBgk2TPANpLJhPmVF0TOSyZ3eQAEMvOT9RuLRLmRTgh5CwgWAr99YxXFhxguggAsdytfd6b + 2xwMfpFhoMsAsAce84sMFEp9SG2z2EfGU6DrR47jwCmMjC4QM5PJwUVsNRh1Obu3SNKcTkCIlKw/17Sm + qKbq3AHQC50umVfsZUS6rI2yuEMkL/j0q9Iq4mLyQ14KprfoKW0iM4DxIDH1iCUGjA+YEDAxnRiSx47j + mHrY5ij0FTwZ5R5YZQWFehvp74V3H+E3u8hvuzQ7PzRgNokg89IHXj6N1B8mtn3g7QvPx2tPfAWvXwrr + teOlXXDLhpbblAbHJgt2plOXoyG+g+m/wu5vI2/fjvx0PPAQ3tHzHfAjlgdEO9CIjxWVJpuJ5LdUGHEX + 5Kl8Ga0KdTRURBzZVzDvt0LJ0AuZbyNnWci0l853qUUSa+6YhmF6A2Ot7FZQXynNrdB8Hll8E3n1hePl + uuULeclLfkXNN8CXwHUON4U3LxmAUOJWOOwdT53h5BP6XtuBlpEYA0VLMkoReU3T7kIC6kqwQoRoFVNF + pPKIm2ZhGY0mu0u7sxN0UIyPiI9ojJmx55E4Ja5GmVHJB4tmTotaxZvIqCSmqhfwyQjHhNRildxe9Sp4 + IvGTEkDJ+/GZ5ND+TC5G/hwlwGOOMH3Sy0wUzjiC7yNDN3E69ByOHcfVwGBDqqvEUpGsqgKp90p0xGCx + weZ0LDm+pkQnyR9Fk76buUcCl2nv5UTUPD79iXag5ostF0KfABGpI9QBWURMgOgNMlg4CaYzmKlKSH8A + GSLm6LFd8h8keAwjNk5UEvLMiOE4wve9IgfYVfBiFNon4fRB+PEJfntSvh3hISZXX7uDZZNS/g87jx0i + p+vA7rPI8BfC1ZdJPehFteAlV1xxg+EOwhV6MoQdjFtleIiM7yLjd5HDbz0ffnPiu2+f+W77nrf+O3Z8 + i+cHLMdERIqOOlpW0XIliYbtxIEm8EslWWoly3GhsYZVgEVU9hoJ8YxFm3Ltrc6dmhS3JasmnwN/ltxP + CyoI46hMmUk6LIFbqP9Kufs3yuuvlW/Wll/LFS/4LJ/8b4CrlH4DaSQ25CGcnul+Yv/Ocv/Q8sPR8DTt + QU8s2OH1yKRTzkySPVgwnkiPyBEjIyJZi1IMWEGdIk4xNmJMSCByTPV/DC6NUdl0rawJuBgwMaIxmaLG + kGW8SKxT1ewwlE1logNfBQbr6TQyTTFzgAQ7Qe2ValLMpPgJ+lhGctPJm7mmJf1/AN7nPdrxC2kCXj76 + vPkTBqCoTvn0GVL9Px48p13PYXdkd3Vi3/R01ZRmAHLildiDiQYWQo2JNk33yYhakxdWRExAbTIE1Vmj + yyRX1dI7yYspcTYu24UlBkj6+TIRGLLcaEKGEBfyPECeWAwW6S2md8iUqcNe4JjbOj7AEDB+wsaOxitp + BStmiJyO8MNOOLbw3sD1APVW6bfwdIIPPt2lowpxBDtkDL8PPHceGo/eRMyvhPaLis3Cct3XrLcttWuB + mjDBdPR0D4bTu5HDjx3HHwZOP3hOP0xsf+q5f9jy4+49H/sf2YcfCHKPMTusDbiqoWmEhTNcW+ENwjUV + de4XRDXpZFpAvAG7E9a95S4KDz6yV8MUijz6RTu+3APNE5R6pqqkqi15+pmseKUud3REk8nsFfAZ2L8Q + 1n9h+OKl4dfVgs/jhoZbBr1GtU20jdy6swrVIMjBMN4rz7/xvPud8sN7yw8n5TFsieY9LfdM7EE9U+o/ + JdclTQHAyAmhz+BcRTQuBcHshmRMVkJWIBqiJrZnJGn32TriqkBlQhqsCkLwhuhTZiuunEcZwDYCtRKW + Sr/0HKuJkyrDpMhgqEaDKwFgjJghzgEgTeRF5JMAoH0OAO9yADjxC5cAcCYZ7EgdnUE9DQPELvV6/SEy + PI8cth1PtzserrY8VwdeMrBiMU9ioRZihYQmKwcFMGEuASAbNkjMAeC8iS9BPi3uORf6/VIMQ0jy4ul7 + HgcWkyS+XUxcVauzZ6CaNAIotcwsWzCoN1BF1Dt0CMQuItFiveIkYEOEMBFHZeoMu72lr4Q9wmJUTKf4 + PtKHFJa9yVolIRlVmqBMg3KKntBM1GvYLCtW0bJ+cNQnw2SER+85jnv60zu2+8jhwXK6P3J6d+D4tqN7 + P3L6OHDYdzz7Pdv4SG8+os0DTX2grj1t7Whry9XKcH0jvFgIn1nLa7Us1SIxKyeLwFKJL8FOwrUKnxvD + 6WgZQ8BGQ58X87z5lYR35AA8d9k1oTde9dytdRnGMkpwmvz7VkKzFjZLwwuxXO9ran/FIEsGDIN2RH3I + 9VZaD81kaXc18kE4/Njx7ncHfvivgR/vhYex42jeMprfAD9g2WGJWWuqZDA+G4IOqIyAyW3A8/hZ0Uj5 + RCslpjJGM7dbKsU0YKrkI6jeomOdeqGuRqbE2BTvk8lKbdEVhBvPsBk5tZGOCu8dMlXYqcJ5g5sUO0Zk + jMQQk7QbkZCB9UwIVk1x4ZlUAmzJ00S/dACAT1/okciSAccJdA9xC9Nz4LjteDg98dbf84YX3HHNioY1 + BpnbNzl1nz35Lk+S8s+l5ZeDhl60vSTOrkFnV5eEwhmTh3kkZQCFEhzFJCZXRcbQ5FzLaQXisu1zRFyc + w56qSZnOSdBjgFOVOP6ZmZhsozx4IfaWSSwHhCFECCGlg1mduJY0g2ZINZ54YRJhKtqKCO7ZUP3eIO+h + C5EP3chpt2Pc/cjjfuDx9Ae6Y8QfO/zxxHTomI4D0zgwxRHvRsxi4mox0C562lZZtI5l61g0lqulcLMR + Xm0sr5xN49jZjyEFgLQpAWqj3DgltoJuDbazbDwcvRI+6cZEfEjtvqCKT2A8U/4eNP18DEqwyQIs2HQv + rEvGpuuTcPvesKpqxvsVb2XFgxoiOyb9jsjH+R6ZKCz6ltXTFfK+4fknz49v9/x0f+Tp+UQXnpnMW7x5 + S5Ankk9zyh6VQCTmadU0KfgJUHzRXJDMzJ35J5eP4mZkBW0NcWlThuMFhgZ0icgSGS0yjWgYEnekdYRb + xb/wjDeBoXUMfQ1hgfMtZqowk8GMYKaImSLiA6qBFALGjF14Mqo45oP5iVSqT/xCxiA/f0z5hT4AH4jc + MrGhRziAbiE8R7ptz9Npy7vpA2/1BW/kJTdc0dBQi81D9jmcTjGRcfoErlAVBh+ZpgtiihtpaYucTTqY + GVKaOwtytvuS0hcmi4Mq6jTTOVNg0WiIsUJjsoIu8wUUe3ADtIKuIK4TTVUqQ/B1NijK9ViMuKyRYHIE + 89mRKNmc5965FKOMnHkIyfShSqml2wK/g/F9YGcm/BjZHybsduS0O/F4uGc/WnyMOEacGXP9OmLaibaK + NCvDcuNYXlkWS8uicSxqw6I2NLWwbJMg690iCYQW9d6YJyuRfLmvwDpY1WBXitsL7cnychAOk6YNnzdI + 8JFxMExTZPSpxThETV8BxqiMQRljZPLp+ps8eGRHsFuwPyg6wulHeNsI9yjoEdUe5X0ar5JUophoWIwt + q+0G87hk+wDvtiee+h1DfCaaR4J9IMg+IfA4hAZKCZAnlS41Jc+gciaklY5bAMJZal5KalB0JYygjSUu + HVqn3xffICzBLpHJISEQtUdXgi4rwm3E33n8xhJsQxzWENbgF1hfUY2GeopUU8SFgIkeUU8SUxtJKowT + 2c1iIIH0O1L6H+GXsQf/+aN0A+5zEPhcAyt6nB5AnyE8KcPzyHa758PhgXfLj9w3D7zkhiVtUjYTl07v + qPgOhm3SmgvzyXwRiQvBx6QhodRnyixBJem2A0iW9polvs6AVMoMUrNabL6jsbgFXfbsUtiXWUacs3fd + QpClQdr0Pu1osipZSAhy8czWZKeT+sgRMWnw1EnKfSpldsI587kE8RY9KoyKf1D21nMisItC5Q1mHPDD + kXGCGJXKKItaWbSRxUJp25jGcpewvHasrpXFWmhqS20tjVhasdTWUDmhdcrSQWtSLR1/drwppMC1BFcp + 1VqoB2E1Wt6Mhm5SJg9+gjCSlIs7ZRwiw6SMXumD0nll8Km+HSZNAqpTZAjJsjz6xDhkgumgPN8HDs2E + dV3enAbVkBRzyui3JHC3jTWLqcX2DX0n7MaRTjuiOSDmgMopt8wK5za30iSxPFVKGl0CQGablvmO4lDm + QcKFunyx+ckBQG2y84qrxGFI7C4H2gJLJLaJ1GMDuoCwEcJNJG4iumjQuEL1GgkbxC+oJsdigsUYaSaP + 9dkyTse8+ce8+QO5SbvnjM/15fb9OQJAvAgA74BvCLzUARcPYJ5BH8F/DBw/dDzePvO+/cj7m4+8rl5w + xTLJOtFCBD9a9ifL00l57mEwiV5oJCQEfu71m/nPmgkaRWtaol78b7oh0SbmXtIATCDO2V7MJ9AxMAcW + sjuQEGcpKC06AaUuya6tsjTIQtBBYQKjAUeThp6kRyUNCyUOU0K+LQl2cCpl9iOxQjMvhChYb2FMizMY + xVslWCG65P7TrJR2FbiRwMJEFrWwWBhWS5N87xeGxcKwWBralaFZW2yTTSXVUAVHHVxSbEYwJmLzoFbg + U7+FOQUu1Io2uz8rNFG4CeCDEnIA8CNMvWHslHFQpjEFgLLxRw/jpAyj0g/KqYe+T/8/5mDQHSOnY+T0 + FAlmwopPtSUwaWTSMIvKJMkupbLJi8LZtC68jQQtI50+q+wkMViRLARLIDKhMiKSAzd5iOxigKyIw0qQ + 2R5tPnjKBSrOvxZ0ocRNJG4Ccamp1hsaJK5AVlC16NIS7jzxpUdvQBcOrZYwXQM3EDeY0FJ5Szsp7RRx + Ux5GC4Gos+BvDmxR83584NP0nz9XACjtwHfAT8ATysRAqzuSWOIawkbpbwae1zvetx95W9/z2eYFL+SK + a1a0XpHO0neOD5PjW+CtUfYyoJooq0JMqVXR6CsrUmS2AJeYTDqJiWOoMXcNiu+6pNNcTcx2zylrUG+Q + YMkT+wkMNBMiPt1gSSZ2pSWWqfSwFOIaZAmxixAi1jtqWpxocoLFz74GSHZ0VYOLktR1QjrBVQufq1hU + Jks1ay1NI9jWUDeGqrFUrWPZCjdN4EU7cl17lrXQNI6mcSxybd80jrpOXoxlUFBJWZL1FuMtJqRFXlyO + 48/dQS+xl0zmCVkvwViDtWmMt8llmmqu6ydhGhQ/JkqwD+BD0orwQQkBpgnGHoajMByhOyl9Fzn2gd0Q + eZoCzz7QTwlMkDDhNTLl82448/YQIpOLDG3ANop1WcugWKqFlGFhDNYm5l8UJYpPngCzJVhaV6o5w8wY + k6imBlHe/DKXAEU9+ZwFqFXiKsKdx7ycCLegT4KMFSYsMe6KuFgTX2wJn3vC55F4a6FtEbNB5AbMDcoa + fIOZBDdO2EkJU0zBNAY85wwgaWzFEykTf0/C5Q5c0CL/nBnAOQCQ2b6HdO1kAbqCYRnZLo7crx74YfOO + V+tbbu0Va11RdWtk6/m4j3wbI79tPT/QsXcHojlgZUw4rDEpAIhikhpCtgC35xS9SFpHcyaGGU2tLKOo + i1nZN3cEQiopYsz9KEsKmiYg4vNiyJuhDIwYkqnlQohXBjYQOiWOggSLiw01isnLNBZC0kxcVEyUM7CU + SQvGKrZ4DVhoGmG1cmyuKq7WFculo60dtatY1nC7mHi17rlejLQVGOMw1uGsxVUWZzMKrYYQhDhlhZ8c + BCR7Nejlpp+ZlJclwJkdqFFSrT8lLWWT4loCWm1q67kKbA1VY1JKHy+kKmZGoCZxjcEQjoI/Cv1R6brI + qYvs+8DzEHnuA6feM3UTU+fpJmEbYBehIzJpGYo9+xwntegL7NgINkvKFal6JLkjq3iiDKgMCTvJTeqI + RXN2NBuClBLgEgRUBQmZ6hvStXRKXES48YTXI+EN+OcqtQrDitDc4F/cMXx5YPpVZPo8Eq4bYnUD8SWE + OwgbJKyQ4LA+YL1HJxgnOPlIFz0TIzFbdKQQyw54C/yQA0B3uVn/HAEAzqSDe86swDRae0ogWXhQdAW6 + 9jxu9vywuWfjNjTLNaFbsn3XIm8t3z+N/CYYflh0PLoHvDxg7RErATUVxcCTTOCRrFNf9P+MxNzKSzed + aLK+Z9K4K0BeaRVKVihWsXlgRubpN2JO+y/8/mYQsHAMGkU3EPPcw9TDOBmaCKjDaoVoNasZk5dXIDJJ + QE3qAYoVrBOaGupWsLXBNtAuhetNxYvbhturhk1b0RhHjaMVWLcTm7VhuXBYp/nzns1OhGQ77X1KW6Of + gercXj3D9poZb2Ky5dqZSXXBqsqH3Oxlz9xqNUaxVeJ1WJcDi1FwGQTNI9KSHZrI+K14gd6iveAHEjYw + RrrRcRqVQxfoT4Hh6OhOnkMXeR5gN8FxhGlKAqLeR0Y8XZgYfCDEiDiwtWCaJDTSqlB5C76mj47nYjn3 + Cfp/YUQr5+s1ny3zP+SsQHMPXn1S9Ck4kwNWkfgq4H+VSE6nhYGhxSxu8a8/Z/zKM37REG492rYEvWMa + 3hCPd9BdwdgkBmBUbEzsQh8CY/SMjExMqXxJqsGeVPe/zQfylguDwD9nACiR5yF/7UjkbKdBCJ2gO9BH + JayV7arnrXmgelowNgs+dg0vHgzyoePjc8PvvfLsOka7R9gjMqRTTBogjVUW1d90MGveVrldZTOyj6SF + Otlzj5bLqawcSDKGoGbmUae1HjOzMJM9tNz9clpKIq/oOk0TTiN0nWA82K7UjIYqNtgoWI05YZ3w1jM5 + RRuDaR11a1gvhduV4W4lrFtL3SZz1fW64uaq5mpRsXSOWi0uZEdeJ1StxdYuDVPl6TH1JvnOZ9ZjiJpT + ezKWwoxnfCItbQFnMhFKU4+6mKfOMsz5OticeovmLDuDZtGkIap0EdFMkZZ8r0z2BheraeDLxeS0uzCY + kBbpQi3rCNMIY++YusA4WoYhcOwjhxMcT3A6Qn9Qpr3QHyK7wfMxjmz9yGAjtoJ6Dc1LuF4bXnrHel8x + 7SredwYfRnY6pLAvnJGP807P8U9mWzot1yYKEiImBKyZMJq+VAMSShAQuBH8r6FrlPhS6PoK014TXnim + l47p5oa4mEBqdLrB97eE5w08tZiDxY4BF5QqKC5EQvSoDnh6Aj2BsYB/ZR/e568DPxsP/HMFADhzjz/k + rzfARiPiBzB7SdLIS2WoPU/TAbn/QGeW3I8LrjrBdie6sWYXA4MZMAzJ4jsaNFY52ZwQ40GmRODRBNYk + GadMBrKaByokbQIE9Wm+WLKfYLosIc0QCAmNLW3EmIQYJNrkycaF+UhJiwOZfRyhTdyFMBqGIc8WuDTl + FyZHG1oacYh4rBmpnEdqxbYRWUO9VtYbeHll+Hxj+XxtuGkMbW2wlaGpDW3taGwSg7QhID6DlpJopn6y + aSNHSbZhU2I5ojkoZvxDnc7KMjOOSpqKg/SZpPBzc1ckjaCeh6oSjTWmtLfMY5SgSeKol9c+D3LkNmrI + G7+k0jbOabpYRarUFzUWaiPUHpaDEL0lqOCjZZqU4QTDAfo9DM8wPMLxER6OnuVkeBCTAsBKaT+H5a+E + l9eGz8eKzfuaIxXGw1MAl803Y673yzqSIrYhJs0zlPIzz5HgQUYwU8BYj41jDgAT4kOeDRF0YQhvoF/A + +CJie4FqQVy/IKxqQnWD2inNmfglelgSnxrMo6XaKXWfWn92DJhxAj+geiJyJHBE6ckHfenIfcgH8dz+ + ++cIAIFzN+An4HOg1UAT+kQKknxjo1GGMLHbn4j2kaNfs/A1DkVZJD6TTkiMRG/wg8X3KQ23daRaDUiz + Q6VLiUBcYHSNoc3LMykLaQa8UjZQTr2k+lpO/0TDzKQhW/TfJW1+XAo6xRvvEhgjL2wl9cxaRW8SyKVW + oLWEvWPqYPSWBZ6lm1i0ymLhaVYRt4g0S2GxdtxcO17dOF6vLS8XhitnqY3JI9EGWxxgYs7Bs6xhQPFR + iJNJJ3wQ1Ev6HvOWzFqLycAwdzFi6WbInMbnaHGOc5lzcfZLMOc+t+j8659M+WRrtXipT1FwxBwi5s1T + ggCpLEgqyemeGMlKzKVroslOHGsTjjBA6GE6KuMOxjvh+KRsjrCZlDcYJhuxK2g+g+WXcLsxvOgctVQ8 + nSwfD8qqc1TRkUNr/poowjNSSMZ5EjAFRmASpEvSZ6YH2wYME8b0hJjGJRPhTFBr0UVmOLYxqXwbQeuG + WEl2E/JpTNlXSO+wO4PbRtpdoDl6quOEHEbCacRPPV6PBHZEdihHMs9nIKX9iZSXAsAnvdw/ZwCInLsB + 3wNfAbeqWuuQMiYT86y9SZ57U5zomgPKAxMtlTis3KKxJUyWMFl8Zxi3wrAbUR2pr4+09hm3eEDdDg2C + 8XdUMTs1Zvkw1SInlvnbElN9pkVQIevda+r/J/VbsvVdKS9MGvO0XGyWi6+yoDWmqeVVii+xFobWElth + PDmG6OmtZWrAriO315E3a8NtE9jUhqvWcnPluNlY1q2htYIjzTjMIhCRrAF/6QdTvp/NOtMUa9n8aX4C + GzLTKF+PIqJwybic76IWh7Uzd7f8kIZc/Wjh9J439Oy9UNSO5WIwgMR1vpB1SM+XiTWXA1zZD0B9ns3I + 785AMpq1gjWJjFS1UK+guYLpVmmPsOoNd9ExikmTew1Ut1C/gEWTxFT8STh9FJb3sMRQxwq0IlDlVzoP + m2eMP5VE2VNSixrmIWW2thOsjVgZMbYjcoSwImqdL0nmO4smyXabr5/RzE7N7r9BUr0/Qt0H2lNkcfSs + 9iPVbiTsB8Kxp5t6Bjo8R5R93udTSf8/kA7hJzIW988VAJREOPhIygA+AN8AN2hic8Uc2dUkG6VgIuP1 + CZpH1CYxBZ0sOlp8t2Q8VAy7SPcwMGz3qHmm9s/4zSP19QPGbBEqKo0oV6guEc3GDgW1LyzAmBvtgfP8 + QD7dJA8VlanA1OtJVlBqImcv8bxyxXwaV4Ok2taCLvPBaQxjI/je4BH6WpiW0GzAbITbpeNrF3ghcGUN + 66WlWVqsyxvCJ7Qdn8G2PG4byUFgHnvPzEJIBIKQvpc0XWyaqUCSbdonzqbzic4Z4Spf8SIzmAnveg4K + JYMowzslE5KSHeRrLybX+1xYtHEOorkTIvleqM+dmknP0lhCAknRpIhrJbsyp+e0DqQFu4FGYSMmlzGp + e2sWYBeJ3qEoxyvFLZVFJazU0miFaEOk4myweb7BRZVuBn99CgCyF2RvsCfBtop1I2JPEA+orOfPqCFd + 5zTgFhGbNACkCCVIVq+KmobIpojxSjVFlr1nefJUx5HQDfR+YGC4AP9GErGaI2cuTmn//Zyo/GcNAJAi + zsNFAOgoy0gT7hb25KntiOrEGDzjtcdXnhgida9oto7qnpf0D4Hucc90eg/1O8bmA373RLPZUrue2i4w + tiXoLRKXmXKbSR7mYhHKxUbReWWnt5Y9AIt8+PlAkvPd1xw4Lk+1GSy6uAKG5Ba7AW1SLRwd9K1hWhra + taFbClILa/G8UGUtBlullLeoG2UCI9FrEpXUc/JS9CO4eAspS/8UoPxEJ+7iPerFnp4Pd51ziXmjF4dk + MT/74csngosNo+frkslayWxFMrEq4wCFLxALoQuUYupyft6Y8RwsGDXEmNR1Z7Znxh5EspdAxVlObraB + JzFJs1RirMG20DZwZYSNOhaxxmiDUgG2YPj5k6XsavaUUE0KPyeQnWB3FneC6ipi3YgxR8Tsif4qkWDy + lEd602EOkBBneK4AzTqC9Ap9akbYoNRjpDlNSDcw+Z5JhywBp/OVJzGB7oHvSO2/B/7I6f/PEQBGUurx + LgeAgkKasvHipPiD5OwvRcBp9ITKo16ZTop2nmHf0T2v6J8C0+GJGN9B+ImwfcA/7BmXIwur6CpizBZr + HjGyyo4uSwqDK2XqOa0rgFhZYSbPeClnafCZZXixy2IGwuZFXtqJl6eizKemQJosTJ6mhCplA+PCUS8s + j01k7zyDpJtvi+JR1hpA04x5DJEQJXWWLgLMufbmnK6Xjzn380uwMxebqjDa4kVQyz9nLogs6YKcs4WC + FpY2avnMF9tk/iY/DwRph85iLpdBo2QD5lLcWi+e7mdRS1NpEC+MXj+xfMgZgbrUBdJL4ma+XtEqUkHj + 4EoM11FSAKDOGYDhk4d++vupzNKkEbEX5ACuAxcDzvQYjuCPKB3oFUlmKregSw/1Z/59qjF9rpMiu6Qd + Ib1iR8X1EXv0xG7ATx2jdkyMhDP9SUk1wDvgD6TDd/cPXiQ//twBoJCC3uc3ck8qA67nVaKgoxL2MU2O + jYp/DkTXE/wTbggwnpj6D4xdi+8iMR6AJwhPxP2R8X4i1ppmxiuPWRwx5gkra6wsgQWzGGipMcN8TH56 + Iy6nOfKCnCm/ueYvdWhatJpr2YtTMQf0+bU075k8shCtMIkjRIPzwn018g7hVwY+R7mK+umJnDfYTJrR + vIny27xco3Khgy8Zp6NYnmluXWbCVNmUWnwPS1Aoz5kR/TzLlPv8eUSpTFbGzHefGyI/2/wlTl5u8gIs + ysWGngkFeVzYna/lPHxjLo3gSh4uZxwSctfi0++lesnWruck0KWXFAu1CGs1XKmhjRVoTSCb0KZdeTGJ + ml+3vPMJ5KRwEMxBcENqzxkzInICk4eVNCRnoRJAL/QSy/YsdvRxiOg+Io9QPQnuANUpYA6euJ+YjgOD + 7xg4MdAxzkEgQkr/3+YA8JY/Av79cwUASFnAA/AjCQz8miTW1s63PgcBiiPqA6iJ+NhhwoTGfZrGCxYN + SnaSTznSFGZhSt/DGMDpRCUdwfRY9Vnxx6XfLyT7kK98Kajz3VCTiT3lpLssF4oIaQGB5oVuctF6JsfM + aHhpp5X1HIQYTepmjJbjFLnH8r2x/MoYvhHlJeYMpM8vwlxHS5l2njfqvOfze8+qMmqQUIKAZHkwTdmL + nLGNzGrKmyinFGXz2vzmTd4AkRTFskaCWIEsgXZG+X8G+M3lyWWWlN+sXATNy2zKlAor/bIpG+4fzIPL + +VqUp7TnrzLH9UmCnDe/2BTIjKZg2URo1OCwiDiiJInw1Bq+LAPOLz0rh0/AUZCdQfaKHQIuelzVY8wJ + kS7V51EznThkPKCk/Hq+RlOAo0efFPMI7klY7CKLnccdesKxYxg7eu3oSUFg4kRkIIt/lAzge9Lh2/+p + zfnPEQAKIPGeVJP8mmRVWTFD7/mnykBFAbfmY2e4WEWkRZO19u0SqmvBrQVbO5w0GFYoC6Jp8OQx3oJy + R7JeYK4xi/ZLIbIYUnungGAF/Rfhsvc944oFCCL3suP551RiAtyKSWkseATYmIZOQog8GcP3tuZbgW+s + 8kphA+cauDxKWps3UTnhSqqf+tGfJMppr37yF+UElvNGL+BTrqe1+CBmg1Sx5XjKAl9ljLqUExfEIeX8 + /s49//M1oiSp+SJq+ZnMmZfSgjWahFntRTU2g4Tnzk66LhfvNU90kqUhxJzr9UJRnr9IdTWDoEMCWFM3 + OOMVcwSxiVknKWAUhuRlN0MjaCfEJ4GPYJ8tzY2hrTyTOxCrHT6eiNGjIQu2qkdiUpKa19EIsgfzAPIE + 1UFpD4HlbmS566hOR8aQHDWG/N9I4gBkOZlL3O1HChX/XzAAwDkL+DZ/fZ6DgP2jP63/jb90wAbkBdR3 + ltWLmua2wWyWUK+wXGPkjmDvwKyI0WFjnhWYO3aFOsx8wqcq4UI4ZLYPM/OikwyGaVEeziRwCRmQCjlI + ZNRZrSbHl5BOXsUiBiqJ2Jgm2I7e8G5c8Hvb8Ks68tIolUaWs0tMCgZSEOM8lXg+8cvGLnsvT8NxkTLn + SUcp1Q6cq8KQSiLNWnVFSFbKiZzzVClUZb144RzwpIy+whkTyGm+FqZfCbjz75tPaLQ5Omc6bbrnxiYw + 76yIm/XwQ8EkStaQ5zmsnpmfVkiTSUkAZs5MbH4un6y67R7Go9BNcEQZ84i2K3UCDi0DdEV3X0y6FkU9 + OkKcBH0S+Mli7oRmIwQXidUJ3DN92DINt8SwSLZhVGltmJCuUQTTCfbBYN9b5ClQd4HVMLA6HmkPB8x4 + YJQD3p0YfM+oPXG25Ow8+I+kg/Y7/hun/z9nAPA5APwB+BXwVyReQPPf9duX6V0FXAnyBqovKto3K5Y3 + 17SLDcauUV2jXCFcE+UalTVGLCoRV1a+yeYhMZ8o+WamAy2eGYAlx57pv+dUVfNCL4xAyWOhkucD1GQ5 + Z5sXNDmdlXQqVSR3mGgiI4ZnrfgR4Q8S+UICGwJ1DLhM3ikb0FhNxCLMOSaWvZeRf811eaHlpkuYPntp + XKSsu5ymMbfesisS6c9zG7Gc4Joo1nmXc87KCvIm8xvR0g6cwb4cBCQx6ubsoJzis8dDCggSuHi+mDsP + GZORnAqV4t6YvPGZ5Ybnzk2+3mLN7AQ9M8A7ha2ij9Dt4XGKPBjlJMntqTJCpEJNIuaUFKlkAWktSVrF + IXUxdC/IO4tsLNVaWLgAt0nNROsHNG4YtUHDCrCocUleOiYgkSewH6F6jNSnSDsNrPyBdthj+wOTP9FL + T297htgRwomUYHcxeTTxPfB7Uu2/508cp//cASCSGEnl9P+3wF+TTOzlH/3NlDVDC7IU7I3FvhKqzxzN + qzXL69c0zec4c4fEFRpqYmxQFkCLSpVVhwOBkFO3pGxrooFQzcSO+a3GOTXIa/18EpfW4dw9KHVvLDVq + OpHUxLNN+bxZc+5pCoCXHJCiNfTW8uAMP1nlJyN8HuBOk+f7jNCZrEVQxp6joYxBnLt76fjWGVW6xCXy + D5lc6+cyQC+Av3N9m7GGwv6bEft43tClNDKlNSo5iCRu/FxhzXGipOkJh0lBIm/MnFlRyqhQgL/MxnQx + Nx804Q4iELPXQfk7I3lwKb3ZjFJQSDuz3DAkHbIj8ATjg/K8g7c+8M4qe0lj343CJDWwIBKQpHRfPkp6 + ZC6DGmWW4n8C+UEwC0NjM4X4uiNWD0QWRKmYPKi26T0FgYPBfAT7TrGPUJ8C7dizmg4sxi123DFOPcfJ + s42efRyY9ICyI6X+IZAO2d/nrw9czP3/qcc/VwCAT3uTJT25YVaW+xMPIUXYa5DXgv3csvisYvlywWL5 + Ame+wvhfE8YXqDbpRJ5bVXZe+GoDMctzlw2hpTU4bxLNaX48v3YBCDWeS4VyhELqP2eGodoUGNT4GcjC + pFQ11dUZmTImD8RYxAjWCNEmW7B3Fn5E+LXAlyK0Z6ZNJiKVz1AMO8rmye+pmKl80kM/I9bnenz+gMy7 + 28qFmW45sc18vc7AR97Zkj9fuXaZiJRGMpKAipZgUVL9uU938TymaDckkBSyL0BIq0bz3D1WM5nJgysY + iZ0TkLNqU3luPb/nGbLPWU0WyAqPcHhSPhyUH4Py3gYOJnkh1ZoWX2RJUnVSpJTTF5eulDjkbgkD6MeE + URlrqA0p27vaofIe1GBCxMcNUS30AfMhUv2oVB8i9XGgmU4sph1Nt8WcdozjiX4KPE3KU/CcdCDoPn0I + RkhZ9kfS5v9t/vOfrP3L458zAEAKVfekNOV74BVn+c0//shEGq6BN2C+Euo3FeurJUuuoX9BP75gGO8I + alE7YoxP6O78FYn5JqVDROcUWMviKws45pOlrMiy2cuf55YgzPY/RVTUaKbZZp69SceqisknU/rSghHk + FlcV08xA55V3VvmDha8RvpRkTJS1SSkzCFr6+wUUzKVJSd8L2+7TmlznU3rORszFKi6y6pcdBYr8lVyk + Bj9D+3Narbn0KZiKGLK7rc5tPCl90NI+tXp+zfk9ZBONAkSWMsVb5tHrdMPSNS5BUOaLdNEg+Hkml9/7 + BJyUuFP6Z2W3hQ995D5GHqynzypAlULE4aUhzQMkYVApuEhZEyWoudypiSSv9wegNhgH1agsbjuoHnGq + TNPEON3i/ZJ4qDAfoH4faPYTtR+ow5Gm22G2O8Zdx3D0HCdlFz1d7AnJ2etyjx9JyP/vSJn2Ez+b/Ptj + j3/uAKCkkPU98BvgNXCVt/cff5QAsCblCzdgryxN07DwS9Q0BFPhzZmkImKRLLlRRl01b5yk1ZA865QC + 2KdaXkQzin4JOlzwJ+a/LhvLfPoPQqY1l8WXT1QtG//yhEo/K2pwPrEdB1U+AL+vhC+M4QtjWWvkhZZc + pRiiZzTdRNRdZOdaKtNcZmQ5rzMolycCLyzVMBc8t1kS7fLkvIDM4Qwc6vlzF2WllBWkejtZEUoC4jRl + SqiDaPNTZlpyOTZj6tel35WLEeXSliwIpn5yvUUuMr4cpOb26OU94PxSdBB3aWJw96R8PCgfRuUB5WAC + XgJGIpUqMSu9KA1JHyCiZkolXpmpKG0FI+fLosyqGAKYg9JsArY9sTCeEI5M4zNTf4M/rJGdoTpMNNNA + FUfs1CG7E/6p47QN7E/KYfL08URgy/nkVzhn19+SMoB3/Anm388f/xIB4JDf6N+SPJy+JHe9/uhvCOkI + bEEXSjKcF8RaKknyU/XSswkBO1lkqgi+YvRZZy5CiIEgnmiTjpxklWDJBarmNpIWPrbk+viysVzGXI2c + zTHnhZgR/zJnMJ+WzAv1k1OI3LIzaSDKxTS3FVU5CdwjfNcYvjPKS5RVEFaxnN6l56S5RVo2gszdjZkV + WByWNbsfIekEDuaiJMjDKJw/7jnVL6VUKTUuUvl5H55bqQUdx2ja/FVuz+VMSaJJqX1O5xOwF/K1LniC + Odf6cnGN9fIawsyln7OWcm/OWUzZl2d/SLI/rqIflP5eeXyEtz28i8JWYMqX2WRnxApB1KLUKC1RIl40 + BQFJwh+fMijLV3oiPWXxmGOeP6g94kZUO8LYEbqeMGyQyeHChNMRmSY4TYStJ+4CwzFyGkM++Yu93xwA + Su3/Pam0vudnqj//2OOfOwBAYiV9R9r035DAwFdcEIM+eVweWLneCkbxVUTrwGrlWS8DGwxXxwVuW9Ht + DU8HeDwKOw+H4OlMh6+OBBMQE7JQaGn1SfIDsAVJiwmFzi+c1IFg9n0ri5Dz6ahS0Odzi6zYkn0a2XKL + Kw/jaB4nlajIJIQRThV8qAw/VvAVypsQWCpJrmvm+2Zl4yBJ7CPz02cyk8QzW0/tHDwkZlsvzkYpc0ou + F/8/8xkuavxLXsKcLVxu/vwr2VfhbFyb5dgyi1ILOlhAyTmQ5LLAynnzohkPON+rRC2IWfgzB8EyI2w+ + jVmfbP5IsiR+VvxbZf+j8v5B+a7PfFkpPHXNEEXKjpwalJooyljIpGhqDZZ2a+GMzNlHfs3iz9mT+vsu + rSMh4DzoZMB7jDgMAQ2ecAr4A4SDJkZgnFA69JPN3+cn5kR6+7/J++pP0n7/2ONfIgBcdgR+m9/0F6Ry + 4B/yAkralt2OdVKmGOjtyLQZqT+b+OwV/Lqq+Gq3pL1fcHyo+OnZ8tOT5eMWHqaRR92zi8pkPCoxKb0U + ID8YYiafmPxF+fciMFpOxnL0lQ2gZVjogj9QgLPy/i+R+EjawHOHQDL6nkZPTEhA2JPCTyLcW8NRDXck + DYC53synoPp8BhRWnrnYkHMGk2cfSvlSpgdLvT63z+JFRyNlPjJT3c6bfAb+Zqpw+hwqpJl9J7PgqMRs + YjmXL7mDIllc5JOpypJllZZe2lRSphyDySVevgWlrXdB7knMvyLTJufWYKaZswf/Qdm/U+7vlR/28APK + Rxfpc21fXI3TbRVcjmwx05gLHTuNl4c8/FhKwFyezcxQOeMOPr8XcfnyWUwMWO0wJGB47JRhpwwHCAP4 + GIjSobLlj2z+klF/R8qovyUFgH+09Xf5+JcIAOTV9EyaVPodqQxYcDkjcPmTI3ACPSmhD4x+pGOgrwf0 + KrJ86fh8WfGvbxx364rTXcubbcsXH2sePggfnke+Hxw/KDx46KLB68QUIc6MsnTquNxyM7NW4MUJMqPu + l+2vy4GZtMAlA4WaV0r6LjNhJg0cJedWzePQYpLzTZS0sLbR8IMafnDCo8BnVrF5CkguJxLzKVmm7CS/ + pRjz+5Xskyik+rWM6oZcl4ukerxKGy9RrXNnI1ulFZp0FnGgaBnOmVA2tJSsZVgIdCWdt2qwGCRmapIV + IjbPOWVQVLK6cpEK44LpmK9J6bakoKWpt1+C80XGMAc6p0mCC4FB4Aj6UTm9h3cfhd/vlT9Myn0dONpI + FJ/fVcyXN5vQq2AkX4v8XbD46BL9NhPMopRuSyovjYQc9myCQCU7LGu6QEYczrgUs31k6iPDHk47pevA + B0+UjoE9geecAcybH861/28uAsDxn7IR/6UCQHnzb4G/Az4DboEVP+8IlPmAbGsQjoGxH+lDRxd7ThoY + jUBtaCvltgncvhCWXcPrhwWnn4SHt47PHoXro/CHyXIfa7bxxFEnhpjtqyJUNtWgJjP4QC90PuTiNL8A + xiTPFcytuDMyDmWflxnwXBoYyNrf+akM1phZG2GIwt4Lb4PwnTP8UDneEHkTPC6arCVoE2mpyniASemz + alIASn4HuWTInPeZLVTKGzWzApK4/J5V0+eR+Y3muj5teilZUMkUYpLMmnG62dqXuVuQhImSAaYImZST + tSBIZdMnI80UFiNJ+7H08EtiZUqmYROvYM680j/PzYQq04InA0eBj4L/SXl8L/xhr/x9EL63kb0LROsR + k511dB4byi9Y1IMNYmrAYbRi0gqvPYGJMNMnS3cgSaSpluwrMUBt5ioILonDBosG8H2g20eO+8ihi5xG + zxQ7otkT2DPpgeL7mx8TafP/Nu+h35FUf/6byP/lw/5TfvgXfhTSqZA2/msSFvApO7D0cA0JJVgBK8Ut + oGpbmvUNy/ULNs0Vd65mXTmadkG9WLFqGm6c4drCWoQGRxUrCBU+uuRKo5FRIz6mhWStJkEJJxTCUOpp + yZnrj5xNRExi6M3dgtl6LINA2ctdQ67DbQTr05eJ86Yx1mIlSU5HDBNpkbdW2DjhyiorE2klWVDLPHCj + +TQkzwlA4cmfSTCcN0q5piFLgGdnWnEZFI2KhOKwnDMdm4BCyZZpkmv0ZOVr04auDKbKlFsvSC/oQZiO + wqEXdhH2BoY6EqqY7LIzEUpMIeqYHEiye3AOyPMcR25HSrbknj93BjtTcMknf6vkPh7sBH0nDN8K778V + /v698p9Pyu8k8uACU5U0/Iyc2X7xor1nJG1cYwxWHEYqjLo0aq42nfDi8uxA9p3MivKJy5z+TSQpGIlN + 5ZVGSxwsw1Ho9pHDwXPoBo5jRxcPDOyYNNmW50Gfy73zBPxX4H/OX7/jnwD+/f9DAFBSSBvy1n6Vv674 + ZMCVc985twNlBbYB1zhMs8Y211TVirZqqU1LxQpnllRU1AKNU9a1sHGWtTS4UBO9ZYjKqIExW0oZq9ha + cVUicKR50Yxmqckp6CVinnXrspVPadPNOXDMvPWSuhrARaQKaXHmYRVjkgadVYdRl9PiFPlsdrdZWLg2 + kWuTlAnnHv/8Xs44g+b0X7gA02aJLmb+geRsZYYsInlm4bzZyJ9PShAo03ZG8ua3SGWRWpIIR2l/PYO/ + h91H+OkA33l4W3n2rSe2HldFaqNUJTgZSRvHZIvwGb03M4gphZ2YOf/GXnYK8mesNMkA1Tml2Bv4SZh+ + J7z9vfC3b+E/7+B3IfDRBQYXwEZMQfTROdYgRYPQ5GBlMaTZgLL5U3HjsOKwOJxUWGsxzmFslfT9Yk0M + jhiSGnOIET9Fpg6GfaR7jhx3E/uu5zAd6eKOiR2BXQb/Jn6G63lS+fz/Bv4DKf3/yD/x9Id/2RKA/IYf + SNHr70jzAUtSIPh0UjDjABzz1ykwHTv2uwPvn/e07YlFNWJXAWTkMzqWLmKWFiNw1QqLleOqrWhNRSUW + 2SuMSXxhT5/puzGvt3SSEW0OQJLbPmmnSAbh5rHZ0hvMZYIW5F3KRk+bKdWlJp8Meaot6/0pBlGLU0Wm + NC24M8ofrHJnha+s5QvjaObefk59y4Te7IlYiEDwKRlG5q6mViVaZAzEZwRtRrjykBOXXJsL0M6YrD1A + Rv3P2AJZjd6/g/0efnTwh9eRrg3cbUa89bSVsA6JFyBpALdwK9McRc6oZnrwRcZTgM7CRZpRd5vfh9F0 + 744G3hrG3yn3v4O//0H5TzvlNz7w0XpGG1IWQXYMymWdzF2As+bC5WgV2TvCYoEagyVqRZRkWxdjQEPA + ExmjoZ8M4xQIoUcZwQygEe0NYWcZd9BNkS729Bzw7POAj+dPAPoDqdf/d6TN/47/DtrvH3v8SwcA8qf8 + APwXUhmwIQWBzSc/VZDUDuQE9EocJvq+5+nYUx17VsueTX3gtopcS0djVmizJroWs3S0S3hdJRcYyzKB + WvsEML2N0GW6Z+mxSz4JdXb/yUi/xrlGPZuH5vSzlCy5TZjwnoupPJO0CYg26+dnrrsk9z0zz6cLwVtO + E7zzwndBeYflYC0bLBJzum4u2molKygc/nPPbm7viUgW28gbOQ+xnBWOLLMVdqHyQgIES3twFsXLLdPL + DKQ8zQR6VIa9sKuUj1fJLlwJvDKBwVCq/Hxzs4bBzGOQefRgzlwKP2DOvPQs7zVTryWxBg+W+M5y+gPc + ///ae5NgybL0zuv3nXOvj2+KMSMi58xKVasktdQDgu41axZgBoaB9QKTNQvAGjZgWG9YwQbMMAPDMKAX + 0A2tptWswFg0w6ZFq9XVUpVUlSUpx4qMjPlN7s/d73DO97E451z3l1lDVqlKmZEZJ+1lvIj3nj/36/d8 + 5xv+w/vGex8H3j433g+Rx1WgrSLiFSe7RC2f8BS7EOL865NileSYuTUKcUV0Tvww3UBBWiMo0Avrzlh3 + DU1sCNZgsiRpWYBuhNBLckamI9CQZL37nffv0mpJNN93SM2/e/wQvb/Psr4IAUBJzYs/JmH9bpEygf2d + t35bMKzSy7UNxD5ifYds1pxeLHk4nXGtDtyaLbleT5i5Iya1R+sJHQ4bGSNvXANEKmA+RHbXG09EaVQh + hlRvaRyYfEk4uEh/scMMTMTz9PWMbFPLPO8tQqzQYC26dDplBJ1UPeZ61CUHWnMVLqQaM2pFF+E8Ko9R + 7ovwyHkO8cx1R2PACrEmN73I7kblug23sQzZQDFR3uULUDr+RYhw+LGdk3+Xh8/ODa9lMkKSvZvkUi0Y + 9QgmM4gjGItQZ9mzbVN1Z/AzzN/KU9ppXu7yCGpJaf5YtwFNBVqHnXviw4qLDx33vw/vfBz5k3P4MESe + +EBXhewWZcOoL1VDPjfotpetwKtzmGY7QrkUXlOpkLMirw7fOvqN0LRC6HpWoeMidpnAcwY0gwZDsUbT + gcQV+SH7uSPN/L8D/CEJ9XfOT7n58937hVghXRE8aRpQpgKjT32nA5mAOwA5FGRSIVXWFnFC7ZRZFdiv + YO7GjOUQkT1MaoI3qCKVN8ZOGFFRxwoJjqhCR5oWBbHcCDdc5uEn63Ab5veu1J7iBxuxghLc4mlSqkz2 + 9oPcYAsu/WnkTRvA9YkWKoYzl9Fnnq4SdAT12DgYw1EN+86YYTvRe9gtiXNQGHGDenEJROx0y8socWdT + 5SbfYE9cOtbeI84PngRJurr0HPL5WajVO++TVkI/h3AVqutweAQvTOGWd1yjYs+SE/ElpBdscQDVtk8y + TAG8ILVDxiCz3OyrSBnM2hOOKzb3Ko4/dNz9EN55EPmj88AHIaS0v4pIZZk1LNkyLU0k/NCHyBZqRQ0K + GZjH6ZJldegh68iNSJfkvnys8JsKXXnWK8dJEznrVqzCCX04JoYlMbTE2BMtoAS2dONBW+0HrTPgu8A/ + Br5JCgAXf5qN90XIAMpak+CMb5M0A2bA66S+f7omDXAKNof+Jtg6wvoc7z6i6QMnFrgrynx0lf3JnGnl + qBAO2J5pXQ0cpgPkOuDwqRwQ0E1FbyMeyYJW1oi1uPzG2O6bjWSlneHd324wtZ1urYHEAaGX7u/cpbuU + opc6/RMfojiSYeUS4SMc7zq4hnFoxigj4tLIyQ8/J7tjujJn2f0abLVOyoRFGCi1A+hGSZ3tMr8rz3V4 + im67K/ocHCsSb2MM/hAOeuEVB1fHEKuKiXMcROWA1Fm/BAQqPZUSs7KeAlg2QKlS76EWZEwa84mmjGpZ + Ex9XLO45Ht2Fjz5WPngSuXsReBAC57nmZ0j7C0x6++vTSs9n2PAkh+TU3sldiktIw3w9c9+gmJvEKHS9 + sA6RdexpbJMJPBt2MPw/yepItf73gN8nTQDOfpoH2l1fpABg+QW9Q9qbWc2TVyjYACMBgk7BTiCcGH7U + YOEp2hlrN+HJeJ/J3j7zOcxqZeo6xmzYI28mUbqRwUFkDFzLuVzPhOZEWLWeDRXHVAS5wHyTs4B4qY52 + AyJv525Qt23OuwT0SXdE/vfSWc+ZhORswpJ0bbqZMuLMnGISh4OvMXggwnvOcxvHi044dIIn5N6V5d+T + gTqF9io/4DKnuDR8sQiVpEwldd3NlxO9COyVWn3b6BR8ZuoBURHNMtcTkD2orsDc0puoCPSC7xxVzHDb + Mp0ojzkgDTOqsWJr7FqanI4E7hEHnWCdYBeO7qln+bHn/kfG+/cj754EPlxHnhLY1Gnk6rJPQUqCisaD + DFlRqkp2oTz5ihV8wXAN08/YTuIieUwsChqEEIW1wdoiDQ3hT7f5y8z/HdIB+Q6pb/Zj6b4/bn2RAgCk + M/4u6Z7ZJwWCQ0hlO5CVXEjCoQ/zIRQjRotOV6yXKx6erpnUK+a2YH9eMa86xuwzYkKFQzFiHYkHRmXC + FXW8asIKz/Jszrp1dOY4FZI8FAFvistsN+88XlxK1QexzaFVnrH4QK7rseTQa5oF7mpy80x3BEp89jdN + PMbER4rDZu3UcWyOu3g+NOE1dVw1OPRxq9mXHjaRmgrIaKD/7mQZRjIY2RXJKDoChcKcC9Ntma47ffry + f5emJJ6UAcAWj18L+O0NJkMwksH8onwvsJ2gFIqzJ0t6sTMUTuAazGBjhAvYnDouToTjJ/DosXLvceT7 + Zz1328BjiWzqdJ3HmRqeAm5S3k0Q5vTL1LkMnLRP5mH51ebMxKBQui2Pggdqt6XrbQH6XtgE2Gikty43 + 9jp+ikmdsZ35/0H+8zNx/T/L+qIFgAIRfpfUELxD2vwjdpuCbb4E43QAaW24ScS1LbpcsqzO+ZiKmUb2 + aZntrfG+5Tr7jBhRkcZMoTY4TPfhFXO8ZjUrq1mfzdm0wprIhkCUnkpiLqGNSmAkBSjjsl5ImRRIPjgt + kz4s37M+8cu8zyX5DonEfMoAcnBCsgkl2Uk3OEIHF8HxuK+4q44POsdVjVQjmPmA83FI+xMLeEdavNxH + QwmSNr71pfFXSpRy2ma0qsvCrKU5VSZxwycZS6CkmmpXOah4/eVfOTyP0S4BaPetl+2/lwBQHnvQJE3T + mdgq/cJYPjaOH8CDp3DvPPLxReDRuuc4BM6ryNolCng1jHHJmo+aEX+U7m4WDy0jv/Skt+e0bTM7245u + tyIsbBOJCDE4+t7RBKNVJdL+uM7+j1rl9P8uKfX/gFQu/0zWFy0AwDYIfJBf9HVSHyD3lkmB9Cw9e51A + PAJ3EHCbNcgZvVWcq3LXIhOX/Ol1DuoDN2XKjAnJ/RW6WqkOlFqFawqvhZpFGHMeHOddCgBr3xGrnih9 + qh8lIcXM6jwhKHfytvNul+6KbQfZJF/1XH+nzepSS098IiWVmzOSAkQv0HrC2rE0xwP1vN8Lh7nxeXMU + 2GND7TQh0twItNrpM+z2HGTANcgll1/bbshB8jzmRDgHq0IvLl8fdBHy6xkoy2ShUbZfL6dlJgldbvWX + 7EQvBwaTBKPuk+R720DTKeuNsTyD44fw6IHw8Zlxv4k81sC5BTYuEjNKsMpd+SGbcTuXovza/B5aKXN2 + YdNl5dGq7DBIB3zE9kEgChqgC0KjSkskpPYyP0UAKCo/75C6/mXm3/2sNtsXZQrwybV79VOpnjAC0+E7 + SsN0DMxAxrlY1sSEUYOemsamNDLCvFGNesbOGCfMVj7Jcte7JiG4tMbamm5ds157Nj10Egi+Q116Ez2K + N5dgoGUDDXThkmJaRpDnTVZOw9xTwxd9v/yProIshjGo+URwMdXkmn4r9B63EWRlaBfoYkdnKzpdEHSJ + WYczhx92WqmvdxpsxeJ7CAB5DX1Jya8jNyzJVunDqV96gmXzKoPZyCfv792/FwakgwFSWFBSu01GJWUn + ncAa+gUsnsDD+8ZH95UPHyjvPTLeeyS8dwIfrYxHMXAuu5vf8E4yxyLbeO/EnNS03TEQyGSkIhAzqCFf + Gku64blu0/88AVDB9YI2jnbjWXaOsxBY2gUtJ0ROYXDt/UwrkE7+7wC/Q0L8vcdPSPb5ceuLmAFAum3O + SQjBI9JUoEwGxsN3NGBnEB+DjALYGh+NShS8Y+P2eCQdUSJaRaxusakDV/ECjinjZDghHhuD34eDK8qL + 58byrOL0YsIy7LHSNRtWBFZUtIiG1CgjwXa3KjqaFHmDbU+KbEApknoJ6W95CD/M0/ML2knBt6cjebYs + aANxbZyujA/WRhuFJzPh7n7kxt4FNyanXB8JN6o1h+6QsZ/g83irkI3KKI/d7ramZ7VVRM4pr6VUGc1S + WDBs1MJFkDIQL4rCP+iAy7W1SFZPFqFYZGEux2whqNEHJXRGbCB2St/AxRKOT+DhsfH4QnnaKWc9nDew + bISNKb2PxCqNar2QxGLIZ0IGHVkpkUpjM7+qgeBUvCCHHb8zpblkv2Tbk79MVVXQkD7aaDSqNNbT06JD + /f8Tle2rfP//HvAtfgqm32dZX9QAANv0509I0OAD0jvxKkVINKQAoBVEM5AOvCVMuh9h7oymusLT0R42 + HmHeE62H6QX4yC32mTBFSCguX8F8Cjf2YH0oHG88j92YB+xxLCkAOOtIhg65xhUDFwdJrK3nW24MOpdT + xJ0T/5I2X9pQZgaxKO6mBlWxyLJCelEhLo3FI2geCScbx0dTx9EV4/BKw9X9E25ON9ypx9ysDrg6mrM3 + njCrx8yqEdOqZlxVVFSgFVEjIQpREwhFiTvyXoZTowqRKkS8Zmju0Aosf8v7X9kBCDHsnYE8WSm+jlSq + +MohMkn25gpt8Gx6ZbExVhtoVtCujM1GWbbG+do4W8LpEhaNsozK2qCLjiBZe99ruk7lRGaH/lAu9+C5 + mK+5lK1vl590aXBe+jcbXs+u5JgMGVUa/YUgtEFoNNLR09OgtGwbgJ+pBGhIgJ+3SXX/9/gpsf4/bn2R + AwBsKcPfIvUAPCkDeIVM3WcN9ijz32tDRj1SNeCW+NExPsyI7YiTRY1RY9FwVxtkFlL9jGfKKNlMI9RO + 8BO4fWic9saD2vPRZsLTeECrmYttbYbPpprRrJyeBcQxFL3b0d9woCQpK1M3nJ7pFM6ju2HkpZjXzMTL + WUbniI2nPYHlPTg+dVSVZ3TkGV2D+eGGq9On3K4Dt+sJL0z2uDrb52gy53A0ZW80Zq8eM6pqxFWprMgc + 9l2ofeHB+wjjXhn3io+6pToUye/8WpWkq6CfNNIcvqWUWgGpQnL8kdQ4DapsuorFRnh6YZwtjfXS2KyU + i0Y56ZTzYGx66AMENUKeyYtXnE9VU+nLgGzr+t3nsdPfsN3TfvuidkJb6UQWXPOu6lGenmTtBSEPJjQ5 + P/e90EWjjZHOup0GYMdnFOpp8z3/R2zr/gf8GIOPn3Z90QMAbFMhTzr5j9glDBlJhvkEbEyq/ywgfkW1 + /5jKJ5ZXXDnOuooPu308AgRsusG84xYz9plQW41TR+2FK3PlFTWOvfDIxixWe8TY0zgI7oLKesQUZ4aW + DVG67JdAP7Y96SU19UwLNTcHADVMQ3mADC9IU4ShvMiNNQsQe2hbCEuP9WNkMYXTMX7ueTAJ3PcbrlUN + 18YbjqYrDsezlAmMRsxGI8aTimrPUe87xnNhOvUpO7AJdZzidIzTmkqFWpNLkcuiJ7s4NcuvTxFUBN3N + Dsp0MQhsHHEtNCGylp7OJfalaEeMkaZ3LNuKs3XFYuXYrI22Mdadch4jKzNCAQPmzZ7S/LKPU3OutE5K + rB16kDvvz2AmNECds5IR2U1p6BKW6UhRhtbte5sDsmQ3n9K+iBFClKRFaTG79u6m/z/29C+l7zukk/87 + JNz/z2Xzw7MRAJQkc/QBqQy4QmoGCmlC4DGwDegDkld7iMhog15psbDG9Q2uhRg9pxvhPdtLtJ+rDcyy + EATCAWNGWW1mOjfueNjgON+MWG/26IPwEE8vFVotMdekd704Bmfl2t1p+ZDiDw3BHYCOMNTaNnTAZdsI + LA+RyToSU+nqZobbB3fu0c0EO92HxSFhdMBFfUYrPacucM+3TKvAuN5Q1xVV5alGntGhMLkjHL4q3NgT + 7sxGvDA+4EhvMOkOGPVHVHFGNE9XkeyrirMQ7DCRbegxpgCwc4sXEaK1Q1YV7ZnnySl83PYc25rOVjhb + IWwI0ejCiE0/ow1jYhBiNHpTWrNh6wy5Vc5aCpapcIDcNqZeCgCXJo5FEs0y07GAeoZU3gapwlQtFKxE + foQC/ixjyvxzFkl03yD0UQkWdk7/S0IeP2o1JHLPH5Covu/wE0p8/aTrWQgAsI2M75KAphNSKVAcAxKw + a5Wb1s6QaaTbi7hpYBQjlfMQPV0HT/xtop9SiVHRoFOj8WNu+RlXx4HpnkNGwl7tuROFX7iA841npZ4Q + PSeAuUj0edhtbDX1xG2BLprSyHQvWaYI5+8fvAVT56DAh6V0xEsAKKM1EjLOz5XRNXBrod84wmZEbObE + 7irWXEdlke2iIxeSjCxE4lYdtwb3AowP4PoU3rgpzG9OeKGumMQRe+0tRt0r1PEISJZqUZKpyrY4+PRS + KxkBmayTXrU/dfh1BV1N96Ti4WngvXjKhfuIql5TV8skf2JTzJIVl0iVVYzSCNfn1D4lQ9vxauIWbsVN + KynA3ctIvqFHmy4wJqV3Uer69JhWxFNymbZLlyDzPkpTlhzwHGnjW++InaMPQjAj0OfmX8tnOP1zMcv3 + gW+TGn/fI00Bfiqa72ddz0oAgHQVH5HqopqEDdgD3sifDyAhe5o8JDsD7Y344obJ/kN8DTpS2oXxVK4x + ihWuF1ZHjiezhjf8mtfnwouVMmuniKuZ9xW3DuH1ruI41FxceEKILKuGvm6IVcSjuF0hSnWYy4IgZQY9 + NP52TntHphfbJRnyQal/qB4MfMSNoRobDqPeOMZnRnzi6WVCyyGdXSfaKXBGEpL4ZHPLBgfmfg9Gr0D3 + dZhcD9zUipfDdebhLerwi1R6FRCiBKJ0lwNAqbXLO2PlVM2/Rxh0neonQr10nI9rztYz3BNY9Q85mXVU + Rx8xqRfUsqGyfZxMMjoyiXAkht2OS4MWfT2PmiNiqCXItElEZduUHJ7IkNJvr2lyRduORCX3L4r+oxNN + RrKp05D7JG5IJWT4LwU+14M2jtA6+uDozYj0nzj9f2QAaEmb/3eAf0QKAj81x/8nWc9SAIB0oe6RAsBB + /qjZnQwo2AXEANolAIleKNxeML4SsHma73ZxzdP+EG1nnDQVD66seLrvWdeROI68hDDrK+qZ5+jA80Lj + uLN0PFLPaduytglNNUJcR+10ULYBSY60vkpRKOTGWNRcBsQtmyzTi6WYkWTlIfJYbuvlZzBSZJLqHS9g + F4LMDUZGl6nNgSMiB6QEaYfSu7skfdluAG/A+A24OhNejBNeideZ2es4/TqOKxmN2KF0FHfcbQDYPtxW + Mnw3A0hfq2rwD+BgXnPMAYdNRd1NiOO7hBqYrxB3gVeHo8ERM1Ui5dnqBnZ+mrWbR7KzvGpG9GFp8++0 + /a2gFM2l3klhKsoW9JMQgQxZlhb75OxXkPwNHWYOlaKxWB43J2oKFkA7oe+EPhq9RSIddqn7/0NXT9rs + 3yZt/t8lBYOfW92/u561AADbC/aHpE1fk86bl9klDW3AnqSMu2/Brwx3Z4O//ggfhdg3LMNtmnCD0+A5 + CxXr1ugmgdZHVmLcrmBvAtVsyv6k4sjX7JkwimOII6ImsI3P5pBSgDLiEJdowoPGbdHZLwKbVcAq3dmn + DonZ1F5Jk4JMLzOniZBX55s8KDJzuLnBDKx21P0Yxxxhj2SMWpOO+x2ATVkuX7E5+AnMxDisHEfVjBGH + pDZL8sNL+UYyxpBhK15epcshuxlA+WQOTI1pXTF3UybmEZvQmKdxkXXVMfMd+9axR8fEeiq1fCr7AZBj + O929MoDIIsAZl++IgzGIbfEKeW5nIUN486jDBuVmHfoGZPcoLWjHHeElK1lANnotfVk1cGpZiTlt/iTs + 0WFD8++HUnyLuMe3SKf/75MctH/m8/4ftp7FAACJA/1O/rxmIKDywqXX1ABPwDoIG+g3imxWSHMf2+/o + NoF1o6yaQGga4tmMdnzAYtJyPO/42rTjRR+YVNBl3r8MZqE57dWc5W+BcpfuUKkY7MjS/vGJzVal8Z5J + 6VD7XP/njMHYYgFkCzEWyG7JBnOFuSJTQVqPi2OEKZZ2HQMg32C4m8vp7EkgIcgD0IJPhhRjE4ElWpfw + AUM28ckAsGMtdin5TspLBXJUYLYiiXTTe2FVJSuwXgRnwsgqRtSYjEhtnQBFqHNAMOf2nmU1pR1Jdh3A + SWTh1C2Gf7BCL+YpJSHIKk+2IzpiIqhUuWFYXnNp+BmX42DuHxhEUzoLdLR5/r8bAD61CtLvD0gn/z8l + nfw/M5z/Z1nPagBQtk3BGakRWMRDbrKbCbRgpwlj0wWgiVQXK+wIdL8izg05WLC5mPF0NmczvsbZ/Bpn + V1vOrwSOazgyTyNwTkegxXOBp003Nkka23Co02xHF4eh+uD+U5C5g1lFOk2K0nASAHHbY42diCJuOwYs + w+exoXOFPUVnSfZaYo0wA+bg5kjdI3WPVQHL5kajqTC6VlPPJlyVKQfmGTPFOCJ1MxpS47knWkvQnqia + Rp38oPN/e+oPnAhJir4exygm67MgkX7kYeYZTVfMrkXsygg3GTNpWybdBMch6m8QZB+RFmNFykLylS58 + gd1rvANG2m1QWsEelJTfp5LqUz5N4rb4jaEtkJyiZGfD22DKwvAaMXJ/z6MKvcYhAATW2ED//VQAKASf + XZjvu/ycO/4/aD2rAaCsCxI+esIWsfHL7AYBUo0WF6RSbA3x1OCoxQ6PcQcb3GFNPBpxsX/Axd4tzg/W + XGjDMnQ8mgaOYo+LC9ZUNNLjZcPIXeClzyezQ7XCLKYmlsu2XMQEGRa3ZbgNIDNLZJyY1IEKQ8VcZOvu + Y9sbLxNNCkbFJobsKbavMHdwXuG6MaIpAEg1wx9u8NcMO4gwESbOcWU84ejFq8yu3OKq3eR2N+Ggcow4 + wJij9BgXecsVkUtNzbYhs/5kc3EHbju8xESB9sHhFULdEY96/Ist+5OH3L7VYjfmjONVRk8cfnONGF8m + uDeJbgycIDkTKQHR8txUpAiCFlgen942Rg7MbLX6inxZBicVq/fkEK1b1+hC9yVlL9suJHlEm4NRAHDE + UNF3jrbvacxoaYiDeu0lIw/YNrP/gKTs809JaNefWNP/Z7Ge9QBQ0qiyY3bZ45cyAetyY3ADbgHuOCAH + C9zhEncAdsUTruzRXduwbjv6ds1mseDx5Jg9P2e8GVOFmr7y9GPD1ZGqKhRZSXx/EURCmptnV5iUg7rt + DZTnUaKSyoJBNpx0SvmYggC2HXmVZlbJdiuDKdheygBkBm5U4WSCY4owhXoEVx3+VWN025gdCFeqGbfq + 61w7fI3p1V/ggFe500y5Mu6YeMVxhKEoDW4AXg5gX7a5b5m0p4tbsPNpX8kA/LMI2meh4GmP3lxT7Z1z + cPgUdyswPThitn4JzxEh3GC1eoMlr7OxJNyi7pxtRpyvm2Xn4GJ2WmzP3A4MKU9dLNf8mnHBxUxUYv65 + jOozlzMDhS24X4beQCrFyHJkDJVS4kAJsRe63tGo0KIEelJ5/6nNX1Sw/wj4J6TT/4/4nDY/PPsBALbp + lOTXs3t3Xs4EFKxJYCHdGP4iwhnEKeh+IF4z4m3B1h2L81P6eo9TP2JUjRi7CWPbp6oO0HpC8MnWSRhh + Nk4EHzKtF8l3f2mMxR3V3CJ3Dds7ScqcK00HyubP5hzm5PKrqlLtKvsK+wZTwVUVXiY4JkhVoQegNxX3 + UuToFePFKyPujK5yw73O3uSXqQ6+wUxe5lo3Yr9fM3Fr/ODFVTTqkqWVFCXkLKV1WTIDyuhyi/rNu64T + rIWIEvd6uLOmdhfMrzRUVypmkxtp3DoO6Pga0wevMTm/zlnoWPo9GpmiUiG53MIER3I/ctmz0fDb0uoT + 4zZTsl17btJa0ngsDk4m29GeweWafxfVyfAykxRcleC/BLDWCF2C/rYWCUSMrAbggORwAAApZUlEQVR1 + ufnXk07+t0kb/5+w1fP/mYh7/DTryxAAIF3tJ6TJQEFdlOPzBp+wG7OYe0cBdJVFesfAaUA359hqQz97 + QpCKVUhqr246pbpyg+rKTcbzA8bVGG9jvO2hto/ZjGzvmTrIltv7g5V3QpkNdFNS80l8FgYYgEQZE6Ae + 0WrbgzJlF9li3mAiMFUYGeYd+ArnKuqrHl4VqleFw5dqXrw95q3DI16uX2ff/RLif4U4e5ORXGMSoYob + xC5AemBUpt9sE6uAyPay7u6J9GkBMQ12wBAMOsNCMmTt9ju0CtQTY3pYIbM9Kj8Hu4XMa0ajAybxKtPN + CLrARib0zImMcaxTiBHNVltsN3EWQJVB6msnMJVxn5c0JjRL5VMpqQZn551XU07//MfAUi5Q7hLgIqm/ + 1EDoIr1CIGRl3/IYww+Xk/+7wG+TNv/bpIDwc5/1/6j1ZQkAsB0PJofndPUj8A3SdOBTlmO6G3c7MqNI + Yd1jY0l7rss303wMtxtcWDOSObP5mGk1wcsRYtdAryHs51/jCmY1jdGUgvnNN16p73NjqlhtDbOlVOgn + kRDJJ0pGrQ39wXwTmhKrSDdXemdUe8LRy479N2tmr+5x9MIBL1054OXZi9x0bzHmF+n96zST60g9IbhA + Y8rGlAl94kmYpM6/dfmGTta2pQ0o4nZ3Tfq3wisuTDx1SIioGqGOtPuBMBPcZMR4DlYZtauo3Bipp4w2 + E0YPK/xI8UAXRqxkRnBTalmQ9ZRw5nCa1PhdRuUl0FCZRhSQVUH5MQi6JhDmToq/29Ez94mXVOjPO9FO + ZHuod4K2ELskAGJq28e6rGNWDDzfJtX8v8OfEcrvs6wvUwCAtCWekjKBHgYdpl8GblMUhbbLLn3WAscI + F2zTwaK9MuthtUD7lj5WrG974sGUUXVEbSu8aB6neUolksR/q2wgnOtol3EAZDx6gQf4fGNmfGmx7Uqn + XP5cUu8gOUUZrlGISj/uaV7oiFPl6I7y2ps1r756wLVrI+bTQ+bVS+z5N/H2OsJtnD/ETWt0rGy8cm7C + eagZm2MmqZhReoLF3PxL8MEBEmsFDF/KgQKftWGDuJh6HAo0Y2O1F2nUYfWE0WiM98IITyUjoKbyFX5i + dHND10LoRvQ6J+gc3BSVNjUFLeJMcU7wleIrS9ycPE0pG6908C2br1huzqaeRe5tZAhw0m6wy8hJSeqM + 2SOIQTcgm7YQUk+pC0Kvgg5ssEuSweVQ+hbp1C9p/xdi88OXLwDAtjHYsZ3BFMOqO6QBeQnPl5GjAVhh + rAdsy/ara4VuA9YQa9C5EPcq1K9SZ5o0xhLmULD9WWFG1WW6r8tKwJmSportVitbtkvS5BsUg0rrWlCT + JBHWJ6SjSaQ/isQrHfVN5frrxluvT/jlm9e5OakQvUXbf41G36CNLxBsinhF645YK22lrDAuIhzimGYZ + biUQNDEdhZg3Q75kslMrDxdKc5ONQRrbYnoDVrWwnAqbWIHUjPN4c4RQRUH6JJai+4Z7QZkIHC48fTem + jXsghxkMtErgGkmTEq0i5pUUevOhrzun+q6yT5ZPt6z9t8v4U5evMRn1k5u3ihtEP9Jrz/DkmMk/AXqF + TqFDcwEA+RcX+64y5/8n/IwFPX8W68sYACBt+FOS25Cw9RT6FZKWQLEKgN0gsLvhP7l6YGnw1OAa2BpU + lSgLIlNMlhhtlgLLDymJrjJo5w21fkpdk6ZA3kaxdPo9xU+wGIWUGXUiE5EUfSNEJ4S5I4xhtB+5cify + ysvCmy/s8cZ8xBXZZ9O9yEl8hcZeILCfEgzXYK5PoqUl9mQlnHT/p3TeLnX/y4UqwW2LChjs1LBh85cT + sjW4qITlxNNmvMMkM+wqS6IjOEPmEbkN85lx+1CZPzXOFyMu2gPWETqbJskzWWByQZBAY5HWjF4NFaHK + 09ZBAnGQ7ZYBpWl5eiCDy3NWA86KnlLYmtkCzXLjr8QTTDK2R5KKUUzKP2tr2dAT6M1gDXIX5Nukjf9N + EnDtmC/Q5ocvbwCArYXyd0h4gQtSSRBIhiMHbKFvu5mA/NBH7ElTqTXQgUXD6LAB9BF2HqLk80VIImec + LltyF6fbLCRBSJh1IHkK+JD+dHk6NGj4bRODMHJ0VwSrjdk149Zt5bVrjldGe9wIFbVeoQkvEPUQ1Roj + ECWkQEWkFpiIMBUYZ45BedafpNWUYzAdniUwpDXM5EsADWn8F3poonAhjlUttJK6+KMCr9Wc/0wNmQnj + a7DfGbdugn/saU8mnF1UnLb7LLsNXTgDe4JhbOIFxx08bY2Vllo/IzJzPyWRMXPPgio9bwfpJIciHpAE + PvJrKP0aS2AgKsmCzbnECbYN3j2EXmlCy8pWbOg00K0gfAh8E+T/Y6vke87nNOr7UevLHAAgXfAzEsoq + z+NoSFv4dZLY6JhPtGx/6CrIr54B4WmqeUMV1dcdyKyxPRllJwsoZHlHrktzo3DXlrvs9IJSKzDXDBFW + EeJI6CYOv69Mbkau3TBemDmu64S9dk7fXyHYIb1NMpKvw6wH6/EkcdQ9J+w7mDujzmd+tHKn/uDLIgWG + e2nYQipxyuAjkOSxorAxYeOFPodbr4aqkS0V8CPwY2MyhQMRrt3wHF6dIk9nLM+F05WyXLf0mxmuM6zb + sGw77sbAB055IBkzOFB0bdBilTKRKdODzMCUIiCLZCs1hp7LFluU9SIrkveCFoIQWC9oJ2gryepbOwts + FtC9B83vQfjHYP+MhO2/YDdifoHWlz0AlLUmqQq1pIBwRoJd/hKpOTj6zI8UYFB5LkQvn3DzSpu47Vkg + 34YEY4vsG0A/QiaulLl/oRAUvPoPSU6GQ9lQ79BacDOh3ofpnjEfCbO2orYRwSaojTFL40mxOCT0DhiL + MRdjT2AqCcFQjCqHaqgEo93R3yUbs+EfGaYcSZiZXlMJ0CADK97DoL9fXMeqEUzmxnwPDmvHtaMx1/fG + TA5G9KeO9bnRLDfokgTjvjjjXFdc9xsmznAu8rE6ljj6KvdZ86DCmSQvxpyCmVhyXcpljFjMQMst3K8g + DQskmPJekVx/aDO3ZA2hhRjNDF1B9z5sfgeafwTdt0E/IpWef6bw3p9kfVUCgAJLUhBYw0DULhXrLbYq + Qz/+kUoQ6Eg22KI5A1hjNAgzhBopqWbJ/CzfWEVGasAuJkHLtHN2pLKB7TTzByHx7dI/pR6YEYj00tPT + EzOZxuPTiZtNAZ0olRNGAmNJQImCVbLiLHwJ8PPJe/gHZQapU26WAkkw6E3oY/o8ZiizkOvqClwNozHM + ZnA4MY5GwsF4xFxmjGUK3rNfBawS8Gucn2AyZqMjpn2L65TYp15A46CrMvBnx3fBXOJrpNwg9/pz8JXy + hux07y3zNQblckmITWs88cII59AtjPUqsOma0Fu7VLoPof8mdL8N3Tch3oPNnwml90+zvioBoKwykzVS + EDgndWX/PElY5JAfFwTKaHDD0AugMnClF7AGO0SYIFIPXWQygk0GcZAM7RVJ+fKATtqCWLa/8PLMffhM + wQVDOkNb6DrY+MiF9UxFaN2KztYYU7xVVPgBsafDfwz9/cSiTSel2q7+XxE83Rmbkam1l4hL22epAr0I + nUGI6eQsjuoppQYZgZ/CaALziXFUw1UH+zjqukbGIxg7/AgYJyIRzkPlmVeOFw2sM9pWOTdYILQuZQHm + 8rAgqyvtmrcMYp/C5dFfadR4l+KvF1yVs5pG0HOPnkD/VFmf9Sw36+ZCl08blu9HVt+C5nch/D7YPXj4 + hd/88NULAJA2/kPS9j0ldWaXpIzgayTR0Yzn/QFLSaX+hq3X49Qw16GscbrOwJl8fIjuMP8kp8872vMq + GeWnOzXpjqvnls9K4bPvolQlgHSCNY7QCo031tazMuhZE2hy3a84q3Dm0mmsgTbCJiobD62DiYORpHIk + iOXZdkqXZfD92p6UYrvlQPr6NndILgi9CTGABUvSWYCO08lfyU4JUAt7PpcjZvgYUhexd2mcYFlAZWYw + MqSGvSC8tBEWDTxQ47FTLlzSBYgiqQxQQV3RbCyXNZdnlujYBUQkpebJJiIm6XnTGSwFPXGEJ0ZzEuLF + ql0v4sWjtS3+pGP5e8bmn0F4G+LHYO3nfZN/1vVVDACQtvAJW8bGmm028CaJQ7BP6g1cDgTGpQBgIU/9 + fUSlJYYWIQyQVCPJVhU2mu1k9lZuTPPpJJLcwh5Qgen0kUxsIePyLW/SlNM7CIIESS5Cmk7aoJc/ouUY + Y6lM0A6axljWcO6NmUs9gdQ4l+SInNUK5VNlQIFJlNO/zNm3XzUTojqiCjHbe1nMKHlJAYAeiqFwUfmt + zRDrsdigvWGdhzbiQpeuaxWTloIZ7AuTC+FaK9wBbpnjzAuNS34BamDO5TpeigFQCqRRstcgQFJ3TlwD + GQbEsVPChaFLxZaeuDDrln2z3myerMLFvQ2rP+7YfNdovg3dn4A+TvfTOzwr66saACC99SuSG/GKxCX4 + CPhVEnLwDRKP4FMQ4ks9gJj7XpUSs+CeWERIKb1pSMIWVmSo06lTzEO3DJpqQPtlRMt2gljsxwYDz3zK + ulTdO++o68i88uz5imlQKh0TwxjTEUErggqqieunFrEm0lTGRW2c1zCvjZkoNZb8O0mNL9ktS/IFMNHd + v2XKbJ5YmGFR0OCIEfooRE0AJsuaApasFZA1hBrCGOI49QkCSrAuQZxjj3UVrgcfe7yFdF3F0p07FdyB + Y945biDc7hwPqTgWz0ZSn0HFJQ8GSSWHVPna9UnIM2l/uhwhGYhMGpRuabRPI+EUdKPETvu23Txc6/I7 + Gy6+1dN824jvAvfAzuFxSAnls7O+ygEA0p29IbmwlAzgmO2U4C0Sj2CP3WsVGUaBiXEGWqyvTInFSlyT + WGXS/C8Y3yLqUU7OMuLbEa8sm6500wrGvuSpWdEmVhArYzSH8Qz2x8KVynMYR0xtjOoUiWOiVnTq0s7L + KB3rldA5Nh0sFRYY+xgzNLmXkwuVXbWcIRnaSoRfahJqSjWsF2JvSSFXk3hnGr3J1mojQGyha6HpE9By + AzQYnoCzSIwRQo31DgkBL3HL1zCDEcjcMW0dV4LjGo794KmKFyCl9k9gH+eBsaZLXZqFGfRjIikIdAnD + 0K+E9tjYPFHtFjFor+tI/6DV1dsbu/jdnub3jPjHII/Btwnq/+ytr3oAKKtMCT4klQRnpD7BfRKZ6Gsk + D4J0vXbL3l1U7FBI7qTGRdxDC5lnpwG4630NFD3AAZ4HFKvwoo2bSoZkQa61YTNFDozJnnIwhiteOHKe + Wmo6asQqVB1qKTh5SsPRUBV6ExqTNBbJe6Aw/Hdf5CdbkZcpwTlYxazC3Ap9B33MPYAMbS7jdshgO03f + s1FY27alMsaoLGEsUM39UU06CcWjQDQ5QU1gNIW9Ney1wkQTiXkw+tzh+Rt5/l/ZFpLdSyqhTBCXTv5w + rjQnkeY0xnYRL/qmexRi916gfbtn852o3R8Z8SOwY3Bt0vR4NtfzAHB5FWOGcxJV8yEpI1iRsoGbwIQi + d1cyc9hGgUFIfoD+7WD/M7/fkkFIyuR3SCgGotm08pPlAGQWnk+JgXOJkzCL+H2YzozDkXIF4dA7xHuW + zuMK590MJ4onIi4iTpJgsaRKP1K69AXeO7yo4f+XXQE+EQDyQFU7R98KXefoYtL7ixmRV4yBy+MX8GML + NLJlbqVyYZuOZ2O/1Ii0mDufMbs6O3wNoyoNCuqe7eQlE/OGpukAtgDJkGwzwTqHtsBG0YtIc9Lr5mnX + tcuwDH1/L9C93Un7zaDtt4K176vFY6BNWO3/9/O+Z/9U63kA+PQKpAygyLosSEHgY1Im8CKOK1TMSZM1 + n4LAJfB5eqQhtS86JXnzD1LAu9/HTgZB+v5dd6DyrwZmLqHenOFqYzw29sZpjHZowlwcQTwuC30KDieW + DcYtzfuzpoDbOZl3P/IT45Pn/vb/5bnqAFq04JIzTnB0UehMCAKaAQZFFa08gGbrhNTL2IIyUlyUAf6c + +Dy5FCrGBpI5FpXhKqg9jJxRuQxizokWzpIdu+XT38BCnuu3HltV6EKIK8XWgbBo++a0OWkW3YOu6e9F + wvsq/duR7ttR+nfUwqnxf38hUX0/zXoeAH7wMtJkoGQD90lw4m/g+CVGvMWEl5hyxIhJsqXziFUZAFSk + tBLcbTsvL9kBadTk8hFlpLvVFVOQrXFI2n8ulxrJvCIixDwPHDk48Mb1Gq7XcBQdE1dxQU3C9lWICBVG + ZUaVT0fnBV9DVRsTb0wkyZmUQ9J+yGWxS59nmLNZEiyNRoyOViVhIiUp9RZMZIIgyYBE9FXqfY48jF0e + C26jC4Oel5L1twupswSANGLN0AAql+p8yZd1APOUyx8FawQLgrYOXXt04YlnYnEZLa77db9pH3frzbtt + 132v1/6daP33zcV7avFjMz03+7++NJsfngeAH7WU0peCM4THTHnINZ7wIgtuEzjkDUbUSevaI4wQSwEg + 0V7cZQrtkJomBlwhpgxEH9kpkp1yKWfOGHs1IZijzy6XYxc5quBmDTdHcNgLlTiiVfRWo+aT87Fo1ivK + jsCV4McwHcNhZRyJMTeoP3nKD3/blQXfhR+mACAqaBQ6FRpxbLzQuSTFVeJYeTma8fZ+BOMaDio48Ene + eVRKqpJVFRt1gyQPnj+IGWNh22flUqefKrVTStckaSgkJJ9dOMIK4oUSLtTisuvj0i7iuj/VtrsfQv9B + F/vvBe3+KEr3YbTwyNSW6T6QLxST72exngeAH78S9q/mMa+z5uuseJnIIXvMuMqIQ0Rq0Sqh/5ggpY9u + MOxgK7PyfNNmVyAGokq1/V4hBYAME05iFSkLCAgdjpDT+n2vvFDBSyPjVi0cqEOlorOaVmuUilqSek6t + glkqD6SGaqrsTSPXauWaKAckUOPWOS+JlhQwUHlywvZYLQONwv/vTVg7YV05+pz0VEUINWc/mnkA9QTm + E7g6gusuwTDHJebZthQQte31K1xjKc3AnXeq+HaMMoQ3klibjUup/nlNOHP0Z5Fu0dNftH3c9I+10/eJ + 9iem4XuGvofxkaFPDD03ietofcCe7Vr/h63nAeCzrg7juyz5Db7PFW6KciIdfbGnTpihGcgcy/ihrWPW + TmOtiFQM9tQ7DavcC7DCZnEuYQPyGK40/3pzROeYOeWKE+54eNEZ1wXG4riQMY1MaKXGxOENvElGAXqC + OKwyqjoyq5VDrxyZMcuow1KHD+Ak251WlEFefs75hJYSABRakoxnyACckvYX1x3NHIDxBI5GcL2Ca5KQ + VzWptUZrWGvQK6opEKWPJE4y4IpDCixeUglQqVCFRADSNhF2bGnomRLPooazGMN5H7rletM1qyca2vcw + /bZ3/lvOu7dF+FjErUQliomKiX1ZNz88DwA/+XqT4By4hrFfMXdKLa5OG1/2Sdr6JQDoVoeuzNGMEhUy + yjcp7uAkg4Myxt47TKqtv4BL1FQVT3QOvDD3cNvBK2a8EJVZTP4EG5nS+BmxHiMmaUNFoVNP6xytgIgy + FWWEMhFjbEpFhgDvKP0M4B12hE52G5gwMAAtGhqVGJUQK6L5JGKSPfdiZfQjRUfGaJxkFg9rOPJwINnc + QcE2hp4ZehZgY4gakmGDVW/4IvAZgTal+LV3TESYbKBeC9IKoTHCSgnnge5cY1yy0rWdxE33JLTr+zE0 + d6F/1yF/Iow+cDK67+rq4vTi73xh2Xs/6/U8APwk6zfxErkmyh1v3PIVR06rSmQfk0NMDokyR6hT6qwl + RXX5sCxAn2JWmQEyKOICRUR0YKRJlTUrXHa0rVCf4L5jB9dH8Ko33sS4FZRxJ4TgaW1C52eoH2XxCuj7 + 1JXfVNCjVKaEqMRgBGcEgVq2jb0Um4Y23xY3PzT/ZBvYykfUJAYS0jxdoyNqnX7WGx2RbgIyikzGxrQW + 9jzMJMEtfX4IXQvxVNHTiG0UJzFZ8FpELBl4+Ah0Ao3DgieoEDqwE0Ue9bAU+sY0NEE3y6ZrV+1C2/DA + YvzANLyr2r0L8UOPfOyonwJLQVrnqq/M5ofnAeCzr/8DR88Rkdcl8jUXue3Fz8TtI1wHuW7m9gRGmPgB + Y55KZRuwc0MxIG6Hc1/6A4Us5PLJmS3DxGWlcE+UNHfcc8qtsfLGyHijUl5AGUfHKjhCHKE6Bq0wtQTJ + VaFT6MUIEYhG1xvrkCS7LnK14cUyaZYsIlLGESRY8CUhkO2cUnIz0FQTyq+v6IMl4J451Ct9lbx+fCb1 + pdEdRUw9PZKCdZI69GuwPiKjHvE9zivOG640VHsHsWLTjXiyER6c9zx91LD5qAvhLG5ix3kfw6Jr27O2 + 756ohrsQ3wV9F+IHAo+E6gLqfiRze9z+92nw+xVazwPAZ13GGOE28BbGG8A1oa5EriDcRuQGyQp3qyJb + 3Ge2PgC6Axt0OxRVTRvfdg4fKcJ2KStQg4jDC8y9cWekvDlV3ppFXp4oe/WWIGS9QzqHtY7YK8GMIMlm + zOeKgh7aKCxVOI3JUXDslLmkFFvNknbJrjvRLv2X8vlOuUDyEAwqdDHQayDGKtMaim120dkVdh55+7JJ + jUrTRNYR0wEAJLZFMaJpnr9p4f658PYT+M6D3j54cNGePF6cdhftxzHaBybcM+Uxpk8Y0J36OBnE2Sbw + Dy0Aqy9df/+zrecB4LOujjHGHYyvkxiDV4yxc1xB5AVEriGMKbDY4fZ2O5s/u9VKAQMNOnpuB/+ffp1k + /TorvHsVqs6YO+XO1PjGzPgLh8Zb+3B1IsmFOGuI+h58K0iXNkk0I2aGYWXgoxCiEFRYmWOhwqEIRxIR + kjRYIJFzSvNx97kNTOWdYJAcdpVoaaP3RHoLxKyQlORRc/mwG1NyE7XAo0wc3rukUjKVBPqTgLbKuumR + GJIddxQ26xgfnbXhnacW//Ah3fcerNd3j5fHi9Xp3dBv3hX0j4Xq+476EdRnUC3ArUiKvRH+4ed9V33u + 63kA+Czr7+OIHAGvAb8IvA7Vodi+Sxv/BsKhbOUFi7gEueS3QUhTzOWpwBZHnDwDZOALUGrtzGjDDN8Z + s7Xyoii/Ojb++Tn82hV4eU+o62IrngRHJGuJSqa8qiPN4w28Sta9FKI5OjU6SyM7NXAZLWiSUu1oeQRo + pV8hQyAoTsVKesnBJGUbln4uomhWQ7KipZe9A3dBk2Ve73JfwXvF1eCnHgmevvUsT5TTexvWZw0hQGMu + PG2bxUeLzckH5xx/eMbTh2fd49PlxYMuNPeM5q5g94T4RGAhVG26MlOF/+3zvqO+MOt5APhx6+8jpBH1 + qyQ+wJvgb8BBhVxHuI7IIQnGUrEFtcqw+besv8tJM3AZcTPYT8tArVU1JEC9Ug7OIy/6wNcPIr9SG1+b + wv5o18arAnE4SRYlLqsPOw+VEzyG14RMtloQ76h96qCPnFC5iBeyR6BSZx9DFYagNTz3oSpIGgVqjh6l + t8QrMDwiDl8UedzWNNSbDG2PTCAkWpo4xD4SNj26CsjaY31li0WrH9+90I++s4iLh5vY9dZeOLe41/cP + 31+fff9B035/2endLnAvhnjfLD51yEJgnSBAGiP/z1equfdZ1/MA8KPWbwLKPsKbJE+Bt0CuC7PKcQPH + HURumJCbfwOVtzTLyLjUwphji2zbCQqFrINLjDRIyDrrDXqQBupzmC6NvVFg1jT4riWGjj5GxHm8nyD1 + DFdPqOox1bimFk8tQp2mhgkda2AjQ2Yem2YK8chx5IS5KBWJc1+hOFHGPmbJsE/k/6WhqRBF2UgyxujF + UCc4X1HLGFyVsh4P3qXyaBSFUbYa7HtlvQxYCLimpztp2Xy4ZvNhQ3dmfdP71clFt7j7/pPlR+8fL5pH + 6wsfOW8qOfkw6qN3++bek7i4p+j9Mf5xhT/z+OaAl/Rt/vfP+w76wq/nAeBHrQRhv47wywi/Dnwdc/uw + B3Ib4WWEm6Tm35bwQ3GIzY23LEqXLai2bS/LGyIZW8p2b8U0C2cJLAQuBFkLXqPpobJoN9xbnhJPz9mL + DdPRSA7HV5kzpbj4mo8wCjinVBIxSxmAc4aOwEbJU29GcjTco7gaboE+KUN3+E8X/5kAlMw/tVG6Vln3 + yiYmBSLB48XlDCEd/XVIIiBeDVvDygxpetbLhumioTrb0D9a2/LukpO7F93pWXd22sd7T9ru7r3jxf2T + p8tH44YnV5k8dSanwTjvzJYtcQlx6bGNx8I9vvl53znPzHoeAH7Y+jsIyr44XgN+BeFXEPey2HwidgPR + 28AtMw5BCoK+UICLd/324STP0rey32w5AT53tTVxY20JdizoI4hPJbqVtCqy0UO36vatOdM+fLReyenJ + Uz9qzup5LdOb48X8hmdadeNqsR5x3kRWVtO5SCzqQoB6GyYKEip04+lqYZVP6JpPOgPzaUKggUTDRUN7 + 2GyM05XxeA2nLawDdCaYpTJASks0TyB6wzZKPO5iYNX147NNe7Bo+sNl29bH62758bK/f+/84t7J6vHD + dvPhQ23ffxSae00ID65Vk6fzqj4+cG49iy5MVHSCtwBaIfaQb33ed84ztZ4HgB+0/mccxhHwdRH+shP+ + vDj/Ku5gLnYHr68j8iJmR6KMM4CnnJK7uP7kaMug6ed2xD5yN8DnSYEKrEHPkqC03hXiR6LhiVy4ngeT + Q/swinxgt+RRdLZaxd4tlqvp8uzkqA+bO1f909dv18vX9tlc0bCu1vEFVoxpJXnWp2ojTxa8YM7jpUbF + o05YOBi7rRVmQSiKpFJALhmepIDl1LAAbS8sW8ei81wEodWtsYhkJSNRwTUOFp5mKeFsZYvTVTher9rT + atWf3DY9fsPp0xttf9Yv+qZZdJvl2WZ51q6enNI8OqN72nvOp6Nq3U1i9zd+8RX9xm//t5fetuXnfd88 + g+t5APjk+k2EyB7CWyL8CyL8unfyNedneyJ3gLcQeQPsBmrjfDh+kilXk2r+1OWS3djATqMv+8wZYI2h + x0K8C+FdiO+j8WPWupD7At/uGvu9cEW+bcF9WFVu6Rz+rNG99043Nx6dn3xtpvqrL47PL14YNa9MXL8v + XIjJTCLBlGhD30GyBlmoPKH2K63cGUglWFHH3f5f8dLhpMeVbv4O8CdFNrEQvfU6ip3WGtRl9cPMV04U + QJEg5he16ONRv3joLh48jQ/vnXf3jtf9x5Xa/fP96uP59fG9o6k8rWq38ZWLzok6cZ3HtV5c16FhYb3+ + g5O/xT/47c/7RvlyrOcBYHf9PTzKIcLXBH7def6K9/5XnN+/6eR2Je5NsDfA3QKbp/v/kt3bzmzLtvr5 + A2ttxzZelCRH1YCuIJ5AvA/x+4T4fRp9wKme8X0i3zPh9+NG/rDf8M56XT39T3/jv4gA/+7f/Yv+4Xn/ + 4N7TcDxWPQuTxcMwfXrnsL6+N3Zz56XFLGJ5op93bVLo6CpPV1cWvFMVMbEdGFLm7EvESYuXNgeArVhY + frz8vZUqE1UbRcHbVk1oYCEhvaNajgkn47B65C/OHobjJ6ftg4fr/lHl5fFenDw5O/DH/dFk+W/+o78Z + Af7eX/sfuHbzJv/if/4vbXuQXzh3vWd7PQ8AZf19hMSI/XMi/Lpz/NWqkl9zfu8l516aCl8DexPsNthe + buYVM49S++9oRQzCnzCk/Lu4+Q5Ygh5DfGiEjyHco9WHnOgpH9uKd4h8l6Q2+Y4ZD2KUxf61MGyB//pf + /734a//ZwbINfN8pixB5L6jtR9VaRUUsCkQzizt1vBVtcCE6p1FENUuFD08+RSkVxYtiEj8RAGRnipGY + /mrREnhYzMnO1EALoxBRVUxNLWivva5jr6vQ64WprPtobR+tE9lu8X/tf/qNz/uu+NKv5wEAEtCHNO4T + x19y8Fe9d7/q/Pwl525NRd7A7E2wF4G9RM4ZNn/u/JcB/w6uPzXU04aTQDrxlYQ3vzD0SSTex8JdYvjY + reITHuk579PxNsZ3SfbmdzGe9i3NO7/779g7v3v5qX/rP17oG3+T1VTYTEY8HFfO1VUllatwUu/YfJWV + n29VYbHCSzW4kZtc7vYL4CU9jpMdiPPwOCkAmFWoVagNol+50iCXAIY4h/MVVnncyFs1wepJ1HHyU7fx + 2Jn3wr/xW3/j874bvlJL/vQP8YyvtPmvAG8J/LoX/qoT/xe8P3jJuRenIm8IvInZSyQ8UJV0/61P2PRh + 9DfgWhMqz0nW1TekB1kBK0FWgi2MeBw0PAhduG+b+NCdx+Pqvq3cHxPkD8C+S1Iofpp/soO//nlfqefr + S7i+uhnAbwHgMQ4w3iI1/P6Kc/JrlZ++7OTWFHmTBPu/A7K/c7mG1PcTsBgpqhckNUyQDlgZdm5watiZ + RDvRLj6Jq/AwHIen+iQuqgc0/gOU7wB/SNr8S4aK9/nmf75+PuurGQD+FxzGDOEWxi9g/EXgL4n4XxS3 + f0fc7YlIavgZd4BDZAD6KOIszbdLnW95zq+CBQeNgxXIUuFMsTNFT6PFhTYsOLFzva+n8X48Dff1gof0 + 9hDjY5JL0T2QBfz1L5X45PP1xVxfnQDw31SgKozVYxwCryH8Ko6/jPErIK+Z7F2DlybwNTHeALmD2SFJ + 7itJeSXUrhtMQQYPv0gC8WwUW5jJMdgj4KGZnmgMF+Gi34SH1ui7tuF7bOw9bfSe9fKUZFK6zOn+hkvd + xOfr+fr5rWc/APxW/rPAzSAf1AJRTDaV0Fplnc4w2yfIIdHdBv/n8NU/h/i/gFSvwmwPe8GpvEHkTRy3 + MUkov1TfZ9kutaQPuzKksa1kdRuwRQ+L2Nu5reXEreyRX8tjWcdzXYUunEQN9zTou/TyxwQ+xOwRyAWD + y2AR5X6e8j9ffzbr2Q4AvzV8th09pz8TqzU6SVrdHCH2IvAauBexyYvI9DX8/Ov4vVeQwzlcF4svoPEO + Fm4A+0ljuoz3fB7g94acKzxUOLMsU6+waJUnFxtONies4n021T1ZTu7LcvTYOnca0TNzdopyTJCnKKfA + BdDDf/CcqfZ8fS7r2Q4AZVq1o0uR9LOoiDJBmYFdpeIVxH0Dcb/EaPQ6k/0X8AeH6NVD9PoUuS3YLSxc + JXZ7SFclNYzYFBxvIso7Aq30PLWOB9pzKkoQodPIcdvw8fKY48XHdOF9bPQeOv9A4t59ZHJiFSsTCamB + 4CxJ2+jzVP/5+lzXsx0AYHeQafwrIH/bmanzKAeY3UZ4g0q+wWT85xlN/hzj2W2qwznxyLG+JqxfgHAH + uAG6l+v41lhtepquJ4QsaCMd0Z/T+kes/UMuqmO6eoNJpMNYaM+iW7BqnqD9x6D3oX5oxFOEhu4/NGb/ + JZ9wB/3hJjzP1/P1Z7Ce7QCwW/N7kL81gpXzEmUMHIK+iLdfYFT9EtXkF/CHd/AHe3AobI6Mp1eN431j + U+difg19gIt1x/nqnEVzStd3qEWC27DxD+lG7+Bn7zCdf595fUrl+sR4ASTZUICtwTbJOXbUo9cM/jvY + BHCdDTI5n5YHeb6erz/T9WwHgH8Z+F8xVISVFzpX0VYTereH2h6i+zj2qKqxVCO1xfiCatpjM1jOAo/H + gacE1use7XowpY+BVb/irHvKon9MH9aI9kQ2rNxDmsn7zOQDbo4ecKBLrnrlDKgFXJWbhgZM88dYkn61 + N8wZ8d//vK/a8/V8DevZDgAA/yrI/1hB5yp6N6F1e9L6OVFqzDpMnhL9B9a5NZ0dotSoN1rfs6Bl2TZs + NitCWKFxQ0/DurpgWZ2wdieIXzG2DkJLqwvacIqPC0LcMK0jf/uv/ZAn9u+xIwfEp/Vvn6/n6/Nfz34A + gIS6C+IIUuUPofcNUR4RpGEtjzjjkEWc0YZR6r1pIISWrt/QNku6zZI+XNBVa9r5ms3+Bf3oghENkzbg + LTIioi4mhgzGP/i3fsST+q+A/8Quu+j825/3lXq+nq9L65k/kuQ3x7AUoZeajR+z8RNpqhGdr4muonM1 + S0Z27EZ2PBmxOfLYDfBXFCaBGFv69YZ2taHtN3Sjlvago7kSiAcRd0Vp/6PP+2U+X8/Xz2U9+xnAeqDc + ZiwePbvE/G3mXbSpdoeHRb0zZutnxVTp10bzdz/vV/Z8PV8/9/XsB4Cy0kbXLMeXZHjKh5f0Smuy9a0U + Z1tDMbxXKm9YZXz0f37er+T5er6er+fr+Xq+fv7r/wfu76bCzj4g4QAAAABJRU5ErkJggg== + + + + + AAABAAUAEBAAAAEAIABoBAAAVgAAABgYAAABACAAiAkAAL4EAAAgIAAAAQAgAKgQAABGDgAAMDAAAAEA + IACoJQAA7h4AAAAAAAABACAAXUYBAJZEAAAoAAAAEAAAACAAAAABACAAAAAAAAAEAAATCwAAEwsAAAAA + AAAAAAAAAAAAAAyOAQBolAAAM48AMnKUBZKVgAttkFAWHXGmlQ6Ko5cSi4aDEH47ZASnXHsAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA/wAALs8CAAD/AABLpAprhqAP9pKbLc6qyaHDt+PPyrnMtMeqqsqibVVwV24g + BBF8RSgAUAAAAAAAAAAAAAAAAAAAAAABAAAAAAAkCy8FqG2SFv2QnyD/qMN//8X13v/H38b/r6+7/3Ni + W/ltQi64ShAYM+1FXAAAAAAAAAAAAAEPAAAAAgAkJlAiwm6ER/+HjiL/iIIg/11yUf+f19f/rbPJ/3lb + Z/9lQ0X/ZT5C/zcQG9MAAAAzAQAAAAAAAAAAAAAJDDAKo3mpa/+emVf/hoMl/4GNX/9lkdn/aZXy/2qP + 6/9ojd7/Zl+e/1svVP88Hy7/EwkKuAAAABUCEQQAAAkCRiE0FPJudzf/gncw/39xNf9xg6z/Z4X4/2aA + 9f9mgfX/Z4r3/2eE5/9EN2v/Tm0m/2JUFfklBQ1t////AB5dMI+EkXb/e2c6/3pkN/9pOkv/WESO/4F5 + xP9tYs3/Xky9/11Sp/+Fca//TDJU/19/H/9jZB//PR0SwwAAAAo2flC5o6Gd/3hZQP90Vj//ZUE9/2Fu + b/+gmav/cV+6/1pCm/9XWnH/lpaj/1AvTv9WdyH/bG8g/z8jEPEFDgMUI0Eqx3l7af+JaV3/dFJL/25O + RP9oWWf/XliG/1900P9gZ7z/Y2R7/32Zvv9vbJz/V29A/3mBFf8yFQ77hsWFlaGjg/C1t5H/yruc/7KT + g/+Pamj/fVpm/3J3o/92j87/iJ+3/6azpP+vwZ//ss6f/7i/uf9eO0b/CAAB7WvOe0ypxJPMx72b/8q0 + l//FrJL/xrqa/8jAm//M163/0eK5/9ntuv/Z4K//zseb/7+se/+6y5f/hFhz/wEAALkrHCYAIUUlQEBP + P+2dmZr/lmOG/3hVcf+rvZr/2t+w/9LLov/S1qb/2uWz/9LFov+8oYj/pJN7/00qN/UAAABfAAAAAAAA + AAUCCguSVXt5/7LI0P+OVJX/cGJ6/8bYqf/Vy6T/zLiX/7OJif+HeX3/qsy4/6eGkP8uCAyoAAAADgAA + AAAAAAAAAAAAGQcMEK5BWV/+i2yh/2Qobf+Eg4D/yMii/9C6mv+vgon/pMvD/7K2w/9tNVPAEAAAJSMD + CQAAAAAAAAAAAAAAAAAAAAAXAQIHiS4ORudQEmj+Uxdp/1xIXf+LlHD/vKSW/5p9oO1kK1iZIgAMIUkF + JwAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAUMAxs5JgY7iSkFOL4PABHTEysWw3teXLtMBi1NAAAABwoA + BAAAAAAAAAAAAOAfAADwBwAA4AMAAMABAACAAAAAgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAIAA + AADAAQAA4AMAAPAHAAAoAAAAGAAAADAAAAABACAAAAAAAAAJAAATCwAAEwsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAADogBAACKAgUzigBXcoICh5VzBVSMPAggjgABAooIAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACJgBAP//AAAbowAaUKoGlYil + DPKXjg/Ul2MNeHChijqWtZRSoL+vVJi4sVSkm4pOnHGZLGQVZAr/4f8AGgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANogQAAKMCF1KlDsiSpxP/lJsT+5C+f/G9zaj7vu7T/LXk + 2/zCy6T6u8HU5np3vbVoOjFjaxYQFq1YPAA/AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALAAAAaCRqC+SIoBn/kJsV/5K0Q/+90Z7/xfTW/7zy6v/H1K3/ytrY/4WPyP90Xjn6ckQswmEa + IEgUAAACOwACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEBBwCSECQJ90VzFv+Klx7/jZYc/4eJ + KP+Pr3b/xfXa/8358f/IyLj/ro+E/3VaYP9rUTz/bFA+/18pLegfAARiAAAAAwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACgASAJExbCX8lLN8/5mQN/+JjCL/io0h/3RRH/8qVkb/h83J/7PU6v+ejbb/aExc/2M9 + R/9iPUX/Yj9H/14tPf8dAgrtAAAAWwAAAAAAAAAAAAAAAAAAAAAAKAEAAAAAZiBeGvec2Z7/r6h8/4qF + J/+GhSf/h4ou/3aUoP9imej/aZry/2qX9P9okej/aJXm/2l4vf9iPG3/XS9O/10tTf8wDR3/AwEC3AAA + ADEAAAAAAAAAAAAAAAAAAAAjAAwA1UWFOv+hn23/iXww/4J8LP+Efin/gY1j/3CZ8f9qjvr/Z4f2/2iG + 9v9nhO7/aZT5/2yi/v9rf9z/WSxn/z0sQP9ARzL/PSkc/xMCB6AAAAAIAAAAAAEZAwAABwF1FyMN/jtK + Gv9xcy7/f3My/4B1Mf9+bDb/b4Ko/2qK+f9mgvX/Zn/1/2Z89P9lgfb/Zob3/2eL9f9nju//UD2G/yY5 + NP9oohj/iogP/0cbFukGAAJBAAEAAAAAAA0LRBe9fqOB/4xrSf93azb/fGw3/3xiOP9qKlH/VCh7/15V + pP9xZsn/ZmnW/2Nu6f9hVsz/XUmz/2Zaqf91Spj/SSJc/ylQMv9+mBX/ZHMf/1xCGv8dAAmPAAYBAAAA + ACgnfT7kstfN/5RpWf92ZDr/eV48/2w6N/9XM1H/UkWH/22Xqv/Sr9f/gUGR/1tMxP9WIG3/UTiD/22c + rv/Qt9f/cyRT/zhQMf97iBn/TUwx/1hVG/8oAwvOAAoBAAAAAEE1jlX0vsPL/4paUf9yWkD/dFtC/3RU + Qf9mQjH/W19G/4StnP+mgp3/aGCj/2Nq6P9aPX7/UEdZ/3OXhP+ch5X/UilQ/yQ6Nf9unBr/dXQk/2de + GP8mAwvwAAUAAAAAAE0jUjH4gXd2/35dUf9zUUj/cFFH/3FTSP9vUEP/aV9d/2FXe/9YWID/YXfd/2V4 + 9f9hY8L/WUhi/19off9ohb3/YEuf/ywnPf9KhSD/krIJ/3VTFv8ZAAj6btmEGkteRHE4Pi36YYdb/728 + nP+wkYL/iWFh/3RLT/9rR0n/a01W/2dRl/9ZWIr/W3CZ/2J36/9hbn3/c4CU/5i+0f+y4ej/utfc/66y + wf9/b3P/XmUq/0QjG/8GAAL1ac14rr3JofTKxKD/y8Og/8/DoP/Pw5//y7ea/7SMg/+UcW7/hVdg/3Vh + bf92i8j/eZLZ/4Ge4P+ctrT/tL2n/6+wiv+lrHL/orlx/7Xhp//S3OP/g0Bo/wwABP8AAADcNs1ZNorM + jbnFyqH91Maj/86+nf/Mt5j/yrKV/8u9mP/RxKL/ybWW/8fPoP/P37D/1eq8/9rwvP/d7rj/2uSy/9XV + qP/OxJr/wquB/6mhUv+26Kz/wIOv/xoAB/8AAACkT7hoACfISBdbkl2jjZp2/7eqkP++oJD/souH/6OK + g/+0r5b/yM2g/9rlsv/Y2az/1NOm/9bhrP/c8bn/3uq3/9narv/Sy6P/z76d/8ihhf+syJX/q2+X/xQA + BPMAAABXAAAAAAAGAgAAAwA5BhAJ6UplYv+uprf/klWL/2YoYv9iNmX/hZ+G/9Tos//Y2a3/0sqj/86/ + m//N0qH/2uq0/9vcr//SwZ//vpyH/5+Faf+Xh3L/Shoo/wAAALwAAAAUAAAAAAAAAAAAAAAEAAAAjRcz + Mf+Uz8P/y+Xl/6R/r/9tH2//XEhs/6rTpf/a3K//1M6m/8+/nf/KtZT/xq6X/6R+hv+HZ2//kKaR/7zg + zv+zfIz/MwcK8AAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAGwAAA7wfND3/gbmw/8Pw6P+5b7b/YRtq/3GB + ev/F3Kf/19Gn/9DBnf/LtpX/u22C/2MuYP+AtqL/u/3j/8vN3f+ANVT7GAAChgAAAAUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAACwAAAHDEBQg/05ccv+IVJ3/YSFr/10uYv98hH7/w86j/9PGof/Mt5f/xI+J/5yr + qP/H/ev/vcbU/4VCcfk1BhWUAAAAEAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjAAAAoQwF + HfVEEWD/VxZu/1gVbf9WGWv/Z05w/4+Zfv+/uJP/ya+R/8PNyP+ujrj/cSxj5jMEHXcAAAANDwEEAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAACwIDCVUZBy62OAlV60QLX/xGC2D/MAMz/wkT + DP9Ba0H/rZOD/4ItYeU3BzeaGQASNwAAAAMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAwAAAAAOBwESPhACGXYOAhOfCAEIuQAAALQAEQSSVmlPp4omPWUAAAAEAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA8D//APgAfwD8AB8A+AAHAPAAAwDgAAMA4AABAMAAAADAAAAAgAAAAIAA + AACAAAAAgAAAAAAAAAAAAAAAAAAAAIAAAADAAAAAwAABAOAAAQDwAAMA+AAHAPwADwD/AD8AKAAAACAA + AABAAAAAAQAgAAAAAAAAEAAAEwsAABMLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGnAEAE4ACAAmH + ARQ4ggBndmwAaotYADmELgEVYgAAAnEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGp + AAALkwEAAJIBByWgAE1XogTGjqAI6JaJC8eUYgyHlSsFMaAAAAIMYjcDLGhhBkA+PQYzPjIGQFFIBkU6 + WQUrABEAJgARAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAwAAAOKgNAA+xBjFTrwrSkq0Q/5eiEf+Yewzeg4JMiX3EtZqrupGxrM64sqPQ + zLKluKuxsKaLqamRr3p/R5hBRxhIEgAAAAASAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArQAASpwYABWhCGtspRL8lqYU/5WjEv+Pqzf/odW7/8vL + nP/D9dX/uPnv/7vZy//J057/x9nc/pWU5fBmXonBaioXbmgOExsAAAAAQQADAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAzADECsEyVEv2SoBj/kJwY/46g + Fv+Zyn3/xMqb/8Tzz/+7+u//veTc/8jMnP/N5s7/pLT//3B6kP94Xiv7dEEqyWUZHlhAAAQITgELAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAWgAAANsBKwL/VZMX/5Ca + HP+OmRz/jpgX/4+2Xf/B0pz/yvTX/8L67//D7ef/yc6m/8/Mtf+ejLn/bFxa/3BaNf9xVzn/bDw08k8J + FYUDAAAOFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAGkEFgLtKU4Y/1x3 + LP9/kh7/jZIf/4uSH/+OjB//a00g/1yTWP+19dT/1vvz/9fz8f/Boqf/lmda/29JQv9oSUD/aElA/2dK + QP9pRUH/SxAe+QcAAJMAAAAPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQBgAAAABZBScD7EiX + Mf+p1aP/tp1i/4yLIf+JiyT/h4wj/4x0Hv9LJiD/FlVG/23Fvf+oyeP/psPi/5Fwpf9dS1//Yz5O/2E6 + Rv9iPEf/YTxH/2E9Sf9VGTH/DgAC+gAAAIcAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMgAW + ANo5jyr/qu22/7y5pf+SiCv/h4cn/4eHJ/+HiCX/h5FV/2aYzP9loO7/apzy/2ib9P9ol/P/Zpjs/2ma + 7P9phM3/ZlCJ/18vUv9eMU3/XTNP/14jRv8gAgz/AAAA8QAAAFoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAsAAAClDEgK/4XSgv+9uKb/lYI7/4WAKf+EgSv/hX4q/4SGMf97n7T/bp3//22U+v9pjfj/aY/4/2uG + 9P9nheH/aZv7/26k/v9soPf/aFKq/1snVv9TKk7/SSxE/zYmLf8hDxf/CAADzwAAACIAAAAAAAAAAAAA + AAAAAAAAAAAASwAAAPEQRA7/bohB/4l8Nf+CeSz/gHku/4B5Lv+DfCv/goxg/3KX7v9qjvn/aIb1/2WB + 9P9mgvX/Zn/0/2WG9f9nivb/aZP4/2uh/P9slvf/YDWI/zYlO/8sOzf/UXkp/21bIP83ERb+CQABfP8g + /wAAAAAAAAAAAAAAAAYABACiESgM/zkuE/88XB//enQz/39yM/9/dDL/gHMz/31mN/9sgaL/aY/5/2qI + +P9ngfX/Zn70/2Z98/9levP/ZYD0/2aE9v9nivj/aIz1/2aU8v9bSKH/Jx83/y5nMf+Buwz/lqcG/3ND + Hf8mAQ7OAAAAHwAAAAAAAgAAAAAAJgQ1DN5lqnX/pHVi/3ZqNP97bDf/fG02/31xN/9+WTr/aRtT/1Qf + cv9XQJT/YV2//2Fm1f9kdOP/ZXry/2Vy7v9kaOH/YVzR/2BRuv9iQp//XTGF/0omZf8iITr/OIcp/5Wc + D/9odCD/bXcY/0UOGPUEAABdAAAAAAANAgAAAQBVHXkv+aru1v+3goz/eWQ2/3loO/98ZTv/dlM4/2ku + O/9XMWT/UzeN/1FCgf+FobL/v3nA/3kvif9aZ9D/Xi2t/1cWbf9TF2b/U1B8/5m/w//MjcX/dR5c/zEi + O/9Ajyb/knsU/0Q4Nv9LeR3/Vx8Y/w8AA58AAAAAAUgJAAAOAH8znFL/vPHm/655hf93Wzr/dGE+/3hf + Pv9ySzv/ZTI0/1Y3Qf9RSW7/WHOR/53s2P/uu+r/kDV4/1ls1P9fMab/VDhl/1NUpP9SZJ//i97L/960 + 3v99JUn/PiA1/z2BLP+OjRP/WD82/018Iv9dKRn/EgAE1AAAAAAAAAACABIAmj2pZP/K2uj/pGRt/3VY + Qf9yWUL/c1pD/3VbRP92VUL/Z0Iq/1ldNf91nXv/oK+0/5VXdf9cYI7/Ynvy/2Ve3f9XNGD/Tjc+/110 + Vv+VsJ3/jmZy/1IxXP8iGjb/J2M0/4GuEP+BbCX/a4wZ/2EqF/8QAATuAAAAAAkAAQYADACnL3lH/5yH + mP9/VE7/cVJF/3FUR/9zVEj/cVRH/3JTR/9vUUP/aFpP/2Ffcf9YTV3/Vl+M/2F56f9ld/P/ZHf1/2Fh + x/9aSWH/W1lZ/11ic/9egbr/X0a2/ykVOP8fNzP/WaoX/523B/+Pkwr/WR8a/woAAvgAAQAACwAABgAD + AKYQHA7/N1Uz/4mngv+qf3j/g1dZ/21ISv9tTEn/cU1L/21NSf9uV1P/aVWf/15Blf9WVW3/XXOa/2V6 + 8f9kdt//Xl53/1pGb/9jbaD/gLXr/5rL+P+jpdf/i3+a/2NLZv9FZDL/baES/4FpHv87DRj/AgAA90/K + cEaTvYp3eodo1np8Y/+Hn3H/wdCm/9fRqf/PwKH/s4+G/49dZf9zR1H/aUNL/2lES/9rTl7/aGu5/1xl + rv9aboL/YHft/2F3z/9qh3P/jbW7/7LSzv+/4cv/v+jH/8T01f/O++3/1eLq/7CApf9XO0T/OSAl/xED + Bv8AAADpR81ksrXNofvUz6z/1s2o/9TIpf/QwKD/zLua/8u8mv/OwZz/zbCZ/7SLgf+bfHb/kV5q/3hM + V/9zbHj/epTa/32X6P+CnuX/j7LW/6/Atf+3tJz/rKN//6CbaP+Zl1X/lZ9M/5y/Zv+677//2ez0/61V + if8dAAj/AAAA/wAAAMkMzTMiYs17o7LMn/rTyaX/0cSi/86/nv/Mu5z/y7WY/8iwk//Hr5L/ysSa/9LD + o//Mr5X/w8aZ/8rXpf/S57P/2O+8/9zxvP/f8bj/3u62/9zptv/a3q//1dKn/9DEnP/GrYf/r5ZW/5ix + Q/+9+c//26PV/0oFH/8AAAD+AAAAjRbKUgAAzzgQUsJle5i9iezIxJ7/0MKg/868m//NuJj/y7OX/8es + kv/FyJ//08am/8zAmv/S5Kz/2+Kx/9fbrP/W3ar/2euz/93zuv/e8rv/3uu4/9vgsv/W1Kr/0smi/8+9 + nP/Mr5X/u51m/6zon//brdz/UQcj/wAAAO0AAABKAAAAAAFzDgAAjgAEEj8djTtaO/93gWj/ppCH/6p9 + hv+WYHf/hExs/3hjcP+ZkIf/s8GY/9bps//a37D/19as/9LKo//Qx5//0dqm/9nwt//e7Lj/2+Cy/9fT + qf/RyKD/z7+c/82wlv+6h3D/mMui/7Bhkv8fAAn/AAAAuwAAABMAAAAAAAAAAAAAAAAAAAA1AAAA5A0e + Iv92pqD/v7LL/51fmv9wJ2j/WyJe/1wkYf9nfHL/veqv/9zhsv/X16z/082k/9HCn//LuJb/y9Ge/9js + tf/c47P/2dSq/9K/n//Dm4n/nnho/4uDV/+YeW3/SA8a/wAAAPgAAABhAAAAAAAAAAAAAAAAAAAAAAAA + AAMAAACGAQoL/kSDd/+9+Oj/1Ozs/7Sewv+FM4L/XRtk/1k0Zf+IxZf/1+S1/9jZrf/Uz6f/0cWi/8y5 + mf/Js5L/y8ae/8Wynv+sg4n/jVxp/36Ccf+hy6z/yODZ/7Nsff9DCgz/AAAAtAAAABIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAABsAAAC+BxAa/1GFhP+u79r/wv/p/8S11/+TLIj/WRVn/19kc/+t3Kb/2tus/9XQ + p//RxaD/zbuZ/8q0lP/FgIn/eyRj/1IoVv9slIP/rvHV/83/8f/Vz+X/lzxa/yIBBd8AAAA6AQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADcAAADVBwkW/z5caf+TyMP/yvLs/8txw/9nG23/XzBi/3OR + eP/B3ab/2NSp/9LIo//OvJr/ybSU/8mSjv+NJmj/ZJGG/7D42v+9/eL/w97j/6pbj/9HCRzrBgAAXQAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADTAwEH/xgZMP9QUHj/ejeQ/1wg + av9cJWP/XSpi/3SDfP+70aP/1c2k/8++nP/LtZb/yaCN/6qHjv+v897/0/7v/8PU3/+dVpP/UQ8v6RYB + A2UAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIAAAC1AAEE+iMM + Q/9TFGv/Vxhs/1kYbP9XFWn/VRpn/2ZRdf+WnYr/vr+a/823mP/IqYz/xtmz/9Pu7v/Cocv/hzZ5/kUJ + LdEYAwpQAAAAAwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ABUAAgJ0DAcd1y8NS/1MDmz/VA5y/1QPcv9WD3X/SwhS/x8SI/8wXzj/j6t7/8uukv+5cYz/eD19/1EN + S+YpACGRDAIDJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAAAkBQIOchkEMLsrBkLkLwdD9zAHQ/0mAyj/BAAB/wADAP4SQR33fJZz+KU1 + YOgmABeICAAINQAAAAUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADUAAABcAAAAggAAAJwAAACeAAAAigAB + AGMmbTp6iUJLlbIAAA2pAAsACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8D////AAP//8A + Af//gAB//gAAH/wAAA/4AAAH+AAAA/AAAAPgAAAB4AAAAcAAAADAAAAAwAAAAMAAAACAAAAAgAAAAIAA + AAAAAAAAAAAAAAAAAACAAAAAwAAAAOAAAAHgAAAB8AAAA/gAAAP8AAAH/gAAD/8AAD//gAB///AB/ygA + AAAwAAAAYAAAAAEAIAAAAAAAACQAABMLAAATCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAABp4BABV3AgANiAIHF3cBK0ZfAEVuPAAyZRQAGFMAAAVcAgAANwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAasAABGAAgAFiwEFD5MBSzaYALxxigDajXoCwZV0A46MTwRmgB4GM4oA + Ag5OAAAAegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK0AAACTAAAOEgEAAKIABQ+tAC8ssAOncLEJ+5ys + C/+XnAz7l30N45NWDKqUIARSmwAADJMCAAAAAAAAAAAHAQAAEQEAAAMBAAAAAQAAAAEAAAEBAAARAQAA + EAEAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJUAAAKt + BQAAqQMYIa8HoWywC/2Zrw//ma0Q/5ihEf+YdQzumToJmW99YUJGtZdqiKuPk5Ksh5SZsJ2Wk7Osloyy + r5aRpZ6VmJuGlJ59eoeZYIJRdSuBKFUAGgknAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAACfAAACrQEAAKsAJiapCMyAqBL/lqkS/5aqEv+XpxL/lpAS/IWqbvCE4OH5wsSt/8fK + j//F7sf/vfTt/7fy6/+22dT/v7qX/8bOmf6+z9L0q4nN2ndUq6dVNGtjQgQZIi4AAAQ/AAIAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqgAAAP8AAASiB3dPpBH8lqQV/5SkFP+UpBT/k6QT/5St + KP+V3rr/xMi0/83LkP/D99H/u/vu/7X67P+35eL/xsak/8vdnf/K9t//xrvx/4Sf9v9qcrP4ajsq0Goc + E4NkBREpRgAEAlUACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAOwA9AbQwmA/9jaEZ/5Kg + F/+SnRf/jpsX/4+gEf+Q0nL/tMqz/8rIjv/F8sH/vvrv/7n67P+57On/w8uz/8nLkv/J77z/y8zy/46s + //9th8D/eGw2/3paK/x2OibSZRUacVMACBaABBsAJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABxAAAA3gAq + Af8vkxH/i50c/4+cGv+Pmxr/j5ka/5CZFf+Nvkn/qcqk/83Ljf/I8sj/wvrv/7757f++9O//xM/B/8rF + jv/L8L//19f6/5mj/f9rb53/dGIy/3ZmM/91XDX/cT8w92YaIq9HAAo1AAAAAScAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAA + AJkAAAD1AAAA/wA+Av9Clxb/jZge/46ZHP+PmBz/jpkc/4+WF/+Jrj7/os2j/87UlP/L9dL/xvnw/8P5 + 7f/D9u//xtnS/8vNmP/Nz6f/xqO3/4ZynP9qVlH/blU2/25WOf9vVzv/b1c8/209Ov9WCBbQJAAARQAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAiAAAArAAFAfwGHwL/H0YM/z9yFv9ylRz/jZMf/4uSHv+Kkx//i5Mf/42SH/+FUBz/S4BI/5K+ + f//A9NH/z/z1/8747//P+u7/0djn/7mqlP+0hXX/kEtH/2RJOv9rTD7/aUw//2hMP/9qSz//aExA/2lH + Qv9eEST/GAAB2gAAAE8AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAABwAAACsABUD/RtZDP9eojX/p8KM/7OQT/+NkB7/jZEj/4yOIf+JjSH/iJEh/46E + Iv94GRH/Ew0B/xJmIf9v8rn/3/n3/9328P/c+vD/4s3u/69JcP9ZRzj/bUND/2VDRP9lQ0X/ZUNF/2ZB + RP9jQkP/YkJD/2ZDRP9iGzT/IQAG/wAAANsAAABJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAJYAFgL7H3QP/3TKS/+y78X/z7y9/6mLNf+IiiP/iYkk/4eJ + JP+GiiP/h4wi/5BiGP9XJBf/Ey84/x5hWf9Ktqv/jbXW/4ux1/+KsdX/jZzR/3palP9XUm7/YkBZ/2E2 + SP9fN0b/YDlJ/2E7Sf9gOkn/YDlJ/189Sv9jJUT/NwIQ/wEAAP8AAADRAAAANQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAbgAMAPUSYgr/a8ZJ/7D6yf/D3OD/s5JZ/4iJ + HP+Khyf/hYgm/4eJJv+JiSb/iYki/4yMTf9jlbb/XKXl/2mn9f9uoPT/aJ70/2Wd9v9nm/b/ZJ32/2Wi + +f9rn/H/aY/d/2hssv9lQHT/YDFM/10zS/9fM03/XjRN/101Tf9hLk//TAcj/wgAAP8AAAD/AAAAsAAA + ABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4AAAA3AI4Av9HtDH/rfe7/8/g + 5/+zl37/j4Mp/4SFKP+HhSr/h4Uq/4iCKf+BhCr/h40w/4Gqrv9yp///cKL9/2+c+/9ulfr/aJX6/2uY + +f9ulvz/bIDl/2aT2/9ooP7/bKf//26s/v9sl+v/akuh/2AmWP9dK1D/XC5S/1stUP9dLlP/Vxc5/xsH + Cv8GAQP/AQAA+AAAAHgAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAACjAAkA/xBs + Dv+A3YH/xdLL/7CTef+Neij/hoAp/4V+K/+Cfyz/hH4r/4R8K/+CgSn/hZRg/3Sg6/9rmf3/a5b5/2uP + +P9oi/f/Z4r3/2iM9/9qi/n/anbo/2aK4P9ol/r/bJv6/2+e+/9rrf//a535/2lFrf9dJFf/VCdQ/1Ep + Tv9CLUL/PDM6/zgxNf81Gin/GgMM/wMAAd0AAAA2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AE0AAADtABAA/xtyGP98mk7/l4JF/4V8LP+Feyz/g3gu/396Lf+AeC3/f34t/4Z8Lf+GhS3/f5er/26Y + /v9sj/j/aIz3/2iG9f9mhPT/ZoT1/2eB9f9mgPT/ZYX1/2eI9/9njPb/aY/3/2mW+f9rn/r/bav9/22I + 9P9lLo//TiJG/zEpPP8qLzf/NEg3/0hsL/9kVCr/TiIm/x8DCf8CAACWAAAABwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAADAAAAKYAAgD/AwcB/wwkBv8tXhj/aHco/4N2Mf9/dDH/fncw/4F3MP+BdjD/gHcw/4N4 + K/99jV3/c5jq/2yR+/9ri/f/aYX1/2eA9P9le/P/Yn70/2aA9P9nevT/Yn3z/2WE9P9ngvT/ZIj2/2eQ + 9/9rk/j/aaP8/2ur//9sUc3/RR9G/yMmNv8pMzn/O5Er/4S3C/+WoQX/fVsa/00SI/8UAATfAAAAMwIA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAOAADAOQHLQr/PUkd/1UpFP8rVBr/X3My/4JzNf+AbzT/e3Iz/4Bz + M/9/dTT/f2wz/3xdOv9oe5X/Y5Lz/2mO+/9piPn/aYH1/2V/8/9nf/P/Z33z/2d78/9lePL/Y3zy/2Z/ + 8/9mgvT/ZoP2/2aL9/9pkPr/aIvz/2Wa8f9oWsr/OR1F/yAhN/8lUDj/Ubca/5y6Bf+XtQT/kZQI/3kz + J/8xAhP9AgAAfQAAAAIAAAAAAAAAAAAAAAABKwYAAAAAdQAnBvwznEj/oJWB/5VlPf91bDT/em44/3xr + Nv97bTX/fW42/3xxN/9+bzb/fTw//2UTXv9THXL/VjmP/11XtP9latL/X3fp/2N+8v9of/P/aH30/2Z8 + 8/9mevT/Zn32/2d69f9levH/Z2/p/2Rd0f9cQ7L/VSSO/000gv9TLn//Lh8//yEgOP8lajX/asMR/6Sd + DP9+dh3/ZKQR/4RjGf9RDCD/DgACvQAAABkAAAAAAAAAAAAAAAAAAAAOAAoAsg1vHP+A8qz/2MDm/61m + W/94ajX/e2o5/3lsOP9+ajn/e205/31vOv9/WDz/cBdJ/1cRWP9TEF7/UQhZ/0skXf9eT4r/dkKc/2s7 + oP9eTaz/X2nR/2J58v9jXeX/YEG4/1wypf9YJJD/VRh3/1Y/d/90YI//ilmP/4Ise/9bFlr/Nx4//x8h + O/8ldTP/dcQN/6VjFf9QJTn/J30n/2V8Ef9nGiT/HAAG5gAAAEMAAAAAAAAAAAAAAAAAAAAnABoB2Smp + Qv+q/9v/zcfn/6pnYv91ZDb/d2Y7/3pnPP98ZTz/eFo6/3BAN/9kKjv/VyA9/1NSfv9UULb/VEGM/1RR + lP9zyLT/3tnq/+OAzf+YD3b/UUJ7/11x6P9fH7T/Vgdb/1QLV/9TDlb/UB9a/1FthP+N5s//6Pf4/+iW + 3f+aHGn/RR4+/zUgPP8udzH/c8EP/55ZFv9LKzj/L1o0/1SHE/9wLCD/KAAL+AAAAHsAAAAAAAAAAAAC + AAAAAABHACoE7z3FZf+3/+X/xcLc/6VhYf93Xjj/dGA8/3VkPv96Yz7/eFU7/28/N/9iKjP/Vigu/1M/ + V/9SSof/U16X/1pss/9w2rj/3v/9//i+9f+/G3z/U05//1117v9gMr3/VRVQ/1RLdP9UXLH/VGuy/1Vq + zP9lybT/zv/6/+uq7P+gI1v/TCQx/0oeN/83ZTT/Z8QT/6FsFf9bNTf/OFU4/1CQFf9xNCH/MAAN/wAA + ALEAAAAAAAAAAAADAAAAAABiADoI+1DWhf/G/vX/0K7W/51XWP93WkD/dFk//3FcQP92XkD/d1tB/3Vd + Qf92Uj//bjkv/1UxH/9RRC//WExG/2Sfc/+h+eD/3eb//9FsvP96M03/U3G5/2N4+P9lWOb/XiFq/1JN + YP9PS6P/UDJo/1BZW/963an/zOT2/7xkm/9qIi//PR4v/yYcNv8iUTz/VMIc/6SLDP9yQC//R147/1yV + Ef90Nh3/MwEP/wEAANUAAAAAAAAAAAAuAAAAAAB4AToJ/lLYiP/L8vr/0oe0/4xVSf91WUX/c1hC/3JX + Qv9xWkP/dFpE/3RaRf91W0T/dlFB/2hCJf9WXij/Z5Bg/4m2oP+aqbL/mmCE/3IyOP9QYnf/XH/o/2d5 + 8/9mdPX/Y0S4/1MoNf9NKh//UVUx/2qidf+cuan/mmlz/2xRPv9WRob/NRlF/xYcM/8gOTz/Pa8j/5q1 + Cf+VcR3/aoIr/3WaCv91Nhz/MAEO/wEAAOkAAAAAAAAAAAAAAAIAAACFAS4I/0W4bv+0ttH/qFp1/3ZS + Qf9yVUb/clZH/3RYSP91VUj/clRG/3FVRv9yU0X/cFNF/3FRRP9oUD//YFFO/1ZGOP9RPy//TEU4/1Rk + h/9geuf/ZXn0/2Z28v9kePP/Y3Dy/2BXq/9ZP0f/VUgr/1lPNv9aSzf/VmJY/12Nvf9mYOT/SBVZ/xwe + MP8iJTr/Ln4q/3fECf+ltgf/l64I/4uSBv9yLSP/JwAK/wAAAPS3AEgA/wD/AEwAHgUAAACJABkF/yxa + NP9yUFr/ZWBJ/3plWv97UE3/b01H/25QSv9yUEr/cU5H/29SSf90UEv/b05G/2xQR/9tWUj/bnyh/2ds + zf9gWKf/WmCm/15xwv9jeuf/Znn0/2V18v9jefP/Y3jx/2Ns0v9hWKn/XlCQ/1tpov9dfND/ZY/u/2ub + //9wXN3/Xh9q/ywfO/8hHzT/KUgx/0ivHv+RvAf/mLQD/414Ef9kHCn/GgAF/wAAAPX2ABgAAAAAAGwA + BgIAAACCAAMA/woRBv8dLBP/NrRg/7vFqv/HnZH/o2xv/39MVf9nREf/aUpJ/29OTP9yTUz/b0pK/2xO + S/9vTUn/bVhe/2Y6nv9hLob/VDZe/1FPO/9Yblb/YXvT/2Z79f9kefH/Y2yV/1tNMP9WN0D/VTZt/2J4 + mv+Bwev/n9jw/7Dj7/+50eb/ur7S/6miuP+HYIf/XDRK/zdeL/9UnRb/g5IU/3tLKv9FDB//CQAB/wAA + APElzF4NRbdmJ2avcU9Ra0quSVY//1pgSv9hdkv/hMaI/9LXsf/Z267/2dmu/9G1o/+wfH7/h1Jf/3RF + Tv9rRkz/akdM/2xHS/9rSEz/bUhM/2xbbf9sdsz/YGbS/1lcgv9XaDT/Xnev/2R5+P9jd+r/YWZc/11x + Sf9vp7L/m9bi/8Lv6v/R+uv/0fzp/8786f/O/uz/z/3x/9L88//X7vL/1KjN/5VIdf9COjv/RT47/0If + K/8eBgn/AQAA/wAAAOIjy1Opns6a0LzInvPGyqT90M6p/9XMqf/UyKb/0sWk/9DCof/NwJ3/zcWd/9HT + pf/X2Kz/1buk/76Eiv+TV2b/ckRS/2tBUP9pP0//ZkFO/2pFTv9rZn//Zn/k/2N49v9fddT/X3jq/2B2 + 9f9ggfb/b6HO/5XIx/+2zM3/uLmv/62sl/+gqIH/mqx2/5q2dv+hzIb/sOKr/8L22P/R/fH/2Pz1/9u6 + 5f+dNXL/NxUj/xUECv8CAAD/AAAA/wAAAMgSzTeIes6I8M7OrP/Szqv/08yo/9HHof/PxqH/0MSk/8++ + n//Mupn/y7eX/8mylv/Is5L/yrqW/865m//KppH/tpuG/66WiP+rcnv/jk1k/3RGVP9uV1b/eIWQ/3+d + 4v+Cn+r/iaTk/42s4P+YwNL/sL+1/7y3nf+zqYv/raF8/6eccP+il2T/nZFX/5eJQ/+OhjD/iZMn/46y + Pv+o45j/y/rr/9n59v/bh8n/bAYl/wIAAP8AAAD/AAAA/QAAAJ8AzAALH8xKc3XMi+rDzKn/1Mun/9DI + o//PxqL/0MKh/86/nf/MvZ3/zLmb/8u1mf/IsJL/xq+U/8eqkf/FupD/zc6j/9O/ov/PsZj/x66R/7/K + m//G1aT/z+Sq/9bwuf/Z8rr/3/O5/+D0uP/h87j/4vG3/9/zuf/f8Lv/4Oq3/9zhs//Y163/1tCo/9HD + nv/KsI3/uJlr/5+LN/+OpB//n+mU/9D88v/h0/X/tCJs/xYAAP8AAAD/AAAA8gAAAGMA1A8AANYABhjN + UVZjynrTtsqd/tTIp//Uw6H/z8Gf/82+nf/Mupr/zLeY/8u1lf/Ks5X/yK+X/8ixkP/Hy53/08yq/9K+ + ov/MsZb/ycyW/9TqsP/d5bL/2uSx/9nmrv/b7rT/3vS6/9/0vP/e87v/3/K6/9/yu//e7bn/3eW1/9re + sf/X1qv/1c+n/9LIov/Qv57/z7WZ/8mkif+xjEj/kMQ+/73+2//f5/3/xzqK/ycAA/8AAAD/AAAA2QAA + AC8AAAAAAM0DAADlAAEMwCszSbVdrpG/ifjJyKL/08Si/9DAoP/Nu5z/zLqZ/8y4mf/MtZf/yrKW/8is + kf/DyZv/0NCs/9TCo//MuJn/ydif/9bns//a4LD/19uu/9bUq//T0qX/0t2o/9jttP/d9Lr/3vO7/97y + uv/f7br/3ea1/9resf/X1av/1M2k/9HHn//Ov5z/y7aW/8qwlf/Knor/rqxR/6v6vf/g3vv/vy18/x4A + Af8AAAD/AAAApAAAAAsAAAAAAAAAAACaAAACCxMAAEIHIw9GHs0/dEj/f5lw/6aqiP+8p5D/vaCN/7mT + jf+vgob/o2t6/5BScP98ZXD/jaaF/7u2mv/Dvpv/zeWt/9vntf/b4bD/2Nuu/9fUq//TzKT/0Maf/8/J + n//S3qX/1/O5/93xvP/e7rf/3Oa1/9resf/Y1qz/1M2j/9DHoP/Ov5z/zbiZ/862lv/OkY7/p5Fb/4rz + wf/motv/hg5B/wcAAP8AAAD1AAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAIQAAwD9BBYI/yY0 + PP9vZ3j/kXaP/49HgP9wJmf/XyZc/14mXf9cJl7/XTVi/2tAbP93iHX/q+2n/+Dnt//b4bL/2duv/9bV + qv/Tzab/0cag/8++nP/Mupf/zNSd/9Txsv/e7rr/3ea1/9resP/Y1av/1Myk/8/Gnv/QwJ3/z7eZ/8SY + i/+paVb/iqFY/6C0wv+VLFn/HQAE/wAAAP8AAADHAAAAHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AC0AAADXAAMA/wwiLf9ftpv/xfTu/9jU5v/Ai8H/lDyE/2sgYf9bJGD/XSNi/1weYP9YQl//dNSQ/9Ls + t//b47L/2N2v/9bWq//Tz6X/0cqi/9HCof/NuJf/ybOT/8fRmf/U7LT/3Oe1/9nfsP/Y1qv/182l/9K+ + oP/LnpD/q3Fr/4JdTf92e0j/j4pg/5hTTf9NCQ3/BQAA/wAAAPgAAABsAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAB4AAEA+gIPEf83e2r/n/ba/9n79v/Y9fH/ysne/61lrP99InT/XR9i/1sh + Zf9cHmL/XIt0/6jssP/c4rX/2d6x/9fYrP/V0aj/0sul/9HEov/Nupn/yrWW/8mxj//I15//2eey/9rW + rv/PsqH/uImK/5tabf97UVP/cYxo/5rKov/A6tX/z7rQ/6VbX/9hEhT/DgAA/wAAALsAAAAaAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaAAAAtwACAv8MFiv/SI+A/6nx3P/T9vD/wfzh/7vr + 4v+8gcf/jRx9/1waZv9ZGWf/WTdo/2/Hjv/I5Lb/29yx/9fZq//W0an/08uj/9HDoP/Nu5r/y7aX/8mw + kv/JoZD/uGyD/4JLb/9tM2L/XyhV/1xSU/92upb/tffc/9H+8f/Y/fT/3Lvj/6w/V/9IBQ3/BQAA5gAA + AEkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPQAAANsAAgT/DRUt/0yG + h/+Y68//wv7l/8H+5//C8ur/z33M/5AYe/9XGGn/WRNp/1libf+M3p//19+v/9nZqv/W06j/08uk/9DC + nv/NvZr/zLaW/8myk//Jm5D/sjFz/1oVV/9PGVT/U1th/3/Vqv+8/uX/yv3r/8r+7f/T5vP/yGyj/3Yb + K/8cAAT3AAAAfAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAA + AGAAAADrAAAD/wsLJ/87XXD/hMu9/7/66P/T//H/4eH0/80+rP9mFW3/WSho/2QwYf9kk3D/quOj/9vc + q//V06j/082n/9LGof/Qvpz/zLeW/8mxlP/Hq5D/w0yC/3EMXP9PUV7/dtqr/7z+5f+++d//tvrf/8bx + 7P/Ji8f/jyNS/zkEEfoFAACcAAAAEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAcAAABuAAAA7QAAAf8JARX/JSZI/1d3jv+Vu8X/v83d/71Gu/9oGW//Vy9h/2Qs + Yf9iNl//a5V3/67epv/Z2qz/19Gn/9LGoP/Pvpz/zLeX/8mxlP/IsJL/x2GF/4k4af9s0Kj/vv/r/8z5 + 5v++/OL/u/Dl/8SKxv+RKWT/Sgwc/BEAA6oAAAAfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAbQAAAOgAAAD/AQAF/woCGf8hGEX/USl3/2EW + dv9WIGv/WiRk/1wjZP9cH2T/XChf/2eAdv+mz5//1dmq/9TGof/OwJ3/zbqZ/8u0l//Ir5H/yIWC/6Km + nP+z/ez/1/3v/9H87f/K5ur/uHy//4MgaP9IDSv6GAIHogAAAB4CAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAFcAAADSAAAA/gAC + A/8YDTr/TBRp/1cYa/9WGWn/Whpu/1kZaf9XGGj/WRVl/1YbZP9eUXb/iqOH/7vIof/QxKb/z7ua/8u1 + l//IqY//xrCJ/8Pwxf/X//X/2Pjz/9PA4f+xVab/dBVZ/z8KJO8YAwqJAQAAFgcAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAAwAAAApQAEBPIQDS3/PxFh/1MUav9TEm7/VBNw/1cTcP9VE27/VBNs/1QTb/9XEWr/ThlY/1RZ + Xv94pnT/sb6T/821l//JqY//xq2L/8jTvf/Ewdr/tnS2/4Ihef9PBkP8LAYayw4BBVkAAAAKAQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAADwACAV0AAwPBCwUh9iwNS/9KDm//VQt3/1QNcv9TDnL/VA90/1UO + eP9WCl3/JAIa/wYCC/8EKA7/MIJD/5q2hv/Pt5T/y46P/64yeP9fF2f/RgNH/S4AJ9sVABOEBQAAJgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAYQMBC7ITBCvnKgZI/DoI + Vf8+CVj/QApb/0MKXf9BBkz/GwEQ/wAAAP8AAAD/ABID/xtqL/+CsX7/yIWR/5oPSPceABfJDAAOgAYA + ATAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AA8AAAA5AgAHcAYBDKMIAQzJCAEL2wcBCOwGAAb1AgAB9wAAAPYAAADwAAAA4QALAcwWay7LgHd67K0X + RrMwAAAiAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAAAaAAAAMAAAAFAAAABkAAAAbAAAAGgAAABZAAAAPAAA + ACEAYwwnOXtFk6MeMnnAAAAH/wAAAFEAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD/gf////8AAP+AP////wAA/8AMA///AAD/8AAAf/8AAP/4AAAP/wAA//wAAAP/ + AAD/8AAAAf8AAP/gAAAAfwAA/8AAAAA/AAD/gAAAAB8AAP8AAAAAHwAA/gAAAAAPAAD8AAAAAAcAAPwA + AAAAAwAA+AAAAAADAAD4AAAAAAEAAPAAAAAAAQAA8AAAAAAAAADwAAAAAAAAAOAAAAAAAAAA4AAAAAAA + AADgAAAAAAAAAOAAAAAAAAAA4AAAAAAAAADAAAAAAAAAAMAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAADwAAAAAAEAAPAAAAAAAQAA+AAAAAAD + AAD4AAAAAAMAAPwAAAAABwAA/gAAAAAHAAD+AAAAAA8AAP8AAAAAHwAA/4AAAAA/AAD/wAAAAH8AAP/g + AAAA/wAA//gAAAH/AAD//gAAB/8AAP//gAAf/wAA///wAD//AACJUE5HDQoaCgAAAA1JSERSAAABAAAA + AQAIBgAAAFxyqGYAAIAASURBVHja7P3JkiVJkqaLfSyi45mPzeaze4wZOVdmdQ330iXCBkQgPAceAERY + YIctsMQWDwECERbYYYFVN3Vd6tu3qrqyOiunmH0yt/EMqirCWIiIHjWPiKzIrMyMiKzQIA0b/JgeParK + LMw///wzfLt9u327/bvd5Ks+gW+3P/omg93Effjz8Pfmc14zfEYU8L9l18Fr9LXXA1ggi18l/jsISkXD + /w1fPGB/UfKjgwv+dnrD21nHyD8/9O6//E9m/Z/+t3r50XeuzrX64IrmZx7397D5Zcl/vN7yf+GIv0Jw + AqpP+Z+/6uv+jdiyr/oEvt3+aFsy7KHRZYPv024Gr/s8R5CO9UXG7z7nazf4mvbkBFw81s4BgOLx/L9Q + /o84BOOFEhgbZGI1V6N53mHUIlbgTPA5NEZYSUbHnL8C8ui4jB8c+9vtt2zfOoA/ry0ZfQYUQAWMgPFg + r+NexdcUfL5jGEYIcNsBJGMfGnoT9zWw+pyv6fstO4cQIgxF2aL8f0H/T3gvGIXaqizGbrJXdEeluuX4 + RkvbIM8v4UrY1sIzk/MxFf8syshAW4J1YNpj/nf6lP/PV30/vvbbtw7gm7V93gqdVvacnUGP4j4BZsAc + WMSvs/j75AxKPusEXk8BPi8CGK7wLcGw18A1cDnY088XwHn8uo5/H44tKA9o+N/j/BX7TJlm3tixG7PX + 3snH7aOJdsd7r3xtr7GbDDJh2wmftJafecOHImimmEwRFNd1nH3V9+obsX3rAL7+W1qJk2GnlXwy+Hm4 + qpeDn9PrkiOYDP5uaPw5t1OCz8v/4bN5/dARNMCGsNJfAzeDrzfAFcEBnMefkwMwgEfo2ODlkrHNsvuj + drK/1x0Xx+0b+aR5Y7R1x2WjteaAQVtoGs956/lI4bnCwkPuPZ06Nqx4/6u+b9+I7VsH8PXchqF8CUwJ + q/c+cDDY9wkr+4xg1MOwPn9tL9lFCTm3V/thqP+7bskpuLi3cW/i12GEkJzDhmEEEI6ipoH6xph5OckP + Nncmx83jxUn75qTq7o8v3Z55oYWLL0XxBramZQX8XJWfdhqNv+HcK91XfQ+/Edu3DuDrsQ3z9uHqPY37 + Mu6Hr+378fcTdgae8vfhCv55P/+htmFFISc4oeQU0pZ+Ts5hhwFkGGaIPcKMJ3Dkrbu/nm/vre63p+sn + dr+7N8IvshUFICKQZVAXyNhhao8xF0DD3+mIx51jheOajpuv+p5+I7ZvHcBXv1nC6r0grOrHcU8GPo97 + CuOnfDaPz/h6lXQ/L32AXUSz++T7IG9h6nfh9KHwaDTWR91xe2/zoN1v7jPy+9lWSwm5vUqGViNkr0GO + QfY2aNUgN6C64ldf9ef+xm3fOoA//TYE7WqCIe8Dp8B94EH8egrsC0wFGQkUAhlICN0lhO+CDAzt82xO + P6ceJqhq/Nfbrx3+X1/7/R9gc/1uUCaIfYid/IDs+D1jHh9OeEPvyt3LJ/le9igbdScYX4vzSKeCIpJB + XdIel6zf2LB+1nB94xn9Gm6u2YGSqUrxbSnwX9m+dQB/uk0IIf6c3Sp/wi6X3yes+ifAkYH9DCa5SJ5j + TYbBSEjZBYOIEP4zyGv/QYq5039DS5CA4qniVPG3zDyU4zv1tHgcDn/Llv4A9mRQKpR9NH8Ey++id78j + +vDelAf1Q4637zHX70khj4WbBd2lofOKugIjJcZQqrs+crx4t+OZ9ZwfQ/M+8Aw4A57Hr1cErMH//if7 + 57996wD+uFsKhTNCuH5IWOHfAt4B3iA4gilhhS8tjDKhypGiEmtrMkaSU0hORoEhQ8Ri4n+3vw8OAeiN + PBi19pQ7EQmQuw+G7lT7Fd/jadSxkpYbbVlpEwv0DTv+zr9hsxgzJTN3sNmbsPwOPHhs5O3jiblfP2DP + /ICy+BEme0JX76FlDlul6wzSlmQYRNZZx+V8w7Oy5fmR5+o96F4AHwO/AX4V9w8JzuCGgDt8GxF8zvat + A/jjbJaQ644JK34C8O4Aj4A34/5AYGnBZkAhhlKMVGRUEgx/TMHYVJRSklNhJEewcd03GDEY7MD4ZUCv + U1AfvxcQg4iJDkDpvI9OIrzC07HWllfa8sxvaHVFxzW7St+/YcuBBSL3sNXbsPyOcO+Nkjf35rxR3OfQ + v0fh/oLOvIMrD3BVhvUdZIpzGeIqMgFr1yLdtoCbAlZTS3cCbBReKDxS5CHoA+B9glN4CbwiRARXBA7C + tyWCuH3rAP7wW0Yw+hPgIfCYkNOfcBu9XwATA9lIhJkYJlIwloqRVNSU1FJQS0klFYWUZFJhJEOwAzg/ + GL0gIMHQk0EbdFDjE0QsKhbF4AW8KNpH9h4nHdfakLuGNRuuJGOjLcrq33ZFCpA9kEdQfgeW7xoePRjx + xvKYh/lj9vU9Cn0P/FuoOURNAbSoGbKGJZIhhBphHHysOCrryUcOd+Iw0w49drgnij4HnhJSg0+AD4Bf + EyKDC751AsC3DuAPsQ059xXBsO8Twvz3gO8QHMEhMDaBsJ6BGCNiajHsS8ahKVjKiIlMKBlRSU1BQSEF + mRRYcowJqz8in4X24kruURAQ2dUWsx4psEjEEbwRFEF8gBEV2NLhtSGXLUZAdM2uHeD3vDIVmD0oHkH5 + HszfM9x7OObJ7A6PeYf97vvk+j1a/xDPHqoGfIdoB94RztIjuFhCEKYUdEyomdOxwNFJy7ZskaLFz1q6 + Ox1u4/AXHv/Sw0eK/hL4J9AF6AeEqGBDSA/+APnNN3P71gH827b4iDMDjoB7hBz/ISHUf0JwBntAaUBq + YISlMBmFLZmagkMpOKJizoiCKUbGZFRYyTGEHB8EH1fuhND3wX7/Zbf+7wDBYD7pJ9OnwiE+sBLeoUXY + esu5F858x413ON3C75v/W2AC5gjKRzB/G/betpzcn3F/cY8H5jvstT+k8N/F60Mcs3ieDUID2rELT4IT + sAgVwkQKhDENC7zu41AatrQgHT7r6LKGtt7Szja4ww163KInSnsK7QNwvwE+Aj6N+0sCUenf3fatA/j9 + N0Mo4x0SDP07wPcIwN4pIe+fEmr8GUCOMBXLgSmYZSPG2YSJGbFPydKXVFohjHFUKAXBihI8F0C7Do+P + VXHR8K+iyUgUI6FOgApODK6n2wsZSqbh77wKTi1WM3IsGzJeeOEDDx+5lle6ouGKQN77HaNlA4whuwvV + mzD/Dhy/Ybh3POP++BHH+j3m3Y/J3Hdxeg/PGMUjbNktysmrhfBEVLEeSoWpZuRS4XSCssDhaGnoovtz + OBoabtjYS7rxBVoo3bRjfQKrN8B/ouhvgJ8D/wz8gpAqrPh3Fg186wB+9y0nGPU+AdR7SED03wPejb+b + Clgbi/YGyMQwMjkHtuLYjlnmE8b5jJGMmLqScZeTuQJHgZLjyNgF9aEk1+HpVPE6XOm1L/wJSqaEiEFC + FaBDcNFJZOLJ8RgUp+C8JcPjsNyo58xbnvqO59qwjg18ypZgE19iS/WOOWR3YPIW7L1rOH6z5N7JHnfr + h5zod5g2P8C67+K4H4xfOgI2twFpQRRM5P2pIA6kVWwDZWvw5ORa0lHhKPFUMUFIzGZPQ8OIioKODM0L + 3LyhmnjyA8fmXkt7r8PfUdwJdCegvyJgBecEsHDLvwNH8K0D+PJbCvcPCEb/LsHwHxNC/9P4bzUhBaci + hgBiqWzJyI5YZBP28imTfEptJxSUZJqjWDoMXi0qQjJ8cGhkzgZALwXzKTwO36fvEEEklAU90nfrJEaA + RHAwBNWKi05mS0eDp6XFxbRYYrrwpawgI7jFPcjuw/gxHL5ZcPfhlAdHx9wZPWGfdxi772D9G3g9RWWE + 4kA3BHtr+6oFagJGIaAx4rEilCIYzSmlpNWSljJGTA4hx8RP19JSUJLHf53jaRjbhvFozba8YjO6YbPX + sboL6zeh+yUhIvgFASx8SghH/qydwLcO4F/fhFDSmxBq9m8A3xPhR8DbBMOfKruY3Ugw/iXCIRkLU1Hb + CWU+o85n1NmEMqvJTIG4LBh+ogxIMHyV1HSXyHMgEnJ2jR20O5JPTAEUjAhGIgqYYgMNwGA6mijBUVgT + UgXAq8eqY6wNcxxbBCVHtcKpjVwC15OFNLonjX2KMofsBIoHMH1i2H9Ucnpnyb3FHe5Wb3Cg71J3byPd + Qzrdx1GiNKhuETagTfi8IiH996BOwQiuVnThMYdKUUHhLSI1rpvSNgtcC8551FnUQ+c9NvYgCS0FHQ2O + jpJGaq7pbM52mnE92qo5cPh7Dn3k8PcdnILuERzBp4SKQTy5P7/tWwfw2zdDWMTvEPL8t4B3RHjHGJ6I + cAjUCuI1LBVWYGxhTwwnUnKsY+YypbQzTDbF2DGZVFjNMN6AglOlE1CTQnuNVqqI+h6l9yaU+gQQDXGA + j6U/g2IUQPCScuGQQvfRgsY9cgYklgQVEO8ZmY5925F5ZUuB1ynqSrxzeHV0tDgaOmnpTEdnHV3t8ftg + 7sP4ibD3JOP43oSjg30Op/fZz56wp28ybp9g3R06v0R9htKh2oBuUd9GHCN4qVAA0GB2ueIOgjOwSyFz + kFtLJWOyzSFyoXSXc7Y3HdsVbDee7caxbjrotqBrhBty2eDF01FQiVDTyZwi26rJNt7UN9xMr2nma9yx + 4h6C+xfQnxGigk8ImgZfMhf65mzfOoDP31L//ZKA6r8H/AD4LvBYhENjGIsJ1y9icRhgZOHAWk5txanM + 2NMlI+aITHAmgntqw4OOB+/jSirRWPsj9vm9QVAJhr1zAMS6PzELSKv9rtXODcJn8Ij66AQCI9AYgzcW + rx6jMFFFPEw0Y+tHOJeDD2mAp6NlSyNb2mJDU29pJlu6/RZ/35O/mbF4s+bO3Sn3F4cclveYyGMK95jS + 3Qd/gNcxqh7RdTgXHOodeEX97vy9V3yn+FahAj0F2fMUKpSFMKktM5kwuYb8xQj3cs3qVcv1pePmvAv7 + K8f1+ZabzTUrf0bDBU62ZCiFCCPJ6dTQASsx5kyriad50Mr2sNX1E9i8Bd0D0APgHwhpwTnBLf3ZpAXf + OoDPbjmhrHdKYOt9h+AA3iYw9/ZFyFOEnYpqVkKRf99aTrOaEzPjgH3G7GGYhpA3ovKqYGLILal+LxJz + f9g5gGj8sbAv/WsEH1dMFe2dgGqICNCo1iESIgQJDiM5DhEBY8AaVMLxjUKNUJAx7irWPqd14UBGQ/jf + SkNbbOmmDd1BQ3vS4B44zEND9ahm73TOyfyA0+KEub9D1t1Du2NwS7xWAYHQBvUOUR+qfF7wPlwT8SH0 + 953iXAA7tQrphamhGsN0Cvu1sE/J/CanOJ/izlvWFx3XFx03Z46bTz03H8LVBy3nz644u3rBZfuMtTvH + yQo1DTldjJsqKhHEjE0nXYU01Vqv552/2vN6s9fpdqG4pMPwK0JacMmfCZHoWwdweysI6P4Twor/YwLY + d48QDYw1OIhbmyUY/0FmObEVJzJnj31q2QeZ0VLRYWjV4whPuUVRVWyC7/qcvYfzYJcQ9NRf1eAEQnXs + NtPfR0OHWBOQ5CCkR9RVgvyOSc4msgFFhFwshVoyCsQpTeyrsyiSedzY4ecOPVD0HshjwT6xFHcq6uWU + Wblkbg6ZdocUbg/TzfBuhNciphoeL/F8fZDu9DErSV9xoC5iAAa0AJkL+QGM94X9mXBaCAdqmbQWuzX4 + BtqNZ7tybF8p24+E7S8t1/9defmLDZ989JKnr/Y4bz5l7V/QyQUdN/11K6VgZgzeQiGOa70xK/dqtnYv + 39j4i2mr6zugD4H/SogG/oVAJGq/6gf237p96wDCZtk167wB/BD4KcEJ3CPg2z2q5mOKngO1gbFYFjbj + wNYcyJQ5S0rdQ5nSUtGKDSU8HKpBSUv7PD+w9IZf+9A+boLEFVxAI5dfdnUCYmkvVfz75EEFFTPA/3e8 + up4mpGEdVBWky1BnYCtIC8aFZVlKj1ko9rhATi32TkZxr6J6OGZ0d0o1n1KaCXkzJ9sssH4ewUMzqCE4 + 1Cjeh1DEyK5zMfEaP9OGbECsYErBToRyIUwmMDfCXKGOGiReLJWHcae4G8HdsbjTnPWRsDzuGP9izPij + CS9eTri4nnK9fcHN9pymu8bpGjEdhTVMstBTkeuIQnKxmBHofTyLTrdLxS8Ck5AFO5AwNUt8Izf7VZ/A + 12CLshS8TTD6vwX+A4HUc5/gGG4LXIS+GmoL+5nhbl5yJ5tyKPtMOaBkD6MTPCUOgxsg530OP2DsJeMX + MRgTuvpSyL/bDUYl4v8Gj8EZwQ1wAas73j8RMwjQQIgsZHDyIrGTMCkKOME1hnZjaBuLEwMlyFwxd8C8 + Yci+W1B+r2b83oz5Gwcc3L3D0fIhe/l9xu6YrN2Ddg5+DJrH1IVBOXFXrgwChLcLmr0TSFoFBigEMxGK + uTCeCYsSliJMRcglCwoBYrHGYjNDVlqKcUYxtxRLS3lgqPYN42XBZDxmnM+odI5pp4irQDMwgreCMxY1 + FjEWKxlZ2I2IzT22dsoMOADdj88F7OTOvpFO4N+7AygIud07BKP/H4G/IuT9RwzVa4ZbTKFHGRznlrtZ + xbGZM2Ofwi8RpjiKWEkP1XaJDD2LYGTXzx8OF9fuaOykPToDEUF6kC+s9V5iQ090JL2wf3xdyv0DZhAN + KjmDiCWk45qYh7edBCG/QvELjznxmIeQvWPJ3yupvzdm/O6MyeMFi6MD9sen7Mkpo2YPmjFNm9N5kxKS + sIv2nlMTHiEBM7ExslF9rcYWSyq9AxgL+VQYTYRpLswEajVkasN1GMYQopB7GDnMwpEfdtRHnumBZTEf + Mamm1HZBrjOsjsi0RMTiRWiM4qKrzySjNAWFVFipjCcvnJqZR4/BH4NfEoJAR3AADd9AXODfawqQynt3 + CTn+D+P+TvzdhC8psZXWtEwNtQZZv0YLOgwdHqTDaurKC2IeIX83/broCAZrwwHDKm6SQwjPtJpgpF6S + 3I1HVRHRCCRKLPsN+PMaugicSN8B6MRjVENc4pTMWYwPDDotwI08btFhjj3ZXUN+t6C8O6I6nTI+mjGa + TxmNZkxlwbzdZ9zOcW3JtlW8b6KASHdLp6jfBnGUEPgSChiNeMBAuTBVVm5tnpDWIOAj0UnDZ9qxIaW/ + w1JDVinlBKZ7hu7YMj8tmZ3UjA9qpj8f8fKjOa/OlxTtM5w+w3EOEvg/IjmlqSjMiExGJpe6vOqqcq0X + I6c3E9iMoEuCrf9E6DT8RgGE/x4dQEYA9B4TQL6fEsp7Dwm5XcWXNP7Gw7lTntFSyIacNRVrrOQIRQzj + Q15pU1uPGBLFJ+hX6WtGuyv90UcEoRrXieAMOPUhN9/Rh1CETgYIgO4wBhC8iRUBFPEe8YpTj/dKDkgF + 2b5Q3oX8Ptj7hvJeQX1nzmj/gPF4j3G+YMyUuptQ+xFVN8K6IpQd5UvwZAYGrZE3oVGyIIF+QI+J9k5g + QGFIuIcf6HvI4HZ9RuJMFFMrtlDyuZIfKvmxkB9mjBdLlpMZLz/YZ3y+JG9qCnIuOafVgO95PKWUYTcV + Vkb4dpSv9dWx8qqC6yX4g/js/BcCNvCKbwhx6N9TCiAEmu4xYdVPIf9fEsp9e4SU4EsZv4nhbIf2cjNG + BGNArUct2MxgbUZmc3KbYa3FGoMYgxrwcVcjUd0v7iaG/yZ+TyjpdSK0Eo1NPEYC+EcM9cPxYt4vqQpg + 8cbgRfoSpGqgAatRKBQzA3sC5ZtQf08YfTdj/O6YyeN9ZndPmO3fZVbdYaKH1Nsl5WZGth1Bm9E5ZauO + rTpa9aESMdxhYMTSfy8xlPEulPwSaSlVCNBYyTAgpcGOhWICVdkxMlsqOjIxWJOUzg2DZIOdBlKMNoxH + cgfjDjN12BqKKqeux4zKMXWeUyLkHmxn0C4DDSmYNZBZwUiGSomjwGON4msRPxfRcWCCimHn21Ob8dd6 + +/fiAIQA2twnIPv/Y9x/xG2g73c6oAdahUaUVsAZj2YOmzuK3FPkGXlWYm1JZjOMNYgNjD9nPc44vHWI + ARuJOWJjfd5Kr9avsZ7vDDijqPGIKMYEqixGApHIEI0+EnyMxRnTO4BdJ0BIwmUE5gCyh0r1HWX6A8P8 + vYr5G3Nmp8dM5/eYVA8YyR3K7gC7nUJT49uCzgmtKlv1wfhTRUIEMTGFSf+pEBVIAuEngBeB8OOTNiED + skIoVaqLOwZKgxl7bLUmt5cUsqIUyCmx1KBFVBr1MalKHRC7nMOjOFF8DlIL+dxSHljGS2E6FmYijNqc + bFOhXYlTG0RJrMObDhUwpiAzJYUpyMVixFhVUyt2osgCdAo+J+ACN3zN04F/Dw7AEHL6BwSD/x8Ixv8D + AtBX/D4HTSGpShLM0pBfS0dlOkYWSnIsVShmxyYVJ6EW3poOZ1owHUY0rmZBHMxb0zMDe3kvCcbvjQZ8 + UKLxWxMQSZOagYLxd2JxYnuij6qgPmoEFYJMIb+jlE+ges8wfa9g8c6UxYN9ZvunjEcPqOQ+ZXtKtt5D + ViP8NqfroPFh1W/wkWOv+NRfkKoS8X0lIn+iQXwkOQIfSJBBkzAylCR+Nmx0ZK2gK8FvDF4N5A6T35Dl + r6jMFSNx1BRk1CglTlMHZSAwBEk0wAvOCx1xj4JtZqrke45ir2M8cUwyGGlO5ipwJbgsnCNdaJWSDmuh + NBm1ySmsxWLFY4tOzcyr7kO3DA5At4Q+ghu+xunAn7sDsIR8/w3gJwTj/ykB7Fv+IT9/AJ+FkVdmTpi0 + lrwt0bakbS2u87i2w7mOTjs66XC2A+OxomQRH2AQsusQFIu7j1FBXzEwBkwg9gTgzeAwsUoQVz8n4MLq + 63MDCyV/4Kjf9Uy+K8zeqZk/2mN2esp4fp+yfEBuTrHdAWY7hW2J3wrOBR1Bp6E1OagGR5aB7qoaJMYx + 2tOb+3/VyPd/TZFYJBm/QhYiGr8V/AW4c8HfGLRzGLuiLC4YF9dM7TaKLYR5Kp4yOLjXVMFVI1joE44Y + 240zRSqHGbXkk4584shryDJL5gvstkTWJa41tL6jsw1iGwrrqK1SGsiMAFackjmvI48fg69DfVE9u4Gp + X8tI4M8ZBDQEdPZNgvH/NQH0e0CICP4NWlfpDYRMhdIZRt4yI2MsGbnJQEwU1e7o2KLYAHUbj+aKLyNI + l4XVXMTFFlgbynxmt3IntCwssvG0ZZflhnw7GGGS+RoqeasSXF0BslDsfaV8R5l+1zB/WDI/2GdU36Uq + 72PMCapL1Neot/EcuhBa6665+HVRMg2NjH31T5W+pCYxUBECBTotzOpjf0NEBAUfgMAcfMye/Qrcp7El + 4VLYtoaNFTbllja7xJsGwWKlxlLjNcdTxDRgp6ew65UIGIM3iUcJUnrcSQeTlmzfs7dnyKYFdV5Ry5js + ZYW0BuM9G/WoWWGMiw4gVIoDk9GYayeL1pu34CaDbQV+AvwdgUZ8xdesj+DP1QFkBFT2deN/xI7A8Ttv + qdYepnJYCjJGmjEmZ6w5UzJmxlJJhpgK73O0M+GBw4cOOBOWIbGCeItNCj6E1zhxOAkEH5VAF1av0VtF + IpAERZ8dqYhIJVZS/U08SBdXwDxkphx68rue+g3H7G1h8UbF4nDJpL5HwUOMvwfdPo46lNs0TPFS6VDx + YdVU7fsXeoCPnrsTfnbBqDV1OIogolgBsUmPIFKTfIqPk7fQnWtW0DX4F+AuQS6gsYbN0rDZ79iMz2nN + DRUlhn0sewTJkzxCsztNg9Qwlbqs1cd25tiEoHmLLLeYylHklmUm5HlBVhWYXxjkqUe2nnMVtvlLtFiD + QKGGsc1osiymIGJu0Hnn2zeUNgOfRraVhArBOV8jcPDP0QFk7Mg9PyUQe75PqO+Pfp8DBnFNoQAqDBU5 + FQUjKibUTCgYS0GdZVQjoZwairIka+bI9Qy9qeg6j9MWR9C6CzX60IRjJKxFTpTOOFqrffiuxMVLTFxm + QwuxDqyvf03yCKlLqYvGPwd9BMXbnskbnsVDw+KkZLZcMqpOKc0jjL8LHOC1DmF0tGhJFQfjYygdY3oN + QN3Q8ndOKuJ5ievfM5xDuiOimL67MZKBYq9Cj8VqaAtmA3oB+gzcFWzHcH1HOb/T8Gp+xcQqmRlTcgYc + IWSR8GwYKiT3y25KTQZdFNEVhCiq9nBXyfKG6dTAModJCf9wiHxoyZuKcztixUsabnDahUawrMJTEtx5 + Z1ZsZ41vHiuuAK0IC08G/DcCNvC1iAT+3BxACvvfIpT5/oYA9t0l1Pd/54MFwzfUGMZkjMkYSclIKsZm + xMyMmOQV46qkmuVkh0J2bMgmJVm7xJ4tkacj3Culu9nimhYnHV4dvutw0uJMS4viTHAAncRyWuT+IyaK + fcTuPUlyIMnYwsMsGkJn7WJDTRaMn/ue/HvK+PvK3psZBwc1s3pBySnW3QV3F88+aLkD0UTj6jko58Ut + JQAJCE1+R+M1SzV8Sc09Emb5hmmgSYGA4AhJ7U+DhigP2gaNEB8kA9ArcCth9RG4Dz3c77AHW7K6wZiX + LHhGzkEYnNLjunFIitCPQotvu3MCoqj4ENlEH+QmHlM0mIlnMsnRokB9hfgj8hcV1o9RJmz8c7xeAy25 + cUysjRe+RbUTp27SKY9gW4Iv2E1P/jmBMPSVg4N/Tg4gY8fp/yuC8X+fIObxOxm/xINVCDWWKTlTCqaU + jKWkzkvKUUU9qZlOamazEZNFRX1QUt61lPcysuWYjH3sy0Pk11PkXwz+/Q73YkuzXrPSa67Xl9y0l6yK + Dp8rzjic7EQ+kixWaPsNjqCv7yeWjN/lsqoaxDTayDFYgDxS8u85Jt+HvXczjk6n7I0OqP0JNHdw3RHq + 91CpSHp6IZkPIbwwwCIGdfaenMMuDQnVid01TFmJxrDbQ0/97Y0w2qWkEiACraJr0E2MAjpB1oJrYFMq + l7/2XN3v2J42sLghz19S8DEz5hhyDHtRI9D0XYgpErjNFND+HCSGUSmy8oXH7rdY45kA+BJjK7JflMjL + EboZ0fkcL09Rcwm+xRgQO0G90njD2lvpNKvg/G7AAdWxm6L8MwJh6CuNBP5cHIAh5PzvsDP+H/J7GD9I + FPg3zMlYkLOUioXUzPKaUV1TzEuKw4ryqGJ6OGK2P2Z2MGZyXDM+LRjdqSj3JpjiALk8RH4xx/4vBfJf + PN3PG26eXnN2+ZKnzac0VlFt8LaJebb2QF/fvBMpxOEJkz7P12hZvkfW455JUDR4rGTfh9EPYPm24eho + zEF9xETvY7o7tO4Q5yeoppaH12ZqJvadD6G/Hyb6SWgkGU9f8humJPRU5uGx0IhtRCc2JA55BOkIs342 + IA1IB6aF7ga2Tz2Xv2rQOw2bOx3moKWuLhnZj8kZU0oFmiNMUpyCi++z6zgcOACNEmzxnHYZiIIFWTrs + mw0TBckNdjJCfl5hP82RK8V0jnPvWek1WChMRSWWUguyLqcJDqgAfwe2qcNB4sX+GQEY/MoigT8HB2AJ + xv82gdX31/weK39Y9Q0lOSNyxmTMsCyzgv1xzWJSMZ3XjPYqquOK0b0Rk9Mp06MFs7050+WM8d6E8bJm + NK8oRmPEzOBgjkwn2KwALzRtx6vVDZvLCabNcQ5c3uJ1A2bbk3s0KQB4iV2AMfw3Ztfgo6DGxDJfoBRr + HEgm95T8B0r1I5i/k7F/VLOs9hn7O9j2Pr49Qt0E9TZaRdc3F4fDKzjFu0jW4bbCkFUwXnZpgMqgrz8a + VxQn6Fd9F9B89dE0xfdVgsB4FCLkgOkE2yhsBNNA60Bbh7vY0r6/olls0IWjHCkTs2W89xKbj1gwJZNR + OD/NImtSAl15MGdgiAKoerwPOozhlILXcqKIVbJli30TJtaSZSWZlBQ6w/oWuenoOqU1wia7wWMxbZAj + HbnQCdo6T1A0vziFjY8XPM2L/CfCDMOvpEz4TXcAlkDhTd18f0sg+/xOxp/0v6bkLJkyY0RNTiWG6SRn + 70HF4mHN5LRgfFwyuzNm7+6cvaN9ZvNDxqNDRvWCsp5SFHVg/5kCoUBsgSxyeGzpLgWeKeaDHC8FjWZs + UVq9QfUcyw0Yxcc6OAjGm1DWS739vRhINJhogWqBXGECcg+ydz3lD2D2rmHvpGJZ7TPydzHtXVx3gOsm + eGejTFgq8Q0gs+gAtI10XQ0GgWjgHrmw4nsik88TVlqf0geNYOcgxtWAvquGfw/5N7EledeuLArWgzSC + X0O3AeccngaaFfmn1/hsTZcr5zbjQ+movrOCvRc05mMWjJiIUjDGk4OE5ixvYtNB1EJW0uofWA3i/S6y + wZOyLjJDtufJ6Jj5LWUnlC5D/ILuKTQboTWGLj+jkRXaOUoR5t6Tec+1V7YqtPhc6Y6g/REhRlsQ0oG/ + I0w0/pOnA99kByCEev4TAtr/1+wAv/LLHiCLL56RsUfFPhPmMqO0OcXMMH5k2f/BiOV7Y6YPRkwOxuwd + zjg62GNvdsC0OKQ0B2QyJzNjkDIe1cSyoSKF4pZKdwh+KbgypzUTtni2ckXHBDQPop6iSBbCeJU4ustb + 1JvYCbc798ifRa0EwG8Ccheyd5X6ezB927I8qVjWe4z8Kba9h2uP6NwE74PxG9+FFXCQlydsIe2aVnVJ + ZcbQ82B87Of3Emi9g7D+Nh8/kpRSnp+OFwEEr7vyZSrZGa+YFliDbBwb7/Fmg/gV5foG89GGziqbPONZ + LWSzDj++pq2fohTkdJRygGGBkRwi9Jgk1hPyH5SOXSjT+nR1Q6OV8RHQzATNFFk48odbJq1iXYV3OR0L + updK10GXZWzNGWKvybuW8dZgsxrj9/Tae4/fdC3rXOnuRni2IAwjuSBEAn/ydOCb6gBSO+8bwF8QjD/l + /F+K2ptW/QnCnJw9RiyYMc+njCcjqqOc0eOM+XdzDn8wYe+tJfOjfaaTAxb1Hnv1gkk+pWSGMEWogRKv + NtBWAcyu6dd7xbmQA6uYoI5jQgOPEodfxFVVUhOMMWG8iLfgsrB4+aSbv9s1E9xE8Hcheycg/tO3DPsn + NXv1komeUrR30e4E5+Y4nxPeNU4OUA2O5pbhDgA6Arjn0/tG6K93Rrexwd35scP1gJBTp3/yEvT/NNT9 + VUIvvsQSgjiQRpGt0rUe9S3ebNFsg7RbsnWL/8jjqoyrueGTPUEnHXr3JaZSLC0GT0EeJw+lyckSV/4u + ftaBM9AEp+6ui5HIoLQeVzjcfodVw1hajjGosWDn6EvBuQynBsSxMZvQD2FzyEeIX6h0K1Z+bVp1ubKe + gz4BfoxwLoEV/c+E6sCfbPsmOoDU2POYnfH/iMDw+1JhvxCMfw4cYDlkxJ5ZMq1mVAc11YOC8Tsly++N + OHhvzMEbc/YOD5nXd5naU0bsUcuIjBw0w5GFx0ZbvHZB9NPQ16LZCN1L2H4qbF4Im5Wn0QafXYG9QLhG + fId0GgCwlHBH5ZHgMCSuwjvmXKCTCDoGd+LhXU/2XcfkbWF5XLM/WjB1pxTbu2h7QtfN8b5E8aG+P2iq + HXbPEclGmJCP29T5tPuC8+zKeewqAKqpYsDOCezYSj1HgNQTHZuCFNAscgmcQAO6EXyjdJ2n0xZnNni7 + xkuDtg5ZefgEmp/lXCwsWjcga8yd50jl8WQsqCikxmhGho0KTRG7GBj/sC4wKHRGxmJoMPLG0JaKHCmF + dUxoOJUMIUd1Aa8MpvMY33LmW9Y4sC21IOLHxrFnm3arnbouuNfNGNF3JMQ5DegN8EvCQJI/yfZNdAAV + oYPvR/weaH8aYDND2CPnUMYcVEv2lkvGd2qqNzJG72bM352w/+Y++3f32NvbY14cMpETKg7JmWI1R2Mz + i9NA+fW6CywzDBkZqjmsLN3HwuqX8PIDy7Nz5azbsjavwD7H2nNgAw6klaCDpxLyeuPjmOxYkhsk1YpB + M/BTD/e2ZG81TN5S9k4r9quamT+gaE7RbVz5tejXblWPi7n/6+U80vfxf5JC/7j674C+GNqbvoAYhD16 + AwuvTweXiCFodCxpVwGN0YGP4b9uwa+DRNmmVbZe6bItLtvgbCgNiPOYG8X/xtBWhivrg3nLBj09w1c5 + nox9sVRGsH5Gi8VrwS6ESi4tEIEY8AVSlKOqqPNhNkKmSA5mT8mfdIxVOfaCeouYKXLmYO1DOmRhm1+B + 25J3hclkhqVzElqqHLQZdKcEtkRKBVrCKPM/yWiyb5oDqAkind8nrPx/SYgEvpjeOwhPMwJocAgckLFv + p8zHe8xOlszemjL7bsb8+4bF2xV7dw5YLO8yL0+ZZPvUzCiYYSlRVVrtIp3U4zUp/kXwCEiKd6IZegPt + x3D1C+Hpb4QPzjzP2hVX5gyfP8PYV6hswSnSWiwmdMJZYjsqeOvwJkPU9D39WoCfAnc68icbJk+27N2x + HExmLN2SsjvGNcd0boHzkeQjw/q34iIoBwNNwURC6q9f+kkTqyb6gkGc35fy5Bbw12MCupMmTYdK9UIR + TWI/wfgdaCO4jWW7sawaYeOhlS0uW6Eaemu0C7x+eQn8DFpnufA5Sof3G/TOM2ztqSC0DgsoMxz5zrAD + B3P4UeP/dn1iO/GSQMtWA64AOSTwBKTlVBRjLaJzfGdom4yuzFD7DL99hXRgdWQyVc1ofJi7uMmVVQX+ + AWHVT+3DHUFd6I+uOvxNcgCJ4vsuIfT/AYHbP/nCv0gVV4FMYeLhQIVTMo6yMbP5gvreHuU7M8of1ox+ + aNl/t+D4zoy96pSp3KPilJIFlgrBxibTTQS9wtv06DW7Vc5GlM63in8ldB8bNh8IF08dz6+3nMklXf6S + LDvDmBtUHaoG0xrUxdDfANaH/n9jAwnIG1QN5KBLD3cc2dsb6rc2LE89+6Mxc/Ypt6ewOcZ1czpfhkVY + fF+T6zkDAzafj+U/o3Hti228fa6vseoAnyECaaLSJkfwuhPQXQOR9NyBgdNIv4g9DNIK2ljapmDbwjY6 + AG9XaBoiag04xTaKPhe8N7QUXBqL6hYjK/I7z6kqS4FhZgy5An6GIaOjxCGItoPQ35DOXIaOD1A1ffri + RWgLwR8oOS1jdZx0Baxz2s2cG2+47IRVq+AarISxr5UZGe/nZquXpmUlSmdgO1H0EcEJrAk4wA3wgj8y + KPhNcQBCKJsk0O8vCMb/xdz+2LkjNtRZJh0cIBxLwXE1ZW9vyfjBPsV3ZmQ/rKm+XzJ6o2J2OGOvOmQp + d6g5IWMPS40EJX8Uh9MutMJqIOMaDEbiim80teejLbQvoHtfaD8wdM887XVL489p8xdodobaa0S6APT5 + DFGL+MT4096JiVe0U3xHiAKWHpm1ZG+vqX+4YfGW42AxZsYx+fYhfvsA3x7ifL0LxQdUmCTWYbn9hO2y + X3qDDUzACArqzrh75/F6zszt2LVvU9DgKgz0/GITacJGQoXOdCEbTrNCfRfTLOnwdou3G1SacM3IdjhD + EyIB/8+GBrjwoSfA+ob8zktsHaTZZqIUAoYpUARnCiQ8hP4T72hYO6ajDblKD5cCOZgDJVPPdNNhLoRm + lXFmZnyyVl6tW7JmBXlDHbka0o1E3dJ6XaO6VZXWCm4P4S1goypXgQDNPxHKg380jsA3wQEIAfF/SAj9 + f0yIAg74on7+HX5GaWDmYV+FI5NxUE9YnBwwebLP9L059fcq8vcK6icjFntzpvkRI04oOSJjgaGMj7cj + tcRqnNirMYFVyaLarex4853gXyru58LmZ4br94WbS8fWX6LZM6R4iuavwGzj8bNwO1LjPxERj2U4GjBN + 0Or3pcfUHnOnpXpnw/ydlv2TiqUcMFo/QLaPaJtT1E/iyh9bY0VvXSIbKcYm0n59XJ4DoSfOGozf98Le + gzR5Bx6mXHo3m+BWp+DOAwROQ3z/IGIiGBPATdEIha3A3whupdB2wBYxazBr1GzDOHGN5KEo7oGLgOWZ + 4n8OnWRcWsMnxpGZLdmdl5gqSLNOTOBWWGYoGS5WjYWEwA5mLMjOFZgopS4qfeVDgTY36AHUDx2z53By + JdzVgvfP5rz0W7blJbgVnpaq7XBSmFZndG4tnhscKxRngQOBdyIYmJSGG0IH4R9l+yY4gAT6/ZCw8r9L + UPLJgVs0UuiFYxGBUmHPw5E3HEnF/mjO+N4eo+8dMP7BjL33Ruw9LhjfqSiXc8b5IQvuUOoRRucoBR1C + YsmlEpHGFtkQr4ZGdxUfRCwSt/wmR973tP8AN39vOPsNvLjecm7O2WSf4sunkF2i0oIKPoUrmtp6oZ/1 + 5WJzjHdByebQYZ54qrdbZo+UvYOCvXLBdH1Cvr2DNod4N0HJEdJqqQM+v/arcmou8lG52A8oxT4u80OG + 307hf0f5lUihTemBRJZgSpN8amSMdZE+yI7twlgwlvg5BXclNGewvXR0roPiBpErxN4g0gIGMQWSZcHL + 55F01Cq0IJfgfp2AQeEZnsJv4fQV7SjjSCwzY8nVYnRCq3kAWLVDosJjD4bKzqVJ1HUWkrckzBRAcBn4 + PSV/4Jmce05WwsN1wflqyk21ZGUuabIb/GormcsoZWLCQPZr8Xodn6cui8/29wiGf0XoF1jFn//g29fd + AQihWvcOAfD7IWFmX1/rNxIenqEMtY8fbKpw5OCeyTmYLpneOSH/4T7V30xZ/Lji9GHNvcWYWTUlt3sY + PSLXI3Jd4GNnnNLFPaldxKVGXMx5o2OQXXusrg18LPAzZfNf4dU/eT75pOHD7QXP7VNu8k9x+QuMWcU2 + lVjquwW8xW+ivJ2iaO3gsMO8A/lPlPH3PIvjgj07YdYch7y/O8D7UPfuHZZ6dup4cjs+T+8Uow0T1XO8 + prA/YQYJ4tSEAw55g4PbFd9HFfGRCSj07c0exQ6R9hStCagT/Epoz2D9XNlcOBq3RctLxLzC2EuMblGx + CBlYi2Zml5NkhJDcg14r+kvoMFyp4VMPrW+4ufuK61HGPbHsi1CgZDIObcRqYuzib1+XwU1J+EWaZqx9 + qVZwY7B3obw0HJ8pT14aLlYlZ2bBuV7RrW5w0kJnJG8yShwt19JyHTx8iATSgtcRMIA0i/AZf4RU4Oss + CZZC/7cJ5b6/JTiCWbobEtvjTYjsiKkzhcLcw5ETTkzBwXTO9P4x9Q+OGf/1gr2/rjl9d8T9gyV3yxMO + OGHqjindAdbPUMrYTt8QlO+6ftfoAIIoZzyTqDKh6kMX2wdC9w8F6/9cc/ZfMz7+Tcf71+d8bD7ionif + Jv8IsleINKRgPIl1auwA1pgTp9ZejKJTDw875Mcd+V96Ju/Ccq9moXuMtnfJmntIdwg6ih4xeY9E9x3G + 7/rZxp30UQYRQEL7Ewo+ZPHd6ujzugu/YEdSIiIEJoKJ8XVJT7HHOJzANfhnhu1vDOv3he3Ljs7d4PLn + uPwjnPkEz3VkFpaIyZGMiPUIYkHyEEiJU0wDbA2+zdh6y0pgbTzORuFWG/CATAx5nARkJO93kcFgFgm8 + jls8hhgVgA36DtYg1mKcwV4b5FJpO+GmgJsRbIpQeqUV2CK+U2npaGjR2wOGoivDEUDBG0I0sOFz3ffv + v31dHUAC/d4irPx/QwiLDhhIeSXyidhdmJl7WHo4VTixJcvZkvrBEcWPjhj/zYL9n1bce7Pm/nzBqbnL + Qh9Sd3fJ3D7iR3gKnChOguSlpxlEASESEDQ25u3YcyjoSuBDi/uvBev/VPLyv5R88CvlN1eXfKwfcV78 + kjZ/H7HPyWQT15QMDTN9bhfiCbdf06zvEuTQI295zI89xQ9gfD9nXk2ZtkeU23vY9g6qC5SCHc89UHR9 + X/La5e2JsKPsSn+ps683UE2ovu7GDXl6nCCN89YBkphSsB14tqvFSl9hSDcwVhc2QKyWNB8Yts+UZtXi + 9BKXPaezH9PxDK/rYIhShMqIGRCN4vFAe46B74S2tWw3hvU1NDfQ+Q6tO0zdkpuOMLTdBGIXRbjYZKRB + bGlMuyQgU2Ewiyk4gTjuyGfBg5uNINvg3F1hcZWlyTNaMbhGcasOt+3Y4mjoULa8FunbuAvBM5wR0oE/ + aBTwdU0BMuCEEPL/B8Korj1e0/HraRzRBnMPUweHHk7znNlsSvFgH35wgP3rGdOflJw8qXgwn3Eix8zd + PfL2Hr6bhzzctGg0ei9NYPX1wFAwHdP/f3cqogZdC/pRhvv7gs1/LDn7u5wPf9nxm8s1n/CUi/KXtMWv + o/Gv4nNq8UTBj9cde1Ky8oTHYBaafMybkD1WykNDWZdkbo7pDjHdPuKniBYxIg4OIBh/lBAbYvSa3vP2 + ij002iSSET6kCfX69OfxwvvIJ+hbguPrewfpQmMPGtpye6FQMziVDlgL/kLQC0E3kU+Rd+DC6ui7KKKi + DqFDTBfPQ4l1y56wJAKmANTgBLprpX0f9MLiXyisPOQrtHbovEFMwx4NFQ5hP670GUo2qG0MB5Gk+x/3 + iK04ITiAiYQ5CxfCgQoPnxdc38y4ErhpPOtRg2bXIBmiNYYZnks0zjeIT3VOSHc7AkHoE0JK8Al/QEmx + r6MDSHn/Y4ID+AEhJ/pcpp+PDrn0sPBw5IVjKZlNZhQP9zA/3qf4qymLH5fceaPk/mzGiZyy6O6Tt6do + t8D7CpXA9EqKOIoLwF4ivQweAtOj6QbUoCuDfJSh/7Vk859KXvxdxkf/veP9iys+Ns+5qN+nzd/H2udY + uQlRr9pYbIpL51B2ZyDoiSEUO09B3oPsR0r9hjKbGaZ+Qr09xrZ3wYfQP7Wy9nE8g3r84G1k6G/699Md + 6aWn77FTy2F3joG0I32a0EcM8ZRvUQoJjswMAMFbkU5yAl3AISR3mMkWwxbZeqTLkKaGbgQ+1Oy9bfHG + 40XBKsYq1sbIzEgg5ZgMR5BQc9eCWweKcZDkcODX6CNPt/Ssy479rGUkDSUdhmlMBeOQ01tzPoYOYFco + 1DR+vVLsHhSnyuTGsLg0LK6UkavIpIKsgDzD2pzS13jmbLmmZYZnzSDSL8Od513gI0IU4PgDtg9/3VKA + lPc/IYT+fwu8xyDv/8yrI8NroeFKnWY5e7MF5cND7I8PqP+HGQd/WfP4jRFvTpbcM3eYu8fk7T3ELUBD + Ywzi8SYMgHDi8OL7wlZvRlG73hrBigkz9dYW/2GG//uC9X8sePmfLR/8c8evX13ysX7KRflrXPUBxj4j + k1UwUA2Ja3xsIqo0iJuT+C7hpXII8p6S/a1S/1SZ3zfsZWOW6xMm6ycUzUOM2wOyXuIqqeDo4FIlPZEw + SyQ2HqWQ1u8IQrvOwPi3cYXfifb040z7Y6coODi3SPFNx4mfJ+ANQ32+eEtT70MjqFPUdmjZhgGfpSK5 + RppiMGyTZ4i1qNg+fUrKyMaE9mJjBbGhWacTQ4fgEiTSgF9Du1I2W8faORq7RfMtxrZY8RHvDzx/6dUO + Y6SjMWUbsgQGDtwIAVvoDHpjWL+Es1fK05uW55sNV5tr3OYG0ziMsxg1KB2ObWh5vj1UKNaHey90TUgF + tn8Ig/u6OYCaQPD5C3Zinse8LuGdGlVsoHgugGMvnNqC5XxG/ugQ+6MDqr+ecvTTksdvlLw5WXCfuyy7 + RxTtPbRb4rWICH5c7cXhjMeZoMkH4YENYKNibSCfWQxmY7GvcuT9EvcPBau/y3nxd/DhP2/4zdkrPvaf + cFG+T1d9hM1fkMk6RqoZSj4ohnl2AzUGBtGFz6gzgUeC/ZFS/4Uyf8OyN6pZNPtMr+9Tbh5h3Qmio+ig + YrrSc3rDsc1rX1PXYTDWIeGHWwDfEHN6/TuJwbIYCVgMcdBnPAVH0AhIkmCwAxJDgUJ2gHvfnqmYBWR7 + Qr7MyOc52aygmFeUixHlYkIxm5BPJuTVhLyYYO0IIyVCEWdyBEJVSAGU1oTdm3gybcBruitYX8Jq7Vn7 + htaGXgPN2nC/EXIsOYYs5fpqQG10CimXSQKkIc2yotgsSMabG+heKtdnystrx8tty3W3pfMbjDpMF9Ik + p442gs4hAmjTdZZ4ZVIDwwWhIvAHaR3+OqUAwk7W6y8Jof8xn+ekBMiDMc493PFwnBUsZwuKh/vIX4RS + 39GPc958lPPWaMJdTpi7R+TtfXALVPMhz40dqTVJgUblm/QasWHlVItZGfTTDPerAv15yfofLS/+0fPr + f1nxm/MzPvGfcll+gqueYrMLrGxj51yO1wT69ctp/EiDEZcxJPcF6JEib0H+FkyPLMu8ZNEtGG/vkrWn + iF+EKKYPq2OK0oNwcSjoYFUfKnulT90jBCI98i/+tVVbBpeItAYGU3BRMky8QheDGBOGmfZzATyIF9Tr + boYAMSAaB9KGzYMqk2lquDZ0l47uqqXbznDNAV27plut6K62uMuW7qKludqyudmw2W5omw3q1qhu8G4T + mrTE70ITBW2E7hzcRti+gvVzz/WLjsvLjrM3W14dt9wbt9wpGvazhlqWGOqACUiIPProZfhYpipJFoIE + nSv5vrJcCqcTw+l5yftmzMtySjOb0OoG3zpkmyG+JmS+lwTez62BQiWh4S2lAh8SIoEX/BvxgK+TAxgT + Gn2+QzD+NwjpwO0rLfRFkswE0G8fw15dU9/bw3z3iOIvZ+z/pOTRk4y3R2Mecsy8uw/tPbzfizcykGNu + VVU0oLzGh9quFRM1+gglIZfBjeA+MrT/bOn+Maf5J+Hilx0ffrTiN5cv+Mh8wsXoY3z1nKy4JDNtmPhD + hiMnyXrLoPzXU2tS6h4dXAD+lPxtZfwIFtOMZTth0hyRb+8ieoRKHToGtQnHiOSeoGwTqL6ifYf7YIXf + kXbSZU1ourjBBdGdcg8MqgWyc1p+kCIkunD/XoSPnLYwEsyERh6NJbtMYeqxSyWfCWWZUboRdp3hrpVu + 0+G7Keo9vvV0Ny3uvMWfNbiXLZuzLdfna26u1mxWK9rNNW57TddegW7wtKiERuCezdl5/KXiLj3tubK6 + 9ly2jldbx8WV52ZP2c49zbRjXq4psxkiI4yMyEyNkSymczFBTBGTpDkPAoWBkaWaCcup4bDKOdh6npqK + VZ6HWYY3il4CXU4IgMcQ5cVf2xIe8A7BCVyyYwn+3qXBr4sDqAke7p24P+DzjN+wI3vkIfyvDFRFTnEy + pvzunPonC5bfH3P/fsEb4xH3OGRP75PpPRoWeCkC6zstQf3SFmEvD5kXvIk1XRvlqrowoqr9tWXzT4ar + v4fLnymX7695cXbN09UZT+1TroqndPkLbH6NMQ5D4I97yfoQ0WhakIL2nyeW6dKKG1RJMcdK/tgxeqLM + 7xgW44KpTqnaA9Qf4mWONwWJgxCcx06Lr/cmMcdPqb7r2bux8WdAzBESay+crRtEKSnVDUFvOG6a8ddp + 4OyDRoMPfRFpxqmRXbzlPKEEKSCZx4yUbOYp5ko1N9SVUGEwrQ1twa2NJUuDd4LfKP7Ko686/KuO7auW + 6cWWm6stm+s12+sVzfU1zdU1m5s1m/WW9bahcWs6Vjg2OG3wrsU1StcqjVGuCs9Vp6xeNWwOr7k5MLw6 + cOwvr5ktpozrGROzx1T2w8SgaD7Sg61pelPQg5IupO8uN2hlKCvPbCNMveclHSvfIHWL5A7ZGkRTCbIK + D/lt8t8QH3tJMPyXhEjg9+4a/Do4gKTo+xYh53/C54F+u+gck0NlYWLCoEZZjNDHE/IfTlj8aMSDxzVv + TEY84IAlD7E8QM0BagtUXKDU9nWvHXgjmsQuiRRcG4A+D+5CaH4FV/8rnP8vnrN/bnn58ZpnV5e89Gdc + Fs/ZyAt8doG1a6wRglBE6N7zIj0sZ6IevlEJ/+ZDmc514XP6StB9yB466see8R3HbFEwqSrK7SJMwDEz + vK3xYmNPvx+E+IPVPY3C6hH+8CIfJ/x4vS3sES510sjfafj7dAsknHda7b2Dzvd1kwDE2VA/t4nlF8/H + EdSF07wesYqpFTNx2ImjrIXaQo2Si8NkkSFZhvdKPEOdGHRi0VmG3/NUN556XTNddzQ3Ldvrhu3lls2r + DZuXW9YvG1YXazbrSzbugsZf07oVzm7pzIatbum2LZtPlbYjdG8eeC4PVnxy7Ni/e8X+/ZKDoymH5YpD + 8czUUUtFLkImElkDu0danMDa0NxkXGwNL72yyjqoVmRcY/w1NBukbDC5Bjl1TQJ1JSHlX/Naml8SJO9W + hPD//fj1Fb9nFPB1cAAZoUX/beC7hKafz+/yi9yLzMDYwCwXxnVOdjyCxxPMW2PqxzXLvRGH2YwlB1Sc + ghzTyQhvPBoHWWukckocZ42JyLbXwPbtQNcW1obupWH1Ibz6mePFP2548fMbXn58ycubc15ywWVxTluc + g73EyjaixYEd1uv4Q2geiqu9iauzeEBMkN2OhR03Efy+IA883HNkex1lWZKbMUb2QJYoE7zkoaw2kNnu + ncAwBh8UMmEH1qWfd5IYu4Aotfca3YX6CczblQoJ6QFJ6DP+rWiPDfSpQdTjDBFIwCVsrkil5BNHOfJU + uaVUQ9ZKoFhrbMzpDxyo12IELUPJTXIwE8F2GWVr6bY53bqiuXZsL1q2Z47Ni5b12ZrV1Yz1ekazvaHZ + rOk2G5r1mvV2hfUbuGzZdg03q4b2ouPybMWzsw2LS2F/bTm6vuJg1nFYKEvbsCwmTMucSZZT24wSS4YN + 0ZEDvxFWV8KzC+XjdcMLuWI1ekVnztFmhawajOmw1oTR8D4RkXISyeg1ByDsJl2/RRgw8gm7NuLf2Ql8 + 1Q4gTfJ5QAj932LQ6PPbTnosMC+E+bJkfHdM9XBCcXdEuawpswklCwr2MCxQRkgfUiVQLz7YJux9cTwy + 3dxa6F5A+4Gw/jmc/3fP019u+OTjc168es7F5hnX5oyVvaHJtqjZYqWJ6rapTMZtq4sjs1OVT9ip40Zr + ChoAFcEl3lfkRDETECnAz0D3QZeo1qjafuUPn2lA6uE2dUVSfpqMN00fNhpkunXX7ZBuDCSZr4gjxHDf + x/dL074xMWpKH1V2zrTPtFycWuRj6J8rpnbk42j8FRSZxZKBz0Kbru5UCoczxnTgUBIgTKaYArIKzEiw + 04x8aSkPPdWdnNFFzviyYHs5prlqaS9b2quG7fmG1dUN1WZFpjdctZesb87ZcMW2aVndOFaXwvXLjlcf + CB8tzphOYD5dcTSfcTgbsTeuWBQVM1syoaDyJXarrK+UT8863n/heP98xafdS55Xz7jJXtGxiThN6j9I + 7N9k/J8FGQdPUuqOfY/ACVgRgMHfuWHoq3QAyZvdJwzxfExA/YvPfWXkXZjI9R8B0zJntl8zfTBlcn/C + cr9kXpSMmJCxJGQWVSzd7Cr6YsNDakwYyW2wsT5scGulvVQ2zzzXv1Zufua4/G8dL3654dPnlzzdPuec + T1lnn+LyC9S04SJKKqvFosWgYybh/APBaYb0nCSvhQGpCGDYqae866kPhLwoEDdGdYH3C9AJqkUE3Hwf + H8fZwLH5Jp6D7DzQziFFsDApfYreWtV57U/7v+tX8UETcAIdjfTI+FAopP+7vtM21PWl9tiJo5g4qlqo + ckNucozLwWd4F/L+FMloZP317Qw+qPPEqR/9+0JQSBYLWQlm4smWUKwt5XVNe1HhroTuQmnPHdtXLatX + K6rrG4rmkkLPuBTDygvtao1bezbngv9UuJkZmG+xey8Z7684OLjgaDnmcDJmv6rZszVzKmpXotucixeG + Tz4UfvNpx8cXN5xlZ1zXL7nOr2ibJhi/z1Fn8JELELa0RHxhlS8nLJTvElKAZ/HrN8oB5ASDfyd+kLsE + MPD2FsByyEK4V9qw+k8kY1yNqA/mjB/MWd4fc7oouGszDhhRs0CYx0NKz+oTIxhjMUaiaJcNYNONwV1a + 3Etl9ZHn1a+UF//d8eoXG159cMXZ2QUvtq84lzPWRcz1sxVGPCYSez5LcRt+CNnlsAS7SEJUgUEmaC2w + 1DDB94FjeuqYLyzjfEzh9hG3j/o5XiuCfkCqZDCwuN2v5FaZUUOXXDSi4WqfXtsTfYannYIT3UUCoqGU + pyki8JHmKzsp8PR5+/mAyU9ZxdQemXVki458phSlJZeCXEPuqxqupbrbVYugiqy3v49UxJ073ZUrNHZY + GwtZBpJbslLQmcEtBXettJee6rykuqopryvKTUG5zrja1my2K7qmhUvw6lkXju1kS7e/we5vOXu+4tm0 + ZjGumOcVC1MxoyTvCjZbw8sL5dmnyvMzx+Vqy6a8wW9XgcUI4eQ0wzmD80mpeMOOB/CFDiDhZk8Ihv8L + gpjo9W/7o8/bvkoHkACN7xJKf0efez4pOirCTawzGKthZEqqYkyxN6W6M2FxUnEytdwzliNqxsyxKQIQ + g+DCAAqCMkxCsbU1tOeG7lND87Hn6kPP2a8bnv58yye/XPPi2RXn65dcyxnX+Tlbe43PbsisQ9RG9X/z + ucafMuH0UA6JNRrpc6oSoHYBnQB3BPvYM3rQsjxQlqOSqSyou0Myv4e6Mao5XkH6+bbx/QajudK1S6uw + iVavEfgL60s4Lwu3/Ehfjhw4iv7jSQj3JaVKqeefAcgYX5rmcPg0EciEnN9OO+yyo5x7itqS2ZKMCutL + NPZHpLRmMMxn8I3emjMQogPpndQthxCdhDoNMu21QKmYiZAtId9Afp1RXNfklxnlRUF9UTO5WLC6vmF7 + vaXtOppNy3a9ptle4tormtWW7auGq2rDsyKjynPGNmckOeIyVhvL+Vq4WiubRgP+5Dxy5TFNuOe6NrRb + Ydt2tLrCc0Zg+17xJYh+JWEBfRT3O4TKwPXvYoRflQMwwJKQx7xNCP8XfE7xs2da2iCRXxiovFCZjCIv + yMcF+SKnngvzHJYYptRkzAnFhBKhC/ROsSFEby2+EZqVZ/PSsfnIsfp1y9X7W159fMHzjy94+tENz55e + c7654sa+oqkuaPIVahqs6aITyQZ94be3pCnj+7w/0d9SVhun/2hggmEFHQucgj5QsuOOegxTWzLTJTmH + iF+GvgVNxXqHRAUbHTz8fXsBfMaQbiv6BOKO9zpgA0Lq//eaZDw10HBT+XKwxrjdLYrlw+AcJEaxrg0d + eZ0orvDI1JEtOoqZUtUZVVaQU2J9iWgWS6PSX6M+h9Ldld39PEg5fBo7NogY+rQlpmIanIBk9INL7RjM + xGDXOdm8pJyPqF9NmIznrC5WrOs164stK1mz2lyhrsOvV2zV06072qzlOhdsYShqIS8yLAV+W9FtKiCj + HhtELX5laS8M2w62bUdz2dJdr2m7S7ac4XnGrv3/S1H9a4ITeEyIBs4IWMCXlhX/KhyAECzzXjzpxwTI + 67cCf/EZJBMojFBaobAWKwFtV28iTpRyhpwdhToanYKuDe6VoXmhXD91XHy45eJXDee/2nD+6TUvzs94 + uXrJq5tLrvwN63xNm63xWYOaLqDQ7AL63wLWDGAAHXDgB1S6mKyrAy00wKF3FbnvYd9jipxcx1R+n1wP + cTqnoYglOReVfvxOJbj3MdpTALy+1viTbkKMCtIK2XcNvhbzeyDxfMXs7gOEeQHWEHX2I60YSXopcayY + 0Ap0RSD7ZMuOYuEZjTJGtqCiItcS00/zHT4mn5PX3PYGw8fjlpLRLYcYxUyTg+oHEcUyhREosgybFeS5 + oSgqqrpiNKtZXa5ZTTeUoxvyK8FuN1jWrH3HZtvQdErnlNZ4GqOYsaMqhXE7Yq8dMbMj6qrAtDnN84KL + m4znZ55nlzdsL89YX76i657j+RDPp4RFfMWXjOSHqcB3CQ7gkt9BUvyrcACJ9PNWPPFDvmiUl9z+Nmhk + GjJrKTJLgcVeZbhPCtYHOZdqeVUp1myp9JrMXSAUeO1onGe7ErozQ/shrD/suPhgzdmH15x9cMOrT684 + v7rgvH3FlTlnba5oJxu8cSCBF56AvlDo0YhSf/F1DsywYK79vN8hMccH1WAn4EbAkVLc95R3G/KFILZG + ugXGH2L9Eq+jAGhGoQ+RIci4u+W9wadhHmHh61mCEgFRSUber/bJaAb1RLQfau1iTjFsXBQBOyhB9o1A + XXAAnSpdIfgZ2H2l2FNGE8PY5tS+IvcVRvN0h3eoP9HJivbgXv8gDEqbrz8u+nm/7JWQgwaCkqKYcMKi + YVCKzUBqCaBBmWNmnmwB5dJSL4TROUwvHTcr4bqpuXJrVrSs6djajm3d0S4V2cuZloY9a3lia+7KnPFq + TjNZ8Kkv+dVFxy8vX/Kbl0LbvGKrLZ5LQjn/hi9pu2kbEyLpl8DHBG7AlxYS/VM7gIT8PyQAf4/4bZ1+ + URJBTOidy9RgychsQZbnWJejzyq2/23EeTfm01eC2XNc5+fU7iPKbkPmSlxjubm2XL0wrD9Vmo9aNh9v + uX56zcXZJefnF1yuL7hxV2zsDa1d44oGsi4ufiZgB5q0/sPMvl3H3BdFAcHQDBIUY2KDCk7RrcN3HueV + pgK3rxT3W+pHLbM7jvGsIvMLtD3GdUc4t0C1iNYV2pY1JufDAR3iI4lHd2Fub6y3kP4dbMbgM/T/75k+ + RMZfaKZJIiKW15xFAuNiON6TLHNgppgDKA6Fepoxyg215pRtgdUcfGiNDj0LEUjsEclBKSI6gh7WHPQo + JGFTkeRGUkl0R2TqozF2xCIxITUw3iHaoBg0B5M5sjGYuaVc5kyWY9xZRvOy5OZsxuXlDS/XN7zya5AN + ji1rbdiYlnbqye84tssVk6LgrXbGw+spcnzC0+mCR63jzosp8xeef9AbPuAlGz7lXwuCv2ArCNoZbxGM + /58J3ICLL/PHf2oHkOr+jwjo/32+aKjHEFPzhA4uFbwYXBbGO7kNtJ8YmnVO+zJHP/GsjrZMyxdUbUvV + vqToarpVwdVZwfknhpunjub5hvZixfbmhnV7w0ov2ZhLunINRYvJldwSY90Q94ruTGcnkfUFqH98wgIh + yIf+gtiJ1yPrTqFV1CpubPHHkN3rmJwq84Vhmo8o2n3UH9G6ZQwRTC9GGvJaw7ARP/H5JfJHRLW3oVtp + gMRzT5yFSNcdqv329GgfRoQT5bu97KoIwo4bkEg+vTsJADemhmIPzIFQzS11mVGppegKTKzD9CXSoUMV + whyD4fCR3qiHQKf2FMXUVSGxtCk+XqIUV/gwxbjnR0RA06iC66Bz/b/7TCFTrFGyiSGb5Mgox1dj1vmS + Ot+QXd9g2xuM3iBmTbvZ0LzasJmtOTtueDpruJhfYbTksJkxubPHyd6Uu+TcWU2YbY+QTxvc1vGxD83A + ygfsBgR96UigIvQJPIz7BwQc4F9FEv/UDqAmeKsEWhzxRcM8Uz4bV5JOlG3n2HjD2rRs8oaNNGSrLe3Z + Bn1esPpYebXfUOYrCndD2ZVkrsSvClZnlutnsD7vaNdbfLvF65bObujyNV22RvKOLFOstZikAa+vn9QQ + af/8fDTweXU3XVc0qA1Zj9j4EHcBvDOlxe6V2ENLvZczHhdMrKFmSc4S8TO8r3GRXzDs9e/TCWKIP1jb + b4kLD86yN9BBzc9EBC/4rd2UnluxQerck918UokfMdX3k2oYNvIZKsHMwO4J2VSocqHCkjuL+EB28TFE + D85DBu/obwm9Dq/2DiRkl5KYQWYgA95QvAhD9egeHNXeV6NRDnnIaBQDxgo2A5sZrA3DWiUTtK7hqsZu + RpTbCdV2RXa5wlxcc35Zsm1bXpiO3zxu+PX8KaeLFQ/lglF9h7t+xshb8jLH/uNd8g9G/P3lnPfbJTf8 + E8ovgWcIN+iXwwKEsJCeEBzArwle5F8dLPKndAAFt8sWJ/y2eX47ybXB7ww+M3SZZWsNGwOF93Tbjq7t + aFbCzaeKtR6jG6y2GF3BxtBdKe2lw23DLHgyhxqHzxxqu8AzwATefBd7WG+1fO6Kebf3Wy+JX0JDjIjE + z6BQgOYOMoNRg+kyxFtMXWJPxpiDkulEGVlHqYZCZ2RugdV6QC7aKfzeZu7snuRhzT7kurvQ3N866ziN + R3cc9n5l10Hpz4TVPUUI6dj+dTBe4x9milRgxkI2F4qpoRgb8sxQOEPeBQFH700fhYRuRonsv1sXsn+6 + ee1q6/C943wB6XGOmEr0KYL28wt7bgJDkHD3WUmPnQwqChacCUo/4PHWkI8Nk5uSfGUYXRWMX5bULzPK + Tw32X0acfWy5umj5l/VT5u/9mmz039H8H3m8OKV86z571R3end8hnx9Q/ZcTyl/cRc5O+E13wIoJYSbI + R+jttuDftmXAPmFxfR94SnAC23/tj/74WyiGzwh1/wcERzAZ3Nvha4MxlmBHYErBZpbc5pS2YFrUjOqK + fDTC5ksyXWDbGXk3i2O5Q8unIwxdAiB3SN0h0pF7AZtBlsUIOtRn1YVYVr1HJZa3hujasIFddNc6mxyF + D7VojeevBUgBphCkMtjKYsoMU+RktiDXgkxKKGvc3gg5KhiXlqoVshuDrSqybonVMgyk0F3NfxjO7wTL + ouinxuGc7Hj48hnjp0/zB1H17pg9ASj+hQnhdKL79qnCwEFo7KegUmQqZAtDMTdUtaHOLIVabBdGnavG + ZqCEGPaVkZ1TGyqHD0/wlutNWEd6bgYrvLADaJOf6cVDU6FjeEAhCv3IbiBK0jXowNlwITVXdOKhNBRj + IVvnFKWh2AiFd+RnwAuhfTbi3Hd8MLnGnF5SHv8Te6w4zO5QLr+HySuW+T3eNFPQKc4d0jZz9KLiQ1Vu + aHBpPNKXq+plBN3MRwQH8EtCSfBr4QAsyoJQ+rsfT9S+9ppwNiXIBIo5jJeG0bSgrsfUxZwqnzMpp8yq + MfNyzCRfUHGI7Q6gneA7i/ce9d2u9KYKnUPWLbJpkc73b6hO8VuHX7e4dUu37Widw6mPLsQjdISZ3R1o + UgUmQHsp7uwVc6NB1IrMgaVgFjnFpKAYVeTliCIPeykjchkhWUk3yvBzQ15aym1OdmWxzmBNFWcSmkHQ + +xrsOFipkjJ3/wl1F+5+xtOmPCGGvL0ceV9KjGSfaDShwSdN/41nMVTFQiAPBJt8KRQzQzkyVJmlwlCo + QbzFe0sXqycaGEXx2KmMsGNK6q0o57OxV+8kUroTz0MGUURSdkpMx3Taye2kzScHoIExKT7wM9IkI3Ua + 5drDG0mhiBWsFcQZdJohkwophU4zVhcTVk+3XDyv+Gil/Npf8DHPuRLPUh5gCos5nDB7r+Jhl9E0Gd31 + MbLpYLPifVbcEOcgfjkJwISv3SU4gVMCwP5b2YF/GgeQY2lYoNwjOIEFQpZ03E0BpgIZCzI15Muc6X7J + wf6E5WzOdLzHqNynLhbU5ZyqGFMVE0o7pWBO7heIq8AZVIO4Jxqbb71C62Hj0LVDtgqthDl7W4dbN3Q3 + G9rrDc26oWk8rfN471Dfon67290W73ejo3o8QIPipeQeGSscgDkRspOM8qCink2o6wVVPqfKplR2EhyA + 1ngMjXG0hYMsI2tKzCrDiGJKg5gMxMeZBDvhqf4R38ESOweQyn6Dh3yw+N2yplR28yaG9/FRSepZKS1g + 8HeRxLibXyABzDQlZDNDOTNUtaW0hsqbILntI9g3HDg6SLE0GmmqAvREnttv/du32zhtuFqRtZScXIrq + vrBuI3FE+eD9REGc9HoNSR1dJZCKtAIzNVSHOdwztD5ntS5YWUfjKtpuwbkueck1595wshGqTQ5Zhj31 + zNyWh1dK+8zSXRywffoWbXfDx1yw4RLPGuXiy1yBgpAG3CE4gD1CeXD9RX/wp3EAe1heMqfhDnCXjIWM + scVCqPYM9UKoZoZqWlDPZkzm+8xmhyynh8xG+4yrJWUxpcgn5NmILKuwtsJKhdUa4yvEZzuLSEMwiA7A + AVvQjSKNQBMHbTaObtvQrde06w3ttqPdgGsE1zhcs8U3W7pmg2s2dNstvm1Q51DXha9tC7RI3WL2Ouyx + J7sL2WlOdlxRLheMxnuMiwNGZkklUwpG5L7EOEvXOfBb1LSoyRBXIV2OOI+oA3F4tnHpNYMHPJXqduHs + 66jEsFafooEeSIvXaogN3P67hHgM+QG743iiAyi0T3eyWqjHhnFlqbKopadBG8/Gsp2JLcZDI03v6gcn + 8Fpj463PM/z+duXithJRSomGf/P6/loQ0V9En66b7AKdIb7iEw1ZCGXDicGc5BiXsVcbuleObuZwRc2V + v8u2e5tXZLzwhqvGUrQNprhBFiNKk7M8V+59WLJ+MWa9voeeb8n9Kz7mBVdc4PoegX91GxHmZ5wQQPZP + CU1Cnysd9qdxAEdktEy54hDhkBmj7I6R6YOSg3s1e0cl80XFbDJlPj5mXj9gkj9glN2lMHtkdhQbeCzG + ZGFAY0Tp1Ydx2sPBFK/LYeNAcoOUEnj3EbX23pG7js6VFF2LaxXdGPzG4jaebt3Srbe06y3tqqFbt7hN + g2uaUEXYbHDNGrVrzP6a/GFD8ailvCsU+xX5bEFRH1Llh4zMPhVzCh2RdTnSmoA7qGM4eXcY6IdW4TbQ + fSUPwzB60sxnO/iAXgREhk92euBvAXc77v4tDYHoDdI5hV+FPzSpxChBlCWI1whSg6kNRSWMCsvYhlJf + 6jG4FbEkkVWC8SccIvUl9Ah80mmIFjw09IRRDNTMA9Ovj1p2n4nBa26lDekqJlJTxDhUdz0FImCM9g7A + p7Sov0bxmhqQkSCHGbZQphOPedGCbdmOatQ/wG+U61HNRXfJDSUzu6LMzqGoMfMx2T3L5B3D3U8z2pcz + 5PoeXfMOK55yw0scV9GO/1VAMCOE/ieESOAjQnPB+ote/MfbFPg/kMsvOLSek/yYfTtinB9gJvcsRw/m + 3L17wtH+Icvpklm5x6w4ZmLvUuodjD8CN0E1I4F7kogipKZJj1eP975fDfsHicHDZMNoR83ig2biTBcJ + X53mqBNoLGwy3DZo0bXbDrducZsOt3G4dfi53Wzp1mt8u4Z6jbmzonhzQ/WwZbQvVHVNbpdYOSTTfXJm + 5L7G+PA+2kV9u9bjVENfgAldZ46WDkVwWBy7gdSxLTJOEeqvRETEdsSf3aM/nNSVpo2jQYHIq94aBjrk + z4fXKE58CHVN7KQUgUyhBFsapDKYSrAVFLlQG0uplsyb3So8AOO8hFyapCoU/6GPKnQHTqaRXD1OkT6q + 6m4VH6Qqw7RmELvsnKBKX/4cpkb99Utdhjp0wkn/d9hvodyqEEmIgJgBBRSFklcdvlNe1TXn7TFcW7pK + cNkLXF6j1kLegWnxuUP3G/LHyv4Hgvy6YPvpmI+be/yCdxGeEXCAC75EFDAsCT5gVxH43LFifxwH8P9G + WJPxf2dExolM+G495e3FEYfTU/LZfsFyucfx8iGn87fZr58wye9QmSWlzMmZIH6E6ghv8jio0qDqkLhi + xswOMyDB3OpeG9wjQ1CSCYmt4KOxifggk41BVPBWQqnRClIKZpyROyHvLOI8tB6/VbqVp1k72k2LlwYz + 3WLvbSgebqmPHONSqF1N1k2DArGfoL5EnaHzkgT04ucw4POA8jvBOaV1oQ9W1VOojxXRJCWye7AT6DUA + 8xlYVV8G64MBSXJeoVDunfR9AAl0G66eys74jQFrJKz8lRDmW1iyLCPLTJDBNlFFX02PR7h4nITJ99PP + BylFz2VIvJ9o7a/TrG7Trl/DQ/o8ZnDQJI2W/pMgmpIAzZ4PMBybPvjTFLF42DEd0xi014HV1KhSEka3 + z6BqLUWeQZvhV1NMc0BeWMqixOoisKSMxRsPs5by1FM88MhJw8GvhPn1ktI/QfiEUNr/6Ms6gDhKhifA + r+J+/qdxAP9PJOsYG+GEgvtMeFIcyrvLuX33ztvl4uTxWA7ne+zl99g3b7IwbzPWNyj0DtLOUJ8FFN6H + UVCqXa9nJ0kGpvfQAcUWp32r6y3EWAiKN9FrawzxXFpPJTw5EpGdwBTzIarIFC1CzmqFoPGuFm2FdiNk + G2idQuGxy5b8qKM47KhHSu0MZVuQNTW+q2l9TuOEzgdwEafBoWgwDUkNTZ2iDbRN6BFQp6ELMqJ8O3R7 + sPK/9iAmLb/df/RJuzGpJyA8/kFPw0Rmz24oiI81dIxHMkWyoHNvC7BFDPkrQ2EtpWTkmvXThVOorKF+ + EtuEDZKCfNmZdSoeiN8Z3o7DsKsG0IODu9V99//bj3V6vaBRizC4RzPENBJXOl2vz6sypPdLz9UAXBh2 + Q95iHDsJkugenLGsc+Emc2y0JfcdmRpqO6bMpliWwARPHpLz0pEtPOagxe0Lo1lB/aKk2hyRc5ctR4SF + /YIvkQYkwt1DQlVgTqAHf0Yw5A/uAEQpSrg3yvhJOeOH2b3sUb1fnxwsFkf3Hh3P757etUejezr392Ts + 7lB2p5j2EHELfFfivNJpg9MOH2VktHcAeqt2DfRLfk+8izdvCBIlUxAZ3uDAb0831PfH8GFmvVFMEpNI + fB4vqDWoEXwZfikjT7YwlPOcqhQqFYrOknU5psuRzuJcqON7Df3zYWz2oJKQzraLIXMGvgQtQWxYWS2R + GksqukchER0Y+s4t3qr3KzF39xK57yG0tb1QafjctwrjNhi+KRRbCFlhyAuDLSy2NNjMUBhLrhk2gpOB + RrsbIz4sSWpP+mVHWU6nODhhCcFRSE9ee7Y+DwPfGe3tsodo+HxJj5ABIPh52En6Oc1QIDq03TRj3aUn + w0cwBRodmFZhA10j3DjDM+N5nrdcV9fMi0tsviUzhowSQwnkeGwEVBUz9mRzpZhDPTZM85LppmTElBUz + PBNCv8C/yvBNJcE7cd8nkO7+OA4g/5+NdI0XvSC3a05H8KPDTP43i0X+08lkfjTW43yvepAdz94oj/QN + u9w+YuSPsG6C7zI6Z3EurPjOpxl9HUnttm9vjU9LLCj13Jy+/NUzv2SHVqcQb0Ds6+fc9SGd4AcK4WHE + lMaQORi+RAE87yJanXuk9Mg4jK/KMBQbQ64ZprP4zu4ij8GQsaERwA70IrXQuogFlNDVSpMTpbU1qg8l + BGowxeczFfLdGts3vfSrnOxYb31EEE8kelexEqTXS4MphKwI4X6eW7LMklmLxWC9iafuY/q1c0bpLAZT + D+Jv5JYTCPdD+18MI5uAuu8+TyBd+UEpYxgZ3L7HYfSZicrHiksdj695kaEKko+VikAD3KkZ69CZpfce + IptdMC3dCH4LN1t41ng+LBue5tesxufMZxeYag2m7K/HcCCNApoL1JCNlLqGaeFZGGXiDReUbBkRKn1J + 2/K3myWhDHhM6LidE1oNb1UD/k0O4P/x/zvi/zw5szfqR8DcZhxPMt5Zevs3R9n4J8fl/lt7xd16Zh/r + zDz2c/NYpu0DGTV3yXSGekPnt7R+Q6fb8CDt7my/4g+ZZ0PP2yPhicceq2SGpCQbe96RvqyTjmF8avBJ + tFfpEWqTymZOegEM9eBclL+SSGIxgU6sKOIMthNsjCq835lCWmVNeoijNSbVt4Rn4KITkPAg+S701mcK + uYRZtUYcgt1FAaTrE1R8Q0gjfUid6vkpvPbRW3rdNfdAQrolqCZlBlMGkU2bCyYTbBbasK0xQfk25ukB + mr09hzDZSWJ6JWZi+v3rI56H0UpywP08ws85bo/D9YcYgJ0Dlk8vTpoWEI1Pf1zJe65EOlaMkkKTkIZr + 4bVnhiLSX+tdpBGxiwa6rWG1FZ5vHR+1Wz7Ornhlz2lHl9jJDbZsUTG4KKI+XBAgSJhRgqmEohLGuWcq + jjFCTklDjVIS9AK+1ECgMhr+YXQGr3it3/jf5AD+r6NzUZgoPMiEtyaW9w4Lee/UT989ye8+PCnerI/K + d2SePZGRnJjSL8M4a1/ivcTVPnhmdJi1xgHcA/TKD0NGTWFjX0+6HfJqMvKw4jkh6PKbYDLWE0d+Dby6 + SXXf+N4DLayQG0v/APVrbapXy/CXu/PxElR+fexOsTtr7Y+TRhD0K5+TIKTRKtoK0kGXKS7Kf99+o9t0 + lj710WDMQzUcjdJdKfVR8XgTexZi04ux0fizkOvb+LvUySjGxLA6rKwOxeEGq/Tt/H5IEvSD3w+BmltN + Oen+sXMgrzsA+Myl3m2vs56gB0p3tbvbxxLdpWMCt0RPUtThzSBS8LffTpQwNKaRYPwtfOQ6PvQ3vOQV + TXZBUW0YlUod5wd8Ft7cpWlSghlBXitVoVQGCmexFIQovvjM3/6WLQ6W5zjuTwnlwFuTR3/n7a/+M1xi + 7A3dVFQfVqo/KEV+epBnP7zL7Mmp3t0/tO+UB+a7fl/flZm/awoZI2oJ0903eO1wKiiOxAfv21I0hviJ + 6yIhpItPeV9D7imsiRDzOWBO8vbeCC7e2DD9NeV00tNgJc2x6zXvBB/7/hPDzkcZ7+Eor/55Htal4s/e + DMLwwaP4+sPM8E89aCdoq0FKuz/kwGI+zzISWJge1HSslJ/HMN1H5p5kPvRdWAkgXybYPKz2NosTkEkG + v3tbBmF3coRGe6z9li2+bpv99zEi6RF33Z3ykK1nXvuYCaZIakvDkt5nmIPJsUanfos0JJ9nhuzStjQt + WQavV+KM8whceqARuq1wsxVetsonruNjVrywl6yLS2y5Ylp4ljZjTsWIETkjwpDYdA37clUY81iFAoEt + lcwqWSsY0syAjN/BAWQExaBTggOYEZiB/zYHsBYyr3oIvF2jPxjBX+xJ9d1je/zolMfLQ97KluZNpvax + n8gdSuZYbODXq6PzXVBBVdOHw2liLemipAsf71Rfrx3anQwejtdurpe4unkZ/FvkoCcln8FC6mPIaIYr + R0SFhhz71Ibfl6oGOaTsznjwfruTF++jKu9OnsrePv1dWNARlHhSnmC0f+jDyhRwCvroZIhw7p7moZH2 + I7wtkAkmD6u9sYK1od01tL0KxgbjN2rCrMS0eA5ONBxyNyrciAyuwu6jpHv6usEN1uXbub9+vnG+dqtf + A1J20c8wNUhhpKhEIFf790zHMAFsiNJmSSMxnc/uwUqLEqIBEN4K7cpwszK8aODjruFjvea5ecVlcYmf + bqknHfuFcCIlx8zYYxEVq6t4b1z/nCjxgaiAkSJl5F+QxqwMx5J/qS05gLvsqgEZg1Fiv7MDePz3WNew + yJR3Jip/WyH/4YDqvRM5Ojky3xnvyQ/NjHeYmFNKmUsutShKp23g6b8GWQ2n4hrZlZD6co0Mc7hBzj64 + N+lZ6IGu+PTcWhGUPp/z0WhgwH9P5bOErKdVJoYgQ+T4MwtvWsFk0OUWl3JBeglrn3LvwbnfyiAGNXJx + isQx8elcvHpcVL+8XROX/hxJD2liDQ9WU7GAlSCVHUN9Y2LoL4TpNFH2jNjZmFSEh911u3fdldeSE0gu + MBl/X7D9HGGPXRJzKzG47eRv/cPgEEMzEAaLxw6M3FVAok5h/Dn51fAHwzfTPlravWnUfVaNo9yCyrFr + FLdSblae5xvlo67jE7/iBedc5q/YTK6xy5ZyruyXwqkU3GHGHgcUTIG8f87DEy+7e5SD5AKZQU1GQH9+ + 67CQL9ost6sBe+xmjgFf0gFkfw++xhae8WbL6Qi+M0d+MqX46ZLRu0ccnhzwRjWXHzKW71PKAy1kJibC + qd67HihyCWlNLlbSo5MudwqMXkvu49O8M37tb14CcG6N2GbnFPoSYjRor0rnd/+m8UEI47Cjxj27ML4P + F9PpDkIRcYJ2gVzUSRj1GXjvsvvjeL7JJaTqUtLoTyGtjyKVqawkDdCFz9yKkuECruGChavE4RkK3qdS + QmDaJUPe4Sj0GgsmrvCZkdBqPLAkSZYbEfnU9//Z/lxu3bfwkt1POwO+beL6BQ/xMNz3Qj+t6Pamff1Q + Xns2XnOH9MGl30UosOsQDX0C2kd/qSokuqtchPcJ1zAj4EKuE9qtst141uuW86bhE9/yMRtecM01F2zs + FevJhmy/QxbKrCw5ImNPS2qtEC1RLE6I5dgwKi7c/sBLyRAkDn9xVIEwtqO5fVkHIARS0BGBF7AkcAQu + ficHQEaGskR5U+AvRshfnlC+d4+9B4ecLuY8KWp5h4p3ybiPkaWI5CG88S6gzgQgzydRxjSjqo/bUo1f + UxWGRBdNCVi/qqSVrk/yw2kaBhlo8ujxCenR4GiMTneLkbI7cKKuanIYJjy0qa9+MAAnpBetAas4EZr4 + lGTxAQ3vuUsDfKxi+dAC0EcETiLIF3W3tROkkyCD5qATaDMldy5kjmoj2SckESoa/pawgkgeDDx9NqM7 + wwnXNxi+lXjFBlHC6/hicsdf/ISlFw6c3WuPaH8Ph799LXpLX/3glckx9y/vXyi7qXk9e3CQo6SIIOk2 + vDaxiN1h4uIhPR5kowMYhpNGwXrBt9Bu4Gbtudw4zpuGl/6GT7jmuay4ljWNbGjLhnbaIIuOfGpYFsKh + t8xUyGIK2BmhNQZjhEzARJhUnIcNmBXotqDzli4qQSuh8ex3cADBLHaVgH2CDoclBkG/1QEs/jPSWsqm + Yy+DN2v4y7nyPxxR/ug+R6ePeFLu8aaUvIXwALiDMCOsgw7UBYqrphwnhDypXCWyE5lkSM9EdqlXHwgM + tfdfu9nx4Uiy1AxW8KD6mkQjBzXqwULUr3CqfUFrV2RjV54avt4r2oanyBuhTSlaXEIzJRJ3YgpBUuuR + W8MyPIq30en0l0KT7H+ImrJIPNIwRNLGN/OSESbKRmDCGMR6bC5ItusNGBoS0SBEE7i3QyxuGeZANVdv + /cPtLaVIu5t1e7u1/vc+ILqV13OqYcvi6wHgIJIb/iJNCfID5z50YOFWDVI6iMrI4bwk0574Y1NKE6OG + VEXRLvRsbDfK1crzct3xst1y5q85kwteySXXrFjbjjbzNCNFJsp4ohzUcGINh2qYeBDv6FRpEToxgTpN + GhZLKPFfg7swtDeGtlOCCkVDoAF/qYag17ecYPhz0rCMUEv8Ygew+DuMwliUk9LxVqn8+BB+8tDlP3zC + wd0HvF0cyo8Z8Q6GExxzvIzx5LsHrr/waTpuDNMTkh8fhmSQvXJL7/VvP1BpFU9ORIbPbp/Taw8ippgy + PU9W5PZDFf+s7/OOD3xv+INJO7dIICkKc4HZpwKShd8bAnEn6099UJ/X4PC8E3zsBVATyU5y28SS4fQ5 + bG6wNnDLc1eCBhaZasoNQ4ekGI9Y7bv2+o8yCKc1hsYaVYxk0DiRQutbyPpvSz1v+Y0vWpl2CkX959Th + OSXMJImTSHBmoX54q/yp8Wh938IAWxm2OKdnI1GbhxWGsGBEjodEGTiCQxaXeiUCNdw1jm3TsVo3XG5a + zrYtL5otL3XDK6651mvWuqKhZZt5tmNB5zCdZTyshXfyjCe24NDnVBry+Q5Dp2bQATrYGqG7EG5ews2l + Y9Ot6bhCuSKU8L8UCeizNyBAi3MCDjAl0And5zqAxX9GXMgd7mfK92rHTw6c/dF9yrfeYv/kob6VH8qP + qfgL4AGeUQidxcYZfNJrzg9X3D7EHHyEIWL+2e9ufwJNNdvU1hZDvSGX/xZ4R4wIEj7QO5j4YBEejk50 + N2RLkppvygXlVtbVwxdp3JUHZ7Qf7GqskBlwmmKeIQ6uMbcVErdM8BgT3sfE5vMht0C6eKu2ghTByG0W + 4ySJUJaa3VWSQO/rnWMCwvrPEJ2aiTnwgIgQ7o/srlHqvBTl8/2A7q7JEBIc3uhhLpEAymTs0Yj7hSIt + 3kZi006YnuR7qd7d26ZefWSQ3aQqSf/+YXVVI7ccm6iEsqWkFEbi9GPFdYpvQy9G1zk224br7ZbzzZqz + Zs2Z23KmWy5lyzVbtrqlpaPLlK4y6EIYL4WHU8MPS+FHJucNGbEnNZlUOCnoNMNHktKuGypGilvD6txy + diac32xZ6QUtL/C8JIj7/N4OoCRgAAeEKOCCGD/e2pbR+BXum5Dv/82RFj9+qIsnTzhePpBHxSHfoeb7 + CA/xLGJ43pAy6FuloIHHlxiap+duKNMkA0/xOsa9+xTSk2/UpFxvV4P2w+hieJkGYaXEUVxDxRs01fhv + h/m3U4toHMQoJAAaaBvsT9ehF6RVxZYR48AFwtFOOicePQyiQFx4nYkzBE0YfyzRnn2rcO3hRehCbErP + OnO4zGGyFjE2dPiksw3WE1bPAaKvvTEF76KSNPVj30MMv+S1r+lK7Jzf0KiV0EjlsQpZ7C3opc9fc999 + 5M9AfTctEqpBi7Gv9oR0R21IBY03QZIrllFTX7NEgRGfMIDdl52giIJ3Gndu6R0kCop6xTeK23o2a8dm + 07HeNKyblut2y2W75rxb88qvuZSGa2nZakejHS2ObaY0I8HNDKOl4d5C+P4EflJkfN9U3NMZY50iOqKj + oDOh+JvJa6XRFrpLy+V5xtmF8Kpbc8MZLc9RzqIDaPk9thQBLNnRgp/yegQw+zvEK7WB+xZ+XMH/dID9 + 64e6fPwWj8cPeVf2eJeSNxBOUcYRMkur2eehwMNN+5BaB8ZsUtifwu04uz4pvQ47tvqPk4Lk9Doj2Pg6 + 23f2DYgvyXFEZxPAuNSSG2fdx9w/5Se7x116IkmfMycvBmgzoPNGG6T0sY02zCQ0koVx5DZAXZo6U8Rg + JITyqiZ4IadBqLRRdO1xZx1d0dIULdeFIy8gKwQTabr9iicGMTmSFZi8QKzF2OAMTGYx1oavRmJ/fyQp + 93OybMhGEz0wVTMieVd3Fz9Z1q7KAHHc+g7vf/0J3E35ITYmyY5cIXbXdMOOfNXLdJOQGXokPyEr5vZb + ve6jwj12oR/AOY9rFdd5XOvxndK1nrZVNpuOm03L5XrD5WbNZbPlym241i1XsuXGNGyko40VBIfSZQTj + Xwj10nBvafn+zPLTkeWHRckTGbP0C0w3wzPCkQ9W/4H1e+AVbJ9aXr0seLqC56y54AVbPsXxEr68QvAX + OYC96ACW8eedAxj9r4hvqQ08yODHI/jbA8xPHuj0yRvcHT+U9zjgh1S8hecQRxlvc9IZiJN3kc8Y/hel + kX3ur7f54em1Rna8fA12Mag1747RF5eGgKCkysHAQPp6fHjwvIs1YelZv/25e5G+d1526NGOqdc/XHEX + xRXxsbeBUadxFHkmBmyYGmsyCXqDKviokIs3aGtCOXHrcTeKW3uabUuzbdl2G/7/tP1Jj2xJlueJ/Y6I + 3EknG97kU7iHh0cOkVnVzOpqgGSDAHdckPwGJECAO+74QfghuOeWGy4aJMAFGyiw2FWVmREZk09vtGeT + jncSkcOFyFXV5xFRldnpqYDBhmdPTfVekSNn+A8DB7w7QNliK4+rFFsotgBjNdf+BnEVppohdY2pC1xl + qUpDUzrmhaMuHFVhMJbUfBRFJY8UxYG49LVJlkzp5zaPBX9wF6dNqOlcGtUc308K5jF34iPGxPwaY0pS + xCAYjMluzZoC1RQEQp6VxuNJIpxaqXoEPp3ux0SRVk5UXk3TFq+EURmHyDCE/OEZ+sA4BIYx0I+efT+y + HQc2Q8vGd+zDwF4HOhnTxtdAiEoAvAjeCUMt+JUyuxY+vhb+8tLwN8uCf1VVfGnmXOuKIqwY45xAmRuQ + GZRgcvCNCmtFvxW6bx13dzWvh8AbWh64oeU1gXv+CZ6ffywATCXAM5hss+kdgPwDEnsaK3xuI/+2Ef6X + z7D/zVesvvyKz5vP+Suu+VdU/DnwAqXKN2IaSfxBlfkHU8uTc+wJ43+Edeavz1F4eSSeOPtyqg+PGI1j + l/iEcT9FlfzlWYahUY5pYAzx2DlOWeE0H56ed8L/n0qTScpa/1h0m3po2Q1Hj1ydtKitS7xisS4hSYMQ + sjCIjqBeoIW4jfi1Z9gMDJuBbtPTbnoOuwMHv6Wza3y5g6LHOI9zEVPEZGZSRkxhkLKCukHmDXZZ0Cws + FzPHs9pxWRZcVgWLwmCt4o0yGoiSASdS5M8ufTYGtSkYqDE5UExplCBiCMYwiqGN0AVhHC1htEn1SJOq + kViPdQFb+kQvLsAai9UCS4HDYXFYki5CjIr3ER9iume59zNBdENIASL6nNrHfE8zii+GdNLHEPEh1fWj + jwxjpB883eDp+pFu8AyDT02+0bPzPXsdOJiR3oz0RWCUgCcrRefST0UYHfQzJV4Is2vDZ1eGX1xa/ubS + 8dezip8Wc670gjKuCHnzpxI15jG3OdUpHnin8Gvh8OuCdzc13/gD37Pllle0vMwlwP+o9H96TCXAc1Im + 0ACt49eUREqEzwz8TQX/7Sqa/+lHsvz5l/L57Cvz1zzhv8LonxN4njd/yK/6rCY8T8unH+kPZrofnMY5 + 5c/p/vFpzmboZgJnTP///ADKxO147Cb/YR4o5uRYS0g1n4a0SAIn+vBJOUgwQY7lyAnJdsoOxGZOvVNs + lRamMaBlEg6QYJCDQfsE3ukNqPjMPRjRYJIL1Zh447GDuI+ErcevB/rHjm59+jg8dhy2ew7jltZuGN2e + aDtEPMYEjIu4IuIKxVSCVgWxqZFlSX3puLq0zBeWsnJclAVPK8vSCcYoI8qgKQBgHdFMAcCiCSaY6nBr + iFMwOOu4qSvwrqR1lihCH4ShN3RtgR8KonfJT0A8YkeofCqNiiQvZtVgk9sjTgqcOISUFfmojCF5J05R + V+AUAM4/zjZ9yJ+9D3ifFJ7HoMkcNgR6Hxj8SDd6+jEweE/vPa0fOcSR3gR8EYiVEguIuVmaehCk3koB + bqGYS2iuDJ9cOn5xUfKvlyV/NSv5omq4lBUuLPFxjqckSB6BH4VRphUXoVe4Af9bw/r3lld38I3vecUt + a14y8oZk+vs/Kv2fHgWp+XdF6gHMgIMDPhZhZQ1/Uwv/7VLl3z6Ji89fyGfNC/eveeL+a2b8gjF8zBDr + aZqdR1vpTRw3nJyCWvpejs2zqREUONXdylTLneURx3JgguTKdCjnE1ePaLWURusfbxrmdXrsLzCNg/RM + N0CPvzcJfthMwVWJqI2pwz+laiTUnHWKK7Iwpsk3MhTIUBHWBX1nGPxIb1v2VUtRdRQ2YFVQbwi9I/QF + vnP4PYzbgN/0DJuOftsy7NNHf+joDx3d0NKHliG0+NATZQTNVuUmYq1irSKF4CslzALOdzix1CJcj5YX + heGFs1w5Q2PSSeSjMkZNp5Ex+aTPH3Ky0lEDaoXoUpNSDWANakp8WbJoChaNYebgfhDu9452P4duhRka + 8ELQgd56OhfozYjXEcIIIWA0EY+cOMRYojUEa/DCcVIhaLYwy4o7UbN4DIQY8/enABBCwIeYNn5U+qiM + Ghk14jUw5g+vER9ToPAh3e9o9FjeRcmHhVHUCq621BeWi0vh8go+uYCv5o6/mM35qpnxadlwbWuqOEdz + zR+ObNYcyHJaaiRgQoRHiK8L7r93fPMWfrvd8018xy3fM/CK5PDV/tFD7p/wENKpf5EDwRw4OIFfWHha + w//iAvmfP9PZly/ix7Nn9i9laf8NhfuvED5FtQT1GSFnzk7kU3ROJ/iHWcF5B12PM9mTD930FNNJPHUT + pjrvfGsnnMBZAIhnqfkfuziSbTzO2v1q9FiinE8qyKVJ9v9NXPlCkUKTyaUkW3BnDEUhFKViqiwlO1rs + toRtTX9T0N1G9t3AwbWE2R1u/khZdJSqyOAIXUnoakJb4A+GYesZdh1j2zL2LX7sCL7H+55gB/xsRPHY + bAmuZ0RZOQdQ5ea9sdBY5akEfhKFL8fIF154hjDPJpoxRAofsEGPKT157JaL9COoKU0LUhBQJxkXK0Rx + xLJElgV67XiygCWROjq2YUUYn2P7a0JX0o7KJgqHaDgEoR1Gxn6LH1ti8MfArlYIhcWXhmCn6cEPWsk6 + ISjJzHo9HSzTBynADVEZQsp0PCTchU2bPObPmgN8aiSn/ojmn6tNysBRFFMb6gvL0+eWT68NXy2FP6sL + flbN+LRYce1WzKTBxQrRgiDuaCZyatRKFmJR3KjYByV+Y3n82vHbN5a/X+/59fjAG35Fx29Ijt87/pH8 + ///So8gbf0XCArTOwN845eki8q+fB/PTT+Ll4hO+5Kn5a+b2F4j7gqhzYujRkOBpmht+H/b6c6rMNPHm + A/baNB78YPZ2/B9nX06qMOfNxLM+wFQmIKe5vjn/u8ea/fSzqVmV5vucygtyR/mInyenDIKUgmssWhuk + EJyxFBRU6ig0CX/oqIxeGffCcG+IbwPt64HN+5aHw5qtuWVsbjHzR0rXUcSIGR2xL4l9RRwKQmcYD4Gx + HfC+I2pHlHTKq/VQpFGdGHCTjM/5bD1XUyFTSW2jzJaRjxbKz2fKX5TwM4GPojILqY8ekzYZxgds/EMJ + caapJZoVmbId+YRwyozUiIHCYr3DFQXzUnCFUjrDoRpQMUgJY71gN9Y0Y4kbClxXsR2EQwz0PjIMih9H + Ru8ZY6RD6Y0ySt7YedY0MUqipqlNEPA2l3J50qP5EqlJ/8crjEHwMRuRugzaKjhqRmITNNoYhzWKLQyu + EopacHVSRTKFUM8Nl9clP3la87OLgj+rHT81JR/ZBStzgWMB1IToCFO5e656ml+fEcUB5d5gvnHs/7bi + 1a8q/v6N5+8Ot3wff8mefw/8PUkN+J9V+58/DKkXMKECO2eUvyqUJxcjn300uuazeMUL+1Oui6+o3ccY + UyfUmngwySxNzlEmZxs/RefTOA/S7+oE3iGNrWWa9U57/vwlHlEwcvbsZ+vTnBa/kamJmk76SdbrPBhM + /YGc6CY9gAmyIoIaJdh0GkxCO6YQbG0wjWDqhMArxFFpQdk77N6gO6V9iHTryPbR0z/29A872oc1m/UD + m+6eg67xbocUHdaMWFUkCupd+ghJZDQOSvSeqCPRDqgdUZPACgkUYxH5kHd3Hj/VQiwFM4P5Qvloqfx8 + qfyiga8cvFCYcVJXOiLwppz6h/394zf5GsYz7RrlyBASjUng1ClsFVdalg0UJhLqA8zuiCYw2J4dl1z4 + gid9yaZt2O1r9oeGQ9fSdR1dP9B1A4euZ9v17PqBdhwZYyAQGYhE4iltJ/EngoE4sWQnbvUUBI4HkDli + FMSBZNAWjmNA00KSs1FlaCrLvHasGsdyXjBrHPPGcTFzvFiU/GRR8VlV8ZGruJCKOTUFNUpJVJfhR1NW + mudWEw6FxO0rRsHclIy/mnH37xu+/iX86mbL74dvued/wPPvSWK+W05F6j87CxASG3BJmgT0TuBzF7la + eK6uR2OeyVwviydSuyuMcRq1V0VFjMdaI+mEPl3d1M2cahs9Bofzg17klNKn2awmoMeRr36KGEcZJ1Ly + eQYc+zBGTIEE0ogoT1Z+WA7EXJtMJg82k2Bs9gpQB9ZFYqlQCqYy2NLhSpc08IzDRYsdDK63yFaId0r/ + NrB7G3h4P3D/uGe339D19wzje9r+ln5c40NLbMMxDTrtq/F0PybcudEkL2Y9uAwQEjnqJMhRCHS6IFON + KsRCMDNhdgEvVsrPF8IvKvh5AR8hNLl3FCbvPwSxEYM50wrkB1+c7mHIWcaHuM18z6MSO8E8gglQz5Mn + IE2AZkeYB/q5p6mUC2vx0TAMc9o2BYC2hbaLdL2nbQd2+5bHzY71dseu7Rj8yEik10AXfQLghJDqeTKK + c0rjLcm806WyLS03QYNJwC2bOBKmJHElzrIBKsE0lqJxLBrHVV1y3VQ8mVdczgoumpLrquB54fjIlqyk + oqIGLVEsw5RRquYm+RkqRk7nmpNkB2AfLOGbmse/X/D9Lwu+frnh+/YN9+43jPoPFPqSqLuUaeucEC0x + 9vm5P8y6/4kBwJEagCugc6KURjFlpJtFhkasOEwVNUgftzFIq1atNVKUhbU2UVBNHodM4hZp81uTT3gm + /vwkXJkT8IkBHPWoRz9h9+PUDzhu+niE/05Q0WOc+KPAAj1d6AzcgWOPLslrF5PwRdK2M06QbGtFDVIa + TOmw1qXhlHfYwSA7QddKuA30tyPt+5HtXc/j/YH7+zWP2zWHYc0Q1wQ2BN0Q9IDGkEU9DHoeASQe+ydC + miyksbvm9FUyOlBO7+Q8HZo2poFQgplDcyG8uISvlsIvavi5SRIwTVaumViYx9Ho1KBFEhbiLGtLvZAp + UzPZROSkbHQMAJKMWqRTtI+wEWQGcgF6CVFGWM5XdwAAgABJREFUQqGEJq38Zu6p6j2WFX68pOuWdP2M + figYR8MwKIe2Z7Pfsdlt2bdtCgBBGWKgD54xRIbgGXygC4E+ejzxWNMHqwSbv8+a/jETOWRSPCoFV5iU + 6RWShU8NZW1pKse8LFhVBVdVyVVVclGVrErH0jmWOObqcFoQtcDj8DodOifQ+HRtjwQvQz75wT1Y9PeO + 7S8LXv7G8Nu3B75tX/HofoWUv+GCO1YRhGSKMw6GtuvphgOjdpkYlMUi/ulBwJGagQugdcD3AnMLj06J + gtqgw8yHh7LVwQqxKLRclCxXVme1aCnJx91Mw25EskuqJHrjNOfUIyMnQzvJoIeQPiY0VcLnTPlp0q6K + xylAzB/6R9+rTvbUNvexjsjYabYnHE1IK8GUBucMrrBpMRQGW5LUcYzDqEMGh3QW2ULcRPxtoH83sH/V + sX23Z7Nu2XQ7NsOaXXtH2z8whj2BkclJWMQgZtp0x+7mGf777HSYBBBl2vT2+I8yjVbOUEqaEihi3vyz + C+HFpfDVCv6yFn5u4SNNh7AcWYdniOi8VgNKT2oxtcAoaeM3wFwTcuSDY2wKvlk0ZSoDZFRkUIieUBmG + ztD3hm4QDq1ntz8QLjzzqw1PrmouFitm5RPq+jkhXBF1gcaGGGsGX9MODbthSTf0jD4QfcyjvdPnwXva + YaD1A0P0eEm06lEiXgJeYqJZTyI0RjEubfyiNBSFwZXT90LlHHPnmFmXHI2NpbHJ5mxmHY2xFGKSN4Ra + vBqimqPg6w8X5zRlmtyNLFAMgrs3xG8c+/9U8OrvI795veE3/Q1vyl8y1r9k0byiEY/hEitJUr47KJs4 + sBkPHPTAwA6lJQGD/slBYNIcmgOtE/jvBUpJ9z2AStRh3oW7ZRteXw7jwxOC+agM17HUqwvHrLKUxmgh + VkqclJS2oixKhBLEEW22zsbmLrXNPQBBkjJn6tDrSYg1krHhGdBBzA2oo7+M58TUO52m015Pm19SBmLy + 1xMi0IGWQC3YKtlwl6WlcDa52ohgo8EMDt054toy3EXa24Hutmf/vmN307J5u2N9v2XX7zjIht48MugD + Pm7R3KhJ79WkTWxTj+HDbO2Ucys5PlpFsv+8JBXR03Y9l/fJmVMQCAUp7V8ZXlwYvloIf1nBVzZBvZqp + +WqSslKSNicJmARlDLCN8B7ljcCtEToLjQjPBD4R5SlQ55bvRNc+oiH1LKgr2dlI6YfIegePCo+9cPuo + vK8iw6Ln6gl8+bHlp883XK12uGpPUT+CXAIpbWiYM9OaVawZY8h27wHNoCDy7H/0nm7oaX3HGH2C+Uqi + zo4ajpOBQCBKRE3EWMW6tPkLZ3AuQakLZ6iNZWYctRgcBksS8CwwFPl7oiFoYvJ5zZOwD8heZw8Tj8MU + h1COBnNviF8X7P6u4tXfCr/++sA/bN7znf0tj/O/Q+vvaKodIgWWCiuOEKCMER1Goi/Q3kE0jNgsEtLn + bOAfjRHI2sPMgJkD/l8csz4JRmwAqQfdPnkYv/38vv3tz/q2X9vhet2E59e1XCxrs6grM6tLMysraVxp + ZqZ0jTFFgxQVxhZHM08rFmtd+l4sohYTEuZ9gkWonFB2mhe55rRKMnRwEq74QPUnlxxq81w1BwBr5ZiJ + GJPklqMDrQy2MpSlo3IOJyYBf0ZgD3GthPeB/t3I7m3P+mbH+nbH5nHPZn1gsz2w73cMuiMWW3B71BxI + kBo9a45OR3t+kR+k72fR4Bz4MDWyUmF/3GBCumap3xJRE4iFYhbC7MLw0aXw1VL4y1r4M6u8iDCfnHam + id7Uj4kQRxh65XFUXobIb4n82sKrQjg4YWnhKwN/lTOqp0ApehQVmXoqHDUeNHXWjRA0dfAfFF4eIq86 + +EbhW1V2pfL0Urm5g/azns8/brm63jBbLCiqC8RcgzxDeIqTS4yZUWbhTPiBP4RCiJ7BW4bg8OpPhiSa + /CLT1/maSUAz8SqtEUk2Z5l4ZUQoJG12l+dDR2mCjDXRI29EjrDxH5z3x9t8nFIBViVZAN5b9GvH/m8L + Xv5Hwy9/0/H3N2/53fAr3hd/R1t8C+4hqwNZTE5ljUBRCvPGEkOZ/kIvSLQMOCIHErW//8dmAh9mAKRZ + Q7rMotFgVKQyg7aXW//m/W332/V2t76V9uJZE16sFu56tSqvZoviqqnNatbGYh6CWfnRLnUs5xKbykhp + rHO4InnHFc7hbPqwUmC0BE06Z0d1X9IMWguDKaBwUBkoxVKYGjF1yuPl1IBCUgdYLRlYIakPcVS4TV+L + EWKuD5w4imBx3iGd4HcwbiL9g2e4G+hvRg7vWrY3Wx7uHtlst2wPB3ZjzyH0DPTgWpw54MyQwDiSOk7H + uu9srKbnTJVjY3SasadTfwI+Qd5gliNl1ahB1KTTzClaCMUcFivD80vDlyvhz2vhKwMfB5iNKe0/e0o0 + kggvHXQt3PeRV2PgNxr4exP5tYNXKuyCcOGEtYMCYWWFGYrLp+H52PFYU2SBUUw6EYegPIzKyxF+OSq/ + 6uH3g7IT5epeedwou23P3brn84/2vLh+4Orinrq+x1aPiHtEzDOsXKLMSU1re0rzckkZcHk5GJwmQLcc + z+HztHwiq6VUWc5Tx+kynd0iz1nGNoHIJtyJCojPTNQz/anpYJITXsSIwwaLPQj6Xui/sex/5XjzK/iH + 3/f83e0Nv+1/w3vzt3T214h5SBnaUKAiBDOCGRKtvRDKmbBQg8QCCYr1aY2MRo7vDB04Ipj+9MPki9oA + jev+kr4D/jvgv6MF/t/83/7D/4k3w/93Per4XR/7/WFsv2VgqdE1VmgasSW2doFitgnry5vNwyd3t9sv + hxu+cpv6kyJUjS0dtjEUlaMsHGVRULoSayrETAYHOQDEdLpoY+C6oHpmuVwFnjnl2iwp7KdY+yliJiTi + eAwA50SeqRwwhjS7bcDWecY7WGxnsb1Ndl0H6O6U3bvA9v3I9r5n97jn8LDhsH7gsHvgcFjTDQf60DMQ + GGwk2og4j7ED0QQMkoA5U0p4NnY8Eh9k6tpPJqfTlo8YialOjJagQrDpvViTy5Lc9Y9O8RWYubBaCZ9d + Cj9bCV/ODJ8beO6hnmb6E5EhJu7D4JXtoDy2kfdd5Psx8nsN/NpFvjYJanIXhF2EuwguCi8wfIbhmREW + 6FEePKbeHxOoRWzqpCdqgzBE2Cm88/DbDn7VwatBGFR56CPdENkdAvePgbsb+Ol1xyfXPddXLRfXW+rV + PWb2HoprRCbU6iJnrcfZHWAIUmJkGo/FnE+e6aEfo9TUr5qi8A8SMlKzOWSHo6nP8cEEKmekUQJqPGQ9 + RUuCM4vIWelQYGODbCvG7y27v488/Ep59zV8++7APzzc8Ov+17yTv6Wzv8HIW5wOiFapBDSRaALRjqhT + BIczFSY6jHcYjQlPEZVWhE4KRq3QsAffnk2Z/uhD8oWsySXAHzx6OkQYReROhI0YnBixEp0VX1iGAqTQ + MYby/fruya/f/O7PX3379r/pv/Wz4n35pBzKxpYWMxdcZVPKXTgKV2FdDXaGSpVYZgqMWYjr2sFXJcu5 + 47OLkaqAS/MC54TCPgVzyYewn7S/AvlUypt/Ur9Vm8ZkCZ/vkEdH3AnDPnB48Gxf9zy87nm46XlY71m3 + a/bdHcP4Hh8fiboHN6BFQI1J5YwxKZUUQFIjKDlHnMafxDOosY0n9pOa7DNgEi5BJtVgySq8JglF5gxA + 88JUCYwWhipSz2C1gM9mws8q4ScWnkSovSK9Evs0m48+MvSRfQ+bQbkdIm+GwLdj4GsiX5eR7w3cF0Jr + YNBkdrqLcK+GO2tZW2jVJKIWcnLrmQ5Rm8xLk615ck7yQRijsA3wLijvIrR54tEG5c0G/AG6B2H7Bu5W + cHPl+fTZjk8/ann6YsPs2S32YoWU12CSlJ3IEqRBpEKoUIo8URdC7pGcQOnZZ2KCoH9wIJ7GdeePFC/N + 8efnHhVHNJokPExyhUr/aJAcknLvQB3Gl+iuof+u4fE/Ka/+3YGXv2757r7j+3DH9/F3vDV/x0F+Dbyl + pM3P74kyJBEUG4mFzyAlwFgsBaWGdPB0DuvBaJHVoptkJB9SE/o/Uw58mAH8sd/43/9P/o/TVYwcYUgH + kkXxN8ff+1//H/438sZ+u3t5/7q+f/P4WXgdN3Iv3ox5xlrnLnthKKyhsA5jS9TWqCkAmzZLnxoY/hMD + 84KLLx3Gel6UBV72iH2B2J8ico3kzIGMDsvl6AkbYME4EGPQUfAHIe4s8c6i76F/HNk8tqwfdqzfbVnf + 7lg/7lm3O3Z+Sxce8bJG7A5b9FgbsBbEpPIFcR8OGWMW8pjSes1df8jCHKQmX56MmGiJ0ea1JUQNxEw5 + nhLUKesMk1iFgI+Jw24GqDthWUQWAlUvaIBDlySqtU8suH6IbNrAbRu5HSLvfOS1Br4n8LJQ3pXwaIXB + mgQfDsm3AFI8C9EQJkWgI5hFPuRtTwOeY4rMUTxVNWUEI5LbIIoZldgbtmPkJYaxgrsGXi+Un1xG3r/y + fPai4+rjLc3TR+ziAVs+Yst7THOJmy1xRYNNaxcvc4JtMmX5hHE4TajyVEl/aFX6h48paTov5c4DQbo3 + ESc2kcYAd+QyOmx0yGhg5xjvK7ZvSt7+Fl7+pwPf/PId37+54U1/x115w4P7lr38lijvcKZFneILIRaR + aH1eTwYJ6dRXqQllhTiLusSsLI0SW0cYDEOUNB6MA/pf1vmdMoAKqP5Z1mC/+v/8hgd9zb5vNe6jckC1 + z1zurGE4mnAcz5mMt0788jzqiqCD5qmAoD8zjIPhiURa1xCoUfOeyD3Ck2MqCpmVZxXrJkltjjVv7JWw + V/yDEG6V+D4w3Ho29wfu1o887u7Z7e7p2ke6YUsXDgz0BNMjZsRYnwxCs0fUMcDkUuOYGh5nj8eldBIN + EUkc/WOCkN67iM1z9dT9CyYe0WLTyEhiCgB+6hv0SjlE6r3ituAXwq4x3Ll02sZeGbuIHwM+eHbjyG0f + eNNFbnzkvUbubOSuCKwd7EWIYrFMfInTmeEkTQPmIlQZQacTcvI43j2+3YzvSMzIQqARaEwaLZmJF65Q + RKgHcB20AV4dhLstvHmE1zfw9nvls5Xy/Kln+bSnXrWUzQ43f6B8sqJ8sqJYzCiLhsItKJtLXHOBdQ2C + y69ragpZUncyovj8In+4D06fpng2bfoTXHy64SDGYo3DieCiYILBeJMUnDtDfDT0b5W7bwe++Try628G + fv/yhpe3v+M+fMPWvqGXe0a9x5tHxLWEJtItIC7AN4kHASW2qyh2M4q2IcYyu1IHKPu0d0LADkqhhspH + xgAxFvjoMub1T6IGz0uA+p8VAF7+/iWjtkZVS5SS5HbwYSZ2Bs+NZ1/9UXzzIQeNMS98CYg8onJH4Bbi + C5xWGOpsYpHzPpOifhyE2Cn+EOk3gf7e078fGd4HhgfP4bFjvdlyv79j09/SxwciG6LZEcsBIVKIJAUf + k9V1ZIIVGZKCmjlRYqdNftwMU5Pq9O2kY4hMKMcs3hGTFmySSxcwAZMl0SVfocnT0ESl6pXZLnIxeAoH + m7nh+7nhvctuVSOZ/urpGNmq59Z7bnzkPiobUQ6F0hrFxyR/7RRGlcncFkRoRHhiDR87w3NnuDDp946D + iSkYTLqKGdg1KS83AlcWXjj4uIBvY1afDCcZOJv7Nvug7IKwb4VdFDbR8N5Gns2Vy1WgmXdU9YCbtxTX + W4rnD9gnNdVlxfJyxosnVzy7vGLeLBFbJcENU4KpSP5ak49e1gI7Cj7IaZlOyRrZgVlzuXOcOMlZQDBY + HCY46IWwi/Q7j995hseB/k3k4evAq689//Cq51f3j3zbveI+/p6+/JagN4jsMMZjqoguleFKGK+V4dLi + Zw2hmCNxRrFfUD+sqB5nSOuIIRDpsLHDlj1SBkwRsaKUYaD0A14LIhWB4hR1/3gAcKQy4J+XAXjv0ZMg + /D/Js+iHr0lImHN6hVbRHogj6rZEuUPjHRLWaLxINzdOf1aJ2Z/Nrw3DbeRw69ndHdg/7Gk3e/pdota2 + 7Z59t2U3PNDFDZ492A6RATE+AZqMw5oUAHIz4bQ81B7pyXJs8MGkRJo2hj02jFQz6VmT6UiyHE+L0Igh + 5mRSjxDdU30dTQoAYqEMcNnC023g4iFQxkjbGLZzQ3TZwCMmWuxgPG3h2bmRLZGdJshIbxPuoohZ8yAI + owq9JjhJBJbG8Lkz/KK0/Hlh+cwZViR34ngu7T6hrWRCdUKCgqfT/6mFnzn46wLWGYR0m0iTHPIkyxz9 + D1LA3w2C9tB64eHGcGkMjQ0ULiBlj20C5qolvHAUn1uef1HyV5/fsXq+4mKxwFQz1DXEYoaWMyjnIA2Y + D0s2PTYRYSKeTSvJMkmDnza/Ecl3SRIIqCvwG0v3qOzvPNvblu3tnvWbPevvOm6/OfD63Y7vDg+8lPfc + FTe07j0qD4hucTIiNfDE4l9A9zyyf2roLipCc0l015iwotgvGa6XlHc15l7QxxFzaCljSyU9rhgx1UhR + DVRDxAeD14JAQ6TPJc+f9BD4pweA/xX/d6yxEjXIoGv9f/K/O3/m/zw4Wc4+n81IyVJQLhRYLYnBMuw8 + 5r7Dr0f2l8qm6pjZNfV4R+G3mOAxwaKxxIeBMUb6zjNuoX+vtG9Gtu8OrO/X7PaPtOOGPm4Zwp4xHBjj + gVEOqB0wklQhJ7ttkyW8ko5eTiE1LRhVc0r9c4dfpoJ3ughHhKQc0YsRhZj0AVX1LAgYRKa+8Zlsdob4 + jpmgUlWwCvDpqPzEwmpU+lZ530XuD8rOwjDBeUUZykjbRPoqMtiYyDIGrAWbYdo+17tT/CpFaazwiTH8 + dWn5ryvHX5SG59bQaPYwUElNssk//ezOq57GmU7g0sAXBWz1NJ3+tcKdJrXkQaAwKV0sYjLGkCyesg7g + D4b2UFB7g82yYsZEmA0MH/W4DXSj8FHcMnYP2OUMO5vhixlaz6GZo80c6gZclTI5CpQKoUSlmGbHJ8Wn + aAgxcwbOgZpKFpYR4mAY1h27d8rm3cjDzZ6HmzV379bcvl5z93LH3dsND4c16+o9+4s7fLHHmgGJIUmf + 1QXmCfC5ED8L9M8s+4uKbn5BLJ6CeY7EC4bVjOGyprhwyFwREyh8hfQzKtNhix6qFuodsWvxAwwU9MwQ + xgxM+5PNwGxARvFPyAAKiM7BUER6/df8n4d/4P+qA8N/dvNLFsrXQqGUhLd3DmdLClNRhorqMKMcatQ5 + +u2IvN2hN2vevehYXgum2PJC75iNa8rgiYeCflux30b2+47D7kC/6ejuB9q7ju3Dju12Teu3DGwZzR4v + e4J2KD538SX3b3M6OyX6x1TdoupQdel6HbtME6HhFNhSTDhGt1QPx4nnkGKCxKQEnDgOJ2Wko37CNGMn + mQ0NVYL5VjPhucLPjPCz1rAYDOvH5E23GZRtVHqE1gh9kWW+vOKz3t9kexWnVkWe21ub6vTKCnNn+MgI + f+Ys/6qw/HWZMoFFRhB6UlMwzcFzw9OkMaacXDSPC6ASeG7hL4spwMBS4GtJ0hajAj5xR+w0tnVps8UA + fWfQaOgHhyPiiBQSMBLQQ4RNRO7BLDwSRmTRI02LFAek2qWNXzdQ1UhZIkWJcSW4CrVVmkBFhwST3JcG + wQ+Wri8YR0v0SS9hEhjxEXxQujawexxYv295vN+zvt/x+Ljj8X7L/d2Wh7sdm82Oli2h2SDugDE+gYvE + QW2Rp2A+j/CVIp844rLEF0u8fYrap4hcgy7RsiDODcMctEyckEYdJRUqJVY7jBfM0INLtnQOg6HiZCPe + 8ican1MfwP2jA0ACoFoLWqVpaI9j5gcez59U/uDPWIEKZC6YhcHOC8pyRu2WNHZFE5Y0+yXlroFg8K1n + fLcjvLnn5rM15mqk0MCs37BsH3H7Pf3DyPqm4O7dyPp+z357R98+0rU7+v5A1+/pY8soPUEGoulJGLWB + hK8vMFIek72UjEhmM2Y+oVo0ZuONyWhOIpIRZUfLqWmHT9LfmSSDnFiAJ1TgWQ0qSdTjpICUTmUvMFgY + G5hdKJcL+EyUryrDV8bSVPB4G4jrSDhEygHuVVhb4VCArwxaCtEKwQiDEbwjyVuVQAVFI9SVoSwNy8Ly + cWH40hr+zBl+VqT6f5VPvRHJJhaSXtwE/jmSEiZ5lzy5yO+wAT62UIgyN8JTA58IfBOFuxHaLE9O3vzO + QlmAs4IZBLNPQaoySj2LzOZJjMM+CTQXkY+N8nRPUjdqFQqPsT24iLoRdS0UBVJaTGMxtYO6RIsKNRVE + hwyCtBC2Qr8u2G4qNnvHYYDBewbv6cZAN0b2fWDbdqz3a9a7B3aHTaIyDwNt37Pveg50dE1PtAOmCRRW + kZhh8RXwROFz4OdK/EKIVzXRXMDwFPHPIFxhZAamQJ3BlxF1mW0QLBItNRYviZxlxxHnCrCWURwFRcqY + jpgJm7OAP3gcj4J/QgYwcELuH6v24zbnj3kXC8mHvga7FIpLoZ4XzIoZM3NFY55S6TVluaAoS0wnqAkM + m5bd2wXdd4/cmwNva8Oqi9j2kXr/mu6h4uHdgtu3LZv7B9rDe4ZwzyhbRmkJticafwJoSsboa5HsrrXC + UOZa9nT8ikkT78RLMsQ4Fec+b/4INmbN/1TvH4E9ao6bXE0kHtVPU/dcsi6/ihDFJI7/hGmIaXQ3BKFz + hs4JMovMF5EXC+ELMXxeGp5XDjc3FFeG8BCpNpFnrfIYYS2wczBaIZpIFBhspHcwFOBLJZQQa8XWhrI2 + rGrL88LyE2f43Bo+s4YnRqhJB4eP4LORyWQecibTC1nbScwUAJLwhmgqBeailE6ZWeXSKM9RfhKEN96y + iTBI0qXWAIWkzKEcEk1bCpNGnrWyuFAWl47FpVIvldlcuW6UTw1cDEIRsqIw6b0rY4L/mgEpSboOMwO1 + Q4sCdakEML1gduBvhcMbR/+24P7RcdsrG/Uc4shhHDkMnu0wsOl3bIZbdv49fdzgGZNylICXiK8DNDEx + TosCaxNQSQqBi4h8GuBnSvgpDM9L+mKBH55C/AgzXAEzxJRJbekM+q21wqXie6XrDPsOTC80naUsSpyr + qWxD6cGpYOiJR9DUn+QJGFLs/cc9MrE3AJ1g1DHrR/ZHMOhZyPkgAFACM7ALaBaGRV2wlIaZLqnkEitX + mGqWOu+lIkExoULfVwz/MIf7lnXp+c7X7Mct5fB7xt2O3eOCzWOk3R/w45pgNgTXEosknyVRQJPIJMbm + Os5iItiYTnUxuQEnEYnxjMJsMoWZ02k+SVpbONpKHUk75pT9m8li/PT/hcnqPDX+mAQ+jGJiJIYkcnHA + 0llDrGDZRJ43gS8q4QsMz42hcimbahbw/EqY7Q0vOuXghUOEVhO7b1CXOvs26dZ7p4QiEYi0VFxpaArD + hTU8NZbnYrjGsNTUcNSYK8hIklBP44isrXgcmCd5srP2b7YKQIIQBAqn1FZ5KpFKlAuFT6PhXiy7AjoP + Q9b3E0lBwEVBVgIv0jUuS5jNlcUC5nOhqaEplJlJZcUMsFnbvZhCk5J6MBKRnuSy3IGUI2oHKBJ2w3jB + bIB3UHwryO+F/r3hblTeusjajhxiTx969qFj7zcc4h293uLNPh0GziLOJSl4KzhrEFtgTJGJaIIuFPPc + I5974ufQvyjYNw37cEmnzwjyFMwSNPeDFMSTsgdDwjG4SGyUbgGbuRL2kXCARVFQlwuqCppQUI2Co00T + EQr+C16C8k8IAAVgvECwNPof+L+opZpO/CncfBgA0kgTaaBooKkNi9qykIImFBS+xHqHiQ6MQ6tE3xQr + VDtD+U2JvJszOs87lEftKeJr8I8Mw4xhKAgSoejAdRmxF5PppTeJASQOrEnzePGYEBNWXmNWvE1DN80m + AZppnmnuneeYOQBMtttJjEROs48picgNzpMX4sTKmaYEJsGGsyW3kCnRGhlEaQsIjbCcw09m8JcV/IUV + PlPD3CYFWW0Sg62ZWYpBWY5KGMH7hMPvo6WLMbV/rCadAZtec7CJO2Es1EaYY1hgmGEoYxo3RlFGSYlj + yCe+BD3Bf0/A+KPW3dT+mDKuOKHvIlhN7j1LA40zPKsMvbGMZUYfqjLGkx5BJFUaSYQTXAFVIVSlUBVQ + FELpsipZhBDkiAL8g/7kFJtD7kYOgAloEdKprMAo2EEp90r5ELDvYRgN60q5rQYOcmBkTy8HBtnhzSPI + Hit9ylSsZM+D7MQkKRvUkNaWliCXEV549JOB8ZmhnTXsWbIfrxnDNcoKbJ1iq4SJ0YR4i5kOkjCiNjJU + KYsLtYdScYWjLGfYSihHoQgDLpaMFARK8hD2TwaBf3QA+H/wvz1fAR/Ghj82BsybnwbcDMo6151zg61T + 77tuA7OtpzwoogU9hoP1tDIgQ8SODtkagg2MJtCaEUuXu5wdqlXyu8/quOTGnpA5wZNt1tHbOy+MSWTk + yMOffj7h9U/7+Tg7zmaOkzTWpDB0DjtVpk0+8ROSerLopG00HZWZthJTg2nA0BcwVkKziny0hL+qhX9j + LX9hHFdqIQiDQq/KaCKxFHBJE199MsCQoNiouQ0kVEZoxJzAPJI6Ocfbo5LcaXM5H+DYOw5MsU+zJNDZ + nZ56JUfKXEYwaSZ0aTbWjALepHtkhNoaGpcxFe604YOmTKALyl6VvSgHC6PVpPnnYBBld2ywZk6rlyQ8 + pKmZWRoorODOaOHAkRcxGT1MNvTpliSHYGcDtUTqKDifmqa9RFrXM5o9g9nhzYEoQ773yelJbFIyNmKz + elNqYEaRlChVEbmM6NPAeKW0M8ve1hyGJYO/JIYVwiw1CcXnix6P5w5Z6SppQMRkPlMpplK6UhgKSygL + bBEwtqQwBS46DGUOAC5Hvj/++GfhAH4QAD58ZNaxacA2SWCxqIXi0lI8s9SN4WqvPHmvLG8dsp+z9xW3 + sedOtxzwae8ZSXDbjPAjX+iEBIxnRpAGCdMmO82pT9Evp+Lk59RJrSVDR880Cyboag7JGWY4HeZJDCOa + VKOZCeUXsoTslP4fWySTASZHbUSRTNSJ4NUwWIuvhGKhXC6Un9TKnxnh58HxQi0mCrshcteP3A0jbYhH + OmrM3ghhMjqRgDGB2igrES6zyEgtieFX5tuTFQsymSkJa04Ku6ezImUuR/fgfD+S4erZCHQ6EmTSNSB7 + MED0iSwlkqW/MxV3cngR0mhwjLD1kTuv3IXII5HOpACAS5lLcGk8GmxaXosAF1FYGWFZCLNSmCPMjWHm + hMalOY+JOaqdo36mtKFQmIFbGuoVzOeOuZZURrHJBAxvBkbpCMfNX2BtgTGSy0tz0myc7N1EwKbnjtcR + /wTahWVnag5+xRiuEqZF56QE+vwMnaBgxxllfr1yxPBpJcQyuRP5zH4VK4mvQoEh6XNoJk79KWTgPysA + 6J+qLabOQAFSJREOU6aTv7p0rL6oefas4ZPQ8PFNw+XrBeb9NeuHGbN1i2nhNkT2tieYcJTlNiZvxFxP + H2G6ChIl1f0xhX61kkNolsVBc6MuY/eZfO9S1JYoR2fZVNue+xpNTbApz43H2bfKJLeT4bQ5AEAGNh29 + ETRThzOISLObrgGpDOVcmM8Cz4uRF6qs+iQY+qiw9YGX3ch3h563bc8uhPSqjGS1XE5GJzZSuMC8gCdW + eGYsT6zl0hguxLA0hhmCVTBqctDQrK93ShTT4Sg/0E/P8fIIxz6TGppwU1nBOJEB0jWIGX8gZ8OSoOnE + 3wXlflRuhsibXnnbR977wDpEeqNMlVy0mghRFrxVnMBC4VKElYNFZZjXwrIyXDbCtTU8KSyXTlip0Fhw + IafomZ+RAgDQgFkp9YVhtipoQkkVFGstYhW1iYATRbOGwHT653U4Cf4FJrgklKA1xCtlfCb0145DY2lZ + MIyXhPEKDSvQ6mzEnC/ksdJKck4qeRKQBWulAiohFIbRGUYLzmpWHDY4UgZwqsz/ND7vnxkAwrQs/jAA + HBeFJN52CXYmzK4Knn8256c/u+KnzTWfrC+5ePUU891zNl8vuPi2pblxuL7kte7ZSJLJLsQjTGnnJLlM + TvM54rWPq/RYEE6JZlqhiTgy1QLTqX6qXnRKwY4gnwmiN2UWOZbk0y9OP5WM/svYyKkZhWZhz8kb73gv + kuiDc0JVC66KXEhkOSh2UO6J/L16Bi+87QNfH3q+ObS863sOIaRE5ejym42WRFEXsWVkVilPKuFF6XhR + WD4qLJ8Wjs+s5SPjuMQmya+cAYRsgJHX2TE7wGThlgnTP937aE5vUkiuSDZJXk+/OCEHyYVRgj0lmPeD + V950kVd94PtO+b6NfN9G3g6RxxhoNZl0hCzZPsV2L8mO3QjUojQW6gKqGurasKiF67nh6Wj5NBo+a9KU + 40VhuHKGmWYD03NN+SwXV9RCVRnKwmAydyBpEXuCeKKEVPpMmo1mgoWnwydl8AnrLKXCVWR8Ae0Lob0u + 6eqaUS+J/gnRX0NcIrE4nfDCKYvMtZGGkP0JNOP3FGqIjRAqYSwMoxNKZ8CaTFFO3ERh4gX8iwWAY2fo + eAgdd8x0jaegViksobqyXD1t+PijBZ/OVnz8bMXqcoWrr3jqL7jce5q2JjJnx5ad2+DtGmSHkZGjKvEx + 0EiWgE7gm+Q0mtOl3BkSnRLeyfYqpViSX3lSGzoj9JwTR6bM7MT+yTh4k9NwzaalKRtQMy38eDIxydnL + JFVG/nuqNtesERcjRRfoB+X1GLkLER+FxxHetJ6Xbc/btuNx7PDRn13gY7civR4XkCpS1JFlLTypLM9q + yyeV44va8bOq4Ksi8hNX8MxYZhnm6qas5QzjlKAOOZAeg+s5eJapcQJBjpT7qcZO9t2puWhHwUpkGA13 + nfK7g/LLXeA3beDbNvKqi7zpIo8+0hKJJgVhzeioFGtOeAPJY1ljI2RbNFcLdSNczAxPFpZPOssXC8PP + 54avKstPneOFcSzFUpzbWJnUK3alwRWSnlOOdiM5yOrx66kPMpUwx4if5oEpEM4UriPhOXTXhnbuGNyc + 0F+g/hL1S1TrlFFIyM+by1GTeCIaEtPzWK6akARsG0UrwZcGXyi+SJBwYzNlPVnY8Mf68j/cwv/cHsAU + 7gdO4mQfmp5rDgANcAnmylAuLLUraCiobcFsVlKvGsz1BZfPDHU/oyuWvBs23HHLKKSnlsmPOyPzjn8g + N6Wm9yrkFC9vtJhGgNP47Vj7TxZnZ917mRp95wISH7wfPQYA1GSbsamhlMqGtEWyb6ByFAhNmoUZKiwW + okECSK/I6NmPns0+8k2njEHpImw8PPaBTe9pB08IHqL/AcDobCLhIgyBoY90LayLwE1leFt7XjWO72ae + 7+eev5h5/rwq+Mw4rqKj9EIRJfcB0iOeveVTnX+KPblFkLQMosCYyyhzcgQuYsSNAh3sA7waI79qlf+4 + j/ztzvNNG7npla1Xdl4ZIkcmL7lXcjxejsKxU5DO5Z2NaYZYCvtKeJwZbmaBd1vL6wt4fSG8WhrezRx/ + VpZ87kqeiqMWm4N/OiysE1wBYgMqI0HHTDr/sM11hIMfc99J8j6ffUVMyvtPFb2GuBC8cwSdEeMFMSzz + hsh6bS5hKaaSVEM2Yp2u6wQVN3lOW0GsUwAYneKdITiT7dmTRInJzIb/3OYnVVf/7Ec4CwAJfHzeu4ia + TtwG5IpkTdhwEsnIoxNXGtyqoPyo4lMKHqqabx9m3HSWMY6odIk2qyEJi8YpvU8xaEKVHcE4xyhtcnl+ + fmLlFzmpDRNP83umk0bOwD3xw88x6wDkhqBKqtMw09hvOiSmJDiXHyRwkaoQg6QGWUi9dx8Gtv3AfRvY + 9nk0JuARRo3pvReC2Mm8LP8VPX1WNAloDulOhA5am5CAXaXcN4FXc+X7MfAGz7rw9Lbi5wLXUlDIdOrH + o8YOMdObz5oDR0gxKSZr1qDQkIOoaNa2I0lXHWDfwfcD/Icx8O/6wH/YB74+RO6GSJc1UwxZoqYALXL5 + mH0R0qXNnyPEoPgwGYgmQVLt00Qk9MJ+B8NGedxEbraRV9fw+tLxfgnbmeEvCsPHCNV0LWWSYE9lRy8j + AyM+y28ffRDOt8+08fO91pxJ6FLRJ4o+E/QyYTdES4gLNKxQFqi4TBNP5dG53R0xmZFC7pmgCeA0ZUUl + UCZ0py+E0QnBTsrckvwejpvhj5YAx6z9xwgAZ7K95DnG6adTbUqWs3ILcJUmTjUFhdYYU8LcwPM0b6+d + 4Wms+GwP7/Yjh3BgXXaMJuLinipLPx3VAY+Z+Xm3iuPmOCatGs+adJNTztTFSinYsYaZcO8yufPki3++ + 4bKw6WRHdYYOmvLU065Rc7QF9z59BB8J44gfO7phz6bveRgDh9yvpBSoDLYSGge1OBq1eXyXZsREIfok + FjIMgaFLdte9D4yiCRJcCF1vaLvIQxu56wfWOjIYj84jzqYNe2lNnmrkW6gCwWFyw3IKAqllose2yBQb + 9YwPYVUpokIX2W+E77fwH/vIfx88/78w8nUfWQ+R0SfUYHqrgquAWYSF4hZCU1tmpWVmLY1YmmipR4OO + jn3vWHeWbRfpuoF+GI7vvesD/c6z3o3s9pH7PpVV9xK5t5F7G/gLG/ncRK6M4qLBDAU6JJvznYnsGRls + T5QOIZHH0pY6kYgkZwIiIE5gDvpMCR9H/HMIKwvWYfwMiZegl+DmCFnaK0RcJ8gg0AuMiokeIx5jPepG + RjvQy8CoITFIjUWdRZ3gbbJ4Hw3Y3JQ2EjE6qQKcB4FjyjJRBccfIwAcx7lMfYDjIDyfSjZNA1wDVS00 + hTAXx4KGeVhQ2RlyYYjViJmnvt5qI3z2UrgZGm7DFY+2p7dDuhEcMASimONwTz94OR9Gacg69keEXiZ8 + ThCAyajDnIxMTp4H0/XTfNzJqTY9qhVPwYJTL2FKkScZ7ZhIOv0Q6QYYPPgQGH1H3+9pxx1t7OltRMts + STY31BeO5bLgsi64dgWXlCwoqdVRRIOMgu8DXes5bEe2j57No2ftI5sQaTV7+AXF956h7Vj3Hd/GgNUR + 66GYgRSBz4tkHT5BeyWmJpeeS5VPCz8HOJkmPi7V+iqSjC+9QVpod4ZXa+Vv15F/N3j+B0a+loFtjBQK + c5mks6EwgikgzhXzFJpnhutrw7NlyZOm5GlR8lQKrmOFGxv23ZL3h5rbDTw8tqzXe9abjsdNz3rd83jo + 2G16+r5jGwKDCBvreGfhe/G80sC/dSN/HSLPBktsG/qDYectGxPZ2pFBDjjZYegQBKsug8DyIs/TJ7EG + UwlyKYSPlfhpYHwG48IRbY2MF0i4QrhEXIOIxflAeVCKBzCPAlswrcfGlrI+4C469HKgbQZUR3wwWUqv + Se7MDoJVRqMMEnE5CxWJWI15lWfw2Ye8gClrH36MHsB5E3AKACcLYAOUilQktFLWYG+0YBYa6jDDSUVo + hNiMuNIjrTBfGp4XwkdquQhzXLwgxi1R16CKyVqoOinGQj6OTrIjacnmVJ9TbZ8kpk+mG4nbH09NxeNJ + ph+AiI7jHj2rgc9GY6nHoMeSXIJAkORd7yP9GDkMkf0Q6b0yxJEhtvS2Zag6aDzN0jBbOhargtXKcXVR + 8HRV8bSZ8dQtuZQ5C62p1OCCQYakBNTtR3aPnu1tZP1WebhTHnaBhyGwDZGdH9lqy1a2dB622vGdRtzo + cZdKWAQ6a/mJWFaW1CSLNpVcwf2gDzKlqgkPIOmtn8qeAbSFdm14/6j8bhP5uz38aox8L56t8YgoM6DW + 3HeZ9hRgnFLUQj0X5ktYXQrXK8OLpePTRcmns5oLs4Txms12xf1jxd194Pa+5fZuz+27PXevd9y8PXDz + 2PNuN/AYBjo63srARgPrTunngaIemHeBsnXYtmDXR/Ze2Jee1nYEDhhaDANGHUZyeq05+OdzQbIQrayE + +ESIT5RxBb6yxNhAWGDCEjEzRBIawwwBt4biLdibiFkH7KGljFuq5ZbSH9BiwLqB0QUGcYyyPDFURYhm + 8kPIEynJ7MqYSoE/pOkoORL0QP9jlQBjjiinEmA6BTNwQZp0gZwTSrGUOArNMOBsNx5dJDSCWQp2BbOF + sKqFi2CZa8khJj53xCb3XKb+zST7nXLnUwBIzrbHVftBmZC/nsh+5rSpRc9W+/npnn/HTD59cYp2Z8hB + Ixirx6QhBoidMIyG1iuHEGjDSBdHBh0YixY/H3DXyupZwUcvKj5+2vDisubpouLZrOBZU/OkXHHlrpmb + FRVFai76AF4JgzL2kX4L/a3l8Nqxeyk8vva8ven4bt3ydbvnddgi4nBi6XeOg/Z87z0SAl6V0ViCcXxu + Ek/AiTktmykTIr0xmaJfzCVWRhuaAThAv4GHB+XbR+U3e+WbIXITlE5jng6cJCtETi0dGcH1wEHRR6WL + nnU74NokTFKulOaZpbkYeEbPR/uI39VsdnPu13B313P/csPd5ZY3xYFv48hv3nu+2bbc6T2jvqftd7xf + Br5dwLMFXEaQvWExCPcxcpDAKC1RMoNU/QRw5oMMk1MiIJp6FqYRZAk6T0CdaAo0NsAcpU5999EgY0Qe + QW4E8xbcjcdtW4puS8WaatxS1C1xORLrkUEC3pbsxTJSouKYZPWO/fCsZmXFYSgyKtb+cBSoeZ/+KBkA + fNgE/JB5YNP8X2qQWjEFGJs6lVZt0ryX3DGftqwVtAZdKfYaZrfKRYBLFQ7RMVLipQA85gTMxeQgctzg + Z82+qaYlg1EmSGhWdjye7ql/aDPI5TxingKCnH+e/tQxaUgquWI1DwQEHcB3hm5UWo10qgwyMtrEWmQ2 + 0DxXVp+WfPxpxU8/mvHF9YJPVw3Pm5KnZcF1UbMqVsyra+piRWkdloBEn5pf0RC9QbsS3TbEdzX+W8Pu + tyNvfr/n16+2rB43zLst7/yctS7YdmsOYc1ed3zrOig9rlAak2TBqio1si0naPQpCE5oRo6bXzUBYUwH + fgO7e+X1g/L7XeTrMfIuKj1KkZt5CYAkWc3/1Pk32ausEOi3kUc3sq8Cd6uBm896XoeS14uBr5YDv2hG + viwjFxeOCz/jSbfk0/WK3bMlm8s975oDnxWRa1GWd3t+19W8ux/pxpF+3XE/j/x+aams4bB2PBmFtXjW + xhOkw+o4dTQ4IZ7SHjo2YTGnMtBlXE9FUjwxFqVCaYiS3IPVG9Qr7BS9AX2ryLuIfewpui2lf6BkTeEO + 2P2A2QXKmadxMZG7TIeXHtXytPPzzTlKllFmXYDsqXBcx8ea+F8kAHScHAun/XacsUoeS553KSXX4ecJ + ezQJ6aRLsJdKs1IuD8plK6y9Y2NLvJSQQsEpa2cal+gZQvFsdjXp+EU4Fv9WcnY0KfIkIRBzsunJ/oTT + mCdlGpJr+qQTrycc0flo3gthEMbB0g9C5yMd0JvAaEeC7ZGmZ3YVuHhheP684uNVwwvTcNmVzNRRdBat + hL6ObOeeseqZlR2rqmBpoMxzOMVBrJEwhydzuG7gynK99Fwt5qwu5izfLnh21/LtY8ur3YY3/Q034xvW + RWA/9Lzznu/GyIvB8MIZnjrDykChmt2BJwDWGUAqA504vmfQDsYt7B7h3Vp52SmvUR5calZVKlRBCAhe + Tw1ajZlJ2Ocr3yZ0YqdKMIoshJvHnmawfK8tb8cDu886+qXnpxYurVBXMKsvuWxWDKsZzy56ni89Lyrl + k991fPJg+YcQ+X4vrPtbbrs9oRP21nJ7sDwfAlE8N3bAy5hXQUG60j9oMJ8/JOM7nKJlanhrIZlsWxFp + iDQoBRoMtIo8RuQ2wnuFB4/Z97i4p4g7HDts32EPgbiP2DZSNJGyEqwMCD1J9MMdg0Ba0iaLk59O/z8x + AfB5r/4oJUDIm7/jRD2aRuEf/tlpdHL8kf7hrwhQKmYB1ZWyvICrB7g6ON6Hkp3UDLZC6FENH/zfIBwN + RSc5aIA4dfM5O/mPzb0TmEZJLjyaleGOun4aT7baOQ9OllO5N2A1DwwkY+AF3xuGg6HthdbDEANBRmIc + iXZE3IhrBpYLeNoUPNOSi8cSuRU2/chI4LY0lI3gLiz2yYHy+Y7rp3O+uGr4clZwnZ2WhBlIlRZcU0Bp + kw9i7bhYNlTPLFffN3z2nfKbrwO/7HeU+0Uqu4aB1neEEHgck3fA28LxSYAnx+wscjRtzy7OkzW7TAdj + RoP4FtodPG6V271y45U7p2ytMlqlMOklujy1dbn9EmOuIz2EMU0gQlDGmMhPYafsB6AT7nYDj+uBfe/Z + /nnkYen5koEXDKxKqK6fUq5m1NclV5eeT5vAT5uSn/ze8OzB8u8Hy69GuNXA3vesjXA3KM/GkUY8o/H0 + RCwFSoMcm2dZY+9kk3zqG6W9nkA6dRrVqXWpaZcDQNQK9TaJ3z4o3EbMg8fuRtzQUciBgj2FtthhwBwi + 7MC0MdnXaQAZUpRkgEz2me5NUpo6+3xeyn64zcZpz/5YPYCepD80lQAy/Sn1pLl05phqTJsnyjSDT6fY + JKWtJLyznSnVChZL5bI0XKij8SWYRHUkFwAy6b7nNDTmGyQ6UVZNjkZTkfnDjQ+Tos8k7pHGg3p8dzoZ + lapBRYkmm35aTfV+hpcTQbwhdAbfGg6tcBiVXj1BBgwdTjs0DGjwlD5S90K5UUwP/RAYtpG4UeKYCEe+ + UsJKic8t5ecFT7+o+fnnNTcvGv5sUfOxnbGIVxjfkC2FEhholQEmDTSXBR9fliwry7wXyt0ctpax84TW + s9572Av7ouW1he/KyGdj4LlYao2YZDmBnqEfj4uf3D/1oD0MB9julIeD8jAoa4WdQK9pVl1VsCyUJxau + RFlFoRzAD7Dr4b6Hu0F49LAPJlEwLJldqPit0t0Hul1PWyn7a+VQe4ILOBUqCpy1iL2keFZQWMs8Kksc + hVngfye075V2SFbjD/6BtbT4MHAIPSsCpZBBYSXCnGOnJ7G+0pLRiRGZTn4qQRuFWSQ2aZKjduraz9IH + SYlID5G4juhDgO2IHTscBwp7wNFhw4jxEdMpekg7S0clkjIUfqD3dzLLm47U848/ul9/1ACg+cmyqPdZ + BhBBx5QWag4PGpSogUAgSDypaB03aXL0MTOlWmkOAMKFGppQILEgSPJrnRBhydTB8KGeo5x9JSny5BRd + zfnmTwt76pRqZtWdUGe5kXg0mEhPopMMSgZzmSioN8TO4A+W7iAcxkgbBwI9QkehHTb2FGEk+oD1ETqh + eww82IHtGIkHGPaRcYh0PmHi+zISrpXyrWW1sfzOF/yWin9Dw/9sccFfiDKTi9yUM3mulmbpSajfYArD + wls+3xlk0xDWT2gPyrhJJ8ZeDHve81Zavi09n1bCcwnM8Mw18fo1ugSJmaC+OZMyuXk3HoTDDu73cNPB + 7Qgbo3SaB1AlFMskc/azWvm5CJ94ZdbCsIX7CN/2wm896GjSeesMZXZODkPyeojbBNK9f+Gxn7YsZsLH + y5rP2OCL96iYjNm/gFUJXxjKIXLRGT7d1vzF+gl+Gym947eu4LZ4y0hLi6c6DYlJGhinnDWtz+mMy4eC + COIM1ApzJc4DcRbR0oF1KBVRZ7kEyBlAq/AI8hiwhwEXWopijytSABD1ib/WkbzbD4qOmjJeGXMGMFXb + BWfnbUYunj7+iA6A5jfRks1Bf4zHeBYATnBg0snAAKFXhkHpfaBXzygjUTwqAXJHeKKjGhMpyoCdRco5 + ieXlhJlYCkkspygOn5V54jHyTX/UnOC5cExbJ6KOHDUA9Cgvrtk/LsaYHXKmqJShZ7njJUZQlySrxCYD + TzxoL8Q+ORH1B+j6yBAGgrQgLY6eIo4QRkYf8UGIG0NnYHSBtekRfKLQjpHglWGItF1giBHzXqm3wjDC + e+CNtexcycJ1XDeOz9wFNlxwlGAiD9jr/D7HdKIsD8JPdobDesHDpmD34Bi84mVgMB17O/C+HnhVwacm + yXPXKtSYlLllV6MpxoooxgvSCXEHu63y/hB5OwTuQmQvSZxEXMTNlNlT4em18NXM8G+An45Cc1CGGdxZ + eCJCJQY7GubGMJRgq5RpaRYq0A7294H1S49+69lceO4/GtjM93TungWSsfA1lBU8dcgQqdeBp+8NP79b + Um4K6qEijJbeBPZmBPEYM5HOJNtvT94Ck5jLAZEBo/GkGGwkZQDziC6U2EAsDEEcMVZEqtQAjAZGRbK5 + S7FXisHjbIdzLdYdEB3ABGIwyCBoq2iriA+YvI6TxNGQLkYubU0u11SVOJWt55Ti09EYOGXshx8rAIQc + AJJPsRAkMRISIS/A6OEwBrZ+5OAHxjgQbY/agSgeL5FeI6NEHB7jRoo6wsxQzAyzSpn3hto4rCkI4hhz + GXB8i+cAQGNAY+ayT5dCThOHfMGOEjKaD/pJ/06y1p3NDR45pSqTEoyQXGFiD7oX/AHGQ6TvI6MfUe2x + psVIR8mIDYHgFUYhDBY/SuLfG1Cb2YLkciIo6hU3KoWHZhRWCOIij0Vg3Qx8PR/5u6XwoikpTcUzsbio + IC9IhpoWJEAV4TI9p3ilaS3P1w1fPMx52Du2bcvh8QHv7nDFI74O3NfKu8LxSRF5lqG9MU9Do+YJlMvF + VQ/mIISNsN0F3g6BN2HkPka6kBiQVaU0F5GrF/DiheHzBn6q8GwE6UAvYDaHainUG+GyN9yYZB9mykz6 + 7BJeX3fKYxBe3iv3byLmY8/jRcv7heUjo1wGh9PrdM9sBZXBPIPZl8KzR6VaWxa7OTI03PeO28EQC5uk + ZNwjaJ8PlWka5BDN7n/isLLH+hETNAkVlAZ1gtZKnENowLuSUWtGrYmUoAbxETlE7DZQ7aBphSYopQtY + egg9UYe8GFODT8cIg8eOIfEqCCkzMT2YHiNFRtUqTkm09ihnzLwzVN6Hh/WOJCP5ozw0R5X0xMIghlJM + MlpAs/Gk92zGgZ0f6GKfxmC2R82IJ9BjGYhZ9WcgukisLXbmqBvDvIeZOJwUjOLorSVMhYOS2YCk+tzo + CaOY5/9xmkpMM4NsVZZ7WylDCLn+y5p9uCT3dKIWZ7x1SLJjsVfiHvw24ndpHj94T2TA0uGkxzFiiUeB + jOAtMViSVIZiNXfB8qlqSMo2lVWq2rAEnkThWixmrdy9HLm98sgzePVi5O+vHllYpZHApRGS9fuS1JXy + YAI5jwfAto6L25JPX1fc3xned89Zt+/h4S1FcUvVHDjMIrdVgs0ejDKfIL8mcwMmfEkkBbSt0D7C/T7y + znve6chaAz4m/f/SwXIGlyvh4tKyaBKzVTKIXBZQz+D5AuxOuByErYFQgsny4tJCUYM+CHdq+O1g+foB + 1ptAFw/cF5GNFUZ/QT1ImkGXDTiLzAz1pyNuD8u1oX6A/bris7bkm76kVYPaDrUHgulO/SmS0IuQLO1F + DEYFqz0maOZ3SBKCrYTYBGItjLZmjA0+1mlKowqDx+yVcqc0e2UxCo1CmUe6MY4pAExFNKTRSPC4EHBR + sTFiEoYHpEdMiRNLqUlPcTrEApIZDNMmiHAi7k0BYPtjBgB/9sQHlJlETNK5Bj8o3Rg5eM/BD3RhYCwG + gowYPEEDgYjHo+oZGJPMl4toCa62lAUUmiiPKhafpb8suRElp3QnQXVzZDA/EK+cqKCTbpRk9V8rZJeK + DGHWNOM+Qv7IjT6Sn2EfiK0SDsmOzLcRP3qiDogZsDJg1WNzuugjEJLld+2gsFCbZI4hKun9O1AnlAWs + KnjSCB9Xhk+D5flQYL3w0Ade3Yy8fjMSPlfefNTxqgh8hmUllxgO+bZMajA+fWoUnijm44LZx5anzywv + ljOePj7hpv8Ebd9jN3eUDy3jvOWhUm5s5H0ZqUykkZCToIygjAI9hD20W+V+Bzdd5H0MbExg1NQ8bGIS + 7myCoQhCjEIncDAwd+DKlHSFkBZRNYenIjwpkyZg6SSZLO/BNRBncN8KlbPYTnjZJYZksD2jDESNOYsr + cgSxYCPmQig/g+JGiF8rT79xPLsreTIKD7KlM6/BviMac+73gmRsiMkZZAI/VTlmp8ZztCOx7NFyRJ0h + moLgy+TrpzatmyEgbcS2UA5QBSglnjAd0SdtShXQkLElHsFjCLgphscJ4BYQYh5cK1YhHCXtpmMOflAC + TBnABtj8WAEAUtxqgQ3KTgOX2lNqm05IOSihU4YxIeEO2nPQgV7G5NBDJGnmnsZ1WakL45K4pTFgzmS/ + Jp+6qd5Xk5t2R4pvFghK8D2MTL2ADP87n5Pm3oAW5NM+N1YmlZeYgS9eoQtoG9A2EjslDJE4BqL3oGMa + G6lP70cn0lHaOIXJZhw1XNVpfj3PfZ1OYV9B30AxE64X8OmF8OXC8gUFz9qKYuPYHZSX+5Ff3XR8/35g + XI+sm5G17XhGTzPVh8hZEMjBsAEuDcWlsFzAVV1w7a656D+j8/eEw3vi45ahCWxL5a0LXNmAc57nQCOa + GrDRYsYU7vvHxLp700beeM8Dgd6ka11HsEEwLbhHGN4LD4Xwekj9ueBScuJb6A5wGJKNmSyVZgmrUqhN + fp7ZKfPQjfAUwzOJ9CFJoi2yDs5kRnMc0U2LoTBwAXINzQVcNMKVtVxQMteaoDVGy0ynDacgcDxLDCoJ + fRKpM0JSiDagrodC0SKm0kgkb3yX3qQ36CAZLqeJBq4Bg091f978Gs5pl5L6TzbmWj+3o4IkCbowIdDO + IUofjtZPAeCDfboH1sDjjx0ADsAaZcfIoEbLuAfZg6TuAHFU+jiy04EdIy0Bl9l9jshUBSc+cziB8Eza + mDrl8Tq5t+kRf6/yQaRLgTQr4hoTUwDQyeNv2hg5/5/IPSYHAi/oIGmKMeY2to/oGIitJxw8oQuon/AG + HmFMC0dC3m/pdYWJb24S3fWyUj5awqeL5KCz6gRaw16FTQOHBZgFXK/gJ1fCT1fCJ9Zw0Trs+wr/zvC8 + H6nXgr2Bx1tlWMBmKWxNoGDEHWfX0y3OqaBVaAwyE8pSmDmYS0nDFVafMQxPYPcOeTjQ1h23s8DLuadB + mElqdlsMGhXbGXQNw0Pkfgtv+sBNCOyyPFUlhkqSFBd7iDeJ8HbXKd9cJHj4toClQjzAfpf0Dw5zxRTK + aim8KOBFAVdqmAEu96/NmEBF88py4ZKi0RJHjcNYm+iFypQant5/mRqjtkp4hLkLzE2gEaXDolpggkts + umMZEM9gZjnzJEPEjYLzUClSdomgY6YsMzsVB4cODu0tOmTqMhEVj+oAcQAZkeO0CSCpVh9LLcuJmBUc + +CySmL3fkmej/mACcAaEOy0CnwPA479UANgAW40MjKgOiHbpptFBGCKd9+zjwJaBA4FGA46Ak2mKaTJa + MB6vs0ybcyLryHFoyFE6NctXHd2qjqm+5mPhTMDuA3z0WRYgWcQzKtoLegDtFB0CjIE4joTeE/pAHAPJ + aixgjE9d5MmFNoMw1AixSDidooEnDfx0AT9fpc8vLCwHIXbCQWFbQTdXZAarFTy7gBfLpOVn9wZGh9tY + no+G3SFydx+Id4H4JLBtlE3pmTEwZ8jXZtKEy4WlALUkerbLVQ9gs19k8DXaVpidpd/DulduY+SpRFpJ + rbEkdpL6UHGXob/7yMMQWMckcS6ZUFSr4HLnfnxIGdV+B2/n4Cu4dTDLg+SuS+njdqWoj1wAnwVhNzd8 + XMC1CqsIZUwprimEoklOR6YAKwahRKQGU6VdMzWIps1g02hUHBRGqUSpJVlbOzVo9pKw6tOE56yJNg0D + I5aYMfZiFCkUKQ1aQcz2bOEYALIhw+igM2gn6JB1GzQFAA2J5Zr481MASN0tzYIhR32amPXd/RQEzu3a + p/d5EsL9Qfo/YXZ2pAxg/WMGgPPIsgF6jagGRL0mDECv+CHQ+pGd9ux04MDISgOWkAAnYhOlNLvpYJLS + 7MR9EJ8bdBMWX2BS80x7Lo0Az2u4yblXmZR7z3H+Z+PD40WMSdwis9piq9BHdPDoOKJjzjk1nfaJKZbq + sYmfkCYPQjSGaAUzh/ISnlzAlyv4xRK+msNTK1RjGiEePOwNdIUSy2SVNXdKaSaorSb97CGNk9wg1Aeh + 2qcxXB+UlsCIR4/ovQnWPMVojpSxaXKSTosWoUXiAGNAe2XsofWwi8qBJBp6vFp59i8H0H0yLD2MSi9J + pdjE1E5xJHvxaYQXvBJ2qfjsLNzkACQ+9QA6A9u5MhyUxUHZPhe6a9jWynNveHIPy7UkR+F5pL8GvVJc + I5RS4lggXKQUKs/xPxyFyXECZDRJoltNjjpOU4YpYrCamn1J7evUV0pQcGXydxQToQhQBWIVGIvI6ARv + shqyFuALdChOeNlB0/ohlYxTBgAeieHUuOYkYJrUlk0WRjTHzZ9GSBMOQE8j6w8Iun+wRzfAlh+xCTit + rt15AGB6adOsvAPfKb33HHTgIAOdenzWEjEEDInjj2ReulHEJu03yQqsR7KOyPGkP5Zr0wF/LmCZBS1S + H++HRJ8/FgTyI9eQya0ld1i9ID4r05DsxEzMIgzTTJbEHfACASU4QRuwS1hcplP9oyU8ncHSpPpfrRD3 + 0A9K7NPmaHtl75VtH5mHSPMQsW894UZZd56XduAhBgYbaWx2HmZ6j/bsvU7fZ++cwUDvCN7gIwRNxXzB + Iw2PxLhF40CMMcUbPjSYmnTqOQYACJ3ifTqpnAUbBSdyEknKim3aQeyTLVivZ0lqXsTeKIcW+k7pdhF5 + FPQSdjPhTpXrrbA6CHEOjyth/Qnox8r1suTaLFjxDMdHwDUJBPFBFzw9okL2UkiORynfdDF5NZiJrzIp + RB21AeNx8+tEAjJKdCOh6ojViC8DwTqiyVbk6lIGMDi0iykDGIEYE+BHB0R7iBnYE7NLylEWjaOWpCGv + /ZgdXkIuMY7IzOm9Tvo8E1hIpyjY5o2fGvU/EhJwevj8xHc5CHRyEoVNGcAB/CHQ9iO7OLBnpMPjc6Sy + EjlHXR0zgFz/S9b4m+r/0+KebkrezBmjP6H2MnqCMxzwH3n55ymDQZwkAcbZaWIgUuSAMCblFk0L16jN + fceUARiNKfkyqSt7HlCOfG3LkWWMF3QH7YNys1Xe9JGHqAw1yKXSzIWrGLi885SvYH+jvBXP96ue+9pj + l5HlAubOMqekoiY5/BVn7zXrKLbAO8G/F/Zb2I2BXvfAPTXvcbzHs2bULhNgz1PMs8s43fEe6DLcO2aT + T5/DkJxl32fo4VxhTX3VvM6TrkBUsImciLTC4RHezZRDBXdOWQZhXgKX0L9Q5EvD808dz+dzPpNnXPMZ + BZ8BT3MAON/86SCiE2KXMhzvyTqyitMAMWRQTcqaIiFJvuUURiVij4CclKJ754lFjxYD6gI6dazF5gBg + k2RPD9pJBhPmVF0TOCyZ3eQAEKedn6DdOkmYT8IJIWcBwTLBX0/9yqkPMJ4FgDjdrW3em+scDH4UMtB5 + ANgC9/mP9EyQ+pDGZrGLDIdA2w3sh55DGBhcIGYkk4Oz2Gow6nJ2b5GkOZ0aITJl/bmmNZNqqh4nAHqm + 0yXHFXsekc5royzuEMkLPv1XqRVxMfkhzwTTWfSQNpHpwXiQmGbEEgPGB0wImJhODMm04zikGbbZC10B + D0a5AeZZQaFcR7ob4e0t/HYT+V2buPN9BWaVADJPfeDpw0D5fmTdBd488dxeeOIzeP5UWCwcT23DFStq + rlIaHKss2JlOXfaG+BbGX8PmV5E3bwZe73fchbd0fAe8wnKHaAsa8bGg0GQzkfyWJkTcGXgqX0arQhkN + BRFH9hXM+22CZOiZzLeRkyxk2kunu1QjCTW3T2SYzsBQKps5lEuluhKqjyPNF5FnnzieLmo+kac85SeU + fAF8ClzkcDPh5iU3IJS4FnZbx0NrOPjUfS9tT81AjIFJSzLKJPKa2O5CatRNwQoRolVMEZHCI248Csto + NNld2p2coINifER8RGPMiD2PxDFhNSaOSj5YNGNa1CreRAYlIVW9gE9GOCakEavk8apXwROJH5QASt6P + jySH9kdyMfIvUQLc5wjTJb3MBOGMA/gu0rcjh13Hbt+yn/f0NqS6SiwFyaoqkGavREcMFhtsTseS42tK + dJL8UTTpsznOSOA87T1nRB3p0x9oB2q+2HIm9AkQkTJCGZAmYgJEb5DewkEwrcGMRer0B5A+YvYe2yb/ + QYLHMGDjSCEhc0YM+wG+7xTZwaaAJ4NQPwiH98KrB/jdQfl2gLuYXH3tBmZVSvnfbzy2jxwuApuPIv2X + wvLTpB70pGh4ypIllxiuISzRgyFsYFgr/V1keBsZvovsfud5/9sD3337yHfrd7zx37HhWzwvsewTECk6 + ymiZR8tSEgzbiQNNzS+VZKmVLMeFyhrmAZqobDUS4qkXbaZrb/U4qUlxW7Jq8inwZ8n9tKCCMAzKmJGk + /Qy4gvIr5fovleefK18sLD+VJU/4KJ/8L4BlSr+BRIkNmYTTMd6MbN9abu5qXu4ND+MW9EDDBq97Rh1z + ZpLswYLxRDpE9hgZEMlalGLACuoUcYqxEWNCaiLHVP/H4BKNyqZrZU3AxYCJEY3JFDWGLONFQp2qZoeh + bCoTHfgi0FtPq5FxjBkDJNgRSq8Uo2JGxY/QxYmSm07ejDWd0v874F3eoy0/kibg+aPLmz/1ABTVMZ8+ + far/h53nsOnYbfZslge2VUdbjIkDkBOvhB5MMLAQSky0id0nA2pNXlgRMQG1yRBUjxpdJrmqTrOTvJgS + ZuN8XDjFAEm/PzECQ5YbTZ0hxIXMB8iMxWCRzmI6h4wZOuwF9nms4wP0AeNHbGypvJJWsGL6yGEPLzfC + voZ3Bi56KNdKt4aHA7z36S7tVYgD2D738LvAY+uh8uhlxPxEqD8pWDWWi65ksa4pXQ2UhBHGvae9Mxze + Duxetexf9hxeeg4vR9avO27u1rzavOO2e8U2vCTIDcZssDbgioqqEhpnuLDCC4QLCso8L4hq0snUQLwE + uxEWneU6Cnc+slXDGCZ59LNx/HQPNDMo9QRVSVVb8vQzWfFKXZ7oiCaT2SXwEdgvhcWXhk+eGn5aNHwc + V1Rc0esFqnWCbeTRnVUoekF2huFGefyt5+3vlZfvLC8Pyn1YE807am4Y2YJ6xjR/Sq5LmgKAkQNCl5tz + BdG4FASzG5IxWQlZgWiImtCekaTdZ8uIKwKFCYlYFYTgDdGnzFbcdB7lBrYRKJUwU7qZZ1+MHFTpR0V6 + QzEY3BQAhojp4zEAJEZeRD4IANrlAPA2B4ADP3IJACeQwYY00enVU9FDbNOs1+8i/ePAbt3ycLXhbrnm + sdjxlJ45zZGJhVqIBRKqrBwUwIRjCQDZsEFiDgCnTXze5NPJPedMv18mwxCSvHj6nOnAYpLEt4sJq2r1 + 6BmoJlEApZQjyhYM6g0UEfUO7QOxjUi0WK84CdgQIYzEQRlbw2Zr6Qphi9AMimkV30W6kMKyN1mrJCSj + ShOUsVcO0ROqkXIBq1nBPFoWd47yYBiNcO89+2FLd3jLehvZ3VkON3sOb3fs37S07wYOtz27bcuj37KO + 93TmFq3uqModZempS0ddWpZzw8Wl8KQRPrKW52qZqUViVk4WgZkSn4IdhQsVPjaGw94yhICNhi4v5uPm + V1K/Iwfg45RdU/fGq56mtS63sYwSnCb/vrlQLYTVzPBELBfbktIv6WVGj6HXlqh3ud5K66EaLfWmRN4L + u1ctb3+/4+WvA69uhLuhZW/eMJjfAi+xbLDErDU1ZTA+G4L2qAyAyWPAE/1s0kj5QCslpjJGM7ZbCsVU + YIrkI6jeokOZZqGuRMaE2BTvk8lKadE5hEtPvxo41JGWAu8dMhbYscB5gxsVO0RkiMQQk7QbkZAb6xkQ + rJriwiOpBFiT2UQ/dgCAD//QPZEZPY4D6BbiGsbHwH7dcnd44I2/4QVPuOaCORULDHIc3+TU/ejJd36S + TP88jfxy0NCzsZfEo2vQydUldeGMyWQeSRnABAmOYhKSqyD30ORUy2kB4rLtc0RcPIY9VZMynYOg+wCH + ImH8MzIx2UZ58ELsLKNYdgh9iBBCSgezOnEpiYNmSDWeeGEUYZy0FRHco6H42iDvoA2R9+3AYbNh2Lzi + fttzf/iGdh/x+xa/PzDuWsZ9zzj0jHHAuwHTjCybnrrpqGulqR2z2tFUluVMuFwJz1aWZ84mOnb2Y0gB + IG1KgNIol06JtaBrg20tKw97r4QPpjERH9K4L6jiUzOeMX8Omn4/BiXYZAEWbLoX1iVj08VBuHpnmBcl + w82cNzLnTg2RDaN+R+T2eI9MFJquZv6wRN5VPL72vHqz5fXNnofHA214ZDRv8OYNQR5IPs0pe1QCkZjZ + qokp+EGj+Gy4IBmZe8SfnD8mNyMraG2IM5syHC/QV6AzRGbIYJFxQEOfsCO1I1wp/olnuAz0taPvSggN + zteYscCMBjOAGSNmjIgPqAZSCBhy78KTu4pDPpgfSKX6yI9kDPLDx5j/0HvgPZErRlZ0CDvQNYTHSLvu + eDiseTu+540+4YU85ZIlFRWl2Eyyz+F0jAmM06XmCsWE4CPDdEHM5EY6jUVOJh0cEVKaJwtysvuSaS5M + FgdV1GmGc6bAotEQY4HGZAU98QuY7MENUAs6h7hIMFUpDMGX2aAo12Mx4rJGgskRzGdHomRznmfnMhll + 5MxDSKYPRUot3Rr4PQzvAhsz4ofIdjdi1wOHzYH73Q3bweJjxDHgzJDr1wFTj9RFpJobZivHbGlpZpam + cjSloSkNVSnM6iTIet0kgdBJvTdmZiWSL/cSrIN5CXauuK1QHyxPe2E3atrweYMEHxl6wzhGBp9GjH3U + 9BFgiMoQlCFGRp+uv8nEIzuAXYN9qegAh1fwphJuUNA9qh3Ku0SvklSimGhohpr5eoW5n7G+g7frAw/d + hj4+Es09wd4RZJs68DiECqYSIDOVzjUlT03lDEibJm4BCCepeZlSg0lXwghaWeLMoWX6/+IrhBnYGTI6 + JASiduhc0FlBuIr4a49fWYKtiP0CwgJ8g/UFxWAox0gxRlwImOgR9SQxtYGkwjiS3Sx6UpN+Q0r/I/w4 + 9uA/fEzTgJscBD7WwJwOpzvQRwgPSv84sF5veb+74+3slpvqjqdcMqNOymbi0ukdFd9Cv05ac+F4Mp9F + 4gngYxJJKM2ZMkpQSbrtAJKlvY4SX6eGVMoM0rBabL6jcXILOp/ZpbAvRxlxTt51jSAzg9TpddrBZFWy + kDrIk2e2JjudNEeOiEnEUycp9ymUoxPOCc8liLfoXmFQ/J2ytZ4DgU0UCm8wQ4/v9wwjxKgURmlKpakj + TaPUdUy03BnMLhzzC6VZCFVpKa2lEkstltIaCifUTpk5qE2qpeMPjjeFFLhm4AqlWAhlL8wHy4vB0I7K + 6MGPEAaScnGrDH2kH5XBK11QWq/0PtW3/ahJQHWM9CFZlkefEIeMMO6Ux5vArhqxrs2b06AakmLORP2W + 1NytY0kz1tiuomuFzTDQaks0O8TsUDnkkdmEuc2jNEkoT5UpjZ4CQEabTvyOyaHMg4QzdfnJ5icHALXJ + zivOE4YhobscaA3MkFgnUI8NaANhJYTLSFxFtKnQOEf1AgkrxDcUo6MZoRki1eixPlvG6ZA3/5A3fyAP + abec+nPddPv+JQJAPAsAb4EvCDzVHhd3YB5B78HfBvbvW+6vHnlX3/Lu8pbnxROWzJKsEzVE8INle7A8 + HJTHDnqT4IVGQurAH2f95vi1ZoDGpDUtUc++TTck2oTcSxqAqYlzshfzqekYOAYWsjuQEI9SUDrpBEx1 + SXZtlZlBGkF7hRGMBhxVIj1Jh0oiCyUMU+p8W1LbwalM3I+ECs24EKJgvYUhLc5gFG+VYIXokvtPNVfq + eeBSAo2JNKXQNIb5zCTf+8bQNIZmZqjnhmphsVU2lVRDERxlcEmxGcGYiM1ErcCHfgvHFHiCVtTZ/Vmh + isJlAB+UkAOAH2DsDEOrDL0yDikATBt/8DCMSj8oXa8cOui69P2Qg0G7jxz2kcNDJJgRKz7VlsCokVHD + UVQmSXYphU1eFM6mdeFtJOhE6fRZZSeJwYpkIVgCkRGVAZEcuMkksjMC2SQOK0GO9mjHg2e6QJPzrwVt + lLiKxFUgzjTVen2FxDnIHIoanVnCtSc+9eglaOPQYgbjBXAJcYUJNYW31KNSjxE3ZjJaCEQ9Cv7mwBY1 + 78c7Pkz/+ZcKANM48C3wGnhAGempdUMSS1xAWCndZc/jYsO7+pY35Q0frZ7wRJZcMKf2irSWrnW8Hx3f + Am+MspUe1QRZFWJKrSaNvmlFihwtwCUmk05iwhhqzFODyXdd0mmuJma755Q1qDdIsGTGfmoGmhERn26w + JBO7aSSWofQwE+ICZAaxjRAi1jtKapxocoLFH30NkOzoqgYXJanrhHSCq054rsmiMlmqWWupKsHWhrIy + FJWlqB2zWrisAk/qgYvSMyuFqnJUlaPJtX1VOcoyeTFOREElZUnWW4y3mJAW+eRyHH/oDnree8lgnpD1 + Eow1WJtovFUu01RzXT8KY6/4IUGCfQAfklaED0oIMI4wdNDvhX4P7UHp2si+C2z6yMMYePSBbkzNBAkj + XiNjPu/6E24PITK6SF8HbKVYl7UMJku1kDIsjMHahPyLokTxyRPgaAmW1pVqzjBzj0lU04Aob345lgCT + evIpC1CrxHmEa495OhKuQB8EGQpMmGHcktgsiE/WhI894eNIvLJQ14hZIXIJ5hJlAb7CjIIbRuyohDGm + YBoDnlMGkDS24oGUib8j9eV2nMEi/yUzgFMAIKN9d+naSQM6h34WWTd7buZ3vFy95dniiiu7ZKFzinaB + rD2328i3MfK72vOSlq3bEc0OK0PqwxqTAoAoJqkhZAtwe0rRJ0nraE7AMKNplGUUdTEr++aJQEglRYx5 + HmVJQdMERHxeDHkzTIQRQzK1bIS4NLCC0CpxECRYXKwoUUxepnECJB2Bi4qJcmosZdCCsYqdvAYsVJUw + nztWy4LlomA2c9Slo3QFsxKumpFni46LZqAuwBiHsQ5nLa6wOJu70GoIQYhjVvjJQUCyV4Oeb/ojkvK8 + BDihAzVKqvXHpKVsUlxLjVabxnquAFtCUZmU0sczqYojIlCTuEZvCHvB74Vur7Rt5NBGtl3gsY88doFD + 5xnbkbH1tKOwDrCJ0BIZdSLFnnyOk1r0We/YCDZLyk1S9UhyR1bxROlR6VPvJA+pIxbN2dHREGQqAc6b + gKogIUN9Q7qWTolNhEtPeD4QXoB/LNKoMMwJ1SX+yTX///b+Jdi2K0vThL4x51r7eV73JeleSf6Qu0dk + vDIyq4qAyjZtGmAGhoFVA0srGoAVdMCw6tCCDphhBoZhQDWgCiqLzKQFRqN4dDKpfERGukd4eDwkl+TS + 1X2f136tvdaacw4aY86117kuucs93F2S+51u2+/VPefss/faa445xj/+8f/tmxv6txP9/UQ8nZLqM0h3 + Id6GeILEJRIrfIj4ENAeuh52IdGkQE9HyhYdFmJZAY+BhzkANOPN+ssIAHAgHTzjwAq00dqdgWTxXNEl + 6FHg4mTNw5NnnFQnTBdHxGbB9ZMZ8tjz8WXHe9HxcN5wUZ0T5Bzvt3iJqKspBp5kAo9knfqi/+ck5Vae + fegkl/U9TeOuAHmlVShZoVjF54EZGabfSDntH/n9DSBg4RhMFT2BlOce+j10vWOaAK3wWiNaD2rG5Nsr + kuglos56gOIFXwnTCUxmgp84/BRmC+H0pObOrSm3jqeczGqmrmJCxUzgaNZzcuRYzCt8pfn9HsxOBLOd + DsHS1hQGoDq3Vw+wvWbGm7hsuXZgUo1YVfmQG7zsGVqtzim+Nl6Hr3JgcQpVBkHziLRkhyYyfitBYO/R + vRBaDBvoEk1XseuUTRPZ7yLttqLZBTZN4qqFVQ/bDvreBERDSHQEmtjThkhMCanATwQ3NaGRmQp18BAm + 7FPFVbGcu4H+j4xo5XC9hrNl+ELOCjT34DWYok/BmSpgmUj3IuFtIznt5g7aGW5+i/Dafbq3At2DKfFW + QGczot6mb18nbW9Dcwzd1BiASfHJ2IUhRroU6Ojo6a18MdXggNX9j/OBfM3IIPCXGQBK5DnPjxVGzq40 + CrERdAV6ocQj5Xq557E7p76c003nvGim3Dl3yPOGF1dTPgjKVdXQ+TXCGpHWTjGZAjZWWVR/7WDWvK1y + u8pnZB+xG7X3hx4t46msHEgyhqBu4FHbvZ4yszCTPbR8+uW0FCOv6JFNE/YdNI3gAvim1IyOOk3xSfCa + csLaE3ygrxSdOtysYjJzHC2EW0vH7aVwNPNMZmauenRUc3Y84Xhes6gqJuqpYnbkrYR65vGTyoap8vSY + Bme+85n1GJPm1J6MpTDgGTekpT1QuUyEUutRF/PUQYY5XwefU2/RnGVn0Cw5G6Kyi4hmirTkz8plb3Dx + agNfVTKn3bnDRbtJ5+o5StB30O0r+ibSdZ62jWz3ic0OtjvYbWG/Ufq1sN8kVm3gReq4Dh2tT/gaJkcw + vQunR467oeJoXdOvap42jhA7Vtpa2BcOyMdhp+f4J4MtnZZrkwSJCRcj3vU4tYdqRGIJAgJnQvgGNFMl + 3RWafY2bnRLvBPq7Ff3ZGWneg0zQ/oywv0W8OoHLGW7j8V2kikodlSomYgqotgT2RPZEugL+lX34LD82 + vDQe+MsKAHDgHj/Pj9eBE01IaMGtxaSRF0o7CVz2G+TZcxq34Fk357gRfLOj6SasUqR1LY7WLL6TQ1Od + k80ecQGkNwKPGlhjMk6ZDOQ1D1SIbQIEDTZfLNlP0C5LtBkCwdDY0kZMJsQgyZsnGyPzkZIWRzL7OMHM + uAuxc7Rtni2obMov9hWzOGMqFSIB7zrqKiATxc8ScgSTI+XoBO4eO+6feO4fOc6mjtnE4WvHdOKYTSqm + 3sQgfYxIyKClGM009N42chKzDeuN5YjmoJjxD610UJYZcFRsKg7sPUnh5+auiI2gHoaqjMaaLO0t8xgl + aGIc9fK7D4McuY0a88YvqbRPQ5ouXpHa+qLOw8QJkwCLVkjBE1UIydP3SruDdgP7NbRX0F7A9gLOt4FF + 7zgXZwFgqczuw+Jt4e6p435Xc/J0wpYaF+AyQpXNN1Ou98t9JEVsQ5zNM5TyM8+REEA6cH3E+YBPXQ4A + PRJing0RdO6Ir8N+Dt2dhN8L1HPS0R3ickKsz1Df25xJWKCbBelyirvw1CtlsrfWn+8irushtKjuSGyJ + bFH25IO+dOSe54N4aP/9KgJA5NANeATcB2Yamca9kYIkf7DJKW3sWa13JH/BNhwxDxMqFGVufCbtkZRI + wRFaT9hbGu4niXrZItMVKo0lAmmO0yMcs3x7mrKQZsDLsoFy6pnqazn9jYaZSUO+6L+LbX4qCzrFG28M + jJFvbMV6ZjNFzwzkUi8w88R1Rd9AFzxzAouqZz5T5vPAdJmo5onpQpgfVZydVtw7q3jtyHN37jiuPBPn + 8ki0wxcHmJRz8CxrGFFCElLv7ISPggaxP1Pekllr0QwMcxcjlW6GDGl8jhaHOJc5Fwe/BHfoc4sOP35j + yidbq6WxPkXBEXOIGDZPCQJYWWAqyfaZOMlKzKVromYnjveGI7QQ99BvlW4F3W1he6mcbOGkV17H0fuE + X8L0DVi8CbdOHHeaionUXO48LzbKsqmoU0UOrfnRU4RnpJCM8ySgBUagF6Qx6TO3Bz+LOHqc2xOTjUsa + 4UxQ79F5ZjjOkql8O0EnU1It2U0o2JhyqJF9hV85quvEbBWZbgP1tkc2HXHXEfo9QbdEViRWKFsyz6fF + 0n4j5VkAuNHL/WUGgMShG/Ax8BZwS1Un2lrG5FKetXfmudennma6QTmnZ0YtFV5uoWlG7D2x94TG0V0L + 7apDtWNyumXmr6jm52i1QqPgwm3qlJ0as3yYapETy/xtSVafaRFUyHr3av1/U78lW9+V8sLZmKdntFlG + j3JDa7Kp5aXFlzQR2pknzYRuV9GmwN57+in4o8St08TrR45b08jJxHE885wdV5ydeI5mjpkXKmzGYRCB + SGQN+LEfTPnzYNZpU6xl89v8BD5mplG+HkVEYcy4HD5FLQ5rB+5u+SaNufrRwuk9bOjBe6GoHctoMADj + Oo9kHez5MrFmPMCV/QA05NmM/OocmNGsF7wzMlI9g8kSpsfQ31JmW1juHbdTRSfOJvemUN+CyR2YT01M + JeyE3Qth8QwWOCapBq2J1Pk3HYbNM8ZvJVH2lNSihrmxzNY3gvcJLx3ONyS2EJckneRLkvnOoibZ7vP1 + c5rZqdn9N4rV+x1M9pHZLjHfBpbrjnrVEdctcbun6fe0NAS2KOu8z/uS/j/HDuFLMhb3qwoAihEOXmAZ + wHPg68AZamyulCO7OrNRii7Rne5geoF6E1PQ3qOdJzQLuk1Nu0o05y3t9Rp1V0zCFeHkgsnpOc5dI9TU + mlCOUV0gmo0dCmpfWIApN9ojh/mBfLpJHioqU4HW6zErKHWJg5d4vnPF3YyrUay29aCLfHA6RzcVwt4R + EPYToV/A9ATciXBrUfG1KnJH4Ng7jhae6cLjq7whgqHthAy25XHbRA4Cw9h7ZhaCEQii/VnSdPE2U4GY + bdoNZ9PhROeAcJVHGmUGA+FdD0GhZBBleKdkQlKyg3ztxeV6n5FFG4cgmjshkj8LDblT0+tBGkswkBQ1 + RVwv2ZXZntNXIDPwJzBVOBGXyxjr3ro5+LnROxRle6xUC2VeC0v1TLVGdEqi5mCwefiAiyrdAP4GCwCy + FmTt8DvBzxRfdYjfQdqgcjS8R412nW3ALSHeNACkCCVIVq9KakNkfcIFpe4Ti31gsQvU247YtOxDS0s7 + Av86jFjNlgMXp7T/XiYq/1IDAFjEOR8FgIZyG6nhbnFNntpOqPZ0MdCdBkIdSDEx2SuaraOaqwX780hz + sabfPYXJE7rpc8LqkunJNZNqz8TPcX5G1FtIWmTKbSZ5uNFNKKONosOdbS8tewAW+fDDgSSHT19z4Bif + agNYNLoCDnOLPQGdWi2cKtjPHP3CMTtyNAtBJsKRBO6ociQOX1vKW9SNMoGRFNREJfWQvBT9CEYvwbL0 + mwDlDZ240WvU0Z4eDncdcolhoxeHZHEvffP4iWC0YfRwXTJZy8xWJBOrMg5Q+AKpELpAKaYuh+dNGc/B + g1NHSqauO7A9M/Ygkr0Eag5ycoMNPMYkzVKJaQJ+BrMpHDvhRCvmaYLTKUoN+ILh53dm2dXgKaFqCj87 + kJXgV55qB/Vxwlcdzm0RtyaFYyPB5CkPe9FxCJCQBniuAM3agewV9taM8FGZdInprkealj7s6bXNEnA6 + XHmMCfQM+Ahr/53zKaf/ryIAdFjq8SQHgIJCurLxUq+EjeTszyJg3wViHdCg9DtFm0C7bmiuluwvI/3m + kpSeQHxEvD4nnK/pFh1zr+gy4dw13l3gZJkdXRYUBpdl6jmtK4BYucNcnvFSDtLgA8twtMtSBsKGm7y0 + E8enogynpoBNFpqnKbG2bKCbV0zmnotpYl0FWrEP3xfFo6w1gNqMeYqJmMQ6S6MAc6i9OaTr5W0O/fwS + 7NxoUxVGWxoFtfx9bkRksQtyyBYKWljaqOU9j7bJ8Ie8HAhshw5iLuOgUbIBNxa31tHTvRS11EqDNDJ6 + vWH5kDMCrawLpGPiZr5eyStSw7SCY3GcJrEAwCRnAI4bS2/+vJVZahoRa0E2UDVQpUjl9ji2ELYoDegx + JjOVW9Clh/qSf59qsve1U2Rl2hGyV3ynVPuE3wZS0xL6hk4bejrigf6kWA3wBPgQO3xXP/ZL8vplB4BC + CnqaX8gzrAw4He4SBe2UuE42OdYp4SqSqj0xXFK1Ebod/f45XTMjNImUNsAlxEvSekv3rCdN1GbG64Cb + b3HuEi9HeFkAcwYx0FJjxuGYvPlBjKc58g05UH5zzV/qULtpNdeyo1MxB/Thd2neM3lkIXmhl4qYHFUQ + ntUdTxDednAf5TjpzRM5b7CBNKN5E+WXOb5HZaSDLxmno1ieaW5dZsJU2ZRafA9LUCjPmRH9PMuU+/x5 + RKlMVqbMdx8aIi9t/hInx5u8AIsy2tADoSCPC1eHazkM37ixEVzJw+WAQ0LuWtz8s1Qv2dr1kARW9ivF + w0SEI3Ucq2OWatAJkWxCa7tyNImaf2955T3ITmEjuI1Qtdaec65DZAcuDytpNGehEkBHeollexY7+tQm + dJ2QC6gvhWoD9S7iNoG07um3LW1oaNnR0tANQSCBpf+PcwB4zKeAf7+qAACWBZwDn2Bg4NcwsbbZ8NHn + IEBxRD0HdYmQGlzs0bS2abzo0ahkJ3nLkfo4CFOGPXQRKu2ppSG6PV5DVvyp7OcLyT7mK18K6vxpqMvE + nnLSjcuFIkJaQKDhRne5aD2QYwY0vLTTyv0chZScdTM6z7ZPPMPzsfO87RxfF+Uu7gCkD7+EoY6WMu08 + bNRhz+fXnlVl1CGxBAHJ8mBq2YscsI3MasqbKKcUZfP6/OJd3gAJi2JZI0G8QJZAO6D8LwF+Q3kyzpLy + i5VR0BxnU65UWPbDrmy4H5sHl8O1KE/pD48yx3UjQc6bX7wFMqcWLKcJpuqo8IhUJDGJcGsNj8uAw68e + lMN7YCvIyiFrxbeRKgWqeo9zO0Qaq8+TZjpxzHhASfn1cI36CNuAXiruAqpLYb5KzFeBarMnbhvarmGv + DXssCPTsSLRk8Y+SAXyMHb77z9qcv4oAUACJp1hN8g3MqrJmgN7zd5WBigJuDcdOO7qLsJsma+37BdSn + QnUk+ElFJVMcS5Q5yU0J5DHegnInsl5grjGL9kshsjisvVNAsIL+izDufQ+4YgGCyL3sdPg+lWSAWzEp + TQWPAJ9s6CTGxKVzfOwn/Ejg6165p3AChxq4rJLW5k1UTriS6ls/+kaibHv1xj+UE1gOG72AT7me1uKD + mA1SxZfjKQt8lTHqUk6MiEPK4fUdev6Ha0RJUvNF1PI9mTMvpQXr1IRZ/agaG0DCQ2fHrsvoteaJTrI0 + hLhDvV4oysMDq6tpBW0NYLVucMYrhgjijVknFjAKQ3LczdAE2gjpUuAF+CvP9MwxqwN9tSHVK0LakVJA + YxZs1YAkU5Ia7qMOZA3uHOQS6o0y20QWq47FqqHebemiOWq0+X8dxgHIcjJj3O0TChX/CwwAcMgCfpQf + 93MQ8J/63fpT/rECTkDuwOS2Z3lnwvTWFHeygMkSzylObhP9bXBLUqrwKc8KDB27Qh1mOOGtShgJhwz2 + YW646SSDYVqUhzMJXGIGpGIOEhl1Vq/m+BLt5FU84qCWhE82wbYNjifdnA/8lLcnibtOqTWxGFxiLBhI + QYzzVOLhxC8bu+y9PA3HKGXOk45Sqh04VIXRSiLNWnVFSFbKiZzzVClUZR394hzwpIy+wgETyGm+FqZf + CbjDz7sbNNocnTOd1j5z5w3MOyjiZj38WDCJkjXkeQ6vB+anF2wyyQRghszE5+cKZtXt19BthaaHLUqX + R7SrUidQoWWArujui7NrUdSjE6Re0EuBRx53W5ieCLFKpHoH1RX7eE3f3iLFudmGUdu94aJdowSuEfy5 + wz/1yGVk0kSWbctyu2W22eC6DZ1sCNWONuzpdE8aLDmbAOEFdtB+xE85/X+VASDkAPAh8DbwLYwXMP1c + Pz1O72rgWJDXoX5QM3t9yeLslNn8BOePUD1COUY4JckpKkc48agkqnLnu2wekvKJkj9MO9DSgQFYcuyB + /ntIVTXf6IURKHksVPJ8gLos5+zzDU1OZ8VOpRpzh0ku0eG40ppPED6UxAOJnBCZpEiVyTtlAzqvRizC + HWJi2XsZ+ddclxdarl1Ce++lcWFZdzlNU269ZVck7O9DG7Gc4GoU67zLOWRlBXmT4YVoaQcOYF8OAmKM + uiE7KKf44PFgAUEio+dLufOQMRnJqVAp7p3LG59Bbnjo3OTrLd4NTtADA7xRuFb0Apo1XPSJc6fsxNye + aickatQZMaekSCULsHtJ7C6O1sXQtSBPPHLiqY+EeRXhlqmZ6OQcTSd0OkXjEvCoq0xeOhmQyCX4F1Bf + JCa7xKxvWYYNs3aN32/ow4697Nn7PW1qiHGHJdhNMo8mPgY+wGr/NZ9xnP6qA0DCGEnl9P8d4NuYib38 + xJ+0rBlmIAvBn3n8PaF+o2J674jF6WtMp/ep3G0kLdE4IaUpyhyYoVJn1eFIJObUzZRtXXIQ64HYMbzU + NKQG+V4/nMSldTh0D0rdm0qNaieSunSwKR82a849XQHwzAEpecfee84rxyOvPHLC/Qi31TzfB4TOZS2C + MvacHGUM4tDds+NbB1RpjEvkb3K51s9lgI6Av0N9m7GGwv4bEPt02NClNHKlNSo5iBg3fqiwhjhR0nTD + YSxI5I2ZMytKGRUL8JfZmFXKzQc13EEEUvY6KP/mJA8u2YvNKAWFtDPIDYPpkG2BS+jOlasVPA6RJ15Z + i419TxV6mQBzEhExpfvyVmxlLoM6ZZDivwR5KLi5Y+ozhfi0IdXnJOYkqekDqM7sNUWBjcO9AP9E8Rcw + 2UVm3Z5lv2HeXeO7FV2/Z9sHrlNgnVp63aCssNQ/RuyQ/SA/njOa+/+s9asKAHCzN1nSkzMGZbnPWIJF + 2FOQ1wR/3zN/o2Zxd858cYfKvYUL3yB2d1Cd2ok8tKr8cOOrj6Qsz102hJbW4LBJNKf56fC7C0Co6VAq + lCMUrP+cGYbqLTCoCwOQhbNU1erqjEw5lwdiPOIE74TkzRbsiYdPEL4h8KYIswPTJhORynsohh1l8+TX + VMxUbvTQD4j1oR4f3iDD7vYyMtMtJ7YbrtcB+Mg7W/L7K9cuE5FsJMMEVLQEi5LqD3260fO4ot1gIClk + X4Bod43muXu8ZjJTgKpgJH5IQA6qTeW59fCaB8g+ZzVZICtewOZSeb5RPonKUx/ZOPNCmqjdfIkFpuqk + SCmnR5eulDjkbgkt6AvDqJx3TByW7R2vUHkK6nAxEdIJST3sI+55ov5EqZ8nJtuWab9j3q+YNte43Yqu + 27HvI5e9chkDO22JurY3QQeWZb/ANv8P898/s/Yv61cZAMBC1TMsTfkYuMdBfvPTVybScAq8Du4tYfJ6 + zdHxggWnsL/DvrtD290mqkd9h3PB0N3hkUj5Q7JDRIcUWMvNV27glE+WckeWzV7+PrQEYbD/KaKiTjPN + NvPsnR2rKi6fTPbQghHkFledbGagCcoTr3zo4WsIb4oZE2VtUsoMgpb+fgEFc2lS0vfCtrtZk+twSg/Z + iBvdxUVWfdxRoMhfySg1eAntz2m15tKnYCriyO62OrTxpPRBS/vU6+F3Dq8hm2gUILKUKcEzjF7bB2bX + uARBGS7SqEHwciaXX3sP7JS0UvZXyuoanu8Tz1Li3Af2WQWoVkhUBJli8wAmDCoFFyn3RAlqVe7UJMzr + /RyYOFwFdafMbzVQX1Cp0vc9XX+LEBakTY17DpOnkem6ZxJaJnHLtFnhrld0q4Z2G9j2yioFmrQnmrPX + eI9vMeT/fSzTvuSlyb9PW7/qAKBYyPoYeA94DTjO2/vTVwkAR1i+cAb+2DOdTpmHBeqmRFcT3IGkIuKR + LLlRRl01bxzTajDPOqUA9lbLi2hG0cegw4g/Mfxz2Vju5heETGsuN18+UbVs/PEJZd8r6qiCsR1bVZ4D + H9TCA+d44DxHmrijJVcphugZTXcJrUbZuZbKNJcZWc7rAMrlicCRpRpuxHMbJNHGJ+cIMocDcKiH912U + lSwrsHrbrAjFgDi1TAmtIPn8lJmWXI7NZP06+1kZjSiXtmRBMPXG9RYZZXw5SA3t0fFnwOFX0UBa2cTg + 6lJ5sVGed8o5ysZFgkScJGpVUlZ6UaaYPkBCXW8lXpmpKG0FJ4fLogyqGAK4jTI9ifjZjrkLxLil767o + 92eEzRGyctSbnmnfUqcO3zfIake4bNhdR9Y7ZdMH9mlH5JrDya9wyK5/hGUAT/gM5t/L64sIAJv8Qv8S + 83B6k9z1+tSfEOwInIHOFTOcF8R7ajH5qckicBIjvvdIXxNDTReyzlyCmCJRAsmbjpxklWDJBarmNpIW + Prbk+njcWC5jrk4O5pjDjZgR/zJnMJyWDDfqjVOI3LJzNhBVJZvbSqrsBJ4hfDR1fOSUuyjLKCxTOb1L + z0lzi7RsBBm6GwMrsDgsa3Y/QuwEjm5UEuRhFA5v95Dql1KqlBqjVH7Yh4dWakHHcWqbv87tuZwpSXKW + 2ud03oC9mK91wRPcodaX0TXW8TWEgUs/ZC3lszlkMWVfHvwhyf64ij5X9s+Uiwt4vIcnSbgW6PNldtkZ + sUYQ9SgTlBlJEkHUgoCY8MdNBmV52BPpLovHbPP8wSQgVYdqQ+waYrMntidIX1HFnko7pO9h1xOvA2kV + abeJXRfzyV/s/YYAUGr/j7HS+hkvqf78pPWrDgBgrKSPsE3/dQwMvMeIGHRjjQ+sXG9Fp4Q6oZPIchk4 + WkROcBxv51TXNc3acbmBi62wCrCJgcY1hHpLdBFxMQuFllafmB+AL0haMhQ6/2JTB4LB963chBxOR5WC + Ph9aZMWW7GZkyy2uPIyjeZxUkiK9EDvY1fC8dnxSw1sor8fIQjG5roHvm5WNo5jYR+anD2QmSQe2nvoh + eEjKtl4cjFKGlFxG/z3wGUY1/piXMGQL482ffyT7KhyMa7McW2ZRakEHCyg5BJJcFng5bF404wGHz8qo + BSkLf+YgWGaE3c2YdWPzJ8yS+EoJj5X1J8rTc+WjfebLSuGpa4YoLDuq1KFMSKJ0hUyKWmuwtFsLZ2TI + PvLvLP6ce6y/X9l9JESqANo7CAEnFY6IxkDcRcIG4kaNEZh6lAa9sfn3+YnZYS//vbyvPpP2+2nriwgA + 447AD/OLfoCVAz/OCyhpW3Y71l7pU2TvO/qTjskbPW/cg2/UNW+tFsyezdme1zy68jy69Ly4hvO+40LX + rJLSu4BKMqWXAuRHR8rkE5cflK8XgdFyMpajr2wALcNCI/5AAc7K6x8j8QnbwEOHQDL6bqMnLhoQdqnw + SIRn3rFVx21MA2CoN/MpqCGfAYWV50Ybcshg8uxDKV/K9GCp14f2WRp1NCzzkYHqdtjkA/A3UIXtfahg + M/uVDIKjkrKJ5VC+5A6KZHGRG1OVJcsqLT3bVFKmHKPLJV7+CEpbb0TuMeZfkWmTQ2sw08xZQ3iurJ8o + z54pD9fwEOVFldjn2r64GtvHKlQ5sqVMYy50bBsvj3n4sZSAuTwbmKFywB1Cfi1S5cvncSnitcFhwHDX + KO1KaTcQWwgpkqRB5ZpP2fwlo/4Iy6h/hAWAn9j6G68vIgCQ76YrbFLpfawMmDOeERh/ZwfsQHdK3Ee6 + 0NHQsp+06HFicbfi/qLmt84qbh/V7G7PeP16xoMXE86fC8+vOj5uKx4qnAdokiNoT58gDYwyO3Wq3HJz + g1bg6AQZUPdx+2s8MGM3uGSgUPOdYn/KQJixgSNzbtU8Di3OnG+S2I11nRwP1fGwEi4E3vCKz1NAMp5I + zKdkmbKT/JJSyq9Xsk+iYPVrGdWNuS4XsXq8to1nVOvc2chWaYUmnUUcKFqGQyaUDS0laxkWAl1J5706 + PA5JmZrkhYTPc04ZFJWsrlykwhgxHfM1Kd0WC1pqvf0SnEcZwxDoKjUJLgRagS3oC2X3FJ68ED5YKx/2 + yrNJZOsTSUJ+VSlf3mxCr4KTfC3yn4InpMrot5lglqR0W6y8dBJz2PMGgUp2WFa7QE4qKldZzA6Jfp9o + 17BbKU0DIQaSNLSsiVzlDGDY/HCo/d8bBYDtz7IRv6gAUF78Y+CvgDeAW8CSlzsCZT4g2xrEbaTbd+xj + Q5P27DTSOYGJY1Yrt6aRW3eERTPltfM5u0fC+eOKNy6E063wYe95liZcpx1b7WlTtq9KUHurQV1m8IGO + dD5kdJqPgDHJcwVDK+6AjEPZ52UGPJcGDrL2d34qh3du0EZok7AOwuMofFQ5HtYVr5N4PQaq5LKWoDfS + Up3xAGfps6opAJnfQS4ZMud9YAuV8kbdoIAkVX7NqvZ+ZHihua63TS8lCyqZQjLJrAGnG6x9GboFJkxk + BpgiZFJO1oLAyqYbI80UFiOm/Vh6+CWxciXT8MYrGDIv+/LQTKgzLbh3sBV4IYRHysVT4cO18m4UPvaJ + dRVJPiAuO+voMDaUf2FRD3aImwAVTmt6rQm6J9ITB/pk6Q6YRJpqyb6MAeozV0GoTBw2ejRC2EeadWK7 + TmyaxK4L9KkhuTWRNb1uKL6/efXY5v9h3kPvY6o/PxX5Hy//s3zzL3gV0qlgG/81DAu4yQ4sPVyHoQRL + YKlUc6hnM6ZHZyyO7nAyPeZ2NeGorpjO5kzmS5bTKWeV49TDkQhTKupUQ6wJqTJXGk10mgjJbiTv1QQl + KqEQhqynJQeuP3IwEXHG0Bu6BYP1WAaBspe7xlyH+wQ+2MOlYdM47/FiktMJR4/d5DMvnFTCsVeWLjET + s6CWYeBG82lInhOAwpM/kGA4bJRyTWOWAM/OtFJlUDQpEovDcs50vAGFki3TJNfoZuXrbUPXDldnym0Q + ZC/oRui3wmYvrBKsHbSTRKyT2WVnIpS4QtRxOZBk9+AckIc5jtyOlGzJPbzvDHZacMkn/0zJfTxYCfpE + aH8kPP2R8O5T5Qc75X1JnFeRvjYNPycHtl8atfec2MZ1zuGlwkmN08pGzdXbCS9Vnh3IvpNZUd64zPY1 + EVMwEm/llSZPaj3tVmjWic0msGlatl1Dkza0rOjVbMvzoM9471wCfw38SX68z88A/n0ZAoBiIa3NW/te + fhxzY8CVQ985twNlCX4K1bTCTY/w01PqesmsnjFxM2qWVG5BTc1EYFopRxPhpPIcyZQqTkjB0yal00iX + LaWcV/xEqWojcNi8aEaz1OUUdIyYZ926bOVT2nRDDpwyb72krg6oElJHuznzsIpzpkHntcJpldNii3w+ + u9vMPZy6xKkzZcKhxz+8lgPOoDn9F0Zg2iDRxcA/kJytDJBFIs8sHDYb+f1JCQJl2s5J3vweqT0yERPh + KO2vKwjPYPUCHm3gowCP68B6FkizQFUnJk6pS3ByYhvHZYvwAb13A4gphZ2YOf/OjzsF+T3WajJAk5xS + rB08Evr3hccfCH/5GH6wgvdj5EUVaasIPuEKoo8OsQYpGoQuByuPw2YDyua34qbCS4WnopIa7z2uqnC+ + Nn2/NCHFihRNjTmmROgTfQPtOtFcJbarnnWzZ9NvadKKnhWRVQb/el7C9QJWPv8r4F9i6f8LfsbTH77Y + EoD8gs+x6PVX2HzAAgsENycFMw7ANj92kX7bsF5teHq1ZjbbMa87/DKCdLxBw6JKuIXHCRzPhPmy4nhW + M3M1tXhkrdCZ+MKafabvpny/2UlG8jkASW772E6RDMINY7OlN5jLBC3Iu5SNbpvJ6lKXT4Y81Zb1/hSH + qKdSRXqbFlw55UOv3PbCW97zwFVMh95+Tn3LhN7giViIQHCTDCNDV1PrEi0yBhIygjYgXHnIiTHXZgTa + OZe1B8io/wFbIKvRhyewXsMnFXz4WqKZRW6fdAQfmNXCUTRegNgAbuFW2hxFzqgGevAo4ylAZ+EiDai7 + z6/DqX12WwePHd37yrP34d2HyvdXynsh8sIHOh8tiyA7BuWyToYuwEFzYTxaRfaO8HhggsOTtCaJ2dal + FNEYCSS65Nj3jq6PxLhH6cC1oAndO+LK062g6RNN2rNnQ2CdB3wCnwHot1iv/6+wzf+Ez0H7/bT1RQcA + 8rt8DvwFVgacYEHg5MZ3FSS1AdkBeyW1Pfv9nsvtnnq7Z7nYczLZcKtOnErD1C3R6RGpmuEWFbMFvFab + C4xnYaDW2gCmxwmaTPcsPXbJJ6EO7j8Z6dc01KgH89CcfpaSJbcJDe8ZTeU50yYr8/iXAABGDElEQVQg + +ayfn7nuYu57bphPF2Lw7Hp4EoSPovIEz8Z7TvBIyum6G7XVSlZQOPyHnt3Q3hORLLaRN3IeYjkoHHkG + K+xC5QUDBEt7cBDFyy3TcQZSnqYH3SrtWljVyotjswtXIvdcpHWUKj9/uFnDYOAxyDB6MGQuhR8wZF56 + kPcaqNdirMGNJz3x7D6EZ+8rP/wk8INr5f0QeVYF2ioiPuFkPKjljU8xphDnX2+KVZJj5sEoxBXROfFD + d4ME0iohAb2w65Rdt2cf9wTdo7LGtCwgNULoxZyR6QjsMVnvfvT53VgtNub7Lgb+PeQz9P4+z/oyBICE + gRd/hXH93sAygePRR38oGLb2drWB2Ee075Bmx+VmzZP5gjt14I3Fmrv1jIU7Y1Z7Uj2jw6ETZeKVO4BI + BSyHyO565bkk9ilBDFZvpThM8plwcJH+YjQZaIPn9vXMbEua57wPDLEyBqvR2emUGXRS9ajrSc4caNVV + uGA1ZkwVXYTrmHhG4pEIT53nFM8yjTQGtAzWZNCL7G5UrttwG8uQDRQT5fG8AAXxL0KEw4+NTv7xHD6j + Gz6VzggmezfLpVpQ6gnMFhAnMBWhzrJnB1B11PgZ+m/lJY3Ay/EcQS2W5k/TIaAlgdah1574pGLzoePR + j+DdTyJ/fQ0fhshzH+iqkN2idGj1WTXkM0B3uGyFXp3DNIcWyo3waqVCzop8cvjW0TfCvhVC17MNHZvY + 5QGeK2A/aDAUa7Q0DHFFPmM/d1jP//vAn2Gsv2t+zs2f794vxQp2RfBYN6B0BSY/9p0OZAbuBORUkFmF + VFlbxAm1SyyqwHEFSzdlKqeIHKFSE7xCFam8MnXChIo6VkhwxCR0WLcoiGYgXHF5Dt+sw3Xo37tSe4of + bMQKS/DAp7FUmeztBxlgC87+VPKmDeB6GwsVxanL7DNPVwlpAvVUOZnCWQ3HTlmgo+g97BabOSgTcYN6 + cQlEjNDy0kocbaoM8g32xAWx9h5xfvAkMOnqgjnk87OMVo8+p1QJ/RLCbajuwukZvD6HN7zjDhVHak7E + N5hecOABVAecZOgCeEFqh0xBFhnsq7AMZucJ5xXNw4rzDx0ffQjvPo785XXggxAs7a8iUmmeGpZsmWYd + CT/gENlCrahBIcPksV2yrA49ZB0ZiHQm9+VjhW8q0taz2zou9pGrbss2XNCHc2JYE0NLjD1RA4nAYdx4 + 0Fb7tHUF/DnwnwF/jAWAzd9k430ZMoCydhid8QeYZsAC+CaG+9s12QOXoEvoXwPdRdhd493H7PvAhQY+ + ksRycpvj2ZJ55agQTjicaV0NnNoBchdweCsHBFJT0euEp7KilR2iLS5/MDr+sJGstDN8+ocNlnSE1ipI + HBh6dn9nlO5Gil7q9JceknCYYeUa4WMc7zm4g3KqyiQz4qzl5Iefk3GbrvRZxl+Dg9ZJ6bAIw0jtQLpJ + GLJd+nfltQ4v0R12RZ+DY4XNbUzBn8JJL3zNwe0pxKpi5hwnMXGCIes3iEAFUykxK+spgGYDlMqwh1qQ + Kdbmk2QZ1bomPqtYPXQ8/Qg+/iTxwfPIR5vA4xC4zjU/Q9pfaNKHX2/LXs+w4TGHZIN3Mkpxg2mYr2fG + DYq5SYxC1wu7ENnFnr02eYCnYcTh/1lWh9X6fwH8a6wDcPXzPNF4fZkCgOY39C62N7OaJ1+jcAMUIwRd + gl5AuFD8ZI+GF6RO2bkZz6fHzI6OWS5hUSfmrmNKwxF5M0mimyicRKbAnZzL9czYXwjb1tNQcU5FkA3q + 9zkLiDfqaDcw8kZ3Q3IHcN4Z0cfuiPzvBVnPmYTkbEJNutZupsw4U5dQicPBt1d4LMIPnec+jjedcOoE + T8jYlebfk4k6ZexVPuUyW1wavliESixTMdRdfTnRi8BeqdUPQKfg86QeEBOSssz1DOQIqluwVPsQEwK9 + 4DtHFTPdtnQnynMOTMPMaqw4GLsWkNNh5B5x0AnaCbpxdC886088jz5W3n8Uee8i8OEu8oJAU1vL1WWf + AkuCisaDDFmRVSVjKk++YoVfMFxD+xkdJS6S28SSIAUhRGGnsNPInj3hb7b5S8//XeyAfBfDzX7quO9P + W1+mAAB2xn+E3TPHWCA4BSvbgazkggmHPsmHUIwoLWm+Zbfe8uRyx6zestQVx8uKZdUx5ZgJMyocCSXW + kXiiVCrcSo6vq7DFs75asmsdnTouBZOHIuA14fK0m3ceL85S9UFsc4DKMxcfyHU9ag69mrLAXU0Gz9JI + oMRnf1ObY7R5pDhs1i45ztXxEZ4PVfhGctxWOPXxoNlnT2tDTYVkNIz/jrIMxQxGxiIZRUegjDDnwvRQ + pqcRTl/+31mXxGMZABz4+LWAP9xgMgQjGcwvyvcChw5KGXH2ZEkvRk1hI9egCo0SNtBcOjYXwvlzePos + 8fBZ5EdXPR+1gWcSaWq7ztM8Gm4B15R3jcJsvyw5l4mT+nIelt9tzkwUyki35lbwMNqtdr01QN8LTYAm + RXrtMrDX8XN06pRDz/9P85+fa9b/86wvWwAoFOH3MEDwAbb5J4xBwTZfgqkdQKlW3Czi2pa0XrOurvmE + ikWKHNOyONrhfctdjpkwocLaTKFWOLX78JY6vqE1W63ZXS1pWmFHpCEQpaeSmEtopRKYSCHKuKwXUjoF + kg9OzUMfmu9Zb/Nl3ueSfDREot4ygByckGxCSXbSDY7QwSY4nvUVHyXHB53jdopUE1j4gPNxSPttCngk + LV7uo6EEsY2vfQH+SolSTtvMVnVZmLWAU6UTN/wlcwkSVlONlYOK11/+lcPrmIwHgMYfvRz+vQSA8tyD + Jql1Z2Kb6FfK+ply/hgev4CH15FPNoGnu57zELiuIjtnI+DV0MYlaz6mzPijoLtZPLS0/OxFH85pPWR2 + emjdHkRYOCQSEWJw9L1jH5Q2JSLtT0P2f9Iqp/+fY6n/B1i5/AtZX7YAAIcg8EF+03cxHCBjy1ggvbJX + n2YQz8CdBFyzA7mi14rrlPhIIzNn/vRpCckHXpM5C2aY+yt0daI6SdRJuJPgG6FmFaZcB8d1ZwFg5zti + 1ROlt/pRjCmmWucOQbmTD8i73rgrDgiySr7quf62zeoM0hNvQ0nl5oxYgOgFWk/YOdbqeJw87/fCaQY+ + X5sEjmioXTJGmptAqkY4wxhzkIHXIDdcfvWwIQfJ85gT4Rysynhx+fqgi5DfzzCyTBYa5fD1clrmIaGb + UH/JTtLNwKBiNOreJN/bPey7xK5R1ldw/gSePhY+uVIe7SPPUuBaA42LxMwSrDIqP2QzbnQpyq/Nn6GW + MmdMmy4rt1ZlNEE68CMOTwJRSAG6IOxToiUSDF7m5wgAReXnXQz1Lz3/7he12b4sXYCX1/jqW6luHIH5 + 8B0FMJ0CC5BpLpaTTcIkhZ6avc7ZywT1SjXpmTplapytfJJl1LvGGFypRtuablez23maHjoJBN+RnH2I + noRXZzTQsoGGceGSYmpmkOdNVk7DjKnhi75f/kdXQRbDGNR8IrhoNXmy3wq9xzWCbJXUBbrY0emWLq0I + aY1qh1OHH3Zaqa9HAFux+B4CQF4DLin5fWTAkmyVPpz6BRMsmzcxmI28fH+P/7tMQDoYKIWFJTUGGROW + nXQCO+hXsHoOTx4pHz9KfPg48cOnyg+fCj+8gI+3ytMYuJbx5le8kzxjkW28RzHHQNuRgUAeRioCMYMa + 8o22pBte6yH9zx2AJLheSHtH23jWneMqBNa6oeWCyCUMrr2fawXs5P8+8M8wxt8P+RmHfX7a+jJmAGC3 + zTXGEDzDugKlMzAdvmMPegXxGcgkgO7wUakkgXc07oin0hElkqqI1i06d+AqXscxZ2qGE+LRKfhjOLmV + ePNaWV9VXG5mrMMR27SjYUtgS0WLpGBAGUbbPajoJFPkDXo4KbIBpYhhCfZfuQk/9NPzGxql4IfTkdxb + FtIe4k653Cof7JQ2Cs8XwkfHkXtHG+7NLrk7Ee5VO07dKVM/w+f2Vhk2Kq08xuh2sld1UETOKa9aqkzK + UlgwbNQyiyClIV4UhT/tgMu1tUhWTxahWGShLsdsISSlD4nQKXEPsUv0e9is4fwCnpwrzzaJF13iqofr + Paz3QqOJ3kdiZa1aL5hYDPlMyKQjLSVSATbzuxoGnIoX5LDjR12aG/ZLejj5S1c1CSnYo43KPiX22tPT + kob6/2cq27f5/v8T4Lv8HJN+n2d9WQMAHNKfv8aowSfYJ/F1ipBosACQKoiqIB14NU66n6Duin11ixeT + I3Q6Qb0nag/zDfjIGxwzY45gLC5fwXIO945gdyqcN55nbspjjjgXCwBOO8zQIde4ouDiIIl18HzLwKBz + OUUcnfg3tPlsQ6kqxKK4awBVscjSMvSShLhWVk9h/1S4aBwfzx1nt5TTW3tuH1/w2rzhQT3lteqE25Ml + R9MZi3rKopowr2qmVUVFBakipkiIQkxGQknEkbyX4pJShUgVIj5lau4ABZb/yvs/MSIIMeydYXiySvg6 + UqWErxwiM7M3T9AGT9MnVo2ybWC/hXarNE1i3SrXO+VqDZdrWO0T65jYKXTRESRr7/tk16mcyIzGH8rl + HjwX8zWXsvX15osuAOeNf9Ph/Ywlx2TIqKz1F4LQBmGfIh09PXsSLQcA8HOVAHuM8PMDrO7/C35Orv9P + W1/mAACHkeHvYhiAxzKAr5FH99mBPs3z77Uikx6p9uDW+Mk5PiyI7YSLVY1So1Fxt/fIIlj9jGfOxGym + EWon+BncP1Uue+Vx7fm4mfEintCmPIutbabPWs2oWk7PQuIYit5D6284UEzKSpMbTk87hXPrbmh5JdSn + PImXs4zOEfee9gLWD+H80lFVnsmZZ3IHlqcNt+cvuF8H7tczXp8dcXtxzNlsyelkztFkylE9ZVLViKus + rMgz7GOqfZmD9xGmfWLaJ3xMh1GHIvmd32vCdBXSy0aaw7eUUisgVTDHHzHgNKRE01WsGuHFRrlaK7u1 + 0mwTm33ioktcB6XpoQ8QkhJyT158wnmrmgouA3Ko68evY4Rv6Pi0P7ypUWgrSGThNY9Vj3L3JGsvCLkx + kcz5ue+FLiptjHTajQDAjs8p1NPme/4vOdT9j/kpBh8/7/qyBwA4pEIeO/nPGA8MKSbDfAE6xeo/DYjf + Uh0/o/I25RW3jquu4sPuGI8AAZ03qHe8wYJjZtRa45Kj9sKtZeJrSTn3wlOdstoeEWPP3kFwGyrtEU04 + VVLZEAVlv0H60cNJLwbqaSqjuTkAJEVTKE+Q6QXWRRjKiwysaYDYQ9tCWHu0nyKrOVxO8UvP41ngkW+4 + U+25M204m285nS4sE5hMWEwmTGcV1ZGjPnZMl8J87i070Bl1nOPSFJdqqiTUyVyKXBY9GfPUNL+/hJBE + SOPsoHQXg0DjiDthHyI76emcTV9K6ogxsu8d67bialex2jqandLulV2XuI6RrSqhkAHzZrc0v+xjA+cK + dFJi7YBBjj6fwUxooDpnJSOym9KAEpbuSFGGTofPNgdkyW4+Bb6IEUIU06LUmF17x+n/Tz39S+n7Lnby + fx/j/f9SNj98NQJAwmSOPsDKgFsYGChYh8CjoA2kx5hXe4jIpCHdatGww/V7XAsxei4b4Yd6ZGM/t/ew + yEIQCCdMmWS1mflSeeChwXHdTNg1R/RBeIKnl4pUrVG3t0+9OAZn5dpxt3xI8QdAcETQEYZaWwcEXA5A + YHmKPKwj0UpXt1DcMbhrT2pm6OUxrE4JkxM29RWt9Fy6wEPfMq8C07qhriuqylNNPJNTYfZAOP26cO9I + eLCY8Pr0hLN0j1l3wqQ/o4oLonq6CrOvKs5CMJpE1gFjtAAwusWLCNHOIduK9srz/BI+aXvOdUenW5xu + ERpCVLowoekXtGFKDEKMSq+JVnXYOkNulbOWwmUqM0DuEFNvBIAbHcciiaZ50rGQeoZUXgepQqsWClci + P0Mhf5Y2Zf45jdi4bxD6mAgaRqf/DSGPn7T22HDPn2Kjvu/yM0p8/azrqxAA4BAZ38OIpjOsFCiOAUbs + 2mbQ2ikyj3RHETcPTGKkch6ip+vgub9P9HMqUSr2pLmy91Pe8AtuTwPzI4dMhKPa8yAKv7WB68azTZ4Q + PReAukj0udmtHDT1xB2ILsnSSLuXNI8I5+8fvAUNOSj0YSmIeAkApbWGMeP8MjG5A24n9I0jNBPifkns + bqP7uyRZZbvoyEbMyEIkHtRxa3Cvw/QE7s7hndeE5WszXq8rZnHCUfsGk+5r1PEMMEu1KGaqcigOfnwl + LRkBeVjH3rW/dPhdBV1N97ziyWXgh/GSjfuYqt5RV2uTP9E5qmbFJVJlFSNr4fqc2lsydGiv2mzhQdy0 + kkLcvcnkGzBau8CoFOyi1PX2nFrEU3KZNh6XIM99FFCWHPActvG1d8TO0QchqBLoM/jX8jlO/1zM8iPg + exjw9xdYF+DnGvP9vOurEgDAruJTrC6qMW7AEfBO/vtAEtIX5iHZKaReiW82zI6f4GtIk0S7Ul7IHSax + wvXC9szxfLHnHb/jm0vhzSqxaOeIq1n2FW+cwje7ivNQs9l4Qoisqz19vSdWEU/CjYUok0NdFgQpPegB + +Bud9o48Xqw3ZMgHpf6helDwETeFaqo4lLpxTK+U+NzTy4yWUzq9S9RL4AoTkngZ3NLBgbk/gsnXoPtt + mN0NvJYq3g53WYbvUIffoUq3ASFKIEp3MwCUWrt8MlpO1fx7hEHXqX4u1GvH9bTmarfAPYdt/4SLRUd1 + 9jGzekUtDZUe42SW2ZEmwmETdiOXhlT09TxJHRElqVGmVSJJDqDk8EKGlP5wTc0V7dASlYxfFP1HJ8mM + ZA1pyDiJG1IJGf5ngc/1kPaO0Dr64OhVifQvnf4/MQC02Ob/Z8A/wYLAzz3j/7Osr1IAALtQD7EAcJIf + NePOQALdQAyQOiOQpE2C+yumtwK6tP5uF3e86E9J7YKLfcXjW1teHHt2dSROI28hLPqKeuE5O/G8vnc8 + WDueJs9l27LTGftqgriO2qVB2QbEHGl9ZVEoZGAsplwGxMM0WR4vlmJGkpWHyG25g5efwiQhM6t3vIBu + BFkqTJQujzYHzoicYAnSaKR3vMS+rPeAd2D6DtxeCG/GGV+Ld1noN3Hpt3HcymzEjkRHccc9BIDD0x0k + w8cZgH2tqsE/hpNlzTknnO4r6m5GnH5EqIHlFnEbfHI49jhiHpWwPDu5YTrfeu3qkewsn1Jm9KG2+Uew + vxaWojrDTsqkohxIP8YIZMiyUrFPzn4F5m/oUHUkKRqL5XlzopZAA6RO6Duhj0qvkUiH3kD/P3P12Gb/ + Hrb5/wUWDH5pdf94fdUCABwu2J9hm77Gzpu3GQ8NNaDPLePuW/BbxT1o8Hef4qMQ+z3rcJ99uMdl8FyF + il2rdLNA6yNbUe5XcDSDajHneFZx5muOVJjEKcQJMRnZxmdzSClEGXGIszHhQeO26OwXgc0qoFUa7VOH + xGxqn7BOQR4vU5dsIK/ON3lIyMLhlgoL0NpR91McS4QjzBi1xo77EcGmLJev2BL8DBainFaOs2rBhFMM + ZjE/PMs3zBhDhq14cxWUQ8YZQPnLEpgr87pi6ebM1CM6Y6+evYvsqo6F7zjWjiM6ZtpTJc2nsh8IOTpC + 90oDIosAZ16+Iw7GIHrgK+S+nYZM4c2tDh2Um9OAG5Ddo1JhO46El7RkAdnoteCyScElzUrMtvlN2KND + B/DvM0d8i7jHd7HT/19jDtq/8H7/Z62vYgAAm4F+N/+9ZhhA5fUb72kPPAftIDTQNwlptsj+EXrc0TWB + 3T6x3QfCfk+8WtBOT1jNWs6XHd+ed7zpA7MKujz3L4NZaE57U87yD0S5G3eoVAx2ZLZ/vE2zVdbeUykI + tc/1f84YlAMXQA4UY4HslqywTLBMyFyQ1uPiFGGO2q5jIOQrDHdzOZ09RhKC3AAt/GSwGGsDLFE74wcM + 2cTLAWBkLXYj+TblpUI5KjRbERu66b2wrcwKrBfBqTDRigk1KhMM1glQhDoHBnOG9zSrKY0k2dNATiIL + px44/IMVejFPKQlBVnnSkeiIipCkyoBhec8F8FNuxsGMHyhETXQa6Ghz/38cAH5sFabfn2In/7/ETv5f + GM//86yvagBIHEDBBQYEFvGQ1xhnAi3opXFsugDsI9Vmi55BOq6IS0VOVjSbBS8WS5rpHa6Wd7i63XJ9 + K3Bew5l69gLXdARaPBs8rd3YmDS24kguZTu6ODTVB/efwswdzCrsNClKwyYA4g7HGqOIIu7QBizN56mS + lgmOEmlhstcSa4QFsAS3ROoeqXu0Cmg2N5rMhcmdmnox47bMOVHPlDnKGYZm7DHguSdqS0g9MSVrdfJp + 5//h1B9mIsQUfT2OSTTrsyCRfuJh4ZnMtyzuRPTWBDebMmtbZt0MxynJ3yPIMSItyhbLQvKVLvMC42s8 + IiONAUot3IOS8nsrqX7Mp0ncgb8xwALmFCWjDa+DKQvDe0TJ+J4nJehTHAJAYIcO478/FgDKgM+Y5vse + v2TE/9PWVzUAlLXB+NEzDoyN32ccBLAaLa6wUmwH8VLhrEVPz3EnDe60Jp5N2ByfsDl6g+uTHZu0Zx06 + ns4DZ7HHxRU7KvbS46Vh4jZ46fPJ7EipQjUaiOWyLRfRKMPiDhNuA8lMbRgnmjpQmVBRFzm4++jhxsuD + JoWjojNFjhJ6nGDp4LrCdVMkWQCQaoE/bfB3FD2JMBNmznFrOuPszdssbr3BbX2N+92Mk8ox4QRlSaJH + 2eQtV0Quk4FtQ2b9Mrg4otsOb9FGoH1w+ASh7ohnPf7NluPZE+6/0aL3lkzjbSbPHb65Q4xvE9y3iG4K + XCA5EykBUXPfVKQIghZaHj++bZQcmDlo9RX5skxOKlbv5hCdDq7RZdwXy14OKCS5RZuDUQBwxFDRd462 + 79mr0rInDuq1N4w84ABm/ymm7PMvMbbrz6zp/4tYX/UAUNKosmPG0+M3MgHtMjDYgFuBOw/IyQp3usad + gN7yhFtHdHcadm1H3+5oViuezc458kumzZQq1PSVp58qro5UVRmRFZv3F0EkWN88u8JYDuoON1DuR0kS + KwsG2XDslPLRggB6aHkVMKtku5XCHPTIMgBZgJtUOJnhmCPMoZ7AbYf/ujK5ryxOhFvVgjfqu9w5/Qbz + 27/FCV/nwX7OrWnHzCccZyiJxB43EC8Hsi+H3Ld02u3iFu687SsZiH8aIfVZKHjek17bUR1dc3L6AvdG + YH5yxmL3Fp4zQrjHdvsOa75Joybcktw1h4w4XzfNzsHF7LTYnrkRDSl3XTTX/CnzgouZqMT8c5nVpy5n + BgkO5H4ZsAErxchyZAyVks1ACbEXut6xT0JLItBj5f2Pbf6igv2XwD/HTv+/5Ava/PDVDwBwSKckv5/x + 3XkzE0igeyMLpUbxmwhXEOeQjgPxjhLvC7rrWF1f0tdHXPoJk2rC1M2Y6jFVdUKqZwRvtk7CBNWpDfiQ + x3qRfPcXYCyOVHOL3DUc7iQpfS7rDpTNn8051MnNd1VZ7SrHCY4V5oKrKrzMcMyQqiKdQHot4d6KnH1N + efPWhAeT29xz3+Ro9vtUJ7/LQt7mTjfhuN8xczv84MVVNOrM0kqKEnKW0ropmQGldXlg/eZd1wnaQiQR + j3p4sKN2G5a39lS3Khaze9ZunQbS9A7zx99gdn2Xq9Cx9kfsZU6SCsnlFio4zP3IZc9GxR9Kq5fabZrI + du0ZpFXTeCwOTiqH1p7CzZp/zOpkeJsmBVcZ/ZcA2iqhM+pvq5FARMlqUDfBvx47+X+Abfx/zkHP/xci + 7vHzrF+HAAB2tZ9jnYHCuijH5z1eshvTmLGjAGmbRXqnwGUgNdfotqFfPCdIxTaY2qubz6lu3aO69RrT + 5QnTaorXKV6PSHqM6oJs72kIsmZ4f7DyNpbZMG6KgU/iszDAQCTKnIDkkVQdMChNjJkt6hVmAvMEE0W9 + A1/hXEV928PXherrwulbNW/en/Kd0zPerr/Jsfs9xP8BcfEtJnKHWYQqNohuQHpgUrrfHBKrgMjhso73 + hP21kJgGO2AICp2iwQxZu+OOVAXqmTI/rZDFEZVfgr6BLGsmkxNm8TbzZgJdoJEZPUsiUxw7CzGSstUW + h02cBVBlkPoaBabS7vNibUJVK59KSTU4O4/eTTn98x/DlHKhcpcAFzF8aQ+hi/QJAiEr+5bnGH64nPx/ + DvxTbPP/AAsIv/Re/09avy4BAA7tQXN4tqsfgd/FugM/ZjmWxnG3I08UJdj16FRsz3X5ZlpO4f4eF3ZM + ZMliOWVezfByhugdSHcQjvOvcYWzam20ROH85huv1PcZmCpWW0NvyQp9EwmRfKJk1tqAD+abUBOxinTL + RO+U6kg4e9tx/K2axdePOHv9hLdunfD24k1ec99hyu/Q+2+yn91F6hnBBfaaaDQxo7c5CRVD/rXLN7RZ + 2xYYUMSNd439W5krLpN4ySEhkpIS6kh7HAgLwc0mTJeglVK7ispNkXrOpJkxeVLhJwkPdGHCVhYEN6eW + FVlPCacOl0yN32VWnpGGSjeikKwKy49B0NVImKMUf4zoqXvpLZXx51G0Ezkc6p2QWoidCYBo0sNz3dQx + KwaeP8Bq/n/Gr4jl93nWr1MAANsSL7BMoIdBh+n3gfsURaHD0ht/a4FzhA2HdLBoryx62K5IfUsfK3b3 + PfFkzqQ6o9YtXlJup3lKJWLiv1U2EM51tMs8ADIfvdADfL4xM7+02HbZKZf/LoYdmFOU4vYJYqKf9uxf + 74jzxNmDxDe+VfP1r59w586E5fyUZfUWR/5beP0mwn2cP8XNa9I00fjEtQrXoWaqjoVYMZPoCRoz+Gf0 + wYESq4UMX8qBQp/VYYO4aBhHAvZTZXsU2SeH1jMmkyneCxM8lUyAmspX+JnSLZW0E0I3oU9LQlqCm5Ok + NVBQI04Tzgm+SvhKbTYnd1PKxisIvmbzFc3grGEWGdvIFGDTbtCbzEkxdcbsEcSgG5BNWwiGKXVB6JOQ + hmmwG5LB5VD6Lnbql7T/S7H54dcvAMABGOw49GCKYdUDrEFewvNN5mgAtii7gdty+OouQdeA7ok1pKUQ + jyqS3xoyjbWxhCUUbn9WmEnJ5XFfl5WA80haSui4WjlMu5gm36AYVKBrIamYRFhvTEeVSH8Wibc66tcS + d7+pfOebM37/tbu8NquQ9AZt/2326R3a+DpB54hPpLoj1om2SmxRNhFOccyzDHciEJJNOgoxb4Z8yWRU + Kw8XKmWQjUEaW6N9ANtaWM+FJlYgNdPc3pwgVFGQ3sRS0rHiXk/MBE5Xnr6b0sYjkNNMBtoauUasU5Kq + iPqEhd586KfRqT5W9sny6Zq1/8YTf8nla0xm/WTwNuEG0Q9775meHPPwT4A+QZegI+UCAPIvLvZdpc// + z/kFC3r+ItavYwAA2/CXmNuQcPAU+gNMS6BYBcA4CIw3/MurB9YKLxTugO4gpUSUFZE5KmuUNkuB5acU + G1cZtPOGWt9SV9MUyNsoFqTfU/wEi1FI6VHbMBGm6BshOiEsHWEKk+PIrQeRr70tfOv1I95ZTrglxzTd + m1zEr7HX1wkcW4Lh9qjrTbS0xJ6shGP3v6XzegP9LxeqBLcDK2CwU0OHzV9OyFZhUwnrmafNfIdZnrCr + 1ERHcIosI3Iflgvl/mli+UK5Xk3YtCfsInQ6N8kzWaGyIUhgr5FWlT4pSYQqd1sHCcRBtlsGlqbm7oEM + Ls9ZDTgrekqZ1swWaJqBvxJPUMncHjEVo2jKPzttaegJ9KqwA/kI5HvYxv9jjLh2zpdo88OvbwCAg4Xy + 9zG+wAYrCQJmOHLCgfo2zgTkM5+xx7pSO6ADjYrSoQPpI4yeouTzRUgiZ5wuW3IXp9ssJEEwzjpgngI+ + 2J8ud4cGDb9DYhAmju6WoLWyuKO8cT/xjTuOr02OuBcq6nSLfXidmE5JqUYJRAkWqIjUAjMR5gLTPGNQ + XvXLYzXlGLTDswQGW0NPvgTQYO2/0MM+ChtxbGuhFUPxJ4Vem3L+M1dkIUzvwHGnvPEa+Gee9mLG1abi + sj1m3TV04Qr0OYrSxA3nHbxolW0qtX5mZGY8xYYxM2ZBZa/bgZ3kUMQDTOAjv4eC16iRgagkCzbnEifo + IXj3EPrEPrRsdUtDlwLdFsKHwB+D/P84KPle8wW1+n7S+nUOAGAX/ApjWeV+HHtsC38TExud8hJk+5mr + ML96BoanppQ3VFF9HVFmlcPJKKMsoAzLO3JdmoHCsS132emFpVZorpkinESIE6GbOfxxYvZa5M495fWF + 426acdQu6ftbBD2l11lm8nWo9qA9HhNHPXLCsYOlU+p85kctd+qnXxYpNNwbzRasxCmNj4DJY0WhUaHx + Qp/DrU9KSkq2VMBPwE+V2RxORLhzz3N6e468WLC+Fi63ifWupW8WuE7RrmHddnwUAx+4xGPJnMFhRFcH + LVYpHZnSPcgTmFIEZJFspcaAuRy4RVkvssK8F1IZEALthdQJqRWz+k6dBpoVdD+E/Z9A+M9A/xXG7d8w + jphfovXrHgDK2mGqQi0WEK4w2uXvYeDg5HM/U4BB5bkMennjzSdam23PAvk6JBgHZt9A+hHy4Erp+5cR + gsJX/4zkZDiUleQdqRbcQqiPYX6kLCfCoq2odULQGUmnqFp7UjQOCb0DpqIsRTkSmIsxGIpR5VANlWA0 + bv3dsDEb/pGhy2HCzPTJSoA9MkzFexj094vrWDWB2VJZHsFp7bhzNuXu0ZTZyYT+0rG7VvbrhrTGaNyb + K67Tlru+YeYU5yKfJMcaR19lnDU3KpyKeTHmFExFzXUplzGiMRMtD3S/wjQslGDKZ4W5/tDm2ZIdhBZi + VFXSFrr3oflnsP8n0H0P0sdY6fkrpff+LOs3JQAkYI0FgR0Mg9qlYn2Dg8rQT3+mEgQ6zAZbUs4Adih7 + hAVCjZRUs2R+mm+sIiM1cBdN0NJ2zkgqGzh0Mz+Nia83/skwMCUQ6aWnpyfmYRqPtxM3mwI6SVROmAhM + xYgShaukxVn4BuHn5Xv40zIDQ8pVLZAEhV6FPtrfY6YyC7mursDVMJnCYgGnM+VsIpxMJyxlwVTm4D3H + VUArAb/D+RkqU5o0Yd63uC4Re8MC9g66KhN/Rr4L6mxew3KDjPXn4CvlAxmh95rnNQblcjHGpu49caOE + a+hWym4baLp96LVdJ7oPof9j6P4pdH8M8SE0v5KR3r/J+k0JAGWVnqxiQeAaQ2X/NiYscspPCwKlNdgw + YAFUCq5gATvQU4QZIvWAIpMZbDKIg2Rqr4jlywM76UBiOfzCmz334W8JXFCkU1ILXQeNj2y0Zy5C67Z0 + ukOZ47Wiwg+MvTT8jwHftylaOymTjvX/iuDpqG1GHq29Mbh0eJVJoBehUwjRTs7iqG4pNcgE/BwmM1jO + lLMabjs4xlHXNTKdwNThJ8DUBolwHirPsnK8qaCd0raJa4UVQussC1CXmwVZXWls3jKIfQo3W38FqPHO + 4q8XXJWzmr2Qrj3pAvoXid1Vz7rZ7Tdp/WLP+v3I9ruw/xcQ/jXoQ3jypd/88JsXAMA2/hNs+15iyOwa + ywi+jYmOZj7vp6yElfoNB6/HuaKuI7HDpV0mzuTjQ9Jo8k9y+jzSnk+SWX5pVJOOXD0P86yUefYxS1UC + SCfo3hFaYe+VnfZsFXp2BPa57k84rXDq7DROgTZCExONh9bBzMFErBwJorm3bemyDL5fh5NSdFwO2NcP + uYO5IPQqxAAa1KSzgDS1k7+SUQlQC0c+lyOq+BgMReydtRM0C6gsFCaK1HAUhLcaYbWHx0l55hIbZ7oA + UcTKgCQkVzQby2XN5ZnaOHYhEUmpebKJiIq9bjqFtZAuHOG5sr8IcbNtd6u4ebrT1V93rP9Eaf4VhB9A + /AS0/aJv8s+7fhMDANgWvuAwsbHjkA18C5shOMawgZuBQLkRADTkrr+PJGmJoUUIAyVVMdmqMo2mo8xe + y42p3k4iyRD2wAq000fyYAuZl695k1pO7yAIEsRchJKdtCHdfETNMUatTEgd7PfKuoZrryycYQIGnIs5 + Ime1QvmxMqDQJMrpX/rsh6+qCjE5YhJitvfSmFnyYgGAHoqhcFH5rVUR7dG4J/WKdh7aiAudXdcqmpaC + KhwLs41wpxUeAG+o48oLe2d+AUlBnct1vBQDIAukUbLXIICpO9usgQwN4tglwkZJ64SuPXGl2q37/a5p + nm/D5mHD9q86mj9X9t+D7q8hPbP76V2+Kus3NQCAffRbzI14i80SfAz8IcYcfAebI/gxCvENDCBm3KtK + xCy4JxoRLKXXFEzYQosMtZ06xTz0MEFTDWy/zGg5dBCL/dhg4JlPWWfVvfOOuo4sK8+Rr5iHRJWmxDBF + 04SQKkISUrJZv6QR3Uf2lbKplesalrWykESNmn8nBnzJuCzJF0Aljf8rj8zmjoUqGoUUHDFCH4WYjMCk + WVNAzVoB2UGoIUwhTg0nCCSCdkZxjj3aVbgefOzxGuy6itqdOxfciWPZOe4h3O8cT6g4F08jhjMkcebB + IFZySJWvXW9Cnqb96XKEZBhkSiHRrZX2RSRcQmoSsUt92zZPdmn9/YbNd3v231Pie8BD0Gt4Fiyh/Oqs + 3+QAAHZnN5gLS8kAzjl0Cb6DzREcMb5WkaEVaBNnkIr1lSZisRJPJlZpmv+F41tEPcrJWVp8I/HKsukK + mlY49iVPzYo2sYJYKZMlTBdwPBVuVZ7TOGGuU1KaI3FKTBVdcrbzMktH+0ToHE0H6wQrlGOUBcncy8mF + ylgtZ0iGDhLhN0DCZKmG9kLs1RRyk4l3WutNDlYbAWILXQv73oiWDbBH8QScRmKMEGq0d0gIeImHeQ1V + mIAsHfPWcSs47uA4Dp6qeAFSan8j+zgPTJNd6gIWZtKPilgQ6IzD0G+F9lxpnqfUrWJIfdpF+sdt2v6g + 0c2/6Nn/iRL/CuQZ+Nao/l+99ZseAMoqXYIPsZLgCsMJHmHDRN/GPAjseo3L3jErdigkR6lxEfdIZZhn + BACOva+Bogc40POAYhVetHGtZDAL8lQrukjIiTI7SpxM4ZYXzpynlpqOGtGKlBxJLTh5CuCopCT0KuxV + rC2S90CZ8B+/yZehyJsjwTlYxazC3Ap9B33MGECmNpd2O2SyXbLvaRLs9ACpTFEqNY4FKWV8NJlOQvEo + kGROUDOYzOFoB0etMEs2xDwYfY7m/JXc/6/0QMnuxUooFcTZyR+uE/uLyP4yxnYVN/2+expi98NA+4Oe + 5vsxdX+pxI9Bz8G1punx1VyvAsDNVYwZrrFRzSdYRrDFsoHXgBlF7q5k5nCIAoOQ/ED9G3H/83y/mkGI + ZfKjIRQFSdm08uVyAPIUnrfEwDmbSVhE/DHMF8rpJHEL4dQ7xHvWzuPKzLsqThKeiLiIODHBYrFKP1JQ + +kLvHd7U8P83XQFeCgC5oZo6R98KXefooun9xczIK8bA5fkL+bEF9nKY3LJy4ZCOZ2M/AyI1ZuQzZldn + h69hUlmjoO45dF7yYN4Amg5kC5BMyVYVtHOkFmgSaRPZX/SpedF17TqsQ98/DHQ/6KT945Da7wZt308a + z4HWuNr/3y/6nv0brVcB4MdXwDKAIuuywoLAJ1gm8CaOW1Qssc6atyBwg3xuzzSk9kWnJG/+QQp4/H2M + Mgjs+8fuQOVfFVSdsd6c4mplOlWOptZGO1VhKY4gHpeFPgWHE80G42r9/qwp4EYn8/iRXxgvn/uH/y+v + NQ2kRQ3OnHGCo4tCp0IQSJlgUFTRyhOkbJ1gWMaBlGFxUQb6s83z5FKoGBtInrGoFFdB7WHilMplEnNO + tHBqduyaT38FDbmv33p0W5FWQtwmdBcIq7bfX+4v9qvucbfvH0bC+0n6H0S670Xp300aLpX/95eS1ffz + rFcB4NOXYp2Bkg08wujEv4vj95jwHWa8xZwzJszMls4jWmUCUJHSMrrboV9esgOs1eTyEaXY3eqKKcjB + OMT2n8ulhplXRISY+4ETBydeuVvD3RrOomPmKjbUGLevQkSoUCpVqnw6Oi/4GqpamXllJiZnUg5J/YzL + ojf+nmnOqiZYGpUYHW0S40SKKfUWTqRRkGRgIvrKsM+Jh6nLbcFDdGHQ80pk/e0y1FkCgLVYMzWAylmd + L/myDmSecvmjoHtBg5BaR9p50soTr0TjOmrc9bu+aZ91u+a9tuv+ok/9u1H7H6mLD5PGT1TTter/69dm + 88OrAPCTVqLgUnCF8Iw5T7jDc95kxX0Cp7zDhNq0rj3CBFELADb24m6O0A6pqU3AlcGUYdBHRkWyS9zI + mTPHPqkQ1NFnl8upi5xV8FoNr03gtBcqcUSt6LUmqTfnY0lZryg7AleCn8J8CqeVcibKUqF++ZQf/mss + Cz6mH1oAkCSkKHRJ2Iuj8ULnTIqrxLHydlLm2/sJTGs4qeDEm7zzpJRUJasqNuoKJg+eH8TMsdDDq3KG + 9FMZnFJQE9NQMCafbhxhC3GTCJukcd31ca2buOsvU9s9CqH/oIv9X4TU/WWU7sOo4akmXdt9IF+qSb5f + xHoVAH76Mu5fzTO+yY7fZsvbRE45YsFtJpwiUkuqjP3HDCk4usKwg7X0yvNNm12BGAZVqsP3ChYAMk3Y + xCosCwgIHY6Q0/pjn3i9grcmyhu1cJIcSSo6rWlTTaKiFlPPqZOgauWB1FDNE0fzyJ06cUcSJxip8eCc + Z6IlhQxUXpxwOFZLQ6PM//cq7Jywqxx9TnqqIoSas5+U5wDqGSxncHsCd53RMKcl5umhFJCkh+tXZo2l + gIGjT6r4dkwyhTdiU5t7Z6n+dU24cvRXkW7V02/aPjb9s9Sl94n615rCXyjphygfK+m5kq5V4i5qH9Cv + dq3/WetVAPi8q0P5c9b8fX7ELV6TxIV09MWe2jhDC5AlmvlDB8esEbBWRCoGe+oRYJWxAC3TLM4ZNyC3 + 4Qr416sjOsfCJW454YGHN51yV2Aqjo1M2cuMVmpUHF7Bq2QWoCeIQyulqiOLOnHqE2eqLDLrsNThAzlJ + x92K0sjLrzmf0FICQIIWk/EMmYBT0v7iupPyDMB0BmcTuFvBHTHmVY1Ba7SKtgp9IiULRPYwcZKBVxws + sHixEqBKQhVsACi1NrCjayVdJeJVTOEqxnDdh269a7r99nkK7Q/R9D3v/Heddz8Q4RMRt5UkUVSSqOiv + 6+aHVwHgZ1/fIjgHbs/Ub1m6RC2uto0vx5i2fgkA6aBDV/poSokKmeVrijs4yeSgzLH3DpXq4C/gbDQ1 + iSc6B15Yerjv4GuqvB4Ti2j+BI3M2fsFsZ4iKrahotAlT+scrYBIYi6JCYmZKFNNVGQK8EjpZyDvMBI6 + GQOYMEwAalRSTMSYCLEiqjcRk+y5FyulnyTSRJlMTWbxtIYzDyeSzR0SaKOkKyVdBWgUSYpk2mDVK74I + fEagtRS/9o6ZCLMG6p0grRD2StgmwnWgu04xrtmmnV7Epnse2t2jGPYfQf+eQ/5amHzgZPLI1dXmcvMf + fWmn937R61UA+FnWP8BL5I4kHnjlDV9x5lJViRyjcorKKVGWCLWlzqmkqC4floXoU8wqM0GGhLhAEREd + JtKkypoVLjvaViRvdN+pg7sT+LpXvoXyRkhMOyEET6szOr8g+UkWr4C+N1S+qaAnUWkixEQMSnBKEKjl + AOxZbBpgvgNvfgD/5BDYyiMmEwMJ1k9P0RFTbT/rlY5INwOZRGZTZV4LRx4WYnRLn58i7YR4mUiXEW0S + TqJZ8GpE1Aw8fAQ6gb1DgyckIXSgFwl52sNa6Peawj6kZr3v2m27Sm14rDF+oCm8l1L3HsQPPfKJo34B + rAVpnat+YzY/vAoAn3/9P3D0nBH5pkS+7SL3vfiFuGOEuyB3Vd2RwAQVP3DMrVTWgTs3FAPiRjP3BR8o + w0Iun5zZMkxcVgr3RLG+45FLvDFNvDNR3qkSr5OYRsc2OEKckNIUUoUmNUpuEroEvSghAlHpemUXTLJr + k6sNL5qHZskiIqUdgdGCbwiBHPqUksFATclYfn1FH9SIe+pIPtFX5vXj81Cfte4oYur2TAm0E0Pod6B9 + RCY94nucTzivuAKo9g5iRdNNeN4Ij697Xjzd03zchXAVm9hx3cew6tr2qu275ymFjyC+B+k9iB8IPBWq + DdT9RJb6rP3fW+P3N2i9CgCfdylThPvAd1DeAe4IdSVyC+E+IvcwK9yDimxxnzn4AKQRbdCNRlSTbXwd + HT5ShO0sK0gKEYcXWHrlwSTxrXniO4vI27PEUX0YENLeIZ1DW0fsE0GVIGYz5nNFQQ9tFNZJuIzmKDh1 + iaVYip1UTbtk7E40Hv+l/H1ULmAegiEJXQz0KRBjlccaim120dkVRs98eNsYUKnJhnVE00AAEj2wGEnW + z29aeHQt/OA5fP9xrx883rQXz1aX3ab9JEb9QIWHmniGpucM7M70zAzitAn8pxqA7a8dvv/51qsA8HlX + xxTlAcpvYxODt5Spc9xC5HVE7iBMKbTY4fZ2o82f3WqlkIEGHT034v/br5OsX6dl7j4JVacsXeLBXPnd + hfJ3T5XvHMPtmZgLcdYQ9T34VpDONklUJeYJw0rBRyFEISRhq45VEk5FOJOIYNJgARvOKeDj+LUNk8qj + YGAOu4mottF7Ir0GYlZIMnnUXD6MY0oGUQs9SsXhvTOVkrkY6U8CqU3s9j0Sg9lxR6HZxfj0qg3vvtD4 + Z0/o/uLxbvfR+fp8tb38KPTNe0L6K6H6kaN+CvUVVCtwW0yxN8J/+kXfVV/4ehUAPs/6hzgiZ8A3gN8B + vgnVqeixs41/D+FUDvKCRVyCXPLrIKQp6nJX4MAjNs8AGeYFKLV2nmhDFd8pi13iTUn84VT5zy/h79yC + t4+Eui624iY4IllLVPLIa3JYP17BJ8m6l0JUR5eUTq1llxRcZguqWKodNbcAteAVMgSC4lScsLccVCzb + UPu5SCJlNSQtWnrZO3BMmiz9epdxBe8TrgY/90jw9K1nfZG4fNiwu9oTAuzVhRftfvXxqrn44JrzD694 + 8eSqe3a53jzuwv6hsv9I0IdCfC6wEqrWrsw8wf/ti76jvjTrVQD4aesfIliL+uvYPMC3wN+Dkwq5i3AX + kVOMxlJxILXKsPkPU383k2bgJuNmsJ+WYbQ2JUUC1NvEyXXkTR/47ZPIH9TKt+dwPBnbeFUgDidmUeKy + +rDzUDnBo/hkzGStBfGO2huCPnFC5SJeyB6BiTr7GCZhCFrDax+qAtMoSOroSfRqcwWKR8ThiyKPO5iG + epUB9sgDhES1jkPsI6HpSduA7DzaV7patemTjzbp4++v4upJE7te241zq4d9/+T93dWPHu/bH6279FEX + eBhDfKQaXzhkJbAzClCKkf/PbxS493nXqwDwk9Y/ABLHCN/CPAW+A3JXWFSOezgeIHJPhQz+DaO8BSwj + 81LLxBwHZtsoKJRhHZxNpIEx67RX6EH2UF/DfK0cTQKL/R7ftcTQ0ceIOI/3M6Re4OoZVT2lmtbU4qlF + qK1raOxYBZ0osvDoPI8QTxxnTlhKosJm7isSThJTH7Nk2Ev5fwE0E0RJNGLGGL0oyQnOV9QyBVdZ1uPB + OyuPJlGYZKvBvk/s1gENAbfv6S5amg93NB/u6a603/d+e7HpVh+9/3z98fvnq/3T3cZHrveVXHwY09P3 + +v3D53H1MJEeTfHPKvyVx+9PeCv9gP/7F30HfenXqwDwk5ZR2O8i/D7CHwG/jbpjOAK5j/A2wmsY+HcY + +KE4xGbgLYvSZQuqA+yleUOYsaUc9la0XjhrYCWwEWQn+BQ1nSZWbcPD9SXx8pqjuGc+mcjp9DZL5hQX + X/URJgHnEpVEVC0DcE5JE9CJeeotMEfDI4qr4YHoYxm6w/948Z8HgMz8M+0TXZvY9YkmmgKR4PHicoZg + R38dTATEJ0V3sFVF9j279Z75ak911dA/3en6ozUXH226y6vu6rKPD5+33UcPz1ePLl6sn073PL/N7IVT + uQzKdae6bolriGuPNh4ND/njL/rO+cqsVwHgs9Z/hJA4Fsc3gD9A+APEvS26nIneQ9J94A1VTkEKg76M + ABfv+sPTSe6lH2S/OcwE+IxqJ5uN1TXouZCeQnwh0W2lTSJNOnXb7lj3V6kPH++2cnnxwk/2V/Wylvlr + 09XynmdeddNqtZtwvY9staZzkVjUhYDkdegoSKhIjaerhW0+oWtedgbmxwcCFSQqLiqph6ZRLrfKsx1c + trAL0KmgamWAFEg0dyB6RZtEPO9iYNv106umPVnt+9N129bnu279ybp/9PB68/Bi++xJ23z4JLXvPw37 + h/sQHt+pZi+WVX1+4txuEV2YJUkzvAZIFaJP+O4Xfed8pdarAPBp6/+MQzkDfluEf8sJf1uc/zruZCn6 + AJ++icibqJ5JYpoJPOWUHPP6zdGWQdPPjcQ+Mhrgc6cgCewgXZmgdPpIiB9LCs9l43oez071wyjygb4h + T6PT7Tb2brXeztdXF2d9aB7c9i++eb9ef+OY5lYKu2oXX2fLlFbMs96qjdxZ8II6j5eaJJ7khJWDqTtY + YRaGooiVAnLD8MQClkuKBmh7Yd06Vp1nE4Q2HYxFJCsZSRLc3sHKs19LuNrq6nIbznfb9rLa9hf3NZ2/ + 49KLe21/1a/6/X7VNeurZn3Vbp9fsn96Rfei91zPJ9Wum8Xu3/udr6Xf/af/2xsf2/qLvm++gutVAHh5 + /QOEyBHCd0T4L4jwR97Jt51fHIk8AL6DyDug90g6zYfjy5NyNVbzG8ol49jACOjLPnMK6F5J50L8CMJ7 + EN8nxU/YpZU8Evhet9c/Cbfkexrch1Xl1s7hr/bp6IeXzb2n1xffXqT0h29OrzevT/Zfm7n+WNiIykIi + QRNRB9xBsgZZqDyh9ttUuSuQStCijnv4/4SXDic9rqD5I+KPRTbREL32aRK7VKeQXFY/zPPKNgIoEkT9 + qpb0bNKvnrjN4xfxycPr7uH5rv+kSvro+rj6ZHl3+vBsLi+q2jW+ctE5SU5c53GtF9d1pLDSPv3ji/+A + f/xPv+gb5ddjvQoA4/Wf4EmcInxb4I+c59/23v+B88evOblfifsW6Dvg3gBd2v1/w+5t1NvSg37+MLU2 + so2XhMlR7SFtIV5AfATxR4T4I/bpMZfpih8R+QsV/nVs5M/6hnd3u+rF//Tv/y8iwH/3P/43/JPr/vHD + F+F8mtJVmK2ehPmLB6f13aOpWzovLaoRzR39vGtNoaOrPF1dafAuJREVHdGQ8sy+RJy0eGlzADiIheXn + y99bpcQsJZ1EwetBTWiYQkJ6R7WeEi6mYfvUb66ehPPnl+3jJ7v+aeXl2VGcPb868ef92Wz93/wn/34E + +E/+nf8Dd157jf/i//y/dMAgv3Tuel/t9SoAlPUPEWwi9m+J8EfO8feqSv6O80dvOffWXPg26LdA74Me + ZTCvmHmU2n+kFTEIf8KQ8o958x2whnQO8YkSPoHwkDY94SJd8olueZfIn2Nqk++q8jhGWR3fCcMW+F// + 1/8k/p3/2cm6DfzIJVYh8sOQ9DimVCdJIhoFoqrGUR2vRRtciM6lKJJSlgofXrxFqSQJLwmV+FIAkFEX + wyb9k0Y18rCok1HXIJWJQiSlhCZNGlKf+rSLfdqGPm00ya6P2vZRO5HDFv+v/Z/+/hd9V/zar1cBAIzo + g7X7xPFvOvh73rs/dH75lnNvzEXeQfVboG8CRzacM2z+jPyXBv+I12+Aum04CdiJnzC++UZJzyPxERo+ + IoZP3DY+52m65n06foDy55i9+UcoL/qW/bv/4r+j7/6Lmy/9u//jVXrn32c7F5rZhCfTyrm6qqRyFU7q + kc1XWfn1VhUaK7xUgxu5yk20XwAv9jxORhTn4XksAKhWJK1IOoh+5UqDXAIo4hzOV2jlcROv1QytZzFN + zU9dp1On3gv/jX/0733Rd8Nv1JK/+VN8xZdt/lvAdwT+yAt/z4n/u96fvOXcm3ORdwS+hepbGB+oMt1/ + 7Y2bPrT+Bl6rsfKcZF19RXqQLbAVZCvoSonnIYXHoQuPtIlP3HU8rx7p1v0VQf4U9M8xheIX+Sc7+He/ + 6Cv1av0art/cDOAfAeBRTlC+gwF+/7Zz8ncqP3/byRtz5FsY7f8ByPHocg2p70u0GCmqF5gaJkgHbBW9 + VrhU9EqiXqQuPo/b8CSchxfpeVxVj9n7D0h8H/gzbPOvGSreV5v/1frlrN/MAPB/waEsEN5A+S2UfwP4 + N0X874g7fiDu/kzEAD/lAXCKDESfhDi1/nap8zX3+ZOgwcHewRZkneAqoVeJdBk1rtKeFRd6nR6ly/go + XoZHacMTen2C8gnmUvQQZAX/7q+V+OSr9eVcvzkB4H9TQUrCNHmUU+AbCH+I499C+QOQb6gc3YG3ZvBt + Ud4BeYDqKSb3ZVJextp1gynI4OEXMRJPk9CVqpyDPgWeqKaLFMMmbPomPNF9ek8b/oJGf5j26aH28gIz + KV3ndL/hBpr4ar1av7z11Q8A/yj/WehmkA9qgSgqTSW0WmmXFqgeE+SU6O6D/1v46j+H+L+LVF+HxRH6 + ukvyDpFv4biPirH8rL7Psl1JTR92q8heD5LVbUBXPaxir9e6kwu31ad+J89kF6/TNnThIqbwMIX0Hr38 + FYEPUX0KsmFwGSyi3K9S/lfrV7O+2gHgHw1/O7Se7U+bao1OTKubM0TfBL4B7k109iYy/wZ++dv4o68h + p0u4KxpfJ8UHaLgHHJvGdGnv+dzA7xW5TvAkwZVmmfoEqzbxfNNw0VywjY9oqoeynj2S9eSZdu4ykq7U + 6SWJc4K8IHEJbIAe/gevJtVerS9kfbUDQOlWjXQpTD+LiigzEgvQ21R8DXG/i7jfYzL5JrPj1/Enp6Tb + p6S7c+S+oG+g4TaxO0K6ytQw4r7weG1Q3hFopeeFdjxOPZeSCCJ0KXLe7vlkfc756hO68D46+SFp+YHE + o0fI7EIrtioSDEBwatI26VWq/2p9oeurHQBg3MhU/isg/6FTTc6TOEH1PsI7VPK7zKZ/m8nsbzFd3Kc6 + XRLPHLs7wu51CA+Ae5COch3fKtumZ9/1hJAFbaQj+mta/5Sdf8KmOqerG1QiHcoq9ay6Fdv9c1L/CaRH + UD9R4iXCnu5/qCz+l7zkDvrZJjyv1qv1K1hf7QAwrvk9yH8wga3zEmUKnEJ6E6+/xaT6ParZb+FPH+BP + juBUaM6UF7eV82OlqXMxv4M+wGbXcb29ZrW/pOs7kkaCa2j8E7rJu/jFu8yXP2JZX1K53iZeADEbCtAd + aGPOsZOedEfhfwdNANfpIJPz4/Igr9ar9StdX+0A8F8G/q8oSYStFzpX0VYzendE0iMkHeM4oqqmUk2S + rqYbqnmPLmC9CDybBl4Q2O16UteDJvoY2PZbrroXrPpn9GGHpJ5Iw9Y9YT97n4V8wGuTx5ykNbd94gqo + BVyVQUMF5vkxFdOv9oo6Jf73v+ir9mq9WsP6agcAgP8qyP+xgs5V9G5G646k9Uui1Kh2qLwg+g+0czs6 + PSVRk7zS+p4VLet2T9NsCWFLig09e3bVhnV1wc5dIH7LVDsILW1a0YZLfFwRYsO8jvyH/85nvLD/HiM5 + IH5c//bVerW++PXVDwBgrLsgjiBVfgi93xPlKUH27OQpV5yyigvaMDHsLQVCaOn6hna/pmvW9GFDV+1o + lzua4w39ZMOEPbM24DUyIZJctAkZlH/83/oJL+p/BfxP9KaLzn/7i75Sr9ardWN95Y8k+QdTWIvQS03j + pzR+JvtqQudroqvoXM2aiZ67iZ7PJjRnHr0H/laCWSDGln7X0G4b2r6hm7S0Jx37W4F4EnG3Eu3/6It+ + m6/Wq/VLWV/9DGA3jNxmLh4948H8Q+ZdtKnGzcOi3hmz9XNCU6LfKfv/+It+Z6/Wq/VLX1/9AFCWbfSU + 5fhMhqc8vNg7rcnWt1KcbZWE4n2i8opWysf/zy/6nbxar9ar9Wq9Wq/WL3/9/wFISBosu5pWEgAAAABJ + RU5ErkJggg== + + + \ No newline at end of file diff --git a/PresenceClient/PresenceClient-GUI/PresenceClient-GUI.csproj b/PresenceClient/PresenceClient-GUI/PresenceClient-GUI.csproj new file mode 100644 index 0000000..9d2261e --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/PresenceClient-GUI.csproj @@ -0,0 +1,137 @@ + + + + + Debug + AnyCPU + {E1E88510-EE21-4E59-A5FD-052063CE7AC3} + WinExe + PresenceClient_GUI + PresenceClient-GUI + v4.8 + latestmajor + 512 + false + true + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + Resources\Icon.ico + + + + + + + + + + + + + + + + + + Form + + + MainForm.cs + + + + + True + True + Resources.resx + + + + MainForm.cs + + + ResXFileCodeGenerator + Designer + Resources.Designer.cs + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + + + + + + {73ead2e4-0f1a-4d06-a84d-13c2ebaa03d8} + PresenceCommon + + + + + False + Microsoft .NET Framework 4.8 %28x86 and x64%29 + true + + + False + .NET Framework 3.5 SP1 + false + + + + + 1.0.175 + + + 13.0.1 + + + + \ No newline at end of file diff --git a/PresenceClient/PresenceClient-GUI/Program.cs b/PresenceClient/PresenceClient-GUI/Program.cs new file mode 100644 index 0000000..6e68105 --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/Program.cs @@ -0,0 +1,18 @@ +using System; +using System.Windows.Forms; + +namespace PresenceClient_GUI; + +internal static class Program +{ + /// + /// The main entry point for the application. + /// + [STAThread] + private static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new MainForm()); + } +} \ No newline at end of file diff --git a/PresenceClient/PresenceClient-GUI/Properties/AssemblyInfo.cs b/PresenceClient/PresenceClient-GUI/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..de3bb1b --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/Properties/AssemblyInfo.cs @@ -0,0 +1,35 @@ +using System.Reflection; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("PresenceClient")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("PresenceClient")] +[assembly: AssemblyCopyright("Copyright © 2020")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("e1e88510-ee21-4e59-a5fd-052063ce7ac3")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/PresenceClient/PresenceClient-GUI/Properties/Resources.Designer.cs b/PresenceClient/PresenceClient-GUI/Properties/Resources.Designer.cs new file mode 100644 index 0000000..457144b --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/Properties/Resources.Designer.cs @@ -0,0 +1,89 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +using System.CodeDom.Compiler; +using System.ComponentModel; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Drawing; +using System.Globalization; +using System.Resources; +using System.Runtime.CompilerServices; + +namespace PresenceClient_GUI.Properties { + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] + [DebuggerNonUserCode()] + [CompilerGenerated()] + internal class Resources { + + private static ResourceManager resourceMan; + + private static CultureInfo resourceCulture; + + [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static ResourceManager ResourceManager { + get { + if (ReferenceEquals(resourceMan, null)) { + ResourceManager temp = new ResourceManager("PresenceClient_GUI.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Icon similar to (Icon). + /// + internal static Icon Connected { + get { + object obj = ResourceManager.GetObject("Connected", resourceCulture); + return ((Icon)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Icon similar to (Icon). + /// + internal static Icon Disconnected { + get { + object obj = ResourceManager.GetObject("Disconnected", resourceCulture); + return ((Icon)(obj)); + } + } + } +} diff --git a/PresenceClient/PresenceClient-GUI/Properties/Resources.resx b/PresenceClient/PresenceClient-GUI/Properties/Resources.resx new file mode 100644 index 0000000..5778670 --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/Properties/Resources.resx @@ -0,0 +1,127 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + ..\Resources\Connected.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\Disconnected.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/PresenceClient/PresenceClient-GUI/Properties/Settings.Designer.cs b/PresenceClient/PresenceClient-GUI/Properties/Settings.Designer.cs new file mode 100644 index 0000000..e93117e --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +using System.CodeDom.Compiler; +using System.Configuration; +using System.Runtime.CompilerServices; + +namespace PresenceClient_GUI.Properties { + + + [CompilerGenerated()] + [GeneratedCode("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "16.6.0.0")] + internal sealed partial class Settings : ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + } +} diff --git a/PresenceClient/PresenceClient-GUI/Properties/Settings.settings b/PresenceClient/PresenceClient-GUI/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/PresenceClient/PresenceClient-GUI/Resources/Connected.ico b/PresenceClient/PresenceClient-GUI/Resources/Connected.ico new file mode 100644 index 0000000..8417988 Binary files /dev/null and b/PresenceClient/PresenceClient-GUI/Resources/Connected.ico differ diff --git a/PresenceClient/PresenceClient-GUI/Resources/Disconnected.ico b/PresenceClient/PresenceClient-GUI/Resources/Disconnected.ico new file mode 100644 index 0000000..f081898 Binary files /dev/null and b/PresenceClient/PresenceClient-GUI/Resources/Disconnected.ico differ diff --git a/PresenceClient/PresenceClient-GUI/Resources/Icon.ico b/PresenceClient/PresenceClient-GUI/Resources/Icon.ico new file mode 100644 index 0000000..06376f7 Binary files /dev/null and b/PresenceClient/PresenceClient-GUI/Resources/Icon.ico differ diff --git a/PresenceClient/PresenceClient-GUI/Utils.cs b/PresenceClient/PresenceClient-GUI/Utils.cs new file mode 100644 index 0000000..ad3ebdf --- /dev/null +++ b/PresenceClient/PresenceClient-GUI/Utils.cs @@ -0,0 +1,49 @@ +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text.RegularExpressions; + +namespace PresenceClient_GUI; + +public static class Utils +{ + public struct MacIpPair + { + public string MacAddress; + public string IpAddress; + } + + //This will only work on Windows(?) + public static string GetMacByIp(string ip) + { + var macIpPairs = GetAllMacAddressesAndIpPairs(); + + return macIpPairs.FirstOrDefault(x => x.IpAddress == ip).MacAddress ?? ""; + } + + public static string GetIpByMac(string mac) + { + mac = mac.ToLower(); + var macIpPairs = GetAllMacAddressesAndIpPairs(); + + return macIpPairs.FirstOrDefault(x => x.MacAddress == mac).IpAddress ?? ""; + } + public static List GetAllMacAddressesAndIpPairs() + { + var mip = new List(); + using (var pProcess = new Process()) + { + pProcess.StartInfo.FileName = "arp"; + pProcess.StartInfo.Arguments = "-a "; + pProcess.StartInfo.UseShellExecute = false; + pProcess.StartInfo.RedirectStandardOutput = true; + pProcess.StartInfo.CreateNoWindow = true; + pProcess.Start(); + var cmdOutput = pProcess.StandardOutput.ReadToEnd(); + const string pattern = @"(?([0-9]{1,3}\.?){4})\s*(?([a-f0-9]{2}-?){6})"; + + mip.AddRange(from Match m in Regex.Matches(cmdOutput, pattern, RegexOptions.IgnoreCase) select new MacIpPair { MacAddress = m.Groups["mac"].Value, IpAddress = m.Groups["ip"].Value }); + } + return mip; + } +} \ No newline at end of file diff --git a/PresenceClient/PresenceClient-Py/README.md b/PresenceClient/PresenceClient-Py/README.md new file mode 100644 index 0000000..935eb7f --- /dev/null +++ b/PresenceClient/PresenceClient-Py/README.md @@ -0,0 +1,41 @@ +# Running with Python +[![pypresence](https://img.shields.io/badge/using-pypresence-00bb88.svg?style=for-the-badge&logo=discord&logoWidth=20)](https://github.com/qwertyquerty/pypresence) + +# Requirements +Follow [setup](https://github.com/Sun-Research-University/PresenceClient/blob/master/README.md) found here + +Download and install the [latest version of Python](https://www.python.org/downloads/) for your platform +### Use pip to install requirements +Just run the following command +```sh +pip install pypresence +``` +:warning: **If you plan on running this headlessly,** be aware for any rich presence application to work, the client must also be running an instance of the [Discord](https://discord.com/download) client. + +# Usage +Download the latest ```presence-client.py``` file in the [Releases](https://github.com/Sun-Research-University/PresenceClient/releases) tab + +Then just run the following command in the same directory as your ```presence-client.py``` file +```sh +python presence-client.py (arguments...) +``` +### Arguments +`ip` The IP address of your device. + +`client_id` The Client ID of your Discord Rich Presence application. + +`--ignore-home-screen` Don't display the home screen. + +Run the help command with `-h` or `--help` + +```sh +usage: presence-client.py [-h] [--ignore-home-screen] ip client_id + +positional arguments: + ip The IP address of your device. + client_id The Client ID of your Discord Rich Presence application. + +optional arguments: + -h, --help show this help message and exit + --ignore-home-screen Dont display the home screen. Defaults to false if missing this flag. +``` diff --git a/PresenceClient/PresenceClient-Py/presence-client.py b/PresenceClient/PresenceClient-Py/presence-client.py new file mode 100644 index 0000000..bf44f04 --- /dev/null +++ b/PresenceClient/PresenceClient-Py/presence-client.py @@ -0,0 +1,156 @@ +import argparse +import sys +import json +import socket +import struct +import time +import re +import requests +from pypresence import Presence + +TCP_PORT = 0xCAFE +PACKETMAGIC = 0xFFAADD23 + +parser = argparse.ArgumentParser() +parser.add_argument('ip', help='The IP address of your device') +parser.add_argument('client_id', help='The Client ID of your Discord Rich Presence application') +parser.add_argument('--ignore-home-screen', dest='ignore_home_screen', action='store_true', help='Don\'t display the home screen. Defaults to false if missing this flag.') + +questOverrides = None +switchOverrides = None + +try: + questOverrides = json.loads(requests.get("https://raw.githubusercontent.com/Sun-Research-University/PresenceClient/master/Resource/QuestApplicationOverrides.json").text) + switchOverrides = json.loads(requests.get("https://raw.githubusercontent.com/Sun-Research-University/PresenceClient/master/Resource/SwitchApplicationOverrides.json").text) +except: + print('Failed to retrieve Override files') + exit() + +#Defines a title packet +class Title: + + def __init__(self, raw_data): + unpacker = struct.Struct('2L612s') + enc_data = unpacker.unpack(raw_data) + self.magic = int(enc_data[0]) + if int(enc_data[1]) == 0: + self.pid = int(enc_data[1]) + self.name = 'Home Menu' + else: + self.pid = int(enc_data[1]) + self.name = enc_data[2].decode('utf-8', 'ignore').split('\x00')[0] + if int(enc_data[0]) == PACKETMAGIC: + if self.name in questOverrides: + if questOverrides[self.name]['CustomName'] != '': + self.name = questOverrides[self.name]['CustomName'] + else: + if self.name in switchOverrides: + if switchOverrides[self.name]['CustomName'] != '': + self.name = switchOverrides[self.name]['CustomName'] + + +def main(): + consoleargs = parser.parse_args() + + switch_ip = consoleargs.ip + client_id = consoleargs.client_id + + if not checkIP(switch_ip): + print('Invalid IP') + exit() + + rpc = Presence(str(client_id)) + try: + rpc.connect() + rpc.clear() + except: + print('Unable to start RPC!') + + switch_server_address = (switch_ip, TCP_PORT) + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + + try: + sock.connect(switch_server_address) + print('Successfully connected to %s' % switch_ip + ':' + str(TCP_PORT)) + except: + print('Error connection to %s refused' % switch_ip + ':' + str(TCP_PORT)) + exit() + + lastProgramName = '' + startTimer = 0 + + while True: + data = None + try: + data = sock.recv(628) + except: + print('Could not connect to Server! Retrying...') + startTimer = 0 + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + try: + sock.connect(switch_server_address) + print('Successfully reconnected to %s' % + repr(switch_server_address)) + except: + print('Error reconnection to %s refused' % + repr(switch_server_address)) + exit() + title = Title(data) + if title.magic == PACKETMAGIC: + if lastProgramName != title.name: + startTimer = int(time.time()) + if consoleargs.ignore_home_screen and title.name == 'Home Menu': + rpc.clear() + else: + smallimagetext = '' + largeimagekey = '' + details = '' + largeimagetext = title.name + if int(title.pid) != PACKETMAGIC: + smallimagetext = 'SwitchPresence-Rewritten' + if title.name not in switchOverrides: + largeimagekey = iconFromPid(title.pid) + details = 'Playing ' + str(title.name) + else: + orinfo = switchOverrides[title.name] + largeimagekey = orinfo['CustomKey'] or iconFromPid(title.pid) + details = orinfo['CustomPrefix'] or 'Playing' + details += ' ' + title.name + else: + smallimagetext = 'QuestPresence' + if title.name not in questOverrides: + largeimagekey = title.name.lower().replace(' ', '') + details = 'Playing ' + title.name + else: + orinfo = questOverrides[title.name] + largeimagekey = orinfo['CustomKey'] or title.name.lower().replace( + ' ', '') + details = orinfo['CustomPrefix'] or 'Playing' + details += ' ' + title.name + if not title.name: + title.name = '' + lastProgramName = title.name + rpc.update(details=details, start=startTimer, large_image=largeimagekey, + large_text=largeimagetext, small_text=smallimagetext) + time.sleep(1) + else: + time.sleep(1) + rpc.clear() + rpc.close() + sock.close() + exit() + +# uses regex to validate ip +def checkIP(ip): + regex = r'''^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.( + 25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.( + 25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.( + 25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)$''' + return re.search(regex, ip) + +def iconFromPid(pid): + return '0' + str(hex(int(pid))).split('0x')[1] + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/PresenceClient/PresenceClient.sln b/PresenceClient/PresenceClient.sln new file mode 100644 index 0000000..003cd4f --- /dev/null +++ b/PresenceClient/PresenceClient.sln @@ -0,0 +1,37 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29201.188 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PresenceClient-GUI", "PresenceClient-GUI\PresenceClient-GUI.csproj", "{E1E88510-EE21-4E59-A5FD-052063CE7AC3}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PresenceClient-CLI", "PresenceClient-CLI\PresenceClient-CLI.csproj", "{7CDBBC94-5E21-474D-ABF9-AF4320E3EC1D}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PresenceCommon", "PresenceCommon\PresenceCommon.csproj", "{73EAD2E4-0F1A-4D06-A84D-13C2EBAA03D8}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {E1E88510-EE21-4E59-A5FD-052063CE7AC3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E1E88510-EE21-4E59-A5FD-052063CE7AC3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E1E88510-EE21-4E59-A5FD-052063CE7AC3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E1E88510-EE21-4E59-A5FD-052063CE7AC3}.Release|Any CPU.Build.0 = Release|Any CPU + {7CDBBC94-5E21-474D-ABF9-AF4320E3EC1D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7CDBBC94-5E21-474D-ABF9-AF4320E3EC1D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7CDBBC94-5E21-474D-ABF9-AF4320E3EC1D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7CDBBC94-5E21-474D-ABF9-AF4320E3EC1D}.Release|Any CPU.Build.0 = Release|Any CPU + {73EAD2E4-0F1A-4D06-A84D-13C2EBAA03D8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {73EAD2E4-0F1A-4D06-A84D-13C2EBAA03D8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {73EAD2E4-0F1A-4D06-A84D-13C2EBAA03D8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {73EAD2E4-0F1A-4D06-A84D-13C2EBAA03D8}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {930A04E8-1CA7-4524-A232-C64B2376520A} + EndGlobalSection +EndGlobal diff --git a/PresenceClient/PresenceCommon/DataHandler.cs b/PresenceClient/PresenceCommon/DataHandler.cs new file mode 100644 index 0000000..ac1180a --- /dev/null +++ b/PresenceClient/PresenceCommon/DataHandler.cs @@ -0,0 +1,21 @@ +using System.Runtime.InteropServices; + +namespace PresenceCommon; + +internal static class DataHandler +{ + internal static T ByteArrayToStructure(byte[] bytes) where T : struct + { + var handle = GCHandle.Alloc(bytes, GCHandleType.Pinned); + T data; + try + { + data = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T)); + } + finally + { + handle.Free(); + } + return data; + } +} \ No newline at end of file diff --git a/PresenceClient/PresenceCommon/PresenceCommon.csproj b/PresenceClient/PresenceCommon/PresenceCommon.csproj new file mode 100644 index 0000000..b36a519 --- /dev/null +++ b/PresenceClient/PresenceCommon/PresenceCommon.csproj @@ -0,0 +1,12 @@ + + + + latestmajor + net48 + + + + + + + diff --git a/PresenceClient/PresenceCommon/Types/Title.cs b/PresenceClient/PresenceCommon/Types/Title.cs new file mode 100644 index 0000000..9eebade --- /dev/null +++ b/PresenceClient/PresenceCommon/Types/Title.cs @@ -0,0 +1,53 @@ +using System.Runtime.InteropServices; +using System.Text; + +namespace PresenceCommon.Types; + +public class Title +{ + public ulong Magic { get; } + public ulong ProgramId { get; } + public string Name { get; } + + [StructLayout(LayoutKind.Sequential, Size = 628)] + private struct TitlePacket + { + [MarshalAs(UnmanagedType.U8)] + public readonly ulong magic; + [MarshalAs(UnmanagedType.U8)] + public readonly ulong programId; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 612)] + public readonly byte[] name; + } + + public Title(byte[] bytes) + { + var title = DataHandler.ByteArrayToStructure(bytes); + Magic = title.magic; + + if (title.programId == 0) + { + ProgramId = 0x0100000000001000; + Name = "Home Menu"; + } + else + { + ProgramId = title.programId; + Name = Encoding.UTF8.GetString(title.name, 0, title.name.Length).Split('\0')[0]; + } + if (title.programId == 0xffaadd23) + { + if (Utils.QuestOverrides.ContainsKey(Name) && Utils.QuestOverrides[Name].CustomName != null) + { + Name = Utils.QuestOverrides[Name].CustomName; + } + } + else + { + if (Utils.SwitchOverrides.ContainsKey($"0{ProgramId:x}") && Utils.SwitchOverrides[$"0{ProgramId:x}"].CustomName != null) + { + Name = Utils.SwitchOverrides[$"0{ProgramId:x}"].CustomName; + } + } + } +} \ No newline at end of file diff --git a/PresenceClient/PresenceCommon/Utils.cs b/PresenceClient/PresenceCommon/Utils.cs new file mode 100644 index 0000000..39ea323 --- /dev/null +++ b/PresenceClient/PresenceCommon/Utils.cs @@ -0,0 +1,111 @@ +using System.Collections.Generic; +using System.Net; +using System.Net.Sockets; +using DiscordRPC; +using Newtonsoft.Json; +using PresenceCommon.Types; + +namespace PresenceCommon; + +public static class Utils +{ + public static readonly Dictionary QuestOverrides; + public static readonly Dictionary SwitchOverrides; + static Utils() + { + var client = new WebClient(); + var json = client.DownloadString("https://raw.githubusercontent.com/Sun-Research-University/PresenceClient/master/Resource/QuestApplicationOverrides.json"); + QuestOverrides = JsonConvert.DeserializeObject>(json); + + json = client.DownloadString("https://raw.githubusercontent.com/Sun-Research-University/PresenceClient/master/Resource/SwitchApplicationOverrides.json"); + SwitchOverrides = JsonConvert.DeserializeObject>(json); + + client.Dispose(); + } + + public static RichPresence CreateDiscordPresence(Title title, Timestamps time, string largeImageKey = "", string largeImageText = "", string smallImageKey = "", string state = "", bool useProvidedTime = true) + { + var presence = new RichPresence + { + State = state + }; + + var assets = new Assets + { + SmallImageKey = smallImageKey, + LargeImageText = title.Name + }; + + if (title.ProgramId != 0xffaadd23) + { + assets.SmallImageText = "SwitchPresence-Rewritten"; + + if (!SwitchOverrides.ContainsKey($"0{title.ProgramId:x}")) + { + assets.LargeImageKey = $"0{title.ProgramId:x}"; + presence.Details = $"Playing {title.Name}"; + } + else + { + var pkgInfo = SwitchOverrides[$"0{title.ProgramId:x}"]; + assets.LargeImageKey = pkgInfo.CustomKey ?? $"0{title.ProgramId:x}"; + + presence.Details = pkgInfo.CustomPrefix ?? "Playing"; + presence.Details += $" {title.Name}"; + } + } + else + { + assets.SmallImageText = "QuestPresence"; + + if (!QuestOverrides.ContainsKey(title.Name)) + { + assets.LargeImageKey = title.Name.ToLower().Replace(" ", ""); + presence.Details = $"Playing {title.Name}"; + } + else + { + var pkgInfo = QuestOverrides[title.Name]; + + assets.LargeImageKey = pkgInfo.CustomKey ?? title.Name.ToLower().Replace(" ", ""); + + presence.Details = pkgInfo.CustomPrefix ?? "Playing"; + presence.Details += $" {title.Name}"; + } + } + if (!string.IsNullOrEmpty(largeImageKey)) + assets.LargeImageKey = largeImageKey; + + if (!string.IsNullOrEmpty(largeImageText)) + assets.LargeImageText = largeImageText; + + presence.Assets = assets; + if (useProvidedTime) + presence.Timestamps = time; + + return presence; + } + + public static byte[] ReceiveExactly(Socket handler, int length = 628) + { + var buffer = new byte[length]; + var receivedLength = 0; + while (receivedLength < length) + { + var nextLength = handler.Receive(buffer, receivedLength, length - receivedLength, SocketFlags.None); + if (nextLength == 0) + { + throw new SocketException(); + } + receivedLength += nextLength; + } + return buffer; + } + + public class OverrideInfo + { + public string CustomName { set; get; } + public string CustomPrefix { set; get; } + public string CustomKey { set; get; } + } +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..df7e90f --- /dev/null +++ b/README.md @@ -0,0 +1,14 @@ +# PresenceClient +Set your Discord rich presence using [SwitchPresence-Rewritten](https://github.com/HeadpatServices/SwitchPresence-Rewritten) or [QuestPresence](https://github.com/HeadpatServices/QuestPresence) running this app on your PC. + +# Setup +Simply Create an application at the [Discord Developer Portal](https://discordapp.com/developers/applications/) call your application `Nintendo Switch`, `Oculus Quest` or whatever you would like and then enter your client ID and Device's IP into PresenceClient!
+ +If you're using QuestPresence, your icon name will be the application name in all lower capitalization with no spaces with the exception of some applications you can take a look [here](https://github.com/HeadpatServices/PresenceClient/blob/master/Resource/QuestApplicationOverrides.json) for those exceptions, you will want to take of a note of the `CustomName` field and format using the above instructions for your icon name. Sometimes an app can have a `CustomKey` field that is filled out, you will want to use this instead of the formatted `CustomName`. + +If you're using SwitchPresence, your icon name will the application title ID, these icons can be dumped from the manager app included in the SwitchPresence release, the dumped icons will be formatted for you to upload directly to your discord developer application. + +Finally to connect you will need your device's IP for QuestPresence this will be on main application page and for SwitchPresence you will have to find it in the connection settings of the switch. + +# Support +If you still need further asstiance you can find us on [Discord](https://link.headpat.services/discord)! diff --git a/Resource/QuestApplicationOverrides.json b/Resource/QuestApplicationOverrides.json new file mode 100644 index 0000000..55c5f2c --- /dev/null +++ b/Resource/QuestApplicationOverrides.json @@ -0,0 +1,32 @@ +{ + "QuestPresence": { + "CustomPrefix": "On the", + "CustomName": "Home Menu", + "CustomKey": null + }, + "Oculus App Runtime": { + "CustomPrefix": "On the", + "CustomName": "Home Menu", + "CustomKey": null + }, + "Netflix": { + "CustomPrefix": "Watching", + "CustomName": null, + "CustomKey": null + }, + "Bigscreen": { + "CustomPrefix": "Watching", + "CustomName": null, + "CustomKey": null + }, + "YouTube VR": { + "CustomPrefix": "Watching", + "CustomName": null, + "CustomKey": null + }, + "System UI": { + "CustomPrefix": "On the", + "CustomName": "Home Menu", + "CustomKey": null + } +} \ No newline at end of file diff --git a/Resource/SwitchApplicationOverrides.json b/Resource/SwitchApplicationOverrides.json new file mode 100644 index 0000000..b1bdb90 --- /dev/null +++ b/Resource/SwitchApplicationOverrides.json @@ -0,0 +1,12 @@ +{ + "01003a400c3da000": { + "CustomPrefix": "Watching", + "CustomName": null, + "CustomKey": null + }, + "0100000000001000": { + "CustomPrefix": "In the", + "CustomName": null, + "CustomKey": null + } +} \ No newline at end of file