diff --git a/BorderlessGaming.Logic/Core/ProcessWatcher.cs b/BorderlessGaming.Logic/Core/ProcessWatcher.cs index ff24970..592870f 100644 --- a/BorderlessGaming.Logic/Core/ProcessWatcher.cs +++ b/BorderlessGaming.Logic/Core/ProcessWatcher.cs @@ -58,7 +58,7 @@ private async void Watch() { while (!_watcherToken.IsCancellationRequested) { - UpdateProcesses(); + await UpdateProcesses(); if (AutoHandleFavorites) { // check favorites against the cache @@ -73,7 +73,7 @@ private async void Watch() { favProcess.IsRunning = true; favProcess.RunningId = pd.Proc.Id; - RemoveBorder(pd, favProcess); + await RemoveBorder(pd, favProcess); } } } @@ -90,56 +90,56 @@ private async void Watch() /// /// remove the menu, resize the window, remove border, and maximize /// - public void RemoveBorder(ProcessDetails pd, Favorite favDetails = null, bool overrideTimeout = false) + public async Task RemoveBorder(ProcessDetails pd, Favorite favDetails = null, bool overrideTimeout = false) { if (favDetails != null && favDetails.DelayBorderless && overrideTimeout == false) { //Wait 10 seconds before removing the border. - var task = new Task(() => RemoveBorder(pd, favDetails, true)); + var task = new Task(async () => await RemoveBorder(pd, favDetails, true)); task.Wait(TimeSpan.FromSeconds(10)); } // If a Favorite screen exists, use the Rect from that, instead if (favDetails?.FavScreen != null) { - RemoveBorder_ToSpecificRect(pd, PRectangle.ToRectangle(favDetails.FavScreen), favDetails, + await RemoveBorder_ToSpecificRect(pd, PRectangle.ToRectangle(favDetails.FavScreen), favDetails, overrideTimeout); return; } - Manipulation.MakeWindowBorderless(pd, _form, pd.WindowHandle, new Rectangle(), favDetails ?? Favorite.FromWindow(pd)); + await Manipulation.MakeWindowBorderless(pd, _form, pd.WindowHandle, new Rectangle(), favDetails ?? Favorite.FromWindow(pd)); } /// /// remove the menu, resize the window, remove border, and maximize /// - public void RemoveBorder_ToSpecificScreen(IntPtr hWnd, Screen screen, Favorite favDetails = null, + public async Task RemoveBorder_ToSpecificScreen(IntPtr hWnd, Screen screen, Favorite favDetails = null, bool overrideTimeout = false) { if (favDetails != null && favDetails.DelayBorderless && overrideTimeout == false) { //Wait 10 seconds before removing the border. - var task = new Task(() => RemoveBorder_ToSpecificScreen(hWnd, screen, favDetails, true)); + var task = new Task(async () => await RemoveBorder_ToSpecificScreen(hWnd, screen, favDetails, true)); task.Wait(TimeSpan.FromSeconds(10)); } var pd = FromHandle(hWnd); - Manipulation.MakeWindowBorderless(pd, _form, hWnd, screen.Bounds, favDetails ?? Favorite.FromWindow(pd)); + await Manipulation.MakeWindowBorderless(pd, _form, hWnd, screen.Bounds, favDetails ?? Favorite.FromWindow(pd)); } /// /// remove the menu, resize the window, remove border, and maximize /// - public void RemoveBorder_ToSpecificRect(IntPtr hWnd, Rectangle targetFrame, Favorite favDetails = null, + public async Task RemoveBorder_ToSpecificRect(IntPtr hWnd, Rectangle targetFrame, Favorite favDetails = null, bool overrideTimeout = false) { if (favDetails != null && favDetails.DelayBorderless && overrideTimeout == false) { //Wait 10 seconds before removing the border. - var task = new Task(() => RemoveBorder_ToSpecificRect(hWnd, targetFrame, favDetails, true)); + var task = new Task(async () => await RemoveBorder_ToSpecificRect(hWnd, targetFrame, favDetails, true)); task.Wait(TimeSpan.FromSeconds(10)); } var pd = FromHandle(hWnd); - Manipulation.MakeWindowBorderless(pd, _form, hWnd, targetFrame, favDetails ?? Favorite.FromWindow(pd)); + await Manipulation.MakeWindowBorderless(pd, _form, hWnd, targetFrame, favDetails ?? Favorite.FromWindow(pd)); } /// @@ -167,7 +167,7 @@ private void HandlePrunedProcess(ProcessDetails pd) } } - private void UpdateProcesses() + private async Task UpdateProcesses() { if (!AutoHandleFavorites) { @@ -189,7 +189,7 @@ private void UpdateProcesses() if (!process.NoAccess) { - TaskUtilities.StartTaskAndWait(() => { currentTitle = Native.GetWindowTitle(process.WindowHandle); }, + await TaskUtilities.StartTaskAndWait(() => { currentTitle = Native.GetWindowTitle(process.WindowHandle); }, Config.Instance.AppSettings.SlowWindowDetection ? 10 : 2); shouldBePruned = process.WindowTitle != currentTitle; } } diff --git a/BorderlessGaming.Logic/Models/ProcessDetails.cs b/BorderlessGaming.Logic/Models/ProcessDetails.cs index a407f64..2969611 100644 --- a/BorderlessGaming.Logic/Models/ProcessDetails.cs +++ b/BorderlessGaming.Logic/Models/ProcessDetails.cs @@ -2,6 +2,7 @@ using System.ComponentModel; using System.Diagnostics; using System.Drawing; +using System.Threading.Tasks; using BorderlessGaming.Logic.System.Utilities; using BorderlessGaming.Logic.Windows; @@ -28,12 +29,18 @@ public ProcessDetails(Process p, IntPtr hWnd) Proc = p; WindowHandle = hWnd; - WindowTitle = ""; - TaskUtilities.StartTaskAndWait(() => { WindowTitle = Native.GetWindowTitle(WindowHandle); }, - Config.Instance.AppSettings.SlowWindowDetection ? 10 : 2); + WindowTitle = Native.GetWindowTitle(WindowHandle); + // GetWindowTitle(); + //this.WindowClass = WindowsAPI.Native.GetWindowClassName(this.WindowHandle); // note: this isn't used, currently } + private async void GetWindowTitle() + { + await TaskUtilities.StartTaskAndWait(() => { WindowTitle = Native.GetWindowTitle(WindowHandle); }, + Config.Instance.AppSettings.SlowWindowDetection ? 10 : 2); + } + // Automatically detects changes to the window handle public IntPtr WindowHandle { @@ -48,7 +55,7 @@ public IntPtr WindowHandle if (!Native.IsWindow(_windowHandle)) { - _windowHandle = Native.GetMainWindowForProcess(Proc); + _windowHandle = Native.GetMainWindowForProcess(Proc).GetAwaiter().GetResult(); } } catch @@ -112,22 +119,16 @@ public string BinaryName private string BinaryNameForComparison => BinaryName.Trim().ToLower().Replace(" ", "").Replace("_", ""); // Detect whether or not the window needs border changes - public bool WindowHasTargetableStyles + public async Task WindowHasTargetableStyles() { - get - { - var targetable = false; - TaskUtilities.StartTaskAndWait(() => - { - var styleCurrentWindowStandard = Native.GetWindowLong(WindowHandle, WindowLongIndex.Style); - var styleCurrentWindowExtended = Native.GetWindowLong(WindowHandle, WindowLongIndex.ExtendedStyle); - targetable = styleCurrentWindowStandard.HasTargetStyles() || - styleCurrentWindowExtended.HasExtendedStyles(); - }, Config.Instance.AppSettings.SlowWindowDetection - ? 10 - : 2); - return targetable; - } + var targetable = false; + await TaskUtilities.StartTaskAndWait(() => + { + var styleCurrentWindowStandard = Native.GetWindowLong(WindowHandle, WindowLongIndex.Style); + var styleCurrentWindowExtended = Native.GetWindowLong(WindowHandle, WindowLongIndex.ExtendedStyle); + targetable = styleCurrentWindowStandard.HasTargetStyles() || styleCurrentWindowExtended.HasExtendedStyles(); + }, Config.Instance.AppSettings.SlowWindowDetection ? 10 : 2); + return targetable; } public override string ToString() // so that the ListView control knows how to display this object to the user diff --git a/BorderlessGaming.Logic/System/Utilities/TaskUtilities.cs b/BorderlessGaming.Logic/System/Utilities/TaskUtilities.cs index 30e9e22..3cd63cb 100644 --- a/BorderlessGaming.Logic/System/Utilities/TaskUtilities.cs +++ b/BorderlessGaming.Logic/System/Utilities/TaskUtilities.cs @@ -9,27 +9,27 @@ namespace BorderlessGaming.Logic.System.Utilities { public static class TaskUtilities { - public static void StartTaskAndWait(Action target) + public static async Task StartTaskAndWait(Action target) { - StartTaskAndWait(target, 0); + await StartTaskAndWait(target, 0); } - public static void WaitAndStartTask(Action target, int iHowLongToWait) + public static async Task WaitAndStartTaskAsync(Action target, int iHowLongToWait) { var ts = new CancellationTokenSource(); var ct = ts.Token; - Task.Run(async () => + await Task.Run(async () => { await Task.Delay(TimeSpan.FromSeconds(iHowLongToWait), ct); target(); - }, ct).Wait(ct); + }, ct); } - public static void StartTaskAndWait(Action target, int iHowLongToWait) + public static async Task StartTaskAndWait(Action target, int iHowLongToWait) { try { - Task.Run(async () => + await Task.Run(async () => { var ts = new CancellationTokenSource(); var ct = ts.Token; @@ -41,6 +41,7 @@ public static void StartTaskAndWait(Action target, int iHowLongToWait) { break; } + if (iHowLongToWait > 0) { if ((DateTime.Now - dtStartTime).TotalSeconds > iHowLongToWait) @@ -53,13 +54,15 @@ public static void StartTaskAndWait(Action target, int iHowLongToWait) { // ignored } + break; } } + await Task.Delay(15, ct); //MainWindow.DoEvents(); } - }).Wait(); + }); } catch (Exception) { diff --git a/BorderlessGaming.Logic/Windows/Manipulation.cs b/BorderlessGaming.Logic/Windows/Manipulation.cs index 0a6512e..807f1bd 100644 --- a/BorderlessGaming.Logic/Windows/Manipulation.cs +++ b/BorderlessGaming.Logic/Windows/Manipulation.cs @@ -3,6 +3,7 @@ using System.Drawing; using System.IO; using System.Linq; +using System.Threading.Tasks; using System.Windows.Forms; using BorderlessGaming.Logic.Models; using BorderlessGaming.Logic.Properties; @@ -30,12 +31,12 @@ public static class Manipulation /// /// remove the menu, resize the window, remove border, and maximize /// - public static void MakeWindowBorderless(ProcessDetails processDetails, Form frmMain, IntPtr targetWindow, + public static async Task MakeWindowBorderless(ProcessDetails processDetails, Form frmMain, IntPtr targetWindow, Rectangle targetFrame, Favorite favDetails) { if (NeedsDelay(targetWindow)) { - MakeWindowBorderlessDelayed(processDetails, frmMain, targetWindow, targetFrame, favDetails); + await MakeWindowBorderlessDelayed(processDetails, frmMain, targetWindow, targetFrame, favDetails); } else { @@ -49,7 +50,7 @@ public static void MakeWindowBorderless(ProcessDetails processDetails, Form frmM { if (processDetails.MadeBorderless) { - if (processDetails.MadeBorderlessAttempts > 3 || !processDetails.WindowHasTargetableStyles) + if (processDetails.MadeBorderlessAttempts > 3 || ! await processDetails.WindowHasTargetableStyles()) { return; } @@ -218,7 +219,7 @@ public static void MakeWindowBorderless(ProcessDetails processDetails, Form frmM } } - private static void MakeWindowBorderlessDelayed(ProcessDetails processDetails, Form frmMain, + private static async Task MakeWindowBorderlessDelayed(ProcessDetails processDetails, Form frmMain, IntPtr targetWindow, Rectangle targetFrame, Favorite favDetails) { // Automatically match a window to favorite details, if that information is available. @@ -231,7 +232,7 @@ private static void MakeWindowBorderlessDelayed(ProcessDetails processDetails, F { if (processDetails.MadeBorderless) { - if (processDetails.MadeBorderlessAttempts > 3 || !processDetails.WindowHasTargetableStyles) + if (processDetails.MadeBorderlessAttempts > 3 || ! await processDetails.WindowHasTargetableStyles()) { return; } @@ -374,7 +375,7 @@ private static void MakeWindowBorderlessDelayed(ProcessDetails processDetails, F ); } //wait before applying styles - TaskUtilities.WaitAndStartTask(() => + await TaskUtilities.WaitAndStartTaskAsync(() => { Native.SetWindowLong(targetWindow, WindowLongIndex.Style, styleNewWindowStandard); Native.SetWindowLong(targetWindow, WindowLongIndex.ExtendedStyle, styleNewWindowExtended); diff --git a/BorderlessGaming.Logic/Windows/Native.cs b/BorderlessGaming.Logic/Windows/Native.cs index e651ce7..36a8dd8 100644 --- a/BorderlessGaming.Logic/Windows/Native.cs +++ b/BorderlessGaming.Logic/Windows/Native.cs @@ -6,6 +6,7 @@ using System.Linq; using System.Runtime.InteropServices; using System.Text; +using System.Threading.Tasks; using BorderlessGaming.Logic.Models; using BorderlessGaming.Logic.System.Utilities; using BorderlessGaming.Logic.Windows.Audio; @@ -219,6 +220,7 @@ public static string GetWindowTitle(IntPtr hWnd) var length = (int) SendMessage(hWnd, WM_GETTEXTLENGTH, IntPtr.Zero, IntPtr.Zero); var sbWindowTitle = new StringBuilder(length + 1); SendMessage(hWnd, WM_GETTEXT, (IntPtr) sbWindowTitle.Capacity, sbWindowTitle); + Console.WriteLine(sbWindowTitle.ToString()); return sbWindowTitle.ToString(); } @@ -350,7 +352,7 @@ private static bool GetMainWindowForProcess_EnumWindows(IntPtr hWndEnumerated, u /// /// /// - public static IntPtr GetMainWindowForProcess(Process process) + public static async Task GetMainWindowForProcess(Process process) { if (Config.Instance.AppSettings.SlowWindowDetection) { @@ -358,27 +360,23 @@ public static IntPtr GetMainWindowForProcess(Process process) { var hMainWindow = IntPtr.Zero; - lock (GetMainWindowForProcess_Locker) + GetMainWindowForProcess_Value = IntPtr.Zero; + await TaskUtilities.StartTaskAndWait(() => { - GetMainWindowForProcess_Value = IntPtr.Zero; - TaskUtilities.StartTaskAndWait(() => + for (uint i = 0; i <= 1; i++) { - for (uint i = 0; i <= 1; i++) + foreach (ProcessThread thread in process.Threads) { - foreach (ProcessThread thread in process.Threads) + if (GetMainWindowForProcess_Value != IntPtr.Zero) { - if (GetMainWindowForProcess_Value != IntPtr.Zero) - { - break; - } - - EnumThreadWindows(thread.Id, GetMainWindowForProcess_EnumWindows, i); + break; } - } - }); - hMainWindow = GetMainWindowForProcess_Value; - } + EnumThreadWindows(thread.Id, GetMainWindowForProcess_EnumWindows, i); + } + } + }); + hMainWindow = GetMainWindowForProcess_Value; if (hMainWindow != IntPtr.Zero) { return hMainWindow; diff --git a/BorderlessGaming/BorderlessGaming.csproj b/BorderlessGaming/BorderlessGaming.csproj index 1513d06..9462ffa 100644 --- a/BorderlessGaming/BorderlessGaming.csproj +++ b/BorderlessGaming/BorderlessGaming.csproj @@ -109,6 +109,9 @@ AboutForm.cs Designer + + AboutForm.cs + AboutForm.cs Designer diff --git a/BorderlessGaming/Forms/AboutForm.Designer.cs b/BorderlessGaming/Forms/AboutForm.Designer.cs index a03043a..18ee83e 100644 --- a/BorderlessGaming/Forms/AboutForm.Designer.cs +++ b/BorderlessGaming/Forms/AboutForm.Designer.cs @@ -43,29 +43,29 @@ private void InitializeComponent() this._dmxtNameTag = new System.Windows.Forms.Label(); this._impulserGithubGlobe = new System.Windows.Forms.PictureBox(); this._impulserNameTag = new System.Windows.Forms.Label(); - this._stackOfPancakesGithubGlobe = new System.Windows.Forms.PictureBox(); - this._stackOfPancakesNameTag = new System.Windows.Forms.Label(); this._copyrightLabel = new System.Windows.Forms.Label(); this._steamGroupLabel = new System.Windows.Forms.Label(); this._viewSteamGroupLinkLabel = new System.Windows.Forms.LinkLabel(); - this._codeusaSoftwareLogo = new System.Windows.Forms.PictureBox(); this._madpewGithubGlobe = new System.Windows.Forms.PictureBox(); this._madpewNametag = new System.Windows.Forms.Label(); this._psouza4Nametag = new System.Windows.Forms.Label(); this._psouza4GithubGlobe = new System.Windows.Forms.PictureBox(); - this.pictureBox2 = new System.Windows.Forms.PictureBox(); this._SecretOnlineNametag = new System.Windows.Forms.Label(); this._SecretOnlineGithubGlobe = new System.Windows.Forms.PictureBox(); + this.pictureBox2 = new System.Windows.Forms.PictureBox(); + this._codeusaSoftwareLogo = new System.Windows.Forms.PictureBox(); + this._stackOfPancakesNameTag = new System.Windows.Forms.Label(); + this._stackOfPancakesGithubGlobe = new System.Windows.Forms.PictureBox(); ((System.ComponentModel.ISupportInitialize)(this._ownerGithubGlobe)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this._dmxtGithubGlobe)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this._impulserGithubGlobe)).BeginInit(); - ((System.ComponentModel.ISupportInitialize)(this._stackOfPancakesGithubGlobe)).BeginInit(); - ((System.ComponentModel.ISupportInitialize)(this._codeusaSoftwareLogo)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this._madpewGithubGlobe)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this._psouza4GithubGlobe)).BeginInit(); - ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this._SecretOnlineGithubGlobe)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this._codeusaSoftwareLogo)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this._stackOfPancakesGithubGlobe)).BeginInit(); this.SuspendLayout(); // // versionLabel @@ -156,19 +156,6 @@ private void InitializeComponent() this._impulserNameTag.Name = "_impulserNameTag"; this._impulserNameTag.Click += new System.EventHandler(this._impulserNameTag_Click); // - // _stackOfPancakesGithubGlobe - // - resources.ApplyResources(this._stackOfPancakesGithubGlobe, "_stackOfPancakesGithubGlobe"); - this._stackOfPancakesGithubGlobe.Cursor = System.Windows.Forms.Cursors.Hand; - this._stackOfPancakesGithubGlobe.Name = "_stackOfPancakesGithubGlobe"; - this._stackOfPancakesGithubGlobe.TabStop = false; - this._stackOfPancakesGithubGlobe.Click += new System.EventHandler(this.OpenStackOfPancakesGithub); - // - // _stackOfPancakesNameTag - // - resources.ApplyResources(this._stackOfPancakesNameTag, "_stackOfPancakesNameTag"); - this._stackOfPancakesNameTag.Name = "_stackOfPancakesNameTag"; - // // _copyrightLabel // resources.ApplyResources(this._copyrightLabel, "_copyrightLabel"); @@ -186,12 +173,6 @@ private void InitializeComponent() this._viewSteamGroupLinkLabel.TabStop = true; this._viewSteamGroupLinkLabel.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.OpenSteamGroup); // - // _codeusaSoftwareLogo - // - resources.ApplyResources(this._codeusaSoftwareLogo, "_codeusaSoftwareLogo"); - this._codeusaSoftwareLogo.Name = "_codeusaSoftwareLogo"; - this._codeusaSoftwareLogo.TabStop = false; - // // _madpewGithubGlobe // resources.ApplyResources(this._madpewGithubGlobe, "_madpewGithubGlobe"); @@ -218,14 +199,6 @@ private void InitializeComponent() this._psouza4GithubGlobe.TabStop = false; this._psouza4GithubGlobe.Click += new System.EventHandler(this.OpenPsouza4Github); // - // pictureBox2 - // - resources.ApplyResources(this.pictureBox2, "pictureBox2"); - this.pictureBox2.Cursor = System.Windows.Forms.Cursors.Hand; - this.pictureBox2.Name = "pictureBox2"; - this.pictureBox2.TabStop = false; - this.pictureBox2.Click += new System.EventHandler(this.OpenPsouza4Steam); - // // _SecretOnlineNametag // resources.ApplyResources(this._SecretOnlineNametag, "_SecretOnlineNametag"); @@ -239,6 +212,33 @@ private void InitializeComponent() this._SecretOnlineGithubGlobe.TabStop = false; this._SecretOnlineGithubGlobe.Click += new System.EventHandler(this.OpenSecretOnlineGithub); // + // pictureBox2 + // + resources.ApplyResources(this.pictureBox2, "pictureBox2"); + this.pictureBox2.Cursor = System.Windows.Forms.Cursors.Hand; + this.pictureBox2.Name = "pictureBox2"; + this.pictureBox2.TabStop = false; + this.pictureBox2.Click += new System.EventHandler(this.OpenPsouza4Steam); + // + // _codeusaSoftwareLogo + // + resources.ApplyResources(this._codeusaSoftwareLogo, "_codeusaSoftwareLogo"); + this._codeusaSoftwareLogo.Name = "_codeusaSoftwareLogo"; + this._codeusaSoftwareLogo.TabStop = false; + // + // _stackOfPancakesNameTag + // + resources.ApplyResources(this._stackOfPancakesNameTag, "_stackOfPancakesNameTag"); + this._stackOfPancakesNameTag.Name = "_stackOfPancakesNameTag"; + // + // _stackOfPancakesGithubGlobe + // + resources.ApplyResources(this._stackOfPancakesGithubGlobe, "_stackOfPancakesGithubGlobe"); + this._stackOfPancakesGithubGlobe.Cursor = System.Windows.Forms.Cursors.Hand; + this._stackOfPancakesGithubGlobe.Name = "_stackOfPancakesGithubGlobe"; + this._stackOfPancakesGithubGlobe.TabStop = false; + this._stackOfPancakesGithubGlobe.Click += new System.EventHandler(this.OpenStackOfPancakesGithub); + // // AboutForm // resources.ApplyResources(this, "$this"); @@ -279,12 +279,12 @@ private void InitializeComponent() ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this._dmxtGithubGlobe)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this._impulserGithubGlobe)).EndInit(); - ((System.ComponentModel.ISupportInitialize)(this._stackOfPancakesGithubGlobe)).EndInit(); - ((System.ComponentModel.ISupportInitialize)(this._codeusaSoftwareLogo)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this._madpewGithubGlobe)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this._psouza4GithubGlobe)).EndInit(); - ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this._SecretOnlineGithubGlobe)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this._codeusaSoftwareLogo)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this._stackOfPancakesGithubGlobe)).EndInit(); this.ResumeLayout(false); this.PerformLayout(); @@ -306,18 +306,18 @@ private void InitializeComponent() private System.Windows.Forms.Label _dmxtNameTag; private System.Windows.Forms.PictureBox _impulserGithubGlobe; private System.Windows.Forms.Label _impulserNameTag; - private System.Windows.Forms.PictureBox _stackOfPancakesGithubGlobe; - private System.Windows.Forms.Label _stackOfPancakesNameTag; private System.Windows.Forms.Label _copyrightLabel; private System.Windows.Forms.Label _steamGroupLabel; private System.Windows.Forms.LinkLabel _viewSteamGroupLinkLabel; - private System.Windows.Forms.PictureBox _codeusaSoftwareLogo; private System.Windows.Forms.PictureBox _madpewGithubGlobe; private System.Windows.Forms.Label _madpewNametag; private System.Windows.Forms.Label _psouza4Nametag; private System.Windows.Forms.PictureBox _psouza4GithubGlobe; - private System.Windows.Forms.PictureBox pictureBox2; private System.Windows.Forms.Label _SecretOnlineNametag; private System.Windows.Forms.PictureBox _SecretOnlineGithubGlobe; + private System.Windows.Forms.PictureBox pictureBox2; + private System.Windows.Forms.PictureBox _codeusaSoftwareLogo; + private System.Windows.Forms.Label _stackOfPancakesNameTag; + private System.Windows.Forms.PictureBox _stackOfPancakesGithubGlobe; } } \ No newline at end of file diff --git a/BorderlessGaming/Forms/AboutForm.en-US.resx b/BorderlessGaming/Forms/AboutForm.en-US.resx new file mode 100644 index 0000000..ddce3d1 --- /dev/null +++ b/BorderlessGaming/Forms/AboutForm.en-US.resx @@ -0,0 +1,1098 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + 5, 33 + + + 41, 13 + + + 5, 49 + + + 31, 13 + + + 75, 33 + + + 235, 13 + + + 75, 49 + + + 109, 13 + + + 6, 91 + + + 64, 13 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAMoSURBVDhPjY9dSJNhGIbftg6S8CAoJBWMnPhTkBlk + mWVpNCu0PygTkyLKUosym1GY2Y/p5lzNv+Z0UxuWmjV1pk0tdFrM6VZuK3/KnOS0voNWQcgOvPvereig + k164efie57ov+Agn8xXhZBkI98Y44d62LeIKp7dzRXYhm0dsOn9PoWtP7yxHedoDQP4Kro+uYI+ycLnN + dK3XxlS+mZqrs07O19t1cyLLIBOpGjHRO+X+FQj0KzxzDOpTT97ZS00GKKdbUW78gJL+z6iZ7MZ9pgl1 + TDMu9vXbKUf5v4KUNg9OqlZx9JFuJqPrOQrfP0DVbCPKjG9RYX4Npa0dlfZGSGcUENrLcLpbM0N52nMJ + FiTV8QMvtVoTayw43KSDwCqHoGsAl9snkW9tgXhWhjNPtMg0l+Ds1FVkTuSDl9lmpT23YF+5NE55/+tG + uQbRFWbE1Zhx8MEYEuvHkaR+gf2KLuwQdyBxJAO7X2YhSl2IuEr1V9pzCQi/oCNed8W5WlmMNWIDwsuH + sanCgs1sIqRD2PIsFzHjBxFpSkKItBRB+RrwpXon7bkF23L167OfzvNa0uGf14NA0SCCC40IERtZWA+e + RAH/mvMIHIjF8rRm+JWLEFHQOU97bsHWa8/WSqqdfjn9rMCAgAIjAoW/kz8E/5w++KrS4PMyEsvO3YP3 + 8CqEdiU4ac8tiLlVEixocQTkmRAkMmN1kQWhEgvC7lpdWSMyIaBKAj+xEF5Nu7DUwIN//QEH7bkFseKd + S5Jqx8IkY2zhPSJKJxAt+wh+5UfEVk1ih3wCUcWjCMvVwbsnCL49IfBMF4zRnlsQX+ZB9spUQdl6Jlo2 + g/jqzzhc9wVHGxgcb2RcM0E1C37ROwS3r8NyaSJDedpzCw7VEpKgWrnwSIM27LaFSX7oQJr6Oy5ofkDQ + 9sM1Ux87kCCzgXcnheEmK7WUpz23gD6vEPZXbq4kx5pVvoL+0T3yaUdq0zfnRc3PeTr3VHxy+GT0jtK7 + i6M8+/4IuGyWsQkmnl4byMaTJ0hyg4Kc7OgkKVq9a9Jvuqd3Qmib8tw/Ag6bxWzo0vs/QjnKcwCQXyFm + FkJonTZMAAAAAElFTkSuQmCC + + + + + NoControl + + + 9, 107 + + + 16, 18 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAVtJREFUOE9j + GAXEA15e3nBhYeFXIiIi/wUFBbdwcXFJQ6UIA6BmAwkJiV9xcXGT582bl6+np3dITExsD1SagYGTkzOZ + h4fnG1DhKyDbGCoMBwoKCrVATRf+//+vAMR8U6dODQEa8B+ohxOsQEhI6NW1a9dCDQ0NjwLZD4DOEwVL + QIGamtoqWVnZN0BNQiC+qqpqlqSk5AegYcxgBUCB00D/HRcXF/8KNOA/Pz//I6AhpUDXhPPx8bUA/f1X + VFT0P1DNN6D/LwHl/8THx3eANYPAxYsXHRwdHaeGhoZOiYyMnGJubr4O6LzvQPxfWlr6KNDgD0CN/9XV + 1c84ODjMmTJlSh7QdkQgAjksQKwMxCA/ygOxdkNDQyk3N/fvHTt2eAANXKuoqHgRKG4OxKpAzAfVihsA + FQnFxMR0s7CwvAB65Vl1dXUiVIp4ADREGojdgNgFiPmhwsMLMDAAALg0hCFEe1vEAAAAAElFTkSuQmCC + + + + 32, 108 + + + 15, 16 + + + 60, 111 + + + 158, 13 + + + 6, 155 + + + 66, 13 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAMoSURBVDhPjY9dSJNhGIbftg6S8CAoJBWMnPhTkBlk + mWVpNCu0PygTkyLKUosym1GY2Y/p5lzNv+Z0UxuWmjV1pk0tdFrM6VZuK3/KnOS0voNWQcgOvPvereig + k164efie57ov+Agn8xXhZBkI98Y44d62LeIKp7dzRXYhm0dsOn9PoWtP7yxHedoDQP4Kro+uYI+ycLnN + dK3XxlS+mZqrs07O19t1cyLLIBOpGjHRO+X+FQj0KzxzDOpTT97ZS00GKKdbUW78gJL+z6iZ7MZ9pgl1 + TDMu9vXbKUf5v4KUNg9OqlZx9JFuJqPrOQrfP0DVbCPKjG9RYX4Npa0dlfZGSGcUENrLcLpbM0N52nMJ + FiTV8QMvtVoTayw43KSDwCqHoGsAl9snkW9tgXhWhjNPtMg0l+Ds1FVkTuSDl9lmpT23YF+5NE55/+tG + uQbRFWbE1Zhx8MEYEuvHkaR+gf2KLuwQdyBxJAO7X2YhSl2IuEr1V9pzCQi/oCNed8W5WlmMNWIDwsuH + sanCgs1sIqRD2PIsFzHjBxFpSkKItBRB+RrwpXon7bkF23L167OfzvNa0uGf14NA0SCCC40IERtZWA+e + RAH/mvMIHIjF8rRm+JWLEFHQOU97bsHWa8/WSqqdfjn9rMCAgAIjAoW/kz8E/5w++KrS4PMyEsvO3YP3 + 8CqEdiU4ac8tiLlVEixocQTkmRAkMmN1kQWhEgvC7lpdWSMyIaBKAj+xEF5Nu7DUwIN//QEH7bkFseKd + S5Jqx8IkY2zhPSJKJxAt+wh+5UfEVk1ih3wCUcWjCMvVwbsnCL49IfBMF4zRnlsQX+ZB9spUQdl6Jlo2 + g/jqzzhc9wVHGxgcb2RcM0E1C37ROwS3r8NyaSJDedpzCw7VEpKgWrnwSIM27LaFSX7oQJr6Oy5ofkDQ + 9sM1Ux87kCCzgXcnheEmK7WUpz23gD6vEPZXbq4kx5pVvoL+0T3yaUdq0zfnRc3PeTr3VHxy+GT0jtK7 + i6M8+/4IuGyWsQkmnl4byMaTJ0hyg4Kc7OgkKVq9a9Jvuqd3Qmib8tw/Ag6bxWzo0vs/QjnKcwCQXyFm + FkJonTZMAAAAAElFTkSuQmCC + + + + 9, 170 + + + 16, 18 + + + 60, 173 + + + 64, 13 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAMoSURBVDhPjY9dSJNhGIbftg6S8CAoJBWMnPhTkBlk + mWVpNCu0PygTkyLKUosym1GY2Y/p5lzNv+Z0UxuWmjV1pk0tdFrM6VZuK3/KnOS0voNWQcgOvPvereig + k164efie57ov+Agn8xXhZBkI98Y44d62LeIKp7dzRXYhm0dsOn9PoWtP7yxHedoDQP4Kro+uYI+ycLnN + dK3XxlS+mZqrs07O19t1cyLLIBOpGjHRO+X+FQj0KzxzDOpTT97ZS00GKKdbUW78gJL+z6iZ7MZ9pgl1 + TDMu9vXbKUf5v4KUNg9OqlZx9JFuJqPrOQrfP0DVbCPKjG9RYX4Npa0dlfZGSGcUENrLcLpbM0N52nMJ + FiTV8QMvtVoTayw43KSDwCqHoGsAl9snkW9tgXhWhjNPtMg0l+Ds1FVkTuSDl9lmpT23YF+5NE55/+tG + uQbRFWbE1Zhx8MEYEuvHkaR+gf2KLuwQdyBxJAO7X2YhSl2IuEr1V9pzCQi/oCNed8W5WlmMNWIDwsuH + sanCgs1sIqRD2PIsFzHjBxFpSkKItBRB+RrwpXon7bkF23L167OfzvNa0uGf14NA0SCCC40IERtZWA+e + RAH/mvMIHIjF8rRm+JWLEFHQOU97bsHWa8/WSqqdfjn9rMCAgAIjAoW/kz8E/5w++KrS4PMyEsvO3YP3 + 8CqEdiU4ac8tiLlVEixocQTkmRAkMmN1kQWhEgvC7lpdWSMyIaBKAj+xEF5Nu7DUwIN//QEH7bkFseKd + S5Jqx8IkY2zhPSJKJxAt+wh+5UfEVk1ih3wCUcWjCMvVwbsnCL49IfBMF4zRnlsQX+ZB9spUQdl6Jlo2 + g/jqzzhc9wVHGxgcb2RcM0E1C37ROwS3r8NyaSJDedpzCw7VEpKgWrnwSIM27LaFSX7oQJr6Oy5ofkDQ + 9sM1Ux87kCCzgXcnheEmK7WUpz23gD6vEPZXbq4kx5pVvoL+0T3yaUdq0zfnRc3PeTr3VHxy+GT0jtK7 + i6M8+/4IuGyWsQkmnl4byMaTJ0hyg4Kc7OgkKVq9a9Jvuqd3Qmib8tw/Ag6bxWzo0vs/QjnKcwCQXyFm + FkJonTZMAAAAAElFTkSuQmCC + + + + 9, 189 + + + 16, 18 + + + 60, 191 + + + 162, 13 + + + 26, 268 + + + 96, 13 + + + 5, 67 + + + 65, 13 + + + 75, 67 + + + 208, 13 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAMoSURBVDhPjY9dSJNhGIbftg6S8CAoJBWMnPhTkBlk + mWVpNCu0PygTkyLKUosym1GY2Y/p5lzNv+Z0UxuWmjV1pk0tdFrM6VZuK3/KnOS0voNWQcgOvPvereig + k164efie57ov+Agn8xXhZBkI98Y44d62LeIKp7dzRXYhm0dsOn9PoWtP7yxHedoDQP4Kro+uYI+ycLnN + dK3XxlS+mZqrs07O19t1cyLLIBOpGjHRO+X+FQj0KzxzDOpTT97ZS00GKKdbUW78gJL+z6iZ7MZ9pgl1 + TDMu9vXbKUf5v4KUNg9OqlZx9JFuJqPrOQrfP0DVbCPKjG9RYX4Npa0dlfZGSGcUENrLcLpbM0N52nMJ + FiTV8QMvtVoTayw43KSDwCqHoGsAl9snkW9tgXhWhjNPtMg0l+Ds1FVkTuSDl9lmpT23YF+5NE55/+tG + uQbRFWbE1Zhx8MEYEuvHkaR+gf2KLuwQdyBxJAO7X2YhSl2IuEr1V9pzCQi/oCNed8W5WlmMNWIDwsuH + sanCgs1sIqRD2PIsFzHjBxFpSkKItBRB+RrwpXon7bkF23L167OfzvNa0uGf14NA0SCCC40IERtZWA+e + RAH/mvMIHIjF8rRm+JWLEFHQOU97bsHWa8/WSqqdfjn9rMCAgAIjAoW/kz8E/5w++KrS4PMyEsvO3YP3 + 8CqEdiU4ac8tiLlVEixocQTkmRAkMmN1kQWhEgvC7lpdWSMyIaBKAj+xEF5Nu7DUwIN//QEH7bkFseKd + S5Jqx8IkY2zhPSJKJxAt+wh+5UfEVk1ih3wCUcWjCMvVwbsnCL49IfBMF4zRnlsQX+ZB9spUQdl6Jlo2 + g/jqzzhc9wVHGxgcb2RcM0E1C37ROwS3r8NyaSJDedpzCw7VEpKgWrnwSIM27LaFSX7oQJr6Oy5ofkDQ + 9sM1Ux87kCCzgXcnheEmK7WUpz23gD6vEPZXbq4kx5pVvoL+0T3yaUdq0zfnRc3PeTr3VHxy+GT0jtK7 + i6M8+/4IuGyWsQkmnl4byMaTJ0hyg4Kc7OgkKVq9a9Jvuqd3Qmib8tw/Ag6bxWzo0vs/QjnKcwCQXyFm + FkJonTZMAAAAAElFTkSuQmCC + + + + 9, 224 + + + 16, 18 + + + 60, 226 + + + 47, 13 + + + 60, 126 + + + 78, 13 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAMoSURBVDhPjY9dSJNhGIbftg6S8CAoJBWMnPhTkBlk + mWVpNCu0PygTkyLKUosym1GY2Y/p5lzNv+Z0UxuWmjV1pk0tdFrM6VZuK3/KnOS0voNWQcgOvPvereig + k164efie57ov+Agn8xXhZBkI98Y44d62LeIKp7dzRXYhm0dsOn9PoWtP7yxHedoDQP4Kro+uYI+ycLnN + dK3XxlS+mZqrs07O19t1cyLLIBOpGjHRO+X+FQj0KzxzDOpTT97ZS00GKKdbUW78gJL+z6iZ7MZ9pgl1 + TDMu9vXbKUf5v4KUNg9OqlZx9JFuJqPrOQrfP0DVbCPKjG9RYX4Npa0dlfZGSGcUENrLcLpbM0N52nMJ + FiTV8QMvtVoTayw43KSDwCqHoGsAl9snkW9tgXhWhjNPtMg0l+Ds1FVkTuSDl9lmpT23YF+5NE55/+tG + uQbRFWbE1Zhx8MEYEuvHkaR+gf2KLuwQdyBxJAO7X2YhSl2IuEr1V9pzCQi/oCNed8W5WlmMNWIDwsuH + sanCgs1sIqRD2PIsFzHjBxFpSkKItBRB+RrwpXon7bkF23L167OfzvNa0uGf14NA0SCCC40IERtZWA+e + RAH/mvMIHIjF8rRm+JWLEFHQOU97bsHWa8/WSqqdfjn9rMCAgAIjAoW/kz8E/5w++KrS4PMyEsvO3YP3 + 8CqEdiU4ac8tiLlVEixocQTkmRAkMmN1kQWhEgvC7lpdWSMyIaBKAj+xEF5Nu7DUwIN//QEH7bkFseKd + S5Jqx8IkY2zhPSJKJxAt+wh+5UfEVk1ih3wCUcWjCMvVwbsnCL49IfBMF4zRnlsQX+ZB9spUQdl6Jlo2 + g/jqzzhc9wVHGxgcb2RcM0E1C37ROwS3r8NyaSJDedpzCw7VEpKgWrnwSIM27LaFSX7oQJr6Oy5ofkDQ + 9sM1Ux87kCCzgXcnheEmK7WUpz23gD6vEPZXbq4kx5pVvoL+0T3yaUdq0zfnRc3PeTr3VHxy+GT0jtK7 + i6M8+/4IuGyWsQkmnl4byMaTJ0hyg4Kc7OgkKVq9a9Jvuqd3Qmib8tw/Ag6bxWzo0vs/QjnKcwCQXyFm + FkJonTZMAAAAAElFTkSuQmCC + + + + 9, 125 + + + 16, 18 + + + 60, 244 + + + 68, 13 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAMoSURBVDhPjY9dSJNhGIbftg6S8CAoJBWMnPhTkBlk + mWVpNCu0PygTkyLKUosym1GY2Y/p5lzNv+Z0UxuWmjV1pk0tdFrM6VZuK3/KnOS0voNWQcgOvPvereig + k164efie57ov+Agn8xXhZBkI98Y44d62LeIKp7dzRXYhm0dsOn9PoWtP7yxHedoDQP4Kro+uYI+ycLnN + dK3XxlS+mZqrs07O19t1cyLLIBOpGjHRO+X+FQj0KzxzDOpTT97ZS00GKKdbUW78gJL+z6iZ7MZ9pgl1 + TDMu9vXbKUf5v4KUNg9OqlZx9JFuJqPrOQrfP0DVbCPKjG9RYX4Npa0dlfZGSGcUENrLcLpbM0N52nMJ + FiTV8QMvtVoTayw43KSDwCqHoGsAl9snkW9tgXhWhjNPtMg0l+Ds1FVkTuSDl9lmpT23YF+5NE55/+tG + uQbRFWbE1Zhx8MEYEuvHkaR+gf2KLuwQdyBxJAO7X2YhSl2IuEr1V9pzCQi/oCNed8W5WlmMNWIDwsuH + sanCgs1sIqRD2PIsFzHjBxFpSkKItBRB+RrwpXon7bkF23L167OfzvNa0uGf14NA0SCCC40IERtZWA+e + RAH/mvMIHIjF8rRm+JWLEFHQOU97bsHWa8/WSqqdfjn9rMCAgAIjAoW/kz8E/5w++KrS4PMyEsvO3YP3 + 8CqEdiU4ac8tiLlVEixocQTkmRAkMmN1kQWhEgvC7lpdWSMyIaBKAj+xEF5Nu7DUwIN//QEH7bkFseKd + S5Jqx8IkY2zhPSJKJxAt+wh+5UfEVk1ih3wCUcWjCMvVwbsnCL49IfBMF4zRnlsQX+ZB9spUQdl6Jlo2 + g/jqzzhc9wVHGxgcb2RcM0E1C37ROwS3r8NyaSJDedpzCw7VEpKgWrnwSIM27LaFSX7oQJr6Oy5ofkDQ + 9sM1Ux87kCCzgXcnheEmK7WUpz23gD6vEPZXbq4kx5pVvoL+0T3yaUdq0zfnRc3PeTr3VHxy+GT0jtK7 + i6M8+/4IuGyWsQkmnl4byMaTJ0hyg4Kc7OgkKVq9a9Jvuqd3Qmib8tw/Ag6bxWzo0vs/QjnKcwCQXyFm + FkJonTZMAAAAAElFTkSuQmCC + + + + 9, 242 + + + 16, 18 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAVtJREFUOE9j + GAXEA15e3nBhYeFXIiIi/wUFBbdwcXFJQ6UIA6BmAwkJiV9xcXGT582bl6+np3dITExsD1SagYGTkzOZ + h4fnG1DhKyDbGCoMBwoKCrVATRf+//+vAMR8U6dODQEa8B+ohxOsQEhI6NW1a9dCDQ0NjwLZD4DOEwVL + QIGamtoqWVnZN0BNQiC+qqpqlqSk5AegYcxgBUCB00D/HRcXF/8KNOA/Pz//I6AhpUDXhPPx8bUA/f1X + VFT0P1DNN6D/LwHl/8THx3eANYPAxYsXHRwdHaeGhoZOiYyMnGJubr4O6LzvQPxfWlr6KNDgD0CN/9XV + 1c84ODjMmTJlSh7QdkQgAjksQKwMxCA/ygOxdkNDQyk3N/fvHTt2eAANXKuoqHgRKG4OxKpAzAfVihsA + FQnFxMR0s7CwvAB65Vl1dXUiVIp4ADREGojdgNgFiPmhwsMLMDAAALg0hCFEe1vEAAAAAElFTkSuQmCC + + + + NoControl + + + 32, 126 + + + 15, 16 + + + + iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAACH + DwAAjA8AAP1SAACBQAAAfXkAAOmLAAA85QAAGcxzPIV3AAAKOWlDQ1BQaG90b3Nob3AgSUNDIHByb2Zp + bGUAAEjHnZZ3VFTXFofPvXd6oc0wAlKG3rvAANJ7k15FYZgZYCgDDjM0sSGiAhFFRJoiSFDEgNFQJFZE + sRAUVLAHJAgoMRhFVCxvRtaLrqy89/Ly++Osb+2z97n77L3PWhcAkqcvl5cGSwGQyhPwgzyc6RGRUXTs + AIABHmCAKQBMVka6X7B7CBDJy82FniFyAl8EAfB6WLwCcNPQM4BOB/+fpFnpfIHomAARm7M5GSwRF4g4 + JUuQLrbPipgalyxmGCVmvihBEcuJOWGRDT77LLKjmNmpPLaIxTmns1PZYu4V8bZMIUfEiK+ICzO5nCwR + 3xKxRoowlSviN+LYVA4zAwAUSWwXcFiJIjYRMYkfEuQi4uUA4EgJX3HcVyzgZAvEl3JJS8/hcxMSBXQd + li7d1NqaQffkZKVwBALDACYrmcln013SUtOZvBwAFu/8WTLi2tJFRbY0tba0NDQzMv2qUP91829K3NtF + ehn4uWcQrf+L7a/80hoAYMyJarPziy2uCoDOLQDI3fti0zgAgKSobx3Xv7oPTTwviQJBuo2xcVZWlhGX + wzISF/QP/U+Hv6GvvmckPu6P8tBdOfFMYYqALq4bKy0lTcinZ6QzWRy64Z+H+B8H/nUeBkGceA6fwxNF + hImmjMtLELWbx+YKuGk8Opf3n5r4D8P+pMW5FonS+BFQY4yA1HUqQH7tBygKESDR+8Vd/6NvvvgwIH55 + 4SqTi3P/7zf9Z8Gl4iWDm/A5ziUohM4S8jMX98TPEqABAUgCKpAHykAd6ABDYAasgC1wBG7AG/iDEBAJ + VgMWSASpgA+yQB7YBApBMdgJ9oBqUAcaQTNoBcdBJzgFzoNL4Bq4AW6D+2AUTIBnYBa8BgsQBGEhMkSB + 5CEVSBPSh8wgBmQPuUG+UBAUCcVCCRAPEkJ50GaoGCqDqqF6qBn6HjoJnYeuQIPQXWgMmoZ+h97BCEyC + qbASrAUbwwzYCfaBQ+BVcAK8Bs6FC+AdcCXcAB+FO+Dz8DX4NjwKP4PnEIAQERqiihgiDMQF8UeikHiE + j6xHipAKpAFpRbqRPuQmMorMIG9RGBQFRUcZomxRnqhQFAu1BrUeVYKqRh1GdaB6UTdRY6hZ1Ec0Ga2I + 1kfboL3QEegEdBa6EF2BbkK3oy+ib6Mn0K8xGAwNo42xwnhiIjFJmLWYEsw+TBvmHGYQM46Zw2Kx8lh9 + rB3WH8vECrCF2CrsUexZ7BB2AvsGR8Sp4Mxw7rgoHA+Xj6vAHcGdwQ3hJnELeCm8Jt4G749n43PwpfhG + fDf+On4Cv0CQJmgT7AghhCTCJkIloZVwkfCA8JJIJKoRrYmBRC5xI7GSeIx4mThGfEuSIemRXEjRJCFp + B+kQ6RzpLuklmUzWIjuSo8gC8g5yM/kC+RH5jQRFwkjCS4ItsUGiRqJDYkjiuSReUlPSSXK1ZK5kheQJ + yeuSM1J4KS0pFymm1HqpGqmTUiNSc9IUaVNpf+lU6RLpI9JXpKdksDJaMm4ybJkCmYMyF2TGKQhFneJC + YVE2UxopFykTVAxVm+pFTaIWU7+jDlBnZWVkl8mGyWbL1sielh2lITQtmhcthVZKO04bpr1borTEaQln + yfYlrUuGlszLLZVzlOPIFcm1yd2WeydPl3eTT5bfJd8p/1ABpaCnEKiQpbBf4aLCzFLqUtulrKVFS48v + vacIK+opBimuVTyo2K84p6Ss5KGUrlSldEFpRpmm7KicpFyufEZ5WoWiYq/CVSlXOavylC5Ld6Kn0Cvp + vfRZVUVVT1Whar3qgOqCmrZaqFq+WpvaQ3WCOkM9Xr1cvUd9VkNFw08jT6NF454mXpOhmai5V7NPc15L + Wytca6tWp9aUtpy2l3audov2Ax2yjoPOGp0GnVu6GF2GbrLuPt0berCehV6iXo3edX1Y31Kfq79Pf9AA + bWBtwDNoMBgxJBk6GWYathiOGdGMfI3yjTqNnhtrGEcZ7zLuM/5oYmGSYtJoct9UxtTbNN+02/R3Mz0z + llmN2S1zsrm7+QbzLvMXy/SXcZbtX3bHgmLhZ7HVosfig6WVJd+y1XLaSsMq1qrWaoRBZQQwShiXrdHW + ztYbrE9Zv7WxtBHYHLf5zdbQNtn2iO3Ucu3lnOWNy8ft1OyYdvV2o/Z0+1j7A/ajDqoOTIcGh8eO6o5s + xybHSSddpySno07PnU2c+c7tzvMuNi7rXM65Iq4erkWuA24ybqFu1W6P3NXcE9xb3Gc9LDzWepzzRHv6 + eO7yHPFS8mJ5NXvNelt5r/Pu9SH5BPtU+zz21fPl+3b7wX7efrv9HqzQXMFb0ekP/L38d/s/DNAOWBPw + YyAmMCCwJvBJkGlQXlBfMCU4JvhI8OsQ55DSkPuhOqHC0J4wybDosOaw+XDX8LLw0QjjiHUR1yIVIrmR + XVHYqLCopqi5lW4r96yciLaILoweXqW9KnvVldUKq1NWn46RjGHGnIhFx4bHHol9z/RnNjDn4rziauNm + WS6svaxnbEd2OXuaY8cp40zG28WXxU8l2CXsTphOdEisSJzhunCruS+SPJPqkuaT/ZMPJX9KCU9pS8Wl + xqae5Mnwknm9acpp2WmD6frphemja2zW7Fkzy/fhN2VAGasyugRU0c9Uv1BHuEU4lmmfWZP5Jiss60S2 + dDYvuz9HL2d7zmSue+63a1FrWWt78lTzNuWNrXNaV78eWh+3vmeD+oaCDRMbPTYe3kTYlLzpp3yT/LL8 + V5vDN3cXKBVsLBjf4rGlpVCikF84stV2a9021DbutoHt5turtn8sYhddLTYprih+X8IqufqN6TeV33za + Eb9joNSydP9OzE7ezuFdDrsOl0mX5ZaN7/bb3VFOLy8qf7UnZs+VimUVdXsJe4V7Ryt9K7uqNKp2Vr2v + Tqy+XeNc01arWLu9dn4fe9/Qfsf9rXVKdcV17w5wD9yp96jvaNBqqDiIOZh58EljWGPft4xvm5sUmoqb + PhziHRo9HHS4t9mqufmI4pHSFrhF2DJ9NProje9cv+tqNWytb6O1FR8Dx4THnn4f+/3wcZ/jPScYJ1p/ + 0Pyhtp3SXtQBdeR0zHYmdo52RXYNnvQ+2dNt293+o9GPh06pnqo5LXu69AzhTMGZT2dzz86dSz83cz7h + /HhPTM/9CxEXbvUG9g5c9Ll4+ZL7pQt9Tn1nL9tdPnXF5srJq4yrndcsr3X0W/S3/2TxU/uA5UDHdavr + XTesb3QPLh88M+QwdP6m681Lt7xuXbu94vbgcOjwnZHokdE77DtTd1PuvriXeW/h/sYH6AdFD6UeVjxS + fNTws+7PbaOWo6fHXMf6Hwc/vj/OGn/2S8Yv7ycKnpCfVEyqTDZPmU2dmnafvvF05dOJZ+nPFmYKf5X+ + tfa5zvMffnP8rX82YnbiBf/Fp99LXsq/PPRq2aueuYC5R69TXy/MF72Rf3P4LeNt37vwd5MLWe+x7ys/ + 6H7o/ujz8cGn1E+f/gUDmPP8usTo0wAAAAlwSFlzAAALDAAACwwBP0AiyAAAF7BJREFUeF7lWml4VdXV + DlesolKrqAgoKIMDWrVKW9tPP+usrbVf0TpUi9YBgYyEEAhhDAhhDCGQORAyzwMhA0lIwpCEzIQQMhDI + PJN5nni/d53k2picBHhq7Q/3fd7n3rPOOXuvtfZaa6+99tUB8JOGKvGnBFXieEhPS3nC5ZDzjktFlyaq + 3f9vIPtc9vRt27bFxcXGva12fzyoEsfDTssd0TY2NnBydLJRu/9j41z2uZlmq82KjFcsx+LFi0lSf24s + qBLHQkJCwssODg52iUmJiE+IfzkkOGSJ2nM/Jnbt3hVq7+gAb09PmK5eWRoQEKCn9txYUCWOBS93L4vw + iCjk5+fj8uXLOHXy1ItRUTEL1Z79MeDs4mx10OWgVURkFDgZsNpnBUtLy2i1Z8eCKnEsODm52JxOTERV + VTUamhpQXFyMI6HhX6ampT+h9vx/EtGxsW/vs7IOjD4WjfPnc5GZmQG3w25Yu2Zt/tnsszPV3lGDKlEN + CfEJrzs6OtqcPZuJlpZmkoCerm5kn83GYXc3C+1zPwbyCwomW27bHhcYGAgKi96uHlRUVSHQPxCmq0zh + H+B/3W6gSlSD+JaXpxcKaf49Pd0kDbbm5iaaX/ASHx+flbxUffeHhu0Be1cbm/1IOHUaLY2NaO/oRGVV + JaKiIrBh00bss97nq/aeGlSJanB0cLQ7GhaGkpJyXCVhgJ+ryi8gPzcPB2xtnVNTUp+RZ/+TSGDw3bBp + c1pIUCiKL5egq6cDV+rrUEMLSDx9Gvv22WDN6lVFau+qQZU4EvkF+ZO59HmcSDiBhvoGkoD+q/0KpF1p + vILQI6Gw2bfPg5eqffxQsLDYkOZo74BTpxLR3t6G1rZW1FTXoLqmGhlpmXA95AojY6PatIzUR9XeHwlV + 4kgkxJ14XZaaM6lJ6OxqJ+lfChAr6OvrQ3paOvZa7Q308/Mx0r73Q8P9sPvWdevWnac7ovDSRfT29KKp + sRnV1XVEFXLOX4C3rx9MV65EgL/vdfGhShwJHy8PMzf3w7iQe4HiDpq+VgHiCtKKLxXDz98PFhs2ZeXk + ZE/XvvtDISsra46BvkGnnb09Ek4koK21DZ30/YaGRlRUVysWUFiQj9CQIGz9div27NkbqNbPSKgSR8KR + WZ8/tV5RVsnLf82+FtKaGpsQdewY9lpbw9ra+rqD0PViB6P+xk2b4OnlzTwkD329fWjmalRfX4/K6kpa + QDVjwmUcDQ+HldVerFu34bxaPyOhShyO3At5d9nY2HrExBxHMyOuNDUF9Pb1IuVMKrx9PLHKbHVRTGzM + DeflY+FY1LGF+gZGrfZ2dpBA3Eg++np70dzUjDoGQFkBKiuriArEHY+Hs5MLVqwwqU1OSblmUFYlDkfi + 6VPPM7ghKTkRPX09JI1WgLjE1atXUZBfgNCwI9izew82b96SrO3j38WaNeb5Gzj7rq6HkJqWyjGB9k5G + /8YG1NbVoqKiApUVg1aQkpwMdzc3GBoZ4ujRo5+o9TccqsThCA+P+OSA7QHkMtuSJj4/UgECaRKIjsfF + wcfTG+vN1+RHRv/7aXJ4RMQHRgaGrQ72tghmultXU4erA1cZA1ppCVRATS3KK8uphErU8Hdmdia8fLyx + 2tQUzs4HrdT6HA5V4nC4ubptJVBZXsFLzr58xlBAO5nKSE9HyJEjcHBy4KpgHUjF3cdbqn1fCxlZGXMs + LCySd+/ZBTdXV87+GWXF6e7sRhv9/0pDvTLrFTT98rJyVHEC8vLyEBwagi1bLLDJYvM1rVCVOBz79+93 + DQkJVQKONDXhBWIZAwMDuHzpMhITkxAVHQ1vBixnJ2eb8IjwD2KZu0fFRL17lL+PHgn7LCg4aIm/v5+R + LzNIWToDmL4GBATqBQUG6QWFhHzp6em5ztJyW7StrS2YZYLvMdA2KKuQrP/NzS2K/1fT9xUFlJcrMaCE + q1FUVBT2cctustJEoraqXFqoErUovFg4aZ+1jW/8yQR093aRNLYCBNLayFxhQSH3CFlIT09DYnISjsce + R2RkJMKOhHF9DoSnpzvcDx+Go7MzuL2GA3MMJ4Gzk7KhcaMPe3l6IDQ0FLLZOX78OAoKC0DpmYb3UwGd + yn6ktrYWVZUMgFUVShyooJWWlpZxqx4HFxcX6Bvqt6ZnpI+bEKkStTh56tSLzKtxLiuTl2P7/3BIU9bn + +iv0zxrFR2sra1FWXqbsHgspyHkmLFlnzyKLO7iM9AyadjqRifSMTJzj5ko2WOdycvjceeTk5qCkuASt + Le3o7mhHZ3cX2ts60MQ9iATAykq6ANNgsYCy0lKOU4kzKanw8HCHyXIT2SaPW7NQJWpx5EjIZ86clUtF + l3k5/uwPh7bJ6jDQT7URPT096KIVdXMH2dExKIQ2lW1l7GhvbVe+W9paFCuS300NTVx6m7nZaeeMt6Dh + SgPaOtp43UZ3aKQChpZAQoJgRVkp3aES57hD9Pb2wVpzcxywP+BMVlTlE6gStfD29FnnRf+rop9JUxN2 + XPCjxAYq4GrfoDL6+/qV5bSX63gvkxlJaPr6CQa3/gG+QYip8zWF1kVltdDfm5qaFAU0NFMhdIGmpkbu + AegCYv5VXAU48yU0/4ryUhTkFSCIW2ULBkLLrZZxIstYUCVqcdDZxSoyPBItrS28HKYAftTa8BR5FCi4 + YKB3QBFaFKAI30PB6df9vcMgiuA7isvxd1cXfZ48SN4vSVBHO62FVtLC7LOpqQX1V64oS7D4f3FJqVKt + Co+Mwq7duyH1QrKmKp9AlSjIKyyYbO/gYJeUlIT+/kGBhamRbXAnMLKNowgBhVKsgf0q30Mzr/bsVWY9 + /dz0tLU10XU6qbQedHBD1tBMC2AMqGYgrGuoU2JCA5fFKq4EpWVliGXglRVkueHy1uSU5DEzQlWiQMpc + B50O4XzeeWXGZXa1LS01FdZ7raG7TB+L/v4pvlz0OczXrEUAza6SgU/b1AS6Eciy2tfdq/h8PxXRxXQ7 + 7WwmpCptsFQPn/ztI3y88EMsXvwN9uzajdMnTqKBS6UkSEmJp3HooAsMDAwRwWSK7KjKqUoUnDp18kU3 + dzdG1rLvhL9S1wAjPQPMnDGDb+p8h5uIScRDEyfhTy/9AX6BQcrz0tQEux4MXB1Ab3cP2rs7lH7qWlqx + Y4clXnjmV5jOse4cGlfLg4aY/9jjWL9uA8poAcUlxXDnSmC8YgV8vH3M2IWqnKpEQUR4+CcBwf5cflp5 + CS5NZ/GrZ579bsDbift0JmCGjgaziLk6EzGH31NJn0n6qhWrhtR2DXdQgQgvgbF7qPRWUluFzxf+VRH8 + YeIRnZs53s38fROmcawpxG2ka3l747U3kMWVID4hHuar13B3OnaJTJUo8PcPMDoeG8+fYBbYhEdmz1E6 + v4WD3a2ZiPuJB4mHNT/DY5pb8bTmdvxW83O8oLkLz5O5mXx2L4OQtHGD4xiQAClN0q+v3vsI89jfCzq3 + 40XNFCzQ3IFfEo9pJmG25mbMIB/3EXcRP+Nzwuc7b7yF00zCdu3Zgw3r12exG1U5VYkCdw+PdWezz/En + YKCnNyj8BI0yyL3EdM1NeIiDP6q5DU+RmV9T+P8lc68Rf9ZMw1s6k/DczbchPTtb6UNNSFXIh8FRgp80 + b3dPPMux/6ozBX/S3M/+76US7sJzHFPGfYzjP0w+hB/h605i4pASTFaYIoS70xXGxrXsSlVOVaLAze2w + Rd2VOpTTl+649Talw5+z8ynENGIWB32EM6AV/kXN3XhVcw/e0UzF+5oZWDRhJl7kO5Z6UiymFXC7rCrw + SMiHK4K0LrqCwfNv4c/s51PNQ1ioeQB/ZP+vcxyxNLGEpwnhQyZjOvkS6xQ+hd95s+ciMDAAq9eszs/K + zJrDLkfJOYogSElNeUIUMHC1Fx6u7kpnotV72LGYmgwmgz7JwX8zJPwbnPk/cebf0zxIZh/AV5rZ+IQm + q/vMS2jnmi9NVeCRGKaAgrx8fH3rPHyucx++0MzCJ1TsQvYv47xBJfzPkBLEHebRDWeSt6mEKOFmuurP + GCOsd+zCt1u3StH2M3Y5StZRBEF4ZPgHjJz8CWxeazE4++xQhBe/n6u5BU/Q55/lwMLEKzTLd8jUB4rw + DyrMLtPMw2Kde2Ew7Zeor6lX+lIVWA3MAKVlHItjH/djmc6D7G8uvlSU8AD+RogSXqESfq/5heIOws9s + xiNtPPg5J0n4Njddhd17rLgrVT/MHUUQ+Plxm+o7qICdm7cPKUBHCXwz6Wvz6HfPcOaf19xJv797aOZn + KjP0JU1Vl8waKgq4Cxsf+g06GwdXElVhR0ASI6n2SiuITcbyCbNgRAUYsb+lmjn4J5Xwdyrgrxzrj5r7 + 8DItT4LvU1SAWKVMkLjCHRNuUvi2WLsBVvv3w2qMIukoguAg9/C+vn7oYTCKjYhSOpJlRvx+LrUsJvdr + Cv8SB3+bTCykAj7izP+TSlhCJo00j2KV5nF8rXMrnF/+uywDSlMTeDhk+Rvok/V/UAHN5bXYMvk5GOhM + w0rNY+x3rtK/KOFjjidKEFeQ4LtAMxnzqQQJiOIKt5Dfu2+5HZ4uh2FzwBbma9eqFklHEQQ7d+8ODWIy + U11bg05uPOZPf1hRgiw5EnV/xYF+R61L0JPI/BFnRPx+GZkzJJPGZHblBM4Yl8MzWw6xy+sQnllfP9d+ + mf2uLu4amQOI3jzf1ccSnVuwTvMkVlCxeooSZmMRFTDoClMVKxBXkID4qFjBhMEg+JeXXkVScjL27NkN + Q0OD1qKiolF/6vjehSArO2vmpk2b0qTGfzZncAkL9fJTOryHkNl/jtoW03+Lvv9/nIWPychXNH09mulK + MmmmmQ9dzr79Q++gr2MwmVETWou+AW6I6Pe93BR1dnKrzNS3tZXpL9+rSs/DGrqAMeOJmeYJLKdyxcWG + u8Lr5OMl8jNoBZMUd52hcxv5DkDC6ZPYYbkdX3+9GNzXLGCX35P3excCqaCYm5kXeXh44PTJ02huHSyF + rfl0sbISzCB+Syv4A7UugU9m/3Oa/jecFQMqwEhnFmfsVlhMehy1iYOFVM7vaMGHPmLykvR0M+3t6urm + fr9TqQ20cf/fxA2QKOHMVjeY6twNfWLFBLGyecp4EnDfJ/5MKxQreJpC30v+pjNgO1jsRE7+BXh4esBy + uyX+8ek/pLI0qlT/vQstzMzMinbu2ImIo+FISUvjVrSJZODQpt14duIdmM3XfkfzflvnDryncw8W0Ue/ + Ir7WmQw9wu35j9Ccfkl5R/x6lOD8Hkx3JePjtphm39kthZJ2bnUHiyHNzVIQaURjW6uy4zzvGQ3Lyc9S + CbfjG465WGcGPtWZjoVcIt/Q+QUWMA2fT77+Mu0JBDu4o6iiBCFHwrDf9gCMVxrjs3/IKjha1lEEgeye + jAyNWqUcnpF1FuUVFegYysvzT2di18d6+GL6c/iAS9RnZOAbmuiaiU/C6X8+RtZOrh6Dq9j3BR+CRHml + AELBpUrU3dOFrs52pUIke/xWznwL9/iy71fKaoxDdfwtKXFpziWELduMHbNfpkXMZYyZxRxhGj7lSrH0 + kd9j35JVKMzKQ0XjFZzkbjCYcWz9uvX48MMPIUVWdjFK1lEELQoLCyfZ2Oz3+OLLL3AyIYFMNTGb452h + 1l7bgtIzubgQfhLFx9LQkFcydGewKUGNCU2fWABnWnxc8fOhSlAPBZeD1o4OCt7Wxv0GBZdZb+S+ntvZ + GmahEoTlHKC6spKTUI66ng40U7sVl8uRHZmMRNcjOOUahNSoEyguLEZdZyvKa6pxjhs3by8vvP/++9i4 + fmOWnCuSJVU5VYnDMW/OHDw4ayZqaqt5ycmVKs7AME2MaDLDPdy393J2RdDeHqJborrs7vrR0c3Z7qSf + U3Cp/Ym/S72vVUpenLmGhgbUc+br6htQW12DiqrqwYMPqfiWlKC8rBSVjXWo6mxBbVcLatqbUN5Ui1IK + foE+X1p6GWlpGZg1cxamTp2KnJyccQ9qVYlaBAT665mtWl0qK0DY0TCSBltHdyfN+F+1IKnd9fZJ6apb + KXr2ylre10O/7lTud3d1Dpax6OPtnO22FoJ+3spvqfUp9T76uwhfW1/LWa9FTXWdUverHDr2krO/kpLL + uHypGEWXLqIgPx/FpcWKsi5fuoSCi4W4VFSgjOdy6BAl02Hk/1p+7yBJVT6BKvF8zvnpTkwdt1hsSdbT + 1f2uswS6wsWLF5Xyk7TY2GjkDO321FoXl7TS4lJFEfK3GjnSFuHlkKWJW2w53LzScAX1DfWQjZfU+QVy + 4isl77M0Zan3yyFIB/OR5tYW5Ri8ki4hATPhxAm4uXkopfe8C7mIj49DUHAwPv7oI4XnRYsWwcTEpNLZ + 6aBNoUoOIBhFEISFhX22du1ayHH0e+/9DbMenIngoFAkxCfgxMkEbN++A0899ZQyyGuvvq4cR4mPVlVX + c5ZKYGpqitjjsewKfHa7coIzvA0wmAxIXJAYQXdRSuXtHejs6FIOPqRJfxstNtLd+hERFYFvlixFanqq + 8h8FOUtIz0zHK394ReFhzty53PKuII/ByiFKNidl/uPz8erLr8LE2ATr15rjWHTUu+x2lKyjCIKQ0JAv + JXrq6enB2MSEaeQaHAkJReqZFJSVlysCL1nyDd58602sMTeTCAsPdw9s2bIFL7z4gsLUAw88gLXr1+LO + 2yfjaSqLSytcnJyU0yE5uYmNicVxQv5TEBEeQYTBlxsw6717YWhkgF8+8STuuO0OGC03wv3336/0uWDB + c1i1yhS2drawsbaBIe+9+eZb+OzTRVROmlIMzc3NVY7GVpiswOJvviafS7FpswWiIsJV64KjCILMzIw5 + bm5uFmbm5jAyXI5169Zh65bNOOjignDmBrkXLqDpSgPqGBj76O+1tVKNrcJl+mgGGTlxOl6iL6ZNvR+v + v/GacvTl4+eHqMhIWtBJZKakM8k6ieiYKAp+lN8xOEFzjow8Bn9/X7i4OMP2wAFlhqdMmYKVFPoIn4uP + i0N25lnk5J5HAXmQk6dcxoLC/AKcSU6Bu6cXJH8xXmGsWCGXcmzYsAFe3l5mYwXDUQQtigovToqJOf6u + vYOjncXGTdA31FcsYvXq1di2bRucGWjCQsNwjMxL6Tw9LRXZ9EOJ1FKuFp+V6nFi8hmlnN3IAFczdJZX + zGdKSgmleFnG4FWsBDUlkDGglZeWKTEgPi4e0dHRKKM7FBRcREZaOv3+FGmxOBIWSovxg6urG/bu26sI + Km6gr6eP5SbL8e3mb3Hw4MEdx4/HvF08zh+7VYnDwaA3KSk5aUFAYICe7QFb180Wm5NFwzKQnq6eMqgZ + lbJ+00ZYbt2OPbutcGC/rZwKg+8gNDgEXl6ekKMqH38f+RMjA1UQZLMVFBSEAF4H+AUQvvD29eIseuLQ + YTe4OLsoriX/TbS2tsbunbvx7bffYv3GDTBbY6aYuMywoYGB8meIVatXiQuedHJwspPzwJSUlGdKLxVf + 8x/tqsTxkHc+776k00nPRzJb9PT2NLOzs3OW/+duJGOmpqvol8Yw0DeA3jI9LF22DEu5ishvfV196PK3 + 3DMw4LWBLnT1DGhZutDX5zMURE9fH8v4ji4Vq7tMl+8vpZJ5X09XEdJ45UqY0y3lPwN7du0KdXS0t/Hy + 9V4ZGRn5QUpSygLGprvUeB4PqsQbRXFR8cTc3Av3SewQ5cTExLzLWPEJo/ISqckfdjtsIX9qdnRytLG3 + t7ezt7VztiUO7Ld3tT1g52ov4DXvODs7O1kdPuS6w93N3cLXz9coODhwSUTE0Q+4qrydnJy8ICsj89EL + Fy7csKBjQZX4U4Iq8Ubw325qPN0IVIk3gv92U+PpRqBKVAObrYynghuhC+1az8u3tOHXw5/TYky6Gv9j + QZWoBum8oKBgFG6ELrRrPT/0za/vXY/CePSRvI8HVaIahjM0EiPp2uvrpWsx7D6/rv/5kdcjeR8PqkQ1 + jDXAcDq/R16PSddijPsjr0dhPPpw/q4FVaIahjM0EiPp2uvrpWsx1vMjMVY/2uuRvI8HVaIatAOMxI3Q + hfZD9DOcLt/D+dNeXy9UiWpgu+FoPAbth+hnOF2J+iOvrxeqxJ8SVIk/JagSfzqAzv8DsBuG5ONkx94A + AAAASUVORK5CYII= + + + + NoControl + + + 277, 163 + + + 66, 65 + + + NoControl + + + 60, 209 + + + 98, 13 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAMoSURBVDhPjY9dSJNhGIbftg6S8CAoJBWMnPhTkBlk + mWVpNCu0PygTkyLKUosym1GY2Y/p5lzNv+Z0UxuWmjV1pk0tdFrM6VZuK3/KnOS0voNWQcgOvPvereig + k164efie57ov+Agn8xXhZBkI98Y44d62LeIKp7dzRXYhm0dsOn9PoWtP7yxHedoDQP4Kro+uYI+ycLnN + dK3XxlS+mZqrs07O19t1cyLLIBOpGjHRO+X+FQj0KzxzDOpTT97ZS00GKKdbUW78gJL+z6iZ7MZ9pgl1 + TDMu9vXbKUf5v4KUNg9OqlZx9JFuJqPrOQrfP0DVbCPKjG9RYX4Npa0dlfZGSGcUENrLcLpbM0N52nMJ + FiTV8QMvtVoTayw43KSDwCqHoGsAl9snkW9tgXhWhjNPtMg0l+Ds1FVkTuSDl9lmpT23YF+5NE55/+tG + uQbRFWbE1Zhx8MEYEuvHkaR+gf2KLuwQdyBxJAO7X2YhSl2IuEr1V9pzCQi/oCNed8W5WlmMNWIDwsuH + sanCgs1sIqRD2PIsFzHjBxFpSkKItBRB+RrwpXon7bkF23L167OfzvNa0uGf14NA0SCCC40IERtZWA+e + RAH/mvMIHIjF8rRm+JWLEFHQOU97bsHWa8/WSqqdfjn9rMCAgAIjAoW/kz8E/5w++KrS4PMyEsvO3YP3 + 8CqEdiU4ac8tiLlVEixocQTkmRAkMmN1kQWhEgvC7lpdWSMyIaBKAj+xEF5Nu7DUwIN//QEH7bkFseKd + S5Jqx8IkY2zhPSJKJxAt+wh+5UfEVk1ih3wCUcWjCMvVwbsnCL49IfBMF4zRnlsQX+ZB9spUQdl6Jlo2 + g/jqzzhc9wVHGxgcb2RcM0E1C37ROwS3r8NyaSJDedpzCw7VEpKgWrnwSIM27LaFSX7oQJr6Oy5ofkDQ + 9sM1Ux87kCCzgXcnheEmK7WUpz23gD6vEPZXbq4kx5pVvoL+0T3yaUdq0zfnRc3PeTr3VHxy+GT0jtK7 + i6M8+/4IuGyWsQkmnl4byMaTJ0hyg4Kc7OgkKVq9a9Jvuqd3Qmib8tw/Ag6bxWzo0vs/QjnKcwCQXyFm + FkJonTZMAAAAAElFTkSuQmCC + + + + NoControl + + + 9, 206 + + + 16, 18 + + + 6, 13 + + + 384, 287 + + + + AAABAAYAICAAAAEACACoCAAAZgAAABgYAAABAAgAyAYAAA4JAAAQEAAAAQAIAGgFAADWDwAAQEAAAAEA + GAAoMgAAPhUAADAwAAABABgAqBwAAGZHAAAgIAAAAQAYAKgMAAAOZAAAKAAAACAAAABAAAAAAQAIAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAACcPDAAoDwwAKRANAC0RDgAxEg4AMRQPACsTEAAsExAALhQQADIT + EAA0ExAAMRQQADYVEQA2FxQAORQQAD4VEQA6GBMAPS0QAEIVEQBGFxEASRcSAEMYEwBFGBIAQRkUAEoY + EwBIGhUAThgUAFAZEwBQGRQAVBkUAFMcFgBUHBYAWxoVAFkdFQBdHBYAYRwXAGYdFwBpHxcAYh0YAGYf + GABqHxkAbR8ZAHEfGQBdIRkAbSAYAHEhGQB1IRkAcSQcAHkhGQB+IhsAfSQaAHkiHAB4JBwAfSUcAGE1 + FQBMRhIAWUgUAGpdFQBjaxMAZGwTAGdsFABqbRQAcm8VAG18FgCBIxsAgiUbAIQlGwCCIx0AhCMdAIEl + HACGJR0AiCYdAIgoHgCMKB4AiyggAIwoIACJLCEAc4kVAHWJFQB6ihYAf4AYAHyWFwCIjhgAiZgYAJaZ + GgCamhoAg6IXAISiFwCGoxgAiaMYAIyjGACKpBgAjaQYAIqsGACRpRkAkbcYAJK4GACauRkAobUaAKO+ + GgC3gyIAt4QjALuEIwC8hCMAp5ggAMmaJQDNoSUAxLclAJbBGQCcwxkAmMYaAJ3MGgCgxBoAoc0bAKbO + GwCk1xoAquIcAK7jHACy7xwAtO8cALPxHQC7/h4AzcEmAOP/cQDp/5EA7/+xAPb/0QD///8AAAAAAC8m + AABQQQAAcFsAAJB0AACwjgAAz6kAAPDDAAD/0hEA/9gxAP/dUQD/5HEA/+qRAP/wsQD/9tEA////AAAA + AAAvFAAAUCIAAHAwAACQPgAAsE0AAM9bAADwaQAA/3kRAP+KMQD/nVEA/69xAP/BkQD/0rEA/+XRAP// + /wAAAAAALwMAAFAEAABwBgAAkAkAALAKAADPDAAA8A4AAP8gEgD/PjEA/1xRAP96cQD/l5EA/7axAP/U + 0QD///8AAAAAAC8ADgBQABcAcAAhAJAAKwCwADYAzwBAAPAASQD/EVoA/zFwAP9RhgD/cZwA/5GyAP+x + yAD/0d8A////AAAAAAAvACAAUAA2AHAATACQAGIAsAB4AM8AjgDwAKQA/xGzAP8xvgD/UccA/3HRAP+R + 3AD/seUA/9HwAP///wAAAAAALAAvAEsAUABpAHAAhwCQAKUAsADEAM8A4QDwAPAR/wDyMf8A9FH/APZx + /wD3kf8A+bH/APvR/wD///8AAAAAABsALwAtAFAAPwBwAFIAkABjALAAdgDPAIgA8ACZEf8ApjH/ALRR + /wDCcf8Az5H/ANyx/wDr0f8A////AAAAAAAIAC8ADgBQABUAcAAbAJAAIQCwACYAzwAsAPAAPhH/AFgx + /wBxUf8AjHH/AKaR/wC/sf8A2tH/AP///wBDREZER0ZHR0dISUlLSEtLR0tLR0lLSEhIR0dHR0dLSDFi + Y2NjVUNCQERDRkRGRkZESEhCSExCSExCZ2pqamlBM2NjY2NVMTFDRTVFRTVDQEVFNUA1RTVFQTVnampq + ajAuY2M0MzQuNDAzMDMwMzUzMTU1MjUyMDAwMDAwNGpqLipjYyoqLi0tLi4uLS4tNC4uNC4uNTQuNDQu + NC4tamopKFRUKSktKSktKSktKS0pKSwtKS0sLCwvLSwvLyxlZSUkJCclJycnJCQkJCUnJyQkJyUnJyck + JCUnJycnJCcnJiMmJiYmJiYjJiYmIyMmIyYmJiYmJiMmJiMmIyYiIyIiICAgIiIiICAgICIiIiAgICAi + IiIiICIgIiIiIiIrISEdHR0dXnl5eXl5eXJSIR0dHR02XnJ5eXl1cFIfHx8bHhocHBxeeXl5eXl5eXlh + GhwcUHd5eXl5eXl5eV4YGhgYExQYFF55eVwTGFN5eXk+FDl5eXltORYUYXl5XBkZFhYSEhISXHl5WhIS + FnF5eVoScXl5bRYSEhJceXlcFRUPFw8PDw9ZeXlbDw8PcXl5Wzh5eXk4Dw8PD1t5eVoODw4QDg4ODll5 + eVkODk95eXk9PXl5eQ4PPXl5eXl5WRAODAwKCgoOWHl5eXl5eXl3Tww8eXl5DAo8eXl5eXlYDAoMDQoJ + CQlYeXl5eXl5dz8JCjt5eXkJCQoJBQkJCQoEBAQEBAQEBVd5eVcEEWB5eU4IBHZ5eTsFBAQEBQQEBQsE + CQUDAwMDV3l5VwMDOnl5dgMDXXl5cxEDAwMDAwQDBQQLCwMHAwNXeXlWAxFdeXl5AwMRc3l5cz8DAzdN + XwMDAwMEAwMDB1Z5eXl5eXl5eV0DAwcRb3l5eXl5eXlvAwgDCAMCAwMDVnl5eXl5eW9NAwICAwMDTWx0 + eXl5b1EDBwcIAwICAgIDAwMCAwICAwMDAwICAgMDAwICAwIDAwMDAwMCAgIDAgMDAgICAgIDAwIDAgID + AgMCAgMCAgIDAgMDAwMCAgICAgMCAgICAgICAgICAgICAwICAgICAwICAwgIAgICAgICAgMCAgICAgIC + AgICAgICAgICAgICAgIDAgICAm5uAgICAgIDAgMDAgMCAgICAwIHAwIIAwIDAwJoaAICeXkCAgICAwIC + BwcCBwMCAwMCAgICAgICAgMCAnp6AgJ5eQICAgICAgICAwIHBwIHBwIHBwIDAgICAgICenoCAnl5eXlu + AgYCAgICAgICAgIDAgYGAgcHAgZoenp6egICeHl5eW4CBgMCBwICBwICAwICAgICAgMCA2h6enprBwIC + AAEBAQEBAQECAQEHAgIHAgIHAgEDAgEBAQEBAgECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAGAAAADAAAAABAAgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAQEIAAcBCwAMAQwAFgELABEBDQAaAQ0AHQEMACMHCwAjAQwAJgEOACIF + DAAmBQ4AKQEPAC8BDwAnDwsAIwsPACYKDQApCQ0AKg4NADMNDwAqEQ4ALREOACsVDQAxEg4ANRsPADEf + DwAzAREAMxMRADYTEAAxFREANxcTADkXEQA9FREAOCEPADgmDwA8JQ8AOioPADshEQBBARMASQcTAE8F + FwBFDREAUQUTAFMJFQBbCxcAXQ8XAFwNGQBBFREASRcTAEcZEwBPGRMAShkUAE8bFQBTERMAVRUWAFsT + FQBeEhcAWRcXAFEZFQBaGxYAWR0VAFkfGQBtDxkAYRcXAGEaFwBgHRcAaRsXAGkfFwBgFRgAbRUZAGMd + GQBpHRgAbh8ZAHcbGQBxHRsAdx0ZAH8ZGwBBJw8AQSMRAEktEQBfJxcAWSsVAEE1EwBJOREAST8RAFE6 + EwBTPRQAYCsWAGMvFQBrIRgAby0ZAHEhGQB0IRkAdyUeAHshGgB+IxwAfyUdAHErGQB9LxsAYzEWAGM1 + FgBnOxcAaTkZAHkxGQB9NRsAS0kRAE1LEQBOTREAU0ETAFdPEwBVUxMAXVsVAHtFGQBnVRUAXWETAF9n + FABxZxUAdmsXAGdzFQBvcRcAaHUUAG9/FwB1fRcAgiMcAIUmHQCJJx4AhS0dAI0vHwCDMRsAjTEfAIk1 + HQCFPx0AjCkgAI1DHACCSRsAh0kbAI1KHQCRQx8AmUMfAIFtGwCBbx0AiXMZAJN1GwCrZR8AmkUgAJ9n + IQBxgxcAc4cXAHWJFwB2jxcAeZMXAH+bFwCFiRcAgZkXAIWVGQCPtxkAl7kZAJW/GQCbvxsAmcMbAJ7L + GgChzhsApc0bAKfTGwCk1xsAqd8bAKjZHACt4xsAr+cbALPtGwCv9xkAtPcbALXzHgCz/xkAt/sfALn/ + GwC6/R4Avf8eAML/HwDH/x8A6c8pAO7XKgD12SsAy/8gAM7/IADS/yEA1v8hANn/IQDc/yEA4v8iAO3/ + IwDy/yUA+f8lAP//MABQADYAcABMAJAAYgCwAHgAzwCOAPAApAD/EbMA/zG+AP9RxwD/cdEA/5HcAP+x + 5QD/0fAA////AAAAAAAsAC8ASwBQAGkAcACHAJAApQCwAMQAzwDhAPAA8BH/APIx/wD0Uf8A9nH/APeR + /wD5sf8A+9H/AP///wAAAAAAGwAvAC0AUAA/AHAAUgCQAGMAsAB2AM8AiADwAJkR/wCmMf8AtFH/AMJx + /wDPkf8A3LH/AOvR/wD///8AAAAAAAgALwAOAFAAFQBwABsAkAAhALAAJgDPACwA8AA+Ef8AWDH/AHFR + /wCMcf8AppH/AL+x/wDa0f8A////AH6IiIiCfXx9hIR9hH2EfYSEfH2BkJCQf4etqq2OTHt7e3t7e2B8 + YHx8fHyPtbS1iYarhmhcSV5eX15fX198XmBeXktegIW0hXCwZz5KSFxcW1tcXFxdW11cXVxKRWK2g1qN + WUJHR1lDSFlHR0dHR1lHWVlDQlmRYUE4ODgsLCwuLURAQUZAOC0uLC03Pzc3QTs7KGZlWGNkWDkqNjUq + O1dkZFdQKzY9PDoyJqu7vL29uKJRJid1p7m9vbmwmCY0NDAzGqa3oyl1sricGnS3uqZxKam4pxoxMC8v + DKa4oQMGmrisDbO5oAUIA564pgkgLyAgCKS4nwEMobmlT7q5bAx3eqi3pgYcHxwcA6S4sqSsubFtTbq6 + ThOxwL6+sQkcHhsXA6S4sqSvs28DFby5UwMFAgICBgkXFxUVBKS4nQAhsLhyALO5oAMIEQkICxUdHRUV + BKS4mwAisLyWAna7upkKACGXIxEXFRQVBKi9vb6+vK5UBgNusby/v7+8UhEWFRQVBXiWk5OUdiQDEQcD + InN5k5JzEhAdFRIOBwYDAwMDAwgQFQ4QCAMDAwMGChIVFBQIChIODg4UDhUUDhIOFA4OFA4SEgcPFCKV + FBAVFBUUFA4OFA4UDhUUFRQUEBaLJWnAJAMHDhQOFhUVFRQVDhQSFA4QAyPBVWu+ayQVCg4VDhQVDhUU + FRUUFAcdIVbBVmrAvsCVChQUFA4UDhQUFBQUFQeMwcHBVhlqamkiFA4SEhIUEhUSFBISDg4hVVZVGAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAQAAAAIAAAAAEACAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAYAAAAIAAYACQAJAAkADQAJABIACQAVAAoAGQAKAB0ACwAZAA4AHAAMACAB + CwAiBwsAIAAOACQADAAjBQwAJwUOAC4EDgAiCQsAJwgLACcPDAApDwwAMAAPACoQDQAtEg4AMRMPADUA + EQAuFBAAMhMQADcVEQA9FhIANyUPAD4gEQBEABIASQATAE4IFwBTABUAVAAVAFgCFQBYBRUAXQUWAFkL + FQBYDxUAXA8WAEEWEgBIGBMASxgUAF0RFgBXGRUAVhwVAFgaFQBcHxUAawYZAGMYFgBjHRcAaRAaAGAZ + GABiHhgAbhkZAHUTGQB2FhkAcR0ZAEspEgBfKhUARTgQAFQ4EgBSOxQAciEYAHQjGgB1JBwAfSEaAHsi + HAB9IhwATUgRAHJeGQBmaRYAY2wWAHtoGgBpchYAaXkVAHJ+FwCAIhsAhiYcAIgmHgCHKB4AiSgeAIko + IACMKSAAikkcAJdZHgCFZhoAk2kcAI1wGwCIdxwAiHgcAJRyHACQfBkAqWwfAJhEIACnXSEAo2IgAKpj + IQCobCEAcYMUAHKHFgB+ghcAcogWAHmAGAB+mxcAhIAYAICOGQCJjhkAkZ0aAIOiFwCSoRoAkLYaAJS/ + GQDQpyQApMcbAKPSHACm1xwApt8bAKbbHACr3hwAs+0dAL3/HgDA/x8Axv8eANTJKADC/yAAyf8gAM3/ + IADS/yEA1v8hANn/IgDe/yIA4/8jAOj/IwDp/yQA7v8kAPb/JgD7/yYA/P8nAP//KAAAAAAALxQAAFAi + AABwMAAAkD4AALBNAADPWwAA8GkAAP95EQD/ijEA/51RAP+vcQD/wZEA/9KxAP/l0QD///8AAAAAAC8D + AABQBAAAcAYAAJAJAACwCgAAzwwAAPAOAAD/IBIA/z4xAP9cUQD/enEA/5eRAP+2sQD/1NEA////AAAA + AAAvAA4AUAAXAHAAIQCQACsAsAA2AM8AQADwAEkA/xFaAP8xcAD/UYYA/3GcAP+RsgD/scgA/9HfAP// + /wAAAAAALwAgAFAANgBwAEwAkABiALAAeADPAI4A8ACkAP8RswD/Mb4A/1HHAP9x0QD/kdwA/7HlAP/R + 8AD///8AAAAAACwALwBLAFAAaQBwAIcAkAClALAAxADPAOEA8ADwEf8A8jH/APRR/wD2cf8A95H/APmx + /wD70f8A////AAAAAAAbAC8ALQBQAD8AcABSAJAAYwCwAHYAzwCIAPAAmRH/AKYx/wC0Uf8AwnH/AM+R + /wDcsf8A69H/AP///wAAAAAACAAvAA4AUAAVAHAAGwCQACEAsAAmAM8ALADwAD4R/wBYMf8AcVH/AIxx + /wCmkf8Av7H/ANrR/wD///8AWF9bUlNTVlZVVVdUVGNlYlx2YDtISEdRSEhIRzxmdWRaYDQ6RENDRERD + RUU9N2ZZNigmJSUnLzg1KyYlJykqOTIib3JwbzAhIT9vcm0zIzEuGn+Da4SHFmmKgW6GfxotLA1+fAFB + iD6GegICe30NHh0JfYJLgoIRilAgj4yEDR0cBH2DTINOAYtxAQIDBg4cGAOBeQB3jAF4iUkBH0AQGxcG + hY6Oi3MEBnSLj49nEBsXCAUBAQIGCwsGAgEDBxMYFwgPFxcVFxQXFxcUFQwKGE9sBQ8XGBgXFxcXFxIF + XkpqgWwKFBcXFxgXGBgHXoBNSWhPFxcXFxcXFxcXF0pNQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAQAAAAIAAAAABABgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgCQcgCQchBkdgBochBkdgBocgBochBkdhBkdhBkdhBkdhh8ehyUdhyUd + hicdhyUdhyUdhicdiSceiSceiSceiScejCgfjCgfjCgfjCgfiSceiScejCgfjCgfjCgfjCgfiSceiSce + jCgfjCgfjCgfjCgfiScehyUdiSceiScejCgfiScehyUdhyUdhyUdhyUdhyUdhyUdhyUdhCQcgh4cgh4c + gh4chBkdgh4cgBocgBocgh4chh8ehh8ehyUdiScegiEcgigdijkci0Mdi0Mdi0Mdi0Mdi0Mdi0MdjUEd + iz8diDYchicdhCQchyUdhCQchCQchyUdhicdhyUdhyUdhyUdhyUdiScejCgfiScehyUdhyUdhyUdjCgf + jCgfiCsfhyUdhyUdiScejCgfjCgfjCgfhyUdhyUdiSceiScejCgfjCgfhyUdhyUdhyUdiSceiScehyUd + hCQciScejzMdkTgekz0elT8flT8fkz0ekz0ekz0el0EhkTgeiCsfhCQceRgbgzwblX8bmp4amp4amp4a + mp4amp4anKMbmZoZmowckG0biDYcgBocgiEchCQchCQchCQchCQchCQchCQchCQchCQchh8ehyUdhyUd + hh8ehyUdhCQchyUdhyUdhCQchCQchCQchyUdhicdiCsfiScehCQchCQciScejCgfjCgfiScehicdhCQc + hCQciSceiScehicdgh4ciTIcpV8gt3shuYQhvoojvocjvocjvocjvoojvoojsW8hkTgefB4aeRgbgUEZ + mp4ap84apsoZpsoZpsoZpsoZp84apMUaobUalocbhDkbgBocgh4cgiEcgiEcgiEcgiEcgiEcgiEcgiEc + giEchCQchCQcgiEcgiEcgiEchCQcgCQchCQchCQcgiEchCQcgCQchyUdhCQchicdgCQchCQchCQchicd + iCsfhicdgCQchCQchCQchicdiCsfhicdfB4ajTcds3UhyZsk0qkl1a0m06wl1a0m0qkl0qkl06wlvocj + kz0eeRsZeRgbgUEZmp4apsoZpMUapMUapsoZp84ap84apsoZobUalocbgzwbeRgbfB4agCQcgiEcgCQc + gCQcgCQcfSQbgCQcgCQcgCQcgCQcgCQcgiEcfSQbgCQcgCQcgCQcgiEcgiEcgiEcgCQcgCQcgCQcgCQc + gCQcgCQcgCQcgCQcgCQcgCQcgCQceycbhCQcgigdgigdgCQcfB4ajTcds3UhyZsk0qkl1a0m1a0m06wl + z6Ulz6Ul0qklu4cjijsceRgbchMZfz8Zmp4apMUapMUaobUanKMbmp4amp4amZoZlI0ZkG0bgTUbeRsZ + fB4aeiEagiEceiEagCQcfSQbeiEaeiEaeiEagCQcgCQcfSQbeiMaeiEagiEcgCQcgiEceiEaeiEafSQb + gCQcgCQceiEafSQbeiEaeiEafSQbgiEcfB4afSQbfSQbfSQbfSQbfSQbgCQcgCQceRsZgzIbpV8gsHkh + uYQhvoojuYQhvoojyZskz6Ul0qklu4cjijscchgZchMZgUEZmp4apsoZpsoZnKMbh1sbfDYafD8Zfz8Z + fD8ZdC8ZeiUbdh8ZdCEZeiMaeiEaeiMaeiEaeiEaeiMafSQbeiEaeiEafB4adh8ZfB4aeiEafSQbeiMa + eiEaeiEaeiEafSQbfSQbfSQbgCQcfSQbeiEaeiEafSQbfSQbeiMaeiMaeiEaeiEaeiEaeiEaeiEaeiEa + dh8ZfSQbgzIbiDYchDkbijkcgTUbl08dvooj06wl06wlu4cjijscbhoYbhQXfD8Zmp4ap84ap84amZoZ + fDYabwsZchMZchMZchgZeRsZdCEZdCEZdSMbdCEZdCEZdCEZeiEadCEZeiEadCEZeiEadh8ZdCEZdh8Z + dh8ZeiEaeiEaeiMaeiEaeiEadh8ZeiMafSQbeycbfSQbeiUbeiEaeiEafSQbfSQbeiMaeiMaeiEadh8Z + dCEZeiMaeiEadCEZeiMadh8ZchsYchsYchgZbhQXbA8YgTUbuYQh1a0m1a0mu4cjhDkbahcYbhQXfD8Z + mp4ap84ap84amp4aeT0ZbA8YchgZchsYch8Zch8ZdCEZdCEZbyEZdCEZdCEZdCEZdCEZdCEZdCEZdCEZ + dCEZdCEZdh8Zch8Zch8ZdCEZdCEZeiEadCEZdCEZdh8ZdCEZeiMaeiUbdSMbeiEadCEZdCEZeiUbeiUb + eiMaeiMadCEZdCEZeiMadSMbeiEadSMbdCEZdh8ZdCEZdh8Zch8ZchsYbhQXhDkbvocj1q8n1q8nu4cj + hDkbahcYaRUZdTsZmZoZpsoZpMUamZoZeT0ZbhQXbhoYbh8Zch8Zch8Zch8ZbyEZbyEZbyEZdCEZdCEZ + dCEZch8ZdCEZbh8Zch8Zch8ZdCEZbyEZbyEZbyEZdCEZbyEZdCEZch8ZdCEZdCEZdCEZdSMbdCEZdCEZ + ch8Zch8ZdSMbdSMbdSMbdCEZch8Zch8ZdSMbdSMbdCEZdCEZdCEZch8ZdSMbdCEZdCEZchsYahcYgTUb + uYQh0qkl0qkluYQhfTkZaRUZaRUZdTsZlI0ZlrEZobUalI0ZdTsZaRUZbhoYax8Ych8Zax8Ybh8Zbh8Z + bB0Xch8Zch8Zbh8Zbh8ZbB0Xbh8Zbh8Zbh8ZbyEZbh8Zbh8Zch8Zbh8Zbh8Zbh8ZbyEZbh8ZbyEZbh8Z + byEZch8ZbyEZch8ZbyEZbyEZbyEZbyEZbh8Zbh8Zbh8ZbyEZdCEZdSMbdCEZbyEZbh8Zbh8ZbyEZdSMb + byEZch8ZaBoXfDYasHkhyZskyZsksHkhdzUbZBYXZBYXbzEYhGkZjoUZjoUZhGkZbzEYahcYaBoXbB0X + bB0Xax8YbB0XbB0XbB0Xax8YbB0XbB0Xax8YbB0XbB0XbB0Xbh8Zbh8Zax8Yax8Yax8Yax8Yax8Yax8Y + ax8Yax8Yax8Yax8YbB0Xbh8Zax8Yax8Ybh8ZbB0Xax8YbB0Xax8Yax8YbB0Xax8Yax8YbyEZax8Yax8Y + bB0XaSMXbyEZbyEZbyEZbB0XaBoXcS0ZmV0eq3Qhq3QhmV0ecS0ZYxsXYxsXaSMXbzEYcDcXcDcXbzEY + aSMXaBoXZR0XZR0XZR0XaBoXZR0XbB0XZR0XbB0XZR0XZR0XaBoXZR0XZR0XbB0XZR0XbB0XZR0XZR0X + ZR0XZR0XZR0XbB0XZR0XZR0XZR0XZR0XZR0XaBoXZR0XbB0XZR0XbB0XZR0XZR0XYxsXZR0XbB0XZR0X + ax8YbB0XZR0XZR0XYxsXaBoXZR0Xax8YZR0XZR0XZR0Xax8YcS0ZdzUbdC8ZcS0ZaSMXYxsXZR0XXhsW + YRQXYRQXYRQXYRQXYxsXZR0XYxsXYxsXYxsXZR0XZR0XYxsXYxsXYxsXYxsXYxsXYxsXZR0XYxsXZR0X + ZR0XZR0XYxsXYxsXYxsXYxsXYxsXZR0XZR0XZR0XZR0XYxsXYxsXYxsXYxsXZR0XZR0XZR0XYxsXYxsX + YxsXZR0XYxsXZR0XYxsXZR0XZR0XYxsXYxsXYxsXYxsXZR0XZR0XZR0XZR0XYxsXXxcXYRQXWRoUXxcX + XhsWYxsXXhsWXhsWXhsWXxcXXxcXZBYXYxsXYxsXXhsWXhsWXhsWYxsXYB0XYxsXZR0XXhsWYxsXYB0X + YB0XYxsXZR0XYxsXYxsXXhsWXhsWYB0XYxsXYxsXYxsXYxsXYxsXXhsWXhsWXhsWYB0XZR0XYxsXYxsX + YxsXXhsWXhsWYB0XXhsWZR0XXhsWZR0XXhsWXhsWXhsWYB0XYB0XZR0XZR0XYxsXYxsXYxsXXhsWXhsW + XhsWXhsWXxcXWRoUXhsWXhsWXhsWXhsWXhsWXhsWYB0XXhsWYxsXWRoUXhsWXhsWXhsWYB0XYxsXXhsW + XhsWXhsWWRoUXhsWXhsWXhsWYB0XXhsWXhsWXhsWXhsWXhsWWRoUYB0XYB0XYxsXXhsWXhsWXhsWXhsW + XhsWXhsWYB0XYxsXXhsWXhsWXhsWXhsWXhsWYB0XXhsWYxsXXhsWXhsWXhsWXhsWXhsWXhsWYB0XXhsW + XhsWXhsWXhsWXhsWXhsWXhsWWRoUXhsWWRoUXhsWWRoUXhsWXhsWWRoUXhsWWRoUXhsWWRoUXhsWWRoU + XhsWWRoUXhsWWRoUXhsWXhsWWRoUXhsWWRoUXhsWWRoUXhsWXhsWWRoUXhsWXhsWXhsWWRoUWRoUXhsW + WRoUXhsWXhsWWRoUXhsWWRoUXhsWWRoUXhsWWRoUXhsWWRoUWRoUXhsWXhsWXhsWXhsWWRoUXhsWWRoU + WRoUXhsWWRoUXhsWWRoUXhsWWRoUXhsWWh4WWh4WWh4WWh4WWh4WWh4WXxcXWRoUWRoUWRoUWRoUWRoU + WRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoU + WRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoUWRoU + WRoUWRoUWRoUXxcXWRoUWRoUWRoUVRkUWRoUWRoUWh4WWh4WWh4WWh4WVh0VVRkUVRkUWRoUUhkUVRkU + VRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkU + VRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkU + VRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVRkUVh0VVh0VUhkUUhkU + Vh0VVh0VUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkU + UhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkUUhkU + UhkUUhkUVRkUVyQUaE8Xd2QYeW8XeW8XcV0XZUMVXS0VUhkUUhkUUhkUUhkUUhkUUhkUThgTUhkUURsV + URsVURsVThgTShcTURsVURsVThgTThgTThgTUhkUUhkUUhkUUhkUThgTThgTThgTUhkUaE8Xu/8fu/8f + u/8fuPkdu/8fuPkdu/8fu/8fu/8fs/Idp84alrEZiZEZVzUTUhkUThgTUhkUThgTUhkUThgTThgTThgT + ThgTUhkUThgTUhkUVyQUf34XpMUauPkdu/8fu/8fu/8fuPkdu/8fu/8fu/8fuPkdnb0bd2QYUhkUThgT + ThgTUhkUThgTSRkTSRkTThgTSRkTShcTShcTSRkTShcTShcTThgTThgTThgTShcTThgTShcTThgTShcT + ThgTaFIWu/8fuPkdu/8fu/8fu/8fu/8fwv4fuPkdu/8fu/8fu/8fu/8fu/8fuPkdkacZXTkVThgTThgT + ShcTThgTThgTShcTThgTThgTThgTf34Xsu4du/8fu/8fu/8fu/8fuPkdu/8fu/8fu/8fu/8fuPkdu/8f + uPkdu/8frecbhYkXThgTShcTShcTSRkTSRkTSRkTShcTRhcSRhcSShcTShcTShcTShcTShcTShcTShcT + ShcTShcTShcTShcTShcTY1EVu/8fwv4fu/8fu/8fu/8fu/8fu/8fu/8fu/8fu/8fu/8fuPkdwv4fu/8f + uPkdsu4dVzUTShcTShcTShcTShcTShcTShcTTCESlrEZu/8fuPkdu/8fuPkdu/8fu/8fwv4fu/8fu/8f + uPkdu/8fu/8fu/8fu/8fu/8fwv4fqt8bShcTShcTShcTSRkTSRkTRhcSRhcSRhcSRhcSRhcSQhURQhUR + QhURShcTQhURQhURShcTQhURQhURQhURQhURY1EVu/8fu/8fuPkdu/8fu/8fuPkdu/8fu/8fu/8fuPkd + u/8fu/8fu/8fu/8fu/8fu/8fp84aURsVQhURShcTQhURQhURRhcSlroZuPkdu/8fu/8fu/8fu/8fwv4f + uPkdu/8fu/8fu/8fwv4fu/8fu/8fu/8fu/8fu/8fu/8fqt8bShcTRhcSRhcSSRkTQhkURhcSQRcRQRcR + QRcRRhcSQhURQhURQhURQhURQhURQhURQhURQhURQhURQhURQhURYE8Vu/8fu/8fu/8fu/8fu/8fY1EV + QhURQhURTCESW0ETh5cZtvUdu/8fuPkdu/8fu/8fu/8ffYMXQhURQhURQhURQhURhYkXu/8fu/8fu/8f + u/8fu/8fu/8fu/8fka0Zd3sXY1cUUzMTXUkVbWkVpsoZu/8fuPkdu/8fuPkdqt8bQhURQhURRhcSQhkU + QRcRQRcRQhURQhURQRcRQhkUQhURQhURQhURQhURQhURQhURQhURQhURQhURQhURQhURYE8Vu/8fuPkd + u/8fu/8fuPkdYE8VPhURQhURPhURQhURQhURY1cUuPkdu/8fu/8fu/8fu/8flrEZQhURQhURQhURRywS + tvUdu/8fu/8fuPkdu/8fu/8fqt8bY1cUPhURQhURPhURQhURQhURPhURfIkXu/8fu/8fu/8fwv4fqt8b + QhURQhURQhURQRcRQRcRPhURPhURPhURPhURQhkUPhURPhURPhURPhURQhURQhURQhURQhURPhURPhUR + PhURYE8Vu/8fu/8fu/8fu/8fu/8fYE8VPhURPhURPhURPhURPhURPhURptEbu/8fu/8fu/8fu/8frecb + QhURPhURQhURg5MXu/8fu/8fu/8fu/8fu/8fsu4dSScRPhURPhURPhURPhURPhURPhURQhURfIkXuPkd + u/8fu/8fu/8fqt8bQhUROBMPPhUROhUQOhUQOhUQOhUQOhUQOhUQOhUQOhUQPhURPhURPhUROBMPOBMP + OBMPOBMPOBMPPhUROhUQXUkVu/8fwv4fuPkdu/8fu/8fVU0TPhURPhUROBMPPhUROBMPOBMPpMUau/8f + u/8fuPkdu/8fuPkdOBMPOBMPPhURqt8buPkdu/8fwv4fuPkdu/8fcXcVPhURPhURPhUROBMPQhUROBMP + OBMPOBMPfIkXu/8fu/8fwv4fuPkdqt8bOBMPPhUROhUQOhUQOBMPOBMPOBMPOhUQNhUROhUQOhUQOBMP + OBMPOBMPOBMPOBMPQhUROBMPPhUROBMPOBMPVU0Tu/8fu/8fu/8fu/8fu/8fW08UOBMPOBMPOBMPOBMP + PhURQR8Rsu4du/8fu/8fu/8fu/8fptEbPhUROBMPTTkTu/8fu/8fu/8fu/8fu/8fqt8bPhUROBMPOBMP + OBMPOBMPOBMPOBMPPhUROBMPfIkXuPkdu/8fu/8fu/8fqt8bPhUROBMPOhUQOhUQOBMPNhURNhURNhUR + NBMQNhUROBMPOBMPOBMPOBMPOBMPOBMPOBMPOBMPOBMPOBMPOBMPVU0Tu/8fu/8fu/8fwv4fuPkdVU0T + OBMPOBMPOBMPOBMPQikRlroZu/8fu/8fuPkdu/8fu/8fe5EVOBMPOBMPZWwUuPkdu/8fu/8fuPkdu/8f + iKUZOBMPOBMPOBMPOBMPTz8TdocWfIkXfYMXfIkXl8EZu/8fu/8fu/8fu/8fqt8bOBMPOhUQOhUQNhUR + NhUROBMPNBMQNhURNhURNhURNBMQNBMQNBMQNBMQMRIPOBMPMRIPOBMPMRIPNBMQNBMQVU0Tu/8fuPkd + u/8fu/8fu/8flroZg6EXiKUZiKsYmsYatvUduPkdu/8fu/8fu/8fu/8fpNYbNxwPOBMPNBMQanMVwv4f + u/8fu/8fu/8fu/8fdYMXNBMQNBMQMRIPNBMQZWwUuPkdu/8fu/8fu/8fu/8fu/8fuPkdu/8fu/8fqt8b + NBMQOBMPNhURNhURNBMQNBMQNBMQNBMQNhURNxwPNBMQOBMPMRIPOBMPMRIPMRIPOBMPMRIPOBMPMRIP + MRIPVU0Tu/8fu/8fu/8fu/8fu/8fu/8fu/8fu/8fwv4fuPkdu/8fu/8fu/8fu/8fwv4fl8EZRi8ROBMP + MRIPNBMQdocWu/8fu/8fu/8fwv4fuPkdXF8TMRIPNBMQNBMQNBMQZWwUwv4fu/8fu/8fuPkdu/8fu/8f + wv4fu/8fu/8fqt8bNBMQNBMQNBMQNBMQMRIPMRIPNBMQNBMQNhURNhURNBMQMRIPMRIPMRIPMRIPMRIP + MRIPMRIPNBMQMRIPOBMPVU0TuPkdwv4fu/8fu/8fuPkdu/8fu/8fuPkdu/8fu/8fu/8fu/8fsu4djbQZ + anMVMBUOMRIPMRIPNBMQNBMQbXcVuPkdu/8fu/8fu/8fu/8fYGITOBMPMRIPMRIPMRIPZWwUuPkdu/8f + u/8fu/8fu/8fuPkdu/8fu/8fuPkdqt8bMRIPMRIPMRIPMRIPMRIPMRIPMRIPMRIPMRIPMRIPNBMQMRIP + MRIPLhEOMRIPMRIPMRIPMRIPMRIPMRIPMRIPT0sRu/8fu/8fu/8fu/8fu/8fu/8fu/8fu/8fu/8fu/8f + u/8fu/8fqt8bbn4VNxwPMRIPLhEOMRIPMRIPMRIPYGITu/8fu/8fu/8fu/8fuPkddocWMRIPMRIPMRIP + MRIPXF8Tqt8bqt8bqt8bqt8bqt8bqt8bqt8bqt8bqt8bmsYaMRIPMRIPMRIPMRIPLhEOMRIPMRIPMRIP + LhEOLhEOMRIPMRIPLhEOLhEOLhEOMRIPMRIPMRIPLhEOLhEOLhEOT0sRu/8fu/8fuPkdu/8fu/8fg6EX + docWdocWe5EVns4bu/8fuPkdwv4fu/8fpNYbQzcPLhEOLhEOMRIPLhEOTz8Tu/8fu/8fuPkdu/8fu/8f + ja8ZLhEOMRIPLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOMRIPLhEOMRIPMRIPMRIP + MRIPLhEOMRIPMRIPMRIPLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOVU0TuPkdu/8f + u/8fu/8fu/8fT0sRLhEOLhEOLhEOLhEOdocWu/8fu/8fu/8fu/8frecbNh8PLhEOLhEOLhEOMBUOsu4d + u/8fu/8fu/8fu/8frOMdNxwPLhEOLhEOLhEOLhEOLhEOLhEOMRIPLhEOLhEOLhEOLhEOLhEOLhEOLhEO + LhEOMRIPMRIPMRIPLhEOMRIPMRIPLhEOMRIPMRIPLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEO + LhEOT0sRu/8fwv4fu/8fuPkdwv4fT0sRLhEOLhEOLhEOLhEOMRIPrOMdu/8fu/8fu/8fu/8fg5MXLhEO + MRIPLhEOLhEOiKsYu/8fu/8fu/8fu/8fu/8feY0XLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEO + LhEOLhEOLhEOLhEOLhEOLhEOLhEOMRIPMRIPLhEOMBUOMBUOMBUOKxMPMRIPJw0MLhEOLhEOLhEOLhEO + LhEOLhEOLhEOJw0MLhEOT0sRu/8fuPkdu/8fu/8fu/8fT0sRLhEOJw0MLhEOLhEOLhEOl8EZu/8fuPkd + u/8fu/8fqt8bLhEOLhEOLhEOLhEOVU0TuPkdu/8fwv4fuPkdu/8fuPkdQzcPLhEOLhEOJw0MLhEOLhEO + LhEOLhEOLhEOLhEOLhEOLhEOLhEOKRANLhEOLhEOLhEOLhEOLhEOLhEOKxMPMBUOMRIPMRIPLhEOLhEO + LhEOJw0MLhEOJw0MLhEOLhEOLhEOLhEOLhEOT0sRu/8fu/8fu/8fuPkdu/8fT0sRLhEOLhEOKRANKRAN + LhEOrecbu/8fu/8fu/8fu/8fu/8fKRANLhEOKRANLhEOKRANl8EZu/8fu/8fu/8fu/8fu/8fsu4dZWwU + LhEOLhEOKRANLhEOLhEOLhEOLhEOKRANLhEONyMNVVcTJw0MLhEOLhEOLhEOLhEOLhEOLhEOLhEOLhEO + LhEOLhEOLhEOKRANKRANLhEOKRANLhEOLhEOLhEOLhEOKRANLhEOT0sRu/8fuPkdu/8fu/8fu/8fT0sR + KRANKRANLhEOQzoQjbQZu/8fu/8fu/8fu/8fu/8fptobLhEOKRANLhEOKRANLhEOQzoQsu4du/8fu/8f + u/8fuPkdu/8fu/8fl8EZZWwURT8PLhgNKRANOywPR0ERVVcTiKsYs/Idl8EZLhEOLhEOLhEOLhEOLhEO + LhEOLhEOLhEOLhEOLhEOLhEOKxEOKRANLhEOJw0MLhEOKRANLhEOKRANKRANLhEOJw0MT0sRu/8fwv4f + u/8fu/8fu/8foNEbl8EZpNYbsu4du/8fu/8fu/8fuPkdu/8fu/8fu/8fiKsYKRANLhEOKRANLhEOKRAN + KRANVVcTuPkdu/8fu/8fu/8fu/8fuPkdu/8fu/8fu/8fu/8fu/8fu/8fu/8fu/8fu/8fu/8fl8EZKRAN + KRANKRANLhEOKRANLhEOKRANLhEOKxEOLhEOKRANKRANLhEOJw0MLhEOKRANKxEOKxEOKRANLhEOJw0M + KRANT0sRu/8fu/8fuPkdu/8fu/8fuPkdu/8fu/8fu/8fu/8fuPkdu/8fwv4fu/8fuPkdrecbQzcPKRAN + LhEOKRANKRANKRANLhEOKRANWVsTsu4dwv4fuPkdu/8fu/8fu/8fu/8fu/8fwv4fuPkdu/8fuPkdu/8f + u/8fu/8fl8EZKRANKxEOKxEOLhEOLhEOKRANKxEOLhEOLhEOLhEOKxEOKRANKRANJw0MLhEOKRANLhEO + KxEOKRANKRANKRANJw0MT0sRu/8fu/8fu/8fu/8fu/8fu/8fu/8fuPkdu/8fu/8fu/8fu/8fu/8fu/8f + qt8bPzQPKRANLhEOKxMPKRANKRANKRANKRANLhEOKRANPzQPl8EZu/8fu/8fu/8fuPkdu/8fu/8fu/8f + u/8fu/8fwv4fu/8fu/8fu/8fl8EZKRANKRANLhEOKxEOLhEOKxEOLhEOKxMPKxMPKxMPLhEOKRANKRAN + LhEOJw0MKRANKRANKRANKRANKRANJw0MLhEOT0sRu/8fu/8fu/8fwv4fuPkdu/8fu/8fu/8fu/8fuPkd + u/8fs/Idl8EZWVsTKRANLhEOKRANKRANKRANKRANLhEOJw0MKRANJw0MKRANKRANKRANT0sRkLgZtvUd + wv4fu/8fu/8fuPkdu/8fu/8fu/8fuPkdu/8frecbc4cVKRANKRANKRANKRANKxEOKxEOKxEOMRIPKxMP + LhEOKxEOKRANJw0MKRANKRANJw0MLhEOKRANKRANJw0MLhEOJw0MMRsNT0sRT0sRT0sRT0sRT0sRT0sR + T0sRT0sRT0sRPzQPMRsNKRANKRANKRANKRANKRANJw0MLhEOKRANKRANJw0MKRANKRANKRANJw0MLhEO + KRANKRANKRANMBUOR0ERZWwUc4cVf5wXg6EXc4cVbn4VXWYTPzQPJw0MKRANKRANKRANLhEOKRANLhEO + LhEOKxEOKxEOKxEOKxEOKRANKRANKRANLhEOKRANKRANKRANJw0MLhEOKRANKRANKRANKRANKRANKRAN + Jw0MKRANKRANKRANJw0MKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANJw0MKRANLhEOKRAN + KRANKRANKRANJw0MKRANKRANKRANKRANKRANJw0MKRANKRANJw0MKRANKRANKRANKRANKRANLhEOJw0M + Jw0MJw0MKRANKRANKRANKRANKxEOKxEOKxEOKRANKxEOKRANKRANKRANKRANKRANKRANKRANKRANKRAN + KRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANJw0MLhEOKRANKRANKRANKRANKRANKRAN + KRANLhEOKRANKRANKRANKRANKRANKRANJw0MLhEOKRANKRANKRANKRANKRANKRANKRANKRANKRANKRAN + KRANKRANKRANJw0MLhEOLhEOJw0MLhEOLhEOKRANLhEOKRANKRANKRANKRANKRANKRANKRANKRANKRAN + LhEOKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRAN + KRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANLhEOKRANKRANKRANKRANKRANKRANKRANKRAN + LhEOKRANKRANKRANKRANKRANKRANKRANJw0MKRANKRANKRANKRANLhEOKxEOKxEOLhEOKRANKRANKRAN + KRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANLhEOKRANKRANKRANKRANKRANKRANKRAN + LhEOKRANKRANKRANKRANKRANKRANKRANLhEOKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRAN + KRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANLhEOKRANLhEOMBUOKxMPKxMP + KxEOKRANKRANJw0MJw0MJw0MIwoMJw0MJw0MKRANKRANKRANJw0MKRANKRANKRANKRANKRANJw0MKRAN + KRANKRANKRANKRANKRANJw0MKRANKRANKRANKRANKRANKRANKRANKRANJw0MKRANJw0MKRANKRANKRAN + KRANJw0MKRANJw0MKRANKRANKRANKRANKRANJw0MKRANKRANJw0MKRANKRANJw0MJw0MKRANKRANKRAN + KRANJw0MKRANKRANKRANKRANKRANJw0MIQUMIAILIAILIAILJw0MKRANKRANKRANJw0MKRANKRANKRAN + KRANJw0MKRANKRANKRANKRANJw0MKRANKRANKRANKRANJw0MKRANJw0MKRANKRANKRANKRANKRANKRAN + KRANKRANJw0MKRANKRANKRANKRANKRANJw0MKRANKRANKRANKRANKRANJw0MKRANKRANKRANJw0MKRAN + Jw0MKRANKRANJw0MIwoMIQUMIQUMIwoMJw0MKxEOJw0MLhgNOywPQDcPQzcPOywPLhgNJw0MKRANKRAN + KRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRAN + KRANKRANKRANKRANJw0MKRANKxMPJw0MKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRAN + KRANKRANKRANKRANKRANKRANJw0MMBUOPSUPRywSQikRPSUPMBUOKRANIQUMOywPbn4ViKsYiKsYbn4V + OywPIQUMJw0MKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANJw0MKRANKRANKRANKRANJw0M + KRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANJw0MKRANKRANKRANKRANKRANKRANKRANKRAN + KRANKRANKRANKRANKRANKRANKRANKRANKRANJw0MIQUMPSUPd2QYlX8bk4Med2QYPSUPIQUMIAILQDcP + jbQZsu4dsu4djbQZQDcPIAILIwoMKRANKRANKRANJw0MKRANKRANKRANKRANKRANKRANKRANKRANLhEO + KRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANJw0MKRANKRANKRAN + KRANKRANJw0MKRANKRANKxMPKRANKRANKRANKRANKRANLhEOKRANJw0MIQUMRi8Rmowcxbckxbcklocb + Ri8RIQUMHQILRT8PmsYawv4fwv4fmsYaRT8PIAILIwoMKRANKRANJw0MKRANKRANKRANKxMPKRANKRAN + KRANKRANKRANKxMPKxMPKxEOKRANKRANKRANLhEOKRANKRANKRANKRANKRANKRANKRANKRANKRANJw0M + KRANKRANKRANLhEOKRANLhEOJw0MLhEOKRANKRANKxMPKRANKRANKRANKRANKRANKRANJw0MHQILRzER + qJog08cn18snqJogRzERHQILHQILRT8Pns4byf8fyf8fns4bQzoQHQILIAILJw0MIwoMJw0MJw0MKRAN + KRANKRANKRANKRANKRANKRANKRANKxEOKxEOKRANKRANKRANKxEOKxEOKxEOLhEOKRANKRANLhEOKRAN + LhEOKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANJw0MJw0M + Jw0MIQUMHQILRi8RrZ8h3tQp3tQprZ8hSjMRHQILHQILRT8Pns4byf8fyf8fmsoaPzQPEgEJHQILHQIL + IAILIQUMJw0MKRANKRANKRANKRANJw0MKRANKRANKRANKRANKxEOKRANKRANKRANKxEOKxEOKxMPKRAN + KRANKRANKRANKxMPKxEOKxEOKRANKRANLhEOKRANLhEOKRANKRANJw0MLhEOKRANKRANKRANKRANKRAN + Jw0MJw0MIwoMIAILHQILHQILEgEJQikRqJog3tQp3tQprJ0hSjMRHQILHQILRT8Pns4byf8fwv4fpNYb + XWYTPzQPQzoQRT8PQDcPOywPLhgNJw0MKRANKRANJw0MKRANJw0MKRANJw0MKRANKRANKRANKRANKRAN + KRANKRANKxEOKRANKRANKRANKxEOLhEOKxMPKRANKRANKRANKxEOKxEOKxEOKRANLhEOKRANKRANKRAN + KRANKRANKRANJw0MJw0MMBUOPSUPRi8RRzERRzERPSUPY1EVsqUh18sn2tAorJ0hSjMRHQILHQILRT8P + ns4bwv4fwv4fs/IdpNYbmsoans4bmsYakLgZboEVOywPIQUMJw0MKRANKRANJw0MKRANKRANKRANKRAN + KRANJw0MJw0MKRANKRANKRANKRANKRANJw0MKRANKRANKRANKxEOKRANKRANKRANKxEOKxEOKxMPKxEO + KRANKRANLhEOKxEOKxMPKxEOKRANJw0MIwoMPSUPd2QYm4keqJogrJ0hqJogsqUhxbck08cn2tAoqJog + SjMRHQILHQILRT8Pns4bwv4fwv4fwv4fwv4fyf8fyf8fwv4fs/IdiKsYPzQPIAILJw0MKRANKRANKRAN + Jw0MKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANJw0MKRANKRANJw0MKRANKRANKRANKRANKRAN + KRANKRANKxEOKRANJw0MKRANKRANKxMPKxEOKxMPJw0MJQ0NIQUMQy4Sk4Mexbck18sn3tQp2tAo2tAo + 08cn08cn2tAorZ8hSjMRHQILHQILRT8PoNEbyf8fyf8fwv4fyf8fyf8fyf8fwv4fs/IdiKsYPzQPHQIL + JQ0NKxMPKRANKRANKRANKRANKRANKRANKRANJw0MKRANKRANKRANKRANKRANKRANJw0MKRANKRANKRAN + KRANJw0MJw0MKRANKRANKRANKRANKRANKRANJw0MKRANKRANKRANKRANKRANJw0MIQUMQy4SlX8bxbck + 18sn3tQp3tQp2tAo18sn2tAo2tAorZ8hTDYUIQUMIAILPzQPf5wXns4bns4bns4bns4bns4bns4bmsYa + jbQZbn4VOywPIQUMJw0MKRANKRANJw0MJw0MKRANKRANKxMPKRANKRANJw0MKRANKxEOKxEOKRANKRAN + KRANKRANKRANKRANKRANKRANKRANKRANKRANKRANKRANJw0MKRANKRANJw0MKRANKRANKRANKRANIwoM + IwoMNyMNd2QYlocbqJogrZ8hqJogrJ0hrJ0hrJ0hrJ0hi3kbQy4SIwoMJQ0NLhgNPzQPRT8PRT8PRT8P + RT8PRT8PRT8PRT8PQDcPOywPLhgNIwoMJw0MKRANKRANJw0MKRANJw0MKRANKRANKRANJw0MKRANKRAN + KRANKxEOKRANKRANKRANKRANKRANKRANKRANJw0MJw0MKRANKRANKxEOKRANKRANKRANJw0MKRANKRAN + Jw0MKRANKRANJw0MJw0MMBUOPSUPQy4SRzERRzERSjMRSjMRSjMRSjMRSjMRQikRMBUOJw0MKRANJQ0N + HQILHQILHQILHQILHQILHQILHQILHQILHQILHQILIwoMKRANKRANKRANJw0MJw0MJw0MKRANKRANJw0M + Jw0MJw0MJw0MKRANKxEOLhEOKRANJw0MJw0MKRANKxMPKxMPKRANKRANKRANKRANKxEOLhEOKRANJw0M + Jw0MKRANKRANKRANKRANJw0MJw0MJw0MJw0MJw0MIQUMIQUMHQILHQILHQILIAILHQILIAILHQILIQUM + JQ0NKxEOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoAAAAMAAAAGAAAAABABgAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgSMdgh8dgxwdgx0dgh0dgx0dhBwdhhwdhh8dhyQdhyYdhiUchiUciCcd + iScdiCYdiicdjCgejSkfiiceiSYdiycfjSkhiykgiCYdiicejSggjCkhiSceiCUciiUdjCYeiyYfiCYd + hyQbiCUchyUchyUdhSMdhCAcgx8chB8cgx8cgx4bhB8chyEeiCUeiCYdfyIciUUbkGEbkWIbkGEbkWEb + kWEbkFobjEkbhiobhSIchCQbhSQbhiUchiUdhSQdhyUdiSUdiSYeiCQdhyQciCYeiScfiCcehiQdhyUd + iicfiygfhyYdhiUbiScdiygfiigfhiYchiUciCcdiCcehCMciCocmEUeoFMfo1cgo1YgolYfo1cgolUh + kTgegyMbfCEaknoZor4Yo78Zo78ZpMAZo8EZn7EYloQahTEagB0agSIagiIagyIcgiIcgSIcgiIchCMc + hCMchCIcgyIbgyQcgyQchCQcgyIchCQchSYdhiYdhCUbgyQahScdiCkfhigegyUbhCUchigdhykfgSEc + izUctHchyZsjz6QkzqMlzaIlzKElyZsknVMefB4aeiEbkoAapMUYo8MYpcUZpskZpMkZoLgZlYgagDIa + fBwafyIagCIbgCMcfyMcfyMbfyMcgSQdgSQdfiIbfiMbgSQbgSMbgCIagCIagSMbgCMbgCMbfyMbgCMb + gCMbgCMcgCQbfyQagCQbgiYcgyYdfR8bijQctnwhzKAj06sm0qklz6YlzqUlzKEknFQeeBwZdiAZkH4Z + pMYZo8AZmJgakHwZkH4ZjnYZiFsZeysZeR4ZeyEafCIbfSIbfCMaeyIZfCIbfSMcfCMbeyIaeyIafiMc + fiIbfCEafSIafiMbfiQbfiQbfCIafCIafiMafSIafCIZfCMZfCMZfSMafSMaeh8ZgiwamlQep2kfq24f + qm0gv4wiz6UlzaIkmlQddBsYcx4Yj34Ypskao8Eah18ZcxkZdB4ZdiEYdSEXdSIYdSIYdiEZdyEZeCEZ + eCEYeCEYeCEaeSAaeCAZdx8YeCAZeyIceiIbeSAaeSEZeyQafCYcfCUbeiIZeSEYfCUbfCQaeiIZeCEY + eCEYeSIZeCEZeCEZdyEYdyEZdyIZdR4YdSAZqW0f06klzqMll1QdcBsYcB0Xjn8YpsoapMIahV0ZbxMY + cBgYcx0Ycx8YciAYciEYcyEZdCEZdSEZdCEZdCEYcyEZdCAZdCAZcx8YdCEZdiEZdiEZdiAYdSAYeCIa + eSQbdyIadSAYdiEZeSQceSMbeCIadSEZdiIaeCMceCIbdSEZdCAZdSAZdB8ZcRsYch0YqGwf06smz6Ql + lVMdaxkYbB4Yi3cZor0aoLYagloYbBcXbhsYcB8ZcCAZbyAZbx8XcSAYcSAYcSAYcB8YcB8YcCAZcSAY + cCAYcCAXcCAYcSAYcSAYcSAYcSAYcyEZdCEacyEZciAYciAYcyIacyIaciAZcSAYcyIadSMbdCEaciAY + cSAYcyIadCIacR4ZcCAYo2gfzKEkyJokkE8cZxgXaB4Yf10Yko4Zj4kZekgYahkXahwYbB4YbB4YbB4Y + bB0Xbh4YbR4YbB4YbB0XbB4YbR4Ybh8YbB8YbB8XbB8YbB8Yax8Yax8Yax8YbB8YbR8YbR8Ybh8XbR8W + bB8Xax8Xax4WbB8XbiAZbyEZbiAYbB8Xax8XbiIabyEbbR4Zax8XkVIdsHwhrXYgg0EaZBoWZR0XaioX + bjMXbjIXayUXZxwXZhwXZhwXZhwXZxwXaB0XaB0XZh0XZhwXZhwXZxwXaB0XaB0XZh0XZhwXZhwXZxwX + aB0XZx0XZh0XZRwXZxwXZxwXaB0XZx0XZh0WZRwXZhwWZxwWaB4XaB4XZh0XZRwWZhwXaB0XaR4XZx0W + Zx0WbygXdTEaczAZaSQXYhwVYhwWYBgWYBUXYhUXYxkWYxwWYhwWYRsWYxwXZBwXZBwWYxwWYhwWYRsW + YxwXZBwXZBwWYxwWYhwWYRsXYxsXZBwXZBwWYxwWYhwWYRsWYxsXZBwXZBwWYxwWYhwWYRsXYxwXZBwX + ZBwWYxwWYhwWYRsXYxsXZBwXZBwWYxwVYhwVYBkVXhcWXRcWXxoWYBwWXhoWXhsWXxsXYRsXYBsWXxoV + XhsWXxsWYBwXYRwXYBsWXxoVXhsWXxsWYBwXYRwXYBsWXxoVXhsWXxsWYBwXYRwXYBsWXxoVXhsWXxsW + YBwXYRwXYBsWXxoVXhsWXxsWYBwXYRwXYBsWXxoVXhsWXxsWYBwXYRwXYBsWXxoWXhsVXhwVXRsWXBsV + XBsVXRwVWxkVXBoVXBsUXBsUXBsVXBoVXBoVXBoUXBsUXBsUXBsVXBoVXBoVXBoUXBsUXBsUXBsVXBoV + XBoVXBoUXBsUXBsUXBsVXBoVXBoVXBoUXBsUXBsUXBsVXBoVXBoVXBoUXBsUXBsUXBsVXBoVXBoVXBoU + XBsUXBsUWxoVXBsWXBwVXR4WXB8XWR0VWRwUWhwVWBkUWBkUWBoTWBoTWBoUWBkUWBkUWBkTWBoTWBoT + WBoUWBkUWBkUWBkTWBoTWBoTWBoUWBkUWBkUWBkTWBoTWBoTWBoUWBkUWBkUWBkTWBoTWBoTWBoUWBkU + WBkUWBkTWBoTWBoTWBoUWBkUWBkUWBkTWBoTWBkTVxkUVxoVWBwUWR4WWB4WVRsUVRsUVhwVUxgTUxgT + UxgUUxgUUxgTUxgTUxgTUxgUUxgUUxgUUxgTUxgTUxgTUxgUUxgUUxgUUxgTUxgTUxgTUxgUUxgUUxgU + UxgTUxgTUxgTUxgUUxgUUxgUUxgTUxgTVBoTYDYVbVIVb1kWbFAWYjoVWCQUUxgUUxgUUxgTUxcTUhgT + UhoUUhsUURsUTxgSUBoTURsVThcTTxkUURkUURgUURcTUBcTTxcTTxkUaU0Wu/4eu/4eu/4eu/4eu/4e + u/4euvserd8cm7oagoUYWjEVUhwUURgUURcTUBcTTxcTTxkUURkUUhoUWy4UgIAXqtkbuvweu/4eu/4e + u/4eu/4euv0ep9QcfXgYWSkUUhoTTxgTTBgTSxkSSxgTSxgTShcTSxgTShcSSxcTTBgTTBcTTRYSTBYS + SxcSSxcTZUwVu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/0eqNYcfHsXUB4TTRYSTBYSSxcSSxcT + ThsTcWIWqtscu/0eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4erN4cZEYUSxcSSRgTSRkTSBgTRxgS + RhYSRxcSRhYRRRYRRhYRRxYRSBYRRxYRRhYRRRYRYEsUu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4e + u/4eu/4eufoef4cXSRkRRxYRRhYRRRgRgIgXtPAdu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4e + u/4et/YdaVkURxYRRxgURxkURhgTRBcRQxcRRBgTQxURQhURQxURQxURRBURQxURQxURQhURXkoUu/4e + u/4eu/4epNIcTCgSQxURSycRc3IWq+Abu/4eu/4eu/4erOAcVzsTQxURQxURbmsVtvUdu/4eu/4eu/4e + uPkel7oadHYWXUkTVz0TaF8VptUbu/4eu/4et/YdZlgURBURQxcSQhcSQRYRQBUQQBcSQhkUQBURPxUR + QBQQQBQQQBQQQBQQQBURPxURW0oTu/4eu/4eu/4epNIcSSgSQBQQQBQQQBQQVT0StPEdu/4eu/4etPEd + YFATQBQQRyMRmr8au/4eu/4eu/4euPkdfowXRyQSQBQQQBQQQBQQQBQQjaYYu/4eu/4et/YdZFcUQBQQ + PxYRPhYQPRUQPBQPPRYRPhcSPRURPRURPRQQPRQQPRMPPRQQPRQQPRURWUkTu/4eu/4eu/4eo9IcRygS + PRQQPRQQPRMPPRQQptcbu/4eu/4euvweZV8UPRQQVkITsu0du/4eu/4eu/4ehp4XPxgQPRURPRQQPRQQ + PRMPPRQQi6YYu/4eu/4et/YdYlgUPRUQOhUQOhUPORQPORQQORQQORQQOhQQOhQQORMPORMPOhQPOhQQ + OhQQORMPVkkTu/4eu/4eu/4eotIbQycQORMPORMPOhUPRioRtPMdu/4eu/4etPIdXFITOhQQam0Vu/4e + u/4eu/4eruYcRScQOhQQORMPOxYPPx0QPx4QPx4QjKkYu/4eu/4et/YdX1gUOhUQOhYROBUQNxQQNxQQ + NhQQNxURNhMPNhMPNRIPNhMPNhMQNhMPNhMPNRIPVEgTu/4eu/4eu/4ep9scWlITUUMSVEgSY2MUncga + u/4eu/4eu/4eoM8bRi8SNhMPfZIXu/4eu/4eu/4elboaPR4QNhMPNRIPU0gSj68Zj68Zj68ZquAcu/4e + u/4et/YdXVcTOBQQOBUSNhQRNRMPNRMQNRURNhYTNBIQNBIPMxIPNBIPNBIPNBIQNBIQMxIPUkgTu/4e + u/4eu/4eufoer+kdrugdsOsdt/gdu/4eu/4eu/4epdcbUkgSNRMPNBIQhqEYu/4eu/4eu/4egpoXOBkQ + NBIQMxIPYWQUu/4eu/4eu/4eu/4eu/4eu/4et/YdXFYTNRIPNRMQMxMQMxEONBMQNBURNBYSNBMQMhIP + MRIOMRIOMhMPMxMQMxMQMhIPUEgSu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eqeAcc4IVNxwOMRIO + MhMPMxMQf5cXu/4eu/4eu/4ef5cXNxoQMxMQMhIPX2MTuvseuvseuvseuvseuvseuvsetfQdWVYTMhIP + MhIOMRENMhEOMhIOMRIOMRMPMRIPMREOLxENMBENMRIOMRIPMRIOMBEOT0cRu/4eu/4eu/4et/cdpdob + o9Ybqd8buPkeu/4epdkba3YUOiMOMBENMRIOMRIPcoIVu/4eu/4eu/4ekrgZOB0PMRIOMBEOTEEQgJoW + gZsXgZsXgJsXgJoWgJoWfpYWSDoRMRMOMRIOMBENMRINMRIOMBINLxENLhENLhENLRANLhENLxENLxEN + LhENLRANTUYRu/4eu/4eu/4epNcbST8QPy4PQzQPc4MVt/cdu/4et/gdlb8YMxgOLxENLxENVlQRufod + u/4eu/4eq+McPSkOLhENLRANLRANLhENLxENLxENLhENLRANLRANLhENLxENMBIOMBIOMBIOLxIOMBMP + MBMPLxIOLhENLhENLhENLhENLhENLhENLhENLhANTkcRu/4eu/4eu/4eoNEbOiQOLhENLhENLxMMns8a + u/4eu/4eu/4ebXsULhENLhENRDYQqeAcu/4eu/4eu/4egp8XLxMNLhANLhENLhENLhENLhENLhENLhAN + LhENLhENLRANLhEOLxIOLxIOLxIOLxQPMBQPLxIOLREOLRAOLBANLBANLRANLREOLREOLREOTUYRu/4e + u/4eu/4eoNIbOCUPLBANLBANLRENlL4Zu/4eu/4eu/4ejrMYLRANLREOMxsPi68Yuvweu/4eu/4eufsd + X2UTMxsPLBANLBANLRANLREOLREOLREOMBYNNyIOLBANLRANLhENLhENLhEOLhMPLxMPLxIOLBEOKxAN + KxANKxANLBEOLBEOLBEOKxANTEYRu/4eu/4eu/4eoNEbNyQPKxANMBgOZG4Tsu8du/4eu/4eu/4ei68Y + LBEOLBEOLBEOSUIQreccu/4eu/4eu/4etPIdiawYWFsSPC0PLRMONyMPRDkQZHAUkrsYb4EULBEOLREO + LREOLRANLRANLRAOLRAOLRANKhEOKxANKxANKxANLBEOKxEOKxEOKxANTEYRu/4eu/4eu/4etfMdnMsZ + pdkatPMcu/4eu/4eu/4eu/4euvwebX0VLBEOKxEOKxEOKxANTkwRsvAdu/4eu/4eu/4eu/4eu/4eu/4e + u/4eu/4eu/4eu/4eu/4ee5UWKxEOLBEOLREOLBANLBANLREOLREOLBAOKRANKg8MKxAOKxAOKxEOKhAN + KhANKg8MTEYSu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4et/cdjLEYNiMPKxEOKhANKhANKg8M + KxAOWl0To9cbuvweu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4ee5UWKhEOKxEOLBEOKxEOLBEOLRIP + LRIOKxENKQ8MKQ8NKg8NKhANKhANKQ8MKQ8MKQ8NS0YRu/4eu/4eu/4eu/4eu/4eu/4eu/4eu/4etvUd + k74YV1sRMhwOKhANKhANKQ8MKQ8MKQ8NKg8NKxINPjAPZnMTotYauvweu/4eu/4eu/4eu/4eu/4eu/4e + se4cZ3UUKRAMKhANLBANLBEOLBEOLRMPLRIOKxEMKQ8MKQ8NKQ8NKQ8NKhANKQ8MKQ8MKQ8NMRwOSkYR + S0YRSkYQSkYQSkYRSkYRR0EQNSIOKhAMKQ8MKQ8NKQ8NKQ8NKhANKQ8MKQ8MKQ8NKQ8NKQ8NKhANKQ8M + KhEMPTEPWmISb4EVepMVbX4UZHATRkAQKxINKQ8NKg8MKxANKxANLBENLBENLBENKxENKhENKhANKhAN + KRAMKRAMKQ8MKhANKhANKRANKRAMKRAMKQ8MKhANKhANKRANKRAMKRAMKQ8MKhANKhANKRANKRAMKRAM + KQ8MKhANKhANKRANKRAMKRAMKQ8MKhANKhANKRANKRAMKRAMKQ8MKhANKhANKRANKRAMKRAMKQ4NKg8M + Kg8MKxAMKxENKxAMKhAMKRAMKRANKRANKRANKRANKhANKRANKRANKRANKRANKRANKhANKRANKRANKRAN + KRANKRANKhANKRANKRANKRANKRANKRANKhANKRANKRANKRANKRANKRANKhANKRANKRANKRANKRANKRAN + KhANKRANKRANKRANKRANKRANKQ8NKRALKhAMKxENLBIOLBIOKxENKg8LKRANKBANKRANKRANKhANKRAN + KRANKBANKRANKRANKhANKRANKRANKBANKRANKRANKhANKRANKRANKBANKRANKRANKhANKRANKRANKBAN + KRANKRANKhANKRANKRANKBANKRANKRANKhANKRANKRANKBANKRANKRANKQ8NKhALKhAMKxENLRIOLBIP + KxENKg8LKRANJQsMJAgMJAgMJw0MKRANKBANKA8MKBANKBANKRANKA8MKA8MKBANKBANKBANKQ8MKBAN + KBANKBANKBANKBANKRANKBANKBANKBANKBANKBANKRANKBANKA8MKA8MKBANKBANKQ8MKA8MKA8MKBAN + KBANKA8MKA4MKRAMKRAMKA4MJgsNJwwOKQ8MKhAMKQ8MMR4NOCkONygOLhkNKA4MKA8NKRANKRANKRAN + KBANKRANKRANKRANKRANKQ8MKRANKQ8MKRANKQ8MKQ8MKQ8MKRANKRANKRANKQ8MKRANKRANKA8MKRAN + KRANKRANKRANKQ8NKRANKRANKRANKRANKRANKRANKA8NKA8NKRAMMxoOOyEPOiAPMBcNKQ8MKA8MX2YS + iK0XhKUXTUoQJAgMJw0NKRANKRANKRANKBANKRANKRANKRANKRANKQ8MKhANKQ8MKRANKA8MKQ8MKQ8M + KRANKRANKRANKQ8MKRANKRANKA8MKRANKhANKhANKRANKQ8NKhENKhINKhENKRANKRANKhANKhANJw0N + KQ8MZVAVlYQckH4cUjsSJQoLJw8Md48Vte0cr+QcXWUSIgYLJwwMKRANKA8MKA8MKRANKhEOKhEOKRAN + KRANKhANKxEOKhANKhANKQ8MKhANKhANKhANKhANKg8MKhANKg8MKhANKA4LKg8MKhANKhANKg8MKg4M + KhANKhINKhENKRAMKhANKhANKxANJgwMKQ8MgW8Zxrokv7IjZE8VIgcLJhAMf54WxfoevfIeYWwTHgUL + IwcMJgwMJgwLKA8MKRANKRANKRANKA8MKBANKhANKhIPKhEOKRANKhANKxIPKxIPKhANKRANKhANKxEO + KhANKhANKQ8MKhANKhANKhANKg8MKQ8MKRANKRAMKRAMKA8LKQ8MKA4MJw0MIwgLJg0Minkb2c0n0MUm + alYWIAYLJhAMgJ8XxfsfvfIdXmgTGQgKHwULIwYLJAgMKA4MKRAMKRANKRANKA8MKBANKRANKhEOKRAN + KRANKhEOKxIPKxIPKRANKRANKhEOKxIPKhEOKhANKhANKxEOKxEOKg8MKg8MKQ8MKRANKRAMKRAMKA8L + KA8MJAoLIgcMHQQLIA4LiHca2M0n0MUmalYXIAYMJhAMgJ4Xw/sfvfcdhqgXXmkSYWwTXWYSTEoRLhkN + Jw0NKRANKA8MJw4LKRANKA8MKRANKA8MKA8MKRANKhEOKRANKA8MKBANKhEOKxIPKhEOKRANKhEOKxIP + KxIPKRANKRANKhEOKhEOKRANKA8NJQwMMhkPVD8UZlIWaVQWalYWpZYf1Mkmz8MlalYWIAYLJhAMgJ8X + w/sfv/4evfcevfIevvIerugcg6UXNicOJQkNKhAOKRANKA8MKRANKRANKRANKA8MKA8MKRANKRANKRAN + KA8MKBANKRANKRANKA8MKA8MKRANKhEOKhEOKRANKA8MKhEOKxIPKhEOKA8NIgkMQCkRl4cexbgk0cYm + 0MQm0MQm0scmzsMla1cXIQcLJxAMf50Wwvcew/sfxPsfxfsfxfsetPEch6wYNygOJAkOKhIPKRANKA8M + KRANKhEOKRANKA8MKA8MKRANKRANKRANKA8MKBANKA8MKRANKA8MKA8MKRANKRANKRANKBANKA8MKA8M + KRANKRANKA8NIQgMQCkQnYwezMAl2c8n2M0n1son1comzsEma1cYIwkOJw8MWV8SfpsWgJ4Wf50WgJ4W + gJ0Wdo8VXWcSMB0NJgwNKRANKQ8MKA4LKQ8MKhANKRANKA8MKA8MKhANKhEOKhANKQ8MKRANKRANKQ8M + KA4LKA8MKRANKRANKQ8MKQ8MKA4LKA8MKA8MKA8MKA4MJAoLNh4OaVUVhHIai3obinkbi3kbi3obhXMa + TjgTJw0OJxANKA8NJhALJhALJhAKJxALJxALJg8LJw4MKA4LKQ8MKA4LKA4LKA0KKQ4LKA4LKA4LJw0K + KA4LKhANKxEOKg8MKQ4LKhANKxIPKhANKQ8MKQ8MKhEOKxEOKg8MKQ4LKQ8MKhANKhANKQ4LKQ4LKA4K + KQ8LKQ4LKA4MJw0LKA4LKA4MKA4MKA4MKA4MKQ8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAACAA + AABAAAAAAQAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIkHYUkHYUkHYUkHYckHYckHYcmHYcmHYcm + HYkoHokmHYwoHo0pIIkmHYwoII0qIYgmHY0oII0qIYgmHYsnHowoIIgmHYgmHYgmHYclHYclHYgmHYcl + HYclHYsoIIknHn4iG6G1GqO+GqO+GqO+GpuaGoMjG4MjG4MjG4MjHYMjHYUjHYUjHYUjHYQlHYYlHoQj + HYYnHokoHoQlG4goHoosIYQlG4goHoksIYMlG7yEI82hJc2hJc2hJcmaJYElG3kiG6O+GqO+GqO+GqO+ + GpqaG3wiG34iG4AjHYAlHX4jG4AlHYAlHX0jG4IlHYAjG4AjG4AjG38jG38jG38jG38jG38lG4ElHIIm + HX8jG7uEI82hJc2hJc2hJc2hJXsiGnUgGaO+GqO+GnciGnciGnciGXYiGXciGnkiGnoiGnkiGXsiHHkh + GnkhGn0kHXsiHHsiGn4nHX4mHHoiGX4mHHwkGnkiGXoiGXkiGXkiGXgiGXkiGXciGc2hJc2hJXYiGXAf + GaO+GqO+GnIfGXIfGXQhGnIhGXIhGXQhGXQhGXMhGXMhGXMhGXMhGXUiGnYhGXUhGXkkHHYiGnUhGXkl + HXgjHHQhGXglHXgjHHQhGXcjG3UhGnMgGc2hJc2hJW8gGWofGZaZGpaZGm0fGW0fGW8gGm0fGW8fGXAg + Gm4fGW4fGXAgGm4gGW4gGW0gGW0gGW0gGW8gGW8gGW8gGG4gGG4gGG4gGHIjG3AhGW0gGHEkHHEiG2wg + GLeEI7eDImkfF2UdF2UdF2cdF2ceF2ceF2ceF2ceF2UdF2UdF2cdF2ceF2ceF2ceF2ceF2UdF2UdF2cd + F2ceF2ceF2ceF2ceF2UdF2UdF2cdF2ceF2ceF2ceF2ceF2YdF2cfGGUfGGMdF18cF2EdGGMdGGEcF2Ec + F2EcF2EcF18cF2EdGGMdGGEcF2EcF2EcF2EcF18cF2EdGGMdGGEcF2EcF2EcF2EcF18cF2EdGGMdGGEc + F2EcF2EcF2EcF18cFl8cFl4cFl4cFlsaFVsbFVsbFVsbFl0dF10dF1sbFVsaFVsbFVsbFVsbFl0dF10d + F1sbFVsaFVsbFVsbFVsbFl0dF10dF1sbFVsaFVsbFVsbFVsbFl0dF10dF1sbFVweFl0hGVkdFVkdFVQZ + FFQZFFQZFFQZFJOmGbv+Hrv+Hrv+Hrv+Hrv+Hrv+HqbOG4iOGFYbFFQZFFQZFFQZFFQZFGE1FZOmGabO + G7v+Hrv+Hrv+Hq7jHKDEGoiOGFYbFFMbFVQcFlAZE1McFk4YFFAaFVAYFFAYFJGlGbv+Hrv+Hrv+Hrv+ + Hrv+Hrv+Hrv+Hrv+Hpu5Gk4YFFAaFVAYFH+AGLTvHLv+Hrv+Hrv+Hrv+Hrv+Hrv+Hrv+Hrv+HpCkGUsZ + E0sZE0oYE0oYE0cXEkcXEkkXEkkXEo+lGbv+Hrv+Ho2kGEcXEkkXEomYGLv+Hrv+Hrv+HnJvFUcXEmtd + Fbv+Hrv+Hrv+Hp3DGmpdFUcXEkkXEpm5Gbv+Hrv+Ho6kGUgaFkgaFUUYEkYYE0IVEUIVEUMVEUMVEYyk + GLv+Hrv+HoujGEIVEUMVEUMVEaLOG7v+Hrv+HoujGEIVEaLNG7v+Hrv+HpzDGUQXEUIVEUIVEUMVEYyj + GLv+Hrv+HoykGEMYE0EXEj8VEUEZFD4WEj4WEj4VET4VEYqjGLv+Hrv+HoqkGD4WEj4VET4VEaHNG7v+ + Hrv+HoqkGFlJFLv+Hrv+Hrv+HllIFD4VET4WEj4WEj4VEYqjGLv+Hrv+HoqjGDsVEDoVEDoVEDoVEDkU + EDkUEDkUEDoVEYijGLv+Hrv+HoijGDkUEDkUEHuLF7v+Hrv+Hrv+HmptFGptFLv+Hrv+Hrv+HjoUEDsV + EWptFLv+Hrv+Hrv+Hrv+Hrv+HomjGDoYEzgVETcVETcWEjUTEDUTEDUTEDYTEIejGLv+Hrv+Hrv+Hrv+ + Hrv+Hrv+Hrv+HrPvHHmKFjUTEGdsFLv+Hrv+Hrv+HjYTEDYTEGdsFLv+Hrv+Hrv+Hrv+Hrv+HoejGDYV + EjQTEDUUETYXFDQTEDISDzITDzMUEIWjGLv+Hrv+Hrv+Hrv+Hrv+Hrv+HrLvHG99FjMTEDQTEGVsE7v+ + Hrv+Hrv+HjITEDMTEDQTEDISDzITDzMUEDITEDITEDMTEDISDjISDjISDjESDi8SDi8SDi8SDjETD4Si + F7v+Hrv+HoSiFy8SDj8tEJK4GLv+Hrv+HnaKFi8SDi8SDrLvHLv+Hrv+HmRsEzEUDy8SDi8SDi8SDjET + DzASDjASDjEUDzIUEDASDjIUEDATDy4RDi4RDi4RDi4RDoSiF7v+Hrv+HoSiFy4RDi4RDmNrE7v+Hrv+ + HrLvHC4RDi4RDoqsGLv+Hrv+HqTXGj4tEC4RDi4RDi4RDi4RDi4RDi4RDi4RDjATDy8SDjAVETAUEC0S + DywRDiwRDi4SD4OiF7v+Hrv+HoOiFywRDjwtEIqsGLv+Hrv+Hrv+Hi0SDywRDjwtEKTXGrv+Hrv+HqTX + Gmx8FiwRDiwRDkxGEnSJFZG3GC0RDi4RDi4RDi4RDi4RDisRDiwRDiwSDywSD4OiF7v+Hrv+Hrv+Hrv+ + Hrv+Hrv+Hrv+Hrv+HoqsGCsRDiwRDiwSDzwtEZ3MGrv+Hrv+Hrv+Hrv+Hrv+Hrv+Hrv+Hp7NGi4SDy4S + DywRDi4TEC0SDyoQDSsQDisRDisRDoOiF7v+Hrv+Hrv+Hrv+Hrv+Hrv+Hp3MGnOJFSsRDioQDSsQDisR + DisRDisRDnOJFZbBGariHLv+Hrv+Hrv+Hp3MGnyWFysRDi0SDy0SDy8VES0SDioQDSoQDSoQDSsQDSsR + DisRDisRDioQDSoQDSoQDSsQDSsRDisRDisRDioQDSoQDSoQDSsQDSsRDisRDisRDioQDSoQDSoQDSsQ + DSsRDisRDisRDiwRDSwRDSwRDSsRDSoQDSoQDSoQDSoQDSoQDSsRDioQDSoQDSoQDSoQDSoQDSoQDSsR + DioQDSoQDSoQDSoQDSoQDSoQDSsRDioQDSoQDSoQDSoQDSoQDSoQDSsRDioQDSsRDSwSDiwSDisRDSkQ + DSkQDSoQDSoQDSoQDSoQDSoQDSkQDSkQDSoQDSoQDSoQDSoQDSoQDSkQDSkQDSoQDSoQDSoQDSoQDSoQ + DSkQDSkQDSoQDSoQDSoQDSoQDSoQDSsRDS0TDy0UECsRDSkQDSkQDSkQDSkQDSkQDSoQDSoQDSkQDSkQ + DSkQDSkQDSkQDSoQDSoQDSkQDSkQDSkQDSkQDSkQDSoQDSoQDSkQDSkQDSkQDSkQDSkQDSoQDSoQDSoR + DSoQDSoQDSoQDSkQDZnGGpnHGikQDSoRDioRDikQDSoRDisRDioQDSsRDisRDioQDSoQDSoQDSoQDSoQ + DSoQDSoQDSoQDSwSDysRDioQDSwTDysSDioQDSwSDysRDioQDaeYIKeYICoQDSgQDbv+Hrv+HikQDSkQ + DSkQDSkQDSoRDioRDikQDSsSDywTECoQDSwSDywSDyoQDSsRDisRDioQDSoQDSoQDSoQDSoQDSoRDioR + DSoQDSsRDioQDSoQDc3BJs3BJikQDSgQDbv+Hrv+HikQDSkQDSkQDSkQDSkQDSkQDSkQDSoRDioRDikQ + DSsSDysSDykQDSwTECwTECoQDSwSDywSDyoQDSsRDioRDikQDSkQDSkQDSkQDSkQDc3BJs3BJikQDSgQ + Dbv+Hrv+Hrv+Hrv+HpnHGikQDSsSDykQDSkQDSoRDikQDSkQDSkQDSkQDSkQDSoRDioRDikQDSsSDysS + DykQDSwTECwTECkQDSsSD6eYIc3BJs3BJs3BJs3BJikQDSgQDbPxHbv+Hrv+Hrv+HpjGGigQDSsTECoR + DikQDSwTECoRDikQDSsSDyoRDikQDSoRDikQDSkQDSkQDSkQDSkQDSkQDSoRDikQDSoRDqeYIM3BJs3B + Js3BJsS3JSwTECgQDSgQDScPDCgPDCgPDCgPDCkPDCkPDCkPDCkPDCoQDSkPDCkPDCwSDyoQDSoQDSwT + ECoQDSoQDSwSDyoQDSkPDCsRDioQDSkPDCkPDCkPDCkPDCkPDCoQDSkPDCoQDQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + + + \ No newline at end of file diff --git a/BorderlessGaming/Forms/AboutForm.resx b/BorderlessGaming/Forms/AboutForm.resx index c876ffa..79a1df9 100644 --- a/BorderlessGaming/Forms/AboutForm.resx +++ b/BorderlessGaming/Forms/AboutForm.resx @@ -160,9 +160,6 @@ $this - - $this - 16, 18 @@ -205,29 +202,6 @@ 8 - - 2 - - - - iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m - dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAMoSURBVDhPjY9dSJNhGIbftg6S8CAoJBWMnPhTkBlk - mWVpNCu0PygTkyLKUosym1GY2Y/p5lzNv+Z0UxuWmjV1pk0tdFrM6VZuK3/KnOS0voNWQcgOvPvereig - k164efie57ov+Agn8xXhZBkI98Y44d62LeIKp7dzRXYhm0dsOn9PoWtP7yxHedoDQP4Kro+uYI+ycLnN - dK3XxlS+mZqrs07O19t1cyLLIBOpGjHRO+X+FQj0KzxzDOpTT97ZS00GKKdbUW78gJL+z6iZ7MZ9pgl1 - TDMu9vXbKUf5v4KUNg9OqlZx9JFuJqPrOQrfP0DVbCPKjG9RYX4Npa0dlfZGSGcUENrLcLpbM0N52nMJ - FiTV8QMvtVoTayw43KSDwCqHoGsAl9snkW9tgXhWhjNPtMg0l+Ds1FVkTuSDl9lmpT23YF+5NE55/+tG - uQbRFWbE1Zhx8MEYEuvHkaR+gf2KLuwQdyBxJAO7X2YhSl2IuEr1V9pzCQi/oCNed8W5WlmMNWIDwsuH - sanCgs1sIqRD2PIsFzHjBxFpSkKItBRB+RrwpXon7bkF23L167OfzvNa0uGf14NA0SCCC40IERtZWA+e - RAH/mvMIHIjF8rRm+JWLEFHQOU97bsHWa8/WSqqdfjn9rMCAgAIjAoW/kz8E/5w++KrS4PMyEsvO3YP3 - 8CqEdiU4ac8tiLlVEixocQTkmRAkMmN1kQWhEgvC7lpdWSMyIaBKAj+xEF5Nu7DUwIN//QEH7bkFseKd - S5Jqx8IkY2zhPSJKJxAt+wh+5UfEVk1ih3wCUcWjCMvVwbsnCL49IfBMF4zRnlsQX+ZB9spUQdl6Jlo2 - g/jqzzhc9wVHGxgcb2RcM0E1C37ROwS3r8NyaSJDedpzCw7VEpKgWrnwSIM27LaFSX7oQJr6Oy5ofkDQ - 9sM1Ux87kCCzgXcnheEmK7WUpz23gD6vEPZXbq4kx5pVvoL+0T3yaUdq0zfnRc3PeTr3VHxy+GT0jtK7 - i6M8+/4IuGyWsQkmnl4byMaTJ0hyg4Kc7OgkKVq9a9Jvuqd3Qmib8tw/Ag6bxWzo0vs/QjnKcwCQXyFm - FkJonTZMAAAAAElFTkSuQmCC - - 12 @@ -244,6 +218,9 @@ 9 + + True + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAVtJREFUOE9j @@ -255,9 +232,6 @@ FQnFxMR0s7CwvAB65Vl1dXUiVIp4ADREGojdgNgFiPmhwsMLMDAAALg0hCFEe1vEAAAAAElFTkSuQmCC - - $this - 60, 173 @@ -273,9 +247,6 @@ $this - - 13 - True @@ -452,7 +423,7 @@ System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - + True @@ -470,6 +441,9 @@ pictureBox1 + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + _copyrightLabel @@ -482,6 +456,9 @@ 23 + + 7 + $this @@ -494,6 +471,9 @@ 41, 13 + + 75, 67 + 4 @@ -506,6 +486,12 @@ _stackOfPancakesNameTag + + $this + + + $this + _psouza4Nametag @@ -530,9 +516,6 @@ 5 - - True - Github: @@ -584,8 +567,8 @@ NoControl - - 32, 126 + + $this 5, 67 @@ -660,7 +643,7 @@ 98, 13 - + $this @@ -675,9 +658,6 @@ $this - - 9, 170 - System.Windows.Forms.PictureBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 @@ -732,8 +712,28 @@ True - - 10 + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAMoSURBVDhPjY9dSJNhGIbftg6S8CAoJBWMnPhTkBlk + mWVpNCu0PygTkyLKUosym1GY2Y/p5lzNv+Z0UxuWmjV1pk0tdFrM6VZuK3/KnOS0voNWQcgOvPvereig + k164efie57ov+Agn8xXhZBkI98Y44d62LeIKp7dzRXYhm0dsOn9PoWtP7yxHedoDQP4Kro+uYI+ycLnN + dK3XxlS+mZqrs07O19t1cyLLIBOpGjHRO+X+FQj0KzxzDOpTT97ZS00GKKdbUW78gJL+z6iZ7MZ9pgl1 + TDMu9vXbKUf5v4KUNg9OqlZx9JFuJqPrOQrfP0DVbCPKjG9RYX4Npa0dlfZGSGcUENrLcLpbM0N52nMJ + FiTV8QMvtVoTayw43KSDwCqHoGsAl9snkW9tgXhWhjNPtMg0l+Ds1FVkTuSDl9lmpT23YF+5NE55/+tG + uQbRFWbE1Zhx8MEYEuvHkaR+gf2KLuwQdyBxJAO7X2YhSl2IuEr1V9pzCQi/oCNed8W5WlmMNWIDwsuH + sanCgs1sIqRD2PIsFzHjBxFpSkKItBRB+RrwpXon7bkF23L167OfzvNa0uGf14NA0SCCC40IERtZWA+e + RAH/mvMIHIjF8rRm+JWLEFHQOU97bsHWa8/WSqqdfjn9rMCAgAIjAoW/kz8E/5w++KrS4PMyEsvO3YP3 + 8CqEdiU4ac8tiLlVEixocQTkmRAkMmN1kQWhEgvC7lpdWSMyIaBKAj+xEF5Nu7DUwIN//QEH7bkFseKd + S5Jqx8IkY2zhPSJKJxAt+wh+5UfEVk1ih3wCUcWjCMvVwbsnCL49IfBMF4zRnlsQX+ZB9spUQdl6Jlo2 + g/jqzzhc9wVHGxgcb2RcM0E1C37ROwS3r8NyaSJDedpzCw7VEpKgWrnwSIM27LaFSX7oQJr6Oy5ofkDQ + 9sM1Ux87kCCzgXcnheEmK7WUpz23gD6vEPZXbq4kx5pVvoL+0T3yaUdq0zfnRc3PeTr3VHxy+GT0jtK7 + i6M8+/4IuGyWsQkmnl4byMaTJ0hyg4Kc7OgkKVq9a9Jvuqd3Qmib8tw/Ag6bxWzo0vs/QjnKcwCQXyFm + FkJonTZMAAAAAElFTkSuQmCC + + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 235, 13 @@ -787,26 +787,20 @@ 6, 155 - - System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - System.Windows.Forms.PictureBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 $this - - System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 11 - - 7 + + 13 System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 @@ -896,14 +890,14 @@ System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Windows.Forms.PictureBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - 75, 67 + + 2 System.Windows.Forms.Form, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 @@ -932,6 +926,9 @@ _ownerNameTag + + 24 + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 @@ -953,7 +950,97 @@ System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 32, 126 + + + 9, 188 + + + _psouza4GithubGlobe + + + _committersLabel + + + _ownerGithubGlobe + + + 16 + + + System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + _SecretOnlineGithubGlobe + + + True + + + $this + + + $this + + + 14 + + + 208, 13 + + + System.Windows.Forms.LinkLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 47, 13 + + + 14 + + + 7 + + + 32, 108 + + + $this + + + 60, 209 + + + Maintainers: + + + $this + + + 65, 13 + + + 277, 162 + + + 26 + + + True + + + Codeusa/AndrewMD5 - Andrew + + + 384, 287 + + + Borderless Gaming + + $this @@ -1441,96 +1528,6 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - - 9, 188 - - - _psouza4GithubGlobe - - - _committersLabel - - - _ownerGithubGlobe - - - 16 - - - System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - _SecretOnlineGithubGlobe - - - True - - - $this - - - $this - - - 14 - - - 208, 13 - - - System.Windows.Forms.LinkLabel, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - - - 47, 13 - - - 14 - - - 7 - - - 32, 108 - - - $this - - - 60, 209 - - - Maintainers: - - - $this - - - 65, 13 - - - 277, 162 - - - 26 - - - True - - - Codeusa/AndrewMD5 - Andrew - - - 384, 287 - - - Borderless Gaming - - - $this - - - 4 - System.Windows.Forms.PictureBox, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 @@ -1543,12 +1540,12 @@ 66, 65 - - Steam Page - _dmxtNameTag + + 4 + 0 @@ -1558,12 +1555,18 @@ 9, 107 + + 10 + 60, 110 $this + + $this + dmxt - Dana @@ -1582,8 +1585,8 @@ $this - - 24 + + 9, 170 _dmxtGithubGlobe @@ -1591,9 +1594,6 @@ 3 - - $this - http://steamcommunity.com/app/388080/ @@ -1609,8 +1609,8 @@ 162, 13 - - System.Windows.Forms.Label, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + Steam Page 5 diff --git a/BorderlessGaming/Forms/MainWindow.cs b/BorderlessGaming/Forms/MainWindow.cs index 8b0c48f..f4acf40 100644 --- a/BorderlessGaming/Forms/MainWindow.cs +++ b/BorderlessGaming/Forms/MainWindow.cs @@ -302,7 +302,7 @@ private async void hideThisProcessToolStripMenuItem_Click(object sender, EventAr /// /// Makes the currently selected process borderless /// - private void btnMakeBorderless_Click(object sender, EventArgs e) + private async void btnMakeBorderless_Click(object sender, EventArgs e) { if (lstProcesses.SelectedItem == null) { @@ -316,7 +316,7 @@ private void btnMakeBorderless_Click(object sender, EventArgs e) return; } - _watcher.RemoveBorder(pd); + await _watcher.RemoveBorder(pd); } private void btnRestoreWindow_Click(object sender, EventArgs e) @@ -876,7 +876,7 @@ private void processContext_Opening(object sender, CancelEventArgs e) var label = fixedDeviceName + (screen.Primary ? " (P)" : string.Empty); var tsi = new ToolStripMenuItem(label); - tsi.Click += (s, ea) => { _watcher.RemoveBorder_ToSpecificScreen(pd, screen); }; + tsi.Click += async (s, ea) => { await _watcher.RemoveBorder_ToSpecificScreen(pd, screen); }; contextBorderlessOn.DropDownItems.Add(tsi); } @@ -884,7 +884,7 @@ private void processContext_Opening(object sender, CancelEventArgs e) // add supersize Option var superSizeItem = new ToolStripMenuItem(LanguageManager.Data("superSize")); - superSizeItem.Click += (s, ea) => { _watcher.RemoveBorder_ToSpecificRect(pd, superSize); }; + superSizeItem.Click += async (s, ea) => { await _watcher.RemoveBorder_ToSpecificRect(pd, superSize); }; contextBorderlessOn.DropDownItems.Add(superSizeItem); } @@ -1162,7 +1162,7 @@ protected override void WndProc(ref Message m) // Otherwise, this is a fresh request to remove the border from the current window else { - _watcher.RemoveBorder(pd); + _watcher.RemoveBorder(pd).GetAwaiter().GetResult(); } }