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 0000000..6a0df95 Binary files /dev/null and b/SwitchGiftDataManager.WinForm/Resources/icon.ico differ diff --git a/SwitchGiftDataManager.WinForm/Resources/icon.png b/SwitchGiftDataManager.WinForm/Resources/icon.png new file mode 100644 index 0000000..62d9ece Binary files /dev/null and b/SwitchGiftDataManager.WinForm/Resources/icon.png differ diff --git a/SwitchGiftDataManager.WinForm/SaveWindow.Designer.cs b/SwitchGiftDataManager.WinForm/SaveWindow.Designer.cs new file mode 100644 index 0000000..72b9547 --- /dev/null +++ b/SwitchGiftDataManager.WinForm/SaveWindow.Designer.cs @@ -0,0 +1,201 @@ +namespace SwitchGiftDataManager.WinForm +{ + partial class SaveWindow + { + /// + /// 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