From 75fd9ea7f11a367f80270210036ee4abd94983a4 Mon Sep 17 00:00:00 2001 From: Manu <52102823+Manu098vm@users.noreply.github.com> Date: Wed, 2 Nov 2022 22:49:00 +0100 Subject: [PATCH] push to github --- .editorconfig | 83 + .gitignore | 4 + README.md | 68 + SwitchGiftDataManager.CommandLine/Program.cs | 222 ++ .../SwitchGiftDataManager.CommandLine.csproj | 48 + .../Classes/BCATManager/BCATManager.cs | 324 +++ .../Classes/WCManager/ChecksumCalculator.cs | 77 + .../Classes/WCManager/GiftData/OtherGift.cs | 90 + .../Classes/WCManager/GiftData/PokemonGift.cs | 39 + .../Classes/WCManager/WA8.cs | 131 ++ .../Classes/WCManager/WB7.cs | 115 ++ .../Classes/WCManager/WB8.cs | 117 ++ .../Classes/WCManager/WC8.cs | 131 ++ .../Classes/WCManager/Wondercard.cs | 64 + SwitchGiftDataManager.Core/Enums/Enums.cs | 120 ++ .../Properties/Resources.Designer.cs | 849 ++++++++ .../Properties/Resources.resx | 169 ++ .../Resources/BDSPClothing.txt | 15 + .../Resources/Items.txt | 1829 +++++++++++++++++ .../Resources/PLAClothingBottoms.txt | 256 +++ .../Resources/PLAClothingHeads.txt | 256 +++ .../Resources/PLAClothingTops.txt | 256 +++ .../Resources/SWSHClothingBags.txt | 57 + .../Resources/SWSHClothingBottoms.txt | 94 + .../Resources/SWSHClothingGlasses.txt | 97 + .../Resources/SWSHClothingGloves.txt | 72 + .../Resources/SWSHClothingHats.txt | 93 + .../Resources/SWSHClothingJackets.txt | 70 + .../Resources/SWSHClothingLegwear.txt | 93 + .../Resources/SWSHClothingShoes.txt | 71 + .../Resources/SWSHClothingTops.txt | 146 ++ .../Resources/Species.txt | 906 ++++++++ .../Resources/UndergroundItems.txt | 940 +++++++++ .../SwitchGiftDataManager.Core.csproj | 57 + .../MainWindow.Designer.cs | 385 ++++ SwitchGiftDataManager.WinForm/MainWindow.cs | 404 ++++ SwitchGiftDataManager.WinForm/MainWindow.resx | 1392 +++++++++++++ SwitchGiftDataManager.WinForm/Program.cs | 17 + .../Properties/Resources.Designer.cs | 83 + .../Properties/Resources.resx | 127 ++ .../Resources/icon.ico | Bin 0 -> 79029 bytes .../Resources/icon.png | Bin 0 -> 109247 bytes .../SaveWindow.Designer.cs | 201 ++ SwitchGiftDataManager.WinForm/SaveWindow.cs | 186 ++ SwitchGiftDataManager.WinForm/SaveWindow.resx | 1386 +++++++++++++ .../SwitchGiftDataManager.WinForm.csproj | 83 + .../SwitchGiftDataManager.WinForm.csproj.user | 11 + SwitchGiftDataManager.sln | 47 + 48 files changed, 12281 insertions(+) create mode 100644 .editorconfig create mode 100644 .gitignore create mode 100644 README.md create mode 100644 SwitchGiftDataManager.CommandLine/Program.cs create mode 100644 SwitchGiftDataManager.CommandLine/SwitchGiftDataManager.CommandLine.csproj create mode 100644 SwitchGiftDataManager.Core/Classes/BCATManager/BCATManager.cs create mode 100644 SwitchGiftDataManager.Core/Classes/WCManager/ChecksumCalculator.cs create mode 100644 SwitchGiftDataManager.Core/Classes/WCManager/GiftData/OtherGift.cs create mode 100644 SwitchGiftDataManager.Core/Classes/WCManager/GiftData/PokemonGift.cs create mode 100644 SwitchGiftDataManager.Core/Classes/WCManager/WA8.cs create mode 100644 SwitchGiftDataManager.Core/Classes/WCManager/WB7.cs create mode 100644 SwitchGiftDataManager.Core/Classes/WCManager/WB8.cs create mode 100644 SwitchGiftDataManager.Core/Classes/WCManager/WC8.cs create mode 100644 SwitchGiftDataManager.Core/Classes/WCManager/Wondercard.cs create mode 100644 SwitchGiftDataManager.Core/Enums/Enums.cs create mode 100644 SwitchGiftDataManager.Core/Properties/Resources.Designer.cs create mode 100644 SwitchGiftDataManager.Core/Properties/Resources.resx create mode 100644 SwitchGiftDataManager.Core/Resources/BDSPClothing.txt create mode 100644 SwitchGiftDataManager.Core/Resources/Items.txt create mode 100644 SwitchGiftDataManager.Core/Resources/PLAClothingBottoms.txt create mode 100644 SwitchGiftDataManager.Core/Resources/PLAClothingHeads.txt create mode 100644 SwitchGiftDataManager.Core/Resources/PLAClothingTops.txt create mode 100644 SwitchGiftDataManager.Core/Resources/SWSHClothingBags.txt create mode 100644 SwitchGiftDataManager.Core/Resources/SWSHClothingBottoms.txt create mode 100644 SwitchGiftDataManager.Core/Resources/SWSHClothingGlasses.txt create mode 100644 SwitchGiftDataManager.Core/Resources/SWSHClothingGloves.txt create mode 100644 SwitchGiftDataManager.Core/Resources/SWSHClothingHats.txt create mode 100644 SwitchGiftDataManager.Core/Resources/SWSHClothingJackets.txt create mode 100644 SwitchGiftDataManager.Core/Resources/SWSHClothingLegwear.txt create mode 100644 SwitchGiftDataManager.Core/Resources/SWSHClothingShoes.txt create mode 100644 SwitchGiftDataManager.Core/Resources/SWSHClothingTops.txt create mode 100644 SwitchGiftDataManager.Core/Resources/Species.txt create mode 100644 SwitchGiftDataManager.Core/Resources/UndergroundItems.txt create mode 100644 SwitchGiftDataManager.Core/SwitchGiftDataManager.Core.csproj create mode 100644 SwitchGiftDataManager.WinForm/MainWindow.Designer.cs create mode 100644 SwitchGiftDataManager.WinForm/MainWindow.cs create mode 100644 SwitchGiftDataManager.WinForm/MainWindow.resx create mode 100644 SwitchGiftDataManager.WinForm/Program.cs create mode 100644 SwitchGiftDataManager.WinForm/Properties/Resources.Designer.cs create mode 100644 SwitchGiftDataManager.WinForm/Properties/Resources.resx create mode 100644 SwitchGiftDataManager.WinForm/Resources/icon.ico create mode 100644 SwitchGiftDataManager.WinForm/Resources/icon.png create mode 100644 SwitchGiftDataManager.WinForm/SaveWindow.Designer.cs create mode 100644 SwitchGiftDataManager.WinForm/SaveWindow.cs create mode 100644 SwitchGiftDataManager.WinForm/SaveWindow.resx create mode 100644 SwitchGiftDataManager.WinForm/SwitchGiftDataManager.WinForm.csproj create mode 100644 SwitchGiftDataManager.WinForm/SwitchGiftDataManager.WinForm.csproj.user create mode 100644 SwitchGiftDataManager.sln diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..268f7d5 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,83 @@ +[*.cs] + +# Default severity for analyzer diagnostics with category 'Style' +dotnet_analyzer_diagnostic.category-Style.severity = none +csharp_indent_labels = one_less_than_current +csharp_using_directive_placement = outside_namespace:silent +csharp_prefer_simple_using_statement = true:suggestion +csharp_prefer_braces = true:silent +csharp_style_namespace_declarations = block_scoped:silent +csharp_style_prefer_method_group_conversion = true:silent +csharp_style_expression_bodied_methods = false:silent +csharp_style_expression_bodied_constructors = false:silent +csharp_style_expression_bodied_operators = false:silent +csharp_style_expression_bodied_properties = true:silent +csharp_style_expression_bodied_indexers = true:silent +csharp_style_expression_bodied_accessors = true:silent +csharp_style_expression_bodied_lambdas = true:silent +csharp_style_expression_bodied_local_functions = false:silent +csharp_space_around_binary_operators = before_and_after + +[*.{cs,vb}] +dotnet_style_operator_placement_when_wrapping = beginning_of_line +tab_width = 4 +indent_size = 4 +end_of_line = crlf +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion +dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion +dotnet_style_prefer_auto_properties = true:silent +dotnet_style_object_initializer = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_prefer_simplified_boolean_expressions = true:suggestion +dotnet_style_prefer_conditional_expression_over_assignment = true:silent +dotnet_style_prefer_conditional_expression_over_return = true:silent +dotnet_style_explicit_tuple_names = true:suggestion +[*.{cs,vb}] +#### Naming styles #### + +# Naming rules + +dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion +dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface +dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i + +dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.types_should_be_pascal_case.symbols = types +dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case + +dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members +dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case + +# Symbol specifications + +dotnet_naming_symbols.interface.applicable_kinds = interface +dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.interface.required_modifiers = + +dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum +dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.types.required_modifiers = + +dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method +dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.non_field_members.required_modifiers = + +# Naming styles + +dotnet_naming_style.begins_with_i.required_prefix = I +dotnet_naming_style.begins_with_i.required_suffix = +dotnet_naming_style.begins_with_i.word_separator = +dotnet_naming_style.begins_with_i.capitalization = pascal_case + +dotnet_naming_style.pascal_case.required_prefix = +dotnet_naming_style.pascal_case.required_suffix = +dotnet_naming_style.pascal_case.word_separator = +dotnet_naming_style.pascal_case.capitalization = pascal_case + +dotnet_naming_style.pascal_case.required_prefix = +dotnet_naming_style.pascal_case.required_suffix = +dotnet_naming_style.pascal_case.word_separator = +dotnet_naming_style.pascal_case.capitalization = pascal_case +dotnet_style_prefer_inferred_tuple_names = true:suggestion diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3e19cc7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +.git +.vs +**/bin +**/obj \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..0fa0a9b --- /dev/null +++ b/README.md @@ -0,0 +1,68 @@ +# Switch Gift Data Manager + +## About +This tool aims to make past Mystery Gift event contents back again in all the Pokémon games for Nintendo Switch. +Since those games won't allow event injection in the SAV file, this tool creates a forged BCAT package, injectable with homebrews like [JKSV](https://github.com/J-D-K/JKSV/releases). +This does not involve hacking the game ROM nor hacking the game SAV. + +### Compatible files: +* Let's Go Pikachu and Let's Go Eevee wondercard full files (.wb7full) +* Sword and Shield wondercard files (.wc8) +* Brilliant Diamond and Shining Pearl wondercard files (.wb8) +* Legends Arceus wondercard files (.wa8) + +### Compatible games: +* Pokémon Let's Go Pikachu and Eevee +* Pokémon Sword and Shield +* Pokémon Brilliant Diamond and Shining Pearl +* Pokémon Legends Arceus +* A support for Pokémon Scarlet and Violet is planned for the future - no guarantee here - don't ask for eta. + +## Disclosure +Neither I nor the Project Pokémon staff takes any responsibility for possible adverse outcomes or bans due to the use of this tool. Use at your own discretion. + +## Usage +This paragraph refers to the Windows Form app. The Command Line app usage is similar and should be fairly intuitive. +* Ensure to have the required [.NET 6.0 runtimes](https://dotnet.microsoft.com/en-us/download/dotnet/6.0) correctly installed +* Dump your game's BCAT with [JKSV](https://github.com/J-D-K/JKSV/releases) and keep some copies somewhere safe +* Open the tool and select your game of choice +* Import wondercard files of your choice (by drag & drop or by clicking the `Open Files` button) +* Eventually edit the wondercard id (WCID) if you have duplicated WCs and click `Apply` +* Click the `Save as BCAT Package` button and browse to your dumped BCAT +* A folder called "Forged_BCAT_{Game}" should appear next to your dumped BCAT +* Restore the Forged Bcat with JKSV and enjoy the old events +* When you're done, restore your original BCAT package with JKSV (not doing so may cause sync issues) + +If you find any bug or you need support, please write in the relevant topic in the Project Pokémon forums. +Alternatively, feel free to contact me on Discord by DMs (SkyLink98#5946 - **only for bug reports**) or in my [server](https://discord.gg/F9nMfvw9sS). + +## Building +* All the Switch Gift Data Manager projects require .NET 6.0. +* .WinForm is a Windows Form application and can only be built in Windows Operating Systems. +* .Core and .CommandLine can be built in any platform OS. +* Use the Debug build configuration when editing or developing code related to the .WinForm project. Build as Release only once the code is complete. +* The .CommandLine project is currently just a simple script that calls the .Core functions and can run in any OS. Feel free to improve it and/or submit a pull request if you'd like :-) + +## Credits +* [kwsch](https://github.com/kwsch), [sora10pls](https://github.com/sora10pls) and all the [PKHeX](https://github.com/kwsch/PKHeX) and [pkNX](https://github.com/kwsch/pkNX) devs and contributors +for a lot of offsets and resources +* [PP-theSLAYER](https://github.com/PP-theSLAYER) for his researches in the Sword and Shield fashion block and for the clothing names resources +* All the Project Pokémon Staff and the [Event Gallery](https://github.com/projectpokemon/EventsGallery) contributors for their archival efforts that made this possible + +## License +![gplv3-with-text-136x68](https://user-images.githubusercontent.com/52102823/199572700-4e02ed70-74ef-4d67-991e-3168d93aac0d.png) + +Copyright © 2022 Manu098vm + +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 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . \ No newline at end of file diff --git a/SwitchGiftDataManager.CommandLine/Program.cs b/SwitchGiftDataManager.CommandLine/Program.cs new file mode 100644 index 0000000..5fddbe6 --- /dev/null +++ b/SwitchGiftDataManager.CommandLine/Program.cs @@ -0,0 +1,222 @@ +using SwitchGiftDataManager.Core; +using Enums; + + +namespace SwitchGiftDataManager.CommandLine +{ + public static class Program + { + public static void Main() + { + var msg = "Switch Gift Data Manager v1.0.0"; + Log(msg); + + msg = $"{Environment.NewLine}Select your game:{Environment.NewLine}{Environment.NewLine}" + + $"1 - LGPE{Environment.NewLine}" + + $"2 - SWSH{Environment.NewLine}" + + $"3 - BDSP{Environment.NewLine}" + + $"4 - PLA{Environment.NewLine}" + + $"5 - SCVI"; + Log(msg); + + Games game = (Games)int.Parse(Console.ReadLine()!); + if(game is Games.None || game > Games.SCVI) + { + Log("Invalid input. Aborted."); + Console.ReadKey(); + return; + } + else if(game is Games.SCVI) + { + Log("Scarlet and Violet are still not supported by this program. Please wait patiently."); + Console.ReadKey(); + return; + } + + var bcat = new BCATManager(game); + + msg = $"{Environment.NewLine}Enter a valid input path.{Environment.NewLine}{Environment.NewLine}The path can be either:{Environment.NewLine}" + + $"- A direct (full) path to a wondercard file{Environment.NewLine}" + + $"- A (full) path to a folder containing wondercard files"; + Log(msg); + + var path = Console.ReadLine()!; + if (File.Exists(path)) + bcat.TryAddWondercards(File.ReadAllBytes(path)); + else if (CheckValidPath(path)) + foreach(var file in Directory.GetFiles(path)) + if (!bcat.TryAddWondercards(File.ReadAllBytes(file))) + Log($"{file} could not be loaded."); + + if (bcat.Count() <= 0) + { + Log("No valid files have been loaded. Aborted."); + Console.ReadKey(); + return; + } + + bcat.Sort(); + Log($"{Environment.NewLine}Enter the source (full) path to your dumped BCAT:"); + var sourcepath = Console.ReadLine()!; + if(!CheckValidBcatPath(sourcepath)) + { + Log("Not a valid BCAT folder path. Aborted."); + Console.ReadKey(); + return; + } + + Log($"{Environment.NewLine}Enter a destination (full) path to save the forged BCAT:"); + var destpath = Console.ReadLine()!; + if (!CheckValidPath(destpath)) + { + Log("Not a valid path. Aborted."); + Console.ReadKey(); + return; + } + + if (game is not Games.LGPE) + { + msg = $"{Environment.NewLine}Select a build option:{Environment.NewLine}{Environment.NewLine}" + + $"1 - Merge as one file{Environment.NewLine}" + + $"2 - Keep separate files"; + Log(msg); + } + + var opt = game is not Games.LGPE ? int.Parse(Console.ReadLine()!) : 2; + if(opt < 1 || opt > 2) + { + Log("Invalid input. Aborted."); + Console.ReadKey(); + return; + } + + destpath = $"{destpath}\\Forged_BCAT_{game}"; + CopyDirectory(sourcepath, destpath); + + if (opt == 1) + { + try + { + var wcdata = bcat.ConcatenateFiles(); + var metadata = bcat.ForgeMetaInfo(wcdata.ToArray()); + var metadatapath = $"{destpath}\\directories\\{bcat.GetDefaultBcatFolderName()}"; + var wcpath = $"{metadatapath}\\files"; + + if (Directory.Exists(metadatapath)) + DeleteFilesAndDirectory(metadatapath); + + Directory.CreateDirectory(wcpath); + File.WriteAllBytes($"{metadatapath}\\files.meta", metadata.ToArray()); + File.WriteAllBytes($"{wcpath}\\{bcat.GetDefaultBcatFileName()}", wcdata.ToArray()); + Log("Done. Press any key to exit..."); + Console.ReadKey(); + } + catch (Exception) + { + Log("Internal Error. Press any key to exit..."); + Console.ReadKey(); + } + } + else + { + var metadata = bcat.ForgeMetaInfo(); + var metadatapath = $"{destpath}\\directories\\{bcat.GetDefaultBcatFolderName()}"; + var wcspath = $"{metadatapath}\\files"; + + if (Directory.Exists(metadatapath)) + DeleteFilesAndDirectory(metadatapath); + + Directory.CreateDirectory(wcspath); + File.WriteAllBytes($"{metadatapath}\\files.meta", metadata.ToArray()); + if (bcat.TrySaveAllWondercards(wcspath)) + { + Log("Done. Press any key to exit..."); + Console.ReadKey(); + } + else + { + Log("Internal error. Press any key to exit..."); + Console.ReadKey(); + } + } + + return; + } + + private static bool CheckValidPath(string path) + { + if (string.IsNullOrWhiteSpace(path)) + return false; + + if (!Directory.Exists(path)) + return false; + + return true; + } + + private static bool CheckValidBcatPath(string path) + { + if (string.IsNullOrWhiteSpace(path)) + return false; + + if (!Directory.Exists($"{path}\\directories")) + return false; + + if (!File.Exists($"{path}\\directories.meta")) + return false; + + if (!File.Exists($"{path}\\etag.bin")) + return false; + + if (!File.Exists($"{path}\\list.msgpack")) + return false; + + if (!File.Exists($"{path}\\na_required")) + return false; + + if (!File.Exists($"{path}\\passphrase.bin")) + return false; + + return true; + } + + static void CopyDirectory(string source, string dest) + { + var dir = new DirectoryInfo(source); + DirectoryInfo[] dirs = dir.GetDirectories(); + Directory.CreateDirectory(dest); + + foreach (FileInfo file in dir.GetFiles()) + { + string targetFilePath = Path.Combine(dest, file.Name); + if (!File.Exists(targetFilePath)) + file.CopyTo(targetFilePath); + } + + foreach (DirectoryInfo subDir in dirs) + { + string newDestinationDir = Path.Combine(dest, subDir.Name); + CopyDirectory(subDir.FullName, newDestinationDir); + } + } + + private static void DeleteFilesAndDirectory(string targetDir) + { + string[] files = Directory.GetFiles(targetDir); + string[] dirs = Directory.GetDirectories(targetDir); + + foreach (string file in files) + { + File.SetAttributes(file, FileAttributes.Normal); + File.Delete(file); + } + + foreach (string dir in dirs) + DeleteFilesAndDirectory(dir); + + Directory.Delete(targetDir, false); + } + + private static void Log(string msg) => Console.WriteLine(msg); + } +} \ No newline at end of file diff --git a/SwitchGiftDataManager.CommandLine/SwitchGiftDataManager.CommandLine.csproj b/SwitchGiftDataManager.CommandLine/SwitchGiftDataManager.CommandLine.csproj new file mode 100644 index 0000000..5f35eef --- /dev/null +++ b/SwitchGiftDataManager.CommandLine/SwitchGiftDataManager.CommandLine.csproj @@ -0,0 +1,48 @@ + + + + Exe + net6.0 + enable + enable + Manu098vm + Copyright (C) 2022 Manu098vm + README.md + pokemon; mystery gift; wondercard; reader; nintendo; bcat; event injection; + LICENSE + Project Pokémon + https://github.com/Manu098vm/Switch-Gift-Data-Manager + https://github.com/Manu098vm/Switch-Gift-Data-Manager + git + + + + embedded + + + + embedded + + + + + True + \ + + + + + + True + \ + + + + + + True + True + + + + diff --git a/SwitchGiftDataManager.Core/Classes/BCATManager/BCATManager.cs b/SwitchGiftDataManager.Core/Classes/BCATManager/BCATManager.cs new file mode 100644 index 0000000..13769ac --- /dev/null +++ b/SwitchGiftDataManager.Core/Classes/BCATManager/BCATManager.cs @@ -0,0 +1,324 @@ +using System.Buffers.Binary; +using Enums; + +namespace SwitchGiftDataManager.Core +{ + public class BCATManager + { + private const int FileNameOffset = 0x00; + private const int UnkOffset = 0x20; + private const int FileSizeOffset = 0x28; + private const int ChecksumOffset = 0x30; + private const int MaxFileNameLength = 0x1F; + private const int WCMetaInfoLength = 0x80; + private const int MetaHeaderLength = 0x04; + + private Games Game { get; set; } + private List? WCList { get; set; } + + public BCATManager(Games game) + { + Game = game; + WCList = new(); + } + + private Wondercard CreateWondercard(ReadOnlySpan data) + { + return Game switch + { + Games.LGPE => new WB7(data), + Games.SWSH => new WC8(data), + Games.BDSP => new WB8(data), + Games.PLA => new WA8(data), + //Games.SCVI => new WC9(data), + _ => throw new ArgumentOutOfRangeException(), + }; + } + + public bool TryAddWondercards(ReadOnlySpan data, bool sort = false) + { + var success = false; + if (Game is not Games.None && WCList is not null) + if (Game is not Games.LGPE || (Game is Games.LGPE && WCList.Count == 0)) + { + var game = GetCompatibleGamesFromWC(data); + if (game == Game) + { + var size = (int)Wondercard.GetSize(game); + var qty = data.Length / size; + for (int i = 0; i < qty; i++) + { + var wc = CreateWondercard(data[(i * size)..((i + 1) * size)]); + if (wc.IsValid()) + { + WCList.Add(wc); + success = true; + } + } + } + if (sort) + Sort(); + } + return success; + } + + public void Sort() => WCList!.Sort((x, y) => x.WCID.CompareTo(y.WCID)); + + public int Count() + { + if (WCList is not null) + return WCList.Count; + + return 0; + } + + public void RemoveWC(int index) + { + if (WCList is not null && WCList.Count > 0 && WCList.Count >= index - 1) + WCList.RemoveAt(index); + } + + public void Reset() + { + if(WCList is not null) + WCList.Clear(); + else + WCList = new List(); + } + + public void SetWCID(int index, ushort wcid) + { + if (WCList is not null && WCList.Count >= index && WCList.Count >= index) + { + var wc = WCList.ElementAt(index); + wc.SetID(wcid); + wc.UpdateChecksum(); + } + } + + public ushort GetWCID(int index) + { + if (WCList is not null && WCList.Count >= index && WCList.Count >= index) + return WCList.ElementAt(index).WCID; + return 0; + } + + public int GetIndex(ushort wcid) + { + if (WCList is not null && WCList.Count > 0) + return WCList.FindIndex((x) => x.WCID == wcid); + else + throw new IndexOutOfRangeException(); + } + + public static Games GetCompatibleGamesFromWC(ReadOnlySpan data) + { + if (data.Length % (int)Wondercard.GetSize(Games.LGPE) == 0) + return Games.LGPE; + else if (data.Length % (int)Wondercard.GetSize(Games.SWSH) == 0) + return Games.SWSH; + else if (data.Length % (int)Wondercard.GetSize(Games.BDSP) == 0) + return Games.BDSP; + else if (data.Length % (int)Wondercard.GetSize(Games.PLA) == 0) + return Games.PLA; + else if (data.Length % (int)Wondercard.GetSize(Games.SCVI) == 0) + return Games.SCVI; + else + return Games.None; + } + + public List GetListNames() + { + List list = new(); + if (WCList is not null && WCList.Count > 0) + foreach (var wc in WCList) + { + var str = wc.Type!.ToString()!.Equals("Pokemon") ? ((PokemonGift)wc.Content!).GetSpeciesName() : ((List)wc.Content!)[0].Type!.ToString()!; + list.Add($"{Game} #{wc.WCID}: {str}"); + } + return list; + } + + public List GetContentToString(int index) + { + var wcid = ""; + var el1 = ""; + var el2 = ""; + var el3 = ""; + var el4 = ""; + var el5 = ""; + + if (WCList is not null && WCList.Count > 0 && WCList.Count >= index - 1) + { + var wc = WCList.ElementAt(index); + wcid = wc.WCID.ToString(); + var content = wc.Content; + if (content!.GetType() == typeof(PokemonGift)) + { + var c = (PokemonGift)content; + el1 = c.ShinyType.ToString(); + el2 = c.GetSpeciesName(); + el3 = c.PIDType.ToString(); + } + else if (content!.GetType() == typeof(List)) + { + foreach (var c in (List)content) + { + var item = c.GetItemName(); + var qty = c.Quantity; + var str = $"{item.Replace("BP", "Battle Points")}"; + if (qty != 0x0 && qty != 0xFFFF) + str = $"{str} x{qty}"; + if (el1.Equals("")) + el1 = str; + else if (el2.Equals("")) + el2 = str; + else if (el3.Equals("")) + el3 = str; + else if (el4.Equals("")) + el4 = str; + else if (el5.Equals("")) + el5 = str; + } + } + } + + return new List { wcid, el1, el2, el3, el4, el5 }; + } + + public List? GetDuplicatedWCID() + { + if (WCList is not null && WCList.Count > 1) + { + var l = WCList.GroupBy(x => x.WCID) + .Where(g => g.Count() > 1) + .Select(y => y.Key) + .ToList(); + return l; + } + else + return new List(); + } + + public string GetDefaultBcatFolderName() => GetDefaultBcatFolderName(this.Game); + public string GetDefaultBcatFileName() => GetDefaultBcatFileName(this.Game); + + public static string GetDefaultBcatFolderName(Games game) + { + return game switch + { + Games.LGPE => "normal", + Games.SWSH => "normal", + Games.BDSP => "99", + Games.PLA => "normal", + _ => throw new ArgumentOutOfRangeException(), + }; + } + + + public static string GetDefaultBcatFileName(Games game) + { + return game switch + { + Games.SWSH => "distribution_internet", + Games.BDSP => "99", + Games.PLA => "distribution_internet", + _ => throw new ArgumentOutOfRangeException(), + }; + } + + public bool TrySaveAllWondercards(string path) + { + if (WCList is null || WCList.Count == 0) + return false; + + for (int i = 0; i < WCList.Count; i++) + if (!TrySaveWondercard(i, path)) + return false; + + return true; + } + + public bool TrySaveWondercard(int index, string path) + { + try + { + var wc = WCList!.ElementAt(index); + File.WriteAllBytes($"{path}\\{ForgeWcFileName(wc)}", wc.Data!); + return true; + } + catch (Exception) + { + return false; + } + } + + public ReadOnlySpan ConcatenateFiles() + { + var size = (int)Wondercard.GetSize(Game); + var data = new byte[size * WCList!.Count]; + foreach (var el in WCList!.Select((wc, i) => new { i, wc })) + el.wc.Data!.CopyTo(data, el.i * size); + return data.AsSpan(); + } + + private string ForgeWcFileName(Wondercard wc) + { + var type = wc.Type!.ToString()!; + var content = type.Equals("Pokemon") ? $"{((PokemonGift)wc.Content!).GetSpeciesName()}" : type; + var str = $"{wc.WCID:0000}_{content}"; + System.Text.StringBuilder sb = new(); + foreach (char c in str) + if (c != '\\' && c != '/' && c != ':' && c != '*' && c != '?' && c != '"' && c != '<' && c != '>' && c != '|') + sb.Append(c); + return sb.ToString().ToLower(); + } + + public ReadOnlySpan ForgeMetaInfo(object? data = null) + { + if (data is not null && data.GetType() == typeof(byte[])) + { + var fileName = System.Text.Encoding.UTF8.GetBytes(GetDefaultBcatFileName()); + var unknown = 0xFFFFFFFF; + var fileSize = (uint)((byte[])data).Length; + var checksum = ChecksumCalculator.CalcReverseMD5((byte[])data); + var metainfo = new byte[WCMetaInfoLength]; + fileName.CopyTo(metainfo, FileNameOffset); + BinaryPrimitives.WriteUInt32LittleEndian(metainfo.AsSpan(UnkOffset), unknown); + BinaryPrimitives.WriteUInt32LittleEndian(metainfo.AsSpan(FileSizeOffset), fileSize); + checksum.ToArray().CopyTo(metainfo, ChecksumOffset); + return ForgeMetaInfoHeader(metainfo); + } + else + { + var metainfo = new byte[WCMetaInfoLength * WCList!.Count]; + foreach (var el in WCList!.Select((wc, i) => new { i, wc })) + ForgeWcMetaInfo(el.wc).ToArray().CopyTo(metainfo, el.i * WCMetaInfoLength); + return ForgeMetaInfoHeader(metainfo); + } + } + + private ReadOnlySpan ForgeWcMetaInfo(Wondercard wc) + { + var fileName = System.Text.Encoding.UTF8.GetBytes(ForgeWcFileName(wc)); + var unknown = 0xFFFFFFFF; + var fileSize = (uint)Wondercard.GetSize(Game); + var checksum = wc.CalcMetaChecksum(); + var data = new byte[WCMetaInfoLength]; + fileName.CopyTo(data, FileNameOffset); + BinaryPrimitives.WriteUInt32LittleEndian(data.AsSpan(UnkOffset), unknown); + BinaryPrimitives.WriteUInt32LittleEndian(data.AsSpan(FileSizeOffset), fileSize); + checksum.ToArray().CopyTo(data, ChecksumOffset); + return data.AsSpan(); + } + + private ReadOnlySpan ForgeMetaInfoHeader(ReadOnlySpan data) + { + uint header = 0x1; + byte[] filesDotMeta = new byte[data.Length + MetaHeaderLength]; + BinaryPrimitives.WriteUInt32LittleEndian(filesDotMeta.AsSpan(), header); + data.ToArray().CopyTo(filesDotMeta, MetaHeaderLength); + return filesDotMeta.AsSpan(); + } + } +} diff --git a/SwitchGiftDataManager.Core/Classes/WCManager/ChecksumCalculator.cs b/SwitchGiftDataManager.Core/Classes/WCManager/ChecksumCalculator.cs new file mode 100644 index 0000000..2b841e4 --- /dev/null +++ b/SwitchGiftDataManager.Core/Classes/WCManager/ChecksumCalculator.cs @@ -0,0 +1,77 @@ +using System.Security.Cryptography; + +//Credits for the CalcCcittFalse implementation to PNZEmil: https://gist.github.com/tijnkooijmans/10981093?permalink_comment_id=3996072#gistcomment-3996072 +namespace SwitchGiftDataManager.Core +{ + public static class ChecksumCalculator + { + private const ushort InitialValue = 0xFFFF; + + private static readonly ushort[] ccittFalseCrc16Table = { + 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, + 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, + 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, + 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, + 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, + 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, + 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, + 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, + 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, + 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, + 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, + 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, + 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, + 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, + 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, + 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, + 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, + 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, + 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, + 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, + 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, + 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, + 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, + 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, + 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, + 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, + 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, + 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, + 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, + 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, + 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, + 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 + }; + + public static ushort CalcCcittFalse(ReadOnlySpan bytes) + { + var crc16 = InitialValue; + + var length = bytes.Length; + var byteIndex = 0; + while (length-- > 0) + { + var tableIndex = crc16 >> 8 ^ bytes[byteIndex++]; + crc16 = (ushort)(crc16 << 8 ^ ccittFalseCrc16Table[tableIndex]); + } + + return crc16; + } + + public static Span CalcReverseMD5(byte[] data) + { + var md5 = MD5.Create().ComputeHash(data); + + var tmp1 = md5.AsSpan((md5.Length / 2)..); + tmp1.Reverse(); + + var tmp2 = md5.AsSpan(0..(md5.Length / 2)); + tmp2.Reverse(); + + var b = new byte[md5.Length]; + tmp2.ToArray().CopyTo(b, 0); + tmp1.ToArray().CopyTo(b, tmp1.Length); + + return b.AsSpan(); + } + } +} \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Classes/WCManager/GiftData/OtherGift.cs b/SwitchGiftDataManager.Core/Classes/WCManager/GiftData/OtherGift.cs new file mode 100644 index 0000000..337bbd1 --- /dev/null +++ b/SwitchGiftDataManager.Core/Classes/WCManager/GiftData/OtherGift.cs @@ -0,0 +1,90 @@ +using Enums; + +namespace SwitchGiftDataManager.Core +{ + public class OtherGift + { + public object? Type { get; set; } + public ushort Item { get; set; } + public ushort Quantity { get; set; } + public ushort Opt { get; set; } + + public string GetItemName() => GetItemName(Item, Type!, Opt); + + public static string GetItemName(ushort id, object type, ushort opt = 0) + { + var str = ""; + + if (type.GetType() == typeof(GiftType7)) + { + if ((GiftType7)type is GiftType7.Item) + str = Properties.Resources.Items.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id]; + else + str = ((GiftType7)type).ToString(); + } + else if (type.GetType() == typeof(GiftType8)) + { + if ((GiftType8)type is GiftType8.Item) + str = Properties.Resources.Items.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id]; + else if ((GiftType8)type is GiftType8.Clothing) + { + var category = (ClothingType8)id; + var description = category switch + { + ClothingType8.Glasses => Properties.Resources.SWSHClothingGlasses.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8.Hats => Properties.Resources.SWSHClothingHats.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8.Jackets => Properties.Resources.SWSHClothingJackets.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8.Tops => Properties.Resources.SWSHClothingTops.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8.Bags => Properties.Resources.SWSHClothingBags.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8.Gloves => Properties.Resources.SWSHClothingGloves.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8.Bottoms => Properties.Resources.SWSHClothingBottoms.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8.Legwear => Properties.Resources.SWSHClothingLegwear.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8.Shoes => Properties.Resources.SWSHClothingShoes.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + _ => throw new ArgumentOutOfRangeException(), + }; + str = $"[{category}] {description}"; + } + else + str = ((GiftType8)type).ToString(); + } + else if(type.GetType() == typeof(GiftType8B)) + { + if ((GiftType8B)type is GiftType8B.Item) + str = Properties.Resources.Items.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id]; + else if ((GiftType8B)type is GiftType8B.Clothing) + str = Properties.Resources.BDSPClothing.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id]; + else if ((GiftType8B)type is GiftType8B.Underground) + str = Properties.Resources.UndergroundItems.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id]; + else + str = ((GiftType8B)type).ToString(); + } + else if (type.GetType() == typeof(GiftType8A)) + { + if ((GiftType8A)type is GiftType8A.Item) + str = Properties.Resources.Items.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id]; + else if ((GiftType8A)type is GiftType8A.Clothing) + { + var category = (ClothingType8A)id; + var description = category switch + { + ClothingType8A.Heads => Properties.Resources.PLAClothingHeads.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8A.Tops => Properties.Resources.PLAClothingTops.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8A.Bottoms => Properties.Resources.PLAClothingBottoms.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt], + ClothingType8A.Outfit => "", + ClothingType8A.Shoes => "", + ClothingType8A.Glasses => "", + ClothingType8A.Eyes => "", + _ => throw new ArgumentOutOfRangeException(), + }; + if(string.IsNullOrWhiteSpace(description)) + description = $"{opt:X4}"; + str = $"[{category}] {description}"; + } + else + str = ((GiftType8A)type).ToString(); + } + + return str; + } + } +} diff --git a/SwitchGiftDataManager.Core/Classes/WCManager/GiftData/PokemonGift.cs b/SwitchGiftDataManager.Core/Classes/WCManager/GiftData/PokemonGift.cs new file mode 100644 index 0000000..a684f88 --- /dev/null +++ b/SwitchGiftDataManager.Core/Classes/WCManager/GiftData/PokemonGift.cs @@ -0,0 +1,39 @@ +using Enums; + +namespace SwitchGiftDataManager.Core +{ + public class PokemonGift + { + public ushort Species { get; set; } + public uint PID { get; set; } + public uint TID { get; set; } + public uint SID { get; set; } + public ShinyType ShinyType { get; set; } + public PIDType PIDType { get; set; } + + public string GetSpeciesName() => GetSpeciesName(Species); + + public bool IsShiny() + { + if (ShinyType is ShinyType.ShinyForced) + return true; + else if (ShinyType is ShinyType.ShinyPossible && PID != 0 && TID != 0 && SID != 0) + return IsShiny(PID, TID, SID); + + return false; + } + + public static string GetSpeciesName(uint species) => Properties.Resources.Species.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)[species].Replace(",", ""); + + public static bool IsShiny(uint pid, uint tid, uint sid) => sid != 0 || tid != 0 ? (sid ^ tid ^ (pid >> 16) ^ (pid & 0xFFFF)) < 16 : false; + + public static bool IsTIDAbusePossible(uint tid, uint sid, PIDType type) + { + if (type is PIDType.FixedPID) + if (tid == 0) + if (sid == 0) + return true; + return false; + } + } +} diff --git a/SwitchGiftDataManager.Core/Classes/WCManager/WA8.cs b/SwitchGiftDataManager.Core/Classes/WCManager/WA8.cs new file mode 100644 index 0000000..6731a01 --- /dev/null +++ b/SwitchGiftDataManager.Core/Classes/WCManager/WA8.cs @@ -0,0 +1,131 @@ +using System.Buffers.Binary; +using Enums; + +namespace SwitchGiftDataManager.Core +{ + internal class WA8 : Wondercard + { + private const int WondercardIDOffset = 0x08; + private const int GiftTypeOffset = 0x0F; + private const int ItemOffset = 0x18; + private const int QuantityOffset = 0x1A; + private const int ClothingOffset = 0x1C; + private const int TIDOffset = 0x18; + private const int SIDOffset = 0x1A; + private const int PIDOffset = 0x24; + private const int SpeciesOffset = 0x238; + private const int ShinyTypeOffset = 0x240; + private const int ChecksumOffset = 0x2C4; + + public WA8(ReadOnlySpan data) : base(data) + { + WCID = BinaryPrimitives.ReadUInt16LittleEndian(data[WondercardIDOffset..]); + Type = (GiftType8A)Data![GiftTypeOffset]; + Content = Type switch + { + GiftType8A.Pokemon => GetPokemon(), + _ => GetItems(), + }; + } + + private PokemonGift GetPokemon() + { + var species = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SpeciesOffset)); + var pid = BinaryPrimitives.ReadUInt32LittleEndian(Data.AsSpan(PIDOffset)); + var tid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(TIDOffset)); + var sid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SIDOffset)); + var test = (ShinyType8)Data![ShinyTypeOffset]; + var pidtype = (ShinyType8)Data![ShinyTypeOffset] switch + { + ShinyType8.ShinyLocked => PIDType.RandomPID, + ShinyType8.ShinyRandom => PIDType.RandomPID, + ShinyType8.ShinyStar => PIDType.FixedPID, + ShinyType8.ShinySquare => PIDType.FixedPID, + ShinyType8.Fixed => PIDType.FixedPID, + _ => throw new ArgumentOutOfRangeException(), + }; + var shinytype = (ShinyType8)Data![ShinyTypeOffset] switch + { + ShinyType8.ShinyLocked => ShinyType.ShinyLocked, + ShinyType8.ShinyRandom => ShinyType.ShinyPossible, + ShinyType8.ShinyStar or ShinyType8.ShinySquare => ShinyType.ShinyForced, + ShinyType8.Fixed => PokemonGift.IsShiny(pid, tid, sid) ? ShinyType.ShinyForced : + PokemonGift.IsTIDAbusePossible(tid, sid, pidtype) ? ShinyType.ShinyTIDAbuse : ShinyType.ShinyLocked, + _ => throw new ArgumentOutOfRangeException(), + }; + + return new PokemonGift + { + Species = species, + PID = pid, + TID = tid, + SID = sid, + ShinyType = shinytype, + PIDType = pidtype, + }; + } + + private List GetItems() + { + List items = new(); + for (int i = 0; i < MaxItemCount; i++) + { + ushort item = 0; + ushort quantity = 0; + ushort opt = 0; + var type = (GiftType8A)Type!; + + if (type is GiftType8A.Clothing) + { + item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x08 * i))); + opt = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ClothingOffset + (0x08 * i))); + } + else + { + item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x04 * i))); + quantity = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(QuantityOffset + (0x04 * i))); + } + + var gift = new OtherGift + { + Type = type, + Item = item, + Quantity = quantity, + Opt = opt, + }; + + if ((type is not GiftType8A.Clothing && gift.Item != 0x00) || (type is GiftType8A.Clothing && opt != 0xFFFF)) + items.Add(gift); + } + return items; + } + + public override bool IsChecksumValid() + { + if (Data is not null) + { + var oldChecksum = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ChecksumOffset)); + var span = Data.ToArray().AsSpan(); + BinaryPrimitives.WriteUInt16LittleEndian(span[ChecksumOffset..], 0x0); + var newchecksum = ChecksumCalculator.CalcCcittFalse(span); + if (oldChecksum == newchecksum) + return true; + } + return false; + } + + public override void UpdateChecksum() + { + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), 0x0); + var checksum = ChecksumCalculator.CalcCcittFalse(Data.AsSpan()); + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), checksum); + } + + public override void SetID(ushort wcid) + { + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(WondercardIDOffset), wcid); + WCID = wcid; + UpdateChecksum(); + } + } +} diff --git a/SwitchGiftDataManager.Core/Classes/WCManager/WB7.cs b/SwitchGiftDataManager.Core/Classes/WCManager/WB7.cs new file mode 100644 index 0000000..92102d4 --- /dev/null +++ b/SwitchGiftDataManager.Core/Classes/WCManager/WB7.cs @@ -0,0 +1,115 @@ +using System.Buffers.Binary; +using Enums; + +namespace SwitchGiftDataManager.Core +{ + internal class WB7 : Wondercard + { + private const int WondercardIDOffset = 0x208; + private const int GiftTypeOffset = 0x259; + private const int ItemOffset = 0x270; + private const int QuantityOffset = 0x272; + private const int TIDOffset = 0x270; + private const int SIDOffset = 0x272; + private const int SpeciesOffset = 0x28A; + private const int ShinyTypeOffset = 0x2AB; + private const int PIDOffset = 0xD4; + private const int ChecksumOffset = 0x202; + + public WB7(ReadOnlySpan data) : base(data) + { + WCID = BinaryPrimitives.ReadUInt16LittleEndian(data[WondercardIDOffset..]); + Type = (GiftType7)Data![GiftTypeOffset]; + Content = Type switch + { + GiftType7.Pokemon => GetPokemon(), + _ => GetItems(), + }; + } + + private PokemonGift GetPokemon() + { + var species = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SpeciesOffset)); + var pid = BinaryPrimitives.ReadUInt32LittleEndian(Data.AsSpan(PIDOffset)); + var tid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(TIDOffset)); + var sid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SIDOffset)); + var pidtype = (ShinyType7)Data![ShinyTypeOffset] switch + { + ShinyType7.Fixed => PIDType.FixedPID, + ShinyType7.ShinyRandom => PIDType.RandomPID, + ShinyType7.Shiny => PIDType.RandomPID, + ShinyType7.ShinyLocked => PIDType.RandomPID, + _ => throw new ArgumentOutOfRangeException(), + }; + var shinytype = (ShinyType7)Data![ShinyTypeOffset] switch + { + ShinyType7.Fixed => PokemonGift.IsShiny(pid, tid, sid) ? ShinyType.ShinyForced : + PokemonGift.IsTIDAbusePossible(tid, sid, pidtype) ? ShinyType.ShinyTIDAbuse : ShinyType.ShinyLocked, + ShinyType7.ShinyRandom => ShinyType.ShinyPossible, + ShinyType7.Shiny => ShinyType.ShinyForced, + ShinyType7.ShinyLocked => ShinyType.ShinyLocked, + _ => throw new ArgumentOutOfRangeException(), + }; + + return new PokemonGift + { + Species = species, + PID = pid, + TID = tid, + SID = sid, + ShinyType = shinytype, + PIDType = pidtype, + }; + } + + private List GetItems() + { + List items = new(); + for (int i = 0; i < MaxItemCount; i++) + { + var type = (GiftType7)Type!; + var item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x04 * i))); + var quantity = type is GiftType7.BP ? item : BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(QuantityOffset + (0x04 * i))); + + var gift = new OtherGift + { + Type = type, + Item = item, + Quantity = quantity, + }; + + if (gift.Item != 0) + items.Add(gift); + } + return items; + } + + public override bool IsChecksumValid() + { + if (Data is not null) + { + var oldChecksum = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ChecksumOffset)); + var span = Data.ToArray().AsSpan(); + BinaryPrimitives.WriteUInt16LittleEndian(span[ChecksumOffset..], 0x0); + var newchecksum = ChecksumCalculator.CalcCcittFalse(span); + if (oldChecksum == newchecksum) + return true; + } + return false; + } + + public override void UpdateChecksum() + { + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), 0x0); + var checksum = ChecksumCalculator.CalcCcittFalse(Data.AsSpan()); + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), checksum); + } + + public override void SetID(ushort wcid) + { + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(WondercardIDOffset), wcid); + WCID = wcid; + UpdateChecksum(); + } + } +} diff --git a/SwitchGiftDataManager.Core/Classes/WCManager/WB8.cs b/SwitchGiftDataManager.Core/Classes/WCManager/WB8.cs new file mode 100644 index 0000000..e116d12 --- /dev/null +++ b/SwitchGiftDataManager.Core/Classes/WCManager/WB8.cs @@ -0,0 +1,117 @@ +using System.Buffers.Binary; +using Enums; + +namespace SwitchGiftDataManager.Core +{ + internal class WB8 : Wondercard + { + private const int WondercardIDOffset = 0x08; + private const int GiftTypeOffset = 0x11; + private const int ItemOffset = 0x20; + private const int QuantityOffset = 0x22; + private const int TIDOffset = 0x20; + private const int SIDOffset = 0x22; + private const int PIDOffset = 0x2C; + private const int SpeciesOffset = 0x288; + private const int ShinyTypeOffset = 0x290; + private const int ChecksumOffset = 0x2D0; + + public WB8(ReadOnlySpan data) : base(data) + { + WCID = BinaryPrimitives.ReadUInt16LittleEndian(data[WondercardIDOffset..]); + Type = (GiftType8B)Data![GiftTypeOffset]; + Content = Type switch + { + GiftType8B.Pokemon => GetPokemon(), + _ => GetItems(), + }; + } + + private PokemonGift GetPokemon() + { + var species = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SpeciesOffset)); + var pid = BinaryPrimitives.ReadUInt32LittleEndian(Data.AsSpan(PIDOffset)); + var tid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(TIDOffset)); + var sid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SIDOffset)); + var test = (ShinyType8)Data![ShinyTypeOffset]; + var pidtype = (ShinyType8)Data![ShinyTypeOffset] switch + { + ShinyType8.ShinyLocked => PIDType.RandomPID, + ShinyType8.ShinyRandom => PIDType.RandomPID, + ShinyType8.ShinyStar => PIDType.FixedPID, + ShinyType8.ShinySquare => PIDType.FixedPID, + ShinyType8.Fixed => PIDType.FixedPID, + _ => throw new ArgumentOutOfRangeException(), + }; + var shinytype = (ShinyType8)Data![ShinyTypeOffset] switch + { + ShinyType8.ShinyLocked => ShinyType.ShinyLocked, + ShinyType8.ShinyRandom => ShinyType.ShinyPossible, + ShinyType8.ShinyStar or ShinyType8.ShinySquare => ShinyType.ShinyForced, + ShinyType8.Fixed => PokemonGift.IsShiny(pid, tid, sid) ? ShinyType.ShinyForced : + PokemonGift.IsTIDAbusePossible(tid, sid, pidtype) ? ShinyType.ShinyTIDAbuse : ShinyType.ShinyLocked, + _ => throw new ArgumentOutOfRangeException(), + }; + + return new PokemonGift + { + Species = species, + PID = pid, + TID = tid, + SID = sid, + ShinyType = shinytype, + PIDType = pidtype, + }; + } + + private List GetItems() + { + List items = new(); + for (int i = 0; i < MaxItemCount; i++) + { + var type = (GiftType8B)Type!; + var item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x10 * i))); + var quantity = type is GiftType8B.BP or GiftType8B.Money ? item : BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(QuantityOffset + (0x10 * i))); + + var gift = new OtherGift + { + Type = Type, + Item = item, + Quantity = quantity, + }; + + if (gift.Item != 0) + items.Add(gift); + } + return items; + } + + public override bool IsChecksumValid() + { + if (Data is not null) + { + var oldChecksum = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ChecksumOffset)); + var span = Data.ToArray().AsSpan(); + BinaryPrimitives.WriteUInt16LittleEndian(span[ChecksumOffset..], 0x0); + var newchecksum = ChecksumCalculator.CalcCcittFalse(span); + if (oldChecksum == newchecksum) + return true; + } + return false; + } + + public override void UpdateChecksum() + { + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), 0x0); + var checksum = ChecksumCalculator.CalcCcittFalse(Data.AsSpan()); + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), checksum); + } + + public override void SetID(ushort wcid) + { + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(WondercardIDOffset), wcid); + WCID = wcid; + UpdateChecksum(); + } + } +} diff --git a/SwitchGiftDataManager.Core/Classes/WCManager/WC8.cs b/SwitchGiftDataManager.Core/Classes/WCManager/WC8.cs new file mode 100644 index 0000000..61e4018 --- /dev/null +++ b/SwitchGiftDataManager.Core/Classes/WCManager/WC8.cs @@ -0,0 +1,131 @@ +using System.Buffers.Binary; +using Enums; + +namespace SwitchGiftDataManager.Core +{ + internal class WC8 : Wondercard + { + private const int WondercardIDOffset = 0x08; + private const int GiftTypeOffset = 0x11; + private const int ItemOffset = 0x20; + private const int QuantityOffset = 0x22; + private const int ClothingOffset = 0x24; + private const int TIDOffset = 0x20; + private const int SIDOffset = 0x22; + private const int PIDOffset = 0x2C; + private const int SpeciesOffset = 0x240; + private const int ShinyTypeOffset = 0x248; + private const int ChecksumOffset = 0x2CC; + + public WC8(ReadOnlySpan data) : base(data) + { + WCID = BinaryPrimitives.ReadUInt16LittleEndian(data[WondercardIDOffset..]); + Type = (GiftType8)Data![GiftTypeOffset]; + Content = Type switch + { + GiftType8.Pokemon => GetPokemon(), + _ => GetItems(), + }; + } + + private PokemonGift GetPokemon() + { + var species = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SpeciesOffset)); + var pid = BinaryPrimitives.ReadUInt32LittleEndian(Data.AsSpan(PIDOffset)); + var tid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(TIDOffset)); + var sid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SIDOffset)); + var test = (ShinyType8)Data![ShinyTypeOffset]; + var pidtype = (ShinyType8)Data![ShinyTypeOffset] switch + { + ShinyType8.ShinyLocked => PIDType.RandomPID, + ShinyType8.ShinyRandom => PIDType.RandomPID, + ShinyType8.ShinyStar => PIDType.FixedPID, + ShinyType8.ShinySquare => PIDType.FixedPID, + ShinyType8.Fixed => PIDType.FixedPID, + _ => throw new ArgumentOutOfRangeException(), + }; + var shinytype = (ShinyType8)Data![ShinyTypeOffset] switch + { + ShinyType8.ShinyLocked => ShinyType.ShinyLocked, + ShinyType8.ShinyRandom => ShinyType.ShinyPossible, + ShinyType8.ShinyStar or ShinyType8.ShinySquare => ShinyType.ShinyForced, + ShinyType8.Fixed => PokemonGift.IsShiny(pid, tid, sid) ? ShinyType.ShinyForced : + PokemonGift.IsTIDAbusePossible(tid, sid, pidtype) ? ShinyType.ShinyTIDAbuse : ShinyType.ShinyLocked, + _ => throw new ArgumentOutOfRangeException(), + }; + + return new PokemonGift + { + Species = species, + PID = pid, + TID = tid, + SID = sid, + ShinyType = shinytype, + PIDType = pidtype, + }; + } + + private List GetItems() + { + List items = new(); + for (int i = 0; i < MaxItemCount; i++) + { + ushort item = 0; + ushort quantity = 0; + ushort opt = 0; + var type = (GiftType8)Type!; + + if (type is GiftType8.Clothing) + { + item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x08 * i))); + opt = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ClothingOffset + (0x08 * i))); + } + else + { + item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x04 * i))); + quantity = type is GiftType8.BP or GiftType8.Money ? item : BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(QuantityOffset + (0x04 * i))); + } + + var gift = new OtherGift + { + Type = type, + Item = item, + Quantity = quantity, + Opt = opt, + }; + + if (gift.Item != 0x00 && opt != 0xFFFF) + items.Add(gift); + } + return items; + } + + public override bool IsChecksumValid() + { + if (Data is not null) + { + var oldChecksum = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ChecksumOffset)); + var span = Data.ToArray().AsSpan(); + BinaryPrimitives.WriteUInt16LittleEndian(span[ChecksumOffset..], 0x0); + var newchecksum = ChecksumCalculator.CalcCcittFalse(span); + if (oldChecksum == newchecksum) + return true; + } + return false; + } + + public override void UpdateChecksum() + { + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), 0x0); + var checksum = ChecksumCalculator.CalcCcittFalse(Data.AsSpan()); + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), checksum); + } + + public override void SetID(ushort wcid) + { + BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(WondercardIDOffset), wcid); + WCID = wcid; + UpdateChecksum(); + } + } +} diff --git a/SwitchGiftDataManager.Core/Classes/WCManager/Wondercard.cs b/SwitchGiftDataManager.Core/Classes/WCManager/Wondercard.cs new file mode 100644 index 0000000..4514b57 --- /dev/null +++ b/SwitchGiftDataManager.Core/Classes/WCManager/Wondercard.cs @@ -0,0 +1,64 @@ +using Enums; + +namespace SwitchGiftDataManager.Core +{ + internal abstract class Wondercard + { + protected const int MaxItemCount = 5; + + public Games Game { get; } + public ushort WCID { get; protected set; } + public object? Type { get; protected set; } + public object? Content { get; protected set; } + public byte[]? Data { get; protected set; } + + public Wondercard(ReadOnlySpan data) + { + Game = (WondercardSize)data.Length switch + { + WondercardSize.WB7 => Games.LGPE, + WondercardSize.WC8 => Games.SWSH, + WondercardSize.WB8 => Games.BDSP, + WondercardSize.WA8 => Games.PLA, + WondercardSize.WC9 => Games.SCVI, + _ => Games.None, + }; + Data = data.ToArray(); + } + + public bool IsValid() + { + if (WCID <= 0) + return false; + + if (Content is null) + return false; + + if (!IsChecksumValid()) + UpdateChecksum(); + + return true; + } + + public ReadOnlySpan CalcMetaChecksum() => ChecksumCalculator.CalcReverseMD5(Data!); + + public abstract bool IsChecksumValid(); + + public abstract void UpdateChecksum(); + + public abstract void SetID(ushort wcid); + + public static WondercardSize GetSize(Games game) + { + return game switch + { + Games.LGPE => WondercardSize.WB7, + Games.SWSH => WondercardSize.WC8, + Games.BDSP => WondercardSize.WB8, + Games.PLA => WondercardSize.WA8, + Games.SCVI => WondercardSize.WC9, + _ => throw new ArgumentOutOfRangeException(), + }; + } + } +} diff --git a/SwitchGiftDataManager.Core/Enums/Enums.cs b/SwitchGiftDataManager.Core/Enums/Enums.cs new file mode 100644 index 0000000..fe89531 --- /dev/null +++ b/SwitchGiftDataManager.Core/Enums/Enums.cs @@ -0,0 +1,120 @@ +namespace Enums { + public enum Games : int + { + None = 0, + LGPE = 1, + SWSH = 2, + BDSP = 3, + PLA = 4, + SCVI = 5, + } + + public enum WCType + { + Pokemon, + Item, + } + + internal enum WondercardSize : ushort + { + WB7 = 0x310, + WC8 = 0x2D0, + WB8 = 0x2DC, + WA8 = 0x2C8, + WC9 = 0x2D1, //Placeholder + } + + internal enum GiftType7 : byte + { + Pokemon = 0, + Item = 1, + Bean = 2, + BP = 3, + } + + internal enum GiftType8 : byte + { + None = 0, + Pokemon = 1, + Item = 2, + BP = 3, + Clothing = 4, + Money = 5, + } + + internal enum GiftType8B : byte + { + None = 0, + Pokemon = 1, + Item = 2, + BP = 3, + Clothing = 4, + Money = 5, + Underground = 6, + } + + internal enum GiftType8A : byte + { + None = 0, + Pokemon = 1, + Item = 2, + Clothing = 3, + } + + public enum PIDType + { + RandomPID, + FixedPID, + } + + public enum ShinyType + { + ShinyLocked, + ShinyPossible, + ShinyForced, + ShinyTIDAbuse, + } + + internal enum ShinyType7 : byte + { + Fixed = 0, + ShinyRandom = 1, + Shiny = 2, + ShinyLocked = 3, + } + + internal enum ShinyType8 : byte + { + ShinyLocked = 0, + ShinyRandom = 1, + ShinyStar = 2, + ShinySquare = 3, + Fixed = 4, + } + + internal enum ClothingType8: byte + { + Glasses = 0x06, + Hats = 0x07, + Jackets = 0x08, + Tops = 0x09, + Bags = 0x0A, + Gloves = 0x0B, + Bottoms = 0x0C, + Legwear = 0x0D, + Shoes = 0x0E, + None = 0xFF, + } + + internal enum ClothingType8A: byte + { + Heads = 0x00, + Tops = 0x01, + Bottoms = 0x02, + Outfit = 0x03, + Shoes = 0x5, + Glasses = 0x06, + Eyes = 0x08, + None = 0xFF, + } +} \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Properties/Resources.Designer.cs b/SwitchGiftDataManager.Core/Properties/Resources.Designer.cs new file mode 100644 index 0000000..3bd3d67 --- /dev/null +++ b/SwitchGiftDataManager.Core/Properties/Resources.Designer.cs @@ -0,0 +1,849 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +//------------------------------------------------------------------------------ + +namespace SwitchGiftDataManager.Core.Properties { + using System; + + + /// + /// 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. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SwitchGiftDataManager.Core.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. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to Tops + ///Outerwear + ///Pikachu Hoodie Style + ///Platinum Style + ///Overalls Style + ///Eevee Jacket Style + ///Cyber Style + ///Summer Style + ///Winter Style + ///Spring Style + ///Casual Style + ///Leather Jacket Style + ///Contest Style + ///Gengar Jacket Style + ///Everyday Style + ///. + /// + internal static string BDSPClothing { + get { + return ResourceManager.GetString("BDSPClothing", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to None + ///Master Ball + ///Ultra Ball + ///Great Ball + ///Poké Ball + ///Safari Ball + ///Net Ball + ///Dive Ball + ///Nest Ball + ///Repeat Ball + ///Timer Ball + ///Luxury Ball + ///Premier Ball + ///Dusk Ball + ///Heal Ball + ///Quick Ball + ///Cherish Ball + ///Potion + ///Antidote + ///Burn Heal + ///Ice Heal + ///Awakening + ///Paralyze Heal + ///Full Restore + ///Max Potion + ///Hyper Potion + ///Super Potion + ///Full Heal + ///Revive + ///Max Revive + ///Fresh Water + ///Soda Pop + ///Lemonade + ///Moomoo Milk + ///Energy Powder + ///Energy Root + ///Heal Powder + ///Revival Herb + ///Ether + ///Max Ether + ///Elixir + ///Max Elixir + ///Lava Cookie + ///Berry Juice [rest of string was truncated]";. + /// + internal static string Items { + get { + return ResourceManager.GetString("Items", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to None + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + ///Fancy Bottoms (Oshawott) + ///Fancy Bottoms (Cyndaquil) + ///Fancy Bottoms (Rowlet) + ///Fancy Bottoms (Typhlosion) + ///Fancy Bottoms (Samurott) + ///Fancy Bottoms (Decidueye) + ///Fancy Bottoms (Gyarados) + ///Fancy Bottoms (Cherrim) + ///Fancy Bottoms (Seascape) + ///Fancy Bottoms (Mountainscape) + ///Fancy Bottoms (Townscape) + ///Fancy Bottoms (Spiritomb) + ///Fancy Bottoms (Honchkrow) /// [rest of string was truncated]";. + /// + internal static string PLAClothingBottoms { + get { + return ResourceManager.GetString("PLAClothingBottoms", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to None + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + ///Baneful Fox Mask (White lily) + ///Baneful Fox Mask (Shiny). + /// + internal static string PLAClothingHeads { + get { + return ResourceManager.GetString("PLAClothingHeads", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to None + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + ///Fancy Kimono (Oshawott) + ///Fancy Kimono (Cyndaquil) + ///Fancy Kimono (Rowlet) + ///Fancy Kimono (Typhlosion) + ///Fancy Kimono (Samurott) + ///Fancy Kimono (Decidueye) + ///Fancy Kimono (Gyarados) + ///Fancy Kimono (Cherrim) + ///Fancy Kimono (Seascape) + ///Fancy Kimono (Mountainscape) + ///Fancy Kimono (Townscape) + ///Fancy Kimono (Spiritomb) + ///Fancy Kimono (Honchkrow) + ///Fancy Kimono [rest of string was truncated]";. + /// + internal static string PLAClothingTops { + get { + return ResourceManager.GetString("PLAClothingTops", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to None, + ///Bulbasaur, + ///Ivysaur, + ///Venusaur, + ///Charmander, + ///Charmeleon, + ///Charizard, + ///Squirtle, + ///Wartortle, + ///Blastoise, + ///Caterpie, + ///Metapod, + ///Butterfree, + ///Weedle, + ///Kakuna, + ///Beedrill, + ///Pidgey, + ///Pidgeotto, + ///Pidgeot, + ///Rattata, + ///Raticate, + ///Spearow, + ///Fearow, + ///Ekans, + ///Arbok, + ///Pikachu, + ///Raichu, + ///Sandshrew, + ///Sandslash, + ///NidoranF, + ///Nidorina, + ///Nidoqueen, + ///NidoranM, + ///Nidorino, + ///Nidoking, + ///Clefairy, + ///Clefable, + ///Vulpix, + ///Ninetales, + ///Jigglypuff, + ///Wigglytuff, + ///Zubat, + ///Golbat, + ///Oddish, + ///Gloom, + ///Vileplume, + ///Paras, + ///Parasect, + ///Venon [rest of string was truncated]";. + /// + internal static string Species { + get { + return ResourceManager.GetString("Species", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Sport Travel Bag (Iconic Style) + ///Sport Travel Bag (Challenger Kit) + ///Sport Travel Bag (Grass Type) + ///Sport Travel Bag (Water Type) + ///Sport Travel Bag (Fire Type) + ///Sport Travel Bag (Ghost Type) + ///Sport Travel Bag (Fighting Type) + ///Sport Travel Bag (Fairy Type) + ///Sport Travel Bag (Rock Type) + ///Sport Travel Bag (Ice Type) + ///Sport Travel Bag (Dark Type) + ///Sport Travel Bag (Dragon Type) + ///Sport Travel Bag (Bug Type) + ///Sport Travel Bag (Steel Type) + ///Sport Travel Bag (Psychic Type) + ///Sport Travel Bag (Electric Type) + ///Sport Tr [rest of string was truncated]";. + /// + internal static string SWSHClothingBags { + get { + return ResourceManager.GetString("SWSHClothingBags", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Sport Shorts (Challenger Kit) + ///Sport Shorts (Grass Type) + ///Sport Shorts (Water Type) + ///Sport Shorts (Fire Type) + ///Sport Shorts (Ghost Type) + ///Sport Shorts (Fighting Type) + ///Sport Shorts (Fairy Type) + ///Sport Shorts (Rock Type) + ///Sport Shorts (Ice Type) + ///Sport Shorts (Dark Type) + ///Sport Shorts (Dragon Type) + ///Sport Shorts (Bug Type) + ///Sport Shorts (Steel Type) + ///Sport Shorts (Psychic Type) + ///Sport Shorts (Electric Type) + ///Sport Shorts (Ground Type) + ///Sport Shorts (Flying Type) + ///Sport Shorts (Normal Type) + ///Sport Shorts (Poi [rest of string was truncated]";. + /// + internal static string SWSHClothingBottoms { + get { + return ResourceManager.GetString("SWSHClothingBottoms", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Sport Sunglasses (Iconic Style) + ///Sport Sunglasses (Challenger Kit) + ///Sport Sunglasses (Grass Type) + ///Sport Sunglasses (Water Type) + ///Sport Sunglasses (Fire Type) + ///Sport Sunglasses (Ghost Type) + ///Sport Sunglasses (Fighting Type) + ///Sport Sunglasses (Fairy Type) + ///Sport Sunglasses (Rock Type) + ///Sport Sunglasses (Ice Type) + ///Sport Sunglasses (Dark Type) + ///Sport Sunglasses (Dragon Type) + ///Sport Sunglasses (Bug Type) + ///Sport Sunglasses (Steel Type) + ///Sport Sunglasses (Psychic Type) + ///Sport Sunglasses (Electric Type) + ///Sport Su [rest of string was truncated]";. + /// + internal static string SWSHClothingGlasses { + get { + return ResourceManager.GetString("SWSHClothingGlasses", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to (empty) (Bare) + ///Sport Glove (Challenger Kit) + ///Sport Glove (Grass Type) + ///Sport Glove (Water Type) + ///Sport Glove (Fire Type) + ///Sport Glove (Ghost Type) + ///Sport Glove (Fighting Type) + ///Sport Glove (Fairy Type) + ///Sport Glove (Rock Type) + ///Sport Glove (Ice Type) + ///Sport Glove (Dark Type) + ///Sport Glove (Dragon Type) + ///Sport Glove (Bug Type) + ///Sport Glove (Steel Type) + ///Sport Glove (Psychic Type) + ///Sport Glove (Electric Type) + ///Sport Glove (Ground Type) + ///Sport Glove (Flying Type) + ///Sport Glove (Normal Type) + ///Sport Glove (Poison [rest of string was truncated]";. + /// + internal static string SWSHClothingGloves { + get { + return ResourceManager.GetString("SWSHClothingGloves", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Sport Cap (Iconic Style) + ///Sport Cap (Challenger Kit) + ///Sport Cap (Grass Type) + ///Sport Cap (Water Type) + ///Sport Cap (Fire Type) + ///Sport Cap (Ghost Type) + ///Sport Cap (Fighting Type) + ///Sport Cap (Fairy Type) + ///Sport Cap (Rock Type) + ///Sport Cap (Ice Type) + ///Sport Cap (Dark Type) + ///Sport Cap (Dragon Type) + ///Sport Cap (Bug Type) + ///Sport Cap (Steel Type) + ///Sport Cap (Psychic Type) + ///Sport Cap (Electric Type) + ///Sport Cap (Ground Type) + ///Sport Cap (Flying Type) + ///Sport Cap (Normal Type) + ///Sport Cap (Poison Type) + ///Scally Cap (White) + /// [rest of string was truncated]";. + /// + internal static string SWSHClothingHats { + get { + return ResourceManager.GetString("SWSHClothingHats", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Tracksuit Jacket (Iconic Style) + ///Tracksuit Jacket (Challenger Kit) + ///Tracksuit Jacket (Grass Type) + ///Tracksuit Jacket (Water Type) + ///Tracksuit Jacket (Fire Type) + ///Tracksuit Jacket (Ghost Type) + ///Tracksuit Jacket (Fighting Type) + ///Tracksuit Jacket (Fairy Type) + ///Tracksuit Jacket (Rock Type) + ///Tracksuit Jacket (Ice Type) + ///Tracksuit Jacket (Dark Type) + ///Tracksuit Jacket (Dragon Type) + ///Tracksuit Jacket (Bug Type) + ///Tracksuit Jacket (Steel Type) + ///Tracksuit Jacket (Psychic Type) + ///Tracksuit Jacket (Electric Type) + ///Tracksui [rest of string was truncated]";. + /// + internal static string SWSHClothingJackets { + get { + return ResourceManager.GetString("SWSHClothingJackets", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Sport Legwear (Challenger Kit) + ///Sport Legwear (Grass Type) + ///Sport Legwear (Water Type) + ///Sport Legwear (Fire Type) + ///Sport Legwear (Ghost Type) + ///Sport Legwear (Fighting Type) + ///Sport Legwear (Fairy Type) + ///Sport Legwear (Rock Type) + ///Sport Legwear (Ice Type) + ///Sport Legwear (Dark Type) + ///Sport Legwear (Dragon Type) + ///Sport Legwear (Bug Type) + ///Sport Legwear (Steel Type) + ///Sport Legwear (Psychic Type) + ///Sport Legwear (Electric Type) + ///Sport Legwear (Ground Type) + ///Sport Legwear (Flying Type) + ///Sport Legwear (Normal Type) /// [rest of string was truncated]";. + /// + internal static string SWSHClothingLegwear { + get { + return ResourceManager.GetString("SWSHClothingLegwear", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Sport High-Tops (Challenger Kit) + ///Sport High-Tops (Grass Type) + ///Sport High-Tops (Water Type) + ///Sport High-Tops (Fire Type) + ///Sport High-Tops (Ghost Type) + ///Sport High-Tops (Fighting Type) + ///Sport High-Tops (Fairy Type) + ///Sport High-Tops (Rock Type) + ///Sport High-Tops (Ice Type) + ///Sport High-Tops (Dark Type) + ///Sport High-Tops (Dragon Type) + ///Sport High-Tops (Bug Type) + ///Sport High-Tops (Steel Type) + ///Sport High-Tops (Psychic Type) + ///Sport High-Tops (Electric Type) + ///Sport High-Tops (Ground Type) + ///Sport High-Tops (Flying T [rest of string was truncated]";. + /// + internal static string SWSHClothingShoes { + get { + return ResourceManager.GetString("SWSHClothingShoes", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Sport Top (Challenger Kit) + ///Sport Top (Grass Type) + ///Sport Top (Water Type) + ///Sport Top (Fire Type) + ///Sport Top (Ghost Type) + ///Sport Top (Fighting Type) + ///Sport Top (Fairy Type) + ///Sport Top (Rock Type) + ///Sport Top (Ice Type) + ///Sport Top (Dark Type) + ///Sport Top (Dragon Type) + ///Sport Top (Bug Type) + ///Sport Top (Steel Type) + ///Sport Top (Psychic Type) + ///Sport Top (Electric Type) + ///Sport Top (Ground Type) + ///Sport Top (Flying Type) + ///Sport Top (Normal Type) + ///Sport Top (Poison Type) + ///Sport Top (Reigning Champion) + ///Sport Top (Pika [rest of string was truncated]";. + /// + internal static string SWSHClothingTops { + get { + return ResourceManager.GetString("SWSHClothingTops", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to None + ///Red Sphere S + ///Blue Sphere S + ///Green Sphere S + ///Prism Sphere S + ///Pale Sphere S + ///Red Sphere L + ///Blue Sphere L + ///Green Sphere L + ///Prism Sphere L + ///Pale Sphere L + ///Revive + ///Max Revive + ///Red Shard + ///Blue Shard + ///Yellow Shard + ///Green Shard + ///Sun Stone + ///Moon Stone + ///Fire Stone + ///Thunder Stone + ///Water Stone + ///Leaf Stone + ///Oval Stone + ///Everstone + ///Odd Keystone + ///Star Piece + ///Heart Scale + ///Root Fossil + ///Claw Fossil + ///Helix Fossil + ///Dome Fossil + ///Old Amber + ///Armor Fossil + ///Skull Fossil + ///Rare Bone + ///Light Clay + ///Iron Ball + ///Icy Rock + ///Smooth Rock [rest of string was truncated]";. + /// + internal static string UndergroundItems { + get { + return ResourceManager.GetString("UndergroundItems", resourceCulture); + } + } + } +} diff --git a/SwitchGiftDataManager.Core/Properties/Resources.resx b/SwitchGiftDataManager.Core/Properties/Resources.resx new file mode 100644 index 0000000..bbe0564 --- /dev/null +++ b/SwitchGiftDataManager.Core/Properties/Resources.resx @@ -0,0 +1,169 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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\BDSPClothing.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\Items.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8 + + + ..\Resources\PLAClothingBottoms.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\PLAClothingHeads.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\PLAClothingTops.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\Species.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8 + + + ..\Resources\SWSHClothingBags.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\SWSHClothingBottoms.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\SWSHClothingGlasses.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\SWSHClothingGloves.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\SWSHClothingHats.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\SWSHClothingJackets.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\SWSHClothingLegwear.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\SWSHClothingShoes.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\SWSHClothingTops.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252 + + + ..\Resources\UndergroundItems.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8 + + \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/BDSPClothing.txt b/SwitchGiftDataManager.Core/Resources/BDSPClothing.txt new file mode 100644 index 0000000..1dc8095 --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/BDSPClothing.txt @@ -0,0 +1,15 @@ +Tops +Outerwear +Pikachu Hoodie Style +Platinum Style +Overalls Style +Eevee Jacket Style +Cyber Style +Summer Style +Winter Style +Spring Style +Casual Style +Leather Jacket Style +Contest Style +Gengar Jacket Style +Everyday Style diff --git a/SwitchGiftDataManager.Core/Resources/Items.txt b/SwitchGiftDataManager.Core/Resources/Items.txt new file mode 100644 index 0000000..3d4eca5 --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/Items.txt @@ -0,0 +1,1829 @@ +None +Master Ball +Ultra Ball +Great Ball +Poké Ball +Safari Ball +Net Ball +Dive Ball +Nest Ball +Repeat Ball +Timer Ball +Luxury Ball +Premier Ball +Dusk Ball +Heal Ball +Quick Ball +Cherish Ball +Potion +Antidote +Burn Heal +Ice Heal +Awakening +Paralyze Heal +Full Restore +Max Potion +Hyper Potion +Super Potion +Full Heal +Revive +Max Revive +Fresh Water +Soda Pop +Lemonade +Moomoo Milk +Energy Powder +Energy Root +Heal Powder +Revival Herb +Ether +Max Ether +Elixir +Max Elixir +Lava Cookie +Berry Juice +Sacred Ash +HP Up +Protein +Iron +Carbos +Calcium +Rare Candy +PP Up +Zinc +PP Max +Old Gateau +Guard Spec. +Dire Hit +X Attack +X Defense +X Speed +X Accuracy +X Sp. Atk +X Sp. Def +Poké Doll +Fluffy Tail +Blue Flute +Yellow Flute +Red Flute +Black Flute +White Flute +Shoal Salt +Shoal Shell +Red Shard +Blue Shard +Yellow Shard +Green Shard +Super Repel +Max Repel +Escape Rope +Repel +Sun Stone +Moon Stone +Fire Stone +Thunder Stone +Water Stone +Leaf Stone +Tiny Mushroom +Big Mushroom +Pearl +Big Pearl +Stardust +Star Piece +Nugget +Heart Scale +Honey +Growth Mulch +Damp Mulch +Stable Mulch +Gooey Mulch +Root Fossil +Claw Fossil +Helix Fossil +Dome Fossil +Old Amber +Armor Fossil +Skull Fossil +Rare Bone +Shiny Stone +Dusk Stone +Dawn Stone +Oval Stone +Odd Keystone +Griseous Orb +Tea +??? +Autograph +Douse Drive +Shock Drive +Burn Drive +Chill Drive +??? +Pokémon Box Link +Medicine Pocket +TM Case +Candy Jar +Power-Up Pocket +Clothing Trunk +Catching Pocket +Battle Pocket +??? +??? +??? +??? +??? +Sweet Heart +Adamant Orb +Lustrous Orb +Greet Mail +Favored Mail +RSVP Mail +Thanks Mail +Inquiry Mail +Like Mail +Reply Mail +Bridge Mail S +Bridge Mail D +Bridge Mail T +Bridge Mail V +Bridge Mail M +Cheri Berry +Chesto Berry +Pecha Berry +Rawst Berry +Aspear Berry +Leppa Berry +Oran Berry +Persim Berry +Lum Berry +Sitrus Berry +Figy Berry +Wiki Berry +Mago Berry +Aguav Berry +Iapapa Berry +Razz Berry +Bluk Berry +Nanab Berry +Wepear Berry +Pinap Berry +Pomeg Berry +Kelpsy Berry +Qualot Berry +Hondew Berry +Grepa Berry +Tamato Berry +Cornn Berry +Magost Berry +Rabuta Berry +Nomel Berry +Spelon Berry +Pamtre Berry +Watmel Berry +Durin Berry +Belue Berry +Occa Berry +Passho Berry +Wacan Berry +Rindo Berry +Yache Berry +Chople Berry +Kebia Berry +Shuca Berry +Coba Berry +Payapa Berry +Tanga Berry +Charti Berry +Kasib Berry +Haban Berry +Colbur Berry +Babiri Berry +Chilan Berry +Liechi Berry +Ganlon Berry +Salac Berry +Petaya Berry +Apicot Berry +Lansat Berry +Starf Berry +Enigma Berry +Micle Berry +Custap Berry +Jaboca Berry +Rowap Berry +Bright Powder +White Herb +Macho Brace +Exp. Share +Quick Claw +Soothe Bell +Mental Herb +Choice Band +King’s Rock +Silver Powder +Amulet Coin +Cleanse Tag +Soul Dew +Deep Sea Tooth +Deep Sea Scale +Smoke Ball +Everstone +Focus Band +Lucky Egg +Scope Lens +Metal Coat +Leftovers +Dragon Scale +Light Ball +Soft Sand +Hard Stone +Miracle Seed +Black Glasses +Black Belt +Magnet +Mystic Water +Sharp Beak +Poison Barb +Never-Melt Ice +Spell Tag +Twisted Spoon +Charcoal +Dragon Fang +Silk Scarf +Upgrade +Shell Bell +Sea Incense +Lax Incense +Lucky Punch +Metal Powder +Thick Club +Leek +Red Scarf +Blue Scarf +Pink Scarf +Green Scarf +Yellow Scarf +Wide Lens +Muscle Band +Wise Glasses +Expert Belt +Light Clay +Life Orb +Power Herb +Toxic Orb +Flame Orb +Quick Powder +Focus Sash +Zoom Lens +Metronome +Iron Ball +Lagging Tail +Destiny Knot +Black Sludge +Icy Rock +Smooth Rock +Heat Rock +Damp Rock +Grip Claw +Choice Scarf +Sticky Barb +Power Bracer +Power Belt +Power Lens +Power Band +Power Anklet +Power Weight +Shed Shell +Big Root +Choice Specs +Flame Plate +Splash Plate +Zap Plate +Meadow Plate +Icicle Plate +Fist Plate +Toxic Plate +Earth Plate +Sky Plate +Mind Plate +Insect Plate +Stone Plate +Spooky Plate +Draco Plate +Dread Plate +Iron Plate +Odd Incense +Rock Incense +Full Incense +Wave Incense +Rose Incense +Luck Incense +Pure Incense +Protector +Electirizer +Magmarizer +Dubious Disc +Reaper Cloth +Razor Claw +Razor Fang +TM01 +TM02 +TM03 +TM04 +TM05 +TM06 +TM07 +TM08 +TM09 +TM10 +TM11 +TM12 +TM13 +TM14 +TM15 +TM16 +TM17 +TM18 +TM19 +TM20 +TM21 +TM22 +TM23 +TM24 +TM25 +TM26 +TM27 +TM28 +TM29 +TM30 +TM31 +TM32 +TM33 +TM34 +TM35 +TM36 +TM37 +TM38 +TM39 +TM40 +TM41 +TM42 +TM43 +TM44 +TM45 +TM46 +TM47 +TM48 +TM49 +TM50 +TM51 +TM52 +TM53 +TM54 +TM55 +TM56 +TM57 +TM58 +TM59 +TM60 +TM61 +TM62 +TM63 +TM64 +TM65 +TM66 +TM67 +TM68 +TM69 +TM70 +TM71 +TM72 +TM73 +TM74 +TM75 +TM76 +TM77 +TM78 +TM79 +TM80 +TM81 +TM82 +TM83 +TM84 +TM85 +TM86 +TM87 +TM88 +TM89 +TM90 +TM91 +TM92 +HM01 +HM02 +HM03 +HM04 +HM05 +HM06 +??? +??? +Explorer Kit +Loot Sack +Rule Book +Poké Radar +Point Card +Journal +Seal Case +Fashion Case +Seal Bag +Pal Pad +Works Key +Old Charm +Galactic Key +Red Chain +Town Map +Vs. Seeker +Coin Case +Old Rod +Good Rod +Super Rod +Sprayduck +Poffin Case +Bike +Suite Key +Oak’s Letter +Lunar Feather +Member Card +Azure Flute +S.S. Ticket +Contest Pass +Magma Stone +Parcel +Coupon 1 +Coupon 2 +Coupon 3 +Storage Key +Secret Medicine +Vs. Recorder +Gracidea +Secret Key +Apricorn Box +Unown Report +Berry Pots +Dowsing Machine +Blue Card +Slowpoke Tail +Clear Bell +Card Key +Basement Key +Squirt Bottle +Red Scale +Lost Item +Pass +Machine Part +Silver Wing +Rainbow Wing +Mystery Egg +Red Apricorn +Blue Apricorn +Yellow Apricorn +Green Apricorn +Pink Apricorn +White Apricorn +Black Apricorn +Fast Ball +Level Ball +Lure Ball +Heavy Ball +Love Ball +Friend Ball +Moon Ball +Sport Ball +Park Ball +Photo Album +GB Sounds +Tidal Bell +Rage Candy Bar +Data Card 01 +Data Card 02 +Data Card 03 +Data Card 04 +Data Card 05 +Data Card 06 +Data Card 07 +Data Card 08 +Data Card 09 +Data Card 10 +Data Card 11 +Data Card 12 +Data Card 13 +Data Card 14 +Data Card 15 +Data Card 16 +Data Card 17 +Data Card 18 +Data Card 19 +Data Card 20 +Data Card 21 +Data Card 22 +Data Card 23 +Data Card 24 +Data Card 25 +Data Card 26 +Data Card 27 +Jade Orb +Lock Capsule +Red Orb +Blue Orb +Enigma Stone +Prism Scale +Eviolite +Float Stone +Rocky Helmet +Air Balloon +Red Card +Ring Target +Binding Band +Absorb Bulb +Cell Battery +Eject Button +Fire Gem +Water Gem +Electric Gem +Grass Gem +Ice Gem +Fighting Gem +Poison Gem +Ground Gem +Flying Gem +Psychic Gem +Bug Gem +Rock Gem +Ghost Gem +Dragon Gem +Dark Gem +Steel Gem +Normal Gem +Health Feather +Muscle Feather +Resist Feather +Genius Feather +Clever Feather +Swift Feather +Pretty Feather +Cover Fossil +Plume Fossil +Liberty Pass +Pass Orb +Dream Ball +Poké Toy +Prop Case +Dragon Skull +Balm Mushroom +Big Nugget +Pearl String +Comet Shard +Relic Copper +Relic Silver +Relic Gold +Relic Vase +Relic Band +Relic Statue +Relic Crown +Casteliacone +Dire Hit 2 +X Speed 2 +X Sp. Atk 2 +X Sp. Def 2 +X Defense 2 +X Attack 2 +X Accuracy 2 +X Speed 3 +X Sp. Atk 3 +X Sp. Def 3 +X Defense 3 +X Attack 3 +X Accuracy 3 +X Speed 6 +X Sp. Atk 6 +X Sp. Def 6 +X Defense 6 +X Attack 6 +X Accuracy 6 +Ability Urge +Item Drop +Item Urge +Reset Urge +Dire Hit 3 +Light Stone +Dark Stone +TM93 +TM94 +TM95 +Xtransceiver +??? +Gram 1 +Gram 2 +Gram 3 +Xtransceiver +Medal Box +DNA Splicers +DNA Splicers +Permit +Oval Charm +Shiny Charm +Plasma Card +Grubby Hanky +Colress Machine +Dropped Item +Dropped Item +Reveal Glass +Weakness Policy +Assault Vest +Holo Caster +Prof’s Letter +Roller Skates +Pixie Plate +Ability Capsule +Whipped Dream +Sachet +Luminous Moss +Snowball +Safety Goggles +Poké Flute +Rich Mulch +Surprise Mulch +Boost Mulch +Amaze Mulch +Gengarite +Gardevoirite +Ampharosite +Venusaurite +Charizardite X +Blastoisinite +Mewtwonite X +Mewtwonite Y +Blazikenite +Medichamite +Houndoominite +Aggronite +Banettite +Tyranitarite +Scizorite +Pinsirite +Aerodactylite +Lucarionite +Abomasite +Kangaskhanite +Gyaradosite +Absolite +Charizardite Y +Alakazite +Heracronite +Mawilite +Manectite +Garchompite +Latiasite +Latiosite +Roseli Berry +Kee Berry +Maranga Berry +Sprinklotad +TM96 +TM97 +TM98 +TM99 +TM100 +Power Plant Pass +Mega Ring +Intriguing Stone +Common Stone +Discount Coupon +Elevator Key +TMV Pass +Honor of Kalos +Adventure Guide +Strange Souvenir +Lens Case +Makeup Bag +Travel Trunk +Lumiose Galette +Shalour Sable +Jaw Fossil +Sail Fossil +Looker Ticket +Bike +Holo Caster +Fairy Gem +Mega Charm +Mega Glove +Mach Bike +Acro Bike +Wailmer Pail +Devon Parts +Soot Sack +Basement Key +Pokéblock Kit +Letter +Eon Ticket +Scanner +Go-Goggles +Meteorite +Key to Room 1 +Key to Room 2 +Key to Room 4 +Key to Room 6 +Storage Key +Devon Scope +S.S. Ticket +HM07 +Devon Scuba Gear +Contest Costume +Contest Costume +Magma Suit +Aqua Suit +Pair of Tickets +Mega Bracelet +Mega Pendant +Mega Glasses +Mega Anchor +Mega Stickpin +Mega Tiara +Mega Anklet +Meteorite +Swampertite +Sceptilite +Sablenite +Altarianite +Galladite +Audinite +Metagrossite +Sharpedonite +Slowbronite +Steelixite +Pidgeotite +Glalitite +Diancite +Prison Bottle +Mega Cuff +Cameruptite +Lopunnite +Salamencite +Beedrillite +Meteorite +Meteorite +Key Stone +Meteorite Shard +Eon Flute +Normalium Z +Firium Z +Waterium Z +Electrium Z +Grassium Z +Icium Z +Fightinium Z +Poisonium Z +Groundium Z +Flyinium Z +Psychium Z +Buginium Z +Rockium Z +Ghostium Z +Dragonium Z +Darkinium Z +Steelium Z +Fairium Z +Pikanium Z +Bottle Cap +Gold Bottle Cap +Z-Ring +Decidium Z +Incinium Z +Primarium Z +Tapunium Z +Marshadium Z +Aloraichium Z +Snorlium Z +Eevium Z +Mewnium Z +Normalium Z +Firium Z +Waterium Z +Electrium Z +Grassium Z +Icium Z +Fightinium Z +Poisonium Z +Groundium Z +Flyinium Z +Psychium Z +Buginium Z +Rockium Z +Ghostium Z +Dragonium Z +Darkinium Z +Steelium Z +Fairium Z +Pikanium Z +Decidium Z +Incinium Z +Primarium Z +Tapunium Z +Marshadium Z +Aloraichium Z +Snorlium Z +Eevium Z +Mewnium Z +Pikashunium Z +Pikashunium Z +??? +??? +??? +??? +Forage Bag +Fishing Rod +Professor’s Mask +Festival Ticket +Sparkling Stone +Adrenaline Orb +Zygarde Cube +??? +Ice Stone +Ride Pager +Beast Ball +Big Malasada +Red Nectar +Yellow Nectar +Pink Nectar +Purple Nectar +Sun Flute +Moon Flute +??? +Enigmatic Card +Silver Razz Berry +Golden Razz Berry +Silver Nanab Berry +Golden Nanab Berry +Silver Pinap Berry +Golden Pinap Berry +??? +??? +??? +??? +??? +Secret Key +S.S. Ticket +Silph Scope +Parcel +Card Key +Gold Teeth +Lift Key +Terrain Extender +Protective Pads +Electric Seed +Psychic Seed +Misty Seed +Grassy Seed +Stretchy Spring +Chalky Stone +Marble +Lone Earring +Beach Glass +Gold Leaf +Silver Leaf +Polished Mud Ball +Tropical Shell +Leaf Letter +Leaf Letter +Small Bouquet +??? +??? +??? +Lure +Super Lure +Max Lure +Pewter Crunchies +Fighting Memory +Flying Memory +Poison Memory +Ground Memory +Rock Memory +Bug Memory +Ghost Memory +Steel Memory +Fire Memory +Water Memory +Grass Memory +Electric Memory +Psychic Memory +Ice Memory +Dragon Memory +Dark Memory +Fairy Memory +Solganium Z +Lunalium Z +Ultranecrozium Z +Mimikium Z +Lycanium Z +Kommonium Z +Solganium Z +Lunalium Z +Ultranecrozium Z +Mimikium Z +Lycanium Z +Kommonium Z +Z-Power Ring +Pink Petal +Orange Petal +Blue Petal +Red Petal +Green Petal +Yellow Petal +Purple Petal +Rainbow Flower +Surge Badge +N-Solarizer +N-Lunarizer +N-Solarizer +N-Lunarizer +Ilima Normalium Z +Left Poké Ball +Roto Hatch +Roto Bargain +Roto Prize Money +Roto Exp. Points +Roto Friendship +Roto Encounter +Roto Stealth +Roto HP Restore +Roto PP Restore +Roto Boost +Roto Catch +Health Candy +Mighty Candy +Tough Candy +Smart Candy +Courage Candy +Quick Candy +Health Candy L +Mighty Candy L +Tough Candy L +Smart Candy L +Courage Candy L +Quick Candy L +Health Candy XL +Mighty Candy XL +Tough Candy XL +Smart Candy XL +Courage Candy XL +Quick Candy XL +Bulbasaur Candy +Charmander Candy +Squirtle Candy +Caterpie Candy +Weedle Candy +Pidgey Candy +Rattata Candy +Spearow Candy +Ekans Candy +Pikachu Candy +Sandshrew Candy +Nidoran♀ Candy +Nidoran♂ Candy +Clefairy Candy +Vulpix Candy +Jigglypuff Candy +Zubat Candy +Oddish Candy +Paras Candy +Venonat Candy +Diglett Candy +Meowth Candy +Psyduck Candy +Mankey Candy +Growlithe Candy +Poliwag Candy +Abra Candy +Machop Candy +Bellsprout Candy +Tentacool Candy +Geodude Candy +Ponyta Candy +Slowpoke Candy +Magnemite Candy +Farfetch’d Candy +Doduo Candy +Seel Candy +Grimer Candy +Shellder Candy +Gastly Candy +Onix Candy +Drowzee Candy +Krabby Candy +Voltorb Candy +Exeggcute Candy +Cubone Candy +Hitmonlee Candy +Hitmonchan Candy +Lickitung Candy +Koffing Candy +Rhyhorn Candy +Chansey Candy +Tangela Candy +Kangaskhan Candy +Horsea Candy +Goldeen Candy +Staryu Candy +Mr. Mime Candy +Scyther Candy +Jynx Candy +Electabuzz Candy +Pinsir Candy +Tauros Candy +Magikarp Candy +Lapras Candy +Ditto Candy +Eevee Candy +Porygon Candy +Omanyte Candy +Kabuto Candy +Aerodactyl Candy +Snorlax Candy +Articuno Candy +Zapdos Candy +Moltres Candy +Dratini Candy +Mewtwo Candy +Mew Candy +Meltan Candy +Magmar Candy +??? +??? +??? +??? +??? +??? +??? +??? +??? +??? +??? +??? +??? +??? +??? +??? +Endorsement +Pokémon Box Link +Wishing Star +Dynamax Band +??? +??? +Fishing Rod +Rotom Bike +??? +??? +Sausages +Bob’s Food Tin +Bach’s Food Tin +Tin of Beans +Bread +Pasta +Mixed Mushrooms +Smoke-Poke Tail +Large Leek +Fancy Apple +Brittle Bones +Pack of Potatoes +Pungent Root +Salad Mix +Fried Food +Boiled Egg +Camping Gear +??? +??? +Rusted Sword +Rusted Shield +Fossilized Bird +Fossilized Fish +Fossilized Drake +Fossilized Dino +Strawberry Sweet +Love Sweet +Berry Sweet +Clover Sweet +Flower Sweet +Star Sweet +Ribbon Sweet +Sweet Apple +Tart Apple +Throat Spray +Eject Pack +Heavy-Duty Boots +Blunder Policy +Room Service +Utility Umbrella +Exp. Candy XS +Exp. Candy S +Exp. Candy M +Exp. Candy L +Exp. Candy XL +Dynamax Candy +TR00 +TR01 +TR02 +TR03 +TR04 +TR05 +TR06 +TR07 +TR08 +TR09 +TR10 +TR11 +TR12 +TR13 +TR14 +TR15 +TR16 +TR17 +TR18 +TR19 +TR20 +TR21 +TR22 +TR23 +TR24 +TR25 +TR26 +TR27 +TR28 +TR29 +TR30 +TR31 +TR32 +TR33 +TR34 +TR35 +TR36 +TR37 +TR38 +TR39 +TR40 +TR41 +TR42 +TR43 +TR44 +TR45 +TR46 +TR47 +TR48 +TR49 +TR50 +TR51 +TR52 +TR53 +TR54 +TR55 +TR56 +TR57 +TR58 +TR59 +TR60 +TR61 +TR62 +TR63 +TR64 +TR65 +TR66 +TR67 +TR68 +TR69 +TR70 +TR71 +TR72 +TR73 +TR74 +TR75 +TR76 +TR77 +TR78 +TR79 +TR80 +TR81 +TR82 +TR83 +TR84 +TR85 +TR86 +TR87 +TR88 +TR89 +TR90 +TR91 +TR92 +TR93 +TR94 +TR95 +TR96 +TR97 +TR98 +TR99 +TM00 +Lonely Mint +Adamant Mint +Naughty Mint +Brave Mint +Bold Mint +Impish Mint +Lax Mint +Relaxed Mint +Modest Mint +Mild Mint +Rash Mint +Quiet Mint +Calm Mint +Gentle Mint +Careful Mint +Sassy Mint +Timid Mint +Hasty Mint +Jolly Mint +Naive Mint +Serious Mint +Wishing Piece +Cracked Pot +Chipped Pot +Hi-tech Earbuds +Fruit Bunch +Moomoo Cheese +Spice Mix +Fresh Cream +Packaged Curry +Coconut Milk +Instant Noodles +Precooked Burger +Gigantamix +Wishing Chip +Rotom Bike +Catching Charm +??? +Old Letter +Band Autograph +Sonia’s Book +??? +??? +??? +??? +??? +??? +Rotom Catalog +★And458 +★And15 +★And337 +★And603 +★And390 +★Sgr6879 +★Sgr6859 +★Sgr6913 +★Sgr7348 +★Sgr7121 +★Sgr6746 +★Sgr7194 +★Sgr7337 +★Sgr7343 +★Sgr6812 +★Sgr7116 +★Sgr7264 +★Sgr7597 +★Del7882 +★Del7906 +★Del7852 +★Psc596 +★Psc361 +★Psc510 +★Psc437 +★Psc8773 +★Lep1865 +★Lep1829 +★Boo5340 +★Boo5506 +★Boo5435 +★Boo5602 +★Boo5733 +★Boo5235 +★Boo5351 +★Hya3748 +★Hya3903 +★Hya3418 +★Hya3482 +★Hya3845 +★Eri1084 +★Eri472 +★Eri1666 +★Eri897 +★Eri1231 +★Eri874 +★Eri1298 +★Eri1325 +★Eri984 +★Eri1464 +★Eri1393 +★Eri850 +★Tau1409 +★Tau1457 +★Tau1165 +★Tau1791 +★Tau1910 +★Tau1346 +★Tau1373 +★Tau1412 +★CMa2491 +★CMa2693 +★CMa2294 +★CMa2827 +★CMa2282 +★CMa2618 +★CMa2657 +★CMa2646 +★UMa4905 +★UMa4301 +★UMa5191 +★UMa5054 +★UMa4295 +★UMa4660 +★UMa4554 +★UMa4069 +★UMa3569 +★UMa3323 +★UMa4033 +★UMa4377 +★UMa4375 +★UMa4518 +★UMa3594 +★Vir5056 +★Vir4825 +★Vir4932 +★Vir4540 +★Vir4689 +★Vir5338 +★Vir4910 +★Vir5315 +★Vir5359 +★Vir5409 +★Vir5107 +★Ari617 +★Ari553 +★Ari546 +★Ari951 +★Ori1713 +★Ori2061 +★Ori1790 +★Ori1903 +★Ori1948 +★Ori2004 +★Ori1852 +★Ori1879 +★Ori1899 +★Ori1543 +★Cas21 +★Cas168 +★Cas403 +★Cas153 +★Cas542 +★Cas219 +★Cas265 +★Cnc3572 +★Cnc3208 +★Cnc3461 +★Cnc3449 +★Cnc3429 +★Cnc3627 +★Cnc3268 +★Cnc3249 +★Com4968 +★Crv4757 +★Crv4623 +★Crv4662 +★Crv4786 +★Aur1708 +★Aur2088 +★Aur1605 +★Aur2095 +★Aur1577 +★Aur1641 +★Aur1612 +★Pav7790 +★Cet911 +★Cet681 +★Cet188 +★Cet539 +★Cet804 +★Cep8974 +★Cep8162 +★Cep8238 +★Cep8417 +★Cen5267 +★Cen5288 +★Cen551 +★Cen5459 +★Cen5460 +★CMi2943 +★CMi2845 +★Equ8131 +★Vul7405 +★UMi424 +★UMi5563 +★UMi5735 +★UMi6789 +★Crt4287 +★Lyr7001 +★Lyr7178 +★Lyr7106 +★Lyr7298 +★Ara6585 +★Sco6134 +★Sco6527 +★Sco6553 +★Sco5953 +★Sco5984 +★Sco6508 +★Sco6084 +★Sco5944 +★Sco6630 +★Sco6027 +★Sco6247 +★Sco6252 +★Sco5928 +★Sco6241 +★Sco6165 +★Tri544 +★Leo3982 +★Leo4534 +★Leo4357 +★Leo4057 +★Leo4359 +★Leo4031 +★Leo3852 +★Leo3905 +★Leo3773 +★Gru8425 +★Gru8636 +★Gru8353 +★Lib5685 +★Lib5531 +★Lib5787 +★Lib5603 +★Pup3165 +★Pup3185 +★Pup3045 +★Cyg7924 +★Cyg7417 +★Cyg7796 +★Cyg8301 +★Cyg7949 +★Cyg7528 +★Oct7228 +★Col1956 +★Col2040 +★Col2177 +★Gem2990 +★Gem2891 +★Gem2421 +★Gem2473 +★Gem2216 +★Gem2777 +★Gem2650 +★Gem2286 +★Gem2484 +★Gem2930 +★Peg8775 +★Peg8781 +★Peg39 +★Peg8308 +★Peg8650 +★Peg8634 +★Peg8684 +★Peg8450 +★Peg8880 +★Peg8905 +★Oph6556 +★Oph6378 +★Oph6603 +★Oph6149 +★Oph6056 +★Oph6075 +★Ser5854 +★Ser7141 +★Ser5879 +★Her6406 +★Her6148 +★Her6410 +★Her6526 +★Her6117 +★Her6008 +★Per936 +★Per1017 +★Per1131 +★Per1228 +★Per834 +★Per941 +★Phe99 +★Phe338 +★Vel3634 +★Vel3485 +★Vel3734 +★Aqr8232 +★Aqr8414 +★Aqr8709 +★Aqr8518 +★Aqr7950 +★Aqr8499 +★Aqr8610 +★Aqr8264 +★Cru4853 +★Cru4730 +★Cru4763 +★Cru4700 +★Cru4656 +★PsA8728 +★TrA6217 +★Cap7776 +★Cap7754 +★Cap8278 +★Cap8322 +★Cap7773 +★Sge7479 +★Car2326 +★Car3685 +★Car3307 +★Car3699 +★Dra5744 +★Dra5291 +★Dra6705 +★Dra6536 +★Dra7310 +★Dra6688 +★Dra4434 +★Dra6370 +★Dra7462 +★Dra6396 +★Dra6132 +★Dra6636 +★CVn4915 +★CVn4785 +★CVn4846 +★Aql7595 +★Aql7557 +★Aql7525 +★Aql7602 +★Aql7235 +Max Honey +Max Mushrooms +Galarica Twig +Galarica Cuff +Style Card +Armor Pass +Rotom Bike +Rotom Bike +Exp. Charm +Armorite Ore +Mark Charm +Reins of Unity +Reins of Unity +Galarica Wreath +Legendary Clue 1 +Legendary Clue 2 +Legendary Clue 3 +Legendary Clue? +Crown Pass +Wooden Crown +Radiant Petal +White Mane Hair +Black Mane Hair +Iceroot Carrot +Shaderoot Carrot +Dynite Ore +Carrot Seeds +Ability Patch +Reins of Unity +Time Balm +Space Balm +Mysterious Balm +Linking Cord +Hometown Muffin +Apricorn +Jubilife Muffin +Aux Powerguard +Dire Hit +Choice Dumpling +Twice-Spiced Radish +Swap Snack +Caster Fern +Seed of Mastery +Poké Ball +??? +Eternal Ice +Uxie’s Claw +Azelf’s Fang +Mesprit’s Plume +Tumblestone +Celestica Flute +Remedy +Fine Remedy +Dazzling Honey +Hearty Grains +Plump Beans +Springy Mushroom +Crunchy Salt +Wood +King’s Leaf +Marsh Balm +Poké Ball +Great Ball +Ultra Ball +Feather Ball +Pokéshi Doll +??? +Smoke Bomb +Scatter Bang +Sticky Glob +Star Piece +Mushroom Cake +Bugwort +Honey Cake +Grain Cake +Bean Cake +Salt Cake +Potion +Super Potion +Hyper Potion +Max Potion +Full Restore +Remedy +Fine Remedy +Superb Remedy +Old Gateau +Jubilife Muffin +Full Heal +Revive +Max Revive +Max Ether +Max Elixir +Stealth Spray +??? +Aux Power +Aux Guard +Dire Hit +Aux Evasion +Aux Powerguard +Forest Balm +Iron Chunk +??? +Black Tumblestone +Sky Tumblestone +??? +Ball of Mud +??? +Pop Pod +Sootfoot Root +Spoiled Apricorn +Snowball +Sticky Glob +Black Augurite +Peat Block +Stealth Spray +Medicinal Leek +Vivichoke +Pep-Up Plant +??? +??? +Tempting Charm B +Tempting Charm P +Swordcap +Iron Barktongue +Doppel Bonnets +Direshroom +Sand Radish +Tempting Charm T +Tempting Charm Y +Candy Truffle +Cake-Lure Base +Poké Ball +Great Ball +Ultra Ball +Feather Ball +??? +??? +Scatter Bang +Smoke Bomb +??? +??? +Pokéshi Doll +Volcano Balm +Mountain Balm +Snow Balm +Honey Cake +Grain Cake +Bean Cake +Mushroom Cake +Salt Cake +Swap Snack +Choice Dumpling +Twice-Spiced Radish +Survival Charm R +Survival Charm B +Survival Charm P +Survival Charm T +Survival Charm Y +Torn Journal +Warding Charm R +Warding Charm B +Warding Charm P +Warding Charm T +Warding Charm Y +Wall Fragment +Basculegion Food +Old Journal +Wing Ball +Jet Ball +Heavy Ball +Leaden Ball +Gigaton Ball +Wing Ball +Jet Ball +Heavy Ball +Hopo Berry +Superb Remedy +Aux Power +Aux Guard +Aux Evasion +Grit Dust +Grit Gravel +Grit Pebble +Grit Rock +Secret Medicine +Tempting Charm R +Lost Satchel +Lost Satchel +Lost Satchel +Lost Satchel +Lost Satchel +??? +Origin Ball +??? +??? +??? +??? +Origin Ore +Adamant Crystal +Lustrous Globe +Griseous Core +Blank Plate +??? +Crafting Kit +Leaden Ball +Gigaton Ball +Strange Ball +Pokédex +Old Verse 1 +Old Verse 2 +Old Verse 3 +Old Verse 4 +??? +Old Verse 5 +Old Verse 6 +Old Verse 7 +Old Verse 8 +Old Verse 9 +Old Verse 10 +Old Verse 11 +Old Verse 12 +Old Verse 13 +Old Verse 14 +Old Verse 15 +Old Verse 16 +Old Verse 17 +Old Verse 18 +Old Verse 19 +Old Verse 20 +Mysterious Shard S +Mysterious Shard L +Digger Drill +Kanto Slate +Johto Slate +Soul Slate +Rainbow Slate +Squall Slate +Oceanic Slate +Tectonic Slate +Stratospheric Slate +Genome Slate +Discovery Slate +Distortion Slate +DS Sounds + + + + + +Legend Plate \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/PLAClothingBottoms.txt b/SwitchGiftDataManager.Core/Resources/PLAClothingBottoms.txt new file mode 100644 index 0000000..c01575e --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/PLAClothingBottoms.txt @@ -0,0 +1,256 @@ +None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Fancy Bottoms (Oshawott) +Fancy Bottoms (Cyndaquil) +Fancy Bottoms (Rowlet) +Fancy Bottoms (Typhlosion) +Fancy Bottoms (Samurott) +Fancy Bottoms (Decidueye) +Fancy Bottoms (Gyarados) +Fancy Bottoms (Cherrim) +Fancy Bottoms (Seascape) +Fancy Bottoms (Mountainscape) +Fancy Bottoms (Townscape) +Fancy Bottoms (Spiritomb) +Fancy Bottoms (Honchkrow) +Fancy Bottoms (Garchomp) +Fancy Bottoms (Heatran) +Fancy Bottoms (Cresselia) +Fancy Bottoms (Darkrai) +Fancy Bottoms (Regigigas) +Fancy Bottoms (Shaymin) +Fancy Bottoms (Giratina) +Fancy Bottoms (Wyrdeer) +Fancy Bottoms (Kleavor) +Fancy Bottoms (Ursaluna) +Fancy Bottoms (Basculegion) +Fancy Bottoms (Growlithe) +Fancy Bottoms (Lilligant) +Fancy Bottoms (Electrode) +Fancy Bottoms (Sneasler) +Fancy Bottoms (Avalugg) +Fancy Bottoms (Braviary) +Fancy Bottoms (Pikachu) +Fancy Bottoms (Shinx) +Fancy Bottoms (Buneary) +Fancy Bottoms (Pachirisu) +Fancy Bottoms (Happiny) +Fancy Bottoms (Croagunk) +Fancy Bottoms (Goomy) +Fancy Bottoms (Bidoof) +Fancy Bottoms (Sneasel) +Fancy Bottoms (Mime Jr.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/SwitchGiftDataManager.Core/Resources/PLAClothingHeads.txt b/SwitchGiftDataManager.Core/Resources/PLAClothingHeads.txt new file mode 100644 index 0000000..e7e1eec --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/PLAClothingHeads.txt @@ -0,0 +1,256 @@ +None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Baneful Fox Mask (White lily) +Baneful Fox Mask (Shiny) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/SwitchGiftDataManager.Core/Resources/PLAClothingTops.txt b/SwitchGiftDataManager.Core/Resources/PLAClothingTops.txt new file mode 100644 index 0000000..b70956a --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/PLAClothingTops.txt @@ -0,0 +1,256 @@ +None + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Fancy Kimono (Oshawott) +Fancy Kimono (Cyndaquil) +Fancy Kimono (Rowlet) +Fancy Kimono (Typhlosion) +Fancy Kimono (Samurott) +Fancy Kimono (Decidueye) +Fancy Kimono (Gyarados) +Fancy Kimono (Cherrim) +Fancy Kimono (Seascape) +Fancy Kimono (Mountainscape) +Fancy Kimono (Townscape) +Fancy Kimono (Spiritomb) +Fancy Kimono (Honchkrow) +Fancy Kimono (Garchomp) +Fancy Kimono (Heatran) +Fancy Kimono (Cresselia) +Fancy Kimono (Darkrai) +Fancy Kimono (Regigigas) +Fancy Kimono (Shaymin) +Fancy Kimono (Giratina) +Fancy Kimono (Wyrdeer) +Fancy Kimono (Kleavor) +Fancy Kimono (Ursaluna) +Fancy Kimono (Basculegion) +Fancy Kimono (Growlithe) +Fancy Kimono (Lilligant) +Fancy Kimono (Electrode) +Fancy Kimono (Sneasler) +Fancy Kimono (Avalugg) +Fancy Kimono (Braviary) +Fancy Kimono (Pikachu) +Fancy Kimono (Shinx) +Fancy Kimono (Buneary) +Fancy Kimono (Pachirisu) +Fancy Kimono (Happiny) +Fancy Kimono (Croagunk) +Fancy Kimono (Goomy) +Fancy Kimono (Bidoof) +Fancy Kimono (Sneasel) +Fancy Kimono (Mime Jr.) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/SwitchGiftDataManager.Core/Resources/SWSHClothingBags.txt b/SwitchGiftDataManager.Core/Resources/SWSHClothingBags.txt new file mode 100644 index 0000000..2ee574a --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/SWSHClothingBags.txt @@ -0,0 +1,57 @@ +Sport Travel Bag (Iconic Style) +Sport Travel Bag (Challenger Kit) +Sport Travel Bag (Grass Type) +Sport Travel Bag (Water Type) +Sport Travel Bag (Fire Type) +Sport Travel Bag (Ghost Type) +Sport Travel Bag (Fighting Type) +Sport Travel Bag (Fairy Type) +Sport Travel Bag (Rock Type) +Sport Travel Bag (Ice Type) +Sport Travel Bag (Dark Type) +Sport Travel Bag (Dragon Type) +Sport Travel Bag (Bug Type) +Sport Travel Bag (Steel Type) +Sport Travel Bag (Psychic Type) +Sport Travel Bag (Electric Type) +Sport Travel Bag (Ground Type) +Sport Travel Bag (Flying Type) +Sport Travel Bag (Normal Type) +Sport Travel Bag (Poison Type) +Canvas Travel Bag (White) +Canvas Travel Bag (Navy) +Canvas Travel Bag (White/Black) +Canvas Travel Bag (White/Blue) +Canvas Travel Bag (White/Red) +Leather-Trimmed Bag (Brown) +Leather-Trimmed Bag (Sand) +Leather-Trimmed Bag (White) +Leather-Trimmed Bag (Maroon) +Leather-Trimmed Bag (White/Brown) +Leather-Trimmed Bag (White/Black) +Plaid Travel Bag (Cream/Green) +Plaid Travel Bag (Cream/Red) +Plaid Travel Bag (Cream/Monotone) +Plaid Travel Bag (Cream/Pink) +Plaid Travel Bag (Cream/Navy) +Plaid Travel Bag (Cream/Yellow) +Canvas Travel Bag (Leppa Laden) +Canvas Travel Bag (Ball Bonanza) +Canvas Travel Bag (Logo Lined) +Studded Leather Case (White) +Studded Leather Case (Black) +Studded Leather Case (Red) +Studded Leather Case (Caramel) +Studded Leather Case (Blue) +Studded Leather Case (Gold) +Studded Leather Case (Brilliant Black) +Studded Leather Case (Harsh Style) +Dojo Travel Bag (Original Style) +Luxury Travel Bag (Black/Red) +Luxury Travel Bag (Black/White) +Luxury Travel Bag (White/Red) +Luxury Travel Bag (White/Black) +Luxury Travel Bag (White) +Luxury Travel Bag (Black) +Expedition Travel Bag (Original Style) +Gold Travel Bag (Original Style) \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/SWSHClothingBottoms.txt b/SwitchGiftDataManager.Core/Resources/SWSHClothingBottoms.txt new file mode 100644 index 0000000..361efcd --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/SWSHClothingBottoms.txt @@ -0,0 +1,94 @@ +Sport Shorts (Challenger Kit) +Sport Shorts (Grass Type) +Sport Shorts (Water Type) +Sport Shorts (Fire Type) +Sport Shorts (Ghost Type) +Sport Shorts (Fighting Type) +Sport Shorts (Fairy Type) +Sport Shorts (Rock Type) +Sport Shorts (Ice Type) +Sport Shorts (Dark Type) +Sport Shorts (Dragon Type) +Sport Shorts (Bug Type) +Sport Shorts (Steel Type) +Sport Shorts (Psychic Type) +Sport Shorts (Electric Type) +Sport Shorts (Ground Type) +Sport Shorts (Flying Type) +Sport Shorts (Normal Type) +Sport Shorts (Poison Type) +Sport Shorts (Reigning Champion) +Sport Shorts (Pikachu Kit) +Sport Shorts (Eevee Kit) +Sport Shorts (Ranked Battles) +Sport Shorts (Battle Tower) +Trackie Bottoms (Iconic Style) +Trackie Bottoms (Challenger Kit) +Trackie Bottoms (Grass Type) +Trackie Bottoms (Water Type) +Trackie Bottoms (Fire Type) +Trackie Bottoms (Ghost Type) +Trackie Bottoms (Fighting Type) +Trackie Bottoms (Fairy Type) +Trackie Bottoms (Rock Type) +Trackie Bottoms (Ice Type) +Trackie Bottoms (Dark Type) +Trackie Bottoms (Dragon Type) +Trackie Bottoms (Bug Type) +Trackie Bottoms (Steel Type) +Trackie Bottoms (Psychic Type) +Trackie Bottoms (Electric Type) +Trackie Bottoms (Ground Type) +Trackie Bottoms (Flying Type) +Trackie Bottoms (Normal Type) +Trackie Bottoms (Poison Type) +Skinny Trousers (White) +Skinny Trousers (Black) +Skinny Trousers (Red) +Skinny Trousers (Yellow) +Skinny Trousers (Green) +Skinny Trousers (Blue) +Skinny Trousers (Orange) +Skinny Trousers (Navy) +Skinny Trousers (Purple) +Skinny Trousers (Pink) +Skinny Trousers (Gray) +Skinny Trousers (Tan) +Designer Denim (Light Blue) +Designer Denim (Blue) +Designer Denim (Navy) +Designer Denim (Black) +Designer Denim (Faded Black) +Plaid Trousers (Green) +Plaid Trousers (Red) +Plaid Trousers (Monotone) +Plaid Trousers (Pink) +Plaid Trousers (Navy) +Plaid Trousers (Yellow) +Leather Trousers (White) +Leather Trousers (Black) +Leather Trousers (Red) +Leather Trousers (Caramel) +Leather Trousers (Blue) +(?) ((?)) +(?) ((?)) +(?) ((?)) +Dojo Shorts (Original Style) +Punk Trousers (Faded Black) +Punk Trousers (Light Blue) +Punk Trousers (Red) +Dress Pants (White) +Dress Pants (Black) +Dress Pants (Red) +Dress Pants (Yellow) +Dress Pants (Green) +Dress Pants (Blue) +Dress Pants (Orange) +Dress Pants (Navy) +Dress Pants (Purple) +Dress Pants (Pink) +Dress Pants (Gray) +Dress Pants (Tan) +Expedition Pants (Original Style) +Gold Expedition Pants (Original Style) +Sport Shorts (Galarian Star Tournament) diff --git a/SwitchGiftDataManager.Core/Resources/SWSHClothingGlasses.txt b/SwitchGiftDataManager.Core/Resources/SWSHClothingGlasses.txt new file mode 100644 index 0000000..7af0b4a --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/SWSHClothingGlasses.txt @@ -0,0 +1,97 @@ +Sport Sunglasses (Iconic Style) +Sport Sunglasses (Challenger Kit) +Sport Sunglasses (Grass Type) +Sport Sunglasses (Water Type) +Sport Sunglasses (Fire Type) +Sport Sunglasses (Ghost Type) +Sport Sunglasses (Fighting Type) +Sport Sunglasses (Fairy Type) +Sport Sunglasses (Rock Type) +Sport Sunglasses (Ice Type) +Sport Sunglasses (Dark Type) +Sport Sunglasses (Dragon Type) +Sport Sunglasses (Bug Type) +Sport Sunglasses (Steel Type) +Sport Sunglasses (Psychic Type) +Sport Sunglasses (Electric Type) +Sport Sunglasses (Ground Type) +Sport Sunglasses (Flying Type) +Sport Sunglasses (Normal Type) +Sport Sunglasses (Poison Type) +Square Eyeglasses (White) +Square Eyeglasses (Black) +Square Eyeglasses (Red) +Square Eyeglasses (Yellow) +Square Eyeglasses (Green) +Square Eyeglasses (Blue) +Square Eyeglasses (Orange) +Square Eyeglasses (Navy) +Square Eyeglasses (Purple) +Square Eyeglasses (Pink) +Square Sunglasses (White/Black) +Square Sunglasses (Black/Black) +Square Sunglasses (Red/Black) +Square Sunglasses (Yellow/Black) +Square Sunglasses (Green/Black) +Square Sunglasses (Blue/Black) +Square Sunglasses (Orange/Black) +Square Sunglasses (Navy/Black) +Square Sunglasses (Purple/Black) +Square Sunglasses (Pink/Black) +Half-Rim Eyeglasses (Black) +Half-Rim Eyeglasses (Silver) +Half-Rim Eyeglasses (Gold) +Half-Rim Eyeglasses (Mottled) +Half-Rim Sunglasses (Black/Gray) +Half-Rim Sunglasses (Black/Blue) +Half-Rim Sunglasses (Black/Purple) +Half-Rim Sunglasses (Black/Pink) +Half-Rim Sunglasses (Black/Yellow) +Half-Rim Sunglasses (Black/Brown) +Half-Rim Sunglasses (Silver/Gray) +Half-Rim Sunglasses (Silver/Blue) +Half-Rim Sunglasses (Silver/Purple) +Half-Rim Sunglasses (Silver/Pink) +Half-Rim Sunglasses (Silver/Yellow) +Half-Rim Sunglasses (Silver/Brown) +Half-Rim Sunglasses (Gold/Gray) +Half-Rim Sunglasses (Gold/Blue) +Half-Rim Sunglasses (Gold/Purple) +Half-Rim Sunglasses (Gold/Pink) +Half-Rim Sunglasses (Gold/Yellow) +Half-Rim Sunglasses (Gold/Brown) +Half-Rim Sunglasses (Mottled/Gray) +Half-Rim Sunglasses (Mottled/Blue) +Half-Rim Sunglasses (Mottled/Purple) +Half-Rim Sunglasses (Mottled/Pink) +Half-Rim Sunglasses (Mottled/Yellow) +Half-Rim Sunglasses (Mottled/Brown) +Round Eyeglasses (Black) +Round Eyeglasses (Metal) +Round Eyeglasses (Mottled) +Round Sunglasses (Black/Yellow) +Round Sunglasses (Black/Blue) +Round Sunglasses (Black/Red) +Round Sunglasses (Black/Black) +Round Sunglasses (Metal/Yellow) +Round Sunglasses (Metal/Blue) +Round Sunglasses (Metal/Red) +Round Sunglasses (Metal/Black) +Round Sunglasses (Mottled/Yellow) +Round Sunglasses (Mottled/Blue) +Round Sunglasses (Mottled/Red) +Round Sunglasses (Mottled/Black) +Wraparound Sunglasses (White) +Wraparound Sunglasses (Black) +Wraparound Sunglasses (Mottled) +Wraparound Sunglasses (Red) +Wraparound Sunglasses (Green) +Wraparound Sunglasses (Blue) +Futuristic Shades (Red) +Futuristic Shades (Yellow) +Futuristic Shades (Blue) +Futuristic Shades (White) +Futuristic Monocle (Red) +Futuristic Monocle (Yellow) +Futuristic Monocle (Blue) +Futuristic Monocle (White) \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/SWSHClothingGloves.txt b/SwitchGiftDataManager.Core/Resources/SWSHClothingGloves.txt new file mode 100644 index 0000000..974e5ac --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/SWSHClothingGloves.txt @@ -0,0 +1,72 @@ +(empty) (Bare) +Sport Glove (Challenger Kit) +Sport Glove (Grass Type) +Sport Glove (Water Type) +Sport Glove (Fire Type) +Sport Glove (Ghost Type) +Sport Glove (Fighting Type) +Sport Glove (Fairy Type) +Sport Glove (Rock Type) +Sport Glove (Ice Type) +Sport Glove (Dark Type) +Sport Glove (Dragon Type) +Sport Glove (Bug Type) +Sport Glove (Steel Type) +Sport Glove (Psychic Type) +Sport Glove (Electric Type) +Sport Glove (Ground Type) +Sport Glove (Flying Type) +Sport Glove (Normal Type) +Sport Glove (Poison Type) +Sport Glove (Reigning Champion) +Sport Glove (Pikachu Kit) +Sport Glove (Eevee Kit) +Sport Glove (Ranked Battles) +Sport Glove (Battle Tower) +Sport Glove (Iconic Style) +Simple Gloves (White) +Simple Gloves (Black) +Simple Gloves (Red) +Simple Gloves (Yellow) +Simple Gloves (Green) +Simple Gloves (Blue) +Simple Gloves (Orange) +Simple Gloves (Navy) +Simple Gloves (Purple) +Simple Gloves (Pink) +Simple Gloves (Gray) +Simple Gloves (Tan) +Plaid Gloves (Green) +Plaid Gloves (Red) +Plaid Gloves (Monotone) +Plaid Gloves (Pink) +Plaid Gloves (Navy) +Plaid Gloves (Yellow) +Patterned Gloves (Eternal Sleep) +Patterned Gloves (Mischief Maker) +Patterned Gloves (Gullet Glam) +Leather Palm Glove (White) +Leather Palm Glove (Black) +Leather Palm Glove (Red) +Leather Palm Glove (Caramel) +Leather Palm Glove (Blue) +Leather Palm Glove (Splashy Pink) +Leather Palm Glove (Red Gas) +Leather Palm Glove (Fresh & Blue) +Dojo Gloves (Original Style) +Punk Gloves (Black) +Expedition Gloves (Original Style) +Gold Expedition Gloves (Original Style) +Formal Gloves (White) +Formal Gloves (Black) +Formal Gloves (Red) +Formal Gloves (Yellow) +Formal Gloves (Green) +Formal Gloves (Blue) +Formal Gloves (Orange) +Formal Gloves (Navy) +Formal Gloves (Purple) +Formal Gloves (Pink) +Formal Gloves (Gray) +Formal Gloves (Tan) +Sport Glove (Galarian Star Tournament) \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/SWSHClothingHats.txt b/SwitchGiftDataManager.Core/Resources/SWSHClothingHats.txt new file mode 100644 index 0000000..b52538d --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/SWSHClothingHats.txt @@ -0,0 +1,93 @@ +Sport Cap (Iconic Style) +Sport Cap (Challenger Kit) +Sport Cap (Grass Type) +Sport Cap (Water Type) +Sport Cap (Fire Type) +Sport Cap (Ghost Type) +Sport Cap (Fighting Type) +Sport Cap (Fairy Type) +Sport Cap (Rock Type) +Sport Cap (Ice Type) +Sport Cap (Dark Type) +Sport Cap (Dragon Type) +Sport Cap (Bug Type) +Sport Cap (Steel Type) +Sport Cap (Psychic Type) +Sport Cap (Electric Type) +Sport Cap (Ground Type) +Sport Cap (Flying Type) +Sport Cap (Normal Type) +Sport Cap (Poison Type) +Scally Cap (White) +Scally Cap (Black) +Scally Cap (Red) +Scally Cap (Yellow) +Scally Cap (Green) +Scally Cap (Blue) +Scally Cap (Orange) +Scally Cap (Navy) +Scally Cap (Purple) +Scally Cap (Pink) +Scally Cap (Gray) +Scally Cap (Tan) +Knit Cap (White) +Knit Cap (Black) +Knit Cap (Red) +Knit Cap (Yellow) +Knit Cap (Green) +Knit Cap (Blue) +Knit Cap (Orange) +Knit Cap (Navy) +Knit Cap (Purple) +Knit Cap (Pink) +Knit Cap (Gray) +Knit Cap (Tan) +Knit Beret (White) +Knit Beret (Black) +Knit Beret (Red) +Knit Beret (Yellow) +Knit Beret (Green) +Knit Beret (Blue) +Knit Beret (Orange) +Knit Beret (Navy) +Knit Beret (Purple) +Knit Beret (Pink) +Knit Beret (Gray) +Knit Beret (Tan) +Bucket Hat (White) +Bucket Hat (Black) +Bucket Hat (Red) +Bucket Hat (Yellow) +Bucket Hat (Green) +Bucket Hat (Blue) +Bucket Hat (Orange) +Bucket Hat (Navy) +Bucket Hat (Purple) +Bucket Hat (Pink) +Bucket Hat (Gray) +Bucket Hat (Tan) +Trapper Hat (White) +Trapper Hat (Black) +Trapper Hat (Red) +Trapper Hat (Yellow) +Trapper Hat (Green) +Trapper Hat (Blue) +Trapper Hat (Orange) +Trapper Hat (Navy) +Trapper Hat (Purple) +Trapper Hat (Pink) +Trapper Hat (Gray) +Trapper Hat (Tan) +Sport Cap (Leon's Look) +Sport Cap (Hex Nut) +Sport Cap (Stuff Cheeks) +Sport Cap (Dynamax) +Sport Cap (W x F x G) +Hard Hat (Original Style) +Gold Hard Hat (Original Style) +Bucket Hat (Green) +Bucket Hat (Blue) +Bucket Hat (Pink) +Replica State Crown (Original Style) +Replica Gold Crown (Original Style) +Partner Cap (Original Style) \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/SWSHClothingJackets.txt b/SwitchGiftDataManager.Core/Resources/SWSHClothingJackets.txt new file mode 100644 index 0000000..e667b0e --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/SWSHClothingJackets.txt @@ -0,0 +1,70 @@ +Tracksuit Jacket (Iconic Style) +Tracksuit Jacket (Challenger Kit) +Tracksuit Jacket (Grass Type) +Tracksuit Jacket (Water Type) +Tracksuit Jacket (Fire Type) +Tracksuit Jacket (Ghost Type) +Tracksuit Jacket (Fighting Type) +Tracksuit Jacket (Fairy Type) +Tracksuit Jacket (Rock Type) +Tracksuit Jacket (Ice Type) +Tracksuit Jacket (Dark Type) +Tracksuit Jacket (Dragon Type) +Tracksuit Jacket (Bug Type) +Tracksuit Jacket (Steel Type) +Tracksuit Jacket (Psychic Type) +Tracksuit Jacket (Electric Type) +Tracksuit Jacket (Ground Type) +Tracksuit Jacket (Flying Type) +Tracksuit Jacket (Normal Type) +Tracksuit Jacket (Poison Type) +Hoodie (White) +Hoodie (Black) +Hoodie (Red) +Hoodie (Yellow) +Hoodie (Green) +Hoodie (Blue) +Hoodie (Orange) +Hoodie (Navy) +Hoodie (Purple) +Hoodie (Pink) +Hoodie (Gray) +Hoodie (Tan) +Hoodie (Gray Greed) +Hoodie (The Champ) +Hoodie (Sunset City) +Satin Varsity Jacket (Bitter Rock) +Satin Varsity Jacket (Shocking Berry) +Varsity Jacket (Green) +Varsity Jacket (Red) +Varsity Jacket (Blue) +Zippered Parka (Lovely Nightmare) +Zippered Parka (Cute Clobbering) +Zippered Parka (Berry Forest) +Motorcycle Jacket (White) +Motorcycle Jacket (Black) +Motorcycle Jacket (Red) +Motorcycle Jacket (Caramel) +Motorcycle Jacket (Blue) +Punk Vest (Faded Black) +Punk Vest (Light Blue) +Punk Vest (Red) +Suit Jacket (White) +Suit Jacket (Black) +Suit Jacket (Red) +Suit Jacket (Yellow) +Suit Jacket (Green) +Suit Jacket (Blue) +Suit Jacket (Orange) +Suit Jacket (Navy) +Suit Jacket (Purple) +Suit Jacket (Pink) +Suit Jacket (Gray) +Suit Jacket (Tan) +Expedition Jacket (Original Style) +Gold Expedition Jacket (Original Style) +Dojo Jacket (Original Style) +Hoodie (W x F x G) +Hoodie (C x L) +Hoodie (Legendary R-D) +Hoodie (Legendary R-E) \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/SWSHClothingLegwear.txt b/SwitchGiftDataManager.Core/Resources/SWSHClothingLegwear.txt new file mode 100644 index 0000000..f155965 --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/SWSHClothingLegwear.txt @@ -0,0 +1,93 @@ +Sport Legwear (Challenger Kit) +Sport Legwear (Grass Type) +Sport Legwear (Water Type) +Sport Legwear (Fire Type) +Sport Legwear (Ghost Type) +Sport Legwear (Fighting Type) +Sport Legwear (Fairy Type) +Sport Legwear (Rock Type) +Sport Legwear (Ice Type) +Sport Legwear (Dark Type) +Sport Legwear (Dragon Type) +Sport Legwear (Bug Type) +Sport Legwear (Steel Type) +Sport Legwear (Psychic Type) +Sport Legwear (Electric Type) +Sport Legwear (Ground Type) +Sport Legwear (Flying Type) +Sport Legwear (Normal Type) +Sport Legwear (Poison Type) +Sport Legwear (Reigning Champion) +Sport Legwear (Pikachu Kit) +Sport Legwear (Eevee Kit) +Sport Legwear (Ranked Battles) +Sport Legwear (Battle Tower) +Sport Low Crew Socks (Iconic Style) +Sport High Socks (Iconic Style) +Sport Cropped Leggings (Iconic Style) +Sport Compression Tights (Iconic Style) +Trainer Socks (Black) +Low Crew Socks (White) +Low Crew Socks (Black) +Low Crew Socks (Red) +Low Crew Socks (Yellow) +Low Crew Socks (Green) +Low Crew Socks (Blue) +Low Crew Socks (Orange) +Low Crew Socks (Navy) +Low Crew Socks (Purple) +Low Crew Socks (Pink) +Low Crew Socks (Gray) +Low Crew Socks (Tan) +High Socks (White) +High Socks (Black) +High Socks (Red) +High Socks (Yellow) +High Socks (Green) +High Socks (Blue) +High Socks (Orange) +High Socks (Navy) +High Socks (Purple) +High Socks (Pink) +High Socks (Gray) +High Socks (Tan) +Cropped Leggings (White) +Cropped Leggings (Black) +Cropped Leggings (Red) +Cropped Leggings (Yellow) +Cropped Leggings (Green) +Cropped Leggings (Blue) +Cropped Leggings (Orange) +Cropped Leggings (Navy) +Cropped Leggings (Purple) +Cropped Leggings (Pink) +Cropped Leggings (Gray) +Cropped Leggings (Tan) +Compression Tights (White) +Compression Tights (Black) +Compression Tights (Red) +Compression Tights (Yellow) +Compression Tights (Green) +Compression Tights (Blue) +Compression Tights (Orange) +Compression Tights (Navy) +Compression Tights (Purple) +Compression Tights (Pink) +Compression Tights (Gray) +Compression Tights (Tan) +Plaid Socks (Green) +Plaid Socks (Red) +Plaid Socks (Monotone) +Plaid Socks (Pink) +Plaid Socks (Navy) +Plaid Socks (Yellow) +Patterned Leggings (Splashy Pink) +Patterned Leggings (Red Gas) +Patterned Leggings (Fresh & Blue) +Patterned Leggings (Serious Stripes) +(?) (Bare) +Dojo Legwear (Original Style) +Patterned Tights (Leon's Look) +Patterned Tights (W x F x G) +Patterned Tights (C x L) +Sport Legwear (Galarian Star Tournament) \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/SWSHClothingShoes.txt b/SwitchGiftDataManager.Core/Resources/SWSHClothingShoes.txt new file mode 100644 index 0000000..1e90212 --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/SWSHClothingShoes.txt @@ -0,0 +1,71 @@ +Sport High-Tops (Challenger Kit) +Sport High-Tops (Grass Type) +Sport High-Tops (Water Type) +Sport High-Tops (Fire Type) +Sport High-Tops (Ghost Type) +Sport High-Tops (Fighting Type) +Sport High-Tops (Fairy Type) +Sport High-Tops (Rock Type) +Sport High-Tops (Ice Type) +Sport High-Tops (Dark Type) +Sport High-Tops (Dragon Type) +Sport High-Tops (Bug Type) +Sport High-Tops (Steel Type) +Sport High-Tops (Psychic Type) +Sport High-Tops (Electric Type) +Sport High-Tops (Ground Type) +Sport High-Tops (Flying Type) +Sport High-Tops (Normal Type) +Sport High-Tops (Poison Type) +Sport High-Tops (Pikachu Kit) +Sport High-Tops (Eevee Kit) +Loafers (Brown) +Loafers (Sand) +Loafers (Black) +Loafers (White) +Loafers (White/Red) +Loafers (Punk Star) +Loafers (Barrier Tiles) +Loafers (Trendy Tread) +Chukka Boots (Brown) +Chukka Boots (Sand) +Chukka Boots (Black) +Casual Trainers (White) +Casual Trainers (Black) +Casual Trainers (Red) +Casual Trainers (Yellow) +Casual Trainers (Green) +Casual Trainers (Blue) +Casual Trainers (Orange) +Casual Trainers (Navy) +Casual Trainers (Purple) +Casual Trainers (Pink) +Casual Trainers (Gray) +Casual Trainers (Tan) +Casual Trainers (Ball Bonanza) +Casual Trainers (Lovely Nightmare) +Casual Trainers (Logo Lined) +Casual Trainers (Leppa Laden) +Casual Trainers (Berry Forest) +Creepers (White) +Creepers (Black) +Creepers (Tan) +Creepers (Splashy Pink) +Creepers (Red Gas) +Creepers (Fresh & Blue) +(?) ((?)) +(?) ((?)) +(?) ((?)) +Dojo Shoes (Original Style) +Punk Boots (Pink) +Punk Boots (Blue) +Punk Boots (Yellow) +Luxury Loafers (Black/Red) +Luxury Loafers (Black/White) +Luxury Loafers (White/Red) +Luxury Loafers (White/Black) +Luxury Loafers (White) +Luxury Loafers (Black) +Hiking Boots (Original Style) +Gold Hiking Boots (Original Style) +(?) (?) \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/SWSHClothingTops.txt b/SwitchGiftDataManager.Core/Resources/SWSHClothingTops.txt new file mode 100644 index 0000000..2acb65b --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/SWSHClothingTops.txt @@ -0,0 +1,146 @@ +Sport Top (Challenger Kit) +Sport Top (Grass Type) +Sport Top (Water Type) +Sport Top (Fire Type) +Sport Top (Ghost Type) +Sport Top (Fighting Type) +Sport Top (Fairy Type) +Sport Top (Rock Type) +Sport Top (Ice Type) +Sport Top (Dark Type) +Sport Top (Dragon Type) +Sport Top (Bug Type) +Sport Top (Steel Type) +Sport Top (Psychic Type) +Sport Top (Electric Type) +Sport Top (Ground Type) +Sport Top (Flying Type) +Sport Top (Normal Type) +Sport Top (Poison Type) +Sport Top (Reigning Champion) +Sport Top (Pikachu Kit) +Sport Top (Eevee Kit) +Sport Top (Ranked Battles) +Sport Top (Battle Tower) +Sport Sweatshirt (Iconic Style) +Loose Top (White) +Loose Top (Black) +Loose Top (Red) +Loose Top (Yellow) +Loose Top (Green) +Loose Top (Blue) +Loose Top (Orange) +Loose Top (Navy) +Loose Top (Purple) +Loose Top (Pink) +Loose Top (Gray) +Loose Top (Tan) +Loose Top (Poliwag Pop) +Loose Top (Luxury Holiday) +Loose Top (Sea Urchin) +Striped Top (White) +Striped Top (Black) +Striped Top (Red) +Striped Top (Yellow) +Striped Top (Green) +Striped Top (Blue) +Striped Top (Orange) +Striped Top (Navy) +Striped Top (Purple) +Striped Top (Pink) +Striped Top (Gray) +Striped Top (Tan) +Three-Fourths Sleeve Polo (White) +Three-Fourths Sleeve Polo (Black) +Three-Fourths Sleeve Polo (Red) +Three-Fourths Sleeve Polo (Yellow) +Three-Fourths Sleeve Polo (Green) +Three-Fourths Sleeve Polo (Blue) +Three-Fourths Sleeve Polo (Orange) +Three-Fourths Sleeve Polo (Navy) +Three-Fourths Sleeve Polo (Purple) +Three-Fourths Sleeve Polo (Pink) +Three-Fourths Sleeve Polo (Gray) +Three-Fourths Sleeve Polo (Tan) +Faded Sweatshirt (White) +Faded Sweatshirt (Black) +Faded Sweatshirt (Red) +Faded Sweatshirt (Yellow) +Faded Sweatshirt (Green) +Faded Sweatshirt (Blue) +Faded Sweatshirt (Orange) +Faded Sweatshirt (Navy) +Faded Sweatshirt (Purple) +Faded Sweatshirt (Pink) +Faded Sweatshirt (Gray) +Faded Sweatshirt (Tan) +Boatneck Sweatshirt (Eternal Sleep) +Boatneck Sweatshirt (Mischief Maker) +Boatneck Sweatshirt (Gullet Glam) +Torn Top (White) +Torn Top (Black) +Torn Top (Nasty Plot) +Torn Top (Astonished Eevee) +Torn Top (Pikachu Payback) +Torn Top (Night Shade) +Torn Top (Scary Face) +Three-Fourths Sleeve Button-Front Top (White) +Three-Fourths Sleeve Button-Front Top (Black) +Three-Fourths Sleeve Button-Front Top (Maroon) +Three-Fourths Sleeve Button-Front Top (Candy Stripe) +Three-Fourths Sleeve Button-Front Top (Paisley Pattern) +Casual Tee (Chosen Design) +Casual Tee (Nasty Plot) +Casual Tee (Astonished Eevee) +Casual Tee (Pikachu Payback) +Casual Tee (Night Shade) +Casual Tee (Scary Face) +Casual Tee (Arcanine Art) +Casual Tee (Urban Smog) +Casual Tee (Camp Curry) +Casual Tee (Dynamax Band) +Casual Tee (Poke Ball Guy) +Casual Tee (Great Ball Guy) +Casual Tee (Ultra Ball Guy) +Casual Tee (Tumblecube Cute) +(?) ((Face Mannequin)) +Dojo Tee (Original Style) +Casual Tee (#7) +Casual Tee (#8) +Casual Tee (#9) +Casual Tee (Festive Feldlands) +Casual Tee (Middelands March) +Casual Tee (Auldlands Amble) +Casual Tee (Ramblin' Rondelands) +Casual Tee (Penguin) +Casual Tee (Cream) +Casual Tee (W x F x G) +Casual Tee (Klara 4-ever) +Casual Tee (Avery 4-ever) +Casual Tee (Great Wave, Greater Dragon) +Casual Tee (The Masterly Mustard) +Vest and Tie Ensemble (White) +Vest and Tie Ensemble (Black) +Vest and Tie Ensemble (Red) +Vest and Tie Ensemble (Yellow) +Vest and Tie Ensemble (Green) +Vest and Tie Ensemble (Blue) +Vest and Tie Ensemble (Orange) +Vest and Tie Ensemble (Navy) +Vest and Tie Ensemble (Purple) +Vest and Tie Ensemble (Pink) +Vest and Tie Ensemble (Gray) +Vest and Tie Ensemble (Tan) +Boatneck Sweatshirt (Poke) +Boatneck Sweatshirt (Bro) +Boatneck Sweatshirt (King) +Boatneck Sweatshirt (Freezington's Fame) +Knit Sweater (Tapping Feet) +Knit Sweater (Rad Applin) +Knit Sweater (Peaceful Pastures) +Cable-Knit Sweater (White) +Cable-Knit Sweater (Black) +Cable-Knit Sweater (Gray) +Cable-Knit Sweater (Maroon) +Cable-Knit Sweater (Navy) +Sport Top (Galarian Star Tournament) \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/Species.txt b/SwitchGiftDataManager.Core/Resources/Species.txt new file mode 100644 index 0000000..45be4a2 --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/Species.txt @@ -0,0 +1,906 @@ +None, +Bulbasaur, +Ivysaur, +Venusaur, +Charmander, +Charmeleon, +Charizard, +Squirtle, +Wartortle, +Blastoise, +Caterpie, +Metapod, +Butterfree, +Weedle, +Kakuna, +Beedrill, +Pidgey, +Pidgeotto, +Pidgeot, +Rattata, +Raticate, +Spearow, +Fearow, +Ekans, +Arbok, +Pikachu, +Raichu, +Sandshrew, +Sandslash, +NidoranF, +Nidorina, +Nidoqueen, +NidoranM, +Nidorino, +Nidoking, +Clefairy, +Clefable, +Vulpix, +Ninetales, +Jigglypuff, +Wigglytuff, +Zubat, +Golbat, +Oddish, +Gloom, +Vileplume, +Paras, +Parasect, +Venonat, +Venomoth, +Diglett, +Dugtrio, +Meowth, +Persian, +Psyduck, +Golduck, +Mankey, +Primeape, +Growlithe, +Arcanine, +Poliwag, +Poliwhirl, +Poliwrath, +Abra, +Kadabra, +Alakazam, +Machop, +Machoke, +Machamp, +Bellsprout, +Weepinbell, +Victreebel, +Tentacool, +Tentacruel, +Geodude, +Graveler, +Golem, +Ponyta, +Rapidash, +Slowpoke, +Slowbro, +Magnemite, +Magneton, +Farfetchd, +Doduo, +Dodrio, +Seel, +Dewgong, +Grimer, +Muk, +Shellder, +Cloyster, +Gastly, +Haunter, +Gengar, +Onix, +Drowzee, +Hypno, +Krabby, +Kingler, +Voltorb, +Electrode, +Exeggcute, +Exeggutor, +Cubone, +Marowak, +Hitmonlee, +Hitmonchan, +Lickitung, +Koffing, +Weezing, +Rhyhorn, +Rhydon, +Chansey, +Tangela, +Kangaskhan, +Horsea, +Seadra, +Goldeen, +Seaking, +Staryu, +Starmie, +MrMime, +Scyther, +Jynx, +Electabuzz, +Magmar, +Pinsir, +Tauros, +Magikarp, +Gyarados, +Lapras, +Ditto, +Eevee, +Vaporeon, +Jolteon, +Flareon, +Porygon, +Omanyte, +Omastar, +Kabuto, +Kabutops, +Aerodactyl, +Snorlax, +Articuno, +Zapdos, +Moltres, +Dratini, +Dragonair, +Dragonite, +Mewtwo, +Mew, +Chikorita, +Bayleef, +Meganium, +Cyndaquil, +Quilava, +Typhlosion, +Totodile, +Croconaw, +Feraligatr, +Sentret, +Furret, +Hoothoot, +Noctowl, +Ledyba, +Ledian, +Spinarak, +Ariados, +Crobat, +Chinchou, +Lanturn, +Pichu, +Cleffa, +Igglybuff, +Togepi, +Togetic, +Natu, +Xatu, +Mareep, +Flaaffy, +Ampharos, +Bellossom, +Marill, +Azumarill, +Sudowoodo, +Politoed, +Hoppip, +Skiploom, +Jumpluff, +Aipom, +Sunkern, +Sunflora, +Yanma, +Wooper, +Quagsire, +Espeon, +Umbreon, +Murkrow, +Slowking, +Misdreavus, +Unown, +Wobbuffet, +Girafarig, +Pineco, +Forretress, +Dunsparce, +Gligar, +Steelix, +Snubbull, +Granbull, +Qwilfish, +Scizor, +Shuckle, +Heracross, +Sneasel, +Teddiursa, +Ursaring, +Slugma, +Magcargo, +Swinub, +Piloswine, +Corsola, +Remoraid, +Octillery, +Delibird, +Mantine, +Skarmory, +Houndour, +Houndoom, +Kingdra, +Phanpy, +Donphan, +Porygon2, +Stantler, +Smeargle, +Tyrogue, +Hitmontop, +Smoochum, +Elekid, +Magby, +Miltank, +Blissey, +Raikou, +Entei, +Suicune, +Larvitar, +Pupitar, +Tyranitar, +Lugia, +HoOh, +Celebi, +Treecko, +Grovyle, +Sceptile, +Torchic, +Combusken, +Blaziken, +Mudkip, +Marshtomp, +Swampert, +Poochyena, +Mightyena, +Zigzagoon, +Linoone, +Wurmple, +Silcoon, +Beautifly, +Cascoon, +Dustox, +Lotad, +Lombre, +Ludicolo, +Seedot, +Nuzleaf, +Shiftry, +Taillow, +Swellow, +Wingull, +Pelipper, +Ralts, +Kirlia, +Gardevoir, +Surskit, +Masquerain, +Shroomish, +Breloom, +Slakoth, +Vigoroth, +Slaking, +Nincada, +Ninjask, +Shedinja, +Whismur, +Loudred, +Exploud, +Makuhita, +Hariyama, +Azurill, +Nosepass, +Skitty, +Delcatty, +Sableye, +Mawile, +Aron, +Lairon, +Aggron, +Meditite, +Medicham, +Electrike, +Manectric, +Plusle, +Minun, +Volbeat, +Illumise, +Roselia, +Gulpin, +Swalot, +Carvanha, +Sharpedo, +Wailmer, +Wailord, +Numel, +Camerupt, +Torkoal, +Spoink, +Grumpig, +Spinda, +Trapinch, +Vibrava, +Flygon, +Cacnea, +Cacturne, +Swablu, +Altaria, +Zangoose, +Seviper, +Lunatone, +Solrock, +Barboach, +Whiscash, +Corphish, +Crawdaunt, +Baltoy, +Claydol, +Lileep, +Cradily, +Anorith, +Armaldo, +Feebas, +Milotic, +Castform, +Kecleon, +Shuppet, +Banette, +Duskull, +Dusclops, +Tropius, +Chimecho, +Absol, +Wynaut, +Snorunt, +Glalie, +Spheal, +Sealeo, +Walrein, +Clamperl, +Huntail, +Gorebyss, +Relicanth, +Luvdisc, +Bagon, +Shelgon, +Salamence, +Beldum, +Metang, +Metagross, +Regirock, +Regice, +Registeel, +Latias, +Latios, +Kyogre, +Groudon, +Rayquaza, +Jirachi, +Deoxys, +Turtwig, +Grotle, +Torterra, +Chimchar, +Monferno, +Infernape, +Piplup, +Prinplup, +Empoleon, +Starly, +Staravia, +Staraptor, +Bidoof, +Bibarel, +Kricketot, +Kricketune, +Shinx, +Luxio, +Luxray, +Budew, +Roserade, +Cranidos, +Rampardos, +Shieldon, +Bastiodon, +Burmy, +Wormadam, +Mothim, +Combee, +Vespiquen, +Pachirisu, +Buizel, +Floatzel, +Cherubi, +Cherrim, +Shellos, +Gastrodon, +Ambipom, +Drifloon, +Drifblim, +Buneary, +Lopunny, +Mismagius, +Honchkrow, +Glameow, +Purugly, +Chingling, +Stunky, +Skuntank, +Bronzor, +Bronzong, +Bonsly, +MimeJr, +Happiny, +Chatot, +Spiritomb, +Gible, +Gabite, +Garchomp, +Munchlax, +Riolu, +Lucario, +Hippopotas, +Hippowdon, +Skorupi, +Drapion, +Croagunk, +Toxicroak, +Carnivine, +Finneon, +Lumineon, +Mantyke, +Snover, +Abomasnow, +Weavile, +Magnezone, +Lickilicky, +Rhyperior, +Tangrowth, +Electivire, +Magmortar, +Togekiss, +Yanmega, +Leafeon, +Glaceon, +Gliscor, +Mamoswine, +PorygonZ, +Gallade, +Probopass, +Dusknoir, +Froslass, +Rotom, +Uxie, +Mesprit, +Azelf, +Dialga, +Palkia, +Heatran, +Regigigas, +Giratina, +Cresselia, +Phione, +Manaphy, +Darkrai, +Shaymin, +Arceus, +Victini, +Snivy, +Servine, +Serperior, +Tepig, +Pignite, +Emboar, +Oshawott, +Dewott, +Samurott, +Patrat, +Watchog, +Lillipup, +Herdier, +Stoutland, +Purrloin, +Liepard, +Pansage, +Simisage, +Pansear, +Simisear, +Panpour, +Simipour, +Munna, +Musharna, +Pidove, +Tranquill, +Unfezant, +Blitzle, +Zebstrika, +Roggenrola, +Boldore, +Gigalith, +Woobat, +Swoobat, +Drilbur, +Excadrill, +Audino, +Timburr, +Gurdurr, +Conkeldurr, +Tympole, +Palpitoad, +Seismitoad, +Throh, +Sawk, +Sewaddle, +Swadloon, +Leavanny, +Venipede, +Whirlipede, +Scolipede, +Cottonee, +Whimsicott, +Petilil, +Lilligant, +Basculin, +Sandile, +Krokorok, +Krookodile, +Darumaka, +Darmanitan, +Maractus, +Dwebble, +Crustle, +Scraggy, +Scrafty, +Sigilyph, +Yamask, +Cofagrigus, +Tirtouga, +Carracosta, +Archen, +Archeops, +Trubbish, +Garbodor, +Zorua, +Zoroark, +Minccino, +Cinccino, +Gothita, +Gothorita, +Gothitelle, +Solosis, +Duosion, +Reuniclus, +Ducklett, +Swanna, +Vanillite, +Vanillish, +Vanilluxe, +Deerling, +Sawsbuck, +Emolga, +Karrablast, +Escavalier, +Foongus, +Amoonguss, +Frillish, +Jellicent, +Alomomola, +Joltik, +Galvantula, +Ferroseed, +Ferrothorn, +Klink, +Klang, +Klinklang, +Tynamo, +Eelektrik, +Eelektross, +Elgyem, +Beheeyem, +Litwick, +Lampent, +Chandelure, +Axew, +Fraxure, +Haxorus, +Cubchoo, +Beartic, +Cryogonal, +Shelmet, +Accelgor, +Stunfisk, +Mienfoo, +Mienshao, +Druddigon, +Golett, +Golurk, +Pawniard, +Bisharp, +Bouffalant, +Rufflet, +Braviary, +Vullaby, +Mandibuzz, +Heatmor, +Durant, +Deino, +Zweilous, +Hydreigon, +Larvesta, +Volcarona, +Cobalion, +Terrakion, +Virizion, +Tornadus, +Thundurus, +Reshiram, +Zekrom, +Landorus, +Kyurem, +Keldeo, +Meloetta, +Genesect, +Chespin, +Quilladin, +Chesnaught, +Fennekin, +Braixen, +Delphox, +Froakie, +Frogadier, +Greninja, +Bunnelby, +Diggersby, +Fletchling, +Fletchinder, +Talonflame, +Scatterbug, +Spewpa, +Vivillon, +Litleo, +Pyroar, +Flabébé, +Floette, +Florges, +Skiddo, +Gogoat, +Pancham, +Pangoro, +Furfrou, +Espurr, +Meowstic, +Honedge, +Doublade, +Aegislash, +Spritzee, +Aromatisse, +Swirlix, +Slurpuff, +Inkay, +Malamar, +Binacle, +Barbaracle, +Skrelp, +Dragalge, +Clauncher, +Clawitzer, +Helioptile, +Heliolisk, +Tyrunt, +Tyrantrum, +Amaura, +Aurorus, +Sylveon, +Hawlucha, +Dedenne, +Carbink, +Goomy, +Sliggoo, +Goodra, +Klefki, +Phantump, +Trevenant, +Pumpkaboo, +Gourgeist, +Bergmite, +Avalugg, +Noibat, +Noivern, +Xerneas, +Yveltal, +Zygarde, +Diancie, +Hoopa, +Volcanion, +Rowlet, +Dartrix, +Decidueye, +Litten, +Torracat, +Incineroar, +Popplio, +Brionne, +Primarina, +Pikipek, +Trumbeak, +Toucannon, +Yungoos, +Gumshoos, +Grubbin, +Charjabug, +Vikavolt, +Crabrawler, +Crabominable, +Oricorio, +Cutiefly, +Ribombee, +Rockruff, +Lycanroc, +Wishiwashi, +Mareanie, +Toxapex, +Mudbray, +Mudsdale, +Dewpider, +Araquanid, +Fomantis, +Lurantis, +Morelull, +Shiinotic, +Salandit, +Salazzle, +Stufful, +Bewear, +Bounsweet, +Steenee, +Tsareena, +Comfey, +Oranguru, +Passimian, +Wimpod, +Golisopod, +Sandygast, +Palossand, +Pyukumuku, +TypeNull, +Silvally, +Minior, +Komala, +Turtonator, +Togedemaru, +Mimikyu, +Bruxish, +Drampa, +Dhelmise, +Jangmoo, +Hakamoo, +Kommoo, +TapuKoko, +TapuLele, +TapuBulu, +TapuFini, +Cosmog, +Cosmoem, +Solgaleo, +Lunala, +Nihilego, +Buzzwole, +Pheromosa, +Xurkitree, +Celesteela, +Kartana, +Guzzlord, +Necrozma, +Magearna, +Marshadow, +Poipole, +Naganadel, +Stakataka, +Blacephalon, +Zeraora, +Meltan, +Melmetal, +Grookey, +Thwackey, +Rillaboom, +Scorbunny, +Raboot, +Cinderace, +Sobble, +Drizzile, +Inteleon, +Skwovet, +Greedent, +Rookidee, +Corvisquire, +Corviknight, +Blipbug, +Dottler, +Orbeetle, +Nickit, +Thievul, +Gossifleur, +Eldegoss, +Wooloo, +Dubwool, +Chewtle, +Drednaw, +Yamper, +Boltund, +Rolycoly, +Carkol, +Coalossal, +Applin, +Flapple, +Appletun, +Silicobra, +Sandaconda, +Cramorant, +Arrokuda, +Barraskewda, +Toxel, +Toxtricity, +Sizzlipede, +Centiskorch, +Clobbopus, +Grapploct, +Sinistea, +Polteageist, +Hatenna, +Hattrem, +Hatterene, +Impidimp, +Morgrem, +Grimmsnarl, +Obstagoon, +Perrserker, +Cursola, +Sirfetchd, +MrRime, +Runerigus, +Milcery, +Alcremie, +Falinks, +Pincurchin, +Snom, +Frosmoth, +Stonjourner, +Eiscue, +Indeedee, +Morpeko, +Cufant, +Copperajah, +Dracozolt, +Arctozolt, +Dracovish, +Arctovish, +Duraludon, +Dreepy, +Drakloak, +Dragapult, +Zacian, +Zamazenta, +Eternatus, +Kubfu, +Urshifu, +Zarude, +Regieleki, +Regidrago, +Glastrier, +Spectrier, +Calyrex, +Wyrdeer, +Kleavor, +Ursaluna, +Basculegion, +Sneasler, +Overqwil, +Enamorus, \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/Resources/UndergroundItems.txt b/SwitchGiftDataManager.Core/Resources/UndergroundItems.txt new file mode 100644 index 0000000..e132562 --- /dev/null +++ b/SwitchGiftDataManager.Core/Resources/UndergroundItems.txt @@ -0,0 +1,940 @@ +None +Red Sphere S +Blue Sphere S +Green Sphere S +Prism Sphere S +Pale Sphere S +Red Sphere L +Blue Sphere L +Green Sphere L +Prism Sphere L +Pale Sphere L +Revive +Max Revive +Red Shard +Blue Shard +Yellow Shard +Green Shard +Sun Stone +Moon Stone +Fire Stone +Thunder Stone +Water Stone +Leaf Stone +Oval Stone +Everstone +Odd Keystone +Star Piece +Heart Scale +Root Fossil +Claw Fossil +Helix Fossil +Dome Fossil +Old Amber +Armor Fossil +Skull Fossil +Rare Bone +Light Clay +Iron Ball +Icy Rock +Smooth Rock +Heat Rock +Damp Rock +Mysterious Shard S +Mysterious Shard L +Hard Stone +Flame Plate +Splash Plate +Zap Plate +Meadow Plate +Icicle Plate +Fist Plate +Toxic Plate +Earth Plate +Sky Plate +Mind Plate +Insect Plate +Stone Plate +Spooky Plate +Draco Plate +Dread Plate +Iron Plate +Pixie Plate + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Square Pedestal XS +Square Pedestal S +Square Pedestal M +Square Pedestal L +Round Pedestal XS +Round Pedestal M +Round Pedestal L +Sturdy Pedestal XS +Sturdy Pedestal S +Sturdy Pedestal M +Sturdy Pedestal L +Clear Pedestal XS +Clear Pedestal S +Clear Pedestal M +Clear Pedestal L +Dawn Pedestal L +Dawn Pedestal XL +Night Pedestal L +Night Pedestal XL +Diamond Pedestal L +Diamond Pedestal XL +Pearl Pedestal L +Pearl Pedestal XL +Spin Pedestal XS +Spin Pedestal M +Spin Pedestal L +Spinback Pedestal XS +Spinback Pedestal M +Spinback Pedestal L +Digger Drill +TM01 +TM02 +TM03 +TM04 +TM05 +TM06 +TM07 +TM08 +TM09 +TM10 +TM11 +TM12 +TM13 +TM14 +TM15 +TM16 +TM17 +TM18 +TM19 +TM20 +TM21 +TM22 +TM23 +TM24 +TM25 +TM26 +TM27 +TM28 +TM29 +TM30 +TM31 +TM32 +TM33 +TM34 +TM35 +TM36 +TM37 +TM38 +TM39 +TM40 +TM41 +TM42 +TM43 +TM44 +TM45 +TM46 +TM47 +TM48 +TM49 +TM50 +TM51 +TM52 +TM53 +TM54 +TM55 +TM56 +TM57 +TM58 +TM59 +TM60 +TM61 +TM62 +TM63 +TM64 +TM65 +TM66 +TM67 +TM68 +TM69 +TM70 +TM71 +TM72 +TM73 +TM74 +TM75 +TM76 +TM77 +TM78 +TM79 +TM80 +TM81 +TM82 +TM83 +TM84 +TM85 +TM86 +TM87 +TM88 +TM89 +TM90 +TM91 +TM92 +Bulbasaur Statue +Ivysaur Statue +Venusaur Statue +Charmander Statue +Charmeleon Statue +Charizard Statue +Squirtle Statue +Wartortle Statue +Blastoise Statue +Pikachu Statue +Nidoqueen Statue +Nidoking Statue +Clefairy Statue +Vulpix Statue +Jigglypuff Statue +Oddish Statue +Meowth Statue +Psyduck Statue +Arcanine Statue +Poliwrath Statue +Alakazam Statue +Machamp Statue +Tentacruel Statue +Geodude Statue +Rapidash Statue +Slowpoke Statue +Farfetch’d Statue +Gengar Statue +Cubone Statue +Lickitung Statue +Weezing Statue +Chansey Statue +Kangaskhan Statue +Seaking Statue +Mr. Mime Statue +Tauros Statue +Magikarp Statue +Gyarados Statue +Lapras Statue +Ditto Statue +Eevee Statue +Vaporeon Statue +Jolteon Statue +Flareon Statue +Porygon Statue +Omastar Statue +Snorlax Statue +Dragonite Statue +Chikorita Statue +Bayleef Statue +Meganium Statue +Cyndaquil Statue +Quilava Statue +Typhlosion Statue +Totodile Statue +Croconaw Statue +Feraligatr Statue +Furret Statue +Noctowl Statue +Crobat Statue +Togepi Statue +Ampharos Statue +Bellossom Statue +Marill Statue +Sudowoodo Statue +Aipom Statue +Sunkern Statue +Quagsire Statue +Espeon Statue +Umbreon Statue +Murkrow Statue +Unown Statue +Wobbuffet Statue +Girafarig Statue +Dunsparce Statue +Steelix Statue +Snubbull Statue +Scizor Statue +Heracross Statue +Magcargo Statue +Octillery Statue +Mantine Statue +Smeargle Statue +Miltank Statue +Tyranitar Statue +Treecko Statue +Grovyle Statue +Sceptile Statue +Torchic Statue +Combusken Statue +Blaziken Statue +Mudkip Statue +Marshtomp Statue +Swampert Statue +Beautifly Statue +Dustox Statue +Ludicolo Statue +Pelipper Statue +Gardevoir Statue +Shroomish Statue +Slaking Statue +Ninjask Statue +Exploud Statue +Skitty Statue +Sableye Statue +Mawile Statue +Aggron Statue +Medicham Statue +Manectric Statue +Plusle Statue +Minun Statue +Volbeat Statue +Illumise Statue +Roselia Statue +Sharpedo Statue +Wailmer Statue +Camerupt Statue +Torkoal Statue +Spinda Statue +Flygon Statue +Cacturne Statue +Altaria Statue +Zangoose Statue +Seviper Statue +Lunatone Statue +Solrock Statue +Whiscash Statue +Claydol Statue +Cradily Statue +Milotic Statue +Castform Statue +Kecleon Statue +Tropius Statue +Chimecho Statue +Absol Statue +Spheal Statue +Clamperl Statue +Relicanth Statue +Luvdisc Statue +Salamence Statue +Metagross Statue +Turtwig Statue +Grotle Statue +Torterra Statue +Chimchar Statue +Monferno Statue +Infernape Statue +Piplup Statue +Prinplup Statue +Empoleon Statue +Staraptor Statue +Bibarel Statue +Kricketot Statue +Luxray Statue +Budew Statue +Roserade Statue +Cranidos Statue +Bastiodon Statue +Burmy Statue +Wormadam Statue +Mothim Statue +Vespiquen Statue +Pachirisu Statue +Floatzel Statue +Cherubi Statue +Gastrodon Statue +Ambipom Statue +Drifloon Statue +Buneary Statue +Mismagius Statue +Honchkrow Statue +Purugly Statue +Skuntank Statue +Bronzong Statue +Happiny Statue +Chatot Statue +Spiritomb Statue +Garchomp Statue +Lucario Statue +Hippowdon Statue +Drapion Statue +Croagunk Statue +Carnivine Statue +Lumineon Statue +Abomasnow Statue +Weavile Statue +Magnezone Statue +Rhyperior Statue +Tangrowth Statue +Electivire Statue +Magmortar Statue +Togekiss Statue +Yanmega Statue +Leafeon Statue +Glaceon Statue +Gliscor Statue +Mamoswine Statue +Porygon-Z Statue +Gallade Statue +Probopass Statue +Dusknoir Statue +Froslass Statue +Rotom Statue +Rotom Statue +Rotom Statue +Rotom Statue +Rotom Statue +Rotom Statue +Articuno Statue +Zapdos Statue +Moltres Statue +Mewtwo Statue +Raikou Statue +Entei Statue +Suicune Statue +Lugia Statue +Ho-Oh Statue +Regirock Statue +Regice Statue +Registeel Statue +Latias Statue +Latios Statue +Kyogre Statue +Groudon Statue +Rayquaza Statue +Bulbasaur Statue  +Ivysaur Statue  +Venusaur Statue  +Charmander Statue  +Charmeleon Statue  +Charizard Statue  +Squirtle Statue  +Wartortle Statue  +Blastoise Statue  +Pikachu Statue  +Nidoqueen Statue  +Nidoking Statue  +Clefairy Statue  +Vulpix Statue  +Jigglypuff Statue  +Oddish Statue  +Meowth Statue  +Psyduck Statue  +Arcanine Statue  +Poliwrath Statue  +Alakazam Statue  +Machamp Statue  +Tentacruel Statue  +Geodude Statue  +Rapidash Statue  +Slowpoke Statue  +Farfetch’d Statue  +Gengar Statue  +Cubone Statue  +Lickitung Statue  +Weezing Statue  +Chansey Statue  +Kangaskhan Statue  +Seaking Statue  +Mr. Mime Statue  +Tauros Statue  +Magikarp Statue  +Gyarados Statue  +Lapras Statue  +Ditto Statue  +Eevee Statue  +Vaporeon Statue  +Jolteon Statue  +Flareon Statue  +Porygon Statue  +Omastar Statue  +Snorlax Statue  +Dragonite Statue  +Chikorita Statue  +Bayleef Statue  +Meganium Statue  +Cyndaquil Statue  +Quilava Statue  +Typhlosion Statue  +Totodile Statue  +Croconaw Statue  +Feraligatr Statue  +Furret Statue  +Noctowl Statue  +Crobat Statue  +Togepi Statue  +Ampharos Statue  +Bellossom Statue  +Marill Statue  +Sudowoodo Statue  +Aipom Statue  +Sunkern Statue  +Quagsire Statue  +Espeon Statue  +Umbreon Statue  +Murkrow Statue  +Unown Statue  +Wobbuffet Statue  +Girafarig Statue  +Dunsparce Statue  +Steelix Statue  +Snubbull Statue  +Scizor Statue  +Heracross Statue  +Magcargo Statue  +Octillery Statue  +Mantine Statue  +Smeargle Statue  +Miltank Statue  +Tyranitar Statue  +Treecko Statue  +Grovyle Statue  +Sceptile Statue  +Torchic Statue  +Combusken Statue  +Blaziken Statue  +Mudkip Statue  +Marshtomp Statue  +Swampert Statue  +Beautifly Statue  +Dustox Statue  +Ludicolo Statue  +Pelipper Statue  +Gardevoir Statue  +Shroomish Statue  +Slaking Statue  +Ninjask Statue  +Exploud Statue  +Skitty Statue  +Sableye Statue  +Mawile Statue  +Aggron Statue  +Medicham Statue  +Manectric Statue  +Plusle Statue  +Minun Statue  +Volbeat Statue  +Illumise Statue  +Roselia Statue  +Sharpedo Statue  +Wailmer Statue  +Camerupt Statue  +Torkoal Statue  +Spinda Statue  +Flygon Statue  +Cacturne Statue  +Altaria Statue  +Zangoose Statue  +Seviper Statue  +Lunatone Statue  +Solrock Statue  +Whiscash Statue  +Claydol Statue  +Cradily Statue  +Milotic Statue  +Castform Statue  +Kecleon Statue  +Tropius Statue  +Chimecho Statue  +Absol Statue  +Spheal Statue  +Clamperl Statue  +Relicanth Statue  +Luvdisc Statue  +Salamence Statue  +Metagross Statue  +Turtwig Statue  +Grotle Statue  +Torterra Statue  +Chimchar Statue  +Monferno Statue  +Infernape Statue  +Piplup Statue  +Prinplup Statue  +Empoleon Statue  +Staraptor Statue  +Bibarel Statue  +Kricketot Statue  +Luxray Statue  +Budew Statue  +Roserade Statue  +Cranidos Statue  +Bastiodon Statue  +Burmy Statue  +Wormadam Statue  +Mothim Statue  +Vespiquen Statue  +Pachirisu Statue  +Floatzel Statue  +Cherubi Statue  +Gastrodon Statue  +Ambipom Statue  +Drifloon Statue  +Buneary Statue  +Mismagius Statue  +Honchkrow Statue  +Purugly Statue  +Skuntank Statue  +Bronzong Statue  +Happiny Statue  +Chatot Statue  +Spiritomb Statue  +Garchomp Statue  +Lucario Statue  +Hippowdon Statue  +Drapion Statue  +Croagunk Statue  +Carnivine Statue  +Lumineon Statue  +Abomasnow Statue  +Weavile Statue  +Magnezone Statue  +Rhyperior Statue  +Tangrowth Statue  +Electivire Statue  +Magmortar Statue  +Togekiss Statue  +Yanmega Statue  +Leafeon Statue  +Glaceon Statue  +Gliscor Statue  +Mamoswine Statue  +Porygon-Z Statue  +Gallade Statue  +Probopass Statue  +Dusknoir Statue  +Froslass Statue  +Rotom Statue  +Rotom Statue  +Rotom Statue  +Rotom Statue  +Rotom Statue  +Rotom Statue  +TM93 +TM94 +TM95 +TM96 +TM97 +TM98 +TM99 +TM100 +Square Pedestal XL +Round Pedestal XL +Sturdy Pedestal XL +Clear Pedestal XL +Spin Pedestal XL +Spinback Pedestal XL +Giratina Origin Statue \ No newline at end of file diff --git a/SwitchGiftDataManager.Core/SwitchGiftDataManager.Core.csproj b/SwitchGiftDataManager.Core/SwitchGiftDataManager.Core.csproj new file mode 100644 index 0000000..0b2d180 --- /dev/null +++ b/SwitchGiftDataManager.Core/SwitchGiftDataManager.Core.csproj @@ -0,0 +1,57 @@ + + + + Library + net6.0 + enable + enable + Manu098vm + Copyright (C) 2022 Manu098vm + README.md + pokemon; mystery gift; wondercard; reader; nintendo; bcat; event injection; + LICENSE + Project Pokémon + https://github.com/Manu098vm/Switch-Gift-Data-Manager + https://github.com/Manu098vm/Switch-Gift-Data-Manager + git + + + + embedded + + + + embedded + + + + + + True + \ + + + + + + True + \ + + + + + + True + True + Resources.resx + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + diff --git a/SwitchGiftDataManager.WinForm/MainWindow.Designer.cs b/SwitchGiftDataManager.WinForm/MainWindow.Designer.cs new file mode 100644 index 0000000..59f3da8 --- /dev/null +++ b/SwitchGiftDataManager.WinForm/MainWindow.Designer.cs @@ -0,0 +1,385 @@ +namespace SwitchGiftDataManager.WinForm +{ + partial class MainWindow + { + /// + /// Required designer variable. + /// + private System.ComponentModel.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(MainWindow)); + this.BtnLGPE = new System.Windows.Forms.Button(); + this.BtnSWSH = new System.Windows.Forms.Button(); + this.BtnBDSP = new System.Windows.Forms.Button(); + this.BtnSCVI = new System.Windows.Forms.Button(); + this.BtnPLA = new System.Windows.Forms.Button(); + this.ListBoxWC = new System.Windows.Forms.ListBox(); + this.BtnOpen = new System.Windows.Forms.Button(); + this.BtnSave = new System.Windows.Forms.Button(); + this.GrpBCAT = new System.Windows.Forms.GroupBox(); + this.BtnApply = new System.Windows.Forms.Button(); + this.GrpContent = new System.Windows.Forms.GroupBox(); + this.LblInfo5 = new System.Windows.Forms.Label(); + this.LblInfo4 = new System.Windows.Forms.Label(); + this.LblInfo3 = new System.Windows.Forms.Label(); + this.LblInfo2 = new System.Windows.Forms.Label(); + this.LblInfo1 = new System.Windows.Forms.Label(); + this.TxtWCID = new System.Windows.Forms.TextBox(); + this.LblWCID = new System.Windows.Forms.Label(); + this.ContextMenuStripWC = new System.Windows.Forms.ContextMenuStrip(this.components); + this.BtnRemove = new System.Windows.Forms.ToolStripMenuItem(); + this.BtnRemoveAll = new System.Windows.Forms.ToolStripMenuItem(); + this.OpenFileDialogWC = new System.Windows.Forms.OpenFileDialog(); + this.ToolTipWcid = new System.Windows.Forms.ToolTip(this.components); + this.GrpBCAT.SuspendLayout(); + this.GrpContent.SuspendLayout(); + this.ContextMenuStripWC.SuspendLayout(); + this.SuspendLayout(); + // + // BtnLGPE + // + this.BtnLGPE.AccessibleDescription = ""; + this.BtnLGPE.AccessibleName = ""; + this.BtnLGPE.Cursor = System.Windows.Forms.Cursors.Hand; + this.BtnLGPE.FlatStyle = System.Windows.Forms.FlatStyle.Flat; + this.BtnLGPE.Location = new System.Drawing.Point(5, 12); + this.BtnLGPE.Name = "BtnLGPE"; + this.BtnLGPE.Size = new System.Drawing.Size(136, 60); + this.BtnLGPE.TabIndex = 0; + this.BtnLGPE.TabStop = false; + this.BtnLGPE.Text = "LGPE"; + this.BtnLGPE.UseVisualStyleBackColor = true; + this.BtnLGPE.Click += new System.EventHandler(this.BtnLGPE_Click); + // + // BtnSWSH + // + this.BtnSWSH.AccessibleDescription = ""; + this.BtnSWSH.AccessibleName = ""; + this.BtnSWSH.Cursor = System.Windows.Forms.Cursors.Hand; + this.BtnSWSH.FlatStyle = System.Windows.Forms.FlatStyle.Flat; + this.BtnSWSH.Location = new System.Drawing.Point(147, 12); + this.BtnSWSH.Name = "BtnSWSH"; + this.BtnSWSH.Size = new System.Drawing.Size(136, 60); + this.BtnSWSH.TabIndex = 1; + this.BtnSWSH.TabStop = false; + this.BtnSWSH.Text = "SWSH"; + this.BtnSWSH.UseVisualStyleBackColor = true; + this.BtnSWSH.Click += new System.EventHandler(this.BtnSWSH_Click); + // + // BtnBDSP + // + this.BtnBDSP.AccessibleDescription = ""; + this.BtnBDSP.AccessibleName = ""; + this.BtnBDSP.Cursor = System.Windows.Forms.Cursors.Hand; + this.BtnBDSP.FlatStyle = System.Windows.Forms.FlatStyle.Flat; + this.BtnBDSP.Location = new System.Drawing.Point(289, 12); + this.BtnBDSP.Name = "BtnBDSP"; + this.BtnBDSP.Size = new System.Drawing.Size(136, 60); + this.BtnBDSP.TabIndex = 2; + this.BtnBDSP.TabStop = false; + this.BtnBDSP.Text = "BDSP"; + this.BtnBDSP.UseVisualStyleBackColor = true; + this.BtnBDSP.Click += new System.EventHandler(this.BtnBDSP_Click); + // + // BtnSCVI + // + this.BtnSCVI.AccessibleDescription = ""; + this.BtnSCVI.AccessibleName = ""; + this.BtnSCVI.Cursor = System.Windows.Forms.Cursors.Hand; + this.BtnSCVI.FlatStyle = System.Windows.Forms.FlatStyle.Flat; + this.BtnSCVI.Location = new System.Drawing.Point(573, 12); + this.BtnSCVI.Name = "BtnSCVI"; + this.BtnSCVI.Size = new System.Drawing.Size(136, 60); + this.BtnSCVI.TabIndex = 3; + this.BtnSCVI.TabStop = false; + this.BtnSCVI.Text = "SCVI"; + this.BtnSCVI.UseVisualStyleBackColor = true; + this.BtnSCVI.Click += new System.EventHandler(this.BtnSCVI_Click); + // + // BtnPLA + // + this.BtnPLA.AccessibleDescription = ""; + this.BtnPLA.AccessibleName = ""; + this.BtnPLA.Cursor = System.Windows.Forms.Cursors.Hand; + this.BtnPLA.FlatStyle = System.Windows.Forms.FlatStyle.Flat; + this.BtnPLA.Location = new System.Drawing.Point(431, 12); + this.BtnPLA.Name = "BtnPLA"; + this.BtnPLA.Size = new System.Drawing.Size(136, 60); + this.BtnPLA.TabIndex = 4; + this.BtnPLA.TabStop = false; + this.BtnPLA.Text = "PLA"; + this.BtnPLA.UseVisualStyleBackColor = true; + this.BtnPLA.Click += new System.EventHandler(this.BtnPLA_Click); + // + // ListBoxWC + // + this.ListBoxWC.AllowDrop = true; + this.ListBoxWC.DrawMode = System.Windows.Forms.DrawMode.OwnerDrawFixed; + this.ListBoxWC.FormattingEnabled = true; + this.ListBoxWC.ItemHeight = 20; + this.ListBoxWC.Location = new System.Drawing.Point(7, 96); + this.ListBoxWC.Name = "ListBoxWC"; + this.ListBoxWC.Size = new System.Drawing.Size(214, 304); + this.ListBoxWC.TabIndex = 5; + this.ToolTipWcid.SetToolTip(this.ListBoxWC, " Wondercards with duplicated WC ID will not be seen by the" + + " game. "); + this.ListBoxWC.DrawItem += new System.Windows.Forms.DrawItemEventHandler(this.ListBoxWC_DrawItem); + this.ListBoxWC.SelectedIndexChanged += new System.EventHandler(this.ListBoxWC_SelectedIndexChanged); + this.ListBoxWC.MouseUp += new System.Windows.Forms.MouseEventHandler(this.ListBoxWC_MouseUp); + this.ListBoxWC.DragEnter += new DragEventHandler(this.FileDragEnter); + this.ListBoxWC.DragDrop += new DragEventHandler(this.FileDragDrop); + // + // BtnOpen + // + this.BtnOpen.Location = new System.Drawing.Point(7, 26); + this.BtnOpen.Name = "BtnOpen"; + this.BtnOpen.Size = new System.Drawing.Size(214, 29); + this.BtnOpen.TabIndex = 6; + this.BtnOpen.Text = "Open Wondercard Files..."; + this.BtnOpen.UseVisualStyleBackColor = true; + this.BtnOpen.Click += new System.EventHandler(this.BtnOpen_Click); + // + // BtnSave + // + this.BtnSave.Enabled = false; + this.BtnSave.Location = new System.Drawing.Point(6, 61); + this.BtnSave.Name = "BtnSave"; + this.BtnSave.Size = new System.Drawing.Size(214, 29); + this.BtnSave.TabIndex = 7; + this.BtnSave.Text = "Save as BCAT Package..."; + this.BtnSave.UseVisualStyleBackColor = true; + this.BtnSave.Click += new System.EventHandler(this.BtnSave_Click); + // + // GrpBCAT + // + this.GrpBCAT.Controls.Add(this.BtnApply); + this.GrpBCAT.Controls.Add(this.GrpContent); + this.GrpBCAT.Controls.Add(this.TxtWCID); + this.GrpBCAT.Controls.Add(this.LblWCID); + this.GrpBCAT.Controls.Add(this.ListBoxWC); + this.GrpBCAT.Controls.Add(this.BtnSave); + this.GrpBCAT.Controls.Add(this.BtnOpen); + this.GrpBCAT.Enabled = false; + this.GrpBCAT.Location = new System.Drawing.Point(5, 78); + this.GrpBCAT.Name = "GrpBCAT"; + this.GrpBCAT.Size = new System.Drawing.Size(704, 409); + this.GrpBCAT.TabIndex = 8; + this.GrpBCAT.TabStop = false; + this.GrpBCAT.Text = "BCAT Manager"; + // + // BtnApply + // + this.BtnApply.Enabled = false; + this.BtnApply.Location = new System.Drawing.Point(426, 355); + this.BtnApply.Name = "BtnApply"; + this.BtnApply.Size = new System.Drawing.Size(97, 32); + this.BtnApply.TabIndex = 11; + this.BtnApply.Text = "Apply"; + this.BtnApply.UseVisualStyleBackColor = true; + this.BtnApply.Click += new System.EventHandler(this.BtnApply_Click); + // + // GrpContent + // + this.GrpContent.Controls.Add(this.LblInfo5); + this.GrpContent.Controls.Add(this.LblInfo4); + this.GrpContent.Controls.Add(this.LblInfo3); + this.GrpContent.Controls.Add(this.LblInfo2); + this.GrpContent.Controls.Add(this.LblInfo1); + this.GrpContent.Enabled = false; + this.GrpContent.Location = new System.Drawing.Point(294, 99); + this.GrpContent.Name = "GrpContent"; + this.GrpContent.Size = new System.Drawing.Size(358, 250); + this.GrpContent.TabIndex = 10; + this.GrpContent.TabStop = false; + this.GrpContent.Text = "Gift Content"; + // + // LblInfo5 + // + this.LblInfo5.AutoSize = true; + this.LblInfo5.Location = new System.Drawing.Point(152, 188); + this.LblInfo5.Name = "LblInfo5"; + this.LblInfo5.Size = new System.Drawing.Size(49, 20); + this.LblInfo5.TabIndex = 4; + this.LblInfo5.Text = "Info_5"; + this.LblInfo5.Visible = false; + this.LblInfo5.SizeChanged += new System.EventHandler(this.LblInfo_SizeChanged); + // + // LblInfo4 + // + this.LblInfo4.AutoSize = true; + this.LblInfo4.Location = new System.Drawing.Point(152, 153); + this.LblInfo4.Name = "LblInfo4"; + this.LblInfo4.Size = new System.Drawing.Size(49, 20); + this.LblInfo4.TabIndex = 3; + this.LblInfo4.Text = "Info_4"; + this.LblInfo4.Visible = false; + this.LblInfo4.SizeChanged += new System.EventHandler(this.LblInfo_SizeChanged); + // + // LblInfo3 + // + this.LblInfo3.AutoSize = true; + this.LblInfo3.Location = new System.Drawing.Point(152, 118); + this.LblInfo3.Name = "LblInfo3"; + this.LblInfo3.Size = new System.Drawing.Size(49, 20); + this.LblInfo3.TabIndex = 2; + this.LblInfo3.Text = "Info_3"; + this.LblInfo3.Visible = false; + this.LblInfo3.SizeChanged += new System.EventHandler(this.LblInfo_SizeChanged); + // + // LblInfo2 + // + this.LblInfo2.AutoSize = true; + this.LblInfo2.Location = new System.Drawing.Point(152, 83); + this.LblInfo2.Name = "LblInfo2"; + this.LblInfo2.Size = new System.Drawing.Size(49, 20); + this.LblInfo2.TabIndex = 1; + this.LblInfo2.Text = "Info_2"; + this.LblInfo2.Visible = false; + this.LblInfo2.SizeChanged += new System.EventHandler(this.LblInfo_SizeChanged); + // + // LblInfo1 + // + this.LblInfo1.AutoSize = true; + this.LblInfo1.Location = new System.Drawing.Point(152, 48); + this.LblInfo1.Name = "LblInfo1"; + this.LblInfo1.Size = new System.Drawing.Size(49, 20); + this.LblInfo1.TabIndex = 0; + this.LblInfo1.Text = "Info_1"; + this.LblInfo1.Visible = false; + this.LblInfo1.SizeChanged += new System.EventHandler(this.LblInfo_SizeChanged); + // + // TxtWCID + // + this.TxtWCID.Enabled = false; + this.TxtWCID.Location = new System.Drawing.Point(435, 63); + this.TxtWCID.MaxLength = 4; + this.TxtWCID.Name = "TxtWCID"; + this.TxtWCID.Size = new System.Drawing.Size(115, 27); + this.TxtWCID.TabIndex = 9; + this.TxtWCID.TextChanged += new System.EventHandler(this.TxtWCID_TextChanged); + this.TxtWCID.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.TxtWCID_KeyPress); + // + // LblWCID + // + this.LblWCID.AutoSize = true; + this.LblWCID.Enabled = false; + this.LblWCID.Location = new System.Drawing.Point(375, 66); + this.LblWCID.Name = "LblWCID"; + this.LblWCID.Size = new System.Drawing.Size(54, 20); + this.LblWCID.TabIndex = 8; + this.LblWCID.Text = "WC ID:"; + // + // ContextMenuStripWC + // + this.ContextMenuStripWC.ImageScalingSize = new System.Drawing.Size(20, 20); + this.ContextMenuStripWC.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.BtnRemove, + this.BtnRemoveAll}); + this.ContextMenuStripWC.Name = "ConextMenuStripWC"; + this.ContextMenuStripWC.Size = new System.Drawing.Size(155, 52); + this.ContextMenuStripWC.Text = "Remove"; + // + // BtnRemove + // + this.BtnRemove.Name = "BtnRemove"; + this.BtnRemove.Size = new System.Drawing.Size(154, 24); + this.BtnRemove.Text = "Remove"; + this.BtnRemove.Click += new System.EventHandler(this.BtnRemove_Click); + // + // BtnRemoveAll + // + this.BtnRemoveAll.Name = "BtnRemoveAll"; + this.BtnRemoveAll.Size = new System.Drawing.Size(154, 24); + this.BtnRemoveAll.Text = "Remove All"; + this.BtnRemoveAll.Click += new System.EventHandler(this.BtnRemoveAll_Click); + // + // OpenFileDialogWC + // + this.OpenFileDialogWC.Multiselect = true; + // + // ToolTipWcid + // + this.ToolTipWcid.AutoPopDelay = 100000; + this.ToolTipWcid.InitialDelay = 500; + this.ToolTipWcid.OwnerDraw = true; + this.ToolTipWcid.ReshowDelay = 100; + this.ToolTipWcid.UseAnimation = false; + this.ToolTipWcid.UseFading = false; + this.ToolTipWcid.Draw += new System.Windows.Forms.DrawToolTipEventHandler(this.ToolTipWcid_Draw); + // + // MainWindow + // + this.AllowDrop = true; + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 20F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(715, 495); + this.Controls.Add(this.GrpBCAT); + this.Controls.Add(this.BtnPLA); + this.Controls.Add(this.BtnSCVI); + this.Controls.Add(this.BtnBDSP); + this.Controls.Add(this.BtnSWSH); + this.Controls.Add(this.BtnLGPE); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "MainWindow"; + this.Text = "Switch Gift Data Manager v1.0.0"; + this.GrpBCAT.ResumeLayout(false); + this.GrpBCAT.PerformLayout(); + this.GrpContent.ResumeLayout(false); + this.GrpContent.PerformLayout(); + this.ContextMenuStripWC.ResumeLayout(false); + this.ResumeLayout(false); + this.DragEnter += new DragEventHandler(this.FileDragEnter); + this.DragDrop += new DragEventHandler(this.FileDragDrop); + } + + #endregion + + private Button BtnLGPE; + private Button BtnSWSH; + private Button BtnBDSP; + private Button BtnSCVI; + private Button BtnPLA; + private ListBox ListBoxWC; + private Button BtnOpen; + private Button BtnSave; + private GroupBox GrpBCAT; + private Button BtnApply; + private GroupBox GrpContent; + private TextBox TxtWCID; + private Label LblWCID; + private ContextMenuStrip ContextMenuStripWC; + private ToolStripMenuItem BtnRemove; + private Label LblInfo5; + private Label LblInfo4; + private Label LblInfo3; + private Label LblInfo2; + private Label LblInfo1; + private OpenFileDialog OpenFileDialogWC; + private ToolStripMenuItem BtnRemoveAll; + private ToolTip ToolTipWcid; + } +} \ No newline at end of file diff --git a/SwitchGiftDataManager.WinForm/MainWindow.cs b/SwitchGiftDataManager.WinForm/MainWindow.cs new file mode 100644 index 0000000..338685c --- /dev/null +++ b/SwitchGiftDataManager.WinForm/MainWindow.cs @@ -0,0 +1,404 @@ +using System.Text.RegularExpressions; +using SwitchGiftDataManager.Core; +using Enums; + +namespace SwitchGiftDataManager.WinForm +{ + public partial class MainWindow : Form + { + private Games CurrentGame = Games.None; + private BCATManager PackageLGPE = new (Games.LGPE); + private BCATManager PackageSWSH = new (Games.SWSH); + private BCATManager PackageBDSP = new (Games.BDSP); + private BCATManager PackagePLA = new (Games.PLA); + private BCATManager PackageSCVI = new (Games.SCVI); + private List Duplicated = new List(); + + public MainWindow() => InitializeComponent(); + + private void ChangeGame(Games game) + { + GrpBCAT.Enabled = true; + CurrentGame = game; + RestoreMenu(); + EditFileFilter(); + EditGameButton(); + UpdateWCList(); + ListBoxWC.SelectedIndex = -1; + DisableContent(); + } + + private void RestoreMenu() + { + BtnLGPE.Enabled = true; + BtnSWSH.Enabled = true; + BtnBDSP.Enabled = true; + BtnPLA.Enabled = true; + BtnSCVI.Enabled = true; + + BtnLGPE.Font = new Font(BtnLGPE.Font.Name, BtnLGPE.Font.Size, FontStyle.Regular); + BtnSWSH.Font = new Font(BtnSWSH.Font.Name, BtnSWSH.Font.Size, FontStyle.Regular); + BtnBDSP.Font = new Font(BtnBDSP.Font.Name, BtnBDSP.Font.Size, FontStyle.Regular); + BtnPLA.Font = new Font(BtnPLA.Font.Name, BtnPLA.Font.Size, FontStyle.Regular); + BtnSCVI.Font = new Font(BtnSCVI.Font.Name, BtnSCVI.Font.Size, FontStyle.Regular); + } + + private void EditFileFilter() + { + OpenFileDialogWC.Filter = CurrentGame switch + { + Games.LGPE => "wb7full files (*.wb7full)|*.wb7full|All files (*.*)|*.*", + Games.SWSH => "wc8 files (*.wc8)|*.wc8|All files (*.*)|*.*", + Games.BDSP => "wb8 files (*.wb8)|*.wb8|All files (*.*)|*.*", + Games.PLA => "wa8 files (*.wa8)|*.wa8|All files (*.*)|*.*", + Games.SCVI => "wc9 files (*.wc9)|*.wc9|All files (*.*)|*.*", + _ => "All files (*.*)|*.*", + }; + } + + private void EditGameButton() + { + Button btn = CurrentGame switch + { + Games.LGPE => BtnLGPE, + Games.SWSH => BtnSWSH, + Games.BDSP => BtnBDSP, + Games.PLA => BtnPLA, + Games.SCVI => BtnSCVI, + _ => throw new ArgumentOutOfRangeException(), + }; + EditSelectedButton(btn); + } + + private void EditSelectedButton(Button btn) + { + btn.Font = new Font(btn.Font.Name, btn.Font.Size, FontStyle.Bold); + btn.Enabled = false; + } + + private void UpdateWCList() + { + if (ListBoxWC.Items.Count > 0) + ListBoxWC.Items.Clear(); + + var list = CurrentGame switch + { + Games.LGPE => PackageLGPE.GetListNames(), + Games.SWSH => PackageSWSH.GetListNames(), + Games.BDSP => PackageBDSP.GetListNames(), + Games.PLA => PackagePLA.GetListNames(), + Games.SCVI => PackageSCVI.GetListNames(), + _ => throw new ArgumentOutOfRangeException(), + }; + + UpdateDuplicatedList(); + + foreach (var el in list) + ListBoxWC.Items.Add(el); + + if (ListBoxWC.Items.Count > 0) + BtnSave.Enabled = true; + else + BtnSave.Enabled = false; + } + + private void UpdateDuplicatedList() + { + var list = GetCurrentList().GetDuplicatedWCID(); + if (list != null) + Duplicated = list; + else + Duplicated = new List { 0 }; + } + + private BCATManager GetCurrentList() + { + return CurrentGame switch + { + Games.LGPE => PackageLGPE, + Games.SWSH => PackageSWSH, + Games.BDSP => PackageBDSP, + Games.PLA => PackagePLA, + Games.SCVI => PackageSCVI, + _ => throw new ArgumentOutOfRangeException(), + }; + } + + private void LoadLocalFiles(string[] files) + { + DisableContent(); + var list = GetCurrentList(); + var errList = new List(); + foreach (var path in files) + { + var data = File.ReadAllBytes(path); + var success = list.TryAddWondercards(data.AsSpan()); + if (!success) + { + if (errList.Count == 0) + if (CurrentGame is Games.LGPE && list.Count() >= 1) + errList.Add("LGPE only supports one (1) wondercard at a time. Aborted file(s):\n"); + else + errList.Add($"Attempted to load invalid files. Aborted file(s):\n"); + errList.Add($"- {Path.GetFileName(path)}"); + } + } + + if (errList.Count > 0) + { + var msg = ""; + foreach (var err in errList) + msg = $"{msg}\n{err}"; + MessageBox.Show(msg); + } + + list.Sort(); + UpdateWCList(); + } + + private void BtnLGPE_Click(object sender, EventArgs e) => ChangeGame(Games.LGPE); + + private void BtnSWSH_Click(object sender, EventArgs e) => ChangeGame(Games.SWSH); + + private void BtnBDSP_Click(object sender, EventArgs e) => ChangeGame(Games.BDSP); + + private void BtnPLA_Click(object sender, EventArgs e) => ChangeGame(Games.PLA); + + private void BtnSCVI_Click(object sender, EventArgs e) //=> ChangeGame(Games.SCVI); + { + ChangeGame(Games.SCVI); + GrpBCAT.Enabled = false; + MessageBox.Show("Scarlet and Violet features still not available."); + } + + private void BtnSave_Click(object sender, EventArgs e) => new SaveWindow(GetCurrentList(), CurrentGame).Show(); + + private void BtnApply_Click(object sender, EventArgs e) + { + try + { + var list = GetCurrentList(); + var wcid = UInt16.Parse(TxtWCID.Text); + var index = list.GetIndex(wcid); + if (index == -1) + { + list.SetWCID(ListBoxWC.SelectedIndex, wcid); + list.Sort(); + UpdateWCList(); + ListBoxWC.SelectedIndex = list.GetIndex(wcid); + BtnApply.Enabled = false; + } + else + { + MessageBox.Show($"WCID {wcid} already exists."); + return; + } + } + catch (Exception ex) + { + MessageBox.Show(ex.ToString()); + return; + } + } + + private void BtnRemove_Click(object sender, EventArgs e) + { + var list = GetCurrentList(); + list.RemoveWC(ListBoxWC.SelectedIndex); + ListBoxWC.SelectedIndex = -1; + DisableContent(); + UpdateWCList(); + } + + private void BtnRemoveAll_Click(object sender, EventArgs e) + { + var list = GetCurrentList(); + list.Reset(); + ListBoxWC.SelectedIndex = -1; + DisableContent(); + UpdateWCList(); + } + + private void BtnOpen_Click(object sender, EventArgs e) + { + if (OpenFileDialogWC.ShowDialog() == DialogResult.OK) + LoadLocalFiles(OpenFileDialogWC.FileNames); + } + + void FileDragEnter(object sender, DragEventArgs e) + { + if(e.Data is not null && CurrentGame is not (Games.None or Games.SCVI)) + if (e.Data.GetDataPresent(DataFormats.FileDrop)) + e.Effect = DragDropEffects.Copy; + } + + void FileDragDrop(object sender, DragEventArgs e) + { + if (e.Data is not null && CurrentGame is not (Games.None or Games.SCVI)) + { + string[] files = (string[])e.Data.GetData(DataFormats.FileDrop); + LoadLocalFiles(files); + } + } + + private void TxtWCID_KeyPress(object sender, KeyPressEventArgs e) + { + if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar)) + e.Handled = true; + } + + private void TxtWCID_TextChanged(object sender, EventArgs e) + { + if (!TxtWCID.Text.Equals("")) + { + var list = GetCurrentList(); + var newWcid = UInt16.Parse(TxtWCID.Text); + var oldWcid = list.GetWCID(ListBoxWC.SelectedIndex); + + if (oldWcid > 0 && newWcid > 0 && newWcid != oldWcid) + BtnApply.Enabled = true; + else + BtnApply.Enabled = false; + } + } + + private void ToolTipWcid_Draw(object sender, DrawToolTipEventArgs e) + { + Point screenPosition = ListBox.MousePosition; + Point listBoxClientAreaPosition = ListBoxWC.PointToClient(screenPosition); + int hoveredIndex = ListBoxWC.IndexFromPoint(listBoxClientAreaPosition); + if (hoveredIndex > -1) + { + var str = ListBoxWC.Items[hoveredIndex].ToString()!; + if (str.Contains('\u26A0')) + { + var msg = "Wondercards with duplicated identifiers may cause issues and will not be seen by the game."; + e.DrawBackground(); + Graphics g = e.Graphics; + g.DrawString(msg, e.Font!, new SolidBrush(Color.Black), new PointF(e.Bounds.X, e.Bounds.Y)); + } + else if (str.Contains('\u2757')) + { + var msg = "Wondercard count is above the maximum allowed, or the WCID is over the maximum allowed."; + e.DrawBackground(); + Graphics g = e.Graphics; + g.DrawString(msg, e.Font!, new SolidBrush(Color.Black), new PointF(e.Bounds.X, e.Bounds.Y)); + } + else + { + ToolTipWcid.Hide(ListBoxWC); + } + } + else + ToolTipWcid.Hide(ListBoxWC); + } + + private void ListBoxWC_MouseUp(object sender, MouseEventArgs e) + { + if (e.Button == MouseButtons.Right) + { + var index = ListBoxWC.IndexFromPoint(e.X, e.Y); + if (index >= 0) + { + ListBoxWC.SelectedIndex = index; + ContextMenuStripWC.Show(Cursor.Position); + } + } + } + + private void ListBoxWC_SelectedIndexChanged(object sender, EventArgs e) + { + if (ListBoxWC.SelectedIndex > -1) + { + var list = GetCurrentList(); + var content = list.GetContentToString(ListBoxWC.SelectedIndex); + var nItem = content.Count(); + if (nItem >= 1) + LblInfo1.Text = content.ElementAt(1); + if (nItem >= 2) + LblInfo2.Text = content.ElementAt(2); + if (nItem >= 3) + LblInfo3.Text = content.ElementAt(3); + if (nItem >= 4) + LblInfo4.Text = content.ElementAt(4); + if (nItem >= 5) + LblInfo5.Text = content.ElementAt(5); + + TxtWCID.Text = content.ElementAt(0); + EnableContent(); + } + else + DisableContent(); + } + + private void ListBoxWC_DrawItem(object sender, DrawItemEventArgs e) + { + if (e.Index > -1) + { + e.DrawBackground(); + Graphics g = e.Graphics; + var curr = ((ListBox)sender).Items[e.Index].ToString()!; + var wcid = UInt16.Parse(Regex.Match(curr, @"(?<=\#)(.*?)(?=\:)").Groups[1].Value); + var handled = false; + if ((CurrentGame is Games.BDSP && wcid >= 2048) || (CurrentGame is Games.SWSH && e.Index >= 129)) + { + if(!curr.Contains('\u2757')) + ((ListBox)sender).Items[e.Index] = $"{curr} \u2757"; + g.FillRectangle(new SolidBrush(Color.IndianRed), e.Bounds); + g.DrawString(((ListBox)sender).Items[e.Index].ToString(), e.Font!, new SolidBrush(e.ForeColor), new PointF(e.Bounds.X, e.Bounds.Y)); + handled = true; + } + foreach (var d in Duplicated) + { + if (d == wcid) + { + if (!curr.Contains('\u26A0')) + ((ListBox)sender).Items[e.Index] = $"{curr} \u26A0"; + g.FillRectangle(new SolidBrush(Color.Orange), e.Bounds); + g.DrawString(((ListBox)sender).Items[e.Index].ToString(), e.Font!, new SolidBrush(e.ForeColor), new PointF(e.Bounds.X, e.Bounds.Y)); + handled = true; + } + } + if(!handled) + g.DrawString(curr, e.Font!, new SolidBrush(e.ForeColor), new PointF(e.Bounds.X, e.Bounds.Y)); + } + } + + private void LblInfo_SizeChanged(object sender, EventArgs e) + { + var lbl = (Label)sender; + lbl.Left = (GrpContent.Width - lbl.Width) / 2; + } + + private void EnableContent() + { + TxtWCID.Enabled = true; + LblWCID.Enabled = true; + LblInfo1.Visible = true; + LblInfo2.Visible = true; + LblInfo3.Visible = true; + LblInfo4.Visible = true; + LblInfo5.Visible = true; + GrpContent.Enabled = true; + } + + private void DisableContent() + { + TxtWCID.Text = ""; + TxtWCID.Enabled = false; + LblWCID.Enabled = false; + LblInfo1.Text = ""; + LblInfo1.Visible = false; + LblInfo2.Text = ""; + LblInfo2.Visible = false; + LblInfo3.Text = ""; + LblInfo3.Visible = false; + LblInfo4.Text = ""; + LblInfo4.Visible = false; + LblInfo5.Text = ""; + LblInfo5.Visible = false; + GrpContent.Enabled = false; + BtnApply.Enabled = false; + } + } +} \ No newline at end of file diff --git a/SwitchGiftDataManager.WinForm/MainWindow.resx b/SwitchGiftDataManager.WinForm/MainWindow.resx new file mode 100644 index 0000000..00e1abb --- /dev/null +++ b/SwitchGiftDataManager.WinForm/MainWindow.resx @@ -0,0 +1,1392 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 407, 17 + + + 17, 17 + + + 222, 17 + + + + + AAABAAEAAAAAAAEAIACfNAEAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAAAFv + ck5UAc+id5oAAIAASURBVHja7L0HWBVZujW8tbune2Z6ejpHW9ucI6BiRjEgIiIoKgYQEAEFJOecc1aC + KIrkKEkEzDnnnHOWHE6o9b/7FHb3zL33/26YcG/P2c/zUsU5VefUqdprvWvtvWsXY8qiLMqiLMqiLMqi + LMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqi + LMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLP9Li3lBkCLWUKzI + 9WOrigKZKa2bFgYxs8IAZprH3wuhbSgKQ9maojBmQWFVHMbMikIpwphpWQRbWxTBrAvp9cJgZlkghrIo + i7L8bwR9YQRbQ2FGwdctCsOZWX4gsygJZTqx65hFfnA3s8Lgbib5ft1W7PDtRiTQzYy/VhDSzbwotNua + 4tBu1qURtB7WzSI/lJmW0ucUcPCHMtvScGZVQp9PhGBZGkPrcRTxypOuLMryzy52xYlsXUEisy9NZE7F + ccwrJ4K5ZQWyqM3O7Nv6vG5DaxLfn1Ib/YeJu8I/mVwT9qlmTfjn88vjvtAri/tyQVn8Fwt2xn+5qCLp + y6VVyV8tqYz7al513OcT92764x8ulb3Pjld3H1mb9d7M/dnd4cKYUdFaNrvYghlkmTKr3GBmlReivADK + oiz/6LKGy/Z3QTI+IMuGmVZv77ahNOF3dgWRf7TJDf1kQ27AV0HbnYYnbXWZs3mzi8nWTfYbSpIc3Gti + 7L0Lk2y9dySt99yeYuuelWrnvn3jeo+sxHWeOxRh45adbGeVucnOMHWzvXZ8pqNmyHZHFac8p2/0y9x+ + r7fT78OVxSEfGOdHdbMpCmFryoKYY7GSCN4V44pAtqo8iK3cGcyMy0LY6tLQn0NZlOV/XEzIv/Mg+a4I + AMylIOwDr6KorwKLokdG5kZMjc0KnhudFWCRlumSlJPqWF+W5HBn90bHhpPJLq3X4lw6TqU6tR1Ks2/Z + k7aheU+aXXP9xvXN9QlWzXWxa5vrIy2aaiPWPKmMtjhTsnFdXWGmY2l2jnt6eoGXXUKO16zQHF9Vj/yA + AQ65/n8yLwrptqYsmJmWBTIrIgGLkn+dNgK7opifY0NxLLMujGLGxeFsWVkEW1EeQiQQoiAAk5IQZlYc + xiyLwhRtLbzNhYeyKMt/qZiRL7fk3rwglK3fQtmlKrr78rrY35lURX7pmu86PnSLg21qrFV2kbfxyd3r + 9e/sN9N5echEv/3wSj3p4TWLhGNOK3DRdw1eJ3hBkhkDWUkKWndloKFmMxqq0vG2JAEN2/zQkuCCjhBb + dPhZyjsC10jbo2wk7XHOnZ2Rbi3t4e7P7yb7XijO8csOLPJZsbosuO/8quCPxlUFdjPf48eMCgLZmuKA + f4nrYVQexox3RrDh+3zYuppQFpXnzRC0koG/idJu7FVy9x4nIt+bVR/+3rTaoG5ueelsQU0sM6yKYMYl + YSIplET8HMqiLP9uWVYRxhYcTmMrSoOYVlU4W1Ud292kJPxjy0z/nxzCHKZY265aY2aycLOZodZFS+1J + TbYThwsbBvcQbH/4RLD+9GOYf/p7mP/wJ1j1/hzOw35A3KxxqLA0xv5wT5wtSRfeXD8E6ZMLwOPzwPV9 + kB/fCdmu7UBhMpAVAWwLATKDgS18GYH2/Djc2xnfdrYs4UxdQVzMxtxAXefigF6Ld/p/EJUTzOzzA5lf + 7m9TCVgVBjK1Qi/mXxrGUrLpN96s6qa9O+l3K3fH/tG1OPiLlK3ugws3OWmXJXsZ5mz01d24JVDTb1uw + mnNhdE+bqqRPjPcmfbRib8Lvlh5I6j7rxjZmvCuOeez1Ymvo89aWhSsru7L8+wRgQlLSuDy0m0Nh5B/X + bfHvvSTYSnPG6rnOM2eq7dAaNejC7P4DG2f92FeY821PzP/me8z/6ito/emPmPfx59D84gtM+/ozzP7s + E2h/8WfofPd5x+I+vZ4tVx99JcLP/sT2rPiDN24cv9DR/rRZLnkOefM9yB+fA67sg3C4FELdDqAmHahK + FYMUA+q2UuQIDfuKGo7s33Zwa90mn4jyGBWXdI/fBRSGsfztkWxRRdBvo72lJkIR6yrDmW1JKHOkrK+d + bcOCd8Z8lJbp9WNaurvq5gzf2dk7QsxykpwSS8It60sDbU6kuJju83deWbbWcUXacg8zp+X+67WXB1mr + msc5DbXZFvCTQ3HU1w7lcZ/aV8X/ziDTXdFGYFkXx8wqlGpAWbqKDVW4RTWRTOtqNltUGvBn00Tnacus + FwXqT1Xbp/PTjy+0v/umY84P38rnfvEV5n32JXS//AoLvvsaWt9/hulf/wFan36DuZ98h4V//A5L/vAt + dH7o2Th11ICqaZoj1y9YOVvTNsp+uFXUhl7Je7eO2vfgROj9109vNHc2dsrlbwV0PoP0zQ1I7p4CLh4A + ztYCZ6qA05UUVRDO7YL8Sj1k5+vkrSd3P7tUn7c9NT9KY0NB8Ee+eUHsXIwzcyn+v6sEHGpCmNXOIGZX + GcTsybsvLU1nBzKc2ZyaiPdtysK+C87yNzyRaLftSaTNtafe619eWmPUuNdoflvmnLESf9WB0rV9v5Ms + 7ftN59ze37ZP79fruebQIRd0Rg0+rD9jbMXiVdpxhl6rrZekOhssK/AbY1Qe+vGC+qjuIVlhbEYtfW9e + kLLyKwtjlvsSmPNGF+ZUEvahddT6CasXasQvHNnvru6PX0sXffMVFn/7FXS/+gx6X3yJRV98jaVffgOj + r77Fkm++hv43X2Led/T+t99A/+uvpQt7/HDNYIJKzEqThVMdgmy+9Uz1+cSzIOIjh9LIDyzy/T4IL037 + ofRInd7J+xeiXrQ9OSwTXjdASoqg/TE6X9+A7OEZ4M5R4PYRisPAzUNkGQ4CN2j9+mGh5WL964s1W3fk + ZwZqmJT4fhix3YsZ1Uaw1dX/dxq8HGvjmc3RHGZVEsg2FfuyL45t7LbgQMxH8/Ym/XH23pQ/WpaGfrE1 + K2DioXSvgIupXideZQY1vU3zF6qtlsBhSC+Y/PCVsOyzz7Hgzx9i5h/fg8ZnH2HSF3+E+jefC+O/+0Y+ + 9ZsvhKk9vpZO6f/DK03Vgdf05044YWyknWoaZLnYKSuwv1NNwgeBW4OYaXEIs8kOVALgX7msLOGNfkFs + /bGM7nZJToNNjbVCzUb0v2fy47eCyfdfY9XXn8Po60+x/PsvsOzbr7Him29h/m0PWH7XC2u/6wlTWtfv + /Q0W/vSVzGDgDxeXz1S1N3ZZ1nf1y+z3HKeNY95RTsw7N4w5FoUzm+JQtrlyO2PhE95zLI3+ZteF2vn3 + X1zNaW9/+laOt+iUPoX01WXg3nGKY8DDE7Q8CeE6kcEtIoAbpBCu7Uf7iZ2vju5M2h6RGzhhTa7XB/al + wWzZDm9mWv6/nwTsqpLZhuqNzCTXX9GzEpnv/bttub4/FWc4zahM3jCnINVl/tb8ENvy3PCC5zs3PZKX + p8kfxbhju8E0mAz6BlO++RMmcLv1yddkuz7FtC8+xuQv6LXPP8akbz7DpC8/h8ann0Lz888w6+svMZvI + WevHrzG37w9vNbVU9y6zWeSzYaPbmNDK5A+c8sPYXBwkBaK0A/+SZTn5aN6l5ETrq7J9P7eyNbRwUR11 + 0emnH4X1Pb+B1U/fwOKnr2BJS8teX2NNr6+wtufXWNfze9j16gWb3r2xtldPer0XVgzr/3TpIg1fozDL + H/hnb3x5khlv9WHWJVHMrJB3TYUzk9IoNmebF3OtS2OVL04xq+0BH6bW7Zh6+uqJHW1NTxvR8gB4ep6y + PmX8q3spDkB+8wgkpAYE/trlerIIZA/OlAoN9VkvqrMjkzcU+A012Bf93rJ90cykIpht2JnwvxP4FXFs + bUUoW1+ZzFwr8ti8uk3vm1SEf5tcHT7v8Gan9FeBJvckHsuaOsIsW5rzoxubzte0PTtbL6tNiRG8dOYK + c7/4Upj9ZwL9p19j6ud/xuQv/4ipn32FKZ98hRlf8Nc/wxwKnc8/x9zPv4TWZ1+A9sG8r76CNpG4Lik1 + o6+/lS0ZOej+SmOdpLWx9uPXlUZ8aLsjiC3ZE6UEw79iWVIYyvQrfNiUc3HdPYLNx3jPmZTtO6Rvs9+A + H+HZ7we496WgpceAHnDv/x2cB/0AR3rN7ade8O7bFz79+sKvT29sGDxQtnbelJ32wetUo5/t6+66yZNZ + F0co+qHXka91LgglFRDCgrJDWOj2YMY96AbKPjsiQ5lrRvAf0qt2TD5z/eiWjhfXXuEeWYCLBPQT5cDx + MghnqyG/UAucqxFfO1wI7M+GrC5HeFYQfffwFhfnoPyALyu227K1xfFsw6EJ/yvPtcfOAKazL4TdTPVl + uvujP96c6Tn5+Eab0OsRJsde+Rk3dPivgRBuB3l+FCSXa2Stb6483b8756LZktmnZg344eysbz+7Ovvr + z17N+vpzuea3n2ImZXtNAvuMr76AJgF81ud/wpzPP4HWl3/GvK+/xvyvv4EeKTYDUgCG331JCu5rmHzz + HYx6/SBfOmrAo3VGcxM94t1Ulx/d8r739jC2Pj/6f96QXBqmCCNSlcsLQ9jyvCC2soBeK4pki4qUvQ// + ++Q/ZWajwg1s8a6AD7036BmGqY04G9qvhxA2uAfCBvdC+OA+CB/SF2FDeyN0SA8EDOmJAHotZNAARFBE + DuqHqEF94TFl3EMnm6Wm1jXRv3dJcGLryiPZCrr4pgUhbFWWL0s+lsPq7x9itdd3s2a8ZjKSvuG1qSx+ + 22bWu8ybzdjm/bste7ap3j1TmyY9WduAwzsB3iuwKwOozQT2ZAP78oC9ucDubUBFGlBMkRsme5ThenDr + dj+NgXu2dXfNC2f25XH/+9pYdsUym6potjs7nqUXhn+6bUfg4tpk5/KHcetetfovF+BvDsS6QshJgHCy + XJC+ufT49qNTWTml6bZr7JeZ6c9RW6c3po/PnD5f7Jjd64v7Wj0+F7QJ+PO/+gxzv/kz5n77Z+jQcv43 + n2J+jy+g3+MHLKJY0uNbLO/xDVb/+C0sfvwea3p8B3Nat+zTQ7BSH37XytrA326bz0/8GC0KItmagv+a + FVieH6iIVQVBbDHZu4UlYUyvKIgZ5Acw45JwZlbGBy1FssVEAnqUBIzyQ5lZThCFvyKU5Z9YzPPDKWNG + MrvUNcw61/ULH+PprtGjhjyMG9RbiB/2E+KG/oT4of0QN7w/Yof3QzT9n9ivF5IG02vD+iN52AAkjxqM + cI3REpf1izI9M7z7pa3SY8HlyZQKGDtxrp6xFYz1SlzZfdFW5w/scwN+H1Ye+3FSZfKfI4oT/mReHPY7 + pIaz1mRXVpflzuZVebxXUZ007nV5xnahdHMD8hOB7CggK4yAHg0U0v/FyUBBPJATCWwNg5DmhcZU51cH + N/t6Lt8V80lMUShbWfG/p0dgTUUsW1YdzYyr49ikvUVsWW3on3Nzg1c1RPuclIc6SoUYRyDaAUj1gZAb + A2FfsVy4fuLF6zsntuw6UTLduSzyC8uCgE/MNvt9aRbqNGKV2SITw2lqtcuG9JesHTQYtgN7w7Lfd7Ac + /BOsaH11z+9g0vsHmJA6W0m2zLjnD1jb5yfY9u0Nm14/0rZfYkPfL+Hb93t4D+rZ4aileszdb/UKu+LY + P35Zt56ZEwFYFP/HdoDf8MXDjI/GLAxm6/gIUbd6NiDXlamVBHUbWxry3pTioPdnFQf/bn5J+IcLyGLo + lkR9OKck6gO14rhu47OzmeW2MGaV5cdWUYJYWujHVuQrlcE/jQDs8kIZo2zsHWs9JGqB+tb0UUNaMoYP + wOYRfZA2vC9SCegp9P/GYf2QOEQkhYSRfRE76iekD++DTCKABJ1JLwLCrJd770n+3fOzx9mKTc6/D8yL + /nZjRerAiroCzeMn66we3joT3vLg6pbO+1ezWm+djX55ttShsWqTiTzdV0cabTvxVdTqIWdjjH/M2Oz0 + bV2+/9Sr2d75ramezUj0BOKcKZyAJHcgxUuMjbQe5wJE2UIasU52M3ZDWVS2Ry+4mbLVO//33C8wsGIr + m0ngT9kdxCx3R/4hc2fIvBsZfvskiR5SJNLvSvWEkO4LbCeSK08RhNPlDS8u7y2oO1wwNTUr4kNmDLZw + T8oHMw9v/cK2PH5qQop7ZLan8f3KNfOFo6u1cXH9Ulx2XY0r/ja4HOyI8wGOOEtxImA9DnqaY4/zCuyx + X4oa83nI1x2HtHGDET+8B6L6fo6ofl8IIeN6t0Ss0syxzgwatbY48f21xeHMaHP+v/kdVqQU1xK5OuVF + MpvsUOaQE8G+376629Isj49WbHX/3CzLp6fPjsCx0VmBixKyAlanZvpaZW71ss9Od3PNTvNwTsrwMHbI + dh23oNTru4mVQR+PrY7+AC6/ZxqVfmxJibUSjP+MYlZABJAbzKbjdvcAj+UzU2epHM1TGS7LUxmCXJX+ + 2DFmALaPHIgtnBCIAFLJBiSNouWYfkhW/Qnbx/RFtspQpK2Y+zg81XOx+/aQL+NrtvQrP71L9+yDc043 + 39xIetP2dG9r+8v70o7XzULHGxna3ghofdEsvLl2W7hx6AwOFuxFSXJxx/aglOcb3X1vhNmuPROy2vJI + 1Modb4NMn8F/LRCwhoIkcpAFEGYNRNgA4evp/7Xia17GeOZnfG172obxnMysKsKZdVXY/xLpH83sK8PZ + qMqI7kmVkaOPlUVltW0LaUO6D5BB5JbhB2FLAKmccKA6Xdp8LPfY4T1b9E1K/X83Y1fMe66FoV8nZweo + b0lztMpJc8ypSbC5fT7YVPbS3xjyIDMggUgwm8hjJymjmq3A/gLgSAlwthS4UKYI4XQRZPXpaN4RhKeh + Ljhrsxz1izVRojES6ep9ET1f5d6GWDt7xzz/7w6vDaMMH8Q25Mcwm4IotqKMyBRk40pDmCWRg39GFLPY + FvC++Xa/Pzrkhvb2L4ydnVS1eU3eocKA2lM784+eLT925lz5hctnSq/dOllw5/bh7Q8uV2+8d6gg4tzO + Hb7FBRnuAWlpLsaBm13UbbLc/syv17IiH7akKEAJyH90MSkKZ045AexboHus+XyD4knDbleNHYmKCSOx + c/wAFKv2R/6o/sgeQURANmDrsL7YMmIgCogMto/5ETlj+yJ/qiryPNZINubGHMo6lB95/MHprOdNj691 + yBrfdqClvRPtMgk6wIPQrwg52gF6FR2NAt7c6cCVw22oK+kUtifL5JHuUrmHpaTZeYmk3VlfgP1CwHkx + 4ErhtoTAvgLwNaFYDXjTuvtyYMNiyFyXNFZsslvd90L6B2v3+P+vIYC1RADXa/3ZmproL3YVR7i0bA5+ + iM1+ZF/8gW2BQDJXM0QEW4KBquQ3N/ZuCnPeF/KdQUnk+3q1sX1cy0LWFqc4Vzz0MHgmddIWBHsdwFaX + zsUyIJTIL532LYsD9m0BThQCl2qA2/shPDoOPDtNcUaM57T+6CikV6rRtj8bzTkJeBnpiSvOpqiwXiBJ + jLE64lceaLqiJvirhZnB3fhwYUsiALPSaGZDWX9RgW93s/zgP27IDf/BsTBa1b823SDrTHnIweuH6u49 + unyn9c3DN9KWx53y1vsCGm8KeH5WwN1DgnC5AsLxHAiVKRAyQtAZ5ym9mOjycke6S41jjusynRKPPy8u + ilESwD+lC7CYpFx+ALcA3dKWaK7cPWHYyz3jR2D3lJHYPXkwKtUHoVR1AIpUBiFvZD9kk/TfpjoIFST7 + C8b0RrHGKNQb6ODa9mRcu3Zc+vTNvcZ2aVObXNYBQd4BucCXUjEECqIBOYUMUkj5/wIRQedTqqDngPO7 + IdRso4xIQAizh4wALnMk0K+dSzELWKcF2MwD7PUAJ3rdmcjA1QCwWwRY6kC+QVd2PNgidl1Z+CcaBc5s + TeU/nwAcq5PZul1xbPCeyO4F+SHTnmcEHJRt8pBhE4E+mQggiaR/tCMQYwds9oekKOnKherkuWProv/g + VRGiWpzmEH7Zy+juCye9zg6HOQAP+/lEePSbvcxEa8Tvn6hMBY4R+C/XAfdPAC8uAU1XgLZrFNeBZlpv + Ok9B57nhLPD6FJHBYdp+N2QH8vCiIA4Xs/w7ygsDD4cW+5ubFgb0Js/+0eTi0m6sKrqb3nafj2yzgoZG + liYvyd1fEHjswsGChw9unH7b/Px5u6yxU4ZWuq4isQs85E10XV/Q996B/Pk5SO8dhOxCBbCXSCovFK2b + nPE80qrzQaD1nupYp4n96oO7Gef7KAH5DyeAkjC2oVBBAGyHwXTz/ROHNR9UH469U0dg77ShqJs6DFVE + AjtVB6J4VF8UkuTPHzsY9SrDUTNdFSdtV6I5Ow2yu+chSN4CQhsFZXaplDI8BYEccpkYAgVBX6CQKSiA + r3OCeA2hkSrqrQMAVUZFo1+MKxBiRRl+FeBIILelrGdNlX+NJmAxk9a1KeZDtl4LcgsCv5kW2k2n46Ld + 0t3+27x7Rm1zVoxzty7/5zYuOVQls9Cdocy/NOSzY+leIZJEtyYk2AOJvP3CG4gk+R5GvzOabA2pgsbM + 6IOppTE6sQXheqUb7baeDTB60cIzvjURoC0RoKOuqIZcSPkE0j5p9BmF8cCeLJL61eKgqYYbQPsjOueP + 6Zw/oeUTuiT3IHTcoKDz3H6VSOEykcEF4BUpg4fHgKu16Dy8A7f2pnfWVSefzyuMjU7MC9V3yvUd5VQQ + PiSyIk236HhF0rn7Z48/aX7wuK3jTQc62wQInXRNO+k6dkIm8JASCcgU/0NooXrwghZEAi8vQrh7iEie + LEl9CpBDlifBAe1BNo/3xznOY88Su5kqCeCf0AaQH8HWFQUqbistWjDN8vDkoe2HJw7FgakU04Zg//Th + qJs0BLvGDUKlWj9Uju2HunFDcW3eTDzx2YDG2h1UiS5DKn9KF72VKkMHVThOAAR22S+gVyz/KuQUXBXI + 0AJ5J1XYB5SVjpaKrfzxVLHDyecHk9T3J6nrThlvA1V+KyIBUw3IjTUgWz0L7UQIEpM5aDHWRPOKyXhi + bnAzLt1tImu5yBbvz/qnEsCGXfHMeddGdj7NnKUXBKm+jHA4qmi/iLIEIogEwh2I5NaSjCeSizRXWIHb + 6eFnfYtDgwoSnctfOSxqwJrJpHwmkvKh372BzoMLnQ83Ck9TsQ1kuw+wKw04RZ6fsiwaKdNLCfR4TUFZ + mM4tpWHI5W+Ig+kayeg8S+8SAdwmoiBl8PoyhDfnIXtxAsLNesguVkN6aKfwtjq74WBV0omYqvD0jCM5 + SWcenN7zpunpK7m0RYDCxrUrKJxfPwXJC7K/JHr+moIEmmj1GR3KPeAxEc7NA2LbRC0ngVA8irc7s2Oj + 1ahG/9XMJM9bCch/dFldSFmyVCSAEr1pVoc0hnUcJ8AfnTIUh6cNxmGNYThA/+9TH4w6tb6oH9cXJ/Qm + 4G3IBrqIOxSj9YS3VyCRPSQC4BWO5B9XAF0VQiAS4BmBx78hApmoDmRUUSRUQYVXVHkv7AZqMskGhBMJ + kLwNI2D4UbbzILnvrE8gmK9QAMLKKZAaTUHb8iloNpqKN0unocFwIp6baL0pCLFY0f9u+Xsrq+KIACL/ + aefWrjqOOdO5HXNu0/sXwzZYd/ibNiCEwBtEBBBsLTZs+hL4fY0oTNERsUE4kO789pqz6bPXq+d1SMym + kLWZRKQ3nWQ//XYXUkJuZH88lwI+tG+MB4GIsv++YghXKLu+uA6h/SWd0za6Bp0Ku4WuEAi0AhrovJMs + 73xAl+meQp6Dn/PH5yBw8n1wTLzn4speCKfK0bJ3m+xpeXLz80u7GyWSZx0k7wUp/1yyd9zicQKQQype + V3SBXqEIOrqC1CAaKV4QAT0gLiDl8ZgUx3X6juNkByoycWaz31bX6FWf5satV4Lxn9INWBjJrHcGKQig + fNF0y8OzR7afnjYMp6YOx3HN4ThK64eJAA4RARwc3x9nNEfjpYMRhNxI4GAucLEO8kenSQ3eoorBLQD3 + gp2KivEuOyjWFRWlK4Su9gCuFDhBdKkAtFKlvE2VYz952dxEsWEshMDiZ0xWwEgEgO08AsRswEwTMgJ/ + ++IJBHx1vDacgjcL1fHAUL2j3GGRe/83+943rYhiNpWx/7Rza0sEtKk0gHnWRX5xP3DdNrnXcgI9/Q4f + S7EBkwPZ1VAMN2O8DTbFiSAjocGYLM5SAr4JZX9LAr8d2R0n+u0uC4kIKQJWkoIgAt5MJFm1HcLpWpLx + 5O1buexv7gK87BdgKs57O0UDnXciABlZg3YigabbCtIVHp8l8J8E7vN7LfhNV/tJqleKIy13boLkCF2P + N3fo+rbylpuu60ZE0KXg8BffJREzP94RAVcgb2k7+s5O+ozXVyE8pO+7dlDAvgIcKYgNGZpq8/uATB+2 + tEQ5c9E/voU6L5KtLQtQEEDZYg2TQ9ojGs5qjMC5aSNxauZIHCcCOD55KE5OGopz00fixSodCOQ9BZJv + Qu0W4BB5uqtHFDYAHTz7NCkagiRdjX2iGuj8VaUQMxLP+jJeQbgK4HbhXWPg49OUHaqAUpK1G/1I/q8j + wJDc9eet/YZiAxhvC7DgJDALAmX+twaqeKGnjga9SXiwRE04uEY7guH+exaVkWxdecw/7dza18Sx1o0k + /8sCRz4LWnsCrosgeJOScbMUFY0TAduBAO1E0t7RCI989dBoqQEsHwEYj6GYQQSgKyofF/rdLmSDfAj8 + Udz707kpS4NwcieEO4cp0ZK3F551yf6On4lWtGD8nLeKtkCgc8xtACfbhpsEyEuQPTtNJHBMtBA395EC + IEI5UUxenZRYcTykeVHoOFoJ+dtnCjKXvvtchcqT/qptR/qz+hO62noU361oF3qpIB6h9S7kby7RdT4i + CEdzhJKSuJRJeaHf4xyYYa4/W76DiCBPOR38P1ABxLI1RcEKAki11tbbtWjMvesaY3BBQwXnZozCGY2R + ODt5GC6RJXi2YAJkVgsIjBYETjcgn1RA/TbgXDVlkBNE9vfo2r+ky95MIflF8v86+3dlCoUC4JXlZ8/I + s0ozhMb7ipt/ULNDtAFRZAOCiQQCiAS8eMYkwGwg4JjPAkwpO5pMQrvheDzVH4eGeROICNRwden0jQzo + rrcniFn+kwjAriaJbdgXwRiev3c6aPXyjg0GL7CBsvgGOn47WtosgGy9JuQ2PMPTa+v10Wk8DbKlo4gA + xhL4pwJriABsCfiOi8QeDzfe8LcW2ETSvzAO8oN5EK6TAnt9BXKS/jJ5O7hElyu6WzvwSwOdtIsEmrss + wEO6Vrcpq5P8f3UeeNKV/e/Qeb9M4D9JpL43C6Dsjx0REFI9IU9ygVCZDtnbq0TvHV3KTaawGvzacSMn + VxCC5C+us/i9HaIV4N8tuSeS1bPzkF3cLeypyzjqXRJuoFsU+GckLGMLiryZV66jEpj/qGJakqS4Weew + Zg8W62U4rt5A7cyN6Sq4NFMVF0junyMCOD9lOK4TGbw2mAS5OWVfF5KxUXZiHzbvfjpapJjei/tJofMx + VcAGRev+z1noLyTir/2i5JdGQsW2tE/nSwhPSM4eIwlauJEqu5/YYBZIntebMqWbgagCLHiPAIFnzRSF + FXi9RB1vdcbh+UI13FoyfQtD83urdwUxq38iAeyJs2VWBzb++ZK/aYKwfoEcNgR0a96iTzbGQpvOJRGA + JYF8XRehLVUHlqgQAdDSRENs+XcgwnVZDMGD2wci3nhXskcxQF02cKFeoZiEtkeUiFuIAKSKkNN5lXMi + EMTW+Z8b6rgcF54THrn8v0mCgDLxC5Ljj06I1usqfd7pcpL+OeJ1zY0CUn2BODr/AatJ+a1Fx75cdLS+ + VmR+uaINQCQAbuJk7xTBXxBAV2Ogwgq8on/5d98QuynvHceza7WNx/Zt25W3I9gkcKvL9+zAArY215dZ + lESxNcXBzHKH8g7Fv28vQFE8My8NY/GxJixg8/peZ+ZP3nd9FhHAXIpZo3F+2nBcmDYCt2er4pXeBHQY + TYVgvUDMRGk+JBHJq+/llXEXVSSS7613qEK86rrg7yT/f0QAnb+qLO8qShPJRMoSN0mS7s0HcmKBBC8g + jKuAVaJvdtADrLREf2wxDYKxJtpXTMKbBWp4ZDAGN4w0dwxuqvvQpSyEra/459wUZLcrkeGDL1hsmudP + V52X7xEsCfQ8OHFZ0LGbzYGwggC+ei79T79jBWX9paqA0RRaJ/9vTgpgPdkcJ7IAHoYQgkwg8EZR3kW6 + Nw+4SHL9CWXSFpLV8reK7M/B/3PvC61LBNGGKVSWokuWFBa3ACTD8fY68PIC8PQMcJey/9U94i3WBwuA + qs2k7mIU3ZKIdaLzbkbKawmE9QboDPOE5OJJ4u12RZefrIsAOPhl767rv7nmki7yoXrB2wJ4D8QrbgNO + Abf2C9LjZR03q1IuZO4M87Er8htsusPnd3bR9swiJ4JZZEcqQfp3twFlQcw7z52trQv55IL27MLrs0fj + gs4wXJszCldnjMA18v53iQCezVNDk7465KuoYrqtEsfm74gUK8zxEn4xSVbShZXy/uc3ouRUtARL/oMQ + CUD4WQV0io1V0reUIShDXSRVUUtSdDt9RyJZjgjyzv4mlBENCRwEJsqgMCGgmMyCYDIZDQYquGswAleW + zyhafyDzk7jtwcz2n0QArruTFLaqNNB61DMzvTsCB705j5mQmc1E56oZRFqzIDOl37GKQG84jILkvxFl + frNpJP3ptznqiO0ewZT5U9whK02C/BjJc36rdCP5eEmLSKKknOTyTkWrCu91UYS0KxRmgIdUYc0gJwJo + IZJ+TeTxlJTWg+OiejtTLY7BeAf+DA5+B1F58XEHVkRUK2dBvmQh2jZFQfbmrkL+SxUEI1XIf/l/SABd + jZDyN2IbBLcBb8l+PD0pEv2V/ZAezJW35Ma+OZ/iXeyb5TR/+s7gT6KL1RmrP8N0S5Tdg39nGxDAHAp9 + mc7JhN8dWqwbcl1bRXp1/mDc1hqFGzNH4gbJ/zuzxuCx1hi81h2LziVUQe2oUoRYA+n+QEmyKBsvkQp4 + QnKy9RZdd5KawtsuEninBKR/FZKfBwa9awcQB5S0Q972gpLFBQi8YpZvFmcJjncUx/57khx2JBVgSURk + Ok1sLFs9Ee1Lx5ICGIHzKzTrAwtjej/cYMXW/RN6AfhMPz7V8QoCqA221Hy7al6j1GSGQqnIaNlhPJ3A + r4HOFTOITAnoRpTxFxP4l6mK3t9qJoFOV+z5CF+nGCGIyhQJTlc24tGZ52h5+FiQNT0kAFJIH/AlEUAD + wVEm8G5VIgCZXFQCnFylFBLeG8N7CGQEwGbKwC8vi4rtDkn/izXAYbJx1RniXZb8vgR+kxInHsr8fNCV + YDoDbYYT0aw9BY+sjdB0rEpBQLytRxzlKfbm/PsE8I7cG0ULIiEb0Ew24BUR0D06hht0DKdLgYoUvMoM + 7Di8yXn/thSXFS473D/bmuLArHO8WXqKsxKofzcbUBrArMsoU+J0t1LbVUtv6qu/ujNvEO7N4tl/CK5p + DMNtzVF4MGsknmuroI2sgLCGMpcXZeME8qQ50UBNhngR7x4gdicVwAf2KKxA439gBf7aK4oh6+ofkAut + ZAUeisNaeU9DySbKSlQxIykrBZmLDYJ8hNxaAv8qAo3xWJLU6ni9aBTOrdQ8Hr4tZBQf3biu6h9PAPa7 + NrHAigim+bLovT0RFubNq+Z0SldqQLZiOjqWT0MzyfyWpXwcw2QCP/f9Eyj7j6cMS+vmk8VuP+8VEKJs + 5cKWwHZ5edpL2YmyS7J7x6vkTXe2ymQv4zvkzZGdQkdEpyCJ6JC1RUtkrSVt6LhEYGzqlMvkEvyqpV7W + ZQGkRACKQTkEvmcXxCnXrpH0P0nXrW67aOcyiWiT6JqGW5H1WAbY6CjaIzqWqOOJ/hg8mT0Gt3Un4sW2 + aMgbnxNZk82Qid/Fv/U/JoCuRkhFO8Aj0Sq+vSi29/B5Hy8T0R8mtVccC1mSl/RoituJiB1uq613uH++ + uiyAOW33YWvzlU+E+rsRgE1xBLs8eyiLjrIZdnrJ5BNP5wzDgzljcJUI4Mq0wbgxfSjucwLQGYum+eMg + WUmZy3mpeFfelkCgjFTAYZKQ1+qA52dFmUkqQMCbrhFhvxotJvy6LeCXUPQr86wl4dvRPrI3iq4qXD0I + 6ZECyMqTgFQ/CDH0nYHGEDwNIbfhsporADUC0BR0UCW9bDz9QkyK20R+f8P6Xf/4RkA+39/e+oXMsyry + D8fdl8Y0rdSQS5ZPRccyAj5F47LJaDGcjLbl4yAzosy/iPv/ceT9J4v3PLiskAphzo9bM0P3Pa5Iybiw + b7vnwSM5BrWnikfXXN7Vq+LGnu8Kr+77pvjawe/Kbx//ofb2yZ8uv7g241HrE4emttd5bfLmG1I0dkjR + qhixpxgQpBiSTZZB9kxshefen0+vdq4S2EfAK9tIdi5M7GGIsBbVxwZdyE010U6E9Up/HK7rjMSF6YNw + VWMIHriYo+M2AZg33HaNAOS9Ooqenb8mAEEke3EwEl1T+XOxG5LsouwFgf8BWZCrVG/OVIqTveQloCPZ + VX4vyu5y8UZnB8vCoK/PRK1m3+/PZetylROI/H0qbVEUwzDGfDLdPjm8Zu6mJ9qq8nu8IXDaEFyaOoiU + wFDcmz0KT+ep4c28sWilDCa30RNHs/EBO3lRlEUygbMV4ogy3sjU+ZgqxMtf2gGEvwL/vyEA8aYhnq34 + TURSoYF4gFQAZQnh4m4IvD0gN5YkMVXSSEuxT9xpoXiTkCmBaPkUCEvVccN4yo344NWaXAFsqPzHNyLZ + ViYx90of5pfn/dn5NdrljZThWxbzmIgGirf0f9uSSZAYkZJaMpqyP0n/Zeoks+fgjavh88dRNnnN8T5G + b7eEjDu5I2xQfm7o9zF5IX8YELaqG59AlMdfl5jCpA937Mn7Ye/5/ZrXrx+Pb7188L702S1yU6/ovIpt + MXykppy3AXAC4C3/l2qBI/ni8xf4wK5Ub7F3h99p6aAH+ZqZaKfjfK03DvfmUjLQHIGzkwbizLjeOGsw + Ha/qy7tGHYqNjiL4/71eAIlo7wQ+FuGNSELNdxUNgcLzo6QaiYgu7iUCICtyhKxIeRopEX+0xTvKb8ba + Xa9IsrMP3+L4NTynMKNCP6ZXuk4J2L8HAUSmO5ANeN2tdsMSk/sLJr2+QZ7//NTBuEBxRWMo7swahUdE + Ci+0iQT01dFpTh7cfQUQQ7J8axB5ON4lWEiZZT/w4iLVufsi2wviEGH8egBJ12jAX3oEurKEoqJ0UHVq + 7+xEU6dM+kxCflVKKkCGA2VylKfLkRtKMtWRVICFKFN5t6AV2YBV0xVZ9IHJ5CdbPA0XcgXgWv6Pn+nW + eH84860IYOE5Ht/dXKp5smnxeDQumoAmAv8bWr5ZrE7AmkjSn2IRKRejsZAvnyy0rTO4fzXEIjyvyGco + h3hTRgi7lRnC9mwPYrnZQSywOIrZVcQw6+oEZlWVyKzLE+j/JOZTs5ltLdnC2o+fYt+e2/h+abD93FNu + ay7cSAiSvD1QLgjPb0ImeUWESmQgf0IEcJXkPwHvdIX40JXCrkY/fh05oTsvgdxSSzHM+u38sXgwezSu + zBiBqxOH46zaQBwZ9SMOTRmOB1sTIbQ3dDX+vRv0JfnVIKSurl6IDZW8F0JhCyWPFaMQ8ZKs4sMjfFQg + JQ5SAad2EwEUioSUR2ok2RXyCGvhUqz1lc2bnSztc/0/37zVn5nn+jHrbOWtw3/z4lTozzBwMNvuv3bU + SROtkxcI8GcmD8F5Av8FsgHXZ9BFn6OCJ0QALxaMRfuKaVAMbglZR9LRByiIFQcG8S5BPrS04Zo47lzR + FvBuhFrnvw05J4c2gUiiXY7WNwT8m53C2yMyyctj8rf3zktvnrklP7b3sXx/+QvZ7m2NKIwXsNWXVICN + on9aMUTYhiwJZVDeiPbGeFLLHhdDcz4YKKT4H0sA0RXxzGxfDMvZ4s62ZLgNv2eoeeONnoqCMN8S+F9T + vF08Dh3c8y8kz7+Q/P+KOfIGu6Vnq1JszSOLvL4rygrpnlQewnRrI5hVdSSzrYpljpUJivh3yZtIbkN5 + ONtQEc7uakxiB4zmzb6yYMLdm/On4IGZIdpS4ijDnobw9i7kraTMnpPvvkaAO0jZv4xs1RZ/scWfjzMg + WydYaSuu7auF4/Fg5ihcmzYc56cMxSXVoTgxoj/qRvTGHtV+uORujc4XD0hZyBXDg0Xylv47Xbtt4khE + 3ijMe4j4IKQXl/nNXwKuHxFw8YCgAP+hEoCPLq1IEO9w3Ex1Ks4a0iAz+dVI25M+O1yW6RT7foLFYKtz + A5lJjpIE/qbFsjyM5YVbschtPp8ftZqfcXrGSPmJiYNxVmMYzpENuDJ9CKmA0XikpYpnOipopkosWMwF + vEzpQrmKU1px9j5RIo4pf8lVwK2uIapvu4ajtv1cIcgT8jvLqPa0kFFtfiyXNxxv6niWc6/hht/dV9dW + 3Ht22fD+rePL7h+uNH5YmWt5aXemz8Xs0F1NofbtsjAbyCKIeEIsusYGiLcHw3w62k0my094rvKfcW/P + RzH5kYpbnf+RBLChKoR9gRfdisNs591bofX0+cIxRJjjKMbjOYHq7aJxkBiS5184DjKyUrftFty5GL5u + 9fl0lz/AaRUry/Fmb0PXs6jq//yQWLM99L21YYrfetBi4dqbC9VaHxDxvLJdjM7NJO/3U7a/fBAC7/a7 + R1n3bLU4sSof7MOnVgsl3++2XHEO5as00ECe/xEpwOsE/LPqA3BybD8cH9Mf9QT+yhF9UDesB46smo+2 + x7dFAuCDjv5iYJei4Y+TulxAixzyBjmkz9rQerMZry62UYLowJV6iXCmWiKc3CkTjubJ5XszhfaaNNnb + yo2drUUJcvnWQFJ6Dopr3BC4VnI4wmK3f4antmlOyMdnIk3YooIwZlHooQTu36qsogzjVuZDlejSe/U2 + C0yPTB/56siEQTg9dSgRANmA6cNwa+ZI3J8zhlTAaDRQBZOtmkHgIxkeRt4xjbJyCTH3gRzgSh1599MK + vynw0V/c9/GxATwLyN9SxngjF2Rv38qlb663tj7Z8/LVrcR7986YnbhQNynv8I4ebnkBH/3Ze+b7bCXr + ztxZN3bi8+6/v+Lz++3+qxZeWzr7zoMlk3F/1TS8MZ0Bybq54n3yfEit5UwFCZzzNin2LQ79Cd99xZxr + 4v9h5zCKzqH7zlBm8aD0d/nOxhbXDWe8faw3Gi/0JuCZ7ng80xuLtwZjIVMoADW0Gqpj14a5pd57wnoU + 5HsoAByy67/2lB6H6kTmVhDDgmrC2ZIHuX+qc12e+GDlZHTY60JIIKtUtgnYS976ZDWEq/UQru1VjCcQ + ylLELr9Ye8BvtWKYsrB6FjoWqeM5Xd/bJPsvThiM42p9SPb3wr7RvVFFUUYEUDP4WxzQm4am+1e5BSCQ + d0pk8nZK91KJGJIWudD2TCJ9e7+t4/md1ub7V1tfXz3S9OTErqab++obz1Tuf1W/rf5l5cbqF5Xxe15W + RJ18WRp+9m5e2N7z2eE7720NqmtJ8bogS3S80xlq+bgzwPLNi2DLl1uSPXb4Z3hNNMl2fd8u052tKXBX + AvdvVdaURzH3giAWGriW+Sc7j6qepX5m78TBwlmqBGcnDcfVKaNwnRTA7bmj8Xi+Gl6SP2whIMr58FYf + E2JrNyC7a2DQmVJSAeTtHpPPa6BK0nINHZ3XIGu5JuDVlU7pq4uPmx6dqbx396jv3gtVuhkHt/eL2pn4 + kb7tIkVDV+GZEhZan8Kcd5P8rY1mrrVRLNt+KdtmubjnqaUz9tyeNxQPZ4/AEy0VvNRXQ4exJgRLUgGW + fJTdDLyy0ribkbZWf/rlXe+v25XB7MvjWeaR8r/7OfShY3arimCrX+363WbHJZZX9CY1PFughuc6k/BU + bxyeGYwh5aQKgQhAShbgicFE7F8+I2/1oZiPjU6EMvva5P9aD05lOFu3O51Nv5bEZp7d+kHwzpCpJ2I3 + HG3zJmWUwOcZJEIuSecPV4Vweick9/dC9uQkJNcPQcavUyKBP2QFBGc9yNbMRvuyGXijMwG3Zo3ApanD + cGbsYBwe1Rd7h/fGbsr+VcN/QtnQXigc9iMqpqjh0aXDMpnQ/roDbdc6ZE2X5Z1vr3a0PT33uuFO1f2X + l5Iu3zvqf/zSbtf6cxVmO8+VT8o+mtcrfU/GD2nVm75JL4r+Ii87+JMteYGfpRUEfp2aH/BNUpbfFylb + fD7J3Or36fZM36+ztnv/sG2rz+jdqT7rL8Z5VbzxtttTH29v57nD4evCJEtmUeSpBO7fsriVhrHQNC/m + tyPw253TVctr1Ad0HhnfDycmDcWVyaMUjUE354zAI+0xeDZPBY0GEyDljYEuvEuQJHkG+clS8pX7d5DM + 3Kl46i9uHYH8zlFBcods/b1jrxtuHz5583JN7L4D2bPKy1O+j88L//36zS7dUusz2Mbdm1kIZdGkHWHM + oyyK2fE7+iqCmX1FGCtxWsk2hdl8fmb5rNzbuiNxV3ukoj3isc5osiRj0LSYjoUPCqLjkVjMkRz2Ntrk + Vhbw/YnCScyUsqRP7t//aUFe9ZuYx64otvpF1QcZ7ivNri6c/Oaprgqe6E7AAz1VvCY7IDEYB/nisWjW + U8M9ItKDhtMKzQ/Ef6R/yo850v7/qZ6G2ghmUxfFLOrD2LEkG4Vy2JjrOfhEknPKq2CbBlkkKbLUQEWX + GqozyV+XK4YPC48uiDMGNd2C/O5RSAoTILiaKKxc+/LJeKWnTr5/NKk9Un2Th+CoSn/K/P1QSwRQNawX + dg7vhRKKgqE/oGLiGFw5VvXoReuz7KedLx0eNz4wv/Pw4qoL1w/r7T1ROa5g15ZeydnhX0el+XwZlOr9 + J6tEx/eYyseK41f0ZOT5MpRGM1boxdg2N8byXRkrDWVIC2Fsbyxj5zfRug9DTAzbGe/6x2PhzkOvB9vp + lqa7zYvL9PzuEu3jvtVLCdq/ZXHmBLDVj3kVhn6WP0tta9WEga37JvTHUaoMFyePxEWNobgxezgeaI3G + UyKBN3rj0b5SA4Ktntggl+gCITtc0a8s37MVwpF8CCcq5dKT1U3tx6ouPzu6M/Pk/lyT/IrkgXplHh/s + rdnKsksSWfDOaMWwXZ/y2H+/gXJXNMuPt2fh9Ykfn1yltenWQlXcWTAGD7VV8VBHhRSJCp7OG403BLa2 + pZPQaqqFGw6LrqZl2OuEnaz4wHLzOlZ8fu/f/fy5Uwb3ro1hK19Wv78tYM2KawbTXj7WpeMk/39fj0iK + bBNv/GtfqEK2YAzuEIkeXKxRvG5fwu8tDgYzpz2p/2/JXxnB1l6KI88fxZyqglnFFvc/Fqe5TKlNsE1+ + FmH3FMEbxP78HVGiGjtaAlw6RERM4H9ym8B/hxT6Q7LrTyA7vxdSH0d0LpuOBrIkj0jdXadrfH7KIJyc + MBD7RvVBLUX1iF6U+XugaOiPKBjWE/nDvkf5xFHS7ck+OVv2ZI8tuLP/DzaFob9jTpPeZ2NZdw7wA/sK + WE5hAkvfEsyStgSxAP7Allz+NOIQtoY/MaokipkXR7I1JcG0DFEEf4gMjzVFYcykKIStKApkttl+rCzR + nb3yIYJo8X0vIdv/9zkbA94/SeSREK0kgL9td2B5GHPJ9mf2JaGfbF48Lbx0wuA3dZMG4OBk0QacnzYY + 12YOx905I/F47hi8ogzGu7dk/CYXj8Xirbt8ltttQUBuBKRVibK2qq1PbtRlFO6rSzfdWp04yKMw6CP+ + XfEHU5lVrhezKA1iU/8fDV4bauNYfIEPW9W268P61VpBVxeOk96ibPqQvv+RDo+xeEIge7aQQncsTpvO + Eh6v1Wo77b8iIfnQ9q8D40zZxebHf/fz51KbxPzq49jnQLftEdazryyc8uiezkgFWT1aMArtumqAzji8 + mT8K9xeMxi0igP2GmsVOexI/dqmPZK71/zEB2NQks/p0X7Z8fxpz3RXJFpxKfc9iT3iPso22Vs+D1x+T + +1i1CZEE/lRSYbnJwK4sAj95/Sv1wL0TAM/+L29A6Hyo6A6U4g1kb5+irSobb9fq4MmcUbihMRBnpwzA + sXH9sF+1H2pG/oSKkZT5KQop6+cRCWQP74kdQ77D1lG9Gn3cjOzXVcZ8vvP6HlZz+xBd0yzmXp3AbErJ + BhUFsNVlgcxiZzCzJWvpmOXPHP6b3Xd2hY7MtMieBRS4sMwsP7Y13Z/h1g4WkagkgL9pWVcRQRfJj1nv + iv4o0UbPKnfS0Hu14/sL+ycOVMwSdJYI4PL0Ibg1c4Sif/iZtgpeLxiruLlFceuqpwkpgfVAtDOQ5CV/ + mRN++1RZQnRFfsj4bZk+f/JOsO/msZN8a0kI+/G4/X/6uDbsjmcB5f5sMm6/X2Cts+6K3sSme/M5AVD2 + 11El8I/DUwL/04UT8IxkbInTYuH4unnyWxv0zhzM8JtmSoAsPpv/DyEAn/pEVuJvzLJibIZf0Z108868 + YbhHlqVhgSokpJiadel4dUfjNh3/tbmq2LNkZqH37sRPgsg6uNWl/fufS+9xmR9f6sZg1pfNPJ7z4cEE + G82HQcs3v3BbdL/D10ymmGMwhcv+ZMh355DsrwDOEfhvHYXw/Dykjdch6bgHqfS1YuYgOe9+lXeQLbiM + hghn3J6jgnMTeuPoxL44qNIHdeT9Kyn7lwz/ESVEBArwD+mB7aQAtgz8FhvH9r3n6b1S2/hO6fsbKKOv + KA1TAuj/erEgAjAvC2G6r6q6RQebTts2ffTRWrWBsgPjB+KoxnCcIQK4pDEE1zVH4N6sUWQDVPCSsnDr + 0qmQrpkNxT3vDssh8zbDqwi7J+c2+wan7wzvp3YyrHtBXjCLKwhlqytCmUvpf236J4e6JOa8S5y9OMPN + UPu6/oyHj+m7H3N/TRbgid5YRfZ/qk8EQJEbYIat+mrCiYVqjfvD13v5nNr6cV5+AFu55+/fDsAJYPtG + G5aZbN/7yvxJVzgB3NceinYiqXYigKdkCe5R3NAejctEALuXzc4N3J38aXRNHHPZ/ZcKwK88gUUWxzGH + XUkstDqSFVa4dK/MdPipOtnO4pzvqkPtLkvaFc9FCLLmhCtm/roCCMerIL90WLxz8OV1oO2BYlJQGV4S + 8Nt+ntKL33khdLwQXpdulV+ePwnHVXti79ie2DOSN/j1QdmIn0jy/4jCEb2RM7QnsoYQ+IeKETtp8MkN + boYjeCerZWWMEjy/ibEARABrqiIUd7K5bLTpmz5vYm7tmMHtB1UGYe+UwTg5dRAuEAFcIQK4PZPbABVF + Y+Bb8rWdSzUhM5tFJKCNN3bzhJ0Ja4747AqZNqMiuntIVThp/tHMu9L+v3VcjvXJzJGOa0uoMYvdZDvk + 5qK5p17OViMwkQqZNxLPF6jhpYE6nuuLfe3FvqZImD9VKJw6RFZvt7DMp8R3IFS+Y4sO0Occ+fsOD3bf + FcMysl1YaobLjxfmT7h0R2sons0ZgTayKC8p+99ZqIpbpAaukd++qKUilC3X3BJUl/JpQt1G5lC1UfEZ + njUbmfeuTWz93kRmsseNjb53hFkd2vrH4CL3CUdjjFI6XBc8xgZDAS6ktkJcgfRQoCiFwJ8PnN0N3DwC + 2csrEPhsvB3PAWmTAvSQv7s5iENfimY0CnLp245LB3c1HtKfITuk0gs1Kj9g97C+5Pn7oJiAnke+P3do + L2QP7Y3MQb2QOqgHNg/tI0ROV62xCjHrM4lI2WFnrBI8v5ViXhnOMnWnMtts708TjecGlo4d9mrPmIGo + nTwYRyYNxLlpw3BZc6TiVuH7WuRttUbj+fyxaDSYhg4+xt1kAtqNNXDe0/h0cnHojEEPiruvOxDLCuO2 + /M8aKMsjWUSOKwss8PryhNG8whfzJuIp+evn80bhBSmBlwvH4oXBWLxcNA57HPQRN3sy4oYNlGfpTLic + FG+/0HlfwoeRBXHMcm/Q3/X8eZMCSCp2Z8nb3b47pzPhAr+r8vW88XhMGf8uHettnTG4Scd7XUcN52aP + kuWunpkYQAQQW5PInGtSmPXBWLbkKdiKo0FsT7oLG3Yj+nfbsjxH3o1Y5/bS0/j4W8dFzXKe9QPXAXGU + 9TfHA6VbgX2FwJndkN8/C+HNA8r6rxXTrPE7K6Xvbgoi2S/IXpADeArpg6voPF0rf3qk4m5ZZWZNyYq5 + z+pVe6N6TA9UDumLgiF9kD+4B/n9H5E1uBcyB/bE5kE9kTSwh5A8pG9n5DyNTOtNTt+e5o20RcqZe35T + BBCe4s7srxV9EOu8fGnO1NEXd40eIK+ZOAgHJw7EmSlDcX76cFyePgy3yQbcnz2SZLgaXulNJIk7Fm1L + R0O6dCIeWBq8zE11cbfbF/2pZ2ks86iMZI41//2K4srHKezyZXb1kR/us17s83DhlI7n83lDpApekQJ4 + pT9WEa+JBA6ZTEP8vCkIGzhISBw96GWq48qQ6JKQ79K3BjC3+mBmX/X3k6x++zax8Ao3FrfD/asz8yac + e6itRiplAq7OGIzrc0fgDlmWW6QEbuqMxfk5o6XZ1nPDfPek/DmiJp651aWzgksFzH5PJLM6mdAtOz/g + 05qNTguOR1rnPfdc8RzOBHw3U8r6G4BkP5L88RAqcyHnt0xfqic/f4Yw/4BkfSMEabtislW5vAUyaSPQ + 9IwswRXITlWisWQz3sb44J6fdXtdvPO22LzI+Zmm82uqx/YXKkb+gNJBfcjv90HOoO+xjQggk4CfMeBH + pA3phYQhPYW4UQNfRi6Z5+ZQn/iHIN+1zFM5c89vq7gWh7B5QDevKCuVlAWTy0rGDOqoHj8I+yYMwvEJ + A3F26lBc5GMCZlNGmz0c9+dSFtZTgaCvDsnKCehYQbF0luxAoEm9c4nnZOfayA9ca0KYVfV/Xyo6lYYz + +wqyEnjTLS90jc6VZdMePScgvdRVw2uS/Yrx9gYTKNRxZelkJC+bgqhBg4X4/gPbs/W1KlPSncf1QkE3 + n2qvvysB+O7dREB2Y5E5Hl9cWDDl7P0FE3BlpgpZp6G4rjUKd3XHUqjhNvn/i9qqndmu+r5uBzb9ybc2 + irnWJTOb+hi2/mBSd6vdgb22b/ewfumz7pTguLwTzoaAH4E/whHYSJK/IBXYQ37/FPl9/izA52cha72L + DjSQ0u9Eu7wVguQ15M9voPnUbjTkJKE1xA0d6wwhX6kNrJiHpxuWXMtOWb9E79a2PydaLwosmzi0o3T4 + 98gf2Btbh/dF1sDvsJUIIIMIIHVADyQO/hHRw3rJwieNOO9ltUhnJR51d97iwVzzlQrgN1UcyyNYpJsu + c812/2qT6dygAvVhL3epDcLeCWQD1PvjFNmB86QArlH2v0kS9x7J28alaoDhFMiXT4N81RTIVk7Ga7OZ + DSe8raNzSsN6wsCF2R6MYd61Sf99YqqIVrRPpKfY9rtgOnPPC91xeK43AS/1J1D2J/AvmozGRRPxZIkW + chaPQ/TIHggd2EuWNH30+a0+Zkarbhd84Fsaxhyq/34E4F2XxNYeD2S+Zb7fXF4849wFrZHYP3kQrk8f + rWhpv0lq5T4RwIPZqriqO76jIGi5i/OR1D+61UUxRLmw/g9qP0gujlA9E7Eh/qW32V2J9yq54iGowZaU + 9T0hZEdDvmsbcLgUOF0D3DgCvLgCNPCJNl5CLn0OacNNdFw+CElZJiRRXmhxMkbDGm00r5iOtpVzABMt + 3Hdc/Kom3TU4vijwB37n5EaHFauLpgx/mz/4a2RxwI/qg60DvsHmIT2RNuhHbBzcE7FDfhQiR/VujdQa + l+0esrZvgMFU5qK8R/+3V1Jzg5lXjjtbc2fz+/E2+jpZU1VO7VQbJK0d1x8H1QfglDofFzAYFzSHkwoY + gWckvTtWTQL4RCF8WO7KKbQ+kchgCmUZwxsHUh3XBlWEfvIyZCnzqUv+bx+XV0Ucq/NbziLKPP9wfL1e + 2MNFEzteEeBfLySy0afgBGA4GS+JAArnDUfCmJ4IHthTFqHa716a1SLP6H1pn2zaFsgcK/8+GcujNpl5 + HkhjWUVebEuB7/Dzy2df3TOxD2rV+wg3Z43FbS1V3NAZgwcLxipurb68YFxLXugqE6uLWR+YHorrFlcd + 92XRjg06RxOt85/4rHkrd+ePRqOsH8anA3cXnwTE+/ePEfjP1wHXjpKsJ8//5CKEexeBqychPVaJhoJ4 + vPY2x0tTPbxePBNNS6coRvrJVk6HZPVcNFstaDnkYZiRUOTbn6FZ0buSEGi1IH/qqMe5g77FFvL+aSP7 + IJXW0wj4mwZR9h/WC/FD+8hDxw+5EbFitqnXzrCP/Da7s40xrkrA/NbKil1RbP6JjSwoeB3zjbDrm6qt + sS1XfWhTtVpPhQo4qzYU59WH4aTmKNycMxJtfCZbU00xVs8Q5+lbKd6fLzEZKznnuWTXxm3e43hFs9q3 + mTn/NwHoXhHDQov8FE8zLvFZb3B5xbSHrxeNRaPeVAL+DLwm8DcZaeD1ihkonT4Am4b1RdigPkLosL5v + NhrOSd+01bfX83GqzLkq+u9GAA77U+j4pN3qkp0Njq7QvJc36if5UY0RuKY1ns4Vef+5o3FPTw0PdUbi + soF6Q1aUubbN4+r3fOoSfgzb7mV1PG75fpn3gjY4LQF8jIEgK3FS1JwwsbGvjsB/qkbANf4Yr9NEAsch + PV6JlsJEtIY7oNNmGVmwOeg0GItOOi+t+tPQupTPOaCuyPxyy/nS+x6mtSmbXcdyNWVbHs5UcK57QIrT + rOwpY2/kUPZPGfwDMob1QdxQIgJFw98PiB7eC4kD+3f4TB9b6hC7fnjokknMcnccM65SPsjjN1lMdocz + 37wg5p0f/KeYVToO+WrDHu0c00vYxXsDxg5U3B9wcvpwPJlPlYt3//Gn9ayZJYYZJwIiAGM+bfdUNK+d + /fp6pJV34KGEj3cWBzKE2jH73f+9e/VDdgayM+tMWU68+6AbJloHnhtORMvCSUQAU6iyUyyZhreLNVA2 + uS9SqRJHDe6LkAE92yJmjqsIDbcezUnIreLvowA+P5bJEncHMYeriZ8cczEPK50z9vVOlR+EiwT861pq + BH413NBWwW1dUgNziDznTWzJSl3vsKk6cPaxBNvIVx4rb7a4LpMKrssB91VEAJT5w12AzQT+4nSgNkfA + wZ0S6ck9Tc3Hqzua9uwQOtNDIPNdB4mFHtqXTkPHYnV0GqqjQ38c2g3HQbpoAuQGMwn8cyCs0cJdZ6Pr + pan2q7zrIj+Mz/diFtWRbCSOd/fKcJmSPl314uYhPZBKgN/SnwA/RJT+cUNpfVhfIXRw3+fui2b4OGf7 + fBbpvZTZVSi9/2+6OFPlWPu6onuM6yrNnMkqJ4pV+kp3ThiAfeMH4sCkQTg9Yxial/AHdMwVCeBdcBIw + nyk+vWfVDAhm0/DCyeDy4UCzZcXlUb/fkx3AVlcGMa/KlP/yMXnui2VF6d4soSbhs4tr9VIeGU6VNy+e + QDJ3ItoNpqKdCKBx0TTsnNAXm0kBxA7ph4j+vTpCxg3b4+++YgJBi/ns/NtXXP99WSxtdyx7RetZ6XYj + K5fPrU1S6d26d0p/4RrJ/VtzVXFLZyyuz1MlAhiPu9rjcMdguqwi0eLskQTbA/f8jZ8JTosAO8r89pT5 + /Qj8kc5AWjiQlwqUZQtCTW5z496Cc9dr83PPFSftu7fRsaPZTk8xElMwmgYYTYV8yThIDMZAajieiIDI + mc4Nls2BbI0uXtroPj3iZeIZl+Xw1VU/U/bD3Sgi+mgigLPdPDa7TErSVD2bPOQHpPC+/n4/Ip78f+KQ + Xogd2hsRg37q9FUbetDHdukcz2t57zkXBSkJ4Lde1tZGKhrdfBLtf9q+UHNLjurAxkI18rQTBqF20gBc + pCwmM5kHrNX5Bfh8ufbd8/t4mwB/pPcECCsny566rNxTWBYxjb3O6xZYw+fO72BWdZv+S8e0YW80C6gI + ZrOaSj+odV5lfWfRjLevSeI2LRuH1kVT0UFZsFF/KsrH9kEGgT9+cB/EDuzdGTFm0NFA28UaPmQfgv4O + MwX1j5/NUnK9mdOdwg93Bpra5M0YfT9i/EDJCc3huDFnOG4TCdzQId8/dxRuzRuH21rjcN1gCk76L5O1 + uJsK4E//UUxsYgC4WovgTw8EcpMgFGyRyfO2v2rO37LrDKXvmOKwpYVbHXY89FjYLphOVEwpLixWIbCr + UdDSYBSkS8ZCtmyy+KwB/vAUa/3XZwPNo4J3+Pa46Wmo8P1m9V7MqC6GzcGR7m6bHKdGz1Q9G0cEkDz4 + R6T074mooT8iZnBvRPXvKfgP6f3IY+G0EPd4hx/42VtTEaEkgN96WV8fw2IirJj7wYSPouwXm6ZPGXWx + eGQf2a6xg1Cj3g83qDILvFWZE8A70PMlf4Ivn7ffossK8Pn7iQRklnNanvitzdi+M/qnr15d7B5XGaMg + GKfq/3w/sm19JHPfFcbq3SxYSoqb2hkz3WPPjdTQsHIcGpZNU8y8+3zhFJSp9EXm0P5IGNIHiYN+ksQO + H3AhzGKhrgPQPTArgLnX/W0nCrE7WKL4LYl5XgP2GM8rjRvTp9F5/oi2Y1qThBszh+OW1ihcmzsC17RH + 4IGOKh7OV0UjWZV2JyPIvVdT5jcEXJZACLUQp+ZO8yfpHwpZRnTHw5zE00fLkkOqCuIme9dGjyjI8/R5 + am9wT0LAxko+rRgngUmAQVeQBcDSKUTOsyGsnQ2p9ZzGK0HGGwvT3XpFpziy+Dxftr4ylNlWRzG7nRFs + Cq52D4qw0UrQULucQODnkj9hSF+EjfgJYQN6IaR/r1Yn7fElTr6mGiF7Ut73THFjxuXKp/n+5su6umjm + WxaoqNhBQaZD4+ZOyCwYNaC5atQA8B6Bu0QA8kW8AZADfq44IYclEYC1lvgUXz5DjwVXBbRcw3sJxqPJ + Wu/l6RDrmIycwOEhu2M+KCkLZxt2/ecb5ez2RLGcbD8WxUcG7oz6ZK+DYchjowkdTasmomX5dLStmI67 + CyaiVLU/to8ciOThRABDfpLHD+t/P9hk/lrHS1kf8d/ztySAwAPJLKE+mcWe2Pq7okS7FcVz1K8Ejh/8 + KMzD8PgR/blNN+eMUUykckOLlID2cMXIxaalkyGz0gOIAAT+wFC7pST7rYAY3s/vDWmit/AyxfftzZSA + mgPpgSu35AX2dq+N6rEt38/8UrTV+TbLuQJMZ4pPR1pJQeSHJRpiT8xqbr+0IFjMR+s6nc5bHgYlhxIt + R0OzP6kUH3YoRpxZd+2uGOZYFMJm4WH3IFcTgwT1kbcT+/9Amf8nyvx9ETKoJ/z6/ihxHzXgnOuaBca+ + mb6fhM+fyjxrE1lSQbgSIP8ShaSiZ5oTcygJ+DjEeO6abLWhNytHDhb2jR2IR9qj0ak9EpLF4yHw1n+e + /TkJUNaB9eyuR3lTZVzPyYEq6Gp1Re/AI8sFTzOjLcMj87z7cjB6lP3Xh+fqHMlQHFt21Jq5d5Zr3Hu7 + bCI6l2uibeUMXNRWQ/EYIoBRA7FxRG8k8Uas4f1fByyb7e1QG/OZJ+79zQjAb28yc3hUxJKLg1hyeej3 + FS5LEjarDL7sPGN0TUCcVfBug3nXbmqp4Y62qmISk4c6w9FOx6p4UKgdf84ht1D88d8mgK8d5IGOkAQ7 + y54HbLh7MNl1y+aSUC2XvQl/ctoX86fg3eG6+zY57Wu3WyRTnNd1XefahEh2xWxFKz/WzBFfW6MN+Vpd + 2Qu7RSezEqzma+6P+XBJdRD7/Fbdz8e+piqWeRIBrEXze75mC1bEDh/4YGO/nggf1gfhA3sjpF8vwb3/ + T09tZ4+L3hBj0ztRV4OtvrCN+e2MVuLiX6WY1YQx14IA5sSJINBsVKLmmNI8lREte1UH46nOGLTOHYwG + ymqdC8mHrqBMZD7nFyVgNUfxaCmsowq6lmcmqpirp0JG/vS55Zxb++LNzWdg9/sFpV5sR/l/7RlwjpSF + OHnEZ7r2PLRuYdFzg2lSudFstC+fieOzxyBnZB9kEQGkjeqHpOE/IWnYgEb/BRrhdkUBX9rTb3Ha/bep + xF77k5nnnng2CE+6522ymFG5eNqh4GGDzqwznOLmm+I8o9ZQ69j9+RPxeP54PKbz1cAnU+V3TnLgk3KS + rSEgW+lCsDGEZN1S3HM2f1sVtqFu2zY/67Sc4EFx1Qkfrj2Y/rF3TeSUA1HWuU12+i0CJw8r7a5z/K7t + hRMtJ4WZYlfsmjnyp47LzpTG2q+MKgz+g2+WJ1uVZctsdif+fOxu5QnMY5sXc8SlD7wXaa6NHNrvcUL/ + n3hrP4L79xF8e/ds3jB2+E5Te4Mp/pdz33dLdmIWO5W3/f7LFYfdscw/ej3zzPT4ImrlTK8U9VH3do8d + JjwhKduqMwRvtIahcc5QtOuMhHwpSf21WuJjsC1/RQCKXgFtsU2APHuHyVTZU49ldU/iN6iaP0zvVl/g + zRC6nm0p8vnP9VAQARRt9mQRR9M/rPIzX3tlxawHTUvJUxtpYv+0Ycge0Re5o4dgy2hOAD2RPLRfU5DO + lFiHAr+vTf6GBBBM0v/yrHEsriz223x3w+D06UMfeQwbfNDOxmB+VIqryqFlM8+8MJiMt/oTyfNPhMxc + fFBo54ppkK7QhNxkDlpXzMEdE62Oc+sXXtrjbZ6UvclLK7Ym/nO9yzu72dRH/T6uOGhKZYRV2h23JS+l + XE1Zz+162vCsX8JSUwQ/f3Ky+TxZk5P+6VuBFsYFW3z/dNPfjNnXJTCHXX8p293L45i3lzFzrgz/OHiB + hn/EyAGvw/p8L/gP7Aunfr0k64f3Oe2kr2nhlxP0J18vc2Z1PE1xx6iy/IsV58oY1u+AK1t3POn9wIBV + c6Nnj68vHzes48H80WjTHY6meWPQNGc4mmcPRcf8UUQCJHFNZ4hEsE5btAO8ncBcW/SnxmQFjCbwLsL2 + R15GuTXbHUayFFW2ryKcZe/9z0tzt72bFCogNdNv0D4rnfxHSydJmxdroG7yUFIAA1AwaijZgH5IHv4j + Ng7v1xwxf9pGpx1eX9PREYH8bYYDh9Yls4+Bbilpnqo5K2fWBI/58a2bukqZY7T9pJTEDWrnVsy48XaR + OjqWToVgpg2BzoHUSAPNRlPRuGwGGvQ1cNdgeiupmPqiWGvT8IrAvituFX/waLuvwuJE1Uf33Z5iH3XV + fvFTqS2f/ZjOqdUs8dyu0exSXFxR0LrlLAjrFsqkdsvOPQwxNU7a6f+ng8kbFOcoouzfEp5HeQzj5ssl + 1rZ32KwJBcHDerf79flWcO/7k8xyaJ87lgZTA9yCrfs541E3110xzLNCKf3/ZQlgA7+Rhyqk+3bnnlHL + tcIK1Ic8u6s7Ci0LhqFNZyw6+SPD5oxAC5FAO1kCqf4YCMsnimMBLChb2c4TlQB/VPbqBYpGKiwbD/mq + ia2v3JZk7871GcUrahRlqozS/1wDk23ldhZYHcFcjmz5KDNyhdEN44m3nuupo3riEOSPGoyiEUOQPbIf + 2YDeSBs9qGmjwZxEjyzvLwfR73Cpi/2fN/7VpzLvqjimhsb3tgVaLMmaNv68W58fHtktnJDgkx0zJDfB + evJtE40nHUbqEPiTgFdT5ifQNy6cjAYddTyYNx6XDGe+LfNYlZ+y2UOzoDzuw9ed51novhTmVh/DjE6m + /GFXob/pS0/Tq7J1MwXFw1DN54oEsH4aESstrelc2ul0PSJNR2hzXHXuTLzNyortjn8o3OJM16yTuVX9 + 2/svHCqj2Zr6aNaDyMvNY+Xs6JFDzwX0/U7u1u9bmWO/Xg9s5kyMsQleM6T6XEU3/nyFtenKJ/T+Sxfr + qggWkezBgo+n/y7QYaVuxrRRR2/rjBCa5w9Gs7Y62vTUyAKQJdAag+Y5RAxzR0BCBCEsHkeZXlOUpgr5 + qi1WYhNN8cm+K6aixXRm8zOfJTlNiWtHMzztdqooWJG1gmv//7sH/aoTmPXhZCZ10mB5W22+OWQzN/6i + nnpLudoA5IwmFTBqOLJGDEbGyD6yrWr9X21apePusTfjD7e4/N37P5sdyOVQOvPZk84O6quw2KrIL3LW + LYpMHt3vqV2/7y7ZrVmwPrAu89uaVEeDZ6tnNclNNCBbPRedhrPQsHA67muPxYW5KpLa5RrXK52WRpdu + clXP2Jv6YVWGO4upi2EvdziwCZ2nux/OtJ/0KMKkpsNuoQRrNegcclWl3XUuZ4lEwLP/enFK9GbHJU9v + BVnan97k9Gc4mrGiAg9WmP1v582L3x3F1tUnEfiPscDNvt+4L50T6D9wwAuvnj9JbQb1fLB26tA4DwuD + kcnHst8LCbJhL2gf753KW37/5YttfTrLoaVTolfPJN3JsTd0R7a0kgJo0p2IJr3RaNdVRfu8cWico0Ix + Em1awyHRHgG5/liS/JPEgUFWXd2EvPHLhN8vQLFsKqSWmm0v/JcWHN7hO4bhMdtMmZ3dOcEs9/3/3z3o + vCeOqd+uUKiT/HCraQeXzThQqNK/I2vMECGTLMCW4RTD+ku2qvZ+EG80fckwoLtPmt/fhADi9qYy/+ul + 3VMz3SfmLpp+IKjP5012o/vss3Nfox10JOOrfQk2AU3m86SC2Sy0rSDw603HAy11nJw1UlJnOOnk9mDz + 9W71Yb1VZbXvJe2OZc7HU1l4XRTbWRPzxz0FPrNuRJvkddrNbuXSXgF+q+lid6vVfMr4OuLThC2mQVg7 + B622+g0XvZamZGa59GnyWcRm3ilgJfn/wYMz7p1n3sXBzLMy6g/ewZaLnKeNOeLWv2+7U+8hD2wmqsZY + uusPn9ue2t0+ZT3bNnCEsuIrSxcBVAcx9+Io5rI39Xc+jot1D+qNvfx60Ui8XjQUnXPHEdhV0DF/CJp1 + BqJFaxA6NAejfQ69pzMSkgWjITckIjCZJpKA7VxREfDnCvAbh1bOgLBas63ddVHpiSLfqYvPpf6hKteH + OdTGsqRtjuTZ/+MRg85F3iw7zIZtKwj/c4bjMufkKcNubFPpJds87EtsGkryf8iozozRaneSls7X5UTh + u93vf3Qewg9tZM6HNrPU+ngWeWzzH/MDzddvmzLy4YZe372wmTZkm0/8+hE79sYNue+8ZK90zRxI6Pc1 + LVLFvbn9cH7OYGmVxczjiZEmq4KqYz/ln+dzMJk5Pshlq65ndHc4uemrvcU+pk0hS4/LbWd1Cpwsrbrs + kxWRphmdO7N5ip4DWC0k+T8PHeuXNNZ5m29z2e4yyvJCWnfbzA2s6mHdX/aa1Kcwuz1JzGT/JlJOUWw4 + HnYLyvIa62s+c5vjyC+eWQ754ubKmaMizFxXDt16taS7WYIF+0ldfPagsiiLotiTDXAsj1ZkW59kx165 + y2dkPNYd39lkOBqt+qPRoTsCnfOHEQlQkAXonDUcHVwFzBtFr1PojoRUXwXypRMI+FSh7RaIvQV8QIti + VNsUSNZMbX/jaXTkVpKTVU5RYJ9FJzPez853VVgCu71x/74V2BXGtm/xYfXCjW6JwebjImarF6WOGtC0 + acD3iBnUF8lDhnVuVR1wL3Xl9Pn8c/icAP51iSywOpI57QtnfrVxLGh3PAuqSaD1BOZLEbA7gbnWx7GQ + 2miWWh7Cigv82L4cL3Yk15dlViQy58NxLD/Lm8VVh/bIW6eXEj+6V6PtTz++sNeZkhK2M2rSkaxAhwZb + wxfylRpo1puEp9qjcWHGYFndsmnnSyLWmZYU+v25MtKUxZ7cxrLI6qx+WP5eemH8sD1R67weBa663Gmr + LQW/yUrxxKOugVa8B4E3ovLX19J5W78Qr11WNB70Wp2VE2E7PuRi9ntpuYHMN9eJxf3qGQMOu0PYl+fp + d+2LY3DRZR/Lz7yXvc1DpchvdVrI7LH3rQf3urNas2+0s53BiE312e+5+1uw9eHrmU+B8sk7yvJXxXFn + CltXE860b+R/kOq0cun1BRq3mxeroWnZSHQYEMAXULbXHQ2JjgopgjFEAEQE80ZDqkvqgJRA21xSBGQL + sHA8qYEZoozl7QLc25qREjCZCMFiDu67LL5TGbEmZlt+kErszuD3PXdHsiUX05hb7b/feGdxIoYlJDmw + 8FyvrwMXzfaNHT74YWLfn4TQgQMQN2RA55Yx3z1OWzFO9wOgm8eejcx/70YCfRRz2xfBfHbzZ+vFs5Dd + icyfvLFvfSLz4wRA9iKQCCCu0IelJq9jBbFmrHKTPdtcnsh8yUJskNZ0j9viOiN7sebhgP5fSB369e6M + WLviyLaymLjzcY5nO9fqyySGk/BaWx03Z6sKp/U1b1V5WNgE7s74875oSzZVep/F10WwqEMx76WVBY4o + jLNPOOdk+LB93TxBMWbCeJYIdt7Cv4YAbzIPgpnY5y+QAmhzXvLmsueaHckZXmrfY997Tnuj2YWgVcxy + zy+t9Zb1EUz/WApzqwlhppFLWd4Or6+Kk2z0doebFxYaabz2GdH/ld3kads2eBmoed3e/J5X8gbmxz5W + VnRl+bclqDaRee5NYZ7kV29/RJk306lP5bp52a/0xpIKGI+2xWQDyO+3G6iiTZ9ioRqBnjK/zmjIdFUh + 1RkDCSkD6RwigBkjIaesKF0yDnLzGWJD1rp5IhmQ3+W3ETeaa706Gmm5eeOuMDW9k+kf+O6NZzYHMpjr + 7jTmvzuOedbHMK/6ZOZXl6xYBhdGscDdKR/7b1hgETJ20OXIPr3k3gP7ImboAFnWyH4NcRsWWS26X/qV + 6eHNf7A+kvbRglMb3x//JOP9tSc3/97+6OaPHY5m/NH66OY/WhxJ/8PaQ+l/WHIu6w+2hzf+KXxnwBdb + tjh+X55q07Muw+nHTeWJX9sf3vR58LG0odsinMMLpms9d+3TSwgc1R9l7jadh9M8G5pdVsqaVmrhmcEU + 3Jo7BucWzmwu9LFMjquI7RGV4clid1aykzvGsjOUZZMPRfY+tMk65rnD/BdSi+miOlqjKzaUmk6m7K8h + yn5TPcht+AhCfUgdzBpOJTllxxT5qXvWZ77Hu+kiq5NZRE0sc6+LZp7VicybZL8jkdiWQi9mcCT2d641 + wYMqk22CXq+bffPlwpHyPLX+UtcZE46YB1gZuO5L+aPnDm/m8aiOuVSFKCu7svxlidntw3yqvNjVKwMV + T9zmMSO/7qOMsJV2F9dMed24eCraF09G5+KxaFsyBq1LVNBqoEKyf4wiJPNVIKWQEQlISRF0zh2pIINW + UgTtusMhLCNbwJ8wZDNfHOhCikBqPgevHea9vhW+YkdFlvtsm0PFv3/33fT35+P4dXyb9fCD2CjTZeFa + aqf8e/eQOA/4AmHDP0femN6y+oAVp/Zmu8Xvy/L1vZTuHfAwwSXwRoBl6CVv4+Qrvqu3XPYz3Xwzxjb1 + duKG1HvxthkPfPSzHkeZZz3J9Et/Wbs9/unRneH3j1UEXalMCbqQGhhzOMsvb3eQ2dWsqSOlXv2/QPps + VdwJsMTz4JVos5iN54bTcXXBJBxZNhFlHiseb84JcQrak/WTRX3Rn9ce2vpZ6MHYHidyAie+DFsf8dpZ + /3GH5RTFTVMw1ejq459I52SSqI5I8gsO89DpvgAPA1fKK9LdriUUx9iur0z5kX55t3fn5N26ImT0b8eb + 90KrQ3ocS1634raXQcWzdRNev146RajRGAb3+WOfOPmvjfYuSeilsFgVpGrKleBXlr8q3lV+bF2Og+Kh + jpn79T89dnnlqMtPlkw689poav0RU59bm3TftNtPR6uxGtoNSepTVu9cNh5SArVUXw0S/lQcsgBSUgFy + Csn80WjWGU7WgNSB1jC0zx4E2bzhAO8yNKHKv3au4ln1ipGEa6fjjaNOy7lYq4PHdrq4X7hoq3Pzidm0 + a09Xj7/y1HT8tUcUj1eNv/pomfqV20sm77lusWDnPrOQLNeZ13yHfiuz7fsnBAz7FAVj+uKKp5FwdYtH + 05WK5IePytOeNJamvGgtSXvTVrKppb1kY3trUVJbS8Wmljdl8U1vCiLbO3cEyGSVGyXyM9Vv8ezafXnL + 06vS1qeXpI/O3pEc3/388a70xtMB5pLMiX3h1e9PKFg4ES3eK9BhOwfNKzRwX28Cblpo4EbcYhyqcX5T + c8E349Bt7zXHH7gtO3rc1Wxfpk3AKZ+lNU2WC14rGkKN1ICV6uTz6RyYTBIJwJo8v60hYK8LaeAcdCYv + xMMCM6HgqPPjree9c8qvOdmcerR26qVn1mMvPLEdd/Gxw/iLT9zHXXvsqX79mL3G8bwNy2viLRPOuuhf + bTCZJsgW9sGteQNRuW6KsGWbyavUQ56ZMUe9VRwq/d732BPFPCqDlBVeWX6V+fcHMZfyQAX4009Ef3Xq + icPahgaTvVLp3EttmH1d2rnoqez5IlnnQQ00BfaFdLkq+Xvyr3r8DrWJikdhyw3GQkp2QEpEwK1AxwIV + vNEfhY75IyGQEpBpDYdca4RiXSBSgAEBYQ2BwHZ219BWXQjrdNCxSVMqvaz7Vtay8L4gnX9IkOnvFyT6 + BwTJ/IOCZPZhNGseF1o1zzZ06Ny8cmhee7TOD7Do8R2c+vRH3sgxaFhNQNqWjI4nV+XtLU9kkvaXHUJn + SwdkTTLIGmWQNsgF+RuZVPJM1tn6SCZ5dEsuf3pPjpbXckhb5HJ5m0wib6Vt22ToaJV3vrgjPI0OQ+bo + 4fAd/BP2rZgHiedKtK/Wx7MlBni5ehbebJuFjluLIGtdLQidK1sF6crn0ga9F+17dJskPjoSwXSqeAff + Mvqty0ner1pABNDVO2K9mBSRMeCwFIL3HEjLDCF9sBpC4yIIbToC/W6pIDV4Rj7qpFxYWt+JZbukcpPd + 6LTZI3trfrR934LbLeEzm9stZsqlBnQ+505Cs/ZEXPdRw81Lmmho1haams1u7nlg4xq4P+gHxtqZc0UY + 868JUFZ8ZRFLSH0Ie3huOEupt/70zF2b1W87Vx3vEJa3Qr64Qy4s7AC0pVL5FKGjeQCk+4ahxWUQOngm + XzYdwtKxEJbw9Qm0nKAgApmeqkIVdPDeAJ3RkBPgpUQIMiIH+Twij1ljqKIOJOIYBLnpeHGugXUGipGE + UqeZkMfMkgt1WhL5K60WQVjQLIdBUzvmNnVgSpMgn0CvqRNC1aVvHs/ADofvsH7Ad7Du2w/bx/XFw9Wz + ISlJh1T2AjI0Qo4mxdz5AJ9Dv5WiGYK8AYLsNb38FHh0Foq5965SnN8L4UwdhAv7gTtXIbx5AnQ8xr2M + aKQN7oO4wQNx2doEnWGukAW54aWbCZ4Gkwq6OhdyKakZ2RLI36yizzCGPHMBJD5zIeMDeficCbxrj4+Q + 5G0gNnrABn3xTsENSyD1WIT22FmQVBIpPFgFSJbT8dH2wkwIIHUgny8H9NsE6DdJpYaNsodLm+T1C1vk + KdPbJB7qso5V6pDq0Dmf2xttBl/jeQgtL0+lc0CWAnS8srXtL9qMD1RfszKM3bPhk1v3hzLvauU8f8rS + VZL3+7Lh8Tu7l5+1V3/aYF4pE5a2SwUDqoT6vPJRRZyKTmE4WoUeEF5pQFo0Ea2OI9BppgaZ0RgIRgRi + Pmno8snAUiICQ3XIKQQiA5AtkBMhSBaNhUSPtp+nRqRA2+uNgVx/MDr1hxJxdM03YKstdhuu04DgNwxt + O4dTZp0BeYs+OuS66AC9DvpcjIMgqKC9WR0HNv8ExzEfw+i7r5A8+ltcMFBB45YISBrvQ97Gn5DzCGh8 + CuHtQwjPbgIPL0N68wQklw6g88QuyHdlQFYQB3lWBOTpAZDxabnT/CEUpaN97040nKrG7TgvbBszENnT + JuF5gCewNQGdqR54vWkhGndPhfCaCKxBC7LLmnhbNB7tIeTx105VzNGnGMe/Xke0O3ycvxOB3nGh4kGr + MmdtCOH6EAop+59fCdlbYwiSpXS+aXvMoKCMLifykNL2pAhkN7TQupcy/OaRdP57QL6qP53DIZBrj4Jk + bl90rv4W0oQRkF6bCZl0loI85IIRZMJqIoMVjTffWG/JPeUwgjkf7BZa56Os+MrCmE1tFMs+7sM2lGz8 + 8NgtB4u2ds0bkOnIqWahE7Mpg5JHFSgkBO5OAqqEAPlyBtqOTEFbEvn/9eRnjfmMNV2z1qyYQkQwRWEN + sJgDXQ0S3luwmCyC3lhFpmrVG03rtL0+eWJ9+ly94RAWjqT96PPXzVYMfFGMJLTRgSxWHZ1HxxOAiYwk + BCBhDlVsyqpUwaWdQ/Hm6hCkr/0OS/t+hcB+3+D0jMFo8nNB+8FayA7shnCgDLJ9JZBVZkCSHQNJWiA6 + Yp0hCbOB1Mcc7e6r0OFkhM4NhpBQZu6gLC0lJSLzWgR5sB2pEW88cDLGDtV+KF+pT5l9I4T0cLRXWqL5 + 0lR0NE+C/NlsdFZPo88bSvJeRRz+zKfpWsaHQs8UG/isdUWlo8j+CyA4zIU0hpTDMfq/eb7id0nAMz7t + hymkXqZCLtGA5PUUtFwZg7YSIk+/iWL7ARGqXH80CbNRBP4xaJ87GK3r+qGtktTIW23I5XRuBTqHMl1a + n0WfxYl8ZWdTk+6h+iu28+dk572fdMSfOe1OVgLgX73Y7otl6ODtAK7f3nq4bKMg03oLQUsA5hD4CaAg + EAvk2Qls6KCMLiNwy6lSt5Nnvz8LrXtGoCV2FJodhkK2erxi2K+wQgNyYw4CqrAKW0CVd7EqKQOe9ckO + kC2QzB0OOdkCLOVTW9F7BlShDWj/pZPFUYOKO+AIIDaTIfOhjJ9L4LhM39lMFZzAIWAaZTdSF61jcXnX + QCQZfYLwwV9hj8pgPF2zFJJEP8g3eUNI8YE8wRuyQGt0kM9uXKODlwTK53Scz5ZNxfPFExTxksjq1SL+ + 7EEVvDEci5YV09BopoPX6+binvEM7NUYjTNWOngcswjN25dAOL6WCIb8ej4dY+QMSNbTb1w+UiTA1ZR9 + V9E54EOgl/NRkNzv60BuMYOIZjpawkdAUk5K5s5CSFr1CKBEAqD3OQFwgmvQg/yaIeRlRIARE9DpMAiS + 1ZTtF/P2EzqHcwj4WqMhzBiHpgW98cL1C3TUDgfe0L4CkSORtoDJtM7JhM4jiHxgIOvs1L1x8aaRY2SZ + x8dHDy1iG2oTlAD4Vy4eu5OYF588Ivx6t7xjdupPny84QDWrQ5E9BKq4CgKgrCwjz94+iDIwAVagbKyo + YCRRhblkqymuLYC8QoOy9URIXQiwlhMhN58EYfUUxXMDOAkIhuNoqUZL3kYwDhJOAvNHQraQKvIyAv4y + IoLFPIg0FqmLVmI5jymK0YOCHWW9OKr41eMgvTQF8icEmOekRh7R957Wwt3YmajRUsXhMQNwbwFZFqeV + gCeF63LK7IZoWjWbwD0Bj3XG4oGOGu7MU8UtbRVF//0tAtPtuaNwhzLq3XkjwW+BfjpXFY8XTMYjOt77 + +hNwfqY6bplo4onbdDSETcfroOF45dQTjebD0LpkLORLifCW8wlS5yr684U1RAxENvLV8yE10UHHWk00 + O44i6zANwgmS/i/J6sgWkzQnK9CxmFQAkcljbUjOErGV0jmKGg259TDAcAThl4hlDhHwrBGQzxhG4mcw + nb8haF86GNJQIsEjM4g0eFvBFIV6gJyumUBLYbpCWUBYwAlAkAt6Lx8+WpKZt9+pPxsB5rY7RQmCf3UC + CCmNY67Fmz46eMrarKVJ+64g6MhIj1Olma8AOEhCooMqE2VaQTJEoQYUHlxBAlTpoSmSRMdUyO5rQlI3 + G7IkymRuVCmtqbKbEXiNNURJvJT+XzYdnYYknRdNIv+vjladMejQVYVsEZEDAUlBGDyLGpFyMBwN2Xx6 + bRa9pkXfuZDUw6rhkNmroy1+Ct5uVkFzymg0+A/GGxt1PKbPe6GtilcL1NGyfBY6VpFC4Q8RMZiEJ/PG + 48FsFdybqYK7s9VwY6YaLmuq4MzscTg9ayzO0vLCnHG4qDUW1+aOw92ZfNsJeDRzDB7OGI+b00gpzJ+C + NwbT8IKO/RmphrdG09CyhP8e8trLyTrwqbmXa0O2koC8SgsyUx10mmijjWxFa4AWmspo2xv02xrpvLVO + gfTVZHTemoL2o+TrS8ZAEqMOKScJ496QLRkIgVuj2QR4Ar0wjchg0hAIGv0h0++PznWkvHKIQK8RUXdo + kXogEoUqXR8iWildExm9LicbJaPrKF9M12oZpNBraXxjcHj3EetZs1KKurtXbWLG+b5KIPwrFvt9Ucxi + 3xYWUxPEgmoiv714eXmCpH1Wo0yYT/J/VhewSc6TnxTaCfQtVAHbSGZKR4m2gINeQQBcKWh3NTiROuig + zPVyCFXMfpDW9kbjlu/QGtwbcjs18c5A4zmKuQXlK4kMSGZLDNTRTrJWMo+ymw5VdH5X4fJp4nh42l66 + dCw6CAhSAj+WjiOg0fGYkTe21kDbmgkE9LFoXT4OnZRhZfxmGjsCG9mP5wvH45kegX6+Cq7NG4XLWqMo + iw/DGU3+tKPhOELrh2aPxKFZKrSuguOz1HCCL6ePoBiOY5ojcEJDDZcmDce5qUQU08kekGqQLFRF56Lx + aOdhOB4ddHwti/igqPG0HItmfTU00rG2cwsUqEUWhNRQ1iTIa4gYjiyBrHY+ZAVEkqnk84NUiMwoTOj3 + LyJ1M38YZNqDIJ3bH5I5fdAxuyckWn3RScckmTWMzsNPaLXvgdZtdH7PzICsiSyRnNsHUmE848vomsin + iQpAcX1onfci8PcV10hHKm2d/eDAWV0Hu7rQTzz2BjKb/YnMpzpNCYh/RQIILwlmf4ir6pazx2P849vL + 9gqtuhJ0GAloNyKwLwNaSJo2UgZ5QcB6QpL/MSmCZ9rAK3rtFfnK5yQtn5BaeELbPloI6YPpkNwjb3uT + COICVchDVOnqDMi/GwKhfMIQUgb8tlcLDQiKacQ1um4XpvVlkyHnPQUL+Vz3BJ7VcxQPIxHMNcVtV08T + 58HjDWr87rvlk9FmOBkdK+j/DasAJ/oOVx3AkTLtikmU4Ufi2ixVXJg9GidmjcTBaUOxd9Ig1FHwJx9V + TB2CihkjUaM5CnWU5feRKtinOQZ1k4dg94QBqKFtdk8ehUNqtM+EEdg7ZRj97DHiQzj48a6a3hVkQYzI + 9vDn8i0joBsRsMnSCHwmX2cK32GQB1DGDu6PJvdv8dryUzSvIlJc3BOd83tD0BpMfMuz/BBIpg8lITUI + nRoDyecPgXwe7TufVIAuEZ++KgQLUklb9CGcXg08NCWipev0hs7960V0PYgIXtO1IGshvKbz1kDnpYVe + a1tK9o2sUAdF5wpB3riw9cplw/yYfd4jLEoqu3vVJDLfXelKQPzLNf499GARRAC2RfEf1e62Nn99fsb9 + 1vPDhaZDw9FcPRGNO9XRUKaG5lKS6UXj0ZanivbtM9CeTbI6ezpaKNqyNNGWqYn2jFnoTCMZmkIVLkkf + iCEgRlAEU8UMMqAlEUkwLX2pYroSATgSkWzgcwbMEAcD8fsEzGdBbk6y2WoB5Ar/bg54UbhTZXem/x2o + otvSZ1vxBrXp5K0JXGYkcW2XAz7r6bNpO199xec2LJ2Ek5NH4OAkVdRPHImq8UNRojYYhapDkE+RRZGh + Ogibx9H6+P7InTAQRQTw4snDkD9uAPJUeiNfpQ9yxg5B6Yh+yKZ9i9R7E7ZGQ2LIrQxlVwK94vtJ+sNI + S/HUZCyaLN4ApccHSo0B5pN/J2UjEJAFXcripGRa5/eHVGuo4j4JaPD7Jei9eUMU2b2Tz7I0m4A+l9TS + AiIashswnC5OCc5vE3Yi9RRjgPZ0XTRnzqFroIHG7MlozpuE1vwJaM1TQVvOCDQUky0qG4M35ap4U6mG + N7sm4m2tBt4e1UTn+QXCq3Mrbmzf427mVJ7xJ7+aZOZRs5G5/A+e6Kws/8eK8+54Zrk/WzGq3L06rc/h + 7eu3tkXptMsCZkLqMwtSLwpP8vOe9L8X+VpPCo+5kHvOh9xHBzKvuRTzIPPWpfd40HteJEe9CfDelHE8 + CfB8PYAykh+Rgjctfeh/X/4wTMrUHgRUL9rGg15zIYXgagi532qq3A5Aig+QEUgRBKQHAKkUifRamL34 + LL3187qmI58lTknuuQIIsSKCWUufbwzBXh939CejePwIZI5XxWbVkUgdMRhxQ/shZkg/RFOEDuoD/4G9 + 4DuoF4IGf4+wYT0QOaIXoob3QuSwnrRNT0QN64uA4f0RNaQvgkcMRMqoXnjF2yb4MTvx23SJtPhNPXz2 + X/7YNK5OVvIGT/Lg/DHqS1UVT/PB8nHiawYEbD6rsoGK4n9hsTpldXUiDfrMJVNEUiFLoQg+sQqfb5FP + CLKBzp0r/U5vyuh0juFBFsJTG1IPshEeOpC6z6NrRfbCm66Rz3SKKZB48Ws3AxJvCh8eMyHx1aLlbAik + xFojdTpq0i2KfCtSJtidqvnA/1ijkgD+1QiA30kSmxX+59pwG+dbIUseSD0pQ7tTZfMwEgHsSeueBFTP + RWKl9+CgpvCn8KVtvQ3E/727tvWlbfz5gy9of98VYgQR4AMpAui1APo/wJj+N6XtKFsHUIRYANF2BHpv + ICsMyI8FipKA4mRxWZAA5MUA20JJWbjR59H2rvR9DkQqNgQGR1oPJeBHEAGE0DJgLaT2i3ByrgqSR/ZB + EIE4aNBPCOrzPTz69oYbhVPPH2D3w3ew6fEt1vX4hpbfwJbWN/T8Hg4//Qh7Coce38G+x1dY1/8HbPjx + C9j36oGUMQPRxKfpDqTf6E9qxIfCndsOOkdOC7sGMGmL8/UrJvCcI9oVi/ldsyV32RjF3X+8m1NDnOZb + MRcAf+yatriPHS2d6Le50+f50Gf703n1o9/px88tqR1fWvrQufehbbzp+73oODyXi0t+Lfg+/Fp60DF5 + 8dAXg2/raah4X+Khh8vBBm/zkp0zQio3Dll3KK07JwC3PRuV4PjNg78+mdg+UUEAyaluI+9a6RwW7GfK + 4cUfVrlIlNIcrEFUWQINxQofSJUrgCKIKlgIVa4gqliB+l3/LxPfD+Y+n0t+ilDK1CH0OcFUMYPpswLp + /0ATem0NEEWZPIkAnx4M5BDgS1KAigygcgtQtUVcVm4FqjPF/8uJDArDgS20T4wNHSMdp9tS8SEbPpb0 + ebZAHEW4NVVyU3TYLUT11H4I6P8pHPp8BpefPoX7D3+C1Q/fwqrnj7D+sQetfw9LArn5t1/A4vufKHpj + DYU5ra/+phdWf/kDzL/5DEY/fII1P3wM2+9+QOqoIWjiIOe/2Z8siR/ZkwBz8ffxCDBTKBB4rRABybsg + 3en3uhI5uREBuhBpOdP+TnSuXA1F0uQqyYvWvY3EfXxpGWwknlN+nkNp+zAiEH8iTV8iP1/6Pn9j8dqE + 0f4hXeTqQ9/lbSyem+DVIklwQvbrCl9O2vSZvvQdAVyBrUCH/TThqNOCqxH5IYYO+1L+6FiTwNzqlQTw + L0EATnVJbMW5nPe3b7Q1ajCd/Fogbwk/qsB+HPBUaYOpwoVywBqLoVg3EStXsIkI7lDaPnSNmIHD11HQ + ejjtF0HvRRDgw6lShtAylPYPo9eiCawbnSibk7Qv2AiUEeh37QDqC4A9hUBdHlCT80vU5tJyh0gIO9OI + BEgRZBIRbPIjS0BkkOALJNN6kgcRAKmIEFNFBux0nIez2gOxe8YgVGmOwC6NQTiorYrTC0bgyuLRuLV0 + LB4YjcPjlePxaMU43DTWwDXy2OcN1XF0/nDsm9MXdZp9sVNjDEpmjsTeheo4rjcXV5doQcrPD//dXIkE + rafvpAij3x9mLgZ/T0F8tAym3xtO65FECGG0HkjnKID2C6XjDOGfYdpFHgTWUAJn2ArxfIZYisoo2Fy8 + DkGrxXYUTjwKQuUqihM0J91lv+zPicOfKy+6PgGccOn8BywXCYIrB7+VYjtMGCmHQCMItup4vEatOXmH + W4DDvtTvbHbFMXc+U/EBZY/Ab7asOpTOnEjm2dYlsnX7Uj6rcV8Z1WExVaKQiEG8UnKpbtJFAGZdgDft + qphm4ja8coet6QpLCJHr0BHviOYEF7yJc0FbghvkkQSMcAJGMCcFyoBxG4A0LyA7gqQ9ZfTyzQT+bQRy + AvheIoB9ReKSE8Feij20Xp8P7Kb3a7bTMou2J0VQlibun58I5HJrEEIk4CHaCC6R3edA8FsAIWglZOHr + IQm2hizEGgJvIwghQAXRb/MjkLhS9iSigCuBwWupmBn9V0Hgwbch8PGRgxICoowAJ/hbQaDzIN2ih6ac + yWjJmYjW7Alo3T4eLRlqaEhRw8skFbxKUMHreFrGUESroXnjdMhz6LOrXeg30m/fH01By72RpG4C6HeQ + Gsqgc5RA4IzmpEkR1kWaQcYi+Okcy2Is0ZFog7cJtngTvwFt8fb0Gv3mMAuREMJWisGJgasTxW8wEd8L + 6lJfXDlwRRe6RCQfVx00mk6RZQRb5TnuTx3peWjze+4EfiUB/IbLyoNpzJUUwMasQOa1K2HoeSuDvTLr + GRDI88tJjgr+CyF4c99pJGaqMDMxs0eYQx60HFLP+ZB66VIm1IM0eBFk8ash2+6Azro4tJ8uQsu5OnQe + rISwmTJ1uCOFA4GfvHsGATWP/HwJAb+CgFxDWb2OCKCewL0nmwCRJ8Y+Av+BIjH2cyIgFbCHv05kUMfJ + gKxBJX1G6SZSBASk7aQCYul7/M0g8AayBH0ISXTsESvE4+fkxTNyGFcmlFlDiQQCCQguvLdAi6Q599m8 + YXKpKJH9l4tZVNGOQa8FUNYN1BPXowwhr9FF+63J6Hg4Dh1PVdH5WB0d9zTQdmsumq9ro/naXLRcoeUF + +v/8PHRcpEx7ZR1kdx3R9MQXjU/D0fYoBo03Q/H2jBudK7I01RYQti5FZ4IBgZr8f4wW5BFz0RmkBVkY + ZexkOvdFgZAc2YzWKwVovlqE9hOZkFZEQ57iBGmkCaQhiyEN0oPEfz5kQUSA9BriOLFYihGzVryWQSvE + 8xFA7/muRKe5DkptV5/03Jsy1/lIxkeulCDcDii7BH+zZdmRdOa9O4GpNtS+n5/kuvjVmqkPBSdDSCPW + oT1YG51hkyBN1IOwwxRCrQ+Ey6mQ30uB/IIb2vYa4lXpMDzPG4hnhQPxsmYwXh8bgYZLqgR8ynQHdQjc + BK7tlG3jKaIp62/0AbZy8MeKmZv7/Z3pVOm3iCSwmwBdu00MBRlwRUCxn0B/oEBUBRz4dbTdbgJ+Ne1f + niI2EuaEkQKwEzO7vT6koZqQH5pNNsFItCyKMBUzIVczCjIzE2U5995OBDY3AnfQShEYQV3tFVw2czLg + r3Gy4JmTEwOX2VX0WQ1zIZNMhhxqgFwDEPhdewu6gpQFv/FGMbZfvMEH0ukQOqZA1joB8qZxEBrGQtY4 + gf6fRq8T+XbQNnw4dQvt30zH1Ewqpnk2xQzafhJkTbT9s8mQPpkG6fNZ6Hw6Ey13xqPp+hi0HJtM12EE + nlcMx9PioXicOxCvikagczf9ppNkt64GQjjjDVmVBaRbKfuHL1H8LjmpAFnMEsjtdfF4lcHjtLwwq8XX + t//J6lQK23B4sxIov9XifXgHc90VxIzvFP4p32el3+3VY1raknUgP0rS9yxlmzNUaS9S5b06G/Ib8yB9 + qA/JU10Iz6hSvzGGvJlA0UyVq3m5GA0kL59SnKIMU0LAS6X3k8jrbnQH0gOBLMrSOSR78+PI95NsL9oo + kkBJahcZkKSv2CxagootXbbgHRFki+Cv5WqBW4YM2p72K6TPyebgp+yf4KToBmz3U4ekaipwgkCUbCRK + 39DVIuh52wDP/OEkl6PoOCPNxe5IZyIs1y4C4MAP6Wqz4A2gCgJYKUpn3lvB5Tj32Nsp7hE4iQBkiiG3 + ExQkIChuuJkngl5BBDqK0XfiKDw+Mm+yLqb8CAAAgABJREFUuG37WAK7iriUTuwaqTera9+FXTftzPvV + /tMVN/agg7ZrpfU2PuyXSKKdonMB5O10Xdrot7TRcbfQMTbRsTeQWnm+FMKTxZA8JFVxVx+yq7qQnJ+N + zhPjIRymzz1M37VnETpjNHHHfGJrWpxtvPWFzB+z9jYzj4PblED5rRb3Q5mKvn/nY2l9Sjz0C+7YjxEk + tfzuM62uSrdAMQkFMJoq7QjIOwdQ9AckVGE7+J1q/I41qkyd8yG8IGK4oA1pzSwIGQSUTZT1Uwj4GaEE + TvLnOwj0OyJFr84JID9etAF5BOC8JHHJGwOLU7uClMFOyvS7touKgKsDDvpd9F4NRWWGuB3/vK1+9H0k + /YOcFfZFUjgV8ruUUffMg8C9NM/8imxv/ktjJffLioZKM9HiuC0UW+a53A/k2X+lGPx/7yVdDW2rxW7L + YLFHQ4hbDNlRDkQiABkBs5NIQKYpTtqhOH+6Xdn/HZDn/DykGjIiqE5OAuPpXNJ+EnXxhh3F+9pdxKHb + RSLzu/afJd7cI50i3o/RTkTQyecHoM+V82uhqfgOgZMFv2+Df46cVIWElAYRjlQ6CfIO/p2kWOh4OzCI + 9uFzDBBxvF5C124mrjsOFjYHLK91PZyq7nn2YHf3Q9uY/cmtSrD8Fov9vjTe/dctKstrwgHPmWde7Rgs + Du0VFlLF4JKVKpTA7/hTg7xtDMlSVap4Y6jyjFDcbCKVaJP/XQTpIQJW7nrK8iTzM1woPGmdQJlGcj+D + sn5WFGV+Amp2lAhY3pefSzYgmxMDKYLtFFkUOUQKBUQGheTpC0gRFHESIKBX0LKCyKGcSKKM9xjw92jb + HCKUzGD6HvquGEdFg5dsywxIr5PMfkgAKSIQRZop2iwQwdsuLMSI5D0Vll29FmaiLfCmLO/G+9ONuhrO + jMXWcz5+wbOrz503likaPk3F90PpvSI+BJq+T0IE0M6BNh0yBRDnd4Ff7xcLoAD2LFEJcLvA51ToGC8G + JwA+dl9x///cX6mHX++vpZgYRJCpQy4dS99FGZwTjzCta8KQqV37z+mK6Yq5G2SykZASgUvlIyGRDINc + Mly8o1OxvXbXtlqQvZyOe5m9UO4y51ZwSejydZdqfr/mRqqSAH6LxY/kv29NAvs90H1ruPHiM/7qTxvP + qlFFnqsAv6DIOPymEqokElIAbRTNlKmaKcO91oP8jiEkh83QXmkKaREBv5jAXkQZvTAZAm+Q47J8O0UW + KYCsQDE4YHOIBLIjRTWQRbGNtt3KVQLfPqKLJGLFQT/cIhQTGZRwq0DgLyHQFyaIyiE3UvzMDG+S+a5A + nBnk6ZTZTpM6eU7Z/zhl4DTeAGj2K/Cv/SU4AShUgLloDfjYBE4CHPABXS3lfKCSL5GBl5FoA3gbgAL8 + 77rjaLs0IofLBKLWcQopzzOtXHHfvXaXCpj/q0z+KwLgoJV2qQZuAXh0ju+6hXfWr0hA968UBL/teoLi + NmwIXDVM+ivga/3yvYpbuImM+A1cElUKNUWA1iEdKyoH2QLFZwsgKyPVwst9I3DAcXxjQoqDz/oLFV9b + Xd7G7E4pbcBvkgAq7Kcxu7NVvy8JWhxwO1ats/0FSUTFrD86P0tIKZ+QooMqTBNVuGfTIb9Krx1eDnmt + PYQyyuC7SYbvJ3m+n6R6Hfn0KvLpVZTFyzgZcCCHE2AJqNn+XWTQRQyZoWKDYAZl8C1B9D+tbw0WM/oO + vg8RQX6M2GCosAz8s2JF4uCEwfdJJ6WRag9sJEDnG0O4qA3hDSmVZ6RaihZ3Af9ddAGfd1fyNoBQC7Fr + khNDWFcX57uM779KXPfv+p8PzPHpUgHvukIDV4vv8zEOe8k+vCVgtdN3S1UgyN/dFan1V0Sg3fX6TBG0 + sgmineLgbxsrWoGfCeDX+73bV0sENAe+nE/GQoCWi3diCtwaKO7158B/pxr4PA6zxM/kCqVzovg97Woi + +Ui1FQQg0OfLhBmKyUfabkzBeY+Rsq1RZpkbzhT3WXs1lzkQATieV6qA3470P7ud+R3awUzQwEJyI3vu + cZxW9SRvFGTN71quecXRUnjZDqhD1j4Rwj0CwAHy9FUJEA7kQXq+CtIbByFc3QvQOk6VAMdygEPcs2eK + Hr2MyKGcsvdO3uUX05W1CbyZBN4MIoRUHyDFi4BM65sDupYUW7sUQ1aASAiZRBhbKDZz0qB90vhgH9ou + ho4njYBfTZX+NlX+t5QNG8nG3B5Jr1MGD3ISxx0oMv5aseEvvGs90prC6hdbwEmAtxUErBSDt/Qrhiuv + FEfkKdoGjMVtOIFwK8AJgA/QyaF4Oo2k9TDKsGNEsHHlpJDlc7qy+bxfEYCm2ODHp1aTqnWpgHFdMyxN + /pUC0P5VzO16nXt2PiXbOHE/RcMjVwGTFbMiiZ/PVRyPWaLHF7rIhm/fyb9PRUFUcsU8DtPEmYc4ufB2 + hJfauJE4CKU+C444H86c5HZqxwf+e7KVBPBbKo5nM9n6k9vYGOFmt9RtHlOPOw+/9WLPCMoOWl3ZQ1fM + HDJSA63akN9cC8lxL4p0yK/XQ/7sHOQN14BXZ4HHp4BbJ4BL+4FzlUQEvO8+XxzUU71N7Kuv4UN7U0UJ + n8d9e6A4EIhL93gCaawzhQuQSIDeSFk9hQCe6kaE4C6SBB/tt9FXHDKs2MeBQGtD65SFaxdBeDQPMt5G + 0UzZ8A1V8NOUYVNs6TP5tvZi8MFHPOK7ItFJfD3WRoy4roiyFoOTg2J9nThmgJNIFL0WQ/9Hr6f313XZ + CNpmMx3PdR0iyuGQ8ywuVf+VL5/1K1n+rjV/dpeUJ7DLxorAb6P92rg8n9TV8PprAtD5lVefIU7DxrN5 + O30Pb9Tj/ytsh8bP6kFQ3PM/u2umJt5QSCTQoS4SDbcqdJwC741QHKPWL20OLdp4UD4cte6TH0eXhhlb + nd/x8aoTm5nb2SwlcH4rZcMZUgCntjP7a6W/z0xca3M5cEhT02XeEMVb9ueKE0jyCthOZPCEMuz5RAjX + qyG8ugSh8xFVnKe03XOqhLeB5pvAy+vAg3PAzQPAlV0QzhARHCFFsJ/33fPBO1kiEVSQny/ivQGUyTdz + YHPvzgcIESCDCVBBBKZQWvKRgzHrRaDy96Mp+J2B0baKG32EcFPIEpZCXr0cwpPlkMlmklUZAHkb/YYX + BIL6pSKJpHGL4C6uv4vUruAEpHjfU/w/xU08no1dkewikg1fTyKCSnISI7lrPYGW8fy4iERS6DNOGim+ + X+At9IqGOY2uTP8um78bG/CuRX92VzafIDYAtk8QwfkzAfzaAiz4SwvxrgGxnXcJ0vbSaYrWfvH7tH7V + dvCONDiZ0z6d6j/bDaGdjlXOrcP0rm7LrkbLzjl4dmI0DrgNb0vdaBtqfTn3yzWXMpj7CVIBV4qV4Pm/ + Xrwu5DPHCzksad8m5nc257syj3lbbqYNkMlezFA0+EkxSSEbZXLK/A1U0R/mQnh9hirOcwiyTvKKUqow + fF79RsW8+oL8NVXAO1SpLpIiIDXw5CiEu3sVRIAzZcBRUgT7eR8+2YLdpATKN4lePos8/2bK6EkEsEgC + eggB34/8uQ8faGPSdbOQ2S/ddVGU7aOWKW54kccvRMeBeZA26EJGlVtGmUyg7CZroyWfkKSSAL01EkIO + KYcdZCG2h3a1P/w6wroinLaJENsd+Ot8ODGPrUFd9oO3UZBi2RIg2pbNfqJN4bcmbw4UFUoGre+jc/WG + QCeZ1pWRNX+W4yIYF1Es7lrq/9Kqz+fpk00TQayYZXmqOO2agiT0urZ/F7/29dPFbXnIpnd9n3bXNvx7 + lvxqn2liwyFv+ZeMUvTkCBSdGAIJxihmHBYU+4qDlZruqeJcaD9hp4dhmcul/AEhhw918z2RrySA30Lx + PJ/HNlzOU3T/Je5MVNtjM/3o04KhkLfMIOAvIBIwoOxAGfZtJMU+koQPqNK8oYrRAbkgo0wroW0kVAE7 + qdJ0UqXpoPda6P8G8r/PIW9/AOEtkcHTk8Cdg8C1OtEaHCsma5AjDvmtTCM7wFvzCXjbCETJlH3juKxf + 13WfQddNRvw+AwUJrIIsehGkGxegI08PspOGBDaS/vJZinkIBQ6Adj6SjiT0PSKM6thfeg6KN3at8+Cj + D/ntxV23GPMbini3Y0FyV/fjr4IPVOJLPmKRDzbi4xZ47wQfyMR7KrL5kv7fTpYmm0iilkjgIR0z75rj + syQLc37Vks8BT+SFFV2xtAucXaMDOeAV8/13EcHPBGDQBeR3YaAAtMKvc8BzJcCn/BKmi1Jfkf11u7Z7 + RzYLFUSkyPS8LUDRIDhNMWejXDIFcvpeQTHp68KuzyZCfaGOWykjUWs153zwwW0zNJ8ffH/1xTLmevGg + EkD/5xsAb9cxl2OZbDEu/C4tzn3FMcfxjxoOjiDw8kpClVNqDaExBMIbAm4HAV8uo8pBoJdLiQAoSCMQ + 4iibyGh7IgLF/3LxNSIDAU0Ki4D2+yQSbkB4eRHyR6cgv30Y8sv1ZA+qIBzJh7B3O9mCzcBOfiMPZeIM + PpiHpHQiyerYNZDFGEHCZX4GKYJCPhTZDMJZG/L7dhDazOn7Fne1pk8XJ7xs1yLiIhK47Qnpvi2Q1WVB + vns75LU7aN8diqW8tuu13dvEdf7abooaWq+m16u2Ql65VbGU0VJWlQnZrm2QVWd2vZcB+c50yMvSIC9N + oaBlcSqkpXGQ18eR8tlAgCKQCdq/DMRRyPfFXcAngoBx1/qyLnDOF7fnoJfNUAwVhnx2l/wnooPRr2KJ + 4jVB8d5scdgxVxA/W415Xd+36OdtRTKY/3ObgMJeSCk6aN9OPh5BHPcBYZFiW8Vcgc0aeFI2CvvXTXkW + VxC1zvhx9ScmV7cx5wu7lAD6v15crlWwhBQPtu5p7eeFLmaRZ/37tL26+SNVBKoAMnNSAmEkrQmonZT5 + 0dwF8l+H7P8R7ywCqQKhkXjhFWQdTyBruQ/Z65uQP+eEcAjCHbIJl4lkTuSTfOb3+ZMqyEtRDBcW8pzQ + udscbWdXQfrYgoBNWV1uLoZgSp+9sgsQXRWcV2DpYjp2cwjPtqHjdiU6bxyB9NoeyK7vg/zaQciuHfgl + rtP/N3gcUgTvzfg5rvM4IMa1/ZBQ8KXsKi2v7IP00l5IL+yB9Hw9RS2k/Ian87shvboT8hfRkPJRdRzQ + Pw/hXdiV8TnwSdlgVdf6qi4SMBS34U//ITAKMj7z8ryuTG70q23fLVd2gVpH0VMjdv1p/cpmcOAv79pu + edd3G4iNu/xzObkoiEaDvuvd2IF3dkNfsb0gW4Bn537ECY8x7dti7FJtb+X1NmgQmPPFGiWA/q8Xh+sl + iuG/SVWZAyoc9aqvxA8UOh73p4phS/hOIDVfQhn2Jv3fTJWh8y+A/f8G/7vosgZo6yKCJgUZQPaSvuM5 + Zeu39PIj4PU14O55yC/sheRcIaSXt6LzZho6n2yC/C2RQlMWiY+tkMhT0Ckkkf1IJhVCIaeMK4+hiCK1 + QTZCHk7rfvQeyfL24/QbbtNXvoK86RGRwn36KWLIfhXyxq5oevCX0Xj/L+Pn9+7/Eo33uuIOZA136bWH + EBroO1uJCARST3IfUkoBipAJQXRGiFQRTctYOkYKeTwtSTEI/Pjp2IVg2i5ADLm/IuQIpNcjaD1GEXJB + DJmcSIa2lwr89/oqQqaIAPqsUPps/nlRinMhk5ONk4fR99L78KJwp+1caBtnCie6Ns4UrkTYbvR9nrT0 + oXCna7UMLTdVcCZkNHI8DQ64H05W45bR8Uo1c7qqJIH/u/7/+m7mcG2nwv+nJ3tr7neYefNpkQrJdD5A + hCpQZxVh9wIBtUEh+8Eb/ATZfwH47+KdWnhHBO0iGRARCEIzVT4ZRStxyguyCXeAJ/uA5zuAVvLpneS1 + JTEUZA2km2gf8uFCvBhyWpclUBDQpeS9JQR+STjtQ9HhSyAkG3E+E+17tqO1PAeNJal4XbwJb4pS8KYw + Ba95FGzCK4o3eRvxNncj3vw78Za/l7cJb/M3oSE/RRFvC1N/FSmKeFOQhLcF8WipyEBnzXZ0nk6EpMGH + fm4AHY9/VwTR8YWJv0lKIYuiJT9+vuTHH0zbBNI+geJ+74LvJwkTt/l1KH5vsPjZ7fR727uW/DM6+T6h + XdvS+ZHStpIQep2/z4+LLFabBwWBvN2NXudB6xJ6XUrvS2k7Kb3faQTp3Ym4nqKCcudZ94IrQhfq4dYH + E89vUBLA/3UCiL92kC3Dzd/tCLeyv2Cn0vy6fhAktzUhe5ZGmfESVYZGhb9XeH/8DUKQdpEBtwYyRRtC + hyJ4G0IrqY0zaH8cSTywEk23J6L15hi03ZiM1nsaaHoyAU3PJqL5OY9paH0+B21PZqHt4VR6fxJa7qij + +dY4NN8ch9aramg5NBoNYRp4ZqGClwaqeLmgP57PH44X81QoxuCFjsrP8Wy+Cp7qUtDyyfwxYuiM7grx + /6eKELd9yffX7oq5o/FMezSeaw/B67k98cpgMJ6tVMHjwDF4fmAUms5NRMtFVTRfGoOWy2PRdn3y/9fe + f0DJUV5bw3D52jcYG1CaHHu6p3vyKAsFJJHBBkyywdkmCokMBhsTjBMGRFKOI03OOeeck2aUJbIxBmOT + jQGBzrf3eap7ZgT3/e+3/n+tV9y/a62zqrq7qkN17X32Cc9T8q/nL5B/vXy2/OvPS+TDV/A7X16C38Dv + nyLvH0iV97n/+Fx5f2wOjp0n/zxwhvzzOfymF+cZe2mBMW4fXiTv4b3fG8ex4zh2fDaOx7GH4+SD55Ox + z0IYzssL8+WfsA+PLNP3e29strw7mijvDsfLOyP47mMJ8ta+VHn38Bn4Hmfi/J8p7z5/Fv6LFfL+/hR5 + OT9Buu9e+MFT2b+874a3e0/7XctB696DDX4gfVmXXx5ptO4pSbce7C8PqnvwW1nP/S7s+Fsd83GR3ifH + 3miAAviL7fkBTgXuxyeEAf9T0E+yL8gRfAZFwDzBZ58clLdfWSvP9V4i+5rj5WBzoBxtDpEjTWFypC1K + jnY55flOh7zY4YLFy4uds7FOlRdaE+S5pjg52uiRow1xcqQeVo3HmfFy+Lr5MnZRnOxbniL7VsTJ2Fnx + sETZc1aCjK6Ml1E8N7LCg+042YPHNH0ej81rbhlZ7jb7rDDPeV8zr8fJEF4bWkmLl+Ezk2V4ZaKMYHv8 + WrccSnfIkdJoGa8+TfZWflP2VZ0uB+pC5FBLjBxt88iL7XHyYkucPN9Ew/etiZS9FTNkrOJ0GSs/VW1v + 5Qw5UBMqRxpwDhqj1Z5rilE72uiQ/XVhMlp5qoyWfk32lP6HsbJT5EDlTDlcG4Zz4sKxsTgv3N8ph/FZ + +2sc2C9Ihgqmy1D+dBkpCJCR/JmypygIx8XIoToPzIX3jpH9TZE418HyepVD+h+I+yznqRt2/eZITdjG + /busO15o9wPpy7j8+I1aa82LtZZHXvjKMxVbFjbdNn/01a1R8m7fVfLpS5DfH8D7H39HS3zHtdb/iZ3M + +/j/N0pAbFJRgsH7fvxneful7fJ898VyuD4BFx8uwvoogMUh++ojZH9zlBxudclzbS4A3i3Pt8bL0dZE + EEOSHG6JlwMNblysbtlX65F9NbCqBNm3O1n2/XiBDF+YBGDOloEVKTK4MglATTLrs5Jl6GxjBO3wCtvw + mteGViRMskQ9dgj7DuIxrX9lgvQB7L1qydJ35iLpW5EqA8vxGT+OlZG0CIAqUvaUhwCUQbBAGasMk70A + 5QEA/xDsIIjrQL1bDtaDNCodMlwcKENFM2WwaAbWs2SkJBjHR+J3OQwg651yEIA+gDW3x6pjZKhklgwW + ni7DOG6g4HTpzz9NRoqm4f3CcVys7K3FuakBoGtjcY7csqfCgf0CpS9nlvRnB8lAdoj0Yd2fGywjpQ4Z + q3LjfV2yB99nT3WkHG4OkL81x8iep+Ol8oEr+9Z3ZixaKq985Y4/t1jXvdbmB9SXbVn1Tot188s11pWf + Df771h2P/Lh3dfzf/lYSLx+N/1aOv96HGPEVU8/XUt7H8NJcf/T/Mvn33ycMjfwn+EEo/3pf3n+5Ql7u + vkJeqouUv1QHyiu46J6rToDXmid7AZDxZlyEbW4lANqRdqccaHfIgY4Y2dceLXuaw2W0MUJGGwC2eoeM + 1gF8GfDoP5orgxcDmGfNke7z5svgWakG+ArkZLNNW4HHy5OmrIe/0EgW9vFngVBwbD8IoY8G4PcsnS+d + y0EGUBjdP3dJB4FVESXjpQBUCcAKcI1XAPz1iXIABLa3zYnfhuebALpGlwzXRslwWZSMFMbIcAG2C6Jl + tAjAK46VPSCAMXh97us9ZhyP99YkyEixQ/cfLXDIYF64Arm36L9kqAqAro+WYZ4TKIA9JBAQxl4STVGA + DOTMkMGsQCWBrvxg6SkMlYGKaBkBUYzUu2S0xikjFbFysC5CXm2LkEPZqdJ55/mvbyt+6mc3fDD0n/e+ + 0uQngC/j8r1/NFiPj2VYt7xVPzPvkZ+vHXso9aP3G38inx4pk+Ps6f/odTvz/57J3HvBf9wL6P9pGfDT + E8qGxhj7H+Nrn30gH7/VKS/0/1wON6TK0doU2dOQJOMN8fD8KQDKXBikMQDzYuMiealpgbzYPFeeb0mR + I61JUAHJkLfxcqgGHrQqVvZXuuVABTxcDS78zFA58P0UGb3II3vOjJNhePqRlXNl5Kx5uh5aPhuWClBD + HZw1V/o/Z3OUONRW0lLh5VN1PbRiDogA7wHrx/G0PiiEvrMAzMuhDs6Kkf5rIqVvJ7x4SYCMl4XLHnjy + sdIQgA+Kpi4aXjwe3z1FDtfhN9TSZsvBSvx2kMRocYgMF0IJQJoPFwbBmwfjt0HGY9/DNYmQ9knYH7+/ + LgXgRHhSFgZAh0DOh8lAXrAMFYbIaH6E7C3x4LgEOVCVJIeqU2DJsrcqSo1Koy9nmgxkBcgQiGo4J0RG + 8sJkrDgSx0B5VUXju4KIKvA96+IRfrnlRbxH373zPsp9+o5nfvN6W2DOSIF1/RutfkB92ZZ7/1Jlbv4x + kpla/evv1f9547ePH+v5g8gL7SJvggA+fBXYZcffPwDYd+wS3jE7iefNBXzyP1QExyaZIQCGFJ/C+x// + 6CV54/AjcrBjIUAOOV+3CJ4nFQaPBy++FxfefqwPNTBGBvCb58hRBT9IodUjRyChD8NTHcAFfaAySvbD + ex2AvN1XGSjjO8Lk8JVzZfSCJBk5E3L9bHp9AP7sOfDeAP3yZJXqfG7wc5aiIUM/Xv9CgxIYoFH2w/iY + SmDwXI8c/sFC2Xv+HBm8yikDm4PgwQH60mDZB5Duhe2riJADtQ451BgHAgCQGxLkKEjuKH7/oSoQXxk8 + fXEYQocQ20L18T78tsM4H4dr4xSQR+qokABueOs9ZaFQAMEyDNAPgwSGC0IB5lAZL4FKAikerEG4AUV1 + qDoRwPbIXnj1UYQmgzlhMpQVKcNqIIWcKNlTAIVQ5pK95S4ZK6cCiNPjDrUlyMuNbhn5Q5KU/OYHjZv2 + laTwGrr3NX9D0Jdu+c2RQutC+fvXdhQ/8d22ey46+lbWz0T2FIIA+kX+0i/H3z4CaQ4S+Pg1eOm/wd41 + sfrxj2w18NEkEvh/Gw7YSuCz9+T916rkcM8SOdg+Sw43zsPFuUDGIGlHqyHnq0MRf8KL1eEiRvx5qMUj + BwH6/QgFDrQ55GAb8wIx8KSRkMGBsq86GDFvELxWsBwqC5aDGxAqfPsMGYb0H1g5WzrOA2DPSda7/w6A + DPpWxEnfcg+AGw8VEC8jy6faMI3KgbY8zjyPuJ/79p0FOzvBtx44G+Dne2K/3vM82H+BDF6Kz1qH8KQg + XPYWB8j+MnzPknC1g4ivDzW55VAzyA2/7WBjFAgB6zrE9eUO7B8t44URMlYYDsMa78H8wQHmRRocagcb + Ysw2ZPoY3nMkD2SRjzAANpQbIgP50xDPB8reaqM4NIeAzz1QORvfJRnvi9+U7YFScstQOsgqwyn9WS6o + iHgoFSgF7DdekSx7oDzGyxAGNM+WPyPc2rfZLTX3XHgorWnLt8NE/u2hP1f6AfVlW9Latlm3ysipxX+8 + 67d77l7x3keFj8hn49Xy2eEOkMAQME8S2C/yPojgoxeAXRDB8TcB3De1I1B8CcFj/7MqwJSKwGca+x97 + p1deHbpWjjYlypHGBNnfGAvwB+GiC5KxCoAZ3me8DAoAHutwA4EC4Le4TfKsGYoAquAovOf+WreMVzk0 + rh2viDbrynAZ2hwj4yCAofPnyfBZkOfnxED+J2rMPwi5PrAcwAWoBwhoJvO4D4Dcf06SWh+s15fgS1DT + fWD9ZyUZw3P9TAjC+zNvMLJ8jvSSYJYvkq6LQQZbA2Ww5HQZhQLYU4bYuiRCRhDjjzMZh+9/oCERvxu/ + CSrmEFTPwXoPfgO8czG+K0hgpChKbRjeehhhxD7I/X11cZrs3F8fB4sHQcbJKM7VIIhiIC8KwI+UHoQB + A/lQBcURsqcK56EW57LKCenvlr218OzVThkuDZf+/ABNBPZmzQT4Z0lf1jQZLMD5x3fci3328RiELKMV + Lnm+dr683DVTDudESMudK/++M+ORu34oR//rD4dy/YD6Mi2/+HuH1ffb66zHDpZG1N/308LXHr760+O1 + G+SzwVL5bKxB5HC3fPbnTvnsr8Mif98n8u4hOf7P54HdVyHdXwWM34R8f88oAg0N/jUpNPjoBPvYDBY6 + zlIfo37K/w9wyHPyj0O/h1dfAc8PWduYqJ5+DF5/vAJxaDm8HiUoPM/eClYEIGObcdHDax5oRszfBAnM + 45grqHEB8NFqeyuMjUEFDK8HUC6eL4MXzpFRJuvOikVsnqAVgAGAdgAkMGhXBDSJ5wX32SSAZDU+ngx+ + BT1fX0mj9Gc4gOdJJmeSVFKkB+HA4FlzpedbOGZduAyUnqqAGiuPBhGEA6z4jiAAAvgACOwAQoEDCn78 + tjoAFB53pCTamJKATQSlAGWNR0G/j8fSEArsg41VukAAYdIHz9+fGyr9iOUHEQrweL62twZeHN5/rMqp + 4N9b45ZRKJL+vJnSlw3LClAC6M+eIYN5gTJaEil7cB7VyqEuQACHa+PlxY5AeR4E2/fIvE8Kn71l96Mv + VAUV5D1grX6z3w+sL8uy5q1ejf/XVj+7uO/Oq4c/5v3z6raIdOaK9FeKgASOc9Te890ifwYJvLFX5K2D + IIGj8tEnR+XDz14CAbxlkoTH3wbA39bQ4LiOFXjPThy+50sgfnb8Qy0pfgYy+IhE8Nlf5OO/lMjL3ecC + ALPhzRH7A9D76ZlwwY1XOHHR0WJgUZqMOkhv2eSBxYEI4pUEDtpEYLLa8KqIrfeWGxstO01Gn0iW/d+e + Lf0XJsuoxujw1iCAAfXcicaw7X088bx3HwCY6kDLfeZ1Y4z9U2Cpahr/Mx+wPFl6NbSYC/MgFAC5rIXC + KD0NBAByK8X3KmIpEJ4c35ne/hBI7BDUzyGAmY+VAKpijVJA3D9K718QKaOFAGKpQz04CWA/z0ddLOQ/ + HoMU6N0HC4MB6EAZAAkM5cK75wTJcGEkzgv3iVfVMFYDNQBFtb8mUeP7ofxgGcxBuJAVIj2ZM6Q/c5YM + ZodAgYAomEwF8PeAiIfw/cdrw+S51gh5ESQ8/JRLKh+8sm9T+67k/fNPsX758V4/sL4sy13/6LJulL/8 + +66dv7l23+or3/iU4/BrtpihuZywg3fd6SwUaESRA7UICbpEXhkV+StI4J0X5fi7f4GChwr49A0z0u8Y + Hh//G7bfAClwngDbNHfwN31OSBjH/m6Oe3dE/jp+P8B7hhxsIgEgBIBRcnoJgBenMYcC/GDDJPA3GTI4 + 1ALgNCEEqAYwKiKxL9RDeRgIAB6r9Bsy8liC7P12qvRdmKw1fQP4xKkEsNKu5dsg55qg53O9yz8Pft9x + TBAC9H3Lk4ytSNKkoBLAyrnSCwLoPgf7/SlW+otPVQLYA1APF86CCsB3rIpRj68EABVzUPsAPGr7qt1K + AMNFoTICACsBFOH4MoLXDY8PkqgzNf0DVASwvdWxMoxjBvJDbAIIkwEQwEBeiCqp/TUJ6vXHYfuqcQ5B + ACxHDkM1kAAGs0MRBiAEyJgBMggE+SBkqPQg/jdkPFQaI6NVYfifwuXVtiQZ2xEvtfeseG1H2ROXLxT5 + t9V/7bd+/WqfH1wn+3LTB/3Ww39tsh55ren0xsfuevKvd33/Y52Io+hZkfJNImWbRYo3mAk8OTS3eZdI + D8kARHAIRPAyFMFrIIM3xiEAjor88wXY8/LZv47ooBtu6+CbD54z9s/nECVgvw9fhiDA63/fKx88ly6H + 2i+C9J0DS4KcdWlG3BBAzBcSAKsAE+A320YBJGhia9yWqiy30UZLpsnoo0ky/i146QtTlAAGbPnuBbIX + 7F6beG5CAUwQxQRZUPJ7ge/1/rp9ZpJ0LY/D8XNUAXSfg/f6g0v6C78J7x2tBDBSxPgaKqXKZRRAg9fz + s9JhCICAHi1lmQ4SHrH/UH6E2khxpMp5NvLsQ8iwv84mgFoSACV9NOL3UIA+VAlgKC9Mt8fKEMtXx9ny + H+FAVZyaKgDszx4AEgCJoz8ToUBmIIiB5xNKpMJhCKDMNAUdboyWl1vj5HBhkrTeO+ejrK13PLTqo/FT + vvVBnZ8AvgzL7cf2WE/sy7eeGM6KHb7n5w3HHr7e3LCDs+pmPor1b0U2/0pkw91mYo6MP4qUghyqt8jH + NdvkjaK18mLRQ/LX+qfk0yMNIq+PyfG/jYm82Q9SGBH526ja8b+NwPmPyPE3+dygySe8OiCfHa6Qv/Xd + Jfua2L2XpFJ2f4Mp87FjbQ8IYA/i5T1l5sIjIRxAjH8YQD/YnOADP72/kgGPh/fbW2mrB4QMBNhoSaCM + /SFFxkAAgxcYApiI3z8P/skEoOW8s5OneP3JykDjfwX+CWHAcpsAVs7VCkP32QnS80iM9OWfAvCGKwGM + FgeDDEBSlfhddR4f+Cn9jRKYIICREhAZYngqgKH8cBkqDMU5cWgi0IQAZt8DtXHa/ciQiQQwaBMA1+wJ + GNXQwaM5gHGcKyoAJQAqgKIwhArBMgAC6MsOlD6EAP2ZIIR8qA6AXgmgggoAZID/g52ZL7XGylEc33O/ + 83jxn35UdPerDRHnvP6M9dDrg36AnezLT97r0eG/2eVrL3xr9fdf1Fl2nrrNzK/HiS3/dLM9/fXVIg/f + IPLo7XLsqdXy/qNXy2v3r5Qj9yRK9zrEhlvOlH8UgzhGGuT4eJsAhQgX6kUONkIpwA7DjjSJHG3G8yCK + /VAQ45Xyr/7fy8vNiwHiCMh/A+JDBDY82l62nuICZ3KK3kxzALgAmRs42Ejgs3U20fb+Cfp4PwCzVzPV + kKzYdy9LaEy2FQXL3t+kyuiFqTJ0fopm/U3m/os8/0QI4LUJ8CdM8v6T1IDt+Y33NwpAcwB8n7PmSc9y + t3StjJeeh52Iy08DIUVAmUBGF4dqay9bfg/UxSnwSQAmH5DweQVQzK7AKEMABXYCkTKeoYK2Pcfq+3gJ + wBsCDJIAco0CGMZ7UM7vq4kzBMBwAABmtWGkKEIJoI8hgA3+/oxg6c8NRwQY4yOA4XIPVADDE6e8CAJ4 + sR7PPxkhzb84b98jfbuWPyjylQfeGLDuf2PMD7KTdbn7vV7rwdebrUtF/r3mT7fe+cGdP3hfp7l+hHPa + XyfyALZ/+UORX1wlct9l8ukvr5B//OI8OXTvbBl8yCVDT8XK2O4UXMTwJjkJ8kLGxXKs5hk5Xp9t5vhr + 4407c00ysStPpDcfVmDyCR358mn7Fnmj5Ro50hglhxti1PPvY098oxsgZ3wboxf4KBTAKIkAF/QYPOU+ + ekgQwP5GjwLfkABIQ4kjTgmA4NcSII4bB4GMwBPu/XWyjIAAhs9LMYm7c1JNJl9bdxMUrH1e8K8wcbx2 + 8y23DY97lyeY5058zQ4Bes9M9NkgFEEv3rvnzFQ8dks33rfnAadm1RkCjEOKjxZTnYQaAtAyHn57g0ft + YGO8PmY8z3NAAhgGQIcKIqACIuCVQ/E8FEAtk4AJiOdjdV9WAg7gOaqm/rwg9fzDeRHaEjyQx/eIAkHG + 6XFjWgkAgVe6jAKAMunLDgD4A6UnY9okAsBxJQ4QAP4TnNvhcrcMl4E0Kt3yXLNLXmyKlMO7XdJ6x4K3 + NqU/dPNP5B//eftb7dav3xj3A+1kXe77cNDaOJxv/f7NjoDuX12b/uEdV352HCCXu3g33GtEbr9Sjt92 + hRy753J575aV8uqqRDl6X6KMr02W4V246EtipbsGHq10lnbcHc2fL69u+a4c2/0bOc6benhv9VWIkKFk + g0jFJjPpZ8lWtX9V/lqer58HME/TjjbG/gQ1B/KwSWVPRZQBP0OA8hhDAAD3Pk0Ask8gTu1gc6I+VoNs + 3quJqkg1DQFYaoNs3ncfvveFs2Xo3GRTsjsrVQFKJcCyX6+tCghsynkT05vkHgHtBfiJYPcl/uznepYl + qDEH0I0QoHsZlUGcDg7q/iVkeS6z6vheJcwDQN2UhJnqBry/9zfxN+raRwAOGSwMgkcP0nq+KgDYSEmU + Jub2QvabeN6t3v9AbYICerDA7McqwADLgTASABXA3hoeA68P8DO7z+f4fr0ggB7E/r0cE5AJNZDOFmEo + lVIQFgA/gv96EOQ1DAUwVuEBgbvkhaYQea4Q4c29qccyn1y99ab3+4NuH99m3ff6sB9oJ+ty67uQ/wkp + Vk7NtvnP3f7DoWN3XCyy5kKR678jch1s1aXyz5vOllfWLJLxe+fL8NPwFJm4sIpTZLwY3r8wTPbi4h0p + 4ai1KKj+INm/2yH/WHcJQog7RJ78hcjTnB6b02hzau2HRXb8RmQbZ8v9o7xbdLXsawyXsWaHHKmbrQ0w + BDM9H2v5puYcaZNAtNa96X0ICkMA8QqSAyz9Ncab57RxhqoBMXZ5hHp/EsBIHrzeHUkyeP4cbfzp05bd + FAV938pkn/WflWK2T0jqTfbs/58IwBsC9C8jAcTrWIGBsxL0fbvuiZGh7DAtx7GkNwqPS3nPUGevNgN5 + fOA3v4thAcEcK0Ps7cc5H8KxgwW2nMd7jFXFyqGmVPz2RCgkQxj7a0xMP1QYDs8fpjkASntDANEK3L2I + /cdr4hXUehzCgD0Adn9uiBJATyarAEEgAJBBdrAMsvmoPFaG+b76f8TieyMMA2E/jxDu+Soog9+6peAX + 3+r8RV/G7NxUy7r99V4/0E7WZd3Rcite5Kt1m3/zk7/edOXrn90K8N8E+9kF8uHPVsjrqxbKvtW4YB+G + Z8o4B3J6oQziwunHxToCCTtW7ND+8YFixJAVzEYjzoYieCVtmXz6xA8QStyAUAL2+xtF/rhK5E9rRB7n + DTNuk2PP3iSvF66UvQD/OCT8ofpkA+LGRNPNxvifCqA8XDP/BMgIwwCGAFQAzYmf85ZKAFASpm8gWo8Z + h2oY58Wai+3VcTJw/hxNAPYR6CuoAJKmEEAvZf6KqVL+i8B/otz3en6uJ6oAyUZVnD0HioPVgBTpuCNa + hrPCTSMPgDxSFAYCAEnhO2sMP4kAvATH36RgRggwVBSuoO/PC9GSnjb2sILQiPPXkKQjAfczJKiJ0xDA + 5ACCZQghgFEAIUog4xXMEyQqAezRECBWSWC0LEbDhB6EAN3p05QA+jNDoQDCoECiZKgcYYJauA4THi01 + SUcOyX6RjVvrY6RkdcrLmzP/cGWKyL/9/pVmP9BO1iW96lnrFx/3fbP5sbuefPvaSz/57Obz4fkvkI+u + O1tevRYAuxOeZd08OVSwCBfJXOmHVOyGV+0uw0VE2VrsxEXgxkUBj10B0NbjAmmKkANZyfL2o2eL3HsV + QgmEE7+8WuR+EMIDPxR58EewH8gHT31LXiqaK2NN8CKNCbj4Y01HWx2344zsrQBAykJ9SUAdFsu4vi52 + AhxTCADfgc0t5U5f6GDq7XifXKeMr/LI4AVzZYTxO+X/ipQp4Kf1LE9UAjhR0k/18P+NAjgzaWqosAzH + Lk/QEYM9Z8aCBFKl43b8hmxKf5BUMcIaxPSs8ROs7ODz/h5jprynsToUwGAR+/k5si9Cpf1gviGSUYQP + 41rTZ1twop6/fdUerZpQKbABaCAnBGt4dnb3cYwAPPk4PP4ogL8HCkLXIJlRJY1w7BckPRmzpBfevy89 + GIQAImD5sQxExAFB5SAfENcIwkAqh+daPPJ8TaDsz3JIy+0pH2Y+e8/DP5W3v/7UgL8t+KRcVn10wGq/ + 44fWn7rTw7t+9fPq9+H15cZz5bMfny2v3bxA9v8uWUZ2pOJCSQbgwnBRfVX2lkXoOHRmikcLEIfC+/dB + CQyVfQMXkFOGaufJSNMcOVy5SJ7btEiO3XaOyC1439u/JXLXpSADhBX3XC5y38Xy7oZEOVqO969LlbEG + ynqH9rTvr0/CZ8EzwauRAEa1iy/S9M3TmNyrc03xkhPbcZoRH9MLOcpIa3w/ldk5iHGvd8vABVAABO7Z + IABm6Sd5/ckEoAA+cyrINbZfmvC5fIA3RPBWAJQ0ONrQDgHYCty91IkwYLa03Yp4PMOEAGMlUDklDtNm + q8m8OAX8Xvv3KQFwXWuSbUMl4UoACv4CE9NrJYCDimpNU89YtWkCYveg1usLw20CYH0/FFI+UAlgpDRG + vf4oSH200hDAGEmgjKQRoYDvYfyfgfg/I0S6se7JBQkURysJjJQHKzkPF7s0nDgK8n25LgDKAt/n3tnH + ix+4Nvf6VxoCMrc8bN3ynj8PcNItYtv28nWL9l932YF/Afj/uGWRvPpQpLy4E56/kNl9ysMkGVPvEqGt + p8Pw+kNFLh05tqfAxJjDuBD2ArR7arAvPND+mmQZz4uTVx9eIMfXfFvk1itE7kRocc9FWF8ln/z6Ankx + HbF+dRTkIy7YpkQtdzGRRQJgcmpUw4wIXZtSoEMHuDBbbVpfTaZcgc+eARss49UxuCAdvsShKbUhds2F + t/p5ggyePU8Gz0yV7vMI3tkqy30EgLCgH8SgeQBK95VJ2v3Xc2a8Zv+5JrB7SRIkALXEL1gb6yPwsX8P + qwpLzPiB7us80rs7TAHMkp6p74dqGMBmoH21TtPQw/JfXaw+3quNTbE6AMjr+SnTB/MiQQBRMlwSrfE8 + wT9OsuAaxqTpYJHJFTCJR+vP5QAhnA+Eb2ztHWPDEMIqEvgetvqWubXK0EPAA/g98P69mTYBZHNmIvwv + IC6S8TD+l0FWBvC/HML3faElQZ4niawNlYr7zhv8Y2v2bF5ja97f4wfcybbc++6Q9TP551ez0x+6/vBP + l739z1uXyT8eXy5vls6VF5soDXGxAYB7qhNlpNKjiSLWjwdwQfUBUEOFuHBo6hEANr3o4IFrE3ARuvUC + PPh0inx4y7kia64E8KEEbjtXKwsfPnKeHChIApBD5XAtLu7GFI0jKd91IAsz06x7s1GGwLe9/ygHA1XE + akxsvL5J/B3UfEC8hgBj1Q47cRg5QQCQydre+mMQwPK5MgDrOtcDAmBsPlvzAPT8U/MABrA9zOKfCdCu + APhBBgS013iMb3uFeY/JRnXRQxVxVoIMLUmVruVu6f0xVMHucB2pN1JividbgRkGsBlof41TW3r3A/j7 + uF3jNB2R6s0N4Gla0gOpDeRzkBD3SVIpr2U9nPsxdvoBjFrWg+dmDN+XC8uhImAewRDAniqnDENpDZM0 + ERaMlXm066+XCiA9FN8V8j8jSLoQCvRkgQAKo7QteESbgty4RhyaEGRz1vNts0EA+A1poVJ9x4I312Y+ + 9uMfyvtfvfWdAT/gTqblnM/2WL/+W6d1/5s906uf+OnG5+6OP/bmxjnyesliebVnvhxpS8AfHKYMP4YL + SwmAA1Lw5w+UTJeOilOkAxKwF3/+QBEkLTPtJAAOMGEMykYUxPIHs1LkzV8tFLkeIcAa2M0ggTsvk/cf + Wyn7SlNkXyMuHJDFaH2iNrBoHRskwIuSBKAxJoHPbSUAp17USgD1bl/i72Bzkl0GpGLhft7GIYdOuaXf + G16s/5o4GThztpJAx9mxqgAYl/eeAF4D6jgf+GncNo/jbTuBAE4Av88YQpyVKIPLZksnj/8hnttlJPwE + AUTqbzXtwGYEIJudtOGJv7PWbZf0GPuzCzBK+rKDlQCGCmLwPuyZSLCBH2uvDSHzPJIA+vMilAB6s0EC + 2WEKZMp99eJl4TYBICQhAYAcWAIkAfSkh2g4QAVA46hCEsBoGduCPVoOHMS53lcZJc83gZSrQ6AendJ6 + a/wnW/+w+qlb3x857bZ3eq3zZdQPvJNlOVMOWekdWdbGnryEpvvObH/p2Qh5BQB/rcMjL3XHaUfeYFEQ + Lg7EibiwRiqhCLRLzKllqMFCxJAFuHiK3NJTBM+qBBCnRhJgLKrevCpOjj6dKP+67SyRVZeAAC6R47ed + L69vWCQjVYjzG12asR6B7B/Hxc5jaKMVThv8pvxnFACAXBZjFEB9wkSirH6idk7bU+XtHXCYzsESh7bO + DqbD830PBADQD66cJ51nu00I8AUEYCzhv7FEX8hwImlMfs23DwigG+qBBMBGoK6rQR47mcwLM2P6i433 + Z/2dNXzTDRinoN/HkX21HtPZV+XR8h3BOVzoMO26kPKD+ewPoNpxazxP8mRWX/8HJvlwHgh2dvL1sr03 + JxLbUBBUDqWmsWeoHO+LNb06Q4Dh4hh4+wB4/yBbAUAJZBgS0H4AVQCxWg0YxH9CY+n1SEMEyDhcjuL5 + 0YdjpPzuS5oePVzjeuxorfU12ecH3kmTAPznqNX/kyus3dt/f1HTHckvv7ArSA7Wni4vdc6SF9udCrDB + omA7Q5wA7w8S4BBQMPtgPv74PHiYvFgtY/UUh8oQB+zUxE8yt3rzsdooGdsVK288sFg+vR7e/6aL5eO7 + V8pLO+fIAGNUZrhrEmVPQ7KM0+vhc/eSEHgxqle0a/9ac8ZFCpCwXMb9vPH/Xr6HHf/zOYYuJm8QY4YQ + F8cYAtgZJv1Xccy/UQBdZ8f5CMD0AyR9oUefDPYvIor/0/76eHkygA/iWZoq3SCQ9ivc0rXNNPOQAIY4 + wq/ENPSwEUe7+FgNYD6Ek3xoX79bR+qZ+j8VQKRm9PtzGM9Ha1w+VhGnHX2jlQ6N5ycIIEYnCGUI0JsV + quDvz41UG+bcAiRb7M8JPkiw6tkR4/dyUtBdgUoA3ekhPgLoyQoxRFTiVO8/ABIZZEIR5/xQQ6gc5XTt + CB0Pb3BJ423LXniyZN1Z6esfsH78sT8ReHJ0//1rr/XgPwb17j81961Z3fur2e+9UIw/rD5A/twVIK+1 + IIavjNf4ew8voKp4taGSaBksZmlphRys+ZYcqpoL7xogfVAAVArjNQmfJ4AaSF1cYEd3LJFja86T4zec + K/+8f4kcyouXXs4uSy9XnSxjSgCxNgEk4P2i9fOZ3BoqjjQAASGQAAhsVQoc/uojAKMG9tYzLjWxP2Pm + PbiYlQAAnIGtIIDLOVFHivQDjF2cvmt5qknc/TcevWtZ/BTgc/1/kvuT34fHdi2N1y7ALvYA4DM7ETq0 + fSdWuvld8k0TD2N0rwJgpt+rAAh6rwIwBBCrBMASndbztakHoU0ey3ZRJn5n6U9Lek7dZo+/KQWGmxAg + x2vhOlPQSKm3AuBSY2WAA35GSxEe5Rr5rwQA60oPlk4ogi6QAL8DVQKrAfT+JAES9L6GEHkeCuAlXE8H + cyOk646Ud3Y/fu/PmQi89Z9D1l0fH/AD8P/28uDxI9bu/hrr9yKnNF974dN7/5j66V/gcV8EmF7uRhzX + Egew489l+cwG/2gln2Opbq6888Ja+eAfDfL2a9tlrPlsHZLKBh0Cn+BlVpngZ+16b0W89JXjYi30yDsP + LZKPVi+Qvz96huyBB+mtBphrKG2TcEy8lrr214MIlAAcCna2nppmEzP7DT3UeKXJE+ytZ408Xk3DDZ0K + y6Odgir/se8eXuDwjiyVDW4EWL7DEl0CCCBFOuGVNUE3CdTeMuBU7x7/haCfrBjM4xS7r8D0F/TQ83M4 + 8LIk6Vjpkd5lIACQQuelcdK7KUoBxnq+9vdzQFBxlGnHtcOnvTaJcltzHoznATrG4IYAOEswk7CJeB+H + ke8c0INzSq9OYLMyQAKg2ujNDlHv3ZMVBk/OdTCUg60AKsxU3+zyI5FQBbDppzuT+4Yp+KkG1HYH4DuE + GgVQ6jIqoIRJ4WjZUxuG6yhaXsR32Vc5U3oe9Hya94sf/+Fmkf94/OVO6+5PDvoB+H97eQAsnLn9aesP + h/cENd17TsGhTfHyamW4vNCUJC92u+RwC/5UgHqA8pu94ZVxmu2lzDzYvFA+fa9QRP4in3zUJfvaL5ex + IiPLjQLwEoBbS3r7KiD1QQC9FVHy53Vz5J1fpspfnp6rTUT9VWxhhQevNFKVvessJfICNgTAuN8QAL2k + qQg4dRirCQFY/kvUIcTaQFOfaBKIlfbMQQQELlBOn6XDYdeD1L6Tqp15TAR2aVbfC+L4zxHA/yQkmDA+ + TvmcGQJIlPYVsSCeVH2u62K813rE4znB2qTDEEDDgOJonWmHSTz+Djb1eM+jEkDVVAIwXX3RGpINFERr + TL6niklQj+ns4408qtgUFavJQxJAr/YBIGwDqLszA00lotyl03uN8r/G/zzCMf88BudNge+1XbbtDtLv + MIwwQQkAqmGghHMU4rvXOOTFJqc8r8OLvyFDT8ZLxj2XZt75yWvT/9heYN35kV8B/F9ffvnPcWvbL2+z + HqiqDq3fuLL0CJj81ZpZiN0S5fkueO4mepYQlXYjHPjBBhSAiRfZeP1s+eC13XLsg+flw7da5UDzFTJW + aCalMElAO/tcY8qAY+XzZbSEN8IIkNHsOHnt8Xh5YWuKDJUzvICXqE7QsehcH2QPQbXpTBuCt6f0HyqO + MkqAErk0UrPU7DrTKgPr5LyZRkOiEoCvfFgepdl1xr2jUDI+AnjaKUMXz9bBP33LWJKjZwd4V5wI+Hif + qYxfFmebUQIngt8QAr39iWa8P7dJAAR/74rZ0v0tHPeskeTa0ccbbxSEaO2diU4d0DOFAMww3738L4pj + NHloegDY4cdYPkbfa7gkRhWACQPcvs6+PXb5sDfHJAAH8pzSlx2tCoAEMFrhkWHb+w+pAdQ4pr+ICiBU + 1UI3k4C7oQR2hSkJsIpgCADeH+d5QIcos504Ro40RMshEnP512VsV7JkPnJR4apDewIfzliPMMA/Tdj/ + 9eX2f+21Hq3caq3p3ju9unJl5qG6CHmh7uvyAu+v18k+8kidForDPZUA7FpvPxNPRQBe4+VytP1HcqRp + GQAWIGPaUea96OxONJ1rDsRRkSR7cJENFQVJL4jm4C6APicBz3N22UR8Fl6vA1mwd706yR6YgouQmWWO + MSgMVyJgVp9lwD0Vpu3USH6Pen9jiaoKCBgOH9Yx8/CoJADOpsvGmcEnAISLZksPh/0yBCDINcZPmOLt + vYAnORC8XilvtlOmAN/bM2AUwBeRgDmm/SyP2T4TquBC7PtUhIYA9Mw6WKeAnYFRGn+P1di9FDXxvno+ + Z/dh6ENSY/xtegDCNAfQl8MhvyRM/g9x+j94QwA2TY3YVQDmCbgvCaAf654sdhUaAvACX4mALceM63H+ + erOjDPgzI6QnPdIQwG4qCeYA3DopyKCGAlBqxfHaqr2vPlT2N7LLc5YcKE6Viuyrdlz4yl9Pu6OjwFr1 + gb8S8H99OVXEWv96r3UF4rKh9nPXv1DnkBfqT5e/dHrk+dYUzQb3URpWxCkB8IIgw2sSKc8l3Xlu6WVZ + KX8mLtzp+NPNEFGf16mKNS2psMFKuwkHF/oALpSRApdeOAO4wPaVQ7LjIh+pg2SvdWsji3YTQraOgHzo + /QeLIlQBmDp5lK0APHbLrMfn+WlmOGyslhBHOWy1xOQA9pS4dPqsgUcdMnh+io8AuijtCXpvc8+yqbV9 + SncvgE8kgMk5g4kcQsr/kQC6liWbhOD5eO+18MZ5phY/bJ8fqgHmPBTwGgol2N6c9XwvAUwoAFMFIKg5 + 7VeMDJcyCZg4hQC8g3t43FCBQwGtlmXie34HHdhTYf5n1vVHlBCMd+d7d2kFIBwKIMImgFBtER7A+w3g + HA/SeL5BAFoOrg+UgyCA56oi5FBVsgy3XP0HS+TfHvnroHXNR6/6AXhShAGf7tFZgF9uOeuJ1+AlXmiY + JX9rYz/3fBlE3N5Z5NQLgRcFB36QEHpzOFMM5CbkanfhN/EcLsJCXASs+VYZz08iGK00cexYjQtx/iwt + dQ3kAZj5MdIJIHeVheuFs78sQWPUoTp4dk7iUZviUwBacmTXYaGpBFDSD2sY4NCGGJ0Bp85jA9+j8+Ab + 2WwIgN6fwBrlgJuSWC2b9f0OYDnbjM/vWYL1MgCRXn65ifE7l8b5JH63ZvATbNme6gMzt3vt9l5vhWCC + EMw+lP1e8vAqiDaEACSA3uWp0nlenLT/KcBOAkaZe/ixH4DbVFNaw/fmU+zeimr31BDATgIO5EZDBRgF + MMAkXJUZ2qtlPWb2GdtzYFSJUwm8JysCwA+XXnr0LBOGDJe57P/ZNYkAjFdneMH4vzs9FOAPlfYdgdKZ + FqyVgF62FBc5DAGQ3Is80s+p1+pn6L0ZDpEA2N3ZuuLX7xecZt0sR/3AO1mWJz5uJgH823NtS59+qTZc + nm8KkJfaOf9csgziguwH+IZUDoIEytwAPS60vEitObOBZIAjzDjZJMFJ0NPrwPMP2xeekgEfU34WRanU + 1PIVy1h8b1zo49X0cmwAoudPNt6LHo+z0jCrXGRyAMZMOXAYBLCnyu1rGdZcA1uJ65g9N23CvCce8w4c + qchJNzgOQEOA+wDacxMVoAR2J4DbAaB2EbQE6/JkX/Kuyxe/J02J5b1enq932sd28zk9JhnPJU15rnsZ + 3k+TgE6scfySOdLyLbd0/cahSUA29WhtPy9Uv6P253NcvlYAnEpo4zVGEegNP5lw42xAIN6h/Gjt6hss + 4PTfTiVjo9pcvsy+kgHH7+O43rxgrQCQBHqyIuHFwzUhOFQY6yvlMaNPIjAEALLHd2OysAeyv3tnqHTu + DJJuEEFXGh5ngoD43+I7M2E4ABXSr9/fIUc5pLsqSI7UOuRIc+ojstayVou/D+CkWTa8mc1xAKfs71y5 + 84XaUHmpLVJeaGf8D1kLcHOAB2XhEKU4vQfjR403TR2Zw0L7OSEFE3SU/QQu563j2pat7CwbpLzlGHLb + 2LFGEhgqo9RN0CYj2njNBAHQg3PaK9MlF23eo8iogSH2AVTZFYa6OFMm4/0COWsOb3FNNVIaqkbPrwRQ + FKGDYfrv8kjnufT2qQrODhBA5/JkH3gnA7dTR/GdmMxLssE/1SaOT/r8a/wsPN++wiW9VACL50jrRbHS + 86BTJ9gwBBBhCECn6nJoLwCnAR+vNjP2MhmoSoChUalTz6EhgBhfI1A/bIB3D+b/xem62EjFORHYx0FS + gJfvywdoWQIE8NVYCsxkHsBpd/M5p+QBmPjtx3/QlTnLlP92BkvHTigAtRBNEPYXGgIYYGciCUC/v0fv + bXigJkoOV0fIwbb5a6k2f3Os0w+8k2VZf+gx66GXsoMH2s+qfr42WP7cGSvPt3ESDshjTjfFbjDW/uE9 + yPKUe3250Zr8ofXxdtM2AQyTADj7DEC5x05aKQGwx7zIgN70sEcoGQxq95nbJoB4NRIA1QATYKoAiqIM + MIoizCw07EtgRUAVgF1l8NbJCf4Gc3ssnba6xHTW7Sk1A5WGC5n9hmS93SkdZ8cpKLvOJAFAESxP9QHe + 6729ntwr4Snnu5aCLJaavMAXAd8ca1TB5PfpZtIPIUP7Srf0LE2S/jNmS8f5Lun5lQNgDDIj+VQBhE0i + ADOWf0xbep1mtJ49Xp8KgA1EfTkmEz+gXX0k50hVAQStV4WdWNsn8fZkT4QBTO6RAAbzXVOA7yMAPMdE + YHdmgBJAZ1ooCCBIOnYE2AQQrspwgElWfPZAIUPFKG0i401NDvMeB5UhMtK1Iu17Iqc8/kGNH3gny5Lf + e5O1e+Bu90DTGcPP182SP3e55bmWeM0I9/BusuVxSgCD6jkilQB6c6K1jEQF0AuP1YsL0fQKxKnnH632 + hgCx6qXZHTigZa7JBBCppDCio9AS7KRVgpKB2ucIwOxPAlAiYA6g2iT7fA0zTCDWuU0ZkBevlg8jtcuN + CUTe1473ueu91SmdK1nWS7EJgCGAF/CJPknvBfXkcl73pMcnEoCXPAyRJOqxPStSYeZzulamgABwXpcm + gwBSpeNchAO/AAFwqm1O1MmYnueS8/bpbbviNNE5QQCxdh6ATT0eDb90TD+VWG6UhgG9HOHHpJyvtdel + BKwEUOHW6sJAQbhpAlIFEDahAPKcqsi016Pc5TOt7ysBEPyBmgNg/N+xM0DJgA1CfQhDBlkOLGbfAJPH + Dh2TwHEMRzk6sxJk1Xle9R/+VhW85cWNfuCdLEtL+2VWQ+c1c0cbZr/8QkOwvNThksPNcZqp78GFNMQp + n1n+UwKgAqD3IPiNt+nlwBKGCpwmmo1CkH3DWjFw2YlAk0jqL8QFxt51OwRg/NqPC1G9UmW8GWegjUZx + eozmEsptAtA2WTu+BHEw5zDMach8BODRcQM69Jhz6bELsdwMWR7U/AEu7GJK3ACdBad7DRTAinj1ykzI + UQF0KJhTpsT0U80k9DqXGutaljT1Na/ZJKD7TdpfbTlCAI4ChALoWZIirefESOfdDunJ4Gg+E56QALQS + UBStAPLO2W+G9rpV9aiywmts6+3lBB92P38fFRlDAVYCoNx01CZCAIYBek55bvF8X36oqev7uvuCpBPG + PADjfw35ypy+UMBLAD3ZIdJJBWCHAO07Z4IAQrQ60MPvX4x9S6gUDQFoxyi+A2/ueqAyXLpazupfN/pH + 187B+/zAO1mW4eYV1lDzOUv218e/81JzhLzQ5tSJOHshSXsLmBDCn6r1YJsAcIGRADR5RI/DkIDenJ6D + 4wa0jGS6Bk0mOt4ME2UTTqGdBGTYwESgKgCPL/4nAYzax41oCTDWVgCRCojJOQAmFU2G3DOFAMZUDSQo + QDTpyFCjyJ4MI5+z2+Jiv8mhQOxZPlvB2s7MPyX68tQpCbzPS3yvl5+sEj4v97lNz6/5hSUJCn7mETrP + JNHES+cSQziNIID2Ox06ws548ZBJBBClYJ1KAB7fjD18zXhy3r03RMOAnqxQNZblFOw6ItCUZLWMa4cA + PIe93v8Q1pURoiTAvACTvtxPwc8hwrYaYKcfFSArASr/Ye1ps4wSYF6Ag4sKY5QE+jQEiFHSZ8nyCJuB + qqOks2HZgd1dtyfmdtzgB97Jshyqn2cdajhjxaHaiH+92AoCaGe7KWJcALufdXo2eOCC6Kci4KAOZo+z + jQrgdje7ynSCSLeC3VsxGLHBPKrhAwnAqTVqDlnVEWicwabYxJujlZ4pYQBNiQSeRysAhcbza/Kv2OQT + qADMnAPxdiKQVQSPIQF2EXK+OiUMdrLhc4s5h36YTmnVeT08L+X5mXMQ+7M7jwBOthXBBJA7EOvTvID3 + xveTE31eQjiRMIwlK/hJAh1cL41Xa1ucKC1nJUv1hU5pvtulMfhAjrnN17BWSsIV3EzY6V16OCVapdMG + s2sqAWQH6KQeSgCZwdrjz1KguXGH054YxDPR3svzUsw+gAijAHxhgPlfmbxj3oeAH+JwYChAlgENAUQB + 7LOkfccsrA3wO1kSZFiQQVJ36Lmm9+9HKNCvU5Tx7s1JMJd01S14rqT9ptSK1p/4gXeyLPubFlr7mhYv + P1gf8+ELLVFytCVWpWYXAVpGj45wABdEL9tBc8IM6Jk8yjJk0MWecnpoSm4lALcdCtjhAJuHSqJNs0i+ + Q0esGQIw4NS4VL3+RCWAg454vCGAKDPkFBct42KSALsCdT4AnXPAbSuABCUA9gGYyS9MlnyQ/QmFMTqm + gXPi9+1G/Hqt08TnZ862ZXmCEkDn0uQp8l4BvyxpisTncySFdnr2L1IDSxN9uQAf+Jck2GQSJ22L4hB+ + zJaeS8+Q4RvOle4HUuFFg6Sf8pu9/flmdOCgKgC3JtLGqty+7soTFYA3BFD5n21P8sFEIKsevhKgS3MA + Wt8vdep5ZO3fdPbZJKAEEGETgNsHfuaACH4qQSb6OAqwDbF/ux0CdEABtO3kBCH4T/OdCv5eEnZxHPY3 + /Qwc23GoDgRQv+i5kq6bUys6fuYH3smyDDWdYQ00LVm6vznpnZfa3XKkxaMJvO58zvMWrzmAfvyJPcwc + I97vpufIYigA6ZqDC4kXH+U5cwWsFmgI4Fbi8HaS9ZdESR8IhRemlqpyI+1sdcwkAvDmAcyIQ5WeHHZs + 5w2M/I9Wr0IC2FPhmZIDMGTg0VGA3B4udfpmzSEJsIowhNCjLy1MOn8WY2f0IdGXJUjbmXHYnuzNp3p3 + owKmSnyvtPeuvfH+5OfbF8f7CKB9SZzpOFyWis9LkuHvr5S/r71D9j1+ttbU+7Oi9I47DAFYVeFvpbce + r0zQAVKmohKnoyVV4VCma1NWkLl1Fzy/z/A/MffBkZk6mErzACahx/dkItVLAEz+aTWAg4LwnIZzVH2l + saoESARs1hpgrz/+L5JFu4I+ADYdNstHAH25LoSNuCbwf/UVulUxsC15H5TakYY46W5ceji3c3VyccfP + /cA7GZbrP33Xamo916pruWDBnvb5f30J8v9QU5xKvh7KdWaaWW7CBdALz0Cwd/HCyWJCCJYTJT0gin5m + fwHIgUqPjwBMCBBvyoel8Ao6DVXExCQUtgLwdpyNTgoZRirtFlQm8QrMxBcaAsCj9GvjUZgSgBnp5vQR + wJ5qkwPYY9fJhwrMmHnNG3C0HaRy7/YI6fiRQ7qXcnbeVMTiiaoAWBHoXJr0ucQdwd92RpyC2Qt0VQD2 + Yy/AJ/Y3CoCvTyaAtsUeaT+TdwaajecTpO/SBTL4gzOl/xezpQsE0JcRoRN1kAD68oNNgrSUg6QQ2lR5 + fPG8EgBH+THHoQN7gnVyD0MC9pTduaZcqhOBljE8o8WYDL+XAOwQQJuBMr1qAITARKTd0ee1fhJvsekv + YPtwx64QHwG07pghbTtYGQjXa4IEQAXQW+DCezk0/6L9AI04Hy0r927quiMhreNGP/hODgJ4z6ppu9Aq + 7Ppu6mjnkiPPt8bqLbno7XsLXRr7s1e/DxdEN+LTTniXDiaMwPaduHg6QQYkgIFSt48ABpmdZvmIRFBO + 7+HQJhJTPpxMAOzom+g5n2o2CeBYQwAROgKRpgqAU5GX2xNX8I5BSgRxmvXeUz1RJ+fsP3o7bBIA18xd + bA2X1u9HSediePTFiP9tBdC5JEmBOeGxTdzevgQXLgG/jJao1sbHtirwefrJuQIeZ4PfqyLal8VLK+cU + XDpbP6v5TKc0rHBK008RkuwIkL7MCDNbbx4AnRugmXoSwN6qRNP4U2HKc1pd0ZF9bk2M9nlv3snx/Zyl + BwTAUiB/MwdNcZJO0wwUq8ePcmAX4/mc6EmNQKFmmC9H++WF2IN6XL51v3aEGjBzEJEhgFkA/zRp2Q4V + sJ0hAY5nRyH+o75ipyqAnvwYbUtmC/JhKIC21rOHnui+z72p6xY/+E6GZfVnf7cKOy+3Ng/dHjPYc27r + C20J2k7bnQ8ZWWTqxsz+M/5vzw6WdlxgBH5XZhSUQIR0sRuwMEZvBjJUES8DlPwAL5UDQwBtHYYc7M0P + 0/Jhn88itKNwuMRtwO4Dvhlx6FUBbBTq19p4uO5PAqA3ZyOQzg9Q4fTNe+cde7Cn2sTJjHP1llm8+01B + lN45ZxCExQk42q52gAASpXtJirYAty8nWBNVAXiz+gpo9fTw/kvjbQIAWTCJZ5s3UTgB9kSbFOL1OD7n + LQ2SAFpAAO2LE/Wz2s50S9tyj7T9OFw6twdKfzbzIyTIYO3U00qHTtcNdVNpOiqNMooxLdYMt4qiNQlI + z29UQJgZ508lwQFFOl13jE0AJuFq2oGdOm7ANAKFaRmPsb32A7ARqcTlywOYEMCpqoBJWxIHE4CtO2aC + BGbqunU7tkFiHen47AKSBd6/IBYEwM5REHRppI7SbGq7oPKe/sfD/th7vx98J8Py649HrTv2b7a++0rT + tJqBH//uxcbUt8ZwwfTkTpNuSr9yXJAl8QryLnjuTib9AKKuLEhoSMHOnBAtF5pkoUkYkgCYDByp4GzC + bgVsH0DIvgFOWqEEwIYiSvJSNgx5wwaPPRmFaXZh78BAUaQt+cO1akDlwP4BUwVw2ARgSmSjVTH26MN4 + 9Xb9xbi4i2ap9B/mIJkCACUnUAae9kjPVW7pWhQvPYvpjVmfT9DSHKft6lzikY7F7ik2eTIQvu6dG8Db + DORVAZo/IAnY72H2hbpY6sF2nFEBZ8POAiEgBKHiaLsGYdRm/DaEVTq2P9se48/x+ZzhtyJe8wBjvj6J + GDPRCYkW56Enh4OJqAIiVJ7rTD/ZgXru2NarzTx2OzBNO/1sAjDgn5joQx9nk9RdertvJnb7OSUYBx6V + OLQVnEquHfu2pwVJR1ooCCBQWrZBDYDE2qEMeJ30gQSGOVK0KBHfKV72FcyU0ZoFb+R2/+wXpz7/6inn + 76vyg+9kWB78ZNR64NVCnROw5IXHzmjt+UHdYHXCsf7Cb8pAMeQkk3+lAApA3pULyZ9tZL/Kf8SLHdmG + AAZLOSW0kf8DFSYc0AYizRwjTADwuth4wlKVytwI7R7UkWMkjArj3Ua8Q1Hp/TloBeDtgSTmUFXmDJQE + 8iM1QTZqtxB7J73wTkXOGJlqgonHHvwG9YSanZ6l8rrn6RhpuwJebBEAvWQOYnP2ATD7nwpvnoTH8cYY + ty8xUr+L9Xx69mXmda471fvDlqUgTEhS4zY7Cts1dEjQtSoMPj4D77kwTnMObDjqPgOfeQbCjB8AiFui + bAKIMCU9zvEHFcDRj2NskqqMn9QsZW7fzU5ASvKeHAP4XpZnIcE7M2YBxLN01CZBywk9OOfCsN0OrOP9 + 4eH7cp2Q/AjrWBXZHaLWlW7+V3px7epj7wdBX2QP9y0iAUQhDGTpD2HAjiAAPwAkEKTWBlIgAegQcZJ3 + EUilMOJ4Z6nn4/LBVRlpR59I4FiA77/a4wffyUIA9+99ynr8gy7r8eOHv1my/7d37G07852DzW4dwDFQ + kSp9lSka4w/woilCOIC4rhvSn56ii52AjPkKWSVg7Adj1p8kwPxBCZtB2C7MTjF6K3hlzkcHEuhm9prZ + fTvjrINXSCDsGbDHoPfi2B4qgEJ7hBnkZB+JgJUBzvDDEYq8wDn1d5VRDsO21CUBdBcFaEJtOJ9VDaia + HHiqJ4Kk/qowaQKo21YukOaz5knLOfOkdeV8aVk5V5pWpho7azZem22v50jjCj4/WxpwXLP3tRVzpJnH + YD2xPVv3bVyRovvzWN1/Jchm+RxpxfPtbEA6E/uCXJp+DHW1hTffiDQ5AB1fwd8cpklQlex2G69WRvj7 + mNDj7L4gxO6sUDNKj/E7S3pUAFQESgAxWsGhDZRFqyJgMo8J2W6EcQQ/43lvVr99V5DJ8WhzV5TuS+/P + mJ7lQWb1u/AZ7bu5fwg8f4A0b5upRNCOxx3p4Sb5xzkEocD2VHBOgMRPO6rn/y1j/2/Ony7yb1d88nfr + qpf9g4FOmuWX/xy0Lv70TVUBGS8+c+X+jmVvHWz3yKFqyLbKudILr2MSex5cRHG4EPAHU8LnO/Bnm46v + 3kKHEgCbhfrY9svOQc0HeCZqymVJUBUeUw6E9bBnPT/alBZZnmObL/vUOfKMXopJRTakaCkKcrcEx4IE + WIbsQszbDS/Zk8ekFdYFQVruYinRDGYxM9T2lYRrHmG0CLIfIUBn1ixpejJIcq6eJdsXhcr2eeGyjbYw + THbMjpDtc7A9N1S2zQk1a9jWObQQ2TI7BPuabfN8CCwM2+G69tqW1FDdl8Zjt88Lg2E9N0x2Yt80PE5L + jpTdqRGStjhMSm90Sdc2kABbcrOCtEGHvfyDOiR38sg8Q47sqSC4uzQhS8B6Z+kN1GQeR2qy54KZeyos + rd+zhKftvPif8sOkIzNIwU8ZzyYelvFMTM97/jm1A5QE0MfwjURTbFp7u/Gfte2C5N85S1q2B4MAglT6 + t+0IRjhA8sG+hYj9cV20FUONgdgP1sV91leZ+kZ+/83JQ9nB1gP/GvGD7mRbLj32N0sus6yq537z4xc6 + Uj842Jko+6oidRadPkhHzfDbyb3+kljj7aEEqAYoF7X5oyhGlQK9P23AtiElD66TtbOQ5GEIwMj63txo + VQfsIOtHGNGH9+hj8pBenLVuhhLlCVpq7Mlj8jHKzkOEKmC6KIELEE7wtmHaP2BPacXP1bKXG7E08xjh + CFmCpXVTpNT/xCFVCx1SkRojZSlRUp4aLZVJLqlMcUl5SoxUwCpnO6Uy1anbFbp2StVsl27r87ZV2s95 + 9/Mebx5734ef45BirMvn4vlEh5QlRUvRonBpXBMn3bvckN6srIRofZ7nc1DvvOs9f7GaJ1FyhKzvAWF2 + pAP8TN5lhBvpvpuZfDPR50ARzhtAqxUYkrIm8Zwq63vYzQcvbzx/oE0CprmnDY+7cxy+/1S9PpUf/vPe + QqionGgQQJA0Q/YbAgjREKB9Z7haVwY8P64J/X75nIdwjhxml2Z56Fv1/VfNfnWTH2sn74LYrGZ49V0v + tkR/vL/NbrIpRRxXQY/uMcBmRQCSsCsfXhug7QZ4uwHKHm3+sMs/uFj7bMIwpGFsoCROk0vdnI0mN0Lz + Ab05kLDZkerV2T8+UBYP0BvT9+EwVMa6fK6Ex0bDi5MAzHHaiQgi6WGZkINYFDB2HzuPY82b4YUST4S0 + Z3MYKzzuTYjhdbaf2dLFOfp5o44z5kn34rnStQTPLZkj3UvnqnUtNo/1Oa69j7m2rfOMVF132/vpc5MN + r7dj3bp8nrSx+egM5g5SpeHcOGm/M0W60z3Sme3QJCt78xlW0WsP2uTpVUY0euSu3HAFPyV3J0uyu0kA + 4Zqd7wS4+0kAJW5VVSRmWn+x6dMnaXeANNp2BqnHb9defqgB7e2HosqJsRWAQ2P5HjXbs0MdtOOzWuDx + W7aHSfPWYGnayl6AMBBBiEkCstMzj/0EETqj1KEaj+yvmPFOw+CVC97wDwI8iZcXxWrruOa3f26JOHaI + 04FXz5HR8hB4Y/z59MYV9MwmIdSNGFwJAH+2MRBBQZRNAAB6uRfICTgmTnqZQ4B3pxfRagKbUFiTzzFg + 7mLcW0CpGq/H9nFffhaMqoChB2VoN2L5zqxo9ZZdWBsSCNeLra/EhBAqd3mTCttzak87CIB9DO1ZEfBy + UdJ2swdxuUdalsZLy7IEtfYlqQrKtmXJ0spkoL1uWZzge9x+Zooat9vs51qWJEory3r2623LknT/E60F + rzeuTJFmEA/3b1waJ9UXuqXlF3jPXU7pALF1aF0eZIrwqq/U7r5jxt4bx8P6AGYSb0dGhHQo6Ol9Q6UT + 6w4m9BBK9Be5tRdfSRnbfcUkA6eSbE8eQAzF0LJ9pmbvGctTvrftCNH36c4mAbjthh6H/t8EvxIAyIGf + SQJo3hqqBNCseQCogm2mCtCZC/WSHyBDeadLZzmnaI8/PlYf8U7lyA8W/SXDD7OTd3lerLqOnzzyfEvs + J0ca4GmqUmWwMsqAWeU45TnHBEQrAfT4wE+PFK2tw5osKjcg7i31qJEAaCQAKoVOJhBzDIF00vtzsknO + LVDIjkF8lh4DK3frup/H4nn2JdC7dGQCKAp+hy2b+V6RJlNdZvIGEx7TSF8OT+1C/ErQtMDbtd4SK63n + sDEHtixOWs7E42WJai2s13uJAevmJXHSDLByuxXPtZ6Z6LNmvm7vq8/Zx3hJhe/l24fHn0migNdfhPc7 + wy0N5zik9U6PtO6MlHYCGh69Oz1KCbW3xE6+lbjU6L1p/QAyX+e+7bsA3LRwXwzeAe/cAXD3supRFGsI + uYj/mUuJg/ma7rwYEADLdwiHIOPbdpBAQIzw4pTx3Tk4psCjYYDJ7TDH4zbJvdwY/dxmxP1NW4NgwdKw + ebo0bpkpTVtsMmE3YJ6521AXFN2hKpfsqYt5u3LkuoV/zvTD7KQOAUq6r7v3cFviR0frAeKqJBmoxEVU + htid9WDIeYKTcrBLZby5mCYIwKEX3AAJg6AnkH0E4DExfL4hAGNRat255nh2jg2UGqKg1yfhqPfHezB8 + 6AVBcD+CvzM7Rj1VZ2aEgpoekQpBk5SlE5K531YE/XiN4xbovRp2zpTGVdHSclY8wAiQLoEaWOoCeAl2 + L1gTfCDm46bFHtvizD4+8yg5eE3JY5mXPBLsfeL02GZYK9uB2SOwCGRwhkcaVkRKyy0x0gwQtjEjz/n2 + d0ea6goz+AR8MaspZoz9QJFJuqoCsAmgfVeEem6SQBskfDtn6s1zaidnH46lAui1h+d6FQCPbVPZHqoE + 0LYjwt4O0x6PPigAs79DiZ0NPUz49trHNm3DOdwyA6APBAFM8xlJhaEM9+/OjZPu4jg5CgIYr419u3Lo + +gV/SffD7OTFPyxt6OY1BzpS/3m0YTYIwG08eUmqATCBXezRJE+HlgEB+lzTIEQzBGBAOGDLdlUDdgjA + i8kQQCS8BICbAw+uFqHP8YIlwZjjDdkw4aimMTzCB5IGPT+sSxVAhMaz/B79JSbMIAH0c/QalACbWHrt + RFhvjgsyOQIEcLrUXRcqTfDEbUsgzQHEpiWxIAKAdXGCSvoWSnaadxvrZhpebzqDZvZtWuIxttitZkgg + YdK+8RO2CCHHwlgdV9C2EIoB71O/LFKaVjmUAFq1Hs8pt6Fq2DZtE4Dx+i6dZktLoQQxzrUhgFBDAiCA + 1p2GANp2s3eCmXiaS8+rkfEO+1iXkmabHbcT+DQm9fi4Iz1CSYL/Va+Svfl/NSTIc9gEMF0atpwOEpgF + FTBLyYBKQAkghyFigrTlzpF+KIkXqmLlYE3cP2oHrp//911+nJ28BPBTy9q456fXH+zwfHigfqH0VgZo + 6W24FKEAYvmBUsTzRR71+l2IBbu8QIQ34gXC0s9kEHpJwOuVWdriYKKObGbjI5UA2uiVcyLUqCyYuFIr + tYGsBODWoaWUoPycdsTJbbgIOyD9NQ4mAeC9+N1MCOElAJeue5g1Z9jC0AFSt3HHqVLz0yBpZBMOE3OL + AFiQQLMCleAl+JMB4CQ8TtS1d5uvN8J7e60JUr75jDg9VteL45UszL4nGo4FyTQizKhfnCyNS1OkenmM + NKxyIqYGATB+RhzfmRahDVckgAF6/yIzxZbO81dg5ttjCMA4Xj1+WqjW4FsRw7ewIWcXFYBbZTv/kx67 + RMsh24aEHXrOWncA9NuCjW1nTB9kEwBCqjxDMiSAbv5vzOznR2r/B6sPzTugALbOMNJ/a4CGAk1bmFQM + AwHEaFm3vTAEBBYoo9URx0cb571RNXbL7Nfy/9MPtJOWAB60rM2jP/vZwfa4D/fVz4f3D9Fe/qHyJEMA + JfHqUdTj59ADx6gU122W8pQA4iZ5YbeR7zaY+wqcGuszEdfBEWVQEG1Z3scRmh9gs9GADXqWnqgolASK + zMAS5gzaM3DhI4ZtzwjXC9kQQLTGuv0l3s+OVenPEhbvQtRdSLUQhQs0XBq3z5D6H0cAkEnwxilQAIkK + YANoQwA04+kT7G0bxIsTfeBv1u04nxpoPsO2xXy/RF0r6GmLuY4H8OOkDoqhFsfX4fWqZTFSf5MTgIJH + 3hViEnoggI6sMK22UAFo7M6yXIGZbZe9EFRC9P6tlP6I/dthzMQ3bwc4OV23DsuN1bBJSQDH8Pwyu8+Q + rU2TgMEmebfdNiUCowC6c526H1UAlZ2qr7xI8/+lh+D7msRfI8CvBvA3bWFzUKgJ0dg1WhiO/yNUBqsi + j+9tSHmjcfz6hDeLv+kH2klLAJssa/fQjd8/1Jb0z/G6FPWeQ+XRWgFgXM/4nARAud7JcQA2Aah5CaDY + JPG8BDDZGIt2AKjtWfTisAx6cIAygyRgRpH1q1xn3RkerMQL5FjtQNT4n0k/tq+q9w/XhBdjXnYlKmC8 + IUOJUQ+9BFCxAQO/ZyvA1cDk1Q9d0rwoScGpQF88AXLj8Q3Q+RrVAJ/Xx/p8gjQsjJukChI/d6yGEkuT + dN0IVdAAz18PhVC/0AMScOt2AwihdplTGm5yQVJHAsgANIG8m0nOSAP8YpdddYkyiVd6cpwLApSxP0Hf + Qk9OOb8zCgCOkBa8T1eOU8MAJlZ7Cz0T4QAJHK+1IExoAuibtgdK4zZ48G2BAHWIvlf7LhKqS5Ue/9Mu + VnjYNqz5Hpf+b0wCNm8LBfiDcD6ZB8D7bAnUEKCd/1EeOy89OP9OGa6OP36k1vH3zqFL3e8Ufc0PtJNx + +e6nr1uSZ1lF+9ZceLgt+b2x2uTjg2XmPoC9WoeOU1Ax/mfMTgnPC4nGMKADpMAMPWXnF4FfM/vFHuwX + Ja2sQQPE7Tqk2GHIIMsoAJPxjlUC6CmeUABMYnVSMWjdm+2oUB0Z8DSQqx27I3R8AoHizRto9htGAuBF + yIuZn8mLvm7zTGn4fow0LUyygZ2g65YlSZPkvgE5TYHtUwSJU4BPUvDuN9moDJo1FMDr2FbwL/LYBADD + c3xeCeDGGAApTGN4greFST3erYdzMhaZMhyB77XJBNAC0DZvN8BV8O+IlBaEA/xP+grjVDlxTSXAEqqq + KEh0EkCzTQANjOFZymNjzw6TS6C66zqBALTBJz9WqzAkgEbI/vrNDAVABlvDtCzYYhNAlyoGt3SxP6My + Vg7VuN7q673I+dfSmX6wnbQEsMSyql74xcoj7anvkgCGKxLNPeHYAswEoK0AtI6fEz1JATg0m28UQNwX + KgDtAYBEn0wAbRq/GzXQQQLIj7LLXoYAugtNz4F6QS8BsMxFwNvA1zo471OXHanNLtq1ZoOfPew9HCxT + aL5fq3q9QBAAJOv3naoACOIJ0CZMAXb9Ao/axGsTxsde8Hv3mTAe59Y1H9dhXQfw65p2hiGAehxfsxQh + wA0Oqd9i4vcWgK85zYQ4PQX2byp2TiWBAnPOKf8p2w1wQ+DFDQk0sS+f4woK4+y2XLcNZIcSoSqhExUA + y3p2KNCyM0ArAV2fUwDRqgCUAHYEatxfv3mGqoDmreH6uHnbLC1ndhfEGgLIZzOQSw7Wxr3dNPLTuLcK + T/OD7WQlAJYBy1958KzD7anv76lO0Lif47p7NJvu0fh6IgcQ7VMATAiaEMBlQoAS9yQpHusjAV5M7Yzh + MyMV9K2INdt3R/hCAG0Rti94xv89LF8V2TMRFTj0uNZdwXbteyLrTQJgDsDb8eYjjSJDAL1FTiWsyQRQ + fw287oKEz3lwL7i9j70kQEB7Y399bRL4fQSwKM68Ppk88FydbfXM+pMAFpMQ4n0EUHd9FIAE4HFYLX5T + 006GAcHauORTMkUxnyMAngMSAOW7sZCpBKC1fDZPudR7+wggJ8Z3Lk60RgC4ZWegTQAMPQzwu3L5H7Ma + 4DQhwA4TAjRsMUqgCd6/cQvzAdPxv4ZpEpFkwRIi7xa1vy7pnbJ9d6f8K9sfApyUy2XH/2rJNy2r5JWH + lh5uS32Ps+v0sx+f5bdSA2LWlLUTjzkAdvAxTsx1GQLgYzsE0IEj9oXrlfQaPuDCbc+OmEIAbfDgrelG + EWjziy15qRZIAD3aiRatBMC4mBluen3GqaYGHq5qgBWJHta9izwqd03yC99PRynaBIDPa9oWJnW4aEkA + DfO9nn8C2FNAPokE6LnrmcSjpKe0R3zP7dqFbmMLuPao1dnvY7x/nO/5BhAAH9ctNs/XLYyX6iVOqbsu + +gsIIMj0WrD5psAAmMk4leEF5pybHECoem314ltD9Pc17QjQc0wAUvIbIMbYEt4oADZDTYA+YIr5QgDt + 7YjxeX5DADHq4TkWoBmfRe/fqA1BIUoATdtmKAF02iVeEpAO1a6f83bR3l8kvlkQ4AfbybhcLK/pYKDC + F+5fcKgt9d091WzecWnd30sATAJqMi13chLQodl85gB4sRCA2nxSbDLwPgVQYrr42uDpJ4cAqgDSI+0L + 1mF7OpqtAAqN95scAhD09H40QwJhWg70EZBNAiQrEoB6MVy4rficpm3hkNuQrt+H9J4fb2JxxvvqnY0X + nwgJ4icRwIQnb2Bib1kypPwEuA0ReGxPb4N/gXnM16oXxGIdp6YKYKEdAiyLlbobnPqdtL+esp6JQICI + zUAGtE7zWxTETkMIUF4duyM1ZvfG8gwBmpUAArWtuCs3xu7UdKmcnxwCkACY9PN6fWMBum7leIBsEzJQ + tWmzV643hHBqBaFp+yzN/DPx17CF28F2CBBg+hmyjWroL+TcBW4ZaZj3Zv6eezyvlDj8YDsZlwvkL5bc + allFR+5JOdQ25x1OrNHH23lB0isBcLKPsngFmDcJ6G3I4cVGz84LhOAzIYBrooRnGz3JBAGEG+mPi7h1 + d4R6FXonX+sqM9eFXm/utLP48OI24FtZ994ZomSguQBmnnPNSDRv6UvBwpq5ythY/Rwm2+o2B0vdNdEA + aLwPsOrNF3lUvjeeYJTtBD09f90Z5pg62/vXTPb8Pqkf74v9ve9bvRAEgNdqSAJneFQxkARIAPU3OjUH + wGReMwGd5lVEDh/gze+J8SkAEgDLfyzFqfxnVp6Dc7aHSzPv2pNl4nYlDyUAx+cIwCQAZ6iZJKAhEhKr + qQI4VVVpCTDXJhC8Z+vuEJsAAtXr122e4asCsENQQwC7aqAEwNGZTYteyxu5x3moIsUPtpNxWSmvWvKQ + ZZXuvz3uYOv8t3mXnb7yaOkvIgGYKsBEGXCCAHih0Xu3cVReXrTdjBNnZ+K9JGCIgBKWOQCv9zcEwN78 + MDtudCh4tXWVXhzko4qCVhinIUcbyWJXFC7SCDVud+zm4KBo22OZAUP8Llr/BpkYBRArLUoAIVK7KUBq + v4AA6hbFTUnuTQkBFnm9+QTYJxOAF/z6uv2e3Obr9P7Vi9xTCKB6AY/1SNVSp9ReHyN1mwhIeNHtWO+I + 1GqHF+zeEEABmG9IgaTbvCPIruMH2wm8MDUqAM3E5xjJ35Xn9BGANwRo3hUiDQBr/ZZpal4CoJFge3Ji + 7SSgy271jrErQA78XySKAOP9N8/SSkADQpgGrrechv8yVEPDDk4qku/WezT2Ni99OXfwnqjRmqV+sJ2M + ywoSQOG/W3Uj1zsPtS18e19dgvRVRNoEMDUJOBECGAJQBcBpwnjPQCYCJycBbflvRvLFaB9AW2akrwxI + AmjdFaEXfFeuY8LbsW5dFGe62djKWgDlke3UcKEzPUZBTwJo3clwwPQTdNkes3uyZC44UQGESM3GmVJ7 + dZQSwGTZrgRwxtTsvoJ/vonzP08Anv/G8NoCgH0+gD4PBDCfJOBRq5pvyKCar8MqFzuk+tpokFKInZVH + LM2+fJsQvb/D58FtFUDFo4nQE0MAkgAUQGeWw9fM4yWAyTkAEgDlfsPW6SCA6b5KAJ/j+3ZlO804jXxv + GOG08z8kgEAlgIbNAUoALAMyHOBjKgD9L/EZHbkmETlWBTJpXvZ8Xs9tYd315/rBdrISwMvNZ1hdfddE + HWpb9I8D9YnSV8lhpXGGALz9+AVGypMAtH5vj8xTRWBXAnye3y7/KQEUORXYHCrqJQBvDqBll0kEehWA + SngCvyhega+ePN808ngVQPuuSAW/IYCISQQQY/e/m5xDZ77JZHeTANKjcLGGggBmfSEB1J8R/znwe632 + BKnvDQfUy6sSiNV1ra0UaubjtQUJajULjRH0JIMahgALE9Wqljil5jqHrQAmEQCbm3LNb+J59Xpjrxog + ATAJyM7GJjt2JwEoCTCJZzcCMbHalef8XBJwMgEwBPCWAUkESgBZMabXw3tONYww/3tzGslipi8B2LAV + RMBOwK1B2gmojUA8noqwMF7Gqz3S0XLmobyOVSEtjd/yg+1kXZ5vWmaNtl8Sdqhl0V85hXNPZaBpwS11 + +QhAk2scisr2XR2V55hEAKYXYHIVwGybEtaJCkCrAAD/1BDAbYcA8P7FIKEi08RCImAIQC/uBX7rzjDt + gGtXBUBPR4BwsJLbNpAGwwH1YrHwTFGaBKzbHCJ110B2L4j7HAF4S3h18NST6/uM4WvouRnLs6lnSYLU + LY7Xx8YAbICfr1Hq1zK8AMBJBEoAi0gCVBlYY59qvF49P0EqQQC11zkho8NsKW8IoIWJtFy21DrV+Ft6 + C+Ps3+cyJdGdpgGocTIBsBKAEEBH5OWZCVRMGXByHwC9eIge17B1pjlWyccQgCmrunyJ3Z58Q8BKAFQA + aVQK000JkJ6f5b8tIbrNRCb/WyqQNp3mLU721sRJe9vyocyuWwObmy/2A+1kXbp7rraa+24MHuo897kD + jQBhJS4elfBOHwFwyC6lOjvVdAILzQEgJichsBZPuU6l4DMQBtt4C3DxAcisQdNbdwCMbSSA9AitSTOx + xCSfKSMa6ymIg/fmsQABLtwOXlT0emmmD0Cz5qx5p4Vrc4rXS5qMt8mYa0caPxcxqSoAlgFBADXfd6hM + Zyae8T179BsXJ9mP43xZfW9oQGAT4AbkE2sCf4IEJpGBqosEXavcX2gIoNberljokpp5cVK1yCVV10dK + zaagKQqA+YquXKNcGE/r4J58hGAkNm3HjdDfzgSgid/tJCB+X7MOyXWq5+9kLiTfrc1A5rw4TSPQrnDt + G2AN31fK2xain8/SrHZ45tixv3fIN49nEnBXsE0AM3UwkFYBQDwNWgY0jUA6aUuuQ2ck2lcdLxXtlzXc + Ob5+VlrH9X6gnaxL1cDNVtbowwGdPZfu2d9opvbq5LRaJV5vzt5yj2lDJegnZfOZ2VcC4IShnH2Hw4Zt + 6yrC+3AmIICzg7GhdvFxNFukOTY9TBNHJAAdd15omnfoxQneLhzbwUks2Da8K9IMeU1jFSBIjWTQkRnh + k6vauGJvMwToAqm0470JqvptwYi3g6T6B9EKRib9atWrw+PTYy+cADvXdUsTjFf3PscaPjy/93UvAVQt + cNkWa4hiYYIP9Cr9SQRUEvNIDolScQYUyDyqA49U3BguNYyfvQTATL4SgAF+d26srr1GELb5CMDu49/O + dbAdAoQaAsg1Mlz7APJi7VyAyyaACBu0wZrAq99sGnoa2Uy0K9TX46HzLniHfHubiHZRdZiRgGYY8EwN + Aeo5NHjbTBMCZEepiugrDJF9lR4p6PhRzrdfqZn26MADfqCdrEtx763WhpHHZrV2X9V7oCFOBsoTpKs0 + UQaLPXYt3vSVa4Y3yzER/2eZuJ5tvqzhd5MAimixal1QBbROAJIDgdrsSSy0CYjTS+GC0rJXrsuO32N0 + 8I/K3UL7PfJdelFr2RAxrikDBptuQBiHxnbaMfNEssypBNCJ95wgAMj/TcFS86MYAJ/xPgDODL325xsC + mPD0HLmXoKD3PYftyY8J+MkEQEJQsvDG/Au82/F43W0TABTAYsh+5gigMCpujJDqTZTxgQpiqpRmnRPA + ALbLBjAJkd6cCc02uxmniX34HNWnvfkGxM2clSeLoYNJxBG0JBOvAuhgCJAWpvuSAFjD95KBHs8+gFyb + bDi0156whe83ET4wBzDLKIDNJgfAagAJQNWYzhXB3E+Y7AUBlHf/8Nnl7x465dF9a/1AO1mXrJ67rAfG + ts5q6P5+68GGJBmumIP4fzYIIN7MK1cUp0kd/rHtmWZknlYAsN3KpB5n6uU89V4FYBOAMbcqgPasaI37 + DQGEaaxLM7Vjl44lMG28tgIoMORBAujIsrvfdhrpr51zHP9OEkAI4R2QNJEMNBKYBNA2mQCYA/hpjLbj + kgBU5i9hHiBJ6s5IVGB7pfxk7/9FNln6GwIwCoDAr5rHrL9nQgkwYcjHUACVZzilAWu+d8WNYSCAWdKg + sXyQEkDL7igdUddhWydjcMr4gi8mAK3La0de6AkEEOVTAJTk+hz+AxKAtu/a3YPN2yI0QcrnGJIZBRBr + qw/T/cn5G5Q8NATwKoCZWgmYQgBZ0TpEnEnIgeIIDQGaeq/5lSXy1T+87J8R5KRddkCerTlYOL2m50dV + hxtmy0jFPOktmQMCSJSBEo4LgBUl2gTgMJNxMBudYff18z5zHDvO7kElALcP/EoK8OYMAdo1k28TwK5Q + OwcQqt7FlP0463CUncSLMQRQYFQH57+j9zcxb4CSgM5t9wUEoEnHPKgUKIFWhAhNu0wbcM3GAKn7mVOz + +PULTDcgE3w189ngk6BZ+onEnnsKARjJ755EAm5fcvBzBDDfEIBXCehxfDwfIcAiQwD8rHIQQA0l+PYJ + BdCSTgLAb87/AtMQIFL7AJp8jUAzNRuvHnxHyEQOQMfym6Qok4o6HBseumVnmILfSP9QJQGTyQ/RvIwe + n+P0EYCZwSnGVg/BpnrgIwDTCFS/eZYSkSGAaC0d9heHgwASpa3nqls51uTB10v8QDtZl6f3r7OufnXg + 1Kqh6zKfa54rI5Xw/mXzZKg0GQRAEkgGASThovDgT+awUDM7L2N5gliH9ObbE0gWun0lPa8xmUcF0L77 + BAUASckyIKWqGbduJrCYTADsC/ASgGl/DfaNg9fhsPBK3qz1RC7AYROAS1qzIqUpLVRqtwRI9YZZUndt + jE7MYQggHiA3tfqaRXETGf3FcVM8/WTAn+j9veYlDCP9TfxfOddtjD0ACAGq5iVJ+UKXIQCEHuU3hUvN + Fm8SkN4cKifDoQTQxt57JkAV/DgfPA+5MUoAbBtWwtgaYGf0g8zAnB0hqpbU2+dF2QN5nBqiGQKIVJXQ + gH3rqDxU+ofaZBCiYZkhAHvmJyoHVQAxSuAtaSFaPVDPD69fv8lUBJgEJCl7FQAJoK8kUvbWpkhLz+U3 + ccq5W95s8APtZF1+90q2lSzyH3WjP378ueZE2VOZLIOlSToTUH8JpwRLgaRL8REAa8VdDAXSTecaL6ye + fHNbaBMy2CU9mwxMDsAQAKeO4hRYVAAsA6rXUQJw+wjESwCdlPL59HpRWv5r1jHwwQp+QwIhSkC8uLvz + vckup0rWdng9Aqgd2034LCoAEkDtdTFSSwJYaAboaGaf8f9Cj3ryEz0/zST/3BNefpLXP7EKUOVN/HmV + AMIBLwFUgwAqFsVK7VzE/wtjpHwVFUCQduYR0A0c1rs7Ur+zIQCnbUYBdGoIEGmkPwfhbDXlO5PRh7Gb + L9NhJD9Ltjowx4zY1FmYMsJ1xKAvB6DvEaIkwCoC/xPvUG8t9SpxmDkc+f8xR6Cfx0FVm2ZK3cZpWAfo + PAteAtBGMU7TVhotY7XJ0tp1ybVyk2Vd8/cOP9BO1uXu10v19mBtw5fc+VxznIxXJeqcgDrNVnH8hALI + ceMCc+pkHpyUoyvDoWqA+YBunY3WC2LPJHMrmCkhlQA44AUXUouGAeEaQjAEIIAnWl9N4rCDIwHhzRlq + UAGYpFewTwnQc5JE6PEmauVu4/V4HMuWuPBJAMwBkABqro2WmqVuU/bz9ufrOt7nyf+7mN8QhMcGuusL + LNaX+Z9oAoqXqoWm/bd2fopUQnHUkADOiJGK1eEaAjRoPT7EJAGZ62Db9CQC4LY+9g7npfzfasfy2wJ1 + Zh7NA+yYmgNQAsg1TVjah8H8gRJAiC8P0KD1/IkkoG+gV1bUf0MAE91/pgoQrCqgdad9bJb5XBLAnpok + aW+/4EeywbLOerPfD7STdbnmzTpLfmVZPQPLrj3aEivj1XGI/506OYeO8y9OgHdPwB/s0sRfp4Kfk20i + Rs902gNQDAj7ihLUegvjfUYvbgggwsTytgLg6Dcm6Dp0DHqsr2nFRwCcSVjLgKb9t8WeuopqwDsajrKU + F9xEI1DsBAFwFKKXAHCBV2+YKTXXRUr1UhcUgE0Ai808fYYA3JM8uesLpf5/by7t/a9a4Jko/2kHYJwS + A5+vmZ8slQsNAVQucUnFLeEmCQhZbcqAhgDa2G1JJcNZeBgC6LZTcwCU6azbcyIOem7K7/otJgxoVhC6 + lADadRLWaLuiYHr5TQ4gVEFvVEOIncQLVBDzP+F/YSo8Jp43IQBICMc2afgQoHG/CQNm2QrCVGc67eMY + MvSXOWQPFEB368prOONUzN/G/UA7WZez/95iSbFlDfamfP9Ii0v2VHsg+Z06qSZVABOBrALoZBSczisd + 8WU6SQAXW4ZTVYAmfqaAP04begjMCQKInFAAIAGOfz+RALwKwAA4yhyLkMMbAhgCCLMJIESn0qKXV9Kw + u+eUAOwQgHEzCYA5gBoqgOtBAJyQU0f7xWkpsMbO+k8GdOV8p6+8N7kb8Iti/8lNQd4E4GSrnO+SShLA + vFRIfxwzJ04JoPK2CFUA2pPP+fUIbCZKbeBqMjA3xmemChBtKgbqeVmDn2k68jQHEIz/IsYOgSJ9CkAJ + gKQwiQAatgRPUgBBSiAaTtkEwI6+yTkAhmGNO8zn1YO06jdN9AEoedgjEbVNHPvzLs9jdaky2LTkqo/K + A6xT3jjoB9rJuiQiPvug6WvWWJfzysNQAHuq449zWureUnu6b73BZpxNABFKAJ2cwHI3B+cYiU4CGChJ + MuGCtvKSDMx6sgLgdFY6/ZWqgAgzJDjLeH1v66rK+HzK3kg9lokpAr5Jp8EKsTPgweaxKgA7bLCTXkog + NgGwE1AJAN6KVYCaGyKlapnDjPNnfz49N8wk/r4o0eeeFBp8XvpPLgVOhAATpgRABcDxBAvmSCVDirkg + AKiQytsjlQDqtkzT+fmoUtgH4JPudlfehJRnS3SkgtVI72Ab/EE+AtAyLRN+2gdgiFWrApxIRCsIwT7v + b3IBtgJgP78djnn7PEgAbPVuZwMRjm3Yznh/OmL/mZoD8PUBbOFsQkETw8RJABVQkiCA0YYFl79e5bCs + 1474gXayLv/x9x7rz23B1sHO6MuOtMbJWE3y8UHW5fVWW25VAUzwsWNPu73Y0bcrQsHPzj4mA1k6MqCf + kP5KACADbxKQfQA6nx0uluY0MweeaQYyzS9UC2ZOe49NABE+BWCy/hFqvhh2S6jKUl7wSgDejjdfCBCj + F2MTyMabBKy6LkIqlrAbEICc5yWA2CndfZMJgMCmGvCFBvOnAn9qOfALFMA8rwJgKXC2hgDVczxSvsQh + 5beZPgAdlgtpXb/VKACV7pOScUaO25l4u5OvcUuYHQLMmpiei/f4Y5mWU4fnmOSqIQB7LAZv7LEj0M7c + B/k6AU1IEKJenp/Zrn0e0WY2Zs7kpAQQAQKYJXWbpoEAZkj9RpMD4PF1UAOcLtzMERmjoQoJYE9N8rGB + 2nmXvl4eall/9hPAybv8rct6rf0/rL92fO3S59rCPttTvVAGi6Okr5Rz67PHP1Yn5mBCqC0zTAHb5p3W + i6U8reVH6fRdbAnWph4dzGNCAF6AbVlRmuHmBdy800x+wRCgkfX8dJPI0yw+W3gLaKyHG2XQodN6h9kq + wC6Z6dz0s4zsZelLk2WRCnxDArRYJZ5GKI46XOxV60AAN4QAiIkAa4IZEDQXcl/BHG/KgezbX5QA8Lql + cp7bbuzhdqw+rtRyntuu83vjfY/u731+Sg+A5gDipBzPlS50SgX2rSAp4DOKbycp2V4UAKxjNj4t0kyf + nm0y9+22aSmOSUCd3izYDgFCbQCb0l6zHQ6pZLf378g1IyMZQnBSFXMsgW+G9Ro5P0tn9SHIlTztzzTn + 0aHj+1szwjRZqceQADZxbUhECcBWAPqZ+dNluBxkXnvO+9lNV377/YJoy3ql3Y+zk3X52pvd1qHOYOtw + Z+D5+9pc749Xz9c70/KGoD06xbap57Pezq4/9ebay8/BKyGmGScrUqf37vMaw087AAA0QUlEQVQRgMeX + A2CNv52NJOnRIIBIBT+JgATQxLZeSs9ceyAPb37B21LlR9nDYV0qhRkqeEeteasBHMrKzjYmvrryY5UA + NG+Qa6R/V55HvReBUb85RKqenSmVN8BjzU+RKm3/9Uj9XIIxVkE60b2X4AOvZvEp4+d5fB1+J0p8H+jn + x33udd0HVqEE4NA1rWpRspTcGSg1GwJVytcpAeC8pJkW6/ZJ4PeCutPbCMSEoY8AAvS36T0PeLcgxuFK + AHY+hGFQgckBcCCQzumv3j9wkpl5Bdk0ZfoGTNjhJQDeWr01nfmCGdJI1bCJCmCWNG4K09GA3gSiqhZ+ + bsEsGS6Ll47aC954vPX2C2XraSCATj/QTualsfc8q77vgvkDbYuP7qtKkh5OAsIZeovNKD8NAXLNFGAG + /OG2hZmJILSWH2M3/7jtxh7PFAJgfEvZbyzcJoIwjTn1tlL2VF4d+REAdLTdwx6rr3Osu3c66wkCYBUg + XAmgu8CtVQMvARjv59L8wgQBzJLy6yFbF6ZK9aIkzdrXzwPAF8X6svamiSd+Qr57m3ls43MnEsBE6S/e + 99h7vPdxJcihDARQ6SOARCm9O0jnA6CUJwHUbmF4FGmD+EQCMKBs1fvzgQg3E8jhCj7+tnpOy8UBUmzQ + Yq4GQCQR6Pvkmffjuaan1zEAW4LstRkUpFOLw8ubz4vyfSa3lfjZUWnfCch7bAO+u84I5KsgRJvbxuH/ + Gy5LlNbacw7f3/744n9kX2BZL/X5QXZSNwON/sq6e/yP4W0d5zUdquaU4InSVWpIoI85gCK3zvzTmhlm + gL87bAoJ6Dh0e+KKHntKai8BENhKALbX9yoAqgEaS0wdOWbsPrsBO/Ij1WuZsqALF2a4hgo6863OfhNu + trciLCBg2JegJTOnSfwxbODkmTlOu34NAgC4qtYFSPmNkLFnpIAAEAbMc+nIvCpfA88JXt0mgCmgnu+Z + AvTJg36+6Fg9foHHEMD8GKlAyFE+1wXVESfFd82UmvUBKuNrAaraLWySsmN/G/AEIG+j1maHBeyg1IrB + JiqAMDuJZwigUQkgwkcALIHSWnPMrdiMAgjxZf+9SUBtBbYJwHzOhKniYzswOxC3m7H/pgIA8tgcZgiA + U4qzgsB+jiyOBYhBCJAsjQ0XtF0yUBZzV+dGy3p+yA+yk3n53oFt1ldePfhfPV0Xph2ui5G+8kTpVAJw + +QiAOYDWzJBJwDcz2LCkp7P72hNZeqfmNjemMGqgQ29LFWWDP9ImABJCqL6PEkC+mRGIw4BVtuaZ7L42 + 86SF2oNWwuxEoBnAQgJgaYyJJ+38y/MmvkBYeW6beMIAkDCpXhcoFauD9QadRvLHSu28OM0BaLw/f8Jz + e8FdMSfW97hqnudzCsAAfxL4F9ilP7xfOY4l4Cv1MQhgnkPfr4IEcAYI4O6Zk0KAYCWA5rQoVS08Hwpk + hls2+LlNL65efyOBaFp66wHGKQRA4shx6VrbhzkbkxJAhH1br1Af8E0OIVhvUtpmN/GYcMN8frt9L0fe + D6CF5MvW4U0zVfrzO9RxmxOCakcm7xvpkkGQ/nAVzk3jZZnf3D8+belwiWX5BwOd5Msrw5astazezm/9 + 5mBD5HHeEahDQ4AYzQEwBDAEEGorADOYx7T0hqpM19lklQDcPiXAiUKoBhhbGgIwCqBxZ4iCv2G7LR9z + TPnPK+U7mLjKN7G9gjjNBv+2cJ3dx1sG4+212zJ4wRsCaMt12PXzWPWCrbioGRvX4djq9cFSdVu41C1O + MmDmMN25ALmdvVfpb3tuXwlv7sRrzANoEtAGvjdvYBKDNvAXGCufFytlc1zq7SuYUJzrUQKomkM1gP2X + xknJL2aBAFiDB5i2hep3NARAsDs0f2FA6NDz06rNOKF6L4E6HwEE2AogaBIBsBEoVtea/KP8h4riQCCT + +Q9R4jDH2uMAONFqVvREDwIJ1b6Jq74nwrc9xQvVOAGJKQUGKgGwvVjLwzp/gEdGeGuy6vCPchp++oD1 + nnzN2t/mx9dJvxwdsqrbf2wVdPz0h+P1we8MlsMTF0dLt95hx9x4g006Or03b+iRbqb28ioB5gU6dDJJ + p292Xu/QXJ2gAxdUs+3xlQB2AMA6Cw57AsL1IqfnVo9FyZrr8Mn5qQrAO4LNDGThbLraP59twG/kLqWv + SYQRSA07AxVcdRvDpfLOUKk+wyT4FKzzTJ2+0gZv1cI4H4jVNGZ3GxDPN3K+CiGAeQ3Pz7ONr2uG3z3l + eN+xIIByhACVs6EM5jmlbKlLSn85E6pklnrvGoCxmrMD7YzQWr4BvlMrGR05Ljuccer5q6PX1tyBIcLJ + CoDZepX+OabyYkIABwgAqmm7kfx1m4zVKxnw82dok5VO2867Nk9OQPI9mOfBfzeYlypD+XM0XDCfG6if + S3JmGMeZnztIALy5S13Qmw82P3jlxznnW9a4vwJw8i/P1Vm/6/ud9UTvLxeNNjlfHKqKl96SKFMFKHLZ + g3QcGg+27DKdfGY4b7htkXrrb5P8i51EBA7b3DrSjRewtpQC+PXbuQ7SMl1rpuk4o2xtVfCbPvgOEkCO + qX83bZ3oYvPKV70AtX3WYaRurmMKAfDYxrRgJYCajWFSfjdUwBmx2ptfudBIc4YClZOASxLwWvWieAX8 + 54hhEri94Pc+R+9fwbLhpH2q5seDAKAGQACl82Kk7EwohAcQ928IUu9do3kATg1uT5tue38FvuYEXAAZ + yGw7vT4z92GaA2AVQB+zDMjBVXa+oFmnazMVAZ5HEkD91gD13F4CqNtIFWAmB23lPQkyIz+XdNQGrowo + bVRq2DRLpX/txun6nbWUyJGAaSZ3QOfA9uXhMhBWveO5yzqfmXtOZ5pljVT48fVlWL69p9j6+fCmsMGW + OUMjdUnSXxqpVYCeIqd9x50Y9fJMRJlGnmCfpGdcTwCb8QCeiVt02ePz6d051p2SX0G/g96fSiBUPVeL + Ti3mNAogb2IgDMMAJQBWELZFTOqAMx6I3rApLdwAxnsctwkcVgG0EzBMCaBqQ4iU3ROkbbgkgOpFCfDi + CTpX/2T5PgXI8z8P9gmQT31s9ner9C+zpX+FrRIqQQBlIICy2bFSglCgdDlUwEPBPgJgElBDgJ1mujQq + F5KisSj9TTx/mitQ+R9ihwAzlQAat4XqHZA67MQfCaBVidCooqb0UCUAcwzfA4TDadI3nq5jEdp3R30O + /L7HJO5tIab2z2M3zYBimWnyD1QP7D/Qz8J/CMU3VOWWpoZ5vUED2aHWsH8Y8JdmORVS7byhtFMaW79d + OVKfKAOlnOXH6SMA78SblHsm/g+zPTq3TfKKiTzG/BOTc5h6vukDMDGsyn9OagFvpwTAG13sNnkAHQvP + nvc8E8MzltULmKPgtkYC+OFqGvduDtU760wQAMcQxBrwU/7bJMAQoxb7Va4PltJ7g6V8iRMhQKxm4suZ + BLQVwOdADRB7Qf3fmY8cePzcWN9aY/9Jx5bhc0rmMyfgkWKEAiUrnVL6cBBCANNNx45AUwaEJ9UQwEj4 + Vr35iukDmCCAQM0BGE8egMcBSiI6ujIzQo9pxnu02OTRwhwKZLwSAI6rBulwKjLOR1gNBVCvd/WJmFJt + MPF/lDGQr94SfAM+l3Mq4LuSAFSNbQ80czrY3ZecQm6wNlGyW36YE9Vf9Q1rpNUPrC/NMtphXdJZ8NWS + lqvX7WmI+6y/FCAu8hKAWxN67NajVDSJwPCJen5atBLD5J5+1vTZHNThG1HmVDA27IB05x1mVAGE6WPK + dL3Q2eyiJODyEQBlfdNujn6LMKDfHKbruk1s8TWDiugxdchsrlcBuKQ123TEUQHUIE6uXB8kZb8MkYql + MVI1h115kONzGbc7NTtfhue0RHeixJ9nyICvG3P5ZL56fn3NvF46O8a3n2+b+8y3CWBevBQvAAGcg+3f + hmoOoBZgqto4Q78jCaA1I9LO/kf7CIDWhFBH+wUI/o02EZA42JbLTr7dNogZ97N7kv9TltkmAdTBW9es + nwElFKT5BkMA06Ru2wwoLEMe3hyAVwGQAJjkY66gcRPO+cZABX/VhtPM3ZZ5T0Dt5HRqvwFnAx6qTfj0 + yeabf2d1D/271dfox9WXhwDaLatbvrKr7ec3jzd6Puovi53IAejNOkxyj3+4mc+PSiBK21ebd0abWrBv + dh+XfX8+b2LQg4vJqfE+wd+0M1yHvzZsD9e4tpGJJDtmbeWwVxIBJyFlNx/IoBXxb9P2aJ3XjyW9xi2G + DHi/P75XC+LUFr3YHYYMsg0B0Bp3mYk3SADlD4RK1QooAHrrhczMe2wF4PHJeG8eYMLD8zWvZ/d6dc8k + b2+MJFBKErETg4YUAHRbARTPBSnMcUvhvGgpPhek84dwLQPWIKauglGl8FyaeRa9KsDhKwc2Ityq3Uzg + Q8ZvDFHg15I4NswwBJBuwOslAD2e4AcxayJ0ywxVADU4thphg5cAardOg7qwCWBy/G/PA8CcDSf9YPMR + CaAWx5EESAqcz5DnvsuehWigOFoGahLfv6/xrp9YvfIVq73aj6sv0yIVlvXLzutXjDan/H2g2nN8sDBG + +osRwxfPBwGw1g+5Dg/VtDsEF41p5NHbWvPOvSznMZufb+r4us4101p1Frg1wdeYFqSTczRtg5zfFqSS + Vh/vZL95lK+N1WskAMr61iwXjnXCW4XjGOO9eCHWMR+wE+HFbqeSRAvHHDB+zmIXII7LdkrD7mip2Roq + Fc/OkrJHAqXsbIe5OQcUQMUCAtal/flecGvvvu3ZKdkrEL/TuO19TEBTPdDKNL6P/9x2CcBewph/LpUG + CADkUDQvRopTPVJwUZhU/jFEqlT6h6hHrtXRgFEmoekjgGjbk0dpiZDqR4c1bzCen6FQNYfl7ubvBtjZ + LMTh05msgNjJw4wYkGyoKg2GDTUbAqRq3elSizWnSq+Hh2fPRFdRKj7blP+8g3r0nG6PNM1KmjOYqXkH + nvvmzd/QcK4uZ7Z0Z4ZKT16gDJfg+JolL13X8tASKccF1VLqB9WXaTnUMt96suO6mK6WJfuG6+Olj3MC + 8uYeRckIBdjvD6DyQgMBMOusg3s4yUeauXMvB+7oRJ6s4+c5fRNcTiaAum3sXYfn3xao4GcNnATQkm6y + +e3eGn62qWd3sIKgBAAFANXAY2q3GE9Uy1LWDlz86SwXulQBKAFkGgLgdj1IqhbEUb0BgPtDmJSe65Cq + eQnq3VmbL4NnLp/jnqjZL4ibFOfHGQKYZ/IFZXPcaj6AzzHe3UsIZTY5eF+jFZMA+Bzev3i+E6QQL4Xf + DpOKPwZKxYZp6o0Zk9dpN55p4jHAj/LF4fTODJcY9hDAJolnrxGL95fMl4Hy+fD2IGRVEJwP0ZQS2SfB + uQaMWpilYUD1umnYnqm3S2MVZaRqkTzffTlIO85M9a4kFKWqjZ2XZsxBoCYCWQXguW/cPE0nIWnJTZJu + NgzlR8poaaxU15zX9ZOmJxxj9ZdYVnuVH1RfpmVT643WL9p+O7O+5bzqkcY46SqdLUN5DAHc0l0aJX06 + KMgDwHH2mtCJHICO8zfZYB3CqzPzOiemuNZsPuv5RgFoCYuTS2wLVgJo5IQfNgF4vb+J4U0mvyUTXgwk + Ubc9xEcAdcyekwDgoSYTABNg9IBKAJkTBMAyYPWj4VJ8dqSUz/aoAiibG22AP2ciiVfh8/6xPsCbZOGE + EiDYi+HdaV4lUDKJGLyv0YrmMPMPgsD7Fi9gmJAohReHS8WjgVIJUE4mgOZ0k71nzK7NOwpmkwwkATDs + IfAJ5Op106V6/QxVQ915SSDeBCUAev62DCd+e7Rut6YbAmCooOBfP13fQ9UACIAl2a6COOktmaukwV4C + nRSE5z3DJADp+bX7bzMHME2zJzIJlDYmb0HSnAy0tTD2+GipR7IrL8qMrS6efnfVr/yA+rItV3dusKye + l75e1P6dp0ebPJ92VCw4PpbPcf7wCqVhCAPiAOp4bRphc44hAPbkh+hMPUwOtqvstwlAY3m7rg8CaN5t + x/1bJxOAea55t6nf02tPDgM0iZURDU+PGHhroIYAnOGHCcBadrWBAJp3xRi5yoFDzIBnGBncjLCiPi1C + Q4BKtgI/GiJF50ZoOY5AL50bY2L2uYYQKk8o6ZXOBmBnGyLwhgBeBeAFuA/4k4jA+xxNCWCuIYAiKoA5 + CVLwnQip+FPAJAIIVAJoYrmTd//JMD39BH6L/dhLAFQABHE1ZLx6dHbj7YpSsmtRr+2wyS9K4/NmEGA9 + w6YN043nBwl41QNJQCsyHGSUaXInmkfINBWBhp2zTNlvw+mm50BVxGlSxTzANt7lORjeP8B81+IEGS5P + +XRjxWW/tirka/9ekeUH1JdtSWrfbVmN8pXMjqtvHGmKf6+nMklG8hOltxAEUByuN30g4zNRNRECGAJg + P7neJ4CAz3fa01i5Jia4ZEdaeoTeA0+72LYGKfg5DFYvfg4M0sSdKd9NJgGvAqjdFqTeXxtneK8/xs4c + GJTGm5REmxxAth0Dw0wIEKUKoGpdEEAXLMUXRqu0p4cnAZRp2y5AT0Uwn4COwfNOANalSbvJHr7E6/GZ + 1DuBALzP+whAvT5jf+w3h8c7pWCOAyFBvBRcDgJ4IkhzAFUbsWaJTacEizKem1N7Zcea35QRreqIMwax + /KcKQGX8dBMCsJ2XidB0kyvgOebkrS2Z9rH4/aqaVDnMVALxhgJMojIEULIA+EmYOm4g0yQiWbVR6b/Z + m3A8XQmgeuPpUrud93gMka6sGZo74M1k+6oWvL218kffE1b/igv8gPrSLU1V1qftydamtuvPGW5Kenmg + Kkb683izTrYFR0uv1tkdeoE07w6fRAChNgFEme49lgvtmXo68iZubMESFwmgYWuEzoLbsD1CCaCWs9yw + Gy3L7mO38wDGGM86AfIoBQkJgB7TSwA1nCEoLUo75drssIE5g9bMGFUDRgGEKQGUweuWXBwDbx9vMvXz + CXyPlukqFiF+xzaTdTTG7CaBNyH5i6AIvHG/V+rr40mJv6JUl5qXCHhMsW67bAKIk8IrEQKsDZJqTlSy + IVgq1s3EOQgyIUAma/4OY7tJbDGmBLjFlP+0BAjCqF4/UxN5NZzQY2ekentVDNqq7VDVxPdoSovUZKsB + /Sw7hxCkj1lVoUJo0cYh/kduexyAQ/s6dM6GbWb0pSb/EP9zXbPpNA3HGC50ZgfqOR8si5DO6sVHHq64 + Z0llzdWWlVfjx9OXbmmpse7vfMS6sfOZxIHGuUPjNaHSxaHARQkyUBAr/ZyqO9dcaE12DkBH9qWZYbra + EJRrZrRtt8fle2e4ZT6AF5UJASLsQTDwMKzvgwiaOCCFXs/bxqudfLF2CBAFLxehIDHlqyAtidVtCbMV + gElY8UJuUiC4VAE02SFANcIFVgFK/nSalF3qMJ168zxSsRAAn0+5nzjFe08GthfcX2ResJsk30RY4H2+ + mDaHxMF8A16HqiiehxDgewhDnpgmFQAjy5MV6+Bd2VabHm3IK8OQANun9XfsogIIA4Dx+9dDAa0noEkE + IRrHTxBAhBKADrxKp5JwKQFQJVD+s/GoRonD2z9g9uV5U9XhHUWocwPyvwqy241nqQIwNhPEcSqIPACh + A1SbTr8WK6Olp0l95bKWOQU7Yi4vesyy8v0VgC/f0lprpbRttU5tLwpobjyrYrw2XDpLncc7i+fIcAHv + ERil9V4dmZYWMjG+X2/bFWHKeRzOWhBrj8s3g3va7XxAe1aMEgBr+Q0cWrotwkcAjdrRF+ur37fa4YBm + 9jOjteOPOQAzdj5EG2dqmBWnAthFj+WyQwhvCOAyCgCkpDmAZwOl+LFvSMl3IlX2a+lvARN0bN2dKukn + Z/gnx/WTM/sl80x8b5J8HvXyfJ7mfb4I71cIz891KUigaB5LgXFS8P1wKX0SBAAwkwAq18Mrc3ATPH5z + hkPzITRDAjH625nz4KxGtOp1ATq8WUmAE3qAANksZfIHkQpq5hN4fMN20wdBxcDGI5MHmK4KgM1VVBne + 3IFpOrKrAOlmDIDX8xP8ZhQhpxH7pt4uvDUrVpqoGhDyDVfgN1VdvMPKajzNkZ9uWRkZfjx9OcOAIstq + Pva1qsbLnxirj/2suzxCOormyjDvUlsYaSbszDLz7U8lgEjjidjKmufyJQG9PfpKBlnmgmQyyxAA5WmE + 5gDqtwerx2u1E4FazvMCmnI0jbfSmukbOFOzKRixKCQ0xwPsmsgBUI4SRJyCrAlgMFUAhADwmsVPnCol + l0dqfK+NOvNdSgClc4w3P5EATgT/5Mx+MUKIyaaAn2ueJ+gLIf0LU52SnxqjBMD8QeHcGJhbCn4QJiVP + ni6VG4JtAoCawbloTqeKcU6EALY17DRdjwS+lwSMMQkYaAiA8wV6CYC/na3XzH+oagrSyUdIAIz9VQVs + 5CQrUVol0HEDDAMy2BAUbv4rHwHM8oHfTAJKRXCqzgnZkeOWBlgvCKC/OuHDtKof32dtkq9aBd2Wtcs/ + B8CXlADqrffbzrXWt9x13WDj/PcGygOls5BDQc18fd06Rj9G20e9E3twuukmePOmHSbzrJl/OwnI+9pp + ToAdahxZtt2MZPMSQO0WxOj06IyBeRtwHwFETyKAGO2Eq97CrPlMDQGqN4ZiDRLYEqxJQOYktJxVnKJV + AEMAUUYBbDM5gOK1p0npVdEq+0vZucdEIJOAkxTAFymBEwmA4PZ5edu8z/nIQM1lCIBJQBxXMAeEwH1/ + BAJ46lRI/wCEJjM1PKndGm4IwP7uXu8/QQDBtuefNXWtVQAOAHKYPgDO1cjjmUvY7TDx/yYz/6BRDd5G + oiAlAA0XCHwShw4JjjAhAN7DlACna+nPqwKUDDZPAwFESzcHHuXEChvGmquX/PXuige+Z/1KvmL9fiUU + QI4fS1/Kpb7auq7lD9YtLb9dMtCw+Oh4RQBAlYw/OUw6dV6AODNTb3qkrxGI003rYB1O18VbgOWaRiAd + 458/QQDMATTuYG05UuNPVQBbIo1H51z/lK02+CcrAKoKEkDNlmnaNlvFjPamcA0BqjkoZWe4Dhgar1sm + 4/UrTBkwwzElBCDIip/8hpR9L1rKF5qYnKEA1UCJXa7Tpp35bNs1CT+V9POM3FdPPzd2wtPPdU8xL+BL + 5k+8F48hARTPiZOSVBDA7Bgp4Hv8NEKKn/6GlCMmL3+GBBCgBMBQRsOA3Wy2ohIw1gClRRBXPD3NDgEC + NR9Qvd4MJW7EMY0guybO3ceJQzUJyPdyaG6hasMMEOB0oxi0ChAwhQAa2dqdEeGbE4BlQE64yglDa9Z/ + 087+G2NIwKpCS3qs9GUGaffmcGG0VFYuH1xW9MS87vpUyyoftqzMXD+WvpRLY601t36DdVHD0wHVdRfm + DldGftpX5ID8R4yuN+2I09JeMwkgDUZAc2KPbeamFY1pgZpI6tKZgKI1adjOAUHZkfZtpiPM6DJ7Oux6 + KgFNCAab8QUc0ZZlSlqt2aYxpjUzWqsNdVs5FHU6vP8008yyORhkMNMeR2+SWPx+zIA3cSbhdFzErALA + e1YCaMVrvy4lP0Cseka89ugXa+weqyGAlurmxUvJggTE6R54a7ct6Rnjm3XRXJeCvEglvlNt4jElvyn5 + MelXZB9fgH0KEPcXzQH4sU8B3qPwxggpewrAx3eqfGaWzlfIfIhKeRBW825WAGIMAYAItJUXv7fqGSgg + kEUNCWBdgMr6Ot4bkPcL4IjJjDD15to7kB6lJcC6LVAKbN55Fp6cSoPyf/00nc6b91vg5C46HyDHA2SE + 24O9Iszsw0y4bjhValgC3GTKh5yApHkHx4HESk9GkHTlRkp/UewnaRWXbJ2ev2OmlbPbsrJy/QTwZV6+ + Vl9vWZWjX32g/pc3tNcu/OtA0UzpKPRIe0G8tGHdXBAj9bzItoEUtsLLbocn2c4Ze6bjwpkuHQCx3lgi + JwQykbXiIOnM5Br77+ZEkt+Ad5kGMxNS6G2nsebtw9szOb11qFqbWoS57RRHEm5lL/o3pW7D12GnwEAE + 62bp7EBtBIxmv8NUCjdw3gK2LKeFKdlUAThla/9L8q4NkPwFAPq8aMjxeIA2XirmJkjZ7CQpwnb+XNi8 + BF1zAE8JbZ5rwvC4iLH8bAdi/Rjdh48LUvE4xaPvUTw7zhCAqgWPZC+Kl9yFEfisOMmbGy3Zd4RI7WMO + qX4S3vwpABPeudFuhmpWVRVhynO7SJgOMwsSx+Iz+/9skG0E83SdlLNZb7UeZgZqpQcAyOZ+C806kg/n + aP1pUvfsNKl/BsB/+lSpffprOPf/KW1pM6Qjg3cUwvlON9O86d2Y8bnNUGWNINfKjadI+YbTsIbaWg8i + 2oD9tnGmIKdWCvrycGzp/FdWlzzwIyv32Ff/o7DdsnKK/SD6Ui99L1pycIF1dc3jCaUNl9YNlkV8xht2 + 8GYdgznh0s0YH0Bt41DSLZCG20+Vuu0Oqd0GyQkyqId3aMqJl+bcBGnN9Ugr24ezaQmQqh6pgWqoBnFU + b4uRKq63OtTq0zyQsfHSmBknDbDGLGxnJ2INS4+X6h0xUr45XCo2hcHgRTdGSukGbG9GGJEWK/XpcVKL + z65Jd0tNBtdOqd0VK1X4nNL1UVK+dpqUXReqkr9ydrjp9Et1SfmcKIDWAc8dDcA64MVh2FbJzgYeem0o + gEKohiJYHp6j5eP5AjzPdR6OL0iJBshBBDi2cHYUjo+QohS8V0qCFKfiuyZwNGCw5N3zH1KzNkRKn4mU + 4mfC9TdU7XBKXUa81KV78J3x/Xe78VvipG4Xztd2l1RudkjZhij8DoeUroOtD8djhAY4rgG/25gH5pYG + /Hb+BzU7HHquytaHSNmzYQg3sP1suJSvD5Pa7SyZuqUpy43za9b1GbR4kGccQivI+nUgGpBG9TOngWhP + g+L4T2nY8jUQxCwFP1Vaf0Hwp7sqv1u2sOAZ95/rz7es0g/8+PnyE4BYN9Q8YLmrMv9rU91P7u6tTn2z + uyASMX2UDMIb9+S4Vc636i2j4cF2TJe6bcw4M94Ol9qd8MDsRwcBtGDfluxYac7mOh4AxwW+MwoXGPd1 + SNXmCN2uAohrcHwjLmA1JQASAS9otxJA7U4XwI6LGN6ojDP8sLkHMriC1QA2q0Au10EJ1DDuhxqohdXt + ipHq7QROsJSunSllNzMO90g5AFlM2a7JuTCAOAJgjpSC+VHw3CCE1CjJB3jzNJMPo3zXfWMBdhDAbNcJ + RlJwSO6caFgkLEJy5oTjWBBLYoIUJIEY4uMk/4wIyb3/61L1VKCUwIoRCpRtCAQB4Lzhu9ftigaZ4bvj + e9ftduE3gxzhjfk7S54NlNJnQRzP4rc8OxOeGSoAIG8AWTQA8A27XDCOgIRCS4vR5Gc54v0y7Fv2DNZP + zcJ2qFRtipT6nU6ESLE4r9iXOQQmG3U7BuQQDo8fIJXPzoBaIAkEqEqp2QjltuMUaQH5N7NpCwqvtTTh + 9QdKr7/V2l3+9cU5j8L7F/rx86Vfyqstq6rWkjrL+ln1H+c0VS9v7S+KPs6bg/TAG3dkJwPY8ObwsHU7 + cEFtN1NbNeg0XWaWmaZdwb66snemGu8oN52nz56aSjvS2NG33gw3ZW86ZXArM9kIMzj0mJN6NEOWNuyI + 0EagcnijCvbCr5+mSarq9d9AnH+6jjak7G+Ah6rbxe8QgLiabbZMtH1dCtfOkKI74iV7YQLkulNyZ3sk + a06cZM4Lk6z54ZK9IEpyQQD5c+jJoQYQ0xemAPTJLjVu0/JTXGp5STFq+ckkiFi8hwvvFSMZUBHpc6Mk + A4SSRVJIwmcmuSQ7IVkyV7gl42EA8in8jrX/KRVPQg1sPFXqd8zU/EnjTg7QMdvstaiHxK9a/+9S8fS/ + wf5LKp/5prFn/1NqN5khuWZmJm9ZlutAvZknX6989mtS+fS/S9XT3wTpnIL3OFWnEWvaYWZ05mxMTbs4 + oxCNk7Uy6/81hExfwf447qkwqYRVgHgq2XfB5CD+0/qcOOktmHG8sPLc1qVFTy6wnhHLKiixrGx//f9/ + x1JVasVUZlpBlYWnPFvz8/uGypzvteYh/s9LkSbI+sbcOHhzSEd4oMYtnKwD4ITcrOakFZzmGiqAXqWR + jSwZ7MpjYw5Cg0yX1MPL1VDKswa+gePhsb0uUGv1bNttgPdqUo/mhEeiR3NJHT3aDsjSLeFSvG4GJDGr + D3E6yq8Mj6s2I65GaFGHmLluFw3eH7F0HTxrNVRJGWLmvLVfl9L7QiR3WRjAHQrvHiXZiOHzVbqzlOeR + wmTE8YluKU6MQ1zvklx48Fy8npMMckhxqHGblp0UKdmJEbrOwfPZyW48jxAB75GXhDXeJzcRaiBlmmSn + TJccqIDMc7H/b/A9npwhJWtPl9Kn8N03hep3p3Lid65n+y5bn3dG2999GvY7FTZdyp6epd68fH2g9lBw + OLT+bqx53hr4+xlibQnTKkPpU98E2UwHCQRKBRRA6dMz8R+FQwGAUHGOGnY7VDE00tKoNqCoQLCV+MxK + SP+yp0/De0yT8mcDpIr/c1q8hhot7Bgs8bx3f8Wa3/xXQfH0mMJ0yyos8uPmf9UiYuUUX2itKbtzUXvV + 4rGuIkj6PEj5nEhpzmGd3iVtaS5p3QLpqGW5UM2413CmWw77xUXcYJOAMaeu2ZxTs4Wx6CyQwCwdq1+J + C6xyHYxz3W2P1Ik+6gEAvagpjbHNi7wKgCjFhV25iTesRHy/LlSbaio24HMRhtTt4HEgmTSu+ThaQ4vy + dcGSu/a/pOj+mZJ9VpjKfJbosuZ41JsXqGf3wFsTvB54/ATJmY3XEc/TMkEW3u305AhJT4mUDNjupHB9 + nJESJZkJMerpc0ECuUmxkpPgkqyEcMlMno7XZ2ENArgQZPHI16Vs7SwQwEx8d5DZRrY0m+9KADekIQzY + EaUj7io3hioAi5/4JvafjjBmlh5DQqvl/IgE/3azbuD5wnHcrt4YrmRRshYgxueU47jSJ2ZI6TMcd2D2 + rd8Zjs/CNtXVzhhtRqrcALX09OlaNWHZsQyqo+Lpb2gHYQPOY8uuOCXnjrzo40WlKwYuK3houVX54Ves + 0g7If3/m/3/dclHlk1Z0ZeH0rMrLtvWWxH3clsMs/QxI+ZlmKmjWq+EZGuBV6rQ/H558E2v1p5u+f97T + Pj3SrG2r17ZeyMoN06XimVN9ra2sU1dtnGWXxNj+69B1Q1q4kkkjLlp29ZE0yp6ebmJaAuIJeih2CLIi + gTgYVs8pxEgkOxDTbo2G1wyUnCe/IfkPzZD08yKMZwdIM5ITsc16PSQ6VEAmiCAjxS1ZqR7ZDdDvng2Q + zzbrXamRut6ZGiFpIJA0e3snX8M+mckgCBrUANcZiTguMRwWZo5FGJF5KcKG354i5U8gpn98luYlCFZ+ + R37fRgCRVofvX7MlCr8VMf8Tp2NfgHFtALYDQQYzIMk5o1KU6avQqdW8FqajLKtBjGVPzlLwV6wNxOdh + +wnTeETCaOBNRrYz5OB8DCDqbU6EDBH6H1SAcCqenC7lINbyZ07Be50i9Ru+Kc1bA6VtR5jOBNVZ4Hr/ + 0cLvr7UKmmamFm63rFx/7P+/coks32FZ5fKVa8vvvbKpbMFzPfluM96cXXZZkIyZHinf4ZIqeLDKzaFS + ASlegfi+nN16bPTZFauSsZ4yfleMrut3uTRDXbYxWIqfgVeDpC0FQEufCpIibFcgnKhlVjwtFjGnS6px + gdYS/DudUrmVCb0QKXw6CDE9jl8bLoVPwqM/EyEVW6AItsfhu8Ths2Nh+JztbhwDSb8OMh4AKngI3vhb + kO4AaEEiPX8yQgGHJu6yAer0OQR5uFpWMuV+jFo25HtWIsCdBDWQEOWzDNsyIfUzU4KgFIxlpAaDQIJk + V3KYZMbGS3pCLAzHX4Hv+of/kNLHviG5jwVKwdoQnCueP3zf7TFSjd9ds92J7Vgph7Li78p/PFgKHsPv + xTof63z87tINUEMELfbneWGik1YDwqvYEiElT+NzngiWwid4HD7n8QAp0s+KwH7433ZwHe47r1U4R2Xr + IqEuAqEajBXjcwqfjIF6Ygu3UzsO63cHS3121PHc4otGv1PwyIVWjnxlekE25H+lHyz/K5fiEquoYKW1 + rOCRsJ3ll25rKlrwXmt2ovaQs/OsPgux6+4QzThXbIKngQenjK9kkw47/OChGMfXA/y1iG9rObPPzkit + BFRsDpKSZ09XiVv2NOPVWVLEbcj56u3RmgGvYcVgJyQyTcuHEVK2HkTx5DRc3IyjQ7EdJAXwduWbIhU4 + VQC+lhi3sdTokMotDilZHyFZa8Mk+5EA2XWlS713dmIw4nLjudMRDtB2I97fnQx5jxg/IzEGwHapZSQ4 + JT0+Ri0j0Qlz2WuvOWR3PECfEIKwIFR2pUSo108DuWTFe2QXyGNnEl77QTiAfyoAPU0KnpgJgAfhe0eb + cug2fv8InDPG9S4AOVpf534Fj02Xgj/NAAHMwDkK0N9K0q3iYB+AuYoDnmB8j5L1M/X8FEEZFT5+Oo79 + ploJzhFzKPyM6u3MmUAt8L/YQfKOBmmAiNfS80MtPDkTFgiVxduqhUFlRGtuojYTYULhnLd/X/iztfGZ + zwQ9lnU1pH+ZHyf/ewkAcV1JqWUVvf/V28rvWlFcfHZGQ96851sy495qyIx4pzYz8N3a3dPeq9we/n7J + ppD3izYGYh3M7feKNwW/W7ot9N3KtJj3qnfFvle1KxoW9V4lDc+VbQ1/r2j9rPcLn575fuFTsz4ofHLW + B3lPTX+vYH3wuyVbot+t2OF4t3wn1mlR7+KY96t2Oj4o3+r4Z9GGsA/yn5rxQe4T09/PfSLk/dwnZ72X + 9eTp7+ZvCHu3ZHvsx6U7PMdKt7s/Ldnm+LR4W/SnBZujP8tZH/Hpzqc9x7b9IfKTTT9K+nTdopjjO2bP + PL5rdvBnO1Ldx7bNTji2PTX+2I4U97FdSa5P05NiP9uZ6IZ51HZge0eC26x1O9ZYovs4TLYj3t+e4Di+ + A0SxPTn2+LZU9/EtqXHHN2O9LS7q+Iak0M82zgv5bOO1MZ9ueyrsw7THw9/OfPzUf+Q+G/RB8Vbnx6Xb + nZ+UbIv6pGR7+CdlO6M/Ltvh+rhwc/S/sp8JeD/rienvZdMeC3g/87Hp7+U8NeP9os1R/yrbGYPfGvlJ + 6Y6oYyXbo44Vb436pHhL5Me562Z+kP3EN9/JfvyUt3Oe+Oa7sPdy1p72QcEzwR+VbI3BuXEcK9sZeawi + LfrT6p2Ojyq3R/6zeFPkP/Ofmvlhwdrp/yqEFTxx2oeFT5z+z5InT/+gakPg+7Xb9D97qyw74c85xSuy + rsj/zRIr5+2vWrnVIIDNfpz8b08GPlj9c+uPu771b/cU/XDaD4vuTLqu4JcX35B/z/Wr8++8487cO351 + V+bqB27ffdODt+284aHb0258+I60mx6+beeND92evurBu7JWP3hPzi0P/iJ39QO0u3NW/frunDUP3Jmx + +kHs+9At265/+JYt1z1yy+brfrNq63UP3Lz9+l/duuumX92RefOv7sxe/au7sm++/57sVQ/ek7n6N3el + r/ntHWk3/+62bTf9ds2W6x+5ecv1D6/eev2DN2+79v6bd1x//60Za9bekX37xjuzb9tyR9YtW2/PvCVj + TeYtZat231J907brK1Y9c0Xtmrt+uuf2q655+5cXnffZry845+MHLjz3rYcuOu8fv7nwrLd+f86Z7z26 + fPGHjy9d9PETi2d/vHbJ7I+fXDrnE9pasz62dunsY08sSf2Ehm2hPbZktjyyYrE8ctaZ8si5K+Xh88+S + B84/R351wdnHHzz33GO/uPC89++57NI/r7r7+33Xbv5+5vXrr/3j9Zt/9uDqnTf+4bZ0fOesNU/dnnXz + 2tuzbnj8jqwbH78tc9Vja3bf9MdV26//Hc7J71dvueFPq7fe9PiqrTc8dvP2G/50S/qqx+7IvvnJO7JW + P3NH5pr1tNszbll36+6bn8R7Pnrzlp//7uZNP31k9eaf/Xb1lp/j+GsfvXX7jU/dkXnbxtszb910R/bq + TXflrNl8d+bNT9yVftODt6Td+ODqrT//3a1br3vm1i3XbVqz6WePr9567QPX7rzxnhvSb73lZ5n3XHdl + 1q++d3b2A+cuy/l1VGLm0/9uPXvYsnZlgQD8t//6373kpVnWbrHuK7zWKi1YYVk7xXKmbfiPBTsembZ8 + y30BF228J/jSjWtCv7P+5tDLnr05jHb5+jVhl61bE3bp+tWhl25YRQv5zibaTSEXr78h5NKNN4d8Z8Oa + 0MvX3xJ2xfpbwq9ad1vEd9fdHnHZhtvDL11/S+glG24JvXTTmpBLN90ccsnGVSGXbbgx9PINq/i+4Veu + uyX8ymdvjbgCdvm628KvWH9b+GV4n2+vuznk2xvWBFyy8ZaAi9evCrhkw6rAyzatjrhs8+q472y8Jfmq + DTek/OTpq8+45de3XXL/Tbfe8Puf/PieP/zoh/f9/vvfve+P11x172NXX37v2isuvvepb19w39MXnnvf + k+cv+9WTF5z5q6cvWPbLZ85f9stnz19637MXLLvvmfOW3Pf0OWfQ7n323MX3PoP1U1g/evEF9/7pOxff + +9iVl933p+9dcd8fvnfFvb+75sp7/nT11Xc9/INrbr3/pz/76Q33rzr/qi03zL5q/e2OyzfdEfqdjbcF + Xbzu5lkXrbtxxkUbbpz+7Y03zLh0440zL9m0atbFG/Fb1t8SeNm6W4OuWHdbCI4Ju2rjnWFXbLoj5LIt + twRdsummgIs3YL/1q2ZdQsNvxznAb18TeOX6W4OvfHZNMM5VCO0KbF+xbk3wZRtvDb50w5rASzeuCrh0 + 400Bl62/KfSy9auivrNhdRT+N8f31t+S8L11t6R+99nV7is33hZ19uZ7ws/cdG9o8saHgkK3PTXDStt1 + irW99t8uyrzfstLFsjLz/Pj4/5slZ6P10bN3WdOxnr/rT9ayHQ9YZ2+527p4053W5Rtvtq5Yf5N1xbPG + rlp/s3XlulXW5Xju8g03ql2x6Qa1yzZch/2x34ZV1pXY77vrV1vfW7fGunrdLXiPW63L8PiyDTdbl2/C + 8Ztusi7beIN15YbrravwHnzf765bbX332TXWVc+stq7CcVetX4PjVluXrrvJ+g6+B7/LZevNZ16J97hi + 8yq8Bz4D7/N+lCqar+DStdZddYW1+YrvWM9ccYn16DVXWo9dfZn15OXftjZceI61c/liqyI50mpzz7LK + 5sZYmUuSrbTlc6y0FXOtzSvnWxux3og1CMACAVggAOtPF19grb34Iuvp73zbeorv+d3Lrd9dc4UFArB+ + f/VV1uPf+571x1u+Y/1q/TnWz57Bb9p0q3XFxjX4rjdZl66/zrp0w7X4/j/HOcL54XnaiO+t5xG/E7/3 + apyb7228zboKx125Bb9z8/V6bi5bbwwEaX1n3Y3YXqXn9LvPrsJ5vVmN27Qr8XlX4H2vwHFXbLwe5x/f + Q8/VKv3fbnjmZ9adT37P+sEz11vf3XiLdd7mO62zNt1tzd14v+XY9pj19TTI/bQd8Pzb/HjwL1+ipcXc + pvq/xg9Y//XKXyzr0FHzfFapZWUUY00rOcHwWnYZvFyJ2ce7/tx+Jea9+HqmfRzN+5gSOR3HZfAxXyub + sJMs1Dupv59/8S//XxPA2H7rP1/6s2UdQPza1WtZw3v858a/+Bf/4l/8i3/xL/7Fv/gX/+Jf/It/8S/+ + xb/4F//iX/yLf/Ev/sW/+Bf/4l/8i3/xL/7Fv/gX/+Jf/It/8S/+xb/4F//iX/yLf/Ev/sW/+Bf/4l/8 + i3/xL/7Fv/gX/+Jf/It/8S/+xb/4F//iX/yLf/Ev/sW/+Bf/4l/8i3/xL/7lS7D8P/W+joR+VmDzAAAA + AElFTkSuQmCC + + + \ No newline at end of file diff --git a/SwitchGiftDataManager.WinForm/Program.cs b/SwitchGiftDataManager.WinForm/Program.cs new file mode 100644 index 0000000..bb1cea8 --- /dev/null +++ b/SwitchGiftDataManager.WinForm/Program.cs @@ -0,0 +1,17 @@ +namespace SwitchGiftDataManager.WinForm +{ + internal static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + // To customize application configuration such as set high DPI settings or default font, + // see https://aka.ms/applicationconfiguration. + ApplicationConfiguration.Initialize(); + Application.Run(new MainWindow()); + } + } +} \ No newline at end of file diff --git a/SwitchGiftDataManager.WinForm/Properties/Resources.Designer.cs b/SwitchGiftDataManager.WinForm/Properties/Resources.Designer.cs new file mode 100644 index 0000000..09e358a --- /dev/null +++ b/SwitchGiftDataManager.WinForm/Properties/Resources.Designer.cs @@ -0,0 +1,83 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +//------------------------------------------------------------------------------ + +namespace SwitchGiftDataManager.WinForm.Properties { + using System; + + + /// + /// 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. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SwitchGiftDataManager.WinForm.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. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Icon similar to (Icon). + /// + internal static System.Drawing.Icon icon { + get { + object obj = ResourceManager.GetObject("icon", resourceCulture); + return ((System.Drawing.Icon)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap icon1 { + get { + object obj = ResourceManager.GetObject("icon1", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/SwitchGiftDataManager.WinForm/Properties/Resources.resx b/SwitchGiftDataManager.WinForm/Properties/Resources.resx new file mode 100644 index 0000000..e7136dd --- /dev/null +++ b/SwitchGiftDataManager.WinForm/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\icon.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\icon.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/SwitchGiftDataManager.WinForm/Resources/icon.ico b/SwitchGiftDataManager.WinForm/Resources/icon.ico new file mode 100644 index 0000000000000000000000000000000000000000..6a0df95fd79f2811e464a730addc530b10746147 GIT binary patch literal 79029 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 literal 0 HcmV?d00001 diff --git a/SwitchGiftDataManager.WinForm/Resources/icon.png b/SwitchGiftDataManager.WinForm/Resources/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..62d9ecec37f445cb229efbb66158c1001f9ca284 GIT binary patch literal 109247 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≺Dc3<2 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 + /// Required designer variable. + /// + private System.ComponentModel.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() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(SaveWindow)); + this.GrpBuild = new System.Windows.Forms.GroupBox(); + this.RadioUnique = new System.Windows.Forms.RadioButton(); + this.RadioMultiple = new System.Windows.Forms.RadioButton(); + this.TxtDestPath = new System.Windows.Forms.TextBox(); + this.BtnPath = new System.Windows.Forms.Button(); + this.GrpDest = new System.Windows.Forms.GroupBox(); + this.BtnCancel = new System.Windows.Forms.Button(); + this.BtnSave = new System.Windows.Forms.Button(); + this.FolderBrowser = new System.Windows.Forms.FolderBrowserDialog(); + this.groupBox2 = new System.Windows.Forms.GroupBox(); + this.BtnSrcBrowse = new System.Windows.Forms.Button(); + this.TxtSourcePath = new System.Windows.Forms.TextBox(); + this.GrpBuild.SuspendLayout(); + this.GrpDest.SuspendLayout(); + this.groupBox2.SuspendLayout(); + this.SuspendLayout(); + // + // GrpBuild + // + this.GrpBuild.Controls.Add(this.RadioUnique); + this.GrpBuild.Controls.Add(this.RadioMultiple); + this.GrpBuild.Location = new System.Drawing.Point(12, 12); + this.GrpBuild.Name = "GrpBuild"; + this.GrpBuild.Size = new System.Drawing.Size(458, 58); + this.GrpBuild.TabIndex = 0; + this.GrpBuild.TabStop = false; + this.GrpBuild.Text = "Build Method"; + // + // RadioUnique + // + this.RadioUnique.AutoSize = true; + this.RadioUnique.Location = new System.Drawing.Point(238, 26); + this.RadioUnique.Name = "RadioUnique"; + this.RadioUnique.Size = new System.Drawing.Size(156, 24); + this.RadioUnique.TabIndex = 1; + this.RadioUnique.Text = "Keep separate files"; + this.RadioUnique.UseVisualStyleBackColor = true; + // + // RadioMultiple + // + this.RadioMultiple.AutoSize = true; + this.RadioMultiple.Checked = true; + this.RadioMultiple.Location = new System.Drawing.Point(76, 26); + this.RadioMultiple.Name = "RadioMultiple"; + this.RadioMultiple.Size = new System.Drawing.Size(145, 24); + this.RadioMultiple.TabIndex = 0; + this.RadioMultiple.TabStop = true; + this.RadioMultiple.Text = "Merge as one file"; + this.RadioMultiple.UseVisualStyleBackColor = true; + // + // TxtDestPath + // + this.TxtDestPath.Location = new System.Drawing.Point(6, 26); + this.TxtDestPath.Name = "TxtDestPath"; + this.TxtDestPath.Size = new System.Drawing.Size(358, 27); + this.TxtDestPath.TabIndex = 1; + // + // BtnPath + // + this.BtnPath.Location = new System.Drawing.Point(370, 26); + this.BtnPath.Name = "BtnPath"; + this.BtnPath.Size = new System.Drawing.Size(82, 29); + this.BtnPath.TabIndex = 2; + this.BtnPath.Text = "Browse"; + this.BtnPath.UseVisualStyleBackColor = true; + this.BtnPath.Click += new System.EventHandler(this.BtnPath_Click); + // + // GrpDest + // + this.GrpDest.Controls.Add(this.TxtDestPath); + this.GrpDest.Controls.Add(this.BtnPath); + this.GrpDest.Location = new System.Drawing.Point(12, 153); + this.GrpDest.Name = "GrpDest"; + this.GrpDest.Size = new System.Drawing.Size(458, 66); + this.GrpDest.TabIndex = 3; + this.GrpDest.TabStop = false; + this.GrpDest.Text = "Destination BCAT Path"; + // + // BtnCancel + // + this.BtnCancel.Location = new System.Drawing.Point(99, 225); + this.BtnCancel.Name = "BtnCancel"; + this.BtnCancel.Size = new System.Drawing.Size(125, 29); + this.BtnCancel.TabIndex = 4; + this.BtnCancel.Text = "Cancel"; + this.BtnCancel.UseVisualStyleBackColor = true; + this.BtnCancel.Click += new System.EventHandler(this.BtnCancel_Click); + // + // BtnSave + // + this.BtnSave.Location = new System.Drawing.Point(250, 225); + this.BtnSave.Name = "BtnSave"; + this.BtnSave.Size = new System.Drawing.Size(125, 29); + this.BtnSave.TabIndex = 5; + this.BtnSave.Text = "Save"; + this.BtnSave.UseVisualStyleBackColor = true; + this.BtnSave.Click += new System.EventHandler(this.BtnSave_Click); + // + // groupBox2 + // + this.groupBox2.Controls.Add(this.BtnSrcBrowse); + this.groupBox2.Controls.Add(this.TxtSourcePath); + this.groupBox2.Location = new System.Drawing.Point(12, 76); + this.groupBox2.Name = "groupBox2"; + this.groupBox2.Size = new System.Drawing.Size(458, 66); + this.groupBox2.TabIndex = 6; + this.groupBox2.TabStop = false; + this.groupBox2.Text = "Source BCAT Path"; + // + // BtnSrcBrowse + // + this.BtnSrcBrowse.Location = new System.Drawing.Point(370, 26); + this.BtnSrcBrowse.Name = "BtnSrcBrowse"; + this.BtnSrcBrowse.Size = new System.Drawing.Size(82, 27); + this.BtnSrcBrowse.TabIndex = 1; + this.BtnSrcBrowse.Text = "Browse"; + this.BtnSrcBrowse.UseVisualStyleBackColor = true; + this.BtnSrcBrowse.Click += new System.EventHandler(this.BtnSrcBrowse_Click); + // + // TxtSourcePath + // + this.TxtSourcePath.Location = new System.Drawing.Point(6, 26); + this.TxtSourcePath.Name = "TxtSourcePath"; + this.TxtSourcePath.Size = new System.Drawing.Size(358, 27); + this.TxtSourcePath.TabIndex = 0; + // + // SaveWindow + // + this.AcceptButton = this.BtnSave; + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 20F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.BtnCancel; + this.ClientSize = new System.Drawing.Size(483, 261); + this.Controls.Add(this.groupBox2); + this.Controls.Add(this.BtnSave); + this.Controls.Add(this.BtnCancel); + this.Controls.Add(this.GrpDest); + this.Controls.Add(this.GrpBuild); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "SaveWindow"; + this.ShowInTaskbar = false; + this.Text = "Save BCAT Package"; + this.GrpBuild.ResumeLayout(false); + this.GrpBuild.PerformLayout(); + this.GrpDest.ResumeLayout(false); + this.GrpDest.PerformLayout(); + this.groupBox2.ResumeLayout(false); + this.groupBox2.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private GroupBox GrpBuild; + private RadioButton RadioUnique; + private RadioButton RadioMultiple; + private TextBox TxtDestPath; + private Button BtnPath; + private GroupBox GrpDest; + private Button BtnCancel; + private Button BtnSave; + private FolderBrowserDialog FolderBrowser; + private GroupBox groupBox2; + private Button BtnSrcBrowse; + private TextBox TxtSourcePath; + } +} \ No newline at end of file diff --git a/SwitchGiftDataManager.WinForm/SaveWindow.cs b/SwitchGiftDataManager.WinForm/SaveWindow.cs new file mode 100644 index 0000000..320b4ef --- /dev/null +++ b/SwitchGiftDataManager.WinForm/SaveWindow.cs @@ -0,0 +1,186 @@ +using System.IO; +using SwitchGiftDataManager.Core; +using Enums; + +namespace SwitchGiftDataManager.WinForm +{ + public partial class SaveWindow : Form + { + private BCATManager Package; + private Games Game; + + public SaveWindow(BCATManager bcat, Games game) + { + InitializeComponent(); + + Package = bcat; + Game = game; + + if(Game is Games.LGPE) + { + RadioUnique.Checked = true; + RadioMultiple.Enabled = false; + } + } + + private void BtnCancel_Click(object sender, EventArgs e) => this.Close(); + + private void BtnSrcBrowse_Click(object sender, EventArgs e) + { + if(FolderBrowser.ShowDialog() == DialogResult.OK) + { + TxtSourcePath.Text = FolderBrowser.SelectedPath; + TxtDestPath.Text = Path.GetDirectoryName(FolderBrowser.SelectedPath); + } + } + + private void BtnPath_Click(object sender, EventArgs e) + { + if (FolderBrowser.ShowDialog() == DialogResult.OK) + TxtDestPath.Text = FolderBrowser.SelectedPath; + } + + private void BtnSave_Click(object sender, EventArgs e) + { + if(!RadioUnique.Checked && !RadioMultiple.Checked) + { + MessageBox.Show("Select a Build Method."); + return; + } + if (!CheckValidBcatPath(TxtSourcePath.Text)) + { + MessageBox.Show("Invalid BCAT source path"); + return; + } + if (!CheckValidPath(TxtDestPath.Text)) + { + MessageBox.Show("Invalid destination path."); + return; + } + + var path = $"{TxtDestPath.Text}\\Forged_BCAT_{Game}"; + CopyDirectory(TxtSourcePath.Text, path); + + if (RadioMultiple.Checked) + { + try + { + var wcdata = Package.ConcatenateFiles(); + var metadata = Package.ForgeMetaInfo(wcdata.ToArray()); + var metadatapath = $"{path}\\directories\\{Package.GetDefaultBcatFolderName()}"; + var wcpath = $"{metadatapath}\\files"; + + if (Directory.Exists(metadatapath)) + DeleteFilesAndDirectory(metadatapath); + + Directory.CreateDirectory(wcpath); + File.WriteAllBytes($"{metadatapath}\\files.meta", metadata.ToArray()); + File.WriteAllBytes($"{wcpath}\\{Package.GetDefaultBcatFileName()}", wcdata.ToArray()); + MessageBox.Show("Done"); + this.Close(); + } + catch (Exception) + { + MessageBox.Show("Internal Error"); + this.Close(); + } + } + else + { + var metadata = Package.ForgeMetaInfo(); + var metadatapath = $"{path}\\directories\\{Package.GetDefaultBcatFolderName()}"; + var wcspath = $"{metadatapath}\\files"; + + if (Directory.Exists(metadatapath)) + DeleteFilesAndDirectory(metadatapath); + + Directory.CreateDirectory(wcspath); + File.WriteAllBytes($"{metadatapath}\\files.meta", metadata.ToArray()); + if (Package.TrySaveAllWondercards(wcspath)) + { + MessageBox.Show("Done."); + this.Close(); + } + else + { + MessageBox.Show("Internal error."); + this.Close(); + } + } + } + + private bool CheckValidBcatPath(string path) + { + if (string.IsNullOrWhiteSpace(path)) + return false; + + if (!Directory.Exists($"{path}\\directories")) + return false; + + if (!File.Exists($"{path}\\directories.meta")) + return false; + + if (!File.Exists($"{path}\\etag.bin")) + return false; + + if (!File.Exists($"{path}\\list.msgpack")) + return false; + + if (!File.Exists($"{path}\\na_required")) + return false; + + if (!File.Exists($"{path}\\passphrase.bin")) + return false; + + return true; + } + + private bool CheckValidPath(string path) + { + if(string.IsNullOrWhiteSpace(path)) + return false; + + if (!Directory.Exists(path)) + return false; + + return true; + } + + private static void CopyDirectory(string source, string dest) + { + var dir = new DirectoryInfo(source); + DirectoryInfo[] dirs = dir.GetDirectories(); + Directory.CreateDirectory(dest); + + foreach (FileInfo file in dir.GetFiles()) + { + string targetFilePath = Path.Combine(dest, file.Name); + if(!File.Exists(targetFilePath)) + file.CopyTo(targetFilePath); + } + + foreach (DirectoryInfo subDir in dirs) + { + string newDestinationDir = Path.Combine(dest, subDir.Name); + CopyDirectory(subDir.FullName, newDestinationDir); + } + } + + private void DeleteFilesAndDirectory(string targetDir) + { + string[] files = Directory.GetFiles(targetDir); + string[] dirs = Directory.GetDirectories(targetDir); + + foreach (string file in files) + { + File.SetAttributes(file, FileAttributes.Normal); + File.Delete(file); + } + + foreach (string dir in dirs) + DeleteFilesAndDirectory(dir); + + Directory.Delete(targetDir, false); + } + } +} \ No newline at end of file diff --git a/SwitchGiftDataManager.WinForm/SaveWindow.resx b/SwitchGiftDataManager.WinForm/SaveWindow.resx new file mode 100644 index 0000000..570f296 --- /dev/null +++ b/SwitchGiftDataManager.WinForm/SaveWindow.resx @@ -0,0 +1,1386 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + AAABAAEAAAAAAAEAIACfNAEAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAAAFv + ck5UAc+id5oAAIAASURBVHja7L0HWBVZujW8tbune2Z6ejpHW9ucI6BiRjEgIiIoKgYQEAEFJOecc1aC + KIrkKEkEzDnnnHOWHE6o9b/7FHb3zL33/26YcG/P2c/zUsU5VefUqdprvWvtvWsXY8qiLMqiLMqiLMqi + LMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqi + LMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLMqiLP9Li3lBkCLWUKzI + 9WOrigKZKa2bFgYxs8IAZprH3wuhbSgKQ9maojBmQWFVHMbMikIpwphpWQRbWxTBrAvp9cJgZlkghrIo + i7L8bwR9YQRbQ2FGwdctCsOZWX4gsygJZTqx65hFfnA3s8Lgbib5ft1W7PDtRiTQzYy/VhDSzbwotNua + 4tBu1qURtB7WzSI/lJmW0ucUcPCHMtvScGZVQp9PhGBZGkPrcRTxypOuLMryzy52xYlsXUEisy9NZE7F + ccwrJ4K5ZQWyqM3O7Nv6vG5DaxLfn1Ib/YeJu8I/mVwT9qlmTfjn88vjvtAri/tyQVn8Fwt2xn+5qCLp + y6VVyV8tqYz7al513OcT92764x8ulb3Pjld3H1mb9d7M/dnd4cKYUdFaNrvYghlkmTKr3GBmlReivADK + oiz/6LKGy/Z3QTI+IMuGmVZv77ahNOF3dgWRf7TJDf1kQ27AV0HbnYYnbXWZs3mzi8nWTfYbSpIc3Gti + 7L0Lk2y9dySt99yeYuuelWrnvn3jeo+sxHWeOxRh45adbGeVucnOMHWzvXZ8pqNmyHZHFac8p2/0y9x+ + r7fT78OVxSEfGOdHdbMpCmFryoKYY7GSCN4V44pAtqo8iK3cGcyMy0LY6tLQn0NZlOV/XEzIv/Mg+a4I + AMylIOwDr6KorwKLokdG5kZMjc0KnhudFWCRlumSlJPqWF+W5HBn90bHhpPJLq3X4lw6TqU6tR1Ks2/Z + k7aheU+aXXP9xvXN9QlWzXWxa5vrIy2aaiPWPKmMtjhTsnFdXWGmY2l2jnt6eoGXXUKO16zQHF9Vj/yA + AQ65/n8yLwrptqYsmJmWBTIrIgGLkn+dNgK7opifY0NxLLMujGLGxeFsWVkEW1EeQiQQoiAAk5IQZlYc + xiyLwhRtLbzNhYeyKMt/qZiRL7fk3rwglK3fQtmlKrr78rrY35lURX7pmu86PnSLg21qrFV2kbfxyd3r + 9e/sN9N5echEv/3wSj3p4TWLhGNOK3DRdw1eJ3hBkhkDWUkKWndloKFmMxqq0vG2JAEN2/zQkuCCjhBb + dPhZyjsC10jbo2wk7XHOnZ2Rbi3t4e7P7yb7XijO8csOLPJZsbosuO/8quCPxlUFdjPf48eMCgLZmuKA + f4nrYVQexox3RrDh+3zYuppQFpXnzRC0koG/idJu7FVy9x4nIt+bVR/+3rTaoG5ueelsQU0sM6yKYMYl + YSIplET8HMqiLP9uWVYRxhYcTmMrSoOYVlU4W1Ud292kJPxjy0z/nxzCHKZY265aY2aycLOZodZFS+1J + TbYThwsbBvcQbH/4RLD+9GOYf/p7mP/wJ1j1/hzOw35A3KxxqLA0xv5wT5wtSRfeXD8E6ZMLwOPzwPV9 + kB/fCdmu7UBhMpAVAWwLATKDgS18GYH2/Djc2xnfdrYs4UxdQVzMxtxAXefigF6Ld/p/EJUTzOzzA5lf + 7m9TCVgVBjK1Qi/mXxrGUrLpN96s6qa9O+l3K3fH/tG1OPiLlK3ugws3OWmXJXsZ5mz01d24JVDTb1uw + mnNhdE+bqqRPjPcmfbRib8Lvlh5I6j7rxjZmvCuOeez1Ymvo89aWhSsru7L8+wRgQlLSuDy0m0Nh5B/X + bfHvvSTYSnPG6rnOM2eq7dAaNejC7P4DG2f92FeY821PzP/me8z/6ito/emPmPfx59D84gtM+/ozzP7s + E2h/8WfofPd5x+I+vZ4tVx99JcLP/sT2rPiDN24cv9DR/rRZLnkOefM9yB+fA67sg3C4FELdDqAmHahK + FYMUA+q2UuQIDfuKGo7s33Zwa90mn4jyGBWXdI/fBRSGsfztkWxRRdBvo72lJkIR6yrDmW1JKHOkrK+d + bcOCd8Z8lJbp9WNaurvq5gzf2dk7QsxykpwSS8It60sDbU6kuJju83deWbbWcUXacg8zp+X+67WXB1mr + msc5DbXZFvCTQ3HU1w7lcZ/aV8X/ziDTXdFGYFkXx8wqlGpAWbqKDVW4RTWRTOtqNltUGvBn00Tnacus + FwXqT1Xbp/PTjy+0v/umY84P38rnfvEV5n32JXS//AoLvvsaWt9/hulf/wFan36DuZ98h4V//A5L/vAt + dH7o2Th11ICqaZoj1y9YOVvTNsp+uFXUhl7Je7eO2vfgROj9109vNHc2dsrlbwV0PoP0zQ1I7p4CLh4A + ztYCZ6qA05UUVRDO7YL8Sj1k5+vkrSd3P7tUn7c9NT9KY0NB8Ee+eUHsXIwzcyn+v6sEHGpCmNXOIGZX + GcTsybsvLU1nBzKc2ZyaiPdtysK+C87yNzyRaLftSaTNtafe619eWmPUuNdoflvmnLESf9WB0rV9v5Ms + 7ftN59ze37ZP79fruebQIRd0Rg0+rD9jbMXiVdpxhl6rrZekOhssK/AbY1Qe+vGC+qjuIVlhbEYtfW9e + kLLyKwtjlvsSmPNGF+ZUEvahddT6CasXasQvHNnvru6PX0sXffMVFn/7FXS/+gx6X3yJRV98jaVffgOj + r77Fkm++hv43X2Led/T+t99A/+uvpQt7/HDNYIJKzEqThVMdgmy+9Uz1+cSzIOIjh9LIDyzy/T4IL037 + ofRInd7J+xeiXrQ9OSwTXjdASoqg/TE6X9+A7OEZ4M5R4PYRisPAzUNkGQ4CN2j9+mGh5WL964s1W3fk + ZwZqmJT4fhix3YsZ1Uaw1dX/dxq8HGvjmc3RHGZVEsg2FfuyL45t7LbgQMxH8/Ym/XH23pQ/WpaGfrE1 + K2DioXSvgIupXideZQY1vU3zF6qtlsBhSC+Y/PCVsOyzz7Hgzx9i5h/fg8ZnH2HSF3+E+jefC+O/+0Y+ + 9ZsvhKk9vpZO6f/DK03Vgdf05044YWyknWoaZLnYKSuwv1NNwgeBW4OYaXEIs8kOVALgX7msLOGNfkFs + /bGM7nZJToNNjbVCzUb0v2fy47eCyfdfY9XXn8Po60+x/PsvsOzbr7Him29h/m0PWH7XC2u/6wlTWtfv + /Q0W/vSVzGDgDxeXz1S1N3ZZ1nf1y+z3HKeNY95RTsw7N4w5FoUzm+JQtrlyO2PhE95zLI3+ZteF2vn3 + X1zNaW9/+laOt+iUPoX01WXg3nGKY8DDE7Q8CeE6kcEtIoAbpBCu7Uf7iZ2vju5M2h6RGzhhTa7XB/al + wWzZDm9mWv6/nwTsqpLZhuqNzCTXX9GzEpnv/bttub4/FWc4zahM3jCnINVl/tb8ENvy3PCC5zs3PZKX + p8kfxbhju8E0mAz6BlO++RMmcLv1yddkuz7FtC8+xuQv6LXPP8akbz7DpC8/h8ann0Lz888w6+svMZvI + WevHrzG37w9vNbVU9y6zWeSzYaPbmNDK5A+c8sPYXBwkBaK0A/+SZTn5aN6l5ETrq7J9P7eyNbRwUR11 + 0emnH4X1Pb+B1U/fwOKnr2BJS8teX2NNr6+wtufXWNfze9j16gWb3r2xtldPer0XVgzr/3TpIg1fozDL + H/hnb3x5khlv9WHWJVHMrJB3TYUzk9IoNmebF3OtS2OVL04xq+0BH6bW7Zh6+uqJHW1NTxvR8gB4ep6y + PmX8q3spDkB+8wgkpAYE/trlerIIZA/OlAoN9VkvqrMjkzcU+A012Bf93rJ90cykIpht2JnwvxP4FXFs + bUUoW1+ZzFwr8ti8uk3vm1SEf5tcHT7v8Gan9FeBJvckHsuaOsIsW5rzoxubzte0PTtbL6tNiRG8dOYK + c7/4Upj9ZwL9p19j6ud/xuQv/4ipn32FKZ98hRlf8Nc/wxwKnc8/x9zPv4TWZ1+A9sG8r76CNpG4Lik1 + o6+/lS0ZOej+SmOdpLWx9uPXlUZ8aLsjiC3ZE6UEw79iWVIYyvQrfNiUc3HdPYLNx3jPmZTtO6Rvs9+A + H+HZ7we496WgpceAHnDv/x2cB/0AR3rN7ade8O7bFz79+sKvT29sGDxQtnbelJ32wetUo5/t6+66yZNZ + F0co+qHXka91LgglFRDCgrJDWOj2YMY96AbKPjsiQ5lrRvAf0qt2TD5z/eiWjhfXXuEeWYCLBPQT5cDx + MghnqyG/UAucqxFfO1wI7M+GrC5HeFYQfffwFhfnoPyALyu227K1xfFsw6EJ/yvPtcfOAKazL4TdTPVl + uvujP96c6Tn5+Eab0OsRJsde+Rk3dPivgRBuB3l+FCSXa2Stb6483b8756LZktmnZg344eysbz+7Ovvr + z17N+vpzuea3n2ImZXtNAvuMr76AJgF81ud/wpzPP4HWl3/GvK+/xvyvv4EeKTYDUgCG331JCu5rmHzz + HYx6/SBfOmrAo3VGcxM94t1Ulx/d8r739jC2Pj/6f96QXBqmCCNSlcsLQ9jyvCC2soBeK4pki4qUvQ// + ++Q/ZWajwg1s8a6AD7036BmGqY04G9qvhxA2uAfCBvdC+OA+CB/SF2FDeyN0SA8EDOmJAHotZNAARFBE + DuqHqEF94TFl3EMnm6Wm1jXRv3dJcGLryiPZCrr4pgUhbFWWL0s+lsPq7x9itdd3s2a8ZjKSvuG1qSx+ + 22bWu8ybzdjm/bste7ap3j1TmyY9WduAwzsB3iuwKwOozQT2ZAP78oC9ucDubUBFGlBMkRsme5ThenDr + dj+NgXu2dXfNC2f25XH/+9pYdsUym6potjs7nqUXhn+6bUfg4tpk5/KHcetetfovF+BvDsS6QshJgHCy + XJC+ufT49qNTWTml6bZr7JeZ6c9RW6c3po/PnD5f7Jjd64v7Wj0+F7QJ+PO/+gxzv/kz5n77Z+jQcv43 + n2J+jy+g3+MHLKJY0uNbLO/xDVb/+C0sfvwea3p8B3Nat+zTQ7BSH37XytrA326bz0/8GC0KItmagv+a + FVieH6iIVQVBbDHZu4UlYUyvKIgZ5Acw45JwZlbGBy1FssVEAnqUBIzyQ5lZThCFvyKU5Z9YzPPDKWNG + MrvUNcw61/ULH+PprtGjhjyMG9RbiB/2E+KG/oT4of0QN7w/Yof3QzT9n9ivF5IG02vD+iN52AAkjxqM + cI3REpf1izI9M7z7pa3SY8HlyZQKGDtxrp6xFYz1SlzZfdFW5w/scwN+H1Ye+3FSZfKfI4oT/mReHPY7 + pIaz1mRXVpflzuZVebxXUZ007nV5xnahdHMD8hOB7CggK4yAHg0U0v/FyUBBPJATCWwNg5DmhcZU51cH + N/t6Lt8V80lMUShbWfG/p0dgTUUsW1YdzYyr49ikvUVsWW3on3Nzg1c1RPuclIc6SoUYRyDaAUj1gZAb + A2FfsVy4fuLF6zsntuw6UTLduSzyC8uCgE/MNvt9aRbqNGKV2SITw2lqtcuG9JesHTQYtgN7w7Lfd7Ac + /BOsaH11z+9g0vsHmJA6W0m2zLjnD1jb5yfY9u0Nm14/0rZfYkPfL+Hb93t4D+rZ4aileszdb/UKu+LY + P35Zt56ZEwFYFP/HdoDf8MXDjI/GLAxm6/gIUbd6NiDXlamVBHUbWxry3pTioPdnFQf/bn5J+IcLyGLo + lkR9OKck6gO14rhu47OzmeW2MGaV5cdWUYJYWujHVuQrlcE/jQDs8kIZo2zsHWs9JGqB+tb0UUNaMoYP + wOYRfZA2vC9SCegp9P/GYf2QOEQkhYSRfRE76iekD++DTCKABJ1JLwLCrJd770n+3fOzx9mKTc6/D8yL + /nZjRerAiroCzeMn66we3joT3vLg6pbO+1ezWm+djX55ttShsWqTiTzdV0cabTvxVdTqIWdjjH/M2Oz0 + bV2+/9Sr2d75ramezUj0BOKcKZyAJHcgxUuMjbQe5wJE2UIasU52M3ZDWVS2Ry+4mbLVO//33C8wsGIr + m0ngT9kdxCx3R/4hc2fIvBsZfvskiR5SJNLvSvWEkO4LbCeSK08RhNPlDS8u7y2oO1wwNTUr4kNmDLZw + T8oHMw9v/cK2PH5qQop7ZLan8f3KNfOFo6u1cXH9Ulx2XY0r/ja4HOyI8wGOOEtxImA9DnqaY4/zCuyx + X4oa83nI1x2HtHGDET+8B6L6fo6ofl8IIeN6t0Ss0syxzgwatbY48f21xeHMaHP+v/kdVqQU1xK5OuVF + MpvsUOaQE8G+376629Isj49WbHX/3CzLp6fPjsCx0VmBixKyAlanZvpaZW71ss9Od3PNTvNwTsrwMHbI + dh23oNTru4mVQR+PrY7+AC6/ZxqVfmxJibUSjP+MYlZABJAbzKbjdvcAj+UzU2epHM1TGS7LUxmCXJX+ + 2DFmALaPHIgtnBCIAFLJBiSNouWYfkhW/Qnbx/RFtspQpK2Y+zg81XOx+/aQL+NrtvQrP71L9+yDc043 + 39xIetP2dG9r+8v70o7XzULHGxna3ghofdEsvLl2W7hx6AwOFuxFSXJxx/aglOcb3X1vhNmuPROy2vJI + 1Modb4NMn8F/LRCwhoIkcpAFEGYNRNgA4evp/7Xia17GeOZnfG172obxnMysKsKZdVXY/xLpH83sK8PZ + qMqI7kmVkaOPlUVltW0LaUO6D5BB5JbhB2FLAKmccKA6Xdp8LPfY4T1b9E1K/X83Y1fMe66FoV8nZweo + b0lztMpJc8ypSbC5fT7YVPbS3xjyIDMggUgwm8hjJymjmq3A/gLgSAlwthS4UKYI4XQRZPXpaN4RhKeh + Ljhrsxz1izVRojES6ep9ET1f5d6GWDt7xzz/7w6vDaMMH8Q25Mcwm4IotqKMyBRk40pDmCWRg39GFLPY + FvC++Xa/Pzrkhvb2L4ydnVS1eU3eocKA2lM784+eLT925lz5hctnSq/dOllw5/bh7Q8uV2+8d6gg4tzO + Hb7FBRnuAWlpLsaBm13UbbLc/syv17IiH7akKEAJyH90MSkKZ045AexboHus+XyD4knDbleNHYmKCSOx + c/wAFKv2R/6o/sgeQURANmDrsL7YMmIgCogMto/5ETlj+yJ/qiryPNZINubGHMo6lB95/MHprOdNj691 + yBrfdqClvRPtMgk6wIPQrwg52gF6FR2NAt7c6cCVw22oK+kUtifL5JHuUrmHpaTZeYmk3VlfgP1CwHkx + 4ErhtoTAvgLwNaFYDXjTuvtyYMNiyFyXNFZsslvd90L6B2v3+P+vIYC1RADXa/3ZmproL3YVR7i0bA5+ + iM1+ZF/8gW2BQDJXM0QEW4KBquQ3N/ZuCnPeF/KdQUnk+3q1sX1cy0LWFqc4Vzz0MHgmddIWBHsdwFaX + zsUyIJTIL532LYsD9m0BThQCl2qA2/shPDoOPDtNcUaM57T+6CikV6rRtj8bzTkJeBnpiSvOpqiwXiBJ + jLE64lceaLqiJvirhZnB3fhwYUsiALPSaGZDWX9RgW93s/zgP27IDf/BsTBa1b823SDrTHnIweuH6u49 + unyn9c3DN9KWx53y1vsCGm8KeH5WwN1DgnC5AsLxHAiVKRAyQtAZ5ym9mOjycke6S41jjusynRKPPy8u + ilESwD+lC7CYpFx+ALcA3dKWaK7cPWHYyz3jR2D3lJHYPXkwKtUHoVR1AIpUBiFvZD9kk/TfpjoIFST7 + C8b0RrHGKNQb6ODa9mRcu3Zc+vTNvcZ2aVObXNYBQd4BucCXUjEECqIBOYUMUkj5/wIRQedTqqDngPO7 + IdRso4xIQAizh4wALnMk0K+dSzELWKcF2MwD7PUAJ3rdmcjA1QCwWwRY6kC+QVd2PNgidl1Z+CcaBc5s + TeU/nwAcq5PZul1xbPCeyO4F+SHTnmcEHJRt8pBhE4E+mQggiaR/tCMQYwds9oekKOnKherkuWProv/g + VRGiWpzmEH7Zy+juCye9zg6HOQAP+/lEePSbvcxEa8Tvn6hMBY4R+C/XAfdPAC8uAU1XgLZrFNeBZlpv + Ok9B57nhLPD6FJHBYdp+N2QH8vCiIA4Xs/w7ygsDD4cW+5ubFgb0Js/+0eTi0m6sKrqb3nafj2yzgoZG + liYvyd1fEHjswsGChw9unH7b/Px5u6yxU4ZWuq4isQs85E10XV/Q996B/Pk5SO8dhOxCBbCXSCovFK2b + nPE80qrzQaD1nupYp4n96oO7Gef7KAH5DyeAkjC2oVBBAGyHwXTz/ROHNR9UH469U0dg77ShqJs6DFVE + AjtVB6J4VF8UkuTPHzsY9SrDUTNdFSdtV6I5Ow2yu+chSN4CQhsFZXaplDI8BYEccpkYAgVBX6CQKSiA + r3OCeA2hkSrqrQMAVUZFo1+MKxBiRRl+FeBIILelrGdNlX+NJmAxk9a1KeZDtl4LcgsCv5kW2k2n46Ld + 0t3+27x7Rm1zVoxzty7/5zYuOVQls9Cdocy/NOSzY+leIZJEtyYk2AOJvP3CG4gk+R5GvzOabA2pgsbM + 6IOppTE6sQXheqUb7baeDTB60cIzvjURoC0RoKOuqIZcSPkE0j5p9BmF8cCeLJL61eKgqYYbQPsjOueP + 6Zw/oeUTuiT3IHTcoKDz3H6VSOEykcEF4BUpg4fHgKu16Dy8A7f2pnfWVSefzyuMjU7MC9V3yvUd5VQQ + PiSyIk236HhF0rn7Z48/aX7wuK3jTQc62wQInXRNO+k6dkIm8JASCcgU/0NooXrwghZEAi8vQrh7iEie + LEl9CpBDlifBAe1BNo/3xznOY88Su5kqCeCf0AaQH8HWFQUqbistWjDN8vDkoe2HJw7FgakU04Zg//Th + qJs0BLvGDUKlWj9Uju2HunFDcW3eTDzx2YDG2h1UiS5DKn9KF72VKkMHVThOAAR22S+gVyz/KuQUXBXI + 0AJ5J1XYB5SVjpaKrfzxVLHDyecHk9T3J6nrThlvA1V+KyIBUw3IjTUgWz0L7UQIEpM5aDHWRPOKyXhi + bnAzLt1tImu5yBbvz/qnEsCGXfHMeddGdj7NnKUXBKm+jHA4qmi/iLIEIogEwh2I5NaSjCeSizRXWIHb + 6eFnfYtDgwoSnctfOSxqwJrJpHwmkvKh372BzoMLnQ83Ck9TsQ1kuw+wKw04RZ6fsiwaKdNLCfR4TUFZ + mM4tpWHI5W+Ig+kayeg8S+8SAdwmoiBl8PoyhDfnIXtxAsLNesguVkN6aKfwtjq74WBV0omYqvD0jCM5 + SWcenN7zpunpK7m0RYDCxrUrKJxfPwXJC7K/JHr+moIEmmj1GR3KPeAxEc7NA2LbRC0ngVA8irc7s2Oj + 1ahG/9XMJM9bCch/dFldSFmyVCSAEr1pVoc0hnUcJ8AfnTIUh6cNxmGNYThA/+9TH4w6tb6oH9cXJ/Qm + 4G3IBrqIOxSj9YS3VyCRPSQC4BWO5B9XAF0VQiAS4BmBx78hApmoDmRUUSRUQYVXVHkv7AZqMskGhBMJ + kLwNI2D4UbbzILnvrE8gmK9QAMLKKZAaTUHb8iloNpqKN0unocFwIp6baL0pCLFY0f9u+Xsrq+KIACL/ + aefWrjqOOdO5HXNu0/sXwzZYd/ibNiCEwBtEBBBsLTZs+hL4fY0oTNERsUE4kO789pqz6bPXq+d1SMym + kLWZRKQ3nWQ//XYXUkJuZH88lwI+tG+MB4GIsv++YghXKLu+uA6h/SWd0za6Bp0Ku4WuEAi0AhrovJMs + 73xAl+meQp6Dn/PH5yBw8n1wTLzn4speCKfK0bJ3m+xpeXLz80u7GyWSZx0k7wUp/1yyd9zicQKQQype + V3SBXqEIOrqC1CAaKV4QAT0gLiDl8ZgUx3X6juNkByoycWaz31bX6FWf5satV4Lxn9INWBjJrHcGKQig + fNF0y8OzR7afnjYMp6YOx3HN4ThK64eJAA4RARwc3x9nNEfjpYMRhNxI4GAucLEO8kenSQ3eoorBLQD3 + gp2KivEuOyjWFRWlK4Su9gCuFDhBdKkAtFKlvE2VYz952dxEsWEshMDiZ0xWwEgEgO08AsRswEwTMgJ/ + ++IJBHx1vDacgjcL1fHAUL2j3GGRe/83+943rYhiNpWx/7Rza0sEtKk0gHnWRX5xP3DdNrnXcgI9/Q4f + S7EBkwPZ1VAMN2O8DTbFiSAjocGYLM5SAr4JZX9LAr8d2R0n+u0uC4kIKQJWkoIgAt5MJFm1HcLpWpLx + 5O1buexv7gK87BdgKs57O0UDnXciABlZg3YigabbCtIVHp8l8J8E7vN7LfhNV/tJqleKIy13boLkCF2P + N3fo+rbylpuu60ZE0KXg8BffJREzP94RAVcgb2k7+s5O+ozXVyE8pO+7dlDAvgIcKYgNGZpq8/uATB+2 + tEQ5c9E/voU6L5KtLQtQEEDZYg2TQ9ojGs5qjMC5aSNxauZIHCcCOD55KE5OGopz00fixSodCOQ9BZJv + Qu0W4BB5uqtHFDYAHTz7NCkagiRdjX2iGuj8VaUQMxLP+jJeQbgK4HbhXWPg49OUHaqAUpK1G/1I/q8j + wJDc9eet/YZiAxhvC7DgJDALAmX+twaqeKGnjga9SXiwRE04uEY7guH+exaVkWxdecw/7dza18Sx1o0k + /8sCRz4LWnsCrosgeJOScbMUFY0TAduBAO1E0t7RCI989dBoqQEsHwEYj6GYQQSgKyofF/rdLmSDfAj8 + Udz707kpS4NwcieEO4cp0ZK3F551yf6On4lWtGD8nLeKtkCgc8xtACfbhpsEyEuQPTtNJHBMtBA395EC + IEI5UUxenZRYcTykeVHoOFoJ+dtnCjKXvvtchcqT/qptR/qz+hO62noU361oF3qpIB6h9S7kby7RdT4i + CEdzhJKSuJRJeaHf4xyYYa4/W76DiCBPOR38P1ABxLI1RcEKAki11tbbtWjMvesaY3BBQwXnZozCGY2R + ODt5GC6RJXi2YAJkVgsIjBYETjcgn1RA/TbgXDVlkBNE9vfo2r+ky95MIflF8v86+3dlCoUC4JXlZ8/I + s0ozhMb7ipt/ULNDtAFRZAOCiQQCiAS8eMYkwGwg4JjPAkwpO5pMQrvheDzVH4eGeROICNRwden0jQzo + rrcniFn+kwjAriaJbdgXwRiev3c6aPXyjg0GL7CBsvgGOn47WtosgGy9JuQ2PMPTa+v10Wk8DbKlo4gA + xhL4pwJriABsCfiOi8QeDzfe8LcW2ETSvzAO8oN5EK6TAnt9BXKS/jJ5O7hElyu6WzvwSwOdtIsEmrss + wEO6Vrcpq5P8f3UeeNKV/e/Qeb9M4D9JpL43C6Dsjx0REFI9IU9ygVCZDtnbq0TvHV3KTaawGvzacSMn + VxCC5C+us/i9HaIV4N8tuSeS1bPzkF3cLeypyzjqXRJuoFsU+GckLGMLiryZV66jEpj/qGJakqS4Weew + Zg8W62U4rt5A7cyN6Sq4NFMVF0junyMCOD9lOK4TGbw2mAS5OWVfF5KxUXZiHzbvfjpapJjei/tJofMx + VcAGRev+z1noLyTir/2i5JdGQsW2tE/nSwhPSM4eIwlauJEqu5/YYBZIntebMqWbgagCLHiPAIFnzRSF + FXi9RB1vdcbh+UI13FoyfQtD83urdwUxq38iAeyJs2VWBzb++ZK/aYKwfoEcNgR0a96iTzbGQpvOJRGA + JYF8XRehLVUHlqgQAdDSRENs+XcgwnVZDMGD2wci3nhXskcxQF02cKFeoZiEtkeUiFuIAKSKkNN5lXMi + EMTW+Z8b6rgcF54THrn8v0mCgDLxC5Ljj06I1usqfd7pcpL+OeJ1zY0CUn2BODr/AatJ+a1Fx75cdLS+ + VmR+uaINQCQAbuJk7xTBXxBAV2Ogwgq8on/5d98QuynvHceza7WNx/Zt25W3I9gkcKvL9+zAArY215dZ + lESxNcXBzHKH8g7Fv28vQFE8My8NY/GxJixg8/peZ+ZP3nd9FhHAXIpZo3F+2nBcmDYCt2er4pXeBHQY + TYVgvUDMRGk+JBHJq+/llXEXVSSS7613qEK86rrg7yT/f0QAnb+qLO8qShPJRMoSN0mS7s0HcmKBBC8g + jKuAVaJvdtADrLREf2wxDYKxJtpXTMKbBWp4ZDAGN4w0dwxuqvvQpSyEra/459wUZLcrkeGDL1hsmudP + V52X7xEsCfQ8OHFZ0LGbzYGwggC+ei79T79jBWX9paqA0RRaJ/9vTgpgPdkcJ7IAHoYQgkwg8EZR3kW6 + Nw+4SHL9CWXSFpLV8reK7M/B/3PvC61LBNGGKVSWokuWFBa3ACTD8fY68PIC8PQMcJey/9U94i3WBwuA + qs2k7mIU3ZKIdaLzbkbKawmE9QboDPOE5OJJ4u12RZefrIsAOPhl767rv7nmki7yoXrB2wJ4D8QrbgNO + Abf2C9LjZR03q1IuZO4M87Er8htsusPnd3bR9swiJ4JZZEcqQfp3twFlQcw7z52trQv55IL27MLrs0fj + gs4wXJszCldnjMA18v53iQCezVNDk7465KuoYrqtEsfm74gUK8zxEn4xSVbShZXy/uc3ouRUtARL/oMQ + CUD4WQV0io1V0reUIShDXSRVUUtSdDt9RyJZjgjyzv4mlBENCRwEJsqgMCGgmMyCYDIZDQYquGswAleW + zyhafyDzk7jtwcz2n0QArruTFLaqNNB61DMzvTsCB705j5mQmc1E56oZRFqzIDOl37GKQG84jILkvxFl + frNpJP3ptznqiO0ewZT5U9whK02C/BjJc36rdCP5eEmLSKKknOTyTkWrCu91UYS0KxRmgIdUYc0gJwJo + IZJ+TeTxlJTWg+OiejtTLY7BeAf+DA5+B1F58XEHVkRUK2dBvmQh2jZFQfbmrkL+SxUEI1XIf/l/SABd + jZDyN2IbBLcBb8l+PD0pEv2V/ZAezJW35Ma+OZ/iXeyb5TR/+s7gT6KL1RmrP8N0S5Tdg39nGxDAHAp9 + mc7JhN8dWqwbcl1bRXp1/mDc1hqFGzNH4gbJ/zuzxuCx1hi81h2LziVUQe2oUoRYA+n+QEmyKBsvkQp4 + QnKy9RZdd5KawtsuEninBKR/FZKfBwa9awcQB5S0Q972gpLFBQi8YpZvFmcJjncUx/57khx2JBVgSURk + Ok1sLFs9Ee1Lx5ICGIHzKzTrAwtjej/cYMXW/RN6AfhMPz7V8QoCqA221Hy7al6j1GSGQqnIaNlhPJ3A + r4HOFTOITAnoRpTxFxP4l6mK3t9qJoFOV+z5CF+nGCGIyhQJTlc24tGZ52h5+FiQNT0kAFJIH/AlEUAD + wVEm8G5VIgCZXFQCnFylFBLeG8N7CGQEwGbKwC8vi4rtDkn/izXAYbJx1RniXZb8vgR+kxInHsr8fNCV + YDoDbYYT0aw9BY+sjdB0rEpBQLytRxzlKfbm/PsE8I7cG0ULIiEb0Ew24BUR0D06hht0DKdLgYoUvMoM + 7Di8yXn/thSXFS473D/bmuLArHO8WXqKsxKofzcbUBrArMsoU+J0t1LbVUtv6qu/ujNvEO7N4tl/CK5p + DMNtzVF4MGsknmuroI2sgLCGMpcXZeME8qQ50UBNhngR7x4gdicVwAf2KKxA439gBf7aK4oh6+ofkAut + ZAUeisNaeU9DySbKSlQxIykrBZmLDYJ8hNxaAv8qAo3xWJLU6ni9aBTOrdQ8Hr4tZBQf3biu6h9PAPa7 + NrHAigim+bLovT0RFubNq+Z0SldqQLZiOjqWT0MzyfyWpXwcw2QCP/f9Eyj7j6cMS+vmk8VuP+8VEKJs + 5cKWwHZ5edpL2YmyS7J7x6vkTXe2ymQv4zvkzZGdQkdEpyCJ6JC1RUtkrSVt6LhEYGzqlMvkEvyqpV7W + ZQGkRACKQTkEvmcXxCnXrpH0P0nXrW67aOcyiWiT6JqGW5H1WAbY6CjaIzqWqOOJ/hg8mT0Gt3Un4sW2 + aMgbnxNZk82Qid/Fv/U/JoCuRkhFO8Aj0Sq+vSi29/B5Hy8T0R8mtVccC1mSl/RoituJiB1uq613uH++ + uiyAOW33YWvzlU+E+rsRgE1xBLs8eyiLjrIZdnrJ5BNP5wzDgzljcJUI4Mq0wbgxfSjucwLQGYum+eMg + WUmZy3mpeFfelkCgjFTAYZKQ1+qA52dFmUkqQMCbrhFhvxotJvy6LeCXUPQr86wl4dvRPrI3iq4qXD0I + 6ZECyMqTgFQ/CDH0nYHGEDwNIbfhsporADUC0BR0UCW9bDz9QkyK20R+f8P6Xf/4RkA+39/e+oXMsyry + D8fdl8Y0rdSQS5ZPRccyAj5F47LJaDGcjLbl4yAzosy/iPv/ceT9J4v3PLiskAphzo9bM0P3Pa5Iybiw + b7vnwSM5BrWnikfXXN7Vq+LGnu8Kr+77pvjawe/Kbx//ofb2yZ8uv7g241HrE4emttd5bfLmG1I0dkjR + qhixpxgQpBiSTZZB9kxshefen0+vdq4S2EfAK9tIdi5M7GGIsBbVxwZdyE010U6E9Up/HK7rjMSF6YNw + VWMIHriYo+M2AZg33HaNAOS9Ooqenb8mAEEke3EwEl1T+XOxG5LsouwFgf8BWZCrVG/OVIqTveQloCPZ + VX4vyu5y8UZnB8vCoK/PRK1m3+/PZetylROI/H0qbVEUwzDGfDLdPjm8Zu6mJ9qq8nu8IXDaEFyaOoiU + wFDcmz0KT+ep4c28sWilDCa30RNHs/EBO3lRlEUygbMV4ogy3sjU+ZgqxMtf2gGEvwL/vyEA8aYhnq34 + TURSoYF4gFQAZQnh4m4IvD0gN5YkMVXSSEuxT9xpoXiTkCmBaPkUCEvVccN4yo344NWaXAFsqPzHNyLZ + ViYx90of5pfn/dn5NdrljZThWxbzmIgGirf0f9uSSZAYkZJaMpqyP0n/Zeoks+fgjavh88dRNnnN8T5G + b7eEjDu5I2xQfm7o9zF5IX8YELaqG59AlMdfl5jCpA937Mn7Ye/5/ZrXrx+Pb7188L702S1yU6/ovIpt + MXykppy3AXAC4C3/l2qBI/ni8xf4wK5Ub7F3h99p6aAH+ZqZaKfjfK03DvfmUjLQHIGzkwbizLjeOGsw + Ha/qy7tGHYqNjiL4/71eAIlo7wQ+FuGNSELNdxUNgcLzo6QaiYgu7iUCICtyhKxIeRopEX+0xTvKb8ba + Xa9IsrMP3+L4NTynMKNCP6ZXuk4J2L8HAUSmO5ANeN2tdsMSk/sLJr2+QZ7//NTBuEBxRWMo7swahUdE + Ci+0iQT01dFpTh7cfQUQQ7J8axB5ON4lWEiZZT/w4iLVufsi2wviEGH8egBJ12jAX3oEurKEoqJ0UHVq + 7+xEU6dM+kxCflVKKkCGA2VylKfLkRtKMtWRVICFKFN5t6AV2YBV0xVZ9IHJ5CdbPA0XcgXgWv6Pn+nW + eH84860IYOE5Ht/dXKp5smnxeDQumoAmAv8bWr5ZrE7AmkjSn2IRKRejsZAvnyy0rTO4fzXEIjyvyGco + h3hTRgi7lRnC9mwPYrnZQSywOIrZVcQw6+oEZlWVyKzLE+j/JOZTs5ltLdnC2o+fYt+e2/h+abD93FNu + ay7cSAiSvD1QLgjPb0ImeUWESmQgf0IEcJXkPwHvdIX40JXCrkY/fh05oTsvgdxSSzHM+u38sXgwezSu + zBiBqxOH46zaQBwZ9SMOTRmOB1sTIbQ3dDX+vRv0JfnVIKSurl6IDZW8F0JhCyWPFaMQ8ZKs4sMjfFQg + JQ5SAad2EwEUioSUR2ok2RXyCGvhUqz1lc2bnSztc/0/37zVn5nn+jHrbOWtw3/z4lTozzBwMNvuv3bU + SROtkxcI8GcmD8F5Av8FsgHXZ9BFn6OCJ0QALxaMRfuKaVAMbglZR9LRByiIFQcG8S5BPrS04Zo47lzR + FvBuhFrnvw05J4c2gUiiXY7WNwT8m53C2yMyyctj8rf3zktvnrklP7b3sXx/+QvZ7m2NKIwXsNWXVICN + on9aMUTYhiwJZVDeiPbGeFLLHhdDcz4YKKT4H0sA0RXxzGxfDMvZ4s62ZLgNv2eoeeONnoqCMN8S+F9T + vF08Dh3c8y8kz7+Q/P+KOfIGu6Vnq1JszSOLvL4rygrpnlQewnRrI5hVdSSzrYpljpUJivh3yZtIbkN5 + ONtQEc7uakxiB4zmzb6yYMLdm/On4IGZIdpS4ijDnobw9i7kraTMnpPvvkaAO0jZv4xs1RZ/scWfjzMg + WydYaSuu7auF4/Fg5ihcmzYc56cMxSXVoTgxoj/qRvTGHtV+uORujc4XD0hZyBXDg0Xylv47Xbtt4khE + 3ijMe4j4IKQXl/nNXwKuHxFw8YCgAP+hEoCPLq1IEO9w3Ex1Ks4a0iAz+dVI25M+O1yW6RT7foLFYKtz + A5lJjpIE/qbFsjyM5YVbschtPp8ftZqfcXrGSPmJiYNxVmMYzpENuDJ9CKmA0XikpYpnOipopkosWMwF + vEzpQrmKU1px9j5RIo4pf8lVwK2uIapvu4ajtv1cIcgT8jvLqPa0kFFtfiyXNxxv6niWc6/hht/dV9dW + 3Ht22fD+rePL7h+uNH5YmWt5aXemz8Xs0F1NofbtsjAbyCKIeEIsusYGiLcHw3w62k0my094rvKfcW/P + RzH5kYpbnf+RBLChKoR9gRfdisNs591bofX0+cIxRJjjKMbjOYHq7aJxkBiS5184DjKyUrftFty5GL5u + 9fl0lz/AaRUry/Fmb0PXs6jq//yQWLM99L21YYrfetBi4dqbC9VaHxDxvLJdjM7NJO/3U7a/fBAC7/a7 + R1n3bLU4sSof7MOnVgsl3++2XHEO5as00ECe/xEpwOsE/LPqA3BybD8cH9Mf9QT+yhF9UDesB46smo+2 + x7dFAuCDjv5iYJei4Y+TulxAixzyBjmkz9rQerMZry62UYLowJV6iXCmWiKc3CkTjubJ5XszhfaaNNnb + yo2drUUJcvnWQFJ6Dopr3BC4VnI4wmK3f4antmlOyMdnIk3YooIwZlHooQTu36qsogzjVuZDlejSe/U2 + C0yPTB/56siEQTg9dSgRANmA6cNwa+ZI3J8zhlTAaDRQBZOtmkHgIxkeRt4xjbJyCTH3gRzgSh1599MK + vynw0V/c9/GxATwLyN9SxngjF2Rv38qlb663tj7Z8/LVrcR7986YnbhQNynv8I4ebnkBH/3Ze+b7bCXr + ztxZN3bi8+6/v+Lz++3+qxZeWzr7zoMlk3F/1TS8MZ0Bybq54n3yfEit5UwFCZzzNin2LQ79Cd99xZxr + 4v9h5zCKzqH7zlBm8aD0d/nOxhbXDWe8faw3Gi/0JuCZ7ng80xuLtwZjIVMoADW0Gqpj14a5pd57wnoU + 5HsoAByy67/2lB6H6kTmVhDDgmrC2ZIHuX+qc12e+GDlZHTY60JIIKtUtgnYS976ZDWEq/UQru1VjCcQ + ylLELr9Ye8BvtWKYsrB6FjoWqeM5Xd/bJPsvThiM42p9SPb3wr7RvVFFUUYEUDP4WxzQm4am+1e5BSCQ + d0pk8nZK91KJGJIWudD2TCJ9e7+t4/md1ub7V1tfXz3S9OTErqab++obz1Tuf1W/rf5l5cbqF5Xxe15W + RJ18WRp+9m5e2N7z2eE7720NqmtJ8bogS3S80xlq+bgzwPLNi2DLl1uSPXb4Z3hNNMl2fd8u052tKXBX + AvdvVdaURzH3giAWGriW+Sc7j6qepX5m78TBwlmqBGcnDcfVKaNwnRTA7bmj8Xi+Gl6SP2whIMr58FYf + E2JrNyC7a2DQmVJSAeTtHpPPa6BK0nINHZ3XIGu5JuDVlU7pq4uPmx6dqbx396jv3gtVuhkHt/eL2pn4 + kb7tIkVDV+GZEhZan8Kcd5P8rY1mrrVRLNt+KdtmubjnqaUz9tyeNxQPZ4/AEy0VvNRXQ4exJgRLUgGW + fJTdDLyy0ribkbZWf/rlXe+v25XB7MvjWeaR8r/7OfShY3arimCrX+363WbHJZZX9CY1PFughuc6k/BU + bxyeGYwh5aQKgQhAShbgicFE7F8+I2/1oZiPjU6EMvva5P9aD05lOFu3O51Nv5bEZp7d+kHwzpCpJ2I3 + HG3zJmWUwOcZJEIuSecPV4Vweick9/dC9uQkJNcPQcavUyKBP2QFBGc9yNbMRvuyGXijMwG3Zo3ApanD + cGbsYBwe1Rd7h/fGbsr+VcN/QtnQXigc9iMqpqjh0aXDMpnQ/roDbdc6ZE2X5Z1vr3a0PT33uuFO1f2X + l5Iu3zvqf/zSbtf6cxVmO8+VT8o+mtcrfU/GD2nVm75JL4r+Ii87+JMteYGfpRUEfp2aH/BNUpbfFylb + fD7J3Or36fZM36+ztnv/sG2rz+jdqT7rL8Z5VbzxtttTH29v57nD4evCJEtmUeSpBO7fsriVhrHQNC/m + tyPw253TVctr1Ad0HhnfDycmDcWVyaMUjUE354zAI+0xeDZPBY0GEyDljYEuvEuQJHkG+clS8pX7d5DM + 3Kl46i9uHYH8zlFBcods/b1jrxtuHz5583JN7L4D2bPKy1O+j88L//36zS7dUusz2Mbdm1kIZdGkHWHM + oyyK2fE7+iqCmX1FGCtxWsk2hdl8fmb5rNzbuiNxV3ukoj3isc5osiRj0LSYjoUPCqLjkVjMkRz2Ntrk + Vhbw/YnCScyUsqRP7t//aUFe9ZuYx64otvpF1QcZ7ivNri6c/Oaprgqe6E7AAz1VvCY7IDEYB/nisWjW + U8M9ItKDhtMKzQ/Ef6R/yo850v7/qZ6G2ghmUxfFLOrD2LEkG4Vy2JjrOfhEknPKq2CbBlkkKbLUQEWX + GqozyV+XK4YPC48uiDMGNd2C/O5RSAoTILiaKKxc+/LJeKWnTr5/NKk9Un2Th+CoSn/K/P1QSwRQNawX + dg7vhRKKgqE/oGLiGFw5VvXoReuz7KedLx0eNz4wv/Pw4qoL1w/r7T1ROa5g15ZeydnhX0el+XwZlOr9 + J6tEx/eYyseK41f0ZOT5MpRGM1boxdg2N8byXRkrDWVIC2Fsbyxj5zfRug9DTAzbGe/6x2PhzkOvB9vp + lqa7zYvL9PzuEu3jvtVLCdq/ZXHmBLDVj3kVhn6WP0tta9WEga37JvTHUaoMFyePxEWNobgxezgeaI3G + UyKBN3rj0b5SA4Ktntggl+gCITtc0a8s37MVwpF8CCcq5dKT1U3tx6ouPzu6M/Pk/lyT/IrkgXplHh/s + rdnKsksSWfDOaMWwXZ/y2H+/gXJXNMuPt2fh9Ykfn1yltenWQlXcWTAGD7VV8VBHhRSJCp7OG403BLa2 + pZPQaqqFGw6LrqZl2OuEnaz4wHLzOlZ8fu/f/fy5Uwb3ro1hK19Wv78tYM2KawbTXj7WpeMk/39fj0iK + bBNv/GtfqEK2YAzuEIkeXKxRvG5fwu8tDgYzpz2p/2/JXxnB1l6KI88fxZyqglnFFvc/Fqe5TKlNsE1+ + FmH3FMEbxP78HVGiGjtaAlw6RERM4H9ym8B/hxT6Q7LrTyA7vxdSH0d0LpuOBrIkj0jdXadrfH7KIJyc + MBD7RvVBLUX1iF6U+XugaOiPKBjWE/nDvkf5xFHS7ck+OVv2ZI8tuLP/DzaFob9jTpPeZ2NZdw7wA/sK + WE5hAkvfEsyStgSxAP7Allz+NOIQtoY/MaokipkXR7I1JcG0DFEEf4gMjzVFYcykKIStKApkttl+rCzR + nb3yIYJo8X0vIdv/9zkbA94/SeSREK0kgL9td2B5GHPJ9mf2JaGfbF48Lbx0wuA3dZMG4OBk0QacnzYY + 12YOx905I/F47hi8ogzGu7dk/CYXj8Xirbt8ltttQUBuBKRVibK2qq1PbtRlFO6rSzfdWp04yKMw6CP+ + XfEHU5lVrhezKA1iU/8fDV4bauNYfIEPW9W268P61VpBVxeOk96ibPqQvv+RDo+xeEIge7aQQncsTpvO + Eh6v1Wo77b8iIfnQ9q8D40zZxebHf/fz51KbxPzq49jnQLftEdazryyc8uiezkgFWT1aMArtumqAzji8 + mT8K9xeMxi0igP2GmsVOexI/dqmPZK71/zEB2NQks/p0X7Z8fxpz3RXJFpxKfc9iT3iPso22Vs+D1x+T + +1i1CZEE/lRSYbnJwK4sAj95/Sv1wL0TAM/+L29A6Hyo6A6U4g1kb5+irSobb9fq4MmcUbihMRBnpwzA + sXH9sF+1H2pG/oSKkZT5KQop6+cRCWQP74kdQ77D1lG9Gn3cjOzXVcZ8vvP6HlZz+xBd0yzmXp3AbErJ + BhUFsNVlgcxiZzCzJWvpmOXPHP6b3Xd2hY7MtMieBRS4sMwsP7Y13Z/h1g4WkagkgL9pWVcRQRfJj1nv + iv4o0UbPKnfS0Hu14/sL+ycOVMwSdJYI4PL0Ibg1c4Sif/iZtgpeLxiruLlFceuqpwkpgfVAtDOQ5CV/ + mRN++1RZQnRFfsj4bZk+f/JOsO/msZN8a0kI+/G4/X/6uDbsjmcB5f5sMm6/X2Cts+6K3sSme/M5AVD2 + 11El8I/DUwL/04UT8IxkbInTYuH4unnyWxv0zhzM8JtmSoAsPpv/DyEAn/pEVuJvzLJibIZf0Z108868 + YbhHlqVhgSokpJiadel4dUfjNh3/tbmq2LNkZqH37sRPgsg6uNWl/fufS+9xmR9f6sZg1pfNPJ7z4cEE + G82HQcs3v3BbdL/D10ymmGMwhcv+ZMh355DsrwDOEfhvHYXw/Dykjdch6bgHqfS1YuYgOe9+lXeQLbiM + hghn3J6jgnMTeuPoxL44qNIHdeT9Kyn7lwz/ESVEBArwD+mB7aQAtgz8FhvH9r3n6b1S2/hO6fsbKKOv + KA1TAuj/erEgAjAvC2G6r6q6RQebTts2ffTRWrWBsgPjB+KoxnCcIQK4pDEE1zVH4N6sUWQDVPCSsnDr + 0qmQrpkNxT3vDssh8zbDqwi7J+c2+wan7wzvp3YyrHtBXjCLKwhlqytCmUvpf236J4e6JOa8S5y9OMPN + UPu6/oyHj+m7H3N/TRbgid5YRfZ/qk8EQJEbYIat+mrCiYVqjfvD13v5nNr6cV5+AFu55+/fDsAJYPtG + G5aZbN/7yvxJVzgB3NceinYiqXYigKdkCe5R3NAejctEALuXzc4N3J38aXRNHHPZ/ZcKwK88gUUWxzGH + XUkstDqSFVa4dK/MdPipOtnO4pzvqkPtLkvaFc9FCLLmhCtm/roCCMerIL90WLxz8OV1oO2BYlJQGV4S + 8Nt+ntKL33khdLwQXpdulV+ePwnHVXti79ie2DOSN/j1QdmIn0jy/4jCEb2RM7QnsoYQ+IeKETtp8MkN + boYjeCerZWWMEjy/ibEARABrqiIUd7K5bLTpmz5vYm7tmMHtB1UGYe+UwTg5dRAuEAFcIQK4PZPbABVF + Y+Bb8rWdSzUhM5tFJKCNN3bzhJ0Ja4747AqZNqMiuntIVThp/tHMu9L+v3VcjvXJzJGOa0uoMYvdZDvk + 5qK5p17OViMwkQqZNxLPF6jhpYE6nuuLfe3FvqZImD9VKJw6RFZvt7DMp8R3IFS+Y4sO0Occ+fsOD3bf + FcMysl1YaobLjxfmT7h0R2sons0ZgTayKC8p+99ZqIpbpAaukd++qKUilC3X3BJUl/JpQt1G5lC1UfEZ + njUbmfeuTWz93kRmsseNjb53hFkd2vrH4CL3CUdjjFI6XBc8xgZDAS6ktkJcgfRQoCiFwJ8PnN0N3DwC + 2csrEPhsvB3PAWmTAvSQv7s5iENfimY0CnLp245LB3c1HtKfITuk0gs1Kj9g97C+5Pn7oJiAnke+P3do + L2QP7Y3MQb2QOqgHNg/tI0ROV62xCjHrM4lI2WFnrBI8v5ViXhnOMnWnMtts708TjecGlo4d9mrPmIGo + nTwYRyYNxLlpw3BZc6TiVuH7WuRttUbj+fyxaDSYhg4+xt1kAtqNNXDe0/h0cnHojEEPiruvOxDLCuO2 + /M8aKMsjWUSOKwss8PryhNG8whfzJuIp+evn80bhBSmBlwvH4oXBWLxcNA57HPQRN3sy4oYNlGfpTLic + FG+/0HlfwoeRBXHMcm/Q3/X8eZMCSCp2Z8nb3b47pzPhAr+r8vW88XhMGf8uHettnTG4Scd7XUcN52aP + kuWunpkYQAQQW5PInGtSmPXBWLbkKdiKo0FsT7oLG3Yj+nfbsjxH3o1Y5/bS0/j4W8dFzXKe9QPXAXGU + 9TfHA6VbgX2FwJndkN8/C+HNA8r6rxXTrPE7K6Xvbgoi2S/IXpADeArpg6voPF0rf3qk4m5ZZWZNyYq5 + z+pVe6N6TA9UDumLgiF9kD+4B/n9H5E1uBcyB/bE5kE9kTSwh5A8pG9n5DyNTOtNTt+e5o20RcqZe35T + BBCe4s7srxV9EOu8fGnO1NEXd40eIK+ZOAgHJw7EmSlDcX76cFyePgy3yQbcnz2SZLgaXulNJIk7Fm1L + R0O6dCIeWBq8zE11cbfbF/2pZ2ks86iMZI41//2K4srHKezyZXb1kR/us17s83DhlI7n83lDpApekQJ4 + pT9WEa+JBA6ZTEP8vCkIGzhISBw96GWq48qQ6JKQ79K3BjC3+mBmX/X3k6x++zax8Ao3FrfD/asz8yac + e6itRiplAq7OGIzrc0fgDlmWW6QEbuqMxfk5o6XZ1nPDfPek/DmiJp651aWzgksFzH5PJLM6mdAtOz/g + 05qNTguOR1rnPfdc8RzOBHw3U8r6G4BkP5L88RAqcyHnt0xfqic/f4Yw/4BkfSMEabtislW5vAUyaSPQ + 9IwswRXITlWisWQz3sb44J6fdXtdvPO22LzI+Zmm82uqx/YXKkb+gNJBfcjv90HOoO+xjQggk4CfMeBH + pA3phYQhPYW4UQNfRi6Z5+ZQn/iHIN+1zFM5c89vq7gWh7B5QDevKCuVlAWTy0rGDOqoHj8I+yYMwvEJ + A3F26lBc5GMCZlNGmz0c9+dSFtZTgaCvDsnKCehYQbF0luxAoEm9c4nnZOfayA9ca0KYVfV/Xyo6lYYz + +wqyEnjTLS90jc6VZdMePScgvdRVw2uS/Yrx9gYTKNRxZelkJC+bgqhBg4X4/gPbs/W1KlPSncf1QkE3 + n2qvvysB+O7dREB2Y5E5Hl9cWDDl7P0FE3BlpgpZp6G4rjUKd3XHUqjhNvn/i9qqndmu+r5uBzb9ybc2 + irnWJTOb+hi2/mBSd6vdgb22b/ewfumz7pTguLwTzoaAH4E/whHYSJK/IBXYQ37/FPl9/izA52cha72L + DjSQ0u9Eu7wVguQ15M9voPnUbjTkJKE1xA0d6wwhX6kNrJiHpxuWXMtOWb9E79a2PydaLwosmzi0o3T4 + 98gf2Btbh/dF1sDvsJUIIIMIIHVADyQO/hHRw3rJwieNOO9ltUhnJR51d97iwVzzlQrgN1UcyyNYpJsu + c812/2qT6dygAvVhL3epDcLeCWQD1PvjFNmB86QArlH2v0kS9x7J28alaoDhFMiXT4N81RTIVk7Ga7OZ + DSe8raNzSsN6wsCF2R6MYd61Sf99YqqIVrRPpKfY9rtgOnPPC91xeK43AS/1J1D2J/AvmozGRRPxZIkW + chaPQ/TIHggd2EuWNH30+a0+Zkarbhd84Fsaxhyq/34E4F2XxNYeD2S+Zb7fXF4849wFrZHYP3kQrk8f + rWhpv0lq5T4RwIPZqriqO76jIGi5i/OR1D+61UUxRLmw/g9qP0gujlA9E7Eh/qW32V2J9yq54iGowZaU + 9T0hZEdDvmsbcLgUOF0D3DgCvLgCNPCJNl5CLn0OacNNdFw+CElZJiRRXmhxMkbDGm00r5iOtpVzABMt + 3Hdc/Kom3TU4vijwB37n5EaHFauLpgx/mz/4a2RxwI/qg60DvsHmIT2RNuhHbBzcE7FDfhQiR/VujdQa + l+0esrZvgMFU5qK8R/+3V1Jzg5lXjjtbc2fz+/E2+jpZU1VO7VQbJK0d1x8H1QfglDofFzAYFzSHkwoY + gWckvTtWTQL4RCF8WO7KKbQ+kchgCmUZwxsHUh3XBlWEfvIyZCnzqUv+bx+XV0Ucq/NbziLKPP9wfL1e + 2MNFEzteEeBfLySy0afgBGA4GS+JAArnDUfCmJ4IHthTFqHa716a1SLP6H1pn2zaFsgcK/8+GcujNpl5 + HkhjWUVebEuB7/Dzy2df3TOxD2rV+wg3Z43FbS1V3NAZgwcLxipurb68YFxLXugqE6uLWR+YHorrFlcd + 92XRjg06RxOt85/4rHkrd+ePRqOsH8anA3cXnwTE+/ePEfjP1wHXjpKsJ8//5CKEexeBqychPVaJhoJ4 + vPY2x0tTPbxePBNNS6coRvrJVk6HZPVcNFstaDnkYZiRUOTbn6FZ0buSEGi1IH/qqMe5g77FFvL+aSP7 + IJXW0wj4mwZR9h/WC/FD+8hDxw+5EbFitqnXzrCP/Da7s40xrkrA/NbKil1RbP6JjSwoeB3zjbDrm6qt + sS1XfWhTtVpPhQo4qzYU59WH4aTmKNycMxJtfCZbU00xVs8Q5+lbKd6fLzEZKznnuWTXxm3e43hFs9q3 + mTn/NwHoXhHDQov8FE8zLvFZb3B5xbSHrxeNRaPeVAL+DLwm8DcZaeD1ihkonT4Am4b1RdigPkLosL5v + NhrOSd+01bfX83GqzLkq+u9GAA77U+j4pN3qkp0Njq7QvJc36if5UY0RuKY1ns4Vef+5o3FPTw0PdUbi + soF6Q1aUubbN4+r3fOoSfgzb7mV1PG75fpn3gjY4LQF8jIEgK3FS1JwwsbGvjsB/qkbANf4Yr9NEAsch + PV6JlsJEtIY7oNNmGVmwOeg0GItOOi+t+tPQupTPOaCuyPxyy/nS+x6mtSmbXcdyNWVbHs5UcK57QIrT + rOwpY2/kUPZPGfwDMob1QdxQIgJFw98PiB7eC4kD+3f4TB9b6hC7fnjokknMcnccM65SPsjjN1lMdocz + 37wg5p0f/KeYVToO+WrDHu0c00vYxXsDxg5U3B9wcvpwPJlPlYt3//Gn9ayZJYYZJwIiAGM+bfdUNK+d + /fp6pJV34KGEj3cWBzKE2jH73f+9e/VDdgayM+tMWU68+6AbJloHnhtORMvCSUQAU6iyUyyZhreLNVA2 + uS9SqRJHDe6LkAE92yJmjqsIDbcezUnIreLvowA+P5bJEncHMYeriZ8cczEPK50z9vVOlR+EiwT861pq + BH413NBWwW1dUgNziDznTWzJSl3vsKk6cPaxBNvIVx4rb7a4LpMKrssB91VEAJT5w12AzQT+4nSgNkfA + wZ0S6ck9Tc3Hqzua9uwQOtNDIPNdB4mFHtqXTkPHYnV0GqqjQ38c2g3HQbpoAuQGMwn8cyCs0cJdZ6Pr + pan2q7zrIj+Mz/diFtWRbCSOd/fKcJmSPl314uYhPZBKgN/SnwA/RJT+cUNpfVhfIXRw3+fui2b4OGf7 + fBbpvZTZVSi9/2+6OFPlWPu6onuM6yrNnMkqJ4pV+kp3ThiAfeMH4sCkQTg9Yxial/AHdMwVCeBdcBIw + nyk+vWfVDAhm0/DCyeDy4UCzZcXlUb/fkx3AVlcGMa/KlP/yMXnui2VF6d4soSbhs4tr9VIeGU6VNy+e + QDJ3ItoNpqKdCKBx0TTsnNAXm0kBxA7ph4j+vTpCxg3b4+++YgJBi/ns/NtXXP99WSxtdyx7RetZ6XYj + K5fPrU1S6d26d0p/4RrJ/VtzVXFLZyyuz1MlAhiPu9rjcMdguqwi0eLskQTbA/f8jZ8JTosAO8r89pT5 + /Qj8kc5AWjiQlwqUZQtCTW5z496Cc9dr83PPFSftu7fRsaPZTk8xElMwmgYYTYV8yThIDMZAajieiIDI + mc4Nls2BbI0uXtroPj3iZeIZl+Xw1VU/U/bD3Sgi+mgigLPdPDa7TErSVD2bPOQHpPC+/n4/Ip78f+KQ + Xogd2hsRg37q9FUbetDHdukcz2t57zkXBSkJ4Lde1tZGKhrdfBLtf9q+UHNLjurAxkI18rQTBqF20gBc + pCwmM5kHrNX5Bfh8ufbd8/t4mwB/pPcECCsny566rNxTWBYxjb3O6xZYw+fO72BWdZv+S8e0YW80C6gI + ZrOaSj+odV5lfWfRjLevSeI2LRuH1kVT0UFZsFF/KsrH9kEGgT9+cB/EDuzdGTFm0NFA28UaPmQfgv4O + MwX1j5/NUnK9mdOdwg93Bpra5M0YfT9i/EDJCc3huDFnOG4TCdzQId8/dxRuzRuH21rjcN1gCk76L5O1 + uJsK4E//UUxsYgC4WovgTw8EcpMgFGyRyfO2v2rO37LrDKXvmOKwpYVbHXY89FjYLphOVEwpLixWIbCr + UdDSYBSkS8ZCtmyy+KwB/vAUa/3XZwPNo4J3+Pa46Wmo8P1m9V7MqC6GzcGR7m6bHKdGz1Q9G0cEkDz4 + R6T074mooT8iZnBvRPXvKfgP6f3IY+G0EPd4hx/42VtTEaEkgN96WV8fw2IirJj7wYSPouwXm6ZPGXWx + eGQf2a6xg1Cj3g83qDILvFWZE8A70PMlf4Ivn7ffossK8Pn7iQRklnNanvitzdi+M/qnr15d7B5XGaMg + GKfq/3w/sm19JHPfFcbq3SxYSoqb2hkz3WPPjdTQsHIcGpZNU8y8+3zhFJSp9EXm0P5IGNIHiYN+ksQO + H3AhzGKhrgPQPTArgLnX/W0nCrE7WKL4LYl5XgP2GM8rjRvTp9F5/oi2Y1qThBszh+OW1ihcmzsC17RH + 4IGOKh7OV0UjWZV2JyPIvVdT5jcEXJZACLUQp+ZO8yfpHwpZRnTHw5zE00fLkkOqCuIme9dGjyjI8/R5 + am9wT0LAxko+rRgngUmAQVeQBcDSKUTOsyGsnQ2p9ZzGK0HGGwvT3XpFpziy+Dxftr4ylNlWRzG7nRFs + Cq52D4qw0UrQULucQODnkj9hSF+EjfgJYQN6IaR/r1Yn7fElTr6mGiF7Ut73THFjxuXKp/n+5su6umjm + WxaoqNhBQaZD4+ZOyCwYNaC5atQA8B6Bu0QA8kW8AZADfq44IYclEYC1lvgUXz5DjwVXBbRcw3sJxqPJ + Wu/l6RDrmIycwOEhu2M+KCkLZxt2/ecb5ez2RLGcbD8WxUcG7oz6ZK+DYchjowkdTasmomX5dLStmI67 + CyaiVLU/to8ciOThRABDfpLHD+t/P9hk/lrHS1kf8d/ztySAwAPJLKE+mcWe2Pq7okS7FcVz1K8Ejh/8 + KMzD8PgR/blNN+eMUUykckOLlID2cMXIxaalkyGz0gOIAAT+wFC7pST7rYAY3s/vDWmit/AyxfftzZSA + mgPpgSu35AX2dq+N6rEt38/8UrTV+TbLuQJMZ4pPR1pJQeSHJRpiT8xqbr+0IFjMR+s6nc5bHgYlhxIt + R0OzP6kUH3YoRpxZd+2uGOZYFMJm4WH3IFcTgwT1kbcT+/9Amf8nyvx9ETKoJ/z6/ihxHzXgnOuaBca+ + mb6fhM+fyjxrE1lSQbgSIP8ShaSiZ5oTcygJ+DjEeO6abLWhNytHDhb2jR2IR9qj0ak9EpLF4yHw1n+e + /TkJUNaB9eyuR3lTZVzPyYEq6Gp1Re/AI8sFTzOjLcMj87z7cjB6lP3Xh+fqHMlQHFt21Jq5d5Zr3Hu7 + bCI6l2uibeUMXNRWQ/EYIoBRA7FxRG8k8Uas4f1fByyb7e1QG/OZJ+79zQjAb28yc3hUxJKLg1hyeej3 + FS5LEjarDL7sPGN0TUCcVfBug3nXbmqp4Y62qmISk4c6w9FOx6p4UKgdf84ht1D88d8mgK8d5IGOkAQ7 + y54HbLh7MNl1y+aSUC2XvQl/ctoX86fg3eG6+zY57Wu3WyRTnNd1XefahEh2xWxFKz/WzBFfW6MN+Vpd + 2Qu7RSezEqzma+6P+XBJdRD7/Fbdz8e+piqWeRIBrEXze75mC1bEDh/4YGO/nggf1gfhA3sjpF8vwb3/ + T09tZ4+L3hBj0ztRV4OtvrCN+e2MVuLiX6WY1YQx14IA5sSJINBsVKLmmNI8lREte1UH46nOGLTOHYwG + ymqdC8mHrqBMZD7nFyVgNUfxaCmsowq6lmcmqpirp0JG/vS55Zxb++LNzWdg9/sFpV5sR/l/7RlwjpSF + OHnEZ7r2PLRuYdFzg2lSudFstC+fieOzxyBnZB9kEQGkjeqHpOE/IWnYgEb/BRrhdkUBX9rTb3Ha/bep + xF77k5nnnng2CE+6522ymFG5eNqh4GGDzqwznOLmm+I8o9ZQ69j9+RPxeP54PKbz1cAnU+V3TnLgk3KS + rSEgW+lCsDGEZN1S3HM2f1sVtqFu2zY/67Sc4EFx1Qkfrj2Y/rF3TeSUA1HWuU12+i0CJw8r7a5z/K7t + hRMtJ4WZYlfsmjnyp47LzpTG2q+MKgz+g2+WJ1uVZctsdif+fOxu5QnMY5sXc8SlD7wXaa6NHNrvcUL/ + n3hrP4L79xF8e/ds3jB2+E5Te4Mp/pdz33dLdmIWO5W3/f7LFYfdscw/ej3zzPT4ImrlTK8U9VH3do8d + JjwhKduqMwRvtIahcc5QtOuMhHwpSf21WuJjsC1/RQCKXgFtsU2APHuHyVTZU49ldU/iN6iaP0zvVl/g + zRC6nm0p8vnP9VAQARRt9mQRR9M/rPIzX3tlxawHTUvJUxtpYv+0Ycge0Re5o4dgy2hOAD2RPLRfU5DO + lFiHAr+vTf6GBBBM0v/yrHEsriz223x3w+D06UMfeQwbfNDOxmB+VIqryqFlM8+8MJiMt/oTyfNPhMxc + fFBo54ppkK7QhNxkDlpXzMEdE62Oc+sXXtrjbZ6UvclLK7Ym/nO9yzu72dRH/T6uOGhKZYRV2h23JS+l + XE1Zz+162vCsX8JSUwQ/f3Ky+TxZk5P+6VuBFsYFW3z/dNPfjNnXJTCHXX8p293L45i3lzFzrgz/OHiB + hn/EyAGvw/p8L/gP7Aunfr0k64f3Oe2kr2nhlxP0J18vc2Z1PE1xx6iy/IsV58oY1u+AK1t3POn9wIBV + c6Nnj68vHzes48H80WjTHY6meWPQNGc4mmcPRcf8UUQCJHFNZ4hEsE5btAO8ncBcW/SnxmQFjCbwLsL2 + R15GuTXbHUayFFW2ryKcZe/9z0tzt72bFCogNdNv0D4rnfxHSydJmxdroG7yUFIAA1AwaijZgH5IHv4j + Ng7v1xwxf9pGpx1eX9PREYH8bYYDh9Yls4+Bbilpnqo5K2fWBI/58a2bukqZY7T9pJTEDWrnVsy48XaR + OjqWToVgpg2BzoHUSAPNRlPRuGwGGvQ1cNdgeiupmPqiWGvT8IrAvituFX/waLuvwuJE1Uf33Z5iH3XV + fvFTqS2f/ZjOqdUs8dyu0exSXFxR0LrlLAjrFsqkdsvOPQwxNU7a6f+ng8kbFOcoouzfEp5HeQzj5ssl + 1rZ32KwJBcHDerf79flWcO/7k8xyaJ87lgZTA9yCrfs541E3110xzLNCKf3/ZQlgA7+Rhyqk+3bnnlHL + tcIK1Ic8u6s7Ci0LhqFNZyw6+SPD5oxAC5FAO1kCqf4YCMsnimMBLChb2c4TlQB/VPbqBYpGKiwbD/mq + ia2v3JZk7871GcUrahRlqozS/1wDk23ldhZYHcFcjmz5KDNyhdEN44m3nuupo3riEOSPGoyiEUOQPbIf + 2YDeSBs9qGmjwZxEjyzvLwfR73Cpi/2fN/7VpzLvqjimhsb3tgVaLMmaNv68W58fHtktnJDgkx0zJDfB + evJtE40nHUbqEPiTgFdT5ifQNy6cjAYddTyYNx6XDGe+LfNYlZ+y2UOzoDzuw9ed51novhTmVh/DjE6m + /GFXob/pS0/Tq7J1MwXFw1DN54oEsH4aESstrelc2ul0PSJNR2hzXHXuTLzNyortjn8o3OJM16yTuVX9 + 2/svHCqj2Zr6aNaDyMvNY+Xs6JFDzwX0/U7u1u9bmWO/Xg9s5kyMsQleM6T6XEU3/nyFtenKJ/T+Sxfr + qggWkezBgo+n/y7QYaVuxrRRR2/rjBCa5w9Gs7Y62vTUyAKQJdAag+Y5RAxzR0BCBCEsHkeZXlOUpgr5 + qi1WYhNN8cm+K6aixXRm8zOfJTlNiWtHMzztdqooWJG1gmv//7sH/aoTmPXhZCZ10mB5W22+OWQzN/6i + nnpLudoA5IwmFTBqOLJGDEbGyD6yrWr9X21apePusTfjD7e4/N37P5sdyOVQOvPZk84O6quw2KrIL3LW + LYpMHt3vqV2/7y7ZrVmwPrAu89uaVEeDZ6tnNclNNCBbPRedhrPQsHA67muPxYW5KpLa5RrXK52WRpdu + clXP2Jv6YVWGO4upi2EvdziwCZ2nux/OtJ/0KMKkpsNuoQRrNegcclWl3XUuZ4lEwLP/enFK9GbHJU9v + BVnan97k9Gc4mrGiAg9WmP1v582L3x3F1tUnEfiPscDNvt+4L50T6D9wwAuvnj9JbQb1fLB26tA4DwuD + kcnHst8LCbJhL2gf753KW37/5YttfTrLoaVTolfPJN3JsTd0R7a0kgJo0p2IJr3RaNdVRfu8cWico0Ix + Em1awyHRHgG5/liS/JPEgUFWXd2EvPHLhN8vQLFsKqSWmm0v/JcWHN7hO4bhMdtMmZ3dOcEs9/3/3z3o + vCeOqd+uUKiT/HCraQeXzThQqNK/I2vMECGTLMCW4RTD+ku2qvZ+EG80fckwoLtPmt/fhADi9qYy/+ul + 3VMz3SfmLpp+IKjP5012o/vss3Nfox10JOOrfQk2AU3m86SC2Sy0rSDw603HAy11nJw1UlJnOOnk9mDz + 9W71Yb1VZbXvJe2OZc7HU1l4XRTbWRPzxz0FPrNuRJvkddrNbuXSXgF+q+lid6vVfMr4OuLThC2mQVg7 + B622+g0XvZamZGa59GnyWcRm3ilgJfn/wYMz7p1n3sXBzLMy6g/ewZaLnKeNOeLWv2+7U+8hD2wmqsZY + uusPn9ue2t0+ZT3bNnCEsuIrSxcBVAcx9+Io5rI39Xc+jot1D+qNvfx60Ui8XjQUnXPHEdhV0DF/CJp1 + BqJFaxA6NAejfQ69pzMSkgWjITckIjCZJpKA7VxREfDnCvAbh1bOgLBas63ddVHpiSLfqYvPpf6hKteH + OdTGsqRtjuTZ/+MRg85F3iw7zIZtKwj/c4bjMufkKcNubFPpJds87EtsGkryf8iozozRaneSls7X5UTh + u93vf3Qewg9tZM6HNrPU+ngWeWzzH/MDzddvmzLy4YZe372wmTZkm0/8+hE79sYNue+8ZK90zRxI6Pc1 + LVLFvbn9cH7OYGmVxczjiZEmq4KqYz/ln+dzMJk5Pshlq65ndHc4uemrvcU+pk0hS4/LbWd1Cpwsrbrs + kxWRphmdO7N5ip4DWC0k+T8PHeuXNNZ5m29z2e4yyvJCWnfbzA2s6mHdX/aa1Kcwuz1JzGT/JlJOUWw4 + HnYLyvIa62s+c5vjyC+eWQ754ubKmaMizFxXDt16taS7WYIF+0ldfPagsiiLotiTDXAsj1ZkW59kx165 + y2dkPNYd39lkOBqt+qPRoTsCnfOHEQlQkAXonDUcHVwFzBtFr1PojoRUXwXypRMI+FSh7RaIvQV8QIti + VNsUSNZMbX/jaXTkVpKTVU5RYJ9FJzPez853VVgCu71x/74V2BXGtm/xYfXCjW6JwebjImarF6WOGtC0 + acD3iBnUF8lDhnVuVR1wL3Xl9Pn8c/icAP51iSywOpI57QtnfrVxLGh3PAuqSaD1BOZLEbA7gbnWx7GQ + 2miWWh7Cigv82L4cL3Yk15dlViQy58NxLD/Lm8VVh/bIW6eXEj+6V6PtTz++sNeZkhK2M2rSkaxAhwZb + wxfylRpo1puEp9qjcWHGYFndsmnnSyLWmZYU+v25MtKUxZ7cxrLI6qx+WP5eemH8sD1R67weBa663Gmr + LQW/yUrxxKOugVa8B4E3ovLX19J5W78Qr11WNB70Wp2VE2E7PuRi9ntpuYHMN9eJxf3qGQMOu0PYl+fp + d+2LY3DRZR/Lz7yXvc1DpchvdVrI7LH3rQf3urNas2+0s53BiE312e+5+1uw9eHrmU+B8sk7yvJXxXFn + CltXE860b+R/kOq0cun1BRq3mxeroWnZSHQYEMAXULbXHQ2JjgopgjFEAEQE80ZDqkvqgJRA21xSBGQL + sHA8qYEZoozl7QLc25qREjCZCMFiDu67LL5TGbEmZlt+kErszuD3PXdHsiUX05hb7b/feGdxIoYlJDmw + 8FyvrwMXzfaNHT74YWLfn4TQgQMQN2RA55Yx3z1OWzFO9wOgm8eejcx/70YCfRRz2xfBfHbzZ+vFs5Dd + icyfvLFvfSLz4wRA9iKQCCCu0IelJq9jBbFmrHKTPdtcnsh8yUJskNZ0j9viOiN7sebhgP5fSB369e6M + WLviyLaymLjzcY5nO9fqyySGk/BaWx03Z6sKp/U1b1V5WNgE7s74875oSzZVep/F10WwqEMx76WVBY4o + jLNPOOdk+LB93TxBMWbCeJYIdt7Cv4YAbzIPgpnY5y+QAmhzXvLmsueaHckZXmrfY997Tnuj2YWgVcxy + zy+t9Zb1EUz/WApzqwlhppFLWd4Or6+Kk2z0doebFxYaabz2GdH/ld3kads2eBmoed3e/J5X8gbmxz5W + VnRl+bclqDaRee5NYZ7kV29/RJk306lP5bp52a/0xpIKGI+2xWQDyO+3G6iiTZ9ioRqBnjK/zmjIdFUh + 1RkDCSkD6RwigBkjIaesKF0yDnLzGWJD1rp5IhmQ3+W3ETeaa706Gmm5eeOuMDW9k+kf+O6NZzYHMpjr + 7jTmvzuOedbHMK/6ZOZXl6xYBhdGscDdKR/7b1hgETJ20OXIPr3k3gP7ImboAFnWyH4NcRsWWS26X/qV + 6eHNf7A+kvbRglMb3x//JOP9tSc3/97+6OaPHY5m/NH66OY/WhxJ/8PaQ+l/WHIu6w+2hzf+KXxnwBdb + tjh+X55q07Muw+nHTeWJX9sf3vR58LG0odsinMMLpms9d+3TSwgc1R9l7jadh9M8G5pdVsqaVmrhmcEU + 3Jo7BucWzmwu9LFMjquI7RGV4clid1aykzvGsjOUZZMPRfY+tMk65rnD/BdSi+miOlqjKzaUmk6m7K8h + yn5TPcht+AhCfUgdzBpOJTllxxT5qXvWZ77Hu+kiq5NZRE0sc6+LZp7VicybZL8jkdiWQi9mcCT2d641 + wYMqk22CXq+bffPlwpHyPLX+UtcZE46YB1gZuO5L+aPnDm/m8aiOuVSFKCu7svxlidntw3yqvNjVKwMV + T9zmMSO/7qOMsJV2F9dMed24eCraF09G5+KxaFsyBq1LVNBqoEKyf4wiJPNVIKWQEQlISRF0zh2pIINW + UgTtusMhLCNbwJ8wZDNfHOhCikBqPgevHea9vhW+YkdFlvtsm0PFv3/33fT35+P4dXyb9fCD2CjTZeFa + aqf8e/eQOA/4AmHDP0femN6y+oAVp/Zmu8Xvy/L1vZTuHfAwwSXwRoBl6CVv4+Qrvqu3XPYz3Xwzxjb1 + duKG1HvxthkPfPSzHkeZZz3J9Et/Wbs9/unRneH3j1UEXalMCbqQGhhzOMsvb3eQ2dWsqSOlXv2/QPps + VdwJsMTz4JVos5iN54bTcXXBJBxZNhFlHiseb84JcQrak/WTRX3Rn9ce2vpZ6MHYHidyAie+DFsf8dpZ + /3GH5RTFTVMw1ejq459I52SSqI5I8gsO89DpvgAPA1fKK9LdriUUx9iur0z5kX55t3fn5N26ImT0b8eb + 90KrQ3ocS1634raXQcWzdRNev146RajRGAb3+WOfOPmvjfYuSeilsFgVpGrKleBXlr8q3lV+bF2Og+Kh + jpn79T89dnnlqMtPlkw689poav0RU59bm3TftNtPR6uxGtoNSepTVu9cNh5SArVUXw0S/lQcsgBSUgFy + Csn80WjWGU7WgNSB1jC0zx4E2bzhAO8yNKHKv3au4ln1ipGEa6fjjaNOy7lYq4PHdrq4X7hoq3Pzidm0 + a09Xj7/y1HT8tUcUj1eNv/pomfqV20sm77lusWDnPrOQLNeZ13yHfiuz7fsnBAz7FAVj+uKKp5FwdYtH + 05WK5IePytOeNJamvGgtSXvTVrKppb1kY3trUVJbS8Wmljdl8U1vCiLbO3cEyGSVGyXyM9Vv8ezafXnL + 06vS1qeXpI/O3pEc3/388a70xtMB5pLMiX3h1e9PKFg4ES3eK9BhOwfNKzRwX28Cblpo4EbcYhyqcX5T + c8E349Bt7zXHH7gtO3rc1Wxfpk3AKZ+lNU2WC14rGkKN1ICV6uTz6RyYTBIJwJo8v60hYK8LaeAcdCYv + xMMCM6HgqPPjree9c8qvOdmcerR26qVn1mMvPLEdd/Gxw/iLT9zHXXvsqX79mL3G8bwNy2viLRPOuuhf + bTCZJsgW9sGteQNRuW6KsGWbyavUQ56ZMUe9VRwq/d732BPFPCqDlBVeWX6V+fcHMZfyQAX4009Ef3Xq + icPahgaTvVLp3EttmH1d2rnoqez5IlnnQQ00BfaFdLkq+Xvyr3r8DrWJikdhyw3GQkp2QEpEwK1AxwIV + vNEfhY75IyGQEpBpDYdca4RiXSBSgAEBYQ2BwHZ219BWXQjrdNCxSVMqvaz7Vtay8L4gnX9IkOnvFyT6 + BwTJ/IOCZPZhNGseF1o1zzZ06Ny8cmhee7TOD7Do8R2c+vRH3sgxaFhNQNqWjI4nV+XtLU9kkvaXHUJn + SwdkTTLIGmWQNsgF+RuZVPJM1tn6SCZ5dEsuf3pPjpbXckhb5HJ5m0wib6Vt22ToaJV3vrgjPI0OQ+bo + 4fAd/BP2rZgHiedKtK/Wx7MlBni5ehbebJuFjluLIGtdLQidK1sF6crn0ga9F+17dJskPjoSwXSqeAff + Mvqty0ner1pABNDVO2K9mBSRMeCwFIL3HEjLDCF9sBpC4yIIbToC/W6pIDV4Rj7qpFxYWt+JZbukcpPd + 6LTZI3trfrR934LbLeEzm9stZsqlBnQ+505Cs/ZEXPdRw81Lmmho1haams1u7nlg4xq4P+gHxtqZc0UY + 868JUFZ8ZRFLSH0Ie3huOEupt/70zF2b1W87Vx3vEJa3Qr64Qy4s7AC0pVL5FKGjeQCk+4ahxWUQOngm + XzYdwtKxEJbw9Qm0nKAgApmeqkIVdPDeAJ3RkBPgpUQIMiIH+Twij1ljqKIOJOIYBLnpeHGugXUGipGE + UqeZkMfMkgt1WhL5K60WQVjQLIdBUzvmNnVgSpMgn0CvqRNC1aVvHs/ADofvsH7Ad7Du2w/bx/XFw9Wz + ISlJh1T2AjI0Qo4mxdz5AJ9Dv5WiGYK8AYLsNb38FHh0Foq5965SnN8L4UwdhAv7gTtXIbx5AnQ8xr2M + aKQN7oO4wQNx2doEnWGukAW54aWbCZ4Gkwq6OhdyKakZ2RLI36yizzCGPHMBJD5zIeMDeficCbxrj4+Q + 5G0gNnrABn3xTsENSyD1WIT22FmQVBIpPFgFSJbT8dH2wkwIIHUgny8H9NsE6DdJpYaNsodLm+T1C1vk + KdPbJB7qso5V6pDq0Dmf2xttBl/jeQgtL0+lc0CWAnS8srXtL9qMD1RfszKM3bPhk1v3hzLvauU8f8rS + VZL3+7Lh8Tu7l5+1V3/aYF4pE5a2SwUDqoT6vPJRRZyKTmE4WoUeEF5pQFo0Ea2OI9BppgaZ0RgIRgRi + Pmno8snAUiICQ3XIKQQiA5AtkBMhSBaNhUSPtp+nRqRA2+uNgVx/MDr1hxJxdM03YKstdhuu04DgNwxt + O4dTZp0BeYs+OuS66AC9DvpcjIMgqKC9WR0HNv8ExzEfw+i7r5A8+ltcMFBB45YISBrvQ97Gn5DzCGh8 + CuHtQwjPbgIPL0N68wQklw6g88QuyHdlQFYQB3lWBOTpAZDxabnT/CEUpaN97040nKrG7TgvbBszENnT + JuF5gCewNQGdqR54vWkhGndPhfCaCKxBC7LLmnhbNB7tIeTx105VzNGnGMe/Xke0O3ycvxOB3nGh4kGr + MmdtCOH6EAop+59fCdlbYwiSpXS+aXvMoKCMLifykNL2pAhkN7TQupcy/OaRdP57QL6qP53DIZBrj4Jk + bl90rv4W0oQRkF6bCZl0loI85IIRZMJqIoMVjTffWG/JPeUwgjkf7BZa56Os+MrCmE1tFMs+7sM2lGz8 + 8NgtB4u2ds0bkOnIqWahE7Mpg5JHFSgkBO5OAqqEAPlyBtqOTEFbEvn/9eRnjfmMNV2z1qyYQkQwRWEN + sJgDXQ0S3luwmCyC3lhFpmrVG03rtL0+eWJ9+ly94RAWjqT96PPXzVYMfFGMJLTRgSxWHZ1HxxOAiYwk + BCBhDlVsyqpUwaWdQ/Hm6hCkr/0OS/t+hcB+3+D0jMFo8nNB+8FayA7shnCgDLJ9JZBVZkCSHQNJWiA6 + Yp0hCbOB1Mcc7e6r0OFkhM4NhpBQZu6gLC0lJSLzWgR5sB2pEW88cDLGDtV+KF+pT5l9I4T0cLRXWqL5 + 0lR0NE+C/NlsdFZPo88bSvJeRRz+zKfpWsaHQs8UG/isdUWlo8j+CyA4zIU0hpTDMfq/eb7id0nAMz7t + hymkXqZCLtGA5PUUtFwZg7YSIk+/iWL7ARGqXH80CbNRBP4xaJ87GK3r+qGtktTIW23I5XRuBTqHMl1a + n0WfxYl8ZWdTk+6h+iu28+dk572fdMSfOe1OVgLgX73Y7otl6ODtAK7f3nq4bKMg03oLQUsA5hD4CaAg + EAvk2Qls6KCMLiNwy6lSt5Nnvz8LrXtGoCV2FJodhkK2erxi2K+wQgNyYw4CqrAKW0CVd7EqKQOe9ckO + kC2QzB0OOdkCLOVTW9F7BlShDWj/pZPFUYOKO+AIIDaTIfOhjJ9L4LhM39lMFZzAIWAaZTdSF61jcXnX + QCQZfYLwwV9hj8pgPF2zFJJEP8g3eUNI8YE8wRuyQGt0kM9uXKODlwTK53Scz5ZNxfPFExTxksjq1SL+ + 7EEVvDEci5YV09BopoPX6+binvEM7NUYjTNWOngcswjN25dAOL6WCIb8ej4dY+QMSNbTb1w+UiTA1ZR9 + V9E54EOgl/NRkNzv60BuMYOIZjpawkdAUk5K5s5CSFr1CKBEAqD3OQFwgmvQg/yaIeRlRIARE9DpMAiS + 1ZTtF/P2EzqHcwj4WqMhzBiHpgW98cL1C3TUDgfe0L4CkSORtoDJtM7JhM4jiHxgIOvs1L1x8aaRY2SZ + x8dHDy1iG2oTlAD4Vy4eu5OYF588Ivx6t7xjdupPny84QDWrQ5E9BKq4CgKgrCwjz94+iDIwAVagbKyo + YCRRhblkqymuLYC8QoOy9URIXQiwlhMhN58EYfUUxXMDOAkIhuNoqUZL3kYwDhJOAvNHQraQKvIyAv4y + IoLFPIg0FqmLVmI5jymK0YOCHWW9OKr41eMgvTQF8icEmOekRh7R957Wwt3YmajRUsXhMQNwbwFZFqeV + gCeF63LK7IZoWjWbwD0Bj3XG4oGOGu7MU8UtbRVF//0tAtPtuaNwhzLq3XkjwW+BfjpXFY8XTMYjOt77 + +hNwfqY6bplo4onbdDSETcfroOF45dQTjebD0LpkLORLifCW8wlS5yr684U1RAxENvLV8yE10UHHWk00 + O44i6zANwgmS/i/J6sgWkzQnK9CxmFQAkcljbUjOErGV0jmKGg259TDAcAThl4hlDhHwrBGQzxhG4mcw + nb8haF86GNJQIsEjM4g0eFvBFIV6gJyumUBLYbpCWUBYwAlAkAt6Lx8+WpKZt9+pPxsB5rY7RQmCf3UC + CCmNY67Fmz46eMrarKVJ+64g6MhIj1Olma8AOEhCooMqE2VaQTJEoQYUHlxBAlTpoSmSRMdUyO5rQlI3 + G7IkymRuVCmtqbKbEXiNNURJvJT+XzYdnYYknRdNIv+vjladMejQVYVsEZEDAUlBGDyLGpFyMBwN2Xx6 + bRa9pkXfuZDUw6rhkNmroy1+Ct5uVkFzymg0+A/GGxt1PKbPe6GtilcL1NGyfBY6VpFC4Q8RMZiEJ/PG + 48FsFdybqYK7s9VwY6YaLmuq4MzscTg9ayzO0vLCnHG4qDUW1+aOw92ZfNsJeDRzDB7OGI+b00gpzJ+C + NwbT8IKO/RmphrdG09CyhP8e8trLyTrwqbmXa0O2koC8SgsyUx10mmijjWxFa4AWmspo2xv02xrpvLVO + gfTVZHTemoL2o+TrS8ZAEqMOKScJ496QLRkIgVuj2QR4Ar0wjchg0hAIGv0h0++PznWkvHKIQK8RUXdo + kXogEoUqXR8iWildExm9LicbJaPrKF9M12oZpNBraXxjcHj3EetZs1KKurtXbWLG+b5KIPwrFvt9Ucxi + 3xYWUxPEgmoiv714eXmCpH1Wo0yYT/J/VhewSc6TnxTaCfQtVAHbSGZKR4m2gINeQQBcKWh3NTiROuig + zPVyCFXMfpDW9kbjlu/QGtwbcjs18c5A4zmKuQXlK4kMSGZLDNTRTrJWMo+ymw5VdH5X4fJp4nh42l66 + dCw6CAhSAj+WjiOg0fGYkTe21kDbmgkE9LFoXT4OnZRhZfxmGjsCG9mP5wvH45kegX6+Cq7NG4XLWqMo + iw/DGU3+tKPhOELrh2aPxKFZKrSuguOz1HCCL6ePoBiOY5ojcEJDDZcmDce5qUQU08kekGqQLFRF56Lx + aOdhOB4ddHwti/igqPG0HItmfTU00rG2cwsUqEUWhNRQ1iTIa4gYjiyBrHY+ZAVEkqnk84NUiMwoTOj3 + LyJ1M38YZNqDIJ3bH5I5fdAxuyckWn3RScckmTWMzsNPaLXvgdZtdH7PzICsiSyRnNsHUmE848vomsin + iQpAcX1onfci8PcV10hHKm2d/eDAWV0Hu7rQTzz2BjKb/YnMpzpNCYh/RQIILwlmf4ir6pazx2P849vL + 9gqtuhJ0GAloNyKwLwNaSJo2UgZ5QcB6QpL/MSmCZ9rAK3rtFfnK5yQtn5BaeELbPloI6YPpkNwjb3uT + COICVchDVOnqDMi/GwKhfMIQUgb8tlcLDQiKacQ1um4XpvVlkyHnPQUL+Vz3BJ7VcxQPIxHMNcVtV08T + 58HjDWr87rvlk9FmOBkdK+j/DasAJ/oOVx3AkTLtikmU4Ufi2ixVXJg9GidmjcTBaUOxd9Ig1FHwJx9V + TB2CihkjUaM5CnWU5feRKtinOQZ1k4dg94QBqKFtdk8ehUNqtM+EEdg7ZRj97DHiQzj48a6a3hVkQYzI + 9vDn8i0joBsRsMnSCHwmX2cK32GQB1DGDu6PJvdv8dryUzSvIlJc3BOd83tD0BpMfMuz/BBIpg8lITUI + nRoDyecPgXwe7TufVIAuEZ++KgQLUklb9CGcXg08NCWipev0hs7960V0PYgIXtO1IGshvKbz1kDnpYVe + a1tK9o2sUAdF5wpB3riw9cplw/yYfd4jLEoqu3vVJDLfXelKQPzLNf499GARRAC2RfEf1e62Nn99fsb9 + 1vPDhaZDw9FcPRGNO9XRUKaG5lKS6UXj0ZanivbtM9CeTbI6ezpaKNqyNNGWqYn2jFnoTCMZmkIVLkkf + iCEgRlAEU8UMMqAlEUkwLX2pYroSATgSkWzgcwbMEAcD8fsEzGdBbk6y2WoB5Ar/bg54UbhTZXem/x2o + otvSZ1vxBrXp5K0JXGYkcW2XAz7r6bNpO199xec2LJ2Ek5NH4OAkVdRPHImq8UNRojYYhapDkE+RRZGh + Ogibx9H6+P7InTAQRQTw4snDkD9uAPJUeiNfpQ9yxg5B6Yh+yKZ9i9R7E7ZGQ2LIrQxlVwK94vtJ+sNI + S/HUZCyaLN4ApccHSo0B5pN/J2UjEJAFXcripGRa5/eHVGuo4j4JaPD7Jei9eUMU2b2Tz7I0m4A+l9TS + AiIashswnC5OCc5vE3Yi9RRjgPZ0XTRnzqFroIHG7MlozpuE1vwJaM1TQVvOCDQUky0qG4M35ap4U6mG + N7sm4m2tBt4e1UTn+QXCq3Mrbmzf427mVJ7xJ7+aZOZRs5G5/A+e6Kws/8eK8+54Zrk/WzGq3L06rc/h + 7eu3tkXptMsCZkLqMwtSLwpP8vOe9L8X+VpPCo+5kHvOh9xHBzKvuRTzIPPWpfd40HteJEe9CfDelHE8 + CfB8PYAykh+Rgjctfeh/X/4wTMrUHgRUL9rGg15zIYXgagi532qq3A5Aig+QEUgRBKQHAKkUifRamL34 + LL3187qmI58lTknuuQIIsSKCWUufbwzBXh939CejePwIZI5XxWbVkUgdMRhxQ/shZkg/RFOEDuoD/4G9 + 4DuoF4IGf4+wYT0QOaIXoob3QuSwnrRNT0QN64uA4f0RNaQvgkcMRMqoXnjF2yb4MTvx23SJtPhNPXz2 + X/7YNK5OVvIGT/Lg/DHqS1UVT/PB8nHiawYEbD6rsoGK4n9hsTpldXUiDfrMJVNEUiFLoQg+sQqfb5FP + CLKBzp0r/U5vyuh0juFBFsJTG1IPshEeOpC6z6NrRfbCm66Rz3SKKZB48Ws3AxJvCh8eMyHx1aLlbAik + xFojdTpq0i2KfCtSJtidqvnA/1ijkgD+1QiA30kSmxX+59pwG+dbIUseSD0pQ7tTZfMwEgHsSeueBFTP + RWKl9+CgpvCn8KVtvQ3E/727tvWlbfz5gy9of98VYgQR4AMpAui1APo/wJj+N6XtKFsHUIRYANF2BHpv + ICsMyI8FipKA4mRxWZAA5MUA20JJWbjR59H2rvR9DkQqNgQGR1oPJeBHEAGE0DJgLaT2i3ByrgqSR/ZB + EIE4aNBPCOrzPTz69oYbhVPPH2D3w3ew6fEt1vX4hpbfwJbWN/T8Hg4//Qh7Coce38G+x1dY1/8HbPjx + C9j36oGUMQPRxKfpDqTf6E9qxIfCndsOOkdOC7sGMGmL8/UrJvCcI9oVi/ldsyV32RjF3X+8m1NDnOZb + MRcAf+yatriPHS2d6Le50+f50Gf703n1o9/px88tqR1fWvrQufehbbzp+73oODyXi0t+Lfg+/Fp60DF5 + 8dAXg2/raah4X+Khh8vBBm/zkp0zQio3Dll3KK07JwC3PRuV4PjNg78+mdg+UUEAyaluI+9a6RwW7GfK + 4cUfVrlIlNIcrEFUWQINxQofSJUrgCKIKlgIVa4gqliB+l3/LxPfD+Y+n0t+ilDK1CH0OcFUMYPpswLp + /0ATem0NEEWZPIkAnx4M5BDgS1KAigygcgtQtUVcVm4FqjPF/8uJDArDgS20T4wNHSMdp9tS8SEbPpb0 + ebZAHEW4NVVyU3TYLUT11H4I6P8pHPp8BpefPoX7D3+C1Q/fwqrnj7D+sQetfw9LArn5t1/A4vufKHpj + DYU5ra/+phdWf/kDzL/5DEY/fII1P3wM2+9+QOqoIWjiIOe/2Z8siR/ZkwBz8ffxCDBTKBB4rRABybsg + 3en3uhI5uREBuhBpOdP+TnSuXA1F0uQqyYvWvY3EfXxpGWwknlN+nkNp+zAiEH8iTV8iP1/6Pn9j8dqE + 0f4hXeTqQ9/lbSyem+DVIklwQvbrCl9O2vSZvvQdAVyBrUCH/TThqNOCqxH5IYYO+1L+6FiTwNzqlQTw + L0EATnVJbMW5nPe3b7Q1ajCd/Fogbwk/qsB+HPBUaYOpwoVywBqLoVg3EStXsIkI7lDaPnSNmIHD11HQ + ejjtF0HvRRDgw6lShtAylPYPo9eiCawbnSibk7Qv2AiUEeh37QDqC4A9hUBdHlCT80vU5tJyh0gIO9OI + BEgRZBIRbPIjS0BkkOALJNN6kgcRAKmIEFNFBux0nIez2gOxe8YgVGmOwC6NQTiorYrTC0bgyuLRuLV0 + LB4YjcPjlePxaMU43DTWwDXy2OcN1XF0/nDsm9MXdZp9sVNjDEpmjsTeheo4rjcXV5doQcrPD//dXIkE + rafvpAij3x9mLgZ/T0F8tAym3xtO65FECGG0HkjnKID2C6XjDOGfYdpFHgTWUAJn2ArxfIZYisoo2Fy8 + DkGrxXYUTjwKQuUqihM0J91lv+zPicOfKy+6PgGccOn8BywXCYIrB7+VYjtMGCmHQCMItup4vEatOXmH + W4DDvtTvbHbFMXc+U/EBZY/Ab7asOpTOnEjm2dYlsnX7Uj6rcV8Z1WExVaKQiEG8UnKpbtJFAGZdgDft + qphm4ja8coet6QpLCJHr0BHviOYEF7yJc0FbghvkkQSMcAJGMCcFyoBxG4A0LyA7gqQ9ZfTyzQT+bQRy + AvheIoB9ReKSE8Feij20Xp8P7Kb3a7bTMou2J0VQlibun58I5HJrEEIk4CHaCC6R3edA8FsAIWglZOHr + IQm2hizEGgJvIwghQAXRb/MjkLhS9iSigCuBwWupmBn9V0Hgwbch8PGRgxICoowAJ/hbQaDzIN2ih6ac + yWjJmYjW7Alo3T4eLRlqaEhRw8skFbxKUMHreFrGUESroXnjdMhz6LOrXeg30m/fH01By72RpG4C6HeQ + Gsqgc5RA4IzmpEkR1kWaQcYi+Okcy2Is0ZFog7cJtngTvwFt8fb0Gv3mMAuREMJWisGJgasTxW8wEd8L + 6lJfXDlwRRe6RCQfVx00mk6RZQRb5TnuTx3peWjze+4EfiUB/IbLyoNpzJUUwMasQOa1K2HoeSuDvTLr + GRDI88tJjgr+CyF4c99pJGaqMDMxs0eYQx60HFLP+ZB66VIm1IM0eBFk8ash2+6Azro4tJ8uQsu5OnQe + rISwmTJ1uCOFA4GfvHsGATWP/HwJAb+CgFxDWb2OCKCewL0nmwCRJ8Y+Av+BIjH2cyIgFbCHv05kUMfJ + gKxBJX1G6SZSBASk7aQCYul7/M0g8AayBH0ISXTsESvE4+fkxTNyGFcmlFlDiQQCCQguvLdAi6Q599m8 + YXKpKJH9l4tZVNGOQa8FUNYN1BPXowwhr9FF+63J6Hg4Dh1PVdH5WB0d9zTQdmsumq9ro/naXLRcoeUF + +v/8PHRcpEx7ZR1kdx3R9MQXjU/D0fYoBo03Q/H2jBudK7I01RYQti5FZ4IBgZr8f4wW5BFz0RmkBVkY + ZexkOvdFgZAc2YzWKwVovlqE9hOZkFZEQ57iBGmkCaQhiyEN0oPEfz5kQUSA9BriOLFYihGzVryWQSvE + 8xFA7/muRKe5DkptV5/03Jsy1/lIxkeulCDcDii7BH+zZdmRdOa9O4GpNtS+n5/kuvjVmqkPBSdDSCPW + oT1YG51hkyBN1IOwwxRCrQ+Ey6mQ30uB/IIb2vYa4lXpMDzPG4hnhQPxsmYwXh8bgYZLqgR8ynQHdQjc + BK7tlG3jKaIp62/0AbZy8MeKmZv7/Z3pVOm3iCSwmwBdu00MBRlwRUCxn0B/oEBUBRz4dbTdbgJ+Ne1f + niI2EuaEkQKwEzO7vT6koZqQH5pNNsFItCyKMBUzIVczCjIzE2U5995OBDY3AnfQShEYQV3tFVw2czLg + r3Gy4JmTEwOX2VX0WQ1zIZNMhhxqgFwDEPhdewu6gpQFv/FGMbZfvMEH0ukQOqZA1joB8qZxEBrGQtY4 + gf6fRq8T+XbQNnw4dQvt30zH1Ewqpnk2xQzafhJkTbT9s8mQPpkG6fNZ6Hw6Ey13xqPp+hi0HJtM12EE + nlcMx9PioXicOxCvikagczf9ppNkt64GQjjjDVmVBaRbKfuHL1H8LjmpAFnMEsjtdfF4lcHjtLwwq8XX + t//J6lQK23B4sxIov9XifXgHc90VxIzvFP4p32el3+3VY1raknUgP0rS9yxlmzNUaS9S5b06G/Ib8yB9 + qA/JU10Iz6hSvzGGvJlA0UyVq3m5GA0kL59SnKIMU0LAS6X3k8jrbnQH0gOBLMrSOSR78+PI95NsL9oo + kkBJahcZkKSv2CxagootXbbgHRFki+Cv5WqBW4YM2p72K6TPyebgp+yf4KToBmz3U4ekaipwgkCUbCRK + 39DVIuh52wDP/OEkl6PoOCPNxe5IZyIs1y4C4MAP6Wqz4A2gCgJYKUpn3lvB5Tj32Nsp7hE4iQBkiiG3 + ExQkIChuuJkngl5BBDqK0XfiKDw+Mm+yLqb8CAAAgABJREFUuG37WAK7iriUTuwaqTera9+FXTftzPvV + /tMVN/agg7ZrpfU2PuyXSKKdonMB5O10Xdrot7TRcbfQMTbRsTeQWnm+FMKTxZA8JFVxVx+yq7qQnJ+N + zhPjIRymzz1M37VnETpjNHHHfGJrWpxtvPWFzB+z9jYzj4PblED5rRb3Q5mKvn/nY2l9Sjz0C+7YjxEk + tfzuM62uSrdAMQkFMJoq7QjIOwdQ9AckVGE7+J1q/I41qkyd8yG8IGK4oA1pzSwIGQSUTZT1Uwj4GaEE + TvLnOwj0OyJFr84JID9etAF5BOC8JHHJGwOLU7uClMFOyvS7touKgKsDDvpd9F4NRWWGuB3/vK1+9H0k + /YOcFfZFUjgV8ruUUffMg8C9NM/8imxv/ktjJffLioZKM9HiuC0UW+a53A/k2X+lGPx/7yVdDW2rxW7L + YLFHQ4hbDNlRDkQiABkBs5NIQKYpTtqhOH+6Xdn/HZDn/DykGjIiqE5OAuPpXNJ+EnXxhh3F+9pdxKHb + RSLzu/afJd7cI50i3o/RTkTQyecHoM+V82uhqfgOgZMFv2+Df46cVIWElAYRjlQ6CfIO/p2kWOh4OzCI + 9uFzDBBxvF5C124mrjsOFjYHLK91PZyq7nn2YHf3Q9uY/cmtSrD8Fov9vjTe/dctKstrwgHPmWde7Rgs + Du0VFlLF4JKVKpTA7/hTg7xtDMlSVap4Y6jyjFDcbCKVaJP/XQTpIQJW7nrK8iTzM1woPGmdQJlGcj+D + sn5WFGV+Amp2lAhY3pefSzYgmxMDKYLtFFkUOUQKBUQGheTpC0gRFHESIKBX0LKCyKGcSKKM9xjw92jb + HCKUzGD6HvquGEdFg5dsywxIr5PMfkgAKSIQRZop2iwQwdsuLMSI5D0Vll29FmaiLfCmLO/G+9ONuhrO + jMXWcz5+wbOrz503likaPk3F90PpvSI+BJq+T0IE0M6BNh0yBRDnd4Ff7xcLoAD2LFEJcLvA51ToGC8G + JwA+dl9x///cX6mHX++vpZgYRJCpQy4dS99FGZwTjzCta8KQqV37z+mK6Yq5G2SykZASgUvlIyGRDINc + Mly8o1OxvXbXtlqQvZyOe5m9UO4y51ZwSejydZdqfr/mRqqSAH6LxY/kv29NAvs90H1ruPHiM/7qTxvP + qlFFnqsAv6DIOPymEqokElIAbRTNlKmaKcO91oP8jiEkh83QXmkKaREBv5jAXkQZvTAZAm+Q47J8O0UW + KYCsQDE4YHOIBLIjRTWQRbGNtt3KVQLfPqKLJGLFQT/cIhQTGZRwq0DgLyHQFyaIyiE3UvzMDG+S+a5A + nBnk6ZTZTpM6eU7Z/zhl4DTeAGj2K/Cv/SU4AShUgLloDfjYBE4CHPABXS3lfKCSL5GBl5FoA3gbgAL8 + 77rjaLs0IofLBKLWcQopzzOtXHHfvXaXCpj/q0z+KwLgoJV2qQZuAXh0ju+6hXfWr0hA968UBL/teoLi + NmwIXDVM+ivga/3yvYpbuImM+A1cElUKNUWA1iEdKyoH2QLFZwsgKyPVwst9I3DAcXxjQoqDz/oLFV9b + Xd7G7E4pbcBvkgAq7Kcxu7NVvy8JWhxwO1ats/0FSUTFrD86P0tIKZ+QooMqTBNVuGfTIb9Krx1eDnmt + PYQyyuC7SYbvJ3m+n6R6Hfn0KvLpVZTFyzgZcCCHE2AJqNn+XWTQRQyZoWKDYAZl8C1B9D+tbw0WM/oO + vg8RQX6M2GCosAz8s2JF4uCEwfdJJ6WRag9sJEDnG0O4qA3hDSmVZ6RaihZ3Af9ddAGfd1fyNoBQC7Fr + khNDWFcX57uM779KXPfv+p8PzPHpUgHvukIDV4vv8zEOe8k+vCVgtdN3S1UgyN/dFan1V0Sg3fX6TBG0 + sgmineLgbxsrWoGfCeDX+73bV0sENAe+nE/GQoCWi3diCtwaKO7158B/pxr4PA6zxM/kCqVzovg97Woi + +Ui1FQQg0OfLhBmKyUfabkzBeY+Rsq1RZpkbzhT3WXs1lzkQATieV6qA3470P7ud+R3awUzQwEJyI3vu + cZxW9SRvFGTN71quecXRUnjZDqhD1j4Rwj0CwAHy9FUJEA7kQXq+CtIbByFc3QvQOk6VAMdygEPcs2eK + Hr2MyKGcsvdO3uUX05W1CbyZBN4MIoRUHyDFi4BM65sDupYUW7sUQ1aASAiZRBhbKDZz0qB90vhgH9ou + ho4njYBfTZX+NlX+t5QNG8nG3B5Jr1MGD3ISxx0oMv5aseEvvGs90prC6hdbwEmAtxUErBSDt/Qrhiuv + FEfkKdoGjMVtOIFwK8AJgA/QyaF4Oo2k9TDKsGNEsHHlpJDlc7qy+bxfEYCm2ODHp1aTqnWpgHFdMyxN + /pUC0P5VzO16nXt2PiXbOHE/RcMjVwGTFbMiiZ/PVRyPWaLHF7rIhm/fyb9PRUFUcsU8DtPEmYc4ufB2 + hJfauJE4CKU+C444H86c5HZqxwf+e7KVBPBbKo5nM9n6k9vYGOFmt9RtHlOPOw+/9WLPCMoOWl3ZQ1fM + HDJSA63akN9cC8lxL4p0yK/XQ/7sHOQN14BXZ4HHp4BbJ4BL+4FzlUQEvO8+XxzUU71N7Kuv4UN7U0UJ + n8d9e6A4EIhL93gCaawzhQuQSIDeSFk9hQCe6kaE4C6SBB/tt9FXHDKs2MeBQGtD65SFaxdBeDQPMt5G + 0UzZ8A1V8NOUYVNs6TP5tvZi8MFHPOK7ItFJfD3WRoy4roiyFoOTg2J9nThmgJNIFL0WQ/9Hr6f313XZ + CNpmMx3PdR0iyuGQ8ywuVf+VL5/1K1n+rjV/dpeUJ7DLxorAb6P92rg8n9TV8PprAtD5lVefIU7DxrN5 + O30Pb9Tj/ytsh8bP6kFQ3PM/u2umJt5QSCTQoS4SDbcqdJwC741QHKPWL20OLdp4UD4cte6TH0eXhhlb + nd/x8aoTm5nb2SwlcH4rZcMZUgCntjP7a6W/z0xca3M5cEhT02XeEMVb9ueKE0jyCthOZPCEMuz5RAjX + qyG8ugSh8xFVnKe03XOqhLeB5pvAy+vAg3PAzQPAlV0QzhARHCFFsJ/33fPBO1kiEVSQny/ivQGUyTdz + YHPvzgcIESCDCVBBBKZQWvKRgzHrRaDy96Mp+J2B0baKG32EcFPIEpZCXr0cwpPlkMlmklUZAHkb/YYX + BIL6pSKJpHGL4C6uv4vUruAEpHjfU/w/xU08no1dkewikg1fTyKCSnISI7lrPYGW8fy4iERS6DNOGim+ + X+At9IqGOY2uTP8um78bG/CuRX92VzafIDYAtk8QwfkzAfzaAiz4SwvxrgGxnXcJ0vbSaYrWfvH7tH7V + dvCONDiZ0z6d6j/bDaGdjlXOrcP0rm7LrkbLzjl4dmI0DrgNb0vdaBtqfTn3yzWXMpj7CVIBV4qV4Pm/ + Xrwu5DPHCzksad8m5nc257syj3lbbqYNkMlezFA0+EkxSSEbZXLK/A1U0R/mQnh9hirOcwiyTvKKUqow + fF79RsW8+oL8NVXAO1SpLpIiIDXw5CiEu3sVRIAzZcBRUgT7eR8+2YLdpATKN4lePos8/2bK6EkEsEgC + eggB34/8uQ8faGPSdbOQ2S/ddVGU7aOWKW54kccvRMeBeZA26EJGlVtGmUyg7CZroyWfkKSSAL01EkIO + KYcdZCG2h3a1P/w6wroinLaJENsd+Ot8ODGPrUFd9oO3UZBi2RIg2pbNfqJN4bcmbw4UFUoGre+jc/WG + QCeZ1pWRNX+W4yIYF1Es7lrq/9Kqz+fpk00TQayYZXmqOO2agiT0urZ/F7/29dPFbXnIpnd9n3bXNvx7 + lvxqn2liwyFv+ZeMUvTkCBSdGAIJxihmHBYU+4qDlZruqeJcaD9hp4dhmcul/AEhhw918z2RrySA30Lx + PJ/HNlzOU3T/Je5MVNtjM/3o04KhkLfMIOAvIBIwoOxAGfZtJMU+koQPqNK8oYrRAbkgo0wroW0kVAE7 + qdJ0UqXpoPda6P8G8r/PIW9/AOEtkcHTk8Cdg8C1OtEaHCsma5AjDvmtTCM7wFvzCXjbCETJlH3juKxf + 13WfQddNRvw+AwUJrIIsehGkGxegI08PspOGBDaS/vJZinkIBQ6Adj6SjiT0PSKM6thfeg6KN3at8+Cj + D/ntxV23GPMbini3Y0FyV/fjr4IPVOJLPmKRDzbi4xZ47wQfyMR7KrL5kv7fTpYmm0iilkjgIR0z75rj + syQLc37Vks8BT+SFFV2xtAucXaMDOeAV8/13EcHPBGDQBeR3YaAAtMKvc8BzJcCn/BKmi1Jfkf11u7Z7 + RzYLFUSkyPS8LUDRIDhNMWejXDIFcvpeQTHp68KuzyZCfaGOWykjUWs153zwwW0zNJ8ffH/1xTLmevGg + EkD/5xsAb9cxl2OZbDEu/C4tzn3FMcfxjxoOjiDw8kpClVNqDaExBMIbAm4HAV8uo8pBoJdLiQAoSCMQ + 4iibyGh7IgLF/3LxNSIDAU0Ki4D2+yQSbkB4eRHyR6cgv30Y8sv1ZA+qIBzJh7B3O9mCzcBOfiMPZeIM + PpiHpHQiyerYNZDFGEHCZX4GKYJCPhTZDMJZG/L7dhDazOn7Fne1pk8XJ7xs1yLiIhK47Qnpvi2Q1WVB + vns75LU7aN8diqW8tuu13dvEdf7abooaWq+m16u2Ql65VbGU0VJWlQnZrm2QVWd2vZcB+c50yMvSIC9N + oaBlcSqkpXGQ18eR8tlAgCKQCdq/DMRRyPfFXcAngoBx1/qyLnDOF7fnoJfNUAwVhnx2l/wnooPRr2KJ + 4jVB8d5scdgxVxA/W415Xd+36OdtRTKY/3ObgMJeSCk6aN9OPh5BHPcBYZFiW8Vcgc0aeFI2CvvXTXkW + VxC1zvhx9ScmV7cx5wu7lAD6v15crlWwhBQPtu5p7eeFLmaRZ/37tL26+SNVBKoAMnNSAmEkrQmonZT5 + 0dwF8l+H7P8R7ywCqQKhkXjhFWQdTyBruQ/Z65uQP+eEcAjCHbIJl4lkTuSTfOb3+ZMqyEtRDBcW8pzQ + udscbWdXQfrYgoBNWV1uLoZgSp+9sgsQXRWcV2DpYjp2cwjPtqHjdiU6bxyB9NoeyK7vg/zaQciuHfgl + rtP/N3gcUgTvzfg5rvM4IMa1/ZBQ8KXsKi2v7IP00l5IL+yB9Hw9RS2k/Ian87shvboT8hfRkPJRdRzQ + Pw/hXdiV8TnwSdlgVdf6qi4SMBS34U//ITAKMj7z8ryuTG70q23fLVd2gVpH0VMjdv1p/cpmcOAv79pu + edd3G4iNu/xzObkoiEaDvuvd2IF3dkNfsb0gW4Bn537ECY8x7dti7FJtb+X1NmgQmPPFGiWA/q8Xh+sl + iuG/SVWZAyoc9aqvxA8UOh73p4phS/hOIDVfQhn2Jv3fTJWh8y+A/f8G/7vosgZo6yKCJgUZQPaSvuM5 + Zeu39PIj4PU14O55yC/sheRcIaSXt6LzZho6n2yC/C2RQlMWiY+tkMhT0Ckkkf1IJhVCIaeMK4+hiCK1 + QTZCHk7rfvQeyfL24/QbbtNXvoK86RGRwn36KWLIfhXyxq5oevCX0Xj/L+Pn9+7/Eo33uuIOZA136bWH + EBroO1uJCARST3IfUkoBipAJQXRGiFQRTctYOkYKeTwtSTEI/Pjp2IVg2i5ADLm/IuQIpNcjaD1GEXJB + DJmcSIa2lwr89/oqQqaIAPqsUPps/nlRinMhk5ONk4fR99L78KJwp+1caBtnCie6Ns4UrkTYbvR9nrT0 + oXCna7UMLTdVcCZkNHI8DQ64H05W45bR8Uo1c7qqJIH/u/7/+m7mcG2nwv+nJ3tr7neYefNpkQrJdD5A + hCpQZxVh9wIBtUEh+8Eb/ATZfwH47+KdWnhHBO0iGRARCEIzVT4ZRStxyguyCXeAJ/uA5zuAVvLpneS1 + JTEUZA2km2gf8uFCvBhyWpclUBDQpeS9JQR+STjtQ9HhSyAkG3E+E+17tqO1PAeNJal4XbwJb4pS8KYw + Ba95FGzCK4o3eRvxNncj3vw78Za/l7cJb/M3oSE/RRFvC1N/FSmKeFOQhLcF8WipyEBnzXZ0nk6EpMGH + fm4AHY9/VwTR8YWJv0lKIYuiJT9+vuTHH0zbBNI+geJ+74LvJwkTt/l1KH5vsPjZ7fR727uW/DM6+T6h + XdvS+ZHStpIQep2/z4+LLFabBwWBvN2NXudB6xJ6XUrvS2k7Kb3faQTp3Ym4nqKCcudZ94IrQhfq4dYH + E89vUBLA/3UCiL92kC3Dzd/tCLeyv2Cn0vy6fhAktzUhe5ZGmfESVYZGhb9XeH/8DUKQdpEBtwYyRRtC + hyJ4G0IrqY0zaH8cSTywEk23J6L15hi03ZiM1nsaaHoyAU3PJqL5OY9paH0+B21PZqHt4VR6fxJa7qij + +dY4NN8ch9aramg5NBoNYRp4ZqGClwaqeLmgP57PH44X81QoxuCFjsrP8Wy+Cp7qUtDyyfwxYuiM7grx + /6eKELd9yffX7oq5o/FMezSeaw/B67k98cpgMJ6tVMHjwDF4fmAUms5NRMtFVTRfGoOWy2PRdn3y/9fe + f0DJUV5bw3D52jcYG1CaHHu6p3vyKAsFJJHBBkyywdkmCokMBhsTjBMGRFKOI03OOeeck2aUJbIxBmOT + jQGBzrf3eap7ZgT3/e+3/n+tV9y/a62zqrq7qkN17X32Cc9T8q/nL5B/vXy2/OvPS+TDV/A7X16C38Dv + nyLvH0iV97n/+Fx5f2wOjp0n/zxwhvzzOfymF+cZe2mBMW4fXiTv4b3fG8ex4zh2fDaOx7GH4+SD55Ox + z0IYzssL8+WfsA+PLNP3e29strw7mijvDsfLOyP47mMJ8ta+VHn38Bn4Hmfi/J8p7z5/Fv6LFfL+/hR5 + OT9Buu9e+MFT2b+874a3e0/7XctB696DDX4gfVmXXx5ptO4pSbce7C8PqnvwW1nP/S7s+Fsd83GR3ifH + 3miAAviL7fkBTgXuxyeEAf9T0E+yL8gRfAZFwDzBZ58clLdfWSvP9V4i+5rj5WBzoBxtDpEjTWFypC1K + jnY55flOh7zY4YLFy4uds7FOlRdaE+S5pjg52uiRow1xcqQeVo3HmfFy+Lr5MnZRnOxbniL7VsTJ2Fnx + sETZc1aCjK6Ml1E8N7LCg+042YPHNH0ej81rbhlZ7jb7rDDPeV8zr8fJEF4bWkmLl+Ezk2V4ZaKMYHv8 + WrccSnfIkdJoGa8+TfZWflP2VZ0uB+pC5FBLjBxt88iL7XHyYkucPN9Ew/etiZS9FTNkrOJ0GSs/VW1v + 5Qw5UBMqRxpwDhqj1Z5rilE72uiQ/XVhMlp5qoyWfk32lP6HsbJT5EDlTDlcG4Zz4sKxsTgv3N8ph/FZ + +2sc2C9Ihgqmy1D+dBkpCJCR/JmypygIx8XIoToPzIX3jpH9TZE418HyepVD+h+I+yznqRt2/eZITdjG + /busO15o9wPpy7j8+I1aa82LtZZHXvjKMxVbFjbdNn/01a1R8m7fVfLpS5DfH8D7H39HS3zHtdb/iZ3M + +/j/N0pAbFJRgsH7fvxneful7fJ898VyuD4BFx8uwvoogMUh++ojZH9zlBxudclzbS4A3i3Pt8bL0dZE + EEOSHG6JlwMNblysbtlX65F9NbCqBNm3O1n2/XiBDF+YBGDOloEVKTK4MglATTLrs5Jl6GxjBO3wCtvw + mteGViRMskQ9dgj7DuIxrX9lgvQB7L1qydJ35iLpW5EqA8vxGT+OlZG0CIAqUvaUhwCUQbBAGasMk70A + 5QEA/xDsIIjrQL1bDtaDNCodMlwcKENFM2WwaAbWs2SkJBjHR+J3OQwg651yEIA+gDW3x6pjZKhklgwW + ni7DOG6g4HTpzz9NRoqm4f3CcVys7K3FuakBoGtjcY7csqfCgf0CpS9nlvRnB8lAdoj0Yd2fGywjpQ4Z + q3LjfV2yB99nT3WkHG4OkL81x8iep+Ol8oEr+9Z3ZixaKq985Y4/t1jXvdbmB9SXbVn1Tot188s11pWf + Df771h2P/Lh3dfzf/lYSLx+N/1aOv96HGPEVU8/XUt7H8NJcf/T/Mvn33ycMjfwn+EEo/3pf3n+5Ql7u + vkJeqouUv1QHyiu46J6rToDXmid7AZDxZlyEbW4lANqRdqccaHfIgY4Y2dceLXuaw2W0MUJGGwC2eoeM + 1gF8GfDoP5orgxcDmGfNke7z5svgWakG+ArkZLNNW4HHy5OmrIe/0EgW9vFngVBwbD8IoY8G4PcsnS+d + y0EGUBjdP3dJB4FVESXjpQBUCcAKcI1XAPz1iXIABLa3zYnfhuebALpGlwzXRslwWZSMFMbIcAG2C6Jl + tAjAK46VPSCAMXh97us9ZhyP99YkyEixQ/cfLXDIYF64Arm36L9kqAqAro+WYZ4TKIA9JBAQxl4STVGA + DOTMkMGsQCWBrvxg6SkMlYGKaBkBUYzUu2S0xikjFbFysC5CXm2LkEPZqdJ55/mvbyt+6mc3fDD0n/e+ + 0uQngC/j8r1/NFiPj2VYt7xVPzPvkZ+vHXso9aP3G38inx4pk+Ps6f/odTvz/57J3HvBf9wL6P9pGfDT + E8qGxhj7H+Nrn30gH7/VKS/0/1wON6TK0doU2dOQJOMN8fD8KQDKXBikMQDzYuMiealpgbzYPFeeb0mR + I61JUAHJkLfxcqgGHrQqVvZXuuVABTxcDS78zFA58P0UGb3II3vOjJNhePqRlXNl5Kx5uh5aPhuWClBD + HZw1V/o/Z3OUONRW0lLh5VN1PbRiDogA7wHrx/G0PiiEvrMAzMuhDs6Kkf5rIqVvJ7x4SYCMl4XLHnjy + sdIQgA+Kpi4aXjwe3z1FDtfhN9TSZsvBSvx2kMRocYgMF0IJQJoPFwbBmwfjt0HGY9/DNYmQ9knYH7+/ + LgXgRHhSFgZAh0DOh8lAXrAMFYbIaH6E7C3x4LgEOVCVJIeqU2DJsrcqSo1Koy9nmgxkBcgQiGo4J0RG + 8sJkrDgSx0B5VUXju4KIKvA96+IRfrnlRbxH373zPsp9+o5nfvN6W2DOSIF1/RutfkB92ZZ7/1Jlbv4x + kpla/evv1f9547ePH+v5g8gL7SJvggA+fBXYZcffPwDYd+wS3jE7iefNBXzyP1QExyaZIQCGFJ/C+x// + 6CV54/AjcrBjIUAOOV+3CJ4nFQaPBy++FxfefqwPNTBGBvCb58hRBT9IodUjRyChD8NTHcAFfaAySvbD + ex2AvN1XGSjjO8Lk8JVzZfSCJBk5E3L9bHp9AP7sOfDeAP3yZJXqfG7wc5aiIUM/Xv9CgxIYoFH2w/iY + SmDwXI8c/sFC2Xv+HBm8yikDm4PgwQH60mDZB5Duhe2riJADtQ451BgHAgCQGxLkKEjuKH7/oSoQXxk8 + fXEYQocQ20L18T78tsM4H4dr4xSQR+qokABueOs9ZaFQAMEyDNAPgwSGC0IB5lAZL4FKAikerEG4AUV1 + qDoRwPbIXnj1UYQmgzlhMpQVKcNqIIWcKNlTAIVQ5pK95S4ZK6cCiNPjDrUlyMuNbhn5Q5KU/OYHjZv2 + laTwGrr3NX9D0Jdu+c2RQutC+fvXdhQ/8d22ey46+lbWz0T2FIIA+kX+0i/H3z4CaQ4S+Pg1eOm/wd41 + sfrxj2w18NEkEvh/Gw7YSuCz9+T916rkcM8SOdg+Sw43zsPFuUDGIGlHqyHnq0MRf8KL1eEiRvx5qMUj + BwH6/QgFDrQ55GAb8wIx8KSRkMGBsq86GDFvELxWsBwqC5aDGxAqfPsMGYb0H1g5WzrOA2DPSda7/w6A + DPpWxEnfcg+AGw8VEC8jy6faMI3KgbY8zjyPuJ/79p0FOzvBtx44G+Dne2K/3vM82H+BDF6Kz1qH8KQg + XPYWB8j+MnzPknC1g4ivDzW55VAzyA2/7WBjFAgB6zrE9eUO7B8t44URMlYYDsMa78H8wQHmRRocagcb + Ysw2ZPoY3nMkD2SRjzAANpQbIgP50xDPB8reaqM4NIeAzz1QORvfJRnvi9+U7YFScstQOsgqwyn9WS6o + iHgoFSgF7DdekSx7oDzGyxAGNM+WPyPc2rfZLTX3XHgorWnLt8NE/u2hP1f6AfVlW9Latlm3ysipxX+8 + 67d77l7x3keFj8hn49Xy2eEOkMAQME8S2C/yPojgoxeAXRDB8TcB3De1I1B8CcFj/7MqwJSKwGca+x97 + p1deHbpWjjYlypHGBNnfGAvwB+GiC5KxCoAZ3me8DAoAHutwA4EC4Le4TfKsGYoAquAovOf+WreMVzk0 + rh2viDbrynAZ2hwj4yCAofPnyfBZkOfnxED+J2rMPwi5PrAcwAWoBwhoJvO4D4Dcf06SWh+s15fgS1DT + fWD9ZyUZw3P9TAjC+zNvMLJ8jvSSYJYvkq6LQQZbA2Ww5HQZhQLYU4bYuiRCRhDjjzMZh+9/oCERvxu/ + CSrmEFTPwXoPfgO8czG+K0hgpChKbRjeehhhxD7I/X11cZrs3F8fB4sHQcbJKM7VIIhiIC8KwI+UHoQB + A/lQBcURsqcK56EW57LKCenvlr218OzVThkuDZf+/ABNBPZmzQT4Z0lf1jQZLMD5x3fci3328RiELKMV + Lnm+dr683DVTDudESMudK/++M+ORu34oR//rD4dy/YD6Mi2/+HuH1ffb66zHDpZG1N/308LXHr760+O1 + G+SzwVL5bKxB5HC3fPbnTvnsr8Mif98n8u4hOf7P54HdVyHdXwWM34R8f88oAg0N/jUpNPjoBPvYDBY6 + zlIfo37K/w9wyHPyj0O/h1dfAc8PWduYqJ5+DF5/vAJxaDm8HiUoPM/eClYEIGObcdHDax5oRszfBAnM + 45grqHEB8NFqeyuMjUEFDK8HUC6eL4MXzpFRJuvOikVsnqAVgAGAdgAkMGhXBDSJ5wX32SSAZDU+ngx+ + BT1fX0mj9Gc4gOdJJmeSVFKkB+HA4FlzpedbOGZduAyUnqqAGiuPBhGEA6z4jiAAAvgACOwAQoEDCn78 + tjoAFB53pCTamJKATQSlAGWNR0G/j8fSEArsg41VukAAYdIHz9+fGyr9iOUHEQrweL62twZeHN5/rMqp + 4N9b45ZRKJL+vJnSlw3LClAC6M+eIYN5gTJaEil7cB7VyqEuQACHa+PlxY5AeR4E2/fIvE8Kn71l96Mv + VAUV5D1grX6z3w+sL8uy5q1ejf/XVj+7uO/Oq4c/5v3z6raIdOaK9FeKgASOc9Te890ifwYJvLFX5K2D + IIGj8tEnR+XDz14CAbxlkoTH3wbA39bQ4LiOFXjPThy+50sgfnb8Qy0pfgYy+IhE8Nlf5OO/lMjL3ecC + ALPhzRH7A9D76ZlwwY1XOHHR0WJgUZqMOkhv2eSBxYEI4pUEDtpEYLLa8KqIrfeWGxstO01Gn0iW/d+e + Lf0XJsuoxujw1iCAAfXcicaw7X088bx3HwCY6kDLfeZ1Y4z9U2Cpahr/Mx+wPFl6NbSYC/MgFAC5rIXC + KD0NBAByK8X3KmIpEJ4c35ne/hBI7BDUzyGAmY+VAKpijVJA3D9K718QKaOFAGKpQz04CWA/z0ddLOQ/ + HoMU6N0HC4MB6EAZAAkM5cK75wTJcGEkzgv3iVfVMFYDNQBFtb8mUeP7ofxgGcxBuJAVIj2ZM6Q/c5YM + ZodAgYAomEwF8PeAiIfw/cdrw+S51gh5ESQ8/JRLKh+8sm9T+67k/fNPsX758V4/sL4sy13/6LJulL/8 + +66dv7l23+or3/iU4/BrtpihuZywg3fd6SwUaESRA7UICbpEXhkV+StI4J0X5fi7f4GChwr49A0z0u8Y + Hh//G7bfAClwngDbNHfwN31OSBjH/m6Oe3dE/jp+P8B7hhxsIgEgBIBRcnoJgBenMYcC/GDDJPA3GTI4 + 1ALgNCEEqAYwKiKxL9RDeRgIAB6r9Bsy8liC7P12qvRdmKw1fQP4xKkEsNKu5dsg55qg53O9yz8Pft9x + TBAC9H3Lk4ytSNKkoBLAyrnSCwLoPgf7/SlW+otPVQLYA1APF86CCsB3rIpRj68EABVzUPsAPGr7qt1K + AMNFoTICACsBFOH4MoLXDY8PkqgzNf0DVASwvdWxMoxjBvJDbAIIkwEQwEBeiCqp/TUJ6vXHYfuqcQ5B + ACxHDkM1kAAGs0MRBiAEyJgBMggE+SBkqPQg/jdkPFQaI6NVYfifwuXVtiQZ2xEvtfeseG1H2ROXLxT5 + t9V/7bd+/WqfH1wn+3LTB/3Ww39tsh55ren0xsfuevKvd33/Y52Io+hZkfJNImWbRYo3mAk8OTS3eZdI + D8kARHAIRPAyFMFrIIM3xiEAjor88wXY8/LZv47ooBtu6+CbD54z9s/nECVgvw9fhiDA63/fKx88ly6H + 2i+C9J0DS4KcdWlG3BBAzBcSAKsAE+A320YBJGhia9yWqiy30UZLpsnoo0ky/i146QtTlAAGbPnuBbIX + 7F6beG5CAUwQxQRZUPJ7ge/1/rp9ZpJ0LY/D8XNUAXSfg/f6g0v6C78J7x2tBDBSxPgaKqXKZRRAg9fz + s9JhCICAHi1lmQ4SHrH/UH6E2khxpMp5NvLsQ8iwv84mgFoSACV9NOL3UIA+VAlgKC9Mt8fKEMtXx9ny + H+FAVZyaKgDszx4AEgCJoz8ToUBmIIiB5xNKpMJhCKDMNAUdboyWl1vj5HBhkrTeO+ejrK13PLTqo/FT + vvVBnZ8AvgzL7cf2WE/sy7eeGM6KHb7n5w3HHr7e3LCDs+pmPor1b0U2/0pkw91mYo6MP4qUghyqt8jH + NdvkjaK18mLRQ/LX+qfk0yMNIq+PyfG/jYm82Q9SGBH526ja8b+NwPmPyPE3+dygySe8OiCfHa6Qv/Xd + Jfua2L2XpFJ2f4Mp87FjbQ8IYA/i5T1l5sIjIRxAjH8YQD/YnOADP72/kgGPh/fbW2mrB4QMBNhoSaCM + /SFFxkAAgxcYApiI3z8P/skEoOW8s5OneP3JykDjfwX+CWHAcpsAVs7VCkP32QnS80iM9OWfAvCGKwGM + FgeDDEBSlfhddR4f+Cn9jRKYIICREhAZYngqgKH8cBkqDMU5cWgi0IQAZt8DtXHa/ciQiQQwaBMA1+wJ + GNXQwaM5gHGcKyoAJQAqgKIwhArBMgAC6MsOlD6EAP2ZIIR8qA6AXgmgggoAZID/g52ZL7XGylEc33O/ + 83jxn35UdPerDRHnvP6M9dDrg36AnezLT97r0eG/2eVrL3xr9fdf1Fl2nrrNzK/HiS3/dLM9/fXVIg/f + IPLo7XLsqdXy/qNXy2v3r5Qj9yRK9zrEhlvOlH8UgzhGGuT4eJsAhQgX6kUONkIpwA7DjjSJHG3G8yCK + /VAQ45Xyr/7fy8vNiwHiCMh/A+JDBDY82l62nuICZ3KK3kxzALgAmRs42Ejgs3U20fb+Cfp4PwCzVzPV + kKzYdy9LaEy2FQXL3t+kyuiFqTJ0fopm/U3m/os8/0QI4LUJ8CdM8v6T1IDt+Y33NwpAcwB8n7PmSc9y + t3StjJeeh52Iy08DIUVAmUBGF4dqay9bfg/UxSnwSQAmH5DweQVQzK7AKEMABXYCkTKeoYK2Pcfq+3gJ + wBsCDJIAco0CGMZ7UM7vq4kzBMBwAABmtWGkKEIJoI8hgA3+/oxg6c8NRwQY4yOA4XIPVADDE6e8CAJ4 + sR7PPxkhzb84b98jfbuWPyjylQfeGLDuf2PMD7KTdbn7vV7rwdebrUtF/r3mT7fe+cGdP3hfp7l+hHPa + XyfyALZ/+UORX1wlct9l8ukvr5B//OI8OXTvbBl8yCVDT8XK2O4UXMTwJjkJ8kLGxXKs5hk5Xp9t5vhr + 4407c00ysStPpDcfVmDyCR358mn7Fnmj5Ro50hglhxti1PPvY098oxsgZ3wboxf4KBTAKIkAF/QYPOU+ + ekgQwP5GjwLfkABIQ4kjTgmA4NcSII4bB4GMwBPu/XWyjIAAhs9LMYm7c1JNJl9bdxMUrH1e8K8wcbx2 + 8y23DY97lyeY5058zQ4Bes9M9NkgFEEv3rvnzFQ8dks33rfnAadm1RkCjEOKjxZTnYQaAtAyHn57g0ft + YGO8PmY8z3NAAhgGQIcKIqACIuCVQ/E8FEAtk4AJiOdjdV9WAg7gOaqm/rwg9fzDeRHaEjyQx/eIAkHG + 6XFjWgkAgVe6jAKAMunLDgD4A6UnY9okAsBxJQ4QAP4TnNvhcrcMl4E0Kt3yXLNLXmyKlMO7XdJ6x4K3 + NqU/dPNP5B//eftb7dav3xj3A+1kXe77cNDaOJxv/f7NjoDuX12b/uEdV352HCCXu3g33GtEbr9Sjt92 + hRy753J575aV8uqqRDl6X6KMr02W4V246EtipbsGHq10lnbcHc2fL69u+a4c2/0bOc6benhv9VWIkKFk + g0jFJjPpZ8lWtX9V/lqer58HME/TjjbG/gQ1B/KwSWVPRZQBP0OA8hhDAAD3Pk0Ask8gTu1gc6I+VoNs + 3quJqkg1DQFYaoNs3ncfvveFs2Xo3GRTsjsrVQFKJcCyX6+tCghsynkT05vkHgHtBfiJYPcl/uznepYl + qDEH0I0QoHsZlUGcDg7q/iVkeS6z6vheJcwDQN2UhJnqBry/9zfxN+raRwAOGSwMgkcP0nq+KgDYSEmU + Jub2QvabeN6t3v9AbYICerDA7McqwADLgTASABXA3hoeA68P8DO7z+f4fr0ggB7E/r0cE5AJNZDOFmEo + lVIQFgA/gv96EOQ1DAUwVuEBgbvkhaYQea4Q4c29qccyn1y99ab3+4NuH99m3ff6sB9oJ+ty67uQ/wkp + Vk7NtvnP3f7DoWN3XCyy5kKR678jch1s1aXyz5vOllfWLJLxe+fL8NPwFJm4sIpTZLwY3r8wTPbi4h0p + 4ai1KKj+INm/2yH/WHcJQog7RJ78hcjTnB6b02hzau2HRXb8RmQbZ8v9o7xbdLXsawyXsWaHHKmbrQ0w + BDM9H2v5puYcaZNAtNa96X0ICkMA8QqSAyz9Ncab57RxhqoBMXZ5hHp/EsBIHrzeHUkyeP4cbfzp05bd + FAV938pkn/WflWK2T0jqTfbs/58IwBsC9C8jAcTrWIGBsxL0fbvuiZGh7DAtx7GkNwqPS3nPUGevNgN5 + fOA3v4thAcEcK0Ps7cc5H8KxgwW2nMd7jFXFyqGmVPz2RCgkQxj7a0xMP1QYDs8fpjkASntDANEK3L2I + /cdr4hXUehzCgD0Adn9uiBJATyarAEEgAJBBdrAMsvmoPFaG+b76f8TieyMMA2E/jxDu+Soog9+6peAX + 3+r8RV/G7NxUy7r99V4/0E7WZd3Rcite5Kt1m3/zk7/edOXrn90K8N8E+9kF8uHPVsjrqxbKvtW4YB+G + Z8o4B3J6oQziwunHxToCCTtW7ND+8YFixJAVzEYjzoYieCVtmXz6xA8QStyAUAL2+xtF/rhK5E9rRB7n + DTNuk2PP3iSvF66UvQD/OCT8ofpkA+LGRNPNxvifCqA8XDP/BMgIwwCGAFQAzYmf85ZKAFASpm8gWo8Z + h2oY58Wai+3VcTJw/hxNAPYR6CuoAJKmEEAvZf6KqVL+i8B/otz3en6uJ6oAyUZVnD0HioPVgBTpuCNa + hrPCTSMPgDxSFAYCAEnhO2sMP4kAvATH36RgRggwVBSuoO/PC9GSnjb2sILQiPPXkKQjAfczJKiJ0xDA + 5ACCZQghgFEAIUog4xXMEyQqAezRECBWSWC0LEbDhB6EAN3p05QA+jNDoQDCoECiZKgcYYJauA4THi01 + SUcOyX6RjVvrY6RkdcrLmzP/cGWKyL/9/pVmP9BO1iW96lnrFx/3fbP5sbuefPvaSz/57Obz4fkvkI+u + O1tevRYAuxOeZd08OVSwCBfJXOmHVOyGV+0uw0VE2VrsxEXgxkUBj10B0NbjAmmKkANZyfL2o2eL3HsV + QgmEE7+8WuR+EMIDPxR58EewH8gHT31LXiqaK2NN8CKNCbj4Y01HWx2344zsrQBAykJ9SUAdFsu4vi52 + AhxTCADfgc0t5U5f6GDq7XifXKeMr/LI4AVzZYTxO+X/ipQp4Kf1LE9UAjhR0k/18P+NAjgzaWqosAzH + Lk/QEYM9Z8aCBFKl43b8hmxKf5BUMcIaxPSs8ROs7ODz/h5jprynsToUwGAR+/k5si9Cpf1gviGSUYQP + 41rTZ1twop6/fdUerZpQKbABaCAnBGt4dnb3cYwAPPk4PP4ogL8HCkLXIJlRJY1w7BckPRmzpBfevy89 + GIQAImD5sQxExAFB5SAfENcIwkAqh+daPPJ8TaDsz3JIy+0pH2Y+e8/DP5W3v/7UgL8t+KRcVn10wGq/ + 44fWn7rTw7t+9fPq9+H15cZz5bMfny2v3bxA9v8uWUZ2pOJCSQbgwnBRfVX2lkXoOHRmikcLEIfC+/dB + CQyVfQMXkFOGaufJSNMcOVy5SJ7btEiO3XaOyC1439u/JXLXpSADhBX3XC5y38Xy7oZEOVqO969LlbEG + ynqH9rTvr0/CZ8EzwauRAEa1iy/S9M3TmNyrc03xkhPbcZoRH9MLOcpIa3w/ldk5iHGvd8vABVAABO7Z + IABm6Sd5/ckEoAA+cyrINbZfmvC5fIA3RPBWAJQ0ONrQDgHYCty91IkwYLa03Yp4PMOEAGMlUDklDtNm + q8m8OAX8Xvv3KQFwXWuSbUMl4UoACv4CE9NrJYCDimpNU89YtWkCYveg1usLw20CYH0/FFI+UAlgpDRG + vf4oSH200hDAGEmgjKQRoYDvYfyfgfg/I0S6se7JBQkURysJjJQHKzkPF7s0nDgK8n25LgDKAt/n3tnH + ix+4Nvf6VxoCMrc8bN3ynj8PcNItYtv28nWL9l932YF/Afj/uGWRvPpQpLy4E56/kNl9ysMkGVPvEqGt + p8Pw+kNFLh05tqfAxJjDuBD2ArR7arAvPND+mmQZz4uTVx9eIMfXfFvk1itE7kRocc9FWF8ln/z6Ankx + HbF+dRTkIy7YpkQtdzGRRQJgcmpUw4wIXZtSoEMHuDBbbVpfTaZcgc+eARss49UxuCAdvsShKbUhds2F + t/p5ggyePU8Gz0yV7vMI3tkqy30EgLCgH8SgeQBK95VJ2v3Xc2a8Zv+5JrB7SRIkALXEL1gb6yPwsX8P + qwpLzPiB7us80rs7TAHMkp6p74dqGMBmoH21TtPQw/JfXaw+3quNTbE6AMjr+SnTB/MiQQBRMlwSrfE8 + wT9OsuAaxqTpYJHJFTCJR+vP5QAhnA+Eb2ztHWPDEMIqEvgetvqWubXK0EPAA/g98P69mTYBZHNmIvwv + IC6S8TD+l0FWBvC/HML3faElQZ4niawNlYr7zhv8Y2v2bF5ja97f4wfcybbc++6Q9TP551ez0x+6/vBP + l739z1uXyT8eXy5vls6VF5soDXGxAYB7qhNlpNKjiSLWjwdwQfUBUEOFuHBo6hEANr3o4IFrE3ARuvUC + PPh0inx4y7kia64E8KEEbjtXKwsfPnKeHChIApBD5XAtLu7GFI0jKd91IAsz06x7s1GGwLe9/ygHA1XE + akxsvL5J/B3UfEC8hgBj1Q47cRg5QQCQydre+mMQwPK5MgDrOtcDAmBsPlvzAPT8U/MABrA9zOKfCdCu + APhBBgS013iMb3uFeY/JRnXRQxVxVoIMLUmVruVu6f0xVMHucB2pN1JividbgRkGsBlof41TW3r3A/j7 + uF3jNB2R6s0N4Gla0gOpDeRzkBD3SVIpr2U9nPsxdvoBjFrWg+dmDN+XC8uhImAewRDAniqnDENpDZM0 + ERaMlXm066+XCiA9FN8V8j8jSLoQCvRkgQAKo7QteESbgty4RhyaEGRz1vNts0EA+A1poVJ9x4I312Y+ + 9uMfyvtfvfWdAT/gTqblnM/2WL/+W6d1/5s906uf+OnG5+6OP/bmxjnyesliebVnvhxpS8AfHKYMP4YL + SwmAA1Lw5w+UTJeOilOkAxKwF3/+QBEkLTPtJAAOMGEMykYUxPIHs1LkzV8tFLkeIcAa2M0ggTsvk/cf + Wyn7SlNkXyMuHJDFaH2iNrBoHRskwIuSBKAxJoHPbSUAp17USgD1bl/i72Bzkl0GpGLhft7GIYdOuaXf + G16s/5o4GThztpJAx9mxqgAYl/eeAF4D6jgf+GncNo/jbTuBAE4Av88YQpyVKIPLZksnj/8hnttlJPwE + AUTqbzXtwGYEIJudtOGJv7PWbZf0GPuzCzBK+rKDlQCGCmLwPuyZSLCBH2uvDSHzPJIA+vMilAB6s0EC + 2WEKZMp99eJl4TYBICQhAYAcWAIkAfSkh2g4QAVA46hCEsBoGduCPVoOHMS53lcZJc83gZSrQ6AendJ6 + a/wnW/+w+qlb3x857bZ3eq3zZdQPvJNlOVMOWekdWdbGnryEpvvObH/p2Qh5BQB/rcMjL3XHaUfeYFEQ + Lg7EibiwRiqhCLRLzKllqMFCxJAFuHiK3NJTBM+qBBCnRhJgLKrevCpOjj6dKP+67SyRVZeAAC6R47ed + L69vWCQjVYjzG12asR6B7B/Hxc5jaKMVThv8pvxnFACAXBZjFEB9wkSirH6idk7bU+XtHXCYzsESh7bO + DqbD830PBADQD66cJ51nu00I8AUEYCzhv7FEX8hwImlMfs23DwigG+qBBMBGoK6rQR47mcwLM2P6i433 + Z/2dNXzTDRinoN/HkX21HtPZV+XR8h3BOVzoMO26kPKD+ewPoNpxazxP8mRWX/8HJvlwHgh2dvL1sr03 + JxLbUBBUDqWmsWeoHO+LNb06Q4Dh4hh4+wB4/yBbAUAJZBgS0H4AVQCxWg0YxH9CY+n1SEMEyDhcjuL5 + 0YdjpPzuS5oePVzjeuxorfU12ecH3kmTAPznqNX/kyus3dt/f1HTHckvv7ArSA7Wni4vdc6SF9udCrDB + omA7Q5wA7w8S4BBQMPtgPv74PHiYvFgtY/UUh8oQB+zUxE8yt3rzsdooGdsVK288sFg+vR7e/6aL5eO7 + V8pLO+fIAGNUZrhrEmVPQ7KM0+vhc/eSEHgxqle0a/9ac8ZFCpCwXMb9vPH/Xr6HHf/zOYYuJm8QY4YQ + F8cYAtgZJv1Xccy/UQBdZ8f5CMD0AyR9oUefDPYvIor/0/76eHkygA/iWZoq3SCQ9ivc0rXNNPOQAIY4 + wq/ENPSwEUe7+FgNYD6Ek3xoX79bR+qZ+j8VQKRm9PtzGM9Ha1w+VhGnHX2jlQ6N5ycIIEYnCGUI0JsV + quDvz41UG+bcAiRb7M8JPkiw6tkR4/dyUtBdgUoA3ekhPgLoyQoxRFTiVO8/ABIZZEIR5/xQQ6gc5XTt + CB0Pb3BJ423LXniyZN1Z6esfsH78sT8ReHJ0//1rr/XgPwb17j81961Z3fur2e+9UIw/rD5A/twVIK+1 + IIavjNf4ew8voKp4taGSaBksZmlphRys+ZYcqpoL7xogfVAAVArjNQmfJ4AaSF1cYEd3LJFja86T4zec + K/+8f4kcyouXXs4uSy9XnSxjSgCxNgEk4P2i9fOZ3BoqjjQAASGQAAhsVQoc/uojAKMG9tYzLjWxP2Pm + PbiYlQAAnIGtIIDLOVFHivQDjF2cvmt5qknc/TcevWtZ/BTgc/1/kvuT34fHdi2N1y7ALvYA4DM7ETq0 + fSdWuvld8k0TD2N0rwJgpt+rAAh6rwIwBBCrBMASndbztakHoU0ey3ZRJn5n6U9Lek7dZo+/KQWGmxAg + x2vhOlPQSKm3AuBSY2WAA35GSxEe5Rr5rwQA60oPlk4ogi6QAL8DVQKrAfT+JAES9L6GEHkeCuAlXE8H + cyOk646Ud3Y/fu/PmQi89Z9D1l0fH/AD8P/28uDxI9bu/hrr9yKnNF974dN7/5j66V/gcV8EmF7uRhzX + Egew489l+cwG/2gln2Opbq6888Ja+eAfDfL2a9tlrPlsHZLKBh0Cn+BlVpngZ+16b0W89JXjYi30yDsP + LZKPVi+Qvz96huyBB+mtBphrKG2TcEy8lrr214MIlAAcCna2nppmEzP7DT3UeKXJE+ytZ408Xk3DDZ0K + y6Odgir/se8eXuDwjiyVDW4EWL7DEl0CCCBFOuGVNUE3CdTeMuBU7x7/haCfrBjM4xS7r8D0F/TQ83M4 + 8LIk6Vjpkd5lIACQQuelcdK7KUoBxnq+9vdzQFBxlGnHtcOnvTaJcltzHoznATrG4IYAOEswk7CJeB+H + ke8c0INzSq9OYLMyQAKg2ujNDlHv3ZMVBk/OdTCUg60AKsxU3+zyI5FQBbDppzuT+4Yp+KkG1HYH4DuE + GgVQ6jIqoIRJ4WjZUxuG6yhaXsR32Vc5U3oe9Hya94sf/+Fmkf94/OVO6+5PDvoB+H97eQAsnLn9aesP + h/cENd17TsGhTfHyamW4vNCUJC92u+RwC/5UgHqA8pu94ZVxmu2lzDzYvFA+fa9QRP4in3zUJfvaL5ex + IiPLjQLwEoBbS3r7KiD1QQC9FVHy53Vz5J1fpspfnp6rTUT9VWxhhQevNFKVvessJfICNgTAuN8QAL2k + qQg4dRirCQFY/kvUIcTaQFOfaBKIlfbMQQQELlBOn6XDYdeD1L6Tqp15TAR2aVbfC+L4zxHA/yQkmDA+ + TvmcGQJIlPYVsSCeVH2u62K813rE4znB2qTDEEDDgOJonWmHSTz+Djb1eM+jEkDVVAIwXX3RGpINFERr + TL6niklQj+ns4408qtgUFavJQxJAr/YBIGwDqLszA00lotyl03uN8r/G/zzCMf88BudNge+1XbbtDtLv + MIwwQQkAqmGghHMU4rvXOOTFJqc8r8OLvyFDT8ZLxj2XZt75yWvT/9heYN35kV8B/F9ffvnPcWvbL2+z + HqiqDq3fuLL0CJj81ZpZiN0S5fkueO4mepYQlXYjHPjBBhSAiRfZeP1s+eC13XLsg+flw7da5UDzFTJW + aCalMElAO/tcY8qAY+XzZbSEN8IIkNHsOHnt8Xh5YWuKDJUzvICXqE7QsehcH2QPQbXpTBuCt6f0HyqO + MkqAErk0UrPU7DrTKgPr5LyZRkOiEoCvfFgepdl1xr2jUDI+AnjaKUMXz9bBP33LWJKjZwd4V5wI+Hif + qYxfFmebUQIngt8QAr39iWa8P7dJAAR/74rZ0v0tHPeskeTa0ccbbxSEaO2diU4d0DOFAMww3738L4pj + NHloegDY4cdYPkbfa7gkRhWACQPcvs6+PXb5sDfHJAAH8pzSlx2tCoAEMFrhkWHb+w+pAdQ4pr+ICiBU + 1UI3k4C7oQR2hSkJsIpgCADeH+d5QIcos504Ro40RMshEnP512VsV7JkPnJR4apDewIfzliPMMA/Tdj/ + 9eX2f+21Hq3caq3p3ju9unJl5qG6CHmh7uvyAu+v18k+8kidForDPZUA7FpvPxNPRQBe4+VytP1HcqRp + GQAWIGPaUea96OxONJ1rDsRRkSR7cJENFQVJL4jm4C6APicBz3N22UR8Fl6vA1mwd706yR6YgouQmWWO + MSgMVyJgVp9lwD0Vpu3USH6Pen9jiaoKCBgOH9Yx8/CoJADOpsvGmcEnAISLZksPh/0yBCDINcZPmOLt + vYAnORC8XilvtlOmAN/bM2AUwBeRgDmm/SyP2T4TquBC7PtUhIYA9Mw6WKeAnYFRGn+P1di9FDXxvno+ + Z/dh6ENSY/xtegDCNAfQl8MhvyRM/g9x+j94QwA2TY3YVQDmCbgvCaAf654sdhUaAvACX4mALceM63H+ + erOjDPgzI6QnPdIQwG4qCeYA3DopyKCGAlBqxfHaqr2vPlT2N7LLc5YcKE6Viuyrdlz4yl9Pu6OjwFr1 + gb8S8H99OVXEWv96r3UF4rKh9nPXv1DnkBfqT5e/dHrk+dYUzQb3URpWxCkB8IIgw2sSKc8l3Xlu6WVZ + KX8mLtzp+NPNEFGf16mKNS2psMFKuwkHF/oALpSRApdeOAO4wPaVQ7LjIh+pg2SvdWsji3YTQraOgHzo + /QeLIlQBmDp5lK0APHbLrMfn+WlmOGyslhBHOWy1xOQA9pS4dPqsgUcdMnh+io8AuijtCXpvc8+yqbV9 + SncvgE8kgMk5g4kcQsr/kQC6liWbhOD5eO+18MZ5phY/bJ8fqgHmPBTwGgol2N6c9XwvAUwoAFMFIKg5 + 7VeMDJcyCZg4hQC8g3t43FCBQwGtlmXie34HHdhTYf5n1vVHlBCMd+d7d2kFIBwKIMImgFBtER7A+w3g + HA/SeL5BAFoOrg+UgyCA56oi5FBVsgy3XP0HS+TfHvnroHXNR6/6AXhShAGf7tFZgF9uOeuJ1+AlXmiY + JX9rYz/3fBlE3N5Z5NQLgRcFB36QEHpzOFMM5CbkanfhN/EcLsJCXASs+VYZz08iGK00cexYjQtx/iwt + dQ3kAZj5MdIJIHeVheuFs78sQWPUoTp4dk7iUZviUwBacmTXYaGpBFDSD2sY4NCGGJ0Bp85jA9+j8+Ab + 2WwIgN6fwBrlgJuSWC2b9f0OYDnbjM/vWYL1MgCRXn65ifE7l8b5JH63ZvATbNme6gMzt3vt9l5vhWCC + EMw+lP1e8vAqiDaEACSA3uWp0nlenLT/KcBOAkaZe/ixH4DbVFNaw/fmU+zeimr31BDATgIO5EZDBRgF + MMAkXJUZ2qtlPWb2GdtzYFSJUwm8JysCwA+XXnr0LBOGDJe57P/ZNYkAjFdneMH4vzs9FOAPlfYdgdKZ + FqyVgF62FBc5DAGQ3Is80s+p1+pn6L0ZDpEA2N3ZuuLX7xecZt0sR/3AO1mWJz5uJgH823NtS59+qTZc + nm8KkJfaOf9csgziguwH+IZUDoIEytwAPS60vEitObOBZIAjzDjZJMFJ0NPrwPMP2xeekgEfU34WRanU + 1PIVy1h8b1zo49X0cmwAoudPNt6LHo+z0jCrXGRyAMZMOXAYBLCnyu1rGdZcA1uJ65g9N23CvCce8w4c + qchJNzgOQEOA+wDacxMVoAR2J4DbAaB2EbQE6/JkX/Kuyxe/J02J5b1enq932sd28zk9JhnPJU15rnsZ + 3k+TgE6scfySOdLyLbd0/cahSUA29WhtPy9Uv6P253NcvlYAnEpo4zVGEegNP5lw42xAIN6h/Gjt6hss + 4PTfTiVjo9pcvsy+kgHH7+O43rxgrQCQBHqyIuHFwzUhOFQY6yvlMaNPIjAEALLHd2OysAeyv3tnqHTu + DJJuEEFXGh5ngoD43+I7M2E4ABXSr9/fIUc5pLsqSI7UOuRIc+ojstayVou/D+CkWTa8mc1xAKfs71y5 + 84XaUHmpLVJeaGf8D1kLcHOAB2XhEKU4vQfjR403TR2Zw0L7OSEFE3SU/QQu563j2pat7CwbpLzlGHLb + 2LFGEhgqo9RN0CYj2njNBAHQg3PaK9MlF23eo8iogSH2AVTZFYa6OFMm4/0COWsOb3FNNVIaqkbPrwRQ + FKGDYfrv8kjnufT2qQrODhBA5/JkH3gnA7dTR/GdmMxLssE/1SaOT/r8a/wsPN++wiW9VACL50jrRbHS + 86BTJ9gwBBBhCECn6nJoLwCnAR+vNjP2MhmoSoChUalTz6EhgBhfI1A/bIB3D+b/xem62EjFORHYx0FS + gJfvywdoWQIE8NVYCsxkHsBpd/M5p+QBmPjtx3/QlTnLlP92BkvHTigAtRBNEPYXGgIYYGciCUC/v0fv + bXigJkoOV0fIwbb5a6k2f3Os0w+8k2VZf+gx66GXsoMH2s+qfr42WP7cGSvPt3ESDshjTjfFbjDW/uE9 + yPKUe3250Zr8ofXxdtM2AQyTADj7DEC5x05aKQGwx7zIgN70sEcoGQxq95nbJoB4NRIA1QATYKoAiqIM + MIoizCw07EtgRUAVgF1l8NbJCf4Gc3ssnba6xHTW7Sk1A5WGC5n9hmS93SkdZ8cpKLvOJAFAESxP9QHe + 6729ntwr4Snnu5aCLJaavMAXAd8ca1TB5PfpZtIPIUP7Srf0LE2S/jNmS8f5Lun5lQNgDDIj+VQBhE0i + ADOWf0xbep1mtJ49Xp8KgA1EfTkmEz+gXX0k50hVAQStV4WdWNsn8fZkT4QBTO6RAAbzXVOA7yMAPMdE + YHdmgBJAZ1ooCCBIOnYE2AQQrspwgElWfPZAIUPFKG0i401NDvMeB5UhMtK1Iu17Iqc8/kGNH3gny5Lf + e5O1e+Bu90DTGcPP182SP3e55bmWeM0I9/BusuVxSgCD6jkilQB6c6K1jEQF0AuP1YsL0fQKxKnnH632 + hgCx6qXZHTigZa7JBBCppDCio9AS7KRVgpKB2ucIwOxPAlAiYA6g2iT7fA0zTCDWuU0ZkBevlg8jtcuN + CUTe1473ueu91SmdK1nWS7EJgCGAF/CJPknvBfXkcl73pMcnEoCXPAyRJOqxPStSYeZzulamgABwXpcm + gwBSpeNchAO/AAFwqm1O1MmYnueS8/bpbbviNNE5QQCxdh6ATT0eDb90TD+VWG6UhgG9HOHHpJyvtdel + BKwEUOHW6sJAQbhpAlIFEDahAPKcqsi016Pc5TOt7ysBEPyBmgNg/N+xM0DJgA1CfQhDBlkOLGbfAJPH + Dh2TwHEMRzk6sxJk1Xle9R/+VhW85cWNfuCdLEtL+2VWQ+c1c0cbZr/8QkOwvNThksPNcZqp78GFNMQp + n1n+UwKgAqD3IPiNt+nlwBKGCpwmmo1CkH3DWjFw2YlAk0jqL8QFxt51OwRg/NqPC1G9UmW8GWegjUZx + eozmEsptAtA2WTu+BHEw5zDMach8BODRcQM69Jhz6bELsdwMWR7U/AEu7GJK3ACdBad7DRTAinj1ykzI + UQF0KJhTpsT0U80k9DqXGutaljT1Na/ZJKD7TdpfbTlCAI4ChALoWZIirefESOfdDunJ4Gg+E56QALQS + UBStAPLO2W+G9rpV9aiywmts6+3lBB92P38fFRlDAVYCoNx01CZCAIYBek55bvF8X36oqev7uvuCpBPG + PADjfw35ypy+UMBLAD3ZIdJJBWCHAO07Z4IAQrQ60MPvX4x9S6gUDQFoxyi+A2/ueqAyXLpazupfN/pH + 187B+/zAO1mW4eYV1lDzOUv218e/81JzhLzQ5tSJOHshSXsLmBDCn6r1YJsAcIGRADR5RI/DkIDenJ6D + 4wa0jGS6Bk0mOt4ME2UTTqGdBGTYwESgKgCPL/4nAYzax41oCTDWVgCRCojJOQAmFU2G3DOFAMZUDSQo + QDTpyFCjyJ4MI5+z2+Jiv8mhQOxZPlvB2s7MPyX68tQpCbzPS3yvl5+sEj4v97lNz6/5hSUJCn7mETrP + JNHES+cSQziNIID2Ox06ws548ZBJBBClYJ1KAB7fjD18zXhy3r03RMOAnqxQNZblFOw6ItCUZLWMa4cA + PIe93v8Q1pURoiTAvACTvtxPwc8hwrYaYKcfFSArASr/Ye1ps4wSYF6Ag4sKY5QE+jQEiFHSZ8nyCJuB + qqOks2HZgd1dtyfmdtzgB97Jshyqn2cdajhjxaHaiH+92AoCaGe7KWJcALufdXo2eOCC6Kci4KAOZo+z + jQrgdje7ynSCSLeC3VsxGLHBPKrhAwnAqTVqDlnVEWicwabYxJujlZ4pYQBNiQSeRysAhcbza/Kv2OQT + qADMnAPxdiKQVQSPIQF2EXK+OiUMdrLhc4s5h36YTmnVeT08L+X5mXMQ+7M7jwBOthXBBJA7EOvTvID3 + xveTE31eQjiRMIwlK/hJAh1cL41Xa1ucKC1nJUv1hU5pvtulMfhAjrnN17BWSsIV3EzY6V16OCVapdMG + s2sqAWQH6KQeSgCZwdrjz1KguXGH054YxDPR3svzUsw+gAijAHxhgPlfmbxj3oeAH+JwYChAlgENAUQB + 7LOkfccsrA3wO1kSZFiQQVJ36Lmm9+9HKNCvU5Tx7s1JMJd01S14rqT9ptSK1p/4gXeyLPubFlr7mhYv + P1gf8+ELLVFytCVWpWYXAVpGj45wABdEL9tBc8IM6Jk8yjJk0MWecnpoSm4lALcdCtjhAJuHSqJNs0i+ + Q0esGQIw4NS4VL3+RCWAg454vCGAKDPkFBct42KSALsCdT4AnXPAbSuABCUA9gGYyS9MlnyQ/QmFMTqm + gXPi9+1G/Hqt08TnZ862ZXmCEkDn0uQp8l4BvyxpisTncySFdnr2L1IDSxN9uQAf+Jck2GQSJ22L4hB+ + zJaeS8+Q4RvOle4HUuFFg6Sf8pu9/flmdOCgKgC3JtLGqty+7soTFYA3BFD5n21P8sFEIKsevhKgS3MA + Wt8vdep5ZO3fdPbZJKAEEGETgNsHfuaACH4qQSb6OAqwDbF/ux0CdEABtO3kBCH4T/OdCv5eEnZxHPY3 + /Qwc23GoDgRQv+i5kq6bUys6fuYH3smyDDWdYQ00LVm6vznpnZfa3XKkxaMJvO58zvMWrzmAfvyJPcwc + I97vpufIYigA6ZqDC4kXH+U5cwWsFmgI4Fbi8HaS9ZdESR8IhRemlqpyI+1sdcwkAvDmAcyIQ5WeHHZs + 5w2M/I9Wr0IC2FPhmZIDMGTg0VGA3B4udfpmzSEJsIowhNCjLy1MOn8WY2f0IdGXJUjbmXHYnuzNp3p3 + owKmSnyvtPeuvfH+5OfbF8f7CKB9SZzpOFyWis9LkuHvr5S/r71D9j1+ttbU+7Oi9I47DAFYVeFvpbce + r0zQAVKmohKnoyVV4VCma1NWkLl1Fzy/z/A/MffBkZk6mErzACahx/dkItVLAEz+aTWAg4LwnIZzVH2l + saoESARs1hpgrz/+L5JFu4I+ADYdNstHAH25LoSNuCbwf/UVulUxsC15H5TakYY46W5ceji3c3VyccfP + /cA7GZbrP33Xamo916pruWDBnvb5f30J8v9QU5xKvh7KdWaaWW7CBdALz0Cwd/HCyWJCCJYTJT0gin5m + fwHIgUqPjwBMCBBvyoel8Ao6DVXExCQUtgLwdpyNTgoZRirtFlQm8QrMxBcaAsCj9GvjUZgSgBnp5vQR + wJ5qkwPYY9fJhwrMmHnNG3C0HaRy7/YI6fiRQ7qXcnbeVMTiiaoAWBHoXJr0ucQdwd92RpyC2Qt0VQD2 + Yy/AJ/Y3CoCvTyaAtsUeaT+TdwaajecTpO/SBTL4gzOl/xezpQsE0JcRoRN1kAD68oNNgrSUg6QQ2lR5 + fPG8EgBH+THHoQN7gnVyD0MC9pTduaZcqhOBljE8o8WYDL+XAOwQQJuBMr1qAITARKTd0ee1fhJvsekv + YPtwx64QHwG07pghbTtYGQjXa4IEQAXQW+DCezk0/6L9AI04Hy0r927quiMhreNGP/hODgJ4z6ppu9Aq + 7Ppu6mjnkiPPt8bqLbno7XsLXRr7s1e/DxdEN+LTTniXDiaMwPaduHg6QQYkgIFSt48ABpmdZvmIRFBO + 7+HQJhJTPpxMAOzom+g5n2o2CeBYQwAROgKRpgqAU5GX2xNX8I5BSgRxmvXeUz1RJ+fsP3o7bBIA18xd + bA2X1u9HSediePTFiP9tBdC5JEmBOeGxTdzevgQXLgG/jJao1sbHtirwefrJuQIeZ4PfqyLal8VLK+cU + XDpbP6v5TKc0rHBK008RkuwIkL7MCDNbbx4AnRugmXoSwN6qRNP4U2HKc1pd0ZF9bk2M9nlv3snx/Zyl + BwTAUiB/MwdNcZJO0wwUq8ePcmAX4/mc6EmNQKFmmC9H++WF2IN6XL51v3aEGjBzEJEhgFkA/zRp2Q4V + sJ0hAY5nRyH+o75ipyqAnvwYbUtmC/JhKIC21rOHnui+z72p6xY/+E6GZfVnf7cKOy+3Ng/dHjPYc27r + C20J2k7bnQ8ZWWTqxsz+M/5vzw6WdlxgBH5XZhSUQIR0sRuwMEZvBjJUES8DlPwAL5UDQwBtHYYc7M0P + 0/Jhn88itKNwuMRtwO4Dvhlx6FUBbBTq19p4uO5PAqA3ZyOQzg9Q4fTNe+cde7Cn2sTJjHP1llm8+01B + lN45ZxCExQk42q52gAASpXtJirYAty8nWBNVAXiz+gpo9fTw/kvjbQIAWTCJZ5s3UTgB9kSbFOL1OD7n + LQ2SAFpAAO2LE/Wz2s50S9tyj7T9OFw6twdKfzbzIyTIYO3U00qHTtcNdVNpOiqNMooxLdYMt4qiNQlI + z29UQJgZ508lwQFFOl13jE0AJuFq2oGdOm7ANAKFaRmPsb32A7ARqcTlywOYEMCpqoBJWxIHE4CtO2aC + BGbqunU7tkFiHen47AKSBd6/IBYEwM5REHRppI7SbGq7oPKe/sfD/th7vx98J8Py649HrTv2b7a++0rT + tJqBH//uxcbUt8ZwwfTkTpNuSr9yXJAl8QryLnjuTib9AKKuLEhoSMHOnBAtF5pkoUkYkgCYDByp4GzC + bgVsH0DIvgFOWqEEwIYiSvJSNgx5wwaPPRmFaXZh78BAUaQt+cO1akDlwP4BUwVw2ARgSmSjVTH26MN4 + 9Xb9xbi4i2ap9B/mIJkCACUnUAae9kjPVW7pWhQvPYvpjVmfT9DSHKft6lzikY7F7ik2eTIQvu6dG8Db + DORVAZo/IAnY72H2hbpY6sF2nFEBZ8POAiEgBKHiaLsGYdRm/DaEVTq2P9se48/x+ZzhtyJe8wBjvj6J + GDPRCYkW56Enh4OJqAIiVJ7rTD/ZgXru2NarzTx2OzBNO/1sAjDgn5joQx9nk9RdertvJnb7OSUYBx6V + OLQVnEquHfu2pwVJR1ooCCBQWrZBDYDE2qEMeJ30gQSGOVK0KBHfKV72FcyU0ZoFb+R2/+wXpz7/6inn + 76vyg+9kWB78ZNR64NVCnROw5IXHzmjt+UHdYHXCsf7Cb8pAMeQkk3+lAApA3pULyZ9tZL/Kf8SLHdmG + AAZLOSW0kf8DFSYc0AYizRwjTADwuth4wlKVytwI7R7UkWMkjArj3Ua8Q1Hp/TloBeDtgSTmUFXmDJQE + 8iM1QTZqtxB7J73wTkXOGJlqgonHHvwG9YSanZ6l8rrn6RhpuwJebBEAvWQOYnP2ATD7nwpvnoTH8cYY + ty8xUr+L9Xx69mXmda471fvDlqUgTEhS4zY7Cts1dEjQtSoMPj4D77kwTnMObDjqPgOfeQbCjB8AiFui + bAKIMCU9zvEHFcDRj2NskqqMn9QsZW7fzU5ASvKeHAP4XpZnIcE7M2YBxLN01CZBywk9OOfCsN0OrOP9 + 4eH7cp2Q/AjrWBXZHaLWlW7+V3px7epj7wdBX2QP9y0iAUQhDGTpD2HAjiAAPwAkEKTWBlIgAegQcZJ3 + EUilMOJ4Z6nn4/LBVRlpR59I4FiA77/a4wffyUIA9+99ynr8gy7r8eOHv1my/7d37G07852DzW4dwDFQ + kSp9lSka4w/woilCOIC4rhvSn56ii52AjPkKWSVg7Adj1p8kwPxBCZtB2C7MTjF6K3hlzkcHEuhm9prZ + fTvjrINXSCDsGbDHoPfi2B4qgEJ7hBnkZB+JgJUBzvDDEYq8wDn1d5VRDsO21CUBdBcFaEJtOJ9VDaia + HHiqJ4Kk/qowaQKo21YukOaz5knLOfOkdeV8aVk5V5pWpho7azZem22v50jjCj4/WxpwXLP3tRVzpJnH + YD2xPVv3bVyRovvzWN1/Jchm+RxpxfPtbEA6E/uCXJp+DHW1hTffiDQ5AB1fwd8cpklQlex2G69WRvj7 + mNDj7L4gxO6sUDNKj/E7S3pUAFQESgAxWsGhDZRFqyJgMo8J2W6EcQQ/43lvVr99V5DJ8WhzV5TuS+/P + mJ7lQWb1u/AZ7bu5fwg8f4A0b5upRNCOxx3p4Sb5xzkEocD2VHBOgMRPO6rn/y1j/2/Ony7yb1d88nfr + qpf9g4FOmuWX/xy0Lv70TVUBGS8+c+X+jmVvHWz3yKFqyLbKudILr2MSex5cRHG4EPAHU8LnO/Bnm46v + 3kKHEgCbhfrY9svOQc0HeCZqymVJUBUeUw6E9bBnPT/alBZZnmObL/vUOfKMXopJRTakaCkKcrcEx4IE + WIbsQszbDS/Zk8ekFdYFQVruYinRDGYxM9T2lYRrHmG0CLIfIUBn1ixpejJIcq6eJdsXhcr2eeGyjbYw + THbMjpDtc7A9N1S2zQk1a9jWObQQ2TI7BPuabfN8CCwM2+G69tqW1FDdl8Zjt88Lg2E9N0x2Yt80PE5L + jpTdqRGStjhMSm90Sdc2kABbcrOCtEGHvfyDOiR38sg8Q47sqSC4uzQhS8B6Z+kN1GQeR2qy54KZeyos + rd+zhKftvPif8sOkIzNIwU8ZzyYelvFMTM97/jm1A5QE0MfwjURTbFp7u/Gfte2C5N85S1q2B4MAglT6 + t+0IRjhA8sG+hYj9cV20FUONgdgP1sV91leZ+kZ+/83JQ9nB1gP/GvGD7mRbLj32N0sus6yq537z4xc6 + Uj842Jko+6oidRadPkhHzfDbyb3+kljj7aEEqAYoF7X5oyhGlQK9P23AtiElD66TtbOQ5GEIwMj63txo + VQfsIOtHGNGH9+hj8pBenLVuhhLlCVpq7Mlj8jHKzkOEKmC6KIELEE7wtmHaP2BPacXP1bKXG7E08xjh + CFmCpXVTpNT/xCFVCx1SkRojZSlRUp4aLZVJLqlMcUl5SoxUwCpnO6Uy1anbFbp2StVsl27r87ZV2s95 + 9/Mebx5734ef45BirMvn4vlEh5QlRUvRonBpXBMn3bvckN6srIRofZ7nc1DvvOs9f7GaJ1FyhKzvAWF2 + pAP8TN5lhBvpvpuZfDPR50ARzhtAqxUYkrIm8Zwq63vYzQcvbzx/oE0CprmnDY+7cxy+/1S9PpUf/vPe + QqionGgQQJA0Q/YbAgjREKB9Z7haVwY8P64J/X75nIdwjhxml2Z56Fv1/VfNfnWTH2sn74LYrGZ49V0v + tkR/vL/NbrIpRRxXQY/uMcBmRQCSsCsfXhug7QZ4uwHKHm3+sMs/uFj7bMIwpGFsoCROk0vdnI0mN0Lz + Ab05kLDZkerV2T8+UBYP0BvT9+EwVMa6fK6Ex0bDi5MAzHHaiQgi6WGZkINYFDB2HzuPY82b4YUST4S0 + Z3MYKzzuTYjhdbaf2dLFOfp5o44z5kn34rnStQTPLZkj3UvnqnUtNo/1Oa69j7m2rfOMVF132/vpc5MN + r7dj3bp8nrSx+egM5g5SpeHcOGm/M0W60z3Sme3QJCt78xlW0WsP2uTpVUY0euSu3HAFPyV3J0uyu0kA + 4Zqd7wS4+0kAJW5VVSRmWn+x6dMnaXeANNp2BqnHb9defqgB7e2HosqJsRWAQ2P5HjXbs0MdtOOzWuDx + W7aHSfPWYGnayl6AMBBBiEkCstMzj/0EETqj1KEaj+yvmPFOw+CVC97wDwI8iZcXxWrruOa3f26JOHaI + 04FXz5HR8hB4Y/z59MYV9MwmIdSNGFwJAH+2MRBBQZRNAAB6uRfICTgmTnqZQ4B3pxfRagKbUFiTzzFg + 7mLcW0CpGq/H9nFffhaMqoChB2VoN2L5zqxo9ZZdWBsSCNeLra/EhBAqd3mTCttzak87CIB9DO1ZEfBy + UdJ2swdxuUdalsZLy7IEtfYlqQrKtmXJ0spkoL1uWZzge9x+Zooat9vs51qWJEory3r2623LknT/E60F + rzeuTJFmEA/3b1waJ9UXuqXlF3jPXU7pALF1aF0eZIrwqq/U7r5jxt4bx8P6AGYSb0dGhHQo6Ol9Q6UT + 6w4m9BBK9Be5tRdfSRnbfcUkA6eSbE8eQAzF0LJ9pmbvGctTvrftCNH36c4mAbjthh6H/t8EvxIAyIGf + SQJo3hqqBNCseQCogm2mCtCZC/WSHyBDeadLZzmnaI8/PlYf8U7lyA8W/SXDD7OTd3lerLqOnzzyfEvs + J0ca4GmqUmWwMsqAWeU45TnHBEQrAfT4wE+PFK2tw5osKjcg7i31qJEAaCQAKoVOJhBzDIF00vtzsknO + LVDIjkF8lh4DK3frup/H4nn2JdC7dGQCKAp+hy2b+V6RJlNdZvIGEx7TSF8OT+1C/ErQtMDbtd4SK63n + sDEHtixOWs7E42WJai2s13uJAevmJXHSDLByuxXPtZ6Z6LNmvm7vq8/Zx3hJhe/l24fHn0migNdfhPc7 + wy0N5zik9U6PtO6MlHYCGh69Oz1KCbW3xE6+lbjU6L1p/QAyX+e+7bsA3LRwXwzeAe/cAXD3supRFGsI + uYj/mUuJg/ma7rwYEADLdwiHIOPbdpBAQIzw4pTx3Tk4psCjYYDJ7TDH4zbJvdwY/dxmxP1NW4NgwdKw + ebo0bpkpTVtsMmE3YJ6521AXFN2hKpfsqYt5u3LkuoV/zvTD7KQOAUq6r7v3cFviR0frAeKqJBmoxEVU + htid9WDIeYKTcrBLZby5mCYIwKEX3AAJg6AnkH0E4DExfL4hAGNRat255nh2jg2UGqKg1yfhqPfHezB8 + 6AVBcD+CvzM7Rj1VZ2aEgpoekQpBk5SlE5K531YE/XiN4xbovRp2zpTGVdHSclY8wAiQLoEaWOoCeAl2 + L1gTfCDm46bFHtvizD4+8yg5eE3JY5mXPBLsfeL02GZYK9uB2SOwCGRwhkcaVkRKyy0x0gwQtjEjz/n2 + d0ea6goz+AR8MaspZoz9QJFJuqoCsAmgfVeEem6SQBskfDtn6s1zaidnH46lAui1h+d6FQCPbVPZHqoE + 0LYjwt4O0x6PPigAs79DiZ0NPUz49trHNm3DOdwyA6APBAFM8xlJhaEM9+/OjZPu4jg5CgIYr419u3Lo + +gV/SffD7OTFPyxt6OY1BzpS/3m0YTYIwG08eUmqATCBXezRJE+HlgEB+lzTIEQzBGBAOGDLdlUDdgjA + i8kQQCS8BICbAw+uFqHP8YIlwZjjDdkw4aimMTzCB5IGPT+sSxVAhMaz/B79JSbMIAH0c/QalACbWHrt + RFhvjgsyOQIEcLrUXRcqTfDEbUsgzQHEpiWxIAKAdXGCSvoWSnaadxvrZhpebzqDZvZtWuIxttitZkgg + YdK+8RO2CCHHwlgdV9C2EIoB71O/LFKaVjmUAFq1Hs8pt6Fq2DZtE4Dx+i6dZktLoQQxzrUhgFBDAiCA + 1p2GANp2s3eCmXiaS8+rkfEO+1iXkmabHbcT+DQm9fi4Iz1CSYL/Va+Svfl/NSTIc9gEMF0atpwOEpgF + FTBLyYBKQAkghyFigrTlzpF+KIkXqmLlYE3cP2oHrp//911+nJ28BPBTy9q456fXH+zwfHigfqH0VgZo + 6W24FKEAYvmBUsTzRR71+l2IBbu8QIQ34gXC0s9kEHpJwOuVWdriYKKObGbjI5UA2uiVcyLUqCyYuFIr + tYGsBODWoaWUoPycdsTJbbgIOyD9NQ4mAeC9+N1MCOElAJeue5g1Z9jC0AFSt3HHqVLz0yBpZBMOE3OL + AFiQQLMCleAl+JMB4CQ8TtS1d5uvN8J7e60JUr75jDg9VteL45UszL4nGo4FyTQizKhfnCyNS1OkenmM + NKxyIqYGATB+RhzfmRahDVckgAF6/yIzxZbO81dg5ttjCMA4Xj1+WqjW4FsRw7ewIWcXFYBbZTv/kx67 + RMsh24aEHXrOWncA9NuCjW1nTB9kEwBCqjxDMiSAbv5vzOznR2r/B6sPzTugALbOMNJ/a4CGAk1bmFQM + AwHEaFm3vTAEBBYoo9URx0cb571RNXbL7Nfy/9MPtJOWAB60rM2jP/vZwfa4D/fVz4f3D9Fe/qHyJEMA + JfHqUdTj59ADx6gU122W8pQA4iZ5YbeR7zaY+wqcGuszEdfBEWVQEG1Z3scRmh9gs9GADXqWnqgolASK + zMAS5gzaM3DhI4ZtzwjXC9kQQLTGuv0l3s+OVenPEhbvQtRdSLUQhQs0XBq3z5D6H0cAkEnwxilQAIkK + YANoQwA04+kT7G0bxIsTfeBv1u04nxpoPsO2xXy/RF0r6GmLuY4H8OOkDoqhFsfX4fWqZTFSf5MTgIJH + 3hViEnoggI6sMK22UAFo7M6yXIGZbZe9EFRC9P6tlP6I/dthzMQ3bwc4OV23DsuN1bBJSQDH8Pwyu8+Q + rU2TgMEmebfdNiUCowC6c526H1UAlZ2qr7xI8/+lh+D7msRfI8CvBvA3bWFzUKgJ0dg1WhiO/yNUBqsi + j+9tSHmjcfz6hDeLv+kH2klLAJssa/fQjd8/1Jb0z/G6FPWeQ+XRWgFgXM/4nARAud7JcQA2Aah5CaDY + JPG8BDDZGIt2AKjtWfTisAx6cIAygyRgRpH1q1xn3RkerMQL5FjtQNT4n0k/tq+q9w/XhBdjXnYlKmC8 + IUOJUQ+9BFCxAQO/ZyvA1cDk1Q9d0rwoScGpQF88AXLj8Q3Q+RrVAJ/Xx/p8gjQsjJukChI/d6yGEkuT + dN0IVdAAz18PhVC/0AMScOt2AwihdplTGm5yQVJHAsgANIG8m0nOSAP8YpdddYkyiVd6cpwLApSxP0Hf + Qk9OOb8zCgCOkBa8T1eOU8MAJlZ7Cz0T4QAJHK+1IExoAuibtgdK4zZ48G2BAHWIvlf7LhKqS5Ue/9Mu + VnjYNqz5Hpf+b0wCNm8LBfiDcD6ZB8D7bAnUEKCd/1EeOy89OP9OGa6OP36k1vH3zqFL3e8Ufc0PtJNx + +e6nr1uSZ1lF+9ZceLgt+b2x2uTjg2XmPoC9WoeOU1Ax/mfMTgnPC4nGMKADpMAMPWXnF4FfM/vFHuwX + Ja2sQQPE7Tqk2GHIIMsoAJPxjlUC6CmeUABMYnVSMWjdm+2oUB0Z8DSQqx27I3R8AoHizRto9htGAuBF + yIuZn8mLvm7zTGn4fow0LUyygZ2g65YlSZPkvgE5TYHtUwSJU4BPUvDuN9moDJo1FMDr2FbwL/LYBADD + c3xeCeDGGAApTGN4greFST3erYdzMhaZMhyB77XJBNAC0DZvN8BV8O+IlBaEA/xP+grjVDlxTSXAEqqq + KEh0EkCzTQANjOFZymNjzw6TS6C66zqBALTBJz9WqzAkgEbI/vrNDAVABlvDtCzYYhNAlyoGt3SxP6My + Vg7VuN7q673I+dfSmX6wnbQEsMSyql74xcoj7anvkgCGKxLNPeHYAswEoK0AtI6fEz1JATg0m28UQNwX + KgDtAYBEn0wAbRq/GzXQQQLIj7LLXoYAugtNz4F6QS8BsMxFwNvA1zo471OXHanNLtq1ZoOfPew9HCxT + aL5fq3q9QBAAJOv3naoACOIJ0CZMAXb9Ao/axGsTxsde8Hv3mTAe59Y1H9dhXQfw65p2hiGAehxfsxQh + wA0Oqd9i4vcWgK85zYQ4PQX2byp2TiWBAnPOKf8p2w1wQ+DFDQk0sS+f4woK4+y2XLcNZIcSoSqhExUA + y3p2KNCyM0ArAV2fUwDRqgCUAHYEatxfv3mGqoDmreH6uHnbLC1ndhfEGgLIZzOQSw7Wxr3dNPLTuLcK + T/OD7WQlAJYBy1958KzD7anv76lO0Lif47p7NJvu0fh6IgcQ7VMATAiaEMBlQoAS9yQpHusjAV5M7Yzh + MyMV9K2INdt3R/hCAG0Rti94xv89LF8V2TMRFTj0uNZdwXbteyLrTQJgDsDb8eYjjSJDAL1FTiWsyQRQ + fw287oKEz3lwL7i9j70kQEB7Y399bRL4fQSwKM68Ppk88FydbfXM+pMAFpMQ4n0EUHd9FIAE4HFYLX5T + 006GAcHauORTMkUxnyMAngMSAOW7sZCpBKC1fDZPudR7+wggJ8Z3Lk60RgC4ZWegTQAMPQzwu3L5H7Ma + 4DQhwA4TAjRsMUqgCd6/cQvzAdPxv4ZpEpFkwRIi7xa1vy7pnbJ9d6f8K9sfApyUy2XH/2rJNy2r5JWH + lh5uS32Ps+v0sx+f5bdSA2LWlLUTjzkAdvAxTsx1GQLgYzsE0IEj9oXrlfQaPuDCbc+OmEIAbfDgrelG + EWjziy15qRZIAD3aiRatBMC4mBluen3GqaYGHq5qgBWJHta9izwqd03yC99PRynaBIDPa9oWJnW4aEkA + DfO9nn8C2FNAPokE6LnrmcSjpKe0R3zP7dqFbmMLuPao1dnvY7x/nO/5BhAAH9ctNs/XLYyX6iVOqbsu + +gsIIMj0WrD5psAAmMk4leEF5pybHECoem314ltD9Pc17QjQc0wAUvIbIMbYEt4oADZDTYA+YIr5QgDt + 7YjxeX5DADHq4TkWoBmfRe/fqA1BIUoATdtmKAF02iVeEpAO1a6f83bR3l8kvlkQ4AfbybhcLK/pYKDC + F+5fcKgt9d091WzecWnd30sATAJqMi13chLQodl85gB4sRCA2nxSbDLwPgVQYrr42uDpJ4cAqgDSI+0L + 1mF7OpqtAAqN95scAhD09H40QwJhWg70EZBNAiQrEoB6MVy4rficpm3hkNuQrt+H9J4fb2JxxvvqnY0X + nwgJ4icRwIQnb2Bib1kypPwEuA0ReGxPb4N/gXnM16oXxGIdp6YKYKEdAiyLlbobnPqdtL+esp6JQICI + zUAGtE7zWxTETkMIUF4duyM1ZvfG8gwBmpUAArWtuCs3xu7UdKmcnxwCkACY9PN6fWMBum7leIBsEzJQ + tWmzV643hHBqBaFp+yzN/DPx17CF28F2CBBg+hmyjWroL+TcBW4ZaZj3Zv6eezyvlDj8YDsZlwvkL5bc + allFR+5JOdQ25x1OrNHH23lB0isBcLKPsngFmDcJ6G3I4cVGz84LhOAzIYBrooRnGz3JBAGEG+mPi7h1 + d4R6FXonX+sqM9eFXm/utLP48OI24FtZ994ZomSguQBmnnPNSDRv6UvBwpq5ythY/Rwm2+o2B0vdNdEA + aLwPsOrNF3lUvjeeYJTtBD09f90Z5pg62/vXTPb8Pqkf74v9ve9bvRAEgNdqSAJneFQxkARIAPU3OjUH + wGReMwGd5lVEDh/gze+J8SkAEgDLfyzFqfxnVp6Dc7aHSzPv2pNl4nYlDyUAx+cIwCQAZ6iZJKAhEhKr + qQI4VVVpCTDXJhC8Z+vuEJsAAtXr122e4asCsENQQwC7aqAEwNGZTYteyxu5x3moIsUPtpNxWSmvWvKQ + ZZXuvz3uYOv8t3mXnb7yaOkvIgGYKsBEGXCCAHih0Xu3cVReXrTdjBNnZ+K9JGCIgBKWOQCv9zcEwN78 + MDtudCh4tXWVXhzko4qCVhinIUcbyWJXFC7SCDVud+zm4KBo22OZAUP8Llr/BpkYBRArLUoAIVK7KUBq + v4AA6hbFTUnuTQkBFnm9+QTYJxOAF/z6uv2e3Obr9P7Vi9xTCKB6AY/1SNVSp9ReHyN1mwhIeNHtWO+I + 1GqHF+zeEEABmG9IgaTbvCPIruMH2wm8MDUqAM3E5xjJ35Xn9BGANwRo3hUiDQBr/ZZpal4CoJFge3Ji + 7SSgy271jrErQA78XySKAOP9N8/SSkADQpgGrrechv8yVEPDDk4qku/WezT2Ni99OXfwnqjRmqV+sJ2M + ywoSQOG/W3Uj1zsPtS18e19dgvRVRNoEMDUJOBECGAJQBcBpwnjPQCYCJycBbflvRvLFaB9AW2akrwxI + AmjdFaEXfFeuY8LbsW5dFGe62djKWgDlke3UcKEzPUZBTwJo3clwwPQTdNkes3uyZC44UQGESM3GmVJ7 + dZQSwGTZrgRwxtTsvoJ/vonzP08Anv/G8NoCgH0+gD4PBDCfJOBRq5pvyKCar8MqFzuk+tpokFKInZVH + LM2+fJsQvb/D58FtFUDFo4nQE0MAkgAUQGeWw9fM4yWAyTkAEgDlfsPW6SCA6b5KAJ/j+3ZlO804jXxv + GOG08z8kgEAlgIbNAUoALAMyHOBjKgD9L/EZHbkmETlWBTJpXvZ8Xs9tYd315/rBdrISwMvNZ1hdfddE + HWpb9I8D9YnSV8lhpXGGALz9+AVGypMAtH5vj8xTRWBXAnye3y7/KQEUORXYHCrqJQBvDqBll0kEehWA + SngCvyhega+ePN808ngVQPuuSAW/IYCISQQQY/e/m5xDZ77JZHeTANKjcLGGggBmfSEB1J8R/znwe632 + BKnvDQfUy6sSiNV1ra0UaubjtQUJajULjRH0JIMahgALE9Wqljil5jqHrQAmEQCbm3LNb+J59Xpjrxog + ATAJyM7GJjt2JwEoCTCJZzcCMbHalef8XBJwMgEwBPCWAUkESgBZMabXw3tONYww/3tzGslipi8B2LAV + RMBOwK1B2gmojUA8noqwMF7Gqz3S0XLmobyOVSEtjd/yg+1kXZ5vWmaNtl8Sdqhl0V85hXNPZaBpwS11 + +QhAk2scisr2XR2V55hEAKYXYHIVwGybEtaJCkCrAAD/1BDAbYcA8P7FIKEi08RCImAIQC/uBX7rzjDt + gGtXBUBPR4BwsJLbNpAGwwH1YrHwTFGaBKzbHCJ110B2L4j7HAF4S3h18NST6/uM4WvouRnLs6lnSYLU + LY7Xx8YAbICfr1Hq1zK8AMBJBEoAi0gCVBlYY59qvF49P0EqQQC11zkho8NsKW8IoIWJtFy21DrV+Ft6 + C+Ps3+cyJdGdpgGocTIBsBKAEEBH5OWZCVRMGXByHwC9eIge17B1pjlWyccQgCmrunyJ3Z58Q8BKAFQA + aVQK000JkJ6f5b8tIbrNRCb/WyqQNp3mLU721sRJe9vyocyuWwObmy/2A+1kXbp7rraa+24MHuo897kD + jQBhJS4elfBOHwFwyC6lOjvVdAILzQEgJichsBZPuU6l4DMQBtt4C3DxAcisQdNbdwCMbSSA9AitSTOx + xCSfKSMa6ymIg/fmsQABLtwOXlT0emmmD0Cz5qx5p4Vrc4rXS5qMt8mYa0caPxcxqSoAlgFBADXfd6hM + Zyae8T179BsXJ9mP43xZfW9oQGAT4AbkE2sCf4IEJpGBqosEXavcX2gIoNberljokpp5cVK1yCVV10dK + zaagKQqA+YquXKNcGE/r4J58hGAkNm3HjdDfzgSgid/tJCB+X7MOyXWq5+9kLiTfrc1A5rw4TSPQrnDt + G2AN31fK2xain8/SrHZ45tixv3fIN49nEnBXsE0AM3UwkFYBQDwNWgY0jUA6aUuuQ2ck2lcdLxXtlzXc + Ob5+VlrH9X6gnaxL1cDNVtbowwGdPZfu2d9opvbq5LRaJV5vzt5yj2lDJegnZfOZ2VcC4IShnH2Hw4Zt + 6yrC+3AmIICzg7GhdvFxNFukOTY9TBNHJAAdd15omnfoxQneLhzbwUks2Da8K9IMeU1jFSBIjWTQkRnh + k6vauGJvMwToAqm0470JqvptwYi3g6T6B9EKRib9atWrw+PTYy+cADvXdUsTjFf3PscaPjy/93UvAVQt + cNkWa4hiYYIP9Cr9SQRUEvNIDolScQYUyDyqA49U3BguNYyfvQTATL4SgAF+d26srr1GELb5CMDu49/O + dbAdAoQaAsg1Mlz7APJi7VyAyyaACBu0wZrAq99sGnoa2Uy0K9TX46HzLniHfHubiHZRdZiRgGYY8EwN + Aeo5NHjbTBMCZEepiugrDJF9lR4p6PhRzrdfqZn26MADfqCdrEtx763WhpHHZrV2X9V7oCFOBsoTpKs0 + UQaLPXYt3vSVa4Y3yzER/2eZuJ5tvqzhd5MAimixal1QBbROAJIDgdrsSSy0CYjTS+GC0rJXrsuO32N0 + 8I/K3UL7PfJdelFr2RAxrikDBptuQBiHxnbaMfNEssypBNCJ95wgAMj/TcFS86MYAJ/xPgDODL325xsC + mPD0HLmXoKD3PYftyY8J+MkEQEJQsvDG/Au82/F43W0TABTAYsh+5gigMCpujJDqTZTxgQpiqpRmnRPA + ALbLBjAJkd6cCc02uxmniX34HNWnvfkGxM2clSeLoYNJxBG0JBOvAuhgCJAWpvuSAFjD95KBHs8+gFyb + bDi0156whe83ET4wBzDLKIDNJgfAagAJQNWYzhXB3E+Y7AUBlHf/8Nnl7x465dF9a/1AO1mXrJ67rAfG + ts5q6P5+68GGJBmumIP4fzYIIN7MK1cUp0kd/rHtmWZknlYAsN3KpB5n6uU89V4FYBOAMbcqgPasaI37 + DQGEaaxLM7Vjl44lMG28tgIoMORBAujIsrvfdhrpr51zHP9OEkAI4R2QNJEMNBKYBNA2mQCYA/hpjLbj + kgBU5i9hHiBJ6s5IVGB7pfxk7/9FNln6GwIwCoDAr5rHrL9nQgkwYcjHUACVZzilAWu+d8WNYSCAWdKg + sXyQEkDL7igdUddhWydjcMr4gi8mAK3La0de6AkEEOVTAJTk+hz+AxKAtu/a3YPN2yI0QcrnGJIZBRBr + qw/T/cn5G5Q8NATwKoCZWgmYQgBZ0TpEnEnIgeIIDQGaeq/5lSXy1T+87J8R5KRddkCerTlYOL2m50dV + hxtmy0jFPOktmQMCSJSBEo4LgBUl2gTgMJNxMBudYff18z5zHDvO7kElALcP/EoK8OYMAdo1k28TwK5Q + OwcQqt7FlP0463CUncSLMQRQYFQH57+j9zcxb4CSgM5t9wUEoEnHPKgUKIFWhAhNu0wbcM3GAKn7mVOz + +PULTDcgE3w189ngk6BZ+onEnnsKARjJ755EAm5fcvBzBDDfEIBXCehxfDwfIcAiQwD8rHIQQA0l+PYJ + BdCSTgLAb87/AtMQIFL7AJp8jUAzNRuvHnxHyEQOQMfym6Qok4o6HBseumVnmILfSP9QJQGTyQ/RvIwe + n+P0EYCZwSnGVg/BpnrgIwDTCFS/eZYSkSGAaC0d9heHgwASpa3nqls51uTB10v8QDtZl6f3r7OufnXg + 1Kqh6zKfa54rI5Xw/mXzZKg0GQRAEkgGASThovDgT+awUDM7L2N5gliH9ObbE0gWun0lPa8xmUcF0L77 + BAUASckyIKWqGbduJrCYTADsC/ASgGl/DfaNg9fhsPBK3qz1RC7AYROAS1qzIqUpLVRqtwRI9YZZUndt + jE7MYQggHiA3tfqaRXETGf3FcVM8/WTAn+j9veYlDCP9TfxfOddtjD0ACAGq5iVJ+UKXIQCEHuU3hUvN + Fm8SkN4cKifDoQTQxt57JkAV/DgfPA+5MUoAbBtWwtgaYGf0g8zAnB0hqpbU2+dF2QN5nBqiGQKIVJXQ + gH3rqDxU+ofaZBCiYZkhAHvmJyoHVQAxSuAtaSFaPVDPD69fv8lUBJgEJCl7FQAJoK8kUvbWpkhLz+U3 + ccq5W95s8APtZF1+90q2lSzyH3WjP378ueZE2VOZLIOlSToTUH8JpwRLgaRL8REAa8VdDAXSTecaL6ye + fHNbaBMy2CU9mwxMDsAQAKeO4hRYVAAsA6rXUQJw+wjESwCdlPL59HpRWv5r1jHwwQp+QwIhSkC8uLvz + vckup0rWdng9Aqgd2034LCoAEkDtdTFSSwJYaAboaGaf8f9Cj3ryEz0/zST/3BNefpLXP7EKUOVN/HmV + AMIBLwFUgwAqFsVK7VzE/wtjpHwVFUCQduYR0A0c1rs7Ur+zIQCnbUYBdGoIEGmkPwfhbDXlO5PRh7Gb + L9NhJD9Ltjowx4zY1FmYMsJ1xKAvB6DvEaIkwCoC/xPvUG8t9SpxmDkc+f8xR6Cfx0FVm2ZK3cZpWAfo + PAteAtBGMU7TVhotY7XJ0tp1ybVyk2Vd8/cOP9BO1uXu10v19mBtw5fc+VxznIxXJeqcgDrNVnH8hALI + ceMCc+pkHpyUoyvDoWqA+YBunY3WC2LPJHMrmCkhlQA44AUXUouGAeEaQjAEIIAnWl9N4rCDIwHhzRlq + UAGYpFewTwnQc5JE6PEmauVu4/V4HMuWuPBJAMwBkABqro2WmqVuU/bz9ufrOt7nyf+7mN8QhMcGuusL + LNaX+Z9oAoqXqoWm/bd2fopUQnHUkADOiJGK1eEaAjRoPT7EJAGZ62Db9CQC4LY+9g7npfzfasfy2wJ1 + Zh7NA+yYmgNQAsg1TVjah8H8gRJAiC8P0KD1/IkkoG+gV1bUf0MAE91/pgoQrCqgdad9bJb5XBLAnpok + aW+/4EeywbLOerPfD7STdbnmzTpLfmVZPQPLrj3aEivj1XGI/506OYeO8y9OgHdPwB/s0sRfp4Kfk20i + Rs902gNQDAj7ihLUegvjfUYvbgggwsTytgLg6Dcm6Dp0DHqsr2nFRwCcSVjLgKb9t8WeuopqwDsajrKU + F9xEI1DsBAFwFKKXAHCBV2+YKTXXRUr1UhcUgE0Ai808fYYA3JM8uesLpf5/by7t/a9a4Jko/2kHYJwS + A5+vmZ8slQsNAVQucUnFLeEmCQhZbcqAhgDa2G1JJcNZeBgC6LZTcwCU6azbcyIOem7K7/otJgxoVhC6 + lADadRLWaLuiYHr5TQ4gVEFvVEOIncQLVBDzP+F/YSo8Jp43IQBICMc2afgQoHG/CQNm2QrCVGc67eMY + MvSXOWQPFEB368prOONUzN/G/UA7WZez/95iSbFlDfamfP9Ii0v2VHsg+Z06qSZVABOBrALoZBSczisd + 8WU6SQAXW4ZTVYAmfqaAP04begjMCQKInFAAIAGOfz+RALwKwAA4yhyLkMMbAhgCCLMJIESn0qKXV9Kw + u+eUAOwQgHEzCYA5gBoqgOtBAJyQU0f7xWkpsMbO+k8GdOV8p6+8N7kb8Iti/8lNQd4E4GSrnO+SShLA + vFRIfxwzJ04JoPK2CFUA2pPP+fUIbCZKbeBqMjA3xmemChBtKgbqeVmDn2k68jQHEIz/IsYOgSJ9CkAJ + gKQwiQAatgRPUgBBSiAaTtkEwI6+yTkAhmGNO8zn1YO06jdN9AEoedgjEbVNHPvzLs9jdaky2LTkqo/K + A6xT3jjoB9rJuiQiPvug6WvWWJfzysNQAHuq449zWureUnu6b73BZpxNABFKAJ2cwHI3B+cYiU4CGChJ + MuGCtvKSDMx6sgLgdFY6/ZWqgAgzJDjLeH1v66rK+HzK3kg9lokpAr5Jp8EKsTPgweaxKgA7bLCTXkog + NgGwE1AJAN6KVYCaGyKlapnDjPNnfz49N8wk/r4o0eeeFBp8XvpPLgVOhAATpgRABcDxBAvmSCVDirkg + AKiQytsjlQDqtkzT+fmoUtgH4JPudlfehJRnS3SkgtVI72Ab/EE+AtAyLRN+2gdgiFWrApxIRCsIwT7v + b3IBtgJgP78djnn7PEgAbPVuZwMRjm3Yznh/OmL/mZoD8PUBbOFsQkETw8RJABVQkiCA0YYFl79e5bCs + 1474gXayLv/x9x7rz23B1sHO6MuOtMbJWE3y8UHW5fVWW25VAUzwsWNPu73Y0bcrQsHPzj4mA1k6MqCf + kP5KACADbxKQfQA6nx0uluY0MweeaQYyzS9UC2ZOe49NABE+BWCy/hFqvhh2S6jKUl7wSgDejjdfCBCj + F2MTyMabBKy6LkIqlrAbEICc5yWA2CndfZMJgMCmGvCFBvOnAn9qOfALFMA8rwJgKXC2hgDVczxSvsQh + 5beZPgAdlgtpXb/VKACV7pOScUaO25l4u5OvcUuYHQLMmpiei/f4Y5mWU4fnmOSqIQB7LAZv7LEj0M7c + B/k6AU1IEKJenp/Zrn0e0WY2Zs7kpAQQAQKYJXWbpoEAZkj9RpMD4PF1UAOcLtzMERmjoQoJYE9N8rGB + 2nmXvl4eall/9hPAybv8rct6rf0/rL92fO3S59rCPttTvVAGi6Okr5Rz67PHP1Yn5mBCqC0zTAHb5p3W + i6U8reVH6fRdbAnWph4dzGNCAF6AbVlRmuHmBdy800x+wRCgkfX8dJPI0yw+W3gLaKyHG2XQodN6h9kq + wC6Z6dz0s4zsZelLk2WRCnxDArRYJZ5GKI46XOxV60AAN4QAiIkAa4IZEDQXcl/BHG/KgezbX5QA8Lql + cp7bbuzhdqw+rtRyntuu83vjfY/u731+Sg+A5gDipBzPlS50SgX2rSAp4DOKbycp2V4UAKxjNj4t0kyf + nm0y9+22aSmOSUCd3izYDgFCbQCb0l6zHQ6pZLf378g1IyMZQnBSFXMsgW+G9Ro5P0tn9SHIlTztzzTn + 0aHj+1szwjRZqceQADZxbUhECcBWAPqZ+dNluBxkXnvO+9lNV377/YJoy3ql3Y+zk3X52pvd1qHOYOtw + Z+D5+9pc749Xz9c70/KGoD06xbap57Pezq4/9ebay8/BKyGmGScrUqf37vMaw087AAA0QUlEQVQRgMeX + A2CNv52NJOnRIIBIBT+JgATQxLZeSs9ceyAPb37B21LlR9nDYV0qhRkqeEeteasBHMrKzjYmvrryY5UA + NG+Qa6R/V55HvReBUb85RKqenSmVN8BjzU+RKm3/9Uj9XIIxVkE60b2X4AOvZvEp4+d5fB1+J0p8H+jn + x33udd0HVqEE4NA1rWpRspTcGSg1GwJVytcpAeC8pJkW6/ZJ4PeCutPbCMSEoY8AAvS36T0PeLcgxuFK + AHY+hGFQgckBcCCQzumv3j9wkpl5Bdk0ZfoGTNjhJQDeWr01nfmCGdJI1bCJCmCWNG4K09GA3gSiqhZ+ + bsEsGS6Ll47aC954vPX2C2XraSCATj/QTualsfc8q77vgvkDbYuP7qtKkh5OAsIZeovNKD8NAXLNFGAG + /OG2hZmJILSWH2M3/7jtxh7PFAJgfEvZbyzcJoIwjTn1tlL2VF4d+REAdLTdwx6rr3Osu3c66wkCYBUg + XAmgu8CtVQMvARjv59L8wgQBzJLy6yFbF6ZK9aIkzdrXzwPAF8X6svamiSd+Qr57m3ls43MnEsBE6S/e + 99h7vPdxJcihDARQ6SOARCm9O0jnA6CUJwHUbmF4FGmD+EQCMKBs1fvzgQg3E8jhCj7+tnpOy8UBUmzQ + Yq4GQCQR6Pvkmffjuaan1zEAW4LstRkUpFOLw8ubz4vyfSa3lfjZUWnfCch7bAO+u84I5KsgRJvbxuH/ + Gy5LlNbacw7f3/744n9kX2BZL/X5QXZSNwON/sq6e/yP4W0d5zUdquaU4InSVWpIoI85gCK3zvzTmhlm + gL87bAoJ6Dh0e+KKHntKai8BENhKALbX9yoAqgEaS0wdOWbsPrsBO/Ij1WuZsqALF2a4hgo6863OfhNu + trciLCBg2JegJTOnSfwxbODkmTlOu34NAgC4qtYFSPmNkLFnpIAAEAbMc+nIvCpfA88JXt0mgCmgnu+Z + AvTJg36+6Fg9foHHEMD8GKlAyFE+1wXVESfFd82UmvUBKuNrAaraLWySsmN/G/AEIG+j1maHBeyg1IrB + JiqAMDuJZwigUQkgwkcALIHSWnPMrdiMAgjxZf+9SUBtBbYJwHzOhKniYzswOxC3m7H/pgIA8tgcZgiA + U4qzgsB+jiyOBYhBCJAsjQ0XtF0yUBZzV+dGy3p+yA+yk3n53oFt1ldePfhfPV0Xph2ui5G+8kTpVAJw + +QiAOYDWzJBJwDcz2LCkp7P72hNZeqfmNjemMGqgQ29LFWWDP9ImABJCqL6PEkC+mRGIw4BVtuaZ7L42 + 86SF2oNWwuxEoBnAQgJgaYyJJ+38y/MmvkBYeW6beMIAkDCpXhcoFauD9QadRvLHSu28OM0BaLw/f8Jz + e8FdMSfW97hqnudzCsAAfxL4F9ilP7xfOY4l4Cv1MQhgnkPfr4IEcAYI4O6Zk0KAYCWA5rQoVS08Hwpk + hls2+LlNL65efyOBaFp66wHGKQRA4shx6VrbhzkbkxJAhH1br1Af8E0OIVhvUtpmN/GYcMN8frt9L0fe + D6CF5MvW4U0zVfrzO9RxmxOCakcm7xvpkkGQ/nAVzk3jZZnf3D8+belwiWX5BwOd5Msrw5astazezm/9 + 5mBD5HHeEahDQ4AYzQEwBDAEEGorADOYx7T0hqpM19lklQDcPiXAiUKoBhhbGgIwCqBxZ4iCv2G7LR9z + TPnPK+U7mLjKN7G9gjjNBv+2cJ3dx1sG4+212zJ4wRsCaMt12PXzWPWCrbioGRvX4djq9cFSdVu41C1O + MmDmMN25ALmdvVfpb3tuXwlv7sRrzANoEtAGvjdvYBKDNvAXGCufFytlc1zq7SuYUJzrUQKomkM1gP2X + xknJL2aBAFiDB5i2hep3NARAsDs0f2FA6NDz06rNOKF6L4E6HwEE2AogaBIBsBEoVtea/KP8h4riQCCT + +Q9R4jDH2uMAONFqVvREDwIJ1b6Jq74nwrc9xQvVOAGJKQUGKgGwvVjLwzp/gEdGeGuy6vCPchp++oD1 + nnzN2t/mx9dJvxwdsqrbf2wVdPz0h+P1we8MlsMTF0dLt95hx9x4g006Or03b+iRbqb28ioB5gU6dDJJ + p292Xu/QXJ2gAxdUs+3xlQB2AMA6Cw57AsL1IqfnVo9FyZrr8Mn5qQrAO4LNDGThbLraP59twG/kLqWv + SYQRSA07AxVcdRvDpfLOUKk+wyT4FKzzTJ2+0gZv1cI4H4jVNGZ3GxDPN3K+CiGAeQ3Pz7ONr2uG3z3l + eN+xIIByhACVs6EM5jmlbKlLSn85E6pklnrvGoCxmrMD7YzQWr4BvlMrGR05Ljuccer5q6PX1tyBIcLJ + CoDZepX+OabyYkIABwgAqmm7kfx1m4zVKxnw82dok5VO2867Nk9OQPI9mOfBfzeYlypD+XM0XDCfG6if + S3JmGMeZnztIALy5S13Qmw82P3jlxznnW9a4vwJw8i/P1Vm/6/ud9UTvLxeNNjlfHKqKl96SKFMFKHLZ + g3QcGg+27DKdfGY4b7htkXrrb5P8i51EBA7b3DrSjRewtpQC+PXbuQ7SMl1rpuk4o2xtVfCbPvgOEkCO + qX83bZ3oYvPKV70AtX3WYaRurmMKAfDYxrRgJYCajWFSfjdUwBmx2ptfudBIc4YClZOASxLwWvWieAX8 + 54hhEri94Pc+R+9fwbLhpH2q5seDAKAGQACl82Kk7EwohAcQ928IUu9do3kATg1uT5tue38FvuYEXAAZ + yGw7vT4z92GaA2AVQB+zDMjBVXa+oFmnazMVAZ5HEkD91gD13F4CqNtIFWAmB23lPQkyIz+XdNQGrowo + bVRq2DRLpX/txun6nbWUyJGAaSZ3QOfA9uXhMhBWveO5yzqfmXtOZ5pljVT48fVlWL69p9j6+fCmsMGW + OUMjdUnSXxqpVYCeIqd9x50Y9fJMRJlGnmCfpGdcTwCb8QCeiVt02ePz6d051p2SX0G/g96fSiBUPVeL + Ti3mNAogb2IgDMMAJQBWELZFTOqAMx6I3rApLdwAxnsctwkcVgG0EzBMCaBqQ4iU3ROkbbgkgOpFCfDi + CTpX/2T5PgXI8z8P9gmQT31s9ner9C+zpX+FrRIqQQBlIICy2bFSglCgdDlUwEPBPgJgElBDgJ1mujQq + F5KisSj9TTx/mitQ+R9ihwAzlQAat4XqHZA67MQfCaBVidCooqb0UCUAcwzfA4TDadI3nq5jEdp3R30O + /L7HJO5tIab2z2M3zYBimWnyD1QP7D/Qz8J/CMU3VOWWpoZ5vUED2aHWsH8Y8JdmORVS7byhtFMaW79d + OVKfKAOlnOXH6SMA78SblHsm/g+zPTq3TfKKiTzG/BOTc5h6vukDMDGsyn9OagFvpwTAG13sNnkAHQvP + nvc8E8MzltULmKPgtkYC+OFqGvduDtU760wQAMcQxBrwU/7bJMAQoxb7Va4PltJ7g6V8iRMhQKxm4suZ + BLQVwOdADRB7Qf3fmY8cePzcWN9aY/9Jx5bhc0rmMyfgkWKEAiUrnVL6cBBCANNNx45AUwaEJ9UQwEj4 + Vr35iukDmCCAQM0BGE8egMcBSiI6ujIzQo9pxnu02OTRwhwKZLwSAI6rBulwKjLOR1gNBVCvd/WJmFJt + MPF/lDGQr94SfAM+l3Mq4LuSAFSNbQ80czrY3ZecQm6wNlGyW36YE9Vf9Q1rpNUPrC/NMtphXdJZ8NWS + lqvX7WmI+6y/FCAu8hKAWxN67NajVDSJwPCJen5atBLD5J5+1vTZHNThG1HmVDA27IB05x1mVAGE6WPK + dL3Q2eyiJODyEQBlfdNujn6LMKDfHKbruk1s8TWDiugxdchsrlcBuKQ123TEUQHUIE6uXB8kZb8MkYql + MVI1h115kONzGbc7NTtfhue0RHeixJ9nyICvG3P5ZL56fn3NvF46O8a3n2+b+8y3CWBevBQvAAGcg+3f + hmoOoBZgqto4Q78jCaA1I9LO/kf7CIDWhFBH+wUI/o02EZA42JbLTr7dNogZ97N7kv9TltkmAdTBW9es + nwElFKT5BkMA06Ru2wwoLEMe3hyAVwGQAJjkY66gcRPO+cZABX/VhtPM3ZZ5T0Dt5HRqvwFnAx6qTfj0 + yeabf2d1D/271dfox9WXhwDaLatbvrKr7ec3jzd6Puovi53IAejNOkxyj3+4mc+PSiBK21ebd0abWrBv + dh+XfX8+b2LQg4vJqfE+wd+0M1yHvzZsD9e4tpGJJDtmbeWwVxIBJyFlNx/IoBXxb9P2aJ3XjyW9xi2G + DHi/P75XC+LUFr3YHYYMsg0B0Bp3mYk3SADlD4RK1QooAHrrhczMe2wF4PHJeG8eYMLD8zWvZ/d6dc8k + b2+MJFBKErETg4YUAHRbARTPBSnMcUvhvGgpPhek84dwLQPWIKauglGl8FyaeRa9KsDhKwc2Ityq3Uzg + Q8ZvDFHg15I4NswwBJBuwOslAD2e4AcxayJ0ywxVADU4thphg5cAardOg7qwCWBy/G/PA8CcDSf9YPMR + CaAWx5EESAqcz5DnvsuehWigOFoGahLfv6/xrp9YvfIVq73aj6sv0yIVlvXLzutXjDan/H2g2nN8sDBG + +osRwxfPBwGw1g+5Dg/VtDsEF41p5NHbWvPOvSznMZufb+r4us4101p1Frg1wdeYFqSTczRtg5zfFqSS + Vh/vZL95lK+N1WskAMr61iwXjnXCW4XjGOO9eCHWMR+wE+HFbqeSRAvHHDB+zmIXII7LdkrD7mip2Roq + Fc/OkrJHAqXsbIe5OQcUQMUCAtal/flecGvvvu3ZKdkrEL/TuO19TEBTPdDKNL6P/9x2CcBewph/LpUG + CADkUDQvRopTPVJwUZhU/jFEqlT6h6hHrtXRgFEmoekjgGjbk0dpiZDqR4c1bzCen6FQNYfl7ubvBtjZ + LMTh05msgNjJw4wYkGyoKg2GDTUbAqRq3elSizWnSq+Hh2fPRFdRKj7blP+8g3r0nG6PNM1KmjOYqXkH + nvvmzd/QcK4uZ7Z0Z4ZKT16gDJfg+JolL13X8tASKccF1VLqB9WXaTnUMt96suO6mK6WJfuG6+Olj3MC + 8uYeRckIBdjvD6DyQgMBMOusg3s4yUeauXMvB+7oRJ6s4+c5fRNcTiaAum3sXYfn3xao4GcNnATQkm6y + +e3eGn62qWd3sIKgBAAFANXAY2q3GE9Uy1LWDlz86SwXulQBKAFkGgLgdj1IqhbEUb0BgPtDmJSe65Cq + eQnq3VmbL4NnLp/jnqjZL4ibFOfHGQKYZ/IFZXPcaj6AzzHe3UsIZTY5eF+jFZMA+Bzev3i+E6QQL4Xf + DpOKPwZKxYZp6o0Zk9dpN55p4jHAj/LF4fTODJcY9hDAJolnrxGL95fMl4Hy+fD2IGRVEJwP0ZQS2SfB + uQaMWpilYUD1umnYnqm3S2MVZaRqkTzffTlIO85M9a4kFKWqjZ2XZsxBoCYCWQXguW/cPE0nIWnJTZJu + NgzlR8poaaxU15zX9ZOmJxxj9ZdYVnuVH1RfpmVT643WL9p+O7O+5bzqkcY46SqdLUN5DAHc0l0aJX06 + KMgDwHH2mtCJHICO8zfZYB3CqzPzOiemuNZsPuv5RgFoCYuTS2wLVgJo5IQfNgF4vb+J4U0mvyUTXgwk + Ubc9xEcAdcyekwDgoSYTABNg9IBKAJkTBMAyYPWj4VJ8dqSUz/aoAiibG22AP2ciiVfh8/6xPsCbZOGE + EiDYi+HdaV4lUDKJGLyv0YrmMPMPgsD7Fi9gmJAohReHS8WjgVIJUE4mgOZ0k71nzK7NOwpmkwwkATDs + IfAJ5Op106V6/QxVQ915SSDeBCUAev62DCd+e7Rut6YbAmCooOBfP13fQ9UACIAl2a6COOktmaukwV4C + nRSE5z3DJADp+bX7bzMHME2zJzIJlDYmb0HSnAy0tTD2+GipR7IrL8qMrS6efnfVr/yA+rItV3dusKye + l75e1P6dp0ebPJ92VCw4PpbPcf7wCqVhCAPiAOp4bRphc44hAPbkh+hMPUwOtqvstwlAY3m7rg8CaN5t + x/1bJxOAea55t6nf02tPDgM0iZURDU+PGHhroIYAnOGHCcBadrWBAJp3xRi5yoFDzIBnGBncjLCiPi1C + Q4BKtgI/GiJF50ZoOY5AL50bY2L2uYYQKk8o6ZXOBmBnGyLwhgBeBeAFuA/4k4jA+xxNCWCuIYAiKoA5 + CVLwnQip+FPAJAIIVAJoYrmTd//JMD39BH6L/dhLAFQABHE1ZLx6dHbj7YpSsmtRr+2wyS9K4/NmEGA9 + w6YN043nBwl41QNJQCsyHGSUaXInmkfINBWBhp2zTNlvw+mm50BVxGlSxTzANt7lORjeP8B81+IEGS5P + +XRjxWW/tirka/9ekeUH1JdtSWrfbVmN8pXMjqtvHGmKf6+nMklG8hOltxAEUByuN30g4zNRNRECGAJg + P7neJ4CAz3fa01i5Jia4ZEdaeoTeA0+72LYGKfg5DFYvfg4M0sSdKd9NJgGvAqjdFqTeXxtneK8/xs4c + GJTGm5REmxxAth0Dw0wIEKUKoGpdEEAXLMUXRqu0p4cnAZRp2y5AT0Uwn4COwfNOANalSbvJHr7E6/GZ + 1DuBALzP+whAvT5jf+w3h8c7pWCOAyFBvBRcDgJ4IkhzAFUbsWaJTacEizKem1N7Zcea35QRreqIMwax + /KcKQGX8dBMCsJ2XidB0kyvgOebkrS2Z9rH4/aqaVDnMVALxhgJMojIEULIA+EmYOm4g0yQiWbVR6b/Z + m3A8XQmgeuPpUrud93gMka6sGZo74M1k+6oWvL218kffE1b/igv8gPrSLU1V1qftydamtuvPGW5Kenmg + Kkb683izTrYFR0uv1tkdeoE07w6fRAChNgFEme49lgvtmXo68iZubMESFwmgYWuEzoLbsD1CCaCWs9yw + Gy3L7mO38wDGGM86AfIoBQkJgB7TSwA1nCEoLUo75drssIE5g9bMGFUDRgGEKQGUweuWXBwDbx9vMvXz + CXyPlukqFiF+xzaTdTTG7CaBNyH5i6AIvHG/V+rr40mJv6JUl5qXCHhMsW67bAKIk8IrEQKsDZJqTlSy + IVgq1s3EOQgyIUAma/4OY7tJbDGmBLjFlP+0BAjCqF4/UxN5NZzQY2ekentVDNqq7VDVxPdoSovUZKsB + /Sw7hxCkj1lVoUJo0cYh/kduexyAQ/s6dM6GbWb0pSb/EP9zXbPpNA3HGC50ZgfqOR8si5DO6sVHHq64 + Z0llzdWWlVfjx9OXbmmpse7vfMS6sfOZxIHGuUPjNaHSxaHARQkyUBAr/ZyqO9dcaE12DkBH9qWZYbra + EJRrZrRtt8fle2e4ZT6AF5UJASLsQTDwMKzvgwiaOCCFXs/bxqudfLF2CBAFLxehIDHlqyAtidVtCbMV + gElY8UJuUiC4VAE02SFANcIFVgFK/nSalF3qMJ168zxSsRAAn0+5nzjFe08GthfcX2ResJsk30RY4H2+ + mDaHxMF8A16HqiiehxDgewhDnpgmFQAjy5MV6+Bd2VabHm3IK8OQANun9XfsogIIA4Dx+9dDAa0noEkE + IRrHTxBAhBKADrxKp5JwKQFQJVD+s/GoRonD2z9g9uV5U9XhHUWocwPyvwqy241nqQIwNhPEcSqIPACh + A1SbTr8WK6Olp0l95bKWOQU7Yi4vesyy8v0VgC/f0lprpbRttU5tLwpobjyrYrw2XDpLncc7i+fIcAHv + ERil9V4dmZYWMjG+X2/bFWHKeRzOWhBrj8s3g3va7XxAe1aMEgBr+Q0cWrotwkcAjdrRF+ur37fa4YBm + 9jOjteOPOQAzdj5EG2dqmBWnAthFj+WyQwhvCOAyCgCkpDmAZwOl+LFvSMl3IlX2a+lvARN0bN2dKukn + Z/gnx/WTM/sl80x8b5J8HvXyfJ7mfb4I71cIz891KUigaB5LgXFS8P1wKX0SBAAwkwAq18Mrc3ATPH5z + hkPzITRDAjH625nz4KxGtOp1ATq8WUmAE3qAANksZfIHkQpq5hN4fMN20wdBxcDGI5MHmK4KgM1VVBne + 3IFpOrKrAOlmDIDX8xP8ZhQhpxH7pt4uvDUrVpqoGhDyDVfgN1VdvMPKajzNkZ9uWRkZfjx9OcOAIstq + Pva1qsbLnxirj/2suzxCOormyjDvUlsYaSbszDLz7U8lgEjjidjKmufyJQG9PfpKBlnmgmQyyxAA5WmE + 5gDqtwerx2u1E4FazvMCmnI0jbfSmukbOFOzKRixKCQ0xwPsmsgBUI4SRJyCrAlgMFUAhADwmsVPnCol + l0dqfK+NOvNdSgClc4w3P5EATgT/5Mx+MUKIyaaAn2ueJ+gLIf0LU52SnxqjBMD8QeHcGJhbCn4QJiVP + ni6VG4JtAoCawbloTqeKcU6EALY17DRdjwS+lwSMMQkYaAiA8wV6CYC/na3XzH+oagrSyUdIAIz9VQVs + 5CQrUVol0HEDDAMy2BAUbv4rHwHM8oHfTAJKRXCqzgnZkeOWBlgvCKC/OuHDtKof32dtkq9aBd2Wtcs/ + B8CXlADqrffbzrXWt9x13WDj/PcGygOls5BDQc18fd06Rj9G20e9E3twuukmePOmHSbzrJl/OwnI+9pp + ToAdahxZtt2MZPMSQO0WxOj06IyBeRtwHwFETyKAGO2Eq97CrPlMDQGqN4ZiDRLYEqxJQOYktJxVnKJV + AEMAUUYBbDM5gOK1p0npVdEq+0vZucdEIJOAkxTAFymBEwmA4PZ5edu8z/nIQM1lCIBJQBxXMAeEwH1/ + BAJ46lRI/wCEJjM1PKndGm4IwP7uXu8/QQDBtuefNXWtVQAOAHKYPgDO1cjjmUvY7TDx/yYz/6BRDd5G + oiAlAA0XCHwShw4JjjAhAN7DlACna+nPqwKUDDZPAwFESzcHHuXEChvGmquX/PXuige+Z/1KvmL9fiUU + QI4fS1/Kpb7auq7lD9YtLb9dMtCw+Oh4RQBAlYw/OUw6dV6AODNTb3qkrxGI003rYB1O18VbgOWaRiAd + 458/QQDMATTuYG05UuNPVQBbIo1H51z/lK02+CcrAKoKEkDNlmnaNlvFjPamcA0BqjkoZWe4Dhgar1sm + 4/UrTBkwwzElBCDIip/8hpR9L1rKF5qYnKEA1UCJXa7Tpp35bNs1CT+V9POM3FdPPzd2wtPPdU8xL+BL + 5k+8F48hARTPiZOSVBDA7Bgp4Hv8NEKKn/6GlCMmL3+GBBCgBMBQRsOA3Wy2ohIw1gClRRBXPD3NDgEC + NR9Qvd4MJW7EMY0guybO3ceJQzUJyPdyaG6hasMMEOB0oxi0ChAwhQAa2dqdEeGbE4BlQE64yglDa9Z/ + 087+G2NIwKpCS3qs9GUGaffmcGG0VFYuH1xW9MS87vpUyyoftqzMXD+WvpRLY601t36DdVHD0wHVdRfm + DldGftpX5ID8R4yuN+2I09JeMwkgDUZAc2KPbeamFY1pgZpI6tKZgKI1adjOAUHZkfZtpiPM6DJ7Oux6 + KgFNCAab8QUc0ZZlSlqt2aYxpjUzWqsNdVs5FHU6vP8008yyORhkMNMeR2+SWPx+zIA3cSbhdFzErALA + e1YCaMVrvy4lP0Cseka89ugXa+weqyGAlurmxUvJggTE6R54a7ct6Rnjm3XRXJeCvEglvlNt4jElvyn5 + MelXZB9fgH0KEPcXzQH4sU8B3qPwxggpewrAx3eqfGaWzlfIfIhKeRBW825WAGIMAYAItJUXv7fqGSgg + kEUNCWBdgMr6Ot4bkPcL4IjJjDD15to7kB6lJcC6LVAKbN55Fp6cSoPyf/00nc6b91vg5C46HyDHA2SE + 24O9Iszsw0y4bjhValgC3GTKh5yApHkHx4HESk9GkHTlRkp/UewnaRWXbJ2ev2OmlbPbsrJy/QTwZV6+ + Vl9vWZWjX32g/pc3tNcu/OtA0UzpKPRIe0G8tGHdXBAj9bzItoEUtsLLbocn2c4Ze6bjwpkuHQCx3lgi + JwQykbXiIOnM5Br77+ZEkt+Ad5kGMxNS6G2nsebtw9szOb11qFqbWoS57RRHEm5lL/o3pW7D12GnwEAE + 62bp7EBtBIxmv8NUCjdw3gK2LKeFKdlUAThla/9L8q4NkPwFAPq8aMjxeIA2XirmJkjZ7CQpwnb+XNi8 + BF1zAE8JbZ5rwvC4iLH8bAdi/Rjdh48LUvE4xaPvUTw7zhCAqgWPZC+Kl9yFEfisOMmbGy3Zd4RI7WMO + qX4S3vwpABPeudFuhmpWVRVhynO7SJgOMwsSx+Iz+/9skG0E83SdlLNZb7UeZgZqpQcAyOZ+C806kg/n + aP1pUvfsNKl/BsB/+lSpffprOPf/KW1pM6Qjg3cUwvlON9O86d2Y8bnNUGWNINfKjadI+YbTsIbaWg8i + 2oD9tnGmIKdWCvrycGzp/FdWlzzwIyv32Ff/o7DdsnKK/SD6Ui99L1pycIF1dc3jCaUNl9YNlkV8xht2 + 8GYdgznh0s0YH0Bt41DSLZCG20+Vuu0Oqd0GyQkyqId3aMqJl+bcBGnN9Ugr24ezaQmQqh6pgWqoBnFU + b4uRKq63OtTq0zyQsfHSmBknDbDGLGxnJ2INS4+X6h0xUr45XCo2hcHgRTdGSukGbG9GGJEWK/XpcVKL + z65Jd0tNBtdOqd0VK1X4nNL1UVK+dpqUXReqkr9ydrjp9Et1SfmcKIDWAc8dDcA64MVh2FbJzgYeem0o + gEKohiJYHp6j5eP5AjzPdR6OL0iJBshBBDi2cHYUjo+QohS8V0qCFKfiuyZwNGCw5N3zH1KzNkRKn4mU + 4mfC9TdU7XBKXUa81KV78J3x/Xe78VvipG4Xztd2l1RudkjZhij8DoeUroOtD8djhAY4rgG/25gH5pYG + /Hb+BzU7HHquytaHSNmzYQg3sP1suJSvD5Pa7SyZuqUpy43za9b1GbR4kGccQivI+nUgGpBG9TOngWhP + g+L4T2nY8jUQxCwFP1Vaf0Hwp7sqv1u2sOAZ95/rz7es0g/8+PnyE4BYN9Q8YLmrMv9rU91P7u6tTn2z + uyASMX2UDMIb9+S4Vc636i2j4cF2TJe6bcw4M94Ol9qd8MDsRwcBtGDfluxYac7mOh4AxwW+MwoXGPd1 + SNXmCN2uAohrcHwjLmA1JQASAS9otxJA7U4XwI6LGN6ojDP8sLkHMriC1QA2q0Au10EJ1DDuhxqohdXt + ipHq7QROsJSunSllNzMO90g5AFlM2a7JuTCAOAJgjpSC+VHw3CCE1CjJB3jzNJMPo3zXfWMBdhDAbNcJ + RlJwSO6caFgkLEJy5oTjWBBLYoIUJIEY4uMk/4wIyb3/61L1VKCUwIoRCpRtCAQB4Lzhu9ftigaZ4bvj + e9ftduE3gxzhjfk7S54NlNJnQRzP4rc8OxOeGSoAIG8AWTQA8A27XDCOgIRCS4vR5Gc54v0y7Fv2DNZP + zcJ2qFRtipT6nU6ESLE4r9iXOQQmG3U7BuQQDo8fIJXPzoBaIAkEqEqp2QjltuMUaQH5N7NpCwqvtTTh + 9QdKr7/V2l3+9cU5j8L7F/rx86Vfyqstq6rWkjrL+ln1H+c0VS9v7S+KPs6bg/TAG3dkJwPY8ObwsHU7 + cEFtN1NbNeg0XWaWmaZdwb66snemGu8oN52nz56aSjvS2NG33gw3ZW86ZXArM9kIMzj0mJN6NEOWNuyI + 0EagcnijCvbCr5+mSarq9d9AnH+6jjak7G+Ah6rbxe8QgLiabbZMtH1dCtfOkKI74iV7YQLkulNyZ3sk + a06cZM4Lk6z54ZK9IEpyQQD5c+jJoQYQ0xemAPTJLjVu0/JTXGp5STFq+ckkiFi8hwvvFSMZUBHpc6Mk + A4SSRVJIwmcmuSQ7IVkyV7gl42EA8in8jrX/KRVPQg1sPFXqd8zU/EnjTg7QMdvstaiHxK9a/+9S8fS/ + wf5LKp/5prFn/1NqN5khuWZmJm9ZlutAvZknX6989mtS+fS/S9XT3wTpnIL3OFWnEWvaYWZ05mxMTbs4 + oxCNk7Uy6/81hExfwf447qkwqYRVgHgq2XfB5CD+0/qcOOktmHG8sPLc1qVFTy6wnhHLKiixrGx//f9/ + x1JVasVUZlpBlYWnPFvz8/uGypzvteYh/s9LkSbI+sbcOHhzSEd4oMYtnKwD4ITcrOakFZzmGiqAXqWR + jSwZ7MpjYw5Cg0yX1MPL1VDKswa+gePhsb0uUGv1bNttgPdqUo/mhEeiR3NJHT3aDsjSLeFSvG4GJDGr + D3E6yq8Mj6s2I65GaFGHmLluFw3eH7F0HTxrNVRJGWLmvLVfl9L7QiR3WRjAHQrvHiXZiOHzVbqzlOeR + wmTE8YluKU6MQ1zvklx48Fy8npMMckhxqHGblp0UKdmJEbrOwfPZyW48jxAB75GXhDXeJzcRaiBlmmSn + TJccqIDMc7H/b/A9npwhJWtPl9Kn8N03hep3p3Lid65n+y5bn3dG2999GvY7FTZdyp6epd68fH2g9lBw + OLT+bqx53hr4+xlibQnTKkPpU98E2UwHCQRKBRRA6dMz8R+FQwGAUHGOGnY7VDE00tKoNqCoQLCV+MxK + SP+yp0/De0yT8mcDpIr/c1q8hhot7Bgs8bx3f8Wa3/xXQfH0mMJ0yyos8uPmf9UiYuUUX2itKbtzUXvV + 4rGuIkj6PEj5nEhpzmGd3iVtaS5p3QLpqGW5UM2413CmWw77xUXcYJOAMaeu2ZxTs4Wx6CyQwCwdq1+J + C6xyHYxz3W2P1Ik+6gEAvagpjbHNi7wKgCjFhV25iTesRHy/LlSbaio24HMRhtTt4HEgmTSu+ThaQ4vy + dcGSu/a/pOj+mZJ9VpjKfJbosuZ41JsXqGf3wFsTvB54/ATJmY3XEc/TMkEW3u305AhJT4mUDNjupHB9 + nJESJZkJMerpc0ECuUmxkpPgkqyEcMlMno7XZ2ENArgQZPHI16Vs7SwQwEx8d5DZRrY0m+9KADekIQzY + EaUj7io3hioAi5/4JvafjjBmlh5DQqvl/IgE/3azbuD5wnHcrt4YrmRRshYgxueU47jSJ2ZI6TMcd2D2 + rd8Zjs/CNtXVzhhtRqrcALX09OlaNWHZsQyqo+Lpb2gHYQPOY8uuOCXnjrzo40WlKwYuK3houVX54Ves + 0g7If3/m/3/dclHlk1Z0ZeH0rMrLtvWWxH3clsMs/QxI+ZlmKmjWq+EZGuBV6rQ/H558E2v1p5u+f97T + Pj3SrG2r17ZeyMoN06XimVN9ra2sU1dtnGWXxNj+69B1Q1q4kkkjLlp29ZE0yp6ebmJaAuIJeih2CLIi + gTgYVs8pxEgkOxDTbo2G1wyUnCe/IfkPzZD08yKMZwdIM5ITsc16PSQ6VEAmiCAjxS1ZqR7ZDdDvng2Q + zzbrXamRut6ZGiFpIJA0e3snX8M+mckgCBrUANcZiTguMRwWZo5FGJF5KcKG354i5U8gpn98luYlCFZ+ + R37fRgCRVofvX7MlCr8VMf8Tp2NfgHFtALYDQQYzIMk5o1KU6avQqdW8FqajLKtBjGVPzlLwV6wNxOdh + +wnTeETCaOBNRrYz5OB8DCDqbU6EDBH6H1SAcCqenC7lINbyZ07Be50i9Ru+Kc1bA6VtR5jOBNVZ4Hr/ + 0cLvr7UKmmamFm63rFx/7P+/coks32FZ5fKVa8vvvbKpbMFzPfluM96cXXZZkIyZHinf4ZIqeLDKzaFS + ASlegfi+nN16bPTZFauSsZ4yfleMrut3uTRDXbYxWIqfgVeDpC0FQEufCpIibFcgnKhlVjwtFjGnS6px + gdYS/DudUrmVCb0QKXw6CDE9jl8bLoVPwqM/EyEVW6AItsfhu8Ths2Nh+JztbhwDSb8OMh4AKngI3vhb + kO4AaEEiPX8yQgGHJu6yAer0OQR5uFpWMuV+jFo25HtWIsCdBDWQEOWzDNsyIfUzU4KgFIxlpAaDQIJk + V3KYZMbGS3pCLAzHX4Hv+of/kNLHviG5jwVKwdoQnCueP3zf7TFSjd9ds92J7Vgph7Li78p/PFgKHsPv + xTof63z87tINUEMELfbneWGik1YDwqvYEiElT+NzngiWwid4HD7n8QAp0s+KwH7433ZwHe47r1U4R2Xr + IqEuAqEajBXjcwqfjIF6Ygu3UzsO63cHS3121PHc4otGv1PwyIVWjnxlekE25H+lHyz/K5fiEquoYKW1 + rOCRsJ3ll25rKlrwXmt2ovaQs/OsPgux6+4QzThXbIKngQenjK9kkw47/OChGMfXA/y1iG9rObPPzkit + BFRsDpKSZ09XiVv2NOPVWVLEbcj56u3RmgGvYcVgJyQyTcuHEVK2HkTx5DRc3IyjQ7EdJAXwduWbIhU4 + VQC+lhi3sdTokMotDilZHyFZa8Mk+5EA2XWlS713dmIw4nLjudMRDtB2I97fnQx5jxg/IzEGwHapZSQ4 + JT0+Ri0j0Qlz2WuvOWR3PECfEIKwIFR2pUSo108DuWTFe2QXyGNnEl77QTiAfyoAPU0KnpgJgAfhe0eb + cug2fv8InDPG9S4AOVpf534Fj02Xgj/NAAHMwDkK0N9K0q3iYB+AuYoDnmB8j5L1M/X8FEEZFT5+Oo79 + ploJzhFzKPyM6u3MmUAt8L/YQfKOBmmAiNfS80MtPDkTFgiVxduqhUFlRGtuojYTYULhnLd/X/iztfGZ + zwQ9lnU1pH+ZHyf/ewkAcV1JqWUVvf/V28rvWlFcfHZGQ96851sy495qyIx4pzYz8N3a3dPeq9we/n7J + ppD3izYGYh3M7feKNwW/W7ot9N3KtJj3qnfFvle1KxoW9V4lDc+VbQ1/r2j9rPcLn575fuFTsz4ofHLW + B3lPTX+vYH3wuyVbot+t2OF4t3wn1mlR7+KY96t2Oj4o3+r4Z9GGsA/yn5rxQe4T09/PfSLk/dwnZ72X + 9eTp7+ZvCHu3ZHvsx6U7PMdKt7s/Ldnm+LR4W/SnBZujP8tZH/Hpzqc9x7b9IfKTTT9K+nTdopjjO2bP + PL5rdvBnO1Ldx7bNTji2PTX+2I4U97FdSa5P05NiP9uZ6IZ51HZge0eC26x1O9ZYovs4TLYj3t+e4Di+ + A0SxPTn2+LZU9/EtqXHHN2O9LS7q+Iak0M82zgv5bOO1MZ9ueyrsw7THw9/OfPzUf+Q+G/RB8Vbnx6Xb + nZ+UbIv6pGR7+CdlO6M/Ltvh+rhwc/S/sp8JeD/rienvZdMeC3g/87Hp7+U8NeP9os1R/yrbGYPfGvlJ + 6Y6oYyXbo44Vb436pHhL5Me562Z+kP3EN9/JfvyUt3Oe+Oa7sPdy1p72QcEzwR+VbI3BuXEcK9sZeawi + LfrT6p2Ojyq3R/6zeFPkP/Ofmvlhwdrp/yqEFTxx2oeFT5z+z5InT/+gakPg+7Xb9D97qyw74c85xSuy + rsj/zRIr5+2vWrnVIIDNfpz8b08GPlj9c+uPu771b/cU/XDaD4vuTLqu4JcX35B/z/Wr8++8487cO351 + V+bqB27ffdODt+284aHb0258+I60mx6+beeND92evurBu7JWP3hPzi0P/iJ39QO0u3NW/frunDUP3Jmx + +kHs+9At265/+JYt1z1yy+brfrNq63UP3Lz9+l/duuumX92RefOv7sxe/au7sm++/57sVQ/ek7n6N3el + r/ntHWk3/+62bTf9ds2W6x+5ecv1D6/eev2DN2+79v6bd1x//60Za9bekX37xjuzb9tyR9YtW2/PvCVj + TeYtZat231J907brK1Y9c0Xtmrt+uuf2q655+5cXnffZry845+MHLjz3rYcuOu8fv7nwrLd+f86Z7z26 + fPGHjy9d9PETi2d/vHbJ7I+fXDrnE9pasz62dunsY08sSf2Ehm2hPbZktjyyYrE8ctaZ8si5K+Xh88+S + B84/R351wdnHHzz33GO/uPC89++57NI/r7r7+33Xbv5+5vXrr/3j9Zt/9uDqnTf+4bZ0fOesNU/dnnXz + 2tuzbnj8jqwbH78tc9Vja3bf9MdV26//Hc7J71dvueFPq7fe9PiqrTc8dvP2G/50S/qqx+7IvvnJO7JW + P3NH5pr1tNszbll36+6bn8R7Pnrzlp//7uZNP31k9eaf/Xb1lp/j+GsfvXX7jU/dkXnbxtszb910R/bq + TXflrNl8d+bNT9yVftODt6Td+ODqrT//3a1br3vm1i3XbVqz6WePr9567QPX7rzxnhvSb73lZ5n3XHdl + 1q++d3b2A+cuy/l1VGLm0/9uPXvYsnZlgQD8t//6373kpVnWbrHuK7zWKi1YYVk7xXKmbfiPBTsembZ8 + y30BF228J/jSjWtCv7P+5tDLnr05jHb5+jVhl61bE3bp+tWhl25YRQv5zibaTSEXr78h5NKNN4d8Z8Oa + 0MvX3xJ2xfpbwq9ad1vEd9fdHnHZhtvDL11/S+glG24JvXTTmpBLN90ccsnGVSGXbbgx9PINq/i+4Veu + uyX8ymdvjbgCdvm628KvWH9b+GV4n2+vuznk2xvWBFyy8ZaAi9evCrhkw6rAyzatjrhs8+q472y8Jfmq + DTek/OTpq8+45de3XXL/Tbfe8Puf/PieP/zoh/f9/vvfve+P11x172NXX37v2isuvvepb19w39MXnnvf + k+cv+9WTF5z5q6cvWPbLZ85f9stnz19637MXLLvvmfOW3Pf0OWfQ7n323MX3PoP1U1g/evEF9/7pOxff + +9iVl933p+9dcd8fvnfFvb+75sp7/nT11Xc9/INrbr3/pz/76Q33rzr/qi03zL5q/e2OyzfdEfqdjbcF + Xbzu5lkXrbtxxkUbbpz+7Y03zLh0440zL9m0atbFG/Fb1t8SeNm6W4OuWHdbCI4Ju2rjnWFXbLoj5LIt + twRdsummgIs3YL/1q2ZdQsNvxznAb18TeOX6W4OvfHZNMM5VCO0KbF+xbk3wZRtvDb50w5rASzeuCrh0 + 400Bl62/KfSy9auivrNhdRT+N8f31t+S8L11t6R+99nV7is33hZ19uZ7ws/cdG9o8saHgkK3PTXDStt1 + irW99t8uyrzfstLFsjLz/Pj4/5slZ6P10bN3WdOxnr/rT9ayHQ9YZ2+527p4053W5Rtvtq5Yf5N1xbPG + rlp/s3XlulXW5Xju8g03ql2x6Qa1yzZch/2x34ZV1pXY77vrV1vfW7fGunrdLXiPW63L8PiyDTdbl2/C + 8Ztusi7beIN15YbrravwHnzf765bbX332TXWVc+stq7CcVetX4PjVluXrrvJ+g6+B7/LZevNZ16J97hi + 8yq8Bz4D7/N+lCqar+DStdZddYW1+YrvWM9ccYn16DVXWo9dfZn15OXftjZceI61c/liqyI50mpzz7LK + 5sZYmUuSrbTlc6y0FXOtzSvnWxux3og1CMACAVggAOtPF19grb34Iuvp73zbeorv+d3Lrd9dc4UFArB+ + f/VV1uPf+571x1u+Y/1q/TnWz57Bb9p0q3XFxjX4rjdZl66/zrp0w7X4/j/HOcL54XnaiO+t5xG/E7/3 + apyb7228zboKx125Bb9z8/V6bi5bbwwEaX1n3Y3YXqXn9LvPrsJ5vVmN27Qr8XlX4H2vwHFXbLwe5x/f + Q8/VKv3fbnjmZ9adT37P+sEz11vf3XiLdd7mO62zNt1tzd14v+XY9pj19TTI/bQd8Pzb/HjwL1+ipcXc + pvq/xg9Y//XKXyzr0FHzfFapZWUUY00rOcHwWnYZvFyJ2ce7/tx+Jea9+HqmfRzN+5gSOR3HZfAxXyub + sJMs1Dupv59/8S//XxPA2H7rP1/6s2UdQPza1WtZw3v858a/+Bf/4l/8i3/xL/7Fv/gX/+Jf/It/8S/+ + xb/4F//iX/yLf/Ev/sW/+Bf/4l/8i3/xL/7Fv/gX/+Jf/It/8S/+xb/4F//iX/yLf/Ev/sW/+Bf/4l/8 + i3/xL/7Fv/gX/+Jf/It/8S/+xb/4F//iX/yLf/Ev/sW/+Bf/4l/8i3/xL/7lS7D8P/W+joR+VmDzAAAA + AElFTkSuQmCC + + + \ No newline at end of file diff --git a/SwitchGiftDataManager.WinForm/SwitchGiftDataManager.WinForm.csproj b/SwitchGiftDataManager.WinForm/SwitchGiftDataManager.WinForm.csproj new file mode 100644 index 0000000..032a045 --- /dev/null +++ b/SwitchGiftDataManager.WinForm/SwitchGiftDataManager.WinForm.csproj @@ -0,0 +1,83 @@ + + + + WinExe + net6.0-windows + enable + true + enable + Resources\icon.png + Resources\icon.ico + Manu098vm + $(MSBuildProjectName) + Copyright (C) 2022 Manu098vm + README.md + pokemon; mystery gift; wondercard; reader; nintendo; bcat; event injection; + LICENSE + Project Pokémon + https://github.com/Manu098vm/Switch-Gift-Data-Manager + https://github.com/Manu098vm/Switch-Gift-Data-Manager + + + + embedded + True + + + + embedded + + + + + True + \ + + + + + + True + \ + + + + + + True + True + + + + + + True + True + Resources.resx + + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + + + True + \ + + + + + + + + + + + + + \ No newline at end of file diff --git a/SwitchGiftDataManager.WinForm/SwitchGiftDataManager.WinForm.csproj.user b/SwitchGiftDataManager.WinForm/SwitchGiftDataManager.WinForm.csproj.user new file mode 100644 index 0000000..9366252 --- /dev/null +++ b/SwitchGiftDataManager.WinForm/SwitchGiftDataManager.WinForm.csproj.user @@ -0,0 +1,11 @@ + + + + + Form + + + Form + + + \ No newline at end of file diff --git a/SwitchGiftDataManager.sln b/SwitchGiftDataManager.sln new file mode 100644 index 0000000..df7d369 --- /dev/null +++ b/SwitchGiftDataManager.sln @@ -0,0 +1,47 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.2.32602.215 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SwitchGiftDataManager.Core", "SwitchGiftDataManager.Core\SwitchGiftDataManager.Core.csproj", "{40C66FF0-A353-46EA-B958-24586D4DD19D}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SwitchGiftDataManager.WinForm", "SwitchGiftDataManager.WinForm\SwitchGiftDataManager.WinForm.csproj", "{6716CC9C-FE4B-4CF6-B02D-CC47182A2EC8}" + ProjectSection(ProjectDependencies) = postProject + {40C66FF0-A353-46EA-B958-24586D4DD19D} = {40C66FF0-A353-46EA-B958-24586D4DD19D} + EndProjectSection +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{C228A89E-40A6-44D8-B4D2-E86AE8E84C3F}" + ProjectSection(SolutionItems) = preProject + .editorconfig = .editorconfig + LICENSE = LICENSE + README.md = README.md + EndProjectSection +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SwitchGiftDataManager.CommandLine", "SwitchGiftDataManager.CommandLine\SwitchGiftDataManager.CommandLine.csproj", "{61B325BA-48B8-425F-BA22-505453B8A9A9}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {40C66FF0-A353-46EA-B958-24586D4DD19D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {40C66FF0-A353-46EA-B958-24586D4DD19D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {40C66FF0-A353-46EA-B958-24586D4DD19D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {40C66FF0-A353-46EA-B958-24586D4DD19D}.Release|Any CPU.Build.0 = Release|Any CPU + {6716CC9C-FE4B-4CF6-B02D-CC47182A2EC8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6716CC9C-FE4B-4CF6-B02D-CC47182A2EC8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6716CC9C-FE4B-4CF6-B02D-CC47182A2EC8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6716CC9C-FE4B-4CF6-B02D-CC47182A2EC8}.Release|Any CPU.Build.0 = Release|Any CPU + {61B325BA-48B8-425F-BA22-505453B8A9A9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {61B325BA-48B8-425F-BA22-505453B8A9A9}.Debug|Any CPU.Build.0 = Debug|Any CPU + {61B325BA-48B8-425F-BA22-505453B8A9A9}.Release|Any CPU.ActiveCfg = Release|Any CPU + {61B325BA-48B8-425F-BA22-505453B8A9A9}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {01702004-A955-4F4E-851F-66A6BE55BB42} + EndGlobalSection +EndGlobal