updates.patch

From 304a49a72d99f1ef0921131be46778162d0aeaa7 Mon Sep 17 00:00:00 2001
From: JC Snider <jcsnider@users.noreply.github.com>
Date: Mon, 20 Apr 2020 21:39:47 -0400
Subject: [PATCH 1/8] Actually makes party xp range and common event options
 work (#162)

* Actually makes party xp range and common event options work

* Fixing exp distribution amounts between members, includes pandas suggested cleanups
---
 Intersect.Server/Entities/Player.cs | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/Intersect.Server/Entities/Player.cs b/Intersect.Server/Entities/Player.cs
index 71815bab..2c140f1d 100644
--- a/Intersect.Server/Entities/Player.cs
+++ b/Intersect.Server/Entities/Player.cs
@@ -861,15 +861,17 @@ public override void KilledEntity(Entity entity)
                     // If in party, split the exp.
                     if (Party != null && Party.Count > 0)
                     {
-                        foreach (var partyMember in Party)
-                        {
-                            //TODO: Only share experience with party members on the 9 surrounding maps....
-                            partyMember.GiveExperience(descriptor.Experience / Party.Count);
+                        var partyMembersInXpRange = Party.Where(partyMember => partyMember.InRangeOf(this, Options.PartySharedXpRange));
+                        var partyExperience = descriptor.Experience / partyMembersInXpRange.Count();
+                        foreach (var partyMember in partyMembersInXpRange) {
+                            partyMember.GiveExperience(partyExperience);
                             partyMember.UpdateQuestKillTasks(entity);
-                            if (partyEvent != null)
-                            {
-                                if (!(playerEvent != null && partyMember == this))
-                                {
+                        }
+
+                        if (partyEvent != null)
+                        {
+                            foreach (var partyMember in Party) {
+                                if (partyMember.InRangeOf(this, Options.PartyStartCommonEventRange) && !(partyMember == this && playerEvent != null)) {
                                     partyMember.StartCommonEvent(partyEvent);
                                 }
                             }

From 26e0a3c053818115c0f6d601e2f40f4194a4784c Mon Sep 17 00:00:00 2001
From: JC Snider <jcsnider@users.noreply.github.com>
Date: Mon, 20 Apr 2020 21:40:02 -0400
Subject: [PATCH 2/8] Provide a client and editor autoupdate system (#157)

* Editor update creation and client autoupdater wip

* Editor updater wip and some bug fixes

* Fixed editor trying to include version.json within updates

* Remove non-existent files from exclude list and allow custom scripts to generate config

* WIP download streaming, much faster, but not fully tested.

* Fixed up editor update creation logic so that it is more user friendly and less destructive

* Fix updater not showing the smaller font/info when downloaded from the host

* Allow the streaming url to be provided in the update configuration.

* Undoing unintended formatting changes to graphics.cs

* Capatilizing strings

* Fixes #161 the base dir check returning true when trying to save update in parent of editors folder
---
 .../Configuration/ClientConfiguration.cs      |    2 +
 Intersect (Core)/Intersect (Core).csproj      |    4 +
 Intersect (Core)/Updater/Update.cs            |   16 +
 Intersect (Core)/Updater/UpdateFile.cs        |   30 +
 Intersect (Core)/Updater/UpdateStatus.cs      |   18 +
 Intersect (Core)/Updater/Updater.cs           |  699 ++++++
 Intersect.Client/Core/Graphics.cs             |    2 +-
 Intersect.Client/Localization/Strings.cs      |   21 +
 .../MonoGame/Graphics/MonoRenderer.cs         |    1 -
 Intersect.Client/MonoGame/IntersectGame.cs    |  276 ++-
 Intersect.Editor/Core/Program.cs              |    3 +-
 Intersect.Editor/Forms/frmLogin.Designer.cs   |    3 +-
 Intersect.Editor/Forms/frmMain.Designer.cs    |   29 +-
 Intersect.Editor/Forms/frmMain.cs             |  203 ++
 Intersect.Editor/Forms/frmMain.resx           |   18 +-
 Intersect.Editor/Forms/frmUpdate.Designer.cs  |  153 ++
 Intersect.Editor/Forms/frmUpdate.cs           |  124 +
 Intersect.Editor/Forms/frmUpdate.resx         | 2151 +++++++++++++++++
 Intersect.Editor/General/Globals.cs           |    4 +
 Intersect.Editor/Intersect.Editor.csproj      |    9 +
 Intersect.Editor/Localization/Strings.cs      |   46 +
 Intersect.Network/Lidgren/LidgrenInterface.cs |    4 +
 22 files changed, 3777 insertions(+), 39 deletions(-)
 create mode 100644 Intersect (Core)/Updater/Update.cs
 create mode 100644 Intersect (Core)/Updater/UpdateFile.cs
 create mode 100644 Intersect (Core)/Updater/UpdateStatus.cs
 create mode 100644 Intersect (Core)/Updater/Updater.cs
 create mode 100644 Intersect.Editor/Forms/frmUpdate.Designer.cs
 create mode 100644 Intersect.Editor/Forms/frmUpdate.cs
 create mode 100644 Intersect.Editor/Forms/frmUpdate.resx

diff --git a/Intersect (Core)/Configuration/ClientConfiguration.cs b/Intersect (Core)/Configuration/ClientConfiguration.cs
index 4bba076c..893914d2 100644
--- a/Intersect (Core)/Configuration/ClientConfiguration.cs	
+++ b/Intersect (Core)/Configuration/ClientConfiguration.cs	
@@ -125,6 +125,8 @@ public void Validate()
         // TODO: What is this for?
         public List<string> IntroImages { get; set; } = new List<string>();
 
+        public string UpdateUrl { get; set; } = "";
+
         #endregion
 
         #region Serialization Hooks
diff --git a/Intersect (Core)/Intersect (Core).csproj b/Intersect (Core)/Intersect (Core).csproj
index faa4aba3..d1dbe3f5 100644
--- a/Intersect (Core)/Intersect (Core).csproj	
+++ b/Intersect (Core)/Intersect (Core).csproj	
@@ -477,6 +477,10 @@
     <Compile Include="Threading\ConcurrentInstance.cs" />
     <Compile Include="Threading\LockingActionQueue.cs" />
     <Compile Include="Threading\Threaded.cs" />
+    <Compile Include="Updater\Update.cs" />
+    <Compile Include="Updater\UpdateFile.cs" />
+    <Compile Include="Updater\Updater.cs" />
+    <Compile Include="Updater\UpdateStatus.cs" />
     <Compile Include="Utilities\AlphanumComparator.cs" />
     <Compile Include="Utilities\DatabaseUtils.cs" />
     <Compile Include="Utilities\ExperienceCurve.cs" />
diff --git a/Intersect (Core)/Updater/Update.cs b/Intersect (Core)/Updater/Update.cs
new file mode 100644
index 00000000..0ba71d9b
--- /dev/null
+++ b/Intersect (Core)/Updater/Update.cs	
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Intersect.Updater
+{
+    public class Update
+    {
+        public List<UpdateFile> Files { get; set; } = new List<UpdateFile>();
+        public bool TrustCache { get; set; } = true;
+        public string StreamingUrl { get; set; }
+
+    }
+}
diff --git a/Intersect (Core)/Updater/UpdateFile.cs b/Intersect (Core)/Updater/UpdateFile.cs
new file mode 100644
index 00000000..bc26ad3b
--- /dev/null
+++ b/Intersect (Core)/Updater/UpdateFile.cs	
@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Intersect.Updater
+{
+    public class UpdateFile
+    {
+        public string Path { get; set; }
+        public string Hash { get; set; }
+        public long Size { get; set; }
+        public bool ClientIgnore { get; set; }
+        public bool EditorIgnore { get; set; }
+
+        public UpdateFile()
+        {
+
+        }
+
+        public UpdateFile(string path, string hash, long size)
+        {
+            Path = path;
+            Hash = hash;
+            Size = size;
+        }
+
+    }
+}
diff --git a/Intersect (Core)/Updater/UpdateStatus.cs b/Intersect (Core)/Updater/UpdateStatus.cs
new file mode 100644
index 00000000..fbf7cb8a
--- /dev/null
+++ b/Intersect (Core)/Updater/UpdateStatus.cs	
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Intersect.Updater
+{
+    public enum UpdateStatus
+    {
+        Checking = 0,
+        Updating = 1,
+        Restart,
+        Done,
+        Error,
+        None
+    }
+}
diff --git a/Intersect (Core)/Updater/Updater.cs b/Intersect (Core)/Updater/Updater.cs
new file mode 100644
index 00000000..773402e1
--- /dev/null
+++ b/Intersect (Core)/Updater/Updater.cs	
@@ -0,0 +1,699 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Intersect.Configuration;
+using Intersect.Logging;
+
+using Newtonsoft.Json;
+
+namespace Intersect.Updater
+{
+    public class Updater
+    {
+
+        private Thread mUpdateThread;
+        private Update mUpdate;
+        private Update mCachedVersion;
+        private Update mCurrentVersion;
+        private string mCurrentVersionPath;
+        private Thread[] mDownloadThreads;
+        private readonly int mDownloadThreadCount = 1;
+        private ConcurrentStack<UpdateFile> mDownloadQueue = new ConcurrentStack<UpdateFile>();
+        private ConcurrentDictionary<UpdateFile, long> mFailedDownloads = new ConcurrentDictionary<UpdateFile, long>();
+        private ConcurrentBag<UpdateFile> mCompletedDownloads = new ConcurrentBag<UpdateFile>();
+        private ConcurrentDictionary<UpdateFile, long> mActiveDownloads = new ConcurrentDictionary<UpdateFile, long>();
+        private long mDownloadedBytes;
+        private bool mFailed;
+        private bool mStopping;
+        private bool mUpdaterContentLoaded;
+        private bool mIsClient;
+        private string mConfigUrl;
+        private string mBaseUrl;
+
+        public float Progress => ((float)BytesDownloaded / (float)SizeTotal) * 100f;
+
+        public int FilesRemaining => mDownloadQueue.Count +
+                                     mActiveDownloads.Count;
+
+        public long SizeRemaining => SizeTotal -
+                                     BytesDownloaded;
+
+        public int FilesTotal => mDownloadQueue.Count +
+                                 mActiveDownloads.Count +
+                                 mCompletedDownloads.Count;
+
+        public long BytesDownloaded => mDownloadedBytes +
+                                       mActiveDownloads.Values.Sum();
+
+        public long SizeTotal { get; private set; }
+
+        public UpdateStatus Status { get; private set; } = UpdateStatus.Checking;
+
+        public Exception Exception { get; private set; }
+
+        public bool ReplacedSelf { get; private set; }
+
+
+
+        public Updater(string updateUrl, string currentVersionPath, bool isClient, int maxDownloadThreads = 10)
+        {
+            if (string.IsNullOrWhiteSpace(updateUrl))
+            {
+                Status = UpdateStatus.None;
+                return;
+            }
+
+            mDownloadThreadCount = maxDownloadThreads;
+            mCurrentVersionPath = currentVersionPath;
+            mIsClient = isClient;
+
+            mUpdateThread = new Thread(RunUpdates);
+            mUpdateThread.Start();
+        }
+
+
+        private async void RunUpdates()
+        {
+            DeleteOldFiles();
+
+            //Download Update Config
+            using (WebClient wc = new WebClient())
+            {
+                try
+                {
+                    mConfigUrl = ClientConfiguration.Instance.UpdateUrl.TrimEnd(new char[] { '/' });
+                    mBaseUrl = ClientConfiguration.Instance.UpdateUrl.TrimEnd(new char[] { '/' });
+                    var uri = new Uri(ClientConfiguration.Instance.UpdateUrl);
+
+                    //Specifying update.json themselves or some other file that generates the config... base url needs to be the folder containing it
+                    if (Path.HasExtension(uri.AbsolutePath))
+                    {
+                        mBaseUrl = uri.AbsoluteUri.Remove(uri.AbsoluteUri.Length - uri.Segments.Last().Length).TrimEnd(new char[] { '/' });
+                    }
+                    else
+                    {
+                        mConfigUrl = ClientConfiguration.Instance.UpdateUrl.TrimEnd(new char[] { '/' }) + "/update.json";
+                    }
+                    var json = wc.DownloadString(mConfigUrl + "?token=" + Environment.TickCount);
+                    mUpdate = JsonConvert.DeserializeObject<Update>(json);
+
+                    var downloadFirst = new List<UpdateFile>();
+
+                    var updateRequired = true;
+
+                    if (File.Exists(mCurrentVersionPath))
+                    {
+                        mCachedVersion = JsonConvert.DeserializeObject<Update>(
+                            File.ReadAllText(mCurrentVersionPath)
+                        );
+
+
+                        updateRequired = false;
+                        foreach (var file in mUpdate.Files.Where(f => f.ClientIgnore == false))
+                        {
+                            var checkFile = mCachedVersion.Files.FirstOrDefault(f => f.Path == file.Path);
+                            if (checkFile == null || checkFile.Size != file.Size || checkFile.Hash != file.Hash)
+                            {
+                                updateRequired = true;
+                            }
+                            else
+                            {
+                                if (!File.Exists(file.Path) || !mUpdate.TrustCache)
+                                {
+                                    updateRequired = true;
+                                }
+                            }
+                        }
+
+                    }
+
+                    //If we are doing a forced full check or if we don't have a current version file then we will start from scratch
+                    if (updateRequired)
+                    {
+                        //Remove Deleted Files
+                        if (mCachedVersion != null)
+                        {
+                            foreach (var file in mCachedVersion.Files)
+                            {
+                                if (!mUpdate.Files.Any(f => f.Path == file.Path))
+                                {
+                                    if (File.Exists(file.Path))
+                                    {
+                                        try
+                                        {
+                                            File.Delete(file.Path);
+                                        }
+                                        catch
+                                        {
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        //Copy Over 
+                        mCurrentVersion = new Update();
+                        foreach (var file in mUpdate.Files)
+                        {
+                            if ((mIsClient && file.ClientIgnore || !mIsClient && file.EditorIgnore) && mCachedVersion != null)
+                            {
+                                var ignoredFile = mCachedVersion.Files.FirstOrDefault(f => f.Path == file.Path);
+                                if (ignoredFile != null)
+                                {
+                                    mCurrentVersion.Files.Add(ignoredFile);
+                                }
+                                continue;
+                            }
+
+                            if (File.Exists(file.Path))
+                            {
+                                //If json we will still trust the cache, this might be wrong but given that the client is constantly updating json files we really can't expect the hash to always match
+                                if (mCachedVersion != null && Path.GetExtension(file.Path) == ".json")
+                                {
+                                    var cacheCompare = mCachedVersion.Files.FirstOrDefault(f => f.Path == file.Path);
+                                    if (cacheCompare != null)
+                                    {
+                                        if (cacheCompare.Size == file.Size &&
+                                            cacheCompare.Hash == file.Hash)
+                                        {
+                                            mCurrentVersion.Files.Add(file);
+
+                                            continue;
+                                        }
+                                    }
+                                }
+
+                                //Otherwise let's compare hashes and potentially add it to the update list
+                                var md5Hash = "";
+                                using (var md5 = MD5.Create())
+                                {
+                                    using (var fs = File.OpenRead(file.Path))
+                                    {
+                                        if (fs.Length != file.Size)
+                                        {
+                                            AddToUpdateList(file, downloadFirst);
+                                        }
+                                        else
+                                        {
+                                            using (var stream = new BufferedStream(fs, 1200000))
+                                            {
+                                                md5Hash = BitConverter.ToString(md5.ComputeHash(stream))
+                                                    .Replace("-", "")
+                                                    .ToLowerInvariant();
+                                            }
+
+                                            if (md5Hash != file.Hash)
+                                            {
+                                                AddToUpdateList(file, downloadFirst);
+                                            }
+                                            else
+                                            {
+                                                mCurrentVersion.Files.Add(file);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                AddToUpdateList(file, downloadFirst);
+                            }
+                        }
+                    }
+
+                    foreach (var file in downloadFirst)
+                    {
+                        mDownloadQueue.Push(file);
+                    }
+
+                    if (mDownloadQueue.Count == 0)
+                    {
+                        Status = UpdateStatus.None;
+                        return;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    //Failed to fetch update info or deserialize!
+                    Status = UpdateStatus.Error;
+                    Exception = new Exception("[Update Check Failed!] - " + ex.Message, ex);
+                    return;
+                }
+            }
+
+            //Got our update list!
+            foreach (var file in mDownloadQueue)
+                SizeTotal += file.Size;
+
+
+            Status = UpdateStatus.Updating;
+
+            var streamingSuccess = false;
+
+            if (!string.IsNullOrWhiteSpace(mUpdate.StreamingUrl))
+            {
+                streamingSuccess = await StreamDownloads();
+            }
+
+            if (!streamingSuccess)
+            {
+                //Spawn Download Threads
+                var threadCount = Math.Min(mDownloadThreadCount, FilesTotal);
+                mDownloadThreads = new Thread[threadCount];
+
+                for (int i = 0; i < threadCount; i++)
+                {
+                    mDownloadThreads[i] = new Thread(DownloadUpdates);
+                    mDownloadThreads[i].Start();
+                }
+            }
+
+            while (Updating())
+            {
+                Thread.Sleep(10);
+            }
+
+            //Success or failure we will save the current version info here
+            foreach (var file in mCompletedDownloads)
+                mCurrentVersion.Files.Add(file);
+
+
+            File.WriteAllText(
+                mCurrentVersionPath,
+                JsonConvert.SerializeObject(
+                    mCurrentVersion, Formatting.Indented,
+                    new JsonSerializerSettings { DefaultValueHandling = DefaultValueHandling.Ignore }
+                )
+            );
+
+
+            if (mStopping)
+            {
+                return;
+            }
+
+            if (!mFailed)
+            {
+                if (ReplacedSelf)
+                {
+                    Status = UpdateStatus.Restart;
+                }
+                else
+                {
+                    Status = UpdateStatus.Done;
+                }
+            }
+            else
+            {
+                Status = UpdateStatus.Error;
+            }
+
+        }
+
+        private async Task<bool> StreamDownloads()
+        {
+            var client = new HttpClient();
+
+            var files = new List<string>();
+
+            while (!mDownloadQueue.IsEmpty)
+            {
+                if (mDownloadQueue.TryPop(out UpdateFile file))
+                {
+                    files.Add(file.Path);
+                    mActiveDownloads.TryAdd(file,0);
+                }
+            }
+            var msg = new HttpRequestMessage(HttpMethod.Post, mUpdate.StreamingUrl + "?token=" + Environment.TickCount)
+            {
+                Content = new StringContent(JsonConvert.SerializeObject(files), Encoding.UTF8, "application/json"),
+            };
+            var response = await client.SendAsync(msg, HttpCompletionOption.ResponseHeadersRead);
+
+            using (var str = await response.Content.ReadAsStreamAsync())
+            {
+                try
+                {
+                    using (var br = new BinaryReader(str))
+                    {
+                        while (true)
+                        {
+                            var name = br.ReadString();
+
+                            var file = mActiveDownloads.Keys.FirstOrDefault(f => f.Path == name);
+                            var size = (int)br.ReadInt64();
+
+                            var dataStream = new MemoryStream(size);
+                            var downloaded = 0;
+                            while (downloaded < size)
+                            {
+                                var chunk = 1024 * 1024;
+                                if (downloaded + chunk > size)
+                                {
+                                    chunk = size - downloaded;
+                                }
+                                dataStream.Write(br.ReadBytes(chunk),0,chunk);
+                                downloaded += chunk;
+                                if (file != null)
+                                {
+                                    mActiveDownloads[file] = downloaded;
+                                }
+                            }
+
+                            var data = dataStream.ToArray();
+                            dataStream.Close();
+                            dataStream.Dispose();
+
+                            if (file != null)
+                            {
+                                try
+                                {
+                                    BeforeFileDownload(file);
+                                    CheckFileData(file, data);
+                                    BeforeReplaceFile(file);
+
+
+                                    //Save New File
+                                    File.WriteAllBytes(file.Path, data);
+
+                                    lock (mUpdate)
+                                    {
+                                        mCompletedDownloads.Add(file);
+                                        mActiveDownloads.TryRemove(file, out long val);
+                                        mDownloadedBytes += file.Size;
+
+                                        if (IsUpdaterFile(file.Path))
+                                        {
+                                            mUpdaterContentLoaded = true;
+                                        }
+                                    }
+
+
+                                }
+                                catch (EndOfStreamException eof)
+                                {
+                                    return mDownloadQueue.IsEmpty && mActiveDownloads.IsEmpty;
+                                }
+                                catch (Exception ex)
+                                {
+                                    lock (mUpdate)
+                                    {
+
+                                        mActiveDownloads.TryRemove(file, out long val);
+
+                                        if (mFailedDownloads.ContainsKey(file))
+                                        {
+                                            mFailedDownloads[file]++;
+                                        }
+                                        else
+                                        {
+                                            mFailedDownloads.TryAdd(file, 1);
+                                        }
+
+                                        if (mFailedDownloads[file] > 2)
+                                        {
+                                            Exception = new Exception("[" + file.Path + "] - " + ex.Message, ex);
+                                            mFailed = true;
+                                        }
+                                        else
+                                        {
+                                            mDownloadQueue.Push(file);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (EndOfStreamException eof)
+                {
+                    //Good to go?
+                    //TODO Check if any files are missing, if so return false and let the basic downloader code try to fetch them.
+                    return true;
+                }
+                catch (Exception ex)
+                {
+                    //Errored
+                    Log.Error("Failed to download streamed files, failure occured on " );
+                    return false;
+                }
+            }
+        }
+
+        private bool Updating()
+        {
+            lock (mUpdate)
+            {
+                return (mDownloadQueue.Count > 0 || mActiveDownloads.Count > 0) && !mFailed && !mStopping;
+            }
+        }
+
+        private async void DownloadUpdates()
+        {
+            while (mDownloadQueue.Count > 0 && !mFailed)
+            {
+                UpdateFile file = null;
+                var streamDl = false;
+                lock (mUpdate)
+                {
+                    if (mDownloadQueue.TryPop(out file))
+                    {
+                        mActiveDownloads.TryAdd(file, 0);
+                    }
+                }
+
+                if (file != null)
+                {
+                    //Download File
+                    BeforeFileDownload(file);
+
+                    try
+                    {
+                        //Use WebClient to Download File To Memory
+                        var wc = new WebClient();
+                        wc.DownloadProgressChanged += ((sender, args) => mActiveDownloads[file] = args.BytesReceived);
+                        var fileData = await wc.DownloadDataTaskAsync(new Uri(mBaseUrl + "/" + file.Path + "?token=" + Environment.TickCount));
+                        wc.Dispose();
+
+                        CheckFileData(file, fileData);
+
+                        BeforeReplaceFile(file);
+
+                        //Save New File
+                        File.WriteAllBytes(file.Path, fileData);
+
+                        lock (mUpdate)
+                        {
+                            mCompletedDownloads.Add(file);
+                            mActiveDownloads.TryRemove(file, out long val);
+                            mDownloadedBytes += file.Size;
+
+                            if (IsUpdaterFile(file.Path))
+                            {
+                                mUpdaterContentLoaded = true;
+                            }
+                        }
+
+
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (mUpdate)
+                        {
+                            mActiveDownloads.TryRemove(file, out long val);
+
+
+                            if (mFailedDownloads.ContainsKey(file))
+                            {
+                                mFailedDownloads[file]++;
+                            }
+                            else
+                            {
+                                mFailedDownloads.TryAdd(file, 1);
+                            }
+
+                            if (mFailedDownloads[file] > 2)
+                            {
+                                Exception = new Exception("[" + file.Path + "] - " + ex.Message, ex);
+                                mFailed = true;
+                            }
+                            else
+                            {
+                                mDownloadQueue.Push(file);
+                            }
+                        }
+                    }
+
+                }
+                Thread.Sleep(10);
+            }
+        }
+
+        private void BeforeFileDownload(UpdateFile file)
+        {
+            //Create any parent directories for this file
+            var dir = Path.GetDirectoryName(file.Path);
+            if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
+            {
+                Directory.CreateDirectory(dir);
+            }
+        }
+
+        private void CheckFileData(UpdateFile file, byte[] fileData)
+        {
+            if (fileData.Length != file.Size)
+            {
+                throw new Exception("[File Length Mismatch - Got " + fileData.Length + " bytes, Expected " + file.Size + "]");
+            }
+
+            //Check MD5
+            var md5Hash = "";
+            using (var md5 = MD5.Create())
+            {
+                using (var stream = new MemoryStream(fileData))
+                {
+                    md5Hash = BitConverter.ToString(md5.ComputeHash(stream)).Replace("-", "").ToLowerInvariant();
+                }
+            }
+
+            if (md5Hash != file.Hash)
+            {
+                throw new Exception("File Hash Mismatch");
+            }
+        }
+
+        private void BeforeReplaceFile(UpdateFile file)
+        {
+            //Delete .old first if exists
+            if (File.Exists(file.Path + ".old"))
+            {
+                try
+                {
+                    File.Delete(file.Path + ".old");
+                }
+                catch { }
+            }
+
+            //Delete Existing File
+            if (File.Exists(file.Path))
+            {
+                try
+                {
+                    File.Delete(file.Path);
+                }
+                catch
+                {
+                    try
+                    {
+                        File.Move(file.Path, file.Path + ".old");
+                    }
+                    catch
+                    {
+                        throw new Exception("Failed to delete or move existing file!");
+                    }
+                }
+            }
+
+            if (file.Path == Path.GetFileName(Assembly.GetEntryAssembly().Location))
+            {
+                ReplacedSelf = true;
+            }
+        }
+
+        private void AddToUpdateList(UpdateFile file, List<UpdateFile> downloadFirst)
+        {
+            if (IsUpdaterFile(file.Path.ToLower()))
+            {
+                downloadFirst.Add(file);
+            }
+            else
+            {
+                mDownloadQueue.Push(file);
+            }
+        }
+
+        private void DeleteOldFiles()
+        {
+            foreach (var file in Directory.GetFiles(Directory.GetCurrentDirectory(), "*.old", SearchOption.AllDirectories))
+            {
+                try
+                {
+                    File.Delete(file);
+                }
+                catch { }
+            }
+        }
+
+        private bool IsUpdaterFile(string path)
+        {
+            switch (path)
+            {
+                case "resources/updater/background.png":
+                    return true;
+                case "resources/updater/font.xnb":
+                    return true;
+                case "resources/updater/fontsmall.xnb":
+                    return true;
+                case "resources/updater/progressbar.png":
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        public string GetHumanReadableFileSize(long size)
+        {
+            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
+            double len = size;
+            int order = 0;
+            while (len >= 1024 && order < sizes.Length - 1)
+            {
+                order++;
+                len = len / 1024;
+            }
+            return String.Format("{0:0.##} {1} Left", len, sizes[order]);
+        }
+
+        public bool CheckUpdaterContentLoaded()
+        {
+            if (mUpdaterContentLoaded)
+            {
+                mUpdaterContentLoaded = false;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public void Stop()
+        {
+            if (mDownloadThreads != null)
+            {
+                foreach (var dlThread in mDownloadThreads)
+                {
+                    try
+                    {
+                        dlThread?.Abort();
+                    }
+                    catch
+                    {
+                    }
+                }
+            }
+
+            mStopping = true;
+        }
+    }
+}
diff --git a/Intersect.Client/Core/Graphics.cs b/Intersect.Client/Core/Graphics.cs
index 3fb9cfeb..fa564aa1 100644
--- a/Intersect.Client/Core/Graphics.cs
+++ b/Intersect.Client/Core/Graphics.cs
@@ -1245,4 +1245,4 @@ public static void UpdatePlayerLight()
 
     }
 
-}
+}
\ No newline at end of file
diff --git a/Intersect.Client/Localization/Strings.cs b/Intersect.Client/Localization/Strings.cs
index a1b0296f..b556e802 100644
--- a/Intersect.Client/Localization/Strings.cs
+++ b/Intersect.Client/Localization/Strings.cs
@@ -1513,6 +1513,27 @@ public struct Numbers
 
         }
 
+        public struct Update
+        {
+
+            public static LocalizedString Checking = @"Checking for updates, please wait!";
+
+            public static LocalizedString Updating = @"Downloading updates, please wait!";
+
+            public static LocalizedString Restart = @"Update complete! Relaunch {00} to play!";
+
+            public static LocalizedString Done = @"Update complete! Launching game!";
+
+            public static LocalizedString Error = @"Update Error! Check logs for more info!";
+
+            public static LocalizedString Files = @"{00} Files Remaining";
+
+            public static LocalizedString Size = @"{00} Left";
+
+            public static LocalizedString Percent = @"{00}%";
+
+        }
+
     }
 
 }
diff --git a/Intersect.Client/MonoGame/Graphics/MonoRenderer.cs b/Intersect.Client/MonoGame/Graphics/MonoRenderer.cs
index 8c861612..2440ad6c 100644
--- a/Intersect.Client/MonoGame/Graphics/MonoRenderer.cs
+++ b/Intersect.Client/MonoGame/Graphics/MonoRenderer.cs
@@ -97,7 +97,6 @@ public MonoRenderer(GraphicsDeviceManager graphics, ContentManager contentManage
             mGame = monoGame;
             mGraphics = graphics;
             mContentManager = contentManager;
-            mGraphics.PreferHalfPixelOffset = true;
 
             mNormalState = new BlendState()
             {
diff --git a/Intersect.Client/MonoGame/IntersectGame.cs b/Intersect.Client/MonoGame/IntersectGame.cs
index 970e5a8a..bb46d116 100644
--- a/Intersect.Client/MonoGame/IntersectGame.cs
+++ b/Intersect.Client/MonoGame/IntersectGame.cs
@@ -1,4 +1,7 @@
 using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
 using System.Reflection;
 
 using Intersect.Client.Core;
@@ -16,6 +19,7 @@
 using Intersect.Client.MonoGame.System;
 using Intersect.Configuration;
 using Intersect.Logging;
+using Intersect.Updater;
 
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
@@ -30,9 +34,21 @@ namespace Intersect.Client.MonoGame
     /// </summary>
     public class IntersectGame : Game
     {
-
+        private bool mInitialized;
         private double mLastUpdateTime = 0;
 
+        private GraphicsDeviceManager mGraphics;
+
+        #region "Autoupdate Variables"
+        private Updater.Updater mUpdater;
+        private Texture2D updaterBackground;
+        private SpriteFont updaterFont;
+        private SpriteFont updaterFontSmall;
+        private Texture2D updaterProgressBar;
+        private SpriteBatch updateBatch;
+        private bool updaterGraphicsReset;
+        #endregion
+
         public IntersectGame()
         {
             //Setup an error handler
@@ -40,8 +56,11 @@ public IntersectGame()
 
             Strings.Load();
 
-            var graphics = new GraphicsDeviceManager(this);
-            graphics.PreparingDeviceSettings += (object s, PreparingDeviceSettingsEventArgs args) =>
+            mGraphics = new GraphicsDeviceManager(this);
+            mGraphics.PreferredBackBufferWidth = 800;
+            mGraphics.PreferredBackBufferHeight = 480;
+            mGraphics.PreferHalfPixelOffset = true;
+            mGraphics.PreparingDeviceSettings += (object s, PreparingDeviceSettingsEventArgs args) =>
             {
                 args.GraphicsDeviceInformation.PresentationParameters.RenderTargetUsage =
                     RenderTargetUsage.PreserveContents;
@@ -59,7 +78,7 @@ public IntersectGame()
 
             Globals.InputManager = new MonoInput(this);
 
-            var renderer = new MonoRenderer(graphics, Content, this);
+            var renderer = new MonoRenderer(mGraphics, Content, this);
             Core.Graphics.Renderer = renderer;
             if (renderer == null)
             {
@@ -74,12 +93,17 @@ public IntersectGame()
             Window.Position = new Microsoft.Xna.Framework.Point(-20, -2000);
             Window.IsBorderless = false;
             Window.AllowAltF4 = false;
+
+            if (!string.IsNullOrWhiteSpace(ClientConfiguration.Instance.UpdateUrl))
+            {
+                mUpdater = new Updater.Updater(ClientConfiguration.Instance.UpdateUrl, Path.Combine("version.json"), true, 5);
+            }
         }
 
         //Really basic error handler for debugging purposes
         public static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs exception)
         {
-            Log.Error((Exception) exception?.ExceptionObject);
+            Log.Error((Exception)exception?.ExceptionObject);
             Environment.Exit(-1);
         }
 
@@ -90,6 +114,18 @@ public static void CurrentDomain_UnhandledException(object sender, UnhandledExce
         ///     and initialize them as well.
         /// </summary>
         protected override void Initialize()
+        {
+            base.Initialize();
+            
+            if (mUpdater != null)
+            {
+                LoadUpdaterContent();
+            }
+
+            mGraphics.ApplyChanges();
+        }
+
+        private void IntersectInit()
         {
             (Core.Graphics.Renderer as MonoRenderer)?.Init(GraphicsDevice);
 
@@ -100,7 +136,7 @@ protected override void Initialize()
             Networking.Network.Socket.Disconnected += (sender, connectionEventArgs) => MainMenu.SetNetworkStatus(connectionEventArgs.NetworkStatus);
 
             Main.Start();
-            base.Initialize();
+            mInitialized = true;
         }
 
         /// <summary>
@@ -110,16 +146,64 @@ protected override void Initialize()
         /// <param name="gameTime">Provides a snapshot of timing values.</param>
         protected override void Update(GameTime gameTime)
         {
-            if (Globals.IsRunning)
+            if (mUpdater != null)
             {
-                if (mLastUpdateTime < gameTime.TotalGameTime.TotalMilliseconds)
+                if (mUpdater.CheckUpdaterContentLoaded())
                 {
-                    lock (Globals.GameLock)
+                    LoadUpdaterContent();
+                }
+
+                if (mUpdater.Status == UpdateStatus.Done || mUpdater.Status == UpdateStatus.None)
+                {
+                    if (updaterGraphicsReset == true)
+                    {
+                        //Drew a frame, now let's initialize the engine
+                        IntersectInit();
+                        mUpdater = null;
+                    }
+                }
+                else if (mUpdater.Status == UpdateStatus.Restart)
+                {
+                    //Auto relaunch on Windows
+                    switch (Environment.OSVersion.Platform)
                     {
-                        Main.Update();
+                        case PlatformID.Win32NT:
+                        case PlatformID.Win32S:
+                        case PlatformID.Win32Windows:
+                        case PlatformID.WinCE:
+                            Process.Start(
+                                Environment.GetCommandLineArgs()[0],
+                                Environment.GetCommandLineArgs().Length > 1
+                                    ? string.Join(" ", Environment.GetCommandLineArgs().Skip(1))
+                                    : null
+                            );
+                            Exit();
+                            break;
                     }
+                }
+
+            }
 
-                    ///mLastUpdateTime = gameTime.TotalGameTime.TotalMilliseconds + (1000/60f);
+            if (mUpdater == null)
+            {
+                if (!mInitialized)
+                {
+                    IntersectInit();
+                }
+                if (Globals.IsRunning)
+                {
+                    if (mLastUpdateTime < gameTime.TotalGameTime.TotalMilliseconds)
+                    {
+                        lock (Globals.GameLock)
+                        {
+                            Main.Update();
+                        }
+                        ///mLastUpdateTime = gameTime.TotalGameTime.TotalMilliseconds + (1000/60f);
+                    }
+                }
+                else
+                {
+                    Exit();
                 }
             }
 
@@ -133,16 +217,36 @@ protected override void Update(GameTime gameTime)
         protected override void Draw(GameTime gameTime)
         {
             GraphicsDevice.BlendState = BlendState.NonPremultiplied;
-            if (Globals.IsRunning)
+
+            GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Black);
+
+            if (mUpdater != null)
             {
-                lock (Globals.GameLock)
+                if (mUpdater.Status == UpdateStatus.Done || mUpdater.Status == UpdateStatus.None)
+                {
+                    if (updaterGraphicsReset == false)
+                    {
+                        (Core.Graphics.Renderer as MonoRenderer)?.Init(GraphicsDevice);
+                        (Core.Graphics.Renderer as MonoRenderer)?.Init();
+                        (Core.Graphics.Renderer as MonoRenderer)?.Begin();
+                        (Core.Graphics.Renderer as MonoRenderer)?.End();
+                        updaterGraphicsReset = true;
+                    }
+                }
+                else
                 {
-                    Core.Graphics.Render();
+                    DrawUpdater();
                 }
             }
             else
             {
-                Exit();
+                if (Globals.IsRunning && mInitialized)
+                {
+                    lock (Globals.GameLock)
+                    {
+                        Core.Graphics.Render();
+                    }
+                }
             }
 
             base.Draw(gameTime);
@@ -169,7 +273,7 @@ protected override void OnExiting(object sender, EventArgs args)
                     var platform = GetType().GetField("Platform", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(this);
                     var field = platform.GetType().GetField("_isExiting", BindingFlags.NonPublic | BindingFlags.Instance);
                     field.SetValue(platform, 0);
-                    
+
                 }
                 catch
                 {
@@ -191,12 +295,152 @@ protected override void OnExiting(object sender, EventArgs args)
                 }
             }
 
+            try
+            {
+                mUpdater?.Stop();
+            }
+            catch { }
             //Just close if we don't need to show a combat warning
             base.OnExiting(sender, args);
             Networking.Network.Close("quitting");
             base.Dispose();
         }
 
+
+        private void DrawUpdater()
+        {
+            //Draw updating text and show progress bar...
+
+            if (updateBatch == null)
+            {
+                updateBatch = new SpriteBatch(GraphicsDevice);
+            }
+
+            updateBatch.Begin(SpriteSortMode.Immediate);
+
+            //Default Window Size is 800x480
+            if (updaterBackground != null)
+            {
+                updateBatch.Draw(
+                    updaterBackground, new Rectangle(0, 0, 800, 480),
+                    new Rectangle?(new Rectangle(0, 0, updaterBackground.Width, updaterBackground.Height)),
+                    Microsoft.Xna.Framework.Color.White
+                );
+            }
+
+            var status = "";
+            var progressPercent = 0f;
+            var progress = "";
+            var filesRemaining = "";
+            var sizeRemaining = "";
+
+            switch (mUpdater.Status)
+            {
+                case UpdateStatus.Checking:
+                    status = Strings.Update.Checking;
+                    break;
+                case UpdateStatus.Updating:
+                    status = Strings.Update.Updating;
+                    progressPercent = mUpdater.Progress / 100f;
+                    progress = Strings.Update.Percent.ToString((int)mUpdater.Progress);
+                    filesRemaining = mUpdater.FilesRemaining + " Files Remaining";
+                    sizeRemaining = mUpdater.GetHumanReadableFileSize(mUpdater.SizeRemaining) + " Left";
+                    break;
+                case UpdateStatus.Restart:
+                    status = Strings.Update.Restart.ToString(Strings.Main.gamename);
+                    progressPercent = 100;
+                    progress = Strings.Update.Percent.ToString(100);
+                    break;
+                case UpdateStatus.Done:
+                    status = Strings.Update.Done;
+                    progressPercent = 100;
+                    progress = Strings.Update.Percent.ToString(100);
+                    break;
+                case UpdateStatus.Error:
+                    status = Strings.Update.Error;
+                    progress = mUpdater.Exception?.Message ?? "";
+                    progressPercent = 100;
+                    break;
+                case UpdateStatus.None:
+                    //Nothing here!
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            if (updaterFont != null)
+            {
+                var size = updaterFont.MeasureString(status);
+                updateBatch.DrawString(
+                    updaterFont, status, new Vector2(800 / 2 - size.X / 2, 360),
+                    Microsoft.Xna.Framework.Color.White
+                );
+            }
+
+            //Bar will exist at 400 to 432
+            if (updaterProgressBar != null)
+            {
+                updateBatch.Draw(
+                    updaterProgressBar, new Rectangle(100, 400, (int)(600 * progressPercent), 32),
+                    new Rectangle?(new Rectangle(0, 0, (int)(updaterProgressBar.Width * progressPercent), updaterProgressBar.Height)),
+                    Microsoft.Xna.Framework.Color.White
+                );
+            }
+
+            //Bar will be 600 pixels wide
+            if (updaterFontSmall != null)
+            {
+                //Draw % in center of bar
+                var size = updaterFontSmall.MeasureString(progress);
+                updateBatch.DrawString(
+                    updaterFontSmall, progress, new Vector2(800 / 2 - size.X / 2, 405),
+                    Microsoft.Xna.Framework.Color.White
+                );
+
+                //Draw files remaining on bottom left
+                updateBatch.DrawString(
+                    updaterFontSmall, filesRemaining, new Vector2(100, 440),
+                    Microsoft.Xna.Framework.Color.White
+                );
+
+                //Draw total remaining on bottom right
+                size = updaterFontSmall.MeasureString(sizeRemaining);
+                updateBatch.DrawString(
+                    updaterFontSmall, sizeRemaining, new Vector2(700 - size.X, 440),
+                    Microsoft.Xna.Framework.Color.White
+                );
+            }
+
+            updateBatch.End();
+        }
+
+
+        private void LoadUpdaterContent()
+        {
+            if (File.Exists(Path.Combine("resources", "updater", "background.png")))
+            {
+                updaterBackground = Texture2D.FromFile(
+                    GraphicsDevice, Path.Combine("resources", "updater", "background.png")
+                );
+            }
+
+            if (File.Exists(Path.Combine("resources", "updater", "progressbar.png")))
+            {
+                updaterProgressBar = Texture2D.FromFile(
+                    GraphicsDevice, Path.Combine("resources", "updater", "progressbar.png")
+                );
+            }
+
+            if (File.Exists(Path.Combine("resources", "updater", "font.xnb")))
+            {
+                updaterFont = Content.Load<SpriteFont>(Path.Combine("resources", "updater", "font"));
+            }
+
+            if (File.Exists(Path.Combine("resources", "updater", "fontsmall.xnb")))
+            {
+                updaterFontSmall = Content.Load<SpriteFont>(Path.Combine("resources", "updater", "fontsmall"));
+            }
+        }
     }
 
 }
diff --git a/Intersect.Editor/Core/Program.cs b/Intersect.Editor/Core/Program.cs
index bc2586bd..88f8cfe4 100644
--- a/Intersect.Editor/Core/Program.cs
+++ b/Intersect.Editor/Core/Program.cs
@@ -50,12 +50,13 @@ public static void Main()
             Log.Diagnostic("Libraries unpacked.");
 
             Log.Diagnostic("Creating forms...");
+            Globals.UpdateForm = new FrmUpdate();
             Globals.LoginForm = new FrmLogin();
             Globals.MainForm = new FrmMain();
             Log.Diagnostic("Forms created.");
 
             Log.Diagnostic("Starting application.");
-            Application.Run(Globals.LoginForm);
+            Application.Run(Globals.UpdateForm);
         }
 
         private static void Application_ThreadException(object sender, ThreadExceptionEventArgs e)
diff --git a/Intersect.Editor/Forms/frmLogin.Designer.cs b/Intersect.Editor/Forms/frmLogin.Designer.cs
index 4695a151..e22d9769 100644
--- a/Intersect.Editor/Forms/frmLogin.Designer.cs
+++ b/Intersect.Editor/Forms/frmLogin.Designer.cs
@@ -191,8 +191,6 @@ private void InitializeComponent()
         }
 
         #endregion
-
-        private Label lblStatus;
         private Timer tmrSocket;
         private DarkTextBox txtUsername;
         private DarkTextBox txtPassword;
@@ -203,5 +201,6 @@ private void InitializeComponent()
         private Label lblPassword;
         private Label lblGettingStarted;
         private DarkCheckBox chkRemember;
+        public Label lblStatus;
     }
 }
\ No newline at end of file
diff --git a/Intersect.Editor/Forms/frmMain.Designer.cs b/Intersect.Editor/Forms/frmMain.Designer.cs
index 1549b812..60b650eb 100644
--- a/Intersect.Editor/Forms/frmMain.Designer.cs
+++ b/Intersect.Editor/Forms/frmMain.Designer.cs
@@ -121,6 +121,7 @@ private void InitializeComponent()
             this.menuStrip = new DarkUI.Controls.DarkMenuStrip();
             this.toolsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
             this.packClientTexturesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            this.packageUpdateToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem();
             this.statusStrip1.SuspendLayout();
             this.toolStrip1.SuspendLayout();
             this.menuStrip.SuspendLayout();
@@ -729,7 +730,7 @@ private void InitializeComponent()
             this.hideDarknessToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked;
             this.hideDarknessToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(220)))), ((int)(((byte)(220)))), ((int)(((byte)(220)))));
             this.hideDarknessToolStripMenuItem.Name = "hideDarknessToolStripMenuItem";
-            this.hideDarknessToolStripMenuItem.Size = new System.Drawing.Size(137, 22);
+            this.hideDarknessToolStripMenuItem.Size = new System.Drawing.Size(136, 22);
             this.hideDarknessToolStripMenuItem.Text = "Darkness";
             this.hideDarknessToolStripMenuItem.Click += new System.EventHandler(this.hideDarknessToolStripMenuItem_Click);
             // 
@@ -739,7 +740,7 @@ private void InitializeComponent()
             this.hideFogToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked;
             this.hideFogToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(220)))), ((int)(((byte)(220)))), ((int)(((byte)(220)))));
             this.hideFogToolStripMenuItem.Name = "hideFogToolStripMenuItem";
-            this.hideFogToolStripMenuItem.Size = new System.Drawing.Size(137, 22);
+            this.hideFogToolStripMenuItem.Size = new System.Drawing.Size(136, 22);
             this.hideFogToolStripMenuItem.Text = "Fog";
             this.hideFogToolStripMenuItem.Click += new System.EventHandler(this.hideFogToolStripMenuItem_Click);
             // 
@@ -749,7 +750,7 @@ private void InitializeComponent()
             this.hideOverlayToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked;
             this.hideOverlayToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(220)))), ((int)(((byte)(220)))), ((int)(((byte)(220)))));
             this.hideOverlayToolStripMenuItem.Name = "hideOverlayToolStripMenuItem";
-            this.hideOverlayToolStripMenuItem.Size = new System.Drawing.Size(137, 22);
+            this.hideOverlayToolStripMenuItem.Size = new System.Drawing.Size(136, 22);
             this.hideOverlayToolStripMenuItem.Text = "Overlay";
             this.hideOverlayToolStripMenuItem.Click += new System.EventHandler(this.hideOverlayToolStripMenuItem_Click);
             // 
@@ -759,7 +760,7 @@ private void InitializeComponent()
             this.hideTilePreviewToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked;
             this.hideTilePreviewToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(220)))), ((int)(((byte)(220)))), ((int)(((byte)(220)))));
             this.hideTilePreviewToolStripMenuItem.Name = "hideTilePreviewToolStripMenuItem";
-            this.hideTilePreviewToolStripMenuItem.Size = new System.Drawing.Size(137, 22);
+            this.hideTilePreviewToolStripMenuItem.Size = new System.Drawing.Size(136, 22);
             this.hideTilePreviewToolStripMenuItem.Text = "Tile Preview";
             this.hideTilePreviewToolStripMenuItem.Click += new System.EventHandler(this.hideTilePreviewToolStripMenuItem_Click);
             // 
@@ -769,7 +770,7 @@ private void InitializeComponent()
             this.hideResourcesToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked;
             this.hideResourcesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(220)))), ((int)(((byte)(220)))), ((int)(((byte)(220)))));
             this.hideResourcesToolStripMenuItem.Name = "hideResourcesToolStripMenuItem";
-            this.hideResourcesToolStripMenuItem.Size = new System.Drawing.Size(137, 22);
+            this.hideResourcesToolStripMenuItem.Size = new System.Drawing.Size(136, 22);
             this.hideResourcesToolStripMenuItem.Text = "Resources";
             this.hideResourcesToolStripMenuItem.Click += new System.EventHandler(this.hideResourcesToolStripMenuItem_Click);
             // 
@@ -777,7 +778,7 @@ private void InitializeComponent()
             // 
             this.mapGridToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(220)))), ((int)(((byte)(220)))), ((int)(((byte)(220)))));
             this.mapGridToolStripMenuItem.Name = "mapGridToolStripMenuItem";
-            this.mapGridToolStripMenuItem.Size = new System.Drawing.Size(137, 22);
+            this.mapGridToolStripMenuItem.Size = new System.Drawing.Size(136, 22);
             this.mapGridToolStripMenuItem.Text = "Map Grid";
             this.mapGridToolStripMenuItem.Click += new System.EventHandler(this.mapGridToolStripMenuItem_Click);
             // 
@@ -971,20 +972,29 @@ private void InitializeComponent()
             // toolsToolStripMenuItem
             // 
             this.toolsToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
-            this.packClientTexturesToolStripMenuItem});
+            this.packClientTexturesToolStripMenuItem,
+            this.packageUpdateToolStripMenuItem});
             this.toolsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(220)))), ((int)(((byte)(220)))), ((int)(((byte)(220)))));
             this.toolsToolStripMenuItem.Name = "toolsToolStripMenuItem";
-            this.toolsToolStripMenuItem.Size = new System.Drawing.Size(47, 20);
+            this.toolsToolStripMenuItem.Size = new System.Drawing.Size(46, 20);
             this.toolsToolStripMenuItem.Text = "Tools";
             // 
             // packClientTexturesToolStripMenuItem
             // 
             this.packClientTexturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(220)))), ((int)(((byte)(220)))), ((int)(((byte)(220)))));
             this.packClientTexturesToolStripMenuItem.Name = "packClientTexturesToolStripMenuItem";
-            this.packClientTexturesToolStripMenuItem.Size = new System.Drawing.Size(179, 22);
+            this.packClientTexturesToolStripMenuItem.Size = new System.Drawing.Size(180, 22);
             this.packClientTexturesToolStripMenuItem.Text = "Pack Client Textures";
             this.packClientTexturesToolStripMenuItem.Click += new System.EventHandler(this.packClientTexturesToolStripMenuItem_Click);
             // 
+            // packageUpdateToolStripMenuItem
+            // 
+            this.packageUpdateToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(220)))), ((int)(((byte)(220)))), ((int)(((byte)(220)))));
+            this.packageUpdateToolStripMenuItem.Name = "packageUpdateToolStripMenuItem";
+            this.packageUpdateToolStripMenuItem.Size = new System.Drawing.Size(180, 22);
+            this.packageUpdateToolStripMenuItem.Text = "Package Update";
+            this.packageUpdateToolStripMenuItem.Click += new System.EventHandler(this.packageUpdateToolStripMenuItem_Click);
+            // 
             // FrmMain
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F);
@@ -1103,5 +1113,6 @@ private void InitializeComponent()
 		private ToolStripSeparator toolStripSeparator13;
 		private ToolStripMenuItem craftsEditorToolStripMenuItem;
         private ToolStripMenuItem packClientTexturesToolStripMenuItem;
+        private ToolStripMenuItem packageUpdateToolStripMenuItem;
     }
 }
\ No newline at end of file
diff --git a/Intersect.Editor/Forms/frmMain.cs b/Intersect.Editor/Forms/frmMain.cs
index 1c6240f2..23a6e847 100644
--- a/Intersect.Editor/Forms/frmMain.cs
+++ b/Intersect.Editor/Forms/frmMain.cs
@@ -4,6 +4,7 @@
 using System.Drawing;
 using System.IO;
 using System.Linq;
+using System.Security.Cryptography;
 using System.Threading;
 using System.Windows.Forms;
 
@@ -22,6 +23,10 @@
 using Intersect.Enums;
 using Intersect.GameObjects;
 using Intersect.Network;
+using Intersect.Updater;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 using WeifenLuo.WinFormsUI.Docking;
 
@@ -1737,6 +1742,204 @@ private void packTextures()
             Globals.PackingProgressForm.NotifyClose();
         }
 
+        private void packageUpdateToolStripMenuItem_Click(object sender, EventArgs e)
+        {
+            using(var fbd = new FolderBrowserDialog())
+            {
+                DialogResult result = fbd.ShowDialog();
+
+                if (result == DialogResult.OK && !string.IsNullOrWhiteSpace(fbd.SelectedPath))
+                {
+                    Uri baseDir = new Uri(Directory.GetCurrentDirectory() + "\\");
+                    Uri selectedDir = new Uri(fbd.SelectedPath + "\\");
+                    if (baseDir.IsBaseOf(selectedDir))
+                    {
+                        //Error, cannot be put within editor folder else it would try to include itself?
+                        MessageBox.Show(
+                            Strings.UpdatePacking.InvalidBase, Strings.UpdatePacking.Error, MessageBoxButtons.OK
+                        );
+                        return;
+                    }
+
+                    Update existingUpdate = null;
+                    if (Directory.Exists(fbd.SelectedPath) && File.Exists(Path.Combine(fbd.SelectedPath, "update.json")))
+                    {
+                        //Existing update! Offer to create a differential folder where the only files within will be those that have changed
+                        if (MessageBox.Show(
+                                Strings.UpdatePacking.Differential, Strings.UpdatePacking.DifferentialTitle,
+                                MessageBoxButtons.YesNo
+                            ) ==
+                            DialogResult.Yes)
+                        {
+                            existingUpdate = JsonConvert.DeserializeObject<Update>(File.ReadAllText(Path.Combine(fbd.SelectedPath, "update.json")));
+                        }
+                    }
+                    else
+                    {
+                        if (Directory.EnumerateFileSystemEntries(fbd.SelectedPath).Any())
+                        {
+                            //Folder must be empty!
+                            MessageBox.Show(
+                                Strings.UpdatePacking.Empty, Strings.UpdatePacking.Error, MessageBoxButtons.OK
+                            );
+                            return;
+                        }
+                    }
+                    
+                    Globals.UpdateCreationProgressForm = new FrmProgress();
+                    Globals.UpdateCreationProgressForm.SetTitle(Strings.UpdatePacking.Title);
+                    Globals.UpdateCreationProgressForm.SetProgress(Strings.UpdatePacking.Deleting,10,false);
+                    var packingthread = new Thread(() => createUpdate(fbd.SelectedPath, existingUpdate));
+                    packingthread.Start();
+                    Globals.UpdateCreationProgressForm.ShowDialog();
+                }
+            }
+        }
+
+        private void createUpdate(string path, Update existingUpdate)
+        {
+            if (!Directory.Exists(path))
+            {
+                Directory.CreateDirectory((path));
+            }
+
+            if (Directory.Exists(path))
+            {
+                DirectoryInfo di = new DirectoryInfo(path);
+
+                foreach (FileInfo file in di.GetFiles())
+                {
+                    file.Delete();
+                }
+
+                foreach (DirectoryInfo dir in di.GetDirectories())
+                {
+                    dir.Delete(true);
+                }
+
+                //Intersect excluded files
+                var excludeFiles = new string[] {"resources/mapcache.db", "update.json", "version.json"};
+                var clientExcludeFiles = new List<string>(){"Intersect Editor.exe", "Intersect Editor.pdb"};
+                var excludeExtensions = new string[] {".dll", ".xml", ".config", ".php"};
+                var excludeDirectories = new string[] {"logs", "screenshots"};
+
+
+                if (Directory.Exists(Path.Combine("resources", "packs")))
+                {
+                    var packs = Directory.GetFiles(Path.Combine("resources", "packs"), "*.json");
+                    foreach (var pack in packs)
+                    {
+                        var obj = JObject.Parse(File.ReadAllText(pack))["frames"];
+                        foreach (var frame in obj.Children())
+                        {
+                            var filename = frame["filename"].ToString();
+                            clientExcludeFiles.Add(filename);
+                        }
+                    }
+                }
+
+
+
+                var fileCount = Directory.GetFiles(Directory.GetCurrentDirectory(), "*.*", SearchOption.AllDirectories).Length;
+
+                var update = new Update();
+                queryFilesForUpdate(update, excludeFiles, clientExcludeFiles.ToArray(), excludeExtensions, excludeDirectories, Directory.GetCurrentDirectory(), Directory.GetCurrentDirectory(), path, 0, fileCount, existingUpdate);
+
+            }
+        }
+
+        private int queryFilesForUpdate(Update update, string[] excludeFiles, string[] clientExcludeFiles, string[] excludeExtensions, string[] excludeDirectories, string workingDirectory, string path, string updatePath, int filesProcessed, int fileCount, Update existingUpdate)
+        {
+            DirectoryInfo di = new DirectoryInfo(path);
+            Uri workingDir = new Uri(workingDirectory + "/");
+
+            foreach (FileInfo file in di.GetFiles())
+            {
+                string relativePath = Uri.UnescapeDataString(workingDir.MakeRelativeUri(new Uri(Path.Combine(path, file.Name))).ToString().Replace('\\', '/'));
+                if (!excludeFiles.Contains(relativePath) && !excludeExtensions.Contains(file.Extension))
+                {
+                    var md5Hash = "";
+                    using (var md5 = MD5.Create())
+                    {
+                        using (var stream = new BufferedStream(File.OpenRead(file.FullName), 1200000))
+                        {
+                            md5Hash = BitConverter.ToString(md5.ComputeHash(stream)).Replace("-", "").ToLowerInvariant();
+                        }
+                    }
+
+                    var updateFile = new UpdateFile(relativePath, md5Hash, file.Length);
+
+                    if (clientExcludeFiles.Contains(relativePath))
+                    {
+                        updateFile.ClientIgnore = true;
+                    }
+
+                    update.Files.Add(updateFile);
+
+                    //Copy File (If not in existing update)
+                    UpdateFile existingFile = null;
+                    if (existingUpdate != null)
+                    {
+                        existingFile = existingUpdate.Files.FirstOrDefault(f => f.Path == updateFile.Path);
+                    }
+
+                    if (existingFile == null || existingFile.Size != updateFile.Size || existingFile.Hash != updateFile.Hash) { 
+                        var relativeFolder = Uri.UnescapeDataString(workingDir.MakeRelativeUri(new Uri(path + "/")).ToString().Replace('\\','/'));
+                        if (!string.IsNullOrEmpty(relativeFolder))
+                        {
+                            Directory.CreateDirectory(Path.Combine(updatePath, relativeFolder));
+                            File.Copy(file.FullName, Path.Combine(updatePath, relativeFolder, file.Name));
+                        }
+                        else
+                        {
+                            File.Copy(file.FullName, Path.Combine(updatePath, file.Name));
+                        }
+                    }
+                }
+                else
+                {
+                    //MessageBox.Show("File not added to update! " + relativePath);
+                }
+
+                filesProcessed++;
+
+                var percentage = (float) (filesProcessed / (float) (fileCount + 1));
+                var outofeighty = (int)(percentage * 80f);
+
+                Globals.UpdateCreationProgressForm.SetProgress(
+                    Strings.UpdatePacking.Calculating, outofeighty + 10, false
+                );
+
+                Application.DoEvents();
+            }
+
+            foreach (var dir in di.GetDirectories())
+            {
+                string relativePath = Uri.UnescapeDataString(workingDir.MakeRelativeUri(new Uri(Path.Combine(path, dir.Name))).ToString().Replace('\\', '/'));
+                if (!excludeDirectories.Contains(relativePath))
+                {
+                    filesProcessed = queryFilesForUpdate(update,excludeFiles, clientExcludeFiles, excludeExtensions,excludeFiles,workingDirectory,Path.Combine(path,dir.Name), updatePath, filesProcessed, fileCount, existingUpdate);
+                }
+                else
+                {
+                    //MessageBox.Show("Directory not added to update! " + relativePath);
+                }
+            }
+
+            if (path == Directory.GetCurrentDirectory())
+            {
+                Globals.UpdateCreationProgressForm.SetProgress(Strings.UpdatePacking.Done, 100, false);
+                Application.DoEvents();
+                System.Threading.Thread.Sleep(1000);
+
+                //TODO: Open folder with update files
+                File.WriteAllText(Path.Combine(updatePath, "update.json"), JsonConvert.SerializeObject(update, Formatting.Indented, new JsonSerializerSettings { DefaultValueHandling = DefaultValueHandling.Ignore }));
+
+                Globals.UpdateCreationProgressForm.NotifyClose();
+            }
+
+            return filesProcessed;
+        }
     }
 
 }
diff --git a/Intersect.Editor/Forms/frmMain.resx b/Intersect.Editor/Forms/frmMain.resx
index d15b1a07..9369b71e 100644
--- a/Intersect.Editor/Forms/frmMain.resx
+++ b/Intersect.Editor/Forms/frmMain.resx
@@ -179,15 +179,15 @@
   <data name="toolStripBtnRedo.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
     <value>
         iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8
-        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAHBSURBVDhPjVJNSwJhEN4ygiIKgi7VqfoBUfYfomsfEAVB
-        dYiuWmQfdOjQKbwUeMjMpI9ThoeISCkPYnaxsETSykgUtUXU1YPFNPP2aivJ1gPDvrvzzDMzz7uCHADQ
-        kMvldBi+RCJRwPjA8x3GgiRJbfiEbDYbxHM7L/lBPp/vwmRg5+IBeuesUDNiBNWwEdTzVjA7/JBOp1+i
-        yRRoTK7fItSZiqe3rkAY3K4YY3o7hGMiOxdFeLkg4GiL1JmS1UNGWD28gVDkHYKRJCzve9gklOvWHJcE
-        aR1ezgR8PdrvJBXjeHbqQCQK23UIGsfNpeJfAvF4okA7U+I5KgL60UE7ksiMwVlWWIw/Beh7UaSSN2UC
-        SLzvQ7cpwVc4R2PreY6J0A3Io0wAX5ZMMhMNZz4iuPHqWjhFGdQtk8mE5KOuHHjoqh5xnU5OUwb9SNgx
-        rN11lUQmNy8hk5XiuIaa05SBxFYc3au3edkqJNK/dgrJVFrCaQY4TRmiKDaRiUfOANSNmpgI/c7+p7dP
-        nHKK05SBntSiyJ7j9hWaJyxMZOPEy4zFnIrTlIHEKhRZ94ZioLO4maH/vhU5UGQWO8cq34YgfAFRX9iR
-        iEttZQAAAABJRU5ErkJggg==
+        YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAHASURBVDhPjVJNLwNhEF4qEiIkEhec8AOE+g/i6iMREgkO
+        4toSn3FwcJJeSBxU0fg4qfQgItrQQ1N1WVKk0Q0lot3URtrd9lAyZl5vaxvN8iSTfXfnmWdmnncFPQCg
+        Kp1OT2OEZFnOYnzg+RpjStO0BnyCqqoRPDfykh9kMpkWTIY3Tm+hfcIFZX12MPXawTzpgi3vHSSTycfX
+        xDtYHP7fItSZikdXz0HoXi8aAzYPRGMKO+dEeLkg4Ggz1JmSpT12WNi7BOnlDSIvCZjbCbJJKNdqOcgL
+        0jq8nAmE2qzfSSrG8TzUgUgU7gsJqge38sW/BOJxOUs7U+LhVQH0o4l2JJGxNV9BYS7+FKDvOZFi3hQI
+        IPGmA92mBF/hBI2t5DkmQjegjwIBfJl16ExcOw4RIYBXV8cpxqBuqVRK0o86vxukq7rHdZo5zRj0I2HH
+        qHXTnxcZXjmDlKrJuIaZ04yBxHocXbS5RbYKiXQuHkHiPanhNF2cZgxFUWrIxH1fGCr6HUyEfudb6fkT
+        pxzhNGOgJ+Uosu29eoLaIScTWT4UmbGYM3GaMZBYgiJLohSDaWeAGfrvW9EDRcaxc6z4bQjCFyc+2ILy
+        tHXhAAAAAElFTkSuQmCC
 </value>
   </data>
   <data name="toolStripBtnPen.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
diff --git a/Intersect.Editor/Forms/frmUpdate.Designer.cs b/Intersect.Editor/Forms/frmUpdate.Designer.cs
new file mode 100644
index 00000000..cb5665de
--- /dev/null
+++ b/Intersect.Editor/Forms/frmUpdate.Designer.cs
@@ -0,0 +1,153 @@
+using System.ComponentModel;
+using System.Windows.Forms;
+using DarkUI.Controls;
+
+namespace Intersect.Editor.Forms
+{
+    partial class FrmUpdate
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.components = new System.ComponentModel.Container();
+            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FrmUpdate));
+            this.lblStatus = new System.Windows.Forms.Label();
+            this.picLogo = new System.Windows.Forms.PictureBox();
+            this.lblVersion = new System.Windows.Forms.Label();
+            this.progressBar = new System.Windows.Forms.ProgressBar();
+            this.lblFiles = new System.Windows.Forms.Label();
+            this.lblSize = new System.Windows.Forms.Label();
+            this.tmrUpdate = new System.Windows.Forms.Timer(this.components);
+            ((System.ComponentModel.ISupportInitialize)(this.picLogo)).BeginInit();
+            this.SuspendLayout();
+            // 
+            // lblStatus
+            // 
+            this.lblStatus.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.lblStatus.ForeColor = System.Drawing.Color.White;
+            this.lblStatus.Location = new System.Drawing.Point(31, 220);
+            this.lblStatus.Name = "lblStatus";
+            this.lblStatus.Size = new System.Drawing.Size(569, 23);
+            this.lblStatus.TabIndex = 0;
+            this.lblStatus.Text = "Checking for updates, please wait!";
+            this.lblStatus.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
+            // 
+            // picLogo
+            // 
+            this.picLogo.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("picLogo.BackgroundImage")));
+            this.picLogo.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch;
+            this.picLogo.Location = new System.Drawing.Point(32, 22);
+            this.picLogo.Name = "picLogo";
+            this.picLogo.Size = new System.Drawing.Size(580, 160);
+            this.picLogo.TabIndex = 4;
+            this.picLogo.TabStop = false;
+            // 
+            // lblVersion
+            // 
+            this.lblVersion.BackColor = System.Drawing.Color.Transparent;
+            this.lblVersion.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.lblVersion.ForeColor = System.Drawing.Color.Gainsboro;
+            this.lblVersion.Location = new System.Drawing.Point(372, 319);
+            this.lblVersion.Name = "lblVersion";
+            this.lblVersion.Size = new System.Drawing.Size(257, 20);
+            this.lblVersion.TabIndex = 5;
+            this.lblVersion.Text = "Editor v1.0.0.0";
+            this.lblVersion.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
+            // 
+            // progressBar
+            // 
+            this.progressBar.Location = new System.Drawing.Point(32, 246);
+            this.progressBar.Name = "progressBar";
+            this.progressBar.Size = new System.Drawing.Size(568, 26);
+            this.progressBar.TabIndex = 6;
+            this.progressBar.Value = 20;
+            // 
+            // lblFiles
+            // 
+            this.lblFiles.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.lblFiles.ForeColor = System.Drawing.Color.White;
+            this.lblFiles.Location = new System.Drawing.Point(28, 275);
+            this.lblFiles.Name = "lblFiles";
+            this.lblFiles.Size = new System.Drawing.Size(284, 23);
+            this.lblFiles.TabIndex = 7;
+            this.lblFiles.Text = "20 Files Remaining";
+            this.lblFiles.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
+            this.lblFiles.Visible = false;
+            // 
+            // lblSize
+            // 
+            this.lblSize.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+            this.lblSize.ForeColor = System.Drawing.Color.White;
+            this.lblSize.Location = new System.Drawing.Point(363, 275);
+            this.lblSize.Name = "lblSize";
+            this.lblSize.Size = new System.Drawing.Size(237, 23);
+            this.lblSize.TabIndex = 8;
+            this.lblSize.Text = "100 MB Left";
+            this.lblSize.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
+            this.lblSize.Visible = false;
+            // 
+            // tmrUpdate
+            // 
+            this.tmrUpdate.Enabled = true;
+            this.tmrUpdate.Interval = 10;
+            this.tmrUpdate.Tick += new System.EventHandler(this.tmrUpdate_Tick);
+            // 
+            // FrmUpdate
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(45)))), ((int)(((byte)(45)))), ((int)(((byte)(48)))));
+            this.ClientSize = new System.Drawing.Size(628, 338);
+            this.Controls.Add(this.lblSize);
+            this.Controls.Add(this.lblFiles);
+            this.Controls.Add(this.progressBar);
+            this.Controls.Add(this.lblVersion);
+            this.Controls.Add(this.picLogo);
+            this.Controls.Add(this.lblStatus);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
+            this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
+            this.KeyPreview = true;
+            this.MaximizeBox = false;
+            this.Name = "FrmUpdate";
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
+            this.Text = "Intersect Editor - Updating";
+            this.Load += new System.EventHandler(this.frmUpdate_Load);
+            ((System.ComponentModel.ISupportInitialize)(this.picLogo)).EndInit();
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private Label lblStatus;
+        private PictureBox picLogo;
+        private Label lblVersion;
+        private ProgressBar progressBar;
+        private Label lblFiles;
+        private Label lblSize;
+        private Timer tmrUpdate;
+    }
+}
\ No newline at end of file
diff --git a/Intersect.Editor/Forms/frmUpdate.cs b/Intersect.Editor/Forms/frmUpdate.cs
new file mode 100644
index 00000000..91fe961f
--- /dev/null
+++ b/Intersect.Editor/Forms/frmUpdate.cs
@@ -0,0 +1,124 @@
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Windows.Forms;
+
+using Intersect.Configuration;
+using Intersect.Editor.Content;
+using Intersect.Editor.Core;
+using Intersect.Editor.General;
+using Intersect.Editor.Localization;
+using Intersect.Editor.Networking;
+using Intersect.Network;
+using Intersect.Updater;
+
+namespace Intersect.Editor.Forms
+{
+
+    public partial class FrmUpdate : Form
+    {
+
+        private Updater.Updater mUpdater;
+
+        public FrmUpdate()
+        {
+            CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("en-US");
+            InitializeComponent();
+        }
+
+        private void frmUpdate_Load(object sender, EventArgs e)
+        {
+            AppDomain.CurrentDomain.UnhandledException += Program.CurrentDomain_UnhandledException;
+            Strings.Load();
+            GameContentManager.CheckForResources();
+            Database.LoadOptions();
+            InitLocalization();
+            mUpdater = new Updater.Updater(ClientConfiguration.Instance.UpdateUrl, Path.Combine("version.json"), false, 5);
+        }
+
+        private void InitLocalization()
+        {
+            Text = Strings.Update.Title;
+            lblVersion.Text = Strings.Login.version.ToString(Application.ProductVersion);
+            lblStatus.Text = Strings.Update.Checking;
+        }
+
+        protected override void OnClosed(EventArgs e)
+        {
+            mUpdater.Stop();
+            base.OnClosed(e);
+            Application.Exit();
+        }
+
+        private void tmrUpdate_Tick(object sender, EventArgs e)
+        {
+            if (mUpdater != null)
+            {
+
+                progressBar.Style = mUpdater.Status == UpdateStatus.Checking
+                    ? ProgressBarStyle.Marquee
+                    : ProgressBarStyle.Continuous;
+
+                switch (mUpdater.Status)
+                {
+                    case UpdateStatus.Checking:
+                        lblStatus.Text = Strings.Update.Checking;
+                        break;
+                    case UpdateStatus.Updating:
+                        lblFiles.Show();
+                        lblSize.Show();
+                        lblFiles.Text = Strings.Update.Files.ToString(mUpdater.FilesRemaining);
+                        lblSize.Text = Strings.Update.Size.ToString(mUpdater.GetHumanReadableFileSize(mUpdater.SizeRemaining));
+                        lblStatus.Text = Strings.Update.Updating.ToString((int)mUpdater.Progress);
+                        progressBar.Value = (int) mUpdater.Progress;
+                        break;
+                    case UpdateStatus.Restart:
+                        lblFiles.Hide();
+                        lblSize.Hide();
+                        progressBar.Value = 100;
+                        lblStatus.Text = Strings.Update.Restart.ToString();
+                        tmrUpdate.Enabled = false;
+                        Process.Start(
+                            Environment.GetCommandLineArgs()[0],
+                            Environment.GetCommandLineArgs().Length > 1
+                                ? string.Join(" ", Environment.GetCommandLineArgs().Skip(1))
+                                : null
+                        );
+
+                        this.Close();
+
+                        break;
+                    case UpdateStatus.Done:
+                        lblFiles.Hide();
+                        lblSize.Hide();
+                        progressBar.Value = 100;
+                        lblStatus.Text = Strings.Update.Done;
+                        tmrUpdate.Enabled = false;
+                        Hide();
+                        Globals.LoginForm.Show();
+                        break;
+                    case UpdateStatus.Error:
+                        lblFiles.Hide();
+                        lblSize.Hide();
+                        progressBar.Value = 100;
+                        lblStatus.Text = Strings.Update.Error.ToString(mUpdater.Exception?.Message ?? "");
+                        break;
+                    case UpdateStatus.None:
+                        lblFiles.Hide();
+                        lblSize.Hide();
+                        tmrUpdate.Enabled = false;
+                        Hide();
+                        Globals.LoginForm.Show();
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+    }
+
+}
diff --git a/Intersect.Editor/Forms/frmUpdate.resx b/Intersect.Editor/Forms/frmUpdate.resx
new file mode 100644
index 00000000..b89054a4
--- /dev/null
+++ b/Intersect.Editor/Forms/frmUpdate.resx
@@ -0,0 +1,2151 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+  <data name="picLogo.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAAkQAAACgCAYAAADtqnPnAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
+        EwAACxMBAJqcGAAAAAd0SU1FB+MEEAY3ISF+/gsAAFvwSURBVHhe7Z0HeBzVuf5RtyRbtiRbvcuyJFsu
+        ki3buDfce+/dmOJCszFgbGN6Mb2EltwUUuCmk4TcJDiEyw3JP7khuaQRSAMCBEKA0Izb//tt9pjReDSa
+        3Z2Vdq3vfZ73Udk5Z845OzPfO9/5zndOUyiijIQgk4TJwpQg+T1RyGfRQkeeW6FQKBQKhSIABAfio4sw
+        S5grzAsyR9hNmCZEsPgtTjry3AqFQqFQKBQBgYEHJlWI8CgQ9hYOEA4RNgn7CsuFiJN0oZ/ChHrwBHUV
+        5gurhdZz9xNWCHsJM4UIJxVFCoVCoVAofAGiAiIwMoR4ZaqEg4WThQuFK4XLhbOFI4U1Qo7Dk+OHKDHn
+        R4iVCAcKJwrNuVcI5wrHCRFJpcIeQs6v3iKFQqFQKBQRwQgRvD0IDMRIgxDhsSS7bMCVtZO3/nDQoqv/
+        2H/enl+XD1v8UGpGjw3y2VghHhzK+OGpwTOFGCsUNgpn51Q0XlE3ZfsTgXPPvfw3pUPmfz65S9et8tl8
+        IaKsTogXi6k1nUZTKBQKhUIRMhAOCAiERHchQgSBMUI4R3hmz97D7+k3a9dvh62/98PTz/zUcTh4+YE3
+        yoct+pJ8vkTIVBbl/PASMVXGNBxtmJbZs/zSfjMv/pWc+5A5d9OyG9+oHLHiB12y8q6QY9ZynJA2IMyI
+        MWIajXpoiwojhUKhUCgUrQKhYOKEiNVBSDD9NVQ4XbimW37va/pMOvt/mlff8S8jRqwcvPKWf/Tsffq1
+        cuwEYaWQeiIVIAgzxFVzYnLa2poJZx10OvfwjQ8cHbjwypeKBkz9UlJq+kVy/DLhJCFTbGVCE9uk8UUK
+        hUKhUCgcgUCwxgkRHM30FHFCK9J7FF5ePnzJo00rDvxj+JkPHht+5iePO3Ho+k8cKhu2+CEpg4cGMUXc
+        DyIrEuBlYrpuZEp61tb+8/b8wenchkPX33Oo78ydv8utar43MTl1i5RbIBwlrBcirPB66TSaQqFQKBSK
+        EzBCCNFBzE+xkBVbY4SLklMzzs/vO+GzDfMu/+OwjfcddhIgVg5eectbIkRulrJThUYQ+eEhol0jROCc
+        VTNx89MiyhzPb+WQ1bf/q3rchqe6FdTcIGXXCWcI8XbRLrxfeK/whmn+IoVCoVAoOikQACZOiMBjPCe1
+        wuFCVottzKkacmfdtPN/idfHSXA4sd+cS/+QkJi0TcozZcYyeDxOkYoNYn8QMKxsW9Grz4jPSJs+cjr/
+        yXzweOPS6/9eNnTho1265++mvBCvF94vvGB4w2ijTqMpFAqFQtGJgNHHI2Jy+iA0yCfULGSaa3W3/Jqr
+        q8dueGLwilveGr5JRIVHDl1/7+Gy5oWPSh1rhMOEiCwEV6RCA+GG94opr9np3QuuGjD/iped2tAah214
+        4GjDnMueL+w/5fOJyWnnST2LhHjB8IbhfTLL9FUYKRQKhUJxigNDj8EnsNjECQ0SniFcntyl646yoQu/
+        MWjJda86iYq22LT8wJvd8nvfJHXNEyI0CGLmfJGCduPFob3jTktIOLdixIonnNrQFoeuu+fD+mkX/l9O
+        xeA7pK6NwllCvGJ4xzS+SKFQKBSKUxhGCNnjhEYLFyYmp23Pqxvz6X6zL/2DCIZDwzc9KOIhdNZNO//Z
+        pNR0vC8kTSR5I0vd/RIVxPrgzWKqa1lu9dAHhqy+4z2ndnhh0/Kb3uw9fuOPMnJLWaa/Woh3DC8Z3jIT
+        X6TL9BUKhUKhOAWAITfL6M12G32ETGfNFG7olt/7xtop237RvObOD5yEg1cO23Dv4cL+kx+ROhEXCAvO
+        5cd0mQEeG2KdaP+0tK65l/WbfcnzTm3xzgeOD1py7avFjTO/nJKetVPqJb4Ib5mJL9Jl+gqFQqFQxDGM
+        VwNDbpbRkxOIPb+mCFd1zavaXzV6zQ8Gr7j5LWexEBobl17/RnqPwqulbhI3sqeZyVLtF+gPHq7AajPh
+        +rJhi76DqHFqTygcuu6ejxrm7n4BL1lSavp2qZstQfCe4UUrEpr4Ip1GUygUCoUiTmCEkHW7jf7CwHYb
+        KRndLyoaNP3hAQv3vzRs0wPHhokg8IPV4zf9JCExiZw/44WsLvNzusyAfiHu6M/87IqmOxuX3/RPp/aE
+        wyFr7/qgZuLZP+1e0o+0AWxBghcNbxrL9NlQFi+bLtNXKBQKhSKGgYE2y+gJDMaz0WK7jbz6cQ/Wz9j5
+        W1aDDdsoIsAnDllz94e9akf/h5yDDV7xQhGDg3DwGwgRYnuIT5rIarHaKdt/5dSmSNi47KY3K0eteTwz
+        t4z4IjaPZZk+/ULo2ZfpqzBSKBQKhSIGgEG2xgnhycCjgWeDRIRrs4rqr6+ZePbTg1fd+q9hGx8Qo+8v
+        G+bs/lN6j6K9ci629yDGB0GGOPMb9BXBR3wS+5StLG6a/dXmtXd/5NSuSNl//t6/FjfOfCQ5LfMCOddi
+        IV42NrfF64b3TeOLFAqFQqGIAWCIMcgmTggPhtluY2Vat56XVY5a/f1BS69/3cng+8WyoQu/I+dbL8Qb
+        hVhAKERLJNBfxAjer5np2UX7Byzc/7JTu/wgYqvvrF2/79Vn1H1yvk1CvG30k/PjhdNl+gqFQqFQdBCM
+        EDLL6BEheC7GChcld+l6QWH/yV/oP3/fX4au/8QRJ0PvF5tWHHg7u3wQOX3mC4ntQZjRtmiBviMA6TP7
+        k23sPf7MHw/beP8xp/b5xaYVt7xdM/GsH3fNq75Gzslu+njDNL5IoVAoFIoOAIbWGidEIkE8FacL8Vxs
+        zK1qvrt+xo7fBKaRNogxjzJrJ2//ZTDzs8k9RIwPoiBaMGIQ4TVAuFD6/Imm5be849Q+v9m49MZ/lJ++
+        7DG8b3Ju6zYgTvFFCoVCoVAofATG1cQJme028EywUSkJBdd0L6q/rve4TU8NXnnLv4ZtuF+Md/TZvOau
+        j4oGTCX3EMKAmB48JX7mHmoNjAUemWrhZBFkF/adefFzTm2MBoeuu/dI/7l7/lLYf8oXUzN6XCRtYBsQ
+        vHMs0zfxRboNiEKhUCgUPsJ4REycEAkDTZzQitSuOZeUNi/45oBFV786FGPdjmyYt+ev6T2K9kk7WJ6O
+        pwohEM3pMgPGBOGFh4xpqzUlg+d+s3ntPUec2hktDll796HaKdt/mVPVfJe0gW1A2BQXbx1joduAKBQK
+        hULhA4wQsm+3wYaki9hRvrD/lC/0m33pC83r7z3qZLCjyvX3HasctfqH0haEwEhhtIOp7WBssoWMyRwR
+        ZlcPXHLdPxzbGmU2Lj/wdvXYDU92K+hzrbSFjW3x2uG9w4tn3QZE44sUCoVCofAIDKaJE2KrCjwNbDzK
+        BqRsRLoxp6Lpzj6Ttz4zeNXtH4gwQZy0OxuX3fR2dtnA9gymtoNxIvkjsTuBDV97j9/8/4auv/eYU3vb
+        gwMW7H+lbNjibyV36XaxtMm+DQjjo8v0FQqFQqHwAAwlngQMPZ4FNhplXzA8Dqszcsv2V4/d+CRixMkg
+        tyfrpp7/a7xU0q72Cqa2g7EipopxQnQszakccn/Tilvec2pve5Fpu35zdv+5oN/EhxKTUhgf4ovw6plt
+        QHQaTaFQKBQKF5igaQwm00+soJokXJ6amX1xceOsrw5YsP9vzes+0WEeEMPBq27/kIBiaVt7B1PbgajA
+        i8bU1JTUjB4X10278HdObW5vNq249b3ayduf6VE64FZpm30bEEQcole9RQqFQqFQBIFBxLATK8S0Ct4W
+        DOe8hMSkc3vWjPhU35m7nm9ee/cRJ8PbEWyYu+fF5LTMXdJGcvEwnYeIow/tDcbOBFcTs7OqoN/ELwaC
+        qx3a3RFsXH7gncqRqx7P7FlutgFB5CJ2iQlDzOERVFGkUCgUik4NI4aILeklRFywfHt59+K+N/Qev/kn
+        g1fe9sHQdfey1Dsm2LzmnqNlzQsfkzauE5KxGcOOmOsoo46XxWSunpGeXbSv/9y9Lzm1vcO49hPHBsy/
+        4m9FA6c/kpTShWk0ckYxFUpsEWISz6CKIoVCoVB0WjBNZsRQvZB4nHW9+ox+sH9gekwESIxx4OLr/tk1
+        r+pGaec8IXExOcL2DKa2AyHBGDLNiEDbUD586Q+c2t7RHLL6rsPV4zb9uEv3/MulncQWsUS/UoigU1Gk
+        UCgUik4JxBDTPT2FiKEzEhISzyxtXviNxuU3/8vJoHY8P3G8asz6nyQkJW+R9o4XssKLWJiONuQIMqYb
+        We02v3tJw+0Dl1z/T+c+dDzrZ178fFZRPaJyqRARhyjCU3QqTJ/xXZAOgalfvo9BNvI/FgsQR2U8i25l
+        BgoR3sab5iS+qYO6zEKE1s5L/Xg0W2tbJDT184JAW9zGIFRGs25IPfbvxA7GnfHne+D74HtxqssLTX/o
+        h/37bOv6CZXWsTPnwitPYldeovAsM4XtVNYLKUsd1EWd1O13H6x06o9CEdfggYMY4qJmd3g8QxsqRqz4
+        7uDVd3yE8IhFNq64+X0RG3dLWzHkrOziARoLng3EJavcEBYTEhKTtlaP2/hTpz7EChvm7XlRxvIWaS9j
+        iacIQ0NMEQ+5jh7PcEHbMQwzhDuENwjpo5X8j/gzAvIHC3khQFgTdO5U5mbh1UKmGklGSryY1RAwVhhq
+        6qJO6m7tvNTPBr2ttS0SmvrxnJKXa27wbz/OE826IfUwbsS4IdBZDcl9bYBIwggTM8j3wPfB9+JUlxea
+        /pCyAyPPNcB3ygsB90Fr10I4tI4dIQkIFZ4TXEtnCUkse5PQqawXUpY6qIs6eZ5DP/tgpb0/eMcVirgF
+        D3AeNkyTsPUEMUNry4YteXTIqjs/al4rBjNG2eeMbb9OSulyobSXG5/VUhjwjgimtsMITARak3BZr5qR
+        /9G47MB7Tv2IFfaft+/lrvm9r5P2LhYSFI6YwOMWC2MaDvDSER/FyrpvCL8vPGgj/3tU+Fkh+ZpIKbFK
+        eKfQqczjwv8SflWIMeDaQwAZYKwRQ9RFndTd2nmp/+HgT6djIqGp/wHhAeH9wb/9OE8064bUw7h9XoiB
+        5/vA2DK2XI+8/GDweRnie+D74HtxqssLTX/+Q3ilEIHHtY/3jqnk1q6FcGgdu61CRB2imHP8p5B4yEj6
+        QlnqoC7q5PnI3o5+9sFKa3/OEfI9qadIEZfAcHPx4lrlTYi3sRWFA6Y91LT8lvedjGascPCqOw7n95v4
+        BWkvb5EEBPOm3hFL7VsDIuLEEvzktMyL6qZe8DunvsQS62fsfC69R+FeaTNGgWkIt2mLWAbtZepgt/Bb
+        QqeHuZUYEgQMBvEeIUbF6TgrMcYXCJneMTmvGK/lQuqKxLD5RQwWgsFvQwijWbfhd4WfEpKBnu+Ta5Ix
+        597/ntCpTLjk+/qO8HYh1z+e8muEXq6FUMmYIfg4F9eK332B1Pk14ZeF0eiDlfTnPiHJenm5VijiDiaI
+        GjHBW+2inMohdwxccv1bQ9beczyWWTd9x/NdsvIwdrzR4xJuLZ6jo4BBRkh8vAS//+SHm1bc+qFTf2KJ
+        vSee/fPE5LTt0uYpQowQbv14iyfiWiCb+m3Cx2fPnv308Vbw3HPPvSnH8FBH4OAl4OfByy677JngIS3w
+        wQcfHA4ej8HBoI0TsrcfYLqNN/JAHdQdLHYS+By2dp5I8dRTT71szuH3eaJZN2DcDhw48GywfsYZb9Ba
+        4dnCzwh/IDz4yCOPvMD3ESwWNh577LG/bN68+WfUKURAXyXE44GRj9bY0S+ESkAM0Zc333zz/eBhYYM6
+        qCt4jhNsh+vsS0KEa5FQoYgrYNyYKmNaoa9wekZOyeV9Z1/6JycjGUscvPrOI8WNs3jzWS0kRxI3YCx6
+        MTDKCDXcyNNSM3pc0nfWJX926lMssWnV7R+VDJn/TWkzBmiUEO8hMVHxNHWGt3C0EEN60KMgwvXPWzs/
+        XQ3Igw8++PtgGRKCkvIB4QuYdt4pDNShgigyWAw7AhPPHYI14O145pln/h48zBcgrLhOpG48RQ8K8ZRy
+        vqiOHUSQBT/2DdRpPUc7XGdM0yFYmW5UKOIKGDemynijZSuHDVWj1z85ZI0YxRhnw9y9L4t4I3CQYFk8
+        GLhoY3He2niJEGwIt9WlzYu+PXjVnUed+hVLHLj4+re6F/cjaHKhkEBTpoJiaUqyLURVEFnKMMVCkktW
+        23BPqSDyERZvHFNzeG6YQnscb07wEF9hERF4O/Au8jOqY+d2bUaKoMCL6nekgkgR78CoYTDY4oIAxUU5
+        Vc13Ny676d0ha+4Wgxi7HLz6zqPlw5fiYsZ7wWooAh+Z9otVQ41QM4kaZ4qQ299//hWvOfUt1lgzacsz
+        wf3PzhASJxNr05JuiKogAhZvAtMqTN3ygqGCyGdYxtnwIB664Me+wnIt4IH+dPBnVMeOqcHgR77D4sls
+        j+tMBZEiLmGmcgj4nZyUmn4+e245GcVYY8Pcva9k9qxgfp9lpORLMrlDYlUQ0S6TqJElyuvLhi7+PsLO
+        qX+xxMblN3+Y328SAoHl4yZwPV4CrKMuiCzTOQStkguLqUUVRD7D6uUwbAdBFNK1EArsYxetvgAVRAqF
+        O6zeITZCXV7QMOWLTctvPTRktRjCWOaqu46Vn76CN0SzTQc3HsGssWygaRuCjRxPDcJ5GTml1w1YcNWb
+        jn2MMdZP3/lCWtdccsJMFSKg48VLFHVBRPBqsBweS5aHMy2KSFdB5CNUEIWPdhZEGlStiDuwssy49icl
+        JqeeVzv1wt8PXn3X8VjngEXX/LNbQQ15cmYLCQSPde+QAe0jfwrxWuNOS0g4t2Lk6h879THW2Lji1o/y
+        +00icNia3iAevERRF0SAY4JlPydcJkQUhSSI2qJbHU5ioTW69cdupENlpHWH2kc3EeG0wspKv6+FSMfO
+        rS9e6qa/wcNPglUQtcUIrzNddq+IO2DEWD5NJlbyeSzKqxv76UFLb3zfyRjGEptW3XGsasz6p6TN64VM
+        PRnvkMn/EikYGyf6AephRR97xBGztSSrsO6OAQuvfsupr7HGPmds+01KRncSDbIMP5YSYLqhXQQRK52C
+        ZQn4JQ0EBuESYUcLIgwUbTiRg8ZHo+573aH2MY4FkRm7rwgDY9dOgojzuuaMivA608SMirgDhtnEs7Cc
+        elPv8Wf9bPAqMXwxzgELr/lnVlE9WXHJPGw2cfUjNw7lMe4YUAQWy8vxoPE7/+MzP4SRWdWHZ+6MxKSU
+        7eXDlz/l1NdY48DFN7yXU9nMA8++RUoso10EERg4cOCTcjx5cVgWjlHYLwzU4WZk+DxIUhyQ7dlsh/AJ
+        IWIjYLw8GioE2SeFrIwyWyow1blHSBJDr0ad6T+mPuiLaY+dftQdTh9P0KMgYkUa3yfnY2wCCTqjKIi8
+        jt1lQq6RwAo2j4LIWvddQtpG/7wKIvqBB8e6xYlf15lu3aGIS+BNMdmTp2UV1l7bMO+Kvw9edacYvthm
+        1ZgN3JCkuMfIlQn98A4hdBBViCC8ZqVC9kiC/I5Hh8/8El4YaWK32M5jqQi8OwcsuvYdp/7GGsuGLf3R
+        aQkJBEwy/oxNrMdutZsgshjgR4RskouxCNThZmT4PEjEkElvANnOganhgAH3aKjIl8MWF8QFmk03iVlj
+        6wly6ng16l8Xkn+HlYWmPXb6UXc4fTxBj4KIIF+MNedjbAI5haIoiLyOHS8Va4RkqPYqiKx1kwiUftE/
+        r4II4YpYx7tu2uLXdaabuyriElywJGJkR+RFRQNnPNK4/JbDTgYwljhw8XX/6lHS/w5p84Jg2+lDpCLF
+        iCEEIh4zHvB4zXjgQH7nf3zGMX6IIuMl4gEyMSExaUvlqDVPO/U51lg/Y9df07rmXi7tNsHV9EMFkeDl
+        l19+J1jeeCQwGqEIIt60MS4GnleqWQwV/aS/9NuA74h0AHj3vBp1ryuFIq07nD6eoEdBxHdB7Bvni9q1
+        EMbY8fxiv8BQBJG1bjy09Iv2eRVEnItzcm4Dv64zhSIuwTRHgZCtJNZUj9/8kyYxdrHOipFrnkY8SJsn
+        CNkZGq9NJN4hDDnikHp4wPC2Myslvfu5vWrH3N6rz+jbUzOzz+V/wc84BgMQaQA3ZXmQ8EDDAC7qXtJw
+        W8P8K9906ncsceCSG97vUTYIVz2ucaYsCZyM5TiidhNEILjtAysgKUsQOpuTqiASqCA6CSqIFIoYAKuD
+        uKHwfpxVP+PiPzWtvON4LHPAwmve6VbQh/2i7PErkQoT5roRh9Q5N6uo71V10y76rRj+92Dd9J3PdS/p
+        z8aObPLIMRzrRwJIRARCjJw1Y4WbKkauftKp77HExuW3HikcOIPtE/geMN5MMcayi7xdBZHFcBEoy/RG
+        IGDWzcgEj4cqiLz18QQ9CiJibliEwb2mgkgFkULRAsR98HBgDnpb/wVXv+lk/GKJlaPW/vS0hASTLZkb
+        mAdxJJ4JBA2GHA8HQYBTumTl7ayfseuP9nOLYHwhPbvkUjmGBz+Zpv0I5Kas2UOO+fc53Usabpbv4p/2
+        88cUV9x+TITbj6S97B+H14xYKMYiVtGugogtJizB1QTABjYfdTMyfB6kCiJvfTxBj4KIugn8JmcZO9cz
+        7e7rRr9ABZFCEZ9AEBG/Mkl4IfFDTStvF4MXm+w/f/8/RSxwA+KVIBAZI8yNGIkgYaqNceDBwtYfq8uG
+        L/1e08rbHNtQNmwJS1VJBIlXjWBu8glFOlVk2kBwciB7deWoNU82rrj1mFMbYoU1k7b8Stq6Qcgu8uQj
+        iuWHYrsKImAxPifoZmQsx6kg8tbHE/QoIhCmfJ+siOMevl4YCCBug0x9PiRkRVYoq+jaSxBRfokwUN6j
+        IELc4e225ghSQaTo1MCYI4gmC3c2rrj9eCyzbPiyJ0liKG3l7Y52++EdwqvBA4U4mNmZvSqv7jtr9ytO
+        54d95+z5e3p2CVNnxM7g0aGsH1N2tAOPE+2Y1TWv+tq+c/a+5tSGWGHt1Iuel7ZuFiLi2ENOBZEFlnpO
+        0M3IWI6LJUHU1kops6qIlwNi7DpEELW1/5dlk1aWlHNeVv5dK2RFH+cMLDW3kf8R+4XQYAzOF35K6PfY
+        sShhuTBcQcRznHhKQgkQfdY+OJGXOsQdL3XWZfEqiBSdGsSucBOQYC+mBVG/OXtfF5FAjgtWlpFEEjcx
+        N2EkQgQxxcPExBRsLBu27GDj8tuOObXh37ztWFHj7MdEmJ0lx48JlqWOSNoBrJ4qXPrrSoct/b57WzqW
+        9TMuwcjwUGbsaDcxabGKdhdEwG6841AQtZVLx+SdYck9Gyy357L7E9ORTE8yTRk8xBGW8+LxIdcTeXgQ
+        RbzgkNPMqW94k9i7j3sdL040xg4xxBL4cAURzzEWl+D1IpeQm8DjM9rDUnk80tbFKCqIFJ0aCCJ2LWfp
+        9MVi7MXQxR4HLb/laOnQxTz8CIjk5vNjqgoBg2eHYGCW7s/vmt/7xn5z973h1AYr+87e/VpGbhkPb1zO
+        JimkHyvOqIPtR9j/amZ6dskVfefsec2pDbHA+pmXvCjt5EGOseDhGstJ2KIqiNjHLPhrC1g8EwHGoSBq
+        i8bI4p0guSBbloQjGMJJCtji+3GbKjKwfLeIIsQX590qxEtuculYPTg8H3n5IgcZoi0aY3enEGEWmI4L
+        QxABvmfaSqJaRBZiqzUBxlZHeKbsIkYFkaJTo6UgWi6GLgZZP33Xi2lZeeS8YUd79izzI5iZNyP6H9hP
+        LCEx6eyyYcuedDq/E0sGz+dhjkAzm8r6seKM8tTD9BNxOauLBs78+qClNx9xakNHs35GQBAxhYkgQqR2
+        WkHElh3BX1sAr0WwrgDdjIzluHgSRIa0DTHU5lh5qdtjHz8j3Ce8V8j9eBABGjysVVB3MOCdOhBFtwrn
+        C7mPW1spGe2xO3GdhSmIgHmhQuwg5qzizgg8PjN7PtqhgkjRqRHzgggxUDhgOq51VjOxUWaRMFLxQVm8
+        Q7z1Mf22IKuw/raGeVe+5dQGJ/addfmrXbLyeRgj0vDoEJzol5eIuljFNi0lo8euuukX/8WpDR1NFUQf
+        w807QXxLsL64EUShgLqEeDtO7I3VToIIzxLTWVyDTDcFRJEXTxHJMy2i6DtCvDRM+3EdO4mFdhu7CARR
+        pFBBpOjUaCGIBi2/9XissXb6zr8kp2Vyk/IwYlm8H8KDqTb6zrz7eOHmilFrf+J0/tY4cOmBI8VN874t
+        ZUm5z+o0vDp+eYmIxWHVFgJwZX7fSQ8PXHrTYad2dCTrZuxSQRQERqw1L5Flw9dTWRC1oBdB5EW4OCHY
+        R6a8WDZPyhDygjHtdUIUuYkKA6Y5LeNFnigSjbJai7hAewqJdhs7FUQKRcegpSBaJoYuhth/4XUf9KwZ
+        hRuet0CyaSMSEAuRemG4eYkL4EG6uHtxwx0N869+16kNbqyftfu19Oxiq5fIuKIjFUXU0V3YRzg1JaPH
+        xdXjznrWqQ0dybrpKogMMGJuK52MN0IFUWSCyDIFiUeFuBvi/1iMwLY6xLOxnJzPPIuiYFZx6kQUGa8T
+        L0tWUaSCyAIVRIpTETZBdIsYuthh1dhNv0pITGapK6vgWJqKSHByZ4cCvEPsRUa/z5D6t1WNO/OXTudv
+        k0tvPlYyZCEPX1bXmFgiHs7WlRvhwIg2smET6LmsR+nAexvmXyWizaEdHcS66RerIAoCI8Yxra10wvjz
+        uQqiyASRGUchCRJJ0Io3B9BPXkrOFLI0PiCKvPSR78wmigi0ZhUWzwgzfiqILFBBpDgVEbOCqGHele9k
+        FffjZiMJ42Ah4oCbzg/vEJ4mhMby3OrTP91/4bXvO7XBC+tnXPJKRm7ZVVIXKzdYcUZeokgDvoERbjyk
+        2Pj13PIRq552akNHUQXRxzCCqLWgXjwRfK6CKDxBRMyPGWMh02L0j1VfvCQZ0Fem1UkWSh8D26XQlraW
+        5PM5x3F8sBzlNwoRWdSrgsgCFUSKUxEtBdFSMXQxwZuPlzYvecLnJIzATEXhbZqakJh8Qe+JW37v3AZv
+        HLjkwNHS5sXEM/Dw5MHAGyvjGmlbjXhjao/A7/ld83rf2Hfm7ted2tERVEH0MYyxxtMQ/NdJoPwpLIhC
+        Dqp2M/wIII5xIOdgWoz7jeeC3WNMf3mm4eHB0xMQRXwvbYkiQLs5XmjOg+jgRYf0HO0ydiqIFIqOQQtB
+        NFCESCywduqOl7p0L7hS2sRSWGIEWA3GDRepd6hFsHJe/YQv9V947YdObQiFfWfv+Ue3wjqM2EIhhsyP
+        pJEAUUW+JcQGWWXXFg6Y8fUBi2884tSO9matCqITsHgvDmLMg/9uAYxZa4HXwJQXdrggshher6RtIS27
+        J64q+C9HWKaxyEHG8nhyFrFEngSExnPjBDy0xAARC0RMUEAUMTat5YuywvJd4oliaT/Z2NkqiBw/0Rq7
+        E9eZCiKFomPQUhAtEUPXwey/8PqP8uonPiLtYZk9cTkk/CMuJxKPC8KEh6RJejgjNTP70j6TL/iTUxvC
+        YenQJf8dBY+Wtd2BZfjJXbruqDnjvOed2tDerJ2mgsjAKohamwrCQ4FBC/55Ekx5YTwJIrwatCucxIwH
+        3QSiJV4I78knhawkY1UZz4S2DDD3Dd5askuzpJ6l9Z5FkeXciCKyb28SEisYjbHzIzGjH1BBpOjUsAmi
+        A2LoOpZVYzb9Mik14wJpD4HUfi6zx9PCgxRPy7rCATMeHbDohiNObQiHfWfteSurqEXMkx8bzwLK49ki
+        hoq31MXZFYPv6Tf3inec2tGerJ22UwVREFZB5Ob5aM17BEx5YSwJIgRBtLbucN2DzMRdCREOLLHnZYO4
+        OuuiBZ4NrSUjJE6Q/rIwg3YFPEV8P27fg4FFFFGOvl4oDKV/Xscu0q07DNzGAmpiRoXCBTEliOpnXvZG
+        1/yam6QtTD2xJN6PqSfKUgfTboEtOtKzi6+pm3bxK05tiIQVI9f8PDEp5Tw5B9sAEKfEwztSLxHg4YUx
+        I6s24mMDcUsDl9x0zKkd7UUVRB/DKoigm+ejNVjKYywxYAYdKYiiublrQJy4xfYEp82I0UOIkN7CHkTN
+        uVnQgLBw2q6CTUzZZoeffJd4mwLndRtHA/rB8ULiia4I/vR77CLd3BUwFjzLdesOhSJMtBBEAxYfON5R
+        7L/w+sOFA2ZwIxIfgBfHr+BkymMIeABMZFqrePDCJ5zaECn7zbvq/R6lgzAIPNx4O/VjZRygPJm1WcHG
+        1iUzUjNzL+kz5aK/OLWjvdhnqgoiA7sgcju2NVjKY7wwmAYdKYi8Ts2EU3eA/B386CRY9oL7ipApM54L
+        3A94ifD4EjyNB4axCQQl22impZjKQ1QRE8TGrogs17EElvPj6WGHfH76PXbc10zt6eauCkUHwiaIbhJD
+        1zGsGrv518lpXS+SdvBQJV4Gt26ky9eNdwhhwjTW0qzC+rvqZ+9526kNfrByzJnPJqdl8hbGmPqVOwnw
+        4EJwmJQBS3Mqh96PCHNqR3uwz9QdKoiCsAsi6CVWxQpL2U4liDxOmzH9dKOQa5/7iWuNFyc8PwGvTxs0
+        sUC7hdRDHqOAKHLz5lmuha8JPx38GWuCiHCACULiuOin6XNrZLwYN8bPes+qIFJ0asSEIOo7e+9bXfNr
+        DkgbiENgqoz4m0gzUgMenGaZ/ZTE5NQLykes/l+nNvjFhvnXHOpZMwojulLIajY/smsDypupM94Gxwo3
+        lg5d+sSAxTc6tiXaVEH0MZwEUSh5doClbKcSRNBt2oy6gseRcJEpIeIK4VxhYArLTURYYoEQHCzXpxyr
+        WAPj6fe10AGCiPJsORIo73bdWa5Txo1xYBwNVBApOjVaCqJFYljbmSIgPsrvN4W3Lty93FhmqixSrwoC
+        wiyzZ9uPFbnVIz7bMO+qD53a4Sdrzjj/Lynp3XfJOY23y4/AcEB5M3VGbpQZXbLyd/eeuO15p3ZEm32m
+        XKSCKAiLocHrwDLxx93O4YRgedjpBJHbLvWWaSu8OsTo8ULgWURYBBHfJatXuScRAwisU0EQEWvJCxjt
+        8yqIOBfn5NwGKogUnRotBFF/MXLtzfKR636elJLOKhDawIMqR+jHVBkCBCFCndNT0rN2iXD4o1Mb/GbD
+        gusOF/SfzkOFhy8bv/LQ8mNLD2CfOlvSo3TQPfWz973j1JZoUgXRx7AYGpZ3Y7gDy7zdjIodwfKw0wki
+        t+PxHgWPYzqIRRdc93iRwxFECAf6ErVrQQWRQhGf6FBB1Gfqzr+l9yg2CRgxAH5NlSEaECA8LMhltLag
+        /7SvNyy8/ohTO6LB2mm7XsvIKbVv6YF3xw8vkZk6M6vO1hcOnPVt6d9Rp7ZEizX/FkQsF6YNBGiqIDrt
+        NHJoEbTKT1fjZkewPOwsggiBw5L2QNxLiNNmjIkKIhVECoVvaCmIFt5wvL3Yd/a+d3OqhjOPTTZZvCgY
+        VNoT6aoyBAM3p1lmPzezV/V1IlD+7tSOqHHB9cdKhy59Us5PzALJ5HDzYzT8nDrDm0aiyWkEpFeM3vhL
+        x7ZEiTVnnP9nObcKIoHN0Fwj5Nr+QVvLyq0IloedRRCx2otkhPwMZdoMjzLT4CfiZlQQqSBSKCJFhwii
+        hgXXHStums8SUCMWuBEJfvZjqow6mCojkJpEbmdVjNrwv07tiDbrZ+39V4+yJpbB8uA2G9QiGiIVRMBM
+        nVEngejz03sUX1U79eJXndoSDdZMOs8IIh6ICCK8e7GK9hRElwpZyfQo/8OIBQ9zBccGGUuCqK1cOpB8
+        Orx8kJQ0EJfjse4vC+8XYtwfd9sHzjZtxviQk4il46EIIs7DClD6QtlAQHYUBZHXsSPhKjGUoQgia908
+        Q+kX/VNBpFCECZsgul4MXfRZNe7s36Zk9LhYzslu1eTV4ab0YzoJ75LJSI3XaWXPPmMe6jf3yg+d2tEe
+        rB5/9u+lrybAGm+OHzFSgPJ4m/gOTX9X5PYe+Zm+s/e959QWv1kzabsKoiBshoY3dxgwcG7lrODYIGNJ
+        ECFA3LItQxL+sZydKeKHhV7rxoCzbQW5gQJL591SFbA8n2OCx7O/2FnCUATRd4V8n/SFrUDYHy2agsjr
+        2F0uZOuOgKDxKIisdd8lpG30TwWRQhEmWgiihgXXH482+0zd+VrX/D68PZts1AQH4+mINOAYgYBBxn2M
+        MZmfnlN2Tc3ki15xakd7sd/8a4/mN0xjSsC6is7PqTPEFd41HmbjhRuLGuf/QM57zKk9frL3RBVEBjZD
+        wzQwwoPrPBAf4yUnEccFiaGMFUHkhXh78YaxWjRglEMQREwvnhADbsbcUo7zXC3kpSoUQeTIKAoiLzxp
+        7DwKolapgkihCA82QXSdGLrosX723vdye4/kRmS+m2BnVib5IQ6MMDCboE5JSEzaVnb6qp85taO9WTv9
+        kjezivqSNI08S7jHzdSZH6vO6DsPIx5seNtMPNGzTm3xk70nblNBFISDoUHsbxEyLeRqpAw4Lsh4E0Qn
+        MQRBRL/OFNKmUKbNOJ4FGfEuiE6iCiKFomPQUhDNF0MXJfabd83RosZ5Jm4ITwbnJdbHj7ghM3WE94Xs
+        q2t71oz+Ut/Z+w85taUjWDnmzN8mpQYyWJupM7+mCYE9nmhBRk7ZtQHvmENb/KIKoo/hYGhYAch3fZ/Q
+        U04iOS5g0IQdLohChWXMAgxBECEaiQfCUxTwkLhtvGqZNmuxlYabiIgE4VwLocI+dtHqC1BBpFC0jnYT
+        RJWjNz2blJLOLvY8kE3cEDdRpILAKgbwvizK7FV9U58pO193akdHEUGY328qrvENQoIg2VuNzV/9mjo7
+        KZ4ou6L5k/Uz97zr1B4/qILoYzgYGqZuCZhlQ1BPOYk4JsjOJIiItRouJCYokKrAzcPBNhscIyT+BzEU
+        iANSQeQNKogUitbRQhD1m38tMS++s/ek817MyK0gToB8Q3gw/JoyQgiYzM2IrOlJqRlMF/3aqR0dzdrp
+        l77VvWQAq87Y/JVtPVgySxB4pKkGAGNhjSdCdG3Mb5j2rfo5+z9yak+krFZBdAKtGBri44gd+6KwTUPH
+        MUF2NkGEx3SK8F6hqzeNaTNSGchxZANn6oyf7SGIiPHxtJdZqLCPndvebpHCcp3q1h0KhQ0tBdE8MXQ+
+        s3ZaQARw0ywTIgIwnJzXr7ihFgKgcNCc7/Wde/VRp7bEAqsnbP9rambOHmnrPOFAIZ4EhEQkY2FgFYiB
+        /EQJicnbS4cu/4lTWyJl9QQVRAatCCKSgzI9zCqgNnMSyTEBgyjsbIKIqW6W7RMTRKJGr9NmbJMSoFvs
+        USQIZ7f7UGEfO7drM1IErw/GjOuDZyYvpgYqiBSdGjZBdI0YOv9YP/uKQ3l9JxNUukbITcM0kV/5hk6a
+        IupR1vhA3Yzd7zq1JXZ49bGSIUt+LEJlm7SZt2KzXYmf8UQIE7J+Y1TnpXbtuadq3DkvOLcnfFZP2KqC
+        KIhWBBHfBd8veYnazEnE50F2NkGEp7RYSHB1YNm+x2mzE4KIv912rQ8HiFeLgGCnfPL+BHIXRXPsoFuS
+        ynBhEXdMM7LUn5cmq5deBZGiUyOKgujqY8VNC34o9fKQI0EiiRJZBeaH4bfGDQWCiLv0KLqy96TzXnZu
+        S2yxfva+D3vVjkMoMp3CrvV+xxOZfEwYmkBG38yeVTfWTL7oNaf2hMs4E0SMLbEqvOW7TstYDBRZkTGA
+        /PQqiOxTEQgjBBJCybUOPhey8IDcNMQfGRCgzaamgXZ4MFQYcPpJf+m3AR4r7kUCvWNBEOFtYZFFkZBn
+        0WQheXUC3rTg4Y6wTJvhUSIYOzB1hpBy88J5BeLBYvQREORY4lqP5tgxBXhiKxP64iVdQ1ugDuqynINk
+        mIQvcG1a4dd1plDEJVoIor5zrznuD68+XjZi3S+TUrpcKPWSfJG9vHoKeYvwI26IeriZ/73MvEu3i8pH
+        rP+Vc1tikzVTdv6jW2E/ktKZqUTEC98HYsYPUcQDCpHFQ26kcFWP8uZP9pl26dtO7QmHVePjShAxJnhr
+        SCAYCMRtgzzsETFM42CkA1M5bZDkgjcLWelopiLwhpKlnBg6L3Xwds5qRESyAdOqxJ3RnoA3pA3SP/pJ
+        f63XEtcELxCs6PLSllBJ2wI7/Vv+1xoRfoiLWULEI9c9HovLhIGtPDyQ44jJu1XIFiABIeEj6QdjSf3s
+        n4aYjObYEVSOx+Uhod99gdTJNcQ9ywuqXcT4dZ0pFHEJmyC6Wgxd5Kwad+6fu3Qv3C91miBqP5MvYmB4
+        gNLuQCLCgv4zv1s/e/8Rp7bEMivHnv3HtG699kkfzOa2fucnwhtnxop4gQ296iZ+rX7WFR85tSdUVo3f
+        Ek+CCCCiMWwYOIQHRtn+kDeJ8jAKJP5jioltHhCvbmX4DOHEsYyF+Q75Hpi+JAeVlzoQVDOEeFMNGFdE
+        lUlESPvc6jAG3O4B8NqWUEkdZswYA7xkbfWTaTuunVqhMcy0lyX4TBm6tc3UwXFsixPYokeImMC7gTD1
+        YtBbo6mfbNbE+9EmpvRgNMfuEuECISvuOAdTioivSPpCWeqgLurcJGwQOt2rfl1nCkVcwndBVDN5xxvd
+        CgNJCNnXyO8g6pO8HjlVp3+mdsbu95zaEg8sHbbyZwlJKdulLxheP9MRAOow3jTevqcSu1TUtOC/+865
+        6phTe0JhHAoirh88cQgOvDBMTWFUreR/bLVCtmmMA55NrjeMolsZPpstxLNjj6dAxBM47KUO2kYbrW/v
+        fI/E3tEe2kX7Qq3DwEtbQiV1mDFj2oss9G31k0UFiCFrUK+X78daB8eZ5wvjjjea2DyyWCMsncp6oamf
+        FxWCvYnxo23RHju+X7w09IVxROTxwnST0KmsF1KWOqiLOtlk2n59Gvh5nSkUcYeWgmjOVccjYe30y97L
+        rmhmc8fVQqYNuPn8CqI+KS4mI6fs+t6TLvi7U1vihfWzrjiMh0v6QyzFBCGubLw6fgdZ86Dl4T4nKS1z
+        V9nw1b90ak8oxBMo9cWTIAI8vPG+YHSI08EzZyX/456wrv7zUobPOKY14xBpHbTDfI+0L9x2gLbaEiqp
+        w4wZzxQEeFv9NCLDDi9tM3VY+8lPnjUIFqboWcHpVNYLneo38NK+UEgd9uuNZx0B8DzrmI7ivnUq64WU
+        pQ7qok7qdoOf15lCEVfwTRDVz9x7qFfdRHZgxrBbM1H7FUTNTYq7nwfd3LRueXsrRp/5B6e2xBvrZuz5
+        ILf3aFYzISQRF34JSQMeggTU4vIfIlyYmpmzt3LMWS84tccr41QQKRQKhUJxEloIovrZVx4Ph3Uz9x0t
+        HDj3iYSkFNzV1MX0jF9TP5RHVPFGyZvOVKaYiocs+Un9rP3HnNoTj+x9xoVvdC2os0418kbH9+PHGxhj
+        SD28IbJ/HPUvzexVfaB6wvZXnNrjhZVjz1FBpFAoFIpTAr4IopKhK36RmJx2kdRBgB0uWuP+9SM42Bhy
+        XOEY3nX5DdO/XTdz72GntsQzq8ZvfbFLVoEJRsc1bXWjRwrqwONkYrDYXHdF99LGe2umXPyWU3vaogoi
+        hUKhUJwqiFgQlY/c8LvUrj1JWMbqCKZjioRMzzBN44d3CC8TwoCpsoU5VSMerJ2++wOntpwKLBux7tnU
+        zBzE5RlCvhsETFvz/l7BeJqVZ8QAIGRW51SPfKjP1EvedWqPG1UQKRQKheJUQUtBNGv/8VBYNfbcF9Oz
+        S6+Tsix9NSvK8Obg1fHLq4G4wjs0JiWjx3Yxwi84teVUYd2MvUfy6s8gaSPLexGBrHLCs+MXjMgkIJIA
+        bgK5N8o5H62bseewU5taowoihUKhUJwqaCGI6sTIeWXVhPNe7ZpfSx4KEguydQaixa9sywbUg8CijZNz
+        qkbcUzNl1ztO7TmVWDp8zS8SEpPWS58RmeRwam2ZbLhgKpM6WyzHLxgw62DdzH3HnNrkxAoVRAqFQqE4
+        RWATRFeIoWubNVN2vp1VHNi1nVwV5APye1WUgRFE7LEzObdmzP19pl36nlObQuc+eCwgAALce6x25t6j
+        tTP2wCNt8CjHUuZEeepyPE/oLBux7pnTEhLZ/430AtEQRMC+HH92QkLiBcXNy37+77FxbpuVFWPPVkGk
+        UCgUilMCLQXRTDF0bbBmyq53syuGfUaON0vEiUXxM2+OFdTHlBkro0andu25rWLUmb9xapeIEqabjtZO
+        v/xI7bTdH/WZetmH0tb3ep+x4+3qCee9UTnm7JfKR2z4Y+mw1c8VD1n6bOGgef9b0H/mT/L7TXsqr++U
+        g73qJn23Z5/x38jtPebLwkdyqkd+IadqxOdzKk//fOCnMLd61Jf4LLdm7Jd71U74Zq/6M/4rr+/UH+Y3
+        zHiqYMDsnxY1LnympHn5b0uHr/lD+chNf64cu+WV6okXvFkzeee/+ky99IM+0y47JO37CFFVNwMhdXI/
+        aqZc8m7P2glkiSVxHfk+8OL4OWVmhVmOT9wXydjmJ3fJuqx06Mr/c2qbnRVjVBApFAqF4tSAEUTsut6m
+        IOozbfchEQFfk2PZlJStIChLLAoeDL/FEKBO6u4lJN38zMyeVXtLh636afWE7a9WTzz/jcqx5/5NhM4L
+        JUNX/lpEzk9E3PxXbu/R/9m9ZNAnu+bV3JWRW3FLlx7FN6Z163VNSnr3/clpXfcmpaTvSUxO3Z2QlLIr
+        ITH5otMSErZK3eRPQuQxBUhMFBtyQmJ5oPmbz9jvh2M3JiQkbZM6diQmpV6SmJx2eVJqxp7kLt32pWRk
+        X5nWLf/a9OzSm6TNt3YrqL8nu2LoZxFdIsQOFg9e/POy09f+vmL05r9Wjd/+dxFOr4vAeEE+/5zUtVbq
+        RmSwGgwPmV9B1XYwvmYVH4IGj9Qiafd+EZ4vOF0DVgYFEbuV01bSBKggUigUCkVcgszPeHhI6b6jdua+
+        462xz/Tdh0VsfEeOYy8c9g7qIyQ3EILFj+X1rQGDTTtJKsi+aNNFgGwQwbELw52UlrlXhMilIm52BIXN
+        BiFTeYuEeFlIBcAGkqTbJ9U86f3ZJgMiBCcJEXcsQ2eVHOcgmJlpJDv5P+SYZiFlKEsd1GXq5Ryci3Oy
+        nQNtYCk9Yoq9rgJCSoTPThFnl6Vm5lyR1i1vj4ipLfIZq/UQGAQ8m/GNhtg0sIoi4sDYuXqpCLnrRfD8
+        1elaMAwKIvZdYtoUQRSNqT2FQqFQKKIOs4KLzNLbameIoXNgn+l7jhYMnPsjESIIDrPnll+717cFDDZT
+        RhhspnYIAsZoI8qY6qM9/ESUjBUS4M30DwKGFP4cT0JH9k1CxCE0DIlNQhAyBtSdL8QbxTSVGzmGYylD
+        WerAW2bq5TyQ80LGy2wngOgyQoql9aYP/M52JxxDTBbnweMSLe+QFWaMrTmKlhE0XzV+26tO1wSsHHvu
+        H+W4aMc6KRQKhUIRdWBwMeqsZlrXe/LOf9bO2CvG7mPWTLnkg4IBsw8mpnQ5X47B44HQyBf6tSu7Fxgv
+        BgIOoYC3CNFgRAg/ESXEGmGYCRTmOGKbIAHfGHtElZVMGVInfcGYIwo4jxcSM0UZyuLBoi57/ZyTc9MG
+        phZpE22zCikjovidaSs+pyx1+5HLySs4j8lRxNgiipZ2K+x7S8XozX+0XxewePCS78kxeL6iHeukUCgU
+        CkVUgQHDkOG9mJlTPfLO8pEbf1094fzXK8dteaWkefkvsiuHfTohMYk4EaaAyJ6M4EBEtKexBpyLc9Jm
+        hBwixAgPxAh/24UNgo1yTowWnM5FOyBtom20kTG09sG0H1HS3mNrwDmtoghP3IL0nLI9+Q0zvi3Xxh/k
+        2nijctzWl4qaFn0/vUcJW7WMCR5LH9rDm6VQKBQKhe/AgGGIif9gmmlmSkb2lozcyv3p2aX7EpPTzpX/
+        EUjMlBqiCTGE+MCwd4TBtsKIDcN4Raz1gzYYUYTHjXgp4qNWpHbteZFcG1fItXGJ/M2ea0z7MSVopk+j
+        1X6ut1B2GMeLSbu87vAd6wi1/9bdyHl58Fo23HGjfaHuNG9tI+VD7SPkOLzDeFV5LvFyF2p5ps0pxzUf
+        aj9CHa9Q+3iqXccKRUwDA4bHgqkdbjpWcjFVQnwOJLiXG5MbGKOHV4ObOhYMtyJ6MKKIh3CBkHgoYp/w
+        BpHZmp8IaIwR8VTRvC4QWlx/BKfvEN4gvKUN3iTcJzxLiGjDYMarMeF7IK6LhQFe+88xHMuYMR3udeys
+        48ZCC8adFya375XnB1O9iGY8hlcLbxY61W+ltY3E+cFQvmPIcbuELKKgvQuFoZbfKVwkRPgjPkLph3W8
+        uC+YCuc+cEJnv44ViriAMX68YSF6EEZMgXDzdmRMi6JjwffMw51pPLxFxI3hMcI48xOhxP/xQERLDDHN
+        yDXIyrx7hN8Qfl94sA0+LnxM+J9CDBvGhGs43sC4Mt4rhXcJvfafYziWMbsy+NNLWeu43SlkEQUvRYhe
+        J0NM+/h+8BbeJvyq8L+E1ONUv5XWNiIQYCjfMeS4R4Xk7aLsfwhDLc/xnxIiPNhDMJR+WMfrgJB4uiKh
+        faw6+3WsUMQVMGbcxAgjE9sSCzEtio4F37kRRibuyZC/jRCK1rXB9cfKO97UMVBORqMtYkx4w0boxxuY
+        ypkrxIh+V+jUPzcyZt8K/nT63I0EzBtDfIYQ8WsH/yO28A4hhtupnrZI28htBsP9jhEOPwj+dPq8LVKW
+        caIN4faDcogiPEV20dLZr2OFIi5hjJuVCgXoiGsDg4sg4M3/4IMPPvj74x7x5ptvvk8Z4beFlwtJuxBP
+        4CWEOJY9Qoz1wQMHDjwb7F6bYKwoY+h17Bi3Rx555AVLWbwZlwmJZ+HlyIDvn9WRFws55uBll132zAcf
+        fHA4WFWbsLcRhvIdg+eee+7N2bNnPx1u+WeeeebvAwcOfNLahlD6wXht3rz5Z8GyiBYyt+MNsiIer2Ne
+        duzxTvzkbxP3pVAoFIp2Ah4SgvqZEgnXkOBZ2S8kRiWegIcWzwx7Bj6O0Q92zTMshjpkofDyyy+/ExQK
+        eE/Yqofs7EyfGyCOiDdkiukHHBuKGDKwthGG2k6AKIqk/FNPPfWyKR9OPyzXGt6fa4UEYzNNZhBv1zHe
+        X+IDSSjLVKaJd+Inf/N/Puc4hUKhULQDOrMgIm4HEfI54UG8NsGueYbV0xOOUMB7EizPdBBjiIfAGHpW
+        YxHo/UlhSN4rK2zeqLDaCSIpjwAy5cPtR1DYMWWHgGVBCtPKBvF0HeOZJIaU7ZnoizXeycRc8X8+5zh7
+        vJRCoVAoogA/DEm8TpmRfPRM4cPCg3gxgl3zDKvnI1yh4WLoEWzs+xe2YAPWNsKOEETAlA+3H5w3WAfT
+        YmwZZI25iqfrGM8kcVC3C4kjC4yLjfyfzzmO4xUKhUIRZbgaEutUiQvjNRiV9pIQlfafJIjsnhVoN+Zu
+        gshp7JzEgIuhZ/qM1W+fF55UtrXvxt6PtgSRUz1O04fms0jLe+0HQiV4SACWceJa5Zrl2jWIp+uYtrLn
+        YqCt9vHgb/4f/JzjrP1UKBQKRZQQriE5FZYrt7sggsQOBQ8JwMXQqyCywGWcQDxdx67fq+W643OOs8aV
+        KRQKhSJK8GpIiG34spBpHWtCuy1CcsOw4a/J/mtWyvAgh2YVDTRZi5kW4id/839T1k5WXrHSymxnQ5Bp
+        OOWcVuy1lyBi7IhPCcSJ8P/gIQG4GHqvgqhF/XEsiBAn9IGf0RJE1B/qdUzuOLx2XEtcU1xb5rMcoUmN
+        wXVmP4bA6CIh07P8zv8QXQROB647+3hYrrsvCc8TmuS9obSHgHy/7hOFQqHoFPBqSFiWfp1wutA8SMk8
+        TMzLaiHZjO0rZchuDPmd/0GTtZitavjJ36acE28U7hYSYMq5WHUVajkMCkku7cuY20sQMXacI7C0n/8H
+        DwnAxdB7FUQt6o9jQUTcDH0IxNVESRAhHO8TspH2WiHXJyu62FS7teuYpJhMZW4Uck1xbZnP+D+7DyA8
+        yC7P9WY9hpQJlNskNHWTAJTvlLa4CaJvCu8Xmmvaa3u4L8l679d9olAoFJ0C4QgixBBbMLAxLZmWHxA6
+        rZR5KEjzmfk/WYsJGOWntZwTTUK/LwoxJCTeC7Xc9UJy1PCwt74B8+aOUeFNPCxB9Nhjj/3FfOYydrQV
+        A8jPaAiiFvXHsSD6jpAM1vx0E0TEWvF9eg6qtpyDa8bqIUIs7BWSbby165g6OSfXCdcU15b5jDIICgQW
+        3iauN+sxiBrKEbhPxm9TtxdyLGkGTBlzzrbaw9Qf96pf94lCofAIbhwrWTLMMlHIm4Yh+zEZ4s4Nhaac
+        tT5zDs4HrW1QeEc4hsRMM1wlRPC4PXCdyEMYLwA/nT5vjeGWY/UQD3vegJkWMMCgsqwdj4GnPjAewaEJ
+        gCXk5jOXscMoqSAKfuZVELVCBAKimKzUZKc28Hod28n3zvlgqNcxpAyih3aHm4HbT9Ie2gH9uk8UCkUQ
+        dqFjxA2xHOyxxY1DECKb12JgIFlWeUBB5rtZPszDHbJfF+QtBDJ3baf5DHKsKUs91GfqZr7cnJOcLbSD
+        /eJoE21DTBkBpaLJGeEYEhOIyptlYHqjNe8KGYnxogT/fVLWYv4OftQqCEK2JxcMoxxvwEwLcH0ZcF2w
+        xJrMx07eAevbeaAvwaoDwINhPoMuY6eCSGA+c+kHY30iFqoVsvXHhULiXrinDcK5jk9ia9cx/eF3a0C8
+        fVwh14j1GK59ylGeNgT/HQDHUsY+HuacMNL2+HSfKBSdBk6CByHhJHZ46CBIeFBzwxCDQeIwggUxLCQ0
+        YysE5tSZViGbLPPZkJ3bmdeGzcKhQbJTuJ3mM44zZSjfJKQu6qV+zsP5OC9TOOwYz1w+m3XSNtpIW2k3
+        Is2IJrtgMp6mziiWomJIKNdaNmLzULcbAjfw0DbnCrMc4o2pDQypFXgZuHaJvTCxTkylsPEq+X9OvPXb
+        p3CMQTN0GTsVRALzmUs/vDAsQeQGjjd0uo7t37sVVqHu1Gc3hCOIQmmPz/eJQnFKwSp8EAF4eDAGeFSM
+        4MHjghcGzwyCAmGB2EFsIDxMIC0ChfgRXKsEuk4VEpRIcCKGhdUaBPSRQ4MAQLIBE7zITtQELq4REtAI
+        eRux03zGcRxPOQwDdVAf9VL/AiHn47xMfRDfMllIMjNc6ogrRBTtpv30gxsdEWcEE/01nibGgfFgXBgf
+        u2fpVERYhoSHMscb2h/cbjAGMJQyIJxzgWA5pg8IIOVasIPvmWvArIbj+ub6Is4pIIjsxsWSYfoEXYRC
+        zAuitoy55VwdLYjCmjJzA8cbhnptWUWx1RPqBeEIorZgbU8U7hOFIu7gJHzwiBjhg6cEEYAYKBNiBPCs
+        9BViDBA8eGd44CAsjNhBeGAkECQIlPXCsxOTUy9M7pK1J7Vb3rXpOeU3Z+bV3t2tqP+D3cuGfC678vSH
+        c6rHfDW3z4RHe9ZN/m6vvlMfz+s344d5DbOezO8/56mCgfN+nD9g7o/l59MFA+f/lJ/8HaB8znF5DTOf
+        6NV32uO96qd8T+r5Vk7vMV/LrhrxSPey5s9nFQ/8VNf8unszcitvS8squCElI/vKpNSMSxMSElmqulmI
+        uEJE0W5EGqKJ/iDiEHMIJvrLzU//8RQwHowL44M3jPE6lYVS1AQRho6He2sG1F7G7nGxvwmb/4dbTojn
+        hxVybuD75P7gmiEo1XEPMQy+fMbUIQYksEzcRSjEtSDCexDsb6vlrfXDcAVR8F+OsIxTyEHVbuB4Q6fr
+        GCCAiRezf3duAsSIZrw2TvVGIojCaY/P94lCEXNoTfwwLcTDAoOOYS8XMpWEwcdTgghADIwV4lGZIcTL
+        slDIVgF4ZzaflpBwfmJSyiVp3fKv65pX9wlESG7vcV8XcfM9ETY/EhHz86KmZb8rbl7959Lh618uG3Hm
+        38tHnf1mxZitb1eOPe/9yvEXHqqasONw9cSLj1VP2nXcBx6T+o5USb2V4857X87zTvmoc/5ZNmLz66XD
+        N/ytZOjavxYPWfF8YePi/8tvmP10r7opP8itmfBoj/LhX+yaX39fl+5FNyalpF8mgokVIWSkRTDhvcL4
+        8YBlHBgPxsWIJcbLLpR4+DL9Rkp9xpyYKqbdzPcB4wVREUTWh3prBjTcB3aUH/RMpfJCwKojpg9OevO3
+        9I3PTyx3dxEKMS+IEH3BP0/AGjDuVt4rTHmXfngVRPZxAlERRGZszOf2785NgFja61rWPh7We8fP9vh8
+        nygUHQ5jbDG+GGEe3ngu7OKHaS48Hkb4kAgMQ4+nB08JomedCJ6tCYnJO5K7ZF2RnlNxe7figZ/Orhr1
+        tV71Uw8WDFzw86Lmlc+XDF//UunIza+Xjz737QoRIZUTLjpcNeniY8Lj8cDKiTuOVIw//4PyMVveoR8l
+        p2/4W/HQ1X8sGLTwmV59p/8op/fYr2cVD/p0em7l7cnp3fczHoxLYHz+7Q1jvOxCiRgmpt+YeiPhGoaL
+        KRc8SQjSePIiqSD6GNxXiN4NQgTGSTvgU3fQIOEZIsboVmFg2X5r/RTGvCDi/3iCgv8KwGlaEHq9Rqyw
+        bu7aEYLIeg43ul3H0P7duQkQS3tdy9rHw3pOP9vj432iUHQYMKYYViOA8P4wjcPDkjgYPBcEFXMBE9eD
+        +GFaCI8PBn1dQmLStqTUzEtSM3te3SW79LZuRQM+m1sz/rH8/nN+VjR4+R9E9LxcNursf5aP3fauiIcP
+        RfQccRIXpxqDYumQ9Ps9+i/j8DfGg3FhfGScPtOle/Etgam4lPRdCQmJZLNFKPHgRVyaRIEEfBPgzdQj
+        cVfkt0Gg4kVCIBG8bTxIsYaoG5LW6gz3gR3FBz33Ft8pIieQNM9ucCxGDvFBrpdLhG2NXVwIInv9iBir
+        N6K18l5gbYNLPzpCELVYTWgfu0gEiKW9rmXt42E9p5/t8fE+USg6BBhQhBBGFQ8EhpapL6ZxCPwkzucM
+        4Wwh4me9iJ/tKenZe9O6F93UtaDvp3Kqx34nr9+snxY2Lft96YjNr1cwlTXugkOVTD1NFGGgdCTjwzhV
+        jN3+XsnwDa8WNi7+ba/6af+TXTnyG5m9au5Lyyq8LjmtG1lgSexHnBIB3gR1Y1BN+n+m2kqFPKz5DvEa
+        xZooCseQeF52D1ur016GvylnaI/bMfWFW07o9qDnuyHgfruQfEsnLbO3rMTBgJIkklg6dss/JQSRU9yP
+        07SZvXxbwNNkFVYu/WhBu8F2GSfg9TpG+FgTM94m/KQwMO1pHzvayv8N7d9dPAki/qa8YZj3iULRIcBw
+        4llgGoZpGbxAeICYuiHAmQfl5tTMnrszcqtuySoe9NnsqtHfyus346fFzav+VD7qnLcqxp2Ht+do1cSd
+        YuSVEXPCjmOV4y88IiLp/bKRm98obFry2551k3/Yo2L4l/8do1R8XVJqxkXyvTDlgkBFII0UMn2JmMUD
+        EWuiKBxDQmJGvCOIAkcjbH9wO9Fepi1EWI72s6SehQNOYNqZoPt7hI5bR1iMzSNCchfxUsL08ykhiKCX
+        aTO38l7o0o8WjJIgQvhYt6DhBQYv31eEbV7H1BP8KIB4EkRtIViurftEoWh3GM8QUy7EBPHgJY5lbVpW
+        wd5uRf3vy64a9fW8hllPFw1Z+ULpiDNfrxx3/iFHI65sDx4rH73lXyXD1r1UMHDB/+X2mfC97qVNn0vP
+        qbjhtIQExBEPX+K5EEUEYjN9FisIx5CwKo9Veoi/tvYB4wHbIsGhYSgPbKtxCbMcYmGHkClmOxCpTHle
+        JgyICruR4pz8X4hnDEHIvlXEG3kZuxaCxW7ELG3scEFkP4c19sfQrbwD+d5NJmfHvbss5fE8cnxg1V6U
+        BBFjhGcXTzsg7MDzfnbUE/wogFNFEFnayvi0dp8oFB0CDCbB0tysrHhZkFU65M6CQUt+Xjx03V/LRm99
+        t3LCzmPC48rYZMXY8w+VnL7p1YJBi3+W2asPK5YQEkx18uDG8xcrXqJoGxLrBpV4XwhAdpxmsz7M3Rhm
+        OfaSYoNNvK1W8D0gPBgDx2X2/G5Zds447BfyfSIK8RR9Qeg2dojJE6vR7EbMYozCFUQt6rePD38HjwvQ
+        pZ2eps1cyiNmrNNREG/D5ULEdOBacekH5U9kqm4nDxEhB+xl9nWh23UcIPUEPwogngRRhPeJQtFhwDvE
+        DY4Bnd29rPnustFb3qqcsEOMrTLeWNi49BfJXbqxzJ8AbIQE+Yw6iyBCAJEXCvHganw8PrDDLdfam69Z
+        Zs++bI6CwmaE8BAhUMhkTYJA9kGj7raEwglDbzdiLobeqyBqUb+9/fwdPC5Al3YGaG9fCOXtYgOaRJcY
+        2bb60R4eIuq3ijZXkR6JALG017WsfTys5/SzPRHeJwpFh4Fl2yyhH5aYnLaxsGnpM06GVhkfLBt1zpvp
+        uZUYXOIVWKrPtFlnEUQYQYw6xt21jP2BbTeI5v9hlsMQ2mMj+A5ok+sye/n/ibptpM4T04EuY9eC9jgd
+        F0PvVRC1oH18+Nv6eVvttJ/HPm0WwjViEFY/oiSIXOlyHQdIPcGPAnATIJb2upa1j4f1nH62J4L7RKHo
+        UPDWyoN6ZHJat61FQ1Y952RolfHB0pFn/SM9RwWRsCMFEbSvnmHlH7ml8PQ4LrNvLTmhE70YYaftHSyG
+        kwzMLJgwGZg7RBAxZRj86ASs4xDCNWKggsilrH08rOf0sz0R3CcKRYfCeIiGnpaQsCav38wnKsdfdFwZ
+        nyxsXPqrpLSu58r3yYozRAGGWAVRmA9sHx/03GPklWKH74MY/WARz7AaKPvYeUVwQ06miZjGQTRzfQC2
+        EGEVGwkgTzKcXsF4Ud7Qi1iwG1qEnPkshGvEwJd+WASGXTgC1+u4LVAGulzHAYYiQOwr9Forax8P6zn9
+        bE8E94lC0aEghoi8Qyy1n56eW7m/uHn1807GVhnbLBt59j+yigcRb0KiTFYykbCxMwVVWwURgZrk7SFw
+        86QybYEyEZRz2rSSjO67hI8KT5rK8gKrgQrVCAOL0SQ2iWBtpipIxApYZUoqAPLkhCXYgN2IunzHJ0iZ
+        4McBWKfNQrhGDHzph4twBB0uiOxj1hbaWxC1hWA53dxVEXNglRk3e5GQ3drnpGUV7u7Vb+aTpSPPebtC
+        DK0ytlk+9vzDBY1Lf901vy9Zj9krjS0/EBGsHozHZfd+CCI8BewdF7KnwJIUMdxyBPzuFpJ80YDtV64Q
+        Bna0t78xe4HVQIVqhGmbZRuQzwgZG8bJAOFMID7JAx03mfWCoJAItBG6fMe0g+DiwLmCH5+AMbZhCKKI
+        +8F3I2U5BzFb1wrZPscIR9Dhgoh+hXINRVsQ2et1Qxv3iULRocB7QG4UEvlheMhhM024XgzsPfkDFvyq
+        fPS2QxXjLjyujDkeK25e+1KPihFfTkrNuEC+M/ZCQwyxpQdvynj/YsU7BJh2YGNbpiHcjB15ZFgtRj8A
+        Yp0s3YF9vFwe3BioJUIMFrFTE4S3CwOrevCQBIu0Ch7WdqMeRjmmxZgeY5rMgEziLAn/trDdBBHnsRk2
+        hAQ5kHgrRzwYcJ1gmC4Wckwge3YoYoI2Uc5Kl+8YY0jSycBqO7uxNdNmIVwjBif1Ay+R134wXpbvEQFO
+        qgMywFvheh23BcrASAQIJCjfy7UJoi2IoE/3iULR4eAhgvHEo1AgZPqMpcuLEhKTt2eVND1UNHjlnyrG
+        XnDMwSgrO4ClI85+K7dm4vfSuhUw9cG2DmQVZy6ehzdiKJamygxIAcAWMAQW8/Z94mFqIdMUCBurB8Nk
+        dmbZeWCVlQMRPYgfRJBJSElQ+WYhuXvwSDiVa40nPBiW/3khgud6IfePdZqFlw3SIQS8XB1A+sK5rxaS
+        ksAaE2PA/0jKeocw4MkKg3yvXwvS7TvGc8d0CT8DS99DoNM1YgX9YP8/po8DAexhkP4fEHI98bJohZfr
+        OFzSN665UMekBdsSLyGwrfb4fZ8oFDEBjCeeIm523rDJWo23CEO7IjWz597s6jHfKhm+6Q0nA61sH5aN
+        2vJ+XsOcn6XnVjI9xhJuHvx4hXgrzhciamPNM2TAtAOCDQFHThbe4I3A4SfxNRg63u7ZxJYVkIDrEg8L
+        b+sPCO3l+JtYD942EUFmmpDyXMN4z0iEaC3nRB7qeCx4c2WrEAxeqOV4yOM94MXC+h1gVNkMGUGCMMHg
+        hmL0TD8fCrKtNkHq5zycD3GwVYgBYjrRaSqVceb7YSsYppzwwmDwvbTTtI/vldwysK3vmOldfvI3/7ce
+        Rzniv9zKW68RK+gHzy/2/UPcee2HdbwQQ3hci4T2sXK7jtuiW9/4G68TdTqNCX0wf7vSoyAy52SqGYba
+        Hj5/UMi14td9olDEDLgwudnxLvAAx8BiaEkmh+Fdl9a96Ia8frP+X9nIc96rGHeBGGlle7B8zLbDhU3L
+        X+ha2PCphMTkbfJdLBRi3EioSQAxb8UYBx7esfyAYVUjidjYJBijSR4SVprwk6BjjBiGDi+XtR8IdUQR
+        K37s5fibQHICl6nfCrxFjBHGl5gTU86JeCyIaUBYEUhLLEqo5fhOeMhjlK3ge8GbgSjCU7RPyLYcTvU5
+        0fST8YHWMWiN1M95OB8vNox7W2kYENMY+ylCrjMEHMLQqX4rTfv4XvEww7a+Y7xm/ORv/m89jnIkWHQr
+        b79GrOAZhiiaKvTaD+t44RlCDNm/R4PWruO2aPpGwL+9b/zNfR14CRVax4S2t5qYM4TpLTwzxJAhFM05
+        ORexd6G0x3yOaOSa9us+UShiDjxkeIBz0/PQYY7XTKMtSEhM2prZq899BQMX/a581NYPK8aK0VZGh2PO
+        J07obz3Kh38lKSWDBw4PpjOEeD544OPNQyzwYIllIWQFbc0WYlBY6cRUHz8RNIgGhJ1TXyjHikh7Of6m
+        vtYerhhHxokAXFPOicTV8ALA9Y4bn+s/nHKtfQ/cUyZWjyBryjnV50TTT8YHWsegNVI/5+F8nNfu6WgN
+        jCP3PdcXYpKgYqf6rbR/D16+Y16++Mnf/N96HOUQ+m7l27reQ+1HqOPl1Me26NY3/uZ6w8trH5PThYio
+        wCKBUOOWLIIIT896IV5lc07OBUNpj/mc+5Fr3s/7RKGISXDBctNjcLnw2WCSh8ok4bKExOQLelSM+ErR
+        kNUvlovhLhcDrvSPJcM3vZlbO+Vgard84oRWCwl2bxYao2CmxzAs+nBRKE5dICDwWjI1/DiByUGt4wmW
+        FYZMtSOGeK4rFIoQgaGFGF7c7Rhi3gTYMwh39KqUjJw9OTUTv1c8fNM/nAy7MjSWjdr6YV7DnJ9n9Kxm
+        bp7VVQQUDxcyZcTbVZYQ7wVvsCqEFIpTH7z0kFuM1A3fEXpe6m7J/M3mx5cI8dLoc0OhiADcQGYaDYOM
+        Ye4j5G2D+KINGPBe/Wb9rHTk2e+Xjz1fjLsyJI7ZfqSgcekfskqaPp+QlLJdxpR5+TFCe5wQb3f6QFMo
+        OhdItMoz4X5hIJVECGS13d1CYu2Y3lIoFD7ACCMMMwaawMO+QuKLFsrHWzPz6h4sGLTkD+Wjtx8pH4Oh
+        V7bF4qHrX+tePvyrSWldTdBovMcJKRQKf8H9z3Q5q0uZOmtrVRc0q8FYNUngNHmbdLpMofAZGGZuLBNf
+        hOEmcA5Dvjw5vcelPcpP/2pR89pXykefd9RJBCjPP14yfPPbubWTn0jrXnyNjJuJE2JVH25tEydEULDG
+        CSkUCjz0iCI8PTuEbqu6oFkNxrQ7YohniUKhiAIw0NAkdTQrEQj8xbCvTs3sua9n7ZQflpy++e3yMeeJ
+        CFDCspHnHsofsODZjNxqkgkSJ8TyXVaSsMqF6UhWx2ickEKhsIMXUa+r28xqMLdVmAqFwkdgsO3xRQQA
+        EwgcyF+Unlt9c6+Guf9bMuKs98oQBJ2UpaO3HiloXPZCt+LGhxKSUth6wBonxHJfjRNSKBQKhSLOgQHH
+        kJv4IgKBiS8aKSSh3uZuxU2fQRCUjdp2tGy0iIROxKLmda9lV435liVOiIRn1jghltaqEFIoFAqF4hSB
+        EUYYeFy1ZL4lKdd44dJAfFHl6G8WDVn7qpNwONVYPPzMd3L7TH6iS4/S66T/a4QaJ6RQKBQKRScBhh0D
+        T3wRwoglo8xlk78oEF/UpXvJtbm1U35UcvpZ75WN3i7i4dRi6cgth/P6z/u/zPz6e6W/GiekUCgUCkUn
+        hhFGGH7S4Zv4IoQBAmFjem7V7XkN835VOuKcD52ERdxx1NajBY3L/tSteNBDicld2FiUOKGxQo0TUigU
+        CoWikwPDb40vQhggEBAKi5JSMy5EQBQ2rXixdNSWI45CIw5YNHT969nVY7+TkpFzufTLGifEkleNE1Io
+        FAqFQhEQAUYYIQwQCAgFBAPCYWVyWrdLs6vHfbeoef0bZaNEZMQJS4ad+a+edTN+nJZVdK30gzih6UIT
+        J5QvxDumcUIKhUKhUChOAEGAMEAgIBQQDAgHtgGZIVzbpUfp9bl1039cLEKjVARHrLJkxLmHejXM/01m
+        XiBOaJOQhGkjhBonpFAoFAqFwhMQCCZ/EcKBbUAQEggKhMWmzIKGB/L6z/+NCI/DpaO2iQiJHeYPWvqX
+        rLKh/5mQmMy+Y4uF44RswGjihHS7DYVCoVAoFJ6BYEA4ICBMfBHCAoGxOCk1c0dWyZCHCxqXvyhC5Jhd
+        mLQ3i5rX/aNH1ZjvpmT23CftY38gpvuahE5xQiqGFAqFQqFQeIYRD9b4okohQmOKcFVq1/z92b0nfL9o
+        2Ma3nIRKtFk8fPP7uXXTfpqeU8EeQeuFZOFmmk/jhBQKhUKhUPgKhERr8UUIkA1depQd6Fk/42cIFCfh
+        4jdLTj/7w7z+83+X0avPfQkJiVukDQuF7O5PFm6m+ZjuY/WcxgkpFAqFQqHwFcZbZJbpIzxYpo8QWZiQ
+        lLItM7/hU3n9F/6ueOimd0tHinjxmSXDz/ogf9CyP2WVND+clJK+U867TDhJyKaJbLfBLv8aJ6RQKBQK
+        hSLqMMII4YEAQYggSBAmSwlozsyrv79n3fSfFjateqVk+OYPSkduFUETHktOP/tQ4ZC1r/fqN/dX3Yqb
+        Pi9C6CI5D/mEpgrJsl0tNNttkIWb9qkYUigUCoVCEXUY0YEAQYggSBAmxBdNFDKFtTEls+ferJIhD+XU
+        THo8r/+C3xQ0rvhr0ZB1rxcPO/PdktPP+ah0xLlHS0duOVo6YstR+fswU25FzevfLGha+VL+gEW/y62d
+        8t/dy4Y9nNa9mFxCZwpZOUbANEKIabsCIbv56zJ6hUKhUCgUHQYEiFmmjzBBGLE/GhvHslSf4Ov5QlZ+
+        sXfYOcJtwvOFFwp3CJn6gnh+2FaDJfMcRw6h1ULEFXutMTWHJwrhhRDSfEIKhUKhUChiClZhROA1K9JY
+        qo8Xh+X6g4XslYaoYek+XqQzhHh7DPmb/7MD/xghggpPEOKKetihv5eQ+jmPxgkpFAqFQqGISSBQWJHG
+        VBoxRogX4ozwHBGEjUgi5ojl+3iSIB4f8zv/53PED8ezog1xhfeJpf/Uqx4hhUKhUCgUcQMjjvDkIGTw
+        6rBCDWEDMx1oPkNMcTxL/Slv8gipEFIoFAqFQqFQKBQKhUKhUCgUCoVC4Qmnnfb/AUyPCB8GtHwrAAAA
+        AElFTkSuQmCC
+</value>
+  </data>
+  <metadata name="tmrUpdate.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>17, 17</value>
+  </metadata>
+  <data name="$this.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        AAABAAEAlZ4AAAEAIABYfAEAFgAAACgAAACVAAAAPAEAAAEAIAAAAAAA2G8BABILAAASCwAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAQAAAAFAAAABwAAAAgAAAAKAAAACgAAAAsAAAALAAAACwAA
+        AAsAAAALAAAACgAAAAoAAAAJAAAABwAAAAYAAAAEAAAAAgAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAACAAAABQAAAAkAAAANAAAAEgAAABYAAAAaAAAAHAAAAB8AAAAhAAAAIgAAACIAAAAjAAAAIgAA
+        ACIAAAAhAAAAHwAAAB0AAAAaAAAAFwAAABMAAAAOAAAACgAAAAUAAAADAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAABwAA
+        AA0AAAATAAAAHAAAACUAAAAsAAAAMwAAADkAAAA9AAAAQAAAAEMAAABFAAAARgAAAEYAAABGAAAARQAA
+        AEMAAABBAAAAPgAAADoAAAA0AAAALgAAACUAAAAdAAAAFQAAAA0AAAAHAAAABAAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAABwAAAA4AAAAWAAAAIgAA
+        AC4AAAA6AAAARwAAAFIAAABcAAAAZAAAAGoAAABuAAAAcQAAAHMAAAB1AAAAdgAAAHYAAAB0AAAAcgAA
+        AG8AAABqAAAAZQAAAF4AAABUAAAASQAAAD0AAAAwAAAAIwAAABgAAAAPAAAABwAAAAMAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAABQAAAAwAAAAWAAAAIwAAADIAAABDAAAAVAAA
+        AGQUCwV/NBwOpUQlEr5TLRbWWzEY4mE0GutmNxv0ajkc+ms6Hf1sOx39bDod/Wo5HPtnOBv2YjUa7lwy
+        GORVLhfYRycTxDceD6obDweHAAAAZgAAAFYAAABGAAAANAAAACUAAAAYAAAADgAAAAcAAAADAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAkAAAASAAAAHwAAADAAAABEAAAAWAQCAW8pFgubSigUyl0y
+        GednOBz3bTsd/207Hf9tOx3/bTsd/207Hf9tOx3/bTsd/207Hf9tOx3/bTsd/207Hf9tOx3/bTsd/207
+        Hf9tOx3/aTkc+WA0GetQKxXSMhsNpgkFA3QAAABbAAAASAAAADQAAAAjAAAAFgAAAAwAAAAFAAAAAQAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABAAAAAgAAAAQAAAAGgAAACsAAAA9AAAAVAUDAW4sFwufVC0W2GU2G/RuOx3/bjsd/247
+        Hf9uOx3/bjsd/247Hf9uOx3/bjsd/247Hf9uOx3/bjsd/247Hf9uOx3/bjsd/247Hf9uOx3/bjsd/247
+        Hf9uOx3/bjsd/247Hf9oOBz3WTAX3zUcDqoJBQN2AAAAWQAAAEQAAAAwAAAAHwAAABIAAAAJAAAABAAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAA
+        AAYAAAANAAAAFwAAACUAAAA3AAAATAAAAGMeEAiNSykUzGc4G/ZuPB3/bjwd/248Hf9uPB3/bjwd/248
+        Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248
+        Hf9uPB3/bjwd/248Hf9uPB3/aTkc+FItFtgmFQqaAgEBbAAAAFQAAAA9AAAAKgAAABoAAAAPAAAACAAA
+        AAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAQAAAAKAAAAEwAA
+        ACEAAAAyAAAARwAAAF0XDAaCQiQRvGQ3GvBuPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248
+        Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248
+        Hf9uPB3/bjwd/248Hf9uPB3/bjwd/2c4G/ZJKBPKIBIJjwAAAGIAAABMAAAANwAAACUAAAAXAAAADQAA
+        AAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAJAAAAEAAAABwAAAAsAAAAQAAA
+        AFYLBgN1NBwOqloxGONuPB3+bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248
+        Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248
+        Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9hNRrtPiIQuRQLBYAAAABcAAAARgAAADIAAAAgAAAAEwAA
+        AAoAAAAEAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAHAAAADwAAABoAAAAoAAAAOgAAAE8AAABlLBgLnFIt
+        FtZrOhz7bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248
+        Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248
+        Hf9uPB3/bjwd/248Hf9uPB3/bjwd/248Hf9uPB3/WDAX4TYeDqwEAgFvAAAAVgAAAEAAAAAsAAAAHAAA
+        ABAAAAAJAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAQAAAAIAAAAGAAAADQAAABcAAAAlAAAANwAAAEsAAABgHRAIiUooE8dmNxvzbzwd/288
+        Hf9vPB3/bzwd/288Hf9vPB3/bzwd/288Hf9vPB3/bzwd/288Hf9vPB3/bzwd/288Hf9vPB3/bzwd/288
+        Hf9vPB3/bzwd/288Hf9vPB3/bzwd/288Hf9vPB3/bzwd/288Hf9vPB3/bzwd/288Hf9vPB3/bzwd/288
+        Hf9vPB3/bzwd/288Hf9vPB3/bzwd/288Hf9vPB3/azoc+VIsFdYpFguZAAAAZQAAAE8AAAA6AAAAKAAA
+        ABkAAAAPAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAEAAAAEAAAACgAAABMAAAAgAAAAMQAAAEYAAABcDQcEekAjEbliNRrsbzwe/288Hv9vPB7/bzwe/288
+        Hv9vPB7/bzwe/288Hv9vPB7/bzwe/288Hv9vPB7/bzwe/288Hv9vPB7/bzwe/288Hv9vPB7/bzwe/288
+        Hv9vPB7/bzwe/288Hv9vPB7/bzwe/288Hv9vPB7/bzwe/288Hv9vPB7/bzwe/288Hv9vPB7/bzwe/288
+        Hv9vPB7/bzwe/288Hv9vPB7/bzwe/288Hv9vPB7/bzwe/2Y3HPNLKBTHGg4HhwAAAF8AAABKAAAANgAA
+        ACUAAAAXAAAADQAAAAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAACAAA
+        ABAAAAAcAAAAKwAAAD8AAABVCgYDczAbDaVbMhnjbDwd/G89Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289
+        Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289
+        Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289
+        Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9iNhrrPyMRtxIKBX0AAABbAAAARgAA
+        ADEAAAAgAAAAEwAAAAoAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABwAAAA0AAAAZAAAAJwAA
+        ADkAAABOAAAAZCITCZJRLBbSajod+G89Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289
+        Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289
+        Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289
+        Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9tPB79WTEY3zAbDaUIBAJyAAAAVQAA
+        AD8AAAArAAAAHAAAABAAAAAIAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABQAAAAoAAAAUAAAAIgAAADQAAABJAAAAXhwP
+        CIdHJxPCaDkc9W89Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289
+        Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289
+        Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289
+        Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bz0e/289Hv9vPR7/bDsd+1EtFtMpFwuZAAAAZAAA
+        AE4AAAA5AAAAKAAAABkAAAAPAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAoAAAARAAAAHQAAAC4AAABBAAAAWBAJBHo9IRCzYDQa6HA9
+        Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9
+        Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9
+        Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9
+        Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/2Y4G/JGJhPBHRAIiAAA
+        AF8AAABJAAAANgAAACUAAAAWAAAADAAAAAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABAAAAAgAAAAQAAAAGwAAACoAAAA7AAAAUQAAAGcyGw2iWTEY3W48Hv1wPR7/cD0e/3A9
+        Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9
+        Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9
+        Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9
+        Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9wPR7/cD0e/3A9Hv9hNRrpPiIRtQwH
+        A3gAAABbAAAARgAAADEAAAAfAAAAEwAAAAoAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAA
+        AAcAAAAOAAAAGQAAACcAAAA4AAAATAAAAGEjEwmOUCwVzmg6HPVwPh7/cD4e/3A+Hv9wPh7/cD4e/3A+
+        Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+
+        Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+
+        Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+
+        Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9wPh7/cD4e/3A+Hv9tPR38WTEY3TEb
+        DaUFAwFwAAAAVQAAAD4AAAArAAAAHAAAABAAAAAIAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAUAAAAMAAAAFgAA
+        ACQAAAA1AAAASQAAAF4UCwaARycUwGc5HPFwPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+
+        H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+
+        H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+
+        H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+
+        H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//cD4f/3A+H/9wPh//azse+VMu
+        F9QjEwqSAAAAZAAAAE4AAAA5AAAAKAAAABkAAAAPAAAABwAAAAMAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAJAAAAEgAAAB8AAAAwAAAARQAA
+        AFoQCQR6OR8Qr2A1GudwPR/9cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+
+        H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+
+        H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+
+        H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+
+        H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/2c4
+        HPFGJxPBGw8HhgAAAF4AAABJAAAANgAAACUAAAAWAAAADAAAAAYAAAACAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAMAAAAIAAAAEAAAABoAAAAqAAAAPQAAAFQBAABtKBYLnVcw
+        GNtvPR/8cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+
+        H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+
+        H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+
+        H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+
+        H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+H/9xPh//cT4f/3E+
+        H/9iNhvpOB8PrwwHA3gAAABbAAAARQAAADEAAAAfAAAAEwAAAAkAAAAEAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAQAAAAMAAAAHAAAADgAAABkAAAAmAAAANwAAAEwAAABjIxQKkU0rFcxpOx32cT8f/3E/
+        H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/
+        H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/
+        H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/
+        H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/
+        H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/H/9xPx//cT8f/3E/
+        H/9vPh/8WDEY2zIcDqYFAwFvAAAAVQAAAD4AAAArAAAAGwAAABAAAAAIAAAABAAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAEAAAAFAAAACwAAABYAAAAjAAAANAAAAEgAAABdEgoFfkMlErtlOBvtcj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//bTwe+E8sFs0jFAqRAAAAZAAAAE0AAAA4AAAAJwAAABkAAAAOAAAABwAAAAMAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAACQAA
+        ABIAAAAeAAAALwAAAEQAAABZBAIBcjogEK5eNBrjcT4f/nI/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/H/9yPx//cj8f/3I/
+        H/9yPx//cj8f/2U4HO5HJxO/Fw0GggAAAF4AAABJAAAANQAAACQAAAAWAAAADAAAAAUAAAACAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAABwAAAA8AAAAZAAAAKQAA
+        AD0AAABTAwIBbSYVC5pVLxjYbTwf+HI/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/
+        IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/
+        IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/
+        IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/
+        IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/
+        IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/IP9yPyD/cj8g/3I/
+        IP9yPyD/cj8g/3E+IP5gNRvmOB8QrgoFA3YAAABbAAAARQAAADEAAAAfAAAAEwAAAAkAAAAEAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABgAAAA0AAAAXAAAAJQAAADYAAABMAAAAYRoP
+        B4pNKxbLajse9XJAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JA
+        IP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JA
+        IP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JA
+        IP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JA
+        IP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JA
+        IP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JAIP9yQCD/ckAg/3JA
+        IP9yQCD/ckAg/3JAIP9uPh/7WjIZ3SwZDJ8EAgFuAAAAVAAAAD0AAAArAAAAGwAAABAAAAAIAAAAAwAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAkAAAATAAAAHwAAADEAAABGAAAAWxQLBn8+IxG1ZTgc7HNA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/bDwe9k8sFswhEwmQAAAAYwAAAEwAAAA3AAAAJQAAABcAAAAMAAAABQAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAQAAAAUAAAAMAAAAGAAAACkAAAA9AAAAVQQCAW8yHA6lXDMa33I/IP5zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/2k6HfBDJRO7GA0HggAAAF0AAABGAAAAMAAAAB0AAAAPAAAABgAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAAEAAAADQAAABwAAAAxAAAASQAAAGIqFwyXUy4X0m49H/lzQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NA
+        IP9zQCD/c0Ag/3NAIP9zQCD/c0Ag/3NAIP5gNRvkOiAQrQoGA3IAAABSAAAANwAAACAAAAAPAAAABQAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAA
+        AAoAAAAaAAAAMgAAAE8ZDgd8TCsVw2o7HfF0QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RB
+        IP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RB
+        IP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RB
+        IP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RB
+        IP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RB
+        IP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RB
+        IP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP90QSD/dEEg/3RB
+        IP90QSD/dEEg/3RBIP90QSD/dEEg/3RBIP9xPx/7WDEY1SoXDJAAAABVAAAANwAAABwAAAAMAAAAAwAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAEgAA
+        ACkAAABKIRMJgl41G9x0QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/aTse7TAbDpQAAABPAAAALAAAABQAAAAGAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAZAAAANgEB
+        AF9MKxbBdEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/dEEh/3RB
+        If90QSH/dEEh/3RBIf90QSH/dEEh/3RBIf90QSH/WDEZ0gwHA2sAAAA7AAAAHAAAAAoAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABwAAAA7DQcEbV00
+        Gtp1QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf9oOx3tIRIJhAAAAEMAAAAhAAAACwAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAGQAAADcHBAJkWDIZ0HVC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/2o8Hu4hEwmEAAAAQwAAACEAAAALAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAATAAAAKwAAAE41Hg+WbD0e8HVC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VCIf91QiH/dUIh/3VC
+        If91QiH/dUIh/3VCIf91QiH/WDEZzw0IBGgAAAA6AAAAHAAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAwAAAAcAAAANgAAAFM0HQ6UVzAYzWE2
+        G+JtPR70dkIh/nZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZC
+        If92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZC
+        If92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZC
+        If92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZC
+        If92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZC
+        If92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZC
+        If92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZCIf92QiH/dkIh/3ZC
+        If9xPyD5ZTkc6FYwGMwmFQuDAAAASgAAACsAAAATAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAA8AAAAfAAAANAAAAEsAAABgGA4Hfy0a
+        DZo8IhGxTSwWyFw0Gt1mOh3rcUAh+XZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL+bD0f82E3HORTLxjTQiYTuzId
+        D6QgEgmKAQEAYwAAAEoAAAAxAAAAGgAAAAsAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAAAA4AAAAbAAAAKQAAADgAAABGAAAAUQAA
+        AFwAAABnFAsGfCITCo8wGw6jPSIRtUsrFspdNRvfajwf8HBAIPh0QiH9dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZDIv92QyL/dkMi/3ZD
+        Iv92QyL/dkMi/3VCIv5zQSH8bz8g9mc7HuxXMhnXRigUwDggEK0pFwyaGw8IiAoGA3QAAABjAAAAWAAA
+        AEoAAAA7AAAAKgAAABoAAAANAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAoAAAASAAAAGgAAACMAAAArAAAANAAA
+        ADwAAABFAAAATgAAAFgAAABiAwIBbxEJBX8aDweMKhgMnz8jErdNKxbKWTIZ2Wc6HetwPyD2ckAh+XVC
+        Ifx3QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dD
+        Iv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dD
+        Iv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dD
+        Iv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dD
+        Iv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3dDIv93QyL/d0Mi/3VCIfxyQCH5bz8g9WM4
+        HOhWMRnXSSkVxjshEbIlFQuaGQ4HiA0HBHYAAABkAAAAWwAAAFMAAABKAAAAQwAAADkAAAAwAAAAJwAA
+        AB0AAAATAAAACgAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAgAAAAUAAAAIAAAADQAAABEAAAAWAAAAHAAA
+        ACIAAAApAAAAMAAAADgAAABAAAAASAAAAE8AAABYAAAAYQMCAW4LBgN5FAsGhR0RCJEuGg2jQSUTuE8t
+        F8xaMxrbYjgc5Wk8Hu9uPx/0cUEg+HRCIfx3RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dE
+        Iv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dE
+        Iv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dE
+        Iv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dE
+        Iv93RCL/d0Qi/3dEIv91QyH8cUEg+W4/H/VpPB7vYjgc5lozGttPLRfMQSUTuC4aDaIbDwiPEQoFgwkF
+        A3gCAQFsAAAAYQAAAFYAAABMAAAAQwAAADoAAAAzAAAALAAAACYAAAAgAAAAGgAAABQAAAAPAAAACgAA
+        AAYAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAUAAAAIAAAADAAA
+        ABAAAAAUAAAAGQAAAB8AAAAkAAAAKgAAADEAAAA3AAAAQAAAAEYAAABMAAAAUgAAAFkAAABhAQEAbQQC
+        AXUOCASBIBIJki8bDaE8IhGwSCkVv1MvGM1cNRrcYjgc5Gc7HetrPR/xcEAg9nRCIft3RCL+d0Qi/3dE
+        Iv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dE
+        Iv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dE
+        Iv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/d0Qi/3dEIv93RCL/dUMh/HFBIPdsPh/yZzsd62M5
+        HOZeNhveVDAY0EoqFcI/JBKxMBsOoSETCZIPCQSCBAIBdQEBAG0AAABhAAAAWAAAAFIAAABLAAAARgAA
+        AD8AAAA3AAAALwAAACgAAAAhAAAAGwAAABYAAAASAAAADgAAAAoAAAAHAAAABAAAAAIAAAABAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAgAA
+        AAQAAAAHAAAACgAAAA0AAAAQAAAAFAAAABkAAAAfAAAAIwAAACcAAAArAAAAMQAAADcAAAA/AAAARgAA
+        AEsAAABPAAAAVAAAAFkAAABgAAAAZwEBAHEFAwJ5Fw0HiCgWDJg1Hg+mQCQTsUYoFLtLKxbCUi8YzVky
+        GtheNRvgYjgd5WY6HuppPB/ubT4g8XA/IfZzQSH5dUIi+3dDI/54RCP/eEQj/3hEI/94RCP/eEQj/3hE
+        I/94RCP/eEQj/3hEI/94RCP/eEQj/3hEI/94RCP/eEQj/3hEI/94RCP/eEQj/3hEI/51QiL8c0Ei+XBA
+        IfZtPiDyajwf72c6HutjOB3mYDYc4ls0G9xWMRnTTiwXyEcoFb1CJRO0OB8QqCkXDJoaDwiLCQUDewIB
+        AXEAAABoAAAAYQAAAFoAAABVAAAAUAAAAEsAAABGAAAAPwAAADcAAAAxAAAAKwAAACcAAAAiAAAAHgAA
+        ABkAAAATAAAADwAAAAsAAAAHAAAABQAAAAMAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAAAQAAAAIAAAAEAAAABwAAAAoAAAAMAAAADgAAABEAAAAVAAAAGQAAAB4AAAAiAAAAJgAA
+        ACoAAAAtAAAAMQAAADYAAAA8AAAAQgAAAEgAAABMAAAAUQAAAFUAAABYAAAAXQAAAGIAAABpBgQCcw4I
+        BH4WDQaHHxIJjicWC5YtGg2dNB4PpDkhEao+IxKvQiYTtEYoFLlIKhW+SysWwE0sFsNPLRfFUS8Yx1Au
+        F8dRLxjIUi8YylEvGMhQLhfHUC4Xx08tF8VNLBbDTCwWwUkqFb5HKRW7QiYTtT4kErA6IhGrNR4Ppi8b
+        Dp8oFwyZIRMKkRgOB4oRCgWDCgYDegIBAXAAAABnAAAAYQAAAFsAAABVAAAAUgAAAE0AAABIAAAAQwAA
+        AD0AAAA3AAAAMQAAAC4AAAAqAAAAJwAAACIAAAAeAAAAGQAAABQAAAARAAAADgAAAAwAAAAJAAAABwAA
+        AAQAAAACAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAgAAAAQAAAAHAAAACQAAAAwAAAAOAAAAEAAA
+        ABIAAAAVAAAAGAAAABwAAAAgAAAAJAAAACgAAAArAAAALgAAADEAAAA0AAAAOAAAAD0AAABDAAAASAAA
+        AEwAAABPAAAAUQAAAFIAAABVAAAAVwAAAFgAAABaAAAAWwAAAF0AAABeAAAAXwAAAGAAAABgAAAAYQAA
+        AGEAAABhAAAAYQAAAGEAAABgAAAAYAAAAF8AAABeAAAAXQAAAFwAAABbAAAAWAAAAFcAAABVAAAAUwAA
+        AFEAAABPAAAATQAAAEoAAABGAAAAQgAAADwAAAA3AAAAMgAAAC4AAAArAAAAKAAAACUAAAAhAAAAHAAA
+        ABkAAAAVAAAAEgAAABAAAAAOAAAADAAAAAkAAAAHAAAABAAAAAIAAAABAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAACAAAAAwAA
+        AAQAAAAGAAAACAAAAAoAAAANAAAADgAAABAAAAATAAAAFAAAABYAAAAZAAAAHAAAACEAAAAkAAAAJwAA
+        ACkAAAArAAAALAAAAC4AAAAvAAAAMQAAADEAAAAzAAAANAAAADQAAAA1AAAANgAAADYAAAA3AAAANwAA
+        ADcAAAA3AAAANwAAADYAAAA2AAAANQAAADQAAAA0AAAAMwAAADIAAAAxAAAALwAAAC4AAAAsAAAAKwAA
+        ACkAAAAoAAAAJgAAACMAAAAgAAAAHAAAABkAAAAWAAAAEwAAABEAAAAPAAAADQAAAAoAAAAIAAAABgAA
+        AAQAAAADAAAAAgAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAABAAAAAgAAAAMAAAAEAAAABQAAAAcAAAAIAAAACgAAAA0AAAAOAAAAEAAA
+        ABAAAAARAAAAEwAAABMAAAAUAAAAFQAAABYAAAAWAAAAFwAAABcAAAAYAAAAGAAAABkAAAAZAAAAGQAA
+        ABkAAAAZAAAAGAAAABgAAAAYAAAAFwAAABYAAAAWAAAAFQAAABQAAAATAAAAEwAAABIAAAAQAAAAEAAA
+        AA8AAAANAAAADAAAAAoAAAAIAAAABgAAAAQAAAAEAAAAAgAAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAEAAAABAAAAAgAA
+        AAMAAAADAAAABAAAAAQAAAAEAAAABQAAAAUAAAAFAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA
+        AAYAAAAGAAAABgAAAAYAAAAGAAAABQAAAAUAAAAEAAAABAAAAAQAAAADAAAAAwAAAAIAAAACAAAAAQAA
+        AAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAQAAAAEAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAQAAAAEAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAABgAAAAoAAAALAAAACwAAAAkAAAAGAAAAAwAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAEAAAABwAAAAoAAAAKAAAACgAAAAcAAAAEAAAAAQAA
+        AAEAAAAAAAAAAAAAAAAAAAABAAAABgAAAAwAAAAUAAAAHAAAACEAAAAiAAAAHQAAABYAAAANAAAABwAA
+        AAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAAEAAAACQAAABAAAAAXAAAAHgAAACAAAAAeAAAAGAAAABAAAAAIAAAABAAA
+        AAEAAAAAAAAAAQAAAAUAAAAOAAAAHAAAACwAAAA6AAAAQwAAAEMAAAA9AAAAMAAAACIAAAAUAAAACgAA
+        AAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABgAAAA0AAAAYAAAAJgAAADQAAAA+AAAAQgAAAD4AAAAzAAAAJAAAABUAAAAKAAAABAAA
+        AAEAAAADAAAACwAAABwAAAAzAAAATBEKBWwhEwqCHREJgAcEAmsAAABWAAAAQQAAACsAAAAZAAAADAAA
+        AAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAYAAAAQAAAAHgAAADEAAABHAAAAWxQMBnQhEwqBHREJeQAAAFgAAABAAAAAKAAAABQAAAAHAAAAAQAA
+        AAUAAAATAAAAKwAAAEw7IxKUZDsf1XFCI+tsQCHnWjUczzchEaEDAgFpAAAASwAAADAAAAAZAAAACgAA
+        AAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAA
+        AAUAAAAIAAAACwAAAA0AAAANAAAADAAAAAsAAAAJAAAABwAAAAUAAAAEAAAAAgAAAAEAAAABAAAAAQAA
+        AAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAEAAAABAAAAAQAA
+        AAIAAAACAAAABAAAAAUAAAAHAAAACgAAAAsAAAANAAAADQAAAAsAAAAJAAAABgAAAAMAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAGAAAAEAAA
+        ACEAAAA4AAAAUx4SCX5LLBe2ZDsf23FCI+xtQCHkVTIavBwQCW4AAAA+AAAAIQAAAA0AAAADAAAACAAA
+        ABoAAAA3AAAAYXZGJO9/Syf/f0sn/39LJ/9/Syf/eUcl904uGL8IBQJxAAAATAAAAC4AAAAXAAAACQAA
+        AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAKAAAAEwAA
+        ABsAAAAhAAAAJAAAACUAAAAkAAAAIgAAAB4AAAAZAAAAFgAAABMAAAAQAAAAEAAAAA8AAAAOAAAADQAA
+        AA0AAAANAAAADQAAAAwAAAAKAAAACQAAAAcAAAAFAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAA
+        AAQAAAAEAAAABAAAAAYAAAAHAAAACQAAAAsAAAAMAAAADQAAAA0AAAANAAAADQAAAA4AAAAPAAAAEAAA
+        ABEAAAATAAAAFgAAABoAAAAfAAAAIgAAACUAAAAlAAAAIgAAAB0AAAAWAAAADQAAAAcAAAADAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAAABAAAAAhAAAAOgAA
+        AFgqGQ2PZz0g3n9LJ/9/Syf/f0sn/39LJ/9/Syf/VzMbuwAAAFIAAAAtAAAAEwAAAAUAAAAKAAAAHwAA
+        AEEAAABugEsn/4BLJ/+ASyf/gEsn/4BLJ/+ASyf/fkom/VAvGMIEAgFtAAAASQAAACoAAAAUAAAABwAA
+        AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAFAAAADQAAABoAAAApAAAAOAAA
+        AEMAAABIAAAASQAAAEgAAABEAAAAPwAAADkAAAAzAAAALgAAACsAAAApAAAAKAAAACcAAAAmAAAAJQAA
+        ACUAAAAlAAAAIwAAACIAAAAfAAAAGgAAABcAAAAVAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAA
+        ABMAAAAVAAAAFwAAABoAAAAfAAAAIgAAACQAAAAlAAAAJQAAACYAAAAmAAAAKAAAACgAAAAqAAAAKwAA
+        AC8AAAA0AAAAOgAAAEAAAABFAAAASAAAAEkAAABFAAAAPAAAAC8AAAAhAAAAEwAAAAgAAAADAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAUAAAAOAAAAIAAAADoAAABZJxcMkG5B
+        IuiASyf/gEsn/4BLJ/+ASyf/gEsn/4BLJ/9rPyHeAAAAXwAAADYAAAAZAAAABwAAAAsAAAAiAAAARgAA
+        AHWATCf/gEwn/4BMJ/+ATCf/gEwn/4BMJ/+ATCf/fEom+0cqFrcAAABlAAAAQwAAACYAAAASAAAABwAA
+        AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAsAAAAbAAAAMQAAAEoEAgFjEQoFeBcN
+        B4ILBwN/BwQCegUDAXUBAQBtAAAAYwAAAFsAAABVAAAAUQAAAE8AAABNAAAATAAAAEsAAABKAAAASQAA
+        AEkAAABHAAAARAAAAEAAAAA6AAAANAAAADEAAAAvAAAALgAAAC4AAAAuAAAALgAAAC4AAAAvAAAALwAA
+        ADEAAAA1AAAAOgAAAEAAAABEAAAARwAAAEkAAABJAAAASgAAAEsAAABMAAAATgAAAE8AAABSAAAAVwAA
+        AF0AAABkAwEBbgYDAnYJBQN7EgsGgRYNB34KBgNsAAAAUwAAAD0AAAAlAAAAEgAAAAcAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAADQAAAB8AAAA4AAAAWB0RCYlpPiDigEwn/4BM
+        J/+ATCf/gEwn/4BMJ/+ATCf/gEwn/2k+IOAAAABnAAAAOwAAABwAAAAHAAAADAAAACQAAABHAAAAd4FM
+        KP+BTCj/gUwo/4FMKP+BTCj/gUwo/4FMKP+BTCj/fEkm+UUpFbAAAABhAAAAQAAAACQAAAARAAAABwAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAHAAAAFQAAACwAAABMIhQLf103HcpvQiPocUMj7Gs/
+        IeZjOh/dXDYc1VEwGclHKha6PSQTrDAcD54lFgyVIBMKjxsQCIsVDQeGDwkFggwHBH8JBQN+BgQCfAUD
+        AXgEAgF0AQEAbQAAAGQAAABeAAAAWQAAAFcAAABWAAAAVgAAAFUAAABVAAAAVgAAAFYAAABXAAAAWgAA
+        AF4AAABkAwEBbgQCAXUGAwJ5BwQCfQoGA34NCASAEQoFgxcNB4cdEQmMIhQLkCkYDZc2IBGjQSYUskwt
+        GL9WMxvNYDke2Wc9IOJvQSLqckMj62k+IN1BJhSkBgMCYAAAAD0AAAAgAAAADQAAAAMAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAA0AAAAdAAAANgAAAFUXDQeCZjwg3YFMKP+BTCj/gUwo/4FM
+        KP+BTCj/gUwo/4FMKP+BTCj/aT4g4AAAAGkAAAA9AAAAHAAAAAgAAAAMAAAAJAAAAEgAAAB3gUwo/4FM
+        KP+BTCj/gUwo/4FMKP+BTCj/gUwo/4FMKP+BTCj/eEcl9DcgEaIAAABeAAAAPQAAACIAAAAQAAAABgAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAoAAAAeAAAAPRQMBm5mPCDWgUwo/4FMKP+BTCj/gUwo/4FM
+        KP+ATCj/f0so/X1KJ/x8SSf6e0gm+HhHJfV1RSTxcEIj7Gk+IeRjOh/eXjcd2lg0G9RRMBnOTC0YyUkr
+        F8VHKha/RCgVuUEmFLI+JBOtPiQTqzsjEqc6IhKmOSESpjoiEqY6IhKmPCMTqT4kE6s/JROtQicVs0Up
+        FbpIKhbASywXxU4uGMpUMRrQWjUc1184HdtlOx/gbD8h53JDI+52RiXzekgm93tJJvl9Sif6fksn/IBL
+        KP6BTCj/gUwo/4FMKP+BTCj/gUwo/3lHJfRCJxSjAAAAUQAAAC0AAAATAAAABQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAMAAAAKAAAAGgAAADMAAABSDggEe1w2HdOBTCj/gUwo/4FMKP+BTCj/gUwo/4FM
+        KP+BTCj/gUwo/4FMKP9pPiDgAAAAagAAAD0AAAAdAAAACAAAAAwAAAAkAAAASAAAAHeBTSj/gU0o/4FN
+        KP+BTSj/gU0o/4FNKP+BTSj/gU0o/4FNKP+BTSj/dkcl8S4bDpgAAABbAAAAOwAAACEAAAAPAAAABQAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAADQAAACMAAABGPiUTm3pJJvWBTSj/gU0o/4FNKP+BTSj/gU0o/4FN
+        KP+BTSj/gU0o/4FNKP+BTSj/gU0o/4FNKP+BTSj/gU0o/4FNKP+BTSj/gU0o/4BNKP+ATSj+gEwo/oBM
+        KP5/TCj+f0wn/X5LJ/1+Syf8fksn/H5LJ/x+Syf8fksn/H5LJ/x+Syf8fksn/H5LJ/1/TCf9f0wo/oBM
+        KP6ATCj+gE0o/oFNKP+BTSj/gU0o/4FNKP+BTSj/gU0o/4FNKP+BTSj/gU0o/4FNKP+BTSj/gU0o/4FN
+        KP+BTSj/gU0o/4FNKP+BTSj/gU0o/2E6HtACAQBfAAAANgAAABkAAAAHAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAACAAAACAAAABYAAAAuAAAATgIBAXJZNRvNgE0o/4FNKP+BTSj/gU0o/4FNKP+BTSj/gU0o/4FN
+        KP+BTSj/gU0o/2k/IOAAAABqAAAAPQAAAB0AAAAIAAAADAAAACQAAABIAAAAd4JNKP+CTSj/gk0o/4JN
+        KP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/cEIi6CcXDJAAAABZAAAAOQAAAB8AAAAOAAAABAAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAANAAAAJAAAAEY6IhKXeEcl8oJNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JN
+        KP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JN
+        KP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JN
+        KP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JN
+        KP+CTSj/gk0o/4JNKP+CTSj/XzgdzwMCAWIAAAA3AAAAGQAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAA
+        AAcAAAATAAAAKQAAAEgEAgFuTS4Yv4BMKP6CTSj/gk0o/4JNKP+CTSj/gk0o/4JNKP+CTSj/gk0o/4JN
+        KP+CTSj/aj8g4AAAAGoAAAA9AAAAHQAAAAgAAAAMAAAAJAAAAEgAAAB3gk0p/4JNKf+CTSn/gk0p/4JN
+        Kf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/az8i4x0RCYgAAABXAAAANwAAAB0AAAANAAAABAAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAQAAAAoAAAAfAAAAPhAKBW9qPyHdgk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JN
+        Kf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JN
+        Kf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JN
+        Kf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JN
+        Kf+CTSn/gk0p/39LKPxFKRatAAAAVQAAAC8AAAAUAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAHAAAAEQAA
+        ACUAAABCAAAAZEUpFrR+Syj7gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JNKf+CTSn/gk0p/4JN
+        Kf9qPyHgAAAAagAAAD0AAAAdAAAACAAAAAwAAAAkAAAASAAAAHeDTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/Yzsf2BQMBn8AAABTAAAANAAAABoAAAAKAAAAAwAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABwAAABYAAAAvAAAAVDoiEp18Sif3g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/YToe1BILBnQAAABFAAAAJAAAAA4AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAAABAAAAAiAAAAPQAA
+        AF47IxKleUgm9INOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/2o/
+        IeAAAABqAAAAPQAAAB0AAAAIAAAADAAAACQAAABIAAAAd4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/WzYczwcEAnQAAABPAAAALgAAABYAAAAIAAAAAgAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAEAAAADQAAAB8AAAA9AAAAYUosF7Z/TCj7g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/21B
+        IuMYDgiCAAAAUgAAADAAAAAWAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAUAAAAOAAAAIAAAADoAAABbMR0PmXdH
+        JfCDTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/aj8h4AAA
+        AGoAAAA9AAAAHQAAAAgAAAAMAAAAJAAAAEgAAAB3g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+ATCj9UC8ZwQUDAW4AAABIAAAAKQAAABMAAAAHAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAAGAAAAEgAAACgAAABIBQMBb1c0G8mCTSn+g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf9zRSTsKBgMkgAA
+        AFgAAAA3AAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAADQAAAB4AAAA3AAAAWCMVC41vQiPng04p/4NO
+        Kf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf+DTin/g04p/4NOKf9qPyHgAAAAagAA
+        AD0AAAAdAAAACAAAAAwAAAAkAAAASAAAAHeETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RP
+        Kv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv9/TCn5QygVsQAAAGQAAABBAAAAJAAAABAAAAAGAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAIAAAAIAAAAFwAAAC8AAABQFg0Hf2Y9INuETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RP
+        Kv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RP
+        Kv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RP
+        Kv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/fkso9z0kE6YAAABeAAAAPQAA
+        ACEAAAAPAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAoAAAAbAAAANAAAAFQSCwZ/aD4h3YRPKv+ETyr/hE8q/4RP
+        Kv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/2tAIuAAAABqAAAAPQAA
+        AB0AAAAIAAAADAAAACQAAABIAAAAd4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RP
+        Kv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv97Sif1NSARnwAAAF4AAAA8AAAAIQAAAA8AAAAFAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAMAAAALAAAAHAAAADYAAABXHhIKiXJEJOqETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RP
+        Kv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RP
+        Kv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RP
+        Kv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4FNKftMLRi5AAAAZAAAAEIAAAAlAAAAEAAA
+        AAYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAIAAAAIAAAAFgAAAC4AAABPCwcDeF44HtGETyr/hE8q/4RPKv+ETyr/hE8q/4RP
+        Kv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/hE8q/4RPKv+ETyr/a0Ai4AAAAGoAAAA9AAAAHQAA
+        AAgAAAAMAAAAJAAAAEgAAAB3hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQ
+        Kv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv91RiXsKhkNkgAAAFgAAAA3AAAAHQAAAAwAAAAEAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAQAAAAOAAAAIAAAADsAAABdOSISonxLJ/WFUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQ
+        Kv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQ
+        Kv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQ
+        Kv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/XDcdzAUDAW8AAABJAAAAKgAAABMAAAAHAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABwAAABMAAAApAAAASAQCAW5TMhrEhE8q/oVQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQ
+        Kv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv9sQSLgAAAAagAAAD0AAAAdAAAACAAA
+        AAwAAAAkAAAASAAAAHeFUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQ
+        Kv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv9rQCLgGQ8IggAAAFIAAAAxAAAAGQAAAAkAAAACAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAUAAAAQAAAAJAAAAEEAAABkTC0YuYJOKfyFUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQ
+        Kv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQ
+        Kv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQ
+        Kv+FUCr/hVAq/4VQKv+FUCr/hVAq/2k/Id4VDQeAAAAAUgAAADAAAAAYAAAACQAAAAIAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAYAAAAQAAAAJAAAAEAAAABjQygVsIFNKfqFUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQ
+        Kv+FUCr/hVAq/4VQKv+FUCr/hVAq/4VQKv+FUCr/hVAq/2xBIuAAAABqAAAAPQAAAB0AAAAIAAAADAAA
+        ACQAAABIAAAAd4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQ
+        Kv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4VQKv9hOh7RCAUDcwAAAEoAAAArAAAAFAAAAAcAAAACAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAcAAAATAAAAKgAAAEkNCAR0Yjof0oZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQ
+        Kv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQ
+        Kv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQ
+        Kv+GUCr/hlAq/4ZQKv92RyXtKxkNlAAAAFkAAAA3AAAAHAAAAAwAAAADAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAADgAA
+        ACAAAAA7AAAAXTUfEJ56SSbxhlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQ
+        Kv+GUCr/hlAq/4ZQKv+GUCr/hlAq/4ZQKv+GUCr/bUEi4AAAAGoAAAA9AAAAHQAAAAgAAAAMAAAAJAAA
+        AEgAAAB3hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZR
+        K/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4VRK/5TMhvAAAAAZgAAAEMAAAAlAAAAEQAAAAYAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAA
+        AAkAAAAYAAAAMQAAAFMaEAiDcEQk5YZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZR
+        K/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZR
+        K/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZR
+        K/+GUSv/gE4p+EAnFa0AAABhAAAAPwAAACIAAAAOAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAsAAAAcAAAANgAA
+        AFciFAuLdEYl6YZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZR
+        K/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/9tQiPgAAAAagAAAD0AAAAdAAAACAAAAAwAAAAkAAAASAAA
+        AHeGUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZR
+        K/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4FOKflGKhatAAAAXwAAAD0AAAAiAAAADwAAAAUAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABAAA
+        AAwAAAAdAAAAOQAAAFsxHhCcfEso9IZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZR
+        K/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZR
+        K/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4VR
+        K/5XNBzHBAIBbgAAAEcAAAAoAAAAEgAAAAYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAIAAAAFwAAADAAAABRFAwGfmpA
+        It2GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZRK/+GUSv/hlEr/4ZR
+        K/+GUSv/hlEr/4ZRK/+GUSv/hlEr/21CI+AAAABqAAAAPQAAAB0AAAAIAAAADAAAACQAAABIAAAAd4dR
+        K/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dR
+        K/+HUSv/h1Er/4dRK/+HUSv/h1Er/3pJJ/AuHA+WAAAAWQAAADcAAAAdAAAADAAAAAQAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAA
+        AA8AAAAjAAAAQAAAAGRPMBm7hVAq/YdRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dR
+        K/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dR
+        K/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/b0Ij4hIL
+        Bn4AAABRAAAALwAAABYAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAAABMAAAApAAAASQQCAW9aNh3Jh1Er/4dR
+        K/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dRK/+HUSv/h1Er/4dR
+        K/+HUSv/h1Er/4dRK/+HUSv/bkIj4AAAAGoAAAA9AAAAHQAAAAgAAAAMAAAAJAAAAEgAAAB3h1Ir/4dS
+        K/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dS
+        K/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/3BEJOMgEwqHAAAAUgAAADEAAAAYAAAACQAAAAIAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAA
+        ABMAAAAqAAAASgoGA3RkPSDVh1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dS
+        K/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dS
+        K/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/3pKJ/AuHA+YAAAAWgAA
+        ADcAAAAcAAAACwAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAUAAAAPAAAAIwAAAEAAAABkSSwXtYJPKfqHUiv/h1Ir/4dS
+        K/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dSK/+HUiv/h1Ir/4dS
+        K/+HUiv/h1Ir/4dSK/9uQyPgAAAAagAAAD0AAAAdAAAACAAAAAwAAAAkAAAASAAAAHeIUiz/iFIs/4hS
+        LP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/iFIs/4hSLP+IUiz/iFIs/2U9IdQJBQNyAAAASQAAACoAAAATAAAABwAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAACQAA
+        ABgAAAAyAAAAVSMVC4x2RybriFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+GUSv9SCsXtAAAAGMAAABAAAAAIgAA
+        AA4AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAAEAAAADAAAAB0AAAA5AAAAWzUgEZ5+TCn0iFIs/4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/iFIs/25DJOAAAABqAAAAPQAAAB0AAAAIAAAADAAAACQAAABIAAAAd4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/iFIs/4hSLP+IUiz/hlEr/VExGrwAAABkAAAAQQAAACQAAAAQAAAABQAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAADAAA
+        AB8AAAA8AAAAYD0lFKmCTir5iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/2Y+IdcLBgN1AAAASQAAACkAAAATAAAABgAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAgAAAAkAAAAYAAAAMQAAAFMeEgqHdEYl54hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hSLP+IUiz/iFIs/4hS
+        LP+IUiz/bkMk4AAAAGoAAAA9AAAAHQAAAAgAAAAMAAAAJAAAAEgAAAB3iFMs/4hTLP+IUyz/iFMs/4hT
+        LP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hT
+        LP+IUyz/iFMs/4hTLP+IUyz/f04p9TskE6MAAABcAAAAOgAAAB4AAAANAAAABAAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAFAAAAEQAA
+        ACgAAABHAwIBbl05HsyIUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hT
+        LP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hT
+        LP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP95SifuKhoOkgAAAFUAAAAyAAAAGAAAAAkAAAACAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAAHAAAAEwAAACoAAABJDAcEdGQ9INSIUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hT
+        LP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hTLP+IUyz/iFMs/4hT
+        LP9uQyTgAAAAagAAAD0AAAAdAAAACAAAAAwAAAAkAAAASAAAAHeJUyz/iVMs/4lTLP+JUyz/iVMs/4lT
+        LP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lT
+        LP+JUyz/iVMs/4lTLP+JUyz/dkgm6SYXDIsAAABUAAAAMQAAABkAAAAJAAAAAgAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAIAAAAFgAA
+        ADAAAABSHhIJhnRGJeeJUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lT
+        LP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lT
+        LP+JUyz/iVMs/4lTLP+JUyz/h1Ir/UksF7MAAABhAAAAPQAAAB8AAAANAAAABAAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAA
+        AA8AAAAjAAAAQQAAAGRSMRq9h1Ir/olTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lT
+        LP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/4lTLP+JUyz/iVMs/29D
+        JOAAAABqAAAAPQAAAB0AAAAIAAAADAAAACQAAABIAAAAd4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lU
+        Lf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lU
+        Lf+JVC3/iVQt/4lULf+JVC3/aUAi1xAKBXcAAABKAAAAKgAAABMAAAAGAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAALAAAAHQAA
+        ADkAAABcPiYUpYNQK/iJVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lU
+        Lf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lU
+        Lf+JVC3/iVQt/4lULf9pQSPZEAoFeAAAAEkAAAApAAAAEgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAMAAAAHQAA
+        ADkAAABbOyQTooBOKvWJVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lU
+        Lf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/iVQt/4lULf+JVC3/b0Ql4AAA
+        AGoAAAA9AAAAHQAAAAgAAAAMAAAAJAAAAEgAAAB3ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pU
+        Lf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pU
+        Lf+KVC3/ilQt/4pULf+IUyz+UjIbvAAAAGQAAABAAAAAIwAAAA8AAAAFAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAUAAAAQAAAAJQAA
+        AEMAAABoYzwgzopULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pU
+        Lf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pU
+        Lf+KVC3/f00p8zIeEJgAAABXAAAAMwAAABgAAAAJAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAACQAAABgAAAAxAAAAUhsQ
+        CYR3SCfoilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pU
+        Lf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf9wRCXgAAAAagAA
+        AD0AAAAdAAAACAAAAAwAAAAkAAAASAAAAHeKVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pU
+        Lf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pU
+        Lf+KVC3/ilQt/4pULf+ATir0OCISoAAAAFsAAAA5AAAAHQAAAAwAAAADAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAVAAAALgAA
+        AFAjFQuIeEkn6opULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pU
+        Lf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4lT
+        Lf5YNh3DAAAAZAAAAEAAAAAhAAAADQAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAYAAAASAAAAKQAAAEkMBwR0ZD0g0YpU
+        Lf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pU
+        Lf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/4pULf+KVC3/ilQt/3FFJeAAAABqAAAAPgAA
+        AB0AAAAJAAAADAAAACQAAABIAAAAd4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tV
+        Lf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tV
+        Lf+LVS3/i1Ut/4tVLf92SCbmGxAJgwAAAFIAAAAwAAAAFwAAAAgAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAoAAAAcAAAAOgAA
+        AGBJLRixiVQs/ItVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tV
+        Lf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/eEkn6R0S
+        CoQAAABOAAAAKwAAABMAAAAGAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAADQAAACAAAAA+AAAAYk0vGbaJVCz9i1Ut/4tV
+        Lf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tV
+        Lf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/dEcl4wAAAGoAAAA+AAAAHQAA
+        AAkAAAAMAAAAJAAAAEgAAAB3i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tV
+        Lf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tV
+        Lf+LVS3/i1Ut/4tVLf9hOx/NCQUDcQAAAEgAAAAoAAAAEgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABAAAABAAAAAoAAAASg4J
+        BXhuQyTei1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tV
+        Lf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4hTLPtKLRiyAAAAXgAA
+        ADkAAAAcAAAACgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAkAAAAZAAAANAAAAFcwHRCXgE4p8otVLf+LVS3/i1Ut/4tV
+        Lf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tV
+        Lf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf+LVS3/i1Ut/4tVLf90RybjAAAAawAAAD4AAAAeAAAACQAA
+        AAwAAAAkAAAASAAAAHeLVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tV
+        Lv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tV
+        Lv+LVS7/i1Uu/4ZSLPpHKxewAAAAYQAAAD0AAAAfAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAACAAAABkAAAA2AAAAWzoj
+        E6OEUSz4i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tV
+        Lv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/cUUl4Q8JBXgAAABJAAAAKAAA
+        ABAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAAGAAAAEwAAACsAAABLFw4IfG5DJNyLVS7/i1Uu/4tVLv+LVS7/i1Uu/4tV
+        Lv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tV
+        Lv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/4tVLv+LVS7/i1Uu/3RHJuMAAABrAAAAPgAAAB4AAAAJAAAADAAA
+        ACQAAABIAAAAd4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xW
+        Lv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xW
+        Lv+MVi7/jFYu/39OKvAlFwyNAAAAVQAAADEAAAAXAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADwAAACUAAABHBgQCcl46
+        H86MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xW
+        Lv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4ZSLPk8JRSmAAAAXAAAADcAAAAZAAAACAAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABAAAAA0AAAAhAAAAPwAAAGRYNh3Bi1Yu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xW
+        Lv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xW
+        Lv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/dUgm4wAAAGsAAAA+AAAAHgAAAAkAAAAMAAAAJAAA
+        AEgAAAB3jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xW
+        Lv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xW
+        Lv+MVi7/jFYu/2c/ItUMBwR0AAAASQAAACgAAAARAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAHAAAAGAAAADMAAABYKRkOlX5O
+        KfGMVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xW
+        Lv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/Zj4h1AsHBHUAAABIAAAAJQAAAA8AAAAEAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAIAAAAJAAAAGQAAADQAAABYNiESm4RRK/aMVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xW
+        Lv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xW
+        Lv+MVi7/jFYu/4xWLv+MVi7/jFYu/4xWLv91SCbjAAAAawAAAD4AAAAeAAAACQAAAAwAAAAkAAAASAAA
+        AHeNVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41W
+        Lv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41W
+        Lv+NVi7/iVQt+0suGbIAAABhAAAAPAAAAB8AAAAMAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAANAAAAIgAAAEMBAQBrVDMbwY1W
+        Lv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41W
+        Lv+NVi7/jVYu/41WLv+NVi7/jVYu/4RRK/YwHRCcAAAAWgAAADQAAAAYAAAABwAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABgAA
+        ABMAAAAqAAAASxMLBnl0RybhjVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41W
+        Lv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41WLv+NVi7/jVYu/41W
+        Lv+NVi7/jVYu/41WLv+NVi7/jVYu/3ZIJuMAAABrAAAAPgAAAB4AAAAJAAAADAAAACQAAABIAAAAd41X
+        L/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41X
+        L/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41X
+        L/+NVy//e0wp7CUXDIwAAABUAAAAMQAAABYAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAVAAAALgAAAFIbEQmGd0ko541X
+        L/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41X
+        L/+NVy//jVcv/41XL/+NVy//XzsgzQUDAnAAAABGAAAAJQAAAA4AAAADAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAANAAAAIAAA
+        AD4AAABjVjUdvoxXL/6NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41X
+        L/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41X
+        L/+NVy//jVcv/41XL/+NVy//dkkn4wAAAGsAAAA+AAAAHgAAAAkAAAAMAAAAJAAAAEgAAAB3jVcv/41X
+        L/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41X
+        L/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41X
+        L/+NVy//ZT4i0QoGA3IAAABHAAAAJwAAABAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAsAAAAdAAAAPAAAAGFLLhm0ilUu/I1X
+        L/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41X
+        L/+NVy//jVcv/35NKvArGg6WAAAAWAAAADMAAAAXAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAACAAAABgAAAAyAAAAVjMg
+        EZeBUCvyjVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41X
+        L/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41XL/+NVy//jVcv/41X
+        L/+NVy//jVcv/41XL/92SSfjAAAAawAAAD4AAAAeAAAACQAAAAwAAAAkAAAASAAAAHeOVy//jlcv/45X
+        L/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45X
+        L/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45X
+        L/+JVC36QykWqwAAAF4AAAA6AAAAHQAAAAoAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABQAAABEAAAApAAAASxELBnpyRibfjlcv/45X
+        L/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45X
+        L/+OVy//VzYdxAEBAGsAAABDAAAAIgAAAA0AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAUAAAARAAAAKAAAAEkMCAR1cEUl3I5X
+        L/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45X
+        L/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45XL/+OVy//jlcv/45X
+        L/+OVy//jlcv/3dJJ+MAAABrAAAAPgAAAB4AAAAJAAAADAAAACQAAABIAAAAd45YL/+OWC//jlgv/45Y
+        L/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45Y
+        L/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45Y
+        L/91SCfkGA8IgwAAAFIAAAAuAAAAFQAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAACAAAABkAAAA3AAAAXEIpFqmHVC34jlgv/45Y
+        L/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/35O
+        Ku0oGQ2PAAAAVAAAADAAAAAWAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAACwAAAB4AAAA8AAAAYEsuGbGLVi78jlgv/45Y
+        L/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45Y
+        L/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45YL/+OWC//jlgv/45Y
+        L/+OWC//d0on4wAAAGsAAAA+AAAAHgAAAAkAAAAMAAAAJAAAAEgAAAB3j1gw/49YMP+PWDD/j1gw/49Y
+        MP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49Y
+        MP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/45Y
+        MP9XNR3BAQEAawAAAEMAAAAiAAAADQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADwAAACUAAABIBAIBcmxDJNmPWDD/j1gw/49Y
+        MP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+NVy/9VjUdvgAA
+        AGQAAAA9AAAAHwAAAAwAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAWAAAALwAAAFIkFgyLfEwq649YMP+PWDD/j1gw/49Y
+        MP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49Y
+        MP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49YMP+PWDD/j1gw/49Y
+        MP93SijjAAAAawAAAD4AAAAeAAAACQAAAAwAAAAkAAAASAAAAHePWTD/j1kw/49ZMP+PWTD/j1kw/49Z
+        MP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49Z
+        MP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/4NR
+        LPIrGw6WAAAAWAAAADMAAAAYAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAHAAAAGQAAADQAAABaOSMToYdULfaPWTD/j1kw/49Z
+        MP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/3lLKeceEwqEAAAATgAA
+        ACsAAAATAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAADAAAADgAAACMAAABDAwIBa106H8iPWTD/j1kw/49ZMP+PWTD/j1kw/49Z
+        MP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49Z
+        MP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/3dK
+        KOMAAABrAAAAPgAAAB4AAAAJAAAADAAAACQAAABIAAAAd49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49Z
+        MP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49Z
+        MP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/2U/
+        ItIEAgFxAAAARwAAACUAAAAPAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAOAAAAJAAAAEUEAgFuZkAi0Y9ZMP+PWTD/j1kw/49Z
+        MP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+OWDD+VDQcugAAAGAAAAA6AAAAHAAA
+        AAoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAQAAAAcAAAAYAAAANAAAAFkvHRCZhFIs9I9ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49Z
+        MP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49Z
+        MP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/j1kw/49ZMP+PWTD/d0oo4wAA
+        AGsAAAA+AAAAHgAAAAkAAAAMAAAAJAAAAEgAAAB3kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZ
+        MP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZ
+        MP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/iFQt9zwl
+        FKQAAABbAAAANgAAABkAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAWAAAAMQAAAFYsGw+ThVIs9JBZMP+QWTD/kFkw/5BZ
+        MP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/3xNKekbEQmAAAAATAAAACkAAAARAAAABAAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAEAAAADwAAACYAAABIEAoFd2hAI9SQWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZ
+        MP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZ
+        MP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP+QWTD/kFkw/5BZMP94SijjAAAAawAA
+        AD4AAAAeAAAACQAAAAwAAAAkAAAASAAAAHeQWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5Ba
+        MP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5Ba
+        MP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/dkon4QsH
+        BHYAAABJAAAAJwAAABAAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAwAAAAhAAAAQQAAAGdgPCDJkFow/5BaMP+QWjD/kFow/5Ba
+        MP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+NWC/8UTIbtgAAAF8AAAA5AAAAGwAAAAkAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAgAAAAZAAAANwAAAFxEKheqjFgv+5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5Ba
+        MP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5Ba
+        MP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/5BaMP+QWjD/kFow/3hLKOMAAABrAAAAPgAA
+        AB4AAAAJAAAADAAAACQAAABIAAAAd5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5Fa
+        Mf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5Fa
+        Mf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+OWDD8Si4ZsQAA
+        AF4AAAA3AAAAGgAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAABgAAABUAAAAvAAAAUykZDpGDUSzwkVox/5FaMf+RWjH/kVox/5Fa
+        Mf+RWjH/kVox/5FaMf+RWjH/kVox/31NKugXDgiAAAAATAAAACkAAAAQAAAABAAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAAEAAA
+        ACgAAABJEAoFeHdKKOGRWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5Fa
+        Mf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5Fa
+        Mf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/eUsp4wAAAGsAAAA+AAAAHgAA
+        AAkAAAAMAAAAJAAAAEgAAAB3kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5Fa
+        Mf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5Fa
+        Mf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf94SinjFg4HfQAA
+        AEwAAAAqAAAAEgAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAACAAAADAAAACAAAABAAwIBaVk3HsORWjH/kVox/5FaMf+RWjH/kVox/5Fa
+        Mf+RWjH/kVox/5FaMf+RWjH/UjMcuwAAAGIAAAA6AAAAHAAAAAkAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAkAAAAbAAAAOAAA
+        AF5MLxqxjlgw/JFaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5Fa
+        Mf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5Fa
+        Mf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf+RWjH/kVox/5FaMf95SynjAAAAawAAAD4AAAAeAAAACQAA
+        AAwAAAAkAAAASAAAAHeRWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5Fb
+        Mf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5Fb
+        Mf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/49aMP1WNh29AAAAYgAA
+        AD0AAAAeAAAACwAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAAGAAAAFAAAAC4AAABSJBcMi4BQK+yRWzH/kVsx/5FbMf+RWzH/kVsx/5Fb
+        Mf+RWzH/kVsx/3xOKukeEwqIAAAAUAAAACsAAAASAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAAEQAAACkAAABMHBEJgX5P
+        KumRWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5Fb
+        Mf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/5Fb
+        Mf+RWzH/kVsx/5FbMf+RWzH/kVsx/5FbMf+RWzH/kVsx/3lMKeMAAABqAAAAPgAAAB0AAAAJAAAADAAA
+        ACMAAABHAAAAdpJbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5Jb
+        Mf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5Jb
+        Mf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/39PK+sjFgyKAAAAUwAA
+        AC8AAAAWAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAMAAAALAAAAHwAAAD0AAABkWTcev5FaMf6SWzH/klsx/5JbMf+SWzH/klsx/5Jb
+        Mf+RWzH+TjEauAEBAGgAAAA+AAAAHwAAAAsAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAoAAAAcAAAAOgAAAGFYNx28kVox/pJb
+        Mf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5Jb
+        Mf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5Jb
+        Mf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/eUsp4QAAAGkAAAA9AAAAHAAAAAgAAAALAAAAIgAA
+        AEYAAAB2klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5Jb
+        Mf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5Jb
+        Mf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/1k4HsMBAQBrAAAAQwAA
+        ACIAAAANAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAQAAAAUAAAATAAAAKwAAAE4hFQuFfE0q55JbMf+SWzH/klsx/5JbMf+SWzH/klsx/35P
+        KuocEQmGAAAAUQAAAC0AAAATAAAABgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAFAAAAEgAAACsAAABNIxYMh39PKumSWzH/klsx/5Jb
+        Mf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5Jb
+        Mf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf+SWzH/klsx/5Jb
+        Mf+SWzH/klsx/5JbMf+SWzH/klsx/5JbMf90SCfcAAAAZwAAADsAAAAbAAAABwAAAAoAAAAiAAAARAAA
+        AHOPWjH7klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5Jc
+        Mv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5Jc
+        Mv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/glIt7ywcD5YAAABYAAAAMgAA
+        ABcAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAgAAAAoAAAAcAAAAOQAAAF5YOB67kVwy/5JcMv+SXDL/klwy/5JcMv+SXDL/VzceugAA
+        AGEAAAA8AAAAHgAAAAsAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAoAAAAdAAAAOwAAAGJfPCHDkFsx/pJcMv+SXDL/klwy/5Jc
+        Mv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5Jc
+        Mv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5JcMv+SXDL/klwy/5Jc
+        Mv+SXDL/klwy/5JcMv+SXDL/klwy/2xEJdIAAABjAAAAOAAAABkAAAAHAAAACgAAAB8AAABAAAAAboVT
+        Le6TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5Nc
+        Mv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5Nc
+        Mv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/YDwhygEBAG4AAABFAAAAIwAA
+        AA0AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABAAAABAAAAAnAAAARxYOCHZ4Synek1wy/5NcMv+TXDL/k1wy/3dLKd0cEQl6AAAASQAA
+        ACgAAAASAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAAGAAAAEwAAAC0AAABPLBwPjoVTLe+TXDL/k1wy/5NcMv+TXDL/k1wy/5Nc
+        Mv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5Nc
+        Mv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5Nc
+        Mv+TXDL/k1wy/5NcMv+SWzL+XjsgwgAAAF4AAAA0AAAAFwAAAAUAAAAIAAAAHAAAADwAAABod0sp35Nc
+        Mv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5Nc
+        Mv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5Nc
+        Mv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+GVC7yJhgNkgAAAFgAAAAxAAAAFgAA
+        AAYAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAACQAAABgAAAAxAAAAUCoaDoR0SSjXilcv9YpXL/V2SijaLRwPhgAAAFAAAAAxAAAAGAAA
+        AAkAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAwAAAAwAAAAfAAAAPwAAAGVeOyDDk1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5Nc
+        Mv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5Nc
+        Mv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5NcMv+TXDL/k1wy/5Nc
+        Mv+TXDL/k1wy/5BaMfxLLxmvAAAAWAAAADAAAAAUAAAABAAAAAYAAAAYAAAANgAAAF9nQSPJlF0y/5Rd
+        Mv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5Rd
+        Mv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5Rd
+        Mv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv9fOyDIAwIBbAAAAEIAAAAhAAAADAAA
+        AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAAEAAAADAAAABwAAAA0AAAATQ8JBWs+JxWSPSYVkhELBmsAAABNAAAANAAAABwAAAANAAAABAAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAAHAAAAFgAAADAAAABVLBwPkYNSLO6UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5Rd
+        Mv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5Rd
+        Mv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5RdMv+UXTL/lF0y/5Rd
+        Mv+UXTL/ilcv9jAeEJUAAABRAAAAKwAAABAAAAADAAAABAAAABMAAAAuAAAAVUsvGquPWjH7lF0z/5Rd
+        M/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5Rd
+        M/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5Rd
+        M/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/4hWL/MtHBCTAAAAUwAAAC4AAAATAAAABQAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAAFAAAADgAAABwAAAAsAAAAPAAAAEUAAABFAAAAPAAAACwAAAAcAAAADgAAAAUAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAA
+        AA0AAAAiAAAAQwMCAWxfPCHIlF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5Rd
+        M/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5Rd
+        M/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5Rd
+        M/94SyniEwwHfQAAAEgAAAAlAAAADQAAAAEAAAACAAAADgAAACUAAABJJxkOh4FRLOqUXTP/lF0z/5Rd
+        M/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5Rd
+        M/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5Rd
+        M/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/2M+IsgAAABlAAAAPQAAAB4AAAAKAAAAAgAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAAFAAAADAAAABQAAAAdAAAAIgAAACIAAAAdAAAAFQAAAAwAAAAFAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAHAAAAFwAA
+        ADIAAABYKRoOlIdVLvKUXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5Rd
+        M/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5Rd
+        M/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/5RdM/+UXTP/lF0z/1g3
+        HsIBAQBpAAAAPQAAAB0AAAAKAAAAAQAAAAEAAAAJAAAAHAAAADwAAABlaEEkzJVdM/+VXTP/lV0z/5Vd
+        M/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5Vd
+        M/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5Vd
+        M/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/hlQu7ykaDo0AAABPAAAAKwAAABIAAAAFAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAADAAAABwAAAAoAAAAMAAAADQAAAAoAAAAHAAAAAwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAA0AAAAjAAAARQUD
+        Am9aOB/FlV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5Vd
+        M/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5Vd
+        M/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+VXTP/lV0z/5VdM/+KVi/1NSESnAAA
+        AFgAAAAxAAAAFgAAAAYAAAAAAAAAAQAAAAUAAAAUAAAALwAAAFU/KBahi1gw9pVeM/+VXjP/lV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+TXTL+Yj4ixQAAAGIAAAA7AAAAHAAAAAoAAAACAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAGAAAAFQAAADEAAABXKBkOk4VU
+        LvCVXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/25FJtYPCgV3AAAARwAA
+        ACUAAAAOAAAAAwAAAAAAAAAAAAAAAgAAAA0AAAAjAAAARAYEAnBzSCfZlV4z/5VeM/+VXjP/lV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+GVS7vJRgNiAAAAE4AAAAqAAAAEQAAAAQAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAsAAAAgAAAAQAEBAGteOyDHlV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5Ve
+        M/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+VXjP/lV4z/5VeM/+QWzH6RCsXqAAAAFwAAAA1AAAAGQAA
+        AAgAAAABAAAAAAAAAAAAAAABAAAABwAAABcAAAA0AAAAWkcsGKiQWjL5ll40/5ZeNP+WXjT/ll40/5Ze
+        NP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5Ze
+        NP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5Ze
+        NP+WXjT/ll40/5ZeNP+WXjT/ll40/5VdNP5bOR++AAAAYQAAADoAAAAcAAAACgAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAAEgAAACwAAABRHRIKiIRTLu6WXjT/ll40/5Ze
+        NP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5Ze
+        NP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/5Ze
+        NP+WXjT/ll40/5ZeNP+WXjT/ll40/5ZeNP+WXjT/ll40/3ZKKd0TDAd4AAAASAAAACUAAAAPAAAABAAA
+        AAAAAAAAAAAAAAAAAAAAAAAEAAAADwAAACUAAABGCQYDcXNJKNiWXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/39QLOcgFAuEAAAATAAAACkAAAARAAAABAAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAkAAAAcAAAAOwAAAGJWNh68lF4z/ZZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+OWjH4RCsXpgAAAFsAAAA1AAAAGQAAAAgAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAAHAAAAFwAAADEAAABVNSISloxZMfSWXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/lF4z/Vg4H7sAAABgAAAAOQAAABsAAAAJAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAACgAAABMHBIKgoFSLemWXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5ZfNP+WXzT/ll80/5Zf
+        NP+WXzT/ll80/5ZfNP+WXzT/ll80/2xEJdAFAwJuAAAARQAAACQAAAAPAAAABAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAMAAAANAAAAIAAAAD4AAABjYj0iw5dfNP+XXzT/l180/5dfNP+XXzT/l180/5df
+        NP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5df
+        NP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5df
+        NP+XXzT/l180/5dfNP+XXzT/f1As5RwSCoAAAABLAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAQAAAAgAAAAaAAAANwAAAF5VNR22lF0z/ZdfNP+XXzT/l180/5dfNP+XXzT/l180/5df
+        NP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5df
+        NP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5dfNP+XXzT/l180/5df
+        NP+XXzT/l180/5dfNP+JVi/wKxsPjwAAAFQAAAAwAAAAFgAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAQAAAAYAAAATAAAAKgAAAEocEgp9ek4q35dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/l2A0/5dgNP+UXjP8TTEbsAAAAF4AAAA3AAAAGgAAAAgAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAEAAAADwAAACcAAABJEAoGeXlNKuCXYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/kl0y+lI0HLMAAABgAAAAPAAAAB8AAAAMAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAgAAAAkAAAAZAAAAMwAAAFU0IRKTiVcv8JdgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/l2A0/5dgNP91SijcFg4IfAAAAEkAAAAmAAAADwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAgAAAAZAAAANgAAAF1GLRiqkFsy+JdgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dgNP+XYDT/l2A0/5dg
+        NP9pQyTNBwQCbwAAAEcAAAAoAAAAEQAAAAUAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABAAAAA0AAAAfAAAAOgAAAFtJLhmlj1oy9phgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hg
+        Nf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hg
+        Nf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hg
+        Nf+YYDX/mGA1/5NdM/tDKxenAAAAXAAAADUAAAAZAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAADgAA
+        ACUAAABHCwcEdHJIKNiYYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hg
+        Nf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hg
+        Nf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/dksp2hkQ
+        CX8AAABQAAAALwAAABYAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABgAAABAAAAAjAAAAPwAAAGBXNx60lF00+phgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hg
+        Nf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hg
+        Nf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hg
+        Nf+YYDX/mGA1/25FJtUIBQNzAAAARgAAACUAAAAOAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAWAAAAMgAA
+        AFk7JRWgjVkx9ZhgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hg
+        Nf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hg
+        Nf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/5hgNf+YYDX/mGA1/4BRLeUkFwyIAAAAVgAA
+        ADYAAAAcAAAACwAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABwAAABIAAAAmAAAAQwAAAGNbOiC5k14z+phhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hh
+        Nf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hh
+        Nf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hh
+        Nf+YYTX/jlsx9iwcD5YAAABYAAAAMQAAABYAAAAGAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADAAAACEAAABCAwIBbWRA
+        I8qYYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hh
+        Nf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hh
+        Nf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf+YYTX/mGE1/5hhNf9+USzjLBwPjwAAAFgAAAA5AAAAHwAA
+        AA4AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAACAAAABwAAABQAAAApAAAARQIBAWZUNR2yjlox85lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lh
+        Nf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lh
+        Nf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lh
+        Nf+YYTX/Yj4iyQQDAWwAAABBAAAAIAAAAAsAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAATAAAALQAAAFIsHA+SiVcv75lh
+        Nf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lh
+        Nf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lh
+        Nf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/d0wp3CkaDosAAABYAAAAOgAAACEAAAAPAAAABQAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAACAAAACQAAABUAAAApAAAAQwAAAGE9JhWdglMt5plhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lh
+        Nf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lh
+        Nf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lh
+        Nf+IVi/vIhYMiwAAAFEAAAArAAAAEgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAACQAAABwAAAA6AAAAY1g4H72ZYTX/mWE1/5lh
+        Nf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lh
+        Nf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lhNf+ZYTX/mWE1/5lh
+        Nf+ZYTX/mWE1/5lhNf+ZYTX/lV40+2VAI8cXDwh9AAAAVQAAADkAAAAhAAAAEAAAAAYAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAADAAAACQAAABUAAAAnAAAAPwAAAFoqGw+KZ0EkyZFcM/eZYTb/mWE2/5lhNv+ZYTb/mWE2/5lh
+        Nv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lh
+        Nv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5df
+        Nf1UNR64AAAAYQAAADoAAAAbAAAACAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAKAAAAEsaEQmAf1At5JlhNv+ZYTb/mWE2/5lh
+        Nv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lh
+        Nv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lhNv+ZYTb/mWE2/5lh
+        Nv+ZYTb/mGA2/oFSLuZKLxqrCAUDbgAAAE8AAAA1AAAAHwAAAA8AAAAGAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAADAAAACAAAABMAAAAiAAAANwAAAFEDAgFrOiUUn3hMKtyWYDX8mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/35Q
+        LOMLBwR4AAAASgAAACcAAAAPAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAABwAAABkAAAA2AAAAXUMrGKiXYDX8mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/41a
+        MfJdOyG+HxQLgQAAAFwAAABEAAAALgAAABsAAAAOAAAABQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAACAAAABgAAAA8AAAAcAAAALgAAAEQAAABaEQsGd00xG6+CUy7mmGE1/ppiNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/kl0z+Ect
+        GagAAABbAAAANAAAABcAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAMAAAAOAAAAJQAAAEcQCgZ3c0ko2JpiNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5BbMvVvRifQLh0QkAAA
+        AGMAAABMAAAANwAAACUAAAAWAAAACwAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABQAAAAsAAAAWAAAAJAAAADUAAABJAAAAXh4TCoJkPyPDjFkx8ZpiNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/cUgo1QMC
+        AW4AAABDAAAAIgAAAAwAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABgAAABYAAAAxAAAAWDQhEpuPWzL1mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5dgNfx8TyvgQysYpQUDAm4AAABVAAAAPgAA
+        ACsAAAAaAAAADwAAAAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAAAwAAAAcAAAAOAAAAGQAAACcAAAA4AAAATQAAAGQyIBKUbUYm0JJdM/eaYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+MWTHxLx4RkwAA
+        AFIAAAAtAAAAEwAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAALAAAAIAAAAEABAQBrZ0Eky5liNv6aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+aYjb/mmI2/5pi
+        Nv+aYjb/mmI2/5piNv+aYjb/mmI2/5piNv+CUy7nVjcetQ0IBHcAAABbAAAARQAAADEAAAAfAAAAEwAA
+        AAkAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAQAAAAQAAAAIAAAAEAAAABsAAAArAAAAPgAAAFUDAgFuRy0Zp3pOK92ZYjX9m2M2/5tj
+        Nv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tj
+        Nv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5piNv5ePCHAAAAAZAAA
+        ADsAAAAcAAAACQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAA
+        ABEAAAArAAAATxoQCYWIVy/tm2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tj
+        Nv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tj
+        Nv+bYzb/m2M2/5tjNv+NWjHxYz8jwyYYDYcAAABfAAAASQAAADYAAAAlAAAAFgAAAAwAAAAFAAAAAgAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAAEAAAACgAAABMAAAAfAAAAMQAAAEYAAABbEgwGeVM1HbOFVS7om2M2/5tj
+        Nv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tj
+        Nv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/35RLOIaEAmAAAAATAAA
+        ACgAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAHAAAAGQAA
+        ADcAAABfUDMcs5dgNfybYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tj
+        Nv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tjNv+bYzb/m2M2/5tj
+        Nv+WYDT5b0cn0TUiEpUAAABkAAAATgAAADkAAAAoAAAAGQAAAA8AAAAHAAAAAwAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAACAAAABgAAAAwAAAAWAAAAJQAAADYAAABJAAAAXykaD4hlQCTFj1wz85tj
+        N/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tj
+        N/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tjN/+bYzf/lV81+kguGqsAAABbAAAANAAA
+        ABcAAAAHAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAA0AAAAjAAAARgcE
+        AnN3TCram2M3/5tjN/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tj
+        N/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tjN/+bYzf/m2M3/5tjN/+ZYTb8flAt4Uct
+        GagQCgZ0AAAAVQAAAD8AAAArAAAAHAAAABAAAAAIAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAcAAAAPAAAAGQAAACgAAAA5AAAATwAAAGQ1IhOWdUsp1pZg
+        NfqcYzf/nGM3/5xjN/+cYzf/nGM3/5xjN/+cYzf/nGM3/5xjN/+cYzf/nGM3/5xjN/+cYzf/nGM3/5xj
+        N/+cYzf/nGM3/5xjN/+cYzf/nGM3/5xjN/+cYzf/nGM3/5xjN/+cYzf/b0Yn0QcEAnAAAABDAAAAIgAA
+        AAwAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAAEwAAAC4AAABUNSITmI9a
+        MvKcYzf/nGM3/5xjN/+cYzf/nGM3/5xjN/+cYzf/nGM3/5xjN/+cYzf/nGM3/5xjN/+cYzf/nGM3/5xj
+        N/+cYzf/nGM3/5xjN/+cYzf/nGM3/5xjN/+cYzf/nGM3/5xjN/+cYzf/i1gx7Vk5H7gUDQd7AAAAWwAA
+        AEYAAAAxAAAAIAAAABMAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAIAAAAEAAAABwAAAAsAAAAPwAAAFUMCARyRi0Zp4BS
+        LeGYYjb8nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xk
+        N/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+NWzLxMB8RkwAAAFIAAAAtAAAAEwAA
+        AAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAoAAAAcAAAAPAAAAGRmQSTHm2Q3/pxk
+        N/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xk
+        N/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/j1sy8WhDJccjFgyGAAAAYAAAAEoAAAA3AAAAJQAA
+        ABcAAAANAAAABgAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAACgAAABMAAAAgAAAAMQAAAEYAAABcFA0He148
+        IbyJWDDrnGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xk
+        N/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/9UNh63AAAAYgAAADoAAAAcAAAACQAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAEAAAACgAAABMGhEJgoJULuWcZDf/nGQ3/5xk
+        N/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xk
+        N/+cZDf/nGQ3/5xkN/+cZDf/lmA1+nhNKtk8JhWaAAAAZQAAAE8AAAA6AAAAKAAAABoAAAAPAAAABwAA
+        AAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABgAAAA0AAAAXAAAAJQAAADcAAABLAAAAYCka
+        DolpQyXIkF0z85xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xk
+        N/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/3xPLN8aEAl/AAAASgAAACYAAAAPAAAAAwAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAcAAAAYAAAANAAAAFxOMhuvlmA1+pxkN/+cZDf/nGQ3/5xk
+        N/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xkN/+cZDf/nGQ3/5xk
+        N/+cZDf/nGQ3/39SLeJMMRurCwcEcgAAAFYAAABAAAAALAAAABwAAAAQAAAACQAAAAQAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAwAAAAcAAAAPAAAAGgAAACgAAAA6AAAATwAA
+        AGZAKRaddksp15liNvudZDf/nWQ3/51kN/+dZDf/nWQ3/51kN/+dZDf/nWQ3/51kN/+dZDf/nWQ3/51k
+        N/+dZDf/nWQ3/51kN/+dZDf/nWQ3/51kN/+dZDf/ll80+D0nFaAAAABaAAAAMgAAABYAAAAGAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAACAAAADAAAACIAAABDBwQCcG9HJ9KdZDf/nWQ3/51kN/+dZDf/nWQ3/51k
+        N/+dZDf/nWQ3/51kN/+dZDf/nWQ3/51kN/+dZDf/nWQ3/51kN/+dZDf/nWQ3/51kN/+dZDf/nWQ3/4xZ
+        Me5fPCG+HhMLgQAAAFwAAABGAAAAMgAAACAAAAATAAAACgAAAAQAAAABAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAJAAAAEAAAABwAAAAtAAAAQAAA
+        AFcPCgV0SjAaqoJULuScZTf+nWU3/51lN/+dZTf/nWU3/51lN/+dZTf/nWU3/51lN/+dZTf/nWU3/51l
+        N/+dZTf/nWU3/51lN/+dZTf/nWU3/51lN/+dZTf/ZUEjyQMCAWwAAABBAAAAIAAAAAsAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAQAAAATAAAALQAAAFIyIBGUjFox751lN/+dZTf/nWU3/51lN/+dZTf/nWU3/51l
+        N/+dZTf/nWU3/51lN/+dZTf/nWU3/51lN/+dZTf/nWU3/51lN/+dZTf/nWU3/5VgNPdpQyXKKxwPjgAA
+        AGMAAABMAAAANwAAACUAAAAXAAAADQAAAAYAAAACAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAEAAAACgAAABMAAAAhAAAAMgAA
+        AEcAAABdIhYMgl89Ir2OWzPwnWU4/51lOP+dZTj/nWU4/51lOP+dZTj/nWU4/51lOP+dZTj/nWU4/51l
+        OP+dZTj/nWU4/51lOP+dZTj/nWU4/51lOP+JWDHsGRAJhQAAAE8AAAAqAAAAEAAAAAQAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAACAAAABsAAAA6AAAAYlU3HrecZTj/nWU4/51lOP+dZTj/nWU4/51lOP+dZTj/nWU4/51l
+        OP+dZTj/nWU4/51lOP+dZTj/nWU4/51lOP+dZTj/nWU4/5dhNvp8UCzdPigWoQkGA28AAABUAAAAPQAA
+        ACsAAAAaAAAAEAAAAAgAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACAAAABgAAAA0AAAAYAAAAJgAA
+        ADcAAABMAAAAYyQXDYtuRyfPlF81951lOP+dZTj/nWU4/51lOP+dZTj/nWU4/51lOP+dZTj/nWU4/51l
+        OP+dZTj/nWU4/51lOP+dZTj/nWU4/5ljN/tGLRmrAAAAXgAAADUAAAAYAAAABwAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAMAAAAOAAAAJgAAAEkTDAd7eU4r3J1lOP+dZTj/nWU4/51lOP+dZTj/nWU4/51lOP+dZTj/nWU4/51l
+        OP+dZTj/nWU4/51lOP+dZTj/nWU4/5xlOP+HVzDoTDEbrQ4JBXYAAABbAAAARQAAADEAAAAfAAAAEgAA
+        AAkAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAgAAAAQAAAAGwAA
+        ACsAAAA9AAAAVAcEAm8+KBahek4r25dhNvmdZTj/nWU4/51lOP+dZTj/nWU4/51lOP+dZTj/nWU4/51l
+        OP+dZTj/nWU4/51lOP+dZTj/nWU4/3FJKNQJBgNwAAAAQwAAACIAAAALAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAA
+        ABYAAAAxAAAAWTYjE5yTXjT1nWU4/51lOP+dZTj/nWU4/51lOP+dZTj/nWU4/51lOP+dZTj/nWU4/51l
+        OP+dZTj/nWU4/51lOP+MWjLuZEEkwh0TCoEAAABeAAAASQAAADUAAAAkAAAAFgAAAAwAAAAFAAAAAQAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAJAAAAEwAA
+        AB8AAAAwAAAARQAAAFoMCAR1VDYesohXMOieZTj/nmU4/55lOP+eZTj/nmU4/55lOP+eZTj/nmU4/55l
+        OP+eZTj/nmU4/55lOP+eZTj/jVoy7iQXDYwAAABRAAAAKwAAABIAAAAEAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAKAAAAHwAA
+        AEABAQBrWzogwZ5lOP+eZTj/nmU4/55lOP+eZTj/nmU4/55lOP+eZTj/nmU4/55lOP+eZTj/nmU4/55l
+        OP+XYTb4c0kp0zMgEpMAAABkAAAATQAAADgAAAAnAAAAGQAAAA8AAAAHAAAAAwAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAIAAAAFAAAADAAA
+        ABYAAAAkAAAANQAAAEkAAABeJRcNhWM/I8GPWzPwnmU4/55lOP+eZTj/nmU4/55lOP+eZTj/nmU4/55l
+        OP+eZTj/nmU4/55lOP+ZYjb7VDUetAAAAF8AAAA3AAAAGQAAAAcAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAABAAAAApAAAAThgP
+        CYSBUi7lnmU4/55lOP+eZTj/nmU4/55lOP+eZTj/nmU4/55lOP+eZTj/nmU4/55lOP+cYzf9e08s3Ect
+        GaYHBAJwAAAAVQAAAD4AAAArAAAAGwAAABAAAAAIAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAAAABwAA
+        AA4AAAAZAAAAJwAAADgAAABOAAAAZDQiEpRxSSjRmGI2+Z5mOP+eZjj/nmY4/55mOP+eZjj/nmY4/55m
+        OP+eZjj/nmY4/55mOP96TyvbAwIBbgAAAEIAAAAgAAAACgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAFgAAADMAAABbOiYVophi
+        NvqeZjj/nmY4/55mOP+eZjj/nmY4/55mOP+eZjj/nmY4/55mOP+dZjj/iVgx6lQ2HrQXDwh8AAAAWwAA
+        AEYAAAAxAAAAHwAAABMAAAAKAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAABAAA
+        AAgAAAAQAAAAGwAAACsAAAA+AAAAVQoGBHFCKhejfVEs3ppkN/ueZjj/nmY4/55mOP+eZjj/nmY4/55m
+        OP+eZjj/nmY4/49cM/A1IhOOAAAASAAAACUAAAANAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAAAbAAAAOgYEAmhnQyXInWY4/55m
+        OP+eZjj/nmY4/55mOP+eZjj/nmY4/55mOP+eZjj/kl4082NAI8UlGA2KAAAAYQAAAEsAAAA2AAAAJQAA
+        ABYAAAAMAAAABgAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAQAAAAKAAAAEwAAAB8AAAAxAAAARgAAAFsZEAl9VzgftI1bMu2dZjj+nmY4/55mOP+eZjj/nmY4/55m
+        OP+eZjj/mGI2+VY3HqUAAABJAAAAJQAAAA0AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABwAAAA7DgkFbX5RLdueZjj/nmY4/55m
+        OP+eZjj/nmY4/55mOP+eZjj/l2I2+XZMKtg1IhOZBgQCbAAAAFMAAAA8AAAAKQAAABkAAAAPAAAABwAA
+        AAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA
+        AAIAAAAGAAAADAAAABYAAAAlAAAANgAAAEoAAABfJBcNhmlEJsaTXjXzn2Y5/59mOf+fZjn/n2Y5/59m
+        Of+PXDPtOSQUhwAAAEIAAAAhAAAADAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAAAAGQAAADUHBAJgaEIlv59mOf+fZjn/n2Y5/59m
+        Of+fZjn/nGQ4/YNUL+RILhqpCQYDdAAAAFkAAABEAAAALwAAAB4AAAASAAAACQAAAAQAAAABAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAEAAAADAAAABwAAAA8AAAAZAAAAKAAAADoAAABPAAAAZjgkFJd4TSvXmWI3+J9mOf+fZjn/jVoz7FU3
+        H6kAAABXAAAANAAAABkAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAASAAAAKAAAAEkfFAt6d0wr0pliN/mfZjn/n2Y5/4tZ
+        MuxbOiG9Fg4IgQAAAGAAAABJAAAANAAAACMAAAAWAAAACwAAAAUAAAABAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAABAAAAAkAAAAQAAAAHAAAACwAAABAAAAAVy4eEYNtRifAhVUw3n5RLdVWNx+lEAoGYwAA
+        AD8AAAAjAAAAEAAAAAQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAoAAAAZAAAAMQAAAE4xIBKBb0cowYVVMN59UC3WUjQdpgwI
+        BG0AAABSAAAAOwAAACgAAAAYAAAADgAAAAcAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAABAAAAAQAAAAQAAAAKAAAAEwAAACIAAAAzAAAARgAAAFQAAABcAAAAWgAAAE4AAAA7AAAAJQAA
+        ABMAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAA0AAAAcAAAALwAAAEMAAABUAAAAXAAAAFsAAABQAAAAQAAA
+        AC4AAAAdAAAAEAAAAAgAAAADAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAQAAAAIAAAAGAAAADQAAABgAAAAkAAAALgAAADQAAAAyAAAAKgAAAB8AAAASAAAACQAA
+        AAMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAABQAAAAwAAAAXAAAAIwAAAC4AAAA0AAAAMgAAACsAAAAgAAAAFQAA
+        AAsAAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAAEAAAACAAAAA4AAAATAAAAFgAAABYAAAASAAAADQAAAAcAAAADAAAAAQAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAgAAAAOAAAAEwAAABYAAAAWAAAAEgAAAA0AAAAHAAAAAwAA
+        AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAEAAAABAAAAAwAAAAQAAAAFAAAABQAAAAQAAAACAAAAAQAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAAMAAAAEAAAABQAAAAUAAAAEAAAAAgAAAAEAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////4AAAf/////////+AD/////////8AAA
+        Af/////////4AP/////////AAAAAf/////////gA/////////wAAAAAf////////+AD////////8AAAA
+        AAf////////4AP////////gAAAAAAf////////gA////////4AAAAAAA////////+AD///////+AAAAA
+        AAA////////4AP///////gAAAAAAAA////////gA///////8AAAAAAAAA///////+AD///////AAAAAA
+        AAAB///////4AP//////wAAAAAAAAAB///////gA//////8AAAAAAAAAAB//////+AD//////gAAAAAA
+        AAAAD//////4AP/////4AAAAAAAAAAAD//////gA/////+AAAAAAAAAAAAD/////+AD/////wAAAAAAA
+        AAAAAD/////4AP////8AAAAAAAAAAAAAH/////gA/////AAAAAAAAAAAAAAH////+AD////wAAAAAAAA
+        AAAAAAH////4AP///+AAAAAAAAAAAAAAAH////gA////gAAAAAAAAAAAAAAAP///+AD///4AAAAAAAAA
+        AAAAAAAP///4AP//+AAAAAAAAAAAAAAAAAP///gA///wAAAAAAAAAAAAAAAAAP//+AD//8AAAAAAAAAA
+        AAAAAAAAf//4AP//AAAAAAAAAAAAAAAAAAAf//gA//4AAAAAAAAAAAAAAAAAAA//+AD//AAAAAAAAAAA
+        AAAAAAAAB//4AP/4AAAAAAAAAAAAAAAAAAAD//gA//gAAAAAAAAAAAAAAAAAAAP/+AD/+AAAAAAAAAAA
+        AAAAAAAAAf/4AP/4AAAAAAAAAAAAAAAAAAAB//gA//gAAAAAAAAAAAAAAAAAAAH/+AD/+AAAAAAAAAAA
+        AAAAAAAAAf/4AP/4AAAAAAAAAAAAAAAAAAAB//gA//gAAAAAAAAAAAAAAAAAAAH/+AD/+AAAAAAAAAAA
+        AAAAAAAAA//4AP/8AAAAAAAAAAAAAAAAAAAD//gA//4AAAAAAAAAAAAAAAAAAAf/+AD//wAAAAAAAAAA
+        AAAAAAAAD//4AP//4AAAAAAAAAAAAAAAAAA///gA///+AAAAAAAAAAAAAAAAA///+AD////wAAAAAAAA
+        AAAAAAB////4AP/////AAAAAAAAAAAAAH/////gA//////8AAAAAAAAAAAf/////+AD///////8AAAAA
+        AAAD///////4AP////////8AAAAAB/////////gA////////////////////////+AD/////////////
+        ///////////4AP////////////////////////gA////////////////////////+AD/////////////
+        ///////////4AP////////////////////////gA////////////////////////+AD/////////////
+        ///////////4APB/////////////////////4PgAwA////////////////////8AGACAA///////////
+        /////////gAIAAAB///////////////////8AAAAAAD////+H///////h/////gAAAAAAH///+AAAf//
+        +AAA////8AAAAAAAf///wAAAAAAAAAA////gAAAAAAA///+AAAAAAAAAAD///8AAAAAAAB///4AAAAAA
+        AAAAH///gAAAAAAAD///AAAAAAAAAAAf//8AAAAAAAAH//8AAAAAAAAAAB///wAAAAAAAAP//wAAAAAA
+        AAAAH//+AAAAAAAAAf//AAAAAAAAAAAf//wAAAAAAAAA//8AAAAAAAAAAB//+AAAAAAAAAB//wAAAAAA
+        AAAAH//wAAAAAAAAAH//gAAAAAAAAAAf/+AAAAAAAAAAP/+AAAAAAAAAAD//wAAAAAAAAAAf/8AAAAAA
+        AAAAP//AAAAAAAAAAA//wAAAAAAAAAB//4AAAAAAAAAAB//gAAAAAAAAAP//AAAAAAAAAAAH//AAAAAA
+        AAAB//4AAAAAAAAAAAP/+AAAAAAAAAH//AAAAAAAAAAAAf/8AAAAAAAAA//4AAAAAAAAAAAA//wAAAAA
+        AAAH//gAAAAAAAAAAAB//gAAAAAAAA//8AAAAAAAAAAAAH//AAAAAAAAH//gAAAAAAAAAAAAP/+AAAAA
+        AAAf/8AAAAAAAAAAAAAf/4AAAAAAAD//wAAAAAAAAAAAAA//wAAAAAAAf/+AAAAAAAAAAAAAD//gAAAA
+        AAB//wAAAAAAAAAAAAAH//AAAAAAAP/+AAAAAAAAAAAAAAP/8AAAAAAB//4AAAAAAAAAAAAAA//4AAAA
+        AAH//AAAAAAAAAAAAAAB//wAAAAAA//4AAAAAAAAAAAAAAD//AAAAAAH//gAAAAAAAAAAAAAAP/+AAAA
+        AAf/8AAAAAAAAAAAAAAAf/8AAAAAD//gAAAAAAAAAAAAAAA//wAAAAAf/+AAAAAAAAAAAAAAAD//gAAA
+        AB//wAAAAAAAAAAAAAAAH/+AAAAAP//AAAAAAAAAAAAAAAAP/8AAAAA//4AAAAAAAAAAAAAAAA//wAAA
+        AH//AAAAAAAAAAAAAAAAB//gAAAAf/8AAAAAAAAAAAAAAAAH//AAAAD//gAAAAAAAAAAAAAAAAP/8AAA
+        AP/+AAAAAAAAAAAAAAAAA//4AAAB//wAAAAAAAAAAAAAAAAB//gAAAH//AAAAAAAAAAAAAAAAAD//AAA
+        A//4AAAAAAAAAAAAAAAAAP/8AAAD//AAAAAAAAAAAAAAAAAAf/4AAAf/8AAAAAAAAAAAAAAAAAB//gAA
+        B//gAAAAAAAAAAAAAAAAAD//AAAP/+AAAAAAAAAAAAAAAAAAP/8AAA//wAAAAAAAAAAAAAAAAAAf/4AA
+        H//AAAAAAAAAAAAAAAAAAB//gAAf/4AAAAAAAAAAAAAAAAAAD//AAD//gAAAAAAAAAAAAAAAAAAP/8AA
+        P/8AAAAAAAAAAAAAAAAAAAf/4AB//wAAAAAAAAAAAAAAAAAAB//wAP/+AAAAAAAAAAAAAAAAAAAD//gB
+        //4AAAAAAAAIAAAAAAAAAAP//gf//AAAAAAAAAgAgAAAAAAAAf/////8AAAAAAAACACAAAAAAAAB////
+        //gAAAAAAAAYAMAAAAAAAAD/////+AAAAAAAABgAwAAAAAAAAP/////4AAAAAAAAOADgAAAAAAAA////
+        //AAAAAAAAA4AOAAAAAAAAB/////8AAAAAAAAHgA8AAAAAAAAH/////gAAAAAAAAeADwAAAAAAAAP///
+        /+AAAAAAAAD4APgAAAAAAAA/////wAAAAAAAAfgA/AAAAAAAAB/////AAAAAAAAB+AD+AAAAAAAAH///
+        /8AAAAAAAAP4AP8AAAAAAAAf////gAAAAAAAB/gA/wAAAAAAAA////+AAAAAAAAP+AD/gAAAAAAAD///
+        /wAAAAAAAB/4AP/gAAAAAAAH////AAAAAAAAP/gA//AAAAAAAAf///4AAAAAAAB/+AD/+AAAAAAAB///
+        /gAAAAAAAf/4AP/+AAAAAAAD///+AAAAAAAD//gA//+AAAAAAAP///wAAAAAAA//+AD//8AAAAAAAf//
+        /AAAAAAAP//4AP//8AAAAAAB///4AAAAAAD///gA///8AAAAAAH///gAAAAAAf//+AD///8AAAAAAP//
+        +AAAAAAH///4AP///4AAAAAA///wAAAAAB////gA////4AAAAAD///AAAAAAP///+AD////4AAAAAH//
+        8AAAAAD////4AP////wAAAAAf//gAAAAA/////gA/////wAAAAA//+AAAAAP////+AD/////wAAAAD//
+        4AAAAB/////4AP/////wAAAAP//AAAAAf/////gA//////gAAAAf/8AAAAH/////+AD//////gAAAB//
+        wAAAB//////4AP//////gAAAH//AAAAP//////gA///////gAAAf/8AAAD//////+AD///////AAAB//
+        wAAA///////4AP///////AAAH//AAAH///////gA////////AAAf/8AAB///////+AD///////+AAD//
+        wAAf///////4AP///////+AAP//gAH////////gA////////+AB///AA////////+AD////////8Af//
+        +AP////////4AA==
+</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/Intersect.Editor/General/Globals.cs b/Intersect.Editor/General/Globals.cs
index 1a846613..d437cfd0 100644
--- a/Intersect.Editor/General/Globals.cs
+++ b/Intersect.Editor/General/Globals.cs
@@ -91,6 +91,8 @@ public static class Globals
 
         public static Guid LoadingMap = Guid.Empty;
 
+        public static FrmUpdate UpdateForm;
+
         public static FrmLogin LoginForm;
 
         public static FrmMain MainForm;
@@ -124,6 +126,8 @@ public static class Globals
 
         public static FrmProgress PreviewProgressForm;
 
+        public static FrmProgress UpdateCreationProgressForm;
+
         //Network Variables
         public static int ReconnectTime = 3000;
 
diff --git a/Intersect.Editor/Intersect.Editor.csproj b/Intersect.Editor/Intersect.Editor.csproj
index 0a8e9137..04efdc14 100644
--- a/Intersect.Editor/Intersect.Editor.csproj
+++ b/Intersect.Editor/Intersect.Editor.csproj
@@ -86,6 +86,12 @@
     <Compile Include="Core\Preferences.cs" />
     <Compile Include="Core\Program.cs" />
     <Compile Include="Entities\Animation.cs" />
+    <Compile Include="Forms\frmUpdate.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\frmUpdate.Designer.cs">
+      <DependentUpon>frmUpdate.cs</DependentUpon>
+    </Compile>
     <Compile Include="Maps\MapGridItem.cs" />
     <Compile Include="Maps\MapSaveState.cs" />
     <Compile Include="Forms\Controls\SearchableDarkTreeView.cs">
@@ -813,6 +819,9 @@
     <EmbeddedResource Include="Forms\frmAbout.resx">
       <DependentUpon>frmAbout.cs</DependentUpon>
     </EmbeddedResource>
+    <EmbeddedResource Include="Forms\frmUpdate.resx">
+      <DependentUpon>frmUpdate.cs</DependentUpon>
+    </EmbeddedResource>
     <EmbeddedResource Include="Forms\frmLogin.resx">
       <DependentUpon>frmLogin.cs</DependentUpon>
     </EmbeddedResource>
diff --git a/Intersect.Editor/Localization/Strings.cs b/Intersect.Editor/Localization/Strings.cs
index d21c0a94..ddb7b964 100644
--- a/Intersect.Editor/Localization/Strings.cs
+++ b/Intersect.Editor/Localization/Strings.cs
@@ -4346,6 +4346,52 @@ public struct TimeEditor
             public static LocalizedString to = @"to";
 
         }
+        
+        public struct Update
+        {
+
+            public static LocalizedString Title = @"Intersect Editor - Updating";
+
+            public static LocalizedString Checking = @"Checking for updates, please wait!";
+
+            public static LocalizedString Updating = @"Downloading updates, {00}% done!";
+
+            public static LocalizedString Restart = @"Update complete! Relaunching!";
+
+            public static LocalizedString Done = @"Update complete! Launching game!";
+
+            public static LocalizedString Error = @"Errpr: {00}";
+
+            public static LocalizedString Files = @"{00} Files Remaining";
+
+            public static LocalizedString Size = @"{00} Left";
+
+            public static LocalizedString Percent = @"{00}%";
+
+        }
+
+        public struct UpdatePacking
+        {
+
+            public static LocalizedString Title = @"Packaging Updater Files, Please Wait!";
+
+            public static LocalizedString Deleting = @"Deleting existing or unchanged files..";
+
+            public static LocalizedString Differential = @"An update already exists in this folder, would you like to generate a differential update (only files that have changed)?";
+
+            public static LocalizedString DifferentialTitle = @"Create differential update?";
+
+            public static LocalizedString Empty = @"You must select an empty folder, or a folder already containing an Intersect update!";
+
+            public static LocalizedString InvalidBase = @"You cannot create the update within the editor folder, the update would include itself!";
+
+            public static LocalizedString Error = @"Error!";
+
+            public static LocalizedString Calculating = @"Calculating checksums, and creating update list...";
+
+            public static LocalizedString Done = @"Done!";
+
+        }
 
         public struct Warping
         {
diff --git a/Intersect.Network/Lidgren/LidgrenInterface.cs b/Intersect.Network/Lidgren/LidgrenInterface.cs
index ce44b7e3..da740ce8 100644
--- a/Intersect.Network/Lidgren/LidgrenInterface.cs
+++ b/Intersect.Network/Lidgren/LidgrenInterface.cs
@@ -600,6 +600,10 @@ private NetIncomingMessage TryHandleInboundMessage()
                                         networkStatus = NetworkStatus.Offline;
                                         break;
 
+                                    case "closing":
+                                        networkStatus = NetworkStatus.Offline;
+                                        break;
+
                                     default:
                                         networkStatus = (NetworkStatus)Enum.Parse(typeof(NetworkStatus), reason ?? "<null>", true);
                                         break;

From 230336b281721b96bc4e22296ed18e3b0f007492 Mon Sep 17 00:00:00 2001
From: JC Snider <jcsnider@users.noreply.github.com>
Date: Mon, 20 Apr 2020 21:40:20 -0400
Subject: [PATCH 3/8] Lock server loop when editor is making changes to
 maps/map grids. (#163)

This fixes crashes when trying to edit games while there are many players online with active npcs needing access to the map grid(s).
---
 Intersect.Server/Networking/PacketHandler.cs | 483 ++++++++++---------
 1 file changed, 248 insertions(+), 235 deletions(-)

diff --git a/Intersect.Server/Networking/PacketHandler.cs b/Intersect.Server/Networking/PacketHandler.cs
index dec4c9da..e41c767a 100644
--- a/Intersect.Server/Networking/PacketHandler.cs
+++ b/Intersect.Server/Networking/PacketHandler.cs
@@ -2150,176 +2150,179 @@ public void HandlePacket(Client client, Player player, Network.Packets.Editor.Cr
                 return;
             }
 
-            var newMap = Guid.Empty;
-            var tmpMap = new MapInstance(true);
-            if (!packet.AttachedToMap)
+            lock (ServerLoop.Lock)
             {
-                var destType = (int) packet.MapListParentType;
-                newMap = DbInterface.AddGameObject(GameObjectType.Map).Id;
-                tmpMap = MapInstance.Get(newMap);
-                DbInterface.GenerateMapGrids();
-                PacketSender.SendMap(client, newMap, true);
-                PacketSender.SendMapGridToAll(tmpMap.MapGrid);
-
-                //FolderDirectory parent = null;
-                destType = -1;
-                if (destType == -1)
+                var newMap = Guid.Empty;
+                var tmpMap = new MapInstance(true);
+                if (!packet.AttachedToMap)
                 {
-                    MapList.List.AddMap(newMap, tmpMap.TimeCreated, MapBase.Lookup);
-                }
+                    var destType = (int) packet.MapListParentType;
+                    newMap = DbInterface.AddGameObject(GameObjectType.Map).Id;
+                    tmpMap = MapInstance.Get(newMap);
+                    DbInterface.GenerateMapGrids();
+                    PacketSender.SendMap(client, newMap, true);
+                    PacketSender.SendMapGridToAll(tmpMap.MapGrid);
 
-                DbInterface.SaveGameDatabase();
-                PacketSender.SendMapListToAll();
-                /*else if (destType == 0)
-                {
-                    parent = Database.MapStructure.FindDir(bf.ReadInteger());
-                    if (parent == null)
+                    //FolderDirectory parent = null;
+                    destType = -1;
+                    if (destType == -1)
                     {
-                        Database.MapStructure.AddMap(newMap);
+                        MapList.List.AddMap(newMap, tmpMap.TimeCreated, MapBase.Lookup);
                     }
-                    else
-                    {
-                        parent.Children.AddMap(newMap);
-                    }
-                }
-                else if (destType == 1)
-                {
-                    var mapNum = bf.ReadInteger();
-                    parent = Database.MapStructure.FindMapParent(mapNum, null);
-                    if (parent == null)
-                    {
-                        Database.MapStructure.AddMap(newMap);
-                    }
-                    else
+
+                    DbInterface.SaveGameDatabase();
+                    PacketSender.SendMapListToAll();
+                    /*else if (destType == 0)
                     {
-                        parent.Children.AddMap(newMap);
-                    }
-                }*/
-            }
-            else
-            {
-                var relativeMap = packet.MapId;
-                switch (packet.AttachDir)
-                {
-                    case 0:
-                        if (MapInstance.Get(MapInstance.Get(relativeMap).Up) == null)
+                        parent = Database.MapStructure.FindDir(bf.ReadInteger());
+                        if (parent == null)
                         {
-                            newMap = DbInterface.AddGameObject(GameObjectType.Map).Id;
-                            tmpMap = MapInstance.Get(newMap);
-                            tmpMap.MapGrid = MapInstance.Get(relativeMap).MapGrid;
-                            tmpMap.MapGridX = MapInstance.Get(relativeMap).MapGridX;
-                            tmpMap.MapGridY = MapInstance.Get(relativeMap).MapGridY - 1;
-                            MapInstance.Get(relativeMap).Up = newMap;
+                            Database.MapStructure.AddMap(newMap);
                         }
-
-                        break;
-
-                    case 1:
-                        if (MapInstance.Get(MapInstance.Get(relativeMap).Down) == null)
+                        else
                         {
-                            newMap = DbInterface.AddGameObject(GameObjectType.Map).Id;
-                            tmpMap = MapInstance.Get(newMap);
-                            tmpMap.MapGrid = MapInstance.Get(relativeMap).MapGrid;
-                            tmpMap.MapGridX = MapInstance.Get(relativeMap).MapGridX;
-                            tmpMap.MapGridY = MapInstance.Get(relativeMap).MapGridY + 1;
-                            MapInstance.Get(relativeMap).Down = newMap;
+                            parent.Children.AddMap(newMap);
                         }
-
-                        break;
-
-                    case 2:
-                        if (MapInstance.Get(MapInstance.Get(relativeMap).Left) == null)
+                    }
+                    else if (destType == 1)
+                    {
+                        var mapNum = bf.ReadInteger();
+                        parent = Database.MapStructure.FindMapParent(mapNum, null);
+                        if (parent == null)
                         {
-                            newMap = DbInterface.AddGameObject(GameObjectType.Map).Id;
-                            tmpMap = MapInstance.Get(newMap);
-                            tmpMap.MapGrid = MapInstance.Get(relativeMap).MapGrid;
-                            tmpMap.MapGridX = MapInstance.Get(relativeMap).MapGridX - 1;
-                            tmpMap.MapGridY = MapInstance.Get(relativeMap).MapGridY;
-                            MapInstance.Get(relativeMap).Left = newMap;
+                            Database.MapStructure.AddMap(newMap);
                         }
-
-                        break;
-
-                    case 3:
-                        if (MapInstance.Get(MapInstance.Get(relativeMap).Right) == null)
+                        else
                         {
-                            newMap = DbInterface.AddGameObject(GameObjectType.Map).Id;
-                            tmpMap = MapInstance.Get(newMap);
-                            tmpMap.MapGrid = MapInstance.Get(relativeMap).MapGrid;
-                            tmpMap.MapGridX = MapInstance.Get(relativeMap).MapGridX + 1;
-                            tmpMap.MapGridY = MapInstance.Get(relativeMap).MapGridY;
-                            MapInstance.Get(relativeMap).Right = newMap;
+                            parent.Children.AddMap(newMap);
                         }
-
-                        break;
+                    }*/
                 }
-
-                if (newMap != Guid.Empty)
+                else
                 {
-                    var grid = DbInterface.GetGrid(tmpMap.MapGrid);
-                    if (tmpMap.MapGridX >= 0 && tmpMap.MapGridX < grid.Width)
+                    var relativeMap = packet.MapId;
+                    switch (packet.AttachDir)
                     {
-                        if (tmpMap.MapGridY + 1 < grid.Height)
-                        {
-                            tmpMap.Down = grid.MyGrid[tmpMap.MapGridX, tmpMap.MapGridY + 1];
+                        case 0:
+                            if (MapInstance.Get(MapInstance.Get(relativeMap).Up) == null)
+                            {
+                                newMap = DbInterface.AddGameObject(GameObjectType.Map).Id;
+                                tmpMap = MapInstance.Get(newMap);
+                                tmpMap.MapGrid = MapInstance.Get(relativeMap).MapGrid;
+                                tmpMap.MapGridX = MapInstance.Get(relativeMap).MapGridX;
+                                tmpMap.MapGridY = MapInstance.Get(relativeMap).MapGridY - 1;
+                                MapInstance.Get(relativeMap).Up = newMap;
+                            }
 
-                            if (tmpMap.Down != Guid.Empty)
+                            break;
+
+                        case 1:
+                            if (MapInstance.Get(MapInstance.Get(relativeMap).Down) == null)
                             {
-                                MapInstance.Get(tmpMap.Down).Up = newMap;
+                                newMap = DbInterface.AddGameObject(GameObjectType.Map).Id;
+                                tmpMap = MapInstance.Get(newMap);
+                                tmpMap.MapGrid = MapInstance.Get(relativeMap).MapGrid;
+                                tmpMap.MapGridX = MapInstance.Get(relativeMap).MapGridX;
+                                tmpMap.MapGridY = MapInstance.Get(relativeMap).MapGridY + 1;
+                                MapInstance.Get(relativeMap).Down = newMap;
                             }
-                        }
 
-                        if (tmpMap.MapGridY - 1 >= 0)
-                        {
-                            tmpMap.Up = grid.MyGrid[tmpMap.MapGridX, tmpMap.MapGridY - 1];
+                            break;
 
-                            if (tmpMap.Up != Guid.Empty)
+                        case 2:
+                            if (MapInstance.Get(MapInstance.Get(relativeMap).Left) == null)
                             {
-                                MapInstance.Get(tmpMap.Up).Down = newMap;
+                                newMap = DbInterface.AddGameObject(GameObjectType.Map).Id;
+                                tmpMap = MapInstance.Get(newMap);
+                                tmpMap.MapGrid = MapInstance.Get(relativeMap).MapGrid;
+                                tmpMap.MapGridX = MapInstance.Get(relativeMap).MapGridX - 1;
+                                tmpMap.MapGridY = MapInstance.Get(relativeMap).MapGridY;
+                                MapInstance.Get(relativeMap).Left = newMap;
                             }
-                        }
+
+                            break;
+
+                        case 3:
+                            if (MapInstance.Get(MapInstance.Get(relativeMap).Right) == null)
+                            {
+                                newMap = DbInterface.AddGameObject(GameObjectType.Map).Id;
+                                tmpMap = MapInstance.Get(newMap);
+                                tmpMap.MapGrid = MapInstance.Get(relativeMap).MapGrid;
+                                tmpMap.MapGridX = MapInstance.Get(relativeMap).MapGridX + 1;
+                                tmpMap.MapGridY = MapInstance.Get(relativeMap).MapGridY;
+                                MapInstance.Get(relativeMap).Right = newMap;
+                            }
+
+                            break;
                     }
 
-                    if (tmpMap.MapGridY >= 0 && tmpMap.MapGridY < grid.Height)
+                    if (newMap != Guid.Empty)
                     {
-                        if (tmpMap.MapGridX - 1 >= 0)
+                        var grid = DbInterface.GetGrid(tmpMap.MapGrid);
+                        if (tmpMap.MapGridX >= 0 && tmpMap.MapGridX < grid.Width)
                         {
-                            tmpMap.Left = grid.MyGrid[tmpMap.MapGridX - 1, tmpMap.MapGridY];
+                            if (tmpMap.MapGridY + 1 < grid.Height)
+                            {
+                                tmpMap.Down = grid.MyGrid[tmpMap.MapGridX, tmpMap.MapGridY + 1];
 
-                            if (tmpMap.Left != Guid.Empty)
+                                if (tmpMap.Down != Guid.Empty)
+                                {
+                                    MapInstance.Get(tmpMap.Down).Up = newMap;
+                                }
+                            }
+
+                            if (tmpMap.MapGridY - 1 >= 0)
                             {
-                                MapInstance.Get(tmpMap.Left).Right = newMap;
+                                tmpMap.Up = grid.MyGrid[tmpMap.MapGridX, tmpMap.MapGridY - 1];
+
+                                if (tmpMap.Up != Guid.Empty)
+                                {
+                                    MapInstance.Get(tmpMap.Up).Down = newMap;
+                                }
                             }
                         }
 
-                        if (tmpMap.MapGridX + 1 < grid.Width)
+                        if (tmpMap.MapGridY >= 0 && tmpMap.MapGridY < grid.Height)
                         {
-                            tmpMap.Right = grid.MyGrid[tmpMap.MapGridX + 1, tmpMap.MapGridY];
+                            if (tmpMap.MapGridX - 1 >= 0)
+                            {
+                                tmpMap.Left = grid.MyGrid[tmpMap.MapGridX - 1, tmpMap.MapGridY];
+
+                                if (tmpMap.Left != Guid.Empty)
+                                {
+                                    MapInstance.Get(tmpMap.Left).Right = newMap;
+                                }
+                            }
 
-                            if (tmpMap.Right != Guid.Empty)
+                            if (tmpMap.MapGridX + 1 < grid.Width)
                             {
-                                MapInstance.Get(tmpMap.Right).Left = newMap;
+                                tmpMap.Right = grid.MyGrid[tmpMap.MapGridX + 1, tmpMap.MapGridY];
+
+                                if (tmpMap.Right != Guid.Empty)
+                                {
+                                    MapInstance.Get(tmpMap.Right).Left = newMap;
+                                }
                             }
                         }
-                    }
 
-                    DbInterface.SaveGameDatabase();
-                    DbInterface.GenerateMapGrids();
-                    PacketSender.SendMap(client, newMap, true);
-                    PacketSender.SendMapGridToAll(MapInstance.Get(newMap).MapGrid);
-                    PacketSender.SendEnterMap(client, newMap);
-                    var folderDir = MapList.List.FindMapParent(relativeMap, null);
-                    if (folderDir != null)
-                    {
-                        folderDir.Children.AddMap(newMap, MapInstance.Get(newMap).TimeCreated, MapBase.Lookup);
-                    }
-                    else
-                    {
-                        MapList.List.AddMap(newMap, MapInstance.Get(newMap).TimeCreated, MapBase.Lookup);
-                    }
+                        DbInterface.SaveGameDatabase();
+                        DbInterface.GenerateMapGrids();
+                        PacketSender.SendMap(client, newMap, true);
+                        PacketSender.SendMapGridToAll(MapInstance.Get(newMap).MapGrid);
+                        PacketSender.SendEnterMap(client, newMap);
+                        var folderDir = MapList.List.FindMapParent(relativeMap, null);
+                        if (folderDir != null)
+                        {
+                            folderDir.Children.AddMap(newMap, MapInstance.Get(newMap).TimeCreated, MapBase.Lookup);
+                        }
+                        else
+                        {
+                            MapList.List.AddMap(newMap, MapInstance.Get(newMap).TimeCreated, MapBase.Lookup);
+                        }
 
-                    DbInterface.SaveGameDatabase();
-                    PacketSender.SendMapListToAll();
+                        DbInterface.SaveGameDatabase();
+                        PacketSender.SendMapListToAll();
+                    }
                 }
             }
         }
@@ -2404,16 +2407,19 @@ public void HandlePacket(Client client, Player player, Network.Packets.Editor.Ma
                             return;
                         }
 
-                        mapId = packet.TargetId;
-                        var players = MapInstance.Get(mapId).GetPlayersOnMap();
-                        MapList.List.DeleteMap(mapId);
-                        DbInterface.DeleteGameObject(MapInstance.Get(mapId));
-                        DbInterface.SaveGameDatabase();
-                        DbInterface.GenerateMapGrids();
-                        PacketSender.SendMapListToAll();
-                        foreach (var plyr in players)
+                        lock (ServerLoop.Lock)
                         {
-                            plyr.WarpToSpawn();
+                            mapId = packet.TargetId;
+                            var players = MapInstance.Get(mapId).GetPlayersOnMap();
+                            MapList.List.DeleteMap(mapId);
+                            DbInterface.DeleteGameObject(MapInstance.Get(mapId));
+                            DbInterface.SaveGameDatabase();
+                            DbInterface.GenerateMapGrids();
+                            PacketSender.SendMapListToAll();
+                            foreach (var plyr in players)
+                            {
+                                plyr.WarpToSpawn();
+                            }
                         }
 
                         PacketSender.SendMapToEditors(mapId);
@@ -2441,47 +2447,51 @@ public void HandlePacket(Client client, Player player, Network.Packets.Editor.Un
             {
                 if (client.IsEditor)
                 {
-                    var map = MapInstance.Get(mapId);
-                    if (map != null)
+                    lock (ServerLoop.Lock)
                     {
-                        map.ClearConnections();
+                        var map = MapInstance.Get(mapId);
+                        if (map != null)
+                        {
+                            map.ClearConnections();
 
-                        var grid = DbInterface.GetGrid(map.MapGrid);
-                        var gridX = map.MapGridX;
-                        var gridY = map.MapGridY;
+                            var grid = DbInterface.GetGrid(map.MapGrid);
+                            var gridX = map.MapGridX;
+                            var gridY = map.MapGridY;
 
-                        //Up
-                        if (gridY - 1 >= 0 && grid.MyGrid[gridX, gridY - 1] != Guid.Empty)
-                        {
-                            MapInstance.Get(grid.MyGrid[gridX, gridY - 1])?.ClearConnections((int) Directions.Down);
-                        }
+                            //Up
+                            if (gridY - 1 >= 0 && grid.MyGrid[gridX, gridY - 1] != Guid.Empty)
+                            {
+                                MapInstance.Get(grid.MyGrid[gridX, gridY - 1])?.ClearConnections((int) Directions.Down);
+                            }
 
-                        //Down
-                        if (gridY + 1 < grid.Height && grid.MyGrid[gridX, gridY + 1] != Guid.Empty)
-                        {
-                            MapInstance.Get(grid.MyGrid[gridX, gridY + 1])?.ClearConnections((int) Directions.Up);
-                        }
+                            //Down
+                            if (gridY + 1 < grid.Height && grid.MyGrid[gridX, gridY + 1] != Guid.Empty)
+                            {
+                                MapInstance.Get(grid.MyGrid[gridX, gridY + 1])?.ClearConnections((int) Directions.Up);
+                            }
 
-                        //Left
-                        if (gridX - 1 >= 0 && grid.MyGrid[gridX - 1, gridY] != Guid.Empty)
-                        {
-                            MapInstance.Get(grid.MyGrid[gridX - 1, gridY])?.ClearConnections((int) Directions.Right);
-                        }
+                            //Left
+                            if (gridX - 1 >= 0 && grid.MyGrid[gridX - 1, gridY] != Guid.Empty)
+                            {
+                                MapInstance.Get(grid.MyGrid[gridX - 1, gridY])
+                                    ?.ClearConnections((int) Directions.Right);
+                            }
 
-                        //Right
-                        if (gridX + 1 < grid.Width && grid.MyGrid[gridX + 1, gridY] != Guid.Empty)
-                        {
-                            MapInstance.Get(grid.MyGrid[gridX + 1, gridY]).ClearConnections((int) Directions.Left);
-                        }
+                            //Right
+                            if (gridX + 1 < grid.Width && grid.MyGrid[gridX + 1, gridY] != Guid.Empty)
+                            {
+                                MapInstance.Get(grid.MyGrid[gridX + 1, gridY]).ClearConnections((int) Directions.Left);
+                            }
 
-                        DbInterface.GenerateMapGrids();
-                        if (MapInstance.Lookup.Keys.Contains(curMapId))
-                        {
-                            mapGrid = MapInstance.Get(curMapId).MapGrid;
+                            DbInterface.GenerateMapGrids();
+                            if (MapInstance.Lookup.Keys.Contains(curMapId))
+                            {
+                                mapGrid = MapInstance.Get(curMapId).MapGrid;
+                            }
                         }
-                    }
 
-                    PacketSender.SendMapGridToAll(mapGrid);
+                        PacketSender.SendMapGridToAll(mapGrid);
+                    }
                 }
             }
         }
@@ -2502,97 +2512,100 @@ public void HandlePacket(Client client, Player player, Network.Packets.Editor.Li
             long gridY = packet.GridY;
             var canLink = true;
 
-            if (adjacentMap != null && linkMap != null)
-            {
-                //Clear to test if we can link.
-                var linkGrid = DbInterface.GetGrid(linkMap.MapGrid);
-                var adjacentGrid = DbInterface.GetGrid(adjacentMap.MapGrid);
-                if (linkGrid != adjacentGrid && linkGrid != null && adjacentGrid != null)
+            lock (ServerLoop.Lock) 
+            { 
+                if (adjacentMap != null && linkMap != null)
                 {
-                    var xOffset = linkMap.MapGridX - gridX;
-                    var yOffset = linkMap.MapGridY - gridY;
-                    for (var x = 0; x < adjacentGrid.Width; x++)
+                    //Clear to test if we can link.
+                    var linkGrid = DbInterface.GetGrid(linkMap.MapGrid);
+                    var adjacentGrid = DbInterface.GetGrid(adjacentMap.MapGrid);
+                    if (linkGrid != adjacentGrid && linkGrid != null && adjacentGrid != null)
                     {
-                        for (var y = 0; y < adjacentGrid.Height; y++)
+                        var xOffset = linkMap.MapGridX - gridX;
+                        var yOffset = linkMap.MapGridY - gridY;
+                        for (var x = 0; x < adjacentGrid.Width; x++)
                         {
-                            if (x + xOffset >= 0 &&
-                                x + xOffset < linkGrid.Width &&
-                                y + yOffset >= 0 &&
-                                y + yOffset < linkGrid.Height)
+                            for (var y = 0; y < adjacentGrid.Height; y++)
                             {
-                                if (adjacentGrid.MyGrid[x, y] != Guid.Empty &&
-                                    linkGrid.MyGrid[x + xOffset, y + yOffset] != Guid.Empty)
+                                if (x + xOffset >= 0 &&
+                                    x + xOffset < linkGrid.Width &&
+                                    y + yOffset >= 0 &&
+                                    y + yOffset < linkGrid.Height)
                                 {
-                                    //Incompatible Link!
-                                    PacketSender.SendError(client,
-                                        Strings.Mapping.linkfailerror.ToString(
-                                            MapBase.GetName(linkMapId), MapBase.GetName(adjacentMapId),
-                                            MapBase.GetName(adjacentGrid.MyGrid[x, y]),
-                                            MapBase.GetName(linkGrid.MyGrid[x + xOffset, y + yOffset])
-                                        ), Strings.Mapping.linkfail
-                                    );
-
-                                    return;
+                                    if (adjacentGrid.MyGrid[x, y] != Guid.Empty &&
+                                        linkGrid.MyGrid[x + xOffset, y + yOffset] != Guid.Empty)
+                                    {
+                                        //Incompatible Link!
+                                        PacketSender.SendError(client,
+                                            Strings.Mapping.linkfailerror.ToString(
+                                                MapBase.GetName(linkMapId), MapBase.GetName(adjacentMapId),
+                                                MapBase.GetName(adjacentGrid.MyGrid[x, y]),
+                                                MapBase.GetName(linkGrid.MyGrid[x + xOffset, y + yOffset])
+                                            ), Strings.Mapping.linkfail
+                                        );
+
+                                        return;
+                                    }
                                 }
                             }
                         }
-                    }
 
-                    if (canLink)
-                    {
-                        for (var x = -1; x < adjacentGrid.Width + 1; x++)
+                        if (canLink)
                         {
-                            for (var y = -1; y < adjacentGrid.Height + 1; y++)
+                            for (var x = -1; x < adjacentGrid.Width + 1; x++)
                             {
-                                if (x + xOffset >= 0 &&
-                                    x + xOffset < linkGrid.Width &&
-                                    y + yOffset >= 0 &&
-                                    y + yOffset < linkGrid.Height)
+                                for (var y = -1; y < adjacentGrid.Height + 1; y++)
                                 {
-                                    if (linkGrid.MyGrid[x + xOffset, y + yOffset] != Guid.Empty)
+                                    if (x + xOffset >= 0 &&
+                                        x + xOffset < linkGrid.Width &&
+                                        y + yOffset >= 0 &&
+                                        y + yOffset < linkGrid.Height)
                                     {
-                                        var inXBounds = x > -1 && x < adjacentGrid.Width;
-                                        var inYBounds = y > -1 && y < adjacentGrid.Height;
-                                        if (inXBounds && inYBounds)
+                                        if (linkGrid.MyGrid[x + xOffset, y + yOffset] != Guid.Empty)
                                         {
-                                            adjacentGrid.MyGrid[x, y] = linkGrid.MyGrid[x + xOffset, y + yOffset];
-                                        }
+                                            var inXBounds = x > -1 && x < adjacentGrid.Width;
+                                            var inYBounds = y > -1 && y < adjacentGrid.Height;
+                                            if (inXBounds && inYBounds)
+                                            {
+                                                adjacentGrid.MyGrid[x, y] = linkGrid.MyGrid[x + xOffset, y + yOffset];
+                                            }
 
-                                        if (inXBounds && y - 1 >= 0 && adjacentGrid.MyGrid[x, y - 1] != Guid.Empty)
-                                        {
-                                            MapInstance.Get(linkGrid.MyGrid[x + xOffset, y + yOffset]).Up = adjacentGrid.MyGrid[x, y - 1];
+                                            if (inXBounds && y - 1 >= 0 && adjacentGrid.MyGrid[x, y - 1] != Guid.Empty)
+                                            {
+                                                MapInstance.Get(linkGrid.MyGrid[x + xOffset, y + yOffset]).Up = adjacentGrid.MyGrid[x, y - 1];
 
-                                            MapInstance.Get(adjacentGrid.MyGrid[x, y - 1]).Down = linkGrid.MyGrid[x + xOffset, y + yOffset];
-                                        }
+                                                MapInstance.Get(adjacentGrid.MyGrid[x, y - 1]).Down = linkGrid.MyGrid[x + xOffset, y + yOffset];
+                                            }
 
-                                        if (inXBounds && y + 1 < adjacentGrid.Height && adjacentGrid.MyGrid[x, y + 1] != Guid.Empty)
-                                        {
-                                            MapInstance.Get(linkGrid.MyGrid[x + xOffset, y + yOffset]).Down = adjacentGrid.MyGrid[x, y + 1];
+                                            if (inXBounds && y + 1 < adjacentGrid.Height && adjacentGrid.MyGrid[x, y + 1] != Guid.Empty)
+                                            {
+                                                MapInstance.Get(linkGrid.MyGrid[x + xOffset, y + yOffset]).Down = adjacentGrid.MyGrid[x, y + 1];
 
-                                            MapInstance.Get(adjacentGrid.MyGrid[x, y + 1]).Up = linkGrid.MyGrid[x + xOffset, y + yOffset];
-                                        }
+                                                MapInstance.Get(adjacentGrid.MyGrid[x, y + 1]).Up = linkGrid.MyGrid[x + xOffset, y + yOffset];
+                                            }
 
-                                        if (inYBounds && x - 1 >= 0 && adjacentGrid.MyGrid[x - 1, y] != Guid.Empty)
-                                        {
-                                            MapInstance.Get(linkGrid.MyGrid[x + xOffset, y + yOffset]).Left = adjacentGrid.MyGrid[x - 1, y];
+                                            if (inYBounds && x - 1 >= 0 && adjacentGrid.MyGrid[x - 1, y] != Guid.Empty)
+                                            {
+                                                MapInstance.Get(linkGrid.MyGrid[x + xOffset, y + yOffset]).Left = adjacentGrid.MyGrid[x - 1, y];
 
-                                            MapInstance.Get(adjacentGrid.MyGrid[x - 1, y]).Right = linkGrid.MyGrid[x + xOffset, y + yOffset];
-                                        }
+                                                MapInstance.Get(adjacentGrid.MyGrid[x - 1, y]).Right = linkGrid.MyGrid[x + xOffset, y + yOffset];
+                                            }
 
-                                        if (inYBounds && x + 1 < adjacentGrid.Width && adjacentGrid.MyGrid[x + 1, y] != Guid.Empty)
-                                        {
-                                            MapInstance.Get(linkGrid.MyGrid[x + xOffset, y + yOffset]).Right = adjacentGrid.MyGrid[x + 1, y];
+                                            if (inYBounds && x + 1 < adjacentGrid.Width && adjacentGrid.MyGrid[x + 1, y] != Guid.Empty)
+                                            {
+                                                MapInstance.Get(linkGrid.MyGrid[x + xOffset, y + yOffset]).Right = adjacentGrid.MyGrid[x + 1, y];
 
-                                            MapInstance.Get(adjacentGrid.MyGrid[x + 1, y]).Left = linkGrid.MyGrid[x + xOffset, y + yOffset];
+                                                MapInstance.Get(adjacentGrid.MyGrid[x + 1, y]).Left = linkGrid.MyGrid[x + xOffset, y + yOffset];
+                                            }
                                         }
                                     }
                                 }
                             }
-                        }
 
-                        DbInterface.SaveGameDatabase();
-                        DbInterface.GenerateMapGrids();
-                        PacketSender.SendMapGridToAll(adjacentMap.MapGrid);
+                            DbInterface.SaveGameDatabase();
+                            DbInterface.GenerateMapGrids();
+                            PacketSender.SendMapGridToAll(adjacentMap.MapGrid);
+                        }
                     }
                 }
             }

From 10e04afb94e3fbf3a21170e786a529cfed55d7f7 Mon Sep 17 00:00:00 2001
From: JC Snider <jcsnider@users.noreply.github.com>
Date: Mon, 20 Apr 2020 23:59:02 -0400
Subject: [PATCH 4/8] Removes animations from entities animation list once
 disposed (#165)

---
 Intersect.Client/Entities/Entity.cs | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/Intersect.Client/Networking/PacketHandler.cs b/Intersect.Client/Networking/PacketHandler.cs
index c69ec70d..2dadd34e 100644
--- a/Intersect.Client/Networking/PacketHandler.cs
+++ b/Intersect.Client/Networking/PacketHandler.cs
@@ -248,9 +248,32 @@ private static void HandlePacket(EventEntityPacket packet)
         //MapEntitiesPacket
         private static void HandlePacket(MapEntitiesPacket packet)
         {
+            var mapEntities = new Dictionary<Guid, List<Guid>>();
             foreach (var pkt in packet.MapEntities)
             {
                 HandlePacket((dynamic) pkt);
+
+                if (!mapEntities.ContainsKey(pkt.MapId))
+                {
+                    mapEntities.Add(pkt.MapId, new List<Guid>());
+                }
+
+                mapEntities[pkt.MapId].Add(pkt.EntityId);
+            }
+
+            //Remove any entities on the map that shouldn't be there anymore!
+            foreach (var entities in mapEntities)
+            {
+                foreach (var entity in Globals.Entities)
+                {
+                    if (entity.Value.CurrentMap == entities.Key && !entities.Value.Contains(entity.Key))
+                    {
+                        if (!Globals.EntitiesToDispose.Contains(entity.Key) && entity.Value != Globals.Me)
+                        {
+                            Globals.EntitiesToDispose.Add(entity.Key);
+                        }
+                    }
+                }
             }
         }
 
diff --git a/Intersect.Server/Entities/Entity.cs b/Intersect.Server/Entities/Entity.cs
index b3acdf0c..bcd6bd89 100644
--- a/Intersect.Server/Entities/Entity.cs
+++ b/Intersect.Server/Entities/Entity.cs
@@ -786,6 +786,26 @@ public virtual void Move(int moveDir, Player forPlayer, bool doNotUpdate = false
                     var oldMap = MapInstance.Get(MapId);
                     oldMap?.RemoveEntity(this);
                     currentMap?.AddEntity(this);
+
+                    //Send Left Map Packet To the Maps that we are no longer with
+                    var oldMaps = oldMap?.GetSurroundingMaps(true);
+                    var newMaps = currentMap?.GetSurroundingMaps(true);
+
+                    if (oldMaps != null)
+                    {
+                        foreach (var map in oldMaps.ToArray())
+                        {
+                            if (newMaps == null || !newMaps.Contains(map))
+                            {
+                                PacketSender.SendEntityLeaveMap(this, oldMap.Id);
+                                if (this is Player)
+                                {
+                                    var a = true;
+                                }
+                            }
+                        }
+                    }
+
                 }
 
                 MapId = tile.GetMapId();
diff --git a/Intersect.Server/Networking/PacketSender.cs b/Intersect.Server/Networking/PacketSender.cs
index b43c19c8..4fc38519 100644
--- a/Intersect.Server/Networking/PacketSender.cs
+++ b/Intersect.Server/Networking/PacketSender.cs
@@ -498,6 +498,12 @@ public static void SendNpcAggressionTo(Player player, Npc npc)
             player.SendPacket(new NpcAggressionPacket(npc.Id, npc.GetAggression(player)));
         }
 
+        //EntityLeftArea
+        public static void SendEntityLeaveMap(Entity en, Guid leftMap)
+        {
+            SendDataToMap(leftMap, new EntityLeftPacket(en.Id, en.GetEntityType(), en.MapId));
+        }
+
         //EntityLeftPacket
         public static void SendEntityLeave(Entity en)
         {

From 30ffa6e64b15889cfac420d3229723c9bd8a011a Mon Sep 17 00:00:00 2001
From: JC Snider <jcsnider@users.noreply.github.com>
Date: Wed, 22 Apr 2020 22:47:01 -0400
Subject: [PATCH 6/8] Fix updater downloading files that it shouldn't (#168)

---
 Intersect (Core)/Updater/Updater.cs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/Intersect (Core)/Updater/Updater.cs b/Intersect (Core)/Updater/Updater.cs
index 773402e1..5996a2a5 100644
--- a/Intersect (Core)/Updater/Updater.cs	
+++ b/Intersect (Core)/Updater/Updater.cs	
@@ -166,13 +166,17 @@ private async void RunUpdates()
                         mCurrentVersion = new Update();
                         foreach (var file in mUpdate.Files)
                         {
-                            if ((mIsClient && file.ClientIgnore || !mIsClient && file.EditorIgnore) && mCachedVersion != null)
+                            if ((mIsClient && file.ClientIgnore || !mIsClient && file.EditorIgnore))
                             {
-                                var ignoredFile = mCachedVersion.Files.FirstOrDefault(f => f.Path == file.Path);
-                                if (ignoredFile != null)
+                                if (mCachedVersion != null)
                                 {
-                                    mCurrentVersion.Files.Add(ignoredFile);
+                                    var ignoredFile = mCachedVersion.Files.FirstOrDefault(f => f.Path == file.Path);
+                                    if (ignoredFile != null)
+                                    {
+                                        mCurrentVersion.Files.Add(ignoredFile);
+                                    }
                                 }
+
                                 continue;
                             }
 

From 6fa425e8c79870fb6a814c97a5c492993f91370e Mon Sep 17 00:00:00 2001
From: JC Snider <jcsnider@users.noreply.github.com>
Date: Wed, 22 Apr 2020 22:51:04 -0400
Subject: [PATCH 7/8] Resolves #171, npcs vanishing when traversing maps (#172)

---
 Intersect.Server/Entities/Entity.cs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/Intersect.Server/Entities/Entity.cs b/Intersect.Server/Entities/Entity.cs
index bcd6bd89..ae5b38af 100644
--- a/Intersect.Server/Entities/Entity.cs
+++ b/Intersect.Server/Entities/Entity.cs
@@ -793,15 +793,11 @@ public virtual void Move(int moveDir, Player forPlayer, bool doNotUpdate = false
 
                     if (oldMaps != null)
                     {
-                        foreach (var map in oldMaps.ToArray())
+                        foreach (var map in oldMaps)
                         {
                             if (newMaps == null || !newMaps.Contains(map))
                             {
-                                PacketSender.SendEntityLeaveMap(this, oldMap.Id);
-                                if (this is Player)
-                                {
-                                    var a = true;
-                                }
+                                PacketSender.SendEntityLeaveMap(this, map.Id);
                             }
                         }
                     }

From 4cab01d144131fe15d3736194806066428258ac2 Mon Sep 17 00:00:00 2001
From: Joyce <azurebeats@hotmail.nl>
Date: Tue, 28 Apr 2020 17:18:51 +0200
Subject: [PATCH 8/8] Assigning loot ownership + small fixes (#181)

* Added loot ownership

* Map items can be spawned with an owner, and only be picked up by the owner and their party. Anyone can still see it, however.
* The time that loot is exclusive to the owner and their party is configurable through the server's config.json under Map Options.
* NPC Drops are owned by the player (and their party) that dealt the most damage to them. (Unless killed by an NPC or something else, then there is no owner)
* Player drops on death are owned by whoever dealt the killing blow and their party.
* Items dropped from your inventory to the map are owned by you and your party until the timer expires.

* Made the packet handler for PickupItempacket slightly less a hassle to read by shortening some checks.

* Removed useless reference and fixed an issue

Removed a useless reference to System from a random test I forgot to remove.

Fixed an oversight in the way the owner was determined by the amount of damage done to an NPC.. It should now no longer always use the last player in the list, but the one with the most damage.

* General code cleanup

Cleaned up my loot tagging attempt in Entity.Die, as well as some general cleaning up of repeated code using Npc.DamageBase.

* Fixed an NPC behaviour check I skipped over last cleanup

* Add an option to hide loot for players until the ownership claim drops.

Added a configurable option to the server configuration (ShowUnownedItems) that can either show or hide loot for players that are not the owner and not in the owner's party until the claim on that item is dropped by the server.

Disabled attempts at picking up invisible items as well.

* Fix a potential error here, in case the item gets deleted before it should become visible.

* Small death rule change if player dies from anything but another player.

Changed the way item ownership is handled upon player death to set ownership to them (and their party) should a player die from anything that is not another player.

* Moved the two new options to their own Options section.

Would prefer to move these as well:

ItemDespawnTime
ItemSpawnTime

But this would definitely break existing configs.

* Added the error a player gets when attempting to pick up an item that does not belong to them localizable.

* Requested changes for pr #181

- Added Xml summaries to LootOptions.cs
- Made LootOptions a child of Options rather than adding more top level options.
- Changed both Player.IsInMyParty checks to instead be simple Linq queries and enforces a player to be passed on.
- Fixed some places that would throw any entity into the Player.IsInMyParty method.
- Changed the new translation string to be Mixed Case and added the NotNull property.
- Changed some MapItem update logic on MapInstance to not refer to each item by id every time, but a simpler re-usable variable.
- Changed more Guid comparisons
- Added a message to picking up items on the server side if the user's inventory is full.
- Added some Todo's to MapOptions for items that could be moved or renamed for clarity.

* Updated the alert messages to utilize CustomColors

* JC Said I could do this. :coy:

Removes ItemDespawnTime from the MapOptions class and places it in the LootOptions class where it beloongs.

Renames ItemSpawnTime in MapOptions to ItemAttributeRespawnTime which is far more descriptive of what it actually does.

Removes these two options from the top level Options class, like why is almost everything there anyway if we have categories?

* Items forcibly returned by trading and items dropped by resources are now tagged with an owner.

* Fix a small bug unrelated to my code related to regenerating NPC vitals, the code would never actually execute for NPCs.

* Resolve some review problems.
---
 Intersect (Core)/Config/LootOptions.cs       | 24 +++++++++
 Intersect (Core)/Config/MapOptions.cs        |  4 +-
 Intersect (Core)/Config/Options.cs           |  8 +--
 Intersect (Core)/Intersect (Core).csproj     |  1 +
 Intersect.Client/Entities/Entity.cs          |  8 +--
 Intersect.Client/Entities/Player.cs          | 34 ++++++-------
 Intersect.Client/Items/MapItem.cs            |  8 ++-
 Intersect.Client/Maps/MapInstance.cs         |  7 +++
 Intersect.Server/Entities/Entity.cs          | 53 ++++++++++----------
 Intersect.Server/Entities/Npc.cs             | 23 ++++++++-
 Intersect.Server/Entities/Player.cs          |  4 +-
 Intersect.Server/Entities/Resource.cs        |  2 +-
 Intersect.Server/Localization/Strings.cs     |  8 +++
 Intersect.Server/Maps/MapInstance.cs         | 42 ++++++++++++----
 Intersect.Server/Maps/MapItemInstance.cs     |  7 +++
 Intersect.Server/Networking/PacketHandler.cs | 39 ++++++++++++--
 16 files changed, 197 insertions(+), 75 deletions(-)
 create mode 100644 Intersect (Core)/Config/LootOptions.cs

diff --git a/Intersect (Core)/Config/LootOptions.cs b/Intersect (Core)/Config/LootOptions.cs
new file mode 100644
index 00000000..e94281eb
--- /dev/null
+++ b/Intersect (Core)/Config/LootOptions.cs	
@@ -0,0 +1,24 @@
+namespace Intersect.Config
+{
+    /// <summary>
+    /// Contains configurable options pertaining to the way loot (item) drops are handled by the engine.
+    /// </summary>
+    public class LootOptions
+    {
+
+        /// <summary>
+        /// Defines how long (in ms) loot will be available for picking up on the map.
+        /// </summary>
+        public int ItemDespawnTime = 15000;
+
+        /// <summary>
+        /// Defines how long (in ms) an item drop will be ''owned'' by a player and their party.
+        /// </summary>
+        public int ItemOwnershipTime = 5000;
+
+        /// <summary>
+        /// Defines whether players can see items they do not ''own'' on the map.
+        /// </summary>
+        public bool ShowUnownedItems = false;
+    }
+}
diff --git a/Intersect (Core)/Config/MapOptions.cs b/Intersect (Core)/Config/MapOptions.cs
index 84ba7b5d..73136c8f 100644
--- a/Intersect (Core)/Config/MapOptions.cs	
+++ b/Intersect (Core)/Config/MapOptions.cs	
@@ -12,9 +12,7 @@ public class MapOptions
 
         public int Height = 26;
 
-        public int ItemDespawnTime = 15000;
-
-        public int ItemSpawnTime = 15000;
+        public int ItemAttributeRespawnTime = 15000;
 
         public int TileHeight = 32;
 
diff --git a/Intersect (Core)/Config/Options.cs b/Intersect (Core)/Config/Options.cs
index 40e9cb47..8f508df2 100644
--- a/Intersect (Core)/Config/Options.cs	
+++ b/Intersect (Core)/Config/Options.cs	
@@ -54,6 +54,8 @@ public class Options
 
         [JsonProperty("Security")] public SecurityOptions SecurityOpts = new SecurityOptions();
 
+        [JsonProperty("Loot")] public LootOptions LootOpts = new LootOptions();
+
         public SmtpSettings SmtpSettings = new SmtpSettings();
 
         [NotNull]
@@ -115,10 +117,6 @@ public class Options
 
         public static int GameBorderStyle => Instance.MapOpts.GameBorderStyle;
 
-        public static int ItemRepawnTime => Instance.MapOpts.ItemSpawnTime;
-
-        public static int ItemDespawnTime => Instance.MapOpts.ItemDespawnTime;
-
         public static bool ZDimensionVisible => Instance.MapOpts.ZDimensionVisible;
 
         public static int MapWidth => Instance?.MapOpts?.Width ?? 32;
@@ -135,6 +133,8 @@ public class Options
 
         public static int MinChatInterval => Instance.ChatOpts.MinIntervalBetweenChats;
 
+        public static LootOptions Loot => Instance.LootOpts;
+
         public static bool UPnP => Instance._upnp;
 
         public static bool OpenPortChecker => Instance._portChecker;
diff --git a/Intersect (Core)/Intersect (Core).csproj b/Intersect (Core)/Intersect (Core).csproj
index d1dbe3f5..6477813b 100644
--- a/Intersect (Core)/Intersect (Core).csproj	
+++ b/Intersect (Core)/Intersect (Core).csproj	
@@ -191,6 +191,7 @@
     <Compile Include="Configuration\IConfiguration.cs" />
     <Compile Include="Configuration\ConfigurationHelper.cs" />
     <Compile Include="Config\ChatOptions.cs" />
+    <Compile Include="Config\LootOptions.cs" />
     <Compile Include="Config\PacketOptions.cs" />
     <Compile Include="Config\PartyOptions.cs" />
     <Compile Include="Config\SecurityOptions.cs" />
diff --git a/Intersect.Client/Maps/MapInstance.cs b/Intersect.Client/Maps/MapInstance.cs
index 0ac64ed9..f05675d5 100644
--- a/Intersect.Client/Maps/MapInstance.cs
+++ b/Intersect.Client/Maps/MapInstance.cs
@@ -651,6 +651,13 @@ public void DrawItemsAndLights()
             //Draw Map Items
             foreach (var item in MapItems)
             {
+                // Are we allowed to see and pick this item up?
+                if (!item.Value.VisibleToAll && item.Value.Owner != Globals.Me.Id && !Globals.Me.IsInMyParty(item.Value.Owner))
+                {
+                    // This item does not apply to us!
+                    continue;
+                }
+
                 var itemBase = ItemBase.Get(item.Value.ItemId);
                 if (itemBase != null)
                 {
diff --git a/Intersect.Server/Entities/Entity.cs b/Intersect.Server/Entities/Entity.cs
index ae5b38af..3af98f81 100644
--- a/Intersect.Server/Entities/Entity.cs
+++ b/Intersect.Server/Entities/Entity.cs
@@ -1776,21 +1776,14 @@ public virtual void TryAttack(Entity target)
                         dmgMap.TryGetValue(this, out var damage);
                         dmgMap[this] = damage + baseDamage;
 
-                        long dmg = baseDamage;
-                        var newTarget = this;
                         if (enemyNpc.Base.FocusHighestDamageDealer)
                         {
-                            foreach (var pair in dmgMap)
-                            {
-                                if (pair.Value > dmg)
-                                {
-                                    newTarget = pair.Key;
-                                    dmg = pair.Value;
-                                }
-                            }
+                            enemyNpc.AssignTarget(enemyNpc.DamageMapHighest);
+                        }
+                        else
+                        {
+                            enemyNpc.AssignTarget(this);
                         }
-
-                        enemyNpc.AssignTarget(newTarget);
                     }
 
                     enemy.NotifySwarm(this);
@@ -1827,21 +1820,9 @@ public virtual void TryAttack(Entity target)
                     //No Matter what, if we attack the entitiy, make them chase us
                     if (enemy is Npc enemyNpc)
                     {
-                        var dmgMap = enemyNpc.DamageMap;
-                        var target = this;
-                        long dmg = 0;
-                        foreach (var pair in dmgMap)
-                        {
-                            if (pair.Value > dmg)
-                            {
-                                target = pair.Key;
-                                dmg = pair.Value;
-                            }
-                        }
-
                         if (enemyNpc.Base.FocusHighestDamageDealer)
                         {
-                            enemyNpc.AssignTarget(target);
+                            enemyNpc.AssignTarget(enemyNpc.DamageMapHighest);
                         }
                         else
                         {
@@ -2438,9 +2419,29 @@ public virtual void Die(int dropitems = 0, Entity killer = null)
                         continue;
                     }
 
+                    // Decide if we want to have a loot ownership timer or not.
+                    Guid lootOwner = Guid.Empty;
+                    if (this is Npc thisNpc)
+                    {
+                        // Check if we have someone that tagged this NPC.
+                        var taggedBy = thisNpc.DamageMapHighest;
+                        if (taggedBy != null && taggedBy is Player)
+                        {
+                            // Spawn with ownership!
+                            lootOwner = taggedBy.Id;
+                        }
+                    } 
+                    else
+                    {
+                        // There's no tracking of who damaged what player as of now, so going by last hit.. Or set ownership to the player themselves.
+                        lootOwner = playerKiller?.Id ?? Id;
+                    }
+
+                    // Spawn the actual item!
                     var map = MapInstance.Get(MapId);
-                    map?.SpawnItem(X, Y, item, item.Quantity);
+                    map?.SpawnItem(X, Y, item, item.Quantity, lootOwner);
 
+                    // Remove the item from inventory if a player.
                     var player = this as Player;
                     player?.TakeItemsBySlot(n, item.Quantity);
                 }
diff --git a/Intersect.Server/Entities/Npc.cs b/Intersect.Server/Entities/Npc.cs
index 2762a000..4d6c3dd4 100644
--- a/Intersect.Server/Entities/Npc.cs
+++ b/Intersect.Server/Entities/Npc.cs
@@ -29,9 +29,30 @@ public class Npc : Entity
         //Spell casting
         public long CastFreq;
 
-        //Damage Map - Keep track of who is doing the most damage to this npc and focus accordingly
+        /// <summary>
+        /// Damage Map - Keep track of who is doing the most damage to this npc and focus accordingly
+        /// </summary>
         public ConcurrentDictionary<Entity, long> DamageMap = new ConcurrentDictionary<Entity, long>();
 
+        /// <summary>
+        /// Returns the entity that ranks the highest on this NPC's damage map.
+        /// </summary>
+        public Entity DamageMapHighest { 
+            get {
+                long damage = 0;
+                Entity top = null;
+                foreach (var pair in DamageMap)
+                {
+                    if (pair.Value > damage)
+                    {
+                        top = pair.Key;
+                        damage = pair.Value;
+                    }
+                }
+                return top;
+            } 
+        }
+
         public bool Despawnable;
 
         //Moving
diff --git a/Intersect.Server/Entities/Player.cs b/Intersect.Server/Entities/Player.cs
index 2c140f1d..78d2de14 100644
--- a/Intersect.Server/Entities/Player.cs
+++ b/Intersect.Server/Entities/Player.cs
@@ -1510,7 +1510,7 @@ public void DropItems(int slotIndex, int amount)
                 return;
             }
 
-            map.SpawnItem(X, Y, Items[slotIndex], itemBase.IsStackable ? amount : 1);
+            map.SpawnItem(X, Y, Items[slotIndex], itemBase.IsStackable ? amount : 1, Id);
 
             slot.Quantity = Math.Max(0, slot.Quantity - amount);
 
@@ -3427,7 +3427,7 @@ public void ReturnTradeItems()
 
                 if (!TryGiveItem(new Item(offer)))
                 {
-                    MapInstance.Get(MapId)?.SpawnItem(X, Y, offer, offer.Quantity);
+                    MapInstance.Get(MapId)?.SpawnItem(X, Y, offer, offer.Quantity, Id);
                     PacketSender.SendChatMsg(this, Strings.Trading.itemsdropped, CustomColors.Alerts.Error);
                 }
 
diff --git a/Intersect.Server/Entities/Resource.cs b/Intersect.Server/Entities/Resource.cs
index 466957f2..0cfc26c7 100644
--- a/Intersect.Server/Entities/Resource.cs
+++ b/Intersect.Server/Entities/Resource.cs
@@ -161,7 +161,7 @@ public void SpawnResourceItems(Entity killer)
                     if (ItemBase.Get(item.ItemId) != null)
                     {
                         MapInstance.Get(selectedTile.GetMapId())
-                            .SpawnItem(selectedTile.GetX(), selectedTile.GetY(), item, item.Quantity);
+                            .SpawnItem(selectedTile.GetX(), selectedTile.GetY(), item, item.Quantity, killer.Id);
                     }
                 }
             }
diff --git a/Intersect.Server/Localization/Strings.cs b/Intersect.Server/Localization/Strings.cs
index cc958bda..59c91510 100644
--- a/Intersect.Server/Localization/Strings.cs
+++ b/Intersect.Server/Localization/Strings.cs
@@ -776,6 +776,14 @@ public sealed class ItemsNamespace : LocaleNamespace
             [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
             public readonly LocalizedString stunned = @"You cannot use this item whilst stunned.";
 
+            [NotNull, JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+            public readonly LocalizedString NotYours = @"This item does not belong to you!";
+
+            // TODO: Generalize this shit. It's everywhere!
+            [NotNull, JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+            public readonly LocalizedString InventoryNoSpace =
+                @"There is no space left in your inventory for that item!";
+
         }
 
         public sealed class MappingNamespace : LocaleNamespace
diff --git a/Intersect.Server/Maps/MapInstance.cs b/Intersect.Server/Maps/MapInstance.cs
index 5f108a3c..1a77809d 100644
--- a/Intersect.Server/Maps/MapInstance.cs
+++ b/Intersect.Server/Maps/MapInstance.cs
@@ -214,6 +214,11 @@ private void SpawnAttributeItems()
         }
 
         public void SpawnItem(int x, int y, Item item, int amount)
+        {
+            this.SpawnItem(x, y, item, amount, Guid.Empty);
+        }
+
+        public void SpawnItem(int x, int y, Item item, int amount, Guid owner)
         {
             if (item == null)
             {
@@ -230,11 +235,15 @@ public void SpawnItem(int x, int y, Item item, int amount)
                 return;
             }
 
-            var mapItem = new MapItem(item.ItemId, item.Quantity, item.BagId, item.Bag)
-            {
+            
+
+            var mapItem = new MapItem(item.ItemId, item.Quantity, item.BagId, item.Bag) {
                 X = x,
                 Y = y,
-                DespawnTime = Globals.Timing.TimeMs + Options.ItemDespawnTime
+                DespawnTime = Globals.Timing.TimeMs + Options.Loot.ItemDespawnTime,
+                Owner = owner,
+                OwnershipTime = Globals.Timing.TimeMs + Options.Loot.ItemOwnershipTime,
+                VisibleToAll = Options.Loot.ShowUnownedItems
             };
 
             if (itemBase.ItemType == ItemTypes.Equipment)
@@ -311,7 +320,7 @@ public void RemoveItem(int index, bool respawn = true)
                             ItemRespawns[ItemRespawns.Count - 1].AttributeSpawnX = MapItems[index].AttributeSpawnX;
                             ItemRespawns[ItemRespawns.Count - 1].AttributeSpawnY = MapItems[index].AttributeSpawnY;
                             ItemRespawns[ItemRespawns.Count - 1].RespawnTime =
-                                Globals.Timing.TimeMs + Options.ItemRepawnTime;
+                                Globals.Timing.TimeMs + Options.Map.ItemAttributeRespawnTime;
                         }
                     }
 
@@ -771,19 +780,34 @@ public void Update(long timeMs)
                 //Process Items
                 lock (MapItems)
                 {
+
                     for (var i = 0; i < MapItems.Count; i++)
                     {
-                        if (MapItems[i] != null && MapItems[i].DespawnTime != -1 && MapItems[i].DespawnTime < timeMs)
+                        var mapItem = MapItems[i];
+                        if (mapItem != null)
                         {
-                            RemoveItem(i);
+                            // Should this item be visible to everyone now?
+                            if (!mapItem.VisibleToAll && mapItem.OwnershipTime < timeMs)
+                            {
+                                mapItem.VisibleToAll = true;
+                                PacketSender.SendMapItemUpdate(Id, i);
+                            }
+
+                            // Do we need to delete this item?
+                            if (mapItem.DespawnTime != -1 && mapItem.DespawnTime < timeMs)
+                            {
+                                RemoveItem(i);
+                            }
                         }
+
                     }
 
                     for (var i = 0; i < ItemRespawns.Count; i++)
                     {
-                        if (ItemRespawns[i].RespawnTime < timeMs)
+                        var itemRespawn = ItemRespawns[i];
+                        if (itemRespawn.RespawnTime < timeMs)
                         {
-                            SpawnAttributeItem(ItemRespawns[i].AttributeSpawnX, ItemRespawns[i].AttributeSpawnY);
+                            SpawnAttributeItem(itemRespawn.AttributeSpawnX, itemRespawn.AttributeSpawnY);
                             ItemRespawns.RemoveAt(i);
                         }
                     }
@@ -796,7 +820,7 @@ public void Update(long timeMs)
                         if (timeMs > LastUpdateTime + 30000)
                         {
                             //Regen Everything & Forget Targets
-                            if (en.Value is Resource || en is Npc)
+                            if (en.Value is Resource || en.Value is Npc)
                             {
                                 en.Value.RestoreVital(Vitals.Health);
                                 en.Value.RestoreVital(Vitals.Mana);
diff --git a/Intersect.Server/Maps/MapItemInstance.cs b/Intersect.Server/Maps/MapItemInstance.cs
index 07b87a48..01a7848f 100644
--- a/Intersect.Server/Maps/MapItemInstance.cs
+++ b/Intersect.Server/Maps/MapItemInstance.cs
@@ -17,6 +17,13 @@ public class MapItem : Item
 
         [JsonIgnore] public long DespawnTime;
 
+        public Guid Owner;
+
+        [JsonIgnore] public long OwnershipTime;
+
+        // We need this mostly for the client-side.. They can't keep track of our timer after all!
+        public bool VisibleToAll = true;
+
         public int X = 0;
 
         public int Y = 0;
diff --git a/Intersect.Server/Networking/PacketHandler.cs b/Intersect.Server/Networking/PacketHandler.cs
index 941b74ee..091e1702 100644
--- a/Intersect.Server/Networking/PacketHandler.cs
+++ b/Intersect.Server/Networking/PacketHandler.cs
@@ -1156,14 +1156,43 @@ public void HandlePacket(Client client, Player player, PickupItemPacket packet)
             if (packet.MapItemIndex < MapInstance.Get(player.MapId).MapItems.Count &&
                 MapInstance.Get(player.MapId).MapItems[packet.MapItemIndex] != null)
             {
-                if (MapInstance.Get(player.MapId).MapItems[packet.MapItemIndex].X == player.X &&
-                    MapInstance.Get(player.MapId).MapItems[packet.MapItemIndex].Y == player.Y)
+                var mapItem = MapInstance.Get(player.MapId).MapItems[packet.MapItemIndex];
+                if (mapItem.X == player.X &&
+                    mapItem.Y == player.Y)
                 {
-                    if (player.TryGiveItem(MapInstance.Get(player.MapId).MapItems[packet.MapItemIndex]))
+                    var canTake = false;
+                    // Can we actually take this item?
+                    if (mapItem.Owner == Guid.Empty || Globals.Timing.TimeMs > mapItem.OwnershipTime)
                     {
-                        //Remove Item From Map
-                        MapInstance.Get(player.MapId).RemoveItem(packet.MapItemIndex);
+                        // The ownership time has run out, or there's no owner!
+                        canTake = true;
                     }
+                    else if (mapItem.Owner == player.Id || player.Party.Any(p => p.Id == mapItem.Owner))
+                    {
+                        // The current player is the owner, or one of their party members is.
+                        canTake = true;
+                    } 
+
+                    if (canTake)
+                    {
+                        // Try to give the item to our player.
+                        if (player.TryGiveItem(mapItem))
+                        {
+                            // Remove Item From Map
+                            MapInstance.Get(player.MapId).RemoveItem(packet.MapItemIndex);
+                        } 
+                        else 
+                        {
+                            // We couldn't give the player their item, notify them.
+                            PacketSender.SendChatMsg(player, Strings.Items.InventoryNoSpace, CustomColors.Alerts.Error);
+                        }
+                    } 
+                    else
+                    {
+                        // Item does not belong to them.
+                        PacketSender.SendChatMsg(player, Strings.Items.NotYours, CustomColors.Alerts.Error);
+                    }
+                    
                 }
             }
         }