From 041ea99c61851d4c9f12ccc771d4ef93cc7c0897 Mon Sep 17 00:00:00 2001 From: Vinay Pamnani Date: Thu, 5 Oct 2017 18:26:07 -0400 Subject: [PATCH] Add project files. --- .gitattributes | 63 + .gitignore | 245 ++ WmiExplorer.sln | 24 + WmiExplorer/ChangeLog.txt | 30 + WmiExplorer/Classes/Enums.cs | 43 + WmiExplorer/Classes/Helpers.cs | 58 + WmiExplorer/Classes/ListViewColumnSorter.cs | 103 + WmiExplorer/Classes/ListViewExtensions.cs | 128 + .../ManagementBaseObjectPropertyDescriptor.cs | 236 ++ WmiExplorer/Classes/ManagementBaseObjectW.cs | 339 ++ .../Classes/ManagementBaseObjectWConverter.cs | 52 + WmiExplorer/Classes/ManagementObjectW.cs | 17 + .../Classes/MouseWheelMessageFilter.cs | 34 + WmiExplorer/Classes/NativeMethods.cs | 30 + WmiExplorer/Classes/ObserverHandler.cs | 139 + .../Classes/ToolStripItemCollectionSorter.cs | 33 + WmiExplorer/Classes/Utilities.cs | 216 ++ WmiExplorer/Classes/WindowPlacement.cs | 111 + WmiExplorer/Classes/WmiClass.cs | 185 + WmiExplorer/Classes/WmiInstance.cs | 50 + WmiExplorer/Classes/WmiMethod.cs | 42 + WmiExplorer/Classes/WmiNamespace.cs | 179 + WmiExplorer/Classes/WmiNode.cs | 68 + WmiExplorer/Forms/Form_About.Designer.cs | 173 + WmiExplorer/Forms/Form_About.cs | 100 + WmiExplorer/Forms/Form_About.resx | 610 +++ WmiExplorer/Forms/Form_ConnectAs.Designer.cs | 169 + WmiExplorer/Forms/Form_ConnectAs.cs | 63 + WmiExplorer/Forms/Form_ConnectAs.resx | 120 + .../Forms/Form_DisplayText.Designer.cs | 101 + WmiExplorer/Forms/Form_DisplayText.cs | 28 + WmiExplorer/Forms/Form_DisplayText.resx | 120 + WmiExplorer/Forms/Form_ExecMethod.Designer.cs | 224 ++ WmiExplorer/Forms/Form_ExecMethod.cs | 324 ++ WmiExplorer/Forms/Form_ExecMethod.resx | 123 + WmiExplorer/Forms/Form_Settings.Designer.cs | 254 ++ WmiExplorer/Forms/Form_Settings.cs | 58 + WmiExplorer/Forms/Form_Settings.resx | 120 + WmiExplorer/Forms/Form_ShowMof.Designer.cs | 89 + WmiExplorer/Forms/Form_ShowMof.cs | 26 + WmiExplorer/Forms/Form_ShowMof.resx | 120 + WmiExplorer/Forms/Form_Update.Designer.cs | 87 + WmiExplorer/Forms/Form_Update.cs | 43 + WmiExplorer/Forms/Form_Update.resx | 120 + WmiExplorer/Icons/Database CMYK .ico | Bin 0 -> 353118 bytes .../Icojam-Blue-Bits-Database-search.ico | Bin 0 -> 193853 bytes WmiExplorer/Program.cs | 26 + WmiExplorer/Properties/AssemblyInfo.cs | 36 + WmiExplorer/Properties/Resources.Designer.cs | 63 + WmiExplorer/Properties/Resources.resx | 120 + WmiExplorer/Properties/Settings.Designer.cs | 260 ++ WmiExplorer/Properties/Settings.settings | 66 + WmiExplorer/Sms/SmsClient.cs | 69 + WmiExplorer/Sms/SmsClientAction.cs | 31 + WmiExplorer/Sms/SmsClientActions.cs | 213 ++ WmiExplorer/Updater/Update.cs | 17 + WmiExplorer/Updater/UpdateEnums.cs | 21 + WmiExplorer/Updater/UpdaterService.cs | 93 + WmiExplorer/WmiExplorer.Designer.cs | 2072 ++++++++++ WmiExplorer/WmiExplorer.Functions.Designer.cs | 2769 ++++++++++++++ WmiExplorer/WmiExplorer.cs | 1623 ++++++++ WmiExplorer/WmiExplorer.csproj | 237 ++ WmiExplorer/WmiExplorer.resx | 3383 +++++++++++++++++ WmiExplorer/app.config | 76 + WmiExplorer/releases.azure.xml | 17 + WmiExplorer/releases.xml | 17 + 66 files changed, 16706 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 WmiExplorer.sln create mode 100644 WmiExplorer/ChangeLog.txt create mode 100644 WmiExplorer/Classes/Enums.cs create mode 100644 WmiExplorer/Classes/Helpers.cs create mode 100644 WmiExplorer/Classes/ListViewColumnSorter.cs create mode 100644 WmiExplorer/Classes/ListViewExtensions.cs create mode 100644 WmiExplorer/Classes/ManagementBaseObjectPropertyDescriptor.cs create mode 100644 WmiExplorer/Classes/ManagementBaseObjectW.cs create mode 100644 WmiExplorer/Classes/ManagementBaseObjectWConverter.cs create mode 100644 WmiExplorer/Classes/ManagementObjectW.cs create mode 100644 WmiExplorer/Classes/MouseWheelMessageFilter.cs create mode 100644 WmiExplorer/Classes/NativeMethods.cs create mode 100644 WmiExplorer/Classes/ObserverHandler.cs create mode 100644 WmiExplorer/Classes/ToolStripItemCollectionSorter.cs create mode 100644 WmiExplorer/Classes/Utilities.cs create mode 100644 WmiExplorer/Classes/WindowPlacement.cs create mode 100644 WmiExplorer/Classes/WmiClass.cs create mode 100644 WmiExplorer/Classes/WmiInstance.cs create mode 100644 WmiExplorer/Classes/WmiMethod.cs create mode 100644 WmiExplorer/Classes/WmiNamespace.cs create mode 100644 WmiExplorer/Classes/WmiNode.cs create mode 100644 WmiExplorer/Forms/Form_About.Designer.cs create mode 100644 WmiExplorer/Forms/Form_About.cs create mode 100644 WmiExplorer/Forms/Form_About.resx create mode 100644 WmiExplorer/Forms/Form_ConnectAs.Designer.cs create mode 100644 WmiExplorer/Forms/Form_ConnectAs.cs create mode 100644 WmiExplorer/Forms/Form_ConnectAs.resx create mode 100644 WmiExplorer/Forms/Form_DisplayText.Designer.cs create mode 100644 WmiExplorer/Forms/Form_DisplayText.cs create mode 100644 WmiExplorer/Forms/Form_DisplayText.resx create mode 100644 WmiExplorer/Forms/Form_ExecMethod.Designer.cs create mode 100644 WmiExplorer/Forms/Form_ExecMethod.cs create mode 100644 WmiExplorer/Forms/Form_ExecMethod.resx create mode 100644 WmiExplorer/Forms/Form_Settings.Designer.cs create mode 100644 WmiExplorer/Forms/Form_Settings.cs create mode 100644 WmiExplorer/Forms/Form_Settings.resx create mode 100644 WmiExplorer/Forms/Form_ShowMof.Designer.cs create mode 100644 WmiExplorer/Forms/Form_ShowMof.cs create mode 100644 WmiExplorer/Forms/Form_ShowMof.resx create mode 100644 WmiExplorer/Forms/Form_Update.Designer.cs create mode 100644 WmiExplorer/Forms/Form_Update.cs create mode 100644 WmiExplorer/Forms/Form_Update.resx create mode 100644 WmiExplorer/Icons/Database CMYK .ico create mode 100644 WmiExplorer/Icons/Icojam-Blue-Bits-Database-search.ico create mode 100644 WmiExplorer/Program.cs create mode 100644 WmiExplorer/Properties/AssemblyInfo.cs create mode 100644 WmiExplorer/Properties/Resources.Designer.cs create mode 100644 WmiExplorer/Properties/Resources.resx create mode 100644 WmiExplorer/Properties/Settings.Designer.cs create mode 100644 WmiExplorer/Properties/Settings.settings create mode 100644 WmiExplorer/Sms/SmsClient.cs create mode 100644 WmiExplorer/Sms/SmsClientAction.cs create mode 100644 WmiExplorer/Sms/SmsClientActions.cs create mode 100644 WmiExplorer/Updater/Update.cs create mode 100644 WmiExplorer/Updater/UpdateEnums.cs create mode 100644 WmiExplorer/Updater/UpdaterService.cs create mode 100644 WmiExplorer/WmiExplorer.Designer.cs create mode 100644 WmiExplorer/WmiExplorer.Functions.Designer.cs create mode 100644 WmiExplorer/WmiExplorer.cs create mode 100644 WmiExplorer/WmiExplorer.csproj create mode 100644 WmiExplorer/WmiExplorer.resx create mode 100644 WmiExplorer/app.config create mode 100644 WmiExplorer/releases.azure.xml create mode 100644 WmiExplorer/releases.xml diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..1ff0c42 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,63 @@ +############################################################################### +# Set default behavior to automatically normalize line endings. +############################################################################### +* text=auto + +############################################################################### +# Set default behavior for command prompt diff. +# +# This is need for earlier builds of msysgit that does not have it on by +# default for csharp files. +# Note: This is only used by command line +############################################################################### +#*.cs diff=csharp + +############################################################################### +# Set the merge driver for project and solution files +# +# Merging from the command prompt will add diff markers to the files if there +# are conflicts (Merging from VS is not affected by the settings below, in VS +# the diff markers are never inserted). Diff markers may cause the following +# file extensions to fail to load in VS. An alternative would be to treat +# these files as binary and thus will always conflict and require user +# intervention with every merge. To do so, just uncomment the entries below +############################################################################### +#*.sln merge=binary +#*.csproj merge=binary +#*.vbproj merge=binary +#*.vcxproj merge=binary +#*.vcproj merge=binary +#*.dbproj merge=binary +#*.fsproj merge=binary +#*.lsproj merge=binary +#*.wixproj merge=binary +#*.modelproj merge=binary +#*.sqlproj merge=binary +#*.wwaproj merge=binary + +############################################################################### +# behavior for image files +# +# image files are treated as binary by default. +############################################################################### +#*.jpg binary +#*.png binary +#*.gif binary + +############################################################################### +# diff behavior for common document formats +# +# Convert binary document formats to text before diffing them. This feature +# is only available from the command line. Turn it on by uncommenting the +# entries below. +############################################################################### +#*.doc diff=astextplain +#*.DOC diff=astextplain +#*.docx diff=astextplain +#*.DOCX diff=astextplain +#*.dot diff=astextplain +#*.DOT diff=astextplain +#*.pdf diff=astextplain +#*.PDF diff=astextplain +#*.rtf diff=astextplain +#*.RTF diff=astextplain diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3a2238d --- /dev/null +++ b/.gitignore @@ -0,0 +1,245 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +[Xx]64/ +[Xx]86/ +[Bb]uild/ +bld/ +[Bb]in/ +[Oo]bj/ + +# Visual Studio 2015 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUNIT +*.VisualState.xml +TestResult.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# DNX +project.lock.json +artifacts/ + +*_i.c +*_p.c +*_i.h +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# JustCode is a .NET coding add-in +.JustCode + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml + +# TODO: Un-comment the next line if you do not want to checkin +# your web deploy settings because they may include unencrypted +# passwords +#*.pubxml +*.publishproj + +# NuGet Packages +*.nupkg +# The packages folder can be ignored because of Package Restore +**/packages/* +# except build/, which is used as an MSBuild target. +!**/packages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/packages/repositories.config +# NuGet v3's project.json files produces more ignoreable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Microsoft Azure ApplicationInsights config file +ApplicationInsights.config + +# Windows Store app package directory +AppPackages/ +BundleArtifacts/ + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ + +# Others +ClientBin/ +[Ss]tyle[Cc]op.* +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.pfx +*.publishsettings +node_modules/ +orleans.codegen.cs + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm + +# SQL Server files +*.mdf +*.ldf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# LightSwitch generated files +GeneratedArtifacts/ +ModelManifest.xml + +# Paket dependency manager +.paket/paket.exe + +# FAKE - F# Make +.fake/ \ No newline at end of file diff --git a/WmiExplorer.sln b/WmiExplorer.sln new file mode 100644 index 0000000..8e9d369 --- /dev/null +++ b/WmiExplorer.sln @@ -0,0 +1,24 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.30723.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WmiExplorer", "WmiExplorer\WmiExplorer.csproj", "{781647DE-1788-4B7C-9289-D0323FDF562A}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{B9BD9632-8046-4414-B261-35222239F891}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {781647DE-1788-4B7C-9289-D0323FDF562A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {781647DE-1788-4B7C-9289-D0323FDF562A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {781647DE-1788-4B7C-9289-D0323FDF562A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {781647DE-1788-4B7C-9289-D0323FDF562A}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/WmiExplorer/ChangeLog.txt b/WmiExplorer/ChangeLog.txt new file mode 100644 index 0000000..4ac0b67 --- /dev/null +++ b/WmiExplorer/ChangeLog.txt @@ -0,0 +1,30 @@ +Version 2.0.0.2 [10-05-2017] + + * Migration to GitHub. + +Version 2.0.0.0 [10-27-2014] + + * New: Asynchronous mode for enumeration of classes and instances in the background. + * New: Method execution. + * New: SMS (System Center Configuration Manager) Mode. + * New: Property tab showing properties of selected class. + * New: Input & Output parameter information in Methods tab with Help information. + * New: List View output mode for Query Results. + * New: Update Notifications when a new version of WMI Explorer is available. + * New: Connect to multiple computers at the same time. + * New: Quick Filter for Classes and Instances. + * New: User Preferences. + * New: View WMI Provider Process Information. + * Improved: UI display on higher scaling levels and resolution. + * Improved: Connect As option to provide alternate credentials. + * Improved: Display of embedded object names in Property Grid. + + +Version 1.0.0.8 [01-07-2014] + + * BugFix: Fixed a crash that occurs due to use of incorrectly displayed right-click context menu when no items are selected in Class/Instance list view. + + +Version 1.0.0.7 [01-07-2014] + + * Initial Release. \ No newline at end of file diff --git a/WmiExplorer/Classes/Enums.cs b/WmiExplorer/Classes/Enums.cs new file mode 100644 index 0000000..df91ecf --- /dev/null +++ b/WmiExplorer/Classes/Enums.cs @@ -0,0 +1,43 @@ +using System; +using System.Drawing; + +namespace WmiExplorer.Classes +{ + public enum MessageCategory + { + Unknown, + Info, + Action, + Warn, + Error, + Cache, + Sms, + None, + } + + [Flags] + public enum EnumOptions + { + None = 0, + IncludeSystem = 1, + IncludeCim = 2, + IncludePerf = 4, + IncludeMsft = 8, + ShowNullInstanceValues = 16, + ShowSystemProperties = 32, + ExcludeSmsCollections = 64, + ExcludeSmsInventory = 128 + } + + public static class ColorCategory + { + public static Color Unknown = Color.Gold; + public static Color Info = Color.YellowGreen; + public static Color Action = Color.Khaki; + public static Color Warn = Color.Yellow; + public static Color Error = Color.Red; + public static Color Cache = Color.LightGreen; + public static Color Sms = Color.LightSkyBlue; + public static Color None = Color.Empty; + } +} diff --git a/WmiExplorer/Classes/Helpers.cs b/WmiExplorer/Classes/Helpers.cs new file mode 100644 index 0000000..68fb398 --- /dev/null +++ b/WmiExplorer/Classes/Helpers.cs @@ -0,0 +1,58 @@ +using System.Drawing; +using System.Management; +using System.Windows.Forms; +using WmiExplorer.Sms; + +namespace WmiExplorer.Classes +{ + public static class Helpers + { + public static Form CenterForm(this Form child, Form parent) + { + child.StartPosition = FormStartPosition.Manual; + child.Location = new Point(parent.Location.X + (parent.Width - child.Width) / 2, parent.Location.Y + (parent.Height - child.Height) / 2); + return child; + } + + public static TreeNode GetRootNode(this TreeNode treeNode) + { + var rootNode = treeNode; + + while (rootNode.Parent != null) + { + rootNode = rootNode.Parent; + } + + return rootNode; + } + + public static ConnectionOptions GetRootNodeCredentials(TreeNode treeNode) + { + var rootNode = treeNode.GetRootNode(); + return ((WmiNode)rootNode.Tag).Connection; + } + + public static SmsClient GetSmsClient(TreeNode treeNode) + { + var rootNode = treeNode; + + while (rootNode.Parent != null) + { + rootNode = rootNode.Parent; + } + + return ((WmiNode)rootNode.Tag).SmsClient; + } + + public static bool IsNodeDisconnected(TreeNode treeNode) + { + WmiNode wmiNode = treeNode.Tag as WmiNode; + if (wmiNode != null && wmiNode.IsRootNode && wmiNode.IsConnected == false) + return true; + + return false; + } + + + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/ListViewColumnSorter.cs b/WmiExplorer/Classes/ListViewColumnSorter.cs new file mode 100644 index 0000000..453105a --- /dev/null +++ b/WmiExplorer/Classes/ListViewColumnSorter.cs @@ -0,0 +1,103 @@ +using System.Collections; +using System.Windows.Forms; + +namespace WmiExplorer.Classes +{ + // How to sort a ListView control by a column in Visual C# + // http://support.microsoft.com/kb/319401 + + internal class ListViewColumnSorter : IComparer + { + /// + /// Specifies the column to be sorted + /// + private int _columnToSort; + + /// + /// Specifies the order in which to sort (i.e. 'Ascending'). + /// + private SortOrder _orderOfSort; + + /// + /// Case insensitive comparer object + /// + private readonly CaseInsensitiveComparer _objectCompare; + + /// + /// Class constructor. Initializes various elements + /// + public ListViewColumnSorter() + { + // Initialize the column to '0' + _columnToSort = 0; + + // Initialize the sort order to 'none' + _orderOfSort = SortOrder.None; + + // Initialize the CaseInsensitiveComparer object + _objectCompare = new CaseInsensitiveComparer(); + } + + /// + /// This method is inherited from the IComparer interface. It compares the two objects passed using a case insensitive comparison. + /// + /// First object to be compared + /// Second object to be compared + /// The result of the comparison. "0" if equal, negative if 'x' is less than 'y' and positive if 'x' is greater than 'y' + public int Compare(object x, object y) + { + // Cast the objects to be compared to ListViewItem objects + ListViewItem listviewX = (ListViewItem)x; + ListViewItem listviewY = (ListViewItem)y; + + // Compare the two items + var compareResult = _objectCompare.Compare(listviewX.SubItems[_columnToSort].Text, listviewY.SubItems[_columnToSort].Text); + + // Calculate correct return value based on object comparison + if (_orderOfSort == SortOrder.Ascending) + { + // Ascending sort is selected, return normal result of compare operation + return compareResult; + } + + if (_orderOfSort == SortOrder.Descending) + { + // Descending sort is selected, return negative result of compare operation + return (-compareResult); + } + + // Return '0' to indicate they are equal + return 0; + } + + /// + /// Gets or sets the number of the column to which to apply the sorting operation (Defaults to '0'). + /// + public int SortColumn + { + set + { + _columnToSort = value; + } + get + { + return _columnToSort; + } + } + + /// + /// Gets or sets the order of sorting to apply (for example, 'Ascending' or 'Descending'). + /// + public SortOrder Order + { + set + { + _orderOfSort = value; + } + get + { + return _orderOfSort; + } + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/ListViewExtensions.cs b/WmiExplorer/Classes/ListViewExtensions.cs new file mode 100644 index 0000000..27acfdc --- /dev/null +++ b/WmiExplorer/Classes/ListViewExtensions.cs @@ -0,0 +1,128 @@ +using System; +using System.Runtime.InteropServices; +using System.Windows.Forms; + +// ReSharper disable InconsistentNaming +// ReSharper disable UnusedMember.Local + +namespace WmiExplorer.Classes +{ + // Sort listview Columns and Set Sort Arrow Icon on Column Header + // http://www.codeproject.com/Tips/734463/Sort-listview-Columns-and-Set-Sort-Arrow-Icon-on-C + internal static class ListViewExtensions + { + [StructLayout(LayoutKind.Sequential)] + public struct LVCOLUMN + { + public Int32 mask; + public Int32 cx; + + [MarshalAs(UnmanagedType.LPTStr)] + public string pszText; + + public IntPtr hbm; + public Int32 cchTextMax; + public Int32 fmt; + public Int32 iSubItem; + public Int32 iImage; + public Int32 iOrder; + } + + private const Int32 HDI_WIDTH = 0x0001; + private const Int32 HDI_HEIGHT = HDI_WIDTH; + private const Int32 HDI_TEXT = 0x0002; + private const Int32 HDI_FORMAT = 0x0004; + private const Int32 HDI_LPARAM = 0x0008; + private const Int32 HDI_BITMAP = 0x0010; + private const Int32 HDI_IMAGE = 0x0020; + private const Int32 HDI_DI_SETITEM = 0x0040; + private const Int32 HDI_ORDER = 0x0080; + private const Int32 HDI_FILTER = 0x0100; + + private const Int32 HDF_LEFT = 0x0000; + private const Int32 HDF_RIGHT = 0x0001; + private const Int32 HDF_CENTER = 0x0002; + private const Int32 HDF_JUSTIFYMASK = 0x0003; + private const Int32 HDF_RTLREADING = 0x0004; + private const Int32 HDF_OWNERDRAW = 0x8000; + private const Int32 HDF_STRING = 0x4000; + private const Int32 HDF_BITMAP = 0x2000; + private const Int32 HDF_BITMAP_ON_RIGHT = 0x1000; + private const Int32 HDF_IMAGE = 0x0800; + private const Int32 HDF_SORTUP = 0x0400; + private const Int32 HDF_SORTDOWN = 0x0200; + + private const Int32 LVM_FIRST = 0x1000; // List messages + private const Int32 LVM_GETHEADER = LVM_FIRST + 31; + private const Int32 HDM_FIRST = 0x1200; // Header messages + private const Int32 HDM_SETIMAGELIST = HDM_FIRST + 8; + private const Int32 HDM_GETIMAGELIST = HDM_FIRST + 9; + private const Int32 HDM_GETITEM = HDM_FIRST + 11; + private const Int32 HDM_SETITEM = HDM_FIRST + 12; + + //This method is used to set arrow icon + public static void SetSortIcon(this ListView listView, int columnIndex, SortOrder order) + { + IntPtr columnHeader = NativeMethods.SendMessage(listView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero); + + for (int columnNumber = 0; columnNumber <= listView.Columns.Count - 1; columnNumber++) + { + IntPtr columnPtr = new IntPtr(columnNumber); + LVCOLUMN lvColumn = new LVCOLUMN(); + lvColumn.mask = HDI_FORMAT; + + NativeMethods.SendMessageLVCOLUMN(columnHeader, HDM_GETITEM, columnPtr, ref lvColumn); + + if (!(order == SortOrder.None) && columnNumber == columnIndex) + { + switch (order) + { + case SortOrder.Ascending: + lvColumn.fmt &= ~HDF_SORTDOWN; + lvColumn.fmt |= HDF_SORTUP; + break; + + case SortOrder.Descending: + lvColumn.fmt &= ~HDF_SORTUP; + lvColumn.fmt |= HDF_SORTDOWN; + break; + } + lvColumn.fmt |= (HDF_LEFT | HDF_BITMAP_ON_RIGHT); + } + else + { + lvColumn.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP & ~HDF_BITMAP_ON_RIGHT; + } + + NativeMethods.SendMessageLVCOLUMN(columnHeader, HDM_SETITEM, columnPtr, ref lvColumn); + } + } + + // Reference link: + // http://stackoverflow.com/questions/14133225/listview-autoresizecolumns-based-on-both-column-content-and-header + // Reference link + public static void ResizeColumns(this ListView lv) + { + //lv.AutoResizeColumns(lv.Items.Count > 0 + // ? ColumnHeaderAutoResizeStyle.ColumnContent + // : ColumnHeaderAutoResizeStyle.HeaderSize); + + lv.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent); + lv.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize); + + //lv.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent); + //ListView.ColumnHeaderCollection cc = lv.Columns; + //for (int i = 0; i < cc.Count; i++) + //{ + // int colWidth = TextRenderer.MeasureText(cc[i].Text, lv.Font).Width + 10; + // if (colWidth > cc[i].Width) + // { + // cc[i].Width = colWidth; + // } + //} + } + } +} + +// ReSharper restore InconsistentNaming +// ReSharper restore UnusedMember.Local \ No newline at end of file diff --git a/WmiExplorer/Classes/ManagementBaseObjectPropertyDescriptor.cs b/WmiExplorer/Classes/ManagementBaseObjectPropertyDescriptor.cs new file mode 100644 index 0000000..4b65d05 --- /dev/null +++ b/WmiExplorer/Classes/ManagementBaseObjectPropertyDescriptor.cs @@ -0,0 +1,236 @@ +using System; +using System.ComponentModel; +using System.Management; + +namespace WmiExplorer.Classes +{ + /// + /// Required for Implementation of ICustomTypeDescriptor + /// Reference Links and Tutorials: + /// http://www.codeproject.com/Articles/539202/CIMTool-for-Windows-Management-Instrumentation-Par + /// http://www.codeproject.com/Articles/4448/Customized-display-of-collection-data-in-a-Propert + /// http://msdn.microsoft.com/en-us/magazine/cc163816.aspx + /// + [TypeConverter(typeof(ManagementBaseObjectWConverter))] + internal class ManagementBaseObjectPropertyDescriptor : PropertyDescriptor + { + protected string category; + private readonly PropertyData _property; + private readonly ManagementBaseObjectW _wrapperObject; + + public ManagementBaseObjectPropertyDescriptor(ManagementBaseObjectW actualObject, PropertyData property) + : base(property.Name, null) + { + _wrapperObject = actualObject; + _property = property; + + if (_property.Origin == "___SYSTEM") + category = "System Properties"; + else + category = "Properties"; + } + + public override string Category + { + get + { + return category; + } + } + + public override Type ComponentType + { + get + { + return _wrapperObject.GetType(); + } + } + + public override string Description + { + get + { + // Embedded instance + if (_property.Value is ManagementBaseObject || _property.Type == CimType.Object) + { + string derivation; + + try + { + derivation = "Embedded " + _property.Qualifiers["CIMTYPE"].Value; + } + catch + { + derivation = "Embedded Object"; + } + + return derivation; + } + + string retVal = "Type - " + _property.Type; + + if (_property.IsArray) + retVal += " []"; + + if (_property.Type == CimType.DateTime && _property.Value != null && !_property.IsArray) + retVal = retVal + " - Normalized Value: " + GetNormalizedDate(_property); + + string pDesc = ""; + try + { + ManagementClass mClass = new ManagementClass(_wrapperObject.ClassPath.Path); + mClass.Options.UseAmendedQualifiers = true; + + foreach (QualifierData qd in mClass.Properties[_property.Name].Qualifiers) + { + if (qd.Name == "Description") + pDesc = qd.Value.ToString(); + + if (qd.Name == "lazy") + retVal += Environment.NewLine + "Lazy Property"; + + if (qd.Name == "enumeration") + retVal += Environment.NewLine + "Enumeration: " + qd.Value; + // TODO: Find other qualifier containing enumerations (Values, ValueMap) + } + } + catch (Exception) + { + pDesc = ""; + } + + if (pDesc != "") + retVal += Environment.NewLine + pDesc; + + return retVal; + } + } + + public override string DisplayName + { + get + { + string retVal = _property.Name; + + foreach (QualifierData q in _property.Qualifiers) + { + if (q.Name == "key") + retVal = "*" + retVal; + } + + return retVal; + } + } + + public override bool IsReadOnly + { + get + { + return true; + } + } + + public override Type PropertyType + { + get + { + return GetDotNetType(); + } + } + + public override bool CanResetValue(object component) + { + return false; + } + + public Type GetDotNetType() + { + if ((_property.Type == CimType.Object) && (_property.Value is ManagementBaseObject)) + { + if (_property.Value is ManagementClass) + { + return typeof(ManagementClass); + } + + if (_property.Value is ManagementObject) + { + return typeof(ManagementObject); + } + + return typeof(ManagementBaseObject); + } + + return ManagementBaseObjectW.GetTypeFor(_property.Type, _property.IsArray); + } + + public override object GetValue(object component) + { + // To expand and display embedded instances, such as Props for SMS SCI classes. + var val = ((ManagementBaseObjectW)component)[_property.Name]; + + if (val is ManagementBaseObject[]) + { + ManagementBaseObject[] props = (ManagementBaseObject[])val; + ManagementBaseObjectW[] propvalues = new ManagementBaseObjectW[props.Length]; + for (int i = 0; i < props.Length; i++) + { + propvalues[i] = new ManagementBaseObjectW(props[i]); + } + return propvalues; + } + + if (val is ManagementBaseObject) + { + ManagementBaseObject props = (ManagementBaseObject)val; + ManagementBaseObjectW propvalue = new ManagementBaseObjectW(props); + return propvalue; + } + + return val; + } + + public override void ResetValue(object component) + { + } + + public override void SetValue(object component, object value) + { + ((ManagementBaseObjectW)component)[_property.Name] = value; + } + + public override bool ShouldSerializeValue(object component) + { + return true; + } + + protected static object GetNormalizedDate(PropertyData propertyData) + { + object retVal = propertyData.Value; + + if (propertyData.Type == CimType.DateTime && propertyData.Value != null) + { + //20080409032454.676631-420 + // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 + // Y 2 0 0 8 M 0 4 D 0 9 H 0 3 M 2 4 S 5 4 . m 6 7 6 6 3 1 U-420 + string dateString = propertyData.Value.ToString(); + try + { + retVal = new DateTime( + int.Parse(dateString.Substring(0, 4)), + int.Parse(dateString.Substring(4, 2)), + int.Parse(dateString.Substring(6, 2)), + int.Parse(dateString.Substring(8, 2)), + int.Parse(dateString.Substring(10, 2)), + int.Parse(dateString.Substring(12, 2)), + int.Parse(dateString.Substring(15, 6)) / 1000, DateTimeKind.Local); + } + catch (ArgumentOutOfRangeException) + { + retVal = dateString; + } + } + + return retVal; + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/ManagementBaseObjectW.cs b/WmiExplorer/Classes/ManagementBaseObjectW.cs new file mode 100644 index 0000000..8878413 --- /dev/null +++ b/WmiExplorer/Classes/ManagementBaseObjectW.cs @@ -0,0 +1,339 @@ +using System; +using System.ComponentModel; +using System.Management; + +namespace WmiExplorer.Classes +{ + /// + /// Wrapper Class for ManagementBaseObject + /// Uses ManagementBaseObjectWConverter to display appropriate text if Embedded Objects are expanded. + /// Reference Links and Tutorials: + /// http://www.codeproject.com/Articles/539202/CIMTool-for-Windows-Management-Instrumentation-Par + /// http://www.codeproject.com/Articles/4448/Customized-display-of-collection-data-in-a-Propert + /// http://msdn.microsoft.com/en-us/magazine/cc163816.aspx + /// + [TypeConverter(typeof(ManagementBaseObjectWConverter))] + internal class ManagementBaseObjectW : ICustomTypeDescriptor + { + private readonly ManagementBaseObject _wrapperObject; + + private ManagementPath _classPath; + + private PropertyDataCollection _properties; + + private QualifierDataCollection _qualifiers; + + private PropertyDataCollection _systemProperties; + + private PropertyDescriptorCollection _propertyDescriptorCollection; + + public ManagementBaseObjectW(ManagementBaseObject actualObject) + { + _wrapperObject = actualObject; + } + + public ManagementPath ClassPath + { + get + { + if (_classPath == null) + { + _classPath = _wrapperObject.ClassPath; + } + return _classPath; + } + } + + public bool IncludeNullProperties { get; set; } + + public bool IncludeSystemProperties { get; set; } + + public PropertyDataCollection Properties + { + get + { + if (_properties == null) + { + _properties = _wrapperObject.Properties; + } + return _properties; + } + } + + public virtual QualifierDataCollection Qualifiers + { + get + { + if (_qualifiers == null) + { + _qualifiers = _wrapperObject.Qualifiers; + } + return _qualifiers; + } + } + + public virtual PropertyDataCollection SystemProperties + { + get + { + if (_systemProperties == null) + { + _systemProperties = _wrapperObject.SystemProperties; + } + return _systemProperties; + } + } + + public object this[string propertyName] + { + get + { + return _wrapperObject[propertyName]; + } + set + { + _wrapperObject[propertyName] = value; + } + } + + public static Type GetTypeFor(CimType cimType, bool isArray) + { + switch (cimType) + { + case CimType.None: + break; + + case CimType.SInt8: + if (isArray) + return typeof(sbyte[]); + return typeof(sbyte); + + case CimType.UInt8: + if (isArray) + return typeof(byte[]); + return typeof(byte); + + case CimType.SInt16: + if (isArray) + return typeof(short[]); + return typeof(short); + + case CimType.UInt16: + if (isArray) + return typeof(ushort[]); + return typeof(ushort); + + case CimType.SInt32: + if (isArray) + return typeof(int[]); + return typeof(int); + + case CimType.UInt32: + if (isArray) + return typeof(uint[]); + return typeof(uint); + + case CimType.SInt64: + if (isArray) + return typeof(long[]); + return typeof(long); + + case CimType.UInt64: + if (isArray) + return typeof(ulong[]); + return typeof(ulong); + + case CimType.Real32: + if (isArray) + return typeof(float[]); + return typeof(float); + + case CimType.Real64: + if (isArray) + return typeof(double[]); + return typeof(double); + + case CimType.Boolean: + if (isArray) + return typeof(bool[]); + return typeof(bool); + + case CimType.String: + if (isArray) + return typeof(string[]); + return typeof(string); + + case CimType.DateTime: + if (isArray) + return typeof(DateTime[]); + return typeof(DateTime); + + case CimType.Reference: + if (isArray) + return typeof(object[]); + return typeof(object); + + case CimType.Char16: + if (isArray) + return typeof(char[]); + return typeof(char); + + case CimType.Object: + + if (isArray) + return typeof(object[]); + return typeof(object); + } + return null; + } + + public bool CompareTo(ManagementBaseObject otherObject, ComparisonSettings settings) + { + return _wrapperObject.CompareTo(otherObject, settings); + } + + public PropertyDescriptorCollection GetProperties() + { + if (_propertyDescriptorCollection == null) + { + _propertyDescriptorCollection = new PropertyDescriptorCollection(null); + + // Properties + foreach (PropertyData property in Properties) + { + if (_propertyDescriptorCollection.Find(property.Name, true) == null) + { + if (IncludeNullProperties) + { + PropertyDescriptor propertyDescriptor = GetPropertyDescriptor(property); + _propertyDescriptorCollection.Add(propertyDescriptor); + } + else if (property.Value != null) + { + PropertyDescriptor propertyDescriptor = GetPropertyDescriptor(property); + _propertyDescriptorCollection.Add(propertyDescriptor); + } + } + } + + // System Properties + if (IncludeSystemProperties) + { + foreach (PropertyData property in SystemProperties) + { + if (_propertyDescriptorCollection.Find(property.Name, true) == null) + { + PropertyDescriptor propertyDescriptor = GetPropertyDescriptor(property); + _propertyDescriptorCollection.Add(propertyDescriptor); + } + } + } + } + + return _propertyDescriptorCollection; + } + + public object GetPropertyQualifierValue(string propertyName, string qualifierName) + { + return _wrapperObject.GetPropertyQualifierValue(propertyName, qualifierName); + } + + public object GetPropertyValue(string propertyName) + { + //not used by PropertyGrid + return _wrapperObject.GetPropertyValue(propertyName); + } + + public object GetQualifierValue(string qualifierName) + { + return _wrapperObject.GetQualifierValue(qualifierName); + } + + public string GetText(TextFormat format) + { + return _wrapperObject.GetText(format); + } + + // ICustomTypeDescriptor implementation + AttributeCollection ICustomTypeDescriptor.GetAttributes() + { + return TypeDescriptor.GetAttributes(this, true); + } + + string ICustomTypeDescriptor.GetClassName() + { + return TypeDescriptor.GetClassName(this, true); + } + + string ICustomTypeDescriptor.GetComponentName() + { + return TypeDescriptor.GetComponentName(this, true); + } + + TypeConverter ICustomTypeDescriptor.GetConverter() + { + return TypeDescriptor.GetConverter(this, true); + } + + EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() + { + return TypeDescriptor.GetDefaultEvent(this, true); + } + + PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() + { + return TypeDescriptor.GetDefaultProperty(this, true); + } + + object ICustomTypeDescriptor.GetEditor(Type editorBaseType) + { + return TypeDescriptor.GetEditor(this, editorBaseType, true); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) + { + return TypeDescriptor.GetEvents(this, attributes, true); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents() + { + return TypeDescriptor.GetEvents(this, true); + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) + { + return GetProperties(); + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() + { + return GetProperties(); + } + + object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) + { + return this; + } + + public void SetPropertyQualifierValue(string propertyName, string qualifierName, object qualifierValue) + { + _wrapperObject.SetPropertyQualifierValue(propertyName, qualifierName, qualifierValue); + } + + public void SetPropertyValue(string propertyName, object propertyValue) + { + _wrapperObject.SetPropertyValue(propertyName, propertyValue); + } + + public void SetQualifierValue(string qualifierName, object qualifierValue) + { + _wrapperObject.SetQualifierValue(qualifierName, qualifierValue); + } + + protected virtual PropertyDescriptor GetPropertyDescriptor(PropertyData property) + { + ManagementBaseObjectPropertyDescriptor result = new ManagementBaseObjectPropertyDescriptor(this, property); + return result; + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/ManagementBaseObjectWConverter.cs b/WmiExplorer/Classes/ManagementBaseObjectWConverter.cs new file mode 100644 index 0000000..528f1f7 --- /dev/null +++ b/WmiExplorer/Classes/ManagementBaseObjectWConverter.cs @@ -0,0 +1,52 @@ +using System; +using System.ComponentModel; +using System.Globalization; +using System.Management; + +namespace WmiExplorer.Classes +{ + /// + /// Used to display property values of Embedded WMI Objects. + /// Reference tutorial: http://www.codeproject.com/Articles/4448/Customized-display-of-collection-data-in-a-Propert + /// + internal class ManagementBaseObjectWConverter : ExpandableObjectConverter + { + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (value is ManagementBaseObjectW) + { + ManagementBaseObjectW mObjectW = (ManagementBaseObjectW)value; + + // If PropertyName contains Name, return the value of the property + foreach (PropertyData p in mObjectW.Properties) + { + if (p.Name.Contains("Name")) + return p.Value.ToString(); + } + + // No match on Name. If PropertyName contains ID, return the value of the property + foreach (PropertyData p in mObjectW.Properties) + { + if (p.Name.Contains("ID")) + return p.Value.ToString(); + } + + // No match on Name or ID. If Property is key, return the value of the property + foreach (PropertyData p in mObjectW.Properties) + { + foreach (QualifierData q in p.Qualifiers) + if (q.Name.Equals("key", StringComparison.InvariantCultureIgnoreCase)) + if (String.IsNullOrEmpty(p.Value.ToString())) + return String.Empty; + else + return p.Value.ToString(); + } + + // No matches. Return an empty string. + return String.Empty; + } + + return base.ConvertTo(context, culture, value, destinationType); + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/ManagementObjectW.cs b/WmiExplorer/Classes/ManagementObjectW.cs new file mode 100644 index 0000000..2cc99e1 --- /dev/null +++ b/WmiExplorer/Classes/ManagementObjectW.cs @@ -0,0 +1,17 @@ +using System.ComponentModel; +using System.Management; + +namespace WmiExplorer.Classes +{ + /// + /// Wrapper Class for ManagementObject + /// + [TypeConverter(typeof(ManagementBaseObjectWConverter))] + internal class ManagementObjectW : ManagementBaseObjectW + { + public ManagementObjectW(ManagementBaseObject actualObject) + : base(actualObject) + { + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/MouseWheelMessageFilter.cs b/WmiExplorer/Classes/MouseWheelMessageFilter.cs new file mode 100644 index 0000000..0f0e47a --- /dev/null +++ b/WmiExplorer/Classes/MouseWheelMessageFilter.cs @@ -0,0 +1,34 @@ +using System; +using System.Drawing; +using System.Windows.Forms; + +namespace WmiExplorer.Classes +{ + /// + /// Used to allow scrolling for the controls, without having to select them or focus on them. + /// http://www.brad-smith.info/blog/archives/635 + /// http://stackoverflow.com/questions/7852824/usercontrol-how-to-add-mousewheel-listener + /// + internal class MouseWheelMessageFilter : IMessageFilter + { + private const int WM_MOUSEWHEEL = 0x20a; + + public bool PreFilterMessage(ref Message m) + { + if (m.Msg == WM_MOUSEWHEEL) + { + // LParam contains the location of the mouse pointer + Point pos = new Point(m.LParam.ToInt32() & 0xffff, m.LParam.ToInt32() >> 16); + IntPtr hWnd = NativeMethods.WindowFromPoint(pos); + if (hWnd != IntPtr.Zero && hWnd != m.HWnd && Control.FromHandle(hWnd) != null) + { + // redirect the message to the correct control + NativeMethods.SendMessage(hWnd, m.Msg, m.WParam, m.LParam); + return true; + } + } + + return false; + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/NativeMethods.cs b/WmiExplorer/Classes/NativeMethods.cs new file mode 100644 index 0000000..f435951 --- /dev/null +++ b/WmiExplorer/Classes/NativeMethods.cs @@ -0,0 +1,30 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Drawing; +using System.Runtime.InteropServices; + +namespace WmiExplorer.Classes +{ + /// + /// Wrapper for Native Methods + /// + internal class NativeMethods + { + // P/Invoke declarations + + [DllImport("user32.dll")] + public static extern bool GetWindowPlacement(IntPtr hWnd, out WINDOWPLACEMENT lpwndpl); + + [DllImport("user32.dll")] + public static extern IntPtr SendMessage(IntPtr hWnd, int msg, IntPtr wp, IntPtr lp); + + [DllImport("user32.dll", EntryPoint = "SendMessage")] + public static extern IntPtr SendMessageLVCOLUMN(IntPtr hWnd, Int32 Msg, IntPtr wParam, ref ListViewExtensions.LVCOLUMN lPLVCOLUMN); + + [DllImport("user32.dll")] + public static extern bool SetWindowPlacement(IntPtr hWnd, [In] ref WINDOWPLACEMENT lpwndpl); + + [SuppressMessage("Microsoft.Portability", "CA1901:PInvokeDeclarationsShouldBePortable", MessageId = "0"), DllImport("user32.dll")] + public static extern IntPtr WindowFromPoint(Point pt); + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/ObserverHandler.cs b/WmiExplorer/Classes/ObserverHandler.cs new file mode 100644 index 0000000..81aca04 --- /dev/null +++ b/WmiExplorer/Classes/ObserverHandler.cs @@ -0,0 +1,139 @@ +using System; +using System.Diagnostics; +using System.Management; +using System.Runtime.Caching; +using System.Windows.Forms; + +namespace WmiExplorer.Classes +{ + internal class ObserverHandler + { + private readonly bool _isClass; + private readonly bool _isNamespace; + private readonly Stopwatch _stopwatch = new Stopwatch(); + private readonly WmiClass _wmiClass; + private readonly WmiNamespace _wmiNamespace; + + /// + /// Constructor for observer working on retrieving classes for a Namespace + /// + /// Instance of WmiNamespace for which to enumerate classes + public ObserverHandler(WmiNamespace wmiNamespace) + { + _wmiNamespace = wmiNamespace; + _wmiNamespace.IsEnumerating = true; + _isNamespace = true; + _stopwatch.Start(); + } + + /// + /// Constructor for observer working on retrieving instances for a Class + /// + /// Instance of WmiClass for which to enumerate instances + public ObserverHandler(WmiClass wmiClass) + { + _wmiClass = wmiClass; + _wmiClass.IsEnumerating = true; + _isClass = true; + _stopwatch.Start(); + } + + public bool IsComplete { get; private set; } + + public void Done(object sender, CompletedEventArgs e) + { + _stopwatch.Stop(); + + if (_isNamespace) + { + if (e.Status == ManagementStatus.CallCanceled) + { + _wmiNamespace.IsPartiallyEnumerated = true; + _wmiNamespace.IsEnumerationCancelled = true; + } + else + { + _wmiNamespace.IsPartiallyEnumerated = false; + _wmiNamespace.IsEnumerationCancelled = false; + } + + _wmiNamespace.IsEnumerated = true; + _wmiNamespace.IsEnumerating = false; + _wmiNamespace.EnumerationStatus = e.Status.ToString(); + _wmiNamespace.EnumTime = DateTime.Now; + _wmiNamespace.EnumTimeElapsed = _stopwatch.Elapsed; + + CacheItem ci = new CacheItem(_wmiNamespace.Path, _wmiNamespace.Classes); + WmiExplorer.AppCache.Set(ci, WmiExplorer.CachePolicy); + _wmiNamespace.ResetClasses(); + } + + if (_isClass) + { + if (e.Status == ManagementStatus.CallCanceled) + { + _wmiClass.IsPartiallyEnumerated = true; + _wmiClass.IsEnumerationCancelled = true; + } + else + { + _wmiClass.IsPartiallyEnumerated = false; + _wmiClass.IsEnumerationCancelled = false; + } + + _wmiClass.IsEnumerated = true; + _wmiClass.IsEnumerating = false; + _wmiClass.IsEnumerationCancelled = false; + _wmiClass.EnumerationStatus = e.Status.ToString(); + _wmiClass.EnumTime = DateTime.Now; + _wmiClass.EnumTimeElapsed = _stopwatch.Elapsed; + + CacheItem ci = new CacheItem(_wmiClass.Path, _wmiClass.Instances); + WmiExplorer.AppCache.Set(ci, WmiExplorer.CachePolicy); + _wmiClass.ResetInstances(); + } + + IsComplete = true; + } + + public void NewObject(object sender, ObjectReadyEventArgs e) + { + ManagementObject mObject = (ManagementObject)e.NewObject; + + if (mObject.Path.IsClass && _isNamespace) + { + WmiClass wmiClass = new WmiClass(mObject as ManagementClass); + + ListViewItem li = new ListViewItem + { + Name = wmiClass.Path, + Text = wmiClass.DisplayName, + ToolTipText = wmiClass.Description, + Tag = wmiClass + }; + + // Add Lazy Properties, Description, and Path columns + li.SubItems.Add(wmiClass.HasLazyProperties.ToString()); + li.SubItems.Add(wmiClass.Description); + li.SubItems.Add(wmiClass.Path); + + _wmiNamespace.AddClass(li); + } + + if (mObject.Path.IsInstance && _isClass) + { + WmiInstance wmiInstance = new WmiInstance(mObject); + + ListViewItem li = new ListViewItem + { + Name = wmiInstance.Path, + Text = wmiInstance.RelativePath, + ToolTipText = wmiInstance.RelativePath, + Tag = wmiInstance + }; + + _wmiClass.AddInstance(li); + } + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/ToolStripItemCollectionSorter.cs b/WmiExplorer/Classes/ToolStripItemCollectionSorter.cs new file mode 100644 index 0000000..5358a97 --- /dev/null +++ b/WmiExplorer/Classes/ToolStripItemCollectionSorter.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections; +using System.Windows.Forms; + +namespace WmiExplorer.Classes +{ + public static class ToolStripItemExtensions + { + public static void SortToolStripItemCollection(this ToolStripItemCollection items) + { + ArrayList aList = new ArrayList(items); + aList.Sort(new ToolStripItemCollectionSorter()); + items.Clear(); + + foreach (ToolStripItem item in aList) + { + items.Add(item); + } + } + } + + public class ToolStripItemCollectionSorter : IComparer + { + public int Compare(object x, object y) + { + // Cast the objects to be compared to ListViewItem objects + ToolStripItem toolStripItemX = (ToolStripItem)x; + ToolStripItem toolStripItemY = (ToolStripItem)y; + + return String.Compare(toolStripItemX.Text, toolStripItemY.Text, StringComparison.OrdinalIgnoreCase); + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/Utilities.cs b/WmiExplorer/Classes/Utilities.cs new file mode 100644 index 0000000..fa7b42e --- /dev/null +++ b/WmiExplorer/Classes/Utilities.cs @@ -0,0 +1,216 @@ +using System; +using System.Collections.Specialized; +using System.Configuration; +using System.Diagnostics; +using System.Linq; +using System.Runtime.InteropServices; +using System.Security; +using System.Security.Principal; +using System.Windows.Forms; +using WmiExplorer.Properties; + +namespace WmiExplorer.Classes +{ + public static class Utilities + { + /// + /// Checks if Application is running as Administrator + /// + /// True if running as Administrator. + public static bool CheckIfElevated() + { + try + { + WindowsIdentity userIdentity = WindowsIdentity.GetCurrent(); + WindowsPrincipal userPrincipal = new WindowsPrincipal(userIdentity); + + if (userPrincipal.IsInRole(WindowsBuiltInRole.Administrator)) + return true; + + return false; + } + catch (Exception ex) + { + MessageBox.Show("Failed to determine if Application is running as Administrator: " + ex.Message); + //Log("Unable to determine whether Application is running Elevated. Error: " + ex.Message); + return false; + } + } + + /// + /// To search and highlight text in Rich Text Box + /// http://www.dotnetcurry.com/showarticle.aspx?ID=146 + /// + /// Text to Search in RichTextBox rtb + /// Start index for search + /// Index of Last Search result + /// RichTextBox to search in + /// + public static int FindTextInRichTextBox(string txtToSearch, int searchStart, int indexOfSearchText, RichTextBox rtb) + { + // Set the return value to -1 by default. + int retVal = -1; + int searchEnd = rtb.Text.Length; + + // A valid starting index should be specified. + // if _indexOfSearchText = -1, the end of search + if (searchStart >= 0 && indexOfSearchText >= 0) + { + // A valid ending index + if (searchEnd > searchStart || searchEnd == -1) + { + // Find the position of search string in RichTextBox + indexOfSearchText = rtb.Find(txtToSearch, searchStart, searchEnd, RichTextBoxFinds.None); + + // Determine whether the text was found in rtb. + if (indexOfSearchText != -1) + { + // Return the index to the specified search text. + retVal = indexOfSearchText; + } + } + } + return retVal; + } + + /// + /// Returns all Application settings + /// + /// String value containing name & value of all settings + public static string GetSettings() + { + string settings = String.Empty; + + foreach (SettingsProperty p in from SettingsProperty p in Settings.Default.Properties + orderby p.Name + select p) + { + // Exclude UpdateCheckUrl and WindowPlacement settings + if (p.Name.StartsWith("UpdateCheckUrl", StringComparison.InvariantCultureIgnoreCase) || p.Name.Equals("WindowPlacement", StringComparison.InvariantCultureIgnoreCase)) + continue; + + // Settings containing a string array + if (Settings.Default[p.Name] is StringCollection) + { + settings += p.Name + " = "; + foreach (var s in Settings.Default[p.Name] as StringCollection) + settings += s + ", "; + settings += "\r\n"; + continue; + } + + // Settings without default values + if (p.DefaultValue == null) + { + settings += p.Name + " = " + Settings.Default[p.Name] + "\r\n"; + continue; + } + + // Other settings with indicator whether value is the default value + if (p.DefaultValue.ToString() == Settings.Default[p.Name].ToString()) + settings += p.Name + " = " + Settings.Default[p.Name] + " (Default)\r\n"; + else + settings += p.Name + " = " + Settings.Default[p.Name] + "\r\n"; + } + + return settings; + } + + /// + /// Launch the specified program + /// + /// Command to run + public static void LaunchProgram(string sCmd) + { + try + { + Process.Start(sCmd); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Error launching program", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + /// + /// Launch the specified program with arguments + /// + /// Command to run + /// Argument for the command + /// Wait for the command to Exit + public static void LaunchProgram(string sCmd, string sArgument, bool bWaitForExit) + { + try + { + if (bWaitForExit) + Process.Start(sCmd, sArgument).WaitForExit(); + else + Process.Start(sCmd, sArgument); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Error launching program", MessageBoxButtons.OK, MessageBoxIcon.Error); + } + } + + /// + /// Returns a string from the source SecureString + /// http://blogs.msdn.com/b/fpintos/archive/2009/06/12/how-to-properly-convert-securestring-to-string.aspx + /// + /// SecureString to convert to String + /// String + public static string SecureStringToString(this SecureString secureString) + { + if (secureString == null) + throw new ArgumentNullException("secureString"); + + IntPtr unmanagedString = IntPtr.Zero; + try + { + unmanagedString = Marshal.SecureStringToGlobalAllocUnicode(secureString); + return Marshal.PtrToStringUni(unmanagedString); + } + finally + { + Marshal.ZeroFreeGlobalAllocUnicode(unmanagedString); + } + } + + /// + /// Returns a Secure string from the source string + /// http://msdn.microsoft.com/en-us/library/system.security.securestring(v=vs.110).aspx + /// + /// String to convert to SecureString + /// SecureString + public static SecureString StringToSecureString(this string source) + { + if (String.IsNullOrWhiteSpace(source)) + return null; + + SecureString result = new SecureString(); + foreach (char c in source.ToCharArray()) + result.AppendChar(c); + + return result; + } + + /// + /// Update User Settings on Application version update + /// http://www.ngpixel.com/2011/05/05/c-keep-user-settings-between-versions/ + /// + public static void UpdateSettings() + { + try + { + Settings.Default.Upgrade(); + Settings.Default.bUpgradeSettings = false; + Settings.Default.bUpdateAvailable = false; + Settings.Default.Save(); + } + catch (Exception ex) + { + MessageBox.Show("Failed to upgrade user settings. Error: " + ex.Message); + } + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/WindowPlacement.cs b/WmiExplorer/Classes/WindowPlacement.cs new file mode 100644 index 0000000..f544f05 --- /dev/null +++ b/WmiExplorer/Classes/WindowPlacement.cs @@ -0,0 +1,111 @@ +using System; +using System.IO; +using System.Runtime.InteropServices; +using System.Text; +using System.Xml; +using System.Xml.Serialization; + +namespace WmiExplorer.Classes +{ + // Reference Link: David Rickard's Blog + // http://blogs.msdn.com/b/davidrickard/archive/2010/03/09/saving-window-size-and-location-in-wpf-and-winforms.aspx + + // POINT structure required by WINDOWPLACEMENT structure + [Serializable] + [StructLayout(LayoutKind.Sequential)] + public struct POINT + { + public int X; + public int Y; + + public POINT(int x, int y) + { + X = x; + Y = y; + } + } + + // RECT structure required by WINDOWPLACEMENT structure + [Serializable] + [StructLayout(LayoutKind.Sequential)] + public struct RECT + { + public int Left; + public int Top; + public int Right; + public int Bottom; + + public RECT(int left, int top, int right, int bottom) + { + Left = left; + Top = top; + Right = right; + Bottom = bottom; + } + } + + // WINDOWPLACEMENT stores the position, size, and state of a window + [Serializable] + [StructLayout(LayoutKind.Sequential)] + public struct WINDOWPLACEMENT + { + public int length; + public int flags; + public int showCmd; + public POINT minPosition; + public POINT maxPosition; + public RECT normalPosition; + } + + internal class WindowPlacement + { + private const int SW_SHOWMINIMIZED = 2; + private const int SW_SHOWNORMAL = 1; + private static readonly Encoding Encoding = new ASCIIEncoding(); + private static readonly XmlSerializer Serializer = new XmlSerializer(typeof(WINDOWPLACEMENT)); + + public static string GetPlacement(IntPtr windowHandle) + { + WINDOWPLACEMENT placement; + NativeMethods.GetWindowPlacement(windowHandle, out placement); + + using (MemoryStream memoryStream = new MemoryStream()) + { + using (XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.ASCII)) + { + Serializer.Serialize(xmlTextWriter, placement); + byte[] xmlBytes = memoryStream.ToArray(); + return Encoding.GetString(xmlBytes); + } + } + } + + public static void SetPlacement(IntPtr windowHandle, string placementXml) + { + if (string.IsNullOrEmpty(placementXml)) + { + return; + } + + byte[] xmlBytes = Encoding.GetBytes(placementXml); + + try + { + WINDOWPLACEMENT placement; + using (MemoryStream memoryStream = new MemoryStream(xmlBytes)) + { + placement = (WINDOWPLACEMENT)Serializer.Deserialize(memoryStream); + } + + placement.length = Marshal.SizeOf(typeof(WINDOWPLACEMENT)); + placement.flags = 0; + placement.showCmd = (placement.showCmd == SW_SHOWMINIMIZED ? SW_SHOWNORMAL : placement.showCmd); + NativeMethods.SetWindowPlacement(windowHandle, ref placement); + } + catch (InvalidOperationException) + { + // Parsing placement XML failed. Fail silently. + } + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/WmiClass.cs b/WmiExplorer/Classes/WmiClass.cs new file mode 100644 index 0000000..2d80c4e --- /dev/null +++ b/WmiExplorer/Classes/WmiClass.cs @@ -0,0 +1,185 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Management; +using System.Windows.Forms; + +namespace WmiExplorer.Classes +{ + internal class WmiClass + { + public List Instances = new List(); + private string _description; + private string _displayName; + private string _enumerationStatus; + private DateTime _enumTime; + private TimeSpan _enumTimeElapsed; + private bool _hasLazyProperties; + private string _instanceFilterQuick; + private string _namespacePath; + private string _path; + private string _relativePath; + + public WmiClass(ManagementClass actualClass) + { + Class = actualClass; + } + + public ManagementClass Class { get; set; } + + public string Description + { + get + { + try + { + foreach (QualifierData q in from QualifierData q in Class.Qualifiers where q.Name.Equals("Description", StringComparison.CurrentCultureIgnoreCase) select q) + { + _description = Class.GetQualifierValue("Description").ToString(); + } + } + catch (ManagementException ex) + { + if ((ex.ErrorCode).ToString() == "NotFound") + _description = String.Empty; + else + _description = "Error getting Class Description"; + } + + return _description; + } + } + + public string DisplayName + { + get + { + if (_displayName == null) + _displayName = Class.ClassPath.ClassName; + + return _displayName; + } + set { _displayName = value; } + } + + public string EnumerationStatus + { + get + { + if (String.IsNullOrEmpty(_enumerationStatus)) + _enumerationStatus = "NoError"; + + return _enumerationStatus; + } + set { _enumerationStatus = value; } + } + + public DateTime EnumTime + { + get { return _enumTime; } + set { _enumTime = value; } + } + + public TimeSpan EnumTimeElapsed + { + get { return _enumTimeElapsed; } + set { _enumTimeElapsed = value; } + } + + public bool HasLazyProperties + { + get + { + foreach (PropertyData pd in Class.Properties) + { + foreach (QualifierData qd in pd.Qualifiers) + { + if (qd.Name.Equals("lazy", StringComparison.CurrentCultureIgnoreCase)) + { + _hasLazyProperties = true; + return _hasLazyProperties; + } + } + } + + return _hasLazyProperties; + } + } + + public int InstanceCount { get; set; } + + public string InstanceFilterQuick + { + get + { + if (_instanceFilterQuick == null) + _instanceFilterQuick = String.Empty; + + return _instanceFilterQuick; + } + set { _instanceFilterQuick = value; } + } + + // Indicates if class has instances enumerated + public bool IsEnumerated { get; set; } + + // Indicates if class is currently being enumerated + public bool IsEnumerating { get; set; } + + // Indicates if cancellation is requested for this class. + public bool IsEnumerationCancelled { get; set; } + + // Indicates if class has instances partially enumerated. This can occur if user cancels operation. + public bool IsPartiallyEnumerated { get; set; } + + public string NamespacePath + { + get + { + if (_namespacePath == null) + _namespacePath = Class.Scope.Path.Path; + + return _namespacePath; + } + } + + public string Path + { + get + { + if (_path == null) + _path = Class.Path.Path; + return _path; + } + } + + public string RelativePath + { + get + { + if (_relativePath == null) + _relativePath = Class.Path.RelativePath; + + return _relativePath; + } + } + + public void AddInstance(ListViewItem listItemInstance) + { + Instances.Add(listItemInstance); + } + + public string GetClassMof(bool bAmended = false) + { + Class.Options.UseAmendedQualifiers = bAmended; + Class.Get(); + return Class.GetText(TextFormat.Mof).Replace("\n", "\r\n"); + } + + public void ResetInstances() + { + InstanceCount = Instances.Count; + Instances = new List(); + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/WmiInstance.cs b/WmiExplorer/Classes/WmiInstance.cs new file mode 100644 index 0000000..b524c88 --- /dev/null +++ b/WmiExplorer/Classes/WmiInstance.cs @@ -0,0 +1,50 @@ +using System.Management; + +namespace WmiExplorer.Classes +{ + internal class WmiInstance + { + private string _path; + private string _relativePath; + + public WmiInstance(ManagementObject actualObject) + { + Instance = actualObject; + } + + public ManagementObject Instance { get; set; } + + public string Path + { + get + { + if (_path == null) + _path = Instance.Path.Path; + + return _path; + } + } + + public string RelativePath + { + get + { + if (_relativePath == null) + _relativePath = Instance.Path.RelativePath; + + return _relativePath; + } + } + + public string GetInstanceMof(bool bAmended = false) + { + if (bAmended) + Instance.Options.UseAmendedQualifiers = true; + else + Instance.Options.UseAmendedQualifiers = false; + + Instance.Get(); + return Instance.GetText(TextFormat.Mof).Replace("\n", "\r\n"); + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/WmiMethod.cs b/WmiExplorer/Classes/WmiMethod.cs new file mode 100644 index 0000000..824de21 --- /dev/null +++ b/WmiExplorer/Classes/WmiMethod.cs @@ -0,0 +1,42 @@ +using System.Management; + +namespace WmiExplorer.Classes +{ + internal class WmiMethod + { + private string _description; + private bool _isStatic; + private string _methodName; + private string _path; + private MethodData _wmiMethod; + + public WmiMethod(MethodData actualMethod) + { + _wmiMethod = actualMethod; + } + + public string Description + { + get { return _description; } + set { _description = value; } + } + + public bool IsStatic + { + get { return _isStatic; } + set { _isStatic = value; } + } + + public string MethodName + { + get { return _methodName; } + set { _methodName = value; } + } + + public string Path + { + get { return _path; } + set { _path = value; } + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/WmiNamespace.cs b/WmiExplorer/Classes/WmiNamespace.cs new file mode 100644 index 0000000..25d0644 --- /dev/null +++ b/WmiExplorer/Classes/WmiNamespace.cs @@ -0,0 +1,179 @@ +using System; +using System.Collections.Generic; +using System.Management; +using System.Windows.Forms; + +namespace WmiExplorer.Classes +{ + internal class WmiNamespace + { + public int ClassCount = 0; + public List Classes = new List(); + private readonly ManagementObject _wmiNamespace; + private string _classFilter; // Class Filter for current namespace + private string _classFilterQuick; // Quick Filter for current namespace + private string _displayName; // Display Name of the current namespace + private string _enumerationStatus; // Class Enumeration status of current namespace + private DateTime _enumTime; // Enumeration Time of current namespace + private TimeSpan _enumTimeElapsed; // Time taken to enumerate classes for current namespace + private bool _isRootNode; // Indicates if current namespace is the root node + private string _path; // Path of the current namespace + private string _relativePath; // Relative Path of current namespace + private string _serverName; // Server name + + public WmiNamespace(ManagementObject actualNamespace) + { + _wmiNamespace = actualNamespace; + } + + public string ClassFilter + { + get + { + if (_classFilter == null) + _classFilter = "%"; + + return _classFilter; + } + set { _classFilter = value; } + } + + public string ClassFilterQuick + { + get + { + if (_classFilterQuick == null) + _classFilterQuick = String.Empty; + + return _classFilterQuick; + } + set { _classFilterQuick = value; } + } + + public string DisplayName + { + get + { + if (_displayName == null) + { + if (IsRootNode) + _displayName = _wmiNamespace.Scope.Path.Path.ToUpper(); + else + _displayName = RelativePath; + } + return _displayName; + } + set { _displayName = value; } + } + + public string EnumerationStatus + { + get + { + if (String.IsNullOrEmpty(_enumerationStatus)) + _enumerationStatus = "NoError"; + + return _enumerationStatus; + } + set { _enumerationStatus = value; } + } + + public DateTime EnumTime + { + get { return _enumTime; } + set { _enumTime = value; } + } + + public TimeSpan EnumTimeElapsed + { + get { return _enumTimeElapsed; } + set { _enumTimeElapsed = value; } + } + + // Indicates if current namespace has classes enumerated + public bool IsEnumerated { get; set; } + + // Indicates if current namespace is currently being enumerated + public bool IsEnumerating { get; set; } + + // Indicates if cancellation is requested for this namespace. + public bool IsEnumerationCancelled { get; set; } + + // Indicates if current namespace has classes partially enumerated. This can occur if user cancels operation. + public bool IsPartiallyEnumerated { get; set; } + + public bool IsRootNode + { + get + { + // Namespace in root node has Path.Path set to Empty string + if (String.IsNullOrEmpty(_wmiNamespace.Path.Path)) + _isRootNode = true; + else + _isRootNode = false; + + return _isRootNode; + } + } + + public string Path + { + get + { + if (_path == null) + { + if (IsRootNode) + _path = _wmiNamespace.Scope.Path.Path.ToUpper(); + else + _path = "\\\\" + _wmiNamespace.Path.Server + "\\" + _wmiNamespace.GetPropertyValue("__Namespace") + "\\" + _wmiNamespace.GetPropertyValue("Name"); + } + return _path; + } + } + + public string RelativePath + { + get + { + if (_relativePath == null) + { + if (IsRootNode) + _relativePath = _wmiNamespace.Scope.Path.NamespacePath.ToUpper(); + else + _relativePath = _wmiNamespace.GetPropertyValue("__NAMESPACE") + "\\" + _wmiNamespace.GetPropertyValue("Name"); + } + return _relativePath; + } + } + + public string ServerName + { + get + { + if (_serverName == null) + _serverName = _wmiNamespace.Scope.Path.Server; + + return _serverName; + } + set { _serverName = value; } + } + + /// + /// Adds new list item to _classes. Called by ObserverHandler when NewObject arrives. + /// + /// + public void AddClass(ListViewItem listItemClass) + { + Classes.Add(listItemClass); + } + + /// + /// Resets contents of _classes + /// + public void ResetClasses() + { + ClassCount = Classes.Count; + Classes = new List(); + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Classes/WmiNode.cs b/WmiExplorer/Classes/WmiNode.cs new file mode 100644 index 0000000..6df8221 --- /dev/null +++ b/WmiExplorer/Classes/WmiNode.cs @@ -0,0 +1,68 @@ +using System; +using System.Management; +using WmiExplorer.Sms; + +namespace WmiExplorer.Classes +{ + internal class WmiNode + { + private ConnectionOptions _connection; + + private string _expansionStatus; + + private string _userSpecifiedPath; + + // Constructor to create Root Node + public WmiNode() + { + } + + // Constructor to create Wmi Node for the specified namespace + public WmiNode(ManagementObject wmiNamespace) + { + WmiNamespace = new WmiNamespace(wmiNamespace); + //_connection = wmiNamespace.Scope.Options; + } + + public ConnectionOptions Connection + { + get { return _connection; } + } + + public string ExpansionStatus + { + get + { + if (String.IsNullOrEmpty(_expansionStatus)) + _expansionStatus = "NoError"; + + return _expansionStatus; + } + set { _expansionStatus = value; } + } + + public bool IsConnected { get; set; } + + public bool IsExpanded { get; set; } + + public bool IsRootNode { get; set; } + + public SmsClient SmsClient { get; set; } + + public string UserSpecifiedPath + { + get { return _userSpecifiedPath; } + set + { + _userSpecifiedPath = IsRootNode ? value : "NotApplicable"; + } + } + + public WmiNamespace WmiNamespace { get; set; } + + public void SetConnection(ConnectionOptions value) + { + _connection = value; + } + } +} \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_About.Designer.cs b/WmiExplorer/Forms/Form_About.Designer.cs new file mode 100644 index 0000000..0b86250 --- /dev/null +++ b/WmiExplorer/Forms/Form_About.Designer.cs @@ -0,0 +1,173 @@ +namespace WmiExplorer.Forms +{ + partial class Form_About + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + 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(Form_About)); + this.tableLayoutPanel = new System.Windows.Forms.TableLayoutPanel(); + this.logoPictureBox = new System.Windows.Forms.PictureBox(); + this.labelProductName = new System.Windows.Forms.Label(); + this.labelVersion = new System.Windows.Forms.Label(); + this.labelCopyright = new System.Windows.Forms.Label(); + this.okButton = new System.Windows.Forms.Button(); + this.textBoxDescription = new System.Windows.Forms.TextBox(); + this.tableLayoutPanel.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.logoPictureBox)).BeginInit(); + this.SuspendLayout(); + // + // tableLayoutPanel + // + this.tableLayoutPanel.ColumnCount = 2; + this.tableLayoutPanel.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 33F)); + this.tableLayoutPanel.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 67F)); + this.tableLayoutPanel.Controls.Add(this.logoPictureBox, 0, 0); + this.tableLayoutPanel.Controls.Add(this.labelProductName, 1, 0); + this.tableLayoutPanel.Controls.Add(this.labelVersion, 1, 1); + this.tableLayoutPanel.Controls.Add(this.labelCopyright, 1, 2); + this.tableLayoutPanel.Controls.Add(this.okButton, 1, 5); + this.tableLayoutPanel.Controls.Add(this.textBoxDescription, 1, 4); + this.tableLayoutPanel.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutPanel.Location = new System.Drawing.Point(9, 9); + this.tableLayoutPanel.Name = "tableLayoutPanel"; + this.tableLayoutPanel.RowCount = 6; + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 4F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 56F)); + this.tableLayoutPanel.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 10F)); + this.tableLayoutPanel.Size = new System.Drawing.Size(416, 263); + this.tableLayoutPanel.TabIndex = 0; + // + // logoPictureBox + // + this.logoPictureBox.Dock = System.Windows.Forms.DockStyle.Fill; + this.logoPictureBox.Image = ((System.Drawing.Image)(resources.GetObject("logoPictureBox.Image"))); + this.logoPictureBox.Location = new System.Drawing.Point(3, 3); + this.logoPictureBox.Name = "logoPictureBox"; + this.tableLayoutPanel.SetRowSpan(this.logoPictureBox, 6); + this.logoPictureBox.Size = new System.Drawing.Size(131, 257); + this.logoPictureBox.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.logoPictureBox.TabIndex = 12; + this.logoPictureBox.TabStop = false; + // + // labelProductName + // + this.labelProductName.Dock = System.Windows.Forms.DockStyle.Fill; + this.labelProductName.Location = new System.Drawing.Point(143, 0); + this.labelProductName.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelProductName.MaximumSize = new System.Drawing.Size(0, 17); + this.labelProductName.Name = "labelProductName"; + this.labelProductName.Size = new System.Drawing.Size(270, 17); + this.labelProductName.TabIndex = 19; + this.labelProductName.Text = "Product Name"; + this.labelProductName.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // labelVersion + // + this.labelVersion.Dock = System.Windows.Forms.DockStyle.Fill; + this.labelVersion.Location = new System.Drawing.Point(143, 26); + this.labelVersion.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelVersion.MaximumSize = new System.Drawing.Size(0, 17); + this.labelVersion.Name = "labelVersion"; + this.labelVersion.Size = new System.Drawing.Size(270, 17); + this.labelVersion.TabIndex = 0; + this.labelVersion.Text = "Version"; + this.labelVersion.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // labelCopyright + // + this.labelCopyright.Dock = System.Windows.Forms.DockStyle.Fill; + this.labelCopyright.Location = new System.Drawing.Point(143, 52); + this.labelCopyright.Margin = new System.Windows.Forms.Padding(6, 0, 3, 0); + this.labelCopyright.MaximumSize = new System.Drawing.Size(0, 17); + this.labelCopyright.Name = "labelCopyright"; + this.labelCopyright.Size = new System.Drawing.Size(270, 17); + this.labelCopyright.TabIndex = 21; + this.labelCopyright.Text = "Copyright"; + this.labelCopyright.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // okButton + // + this.okButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.okButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.okButton.Location = new System.Drawing.Point(338, 238); + this.okButton.Name = "okButton"; + this.okButton.Size = new System.Drawing.Size(75, 22); + this.okButton.TabIndex = 24; + this.okButton.Text = "&OK"; + // + // textBoxDescription + // + this.textBoxDescription.BorderStyle = System.Windows.Forms.BorderStyle.None; + this.textBoxDescription.Dock = System.Windows.Forms.DockStyle.Fill; + this.textBoxDescription.Location = new System.Drawing.Point(143, 91); + this.textBoxDescription.Margin = new System.Windows.Forms.Padding(6, 3, 3, 3); + this.textBoxDescription.Multiline = true; + this.textBoxDescription.Name = "textBoxDescription"; + this.textBoxDescription.ReadOnly = true; + this.textBoxDescription.Size = new System.Drawing.Size(270, 141); + this.textBoxDescription.TabIndex = 23; + this.textBoxDescription.TabStop = false; + this.textBoxDescription.Text = resources.GetString("textBoxDescription.Text"); + // + // Form_About + // + this.AcceptButton = this.okButton; + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.AutoSize = true; + this.CancelButton = this.okButton; + this.ClientSize = new System.Drawing.Size(434, 281); + this.Controls.Add(this.tableLayoutPanel); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "Form_About"; + this.Padding = new System.Windows.Forms.Padding(9); + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "Form_About"; + this.tableLayoutPanel.ResumeLayout(false); + this.tableLayoutPanel.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.logoPictureBox)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.TableLayoutPanel tableLayoutPanel; + private System.Windows.Forms.PictureBox logoPictureBox; + private System.Windows.Forms.Label labelProductName; + private System.Windows.Forms.Label labelVersion; + private System.Windows.Forms.Label labelCopyright; + private System.Windows.Forms.TextBox textBoxDescription; + private System.Windows.Forms.Button okButton; + } +} diff --git a/WmiExplorer/Forms/Form_About.cs b/WmiExplorer/Forms/Form_About.cs new file mode 100644 index 0000000..9f9c73c --- /dev/null +++ b/WmiExplorer/Forms/Form_About.cs @@ -0,0 +1,100 @@ +using System; +using System.Reflection; +using System.Windows.Forms; + +namespace WmiExplorer.Forms +{ + partial class Form_About : Form + { + public Form_About() + { + InitializeComponent(); + this.Text = String.Format("About {0}", AssemblyTitle); + this.labelProductName.Text = AssemblyProduct; + this.labelVersion.Text = String.Format("Version {0}", AssemblyVersion); + this.labelCopyright.Text = AssemblyCopyright; + //this.labelCompanyName.Text = AssemblyCompany; + //this.textBoxDescription.Text = AssemblyDescription; + } + + #region Assembly Attribute Accessors + + public string AssemblyTitle + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false); + if (attributes.Length > 0) + { + AssemblyTitleAttribute titleAttribute = (AssemblyTitleAttribute)attributes[0]; + if (titleAttribute.Title != "") + { + return titleAttribute.Title; + } + } + return System.IO.Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase); + } + } + + public string AssemblyVersion + { + get + { + return Assembly.GetExecutingAssembly().GetName().Version.ToString(); + } + } + + public string AssemblyDescription + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyDescriptionAttribute)attributes[0]).Description; + } + } + + public string AssemblyProduct + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyProductAttribute)attributes[0]).Product; + } + } + + public string AssemblyCopyright + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyCopyrightAttribute)attributes[0]).Copyright; + } + } + + public string AssemblyCompany + { + get + { + object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCompanyAttribute), false); + if (attributes.Length == 0) + { + return ""; + } + return ((AssemblyCompanyAttribute)attributes[0]).Company; + } + } + #endregion + } +} diff --git a/WmiExplorer/Forms/Form_About.resx b/WmiExplorer/Forms/Form_About.resx new file mode 100644 index 0000000..f4ea5e9 --- /dev/null +++ b/WmiExplorer/Forms/Form_About.resx @@ -0,0 +1,610 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAAHgAAAEGCAIAAAAhWcaAAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6 + JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AABvkklEQVR4Xu29B1hUd9r+z3X939+7bzax + RQWmnZmhS++9i4KCXRRRsKGoiKKIKIJKlSrSpTdpioWmYm9gLzEao4kliTGmZ3ez6767yb7/+3u+M8fD + DBiTTVE33+u5cKSe85n73M/9nJk5oyEsE4rKRaIKkbhKLKmVMPUM08hIW6Ty3XL5PrlOl45Ot47uEV3d + 47p6J/X0TrGFG8f09I7o6Xbr6u7X1W3X1d2nq7NbR2enjk6zjk6jjk69jk6djixDxsxhRJailJSUy5cv + f/vtt3/729/+/ve//+///u8//vGPf/7zn999993333//L3b936u+WNBlInG5WFIhkVRKmCpGWiOV1kpl + O2TyJrm8RS5vlevs1dHt1NU9oAuy4Esoo46yrA+xn8dX29RY1+joVOvI0mXMbEZkIUpPT7958+Zf/vKX + v/71r0+ePPlPw60BylA0Bc1UMgR0lVRWLZPVyuR1cnm9XKeBBdeio9OqA+US/Xbp6h7UJYi5UrLW3aOr + s6sPa3mVXF4pl6ZKJTMlQmNhYWHhhx9++B+Im4B+SrlSSblaJq+Rk6qVwwQIsh06hHiTkvheljjgwjoA + HQXWuAOojbSqsa6Qy8vl0o1SyWSJUEfY0NDwpz/96T8KtwYoiysUoEFZWk1AP6Vcq/O0OOIgCI4qxEEZ + hRucZeMbVFiXyeWlcmY1I/YRR0REHDlyhMP9ynu3hrhMLCmXMBWsnCtZOdcoQPehzBVwqxCHL+9mXQXW + Acq0uPaIgwDfybEulcu3y+WFcmYRI7IXbdmy5c6dO3zcYK2CW7GlL/nSEBeLxaWENaFcJUPJq+WkBgLN + lYqlgPguHXi0gjgKN2DZtD2qsC6Ry4vlsmSZZLpEqC9samr6+uuvgZtLJq+etDXEOWLJNglTxDAljLRM + KquQySoJa3DpUyqUuepX4LAUShzGwrVH3B+1PNbFcnkRK+0oRuwpXr9+/ZUrV4D7z3/+80DGrdjkl3Np + iNPF4gyxJEPC5DDSPKmsSCYrkREzLSdpAfnsuYir44ZBgy8sBaDhIVwUqevLulAuL5AjcUtmkUxSX1// + 5ZdffvPNNxQ337hfdmlriFPFkjQJs4VhMhhplhQl2yqTb2MRwExBHFCApur5NK6CWylwUmDNtcdqnT6s + 8+WyPBmzihF7iTds2HDjxo2vvvqKc5JXQ9oa4mSxJEXCpDFgLU2XSjOkskyZLJstEM9jD3Ae8efSOB83 + tW/gpkV1ja/Csvms8+SybTJpmlQSKBEaCPfs2fPFF1/06yQvqbQ1JIkSJplhUhjMFNhP2RYZZjnCmsNN + ieezRMDl+QWujhuKpqy5KMJjDVHjD8lyZMwyRuQkysrK+vjjj+EkNJO87NJmQScx0mQpqRSpLE1GiuLO + YHFnKXHnyMBCxVJ+QOAq3k1x0+JYVypZw6y3KVhLN0jF/mKBUNDb2/v555+rS/ulCyQaoMyBlqXIFJXK + w60u8FwWN9D8NNwoyho3KGscIiqs2T/EzGaEo4QtLS2ffvrpyy5tAvqpnDnQfNwDCRx+UvBj/EQdN0RN + WdPYh7sNvw2NEaxx9FDWsBFH0bZt2x4/fsyXtnrWVuzQi7o0xIvFTDxhrUqZX8/G3de+f1jdYM3H3S/r + 3Kespeuk4jEkaN+6deuzzz7jAsnLZSMazs7OAgOByE0kni5mljOqiPnF95OB1P08ZsKXNj01iI/qrJUG + QlinSCVTJAKJ4PTp05A2AgmytoqNvOCsNerq6vLz82NiYoKCghwdHUVWIom/hAljZBvVQNN6hrqpd2O8 + Biy0OHXcHGsV3FzRcaY/1ihi2YbC9vb2Tz755KWzEY2dO3e2trbuZhfSa3Z29pIlS8aMGSMyF0nGSZhF + jCxRjTVKHTdHBMmERu/nNG7OSVC4MbCuUVCAyEKEARLJDx2S2ghNIy84a42Ojo7Ozs6urq79+/fjBhYk + 09bWBpkvX76cELcWSSZLmEg1V+GchOIGaw53zg8ZtwprDjetZ7NeTk77FRcXP3z4EDZC00i/lq3YxRdj + aRw5cuTo0aPH2IUbhw8fPnTo0MGDByl3QIfGFyxYIJQJxR5iJlTNUp5h3NRJIG32tMkPS5uPm2Y+yhpD + o7Ix0sKwLnIR5eTkfPjhh8+2bMVevgBL4yy7zp07h4+YDs6cOXPq1KkTJ06AO+4DDjrC7IYNGyZOnEgE + Pl0iXaMWujnc/6a0KW58fCZr6Vop7vjU1NQPPviAb9kvbHvUeOutt65fv46P165du3r16uXLly9dunT+ + /HlwB3R0eUCH0kG8u7sbxHNzc0NDQ4UmQskECROl9JNnJ26+tNVdm8+aj5vPuogd0Pmss2TSOKnYW5yY + mPjgwYNHjx4h+am3xxeHtcadO3feU6533333nXfeuXnzJtCD+5UrVy5evAjoUDqInzx5EjKHt4B4RUUF + eiYyAIkoK1ncYP08rg1qz2kj6qwxyHCgUWAdLxX7iDdu3Hj//n2uPapHkReBtcZHygW/w2GILb537x6g + 3759m4MOpUPmFy5cgMw54tA4un9kZCTBHSCRrpI+ZT2QtGkgeR4b4XDjBjejq7DGr82USRPIOJOQkIAt + p+2RiyIvFGsNqAAHHTwON7CV8DtIA9wp9Lt373JKf/vttzniVONwFfj4jh07IiIihKZCyVSJdL3ytJQK + a07anI30G/74oLliv6Q491TIDo3qrH3EmzZtgkSw5VwUeaFYa8DX0LKxWfiI29hEQAd6DjqUDhOkMqfE + OY2jhfb09KB5QuBVVVVhYWEiWxEzh3USPmsVG6FjJOaa57FsWvh8NY81F/hY0IQ1PMRbnJycDGXwWSP2 + vSCsNXC3cwsJCQanAp0qncqcTxyughYKH+cEfvz48YKCghkzZoi9xMxS5lmsn23ZKpRpUdY4DnA09Msa + vdFDnJGRAdZc7HtxWGvQjcBCKsJtxH4kJEDH9nHQ4XrYaCpzSpy6Chop31IgcOonSUlJxLgnS6Qb2EcS + ONZ9LZs8fPOc7ZGCpmYN1jgaMMhwIYRjHSMVOYvy8vLef//9F421Bv4wXdgIrH6hQ+l84pzGqY9D4Ldu + 3bpx4waCCsWNXIixfunSpSInETltMjBrNLc+7ZEPGvUM1jRc01+CYkGjkDhFdqLy8vJnsP5NZhkNevfS + hS3A6he6OnG4CnYDAZYKHDvG+QmHG6FbqCuUTJLAQ38G1spPEtbw92JeCFGKmrBeyojMRc3NzSqssf2/ + IWsNxb/KRYljUeIUugpxzlXg41TgaJuIVnBw+IkK7q6uLkRAsQvr2j8Xa5g1WNNwzYUQjnWGjFnACA2E + Bw4c4Fir55BfmbUqaP7iiFPofOJwFb7AsRvUwVVwUzNB+s7OzhaOEjJBjAK0OmvEvudhrfwMAa0eQiho + yjqIEUgEuKdfENbPAs2tfomrCJzvJ3zc8G60SkyYLS0tmN3F48Qka3Ogfyxr3mcIa3wnQkiBsjHyRI0/ + IZkoiYqKQrvGltDMhy2kcyM2HruAffnVWD8XaG5xxPsVOPUT7AynburdaJVIJpcvX0YKjI2NRTBgIlhp + q7PmPEQlh3CK7pc1QgjXGDnW6TJpolQ8WpySkqLOGvr4lVn/ONB0cbixgJsTOB83NRN4N22VNAhS487J + yRGaC5m5DAE9EGv4L0DzZ/T+QCvMWqUx0l/Iilq6RiqyJyEEdzYmANz36Cj03BNljY0Ha7pHit37ZdZP + Ac0tDjffTzjc1LuxY0gmCILYT+okmHHq6upIGgmUPAXNZ50nU+Tr5xC1gjXfrHmiRjHhjNBI2NHRgb+O + uxypFAoAazQYbCq2GVuOXXihQdPFqqGPn1Dc1LtpMsExiz2EcSN0U2l3dnbOmzdPMkGCA/wpawqam2XY + GV0BlA+6L2sCul+zZkVNWKMxCgTwLsoadzx6CXSALfzVWP8MoOlSx821Ss644SQIAJD27du3IW0E7RUr + VojHiskASUFzoqYzOsyXa4wqoFHqrPlmTX8hCxqxEk04Pj4erQImhvsbW6ISrn9ps/7ZQNNFWWNR1hQ3 + 30lUpI38t379erGXWBqrxnqr8jwf9+xhFdAojrV6su4ravx+kYOorKwMdzD+NKwMW8IFvl+hMf7MoOlS + kTbnJNgrOAkOW07aOJahssTERLGrmIlmFKwpaI41/HcgUaOUrAloLllTA6G/TSlqZjEj1BceOnQIAZ8L + 1/wQgq3FNr9MoLGwuSq4qZOgBUHa1LVp/sOxjD1PT08nsW81y5oTNQohhG/W3KMBaqAVrKmB5PMMhIqa + Pd8imSbBmIpcj4OJH0J+hcb4S4Gmi8OtLm3q2jSQUBvB9EhOQoE1QKuYNVhXsAYCsj/ImqY9voEoRS3d + LBW7i5Ev0Y25EMI1xl/UrH9Z0HRR1nxpU9fm2wgGCkRdwhq6hofwRa1iIBS0Cm6ONcxa3UB4omaWkbTX + 1tZ2/fp19GSVxsiZ9UsJGosIu6+0qY1g92iHpHMNVJaZmSl2E0vXSZ+CRvGnGGB9JmuFgaCL8hOIUtSy + NPJSsCVLlmB0oo2xX7P+2UX9K4Gmi7LmpA0bgYiojcArcRSDNVSWmppKckg8jzUMhCZrGAhogi997kd/ + oBWsYSBIIHSEAWjKmhW1dJMUvXfr1q0YnWBZOJhg1r/0FPOrgsZSYc23EewqTX5ojxs3bhT7ismTiTnW + XNqjBsI9p6lf1pyBYIShP04NhAUNUZNxUU948OBB5Ev+FPPLGcivDRoLW09x822Es2yuPUZHR0smSp6C + huEqDYR0RSrqgVkrDIQ7B8J1RRY0MZAJktWrV1+8eJFOMVyy/oUM5DcATRdlDdVwrGnyo+0Ruw2thYeH + S2byWEPUynGR0ARi+gRUvocoQStYw9ZVuqJS1GSEsRZVVlZiNKfJGn3il0t7vxloLI419gesueRHUzZY + nz59WqgrZBYwCtBU1DAQ2hUBl3uyb3+sFaKG29BYrSZqZjYze/bsc+fOIVkj83Bp75cwkN8SNBafNfZK + nTVymNBCSJ51RllTUXNdEZTpqwWeYSAqXZGKmj4VIlmGWI1ZCQaCtPeLGshvDBrrB1lXVFSIXEWKEMKJ + msZq8KUvzlBhrQT9tCvyZ0VO1KnsXC4jcznSnoqB/LwjzG8PGgv7gMWxxu6psE5OThb7ixWg1UXNveKo + P9YKA0FX7FfUqTLEm/Xr1/MNBA2ZP8Jgq/59A3khQGNR1hBOv6yx80uXLoWlElLgxT1ZkoqagqasBzIQ + Oiv2K+pI8tKY1tZWlQRCR5ifqyu+KKCxnsEaOeTkyZNCYyGzgiGgqXtw8QOIm9iCjTxb1PQESF/QshSZ + JECycuXKnp4eJBB6vok7BwJRcwbyioDGUmHN+TXN17W1tWQ6xxSTy7oHN5RDyPTFz882EBr1+KKm7pEi + k66SCk3IlZ7Onz9PzzfRcyBcV/z3Rf1igcbqlzXN11BZQkKCZJqEgMZETgfFSjbnATH/Zc9qoElXhKhL + lPOLuqgnSZYtW3bmzJlnd8VXBzQWZc31RrDGBEFn9Bs3bpBkHcEoQLOnqglHmAYotyhZ/6CoaabmgZZG + E1HX19efPXv2GV3xJ4v6RQSNxWeNPeRmdEisubkZaQ9oFKC5lgjEO1nW9LoJHGiONSdqdadmX4mDiR+i + xpREuyJ3Yo/Oiv+mqF9Q0FjYH8hHhTWSAPY8Pj6emcEQ0LBpuAfXEvnXXunPQFRFzeU8FjRxaiNhY2Nj + b28vPbGnPiv+ZFG/uKCxONaQEnYSu4odRoNCNgARHOwENLIH3KOaJQvEu5Ss+00gVNT8TE1bIuseRNT+ + 5Flkp06dunDhAn9WpKKmUe+nifqFBo3FZ42Dl7KGxDAuiseIiagBmjv1QUG3sqxVDERF1PT0KUD3FTWz + nBHqCPfu3ase9f5NUb/ooLEoa+yeSmMMDw9nwhkCGjaN7AGa1D12s6y5C2X9oKh5oFHi0eK4uDjEdhr1 + fi5RvwSgsfisObPu7OwUOYlAioCmNg27YEE/vdjeQKLGj9CzH1xLVLoHE8aMGzfu6NGjiHo/o6hfDtBY + 2CuuMVIDQfCC9JgQhlgBQMOmafag1++kF5F8hqiL2PPUai0RhfsvMzPz5xX1ywSab9Z0ikHmFVmKMCsS + cJxN08sv04ujPkPU2/sOLzzQTBAza9asn1fULw1oLMpaxaxTU1MlMyVPQbM2TUCzF0d9KmoKWsmagC5X + 5jw195CuI8NLVVUVFbV6/PgJmfplAo3FsYamYNbQFw5tobFQmiQloMGRgqYXW0bBQAYSdSU7vAzQEiXj + Sc6DqBE/uEzNDYr8sx+KLfuh9ZKBxgJrFQOBn0pmSBSg2VkcfAnljh8SNcyd3xL57hFOnunb3d1NMzU3 + KPLPfvwo93gpQfMNBAkEhzaOdGAiEOnYgn4I0F0s64FEzbVEgEZL7OseKJEDuZrksWPH6KBIz36onNJ7 + fvd4+UBj8Q2EJhA4NTObISg50PBoepH2NqWoOdBK1kTUaIncqY++oCXTJHPnzj106BA9+3Hjxg16Sg8R + np6n/lEt8aUEjYV94xvIpUuXED/kW9m3fgBoBA8Kmr7LAxV1vzkPLZGbElXcI4o8nNja2nr8+HHEG/pU + mwcPHqAl8h98eU5Rv8SgOQOhIwzJ1IsYolwKGsEDoOm7PLSzosZ9oC5qtERMiZx78ECjxC7kigmHDx+G + qOl56oFynmKzBl4vK2gsFVEfOXJE5CwiLZEPupt99xLcgKibBmiJpbxA3dc9mBlMcHDwwYMHT5w4oT68 + /KiW+HKD5kRNu2JYWBgTw6iCPszqGk7dMnBL5AJ135BHTpzKhDt37lTPeT+2Jb7EoLE41rQrNjQ0SAIk + xCUoaLjzIfJWSIR1F/vuMAO1ROoeajaNwjgO90BLRM7jWiJ99umPco+XGzQW9pAaCESN/RfqCuG2itMd + FPRR8oZTRNrI1LQlqoOGe9DJhZ734IFG9ggNDT1w4AC/JVL3QEt8/inxpQetImqojwljyMBCrQOgj+np + nWDf1quTbYl896CsqXtwk4uKTS8nk0tHRwdaIn3ott8p8dUHjYU95EQN3Yldxbot7LkODvQpwpo4NVpi + v+6B7EEnl37dw0qUm5uLKfHkyZPclNhvoFZsUH/rFQHNF/WsWbNkybKnoI/r6Z1mC6JGzhvIPTC50LOm + aqAl4yTLly/fv38/nRKvXr3KD9Sce2AbniHqVwE0Fl/U+fn5TAhDhu/9CtD6p/UNTxsSUe9XugcHmrKG + e5SxF4vsz6aZuUxAQEBnZycXqLkTp8/vHuRSP4qbL/PiixpHt8hBRIIHRhWAPqFncNrA+IwxcOO/A7qH + Ssjj2bQ0ViqUk0fH/x33eEVAY2FHsKtQFvSFKQOHPzHlwwQ05GzWYwbWUPez3IMLeX1Bo3DPpaWlUfeg + z7D5se6h8Yw74eVaVNTYW+wzehezgCFyPkI6IRBb9lpa9FgQUVP34INmWStC3kA2HSAJDw+n7qGePZ5n + ciGgXxlRY1+oe8BJxW5i8satCNEsaKteK9uztiZnTBTu0e95j3KeTfcFzcwnj9i2tbXx3aPfyWVA0D8Y + AF+ihR3hWuL48eMRJGjkgG+AsuM5R+AmLRHj+EAhj2/TPNDSGKmAEbS0tNDJ5dy5c2+99dbt27f55z2e + bdMaz7bwl2sBNCfquLg40KGd0LzH3OGcg+t5V7CGX5NxXMWmWdaqNs0DjUKazs7OhnscOXIE7qH+UADu + 3WfYtMazLfylW5yooT5Mz/ANkIVBO5138rzo6XHBA9DhHuRZH2qgSchDmh6gH4pHi1etWtXe3k4fClA/ + a/psmyagXzH3gG6wUziuRZYivQPEoK17rSHn0ZdG+1zygbRJ9tjL2rQKaIgaaXpr//2QCWSCgoJg09xZ + 0+vXr/cb8voHzTnLK8Oac4+pU6fql+jDoO3O2kHL4y6NC7gcgBskeyDkDZSm6Uv11UGHM56ennv37uVC + 3rVr11Rsmjs9rdgU3tKgzvJKtsT4+Hi9dXrUNyDniVcmTr061feSL9CTkAeb5oNmWRObpv1QLXhI15N+ + 2NTUxIU8+tya57Rpcv3oZ7fLl25hJ7Ev2GFAkQfJkTfgG+ALyjPfmjn5ymS4B7HpgdL0M/qhOXl7tJ9m + 0xrPeU7k5VrYF0gHwYBxYoAVdjH+8vjAa4Eh10PAGv+FTZMnjP1gP+wLGtkcYYZv0/xZ/NlpWoO7H/r9 + 8ku6sCOQFQ5kgUjgsMfB+6I3fGP29dkLbyyc+/ZcmDUyH3kcQP3sEu2HmA/7A435MCwsbN++fZxNP3+a + 1kC75H/51WBNQUM9oaGhdoV2IDv92vT5N+Yve2fZkneWTLs6jYS8TrYf8kGzrNEPSfAAaPTDvgmPmc1M + mTJlz549NE3TRxHVT3r0D5rv4q9SS6TusXnzZus4a8g5+Hpw+Dvhq99djQp9O5TY9IEB+iHmQwQPmvBU + QC9h3N3dd+/e3dHRwdm0ysO1A/VDDfUTfa+MqLE7dXV15nPNIed5b89bcWvF+jvr496Lg6i9LnrpHdEj + j4s/I3ioJTzpWqmZmdmuXbtg09zDteiHd+/e/cF+qEE1/+qJGnuBfQELo7FGkPOim4tibsckvp+YfDc5 + +t1oBGpM52Q+7Bc0fVhLLeHJkmVCXWFlZeVAYwvXD/sB/fDhw3/n+dUv7MIuYEfQpuTm8rnX5i5/Zzm0 + nH4vPft+dsJ7CUgg6If9Bw+wpglPHTSb8HJyclT64Z07d/hPNKUYVUH3+2QybKLi6y/zwl5ghx0dHUMO + h0DF0PK2B9uKPihKv5++4MYCMrYgeKiAZlk/TXjqoJ1EGzduRD/s6uqiz6qhDwJwwWOgfqjBXYzslRQ1 + 9mXy5MkhLSHx78VDy2UflVV9XFX4QWHkO5GYy8kgrpLwKOjSgaO0tzgqKgr9kD8fcqfxqF65uUSxHezS + 4NIJv2m+Gqyx/Tg6lyxZMqt4Vtq9tOIPi3c82rHz8c7qj6vj7sRhbCGDeL8JD1F6ANA0Sre2tvLnQ5VH + W7jgodgOdmnQpklFTTM1vUNega5IQeNID0wNzH2QC767H+/u/Kxz1+Nd4I6hXLd74Cg90MwSKJk5cyYN + HvTRlucMHhrcFfZ+3stTvCALu1BYWDhpzaTSj0qbP2k+8PmBo18e7fqsK+9B3pSrU0jCQ5TuFzSdWdRA + MyHkqQc7d+7kggf/YS0uVvQDGsrnnsv+M16e4gVZAN3U1DQ+bHztx7Xtn7Uf/+r42W/O4mPlw0pM5OSM + R7+gq9gn8vYLOowZPXo0QCN4cA9rPc+JafKes7/E5SlekIWNh+68Z3jDLg5/cRiUaUHdYTfC9E6xM4sK + aPY9nMmjtP2CjmCcnZ1bWlr4J6afJ+FpZGdn08tTcE+x5ke9l501thyKcxnnArvo+bqHAw11I3gYnjYk + J0v7A02e84gpXA20NEpqbW3d3NzMJTz6JLF+Ty31Ac0w5rh/+K8PfZW6IrYc+2XraktNgys4deztWJMz + JmQ4VANNTpYOBHqt1NTUlILmP1D7g6eWNMzMloSGhuJugf7pd9OuSLvni2Yg2IwfXIpvZRf+C6GZWZvx + KaOg7s3vb7bosSDPTlehjALoQuV5JRXQcVIDAwOA7jdKPwu0q2u9kVFgbGws7Yowdf71bX5RA8GhgzaC + bW1sbMzPz9+0adOKFStwr2PEQMNxcnKysLAwNDSUyWQSiUTILtzAf/FJfAnf4O3tPWnSJPxIZGQkYty2 + bdt27NiBeIsohV3ANmPhrxiMMuj9updfYI1x3KrXikzhKpRR6IcDgJZtlMnlcjTYfs/hqT+mpdhVFvQO + R8c8Pb3RGOFxCHAGgqSiYiD4sZ/MGr8HbQCRKC8vb/Xq1YGBgcBkbjxqrIdryNSJq8Pmpq1ZuT1lY0t+ + dnd1ydld9Tf2775/vOvx2aN/unz6ydvn//HOpe/fvYzCDfwXn8SX8A032prO1pV0F6S3JK/bHr0kNSx4 + VWDAHB+3sbaW5ga6GL7xh5YvX/7m8DczdmTUnak78uGRni97SH3Vk3Mvx67HjiiaPb9B6nlAJ8oYhgHo + gWaWZ4FG2dhslkqt6+rq6EMG1EBUEsiPMmv8FP489JWQkICEr6cjH+PuGh48Y0tMVMPW9FNNVcD0j3cu + /uv2lX+3bvT+6/Kx73u7vj/e+v2hhu87Kr9vLfy+IevvFZvvpq84GRNaP39ilLPxPDdzD1M5I9bynuw9 + d83cjds3xrTF2B2zk+9krz+B4nCjYB0FA4BOlolEIoBWP1kKgT5jOAToBrZ2WFquEov14Tt8A6EJ5DlH + GNyZyJXQ7KJFi3Tl8gAf7zWL5pelbj7RUPXxmUOqgH7GunXxX9dO/evCoe9Pt31/uPn7rqrvdxPW31Ul + fVca911B9KN1M55smfckefa9NRO753sVTrKLdBvlbSIaqvWHQT6DhgcPF6wVMAUMCRts6VSxoGm8S2aL + xxoOBq9THw77fZRWgYYF3eTq2khxm5qGzZs3D+5ODYTO5c82a9zGn9m+fXt4eLiJkeGsiQHQbHtZwb1j + Xao4ftF699K/rvf869KR73s6ibQP1H6/t+T75q3f1aZ9V77x0aa5T3LCWdbBTzZO/9uGSX+L9f/zau/z + c83K/WVRjlrehoNHav73IM9BI0JHCBOE9NmO0gypNFUqS1KyVhYFTYdD7jmPUGe/U7gCE0C7uTXzWY8a + FYyOxM3lOBa4sZJv1qCPv5GcnIy/OsHHe/PKZftKtj04cUB1/3/NeufCv946rWS9i7BuK/1+V/73OzIf + pUc8KV79JHfZk4yFT1LnPNk042/xU/4cM/bxSodHS60eLTJ7tND47Az9ojHixTYj7HRe/6+h/9+w8cO0 + FmhJNpD3TCOVRIpATyLWAUtEJqZT+LNBc6IkoHmsG52cyg0Np6xfv54bYbi0B9YQOH57XFyckYH+3OmT + ixI3XNjToLrDv34BMeR89SQo/+vcwe/PdCj8urPq+7bt3+3M+yQ35kll/JPtMU/yVjzJXkyknTTr2/hJ + j6PdH0XaP1rCsl4w6sP5RvfnGb0fatjkL13rqOmjP3jY8P8e4j5Ec7amZJ1Eii4G4hulaIb19fUAzU3h + 9HkH/NMd/YJu4bEmuB0dCw0M/BMTE+E71KzBGlEGbc1AX2/e9KllqZve7tr93S2SBFT3+WcvNEyi06MK + gif3ErUeaf7+UCOp7h3fd9d/f7CO6Be1v+b7rmqWb/n3+7Z/v7vo+10F/2zKebwt5knN5ifl65+URD/J + X0FsJH3+t0lBn8aNeQTWK5weLbV5tMgcuias5xrdCTF8d47hO8EGe/xl6x21xugNHjbsv4d6DdWap4Uc + jXxZW1uLfoiZhZvC6emOZ5xX0nB3363Gusnefque3pj09HRMmUlJSVpaWlN8x2Stj0bw+utbZ/9+A3nr + 4j+VkUsVzU+oqydJHwM10GnK/q46mTSxwujvtkZ+l7Xku/Sw71Lnf5cc+l1SyHeJs0ltDmZvzPkuOeS7 + lLnfpc0n35Ox+LvsZeRHtq38Ln8V+fGitd+VrPtHUezjlEUEcdHqJwVRT/Iin+QufZK16Nu0kE83BXyy + Hqw9CesIu0fhlo8WmjycPwq6fi/E8FawwY1ZBteD9K/O1G/wY1bajnSSv/Ffb/x/mpqaW7ZsaWhoQMKj + wyEd97jTHfS8kipoT8+Oflmbm6doatrpSqWRc2c3b8t8eKr707NHv7p44s9Xz/zt+rn//TdYkygG0dWn + f1cU8136ou82Bf1z3aR/Ro39Z6T3/y7z+HaJ+5/C3b5c7Pr5YtfHi1wfh7k8Wujy8UKXhwtdPlpACjfw + X9QnYS746meLXL9Y7Pp1uBt+6q9L3f++zP2fER7/XOFNfuEaf/zmJ2snfxrh82RT4JPEoCcpc56khTxJ + C0V9mzLr8Sb/T+J8P4n1eRTt8Wil86Pl9oT1ItOPF4x6EGp0d46C9VtB+ldm6l+coX8hUD/fUzhHb7iV + WDMgIACHOBeluSkcRz93uqMPaG/vQyzrPZS1i0ujrW21qWmJqUmRqXGCTOKSFbvq1sE9SBFg/dm5Y19f + OvmXaz0ca2ogz2ZN1Lozj+grZS7L1Ac4wAWMwOuDBc735zm/P9fpTqjTu6FO74Q63QxxuhHi9HaI4/U5 + jm/NcbzWX+Hz+Cq+B4Vvxk+h8OPvzXW6O8/p/nxn/Fr8ctwTn8xzuBto/M0Sx78uc/pbhOvfVnr9LXrM + 39aO/3PsuE/Wejxa40kUvdr9UZQr0TVYE8s2fzTf+MO5hPWd2YZU12AN0Oem6p3z1z800SzJWW+8gdDL + yysmJgZ9i5/w6MxCswMX0gD6KMu608Vll41NtZFRgYV5qb1tpatjHcrOKkVX6p4ZE/Vu9977x/d/fJqw + /ubSqR9gjc8caviuctN3aQsI2eVef1niTrECAZhSoADER3l19s9Q3D1B7wbcZ9dmWp+baPROqO2deXZ3 + 59t9sMD+UZjDZ4scvwi3e7TIGPolKoZHwzpo4TbRNWH9Ueio+yFGYA2/VrCepndhgsH1mVbXZlhemWFV + 5GUUYs7oCTTXrFmDxgj3+Oijj2DTcA/0Q+6MB1gD9HEPj257+z2mpjU2VjWOdrVuTjuUVY+ys0rTl3ul + rlp+u3vfgxP7H5059Pn545Q1pmE+6+9O7CH2mjofx+w/lnngcMZRzyeLPf95sT5PnZtmcWKC4aVga9SV + 2TbX5ti8HWJzM9T2Zqjl5Tn61+cYvDPH8L1QQ/gyHAP98FGYKaEcZv5ogemjecYfzyWs359NbOTtWQZX + p+tfnWx0c6bV24S11dWZ1pdnWNX5miy10bWUCmNjY48ePYpBD/MhHT64oVrD0XG/lWWrg91ed5cOT9d9 + Hi673JwaVFg72GQa6PgmRCy6c6gNrD/pOcxn/fe9pX/PXfG/66f8Y7kn4MI6AReH8C3WBDi4Kvv/q1XP + ZLMTE0ddmGVN62IwKUA/F2x2fKbuqUDdnhl652bqXZqlfy3Y4Ca8IsTw3lwj+MbDuaNAGUV1fXe24buw + kUCDG1OMb8+yfifI+u0gaxwuV2aAtfWlmTY7/c2jHPTtdMTwbrRHbtADa3iIhqN9p6fbodGeh709ur3c + 93u5tXm4tLo7N/bFvcPRLs9Qb2L0gpCrbc2U9Wf12V+lhH2zatyfwl0J3HmA60jg8pSrss+/SZ2eaHJq + sgkHmqszQaaHZ+gcmqZzZJrO0Wk6J6brnmahXwjSvxSkf32W/s1gA5gG+IIy6t4cwvr2DMM7gab3Z1u/ + F2zzbrDNjSCb60HWV2faXJ5pc3Gm7YWZtq0TLKMcDe11Jampqch8MGskEODWGO15jK2joz2PeHsc8nI/ + 4OXW7um6x925SYW1s0OZscHMReO9T6wIvLd0zAfznO7MdbgZYv/2bPtrsx2ukb1yuELKEaWyt79hnQwY + dWaqqQpl1KmZJoem6xyaqqxpOodZ4sen6Z6crntmmt65QD0kDWQ7OAZ8A9BJBRren2n2YYjN/Tk278+2 + BetbwTZvz7K5FmR7JciWsA6yOxdk1xJgudzBwEIuLigoQOaDtDnQlPVRsPb2OOjlBhsB6xaWNYvbsc7N + psLNcrspM104aHjl6FGnA23OBNr2zLDtnWl7Nsjuwiz7C7McLgU7XCb1ArE+Nt6wZ7q5CmXUyZnGfUDz + 6vBUnaNTdI5N0T05RfcMYsZ0PeQNEEc/vDHV4P5M84chNh+F2H4QYndvju17c2zfnW17M9juerDdlVl2 + F4PszgfZnZ1p1xtkVzPOYoGNgT4jQujmg+Zww0YOerl3sZbd6u5Q52Zd7mZR7Gpe5GJe5GxWZCqbLxoq + S3TSOTjF+uh0mxOBNqcJbvwBsLZXZ001zhX7VVL4zouzSJ2f5XAuyP5skH3PTFKnUTPsUKdm2J0MtDvB + K/wXhc/Tb8B34vt72Z/Fb8A9jd+GX6vcBnJ4HfbVOzvD8vwsaxQf9ImZRv2DnqLTPZnUock6hycT4sf5 + xCfqvTvD/P5smwdzbD8MsfsgxPZ+iN3dELs7c+xvzWYP7mD7S7PsLpBNsqP7kudjNs1cF6CPs3zpR441 + bKTby2mfp22jh1WNq0W5s3mJs1mxk1kRLQu9KOkIqwgLSeckq8NTbY5Ptzk1A+q2OzeTsKbSvhTseFmJ + lTLF54GD/nnAOh5odyTQ9tB02wPTbDqn2HSw1T7Fml9tk1VL5RvoT+HH90+16Z5GftvRQFvcJbgbyN02 + w6ZzjE7PTKveIKuzQVbn2KLQj84w7J6mRnmqTjcFPUlRwM0RPzFF99R4navTzNEJbwdbwzruz7F9EGL3 + INT+Xqj9+6EO74Y43Jjj8NZse+wyOODuP8OKBrtJQfctj2OjnfePtm/ztm31tNnpbtXgalnjYlHhbL7d + 0azE0ayYrSJbo0Q97dEzDLQrfIy7p9ocg7Rn2J6ZYdcL3MSniMTOBjlAbhTrsUA7PlMwouD2KWvvJOs9 + bO1+jqLfiR9Bcb+Bf09Q+vsCzJu8dQ5Oszg03eJooMWJGZanZlr2BBHuhwP1Dk6VH5wi7wZctvoFzRXF + fcRXfn6q+ZVAy7dmWN2cBdy278+xvRdifz/U4f5ch7tzHe+EON4Kcbg+x+EKYe1AWWP3+4IGYqcDo+3b + ve3avGwh572etrvdbXa5WTe5WtW5WFY7mZc59cU9igkSDhYlOunCRo5MswbuY9NQtvh4eBrB2jXVun2y + TRu78xQrBUp5tU602jXRaievWiYoqlmtuC+h+D+C34DCr+LuA45+s69xnbfO7klmqL2TzNummHdNteie + ZnEk0KJtqk77ZFnnZPn+KfIDU3jEp+gc7A80qQk6h311z06zOD/N4mIgGVjeCrK+Ocv29mzb90Ls7811 + uDfX8d5cTKdIX45vk9BFjmOwhtSUHq2KmFabh80+D5s97ta73K13ulrtcLGsdbao5OEmxM11V0pH2Cww + EdX5me2baLl7kiUiDtlt3CY7jxso61YWK0Wj4Bjws1bfO4Cirx1tUOOj3zLRbOckUrtY4qhdk0zqJjCN + /szOAOnuCdK2SbL2SbKuySzxyfKDk1A6tPqADtA54qffO9UCrM9Nt7ww3fLSDKtrSHizbN8JtrsTAvcg + oO/Nc8KMdpuMESTjwjbBmgVNjcJuH4fYA2VDQNPicLPSroe0n+I2J7htjdP1hBNGvvHmWjt53Tizen/z + hvEWDf4Wjf4WDQGWTQGW5KO/VVMAKVVAv1Cx92WZu071WMOGCaZNqIlmqGYW+o4JhhXjJZV+kio/SfU4 + yY7xTLM/Ib5voqx9oqxronz/RPlBWnzi/jrHxhkQ0IS15blplucDrS7OsL4SZPPWLLsbwXa35jjcCXV8 + f67jXbBG/GXnYYwUYK0x2qFtNEEMlyBFEXNFKCvL3Wavu81uNyLtJhfLOmeLakfzSkfzcgezMnuzUpSJ + PEI83DLQQJDpYVTua1bpZ17jZ143zqJ+vMWO8ZYN/paN/grcqlB+mcIfyrMXVfuNqvM3rQ8w3RFgCuKN + LPRqf73tfpLSsZIyX0m5b1/i46W7/aV7A2TtAbKuCfIDfNzjdI77G/UBPd3qfKD1RQwsQbbXSMKzvzkH + LdHxDjEQha7B+vocRw0v292etntQHqBsQ6sPayXodrYIbjebVlfrFmerRifLOkfgtqhyMK9wAHHzchvj + bF3hlJFvaIebM2VjzSp8zar9zGv9LOoJbsIa9atJu97PrNCZAWV+UeJl4+VFvuLiMeKSsZLtYxXEK0Dc + V1w5VlLjK2nwY3aOk+7xl7UFyDonKAR+wFd+YoJxz1QL1j0s4R4AfSHQ+sIMMhZenmV3dZYdIgeCxzsh + ju+GOkLRwE1Za3jY7PSwbYUzsNWHtTtbStBt7qTa3WxQ+1yt97hY7XKxanGybHC0qHcwr3EwB25Fmemt + lWq6+khHxNrrQtpVvpC2Rb/S/kVxV/uMKnGXq4CmVeQrLRgrLvQRF40hxREvGysuHyOuYKtqjKTel2ny + Y3aPl+71JwLvHCM7OdHkzBRzgO6dZnl2utU5FvTFGTaXZtpeCrK7Emx/NZjMyUgdN+Y4srjJCTWUhpt1 + ozsynM0uD5vdHGvWJRSgSdm2Aa6bDT6CcoerotpcrPc4W+1yJrgbHS12OFrUOZjXstBr7M0qjaSLhMNM + p+hpJ7sYVPqaq0sbuBv8rQrGmKd4msQ4G4XbGQZb6k001RltJHPSZ6x0GGOpWE8ikoqEYqFQKBCgcAP/ + xSfxJXwDvg3fjB/BD+LH8UvwqwrHmDeyoMs99cu89FQQo2r9TQp8Jfk+4vzRpAp8nhIvQfmIS33EZT7i + CtQYceUYSa2vpNGP2eUn3eslPTbR9NRk8zNTFazPBRLrgKIp6Muz7K/MskfYAOu3ZjvQ87SQ8y2ARmdD + nHCzbkGvA2t3ND0FaFJEvDZ7Xa1JsbfbXG3aQdnNthPF4XaxbmVxN7ECB/F6WrYm+friWdpD5EFGwgx3 + I0g7y9NkrZPRQhuDiaZyF33GiBGbmJg4OTn5+fkFBgYuWLAgMjJy3bp1SUlJWVlZeXl527dvr6ioqK6u + rmNXbW1tVVVVWVlZYWFhdnZ2SkpKXFxcVFTUokWLZs6cOX78eBcXF1NT01GM2NVA6iEeNsdcstZFP3u0 + ER905XjD/LFiDjRXwE1qtKh4tKhktHj7aIK7XIm7erSk2Ut+IMD0yESzE5PNT0+x6KGiBmj2jBIHGgn6 + ajBhjcjBnRbXQHJwtqhClnCzakajc7dpZVnvcVPw3UMpu7DlSlijONZdbFHi+1ysdysFDuJw8AbC3bLR + 3CiDEUwd9EeBePhQzZEj3N3dp06dunjx4vXr1+fk5FRWVoJdTU0NIALlDnY1sKuxsbFJuZr7Wy3sUvyH + t0pKSqKjo0dqj/Se7G3vZT9Se4SFXNvPWLLARp7gZrBtjE6/oEl5iwu8RWBd6C0q9u6L21Nc56nTOs64 + 3d/k4ASzo5PNTxLWVmcDrc/PsAFrgL40y56wZkFD11fZByKQOkgzxNCBfOZsUYGM7GrVCGm7Wu9ytd7N + IibFClYBegDW+9mixKnAdztY7rS1aLYybzI3a7Kw2Glt3WpqmiOTBY8caTBt2rTNmzeXlpaWl5cDMdQK + xPX19RxZkAK+nTt37mJXa2vrbnbtUa69AyzFl/fswTfHxsY6jXZKrU1FpVSnrExbOXvF7LGBYy2dLcWi + 1+303phmNmy1g2aeGuh8LxGqgC3gLlLiLnUX13nptfiN2uVnsme8SWeA2aFJ5senWJ4mrG3OzySn7gjo + YAKasGZBU9YoChqFMa/MyaLKyXKHs1UzGp2rdSt4sUVZP8WtZA0boaz3u9sdQLnZHnCy2W9n1WFl0WZl + 1WZj02Fn1+no2OXsvN/JiZSz8wFr6+36+gu0tEwnTZoUHx8PIUPFVL/gC7jAClKgtm/fvra2tnZ2dXR0 + dLKrS7n2qy3FF7q66HfOmjUrcHFgVnNWVlNWZmNmRkNGxo6M9Pr0LXVbZLGyodOGvu78+v/o/Y+e+DUf + w8HhtiMyPYUsaEKZlCcpylqhbhdx3WiDJt9RmDZ3jjNuHW+6L8D0wCTzo1MsT06z7p1hew6siajREgno + K0rQtDQcTAsczAodTIvsUWYlDuaVThb1zpaNcAD4wECslbgJa1fbTkfrTnvr/dZWB2xsjjg4HHd2PuHm + dtLV9TjKxeWoi8thlLMz+YhydT1ib7/DyGilWOzs4+OzatUquAcQU82CL8V64MCBgwcPdrPr0KFDhw8f + PsKuo+w6prbo5+n34JsdHBxicmLy9uZt27Mtd3dubmvu1l1bs3dmR9VGCdOFWrFaWlFaWiu0hgcNH+w9 + +DWT1xjh/3gbDA63HpHt8RT0U9woR1Gdj9GOsaMafI2b/cDaBKz3+Jt1TrQ4NMXqxDTrHsKanC6GexBd + s6fmcRtB8GTAKA170wI7kwJ700I7RRWzibgG9joA66e4naz32VnutbLYZw3Q9t0s3zNubr3u7mfZ6nVz + 63FzO+3mdsrNDV8iRenjhrv7CReXAxYWKTo6U0aOZObOnUsvdgZtgizFCnwnTpw4efLkqVOnTp8+febM + mZ6enl7lOstbik/19uIb8G3on9ZO1iX7S1DFXcVFnUWowo7CgraCaVXTBOkCQZxAe4229mq2orQJ8eDh + gz0Gv2bwmr7gtQDDodH2mnzW+e5QtLR2jFHdGMrapNnPpGW8aau/2Z4A87YJlgenWB2bRk4XnwXrIPtL + wfYIJKcnmXaP1T3mP+rMZAsNO5N8lK1JAcoO0AnrIjvTUsRh5Ae0NeBGqODjdrbeY2+5x9pij7nZbviD + o+NBF5cjLi7HWIigeRqI3d3PeXhcYOs8W4Q7ysPjjLJ62Or19Dzn4FBrbLyKYdypwOmbVIEXwAHi+fPn + L168eIldV65cuXr16rVr195SW/gkFr6K70Fumb5wevWJ6urj1VXHqiqPVlYcrag4UlF2qMy50lmUKRIm + CIXrhYJ1AkGsQBAj0I5mcS/V0lyg+ab/m2/YvDFo2P+zl74x1/zNTHchQOe5iLa76VT7GNX4jKobO6re + 17jRz6R5nOlOf7PWAPO9Eyz2TbTsmmJ1ZJoNnOTIRJPucYbdfvonJpj0TEX4c0ABdJ4tKbAmpWRNpG1v + hnmvli9tJ6vdtpa7Lc13w4Lhv05OUPEhFPUE1iWAG2olrMHX0/Oip+dlL68r7EfUJRQ+6eXVp7y9L48e + fcXL65yd3fZRo5ZKJE4IauhmsG9QA77r16+//fbbN2/efOedd26x6za77vAW/cy77Jo8eXJ8QXzT+abG + c42NZxsbzjbU99TXnakrP1luWG0ozhGLkkSijSJRgkgYT4gL1wkF0QLtZdpaYVpa87S0QrVGBo0c6jH0 + NaPX9IWvTRk1LN5aq8xDr2q0Uc2YUbVjCOh6XxPCerzZLn/z1gkWcJKmMYY7vHSbPOVtvkaHJlicnmbb + G2h/bob9+Rn2BLS+eLqtyTa21HE/lba9RZONebO5WYuNTZuDA/obENMioClrmC9bxBlgF2Dt6XkeZL29 + r3p7v+XtfX30aK7e8vG55uODj09rzJjrY8a8PXbsO6NHX3J0rDI2DpPJ3Dw9PSMiIpCajx8//t57791l + 17179+6z68GDBx+oLRi6jbMN+O55a8/ua7tbr7W2Xm3ddWVXy6WWtUfXSuukkq0S8RaxOEUsThaLE8Wi + zazAY4WC5QLBMoF2mLb2Am2t+Qrib45/8w3TN4Sv//d0I2Gykx6mTbCuG0tAQ9o1ow2qvPTK3WSVbrI6 + L/3msca7/a3aJ1p3T7Y5NtX21HS7nkD7syxrjWH/85qOwM/KaEt/uIm0rU2KLUzKTIyrrKxaHBzanJxI + inB2PsgWAe3iwikadcTN7aib2zHWhU/BHOAMlPXo0W/7+NwcM+bWmDHv0ho7ltYttnDjtq/vHT8/1Ht+ + fnd9fC6gXFx2WFltNDAIkkis/P39YSzIhbDvDz/88OHDhx+z69GjR5988gn9iJWZmRkSGdJ5u7Pjdkf7 + u+2kbrXvu7lv3419k7snM7WMJF8iyZJIMiWSDIlki0SSJhEniUVxIuEqoXC5ULBEIFgsECxiiS/U1p6v + rTlGE1OVl5eXrtbwyfqCBFtmu5u82JkpdJRsd5VVeurX+Rg3jbNsGWe509+q1d9qT4DVvgDr/ZNsj0yx + PTnN7kygPaStkeJqMF5HkxnpbKYXq2StwG1lnG82Kt/IMN/MrMzGptbOrtnBodXREaxhGoS1i0s3S5nK + mVP0UXf3Y2wdd3c/6el52sur19v7AswBsoVgKVBf3/dBEzVu3D227rP1gK0Pxo37cOzYG2PH3vTzu+Xn + d3vcuPd8fa+5u++0t081M5uvq+umrS1EgIMXY3RE/4SxfM6uL774AiNiRn1G973u7vvd+Hjw7kHU/vf2 + d93pst1vK62RMkUMk8cwuQyzlSHEsyTiNLFog0i0RiSKEokiRcAtXCYULhFqL9IeOX/kEKshBgYGGDhf + f/31YcOGCwa9PkFHM8lBp3q0ce0Y03pfs3pf80Y/C8J6vNUuBWvrvRNsOifaHp5iewKsp9tp5HmZ5HiO + mmkoFAwdNUq2mIK2Nt5mZpRrZJhralpsZVVua1vNVo2dXYODQ4uj414npw5n5y4XF7A+5OqKIpTd3Kic + FaA9PI6jPD0p6x5v73PwhDFjroKgr++7fn7vs2Q/HD/+o/HjH44f/8jf/1FAAOqTgIDHKEp//PgPAgI+ + mDDhg0mTPpoy5aPAwIdBQQ+Dgz+eNq3H37/J23uLo+MSc3N/XV0LOzu7gICAiRMnWmPKurGn672u/Xf3 + H7x3kOBGPejOuJ4h65IBtLREKi2UMvmMJE8izhULs4SCFIHmOs2Rq0YOXz58WPiwIWFD3pj3xushr/9x + 9h9fn/3G/4j+aGnpNG7czFmzli1ZEh8aGuXpGWAk0JpjKsvzgIeY7fAz3+Fn0TjOonm8FVjvBO4A6z0T + COv2iTbdk21hIxpFo03zvAnrxeaM5iCBnmi6mdHWUYZbTU0LLC2329hAy+U2NpUoJe46e/tmR8dWJ6c2 + lvUBV9duN7fDbAExLQVlCtrLC3XKy+uMt3evj8/5MWMujx37lq/vO7AI0Bw//kMW8eMJEz6bMOGLiRO/ + mDTpi8mT8fHjyZMfTZ36ybRpnwQGPp458/GsWZ/OmfPp3Lmfzp//aVjYZ0uXfhYZ+fnq1Z/Hxn4eF/d4 + zZprkZEH7e2D5kaHtd/uarvdue9W+9532nbf2NP6duuu67vGdI15o+KN17Nefz3t9deTSb2R9MagpEGD + Ng0avG7I4KjBgyOHDl325rBlw99cPnJEhObICG2t5cKRMwXDho2IiEhYtmxTRMTmyMjkqKjU1avTw8LW + entPsJOKIqz1a30J6IZxYG0J1s3+Vjv9rcF6N4u7bYLNgUm2GmVjTYt9COutnsazTZk//Nd/aWqOHjUq + ydq6FKUETVjb2lbZ2VXb2UHXtfb29Y6OLU5Oe1xcOlxdD7i5dbu7H3Z3P+LhcdTDA5SPeXoC8QlaLOiT + 3t6nvL1Pe3v3jB59dsyYC8Dt6/uWn987sAV///v+/g9Z1gTx1KlfBgZ+OWPGpzNnfhocDLifhYR8Nm/e + 5wsXfrFo0RdLl34REfHFihVfRkd/uW7dlwkJXyYmfrVly9fZ2V9nZn4oYnSL91ceeXj6yEenjjw8dfTj + U0cfnTrGlvVxO6ZFLqmQS0rlkhJS4iKZuFAmypWKUqXCjYwwTiJcKxHESARrJILVYpT2KvFIH21XVz/A + XbkybdWqtDVrstauzV63buuGDQWbNhUvXrze3X28r4F0k/OohnGWKMLa3xrFsW7xs2oaba1R4WsG1uke + xtPN5HpCLRjchAkTBAI7Q8OV1tZltADa1halYG1vX2NvX+vgANaNzs6tLi5tbm5d7u4HwRqgPT0p5eNe + XkDMp0xq9OjTbPX4+JxVqvuan9/NcePujB9/PyDg4YQJn06a9CVYz5jx+ezZn4eEfDl//pdhYV8tXvxV + RMRXUVHfREd/Exv7TVzcN5s2/Skl5U8ZGX/euvXPhYV/KSv7duXKxolzAo89OnPskzPHH5858bjn5Kc9 + J/HxcU/SrTTpIR2mQQkatZ1lXSgT58pEKVLRZkYYzwjXM8J1jDCW4YgPt9QKDFy8Zk1GTExWbOzW9evz + 4uMLN20qSU4uT0urycioz85unD8/Wl8oDLHQK/Exaxxv2QQD8bfe4WtV621V42lV7WFZ62GhUe1nvtrR + 0E1PguwZFxeXlpaWnJw8b9684cOlOjozLS23saJWsLazq7Szq7K3J6xZ0KgdTk7Nrq573Nw63N0PeHgc + 8vQ84uV1zMuLgPb2BmJafUD7+Jxhi+AeM+bc2LEXx4694uf39rhx744ff9ff/8MJEz6BgUyf/uWsWV+F + hn4dFvZ1ePg3K1b8KTr6T+vW/Sk+/k+JiX/esuXPOTl/KSj4trT026qqvzY2/s3PLzy5MuPkp70nP+s9 + 9fnZ02ydwu3PeidemCpt12HqdZgqHaacrTI5iog6h4KWijYoK05BXLBYMlyoBTmvW7ctLi4/IQEqLklM + rEhLq87M3JGT07xtW2t+/t6iorbU1Mrp0xe660qjbUdVeVlWuJMqd7eocDOvckeZacy21NUTC1esWJGb + m7t161Zko4yMjC1btqCh+/r6isUexsZrbW3LWEUDdAVY29tXOThUY5xzdKxzcgLoBmfnRheXXW5u+9zd + Oz08Dnp5HfbyOurtfdzbm7IGX1pUzk9LSRzeDeLnx4695Ot7lRL3978bEPARBD55MtT9VUgIwR0R8c2q + VYQ15JyaSkAXFX1bXv7Xurq/pqaedBnjvf/9I4TyZwrKtNo/6TI5ZSFt1WFqWdAVbBHWOpIiuThTJk6R + ihOlogS24tliiWtPFHt4+G/YkA8Vb9xYvHlzWWpqVXp6XXZ2U15ea2FhGyJPWdnBlJQDS5d2Tp3aaWWV + POIN7ck68kwHkzJXs3I3RVUCdFBQUFZWVlFREYaC/Pz8vLw8EMfKzs7G5+fPn6+pqaenN9vaOs/ODqDL + 7e0ButLBocrRscbRsdbJibBmQaOaXF13ubu3eXh0eXp2e3kd8fY+Nnr0idGjT7I1IG5UX40T4kqN34LG + AwKg8cewlMBAIvBFi75ZvvybNWuItIF769a/FBd/O2VK/Mq02BOPe0/0VTQq8sYq6SFdpkmHqdZhKtli + WRMDyZeLtwC0TJwoE2+k9ZS4pp1w9uxIVsWlyckQck1mZn1OTkt29p74+PYlS7oCAw/4+cEzD8A/nZx2 + 4fgGKIaZaactWm1mUOZqWu5mWuZGPmqUsQtTAAIpVgm7itkF+lhJSUnITAzjYWoaY29f4eAAyqQcHavB + 2tm51tm5ztkZrBvYF9CBdbObG8Xd6eXVzb6iQB23Kmh+KYn3wlWUMoeP3+DJ/DGVOaAvXkwsZdGiy6Ms + 7Wp7Wo9+3HvsUe+xT3qPc8Q/O+vS6yFt02F2qIFGS8yVi9NZ0Jtl4k282igTLmVGigToe/HxpdHRFUuX + Vs2ZUz1lSr2fX4uHx26kAGfnvc7OuIEAhlzQAMpwVPagL9XXjxQP0QrWl4MyLY0KdtGHOaqrq+nHmpoa + 7iMWPrl69WptbR19/Rk2NpmYj1FOTtVsEdYuLnUuLvUuLg3QtZJ1i7v7Lg+PfZ6enZ6exExY4seVrFXh + 9ls8mT+FrlT6O+PHk7gSEPAx7MXMLDVk1fIDD3oPPujt/qC3+8PeQx/1Hn7Ye+Rhb9LNLNFBPcEOHUGF + XFgmF5aSEuFjiUyYLxNskQlSZILNMkGCVDuelNYGqWacdOR66dAxIgODSe7uBc7ORXZ2SLq0iIXCPMEU + LYrappOTovAZOCq+ikPf1DRJIPAbyzBpdqMIaAqUPozU0NBAHzfiP8CBhdtY5eXlCxYsYBh7E5Mljo7l + Tk5Vzs6gzBXB7epaz76Kn7w2lL7My81tp7v7Hk/Pdi+vA97eh/rifl7itPjclQ6DLnrZw+OAVM+0sLOu + 697prntn9pPqUdT9Ho9jE99skr9ZKnuzQPZmnuzNfNnwPFJv5siGpcmGJkiHxkmHxkiHrpEOiWZ4JXlN + X0tHJ9zcPNXcPI2tDEvLLGvrbba2Rba2pax5AjT4tjg773R23sV+RDVB2g4OmDYQ0rZLpbNttYQx5gYa + QLxjx47Gxsbm5mb66EZbW1tHR0cX+ygGPfuOj1j4b2dnJxrmtGnTdHXHWlrGOjtXs1Xj4gLKtIi0WdYK + J1HipgJvg8C9vA56e/8UgasXRW9ktHrmsrCuuye77p5S1D1F5d2oEnUYDatihhYyQ7cxQ3OZoVtJDcmR + DEmXDN4kHhwnHrxWPHg1LRFXbwQK/vCHEcbGG0xM4k1NN5qZJVpYpFlaZlpZ5draltjZlTk41Dg5NYEv + rMPVda+r6z5kAfYG8u5OfIlVN8aOcn39ZTpDtTQ4xHv37m1vbwfNQ4cOHT169AS7zpw5c/r06Z6eHnrq + HZ85fvw4vpqYmCgS6RgaTrWxSaK4XVyAeyDi5IWLPOK7WeJdrIOThvnvEMd+MromeW1VLGjV8jseOLRZ + MnS7eGieeOg28dBc8dCtpIZkiYakiAbHCQfHCgevEQ5erVp/dNASCscbG69Xgk42N99iZZVtY5MPC2Z9 + Y4eLSwuba9sxRrCTRCebcTvc3PYig7HSxrRRgSNg1KjVGvAEqmJo9vDhw8eOHQPQs2fPXrhw4dKlS5cv + X77GnmXHxytXruC/58+f7+3txR0Aya9du1YiMRk1KtjOLl2pbg66Cm7qJxxuSpxYCo/4T9G4gcHK4MjF + fLhcVd7aKe00GVojGVrEglZSHpojHpIuGrKJBb1WFTFq0CLBHwQjdHXDjY3jTEwSTE03m5mlWFhAzvCN + YogUudbZucXFZTcou7sDMQaIg2wdYEFD3dA1LBtWXmJjk2ttnaGxb98+GEJ3dzd0CtkCMfgC640bN27d + uvXuu+/euXPnPXbhBj6Dz4M7oFPicHBkcIaxMDaeY2eX4ewM46b1o4i38lyF83EElR/wcchKz9Sq+EC9 + CmJaU06GDNvJDC0TD81Xk3OqaPAGVs4xqpRRr4/VHjHC1dh4HawDcjY1TYScWYPOg+2i16EH8uaGA8iy + +MhWp7s7DASujVGuwtER3wxDz7OxydGAMOEV8AT4w8WLF69evQqU4Pv+++8/ePCAnvbF+uijj3D7gw8+ + uH//PiX+9ttvQ+AQPn4QXXTZsmUMYzlq1Bxb2y083D9MnO8q6JweHnt5MlexclXourqLF65bqcKXVs27 + rfIus6G1kqHF/cl584ByRv2PwUipNFjpG5uUvpFjY1PAujNGB2x2KyIsTbEs37301ccuLki60Du8BSEY + JoPEAtDZGrCLkydPUiGDHRDfvXsXiAH3k08++eyzz+h5XroeP3788ccfgzhwQ+McbqgbZlJfX8/iNjUy + QgpM7IubloqVD9Q51aGrKJ1wx1Fs7eZe27NbBTEtIuddA8g5TTQ4Xjh4Xf9yfmOKYOhQaypnExPIGb6R + amGRwbZBUCN5A3MDpjN2QINNNyt3ATLH5+uxm4hkjo64S0rs7QsB2s4uVwOODEywgps3b0KqIEgRA+tX + X331zTff/OlPf/ozu3Dj66+//vLLL0Ef3wCNU3W/8847MBPcT7i38NvQXaOiosRifUPDiZaWa9VYczWQ + zNWhE+6svSCVP+UukUxfnbVRhS+tsneaiDv3K+cM0ZBEpZyjVSmjXrPSFIkmsXKOMzWFogE6CZHDyirT + xmarrS2aYREIgiPMgc21ZOOVO4L/wlgqnJzw1VKUknW+Bo59ODJgQaFwhkePHoEjEAPrX/7yl7/+9a9/ + U64nT57gv5Q4cH/66af4ZvzIvXv3cBzgfoLtwHxg3PB6ZJi4uLhx48bp6nqZmS1xcMjtS1mlVKCrKl2d + +6hR0WOmT26/fbTz7gmuuhSFsDF92E7JkNIfL+dZ2n8YMhyBDDkBf2LUqBhj41gTk/VmZvEWFpssLdNs + bLKgUBgCyxpdsdLJqZK3I7hNimWNrxLcDg7bHRyKNSBGOADsAoZAhQzZgiaY/v3vf6cvr8XCDbo43Pi2 + L774gpoJrAaeTp0EBwc1bjgSGmxmZuasWbNg30ZGgVZWcbxtGqj6sRcVvWM/RTL9tB3bOu8eV6+st4pE + 7QZDq0VDioVDtgmHbFXU4Gzh4HTh4EThoDjBoFjBoGjBoNW0tAetUtQfHUdoaXkYGCwxMFhmaLjcyGgl + cJuYrDUz22BuvtnSMgX5wdY2x94erAtZ1qUQL7CyfLld4FgrpA3W5ELdcAD4AJDRS/pAyNAvmIIvfXE+ + 1nfswn8pdHzDt99+i2+G9nHfcE6CwwIHx/Xr1znjprgxxMNPBAKhjo67icl8W9tU3mY9u1R6KUEvkwWF + rl7SefdYv+V22Hdoo3BIqWBIvmBIrmDIVsGQHFKDswSDUwSDNmgPWqc9aM1TuFy9Ear1h5HD8Mv19ReD + taEhWK8YNSrKxGSNmdl6c/ONFhZJ1tZb0Nns7LaxoLezoCllPmgU/cxTaWuADiQJH6B2AbVCsxQxyNJL + IPyf8lqV+C/HGnqn0oaPc05C+yRn3Cq4ESKzsrLmzp2LYUdPz8fUdLFaRPnhMjGJcfTxrjvb2vn+MfVa + c2HjiH3M0CrhkELBkG18ytqDt2gP3qw9aL3WoLVag1ZrDVqlWq+5DB850klPb6G+fhhlbWQUwYKOMTUl + oKFoGxsoeqvSPQBaXc78UrC2sUnVAGWYMt8u1Clzi7LmS7tfJ6HGrYKbjpfHjh1DmsQgmpycHBwcDOK6 + ut7QuI3NZrWt7KewhyMF0oTSLSp8uTI74DB0h2BIiWBIXl85Z2gPTtYeFKc1KFZr0BpVxKg35mn+QXso + w0zT01ugpwfQ4VC0kVGksfEqU1NYBzw60cqKejTkXADbZeVc/gzQ2CnsGroUdlODM2UVu2AV3IcyXfTz + fNy4bzgnwa/iUiAfN8yEejdaJZIJ5njEyoMHD2IuBfHQ0FC4ikzmCB+3sFhlb5+jssVc4bieHbVIBS5X + M0/PH7ZbOLSCNQ2+nDNZOW96ppxdh48Y4airC8oL9PUXsdYBOa+Eb5iarmPlnGxtnQ6DZuVMfYOT81PQ + 2HjsAnYEu4OdCgwMjImJKSwsJO+VxTflfoWsvlRYU9yQNn7VM3DTVolkQoMgpiT4CQSO6b+joyM3N3f5 + 8uUBAQFisR6sfNSoWZaWq+3ts7l9gLjcxvkOZBrbrpcyHUZD6wRDivvKOVswOF17cJKScr9yDlWR82JW + zstZOcegE1pYbGblnIlEbGfHyVkBGhuJTcUGY7Ox8WPHjl2wYMHmzZu5c861tbUaUCIOf1AeyC4GWkTY + ak7yDNy0VdIhHoESuZvzEypwODg9QYgknpaWFh4ejnQoEjEymQMiuYHBTKmeQWpdjgpfrlwOjxnaLBhS + ptYDIedU7UEJWoPWaQ2KUUVM6zUnuLMzT87wDch5hbFxNCvnBFbOW2xtFW3Q1jbTwmKticlCQ8MJ2Dxs + pI+PD45LJNqioiL+mWcMcfTkqOIdOn8sZW71i5satwpurlUiCNLcTc+ZUIHThgkH5xNva2traWnJzs5e + uXKlsbHxssRlbbfb2u50tN/pan/vQMd73R3vHep4/0jn+0cX9EYM2ysaWikYUsSaBkBzPRBy5npgtCpi + 1OvBI/8wYqhMNoOTs4HBUipn2gZNTVeNGhU+alSInt5kudxLIrEQChlXV9epU6cuWbIkKSmpvLxchSyF + y3/1Anlz359MmVvPgxutEsmEBkHkbs5POIFzDs4nDlcBcUz2syNnH/vkGOrIx0cOfXTo4IOD++/v77zb + 2f5ee961fFm7zqCaoYOKhg7KfXNQzvDBOSMGZ49EDUofOShZc9AGzUGxmoNiNPsixn9J/Y/N0BEj7KTS + iQwznmHGSCToXS5CoZ1AYKGtbaCpKdHT07OxsYFmZ86cGRERAU+AbKktAC5HlnvYhIPLvXoBiiHvCw46 + lJQC209d9Jc8Gzed4Pl+QgVOHRyzJSXOaRyukpKS4jvNt+Viy4lPT5x4TOr44+NP65PjY3rGCNoEmrWa + I7aPGF44/M28N4fmDh26dejgzMGDUge9kfDG67Gv/3HNH/8Y9cc/ruhbK//42qTX/t8b/08ikejq6uKg + sbKycnR09PLyQqtAKIJ9rVu3Lj09HUdVfn5+cXExfd0N9EsfkKJn8zmyu3bt4l63ALjt7e1QCY5OtH0N + KmQsBa1/e9HfpoKbSyY0d9Mxh/rJw4cPOQdXJw7V2LrYFrYXnvz0JIqw5oqFvvjaYvFhsWinSFgjFFYI + hWVCYalQuF0oKBYICgSCbIF2irZ2orb2Rm3teFJa8VpPK05ruN1wPz+/xYsXg+nSpUvRjWFT0dHR4JuQ + kIBElJGRgS5dUFBQVlZWWVkJxBAvlS3VLJ8sFn1dCIWLPo/jEkcn2r4G5aKA9PMt+mv5uLEobggcuFUE + DuKcpXDEsZV6hnrJFcmnPj916jNSJz87SYqFjtp6Z6vxcWPxHrGoXiSqEonKRU9BFwkEuQLtNG0CerOC + skqNnDoSngCfhTUB8YoVK1atWoU0tn79+o0bN4JyZmYmKMMoIGTc5RQx+AIuyGJRzdKH/ShZLO5FIbBB + HJc4OtH2CWgFm19gqeDmBE79hAocxCFwODhnKZQ4vBsIojOjT39xmtTnpwluWiz0A58ccOlxkXRKxE1i + cbVYXCkGaFGZSFQqEpYIhflC8jTRVIEgSSDYJBAkqJZ2pPZwk+Gw3cjISKgYiNesWRMbGxsfH5+YmIjY + w72iFEKGEUPC0C+FC7JoHmghVLMIqZQsfcAPUYrCxUGJYQ0dCGOEhgLJL7k43HyBc37COTi1FI74hg0b + lsQtOfPlGVJfkFIQZ6GjplycIj0kZXYxkjqJpEoirhCLy8XiMrFou0hUJBJtFQnThMJkoXCzULhRKNgo + UJQStOYYTfqSGRgF1tq1a/EXN23ahJYAU+aEDC+Giili8IVsqRugeaCFUM1yZOlrbRClEKhggPS1ILdv + 38Yx+muA5hZHXEXg6sShppDIkIP3Dire++DLHgVxJfSIGxE6J3Ske6RMA8NUM0wVI6mQSMolkjKJuEQs + zhOLMkSiNJEoSSTcJCS1sU9pz9MewYyAXUDCsGPkXzgygtqWLVtycnLQ9yBkeAXaHfobfcya8oVmKVb0 + D4oVmkVHAVnIlpKF71G4sEH0HnQgHKO/Kmi6ONx8gfOJYycDwwL3vb2v96teVM9X5E0mSCmhp72fZnrK + VNYukzZJpXVSCpqpIAXQkkKJJEciTheLUxUvURFt6lPCdUItB61Zs2bBJcAXKgbi1NRU3Lvbtm1DtKio + qIBXwIvR3IAYngvxgi91A4qVEyxGMJBFVAXZu3fvgix8j8KFDSLO4ujEMfobgOYWRxy4OeLYw0lzJiHM + PX3bFBY3B732Ya3DWQd5l1y2UyarZ5/BXyWVVpJiyhimhGG2MeTFKWkSSbIEoElt7lPak7R9fX0BF+0O + fKFiIKZegWiBaAw7RvgFYpgvJHzu3DnwBVy0Dc4KkEopVqpZzGKULLo6yFK4SFbo9uj5OEZ/S9Dc4ojD + DQOCAnac2XH267Oop6yVdfiLw6MvjNY5rCNvlcsaZbJamaxGJqsiJa2QSkul0gIpk8Uw6YwkVSJJ7KdE + i0Ra+lpwDBgxQgWMgqY3HEYIyPAK2DEiGowCKgZiGC7EC77QLOBSrGCKVEqxUs1iFuPIotMALjwQC90e + PR+u+EKApgs68p/hX3eqjlJWKQp68pXJusd0dfbqyJvk8nq5vFYur5HLq+WEdZlMWiRlchgmk2G2MEwK + wySplmSDROAiCAsLA18sGEVhYWFJSQm8ggoZHQ9ChhfDKKiK4Qzgy7cCjikWWjfFyieLTkPhwgaRr+CH + cMUXBTRGLGi57nQd93ZWiuKxnnN9ju5JXZ12HXlLH8rkXfEqZLISmWybTJollaaTt/WQJvcpJpmAFk0S + TZkyBaENiyKGV0DICMjUkREqIGT0OhgxjAIWAcOFeKkVcFhhBRzWgchi0d7Ddv1/vhCgsauTQyYTx1Ch + zKvFNxcbnDbQ7dAlb4y3Q/l+3uwbAZH3pt8ul+XLZNnsm6ekqVKmJVkoEegKEJDhxRQxFTJNb5g7YBdw + ZMQJCBlGjMwAFUO/1BAAF0wBlDLlY+2XLBYaD9vyyez924PGbs9YNKPlUosKWX6tvLVy1JlRul0s5Ubl + m3lzlMvk5I2ABng7XlrSNVKhvXD16tVAXFpaCsRIb2i8oIwxj6OMxIaUBsoQMvwXlKFfqlmKlQLFokzp + 4rByZLFo48Giu/lbgsYOoCOFrgxtu9mmQpZfMbdjyHt479clbyCmTrmcfWP6HJnira1SVRHTEvmK5s2b + B8T0lAWEDLtoYd9oE2MIAhzmDlBG30PTo08IgFFAxdAvRcwBpWsgrFiK3eu7fjPQaC+YFJYlLDv04JAK + WX6tu7NOlTJMg1Kukssr5ORd6bcS0+j3jelpSWZIBAIBcgV9yn1NTQ3SBVrfHvZdNkEZAx4cA5Q5LYMy + LBj+AFugiClWBUvlUuzMc6zfBjQaupGpUWxOrApWlQJl8x5z3QPPpLyNpQzTGIAys4gRGgkRlrkzyJQy + HAMx7hD79m2cL4My1TIoQ8iwCCCmfBWb/lPXbwAau+fk5ZRem66CVaUUjgHKu3V0mpSU6ZsNUsol7Fvw + PtuaV0lFdqK1a9fS147Qk5yUMgbr7u7uEydOICwjYyDGISMjwKH1US1TI4aQ/33KWL8qaKgDvWhC8ISy + g2UqWFUK3e+pY/SlTN5sEJS3y+V5P9QAE6Rib/HixYs5yrT77WLfIe/AgQM0L1++fBnDNMIyzRjofmh9 + nCn/LHLG+vVAo8msX79+YczCfdf3qWBVqfCb4SRjqPgyR5kNc+TNdyll9fd2VJYkgLwrPaUM06irq0Na + R16m5+GoNXMNED0DYRkxDi365zUNun4l0Bi3bJxsEgoTMN2pYFWpkOshhqcNSZL79ygzMxiBRIDZmm/N + iBlogAhzsGYMJufPn7/W3xsK/rymQdcvDhpbj2EX88j2/dtVmKrUkS+PkLf5P6WnmEqeTbnf9ylVFhPK + CA0UDRCLhjm+NR8/fhzj3xX2PXbv3r2L2Q+D3y9kGnT9sqBxeCJdrExe2XWnSwWrStU/qve55KN3XE+3 + vS9lNmP0T3mAyMyEMyIzUXx8PL8BqlgzUjOSDx2ykZphGpitfyHToEtje1HiL1HpqdHTpoz1muCRVpdy + 9OPDz65NN+ItjpkJ27UEDVra1ZraZZrapZraJZraxaS0Ckdq5Y3U2jpSa8tIzaQRmptHaG4coblhhGZc + PzViwZvDjAf7+DiHzJ4UOmfS3NAp8+dODVswfdHCGUvDgyIj5kStmBezeuG6teEJG5YlblyRlrw6c8ua + 7MzYbTlx+dviC/MSivI3FhdsKincrLJH/2b9IopubW01tzFflbrqB4WMQsCw6LHQPairu0dXp1ntPAZN + cs+nZRLmnETLly/ntMw1QEyA1JqRmmHNSM3UmmmeoxMgnU24wUSxMz/T6qPo0uIkWmUlycpKKd+OSkVV + lKLSKsrSKsu2oKrK0xVVkVFNKrOmMjM+LsLX121SyIRtu7cee3REtT7pU10POyac9ZccFglbBcJ6bWG1 + trBcW1imLSzVFm4nJSjWEhRoCXK1BBla2ila2kla2pu1tBO0tOO1BLQSnpZ2pOYI++Hj/EZHrVy8Kip8 + 9aqlMdERsWsjN8RFbUxYk5y4Lj0tPic7qSA/vbQkp7oyv2HH9p3NFXt313a0NR7o2nmoe/eRw3uPH207 + cbzz1InOM6f2nzl1oOf0wZ4zB3vPdPf2HDrbe/gc6uyR82ePXjh37ML5YxfPH7944cSliycvXzx1+dKp + K5dPX7185uqVnmtXet662vvWtbPXr527/ta5t6+ff/v6hZ9N0Qj8qampPpN8UqpSznxxRkW26lX0QZHX + Ra9+TFlFy5j9uKlk4O4nXScVe4kXLFjAhTluAkTM4Bpgb28vl5r7teafN2nw18+g6KyM9cFBE8xsTZYn + Ltt5pVlVxfxSannRlYVGRw2EbdrCJm1BjbagUilkTstFWoJ8LcFWLe10Te0UTYWW458WX9HaqzRHuAz3 + 9naLWrEoagXkvCR69bK1ayLi1q2M3xCduGltWmpcZsbmvG0pxYWZFWW5dTVFTQ2lu3dV79tT19XRdHD/ + zsOcnI91nDzRefpk14ul6AcPHhQVFVnaWy7fvLz5QrOKZvut5k+aJ16ZqHdajyRlzNZqpkwCBrRcxp6T + o2eLBp79UNL1UvFocUhISEVFBadlGubQKlRiBp1N+Cc0uNNGv5A1c+snKjotOXrWzABDU/15q0PLDm1X + Ve4AFXktwuy4iahDIGzWFtRqCSq1BGXaglJtAatiUiXagkItQZ6WIEtLO5XVcqKm9iZNvpZpUUVrRxEt + e3k6r4gMW7liMdyZWPOaZetiYc2rNiXEpCSvz0jfmJuTVJifXrY9uwrWXF/SQqy5pn3fjv2dzd0HdkHO + Rw/vPXYMcm6HO5862fVCKPrcuXNJSUn2rvYrklY09jaqCHagQkyGkPVP62OwVqSLhgFMGQGDnsVHDXzm + EyWNIb4cGhpKtYzFaZlGZvpMAXoKlB8zfunZpN/1vIrOz01YtmS2l6ej02iHFSnL63trjz06rCxV5arU + /MtziSO3s46sELKWoFRLsF1LAAmjqCkjYGzVEqQjYMCUNbU3a2pvhJZpqSpae5nmCLs3fXzcVywPo3Je + HbVkTfTStTHLYc2bEDOSYrekxudkJeZtS91enFlZvq2+trCpoax1J7HmzvaGg/tbug/sPHKIyBnufPxY + 28njHb+lopE6MzMz9Q31Zyyakbkj8+hHR1XU+ozacm8LiRYn+zpyXyH3MeVcXsAYICyjmOUM8nJ4eDg/ + Y/DHv66uLvrQFDb+6tWrdM7+iH2JHz9m/ArWzK0BFb0pYTmGKycHS0cv+yXxi0oOFh19dJhfz1Z04Xv5 + vj1jmENi4R5tYSOihZaggidkomVS2lxSVjVllXqqZa25I4ebDvP391kesRByZmPG4jWrl8TGLF+/bkVC + /OrEzYgZG7IyN27bipiRUV62tbamAKl5V0vFntaajrYGNmm0HDrYCjkfO7L32JF9cOcTx9t/VUVfvHgR + QQLG5+ztHL4uvGBfwcnHJ1V0+uza/Xj37OuzySMjh3R125QZmUYLdSGXk6SsOLOMqe+ZpoxiQsl5jOjo + aBUtc77MaZmezoeWucj8JftyVf6jU7+Olukiik5NXrU0PMh/vKe5maGDh+3cVSEZDVs6brcpzkX0FTJX + 6opu+aAp+EIQ7JjkihZtQb2WoEpLUM53ZKWQizS1CzW1t2lpZ/cV8lNTVimiZc2JI95khs4InLA8YkHk + 8oWw5qiVi6JXLVkbs4xoecOqpM0xqcnrMzM25m5NLirYUsZOgDvqiluaylt3VbfthTVjCGxGcD50cNfR + w3tQx4/uY+PzL6/owMBASwfLwIWBcXlxNSdqfvB8cb+179N9C28stDlro3eUPcnZytoxP1dwQuY9EKU4 + fUFNeeCkjJImSCUBEoFEsGXLFv55DDr70byMjDGQltUfaf01tUyXxrbdW9tu7eVOpPVTalqmReVc+n7J + 1HOTjY4YCDu0hTu1iIqr+6pYRcgFELKmdramFl/ICSr67VNaSzVHOL3p4my3aGEwq+UFKyPDVhEth69d + s2x9LLQclbiJajlhKyJzQVppSXZVxbZ6MgGWwZqVqZnIGUnjcDfnzsgbv5aiVbT5/JV9P3vylcnkkT14 + cfsPqLiPIz+3kFHMIkZkJ+Ie96Narq+vb2xspA+X0Nnv6NGjyMtcxlDRMndmjjub8SvLGUtDVb/q1VfI + ux60hF9eZH/SVtQtEOzREjRqCWo1BVWaRMWchHkqJkKGHUPIuZraWRDySK3kkVqJmlo/JGTUSJiybOjk + Sb4RS+dFLJun0HLUoujVS9auiVgfG0m0vDEmNUWp5fy07cVZVRW5dTWFjQ3bdzaV724l1tzV0bC/E0lD + IWcU3PnFVXTG/YxpV6dZ9lrqHSO5mAx4LcpE0a+KqR1XKjMyfQIGosVzCJlMfb5igeCpKfPDMj2/3NHR + 0d3dTc9jICzRZ35yeZlmjBdBy3T9sKIzb6VPPz/V/Jip8KA2kXCTlnatpnY1JKwpKNUUbGerBNVXxTRX + 5Glq52hqZ2gSFSdByCO1No3UShiptUETpY1SUzFKc/aI4ebDvD2dwxeHRCydq9DyioVEy4qMEZkQv4r4 + csq6zPQE9lRGamkJtLy1trqgkZxoLt+9q6ptT11H2w7I+UAXDc4kbMCd2WnwxVD0ia9OZN3PQhx2OudE + zrR181xYXcJ9VfzUjpErCthnxVE7xrD3zIyMIuliikSoL4yNjeWEzDfl3bt304BBH8bu7e2l5+ToeQz6 + /FrMfioZ47fVMl19FF30XsGSK4u9T3sYHtEXHlDqt05Tu0pTu0L5UN529tE8ImG2ipU3IORi1o7zWTvO + 5Ox4pNbmkVoboWJ+9aNozXkjhtu+6exsGxoyfemSkGVLQpcTLc9fuSJs9crFa6Ix+0VsWL9iY/yqpMS1 + W1LXZ2Vg9ksszN9Suj2rkvgytIzIXAYt79tT276vrpPIGUmjqfsAOa1xuHsXzRu/jaKLPyyOuhWF/OBw + zoE8AfmwLvHffexEN5B+n6Hi7XJ5ofI8Mp30YMcDn7WgRYQ8TSI0EkZFRfHTBZeUMfXtU14IEabMBYyb + N2/S54o/Yq+5RZ9iq56Xf1st06UhPKAl2KslQARuUIq3nCdepX77FPvgNNEybhSNVHjxVtaLVVQcryJk + rp4qWjNkxHCbYY4O1rNnTVkSPgdahi8vj5i3MnIBO/iFx6xZuj52+Ya4lZs3Ricnrd2SFpeduSkvl539 + tmdWlSu03NxY2rqTROa2vbWw5s72HQc6m9g5sJm682+s6H6Uqy5eWnwJ8xMFjcbUi59bxShEC8x7Qj3h + Kvad9tSFjHRBH/FDUj7CvgbtLHshxOvXr8OU7927x4Xlb/pe3uU3mf2evTQGlC2/WAkrisSJkdr5I7Vz + R2pnk+daEAmjIGGaKAZUMa/iNEdOGf7mqKFurvZzQ6YTIYfPYU157gqYciQJGGtWh8euXRbHBoykzWtS + kxEw4rdmb87fllxcmF62neTl+tqCxnr4cunuXdBy9b499IQGGQJRB4mc4c6KvPFbK1pFtvwaSMKIE5wR + c4nih6IxVxj2xO7igICAhIQElWihLuTDhw+fUF43lbsQIkz54+e4stkLtTRUxYvi65c+UahgpFY++1yh + rJFaaSO0ktn6YSNWLc2wEcPdhw3TGuLn67F4UXD44tnQ8jKY8rK5kcvmrVi+YNXKsOjVi2Njlq6LXR4P + U94UnZK4Np2YcgIbMDD4pVeUZVdXbSNaJhmjtJWcZa5ktQxrJnKmwZlk5xdU0er6RVXI5aVkriOnjDkX + 5iT8HEZMS7qKtWNDYVhYWGFhIWfHdNhDRqbRAvOeupBpurijvG7qs035BdQyXRp99FukqRAvfa5b5kjN + LSM0k0eQZ7wljtDaPEJr0withBFa8SO04kaoqHWg0lw2YsTYN4fpDHFxsZ01a+LiMAg5eMni2UuXzIlg + kzJMOWrlwuhVi9ZGL1m3NiI+bsXmjUjKa7akrsvM2LA1exNrymmlJGBg8MvbUVfQ1FCysxkZA+NfJay5 + bW8NtNzRVt/ZXs+e1iDZ+cVTtIp4ESHgv/SxO06/NEj80FynUkTFEyVCE2FwcHBaWhpVMT1lQe2YnrWg + wx4y8sGDB2m0UBcyPX3xed/rpr7gpqyyNLRyR2ohPGSM1ExjlcuKlzxjkz5pM2GEZrziiZpExfxSEy9X + IxcMH+41bJh0iJOjdeD08YsWBi0OmxW+KHgphBwesmwpmy4i56+CkFcvXrtmybpYCDlyU0JU8uaYtJTY + zPS4nOyNeblJRQUppcXp5WVZNZVba2vyGuoKqZZ3tZTDl6k1t+/FEFgLLbPuTAz6BVW0QrkoKJczX4j3 + uf2XX0wYIx4tFuoI586dm5mZ2a+KW1paWvu+dwMd9mhGfuuttxAtBhIy0oXKo9cvvpbp0iCy5ZSrFG+/ + 9QxFa64YMWLim8MshhgZ6Xp7Os2ZNTls4UxOyHDkZXDkpaErls9duWLBqqiFayDkmKVxEPKGFZsSWEdO + WZuRFrc1a+O23M2F+SklRWnlMOWKnJoqhOX8xvqi5saSnU3QchkiM9UykfO+2o59cGeEjRdf0T9JuVwx + 4YxkPDHiiRMnxsTEcBKmAx6XKODFnIq72HcVOHr0KLXjCxcu0Es10OsI0IxMo4W6kF/8dDHQ0lCR7TOK + L+eRi4cPHzdsmNmQIUMGubrYTp82buG8GWHzZ4QtCFoUFhS+aBaixdLw2cuWzomMmLsyct6qFQtXRy1a + uyZ83dqlG9ZHJGwg0SIlMXpLKufImwvykkuKtpRtz6gsz66u3FoPU64vbNpBtbydaHknsea9u2lqrkG9 + VIpWE+kzCkGCmcGIXcRCGbmObFxcHH+0oxLmjBi5mD6m19HRQb2YqvjMmTPnz5+/fPky344//PBD+iJ3 + 7joCNFq87ELm1nMpeuSCN4l+LYYM1RxsbWXiO8ZtTvCkBfMCF8wPXDg/kNhx2EyoeGk4UXHEspDIiNAV + kfOiVixYHRUWE70oNmbJhnVsQE6IStq8OjU5Jj11XVbGhtychLxczHsQclrZ9i0VpVnVFTl1Ndsa6vIb + dxRAyy1NVMul0PLuXeV7iZyr9u1BvUKKlsZKmbmMZJxEZCUSCAT0OshF7DU5IV6qXwQJzoU5Ce9TXhmO + Xrns+PHjSBS9vb3Ui69fv05VfO/evQ8++IDaMc0V9CE+DHvqGfnlFTK3+ih6ZMTwETOHDfceCvMdqjXY + 2FjPxdlmQoD3vNCp8+dOWzBv2oL50xcuCFyklPCSxUTFMOLlS6Fi1otXLohetTAmevG6tUviYpex6XhF + 0uZVKUmY9GKz0tfnZMXn5mws2JZYVJBcWgwhp1eWZVVX5tRWs6bMarm5Ab5cvLOpBFpuhZx3le8hSaPi + 5VY0YgMTSMIvUS4j+MHrIMN/aYrg9EvnOrhwd3c3lfAp9uJwMGLk4mvKd4N677334MXqKv4L+yYkfDt+ + lYTMLQ19XamVpbGHu92EAK+Q4Enz2BfmKcRLCvqdAf0uDpu5ZHHQEjZLREDCy0IQiqNWQMLzWQmTRLE+ + lk0U8cs3b1wJFacSFa/NSl+XnRnH2vHmovykksKU7cWp5SRaZLJCzq2vQVLOa6xHWC6ElluaiJZ3NpdA + y607kTQQnF8JRUOwfM1i0dhAlQvnpREY4kUKhnjhv9DvAfbKnNAvhjoECc6FOQlzRoxcjAGPXlyLRmNO + xfx0/EqqmL80FsyfBuWGLUAR8S5eSMQbvgjiZf13CfQ7m9Vv6MrIuatWzotetWDNKpolwuNil8SvXwYJ + w4gTN0WlJK1OS1mTnrY2M319dlZcbnZCfu6mwnzYcdL2otTSEuSKjKpyOHJ2bRUx5R2123bAlOvzmxqg + ZSJnquVdzUga2181RVO3hWZ3P991kCFeBOFz585R/V69ehVDHfT77rvvci788OFDhGJqxF+xb7iFXMwl + iv8cFfOXxtLwWcuWoIKXL5sdGYFBLmRlZGjUirmrqP+S8xJha9dAv4vj1i3ZsH5p/IaITfGRiRtXJpMs + sSotJXoLJLwlNjsDEt6wbWtC/raNBXmbiwqh4pRSYsdbKsvI62qrK7Ig5LrqrXU1udByQz3ryyRjFDY3 + FrWQUrjzq6loCBZuSzX7PNdBvnnzJiLE7du332evH0ktmAYJ7hJ8cGEqYRUj/k9TMX9prI5CbJi/ZvWC + mOiFsWvC1q1dtH6tUrxxyzbGR27eGJm4aUXy5qhU6DcZ+o3J2EKyRA5x4bhtOfF5ucjFmwrzEoupikuI + iivIq2vhyBk1lVk1ldl11TlIFztqiZZ31G1jtZzfhPGPuvN/gqJhtRd/zHWQIV5ECL5+YcFckFBx4f9k + CassjY0blm1KiNicsDxxY2TSJkxxMF9WvDDf1DXpqTGZ6WuzMmJzMtdtzVrPuvCG/NyEgm0bi/I3Fxcg + FydtL04pK0GlkdfVlqZXlqdXwZErM2urkC6IllFUyw11qDylO/+HKRpW+6Oug8z3X75+qYSh398l3O/S + SE+NzkiLztiyJnPLmqz0tdkZyA+xrHjhv8SCqX4L8jYVF0DCiSXkFYlJpcXkRbVlxI5TWTveAjumV+1Q + aLlaoeX6mq2o3xVN3v0Ni7otNEsnNypb2C6nXIQHFfFy/vu7fp9naeQS2cblbd2Ays+NL9iWUMBeV4gt + ouKSQhTiBH2BeErZ9hTWixVX7SBa5l2BhmSMKuTl3xWtpmi+YKlmVWSLpaJcLMXd9Pt67qVRmLcRRSXM + ipcU73XhimscoJ7nmkq/K3pARbMxQSFYLIVi2aW4L35fP8fS4CSscnUDZfV/BZrfFf2jFa0A/vv6hdfP + cJWw3xX9u6JfoPW7on9X9Ku1flf074p+tdbviv5d0a/S+r//+/8BPTxUq6Ub7iwAAAAASUVORK5CYII= + + + + WMI Explorer is a utility intended to provide the ability to browse and view WMI objects in a single pane of view. + +This application is written by Vinay Pamnani and is provided without any warranties or support. Special thanks to Tim Helton for his guidance and support. + +For feedback/suggestions/bugs, please post on https://github.com/vinaypamnani/wmie2/issues + + \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_ConnectAs.Designer.cs b/WmiExplorer/Forms/Form_ConnectAs.Designer.cs new file mode 100644 index 0000000..0cc6cbe --- /dev/null +++ b/WmiExplorer/Forms/Form_ConnectAs.Designer.cs @@ -0,0 +1,169 @@ +namespace WmiExplorer.Forms +{ + partial class Form_ConnectAs + { + /// + /// 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.buttonCancel = new System.Windows.Forms.Button(); + this.buttonConnect = new System.Windows.Forms.Button(); + this.labelPassword = new System.Windows.Forms.Label(); + this.textBoxPassword = new System.Windows.Forms.TextBox(); + this.labelUsername = new System.Windows.Forms.Label(); + this.textBoxUsername = new System.Windows.Forms.TextBox(); + this.labelPath = new System.Windows.Forms.Label(); + this.textBoxPath = new System.Windows.Forms.TextBox(); + this.labelDescription = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // buttonCancel + // + this.buttonCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonCancel.Location = new System.Drawing.Point(15, 178); + this.buttonCancel.Margin = new System.Windows.Forms.Padding(10); + this.buttonCancel.Name = "buttonCancel"; + this.buttonCancel.Size = new System.Drawing.Size(108, 23); + this.buttonCancel.TabIndex = 4; + this.buttonCancel.Text = "Cancel"; + this.buttonCancel.UseVisualStyleBackColor = true; + this.buttonCancel.Click += new System.EventHandler(this.buttonCancel_Click); + // + // buttonConnect + // + this.buttonConnect.Location = new System.Drawing.Point(259, 178); + this.buttonConnect.Margin = new System.Windows.Forms.Padding(10); + this.buttonConnect.Name = "buttonConnect"; + this.buttonConnect.Size = new System.Drawing.Size(113, 23); + this.buttonConnect.TabIndex = 3; + this.buttonConnect.Text = "Connect"; + this.buttonConnect.UseVisualStyleBackColor = true; + this.buttonConnect.Click += new System.EventHandler(this.buttonOk_Click); + // + // labelPassword + // + this.labelPassword.AutoSize = true; + this.labelPassword.Location = new System.Drawing.Point(12, 129); + this.labelPassword.Name = "labelPassword"; + this.labelPassword.Size = new System.Drawing.Size(56, 13); + this.labelPassword.TabIndex = 18; + this.labelPassword.Text = "Password:"; + // + // textBoxPassword + // + this.textBoxPassword.Location = new System.Drawing.Point(15, 146); + this.textBoxPassword.Name = "textBoxPassword"; + this.textBoxPassword.Size = new System.Drawing.Size(357, 20); + this.textBoxPassword.TabIndex = 2; + this.textBoxPassword.UseSystemPasswordChar = true; + // + // labelUsername + // + this.labelUsername.AutoSize = true; + this.labelUsername.Location = new System.Drawing.Point(12, 86); + this.labelUsername.Name = "labelUsername"; + this.labelUsername.Size = new System.Drawing.Size(169, 13); + this.labelUsername.TabIndex = 16; + this.labelUsername.Text = "Username (DOMAIN\\User format):"; + // + // textBoxUsername + // + this.textBoxUsername.Location = new System.Drawing.Point(15, 103); + this.textBoxUsername.Name = "textBoxUsername"; + this.textBoxUsername.Size = new System.Drawing.Size(357, 20); + this.textBoxUsername.TabIndex = 1; + // + // labelPath + // + this.labelPath.AutoSize = true; + this.labelPath.Location = new System.Drawing.Point(12, 43); + this.labelPath.Name = "labelPath"; + this.labelPath.Size = new System.Drawing.Size(122, 13); + this.labelPath.TabIndex = 14; + this.labelPath.Text = "Remote Computer/Path:"; + // + // textBoxPath + // + this.textBoxPath.Location = new System.Drawing.Point(15, 60); + this.textBoxPath.Name = "textBoxPath"; + this.textBoxPath.Size = new System.Drawing.Size(357, 20); + this.textBoxPath.TabIndex = 0; + // + // labelDescription + // + this.labelDescription.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.labelDescription.Location = new System.Drawing.Point(12, 9); + this.labelDescription.Name = "labelDescription"; + this.labelDescription.Size = new System.Drawing.Size(360, 36); + this.labelDescription.TabIndex = 5; + this.labelDescription.Text = "Connect to a remote computer/path using Alternate Credentials. Alternate Credenti" + + "als can only be used for remote connections."; + // + // Form_ConnectAs + // + this.AcceptButton = this.buttonConnect; + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.AutoSize = true; + this.CancelButton = this.buttonCancel; + this.ClientSize = new System.Drawing.Size(384, 211); + this.ControlBox = false; + this.Controls.Add(this.buttonConnect); + this.Controls.Add(this.buttonCancel); + this.Controls.Add(this.textBoxPassword); + this.Controls.Add(this.labelPassword); + this.Controls.Add(this.textBoxUsername); + this.Controls.Add(this.labelUsername); + this.Controls.Add(this.textBoxPath); + this.Controls.Add(this.labelPath); + this.Controls.Add(this.labelDescription); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.MinimizeBox = false; + this.Name = "Form_ConnectAs"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "Connect As..."; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button buttonCancel; + private System.Windows.Forms.Button buttonConnect; + private System.Windows.Forms.Label labelPassword; + private System.Windows.Forms.TextBox textBoxPassword; + private System.Windows.Forms.Label labelUsername; + private System.Windows.Forms.TextBox textBoxUsername; + private System.Windows.Forms.Label labelPath; + private System.Windows.Forms.TextBox textBoxPath; + private System.Windows.Forms.Label labelDescription; + + + } +} \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_ConnectAs.cs b/WmiExplorer/Forms/Form_ConnectAs.cs new file mode 100644 index 0000000..5da2b6f --- /dev/null +++ b/WmiExplorer/Forms/Form_ConnectAs.cs @@ -0,0 +1,63 @@ +using System; +using System.Management; +using System.Windows.Forms; +using WmiExplorer.Classes; + +namespace WmiExplorer.Forms +{ + public partial class Form_ConnectAs : Form + { + public ConnectionOptions Connection; + public string Path; + public bool Cancelled; + + public Form_ConnectAs(string path = "") + { + InitializeComponent(); + + if (!String.IsNullOrEmpty(path)) + { + textBoxPath.Text = path; + textBoxPath.ReadOnly = true; + textBoxUsername.Select(); + } + + } + + private void buttonOk_Click(object sender, EventArgs e) + { + if (String.IsNullOrEmpty(textBoxPath.Text)) + { + MessageBox.Show("No path specified. Please specify a remote computer/path to connect to. ", + "Invalid Path", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + + Path = textBoxPath.Text.ToUpperInvariant(); + Connection = new ConnectionOptions + { + EnablePrivileges = true, + Impersonation = ImpersonationLevel.Impersonate, + Authentication = AuthenticationLevel.Default, + Username = textBoxUsername.Text, + SecurePassword = textBoxPassword.Text.StringToSecureString() + }; + + if (String.IsNullOrEmpty(textBoxUsername.Text)) + { + MessageBox.Show("No username specified. Logged on user's credentials will be used. ", + "Invalid Credentials", MessageBoxButtons.OK, MessageBoxIcon.Warning); + Connection.Username = null; + Connection.SecurePassword = null; + } + + Close(); + } + + private void buttonCancel_Click(object sender, EventArgs e) + { + Cancelled = true; + Close(); + } + } +} diff --git a/WmiExplorer/Forms/Form_ConnectAs.resx b/WmiExplorer/Forms/Form_ConnectAs.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/WmiExplorer/Forms/Form_ConnectAs.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_DisplayText.Designer.cs b/WmiExplorer/Forms/Form_DisplayText.Designer.cs new file mode 100644 index 0000000..da96441 --- /dev/null +++ b/WmiExplorer/Forms/Form_DisplayText.Designer.cs @@ -0,0 +1,101 @@ +namespace WmiExplorer.Forms +{ + partial class Form_DisplayText + { + /// + /// 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.buttonOk = new System.Windows.Forms.Button(); + this.richTextBox = new System.Windows.Forms.RichTextBox(); + this.labelCaption = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // buttonOk + // + this.buttonOk.Anchor = System.Windows.Forms.AnchorStyles.Bottom; + this.buttonOk.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonOk.Location = new System.Drawing.Point(194, 249); + this.buttonOk.Name = "buttonOk"; + this.buttonOk.Size = new System.Drawing.Size(100, 25); + this.buttonOk.TabIndex = 2; + this.buttonOk.Text = "OK"; + this.buttonOk.UseVisualStyleBackColor = true; + this.buttonOk.Click += new System.EventHandler(this.buttonOk_Click); + // + // richTextBox + // + this.richTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.richTextBox.BorderStyle = System.Windows.Forms.BorderStyle.None; + this.richTextBox.Location = new System.Drawing.Point(12, 49); + this.richTextBox.Name = "richTextBox"; + this.richTextBox.ReadOnly = true; + this.richTextBox.Size = new System.Drawing.Size(470, 194); + this.richTextBox.TabIndex = 3; + this.richTextBox.Text = ""; + this.richTextBox.WordWrap = false; + // + // labelCaption + // + this.labelCaption.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.labelCaption.BackColor = System.Drawing.Color.LightSteelBlue; + this.labelCaption.Location = new System.Drawing.Point(0, 0); + this.labelCaption.Name = "labelCaption"; + this.labelCaption.Padding = new System.Windows.Forms.Padding(5); + this.labelCaption.Size = new System.Drawing.Size(488, 35); + this.labelCaption.TabIndex = 5; + this.labelCaption.Text = "Title"; + this.labelCaption.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // Form_DisplayText + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.CancelButton = this.buttonOk; + this.ClientSize = new System.Drawing.Size(484, 286); + this.Controls.Add(this.labelCaption); + this.Controls.Add(this.richTextBox); + this.Controls.Add(this.buttonOk); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.SizableToolWindow; + this.Name = "Form_DisplayText"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Show; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "Form_DisplayText"; + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button buttonOk; + private System.Windows.Forms.RichTextBox richTextBox; + private System.Windows.Forms.Label labelCaption; + } +} \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_DisplayText.cs b/WmiExplorer/Forms/Form_DisplayText.cs new file mode 100644 index 0000000..4b9a4b3 --- /dev/null +++ b/WmiExplorer/Forms/Form_DisplayText.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace WmiExplorer.Forms +{ + public partial class Form_DisplayText : Form + { + public Form_DisplayText(string windowTitle, string caption, string text) + { + InitializeComponent(); + labelCaption.Font = new Font("Arial", 10, FontStyle.Bold); + Text = windowTitle; + labelCaption.Text = caption; + richTextBox.Text = text; + } + + private void buttonOk_Click(object sender, EventArgs e) + { + this.Close(); + } + } +} diff --git a/WmiExplorer/Forms/Form_DisplayText.resx b/WmiExplorer/Forms/Form_DisplayText.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/WmiExplorer/Forms/Form_DisplayText.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_ExecMethod.Designer.cs b/WmiExplorer/Forms/Form_ExecMethod.Designer.cs new file mode 100644 index 0000000..3051ea4 --- /dev/null +++ b/WmiExplorer/Forms/Form_ExecMethod.Designer.cs @@ -0,0 +1,224 @@ +namespace WmiExplorer.Forms +{ + partial class Form_ExecMethod + { + /// + /// 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.groupBoxInParams = new System.Windows.Forms.GroupBox(); + this.panelInParams = new System.Windows.Forms.Panel(); + this.labelInput = new System.Windows.Forms.Label(); + this.groupBoxOutParams = new System.Windows.Forms.GroupBox(); + this.propertyGridOutParams = new System.Windows.Forms.PropertyGrid(); + this.panelButtons = new System.Windows.Forms.Panel(); + this.buttonClose = new System.Windows.Forms.Button(); + this.buttonCopyOutput = new System.Windows.Forms.Button(); + this.buttonExecute = new System.Windows.Forms.Button(); + this.statusStrip = new System.Windows.Forms.StatusStrip(); + this.toolStripLabel = new System.Windows.Forms.ToolStripStatusLabel(); + this.labelCaption = new System.Windows.Forms.Label(); + this.groupBoxInParams.SuspendLayout(); + this.panelInParams.SuspendLayout(); + this.groupBoxOutParams.SuspendLayout(); + this.panelButtons.SuspendLayout(); + this.statusStrip.SuspendLayout(); + this.SuspendLayout(); + // + // groupBoxInParams + // + this.groupBoxInParams.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.groupBoxInParams.Controls.Add(this.panelInParams); + this.groupBoxInParams.Location = new System.Drawing.Point(12, 48); + this.groupBoxInParams.Name = "groupBoxInParams"; + this.groupBoxInParams.Size = new System.Drawing.Size(410, 54); + this.groupBoxInParams.TabIndex = 0; + this.groupBoxInParams.TabStop = false; + this.groupBoxInParams.Text = "Input Parameters"; + // + // panelInParams + // + this.panelInParams.AutoScroll = true; + this.panelInParams.Controls.Add(this.labelInput); + this.panelInParams.Dock = System.Windows.Forms.DockStyle.Fill; + this.panelInParams.Location = new System.Drawing.Point(3, 16); + this.panelInParams.Name = "panelInParams"; + this.panelInParams.Size = new System.Drawing.Size(404, 35); + this.panelInParams.TabIndex = 0; + // + // labelInput + // + this.labelInput.AutoSize = true; + this.labelInput.Location = new System.Drawing.Point(3, 5); + this.labelInput.Name = "labelInput"; + this.labelInput.Size = new System.Drawing.Size(157, 13); + this.labelInput.TabIndex = 0; + this.labelInput.Text = "Specify Input Parameter values:"; + // + // groupBoxOutParams + // + this.groupBoxOutParams.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.groupBoxOutParams.Controls.Add(this.propertyGridOutParams); + this.groupBoxOutParams.Location = new System.Drawing.Point(12, 108); + this.groupBoxOutParams.Name = "groupBoxOutParams"; + this.groupBoxOutParams.Size = new System.Drawing.Size(410, 150); + this.groupBoxOutParams.TabIndex = 1; + this.groupBoxOutParams.TabStop = false; + this.groupBoxOutParams.Text = "Output Parameters"; + // + // propertyGridOutParams + // + this.propertyGridOutParams.Dock = System.Windows.Forms.DockStyle.Fill; + this.propertyGridOutParams.HelpVisible = false; + this.propertyGridOutParams.Location = new System.Drawing.Point(3, 16); + this.propertyGridOutParams.Name = "propertyGridOutParams"; + this.propertyGridOutParams.Size = new System.Drawing.Size(404, 131); + this.propertyGridOutParams.TabIndex = 0; + this.propertyGridOutParams.TabStop = false; + this.propertyGridOutParams.ToolbarVisible = false; + // + // panelButtons + // + this.panelButtons.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.panelButtons.Controls.Add(this.buttonClose); + this.panelButtons.Controls.Add(this.buttonCopyOutput); + this.panelButtons.Controls.Add(this.buttonExecute); + this.panelButtons.Location = new System.Drawing.Point(12, 257); + this.panelButtons.Name = "panelButtons"; + this.panelButtons.Size = new System.Drawing.Size(410, 42); + this.panelButtons.TabIndex = 2; + // + // buttonClose + // + this.buttonClose.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonClose.Location = new System.Drawing.Point(329, 9); + this.buttonClose.Name = "buttonClose"; + this.buttonClose.Size = new System.Drawing.Size(75, 23); + this.buttonClose.TabIndex = 2; + this.buttonClose.Text = "Close"; + this.buttonClose.UseVisualStyleBackColor = true; + this.buttonClose.Click += new System.EventHandler(this.buttonClose_Click); + // + // buttonCopyOutput + // + this.buttonCopyOutput.Location = new System.Drawing.Point(166, 9); + this.buttonCopyOutput.Name = "buttonCopyOutput"; + this.buttonCopyOutput.Size = new System.Drawing.Size(75, 23); + this.buttonCopyOutput.TabIndex = 1; + this.buttonCopyOutput.Text = "Copy Output"; + this.buttonCopyOutput.UseVisualStyleBackColor = true; + this.buttonCopyOutput.Click += new System.EventHandler(this.buttonCopyOutput_Click); + // + // buttonExecute + // + this.buttonExecute.Location = new System.Drawing.Point(248, 9); + this.buttonExecute.Name = "buttonExecute"; + this.buttonExecute.Size = new System.Drawing.Size(75, 23); + this.buttonExecute.TabIndex = 0; + this.buttonExecute.Text = "Execute"; + this.buttonExecute.UseVisualStyleBackColor = true; + this.buttonExecute.Click += new System.EventHandler(this.buttonExecute_Click); + // + // statusStrip + // + this.statusStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStripLabel}); + this.statusStrip.Location = new System.Drawing.Point(0, 300); + this.statusStrip.Name = "statusStrip"; + this.statusStrip.Size = new System.Drawing.Size(434, 22); + this.statusStrip.SizingGrip = false; + this.statusStrip.TabIndex = 3; + this.statusStrip.Text = "statusStrip1"; + // + // toolStripLabel + // + this.toolStripLabel.Name = "toolStripLabel"; + this.toolStripLabel.Size = new System.Drawing.Size(112, 17); + this.toolStripLabel.Text = "toolStripStatusLabel"; + // + // labelCaption + // + this.labelCaption.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.labelCaption.BackColor = System.Drawing.Color.LightSteelBlue; + this.labelCaption.Location = new System.Drawing.Point(0, -1); + this.labelCaption.Name = "labelCaption"; + this.labelCaption.Padding = new System.Windows.Forms.Padding(5); + this.labelCaption.Size = new System.Drawing.Size(434, 46); + this.labelCaption.TabIndex = 4; + this.labelCaption.Text = "Title"; + this.labelCaption.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // Form_ExecMethod + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.AutoSize = true; + this.CancelButton = this.buttonClose; + this.ClientSize = new System.Drawing.Size(434, 322); + this.Controls.Add(this.labelCaption); + this.Controls.Add(this.statusStrip); + this.Controls.Add(this.panelButtons); + this.Controls.Add(this.groupBoxOutParams); + this.Controls.Add(this.groupBoxInParams); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "Form_ExecMethod"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "Execute Method "; + this.groupBoxInParams.ResumeLayout(false); + this.panelInParams.ResumeLayout(false); + this.panelInParams.PerformLayout(); + this.groupBoxOutParams.ResumeLayout(false); + this.panelButtons.ResumeLayout(false); + this.statusStrip.ResumeLayout(false); + this.statusStrip.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.GroupBox groupBoxInParams; + private System.Windows.Forms.Panel panelInParams; + private System.Windows.Forms.Label labelInput; + private System.Windows.Forms.GroupBox groupBoxOutParams; + private System.Windows.Forms.PropertyGrid propertyGridOutParams; + private System.Windows.Forms.Panel panelButtons; + private System.Windows.Forms.Button buttonClose; + private System.Windows.Forms.Button buttonCopyOutput; + private System.Windows.Forms.Button buttonExecute; + private System.Windows.Forms.StatusStrip statusStrip; + private System.Windows.Forms.ToolStripStatusLabel toolStripLabel; + private System.Windows.Forms.Label labelCaption; + } +} \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_ExecMethod.cs b/WmiExplorer/Forms/Form_ExecMethod.cs new file mode 100644 index 0000000..c3d73ab --- /dev/null +++ b/WmiExplorer/Forms/Form_ExecMethod.cs @@ -0,0 +1,324 @@ +using System; +using System.Drawing; +using System.Management; +using System.Text.RegularExpressions; +using System.Windows.Forms; +using WmiExplorer.Classes; + +namespace WmiExplorer.Forms +{ + public partial class Form_ExecMethod : Form + { + private ManagementObject _mObject; + private MethodData _method; + private string _clipboardText = String.Empty; + + public Form_ExecMethod(ManagementObject mObject, MethodData method) + { + _mObject = mObject; + _method = method; + InitializeComponent(); + //InitializeUi(); + InitializeForm(); + + } + + private void InitializeForm() + { + // Update Form Title + labelCaption.Text = _method.Name + " Method for \n" + _mObject.ClassPath.Path; + toolStripLabel.Text = String.Empty; + + // Populate Input Parameters + if (_method.InParameters == null ||_method.InParameters.Properties.Count == 0) + { + labelInput.Text = "This method doesn't have any Input Parameters."; + } + else + { + Label[] label = new Label[_method.InParameters.Properties.Count]; + TextBox[] textBox = new TextBox[_method.InParameters.Properties.Count]; + Control[] paramControls = new Control[_method.InParameters.Properties.Count]; + + var i = 0; + var maxLabelWidth = 0; + foreach (PropertyData inParam in _method.InParameters.Properties) + { + // Create a label + label[i] = new Label + { + AutoSize = true, + TextAlign = ContentAlignment.MiddleLeft, + Text = inParam.Name + " (" + inParam.Type + ") :" + }; + + // Set location appropriately for the first property + if (i == 0) + { + label[i].Location = new Point(6, labelInput.Bottom + 10); + } + else + { + label[i].Location = new Point(6, label[i-1].Bottom + 15); + } + + // Set Max Label width + if (label[i].PreferredWidth > maxLabelWidth) + maxLabelWidth = label[i].PreferredWidth; + + // Create a new textbox or checkbox depending on type + + if (inParam.Type == CimType.Boolean) + { + paramControls[i] = new CheckBox + { + Text = String.Empty, + Tag = inParam.Name, + Checked = false + }; + } + else + { + if (inParam.Type == CimType.Object || inParam.Type == CimType.Reference) + { + paramControls[i] = new TextBox + { + Text = "Object parameter not supported", + ReadOnly = true, + Tag = inParam.Name + }; + } + else + { + paramControls[i] = new TextBox + { + Text = String.Empty, + Tag = inParam.Name + }; + } + } + + + // Add controls to Panel + panelInParams.Controls.Add(label[i]); + panelInParams.Controls.Add(paramControls[i]); + + // Resize groupbox to adjust for the new property. Stop resizing after 5 properties. + if (i < 5) + groupBoxInParams.Height += (label[i].Height * 2); + + i++; + } + + // Set textbox location now that we have the max Label width + for (i = 0; i < _method.InParameters.Properties.Count; i++) + { + if (paramControls[i] is TextBox) + { + paramControls[i].Location = new Point(maxLabelWidth + 15, label[i].Top - 3); + paramControls[i].Width = panelInParams.Width - (maxLabelWidth + 40); + } + + if (paramControls[i] is CheckBox) + { + paramControls[i].Location = new Point(maxLabelWidth + 15, label[i].Top - 3); + } + } + + } + + // Reposition controls + groupBoxOutParams.Location = new Point(groupBoxInParams.Left, groupBoxInParams.Bottom + 3); + panelButtons.Location = new Point(groupBoxOutParams.Left, groupBoxOutParams.Bottom + 3); + + // Resize form + this.Size = new Size(this.Width, labelCaption.Height + groupBoxInParams.Height + groupBoxOutParams.Height + panelButtons.Height + statusStrip.Height + 50); + + } + + private void InitializeUi() + { + Label[] label = new Label[10]; + TextBox[] textBox = new TextBox[10]; + + // Add Input Parameters + for (var i = 1; i <= 7; i++) + { + if (i == 1) + { + label[i] = new Label + { + Location = new Point(6, labelInput.Bottom + 10), + AutoSize = true, + TextAlign = ContentAlignment.MiddleLeft, + Text = "Property Name: " + }; + } + else + { + label[i] = new Label + { + Location = new Point(6, label[i-1].Bottom + 15), + AutoSize = true, + TextAlign = ContentAlignment.MiddleLeft, + Text = "Property Name: " + }; + } + + + textBox[i] = new TextBox + { + Location = new Point(label[i].Width + 30, label[i].Top - 3), + Width = 200, + Text = String.Empty + }; + + panelInParams.Controls.Add(label[i]); + panelInParams.Controls.Add(textBox[i]); + + groupBoxInParams.Height += (label[i].Height * 2); + + } + + // Add Output Parameters + + GroupBox groupBoxOutParamsTest = new GroupBox(); + groupBoxOutParamsTest.Location = new Point(groupBoxInParams.Left, groupBoxInParams.Bottom + 10); + groupBoxOutParamsTest.Size = new Size(groupBoxInParams.Width, 150); + groupBoxOutParamsTest.Text = "Output Parameters"; + + PropertyGrid outParamsPropertyGrid = new PropertyGrid(); + outParamsPropertyGrid.Dock = DockStyle.Fill; + outParamsPropertyGrid.HelpVisible = false; + outParamsPropertyGrid.ToolbarVisible = false; + + groupBoxOutParamsTest.Controls.Add(outParamsPropertyGrid); + this.Controls.Add(groupBoxOutParamsTest); + + // Resize form + this.Size = new Size(this.Width, groupBoxInParams.Height + groupBoxOutParamsTest.Height + 25); + + } + + private void buttonClose_Click(object sender, EventArgs e) + { + this.Close(); + } + + private void buttonExecute_Click(object sender, EventArgs e) + { + ExecuteMethod(); + } + + private void ExecuteMethod() + { + string returnString = String.Empty; + try + { + this.Cursor = Cursors.WaitCursor; + SetStatusBar("Executing method...", MessageCategory.Action); + + ManagementBaseObject inParams = _mObject.GetMethodParameters(_method.Name); + + foreach (Control control in panelInParams.Controls) + { + if (control is TextBox) + { + inParams[control.Tag.ToString()] = control.Text; + } + + if (control is CheckBox) + { + inParams[control.Tag.ToString()] = ((CheckBox) control).Checked.ToString(); + } + + } + + ManagementBaseObject outParams = _mObject.InvokeMethod(_method.Name, inParams, null); + + if (outParams != null && outParams.Properties.Count > 0) + { + ManagementBaseObjectW outParamsW = new ManagementBaseObjectW(outParams); + propertyGridOutParams.SelectedObject = outParamsW; + _clipboardText = outParams.GetText(TextFormat.Mof).Replace("\n", "\r\n"); + SetStatusBar("Successfully executed method.", MessageCategory.Info); + } + else + { + SetStatusBar("Successfully executed method. No output parameters.", MessageCategory.Info); + } + + returnString = "Successfully executed method " + _method.Name + " of object " + _mObject.Path.RelativePath; + + } + catch (Exception ex) + { + SetStatusBar("Method Execution Failed. Error: " + ex.Message, MessageCategory.Error); + returnString = "Failed to execute method " + _method.Name + " of object " + _mObject.Path.RelativePath + ". Error: " + ex.Message; + } + finally + { + WmiExplorer parentForm = (WmiExplorer) this.Owner; + parentForm.Log(returnString); + this.Cursor = Cursors.Default; + } + } + + private void buttonCopyOutput_Click(object sender, EventArgs e) + { + if (!String.IsNullOrEmpty(_clipboardText)) + Clipboard.SetText(_clipboardText); + } + + private void SetStatusBar(string text, MessageCategory messagecategory) + { + if (text != String.Empty) + { + toolStripLabel.BorderSides = ToolStripStatusLabelBorderSides.All; + toolStripLabel.BorderStyle = Border3DStyle.SunkenInner; + } + else + { + toolStripLabel.BorderSides = ToolStripStatusLabelBorderSides.None; + toolStripLabel.BorderStyle = Border3DStyle.Flat; + } + + toolStripLabel.Text = text; + + switch (messagecategory) + { + case MessageCategory.Info: + toolStripLabel.BackColor = Color.LightSteelBlue; + break; + + case MessageCategory.Action: + toolStripLabel.BackColor = ColorCategory.Action; + break; + + case MessageCategory.Warn: + toolStripLabel.BackColor = ColorCategory.Warn; + break; + + case MessageCategory.Cache: + toolStripLabel.BackColor = ColorCategory.Cache; + break; + + case MessageCategory.Error: + toolStripLabel.BackColor = ColorCategory.Error; + break; + + case MessageCategory.Sms: + toolStripLabel.BackColor = ColorCategory.Sms; + break; + + case MessageCategory.None: + toolStripLabel.BackColor = ColorCategory.None; + break; + + default: + toolStripLabel.BackColor = ColorCategory.Unknown; + break; + } + } + } +} diff --git a/WmiExplorer/Forms/Form_ExecMethod.resx b/WmiExplorer/Forms/Form_ExecMethod.resx new file mode 100644 index 0000000..422cca5 --- /dev/null +++ b/WmiExplorer/Forms/Form_ExecMethod.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_Settings.Designer.cs b/WmiExplorer/Forms/Form_Settings.Designer.cs new file mode 100644 index 0000000..22cd039 --- /dev/null +++ b/WmiExplorer/Forms/Form_Settings.Designer.cs @@ -0,0 +1,254 @@ +namespace WmiExplorer.Forms +{ + partial class Form_Settings + { + /// + /// 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.groupBoxSettings_General = new System.Windows.Forms.GroupBox(); + this.checkBoxSettings_RememberEnumOptions = new System.Windows.Forms.CheckBox(); + this.checkBoxSettings_RememberRecentPaths = new System.Windows.Forms.CheckBox(); + this.checkBoxSettings_PreserveLayout = new System.Windows.Forms.CheckBox(); + this.groupBoxSettings_Update = new System.Windows.Forms.GroupBox(); + this.labelUpdate_LastUpdateCheck = new System.Windows.Forms.Label(); + this.textBoxSettings_UpdateCheckInterval = new System.Windows.Forms.TextBox(); + this.labelUpdate_CheckInterval = new System.Windows.Forms.Label(); + this.checkBoxSettings_CheckForUpdates = new System.Windows.Forms.CheckBox(); + this.groupBoxSettings_Caching = new System.Windows.Forms.GroupBox(); + this.textBoxSettings_CacheAge = new System.Windows.Forms.TextBox(); + this.labelCaching_CacheAge = new System.Windows.Forms.Label(); + this.buttonSettings_Save = new System.Windows.Forms.Button(); + this.buttonSettings_Cancel = new System.Windows.Forms.Button(); + this.groupBoxSettings_General.SuspendLayout(); + this.groupBoxSettings_Update.SuspendLayout(); + this.groupBoxSettings_Caching.SuspendLayout(); + this.SuspendLayout(); + // + // groupBoxSettings_General + // + this.groupBoxSettings_General.Controls.Add(this.checkBoxSettings_RememberEnumOptions); + this.groupBoxSettings_General.Controls.Add(this.checkBoxSettings_RememberRecentPaths); + this.groupBoxSettings_General.Controls.Add(this.checkBoxSettings_PreserveLayout); + this.groupBoxSettings_General.Location = new System.Drawing.Point(12, 12); + this.groupBoxSettings_General.Name = "groupBoxSettings_General"; + this.groupBoxSettings_General.Size = new System.Drawing.Size(460, 86); + this.groupBoxSettings_General.TabIndex = 0; + this.groupBoxSettings_General.TabStop = false; + this.groupBoxSettings_General.Text = "General"; + // + // checkBoxSettings_RememberEnumOptions + // + this.checkBoxSettings_RememberEnumOptions.AutoSize = true; + this.checkBoxSettings_RememberEnumOptions.Checked = global::WmiExplorer.Properties.Settings.Default.bRememberEnumOptions; + this.checkBoxSettings_RememberEnumOptions.CheckState = System.Windows.Forms.CheckState.Checked; + this.checkBoxSettings_RememberEnumOptions.DataBindings.Add(new System.Windows.Forms.Binding("Checked", global::WmiExplorer.Properties.Settings.Default, "bRememberEnumOptions", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.checkBoxSettings_RememberEnumOptions.Location = new System.Drawing.Point(6, 65); + this.checkBoxSettings_RememberEnumOptions.Name = "checkBoxSettings_RememberEnumOptions"; + this.checkBoxSettings_RememberEnumOptions.Size = new System.Drawing.Size(271, 17); + this.checkBoxSettings_RememberEnumOptions.TabIndex = 2; + this.checkBoxSettings_RememberEnumOptions.Text = "Remember Class and Instance Enumeration Options"; + this.checkBoxSettings_RememberEnumOptions.UseVisualStyleBackColor = true; + // + // checkBoxSettings_RememberRecentPaths + // + this.checkBoxSettings_RememberRecentPaths.AutoSize = true; + this.checkBoxSettings_RememberRecentPaths.Checked = global::WmiExplorer.Properties.Settings.Default.bRememberRecentPaths; + this.checkBoxSettings_RememberRecentPaths.CheckState = System.Windows.Forms.CheckState.Checked; + this.checkBoxSettings_RememberRecentPaths.DataBindings.Add(new System.Windows.Forms.Binding("Checked", global::WmiExplorer.Properties.Settings.Default, "bRememberRecentPaths", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.checkBoxSettings_RememberRecentPaths.Location = new System.Drawing.Point(6, 42); + this.checkBoxSettings_RememberRecentPaths.Name = "checkBoxSettings_RememberRecentPaths"; + this.checkBoxSettings_RememberRecentPaths.Size = new System.Drawing.Size(313, 17); + this.checkBoxSettings_RememberRecentPaths.TabIndex = 1; + this.checkBoxSettings_RememberRecentPaths.Text = "Remember previously connected Computer names and paths"; + this.checkBoxSettings_RememberRecentPaths.UseVisualStyleBackColor = true; + // + // checkBoxSettings_PreserveLayout + // + this.checkBoxSettings_PreserveLayout.AutoSize = true; + this.checkBoxSettings_PreserveLayout.Checked = global::WmiExplorer.Properties.Settings.Default.bPreserveLayout; + this.checkBoxSettings_PreserveLayout.CheckState = System.Windows.Forms.CheckState.Checked; + this.checkBoxSettings_PreserveLayout.DataBindings.Add(new System.Windows.Forms.Binding("Checked", global::WmiExplorer.Properties.Settings.Default, "bPreserveLayout", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.checkBoxSettings_PreserveLayout.Location = new System.Drawing.Point(6, 19); + this.checkBoxSettings_PreserveLayout.Name = "checkBoxSettings_PreserveLayout"; + this.checkBoxSettings_PreserveLayout.Size = new System.Drawing.Size(447, 17); + this.checkBoxSettings_PreserveLayout.TabIndex = 0; + this.checkBoxSettings_PreserveLayout.Text = "Remember UI Layout when application closes (Window Size, Location and Splitter Wi" + + "dth)"; + this.checkBoxSettings_PreserveLayout.UseVisualStyleBackColor = true; + // + // groupBoxSettings_Update + // + this.groupBoxSettings_Update.Controls.Add(this.labelUpdate_LastUpdateCheck); + this.groupBoxSettings_Update.Controls.Add(this.textBoxSettings_UpdateCheckInterval); + this.groupBoxSettings_Update.Controls.Add(this.labelUpdate_CheckInterval); + this.groupBoxSettings_Update.Controls.Add(this.checkBoxSettings_CheckForUpdates); + this.groupBoxSettings_Update.Location = new System.Drawing.Point(12, 156); + this.groupBoxSettings_Update.Name = "groupBoxSettings_Update"; + this.groupBoxSettings_Update.Size = new System.Drawing.Size(460, 71); + this.groupBoxSettings_Update.TabIndex = 1; + this.groupBoxSettings_Update.TabStop = false; + this.groupBoxSettings_Update.Text = "Application Updates"; + // + // labelUpdate_LastUpdateCheck + // + this.labelUpdate_LastUpdateCheck.AutoSize = true; + this.labelUpdate_LastUpdateCheck.Location = new System.Drawing.Point(240, 41); + this.labelUpdate_LastUpdateCheck.Name = "labelUpdate_LastUpdateCheck"; + this.labelUpdate_LastUpdateCheck.Size = new System.Drawing.Size(105, 13); + this.labelUpdate_LastUpdateCheck.TabIndex = 3; + this.labelUpdate_LastUpdateCheck.Text = "Last Update Check: "; + // + // textBoxSettings_UpdateCheckInterval + // + this.textBoxSettings_UpdateCheckInterval.DataBindings.Add(new System.Windows.Forms.Binding("Text", global::WmiExplorer.Properties.Settings.Default, "UpdateCheckIntervalInDays", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.textBoxSettings_UpdateCheckInterval.Location = new System.Drawing.Point(174, 38); + this.textBoxSettings_UpdateCheckInterval.Name = "textBoxSettings_UpdateCheckInterval"; + this.textBoxSettings_UpdateCheckInterval.Size = new System.Drawing.Size(60, 20); + this.textBoxSettings_UpdateCheckInterval.TabIndex = 2; + this.textBoxSettings_UpdateCheckInterval.Text = global::WmiExplorer.Properties.Settings.Default.UpdateCheckIntervalInDays; + // + // labelUpdate_CheckInterval + // + this.labelUpdate_CheckInterval.AutoSize = true; + this.labelUpdate_CheckInterval.Location = new System.Drawing.Point(6, 41); + this.labelUpdate_CheckInterval.Name = "labelUpdate_CheckInterval"; + this.labelUpdate_CheckInterval.Size = new System.Drawing.Size(162, 13); + this.labelUpdate_CheckInterval.TabIndex = 1; + this.labelUpdate_CheckInterval.Text = "Update Check Interval (In Days):"; + // + // checkBoxSettings_CheckForUpdates + // + this.checkBoxSettings_CheckForUpdates.AutoSize = true; + this.checkBoxSettings_CheckForUpdates.Checked = global::WmiExplorer.Properties.Settings.Default.bCheckForUpdates; + this.checkBoxSettings_CheckForUpdates.DataBindings.Add(new System.Windows.Forms.Binding("Checked", global::WmiExplorer.Properties.Settings.Default, "bCheckForUpdates", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.checkBoxSettings_CheckForUpdates.Location = new System.Drawing.Point(9, 19); + this.checkBoxSettings_CheckForUpdates.Name = "checkBoxSettings_CheckForUpdates"; + this.checkBoxSettings_CheckForUpdates.Size = new System.Drawing.Size(227, 17); + this.checkBoxSettings_CheckForUpdates.TabIndex = 0; + this.checkBoxSettings_CheckForUpdates.Text = "Automatically check for updates on launch"; + this.checkBoxSettings_CheckForUpdates.UseVisualStyleBackColor = true; + // + // groupBoxSettings_Caching + // + this.groupBoxSettings_Caching.Controls.Add(this.textBoxSettings_CacheAge); + this.groupBoxSettings_Caching.Controls.Add(this.labelCaching_CacheAge); + this.groupBoxSettings_Caching.Location = new System.Drawing.Point(12, 104); + this.groupBoxSettings_Caching.Name = "groupBoxSettings_Caching"; + this.groupBoxSettings_Caching.Size = new System.Drawing.Size(460, 46); + this.groupBoxSettings_Caching.TabIndex = 2; + this.groupBoxSettings_Caching.TabStop = false; + this.groupBoxSettings_Caching.Text = "Caching"; + // + // textBoxSettings_CacheAge + // + this.textBoxSettings_CacheAge.DataBindings.Add(new System.Windows.Forms.Binding("Text", global::WmiExplorer.Properties.Settings.Default, "CacheAgeInMinutes", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.textBoxSettings_CacheAge.Location = new System.Drawing.Point(133, 16); + this.textBoxSettings_CacheAge.Name = "textBoxSettings_CacheAge"; + this.textBoxSettings_CacheAge.Size = new System.Drawing.Size(60, 20); + this.textBoxSettings_CacheAge.TabIndex = 1; + this.textBoxSettings_CacheAge.Text = global::WmiExplorer.Properties.Settings.Default.CacheAgeInMinutes; + // + // labelCaching_CacheAge + // + this.labelCaching_CacheAge.AutoSize = true; + this.labelCaching_CacheAge.Location = new System.Drawing.Point(6, 19); + this.labelCaching_CacheAge.Name = "labelCaching_CacheAge"; + this.labelCaching_CacheAge.Size = new System.Drawing.Size(121, 13); + this.labelCaching_CacheAge.TabIndex = 0; + this.labelCaching_CacheAge.Text = "Cache Age (In Minutes):"; + // + // buttonSettings_Save + // + this.buttonSettings_Save.Location = new System.Drawing.Point(295, 241); + this.buttonSettings_Save.Margin = new System.Windows.Forms.Padding(10); + this.buttonSettings_Save.Name = "buttonSettings_Save"; + this.buttonSettings_Save.Size = new System.Drawing.Size(75, 23); + this.buttonSettings_Save.TabIndex = 3; + this.buttonSettings_Save.Text = "Ok"; + this.buttonSettings_Save.UseVisualStyleBackColor = true; + this.buttonSettings_Save.Click += new System.EventHandler(this.buttonSettings_Save_Click); + // + // buttonSettings_Cancel + // + this.buttonSettings_Cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonSettings_Cancel.Location = new System.Drawing.Point(390, 241); + this.buttonSettings_Cancel.Margin = new System.Windows.Forms.Padding(10); + this.buttonSettings_Cancel.Name = "buttonSettings_Cancel"; + this.buttonSettings_Cancel.Size = new System.Drawing.Size(75, 23); + this.buttonSettings_Cancel.TabIndex = 4; + this.buttonSettings_Cancel.Text = "Cancel"; + this.buttonSettings_Cancel.UseVisualStyleBackColor = true; + this.buttonSettings_Cancel.Click += new System.EventHandler(this.buttonSettings_Cancel_Click); + // + // Form_Settings + // + this.AcceptButton = this.buttonSettings_Save; + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.AutoSize = true; + this.CancelButton = this.buttonSettings_Cancel; + this.ClientSize = new System.Drawing.Size(484, 276); + this.ControlBox = false; + this.Controls.Add(this.buttonSettings_Cancel); + this.Controls.Add(this.buttonSettings_Save); + this.Controls.Add(this.groupBoxSettings_Caching); + this.Controls.Add(this.groupBoxSettings_Update); + this.Controls.Add(this.groupBoxSettings_General); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.Name = "Form_Settings"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "Preferences"; + this.Load += new System.EventHandler(this.Form_Settings_Load); + this.groupBoxSettings_General.ResumeLayout(false); + this.groupBoxSettings_General.PerformLayout(); + this.groupBoxSettings_Update.ResumeLayout(false); + this.groupBoxSettings_Update.PerformLayout(); + this.groupBoxSettings_Caching.ResumeLayout(false); + this.groupBoxSettings_Caching.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.GroupBox groupBoxSettings_General; + private System.Windows.Forms.GroupBox groupBoxSettings_Update; + private System.Windows.Forms.CheckBox checkBoxSettings_PreserveLayout; + private System.Windows.Forms.CheckBox checkBoxSettings_RememberRecentPaths; + private System.Windows.Forms.TextBox textBoxSettings_UpdateCheckInterval; + private System.Windows.Forms.Label labelUpdate_CheckInterval; + private System.Windows.Forms.CheckBox checkBoxSettings_CheckForUpdates; + private System.Windows.Forms.GroupBox groupBoxSettings_Caching; + private System.Windows.Forms.TextBox textBoxSettings_CacheAge; + private System.Windows.Forms.Label labelCaching_CacheAge; + private System.Windows.Forms.Button buttonSettings_Save; + private System.Windows.Forms.Button buttonSettings_Cancel; + private System.Windows.Forms.Label labelUpdate_LastUpdateCheck; + private System.Windows.Forms.CheckBox checkBoxSettings_RememberEnumOptions; + } +} \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_Settings.cs b/WmiExplorer/Forms/Form_Settings.cs new file mode 100644 index 0000000..98e605d --- /dev/null +++ b/WmiExplorer/Forms/Form_Settings.cs @@ -0,0 +1,58 @@ +using System; +using System.Diagnostics; +using System.Globalization; +using System.Windows.Forms; +using WmiExplorer.Properties; + +namespace WmiExplorer.Forms +{ + public partial class Form_Settings : Form + { + private readonly string _currentCacheAge; + + public Form_Settings() + { + InitializeComponent(); + _currentCacheAge = textBoxSettings_CacheAge.Text; + } + + private void buttonSettings_Save_Click(object sender, EventArgs e) + { + bool restartRequired = false; + + if (Settings.Default.CacheAgeInMinutes != _currentCacheAge) + { + if (MessageBox.Show( + "New Cache Age will take effect after restarting WMI Explorer.\n\n" + + "Would you like to restart WMI Explorer now ?", + "WMI Explorer - Restart Required", + MessageBoxButtons.YesNo, + MessageBoxIcon.Question + ) == DialogResult.Yes) + { + restartRequired = true; + } + } + + Settings.Default.Save(); + + if (restartRequired) + { + Process.Start(Application.ExecutablePath); + Application.Exit(); + } + + Close(); + } + + private void buttonSettings_Cancel_Click(object sender, EventArgs e) + { + Close(); + } + + private void Form_Settings_Load(object sender, EventArgs e) + { + labelUpdate_LastUpdateCheck.Text += Settings.Default.LastUpdateCheck.ToString(CultureInfo.InvariantCulture); + } + } +} diff --git a/WmiExplorer/Forms/Form_Settings.resx b/WmiExplorer/Forms/Form_Settings.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/WmiExplorer/Forms/Form_Settings.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_ShowMof.Designer.cs b/WmiExplorer/Forms/Form_ShowMof.Designer.cs new file mode 100644 index 0000000..f342a1f --- /dev/null +++ b/WmiExplorer/Forms/Form_ShowMof.Designer.cs @@ -0,0 +1,89 @@ +namespace WmiExplorer +{ + sealed partial class Form_ShowMof + { + /// + /// 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.textBoxShowMOF = new System.Windows.Forms.TextBox(); + this.buttonCloseMof = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // textBoxShowMOF + // + this.textBoxShowMOF.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.textBoxShowMOF.BackColor = System.Drawing.SystemColors.Control; + this.textBoxShowMOF.ImeMode = System.Windows.Forms.ImeMode.Off; + this.textBoxShowMOF.Location = new System.Drawing.Point(12, 13); + this.textBoxShowMOF.Multiline = true; + this.textBoxShowMOF.Name = "textBoxShowMOF"; + this.textBoxShowMOF.ReadOnly = true; + this.textBoxShowMOF.ScrollBars = System.Windows.Forms.ScrollBars.Both; + this.textBoxShowMOF.Size = new System.Drawing.Size(510, 253); + this.textBoxShowMOF.TabIndex = 0; + this.textBoxShowMOF.TabStop = false; + this.textBoxShowMOF.WordWrap = false; + // + // buttonCloseMof + // + this.buttonCloseMof.Anchor = System.Windows.Forms.AnchorStyles.Bottom; + this.buttonCloseMof.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonCloseMof.Location = new System.Drawing.Point(227, 274); + this.buttonCloseMof.Name = "buttonCloseMof"; + this.buttonCloseMof.Size = new System.Drawing.Size(75, 25); + this.buttonCloseMof.TabIndex = 1; + this.buttonCloseMof.Text = "Close"; + this.buttonCloseMof.UseVisualStyleBackColor = true; + this.buttonCloseMof.Click += new System.EventHandler(this.buttonCloseMOF_Click); + // + // Form_ShowMof + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.BackColor = System.Drawing.SystemColors.Control; + this.CancelButton = this.buttonCloseMof; + this.ClientSize = new System.Drawing.Size(534, 311); + this.Controls.Add(this.buttonCloseMof); + this.Controls.Add(this.textBoxShowMOF); + this.Name = "Form_ShowMof"; + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Show; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "MOF"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.TextBox textBoxShowMOF; + private System.Windows.Forms.Button buttonCloseMof; + } +} \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_ShowMof.cs b/WmiExplorer/Forms/Form_ShowMof.cs new file mode 100644 index 0000000..56aec4f --- /dev/null +++ b/WmiExplorer/Forms/Form_ShowMof.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace WmiExplorer +{ + + public sealed partial class Form_ShowMof : Form + { + public Form_ShowMof(string mofText) + { + InitializeComponent(); + textBoxShowMOF.Text = "\r\n" + mofText; + } + + private void buttonCloseMOF_Click(object sender, EventArgs e) + { + this.Close(); + } + } +} diff --git a/WmiExplorer/Forms/Form_ShowMof.resx b/WmiExplorer/Forms/Form_ShowMof.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/WmiExplorer/Forms/Form_ShowMof.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_Update.Designer.cs b/WmiExplorer/Forms/Form_Update.Designer.cs new file mode 100644 index 0000000..11e4f4f --- /dev/null +++ b/WmiExplorer/Forms/Form_Update.Designer.cs @@ -0,0 +1,87 @@ +namespace WmiExplorer.Forms +{ + partial class Form_Update + { + /// + /// 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.richTextBoxUpdate = new System.Windows.Forms.RichTextBox(); + this.buttonCancelHidden = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // richTextBoxUpdate + // + this.richTextBoxUpdate.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.richTextBoxUpdate.BorderStyle = System.Windows.Forms.BorderStyle.None; + this.richTextBoxUpdate.Cursor = System.Windows.Forms.Cursors.IBeam; + this.richTextBoxUpdate.Location = new System.Drawing.Point(12, 12); + this.richTextBoxUpdate.Name = "richTextBoxUpdate"; + this.richTextBoxUpdate.ReadOnly = true; + this.richTextBoxUpdate.Size = new System.Drawing.Size(471, 156); + this.richTextBoxUpdate.TabIndex = 0; + this.richTextBoxUpdate.Text = ""; + this.richTextBoxUpdate.LinkClicked += new System.Windows.Forms.LinkClickedEventHandler(this.richTextBoxUpdate_LinkClicked); + // + // buttonCancelHidden + // + this.buttonCancelHidden.Anchor = System.Windows.Forms.AnchorStyles.Bottom; + this.buttonCancelHidden.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonCancelHidden.Location = new System.Drawing.Point(193, 174); + this.buttonCancelHidden.Name = "buttonCancelHidden"; + this.buttonCancelHidden.Size = new System.Drawing.Size(100, 25); + this.buttonCancelHidden.TabIndex = 1; + this.buttonCancelHidden.Text = "OK"; + this.buttonCancelHidden.UseVisualStyleBackColor = true; + this.buttonCancelHidden.Click += new System.EventHandler(this.button1_Click); + // + // Form_Update + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.AutoSize = true; + this.CancelButton = this.buttonCancelHidden; + this.ClientSize = new System.Drawing.Size(484, 211); + this.Controls.Add(this.richTextBoxUpdate); + this.Controls.Add(this.buttonCancelHidden); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "Form_Update"; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; + this.Text = "WMI Explorer Update"; + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.RichTextBox richTextBoxUpdate; + private System.Windows.Forms.Button buttonCancelHidden; + } +} \ No newline at end of file diff --git a/WmiExplorer/Forms/Form_Update.cs b/WmiExplorer/Forms/Form_Update.cs new file mode 100644 index 0000000..84731a9 --- /dev/null +++ b/WmiExplorer/Forms/Form_Update.cs @@ -0,0 +1,43 @@ +using System; +using System.Diagnostics; +using System.Drawing; +using System.Windows.Forms; +using WmiExplorer.Properties; + +namespace WmiExplorer.Forms +{ + public partial class Form_Update : Form + { + public Form_Update(bool bUpdateAvailable, string changelog) + { + InitializeComponent(); + + if (bUpdateAvailable) + { + Font font = new Font("Arial", 10, FontStyle.Bold); + richTextBoxUpdate.SelectionFont = font; + richTextBoxUpdate.AppendText("A new version of WMI Explorer is available!\n"); + richTextBoxUpdate.AppendText(Settings.Default.UpdateUrl + "\n\n"); + richTextBoxUpdate.AppendText(changelog); + richTextBoxUpdate.SelectionStart = 0; + richTextBoxUpdate.ScrollToCaret(); + } + else + { + Width = 400; + Height = 200; + richTextBoxUpdate.AppendText("You are running the latest version!"); + } + } + + private void button1_Click(object sender, EventArgs e) + { + Close(); + } + + private void richTextBoxUpdate_LinkClicked(object sender, LinkClickedEventArgs e) + { + Process.Start(e.LinkText); + } + } +} diff --git a/WmiExplorer/Forms/Form_Update.resx b/WmiExplorer/Forms/Form_Update.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/WmiExplorer/Forms/Form_Update.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/WmiExplorer/Icons/Database CMYK .ico b/WmiExplorer/Icons/Database CMYK .ico new file mode 100644 index 0000000000000000000000000000000000000000..64869531e991a221a01d581fc6d4723ea775ec67 GIT binary patch literal 353118 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≠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 z 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 + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + if (Environment.OSVersion.Version.Major >= 6) SetProcessDPIAware(); + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new WmiExplorer()); + } + + [System.Runtime.InteropServices.DllImport("user32.dll")] + private static extern bool SetProcessDPIAware(); + + } +} diff --git a/WmiExplorer/Properties/AssemblyInfo.cs b/WmiExplorer/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..ff588cb --- /dev/null +++ b/WmiExplorer/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("WMI Explorer")] +[assembly: AssemblyDescription("WMI Explorer is a utility intended to provide the ability to browse and view WMI objects in a single pane of view.")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("WMI Explorer")] +[assembly: AssemblyCopyright("Copyright © 2014 by Vinay Pamnani")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("0186a05f-638a-4422-9992-412b499e60e4")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("2.0.0.2")] +[assembly: AssemblyFileVersion("2.0.0.2")] diff --git a/WmiExplorer/Properties/Resources.Designer.cs b/WmiExplorer/Properties/Resources.Designer.cs new file mode 100644 index 0000000..59fa228 --- /dev/null +++ b/WmiExplorer/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.34014 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace WmiExplorer.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", "4.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("WmiExplorer.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; + } + } + } +} diff --git a/WmiExplorer/Properties/Resources.resx b/WmiExplorer/Properties/Resources.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/WmiExplorer/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/WmiExplorer/Properties/Settings.Designer.cs b/WmiExplorer/Properties/Settings.Designer.cs new file mode 100644 index 0000000..4346655 --- /dev/null +++ b/WmiExplorer/Properties/Settings.Designer.cs @@ -0,0 +1,260 @@ +//------------------------------------------------------------------------------ +// +// 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 WmiExplorer.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "14.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("False")] + public bool bCheckForUpdates { + get { + return ((bool)(this["bCheckForUpdates"])); + } + set { + this["bCheckForUpdates"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool bPreserveLayout { + get { + return ((bool)(this["bPreserveLayout"])); + } + set { + this["bPreserveLayout"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool bRememberEnumOptions { + get { + return ((bool)(this["bRememberEnumOptions"])); + } + set { + this["bRememberEnumOptions"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool bRememberRecentPaths { + get { + return ((bool)(this["bRememberRecentPaths"])); + } + set { + this["bRememberRecentPaths"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("False")] + public bool bUpdateAvailable { + get { + return ((bool)(this["bUpdateAvailable"])); + } + set { + this["bUpdateAvailable"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool bUpgradeSettings { + get { + return ((bool)(this["bUpgradeSettings"])); + } + set { + this["bUpgradeSettings"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("60")] + public string CacheAgeInMinutes { + get { + return ((string)(this["CacheAgeInMinutes"])); + } + set { + this["CacheAgeInMinutes"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("None")] + public global::WmiExplorer.Classes.EnumOptions EnumOptionsFlags { + get { + return ((global::WmiExplorer.Classes.EnumOptions)(this["EnumOptionsFlags"])); + } + set { + this["EnumOptionsFlags"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("1970-01-01")] + public global::System.DateTime LastUpdateCheck { + get { + return ((global::System.DateTime)(this["LastUpdateCheck"])); + } + set { + this["LastUpdateCheck"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public global::System.Collections.Specialized.StringCollection RecentPaths { + get { + return ((global::System.Collections.Specialized.StringCollection)(this["RecentPaths"])); + } + set { + this["RecentPaths"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("220")] + public int SplitterDistanceNamespaces { + get { + return ((int)(this["SplitterDistanceNamespaces"])); + } + set { + this["SplitterDistanceNamespaces"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("200")] + public int SplitterDistanceClasses { + get { + return ((int)(this["SplitterDistanceClasses"])); + } + set { + this["SplitterDistanceClasses"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("180")] + public int SplitterDistanceInstances { + get { + return ((int)(this["SplitterDistanceInstances"])); + } + set { + this["SplitterDistanceInstances"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("7")] + public string UpdateCheckIntervalInDays { + get { + return ((string)(this["UpdateCheckIntervalInDays"])); + } + set { + this["UpdateCheckIntervalInDays"] = value; + } + } + + [global::System.Configuration.ApplicationScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("https://raw.githubusercontent.com/vinaypamnani/wmie2/master/WmiExplorer/releases." + + "xml")] + public string UpdateCheckUrl { + get { + return ((string)(this["UpdateCheckUrl"])); + } + } + + [global::System.Configuration.ApplicationScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("http://wmie.azurewebsites.net/releases.xml")] + public string UpdateCheckUrlBackup { + get { + return ((string)(this["UpdateCheckUrlBackup"])); + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("https://github.com/vinaypamnani/wmie2/releases")] + public string UpdateUrl { + get { + return ((string)(this["UpdateUrl"])); + } + set { + this["UpdateUrl"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("")] + public string WindowPlacement { + get { + return ((string)(this["WindowPlacement"])); + } + set { + this["WindowPlacement"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool bEnumModeAsync { + get { + return ((bool)(this["bEnumModeAsync"])); + } + set { + this["bEnumModeAsync"] = value; + } + } + + [global::System.Configuration.UserScopedSettingAttribute()] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Configuration.DefaultSettingValueAttribute("True")] + public bool bSmsMode { + get { + return ((bool)(this["bSmsMode"])); + } + set { + this["bSmsMode"] = value; + } + } + } +} diff --git a/WmiExplorer/Properties/Settings.settings b/WmiExplorer/Properties/Settings.settings new file mode 100644 index 0000000..d79410e --- /dev/null +++ b/WmiExplorer/Properties/Settings.settings @@ -0,0 +1,66 @@ + + + + + + False + + + True + + + True + + + True + + + False + + + True + + + 60 + + + None + + + 1970-01-01 + + + + + + 220 + + + 200 + + + 180 + + + 7 + + + https://raw.githubusercontent.com/vinaypamnani/wmie2/master/WmiExplorer/releases.xml + + + http://wmie.azurewebsites.net/releases.xml + + + https://github.com/vinaypamnani/wmie2/releases + + + + + + True + + + True + + + \ No newline at end of file diff --git a/WmiExplorer/Sms/SmsClient.cs b/WmiExplorer/Sms/SmsClient.cs new file mode 100644 index 0000000..f64cc0c --- /dev/null +++ b/WmiExplorer/Sms/SmsClient.cs @@ -0,0 +1,69 @@ +using System.Linq; +using System.Management; + +namespace WmiExplorer.Sms +{ + public class SmsClient + { + public SmsClient(string clientNamespacePath, ConnectionOptions connection) + { + ClientNamespacePath = clientNamespacePath; + SmsClientClassPath = clientNamespacePath + ":SMS_Client"; + Connection = connection; + IsClientInstalled = IsInstalled(); + } + + public string ClientNamespacePath { get; set; } + + public ConnectionOptions Connection { get; set; } + + public bool IsClientInstalled { get; set; } + + public bool IsConnected { get; set; } + + public ManagementClass SmsClientClass { get; set; } + + public string SmsClientClassPath { get; set; } + + public bool IsInstalled() + { + const string queryString = "SELECT * FROM meta_class WHERE __Class = 'SMS_Client'"; + + ManagementScope scope = new ManagementScope(ClientNamespacePath, Connection); + ObjectQuery query = new ObjectQuery(queryString); + EnumerationOptions eOption = new EnumerationOptions(); + ManagementObjectSearcher queryClientSearcher = new ManagementObjectSearcher(scope, query, eOption); + + ManagementObject ccmClient = (from ManagementClass mClass in queryClientSearcher.Get() + orderby mClass.Path.ClassName + select mClass).FirstOrDefault(); + + return ccmClient != null; + } + + //public void InitiateClientAction(SmsClientAction smsClientAction) + //{ + // try + // { + // ManagementBaseObject inParams = SmsClientClass.GetMethodParameters("TriggerSchedule"); + // inParams["sScheduleId"] = smsClientAction.Id; + // ManagementBaseObject outParams = SmsClientClass.InvokeMethod("TriggerSchedule", inParams, null); + + // if (outParams != null) + // { + // MessageBox.Show("Successfully triggered " + smsClientAction.DisplayName + ".", + // "Initiate Client Action", + // MessageBoxButtons.OK, + // MessageBoxIcon.Information); + // } + // } + // catch (Exception ex) + // { + // MessageBox.Show("Failed to trigger " + smsClientAction.DisplayName + ". Error: " + ex.Message, + // "Initiate Client Action", + // MessageBoxButtons.OK, + // MessageBoxIcon.Error); + // } + //} + } +} \ No newline at end of file diff --git a/WmiExplorer/Sms/SmsClientAction.cs b/WmiExplorer/Sms/SmsClientAction.cs new file mode 100644 index 0000000..ee92d25 --- /dev/null +++ b/WmiExplorer/Sms/SmsClientAction.cs @@ -0,0 +1,31 @@ +namespace WmiExplorer.Sms +{ + public static class ActionGroup + { + public static string ApplicationEvaluation = "Application Evaluation"; + public static string Default = "Default"; + public static string Endpoint = "Endpoint Protection"; + public static string Inventory = "Inventory"; + public static string LocationServices = "Location Services"; + public static string Other = "Other"; + public static string Policy = "Policy"; + public static string SoftwareUpdates = "Software Updates"; + public static string StateMessage = "State Messages"; + } + + public class SmsClientAction + { + public SmsClientAction(string id, string displayName, string group = "Default") + { + Id = id; + DisplayName = displayName; + Group = group; + } + + public string DisplayName { get; set; } + + public string Group { get; set; } + + public string Id { get; set; } + } +} \ No newline at end of file diff --git a/WmiExplorer/Sms/SmsClientActions.cs b/WmiExplorer/Sms/SmsClientActions.cs new file mode 100644 index 0000000..dc5bfe0 --- /dev/null +++ b/WmiExplorer/Sms/SmsClientActions.cs @@ -0,0 +1,213 @@ +namespace WmiExplorer.Sms +{ + internal class SmsClientActions + { + public SmsClientActions() + { + } + + public static SmsClientAction HardwareInventory + { + // {00000000-0000-0000-0000-000000000101} is the same + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000001}", "Hardware Inventory Cycle", ActionGroup.Inventory); } + } + + public static SmsClientAction SoftwareInventory + { + // {00000000-0000-0000-0000-000000000102} is the same + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000002}", "Software Inventory Cycle", ActionGroup.Inventory); } + } + + public static SmsClientAction HeartbeatDiscovery + { + // {00000000-0000-0000-0000-000000000103} is the same + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000003}", "Discovery Data Collection Cycle", ActionGroup.Inventory); } + } + + public static SmsClientAction FileCollection + { + // {00000000-0000-0000-0000-000000000104} is the same + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000010}", "File Collection Cycle", ActionGroup.Inventory); } + } + + public static SmsClientAction IdmifCollection + { + // {00000000-0000-0000-0000-000000000105} is the same + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000011}", "IDMIF Collection Cycle", ActionGroup.Inventory); } + } + + public static SmsClientAction ClientMachineAuthentication + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000012}", "Client Machine Authentication", ActionGroup.Other); } + } + + public static SmsClientAction MachineAssignmentsRequest + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000021}", "Request Machine Assignments", ActionGroup.Policy); } + } + + public static SmsClientAction MachineAssignmentsEvaluate + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000022}", "Evaluate Machine Assignments", ActionGroup.Policy); } + } + + public static SmsClientAction LocationRefreshDefaultMp + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000023}", "Refresh Default MP", ActionGroup.LocationServices); } + } + + public static SmsClientAction LocationRefreshLocations + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000024}", "Refresh Locations", ActionGroup.LocationServices); } + } + + public static SmsClientAction LocationTimeoutRefresh + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000025}", "Timeout Refresh", ActionGroup.LocationServices); } + } + + public static SmsClientAction UserAssignmentsRequest + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000026}", "Request User Assignments", ActionGroup.Policy); } + } + + public static SmsClientAction UserAssignmentsEvaluate + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000027}", "Evaluate User Assignments", ActionGroup.Policy); } + } + + public static SmsClientAction SoftwareMeterUsageReport + { + // {00000000-0000-0000-0000-000000000106} + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000031}", "Software Metering Usage Report Cycle", ActionGroup.Inventory); } + } + + public static SmsClientAction SourceUpdateCycle + { + // {00000000-0000-0000-0000-000000000107} + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000032}", "Windows Installer Source List Update Cycle", ActionGroup.Other); } + } + + public static SmsClientAction ProxySettingsCacheClear + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000037}", "Clear Proxy Settings Cache", ActionGroup.Other); } + } + + public static SmsClientAction PolicyAgentCleanupMachine + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000040}", "Policy Agent Cleanup Cycle (Machine)", ActionGroup.Policy); } + } + + public static SmsClientAction PolicyAgentCleanupUser + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000041}", "Policy Agent Cleanup Cycle (User)", ActionGroup.Policy); } + } + + public static SmsClientAction PolicyAgentValidateMachine + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000042}", "Validate Machine Policy/Assignment", ActionGroup.Policy); } + } + + public static SmsClientAction PolicyAgentValidateUser + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000043}", "Validate User Policy/Assignment", ActionGroup.Policy); } + } + + public static SmsClientAction RetryRefreshCertificate + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000051}", "Retry/Refresh Certificates in AD on MP", ActionGroup.Other); } + } + + public static SmsClientAction SoftwareUpdateInstallSchedule + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000063}", "Software Updates Install Schedule", ActionGroup.SoftwareUpdates); } + } + + public static SmsClientAction Nap + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000071}", "Network Access Protection Schedule", ActionGroup.Other); } + } + + public static SmsClientAction SoftwareUpdateAssignmentEvaluation + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000108}", "Software Updates Assignment Evaluation Cycle", ActionGroup.SoftwareUpdates); } + } + + public static SmsClientAction DcmPolicy + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000110}", "DCM Policy", ActionGroup.Other); } + } + + public static SmsClientAction StateMessageSendUnsent + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000111}", "Send Unsent State Messages", ActionGroup.StateMessage); } + } + + public static SmsClientAction StateMessagePolicyCacheClean + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000112}", "State System Policy Cache Clean", ActionGroup.StateMessage); } + } + + public static SmsClientAction SoftwareUpdateScan + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000113}", "Software Update Scan Cycle", ActionGroup.SoftwareUpdates); } + } + + public static SmsClientAction SoftwareUpdateStore + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000114}", "Software Update Store Refresh", ActionGroup.SoftwareUpdates); } + } + + public static SmsClientAction StateMessageSendHigh + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000115}", "Bulk Send High Priority", ActionGroup.StateMessage); } + } + + public static SmsClientAction StateMessageSendLow + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000116}", "Bulk Send Low Priority", ActionGroup.StateMessage); } + } + + public static SmsClientAction AmtStatusCheck + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000120}", "AMT Status Check Policy", ActionGroup.Other); } + } + + public static SmsClientAction ApplicationPolicy + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000121}", "Application Manager Machine Policy", ActionGroup.ApplicationEvaluation); } + } + + public static SmsClientAction ApplicationPolicyUser + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000122}", "Application Manager User Policy", ActionGroup.ApplicationEvaluation); } + } + + public static SmsClientAction ApplicationPolicyGlobal + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000123}", "Application Manager Global Evaluation Policy", ActionGroup.ApplicationEvaluation); } + } + + public static SmsClientAction PowerMgmtSummarize + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000131}", "Power Management Summarizer", ActionGroup.Other); } + } + + public static SmsClientAction EpDeploymentReevaluate + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000221}", "Endpoint Protection Deployment Re-Evaluate", ActionGroup.Endpoint); } + } + + public static SmsClientAction EpAmPolicyReevaluate + { + get { return new SmsClientAction("{00000000-0000-0000-0000-000000000222}", "Endpoint Protection AM Policy Re-Evaluate", ActionGroup.Endpoint); } + } + + // Excluded Actions: + // {00000000-0000-0000-0000-000000000061} + // {00000000-0000-0000-0000-000000000062} + // {00000000-0000-0000-0000-000000000101} + // {00000000-0000-0000-0000-000000000109} + // {00000000-0000-0000-0000-000000000223} + } +} \ No newline at end of file diff --git a/WmiExplorer/Updater/Update.cs b/WmiExplorer/Updater/Update.cs new file mode 100644 index 0000000..bb1a227 --- /dev/null +++ b/WmiExplorer/Updater/Update.cs @@ -0,0 +1,17 @@ +using System; + +namespace WmiExplorer.Updater +{ + internal class Update + { + public Uri ChangeLogUrl { get; set; } + + public DateTimeOffset LastUpdatedTime { get; set; } + + public ReleaseStatus ReleaseStatus { get; set; } + + public Uri Url { get; set; } + + public Version Version { get; set; } + } +} \ No newline at end of file diff --git a/WmiExplorer/Updater/UpdateEnums.cs b/WmiExplorer/Updater/UpdateEnums.cs new file mode 100644 index 0000000..9753f48 --- /dev/null +++ b/WmiExplorer/Updater/UpdateEnums.cs @@ -0,0 +1,21 @@ +using System; + +namespace WmiExplorer.Updater +{ + [Flags] + public enum ReleaseStatus + { + None = 0, + Stable = 1, + Beta = 2, + Alpha = 4 + } + + public enum UpdateFilter + { + None = 0, + Stable = ReleaseStatus.Stable, + Beta = Stable | ReleaseStatus.Beta, + Alpha = Beta | ReleaseStatus.Alpha + } +} \ No newline at end of file diff --git a/WmiExplorer/Updater/UpdaterService.cs b/WmiExplorer/Updater/UpdaterService.cs new file mode 100644 index 0000000..d5a52ec --- /dev/null +++ b/WmiExplorer/Updater/UpdaterService.cs @@ -0,0 +1,93 @@ +using System; +using System.Diagnostics; +using System.Linq; +using System.Net; +using System.Reflection; +using System.ServiceModel.Syndication; +using System.Xml; + +namespace WmiExplorer.Updater +{ + internal class UpdaterService + { + public static Update GetUpdateFromSyndicationItem(SyndicationItem item) + { + Debug.Assert(item != null); + + var update = new Update(); + + // Update Version + Version version; + if (Version.TryParse(item.Title.Text, out version)) + { + update.Version = version; + } + + // Last Updated Time + update.LastUpdatedTime = item.LastUpdatedTime; + + // Update Url + var updateLink = item.Links.FirstOrDefault( + l => String.IsNullOrWhiteSpace(l.RelationshipType) + || l.RelationshipType.Equals("alternate", StringComparison.OrdinalIgnoreCase)); + + if (updateLink != null) + { + update.Url = updateLink.GetAbsoluteUri(); + } + + // Change Log Url + var changeLogLink = item.Links.FirstOrDefault( + l => String.IsNullOrWhiteSpace(l.RelationshipType) + || l.RelationshipType.Equals("related", StringComparison.OrdinalIgnoreCase)); + + if (changeLogLink != null) + { + update.ChangeLogUrl = changeLogLink.GetAbsoluteUri(); + } + + // Update Release Status + update.ReleaseStatus + = item.Categories.Aggregate( + ReleaseStatus.None, + (rs, c) => + { + ReleaseStatus releaseStatus; + + if (Enum.TryParse(c.Name, true, out releaseStatus)) + { + rs |= releaseStatus; + } + + return rs; + }); + + return update; + } + + public Update CheckForUpdatesAsync(string updateUrl, UpdateFilter updateFilter) + { + Debug.Assert(!String.IsNullOrWhiteSpace(updateUrl)); + + Update latestUpdate = null; + + var formatter = new Atom10FeedFormatter(); + var reader = XmlReader.Create(updateUrl); + formatter.ReadFrom(reader); + + latestUpdate = (from i in formatter.Feed.Items + let u = GetUpdateFromSyndicationItem(i) + where u.Version > Assembly.GetExecutingAssembly().GetName().Version + && ((int)updateFilter & (int)u.ReleaseStatus) != 0 + orderby u.LastUpdatedTime descending + select u).FirstOrDefault(); + + return latestUpdate; + } + + public string GetChangeLog(Uri changeLogUrl) + { + return new WebClient().DownloadString(changeLogUrl); + } + } +} \ No newline at end of file diff --git a/WmiExplorer/WmiExplorer.Designer.cs b/WmiExplorer/WmiExplorer.Designer.cs new file mode 100644 index 0000000..c1e30cd --- /dev/null +++ b/WmiExplorer/WmiExplorer.Designer.cs @@ -0,0 +1,2072 @@ +using System.Windows.Forms; + +namespace WmiExplorer +{ + partial class WmiExplorer + { + /// + /// 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(WmiExplorer)); + this.menuStrip = new System.Windows.Forms.MenuStrip(); + this.menuItemFile = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemFile_ConnectAs = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemFile_Preferences = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemFile_SmsMode = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemFile_Exit = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemLaunch = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemLaunch_DcomCnfg = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemLaunch_WmiMgmt = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemLaunch_WbemTest = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemHelp = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemHelp_Documentation = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemHelp_CheckUpdate = new System.Windows.Forms.ToolStripMenuItem(); + this.menuItemHelp_About = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripLabelUpdateNotification = new System.Windows.Forms.ToolStripStatusLabel(); + this.statusStrip = new System.Windows.Forms.StatusStrip(); + this.toolStripLabel1 = new System.Windows.Forms.ToolStripStatusLabel(); + this.toolStripLabel2 = new System.Windows.Forms.ToolStripStatusLabel(); + this.toolStripLabel3 = new System.Windows.Forms.ToolStripStatusLabel(); + this.tableLayoutPanelMain = new System.Windows.Forms.TableLayoutPanel(); + this.groupBoxComputer = new System.Windows.Forms.GroupBox(); + this.buttonComputerConnect = new System.Windows.Forms.Button(); + this.textBoxComputerName = new System.Windows.Forms.TextBox(); + this.groupBoxClassOptions = new System.Windows.Forms.GroupBox(); + this.buttonClassesRefresh = new System.Windows.Forms.Button(); + this.checkBoxMSFT = new System.Windows.Forms.CheckBox(); + this.checkBoxPerf = new System.Windows.Forms.CheckBox(); + this.checkBoxCIM = new System.Windows.Forms.CheckBox(); + this.checkBoxSystem = new System.Windows.Forms.CheckBox(); + this.textBoxClassFilter = new System.Windows.Forms.TextBox(); + this.labelClassFilter = new System.Windows.Forms.Label(); + this.groupBoxQuery1 = new System.Windows.Forms.GroupBox(); + this.buttonQueryExecute1 = new System.Windows.Forms.Button(); + this.labelQuery = new System.Windows.Forms.Label(); + this.textBoxQuery1 = new System.Windows.Forms.TextBox(); + this.splitContainerNamespaceClasses = new System.Windows.Forms.SplitContainer(); + this.groupBoxNamespaces = new System.Windows.Forms.GroupBox(); + this.buttonHideNamespaces = new System.Windows.Forms.Button(); + this.treeNamespaces = new System.Windows.Forms.TreeView(); + this.tabControlClasses = new System.Windows.Forms.TabControl(); + this.tabClasses = new System.Windows.Forms.TabPage(); + this.splitContainerClassesInstances = new System.Windows.Forms.SplitContainer(); + this.tableLayoutClasses = new System.Windows.Forms.TableLayoutPanel(); + this.textBoxClassQuickFilter = new System.Windows.Forms.TextBox(); + this.groupBoxClasses = new System.Windows.Forms.GroupBox(); + this.listClasses = new System.Windows.Forms.ListView(); + this.labelClassQuickFilter = new System.Windows.Forms.Label(); + this.tabControlInstances = new System.Windows.Forms.TabControl(); + this.tabInstances = new System.Windows.Forms.TabPage(); + this.groupBoxInstanceOptions = new System.Windows.Forms.GroupBox(); + this.buttonRefreshObject = new System.Windows.Forms.Button(); + this.buttonInstancesRefresh = new System.Windows.Forms.Button(); + this.checkNullProps = new System.Windows.Forms.CheckBox(); + this.checkSystemProps = new System.Windows.Forms.CheckBox(); + this.textBoxInstanceFilterQuick = new System.Windows.Forms.TextBox(); + this.labelInstanceFilter = new System.Windows.Forms.Label(); + this.splitContainerInstancesProperties = new System.Windows.Forms.SplitContainer(); + this.groupBoxInstances = new System.Windows.Forms.GroupBox(); + this.listInstances = new System.Windows.Forms.ListView(); + this.propertyGridInstance = new System.Windows.Forms.PropertyGrid(); + this.contextMenu = new System.Windows.Forms.ContextMenuStrip(this.components); + this.tabProperties = new System.Windows.Forms.TabPage(); + this.splitContainerClassProperties = new System.Windows.Forms.SplitContainer(); + this.groupBoxClassProperties = new System.Windows.Forms.GroupBox(); + this.listClassProperties = new System.Windows.Forms.ListView(); + this.richTextBoxClassDetails = new System.Windows.Forms.RichTextBox(); + this.tabMethods = new System.Windows.Forms.TabPage(); + this.splitContainerMethodsTab = new System.Windows.Forms.SplitContainer(); + this.splitContainerMethodsParams = new System.Windows.Forms.SplitContainer(); + this.groupBoxClassMethods = new System.Windows.Forms.GroupBox(); + this.listMethods = new System.Windows.Forms.ListView(); + this.tableLayoutMethods = new System.Windows.Forms.TableLayoutPanel(); + this.groupBoxMethodsParamsIn = new System.Windows.Forms.GroupBox(); + this.listMethodParamsIn = new System.Windows.Forms.ListView(); + this.groupBoxMethodsParamsOut = new System.Windows.Forms.GroupBox(); + this.listMethodParamsOut = new System.Windows.Forms.ListView(); + this.richTextBoxMethodDetails = new System.Windows.Forms.RichTextBox(); + this.tabQueryResults = new System.Windows.Forms.TabPage(); + this.splitContainerQuery = new System.Windows.Forms.SplitContainer(); + this.tableLayoutQuery = new System.Windows.Forms.TableLayoutPanel(); + this.groupBoxQueryOutput = new System.Windows.Forms.GroupBox(); + this.radioQueryOutDataGrid = new System.Windows.Forms.RadioButton(); + this.radioQueryOutListView = new System.Windows.Forms.RadioButton(); + this.groupBoxQuery2 = new System.Windows.Forms.GroupBox(); + this.textBoxQuery2 = new System.Windows.Forms.TextBox(); + this.buttonQueryExecute2 = new System.Windows.Forms.Button(); + this.groupBoxQueryResults = new System.Windows.Forms.GroupBox(); + this.splitContainerQueryResults = new System.Windows.Forms.SplitContainer(); + this.listQueryResults = new System.Windows.Forms.ListView(); + this.propertyGridQueryResults = new System.Windows.Forms.PropertyGrid(); + this.tabScript = new System.Windows.Forms.TabPage(); + this.tableLayoutScript = new System.Windows.Forms.TableLayoutPanel(); + this.groupBoxScriptLanguage = new System.Windows.Forms.GroupBox(); + this.radioScriptPs = new System.Windows.Forms.RadioButton(); + this.radioScriptVbs = new System.Windows.Forms.RadioButton(); + this.groupBoxScriptOutput = new System.Windows.Forms.GroupBox(); + this.radioScriptOutTxt = new System.Windows.Forms.RadioButton(); + this.radioScriptOutCmd = new System.Windows.Forms.RadioButton(); + this.groupBoxScriptExecute = new System.Windows.Forms.GroupBox(); + this.buttonScriptSave = new System.Windows.Forms.Button(); + this.buttonScriptRun = new System.Windows.Forms.Button(); + this.groupBoxScript = new System.Windows.Forms.GroupBox(); + this.textBoxScript = new System.Windows.Forms.TextBox(); + this.tabLogging = new System.Windows.Forms.TabPage(); + this.textBoxLogging = new System.Windows.Forms.TextBox(); + this.tabDebug2 = new System.Windows.Forms.TabPage(); + this.tableLayoutDebug2 = new System.Windows.Forms.TableLayoutPanel(); + this.propertyGridDebugWmiInstance = new System.Windows.Forms.PropertyGrid(); + this.propertyGridDebugWmiClass = new System.Windows.Forms.PropertyGrid(); + this.tabSearch = new System.Windows.Forms.TabPage(); + this.tableLayoutSearch = new System.Windows.Forms.TableLayoutPanel(); + this.groupBoxSearch = new System.Windows.Forms.GroupBox(); + this.radioSearchProperties = new System.Windows.Forms.RadioButton(); + this.checkBoxSearchRecurse = new System.Windows.Forms.CheckBox(); + this.radioSearchMethods = new System.Windows.Forms.RadioButton(); + this.radioSearchClasses = new System.Windows.Forms.RadioButton(); + this.labelSearch2 = new System.Windows.Forms.Label(); + this.buttonSearch = new System.Windows.Forms.Button(); + this.textBoxSearchPattern = new System.Windows.Forms.TextBox(); + this.labelSearch1 = new System.Windows.Forms.Label(); + this.groupBoxSearchResults = new System.Windows.Forms.GroupBox(); + this.listSearchResults = new System.Windows.Forms.ListView(); + this.tabDebug1 = new System.Windows.Forms.TabPage(); + this.tableLayoutDebug1 = new System.Windows.Forms.TableLayoutPanel(); + this.propertyGridDebugWmiNamespace = new System.Windows.Forms.PropertyGrid(); + this.propertyGridDebugWmiNode = new System.Windows.Forms.PropertyGrid(); + this.groupBoxCallingMode = new System.Windows.Forms.GroupBox(); + this.radioModeSync = new System.Windows.Forms.RadioButton(); + this.radioModeAsync = new System.Windows.Forms.RadioButton(); + this.toolTip = new System.Windows.Forms.ToolTip(this.components); + this.saveScriptDialog = new System.Windows.Forms.SaveFileDialog(); + this.menuStrip.SuspendLayout(); + this.statusStrip.SuspendLayout(); + this.tableLayoutPanelMain.SuspendLayout(); + this.groupBoxComputer.SuspendLayout(); + this.groupBoxClassOptions.SuspendLayout(); + this.groupBoxQuery1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerNamespaceClasses)).BeginInit(); + this.splitContainerNamespaceClasses.Panel1.SuspendLayout(); + this.splitContainerNamespaceClasses.Panel2.SuspendLayout(); + this.splitContainerNamespaceClasses.SuspendLayout(); + this.groupBoxNamespaces.SuspendLayout(); + this.tabControlClasses.SuspendLayout(); + this.tabClasses.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerClassesInstances)).BeginInit(); + this.splitContainerClassesInstances.Panel1.SuspendLayout(); + this.splitContainerClassesInstances.Panel2.SuspendLayout(); + this.splitContainerClassesInstances.SuspendLayout(); + this.tableLayoutClasses.SuspendLayout(); + this.groupBoxClasses.SuspendLayout(); + this.tabControlInstances.SuspendLayout(); + this.tabInstances.SuspendLayout(); + this.groupBoxInstanceOptions.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerInstancesProperties)).BeginInit(); + this.splitContainerInstancesProperties.Panel1.SuspendLayout(); + this.splitContainerInstancesProperties.Panel2.SuspendLayout(); + this.splitContainerInstancesProperties.SuspendLayout(); + this.groupBoxInstances.SuspendLayout(); + this.tabProperties.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerClassProperties)).BeginInit(); + this.splitContainerClassProperties.Panel1.SuspendLayout(); + this.splitContainerClassProperties.Panel2.SuspendLayout(); + this.splitContainerClassProperties.SuspendLayout(); + this.groupBoxClassProperties.SuspendLayout(); + this.tabMethods.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerMethodsTab)).BeginInit(); + this.splitContainerMethodsTab.Panel1.SuspendLayout(); + this.splitContainerMethodsTab.Panel2.SuspendLayout(); + this.splitContainerMethodsTab.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerMethodsParams)).BeginInit(); + this.splitContainerMethodsParams.Panel1.SuspendLayout(); + this.splitContainerMethodsParams.Panel2.SuspendLayout(); + this.splitContainerMethodsParams.SuspendLayout(); + this.groupBoxClassMethods.SuspendLayout(); + this.tableLayoutMethods.SuspendLayout(); + this.groupBoxMethodsParamsIn.SuspendLayout(); + this.groupBoxMethodsParamsOut.SuspendLayout(); + this.tabQueryResults.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerQuery)).BeginInit(); + this.splitContainerQuery.Panel1.SuspendLayout(); + this.splitContainerQuery.Panel2.SuspendLayout(); + this.splitContainerQuery.SuspendLayout(); + this.tableLayoutQuery.SuspendLayout(); + this.groupBoxQueryOutput.SuspendLayout(); + this.groupBoxQuery2.SuspendLayout(); + this.groupBoxQueryResults.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerQueryResults)).BeginInit(); + this.splitContainerQueryResults.Panel1.SuspendLayout(); + this.splitContainerQueryResults.Panel2.SuspendLayout(); + this.splitContainerQueryResults.SuspendLayout(); + this.tabScript.SuspendLayout(); + this.tableLayoutScript.SuspendLayout(); + this.groupBoxScriptLanguage.SuspendLayout(); + this.groupBoxScriptOutput.SuspendLayout(); + this.groupBoxScriptExecute.SuspendLayout(); + this.groupBoxScript.SuspendLayout(); + this.tabLogging.SuspendLayout(); + this.tabDebug2.SuspendLayout(); + this.tableLayoutDebug2.SuspendLayout(); + this.tabSearch.SuspendLayout(); + this.tableLayoutSearch.SuspendLayout(); + this.groupBoxSearch.SuspendLayout(); + this.groupBoxSearchResults.SuspendLayout(); + this.tabDebug1.SuspendLayout(); + this.tableLayoutDebug1.SuspendLayout(); + this.groupBoxCallingMode.SuspendLayout(); + this.SuspendLayout(); + // + // menuStrip + // + this.menuStrip.BackColor = System.Drawing.SystemColors.Control; + this.menuStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.menuItemFile, + this.menuItemLaunch, + this.menuItemHelp, + this.toolStripLabelUpdateNotification}); + this.menuStrip.Location = new System.Drawing.Point(0, 0); + this.menuStrip.Name = "menuStrip"; + this.menuStrip.Size = new System.Drawing.Size(1008, 24); + this.menuStrip.TabIndex = 0; + this.menuStrip.Text = "menuStrip1"; + // + // menuItemFile + // + this.menuItemFile.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.menuItemFile_ConnectAs, + this.menuItemFile_Preferences, + this.menuItemFile_SmsMode, + this.menuItemFile_Exit}); + this.menuItemFile.Name = "menuItemFile"; + this.menuItemFile.Size = new System.Drawing.Size(37, 20); + this.menuItemFile.Text = "&File"; + // + // menuItemFile_ConnectAs + // + this.menuItemFile_ConnectAs.Name = "menuItemFile_ConnectAs"; + this.menuItemFile_ConnectAs.Size = new System.Drawing.Size(176, 22); + this.menuItemFile_ConnectAs.Text = "Connect &As..."; + this.menuItemFile_ConnectAs.ToolTipText = "Connect as alternate credentials"; + this.menuItemFile_ConnectAs.Click += new System.EventHandler(this.menuItemFile_ConnectAs_Click); + // + // menuItemFile_Preferences + // + this.menuItemFile_Preferences.Name = "menuItemFile_Preferences"; + this.menuItemFile_Preferences.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.P))); + this.menuItemFile_Preferences.Size = new System.Drawing.Size(176, 22); + this.menuItemFile_Preferences.Text = "&Preferences"; + this.menuItemFile_Preferences.Click += new System.EventHandler(this.menuItemFile_Preferences_Click); + // + // menuItemFile_SmsMode + // + this.menuItemFile_SmsMode.Checked = global::WmiExplorer.Properties.Settings.Default.bSmsMode; + this.menuItemFile_SmsMode.CheckOnClick = true; + this.menuItemFile_SmsMode.Name = "menuItemFile_SmsMode"; + this.menuItemFile_SmsMode.Size = new System.Drawing.Size(176, 22); + this.menuItemFile_SmsMode.Text = "Enable &SMS Mode"; + this.menuItemFile_SmsMode.ToolTipText = "Enables SMS (Configuration Manager) Mode"; + this.menuItemFile_SmsMode.CheckedChanged += new System.EventHandler(this.menuItemFile_SmsMode_CheckedChanged); + // + // menuItemFile_Exit + // + this.menuItemFile_Exit.Name = "menuItemFile_Exit"; + this.menuItemFile_Exit.Size = new System.Drawing.Size(176, 22); + this.menuItemFile_Exit.Text = "E&xit"; + this.menuItemFile_Exit.Click += new System.EventHandler(this.menuItemFile_Exit_Click); + // + // menuItemLaunch + // + this.menuItemLaunch.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.menuItemLaunch_DcomCnfg, + this.menuItemLaunch_WmiMgmt, + this.menuItemLaunch_WbemTest}); + this.menuItemLaunch.Name = "menuItemLaunch"; + this.menuItemLaunch.Size = new System.Drawing.Size(58, 20); + this.menuItemLaunch.Text = "&Launch"; + // + // menuItemLaunch_DcomCnfg + // + this.menuItemLaunch_DcomCnfg.Name = "menuItemLaunch_DcomCnfg"; + this.menuItemLaunch_DcomCnfg.Size = new System.Drawing.Size(211, 22); + this.menuItemLaunch_DcomCnfg.Text = "&DCOM Config"; + this.menuItemLaunch_DcomCnfg.Click += new System.EventHandler(this.menuItemLaunch_DcomCnfg_Click); + // + // menuItemLaunch_WmiMgmt + // + this.menuItemLaunch_WmiMgmt.Name = "menuItemLaunch_WmiMgmt"; + this.menuItemLaunch_WmiMgmt.Size = new System.Drawing.Size(211, 22); + this.menuItemLaunch_WmiMgmt.Text = "WMI &Control (WmiMgmt)"; + this.menuItemLaunch_WmiMgmt.Click += new System.EventHandler(this.menuItemLaunch_WmiMgmt_Click); + // + // menuItemLaunch_WbemTest + // + this.menuItemLaunch_WbemTest.Name = "menuItemLaunch_WbemTest"; + this.menuItemLaunch_WbemTest.Size = new System.Drawing.Size(211, 22); + this.menuItemLaunch_WbemTest.Text = "WMI &Tester (WbemTest)"; + this.menuItemLaunch_WbemTest.Click += new System.EventHandler(this.menuItemLaunch_WbemTest_Click); + // + // menuItemHelp + // + this.menuItemHelp.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.menuItemHelp_Documentation, + this.menuItemHelp_CheckUpdate, + this.menuItemHelp_About}); + this.menuItemHelp.Name = "menuItemHelp"; + this.menuItemHelp.Size = new System.Drawing.Size(44, 20); + this.menuItemHelp.Text = "&Help"; + // + // menuItemHelp_Documentation + // + this.menuItemHelp_Documentation.Name = "menuItemHelp_Documentation"; + this.menuItemHelp_Documentation.Size = new System.Drawing.Size(173, 22); + this.menuItemHelp_Documentation.Text = "&Documentation"; + this.menuItemHelp_Documentation.Click += new System.EventHandler(this.menuItemHelp_Documentation_Click); + // + // menuItemHelp_CheckUpdate + // + this.menuItemHelp_CheckUpdate.Name = "menuItemHelp_CheckUpdate"; + this.menuItemHelp_CheckUpdate.Size = new System.Drawing.Size(173, 22); + this.menuItemHelp_CheckUpdate.Text = "Check For &Updates"; + this.menuItemHelp_CheckUpdate.Click += new System.EventHandler(this.menuItemHelp_CheckUpdate_Click); + // + // menuItemHelp_About + // + this.menuItemHelp_About.Name = "menuItemHelp_About"; + this.menuItemHelp_About.Size = new System.Drawing.Size(173, 22); + this.menuItemHelp_About.Text = "&About"; + this.menuItemHelp_About.Click += new System.EventHandler(this.menuItemHelp_About_Click); + // + // toolStripLabelUpdateNotification + // + this.toolStripLabelUpdateNotification.IsLink = true; + this.toolStripLabelUpdateNotification.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.toolStripLabelUpdateNotification.Name = "toolStripLabelUpdateNotification"; + this.toolStripLabelUpdateNotification.Size = new System.Drawing.Size(96, 20); + this.toolStripLabelUpdateNotification.Text = "Update Available"; + this.toolStripLabelUpdateNotification.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + this.toolStripLabelUpdateNotification.Click += new System.EventHandler(this.toolStripLabelUpdateNotification_Click); + // + // statusStrip + // + this.statusStrip.BackColor = System.Drawing.SystemColors.Control; + this.statusStrip.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStripLabel1, + this.toolStripLabel2, + this.toolStripLabel3}); + this.statusStrip.Location = new System.Drawing.Point(0, 707); + this.statusStrip.Name = "statusStrip"; + this.statusStrip.Size = new System.Drawing.Size(1008, 22); + this.statusStrip.TabIndex = 3; + this.statusStrip.Text = "statusStrip1"; + // + // toolStripLabel1 + // + this.toolStripLabel1.Name = "toolStripLabel1"; + this.toolStripLabel1.Size = new System.Drawing.Size(62, 17); + this.toolStripLabel1.Text = "StatusBar1"; + // + // toolStripLabel2 + // + this.toolStripLabel2.Name = "toolStripLabel2"; + this.toolStripLabel2.Size = new System.Drawing.Size(62, 17); + this.toolStripLabel2.Text = "StatusBar2"; + // + // toolStripLabel3 + // + this.toolStripLabel3.Name = "toolStripLabel3"; + this.toolStripLabel3.Size = new System.Drawing.Size(869, 17); + this.toolStripLabel3.Spring = true; + this.toolStripLabel3.Text = "StatusBar3"; + this.toolStripLabel3.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + // + // tableLayoutPanelMain + // + this.tableLayoutPanelMain.AutoSize = true; + this.tableLayoutPanelMain.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink; + this.tableLayoutPanelMain.ColumnCount = 5; + this.tableLayoutPanelMain.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 1F)); + this.tableLayoutPanelMain.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 220F)); + this.tableLayoutPanelMain.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 120F)); + this.tableLayoutPanelMain.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutPanelMain.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 1F)); + this.tableLayoutPanelMain.Controls.Add(this.groupBoxComputer, 1, 0); + this.tableLayoutPanelMain.Controls.Add(this.groupBoxClassOptions, 3, 0); + this.tableLayoutPanelMain.Controls.Add(this.groupBoxQuery1, 1, 2); + this.tableLayoutPanelMain.Controls.Add(this.splitContainerNamespaceClasses, 1, 1); + this.tableLayoutPanelMain.Controls.Add(this.groupBoxCallingMode, 2, 0); + this.tableLayoutPanelMain.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutPanelMain.Location = new System.Drawing.Point(0, 24); + this.tableLayoutPanelMain.Name = "tableLayoutPanelMain"; + this.tableLayoutPanelMain.RowCount = 3; + this.tableLayoutPanelMain.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 60F)); + this.tableLayoutPanelMain.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutPanelMain.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 60F)); + this.tableLayoutPanelMain.Size = new System.Drawing.Size(1008, 683); + this.tableLayoutPanelMain.TabIndex = 0; + // + // groupBoxComputer + // + this.groupBoxComputer.Controls.Add(this.buttonComputerConnect); + this.groupBoxComputer.Controls.Add(this.textBoxComputerName); + this.groupBoxComputer.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxComputer.Location = new System.Drawing.Point(4, 3); + this.groupBoxComputer.Name = "groupBoxComputer"; + this.groupBoxComputer.Size = new System.Drawing.Size(214, 54); + this.groupBoxComputer.TabIndex = 0; + this.groupBoxComputer.TabStop = false; + this.groupBoxComputer.Text = "Computer"; + // + // buttonComputerConnect + // + this.buttonComputerConnect.Location = new System.Drawing.Point(130, 19); + this.buttonComputerConnect.Name = "buttonComputerConnect"; + this.buttonComputerConnect.Size = new System.Drawing.Size(75, 23); + this.buttonComputerConnect.TabIndex = 1; + this.buttonComputerConnect.Text = "Connect"; + this.buttonComputerConnect.UseVisualStyleBackColor = true; + this.buttonComputerConnect.Click += new System.EventHandler(this.buttonComputerConnect_Click); + // + // textBoxComputerName + // + this.textBoxComputerName.Location = new System.Drawing.Point(6, 21); + this.textBoxComputerName.Name = "textBoxComputerName"; + this.textBoxComputerName.Size = new System.Drawing.Size(118, 20); + this.textBoxComputerName.TabIndex = 0; + this.textBoxComputerName.Text = "."; + this.toolTip.SetToolTip(this.textBoxComputerName, "Computer Name or Path"); + this.textBoxComputerName.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBoxComputerName_KeyDown); + // + // groupBoxClassOptions + // + this.groupBoxClassOptions.Controls.Add(this.buttonClassesRefresh); + this.groupBoxClassOptions.Controls.Add(this.checkBoxMSFT); + this.groupBoxClassOptions.Controls.Add(this.checkBoxPerf); + this.groupBoxClassOptions.Controls.Add(this.checkBoxCIM); + this.groupBoxClassOptions.Controls.Add(this.checkBoxSystem); + this.groupBoxClassOptions.Controls.Add(this.textBoxClassFilter); + this.groupBoxClassOptions.Controls.Add(this.labelClassFilter); + this.groupBoxClassOptions.Location = new System.Drawing.Point(344, 3); + this.groupBoxClassOptions.Name = "groupBoxClassOptions"; + this.groupBoxClassOptions.Size = new System.Drawing.Size(571, 54); + this.groupBoxClassOptions.TabIndex = 2; + this.groupBoxClassOptions.TabStop = false; + this.groupBoxClassOptions.Text = "Class Enumeration Options"; + // + // buttonClassesRefresh + // + this.buttonClassesRefresh.Location = new System.Drawing.Point(455, 19); + this.buttonClassesRefresh.Name = "buttonClassesRefresh"; + this.buttonClassesRefresh.Size = new System.Drawing.Size(104, 23); + this.buttonClassesRefresh.TabIndex = 5; + this.buttonClassesRefresh.Text = "Refresh Classes"; + this.toolTip.SetToolTip(this.buttonClassesRefresh, "Refresh list of classes for the selected namespace"); + this.buttonClassesRefresh.UseVisualStyleBackColor = true; + this.buttonClassesRefresh.Click += new System.EventHandler(this.buttonClassesRefresh_Click); + // + // checkBoxMSFT + // + this.checkBoxMSFT.AutoSize = true; + this.checkBoxMSFT.Location = new System.Drawing.Point(310, 32); + this.checkBoxMSFT.Name = "checkBoxMSFT"; + this.checkBoxMSFT.Size = new System.Drawing.Size(132, 17); + this.checkBoxMSFT.TabIndex = 4; + this.checkBoxMSFT.Tag = ""; + this.checkBoxMSFT.Text = "Include MSFT Classes"; + this.checkBoxMSFT.UseVisualStyleBackColor = true; + this.checkBoxMSFT.CheckedChanged += new System.EventHandler(this.checkBoxEnumOptions_CheckedChanged); + // + // checkBoxPerf + // + this.checkBoxPerf.AutoSize = true; + this.checkBoxPerf.Location = new System.Drawing.Point(310, 14); + this.checkBoxPerf.Name = "checkBoxPerf"; + this.checkBoxPerf.Size = new System.Drawing.Size(122, 17); + this.checkBoxPerf.TabIndex = 3; + this.checkBoxPerf.Tag = ""; + this.checkBoxPerf.Text = "Include Perf Classes"; + this.checkBoxPerf.UseVisualStyleBackColor = true; + this.checkBoxPerf.CheckedChanged += new System.EventHandler(this.checkBoxEnumOptions_CheckedChanged); + // + // checkBoxCIM + // + this.checkBoxCIM.AutoSize = true; + this.checkBoxCIM.Location = new System.Drawing.Point(167, 32); + this.checkBoxCIM.Name = "checkBoxCIM"; + this.checkBoxCIM.Size = new System.Drawing.Size(122, 17); + this.checkBoxCIM.TabIndex = 2; + this.checkBoxCIM.Tag = ""; + this.checkBoxCIM.Text = "Include CIM Classes"; + this.checkBoxCIM.UseVisualStyleBackColor = true; + this.checkBoxCIM.CheckedChanged += new System.EventHandler(this.checkBoxEnumOptions_CheckedChanged); + // + // checkBoxSystem + // + this.checkBoxSystem.AutoSize = true; + this.checkBoxSystem.Location = new System.Drawing.Point(167, 14); + this.checkBoxSystem.Name = "checkBoxSystem"; + this.checkBoxSystem.Size = new System.Drawing.Size(137, 17); + this.checkBoxSystem.TabIndex = 1; + this.checkBoxSystem.Tag = ""; + this.checkBoxSystem.Text = "Include System Classes"; + this.checkBoxSystem.UseVisualStyleBackColor = true; + this.checkBoxSystem.CheckedChanged += new System.EventHandler(this.checkBoxEnumOptions_CheckedChanged); + // + // textBoxClassFilter + // + this.textBoxClassFilter.Location = new System.Drawing.Point(46, 22); + this.textBoxClassFilter.Name = "textBoxClassFilter"; + this.textBoxClassFilter.Size = new System.Drawing.Size(115, 20); + this.textBoxClassFilter.TabIndex = 0; + this.toolTip.SetToolTip(this.textBoxClassFilter, resources.GetString("textBoxClassFilter.ToolTip")); + this.textBoxClassFilter.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBoxClassFilter_KeyDown); + // + // labelClassFilter + // + this.labelClassFilter.AutoSize = true; + this.labelClassFilter.Location = new System.Drawing.Point(6, 25); + this.labelClassFilter.Name = "labelClassFilter"; + this.labelClassFilter.Size = new System.Drawing.Size(32, 13); + this.labelClassFilter.TabIndex = 0; + this.labelClassFilter.Text = "Filter:"; + // + // groupBoxQuery1 + // + this.groupBoxQuery1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.tableLayoutPanelMain.SetColumnSpan(this.groupBoxQuery1, 3); + this.groupBoxQuery1.Controls.Add(this.buttonQueryExecute1); + this.groupBoxQuery1.Controls.Add(this.labelQuery); + this.groupBoxQuery1.Controls.Add(this.textBoxQuery1); + this.groupBoxQuery1.Location = new System.Drawing.Point(4, 626); + this.groupBoxQuery1.Name = "groupBoxQuery1"; + this.groupBoxQuery1.Size = new System.Drawing.Size(1000, 54); + this.groupBoxQuery1.TabIndex = 6; + this.groupBoxQuery1.TabStop = false; + this.groupBoxQuery1.Text = "WQL Query (Selected Object)"; + // + // buttonQueryExecute1 + // + this.buttonQueryExecute1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonQueryExecute1.Location = new System.Drawing.Point(908, 19); + this.buttonQueryExecute1.Name = "buttonQueryExecute1"; + this.buttonQueryExecute1.Size = new System.Drawing.Size(86, 23); + this.buttonQueryExecute1.TabIndex = 0; + this.buttonQueryExecute1.Text = "Execute"; + this.buttonQueryExecute1.UseVisualStyleBackColor = true; + this.buttonQueryExecute1.Click += new System.EventHandler(this.buttonQueryExecute1_Click); + // + // labelQuery + // + this.labelQuery.AutoSize = true; + this.labelQuery.Location = new System.Drawing.Point(6, 23); + this.labelQuery.Name = "labelQuery"; + this.labelQuery.Size = new System.Drawing.Size(35, 13); + this.labelQuery.TabIndex = 1; + this.labelQuery.Text = "Query"; + // + // textBoxQuery1 + // + this.textBoxQuery1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right))); + this.textBoxQuery1.Location = new System.Drawing.Point(47, 21); + this.textBoxQuery1.Name = "textBoxQuery1"; + this.textBoxQuery1.ReadOnly = true; + this.textBoxQuery1.Size = new System.Drawing.Size(855, 20); + this.textBoxQuery1.TabIndex = 1; + // + // splitContainerNamespaceClasses + // + this.tableLayoutPanelMain.SetColumnSpan(this.splitContainerNamespaceClasses, 3); + this.splitContainerNamespaceClasses.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainerNamespaceClasses.Location = new System.Drawing.Point(4, 63); + this.splitContainerNamespaceClasses.Name = "splitContainerNamespaceClasses"; + // + // splitContainerNamespaceClasses.Panel1 + // + this.splitContainerNamespaceClasses.Panel1.Controls.Add(this.groupBoxNamespaces); + // + // splitContainerNamespaceClasses.Panel2 + // + this.splitContainerNamespaceClasses.Panel2.Controls.Add(this.tabControlClasses); + this.splitContainerNamespaceClasses.Size = new System.Drawing.Size(1000, 557); + this.splitContainerNamespaceClasses.SplitterDistance = 216; + this.splitContainerNamespaceClasses.TabIndex = 7; + this.splitContainerNamespaceClasses.TabStop = false; + this.splitContainerNamespaceClasses.SplitterMoved += new System.Windows.Forms.SplitterEventHandler(this.splitContainerNamespaceClasses_SplitterMoved); + // + // groupBoxNamespaces + // + this.groupBoxNamespaces.Controls.Add(this.buttonHideNamespaces); + this.groupBoxNamespaces.Controls.Add(this.treeNamespaces); + this.groupBoxNamespaces.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxNamespaces.Location = new System.Drawing.Point(0, 0); + this.groupBoxNamespaces.Name = "groupBoxNamespaces"; + this.groupBoxNamespaces.Size = new System.Drawing.Size(216, 557); + this.groupBoxNamespaces.TabIndex = 0; + this.groupBoxNamespaces.TabStop = false; + this.groupBoxNamespaces.Text = "Namespaces"; + // + // buttonHideNamespaces + // + this.buttonHideNamespaces.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.buttonHideNamespaces.Location = new System.Drawing.Point(191, 18); + this.buttonHideNamespaces.Name = "buttonHideNamespaces"; + this.buttonHideNamespaces.Size = new System.Drawing.Size(20, 20); + this.buttonHideNamespaces.TabIndex = 1; + this.buttonHideNamespaces.Text = "-"; + this.buttonHideNamespaces.UseVisualStyleBackColor = true; + this.buttonHideNamespaces.Click += new System.EventHandler(this.buttonHideNamespaces_Click); + this.buttonHideNamespaces.MouseHover += new System.EventHandler(this.buttonHideNamespaces_MouseHover); + // + // treeNamespaces + // + this.treeNamespaces.Dock = System.Windows.Forms.DockStyle.Fill; + this.treeNamespaces.HideSelection = false; + this.treeNamespaces.Location = new System.Drawing.Point(3, 16); + this.treeNamespaces.Name = "treeNamespaces"; + this.treeNamespaces.ShowNodeToolTips = true; + this.treeNamespaces.Size = new System.Drawing.Size(210, 538); + this.treeNamespaces.TabIndex = 0; + this.treeNamespaces.BeforeSelect += new System.Windows.Forms.TreeViewCancelEventHandler(this.treeNamespaces_BeforeSelect); + this.treeNamespaces.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.treeNamespaces_AfterSelect); + this.treeNamespaces.NodeMouseClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.treeNamespaces_NodeMouseClick); + this.treeNamespaces.NodeMouseDoubleClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.treeNamespaces_NodeMouseDoubleClick); + // + // tabControlClasses + // + this.tabControlClasses.Controls.Add(this.tabClasses); + this.tabControlClasses.Controls.Add(this.tabSearch); + this.tabControlClasses.Controls.Add(this.tabDebug1); + this.tabControlClasses.Dock = System.Windows.Forms.DockStyle.Fill; + this.tabControlClasses.Location = new System.Drawing.Point(0, 0); + this.tabControlClasses.Name = "tabControlClasses"; + this.tabControlClasses.SelectedIndex = 0; + this.tabControlClasses.Size = new System.Drawing.Size(780, 557); + this.tabControlClasses.TabIndex = 0; + // + // tabClasses + // + this.tabClasses.BackColor = System.Drawing.SystemColors.Control; + this.tabClasses.Controls.Add(this.splitContainerClassesInstances); + this.tabClasses.Location = new System.Drawing.Point(4, 22); + this.tabClasses.Name = "tabClasses"; + this.tabClasses.Padding = new System.Windows.Forms.Padding(3); + this.tabClasses.Size = new System.Drawing.Size(772, 531); + this.tabClasses.TabIndex = 0; + this.tabClasses.Text = "Classes"; + // + // splitContainerClassesInstances + // + this.splitContainerClassesInstances.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainerClassesInstances.Location = new System.Drawing.Point(3, 3); + this.splitContainerClassesInstances.Name = "splitContainerClassesInstances"; + // + // splitContainerClassesInstances.Panel1 + // + this.splitContainerClassesInstances.Panel1.Controls.Add(this.tableLayoutClasses); + // + // splitContainerClassesInstances.Panel2 + // + this.splitContainerClassesInstances.Panel2.Controls.Add(this.tabControlInstances); + this.splitContainerClassesInstances.Size = new System.Drawing.Size(766, 525); + this.splitContainerClassesInstances.SplitterDistance = 199; + this.splitContainerClassesInstances.TabIndex = 0; + this.splitContainerClassesInstances.TabStop = false; + // + // tableLayoutClasses + // + this.tableLayoutClasses.ColumnCount = 2; + this.tableLayoutClasses.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 70F)); + this.tableLayoutClasses.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutClasses.Controls.Add(this.textBoxClassQuickFilter, 1, 0); + this.tableLayoutClasses.Controls.Add(this.groupBoxClasses, 0, 1); + this.tableLayoutClasses.Controls.Add(this.labelClassQuickFilter, 0, 0); + this.tableLayoutClasses.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutClasses.Location = new System.Drawing.Point(0, 0); + this.tableLayoutClasses.Name = "tableLayoutClasses"; + this.tableLayoutClasses.RowCount = 2; + this.tableLayoutClasses.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 25F)); + this.tableLayoutClasses.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutClasses.Size = new System.Drawing.Size(199, 525); + this.tableLayoutClasses.TabIndex = 0; + // + // textBoxClassQuickFilter + // + this.textBoxClassQuickFilter.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.textBoxClassQuickFilter.Location = new System.Drawing.Point(76, 3); + this.textBoxClassQuickFilter.Margin = new System.Windows.Forms.Padding(6, 3, 6, 3); + this.textBoxClassQuickFilter.Name = "textBoxClassQuickFilter"; + this.textBoxClassQuickFilter.Size = new System.Drawing.Size(117, 20); + this.textBoxClassQuickFilter.TabIndex = 0; + this.toolTip.SetToolTip(this.textBoxClassQuickFilter, "Quick Filter for displayed classes. This filter is applied after classes are enum" + + "erated and filters the list after specifying atleast 3 characters."); + this.textBoxClassQuickFilter.TextChanged += new System.EventHandler(this.textBoxClassQuickFilter_TextChanged); + // + // groupBoxClasses + // + this.groupBoxClasses.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.tableLayoutClasses.SetColumnSpan(this.groupBoxClasses, 2); + this.groupBoxClasses.Controls.Add(this.listClasses); + this.groupBoxClasses.Location = new System.Drawing.Point(3, 28); + this.groupBoxClasses.Name = "groupBoxClasses"; + this.groupBoxClasses.Size = new System.Drawing.Size(193, 494); + this.groupBoxClasses.TabIndex = 2; + this.groupBoxClasses.TabStop = false; + this.groupBoxClasses.Text = "Classes"; + // + // listClasses + // + this.listClasses.Dock = System.Windows.Forms.DockStyle.Fill; + this.listClasses.FullRowSelect = true; + this.listClasses.HideSelection = false; + this.listClasses.Location = new System.Drawing.Point(3, 16); + this.listClasses.MultiSelect = false; + this.listClasses.Name = "listClasses"; + this.listClasses.ShowItemToolTips = true; + this.listClasses.Size = new System.Drawing.Size(187, 475); + this.listClasses.TabIndex = 0; + this.listClasses.UseCompatibleStateImageBehavior = false; + this.listClasses.View = System.Windows.Forms.View.Details; + this.listClasses.ColumnClick += new System.Windows.Forms.ColumnClickEventHandler(this.listView_ColumnClick); + this.listClasses.SelectedIndexChanged += new System.EventHandler(this.listClasses_SelectedIndexChanged); + this.listClasses.DoubleClick += new System.EventHandler(this.listClasses_DoubleClick); + this.listClasses.MouseClick += new System.Windows.Forms.MouseEventHandler(this.listClasses_MouseClick); + // + // labelClassQuickFilter + // + this.labelClassQuickFilter.AutoSize = true; + this.labelClassQuickFilter.Location = new System.Drawing.Point(3, 6); + this.labelClassQuickFilter.Margin = new System.Windows.Forms.Padding(3, 6, 3, 3); + this.labelClassQuickFilter.Name = "labelClassQuickFilter"; + this.labelClassQuickFilter.Size = new System.Drawing.Size(63, 13); + this.labelClassQuickFilter.TabIndex = 6; + this.labelClassQuickFilter.Text = "Quick Filter:"; + // + // tabControlInstances + // + this.tabControlInstances.Controls.Add(this.tabInstances); + this.tabControlInstances.Controls.Add(this.tabProperties); + this.tabControlInstances.Controls.Add(this.tabMethods); + this.tabControlInstances.Controls.Add(this.tabQueryResults); + this.tabControlInstances.Controls.Add(this.tabScript); + this.tabControlInstances.Controls.Add(this.tabLogging); + this.tabControlInstances.Controls.Add(this.tabDebug2); + this.tabControlInstances.Dock = System.Windows.Forms.DockStyle.Fill; + this.tabControlInstances.Location = new System.Drawing.Point(0, 0); + this.tabControlInstances.Name = "tabControlInstances"; + this.tabControlInstances.SelectedIndex = 0; + this.tabControlInstances.Size = new System.Drawing.Size(563, 525); + this.tabControlInstances.TabIndex = 0; + this.tabControlInstances.Selected += new System.Windows.Forms.TabControlEventHandler(this.tabControlInstances_Selected); + // + // tabInstances + // + this.tabInstances.BackColor = System.Drawing.SystemColors.Control; + this.tabInstances.Controls.Add(this.groupBoxInstanceOptions); + this.tabInstances.Controls.Add(this.splitContainerInstancesProperties); + this.tabInstances.Location = new System.Drawing.Point(4, 22); + this.tabInstances.Name = "tabInstances"; + this.tabInstances.Padding = new System.Windows.Forms.Padding(3); + this.tabInstances.Size = new System.Drawing.Size(555, 499); + this.tabInstances.TabIndex = 0; + this.tabInstances.Text = "Instances"; + // + // groupBoxInstanceOptions + // + this.groupBoxInstanceOptions.Controls.Add(this.buttonRefreshObject); + this.groupBoxInstanceOptions.Controls.Add(this.buttonInstancesRefresh); + this.groupBoxInstanceOptions.Controls.Add(this.checkNullProps); + this.groupBoxInstanceOptions.Controls.Add(this.checkSystemProps); + this.groupBoxInstanceOptions.Controls.Add(this.textBoxInstanceFilterQuick); + this.groupBoxInstanceOptions.Controls.Add(this.labelInstanceFilter); + this.groupBoxInstanceOptions.Location = new System.Drawing.Point(6, 6); + this.groupBoxInstanceOptions.Name = "groupBoxInstanceOptions"; + this.groupBoxInstanceOptions.Size = new System.Drawing.Size(544, 54); + this.groupBoxInstanceOptions.TabIndex = 0; + this.groupBoxInstanceOptions.TabStop = false; + this.groupBoxInstanceOptions.Text = "Instance Options"; + // + // buttonRefreshObject + // + this.buttonRefreshObject.Location = new System.Drawing.Point(442, 20); + this.buttonRefreshObject.Name = "buttonRefreshObject"; + this.buttonRefreshObject.Size = new System.Drawing.Size(94, 23); + this.buttonRefreshObject.TabIndex = 4; + this.buttonRefreshObject.Text = "Refresh Object"; + this.toolTip.SetToolTip(this.buttonRefreshObject, "Refresh selected instance. This is generally useful for populating values of lazy" + + " properties."); + this.buttonRefreshObject.UseVisualStyleBackColor = true; + this.buttonRefreshObject.Click += new System.EventHandler(this.buttonRefreshObject_Click); + // + // buttonInstancesRefresh + // + this.buttonInstancesRefresh.Location = new System.Drawing.Point(323, 20); + this.buttonInstancesRefresh.Name = "buttonInstancesRefresh"; + this.buttonInstancesRefresh.Size = new System.Drawing.Size(113, 23); + this.buttonInstancesRefresh.TabIndex = 3; + this.buttonInstancesRefresh.Text = "Refresh Instances"; + this.toolTip.SetToolTip(this.buttonInstancesRefresh, "Refresh list of instances for the selected class"); + this.buttonInstancesRefresh.UseVisualStyleBackColor = true; + this.buttonInstancesRefresh.Click += new System.EventHandler(this.buttonInstancesRefresh_Click); + // + // checkNullProps + // + this.checkNullProps.AutoSize = true; + this.checkNullProps.Location = new System.Drawing.Point(180, 15); + this.checkNullProps.Name = "checkNullProps"; + this.checkNullProps.Size = new System.Drawing.Size(109, 17); + this.checkNullProps.TabIndex = 1; + this.checkNullProps.Text = "Show Null Values"; + this.toolTip.SetToolTip(this.checkNullProps, "Show properties witn NULL values"); + this.checkNullProps.UseVisualStyleBackColor = true; + this.checkNullProps.CheckedChanged += new System.EventHandler(this.checkBoxEnumOptions_CheckedChanged); + // + // checkSystemProps + // + this.checkSystemProps.AutoSize = true; + this.checkSystemProps.Location = new System.Drawing.Point(180, 33); + this.checkSystemProps.Name = "checkSystemProps"; + this.checkSystemProps.Size = new System.Drawing.Size(140, 17); + this.checkSystemProps.TabIndex = 2; + this.checkSystemProps.Text = "Show System Properties"; + this.toolTip.SetToolTip(this.checkSystemProps, "Show System Properties"); + this.checkSystemProps.UseVisualStyleBackColor = true; + this.checkSystemProps.CheckedChanged += new System.EventHandler(this.checkBoxEnumOptions_CheckedChanged); + // + // textBoxInstanceFilterQuick + // + this.textBoxInstanceFilterQuick.Location = new System.Drawing.Point(75, 22); + this.textBoxInstanceFilterQuick.Name = "textBoxInstanceFilterQuick"; + this.textBoxInstanceFilterQuick.Size = new System.Drawing.Size(99, 20); + this.textBoxInstanceFilterQuick.TabIndex = 0; + this.toolTip.SetToolTip(this.textBoxInstanceFilterQuick, "Quick Filter for displayed Instances. This filter is applied after instances are " + + "enumerated and filters the list after specifying atleast 3 characters."); + this.textBoxInstanceFilterQuick.TextChanged += new System.EventHandler(this.textBoxInstanceFilterQuick_TextChanged); + // + // labelInstanceFilter + // + this.labelInstanceFilter.AutoSize = true; + this.labelInstanceFilter.Location = new System.Drawing.Point(6, 25); + this.labelInstanceFilter.Name = "labelInstanceFilter"; + this.labelInstanceFilter.Size = new System.Drawing.Size(63, 13); + this.labelInstanceFilter.TabIndex = 7; + this.labelInstanceFilter.Text = "Quick Filter:"; + // + // splitContainerInstancesProperties + // + this.splitContainerInstancesProperties.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.splitContainerInstancesProperties.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.splitContainerInstancesProperties.Location = new System.Drawing.Point(6, 67); + this.splitContainerInstancesProperties.Name = "splitContainerInstancesProperties"; + // + // splitContainerInstancesProperties.Panel1 + // + this.splitContainerInstancesProperties.Panel1.Controls.Add(this.groupBoxInstances); + this.splitContainerInstancesProperties.Panel1.Padding = new System.Windows.Forms.Padding(3); + // + // splitContainerInstancesProperties.Panel2 + // + this.splitContainerInstancesProperties.Panel2.Controls.Add(this.propertyGridInstance); + this.splitContainerInstancesProperties.Panel2.Padding = new System.Windows.Forms.Padding(3); + this.splitContainerInstancesProperties.Size = new System.Drawing.Size(546, 426); + this.splitContainerInstancesProperties.SplitterDistance = 179; + this.splitContainerInstancesProperties.TabIndex = 0; + this.splitContainerInstancesProperties.TabStop = false; + // + // groupBoxInstances + // + this.groupBoxInstances.AutoSize = true; + this.groupBoxInstances.Controls.Add(this.listInstances); + this.groupBoxInstances.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxInstances.Location = new System.Drawing.Point(3, 3); + this.groupBoxInstances.Name = "groupBoxInstances"; + this.groupBoxInstances.Size = new System.Drawing.Size(169, 416); + this.groupBoxInstances.TabIndex = 0; + this.groupBoxInstances.TabStop = false; + this.groupBoxInstances.Text = "Instances"; + // + // listInstances + // + this.listInstances.Dock = System.Windows.Forms.DockStyle.Fill; + this.listInstances.FullRowSelect = true; + this.listInstances.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.None; + this.listInstances.HideSelection = false; + this.listInstances.Location = new System.Drawing.Point(3, 16); + this.listInstances.MultiSelect = false; + this.listInstances.Name = "listInstances"; + this.listInstances.ShowItemToolTips = true; + this.listInstances.Size = new System.Drawing.Size(163, 397); + this.listInstances.TabIndex = 0; + this.listInstances.UseCompatibleStateImageBehavior = false; + this.listInstances.View = System.Windows.Forms.View.Details; + this.listInstances.SelectedIndexChanged += new System.EventHandler(this.listInstances_SelectedIndexChanged); + this.listInstances.MouseClick += new System.Windows.Forms.MouseEventHandler(this.listInstances_MouseClick); + // + // propertyGridInstance + // + this.propertyGridInstance.ContextMenuStrip = this.contextMenu; + this.propertyGridInstance.Dock = System.Windows.Forms.DockStyle.Fill; + this.propertyGridInstance.Location = new System.Drawing.Point(3, 3); + this.propertyGridInstance.Name = "propertyGridInstance"; + this.propertyGridInstance.Size = new System.Drawing.Size(353, 416); + this.propertyGridInstance.TabIndex = 0; + this.propertyGridInstance.ToolbarVisible = false; + // + // contextMenu + // + this.contextMenu.Name = "contextMenu"; + this.contextMenu.Size = new System.Drawing.Size(61, 4); + this.contextMenu.Opening += new System.ComponentModel.CancelEventHandler(this.contextMenu_Opening); + // + // tabProperties + // + this.tabProperties.BackColor = System.Drawing.SystemColors.Control; + this.tabProperties.Controls.Add(this.splitContainerClassProperties); + this.tabProperties.Location = new System.Drawing.Point(4, 22); + this.tabProperties.Name = "tabProperties"; + this.tabProperties.Padding = new System.Windows.Forms.Padding(3); + this.tabProperties.Size = new System.Drawing.Size(555, 499); + this.tabProperties.TabIndex = 4; + this.tabProperties.Text = "Properties"; + // + // splitContainerClassProperties + // + this.splitContainerClassProperties.BackColor = System.Drawing.SystemColors.Control; + this.splitContainerClassProperties.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.splitContainerClassProperties.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainerClassProperties.Location = new System.Drawing.Point(3, 3); + this.splitContainerClassProperties.Name = "splitContainerClassProperties"; + this.splitContainerClassProperties.Orientation = System.Windows.Forms.Orientation.Horizontal; + // + // splitContainerClassProperties.Panel1 + // + this.splitContainerClassProperties.Panel1.Controls.Add(this.groupBoxClassProperties); + this.splitContainerClassProperties.Panel1.Padding = new System.Windows.Forms.Padding(3); + // + // splitContainerClassProperties.Panel2 + // + this.splitContainerClassProperties.Panel2.Controls.Add(this.richTextBoxClassDetails); + this.splitContainerClassProperties.Size = new System.Drawing.Size(549, 493); + this.splitContainerClassProperties.SplitterDistance = 284; + this.splitContainerClassProperties.TabIndex = 2; + // + // groupBoxClassProperties + // + this.groupBoxClassProperties.BackColor = System.Drawing.SystemColors.Control; + this.groupBoxClassProperties.Controls.Add(this.listClassProperties); + this.groupBoxClassProperties.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxClassProperties.Location = new System.Drawing.Point(3, 3); + this.groupBoxClassProperties.Name = "groupBoxClassProperties"; + this.groupBoxClassProperties.Size = new System.Drawing.Size(539, 274); + this.groupBoxClassProperties.TabIndex = 1; + this.groupBoxClassProperties.TabStop = false; + this.groupBoxClassProperties.Text = "Class Properties"; + // + // listClassProperties + // + this.listClassProperties.Dock = System.Windows.Forms.DockStyle.Fill; + this.listClassProperties.FullRowSelect = true; + this.listClassProperties.HideSelection = false; + this.listClassProperties.Location = new System.Drawing.Point(3, 16); + this.listClassProperties.MultiSelect = false; + this.listClassProperties.Name = "listClassProperties"; + this.listClassProperties.ShowItemToolTips = true; + this.listClassProperties.Size = new System.Drawing.Size(533, 255); + this.listClassProperties.TabIndex = 0; + this.listClassProperties.UseCompatibleStateImageBehavior = false; + this.listClassProperties.View = System.Windows.Forms.View.Details; + this.listClassProperties.ColumnClick += new System.Windows.Forms.ColumnClickEventHandler(this.listView_ColumnClick); + this.listClassProperties.SelectedIndexChanged += new System.EventHandler(this.listProps_SelectedIndexChanged); + // + // richTextBoxClassDetails + // + this.richTextBoxClassDetails.BorderStyle = System.Windows.Forms.BorderStyle.None; + this.richTextBoxClassDetails.Cursor = System.Windows.Forms.Cursors.Arrow; + this.richTextBoxClassDetails.Dock = System.Windows.Forms.DockStyle.Fill; + this.richTextBoxClassDetails.Location = new System.Drawing.Point(0, 0); + this.richTextBoxClassDetails.Name = "richTextBoxClassDetails"; + this.richTextBoxClassDetails.ReadOnly = true; + this.richTextBoxClassDetails.Size = new System.Drawing.Size(545, 201); + this.richTextBoxClassDetails.TabIndex = 0; + this.richTextBoxClassDetails.Text = ""; + this.richTextBoxClassDetails.LinkClicked += new System.Windows.Forms.LinkClickedEventHandler(this.richTextBoxClassDetails_LinkClicked); + this.richTextBoxClassDetails.Click += new System.EventHandler(this.richTextBox_Click); + // + // tabMethods + // + this.tabMethods.BackColor = System.Drawing.SystemColors.Control; + this.tabMethods.Controls.Add(this.splitContainerMethodsTab); + this.tabMethods.Location = new System.Drawing.Point(4, 22); + this.tabMethods.Name = "tabMethods"; + this.tabMethods.Padding = new System.Windows.Forms.Padding(3); + this.tabMethods.Size = new System.Drawing.Size(555, 499); + this.tabMethods.TabIndex = 1; + this.tabMethods.Text = "Methods"; + // + // splitContainerMethodsTab + // + this.splitContainerMethodsTab.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.splitContainerMethodsTab.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainerMethodsTab.Location = new System.Drawing.Point(3, 3); + this.splitContainerMethodsTab.Name = "splitContainerMethodsTab"; + this.splitContainerMethodsTab.Orientation = System.Windows.Forms.Orientation.Horizontal; + // + // splitContainerMethodsTab.Panel1 + // + this.splitContainerMethodsTab.Panel1.Controls.Add(this.splitContainerMethodsParams); + // + // splitContainerMethodsTab.Panel2 + // + this.splitContainerMethodsTab.Panel2.Controls.Add(this.richTextBoxMethodDetails); + this.splitContainerMethodsTab.Size = new System.Drawing.Size(549, 493); + this.splitContainerMethodsTab.SplitterDistance = 381; + this.splitContainerMethodsTab.TabIndex = 0; + // + // splitContainerMethodsParams + // + this.splitContainerMethodsParams.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainerMethodsParams.Location = new System.Drawing.Point(0, 0); + this.splitContainerMethodsParams.Name = "splitContainerMethodsParams"; + this.splitContainerMethodsParams.Orientation = System.Windows.Forms.Orientation.Horizontal; + // + // splitContainerMethodsParams.Panel1 + // + this.splitContainerMethodsParams.Panel1.Controls.Add(this.groupBoxClassMethods); + this.splitContainerMethodsParams.Panel1.Padding = new System.Windows.Forms.Padding(3); + // + // splitContainerMethodsParams.Panel2 + // + this.splitContainerMethodsParams.Panel2.Controls.Add(this.tableLayoutMethods); + this.splitContainerMethodsParams.Size = new System.Drawing.Size(545, 377); + this.splitContainerMethodsParams.SplitterDistance = 225; + this.splitContainerMethodsParams.TabIndex = 2; + // + // groupBoxClassMethods + // + this.groupBoxClassMethods.Controls.Add(this.listMethods); + this.groupBoxClassMethods.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxClassMethods.Location = new System.Drawing.Point(3, 3); + this.groupBoxClassMethods.Name = "groupBoxClassMethods"; + this.groupBoxClassMethods.Size = new System.Drawing.Size(539, 219); + this.groupBoxClassMethods.TabIndex = 0; + this.groupBoxClassMethods.TabStop = false; + this.groupBoxClassMethods.Text = "Methods"; + // + // listMethods + // + this.listMethods.Dock = System.Windows.Forms.DockStyle.Fill; + this.listMethods.FullRowSelect = true; + this.listMethods.HideSelection = false; + this.listMethods.Location = new System.Drawing.Point(3, 16); + this.listMethods.MultiSelect = false; + this.listMethods.Name = "listMethods"; + this.listMethods.ShowItemToolTips = true; + this.listMethods.Size = new System.Drawing.Size(533, 200); + this.listMethods.TabIndex = 0; + this.listMethods.UseCompatibleStateImageBehavior = false; + this.listMethods.View = System.Windows.Forms.View.Details; + this.listMethods.SelectedIndexChanged += new System.EventHandler(this.listMethods_SelectedIndexChanged); + // + // tableLayoutMethods + // + this.tableLayoutMethods.ColumnCount = 2; + this.tableLayoutMethods.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F)); + this.tableLayoutMethods.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F)); + this.tableLayoutMethods.Controls.Add(this.groupBoxMethodsParamsIn, 0, 0); + this.tableLayoutMethods.Controls.Add(this.groupBoxMethodsParamsOut, 1, 0); + this.tableLayoutMethods.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutMethods.Location = new System.Drawing.Point(0, 0); + this.tableLayoutMethods.Name = "tableLayoutMethods"; + this.tableLayoutMethods.RowCount = 1; + this.tableLayoutMethods.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutMethods.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 148F)); + this.tableLayoutMethods.Size = new System.Drawing.Size(545, 148); + this.tableLayoutMethods.TabIndex = 1; + // + // groupBoxMethodsParamsIn + // + this.groupBoxMethodsParamsIn.Controls.Add(this.listMethodParamsIn); + this.groupBoxMethodsParamsIn.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxMethodsParamsIn.Location = new System.Drawing.Point(3, 3); + this.groupBoxMethodsParamsIn.Name = "groupBoxMethodsParamsIn"; + this.groupBoxMethodsParamsIn.Size = new System.Drawing.Size(266, 142); + this.groupBoxMethodsParamsIn.TabIndex = 2; + this.groupBoxMethodsParamsIn.TabStop = false; + this.groupBoxMethodsParamsIn.Text = "In Params"; + // + // listMethodParamsIn + // + this.listMethodParamsIn.Dock = System.Windows.Forms.DockStyle.Fill; + this.listMethodParamsIn.FullRowSelect = true; + this.listMethodParamsIn.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.Nonclickable; + this.listMethodParamsIn.HideSelection = false; + this.listMethodParamsIn.Location = new System.Drawing.Point(3, 16); + this.listMethodParamsIn.Name = "listMethodParamsIn"; + this.listMethodParamsIn.ShowItemToolTips = true; + this.listMethodParamsIn.Size = new System.Drawing.Size(260, 123); + this.listMethodParamsIn.TabIndex = 0; + this.listMethodParamsIn.UseCompatibleStateImageBehavior = false; + this.listMethodParamsIn.View = System.Windows.Forms.View.Details; + this.listMethodParamsIn.SelectedIndexChanged += new System.EventHandler(this.listProps_SelectedIndexChanged); + // + // groupBoxMethodsParamsOut + // + this.groupBoxMethodsParamsOut.Controls.Add(this.listMethodParamsOut); + this.groupBoxMethodsParamsOut.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxMethodsParamsOut.Location = new System.Drawing.Point(275, 3); + this.groupBoxMethodsParamsOut.Name = "groupBoxMethodsParamsOut"; + this.groupBoxMethodsParamsOut.Size = new System.Drawing.Size(267, 142); + this.groupBoxMethodsParamsOut.TabIndex = 3; + this.groupBoxMethodsParamsOut.TabStop = false; + this.groupBoxMethodsParamsOut.Text = "Out Params"; + // + // listMethodParamsOut + // + this.listMethodParamsOut.Dock = System.Windows.Forms.DockStyle.Fill; + this.listMethodParamsOut.FullRowSelect = true; + this.listMethodParamsOut.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.Nonclickable; + this.listMethodParamsOut.HideSelection = false; + this.listMethodParamsOut.Location = new System.Drawing.Point(3, 16); + this.listMethodParamsOut.Name = "listMethodParamsOut"; + this.listMethodParamsOut.ShowItemToolTips = true; + this.listMethodParamsOut.Size = new System.Drawing.Size(261, 123); + this.listMethodParamsOut.TabIndex = 0; + this.listMethodParamsOut.UseCompatibleStateImageBehavior = false; + this.listMethodParamsOut.View = System.Windows.Forms.View.Details; + this.listMethodParamsOut.SelectedIndexChanged += new System.EventHandler(this.listProps_SelectedIndexChanged); + // + // richTextBoxMethodDetails + // + this.richTextBoxMethodDetails.BorderStyle = System.Windows.Forms.BorderStyle.None; + this.richTextBoxMethodDetails.Dock = System.Windows.Forms.DockStyle.Fill; + this.richTextBoxMethodDetails.Location = new System.Drawing.Point(0, 0); + this.richTextBoxMethodDetails.Name = "richTextBoxMethodDetails"; + this.richTextBoxMethodDetails.ReadOnly = true; + this.richTextBoxMethodDetails.Size = new System.Drawing.Size(545, 104); + this.richTextBoxMethodDetails.TabIndex = 0; + this.richTextBoxMethodDetails.Text = ""; + this.richTextBoxMethodDetails.LinkClicked += new System.Windows.Forms.LinkClickedEventHandler(this.richTextBoxMethodDetails_LinkClicked); + this.richTextBoxMethodDetails.Click += new System.EventHandler(this.richTextBox_Click); + // + // tabQueryResults + // + this.tabQueryResults.BackColor = System.Drawing.SystemColors.Control; + this.tabQueryResults.Controls.Add(this.splitContainerQuery); + this.tabQueryResults.Location = new System.Drawing.Point(4, 22); + this.tabQueryResults.Name = "tabQueryResults"; + this.tabQueryResults.Padding = new System.Windows.Forms.Padding(3); + this.tabQueryResults.Size = new System.Drawing.Size(555, 499); + this.tabQueryResults.TabIndex = 5; + this.tabQueryResults.Text = "Query"; + // + // splitContainerQuery + // + this.splitContainerQuery.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainerQuery.FixedPanel = System.Windows.Forms.FixedPanel.Panel1; + this.splitContainerQuery.Location = new System.Drawing.Point(3, 3); + this.splitContainerQuery.Name = "splitContainerQuery"; + this.splitContainerQuery.Orientation = System.Windows.Forms.Orientation.Horizontal; + // + // splitContainerQuery.Panel1 + // + this.splitContainerQuery.Panel1.Controls.Add(this.tableLayoutQuery); + this.splitContainerQuery.Panel1MinSize = 100; + // + // splitContainerQuery.Panel2 + // + this.splitContainerQuery.Panel2.Controls.Add(this.groupBoxQueryResults); + this.splitContainerQuery.Size = new System.Drawing.Size(549, 493); + this.splitContainerQuery.SplitterDistance = 100; + this.splitContainerQuery.SplitterWidth = 1; + this.splitContainerQuery.TabIndex = 0; + // + // tableLayoutQuery + // + this.tableLayoutQuery.ColumnCount = 2; + this.tableLayoutQuery.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutQuery.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 120F)); + this.tableLayoutQuery.Controls.Add(this.groupBoxQueryOutput, 0, 0); + this.tableLayoutQuery.Controls.Add(this.groupBoxQuery2, 0, 0); + this.tableLayoutQuery.Controls.Add(this.buttonQueryExecute2, 1, 1); + this.tableLayoutQuery.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutQuery.Location = new System.Drawing.Point(0, 0); + this.tableLayoutQuery.Name = "tableLayoutQuery"; + this.tableLayoutQuery.RowCount = 2; + this.tableLayoutQuery.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutQuery.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 30F)); + this.tableLayoutQuery.Size = new System.Drawing.Size(549, 100); + this.tableLayoutQuery.TabIndex = 0; + // + // groupBoxQueryOutput + // + this.groupBoxQueryOutput.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left))); + this.groupBoxQueryOutput.BackColor = System.Drawing.SystemColors.Control; + this.groupBoxQueryOutput.Controls.Add(this.radioQueryOutDataGrid); + this.groupBoxQueryOutput.Controls.Add(this.radioQueryOutListView); + this.groupBoxQueryOutput.Location = new System.Drawing.Point(432, 3); + this.groupBoxQueryOutput.Name = "groupBoxQueryOutput"; + this.groupBoxQueryOutput.Size = new System.Drawing.Size(114, 64); + this.groupBoxQueryOutput.TabIndex = 2; + this.groupBoxQueryOutput.TabStop = false; + this.groupBoxQueryOutput.Text = "Output View"; + // + // radioQueryOutDataGrid + // + this.radioQueryOutDataGrid.AutoSize = true; + this.radioQueryOutDataGrid.Checked = true; + this.radioQueryOutDataGrid.Location = new System.Drawing.Point(6, 19); + this.radioQueryOutDataGrid.Name = "radioQueryOutDataGrid"; + this.radioQueryOutDataGrid.Size = new System.Drawing.Size(70, 17); + this.radioQueryOutDataGrid.TabIndex = 0; + this.radioQueryOutDataGrid.TabStop = true; + this.radioQueryOutDataGrid.Text = "Data Grid"; + this.radioQueryOutDataGrid.UseVisualStyleBackColor = true; + this.radioQueryOutDataGrid.CheckedChanged += new System.EventHandler(this.radioQueryOutDataGrid_CheckedChanged); + // + // radioQueryOutListView + // + this.radioQueryOutListView.AutoSize = true; + this.radioQueryOutListView.Location = new System.Drawing.Point(6, 42); + this.radioQueryOutListView.Name = "radioQueryOutListView"; + this.radioQueryOutListView.Size = new System.Drawing.Size(67, 17); + this.radioQueryOutListView.TabIndex = 1; + this.radioQueryOutListView.Text = "List View"; + this.radioQueryOutListView.UseVisualStyleBackColor = true; + this.radioQueryOutListView.CheckedChanged += new System.EventHandler(this.radioQueryOutListView_CheckedChanged); + // + // groupBoxQuery2 + // + this.groupBoxQuery2.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.groupBoxQuery2.BackColor = System.Drawing.SystemColors.Control; + this.groupBoxQuery2.Controls.Add(this.textBoxQuery2); + this.groupBoxQuery2.Location = new System.Drawing.Point(3, 3); + this.groupBoxQuery2.Name = "groupBoxQuery2"; + this.tableLayoutQuery.SetRowSpan(this.groupBoxQuery2, 2); + this.groupBoxQuery2.Size = new System.Drawing.Size(423, 94); + this.groupBoxQuery2.TabIndex = 1; + this.groupBoxQuery2.TabStop = false; + this.groupBoxQuery2.Text = "WQL Query"; + // + // textBoxQuery2 + // + this.textBoxQuery2.Dock = System.Windows.Forms.DockStyle.Fill; + this.textBoxQuery2.Location = new System.Drawing.Point(3, 16); + this.textBoxQuery2.Multiline = true; + this.textBoxQuery2.Name = "textBoxQuery2"; + this.textBoxQuery2.ScrollBars = System.Windows.Forms.ScrollBars.Both; + this.textBoxQuery2.Size = new System.Drawing.Size(417, 75); + this.textBoxQuery2.TabIndex = 0; + // + // buttonQueryExecute2 + // + this.buttonQueryExecute2.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.buttonQueryExecute2.Location = new System.Drawing.Point(432, 73); + this.buttonQueryExecute2.Name = "buttonQueryExecute2"; + this.buttonQueryExecute2.Size = new System.Drawing.Size(114, 24); + this.buttonQueryExecute2.TabIndex = 0; + this.buttonQueryExecute2.Text = "Execute"; + this.buttonQueryExecute2.UseVisualStyleBackColor = true; + this.buttonQueryExecute2.Click += new System.EventHandler(this.buttonQueryExecute2_Click); + // + // groupBoxQueryResults + // + this.groupBoxQueryResults.Controls.Add(this.splitContainerQueryResults); + this.groupBoxQueryResults.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxQueryResults.Location = new System.Drawing.Point(0, 0); + this.groupBoxQueryResults.Name = "groupBoxQueryResults"; + this.groupBoxQueryResults.Size = new System.Drawing.Size(549, 392); + this.groupBoxQueryResults.TabIndex = 0; + this.groupBoxQueryResults.TabStop = false; + this.groupBoxQueryResults.Text = "Results"; + // + // splitContainerQueryResults + // + this.splitContainerQueryResults.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.splitContainerQueryResults.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainerQueryResults.Location = new System.Drawing.Point(3, 16); + this.splitContainerQueryResults.Name = "splitContainerQueryResults"; + // + // splitContainerQueryResults.Panel1 + // + this.splitContainerQueryResults.Panel1.Controls.Add(this.listQueryResults); + this.splitContainerQueryResults.Panel1.Padding = new System.Windows.Forms.Padding(3); + // + // splitContainerQueryResults.Panel2 + // + this.splitContainerQueryResults.Panel2.Controls.Add(this.propertyGridQueryResults); + this.splitContainerQueryResults.Panel2.Padding = new System.Windows.Forms.Padding(3); + this.splitContainerQueryResults.Size = new System.Drawing.Size(543, 373); + this.splitContainerQueryResults.SplitterDistance = 177; + this.splitContainerQueryResults.SplitterWidth = 1; + this.splitContainerQueryResults.TabIndex = 1; + // + // listQueryResults + // + this.listQueryResults.Dock = System.Windows.Forms.DockStyle.Fill; + this.listQueryResults.FullRowSelect = true; + this.listQueryResults.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.None; + this.listQueryResults.HideSelection = false; + this.listQueryResults.Location = new System.Drawing.Point(3, 3); + this.listQueryResults.MultiSelect = false; + this.listQueryResults.Name = "listQueryResults"; + this.listQueryResults.ShowItemToolTips = true; + this.listQueryResults.Size = new System.Drawing.Size(167, 363); + this.listQueryResults.TabIndex = 0; + this.listQueryResults.UseCompatibleStateImageBehavior = false; + this.listQueryResults.View = System.Windows.Forms.View.Details; + this.listQueryResults.SelectedIndexChanged += new System.EventHandler(this.listQueryResults_SelectedIndexChanged); + // + // propertyGridQueryResults + // + this.propertyGridQueryResults.Dock = System.Windows.Forms.DockStyle.Fill; + this.propertyGridQueryResults.Location = new System.Drawing.Point(3, 3); + this.propertyGridQueryResults.Name = "propertyGridQueryResults"; + this.propertyGridQueryResults.Size = new System.Drawing.Size(355, 363); + this.propertyGridQueryResults.TabIndex = 0; + this.propertyGridQueryResults.ToolbarVisible = false; + // + // tabScript + // + this.tabScript.BackColor = System.Drawing.SystemColors.Control; + this.tabScript.Controls.Add(this.tableLayoutScript); + this.tabScript.Location = new System.Drawing.Point(4, 22); + this.tabScript.Name = "tabScript"; + this.tabScript.Padding = new System.Windows.Forms.Padding(3); + this.tabScript.Size = new System.Drawing.Size(555, 499); + this.tabScript.TabIndex = 6; + this.tabScript.Text = "Script"; + // + // tableLayoutScript + // + this.tableLayoutScript.ColumnCount = 3; + this.tableLayoutScript.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 175F)); + this.tableLayoutScript.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 175F)); + this.tableLayoutScript.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle()); + this.tableLayoutScript.Controls.Add(this.groupBoxScriptLanguage, 0, 0); + this.tableLayoutScript.Controls.Add(this.groupBoxScriptOutput, 1, 0); + this.tableLayoutScript.Controls.Add(this.groupBoxScriptExecute, 2, 0); + this.tableLayoutScript.Controls.Add(this.groupBoxScript, 0, 1); + this.tableLayoutScript.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutScript.Location = new System.Drawing.Point(3, 3); + this.tableLayoutScript.Name = "tableLayoutScript"; + this.tableLayoutScript.RowCount = 2; + this.tableLayoutScript.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 55F)); + this.tableLayoutScript.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutScript.Size = new System.Drawing.Size(549, 493); + this.tableLayoutScript.TabIndex = 0; + // + // groupBoxScriptLanguage + // + this.groupBoxScriptLanguage.BackColor = System.Drawing.SystemColors.Control; + this.groupBoxScriptLanguage.Controls.Add(this.radioScriptPs); + this.groupBoxScriptLanguage.Controls.Add(this.radioScriptVbs); + this.groupBoxScriptLanguage.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxScriptLanguage.Location = new System.Drawing.Point(3, 3); + this.groupBoxScriptLanguage.Name = "groupBoxScriptLanguage"; + this.groupBoxScriptLanguage.Size = new System.Drawing.Size(169, 49); + this.groupBoxScriptLanguage.TabIndex = 1; + this.groupBoxScriptLanguage.TabStop = false; + this.groupBoxScriptLanguage.Text = "Script Language"; + // + // radioScriptPs + // + this.radioScriptPs.AutoSize = true; + this.radioScriptPs.Location = new System.Drawing.Point(78, 19); + this.radioScriptPs.Name = "radioScriptPs"; + this.radioScriptPs.Size = new System.Drawing.Size(78, 17); + this.radioScriptPs.TabIndex = 1; + this.radioScriptPs.TabStop = true; + this.radioScriptPs.Text = "PowerShell"; + this.radioScriptPs.UseVisualStyleBackColor = true; + this.radioScriptPs.CheckedChanged += new System.EventHandler(this.radioScriptPs_CheckedChanged); + // + // radioScriptVbs + // + this.radioScriptVbs.AutoSize = true; + this.radioScriptVbs.Location = new System.Drawing.Point(6, 19); + this.radioScriptVbs.Name = "radioScriptVbs"; + this.radioScriptVbs.Size = new System.Drawing.Size(66, 17); + this.radioScriptVbs.TabIndex = 0; + this.radioScriptVbs.TabStop = true; + this.radioScriptVbs.Text = "VBScript"; + this.radioScriptVbs.UseVisualStyleBackColor = true; + this.radioScriptVbs.CheckedChanged += new System.EventHandler(this.radioScriptVbs_CheckedChanged); + // + // groupBoxScriptOutput + // + this.groupBoxScriptOutput.Controls.Add(this.radioScriptOutTxt); + this.groupBoxScriptOutput.Controls.Add(this.radioScriptOutCmd); + this.groupBoxScriptOutput.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxScriptOutput.Location = new System.Drawing.Point(178, 3); + this.groupBoxScriptOutput.Name = "groupBoxScriptOutput"; + this.groupBoxScriptOutput.Size = new System.Drawing.Size(169, 49); + this.groupBoxScriptOutput.TabIndex = 2; + this.groupBoxScriptOutput.TabStop = false; + this.groupBoxScriptOutput.Text = "Output Format"; + // + // radioScriptOutTxt + // + this.radioScriptOutTxt.AutoSize = true; + this.radioScriptOutTxt.Location = new System.Drawing.Point(117, 19); + this.radioScriptOutTxt.Name = "radioScriptOutTxt"; + this.radioScriptOutTxt.Size = new System.Drawing.Size(46, 17); + this.radioScriptOutTxt.TabIndex = 1; + this.radioScriptOutTxt.Text = "Text"; + this.radioScriptOutTxt.UseVisualStyleBackColor = true; + // + // radioScriptOutCmd + // + this.radioScriptOutCmd.AutoSize = true; + this.radioScriptOutCmd.Checked = true; + this.radioScriptOutCmd.Location = new System.Drawing.Point(6, 19); + this.radioScriptOutCmd.Name = "radioScriptOutCmd"; + this.radioScriptOutCmd.Size = new System.Drawing.Size(108, 17); + this.radioScriptOutCmd.TabIndex = 0; + this.radioScriptOutCmd.TabStop = true; + this.radioScriptOutCmd.Text = "Command Prompt"; + this.radioScriptOutCmd.UseVisualStyleBackColor = true; + // + // groupBoxScriptExecute + // + this.groupBoxScriptExecute.Controls.Add(this.buttonScriptSave); + this.groupBoxScriptExecute.Controls.Add(this.buttonScriptRun); + this.groupBoxScriptExecute.Location = new System.Drawing.Point(353, 3); + this.groupBoxScriptExecute.Name = "groupBoxScriptExecute"; + this.groupBoxScriptExecute.Size = new System.Drawing.Size(177, 49); + this.groupBoxScriptExecute.TabIndex = 3; + this.groupBoxScriptExecute.TabStop = false; + this.groupBoxScriptExecute.Text = "Execute"; + // + // buttonScriptSave + // + this.buttonScriptSave.Enabled = false; + this.buttonScriptSave.Location = new System.Drawing.Point(95, 20); + this.buttonScriptSave.Name = "buttonScriptSave"; + this.buttonScriptSave.Size = new System.Drawing.Size(75, 23); + this.buttonScriptSave.TabIndex = 1; + this.buttonScriptSave.Text = "Save Script"; + this.buttonScriptSave.UseVisualStyleBackColor = true; + this.buttonScriptSave.Click += new System.EventHandler(this.buttonScriptSave_Click); + // + // buttonScriptRun + // + this.buttonScriptRun.Enabled = false; + this.buttonScriptRun.Location = new System.Drawing.Point(6, 20); + this.buttonScriptRun.Name = "buttonScriptRun"; + this.buttonScriptRun.Size = new System.Drawing.Size(83, 23); + this.buttonScriptRun.TabIndex = 0; + this.buttonScriptRun.Text = "Run Script"; + this.buttonScriptRun.UseVisualStyleBackColor = true; + this.buttonScriptRun.Click += new System.EventHandler(this.buttonScriptRun_Click); + // + // groupBoxScript + // + this.tableLayoutScript.SetColumnSpan(this.groupBoxScript, 3); + this.groupBoxScript.Controls.Add(this.textBoxScript); + this.groupBoxScript.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxScript.Location = new System.Drawing.Point(3, 58); + this.groupBoxScript.Name = "groupBoxScript"; + this.groupBoxScript.Size = new System.Drawing.Size(544, 432); + this.groupBoxScript.TabIndex = 4; + this.groupBoxScript.TabStop = false; + this.groupBoxScript.Text = "Script"; + // + // textBoxScript + // + this.textBoxScript.Dock = System.Windows.Forms.DockStyle.Fill; + this.textBoxScript.Location = new System.Drawing.Point(3, 16); + this.textBoxScript.Multiline = true; + this.textBoxScript.Name = "textBoxScript"; + this.textBoxScript.ScrollBars = System.Windows.Forms.ScrollBars.Both; + this.textBoxScript.Size = new System.Drawing.Size(538, 413); + this.textBoxScript.TabIndex = 0; + // + // tabLogging + // + this.tabLogging.Controls.Add(this.textBoxLogging); + this.tabLogging.Location = new System.Drawing.Point(4, 22); + this.tabLogging.Name = "tabLogging"; + this.tabLogging.Padding = new System.Windows.Forms.Padding(3); + this.tabLogging.Size = new System.Drawing.Size(555, 499); + this.tabLogging.TabIndex = 2; + this.tabLogging.Text = "Logging"; + this.tabLogging.UseVisualStyleBackColor = true; + // + // textBoxLogging + // + this.textBoxLogging.BackColor = System.Drawing.SystemColors.Control; + this.textBoxLogging.Dock = System.Windows.Forms.DockStyle.Fill; + this.textBoxLogging.Location = new System.Drawing.Point(3, 3); + this.textBoxLogging.Multiline = true; + this.textBoxLogging.Name = "textBoxLogging"; + this.textBoxLogging.ScrollBars = System.Windows.Forms.ScrollBars.Vertical; + this.textBoxLogging.Size = new System.Drawing.Size(549, 493); + this.textBoxLogging.TabIndex = 0; + // + // tabDebug2 + // + this.tabDebug2.Controls.Add(this.tableLayoutDebug2); + this.tabDebug2.Location = new System.Drawing.Point(4, 22); + this.tabDebug2.Name = "tabDebug2"; + this.tabDebug2.Padding = new System.Windows.Forms.Padding(3); + this.tabDebug2.Size = new System.Drawing.Size(555, 499); + this.tabDebug2.TabIndex = 3; + this.tabDebug2.Text = "Debug"; + this.tabDebug2.UseVisualStyleBackColor = true; + // + // tableLayoutDebug2 + // + this.tableLayoutDebug2.ColumnCount = 2; + this.tableLayoutDebug2.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F)); + this.tableLayoutDebug2.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F)); + this.tableLayoutDebug2.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 20F)); + this.tableLayoutDebug2.Controls.Add(this.propertyGridDebugWmiInstance, 1, 0); + this.tableLayoutDebug2.Controls.Add(this.propertyGridDebugWmiClass, 0, 0); + this.tableLayoutDebug2.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutDebug2.Location = new System.Drawing.Point(3, 3); + this.tableLayoutDebug2.Name = "tableLayoutDebug2"; + this.tableLayoutDebug2.RowCount = 1; + this.tableLayoutDebug2.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutDebug2.Size = new System.Drawing.Size(549, 493); + this.tableLayoutDebug2.TabIndex = 1; + // + // propertyGridDebugWmiInstance + // + this.propertyGridDebugWmiInstance.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.propertyGridDebugWmiInstance.Location = new System.Drawing.Point(277, 3); + this.propertyGridDebugWmiInstance.Name = "propertyGridDebugWmiInstance"; + this.propertyGridDebugWmiInstance.Size = new System.Drawing.Size(269, 487); + this.propertyGridDebugWmiInstance.TabIndex = 2; + // + // propertyGridDebugWmiClass + // + this.propertyGridDebugWmiClass.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.propertyGridDebugWmiClass.Location = new System.Drawing.Point(3, 3); + this.propertyGridDebugWmiClass.Name = "propertyGridDebugWmiClass"; + this.propertyGridDebugWmiClass.Size = new System.Drawing.Size(268, 487); + this.propertyGridDebugWmiClass.TabIndex = 1; + // + // tabSearch + // + this.tabSearch.BackColor = System.Drawing.SystemColors.Control; + this.tabSearch.Controls.Add(this.tableLayoutSearch); + this.tabSearch.Location = new System.Drawing.Point(4, 22); + this.tabSearch.Name = "tabSearch"; + this.tabSearch.Padding = new System.Windows.Forms.Padding(3); + this.tabSearch.Size = new System.Drawing.Size(772, 531); + this.tabSearch.TabIndex = 1; + this.tabSearch.Text = "Search"; + // + // tableLayoutSearch + // + this.tableLayoutSearch.ColumnCount = 1; + this.tableLayoutSearch.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutSearch.Controls.Add(this.groupBoxSearch, 0, 0); + this.tableLayoutSearch.Controls.Add(this.groupBoxSearchResults, 0, 1); + this.tableLayoutSearch.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutSearch.Location = new System.Drawing.Point(3, 3); + this.tableLayoutSearch.Name = "tableLayoutSearch"; + this.tableLayoutSearch.RowCount = 2; + this.tableLayoutSearch.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 90F)); + this.tableLayoutSearch.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutSearch.Size = new System.Drawing.Size(766, 525); + this.tableLayoutSearch.TabIndex = 0; + // + // groupBoxSearch + // + this.groupBoxSearch.Controls.Add(this.radioSearchProperties); + this.groupBoxSearch.Controls.Add(this.checkBoxSearchRecurse); + this.groupBoxSearch.Controls.Add(this.radioSearchMethods); + this.groupBoxSearch.Controls.Add(this.radioSearchClasses); + this.groupBoxSearch.Controls.Add(this.labelSearch2); + this.groupBoxSearch.Controls.Add(this.buttonSearch); + this.groupBoxSearch.Controls.Add(this.textBoxSearchPattern); + this.groupBoxSearch.Controls.Add(this.labelSearch1); + this.groupBoxSearch.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxSearch.Location = new System.Drawing.Point(3, 3); + this.groupBoxSearch.Name = "groupBoxSearch"; + this.groupBoxSearch.Size = new System.Drawing.Size(760, 84); + this.groupBoxSearch.TabIndex = 1; + this.groupBoxSearch.TabStop = false; + this.groupBoxSearch.Text = "Search Options"; + // + // radioSearchProperties + // + this.radioSearchProperties.AutoSize = true; + this.radioSearchProperties.Location = new System.Drawing.Point(152, 39); + this.radioSearchProperties.Name = "radioSearchProperties"; + this.radioSearchProperties.Size = new System.Drawing.Size(72, 17); + this.radioSearchProperties.TabIndex = 2; + this.radioSearchProperties.Text = "Properties"; + this.radioSearchProperties.UseVisualStyleBackColor = true; + // + // checkBoxSearchRecurse + // + this.checkBoxSearchRecurse.AutoSize = true; + this.checkBoxSearchRecurse.Location = new System.Drawing.Point(516, 41); + this.checkBoxSearchRecurse.Name = "checkBoxSearchRecurse"; + this.checkBoxSearchRecurse.Size = new System.Drawing.Size(74, 17); + this.checkBoxSearchRecurse.TabIndex = 4; + this.checkBoxSearchRecurse.Text = "Recursive"; + this.checkBoxSearchRecurse.UseVisualStyleBackColor = true; + // + // radioSearchMethods + // + this.radioSearchMethods.AutoSize = true; + this.radioSearchMethods.Location = new System.Drawing.Point(80, 39); + this.radioSearchMethods.Name = "radioSearchMethods"; + this.radioSearchMethods.Size = new System.Drawing.Size(66, 17); + this.radioSearchMethods.TabIndex = 1; + this.radioSearchMethods.Text = "Methods"; + this.radioSearchMethods.UseVisualStyleBackColor = true; + // + // radioSearchClasses + // + this.radioSearchClasses.AutoSize = true; + this.radioSearchClasses.Checked = true; + this.radioSearchClasses.Location = new System.Drawing.Point(13, 39); + this.radioSearchClasses.Name = "radioSearchClasses"; + this.radioSearchClasses.Size = new System.Drawing.Size(61, 17); + this.radioSearchClasses.TabIndex = 0; + this.radioSearchClasses.TabStop = true; + this.radioSearchClasses.Text = "Classes"; + this.radioSearchClasses.UseVisualStyleBackColor = true; + // + // labelSearch2 + // + this.labelSearch2.AutoSize = true; + this.labelSearch2.Location = new System.Drawing.Point(10, 64); + this.labelSearch2.Name = "labelSearch2"; + this.labelSearch2.Size = new System.Drawing.Size(641, 13); + this.labelSearch2.TabIndex = 3; + this.labelSearch2.Text = "\"Include\" checkboxes in Class Options apply to Search Results as well. NOTE: Recu" + + "rsively Searching Properties can take a long time.\r\n"; + // + // buttonSearch + // + this.buttonSearch.Location = new System.Drawing.Point(596, 37); + this.buttonSearch.Name = "buttonSearch"; + this.buttonSearch.Size = new System.Drawing.Size(102, 23); + this.buttonSearch.TabIndex = 5; + this.buttonSearch.Text = "Search"; + this.buttonSearch.UseVisualStyleBackColor = true; + this.buttonSearch.Click += new System.EventHandler(this.buttonSearch_Click); + // + // textBoxSearchPattern + // + this.textBoxSearchPattern.Location = new System.Drawing.Point(230, 38); + this.textBoxSearchPattern.Name = "textBoxSearchPattern"; + this.textBoxSearchPattern.Size = new System.Drawing.Size(280, 20); + this.textBoxSearchPattern.TabIndex = 3; + this.textBoxSearchPattern.KeyDown += new System.Windows.Forms.KeyEventHandler(this.textBoxSearchPattern_KeyDown); + // + // labelSearch1 + // + this.labelSearch1.AutoSize = true; + this.labelSearch1.Location = new System.Drawing.Point(7, 20); + this.labelSearch1.Name = "labelSearch1"; + this.labelSearch1.Size = new System.Drawing.Size(601, 13); + this.labelSearch1.TabIndex = 0; + this.labelSearch1.Text = "Select namespace, and specify search criteria to find all matching classes/method" + + "s/properties within the selected namespace:"; + // + // groupBoxSearchResults + // + this.groupBoxSearchResults.Controls.Add(this.listSearchResults); + this.groupBoxSearchResults.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxSearchResults.Location = new System.Drawing.Point(3, 93); + this.groupBoxSearchResults.Name = "groupBoxSearchResults"; + this.groupBoxSearchResults.Size = new System.Drawing.Size(760, 429); + this.groupBoxSearchResults.TabIndex = 2; + this.groupBoxSearchResults.TabStop = false; + this.groupBoxSearchResults.Text = "Search Results"; + // + // listSearchResults + // + this.listSearchResults.Dock = System.Windows.Forms.DockStyle.Fill; + this.listSearchResults.FullRowSelect = true; + this.listSearchResults.HideSelection = false; + this.listSearchResults.Location = new System.Drawing.Point(3, 16); + this.listSearchResults.MultiSelect = false; + this.listSearchResults.Name = "listSearchResults"; + this.listSearchResults.ShowItemToolTips = true; + this.listSearchResults.Size = new System.Drawing.Size(754, 410); + this.listSearchResults.TabIndex = 0; + this.listSearchResults.UseCompatibleStateImageBehavior = false; + this.listSearchResults.View = System.Windows.Forms.View.Details; + this.listSearchResults.ColumnClick += new System.Windows.Forms.ColumnClickEventHandler(this.listView_ColumnClick); + // + // tabDebug1 + // + this.tabDebug1.Controls.Add(this.tableLayoutDebug1); + this.tabDebug1.Location = new System.Drawing.Point(4, 22); + this.tabDebug1.Name = "tabDebug1"; + this.tabDebug1.Size = new System.Drawing.Size(772, 531); + this.tabDebug1.TabIndex = 2; + this.tabDebug1.Text = "Debug"; + this.tabDebug1.UseVisualStyleBackColor = true; + // + // tableLayoutDebug1 + // + this.tableLayoutDebug1.ColumnCount = 2; + this.tableLayoutDebug1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F)); + this.tableLayoutDebug1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F)); + this.tableLayoutDebug1.Controls.Add(this.propertyGridDebugWmiNamespace, 1, 0); + this.tableLayoutDebug1.Controls.Add(this.propertyGridDebugWmiNode, 0, 0); + this.tableLayoutDebug1.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutDebug1.Location = new System.Drawing.Point(0, 0); + this.tableLayoutDebug1.Name = "tableLayoutDebug1"; + this.tableLayoutDebug1.RowCount = 1; + this.tableLayoutDebug1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutDebug1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 531F)); + this.tableLayoutDebug1.Size = new System.Drawing.Size(772, 531); + this.tableLayoutDebug1.TabIndex = 0; + // + // propertyGridDebugWmiNamespace + // + this.propertyGridDebugWmiNamespace.Dock = System.Windows.Forms.DockStyle.Fill; + this.propertyGridDebugWmiNamespace.Location = new System.Drawing.Point(389, 3); + this.propertyGridDebugWmiNamespace.Name = "propertyGridDebugWmiNamespace"; + this.propertyGridDebugWmiNamespace.Size = new System.Drawing.Size(380, 525); + this.propertyGridDebugWmiNamespace.TabIndex = 1; + // + // propertyGridDebugWmiNode + // + this.propertyGridDebugWmiNode.Dock = System.Windows.Forms.DockStyle.Fill; + this.propertyGridDebugWmiNode.Location = new System.Drawing.Point(3, 3); + this.propertyGridDebugWmiNode.Name = "propertyGridDebugWmiNode"; + this.propertyGridDebugWmiNode.Size = new System.Drawing.Size(380, 525); + this.propertyGridDebugWmiNode.TabIndex = 2; + // + // groupBoxCallingMode + // + this.groupBoxCallingMode.Controls.Add(this.radioModeSync); + this.groupBoxCallingMode.Controls.Add(this.radioModeAsync); + this.groupBoxCallingMode.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBoxCallingMode.Location = new System.Drawing.Point(224, 3); + this.groupBoxCallingMode.Name = "groupBoxCallingMode"; + this.groupBoxCallingMode.Size = new System.Drawing.Size(114, 54); + this.groupBoxCallingMode.TabIndex = 1; + this.groupBoxCallingMode.TabStop = false; + this.groupBoxCallingMode.Text = "Mode"; + // + // radioModeSync + // + this.radioModeSync.AutoSize = true; + this.radioModeSync.Location = new System.Drawing.Point(7, 31); + this.radioModeSync.Name = "radioModeSync"; + this.radioModeSync.Size = new System.Drawing.Size(87, 17); + this.radioModeSync.TabIndex = 1; + this.radioModeSync.TabStop = true; + this.radioModeSync.Text = "Synchronous"; + this.toolTip.SetToolTip(this.radioModeSync, "Synchronous enumeration of classes and instances. This can freeze the UI when enu" + + "merating a large number of objects."); + this.radioModeSync.UseVisualStyleBackColor = true; + // + // radioModeAsync + // + this.radioModeAsync.AutoSize = true; + this.radioModeAsync.Checked = global::WmiExplorer.Properties.Settings.Default.bEnumModeAsync; + this.radioModeAsync.DataBindings.Add(new System.Windows.Forms.Binding("Checked", global::WmiExplorer.Properties.Settings.Default, "bEnumModeAsync", true, System.Windows.Forms.DataSourceUpdateMode.OnPropertyChanged)); + this.radioModeAsync.Location = new System.Drawing.Point(7, 14); + this.radioModeAsync.Name = "radioModeAsync"; + this.radioModeAsync.Size = new System.Drawing.Size(92, 17); + this.radioModeAsync.TabIndex = 0; + this.radioModeAsync.TabStop = true; + this.radioModeAsync.Text = "Asynchronous"; + this.toolTip.SetToolTip(this.radioModeAsync, resources.GetString("radioModeAsync.ToolTip")); + this.radioModeAsync.UseVisualStyleBackColor = true; + // + // saveScriptDialog + // + this.saveScriptDialog.FileOk += new System.ComponentModel.CancelEventHandler(this.saveScriptDialog_FileOk); + // + // WmiExplorer + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.ClientSize = new System.Drawing.Size(1008, 729); + this.Controls.Add(this.tableLayoutPanelMain); + this.Controls.Add(this.statusStrip); + this.Controls.Add(this.menuStrip); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.KeyPreview = true; + this.MainMenuStrip = this.menuStrip; + this.MinimumSize = new System.Drawing.Size(18, 45); + this.Name = "WmiExplorer"; + this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Show; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "WMI Explorer 2.0"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.WmiExplorer_FormClosing); + this.Load += new System.EventHandler(this.WmiExplorer_Load); + this.KeyDown += new System.Windows.Forms.KeyEventHandler(this.WmiExplorer_KeyDown); + this.menuStrip.ResumeLayout(false); + this.menuStrip.PerformLayout(); + this.statusStrip.ResumeLayout(false); + this.statusStrip.PerformLayout(); + this.tableLayoutPanelMain.ResumeLayout(false); + this.groupBoxComputer.ResumeLayout(false); + this.groupBoxComputer.PerformLayout(); + this.groupBoxClassOptions.ResumeLayout(false); + this.groupBoxClassOptions.PerformLayout(); + this.groupBoxQuery1.ResumeLayout(false); + this.groupBoxQuery1.PerformLayout(); + this.splitContainerNamespaceClasses.Panel1.ResumeLayout(false); + this.splitContainerNamespaceClasses.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerNamespaceClasses)).EndInit(); + this.splitContainerNamespaceClasses.ResumeLayout(false); + this.groupBoxNamespaces.ResumeLayout(false); + this.tabControlClasses.ResumeLayout(false); + this.tabClasses.ResumeLayout(false); + this.splitContainerClassesInstances.Panel1.ResumeLayout(false); + this.splitContainerClassesInstances.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerClassesInstances)).EndInit(); + this.splitContainerClassesInstances.ResumeLayout(false); + this.tableLayoutClasses.ResumeLayout(false); + this.tableLayoutClasses.PerformLayout(); + this.groupBoxClasses.ResumeLayout(false); + this.tabControlInstances.ResumeLayout(false); + this.tabInstances.ResumeLayout(false); + this.groupBoxInstanceOptions.ResumeLayout(false); + this.groupBoxInstanceOptions.PerformLayout(); + this.splitContainerInstancesProperties.Panel1.ResumeLayout(false); + this.splitContainerInstancesProperties.Panel1.PerformLayout(); + this.splitContainerInstancesProperties.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerInstancesProperties)).EndInit(); + this.splitContainerInstancesProperties.ResumeLayout(false); + this.groupBoxInstances.ResumeLayout(false); + this.tabProperties.ResumeLayout(false); + this.splitContainerClassProperties.Panel1.ResumeLayout(false); + this.splitContainerClassProperties.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerClassProperties)).EndInit(); + this.splitContainerClassProperties.ResumeLayout(false); + this.groupBoxClassProperties.ResumeLayout(false); + this.tabMethods.ResumeLayout(false); + this.splitContainerMethodsTab.Panel1.ResumeLayout(false); + this.splitContainerMethodsTab.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerMethodsTab)).EndInit(); + this.splitContainerMethodsTab.ResumeLayout(false); + this.splitContainerMethodsParams.Panel1.ResumeLayout(false); + this.splitContainerMethodsParams.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerMethodsParams)).EndInit(); + this.splitContainerMethodsParams.ResumeLayout(false); + this.groupBoxClassMethods.ResumeLayout(false); + this.tableLayoutMethods.ResumeLayout(false); + this.groupBoxMethodsParamsIn.ResumeLayout(false); + this.groupBoxMethodsParamsOut.ResumeLayout(false); + this.tabQueryResults.ResumeLayout(false); + this.splitContainerQuery.Panel1.ResumeLayout(false); + this.splitContainerQuery.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerQuery)).EndInit(); + this.splitContainerQuery.ResumeLayout(false); + this.tableLayoutQuery.ResumeLayout(false); + this.groupBoxQueryOutput.ResumeLayout(false); + this.groupBoxQueryOutput.PerformLayout(); + this.groupBoxQuery2.ResumeLayout(false); + this.groupBoxQuery2.PerformLayout(); + this.groupBoxQueryResults.ResumeLayout(false); + this.splitContainerQueryResults.Panel1.ResumeLayout(false); + this.splitContainerQueryResults.Panel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.splitContainerQueryResults)).EndInit(); + this.splitContainerQueryResults.ResumeLayout(false); + this.tabScript.ResumeLayout(false); + this.tableLayoutScript.ResumeLayout(false); + this.groupBoxScriptLanguage.ResumeLayout(false); + this.groupBoxScriptLanguage.PerformLayout(); + this.groupBoxScriptOutput.ResumeLayout(false); + this.groupBoxScriptOutput.PerformLayout(); + this.groupBoxScriptExecute.ResumeLayout(false); + this.groupBoxScript.ResumeLayout(false); + this.groupBoxScript.PerformLayout(); + this.tabLogging.ResumeLayout(false); + this.tabLogging.PerformLayout(); + this.tabDebug2.ResumeLayout(false); + this.tableLayoutDebug2.ResumeLayout(false); + this.tabSearch.ResumeLayout(false); + this.tableLayoutSearch.ResumeLayout(false); + this.groupBoxSearch.ResumeLayout(false); + this.groupBoxSearch.PerformLayout(); + this.groupBoxSearchResults.ResumeLayout(false); + this.tabDebug1.ResumeLayout(false); + this.tableLayoutDebug1.ResumeLayout(false); + this.groupBoxCallingMode.ResumeLayout(false); + this.groupBoxCallingMode.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.MenuStrip menuStrip; + private System.Windows.Forms.ToolStripMenuItem menuItemFile; + private System.Windows.Forms.ToolStripMenuItem menuItemFile_Exit; + private System.Windows.Forms.ToolStripMenuItem menuItemLaunch; + private System.Windows.Forms.ToolStripMenuItem menuItemHelp; + private System.Windows.Forms.ToolStripMenuItem menuItemHelp_Documentation; + private System.Windows.Forms.ToolStripStatusLabel toolStripLabelUpdateNotification; + private System.Windows.Forms.StatusStrip statusStrip; + private System.Windows.Forms.ToolStripStatusLabel toolStripLabel1; + private System.Windows.Forms.ToolStripStatusLabel toolStripLabel2; + private System.Windows.Forms.ToolStripStatusLabel toolStripLabel3; + private System.Windows.Forms.TableLayoutPanel tableLayoutPanelMain; + private System.Windows.Forms.GroupBox groupBoxComputer; + private System.Windows.Forms.Button buttonComputerConnect; + private System.Windows.Forms.TextBox textBoxComputerName; + private System.Windows.Forms.GroupBox groupBoxClassOptions; + private System.Windows.Forms.Button buttonClassesRefresh; + private System.Windows.Forms.CheckBox checkBoxMSFT; + private System.Windows.Forms.CheckBox checkBoxPerf; + private System.Windows.Forms.CheckBox checkBoxCIM; + private System.Windows.Forms.CheckBox checkBoxSystem; + private System.Windows.Forms.TextBox textBoxClassFilter; + private System.Windows.Forms.Label labelClassFilter; + private System.Windows.Forms.GroupBox groupBoxQuery1; + private System.Windows.Forms.Button buttonQueryExecute1; + private System.Windows.Forms.Label labelQuery; + private System.Windows.Forms.TextBox textBoxQuery1; + private System.Windows.Forms.SplitContainer splitContainerNamespaceClasses; + private System.Windows.Forms.GroupBox groupBoxNamespaces; + private System.Windows.Forms.TreeView treeNamespaces; + private System.Windows.Forms.TabControl tabControlClasses; + private System.Windows.Forms.TabPage tabClasses; + private System.Windows.Forms.SplitContainer splitContainerClassesInstances; + private System.Windows.Forms.TabControl tabControlInstances; + private System.Windows.Forms.TabPage tabInstances; + private System.Windows.Forms.GroupBox groupBoxInstanceOptions; + private System.Windows.Forms.Button buttonRefreshObject; + private System.Windows.Forms.Button buttonInstancesRefresh; + private System.Windows.Forms.CheckBox checkNullProps; + private System.Windows.Forms.CheckBox checkSystemProps; + private System.Windows.Forms.TextBox textBoxInstanceFilterQuick; + private System.Windows.Forms.Label labelInstanceFilter; + private System.Windows.Forms.SplitContainer splitContainerInstancesProperties; + private System.Windows.Forms.GroupBox groupBoxInstances; + private System.Windows.Forms.ListView listInstances; + private System.Windows.Forms.PropertyGrid propertyGridInstance; + private System.Windows.Forms.TabPage tabMethods; + private System.Windows.Forms.TabPage tabLogging; + private System.Windows.Forms.TextBox textBoxLogging; + private System.Windows.Forms.TabPage tabSearch; + private System.Windows.Forms.TableLayoutPanel tableLayoutClasses; + private System.Windows.Forms.TextBox textBoxClassQuickFilter; + private System.Windows.Forms.GroupBox groupBoxClasses; + private System.Windows.Forms.ListView listClasses; + private System.Windows.Forms.Label labelClassQuickFilter; + private System.Windows.Forms.ToolStripMenuItem menuItemFile_Preferences; + private System.Windows.Forms.Button buttonHideNamespaces; + private System.Windows.Forms.ContextMenuStrip contextMenu; + private System.Windows.Forms.ToolTip toolTip; + private System.Windows.Forms.TabPage tabDebug2; + private System.Windows.Forms.TableLayoutPanel tableLayoutDebug2; + private System.Windows.Forms.PropertyGrid propertyGridDebugWmiInstance; + private System.Windows.Forms.PropertyGrid propertyGridDebugWmiClass; + private System.Windows.Forms.TabPage tabProperties; + private System.Windows.Forms.GroupBox groupBoxClassProperties; + private System.Windows.Forms.SplitContainer splitContainerClassProperties; + private System.Windows.Forms.RichTextBox richTextBoxClassDetails; + private System.Windows.Forms.ListView listClassProperties; + private System.Windows.Forms.SplitContainer splitContainerMethodsTab; + private System.Windows.Forms.TableLayoutPanel tableLayoutMethods; + private System.Windows.Forms.GroupBox groupBoxClassMethods; + private System.Windows.Forms.ListView listMethods; + private System.Windows.Forms.GroupBox groupBoxMethodsParamsIn; + private System.Windows.Forms.ListView listMethodParamsIn; + private System.Windows.Forms.GroupBox groupBoxMethodsParamsOut; + private System.Windows.Forms.ListView listMethodParamsOut; + private System.Windows.Forms.RichTextBox richTextBoxMethodDetails; + private System.Windows.Forms.TabPage tabQueryResults; + private System.Windows.Forms.SplitContainer splitContainerQuery; + private System.Windows.Forms.GroupBox groupBoxQueryResults; + private System.Windows.Forms.SplitContainer splitContainerQueryResults; + private System.Windows.Forms.PropertyGrid propertyGridQueryResults; + private System.Windows.Forms.ListView listQueryResults; + private System.Windows.Forms.TableLayoutPanel tableLayoutQuery; + private System.Windows.Forms.Button buttonQueryExecute2; + private System.Windows.Forms.GroupBox groupBoxQueryOutput; + private System.Windows.Forms.RadioButton radioQueryOutDataGrid; + private System.Windows.Forms.RadioButton radioQueryOutListView; + private System.Windows.Forms.GroupBox groupBoxQuery2; + private System.Windows.Forms.TextBox textBoxQuery2; + private System.Windows.Forms.DataGridView dataGridQueryResults; + private TabPage tabDebug1; + private TableLayoutPanel tableLayoutDebug1; + private PropertyGrid propertyGridDebugWmiNamespace; + private PropertyGrid propertyGridDebugWmiNode; + private TableLayoutPanel tableLayoutSearch; + private GroupBox groupBoxSearch; + private RadioButton radioSearchProperties; + private CheckBox checkBoxSearchRecurse; + private RadioButton radioSearchMethods; + private RadioButton radioSearchClasses; + private Label labelSearch2; + private Button buttonSearch; + private TextBox textBoxSearchPattern; + private Label labelSearch1; + private GroupBox groupBoxSearchResults; + private ListView listSearchResults; + private TabPage tabScript; + private TableLayoutPanel tableLayoutScript; + private GroupBox groupBoxScriptLanguage; + private RadioButton radioScriptPs; + private RadioButton radioScriptVbs; + private GroupBox groupBoxScriptOutput; + private RadioButton radioScriptOutTxt; + private RadioButton radioScriptOutCmd; + private GroupBox groupBoxScriptExecute; + private Button buttonScriptSave; + private Button buttonScriptRun; + private GroupBox groupBoxScript; + private TextBox textBoxScript; + private SaveFileDialog saveScriptDialog; + private ToolStripMenuItem menuItemLaunch_DcomCnfg; + private ToolStripMenuItem menuItemLaunch_WbemTest; + private ToolStripMenuItem menuItemLaunch_WmiMgmt; + private ToolStripMenuItem menuItemHelp_CheckUpdate; + private GroupBox groupBoxCallingMode; + private RadioButton radioModeSync; + private RadioButton radioModeAsync; + private ToolStripMenuItem menuItemFile_ConnectAs; + private ToolStripMenuItem menuItemFile_SmsMode; + private ToolStripMenuItem menuItemHelp_About; + private SplitContainer splitContainerMethodsParams; + } +} + diff --git a/WmiExplorer/WmiExplorer.Functions.Designer.cs b/WmiExplorer/WmiExplorer.Functions.Designer.cs new file mode 100644 index 0000000..72f6e0a --- /dev/null +++ b/WmiExplorer/WmiExplorer.Functions.Designer.cs @@ -0,0 +1,2769 @@ +using System; +using System.Collections.Generic; +using System.Collections.Specialized; +using System.ComponentModel; +using System.Data; +using System.Diagnostics; +using System.Drawing; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Management; +using System.Reflection; +using System.Runtime.Caching; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using System.Windows.Forms; +using WmiExplorer.Classes; +using WmiExplorer.Forms; +using WmiExplorer.Properties; +using WmiExplorer.Sms; +using WmiExplorer.Updater; + +namespace WmiExplorer +{ + partial class WmiExplorer + { + private static int _tempSplitterDistance; + private BackgroundWorker _bwClassEnumWorker; + private BackgroundWorker _bwInstanceEnumWorker; + private string _changeLogPath; + private ConnectionOptions _defaultConnection; + private string _instanceMof = String.Empty; + private ListViewColumnSorter _listClassesColumnSorter; + private ListViewColumnSorter _listClassPropertiesColumnSorter; + private ListViewColumnSorter _listMethodsColumnSorter; + private ListViewColumnSorter _listSearchResultsColumnSorter; + private bool _richTextSelectionResetRequired; + private bool _searchErrorOccurred; + private int _searchResultCount; + + private void AppendClassHelp(string helpText, FontStyle fontStyle = FontStyle.Regular, bool newLine = true, bool tabbed = true) + { + Font font; + + switch (fontStyle) + { + case FontStyle.Bold: + font = new Font("Arial", 10, fontStyle); + break; + + case FontStyle.Italic: + font = new Font("Arial", 9, fontStyle); + break; + + default: + font = new Font("Arial", 8, fontStyle); + break; + } + + if (tabbed && fontStyle == FontStyle.Regular) + helpText = " " + helpText.Replace("\n", "\n "); + + richTextBoxClassDetails.SelectionFont = font; + richTextBoxClassDetails.SelectedText = newLine ? helpText + "\n" : helpText; + } + + private void AppendMethodHelp(string helpText, FontStyle fontStyle = FontStyle.Regular, bool newLine = true, bool tabbed = true) + { + Font font; + + switch (fontStyle) + { + case FontStyle.Bold: + font = new Font("Arial", 10, fontStyle); + break; + + case FontStyle.Italic: + font = new Font("Arial", 9, fontStyle); + break; + + default: + font = new Font("Arial", 8, fontStyle); + break; + } + + if (tabbed && fontStyle == FontStyle.Regular) + helpText = " " + helpText.Replace("\n", "\n "); + + richTextBoxMethodDetails.SelectionFont = font; + richTextBoxMethodDetails.SelectedText = newLine ? helpText + "\n" : helpText; + } + + private void Connect(WmiNode nodeToConnect) + { + var pathToConnect = nodeToConnect.UserSpecifiedPath; + var userDisplayName = String.Empty; + try + { + string namespacePath; + var bNodeDisconnected = false; + + // Expand namespaces if hidden + if (buttonHideNamespaces.Text == "+") + buttonHideNamespaces.PerformClick(); + + // Parse the path + if (pathToConnect.Contains("\\")) + namespacePath = pathToConnect; + else + namespacePath = "\\\\" + pathToConnect + "\\root"; + + if (nodeToConnect.Connection.Username == null) + userDisplayName = SystemInformation.UserDomainName + "\\" + SystemInformation.UserName; + else + userDisplayName = nodeToConnect.Connection.Username; + + // Connect to Management Scope for root namespace + ManagementPath mPath = new ManagementPath(namespacePath); + ManagementScope mScope = new ManagementScope(mPath, nodeToConnect.Connection); + mScope.Connect(); + + // Get the Management Object for root namespace, and set the WmiNamespace object for the node + ObjectGetOptions oOptions = new ObjectGetOptions(); + ManagementObject mObject = new ManagementObject(mScope, mPath, oOptions); + nodeToConnect.WmiNamespace = new WmiNamespace(mObject); + + // Check if the node is already populated as Connected/Disconnected. + foreach (var treeNode in (from TreeNode treeNode in treeNamespaces.Nodes + where treeNode.Level == 0 + select treeNode)) + { + WmiNode currentWmiNode = treeNode.Tag as WmiNode; + + // Check if the path is already connected and select the node + if (currentWmiNode != null && currentWmiNode.IsConnected && currentWmiNode.WmiNamespace != null) + { + if (currentWmiNode.WmiNamespace.Path == nodeToConnect.WmiNamespace.Path) + { + treeNamespaces.SelectedNode = treeNode; + treeNamespaces.Select(); + SetStatusBar1(pathToConnect + " is already connected.", MessageCategory.Info, true); + SetStatusBar2( + "Right click " + nodeToConnect.WmiNamespace.Path + " and Disconnect before reconnecting.", + MessageCategory.Info); + return; + } + } + + // Check if path is already populated as Disconnected and select the node + if (currentWmiNode != null && currentWmiNode.UserSpecifiedPath == pathToConnect && !currentWmiNode.IsConnected) + { + treeNamespaces.SelectedNode = treeNode; + bNodeDisconnected = true; + break; + } + } + + // Check if connecting from disconnected state + if (treeNamespaces.SelectedNode != null && bNodeDisconnected) + { + // Set selected node values + // TODO: Investigate if this can be added to CreateTreeNodeFromWmiNode + treeNamespaces.SelectedNode.Name = nodeToConnect.WmiNamespace.Path; + treeNamespaces.SelectedNode.Text = nodeToConnect.WmiNamespace.DisplayName; + treeNamespaces.SelectedNode.Tag = nodeToConnect; + + // Populate child nodes and expand tree + EnumerateChildNamespaces(treeNamespaces.SelectedNode); + treeNamespaces.SelectedNode.Expand(); + treeNamespaces.Sort(); + } + else + { + // This is the first time we're connecting to this path + + // Create a new tree node + TreeNode tnRoot = CreateTreeNodeFromWmiNode(nodeToConnect); + + // Populate child nodes and expand tree + EnumerateChildNamespaces(tnRoot); + tnRoot.Expand(); + + // Sort and select node + treeNamespaces.Sort(); + treeNamespaces.SelectedNode = tnRoot; + + // Add node to treeview + treeNamespaces.Nodes.Add(tnRoot); + } + + // Activate treeview + treeNamespaces.Select(); + + nodeToConnect.IsConnected = true; + SetStatusBar1("Connected to " + pathToConnect + " using " + userDisplayName, MessageCategory.Info, true); + + // Save path to the RecentPaths after successful connection + if (Settings.Default.bRememberRecentPaths && !Settings.Default.RecentPaths.Contains(pathToConnect)) + { + Settings.Default.RecentPaths.Add(pathToConnect.ToUpper()); + Settings.Default.Save(); + } + + // Connect to SMS Client + if (Settings.Default.bSmsMode && nodeToConnect.SmsClient != null && nodeToConnect.SmsClient.IsClientInstalled) + { + Log("SMS Mode is enabled and SMS Client is installed."); + ConnectToSmsClient(nodeToConnect.SmsClient); + } + else if (Settings.Default.bSmsMode && nodeToConnect.SmsClient != null && !nodeToConnect.SmsClient.IsClientInstalled) + { + Log("SMS Mode is enabled but SMS Client is NOT installed."); + } + else if (Settings.Default.bSmsMode && nodeToConnect.SmsClient == null) + { + Log("SMS Mode is enabled but SMS Client is NOT installed."); + } + else if (!Settings.Default.bSmsMode && nodeToConnect.SmsClient != null && nodeToConnect.SmsClient.IsClientInstalled) + { + Log("SMS Mode is NOT enabled but SMS Client is installed."); + } + else if (!Settings.Default.bSmsMode) + { + Log("SMS Mode is NOT enabled"); + } + } + catch (UnauthorizedAccessException ex) + { + var errorMessage = "Failed to connect to " + pathToConnect + " using " + userDisplayName + ". Error: " + ex.Message; + MessageBox.Show(errorMessage, "Authentication Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + Log("Failed to connect to " + pathToConnect + " using " + userDisplayName + ". Error: " + ex.Message); + } + catch (ManagementException ex) + { + var errorMessage = "Failed to connect to " + pathToConnect + " using " + userDisplayName + ". Error: " + ex.Message; + MessageBox.Show(errorMessage, "WMI Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + Log("Failed to connect to " + pathToConnect + " using " + userDisplayName + ". Error: " + ex.Message); + } + catch (COMException ex) + { + var errorMessage = "Failed to connect to " + pathToConnect + " using " + userDisplayName + ". Error: " + ex.Message; + MessageBox.Show(errorMessage, "Connection Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + Log("Failed to connect to " + pathToConnect + " using " + userDisplayName + ". Error: " + ex.Message); + } + catch (Exception ex) + { + var errorMessage = "Failed to connect to " + pathToConnect + " using " + userDisplayName + ". Error: " + ex.Message; + MessageBox.Show(errorMessage, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + Log("Failed to connect to " + pathToConnect + " using " + userDisplayName + ". Error: " + ex.Message); + } + } + + private void ConnectToSmsClient(SmsClient smsClient) + { + try + { + ManagementScope mScope = new ManagementScope(smsClient.SmsClientClassPath, smsClient.Connection); + ManagementClass smsClass = new ManagementClass(mScope, new ManagementPath(smsClient.SmsClientClassPath), new ObjectGetOptions()); + smsClass.Get(); + smsClient.SmsClientClass = smsClass; + smsClient.IsConnected = true; + } + catch (Exception ex) + { + var errorMessage = "Failed to connect to SMS Client. Error: " + ex.Message; + SetStatusBar2(errorMessage, MessageCategory.Error, true); + } + } + + private string CreateClassEnumQuery(string wqlFilter) + { + string queryString; + + if (String.IsNullOrEmpty(wqlFilter)) wqlFilter = "%"; + + if (wqlFilter == "%" && checkBoxSystem.Checked && checkBoxCIM.Checked && checkBoxPerf.Checked && checkBoxMSFT.Checked) + { + queryString = "SELECT * FROM meta_class"; + } + else + { + if (wqlFilter.StartsWith("!")) + { + wqlFilter = wqlFilter.Substring(1); + wqlFilter = String.Format("%{0}%", wqlFilter); + queryString = String.Format("SELECT * FROM meta_class WHERE NOT __Class LIKE \"{0}\"", wqlFilter); + } + else + { + wqlFilter = String.Format("%{0}%", wqlFilter); + queryString = String.Format("SELECT * FROM meta_class WHERE __Class LIKE \"{0}\"", wqlFilter); + } + } + + if (checkBoxSystem.Checked == false) + queryString += " AND NOT __Class LIKE \"[_][_]%\""; + + if (checkBoxCIM.Checked == false) + queryString += " AND NOT __Class LIKE \"CIM[_]%\""; + + if (checkBoxPerf.Checked == false) + queryString += " AND NOT __Class LIKE \"Win32_Perf%\""; + + if (checkBoxMSFT.Checked == false) + queryString += " AND NOT __Class LIKE \"MSFT[_]%\""; + + if (Settings.Default.EnumOptionsFlags.HasFlag(EnumOptions.ExcludeSmsCollections)) + queryString += " AND NOT __Class LIKE \"SMS_CM_RES_COLL_%\""; + + if (Settings.Default.EnumOptionsFlags.HasFlag(EnumOptions.ExcludeSmsInventory)) + { + queryString += " AND NOT __Class LIKE \"SMS_G_System%\""; + queryString += " AND NOT __Class LIKE \"SMS_GH_System%\""; + queryString += " AND NOT __Class LIKE \"SMS_GEH_System%\""; + } + + return queryString; + } + + private string CreateQueryForSelectedClass(WmiClass wmiClass) + { + return "SELECT * FROM " + wmiClass.DisplayName; + } + + private string CreateQueryForSelectedInstance(WmiInstance wmiInstance) + { + string queryString; + var instanceRelPath = wmiInstance.RelativePath; + + if (instanceRelPath.Contains("=@")) + { + queryString = "SELECT * FROM " + wmiInstance.Instance.Path.ClassName; + } + else if (instanceRelPath.Contains(".")) + { + var fromString = instanceRelPath.Substring(0, instanceRelPath.IndexOf(".", StringComparison.CurrentCultureIgnoreCase)); + var whereString = instanceRelPath.Substring(instanceRelPath.IndexOf(".", StringComparison.CurrentCultureIgnoreCase) + 1); + whereString = whereString.Replace("\"", "'"); + whereString = whereString.Replace(",", " AND "); + queryString = "SELECT * FROM " + fromString + " WHERE " + whereString; + } + else + { + queryString = "SELECT * FROM " + wmiInstance.Instance.Path.ClassName; + } + + return queryString; + } + + private void CreateSmsClientActionToolStripItem(SmsClientAction action, ToolStripMenuItem parentItem) + { + // Create tool strip menu item for the action + ToolStripMenuItem item = new ToolStripMenuItem(action.DisplayName, null, InitiateAction) + { + Tag = action + }; + + // Add action item to parent item if it belongs to default group + if (action.Group == "Default") + { + parentItem.DropDownItems.Add(item); + return; + } + + // Create tool strip menu item for the group + ToolStripMenuItem groupItem; + if (!parentItem.DropDownItems.ContainsKey(action.Group)) + { + // Create new group + groupItem = new ToolStripMenuItem(action.Group, null, null, action.Group); + parentItem.DropDownItems.Add(groupItem); + } + else + { + // Get existing group + groupItem = parentItem.DropDownItems[action.Group] as ToolStripMenuItem; + } + + // Add item to group + if (groupItem != null) groupItem.DropDownItems.Add(item); + } + + private TreeNode CreateTreeNodeFromWmiNode(WmiNode wmiNode) + { + TreeNode tn = new TreeNode + { + Name = wmiNode.WmiNamespace.Path, + Text = wmiNode.WmiNamespace.DisplayName, + Tag = wmiNode + }; + + return tn; + } + + private void EnumClassWorker_DoWork(TreeNode currentNode, string queryString) + { + WmiNode currentWmiNode = currentNode.Tag as WmiNode; + + // This should never happen, but check anyway. + if (currentWmiNode == null) + { + string message = "Failed to enumerate classes from " + currentNode.Text + ". ERROR: DoWork - Current WmiNode is null."; + NotifyNodeError(currentNode, message); + return; + } + + WmiNamespace currentNamespace = currentWmiNode.WmiNamespace; + ManagementScope scope = new ManagementScope(currentNamespace.Path, Helpers.GetRootNodeCredentials(currentNode)); + ObjectQuery query = new ObjectQuery(queryString); + + EnumerationOptions eOption = new EnumerationOptions + { + EnumerateDeep = true, + UseAmendedQualifiers = true + }; + + ManagementOperationObserver observer = new ManagementOperationObserver(); + ObserverHandler handler = new ObserverHandler(currentNamespace); + observer.ObjectReady += new ObjectReadyEventHandler(handler.NewObject); + observer.Completed += new CompletedEventHandler(handler.Done); + + ManagementObjectSearcher queryAllClasses = new ManagementObjectSearcher(scope, query, eOption); + queryAllClasses.Get(observer); + + while (!handler.IsComplete) + { + Thread.Sleep(100); + + // Check if cancellation is requested for the current Namespace + if (_bwClassEnumWorker.CancellationPending && currentNamespace.IsEnumerationCancelled) + { + observer.Cancel(); + return; + } + } + } + + private void EnumClassWorker_RunWorkerCompleted(RunWorkerCompletedEventArgs e, TreeNode currentNode) + { + WmiNode currentWmiNode = currentNode.Tag as WmiNode; + + // This should never happen, but check anyway. + if (currentWmiNode == null) + { + string message = "Failed to enumerate classes from " + currentNode.Text + ". ERROR: RunWorkerCompleted - Current WmiNode is null."; + NotifyNodeError(currentNode, message); + return; + } + + WmiNamespace currentNamespace = currentWmiNode.WmiNamespace; + + // Error occured + if (e.Error != null) + { + currentNamespace.IsEnumerating = false; + currentNamespace.EnumerationStatus = e.Error.Message; + string message = "Failed to enumerate classes from " + currentNamespace.DisplayName + ". ERROR: " + e.Error.Message; + NotifyNodeError(currentNode, message); + return; + } + + // No error and no cancellation + if (!e.Cancelled && e.Error == null) + { + // Get Cached Classes + var cachedItem = AppCache[currentNamespace.Path]; + + if (cachedItem != null) + { + // Get list of cached classes + List lc = (List)cachedItem; + + // If current node is still selected, populate classes. Else, just update the log + if (treeNamespaces.SelectedNode == currentNode) + { + PopulateListClasses(lc); + tabClasses.Text = "Classes (" + currentNamespace.ClassCount + ")"; + + if (currentNamespace.IsPartiallyEnumerated) + { + SetStatusBar1( + "Retrieved " + lc.Count + " classes from " + currentNamespace.DisplayName + + " before operation was cancelled.", MessageCategory.Warn); + SetStatusBar2("", MessageCategory.None); + } + else + { + SetStatusBar1( + "Retrieved " + lc.Count + " classes from " + currentNamespace.DisplayName + + " that match specified criteria.", MessageCategory.Info); + SetStatusBar2("", MessageCategory.None); + } + + SetStatusBar3("Enumerate Classes", currentNamespace.EnumTimeElapsed); + } + + // Log and update color without updating the Status bar + if (currentNamespace.IsPartiallyEnumerated) + { + Log("Retrieved " + lc.Count + " classes from " + currentNamespace.DisplayName + + " before operation was cancelled in " + currentNamespace.EnumTimeElapsed.TotalSeconds + " seconds"); + currentNode.BackColor = ColorCategory.Warn; + } + else + { + Log("Retrieved " + lc.Count + " classes from " + currentNamespace.DisplayName + + " that match specified criteria in " + currentNamespace.EnumTimeElapsed.TotalSeconds + " seconds"); + currentNode.BackColor = ColorCategory.Info; + } + } + else + { + // There's nothing in cache. Even for namespaces with 0 classes, CachedClasses still gets an entry, so we should never reach here + Log("Failed to enumerate classes. Error: No items found"); + } + } + } + + private void EnumerateChildNamespaces(TreeNode currentNode) + { + WmiNode currentWmiNode = currentNode.Tag as WmiNode; + + if (currentWmiNode == null) + { + SetStatusBar1("Unexpected Error. EnumerateChildNamespaces - Current WmiNode is null.", MessageCategory.Error, true); + SetStatusBar2("", MessageCategory.None); + return; + } + + // If current namespace is already expanded, do nothing and return + if (currentWmiNode.IsExpanded) + { + SetStatusBar1("Double click on namespace to enumerate classes...", MessageCategory.Info); + SetStatusBar2("", MessageCategory.Info); + return; + } + + // If Expansion Errored out previously, do nothing and return - Error is displayed in node's Tooltip + // TODO: Do we need to allow enumerating child namespaces again despite previous error? + if (currentWmiNode.ExpansionStatus != "NoError") return; + + Cursor = Cursors.WaitCursor; + + try + { + ManagementScope mScope = new ManagementScope(currentWmiNode.WmiNamespace.Path, Helpers.GetRootNodeCredentials(currentNode)); + + //mScope.Connect(); + + ObjectQuery query = new ObjectQuery("SELECT * FROM __Namespace"); + ManagementObjectSearcher namespaces = new ManagementObjectSearcher(mScope, query); + + // Get child namespaces, and add them to the selected node. + foreach (ManagementObject instance in namespaces.Get()) + { + WmiNode childWmiNode = new WmiNode(instance); + TreeNode tn = CreateTreeNodeFromWmiNode(childWmiNode); + currentNode.Nodes.Add(tn); + + // Set SmsClient if client namespace exists + if (childWmiNode.WmiNamespace.DisplayName.ToUpperInvariant() + .Equals("ROOT\\CCM", StringComparison.InvariantCultureIgnoreCase)) + { + currentWmiNode.SmsClient = new SmsClient(childWmiNode.WmiNamespace.Path, Helpers.GetRootNodeCredentials(currentNode)); + } + } + + currentWmiNode.IsExpanded = true; + currentNode.Expand(); + + SetStatusBar1("Enumerated " + currentNode.Nodes.Count + " child namespaces. Double click on namespace to enumerate classes...", + MessageCategory.Info); + + SetStatusBar2("", MessageCategory.Info); + } + catch (Exception ex) + { + currentWmiNode.ExpansionStatus = ex.Message; + currentNode.ToolTipText = ex.Message; + currentNode.BackColor = ColorCategory.Error; + SetStatusBar1("Failed to enumerate child namespaces for " + currentWmiNode.WmiNamespace.DisplayName + ". ERROR: " + ex.Message, MessageCategory.Error, true); + SetStatusBar2("", MessageCategory.Error); + } + finally + { + Cursor = Cursors.Default; + } + } + + private void EnumerateClasses() + { + // Get current node and namespace + TreeNode currentNode = treeNamespaces.SelectedNode; + WmiNode currentWmiNode = currentNode.Tag as WmiNode; + + // Check for NullReferenceException + if (currentWmiNode == null) + { + string message = "Failed to enumerate classes from " + currentNode.Text + ". EnumerateClasses - Current WmiNode is null."; + NotifyNodeError(currentNode, message); + return; + } + + WmiNamespace currentNamespace = currentWmiNode.WmiNamespace; + currentNode.BackColor = ColorCategory.Action; + + // Expand selected namespace's tree node, if it was already expanded. Collapse if it was already collapsed. + if (!currentNode.IsExpanded) + currentNode.Expand(); + else + currentNode.Collapse(); + + // Check if current namespace is already being enumerated + if (currentNamespace.IsEnumerating) + { + SetStatusBar1("Enumerating Classes from " + currentNamespace.DisplayName + ". Please wait before trying again...", MessageCategory.Action); + SetStatusBar2("", MessageCategory.None); + return; + } + + // Update status + SetStatusBar1("Enumerating Classes from " + currentNamespace.DisplayName, MessageCategory.Action); + SetStatusBar2("", MessageCategory.None); + + // Set Class Filter to %, if it's blank or * + if (textBoxClassFilter.Text == "" || textBoxClassFilter.Text == "*") + textBoxClassFilter.Text = "%"; + + textBoxClassQuickFilter.Text = String.Empty; + + if (radioModeAsync.Checked) + EnumerateClassesAsync(currentNode, currentNamespace); + else + EnumerateClassesSync(currentNode, currentNamespace); + } + + private void EnumerateClassesAsync(TreeNode currentNode, WmiNamespace currentNamespace) + { + try + { + string queryString = CreateClassEnumQuery(textBoxClassFilter.Text); + + _bwClassEnumWorker = new BackgroundWorker { WorkerSupportsCancellation = true }; + _bwClassEnumWorker.DoWork += (obj, e) => EnumClassWorker_DoWork(currentNode, queryString); + _bwClassEnumWorker.RunWorkerCompleted += (obj, e) => EnumClassWorker_RunWorkerCompleted(e, currentNode); + + // Start work + _bwClassEnumWorker.RunWorkerAsync(currentNode); + } + catch (Exception ex) + { + currentNamespace.IsEnumerating = false; + string message = "Failed to enumerate classes from " + currentNamespace.DisplayName + ". ERROR: " + ex.Message; + NotifyNodeError(currentNode, message); + } + } + + private void EnumerateClassesFromCache(WmiNamespace currentNamespace) + { + // Do nothing if current namespace is not enumerated + if (!currentNamespace.IsEnumerated) return; + + TreeNode currentNode = treeNamespaces.SelectedNode; + Stopwatch stopwatch = new Stopwatch(); + Cursor = Cursors.WaitCursor; + + try + { + // Get cached classes for current namespace + var cachedItem = AppCache[currentNamespace.Path]; + if (cachedItem != null) + { + // Get cached classes and add to list + List lc = (List)cachedItem; + PopulateListClasses(lc); + tabClasses.Text = "Classes (" + currentNamespace.ClassCount + ")"; + + if (currentNamespace.IsPartiallyEnumerated) + SetStatusBar1("Showing " + lc.Count + " cached classes (partial results) for " + currentNamespace.DisplayName + " from " + currentNamespace.EnumTime.ToString("HH:mm:ss"), + MessageCategory.Cache, true); + else + SetStatusBar1("Showing " + lc.Count + " cached classes for " + currentNamespace.DisplayName + " from " + currentNamespace.EnumTime.ToString("HH:mm:ss"), + MessageCategory.Cache, true); + } + else + { + currentNode.BackColor = ColorCategory.Warn; + SetStatusBar1("Cache Expired for " + currentNamespace.DisplayName + ". Double click namespace to enumerate classes.", + MessageCategory.Warn, true); + } + } + catch (Exception) + { + SetStatusBar1("Error retrieving Cached Classes for " + currentNamespace.DisplayName + ". Double click on Namespace to enumerate Classes", + MessageCategory.Warn); + Log("Error retrieving Cached Classes for " + currentNamespace.DisplayName); + } + finally + { + Cursor = Cursors.Default; + stopwatch.Stop(); + SetStatusBar3("Enumerate Cached Classes", stopwatch.Elapsed); + } + } + + private void EnumerateClassesSync(TreeNode currentNode, WmiNamespace currentNamespace) + { + Stopwatch stopwatch = new Stopwatch(); + stopwatch.Start(); + Cursor = Cursors.WaitCursor; + + try + { + string queryString = CreateClassEnumQuery(textBoxClassFilter.Text); + + ManagementScope scope = new ManagementScope(currentNamespace.Path, Helpers.GetRootNodeCredentials(currentNode)); + ObjectQuery query = new ObjectQuery(queryString); + + EnumerationOptions eOption = new EnumerationOptions + { + EnumerateDeep = true, + UseAmendedQualifiers = true + }; + + ManagementObjectSearcher queryAllClasses = new ManagementObjectSearcher(scope, query, eOption); + foreach (ManagementClass mClass in (from ManagementClass mClass in queryAllClasses.Get() + orderby mClass.Path.ClassName + select mClass)) + { + WmiClass wmiClass = new WmiClass(mClass); + ListViewItem li = new ListViewItem + { + Name = wmiClass.Path, + Text = wmiClass.DisplayName, + ToolTipText = wmiClass.Description, + Tag = wmiClass + }; + + // Add Lazy Properties, Description, and Path columns + li.SubItems.Add(wmiClass.HasLazyProperties.ToString()); + li.SubItems.Add(wmiClass.Description); + li.SubItems.Add(wmiClass.Path); + + currentNamespace.AddClass(li); + } + + // Mark current Namespace as Enumerated + currentNamespace.IsEnumerated = true; + currentNode.BackColor = ColorCategory.Info; + + // Populate list classes + PopulateListClasses(currentNamespace.Classes); + tabClasses.Text = "Classes (" + currentNamespace.Classes.Count + ")"; + SetStatusBar1( + "Retrieved " + currentNamespace.Classes.Count + " classes from " + currentNamespace.DisplayName + + " that match specified criteria.", MessageCategory.Info, true); + SetStatusBar2("", MessageCategory.None); + + // Add classes to cache + CacheItem ci = new CacheItem(currentNamespace.Path, currentNamespace.Classes); + AppCache.Set(ci, CachePolicy); + currentNamespace.ResetClasses(); + } + catch (Exception ex) + { + var message = "Failed to enumerate classes from " + currentNamespace.DisplayName + ". ERROR: " + ex.Message; + NotifyNodeError(currentNode, message); + } + finally + { + Cursor = Cursors.Default; + stopwatch.Stop(); + SetStatusBar3("Enumerate Classes", stopwatch.Elapsed); + currentNamespace.EnumTime = DateTime.Now; + currentNamespace.EnumTimeElapsed = stopwatch.Elapsed; + } + } + + private void EnumerateInstances() + { + TreeNode currentNode = treeNamespaces.SelectedNode; + WmiNode currentWmiNode = currentNode.Tag as WmiNode; + ListViewItem currentListViewItem = listClasses.SelectedItems[0]; + WmiClass currentClass = currentListViewItem.Tag as WmiClass; + + if (currentWmiNode == null || currentClass == null) + { + string message = "Failed to enumerate instances from " + currentListViewItem.Text + ". EnumerateInstances - Current Class is null."; + NotifyClassError(currentListViewItem, message); + return; + } + + // Check if current class is already being enumerated + if (currentClass.IsEnumerating) + { + SetStatusBar2("Enumerating Instances from " + currentClass.DisplayName + ". Please wait before trying again...", MessageCategory.Action); + return; + } + + // Update status + SetStatusBar2("Enumerating Instances from " + currentClass.DisplayName, MessageCategory.Action); + currentListViewItem.BackColor = ColorCategory.Action; + + // Set Instance Filter to blank, if it's * or % + //if (textBoxInstanceFilterQuick.Text == "*" || textBoxInstanceFilterQuick.Text == "%") + // textBoxInstanceFilterQuick.Text = String.Empty; + + // Reset instance filter for current Class + textBoxInstanceFilterQuick.Text = String.Empty; + + if (radioModeAsync.Checked) + EnumerateInstancesAsync(currentNode, currentClass, currentListViewItem); + else + EnumerateInstancesSync(currentClass, currentListViewItem); + } + + private void EnumerateInstancesAsync(TreeNode currentNode, WmiClass currentClass, ListViewItem currentListViewItem) + { + try + { + _bwInstanceEnumWorker = new BackgroundWorker { WorkerSupportsCancellation = true }; + _bwInstanceEnumWorker.DoWork += (obj, e) => EnumInstanceWorker_DoWork(currentNode, currentListViewItem); + _bwInstanceEnumWorker.RunWorkerCompleted += (obj, e) => EnumInstanceWorker_RunWorkerCompleted(e, currentListViewItem); + + _bwInstanceEnumWorker.RunWorkerAsync(); + } + catch (Exception ex) + { + string message = "Failed to enumerate instances from " + currentClass.DisplayName + ". ERROR: " + ex.Message; + currentListViewItem.BackColor = ColorCategory.Error; + //currentListViewItem.ToolTipText = message; + currentClass.IsEnumerating = false; + SetStatusBar2(message, MessageCategory.Error, true); + } + } + + private void EnumerateInstancesFromCache(WmiClass currentClass) + { + if (!currentClass.IsEnumerated) + { + SetStatusBar2("Double click on Class to enumerate Instances", MessageCategory.Info); + return; + } + + ListViewItem currentItem = listClasses.SelectedItems[0]; + Stopwatch stopwatch = new Stopwatch(); + Cursor = Cursors.WaitCursor; + + try + { + var cachedItem = AppCache[currentClass.Path]; + if (cachedItem != null) + { + // Get cached classes and add to list + List lc = (List)cachedItem; + PopulateListInstances(lc); + tabInstances.Text = "Instances (" + currentClass.InstanceCount + ")"; + + if (currentClass.IsPartiallyEnumerated) + SetStatusBar2( + "Showing " + lc.Count + " cached instances (partial results) for " + + currentClass.DisplayName + " from " + currentClass.EnumTime.ToString("HH:mm:ss"), + MessageCategory.Cache, true); + else + SetStatusBar2( + "Showing " + lc.Count + " cached instances for " + currentClass.DisplayName + " from " + + currentClass.EnumTime.ToString("HH:mm:ss"), + MessageCategory.Cache, true); + } + else + { + currentItem.BackColor = ColorCategory.Warn; + SetStatusBar2( + "Cache Expired for " + currentClass.DisplayName + + ". Double click on Class to enumerate Instances.", MessageCategory.Warn, true); + } + } + catch (Exception ex) + { + SetStatusBar2( + "Error retrieving Cached Instances for " + currentClass.DisplayName + + ". Double click on Namespace to enumerate Instances", MessageCategory.Warn); + Log("Error retrieving Cached Instances for " + currentClass.DisplayName + ". Error: " + ex.Message); + } + finally + { + Cursor = Cursors.Default; + stopwatch.Stop(); + SetStatusBar3("Enumerate Cached Instances", stopwatch.Elapsed); + } + } + + private void EnumerateInstancesSync(WmiClass currentClass, ListViewItem currentListViewItem) + { + // Start enumerating + Stopwatch stopwatch = new Stopwatch(); + stopwatch.Start(); + Cursor = Cursors.WaitCursor; + + try + { + ObjectGetOptions options = new ObjectGetOptions { UseAmendedQualifiers = false }; + EnumerationOptions eOption = new EnumerationOptions + { + EnumerateDeep = true, + UseAmendedQualifiers = false + }; + + ManagementPath mPath = new ManagementPath(currentClass.Path); + ManagementScope mScope = new ManagementScope(mPath, Helpers.GetRootNodeCredentials(treeNamespaces.SelectedNode)); + ManagementClass mClass = new ManagementClass(mScope, mPath, options); + + foreach (ManagementObject mInstance in (from ManagementObject mObject in mClass.GetInstances(eOption) + orderby mObject.Path.ClassName + select mObject)) + { + WmiInstance wmiInstance = new WmiInstance(mInstance); + ListViewItem li = new ListViewItem + { + Name = wmiInstance.Path, + Text = wmiInstance.RelativePath, + ToolTipText = wmiInstance.RelativePath, + Tag = wmiInstance + }; + + currentClass.AddInstance(li); + } + + // Mark current class as Enumerated + currentClass.IsEnumerated = true; + currentListViewItem.BackColor = ColorCategory.Info; + + // Populate list + PopulateListInstances(currentClass.Instances); + tabInstances.Text = "Instances (" + currentClass.Instances.Count + ")"; + SetStatusBar2( + "Retrieved " + currentClass.Instances.Count + " instances from " + currentClass.DisplayName, + MessageCategory.Info); + + // Add item to cache + CacheItem ci = new CacheItem(currentClass.Path, currentClass.Instances); + AppCache.Set(ci, CachePolicy); + currentClass.ResetInstances(); + } + catch (Exception ex) + { + string message = "Failed to enumerate instances from " + currentClass.DisplayName + ". ERROR: " + + ex.Message; + currentListViewItem.BackColor = ColorCategory.Error; + //currentListViewItem.ToolTipText = message; + SetStatusBar2(message, MessageCategory.Error, true); + } + finally + { + stopwatch.Stop(); + currentClass.EnumTime = DateTime.Now; + currentClass.EnumTimeElapsed = stopwatch.Elapsed; + Cursor = Cursors.Default; + SetStatusBar3("Enumerate Instances", currentClass.EnumTimeElapsed); + } + } + + private void EnumInstanceWorker_DoWork(TreeNode currentNode, ListViewItem currentListViewItem) + { + WmiNode currentWmiNode = currentNode.Tag as WmiNode; + WmiClass currentClass = currentListViewItem.Tag as WmiClass; + + // Check for NullReferenceException + if (currentClass == null || currentWmiNode == null) + { + string message = "Failed to enumerate instances from " + currentListViewItem.Text + ". DoWork - Current Node/Class is null."; + NotifyClassError(currentListViewItem, message); + return; + } + + ObjectGetOptions options = new ObjectGetOptions { UseAmendedQualifiers = false }; + EnumerationOptions eOption = new EnumerationOptions + { + EnumerateDeep = true, + UseAmendedQualifiers = false + }; + + ManagementPath mPath = new ManagementPath(currentClass.Path); + ManagementScope mScope = new ManagementScope(mPath, Helpers.GetRootNodeCredentials(currentNode)); + ManagementClass mClass = new ManagementClass(mScope, mPath, options); + + ManagementOperationObserver observer = new ManagementOperationObserver(); + ObserverHandler handler = new ObserverHandler(currentClass); + observer.ObjectReady += new ObjectReadyEventHandler(handler.NewObject); + observer.Completed += new CompletedEventHandler(handler.Done); + + mClass.GetInstances(observer, eOption); + + while (!handler.IsComplete) + { + Thread.Sleep(100); + + // Check if cancellation is requested for the current Class + if (_bwInstanceEnumWorker.CancellationPending && currentClass.IsEnumerationCancelled) + { + observer.Cancel(); + return; + } + } + } + + private void EnumInstanceWorker_RunWorkerCompleted(RunWorkerCompletedEventArgs e, ListViewItem currentListViewItem) + { + WmiClass currentClass = currentListViewItem.Tag as WmiClass; + + // Check for NullReferenceException + if (currentClass == null) + { + string message = "Failed to enumerate instances from " + currentListViewItem.Text + ". RunWorkerCompleted - Current Class is null."; + NotifyClassError(currentListViewItem, message); + return; + } + + // Error Occurred for Background Worker + if (e.Error != null) + { + currentClass.IsEnumerating = false; + currentClass.EnumerationStatus = e.Error.Message; + string message = "Failed to enumerate classes from " + currentClass.DisplayName + ". ERROR: " + e.Error.Message; + NotifyClassError(currentListViewItem, message); + return; + } + + // Get results + var cachedItem = AppCache[currentClass.Path]; + + if (cachedItem != null) + { + List lc = (List)cachedItem; + + // If current class is still selected, populate instances + if (listClasses.SelectedItems[0] == currentListViewItem) + { + PopulateListInstances(lc); + tabInstances.Text = "Instances (" + currentClass.InstanceCount + ")"; + + if (currentClass.IsPartiallyEnumerated) + { + SetStatusBar2( + "Retrieved " + lc.Count + " instances from " + currentClass.DisplayName + + " before operation was cancelled.", MessageCategory.Warn); + } + else + { + SetStatusBar2( + "Retrieved " + lc.Count + " instances from " + currentClass.DisplayName, + MessageCategory.Info); + } + + SetStatusBar3("Enumerate Instances", currentClass.EnumTimeElapsed); + } + + // Log and update color regardless of whether the current class is still selected + if (currentClass.IsPartiallyEnumerated) + { + Log("Retrieved " + lc.Count + " instances from " + currentClass.DisplayName + + " before operation was cancelled in " + currentClass.EnumTimeElapsed.TotalSeconds + " seconds"); + currentListViewItem.BackColor = ColorCategory.Warn; + } + else + { + Log("Retrieved " + lc.Count + " instances from " + currentClass.DisplayName + + " in " + currentClass.EnumTimeElapsed.TotalSeconds + " seconds"); + currentListViewItem.BackColor = ColorCategory.Info; + } + } + else + { + // There's nothing in cache. + Log("Failed to enumerate instances. Error: No items found in the Cache."); + } + } + + private void ExecuteQuery(string queryText) + { + TreeNode currentnode = treeNamespaces.SelectedNode; + + if (currentnode == null) + { + SetStatusBar2("Please select a namespace before running a query.", MessageCategory.Warn); + return; + } + + WmiNode currentWmiNode = treeNamespaces.SelectedNode.Tag as WmiNode; + if (currentWmiNode != null && currentWmiNode.IsRootNode && !currentWmiNode.IsConnected) + { + SetStatusBar1("Please connect to " + currentWmiNode.UserSpecifiedPath + " before attempting to run a query.", MessageCategory.Warn); + return; + } + + if (String.IsNullOrEmpty(queryText)) + { + SetStatusBar2("Invalid Query!", MessageCategory.Error); + return; + } + + Stopwatch stopwatch = new Stopwatch(); + stopwatch.Start(); + + // Set Status bar + SetStatusBar2("Executing query...", MessageCategory.Action); + Cursor = Cursors.WaitCursor; + + try + { + ManagementScope mScope = new ManagementScope(currentWmiNode.WmiNamespace.Path, Helpers.GetRootNodeCredentials(currentnode)); + ObjectQuery query = new ObjectQuery(queryText); + ManagementObjectSearcher queryResults = new ManagementObjectSearcher(mScope, query); + queryResults.Options.EnumerateDeep = true; + queryResults.Options.DirectRead = true; + + int i = 0; + + ResetListQueryResults(); + dataGridQueryResults.DataSource = null; + + listQueryResults.BeginUpdate(); + + DataTable dt = new DataTable(); + + foreach (ManagementObject instance in queryResults.Get()) + { + // Populate list + ListViewItem li = new ListViewItem(); + if (instance.Path.RelativePath == String.Empty) + { + li.Name = instance.GetPropertyValue("__CLASS").ToString(); + li.Text = "instance of " + instance.GetPropertyValue("__CLASS"); + li.ToolTipText = "instance of " + instance.GetPropertyValue("__CLASS"); + li.Tag = instance; + } + else + { + li.Name = instance.Path.Path; + li.Text = instance.Path.RelativePath; + li.ToolTipText = instance.Path.RelativePath; + li.Tag = instance; + } + + listQueryResults.Items.Add(li); + + // Populate Data Grid + DataRow dr = dt.NewRow(); + foreach (PropertyData p in instance.Properties) + { + // Add Column headers if this is the first row (i=0). + if (i == 0) + dt.Columns.Add(p.Name); + + // Add property values to each cell in the row. + if (p.Value == null) + dr[p.Name] = String.Empty; + else if (p.IsArray) + dr[p.Name] = p.Type + " []"; + else + dr[p.Name] = p.Value.ToString(); + } + + // Add row to the table, and increase counter. + dt.Rows.Add(dr); + i++; + } + + dataGridQueryResults.DataSource = dt; + dataGridQueryResults.AutoResizeColumns(); + + listQueryResults.Sorting = SortOrder.Ascending; + listQueryResults.Sort(); + listQueryResults.ResizeColumns(); + + SetStatusBar2("Successfully ran query, and retrieved " + i + " instances", MessageCategory.Info, true); + groupBoxQueryResults.Text = "Results (" + i + ")"; + } + catch (Exception ex) + { + SetStatusBar2("Error running query against " + treeNamespaces.SelectedNode.Text + " namespace. " + ex.Message, + MessageCategory.Error, true); + } + finally + { + listQueryResults.EndUpdate(); + Cursor = Cursors.Default; + stopwatch.Stop(); + SetStatusBar3("Execute Query", stopwatch.Elapsed); + } + } + + private void GeneratePsScript() + { + if (!radioScriptPs.Checked) return; + if (listClasses.SelectedItems.Count == 0) return; + + WmiClass wmiClass = listClasses.SelectedItems[0].Tag as WmiClass; + if (wmiClass == null) + { + SetStatusBar2("Failed to generate script. ERROR: GeneratePsScript - Current Class is null", MessageCategory.Error, true); + return; + } + + string className = wmiClass.DisplayName; + string namespaceName = wmiClass.Class.Path.NamespacePath; + + StringBuilder script = new StringBuilder(); + + script.Append("$computer = $env:COMPUTERNAME").AppendLine(); + script.Append("$namespace = \"" + namespaceName + "\"").AppendLine(); + script.Append("$classname = \"" + className + "\"").AppendLine(); + script.AppendLine(); + script.Append("Write-Output \"=====================================\"").AppendLine(); + script.Append("Write-Output \"COMPUTER : $computer \"").AppendLine(); + script.Append("Write-Output \"CLASS : $classname \"").AppendLine(); + script.Append("Write-Output \"=====================================\"").AppendLine(); + script.AppendLine(); + script.Append("Get-WmiObject -Class $classname -ComputerName $computer -Namespace $namespace |").AppendLine(); + script.Append(" Select-Object * -ExcludeProperty PSComputerName, Scope, Path, Options, ClassPath, Properties, SystemProperties, Qualifiers, Site, Container |").AppendLine(); + script.Append(" Format-List -Property [a-z]*").AppendLine(); + + textBoxScript.Text = script.ToString(); + } + + private void GenerateVbScript() + { + if (!radioScriptVbs.Checked) return; + if (listClasses.SelectedItems.Count == 0) return; + + WmiClass wmiClass = listClasses.SelectedItems[0].Tag as WmiClass; + if (wmiClass == null) + { + SetStatusBar2("Failed to generate script. ERROR: GenerateVbScript - Current Class is null", MessageCategory.Error, true); + return; + } + + string className = wmiClass.DisplayName; + string namespaceName = wmiClass.Class.Path.NamespacePath; + string queryText = "SELECT * FROM " + className; + + StringBuilder script = new StringBuilder(); + + script.Append("On Error Resume Next").AppendLine(); + script.AppendLine(); + + script.Append("Const wbemFlagReturnImmediately = &h10").AppendLine(); + script.Append("Const wbemFlagForwardOnly = &h20").AppendLine(); + script.AppendLine(); + + script.Append("Set wshNetwork = WScript.CreateObject(\"WScript.Network\")").AppendLine(); + script.Append("strComputer = wshNetwork.ComputerName").AppendLine(); + script.AppendLine(); + script.Append("strQuery = \"" + queryText + "\"").AppendLine(); + script.AppendLine(); + script.Append("WScript.StdOut.WriteLine \"\"").AppendLine(); + script.Append("WScript.StdOut.WriteLine \"=====================================\"").AppendLine(); + script.Append("WScript.StdOut.WriteLine \"COMPUTER : \" & strComputer").AppendLine(); + script.Append("WScript.StdOut.WriteLine \"CLASS : " + namespaceName + ":" + className + "\"").AppendLine(); + script.Append("WScript.StdOut.WriteLine \"QUERY : \" & strQuery").AppendLine(); + script.Append("WScript.StdOut.WriteLine \"=====================================\"").AppendLine(); + script.Append("WScript.StdOut.WriteLine \"\"").AppendLine(); + script.AppendLine(); + script.Append("Set objWMIService = GetObject(\"winmgmts:\\\\\" & strComputer & \"\\" + namespaceName + "\")").AppendLine(); + script.Append("Set colItems = objWMIService.ExecQuery(strQuery, \"WQL\", wbemFlagReturnImmediately + wbemFlagForwardOnly)").AppendLine(); + script.AppendLine(); + script.Append("For Each objItem in colItems").AppendLine(); + script.AppendLine(); + foreach (PropertyData property in wmiClass.Class.Properties) + { + if (property.IsArray) + { + script.Append(" str" + property.Name + " = Join(objItem." + property.Name + ", \",\")").AppendLine(); + script.Append(" WScript.StdOut.WriteLine \"" + property.Name + ": \" & str" + property.Name).AppendLine(); + } + else + { + script.Append(" WScript.StdOut.WriteLine \"" + property.Name + ": \" & objItem." + property.Name).AppendLine(); + } + } + + script.Append(" WScript.StdOut.WriteLine \"\"").AppendLine(); + script.AppendLine(); + script.Append("Next").AppendLine(); + + textBoxScript.Text = script.ToString(); + } + + private ToolStripMenuItem GetClientActionsContextMenuItem() + { + ToolStripMenuItem smsClientActionsMenuItem = new ToolStripMenuItem("SMS Client &Actions"); + + // Create tool strip item for each public static property of SmsClientAction Type + SmsClientActions smsClientActions = new SmsClientActions(); + foreach (var prop in smsClientActions.GetType() + .GetProperties(BindingFlags.Public | BindingFlags.Static) + .Where(prop => prop.PropertyType.Name == "SmsClientAction") + .OrderBy(prop => prop.Name)) + { + CreateSmsClientActionToolStripItem(prop.GetValue(null, null) as SmsClientAction, smsClientActionsMenuItem); + } + + smsClientActionsMenuItem.DropDownItems.SortToolStripItemCollection(); + + return smsClientActionsMenuItem; + } + + private ToolStripMenuItem GetMethodsContextMenuItem(bool returnStaticMethods) + { + ToolStripMenuItem executeMethods = new ToolStripMenuItem("Execute Method"); + + WmiClass wmiClass = listClasses.SelectedItems[0].Tag as WmiClass; + + foreach (MethodData method in wmiClass.Class.Methods) + { + bool methodStatic = false; + + foreach (QualifierData qualifier in method.Qualifiers) + { + if (qualifier.Name.Equals("Static", StringComparison.CurrentCultureIgnoreCase)) + { + methodStatic = true; + break; + } + } + + // Static Methods when right clicking on a class + if (methodStatic && returnStaticMethods) + { + ToolStripMenuItem item = new ToolStripMenuItem(method.Name, null, InvokeClassMethod); + item.Tag = method; + executeMethods.DropDownItems.Add(item); + } + + // Non static methods when right clicking on an instance + if (!methodStatic && !returnStaticMethods) + { + ToolStripMenuItem item = new ToolStripMenuItem(method.Name, null, InvokeInstanceMethod); + item.Tag = method; + executeMethods.DropDownItems.Add(item); + } + } + + executeMethods.DropDownItems.SortToolStripItemCollection(); + return executeMethods; + } + + private void GetPropertyHelp(PropertyData property, out bool enumAvailable, out string propertyHelp) + { + enumAvailable = false; + + StringBuilder helpBuilder = new StringBuilder(); + + string propDesc = String.Empty; + string propQualifiers = String.Empty; + object propEnum = null; + object propEnumMap = null; + bool enumBitMap = false; + + foreach (QualifierData qualifier in property.Qualifiers) + { + if (qualifier.Name.Equals("Description", StringComparison.CurrentCultureIgnoreCase)) + propDesc = qualifier.Value.ToString(); + + if (qualifier.Name.Equals("values", StringComparison.CurrentCultureIgnoreCase)) + propEnum = qualifier.Value; + + if (qualifier.Name.Equals("valuemap", StringComparison.CurrentCultureIgnoreCase)) + propEnumMap = qualifier.Value; + + if (qualifier.Name.Equals("bitvalues", StringComparison.CurrentCultureIgnoreCase)) + { + propEnum = qualifier.Value; + enumBitMap = true; + } + + if (qualifier.Name.Equals("bitmap", StringComparison.CurrentCultureIgnoreCase)) + propEnumMap = qualifier.Value; + + if (qualifier.Name.Equals("bits", StringComparison.CurrentCultureIgnoreCase)) + { + propEnum = qualifier.Value; + enumBitMap = true; + } + + if (qualifier.Name.Equals("enumeration", StringComparison.CurrentCultureIgnoreCase)) + propEnum = qualifier.Value; + + if (qualifier.Name.Equals("stringenumeration", StringComparison.CurrentCultureIgnoreCase)) + propEnum = qualifier.Value; + + propQualifiers += qualifier.Name + ", "; + } + + // Qualifiers + propQualifiers = propQualifiers.Substring(0, propQualifiers.Length - 2); + helpBuilder.AppendLine("\nQualifiers: " + propQualifiers); + + // Description + if (propDesc != String.Empty) + helpBuilder.AppendLine("\n" + propDesc); + else + helpBuilder.AppendLine("\n[Description Not Available]"); + + // Enumerations + if (propEnum != null) + { + enumAvailable = true; + helpBuilder.AppendLine(enumBitMap ? "\nPossible Bit Values: " : "\nPossible Enumeration Values: "); + + if (propEnum is String[]) + { + String[] tempPropEnum = propEnum as String[]; + + if (propEnumMap is String[]) + { + String[] tempPropEnumMap = propEnumMap as String[]; + + for (int i = 0; i < tempPropEnum.Length; i++) + { + //TODO: This could fail if the number of elements in Values and ValueMap qualifiers are not same. + if (tempPropEnumMap[i] == tempPropEnum[i]) + helpBuilder.AppendLine(tempPropEnum[i]); + else + { + if (enumBitMap) + helpBuilder.AppendLine("Bit " + tempPropEnumMap[i] + " - " + tempPropEnum[i]); + else + helpBuilder.AppendLine(tempPropEnumMap[i] + " - " + tempPropEnum[i]); + } + } + } + else if (propEnumMap is int[]) + { + int[] tempPropEnumMap = propEnumMap as int[]; + + for (int i = 0; i < tempPropEnum.Length; i++) + { + //TODO: This could fail if the number of elements in Values and ValueMap qualifiers are not same. + if (tempPropEnumMap[i].ToString() == tempPropEnum[i]) + helpBuilder.AppendLine(tempPropEnum[i]); + else + { + if (enumBitMap) + helpBuilder.AppendLine("Bit " + tempPropEnumMap[i] + " - " + tempPropEnum[i]); + else + helpBuilder.AppendLine(tempPropEnumMap[i] + " - " + tempPropEnum[i]); + } + } + } + else + { + foreach (string s in propEnum as String[]) + helpBuilder.AppendLine(s); + } + } + + if (propEnum is int[]) + { + foreach (int i in propEnum as int[]) + helpBuilder.AppendLine(i.ToString(CultureInfo.InvariantCulture)); + } + + if (propEnum is String) + { + foreach (string s in ((String)propEnum).Split(',')) + helpBuilder.AppendLine(s); + } + } + + propertyHelp = helpBuilder.ToString(); + } + + private string GetPropertyNameWithType(PropertyData property) + { + var propName = property.Name; + var propType = property.Type.ToString(); + bool propKey = false; + + foreach (QualifierData qualifier in property.Qualifiers) + { + if (qualifier.Name.Equals("key", StringComparison.CurrentCultureIgnoreCase)) + propKey = true; + } + + if (propKey) propName = "*" + propName; + if (property.IsArray) propType += " []"; + + // Display name + string propNameWithType = propName + " - " + propType; + + return propNameWithType; + } + + private void InitializeEnumOptions() + { + checkBoxSystem.Tag = EnumOptions.IncludeSystem; + checkBoxCIM.Tag = EnumOptions.IncludeCim; + checkBoxPerf.Tag = EnumOptions.IncludePerf; + checkBoxMSFT.Tag = EnumOptions.IncludeMsft; + checkNullProps.Tag = EnumOptions.ShowNullInstanceValues; + checkSystemProps.Tag = EnumOptions.ShowSystemProperties; + } + + private void InitializeForm() + { + // Start stopwatch to get Application load time + Stopwatch stopwatch = new Stopwatch(); + stopwatch.Start(); + + // Setup default connection options + _defaultConnection = new ConnectionOptions + { + EnablePrivileges = true, + Impersonation = ImpersonationLevel.Impersonate, + Authentication = AuthenticationLevel.Default, + Username = null, + SecurePassword = null + }; + + // Assign column sorter to listClasses, listClassProperties and listMethods + _listClassesColumnSorter = new ListViewColumnSorter { SortColumn = 0, Order = SortOrder.Ascending }; + _listClassPropertiesColumnSorter = new ListViewColumnSorter { SortColumn = 0, Order = SortOrder.Ascending }; + _listMethodsColumnSorter = new ListViewColumnSorter { SortColumn = 0, Order = SortOrder.Ascending }; + _listSearchResultsColumnSorter = new ListViewColumnSorter { SortColumn = 0, Order = SortOrder.Ascending }; + listClasses.ListViewItemSorter = _listClassesColumnSorter; + listClassProperties.ListViewItemSorter = _listClassPropertiesColumnSorter; + listMethods.ListViewItemSorter = _listMethodsColumnSorter; + listSearchResults.ListViewItemSorter = _listSearchResultsColumnSorter; + + // Check if Settings need to be updated on App Update + if (Settings.Default.bUpgradeSettings) + Utilities.UpdateSettings(); + + Log("CLR Version: " + Environment.Version); + + // Check .NET Version + // RTM build of .NET 4.5 = 4.0.30319.17929 + // RTM build of .NET 4.5 January 2013 Update= 4.0.30319.18033 + // RTM build of .NET 4.5.1 October 2013 Update= 4.0.30319.18408 + // RTM build of .NET 4.5.2 May 2014 Update = 4.0.30319.34209 + if (Environment.Version >= new Version(4, 0, 30319, 17929) && Environment.Version < new Version(4, 0, 30319, 18033)) + { + if (MessageBox.Show( + "You are running .NET 4.5 but .NET 4.5.1 is NOT installed. " + + "Please install .NET 4.5.1 to fix a known issue (Bad Layout in Query tab) in WMI Explorer.\n\n" + + "Would you like to download .NET 4.5.1 now ?", + "WMI Explorer - Known Issue Detected", + MessageBoxButtons.YesNo, + MessageBoxIcon.Exclamation + ) == DialogResult.Yes) + { + Process.Start("http://msdn.microsoft.com/en-us/library/5a4x27ek(v=vs.110).aspx"); + Close(); + } + } + + // Initialize Form UI + InitializeFormUi(); + + // Check for update if Update check is enabled. Make sure this is called after InitializeFormUi() + _changeLogPath = Environment.GetEnvironmentVariable("TEMP") + "\\WmieChangelog.TXT"; + if (Settings.Default.bCheckForUpdates) + UpdateCheck(); + + // Set Cache Policy + CachePolicy.SlidingExpiration = TimeSpan.FromMinutes(Convert.ToDouble(Settings.Default.CacheAgeInMinutes)); + + stopwatch.Stop(); + Log("Application Load Time = " + stopwatch.Elapsed); + } + + private void InitializeFormUi() + { + // Resize Query layout based on current DPI settings + Graphics g = this.CreateGraphics(); + DisplayDpi = Convert.ToInt32(g.DpiX); + if (DisplayDpi > 96) + { + splitContainerQuery.SplitterDistance += (DisplayDpi - 96); + splitContainerQuery.Panel1MinSize = splitContainerQuery.SplitterDistance; + } + + // Log current display DPI setting + Log("Display DPI Settings: " + DisplayDpi.ToString(CultureInfo.InvariantCulture) + "dpi"); + +#if DEBUG + Text = "WMI Explorer (Beta Debug Build)"; +#endif + + // Check if we're running Elevated + if (Utilities.CheckIfElevated()) + Text += " (Administrator)"; + + // Remove Debug tabs + tabControlClasses.Controls.Remove(tabDebug1); + tabControlInstances.Controls.Remove(tabDebug2); + + // Set all Status Labels to blank strings + toolStripLabel1.Text = String.Empty; + toolStripLabel2.Text = String.Empty; + toolStripLabel3.Text = String.Empty; + toolStripLabelUpdateNotification.Text = String.Empty; + + // Restore Window Placement + if (Settings.Default.bPreserveLayout) + { + WindowPlacement.SetPlacement(this.Handle, Settings.Default.WindowPlacement); + splitContainerNamespaceClasses.SplitterDistance = Settings.Default.SplitterDistanceNamespaces; + splitContainerClassesInstances.SplitterDistance = Settings.Default.SplitterDistanceClasses; + splitContainerInstancesProperties.SplitterDistance = Settings.Default.SplitterDistanceInstances; + } + + // Load Recent Paths if RememberRecentPaths is set to true + if (Settings.Default.bRememberRecentPaths) + LoadRecentPaths(); + + // Initialize EnumOptions for enumeration checkboxes + InitializeEnumOptions(); + + // Populate enumeration mode and options + if (Settings.Default.bRememberEnumOptions) + { + // Select checkboxes + PopulateEnumCheckboxes(); + + // Set Enum Mode + if (Settings.Default.bEnumModeAsync) + radioModeAsync.Checked = true; + else + radioModeSync.Checked = true; + } + else + radioModeAsync.Checked = true; + + // SMS Mode + menuItemFile_SmsMode.Checked = Settings.Default.bSmsMode; + + // Hide list view and show datagrid view for query results + splitContainerQueryResults.Visible = radioQueryOutListView.Checked; + dataGridQueryResults = new DataGridView + { + Parent = groupBoxQueryResults, + Dock = DockStyle.Fill, + Visible = radioQueryOutDataGrid.Checked + }; + + // Resize property grid description area to 6 lines + ResizePropertyGridDescription(propertyGridInstance, 6); + } + + private void InitiateAction(object sender, EventArgs e) + { + TreeNode currentNode = treeNamespaces.SelectedNode; + SmsClient smsClient = Helpers.GetSmsClient(currentNode); + var actionItem = (ToolStripMenuItem)sender; + SmsClientAction action = actionItem.Tag as SmsClientAction; + + if (action != null) + { + try + { + ManagementBaseObject inParams = smsClient.SmsClientClass.GetMethodParameters("TriggerSchedule"); + inParams["sScheduleId"] = action.Id; + ManagementBaseObject outParams = smsClient.SmsClientClass.InvokeMethod("TriggerSchedule", inParams, null); + + if (outParams != null) + { + SetStatusBar2("Successfully triggered " + action.DisplayName + " action.", MessageCategory.Sms, true); + //MessageBox.Show("Successfully triggered " + action.DisplayName + ".", + // "Initiate Client Action", + // MessageBoxButtons.OK, + // MessageBoxIcon.Information); + } + } + catch (Exception ex) + { + SetStatusBar2("Failed to trigger " + action.DisplayName + " action. Error: " + ex.Message, MessageCategory.Error, true); + //MessageBox.Show("Failed to trigger " + action.DisplayName + ". Error: " + ex.Message, + // "Initiate Client Action", + // MessageBoxButtons.OK, + // MessageBoxIcon.Error); + } + } + } + + private void InvokeClassMethod(object sender, EventArgs e) + { + ManagementClass mClass = (listClasses.SelectedItems[0].Tag as WmiClass).Class; + MethodData method = ((ToolStripMenuItem)sender).Tag as MethodData; + + Form_ExecMethod execMethodForm = new Form_ExecMethod(mClass, method); + execMethodForm.CenterForm(this).Show(this); + } + + private void InvokeInstanceMethod(object sender, EventArgs e) + { + ManagementObject mObject = (listInstances.SelectedItems[0].Tag as WmiInstance).Instance; + MethodData method = ((ToolStripMenuItem)sender).Tag as MethodData; + + Form_ExecMethod execMethodForm = new Form_ExecMethod(mObject, method); + execMethodForm.CenterForm(this).Show(this); + } + + private void LoadRecentPaths() + { + // Initialize RecentPaths if it's null + if (Settings.Default.RecentPaths == null) + Settings.Default.RecentPaths = new StringCollection(); + + // Populate nodes as Disconnected + foreach (var path in Settings.Default.RecentPaths) + { + WmiNode wmiNode = new WmiNode { IsRootNode = true, UserSpecifiedPath = path }; + wmiNode.SetConnection(_defaultConnection); + + TreeNode treeNode = new TreeNode + { + Name = wmiNode.UserSpecifiedPath, + Text = wmiNode.UserSpecifiedPath + " (Disconnected)", + Tag = wmiNode + }; + + treeNamespaces.Nodes.Add(treeNode); + } + } + + private void LogSettings() + { + textBoxLogging.Text += "\r\n"; + Log("Application Settings:\r\n" + Utilities.GetSettings()); + } + + private void NotifyClassError(ListViewItem currentListViewItem, string message) + { + currentListViewItem.BackColor = ColorCategory.Error; + SetStatusBar2(message, MessageCategory.Error, true); + } + + private void NotifyNodeError(TreeNode treeNode, string message) + { + treeNode.BackColor = ColorCategory.Error; + treeNode.ToolTipText = message; + SetStatusBar1(message, MessageCategory.Error, true); + SetStatusBar2(String.Empty, MessageCategory.Error); + } + + private void PopulateClassProperties(WmiClass wmiClass) + { + ResetListClassProperties(); + listClassProperties.BeginUpdate(); + + string superClass = String.Empty; + if (wmiClass.Class.Derivation != null) + { + foreach (String cls in wmiClass.Class.Derivation) + { + superClass += cls + ", "; + } + } + + if (superClass != String.Empty) + { + superClass = superClass.Substring(0, superClass.Length - 2); + AppendClassHelp("\n" + wmiClass.DisplayName + " Class : " + superClass, FontStyle.Bold); + } + else + AppendClassHelp("\n" + wmiClass.DisplayName + " Class", FontStyle.Bold); + + string classDesc = listClasses.SelectedItems[0].SubItems[2].Text; + + if (String.IsNullOrEmpty(classDesc)) + AppendClassHelp("\n[Class Description Not Available]"); + else + AppendClassHelp("\n" + classDesc); + + //AppendClassHelp("\nSyntax:", FontStyle.Bold); + //AppendClassHelp("\n" + wmiClass.GetClassMof()); + + AppendClassHelp("\nClass Qualifiers:\n", FontStyle.Bold); + + foreach (QualifierData qualifier in wmiClass.Class.Qualifiers) + { + if (qualifier.Name.Equals("Description", StringComparison.CurrentCultureIgnoreCase)) + AppendClassHelp(qualifier.Name); + else + AppendClassHelp(qualifier.Name + " - " + qualifier.Value); + } + + AppendClassHelp("\nProperties:", FontStyle.Bold); + + if (wmiClass.Class.Properties.Count > 0) + { + foreach (PropertyData property in wmiClass.Class.Properties) + { + string propName = property.Name; + string propDesc = String.Empty; + bool propLazy = false; + string propType = property.Type.ToString(); + if (property.IsArray) propType += " []"; + + foreach (QualifierData qualifier in property.Qualifiers) + { + if (qualifier.Name.Equals("Description", StringComparison.CurrentCultureIgnoreCase)) + propDesc = qualifier.Value.ToString(); + + if (qualifier.Name.Equals("lazy", StringComparison.CurrentCultureIgnoreCase)) + propLazy = true; + } + + AppendClassHelp("\n" + GetPropertyNameWithType(property), FontStyle.Italic); + + bool propEnumAvailable; + string propHelp; + GetPropertyHelp(property, out propEnumAvailable, out propHelp); + + AppendClassHelp(propHelp); + + // Add to list + ListViewItem listItem = new ListViewItem + { + Name = propName, + Text = propName, + ToolTipText = propDesc, + Tag = property + }; + listItem.SubItems.Add(propType); + listItem.SubItems.Add(propEnumAvailable.ToString()); + listItem.SubItems.Add(propLazy.ToString()); + listItem.SubItems.Add(propDesc); + + listClassProperties.Items.Add(listItem); + } + } + else + AppendClassHelp("\nThis class has no Properties."); + + listClassProperties.Sorting = SortOrder.Ascending; + listClassProperties.Sort(); + listClassProperties.ResizeColumns(); + listClassProperties.SetSortIcon(_listClassPropertiesColumnSorter.SortColumn, _listClassPropertiesColumnSorter.Order); + listClassProperties.EndUpdate(); + + AppendClassHelp("\nSearch Online Documentation:", FontStyle.Bold); + AppendClassHelp("http://www.bing.com/search?q=" + wmiClass.DisplayName + "+WMI+Class", FontStyle.Regular, true, false); + + //AppendClassHelp("\nStandard WMI Qualifiers:", FontStyle.Bold); + //AppendClassHelp("http://msdn.microsoft.com/en-us/library/aa393650(v=vs.85).aspx", FontStyle.Regular, true, false); + + tabProperties.Text = "Properties (" + wmiClass.Class.Properties.Count + ")"; + } + + private void PopulateEnumCheckboxes() + { + EnumOptions flags = Settings.Default.EnumOptionsFlags; + + if (flags == EnumOptions.None) + return; + + if (flags.HasFlag(EnumOptions.IncludeSystem)) + checkBoxSystem.Checked = true; + + if (flags.HasFlag(EnumOptions.IncludeCim)) + checkBoxCIM.Checked = true; + + if (flags.HasFlag(EnumOptions.IncludePerf)) + checkBoxPerf.Checked = true; + + if (flags.HasFlag(EnumOptions.IncludeMsft)) + checkBoxMSFT.Checked = true; + + if (flags.HasFlag(EnumOptions.ShowNullInstanceValues)) + checkNullProps.Checked = true; + + if (flags.HasFlag(EnumOptions.ShowSystemProperties)) + checkSystemProps.Checked = true; + } + + private void PopulateInstanceProperties(ListViewItem currentListViewItem, bool refreshObject = false) + { + WmiInstance wmiInstance = currentListViewItem.Tag as WmiInstance; + if (wmiInstance == null) + { + currentListViewItem.BackColor = ColorCategory.Error; + const string message = "Failed to display Properties for selected instance. PopulateInstanceProperties - Current Instance is null."; + SetStatusBar2(message, MessageCategory.Error, true); + return; + } + + try + { + ManagementBaseObjectW mObjectW; + + if (refreshObject) + { + ManagementObject mObject = new ManagementObject(wmiInstance.Path); + mObjectW = new ManagementBaseObjectW(mObject) + { + IncludeNullProperties = checkNullProps.Checked, + IncludeSystemProperties = checkSystemProps.Checked + }; + } + else + { + mObjectW = new ManagementBaseObjectW(wmiInstance.Instance) + { + IncludeNullProperties = checkNullProps.Checked, + IncludeSystemProperties = checkSystemProps.Checked + }; + } + + // Some objects don't allow refreshing. Call GetText to see if we get an error, and set the Mof to be used for Show/Copy MOF + _instanceMof = mObjectW.GetText(TextFormat.Mof).Replace("\n", "\r\n"); + + propertyGridInstance.SelectedObject = mObjectW; + currentListViewItem.BackColor = ColorCategory.Info; + } + catch (Exception ex) + { + string message = String.Format("Failed to {0}. Error: {1}", refreshObject ? "Refresh Object" : "Populate Instance Properties", ex.Message); + if (!refreshObject) currentListViewItem.BackColor = ColorCategory.Error; + SetStatusBar2(message, MessageCategory.Error); + } + } + + private void PopulateListClasses(List items, string filterText = "", bool notFilter = false) + { + ResetListClasses(); + listClasses.BeginUpdate(); + + if (String.IsNullOrEmpty(filterText)) + { + listClasses.Items.AddRange(items.ToArray()); + } + else + { + foreach (ListViewItem l in items) + { + if (notFilter && !l.Text.ToLower().Contains(filterText)) + listClasses.Items.Add(l); + + if (!notFilter & l.Text.ToLower().Contains(filterText)) + listClasses.Items.Add(l); + } + } + + listClasses.Sort(); + listClasses.SetSortIcon(_listClassesColumnSorter.SortColumn, _listClassesColumnSorter.Order); + listClasses.EndUpdate(); + + // Ensure previously selected item is visible in the list by scrolling to it. + if (listClasses.SelectedItems.Count > 0) + listClasses.EnsureVisible(listClasses.SelectedItems[0].Index); + } + + private void PopulateListInstances(List items, string filterText = "", bool notFilter = false) + { + ResetListInstances(); + listInstances.BeginUpdate(); + + if (String.IsNullOrEmpty(filterText)) + { + listInstances.Items.AddRange(items.ToArray()); + } + else + { + foreach (ListViewItem l in items) + { + if (notFilter && !l.Text.ToLower().Contains(filterText)) + listInstances.Items.Add(l); + + if (!notFilter && l.Text.ToLower().Contains(filterText)) + listInstances.Items.Add(l); + } + } + + listInstances.Sorting = SortOrder.Ascending; + listInstances.Sort(); + listInstances.ResizeColumns(); + listInstances.EndUpdate(); + + // Ensure previously selected item is visible in the list by scrolling to it. + if (listInstances.SelectedItems.Count > 0) + listInstances.EnsureVisible(listInstances.SelectedItems[0].Index); + } + + private void PopulateMethodHelp(MethodData methodData) + { + ResetListMethodParams(); + + AppendMethodHelp("\n" + methodData.Name + " method of the " + methodData.Origin + " class", FontStyle.Bold); + string methodDesc = listMethods.SelectedItems[0].SubItems[2].Text; + + if (String.IsNullOrEmpty(methodDesc)) + AppendMethodHelp("\n[Method Description Not Available]"); + else + AppendMethodHelp("\n" + methodDesc); + + AppendMethodHelp("\nExecution:\n", FontStyle.Bold); + + string methodStatic = listMethods.SelectedItems[0].SubItems[1].Text; + + AppendMethodHelp( + methodStatic.Equals("True", StringComparison.CurrentCultureIgnoreCase) + ? "This method is static, which means you can use this method without creating an instance of this class. To execute this method, right click on the Class." + : "This method is not static, which means you need an instance of this class to execute this method. To execute this method, right click on the Instance."); + + // Method In Params + AppendMethodHelp("\nInput Parameters:", FontStyle.Bold); + + if (methodData.InParameters != null) + { + if (methodData.InParameters.Properties.Count == 0) + AppendMethodHelp("\nThis method has no Input parameters."); + + foreach (PropertyData inParam in methodData.InParameters.Properties) + { + string paramId = String.Empty; + string paramDesc = String.Empty; + string paramType = String.Empty; + bool paramOptional = false; + + foreach (QualifierData qualifier in inParam.Qualifiers) + { + if (qualifier.Name.Equals("ID", StringComparison.CurrentCultureIgnoreCase)) + paramId = qualifier.Value.ToString(); + + if (qualifier.Name.Equals("CIMTYPE", StringComparison.CurrentCultureIgnoreCase)) + paramType = qualifier.Value.ToString(); + + if (qualifier.Name.Equals("Description", StringComparison.CurrentCultureIgnoreCase)) + paramDesc = qualifier.Value.ToString(); + + if (qualifier.Name.Equals("Optional", StringComparison.CurrentCultureIgnoreCase)) + paramOptional = true; + } + + if (inParam.IsArray) paramType += " []"; + + string paramDisplayName = inParam.Name + " - " + paramType; + if (paramOptional) paramDisplayName = "(Optional) " + paramDisplayName; + + AppendMethodHelp("\n" + paramDisplayName, FontStyle.Italic); + + bool enumAvailable = false; + string propHelp = String.Empty; + GetPropertyHelp(inParam, out enumAvailable, out propHelp); + AppendMethodHelp(propHelp); + + ListViewItem listItem = new ListViewItem + { + Name = paramId, + Text = paramId, + ToolTipText = paramDesc, + Tag = inParam + }; + + listItem.SubItems.Add(inParam.Name); + listItem.SubItems.Add(paramType); + listItem.SubItems.Add(paramDesc); + + listMethodParamsIn.Items.Add(listItem); + } + } + else + { + AppendMethodHelp("\nThis method has no Input parameters."); + } + + // Method Out Params + AppendMethodHelp("\nOutput Parameters:", FontStyle.Bold); + + if (methodData.OutParameters != null) + { + if (methodData.OutParameters.Properties.Count == 0) + AppendMethodHelp("\nThis method has no Output parameters."); + + foreach (PropertyData outParam in methodData.OutParameters.Properties) + { + string paramDesc = String.Empty; + string paramType = String.Empty; + bool paramOptional = false; + + foreach (QualifierData qualifier in outParam.Qualifiers) + { + if (qualifier.Name.Equals("CIMTYPE", StringComparison.CurrentCultureIgnoreCase)) + paramType = qualifier.Value.ToString(); + + if (qualifier.Name.Equals("Description", StringComparison.CurrentCultureIgnoreCase)) + paramDesc = qualifier.Value.ToString(); + + if (qualifier.Name.Equals("Optional", StringComparison.CurrentCultureIgnoreCase)) + paramOptional = true; + } + + if (outParam.IsArray) paramType += " []"; + + string paramDisplayName = outParam.Name + " - " + paramType; + if (paramOptional) paramDisplayName = "(Optional) " + paramDisplayName; + + AppendMethodHelp("\n" + paramDisplayName, FontStyle.Italic); + + bool enumAvailable = false; + string propHelp = String.Empty; + GetPropertyHelp(outParam, out enumAvailable, out propHelp); + AppendMethodHelp(propHelp); + + ListViewItem listItem = new ListViewItem + { + Name = outParam.Name, + Text = outParam.Name, + ToolTipText = paramDesc, + Tag = outParam + }; + + listItem.SubItems.Add(paramType); + listItem.SubItems.Add(paramDesc); + + listMethodParamsOut.Items.Add(listItem); + } + } + else + { + AppendMethodHelp("\nThis method has no Output parameters."); + } + + // Sort and Resize Columns for In Params + listMethodParamsIn.Sorting = SortOrder.Ascending; + listMethodParamsIn.Sort(); + listMethodParamsIn.ResizeColumns(); + + // Sort and Resize Columns for Out Params + listMethodParamsOut.Sorting = SortOrder.Ascending; + listMethodParamsOut.Sort(); + listMethodParamsOut.ResizeColumns(); + + AppendMethodHelp("\nSearch Online Documentation:", FontStyle.Bold); + AppendMethodHelp("http://www.bing.com/search?q=" + methodData.Name + "+Method+of+the+" + methodData.Origin + "+Class", FontStyle.Regular, true, false); + } + + private void PopulateMethods(WmiClass wmiClass) + { + ResetListMethods(); + + var cachedItem = AppCache[wmiClass.Path + "_Methods"]; + if (cachedItem != null) + { + // Get cached methods and add to list + ListViewItem[] lc = (ListViewItem[])cachedItem; + listMethods.Items.AddRange(lc); + tabMethods.Text = "Methods (" + wmiClass.Class.Methods.Count + ")"; + } + else + { + foreach (MethodData method in wmiClass.Class.Methods) + { + string methodDesc = String.Empty; + bool methodStatic = false; + + foreach (QualifierData qualifier in method.Qualifiers) + { + if (qualifier.Name.Equals("Static", StringComparison.CurrentCultureIgnoreCase)) + methodStatic = true; + + if (qualifier.Name.Equals("Description", StringComparison.CurrentCultureIgnoreCase)) + methodDesc = qualifier.Value.ToString(); + } + + ListViewItem li = new ListViewItem + { + Name = method.Name, + Text = method.Name, + ToolTipText = methodDesc, + Tag = method + }; + li.SubItems.Add(methodStatic.ToString()); + li.SubItems.Add(methodDesc); + + listMethods.Items.Add(li); + } + + // Add to cache + ListViewItem[] methods = new ListViewItem[listMethods.Items.Count]; + listMethods.Items.CopyTo(methods, 0); + CacheItem cacheItem = new CacheItem(wmiClass.Path + "_Methods", methods); + AppCache.Set(cacheItem, CachePolicy); + } + + listMethods.Sorting = SortOrder.Ascending; + listMethods.Sort(); + listMethods.ResizeColumns(); + listMethods.SetSortIcon(_listMethodsColumnSorter.SortColumn, _listMethodsColumnSorter.Order); + tabMethods.Text = "Methods (" + wmiClass.Class.Methods.Count + ")"; + } + + private void RenameClassTabsToDefault() + { + tabInstances.Text = "Instances"; + tabProperties.Text = "Properties"; + tabMethods.Text = "Methods"; + textBoxInstanceFilterQuick.Text = String.Empty; + } + + private void RenameNamespaceTabsToDefault() + { + tabClasses.Text = "Classes"; + RenameClassTabsToDefault(); + } + + private void ResetListClasses() + { + // Clear list view and add columns. + listClasses.Clear(); + listClasses.Columns.Add("Name", 150, HorizontalAlignment.Left); + listClasses.Columns.Add("Lazy Properties", 50, HorizontalAlignment.Left); + listClasses.Columns.Add("Description", 150, HorizontalAlignment.Left); + listClasses.Columns.Add("Path", 150, HorizontalAlignment.Left); + } + + private void ResetListClassProperties() + { + listClassProperties.Clear(); + listClassProperties.Columns.Add("Property Name", -2, HorizontalAlignment.Left); + listClassProperties.Columns.Add("Type", -2, HorizontalAlignment.Left); + listClassProperties.Columns.Add("Enumeration Available", -2, HorizontalAlignment.Left); + listClassProperties.Columns.Add("Lazy", -2, HorizontalAlignment.Left); + listClassProperties.Columns.Add("Description", -2, HorizontalAlignment.Left); + listClassProperties.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize); + + richTextBoxClassDetails.Clear(); + } + + private void ResetListInstances() + { + listInstances.Clear(); + listInstances.Columns.Add("Instances", -2, HorizontalAlignment.Left); + } + + private void ResetListMethodParams() + { + // Clear In Params + listMethodParamsIn.Clear(); + listMethodParamsIn.Columns.Add("ID", -2, HorizontalAlignment.Left); + listMethodParamsIn.Columns.Add("Name", -2, HorizontalAlignment.Left); + listMethodParamsIn.Columns.Add("Type", -2, HorizontalAlignment.Left); + listMethodParamsIn.Columns.Add("Description", -2, HorizontalAlignment.Left); + listMethodParamsIn.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize); + + // Clear Out Params + listMethodParamsOut.Clear(); + listMethodParamsOut.Columns.Add("Name", -2, HorizontalAlignment.Left); + listMethodParamsOut.Columns.Add("Type", -2, HorizontalAlignment.Left); + listMethodParamsOut.Columns.Add("Description", -2, HorizontalAlignment.Left); + listMethodParamsOut.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize); + + // Clear Help Text + richTextBoxMethodDetails.Clear(); + } + + private void ResetListMethods() + { + listMethods.Clear(); + listMethods.Columns.Add("Method Name", -2, HorizontalAlignment.Left); + listMethods.Columns.Add("Static", -2, HorizontalAlignment.Left); + listMethods.Columns.Add("Description", -2, HorizontalAlignment.Left); + listMethods.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize); + + ResetListMethodParams(); + richTextBoxMethodDetails.Clear(); + } + + private void ResetListQueryResults() + { + listQueryResults.Clear(); + listQueryResults.Columns.Add("Results", 150, HorizontalAlignment.Left); + groupBoxQueryResults.Text = "Results"; + } + + private void ResizePropertyGridDescription(PropertyGrid grid, int lines) + { + try + { + var info = grid.GetType().GetProperty("Controls"); + var collection = (Control.ControlCollection)info.GetValue(grid, null); + + foreach (var control in collection) + { + var type = control.GetType(); + + if ("DocComment" == type.Name) + { + const BindingFlags Flags = BindingFlags.Instance | BindingFlags.NonPublic; + var field = type.BaseType.GetField("userSized", Flags); + field.SetValue(control, true); + + info = type.GetProperty("Lines"); + info.SetValue(control, lines, null); + + grid.HelpVisible = true; + break; + } + } + } + + catch (Exception ex) + { + Log("Error resizing Property Description: " + ex.Message); + } + } + + private void SearchClasses(string searchPattern, WmiNode currentWmiNode) + { + string sNamespace = currentWmiNode.WmiNamespace.Path; + ConnectionOptions connection = Helpers.GetRootNodeCredentials(treeNamespaces.SelectedNode); + bool bRecurse = checkBoxSearchRecurse.Checked; + + // Clear list view + listSearchResults.Clear(); + listSearchResults.Columns.Add("Class Name", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Lazy Properties", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Path", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Description", -2, HorizontalAlignment.Left); + + Stopwatch stopwatch = new Stopwatch(); + stopwatch.Start(); + + Cursor = Cursors.WaitCursor; + SetStatusBar2("Searching classes in " + sNamespace + " that match search pattern: " + searchPattern, MessageCategory.Action, true); + + listSearchResults.BeginUpdate(); + + string queryString = CreateClassEnumQuery(searchPattern); + SearchClassesRecurse(sNamespace, queryString, bRecurse, connection); + + listSearchResults.Sorting = SortOrder.Ascending; + listSearchResults.Sort(); + listSearchResults.ResizeColumns(); + listSearchResults.SetSortIcon(_listSearchResultsColumnSorter.SortColumn, _listSearchResultsColumnSorter.Order); + listSearchResults.EndUpdate(); + + Cursor = Cursors.Default; + stopwatch.Stop(); + SetStatusBar3("Search Classes", stopwatch.Elapsed); + + if (!_searchErrorOccurred) + { + SetStatusBar2("Search completed successfully and found " + _searchResultCount + " results.", MessageCategory.Info); + } + else + { + SetStatusBar2("Search completed with errors and found " + _searchResultCount + " results.", MessageCategory.Warn); + } + } + + private void SearchClassesRecurse(string sNamespace, string queryString, bool bRecurse, ConnectionOptions connection) + { + // Skip root\directory\ldap namespace from search + if (sNamespace.ToLower().Contains("root\\directory\\ldap")) + { + Log("Skipping ROOT\\directory\\LDAP namespace as it can take a very long time"); + return; + } + + SetStatusBar2("Searching classes in " + sNamespace + "...", MessageCategory.Action); + + try + { + ManagementScope scope = new ManagementScope(sNamespace, connection); + ObjectQuery query = new ObjectQuery(queryString); + EnumerationOptions eOptions = new EnumerationOptions { EnumerateDeep = true, UseAmendedQualifiers = true }; + + ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query, eOptions); + foreach (ManagementClass mClass in (from ManagementClass mClass in searcher.Get() + orderby mClass.Path.ClassName + select mClass)) + { + _searchResultCount++; + WmiClass wmiClass = new WmiClass(mClass); + + ListViewItem li = new ListViewItem + { + Name = wmiClass.Path, + Text = wmiClass.DisplayName, + ToolTipText = wmiClass.Description + }; + li.SubItems.Add(wmiClass.HasLazyProperties.ToString()); + li.SubItems.Add(wmiClass.Path); + li.SubItems.Add(wmiClass.Description); + + // Add item to list view + listSearchResults.Items.Add(li); + } + + if (bRecurse) + { + // Get and search child namespaces + query = new ObjectQuery("SELECT * FROM __Namespace"); + searcher = new ManagementObjectSearcher(scope, query); + foreach (ManagementObject mObject in searcher.Get()) + { + sNamespace = "\\\\" + mObject.Path.Server + "\\" + mObject.Path.NamespacePath + "\\" + mObject.GetPropertyValue("Name"); + SearchClassesRecurse(sNamespace, queryString, true, connection); + } + } + } + catch (Exception ex) + { + SetStatusBar2("Error searching classes within " + sNamespace + " namespace. " + ex.Message, MessageCategory.Error, true); + _searchErrorOccurred = true; + } + } + + private void SearchMethods(string searchPattern, WmiNode currentWmiNode) + { + string sNamespace = currentWmiNode.WmiNamespace.Path; + ConnectionOptions connection = Helpers.GetRootNodeCredentials(treeNamespaces.SelectedNode); + bool bRecurse = checkBoxSearchRecurse.Checked; + + // Clear list view + listSearchResults.Clear(); + listSearchResults.Columns.Add("Method Name", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Class", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Static", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Namespace", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Description", -2, HorizontalAlignment.Left); + + Stopwatch stopwatch = new Stopwatch(); + stopwatch.Start(); + + Cursor = Cursors.WaitCursor; + SetStatusBar2("Searching methods in " + sNamespace + " that match search pattern: " + searchPattern, MessageCategory.Action, true); + + listSearchResults.BeginUpdate(); + + string queryString = CreateClassEnumQuery("%"); + SearchMethodsRecurse(sNamespace, queryString, searchPattern, bRecurse, connection); + + listSearchResults.Sorting = SortOrder.Ascending; + listSearchResults.Sort(); + listSearchResults.ResizeColumns(); + listSearchResults.SetSortIcon(_listSearchResultsColumnSorter.SortColumn, _listSearchResultsColumnSorter.Order); + listSearchResults.EndUpdate(); + + Cursor = Cursors.Default; + stopwatch.Stop(); + SetStatusBar3("Search Methods", stopwatch.Elapsed); + + if (!_searchErrorOccurred) + { + SetStatusBar2("Search completed successfully and found " + _searchResultCount + " results.", MessageCategory.Info); + } + else + { + SetStatusBar2("Search completed with errors and found " + _searchResultCount + " results.", MessageCategory.Warn); + } + } + + private void SearchMethodsRecurse(string sNamespace, string queryString, string searchPattern, bool bRecurse, ConnectionOptions connection) + { + // Skip root\directory\ldap namespace from search + if (sNamespace.ToLower().Contains("root\\directory\\ldap")) + { + Log("Skipping ROOT\\directory\\LDAP namespace as it can take a very long time"); + return; + } + + SetStatusBar2("Searching methods in " + sNamespace + "...", MessageCategory.Action); + + try + { + ManagementScope scope = new ManagementScope(sNamespace, connection); + ObjectQuery query = new ObjectQuery(queryString); + EnumerationOptions eOptions = new EnumerationOptions { EnumerateDeep = true, UseAmendedQualifiers = true }; + + ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query, eOptions); + foreach (ManagementClass mClass in (from ManagementClass mClass in searcher.Get() + orderby mClass.Path.ClassName + select mClass)) + { + if (mClass.Methods.Count == 0) continue; + + foreach (MethodData method in mClass.Methods) + { + if (method.Name.ToLower().Contains(searchPattern.ToLower()) || searchPattern == "%") + { + _searchResultCount++; + string methodDesc = String.Empty; + bool methodStatic = false; + + // Set method Static and Description. + foreach (QualifierData qd in method.Qualifiers) + { + if (qd.Name.Equals("Static", StringComparison.CurrentCultureIgnoreCase)) + methodStatic = true; + + if (qd.Name.Equals("Description", StringComparison.CurrentCultureIgnoreCase)) + methodDesc = qd.Value.ToString(); + } + + ListViewItem li = new ListViewItem + { + Name = mClass.Path.NamespacePath + "_" + mClass.Path.ClassName + "_" + method.Name, + Text = method.Name, + ToolTipText = methodDesc + }; + + li.SubItems.Add(mClass.Path.ClassName); + li.SubItems.Add(methodStatic.ToString()); + li.SubItems.Add(sNamespace); + li.SubItems.Add(methodDesc); + + listSearchResults.Items.Add(li); + } + } + } + + if (bRecurse) + { + // Get and search child namespaces + query = new ObjectQuery("SELECT * FROM __Namespace"); + searcher = new ManagementObjectSearcher(scope, query); + foreach (ManagementObject mObject in searcher.Get()) + { + sNamespace = "\\\\" + mObject.Path.Server + "\\" + mObject.Path.NamespacePath + "\\" + mObject.GetPropertyValue("Name"); + SearchMethodsRecurse(sNamespace, queryString, searchPattern, true, connection); + } + } + } + catch (Exception ex) + { + SetStatusBar2("Error searching methods within " + sNamespace + " namespace. " + ex.Message, MessageCategory.Error, true); + _searchErrorOccurred = true; + } + } + + private void SearchProperties(string searchPattern, WmiNode currentWmiNode) + { + string sNamespace = currentWmiNode.WmiNamespace.Path; + ConnectionOptions connection = Helpers.GetRootNodeCredentials(treeNamespaces.SelectedNode); + bool bRecurse = checkBoxSearchRecurse.Checked; + + // Clear list view + listSearchResults.Clear(); + listSearchResults.Columns.Add("Property Name", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Class", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Lazy", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Namespace", -2, HorizontalAlignment.Left); + listSearchResults.Columns.Add("Description", -2, HorizontalAlignment.Left); + + Stopwatch stopwatch = new Stopwatch(); + stopwatch.Start(); + + Cursor = Cursors.WaitCursor; + SetStatusBar2("Searching properties in " + sNamespace + " that match search pattern: " + searchPattern, MessageCategory.Action, true); + + listSearchResults.BeginUpdate(); + + string queryString = CreateClassEnumQuery("%"); + SearchPropertiesRecurse(sNamespace, queryString, searchPattern, bRecurse, connection); + + listSearchResults.Sorting = SortOrder.Ascending; + listSearchResults.Sort(); + listSearchResults.ResizeColumns(); + listSearchResults.SetSortIcon(_listSearchResultsColumnSorter.SortColumn, _listSearchResultsColumnSorter.Order); + listSearchResults.EndUpdate(); + + Cursor = Cursors.Default; + stopwatch.Stop(); + SetStatusBar3("Search Properties", stopwatch.Elapsed); + + if (!_searchErrorOccurred) + { + SetStatusBar2("Search completed successfully and found " + _searchResultCount + " results.", MessageCategory.Info); + } + else + { + SetStatusBar2("Search completed with errors and found " + _searchResultCount + " results.", MessageCategory.Warn); + } + } + + private void SearchPropertiesRecurse(string sNamespace, string queryString, string searchPattern, bool bRecurse, ConnectionOptions connection) + { + // Skip root\directory\ldap namespace from search + if (sNamespace.ToLower().Contains("root\\directory\\ldap")) + { + Log("Skipping ROOT\\directory\\LDAP namespace as it can take a very long time"); + return; + } + + SetStatusBar2("Searching properties in " + sNamespace + "...", MessageCategory.Action); + + try + { + ManagementScope scope = new ManagementScope(sNamespace, connection); + ObjectQuery query = new ObjectQuery(queryString); + EnumerationOptions eOptions = new EnumerationOptions { EnumerateDeep = true, UseAmendedQualifiers = true }; + + ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query, eOptions); + foreach (ManagementClass mClass in (from ManagementClass mClass in searcher.Get() + orderby mClass.Path.ClassName + select mClass)) + { + if (mClass.Properties.Count == 0) continue; + + foreach (PropertyData property in mClass.Properties) + { + if (property.Name.ToLower().Contains(searchPattern.ToLower()) || searchPattern == "%") + { + _searchResultCount++; + string propDesc = String.Empty; + bool propLazy = false; + + // Set method Static and Description. + foreach (QualifierData qd in property.Qualifiers) + { + if (qd.Name.Equals("lazy", StringComparison.CurrentCultureIgnoreCase)) + propLazy = true; + + if (qd.Name.Equals("Description", StringComparison.CurrentCultureIgnoreCase)) + propDesc = qd.Value.ToString(); + } + + ListViewItem li = new ListViewItem + { + Name = mClass.Path.NamespacePath + "_" + mClass.Path.ClassName + "_" + property.Name, + Text = property.Name, + ToolTipText = propDesc + }; + + li.SubItems.Add(mClass.Path.ClassName); + li.SubItems.Add(propLazy.ToString()); + li.SubItems.Add(sNamespace); + li.SubItems.Add(propDesc); + + listSearchResults.Items.Add(li); + } + } + } + + if (bRecurse) + { + // Get and search child namespaces + query = new ObjectQuery("SELECT * FROM __Namespace"); + searcher = new ManagementObjectSearcher(scope, query); + foreach (ManagementObject mObject in searcher.Get()) + { + sNamespace = "\\\\" + mObject.Path.Server + "\\" + mObject.Path.NamespacePath + "\\" + mObject.GetPropertyValue("Name"); + SearchPropertiesRecurse(sNamespace, queryString, searchPattern, true, connection); + } + } + } + catch (Exception ex) + { + SetStatusBar2("Error searching methods within " + sNamespace + " namespace. " + ex.Message, MessageCategory.Error, true); + _searchErrorOccurred = true; + } + } + + private void UpdateCheck() + { + if (Settings.Default.LastUpdateCheck > DateTime.Now.AddDays((-(Convert.ToInt32(Settings.Default.UpdateCheckIntervalInDays))))) + { + Log("Update Check - Last Update Check was within configured interval: " + + Settings.Default.LastUpdateCheck); + + if (Settings.Default.bUpdateAvailable) + { + Log("Update Check - New version is available as per last check. Click on \"Update Available\" for more information."); + UpdateNotify(true); + } + else + { + Log("Update Check - Running the latest version as per last check!"); + //UpdateNotify(false); + } + } + else + { + UpdateCheckAsync(); + } + } + + private void UpdateCheckAsync(bool manualRequest = false) + { + BackgroundWorker bwUpdateCheckWorker = new BackgroundWorker(); + bwUpdateCheckWorker.DoWork += UpdateCheckWorker_DoWork; + //bwUpdateCheckWorker.RunWorkerCompleted += UpdateCheckWorker_RunWorkerCompleted; + bwUpdateCheckWorker.RunWorkerCompleted += (obj, e) => UpdateCheckWorker_RunWorkerCompleted(e, manualRequest); + bwUpdateCheckWorker.RunWorkerAsync(); + } + + private void UpdateCheckWorker_DoWork(object sender, DoWorkEventArgs e) + { + Update update; + UpdaterService updaterService = new UpdaterService(); + + try + { + update = updaterService.CheckForUpdatesAsync(Settings.Default.UpdateCheckUrl, UpdateFilter.Stable); + if (update != null && update.ChangeLogUrl != null) + { + var changeLog = updaterService.GetChangeLog(update.ChangeLogUrl); + File.WriteAllText(_changeLogPath, changeLog); + } + } + catch (Exception ex) + { + Log("Update Check - Error: " + ex.Message); + Log("Update Check - Trying backup URL."); + update = updaterService.CheckForUpdatesAsync(Settings.Default.UpdateCheckUrlBackup, UpdateFilter.Stable); + if (update != null && update.ChangeLogUrl != null) + { + var changeLog = updaterService.GetChangeLog(update.ChangeLogUrl); + File.WriteAllText(_changeLogPath, changeLog); + } + } + + e.Result = update; + } + + private void UpdateCheckWorker_RunWorkerCompleted(RunWorkerCompletedEventArgs e, bool manualRequest) + { + // Save Last Update Check time + Settings.Default.LastUpdateCheck = DateTime.Now; + Settings.Default.Save(); + + if (e.Error != null) + { + Log("Update Check - Error: " + e.Error.Message); + SetStatusBar1("Update Check Failed! See log tab for more information.", MessageCategory.Error); + SetStatusBar2(String.Empty, MessageCategory.None); + return; + } + + try + { + var update = (Update)e.Result; + if (update != null) + { + UpdateNotify(true); + Log("Update Check - New Version is available: " + update.Version); + Settings.Default.bUpdateAvailable = true; + Settings.Default.UpdateUrl = update.Url.ToString(); + Settings.Default.Save(); + } + else + { + Log("Update Check - Running the latest version!"); + Settings.Default.bUpdateAvailable = false; + Settings.Default.Save(); + + if (manualRequest) + UpdateNotify(false); + } + } + catch (Exception ex) + { + Log("Update Check - Error: " + ex.Message); + } + } + + private void UpdateNotify(bool bUpdateAvailable) + { + toolStripLabelUpdateNotification.Text = bUpdateAvailable ? "Update Available" : "No Update Available"; + toolStripLabelUpdateNotification.Tag = bUpdateAvailable; + } + } +} \ No newline at end of file diff --git a/WmiExplorer/WmiExplorer.cs b/WmiExplorer/WmiExplorer.cs new file mode 100644 index 0000000..65b0885 --- /dev/null +++ b/WmiExplorer/WmiExplorer.cs @@ -0,0 +1,1623 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; +using System.Drawing; +using System.IO; +using System.Linq; +using System.Management; +using System.Reflection; +using System.Runtime.Caching; +using System.Text; +using System.Windows.Forms; +using WmiExplorer.Classes; +using WmiExplorer.Forms; +using WmiExplorer.Properties; + +namespace WmiExplorer +{ + public partial class WmiExplorer : Form + { + public static readonly CacheItemPolicy CachePolicy = new CacheItemPolicy(); + public static MemoryCache AppCache = new MemoryCache("AppCache"); + public static bool DebugMode = false; + public static int DisplayDpi; + + public WmiExplorer() + { + InitializeComponent(); + Application.AddMessageFilter(new MouseWheelMessageFilter()); + } + + private delegate void LogCallback(string text); + + private delegate void SetStatusBar1Callback(String text, MessageCategory messagecategory, bool bLog = false); + + private delegate void SetStatusBar2Callback(String text, MessageCategory messagecategory, bool bLog = false); + + private delegate void SetStatusBar3Callback(string category, TimeSpan time); + + public void Log(string text) + { + if (textBoxLogging.InvokeRequired) + { + LogCallback d = Log; //LogCallback d = new LogCallback(Log); + Invoke(d, new object[] { text }); + } + else + { + textBoxLogging.AppendText(Environment.NewLine + DateTime.Now + " : " + text); + } + } + + private void buttonClassesRefresh_Click(object sender, EventArgs e) + { + if (treeNamespaces.SelectedNode == null) + SetStatusBar1("No namespace is selected.", MessageCategory.Warn); + else + treeNamespaces_NodeMouseDoubleClick(sender, null); + } + + private void buttonComputerConnect_Click(object sender, EventArgs e) + { + // Set computer name display text to NetBIOS name if using . or localhost or blank name + if (textBoxComputerName.Text == "." || textBoxComputerName.Text == "localhost" || textBoxComputerName.Text == String.Empty) + textBoxComputerName.Text = SystemInformation.ComputerName; + + WmiNode rootNode = new WmiNode + { + IsRootNode = true, + UserSpecifiedPath = textBoxComputerName.Text.ToUpperInvariant() + }; + + rootNode.SetConnection(_defaultConnection); + + Connect(rootNode); + } + + private void buttonHideNamespaces_Click(object sender, EventArgs e) + { + if (buttonHideNamespaces.Text == "-") + { + buttonHideNamespaces.Text = "+"; + treeNamespaces.Visible = false; + groupBoxNamespaces.Text = "N"; + _tempSplitterDistance = splitContainerNamespaceClasses.SplitterDistance; + splitContainerNamespaceClasses.SplitterDistance = 30; + splitContainerNamespaceClasses.IsSplitterFixed = true; + } + else + { + buttonHideNamespaces.Text = "-"; + treeNamespaces.Visible = true; + groupBoxNamespaces.Text = "Namespaces"; + splitContainerNamespaceClasses.SplitterDistance = _tempSplitterDistance; + splitContainerNamespaceClasses.IsSplitterFixed = false; + } + } + + private void buttonHideNamespaces_MouseHover(object sender, EventArgs e) + { + toolTip.SetToolTip(buttonHideNamespaces, + buttonHideNamespaces.Text == "+" ? "Show Namespaces" : "Hide Namespaces"); + } + + private void buttonInstancesRefresh_Click(object sender, EventArgs e) + { + if (listClasses.SelectedItems.Count != 0) + listClasses_DoubleClick(sender, e); + else + SetStatusBar2("No class is selected", MessageCategory.Warn); + } + + private void buttonQueryExecute1_Click(object sender, EventArgs e) + { + tabControlInstances.SelectTab(tabQueryResults); + textBoxQuery2.Text = textBoxQuery1.Text; + buttonQueryExecute2.PerformClick(); + } + + private void buttonQueryExecute2_Click(object sender, EventArgs e) + { + ExecuteQuery(textBoxQuery2.Text); + } + + private void buttonRefreshObject_Click(object sender, EventArgs e) + { + if (listInstances.SelectedItems.Count == 0) + { + SetStatusBar2("No instance is selected. ", MessageCategory.Warn); + return; + } + + ListViewItem currentListViewItem = listInstances.SelectedItems[0]; + PopulateInstanceProperties(currentListViewItem, true); + } + + private void buttonScriptRun_Click(object sender, EventArgs e) + { + const string cmd = "cmd.exe"; + string args; + string tempPath = Environment.GetEnvironmentVariable("TEMP"); + + if (radioScriptVbs.Checked) + { + string scriptPath = tempPath + "\\temp_script.vbs"; + string outPath = tempPath + "\\temp_script_vbs_out.txt"; + File.WriteAllText(scriptPath, textBoxScript.Text); + + if (radioScriptOutCmd.Checked) + { + args = " /k cscript.exe //E:VBScript //NoLogo " + scriptPath; + Utilities.LaunchProgram(cmd, args, false); + } + + if (radioScriptOutTxt.Checked) + { + args = " /c cscript.exe //E:VBScript //NoLogo " + scriptPath + " > " + outPath; + Utilities.LaunchProgram(cmd, args, true); + Utilities.LaunchProgram("Notepad.exe", outPath, false); + } + } + + if (radioScriptPs.Checked) + { + string scriptPath = tempPath + "\\temp_script.ps1"; + string outPath = tempPath + "\\temp_script_ps1_out.txt"; + File.WriteAllText(scriptPath, textBoxScript.Text); + + if (radioScriptOutCmd.Checked) + { + args = " /k powershell.exe -ExecutionPolicy Bypass -NoLogo -NoExit " + scriptPath; + Utilities.LaunchProgram(cmd, args, false); + } + + if (radioScriptOutTxt.Checked) + { + args = " /c powershell.exe -ExecutionPolicy Bypass -NoLogo " + scriptPath + " > " + outPath; + Utilities.LaunchProgram(cmd, args, true); + Utilities.LaunchProgram("Notepad.exe", outPath, false); + } + } + } + + private void buttonScriptSave_Click(object sender, EventArgs e) + { + saveScriptDialog.InitialDirectory = Environment.CurrentDirectory; + saveScriptDialog.FileName = listClasses.SelectedItems[0].Text; + + if (radioScriptVbs.Checked) + { + saveScriptDialog.Filter = "VBScript files (*.vbs)|*.vbs|Text files (*.txt)|*.txt|All files (*.*)|*.*"; + saveScriptDialog.ShowDialog(); + } + else if (radioScriptPs.Checked) + { + saveScriptDialog.Filter = "Powershell Script files (*.ps1)|*.ps1|Text files (*.txt)|*.txt|All files (*.*)|*.*"; + saveScriptDialog.ShowDialog(); + } + else + { + MessageBox.Show("No Script Language Selected.", "Invalid Action", MessageBoxButtons.OK, MessageBoxIcon.Warning); + } + } + + private void buttonSearch_Click(object sender, EventArgs e) + { + if (treeNamespaces.SelectedNode != null) + { + string searchPattern = textBoxSearchPattern.Text; + if (String.IsNullOrEmpty(searchPattern)) + { + SetStatusBar2("Error: Search String is Empty.", MessageCategory.Warn); + return; + } + + WmiNode currentWmiNode = treeNamespaces.SelectedNode.Tag as WmiNode; + if (currentWmiNode == null) + { + SetStatusBar2("Error: Current WmiNode is null.", MessageCategory.Error, true); + return; + } + + if (currentWmiNode.IsRootNode && !currentWmiNode.IsConnected) + { + SetStatusBar2("Please connect to " + currentWmiNode.UserSpecifiedPath + " before searching.", MessageCategory.Warn, true); + return; + } + + // Reset search result counter and error + _searchResultCount = 0; + _searchErrorOccurred = false; + + if (radioSearchClasses.Checked) + SearchClasses(searchPattern, currentWmiNode); + + if (radioSearchMethods.Checked) + SearchMethods(searchPattern, currentWmiNode); + + if (radioSearchProperties.Checked) + SearchProperties(searchPattern, currentWmiNode); + } + else + { + SetStatusBar2("No Namespace selected.", MessageCategory.Warn); + } + } + + private void checkBoxEnumOptions_CheckedChanged(object sender, EventArgs e) + { + try + { + var checkbox = (CheckBox)sender; + var currentflag = (EnumOptions)checkbox.Tag; + + if (checkbox.Checked) + Settings.Default.EnumOptionsFlags |= currentflag; + else + Settings.Default.EnumOptionsFlags ^= currentflag; + + // Re-populate instance properties if Instance Enumeration options changed. + if (listInstances.SelectedItems.Count == 0) return; + PopulateInstanceProperties(listInstances.SelectedItems[0]); + } + catch (Exception ex) + { + Log("checkBoxEnumOptions_CheckedChanged - Failed to get the enumeration options. Error: " + ex.Message); + } + } + + private void contextMenu_Opening(object sender, CancelEventArgs e) + { + // Clear current items + contextMenu.Items.Clear(); + e.Cancel = false; + + // if context menu is being displayed for treeNamespaces Tree View + if (contextMenu.SourceControl == treeNamespaces) + { + if (treeNamespaces.SelectedNode != null) + { + WmiNode currentWmiNode = (WmiNode)treeNamespaces.SelectedNode.Tag; + + // Disconnected nodes + if (Helpers.IsNodeDisconnected(treeNamespaces.SelectedNode)) + { + ToolStripItem defaultItemDisconnected = new ToolStripMenuItem("&Connect", null, contextMenuItemConnectPath_Click); + defaultItemDisconnected.Font = new Font(defaultItemDisconnected.Font, defaultItemDisconnected.Font.Style | FontStyle.Bold); + contextMenu.Items.Add(defaultItemDisconnected); + contextMenu.Items.Add("&Connect As", null, contextMenuItemConnectAsPath_Click); + contextMenu.Items.Add("&Remove", null, contextMenuItemRemovePath_Click); + return; + } + + // All nodes default item + ToolStripItem defaultItem = new ToolStripMenuItem("&Enumerate Classes", null, contextMenuItemGetClasses_Click); + defaultItem.Font = new Font(defaultItem.Font, defaultItem.Font.Style | FontStyle.Bold); + contextMenu.Items.Add(defaultItem); + + // Root Nodes + if (currentWmiNode.IsRootNode) + { + contextMenu.Items.Add("Show WMI &Provider Host Information", null, contextMenuItemShowProviderInfo_Click); + contextMenu.Items.Add("&Disconnect", null, contextMenuItemDisconnectPath_Click); + contextMenu.Items.Add("Disconnect and &Remove", null, contextMenuItemDisconnectRemovePath_Click); + } + + // SMS Provider Node + if (Settings.Default.bSmsMode && + currentWmiNode.WmiNamespace.DisplayName.StartsWith("ROOT\\SMS\\SITE_", + StringComparison.InvariantCultureIgnoreCase)) + { + var excludeSmsCollections = new ToolStripMenuItem("Exclude SMS &Collection Classes", null, contextMenuItemExcludeSmsCollections_Click); + var excludeSmsInventory = new ToolStripMenuItem("Exclude SMS &Inventory Classes", null, contextMenuItemExcludeSmsInventory_Click); + excludeSmsCollections.Checked = Settings.Default.EnumOptionsFlags.HasFlag(EnumOptions.ExcludeSmsCollections); + excludeSmsInventory.Checked = Settings.Default.EnumOptionsFlags.HasFlag(EnumOptions.ExcludeSmsInventory); + contextMenu.Items.Add(excludeSmsCollections); + contextMenu.Items.Add(excludeSmsInventory); + } + + // SMS Client Actions + if (Settings.Default.bSmsMode && Helpers.GetSmsClient(treeNamespaces.SelectedNode) != null && Helpers.GetSmsClient(treeNamespaces.SelectedNode).IsClientInstalled) + { + if (currentWmiNode.WmiNamespace.DisplayName.Equals("ROOT\\CCM", StringComparison.InvariantCultureIgnoreCase)) + { + var smsClientActionsToolStripItem = GetClientActionsContextMenuItem(); + contextMenu.Items.Add(smsClientActionsToolStripItem); + } + } + + // Currently Enumerating Nodes + if (currentWmiNode.WmiNamespace.IsEnumerating) + contextMenu.Items.Add("&Cancel Enumeration", null, contextMenuItemCancelEnumNamespace_Click); + + // All nodes + contextMenu.Items.Add("Copy Path", null, contextMenuItemCopyNamespacePath_Click); + contextMenu.Items.Add("Copy Relative Path", null, contextMenuItemCopyNamespaceRelativePath_Click); + } + } + + // if context menu is being displayed for listClasses list + if (contextMenu.SourceControl == listClasses) + { + if (listClasses.SelectedItems.Count != 0) + { + WmiClass currentWmiClass = ((WmiClass)listClasses.SelectedItems[0].Tag); + // All classes default item + ToolStripItem defaultItem = new ToolStripMenuItem("&Enumerate Instances", null, listClasses_DoubleClick); + defaultItem.Font = new Font(defaultItem.Font, defaultItem.Font.Style | FontStyle.Bold); + contextMenu.Items.Add(defaultItem); + + // Currently Enumerating Classes + if (currentWmiClass.IsEnumerating) + { + contextMenu.Items.Add("&Cancel Enumeration", null, contextMenuItemCancelEnumClass_Click); + } + + contextMenu.Items.Add("Show MOF", null, contextMenuItemShowClassMof_Click); + contextMenu.Items.Add("Show MOF (Amended Qualifiers)", null, contextMenuItemShowClassMofAmended_Click); + contextMenu.Items.Add("Copy MOF", null, contextMenuItemCopyClassMof_Click); + contextMenu.Items.Add("Copy Path", null, contextMenuItemCopyClassPath_Click); + contextMenu.Items.Add("Copy Relative Path", null, contextMenuItemCopyClassRelativePath_Click); + + var executeMethodsToolStripItem = GetMethodsContextMenuItem(true); + if (executeMethodsToolStripItem.HasDropDownItems) + contextMenu.Items.Add(executeMethodsToolStripItem); + } + } + + // if context menu is being displayed for listInstances list + if (contextMenu.SourceControl == listInstances) + { + if (listInstances.SelectedItems.Count != 0) + { + contextMenu.Items.Add("Show MOF", null, contextMenuItemShowInstanceMof_Click); + contextMenu.Items.Add("Copy MOF", null, contextMenuItemCopyInstanceMof_Click); + contextMenu.Items.Add("Copy Path", null, contextMenuItemCopyInstancePath_Click); + contextMenu.Items.Add("Copy Relative Path", null, contextMenuItemCopyInstanceRelativePath_Click); + + var executeMethodsToolStripItem = GetMethodsContextMenuItem(false); + if (executeMethodsToolStripItem.HasDropDownItems) + contextMenu.Items.Add(executeMethodsToolStripItem); + } + } + + // if context menu is being displayed for instance property grid + if (contextMenu.SourceControl == propertyGridInstance && propertyGridInstance.SelectedGridItem != null) + { + contextMenu.Items.Add("Copy Name and Value", null, contextMenuItemCopyPropertyNameValue_Click); + contextMenu.Items.Add("Copy Value", null, contextMenuItemCopyPropertyValue_Click); + contextMenu.Items.Add("Copy Description", null, contextMenuItemCopyPropertyDescription_Click); + } + } + + private void contextMenuItemCancelEnumClass_Click(object sender, EventArgs e) + { + if (_bwInstanceEnumWorker == null) return; + + WmiClass currentClass = listClasses.SelectedItems[0].Tag as WmiClass; + + if (currentClass == null) + { + SetStatusBar2("Unable to cancel Enumeration: NullReferenceException", MessageCategory.Error, true); + return; + } + + if (currentClass.IsEnumerating) + { + currentClass.IsEnumerationCancelled = true; + currentClass.IsEnumerating = false; + _bwInstanceEnumWorker.CancelAsync(); + SetStatusBar2("Cancelling enumeration for " + currentClass.DisplayName, MessageCategory.Warn, true); + } + else + { + SetStatusBar1("Cancellation skipped. Enumeration already completed.", MessageCategory.Info); + } + } + + private void contextMenuItemCancelEnumNamespace_Click(object sender, EventArgs e) + { + if (_bwClassEnumWorker == null) return; + + WmiNode currentWmiNode = treeNamespaces.SelectedNode.Tag as WmiNode; + if (currentWmiNode == null) + { + SetStatusBar1("Unable to cancel enumeration: NullReferenceException", MessageCategory.Error, true); + return; + } + + if (currentWmiNode.WmiNamespace.IsEnumerating) + { + currentWmiNode.WmiNamespace.IsEnumerationCancelled = true; + currentWmiNode.WmiNamespace.IsEnumerating = false; + _bwClassEnumWorker.CancelAsync(); + SetStatusBar1("Cancelling enumeration for " + currentWmiNode.WmiNamespace.DisplayName, MessageCategory.Warn, true); + } + else + { + SetStatusBar1("Cancellation skipped. Enumeration already completed.", MessageCategory.Info); + } + } + + private void contextMenuItemConnectAsPath_Click(object sender, EventArgs e) + { + WmiNode namespaceNode = treeNamespaces.SelectedNode.Tag as WmiNode; + if (namespaceNode != null) + { + using (Form_ConnectAs connectAsForm = new Form_ConnectAs(namespaceNode.UserSpecifiedPath)) + { + connectAsForm.ShowDialog(this); + + if (connectAsForm.Cancelled) return; + + if (connectAsForm.Connection != null) + { + namespaceNode.SetConnection(connectAsForm.Connection); + } + else + { + MessageBox.Show("Failed to set credentials. Using logged on user's credentials.", "Credentials Failure", MessageBoxButtons.OK, MessageBoxIcon.Error); + namespaceNode.SetConnection(_defaultConnection); + } + + Connect(namespaceNode); + } + } + } + + private void contextMenuItemConnectPath_Click(object sender, EventArgs e) + { + WmiNode namespaceNode = treeNamespaces.SelectedNode.Tag as WmiNode; + if (namespaceNode != null) + Connect(namespaceNode); + } + + private void contextMenuItemCopyClassMof_Click(object sender, EventArgs e) + { + string mof = ((WmiClass)listClasses.SelectedItems[0].Tag).GetClassMof(); + if (mof != null) + Clipboard.SetText(mof); + } + + private void contextMenuItemCopyClassPath_Click(object sender, EventArgs e) + { + var path = ((WmiClass)listClasses.SelectedItems[0].Tag).Path; + if (path != null) + Clipboard.SetText(path); + } + + private void contextMenuItemCopyClassRelativePath_Click(object sender, EventArgs e) + { + var relativePath = ((WmiNode)treeNamespaces.SelectedNode.Tag).WmiNamespace.RelativePath; + if (relativePath != null) + { + relativePath += ":" + ((WmiClass)listClasses.SelectedItems[0].Tag).RelativePath; + Clipboard.SetText(relativePath); + } + } + + private void contextMenuItemCopyInstanceMof_Click(object sender, EventArgs e) + { + if (_instanceMof != String.Empty) + Clipboard.SetText(_instanceMof); + } + + private void contextMenuItemCopyInstancePath_Click(object sender, EventArgs e) + { + var path = ((WmiInstance)listInstances.SelectedItems[0].Tag).Path; + if (path != null) + Clipboard.SetText(path); + } + + private void contextMenuItemCopyInstanceRelativePath_Click(object sender, EventArgs e) + { + var relativePath = ((WmiNode)treeNamespaces.SelectedNode.Tag).WmiNamespace.RelativePath; + if (relativePath != null) + { + relativePath += ":" + ((WmiInstance)listInstances.SelectedItems[0].Tag).RelativePath; + Clipboard.SetText(relativePath); + } + } + + private void contextMenuItemCopyNamespacePath_Click(object sender, EventArgs e) + { + string path = ((WmiNode)treeNamespaces.SelectedNode.Tag).WmiNamespace.Path; + if (path != null) + Clipboard.SetText(path); + } + + private void contextMenuItemCopyNamespaceRelativePath_Click(object sender, EventArgs e) + { + var relativePath = ((WmiNode)treeNamespaces.SelectedNode.Tag).WmiNamespace.RelativePath; + if (relativePath != null) + Clipboard.SetText(relativePath); + } + + private void contextMenuItemCopyPropertyDescription_Click(object sender, EventArgs e) + { + if (propertyGridInstance.SelectedGridItem.PropertyDescriptor == null) + return; + + if (propertyGridInstance.SelectedGridItem.PropertyDescriptor.Category == "Misc") + { + if (propertyGridInstance.SelectedGridItem.Value is ManagementBaseObjectW) + MessageBox.Show("Copy Description Operation on an Array Element is Not Allowed. Expand the Object to Copy Description of Desired Property." + , "Not Supported" + , MessageBoxButtons.OK + , MessageBoxIcon.Information); + else + MessageBox.Show("Copy Description Operation on an Array Element is Not Allowed." + , "Not Supported" + , MessageBoxButtons.OK + , MessageBoxIcon.Information); + } + else + { + var txtToCopy = propertyGridInstance.SelectedGridItem.PropertyDescriptor.DisplayName; + txtToCopy += Environment.NewLine + propertyGridInstance.SelectedGridItem.PropertyDescriptor.Description; + txtToCopy = txtToCopy.Replace("\n", "\r\n"); + Clipboard.SetText(txtToCopy); + } + } + + private void contextMenuItemCopyPropertyNameValue_Click(object sender, EventArgs e) + { + var nameValue = String.Empty; + + if (propertyGridInstance.SelectedGridItem.PropertyDescriptor == null) + return; + + if (propertyGridInstance.SelectedGridItem.Value != null && propertyGridInstance.SelectedGridItem.Value.ToString() != String.Empty) + { + if (propertyGridInstance.SelectedGridItem.Value is ManagementBaseObjectW) + { + if (propertyGridInstance.SelectedGridItem.PropertyDescriptor.Category == "Misc") + MessageBox.Show("Copy Value Operation on an element of Embedded Object is Not Allowed. Expand the Object to Copy the Value of Desired Property." + , "Not Supported" + , MessageBoxButtons.OK + , MessageBoxIcon.Information); + else + { + nameValue = propertyGridInstance.SelectedGridItem.PropertyDescriptor.DisplayName; + nameValue += " = "; + nameValue += propertyGridInstance.SelectedGridItem.Value.ToString(); + } + } + else + { + nameValue = propertyGridInstance.SelectedGridItem.PropertyDescriptor.DisplayName; + nameValue += " = "; + nameValue += propertyGridInstance.SelectedGridItem.Value.ToString(); + } + } + else + { + nameValue = propertyGridInstance.SelectedGridItem.PropertyDescriptor.DisplayName; + nameValue += " = null"; + } + + if (nameValue != String.Empty) + Clipboard.SetText(nameValue); + } + + private void contextMenuItemCopyPropertyValue_Click(object sender, EventArgs e) + { + if (propertyGridInstance.SelectedGridItem.PropertyDescriptor == null) + return; + + if (propertyGridInstance.SelectedGridItem.Value != null && propertyGridInstance.SelectedGridItem.Value.ToString() != String.Empty) + { + if (propertyGridInstance.SelectedGridItem.Value is ManagementBaseObjectW) + { + if (propertyGridInstance.SelectedGridItem.PropertyDescriptor.Category == "Misc") + MessageBox.Show("Copy Value Operation on an element of Embedded Object is Not Allowed. Expand the Object to Copy the Value of Desired Property." + , "Not Supported" + , MessageBoxButtons.OK + , MessageBoxIcon.Information); + else + Clipboard.SetText(propertyGridInstance.SelectedGridItem.Value.ToString()); + } + else + Clipboard.SetText(propertyGridInstance.SelectedGridItem.Value.ToString()); + } + } + + private void contextMenuItemDisconnectPath_Click(object sender, EventArgs e) + { + var nodeToDisconnect = ((WmiNode)treeNamespaces.SelectedNode.Tag).UserSpecifiedPath; + + // Clear all UI elements + ResetListClasses(); + ResetListInstances(); + ResetListMethods(); + ResetListClassProperties(); + ResetListQueryResults(); + RenameNamespaceTabsToDefault(); + RenameClassTabsToDefault(); + dataGridQueryResults.DataSource = null; + propertyGridInstance.SelectedObject = null; + propertyGridQueryResults.SelectedObject = null; + textBoxQuery1.Text = String.Empty; + textBoxQuery2.Text = String.Empty; + textBoxClassQuickFilter.Text = String.Empty; + textBoxInstanceFilterQuick.Text = String.Empty; + + ((WmiNode)treeNamespaces.SelectedNode.Tag).IsConnected = false; + ((WmiNode)treeNamespaces.SelectedNode.Tag).IsExpanded = false; + + treeNamespaces.SelectedNode.Text = nodeToDisconnect + " (Disconnected)"; + treeNamespaces.SelectedNode.Nodes.Clear(); + + foreach (var element in AppCache) + { + if (element.Key.Contains(((WmiNode)treeNamespaces.SelectedNode.Tag).WmiNamespace.Path)) + { + AppCache.Remove(element.Key); + } + } + + SetStatusBar1(nodeToDisconnect + " Disconnected", MessageCategory.Info, true); + SetStatusBar2(String.Empty, MessageCategory.None); + } + + private void contextMenuItemDisconnectRemovePath_Click(object sender, EventArgs e) + { + contextMenuItemDisconnectPath_Click(sender, e); + contextMenuItemRemovePath_Click(sender, e); + } + + private void contextMenuItemExcludeSmsCollections_Click(object sender, EventArgs e) + { + ToolStripMenuItem t = (ToolStripMenuItem)sender; + + if (t.Checked) + { + Settings.Default.EnumOptionsFlags ^= EnumOptions.ExcludeSmsCollections; + t.Checked = false; + } + else + { + Settings.Default.EnumOptionsFlags |= EnumOptions.ExcludeSmsCollections; + t.Checked = true; + } + + Settings.Default.Save(); + } + + private void contextMenuItemExcludeSmsInventory_Click(object sender, EventArgs e) + { + ToolStripMenuItem t = (ToolStripMenuItem)sender; + + if (t.Checked) + { + Settings.Default.EnumOptionsFlags ^= EnumOptions.ExcludeSmsInventory; + t.Checked = false; + } + else + { + Settings.Default.EnumOptionsFlags |= EnumOptions.ExcludeSmsInventory; + t.Checked = true; + } + + Settings.Default.Save(); + } + + private void contextMenuItemGetClasses_Click(object sender, EventArgs e) + { + ResetListInstances(); + ResetListClassProperties(); + ResetListMethods(); + RenameClassTabsToDefault(); + + EnumerateClasses(); + } + + private void contextMenuItemRemovePath_Click(object sender, EventArgs e) + { + string nodeToRemove = ((WmiNode)treeNamespaces.SelectedNode.Tag).UserSpecifiedPath; + if (Settings.Default.RecentPaths.Contains(nodeToRemove)) + { + Settings.Default.RecentPaths.Remove(nodeToRemove); + Settings.Default.Save(); + } + Log(nodeToRemove + " Removed"); + treeNamespaces.SelectedNode.Remove(); + } + + private void contextMenuItemShowClassMof_Click(object sender, EventArgs e) + { + var mof = ((WmiClass)listClasses.SelectedItems[0].Tag).GetClassMof(); + Form_ShowMof mofForm = new Form_ShowMof(mof); + mofForm.CenterForm(this).Show(this); + } + + private void contextMenuItemShowClassMofAmended_Click(object sender, EventArgs e) + { + var mof = ((WmiClass)listClasses.SelectedItems[0].Tag).GetClassMof(true); + Form_ShowMof mofForm = new Form_ShowMof(mof); + mofForm.CenterForm(this).Show(this); + } + + private void contextMenuItemShowInstanceMof_Click(object sender, EventArgs e) + { + Form_ShowMof mofForm = new Form_ShowMof(_instanceMof); + mofForm.CenterForm(this).Show(this); + } + + private void contextMenuItemShowProviderInfo_Click(object sender, EventArgs e) + { + const string msftProvidersQuery = "SELECT * FROM MSFT_Providers"; + + StringBuilder output = new StringBuilder(); + var caption = "WMI Provider Process Information"; + + try + { + WmiNode rootWmiNode = treeNamespaces.SelectedNode.Tag as WmiNode; + + if (rootWmiNode == null) + { + SetStatusBar1("Unable to get WMI Provider Process information: NullReferenceException", MessageCategory.Error, true); + SetStatusBar2(String.Empty, MessageCategory.None); + return; + } + + Cursor = Cursors.WaitCursor; + + if (rootWmiNode.WmiNamespace.ServerName.Equals(".", StringComparison.InvariantCultureIgnoreCase)) + caption += " for localhost"; + else + caption += " for " + rootWmiNode.WmiNamespace.ServerName; + + output.AppendLine(String.Empty); + + ManagementScope mScope = new ManagementScope("\\\\" + rootWmiNode.WmiNamespace.ServerName + "\\ROOT\\CIMV2", Helpers.GetRootNodeCredentials(treeNamespaces.SelectedNode)); + ObjectQuery query = new ObjectQuery(msftProvidersQuery); + ManagementObjectSearcher queryResults = new ManagementObjectSearcher(mScope, query); + queryResults.Options.EnumerateDeep = false; + + foreach (var instance in (from ManagementBaseObject i in queryResults.Get() + orderby i.GetPropertyValue("HostProcessIdentifier") + select i)) + { + output.AppendLine("Process ID " + instance.GetPropertyValue("HostProcessIdentifier")); + output.AppendLine(" - Used by Provider " + instance.GetPropertyValue("provider")); + output.AppendLine(" - Associated with Namespace " + instance.GetPropertyValue("namespace")); + + var user = instance.GetPropertyValue("user").ToString(); + if (!String.IsNullOrEmpty(user)) + output.AppendLine(" - By User " + user); + + var hostingGroup = instance.GetPropertyValue("hostinggroup").ToString(); + if (!String.IsNullOrEmpty(hostingGroup)) + output.AppendLine(" - Under Hosting Group " + hostingGroup); + + output.AppendLine(String.Empty); + } + } + catch (Exception ex) + { + output.AppendLine("Error getting WMI Provider details. " + ex.Message); + } + finally + { + Cursor = Cursors.Default; + } + + using (Form_DisplayText displayForm = new Form_DisplayText("WMI Providers", caption, output.ToString())) + { + displayForm.ShowDialog(this); + } + } + + private void listClasses_DoubleClick(object sender, EventArgs e) + { + EnumerateInstances(); + } + + private void listClasses_MouseClick(object sender, MouseEventArgs e) + { + // Display context menu on Right Click + if (e.Button == MouseButtons.Right) + { + ListView listView = sender as ListView; + + // ReSharper disable PossibleNullReferenceException + ListViewItem item = listView.GetItemAt(e.X, e.Y); + // ReSharper restore PossibleNullReferenceException + + if (item != null) + { + item.Selected = true; + contextMenu.Show(listView, e.Location); + } + } + + // Generate script if Scripts tab is selected + if (tabControlInstances.SelectedTab == tabScript) + { + GenerateVbScript(); + GeneratePsScript(); + } + + // Create class query + WmiClass currentWmiClass = listClasses.SelectedItems[0].Tag as WmiClass; + if (currentWmiClass != null) + textBoxQuery1.Text = CreateQueryForSelectedClass(currentWmiClass); + } + + private void listClasses_SelectedIndexChanged(object sender, EventArgs e) + { + // SelectedIndexChanged occurs twice, so bail out if nothing is selected + if (listClasses.SelectedItems.Count == 0) + { + // Clear UI + ResetListInstances(); + propertyGridInstance.SelectedObject = null; + RenameClassTabsToDefault(); + ResetListMethods(); + ResetListClassProperties(); + buttonScriptRun.Enabled = false; + buttonScriptSave.Enabled = false; + textBoxScript.Text = String.Empty; + return; + } + + ListViewItem currentItem = listClasses.SelectedItems[0]; + if (currentItem == null) return; + + WmiClass currentWmiClass = currentItem.Tag as WmiClass; + if (currentWmiClass == null) + { + SetStatusBar2("Unexpected error. Currently selected class has a null value.", MessageCategory.Error, true); + return; + } + + // Check if current class is already being enumerated + if (currentWmiClass.IsEnumerating) + { + SetStatusBar2("Enumerating Instances from " + currentWmiClass.DisplayName + "...", MessageCategory.Action); + ResetListInstances(); + return; + } + + // Set Instance Filter + textBoxInstanceFilterQuick.Text = currentWmiClass.InstanceFilterQuick; + + // Enable script buttons + buttonScriptRun.Enabled = true; + buttonScriptSave.Enabled = true; + + PopulateClassProperties(currentWmiClass); + PopulateMethods(currentWmiClass); + EnumerateInstancesFromCache(currentWmiClass); + + // Display properties if DebugMode + if (DebugMode) + propertyGridDebugWmiClass.SelectedObject = listClasses.SelectedItems[0].Tag; + } + + private void listInstances_MouseClick(object sender, MouseEventArgs e) + { + // Display context menu on Right Click + if (e.Button == MouseButtons.Right) + { + ListView listView = sender as ListView; + + // ReSharper disable PossibleNullReferenceException + ListViewItem item = listView.GetItemAt(e.X, e.Y); + // ReSharper restore PossibleNullReferenceException + + if (item != null) + { + item.Selected = true; + contextMenu.Show(listView, e.Location); + } + } + + // Create query for selected instance + WmiInstance currentWmiInstance = listInstances.SelectedItems[0].Tag as WmiInstance; + if (currentWmiInstance != null) + textBoxQuery1.Text = CreateQueryForSelectedInstance(listInstances.SelectedItems[0].Tag as WmiInstance); + } + + private void listInstances_SelectedIndexChanged(object sender, EventArgs e) + { + // SelectedIndexChange doccurs twice, so bail out if nothing is selected + if (listInstances.SelectedItems.Count == 0) + { + propertyGridInstance.SelectedObject = null; + return; + } + + // Display properties if DebugMode + if (DebugMode) + propertyGridDebugWmiInstance.SelectedObject = listInstances.SelectedItems[0].Tag; + + // Display instance properties + PopulateInstanceProperties(listInstances.SelectedItems[0]); + } + + private void listMethods_SelectedIndexChanged(object sender, EventArgs e) + { + if (listMethods.SelectedItems.Count == 0) + { + ResetListMethodParams(); + return; + } + + PopulateMethodHelp(listMethods.SelectedItems[0].Tag as MethodData); + } + + private void listProps_SelectedIndexChanged(object sender, EventArgs e) + { + ListView lvSender = (ListView)sender; + RichTextBox rtb; + string textToSearch; + _richTextSelectionResetRequired = true; + + if (lvSender.SelectedItems.Count == 0) + { + if (lvSender == listClassProperties) + richTextBoxClassDetails.SelectionBackColor = SystemColors.Control; + else + richTextBoxMethodDetails.SelectionBackColor = SystemColors.Control; + return; + } + + if (lvSender == listClassProperties) + { + rtb = richTextBoxClassDetails; + textToSearch = listClassProperties.SelectedItems[0].Text + " - " + listClassProperties.SelectedItems[0].SubItems[1].Text; + } + else if (lvSender == listMethodParamsIn) + { + rtb = richTextBoxMethodDetails; + textToSearch = listMethodParamsIn.SelectedItems[0].SubItems[1].Text + " - " + listMethodParamsIn.SelectedItems[0].SubItems[2].Text; + } + else if (lvSender == listMethodParamsOut) + { + rtb = richTextBoxMethodDetails; + textToSearch = listMethodParamsOut.SelectedItems[0].Text + " - " + listMethodParamsOut.SelectedItems[0].SubItems[1].Text; + } + else + return; + + // Reset start index and highlighting + int startindex = 0; + rtb.SelectionBackColor = SystemColors.Control; + + if (textToSearch.Length > 0) + startindex = Utilities.FindTextInRichTextBox(textToSearch.Trim(), 0, 0, rtb); + + // If string was found in the RichTextBox, highlight it + if (startindex >= 0) + { + // Set the highlight color as yellow + rtb.SelectionBackColor = Color.Yellow; + + // Find the end index. End Index = number of characters in textbox + int endindex = textToSearch.Length; + + // Highlight the search string + rtb.Select(startindex, endindex); + rtb.ScrollToCaret(); + } + } + + private void listQueryResults_SelectedIndexChanged(object sender, EventArgs e) + { + if (listQueryResults.SelectedItems.Count == 0) + { + propertyGridQueryResults.SelectedObject = null; + return; + } + + ManagementObject mObject = listQueryResults.SelectedItems[0].Tag as ManagementObject; + + ManagementBaseObjectW mObjectW = new ManagementBaseObjectW(mObject) + { + IncludeNullProperties = checkNullProps.Checked, + IncludeSystemProperties = checkSystemProps.Checked + }; + + propertyGridQueryResults.SelectedObject = mObjectW; + } + + private void listView_ColumnClick(object sender, ColumnClickEventArgs e) + { + ListView lvSender = (ListView)sender; + ListViewColumnSorter lvColumnSorter; + + if (lvSender == listMethods) + lvColumnSorter = _listMethodsColumnSorter; + else if (lvSender == listClassProperties) + lvColumnSorter = _listClassPropertiesColumnSorter; + else if (lvSender == listClasses) + lvColumnSorter = _listClassesColumnSorter; + else if (lvSender == listSearchResults) + lvColumnSorter = _listSearchResultsColumnSorter; + else + return; + + // Determine if clicked column is already the column that is being sorted. + if (e.Column == lvColumnSorter.SortColumn) + { + // Reverse the current sort direction for this column. + lvColumnSorter.Order = lvColumnSorter.Order == SortOrder.Ascending ? SortOrder.Descending : SortOrder.Ascending; + } + else + { + // Set the column number that is to be sorted; default to ascending. + lvColumnSorter.SortColumn = e.Column; + lvColumnSorter.Order = SortOrder.Ascending; + } + + // Perform the sort with these new sort options. + lvSender.Sort(); + lvSender.SetSortIcon(lvColumnSorter.SortColumn, lvColumnSorter.Order); + } + + private void menuItemFile_ConnectAs_Click(object sender, EventArgs e) + { + using (Form_ConnectAs connectAsForm = new Form_ConnectAs()) + { + connectAsForm.ShowDialog(this); + + if (connectAsForm.Cancelled) return; + + WmiNode rootNode = new WmiNode + { + IsRootNode = true, + UserSpecifiedPath = connectAsForm.Path + }; + + if (connectAsForm.Connection != null) + { + rootNode.SetConnection(connectAsForm.Connection); + } + else + { + MessageBox.Show("Failed to set credentials. Using logged on user's credentials.", "Credentials Failure", MessageBoxButtons.OK, MessageBoxIcon.Error); + rootNode.SetConnection(_defaultConnection); + } + + Connect(rootNode); + } + } + + private void menuItemFile_Exit_Click(object sender, EventArgs e) + { + Close(); + } + + private void menuItemFile_Preferences_Click(object sender, EventArgs e) + { + using (Form_Settings settingsForm = new Form_Settings()) + { + settingsForm.ShowDialog(this); + } + } + + private void menuItemFile_SmsMode_CheckedChanged(object sender, EventArgs e) + { + // Save current setting + Settings.Default.bSmsMode = menuItemFile_SmsMode.Checked; + Settings.Default.Save(); + + // return if nothing is selected + if (treeNamespaces.SelectedNode == null) + return; + + // Connect to Sms Client + TreeNode rootNode = treeNamespaces.SelectedNode.GetRootNode(); + WmiNode rootWmiNode = rootNode.Tag as WmiNode; + + if (rootWmiNode != null && rootWmiNode.SmsClient != null && rootWmiNode.SmsClient.IsClientInstalled && Settings.Default.bSmsMode) + { + ConnectToSmsClient(rootWmiNode.SmsClient); + } + } + + private void menuItemHelp_About_Click(object sender, EventArgs e) + { + using (Form_About aboutForm = new Form_About()) + { + aboutForm.ShowDialog(this); + } + } + + private void menuItemHelp_CheckUpdate_Click(object sender, EventArgs e) + { + UpdateCheckAsync(true); + } + + private void menuItemHelp_Documentation_Click(object sender, EventArgs e) + { + Process.Start("https://github.com/vinaypamnani/wmie2/wiki"); + } + + private void menuItemLaunch_DcomCnfg_Click(object sender, EventArgs e) + { + Utilities.LaunchProgram("dcomcnfg.exe"); + } + + private void menuItemLaunch_WbemTest_Click(object sender, EventArgs e) + { + Utilities.LaunchProgram("wbemtest.exe"); + } + + private void menuItemLaunch_WmiMgmt_Click(object sender, EventArgs e) + { + Utilities.LaunchProgram("wmimgmt.msc"); + } + + private void radioQueryOutDataGrid_CheckedChanged(object sender, EventArgs e) + { + dataGridQueryResults.Visible = radioQueryOutDataGrid.Checked; + } + + private void radioQueryOutListView_CheckedChanged(object sender, EventArgs e) + { + splitContainerQueryResults.Visible = radioQueryOutListView.Checked; + } + + private void radioScriptPs_CheckedChanged(object sender, EventArgs e) + { + GeneratePsScript(); + } + + private void radioScriptVbs_CheckedChanged(object sender, EventArgs e) + { + GenerateVbScript(); + } + + private void richTextBox_Click(object sender, EventArgs e) + { + RichTextBox rtb = (RichTextBox)sender; + + if (_richTextSelectionResetRequired) + { + int firstVisibleChar = rtb.GetCharIndexFromPosition(new Point(0, 0)); + rtb.SelectAll(); + rtb.SelectionBackColor = SystemColors.Control; + rtb.DeselectAll(); + rtb.SelectionStart = firstVisibleChar; + rtb.ScrollToCaret(); + _richTextSelectionResetRequired = false; + } + } + + private void richTextBoxClassDetails_LinkClicked(object sender, LinkClickedEventArgs e) + { + Process.Start(e.LinkText); + } + + private void richTextBoxMethodDetails_LinkClicked(object sender, LinkClickedEventArgs e) + { + Process.Start(e.LinkText); + } + + private void saveScriptDialog_FileOk(object sender, CancelEventArgs e) + { + string scriptPath = saveScriptDialog.FileName; + try + { + File.WriteAllText(scriptPath, textBoxScript.Text); + } + catch (Exception ex) + { + SetStatusBar2("Error saving script to " + scriptPath + ": " + ex.Message, MessageCategory.Error, true); + } + } + + private void SetStatusBar(ToolStripStatusLabel toolStripLabel, String text, MessageCategory messagecategory, bool bLog = false) + { + if (text != "") + { + toolStripLabel.BorderSides = ToolStripStatusLabelBorderSides.All; + toolStripLabel.BorderStyle = Border3DStyle.SunkenInner; + } + else + { + toolStripLabel.BorderSides = ToolStripStatusLabelBorderSides.None; + toolStripLabel.BorderStyle = Border3DStyle.Flat; + } + + toolStripLabel.Text = text; + + switch (messagecategory) + { + case MessageCategory.Info: + toolStripLabel.BackColor = ColorCategory.Info; + break; + + case MessageCategory.Action: + toolStripLabel.BackColor = ColorCategory.Action; + break; + + case MessageCategory.Warn: + toolStripLabel.BackColor = ColorCategory.Warn; + break; + + case MessageCategory.Cache: + toolStripLabel.BackColor = ColorCategory.Cache; + break; + + case MessageCategory.Error: + toolStripLabel.BackColor = ColorCategory.Error; + break; + + case MessageCategory.Sms: + toolStripLabel.BackColor = ColorCategory.Sms; + break; + + case MessageCategory.None: + toolStripLabel.BackColor = ColorCategory.None; + break; + + default: + toolStripLabel.BackColor = ColorCategory.Unknown; + break; + } + + if (bLog) + Log(text); + } + + private void SetStatusBar1(String text, MessageCategory messagecategory, bool bLog = false) + { + if (statusStrip.InvokeRequired) + { + SetStatusBar1Callback d = SetStatusBar1; //SetStatusBar1Callback d = new SetStatusBar1Callback(SetStatusBar1); + Invoke(d, new object[] { text, messagecategory, bLog }); + } + else + { + SetStatusBar(toolStripLabel1, text, messagecategory, bLog); + } + } + + private void SetStatusBar2(String text, MessageCategory messagecategory, bool bLog = false) + { + if (statusStrip.InvokeRequired) + { + SetStatusBar2Callback d = SetStatusBar2; //SetStatusBar2Callback d = new SetStatusBar2Callback(SetStatusBar2); + Invoke(d, new object[] { text, messagecategory, bLog }); + } + else + { + SetStatusBar(toolStripLabel2, text, messagecategory, bLog); + } + } + + private void SetStatusBar3(string operation, TimeSpan time) + { + if (statusStrip.InvokeRequired) + { + SetStatusBar3Callback d = SetStatusBar3; //SetStatusBar3Callback d = new SetStatusBar3Callback(SetStatusBar3); + Invoke(d, new object[] { operation, time }); + } + else + { + toolStripLabel3.Text = "Time to " + operation + ": " + time.ToString(@"mm\:ss\.fff"); + } + } + + private void splitContainerNamespaceClasses_SplitterMoved(object sender, SplitterEventArgs e) + { + if (buttonHideNamespaces.Text == "+") + { + splitContainerNamespaceClasses.SplitterDistance = 30; + } + } + + private void tabControlInstances_Selected(object sender, TabControlEventArgs e) + { + // Scroll to the last line when Logging tab is selected + if (tabControlInstances.SelectedTab == tabLogging) + { + // ReSharper disable InconsistentNaming + const int WM_VSCROLL = 0x115; + const int SB_BOTTOM = 7; + // ReSharper restore InconsistentNaming + + NativeMethods.SendMessage(textBoxLogging.Handle, WM_VSCROLL, (IntPtr)SB_BOTTOM, IntPtr.Zero); + } + } + + private void textBoxClassFilter_KeyDown(object sender, KeyEventArgs e) + { + if (e.KeyCode == Keys.Enter) + buttonClassesRefresh.PerformClick(); + } + + private void textBoxClassQuickFilter_TextChanged(object sender, EventArgs e) + { + // Do nothing and return if no node is selected + if (treeNamespaces.SelectedNode == null) return; + + TreeNode currentNode = treeNamespaces.SelectedNode; + WmiNode currentWmiNode = currentNode.Tag as WmiNode; + if (currentWmiNode == null || currentWmiNode.WmiNamespace == null) + { + SetStatusBar1("Failed to filter results. ERROR: TextChanged - Current Namespace is null", MessageCategory.Error, true); + return; + } + + // Do nothing and return if current namespace is not enumerated + WmiNamespace currentNamespace = currentWmiNode.WmiNamespace; + if (!currentNamespace.IsEnumerated) return; + + // Parse filter text + string filterText = textBoxClassQuickFilter.Text.ToLower(); + bool notFilter = false; + if (filterText.StartsWith("!") && filterText.Length > 1) + { + filterText = filterText.Substring(1); + notFilter = true; + } + + // Don't do anything if filter Text is not atleast 3 characters + if (filterText.Length > 0 && filterText.Length < 3) return; + + // Clear UI Elements + ResetListInstances(); + ResetListClassProperties(); + ResetListMethods(); + RenameClassTabsToDefault(); + propertyGridInstance.SelectedObject = null; + + var cachedItem = AppCache[currentNamespace.Path]; + if (cachedItem != null) + { + List lc = cachedItem as List; + PopulateListClasses(lc, filterText, notFilter); + SetStatusBar1("Showing " + listClasses.Items.Count + "/" + currentNamespace.ClassCount + " matching cached classes from " + currentNamespace.DisplayName, MessageCategory.Cache); + } + else + { + SetStatusBar1("Cache Expired for " + currentNamespace.DisplayName, MessageCategory.Warn, true); + SetStatusBar2("Double click namespace to refresh classes.", MessageCategory.Warn); + } + } + + private void textBoxComputerName_KeyDown(object sender, KeyEventArgs e) + { + if (e.KeyCode == Keys.Enter) + buttonComputerConnect.PerformClick(); + } + + private void textBoxInstanceFilterQuick_TextChanged(object sender, EventArgs e) + { + // Do nothing and return if no Class is selected. + if (listClasses.SelectedItems.Count == 0) return; + + WmiClass currentWmiClass = listClasses.SelectedItems[0].Tag as WmiClass; + if (currentWmiClass == null) + { + SetStatusBar2("Failed to filter results. ERROR: TextChanged - Current Class is null", MessageCategory.Error, true); + return; + } + + // Do nothing and return if selected class is not enumerated + if (!currentWmiClass.IsEnumerated) return; + + // Save filter text + string filterText = textBoxInstanceFilterQuick.Text.ToLower(); + currentWmiClass.InstanceFilterQuick = filterText; + + // Parse filter text + bool notFilter = false; + if (filterText.StartsWith("!") && filterText.Length > 1) + { + filterText = filterText.Substring(1); + notFilter = true; + } + + // Don't do anything if filter Text is not atleast 3 characters + if (filterText.Length > 0 && filterText.Length < 3) return; + + // Clear UI Elements + propertyGridInstance.SelectedObject = null; + + var cachedItem = AppCache[currentWmiClass.Path]; + if (cachedItem != null) + { + List lc = cachedItem as List; + PopulateListInstances(lc, filterText, notFilter); + SetStatusBar2("Showing " + listInstances.Items.Count + "/" + currentWmiClass.InstanceCount + " mathing instances from " + currentWmiClass.DisplayName, MessageCategory.Cache); + } + else + { + SetStatusBar2("Failed to filter results. Cache Expired for " + currentWmiClass.DisplayName, MessageCategory.Warn, true); + } + } + + private void textBoxSearchPattern_KeyDown(object sender, KeyEventArgs e) + { + if (e.KeyCode == Keys.Enter) + { + buttonSearch.PerformClick(); + } + } + + private void toolStripLabelUpdateNotification_Click(object sender, EventArgs e) + { + var changeLog = File.Exists(_changeLogPath) ? File.ReadAllText(_changeLogPath) : "Change Log Not Available"; + bool bUpdateAvailable = (bool)toolStripLabelUpdateNotification.Tag; + + if (bUpdateAvailable) + { + using (Form_Update updateForm = new Form_Update(bUpdateAvailable, changeLog)) + { + updateForm.ShowDialog(this); + } + //string caption = "A new version of WMI Explorer is available!"; + //string updateUrl = "To download the latest version, visit the link below:\n" + Settings.Default.UpdateUrl; + //changeLog = updateUrl + "\n\n" + changeLog; + //using (Form_DisplayText displayForm = new Form_DisplayText("WMI Explorer Update", caption, changeLog)) + //{ + // displayForm.ShowDialog(this); + //} + } + else + { + MessageBox.Show( + "You are running version " + Assembly.GetExecutingAssembly().GetName().Version + "\n\n" + + "This is the latest version!", + "WMI Explorer Update", + MessageBoxButtons.OK, + MessageBoxIcon.Information + ); + } + + // Log(File.Exists(_changeLogPath) ? File.ReadAllText(_changeLogPath) : "Change Log not available"); + //Process.Start(Settings.Default.UpdateUrl); + } + + private void treeNamespaces_AfterSelect(object sender, TreeViewEventArgs e) + { + WmiNode selectedWmiNode = treeNamespaces.SelectedNode.Tag as WmiNode; + if (selectedWmiNode == null) + { + const string message = "Unexpected Error. treeNamespaces_AfterSelect - Current WMI Node is null."; + NotifyNodeError(treeNamespaces.SelectedNode, message); + return; + } + + // Check if we've selected a DISCONNECTED node + if (Helpers.IsNodeDisconnected(treeNamespaces.SelectedNode)) + { + SetStatusBar1(selectedWmiNode.UserSpecifiedPath + " is not connected. Right click to connect.", MessageCategory.Info); + textBoxClassQuickFilter.Text = String.Empty; + textBoxClassFilter.Text = String.Empty; + return; + } + + ResetListClasses(); + ResetListInstances(); + ResetListClassProperties(); + ResetListMethods(); + RenameNamespaceTabsToDefault(); + propertyGridInstance.SelectedObject = null; + + WmiNamespace selectedNamespace = selectedWmiNode.WmiNamespace; + + // Populate child namespaces, after clicking on a namespace + EnumerateChildNamespaces(treeNamespaces.SelectedNode); + + // Enumerate classes from cache, if they exist in cache + EnumerateClassesFromCache(selectedNamespace); + + // Set quick filter text back so that items are filtered again + textBoxClassQuickFilter.Text = selectedNamespace.ClassFilterQuick; + textBoxClassFilter.Text = selectedNamespace.ClassFilter; + + // Check if current namespace is already being enumerated + if (selectedNamespace.IsEnumerating) + { + SetStatusBar1("Enumerating Classes from " + selectedNamespace.DisplayName + "...", MessageCategory.Action); + SetStatusBar2("", MessageCategory.None); + } + + if (DebugMode) + { + propertyGridDebugWmiNode.SelectedObject = selectedWmiNode; + propertyGridDebugWmiNamespace.SelectedObject = selectedNamespace; + } + } + + private void treeNamespaces_BeforeSelect(object sender, TreeViewCancelEventArgs e) + { + // If selected node is null, do nothing and return + if (treeNamespaces.SelectedNode == null) return; + + // Save filter text before moving away from the namespace + WmiNode selectedWmiNode = treeNamespaces.SelectedNode.Tag as WmiNode; + if (selectedWmiNode != null && selectedWmiNode.WmiNamespace != null) + { + selectedWmiNode.WmiNamespace.ClassFilterQuick = textBoxClassQuickFilter.Text; + selectedWmiNode.WmiNamespace.ClassFilter = textBoxClassFilter.Text; + } + } + + private void treeNamespaces_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e) + { + if (e.Button == MouseButtons.Right) + { + treeNamespaces.SelectedNode = e.Node; + contextMenu.Show(treeNamespaces, e.Location); + } + } + + private void treeNamespaces_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e) + { + // Check if we've double clicked a DISCONNECTED node + if (Helpers.IsNodeDisconnected(treeNamespaces.SelectedNode)) + { + WmiNode wmiNode = treeNamespaces.SelectedNode.Tag as WmiNode; + if (wmiNode != null) + Connect(wmiNode); + + return; + } + + ResetListInstances(); + ResetListClassProperties(); + ResetListMethods(); + RenameClassTabsToDefault(); + + EnumerateClasses(); + } + + private void WmiExplorer_FormClosing(object sender, FormClosingEventArgs e) + { + // Show namespaces again so that splitter distance is saved properly + if (buttonHideNamespaces.Text == "+") + buttonHideNamespaces.PerformClick(); + + // Save Window Placement + if (Settings.Default.bPreserveLayout) + { + Settings.Default.WindowPlacement = WindowPlacement.GetPlacement(Handle); + Settings.Default.SplitterDistanceNamespaces = splitContainerNamespaceClasses.SplitterDistance; + Settings.Default.SplitterDistanceClasses = splitContainerClassesInstances.SplitterDistance; + Settings.Default.SplitterDistanceInstances = splitContainerInstancesProperties.SplitterDistance; + } + + // Save Settings + Settings.Default.Save(); + } + + private void WmiExplorer_KeyDown(object sender, KeyEventArgs e) + { + // Log Settings on Ctrl+Shift+S + if (e.Control && e.Shift && e.KeyCode == Keys.S) + LogSettings(); + + // Enable/Disable Debug Mode on Ctrl+Shift+D + if (e.Control && e.Shift && e.KeyCode == Keys.D) + { + if (DebugMode) + { + DebugMode = false; + tabControlClasses.Controls.Remove(tabDebug1); + tabControlInstances.Controls.Remove(tabDebug2); + } + else + { + DebugMode = true; + tabControlClasses.Controls.Add(tabDebug1); + tabControlInstances.Controls.Add(tabDebug2); + } + } + } + + private void WmiExplorer_Load(object sender, EventArgs e) + { + InitializeForm(); + } + } +} \ No newline at end of file diff --git a/WmiExplorer/WmiExplorer.csproj b/WmiExplorer/WmiExplorer.csproj new file mode 100644 index 0000000..d31dc66 --- /dev/null +++ b/WmiExplorer/WmiExplorer.csproj @@ -0,0 +1,237 @@ + + + + + Debug + AnyCPU + {781647DE-1788-4B7C-9289-D0323FDF562A} + WinExe + Properties + WmiExplorer + WMIExplorer + v4.0 + 512 + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + SAK + SAK + SAK + SAK + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + Icons\Icojam-Blue-Bits-Database-search.ico + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Form + + + Form_About.cs + + + Form + + + Form_ConnectAs.cs + + + Form + + + Form_DisplayText.cs + + + Form + + + Form_ExecMethod.cs + + + Form + + + Form_Settings.cs + + + Form + + + Form_ShowMof.cs + + + Form + + + Form_Update.cs + + + + + + + + + Form + + + WmiExplorer.cs + + + WmiExplorer.cs + + + + + Form_About.cs + + + Form_ConnectAs.cs + + + Form_DisplayText.cs + + + Form_ExecMethod.cs + + + Form_Settings.cs + + + Form_ShowMof.cs + + + Form_Update.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + WmiExplorer.cs + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + False + Microsoft .NET Framework 4 %28x86 and x64%29 + true + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + false + + + False + Windows Installer 4.5 + true + + + + + PreserveNewest + + + + + Designer + + + + + + + \ No newline at end of file diff --git a/WmiExplorer/WmiExplorer.resx b/WmiExplorer/WmiExplorer.resx new file mode 100644 index 0000000..36d3757 --- /dev/null +++ b/WmiExplorer/WmiExplorer.resx @@ -0,0 +1,3383 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 27, 18 + + + 126, 17 + + + 342, 19 + + + Filter Pattern for Class Enumeration. This filter is applied before enumeration begins. +Wildcard (%) is automatically applied before and after filter pattern, but you can specify the wildcard within the filter pattern. +Example: Win32%System + + + 218, 19 + + + Asynchronous enumeration of classes and instances allows you to continue working while enumeration is performed, however some firewalls don't allow Async calls for WMI. +NOTE: This mode currently applies only for enumerating classes and instances. Searching and Query Execution is still performed synchronously. + + + 432, 19 + + + 56 + + + + + AAABAAkAAAAAAAEAIADnfAAAlgAAAICAAAABACAAKAgBAH19AABgYAAAAQAgAKiUAAClhQEASEgAAAEA + IACIVAAATRoCAEBAAAABACAAKEIAANVuAgAwMAAAAQAgAKglAAD9sAIAICAAAAEAIACoEAAApdYCABgY + AAABACAAiAkAAE3nAgAQEAAAAQAgAGgEAADV8AIAiVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABc + cqhmAAAACXBIWXMAAA7DAAAOwwHHb6hkAAAgAElEQVR4nOy9aYwkSXYm9pm5e3jcEXkfdWZWdfVd3T19 + d0339JCzM7zEJTnkkCIFieABkljxn4BdEoIkkPoj/lgIEsAFdrmQCGiJpShSAGd3tcOZnd2dGU5P91RP + V3dV15VnZVXlnRn34YeZ6Ye5eXh4RuRRmZFHtX9AZEa4m5ubH++z9549ewZEiBAhQoQIESJEiBAhQoQI + ESJEiBAhQoQIESJEiBAhQoQIESJEiBAhQoQIESJEiBAhQoQIESJEiBAhQoQIESJEiBAhQoQIESJEiBAh + QoQIESJEiBAhQoQIEY4C5KgbcMJAdvhOANAO2zr936mexxEi9L/b927b+C7KRNgDHtcXbS8I3gOKlhAH + vxO0CzcC28LCr3v/tVCZ8Cdcx+Mu/EC7oAY/nbap7cz7iNB3AXmvuFcuSA7qt9oW/B6u/zONx/llUwgK + L4EUzG7CHRRgX5Cz2WxyeHg4FY/H46ZpxnVdN3Vdj1NKTUppnFJqmqZpTkxMpE6fPp3u6+tLplKplGEY + pqZpGqVU0zTNIIRolFJN/aeU6pRSDYBOCNHUB+1E87hACCGY93G9DxNCMM65yzlnnHMmhGCMMYcxxjjn + zHVdu1ar1QqFQn15ebl29+7dmmVZTc55UwhhMcaarutarus2m81mo9lsWuvr67VSqdQA4EIKPgt9DxKD + CHxnHbY/1nicCCAoxFqH/xpaQh0bGxvLJZPJtGEYKU3TUlTTkk9eupR//vnnh/r7+wdSqVR/LBbrMwyj + f3R0NDs4OBg3TTMWi8Viuq4bmqbFKKWGJ8QAAM45hBD+ZzsIANihzGcFhGz/GhJC/E/oXrseWdiu69qW + ZdmWZTkbGxvN5eXlquM4G7Ztb1Sr1c319fX1mzdvbty5c6fEOa+5jNUc267W6/XK8vJyBYCNloahPrzD + /7CmcaJxUgkgKOhKsHW0BN7I5/O5eDye1zQt9+KLLw5dvnz5VC6XG03E42ODg4Mjly5dymez2YwZj6cN + XU9rmhYnhACEtG6K92Iy14XLWEuwhWgT4MfmbThBCD4jov4TAkoIqKZB13W5P/iMhAAXApyxhuM41Waz + WS2Vy5WpqanSxvr6SqPZXCxsbi59/MknD69fv77BOS83Go1CsVgsAXDQIgHX+wSJQpkiJwonhQCUsOsA + DLR6cjORSOR0Xc9cunRp+LXXXnsil8udHxoaGn/llVfGBgYGRk3THDNNM2EYBiilIISAcw7btmUvwgUE + du6xIzw+CGsUsVgMlFIIIcA5h+M4sCyrbtv2yvr6+tLVq1eXVldXH1ar1XsffPDB9O3bt5c9AikBsNAi + BQctYjgRJsRxJYCgQ81ES/gzuq5n3nzzzXOTk5NPX7p06dKbb74xmc1mJzKZzEgmk43rug7OOSzLAmPy + Ocie+wivJsKJglQEpWtI0zSYpglKCRhjKJcrzUqlslwoFGa///3vz87MzEzNzc3deu+99xZc160AqKCl + IdhoEcKxxHEjACX0MciePkkpzb755puXJicnn/uZn/7pl0ZHRy+Pj4+PZrPZjBJ0xdycn0gtLMIJAqXU + +xDEYiYopSiVSpXFpaWl1ZWV61//N//mo+np6U/ef//9ac55CYByRlpoOSKPDY4LAVBIoTcBxBOJxMDz + zz//3Fd/4Rc+f/ny5S88+dST55OJRNa2HXDO4LoMnDN/HChChKMEpRp0XQOlGmIxA7VavXT37t3569ev + f+dv/uZvvvvxJ5/caDQamwCakERg45gQwVHLD4Hs6RMAEmNjYxNf+9rXvvyVL3/5Z5999tlnCSEm4xy2 + ZYFHOnyEEwLlV9CkX8G68emnN775zW9+/S//8i//bmlpaQ5SK6hDagRH+mIfJQGoXj+VSCRGf+d3fudX + fu3Xfu1XhoeGLrqMwWo2IaI+PsKJhgABgRmPQ9c0rK6tTv/F//Wv/vU//7M/+9e1Wm0ZQA1SIzgyEjhK + 6TIBZJ5++unLf/Inf/I/XH7++S80Gg24rnuETYoQoXfQdR2JZALXrn38n3//93//f1xYWLgB6TS0j6pN + R0UAGoDM+Pj4E3/+5//nn05OXnilVqsdUVMiRDhcZNJp3Lp9+4Nf//Vf/0erq6tTAKo4opEC7QjOSSBt + /uwf/MEf/P67X/jCP6yUy0fQjAgRjgaWZeH8+fOnNtbX165evfoRWsOGh46j0AA0ALkvfelLP/ZXf/VX + /8fCvfm0DMKJbP0InxUI6IaBzY3NB7/5W7/1X09NTf0I0hQ49JEB/bBPCEkAsd/8zd/85Xw+n97czGJj + fR2arkcUEOGzAUJgNS309fWdfuedd35yamrqGqRT/LNBAPl8Pv/SSy9dAICzZ8+CEoL19TUIIYdQIiKI + 8DhCAKCEgAuOZqMJSik4Y8OQcngkr/1REACNx+NmMpnUAekZPT8xgWw2i+XlZVSrVQjBQQjdcZZYhAgn + BfJVJrBdF47jQAihJJ6jNS390HEUBAAhBFFhu2oSTv/AAPJ9fSgWi1hbW0OlUoFj2wBRkzcizSDC8Yca + 0Pezu1AKCAGXcbiOA875serYjoQAOkHdmP7+fvT19aHZbKJUKqGwuYlGo4FmswEhFBm0JmtEiHCcoGYZ + Ci8ISAk9Y8zfd5xwbAgAQFsyjXg8jng8geHhYViWhXqthmq1inKpBMu24DgOmOv42gEIQOSfCBF6i0Dc + HqFUqvcCoJoG5uWNCE9OO26Cr3CsCCCIoIkQi8UQj8fR19/vz9eu12qo1+toNpuo1aqwLDm/n7kuuGdf + EUJAaLumcDwfQ4TjhvZUL638ARBCzgbUNAjOZbA6IWCcgXm2vQIh5NjnmTi2BBCEEMKb2y+/G4aBXD6P + fF+fz7ReEgc06nU0LQuOY8NqNtFoNMCYzOIkuAAX3E8nKTUGz6QIU0PEFI8vBLx5Ji0o7dF/DwigaToo + Jb55qmm6/74xxlpZho6ZXb8XnAgCCCOcc48QglgsBtM0kctmZVZHzsEZg8sYXNeFY9uwLAtNqwnHtsFc + tc+B4zhyDkLwxVDfg2Thn7D9RdlCHhF6juBz6gr/EQWfjwClGjRNk+o7VNYwAV3TQQKZgVQPTqkGIUTb + PJXw+3dScSIJoBO25OuDjCkwKIURiyGZSPg5/iAEmMfkymxgijAcF47r+IRhOw6E4H7CT+4fJ8A5A2Mc + nKsMUIeP/b16h/jienbydvvbBEl4zzTcUwdy/xFKPRuc+MNsyg2kBFfTNGiUAp4wC9VbB+JNBADu9eic + 81YewV0kdz3peGwIoBNEIHmnCBCDIgmV3UXXtDZyCD9yLgQEYzKhJBcQnPkEwhjz/BUeOTAO5r1Emq75 + iSglN3FpN4rWy8U5980S4X0XfucWaskuXkbVm+3uBnUq2SHRaXhsK4C9aD8qJ6MSdhrIzac0NWWWUUKQ + TCah6bpM9Ok9K8uyUK6U/TiRoGc9KNB+rsdQlijiZRUOCvfjLeLb47EmgJ3gs3uQ6YOkESovX0IAgsrQ + rbCTJ3AMIQTJRALCcxwFywBdXroO5zyU7aEyh9G+4DkIIShXKqiUSgG1m2JwcBBGLOYLMSEElWoVjUbD + 79GhtL7Aubo9vwhb8ZkmgL0iTBJbVMQQATDGpGaxzcvYUcXcbc90CITRtR27aeMeCIB7w2dyt7yvjHNQ + xtoIgLnuY6+WHyYiAjhJ6CZ0x0WV3S9h7OYU+zw+QjsiAnjcsVeV/lFMgP1gp/NFqnxPERFAj+A7vcPq + 6kHa2McFB2labCnabmZF6v/BIiKAk4zj5gPYjwnQQbBFh30RARwsIgKIcLTYTqA7mQARARwoIgI4DBzU + KMCjOAEPwwdwAJpFp/vQSQOICOBgERFAhKPFHjWASPwPFhEBnGQ8Tj6AToeEjpVfIwo4SEQE0EPsOcjn + MzwK0E2wo2HA3iIigMcdJyQOYNt9kQbQM0QEcBxxkE7AXrSj2759mABdNQAv6Yb/u8vxER4NEQEcMY5F + j3ZM1WwByMlUwRl9x+F+PUaICOAwcNgCdti+hF5FAqqZfsFNj9K+CF0REcBJQK8E+jB9AI9gvgi1PYoD + 6BkiAjhOOOzJNgdd737O1W3EJOwDiAjgQBERwGHjAITkwJ2ABzBpp1f1btEAIhwoIgLoIR65t+qh4O3K + 7u527p3qfZRRgJ3uUTQbsKeICOCIsa8Xuhc+gCOAgHcfQtl1j0PbHndEBHAYOEpB7YXJsdt6d2kCdE0r + 2iv/RQQfEQEcJzyqoPfKZDjI47cxAXYKDoqGAXuHiABOEg5D0PczDPio7duFH6D1NaKAg0REAIeNXarO + O5bZ4fhdHdtr02KfowBR3v7eIyKAk4xeO/EOQwA7OP+6tWPL9wj7RkQAvcQuBLTnKu1+euo9nGPfpkWH + +xDWAAQibeCgERFAr3CQC0YelO3da0HfS4z/bsqFykc4eEQEEKEdvRLiR0R4TceIDA4WR0EAAjjZSyrv + GQfllDvonr5XXv29tGMbgRa7KBNhfzgSAmCM2Ty0auvjiP0E0OxYxit3ID31fgljr6HAncb3u00G6rBv + p5XGTxQIoQCObH15egTn5BsbG4Vr165NH8G5I5xwPDaCD0A3DABYAeDiM0QArhCi8Ud/9Ef/bHV1dS64 + vnuELhCt9Nhde1dVZrvePFhmuzH6nc7XodyO59uh7Z13CfDAsUHt4SSDEIJsNosbN2784Bvf+Mb/DYB7 + n0OHdhQnBYDl5eXCN77xjWvPPvvs0Llz54YIIaZaG/5xACEElJCjHwbc/uTHwhQRABzHAefcnxdACIEh + e8g2oXccp+PEoZOAwDWtf/d73/v6H/7hH/7RysrKDIA6pBZw6DgqAmAAtNXV1cZf//Vf//DJS088A4iJ + fL4Puq6D0qNQTA4WhJC9X8dxGe571Hr3MYLQiQB0Xd9SznWcE2UGEEJANQ0apXAcB0uLi5ifm/2P//if + /MEfl8vlNQAVAM2jat9REQAFEE+lUgO/9Ru/8d9XioWfuPbRR2RuZgaVagVm3EQqlYKmab4QnTTNoI0A + jkogvTJADwKBDqper4ztOG3JPxUBhJ2GjuseezOAEOK/u4wxlItF3Jufw9SdO1i4Nw/HsS9dvHix//qN + G99zXbcKwD6qth4VAZgAUj//8z//q5978fI/qtXrRDd0FItFzExP49PrNzA/P4dSsQjHcRCPm4iZcWia + Bk3TcBJMhUfSABSOMga+V+feoV7HcSBCBKDpWwep3GNHAASUymdNKAWEgGVZKGxuYnFpEbPT05ifm8Pm + 5gYYc2EYBhhjmJiYeHazUJheWFj4FFL9Z0fR+qMYBqQA4k899dQTv/d7v/sbH77/PuLxOAgIEJMFuOB4 + cG8B92bnYMZNpNMZjI6N4tSp0+gfGES+L49cLg8jJg8gADjn0mnE2PEmh14IWK9Mg0Ost6NFv5vhxUOC + clQTQgBCPLIiYMxFrVaD1WiiWquiVCqiVq3Bti24rguNUsRiBkzvXQUAAYF6tYZf+sVf/OVbt25/e319 + 3Qbg4Agu8SgIQAdg/N7v/d4vv/vuFyfvzc5iZWUFscANCkIIgWazidmZWUxPTUPTNKTSaaRTKfT192Nw + aBh9fX1Ip9NIJJNIJhIwTHOrx9tLLql+HwYO7CyPIGAHEgi01/KPIqiBZ7R1VygleI+fW5uQh+C6Lmzb + huM4sC0L9XodtVoVzXodlm3DsW1wIUAJAaEUZiwO0+x8Htd10T8wiJdfe+2NL7//wU/8xV/8xb+A7BgP + XQs4Eg0gmUxmr1y58hoA/Bc/93P49//fv8PayioMw4AaFuz0sNV2zhiKxSKKhQJmZ2YAIWDEYkilUkim + UkilUsjmcsikM0hn0kimUogZMeiGAcP7wKtLkQNXL29ADT0MotjTOXqonvfcB7Cftqt79IihwGGBJmp0 + Rgj/O3MZGJMf13XgOA6spgXLsmA1m7AdKeS2bYMx5g1CyHo1TYOeTO743qrPwMAAzk1eAAGQiMefhjTF + PzsEkMlkUsPDwwkA6O8fwC989Rfxo6sfYuruXVhWU9r5lHZPFdUBQgjYto2m1cTGxgYIAQiI54WlSCSS + SCQSSCQSMM044vE44kn5O27GEU8kYBiGz+DUs+EppfIBci4HaoWA4AICwnsXA4Th7Q+3aw8Xcei2977L + e8fsxwToNjS4bZ2EtL8fgd9qNSHuCZxvHnLuCbgLx5G9ues4cFwXruMGftsQ3Gujen5e/aZp7iluRb0T + QggYhoH+gQH09w+Aex0Z51xAEsCRjGseBQEQAFSFAgshEI8n8NbnP4+nn30W09NTWJifR71eB+fc96YK + 7P4OCf9PawtjDOVyGaVSCcJjfiXc6r9hGDBNE4YRQywWgxEzEAt8N4wYdF2HrmvQNB26oUPTdP94eOPT + qk5Ntdt7YYQAILjfxrDqK0Lh0TuSR69Mg0B5YO/k4Y/Rh4XUA/H2+cIBz2EqWkJHCAEBkUSrygU+Spg5 + 4xBc9d4cnDO4zAVzW/8Zc+F6/xnjANrr8tvldRamFof/tpG9SaZ6T1XdlBAYpvRjpdNpaJoGxo7E39cR + x2I2oLpZfX19ePXV1/Dcc89jZXkFi4sPsbG2hmaz6QV/oCVsB3Li4FcBCKDZaKLRaHgvHNrOK89NPS2B + BL5TGIoYdAO6riMWi8GMm9CoBk2jcixYkQWl0nNM5LW06gKg6vTq3dW1Pqp6vQ0hiMAfsVN5ISP2tvTs + qucN+2EC28E5OOdoWBa464ILDs7kNkA6dxln4C4D4wyO48qe0zufCAgzROtdkrRCPAGW91DXNOha4JU/ + yD7Xe1/U8zJiBmKmiUQiAV2Xpq0yMY4TjgUBKKiHHo/HcX7iPM5PnEe1WkWlXMbq6grKpRJq1Rosq+n3 + IgQtz2yvdCgR/iWC2wQEZ7AsF5aFNs+1aKvBMylUW7t8APW9dV2+WUI1UI8sZA8pAEKB4Mvu/W7dj4AQ + +B1zQF1WbfXll8vvUEKlemX5h/sX3+o9heAQXI7eSB8NhxAtDU8EygfP115HUJBl+/3/UO2W10MJ/PvY + TYp7qU93IkFdN6QvwNBhmnEIwO/tlcZyHHGsCEAheLOSySRSqRTGxsfhMoZ6tYparYZKpYxCodDmmQVC + ZBD4fyzQqafuoOb7QiZ4zwaGgtXu++50uL8ksE8JbstvRjqX7VLXkaCb+eUF+ShSNWOmT0SarrWGoYXw + hf8441gSQBA8FBySSqeRzmQwPDICIQRc10Wj0UCjXoflDc/U63U/sMRlLhhnvhq47eSjY/LuReghdiGP + BMosI74Sous6CKG+XwoE4Ey6KpXmwlz32At8GMeeAIIIOm3Uf03TkMlkkMlkAMC3DxljcGwbzWYTlheU + 4ToubMeGbVm+LdYWK+DVSdrUzogVHhd0e5ZS4L3RHggIxj2Ti7ap70IIUEr9UQWFkyb0QZwoAuiELd5c + 77+u69A1DYlUSnplg8NCTDqUGJOeZKaGglwX3HNKMc5lOdcFa7PfRBftUARMVuX176ZGqhIRuQQRFlB5 + /9rv926nj3eqi3PeOp547w5vd2B6Hl/Zo4dU+JMs6N1w4gmgG5QdJpTXNeCU0zQNVNMg44GIv88f7xet + 4CDF9iI0rsw5byujfqvhPQDtcwGCTsEt3vTASx584TpdU4+w37qDNn+g0l3Z9ISQtvunYBiGfw/lAAmB + 67iwbFtWG3DG+scGRx1UG/zmBDTIwL5u3z8LeGwJYDsEQ0x9omjt9L+rob/wdv+78lQHtquIQkIIEvG4 + H3EYPHe34bSuYcrbDL8dyPZQGaCDUOxwzCOLjJBj/pVqFdVq1R9Dp5SiLy/ne/iESgjKlQrq9XqLWEIm + YbDtnzVhfhR8JglgtxAh4d5CAGGBDQlC0Cxpew0Dw5fhQJQuDektAexWgEP3ANiBHLrVq8b4AcAfzpO9 + eFuIdkADAwDhT8KJcFCICOAIsV2PD3QQrr1u71Bur8TQtd5thjT3XBc6myBhsgHga1gRDgYRATzu2EEo + 90Qm+1H1u2Gn84XP2WMC4Jy3jeErx/CWsO1tnIPhEPMDjV49YEQE0EN0tEF321ufJBykZrFN+V5ACAHG + OZg3CuR6Iz+cc1iWhVqthnqjAavZ7BrGGxw+1jRNTjRLJOTUdMMA8eaFqIQ2wUxXR42IAHqER+L742Lr + HyP0IieAEnrXkdN+GedoNhqo1mqoVioolUpYXlpCJpMBpQSFzU1sbGyAM7ZtTy4AP09FKpVGuVJBzDQx + NDwMMxZDOp32U93puo64aUIIcaSqQUQAEY7WBxBwlG7ZFS7Tre5dgnPuTQV2ZFh5rYZSqYSl5WU0G3Uw + x8XqyjI0TYNt21hdXoLgraAgTds5g169Xke1WoWa/ptIJFDc2ADjDGNj47BcB6Mjo8jlctB1HY1GwwCQ + hEwOeuhZgSICOAxs0/P23Al4GD6AAzABug5/HoAPQAm+ZVmwbRulchmLDx+iXq9jbXUFzHFQqVS8RB/E + jwnRdR2aRgEihT9umjJrtafCt2b4SfOh2bTgOA40Lz6EMYZKpeINdFBM3b2DZDKJWqmEWDyOpaVFVCqV + YQADkJmBKWSC0EMjgogAIhwtthHoTnP29zIKwDmHY9syq49lYX19HUtLS3KKeaOOcqnkBw2pKdyxWAyZ + XA7pZAr5gX4M9PX76eZiZsyf0k3l3G0ZNepFi9qWhVq9jmq1guJmARsb66iUK6hWK2g2myCEeKnEatA0 + DZvr67g4OfHOf/nLX/vjO3en/p/pmZm/L5fLG5Bk0MQhrBgUEUCEYzEMeJAQQsh5IJaFZqOBlZUVLC0u + olQsYHNjA5ZlSaE3DJjeXJJ8/wBOnT6FsdEx9PVLodcNQ2oDwbgEL5BL/W+L5SAUBALcO4Yxhmq1ilKx + iOWVZTxYWMDG+jqq1SqY52RsNptmMh7/ibdef+3Lr7788t/fvH37X/3oo4++U6vV1gE00CKCniAigOOE + z7ATcLdxADtpDJxzNJpNWM0m1jc2MD83h+LmBgobG2g0m9C8nj6ZSmFoaBjnJ87j7LnzGBgc9Gb8EW+u + CG9fhCSgiajRHQH4QU1yH9sShZhKp5HJZnHqzFm8+OJLKJdKePDwAWamp7G8tIRmoyFNhXKZUk17+/Kz + z3z+6Sef/M8//PDDf/nJ9Rt/z5hbglw5yEYPlg+LCKCH2JN9fxQ4Rj6A7k3sPv4ehLLzG40GKtUq7s3P + Y2V5CWsrK6jXatANA8lkEulMBhMTk3jyqacwfuoUzHjcmzYuh/+CAk8oBfF6ez97kRAILk/cPpGoFc1J + CQEH/LrV9eb7+tA/MIinnnoaa2trmJ66i+mpaZRLRXDOUa1WiaZp71554/XXn33mmf/3799775/Pzc3d + gSSBOg54JeGIAE4SDtoJeNDYxyjAbp2AnermnKPRaMCyLCwuLmLh3j2sLC2iVCqBUopEMolsLo9Lly7h + meefw8jIKCilcL0koMFx/GBWIsfLAByPx2GaJhzbBhHCd+rJSUzCb5Wu62CcoVFvgDMGquv+9aksTCot + GKEUY2NjGBsfx3PPv4Dbt2/h7q2bKBQ2lfMwEY8Zv/qzP/WTb35849P/7f0PPvh6o9EoAlArCR3II40I + 4IhxLLSEg/IBHDB80epiAqgkHI1GA7VaDXNzc1iYm8X62hps24YZjyOdyeDCxYt48cWXMH7mDMAFXOb6 + 6r3qsTnnsG0buqbB5QzJZBL5fB4CMhNwLBYLJH+V6c8A+CtVqdED18tOJYS3QlChAM657wQMTi5zGQOE + QD6fw1tvvYVnn3kG1659hFuffop6vQ7XdVEqFieeffqpfzo5cf6Nr//bf/e/rq2tzQCoQfoG9m0SRARw + GDhs2/uwfQC9MgG8nriTBiCEgOM4aNTrKBaLuH37NlYWF7GxvgZN15HJZjF+6hRee+NNTF64IBfnVBl7 + As4728scRSlFNpuFaZpIJJOwbZk4xnEcrCwvo1qtwrYsGRYMgHMGCC9TkLc0WCxmIplMon9gQKayS6cx + NDwM13VRqVT8ttq2XApQ0zQISK3AZQzpTAbvfOFdPHHpEj784IeYnZ0BFwLVSoWYpvnLX/25f/jM1Y+u + /fHVq1e/B5lKXJkEj4yIAE4yeiHQj+ID6NX51P6QBqAEt1arYXV1FdN37+DhwgKqtRoSiQTyfX147rnn + 8cprryGTycD2Er4owedCwHUcMMYQM01kMhkYug7HcVAoFjB19y4KhU00Gg3ousxJYMZN5HJ5mKYJTdeg + Ua2Vx0AIOI6Ner2BpcVFPHhwH5wxGDET+Xweg4ODGB4ZQTabxdj4OIqFAorFIsrlMtTUZwLIkGTGMDo6 + hq/81E/h0xvX8cP330e1VoNlWaCUPn/ljdf/NJ/P/c/f+tZ/+BvIuIEa9jFKEBHAcUIveu7DFOgDNhla + Kb5bUDH69UYDDx8+xNzsDO7NzsJlDJlsFqOjo7jy9tt44tKTEJzLVYcDPb5lWRCcIx6PI5VOAwA21tex + tLyE9dU1CMGRyWYxMjqGfD6HbD6PmBGT4btqwRqVjZgErkt4cwo8YqnX6ygViyhXK5i6exe3b91CLp/D + +PgpjJ06hf6BAVSrVayvraFYKslcg946Eq4r5fmFF1/CyOg4/v6738GD+wsQQqC4uTn47JNP/i+U0OFv + fus//JkQnED6BR6JBCICOGz0wnbulT3eKx/ANjEEW4oGy3sCXKvVcG9hAQvzc7g3NwuAIJ/LYfLiRbzz + hXcxPDwMx3HAhZBzMiiFbdlwHBumaSKbzcJ1XTxYWMD8vXuoVioYGBzApScvYWRkFMlkEkYs1jbG7ydy + 4VyuPBT0RXj/NUKgeQsCJtNpDA4NgTGGRqOBarWKleVl3Lp1E7dv38LpM2cwMXEBExcuoF6tYnFpEaVi + yU8DD8gVk0dHR/CTP/Mz+P73voubN26AUIpioWA+efHCH8ZNM/WNb37zf7dkRuxHIoGjWB48lk6nB377 + t3/75xanv3UAACAASURBVPP5/MgRnP9QIFeZecTb+yje/lC5nsQH7Kfeba6JALBsG8x1faccIcRbNdpz + BgoBy7ZRKBRw9+5dzM/O4P78PAilyOfzuPzii/gHX/lJ5HI5OMFen3M063UAcgguFothYWEBH330Iywv + L2N8bAyXX3wBly49ieGREXlOlRouMA24U+IX3x/RdjleeW9aMSFERhdmMhgaGsLw8AjMWAzLS8uYnZlG + o17HwOAgxsbGkYjHUa/VYNt2W6ixYRg4PzEBXTewtLToa0HDQ4NvDA4Niqmp6Y8hfQF7jhyMCKBHUFND + d8K+ZrftV4XfaxzALup7pGMJgWVZYJz7sygJITBVSjWl9tdquHXrFmbu3sXD+/ehaRr6Bwbw6uuv490v + /hgMXYfrxfNTQnwnYSKZRDabxdrqKj768EMsPnyIcxPn8dLnXsbE5CRSqbRvz7PAmP2Wy/PauuvbAbRr + EJCL3vT3D2BkZATJZBLz83PO/NycJgCMjY1haHgYzHVQrdUBzz+gsiCdPnMGyWQSD+4v+CQwOjz8ei7f + 15iZnb0BOSqwJxKITIAIj4YDJIquIuWVsx0HtXod9+/fx+zUFB4+kMI/MDCA1996C2+8dUVG73nCSyhF + vVYDc13k+vrgOg6uffQRFu7dw/jp03jtzTeRz+dB0LK3d0Jrfcftr7jTQjTBY1QbY7EYzpw9i0QyWS4U + Ngt37tw6/fDBg/gLL76IyQsXkc3lMT8/D+a6crTAG/V47vJl6LqG//Ttb8OyLJTLZfLUExf/O0BU/+6b + 3/pzSBKoY5dDhJEG0CO0aQC96Kn3cCywg6AewHDdI5sWSsjVstveZkIIYqYJlzFUKxWsra7i2o9+hJnp + Ka/n78drr7+JN69cgZ+73xuPr9WqEIIjn+/Dxvo6rn7wPmq1Gl5+9VU899xzSCSTcmHRbn6HDtu7CX4g + KLBFZGrkIvjpcgyl1D116tTG+Piph+trq9qdO3fShBCcOnUauXwOlXIZjuP4fgHGGEZGx5BKp3F/YQGM + MTSbTe3smbNvxBOJ2fl79+YhtYBdMVtEAD3Cbk2ANjyqoO9XUPdwnp4QESEdCcDQdTTqdWwWCvjggw8w + M3UXjHP09/fj5Vdfw5W33waBHBkg3urC1WoVGqVIZzKYn5vFjz78EIPDg3jzrSsYGRnx07gjcJ6dsFMS + ED9eIegb2K7eQLiwZVlNXdedZDKpnzp9ZpUQUrl9+1auUq1op8+cweDgIOr1OhqNRmu4kDGMjIxC13U8 + uH8fANBoNGJnz5x9aXll5fulUmkTkgB2jBGICKBH6EoAh2Fj91pj6FZuH8eGCQCQcfbVWg2ffHwNU7dv + oV6vI5fP47nLL+DHfvzHoVEKLuQS3FwIlEslb1XmOG7dvIlbNz/Fc88/jxdf+hzi8XjH/H7dErOGF0/t + 1JNvf4kCHR2IwXNIP0XTiMWqAASl1BweHq7lsrmlmenp3PLSUmz81DiGhobRbDRQr9X8SEIhBMbGxsAY + w8OHDwEAjLnZS088cXpmbu57zWaziV3kFTgeickitCPYo2wnzOFe5xHOs1P9u2rHTvVv18YuwuG6Lur1 + OqanpjA7PY1yuYxMJoPJyUl88YtfhGEY/jCfAFApl2B6CTuuffQjTN25jTevXMGzzz0HSghcx+m4pFcw + /Xjbgi/BhWACn7Bgd/p0vswO55L3RQghuBCCMcaY67qJ0bEx48rbb39qWdbm977zXViWhYtPPIH+gQGf + JGU9Aq+89jqeuHQJQsjZixrBj335S1/6XQAZAAnskJ0uIoBeYheCI8Q+BGyXbdiNoO8oqDucY8djO6nJ + oeMVOOdoWhbW19YwdfcuVldWkEgkMDo2hi/++Jf8cXxA9qKVchmapkPTdVy79hEe3r+Pd774RZw9e07m + /PMy/IbXGugmtMGhPH/Fog7HdKtjL+W8tilwzjlzHEfPZDKJK2+/fUvTtOXvffe7qNfrmJicRCaT8UmA + CwFN03Dl7XcwNDwMAKg3GhgZGvzt11579ccgU40Z2IYEIgLoFQ4yDfR+e/qDbke3tuxXY4AUCtu20ajX + cfPmp1h8cB+EEPT19eG119/A6VOn4DgOCGT67Wq1Cs4ZzFgM1z/5GIsPHuCdd7+I8TFZLtiz88DYfrff + Owlvp7raiEVpGdvV004oQgjBIb32XP12HIfE4/H062++cZdSuv7+D94DYy4uXLwIM25Kvwdk+HA2m8WV + t78A0wtCqlYqsc+98MJ/m8/nxyFJoKucRwTwOGCvJkMvNY7dYBttQM2cW1hYwNKDB6jXashms3jqmWdw + +cUXZUw/pPAr51gqlcHdO3cwPzuLN698HsMjI7BtqyXcqudV5+0kuEEBD6n8YfUfofa2Ha80h6Cghwkj + eM2yQmUGBMEcxyGxmJl9/Y03bjmOU/jg/feh6zouXrzor1wMAI7r4uzZc3j2+ct+Owjw8ttXrnwNkgBi + 3R5FRACHgd2q2Mehp99OVd+mXLcyO163EkxIWWg2m6jVari/sIC11VXEEwmMjI3hjTffkim6hPAj5Gq1 + KjKZDB7cv4+bn36Kz73yKsbHx/1U33yb3riTBtCmpgeOU995SJjbli0LlPeFX2z1G4TP47VT3R4e+AgA + 3HVdJBKJ5CuvvvZpoVCsX//4Y2QyWZw+cwact5ymXHB87uWXMeyNdNTrdZw/e+Y3L1269DykL6BjzM9R + EIAAwDRNO55LpRxnPEpPj90RzoGcb4dz7VSOMQbbtnHv3j2ZrZcxZHM5XH7hBYyMjoI5jhzrpxSFYhEx + I4ZqpYKPfnQVT1y6hAsXLvgJNzr16HtR71mgFw86BL3uuuNxrAvhhOMNQlqDAMA454JzrjQB9RFCCOG6 + Ls3lctpzzz//6czMjJifn8f4+Dj6+vtb/gDOkUqn8cqrr8lJS4Sg0WgMv/bKK/+NruspdNECjoIAWLFY + LC0sLGwewbkPFdv1eJ3UyW5lDlLwtq1nt4TRrdwe2h1uuwptrVQqMptPoYBUOo2z587j8uUXfacfpRS1 + Wg2cc1BNw8fXriGVTuH5Fy77qbi7CrborM5veRZdtIZO8wO6lfHP06W8Oi8Cdr+QTkAeJANvP3ccJ37m + 9OnG5IULd6599BHK5TLOnj0HQ2lFkKbA5OQkzp6fkBmRHQcDffmfmpycuAwgjg7D/kcRB0C8GVLsq1/9 + 6j8ghDyW4cht2V9OEtTLeRDltiOBUD3NZhPVahXTM9O4NzcHy7IwODSEd979As6cOQvXdUEoBWcMm5ub + SCaTmJudwdzsLD7/zheQSqXheOm9tgjzDu3bQgbAluXHIURrFeOdCFyV3+YYbyjPEUIsxWKxJqU0mOvP + 51fRDmNgYGBtaWkxUyhspiYvXAAhBKVCQQZCQSYoSaVSmJuZVnMb4kNDQ871T29+DzKVWFuE4FEQAADQ + Gzdu3F9ZWVl79913XzBNMx1eKvukQ01I2emKdnXNOwnSHoS2V0ON+yEMAaBSqWBzcxNTd+9iZWkJyVQK + T1x6Em9euQJC5fHeVFgIIWA1m/jw6g/x7HPP49z5877wt07XLmzBbf6+DjH76hgVLRhy2LWVD+YQFJ2u + LzRtWB3jJSVpWpZ1P5FIlAkhnFIqwuWC/2XzBHRdp6l0evPWrZvjmXSGjo2NoVQqwbZtf0JTNpfD5uYm + 1tZWwTlHXz5/Zn1j8zuFQmEVoXyCR0EAytlBrl69eu9v//Zvv/PKyy+fyuZyE2oq5uNABj3RAA5a0A+K + WPZaPlSOMYZyuYz5+XnMz8yg0WxicGAAb739eZw5e1ZOE6YUjuOgVCohHo/jxvXrsG0br7z6qm9CdDxV + 6H97MzqQhLc9HP7bRgLtKrw8vlN5dX8D5bxeeZMxNh+LxRq6rru6rruhQ0XYPAn8pul0ulGv18TDBw/6 + z01MwDAMFDc3/TZoug5d1zE3M6PuSzKby23eun37fQAWAiHCR6UBANIpkXzx8uUvC+7+/I8+vJqoVqqI + x+NIJpNyCaaTqEJ7CCeAPBCBfBQclKq+l3J7KS/kuH+xVMKtTz/F+uoKNF3H5BNP4POff1sOd0HGzReL + RUAIlMtlXP/4Gl565VX0DwzIBJ+BITb/3MqWx/aaVsfeu4MfYMsxnTQO73xBQhBCwHUdNL3kpcx1DS64 + petGzev9lR9ASX7441Xj79Mymez67OzMWMwwjNOnT6NcbmkBQghkslksLy2h6CUlzeXzubtT0//esiyV + VRjA0RFADEDyzTfeePeXfumr/7RcLmWazSbm52fxycfXMDs7i3K57CdTMGKxLUsqH3cNYV8awFGq9Afp + A9hFeSHk0N/9Bw9wf34ea2tr6Ovrw+defgVPXLoknX+EgLkuCpubiCcSuHH9E2i6gcsvvOA73MJ1tvX8 + O9nqQLugK9LocGxwe5gwCORUZOl4ZHAdB81m04tXqMN1HQgICC4o1WiWMV6OxWINQggPVN/uj+hAPpxz + kkgk7GajgQf3Hwyen5iApmkoFAp+fEAsFgMXHHOzsxCcI5lI9Fu2ffXh4uI0AouMHIkTEEAqm82O/eE/ + +cf/U71WnRRcIGbEEIuZoBpFqVjE/Pwcbt64jts3b8lFFMtlPzuKWl5ZreQCHD9C6EoAexWc3aBXhHEI + 9TLOUavXMX33Lmam7oIQgtGxMbz99jtIp9My3JXKd8L1ltq68ckneOGll5DN5cC8ZJ9bhKWDXR70yPuk + 0SliM7hN9fQdrjH47nEh4LgubMuC1Wx66xQ04ThyApLKI6iqJgBhnMMwjCIhRFBK1di/V6X/QofcEEJt + 05PJVGFubuZUMpnSx0+dwsbGOlzX9UkgkUhgblaaVJxzmslka3fu3v0u59xfbuwoPPA6AON3f/d3f/ZX + f+2/evuf/7M/he4JtYIX0QgIgVqtips3buDWzZswTRPxRAIDA/0YHhrBwOAg8n19SGcySCaTMkc7ILPI + ABDenO8dPbbHHUfpvNtjfcDeyM11XTi2jZWVFTDXRTwex5mzZzE8PNwa4/aSbBqGgTt3biMej2PIy/sX + fq4qRt4XTi9PQMfnr67f8zu1NouOiT3UKkGtoT4O5sq4A+alCRcQ3iIgASdeWzXyNxcCuUx6oFarrWcy + mXVCiPD8X0IdJ4QgxGuYFywUdDySVDrlDI+M3pudmbl09tw5DA0O4f6DB6CyPDKZDE6fOYtisQDXddGX + z72TTCZPlUqlIuS6AuIoCEDTdT35la985SvxRAJf+spX8K2/+ztwzr0efesLpJKvCiFXa1l8uIgHC/dB + KEE8nvCIIY5cLo++/j7kcn1IZ9JyuxlHPBH3Z48BaLMLlcrHe0ASu6mtJ8TUC1u9R/W6joNyqYRmvQ7L + sZHv78eZM2cQM01YlgVCCJqW5Y/vP3zwABcvPgFKNTDm+sKqzhPslZUzL9zHB8t38tSr96G1ECgHZ53j + /wEBQqifJJgSGqoq4FD0CIJSikQiAUIptSwrl0ql1pV97wm9ei+IRwieW6E9SSnnPHb6zJnlqz/84GKp + WKTZXA7a8jKEp3EQQnB+cgI3P70hnYGcn3r15Zef+da3v31H3YajIADa39+fu3DhwgAAPPPsc8hksnj/ + ve9jdXXFs/U176Zt9/oQ/0E5jiPXfS+WcG9+HhACuqHDNOWSTmqxh3Qmg1QqjVQyiXgiASMWg6Eb0HUN + umFIAgLx7DTe5jzyfwP+gpBQvw9Lu3gU8+GAbPVe1Kty8C0tLaFeq0KjGrLZLE6fPuN79ammoVIuQdM1 + rK2uwrYsjI6Pg3PmT4gJecq29ObtzQg47gLPWAR79racAQJCtHpyf3gOxBOylsCTkCbhb1cURORiIGY8 + Dko1//oZY4IQIjRNE4QQ4V0DAcAUIcAjh8C5hOu6NJVK1RLxRGF+fn7glVdfRTIeR7VWg+aRxeDgELLZ + LAqFAoQUmpcAfB1ylqB1FARACCF6kKnPnD2LkZFRTM9MYeqOXJSBc9627NJeoR5g07LQaDRQKBblyWUL + AACGYfjLPsW8/2bM9L/HTPnbNE0Yhg5CpSOSAgCl/nfi5Yv3bVFIr7UfB+CrNTuIC+d7W+upVz19oDyw + Bx/Adna1DwIi5KvIuczbX2805PBeIoGh4WH09/f7drPrunAZh0Y1LD58iL6+fqRTKX+Vn3BKLnX/lUDL + 3wKCt3p09VvILlk2129zS3VXok5pu/C36fTbJv4JCD71OhlNA7zxeiqFNAiuavQ0AgJAhGIC1H4ihBAx + 08Tw8PD9lZWVAavZRD6fR93LgswYQy6Xw8DAIAqFAur1OiYnJ5/LffijvlKpVAGOMCloGxMLgZgZwzPP + PIsnnriExcVFLC0uYnlpCVazCcYYqEZ7MK4OcMbRqDdQr9X9NvmkQ1ovAtU0qS0Yuj/3XNc16JoO6jkl + W85JDWbMRDweB9U0qdV4/wMU7ttzrV4Frf9bA0G2CqSQa9F3UmFFp2P88m21tM7q2VokUD58vjbVGf7b + uKV84P1tq0MIFS8PWJaFRr2OtdUVf8Rn7NQpJJJJOeXX8/43ajWYpon1tTVMXryIarXqzwr02xVQjcMg + tKWCB4WJgAC01Zur7VsraPXiwd68tbvDNu/5apoGzXNWq+m7waw+nsbBOeecEMJJgGWUX0D1/CHtRgAA + c11tcGiosLBwz61UKno2m8WDBw+g67pffvzUKczOzsgFUWLm05qmjQNYBHB8wnCVyqfrOs6dO4dz586h + Xq9jbXUVGxvrKBaKqFTKvpqmvOyPoh3sBq33KEhUHI5twxaW97vdp6CGgQiIv14c0HoZlMqoyKztQyiI + /9u7Nm87pfI4QuVLSzUK9dqp86o/LdMpIKCtP20vs1Jvgw5nJZzCu15lt0rTx+s9FYEIRRRq4ozysHP5 + XcXE+yo1b6naQs5YW1/fwPLiEjjnSCQSGOgfaLtvjUYDZjyOzY0N1Gt1pFIpWFYTnPGWYPve9dZ/eTz8 + etSG8PvSfpx63sHfgfqCjr1A/cEySmvVlFao3o8AeSotj1OK8CSg1oMCCQh8UPVvPVFCiOu6WjKVqgBo + rK+vZ85PTCCVSvmLkQoAQ8PDoJSCA2jUa0NPPnnp3Hvv/eAajhMBKChWBIBEIoFz58/j3PnzMi+8t9xS + oVBAs1GXPYHjtB2vmLZXxLBt27dsEB33c87Bt+SfF/6PTtt8BAU4cI1hQQ9qGm2Ht79PW9ra7Rp23B4y + L9plg2zZLoQMAJKpvtKoVspIZzIY8NJeAXLiT7lcBgAUigUk0ykkEkkQAlBNEu3W6+t+veGrloS8tcVb + 6whpB60+2nf6KcFX5p/yFXUyn4jyXXhTgRljXNM0FRDkn5xSSrzfgdssfLPA+050XUd//8D60uJi5smn + noIZN1Gr16W5IYQcJUulUKlUoMkO9vx77/1AB6AdOwIIIjjfWtd15HJ55PJ5nJuYgGPbaDQasC0LtXod + 5XIZzWYDzHFhO7ZPDMGH2dYTHPrVHA62JY+9ooPgHhSEEGBCoFKtol6rwTAMpDMZ9PX1tanzhmHIZbY3 + NpFOpWHEDLiO2/4sO6njgWugIcHtVIaE94Xem6CmQKkGdX+V70f5FwgApsw7eRFb6gNaZhJjzNcC1FCf + OqfXEbaUPM8ZSKSn0LtFcqgwnc2urC4vTzDGpNYY8LElUylkczmUSyUAAo164yyk+U+PNQEEIVVI1man + p1IppNNp9A8M+JqDY9uwbAu27cCxLTQaTTQbDTiuE/S6hlJDA0HnT4TegzEGTdPk6j2NBgzDQCadQSwW + gxByqMxqNtG0LBAA5XIZQ8PDnlMVbb3/FuENwvPldIQyy4KVQL4DvgChZdopqKFjEOIvAdbWEGUSktZk + MBIoo1R775315wBz+VL6wk5U9BCUL9l/R1sGixCEMcZjhtFs1GsolUro6+tDqVTySSZumkilUvK+uwzM + sU/ruq67rntyCCCMcHCP+m4Yhr+wo2JmVdZ1XbjekKFMES3JwHWZ3Oc6cF05K1Me03JadRvp66RCBkzs + 7XGIXHPcaM1xHGiahr6+PB7cm4cZjyOdToEGgrkc10Wz0UDMjMGymhgcGpQ+EEo7EEBQgFvnIWgXbEUe + La8NfJNxi3NV/QQAlbI8SBQhoabwZrkpIffqQmA7lF3fejeFEIIB4JxzoQKBPJKgaI0CkABxBLUC4bou + SafTlgDsWr0WGxwYlKMMah6FpiGZSIIQAsu2MTE5OTI8PJxfXFzcOLEE0A1txBDyhqvw4UQi4T80AO3j + wZ6Dirmuv167yievtIa2YBDuOb18ZxfvShbd2vuZBKHyI+T91w0D6UwWmqbJUR/4vSAajQYYY0im0q2R + oKAweQjHAAThq+NBpyZa2mTwoQUFt60OQnyhVz08ABkXQkh7eDEJRR+q9zKgWSgfgBBCMMY4IYQHrkHx + SVDrJYE6VWAQYYwRMx6vE0obzHFjQdOZeCdLZ+S9c10XCTOeNmOxDI6jE7CXCNqWon1HWySZRqm/Vrv/ + kANlRMC5488b99TC4MSUuGl2fhFCbQm2rxMhdCWJ8HV0KtvNiRc8PugT6VB+J5Jq81LtEs1m08/aCwC6 + piGVSvoEIABolCJmmiivlsBchlQyCU3X0Wg0/OfS6Xo7+E0BtLzvYZIImpXocC3BeyOCxwbvlQgN5wY6 + obbRB2U+oOXwZowJTdN8E8Ar6w8Jhq6VhDQC4vX2lhBwm82mHLZuGzIXSCSTcrVqGT9hCjkh77NFALuF + EuagoIa1iS0vifeQtMAQlmEYfk+1KwHpVq7X20NlgB0I4wC284APAABACAzd2DLjU/PyADDO5Bg63z5k + ezf3uaNnHu0dQ5tmESqnrkGRZ/C6goSviFF5/FsmSysGhDEmGGMqHZiAVPm9voeQwH91rHL8Barm4Jwz + CCHkgkByVIIH3mNDN/xr4pzHOOcmIgI4eHTyS2wneB1f5u2EMFSu14LatR27aeN2BOCZVCreX6cUmi5f + RyUgli2nrat8gMKbgBOuN6iBtAndNu1SxOydsLULLTII7wtft286qG3KRCB+1p82YglrEl6MhB8D4AUD + qZ5dqGE+tPv9giaCIIQQSilhjLlCCOZ6hEo1DdxtjZbIMHd5LOPMFJwbiAjghKGb0O1XUA8Ke2iH0q6a + zQZApGNPjVsD8kW1bRsC8KeBExk44wtWW/Wh71vaELLzg22C1xYEemb/mGCmoRBRKEdfR/IJmnieicUD + 1wblb5IjUkr958Fen1IqRGu8r03198oCAFG8oeu643j5EzRNa1v6XMUpQN7PGOM8BhxhKPBnAco2bN94 + iAK5Ezr10IdkAiinWGvirHdObwVcQAbUQAiAyjkBzHWlltDJ94GWAG7XFuXJF14wzpYyQXIJHdPtesIa + R7COsH/A369MABkIxEIEAAQEG+1agOz+5Zx/IoQgmqYRwTl3XZeqXABqRqA6gAfaTilhlBAGRATQMzzS + sNt+bPcTCEKIP+4vF8hgbcN7MdMEKhVolIJ5IzE05CglkKq377MJ1B3uodV+ssP93E6DUb25XyZIDIEy + Qgg/SChcpzpemQAqFgAhAgjEAiifQKA50jzw1H8CTROMMU2lCQ8vta4SpwAClOoOodQFjmY6cISDwnHz + AeylvKf2x0xJAFwIuIx7I2geAXjkoFGtbdSlzZ4GfKetqhdA20iNDyWsnUYQutj8BIHRA1U0eD0hX0Jb + u0JBQv7xikSkM1R4CgCDJADlBSVeKHCA04K+QD9egBBCiPSfCGrEDEC0Aq2Ur8JVoecCoJQ4lFIbEQFE + OCoQz05NpdIApLA4tu0PCyrvl23biJkmNEql7R/QANrsdbQLpj/0F1S/A07ZNgRtc2BL/cHx+7DNHyRP + osil0yhAsJz67cUBhHwAwWIk+D1gAqjsQRBCUEopE4zFhBCGacYhBPen0yvYluVfF6W0SWR24IgADgUH + NQpw0E7AI/QBUE8DSCSTAADGXNRqVX+mp/KiO46DZDIBqmmwrSbi8USbDb3dOUWHbd3QyVvfMX4j+DtI + LKQV+x/s6f12BIgo6Cvw0gEHfQCA5wRkjLXZ/YS0RgQ9EwAeYTDLtpMEMGW+AbRmygoBqmmo1ar+JCvX + dYsu52VEBBABwJGZALGYXK6OUALXZXLJL8a2jJfHjBg0SrGysoozZ89K9T4YdNPhnMHfwR4cge8dg66C + P1Rv3iH4p+27MkECAh4eImyLD1CEIdrmAjCglfxDViHNgQApbPkvhCCUUqdaLse4EHHTNOE4rswHELj+ + er0OzjkMXcfCwv3ixvp6CREBHDMcgk1/XJyJKlDKcRzEjBhcx0G1UgHzckMKIRCPx5HOZGA1m0gkkihs + rEsCCAmur/p38dR3VNWDxwBtwtJWt2gfcgwTTptDMKj6B9qj9vnmQMAHoAKBXNfluq7zkJRz2Vy/t/eb + EJgqTEAIazSbGV03SC6Xw8rqqj8XgFAK27bRqNcBQqAbBmr12lqj0bAAsIgAeoh9BfmcJDyiCUAIQV9/ + PzJezrpyuYxGo45cLg/mujA92x8Acvkcqp6GwIXw89kH7f6gLb8lCCsgjEFVvtOIQJtAB3wOvprfqSxC + ZBBsV6dyQs0l4YJzzpQWEPD0US8qss35p/4zxlqjAK4rbNseSqVSMGIxuI6/7oe/mGq5XPZDhHP5vgXI + tOD85C69E2F3CLzEnez9TvMigtvD+0S3fXsE8XwAg4ODiCcScF0XtWoVhU25uEXQDKCUIt/Xh831DVSr + VT/Xn9/etia2BLbt2lSbu2wL19GmvofuTdt9CHx4h/vjtydAPsEVij0NgHkk4H+EEC6XYYKcMeZ/FIQQ + TAh5KGOMb6yvjw4MDnih1a1sWYQQ1Go1VCsVADLF+ura2i1IAog0gGOJg3QC9qId3fbt0QdAKUU2m0Wz + 2YSmaajWaigUCv4cASEEhoaGMDc3h77+AXDO0Ww2oet6u5fbC+zxxhDbztdJAwibYh8JgAAAIABJREFU + A+FtnRx8W76Hrm2LSRA2AQLbgk5G1fN7Qs8C6j6hlHLOuT8CoCb/ePuVeuAyxnKObfePjo7BsizUarW2 + vAqbGxtwXHk/NcMof/zxtXnI9QFFpAEcBrbpOUVo36G1I/zCH1DP3vV8wXq9HlHTNMTjcZw+exYA0Gg0 + sLa2JpcC9174mGmCMYZsNotMJoMHCwttU7P9+kJOwSBIJ6FV7VNfA+0NtlEAbesOqt483PuHzYtg7992 + D0JrGDIvKagaCVA9O+ecq0lCwW1KK1BmAyHE2ljfGDVN08hms7CaVtvwHwCsLC+DeesaJJOpe5Rqa5Aa + QEQAJxq9UNUfxQR4xHNpmgYzFkM2lwOlFM1GA4sPH6BWq4FSDUIImKaJvr4+cM4xPDqCUqkow4K9hULC + HvqgQO/o5VfX26FM2Ezwy4aFPtTDt20PtkcIX/h58LsUdKX6u0F/gLfLbRXxt8kdrss456hVK5P9/f1I + pdMoFjb97EVU01Cv17G6uiIzApsmpqanbxWLxVV4S4NFBHAS0IveOVRvz9GBWFQa9Xwuj8GhITTqdWxu + bGBjfV0m/fRs2HhCjv2Pnz6NRr2BcrnkawGefgx4/0ORM1uuFUA7SSDQU3dpq3882slBHctDZcOaQfj+ + Bp2AnDEVB7DFBxDo+YN+AbdFFMx2bLuvWCycm5icRKPe8NdSBGSOhY3NDRQ2NiAgQ6ublvUD13UtRARw + DNEjNbwngt5FSMJawnYghEDXdYyPj4NoGighKJfLuL9wD5onvJxzDAxI+7+vrx/5vjyWFhe9FG6uL9Rb + lPzQzD3lH1DhdeHhPdX+LVoFsHWoL3Cdrc1erx40F9CBJELHcSGE15Ornp5xzt2QYzCoGXDl/CNEswuF + zafSqZQ+NDzsB/so4gSApcVFNG0bRAi4jK1fv3HjGgAH0gcQEcChI6xG7uPYRxW8TvVuZ6v3sl7dMJBK + pzE8PALdMFCtVDA/P49areb3ZIZhIJvNQnCO85OT2FhbkzED3pAg4PX2IU2ABIQeCIXxdvIZdAkQamt3 + eFtwOyFd712bBhHYzqVq7/fsXi8f7O3DJMA458x1XcaYGy9sFp46ffYcYqaJYqkE3ZsMRIjMpzA/N+fP + n6Cadm2zUFiEJAABRATQU+xHcHoleDs6HTuo6nuut1P9XerVKEXMMDAwOIhkKoV6vY7FxUUsLy+3JQgZ + GByEy1ycOi0XDt1YX/enCAcFPezwI13+d7tv/lx9BPwIYQFW1+PtD29Dh3Jt9yBw/cyLA1DqvvdpE3xl + DiifgOu6nHPerNeqzwjO+i9evIhqpdIWRq3rOpaWFrG2ugrOGDLpNG7duv0d27IKkAQAICKAI8eOArn9 + wfszGfZjGuzHtAiq0F502sjICPKes69UKGBq6i4AKbCcc+TzeSTiCcRiMUxeuIiHD+6jWqnAdhx/6mtY + C/C+tKnEbVDEESIPEjAViCrX5TqC1y6C2xRxIPSMQyYEYyxoAriMMVdl9/GEX6n+igi4bduMUppcXVl5 + 49zEBNKZDErlsq8xqfbOzcyg2WgAALgQa/MLC98RQjjw7H8gIoDDQbeec6/HP+KxOwrqfk2AvWoMARDI + dFXZbBa5fB+SySTKpTKmpqewtroK3TBkOUIwMjoK27Jw4cIFmLEYlhYfwrYs2F7MgKqPeKp40CnoVdJO + En4zd7ir4V48cC0qzDgo8OhSX9h5CMA3AZTgB82BwCiArwE4jsMZY816rfYi56L/qaeeRr1eh2VZfkp1 + TdNQKBQwPzvrx0tU6vVvz8/Pz0POAvTHUCMCOE54VEHfr8lwGNjGtFDp2k+dPo18fz8azQZWl5Zx+85t + P2SYM4a+/n4kk0nETBNPPvU0lh4+RKlchmPbW5xfHeMBgt8D5brFCWy5jyLgIOxwHaLTJ0gMqnygHm9Q + 3w308MoPEFT9XcaY6zgOazabDiFkcGVp6fPPPP00MtksioUCdK2V80+jFLdv30KhWARjDOl02rr28cd/ + C6AKwA40OSKAE4WD9A0cpA9gn+0jAEzTxNDQEPJ9/YjH4yhuFnDn1i1sepGBgHy5x0+dgmVZmLhwAf0D + A7h/bx71RgOWZfnTXUlQ7Q8INwmbA6F9gR8t52EXn0Ins2CLNtDNl6BMAUgNwHVdNabvMMYcJtHmFOSc + M8uyQClFpVz6iWQqmXrymWdQLpdge4usAHLsv1gq4u7t235SkFqj8cOZmdmrCHj/FSICOGx0eAl2KnNg + TsBu5fZaf7iNe21HB5LRdR2maeLMmTPo7+9HrV7Dg/v3ceP6J/7cAMEYcrk88t76gS997hWUikWsLC/D + tm3YgYQiCqpXDM7F97cBbbMBfYIIXYZPJMq0CBy/RasIkc52908I4TsBlcrvOQEdIYTLGHNc13UYY26j + 0RCWZTcF5y8VNwvPvfzKq9B1HeVSGTHDgIDnT9E03Lp5E5sbm2COg1Qyye5MTf9FvV4vAGgi9DpEBNBL + 9Fol36WQH4Sz7pF8AHs4B6UUsVgMo6OjGBwegWmaWF9fx41PPsHa6ioMXfcES+DMmTMQQmBwcBBPP/MM + 5memsb6+Dsuy/DkEPsJaQKiNQWEOb0doOwker9T4QP1CiDYNoWsIsl/E0xlkuK+AtM2Fd785PAvBcRw0 + m03XjMXOri4t/fSlJ5/EmXPnsLmxISdLeba/rutYXV3Fp598Atd1QCiFw/kPP/744/8Eafs74TZEBNAr + 7KYXwC5HAfYjYLtrxN40hkcxAbYzLTzEYjHE43GcOXsWg4NDqNdqePjwIT68ehUCrSxAiXgCp8+cQaPZ + wHPPX8bwyChmZ6ZQLlfQbDbb0mEjTAboPhS4peffYbu6Jl+TCMQBtEUkbjkRCR6vBN9LDiTUEmFCCCFc + 1yX1el3oup4rbKz/SjafS7/08suolMv+oqoQwiexD69eRaFQgOM4yGQy7PqNT/9lpVJZR4feH4gI4PHA + Xnvqo3YWdiEDSilM08Tw8DCGx8aQTqekFnDjOu7cueNnEGKcYXhoCH39/XAcB6+/9RbABeZmp1Gv19Fo + NFqLiajzeejaK+/UW297OYERCLWtS/1t7SF+zsE2EuDeYiGe8BNd12Oubf2SEPzUlbffAQCUSiXE43G/ + +lgshunpKUzfvQPXdREzDJQr1X979cMP/yOk8G/p/YGIACKEsYueulO5g4JhGIjH47hw4QJGxsbhOg6W + l5bwg/feQ6lYhO4FBwkhMDExgXg8jrhp4so7X0C5WMTszAzq9TrqHgkI5RNQAT6e6r6FCDpoCm3YzrYP + BA8BIVMhXLTtlFL4mZwPoG43B8Bd1yXVapVQSg3uul8rFgovXHnnC8hls1hfX5P3wWuPpusolkr4wXvv + oVargTGGeDK58YMPfvgvbNsuAmh0ac6REIAghAhN03anIz8OeASn3I4e+kdxvm1zvm77e+6MVN5xD5RS + xP//9r48uK07v+/zTjxcBAnwPsVLp3VLtiXf9trrS17v2t7NXl6vk3Y6Tad/ZNImm2Smyc60M9vZZtpO + 08kkmaTtNpnG3rW9pg5ba/lY2ZJ1UBIpUbwv8AIIEgCJ692vf7yDDxBAkbpIyfiMYUJ4D8B7D+/z+X2v + 3/fHcfD7/WhubYPfH0AsGsXY6ChOnzqtxwsMU5uiKDS3tEBRFJSXl+PAQw8hEg5hdGgI6VTKIgNgS/fZ + hCA3S5CFQgKR5z2WC5BzjbL2MmMGOZ9tWA+mxa+pqqpJkkQkk0mSIAhaU5RX5uciDz7y2OOoqanB3Nwc + aIrSTX8AhLGQytkvTyM0MwNJkuB2exCcnPqb/oH+i9DJnxX5t2MtBEBNpVKpxcVF8fq73t1YCYnzv/EW + Bt9uJlq/0v1yXYvrxQDyfI79WtA0DY7j0NbaioamJjg5DqGZGVy82ImuS5csV0BVVbhdLrS2tYHPZFDf + 0IiDDz+MyGwYw4ODSGd0d0DMbTeeUy9wTaWgadIXeN3cZvn9NnEgjHMp+NsvfYDVs4+iKJkgCEVVVU0U + RWpxcZEA4IamfjcSmX3k4UceQdOGDYhFowAAhmEtAWMYGpe7u3G1pweiIIAiSciKcvKjEyf+CUAKBXx/ + E1ShDbcRpCiKWl1dXfUjjzzy8PUipXcrzFZWdx2Mm/S6o/1K9luJ1WB8jmgsFW7eDRRNg6YocE4nkokk + onMRZHge6UwaVdXVCJSXWz0B3C4XnC4XwqEQyisrUeYvQ39fL9LJJJwulz5KEkttsrK+3va8kEWQNanI + LgLICQjmVCBq2R+S9dkkSYJmGHVkZOSE2+0Osiyr8DxPJ5NJjaKoakUWf5xcXNzz+BNPYENLK+KxGFRV + BetwWKlIlmUxOjqMTz/+GAsLC5BlGWWBQOiTz37776dnZvoBJLDM6A+sjQBoAKizZ8+Otre3l23btm0b + QRBEwdHwLgVBEJapuhxWdN7XI9IqSHvbsggr2AfIf4waAClXAAyyyrIMDUB0fh6LCwsQRRHxeBx1DQ3w + eUvMjjpwu91wu1wIh8MoK/OjuqYWI8NDiIRDYB0cWJa1JsuYIy9QuGLQXiac1WegULTfRnp7BsD+b2NH + kPpKyML58+c/APA5y7KyKIrgBQFul2t7cmHh96BpzU9+7WnU1zcgGosBABwcZ11HhnUgMjuL48eOYS4S + gcjzKCktVTsvXvqzCxcvfoQ8VX/5sFYCoIqiiLfffvuSz+dbbGtrPeDxeEjT5LoXxOCusABulbDcAuQK + gDnffyEex0B/nz6rTVWRTCbhLSlBJBxGY1MTXG631RzE7XLB7XZjbn4eLrcbGzY0Y3Z2FuOjIybpLF/d + FOjlov9ZAbs8rxcK9Jn7ZxUJQRc1aCoUWZbPnT//1uLi4mmapiVVVQWGYdwszRyKzke+X1FZ5Xviqafg + 9/sxPz8PhqZ1t8ewMliGQSwWw4fHjmJ6agp8JgOX2435ePx/HP/NR/+gadoilgn82bEWAgDo18NRXl5e + 0d7W+v1LFzpbw+EQ4Xa74fF4QNO0Za7drWJwQwJwt4/0N+E+2AVAkiSk02k9BdhzBWPDQxBFEZIk4dHH + H8f3f/g6wqEwuru7sKG5BS6XyxIBp8sFn8+HxQW9a1BbWzsIEBgc6EcymQDNMCApKmuNQWK532mVtQP2 + /U1rgdT9ciwuxDE5MYGJiSChyAoZmZsbYhhWKCv1bZRF8fVkcvHgfTt2Ug8+9BAoikI8HoeD4/RFUs2R + n6axuLiID48dxfjoKDKZDBwOBxQQ777fcfhnmUxmHvror+YeWj6slQBwAFw/ev31f9Hc1PDDVCpFhGZm + cLm7C4MD/VhcWADLsmBYFg6HI6vF8d2CLAFYp6b3qj7ndn2usY8oSYCqQpZlJJNJzM3Nobu7G+Mjw+B5 + HoIgYPuOnXj9jR+DYRg0NjVhamoKXZcuomlDM9xut7VmAMuy8AcC4DNppFNp1NbXo6q6GuFQCONjo1AU + 1Rr9VVtvQcvXz7UMVnrfGe+lSBIkSUKSZWTSKcyGw5iZnkJkNmTUKEiEx+OpUhVV9ZeV7k8mEt/y+XwV + jz3+ONo3bkQ6nQbP83C7XDBX+wX0FGl8YQHHP/wAoyMjSKfTevdfEJ/86r33/iwej09BJ7+87HHasBYC + QAFw3X///Xt/+tO/+POB3j43QzPgnBxoikYqmcREcBw9V65geGgI01NTyKQzoGgalJH+MC0EE+vRUrgp + F+B2md63SjBu4eeqqgpFUZDJZCDwPFKpFKLRKHquXMHk+BgymQwkSYLT6cRzL7yIuvp6yLIMhqLQ2t6O + mZkZdJ4/j4aGBpSUlkI12oSRJAl/IADGMJfdbjda29rhcrkRHBvFzPQ0FFk2Kgz15cezOgzBGMFz6gay + egYYv7E5V0FVFAiCgIV4HHORCGZnw4jMziKRTEASJf2jKBIO1hjUNHUDwzD1e/buIx948EE4XS4sLiyA + IAh4vV49hqTplYasw4FwOIQPjx3F2Ogo0kbrbxDEqXfff/+Po9HoCFZJfvM87zRYAGV///d//7Mf//jH + P/rVW29haGgQDofDOhz9umv6j2LMZ2ZZFmV+P/x+PwLl5QgEyuEPBOB0OnVxMH4IVVGgmH3Z7EtE22/S + PCmqa7atZB/kBPFsr5MkCdpYnjn3vUDhFKGWb59l0kp598/Zx9q23DkV2H9Vn7ua/TUNgjGBRxRFJJNJ + CDyPdDqN3qtXMTaiF/SIooi9+/bjqa89DbfHBYeDg8fj0VNgLAuKIvHpJ59gZGQYTz/zdbS1bYQkChaR + SYoCn9a7DceN6jlBEDA8NITBgX5k0mmUlpWhorIKLo9Hv59IErQx4Ji19mZQUgOsvn+SLEHgefC8AD6T + gSDwEHgBsiJDVfW0p6qpVodjkiQhyyIEXoDb5camLZvRvmkzOI5DOpWCbMQxGIbJSlvSNI3h4WF8+vEJ + zExPI5VKgeM4aAROvP2rd/8kHo+PQI/4i4UufyGshQA4vV5vwxdffPFP27dv35tKJvHpxx9jZHgIFEVd + 09PcTgLFGC30/CcDhmHg9XrhKy1FibcEXl8JPB4PPB4vXG63HnQhlqaAWrlnVbWaNJqffTsEwDqXOy0A + 19t/uf2WE4BbIESqpkFVFPA8j3Qmg+mpKQSDQfT39gIEUF1djeDYmJW/37V7D7716mvweNwQJQmiIMDl + csHlcoMg9SXGNY1CZ+d5dHd14sEHH8TOXbuXMgiaBoIkQUIvn52a0puIsA4HJElCcHwcY6MjmJuLwOl0 + wcFxKK+oAMc5QdO0nnYzXBNZkiDLMiRZgiRKkCUJqqZCVVTdkoAZTzBcC2hgGAbpVAoaAEWSESgPoK19 + Iza0tIBlGGR4HrIkgXM64TS6H2tGzQRJ01AVBRfOn8OZM18iNh9FJpOB08lBBfnrt375yz9fWFiYxA2S + H1gbAXBVV1e3nz179hcNDQ3bAV1Re3p60HvlMuLxuO5HGeqbF2YBiXGxzAAQSRBW7IBlWbhcLrg9Xrg9 + brjdbnBOJxwODg5jH4ZlLTPPntZRNVO9jRt6GWviZgUgr+tSiHiFCHazArDM/gU/N9+xrGB/2TD3k8kk + rl69ipGBAUQis9aIp6oqJEmCJEnYsnUbvvXaa3ByHAANDMOCJCmQhAaapiDKGjjODVXV+wn0913Fb44f + wX33bcfBgwfhKyuzgouA/ptoqopYPI7I7CwEnrdcy1gshsmJIMKhEBYWFiDwPLwlJWAYFhk+A6dx75Ck + Pd1HWO3LNU3TF+HMZMBxHBRZQTqVBMOyKCsrQ3VNDRqbNsDv90PTNPCCAGj6wicupxMEQViDktnTLxad + x6kvTuFqzxUkEwkIggCPxwNBlH7xy/fe+88L8fgMdLNfyPfzrQRrsTQYoWkaYf4opkLft3072jduxNjY + KEaHhhCLxfRGB2YAcCX+tKZBgwZVA3hBQIbnMTc/rxMYGmiK1olvxBEYhoHD6YST48BxTnBOva6cYljQ + RtrI7F1P5RDaLg7W19tEgjRKNDUgq0Ls+sd/i7Fan/52xQAAKMbIn0gk0HPlCq5e7sa88fuIogiSJMEw + jNXj78BDD6HE60U6nQZN0/rrJAmKYRGPR5FK86iqqoPDoQtEX28PhgYGkFhcRDgcwsGHHkZrW5u11Jh5 + z/n9fpSWliKxuIhYLIpEIgGv14vtO3Zi2/Yd4DMZRCKziM7NY2EhDkCDLIpIJVP6lbF+fwIUpd+XlDGR + iTXmMpSV+REIBFBdUwPO6QRNURAlEal0ChRJweV0wsFxOvENl4IAQBvn33PlMs5++SVCMzNIJpNQVRU+ + n29heGzsv3/225O/SKVSZrT/pipq18ICcFdVVbWfOXPm/zQ1NW3XbEQyg2aqqiIajSI0M4PpmWlkjKjo + UmCNMAKzqz387BLcwqM3BZqmQNOM8VdvWUXRNBjjub6NtirWzG0kRen+vyEwVpMJktTbWwFZUWXT2sg9 + hqzjK2ABZFklWadZYKReiWWw2hgAQYDQNHMd64L7K7Ksj/ypNC53d+HypYuIRqNQFAU0TWPj5s1IJpIY + HhrEhuZmPPTIo2htbYXH44GiqJBkCYx5vRkWmqIilVmErGoo8QZw9ovP8c6v/lkfoQkSpaWlqK6txdZt + 27B33z5UVVVDURR9lqBxvqZImxZJLBaDpmnGKO4ETVOQFQWSKEFVFSiKDFEQrRoFgtAbmjI0DQfHWcfH + Ohy6H29YOyzLQpZluN1usIZ1qhqWq3ktKVpv6TU9M43Oc+cx0N+HhYUF8Mb7nS5335dnz/7Hc+fPfwKd + +GkUmOG3GqwrAbDDFANZlpFIJBCLRhGPxay5zlbe2BZtJ7L/d+OwuRhZzw3YSZz7nab7wtC6tWFGiU1h + MG9Q0laaaomDua95TmaU2dimn6uZprJZGPZrZ0auc0+pwH7XCIOdxKZZnnNdsvbTlkTVHMlUWxBW1TQo + ioJ0Oo1UMon+gQGMDQ8jFovq0XyGwSuvfRt79u3DwsICTn/xOdraN6Kuvh6KMaXX4/VAFGUosgSaYcBx + HlA0A1EU0NvXgw+PdCA0PQ1Av28YmoYoSaBpGv5AAHUNDdixYye2bt0Kv7HIiH1RERMkSYLnM0ZPAQVz + kQgIggDrcEDg+aWJRSQB0nb9NSwF6xz66jtQFQW+0lKQRrCSZZilxUFsNQiksSBKZC6CrkuX0NvTg+j8 + PNLpNFRVQUmJT11IJN/7+NNP/3JycnIQOvGXneCzGqzL1YE146Yx4fP5rPXhJEkCn8kgHo8jlUoik8kg + lUxClmQ9IGNFT/O0g76VcreMzatBAzRAFARYdNJs26zDMWeH2f5NXLst735LH5K9r3W+NiuJyH6P/XVD + AZa04Zr4hk2gNeQRCrsVBdjkA9B0a44XBKTTKYyNjyM8PY14PG6R/7Xv/A527dmDdCoFkiTx8KOPIZNO + Ix6LweVyw+nkQKgK3E4HUhnAwbpAUjQ0VYWvpBThqWkMDQzA6/UC0O+Vmrp6xKJRLMRjCE1PY3FxEeFQ + CFcud2Pzli3Yum0bAoFykARpROx1wdKPiQXLOqBpGsqM1mOyLCOdTkMSxaVYkSmgpkVp+O0cxxmByWzX + ULW7hxQFmtKti3AohKtXr2JwoB+RcFj/HkkExznh4LxXL3Z1/9X5zs4PeJ6PQye/gGXvvtVhXQpALswg + H6BPAfV4vfCWlFhCIUkyRFGwxEAQRciSBEEQIIpi3mi/OYrnmuTrEto1T1b3tut+3JLwWNcEK50qWlhg + VVWFIAiQVRWTU9OIhEKIG51qGYbBK9/+Nnbs3Il0Og0z7SsbhTkEQUAQdLePZT2IxWLgRQmu6hK9jJRz + 4vy5L3Hiow8s8gcCAdQ2NKKmpgaVVVWYmZnBQiyK6Pw8JicmEJufx/TUFK5cuYLm5ma0trairr4Bbrcb + GgDZaCdmCoJ+jTSQFIUSr9e6T66xWo37yrxP7ZYjNA2aUXZMURRUTUMymcTkxASGhwYxOjKCaDSKjJHy + dLAsfKVlsZnw7D+e+vD4L6anpsaRPerf0jDRXSEAdthNTgDGDcKAZfWUIFFZaZmdsiRBMvw1URAgCgIE + UbTqC1RFgWI8CgboCCL3vs7aBqyNH7XeYY78sixjMhjEzNSk7vPLMmiGwbde+zZ27ty9FNsxAqzm72UX + gWSKBM04QMgiFpNxVFZUo7vrIn7xv/4OoiCCJAiUBQJo2NCM9rY2sEZ2p6qqCrPhMKZnprEQjSIajWJq + chKxaBQTwSC6u7tRXV2NDc3NqK2pRVVVFZwul9VsQ5F16wCqqrtBBeJHdsKbA4rp8mmaBlmSkEylEA7N + YGpyEqOjo5gzljfjjfuSc3Ao8fmikfn5I6fOnX+7p6enC3p6L4NbPOrbcdcJQC4KqbFVK2DMHYdhpgG6 + SSYriqXYliCoKmRJgqIqUGQ9YGQVFZk/sv2BpR8/nxhkiUoBK+NeFA9VVcHzPCRJwujoKILj44jNz0OW + ZVAUhW++9hp27d4NwSC/CZqmwTkcuqmtaZAkSQ+AOT1wuTwgGQbT05P4+PhxXDh/DjzPg6JI+HylaGpu + weYtW+Dz+eDkOOv9Xq8XtfX1CIdCmJ6e1qv0ZsOIzc0hOjeH8MwMBvr74fN6URYIoLq6BhWVlfD7/Sgp + KYHH67X6D+SrONV/ftXKDGiqCkEUsLiYwOJCHNFoDKHQDMKG9WOm8/hMRi84YhiUlpXOhcKRo12nvnhr + aHjksqooKSwR/5b4+oVw1wtAIdgJa7yQ5b9aJZwACJbNm3M3U32qseqrPYhjPldtApH7sLevyhdwWxIv + 1fKf81kiBa2TQlH9W4AbLa3WNA08zwMEgTGjyCY6PwdZUUBSFF799newa/eeLPLbRUCvCAUWFxf166tp + kEQRlJdCeaAKn3/6KT44ehgejwcUScLr9aGusQmbNm9GidcLJ8fpKWNV1Sf+GOlbtqEB5eXliMzNYTYQ + wPz8HCQ+g1g0hkwqhbnZWbCTkxgaHATDsnC7XPD6fHC7XOCcTni9XrhdbjAsA4rSM0GmyMiyBFHQqxkT + yQT4dBrJVBKJxQQymTQkSQZvtCgzA7oVFRVgHA6Mjo13vX/02H8Kh8PnAcShN/AQscqS3hvFPSsA10Ou + CZdPAOwBHzMaj5xtZgAIdpIb73Fy3DV+Y4Gj0f8rROhb9fpK9rNnAVb5fZqmWf58b28vBnt7MT87C9mo + 3nzt23q0n89k8tbWm/PsOacTJEkik05jbn4egwMD2LptOyiCxrmzX8LtdoMgCJSUlKCmrh5btmyB1+Ox + xENVVes8zBZjrDGxzOVyoaa6GolkEtNTU6ip4zEbDkNVFaSSScSjUYAgMG926zFTuiwLyojYmxkZ2DMf + mgZZliBJsjWvwH5dXC4XAoEARElCeWUV3G43WpqbMTQ80hsOhy8BMPP6t3XEz8VXVgBWi6zROVcA8lkZ + Bfa/5nNvcKS9IdysYCwDVVWtfHpXVxcunDuLSEQnP0mU5GdnAAAcdUlEQVSSeOXV17Bn7z5rsUrgWvLb + X3O5XIhGowiHwxifmED/wABcHIfI7KxlkldUV2Pzli3wmDX8VOG5bea6A7Qxt97BcSgtLYUoCNjQ0oJ4 + PI5QaAYswyIWiyIejeruiJFyXlxYMMp7jWPP/QIj42S2NmdZB3g+AwfHoaKqGqIooqKyEr6SEjhdLjhY + FmWlpXA6nSKWfP07Sn6gKADrE4VG4dW+fruOI2ebRf5EAl1dXbjYeR6R2Vnd5CVJfPOVV/WRn+f199oC + q7nkJwCQBIFQOIyZmRmEZmeNte8oVFVVYdv27ei7ehUEQUCRFQiiaKXeVgJTCBiWhaookB0OOF0ulJWW + orGhARmeRyadAc9nkE6nEYvFEI8vpSQ1VYWiqJAV2cr9kyQFEARkScTiYgKlpfrqRQ6jIMjlcoHjOMvt + ZA1rwu12g6ZpBSucu387UBSAex2rNelXub8Z8Esmk+ju7kbXhQuYDYetSrmXX3kFe/fvt6L9gG30tPn+ + FvlJEpFIBBPBIMbGxzEXicDhcKA8EEBtTQ1YmkJvT49R47FUeHUjyBUDTdPgdLmglCxlIsx6FMlIK5tZ + I/v8ArPyk7KVjJs1KOYEN5Jc6ku4nlAUgNuEvFV6tn/fFp/+DsMM+KWSSVy+fBldFzsRCs1Y5bYvv/oq + 9t//AIQ8Pr+9BsNsz0UQBCJzcwgGgxgPBjFrLAnm9/vR2NgImqLQee6cVSlJUbReA3AL6jhMYpIUBRgt + t80skX2ikhX0zb4QWR2s7IuZ2q/VekRRAO5m3O6g4TJipRkjfyqVQldXFy5d6MTM9Iw1cn7zlVfxwAMP + WhkBAPlFwDZXYnZ2FhMTExgPBhEOh3Xyl5ejob4BLMvi6OEOxGIx0DSNkpISeH0+eNxu0DdoAVwPJqlN + Ql+T+7/O83z/Xm8oCkARq4Y5YSab/NNGB18NL7/yCh48cGDJ50fhgJ/ZQis8O4tgMIhgMIhZk/yBABob + GsA5HDh25DDm5+bAMAzcHg+q6xuwceNGMEaqr4gbQ1EA7gRWmwW4lUHAWxwDUGw+/5UrV3DpwgWL/ADw + jZe/hQMHDq4q4DdrJ//sLGiGgd/vR0NDA5wcp5M/EtHJ73ajvrERO3bsgNfrhcPhyFugU8TKUBSAIlYM + s7Y/mUyip6cHXRc6EbKR/9DLL+PAQwfBZ3jbxCUDBQJ+s0bAzyK/4fPX19fD43bj2OEOzEUioI1o+obW + NmzZsgUlJSXXTf0VcX0UBeBuxh2MAZhdbOzkn5qctHz+F7/xMg4+9DAE3kb+AgG/XPKP5yG/r8SLIx0d + eiyAYeB0OrFpyxZs37HTSq3RNH1tkLWIVaEoALcRqzLvjW3rMQtgRftTKVy9ehXdFy9Y5FdVFYe+8TIe + fuQRnfwGlgv4mT6/GfCbDYezyF/q8+FIx/sIh0IW+Tdu2YoHDhzUF8W0RdqLuDkUBeBex03GAHLJ39XZ + iclgUJ9Mpah48Rsv4dHHHkNmBRV+BJAd8BsfR9hI9QUCAdQZ5D/a8T5mpqetqrpNW7bigQcfhN/vt1pv + r/sp3HcJiuHTuwm2CU658xfyvn7TX7dE/r6+Ply80ImJiaA1k/KFlw7hscefWBn5jSmy4ZyAH8MwS+Qv + LcWxwx2Ynp6GwyD/5m33Yf8DD6DM74fL5bKmDRdxa1C0ANYYq3YTbs9BXPNdmqaBN2r7+wcGcPH8eUyM + jVlVcM8+/0I2+VcY7Z/IifYH/H7U1dejrKwURzt08uu1+g5s2roV+++/H/6yMrhdLtAUdU9On15LFAXg + TuBO+/A3GUswR/5kMomBgQFc6jyP4LhBfkXB1194AY8/+aTe2trAasp7I5GI5fPX1tcj4PfjSMf7mJ6a + 0js1Oxxobm3Hvn374ff79Zp5hrFmCxZx61AUgLsBtys4mG/kN1J9qVQKA4OD6Lp4AeNjY1Yn3OeefwFP + PPlU3oDfist7jTx/XV09KsoDOPL++5icmLA65ja3tuG+7dvhDwTg9njAUFTWjMsibh2KArCecDsshVW4 + E2Z//mQqhcHBQXRd6MTo8DBko73a159/Hk8+/XThCj/9yfXLe/1+1NXVoaK8HEcPv4+JYNAif0v7Rmzd + tk0f+V0uMObyarZjLOLWoSgAdxo349/frunARkMLc+QfGhrCpc4l8iuKjGeeew5fe+br+sivqhbRgdWX + 99bV1aGiogLHDncgODZukb+1vd0iv5nnzzuhqohbhqIA3Ebc8Gh1Cwi9GpdBM8ifTCYxMjKCi52dGBka + NMiv4GvPPIuvPfMsBJ7Xz8lYUANYfXlvfV0dysvL8cGRwxgfG4PDwYKhWbRt3oyNGzeirKwMTqfTWlTl + miYrN3pNisiLogCsMW7KpL0FMQDVRv7R0VFc6jxvkV+WZTz19DN4+plnIAi8JUw3Ut4b8PtRY4z8Hx49 + gvGxMaNDD4PN992n9/QrKTGbZOiHZztO5HtexE2jKAB3ArchWLea9wIFpvTmIf/QwIC+HJYk4amvPY2v + P/ssRHu0/wbLe2tr9bbbHx49gtHRUWt1501bt2L3nj1wu91gGAYsw2S1Uit07EXcGhQFYD3hRol+A0Qx + A36pVArB8XFc6uzEYA75n3vhBQjW6kY3Xt5bW1uL6poaHD92FMNDQ3oXHobBpi1bsXv3HlRVVVlFTLnH + mHteRTG4tShWAt5NuNmKP22plTnP80gkkxgfH0fnuXMYHOiHLMuQJAlPPPUUnn/xRQiCsLTUWm7Azzby + 2wN+42NjCJvkDwRQW1uLmupqfPTBBxgcGDDIT6N982bs2rMH1dXVWWb/cueNPCJRxM2haAHcadwJs/Y6 + /QfMkX9iYgIXzuvkN1dSevzJJ/HCoZfA87y1+Oqy5b250X6zvNfw+aurqvDR8Q8x0N+nk99YCXjXboP8 + Hg9oms5qn2Ud6+26PkVYKArAesRKRWKVVoBJ/kQioZP/3FkM9vVZRT6PPvEEXjj0khXtJ1YY7c9X3ltj + jPwnfnMcA/39YAzyt2/ejJ279qCmpgYejwdMAfJnXYdiEPC2oSgAtxMrIOhtN2mNz1fNIp9kEpOTk7hw + /jz6+/qMxVUlPPrY43jx0Ev6isYrjPYXKu+trqlBbU0NPjnxEfp7e8EwDGiaRuvGjdi+cxdq6+p08jOM + /h0FTPvcGICGolVwq1EUgNuFWzld9XpCch2LwVzCyiR/57lzGOjt1X1+UcTDjz2GQ994GaJoI/8NlvfW + 1NSgvr4On544gas9V8Aw+mIcre0bsXPXbjQ0NOgVfrmpvhWcXxG3HkUBuBNYqal+G0qBNU2DKElIJBKY + mppC59mzGOjrhSRLEAUBDz/6KF7+5rf0aH++Cj/9yYrKe03yf/bJJ7jc3W2txNPc2oYdu3ahobERbrcb + rFHks5Iqv3zTnou4dSgKwN2EVcYGzJE/kUhgZmYG58+eQX+fPvKLooiHH30U33zlVYiiuKKAX6Hy3kB5 + Oaqrq1FfV4eTn32Gy5cuLZG/pRU7du1Co0l+ll3xlN68hUBF3FKshQComqbJJEkWp3bfRmg2n39mZhrn + zpxFf+8S+R96+BGL/IqirDjgl6+8t7q6GnV1dfj8t79F18WLYAzyNzU3Y8fu3WhqaoLHGPmBm/fjrUVX + 7g2Q0JcGW5NTWos6AHV+fj7W398/tQbffUdRsNGmLZef/40rzPfbtufOmDN9/pnpaZz98gz6rvZY5H/w + 4EP45iuvLI38NvIvV94bzFfeW1OD+vp6nP78c3RdumgF/BqbmrBjl05+r9erj/zmZ9vPzzj2go1R7Nfh + TvdVuM2g9OXEFqAvBf6VEQBFUZTMz372s7/leT5qNzuLKIACRLdvtxf5mD5/KBTCubNnMNB7FbIsQxAE + PHDgAF559VVIkrRU5GN+zirLe6tratDQ0IAvT32Bi52doGkaNE3rfft370FLc7NV4luwmccyfr257LYl + Eub+9wDcLhempqYGTp48+SvoFsCaLBC6Fg3WNAAYGRkJnzt3rvfAgQPtfr+/6l4TATNififTgPaRPxwO + 4+zp0+jv64Uky+D5DB48cACvfed3IEvyktmfY+pnlfdSlE7+nPLeQCCA6upqNDU24uzpUzh35ow18tc1 + NGDn7j1oa2uDx+OBg+OsWX1AgTkJgCVIdjeEMVwGO+klSdKv2V16v5iLm/T09n72p3/6pz/p7++/AiAF + 3Qq441irDosqAHV4eHjq7bff/mxxcTG8efPmOq/X6zdvvru95POGVoK9iXRfFvlDIXx5+pQe7ZckCDyP + Bx44gO9893uQJQmKIuf3+e3lvfYGnjnde6uqq9HY2IhzZ87gzOnToGkaDMOgtr4eu3bvQVt7ux7wM1bt + Wcl55BOAa2YFApAl6a5zAwiCAMdxcDgcmJmZufS3f/d3P//5z3/+32ZmZoagk1/EGrkAaymjJAAGgBOA + s7a2dsMPf/jDJ5977rknDhw4sI9lWR+g39jmEs3mv+1/c1/PItFKnhfatpJ9co/D9jpJkqDNbjbXKc3N + +x35vruAAGiqqkf7jZH/y1OnMNB7FaKxpPX+++/Hd773fYP8Srapb/zV/yyV987mRPvNCj/T7O88dw6n + Pz8JyiR/XT127N6Nje3tcHs8+pJdeY7VPB/rPIxzS6XTUI0VhjRNX22X47hrzP50JgNNVa/JEGQt0Jnn + mhXaZ7nn17xnFc/N4zfmXUQuXLhw5tz58yc6Ojp+G4/HJwEIANJYQ/8fWFsBMEECYAE4ALA0TZdt3ry5 + 7bvf/e7BnTt3PvDwww+3+3y+JvsbzDXa7binBKDQSJ/7uuEjm6m+2dlZfHn6tE5+UYQgCNi3fz++873v + Q5ENsz9PgY/+Z3mfP+D3o8ow+y+cO4dTp74ASZJgGAY1tbXYuWcv2vOY/dcQNc85FRIAB8dd897MOhUA + c3qzsXy4lkgmRy50dg4Mj4ycOnr06OlgMDiqqmoCOvEFABLWyO+3Yz0IgAkCelqSNR4MAFdbW1tDY2Nj + y2uvvba7ubl555YtWxobGxurALjtbzZFIffmWHcCsIwZv1oB0GwBv8jsLE6f0s1+k/x79+3D73z3+1BU + JXvkR4FUn1HeG8wp7w34/aisqsKGDRvQdeECTn72qR7BJklU19Zi9959aGtvh8fjAWeSf7nzznN+6XQa + Sq4AOBzX7M/z/JoKgCl65nOaoiArSmJqaiocDAbHpmdmLhw7erR7bn5+ZHx8fAoAjyXCS1jjET8X60kA + 7DDFgDH+0tAtBK6uri7Q0tLSVFlZ2Xjo0KH21tbWTT6fr7GxsbHM5/N5oYsHAJ0gqhEZVxVFjyibEXP7 + t90mAbCWr7pZAchjQWiaBkkUkUgmdfJ/8QUG+vsgCAJ4PoM9e/fjez/4gT7LT7b5/HlG/qzy3vHxpQo/ + w+yvrKpCc3Mzui5exGeffAyKokBRlDXyb960CS63G5y5Um+Bc7POKdcF0DSkMxmohlVnkotl2ez0JqBP + VLqNAgDjetjjN2Z2Q1YUMbG4mJiamoqJojgenJjo+/jjjwcSicTE+Pj4eCgUmodOdhE60U3CryvS27Fe + BSAXlPFgjL8klkTBRZIkt2fPnqqmpqYGt9tds2vXrvp9+/Y1lJWWVrnc7prS0lKfr6SEo2iaMT9QVVVr + kQtTKExxUFcqErh5AVjRwiA5N7Np9qdSKUQiEZw6edIifyaTwZ69e/GD138EWVYgy9Ky5CcAkBS1VN47 + Pm6V9wYCAVRWV6N5QzOudF/Cxx99BIqiQNM0qmpqsHP3HmzevBlut1sf+c3DLXDNsrbZ97meANhILhiT + lW5EAMxzhu1akCQJhmVBEoR5XaXE4iKfSCQWZEUJJZPJmcvd3ZNXenomZVmeDoVCk5cuXQqrqpoBkIE+ + wivQzXnZ9lhz834luFsEIBek8TCFgba9RgJwkCTpoiiKI0mS27hxY+n27dtry8rKqtxud3VlRUX59h07 + ympqagIej6eM47gyh8NR6nK5GIamSYIkQdpMZEmSIEuSJRKmYACwcukArhUAkry+GV9AQHLfYx8tRSPa + Pzc3hy9OnsTQQD94ngfP89i5ezd++MaPoRrNPa438l8zn99M9ZWXo6qqChuam9HT3Y0Tvzm+NPLX1GLH + 7t06+T0ecA5H/rTcCl0ATdOQyREAgiT19mBYuknzCYB9m30JMtasPdB9cqh6oFTNZDKyoigLkixH+Uwm + Oj8/H7t85cr8/NzcnCTL4WQyGerr65sZGBiIAeBVVc3IspyGPqqrtoed6AryaNvdgLtVAPKBMB6mMOSK + BGnfzjCMi+M4N03THEVRTo/H49q/f395XV1dwOv1lrpcrlKWZcs4jvO1tbX5amtrvR6Px+NwODiGYZwU + TTtpinISBEGTJAnSTjSDWGYdgJnJMK0Ns8AFxrbcAOY1VoH5uqpClmUsJhKYm5vDqc9PYqi/HxmehyAI + 2LFzJ37wozesrIBlxuYp8AH0kT8yO4vx3Aq/QACVlZVobm7G1Z4rOHH8uGXRVFVXY9fefdi0aRM8bjcc + HLdU73Ad9yZ3ApBJbrtvb34PSZJwsKw+jNrEVhAEPd6jqlD1iFtGVVVeluWMJMuZTDqdDM/OJkaGhxfT + mUxckeWYKIrxdDodD4XDc52dnXPJZDKlaRqvKEpaEMW0wPMZLJFZQzbJFWQTXyt0incj7iUBWA4EsgWC + zHle6EEAIBmGcfp8PpfD4XDRNM1SFOWgKMpBEATrcrmc7e3trvr6+hK/3+/xeDxejuM8Ho+nrKSkxEeS + pMvJcc7yigqupKTE4XA4WIZhaIqiaIqiaENAKJIkaZIgaBAETWApSGePWYiCgFQyiZlwGCc/+wy9PVfA + 8zwEgcf2HTvxg9d/BADZI7/tswC9ph9YIn8wGMT4+DhmzYCfQf6Wlhb09lzBRx9+CMJG/n0PPIht27bB + Y5r9JJllodhjAPY0oCF0CgBFVRRZ0zRZUVVFVRRZlmU5kUwKfCYjLiwuCjPT03w6k0mRBJFWNS0ly3JK + FMVkJpNJzs/Px2ZmZhb7+/oSi4mEAEDUNE1QVVVQFEUQJSmTTCRS6XQ6g6WR2U5epcDzXILfMyRfDl8V + AVgJiAIPMuevNYAW2MdueVjPA4EA5/F4nA6Hg6VpmjEEgCFJkjFEYEkA9AdDURRdV1fnqKqqcnAc5yQI + wsvzvF/k+YOaIrVlMrrZf9/2HXj9jTcA4Lpmv+nzm9H+8fHxrDx/ZVUVWlpb0X/1Ko4fO2qQn4TPVyqo + BHm+tq5u2uV2Cw6GkQAoiqoqmqqqoiSJfCYjpNJpIR6P89FoVJianBQzPC9B02QNkAwBkFRVVTRNkzRN + k1VFkRVVlURR5EVRFBKJhBCNRtPIT17N9rqCbLKa+8L2XMO1pP7KkHslKArAjYPI8zdXKOwPXOe5VmCb + WSfhdTgclS8dOvSHgVLfS5lMBplMBvdt34EfvfkmYAQGV+Lzz+aS3/D5Kyoq0NbaioGBfhzr6ABpmOIe + jyd28tTpn3Z1d5+EXrlmjq4m8pHMXt+ureKv/bmaZ1su0e1/i1gliv0Abhw3e/PlE998rzEASpxOJ/ON + Q4f+TWmJ96VMJgOe57HtvvvwxptvQsP1R357wM8q8rGR3zT7BwcHcOxwB8y4hsfrnT/XeeGPu7q7fwMg + CZ38udNXc0fV6420ua8XCbxGKArA2iHfTZ/7GgPAzTmd/m8cevEnZb6Sb6fTaQg8jy1bt+GNN38XACCJ + Yn7yE8SSOZKney/NMFk+//DgoD7yk5RF/kuXr/y7M2fPfgAgAb109a5IbxWxMhTXBVi/YAB4OY6rfPH5 + 5//E7/N9L51OQxAEbNm6FW+8+SYIgoAoitkZCOOvSX4AIIyA38TEBILBICK2iT2VFRVoaWnByPAwjh05 + DDMF6i0piV7u6fmjzz///DiK5L9nURSA9QkKgJtl2fIXn3/+jyoD/tdTBvk3bdqE13/8JkiStMhvIsvs + N16zAn4TExgfG0NkdhaUsWhHZUUFWlrbMD46iqMd7+vvIwh4fb54T2/fTz777cljABZRJP89i6IArD8Q + ABwURXmf/frXf7+qovyNVCoFnufRtnEj3vjd3wNFURANs19/B3FNbT9pFMRkRfttef6Kigq0trUhOD6K + jl+/Z72vxOdL9PYP/MnHn3xyGPrIn0KR/PcsigKw/kAAcOzauXP/hsaGf5lMJiEIAtrbN+Jf/evfB03T + FvkLBvwAq3vvuEH+sJHq8xvkb2trw0RwHO+/+65VRefz+VL9Q0M/+ejEiV+jOPJ/JVAUgPUHCgBVU1X1 + tCQInKLIqG9owL/9gz+Az+cDz/PXj/Ybtf1mMw9ruS4j4KeTP4hfv/OOVXfv8/mS/cPDPzl+/DfvYcnn + VwocYxH3CIoCsP5AkiTJiKLYJMkyFEXFgYMPoaKiApqm6evoAdeU95LGv4mcBp5ZAT8j2j85MYGOd9+B + apTe+ny+5ODI6J99+OHxd6GP/EWz/yuCogCsP2iqqmqqqkrmzLVUMglA7yfn9XoBLBPwy0312QJ+ra2t + mJmeQsd770JWFJC62Z8eGhv7D8c++OAdFM3+rxyKArD+oAKQnW73VZqmQVEUznx5GsFgEAzD6L3lzFZZ + WJremhXtN81+g/wVFRVoaW1FaGYav37nHWuikK+0NDMSDP7F0aPH3gKwAH3kL5r9XyGsVVPQIpYHzfN8 + etuWLc+LouhOLC5iLhLB3v37rW69sixnzZ5bNtrf2oa5SATvvP0WRFEERVHw+XzCWHDip4ePHP0nLJn9 + RfJ/xVAUgPUHDQCxuLiYLisrU6oqyx9XVBXTU1MgCGDbfduhqipoirL6Imb18DMn9tjM/rm5CH719lsQ + BQEkSaK0tFQaC078RceRI/9X07TiyP8VRlEA1idUAMTk1PTofdvu20CR5CZoGvr7+uDxeNHW3q43omRZ + hEIhjI2NXVvea5j90bk5vPP22+B5HhRFobS0VBoNTvz08JEjvyiSv4iiAKxPaABUWZa10Gx4cNu2bQdV + VS1XNQ29V3tQWlqGDS0tCIfDmJqawtjYGEKh0NJ8/ooKNLe0IBaN4t1f/RLpdNoa+UcnJv7T4SNH/neR + /EUARQFYz1ABaIlEIpFKpQc3bdz4hCRJbkVR0HPlMkiSgqppGBoawtzcHFiWRVlZmR7wa2nBQjyOd3/5 + NlKplBnwk8cnJn/W0XH4HwDEoc/sK5L/K46iAKxvKAAQmZubdXBccENT0+OSKHKKomCgv09vkSVKIAgC + lZWVqK+vx8ZNmxCPxfDLf/5/SCaTJvmV4NTUzzs6Dv8NiuQvwoaiAKx/KAC0YDAYZByOocaGhoOqorgV + RUFoeho0TaFpwwZsaG5GS0sLIrOz+Od/+kckEgnQNA2fz6cGJ6f/y/sdHX+taVqR/EVkoSgA6x8ajIaV + wWBwQhDFnpbm5p0kQQQURUE8Hkd0fh6xaBTDg4P47aef6OSnaJT4SrTxycm/7Dhy5H9qmhZDkfxF5KDY + EuzuAQl9HUVPXW3t5uefffYPGZp6MZVKWWscALA66paUeDE6MfmXR44c/StN06LQyb8mK9AWsX5RtADu + HpiWgJJIJGIDg4OfezzeSF19fS1NUeUOhwMsw8DBcXC73Ymx4MR/7Th85K8BFMlfREEULYC7EwwAFwBn + RUVF0769ex9SFHlXJp32lvn9kxOTUycuXbp0XtM0cz5/kfxF5EVRAO5emMurO7C0ZBoB3ceXsbRGXdHn + L6Ig/j+m73JTl3X5lgAAAABJRU5ErkJggigAAACAAAAAAAEAAAEAIAAAAAAAAAgBAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABTU1UBKSorDBcXFzIfICBfHx8f + QRUVFg1VVVcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAARERFAwYGBhxGRkiVYGFk9VtcYP9gYWX7P0BBjRcXFxFZWVsBAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEpKTAQPDw8nVldZxVpbX/91dnj/qamq + /3h4fP9cXWH+QUFCjBcXGBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABKSkwCCgoKIlpbXs5ZWl7/lZWX/42Njf+ampr/wMDA/3V2ef9cXWH+QUFCiRYWFxAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcHBNQUVOxWFle/7Cwsv/t7e3/tLS0 + /4GBgf+SkpL/vLy8/3N0eP9cXWH9QEFChRYXFw8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAqKisGMzM1cVpbX/+cnJ//9PT0/+Tk5f/c3N3/r6+v/4GBgf+SkpL/vLy8/3Jydf9cXWH9QEBC + ghYWFw8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkpKg1UVFfNbGxw//T09P/o6Oj/3t7e + /9/f4P/d3d3/r6+v/4GBgf+SkpL/u7u8/3BxdP9dXmL8P0BBfhYWFg8AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAJycoDlNUV9JxcnX/8/Pz/9zc3f/d3d7/39/f/9/f4P/d3d3/r6+v/4GBgv+SkpL/urq7 + /25vcv9dXmL8PT4/ehYWFg0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApKSoHOzs8fVtcYP+Jioz/39/g + /9zc3f/d3d7/3t7f/9/f4P/d3d3/r6+v/4GBgf+SkpL/urq6/21ucf9dXmL8PDw9eBYWFg0AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAjIyQTRERGmVpbYP+Jio3/39/g/9zc3f/d3d7/3t7f/+Dg4P/d3d3/r6+v + /4GBgv+SkpP/ubm5/2xtcP9dXmL7OTo7dBgYGQ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk5OUAZeXmAIpKSkVRkZI + nlpbX/+Li47/39/g/9zc3f/d3d7/39/f/9/f4P/d3d3/r6+v/4GBgf+SkpL/uLi4/2prb/9dXmL6NjY3 + chwcHBA6OjsEf3+AA4iJigOUlJUCoKChAqioqAGoqKkBpqanAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAALCwsAGwsLACVlZWBFhYWAVYWFkGWVlZCFhYWApZWVkMWVlaDwAAABMAAAAWDAwM + HhQUFCUXFxcqGRkZLxoaGzMbGxs4HR0dPTExMUY9PT1dY2Nly1lbX/+MjI//3t7f/9zc3f/d3d7/3t7f + /+Dg4P/d3d3/r6+v/4CAgf+SkpL/uLi4/2lqbv9dXmL6QUFDl0ZGRmVMTExcSkpKWUVFRVI6OjpKJiYm + QRoaGzsaGho3GRkZMhgYGC0WFhYpERERIQQEBBkAAAATUVFSEVBQUA9QUFALT09PCU9PTwdNTU0GTExM + BXFxcgOWlpcClZWWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAALS0tQJZWVkFWlpaCFtbWwtbW1wOBAQEGAkJCSMdHR0yOzs7RkVFRVhUVFRreHh4 + goSEhJOLi4qim5ubr7i4uLzFxcXI0tLT19nZ2eLn5+fq7e3u8PDw8PTx8fH48vLz/PLy8//z8/P/8vLz + /+/v8P/c3N3/j5CS/1pbX/+NjpH/39/g/9zc3f/d3d7/3t7f/+Dg4P/c3N3/rq6v/4GBgf+SkpL/tra3 + /2lqbf9hYmb/p6io/93d3v/n5+f/5ubn/+bm5//m5ub/5ubm/+Xl5v7k5OX74uLj99/f4PPR0dLtw8PE + 5ru7vNy7u7zRtLS1xp6enrd+fn6qeXl5nXNzdI1hYWF5QEBAYjo6O1AuLi49DAwMKQcHBx4oKCgTTExM + DEtLSwlKSkoGb29wA5OTkwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIaGhgRaWloIXV1dDgAAABohISExOzs7T2ZmZ3N/f3+Tr6+w + s7+/wMvg4ODd7Ozs7/Pz8/z39/f/9/f4//b29v/y8vL/8PDx/+/v7//u7u7/7e3u/+3t7f/w8PD/8fHx + //Hx8f/w8PH/8PDw/+/v7//u7u//7u7u/+7u7v/t7e7/7Ozt/+rq6v/Y2Nj/jo6R/1laXv+Pj5H/39/g + /9zc3f/d3d7/3t7f/+Dg4P/c3N3/r6+v/4CAgf+SkpP/tra2/2dobP9iYmb/paWm/9ra2v/j4+P/4+Pj + /+Li4//i4uL/4eHi/+Dg4f/g4OD/39/g/9TU1f/S0tP/1tbX/9nZ2f/Y2Nn/0NDR/9DQ0P/Pz9D/zs7P + /9DQ0P/T09P/0dHS/8/P0P7Jycr4xMTF57CwsdWcnJzAhYWFpF1dXYRJSUlhJiYmQA0NDSMlJSUTSkpK + CkhISAaPj48CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACqqqoBVlZWBy0tLREZGRkvU1NT + Yo6Ojpa8vLzB5OTk5fn5+fj7+/v/+vr6//j4+P/19fb/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx + //Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Dw8P/x8fL/8fHx//Dw8f/w8PD/8PDw/+/v8P/u7u//7u7u + /+3t7v/t7e3/7e3t/+rq6//X19f/jY2Q/1laXv+QkZP/3t7f/9zc3f/d3d7/3t7f/+Dg4P/c3N3/r6+v + /4GBgf+SkpL/tLS0/2Zna/9iY2f/pqan/9nZ2v/j4+P/4+Pj/+Pj4//i4uP/4eHi/+Hh4f/g4OD/1NTV + /9LS0//X19j/2tra/9ra2v/R0dH/0NDQ/8/P0P/Ozs//zs7O/83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK + /8nJyv/Jycr/ysrL/8vLzP/Nzc39wMDB8bCwsdOGhoesWFhYeSsrK0MHBwcbR0dICmZmZwMAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACpqakCKysrDCQkJDZ6enqHzc3Nz/r6+vf9/f3/+/v7//n5+f/5+fn/+Pj4//f39//29vf/9vb2 + //X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8PDx + //Hx8v/x8fH/8fHx//Hx8f/w8PD/7+/w/+7u7//u7u7/7u7u/+3t7v/t7e3/7Ozt/+rq6v/X19f/jY2P + /1laXv+RkpX/39/g/9zc3f/d3d7/3t7f/9/f4P/c3N3/r6+v/4GBgf+SkpP/srKz/2Vmav9jZGj/p6eo + /9ra2//j4+P/4+Pj/+Li4//i4uL/4uLi/+Hh4f/V1dX/0tLT/9jY2P/b29z/29vb/9HR0f/Q0ND/z8/Q + /87Oz//Ozs7/zc3N/8zMzf/Ly8z/y8vM/8rKy//Kysr/ycnK/8jIyf/IyMn/x8fI/8bGx//Gxsf/xcXG + /8TExf/Hx8j/x8fI/re3uOSGhoaqPDw8VicnJxdnZ2gFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe3t7AxERESSbm5uh+Pj49v39/f/8/Pz/+/v7 + //v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx + //Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/w8PH/8vLy//Ly8v/x8fL/8fHx//Dw8P/v7/D/7+/v + /+/v7//u7u//7e3u/+3t7f/t7e3/7Ozt/+rq6v/X19f/jIyO/1laXv+Sk5b/39/g/9zc3f/d3d7/3t7f + /9/f4P/d3d3/r6+v/4CAgf+SkpP/sbGy/2RlaP9kZWj/qamq/9vb2//k5OT/4+Pk/+Li4//i4uL/4uLi + /9XV1f/S0tP/2NjZ/9zc3P/c3Nz/0NDS/9DQ0P/Pz9D/zs7P/87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrL + /8rKyv/Jycr/yMjJ/8jIyf/Hx8j/xsbH/8bGx//Fxcb/xMTF/8TExf/Dw8T/w8PE/8LCw//Gxsf/p6eo + 0DU1NVBFRUUJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABUVFQOvb29vf7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3 + //b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t + //Hx8f/y8vP/8vLy//Hx8v/x8fH/8fHx//Dw8f/v7/D/7+/v/+7u7//u7u7/7u7u/+3t7v/s7O3/7Ozs + /+rq6v/W1tb/i4uO/1laXv+UlZf/3t7f/9zc3f/d3d7/3t7e/9/f4P/c3N3/r6+v/4GBgf+SkpP/sLCx + /2NkaP9kZWn/q6us/9vb2//j4+T/4+Pk/+Pj4//i4uP/1dXV/9LS0//Y2Nn/3d3d/93d3f/Q0NL/0NDQ + /8/P0P/Ozs//zs7O/83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK/8nJyv/IyMn/yMjJ/8fHyP/Gxsf/xsbH + /8XFxv/ExMX/xMTF/8PDxP/Dw8T/wsLD/8HBwv/BwcL/xcXG9SIiIjuIiIkBAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCxzw8PDo/v7+//39/f/8/Pz//Pz8 + //v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy + //Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8fHx//Ly8//y8vL/8vLy//Ly8v/x8fH/8PDx + //Dw8P/w8PD/7+/w/+7u7//u7u7/7u7u/+3t7v/t7e3/7Ozt/+np6f/V1tb/i4yO/1laXv+Vlpn/3t7f + /9zc3f/d3d7/3t7f/9/f4P/c3N3/r6+v/4GBgf+SkpP/rq6v/2JjZ/9lZmn/ra2u/9zc3P/k5OT/5OTk + /+Pj5P/V1dX/0tLT/9nZ2v/e3t//3t7f/9HR0v/Q0ND/z8/Q/87Oz//Ozs7/zc3N/8zMzf/Ly8z/y8vM + /8rKy//Kysr/ycnK/8jIyf/IyMn/x8fI/8bGx//Gxsf/xcXG/8TExf/ExMX/w8PE/8PDxP/CwsP/wcHC + /8HBwv/Hx8n/MDAwWouLjAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3 + //b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u + /+3t7f/x8fH/8vLz//Ly8v/y8vL/8vLy//Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v/+/v7//u7u//7e3u + /+3t7f/t7e3/7e3t/+rq6v/V1dX/ioqM/1hZXf+Wl5n/3t7f/9zc3f/d3d7/3t7e/+Dg4P/c3N3/r6+v + /4CAgf+SkpL/rq6v/2FiZv9mZmr/sLCw/9zc3P/j4+T/4+Pk/9XV1f/S0tP/2dna/9/f4P/f39//0dHS + /9DQ0P/Pz9D/zs7P/87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrL/8rKyv/Jycr/yMjJ/8jIyf/Hx8j/xsbH + /8bGx//Fxcb/xMTF/8TExf/Dw8T/w8PE/8LCw//BwcL/wcHC/8fHyf8wMDBaj4+QAwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8 + //z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz + //Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Dw8f/z8/P/8/Pz//Ly8//y8vL/8fHx + //Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v/+7u7//u7u7/7u7u/+3t7v/t7e3/7Ozt/+rq6v/U1NT/iYmL + /1laXv+YmJv/3t7f/9zc3f/d3d7/3t7f/9/f4P/c3N3/rq6v/4GBgf+SkpP/rK2u/2BhZf9mZ2v/sbKy + /93d3f/k5OT/1dXV/9LS0//Z2dr/4ODh/+Dg4P/R0dL/0NDQ/8/P0P/Ozs//zs7O/83Nzf/MzM3/y8vM + /8vLzP/Kysv/ysrK/8nJyv/IyMn/yMjJ/8fHyP/Gxsf/xsbH/8XFxv/ExMX/xMTF/8PDxP/Dw8T/wsLD + /8HBwv/BwcL/x8fJ/zAwMFqXl5gDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4 + //f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u + /+3t7v/t7e3/8fHx//Pz9P/z8/P/8vLz//Ly8v/y8vL/8fHy//Hx8f/x8fH/8PDx/+/v8P/v7+//7+/v + /+7u7//u7u7/7e3u/+3t7f/t7e3/7Ozt/+np6f/U1NT/iIiK/1laXv+Zmpz/3t7f/9zc3f/d3d7/3t7f + /+Dg4P/c3N3/r6+v/4CAgf+Tk5P/q6us/19gZP9naGz/s7O0/93d3f/V1dX/0tLT/9ra2//h4eL/4eHi + /9LS0v/Q0ND/z8/Q/87Oz//Ozs7/zc3N/8zMzf/Ly8z/y8vM/8rKy//Kysr/ycnK/8jIyf/IyMn/x8fI + /8bGx//Gxsf/xcXG/8TExf/ExMX/w8PE/8PDxP/CwsP/wcHC/8HBwv/Hx8n/MDAwWpubnAMAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39 + //z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0 + //Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/x8fH/8/P0//Pz8//z8/P/8/Pz + //Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw//Dw8P/v7/D/7u7v/+7u7v/u7u7/7u7u/+3t7v/t7e3/7e3t + /+rq6v/T09P/hoeJ/1hZXf+amp3/3t7f/9zc3f/d3d7/3t7e/+Dg4P/c3N3/r6+v/4GBgf+Tk5P/q6us + /15fY/9oaWz/tba2/8/Pz//S0tP/2trb/+Li4//j4+P/0tLT/9DQ0P/Pz9D/zs7P/87Ozv/Nzc3/zMzN + /8vLzP/Ly8z/ysrL/8rKyv/Jycr/yMjJ/8jIyf/Hx8j/xsbH/8bGx//Fxcb/xMTF/8TExf/Dw8T/w8PE + /8LCw//BwcL/wcHC/8fHyf8wMDBam5ucAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5 + //j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v + /+7u7v/t7e7/7e3t//Hx8f/09PT/9PT0//Pz9P/z8/P/8vLy//Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw + /+/v8P/v7+//7+/v/+7u7//u7u7/7u7u/+3t7v/t7e3/7Ozt/+np6v/S0tL/hYaI/1hZXv+cnJ7/3t7f + /9zc3f/d3d7/3t7f/9/f4P/c3N3/r6+v/4GBgf+Tk5P/qKmq/15fYv9pam3/q6ur/8vLzP/b29z/4+Pk + /+Tk5P/S0tP/0NDQ/8/P0P/Ozs//zs7O/83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK/8nJyv/IyMn/yMjJ + /8fHyP/Gxsf/xsbH/8XFxv/ExMX/xMTF/8PDxP/Dw8T/wsLD/8HBwv/BwcL/x8fJ/zAwMFqbm5wDAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+ + //39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0 + //Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8fHy//T09f/09PT/8/P0 + //Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy//Dw8f/w8PD/8PDw/+/v8P/v7+//7+/v/+/v7//u7u//7u7u + /+7u7v/t7e7/7Ozt/+rq6v/T09P/hISH/1haXv+dnaD/3t7f/9zc3f/d3d7/3t7f/+Dg4P/d3d3/r6+v + /4CAgf+Tk5P/qKip/11eYv9naGz/qqqr/9XV1v/k5OX/5eXl/9PT1P/Q0ND/z8/Q/87Oz//Ozs7/zc3N + /8zMzf/Ly8z/y8vM/8rKy//Kysr/ycnK/8jIyf/IyMn/x8fI/8bGx//Gxsf/xcXG/8TExf/ExMX/w8PE + /8PDxP/CwsP/wcHC/8HBwv/Hx8n/MDAwWpubnAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5 + //n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w + /+/v7//u7u7/7e3u/+3t7f/x8fL/9PT1//T09P/09PT/9PT0//Pz8//z8/P/8vLz//Ly8v/x8fL/8fHx + //Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v/+/v7//u7u//7u7u/+3t7v/t7e3/7e3t/+rq6v/R0dH/goOG + /1laXv+en6H/3t7e/9zc3f/d3d7/3t7e/+Dg4P/c3N3/r6+v/4GBgf+Tk5P/p6io/11eYf9oaGz/s7O0 + /9/f3//m5ub/09PU/9DQ0P/Pz9D/zs7P/87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrL/8rKyv/Jycr/yMjJ + /8jIyf/Hx8j/xsbH/8bGx//Fxcb/xMTF/8TExf/Dw8T/w8PE/8LCw//BwcL/wcHC/8fHyf8wMDBam5uc + AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v + 6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1 + //T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Hx8v/19fX/9fX1 + //T09f/09PT/8/Pz//Pz8//y8vP/8vLy//Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw//Dw8P/w8PD/7+/w + /+/v7//v7+//7u7v/+3t7v/t7e3/7e3t/+rq6v/R0dH/gYKE/1laXv+goKL/3t7f/9zc3f/d3d7/3t7f + /9/f4P/c3N3/r6+v/4GBgf+Tk5T/paan/1xdYf9qa2//urq7/+Dg4P/U1NT/0NDQ/8/P0P/Ozs//zs7O + /83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK/8nJyv/IyMn/yMjJ/8fHyP/Gxsf/xsbH/8XFxv/ExMX/xMTF + /8PDxP/Dw8T/wsLD/8HBwv/BwcL/x8fJ/zAwMFqbm5wDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6 + //n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw + /+/v8P/v7+//7u7u/+3t7v/t7e3/8fHy//X19f/19fX/9PT1//T09P/09PT/8/P0//Pz8//z8/P/8vLz + //Ly8v/y8vL/8fHy//Hx8f/x8fH/8PDx//Dw8P/v7/D/7+/v/+/v7//u7u//7u7u/+7u7v/t7e7/7e3t + /+rq6v/R0dH/f4CD/1lZXv+hoaT/3t7e/9zc3f/d3d7/3t7f/9/f4P/d3d3/r6+v/4CAgf+Tk5P/pKWm + /1xdYf9ra2//vLy9/8/Pz//Pz8//z8/Q/87Oz//Ozs7/zc3N/8zMzf/Ly8z/y8vM/8rKy//Kysr/ycnK + /8jIyf/IyMn/x8fI/8bGx//Gxsf/xcXG/8TExf/ExMX/w8PE/8PDxP/CwsP/wcHC/8HBwv/Hx8n/MDAw + WpubnAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsL + He/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1 + //T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/y8vL/9fX2 + //X19f/19fX/9fX1//T09P/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw + //Dw8P/v7/D/7+/v/+/v7//u7u//7u7u/+7u7v/t7e7/7e3t/+rq6v/Pz8//fn+B/1lZXv+io6T/3d3e + /9zc3f/d3d7/3t7e/9/f4P/c3N3/r6+v/4GBgf+Tk5P/o6Ol/1xdYf9rbHD/rq6v/8rKyv/Pz9D/zs7P + /87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrL/8rKyv/Jycr/yMjJ/8jIyf/Hx8j/xsbH/8bGx//Fxcb/xMTF + /8TExf/Dw8T/w8PE/8LCw//BwcL/wcHC/8fHyf8wMDBampqbAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7 + //r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx + //Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Ly8v/19fb/9fX1//X19f/19fX/9PT0//T09P/z8/T/8/Pz + //Pz8//y8vP/8vLy//Ly8v/x8fL/8fHx//Hx8f/x8fH/8PDx//Dw8P/w8PD/7+/w/+/v7//v7+//7u7v + /+7u7v/u7u7/7e3u/+rq6v/Pz8//fH1//1laXv+jpKb/3t7f/9zc3f/d3d7/3t7f/9/f4P/c3N3/r6+v + /4GBgf+Tk5P/oaKj/1tcYP9qa27/rKys/8vLzP/Ozs//zs7O/83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK + /8nJyv/IyMn/yMjJ/8fHyP/Gxsf/xsbH/8XFxv/ExMX/xMTF/8PDxP/Dw8T/wsLD/8HBwv/BwcL/x8fJ + /zAwMFqRkZIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2 + //X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8vLy + //b29v/29vb/9fX2//X19f/19fX/9PT1//T09P/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy + //Hx8f/x8fH/8PDx//Dw8P/w8PD/7+/w/+/v7//v7+//7u7v/+7u7v/u7u7/7u7u/+rq6//Pz9D/fH1/ + /1hZXf+kpaf/3d3e/9zc3f/d3d7/3t7e/+Dg4P/c3N3/r6+v/4CAgf+Uk5P/oaGj/1tcYf91dXj/wsLD + /87Oz//Ozs7/zc3N/8zMzf/Ly8z/y8vM/8rKy//Kysr/ycnK/8jIyf/Hx8j/xcXG/8PDxP/BwcL/wcHB + /8DAwf/BwcL/wcHC/8LCw//CwsP/wcHC/8HBwv/Hx8n/MDAwWoODhAMAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7 + //v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx + //Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/y8vL/9vb3//b29v/29vb/9vb2//X19f/19fX/9PT1 + //T09P/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/y8vL/8vLy//Hx8v/x8fH/8fHx//Dw8f/w8PD/8PDw + /+/v8P/v7+//7+/v/+7u7//u7u7/7u7u/+rq6v/Ozs7/ent+/1laXv+mpqj/3d3e/9zc3f/d3d7/3t7f + /9/f4P/c3N3/rq6v/4CAgP+Wlpb/c3R3/2trbv+3t7f/zs7P/87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrK + /8bGxv/AwMH/tra3/6qqq/+ZmZr/mJiZ/5SVlv+QkZL/lJWW/5iYmf+Wlpj/pqan/6+vsP+4uLn/vb2+ + /8fHyP8wMDBafn5/AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3 + //b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8f/w8PD/7+/v/+7u7v/u7u7/7e3t + //Ly8//39/f/9vb2//b29v/29vb/9fb2//X19f/19fX/9fX1//T09f/09PT/9PT0//Pz9P/z8/P/8/Pz + //Ly8//y8vL/8vLy//Hx8v/x8fH/8fHx//Dw8f/w8PD/8PDw//Dw8P/w8PD/7+/w/+/v7//v7+//7u7v + /+rq6v/Ozs7/enp9/1laXv+np6r/3t7f/9zc3f/d3d7/3t7f/+Dg4P/V1db/paWl/66srf9cXWH/Z2hr + /6enqf/Jycr/zs7O/83Nzf/MzM3/ycnK/8HBwv+vr6//l5eZ/3x9f/9sbXD/YmNn/2NkaP9iY2f/Y2Ro + /2Rlaf9iY2j/YWJm/2JjZ/9iY2f/aWpt/3p6ff+PkJH/rKyu/ysrLGFhYWIGAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8 + //v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//39/f/9/f3//b29v/19fb/8/Pz//Hx8f/u7u7/6urr + /+bm5//j4+P/4ODh/97e3//c3Nz/2tra/9nZ2f/Y2Nj/2NjY/9jY2f/Y2Nj/2NjY/9fX1//X19f/1tbX + /9bW1v/W1tb/1dXW/9XV1v/V1db/1dXW/9XV1f/V1dX/1dXV/9XV1f/V1dX/1dXV/9XV1f/V1dX/1dXV + /9XV1f/V1dX/1NTV/9TU1f/U1NX/1NTV/9TU1f/U1NX/1NTV/9HR0v+4uLj/dHR3/1laXv+nqKn/3d3e + /9zc3f/d3d7/1tbX/8nJyv/Y19f/8e3s/5SUlf9bXGD/bG1w/6+vsP/MzM3/zMzM/8LCwv+mpqf/gICC + /2Vnav9jZGj/cnN2/5GRk/+tra//w8TF/9HR0v/X19f/2dna/9XV1f/MzM7/vb6//6WmqP+Jioz/bW5x + /2BhZf9lZmr/TU5QxB4eHkgeHh8PT1BRAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+vr6//j4+P/y8vL/6Ojo + /9/f4P/W1tb/z8/R/8nJyv/Hx8j/xMTG/8PDxf/Dw8X/w8PF/8TExf/ExMX/xMTF/8TExf/ExMX/xMTG + /8TExv/ExMb/xMTG/8TExv/ExMb/xMTG/8TExv/ExMb/xMTG/8TExv/ExMb/xMTG/8TExv/ExMb/xMTG + /8TExv/ExMb/xMTF/8TExf/ExMX/xMTF/8TExf/ExMX/xMTF/8TExf/ExMX/xMTG/8TExv/ExMb/xMTG + /8TExv/ExMb/xMTG/8HBwv+qqqv/cHBz/1laXv+oqar/3d3e/9nZ2v/Pz8//zc3O/9nZ2v/W1tf/7enp + /7i1t/9aW1//cHF0/6amp/+jo6T/fH1//2NkZ/9ub3L/mpuc/83Nzf/p6en/8/Pz//Ly8v/v7/D/7+/w + /+/v7//u7u7/7e3t/+zs7P/q6ur/6+vr/+rq6v/e3t//vr/A/46Okf9mZ2v/YGBk+lJSVbcbGxs+GRkZ + C2ZmaAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8 + //39/f/4+Pj/6Ojp/9XV1v/ExMX/urq8/7W1t/+ztLb/tLS3/7W1uP+1tbj/tba4/7W2uP+1trj/tba4 + /7W1uP+0tbf/tLS2/7O0tv+ztLb/tLS2/7S0t/+0tLf/tbW4/7m5vP+7vL7/vr7A/7+/wf/AwcP/wsLE + /8TExv/Gxsj/yMjK/8rKzP/LzM3/zc3P/87O0P/OztD/zs7Q/8/P0f/Pz9H/0NDR/9DQ0f/Q0NH/0NHS + /9DQ0f/Pz9D/zs7Q/83Nz//Mzc7/y8zN/8vLzP/Kysz/ycnL/8jIyv/Gxsj/xMTG/8DAwf+oqKr/cHF0 + /1laXv+qqqz/3Nzc/8HBwv/W1tb/3+Dh/+Hh4v/q5+f/8u3s/4mJiv9ZWl7/amtv/2NkaP9ub3L/qqqs + /+Pj5P/19fX/8/Pz//Ly8v/t7e3/5OTk/9/f4P/V1db/09PT/9TU1f/T09T/1tbW/97e3v/f39//5eXl + /+fn6P/m5uf/5+fn/9HR0v+XmJr/ZWZq/19hZPRBQkONBwcHGk5PUAQAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//z8/P/h4uL/v7/B/6mqrP+kpab/paao/6anqP+mp6j/pqao + /6Wmp/+kpaf/o6Sm/6Okpv+oqar/rK2u/7O0tf+7vL3/w8PE/8rKy//R0tL/2NjZ/9zd3v/g4OH/4+Pk + /+fn5//p6en/7u7u//Dw8P/y8vH/8fHy//Ly8v/w8PD/8PDw/+/v7//v7+//7u7v/+3t7v/t7e3/7Ozs + /+vr7P/r6+v/6+vr/+rq6v/p6er/6enp/+np6f/o6On/6Ojo/+fn5//m5uf/5ubm/+bm5v/l5eb/5eXl + /+Tk5f/k5OT/4+Pj/+Pj4//j4+P/4+Pj/93d3v/CwsL/dHV4/1pbX/9pam3/Xl9j/6WmqP/e3t//3Nzd + /+bl5f/Z2tr/5+Xj/6elp/9hYmb/lpeZ/+Dh4f/29vb/9PT0//Dw8P/f3+D/0dHS/8jIyf+5ubv/qKmq + /5+fov+YmJv/lZWX/5qanP+io6b/rq6w/8LCw//R0dL/1tbX/9rb2//i4uL/4+Pk/+Tk5f/LzMz/g4SG + /19gZP9YWFvIFBUVNFFRUgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJGuzs7Ofo6On/paWp + /5SVmf+Wl5v/lpeb/5WWmv+TlJj/l5ib/6Gipf+ur7L/wMHD/9DR0//d3d//6Onp/+/v8P/z8/T/9fX1 + //T09P/z8/T/8vLy//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/w8PD/8fHy//Hx8f/w8PH/8PDw + /+/v7//v7+//7u7v/+7u7v/t7e7/7Ozt/+zs7P/s7Oz/6+vs/+vr6//q6uv/6urq/+rq6v/p6er/6enp + /+jo6f/n5+j/5+fn/+fn5//m5uf/5ubm/+Xl5v/l5eX/5OTl/+Tk5P/j4+T/4+Pj/+Li4//i4uL/4eHi + /9zc3P/CwsP/iIiL/2Zmav9naGz/YGFl/8TExf/h4eL/4eHj/+vr6//y7+//xcLD/7y9vv/09PX/9fX0 + //Hx8v/a2tv/ycnL/7Gxs/+RkpT/hoeJ/4yNj/+UlZb/lZWX/5OUlv+OjpH/jY6Q/4qLjf+HiIr/g4SH + /4eIi/+cnZ//v7/B/9fX1//Y2Nn/4ODg/+Hh4f/f39//pKWn/2NlaP9fYGTnICAgR1FSUwgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABSUlMMqKmps42Okf+HiIv/hYaJ/4uMj/+io6b/w8TF/93d3v/w8PD/+fn4 + //r6+v/4+Pn/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v + /+7u7v/t7e7/7e3t//Dw8f/x8fL/8fHx//Dw8f/w8PD/8PDw/+/v8P/u7u//7u7u/+3t7v/t7e3/7e3t + /+zs7f/r6+z/6+vr/+vr6//r6+v/6urr/+np6v/p6en/6Ojp/+jo6P/o6Oj/5+fo/+bm5//m5ub/5ubm + /+bm5v/l5eb/5OTl/+Pj5P/j4+P/4+Pj/+Pj4//i4uP/4eHi/9/f3//X19f/xcXG/6mpqv9oaWz/YmNn + /6+vsf/p6en/7+/w/7q7vP/S09P/9/f3//X19f/j4+P/ysrL/6urrf+Fhon/jo+R/6ioqf+zs7T/ubm6 + /7u7u/+9vb7/vLy9/7m6uv+zs7T/qamr/5ycnv+PkJL/h4iK/4aGif+DhIb/kJGU/r6+v//Z2dn/2dna + /+Dg4P/g4OH/u7u9/2lqbf9fYGPuISEiUlFSUwgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH19fgMfHx87fH6A + 7Zyen//R0tP/9fX1//39/f/8/Pz/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0 + //Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8PDx//Hx8v/x8fH/8fHx + //Hx8f/w8PD/7+/w/+/v7//v7+//7u7v/+3t7v/t7e3/7Ozt/+zs7P/s7Oz/6+vs/+vr6//q6uv/6urq + /+rq6v/p6er/6Ojp/+jo6P/o6Oj/5+fo/+fn5//m5uf/5ubm/+Xl5v/l5eX/5OTl/+Tk5P/j4+T/4+Pj + /+Pj4//i4uP/4uLi/+Hh4f/V1dX/zMzN/6qqq/9pa27/YGFl/9bX1/+3uLn/29vc//b29//09PT/1dXW + /7y8vv+IiYz/kJGS/66urv+5ubr/vr6+/76+v/++vr//vb2+/7y8vf+8vL3/u7u8/7q6u/+6urv/urq7 + /7m5uv+vsLD/m52e/4WHif57e3zChYWHr5ubnvXT09P/19fY/93d3f/d3d7/w8PE/2prb/9eX2PuICAh + RlBQUgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAfX1+BS0tLUXd3d3f/v7+//39/f/8/Pz/+/v7//v7+//6+vr/+fn5 + //n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w + /+/v7//u7u7/7e3u/+3t7f/w8PH/8vLy//Ly8v/x8fL/8fHx//Dw8P/w8PD/7+/w/+/v7//u7u//7u7u + /+7u7v/t7e7/7Ozt/+zs7P/s7Oz/7Ozs/+vr7P/q6uv/6urq/+np6v/p6en/6enp/+jo6f/n5+j/5+fn + /+fn5//n5+f/5ubn/+Xl5v/l5eX/5eXl/+Tk5f/k5OT/4+Pk/+Pj4//j4+P/4uLi/9XV1f/S0tP/0NDR + /6Wmp/9eX2P/dnd6/9ra2//39/f/8/Pz/87Oz/+urq//gYGE/6enqP+5ubr/wMDA/8DAwP+/v8D/vr6/ + /76+vv+8vL3/vLy9/7y8vP+7u7v/urq7/7q6u/+5ubn/ubm5/7i4uP+4uLn/t7e4/pGRka+IiIhlkpKS + d5CQktvFxcf/2dna/9vb2//c3N3/v7/A/2Vmav9eX2LjDw8PLE5OTwMAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCwR1tbW + 1P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1 + //T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Hx8f/y8vP/8vLy + //Hx8v/x8fH/8fHx//Dw8f/v7/D/7+/v/+/v7//u7u//7u7u/+3t7v/t7e3/7e3t/+zs7f/s7Oz/6+vs + /+vr6//r6+v/6urr/+np6v/p6en/6Ojp/+jo6P/o6Oj/5+fo/+fn5//m5uf/5ubm/+Xl5v/l5eX/5OTl + /+Tk5P/k5OT/4+Pk/+Pj4//i4uP/1dXV/9LS0//Ly8z/iIiL/2dobP/MzM3/9/f3//T09P/Nzc7/paao + /4iIiv+wsLH/vr6//8HBwv/AwMH/wMDA/76+v/++vr7/vr6+/7y8vf+8vLz/u7u8/7u7u/+6urv/ubm6 + /7i4uf+5ubn/uLi5/7e3uP+3t7j/vb29/oqKiomfn59el5eXZ5KTlMK+vsD/29vb/9nZ2v/b29v/rq+w + /19gZP9VVVi8HR4eFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3w8PDo/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6 + //n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw + /+/v8P/v7+//7u7u/+3t7v/t7e3/8fHx//Ly8//y8vL/8vLy//Ly8v/x8fH/8PDx//Dw8P/w8PD/7+/w + /+7u7//u7u7/7u7u/+3t7v/t7e3/7Ozt/+zs7P/s7Oz/6+vs/+vr6//q6uv/6urq/+rq6v/p6er/6Ojp + /+jo6P/o6Oj/6Ojo/+fn6P/n5+f/5ubn/+bm5v/l5eb/5eXl/+Xl5f/k5OX/5OTk/+Pj5P/V1dX/zc3O + /6Skpf9iY2f/rKyu//j4+P/29vb/0dHS/6eoqv+Kioz/tLS0/7+/wP/BwcL/wMDB/8DAwP+/v7//vr6/ + /76+vv+9vb7/vLy9/7y8vP+7u7z/urq7/7q6uv+5ubr/ubm5/7m5uf+4uLn/t7e4/7e3uP+7u7z/h4eI + lqOjo2CmpqZgnJycZ5eXmb3Cw8T/2dna/9jY2P/a2tr/kJGT/11eYv83Nzh2NDQ1CAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsL + He/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1 + //T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/x8fH/8/Pz + //Pz8//y8vP/8vLy//Hx8f/x8fH/8PDx//Dw8P/v7/D/7+/v/+/v7//u7u//7e3u/+3t7f/t7e3/7e3t + /+zs7f/r6+z/6+vr/+vr6//q6uv/6urq/+rq6v/p6er/6enp/+jo6f/o6Oj/6Ojo/+fn6P/m5uf/5ubm + /+bm5v/m5ub/5eXm/+Tk5f/k5OT/5OTk/9XV1f+9vb7/b3Bz/4GChf/v8PD/9vb2/9vb3P+1tbb/hYaI + /7S0tP/BwcH/wcHB/8HBwf/AwMH/v7/A/7+/v/++vr//vb2+/729vv+8vL3/u7u8/7u7vP+6urv/ubm6 + /7q6uv+5ubn/ubm5/7i4uf+3t7j/t7e3/7u7vP+KiouXpKSkYqioqGOoqKhln5+fa5eYmsvR0dL/1tbX + /9fX2P/Q0dL/bW5y/15fY+oPDxAqZWZnAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7 + //r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx + //Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Dw8f/z8/P/8/Pz//Ly8//y8vL/8vLy//Hx8v/w8PH/8PDw + //Dw8P/v7/D/7+/v/+7u7//u7u7/7u7u/+3t7v/t7e3/7Ozt/+zs7P/s7Oz/6+vs/+vr6//r6+v/6urr + /+np6v/p6en/6enp/+np6f/o6On/5+fo/+fn5//n5+f/5ubn/+bm5v/m5ub/5eXm/+Xl5f/k5OX/z8/P + /5eXmf9kZWn/ysvM//b29//s7Oz/w8LE/4OEhv+urq//wMDB/8LCwv/BwcL/wMDB/8DAwP+/v8D/vr6/ + /76+vv+9vb7/vLy9/7y8vP+7u7v/u7u7/7q6u/+6urr/ubm6/7m5uf+4uLn/uLi4/7e3uP+3t7j/u7u8 + /4uLi5qlpaVlqampZaqqqmepqalqoqKidZ2doObh4eH/1NTV/9fX1/+srK7/XV5i/0RFR5U1NTYKAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2 + //X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8fHx + //Pz9P/z8/P/8/Pz//Pz8//y8vL/8fHy//Hx8f/x8fH/8PDx/+/v8P/v7+//7+/v/+7u7//u7u7/7u7u + /+7u7v/t7e7/7Ozt/+zs7P/s7Oz/6+vs/+vr6//q6uv/6urq/+rq6v/p6er/6enp/+np6f/o6On/5+fo + /+fn5//n5+f/5+fn/+bm5//m5ub/5ubm/+Xl5f/BwcH/bW5x/4qLjf/19fX/9vb2/9DQ0P+XmJr/oKCh + /76+v//CwsP/wcHC/8DAwf+/v8D/v7/A/76+v/++vr7/vb2+/7y8vf+8vLz/u7u8/7q6u/+7u7v/ubm6 + /7m5uv+5ubn/uLi5/7i4uf+4uLj/t7e4/7e3uP+8vLz/j4+QnqmpqWysrKxsrq6ub6+vr3GsrKx0pqen + k7S0tvzd3d3/1dTV/9PU1P90dXf/X2Bk7g0NDShlZWcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7 + //v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx + //Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/x8fH/8/P0//Pz8//z8/P/8/Pz//Ly8v/y8vL/8fHy + //Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v/+/v7//u7u//7u7u/+3t7v/t7e3/7e3t/+zs7f/r6+z/6+vr + /+vr6//q6uv/6urq/+rq6v/q6ur/6enq/+jo6f/o6Oj/6Ojo/+fn6P/n5+f/5+fn/+bm5//m5ub/4uLi + /6Kio/9jZGj/x8jJ//b29v/o6Oj/u7u8/4iJi/+3t7j/wcHC/8HBwv/AwMH/wMDA/7+/wP++vr//vr6+ + /729vf+9vb7/vLy9/7y8vf+7u7z/u7u7/7q6u/+6urr/ubm6/7m5uv+5ubr/ubm6/7m5uf+4uLj/uLi5 + /7y8vf+UlJSjra2tdLCwsHSysrJ2srKyeLOzs3qvr698oqKky9vc3P/T09P/1NTV/6ioqv9cXWH/ODg5 + fDQ0NQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3 + //b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t + //Hx8f/09PT/9PT0//Pz9P/z8/P/8/Pz//Ly8//x8fL/8fHx//Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v + /+7u7//u7u7/7u7u/+3t7v/t7e3/7e3t/+zs7f/s7Oz/6+vs/+vr6//r6+v/6urr/+rq6v/q6ur/6enq + /+np6f/o6On/6Ojo/+jo6P/n5+j/5+fn/+fn5//c3Nz/fn+B/3d4e//u7u//9fX1/9HR0v+Wl5n/qKip + /7+/wP/BwcH/wMDB/8DAwP+/v7//vr6//76+vv+9vb7/vb29/7y8vf+8vLz/vLy8/7u7u/+7u7v/u7u7 + /7q6u/+6urv/urq6/7q6uv+6urr/ubm6/7m5uv+5ubr/vb2+/5qamqixsbF7tLS0e7W1tX22trZ/tra2 + gba2toKzs7SRtLW2+t7e3v/T09P/zMzM/2Znav9ZWV3NHR4eEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8 + //v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy + //Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8fHy//T09f/09PT/9PT0//T09P/z8/P/8vLz + //Ly8v/y8vL/8fHy//Hx8f/x8fH/8PDx//Dw8P/w8PD/7+/w/+/v7//u7u//7u7u/+7u7v/t7e7/7e3t + /+3t7f/s7O3/7Ozs/+zs7P/r6+z/6+vr/+rq6//q6ur/6enq/+np6f/p6en/6enp/+jo6f/o6Oj/5+fn + /8rKy/9oaWz/oaKk//f39//u7u7/w8PE/4mKjP+4uLj/wMDB/8DAwP/AwMD/v7+//76+v/++vr7/vr6+ + /729vf+9vb3/vLy9/7y8vP+8vL3/vLy8/7y8vP+7u7z/u7u7/7u7u/+6urv/urq7/7u7u/+7u7v/urq7 + /7u7vP++vr//np6frbW1tYK3t7eCubm5hLq6uoW6urqHu7u7iLu7u4inqKnX4+Pk/9HR0v/T09T/hoeJ + /19gZPoXFxc1Z2hqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3 + //b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u + /+3t7f/x8fL/9PT1//T09P/09PT/9PT0//Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy//Hx8f/w8PH/8PDw + //Dw8P/v7/D/7+/v/+/v7//u7u//7u7u/+7u7v/t7e7/7e3t/+zs7f/s7Oz/7Ozs/+vr7P/r6+v/6+vr + /+rq6//q6ur/6urq/+np6v/p6en/6enp/+jo6f/l5eX/s7S0/2NkZ//Kysv/9fX1/9/f4P+sra//nZ2f + /729vf/AwMH/v7/A/8DAwP++vr//vr6//76+v/++vr7/vb2+/729vv+9vb7/vb29/729vf+8vLz/vLy9 + /7y8vf+8vLz/vLy9/7y8vf+8vLz/vLy9/7y8vP+7u7z/vLy8/8DAwf+jo6Oxubm5iby8vIi8vLyLvb29 + jL6+vo2/v7+Ov7+/kLi4uKvNzc7/1dTV/9HR0v+pqqz/W1xg/zU1NnI0NTYFAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8 + //z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz + //Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Hx8v/19fX/9fX1//T09f/09PT/9PT0 + //Pz9P/y8vP/8vLy//Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw//Dw8P/w8PD/7+/w/+/v7//v7+//7u7v + /+7u7v/u7u7/7e3u/+zs7f/s7Oz/7Ozs/+zs7P/r6+z/6+vr/+rq6//q6ur/6urq/+rq6v/p6er/6enp + /+Li4/+ampz/a2xv/+Tk5P/19fX/09PU/5WWmP+0tLX/wMDA/8DAwf+/v8D/v7/A/7+/v/++vr//vr6/ + /76+v/++vr7/vr6+/76+vv++vr7/vr6+/729vv+9vb7/vr6+/76+vv+9vb7/vb29/729vv++vr7/vb2+ + /729vv++vr7/wcHC/6enqLS8vLyPv7+/jsDAwJDBwcGSwcHBksPDw5PExMSVxsbGmLa2uPjf3+D/0NDR + /8LCw/9eX2P/RUZIpzk5OgkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4 + //f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u + /+3t7v/t7e3/8fHy//X19f/19fX/9PT1//T09P/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy + //Hx8f/x8fH/8PDx//Dw8P/w8PD/7+/w/+/v7//v7+//7u7v/+7u7v/u7u7/7e3u/+3t7f/t7e3/7e3t + /+zs7f/r6+z/6+vr/+vr6//q6uv/6urq/+rq6v/p6er/4ODg/4KChf96e37/8fHx//Pz8//MzM3/j5CT + /7+/v//BwcH/wMDB/8DAwf/AwMD/wMDA/7+/wP+/v8D/v7/A/7+/v/+/v7//v7+//7+/v/+/v7//vr6/ + /7+/v/+/v8D/v7+//7+/v/+/v7//v7/A/7+/wP+/v8D/v7+//8DAwP/Dw8T/rKysucDAwJTDw8OUxMTE + lsXFxZfGxsaXxsbGmMfHx5rLy8uYsLCy4ubm5v/Ozs//zc3O/2lqbf9XWFvPPDw9DwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39 + //z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0 + //Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/y8vL/9fX2//X19f/19fX/9fX1 + //T09P/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy//Hx8f/x8fH/8fHx//Dw8f/w8PD/8PDw + /+/v8P/u7u//7u7u/+7u7v/t7e7/7e3t/+3t7f/t7e3/7Ozt/+zs7P/r6+z/6+vr/+vr6//r6+v/6urr + /+rq6v/a2tv/eXp8/4yNj//09PT/7u7u/8PDxf+Xl5r/wcHB/8HBwf/BwcL/wcHB/8HBwf/BwcH/wMDB + /8HBwf/AwMH/wMDA/8DAwP/AwMH/wMDB/8DAwf/AwMH/wcHB/8HBwf/BwcH/wcHB/8HBwf/BwcH/wsLC + /8LCwv/CwsL/wsLD/8bGxv+xsbG8xcXFmcfHx5nHx8ebyMjInMnJyZ3Kysqey8vLn83NzZ20tbfS5ubn + /87Ozv/R0dH/dHV4/1xdYOUJCQkaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5 + //j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v + /+7u7v/t7e7/7e3t//Ly8v/29vb/9vb2//X19v/19fX/9fX1//T09f/09PT/9PT0//Pz9P/z8/P/8/Pz + //Ly8//y8vL/8vLy//Hx8v/x8fH/8fHx//Dw8f/w8PD/8PDw/+/v8P/v7+//7+/v/+7u7//u7u7/7u7u + /+7u7v/t7e7/7e3t/+zs7f/s7Oz/7Ozs/+zs7P/r6+z/6+vr/9bW1v9xcXX/mZqb//b29v/t7e7/v7/A + /56eoP/ExMT/wsLC/8LCw//CwsL/wsLC/8LCwv/BwcL/wsLC/8LCwv/CwsL/wsLC/8LCwv/CwsL/wsLC + /8LCw//CwsP/w8PD/8PDw//Dw8P/w8PD/8TExP/ExMT/xMTE/8TExP/FxcX/yMjI/7S0tb/Jycmey8vL + nszMzKDNzc2gzc3Nos7OzqLPz8+j0NDQpLy9vsXi4uP/zMzN/9DQ0P+BgYT/ZGVo8w8PDycAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+ + //39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0 + //Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8vLy//b29v/29vb/9fX2 + //X19f/19fX/9PT1//T09P/09PT/8/P0//Pz8//z8/P/8/Pz//Ly8//y8vL/8vLy//Ly8v/x8fL/8fHx + //Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v/+/v7//u7u//7u7u/+7u7v/t7e7/7e3t/+3t7f/s7O3/7Ozs + /+zs7P/r6+z/09PU/2pqbv+en6H/9fX1/+jo6f+9vr7/n6Ci/8bGxv/Dw8P/w8PE/8PDxP/Dw8P/w8PD + /8PDxP/Dw8T/w8PE/8PDxP/ExMT/xMTE/8TExP/ExMX/xMTF/8XFxf/FxcX/xcXF/8XFxv/Fxcb/xsbG + /8bGx//Gxsf/x8fH/8fHx//Ly8v/ubm5ws3NzaPPz8+jz8/PpNHR0aTR0dGm0tLSptPT06fV1dWpvr6/ + wd3d3v/Ozs//zs7P/4WGiP9iY2f4Dg4OLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5 + //n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w + /+/v7//u7u7/7e3u/+3t7f/y8vL/9vb3//b29v/29vb/9vb2//X19f/19fX/9PT1//T09P/09PT/8/P0 + //Pz8//z8/P/8vLz//Ly8v/y8vL/8vLy//Hx8v/x8fH/8fHx//Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v + /+/v7//v7+//7u7v/+7u7v/t7e7/7e3t/+3t7f/t7e3/7Ozt/+zs7P/U1NX/amtu/56eof/09PT/5+fn + /729v/+jo6X/yMjI/8XFxf/Fxcb/xcXF/8XFxv/FxcX/xcXG/8XFxv/Fxcb/xsbG/8bGxv/Gxsf/xsbH + /8bGx//Hx8f/x8fH/8fHyP/Hx8f/x8fI/8jIyP/Jycn/ycnJ/8nJyv/Jycr/ysrK/83Nzf++vr7F0dHR + p9PT06fU1NSo1NTUqdXV1arV1dWq1tbWrNjY2K3CwsPC3Nzd/87Ozv/Ozs7/hoeK/2FiZvoNDQ0vAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v + 6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1 + //T09P/z8/T/8/Pz//Ly8v/x8fL/8vLy//Hx8f/w8PD/7+/v/+7u7v/t7e3/7Ozs//Dw8f/19fX/9PT0 + //T09P/z8/P/8/Pz//Ly8v/x8fH/8fHx//Hx8f/w8PD/8PDw//Dw8P/v7+//7+/v/+7u7//u7u7/7u7u + /+3t7v/t7e3/7e3t/+3t7f/t7e3/7Ozt/+zs7P/s7Oz/6+vs/+vr6//r6+v/6+vr/+vr6//r6+v/6urr + /+rq6v/q6ur/6urq/9XV1f9wcXT/mJmb//Pz8//r6+z/wcHC/6Okpv/Lysv/x8fH/8fHx//Hx8f/x8fH + /8fHx//Hx8j/x8fI/8jIyP/IyMj/yMjI/8jIyf/Jycn/ycnJ/8nJyf/Jycr/ysrK/8rKyv/Kysr/ysrL + /8vLy//MzMz/zMzM/8zMzf/Nzc3/0NDR/8LCwsjU1NSr1tbWqtfX16zY2Nit2dnZrdnZ2a7a2tqv3Nzc + sMTExcji4uP/y8vM/83Nzv+CgoX/ZGRo8w8PDykAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6 + //n5+f/5+fn/+Pj4//f3+P/4+Pj/9vb2//T09f/w8PD/7Ozs/+jo6f/j4+T/39/g/9vb3P/X19j/1NTV + /9PT1P/S0tL/0dHS/9DQ0P/Oz8//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs7/zs7O/87Ozv/Ozs7/zs7O + /87Ozv/Ozs7/zs7O/87Ozv/Ozs7/zs7O/87Ozv/Ozs7/zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P + /87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//v8DA/3N0d/+LjI7/8PDx + /+rq6//Gxsf/n6Ch/8jJyf/IyMj/ycnJ/8nJyf/Jycn/ycrK/8rKy//Kysv/ysvL/8rLy//Ly8v/zMzM + /8vLzP/MzMz/zMzM/8zMzP/Nzc3/zc3N/83Nzv/Nzc7/zs7P/8/Pz//Pz8//zs7P/9DQ0P/S0tP/x8fH + ytjY2K/a2tqu29vbsNvb27Hc3Nyx3d3dst3d3bPf39+ywsPE0+np6f/Jycr/zs3O/3Z3ev9jZGfrDg4O + IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsL + He/v7+j+/v7//f39//z8/P/8/Pz/+/v7//z7+//8/Pv/9/f3//Dw8P/j4+P/2NjZ/87Pz//Gx8j/wcLD + /7/Awf++v8D/vr/A/76/wP+/wMH/v8DB/7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB + /7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB/7/Awf+/wMD/vr/A + /76/wP++v8D/vr/A/76/wP++v8D/vr/A/76/wP++v8D/v8DA/7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB + /7/Awf+/wMH/v8DB/7/Awf+3uLn/cXJ0/3t7fv/t7e3/7e3t/8/P0P+Xl5r/xsbG/8TExf/Fxsb/xcbG + /8bGx//Gxsf/x8jI/8jIyf/Iycn/ycnK/8rKyv/Ly8v/y8vM/83Nzf/Nzc3/zs/P/8/Q0P/P0ND/0NDR + /9DQ0P/Q0NH/0dHS/9HR0v/S0tL/0tLS/9XV1v/KysrN29vbs93d3bPe3t6z39/ftN/f37Xg4OC14eHh + tuXl5bS7u73h6+vr/8rKyv/Ly8v/amtu/1VWWtYfHyASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//f39//v7+//q6ur/09PU + /7/Awv+0tbf/r7Cz/6+ws/+wsbP/sLG0/7CxtP+wsbT/sLG0/7CxtP+wsbT/sLG0/7CxtP+wsbT/sLG0 + /6+ws/+vsLP/rq+y/66vsv+ur7L/r7Cy/7CxtP+wsbT/sbK1/7O0tv+1trj/t7i6/7i5u/+6u73/u72+ + /72+wP++v8H/wMHD/8HCxP/CwsT/wsPF/8PExf/DxMb/xMTG/8TFxv/Fxsf/xcbH/8TFxv/DxMb/w8PF + /8LDxP/BwsT/wMHD/8DAwv+/v8L/vr/B/7y9v/+7vL7/urq9/7i5u/+3uLr/tre5/6+ws/+BgYP/amtv + /+Dg4P/v7+//09PU/52dn//AwcL/wcLD/8LDxP/Dw8T/xMTF/8TExf/Fxcb/xcbH/8fHyP/Hx8j/x8jJ + /8jJyv/Jycr/ycrL/8rKy//Ly8z/y8zM/8zNzf/Nzs//z8/Q/9LS0v/U1NX/1NTV/9TU1f/V1dX/2NjY + /87Ozs/e3t624eHhtuHh4bbi4uK34uLiuOPj47jj4+O55+fntr29v/Pn5+j/ycnJ/8HBwv9eX2P/VFVX + uDo7PAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAsLCx3v7+/o/v7+//Ly8//Jycr/qqus/6GhpP+io6X/oqOl/6Kjpf+io6X/oqOl/6Kjpf+hoqT/oKGj + /6Cho/+goaP/oaKk/6enqv+sra//s7O1/7q7vP/BwsT/ycnL/8/P0P/U1NX/2NjZ/93d3f/g4OD/5+fo + /+vr7P/u7u7/7u7v/+/v7//u7u7/7u7v/+7u7v/u7u7/7u7v/+7u7v/t7e7/7e3t/+zs7P/s7Oz/6+vs + /+vr6//q6uv/6enq/+no6P/o6Oj/6Ojo/+jn5//n5+f/5ubn/+bm5v/l5eb/5eXl/+Xl5f/k5OX/4+Pk + /+Pj4//i4uP/4uLi/+Hh4f/g4OD/3Nzd/6qqq/9iY2f/yMjJ/+7u7v/b29z/srO1/7m5u//Ly8v/y8vL + /8rKy//Jycr/yMjJ/8fIyP/Gx8f/xsbH/8XGxv/Fxsf/x8fI/8jIyP/IyMn/yMnJ/8nKyv/Ky8v/y8vL + /8vMzP/LzMz/zc3O/87Oz//R0dH/1dXV/9jY2f/b29v/09PT0eHh4brk5OS65OTkuuXl5bvl5eW75ubm + vOfn57zf39+/z8/Q/tjY2f/Jycr/rKyu/1laX/87Oz2FNzc4BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgYGFubm5uPQ0NH/lJWY/5GTlv+SlJf/kpSX + /5KTlv+RkpX/j5CU/5WWmf+dn6H/ra6w/72+wP/Mzc7/2trb/+Xl5v/t7e3/8fDx//T09P/09PX/8/Pz + //Ly8v/x8fH/8PDw/+/v7//u7u7/7e3u/+3t7f/w8PD/8fHy//Hx8f/w8PH/8PDw/+/v7//v7+//7u7v + /+7u7v/t7e7/7Ozt/+zs7P/s7Oz/6+vs/+vr6//q6uv/6urq/+np6v/p6en/6enp/+jo6f/n5+j/5+fn + /+bm5//m5ub/5ubm/+Xl5v/l5eX/5OTl/+Tk5P/j4+T/4+Pj/+Li4//i4uL/4eHi/+Hh4f/g4OD/wMDB + /2Znav+goaP/7+/v/+Xl5f/Jysr/o6Ol/9XV1f/T09T/09PT/9TU1P/U1NT/1dXV/9XV1f/V1dX/1NTV + /9TU1P/T09P/0dHS/8/Pz//Nzc7/y8vM/8rKy//Jycr/ysrL/8rLzP/MzM3/zMzN/83Nzv/Nzc7/0dHS + /93d3f/W1tbT5eXlvebm5r3n5+e+6Ojovujo6L/p6em/6+vrv8jIydjp6en/ysrL/8rKy/+LjI7/Xl9k + /iAhIkhsbG4CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABQUFAJhYWGmIaHi/+EhYn/g4SH/4KEh/+RkZX/ra2w/8nKy//i4uP/8fHy//j4+P/5+fn/+Pj4 + //b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t + //Dw8f/x8fL/8fHx//Dw8f/w8PD/8PDw/+/v8P/u7u//7u7u/+3t7v/t7e3/7e3t/+zs7f/r6+z/6+vr + /+vr6//r6+v/6urr/+np6v/p6en/6Ojp/+jo6P/o6Oj/5+fo/+bm5//m5ub/5ubm/+bm5v/l5eb/5OTl + /+Pj5P/j4+P/4+Pj/+Pj4//i4uP/4eHi/+Hh4f/U1NP/d3d6/3h5e//n5+j/6+vr/9PT1P+hoaP/0tLS + /9bW1//W1tb/1tbX/9fX1//X19f/19fY/9fX2P/X19j/2NjZ/9nZ2f/Z2dn/2tra/9ra2v/a2tr/2tra + /9jZ2f/W1tb/0tLS/8/P0P/Mzc3/zMzN/83Nzv/Nzs//1NXV+eDg4Mjo6Oi/6enpwOrq6sDr6+vB6+vr + wuvr68Ls7Oy+v7/B8+np6f/Hx8j/x8fI/2lqbf9dXmHhBQUFHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKOjpAEODg4nc3V314mLjv+7vL7/5ubn + //r6+v/9/f3/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy + //Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8PDx//Hx8v/x8fH/8fHx//Hx8f/w8PD/7+/w + /+7u7//u7u7/7u7u/+3t7v/t7e3/7Ozt/+zs7P/s7Oz/6+vs/+vr6//q6uv/6urq/+rq6v/p6er/6Ojp + /+jo6P/n5+j/5+fn/+fn5//m5uf/5ubm/+Xl5v/l5eX/5OTl/+Tk5P/j4+T/4+Pj/+Li4//i4uL/4uLi + /9zc3P+cnJz/YmNn/8XFxv/q6ur/3d3e/8TExv+urrD/29vb/9nZ2f/Z2dn/2dnZ/9nZ2v/b29v/29vb + /9vb2//b29v/3Nzc/9zc3P/c3N3/3Nzc/93d3f/d3d7/3d3d/97e3v/e3t7/39/f/97e3v/Z2dr/0tPU + /9DQ0f7Z2trf6OjoxOvr68Lr6+vD7OzsxO3t7cXt7e3F7+/vxdPT1NHf3+D/0dLT/8jIyf+sra7/Wltf + /0RERpk1NTYKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAeXl6BBoaGjC5ubm7+/v7//39/f/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3 + //b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u + /+3t7f/w8PH/8vLy//Ly8v/x8fL/8fHx//Dw8P/w8PD/7+/w/+/v7//u7u//7e3u/+3t7f/t7e3/7Ozt + /+zs7P/r6+z/6+vr/+vr6//q6uv/6urq/+np6v/p6en/6enp/+jo6f/n5+j/5+fn/+fn5//n5+f/5ubn + /+Xl5v/k5OX/5OTk/+Tk5P/k5OT/4+Pk/+Li4//i4uL/4eHh/7q6uv9oaWz/iouO/+rq6v/o6Oj/1NTU + /6Wlp//U1NX/3Nzc/9zc3P/c3Nz/3d3d/93d3f/d3d3/3d3d/97e3v/e3t//3t7e/9/f3//f39//39/g + /+Dg4P/g4OD/4ODg/+Hh4f/h4eL/4eHi/+Hh4v/i4uL/4uLi+uHh4dzq6urI7u7uxu7u7sfv7+/I8PDw + yPDw8Mnv7+/Ev8DB9evr6//Hx8j/ycnK/3l6ff9fYGT6HBwdQGhoagIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSUlIOx8fHx/7+/v/9/f3//Pz8 + //z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz + //Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Hx8f/y8vP/8vLy//Hx8v/x8fH/8fHx + //Dw8f/v7/D/7+/v/+/v7//u7u//7u7u/+3t7v/t7e3/7e3t/+zs7f/s7Oz/6+vs/+vr6//r6+v/6urr + /+np6v/p6en/6Ojp/+jo6P/o6Oj/5+fo/+fn5//m5uf/5ubm/+Xl5v/l5eX/5OTl/+Tk5P/k5OT/4+Pk + /+Pj4//i4uP/zc3N/4yNj/9jZGj/yMjJ/+jo6P/e3t//zs7P/6Okpv/g4eH/39/f/9/f3//f39//4ODg + /+Dg4P/g4OD/4eHh/+Hh4f/h4eL/4uLi/+Hh4v/i4uL/4uLi/+Pj4//j4+P/4+Pj/+Pj5P/k5OT/5OTk + /+Xl5f/l5eX/5+fn/eXl5dbw8PDJ8PDwyfHx8cry8vLL8/PzycfIyN/p6en/zs7P/8jIyf+wsLL/W1xg + /1FSVLYbGxsPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAsLCxzw8PDo/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4 + //f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u + /+3t7v/t7e3/8fHx//Ly8//y8vL/8vLy//Ly8v/x8fH/8PDx//Dw8P/w8PD/7+/w/+7u7//u7u7/7u7u + /+3t7v/t7e3/7Ozt/+zs7P/s7Oz/6+vs/+vr6//q6uv/6urq/+rq6v/p6er/6Ojp/+jo6P/o6Oj/6Ojo + /+fn6P/m5uf/5ubm/+bm5v/l5eb/5eXl/+Tk5f/k5OT/5OTk/+Pj5P/U1NT/tra3/2hpbf+BgoX/5eXm + /+bm5//X19f/vr7A/7i4uv/j4+T/4eHh/+Li4v/i4uP/4uLj/+Li4v/j4+P/4+Pj/+Tk5P/k5OT/5OTk + /+Tk5P/l5eX/5eXl/+Xl5f/m5ub/5ubm/+bm5//m5ub/5+fn/+fn5//p6en/5eXl3vLy8s3z8/PN8/Pz + zfT09M3a2trS09PU/t/g4P/Hx8j/yMjI/3Jzd/9fYGT5ISEhR0xNTgMAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39 + //z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0 + //Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/x8fH/8/Pz//Pz8//y8vP/8vLy + //Hx8f/x8fH/8PDx//Dw8P/v7/D/7+/v/+/v7//u7u//7e3u/+3t7f/t7e3/7e3t/+zs7f/r6+z/6+vr + /+vr6//q6uv/6urq/+rq6v/p6er/6enp/+jo6f/o6Oj/6Ojo/+fn6P/m5uf/5ubm/+bm5v/m5ub/5eXm + /+Tk5f/k5OT/5OTk/9XV1f/Ly8z/l5iZ/2BhZf+rq63/5+fo/+Pj4//W1tf/s7O1/8XGx//m5ub/5OTk + /+Tk5f/k5OX/5eXl/+Xl5f/m5ub/5ubn/+bm5//m5ub/5+fn/+fn5//o6Oj/6Ojo/+jo6P/o6On/6enp + /+np6f/p6en/6enq/+vr6//o6Ojg9PT0z/T09ND19fXQ4+Tkz8fIyfrr6+v/x8fI/8nJyf+ZmZz/Wltf + /0hJS6AaGhoNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5 + //j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v + /+7u7v/t7e7/7e3t//Dw8f/z8/P/8/Pz//Ly8//y8vL/8fHx//Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v + /+7u7//u7u7/7u7u/+3t7v/t7e3/7Ozt/+zs7P/s7Oz/6+vs/+rq6//q6ur/6urq/+np6v/p6en/6enp + /+np6f/o6On/5+fo/+fn5//n5+f/5ubn/+bm5v/l5eb/5eXl/+Xl5f/k5OX/1dXV/9LS0//Hx8j/fH1/ + /2dobP/IyMr/5eXl/9/f4P/Y2Nj/srK0/8XGx//p6en/5+fo/+fn5//o6Oj/6Ojo/+np6f/o6On/6Ojp + /+np6f/p6en/6urq/+rq6v/q6ur/6urq/+vr6//r6+v/6+vr/+vr6//r6+v/7e3t/+rq6uL19fXT9/f3 + 0uPj49LFxcb57+/v/8nJyv/IyMj/s7S1/15fY/9eX2LiDQ0NKGRlZwIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+ + //39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0 + //Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8fHx//Pz9P/z8/P/8vLz + //Ly8v/y8vL/8fHy//Hx8f/x8fH/8PDx/+/v8P/v7+//7+/v/+7u7//u7u7/7e3u/+3t7f/t7e3/7Ozt + /+zs7P/s7Oz/6+vs/+vr6//q6uv/6urq/+rq6v/p6er/6enp/+jo6f/o6Oj/5+fo/+fn5//n5+f/5+fn + /+bm5//l5eb/5eXl/+Xl5f/W1tb/0tLT/9fX2P++vr7/aWpt/3R0d//U1NX/4+Pj/97e3f/Z2dn/uru8 + /7u7vP/p6er/6urq/+rq6v/r6+v/6+vr/+vr6//r6+z/6+vs/+zs7P/s7Oz/7Ozs/+zs7P/s7Oz/7Ozs + /+3t7f/t7e3/7e3t/+7u7v/v7/D/7Ozs5fj4+NPX19jZysrL/O3u7v/Jycv/yMjI/76/v/9oaW3/X19j + +CQkJVBNTk8GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5 + //n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w + /+/v7//u7u7/7e3u/+3t7f/x8fH/8/P0//Pz8//z8/P/8/Pz//Ly8v/y8vL/8fHy//Hx8f/w8PH/8PDw + //Dw8P/v7/D/7+/v/+/v7//u7u//7u7u/+3t7v/t7e3/7e3t/+zs7f/r6+z/6+vr/+vr6//q6uv/6urq + /+rq6v/q6ur/6enq/+jo6f/o6Oj/6Ojo/+fn6P/n5+f/5+fn/+bm5//m5ub/5ubm/9bW1v/S0tP/29vb + /9zc3P+xsbL/ZGVp/3p7fv/W1tb/4eHh/97e3v/Y2Nn/y8vM/66usP/b29v/7e3t/+zs7P/s7Oz/7Ozs + /+3t7f/t7e3/7u7u/+7u7v/u7u7/7u7u/+7u7v/u7u//7+/v/+/v7//v7+//7+/v//Ly8v/k5eXixMXF + 6dra2//o6Oj/yMjJ/8jIyf/BwsL/b3Bz/11eYv07PD17GRkaCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v + 6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1 + //T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Hx8f/09PT/9PT0 + //Pz9P/z8/P/8vLy//Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw/+/v8P/v7+//7+/v/+7u7//u7u7/7u7u + /+3t7v/t7e3/7Ozt/+zs7P/s7Oz/6+vs/+vr6//r6+v/6urr/+rq6v/q6ur/6enq/+jo6f/o6Oj/6Ojo + /+jo6P/n5+j/5+fn/+fn5//m5uf/1tbW/9LS0//b29z/4+Pk/9vb2/+enp//Y2Ro/3d4e//Pz9D/4ODg + /93d3v/X19j/29vc/7u7vf+4uLn/39/f/+/v7//w8PD/7+/v/+/v7//v7+//8PDw//Dw8P/w8PD/8PDw + //Dw8P/w8PD/8fHx//Hx8f/n5+f/ycrK/8bHyP3t7e3/2dna/8jIyP/Jycn/vb2+/25ucv9dXmL/Pj5A + jRoaGw8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6 + //n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw + /+/v8P/v7+//7u7u/+3t7v/t7e3/8fHy//T09f/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy + //Hx8f/x8fH/8PDx/+/v8P/v7+//7+/v/+/v7//u7u//7u7u/+7u7v/t7e7/7e3t/+3t7f/s7O3/6+vs + /+vr6//r6+v/6+vr/+rq6//q6ur/6enq/+np6f/p6en/6enp/+jo6f/n5+j/5+fn/+fn6P/W1tb/0tLT + /9vb3P/k5OX/5OTl/8rKy/+fn5//ZWZp/25vcv+6u7z/39/g/93d3f/Y2Nn/2tra/9vb3P/AwMH/tre4 + /8nJyv/g4OH/7e3t//Dw8f/y8vL/8/Lz//Ly8v/x8fH/7u7v/+Xl5v/T09P/wsPE/8rKy//o6Oj/4+Pk + /8vMzP/IyMn/ycnK/6+vsP9lZmr/XV5j/T4+QI0cHBwRZGRmAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsL + He/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1 + //T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/x8fL/9PT1 + //T09P/09PT/9PT0//Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy//Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v + /+/v7//u7u//7u7u/+7u7v/t7e7/7e3t/+zs7f/s7Oz/7Ozs/+vr7P/r6+v/6+vr/+rq6//q6ur/6urq + /+np6v/p6en/6enp/+jo6f/o6Oj/6Ojo/9bW1v/S0tP/3Nzd/+bm5v/m5ub/09PU/8jIyP+mpqf/bGxw + /2JjZ/+Xl5r/1tbW/9zc3f/a2tv/1tbX/9nZ2f/g4OH/2dra/8fHyP+/v8D/u7u8/8DBwv/BwsP/w8PE + /8DBwv/Dw8T/zc7O/+Li4v/q6ur/3d3e/8zMzf/Jycr/ysrL/8bGx/+QkJP/XF1h/15fY/M4OTlyGhoa + D2NkZgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7 + //r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx + //Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Hx8v/19fX/9fX1//T09f/09PT/8/Pz//Pz8//y8vP/8vLy + //Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw//Dw8P/w8PD/7+/w/+/v7//v7+//7u7v/+3t7v/t7e3/7e3t + /+zs7f/s7Oz/7Ozs/+zs7P/r6+z/6+vr/+rq6//q6ur/6urq/+rq6v/p6er/6enp/+np6f/o6On/1tbX + /9LS0//c3N3/5+fn/+fn5//U1NX/z8/P/8rKy/+zs7T/fn6B/19gZP9vcHP/q6ut/9bW1v/a2tr/2NjZ + /9XV1v/T09T/2NjZ/9vb3P/k5OT/4+Pj/+Pj4//k5OT/5ubm/9/f3//Y2Nn/zs7P/8rKy//Ly8z/zMzM + /8nIyf+jo6X/aWpt/1tcYP9aW17SHx8gRTQ0NQkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2 + //X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8fHy + //X19f/19fX/9PT1//T09P/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy//Hx8f/x8fH/8PDx + //Dw8P/w8PD/7+/w/+/v7//u7u//7u7u/+7u7v/t7e7/7e3t/+3t7f/s7O3/7Ozs/+zs7P/r6+z/6+vr + /+vr6//q6uv/6urq/+rq6v/p6er/6enp/+np6v/X19f/0tLT/93d3f/o6On/6Ojp/9TU1f/Q0ND/z8/Q + /8vLzP/AwMD/nJyd/21ucf9eX2P/cHB0/5+fof/Hx8j/19fX/9fX2P/V1dX/1NTU/9HR0v/Q0NH/0NDQ + /87Oz//Ozs//zs7P/87Ozv/Ozs7/zc3N/7+/wP+YmJr/bGxw/1pbX/9gYGTuPT0/hggICBxNTU4FAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7 + //v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx + //Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/y8vL/9fX2//X19f/19fX/9fX1//T09P/09PT/8/P0 + //Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy//Hx8f/x8fH/8fHx//Dw8f/w8PD/8PDw/+/v8P/u7u//7u7u + /+7u7v/t7e7/7e3t/+3t7f/t7e3/7Ozt/+zs7P/r6+z/6+vr/+vr6//r6+v/6urr/+rq6v/q6ur/6enq + /9fX2P/S0tP/3d3e/+np6f/p6en/1dXW/9DQ0P/Pz9D/zs7P/83Nzv/Hx8j/tra3/5WVl/9vb3L/YGFl + /2FiZv93eHr/lpaZ/6+wsf/BwcL/ycrL/8zMzf/Nzc7/y8vM/8fHyP+9vr7/q6yu/5KSlf9zdHf/Xl9j + /1xdYf9dXmLrQkJEkhEREiw3NzgJX2BiAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3 + //b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t + //Ly8v/19fb/9fX1//X19f/19fX/9PT0//T09P/z8/T/8/Pz//Pz8//y8vP/8vLy//Ly8v/x8fL/8fHx + //Hx8f/x8fH/8PDx//Dw8P/w8PD/7+/w/+/v7//v7+//7u7v/+7u7v/u7u7/7e3u/+3t7f/t7e3/7Ozt + /+zs7P/s7Oz/6+vs/+vr6//r6+v/6urr/+rq6v/q6uv/19fY/9LS0//d3d7/6urr/+rq6//W1tf/0NDQ + /8/P0P/Ozs//zs7O/83Nzf/Ly8z/xsbH/7q6u/+hoaL/gYKE/21ucf9gYWX/XV5i/11eYv9iY2f/Zmdr + /2hpbf9mZ2v/YWNm/1xdYf9aW1//YGFl/2doa/94eXv/l5eY/ycnKGwfHx8MdXZ3AQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8 + //v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy + //Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8vLy//b29v/29vb/9fX2//X19f/19fX/9PT1 + //T09P/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy//Hx8f/x8fH/8PDx//Dw8P/w8PD/8PDw + //Dw8P/v7/D/7+/v/+/v7//u7u//7u7u/+7u7v/t7e7/7e3t/+3t7f/s7O3/7Ozs/+zs7P/r6+z/6+vr + /+vr6//Y2Nj/0tLT/97e3//r6+z/6+vs/9bW1//Q0ND/z8/Q/87Oz//Ozs7/zc3N/8zMzf/Ly8z/ysrL + /8jIyP/CwsP/t7e4/6amp/+Wlpf/i4yN/3Z2eP91dXj/dXV4/3R1d/90dXf/goOF/5KSlP+dnZ7/q6us + /7e3uP/Dw8X/Ly8wWnx8fgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3 + //b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u + /+3t7f/y8vL/9vb3//b29v/29vb/9vb2//X19f/19fX/9PT1//T09P/09PT/8/P0//Pz8//z8/P/8vLz + //Ly8v/y8vL/8vLy//Hx8v/x8fH/8fHx//Dw8f/w8PD/8PDw/+/v8P/v7+//7+/v/+7u7//u7u7/7u7u + /+7u7v/t7e7/7e3t/+3t7f/t7e3/7Ozt/+zs7P/s7Oz/7Ozs/9jY2P/S0tP/3t7f/+zs7f/s7O3/19fY + /9DQ0P/Pz9D/zs7P/87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrL/8rKyv/Jycr/x8fI/8XFxv/CwsP/wMDB + /8DAwf+/v8D/vr6//76+v/++vr//v7/A/8DAwf/BwcL/wcHC/8fHyf8wMDBae3t9AwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8 + //z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz + //Ly8v/x8fH/8fHx//Dw8f/w8PD/7+/v/+/v7//u7u//7e3t//Ly8//39/f/9vb2//X19v/19fX/9fX1 + //X19f/09PT/9PT0//T09P/z8/P/8/Pz//Pz8//y8vL/8vLy//Ly8v/x8fH/8fHx//Hx8f/w8PD/8PDw + //Dw8P/w8PD/7+/w/+/v7//v7+//7u7v/+7u7v/u7u7/7e3u/+3t7f/t7e3/7e3t/+3t7f/t7e3/7Ozt + /+zs7P/s7Oz/2dnZ/9PT1P/f3+D/7u7u/+7u7v/Y2Nn/0NDQ/8/P0P/Ozs//zs7O/83Nzf/MzM3/y8vM + /8vLzP/Kysv/ysrK/8nJyv/IyMn/yMjJ/8fHyP/Gxsf/xsbH/8XFxv/ExMX/xMTF/8PDxP/Dw8T/wsLD + /8HBwv/BwcL/x8fJ/zAwMFqFhYYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4 + //f39//39/f/9/f3//X19v/09PT/8fHx/+7u7//q6ur/5ubn/+Pj4//e3t//3Nzd/9ra2//Y2Nn/19fX + /9TU1f/U1NT/1NTU/9TU1f/U1NT/09TU/9PU1P/T1NT/09PU/9PT1P/T09P/09PT/9LS0//S0tP/0tLT + /9LS0//S0tP/0tLT/9LS0//S0tP/0tLT/9LS0//S0tP/0tLT/9LS0v/S0tL/0tLS/9LS0v/S0tL/0tLS + /9LS0v/S0tL/0tLT/9LS0//S0tP/0tLT/9LS0//S0tP/0tLT/9LS0//R0dL/0dHS/9LS0//U1NT/1NTV + /9HR0v/Q0NH/0NDR/8/P0P/Ozs//zs7P/87Oz//MzM3/zMzN/8zMzP/Kysv/ycnK/8nJyf/IyMn/x8fI + /8bGx//Gxsf/xcXG/8TExf/ExMX/w8PE/8PDxP/CwsP/wcHC/8HBwv/Hx8n/MDAwWpOTlAMAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39 + //z8/P/8/Pz/+/v7//v7+//7+/v/+vr6//b29v/t7e7/4uLj/9ra2//P0NH/ysvM/8XGx//Cw8T/wcLD + /8DCwv/AwsL/wcLD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD + /8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD + /8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD + /8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD/8HDw//Bw8P/wcPD + /8HDw//Cw8T/wsPE/8LDxP/DxMX/w8PF/8XFxv/Fxcb/xsfI/8bGx//Gxsf/xcXG/8TExf/Dw8T/w8PE + /8LCw//BwcL/wcHC/8fHyf8wMDBamJiZAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//f39//39/f/09PX/4uLj/83Nz/+9vsD/tba5 + /7Gytf+ys7b/srO2/7O0t/+ztLf/s7S3/7O0t/+ztLf/s7S3/7O0t/+ztLf/s7S2/7O0tv+ztLb/s7S2 + /7O0tv+ys7X/srO1/7GytP+xsrT/sbK1/7Kztv+ztLb/tLW3/7W2uP+2trn/tre5/7e4uv+5urz/u7u9 + /7u8vv+8vb//vL2//72+wP+9vsD/vr7A/76/wf++v8H/v8DB/76/wf++vsD/vb7A/7y9v/+8vb//u7y+ + /7u7vf+6u73/ubu8/7m5u/+3uLr/tre5/7W2uP+0tbj/tLW3/7S1t/+ztLb/srO2/7Kztf+ys7X/srO1 + /7Kztf+ztLb/s7S2/7O0tv+ztLb/s7S2/7O0t/+ztLf/s7S3/7O0t/+ztLf/s7S3/7O0t/+ztLf/s7S3 + /7O0t/+ztLf/tLW3/7W2uP+5ubz/vr2//8HCw//Dw8T/wsLD/8HBwv/BwcL/x8fJ/zAwMFqSkpQDAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+ + //r6+v/Z2tr/t7i5/6amqf+kpKb/paao/6WmqP+lpqj/paao/6WmqP+lpqj/paao/6Slp/+io6X/o6Sm + /6WlqP+mp6n/rKyv/7GxtP+2trn/vb6//8PDxf/Iycr/zc3O/9HR0//W1tf/3t7f/+Pj5P/m5uf/6Ojo + /+np6f/p6ur/6urr/+vr6//s7Oz/7Ozt/+zs7P/s7Oz/6+vs/+rq6//q6ur/6urq/+rq6v/p6er/6Ojp + /+jo6P/n5+j/5+fn/+fn5//m5uf/5eXl/+Tk5f/k5OT/5OTk/+Pj5P/j4+P/4eHi/+Hh4f/h4eH/39/g + /97e3v/c3N3/29vc/9nZ2v/Pz9D/y8zN/8zLzf/Ly8z/x8fJ/7+/wf+8vL3/ubm7/7W1t/+xsrT/ra6w + /6qrrf+nqKr/paao/6Slp/+kpaf/pKWn/6WmqP+lpqj/paao/6WmqP+lpqj/paao/6WmqP+lpaj/paao + /6mqq/+ys7T/vr6//8HBwv/Hx8n/MDAwWouLjQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACAgIGOvr6+bg4eL/n5+i/5SVmP+Wl5n/lpea/5aXmv+Vlpn/k5SY + /5OUl/+XmJv/oaKk/6+wsv+8vb//y8vM/9jY2f/h4eL/6enp/+/v7//x8fH/8fHy//Pz8//y8vL/8fDx + //Dv7//u7u7/7u7u/+3t7f/w8PD/8fHx//Hx8f/w8PH/8PDw/+/v7//u7u//7u7u/+7u7v/t7e7/7Ozt + /+zs7P/s7Oz/6+vs/+vr6//q6uv/6urq/+np6v/p6en/6enp/+jo6f/n5+j/5+fn/+bm5//m5ub/5ubm + /+Xl5v/l5eX/5OTl/+Pj5P/j4+P/4+Pj/+Li4//i4uL/4eHi/+Dg4f/g4OD/39/g/9TU1f/S0tP/19fX + /9nZ2v/Y2Nn/0NDR/9DQ0P/Pz9D/z8/P/8/Pz//Nzc7/zMzN/8rKy//Hx8j/wsPD/76+v/+3t7j/rq+x + /6eoqv+foKL/mZqd/5WWmf+Ulpn/lZaZ/5aXmv+Wl5r/lpea/5aXmf+Wl5r/qKmr/8jIyf8wMDFah4iJ + AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPT1ALnZ2d + qoqMj/+HiIz/h4iL/4SFiP+Jio3/nZ6h/7a3uP/R0dL/5ubm//Hx8v/4+Pj/+fn5//f39//29vb/9PT1 + //T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Dw8P/x8fL/8fHx + //Dw8f/w8PD/8PDw/+/v8P/u7u//7u7u/+3t7v/t7e3/7e3t/+zs7f/r6+z/6+vr/+rq6//q6ur/6urq + /+np6v/p6en/6Ojp/+jo6P/o6Oj/5+fo/+bm5//m5ub/5eXm/+Xl5f/l5eX/5OTl/+Pj5P/j4+P/4+Pj + /+Pj4//i4uP/4eHi/+Hh4f/g4OD/1NTV/9LS0//X19j/2tra/9nZ2v/R0dH/0NDQ/8/P0P/Ozs//zs7O + /83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK/8nJyv/Jycn/ycnK/8jIyf/Fxcb/wMDB/7W1t/+nqKr/mZqd + /4yNkP+Gh4r/hoiL/4eIjP+Gh4r/oKGj8RsbGzCHh4gBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHh4eQIYGBgzfX6B6n+BhP+mp6n/1dbW//Hy8v/8/Pz//Pz8 + //n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw + /+/v8P/v7+//7u7u/+3t7v/t7e3/8PDx//Hx8v/x8fH/8fHx//Hx8f/w8PD/7+/w/+7u7//u7u7/7u7u + /+3t7v/t7e3/7Ozt/+zs7P/s7Oz/6+vs/+vr6//q6uv/6urq/+rq6v/p6er/6Ojp/+jo6P/n5+j/5+fn + /+fn5//m5uf/5ubm/+Xl5v/l5eX/5OTl/+Tk5P/j4+T/4+Pj/+Li4//i4uL/4uLi/+Hh4f/V1dX/0tLT + /9jY2P/b29z/29vb/9HR0f/Q0ND/z8/Q/87Oz//Ozs7/zc3N/8zMzf/Ly8z/y8vM/8rKy//Kysr/ycnK + /8jIyf/IyMn/x8fI/8bGx//Gxsf/xcXG/8XFxv/Fxcb/wsLD/7a3uP+foKL/hYaJ/3t9gP9PUFGQR0dI + CgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeHh5 + AgsLCyOenp6o8/Pz//39/f/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1 + //T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/w8PH/8vLy + //Ly8v/x8fL/8fHx//Dw8P/v7/D/7+/v/+/v7//u7u//7e3u/+3t7f/t7e3/7Ozt/+zs7P/r6+z/6+vr + /+vr6//q6uv/6urq/+np6v/p6en/6enp/+jo6f/n5+j/5+fn/+bm5//m5ub/5ubm/+Xl5v/k5OX/5OTk + /+Tk5P/k5OT/4+Pk/+Li4//i4uL/4uLi/9XV1f/S0tP/2NjZ/9zc3P/c3Nz/0NDS/9DQ0P/Pz9D/zs7P + /87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrL/8rKyv/Jycr/yMjJ/8jIyf/Hx8j/xsbH/8bGx//Fxcb/xMTF + /8TExf/Dw8T/w8PE/8PDw//BwcL/sbGz5yoqKkxHR0cJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUFAMsrKytP7+/v/9/f3//Pz8//z8/P/7+/v/+/v7 + //r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx + //Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Hx8f/y8vP/8vLy//Hx8v/x8fH/8fHx//Dw8f/v7/D/7+/v + /+7u7//u7u7/7u7u/+3t7v/s7O3/7Ozs/+zs7P/s7Oz/6+vs/+rq6//q6ur/6urq/+np6v/p6en/6Ojp + /+jo6P/o6Oj/5+fo/+fn5//m5uf/5ubm/+Xl5v/l5eX/5OTl/+Tk5P/k5OT/4+Pk/+Pj4//i4uP/1dXV + /9LS0//Y2Nn/3d3d/93d3f/Q0NL/0NDQ/8/P0P/Ozs//zs7O/83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK + /8nJyv/IyMn/yMjJ/8fHyP/Gxsf/xsbH/8XFxv/ExMX/xMTF/8PDxP/Dw8T/wsLD/8HBwv/BwcL/wsLD + 8R4eHjaHh4gBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAoKChvv7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2 + //X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8fHx + //Ly8//y8vL/8fHy//Hx8f/x8fH/8PDx/+/v8P/v7+//7+/v/+7u7//u7u7/7e3u/+3t7f/t7e3/7Ozt + /+zs7P/r6+z/6+vr/+vr6//q6uv/6enq/+np6f/p6en/6Ojp/+jo6P/n5+j/5+fn/+fn5//m5uf/5ubm + /+Xl5v/l5eX/5eXl/+Tk5f/k5OT/4+Pk/+Pj4//V1dX/0tLT/9nZ2v/e3t7/3d3e/9HR0v/Q0ND/z8/Q + /87Oz//Ozs7/zc3N/8zMzf/Ly8z/y8vM/8rKy//Kysr/ycnK/8jIyf/IyMn/x8fI/8bGx//Gxsf/xcXG + /8TExf/ExMX/w8PE/8PDxP/CwsP/wcHC/8HBwv/Hx8n/MDAwWoqKiwIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7 + //v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx + //Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/x8fH/8/Pz//Pz8//y8vP/8vLy//Hx8f/x8fH/8PDx + //Dw8P/v7/D/7+/v/+/v7//u7u//7e3u/+3t7f/t7e3/7e3t/+zs7f/r6+z/6+vr/+vr6//q6uv/6urq + /+np6v/p6en/6enp/+jo6f/o6Oj/5+fo/+fn5//m5uf/5ubm/+bm5v/m5ub/5eXm/+Tk5f/k5OT/5OTk + /9XV1f/S0tP/2dna/9/f4P/f39//0dHS/9DQ0P/Pz9D/zs7P/87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrL + /8rKyv/Jycr/yMjJ/8jIyf/Hx8j/xsbH/8bGx//Fxcb/xMTF/8TExf/Dw8T/w8PE/8LCw//BwcL/wcHC + /8fHyf8wMDBakJCRAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3 + //b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t + //Dw8f/z8/P/8/Pz//Ly8//y8vL/8fHx//Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v/+7u7//u7u7/7u7u + /+3t7v/t7e3/7Ozt/+zs7P/s7Oz/6+vs/+rq6//q6ur/6urq/+np6v/p6en/6enp/+np6f/o6On/5+fo + /+fn5//n5+f/5ubn/+bm5v/l5eb/5eXl/+Xl5f/k5OX/1dXV/9LS0//Z2dr/4ODh/+Dg4P/R0dL/0NDQ + /8/P0P/Ozs//zs7O/83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK/8nJyv/IyMn/yMjJ/8fHyP/Gxsf/xsbH + /8XFxv/ExMX/xMTF/8PDxP/Dw8T/wsLD/8HBwv/BwcL/x8fJ/zAwMFqXl5gDAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8 + //v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy + //Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8fHx//Pz9P/z8/P/8vLz//Ly8v/y8vL/8fHy + //Dw8f/w8PD/8PDw/+/v8P/v7+//7+/v/+7u7//u7u7/7e3u/+3t7f/t7e3/7Ozt/+zs7P/r6+z/6+vr + /+vr6//q6uv/6urq/+rq6v/p6er/6enp/+jo6f/o6Oj/5+fo/+fn5//m5uf/5ubm/+bm5v/l5eb/5eXl + /+Xl5f/W1tb/0tLT/9ra2//h4eL/4eHi/9LS0v/Q0ND/z8/Q/87Oz//Ozs7/zc3N/8zMzf/Ly8z/y8vM + /8rKy//Kysr/ycnK/8jIyf/IyMn/x8fI/8bGx//Gxsf/xcXG/8TExf/ExMX/w8PE/8PDxP/CwsP/wcHC + /8HBwv/Hx8n/MDAwWpubnAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3 + //b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u + /+3t7f/x8fH/8/P0//Pz8//z8/P/8/Pz//Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw//Dw8P/v7/D/7u7v + /+7u7v/u7u7/7u7u/+3t7v/t7e3/7e3t/+zs7f/r6+z/6+vr/+vr6//q6uv/6urq/+rq6v/q6ur/6enq + /+jo6f/o6Oj/6Ojo/+fn6P/n5+f/5ubn/+bm5v/m5ub/5ubm/9bW1v/S0tP/2trb/+Li4//j4+P/0tLT + /9DQ0P/Pz9D/zs7P/87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrL/8rKyv/Jycr/yMjJ/8jIyf/Hx8j/xsbH + /8bGx//Fxcb/xMTF/8TExf/Dw8T/w8PE/8LCw//BwcL/wcHC/8fHyf8wMDBam5ucAwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8 + //z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz + //Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Hx8f/09PT/9PT0//Pz9P/z8/P/8vLy + //Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw/+/v8P/v7+//7+/v/+7u7//u7u7/7u7u/+3t7v/t7e3/7Ozt + /+zs7P/s7Oz/6+vs/+vr6//r6+v/6urr/+rq6v/q6ur/6enq/+jo6f/o6Oj/6Ojo/+jo6P/n5+j/5+fn + /+fn5//m5uf/1tbW/9LS0//b29z/4+Pk/+Pj5P/S0tP/0NDQ/8/P0P/Ozs//zs7O/83Nzf/MzM3/y8vM + /8vLzP/Kysv/ysrK/8nJyv/IyMn/yMjJ/8fHyP/Gxsf/xsbH/8XFxv/ExMX/xMTF/8PDxP/Dw8T/wsLD + /8HBwv/BwcL/x8fJ/zAwMFqbm5wDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4 + //f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u + /+3t7v/t7e3/8fHy//T09f/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy//Dw8f/w8PD/8PDw + /+/v8P/v7+//7+/v/+/v7//u7u//7u7u/+7u7v/t7e7/7Ozt/+zs7P/s7Oz/6+vs/+vr6//r6+v/6+vr + /+rq6//q6ur/6enq/+np6f/o6On/6Ojo/+jo6P/n5+j/5+fn/+fn6P/W1tb/0tLT/9vb3P/k5OX/5eXl + /9PT1P/Q0ND/z8/Q/87Oz//Ozs7/zc3N/8zMzf/Ly8z/y8vM/8rKy//Kysr/ycnK/8jIyf/IyMn/x8fI + /8bGx//Gxsf/xcXG/8TExf/ExMX/w8PE/8PDxP/CwsP/wcHC/8HBwv/Hx8n/MDAwWpubnAMAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39 + //z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0 + //Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/x8fL/9PT1//T09P/09PT/9PT0 + //Pz8//z8/P/8vLz//Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v/+/v7//u7u//7u7u + /+3t7v/t7e3/7e3t/+zs7f/s7Oz/7Ozs/+vr7P/r6+v/6+vr/+rq6//q6ur/6urq/+np6v/p6en/6Ojp + /+jo6P/o6Oj/6Ojo/9bW1v/S0tP/3Nzc/+bm5v/m5ub/09PU/9DQ0P/Pz9D/zs7P/87Ozv/Nzc3/zMzN + /8vLzP/Ly8z/ysrL/8rKyv/Jycr/yMjJ/8jIyf/Hx8j/xsbH/8bGx//Fxcb/xMTF/8TExf/Dw8T/w8PE + /8LCw//BwcL/wcHC/8fHyf8wMDBam5ucAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5 + //j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v + /+7u7v/t7e7/7e3t//Hx8v/19fX/9fX1//T09f/09PT/8/Pz//Pz8//y8vP/8vLy//Ly8v/x8fL/8fHx + //Hx8f/w8PH/8PDw//Dw8P/w8PD/7+/w/+/v7//v7+//7u7v/+3t7v/t7e3/7e3t/+zs7f/s7Oz/7Ozs + /+zs7P/r6+z/6+vr/+rq6//q6ur/6urq/+rq6v/p6er/6enp/+np6f/o6On/1tbX/9LS0//c3N3/5+fn + /+fn5//U1NX/0NDQ/8/P0P/Ozs//zs7O/83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK/8nJyv/IyMn/yMjJ + /8fHyP/Gxsf/xsbH/8XFxv/ExMX/xMTF/8PDxP/Dw8T/wsLD/8HBwv/BwcL/x8fJ/zAwMFqbm5wDAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+ + //39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0 + //Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7v/t7e3/8fHy//X19f/19fX/9PT1 + //T09P/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy//Hx8f/x8fH/8PDx//Dw8P/v7/D/7+/v + /+/v7//u7u//7u7u/+7u7v/t7e7/7e3t/+3t7f/s7O3/7Ozs/+zs7P/r6+z/6+vr/+vr6//q6uv/6urq + /+rq6v/p6er/6enp/+np6f/X19f/0tLT/9zc3f/o6Oj/6Ojo/9TU1f/Q0ND/z8/Q/87Oz//Ozs7/zc3N + /8zMzf/Ly8z/y8vM/8rKy//Kysr/ycnK/8jIyf/IyMn/x8fI/8bGx//Gxsf/xcXG/8TExf/ExMX/w8PE + /8PDxP/CwsP/wcHC/8HBwv/Hx8n/MDAwWpubnAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5 + //n5+f/4+Pj/9/f3//b29//29vb/9fX1//T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w + /+/v7//u7u7/7e3u/+3t7f/y8vL/9fX2//X19f/19fX/9fX1//T09P/09PT/8/P0//Pz8//z8/P/8vLz + //Ly8v/x8fL/8fHx//Hx8f/w8PH/8PDw//Dw8P/v7/D/7+/v/+/v7//u7u//7u7u/+7u7v/t7e7/7e3t + /+3t7f/t7e3/7Ozt/+zs7P/r6+z/6+vr/+vr6//r6+v/6urr/+rq6v/q6ur/6enq/9fX2P/S0tP/3d3d + /+np6f/p6en/1dXW/9DQ0P/Pz9D/zs7P/87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrL/8rKyv/Jycr/yMjJ + /8jIyf/Hx8j/xsbH/8bGx//Fxcb/xMTF/8TExf/Dw8T/w8PE/8LCw//BwcL/wcHC/8fHyf8wMDBam5uc + AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v + 6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7//r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1 + //T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e7/7e3t//Ly8v/19fb/9fX1 + //X19f/19fX/9PT0//T09P/z8/T/8/Pz//Pz8//y8vP/8vLy//Ly8v/x8fL/8fHx//Hx8f/x8fH/8PDx + //Dw8P/w8PD/7+/w/+/v7//v7+//7u7v/+7u7v/u7u7/7e3u/+3t7f/t7e3/7Ozt/+zs7P/s7Oz/6+vs + /+vr6//r6+v/6urr/+rq6v/q6uv/19fY/9LS0//d3d7/6urq/+rq6v/V1df/0NDQ/8/P0P/Ozs//zs7O + /83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK/8nJyv/IyMn/yMjJ/8fHyP/Gxsf/xsbH/8XFxv/ExMX/xMTF + /8PDxP/Dw8T/wsLD/8HBwv/BwcL/x8fJ/zAwMFqbm5wDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6 + //n5+f/5+fn/+Pj4//f39//29vf/9vb2//X19f/09PX/9PT0//Pz9P/z8/P/8vLy//Hx8f/x8fH/8PDw + /+/v8P/v7+//7u7u/+3t7v/t7e3/8vLy//b29v/29vb/9fX2//X19f/19fX/9PT1//T09P/09PT/8/P0 + //Pz8//z8/P/8vLz//Ly8v/y8vL/8fHy//Hx8f/x8fH/8PDx//Dw8P/w8PD/7+/w/+/v7//v7+//7u7v + /+7u7v/u7u7/7u7u/+3t7v/t7e3/7Ozt/+zs7P/s7Oz/7Ozs/+vr7P/r6+v/6+vr/+vr6//Y2Nj/0tLT + /97e3v/r6+v/6+vr/9bW1//Q0ND/z8/Q/87Oz//Ozs7/zc3N/8zMzf/Ly8z/y8vM/8rKy//Kysr/ycnK + /8jIyf/IyMn/x8fI/8bGx//Gxsf/xcXG/8TExf/ExMX/w8PE/8PDxP/CwsP/wcHC/8HBwv/Hx8n/MDAw + WpubnAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsL + He/v7+j+/v7//f39//z8/P/8/Pz/+/v7//v7+//6+vr/+fn5//n5+f/4+Pj/9/f3//b29//29vb/9fX1 + //T09f/09PT/8/P0//Pz8//y8vL/8fHx//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+3t7f/y8vL/9vb3 + //b29v/29vb/9vb2//X19f/19fX/9PT1//T09P/09PT/8/P0//Pz8//z8/P/8vLz//Ly8v/y8vL/8vLy + //Hx8v/x8fH/8fHx//Dw8f/w8PD/8PDw/+/v8P/v7+//7+/v/+7u7//u7u7/7u7u/+7u7v/t7e7/7e3t + /+3t7f/t7e3/7Ozt/+zs7P/s7Oz/7Ozs/9jY2P/S0tP/3t7f/+zs7f/s7O3/19fY/9DQ0P/Pz9D/zs7P + /87Ozv/Nzc3/zMzN/8vLzP/Ly8z/ysrL/8rKyv/Jycr/yMjJ/8jIyf/Hx8j/xsbH/8bGx//Fxcb/xMTF + /8TExf/Dw8T/w8PE/8LCw//BwcL/wcHC/8fHyf8wMDBam5ucAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//z8/P/7+/v/+/v7 + //r6+v/5+fn/+fn5//j4+P/39/f/9vb3//b29v/19fX/9PT1//T09P/z8/T/8/Pz//Ly8v/x8fH/8fHx + //Dw8P/w8PD/7+/v/+/v7//u7u//7u7u//Pz8//4+Pj/9/f3//f39//39/f/9vb2//b29v/19fb/9fX1 + //X19f/19fX/9fX1//T09f/09PT/9PT0//Pz9P/z8/P/8/Pz//Ly8//y8vL/8vLy//Hx8v/x8fH/8fHx + //Dw8f/w8PD/8PDw//Dw8P/v7/D/7+/v/+/v7//v7+//7u7v/+7u7v/u7u7/7e3u/+3t7f/t7e3/2dnZ + /9PT1P/f3+D/7u7v/+7u7//Y2Nn/0NDQ/8/P0P/Ozs//zs7O/83Nzf/MzM3/y8vM/8vLzP/Kysv/ysrK + /8nJyv/IyMn/yMjJ/8fHyP/Gxsf/xsbH/8XFxv/ExMX/xMTF/8PDxP/Dw8T/wsLD/8HBwv/BwcL/x8fJ + /zAwMFqbm5wDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAsLCx3v7+/o/v7+//39/f/8/Pz//Pz8//v7+//7+/v/+vr6//n5+f/5+fn/+Pj4//f39//29vf/9vb2 + //b29v/29vb/9PT0//Hx8v/v7+//6urr/+Tk5f/f4OD/3Nzd/9jZ2f/U1dX/0NDQ/83Oz//LzMz/y8zM + /8vMzf/Ky8v/ycnK/8jIyf/Gx8j/xcbH/8TExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/wsPF + /8LDxf/Cw8X/wsPF/8LDxf/Cw8X/w8PE/8PDxP/Cw8T/wsPE/8LCxP/CwsT/wsPE/8LDxP/Dw8T/w8PE + /8PDxP/Dw8T/w8PE/8PDxf/ExMb/xcXH/8bGyP/ExcX/xMTF/8fHyP/Ly8z/zc3O/8fIyP/Gxsf/ycnJ + /8nKyv/Kysv/ycnK/8vLzP/Ly8z/ysrL/8vLy//Ly8v/ycnK/8jIyf/IyMn/x8fI/8bGx//Gxsf/xcXG + /8TExf/ExMX/w8PE/8PDxP/CwsP/wcHC/8HBwv/Hx8n/MDAwWpubnAMAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwsLHe/v7+j+/v7//f39//z8/P/8/Pz/+/v7 + //v7+//6+vr/+vr6//n5+f/09PT/7Ozs/+Pk5P/Z2dr/0tLU/8rKy//Gxsj/wsPE/8DAwv+/wMH/v8DB + /7+/wf+/wMH/v8DB/8DAwv/AwcL/wMHC/8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC + /8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC + /8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC + /8DBwv/AwcL/wMHC/8DBwv/AwcL/wMHC/8DBwv/AwML/wMDC/8DAwv/AwML/wMHC/8DBwv/AwcP/wsPE + /8PDxP/ExMb/xsbH/8bGx//Hx8j/x8fI/8bGx//Fxcb/xMTF/8TExf/Dw8T/w8PE/8LCw//BwcL/wcHC + /8fHyf8wMDBanJydAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALCwsd7+/v6P7+/v/9/f3//Pz8//39/f/6+vr/8fHx/+Li4//U1NX/ysvM/8TFxv/CwsT/wsLE + /8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF + /8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF + /8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF + /8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF + /8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/DxMX/w8TF/8PExf/ExMX/xMTG + /8bGx//Gx8j/xsbH/8TExf/Dw8T/wsLD/8HBwv/BwcL/x8fJ/zAwMFqcnJ0DAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLCx3v7+/o/v7+//39/f/w8PD/29vb + /8vLzP/Fxcb/xsbH/8bHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI + /8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI + /8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI + /8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI + /8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI + /8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fHyP/Hx8j/x8fI/8fIyP/Gxsf/wsLD + /8DAwf/Hx8n/MDAwWpqamwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACgoKGu7u7uf19fb/1NTV/8nJyv/Jycv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL + /8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL + /8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL + /8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL + /8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL + /8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/ysrL + /8rKy//Kysv/ysrL/8rKy//Kysv/ysrL/8rKy//Kysv/yMjJ/8jIyf8wMDBalJSVAgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUFAMtra2vNDR0v/Ozs7/zs7P + /87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P + /87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P + /87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P + /87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P + /87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P + /87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P + /87Oz//Ozs//zMzN+CIiIjqNjY4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAHV1dQMoKCg90dHS8tHR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR + /9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR + /9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR + /9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR + /9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR + /9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR + /9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9HR0f/R0dH/0dHR/9TU1P+FhYagJCQkDAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1NTQk5OTlQvLy9 + 19jY2f/T1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU + /9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU + /9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU + /9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU + /9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU + /9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/1NTU/9TU1P/U1NT/09TU + /9bW1v/V1db2goODmwcHBxuRkZIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHJycgUGBgYaS0tLY5+foLfS0tPw3d3e/9na2v/X2Nj/19jY + /9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY + /9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY + /9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY + /9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY + /9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY/9fY2P/X2Nj/19jY + /9fY2P/X2Nj/19jY/9fY2P/Y2Nn/29vc/9zc3fu/v8DYdXV1kCIiIjclJSYMlJSVAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABxcXEETk5PDQ8PDyVBQUFXdnZ3kqysrcTR0dLn3d3d/eHh4v/c3N3/29vc/9vb2//b29v/29vb + /9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb + /9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb + /9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb + /9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb + /9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b3Nz/39/f/+Dh4f/X19j1wMDB1ZeXl61bW1t1JSUl + OykpKRVOTk4Il5eXAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHh4eANSUlIIU1NT + DgUFBR4nJyc5QUFBXG9vb4KIiIintLS0wsHBwtrZ2dnr4ODg+OLi4v/j4+P/4+Pj/+Li4v/f39//3t7f + /97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e + /97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e + /97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e + /97e3v/e3t7/3t7e/97e3v/e3t7/39/f/+Dg4f/j4+P/4+Pj/+Li4//h4eH83d3d8c3NzeS6urvOoaGi + tHl5eZZXV1duODg4SxAQECksLCwVU1NTC1JSUgWioqIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKOjpAF8fHwDUlJTBVNTUwlUVFQNAAAA + Ew8PDyEUFBQtICAgO0VFRVFQUFBmXl5ee4CAgI6MjIyck5OTqZeXl7Ojo6O7vLy8x8bGxtDKysrUzMzM + 2M3NzdvPz8/f0NDQ4tHR0eXS0tLo0tLS6dLS0unS0tLp0tLS6dLS0unS0tLp0tLS6dLS0unS0tLp0tLS + 6dLS0unS0tLp0tLS6dLS0unS0tLp0tLS6dLS0unS0tLp0tLS6dLS0unS0tLp0tLS6dLS0unS0tLp0tLS + 6dLS0unR0dHn0NDQ5M/Pz+DOzs7dzc3N2svLy9bIyMjTw8PDzLOzs8KZmZm4lZWVr5CQkKKGhoaUcXFx + hlNTU3FMTExbNDQ0RRYWFjMSEhInBgYGGSoqKhBUVFQLU1NTB1JSUwSnp6cCAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACmpqYBpqenAlNTUwRUVFQFVFRV + B1VVVQhWVlYJV1dXCldXWAtXV1cQV1dXEgAAABQAAAAVAAAAFwAAABcAAAAZAAAAGgAAABsAAAAbAAAA + GwAAABsAAAAbAAAAGwAAABsAAAAbAAAAGwAAABsAAAAbAAAAGwAAABsAAAAbAAAAGwAAABsAAAAbAAAA + GwAAABsAAAAbAAAAGwAAABsAAAAbAAAAGwAAABsAAAAbAAAAGwAAABsAAAAaAAAAGAAAABcAAAAWAAAA + FQAAABRWVlYRVlZXDldXVwpXV1cJVlZWCFVVVQdUVFQGVFRUBX5+fgOmpqcBAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAA/////////Af///////////////////gD///////////////////w + A///////////////////4AH//////////////////+AA///////////////////AAH////////////// + ////wAA//////////////////8AAH//////////////////AAA//////////////////4AAH//////// + /////////8AAAAP/////////////wAAAAAAAAAP/////////wAAAAAAAAAAAA///////+AAAAAAAAAAA + AAAf/////4AAAAAAAAAAAAAAA/////4AAAAAAAAAAAAAAAD////8AAAAAAAAAAAAAAAAf////AAAAAAA + AAAAAAAAAD////wAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////wA + AAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////wAAAAAAAAAAAAAAAA/ + ///8AAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////wAAAAAAAAAAAAAAAA////8AAAAAAAAAAAA + AAAAP////AAAAAAAAAAAAAAAAD////wAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////AAAAAAA + AAAAAAAAAD////wAAAAAAAAAAAAAAAAP///8AAAAAAAAAAAAAAAAA////AAAAAAAAAAAAAAAAAH///wA + AAAAAAAAAAAAAAAA///8AAAAAAAAAAAAAAAAAH///AAAAAAAAAAAAAAAAAA///wAAAAAAAAAAAAAAAAA + H//8AAAAAAAAAAAAAAAAAA///AAAAAAAAAAAAAAAAAAP//wAAAAAAAAAAAAAAAAAB//8AAAAAAAAAAAA + AAAAAAP//AAAAAAAAAAAAAAAAAAD//wAAAAAAAAAAAAAAAAAAf/8AAAAAAAAAAAAAAAAAAH//AAAAAAA + AAAAAAAAAAAB//wAAAAAAAAAAAAAAAAAAP/8AAAAAAAAAAAAAAAAAAD//AAAAAAAAAAAAAAAAAAA//wA + AAAAAAAAAAAAAAAAAP/8AAAAAAAAAAAAAAAAAAD//AAAAAAAAAAAAAAAAAAA//wAAAAAAAAAAAAAAAAA + AP/8AAAAAAAAAAAAAAAAAAD//AAAAAAAAAAAAAAAAAAA//wAAAAAAAAAAAAAAAAAAP/8AAAAAAAAAAAA + AAAAAAD//AAAAAAAAAAAAAAAAAAA//wAAAAAAAAAAAAAAAAAAP/8AAAAAAAAAAAAAAAAAAD//AAAAAAA + AAAAAAAAAAAB//wAAAAAAAAAAAAAAAAAAf/8AAAAAAAAAAAAAAAAAAH//AAAAAAAAAAAAAAAAAAD//wA + AAAAAAAAAAAAAAAAA//8AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAA + D//8AAAAAAAAAAAAAAAAAB///AAAAAAAAAAAAAAAAAA///wAAAAAAAAAAAAAAAAAP//8AAAAAAAAAAAA + AAAAAH///AAAAAAAAAAAAAAAAAH///wAAAAAAAAAAAAAAAAD///8AAAAAAAAAAAAAAAAB////AAAAAAA + AAAAAAAAAB////wAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////wA + AAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////wAAAAAAAAAAAAAAAA/ + ///8AAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////wAAAAAAAAAAAAAAAB////8AAAAAAAAAAAA + AAAAf////AAAAAAAAAAAAAAAAD////wAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////AAAAAAA + AAAAAAAAAD////wAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////wA + AAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////wAAAAAAAAAAAAAAAA/ + ///8AAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////wAAAAAAAAAAAAAAAA////8AAAAAAAAAAAA + AAAAP////AAAAAAAAAAAAAAAAD////wAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////AAAAAAA + AAAAAAAAAD////wAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////wA + AAAAAAAAAAAAAAB////+AAAAAAAAAAAAAAAAf////wAAAAAAAAAAAAAAAP/////AAAAAAAAAAAAAAAP/ + ////+AAAAAAAAAAAAAAf//////+AAAAAAAAAAAAD/////////4AAAAAAAAAD//////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////8oAAAAYAAAAMAAAAABACAAAAAAAICUAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEZHSAEvLzAXLS0u + aTExM38eHh8vTU1PAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAATE1OAh8fIDZQUVTHZ2hr/XBxdP5XWFveIyMkNU5OUAIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUFIBHh4fNVdYW9x7e37+kJCR/rKys/59foD+VldZ + 2SMjIzJOTlACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKCkaVVZZ + 04yMkP/o6On/sbGx/oeHh/+srK3/e3x//ldYW9ohIiI1TU1PAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAEBAQgM2NjiAc3N3/ufn6P/i4uP/3Nzd/q+vr/+Hh4f/qqqr/np7fv5XWFvYIiIj + LktLTQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADw8PgU+PkGklJSX/unp6v7d3d7+39/f + /tzc3f6vr6/+hoaG/qqqqv53eHv+VVZZ0iEhIixKS0wBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AExNTgEpKSpOXV1h9aurrf/d3d3/3d3e/t/f3//e3t7/r6+v/oeHh/+rq6v/dnd6/lZXWtQfHyAuUFBS + AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtbm4GMjIzaV5fYvOrrK7/3d3e/t3d3v/f39//3Nzd + /q+vr/+Hh4f/qKip/nZ3ev5UVVjRISEiKVpaXAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACrq6sBaWlpA2trbARsbGwFbGxsB21tbQo7OzsNLS0tETg4OBk6OjofOTk5JDo6Oig8PDwtNjY2 + PFBQUZteX2P7sLCy/t3d3f7d3d7+39/f/tzc3f6vr6/+hYWG/qioqP5zdHj+UVJV0DAwMF5QUFFHWlpb + Q1dXVzxJSkozPz8/LD09PSg7OzsjODg4HTAwMBYnJycPY2NkDGJiYgphYWEHYGBgBV1dXQRxcXEDkpKT + AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACrq6sBgoKC + A4WFhQZVVVUMTk5OF2BgYSlBQUE+QUFBVWFhYWxycnJ/hISEk5ycnKijo6O3tLS0xcvLy9HX19jf4eHh + 6uzs7PLv7/D28PDw+vHx8v7x8fL/8fHx/ujo6f+trq//YmNn/q2ur//d3d7/3d3e/t/f3//e3t7/rq6v + /oeHh/+pqan/cnN2/nd4e//Kysv/5eXl/uXl5v/l5eX+5eXl/+Tk5P3i4uL53Nzd9c3Nzu/CwsPmwsLC + 27S0tc6Xl5fBjo6Os4WFhaJqamuMYGBheUhISGQ1NTVNRkZGNk5OTiI7OzsSWlpbCWxsbAR2dncCAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AJeXlwF8fHwFY2NjEz8/Py9eXl5VdHR0gqCgoKnExMTH2dnZ4ejo6O/v7+/18vLz+/Pz9P7y8vP+8vLy + //Dw8P/v7+/+7u7u/+3t7f/v7+//8fHx/vDw8f/w8PD/7+/v/u7u7//u7u7/7e3t/uzs7P/l5eX/qKip + /mVmav+ur7H/3dzd/t3d3v/f39//3Nzd/q+vr/+Ghof/pqan/nN0d/93eHr/ysrL/uHh4v/i4uP+4uLi + /+Hh4v/g4OH+3d3d/9PT1P/V1db+2dna/9XV1f/Pz9D+zs7P/87Oz//Ozs7+zc3O/8vLzP7Kysr5xMTF + 876+vuusrK3Zl5eXvHl5eZtaWlpxPz8/RD4+PyFJSUoMdnZ3AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACkpKQBREREDlFRUUiPj4+Yz8/P0vDw8PL6+vr++vr6//f3+P/29vb+9fX2 + //T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/v7/D/8fHx/vDw8f/w8PD/7+/v + /u/v7//u7u7/7u7u/u3t7f/s7Oz/4+Pk/qenqP9iY2f/tLS2/t3d3v/d3d7/39/f/tzc3f+urq//hoaG + /qWlpv9wcHT/e3t+/svLy//i4uL+4uLj/+Li4v/h4eL+3t7e/9PT1P/W1tf+29vb/9bW1v/Pz9D+zs7P + /87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Hx8j+xcXG+7a2t+eSkpO9WVlZ + dzs7OydoaGkFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJGRkQE3Nzc0xMTExvz8/P38/Pz++vr6 + /vr6+v75+fn++Pj4/vf39/729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t + /u3t7f7v7+/+8fHy/vHx8f7w8PH+8PDw/u/v7/7u7u/+7u7u/u3t7f7t7e3+7Ozs/uTk5P6qqqv+YWJm + /rCxs/7d3N3+3d3e/t7e3/7e3t7+rq6v/oaGh/6mpqf+bm9y/np6ff7Kysv+4uLj/uPj4/7i4uL+39/f + /tPT0/7W1tf+3Nzc/tbW1/7Pz9D+zs7P/s3Nzv7Nzc3+y8vM/svLzP7Kysv+ycnK/sjIyf7Hx8j+xsbH + /sbGx/7Fxcb+xMTF/sPDxP7CwsP+wsLD/r29vvFqamqMTExMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AG9vbweqqqqs/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz + //Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PD/8vLy/vHx8v/x8fH/8PDw/vDw8P/v7+//7+/v + /u7u7v/t7e7/7e3t/uzs7P/k5OT/paWn/mZnav+ysrT/3Nzd/t3d3v/e3t//3Nzc/q+vr/+Hh4f/o6Ok + /m9wc/97fH/+zs7O/+Li4//j4+P+4ODg/9PT0//X19j+3d3e/9fX2P/Pz9D+zs7P/87Ozv/Nzc3+zMzN + /8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC/8HBwv/Fxcf9RERF + PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFRUVAq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4 + /vf39/729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7v7/D+8vLy + /vLy8v7x8fL+8PDw/vDw8P7v7/D+7+/v/u7u7v7u7u7+7e3t/uzs7f7s7Oz+4+Pj/qSlpv5iYmb+tra4 + /tzc3f7d3d7+3t7f/tzc3f6vr6/+hYWG/qOjo/5rbHD+gICD/s/Pz/7i4uP+4ODg/tPT0/7X19j+3t7f + /tjY2f7Pz8/+zs7P/s3Nzv7Nzc3+y8vM/svLzP7Kysv+ycnK/sjIyf7Hx8j+xsbH/sbGx/7Fxcb+xMTF + /sPDxP7CwsP+wcHC/sDAwf7Fxcf+SEhIRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFlZWQq5ubm6/f39 + /vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx + /+/v8P/u7u/+7u7u/+3t7f/v7/D/8/Pz/vLy8//y8vL/8fHx/vHx8f/w8PD/8PDw/u/v7//u7u//7u7u + /u3t7v/t7e3/7Ozs/uPj5P+np6j/YmNn/rOztf/c3N3/3d3e/t/f3//d3d7/rq6v/oeHh/+kpKX+amtu + /3+Ag//Ozs/+4ODh/9PT1P/X19j+4ODh/9ra2v/Pz8/+zs7P/87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK + /8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC/8HBwv/Fxcf+SkpLRQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2 + //T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PD/8/Pz/vPz8//y8vL/8fHx + /vHx8f/x8fH/8PDw/u/v8P/v7+//7u7u/u7u7v/t7e7/7Ozt/uzs7P/j4+T/oqKk/mZnav+0tLb/3Nzd + /t3d3v/e3t//3Nzd/q6ur/+Ghof+oaGi/2tscP+BgYT+z8/P/9LS0//Y2Nn+4eHi/9vb2//Pz8/+zs7P + /87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC + /8HBwv/Fxcf+S0tMRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P77+/v++vr6 + /vr6+v75+fn++Pj4/vf39/729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t + /u3t7f7v7/D+8/Pz/vPz8/7y8vP+8vLy/vHx8v7w8PH+8PDw/vDw8P7v7+/+7+/v/u7u7/7t7e7+7e3t + /u3t7f7s7Oz+4uLi/qChov5iY2f+ubm7/tzc3f7d3d3+3t7f/tzc3P6urq/+hoaG/qCgof5oaW3+hISG + /sHCwv7Y2Nn+4+Pj/tzc3P7Pz8/+zs7P/s3Nzv7Nzc3+y8vM/svLzP7Kysv+ycnK/sjIyf7Hx8j+xsbH + /sbGx/7Fxcb+xMTF/sPDxP7CwsP+wcHC/sDAwf7Fxcf+S0tMRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz + //Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PD/9PT0/vPz9P/z8/P/8vLy/vLy8v/y8vL/8fHx + /vDw8f/w8PD/7+/v/u/v7//v7+//7u7u/u7u7v/t7e7/7Ozs/uPj4/+io6T/YmNn/ra2uP/c3N3/3d3e + /t7e3//e3t7+r6+v/4aGh/+ioqL+Z2hs/35+gf/Hx8j+5OTk/93d3v/Pz8/+zs7P/87Ozv/Nzc3+zMzN + /8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC/8HBwv/Fxcf+S0tM + RQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4 + //f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PD/9PT0 + /vT09P/09PT/8/Pz/vLy8//y8vL/8fHy/vHx8f/x8fH/8PDw/vDw8P/v7+//7u7v/u7u7v/u7u7/7e3t + /uzs7P/j4+P/nZ2f/mZna/+3t7n/3Nzd/t3d3v/e3t/+3Nzd/66ur/+Hh4f+n5+g/2lqbf+Cg4b+1dXV + /93d3v/Pz8/+zs7P/87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF + /8PDxP/CwsP+wcHC/8HBwv/Fxcf+S0tMRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39 + /vz8/P77+/v++vr6/vr6+v75+fn++Pj4/vf39/729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw + /u/v8P7u7u/+7e3t/u3t7f7w8PD+9PT0/vT09P7z8/T+8/Pz/vPz8/7y8vL+8vLy/vHx8f7x8fH+8PDw + /vDw8P7v7/D+7+/v/u/v7/7u7u7+7u7u/u3t7f7t7e3+4uLi/pycnv5jY2f+vLy+/tzc3f7d3d7+39/f + /tzc3f6urq/+hoaG/p6en/5mZ2v+iImL/s/Pz/7Pz8/+zs7P/s3Nzv7Nzc3+y8vM/svLzP7Kysv+ycnK + /sjIyf7Hx8j+xsbH/sbGx/7Fxcb+xMTF/sPDxP7CwsP+wcHC/sDAwf7Fxcf+S0tMRQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2 + //T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PH/9fX1/vX19f/19fX/8/Pz + /vPz9P/z8/P/8vLy/vLy8v/x8fL/8fHx/vHx8f/w8PD/7+/w/u/v7//v7+//7u7u/u7u7v/t7e7/7e3t + /uLi4v+dnp//Y2Nn/rm5uv/c3N3+3d3e/97e3//d3d7+rq6v/4eHh/+fn6D+Zmdq/4KDhf/AwMD+zs7P + /87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC + /8HBwv/Fxcf+SkpLRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7 + //r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u + /+3t7f/w8PH/9fX1/vX19f/19fX/9PT0/vT09P/z8/T/8/Pz/vLy8//y8vL/8fHy/vHx8f/x8fH/8PDx + /vDw8P/w8PD/7+/v/u/v7//u7u//7u7u/u3t7f/j4+P/mZmb/mZna/+5urv+3Nzd/93d3v/e3t/+3Nzd + /6+vr/+Ghof+nJyd/2dobP+EhIb+ycnJ/87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK/8jIyf/Hx8j+xsbH + /8XFxv/ExMX+w8PE/8LCw//CwsP+wcHC/8HBwv/Fxcf+R0dHRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFtbWwq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4/vf39/729vb+9fX1/vT09f7z8/T+8/Pz + /vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7w8PH+9vb2/vX19f719fX+9PT0/vT09P7z8/T+8/Pz + /vPz8/7y8vL+8vLy/vHx8v7x8fH+8fHx/vHx8f7w8PD+8PDw/u/v7/7v7+/+7u7v/u7u7v7t7e7+4eHh + /peYmv5jZGj+vr/A/tzc3f7d3d3+39/f/tzc3f6urq/+hYWG/o6OkP5mZ2r+vr6+/s3Nzv7Nzc3+y8vM + /svLzP7Kysr+xsbG/r+/v/6zs7T+o6Ok/qChov6cnJ3+n5+g/qCgof6rq6z+tbW2/ry8vf7Fxcb+RERF + RQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4 + //f39//29vb+9fX2//T09f/09PT+8/P0//Pz8//x8fL+8PDx/+/v7//t7e7+7Ozs/+rq6//t7e3/8vLy + /vHx8f/x8fH/7/Dw/u/v7//v7+//7u7u/u7u7v/t7e7/7Ozs/uzs7f/s7Oz/7Ozs/uvr7P/r6+v/6+vr + /urq6//q6ur/6urq/unp6v/p6en/6enp/t3d3f+Wl5j+Y2Ro/7u8vf/c3N3+3d3e/97e3//V1db+tLO0 + /5aVl/9gYWX+paWm/8vLzP/Nzc3+ysrL/76+v/+kpKX+hYWH/3Bwc/9qa27+cXJ1/3d4e/97fH/+d3h8 + /3BxdP9pam7+amtu/3p7ff+YmJr+Ly8vVlpaWwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFpaWgq5ubm6/f39 + /vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//X19v/x8fH+6+vr/+Tk5f/f3+D+2trb/9bW1//S09T+0NDR + /8/P0P/Ozs/+zc3O/83Nzv/MzM7/zMzO/szMzf/MzM3/zMzN/szMzf/MzM3/zMzN/szMzf/MzM3/y8vN + /szMzf/MzM3/y8vN/szMzf/MzM3/y8vN/szMzf/Ly83/y8vN/svLzf/Ly83/y8vN/svLzf/BwcL+hoaI + /2Znav+7vL3+3Nzd/9fX2P/Ly8z+3Nvb/9XU1P+Qj5H+aGhs/6mpqv+9vb7+nJye/3Z2ef9yc3X+lpeZ + /76+v//Y2Nn+5eXl/+np6f/p6en+5+fn/+Hi4v/W1tf+vb2+/5eXmv9yc3b+WVpd4jg4OoApKSkiSEhJ + AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFZWVwq5ubm6/f39/vz8/P78/Pz+9vb2/uXl5v7U1NX+x8fJ/r6/wf66urz+uLi6 + /re4uv63uLr+uLi6/ri4uv63uLn+t7e5/ra3uf63t7n+t7e5/re3uv66urz+vb2//r+/wP7AwML+wsLE + /sTExv7Gxsj+x8fJ/snJy/7Kysz+ysrM/svLzf7Ly83+y8zN/szMzf7MzM3+y8vN/svLzP7Kysv+ycnL + /sjIyv7IyMn+xsfI/sXFx/7Dw8X+t7e5/oOEhv5jZGj+wcHC/s3Ozv7R0dL+3+Dh/uPh4v7t6Oj+dHV3 + /mdoa/5yc3b+c3R3/rGys/7j4+P+8/Pz/vHx8f7o6Oj+4uLi/tra2/7b29v+2trb/t/f3/7h4eH+5ubm + /ufn6P7c3Nz+sbGy/nR1eP5YWVzaLi4vWjMzNAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFFRUQq5ubm6+/v7/t3e3/+6urz+pKWn + /6Kjpf+io6X+oqKk/6Kjpf+lpqj+rK2v/7S1tv+8vb7+xcbG/83Nzv/T09T+2trb/+Dg4P/j4+T+5ubn + /+np6f/u7u7/8fHx/vHx8f/x8fH/8PDw/u/v7//v7+//7u7u/uzs7f/s7Oz/6+vr/uvr6//q6ur/6enq + /unp6f/o6On/5+fo/ufn5//m5ub/5eXm/uXl5f/k5OX/5OTk/uPj4//j4+P+4uLi/9XV1v+SkpT+YWJm + /2BhZf+Jio3+3Nzd/+Hh4f/f3+D+5uLi/4aGif+goaP+6urq//T09P/p6en+19fY/76/wP+qqqz+nZ2f + /5eXmv+Tk5b+mJmb/5+gov+ur7D+wcLD/9XW1v/d3d7+4uLj/93d3f+kpaf+Zmdq+0FCRJo2NjcYAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AG1tbQagoKCmrq6x/o+Qk/+PkJP+lpea/6eoqv+8vb/+0tLT/+Hh4v/r6+z+8fHx//Pz8//z8/T+8/P0 + //Ly8//x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/v7+//8fHx/vDw8f/w8PD/7+/v/u/v7//u7u7/7e3t + /uzs7f/s7Oz/6+vr/uvr6//q6ur/6enq/unp6f/o6On/5+fo/ufn5//m5uf/5ubm/uXl5f/l5eX/5OTk + /uPj4//j4+P+4uLi/+Hh4f/W1tf+ra2u/5GSlP9lZmr+n5+i/9vb3P/s7O3+1NPU/87Ozv/z8/P+7Ozt + /9HR0/+ur7D+k5OW/5iYmv+lpaf+rKyt/6urrP+lpab+m5ye/5GSlP+Kio3+iIiL/5GRlP+xsrP+09PU + /93d3f/g4OD+v8DB/3Fzdv1MTU+1ODk6G2FhYwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJOTkwE6OjpAgYOF9Kqrrf7V1tf+8PDw/vr6+v76+vr++Pj4 + /vf39/729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7v7+/+8fHx + /vHx8f7w8PH+7+/v/u/v7/7u7u7+7u7u/u3t7f7s7Oz+7Ozs/uvr7P7q6uv+6urq/unp6v7p6en+6Ojo + /ujo6P7n5+f+5ubn/ubm5v7l5eX+5OTl/uTk5P7j4+P+4+Pj/uLi4/7h4eL+3d3d/s3Nzv6lpaf+YWNm + /qSlp/7Pz9D+1tbX/vX19f7i4+P+ubm7/pKSlP6enp/+tbW2/ry8vP69vb7+vb2+/ry8vf67u7z+urq7 + /ri4uf6xsrP+oqOk/o2OkP5+f4HckpKTzsDAwf3Z2dr+3d3e/snKy/5zdHj+SktOtDg4ORcAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJOTkwJOTk5O6+vr + 7f39/f/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx + /+/v8P/u7u/+7u7u/+3t7f/v7/D/8vLy/vHx8v/x8fH/8PDw/u/v8P/v7+//7u7u/u7u7v/t7e7/7Ozs + /uzs7P/s7Oz/6urr/urq6v/q6ur/6enp/ujo6f/n5+j/5+fn/ufn5//m5uf/5eXl/uXl5f/k5OT+4+Pk + /+Pj4//i4uP+39/f/9PT0//Q0NH+kpOU/2tsb//R0dL+9vb2/9vb2/+pqar+kpKU/7S0tf+/v8D+v7/A + /76+v/+9vb7+vLy9/7y8vP+7u7v+urq7/7m5uv+4uLn+uLi4/7e4uP6ioqPRjIyMaZKSk5aurrDw2dna + /9vb2//MzMz+bW5x/0JDRZ04OTkMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFdXWAiysrK0/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2 + //T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PD/8vLy/vHx8v/x8fH/8PDw + /vDw8P/v7+//7+/v/u7u7v/t7e7/7e3t/uzs7f/s7Oz/6+vr/uvr6//q6uv/6enp/unp6f/o6On/6Ojo + /ufn5//n5+f/5ubm/uXl5v/l5eX+5OTl/+Tk5P/j4+T+4ODg/9LS0/+/v8D+cHF0/7m5u//29vb+3Nzd + /6Slp/+ampv+u7u8/8DAwf/AwMD+v7+//76+vv+9vb7+vLy9/7u7vP+6urv+urq6/7m5uf+4uLn+t7e4 + /7e3uP+6urv+jo6OhaGhoWCZmZmBra6v7djY2f/Z2dn+uLm6/2RkaPguLjBjUFFSAgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFRUVAq5ubm6/f39/vz8/P/7+/v++/v7 + //r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u + /+3t7f/w8PD/8vLy/vLy8//y8vL/8PDw/vDw8f/w8PD/7+/v/u/v7//u7u//7e3t/u3t7f/t7e3/6+vs + /uvr6//r6+v/6urq/unp6v/p6en/6Ojp/ujo6P/n5+j/5+fn/ubm5v/l5eX+5eXm/+Tk5f/k5OT+4eHh + /8zMzf+IiYv+kJCT//Ly8v/n5+f+ra2v/5mam/+8vL3+wcHB/8DAwf+/v8D+vr6//76+vv+9vb3+vLy8 + /7u7vP+6urv+ubm6/7m5uf+4uLn+t7e4/7e3t/+6urv+j4+Qiqenp2GmpqZknZ2eiLa2uPLZ2dn+19fY + /5aXmf9ZWl7hLC0tGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFpaWgq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4/vf39/729vb+9fX1/vT09f7z8/T+8/Pz + /vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7v7/D+8/Pz/vLy8v7y8vL+8fHx/vHx8f7w8PD+7+/w + /u/v7/7u7u7+7u7u/u3t7v7t7e3+7Ozs/uzs7P7r6+v+6urr/urq6v7p6er+6enp/unp6f7o6Oj+5+fn + /ufn5/7m5ub+5ubm/uXl5v7l5eX+4ODh/rKysv5tbnH+3N3e/vHx8f7DwsT+kJGT/rq6u/7CwsL+wcHB + /sDAwP6/v7/+vr6+/r29vv68vL3+u7u8/rq6u/66urr+ubm6/ri4uf64uLn+t7e3/ra2t/66urv+kZGR + jqioqGaqqqpoqampbKGhop/Kysv81dXW/s3Nzv5ub3L+ODk6g05OTwUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4 + //f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PD/8/Pz + /vPz8//z8/P/8fHx/vHx8f/x8fH/8PDw/u/v8P/v7+//7u7u/u7u7v/u7u7/7e3t/uzs7f/s7Oz/6+vr + /uvr6//q6ur/6urq/unp6v/p6en/6Ojo/ufn6P/n5+f+5+fn/+bm5v/l5eb+3Nzd/4iIiv+Wl5n+9vb3 + /9vb3P+YmJv+srKy/8HBwv/BwcH+wMDB/7+/v/++vr7+vb2+/7y8vf+8vLz+u7u8/7q6u/+6urr+ubm6 + /7m5uf+4uLn+uLi5/7e3uP+7u7v+l5eYlK2trW+vr69ysbGxda6urnqoqKnQ3Nzc/9TU1f+foKL+Vlda + 3CoqKx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39 + /vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx + /+/v8P/u7u/+7u7u/+3t7f/w8PD/9PT0/vPz9P/z8/P/8vLy/vLy8v/x8fH/8fHx/vDw8P/v7/D/7+/v + /u7u7//u7u7/7e3u/u3t7f/t7e3/7Ozs/uvr7P/r6+v/6urr/urq6v/p6er/6enp/ujo6f/o6Oj+5+fo + /+fn5//m5uf+zs7O/3BxdP/P0NH+8fHx/729vv+ZmZv+v7+//8HBwf/AwMD+v7+//76+v/+9vb7+vb29 + /7y8vP+7u7z+u7u7/7u7u/+6urv+urq6/7q6uv+5ubr+ubm5/7m5uf+8vL3+np6enLKysnm0tLR7tbW1 + fra2toCxsbGVx8fI/NXV1f/Jycr+Y2Rn/S8wMVxXV1kBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4/vf39/729vb+9fX1 + /vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7w8PD+9PT0/vPz8/7z8/P+8vLy + /vLy8v7x8fL+8fHx/vHx8f7w8PD+7+/v/u/v7/7u7u/+7u7u/u7u7v7t7e3+7Ozt/uzs7P7r6+z+6+vr + /uvr6/7q6ur+6urq/unp6f7p6en+6Ojo/ujo6P7n5+f+sLCy/nt8f/7t7e7+4uLj/qCgov6ysrL+wMDB + /r+/wP6/v7/+vr6//r29vv69vb3+vb29/ry8vP68vL3+vLy8/ru7vP67u7v+u7u7/ru7u/67u7v+u7u7 + /rq6u/69vb7+pKSko7e3t4O5ubmFurq6h7u7u4i7u7uJtbW32tra2/7S0tP+gIGE/kRFR6hDREUGAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7 + //r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u + /+3t7f/w8PD/9PT0/vT09P/09PT/8/Pz/vPz8//y8vL/8vLy/vHx8f/x8fH/8PDw/vDw8P/v7/D/7u7v + /u7u7v/u7u7/7e3t/u3t7f/s7O3/7Ozs/uvr7P/r6+v/6urr/urq6v/p6er+6enp/+np6f/l5eX+k5SW + /5qbnf/19fX+0tLT/5qanP+8vL3+wMDA/7+/wP+/v7/+vr6//76+v/+9vb7+vr6+/729vv+9vb3+vb29 + /729vf+9vb3+vLy9/729vf+9vb3+vLy9/729vf/AwMD+qqqqqby8vIu+vr6Nv7+/j8DAwJDBwcGSuLe4 + ttjY2f7Pz9D+oKGj/1ZXWtouLi8UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz + //Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PD/9fX1/vT09f/09PT/8/Pz/vPz8//z8/P/8vLy + /vLy8v/x8fL/8PDw/vDw8f/w8PD/7+/v/u/v7//u7u//7u7u/u3t7v/t7e3/7Ozt/uzs7P/s7Oz/6+vr + /uvr6//q6ur+6urq/+np6v/i4uP+fX6A/7a3uf/09PT+v7/A/6Wlp/+/v7/+wMDB/8DAwP+/v7/+v7/A + /7+/v/+/v7/+v7+//7+/v/++vr/+vr6//7+/v/+/v7/+v7+//7+/v/+/v8D+v7/A/7+/v//CwsP+r6+w + r8HBwZPDw8OUxMTElsXFxZfGxsaZxMTEpc7Oz/jQ0NH+tbW3/15fYvE/P0AuAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4 + /vf39/729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7w8PH+9fX1 + /vX19f709PX+9PT0/vPz9P7z8/P+8vLz/vLy8v7y8vL+8fHx/vHx8f7w8PH+8PDw/vDw8P7v7+/+7u7u + /u7u7v7t7e7+7e3t/u3t7f7s7O3+7Ozs/uvr7P7r6+v+6+vr/urq6v7d3d7+dHV4/srLzP7v7+/+sbGz + /rS1tv7BwcH+wcHC/sHBwf7BwcH+wMDB/sHBwf7BwcH+wMDB/sHBwf7BwcH+wMDB/sHBwf7BwcH+wcHB + /sHBwv7CwsL+wsLC/sLCw/7Fxcb+tra2tMbGxprIyMibycnJncrKyp7Ly8ufzc3NocbGyPHV1db+wcHC + /mJjZ/khISFJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39 + /vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx + /+/v8P/u7u/+7u7u/+3t7f/w8PH/9fX1/vX19v/19fX/9PT0/vT09P/09PT/8/Pz/vPz8//y8vP/8vLy + /vLy8v/x8fH/8PDx/vDw8P/w8PD/7+/v/u/v7//u7u//7u7u/u7u7v/t7e7/7e3t/uzs7f/s7Oz+6+vs + /+vr6//a2tr+bm9y/9TU1f/t7e3+ra2v/7u8vP/CwsL+w8PD/8LCw//CwsP+wsLD/8LCw//CwsP+w8PD + /8PDw//Dw8P+w8PE/8TExP/ExMT+xMTF/8TExf/FxcX+xcXG/8bGxv/Jycn+u7u7uczMzKDNzc2hz8/P + o8/Pz6TQ0NCl1NTUpMPDxOrW1tb+xcXG/2dobPwmJidbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2 + //T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PH/9vb2/vX19v/19fX/9PT0 + /vT09f/09PT/8/Pz/vPz8//z8/P/8vLy/vLy8v/y8vL/8fHx/vHx8f/w8PH/8PDw/u/v8P/v7+//7u7v + /u7u7v/u7u7/7e3t/u3t7f/t7e3+7Ozs/+zs7P/a2tr+bG1x/9XV1v/p6er+ra2v/7+/wP/ExMX+xcXF + /8XFxf/FxcX+xcXF/8XFxv/Fxcb+xcXG/8bGxv/Gxsf+xsbH/8fHx//Hx8f+x8fH/8jIyP/IyMn+yMjJ + /8nJyf/MzMz+wcHBvdHR0abT09On1NTUqNTU1KnV1dWq2NjYqcLCxOnX19j+xcXG/2hpbP0kJSVgAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P77+/v++vr6 + /vr6+v75+fn++Pj4/vf39/729vb+9fX1/vX19f709PT+8/P0/vLy8v7w8PD+7u7u/uzs7P7q6ur+6Ojo + /ubm5v7o6Oj+7Ozs/uvr7P7r6+v+6urq/unp6v7p6en+6enp/ujo6P7o6Oj+6Ojo/ufn5/7n5+f+5ubn + /ubm5v7m5ub+5ubm/ubm5v7l5eb+5eXl/uXl5f7l5eX+5OTl/uTk5P7k5OT+5OTk/uTk5P7V1dX+cHF0 + /s/P0P7s7Oz+sLGy/sHBwf7Hx8f+yMjI/sjIyP7IyMj+yMjI/sjIyP7IyMj+ycnJ/snJyf7Jycn+ycnK + /srKyv7Kysv+y8vL/svLzP7MzMz+zMzN/s3Nzf7Pz9D+x8fHwdbW1qvY2Nis2dnZrdnZ2a7a2tqv3d3d + rsjIye3U1NX+wsLD/mZnavsnJyhXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFpaWgq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn+9vb2//Dw8f/p6ur+4eHi/9ra2//T1NX+0NDR + /8zNzf/Ky8z+yMnJ/8fIyP/Hx8j+xsfI/8bHyP/Gx8f/xsbH/sbGx//Gx8f/xsfH/sbHx//Gx8f/xsfH + /sbHx//Gx8f/xsfH/sbHx//Gx8f/xsbH/sbHx//Gx8f/xsbH/sbHx//Gx8f/xsfH/sbHyP/Gx8j/xsfH + /sbHyP/Gx8f+xsfI/8bHyP++vr/+bm9y/8DAwf/s7O3+urq8/7W2t//Gxsb+x8fH/8fIyP/HyMj+ycnJ + /8nKyv/Kysr+y8vL/8zMzP/MzM3+zc3N/87Ozv/Ozs/+zs7P/8/Pz//Q0ND+0NDQ/9DQ0f/T09P+zMzM + xdra2rDc3Nyx3d3ds97e3rPf39+039/ftc7Oz/XT09P+u7u8/2BhZfciIiNDAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFVVVQq5ubm6/f39/v39/f/7+/v+6+vr/9bW1//Gxsj+u7y+ + /7W2uP+ys7b+srO2/7O0tv+ztLb+s7S2/7O0tv+ztLb+s7S2/7Kztv+ys7X+sbK1/7Gytf+ztLb/s7S3 + /rS1t/+2t7n/uLm7/rq6vP+7vL7/vb3A/r6/wf/AwML/wMHC/sHCw//BwsP/wcLE/sLDxP/Cw8T/wsLE + /sHCw//AwcP/v8DC/r/Awf++v8H/vb7A/ry8vv+6u73+ubq8/7i5u/+ys7X+dXZ4/6ipq//v7+/+ycnL + /6qqrP/CwsT+w8PE/8TExf/ExMX+xcbH/8bHyP/Hx8j+yMjJ/8nJyv/Kysv+ysvL/8zMzf/Nzc7+zs/Q + /9DQ0f/T09T+1NTU/9TU1P/W1tf+0dHRyN/f37Xg4OC14eHht+Li4rfj4+O429vbwNjY2fvMzM3+rKyu + /1xdYe4+P0AoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE5PTwm5ubm69fX1 + /svMzf6pqav+np+h/p+gov6foKL+np+i/p6fof6en6L+oqOm/qmqrP6xsbP+ubq8/sHBw/7IyMn+z8/Q + /tXV1v7a2tv+3t7f/uLi4v7o6Oj+7e3t/u/v7/7v7+/+7u7u/u7u7v7u7u7+7u7u/u3t7f7s7O3+6+vr + /uvr6/7q6ur+6enq/unp6f7o6Oj+5+fo/ufn5/7m5ub+5eXm/uXl5f7k5OX+5OTk/uPj4/7i4uL+4eHh + /uDg4f7e3t7+mpuc/oiJi/7s7Oz+2dra/qmpq/7Ozs7+zc3N/szMzP7Ly8v+ysvL/snKyv7Jycn+yMnJ + /sjJyf7IyMn+yMjJ/snKyv7Kysv+y8vM/szMzf7Nzc7+0NDR/tXV1f7a2tv+1tbWzOPj47rk5OS75eXl + u+bm5rzn5+e90dHS0eDg4f7IyMn+k5OW/lJSVs82NzcPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAGlpaQWRkZGanZ6h/ouMj/+KjI/+jpCT/5qbnv+trbD+w8TF/9TV1v/j4+T+7Ozt + //Dw8f/y8vP+8/Pz//Pz8//x8fL+8fHx//Dw8P/v7+/+7u7u/+3t7f/v7+//8fHx/vDw8f/w8PD/7+/v + /u/v7//u7u7/7e3t/uzs7f/s7Oz/6+vr/urq6//q6ur/6enq/unp6f/o6On/5+fn/ufn5//m5uf/5eXm + /uXl5f/l5eX/5OTk/uPj4//i4uP+4uLi/+Hh4v/g4OH+uLi5/3BxdP/c3N3+4uLj/7a3uP/IyMn+1dXV + /9XV1f/V1dX+1tbW/9bW1v/W1tb+19fX/9fX1//W1tb+1NTV/9PT0//Q0NH+zc7O/8zMzf/MzM3+zM3N + /83Ozv/X19f93d3dyufn577o6Oi/6enpwOrq6sDs7Oy+zM3N7NnZ2f/Jycr+cXJ2/z8/QZdNTk8EAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NjcueXt96Jmbnf/Gx8j+5ubn + //b29//6+vr++fn5//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u + /+3t7f/v7/D/8fHx/vDw8f/w8PD/7+/v/u/v7//u7u7/7u7u/u3t7f/s7O3/6+vs/uvr6//r6+v/6enq + /unp6f/p6en/6Ojo/ufn6P/n5+f/5ubm/ubm5v/l5eb/5OTl/uTk5P/j4+P+4uLj/+Li4v/h4eL+0NDQ + /3N0d/+0tbb+6enp/8/P0P+ys7T+2dna/9jY2f/Z2dn+2dnZ/9ra2v/a2tr+29vb/9vb2//c3Nz+29vc + /9zc3f/d3d3+3d3d/9zc3f/a2tv+1dXW/8/Q0P7V1tbq6Ojow+vr68Lr6+vD7OzsxO3t7cXe3t/K29vc + /svLzP+3uLn+Xl9i+igoKUpZWlwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AI6OjwE+Pj4+1tbW2P39/f78/Pz++vr6/vr6+v75+fn++Pj4/vf39/729vb+9fX1/vT09f7z8/T+8/Pz + /vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7v7+/+8fHy/vHx8f7w8PH+8PDw/u/v8P7u7u/+7u7u + /u3t7v7t7e3+7Ozs/uzs7P7r6+v+6urr/urq6v7p6er+6enp/ujo6P7n5+j+5+fn/ufn5/7m5ub+5eXl + /uTk5f7k5OT+4+Pj/uPj4/7i4uL+3Nzc/paXmP54eX3+5ubm/t/f3/63t7j+z8/Q/t3d3f7c3Nz+3d3d + /t7e3v7e3t7+3t7e/t/f3/7f39/+39/g/uDg4P7g4OD+4eHh/uHh4v7h4eL+4uLi/uLi4v7i4uLp6urq + ye7u7sfv7+/I8PDwyO/v78fMzc7s3t7e/sfHyP6Hh4r+UVJVyTk5OhMAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGxsbAetra2v/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4 + //f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PD/8vLy + /vHx8v/x8fH/8PDw/vDw8P/v7+//7+/v/u7u7v/t7e7/7e3t/uzs7f/s7Oz/6+vr/uvr6//q6uv/6enp + /unp6f/o6On/6Ojo/ufn5//n5+f/5ubm/uXl5v/l5eX+5OTk/+Tk5P/j4+P+39/g/729vv9tbnL+tba3 + /+bm5//W19f+sbGz/9zc3f/g4OD+4ODg/+Hh4f/h4eH+4uLi/+Li4v/i4uP+4uLj/+Pj4//k5OT+5OTk + /+Tk5f/l5eX+5eXl/+bm5v/o6Oj+6Ojo1/Hx8cvy8vLL8/Pzy9XV1tzh4uL+ycnJ/7W1tv9hYmb9Ly8w + YlJSVAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFRUVAq5ubm6/f39 + /vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx + /+/v8P/u7u/+7u7u/+3t7f/w8PD/8vLy/vLy8v/y8vL/8PDw/vDw8P/w8PD/7+/v/u/v7//u7u//7e3t + /u3t7f/t7e3/6+vs/uvr6//r6+v/6urq/unp6v/p6en/6Ojp/ujo6P/n5+j/5+fn/ubm5v/l5eX+5eXl + /+Tk5f/k5OT+4ODh/8/P0P+ampz+cnN2/9fX2P/h4eL+zc3O/7e4uf/j4+P+5OTk/+Tk5P/k5OT+5eXl + /+bm5v/m5ub+5ubm/+bm5//n5+f+5+fn/+jo6P/o6On+6Ojo/+jo6P/q6uv+6urq2/T09M/09PTP3t/f + 1dvb3PvR0dL+xsbG/3p7fv9RUlXHKyssEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFpaWgq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4/vf39/729vb+9fX1 + /vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7v7/D+8/Pz/vLy8v7x8fL+8fHx + /vDw8f7w8PD+7+/w/u/v7/7u7u7+7e3u/u3t7v7s7O3+7Ozs/uzs7P7r6+v+6urq/urq6v7p6er+6enp + /unp6f7o6Oj+5+fn/ufn5/7m5ub+5ubm/uXl5f7k5OX+4eHh/tPT0/7MzM3+fn+C/omKjP7f3+D+3t7f + /s3Ozv65urv+5eXl/ujo6P7o6Oj+6enp/unp6f7p6en+6enp/urq6v7q6ur+6urq/uvr6/7r6+v+6+vr + /uvr6/7t7e3+7e3t3/b29tLe3t/Y2NjZ+9bW1/7IyMj+k5OW/ltcYOwjJCRAYGBiAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7 + //r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u + /+3t7f/w8PD/8/Pz/vPz8//y8vP/8fHx/vHx8f/x8fH/8PDw/u/v8P/v7+//7u7u/u7u7v/t7e7/7e3t + /uzs7P/s7Oz/6+vr/uvr6//q6ur/6urq/unp6f/p6en/6Ojo/ufn6P/n5+f+5+fn/+bm5v/l5eb+4uLi + /9PT1P/X19j+w8PE/3Nzdv+YmZv+4ODg/93d3f/S0tP+uru8/9zc3f/r6+v+6+vr/+zs7P/s7Oz+7Ozs + /+3t7f/t7e3+7e3t/+3t7f/t7e7+7u7u/+7u7v/w8PD+6+vr4NXV1uTc3N381dXW/8fHyP+jpKX+Xl9j + +TIyNHBJSksFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz + //Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PD/8/Pz/vPz9P/z8/P/8vLy/vHx8v/x8fH/8PDw + /vDw8P/v7/D/7+/v/u7u7//u7u7/7e3t/u3t7f/s7O3/7Ozs/uvr7P/r6+v/6urr/urq6v/p6er/6enp + /ujo6P/o6Oj+5+fo/+fn5//m5ub+4+Pj/9PT1P/Z2dn+4ODh/7a2t/9qa27+mpud/93d3f/c3N3+19fY + /8XFxv/Dw8T+5eXl/+/v7//v7+/+7+/v/+/v7//v7+/+7+/v//Dw8P/w8PD+8fHx/+7u7v/Y2Nn+zs/P + +OLi4v7Q0ND+yMjJ/6KjpP9hYmb+OTo7ijk6OwwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4 + /vf39/729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7w8PD+9PT0 + /vPz8/7z8/P+8vLy/vLy8v7x8fL+8fHx/vHx8f7w8PD+7+/v/u/v7/7u7u/+7u7u/u7u7v7t7e3+7Ozt + /uzs7P7r6+z+6+vr/uvr6/7q6ur+6urq/unp6f7p6en+6Ojo/ujo6P7n5+f+5OTk/tPT1P7Z2dr+5OTl + /tra2/6vr6/+bW5x/oWGif7Ozs/+3Nzd/tjY2f7a2tv+xsbH/sXGx/7Q0NH+3d3e/ubm5v7p6er+6Ojp + /uLi4/7Z2dr+0NHR/tDQ0f7f39/+2dnZ/snJyv7Fxcb+j4+R/l5fY/g5OTuJPDw9CgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39 + /vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx + /+/v8P/u7u/+7u7u/+3t7f/w8PD/9PT0/vT09P/09PT/8/Pz/vLy8//y8vL/8vLy/vHx8f/x8fH/8PDw + /vDw8P/v7+//7u7v/u7u7v/u7u7/7e3t/u3t7f/s7O3/7Ozs/uvr7P/r6+v/6urq/urq6v/p6en+6enp + /+jo6f/o6Oj+5eXl/9PT1P/Z2dr+5ubm/97e3//Nzc3+s7S1/3p7fv9ub3P+ra2v/9XV1v/Z2dn+19fY + /9nZ2v/Z2dr+1dXW/9PT1P/T09P+1dXW/9jY2P/d3d7+3Nzd/9TU1P/Ly8z+yMjJ/66vsP90dXn+Wlte + 5zM0NWg5OToLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4/vf39/729vb+9fX1 + /vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7w8PD+9fX1/vT09P709PT+8/Pz + /vPz8/7y8vL+8vLy/vHx8f7x8fH+8PDw/vDw8P7v7/D+7+/v/u/v7/7u7u7+7u7u/u3t7f7t7e3+7Ozt + /uzs7P7s7Oz+6+vr/urq6/7q6ur+6urq/unp6v7p6en+5eXm/tPT1P7a2tr+6Ojo/t/f4P7Pz8/+zc3O + /sDAwf6VlZb+aGls/nZ3ev6np6n+zs7P/tfX1/7U1NX+09PT/tHR0v7Q0dH+z8/Q/s/P0P7MzM3+zc3O + /sjIyf6rq6z+fHx//l9gZPtLS060Hh4fMlNTVQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7 + //r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u + /+3t7f/w8PH/9fX1/vX19f/19fX/8/Pz/vPz9P/z8/P/8vLy/vLy8v/y8vL/8fHx/vHx8f/x8fH/7+/w + /vDw8P/v7/D/7u7u/u7u7v/t7e7/7e3t/u3t7f/s7O3/7Ozs/uvr7P/r6+v+6urr/+rq6v/p6er+5ubn + /9PT1P/a2tv+6enp/+Hh4f/Pz8/+zs7P/87Ozv/Kysr+tra3/4+Qkv9ubnH+ZmZq/3t8f/+XmJr+qqut + /7S0tv+2t7j+s7S1/6urrP+amp3+f4CD/2Vmav9jZGj+SUpMvS8vMEc6OjsKAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz + //Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PH/9fX1/vX19f/19fX/9PT0/vT09P/z8/T/8/Pz + /vLy8//y8vL/8fHy/vHx8f/x8fH/8PDx/vDw8P/w8PD/7+/v/u/v7//u7u//7u7u/u7u7v/t7e3/7e3t + /uzs7P/s7Oz+6+vr/+vr6//q6uv+5+fo/9PT1P/a2tv+6+vr/+Li4//Pz8/+zs7P/87Ozv/Nzc3+y8vM + /8fHyP+7u7z+oqKj/4qKjP91dnj+a2xv/2NkaP9kZWn+ZGVo/2Vmaf9wcHP+fX1//5KSlP+tra/+MTEx + S2pqawIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4 + /vf39/729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7w8PH+9vb2 + /vX19f719fX+9PT0/vT09P7z8/T+8/Pz/vPz8/7y8vL+8vLy/vHx8v7x8fH+8fHx/vHx8f7w8PD+8PDw + /u/v7/7v7+/+7u7v/u7u7v7u7u7+7e3t/u3t7f7s7Oz+7Ozs/uvr7P7r6+v+6Ojo/tPT1P7b29v+7Ozs + /uPj5P7Pz8/+zs7P/s3Nzv7Nzc3+y8vM/svLzP7Kysv+yMjJ/sXFxv7BwcL+uLi5/rS0tf6zs7T+srKz + /rKys/64uLn+vb2+/r+/wP7Fxcf+Q0NERQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39 + /vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/09PT+8/P0//Pz8//x8fH+8PDw + /+7u7v/s7O3+6+vr/+np6f/r6+z/8PDw/u/v7//v7+//7u7u/u7u7v/t7e3/7e3t/uzs7P/s7Oz/6+vr + /uvr6//r6+v/6+vr/urq6v/q6ur/6urq/unp6f/p6en/6Ojp/ujo6P/o6Oj/5+fo/ujo6P/n5+j+5+fn + /+fn5//m5uf+5OTl/9TU1f/a2tv+6enp/+Pj4//Q0ND+z8/Q/87Oz//Nzc3+zMzN/8vLzP/Kysv+ycnK + /8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC/8HBwv/Fxcf+RkZHRQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFpaWgq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//T09P/v7+/+5+jo + /+Hh4v/a29z+1tfY/9LS0//P0NH+zM3O/8vMzf/Ly8z+ysvL/8nKy//Jysv/ycrL/snKy//Jysv/ycrL + /snKy//Jysv/ycrK/snKyv/Jysr/ycrK/snKyv/Jysr/ycrK/snKyv/Jysr/ycrK/snKyv/Jysr/ycnK + /snKyv/Jysr/ycnK/snKyv/Jysr+ycrK/8nKyv/Jysr+ycrK/8nKyv/Jysr+ycrL/8nKy//Jycr+ycnK + /8jJyv/Iycr+yMnK/8jIyf/Iycn+x8jJ/8jIyP/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC + /8HBwv/Fxcf+SkpKRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFZWVgq5ubm6/f39/vz8/P78/Pz+8/Pz + /uDg4f7Pz9H+w8PF/ru7vv63t7r+tba4/rW2uP62t7n+tre5/ra3uf62t7n+tre4/rW3uP61trj+tba4 + /rW2uP60tbf+tLW3/rW2uP62t7j+tre5/re4uv64ubv+ubq7/ru8vf68vb7+vL2//r2+v/69vsD+vr/A + /r6/wP6+v8H+vr/A/r2+wP69vr/+vL2//ru8vv67vL3+uru9/rm6vP64ubv+t7i6/ra4uf62t7n+tre4 + /rW2uP61trj+tba4/rW2uP61t7j+tre4/ra3uP62t7n+tre5/ra3uf62t7n+tre5/ra3uf62t7n+tre6 + /ri4u/65urz+vLy+/sDAwv7Dw8T+wcHC/sDAwf7Fxcf+SUlKRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AE9PTwm5ubm6+fn5/tjY2f+0tbb+oqOl/6Gipf+io6X+oqOl/6GipP+hoqT+oqOl/6anqf+srK7+s7S1 + /7q6vP/AwML+x8fJ/83Nzv/R0tP+1tbX/9ra2//h4eL/5+fn/unp6v/q6+v/6+vr/uvr7P/s7Oz/7Ozt + /uzs7P/r6+z/6urr/urq6v/q6ur/6Ojp/ujo6P/o6Oj/5+fn/ubm5//l5eb/5OTl/uTk5P/j4+T/4uLj + /uHh4v/h4eH+4ODg/97e3v/c3N3+2NjZ/87O0P/Ozs/+zs7P/8fHyf/BwcL+vr7A/7q6vP+2trj+srK0 + /66usP+qq63+pqep/6Okpv+ioqX+oaKl/6Kjpf+io6X+oqOl/6Kjpf+kpaf+rq6w/7q7vP/Gxsf+R0dI + RQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGhoaQabm5uiqKms/o6Pkv+NjpL+j5CT/5aXmv+kpKf+t7i6 + /8nJy//Z2dr+5OXl/+zs7P/w8PD+8fLy//Ly8v/x8fH+8fHx//Dw8P/v7+/+7u7u/+3t7f/v7+//8fHx + /vDw8f/w8PD/7+/v/u7u7//u7u7/7e3t/uzs7f/s7Oz/6+vr/urq6//q6ur/6enq/unp6f/o6On/5+fn + /ufn5//m5uf/5eXm/uXl5f/k5OX/5OTk/uPj4//i4uP+4uLi/+Hh4v/g4OH+3d3d/9PT1P/V1db+2dna + /9XV1f/Q0ND+zs7P/87Oz//Nzc3+zMzN/8rKy//Jycr+x8fH/8PDxP+9vb7+tbW3/6urrf+goaT+lpea + /5CRlP+Oj5L+jo+S/5CRlP+xsbP8QkJCOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI2NjgEyMjI5fn+C + 846Pkv65urv+29zc/vDw8f74+Pj++fn5/vf3+P729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw + /u/v8P7u7u/+7e3t/u3t7f7v7+/+8fHx/vDw8P7w8PD+7+/v/u/v7/7u7u7+7u7u/u3t7f7s7Oz+6+vr + /uvr6/7q6uv+6enq/unp6f7p6en+6Ojo/ufn5/7n5+f+5ubm/ubm5v7l5eX+5OTk/uTk5P7j4+P+4uLi + /uLi4v7h4eL+3t7e/tPT1P7W1tf+29vb/tbW1v7Pz9D+zs7P/s3Nzv7Nzc3+y8vM/svLzP7Kysv+ycnK + /sjIyf7Hx8j+x8fI/sbGx/7Fxcb+wsLD/rq6u/6rrK3+lJWX/n+BhP5mZ2m7TExNCwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAI2NjgEwMDAxxMTEzvv7+//8/Pz++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2 + //T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/v7/D/8vLy/vHx8v/x8fH/8PDw + /u/v8P/v7+//7u7u/u3t7v/t7e3/7Ozs/uzs7P/r6+v/6urr/urq6v/p6er/6enp/ujo6f/n5+j/5+fn + /ubm5v/m5ub/5eXl/uTk5f/k5OT+4+Pk/+Pj4//i4uL+39/f/9PT0//W1tf+3Nzc/9bW1//Pz9D+zs7P + /87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wsLD + /7y8vfpnZ2eMTExNCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpqagempqap/f39/vz8/P/7+/v++/v7 + //r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u + /+3t7f/w8PD/8vLy/vHx8v/x8fH/8PDw/vDw8P/v7+//7u7v/u7u7v/t7e7/7Ozt/uzs7P/s7Oz/6+vr + /urq6//q6ur/6enp/unp6f/o6Oj/5+fo/ufn5//m5uf/5ubm/uXl5v/l5eX+5OTk/+Tk5P/j4+P+39/g + /9PT0//X19j+3d3e/9fX2P/Pz9D+zs7P/87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI + /8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC/8HBwv/Fxcb8Q0NEOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFJSUgq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4/vf39/729vb+9fX1/vT09f7z8/T+8/Pz + /vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7v7/D+8vLy/vLy8v7x8fL+8PDw/vDw8P7v7/D+7+/v + /u7u7v7u7u7+7e3t/uzs7f7s7Oz+6+vs/uvr6/7q6ur+6urq/unp6f7p6en+6Ojo/ujo6P7n5+f+5+fn + /ubm5v7l5eX+5eXl/uTk5f7j4+T+4ODg/tPT0/7X19j+3t7f/tjY2f7Pz8/+zs7P/s3Nzv7Nzc3+y8vM + /svLzP7Kysv+ycnK/sjIyf7Hx8j+xsbH/sbGx/7Fxcb+xMTF/sPDxP7CwsP+wcHC/sDAwf7Fxcf+SEhJ + RQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFlZWQq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4 + //f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/v7/D/8/Pz + /vLy8//y8vL/8fHx/vHx8f/w8PD/7+/v/u/v7//u7u//7u7u/u3t7v/t7e3/7Ozs/uzs7P/r6+z/6urq + /urq6v/p6er/6enp/unp6f/o6On/5+fn/ufn5//m5ub+5eXm/+Xl5f/k5OX+4eHh/9PT1P/X19j+4ODh + /9ra2v/Pz8/+zs7P/87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF + /8PDxP/CwsP+wcHC/8HBwv/Fxcf+SkpLRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39 + /vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx + /+/v8P/u7u/+7u7u/+3t7f/w8PD/8/Pz/vPz8//y8vL/8fHx/vHx8f/w8PH/8PDw/u/v8P/v7+//7u7u + /u7u7v/t7e7/7Ozt/uzs7P/s7Oz/6+vr/urq6//q6ur/6enq/unp6f/p6en/6Ojo/ufn6P/n5+f+5ubm + /+bm5v/l5eb+4uLi/9PT1P/Y2Nn+4eHi/9vb2//Pz8/+zs7P/87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK + /8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC/8HBwv/Fxcf+S0tMRQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4/vf39/729vb+9fX1 + /vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7v7/D+8/Pz/vPz8/7y8vP+8vLy + /vHx8v7w8PH+8PDw/vDw8P7v7+/+7+/v/u7u7/7t7e7+7e3t/u3t7f7s7Oz+7Ozs/uvr6/7q6uv+6urq + /urq6v7p6en+6enp/ujo6P7n5+f+5+fn/ubm5/7m5ub+4+Pj/tPT1P7Y2Nn+4+Pj/tvb3P7Pz8/+zs7P + /s3Nzv7Nzc3+y8vM/svLzP7Kysv+ycnK/sjIyf7Hx8j+xsbH/sbGx/7Fxcb+xMTF/sPDxP7CwsP+wcHC + /sDAwf7Fxcf+S0tMRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7 + //r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u + /+3t7f/w8PD/9PT0/vPz9P/z8/P/8vLy/vLy8v/y8vL/8fHx/vDw8f/w8PD/7+/v/u/v7//v7+//7u7u + /u7u7v/t7e7/7Ozs/uzs7P/r6+z/6+vr/uvr6//q6uv/6urq/unp6f/o6On+6Ojo/+jo6P/n5+f+5OTk + /9PT1P/Z2dr+5eXl/93d3v/Pz8/+zs7P/87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI + /8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC/8HBwv/Fxcf+S0tMRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz + //Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PD/9PT0/vT09P/09PT/8/Pz/vLy8//y8vL/8fHx + /vHx8f/x8fH/8PDw/vDw8P/v7+//7u7v/u7u7v/u7u7/7e3t/u3t7f/s7O3/6+vs/uvr7P/r6+v/6urq + /urq6v/p6en+6enp/+jo6f/o6Oj+5eXl/9PT1P/Z2dr+5ubm/97e3//Pz8/+zs7P/87Ozv/Nzc3+zMzN + /8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC/8HBwv/Fxcf+S0tM + RQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P77+/v++vr6/vr6+v75+fn++Pj4 + /vf39/729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t/u3t7f7w8PD+9PT0 + /vT09P7z8/T+8/Pz/vPz8/7y8vL+8vLy/vHx8f7x8fH+8PDw/vDw8P7v7/D+7+/v/u/v7/7u7u7+7u7u + /u3t7f7t7e3+7Ozs/uzs7P7r6+z+6+vr/urq6v7q6ur+6enp/unp6f7o6On+5eXm/tPT1P7Z2dr+5+fo + /t/f4P7Pz8/+zs7P/s3Nzv7Nzc3+y8vM/svLzP7Kysv+ycnK/sjIyf7Hx8j+xsbH/sbGx/7Fxcb+xMTF + /sPDxP7CwsP+wcHC/sDAwf7Fxcf+S0tMRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39 + /vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx + /+/v8P/u7u/+7u7u/+3t7f/w8PH/9fX1/vX19f/19fX/8/Pz/vPz9P/z8/P/8vLy/vLy8v/x8fL/8fHx + /vHx8f/w8PD/7+/w/u/v7//v7+//7u7u/u7u7v/t7e7/7e3t/u3t7f/s7O3/7Ozs/uvr7P/r6+v+6urr + /+rq6v/p6er+5ubn/9PT1P/a2tv+6enp/+Dg4f/Pz8/+zs7P/87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK + /8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC/8HBwv/Fxcf+S0tMRQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2 + //T09f/z8/T+8/Pz//Ly8v/x8fH+8PDx/+/v8P/u7u/+7u7u/+3t7f/w8PH/9fX1/vX19f/19fX/9PT0 + /vT09P/z8/T/8/Pz/vLy8//y8vL/8fHy/vHx8f/x8fH/8PDx/vDw8P/w8PD/7+/v/u/v7//u7u//7u7u + /u3t7v/t7e3/7Ozt/uzs7P/s7Oz+6+vr/+vr6//q6uv+5+fo/9PT1P/a2tv+6urq/+Li4v/Pz8/+zs7P + /87Ozv/Nzc3+zMzN/8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC + /8HBwv/Fxcf+S0tMRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P77+/v++vr6 + /vr6+v75+fn++Pj4/vf39/729vb+9fX1/vT09f7z8/T+8/Pz/vLy8v7x8fH+8PDw/u/v8P7u7u/+7e3t + /u3t7f7w8PH+9vb2/vX19f719fX+9PT0/vT09P7z8/T+8/Pz/vPz8/7y8vL+8vLy/vHx8v7x8fH+8fHx + /vHx8f7w8PD+8PDw/u/v7/7v7+/+7u7v/u7u7v7u7u7+7e3t/u3t7f7s7Oz+7Ozs/uvr7P7r6+v+6Ojo + /tPT1P7b29v+7Ozs/uTk5P7Pz8/+zs7P/s3Nzv7Nzc3+y8vM/svLzP7Kysv+ycnK/sjIyf7Hx8j+xsbH + /sbGx/7Fxcb+xMTF/sPDxP7CwsP+wcHC/sDAwf7Fxcf+S0tMRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4//f39//29vb+9fX2//T09f/09PT+8/P0 + //Pz8//x8fL+8fHx/+/v8P/t7e7+6+vr/+rq6v/s7Oz/8PDx/u/v8P/u7u//7e3t/uzs7P/r6+v/6uvr + /urq6//q6uv/6enq/unp6v/o6en/6Ojp/ujo6P/o6Oj/5+fo/ufn5//m5+f/5ubm/ubm5v/m5ub/5eXm + /uXl5v/l5eX+5eXl/+Xl5f/l5eb+4+Pk/9LS0//Z2dn+6enq/+Pj4//Pz8/+z8/P/87Oz//Nzc3+zMzN + /8vLzP/Kysv+ycnK/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF/8PDxP/CwsP+wcHC/8HBwv/Fxcf+S0tM + RQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFtbWwq5ubm6/f39/vz8/P/7+/v++/v7//r6+v/5+fn++Pj4 + //b29v/y8vP+7e3t/+bm5//f4OD+2dna/9TU1f/OztD+ycrL/8fIyf/Fxcf+w8PE/8LCw//BwsP/wcLD + /sHBw//BwcL/wMDC/sDAwv+/wMH/v8DB/r/Awf+/wMH/v8DB/r/Awf+/wMH/v8DB/r/Awf+/wMH/v7/B + /r/Awf+/wMH/v7/B/r/Awf+/wMH/v7/B/r/Awf+/v8H+v8DB/8DAwv/AwML+wMHC/8DAwv/AwcL+wcLD + /8HCw//AwcL+wsLE/8PDxP/Dw8T+xcXH/8XFx//Hx8j+x8jI/8jIyf/Hx8j+x8fI/8bGx//Fxcb+xMTF + /8PDxP/CwsP+wcHC/8HBwv/Fxcf+S0tMRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFlZWQq5ubm6/f39 + /vz8/P78/Pz++fn5/u3u7v7f4OH+1NXW/szMzf7Gxsj+w8PE/sLCxP7CwsT+wsPE/sLDxP7Cw8T+wsPE + /sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE + /sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE + /sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE/sLDxP7Cw8T+wsPE + /sLDxP7Dw8X+xMTF/sXFxv7Fxcf+xcXH/sTExf7Dw8T+wcHC/sDAwf7Fxcf+S0tMRQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAFVVVQq5ubm6/f39/u7u7v/Z2dn+ycnK/8bGx//Hx8j+x8fI/8fHyP/Hx8j+x8fI + /8fHyP/Hx8j+x8fI/8fHyP/Hx8j+x8fI/8fHyP/Hx8j+x8fI/8fHyP/Hx8j/x8fI/sfHyP/Hx8j/x8fI + /sfHyP/Hx8j/x8fI/sfHyP/Hx8j/x8fI/sfHyP/Hx8j/x8fI/sfHyP/Hx8j/x8fI/sfHyP/Hx8j/x8fI + /sfHyP/Hx8j/x8fI/sfHyP/Hx8j+x8fI/8fHyP/Hx8j+x8fI/8fHyP/Hx8j+x8fI/8fHyP/Hx8j+x8fI + /8fHyP/Hx8j+x8fI/8fHyP/Hx8j+x8fI/8fHyP/Hx8j+x8fI/8fHyP/Hx8j+x8fI/8fHyP/IyMj+xsbH + /8LDw//Fxcf+S0tLRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGxsbAakpKSp3N3d/szMzf/Ly83+zMzN + /8zMzf/Ly83+zMzN/8zMzf/Ly83+zMzN/8zMzf/Ly83+zMzN/8zMzf/Ly83+zMzN/8zMzf/Ly83+zMzN + /8zMzf/MzM3/y8vN/szMzf/MzM3/y8vN/szMzf/MzM3/y8vN/szMzf/MzM3/y8vN/szMzf/MzM3/y8vN + /szMzf/MzM3/y8vN/szMzf/MzM3/y8vN/szMzf/MzM3/y8vN/szMzf/Ly83+zMzN/8zMzf/Ly83+zMzN + /8zMzf/Ly83+zMzN/8zMzf/Ly83+zMzN/8zMzf/Ly83+zMzN/8zMzf/Ly83+zMzN/8zMzf/Ly83+zMzN + /8zMzf/Ly83+zMzN/8zMzf/Ly83+zMzN/8zMzf/Ly8z9RkZGPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AIuLiwFCQkJD0NHR99DQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR + /tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR + /tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR + /tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR + /tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tDQ0f7Q0NH+0NDR/tHR0f6mpqbGOzs7 + DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtbW0FTk5OVK6urszU1dX71dXW/9TU1f/U1NX+1NTV + /9TU1f/U1NX+1NTV/9TU1f/U1NX+1NTV/9TU1f/U1NX+1NTV/9TU1f/U1NX+1NTV/9TU1f/U1NX/1NTV + /tTU1f/U1NX/1NTV/tTU1f/U1NX/1NTV/tTU1f/U1NX/1NTV/tTU1f/U1NX/1NTV/tTU1f/U1NX/1NTV + /tTU1f/U1NX/1NTV/tTU1f/U1NX/1NTV/tTU1f/U1NX+1NTV/9TU1f/U1NX+1NTV/9TU1f/U1NX+1NTV + /9TU1f/U1NX+1NTV/9TU1f/U1NX+1NTV/9TU1f/U1NX+1NTV/9TU1f/U1NX+1NTV/9TU1f/U1NX+1NTV + /9TU1f/W1tf+zs7O8YyNjacxMTImAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAenp6 + Ak5OThVJSUpKent7lbGxsszOzs7t2NjZ+tra2/7Z2tr+2dna/9nZ2v/Z2dr+2dna/9nZ2v/Z2dr+2dna + /9nZ2v/Z2dr+2dna/9nZ2v/Z2dr/2dna/tnZ2v/Z2dr/2dna/tnZ2v/Z2dr/2dna/tnZ2v/Z2dr/2dna + /tnZ2v/Z2dr/2dna/tnZ2v/Z2dr/2dna/tnZ2v/Z2dr/2dna/tnZ2v/Z2dr/2dna/tnZ2v/Z2dr+2dna + /9nZ2v/Z2dr+2dna/9nZ2v/Z2dr+2dna/9nZ2v/Z2dr+2dna/9nZ2v/Z2dr+2dna/9nZ2v/Z2dr+2dna + /9nZ2v/Z2dr+2trb/9na2/7V1tb2xcXG5KCgoLlqamt6QUFBMVVVVQoAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdnZ2BEZGRg9XV1coOjo6UGJiYniEhISbpKWl + wcPDw9rW1tbu39/f++Dg4f7h4eH+4ODg/t7e3v7d3d3+3d3d/t3d3f7d3d3+3d3d/t3d3f7d3d3+3d3d + /t3d3f7d3d3+3d3d/t3d3f7d3d3+3d3d/t3d3f7d3d3+3d3d/t3d3f7d3d3+3d3d/t3d3f7d3d3+3d3d + /t3d3f7d3d3+3d3d/t3d3f7d3d3+3d3d/t3d3f7d3d3+3d3d/t3d3f7d3d3+3d3d/t3d3f7d3d3+3d3e + /t7e3/7h4eH+4eHh/uDg4P7d3d32zs7O6Lu7u9CXl5e0dXV1jVRUVGlERERATU1NHFtcXAmFhYYDAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAJqamwFlZWUDZ2dnB0hISAwyMjIWOjo6JFFRUTVFRUVLTExMYmVlZXNtbW2AcnJy + jISEhJaTk5Oil5eXqJmZmaybm5uwnJyctJ2dnbednZ25nZ2duZ2dnbmdnZ25nZ2duZ2dnbmdnZ25nZ2d + uZ2dnbmdnZ25nZ2duZ2dnbmdnZ25nZ2duZ2dnbmdnZ25nZ2duZ2dnbmdnZ25nZ2duZycnLabm5uympqa + rpmZmauWlpamkJCQnnx8fJJwcHCJa2trfF5eXm1CQkJaUVFRQ0RERC04ODgfLS0tEWBgYApmZ2cFdXV1 + AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAjo6OAZCQkAKSkpIClZWVA5WVlQSUlJQGUlJSB1JSUgdQUFAIUFBQCVBQUAlQUFAKUFBQ + ClBQUApQUFAKUFBQClBQUApQUFAKUFBQClBQUApQUFAKUFBQClBQUApQUFAKUFBQClBQUApQUFAKUFBQ + ClBQUApQUFAKUFBQClBQUAlQUFAIUFBQCFFRUQdSUlIHk5OTBZSUlAOUlJQDkpKSApCQkAGOjo4BAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////8D//////////////4B//////////// + //wA//////////////wAf/////////////gAP/////////////gAH/////////////gAD/////////// + //wAB///////////wAAAAAAD//////+AAAAAAAAAA/////gAAAAAAAAAAD///+AAAAAAAAAAAA///8AA + AAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AA + AAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AA + AAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAP//8AAAAAAAAAAAAD//8AAAAAAAAAAAAB//8AA + AAAAAAAAAAA//8AAAAAAAAAAAAAP/8AAAAAAAAAAAAAP/8AAAAAAAAAAAAAH/8AAAAAAAAAAAAAD/8AA + AAAAAAAAAAAD/8AAAAAAAAAAAAAB/8AAAAAAAAAAAAAB/8AAAAAAAAAAAAAA/8AAAAAAAAAAAAAA/8AA + AAAAAAAAAAAA/8AAAAAAAAAAAAAA/8AAAAAAAAAAAAAA/8AAAAAAAAAAAAAA/8AAAAAAAAAAAAAA/8AA + AAAAAAAAAAAA/8AAAAAAAAAAAAAA/8AAAAAAAAAAAAAA/8AAAAAAAAAAAAAA/8AAAAAAAAAAAAAA/+AA + AAAAAAAAAAAA/8AAAAAAAAAAAAAB/8AAAAAAAAAAAAAB/8AAAAAAAAAAAAAD/8AAAAAAAAAAAAAD/8AA + AAAAAAAAAAAH/8AAAAAAAAAAAAAP/8AAAAAAAAAAAAAf/8AAAAAAAAAAAAA//8AAAAAAAAAAAAB//8AA + AAAAAAAAAAH//8AAAAAAAAAAAAP//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AA + AAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AA + AAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AA + AAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AA + AAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AAAAAAAAAAAAf//8AA + AAAAAAAAAAf//8AAAAAAAAAAAAf//+AAAAAAAAAAAA////AAAAAAAAAAAB////4AAAAAAAAAAH/////g + AAAAAAAAD///////4AAAAAAH//////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////KAAAAEgAAACQAAAAAQAg + AAAAAABgVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADk5Ogk1NTdjPDw+nysrLD9PT1EBAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAOjs8DUJDRaFvb3L8mJma/19gY+svLzBATk5QAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRkgEOzw+ + k5GSlf7IyMn+jo6O/6Chov5eX2LqLS4vQE1OTwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMjMvdnd6+ujo6P/f3+D/wcHB + /46Ojv+en6D/X19j6S0tLjtMTE4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvMDEscXF1+NbW1//d3d7+39/f/8HBwf6NjY7/np6f + /1xcYOUsLC06S0tMAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABycnQDPT0+bHN0d/jS0tP/3d3e/9/f3//BwcH/jY2O/5ycnf9cXWHlLS0u + N15fYAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAjo6PAX9/fwOAgIAGXV1dClhYWBJeXl4acnJyJ1NTUzZZWVlFZmZm + UGhoaFlqampgZ2doanZ2eMV3eHv+09PU/93d3v7f39//wcHC/42Njf6am5z/WVpd5FBQUIJ9fX50fHx9 + bXBwcGVpaWlfZmZmV19fX05KSkpAZGRkM2RkZSVRUVIYTU1NEVtbXAltbW0Fa2tsA4KCggEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJCQAm9vbwtlZWUgbW1t + QGdnZ2SBgYGHmZmZoq6urr3KysvT2NjY4+bm5/Dp6en47Ozt+/Dw8fzx8fL98PDx/u/v7/7u7u7/7e3u + /+jo6P+oqKr/eHl8/9PT1P/d3d7/39/g/8HBwf+NjY7/mZma/29wc//Dw8T/4uLi/+Li4v/h4eL/4ODh + /tvb2/7U1NX92tra/NLS0/rLy8v3xsbH7bW1tt+np6jOjo6Otnt7fJpjY2N+WlpbWVFRUjZZWVoYYmJi + B3d3dwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF5eXhBtbW1XmJiYoM/Pz9Tt7e3x+Pj4/ff39//19fb/9PT0 + //Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Dw8P/x8fH/8PDw/+/v8P/u7u//7u7u/+3t7f/n5+f/pqan + /3h5fP/V1db/3d3e/9/f3//BwcH/jY2N/5eXmf9vcHP/xcbG/+Li4//i4uL/4eHi/9vb3P/T09T/29vb + /9TU1P/Pz9D/zs7P/8zMzf/Ly8z/ysrL/8nJyv/IyMn/yMjJ/8XFxvu5ubrqmpqbxm9vcIxNTU07ZmZm + BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAWFhYO93d3d78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw + /u/v8P/u7u7+7e3t//Dw8P7x8fL/8fHx//Dw8P7v7+//7u7u/u3t7v/s7O3+5+fo/6enqf55en3/09PU + /93d3v7f39//wcHB/o2Njf+Vlpf+cHB0/8bGxv7j4+P/4uLj/tzc3P/T09T/3Nzd/tXV1f/Pz8/+zs7O + /8zMzf7Ly8z/ysrL/snJyv/IyMn/x8fI/sbGx//ExMX+w8PE/8LCw/7CwsP9jo6Ot1hYWBAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhIQBjo6O + kP39/f/8/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t + //Dw8f/y8vL/8fHy//Dw8f/w8PD/7+/v/+7u7v/t7e7/7e3t/+fn5/+kpKb/ent+/9XV1//d3d7/39/f + /8HBwf+NjY7/k5OV/3Fxdf/Jycr/4+Pj/93d3f/T09T/3t7f/9XV1v/Pz9D/zs7P/8zMzf/Ly8z/ysrL + /8nJyv/IyMn/x8fI/8bGx//ExMX/w8PE/8LCw//BwcL/xMTG/1hYWTMAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACLi4sBjY2Nkv39/f78/Pz/+/v7 + /vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t//Dw8f7y8vP/8vLy + //Hx8f7w8PH/7+/w/u/v7//u7u7+7e3t/+zs7f7n5+f/pKWm/3p7fv7U1NX/3d3d/t/f3//BwcH+jY2O + /5KSlP5yc3b/ycnK/t3d3v/T09T/4ODg/tfX1//Pz8/+zs7O/8zMzf7Ly8z/ysrL/snJyv/IyMn/x8fI + /sbGx//ExMX+w8PE/8LCw/7BwcL/xMTF/l1dXTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4 + //b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Hx8f/z8/P/8vLz//Hx8v/x8fH/8PDw + /+/v7//v7+//7u7u/+3t7f/s7O3/5+fn/6Gho/98fYD/1dXW/93d3v/f39//wMDB/42Njv+QkJL/c3N2 + /8fHx//T09P/4eHi/9jY2P/Pz9D/zs7P/8zMzf/Ly8z/ysrL/8nJyv/IyMn/x8fI/8bGx//ExMX/w8PE + /8LCw//BwcL/xMTF/19fYDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0 + //Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t//Hx8f7z8/T/8/Pz//Ly8v7x8fL/8fHx/vDw8P/v7+/+7+/v + /+7u7v7t7e7/7e3t/+bm5v6hoaP/fH2A/tXV1v/d3d7+39/f/8HBwf6NjY7/j4+R/nFydf+9vb7/4+Pk + /tnZ2v/Pz8/+zs7O/8zMzf7Ly8z/ysrL/snJyv/IyMn/x8fI/sbGx//ExMX+w8PE/8LCw/7BwcL/xMTF + /l9fYDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx + /+/v8P/u7u7/7e3t//Hx8f/09PT/9PT0//Pz8//y8vP/8fHy//Hx8f/w8PD/8PDw/+/v7//u7u//7u7u + /+3t7f/n5+f/np+g/35+gf/V1db/3d3e/9/f3//AwMH/jY2N/42OkP9ycnb/zs7P/9ra2v/Pz9D/zs7P + /8zMzf/Ly8z/ysrL/8nJyv/IyMn/x8fI/8bGx//ExMX/w8PE/8LCw//BwcL/xMTF/19fYDQAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2N + kv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t + //Hx8f709PX/9PT0//Pz8/7z8/P/8vLy/vHx8v/x8fH+8PDw/+/v8P7v7+//7u7v/+7u7v7t7e3/5ubn + /p2dn/9+f4L+1tbX/93d3v7f39//wcHB/o2Njf+MjI7/dXZ5/sXFxv/Pz8/+zs7O/8zMzf7Ly8z/ysrL + /snJyv/IyMn/x8fI/sbGx//ExMX+w8PE/8LCw/7BwcL/xMTF/l9fYDQAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7 + //r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Ly8v/19fX/9fX1 + //T09P/z8/T/8/Pz//Ly8v/x8fL/8fHx//Dw8f/w8PD/7+/w/+/v7//u7u7/7e3u/+fn5/+cnJ7/f4CC + /9bW1//d3d7/39/f/8HBwf+NjY7/i4uN/3Jzdv++vr7/zs7O/8zMzf/Ly8z/ysrL/8nJyv/IyMn/x8fI + /8bGx//ExMX/w8PE/8LCw//BwcL/xMTF/1tbXDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4 + //b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Ly8v/29vb/9fX1//T09f/09PT/8/Pz + //Pz8//y8vL/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7v/+7u7v/n5+f/mZmb/3+Ag//X2Nn/3d3e + /9/f3//BwcH/jIyN/3x9gP+VlZf/zc3O/8zMzf/Ly8z/ysrL/8bGx/+9vb3/rq6v/6ipqv+mpqf/qKiq + /7Kys/+7u7z/w8PE/1NTVDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0 + //Ly8v7v7/D/7Ozs/urq6v/n5+f+5eXm/+jo6P7q6ur/6urq/+np6f7o6Oj/5+fo/ufn5//m5uf+5ubm + /+bm5v7l5eb/5eXl/+Xl5f7k5OX/5OTk/uTk5P/j4+T+3Nzd/5KTlf6AgIP/1tbX/t3d3v/a2tr/wsHB + /pKRk/93eHv+wsLD/8zMzP6+vr//mZqb/nt8fv94eXv/h4iK/pGSlP+Tk5b+ioqN/3p7fv5zdHb/hoeJ + /jk5OllUVFUFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACNjY0BjY2Nkv39/f/8/Pz/+/v7//f39//r6+v/3t7f/9XV1v/Nzs//yMjK/8XFx//Dw8X/wsLE + /8LCw//BwcP/wcLD/8HBw//BwcP/wcLD/8LCxP/CwsT/w8PF/8PDxf/Dw8X/w8TG/8TExv/ExMb/xcXG + /8TFxv/ExMb/w8TF/8PDxf/Dw8X/w8PE/7y8vv+Cg4X/gIGE/9jY2f/Q0ND/2tnb/+De3v+SkZP/fH2A + /5OTlf94eHv/oaKk/9TV1f/q6uv/7e3t/+np6f/o6Oj/6Ojo/+bm5v/W1tf/r7Cx/3V2efZGR0msMDAx + KVJSVAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBgYIBjY2N + kfj4+f7X2Nn/urq8/qmqrP+lpqj+paao/6mqrP6wsbL/ubm7/8HBwv7IyMn/zs/P/tPU1f/X19j+2tvb + /+Hh4v7m5ub/5+fo/+jo6P7o6On/6enq/unp6v/p6en+6enp/+jo6P7n5+f/5ubn/+Xl5v7k5OX/4+Pk + /uPj4//h4eL+4ODg/97e3v7V1db/kpKU/nV2ef9/f4L/1dXW/uLi4v/b2tn+jIyO/5ycnv7m5uf/7u7u + /tvb3P/AwMH/q6ut/qOjpf+io6X+qqut/7q7vP7T09T/39/f/uDg4P+wsbL/aGhs7TQ1NmRWVlcFAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAenp6dJ2eof+Oj5L/o6Om + /76/wf/U1db/5OXm/+/v7//z8/P/9PT0//Pz8//y8vL/8PDx/+/v8P/u7u7/7e3t//Dw8P/x8fH/8PDw + /+/v7//u7u//7e3t/+3t7f/s7Oz/6+vr/+rq6v/p6er/6Ojp/+jo6P/n5+f/5ubm/+Xl5f/k5OX/4+Pk + /+Pj4//i4uL/29vb/7OztP+Jioz/goOG/9ra2//e3t//09PU//Hx8v/X19j/qamr/5manP+mpqf/sLCx + /66vsP+np6n/nJye/4+Pkf+Kio3/oaKk/czMzf7d3d3/zc3O/3l6ffo+PkB8V1dZBgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEhIJLm6u+/r7Oz/+/v7/vr6+v/4+Pj+9/f3 + //b29v719fX/9PT0//Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t//Dw8P7x8fH/8fHx/+/v7/7v7+//7u7u + /u3t7f/s7O3+6+vs/+vr6/7q6ur/6enq/+jo6P7o6Oj/5+fn/ubm5v/l5eb+5OTl/+Tk5P7j4+P/4uLi + /tzc3P/MzM3/i4yO/oyNj//Y2Nn+7u7v/7+/wP6YmJv/sLCx/r29vv++vr//vb2+/ry8vP+6urv+ubm6 + /7i4uf6sra3/j5CR1IyMjZm1trfv2trb/tLT0/95en37OTo7blJSVAIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAhoaGg/39/f78/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0 + //Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Dw8P/y8vL/8fHx//Dw8P/v7/D/7+/v/+7u7v/t7e3/7Ozt + /+vr7P/r6+v/6urr/+np6f/o6On/6Ojo/+fn5//m5uf/5eXm/+Xl5f/k5OT/4+Pk/93d3f/Ozs7/iIiK + /7u7vf/w8PD/uLi5/52dnv+8vL3/wMDB/7+/v/++vr7/vLy9/7u7vP+6urv/ubm5/7i4uf+3t7j/ubm5 + /ZOTk3ibm5t2sLCy4tjZ2f/Ly8z/ampu8jMzND0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACGhoYBjY2Nkv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw + /u/v8P/u7u7+7e3t//Dw8P7y8vP/8vLy//Hx8f7w8PH/7+/v/u/v7//u7u7+7e3t/+zs7f7r6+z/6+vr + /+rq6v7p6er/6Ojp/ujo6P/n5+f+5ubm/+bm5v7l5eX/5OTk/t3d3f+pqqv/kJCT/vLy8v/ExMX+nJ2e + /76+v/7AwMH/v7/A/r6+v/+9vb7/vLy8/ru7u/+6urr+ubm5/7i4uf63t7j/ubm6/pWVlYCoqKhjoKGh + erq6u+vY2Nn+r6+x/09QU8VEREUKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACPj48BjY2N + kv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t + //Dw8f/z8/P/8vLy//Hx8v/w8PH/8PDw/+/v7//u7u//7u7u/+3t7f/s7O3/7Ozs/+vr6//q6ur/6enq + /+np6f/o6On/5+fo/+fn5//m5ub/5eXm/9fX1/98fH//29vc/9/f3/+bm53/vLy9/8HBwf/AwMH/v7+/ + /729vv+8vL3/u7u8/7q6u/+5ubr/ubm5/7i4uP+3t7j/ubm6/5mZmYesrKxrra2tcKamp5fOzs/809PU + /3t8f/43NzhSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7 + //r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Hx8f/z8/T/8/Pz + //Ly8v/x8fL/8fHx//Dw8P/v7+//7+/v/+7u7v/t7e3/7e3t/+zs7P/r6+v/6urr/+rq6v/p6en/6Ojp + /+jo6P/n5+f/5ubn/76+v/+MjY//8/Pz/7W1t/+srK3/wcHB/8DAwP++vr//vb2+/729vf+8vLz/u7u8 + /7q6u/+6urr/ubm6/7m5uv+5ubn/u7u8/6KiopKzs7N4tLS0fLS0tIC2t7jU19fX/6ytrv9HSEuzSUpL + BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3 + //b29v719fX/9PT0//Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t//Hx8f709PT/9PT0//Ly8v7y8vL/8fHx + /vHx8f/w8PD+7+/w/+7u7/7u7u7/7e3u/+3t7f7s7Oz/6+vs/uvr6//q6ur+6enq/+np6f7o6Oj/5+fn + /pmanP+9vr//5eXl/qChov+9vb7+v7/A/76+v/6+vr7/vb2+/r29vf+8vL3/vLy8/ry8vP+7u7z+u7u8 + /7u7vP67u7v/vb2+/qmpqpy5ubmFu7u7iLy8vIq2tral1NTV/czMzf5iYmbtODk6HQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0 + //Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Hx8f/09PX/9PT0//Pz8//y8vP/8vLy//Hx8f/x8fH/8PDw + /+/v8P/v7+//7u7u/+7u7v/t7e3/7Ozs/+zs7P/r6+v/6urr/+rq6v/p6en/5eXl/4ODhv/d3d7/1NTU + /6amqP/AwMD/v7/A/7+/v/++vr//vr6+/76+vv++vr7/vb2+/76+vv++vr7/vb2+/76+vv++vr7/wMDB + /7GxsaW/v7+PwsLCksPDw5TFxcWXysrL8tDQ0f97fH/9Pj5ASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACQkJABjY2Nkv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw + /u/v8P/u7u7+7e3t//Ly8v719fX/9fX1//T09P7z8/P/8vLz/vLy8v/x8fH+8fHx//Dw8P7w8PD/7+/v + /+7u7v7u7u7/7e3t/u3t7f/s7Oz+6+vs/+vr6/7q6uv/4eHh/nx9gP/q6+v/wcHC/rW1tv/BwcH+wcHB + /8DAwP7AwMH/wMDA/sDAwP/AwMH/wMDB/sHBwf/BwcH+wcHB/8HBwv7BwcL/xMTE/rm5ua3GxsaZyMjI + m8rKyp3MzMyeyMjJ4NLT0/6Oj5H/NTU3bgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2N + kv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t + //Ly8v/19fb/9fX1//T09f/09PT/8/Pz//Pz8//y8vL/8vLy//Hx8f/w8PH/8PDw/+/v7//v7+//7u7u + /+7u7v/t7e3/7Ozt/+zs7P/r6+z/3t7e/3x8gP/u7u7/urq7/76+vv/Dw8P/w8PD/8PDw//Dw8P/w8PD + /8PDxP/ExMT/xMTE/8TExf/ExMX/xcXF/8XFxv/Gxsb/yMjJ/8DAwLPNzc2iz8/Po9DQ0KXT09OnyMjJ + 19TU1P+Wl5n/NDU2hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f78/Pz/+/v7 + /vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8fHx/vDw8P/u7u7+7e3t//Hx8v719fX/9fX1 + //T09P7z8/P/8vLy/vLy8v/x8fH+8fHx//Dw8P7v7/D/7+/v/+/v7/7u7u7/7e3u/u3t7f/s7O3+7Ozs + /+zs7P7r6+v/3t7f/nx9gP/s7O3/u7u9/sLCwv/Gxsb+xsbG/8bGxv7Gxsf/x8fH/sfHx//Hx8j/yMjI + /sjIyf/IyMn+ycnJ/8rKyv7Ly8v/zc3N/sjIyLnU1NSp1tbWq9fX16zZ2dmuy8vM2dPT1P6Wlpj/NDQ2 + gwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACPj48BjY2Nkv39/f/8/Pz/+/v7//r6+v/4+Pj/8/Pz + /+vs7P/j4+T/3N3e/9jZ2f/U1dX/0NHR/87Oz//Nzc7/y8zM/8vLzP/Ly8z/y8vM/8rLzP/Ky8v/ysvL + /8rLy//Ky8v/ysvL/8rLy//Ky8v/ysvL/8rLy//Ky8v/ysvL/8rLy//Ky8v/ysvL/8rLy//Ky8v/w8TE + /3d4ev/m5uf/xMTF/7u8vP/Hx8f/yMjI/8jIyf/Jycr/ysrK/8vLy//MzMz/zMzN/83Nzv/Ozs7/zs7P + /8/P0P/Pz9D/0tLS/8/Pz7/b29uw3Nzcst3d3bLf39+z0NHR5NHR0f+MjY//MjI0cAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACFhYYBjY2Nkv39/f729vb/3Nzd/sjIyf+5urz+srO1/6+wsv6vsLP/sLCz + /6+wsv6vr7L/r7Cy/rKytf+0tbf+t7i6/729wP7BwsT/w8TG/8XGyP7HyMn/ycrL/srLzf/LzM3+y8zN + /8vMzf7MzM3/zMzN/8vMzf7Ky8z/ycrL/sjJyv/HyMn+xsbI/8TExv7Cw8T/vr7A/nl5fP/W19f/1dXW + /rCwsv/Dw8T+w8TF/8TExf7Fxsf/x8fI/sjIyf/Jycr/ysrL/svMzP/Nzc7+z8/Q/9LS0/7U1NX/19fX + /tXV1cTg4OC24uLit+Pj47jl5eW409TV88vLzP56e37+QUFCTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB8fHwBh4eHisTFx/+Zmpz/lJaY/5aXmv+fn6L/rK2v/7u8vv/Iycr/09PU/93d3v/k5OX/6enq + /+zs7f/t7e3/7e3t//Dw8P/x8fH/8PDw/+/v7//u7u7/7e3t/+zs7P/r6+z/6+vr/+rq6v/p6en/6Ojo + /+fn5//m5uf/5eXm/+Xl5f/k5OT/4+Pj/+Li4v/h4eL/4ODg/5iYmv+0tbb/4uLi/7O0tf/T09P/0tLS + /9LS0v/R0dL/0NDR/9DQ0P/Oz8//zc3O/8zMzf/Ly8z/y8vM/8zMzf/Pz9D/2NjY/tzc3Mjm5ua85+fn + vujo6L7d3d3H2dna/cTExf9hYWXvPz9AHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVFVV + Mn+BhPKlpqn/zM3O/+fn6P/09PX/+Pj4//f39//19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t + //Dw8P/x8fH/8PDw/+/v8P/u7u//7u7u/+3t7f/s7Oz/6+vr/+rq6//p6er/6enp/+jo6P/n5+f/5ubm + /+bm5v/l5eX/5OTk/+Pj4//i4uL/4eHi/7q6u/+Gh4n/6enp/8DBwv/MzM3/2NjY/9jY2P/Z2dn/2dna + /9ra2v/b29v/29vb/9zc3P/b29z/2dna/9bW1//Q0dH/09TU8ufn58Pr6+vC7Ozsw+3t7cTV1dbi1NXV + /6amqP9JSUy5RkdIBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXV1eQufn5+n8/Pz/+/v7 + /vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t//Dw8P7x8fL/8fHx + //Dw8P7v7/D/7u7u/u3t7v/s7O3+7Ozs/+vr6/7q6uv/6urq/+np6f7o6Oj/5+fn/ufn5//l5eb+5OTl + /+Tk5P7j4+T/4uLj/tXV1f96en3/y8zN/t3d3f+5ubr+3d3d/93d3f7e3t7/3t7e/t/f3//g4OD/4ODg + /uDg4f/h4eH+4uLi/+Li4/7j4+P/4+Pj8uvr68rv7+/I8PDwyeTk5M7Z2tr8x8fI/3Z3ev42NjhXAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgIEBj4+PkP39/f/8/Pz/+/v7//r6+v/5+fn/9/f4 + //b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Dw8f/y8vL/8fHy//Dw8f/w8PD/7+/v + /+7u7v/t7e7/7e3t/+zs7P/r6+z/6urr/+rq6v/p6en/6Ojo/+fn6P/n5+f/5ubm/+Xl5f/k5OX/5OTk + /93d3f+pqar/hoeJ/+Pj4//Ozs//xcXG/+Li4v/i4uP/4+Pj/+Pj4//k5OT/5OTl/+Xl5f/m5ub/5ubm + /+bm5//n5+f/6enp/+vr69bz8/PN7+/vztfX1/LQ0NH/paWn/1FRVcs8PD0MAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACLi4sBjY2Nkv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0 + //Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t//Dw8f7y8vP/8vLy//Hx8f7w8PH/7+/w/u/v7//u7u7+7e3u + /+zs7f7s7Oz/6+vs/+rq6v7q6ur/6enp/ujo6P/n5+j+5+fn/+bm5v7l5eb/5eXl/t7e3v/Ozs//iImL + /qmpq//h4eH+ysvL/8vLzP7n5+f/5+fn/ujo6P/o6On/6Ojp/unp6f/q6ur+6urq/+vr6/7r6+v/7Ozs + /u/v79vw8PDS1tbX7tbW1v+7vL3+Zmdq9DM0NUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx + /+/v8P/u7u7/7e3t//Hx8f/z8/P/8vLz//Hx8v/x8fH/8PDw//Dw8P/v7+//7u7u/+3t7v/t7e3/7Ozs + /+vr6//r6+v/6urq/+np6f/o6On/6Ojo/+fn5//m5uf/5ubm/9/f3//T09T/z8/Q/3p7ff+3t7n/39/f + /8/Q0P/Gx8j/5eXl/+zs7P/s7Oz/7e3t/+3t7f/t7e7/7e3u/+7u7v/u7u//7+/w/+Dg4OPY2Nj11dXW + /8DAwf9zdHf9Nzc5eVFRUwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2N + kv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t + //Hx8f7z8/T/8/Pz//Ly8v7x8fL/8fHx/vDw8P/v7/D+7+/v/+7u7v7t7e7/7e3t/+zs7P7r6+z/6+vr + /urq6v/q6ur+6enp/+jo6P7n5+j/5+fn/uDg4P/T09T/4+Pj/sLCw/91dnn+rKyu/9zc3f7Y2Nn/ycnK + /s/P0P/g4OH/7u7u/vDw8f/x8fH+8PDw/+vr6/7c3N3/1tbX/tra2v7Pz9D/urq7/nJzdvw8PD6LSktM + BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7 + //r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Hx8f/09PT/9PT0 + //Pz8//y8vP/8vLy//Hx8f/w8PD/8PDw/+/v7//u7u//7u7u/+3t7f/s7O3/7Ozs/+vr6//q6uv/6urq + /+np6f/p6en/6Ojo/+Hh4f/T09T/5eXm/9ra2v+8vb3/fX2A/4qLjf/Ly8z/2dnZ/9nZ2f/T09T/zs7P + /9LT0//V1dX/1NTU/9XV1v/a2tv/0tLS/8fHyP+foKL/Y2Ro8Tg4OXJKSkwHAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3 + //b29v719fX/9PT0//Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t//Hx8v709PX/9PT0//Pz8/7z8/P/8vLy + /vHx8v/x8fH+8PDw//Dw8P7v7+//7+/v/+7u7v7t7e3/7Ozt/uzs7P/r6+z+6+vr/+rq6v7q6ur/6enp + /uHh4v/T09T/5+fo/tvb3P/Pz8/+xcXG/5mZm/5xcXX/jo6R/rq6u//R0dH/1NTV/tLS0//Q0NH+0NDR + /83Nzf6+vr//nJye/nBxdPxKS067Ly8wN1ZWWAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0 + //Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Ly8v/19fX/9fX1//T09P/z8/T/8/Pz//Ly8v/x8fL/8fHx + //Dw8f/w8PD/7+/w/+/v7//u7u7/7u7u/+3t7f/s7O3/7Ozs/+vr6//r6+v/6urq/+Li4//T09T/6enp + /93d3f/Pz9D/zs7P/8vLzP++vr//m5ud/3h5e/9ub3L/eHl8/4GChf+DhIf/e3x//29wc/9sbXD/goKF + /zIzNF9UVVYHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACQkJABjY2Nkv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw + /u/v8P/u7u7+7e3t//Ly8v719fb/9fX1//T09P709PT/8/Pz/vPz8//y8vL+8fHy//Hx8f7x8fH/8PDw + //Dw8P7v7+//7u7v/u7u7v/t7e7+7e3t/+zs7P7s7Oz/6+vr/uTk5P/T09T/6+vr/t7e3//Pz8/+zs7O + /8zMzf7Ly8z/ysrK/sXFxv+5ubr/rK2u/qKipP+hoaP+oqKk/66ur/64uLn/wsLD/lFRUjQAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2N + kv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/8/P0//Hx8f/u7u7/6+vr/+jo6f/m5ub/5OTk + /+bm5v/o6Oj/5+fo/+fn5//m5uf/5ubm/+Xl5v/l5eX/5eXl/+Tk5P/k5OT/5OTk/+Pj4//j4+P/4uLj + /+Li4v/i4uL/4uLi/+Li4v/i4uL/4eHi/93d3f/T09T/4+Pj/9vb2//Q0ND/zs7P/83Nzv/MzM3/y8vL + /8nJyv/IyMn/x8fI/8bGx//ExMX/w8PE/8LCw//BwcL/xMTF/1hYWDQAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMjY0BjY2Nkv39/f/8/Pz/+/v7 + //X19v/n6Oj/29vc/9HS0//Ky8v/xcbH/8LDxP/AwsL/wMHB/7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB + /7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB + /7/Awf+/wMH/v8DB/7/Awf+/wMH/v8DB/7/Awf+/wMH/v8HB/7/Bwf+/wcH/wMDC/8DAwv/AwcL/wMHC + /8HCw//Dw8T/w8PE/8LCw//BwcL/xMTF/11dXjQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/f38BjY2Nkfb29/7T09T/tra4/qeoqv+lpqj+paao + /6SlqP6mqKr/rKyv/7Oztv65urz/wMDC/sbGyP/Ky8z+zs7Q/9TV1v7Z2dr/29zd/93d3v7e3t//4ODh + /uHh4f/h4eL+4eHh/+Dg4f7g4OH/4ODh/9/f4P7e3t7/3Nzd/tvb3P/a2tv+2NjZ/9bW1/7U1NX/0tLT + /szNzv/Fxcf/xsbH/sDAwv+7vL3+uLi6/7S0tv6wsLP/rKyv/qipq/+lpqn/paao/qWmqf+lpqn+p6iq + /62usP63t7n/xMTF/lhYWTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAdXV1cJqcnv+LjI//k5SX/6qqrf/BwcP/09PU/+Li4//r7Oz/8PHx + //Ly8v/x8fL/8fHx//Dw8P/u7u7/7e3t//Dw8P/w8PH/8PDw/+/v7//u7u//7e3t/+zs7f/r6+z/6+vr + /+rq6v/p6er/6Ojp/+fn6P/n5+f/5ubm/+Xl5f/k5OT/4+Pk/+Li4//i4uL/4eHh/9vb2//T09T/2tra + /9PT1P/Pz9D/zs7P/83Nzf/Ly8z/ycnK/8fHyP/CwsP/urq8/7Gxs/+lpqj/l5ib/42Okf+LjI//n6Ci + +FFRUSMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAOzs8GJydn97Y2dn/9fb2/vv7+//4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw + /u/v8P/u7u7+7e3t//Dw8P7x8fH/8fHx/+/v7/7u7u//7u7u/u3t7f/s7Oz+6+vs/+rq6/7q6ur/6enq + /+jo6P7n5+j/5ubn/ubm5v/l5eX+5OTk/+Pj4/7j4+P/4uLi/tzc3P/T09T/29vc/tTU1f/Pz8/+zs7O + /8zMzf7Ly8z/ysrL/snJyv/IyMn/x8fI/sbGx//ExMX+w8PE/7y8vf6mpqj/YWFjo2NjZAUAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfX19 + dPz8/P38/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t + //Dw8P/x8fL/8fHx//Dw8P/v7/D/7u7v/+7u7v/t7e3/7Ozs/+vr7P/q6uv/6urq/+np6f/o6On/5+fo + /+fn5//m5ub/5eXm/+Tk5P/k5OT/4+Pj/93d3f/T09T/3d3e/9XV1v/Pz9D/zs7P/8zMzf/Ly8z/ysrL + /8nJyv/IyMn/x8fI/8bGx//ExMX/w8PE/8LCw//BwcL/v7/A9VJSUyUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBgYIBjY2Nkv39/f78/Pz/+/v7 + /vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t//Dw8P7y8vL/8vLy + //Dw8P7w8PD/7+/v/u7u7//t7e7+7e3t/+zs7P7r6+z/6+vr/+rq6v7p6en/6Ojp/ujo6P/n5+f+5ubm + /+Xl5v7l5eX/5OTk/t3d3v/T09T/39/f/tbW1v/Pz8/+zs7O/8zMzf7Ly8z/ysrL/snJyv/IyMn/x8fI + /sbGx//ExMX+w8PE/8LCw/7BwcL/xMTF/lpaWzQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACPj48BjY2Nkv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4 + //b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Dw8f/z8/P/8vLy//Hx8f/w8PH/8PDw + /+/v7//u7u7/7u7u/+3t7f/s7O3/6+vs/+vr6//q6ur/6enp/+np6f/o6Oj/5+fn/+bm5v/m5ub/5eXl + /97e3//T09T/4ODh/9fX2P/Pz9D/zs7P/8zMzf/Ly8z/ysrL/8nJyv/IyMn/x8fI/8bGx//ExMX/w8PE + /8LCw//BwcL/xMTF/15eXzQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0 + //Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t//Dw8f7z8/P/8/Pz//Ly8v7x8fH/8PDw/vDw8P/v7+/+7u7v + /+3t7v7t7e3/7Ozt/+vr7P7r6+v/6urq/urq6v/p6en+6Ojo/+fn5/7n5+f/5ubm/t/f3//T09T/4uLj + /tjY2f/Pz8/+zs7O/8zMzf7Ly8z/ysrL/snJyv/IyMn/x8fI/sbGx//ExMX+w8PE/8LCw/7BwcL/xMTF + /l9fYDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx + /+/v8P/u7u7/7e3t//Hx8f/09PT/8/Pz//Ly8//y8vL/8fHx//Dw8f/w8PD/7+/v/+7u7//u7u7/7e3u + /+zs7P/s7Oz/6+vr/+vr6//q6ur/6enq/+np6f/o6Oj/5+fo/+Dg4f/T09T/5OTl/9ra2v/Pz9D/zs7P + /8zMzf/Ly8z/ysrL/8nJyv/IyMn/x8fI/8bGx//ExMX/w8PE/8LCw//BwcL/xMTF/19fYDQAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2N + kv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4//b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t + //Hx8f/09PT/9PT0//Pz8//y8vP/8vLy//Hx8f/w8PH/8PDw/+/v7//v7+//7u7u/+3t7f/t7e3/7Ozs + /+zs7P/r6+v/6urq/+rq6v/p6en/6Ojp/+Hh4f/T09T/5ubn/9vb2//Pz9D/zs7P/8zMzf/Ly8z/ysrL + /8nJyv/IyMn/x8fI/8bGx//ExMX/w8PE/8LCw//BwcL/xMTF/19fYDQAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f78/Pz/+/v7 + /vr6+v/4+Pj+9/f3//b29v719fX/9PT0//Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3t//Hx8v719fX/9PT0 + //Pz8/7z8/P/8vLy/vLy8v/x8fH+8PDx//Dw8P7v7/D/7+/v/+7u7v7u7u7/7e3t/u3t7f/s7Oz+6+vr + /+vr6/7q6ur/6enq/uLi4v/T09T/6Ojo/tzc3f/Pz8/+zs7O/8zMzf7Ly8z/ysrL/snJyv/IyMn/x8fI + /sbGx//ExMX+w8PE/8LCw/7BwcL/xMTF/l9fYDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7//r6+v/5+fn/9/f4 + //b29v/19fX/9PT0//Pz8//x8fL/8PDx/+/v8P/u7u7/7e3t//Ly8v/19fb/9fX1//T09P/09PT/8/Pz + //Pz8//y8vL/8fHy//Hx8f/w8PH/8PDw/+/v7//v7+//7u7u/+3t7v/t7e3/7Ozt/+zs7P/r6+v/6+vr + /+Pj4//T09T/6urq/93d3v/Pz9D/zs7P/8zMzf/Ly8z/ysrL/8nJyv/IyMn/x8fI/8bGx//ExMX/w8PE + /8LCw//BwcL/xMTF/19fYDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACQkJABjY2Nkv39/f78/Pz/+/v7/vr6+v/4+Pj+9/f3//b29v719fX/9PT0 + //Pz8/7x8fL/8PDw/u/v8P/u7u7+7e3u//Ly8/729vb/9vb2//X19f709PX/9PT0/vPz9P/z8/P+8vLz + //Ly8v7x8fL/8fHx//Dw8P7w8PD/7+/v/u/v7//u7u7+7u7u/+3t7f7t7e3/7Ozs/uTk5f/T09T/7Ozs + /t/f4P/Pz8/+zs7O/8zMzf7Ly8z/ysrL/snJyv/IyMn/x8fI/sbGx//ExMX+w8PE/8LCw/7BwcL/xMTF + /l9fYDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACQkJABjY2Nkv39/f/8/Pz/+/v7//r6+v/5+fn/9/f3//Ly8//s7O3/5ebm/9/f4P/a2tv/1NTV + /9HR0v/Nzc7/ysrL/8nKy//Jysv/yMjK/8fHyP/Fxsf/xcbH/8XFx//Fxcf/xcXH/8TFxv/Excb/xMXG + /8TFxv/Excb/xMTG/8TExv/ExMb/xMTG/8TExv/Fxcb/xcbH/8XGx//DxMX/ycnK/8fHyf/Fxcb/xsbH + /8bGx//Hx8j/x8fJ/8jIyf/IyMn/x8fI/8bGx//ExMX/w8PE/8LCw//BwcL/xMTF/19fYDQAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMjIwBjY2N + kv39/f78/Pz/8PDw/uHh4v/U1db+y8vM/8XGx/7Dw8X/w8PE/8PDxf7DxMX/w8TF/sPExf/DxMX+w8TF + /8PExf7DxMX/w8TF/8PExf7DxMX/w8TF/sPExf/DxMX+w8TF/8PExf7DxMX/w8TF/8PExf7DxMX/w8TF + /sPExf/DxMX+w8TF/8PExf7DxMX/w8TF/sPExf/DxMX/w8TF/sPExf/DxMX+w8TF/8PExf7DxMX/w8PF + /sPDxf/DxMX/xMXG/sXFxv/Fxsf+xcXG/8PDxP7BwcL/xMTF/l9fYDQAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEhIQBjIyMjuvs7P/R0dL/ycnK + /8nJyv/Jycr/ycnL/8nJyv/Jycv/ycnL/8nJyv/Jycv/ycnK/8nJy//Jycr/ycnL/8nJyv/Jycv/ycnL + /8nJyv/Jycv/ycnK/8nJy//Jycr/ycnL/8nJyv/Jycv/ycnL/8nJyv/Jycv/ycnK/8nJy//Jycr/ycnL + /8nJyv/Jycv/ycnK/8nJy//Jycv/ycnK/8nJy//Jycr/ycnL/8nJyv/Jycv/ycnK/8nJy//Jycv/ycnK + /8nJy//Jycr/ycnK/8nJy//IyMr/x8fI/1xcXTMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXFxcQ9DQ0frQ0ND/0NDQ/tDQ0P/Q0ND+0NDQ + /9DQ0P7Q0ND/0NDQ/9DQ0P7Q0ND/0NDQ/tDQ0P/Q0ND+0NDQ/9DQ0P7Q0ND/0NDQ/9DQ0P7Q0ND/0NDQ + /tDQ0P/Q0ND+0NDQ/9DQ0P7Q0ND/0NDQ/9DQ0P7Q0ND/0NDQ/tDQ0P/Q0ND+0NDQ/9DQ0P7Q0ND/0NDQ + /tDQ0P/Q0ND/0NDQ/tDQ0P/Q0ND+0NDQ/9DQ0P7Q0ND/0NDQ/tDQ0P/Q0ND/0NDQ/tDQ0P/Q0ND+0NDQ + /9DQ0P7Q0ND/uLi53lBQUBEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAfHx8A1lZWVOnp6jH0tLT+NbW1//V1db/1dXW/9XV1v/V1db/1dXW + /9XV1v/V1db/1dXW/9XV1v/V1db/1dXW/9XV1v/V1db/1dXW/9XV1v/V1db/1dXW/9XV1v/V1db/1dXW + /9XV1v/V1db/1dXW/9XV1v/V1db/1dXW/9XV1v/V1db/1dXW/9XV1v/V1db/1dXW/9XV1v/V1db/1dXW + /9XV1v/V1db/1dXW/9XV1v/V1db/1dXW/9XV1v/V1db/1dXW/9XV1v/V1db/1tfX/szMzfCQkJGuS0tL + LwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABsbGwJXl5eMGBgYGyKiouisbKyzs7Pz+za2tv63Nzc/dvb3P7b29z/29vc + /9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb + /9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/9vb2//b29v/29vc + /9vb3P/b29z/29vc/tzc3PzY2Nn5yMjI5Kanp8OAgICUXV1dWl9fXyJ1dXUFAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACJiYkCdHR1BlBQURBkZGQmUlJSQmZmZlp2dndwcHBwhoWFhZiLi4ulmJiY + r6enp7qqqqq/q6urw62trcetra3Kra2tyq2trcqtra3Kra2tyq2trcqtra3Kra2tyq2trcqtra3Kra2t + yq2trcqtra3Kra2tyq2trcqtra3JrKysxqurq8Kpqam+paWluJKSkqyKioqhgYGBk2pqaoB4eHhpYmJi + VFFRUTlhYWEfV1dYDHl5eQSUlJUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj4+PAZKSkgGWlpYCl5eYA4qKigRkZGUFY2Nj + BmFhYQZhYWEHYWFhB2FhYQdhYWEHYWFhB2FhYQdhYWEHYWFhB2FhYQdhYWEHYWFhB2FhYQdhYWEHYWFh + B2FhYQdhYWEHYWFhBmJiYgZkZGQFiYmJBJaWlgKVlZUCkpKSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AP////wf/////wAAAP////gP/////wAAAP////AH/////wAAAP////AD/////wAAAP////AB/////wAA + AP////AA/////wAAAP//gAAAAAH//wAAAP/gAAAAAAAH/wAAAP+AAAAAAAAB/wAAAP8AAAAAAAAA/wAA + AP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAA + AP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAAfwAAAP4AAAAAAAAAHwAA + AP4AAAAAAAAADwAAAP8AAAAAAAAABwAAAP8AAAAAAAAAAwAAAP8AAAAAAAAAAwAAAP4AAAAAAAAAAQAA + AP4AAAAAAAAAAQAAAP4AAAAAAAAAAAAAAP4AAAAAAAAAAAAAAP4AAAAAAAAAAAAAAP4AAAAAAAAAAAAA + AP4AAAAAAAAAAAAAAP4AAAAAAAAAAAAAAP4AAAAAAAAAAAAAAP4AAAAAAAAAAAAAAP4AAAAAAAAAAAAA + AP8AAAAAAAAAAAAAAP8AAAAAAAAAAQAAAP4AAAAAAAAAAQAAAP4AAAAAAAAAAwAAAP4AAAAAAAAAAwAA + AP4AAAAAAAAABwAAAP4AAAAAAAAADwAAAP4AAAAAAAAAHwAAAP4AAAAAAAAAfwAAAP4AAAAAAAAA/wAA + AP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP8AAAAAAAAA/wAAAP8AAAAAAAAA/wAA + AP8AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAA + AP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAA + AP4AAAAAAAAA/wAAAP4AAAAAAAAA/wAAAP8AAAAAAAAA/wAAAP8AAAAAAAAB/wAAAP/AAAAAAAAD/wAA + AP/4AAAAAAAf/wAAAP//8AAAAB///wAAAP///////////wAAAP///////////wAAAP///////////wAA + AP///////////wAAAP///////////wAAACgAAABAAAAAgAAAAAEAIAAAAAAAAEIAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMjMvPD0/ + oTQ1N3ZFRkcEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAvLzBHZ2hr8JGRkv+Cg4X+PT4/iEVFRwQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAA1NTYiZ2hs693d3v+wsLD/mJiY/3+Agv49PT+FRERGBAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPj5Ab7Gxs//g4OD/3t7f/6+vr/+YmJj/fX6B + /jw8PoFCQ0QDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQSZhYWTlycnK + /93d3v/e3t//r6+v/5iYmP98fH/+Ojo8fUpKTAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoqKiAXl5eQJ8fHwDfX19BWlpaQhXV1cNXFxc + FFVVVhlYWFkeNzc4VWhpbPLJycv/3d3e/97e3/+vr6//l5eX/3p7fv08PD6FU1NTMmtrayxqamojYWFh + HVxcXRhXV1cSTk5OC3NzcwhwcHAFbm5uA3JycgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAlpaWAYCAgAVfX18TbGxsMnl5eVaAgIB0gYGBkJubnKetra27u7u8 + zMvLzNrd3d3n6Ojo8u/v7/jw8PD88PDw/+/v7//Ly8z/c3R4/8rKy//d3d7/3t7f/6+vr/+Xl5f/enp9 + /6OjpP/i4uP/5OTl/+Pj5P7i4uL82dnZ98rKyvDIyMnlr6+v16Kio8qRkZG2goKDomhoaIlwcHBtXV1e + TlxcXClSUlMNZmZmBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnZ2cRcnJyW5mZmaHPz8/V8/Pz9/j4+f/29vb/9PT0 + //Pz8//x8fL/8PDw/+/v7//t7e7/7u7u//Hx8f/w8PD/7+/w/+7u7v/t7e7/7Ozs/8nJyv90dHj/y8vM + /93d3v/e3t//rq6v/5aWl/94eHz/oqOk/+Hh4f/i4uP/4eHi/9ra2//V1db/2trb/9DQ0P/Ozs//zc3O + /8vLzP/Kysv/ycnK/8nJyf/Jycr+v7/A8Jqam8hsbGyQXFxcQ2VlZgcAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnZ2c84+Pj5fz8/P/7+/v/+fn5 + //j4+P/29vf/9fX1//T09P/z8/P/8fHy//Dw8P/v7+//7e3u/+7u7//y8vL/8fHx//Dw8P/v7+//7u7u + /+3t7f/r6+z/yMnJ/3R0eP/Ly83/3d3e/97e3/+urq//lpaW/3d3ev+lpab/4eHh/+Li4//b29v/1dXW + /9zc3f/Q0NH/zs7P/83Nzv/Ly8z/ysrL/8nJyv/IyMn/xsbH/8XFxv/ExMX/w8PE/8LCw/+YmJnFXV1d + EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfX19 + gv39/f/8/Pz/+/v7//n5+f/4+Pj/9vb3//X19f/09PT/8/Pz//Hx8v/w8PD/7+/v/+3t7v/v7+//8vLy + //Ly8v/w8PH/8PDw/+/v7//u7u7/7e3t/+zs7P/IyMn/dHV4/8vMzf/d3d7/3t7f/6+vr/+VlZX/dXZ5 + /6eoqf/i4uL/3Nzc/9bW1v/e3t//0NDR/87Oz//Nzc7/y8vM/8rKy//Jycr/yMjJ/8bGx//Fxcb/xMTF + /8PDxP/BwcL/xMTF/15eXy4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAH19fYP9/f3//Pz8//v7+//5+fn/+Pj4//b29//19fX/9PT0//Pz8//x8fL/8PDw + /+/v7//t7e7/7u7v//Pz8//y8vL/8fHx//Dw8P/v7/D/7u7v/+7u7v/t7e3/7Ozs/8bHx/90dXj/zMzO + /93d3v/e3t//r6+v/5SUlf90dXj/qqqs/9vb2//W1tf/4ODh/9DQ0f/Ozs//zc3O/8vLzP/Kysv/ycnK + /8jIyf/Gxsf/xcXG/8TExf/Dw8T/wcHC/8TExf9kZGUuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fX2D/f39//z8/P/7+/v/+fn5//j4+P/29vf/9fX1 + //T09P/z8/P/8fHy//Dw8P/v7+//7e3u/+/v7//z8/P/8/Pz//Ly8v/x8fH/8PDw/+/v8P/u7u//7u7u + /+3t7f/s7Oz/xcXG/3R1eP/Nzc7/3d3e/97e3/+urq//lJSV/3N0d/+mpqf/1NTV/+Pj4//R0dH/zs7P + /83Nzv/Ly8z/ysrL/8nJyv/IyMn/xsbH/8XFxv/ExMX/w8PE/8HBwv/ExMX/ZWVmLgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfX19g/39/f/8/Pz/+/v7 + //n5+f/4+Pj/9vb3//X19f/09PT/8/Pz//Hx8v/w8PD/7+/v/+3t7v/v7+//9PT0//Pz8//y8vP/8vLy + //Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u/+zs7P/ExMX/dHV4/83Oz//d3d7/3t7f/66ur/+Uk5T/cnN2 + /6anqP/j4+T/0dHS/87Oz//Nzc7/y8vM/8rKy//Jycr/yMjJ/8bGx//Fxcb/xMTF/8PDxP/BwcL/xMTF + /2VlZi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AH19fYP9/f3//Pz8//v7+//5+fn/+Pj4//b29//19fX/9PT0//Pz8//x8fL/8PDw/+/v7//t7e7/7+/v + //X19f/09PT/8/Pz//Ly8v/y8vL/8fHx//Dw8P/w8PD/7+/v/+7u7//t7e7/7Ozs/8PDxP90dXj/zs7P + /93d3v/e3t//r6+v/5OTlP9xcnb/sLCy/9DQ0f/Ozs//zc3O/8vLzP/Kysv/ycnK/8jIyf/Gxsf/xcXG + /8TExf/Dw8T/wcHC/8TExf9lZWYuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAB9fX2D/f39//z8/P/7+/v/+fn5//j4+P/29vf/9fX1//T09P/z8/P/8fHy + //Dw8P/v7+//7e3u/+/v7//19fX/9fX1//T09P/z8/P/8vLz//Ly8v/x8fH/8PDx//Dw8P/v7+//7u7v + /+7u7v/s7O3/wcLC/3R1eP/Oz9D/3d3e/97e3/+vr6//kpOT/3Fydf+jpKX/zc3O/83Nzv/Ly8z/ysrL + /8nJyv/IyMn/xsbH/8XFxv/ExMX/w8PE/8HBwv/ExMX/Y2NjLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfX19g/39/f/8/Pz/+/v7//n5+f/4+Pj/9vb3 + //X19f/09PT/8/Pz//Hx8v/w8PD/7+/v/+3t7v/v7+//9vb2//X19f/09PX/9PT0//Pz8//y8vP/8vLy + //Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7f/BwcL/dHV4/8/P0P/d3d7/3t7f/66ur/+SkpP/a2xv + /8XFxv/Nzc7/y8vM/8rKy//Gxsf/vLy8/66ur/+qqqv/q6us/7Cwsf+6urv/w8PE/1hYWS4AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH19fYP9/f3//Pz8 + //v7+//5+fn/+Pj4//b29//29vb/9PT0//Hx8f/s7O3/6enp/+bm5v/k5OT/5OTk/+fn6P/n5+f/5ubm + /+Xl5f/k5OX/5OTl/+Tk5P/j4+T/4+Pj/+Pj4//i4uP/4uLi/+Li4v/h4eL/4ODg/7S0tf9zdHf/z9DR + /93d3v/V1db/x8XF/2xtcP+jo6X/zMzN/7+/wP+Vlpf/ent9/4OEhv+Wl5n/np6g/5manP+Kio3/dnd6 + /4CBg/8+Pj9cUFFRBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB9fX2D/f39//z8/P/19fX/4+Pk/9bW1//MzM3/xMTF/76/wP+8vb7/vLy+/7u8vf+7vL3/vLy+ + /72+wP/AwML/wsLE/8PExf/Fxsf/x8fJ/8jJyv/Jycv/ycnL/8rKy//Kysv/ycnL/8nJyv/IyMr/x8fJ + /8bGyP/ExMX/oKCi/3Nzd//Pz9D/zc3N/9zc3f/g3N3/a2xv/4aGiP99foH/uLm6/+fn5//t7e3/5eXl + /+Hh4f/g4OH/5OTl/+Xl5f/Gx8j/jIyP/UxNT7oxMjMtVlZYAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAfHx8geLi4/+ys7b/np+i/52eof+np6r/tre5/8PDxf/Nzs//1tbX + /9zd3f/i4+P/5ufn/+np6f/t7e3/8fHx//Dw8f/v7/D/7u7v/+3t7v/s7Oz/6+vr/+rq6v/p6er/6Ojp + /+fn5//m5uf/5eXm/+Tk5f/k5OT/4+Pj/+Hh4f+1tbb/bG1w/3Nzd//Y2Nn/4+Pj/9LPz/+qqqz/7+/v + /+Li4v+8vb7/paWn/5ycnv+TlJb/lZWY/56fof+zs7X/1NXV/+Dg4P/DxMX/b3Bz8Tk5O1pbXF0CAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGVlZj+LjI/6tba4/9fY2f/w8PD/+fn5 + //f39//19fX/9PT0//Pz8//x8fL/8PDw/+/v7//t7e7/7u7v//Hx8f/w8PH/7+/w/+7u7v/t7e7/7Ozt + /+vr7P/r6+v/6urq/+np6f/o6Oj/5+fn/+bm5v/l5eb/5OTk/+Pj4//i4uP/4eHh/9TU1f+ioqT/d3d6 + /9nZ2v/X2Nj/7e3u/7y8vv+cnJ3/q6us/7q6u/+8vL3/u7u8/7S0tf+oqKn/lpeY/4WGiO+urq/o2dnZ + /9XV1v99foH6PDw+Y1laWwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABra2tM9fX1 + 9/z8/P/7+/v/+fn5//j4+P/29vf/9fX1//T09P/z8/P/8fHy//Dw8P/v7+//7e3u/+7u7//y8vL/8fHx + //Dw8P/v7+//7u7u/+3t7v/s7Oz/7Ozs/+rq6//q6ur/6enp/+jo6P/n5+f/5ubn/+Xl5f/k5OX/4+Pk + /+Pj4//b29v/0NDR/319gP/Fxcb/6urr/6qrrP+lpqf/vr6//7+/wP++vr7/vLy9/7u7vP+6urr/uLi5 + /7i4uP+vr6/qkZGRcZ+gocHT09T/1NTU/3R1ePg0NDVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAfX19gv39/f/8/Pz/+/v7//n5+f/4+Pj/9vb3//X19f/09PT/8/Pz//Hx8v/w8PD/7+/v + /+3t7v/v7+//8vLy//Ly8v/w8PH/8PDw/+/v7//u7u7/7e3t/+zs7f/r6+z/6+vr/+rq6v/p6en/6Ojo + /+fn6P/m5uf/5eXm/+Xl5f/k5OT/3Nzc/6enqf+goKL/8PDw/62tr/+srK3/wMDB/8DAwP++vr//vb2+ + /7u7vP+6urv/ubm6/7m5uf+3t7j/ubm6/5aWlnykpKRkpKSlvdbW1//ExMb/WFhc10FBQg0AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH19fYP9/f3//Pz8//v7+//5+fn/+Pj4//b29//19fX/9PT0 + //Pz8//x8fL/8PDw/+/v7//t7e7/7u7v//Pz8//y8vL/8fHy//Dw8P/v7/D/7+/v/+7u7v/t7e3/7Ozt + /+zs7P/r6+v/6urq/+np6f/o6On/5+fo/+fn5//m5ub/5eXl/9bW1v99fYD/6+vr/8XFx/+kpKX/wcHC + /8DAwf+/v7//vr6+/7y8vf+7u7v/urq6/7m5uv+4uLn/t7e4/7m5uv+ampqCq6uraqqpqXG2trfd19fX + /5SUl/85OjttAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fX2D/f39//z8/P/7+/v/+fn5 + //j4+P/29vf/9fX1//T09P/z8/P/8fHy//Dw8P/v7+//7e3u/+/v7//z8/T/8/Pz//Ly8v/x8fH/8PDx + /+/v8P/v7+//7u7u/+3t7v/t7e3/6+vs/+vr6//q6ur/6enq/+jo6f/o6Oj/5+fn/+bm5/+3uLj/pKSm + /+np6f+goaL/vr6//8DAwf+/v7//vr6+/729vf+8vLz/u7u7/7q6u/+5ubr/ubm6/7m5uf+7u7v/o6Oj + jrOzs3m0tLR8r6+vltDQ0f3Hx8j/VVVY0UJCQwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfX19 + g/39/f/8/Pz/+/v7//n5+f/4+Pj/9vb3//X19f/09PT/8/Pz//Hx8v/w8PD/7+/v/+3t7v/v7+//9PT0 + //T09P/y8vP/8vLy//Hx8f/w8PH/8PDw/+/v7//u7u//7e3u/+3t7f/s7Oz/6+vs/+vr6//q6ur/6enp + /+jo6f/n5+f/kpOV/9bW1//Pz9D/p6eo/8DAwP+/v7//vr6//729vv+9vb3/vLy9/7y8vP+8vLz/u7u8 + /7u7vP+7u7z/vb2+/6ysrJq6urqGvLy8ib29vYvExMXg0tLT/3p7fv06OjsrAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAH19fYP9/f3//Pz8//v7+//5+fn/+Pj4//b29//19fX/9PT0//Pz8//x8fL/8PDw + /+/v7//t7e7/7+/v//X19f/09PT/8/P0//Ly8v/y8vL/8fHx//Dw8P/w8PD/7+/v/+7u7//u7u7/7e3t + /+zs7P/s7Oz/6+vr/+rq6v/q6ur/5eXl/4CBg//v7+//sbGz/729vf/AwMD/v7/A/7+/v/++vr//vr6/ + /76+vv++vr7/vr6//76+vv++vr//vr6//8DAwf+0tLSkwcHBksPDw5XFxcWXvr6+wtjY2f+Vlpj/REVG + YwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fX2D/f39//z8/P/7+/v/+fn5//j4+P/29vf/9fX1 + //T09P/z8/P/8fHy//Dw8P/v7+//7e3u/+/v7//19fX/9fX1//T09P/z8/P/8/Pz//Ly8v/x8fH/8fHx + //Dw8P/v7/D/7u7v/+7u7v/t7e3/7e3t/+zs7P/r6+v/6+vr/+Hh4f+DhIf/8fHx/66usP/CwsL/wcHC + /8HBwf/BwcH/wcHB/8HBwf/BwcL/wcHC/8LCwv/CwsL/w8PD/8PDw//FxcX/vb29rMnJyZzLy8ufzMzM + oMPExLbY2Nn/paan/zY2OIYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfX19g/39/f/8/Pz/+/v7 + //n5+f/4+Pj/9vb3//X19f/09PT/8/Pz//Hx8v/w8PD/7+/v/+3t7v/v7+//9vb2//X19f/09PX/9PT0 + //Pz8//z8/P/8vLy//Ly8v/x8fH/8PDx//Dw8P/v7+//7u7v/+7u7v/t7e3/7e3t/+zs7P/g4OD/hISI + /+7u7v+vr7H/xcXG/8TExf/ExMT/xMTF/8TExf/FxcX/xcXG/8XFxv/Gxsb/xsbH/8fHyP/IyMj/ysrK + /8XFxbTR0dGl09PTp9TU1KnLy8y21dXW/6qqrP83ODqUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AH19fYP9/f3//Pz8//v7+//5+fn/+Pj4//f39//19fX/8fHx/+zs7f/n5+j/4+Pk/+Hh4f/f39//3t7f + /+Hh4f/h4eH/4ODg/9/g4P/f39//39/f/97f3//e3t7/3d7e/93d3v/d3d7/3d3e/93d3f/c3d3/3Nzd + /9zc3f/c3Nz/09PT/4KChf/u7u7/srK0/8jIyf/IyMj/yMjI/8jIyf/Jycn/ysrK/8rKyv/Kysv/y8vM + /8zMzP/Nzc3/zc3O/9DQ0P/Nzc272NjYrdra2q/b29uw0NDRv9jY2P+lpaf/OTk7igAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAB9fX2D/f39//z8/P/t7e3/2drb/8zNzv/BwsT/uru9/7e4uv+3uLr/t7i6 + /7e4uv+3uLr/tre5/7e4uv+4ubv/ubq8/7u8vf+9vr//vr/B/8DAwv/AwcL/wcHD/8HCw//BwsP/wcLD + /8DBwv/AwML/v8DB/76/wP+8vb//u7y9/7e4uf92dnn/6urq/7a2t//Dw8T/xMTF/8XFxv/Gx8f/yMjI + /8nJyv/Ky8v/zMzM/83Ozv/Pz9D/0tLS/9PT0//V1dX/1NTUwd/f37Tg4OC24uLit9HR0s/Z2dr/lZaY + /0FBQ2oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAenp6gNXV1v+mp6n/mZud/5manf+dn6H/q6yu + /7m6vP/Fxcf/zs7P/9XV1v/b29z/4ODh/+Tk5P/p6en/7+/v/+/v7//u7u//7u7u/+3t7v/s7O3/6+vr + /+rq6//p6er/6Ojo/+fn5//m5uf/5eXm/+Xl5f/j4+T/4uLj/+Hh4f/f3+D/jI2P/9HR0v/Pz9D/v7/A + /8/Pz//Ozs//zs7O/83Nzv/Nzc3/zMzM/8rLy//Kysv/ysvM/83Nzv/Q0NH/2NjZ/9zc3Mbl5eW75+fn + vejo6L3X19jlzc3O/3x8gP4/QEE1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGFhYjOBg4b1qaqt + /83Nz//n5+j/9vb2//f3+P/19fX/9PT0//Pz8//x8fL/8PDw/+/v7//t7e7/7u7v//Hx8f/w8PD/7+/w + /+7u7v/t7e7/7Ozt/+vr7P/r6+v/6enq/+np6f/o6Oj/5+fn/+bm5v/l5eb/5OTk/+Pj4//i4uP/4eHi + /7Cwsf+hoqT/4eHi/7m5u//Y2Nj/2NjY/9jY2f/Z2dn/2tra/9vb2//b29v/29vb/9nZ2f/W1tf/0dHS + /9PT1PXn5+fD6+vrwuzs7MPm5ufF1tbX/MHBwv9ZWV3ePj5ACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABra2tC6+vs7vz8/P/7+/v/+fn5//j4+P/29vf/9fX1//T09P/z8/P/8fHy//Dw8P/v7+//7e3u + /+7u7//y8vL/8fHx//Dw8P/v7+//7u7u/+3t7f/s7Oz/6+vs/+rq6//q6ur/6enp/+jo6P/n5+f/5ubn + /+Xl5f/k5OT/4+Pk/+Li4//S0tP/eHl8/+Dg4f/Jycr/zc3O/93d3f/e3t7/39/f/9/f3//g4OD/4ODh + /+Hh4f/i4uL/4uLj/+Pj4//k5OT06+vry+/v78jx8fHJ19jY5dLS0/+TlJb/Ojo8gAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAfX19gv39/f/8/Pz/+/v7//n5+f/4+Pj/9vb3//X19f/09PT/8/Pz + //Hx8v/w8PD/7+/v/+3t7v/v7+//8vLy//Ly8v/w8PH/8PDw/+/v7//u7u7/7e3t/+zs7f/r6+z/6+vr + /+rq6v/p6en/6Ojo/+fn6P/m5uf/5eXm/+Xl5f/k5OT/3Nzc/6Cgov+cnZ//4eLi/8DAwf/c3Nz/4+Pj + /+Pj5P/k5OT/5eXl/+Xl5f/m5ub/5+fn/+fn6P/n5+j/6enp/+3t7db09PTO3t7f2tnZ2v68vL3/XV1h + 5Tk5OhYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH19fYP9/f3//Pz8//v7+//5+fn/+Pj4 + //b29//19fX/9PT0//Pz8//x8fL/8PDw/+/v7//t7e7/7u7v//Pz8//y8vL/8fHx//Dw8P/v7/D/7+/v + /+7u7v/t7e3/7Ozt/+vr7P/q6uv/6urq/+np6f/o6On/5+fo/+fn5//m5ub/5eXl/93d3f/Q0NH/g4OG + /729vv/e3t7/wsPE/93d3v/p6en/6urq/+rq6v/q6ur/6+vr/+vr6//s7Oz/7Ozs/+3t7f/x8fHb39/f + 3tvb2/3Fxsb/dnd6/Tc3OVgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fX2D/f39 + //z8/P/7+/v/+fn5//j4+P/29vf/9fX1//T09P/z8/P/8fHy//Dw8P/v7+//7e3u/+/v7//z8/P/8/Pz + //Ly8v/x8fH/8PDw/+/v8P/v7+//7u7u/+3t7f/s7O3/6+vs/+vr6//q6ur/6enq/+jo6f/o6Oj/5+fn + /+bm5v/e3t7/1tbX/9LS0/94eHv/v7/A/93d3f/Ly8z/zs/P/+nq6v/u7u7/7u7u/+/v7//v7+//7+/w + //Dw8P/k5OX/19fY8tnZ2f/Fxcb/f3+C/zw8PoVMTE4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAfX19g/39/f/8/Pz/+/v7//n5+f/4+Pj/9vb3//X19f/09PT/8/Pz//Hx8v/w8PD/7+/v + /+3t7v/v7+//9PT0//Pz8//y8vP/8vLy//Hx8f/w8PH/7+/w/+/v7//u7u7/7e3u/+3t7f/s7Oz/6+vr + /+vr6//q6ur/6enp/+jo6f/n5+j/39/f/9fX2P/l5eX/wcHB/3l6fP+lpaf/2tra/9nZ2v/MzM3/0tLT + /9bW1//a2tr/2dra/9nZ2v/Y2Nn/19fX/9DQ0f+6urv/dHR4/Ds8PoJPT1EEAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH19fYP9/f3//Pz8//v7+//5+fn/+Pj4//b29//19fX/9PT0 + //Pz8//x8fL/8PDw/+/v7//t7e7/7+/v//X19f/09PT/8/Pz//Ly8v/y8vL/8fHx//Dw8P/w8PD/7+/v + /+7u7//t7e7/7e3t/+zs7P/s7Oz/6+vr/+rq6v/p6er/6enp/9/f4P/X19j/5+fo/9LS0v/Gxsf/jo6Q + /3l6ff+wsLH/0tLT/9bW1v/Z2dn/2dna/9nZ2v/U1NX/zMzN/7u7vP+MjY//WFlc3DM0NU5SU1QCAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fX2D/f39//z8/P/7+/v/+fn5 + //j4+P/29vf/9fX1//T09P/z8/P/8fHy//Dw8P/v7+//7e3u/+/v7//19fX/9fX1//T09P/z8/P/8vLz + //Ly8v/x8fH/8fHx//Dw8P/v7/D/7u7v/+7u7v/t7e3/7e3t/+zs7P/r6+v/6+vr/+rq6v/g4OH/19fY + /+rq6v/S0tP/zs7P/8zMzP+3t7j/iouN/3Fydf+BgYT/kpOV/5qanf+Wl5n/iIiL/3N0d/9yc3b/OTo7 + fUhISg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfX19 + g/39/f/8/Pz/+/v7//n5+f/4+Pj/9vb3//X19f/09PT/8/Pz//Hx8v/w8PD/7+/v/+3t7v/v7+//9vb2 + //X19f/09PX/9PT0//Pz8//y8vP/8vLy//Hx8f/x8fH/8PDw//Dw8P/v7+//7u7v/+7u7v/t7e3/7Ozt + /+zs7P/r6+v/4uLi/9jY2f/s7Oz/09PT/87Oz//Nzc7/y8vM/8rKyv/Dw8P/srKz/6Ghov+ampz/mZmb + /6Skpv+ysrP/wMDC/1VVVi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAH19fYP9/f3//Pz8//v7+//5+fn/+Pj4//b29//29vb/8/Pz/+/v8P/r6+v/5+fn + /+Tk5f/i4uL/4uLi/+Xl5f/k5OX/5OTk/+Pj5P/j4+P/4uLj/+Li4v/i4uL/4eHi/+Hh4f/h4eH/4ODh + /+Dg4P/g4OD/39/g/9/f4P/f3+D/39/f/9ra2//V1db/4eHh/9LS0//Pz9D/zs7O/8zMzf/Ly8z/ycnK + /8jIyf/Gxsf/xcXG/8TExf/Dw8T/wcHC/8TExf9eXl4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fX2D/f39//z8/P/z8/P/4ODh/9LT1P/IyMr/wMHC + /7u8vv+6u73/uru8/7q7vf+6u7z/uru8/7m6vP+5urz/uru9/7u8vf+7vb7/vL6//76/wP++wMH/v8DB + /7/Bwv/AwcL/wMHC/7/Awf++v8H/vr/A/72+v/+8vb7/u7y+/7q8vf+6u73/ubu8/7q7vP+6u7z/uru9 + /7q7vf+6u73/uru9/7u8vf+7vL7/vL2//72+v//AwMH/wsLE/8HBwv/ExMX/YmJjLgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe3t7gd7e3/+vr7H/nZ6h + /52eoP+dnqH/pqep/7S1tv/AwML/ycnK/9DQ0f/W1tf/29vc/97e3//k5OX/6+vr/+zs7P/s7Oz/7Ozt + /+zs7f/r6+z/6urr/+rq6v/p6en/6Ojo/+fn5//m5ub/5eXl/+Tk5P/i4uP/4eHi/+Dg4P/e3t7/19fX + /9DQ0f/R0dL/x8fI/8PDxP+/v8D/urq8/7W1t/+vsLH/qKiq/6GhpP+dnqD/nZ6h/56fov+nqKr/vr7A + /1xdXS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AF9fXzuDhYj5oaKl/8XGx//f3+D/8vLy//f3+P/29vb/9PT0//Pz8//x8fL/8PDw/+/v7//t7e7/7u7u + //Hx8f/w8PD/7+/w/+7u7v/t7e7/7Ozt/+vr6//q6uv/6enq/+np6f/o6Oj/5+fn/+bm5v/l5eX/5OTk + /+Pj4//i4uP/4eHi/9ra2//V1db/2trb/9DQ0P/Ozs//zc3O/8vLzP/Kysv/ycnK/8jIyf/Gxsf/wMDB + /7Kztf+io6X/jI2Q/3x9f99cXF0PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABhYWE54+Pj6fz8/P/7+/v/+fn5//j4+P/29vf/9fX1//T09P/z8/P/8fHy + //Dw8P/v7+//7e3u/+7u7//y8vL/8fHx//Dw8P/v7+//7u7u/+3t7f/s7Oz/6+vs/+rq6//q6ur/6enp + /+jo6P/n5+f/5ubm/+Xl5f/k5OT/4+Pk/+Li4//b29v/1dXW/9zc3f/Q0NH/zs7P/83Nzv/Ly8z/ysrL + /8nJyv/IyMn/xsbH/8XFxv/ExMX/w8PE/8HBwv+XmJjIXV1dEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfX19gv39/f/8/Pz/+/v7//n5+f/4+Pj/9vb3 + //X19f/09PT/8/Pz//Hx8v/w8PD/7+/v/+3t7v/v7+//8vLy//Hx8v/w8PH/7+/w/+/v7//u7u7/7e3t + /+zs7P/r6+z/6urr/+np6v/p6en/6Ojo/+fn5//m5uf/5eXm/+Xl5f/k5OT/3Nzc/9XV1v/e3t//0NDR + /87Oz//Nzc7/y8vM/8rKy//Jycr/yMjJ/8bGx//Fxcb/xMTF/8PDxP/BwcL/xMTF/15eXy4AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH19fYP9/f3//Pz8 + //v7+//5+fn/+Pj4//b29//19fX/9PT0//Pz8//x8fL/8PDw/+/v7//t7e7/7u7v//Pz8//y8vL/8fHx + //Dw8P/v7/D/7u7v/+7u7v/t7e3/7Ozt/+vr7P/q6uv/6enq/+np6f/o6On/5+fo/+bm5//m5ub/5eXl + /93d3f/W1tf/4ODh/9DQ0f/Ozs//zc3O/8vLzP/Kysv/ycnK/8jIyf/Gxsf/xcXG/8TExf/Dw8T/wcHC + /8TExf9kZGUuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAB9fX2D/f39//z8/P/7+/v/+fn5//j4+P/29vf/9fX1//T09P/z8/P/8fHy//Dw8P/v7+//7e3u + /+/v7//z8/P/8/Pz//Ly8v/x8fH/8PDw/+/v8P/u7u//7u7u/+3t7f/s7O3/6+vs/+rq6//q6ur/6enq + /+jo6f/n5+j/5+fn/+bm5v/e3t7/1tbX/+Pj4//R0dH/zs7P/83Nzv/Ly8z/ysrL/8nJyv/IyMn/xsbH + /8XFxv/ExMX/w8PE/8HBwv/ExMX/ZWVmLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAfX19g/39/f/8/Pz/+/v7//n5+f/4+Pj/9vb3//X19f/09PT/8/Pz + //Hx8v/w8PD/7+/v/+3t7v/v7+//9PT0//Pz8//y8vP/8vLy//Hx8f/w8PD/7+/w/+/v7//u7u7/7e3u + /+zs7f/s7Oz/6+vr/+rq6//q6ur/6enp/+jo6P/n5+j/39/f/9fX2P/l5eX/0dHS/87Oz//Nzc7/y8vM + /8rKy//Jycr/yMjJ/8bGx//Fxcb/xMTF/8PDxP/BwcL/xMTF/2VlZi4AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH19fYP9/f3//Pz8//v7+//5+fn/+Pj4 + //b29//19fX/9PT0//Pz8//x8fL/8PDw/+/v7//t7e7/7+/v//X19f/09PT/8/Pz//Ly8v/y8vL/8fHx + //Dw8P/w8PD/7+/v/+7u7//t7e7/7e3t/+zs7P/r6+z/6+vr/+rq6v/p6er/6enp/9/f4P/X19j/5+fn + /9LS0v/Ozs//zc3O/8vLzP/Kysv/ycnK/8jIyf/Gxsf/xcXG/8TExf/Dw8T/wcHC/8TExf9lZWYuAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fX2D/f39 + //z8/P/7+/v/+fn5//j4+P/29vf/9fX1//T09P/z8/P/8fHy//Dw8P/v7+//7e3u/+/v7//19fX/9fX1 + //T09P/z8/P/8vLz//Ly8v/x8fH/8PDx//Dw8P/v7+//7u7v/+7u7v/t7e3/7e3t/+zs7P/r6+v/6+vr + /+rq6v/g4OH/19fY/+np6v/S0tP/zs7P/83Nzv/Ly8z/ysrL/8nJyv/IyMn/xsbH/8XFxv/ExMX/w8PE + /8HBwv/ExMX/ZWVmLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAfX19g/39/f/8/Pz/+/v7//n5+f/4+Pj/9vb3//X19f/09PT/8/Pz//Hx8v/w8PD/7+/v + /+3t7v/v7+//9vb2//X19f/09PX/9PT0//Pz8//y8vP/8vLy//Hx8f/x8fH/8PDw/+/v8P/v7+//7u7u + /+7u7v/t7e3/7Ozs/+zs7P/r6+v/4uLi/9jY2f/r6+z/09PT/87Oz//Nzc7/y8vM/8rKy//Jycr/yMjJ + /8bGx//Fxcb/xMTF/8PDxP/BwcL/xMTF/2VlZi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH19fYP9/f3//Pz8//v7+//5+fn/+Pj4//b29//29vb/9PT0 + //Hx8v/s7O3/5+fn/+Pj4//e39//3t7e/+Hh4v/f4OD/3t7f/9zd3f/c3N3/29zd/9vc3P/a29z/2tvc + /9ra2//a2tv/2dna/9nZ2v/Z2dr/2dnZ/9jY2f/Y2Nn/2dna/9TU1f/Pz9D/3d3e/83Nzv/LzMz/y8vM + /8vLzP/Kysv/ycnK/8jIyf/Gxsf/xcXG/8TExf/Dw8T/wcHC/8TExf9lZWYuAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9fX2D/f39//z8/P/4+Pj/6urr + /9/f4P/V1db/zM3O/8XGx//CwsT/wcLD/8HBw//BwsP/wcLD/8LCxP/CwsT/wsLE/8LCxP/CwsT/wsLE + /8LCxP/CwsT/wsLE/8LCxP/CwsT/wsLE/8LCxP/CwsT/wsLE/8LCxP/CwsT/wsLE/8LCxP/CwsT/wsLE + /8LCxP/BwsP/wcLD/8HCw//BwsP/wsPE/8PExf/Excb/xcXG/8XFx//Fxcb/w8PE/8HBwv/ExMX/ZmZm + LgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfHx8 + gvHx8f/X19j/ycnK/8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ + /8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ + /8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ/8jIyf/IyMn/yMjJ + /8jIyv/Hx8j/xsbH/2NjZC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAGhoaELQ0NH7z8/Q/8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q + /8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q + /8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q + /8/P0P/Pz9D/z8/Q/8/P0P/Pz9D/z8/Q/729veVXV1gSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/gIACW1tbUaWlpsbV1tb71tbW/9XW1v/V1tb/1dbW + /9XW1v/V1tb/1dbW/9XW1v/V1tb/1dbW/9XW1v/V1tb/1dbW/9XW1v/V1tb/1dbW/9XW1v/V1tb/1dbW + /9XW1v/V1tb/1dbW/9XW1v/V1tb/1dbW/9XW1v/V1tb/1dbW/9XW1v/V1tb/1dbW/9XW1v/V1tb/1dbW + /9XW1v/V1tb/1dbW/9XW1v/V1tb/1dbW/9XW1v/W19f/0dHR9JCQka9RUVExAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3d3gEWVlZ + IHJyclt2dnePm5ubt7y8vdrU1NTx3t7e/d/f3//e3t7/3Nzd/9zc3P/c3Nz/3Nzc/9zc3P/c3Nz/3Nzc + /9zc3P/c3Nz/3Nzc/9zc3P/c3Nz/3Nzc/9zc3P/c3Nz/3Nzc/9zc3P/c3Nz/3Nzc/9zc3P/c3Nz/3Nzc + /9zc3P/c3Nz/3Nzc/9zc3f/e3t7/3t7f/93d3fvPz8/stLS00pSUlK11dXWCZWZmTGNjYxSAgIECAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAgAJ4eHkFVVVVDWBgYBpjY2QvYWFhRXJyclV6enphjIyM + bmVlZXVnZ2d6aGhofmlpaYJpaWmCaWlpgmlpaYJpaWmCaWlpgmlpaYJpaWmCaWlpgmlpaYJpaWmCaWlp + gmlpaYJoaGiBaGhofmZmZnlkZGR0iYmJa3d3d15wcHBRW1tbQGlpaSlcXV0WXV1dCnh4eQSKiooBAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA////4f/////////A/////////4B/////////gD////////+AH///////gAAAA////8AA + AAAAB///AAAAAAAA//4AAAAAAAB//gAAAAAAAH/+AAAAAAAAf/4AAAAAAAB//gAAAAAAAH/+AAAAAAAA + f/4AAAAAAAB//gAAAAAAAH/+AAAAAAAAP/4AAAAAAAAP/gAAAAAAAAf+AAAAAAAAA/4AAAAAAAAD/gAA + AAAAAAH+AAAAAAAAAf4AAAAAAAAA/gAAAAAAAAD+AAAAAAAAAP4AAAAAAAAA/gAAAAAAAAD+AAAAAAAA + AP4AAAAAAAAA/gAAAAAAAAD+AAAAAAAAAP4AAAAAAAAB/gAAAAAAAAH+AAAAAAAAA/4AAAAAAAAD/gAA + AAAAAAf+AAAAAAAAD/4AAAAAAAA//gAAAAAAAH/+AAAAAAAAf/4AAAAAAAB//gAAAAAAAH/+AAAAAAAA + f/4AAAAAAAB//gAAAAAAAH/+AAAAAAAAf/4AAAAAAAB//gAAAAAAAH/+AAAAAAAAf/4AAAAAAAB//gAA + AAAAAH/+AAAAAAAAf/4AAAAAAAB//gAAAAAAAH/+AAAAAAAAf/4AAAAAAAD//4AAAAAAAf//+AAAAAAf + //////////////////////////////////////////////////////8oAAAAMAAAAGAAAAABACAAAAAA + AIAlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5OTtFTU5QuTk6O1EAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADs7PUmRkpT2n5+f + /35/gfU6OzxRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDQ2 + Al9fYsjk5OT+0tLS/5mZmv59fYD1OTk7TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAElKS22kpKf83t7e/9LS0v+ampr/e3t+9Dk5O0oAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgoKCAnNzdAl5eXkafX19 + MIKCgkaGhoZalpaWaoiIiHqTk5OIlZWVkZWVlZqRkZPlp6ep/93d3v7S0tL+mZmZ/3h5e/NwcXKpn5+f + n5SUlZePj5CQhISFhoSEhHeDg4RodHR0V3NzdEJnZ2csaGhpFmNjZAdtbW4BAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcXFxFY+Pj2CioqKdwcHB + yuLi4unw8PD48/Pz/vHx8f7v7+/+7e3t//Dw8P7w8PD+7+/v/+3t7v7q6uv+pqao/6ioq/7d3d7+0dHS + /5iYmf6AgIP+vLy+/+Li4v7h4eH+2NjZ/9jY2P7S0tP/zs7P/s3Nzf7Kysv9xcXF97S0teSYmJnCfn5/ + kmpqa1FnZ2cLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eHg67+/v + 8Pv7+//5+fn/+Pj4//b29v/09PT/8vLz//Hx8f/v7+//7e3t//Hx8f/x8fH/8PDw/+/v7//t7e7/6urr + /6Wlp/+pqaz/3d3e/9LS0v+YmJn/f3+C/72+v//j4+P/2dna/9ra2v/T09T/zs7P/8zMzf/Kysv/ycnJ + /8fHyP/Fxcb/w8PE/8LCw/+rq6zeZWVlEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACIiIhi/f39//v7+/75+fn++Pj4//b29v709PT/8vLz/vDw8f7v7+/+7e3t//Hx8f7y8vL+8fHx + /+/v8P7u7u/+7e3t/+rq6v6kpKb+qqqs/93d3v7S0tL+l5eY/35/gf7AwMH+2tra/9vb3P7U1NT/zs7P + /szMzf7Kysv/ycnJ/sfHyP7Fxcb/w8PE/sLCw/7Dw8T/a2trIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+/75+fn++Pj4//b29v709PT/8vLz/vDw8f7v7+/+7e3t + //Hx8v7z8/P+8fHy//Dw8f7v7+/+7u7u/+3t7f7q6ur+oqOk/6urrf7d3d7+0dHS/5eXl/59foD+urq7 + /93d3v7V1db/zs7P/szMzf7Kysv/ycnJ/sfHyP7Fxcb/w8PE/sLCw/7Dw8T/cHBxIwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+//5+fn/+Pj4//b29v/09PT/8vLz + //Hx8f/v7+//7e3t//Ly8v/z8/T/8vLz//Hx8v/w8PH/7+/w/+7u7//u7u7/6urq/6Gho/+srK7/3d3e + /9LS0v+Xl5j/e3x+/8DBwv/W1tf/zs7P/8zMzf/Kysv/ycnJ/8fHyP/Fxcb/w8PE/8LCw//Dw8T/cHBx + IwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+/75+fn++Pj4 + //b29v709PT/8vLz/vDw8f7v7+/+7e3t//Ly8/709PT+8/Pz//Ly8/7x8fL+8PDx/+/v8P7v7+/+7u7u + /+rq6v6foKL+ra2v/93d3v7S0tL+lpaX/319gP64uLn/zs7P/szMzf7Kysv/ycnJ/sfHyP7Fxcb/w8PE + /sLCw/7Dw8T/b29wIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39 + //v7+//5+fn/+Pj4//b29v/09PT/8vLz//Hx8f/v7+//7e3t//Pz8//19fX/9PT0//Pz9P/y8vP/8vLy + //Hx8f/w8PD/7+/v/+7u7//r6+v/np6g/66usP/d3d7/0dHS/5aWlv94eHv/yMjJ/8zMzf/Kysv/xsbG + /7m5uv+xsbL/sbGy/7m5uv/CwsP/YWJjIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACKiopi/f39//v7+/75+fn+9/f3//Ly8v7r6+v/5eXm/uHh4v7e3t/+3Nzc/97e3v7e3t/+3t7e + /93d3v7c3N3+3Nzd/9zc3P7b29z+29vc/9vb2/7a2tv+19fY/5CQk/6urrD+3Nzc/8zLzP6Xlpj/oKCi + /ry8vf6Sk5X/kpOV/qanqP6xsbP/rKyu/pmanP6Hh4r/RkdIb0dHSAkAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACGhoZi9PX1/9TU1v6/wMH+srO1/7Gxs/64uLr/wMHC/sfHyP7MzM3+z8/R + /9XV1v7Y2Nn+2dna/9ra2/7b29z+29vc/9ra2/7a2tv+2dna/9jY2f7W1tf+1dXW/9DQ0f6TlJb+lJSX + /8XGx/7k4uP/kpGT/pycnv7c3N3/3t7f/sTExf64uLn/vLy+/s7Oz/7d3t7/ubm7/mRlZ8tCQkQvAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2dnc7mpue/Lq7vf7W1tf+6Onp//Ly8v709PT/8/Pz + /vHx8f7v7+/+7e3t//Dw8P7w8PD+7+/v/+7u7v7s7O3+6+vr/+rq6v7p6en+6Ojo/+bm5/7l5eX+5OTk + /+Pj4/7f39/+urq7/4ODhv7Pz9D/29vc/t/f4P6srK7/p6eo/rOztP6ysrP/qKip/pmanP6TlJb2wMDB + 8tXW1v5/f4LsR0dJOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6entD+fn5+vv7+//5+fn/+Pj4 + //b29v/09PT/8vLz//Hx8f/v7+//7e3t//Hx8f/x8fH/8PDw/+/v7//t7e7/7Ozt/+vr7P/q6ur/6enp + /+jo6P/n5+f/5eXm/+Tk5P/j4+P/2dnZ/6Slpv+7u73/1NTV/6Skpf+9vb7/v7+//729vf+7u7z/ubm6 + /7i4uf+zs7Pzk5OTebOztNfW1tb/c3N25ERERRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIiIhi/f39 + //v7+/75+fn++Pj4//b29v709PT/8vLz/vDw8f7v7+/+7e3t//Hx8f7y8vL+8fHx/+/v8P7u7u/+7e3u + /+zs7f7r6+v+6urq/+np6f7o6Oj+5+fn/+bm5v7l5eX+0NDQ/5iZm/7j4+T/pKWm/sDAwP7AwMD/vr6+ + /ry8vf66urv/ubm6/ri4uP64uLn/nJyceKWmpnC/v8DjxMTF/ktMTp9MTU4BAAAAAAAAAAAAAAAAAAAA + AAAAAACKiopi/f39//v7+/75+fn++Pj4//b29v709PT/8vLz/vDw8f7v7+/+7e3t//Hx8v7z8/P+8vLy + //Dw8f7v7/D+7u7v/+3t7v7s7O3+6+vr/+rq6v7p6er+6Ojo/+fn5/7m5ub+qamq/9PT1P6ys7T/vLy9 + /sDAwP6+vr7/vb29/ru7vP66urv/ubm6/rm5uf66urr/paWlhrKysnivr6+Y09PT/oiJi/VCQkMeAAAA + AAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+//5+fn/+Pj4//b29v/09PT/8vLz//Hx8f/v7+//7e3t + //Ly8v/09PT/8/Pz//Hx8v/w8PH/8PDw/+/v7//u7u7/7e3t/+zs7P/r6+v/6urq/+np6f/n5+f/lpeZ + /+bm5v+qqqv/wMDA/76+v/+9vb7/vb29/7y8vf+8vLz/vLy8/7y8vP+9vb7/sLCwl7y8vIq+vr6NyMjJ + 47Gxs/9DREVnAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+/75+fn++Pj4//b29v709PT/8vLz + /vDw8f7v7+/+7e3t//Ly8/709PT+8/Pz//Ly8/7y8vL+8fHx//Dw8P7v7+/+7u7u/+3t7f7s7O3+6+vr + /+rq6/7l5eX+nZ2f/9XV1v62trf/wMDB/sDAwP7AwMD/wMDA/r+/wP7AwMD/wMDA/sDAwf7CwsP/u7u7 + pMbGxpjIyMibycnKzMfHyP5ISEuYAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+/75+fn++Pj4 + //b29v709PT/8vLz/vDw8f7v7+/+7e3t//Pz8/719fX+9PT0//Pz9P7z8/P+8vLy//Hx8f7w8PD+7+/w + /+7u7/7u7u7+7e3t/+zs7P7j4+P+oaGj/8zMzf7AwMH/xMTE/sPDxP7ExMT/xMTE/sTExf7Fxcb/xsbG + /sfHx/7Jycn/xsbGr9DQ0KXS0tKnzMzNyM7Ozv5GR0mtAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39 + //v7+//6+vr/9fb2/+3t7v/l5ub/4ODh/9zc3f/Z2dr/19fY/9jY2f/Z2dn/2NjZ/9fY2P/X19j/19fX + /9bX1//W1tf/1tbX/9XW1v/V1tb/1dbW/9XV1v/Pz9D/m5ye/9HR0v/BwcH/x8fI/8jIyP/Jycn/ysrK + /8vLy//MzMz/zc3N/87Ozv/Q0ND/0dHRuNra2q/c3Nyx1NXV0cnJyv9EREejAAAAAAAAAAAAAAAAAAAA + AAAAAACFhYVi7+/v/8vMzf62t7n+q6yu/6mqrf6wsbP/uLm7/r/Awf7Fxcf+ycnL/8/P0f7S0tT+09TV + /9XV1v7W1tf+1tbX/9XW1/7V1tb+1NTV/9PT1P7R0tP+0NDR/87Oz/7Kysz+kJGT/+Dg4P64ubr/yMjJ + /sjIyf7IyMn/yMnJ/snJyv7Ly8z/zc7O/tHR0v7W1tf/2trawePj47nk5OS62dna47W1tv5JSUt9AAAA + AAAAAAAAAAAAAAAAAAAAAABxcXIzjpCT+bGytP7Ozs/+4uLj/+7v7/7z8/P/8/Pz/vHx8f7v7+/+7e3t + //Dw8P7w8PD+7+/v/+3t7v7s7O3+6+vr/+rq6v7p6en+5+fo/+bm5v7l5eX+5OTk/+Li4/7h4eL+m5ud + /9fX2P7AwMH/19fX/tfX1/7Y2Nj/2dnZ/tjY2f7X19f/1dXV/tLS0/7S09P55ubmw+rq6sHo6OjD09PU + +pSUl/1DREU5AAAAAAAAAAAAAAAAAAAAAAAAAAB5eXo98/Pz9fv7+//5+fn/+Pj4//b29v/09PT/8vLz + //Hx8f/v7+//7e3t//Hx8f/x8fH/8PDw/+/v7//t7e7/7Ozt/+vr6//q6ur/6enp/+jo6P/n5+f/5eXl + /+Tk5P/j4+P/xMTF/6Cho//V1dX/zs7P/97e3//f3+D/4ODg/+Hh4f/i4uL/4+Pj/+Pj5P/l5eX57Ozs + zPHx8crd3d3jycnK/1paXcpKS0wFAAAAAAAAAAAAAAAAAAAAAAAAAACIiIhi/f39//v7+/75+fn++Pj4 + //b29v709PT/8vLz/vDw8f7v7+/+7e3t//Hx8f7y8vL+8fHx/+/v8P7u7u/+7e3t/+zs7P7r6+v+6urq + /+np6f7o6Oj+5+fn/+bm5v7k5OX+2dnZ/5aWmP7IyMr/zMzN/tnZ2v7m5ub/5+fn/ufn6P7o6Oj/6enp + /urq6v7r6+v/8PDw1+Li497S0tP+i4yO+kBAQkYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39 + //v7+/75+fn++Pj4//b29v709PT/8vLz/vDw8f7v7+/+7e3t//Hx8v7z8/P+8fHy//Dw8f7v7/D+7u7v + /+3t7f7s7Oz+6+vr/+rq6v7p6en+6Ojo/+fn5/7m5ub+29vb/9XV1v6Li47/zc3O/tDQ0f7U1NX/6+vr + /u3t7f7u7u7/7u7u/u/v7/7p6en/3Nzd7tLS0/6cnJ7/QUFDgE9PUQEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACKiopi/f39//v7+//5+fn/+Pj4//b29v/09PT/8vLz//Hx8f/v7+//7e3t//Ly8v/z8/T/8vLz + //Hx8v/w8PH/7+/w/+7u7//u7u7/7e3t/+zs7P/r6+v/6urq/+np6f/o6Oj/3Nzc/9/f4P/Nzc7/iImL + /7Gys//Y2Nn/z8/Q/9fX2P/d3d7/3t7e/9nZ2f/T1NT/xsbH/4mJjPlBQUN9T1BRAgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+/75+fn++Pj4//b29v709PT/8vLz/vDw8f7v7+/+7e3t + //Ly8/709PT+8/Pz//Ly8/7x8fL+8PDx//Dw8P7v7+/+7u7u/+3t7f7s7Oz+6+vr/+rq6v7p6er+3Nzd + /+Hh4v7Y2Nj/ysrL/p+fof6Hh4r/oaKk/rq6vP7Dw8T/v7/A/q2tr/6Pj5L/VVVYv0BAQTxRUVMBAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+/75+fn++Pj4//b29v709PT/8vLz + /vDw8f7v7+/+7e3t//Pz8/719fX+9PT0//Pz9P7y8vP+8vLy//Hx8f7w8PD+7+/v/+7u7/7t7e7+7e3t + /+zs7P7r6+v+3t7e/+Pj4/7Z2dn/zs7P/szMzf7Gxsf/rq6v/paXmf6MjI7/i4yO/piZmv6xsbL/VFVW + JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+//6+vr/9/f3 + //Dw8f/p6er/4+Tk/9/f4P/c3N3/2trb/9vc3P/c3N3/3Nzc/9vb3P/b29v/2tvb/9ra2//Z2tr/2dna + /9nZ2v/Y2dn/2NnZ/9jY2f/Y2Nn/09PU/9XW1v/R0tL/zMzN/8rLy//Jycr/yMjJ/8fHyP/Fxcb/w8PE + /8LCw//Dw8T/aGhpIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGhoZi8/Pz + /9HS0/69vb/+sLGz/6ytr/6vsLL/tre5/ry9v/7Cw8T+xsfI/8zNzv7P0NH+0dLT/9LT1P7T1NX+09TV + /9PU1f7T09T+0tPT/9HR0v7P0NH+zs7P/8zMzf7Kysv+xMXG/8HCw/69vb//ubm7/rW2t/6xsrT/ra6w + /qytr/6trrD/sLGz/rW2t/7BwcP/aGlqIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABxcXE4kZKV/Kytr//Iycr/3N3d/+rq6//x8fH/8vLy//Hx8f/v7+//7e3t//Dw8P/w8PD/7+/v + /+7u7v/s7O3/6+vr/+rq6v/p6en/5+fo/+bm5v/l5eX/5OTk/+Li4//h4eL/2NjZ/9jY2P/S0tP/zs7P + /8zMzf/Kysv/x8fH/8DAwf+2trj/qamr/5eYmv+Ji43tZGRkEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABzc3M47u7u8vv7+/75+fn++Pj4//b29v709PT/8vLz/vDw8f7v7+/+7e3t + //Hx8f7x8fH+8PDw/+7u7/7t7e7+7Ozs/+vr6/7q6ur+6enp/+fn6P7m5uf+5eXl/+Tk5P7j4+P+2dnZ + /9nZ2v7T09T/zs7P/szMzf7Kysv/ycnJ/sfHyP7Fxcb/w8PE/sLCw/6qqqvgZGRlEQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACHh4di/f39//v7+/75+fn++Pj4//b29v709PT/8vLz + /vDw8f7v7+/+7e3t//Hx8f7y8vL+8fHx/+/v8P7u7u/+7e3t/+zs7P7r6+v+6urq/+np6f7o6Oj+5+fn + /+Xl5v7k5OX+2tra/9vb3P7U1NT/zs7P/szMzf7Kysv/ycnJ/sfHyP7Fxcb/w8PE/sLCw/7Dw8T/a2tr + IwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+//5+fn/+Pj4 + //b29v/09PT/8vLz//Hx8f/v7+//7e3t//Hx8v/z8/P/8fHy//Dw8f/v7/D/7u7u/+3t7f/s7Oz/6+vr + /+rq6v/p6en/6Ojo/+fn5//m5ub/29vb/93d3v/V1db/zs7P/8zMzf/Kysv/ycnJ/8fHyP/Fxcb/w8PE + /8LCw//Dw8T/cHBxIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39 + //v7+/75+fn++Pj4//b29v709PT/8vLz/vDw8f7v7+/+7e3t//Ly8v7z8/T+8vLy//Hx8v7w8PH+7+/w + /+7u7/7u7u7+7Ozt/+vr7P7r6+v+6urq/+np6f7o6Oj+3Nzc/9/f4P7W1tf/zs7P/szMzf7Kysv/ycnJ + /sfHyP7Fxcb/w8PE/sLCw/7Dw8T/cHBxIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACKiopi/f39//v7+/75+fn++Pj4//b29v709PT/8vLz/vDw8f7v7+/+7e3t//Ly8/709PT+8/Pz + //Ly8v7x8fL+8PDx/+/v8P7v7+/+7u7u/+3t7f7s7Oz+6+vr/+rq6v7p6er+3Nzd/+Hh4f7Y2Nj/zs7P + /szMzf7Kysv/ycnJ/sfHyP7Fxcb/w8PE/sLCw/7Dw8T/cHBxIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+//5+fn/+Pj4//b29v/09PT/8vLz//Hx8f/v7+//7e3t + //Pz8//19fX/9PT0//Pz9P/y8vP/8vLy//Hx8f/w8PD/7+/v/+7u7//t7e7/7e3t/+zs7P/r6+v/3t7e + /+Pj4//Z2dn/zs7P/8zMzf/Kysv/ycnJ/8fHyP/Fxcb/w8PE/8LCw//Dw8T/cHBxIwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKiopi/f39//v7+/75+fn+9/f4//Lz8/7r6+z/5eXl + /t7f3/7a2tv+1tfX/9jY2f7Y2Nn+1tbX/9XV1v7U1db+1NXW/9TU1f7T1NX+09PU/9PT1P7S09T+0tLT + /9LS0/7S0tT+zc7O/9HR0v7Nzc7/yMjJ/sjIyf7IyMn/yMjJ/sfHyP7Fxcb/w8PE/sLCw/7Dw8T/cHBx + IwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIiIhi+fn5/+bm5v7W19f+zMzN + /8bGx/7Excb/xcXG/sXFxv7Fxcb+xcXG/8XFxv7Fxcb+xcXG/8XFxv7Fxcb+xcXG/8XFxv7Fxcb+xcXG + /8XFxv7Fxcb+xcXG/8XFxv7Fxcb+xcXG/8XFxv7Fxcb/xcXG/sXFxv7Fxcb/xcXG/sXFxv7Gxsf/xsbH + /sTExf7Dw8X/b29wIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3d3c90tPT + /c7Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P + /87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P/87Oz//Ozs//zs7P + /87Oz//Ozs//zs7P/87Oz//Dw8TwY2NkEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACAgIABcXFxTpubnLbKysrt19fX/dfX1/7W19f/1tfX/tbX1/7W19f+1tfX/9bX1/7W19f+1tfX + /9bX1/7W19f+1tfX/9bX1/7W19f+1tfX/9bX1/7W19f+1tfX/9bX1/7W19f+1tfX/9bX1/7W19f/1tfX + /tbX1/7W19f/1tfX/tfX2P7W1tf8w8PE5pSUlKdoaGg2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGBgQFxcXENdHV1Mn19fVqFhYV7kpKTlJSUlaujo6O8rKys + yLm5udK7u7vWvb292r29vdy9vb3cvb293L29vdy9vb3cvb293L29vdy9vb3cvb293L29vdy8vLzZu7u7 + 1bi4uNCpqanGoaGhuZWVlaaOjo6QhYWGdXp6elJ2dnYqdHR0CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACNjY0BlJSUAYODgwNwcHAEbW1tBG5ubgVubm4Fbm5uBW5ubgVubm4Fbm5uBW5ubgVubm4Fbm5u + BW5ubgVtbW0Eb29vBIGBgQOSkpIBjY2OAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA///x + ////AAD//+D///8AAP//wH///wAA///gP///AAD/gAAAAf8AAPwAAAAAPwAA+AAAAAAfAAD4AAAAAB8A + APgAAAAAHwAA+AAAAAAfAAD4AAAAAB8AAPgAAAAAHwAA+AAAAAAPAAD4AAAAAAcAAPgAAAAAAwAA+AAA + AAABAAD4AAAAAAAAAPgAAAAAAAAA+AAAAAAAAAD4AAAAAAAAAPgAAAAAAAAA+AAAAAAAAAD4AAAAAAAA + APgAAAAAAAAA+AAAAAAAAAD4AAAAAAEAAPgAAAAAAQAA+AAAAAADAAD4AAAAAAcAAPgAAAAAHwAA+AAA + AAAfAAD4AAAAAB8AAPgAAAAAHwAA+AAAAAAfAAD4AAAAAB8AAPgAAAAAHwAA+AAAAAAfAAD4AAAAAB8A + APgAAAAAHwAA+AAAAAAfAAD4AAAAAB8AAPgAAAAAHwAA+AAAAAA/AAD+AAAAAP8AAP/8AAA//wAA//// + ////AAD///////8AAP///////wAAKAAAACAAAABAAAAAAQAgAAAAAACAEAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERUdaYWFj + xUNDRSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjY4 + JLW2t/q1tbb/dHV34EFBQyIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZWVkBXl5e + A1hYWAhRUVIXcnJ1y9nZ2f+1tbX/cnJ03k1NTi5qamoUYWFhDVRUVAdbW1sDUVFRAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4eHgbn5+fX66uro+4uLmywMDA + zdLS0uHh4eHv7u7u+u/v8P7l5eX/n5+h/9nZ2v+0tLX/iouN/9LS0//i4uL+1NTV+cjIye60tLTfoKCh + ypiYmK6NjY6Je3t8V2RkZRIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfn5+L/b29vj6+vr/9/f3 + //T09f/y8vL/7+/w/+7u7v/x8fL/8PDw/+7u7v/j4+P/n5+h/9nZ2v+0tLX/iYqM/9PT1P/Y2Nn/19fX + /87Ozv/Ly8z/yMjJ/8bGx//Dw8T/uLi58GZmZhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMjIxB/Pz8 + //r6+v/39/f/9PT1//Ly8v/v7/D/7u7u//Pz8//x8fH/7+/w/+7u7v/j4+P/np+h/9nZ2v+0tLT/iYqM + /8vLzP/Z2dr/zs7O/8vLzP/IyMn/xsbH/8PDxP/CwsT/cXFxFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AIyMjEH8/Pz/+vr6//f39//09PX/8vLy/+/v8P/u7u7/9PT0//Ly8//x8fH/7+/w/+7u7v/i4uP/np+h + /9ra2v+0tLT/h4iK/83Nzv/Ozs7/y8vM/8jIyf/Gxsf/w8PE/8LCxP9ycnMXAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAjIyMQfz8/P/6+vr/9/f3//T09f/y8vL/7+/w/+7u7v/19fX/9PT0//Ly8//x8fH/8PDw + /+/v7//i4uP/np6g/9ra2v+zs7T/hIWH/8vLzP/Ly8z/xcXF/7m5uv+4uLn/wMDC/2dnaBcAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACLi4tB/Pz8//Pz8//k5OX/29vc/9XV1//R0dP/0NDR/9TU1f/V1db/1tbX + /9bW1//W1tf/1tbW/9TU1f/Hx8n/lZaY/9PT1P+8u7z/mJia/6KjpP+0tbb/vr/A/7q6vP+oqar/WVpc + hkJCRAsAAAAAAAAAAAAAAAAAAAAAAAAAAHx8fDC1trj9wMHD/9PT1f/e3t//5ebm/+rq6v/s7O3/8fHx + /+/v7//t7e3/6+vr/+np6f/n5+f/5eXm/+Pj5P/W1tf/lZaY/8PDxP/Qz9D/ysrL/7Gys/+qqqv/pKSm + /6ipqvvKysv5f3+B0U5OUBkAAAAAAAAAAAAAAAAAAAAAf39/M/r6+v36+vr/9/f3//T09f/y8vL/7+/w + /+7u7v/x8fL/8PDw/+7u7v/s7Oz/6+vr/+np6f/n5+f/5eXm/+Tk5P/MzMz/tLW2/7u8vf+5ubr/vr6+ + /7u7vP+5ubr/tra2+Zubm4TIyMnucXFzw0JDRAMAAAAAAAAAAAAAAACMjIxB/Pz8//r6+v/39/f/9PT1 + //Ly8v/v7/D/7u7u//Pz8//x8fH/7+/w/+7u7v/s7O3/6+vr/+np6v/n5+j/5ubm/6usrf/Ozs//ubm6 + /7+/v/+9vb3/urq7/7m5uv+5ubn/p6enfbGxsZjAwcL+SUlLUQAAAAAAAAAAAAAAAIyMjEH8/Pz/+vr6 + //f39//09PX/8vLy/+/v8P/u7u7/9PT0//Ly8//x8fH/8PDw/+7u7v/t7e3/6+vs/+rq6v/n5+j/tra3 + /7m5uv+/v8D/vr6//729vv+9vb3/vb29/76+vv+3t7eWwMDAkMvLzOhjZGajAAAAAAAAAAAAAAAAjIyM + Qfz8/P/6+vr/9/f3//T09f/y8vL/7+/w/+7u7v/19fX/9PT0//Pz8//x8fL/8PDw/+/v7//t7e7/7Ozs + /+bm5v+6urv/ubm6/8PDw//Dw8P/w8PD/8TExP/FxcX/xsbH/8fHx6jPz8+kz8/Q2m9vccYAAAAAAAAA + AAAAAACLi4tB/Pz8/+7u7//f3+D/1tbX/9DR0v/Mzc7/ysvM/83Nzv/Ozs//z8/Q/8/Q0P/P0NH/z8/Q + /87Oz//Nzc7/yMnK/7S0tv+9vb7/xsbH/8jIyf/Kysr/zMzM/87Oz//R0dH/1tbWt97e3rPU1NXjbW1v + vAAAAAAAAAAAAAAAAHh4eSypqqz8urq8/87Oz//a2tv/4uLj/+fn5//q6ur/8PDw/+7u7//t7e3/6+vr + /+np6f/n5+f/5eXm/+Pj5P/h4eH/rKyu/8rKy//T09P/09PT/9PT1P/T09P/0dLS/9PT1Pzk5OTC6Ojo + wc/P0PdUVVeHAAAAAAAAAAAAAAAAfX19Mfj4+Pr6+vr/9/f3//T09f/y8vL/7+/w/+7u7v/x8fL/8PDw + /+7u7v/s7Oz/6+vr/+np6f/n5+f/5eXm/+Tk5P+ysrP/ysrL/9HS0v/h4eH/4uLi/+Pj4//k5OX/5ubm + /O/v787g4ODin6Ci+EVFRyUAAAAAAAAAAAAAAACMjIxB/Pz8//r6+v/39/f/9PT1//Ly8v/v7/D/7u7u + //Pz8//x8fH/7+/w/+7u7v/s7Oz/6+vr/+np6f/n5+j/5ubm/9jY2f+io6X/z8/Q/9jY2P/r6+v/7Ozt + /+3t7f/r6+v/4ODg6rm5uv5NTlB3AAAAAAAAAAAAAAAAAAAAAIyMjEH8/Pz/+vr6//f39//09PX/8vLy + /+/v8P/u7u7/9PT0//Ly8//x8fH/7+/w/+7u7v/t7e3/6+vs/+rq6v/o6On/29vc/9jY2P+cnZ//t7e5 + /9HS0v/Y2Nn/2NjZ/87Ozv+cnJ72TU5QdEVFRwEAAAAAAAAAAAAAAAAAAAAAjIyMQfz8/P/6+vr/9/f3 + //T09f/y8vL/7+/w/+7u7v/19fX/9PT0//Ly8//x8fH/8PDw/+/v7//t7e7/7Ozs/+vr6//c3N3/39/f + /83Nzv+1trf/mpqc/5qanP+Xl5n/lpaY/05PUC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACLi4tB/f39 + //Hy8v/i4uP/2dna/9PU1f/Q0NH/zs7P/8/Q0f/P0NH/0NDR/9DR0v/Q0dL/0NDR/8/P0P/Ozs//zc3O + /8nJyv/Kysv/xMXG/8PDxf/CwsP/wcHD/8LCw//CwsT/a2tsFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AHh4eC+sra/9t7i6/8vMzf/X2Nj/39/g/+Tk5f/n6Oj/7u7u/+3t7v/s7O3/6urr/+np6f/n5+f/5eXl + /+Pj4//g4OH/1dXW/9DQ0f/Hx8j/wcHC/7q6vP+xsbP/pKWn/5ucnvdjZGQPAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAeXl6L/b29vn6+vr/9/f3//T09f/y8vL/7+/w/+7u7v/x8fL/8PDw/+7u7v/s7Oz/6urr + /+np6f/n5+f/5eXl/+Pj5P/Y2Nn/19fX/87Ozv/Ly8z/yMjJ/8bGx//Dw8T/t7e48WRkZQ8AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAACLi4tB/Pz8//r6+v/39/f/9PT1//Ly8v/v7/D/7u7u//Pz8//x8fH/7+/w + /+7u7v/s7Oz/6urr/+np6f/n5+j/5ubm/9ra2v/Z2dr/zs7O/8vLzP/IyMn/xsbH/8PDxP/CwsT/cHBx + FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIyMjEH8/Pz/+vr6//f39//09PX/8vLy/+/v8P/u7u7/9PT0 + //Ly8//x8fH/7+/w/+7u7v/s7O3/6+vs/+rq6v/o6On/29vc/9zc3P/Ozs7/y8vM/8jIyf/Gxsf/w8PE + /8LCxP9ycnMXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjIyMQfz8/P/6+vr/9/f3//T09f/y8vL/7+/w + /+7u7v/19fX/9PT0//Ly8//x8fH/8PDw/+/v7//t7e7/7Ozs/+vr6//c3N3/3t7f/87Ozv/Ly8z/yMjJ + /8bGx//Dw8T/wsLE/3JycxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMjIxB/Pz8//X19v/o6en/39/g + /9jY2f/T09T/0NDR/9HR0v/P0NH/z8/Q/87P0P/Ozs//zs7P/83Nz//Nzc7/zc3O/8nKy//LzM3/xsfI + /8bGyP/Gxsf/xcXH/8PDxf/CwsT/cnJyFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH19fjHa2tr+zMzN + /8zMzf/MzM3/zMzN/8zMzf/MzM3/zMzN/8zMzf/MzM3/zMzN/8zMzf/MzM3/zMzN/8zMzf/MzM3/zMzN + /8zMzf/MzM3/zMzN/8zMzf/MzM3/zMzN/8bGx/hnZ2cQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AICAgUeenp6dr6+w0c/Pz/La2tr+2dna/9nZ2f/Z2dn/2dnZ/9nZ2f/Z2dn/2dnZ/9nZ2f/Z2dn/2dnZ + /9nZ2f/Z2dn/2dnZ/9nZ2v/Z2tr+y8zM762trcucnJyVe3t7OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAaWlpBHJychJ9fX0mjo6ONH5+fjx9fX1AfX19QX5+fkF+fn5Bfn5+ + QX5+fkF9fX1BfX19P319fTuLi4wye3t7JHJychBra2sDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAD/+P////B///+AAf/wAAAP4AAAB+AAAAfgAAAH4AAAB+AAAAPgAAAB4AAA + AOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAAHgAAAB4AAAB+AAAAfgAAAH4AAAB+AAAAfgAAAH4AAA + B+AAAAfgAAAH8AAAD/4AAH///////////ygAAAAYAAAAMAAAAAEAIAAAAAAAYAkAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NjcSbm5wvU9PUWYAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABQUFJOzs7P/qChofxMTU5iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABra2sdmpqaWrCwsIG5ubmdvr6+sL+/v8DCwsLKsrK0 + +M3Nzv6fn6D8k5OU0bq6usmurq6+pqamr5ycnZuRkZJ+e3t8VVdXVxcAAAAAAAAAAAAAAAAAAAAAAAAA + AGhoaCf4+Pj7+fn5//X19f7x8fL/7u7u//Hx8f7w8PD/7e3t/7e3uf/Nzc7+oKCh/7i4uf7a2tr/0dHR + /8vLzP7IyMn/xMTF/7y8vvZSUlINAAAAAAAAAAAAAAAAAAAAAHJycjH8/Pz/+fn5//X19f7x8fL/7u7u + //Ly8/7x8fL/7+/w/+3t7f+2trj+zs7P/5+foP61tbb/0tLS/8vLzP7IyMn/xMTF/8LCw/5aWloRAAAA + AAAAAAAAAAAAAAAAAHJycjH8/Pz++Pj5/vX19f7x8fL+7u7u/vT09P7z8/P+8fHy/vDw8P7t7e7+tba3 + /s7Oz/6en6D+sbKz/svLzP7ExMT+u7u8/sDAwf5VVVYRAAAAAAAAAAAAAAAAAAAAAG9vbzHw8PH/2dna + /9HR0/7T1NX/1dXW/9ra2/7c3Nz/3Nzc/9vb3P/a2tr+19fY/6ipqv7AwML/q6us/7Kys/63t7j/tLW2 + /7Oztf5ra22QPDw+CwAAAAAAAAAAAAAAAGJiYh/S0tT97Ozs//T09P7y8vL/7u7u//Dw8f7v7+//7Ozt + /+rq6v/o6Oj+5eXm/+Li4v6vr7D/zs7P/7u7vP61tbb/s7S0/6amp/m3t7jQg4SGwjk5OwcAAAAAAAAA + AHBwcDH8/Pz++Pj5/vX19f7x8fL+7u7u/vLy8v7x8fH+7u7v/uzs7f7q6ur+6Ojo/ubm5v65ubr+vr6/ + /r+/wP68vL3+urq6/rm5uf6mpqZ5wcHC3lhZW20AAAAAAAAAAHJycjH8/Pz/+fn5//X19f7x8fL/7u7u + //Pz8/7y8vP/8fHx/+/v7//t7e3+6+vr/+jo6P67vL3/uLi5/7+/v/6+vr7/vr6+/7+/v/67u7uXxsbG + toGBg78AAAAAAAAAAHJycjH8/Pz/+Pj4/+/v8P7o6Oj/4+Pj/+bm5/7m5ub/5eXl/+Pk5P/i4uP+4eHi + /93d3f62trj/w8PD/8bGxv7Hx8j/ycnJ/8vLzP7Q0NCv1NTUvIiJitMAAAAAAAAAAGRkZCW+v8H9xMXG + /8/P0P7X19j/2tvc/+Dg4f7h4eL/4eHi/9/g4P/d3d7+29vb/9fX2P64ubr/xsbH/9DQ0P7R0dH/0dHS + /9PT1P3j4+O/3t7f1nV2d60AAAAAAAAAAGdnaCj5+fn8+Pj5/vX19f7x8fL+7u7u/vHx8f7w8PD+7e3u + /uvr6/7p6en+5ubn/uTk5f61tbb+zs7P/t/f4P7k5OT+5eXm/ufn5/3s7OzTwcHC9kpLTUUAAAAAAAAA + AHJycjH8/Pz/+fn5//X19f7x8fL/7u7u//Ly8/7x8fL/7+/w/+3t7v/r6+z+6enq/+fn6P7b29v/q6yt + /8vLzP7f4OD/5ubm/+Hh4f6/v8H5W1xdfwAAAAAAAAAAAAAAAHJycjH8/Pz++Pj5/vX19f7x8fL+7u7u + /vT09P7z8/P+8fHy/vDw8P7u7u7+7Ozt/uvr6/7f3+D+0tLT/q6ur/6oqKr+pqeo/qGho/5NTU9IAAAA + AAAAAAAAAAAAAAAAAG9vbzHv7+//19jZ/83Oz/7Nzs//0NDR/9XV1v7W19j/19fY/9bX1//V1tb+09TV + /9HS0/7LzM3/xcXG/76/wP66urz/urq7/7+/wP5UVFQRAAAAAAAAAAAAAAAAAAAAAF1dXRzJysv75ebm + //Hx8v7x8fL/7u7u//Dw8f7v7+//7Ozs/+rq6v/n5+j+5eXl/+Pj4/7Z2dn/0NDR/8vLzP7Gxsf/urq7 + /6OkpfNNTU4IAAAAAAAAAAAAAAAAAAAAAG9vbzH8/Pz++Pj5/vX19f7x8fL+7u7u/vLy8v7w8PH+7u7u + /uzs7P7q6ur+6Ojo/ubm5v7b29z+0dHS/svLzP7IyMn+xMTF/sLCw/5XV1cRAAAAAAAAAAAAAAAAAAAA + AHJycjH8/Pz/+fn5//X19f7x8fL/7u7u//Pz8/7y8vP/8PDx/+/v7//t7e3+6+vr/+np6f7e3t//0tLT + /8vLzP7IyMn/xMTF/8LCw/5aWloRAAAAAAAAAAAAAAAAAAAAAHJycjH8/Pz/+Pj5//Ly8v7p6ur/4+Pk + /+bm5v7l5eX/4+Pk/+Li4//h4eL+4ODg/9/f3/7Y2Nn/z8/Q/8rKy/7IyMn/xMTF/8LCw/5aWloRAAAA + AAAAAAAAAAAAAAAAAGhoaCfg4OD+z9DQ/snKy/7Jycr+ycnK/snJyv7Jycr+ycnK/snJyv7Jycr+ycnK + /snJyv7Jycr+ycnK/snJyv7Jysv+ysrL/sbGx/tTU1MNAAAAAAAAAAAAAAAAAAAAAAAAAACBgYFBoaKi + i6ysrLS1tbXPv7+/4MjIyenKysrtysrK7crKyu3KysrtysrK7crKyuzIyMjpvr6+37S0tM2rq6yxoaGh + hX19fjcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExMTAFGRkYCRkZG + AkZGRgJGRkYCRkZGAkZGRgJLS0sBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/j/8A/4f/AOAABwDAAAMAwAADAMAAAwDAAAEAwAAA + AMAAAADAAAAAwAAAAMAAAADAAAAAwAABAMAAAwDAAAMAwAADAMAAAwDAAAMAwAADAMAAAwDgAAcA/wD/ + AP///wAoAAAAEAAAACAAAAABACAAAAAAAEAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAWFhaXnN0dbIjIyQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUVFR + Hnx8fFCTk5NsoaGhfaamp7fBwcL/f4CBwqCgoIeTk5N8fn5/a2ZmZk5BQUEaAAAAAAAAAAAAAAAASEhI + HPn5+f329vb/8fHx//Dw8P/v7/D/1NXV/8HBwv+mp6j/1dXV/8zMzf/Hx8j/wMDB+zg4OAkAAAAAAAAA + AExMTCD7+/v/9vb2//Hx8f/x8fH/8vLz//Dw8P/U1NX/wcHC/6Ojpf/Ly8z/w8PE/8DAwf87OzsLAAAA + AAAAAABHR0cc2drb/tzc3f/e3t7/4ODh/+Li4v/g4OH/3t7e/8bGx/+6urv/tbW3/7O0tf+srK7+eXl7 + lyQkJQYAAAAASEhIHfv7+/729vb/8fHx//Dw8P/w8PD/7Ozt/+np6f/m5ub/vr/A/7u7vP+8vL3/uLi5 + /a6vr6JvcHGFAAAAAExMTCD7+/v/9vb2//Hx8f/x8fH/8vLz//Dw8P/t7e3/6enp/7i5uv/BwcH/wMDB + /8HBwv/Dw8Ocm5udywAAAABGRkYb09TV/tfX2P/Z2tr/3Nzd/97e3//d3d3/2trb/9bW1/+6urv/zc3O + /8/Pz//R0dL+4ODgu5mZm8cAAAAAR0dHHPr6+v329vb/8fHx//Dw8P/v7/D/7Ozs/+np6f/m5ub/vb6/ + /9bW1//n5+f/6enp/tra2uZcXF5lAAAAAExMTCD7+/v/9vb2//Hx8f/x8fH/8vLz//Dw8P/t7e3/6urr + /9vb3P+1trf/t7e5/7W1tv9cXV5mAAAAAAAAAABGRkYc1NXW/tfY2f/Z2tv/3N3d/97f3//d3d7/2tvb + /9fY2P/Ozs//xMTF/7u8vf+xsbP9NjY3CQAAAAAAAAAARkZGHPn5+f329vb/8fHx//Dw8P/v7/D/7Ozs + /+np6f/l5eb/2NjZ/8zMzf/Hx8j/wMDB+zc3OAkAAAAAAAAAAExMTCD7+/v/9vb2//Hx8f/x8fH/8vLz + //Dw8P/t7e3/6urq/9zc3f/MzM3/x8fI/8PDxP88PDwLAAAAAAAAAABHR0cc5ubm/tjY2P/R0dL/zs7P + /83Nzv/Nzc7/zM3O/8zMzf/Ly8z/ycnK/8nJyv/Gxsf9ODg5CQAAAAAAAAAAAAAAAGhpaTmUlJRyqKip + ja+vsJurq6ufq6uroKurq6Crq6ufrq+vm6ioqIyUlJRvZ2dnMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPx/AADAAwAAgAEA + AIABAACAAAAAgAAAAIAAAACAAAAAgAAAAIABAACAAQAAgAEAAIABAACAAQAAwAMAAP//AAA= + + + \ No newline at end of file diff --git a/WmiExplorer/app.config b/WmiExplorer/app.config new file mode 100644 index 0000000..59d4371 --- /dev/null +++ b/WmiExplorer/app.config @@ -0,0 +1,76 @@ + + + + +
+ + +
+ + + + + + False + + + True + + + True + + + True + + + False + + + True + + + 60 + + + None + + + 1970-01-01 + + + 220 + + + 200 + + + 180 + + + 7 + + + https://github.com/vinaypamnani/wmie2/releases + + + + + + True + + + True + + + + + + + https://raw.githubusercontent.com/vinaypamnani/wmie2/master/WmiExplorer/releases.xml + + + http://wmie.azurewebsites.net/releases.xml + + + + \ No newline at end of file diff --git a/WmiExplorer/releases.azure.xml b/WmiExplorer/releases.azure.xml new file mode 100644 index 0000000..b890db3 --- /dev/null +++ b/WmiExplorer/releases.azure.xml @@ -0,0 +1,17 @@ + + + WMI Explorer + https://github.com/vinaypamnani/wmie2/releases + 2017-10-05T00:00:00Z + + Vinay Pamnani + + + https://github.com/vinaypamnani/wmie2/releases + 2.0.0.2 + 2017-10-05T00:00:00Z + + + + + \ No newline at end of file diff --git a/WmiExplorer/releases.xml b/WmiExplorer/releases.xml new file mode 100644 index 0000000..9ae6d06 --- /dev/null +++ b/WmiExplorer/releases.xml @@ -0,0 +1,17 @@ + + + WMI Explorer + https://github.com/vinaypamnani/wmie2/releases + 2017-10-05T00:00:00Z + + Vinay Pamnani + + + https://github.com/vinaypamnani/wmie2/releases + 2.0.0.2 + 2017-10-05T00:00:00Z + + + + + \ No newline at end of file

~li@LhZwRo2FiC4G8Pt(s<{n$PoJUa5g4oygl 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�P(^Sn;kBS(Jr( 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 literal 0 HcmV?d00001 diff --git a/WmiExplorer/Program.cs b/WmiExplorer/Program.cs new file mode 100644 index 0000000..a0b7cce --- /dev/null +++ b/WmiExplorer/Program.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows.Forms; + +namespace WmiExplorer +{ + static class Program + { + ///