From 5e4edd102e32d92118ec9418459d5331858878a8 Mon Sep 17 00:00:00 2001 From: "DESKTOP-63JQM2H\\justi" Date: Fri, 4 Oct 2024 17:07:01 -0500 Subject: [PATCH] add initial files --- VTFXUtil.sln | 25 + VTFXUtil/App.config | 20 + VTFXUtil/Form1.Designer.cs | 265 ++ VTFXUtil/Form1.cs | 500 +++ VTFXUtil/Form1.resx | 3363 +++++++++++++++++++++ VTFXUtil/Form2.Designer.cs | 109 + VTFXUtil/Form2.cs | 44 + VTFXUtil/Form2.resx | 3348 ++++++++++++++++++++ VTFXUtil/Formats.cs | 50 + VTFXUtil/ImageImportProperties.cs | 36 + VTFXUtil/ImageImporter.cs | 292 ++ VTFXUtil/MipMaker.cs | 231 ++ VTFXUtil/Program.cs | 22 + VTFXUtil/Properties/AssemblyInfo.cs | 36 + VTFXUtil/Properties/Resources.Designer.cs | 63 + VTFXUtil/Properties/Resources.resx | 117 + VTFXUtil/Properties/Settings.Designer.cs | 26 + VTFXUtil/Properties/Settings.settings | 5 + VTFXUtil/VTFGeneral.cs | 243 ++ VTFXUtil/VTFXHandler.cs | 323 ++ VTFXUtil/VTFXUtil.csproj | 144 + VTFXUtil/packages.config | 11 + VTFXUtil/vtfxedit_icon.ico | Bin 0 -> 193167 bytes 23 files changed, 9273 insertions(+) create mode 100644 VTFXUtil.sln create mode 100644 VTFXUtil/App.config create mode 100644 VTFXUtil/Form1.Designer.cs create mode 100644 VTFXUtil/Form1.cs create mode 100644 VTFXUtil/Form1.resx create mode 100644 VTFXUtil/Form2.Designer.cs create mode 100644 VTFXUtil/Form2.cs create mode 100644 VTFXUtil/Form2.resx create mode 100644 VTFXUtil/Formats.cs create mode 100644 VTFXUtil/ImageImportProperties.cs create mode 100644 VTFXUtil/ImageImporter.cs create mode 100644 VTFXUtil/MipMaker.cs create mode 100644 VTFXUtil/Program.cs create mode 100644 VTFXUtil/Properties/AssemblyInfo.cs create mode 100644 VTFXUtil/Properties/Resources.Designer.cs create mode 100644 VTFXUtil/Properties/Resources.resx create mode 100644 VTFXUtil/Properties/Settings.Designer.cs create mode 100644 VTFXUtil/Properties/Settings.settings create mode 100644 VTFXUtil/VTFGeneral.cs create mode 100644 VTFXUtil/VTFXHandler.cs create mode 100644 VTFXUtil/VTFXUtil.csproj create mode 100644 VTFXUtil/packages.config create mode 100644 VTFXUtil/vtfxedit_icon.ico diff --git a/VTFXUtil.sln b/VTFXUtil.sln new file mode 100644 index 0000000..d174d7b --- /dev/null +++ b/VTFXUtil.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.28307.438 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VTFXUtil", "VTFXUtil\VTFXUtil.csproj", "{AC6B703C-9018-4420-8EBB-E57E7A1D2562}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {AC6B703C-9018-4420-8EBB-E57E7A1D2562}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AC6B703C-9018-4420-8EBB-E57E7A1D2562}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AC6B703C-9018-4420-8EBB-E57E7A1D2562}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AC6B703C-9018-4420-8EBB-E57E7A1D2562}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {BEA56C1C-1F4C-42D9-B0F8-3B2DC4321135} + EndGlobalSection +EndGlobal diff --git a/VTFXUtil/App.config b/VTFXUtil/App.config new file mode 100644 index 0000000..b0f2e9b --- /dev/null +++ b/VTFXUtil/App.config @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/VTFXUtil/Form1.Designer.cs b/VTFXUtil/Form1.Designer.cs new file mode 100644 index 0000000..72c85a5 --- /dev/null +++ b/VTFXUtil/Form1.Designer.cs @@ -0,0 +1,265 @@ +namespace VTFXUtil +{ + partial class Form1 + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1)); + this.helloWorldLabel = new System.Windows.Forms.Label(); + this.toolStrip1 = new System.Windows.Forms.ToolStrip(); + this.toolStripDropDownButton1 = new System.Windows.Forms.ToolStripDropDownButton(); + this.openToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.importToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.exportToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.exitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.MonsieurResizer = new System.Windows.Forms.Panel(); + this.PreviewBox = new System.Windows.Forms.PictureBox(); + this.label1 = new System.Windows.Forms.Label(); + this.TxFmtLb = new System.Windows.Forms.Label(); + this.DimensionLb = new System.Windows.Forms.Label(); + this.groupBox2 = new System.Windows.Forms.GroupBox(); + this.ResTbl = new System.Windows.Forms.ListView(); + this.ResType = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.ResOffset = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.toolStrip1.SuspendLayout(); + this.groupBox1.SuspendLayout(); + this.MonsieurResizer.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.PreviewBox)).BeginInit(); + this.groupBox2.SuspendLayout(); + this.SuspendLayout(); + // + // helloWorldLabel + // + this.helloWorldLabel.AutoSize = true; + this.helloWorldLabel.Font = new System.Drawing.Font("Microsoft Sans Serif", 16F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.helloWorldLabel.Location = new System.Drawing.Point(115, 25); + this.helloWorldLabel.Margin = new System.Windows.Forms.Padding(2, 0, 2, 0); + this.helloWorldLabel.Name = "helloWorldLabel"; + this.helloWorldLabel.Size = new System.Drawing.Size(422, 26); + this.helloWorldLabel.TabIndex = 3; + this.helloWorldLabel.Text = "hello yes i am a program i convert textures"; + // + // toolStrip1 + // + this.toolStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStripDropDownButton1}); + this.toolStrip1.Location = new System.Drawing.Point(0, 0); + this.toolStrip1.Name = "toolStrip1"; + this.toolStrip1.Size = new System.Drawing.Size(1212, 25); + this.toolStrip1.TabIndex = 4; + this.toolStrip1.Text = "toolStrip1"; + // + // toolStripDropDownButton1 + // + this.toolStripDropDownButton1.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Text; + this.toolStripDropDownButton1.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.openToolStripMenuItem, + this.importToolStripMenuItem, + this.exportToolStripMenuItem, + this.exitToolStripMenuItem}); + this.toolStripDropDownButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripDropDownButton1.Image"))); + this.toolStripDropDownButton1.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripDropDownButton1.Name = "toolStripDropDownButton1"; + this.toolStripDropDownButton1.ShowDropDownArrow = false; + this.toolStripDropDownButton1.Size = new System.Drawing.Size(29, 22); + this.toolStripDropDownButton1.Text = "File"; + // + // openToolStripMenuItem + // + this.openToolStripMenuItem.Name = "openToolStripMenuItem"; + this.openToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.openToolStripMenuItem.Text = "Open"; + this.openToolStripMenuItem.Click += new System.EventHandler(this.openToolStripMenuItem_Click); + // + // importToolStripMenuItem + // + this.importToolStripMenuItem.Name = "importToolStripMenuItem"; + this.importToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.importToolStripMenuItem.Text = "Import"; + this.importToolStripMenuItem.Click += new System.EventHandler(this.importToolStripMenuItem_Click); + // + // exportToolStripMenuItem + // + this.exportToolStripMenuItem.Name = "exportToolStripMenuItem"; + this.exportToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.exportToolStripMenuItem.Text = "Export"; + this.exportToolStripMenuItem.Click += new System.EventHandler(this.exportToolStripMenuItem_Click); + // + // exitToolStripMenuItem + // + this.exitToolStripMenuItem.Name = "exitToolStripMenuItem"; + this.exitToolStripMenuItem.Size = new System.Drawing.Size(110, 22); + this.exitToolStripMenuItem.Text = "Exit"; + this.exitToolStripMenuItem.Click += new System.EventHandler(this.exitToolStripMenuItem_Click); + // + // groupBox1 + // + this.groupBox1.AutoSize = true; + this.groupBox1.Controls.Add(this.MonsieurResizer); + this.groupBox1.Location = new System.Drawing.Point(77, 54); + this.groupBox1.Name = "groupBox1"; + this.groupBox1.Size = new System.Drawing.Size(527, 553); + this.groupBox1.TabIndex = 5; + this.groupBox1.TabStop = false; + this.groupBox1.Text = "Preview"; + // + // MonsieurResizer + // + this.MonsieurResizer.AutoScroll = true; + this.MonsieurResizer.Controls.Add(this.PreviewBox); + this.MonsieurResizer.Location = new System.Drawing.Point(6, 19); + this.MonsieurResizer.Name = "MonsieurResizer"; + this.MonsieurResizer.Size = new System.Drawing.Size(515, 515); + this.MonsieurResizer.TabIndex = 10; + // + // PreviewBox + // + this.PreviewBox.BackgroundImageLayout = System.Windows.Forms.ImageLayout.None; + this.PreviewBox.Location = new System.Drawing.Point(0, 0); + this.PreviewBox.Name = "PreviewBox"; + this.PreviewBox.Size = new System.Drawing.Size(512, 512); + this.PreviewBox.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; + this.PreviewBox.TabIndex = 0; + this.PreviewBox.TabStop = false; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(621, 86); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(74, 13); + this.label1.TabIndex = 6; + this.label1.Text = "Platform type: "; + // + // TxFmtLb + // + this.TxFmtLb.AutoSize = true; + this.TxFmtLb.Location = new System.Drawing.Point(621, 99); + this.TxFmtLb.Name = "TxFmtLb"; + this.TxFmtLb.Size = new System.Drawing.Size(81, 13); + this.TxFmtLb.TabIndex = 7; + this.TxFmtLb.Text = "Texture format: "; + // + // DimensionLb + // + this.DimensionLb.AutoSize = true; + this.DimensionLb.Location = new System.Drawing.Point(621, 112); + this.DimensionLb.Name = "DimensionLb"; + this.DimensionLb.Size = new System.Drawing.Size(67, 13); + this.DimensionLb.TabIndex = 8; + this.DimensionLb.Text = "Dimensions: "; + // + // groupBox2 + // + this.groupBox2.AutoSize = true; + this.groupBox2.Controls.Add(this.ResTbl); + this.groupBox2.Dock = System.Windows.Forms.DockStyle.Right; + this.groupBox2.Location = new System.Drawing.Point(867, 25); + this.groupBox2.Name = "groupBox2"; + this.groupBox2.Size = new System.Drawing.Size(345, 598); + this.groupBox2.TabIndex = 9; + this.groupBox2.TabStop = false; + this.groupBox2.Text = "Resources"; + // + // ResTbl + // + this.ResTbl.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.ResTbl.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.ResType, + this.ResOffset}); + this.ResTbl.GridLines = true; + this.ResTbl.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.Nonclickable; + this.ResTbl.HideSelection = false; + this.ResTbl.Location = new System.Drawing.Point(7, 20); + this.ResTbl.Name = "ResTbl"; + this.ResTbl.Size = new System.Drawing.Size(332, 193); + this.ResTbl.TabIndex = 0; + this.ResTbl.UseCompatibleStateImageBehavior = false; + this.ResTbl.View = System.Windows.Forms.View.Details; + // + // ResType + // + this.ResType.Text = "Resource Type"; + this.ResType.Width = 189; + // + // ResOffset + // + this.ResOffset.Text = "Resource Offset (base 10)"; + this.ResOffset.Width = 137; + // + // Form1 + // + this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi; + this.AutoSize = true; + this.ClientSize = new System.Drawing.Size(1212, 623); + this.Controls.Add(this.groupBox2); + this.Controls.Add(this.DimensionLb); + this.Controls.Add(this.TxFmtLb); + this.Controls.Add(this.label1); + this.Controls.Add(this.groupBox1); + this.Controls.Add(this.toolStrip1); + this.Controls.Add(this.helloWorldLabel); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.Margin = new System.Windows.Forms.Padding(2); + this.Name = "Form1"; + this.Text = "VTFXUtil"; + this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.Form1_FormClosed); + this.toolStrip1.ResumeLayout(false); + this.toolStrip1.PerformLayout(); + this.groupBox1.ResumeLayout(false); + this.MonsieurResizer.ResumeLayout(false); + this.MonsieurResizer.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.PreviewBox)).EndInit(); + this.groupBox2.ResumeLayout(false); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + private System.Windows.Forms.Label helloWorldLabel; + private System.Windows.Forms.ToolStrip toolStrip1; + private System.Windows.Forms.ToolStripDropDownButton toolStripDropDownButton1; + private System.Windows.Forms.ToolStripMenuItem openToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem exportToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem exitToolStripMenuItem; + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label TxFmtLb; + private System.Windows.Forms.Label DimensionLb; + private System.Windows.Forms.GroupBox groupBox2; + private System.Windows.Forms.ListView ResTbl; + private System.Windows.Forms.ColumnHeader ResType; + private System.Windows.Forms.ColumnHeader ResOffset; + private System.Windows.Forms.PictureBox PreviewBox; + private System.Windows.Forms.Panel MonsieurResizer; + private System.Windows.Forms.ToolStripMenuItem importToolStripMenuItem; + } +} + diff --git a/VTFXUtil/Form1.cs b/VTFXUtil/Form1.cs new file mode 100644 index 0000000..6b3c7e6 --- /dev/null +++ b/VTFXUtil/Form1.cs @@ -0,0 +1,500 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; // image control +using System.Drawing.Drawing2D; +using System.Linq; // this might need to be tossed +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; // UI + + +namespace VTFXUtil +{ + public partial class Form1 : Form + { + public static string MyCodeSucks = null; // i forced this to be classwide, so that importing would work correctly + // i really did not want to deal with returning tuples + private static VTFXHandler.VTFXFile FileInMem; // make this a classwide var, will use for exporting + private static byte[] UnscrewedTextureData; // will be used for exporting + private static byte[] UnscrewedMippedTextureData; // used for non-VTF exports + private static bool GlobalMipped; // non-VTF exports will use this + private static readonly string AppTempPath = System.IO.Path.GetTempPath() + @"\DONT TOUCH ME"; + private static int ExportMipCount; // also for exporting + string LabelPersistText = "Platform type: "; + string TexFormatLabelText = "Texture format: "; + string DLb = "Dimensions: "; + public static readonly byte[] XBoxBytes = { 0, 0, 3, 96 }; + public static readonly byte[] PS3Bytes = { 0, 0, 3, 51 }; + + OpenFileDialog Opener = new OpenFileDialog(); + public Form1() + { + InitializeComponent(); + } + + private void openToolStripMenuItem_Click(object sender, EventArgs e) + { + + ImportAsVTFX(ImportAndClearTable(), null); // isolated this to make it cleaner here + } + + private string ImportAndClearTable() + { + ResTbl.Items.Clear(); + + Opener.Filter = "Valve Texture Format|*.vtf|Xbox 360 VTF|*.360.vtf|PlayStation 3 VTF|*.ps3.vtf"; + Opener.Title = "Open File"; + Opener.ShowDialog(); + if (Opener.FileName.Equals("")) + { + return ""; + } + string Path = Opener.FileName; + return Path; + } + + private void ImportAsVTFX(string Path, System.IO.MemoryStream MemStream) + { + if (Path.Equals("")) + { + return; + } + VTFXHandler.VTFXFile Imported; + if(MemStream == null) // checks to see if we are using this to import from a MemoryStream + { + Imported = VTFXHandler.ImportVTFX(Path); + } + else + { + Imported = VTFXHandler.ImportVTFX(MemStream); + } + if(Imported == null) + { + GC.Collect(); // we're done here, clean the ram + return; + } + byte[] VerMaj = new byte[4]; + byte[] VerMin = new byte[4]; + bool NeedLZMADecompress = false; + byte[] Texture; + Array.Copy(Imported.VersionNum, 0, VerMaj, 0, 4); + Array.Copy(Imported.VersionNum, 4, VerMin, 0, 4); + Array.Reverse(VerMin); + int VerMinInt = System.BitConverter.ToInt32(VerMin, 0); + string VerTextAppend = ""; + Console.WriteLine(VerMaj); + Console.WriteLine(VerMin); + foreach (object Thing in VerMaj) + { + Console.WriteLine(Thing); + } + foreach (object Thing in VerMin) + { + Console.WriteLine(Thing); + } + if (VerMaj.SequenceEqual(XBoxBytes)) + { + VerTextAppend = "Xbox 360"; + NeedLZMADecompress = true; + } + else if (VerMaj.SequenceEqual(PS3Bytes)) + { + VerTextAppend = "PlayStation 3"; + } + else + { + VerTextAppend = "Unknown"; + } + label1.Text = LabelPersistText + VerTextAppend + ", Revision " + VerMinInt.ToString(); + byte[] TxFmtLE = Imported.TextureFormat; + int TxFmtInt = System.BitConverter.ToInt32(TxFmtLE, 0); + TxFmtLb.Text = TexFormatLabelText + VTFGeneral.TexFmtStrArr[TxFmtInt]; + Console.WriteLine("Texture format of imported texture is: {0}.", VTFGeneral.TexFmtStrArr[TxFmtInt]); + DimensionLb.Text = DLb + Imported.ImageWidth.ToString() + "x" + Imported.ImageHeight.ToString(); + foreach (var Resource in Imported.Resources) + { + string[] ResArr = new string[2]; + ResArr[0] = VTFGeneral.GetResourceType(Resource.Key); + ResArr[1] = Resource.Value.ToString(); + ListViewItem ResourceItem = new ListViewItem(ResArr); + ResTbl.Items.Add(ResourceItem); + } + System.IO.Directory.CreateDirectory(AppTempPath); + if (NeedLZMADecompress) //Xbox 360 textures are LZMA compressed, so we need to decompress them into an uncompressed mess + { + string TempInPath = AppTempPath + @"\" + Opener.SafeFileName + ".ENC"; + string TempOutPath = AppTempPath + @"\" + Opener.SafeFileName + ".DEC"; + Texture = ImageImporter.LZMADecompress(Imported.FileData, TempInPath, TempOutPath); + } + else //just take the file data itself, will only be used in the case of PS3 formatted files + { + Texture = Imported.FileData; + } + VTFGeneral.VTFFormatProps TextureProperties = VTFGeneral.FormatTable[TxFmtInt]; + int ByteBufferLen = TextureProperties.ColorByteAmount; + if (!(TextureProperties.IsCompressed)) // endianswap for non-compressed textures + { + Texture = ImageImporter.EndianSwap(Texture, ByteBufferLen); + } + if (TextureProperties.IsCompressed && NeedLZMADecompress) //this will only trigger on files from the 360, as they will always be LZMA compressed + { + Console.WriteLine("This is a 360 texture, needing to fuck it up now!"); + Texture = ImageImporter.RearrangeCompressedTexture(Texture, TxFmtInt); + } + //STARTING HERE, MIPMAPS WILL BE REVERSED, AS DDS AND OTHER FORMATS HAVE THE BIGGEST MIP FIRST, WHILE VTF HAS SMALLEST MIP FIRST + + bool Mippable = MipMaker.IsMipped(Imported.ImageWidth, Imported.ImageHeight, TxFmtInt, Texture.Length); + GlobalMipped = Mippable; + + System.IO.MemoryStream CurrentTexture = new System.IO.MemoryStream(); + MipMaker.MipMap[] MipList; + int MipCount = 1; + if (Mippable) + { + //Console.WriteLine("hey we can mip this"); + MipList = MipMaker.GenMipInfo(Imported.ImageWidth, Imported.ImageHeight, TxFmtInt); + MipCount = MipList.Length; + CurrentTexture = ImageImporter.ReverseMipsIntoMemoryStream(Texture, Imported.ImageWidth, Imported.ImageHeight, TxFmtInt, MipList); + } + + UnscrewedTextureData = Texture; + if (Mippable) + { + Texture = CurrentTexture.ToArray(); + UnscrewedMippedTextureData = Texture; + } + ExportMipCount = MipCount; + System.IO.MemoryStream PNGStream = ImageImporter.GenerateImage(Texture, ExportMipCount, TxFmtInt, Imported); + Bitmap PreviewImage = new Bitmap(PNGStream); + PreviewBox.Image = PreviewImage; + FileInMem = Imported; // pass this through for export purposes + if (Imported.ImageWidth > MonsieurResizer.Width || Imported.ImageHeight > MonsieurResizer.Height) + { + PreviewBox.SizeMode = PictureBoxSizeMode.AutoSize; // enable autosizing to allow for scrollbars to appear if image is bigger than 512x512 + } + else + { + PreviewBox.Width = 512; + PreviewBox.Height = 512; // set picture box size to default, that way it properly recenters it + PreviewBox.SizeMode = PictureBoxSizeMode.CenterImage; // apply centering + } + GC.Collect(); // we're done here, clean the ram + } + + private void Form1_FormClosed(object sender, FormClosedEventArgs e) + { + if (System.IO.Directory.Exists(AppTempPath)) + { + System.IO.Directory.Delete(AppTempPath, true); // empty the temp directory that we have + } + } + + private void exportToolStripMenuItem_Click(object sender, EventArgs e) + { + SaveFileDialog SaveDlg = new SaveFileDialog(); + SaveDlg.Filter = "Valve Texture Format|*.vtf|Tagged Image Format|*.tif|DirectDraw Surface|*.dds"; // hehe filters + SaveDlg.Title = "Export File"; + SaveDlg.ShowDialog(); + if (SaveDlg.FileName.Equals("")) + { + return; + } + System.IO.FileStream OutputFile = (System.IO.FileStream)SaveDlg.OpenFile(); + switch (SaveDlg.FilterIndex) + { + case 1: // VTF + byte[] VTFString = { 0x56, 0x54, 0x46, 0x00 }; // "VTF" + 0x00 + byte[] VTFVer = { 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00 }; // Defaults to 7.3 + int ResourceHeaderLength = 8; //only exports high res data and headers, as the console formats seem to only use it + int HeaderSize = 0x50 + ResourceHeaderLength; + byte[] StartFrame = { 0x00, 0x00 }; + byte[] FourBytePadding = { 0x00, 0x00, 0x00, 0x00 }; + byte[] HighRes = { 0x30, 0x00, 0x00, 0x00 }; + byte[] NOFORMAT = { 0xFF, 0xFF, 0xFF, 0xFF }; + int MipCount = ExportMipCount; // is set to whatever was calculated earlier on when importing + // holy fuck this feels like too much just to write one file + OutputFile.Write(VTFString, 0, VTFString.Length); + OutputFile.Write(VTFVer, 0, VTFVer.Length); + OutputFile.Write(BitConverter.GetBytes(HeaderSize), 0, 4); + OutputFile.Write(BitConverter.GetBytes(FileInMem.ImageWidth), 0, 2); + OutputFile.Write(BitConverter.GetBytes(FileInMem.ImageHeight), 0, 2); + OutputFile.Write(FileInMem.VTFFlags, 0, FileInMem.VTFFlags.Length); + OutputFile.Write(BitConverter.GetBytes(FileInMem.FrameCount), 0, 2); + OutputFile.Write(StartFrame, 0, 2); + OutputFile.Write(FourBytePadding, 0, 4); + OutputFile.Write(FileInMem.ReflectivityVec, 0, 12); + OutputFile.Write(FourBytePadding, 0, 4); + OutputFile.Write(BitConverter.GetBytes(FileInMem.BumpScale), 0, 4); + OutputFile.Write(FileInMem.TextureFormat, 0, FileInMem.TextureFormat.Length); + OutputFile.Write(BitConverter.GetBytes(MipCount), 0, 1); + OutputFile.Write(NOFORMAT, 0, 4); + OutputFile.Write(BitConverter.GetBytes(0), 0, 1); + OutputFile.Write(BitConverter.GetBytes(0), 0, 1); + OutputFile.Write(BitConverter.GetBytes(FileInMem.BitDepth), 0, 1); + OutputFile.Write(FourBytePadding, 0, 4); + OutputFile.Write(BitConverter.GetBytes(FileInMem.ResourceCount), 0, 4); + OutputFile.Write(FourBytePadding, 0, 4); + OutputFile.Write(FourBytePadding, 0, 4); + OutputFile.Write(HighRes, 0, 4); + OutputFile.Write(BitConverter.GetBytes(HeaderSize), 0, 4); + OutputFile.Write(UnscrewedTextureData, 0, UnscrewedTextureData.Length); + break; + case 2: // TIF + Console.WriteLine("Not implemented yet!!!"); + break; + case 3: // DDS + CSharpImageLibrary.ImageEngineFormat ParsedEnum = (CSharpImageLibrary.ImageEngineFormat)Enum.Parse(typeof(VTFGeneral.TEXTURE_FORMATS_INTEROP), Enum.GetName(typeof(VTFGeneral.TEXTURE_FORMATS), System.BitConverter.ToInt32(FileInMem.TextureFormat, 0))); + CSharpImageLibrary.Headers.DDS_Header newDDSHeader = new CSharpImageLibrary.Headers.DDS_Header(ExportMipCount, FileInMem.ImageHeight, FileInMem.ImageWidth, ParsedEnum, CSharpImageLibrary.Headers.DDS_Header.DXGI_FORMAT.DXGI_FORMAT_UNKNOWN); + byte[] DDSHeader = new byte[newDDSHeader.dwSize + 4]; + newDDSHeader.WriteToArray(DDSHeader, 0); + byte[] RealTexture = new byte[DDSHeader.Length + UnscrewedTextureData.Length]; + Array.Copy(DDSHeader, 0, RealTexture, 0, DDSHeader.Length); + if (GlobalMipped) + { + Array.Copy(UnscrewedMippedTextureData, 0, RealTexture, DDSHeader.Length, UnscrewedMippedTextureData.Length); + } + else + { + Array.Copy(UnscrewedTextureData, 0, RealTexture, DDSHeader.Length, UnscrewedTextureData.Length); + } + OutputFile.Write(RealTexture, 0, RealTexture.Length); + break; + } + OutputFile.Close(); + } + + + + private void importToolStripMenuItem_Click(object sender, EventArgs e) + { + // i wonder how well it can work with animated png's + // if i can't do that then i guess some other demuxing of other formats could do the job + + Opener = new OpenFileDialog(); + Opener.Filter = "Valve Texture Format|*.vtf"; + Opener.Title = "Import File"; + Opener.ShowDialog(); + if (Opener.FileNames.Length == 0) + { + Console.WriteLine("whoops nothing!"); + return; + } + Form2 ImportDlg = new Form2(); + ImportDlg.ShowDialog(); + if (MyCodeSucks == null) + { + return; + } + System.IO.FileStream InputFile = (System.IO.FileStream)Opener.OpenFile(); + //Factory.Load(InputFile); // leave this out for now, need to figure out image shit + // anything that isn't png or vtf will have to have individual frames shoved in as seperate files + Formats.VTFFile ImportVTF = new Formats.VTFFile(); + byte[] VTFTextureData; + using (InputFile) // convert our file data into an object, and fill the object with the file's data + { + InputFile.Position += 4; // skip file magic, we already told it to ensure that it is correct + InputFile.Read(ImportVTF.FileVersion, 0, 8); + byte[] TempByteConvert = new byte[4]; + InputFile.Read(TempByteConvert, 0, 4); + ImportVTF.HeaderLength = System.BitConverter.ToInt32(TempByteConvert, 0); + TempByteConvert = new byte[2]; + InputFile.Read(TempByteConvert, 0, 2); + ImportVTF.Width = System.BitConverter.ToInt16(TempByteConvert, 0); + InputFile.Read(TempByteConvert, 0, 2); + ImportVTF.Height = System.BitConverter.ToInt16(TempByteConvert, 0); + InputFile.Read(ImportVTF.Flags, 0, 4); + InputFile.Read(TempByteConvert, 0, 2); + ImportVTF.Frames = System.BitConverter.ToInt16(TempByteConvert, 0); + InputFile.Read(TempByteConvert, 0, 2); + ImportVTF.FirstFrame = System.BitConverter.ToInt16(TempByteConvert, 0); + InputFile.Position += 4; // skip over padding + InputFile.Read(ImportVTF.ReflectivityVector, 0, 12); + InputFile.Position += 4; // skip over more padding + TempByteConvert = new byte[4]; + InputFile.Read(TempByteConvert, 0, 4); + ImportVTF.BumpScale = System.BitConverter.ToSingle(TempByteConvert, 0); + InputFile.Read(ImportVTF.Format, 0, 4); + TempByteConvert = new byte[1]; + InputFile.Read(TempByteConvert, 0, 1); + ImportVTF.MipmapCount = TempByteConvert[0]; + InputFile.Read(ImportVTF.ThumbFormat, 0, 4); + InputFile.Read(TempByteConvert, 0, 1); + ImportVTF.ThumbWidth = TempByteConvert[0]; + InputFile.Read(TempByteConvert, 0, 1); + ImportVTF.ThumbHeight = TempByteConvert[0]; + InputFile.Read(TempByteConvert, 0, 1); + ImportVTF.ImageDepth = TempByteConvert[0]; + InputFile.Position += 4; // skip over even more padding + TempByteConvert = new byte[4]; + InputFile.Read(TempByteConvert, 0, 4); + ImportVTF.ResourceCount = System.BitConverter.ToInt32(TempByteConvert, 0); + int ResByteLength = ImportVTF.ResourceCount * 8; + while (ResByteLength > 0) // get those resources, boy + { + byte[] ResType = new byte[3]; + byte ResKind; + int ResOffset; + InputFile.Read(ResType, 0, 3); + ResByteLength -= 3; + TempByteConvert = new byte[1]; + InputFile.Read(TempByteConvert, 0, 1); + ResKind = TempByteConvert[0]; + ResByteLength--; + TempByteConvert = new byte[4]; + InputFile.Read(TempByteConvert, 0, 4); + ResOffset = System.BitConverter.ToInt32(TempByteConvert, 0); + ImportVTF.Resources.Add(new VTFGeneral.VTFResource(ResType, ResKind, ResOffset)); + ResByteLength -= 4; + } + InputFile.Position = ImportVTF.HeaderLength; + VTFTextureData = new byte[InputFile.Length - ImportVTF.HeaderLength]; + InputFile.Read(VTFTextureData, 0, VTFTextureData.Length); + Bitmap ColorSamplingMan = new Bitmap(1, 1); + + // TODO: implement actual features for changing texture formats, such as converting DXT5 into RGBA8888 and so forth + // as all this does is just eat the original texture with it's current format, and ignores what the user wanted + // actually no, screw this, i'm going to reduce this to only the VTF format for imports, as it will be easier to do so with + // and then do nothing if our format is already the same + if (ImportVTF.MipmapCount > 1) + { + MipMaker.MipMap[] MipList = MipMaker.GenMipInfo(ImportVTF.Width, ImportVTF.Height, System.BitConverter.ToInt32(ImportVTF.Format, 0)); + System.IO.MemoryStream heheimrawdata = ImageImporter.ReverseMipsIntoMemoryStream(VTFTextureData, ImportVTF.Width, ImportVTF.Height, System.BitConverter.ToInt32(ImportVTF.Format, 0), MipList); + System.IO.MemoryStream NewImage = ImageImporter.GenerateImage(heheimrawdata.ToArray(), ImportVTF.MipmapCount, System.BitConverter.ToInt32(ImportVTF.Format, 0), ImportVTF); + heheimrawdata.Flush(); + heheimrawdata.Dispose(); + Bitmap ReversedMips = new Bitmap(NewImage); + using (Graphics g = Graphics.FromImage(ColorSamplingMan)) + { + g.InterpolationMode = InterpolationMode.HighQualityBicubic; + g.DrawImage(ReversedMips, new Rectangle(0, 0, 1, 1)); + } + NewImage.Flush(); + NewImage.Dispose(); + } + else + { + System.IO.MemoryStream NewImage = ImageImporter.GenerateImage(VTFTextureData, ImportVTF.MipmapCount, System.BitConverter.ToInt32(ImportVTF.Format, 0), ImportVTF); + Bitmap Gimage = new Bitmap(NewImage); + using (Graphics g = Graphics.FromImage(ColorSamplingMan)) + { + g.InterpolationMode = InterpolationMode.HighQualityBicubic; + g.DrawImage(Gimage, new Rectangle(0, 0, 1, 1)); + } + NewImage.Flush(); + NewImage.Dispose(); + } + Color AveragedColor = ColorSamplingMan.GetPixel(0, 0); + byte[] ColorSamplingValue = { AveragedColor.R, AveragedColor.G, AveragedColor.B, AveragedColor.A }; + VTFGeneral.VTFFormatProps TextureProperties = VTFGeneral.FormatTable[System.BitConverter.ToInt32(ImportVTF.Format, 0)]; + int ByteBufferLen = TextureProperties.ColorByteAmount; + if (!(TextureProperties.IsCompressed)) // endianswap for non-compressed textures, or just only do this in the case of an uncompressed texture + { + VTFTextureData = ImageImporter.EndianSwap(VTFTextureData, ByteBufferLen); + } + byte[] TexturePlatform = null; + byte[] CompressedSize = new byte[4]; + string PlatformSpecificExtension = ".vtf"; + if (TextureProperties.IsCompressed && MyCodeSucks.Equals("Xbox 360")) //this will only trigger on files from the 360, as they will always be LZMA compressed + { + TexturePlatform = XBoxBytes; + PlatformSpecificExtension = ".360.vtf"; + VTFTextureData = ImageImporter.RearrangeCompressedTexture(VTFTextureData, System.BitConverter.ToInt32(ImportVTF.Format, 0)); + System.IO.MemoryStream Compressed = ImageImporter.LZMACompress(VTFTextureData); + byte[] CompressedArray = Compressed.ToArray(); + VTFTextureData = CompressedArray; + CompressedSize = System.BitConverter.GetBytes(VTFTextureData.Length); + CompressedSize.Reverse(); + } + if (MyCodeSucks.Equals("PlayStation 3")) + { + PlatformSpecificExtension = ".PS3.vtf"; + TexturePlatform = PS3Bytes; + CompressedSize[0] = 0; + CompressedSize[1] = 0; + CompressedSize[2] = 0; + CompressedSize[3] = 0; + } + if (TexturePlatform == null) + { + return; // program machine broke + } + VTFXHandler.VTFXFile ConversionMan = VTFXHandler.ConvertVTFToVTFX(ImportVTF, VTFTextureData, TexturePlatform, ColorSamplingValue); + System.IO.FileStream OutputFile = new System.IO.FileStream(Opener.FileNames[0] + PlatformSpecificExtension, System.IO.FileMode.Create); + using (OutputFile) + { + OutputFile.Write(Encoding.UTF8.GetBytes(ConversionMan.FileMagic), 0, ConversionMan.FileMagic.Length); + OutputFile.Write(ConversionMan.VersionNum, 0, 4); + TempByteConvert = new byte[4]; + TempByteConvert[0] = 0; + TempByteConvert[1] = 0; + TempByteConvert[2] = 0; + TempByteConvert[3] = 0x08; + OutputFile.Write(TempByteConvert, 0, 4); + TempByteConvert = System.BitConverter.GetBytes(ConversionMan.HeaderSize); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 4); + TempByteConvert = new byte[4]; + Array.Copy(ConversionMan.VTFFlags, 0, TempByteConvert, 0, 4); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 4); + TempByteConvert = new byte[2]; + TempByteConvert = System.BitConverter.GetBytes(Convert.ToUInt16(ConversionMan.ImageWidth)); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 2); + TempByteConvert = System.BitConverter.GetBytes(Convert.ToUInt16(ConversionMan.ImageHeight)); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 2); + TempByteConvert = System.BitConverter.GetBytes(Convert.ToUInt16(ConversionMan.BitDepth)); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 2); + TempByteConvert = System.BitConverter.GetBytes(Convert.ToUInt16(ConversionMan.FrameCount)); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 2); + TempByteConvert = System.BitConverter.GetBytes(Convert.ToUInt16(ConversionMan.PreloadSize)); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 2); + OutputFile.WriteByte(Convert.ToByte(ConversionMan.MipSkipCount)); + OutputFile.WriteByte(Convert.ToByte(ConversionMan.ResourceCount)); + TempByteConvert = new byte[4]; + Array.Copy(ConversionMan.ReflectivityVec, 0, TempByteConvert, 0, 4); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 4); + Array.Copy(ConversionMan.ReflectivityVec, 4, TempByteConvert, 0, 4); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 4); + Array.Copy(ConversionMan.ReflectivityVec, 8, TempByteConvert, 0, 4); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 4); + TempByteConvert = System.BitConverter.GetBytes(ConversionMan.BumpScale); + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 4); + TempByteConvert = ConversionMan.TextureFormat; + Array.Reverse(TempByteConvert); + OutputFile.Write(TempByteConvert, 0, 4); + OutputFile.Write(ConversionMan.LowResSamplingAmt, 0, 4); + OutputFile.Write(CompressedSize, 0, 4); + TempByteConvert[0] = 0x30; + TempByteConvert[1] = 0; + TempByteConvert[2] = 0; + TempByteConvert[3] = 0; + OutputFile.Write(TempByteConvert, 0, 4); + TempByteConvert[0] = 0; + TempByteConvert[3] = 0x44; + OutputFile.Write(TempByteConvert, 0, 4); + OutputFile.Write(VTFTextureData, 0, VTFTextureData.Length); + Console.WriteLine("texture imported and saved to " + Opener.FileNames[0] + PlatformSpecificExtension); + } + } + //InputFile.Flush(); + InputFile.Dispose(); + GC.Collect(); // we're done here, clean the ram + } + + private void exitToolStripMenuItem_Click(object sender, EventArgs e) + { + Close(); + } + } +} diff --git a/VTFXUtil/Form1.resx b/VTFXUtil/Form1.resx new file mode 100644 index 0000000..a42103c --- /dev/null +++ b/VTFXUtil/Form1.resx @@ -0,0 +1,3363 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAIDSURBVDhPpZLrS5NhGMb3j4SWh0oRQVExD4gonkDpg4hG + YKxG6WBogkMZKgPNCEVJFBGdGETEvgwyO9DJE5syZw3PIlPEE9pgBCLZ5XvdMB8Ew8gXbl54nuf63dd9 + 0OGSnwCahxbPRNPAPMw9Xpg6ZmF46kZZ0xSKzJPIrhpDWsVnpBhGkKx3nAX8Pv7z1zg8OoY/cITdn4fw + bf/C0kYAN3Ma/w3gWfZL5kzTKBxjWyK2DftwI9tyMYCZKXbNHaD91bLYJrDXsYbrWfUKwJrPE9M2M1Oc + VzOOpHI7Jr376Hi9ogHqFIANO0/MmmmbmSmm9a8ze+I4MrNWAdjtoJgWcx+PSzg166yZZ8xM8XvXDix9 + c4jIqFYAjoriBV9AhEPv1mH/sonogha0afbZMMZz+yreTGyhpusHwtNNCsA5U1zS4BLxzJIfg299qO32 + Ir7UJtZfftyATqeT+8o2D8JSjQrAJblrncYL7ZJ2+bfaFnC/1S1NjL3diRat7qrO7wLRP3HjWsojBeCo + mDEo5mNjuweFGvjWg2EBhCbpkW78htSHHwRyNdmgAFzPEee2iFkzayy2OLXzT4gr6UdUnlXrullsxxQ+ + kx0g8BTA3aZlButjSTyjODq/WcQcW/B/Je4OQhLvKQDnzN1mp0nnkvAhR8VuMzNrpm1mpjgkoVwB/v8D + TgDQASA1MVpwzwAAAABJRU5ErkJggg== + + + + + AAABAA0AAAAAAAEAIABZ3QAA1gAAAICAAAABACAAKAgBAC/eAACAgAAAAQAIAChMAABX5gEAQEAAAAEA + IAAoQgAAfzICAEBAAAABAAgAKBYAAKd0AgAwMAAAAQAgAKglAADPigIAMDAAAAEACACoDgAAd7ACACAg + AAABACAAqBAAAB+/AgAgIAAAAQAIAKgIAADHzwIAGBgAAAEAIACICQAAb9gCABgYAAABAAgAyAYAAPfh + AgAQEAAAAQAgAGgEAAC/6AIAEBAAAAEACABoBQAAJ+0CAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgG + AAAAXHKoZgAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAA7DAAAOwwHHb6hkAADc + 7klEQVR4Xuz9B3hdZ5qdiZY99lyPx3PvHc94ZnztGd/xbbu7VSSr253d3Q7dbk+3AiXmgJxzBk7OAQcn + n4Occw4Ec44SJZHKpHLOsRRLqlzAuuv79z4HIAvtcalYIqXCfp717AMQBE7Y6/3W9+9///tb69v6tr6t + b+vb+ra+rW/r2/q2vq1v69v6tr6tb+vb+ra+rW/r2/q2vq1v69v6tr6tb+vb+ra+rW/r2/q2vq1v69v6 + tr6tb+vb+ra+rW/r2/q2vq1v69v6tr6tb+vb+ra+rW/r2/q2vq1v69v6tr6tb+vb+ra+rW/r2/q2vq1v + 69v6tr6tb+vb+ra+rW/r2/q2vq1v69v6tr6tb+vb+ra+rW/r2/q2vq1v69v69sts+Na3/g6ct/23KL/t + Hy3X3faPl80b/tdl67f/d5g2/stl22//q2Xbt3972blh07Jz479Ztn/7D5btm/6I//5v0zLxa8t3/nDZ + wn83b9qw7Nz0r9X/tXznny07+fvq/vl/J39D/3Pr2/p2YzY4v/V34fy9f7hs+q3/SQ7YZfNtty1bbvvD + Zeumv+BBeyesG3dwn81/K1u2bqhftm60LNk3epasm0JL9g0JqnPJtrGfGl2yfnuCX0/x32eWHBvmr5F9 + 0+LfqpWfmVP/V4m/x7ZpUn4vbJuGuR/kv/ct2Tb0Llk3dnHfzp9r5T6+ZNkQ47+HYd/Ywu8183te/oxn + 2b7BcY1sG63L9o2Wn5Ntg13+Xf6P+h3q98nv39DH3zcGx8ZZ/u0DS67vHFtybjy75Np0P5ybHuG/P8nv + v0i9yef/Af/PJ0uOTd/j//kBn/uP+fuWYN8EOCjnd34xyf/h/+Xf+BnF37fxM+7fX3JsfGHJ+Z1LfC6H + +PsH+JnwdfHzsW/882Xnb/5/+Hn+Pf2jXd9+nTepFssNm/57VUmsG/8TbBtz5UDnQdq75Nq4sOTcdC8P + 1Kd5wL7BA/hjGvrH3C+nD1h10K56LN9f160p/TPiZ/szgugtfran+TjIlHEXP///RT8k1rdv6rbc9Jv/ + w7Jt0+9KJeAHH19ybjhOYz/HCvG5MnWqoqwb+ddLBDgh/yNJDIS/mQnoN/VDZn37um7Y8a3/Rqr6svW2 + Pfxwu2n2SxIP1w2+rv+iJCE4NvyEBeECj5/dcP6Lf6AfUuvbrb6xH/8/YdmYyx6Q/fWGV9lfLql4vtYH + va51/d9JJYNNLy87NlbI+I9+mK1vt8omo8nLlo1/zMoe4Ad1hbH+p+vVfV03XFoqeIWtwV5Jlvrht77d + jE1Gb2Ukd8mxMSlVft3w6/rKpECw8aycqtQPx/Xtq9pg3vBbNLyP1f7FddOv62aKreXnTAM1cmpYPzzX + t1/Fps67OzZk0PDnVbxf48NY17puiiQN2DcuoOY7/2/9cF3fbtS2bP3tf0HKehm33lmv9uu6lbXk2HQV + ztv+D/3QXd9+mY2xaiPf0CEa/wfrxl/X10VL9k2vyzRm/TBe337RTeZ1L9m/s7Ae89f1dZXMFIXxN/+/ + +iG9vv3XbMvOTRvU3PZ146/rGyCZVSrXiuiH9/r2t23SMy05vjPA6PTjtd7Ida3r6yoWtOMo/r2/rx/q + 69vqTc3Fd2xyLtk3frbWm7eudX3t5diEZft3bPohv76ltmX7hi0ym2p9cG9d33Qx2f5IxrX0Q//Xe5PF + GljxD60bf12/TiIEHvy1njasTdndUA3Hxk/XeoPWta5vtKQVsG7I0O3w67XJOVFW/XPrVX9dv86SswJy + wZpui1+Pbdm2IX/JvuGTtd6Qr7UEZiK5vDit1ctTrfp+6mfX+j3r+vURj4Fly6ZtujW+2Rt7/f9xyblp + 8mt54CtjfwfLfPwT++/iM+e/xbvuv8BLnjvwpHcbHvLuxQV/Pk40l+FooBIHA7VYaGnAfKAR8y1N3Ddh + obkB+5rrcMhfhWP+Mpz2FeB+TwYedW/Hc5478Zb7L/EJf6/8fvk76dWHVj+PdX3jxGJ4RrfIN3eDfePv + Ldk3vbjWG3DLSajM/Q+cf4A3Pf8ZV7w7cLq5mIZuwmDIg/ZIBPFoArFYElHu49zHo/J45euY/lh+JiZ7 + Sr6OhuOIRbiPxNXjSCiGcCiKEBUMRhBsCSMW8KPXb8GstxqnXdm46tqM95z/Dj8mGBQQ1qHwjZKsLrRs + /fb/T7fKN29bdmwsovk/X+vF3xJiJP+Z43fwgfvf4wnvThxtrsRwyInWaEwZORZr1ff647WU+jn9Z6Jx + io81KGgwiAgAxPwpGAgE5PsCgnBMh4EGBIFBC2EQCITgbw6i2d+CiNeFEXcdTjiz8Jzzr/G54w/XgfAN + ET1Sp9vlm7PJ4MaSdWPbLXmA8jl97vwjPOPdgiOBavSGm9MmjqdMvcrQ6vvxtmseX6/V3089VuYXEOgw + kO+ngKBB4DogpFNBDCFCIBQkDBQIgvA1t8BPEPh9AXg9fvjdHvQ563HGsQevO/4CP7X/zjoMvqaS1Yd1 + 23wzNtT/6/+ZVf/ULXVA8rl86vpTPOzdg+mgBYlING3o1VIG1o2cUiLRviL5+rrvrf7Z6xXl75REcP3f + ScNB0gIfpxMCISD7dCogBFoIg0BAA0GAiUAg4PM2w0MQiNwuD6IOM/bbc/Gi4z/hp0w06zD4Gsmx4VM4 + /8k/0u3z9d6WTbf9hjq9sdYL/apFE/zI8Xu46t1G05toevbgekXWjKhX/etMm0hea/hk+nG79ph7UVzX + 6sfXfB2TNKBBQPYpKShEWxHRk4EyvJ4GInyOKUkqkBZBtQYqDbA1UCAIqbZAICByu32UFy6CwOl0I2o3 + 4pg9A+84/pzxco33ZV23lvgZyU1kdAt9fbdl+4Y/YZx5b80X+RVKBvHedf3H5ZPNpeiIhDSTUddHemV2 + 3eSyTyY70mZPJuTx2lIASD1etVdaBYDrwbACAgJAgUDaBB0Gso8wCRAEYQFCCgZqjECHgGoNmAgEAs0C + AaYBv5YGvAoEXgUDl5MgsLvgtDnRa6vCY7Y7tEHE696ndd0iEgDYNuTrNvp6bsuWDXew8n9vzRf4FWnJ + +Tt40XMHpltMqnqmYzZ1TYVP7fVq3qqMf61ak51Kqx//l6T+X2q/SgKFFAC01oJ7Gj+VDmLRVRBQANAg + EAnr0h+H+XqugYC0BYSAtATNvhb4vQSBZyUNSBJwOtxwEAR2mwNBaxNOW3fie/Y/WG8PbkEt2TZGdSt9 + /bZl26bdS/aNP1zrhX0VklH8Zzx3YyTooJFSp+iurfbK7Kqyp/ZiUDE/TUsAXG/o1tYutLZpSur71tZO + tMn3U1L/V/9Z9bX+vYT2fe1vaPtEXFNMh4EAIAUD1Rb8XBLQXoMCgKSCkACAkjRAKQiwJVBjA/qZAoGA + 1+3XUoDrOghYHbBRbosZhyx78Yn9j9ZBcCvJuWlWt9PXa1t2bMhbuknX7S85voOnnLej221kFQwi4A+p + PlkMogCQoMmotPFpuFYxY9q4msTUytg0eVvK7G3dytRtaq8p/Vj2bT36z2hKKghwTwgo8WvZJwiAFWkQ + iCtJIlglgYBqDTQQaFoBgJYIdADoMAiuGiBsVhBgS5BOAhoIHASAna2A1WyD2WiF0WCFockES1M99pu3 + 4VNJBGu8t78OWrJu0m46egtoybXpgm6pr8+2bN1UcFNW62Hletb5+/C5/xqFni0o9m5HmXcPqrx5qHdX + wOIxwO1zoTkQQojGEXOlqvo1xteNLsZeUY+m9t70vrVd/1qXZv61JCBIaRUE+DevBUEnTd+BqCimAUD2 + 6XEBXSoNSCpItQWSBHQAhETBmAYBSQJUM1sCOVUoKUCMb7HYYTJZ0WQ0osFci2pbMcpdWSj17kKhbysK + fHej0nsHDrj+DD8gTNd8r9f1lYjt81XdVl+PbdnKyv9Vm5/G/9Dxb9Du/IvlPO+dyPffhcLAZhS13I2i + 4GYUhu5WUl8HtqDUvwvV3kJYfAZ4m/3KPHGJ++3daFem1s0uWmXy9o4+7bHs1ePrdN33WkVtAgZNSVEa + BBoMEsluBYK4DgDZx5kIBARKCgC61LgAARDRWgJRmBAIEQAhvgZJAwK2VBIQEAjs3O5mWK0uZfoGcz0q + 7UUo8e1FcWArioP3aO8RVcz3qJh7+bqg+S6+j3ei0fN/4ZLzj9fPGtwkLTk3vKBb69bfVM9v+2pj/09Y + oQ47/3S5zHU7cj2bedDyYFbGp8L3oDBCcS+Pi2Uf4tehLTzgt6CghY/9W1Huy0GTtwHeloAynECgvbsf + 7Z26qVOSryn1/evUet1jUZL/J6WEJAQlfk0QJFp7NCkA6CBIdLEFkBRAxcT8unQQRFIAUJIEoKUAgYCc + IQgLAHTj+xn7HQ4vjIz4ddZ6VDgLUOTdgcLmu1Eghlfvzd0oCfN94r6Y71NxeAu/1kBQ2ML3UiDguxN5 + 7jsRcv4F3iZk18cHvlqxjX5Zt9etvS3bNtzOJ/vVDfjxQHzd8Xtwuf4Kuaz6eV6pWHfR1Dx4xehRHtgx + EVuBOA/uxFbtMSX7oigVIQgECAKDAI3RvI0wKGAyMKM5FEOC0b2zZxCdvUNo7yIQlAZ+Th3dg2nJ1238 + uZQUDAiA1D4NBcLgGhCkpQFBQJBSCgTRqEBAA4EoTACEVQqgwklG/hjcngDMVicaLAZUOotR5NvJ13YP + 8gm7AlZ7MbcYvijGx+q90VSa5J7vkXp/+N4VEwQqGQT4vrIdyPPciRL37Tjg/FMF3TU/k3XdcC05vgYJ + YNn67X/7VZ7q+ynNv9/2p8uFzjuU+QuaWa2k6ouZdfPLQV2S3IqythWVt2/jfhtKW7ehRIAQpwiCQqqA + qaBApQKBgSSD3ajzVcPdHGAk70Z33wh6+kcJhKEVw8vjtaSDILVPqa2zX5k/DQJJAyoRUK2EQVJLBHGR + pAE9EaQgIGMDCgBMA2ECICSi+QOBKJyuAKu9A7XWGhR7svieyOvR4CaQ09KQBr+S1i0oa+X7Ie8J34/y + dnl/+D15n/j9koTAgf9HQBGSRMWWQEDAlkBaLKfjr/C6/ffW/GzWdWO1ZN/4uG6zW3PTFvHY8P5aT/5X + oQ/svwuv9S+Q7WBVkqrPmKp6fB6shVEetDzAS3XjV3RsR2XXdlR17UBl905Ude9GRddOfm8n/20HD/zt + hMF2Vr5t/H/bURDZivzINuSFt1JbkBfcygrI3+Evhs3vRiTehe7+MfQPT6KLQOjsHSYQhtHVO5KWfC3S + YKDt27s1tRECrZ2atLZgRQKChCQCKs4kECN0YgoE3Cc6aX5CQPYCAh0AzYEYbM5mNJmtqLKXo9C3G/k0 + fD5hls/nXyCSlBNjZSfsSmnuMkKwolPeF74n8t5070BVj7wn+vf4bxUKlAICwkLaA8JDJYcgE1aztAR3 + oMj+1zhq/ROJqGt+Tuu6QXJuOq9b7dbbls2/80/Y8381l/Oy6l+2/iGKTf8Z2bY7kOO6C3k+GbySSKvF + 11JKVTYewHIwV/XS9KL+naju342qgd2oHNjFx7tQ1bcLlb27UE4wlBEGZW07+Tu2MzWwT45tU6kgXwFB + N1SQpvDnwex3IsRK3Dc4gcHRWQWErr5RaoxAYEKgOgiCtBQENGkQGExDQAOBpIJ+BYE4k4AS04ASE4GA + IErwKABQAoDmljiN70ejyYJyRzFNuUMzvjL8VhRIqqHpiwi2YqYdSTySfASIYvaqvp2o4XtQzfelaoCP + dcn7JO9LFd+Tig7+HyaFUkpAIG2UwKCg5S6mLiYvpq8sy18jbPoP+FSuMVjrM1vXL69bdR4AnP/iH6jl + u9Z60jdYP2PPOWv+C+xu/L+QYf4bVv87keNhNZKRflanEh6cWsWXCibVfgeqeZBX0+w1Q7tRM7IHtaMi + xvrxvfx6N6qH96Ca/6ag0Mdk0LMbZZ27UNq+ixF5B1PEDrYImgqi2wiC7TQY1cL2wZ8Lg9eGUKwLAyMz + GB6fJwjGFQRSSsOgRyAwQvMLADS1dQ3R/AKCQZp/AAkBABXXIRBTEOA+2UsA9CDKVkAAEAgmYHP4UW82 + o4z9fUFgJ5MKE4tASoxPcBXHt6MoyWTTxtdAlXfQzJ00toCQ5pbXLK8/9X40jO9B3dgu1Ml7MyLvl8CS + QOghCPheCggqOtkmSGsgbQFbgjy2ArkuAsD619hr/M+obvprvOr4s/UBwl+Blmy3JXXL3VobK3/vWk/4 + RksW4Jj31yEUZp8bsKvz1TlOxlDfXShib1oUuUdVOIm11axcNb07WM14IFO1NHn9GDWxFw2T1BQ1nYE6 + 7usmuKdqxzJQM5zBZLAHlf17UNHNVNC1m8YhENp300S7mAx2EgQ7WVVZaSM7aDqCILgDJb58mHxORFmt + hycWMDqxD10KBJo6CYKOXtEo2ntEAoIRAkAgMIxWgiCpIDDIBCApgBDQU0BMB0CUAGgJtcHubEG9yYoS + ewmr8E7Gez4HQqkgqqmYwCoWcLXuYqKh6fkaKtnyVPVyz/RTPayBsJ4AVO+FaHovGmeo6T1onCQMJnaj + XkAwpKWDGoFoD5MU2wMBQWmSrYCMJQSYvtx3otixEw2OKtjsdrgsFly2b17zM1zXlxSBumzfVKpb7tbZ + lu0bKr8K2stSWAPN9vS18DLjTab0+iJeVAfztOrP2C99qxyotTxg6wZ5ELPKNYho/kaav4mGb+KB3jSb + gaY5aj4DjbOZPPAzUT+VibrJTNSOazCoHNhLw+xFec8epbKuPSjtpAiDEpqrgCAoIAgKIzuZCAiE8E4m + gmKYfV728YOYmD2EkUmCoG9CqZMg0CAwpiDQJgDQIdBKJTsFAkOs/gNKUv2VCIBgpBMOdwgNJhfK7RU0 + Pnt8SSJRSSVaOhE4FbfuVM9PEkyFjHNIohHTD+1F1fBevi5KIDjF100ANs7Ke7EXxvlMGObk8R4YZqjp + 3WhkImhkQhAI1IoGd6JW0kOX1kbI4GBFcC9M3jpYrTKL0AIzwWQxW2G12HHIlqmmYK/1ea7rF5RTALDx + z3Xb3RobrLf92Vdxuu8N139CR4sPITG+bn514YtMfY20MhK3wZPwoKY1W1Wo2v4daBjchQZWugZWuiYx + Pw/8JlY6w0wGjDS/keaXg964jwe+OvizePATBDNZBEEWahUIslAzmonKIVEGyvsIg74MlHXvJQz2oqRt + L6vtbqXCmMCAMZwwyAszOfjKYPe30PQTmF08gcGxfepxZ69AQFN7zxiNP5JWkhBIEAAJpoC4iBCIxHvg + 9sXRZPagwlKLAt9elTzkbxVGJY0wlSTZrjClKBFS5T18ngSXAKx6JAPVo5JwNLBJ6mkg7Axz2us2EoDG + BZqY74NpQf+aIDASkoYJvndMAY1j8j7uIkwJVb63tUxWlUxDxmAN7A4nzDS8yUTzCwAUBCxpCIzYSpnc + fn/Nz3Vd//Vasm/4gayZqVvv5m9ovO1/W3JuemOtJ3vDxGTxgvt2xAIt6sKWkCyAocyfQFiu4otql86q + S2pl1lyyDa52I+r79rDq70IjD94mHryGce55MBtY/cX8Jh7kpn1ZMPOgN+t7Iw9+w3yWBoK5bAWChuls + goAQEI1loWqEIBjOQvlApgJBKUFQ0qGpqHUP+23u43uQr4Mgn9Wx0lMLdzCO0amDWDh4Br1DMxoIqHZC + oI0QaOseJQBGCQBCoJMQ6Bhi5R+Ar6UNJmszqkwGxuxcBRZJGYWxXShKEDz8myXte1UqUVBiSqmg8SsG + M9RzrR6j6cX4k9LqMOHQ/PL6DPL6F7L4HmTAvJgS3wvuTYSBWYAgkJT3i62AcXyXeh8lDdQzBRjbSuDw + Omlwmt/Eys+qLwAw0fyiFQjYFATa7XX41P7Ha3/G6/qvEr32gG69m7/J3UpIpGNrPdEbqSfd9yDSElIL + XUj1V5e5KgCsmF8umFFX0ekX8MiEnXB7DJaBMhh40MoBbOKBbGbklapmYnWz0PDWxSwqW9vvz4KFj00L + OQRBtlKTAkEO6gmCOkpAUDuZjZrxHFSNZqFCQDCYibLeLJT2ZqKkKwPFHVR7BgqTGazQexQEsoO7kOfP + Rp3HgmCiF/OEwOz+U+jom2QKIAR6JgiBcbR2jyFBCCQIgJZYD8yOIGqNdhQ6ipHNPj83xMgf3YXC+G4U + tdH4/FulnRkoofEFRpV8LhVMKVWs+DWSXCYy+NzF9Fk6zDL5eqTCi/GzCT2Kr928n+/FAYrvgRJBYFnI + gIVtgWl6D8yEhmlS3kcafygLzqgVDocHFouDBnew+ttXIKADIAUBC79ntdjUVYZxuwHfdfzpmp/zuv7v + tWTb4NXtd/O3ZdsG46+07+fvftyzDeGWsKr86hp3Vv+gbn51AYx+vX4aAHK9fqtcuNOjTbPt6IOv2woz + Y6+F5rcw+lsZ+62MvVYCwEbD23nA2/dzzxSgQEBTWPblsAISAvM5rJQ5WhqYJQgkDcwQAFPcT+WgmiCo + HMuh6bJQNkgNZBMEVE8WQZBJk2ogyIvsRi4rd3aAbYKniP1yM7oGZnDk9IMYmTqENoEA1dY9zqo/BJc/ + wT7fg1JTDbK9e5FD48v/z48yYSTYcrDtKO3KVNAp65e/m6VSSSWhVD3B50dQiekbxPiz2Wig+ZvmNaCJ + 8UUa/LJgk9d/IAsO0UF9TyDYmAys87thm9vD900gsBeO/kp4m32w2z2w2dzs+Z06AAQEKxAwGsxKaQio + VoAQsDkRcZjwnuPP1/7M1/W3asmxaXnZ9Nt/pNvv5m7L9m//AZ/Qj9Z6ojdENP+jnu0IBUJq5dvUAhfq + CjdG/9RlsOp6eTE/o79ILqiRK/LE+DIHX8226x5EpCsG+1gRbIy0Dprfxqhv58Hv4MHvpPk1ZcLB7ykQ + 6BAwUcaFXEIgl+bJVRBomM1lVRUY5CoQ1BAElWPZGghGcwiCbKUSpoLiriwUMQ0UJNgSRPfSxLuR1UI1 + s0d318ETbMfM4mkcPX0Jnf3TaI50w2ALopLmyXPlIYvAyA6y8tP4Yn6Bify+km6an7ApG8xB+QiTyIiY + XnsutQIpMT+fayNhJfASGQgAE6EmKccixtfNL++Bm9XfRTkJABcB4DrIx2wFHEwBDrYCttlMeDotcHuD + ND7Nb3XrAHAxBUj/74CJacBEAJiMTAGGlRSgIJAeD7DBIRBwWtYh8AuKfntJbpOnW/DmbXDe9o+WbJue + XetJ3ig97t5G84fVNfvp6h+i+UXXR38xv6r8Yn7tyjyZZ6+m3upTcWVGXltPH7zDDQRABlys/i7GXBdN + 797Pr2mClJwCBkLATvNbxTBsCSxMASZJA4RA0wxBQDVQtdM5qCMIqidzUTXBPVU5qqlsKAcl/RQTQVFH + Fgpbs5Afy2CMZ0UP7lHmzvXwd3k8aGULEEoMoM7oRZGlEpn+vTQ+/11VfqaGBNNEayaKO9lm9DBh0PgV + IwIc+Zs5NL88D2lVpNrzuYn5CSoD2xd5zmJ8ZX4Ftmxlfqd6vZrx3TS852AGvGqvfc8l7wsh4JouhD/p + g8cThNPph93hg40JwEoIiNIAkARAGRUAViCQTgL6eIDNYofD7kTUZcGHt3g7sGTduLRk37S81r991Vqy + bQzoFry5G9+QxFpP8IaIlf8p92aaP6iuXZdr2OVKtpT51fXuUv2V+aXnF/NL5ddiv0ynlQtu1Fx7Vn41 + LbdvFD0DE+gbnER33xha+t1w09Tq4Kc8rHieA9kEQTY8lJsV0kU5aRQHTWOnFAikgtJQRhrLqCCQx4jN + NDCdx8orEKARp/IUCCrHc1ExlovS4VyUDOaiuCcHhZ05KGjLQl4sCzlhGpwgyGrZgww/e3l3NSotFmQ7 + c5EZ2MN+X2L/XrYOmcin+QvbmSQ6swgUJgsxv0CGf0PAI3+7lpLn0SDPiRLzS2IRaInMlJVyyGuS16a/ + dqn8Pr5+Lyu/VwFAk8DAfSADvslKNEfDrPwhuFwBAqCZACAE7F6VBBQA2AYIADTJugI2tZhICgIpAJiM + ZtUeCARkPMDlcKPVbcZnzltzYJBFbnnJenMWsLleS46NP1s2b9qgW/DmbbB++z8sOTb8bK0neSP0gutv + EGpuUSvXyAo215o/QfOz+tP82nJZrPqyok6yW11Fl7rCTgAgF92k5uQr8w9NKfUPT1OziPTF4JsvUMb3 + UV5WQ5FPDMG9ZzGHICAkmAKchIWd5rfRQBZWVtNsHsXqSgg00XT1U/nKfLWTonzUTOQTAnmo5L5iLB/l + o/kKAkW9eSjqJgjasmnqLOTGBQSZUBBgGshg1c8MSDogHMIZyOO/5yezUCDm7yVE+iRVECxifkkb6u/l + oY7Qkb+vAYDPSa/8JrYtYn4Blzx3+4KWbJyUhxCQ1+6n8Ztpdj+rvv9gNpoPZcF/iO8BFRg1IMD33esj + AFj9Xe4WdYGRAMAmAEilAAvbALMOAZMOAFlRaFUSWA2B1KlBaQXcLi963U344fopwv+iCICLugVv3rbc + sOm//1VG/zddf4lYs1+tWBOg+a+p/uz9tbXvJPpr5teqv6ymw8ovA36rYn+68vdPoJeVv2+Y5h+h+Udn + MDi2gMHRfUj29cA3UwY/De+n8ZtZCZv5WORjRPaKSVgxNQjkMg3kEgS5sLKymmk0E2WUassU0Ejz1dH8 + AgPZ10wUMJoXoGo8H5VjeSgbyUfxYB6K+/NQ2JVLU+fQ3DnIZRoQs2cFM5DJqp8VYosQ0VJCfms2Cjpy + UMT0UDKUj9KhPAWUKlb+GgJGYCOq49+Uv980k0/lwUAAmAgqCyEgVd9GANgl8ejJRlKOj5LX20LjB2n2 + FkIgcJjvAb8OEAqBQTv8wSS8/iirfxgeJgC3W1oAJgC2AVa2AVarngAIAHMKACoBrKQAQxPNn1IaAvqp + QaYAp8MFr9uHaU/V+mShv01MxbfE7cFpfma/NZ7gDdBHzj9Fq9+jLVxJAKSqf1Af+FPVX18iWwFAVszR + zS8La6jo38nor1d+uSBHKv+K+WcxMLqAobF9GBpfVBqeOID2gTE0T9TRDDzwafwAq2JAjEGjNFMCAS8h + 4GYL4KKJnGImAkAgYKHRzDS/gRW4iWpkNW6g6nUA1ND8VWOEAFU5WkAIFLAlKEBRXx4KBAKdeTS5QCAb + OdFstgRMBNznJrKRx+8XdhEWPaz8A3koH6FG2V7wdwpY5PeL8QU4DfzbBgLAwOciQDLzeVkJAKn6NgLL + IQDbl0uY5ajK7+frk9cY5GsO0fgCgKAOgsCBXAS6m+FrScDjj8Hj0wAgchIADqYAByFgs/vYAngVBFIA + MJm0cQCj0XYNAFYgsOrMgMmSPjUoS5P7vc047cld89j4dRd7/7eX6/75f6fb8OZsy7bf/vavarbfF84/ + QJfPqi1dLdF/Ve8vq9loS15L9dfNn6r+qvLrsX+V+eWCG6n8PWJ+Fftp/hExf8r4+5X5R6cOY3T6CHqG + 59AybEaQPXELIdCizJHNx4SBVEoCwEfze3S5aCo7TWaj2axiOJrPKBWYxm+kmhj968cLUEvVUCkAlDMF + lHNfOlSAwr58FPbmI58QyGvLo+lzkBMjDJK5yO8QQDAt9BWwdchX6UH+fyV/T/VYoQJLLQHQoP4eIz8B + YOLfF0kyETjZWf0dYn5CQMAl5veJ+ZlsWmh8MX+Epo8y8odp/NChDIT2FaClPQRvQCp/XAHATQCkIKAA + wBZAAKDagBQA9BRgkoFAQsDIBGBMtQFrQGAlBeitgN0FD1NAwBfAVfc9ax4jv85atm1w6ja8ORuc3/q7 + S45Np9d6cr+sfur4XUx4atVy1YEAAaCqf8r8WvVX5/xlqi8BoJlfXy5LB4CYX66rl8trxfxyFd6K+Wdo + /nlV+QcFANeZf2zmKMZnj2GA/xYa8CC0P4dVMYvmyEbkQA6hQBAs5ugQoGgoDw3mIgAcNJtAwKbMlw8j + q3ETE4CAoCEFAd20VVTlSCEqRopUCigeZBIYLERBbwHyOvOR15FP8xMG3Bf0FPD7+Yz9WmIoZ3IQAFRR + NeOFqKP56yVtsA0wcC/wEQhZBEjyvPj8nPIc+VzdTCxe7v18/s3s/QVwIXltNH6ckT9+JAtR7iMLpQgk + aHaa30Pzu31ifg0ASgSAyxOC0yUJIKCuQLTaUwnADTMBYJQEoJQCwLUpYG0I2AgSJ1OAGz6PH9FmH953 + /vs1j5VfR8miOsuW3/qnuhVvzgbrxh2/igk/sqjkUXeBWqdeVqltbllV/VOn/WRBSzXyL6vfypLYHWq6 + r2Z+beBPMz/7/t4R9v0S/SdV9JcBv4GROdXvyxx8Zf7JQ8r8Yynzzx3HxNwJTC6cwDC/H+oLIro/HzFC + QBRlEggTAsFFRmNWUf9CLiHAOM0K6yYAHDSdXVIAq7CZxjfQnMbJAjQSAA3s1+sIgFqp2qMEgK4ygqBk + mBoqZLwvQD4rvYAgt5OPaf6iAX6fgBDzlxEYAo4q/j9V/fn7BCyNNH+T/C3+XQvBYyWAbDS/JBO3SEBF + CbD8TAABVv8g4RbRX1eCpk8eyUTiSAaic1Xws71yNTP2++JwUbJXAPBG4fJGqFQC0ABgd2htgMXmYfyX + 6i9yKgioBCDmJwSU6XUINDWaYdCVbgX0FGBXA4IeNDMFDDRb8WPn+upCoiX7xlbdhjdnUwN/9k0vr/Xk + finR/I+5tujmlxtZpuK/3NeO0gf+ZF07qf4S/ZX542J+WT13xfwS/aX6a+ZP9f3TFKu/Mr9e+ScPYiRd + +Y+x8h/H5NxJZf6pfacxvXiW3z+JcE8C8YV8JMQoTAExVs0IIRAiAILspVsIAb+CQB5cAgFWX7uYkDLR + /KbJQgWCRlbrepq2Tio3VU3TV0kKGC5C2ZCohBG/SBm+qL8Q+b2FKOS+mN+T75fx58qpKkKgWv0O/i4C + oIEAEPObKDP/po3mFwg5KdcMwUQ4eSkBlQCrRZ43n3/K/ElW/7bDGWhn9Y9N18AXaYPTn4BbpIyvQSCV + AlyEgNNDCHjCND8BQAjY7JIABABelQBEJpMGAINREoAGAcN1CSAFgfSgoMwN0GcIyo1JZEBQ0uBxX4k6 + RtY8dn5NtGRjy23a+C91K96cTU33XePJ/bJ6x/kfEPR61dr06kYVqvrLuvUrvX/qKj+t+uvmT0r8l2m+ + 0vtL9NfMr0V/9v1S/eWUn+r792kAkEG/iWvNPzF7gpX/JI1/ijpD85/DzIHzmD14gUA4g1A3/9Z8MVrF + MIzMcRooxioaoZkEBC1iLgLAM5vHJJCvQYAJwEqJMUVNNGsTAVAvxqVqaP5qqejK/MUopUoGS1Dcz/1A + Mc0vMGCLMMh/o8qHixUsqvn/ain5PQ3yOwkW40ShMr+VCcBBufj3XQSAPB8V+Wn8ZlZ+MX+YlT96gJGf + r6WV/X4H1UnzJyYa4Qt10OxJKqHk1uXy0viEgFPMrwDABMAWQAGAsjMFKACoMQCPlgB0AKQgYDBIArCi + aRUAUtJaAa0NUCnA6lBjAXJasNkfQKglhOfdd6557Py6aMmxYUS34c3Zlhv+5f9CCn201pP7ZfQDx++j + 02OFX+5TJ+aX6q8DQKq/AoBEf1Z/Wd1WACDVP9X7r5zzZ/Wn+WV1HVlsQ8wvvb9cadc3PL9S/ccPYERF + /5XKL+afnNfNv/+sbv77MH/4IhaOPoDpA/ci3N2H5Fw52g/mIHkgF/FFGkmHQFgq63wefGI4AkAM6KAh + FQRYoS3j+TBybyIAGqmG0SLU0sy1TAHV3FcQAuU0edkAAaCriCAoJghKqXKmg0oCQH5WzF9HcAgA5HcZ + pfLzd9v4twQ8LiYAz6yIz4W9v6STAJ9bkM8zwucrCSZOtbHydzD6dx0l0EYt8Ia74KD5nSl5E5SYXhSD + g1J7Vn9JALIOgYNtgM0RYAJohtWmJ4AUACiD0YEmMb/SCgBWQ0ClAO7TEFApwK5uRyY3KZGxgBYeF51B + P75w/uGax9A3XUzdP14233abbsWbsy05NobXenK/jKTvX3SXqNtSSfUXAIj5AwH2/quqvwAglOr9ozLy + 36lWxFWr5LL6y5p5Uv1lOa3O3jFV/bsVAKT6z6H/OvOP0Pyj15hfIj+r/n4x/nnMHaLxjzyAfUcvYf/x + y9h/4iHMHX4AYVmhZ6aWEChE6362BYsEwb48xBbyEKLJWthv+1l5vRK/pwvgnKIxWZ1FJlZrE01rkMpN + ANTT0LUiVv4qRvwKMTqNX9JfQtPrSYAq4/crCIcqQqKaqicE6keKlfkNCi4FCjICG2V+AkhAJIkkQAC0 + MAEEWf3DBECcAEgyvbQxxXQezkHvkXxEhx3wBbvh8LcRAK2w0/wOml8kEHB4dAB4RFEFALuL8d/Nw8EZ + VCsRCQQsegtgtngoN4w6ADTzy96GJrYATToEGmn8piZKB0AKAloK0C4ZTqcAX4BtYARHmit/LW9AsmT7 + zrRuw5uzLVu//b8v2Td8sdaT+2V01blZuycdpaK/ngBaBAA0vygUJABCBEBUqv+qgT818q+tmKuqP80v + S2up5bZ0AEj17x+R6r/I6L9fi/6ThzEyfRRjuvknWPmn97Hq0/wzBy6w6t+vmf/YgzT/Qzhw8hEcOPUo + Dp1+nN97COHOMSSmTGg/UEoIFCO5rxiJfYWEQD7CYjoxH03oZQJwTxIClJ0AsDKqm2laBQFW8AaauI5m + FlXT4JVidKn4BECZMj/3OhTk32pofgFGA/9vI2Xk75FEIb/XzhTgImx8/LsCoGaCKEAFWf1DC1pKiTGx + JJhc2qiOQwXoPVyM6KAHnpYeGr8ddm8bzU95k5o8CSquAUBBQB7rEHATAjoAbA4NAFamALMAQCUAAoAt + gGb8VAogAJT5qcYUALQEkNLqVmD1WIDcxlxSQDQcxUueO9Y8lr6pUnfRct72O7oVb87G6s8jYu0n+GX1 + qfOPEfO4tOhPyQ0qVfyn+dP9v1R/EaO/KELzy9LXshJuQtbJT1f/IbWeniyrpZbaUuf9ZeCP1V96/7H9 + BMABDNH8w3r1H5O+X2L/4hm98t+rmf/og5r5TzysjH+Axj905gkcPnsFR85dwf6TjyLYPo7YhAUdB6vR + uliJ5GIF4guliMwXITRXgABN6CcAvKzKAgEXAeCQJDBWBIsYlwZuYvxvYPUX1bD3r1JGL0G5AgCTQB/3 + VCVhIP8mSaGeEGgiMAQgK+YvhGuykMApUOCRv93Cyh8ijMJMJVG2J5JSkosFNH8Rn3Mxug9XItTXDDcr + v93fAZu3nRLzt3KfMn8CViYAgYBdGV/b290aAGyU1SUJIEjz6wCwemESmT0aAHQINBnshMBKAmgkAAQC + KQAIDBQQdAjIlGEBgDY70A2PRwYDZQGYCPpDnl+rswKM/4u6DW/OtmzY+M/Z+3++1pP7spIYN+2qUHej + leqvAKBXfwFAQPX/MSaAOIIq/mvVXw3+yc0wBABtqeo/mAaALK2lVf8p9A7PEgALjP+L6CcAhiYOYXjy + iF79T2BMjfinBvw088+ryn8J+8T8NLpUfWX8s1dx9PxTOEIdvfAUDp65glDHJKJjLnTsb0T7Yj1a99Ug + Nl+B6FwJQjNFaGEL4KcpvQSAWyq0QICGFQiY2QIYWc0baWpRHQFQQ5NX0/gVusp6S7kvVeYXQNQzJTQQ + AEYxP/+/hQAQqMjv9RA0zfxbgZkCBNn/h+byESGIYgsFTCdFhFQJ2vaXo/NgJXoO1SLYG4Iz2Aebr5OG + 76DR22H1tCkIWD1JiuanLDS91U3jK8Vo+ihsTAA2FwHANsDmCsFGAFgIALNNAOCj+VMAcCsANKUAYLCh + kcZuUNVfSwCNDSvGTynVCqgLhdTlwi64XB54/WwDWkKIRGK42Jz3a3FWgL5bWrZs/GPdijdnI4FCaz25 + X0ZXnXcur5g/qI3++0PwEwDNqQQg5mf0D6rBP633FwDEBADs/eNykwxWf1k5t03if88YZIFNif7drP49 + Q1r1F/MPjh9U5lcAmDlOADD6L5zG1L5zmN5/QRvwo/kX2PMvHn8Y+1n5D6bMf/5JZf5j9z6Dk/c/Rz2P + kw+8gMPnn0ZLm0DAj679TAP7TWwH6hGfr6H5WGGny9AyVUwIsDqzQntofhflYAKw0sDmkRIYFATY0w+U + opamr+a+sk9TOQFQxe/VUHVsARoJAQNhYR4tZooogp0AkN8ncBHQCHCCBEB4tpAQKiKMSmj+Cpq/Ch0H + atF9sAG9hwxo6Y7Q/AOw+Lpg8XbS6ASARwOAJgLATQCkRQi4pPLHCYAYHxMAAgJCwOoMwerQEoAAwKQD + wEgAGAiAJqOLctL4AgC7AkBjo5YAlAiAhgaTDgNTGgIrKcCuJgY5HC649RQQDkXRFo3iE/efrXlsfZNE + 753SbXhztmXnbf94ybHp47We3JeVjPrHnPZlL/u6FQBI9Q8TAGE069U/kKr+KQCI+dXgX7d2UwxW/0TH + gA4ALf7LmnpdrP7dgzNMAKz+I4uM/wcIgEOM/1L9jzH+S/U/xfh/BlOq76f5D2nmlx5//wnG/lNi/quM + /FLxn8bx+57FiYs0P41/8sGXcPrSKzj70Ks4eu/z8LVOIjISQvcBNzoX7WhbMCMx34jobC2TQBWNWY7m + 8WL4WPk9lJPmdXBvY5Q3EwCGoRI00Nx1rPR1AgGaXyQQkL18r54AaOLPmIZLCI9i2Pk7nASAl9XfR7gE + CIDQTDHCMyX8u+VsR9iWLNSoZNK5v4nPzUzz2xHoSsARHKTxaX5PJ9UBi7sdZqU2qpVfJ6kEzK642lvV + XoyvmX9FEVh0AJhtAgANAkaLBoAmBQAxv0MXAdDEFMAWQFJAgzK/BoDUfnUKEADIikLqbIA+GOiXFBAM + sxjEcSRY/41OAfTd8rJ5w1/pVrw527JjQ8MNfZP5u445s5e9evVXAJDRfx0AUv0l/stNLFUCUACQG1xq + 1V/ugCM3wkhVfwGALJ+t1tQXADD+dw1I9Z8lAFj9R/crAAxNHFEAGJ2m+WdOYpzmn2T1FwDMHZLofwkL + xy5jkebff/oJ9vzS72vmV8Zn1T8lxr9M4z/8Gs49/DrOPfIG92/iyL0vwBUbR3Qkip4DAXTsc6N1wYHE + nAXRmSYmgVr0H21EF6twaKoMXprXxRhvJwCsBICZVd1AczcoADAJ0PQ1rP7VVI0OgMbBUpgICvl5O/+v + QMRNAPgnihCYLFZpIzxbidhsNeFTx78vbYmJ5reh56ATfQe9rPztyvwmbzfMBICZAFByd8DkEvMLBFpp + /CSV4PcEAmwDBABKGgQsNL/FKeYPKwBYHCEavwUmAsBo8dP8PlZ/DQCNBgFACgJ2Gj8FgJ+HwOpxANUG + EAAmo02lABkMVBcJ+QJsEUMIh6NIxpN42/NXax9n3wCx+j8q62zqVvzqt+Wq3/h/sAe5obP+3nP82XKz + 9HOren8lAQDNvxoAcu15C6t/iNVfA4AM/kn/LwDQqr+sly9r58sKurKabmf/5DUA6FMAOIRBAcDUUVb/ + 4xidZfVn7z+5yOp/8KI6vTd/5DL2HX+Eff/jjP4y4MeeX6/8UvVPX3oZZy6/SsPT9GL8R96k3sL5R9/G + mYfegDs2hYIGVqfxALr3RwiBZrTNe5CYdSI2bcbZJ0J45MUIHngmgGOPODB1romxvJpAKIeTVd3Uzwrf + RwjQ8LV9ZQSASANCAyWAsBAUdgLAxQTgZoLwUoGJMgQnKxGZqUVspp7QaWICYTvCJNK16CaQ/Og/0gJr + 0k3zD6Nr7AQB0AOTu0tXJ40uAGjX1UYlYXLS/GnFNdH8ZicB4CQABAKOML+m7JIAWmC0CgDE/F4FAIOR + AGALIOZvaBLpAKAEAPWia1KAplQroE4NGpkCZMEQ/WyAx+NnoQiqNiAeS2I+bPlmnhbka1q2bsjTrXhz + tmXbpq03svrLBzXhKF32uP3p6u+j+UV+vf8X8zcH9ASg+n8Z/RcAyA0vOxGRG2EmGf+vAYAs7yU31pgg + AKbU4po9QwsEwKIGgPHDGJT+f5rmZ/VX8X/fWUwtXlAAEPMvsO9fPPkYo79e/dnfH7vvOZy4/wVV+c88 + 9Bor/xs4T+Ofp/EvPPYOzf8Ov/cWon1HUFAfwraGKpQnmlhtO2m+BCEQIQRakJjx4t4rrXjy1S5ceaUV + j70cxyMvhXH5hQDOP+nG4YdsGDtjQGS+mm1BGRpZ+et7BADcEwaNBICRALAyAQgsPCMl8I2Wsa2opPlr + EJ5qQHzWhOScVSWP9n1eQiiA3oNhDByOM/rHscOVj3yTA67IOOJ9h2BMAcClAcBA8xucbWhytnKfhNGR + 5J4pwEHJngAQCQDMBICSI0KFYbKHYLBrADAwARjMGgCaCIAGVn8xf+MqACg16CmgwYL6epOSmL/+OgBI + CpA2wGpJtQG+a9qA1kQbXvfevubx9nXWkm3D+yi/7R/pVrw525J9w5m1ntyX1Wv2/wi300uKN6cTgM+r + VX8xv+r/U+ZPDwDKve3lfvcaAOQ2WHKbrbjcIktumdUpd88ZYQsgN9WYQEcaAPvQowBwQAFgaOoYhqeO + Y4TVf3zhLOP/ecb/+zAj8f/oQ6r6KwCcvoLDjP7H7n0Wxy/KYF/K/BL5aX5WfDH/uUfexlmqc/wsiurD + 2F5Xi7uthdjhKaH5+tC7v5sQ6ETnQivaZyN48KkBPP/mMJ55fQBPvdZDELQRBDE8+lIED7/YgkvPN+O+ + Z/04c9WL2Ys2tB9uhHeySi1jbmQSsDAh2AkB90gZfGNVNH8Nzd+A8KQR8Rkaf85D2PjQvtDCvx9F34Ek + Bg61Y/BIN5onAtjqyMMWWx7yaUov00qgbQaNNL9B5Oyg8TUAKNH8Rh0CRgJAEwFAGR0EAGWk+Y12qf4E + gC0EIxOAwdpMADABsAVoMnpY+aUFcBECKfPbWfVXAFAv5lcyo24VBBr0NiAFAQGALDcuKUCOHxk8Vm1A + JIZEvBXzUfs3LgUs2TdGdBvenG3Z8O3fVhMQ1nhyX0byAQ06KlX1vyYB6ADwKQBIC6ADoGUFACECIJUA + BADqvnirACA3zpD182UZbVlJt2twlgBY1AFwUE8AAoATBMBp9v/nGP8vYPrg/Yz/lwiAhwkA9v6nGP/P + XFWj+1L9j1+U6v8KAfA6AaCZX1V9Gv/Mw29jaOFBlDTEsL2mEZsthbjbXoh73MXsy5PoPzCKnsUBdO3r + Red8Bx5+ZgovvzOPF9+awgtvjCoQPPlapwLB4yoRRJgIWvAgdf9zAdxHnX7Sj0MPuTBxxoS2fbWs+pXw + DVfDP1rP6G+g+a2ITTmRnPXT+CHCJkroJNF7oAMDB3swfHgII0eHUdluxDZ3IbY687GVkCo0soomZ5gG + xtDo7KT5O9DoaFNqkhTgaEWTnQlAUoA9QYnxNRlsUX4/yseUPcLqH6b5g6z+BIBFEkAzGtkCNAoACJt6 + AqCe1b+eAKjXAaAkAKiXMQArza8BIAWBVApQLYCeAiQBqHEAh7SPWhsQYhsQiybQ1tqON3zfnBSw5Nj4 + k2Xbxt/UrXhzNtg3tqz15L6sXnL85bIM4rhp/lT193q0FiAFAF8aAOz9RSH2/+G2FQDILbAJALknntwe + S+6UowFgVAfApA6AOXRLAhjZrwGA/b8CwPRJBYAxAmBq8T5MHxAAXNYAcEKq/1UC4CkcufAso/+LrP4v + s/d/TfX4UvFFYvzTD72F6aNPoMzYip3VRtxlFvMXY4urFFv9ZajqcmHw0BwhME0IjKFrfhCPP78fb7x3 + FK+9ewCvEAQvEQTPvUkQvCGJINUaxJgGQrj8YpCJoAUPPK/tH3ohSEBE8eCzERy7HMTYcR/N7kFi0ovk + VADtczF+3UbYdLLy96H/4CDNP67Ud2gEeyJl2OEvxjZPEbY48rHFXIwSI1NX6wzM/n4aXwDQjgYdAo32 + ViqpQYAAaCIABAJN9lgaAAa7AIDml/hvDaKJ5m8S87P6Nxo1ADQwAdQ3OZXqxPwCgQYb6lT11wBQp2RG + rQ4ABQFJAavbABkHMMm1ATIO4IGHbUAzjxtZHj4aiSPJNmB/9JszFsDqf0K34c3Z4Lztv11y3Ljbey1T + w/aKZRc/OAGA1gJo1V9J9f9yClADQCCgtQCrARCJsv+PdyMqd8OVu+K2yRmAIXXHHAFAW4/cSCMFgHl0 + KQAcIAAOoW9cAHAcQwTA6BwBsMAEsP8iE8ADmD3yEOZY/fcx/u9n/D907mkcvVeqPwFw6VWcvizV/610 + 1Rfz7z/7PGodPdhTZcedxiJsthXjHmcJtvjKsC1YgYx4DWO4AIAJZP8CehamcPWlU3j3u+fxzgen8eZ7 + x/DaewcVCF58e5KtwQgTQT+uMhE8QRA8qkAQxkOEgQwcPv5yAldebScouvmzQ3jhzTFcfXkMDz45gkP3 + 0uwHe9G30IvexSH+zUnCZxpDh6YwcmQOLTPt2BUtxY5wKbYLBJgEttjzsd1UhnJTVEGgyd2Nens76uxt + 3LcRBK1ooPlFjTYBQIL7GJpsKxBoIgAMtjAVQlMaAAECwK8SQEMaAC7UpQBA1QkA6ln1VeVfDYCVFCC6 + BgByNiA9DuBWqwXJ2QAZB5B7QgoAOto68L7nL9c8/r5WIsSWLRu26Fa8Oduy9dv/+UYO/r3p+PdqyWeX + y6sBQElSgDYA6GMC8Pq0FiCgAyDA+N/C+B+k+UORDgUAqf6RNADkTrmDBIDcPFMSAAHQN4WO/hl0Diww + AbAFGDmI3jQATqwCwHlMLF7EFAEww+o/f4wAOPEEE8CTjP/PEgAv4Pj9L+OUqv5vpo1/6vJbOHLfKzA2 + j2JvpRt3Gkqw2VqEu52l2OItw9ZAObaFK7E7Vgn/ZD/NeJgAOEgAzOPJl8/jg48v4f2P7sd7H57DO989 + gzffZyJ474DeGkziuTcEBH24+qoGgsdeofHZIjxN4z/7Rj+NP4KX357Ba/z51/n/3nr/CN7+4BSTxTk8 + 9txJHL14GJNHFzF0YB+GDx3A2NHDqO6zY3eynBAow85QGbb7itkKFBACBdhhqESVpRWe+CTN34E6GwGg + RADYxPxJPk7wcZyPRTEmA0pSgECAAGiyphJACxrMzWgw+Wl+nwJAXaPE/xUAKOkAqKXxlepofpGeAmrr + jGkAyFhAqg0QAMgdh+wyKzA1DtASYoGIqbMBAoBTkdqv/bwAtt2vytk33Yo3Z5Prjtd6cl9K/EDmbPkq + /qcSgLQAqQTgFUkL4GcCoPmbxfyM/4EgARBqRYsOgLCcAYj3MAH0KQBEmQDi7UOId8idcwkAuZde7xQh + oAGga1ASwEEmAJpw/CjbgOMYmDqJ4dmzBMAFTDABTB18EDNHBACPYfHkVRxg/D984Tl1Xv/EA68yAbxO + 07+pzH/y0ps4/sDr8LQuILPKj7say3CnhdXfXsq+X8xfQfNXYEe0igCoQnWPjwA4jt79R9C7cBDPvXIZ + 3/3kMXzwyWUFgg8+FhBcIAiYCAQE7+7HS+/M4oW3xvEsq7wMFAoIniYQnqPxBRCvvD3H9HCIxj/GJHEK + 7310Ht/l7/rwk0fx8adX8eHHV/Da24/i8tX7sHD6JAaYQLKT1cggAPYmK7ArUo7tgRJsUxAguGz52NVY + h1pbB+yhEe7bqVaCgLLS/NaErriCQL01xlRAWaOEQCQNgCaLDgBTM+qNGgDqDV4a341aQqCu0cm9A7U0 + v5IAoG4tAMhjSQBGtgeUngJS8wFklWEBgJPHkhxDqXEAAUBrawd62tvwhetP1j4Ovw6S6m/bYNdteHM2 + dZcfx6YP13yCX0Kf2P9o2Wu380PzKgCkqr+0AWkAsPqnACDVv1kBQFoAAkC1AEwAsS4NAIk+RBQABhAj + AGIdI+rmmZIAWntWANA5mEoAGgD6J05gcPoURubOYXT+XrYADxAAlwiAR7QEcPIKW4CncOi8AOBFmv1V + nHhQA4CY/8SDbyI+eBJZVS24q74Kd4j5Gf3vdpUx+tP8oSpl/l00/+5YNbLitejcd4ix/Bi65w/j+Vcf + xaefPUOjPomPPn2ceox6lOa9TBCcZyU/iTdY0V95dx/bghlG/VEmgmEFBKn6r767SFAcUcCQn/+ASeKj + Tx/BJ59ewSefPYlPv/cM909T8jeeZdJgknl4HlX9dchMVCgA7I6XsxVgCgiUYqunGFschbjbWoAMmqzB + 1QOjfwA1TAQ1lgRqafw67lMAqLPEUC+i+RssEUKAsoTRSAA0moM0fwvqjAIAMb8PdQRArQ6A2jQA7GkA + 1AgAlNYAgIKApABtYpA2DiAA0MYBZI0ABQB9HCAWSSCZZBvQ0YVHg3lrHodfBy1ZN/5w2fAb/1y34s3Z + lm0bN9/IGHXetm1Z+rZU9ddaAC0BiPk9viA8/hBTQFgfBNQA0CwtQChJaQAI6wCIxHvZBggE+gkBAqCd + AGACSHZpAGgjADoG9lGL6B5m/CYAesZSADiNodlzTAD3YWzxfkweuKwAMMcEMH+CADjzNA6eew6HCYBj + CgBvaJWf5u+fexC5tVFsrq7HHaZimr9Emf8emn9rSyW2R6qwM1pNAFQTADXIIAy8owPoXjiJ7rnjeO7V + q/jse8/rek4Z9rPviWFZuT95iIa9iHc/PIs3PziO1989pNqCl96epvEXGPel6p/gv59jxX8AH33ysPp/ + n372lPpdn30uv/NF/s4XqJeol/G9z1/FuecGMfFQC8JH7CjursEeAmB3nClFIOBnEnBpELjHUojsBiea + 3H1odHURAEnUWsT0shcQaACoNQsEoisQIAAazCHUm1YAUGfwUz6a30PTawCo4e+uqbcr1dbbaP4VANQw + BdQQADW1Ju6lBaD0VkA7LWhWVwxq4wB2yK3HBQBSSBQAWsLq1vDaOEAnJlqDWPqa3k9gyb5pTrfhzduW + 7Dcu/i85voOErV4HAPt/QsDlWgGAhwCQm0t6CQEBgAwANjdTBIBfbwGC4VQLQADEuhFOA2AAUUkABECc + AEh0TyKpADCL9v4FdDABdA0dRPeIAOAYU8AJ9E9qABiZv4CxfRoApg8/gpmjjyoALAoAzj/PPv9lHL1f + A4CYf/rYkyhuasXWKiPNX8Toz8rvLKf5K7ElUIXtoWqaitWfANgdqcFe7jMJgpouH3r2nUfXzCk8/9rT + +N4Xr9GYNOcXr3D/IvUC9TwN+xQh8DDbggcY6+9jlT+ltQXv0/gfHGM6OENA3KtA8fFnV/jz/F3q/8rv + ELO/TAiIXuVj6os38N3PCLKrcey/EsbC42GMPBCAZcaEzGQldkeZBEJl2EYISBK4RyBgLkR+gx8Gbx9q + rG2oNidRY06gmgCoMceV+QUCWhIgBAiAegKgXgdAPQFQKwBgC1DXpAGghgBQ5qeqdQDU1NlQrQNAVC3m + 11NAGgB6AkilgBUAaPMBBABufSCwJSAAkHGAVrSzDejs7MabzV+/9QLUvH/7t/+jbsObs2mj/xvfWesJ + fhm9Yv+P6tytfGAycCPmTwHAIwDQIeDVE4BfzC8JIMAWgNU/IC2AJIBoJ9WlzB+O9yGk2gACgAkgSgDE + OkYJgXEFgNbeWUJgAe1MAF1Dh9BFAHSPHkUvATDAFmBw5hyG5y5gdN9FTBAAE4cfxuzRJzB34irm2QIs + qgTwMo5cfI3mfwP7z72IGkcftlfYcKexFHdZS3CXvQybvRXY0lKN7WGaP1KNnTT+7qhm/gwqi48LYrVo + nT2OTkLnhdeex+dfvIkvvi96A18QBp8TBJ9/IQaWyv00PmRbkAKBVPt3aPz3PrrArx9ULcMn35MU8az6 + +e9/8Tq+//23+Hvkd73O3yN6g3qLAHgHL7xzDkefjBACUex/IkIIRDD9aAixEy7kt8vzJQSChEBzKbY4 + CQB7PraYylDYyH7e3asAUC0AMCVQZYorCNQQArXmKFNBlCCIoM4UpjQA1BoDqGH1r1XV30vzCwBcqG6g + 6gUCDgWAagIgDYFacxoAmlalAB0CkgJk3QBZTFQSgNx4ND0Q6A3wWAmpMwGxaBJtAoCObpyJNXztBgOX + 7N958qbO+5dt2fztPxUSrfUEf2HxA9hvzdQGbRweNQbglDZgNQDcegvgWwGAXwdAc0uCbYCMAbQjGBEA + dCMU60GIEAgqAAwiQgBE2oaZApgA2AJoKWAGbUwAbQRAx+ABDQAjR9BDAPRNnkL/1FkC4F4C4AGM77+M + yUMPMwE8htnjV7Bw6mka/nkcJAAO3/eqki08jV3lHtzZVMa+n+Z3lOFuD6t/cyX7fjF/Dat/DQ1Vy+pf + S/PXIJPKZgLIi7ENGBlF58xFvPD6SzT+u/j+D1J6mwZ+gxLjvsLqLRB4Ro0PfCwg+FhrCwQIH0vc16P+ + ex+8gCvPPY3nX3mJrQDNr4BCEHz/Hep96gN88YP3cfnlUZx6KoZjT8Zw6GqMEIgqCMw8FkH3eR9Keuu0 + QcFgOVOAQICpxlaAbU2VKDWwyju7UWVcAUC1UlRBoNocQa0yf5j7EKu+BoBaQzNqWP1rGjUAKPMrADhQ + VUfz6wCorrXqANASgJK0AKvbAAEApcYB9BSgAJAeCNQAoGYEqglBSbQm2tHR3oXBzrav3YIhy/ZN1boN + b962ZNvgXevJfRn91P47CFia1IflIACkBZDq76b5U/J4NACI+T1qDEAAINIBEGxFIA2ALgQVBDQAhJL9 + CLdqAIgSAPHOCcS7JpEgAFqZANr6ZRzgIDqHDqNz+Ai6xwiAidMKAIOz92Fk4X6MLjIBHHwYk9IGHLuC + eQJg35nncODCSzh07ysI9R7D3vJm3FlfiTvMpdjMyn+3pwJ30/xS/bfpxt+laze/ziQQcgiA3JgkgGrU + d/jRNfswXnzjLZr+Q/zgh5Tsf/AB9R5+QON+/wdiYonvEuOfU4N6H336hF712efT+N/7/CW8/+ELmDp6 + H1uK+9A7d5HgehCvvvUq///7uj6k+T/EJ5+/gXufS+DsM3ENAk/FFQQWVRKIYubRMPrvD6Csr47wkjMD + TALeEkKgSA0K7m5oQIWJ/b+tA5WEgACgykjjEwDVJtlHUG0U81PGECt/C6UlgOpGH+Wl8d2oovmrWP2r + BADK/HaCYAUASnoKEAAoCFwHAEkAKQBoA4GOlQlBcirQH4TcLl4AkCQA2ts70dXVi5cCW9c8Lm9JOTZ8 + ivp//T/rNrx5G/v/y2s+wS+hl+x/oZZz0gDg1s8CEAA6BDzuVQmA5pc7zgoAvM0x+AgAv54AAqF2poBO + ml8A0KPUwjYgmCAAkoOEwDDCbSOIdowj1qkBINm7gGTfPrYBB9A+eIgAOIqu0eNMAaeYAs5iYPZeDM/f + j5HFSxg78BAmDj2CqSNsA04+hYXTz2L/+ZfQPX0/sqsj2FxTi9tNxbjLVo7NLlZ+fyW2Bmtofon/tdhJ + ifH30vgZVBaVS+UTAIUEQFm8FsnJ+/Dym+/hhz/6Hn74w8/wox99yv2H1Ef8nuxpXlbxVBqQ3v7Tz59N + 9/qqVSAgLj72KNonz6F99n50zl1ia/EAJo5cxnc//oC/h79T/f4v8MZ378cDzyd0CCRw6mlJAhoEJAnM + CwSYBPru8yO/kykmXKEgsEUgIOMBcmagnua0tKPK3IoKJoJKAkAgUGWMKCkAUDUCAGMLqpuaaXw/Ta8B + oEoAUO9GZZ2T0hJAVa0tDYAqgYAkAAGAkg6AWiP3Bg0C+jjAWgBwrDoVGBYARBJIJNrQ3qYB4ETC+LVp + A5i6+3QL3rxt2fw7/2TJvvFHaz3BX1h84w9Y9iynAKBaAMZ/kRoHUAmA5vcEIfeZ99D8Xn+E5o/qKUAH + ABNAswAg1IGWSBfVTa0AIEgAhJJDhMAIIu1jiEoK6J6h5gmBfWjtP4A2AqB96Ag6R44zBZxEz8QZ9E9f + YAq4qObyjzAFjB14hCngcUwfu0oIPIPxw1dQ1NSGLZVG3G4sxp1W9vxOVn5vFe4JsPKHJPbXYnuIlZ/7 + vQRABhNAJvfZVB4TQCEBUBwnABJsAwYm8MqbH9H4P6S+oD6nCIIff0LTyvc/YjJ4n4ngHYppQMYHWPFl + fEDMr3p8VvX5kw+idfIi2mYuEwICgIeYBh7BY8++of/e7ys98/okHnoxgQdeSEEgjpNPx5kE2A5ckYFB + tgNMA9OPRhA/6UJGvJKvpRzbmpkE9NOD91iKkFPnRrW1DRXGOCEQVao0rACgyhBCtSGIqqYWKoAqHQBV + DQRAvQeVAoB6lwJAZa2dIgCUBABifovaV9WYuRfjUzXavqbOqE4Lps8ENBIAJg0AFh5TdgJAEoCsIxlq + iaopwfF4qwJAZ2cPBrs72Abc+rcYX7LLkl8bfl+34c3blm3fvhPOtZ/kLyoZ/Y+Ya5YVqe2s/gSAEDsF + ALerGS7Gf9cqAHh8BICfAPCvJAB/CwEQ1AHAFCAQCAgAohoAWhIDCgAhAiDcNoZIxwRiXdOI98wxCUgK + 2E8IHCQEDqNj+Bg6Rk6ga/w0U8B59DNGD849gCECYPTAwxg/9Bgmj16lnkSNcwA7yhz4m6ZS9v2lqu/f + 7K1U5t9K82+j6QUAOwUA1B5KKn+OVH+aP58qjtew+tegMlELY3sLXnrrY/z4xz/BT378Y+5/RP2A+gI/ + Jgx+rCo304C0B5IGfvC2gsAXX7zK1uANfv0W24K3CKlLaJ16kAB4mHoEHbOPo2P6cRy68AJ+8pMf0fw/ + ZFJ4D1df7cGjL7fioZeSTAJJ3CcQeJbtACFwVE8C0g7MMgkIBKyzZrYyFdhBCKg5Au4S3GMvwD3GEhTW + s7pb2lCuA6CiSQNAlSFM84dofA0AlY3NqGzQAFBZ70UF4VFR56K0BPBzAKjRzU9VCgBqTJSYX5IAAUAJ + AFbmA8hAoA1yt2GrVSsqcipQFpMJtmjXBMiVgWogkADo7u3D64G71zw+byURAA/iW9/6O7oNb962ZN0Y + WesJfhl91/4nsKp7vGlzt2UMQAHAKSlAABBQCcBFuQkBr3cFAF4CwN8cJwRWABAgAAIEQCAFgFgfAlQw + McgUMIQg24CQAKB9ApHOacS656gFxHrknv8H0TpwGG1MAQKAztHT6GYb0Dt9L1uB+zG4cAlD+wQCj2Ly + yFU4YvPYXe7DHfXlrP4luNNG87sr2ffT/EGp/rVKOyiJ/rsJhL2Egar8Ev316l9CVTD+V7c2oT5px/Ov + vakD4Cdq/+OfEATUT3T96MeEwI8+JgS+S8n4wLus/m+pVCD9/affe18NWCanHkHr9BNom75CCFxF+/RV + TBx9jv9XoPJjvP/xE3jmjUFcfa1Lg8CLhMALyXQ7cFJvBw4wCexjOzBHCAzcH0BhVw12xdgKSBLwaYOC + m9kKbG+sRHFDGJWmJMqbNABUMAVUNvF7TSGlisYAKmh+kTI/q395CgC1TioFAKrGqokQqCQExPwpAFQS + AAKB9GAgzS9KA6DJmgaAHFMKAL4WyP0j1anAeBvaktqZgK6ePtwbr1vz+LxlJC2KbWOubsGbuy05N15c + 80l+CV223MGoJrd30k4BivkdchaAANBagAD3lEAgnQIilAYAHwHg1QHgD7axDeggCAQCGgCao70UIRAf + YAoYQkuSAGgdQ5gACHdMEQKziHYtMAksItF7AIn+Q0gOHiEEjqN99CQ6x88QAhfQO3MR/bMPEgKXMbz/ + EcQGTyGjMog7a6pp/lLcaSlj9Zfz/VVa358yv17996j4z+pP5RAA+dFaFFIlhEC5mD9J87fa0JT04MqL + j2nG1yHw85Jk8DmNzLbghx/j408+wAcfvIfPPpOxgw/x2fc+IgCuIjH5BCFwhbpKEFxFG/cjB59hUvgh + //+P8NYHZ/Di21NpCDymJ4H72Q5ceC6pksDxp+JqjsABtgL7CIDZx6JwL9qwhwDYSW1rKcNWTwm2yOXN + 1nzsrmtCWaMkgLiCQLlAQAdARWMQ5Q0BlNcTAPU+agUA5cr8TpTX2FFBaQCwUVZ+bUFFtWZ+DQCyFwAY + VBsgENDGAbQ2QACgnQlwpAEgk8qkBVAAkFOBsVY1JVhmBAoAZrpjKo2udYzeClKLfjhv8qIfsi03/eb/ + sGTb+NlaT/IXFqk2acrWVnEhAGQMwG7X4r/DIQBg/E+ZXymobjPtljZATwApAPgCyRUAKHWhOdyN5kgv + /ARAc6yfEBhEIDFMCIwg2DaOUPskQh3ThMA8ot37EOvdjzhTQHLgCHWMEDhBCJxmK3CBELiXEHgA/TKg + Nnkf8uvi2FzZyOhfjDvMND/7/s0evfqHqlXPL5U/Ff0180vfX4vciGb+YqqM1b8q0Yhamr+xzQdTWxiP + PnuOFV+r/Jrhf3qd+D3+mwzkffTxd2l+AuD9D/DOO+/g448/wPe++AITB59GfOKKUmJSU5Ia2PckAfED + fP+Hn+Dt757Cq+8eUOsOPP36AK4oCLSlk4BA4PQzcZwgBI7IRKEnYmpQcIgpILetGrvilWpQUMYDBAKy + xsFmUz6yaN40ABoJgMYwjR9EWUML980oq/MRAj6U1Yr5RS5NNQ4FgBQEKgiAilUAqNABoFRNAKixAGkD + DHoKIAAatLUD5Z4CMg5gsWjHlAAgnQB0AEgC6GjvRndPL/r7B/CJ7z+sfZzeAqLnoroFb+62bP/2H9yo + EVP2NAgaa2BRUU0HgLQAqg2QFkAHgA4BNwHgVgCIUBoAvDoAvASAjwDwsw3wMwH4g53wEwK+cE8aAM2x + ATTHh9CsIDCGltYJQmAKYaaAcOeCDoEDhMBhJoGjTALH0Tp8Cu1jZ5kEzqNr6iJ6Zh5EhbUH28rs+JvG + EvyNDPzZynG3pwp3s++XU35baXg16EftDkrfX4dMKptfi/kLKM38taiMN6AmyYO2zQtjB3vsjg489twZ + ZW4tAVxvfk0/Yoz/6KOP8d3vCgC+i/ffIwDefhdvvPEm3nzrXYwfeBrR8ScQIwBECgRUvw6A733xupo7 + 8NYHJ/HKu4t4/q0JQqAfT7zaqZLAZULg4vNJnHs2gdMyKKjGA7RBQYFA41iTupJxF7U9zFbAX6pmCW5m + CrjbWIT8Wpq8Kc40QPNTZQoAAZTVCwD8CgJltV7KTbkoqf4rACivFvNT1VZ+beHXBMBqCOgA0MYCZCBw + BQBaApDJQA5tMhCPJ5dKAKFrE0BSmwvQ3S0AGMSz4cw1j9ObLVlsZ9n27d/WLXhzN9g3Ft8oAHxs/yOY + DWYFABkEtNvdOgCYAAgAh9PPVmAlBSjzswVwe1cBwE8AyL3pBQAtbUoCAB8B4BMAhHrgi/Qp+aM6AOLD + TAICgHG1Vn+oXQNAiIp070e05xAhcARxpoDk4ElC4AwhcB6dE/fBHJzCrjIvbq8vxd8YWP0Z/e90VOBu + Pfpvl4G/YJ3W91My6JdBqehP4+dTRYz9JTR/Bc1fneRB2+qGoSMMa1cHnJ0DuPr8/Wqizo/XML7ohz/4 + ET75+BN8+OFK9X/v3ffx9tvvEABv4dnnX0S07xzCo48pCCjpIOibl4uBvq8mE8kFRu9/eB/e/OAYXnln + H55/cxxPvd6HK692qDGBS4TAfc+3shVI4ORTiTQEFp+IInbMhb00/55EJXZGtVOD2kVD2pWD2xorUFTH + yM92oLQhROO3oLQ+gNK6ZpQQAKUERCkBUMoUUFpDANQ4UVotANAgUEYAlNP8ZQKA6hQATLqMCgDSBqiz + AelxgFUASM8G1IqKXF8iCUBuIx8OxxCVqwJVAiAAunrR2zeAc21mrde+7ji92VpybDyp2+/mb6RR71pP + 8svoKetfwWiQddx+HgB2BQE/1axBIN0CiMIKAB4dAB6/lgC8gVZ4W9oJAQJAFNQBEO6FVyAQ7YcvNgh/ + bAj++Aiak+MItE4SAlMIts8j2LGAcNd+hLsPINJ7mDqKeP9xJNjvt46chb/9ADJV319F85eoCT932ctV + 9L9HDfwJAFZFf1b/tPkpMX8hJeYvj9Ux+ptQR/M3tQdh6WyDo2cQ7u5xPPnCQ5CpwCtjACvm//73f8CY + /yk+/OijdPV/77338e6777Hyv4XXX38Tzz73Enytx1AbOIzg8KOIjD2BiECA+975q/jk00+YAF5Wswll + 9uC7H57HG+8fVRcVPf/WqLqs+AlC4JGXWvVBwaQ+KMhWQAYFCYCB+5qR21qNvXG5qIkQ0OcHbPPK9QIF + 2GzOxe66RjUoWEqV1LVQAYoAqNUAUFLjodwoqRbzO2l2B6WZX5OYfwUA5TR/OY2fBgCVOiWoxgHkTIC0 + AHoCMBp/HgCSAAQAWgLoQHtbFzp1AMz1JrF8q40DqMG/Dffo9rv5240cADxh2pq+oYNcuWWz6WcBHF5l + frvj2gTgdGkDgQIAF9sAl0DAF9MA0JxkCmiFW0FAA4C3pRNeQsAb7IE33EcI9MMTGYA3OkgQEABMAc3J + CTQTAoG2WbQIBDoXmQQOINR1EOGeI4TAMcQGTiJMGOTXx3E3+/6/birC7Sbd/DLqz+q/hebfSsOL+VX0 + p/Yy9qcAkCfml0E/mr+M5q+MG9n3O9n3t8Dc2Qpbdz9cfeMEAPvxl55QU39/pE7/pcz/E3zx+Rc0/yd6 + 9P8wHf3F/O+o6v8mXn31dTzz7IvwJI6i1L0P5Z598Pdf1iBA9cxdxcefvk/AyMVGclXgU/jux5fV9QTq + EmOBwJujao2BJ15px0OEgAwKCgRkPOA4ASCDgjMPBVHRw9cYr1IpQCWBiCwiIhOEtFmCm435yKy1o6Q+ + pABQTPMX0/wlNH9xjZfyUC4CwKUAUFLl4J4AqLKhtEqr/kpVFu4FAKtTgEkDgEoBMilo9RjAdQCwrQaA + lgAEAEkBABNACgCDg0P43Htr3UFoyb7xVbnuRrffzd1Q/K2/r0Yj13iiv7CcmzBszNUAoG7vrAFABmzs + dq+WAAgAkXM1ANwhOCkX2wABgFsHgIcAcIsCbUregAYADwHgaenmvhceQkADwBA1DG9sFP7EODVJCMxQ + cwi0LxAEi2ghBIJdhxDqJgT6jqHS1oPt5Xb8dWMx+/4SbcKPqwL3+Nn30/xbaP5tNPwO7nezBcig6TNp + fpH0/fmRGr3vr2P0b0JNws6+vxmmjgRsPAAdvaNw9U7D27OIZ15+Sp3a++GPPlMpQPQ5zf/JJzT/xx8z + +uvV/31Wf0b/d995D2+99Tar/+t45ZVX8dQzL8AdP4IS5zyK7LNKrq6LiIw+ga7ZK/j4E7m24C01cUgm + EH3yvafx3U8EAmfVOgIvvzOL594c1s8MaIOC9zMJyHiAzA+QMwP7H4+gabQJmfFKZCSrtEVE5NRgS6lK + ATJBaLMlD1sMhcgToxMARbXNKKohAGo0ABRVs/ozARTr5tdEYOgA0ETzK2kJoKzKiHKqgqqsNuhnA1bO + BEgCEAioQUABgFk7ruSMkqwoJQkgFNJagGRSpgMTAJ296Ontx+DQCN4Mbln7eL1JWnbc5EU/Vm/6bb9/ + ttYT/UUla/9FDZUKAKkrtxQASGu7JADVAjSrFCB7ByEgAHDqZwKclMsrAIhrIgTc/iRczW2EgaidiaCD + 5icAmADcBIA71Ad3uJ8agIcQ8BACvtgYvPEJ+AgBX3IG/tZ5NLctEAT7Eeg8iCABYGwex95yH26v0/t+ + mesvfb9Xm+evJvzQ6BL/1Sk/if7hGmTxcU64Tu/75ZQf+/5YE6O/lX2/j31/jH1/Dxzdw3D3zsDbvx8+ + th7PvvKCug7gR/pA4GeffU7zf8rKz77/mujP6k/zS+//5ptv4rVXX8PLL72CJ59+Hq7YIRQ75lBgn0G+ + ZRp55glYW88RAI+zBZALjN4jBLSZhJIEPvlMksAltfyYLCH20tvamQE1R+CVVlwiAO5Tg4LaTMGjTAHu + WTNyCIBMAQATwO5EBXZGtQlC29yyqGgB7iYEtjdUIL/aT/MTANVifh/3HgWAoioXiquc1AoASgmAkhQA + GP9LK806AGQvbUBqHODaFCAAUAmgUbursNxiPHUWQM4sefzaGICsCaBaAP2CoG4CoLdPA8AT8bI1j9eb + oSXHhh+I53T73fxt2f7bfw7njemRfmz7HdgaG9UYwPUAsKVSgF3GAtgKyDjAKgCI+Z1sA5wepgBvTIdA + Ai4BgL+VYgogANzNBECgk4mgC+6WHrhaeuEiBFyhATjDg3BGhuCOjMATG4eHEPAmZgiBOfbP8/C3LaK5 + /SBc8XlkV4ewubqG5i+k+eUSXy3639MsA3/ahB85358a9d/LvVT+a8yv+n4xv4XRX/r+CKN/F+zdI4z+ + NP8AzT9wFP7eE3j+1VdpfrkO4At8+umneuz/iOb/UIv+BMB772vRXzO/9P5a9X/xxZfx5FPPwRk9hELb + LAqsBIB5CrmmcWQ3MWW0naDZ5ZoCuciIICAEPv++XGH4HFuDK3j/4/v104P78IKcGXijH4+/0oGHX0ri + QX268Bk1XTiGyAErcmn8LAIgI8k2QNYPiBMCamXhEmx1yipC+Wo8YE9tIwoIgUICoKDKi8IqD0UAVGoA + KKp0cG9HcaWWAAQAJZU0P6t/CgBifkkAIgFAaizgbweAHWYFAO3aEkkAAb0FiKoWQEsACgBMAAODwzjf + 5VLpdK1j9qvWku0707r1bo1t2Xpbzo0aJf3A9icwNBq1O7sSAGYdADYdADZ+aCJV/ZUCTAEt3AsEpA0g + ANgGOJkCXN64JgWBVjgJAKe/nY81CAgAXGwDnIFedZtrZ6hf3fHWGRoiCEYIgTG4YxOEwBR75xlqHt7W + BaXipiS2VZjxNw2FjP5F6kKfu2XQz0/zy1V+rP6pU34y4p8yf6rvL2D0l8pfFqun+c2oa/WgqS0EU2c7 + zT/M2D8LDyu/t/8w/AMn4O87TQC8zgTwPRr/Y834jPwffijm10/56eZ/5513VfRP9f4vv/wKXnzhJVy5 + +gzs4QPK/HkWMf8kcozjyGoaQYmV/f0zz+JHP/5MzSRUswe/L2sDvApZMUjODMi6AnJmQFYYkjUGn3yt + hxCQVkCuGZD5AQKBGDqOu5BPAOQQAFk0v7QCGanlxILSChSpRUXvsebiHmM+smnw/EqvAoAGATcKCYCi + Sh0ANL8GABEBoCBgViqtFPMTApUCAAPbAIPeBshAoHZxkCwUou4foAPAaHLoAJAxALm/RGomoJYA1BhA + W5e6IEhaAAHAgYG2W2PJcHkO1m//B916t8YG+0a+m9c90S+pF63/EU2NJh0ANgUAmbV1PQBskgLUgKC0 + ARoA7EwBDgLAISlAASCmAOAkADS1wuHTIOD0d7At6ISzuYsA6IGzpQ8OUZAQCA3CERpWEHASAs7IOKPz + FPvnWbgJAVncY3eZG7fXl+in/EoY/QkAn1zlJ5N9Vkb9UwDIpPG16L/6fL8+6Jd0su9vgbFDBv0G4Gbl + 9/QfWDH/4Fk0953Dsy+/oQy/YnyKxhelB/1o/jffTJn/Nbzy8qt4idX/hRdexBNXnoYtdICxf5rmn0K2 + mN8wisxGAsAygvMX7sOzzz6DH/1QZhLqEPiBNibwmToz8JAaFHz9/SNsBWbw7JvDhED3ykzB5+M491wc + vadoXgIgr7UK2QSArCCkkkBCVhbWILCdEJD7C9xtycW2hhLkVboJAQ8BoCWAggonIaABoEgHQHElEwBV + XKmlgBKaXwFAWgACQMYA1DiAngC004HXAUC1ljIP4FoABNRZgFUAYAIQAKhBQLYAUyPD+LHrD9Y8Zr9K + Ldk23PxFP67fYNswvNaT/TJ6yPzXaFwNALM2bdNmZQoQACgQEACqBdABICmAALC5BAAhgkAgECUEdAB4 + EzS+6FoAOP2dcIiau+FgCrAH+mAnBOwtA7AFB2EnBGSlW0d4nBCYgCMyBVPzKLIqg7irphK3M/rfaS7W + F/iowBZG/9RVfnKFn4z4i2TgT2b7pc73a6f8alTfrwb9WpthaE/A2s0k0svE0b9I8x9h9Kf5B86gefAC + 3F3n8MiVl9PVPiWp+qnTfavN/9prjP5i/pc08z/33At4/ImnYGlZRI4y/wTNP4ZMxv+MhmEUmxlzL1zE + gw8+iKtXr9D40g5o1xN8//tv43ufv6JOD8pqxG9/cBqvv3cQL749jWdluvCrnXj05SQuMQncRwAMn3Oj + hH1/AQGQ2yqtACHAx7KysAYBtgIBub9AEe6x5eFucw521VUjt0IgQPOz+qcAUFjhoOwoqrARBCKrDoCV + BFAq1V9JEgAhwP1qAMhKQSsAsKkEYOXxJGNKcll5ahAwHCIA4tpU4OsBMDY+iU/9N/meAaz+y5YNlbrt + bp1tybnp5JpP+EvopPEelQAMspSzGqxxqhFb+cDS5qesak6ADAQGCAIRUwABYHdSOgAcBIBTB4Cde7sv + qQBg91K+dj7u4J4iBOz+btiae2EjBKyBfthaBqkhWFsIgfAYK+e4UkF9lNHfgL9pLMTtKvqXsu8v18yv + T/hJAUCMr0b9xfzcp075FatTfg2oZt9fJ4N+7XH2/d2q73f3zcPTd5DmP6ab/zyc3edgiJzEQ0+8rCb3 + KNNfZ/y330r1/G/o5n9FmV+i/3PPPc/K/hweIwDMgX0/Z/49dYMoMg3hnA6A+++/H4899gi++EIuKiII + fvABgfAOIfCyWllIVhPWxgP2q6XGtfEAtgLqysE4Ju/1oIyRv7CtEvkEQC4BoJIAH2fy+7Kw6K5QCXb4 + irDNlU8I5GKLKReZrOR5FWwflJwKAgU6AKT6KwBUaAAoZvslCSCVAlIQSM0HUClAzgLQ/KkEILcUb5QE + kDqeeBxpANCuBZAEoC4Gau3UAEAgrwbAW+Ftax6zX5lk0Q/Txv9Rt92tsxEAV9d8wr+oSLgFwy6VAFJ3 + c1HXbq8CgDUNAZ+WApgAbJQAQBMB4JIUEIGdELB7YoQBza+UgM2bVACwKbVTnZp8BICvB9bmPliUBpSs + hIClZYT7MVSY27Gn3InbG4poflZ/SzGjv76qb7CKxteW99pFw8tFPqry65f3ygIfhTLTj0r1/dqgX5jm + 59/vHoKzZ4rml75fqv9JVfntnWfRQPM3BI/j0mMvKsOnJcZ/5232+9q5fjG/xP6XX345HfufZ+UX8z/z + 9LN45LGrTDALNP+Ebv4R7Kkfwu7aARQaCYDz9ykAPEAA3H/fRTz80CV89pksFKJdZiyXFX+qBgUfx3sf + 3Yu3Pjiu5gc8++YIrrzahUcJgMsvxjF9rxsVrRUobqtCASGQR+W2VSCb+0x+fy9TwJ5YmYLAToGAkxCw + ZmMrE1U2TZ/H91gBoNyhAFCgJ4BCmn8FANICEAIVhECFEaVUGgCqDZBLg1eNATRodxJeKwH4FQCiBEBC + AUBNBGrvVgDo6x9UABgfn8Lzsfy1j9uvSEvWTT265W6dTfqRJfuGt9Z6wr+wnJswashWAEjdzEHWcU8B + QIMAq78OASshYLX7FQBsDi0FKAA4Q7AyBdgIAaskAR0ANgGAOwGLJ8nvs98mACzeDgUAq6+Lj7thJgQs + /j6Ym/upAWqQVXMY9a4+ZFc2Y3NNGe6Q6K9W9S3F3d5ybAvIYhj6op6s8nu4l8U9Utf357HqF7LqFzH2 + a/P8tb6/sS0IUwdB1NVP84+z+u8jAA7R/MdZ/c/B2nYKtcGjqAsdR33gGB545Hl1YY9M7pGKLwN9UvXT + kf8Vred/8cWXrqn8zzzzLJ566mk8/OgVGPxz15h/V+0gNYB8wwDOnr93BQAXL+K+e/n1A/fjk4+1qwnV + 5cV6K/DhJ4/gHRkPeO+wunLw6dcH1fUCD7+UwOQFF6po9BIavpgqpPnzqRx+L4v7TCqjTSBQip1sBba7 + C7DVzhRgycauesKCxs9LAaDcrlSYBoCFMqsEUKzMvwoAIhkIlOqvA0AGAq8BAFOl0aQdTzKpTNaW1BJA + FBECIJFo1xNANzq7+64BwBPtddog3FrH7q9Ycpp92fbbv6vb7tbZ5FJE2BlN1njSv7AIgK6mfH5YhjQA + ZBzAJCnA4tIhwBQg0lOAAMCqA8Dm0ABgE+kpwOaOwuqimASsAgEBACUAsHjaKELAQwAQAhZvF8wKAr0w + EQImfz81AIN3AAV1UWyvbMTtjXm4I3UvP085tqolvaX6s/KzuqtFPWn6axf30Ob5q8U9ZLJPUpvsY+zk + c5HJPj1j7P1naP4DWvQfPAtT8gSqA0dQEziqyXcYFx96Rhn+rbfe4v5NvEnjv6FXfTnVpyI/zf/C89Lz + a+Z/+ulnlPmfvPoULj/8OJq8MyuVn9FfzL+zph/5TRoAHnjggTQALt57H+69cAEX77sXH34o6wrIHIG3 + 2Aq8xFbgSbz/8SWmgFPpi4aeeq0Xj73SivFzLtTQ5OXtlSjlvkiHQEF7BdMAkwD3mW1lCgC7wkwB/kJs + Zyuw1ZaDLeZsZFY1KQjkK9mVCnQAFJYLACwaABj9i2n6YrZk0gIoCMgYgGoBrgOAGgOwqVOAqRZAAKAS + gFwMFIwhJAlAB0BHR086AQwNj2J8YgoP9jhvJgDu0y13a23L5t/4J3xyP1nrSf/Ccn4HMcbrhgZj+tbO + cipQAGBWH5oHlhQEpB1IAUBpBQIpANhckgJ0ALgJAHecjymVAggAdxvM7naYPR0KAmbK5OlWMnp71fr2 + Bl8/yo1J7GUMvZN9/x3GAmy2yL38SrDVX4HtjP47I9XK/Hui1WpdP7Wir5ifKmDVL6LxS6mKeL26wq++ + 1QtDRxQW6ft7RuDolegvA39HCYDTMMSOocJ3EJX+Q9RhVDVT3oO499LTqtq/8cYbeJ0V/7VXtXP86jSf + XvVTkf/ZZ641/5UrT+LyQ4+i0TNN8w/r5h9U5t9R3Yc8AuDMOQJAN7+0AJIALhAA58+dx4Xz5/Huey8r + AMipQVlhWG4l9u6H9zIFHMVL78zh2TekFejG4DEbatvLUdlRgTKBAA1fwseFAgAqh8piAshMlmFvvBS7 + Q0VsBQqxzcUUYMvGNkMecmn43DI72wEBgE2pQAdAIc1fWC7mlxRgTCcArQ3QBgIrZXEQQkAWC03dSVji + v8GonQKU40clAE8Azc1hBINsASJJAkAbA1AA6OlD/8BQGgAXBkLqGF3z2P1VSgb/bBv36pa7tbZl66b/ + c80n/WXEFxqoLyOtDQoAKgUYtdM2AgAxfwoAFj0FpCBgWQUAq4gQsKpWIAKLk62AKwYLJQCQBGB2Ue5W + SoOAydUBk7sTRncXAdAFg7sbTZ5e1Do6kVPpx9115bjTlI+7rUXaXXy9Zeouvjsj2s089sSq1Vr+yvzc + y6q+yvz8fmm8Wq3sU5U00vwumj9E87fD1jMIZ98ko/8CzX8IXvb9DZFDKHMvotxzQKmCxldy78f5B66q + qP+qRP1Vxpdef3XVT0X+J598GleV+a/iiSeewIOXH0a9e/I681NVfcht7CcALuCBi3r1v0+r/qIL587h + 3JmzOHf2LNPH82osQG4iIhD44JOH8fZ3z+G19w7hhbemmQL60bHfhnoavrazAlVUOR+XUkU0fr5AgI9z + qOz2MmS2liFDIBAswg4fU4AjG1stWXyOlcgRAJRp5s8vtxIAFrYDNL8OgCKBQLkGgJVxAA0A14wBsPpr + ALBrADDLaWVZYr5Z3VnKHxAAxBCNJlUL0KrWBOxFtw6A4ZExTExM4/RI+01JAOo+G8X/9B/qlru1tmXn + b21Y60l/Gck0YG9dBQGgJYAUAIwyIUgAQHJbLISASCUAL/eUAMAmKSCgSUEgSOMTADS/AMDCFCAAEJmY + BAQAJleSaqXaYHC1w0gIGF0aBJpcXWh0dqOoNoQdlU24y5CPuyz5apmrbX45l62bP1alzL+XZs/iPofK + o8T8qTX9KhI1NH8j6lodaGoPwNyZhI39paN3TI36exn9Pf3HUBvaj2LnAkpdi+qCnVKCoIzGL/NQzkWc + ve8JZXqZ1puu+M+/kDa+Mv/TuvmvivmfVOZ//PHHlR548CHUuSb02D+gmZ/Vf3tlL3IaCIAzAgAx/0r1 + l8p//uw56izOnj5Dncbrrz/LFPAaIfASPlKtwANsBU6zFTiAKy8NIzxhRWNXFeq7KlDTWY4KAYAkgY5y + FBEIBdzn8fu5fCwQyEiWYk+4CLv8BdjhzmUroEEgS1qBUqsCQF6ZmF8HgDK/+W8FgLogSJlfWy68LgWA + JjuPJy0ByBiSAoBPA0CIAIgwASRSVwIKAHr7VwAwOY1j4/1rHre/ai3ZNgV1u91627Lltj+8UVT8GeUk + +SUBpO/tbtAAkJq9lQaApABCwGz1wmzzKQBICrCsBoCDlZbmNzsEAlGYnTEYHTHuNQAYnUlNhIDBKRDo + 4L6TEvN3qdVrMiuc2Mzof6eZ1d9WiC2uUmwLyLlsOZ1VpS57zaSyCIJsmj2Pjwuo4gQrP6WZvwG1rRY0 + tvtg6ozR/N3s+Ufh6ptl5ddG/Wta9qHIPqdU7FhQIChx7kMJYaBkm8epC48r00u114y/Evel6kvkl6ov + 5k9VfdFjjz2GRx99FBcfuIRa5/jPmX9bRQ9y6vsIgPN69L9PAUCr/hoAJAEIAE6fOk2x73/lSXz2hZwW + fBbf/eRxtgL34Y33j+Ph58bhHeTn1V2Phu4K1BEC1VQlzV5GlXSVo5jmL6DydABktZUiI1FCCBQSAnmE + QA622TOxw5iPPLYCeWXWFQCUCQCospUEkIJAOgEoAND8lNw6TFoA6f8lAQgA5PiRi8pkZWkZAGwORBQA + ogRAMrEyC1AAILMAR0bHMTk1g0NTo6pIrXXs/qq05Njwk2Xbb/8r3W633rZs3fjvbhQAfmr/Dux11air + a1IpQACQWstdruCSwRuJb/IBmpUIAMrCNkAAYFYQCFAEgJ0AsIdofooQMBEAJkdUAcBEAJicCTQ5KALA + 4GzlY4oQaHS0c9+BWmsb8quasaW2AneZ8tQKt7LS7fbmMshyV7LYhQAgM1GFLBo+h4/zqAKqSDd/ZauY + vw61bSaa3w1jZxiW7g5W/iG4+qf1CT8H2ePPodA2reboF9rkMUUQFNrnFQyKBAjWOZw8/6jq8VXFp+lX + G/8pMf6TT6WrvhhfVf7HHscjjzyidN/9l1BjH1Pm387YnzL/tvJu5NT14jQBINFfAKDML9V/FQDOnBEA + nMKpk6dw8sQJvPjS40wBL+KjT59mCnhItQInH5IBTaazPqa3nho0dpejjqqm8SuoUhpfAFBI5XeVIZff + y+4oRXZbCd/LYuwlBHb787HdlY3ttgxk1FerBJBLAOTT/PmlZkLA9F8FAFkjUG4emgKAGgA0aa2kzCFx + uwPw+UMIEAByCjAaXb0WQN91AJjFwZlJLPEYXevY/VWJ8f+wbrVbc1u2bvqLGwWAn9h/B9baqjQAJAXI + QKBKAdcDgB+iWY0FSAKQVkAA0AyTVVJACxWEWSkEowKBDgC7BgGjIw6DAEBkT9L4rVQbGpTaUVIXxK5K + IzYb89SVa3IvfLkR5s5wOXbHxPyVrFqs/joA8vi4kCpOVqOMqqCqCICa1iY0tLPydBJM3UnY2Ve6+ydp + /gU13bfSJ1flTVJTyLdOUzMoUBfrUARBWqZpHD/zsDJ82vSM+iLp81cbP1X1H3v0MWX8hx9+GA899BDu + vfgAqm0jbGmuNf/Wsi5kCwBOn8N90vunqr8OAOn9z9L8Zxj/VwPg+LFjeO75R/HJ957XU8CDGDw4CM9A + CM4BJyHQBGNvJRp7ylDbU44qgkAgUEaVdJehmCrk9/K5z+sqRU4HIRAvwp6WAuz05GK7PQM7LJnIqzSx + FTAjj1oNgMIyzfzXAECdBdATQK1292B1CrBJGwA08fiRMSQBgNxVSgCgzQGQacD6AGCbdgpQJgEJAEbH + JjA1PYcDc7P4qePfrHns/kpEXy3bNtyuW+3W3JbtG/7qRgLAUqslgLo6rQ3Q7u2uXcKpncK5LgHwwxQA + mK0+yq8AYLKxz7a1KACYbCkIhKmIAoDBHlNqssfRqJREg8hGEQCydn1upRv3NBaotezkwhW5ln1nsJTR + v1wzv7rQpUpd8JJHCORTRVQpv65sq0JNWw3q2hvR2MH00smE0h2DvbeHsX8M3gH2/QMywDeprsbLNU0g + zzxJTal5+nlyma4S4UAQyD7POIUjpy6lTf+kqvYrxr9y5Uq66qeMv9r8ly9fxoX77ke1dRjbK3TzV9D8 + BMAWAiCrthunThEAevW/93wKAKuqPwFwSgHgJE4cP64AcOzIUTzz7CW2Ak/j8efOIjY2CP9IK7xDATgG + rLD01RECFQoCdYRANVVJw5fz61KqhCqk8pgGBABZySJkRAqwN5CH3e5s7HBkYo+hiPHfpsx/LQDWSADX + AaCu3op6Vv/G1QOA7P/lQjIBgD99BkAmAemnANt7NADocwBkFuD0zDwBMIeffoU3CmHv/yKKf+/v61a7 + Nbdl67f/8w0FQE0VamsaVwAgYwEqBQgAbCrCyYe4ugUwMQWYBABMAMZVADARAAYFAQJARAgYbGE02SI0 + vwAgpgHAlqD5RUnUWRMorG7GToJoszkHW+yMo74iZf49NP/eRIW6sEUucBHz51L5VBG/Lm2tQkVrJaoJ + gNr2WjR2mmHq9sLaE2Hs76T5h2j8GVbIRWX+HMMIcoyj1BhyCIIcgkAu0hHJfH1RrlyySyjkNE3g0IkH + 1Cm9q1dXDJ+O+mJ8vddPGX+1+RUA7r0flZZhrerrlV/Mf09pJzJrunHy5Jl0768AoMf/lepPAND8Uv0V + AI5qADhy6DAeu3I/Jo8dRmh8FMGxXjSPxuAZotEGTDD3V8PYV4amXkKAqqbhK3tKUaYDoIhAKODX+d0l + yO0sYjtQhMxoAfYEcrHLk6kgkFPfoMYBUgAoKDWisNzANsCwAgCZDrwGALT+36EmAGlXAfrUilJyV+lU + /68GABUAGP87etUpQAFA6hTgzOw8Ds7PEwBf0Q1Dtepv1G12627L9o1/eaMAIGMA1poKAqABdbXSBqQG + A7WlnCQBqA+RADDxg0xBIAUATRoATFZKIGCldAAYlAgAJoFGK2UjAKgGWxz1VlECpQ0tyKy04G72/Vts + edjuLlQXruyKyDnrcmTIxS1UDk2ex73MdS+k8Yu5L+f3qtsrUdtRg/oOxt8u9ps9LXD0tcHZ3w/P4CR8 + gwso94wjq3EY2U0UIZBtGNVEEMgVepom0soy8OuGURw8fjFt+rTx2eOvVfFXG//SpUu49OCDaqpvhXlI + GT9V+cX895RoADhBANx7gQBYZX41+HdN/BcAMAEcWwHA4YOH4IsMwBAcQmRyGuHxIUKgE80jYULABcdg + Eyz9FQoCjVQKAhXcl1ElvaUo0lXQIxAoRnayEJnhfOzxZ2OnKwO7rTnIr5QEQPOXGTQAXN8CKACY1ArB + qduGKQAw/jcSAKn0KBPIZDk5ry+o+v9QKK76/0SiIw0A6f9Tk4DkDMDs3MJXCoAlx4Yvls0b/lfdZrfu + Jtcm3ygAyFkAR005aqob0imgXm8D1P3d9TZAICAfpsns1mQhACwaAIzcSwpQSYAQMBIARrYBCgBWDQCN + ShE0EAINVgKAqicEqo0R5Fd5sKO+BPfwgNvqzMMOfzF2h1n943LOWiawiPm1+e0yz10ueClRs96qUEXz + 11D1HfVo6rLA3ONj7I/D1d/Dyj9K88+z8o8js2GAGtTUOEQNI6tpVEmm6a5oDBmNo5rqhrD/6L2a4aW/ + X6Pa/23mf/CBB6kHcO7cvagwDV5T+e8p7SAAOpBZ3cV4TwCsMn968E9G/wUANP8pVv+Tx5kACABlflb/ + cOsodpZEsLWICSs8hNjkJCITfUwDSbYDrLRDVtgHa2EZKIWxvwSN/WWo7StFNQ1fxX05VcrHxdwX9pYg + v6sYue2FyIrnIzOYgz1eQsC5l+9PhToNmDL/9QBQqwLJHAC9+tfUWXUA2NFk1I4ZmQCkDQBq/b9cBiwA + iLH6a+sAsP+XpcDY//frA4ACgLn5RRxemMfPHL+75rF7o7Vk2ziuW+zW3tgC/NsbBQA5xeKuKdUAUCsA + WBkMVHd3NchcbjmV41wFAQ+MlMnspflFAgE/DJZmGl6SQAv3IrYDVBMh0Eg1UPUEQL01ijqLKIaS2mZk + VDdii1yY4sjFDm8BdrUUY2+sVF3KKnPYZRabXNgic9uLaPYSfl1OVXVUoK6jEg2dNaz8RkZ/Vpq+ICt/ + Oyv/EPxDM6j0jSCjvo/qRwYhkEEAaBqihnXJz3Bfx3Qge35vr6hmEAuHz61p+pTxU6ZXxn+QxmfVF+OL + ZIbf2bMXUG4cwJZSzfx30/gCgLuL27GjrAM9Q/tw4sRpNeinpJ/6S8d/Vv4UAI4dPYrFxUPwhAaxszhK + 82sA2FZE2EYGEZ8eZxroYRKIwj/qgXvYCPtQFSyDhMBACRr6S1FH1VCVfSUoJxhK+biYjwv7ilHQrUMg + koeMQDZ2uZkC7BkoqDUSANoA4JoAYPxfAYB2BkCqf5M6/+9W8T/V//v8YW0AUO//k8lOtMsMwK4+BYAB + 9v8yACinAOfn9+PYwtxXchpwyb5pedn+7T/VLXZrb3KBwlov4kuJIGmuLf45AGgpQFvXXUsBWj8nADAy + ARiuA4BBSYeAJaAA0GRJKagA0GghBCxh1FsiqDNHUdnYwojpxLYmmZOezeifj12BQuyNljDylyG7vVzN + XsvrKFdz2ou4XzE/U0tnOeo7K2HoboCl187K3wLXQCvN3w//8BSq/TR2XS8lANAgsLd+QNegJpp8b+0A + KmxjCHbux8DEUf6cNmtvV1Uf5g+evcbwP2d6PeprxtfML8bXpvfejzNnzysAKPOL8QkAMb9oc1Eb7i5o + RWFjDwLJKYxOHcShwyeU8c8w+p8+yfhP80vVn5k9gFj7BIoa2rClIIItNP89NP/WohABEMLWwhaYY4NI + zIwhOtmO4HgLIWCHa7ieECiHdbAEpqESGAaLUT/Az5tAqKI0CJSgSCDQW4y8rkJkJ/KQGcrBbl8mdrv2 + ItNcpK4FuB4Aqfgv6wPK/QKraf5aGQBs0OK/0aS1jDIAKPHf4w3C3xxBIMT+n/FfANAqFwGpawCuHQCU + MwDzCwdwcm7yq5kH4Nj0CJzf+ru6xW7tDc4Nv7Xmi/gykmsB6vIJgPqfawNSN3eUsQBJASkICACa9BRg + JAQMCgJifg0ATUwBTYTANQAwB2l+JgCzBoAaU0itRruntpp9fxa2ORk5vflqempmopSxX0aoyzXzUzKb + rYT7cpq+qkub7NJANXXXMvabWPl5kPXHaP4uRuBR1LWwktd2Uz38G73YQwgo1VI1hAFVZBiCMzqDifmT + OH3uojL08VP38mf61cSdnZW9mN1/+udMnzL+atOvNv7K1N6L6jx/qaFfGX+zSDe+6K6UCpK4Kz+B7UVJ + ZFd3oNQkU6KHYPQOodE9gJImtgvlSWwtiNL8VBFVGKZCVJDmF7VgW2EzbMkBJGaHEJ1KIDjhQ/OYBZ7R + WjiGS2EhAEwEQCMBUEfzpyEwUIRSqri/mBAoRH4nIRDPRWZLFnZ7mQKcu1FQ36BmAwoAiijV/+vml7sE + Sf8v8V8AIPG/0aAVC5k4JvFf7ivpYf/vVwOAcQUANQCox//uHvb/q64BmJ5ZwD6mnXMzw2sftzdSMvhn + 3Vik2+vW35Yt/+qfLdk2La/5Yn5RydWAdVkKANVV9QoAtbVN7OO0FKAgoC/qoOZ1CwBMbt38Hn5NEQJN + Zh+NTpn93BMCAgBzgMZv0RWk+UOs/GHUmsLqppR51VZss2jm3+XLw95QoTJ/TkcZcmXSikxe6dImschs + Ns385cr8MtnF0FMFc28T7H1OuAdD8A61IzBC04QY72s6qS5W926KEKgSdSO3oQ+WwAR6xw7j5OkLWgXX + JcY+cuI8dlX3qrn6Oyp6MLN4auVnGPFVtVem141/v6aVqq8ZX9N9OHXmHA3cd03VTxtfqRV3FbbizsKk + rgSBEMfmvJjS3flUAVUYZcWPUdynzF+gAWALzS8A2FrQTAj44WjrYRLoIgQYtydc8I81EQIVcIwUwzZc + BNMwIUAQ1FE1Q8Wo4r6cKqGK+4vYChQiN5mH7HA29vozsce1B3stuSiusqBoVfwv1VcHVtW/1ooamr+O + 1V/r/7Xqb5X5/4z/6f4/ENUGAGNtagqwAoDE/16t/x8e0fr/mdl9WNx/GPdPdaljdM1j9wZpybHxw2Xn + b/w/dXvd+tuy87Z/vGTd+MO1XswvLNJvtH43zV+3CgCNjHMGQkADgNzdRQFAUgABYGC0M+gQkCSgAGAS + CKRA0EzDiwJo0AHQYGpBvSmIOlb+akMLiqvd2F1fgu22TOxwEQD+fOyNsP9sZR/aWapmrBVSYvxSmczS + XYpq7uW8tpzflvPc5r4G2AdscA02wzecRMtoHwxR9vnK/FQ1VdWJ3Jpu1DqH0da/DwePnFbr8IlZlXl1 + M4uxxeSHj51l9O/Bdpm4U9aN6X0n0v+eqvTXV/u1jK/N7ruXkDmLksbenzP+nTS9mF+ZnglA29P8AoAU + BGh+0d35Ue4Z+Rn978mn6fMY+/ODFKt+XgBb85o15fuUthd44ensQnKmnRBoQWjShubxOnhHy+AaKYR1 + pAhGQqBhqAh1BEA1jV85WEQI6Emgr5AQyCcEcpEVEgjsxW73LuQ3VWnrAqT7/1UAYPVXAFDn/7VjRIv/ + cl9JLf5r/X9MXQEoE4C0dQC1/l/iv+r/RycwMTWLOfb/+w8cwcPj8V/51YBL9o2turW+Hhuc//QfMgF8 + tNaL+YVFACw2bkW1ngBSbUCNAoBRh4C2tlujQTu3Kx+uEF4g0KQnAEMKANw3MgVoAGim8TUINEgCUAAI + oqzOizzGx+2WTGx3ZGGnLwd7ggXIShQjp70EeZ1lPABZ+bvLUKbMX4YqqobGb+jVzm2b+6tg6zfQ/G54 + hyM0fxcsyX6avg0Zle3IZJSusvYh1MZqMn8E586dV4bUzHlR9eeitJEVDB7AoaNnWPm7sK28B9tKuzA1 + f1w3/PURP7Wn4dPm14yvTutR9124oM7zFxMAq42/opT5E9zHcWdeHHflRHEXK/9WVvuMilb2/O2otffC + 5JUVlAcQiA8jmBxBtHUYkeQQQvEB+CN98AZ7IWstNMqZFUNU3f03MdKNjnlW2ykPwhNGQqAK3rFiOMeK + YKPMTARNhEE9YVDLZFA1XIgKQqFsqBBF/QVMYHnIjeWwFcjAHs9u7LVnoKRGWxBEWxlYawGqpPrX2VCr + V38BgPT/Kv47/XCy+nt8IdX/Bxn/1SXAqv/vUv1/T3e/1v8z/o+NSf8/jzn2/wcPHsPVIa86Rtc8dm+A + lmwbf7ps+863dWt9PTZ861t/Z8m+4dW1XtCX0dmm21HFBCBKpYAaGRCsN6C2TloBWd3Fgnp1blfinUN9 + yBoE9DZAACDmNwoAfAoCDToA6qk6PQFUNfnV3Wd2NxViuz0TuzysMC35yIwV0PxFyOsqofnLUNRTyspf + qmavVdHwNb2laOgrg6GvlOYvh22gDs5BK83vR2A0CRujZG5NK0oMnfCERzE6eQCHjxxXp9Pk1JqcZpPJ + NmJKBQLqft2wYmKRGPrg4VPYUd6Jraz+W4s7MDl3TKvyutnF+GL41RVfpvLK70xJTekVndcB0NBzjfHv + kD17/jvzEqzscWwvjBNabQRWD7zRUXQPzmFyej/mFw4yBh/CoYOHcfjQIXXu/9CBAziwyOq4bxEL8wuY + n5vD3MwMZqanMTU5ifGxMYywksoddvv6+/Hg47O4/6kBHHogjMFjZsTnKgiCIjhHi2BhGjCOFKCREKgj + AKpp/kruSwcL2QoUMIHlIy+Rg6xgJvb6dmOPcxdyjUxkamFQs1oZWG4XXkUJACT+p44LOVUsl4075K7S + nhZ4Wf2bJf6n+n91ARABJRcApfr/kTH2/9OYZvxf2HcQBw8dw4vd9WseszdK9NEZ3VZfr4190SNrvaAv + o8dN/+kaAEgKqFZnBZoIAIGAfpMHqlERnmoiBPhBNxm1FNBk9PBrEQFAEDSYfJQfdcZmDQDGAGoNAVZ/ + N3L4u3dYM7DDyf7Sn4OMUD6ykzR/ZzHyafximajCfTn3VTS+TGCpkwkt/VL5S2EdqIJj0KAmvDQPBREc + 7IK9pR/dAzPYT8OckNNmJ0+qSTQCgLNnzjIBnFNz7O89L1oBgQYDDQSiA4dPYjsBIKftthS1Y2L22DVm + TxlefjZteNnrcJHfnZIAQE7xFa0CwB00vVT6vUwptY5+RDqmMDZFWB0+pp/zP6md8z9+XDvvf/QojhwW + ABwmCGiK/Qewf3ERiws0yRwr5ewsZqdnMD05hakJxuexcYyPjhICwxgaHGRFHcSTL87gqdcH8fjLSdz/ + rA9HHjZi9EwtYvvL4JgohGFYIFCIWoKgmmCo4OPSwQK2AnkoaM9FbjQLWc17kME2YK99N0pq5QyAdnuw + SjX5x6qqf12jHQ0q/mtXjqbiv9sTVADwt0QRDCdU/G+V038y/Ved/htc6f+nCDMCQAYADx8+gbfafoVr + Asrgn2XTNt1SX69tybXpyJov6kvoNeufpQEgEgDU6CmgplYDQF3qZo/s8dQsLwEA24EUBDTzEwR6ChAA + 1BMAojqjBoKqBi8jpAO7DLnYyTi5y5PF6s8+M1qAPFb/gq5iFPWWoKSvBGXcy6y1alZ8mcDSQPMbaX4L + 946BGrSMWdF3MIaj908wLrK3P3AIx44cUTPlxDwydVZm0KlTamfOqPPrapKNTLYhCGTOvZp+K3FdN7Jo + /8ET2FbWQQAQAgTA+MwR3ewpw2v71MU7KZismF5+t6zoI3/nHI6fPI3C+m7cIVGfVb/MzAN+eB/722M4 + fpzPT5/tp53yO6ngdYIAUHP++VqOHj6CI6z+hw6smH8fX++++Xm9+s9iZopVk9V/cnyC5h/D6MgIhnUA + DDIFjI8P4OqL47j6ahcefjGEi8+5cP5pK44+YcbcJQM6TlTDPVcKA81fw0RQRZUTCqUDeSjuyUd+Ihs5 + ob3I8LMNcO1ErqmY1d+iVX+av1qP//X64J/MExEAyOKx6vQf479U/1T/H48x/qfO/7P69/YP6f0/X8O0 + 1v8fOHCUCe4EPopuXfOYvRFiG/06nP/iH+iW+nptS/ZNfWu9qC+jT22/j5qqGg0AlVoKqKphClAQaKKM + q1KANs9ber0GQkCI36gAoEkA0GDwop4QqDcSArr5aw1+lNW6kFtbi522vdjpZF/pz0ZGOA85bYU0fxFj + fzFKafYyAqCSZq+mavtL0DBQAgP3tsFSRthaTJ/34f6ne/Dsqws4dmw/zX9QRWQxi1TM46ycYiKBgFRV + lQQIApleq9LAWcJATwQKBMq4AoMLWDwgAGjHFpmwU9iGsenDuvEpfcquMvw1pqfh1UU814sAOHEqDYDN + rPyJnrn0RB95Tsr4fI4y1VcB4BrzH1Zz/g9L5dejv1T+fQsr0X+WWl39x0ZY/YcFAIzUA4MY6B9Af28f + Jib7cOWlATz2cgIPPufFhWesOHXVgsOPW7D4qBnTDxnQe64B3sVy1I0xBQwRAgP5KOnNQ2F7NnIjGchU + KWAn9th3ooztoTb9V+v/66T683iQ6i8AsNq0yT+p6q+N/ie00f94B1rbuhj/tdF/AUA6/s/wten9/7Gj + J/FD/5+veczeCC3bNjl1O339tmX7RtuNGhz5mW0TrNXlqKysTUOgSm8DtCSgjQWoWz7rK73I1V4CgXoF + ARfTAKUngQYDJQAw+FAnIgSqGuT+83bsbMpi9d+DXe5MZATYX0bZZ7bLqLMAgP0nzV9BVYn5uW/oK4Zj + rBxdR+pw5BE7I2wYj7/Sjadem8SxEwusiAKAAyoeS0w+whQgEJD4LFoTAtIWqJl3hIDAQKUCuQDnLCZn + DmNrSRvuKWnHPTTt6PQhmnylbVgxvQYPNYVXzJ8GgKQMDTDy+48dJwDqOhUA7sqNI9Y1s1L1Ke0y31UX + ++ix/yhfhwBA+n5l/v1a3y/mX5DqPzvH6E/DTIn5V6r/yDArf6r6DwxgoI/9dW8veru7aa5uPP5SFy6/ + EMC9z9pw+kkzjl0x48DjJsw/YsTUQ0aMPGhA+7k6WOdLUTmUjzKVAvKQ35qJnOBeZPrYBri2I89USABo + 1b+mXqq/lgYFAHKtiM0u5/5b4PYRAM1htQCoXP+fiv9t+grA3er03whGRvn8CYCZ2UXV/x86fBxnD+3H + kvNXMw2YBfRHMN72f+h2+vpty9YNGTdsdJS/J1ablwZApZ4CFACqG5kEJAWsagVWQUBin6SA+ianAkGD + wU3jCwT0FEAA1PJxRa0DOTXV7P13YZdL4iT7ykgO8lrzUUjzl/TS/KzyFYPFqGbFrx0ohmuyAr2nm1il + HKxYHjzwXACPvNzKKDuIE6dnGYMJgH37WBkXdQgcUv2ylgTYCqgksKod0EFw9pRUYEkD0hqc4c+cwsDY + ftgCo8iu6cQ9xa24u1hm6REAU4do8nNpw99Lk6dNrwyvmT5leE3axTyio8dOoKCWAGD835wbQ6xzBqfU + HH+t8q/0/FL5dfPz+SvzM9Vca372/Xr0l75/fGySMXoAzeFu2DxJdal1rTlGRWCwR+H0xRGKtqG7sws9 + XV3o6uzE3GIHHnkxhvvZBpx5yowTV004+LiRADAwBTRh7FITBu9vRPe9DXAtlvHzyNVSQFs28iIEQPNu + ZLh2YK9tO8ob5F6Aqeqv9f4mml+WjJObyEr19/hDavKPjP5HIjL7j9Vfjf7L1X+p+D+KUb4WWQBkbv6A + Ov8v8f/S3MCvbA7Akv07C7qVvp6buh7gRp0fJQAm63fq5q9VAEi3AioJEAA1Bq0VIAAEArLmm8z5lvO+ + AgEBgCaBgId7D+ooAUBVg4vV34rdUv1tu7HbQwAEspEdY2VpIwC6ClDcW8joX4zKgSKYJ1jxTzdi/mEb + jl5x4vRTLlYsNy69INW/C6fPTWJudl71wYusiAoCNInWCjAFCASOHFUQEK20BDSbmI46cuQ4JqYPwhMZ + Q0F9F3aUtDLyJ3FPkWb+zbIvSGBk8oBmat3gP292kT6PX5cYX8YdFACOCgA6CADtFJ8CgKr8K8bXKr88 + V838YnyBmfT98rpS0V8G/cbGp9DaMaQuo84sC2BHnhdbczy4J8eNLaJcF7bmOikHdlB78u0orfGpWXdd + Hey729qx77DcYrwZ5582sw0w4vATRux/zIDZh5swebkJI5ca0X9/Azov1MG2UIzy/hwUd+YgPyEpYDcy + PTuwx7EVuaYClQDqGrUUqFV/WTTWr+4e7fKGtPjP3j8YktF/Lf6rq//U+n8D6BtgWhlm68LXNTUj03/5 + mg/yfTh2Cs+M+H4lpwCXHDLvf+Nf6lb6em7Lht/453LjgrVe4JfRfcbbaXgNAKoFUNJSQLWkAIEAU0AN + U4AoDQB98odUAQFAXaMGAUkBAoBaqpzVP5fVf6dlJ3Y5dmGPd6+aYJKbYGXpyEdxdyFKmQBqhosROlyL + iUtW9qV2HHrCwQrlxNmnnLiPfetDrFxnLg6p6Ds7O0tDzKkUIOaQCqnMwlbgEA0kEEi1A2IugYBoauYA + gq0TqDD3YEdZK7YUJljxaXwBgKr8mgQAcopueGK/nhTE2CmDU7IXw8v31L9phtcW8dR7fOrI0eMaAGRm + X24U0Y5pDUS68ZX5BVQS+SkB2OrYv8jXNU/jd/SOwuzuQE5FmGb3YXOWF3dzf3cu97keiubP07Q1jxDI + c2J7vgPb89h25dhYhWPo6OhAR2sb2pJJHDwVxcVnHTj1pBFHrhiw/1ECgAlg/HIjhh9sQP/FenRdqEf0 + eCWqh/JQ2p3NFJDJFLAHWf6dTAHbsce2DRVMAfLZG9j+ycQwVf3V4J+c+w9fc+4/RvMnE1r871Bz/4fS + 8X9iclaL/4sEH+P/8eNn8GZn6ZrH6i+rJefGp+D81t/TrfT13PDvv/X3lmyb3l3rBX4ZvWb7c5qcFV/G + APQ2oEraAKVrU4AAQG78IEs/CwBk/recA5ZKIACoa3TR/G4FgBpW/1Kp/o0Z2GndqWaUZQZ4IMVzUNAu + 5i+g+QvQMFqC9jONmHjIitlHCIDHbDh8xY6TTzpw7mknHng+gLOXe9W5bul7ZfBLToFJVUynAL0VUElA + 2gF16uwwTb8Pya4JVFu7kVGexI7iOLZSW0qSaQkE7k6pKEkAyPz8OIbGF5WRUwZPGftvM3xaMsDHSn/4 + yDEFgNvzY0wAEXXa7/rIr8yvRvu12C+Vf25uHwaGp+EK9CK3KsIq78ddWT7+DppflCtKmZ8JQMwv1V83 + /zZW/+05duwtsKPR0qIqfwfVrgDQSiPGceTeANsAI45facLBx5i4HmnA1OUGjF6qZxtQzzagDsnTVTBM + 8DMiAIraM5Ef3YPswC5kuLdhj30L8o1F6gyAmF/WiJDqL/eOdLu1wb9mgicog3+s/gKAdPzXB/9S8X9q + ak7F/316/D9x8iw+i9y55rH6S4mJYtm+oVq30dd7I8kurvkiv4R+YP83aKqu1lsAXRUyJiBQWJUCCIFq + BQLtDrCy/psAQKnBjlpCoJYQqCUERJW1duSz+m+3sGLYpfqzgrRkIS+WjYK2PEbLfFT2FSJ5sh6jD5rY + h1p4IFqw/3ErK5Mdp56y4cKzLpx/tBWTE2PUhIKAnPqam5lVg2H7CIGV8QC2AvsPsGruQ1v3OAzuHuRW + J7CzJEbjx7CtNI5tJQlspbYIBIolAWi6W1SkaTMlM/IEADJod63BdcPLKUZdqUG9tNjjiw4dOoqCmnbc + zt+lANA+tVL10+YX42vn+cfG59AcHURJA59fQQvuzPThzmw/7iQA7qTxFQBo/rsY+zeL9Op/D82/RczP + +L+Nxs8pZSS3BhEKJ1X072rXqn87zd+WSCIZjzOKR3H8sqSsBhx8vAELBMD05XqMEQBDD9Si975atJ2p + gpEAqOjLQWkXU0CSbUCIbYBvB/YSAHssW1HdZFKn/2SlaKn+Ev9T1b+F1T/I5xCNaZf+trX1aKP/6tz/ + CIb1wT81+r9P4v8xFf/P8j36qevGLwW2ZNv42bLpt/4n3UJf7+1GngoUMkbqCvXqX4sKml+kJYEGqlEp + 1QpUMwmkbgMt14CLpBKsQMCF6noHKmqt2FMvC03uwG7nLuz170FOOAv5SfaVHXko686Hc64cww8YMHHZ + xOpvxr5HLTj4hBXHr1pZoaw4f6UFk5ODapbb5Pi4GvGWFDAzzRRACCwIBAiAqalZ9PRPwO7vQWFdAhml + UeyidpTS/NR2mn87QbBVSU8BKRXFcU9BDPcUxlYgkBfF4Ng+zcwpU69ldP2xGtRbJYn6BwmA/Jo2tgBR + mjaMcNsEzb9S9aXXn5xaQKJjDGWGNmwrCOKu7ADuyG5W0oxPZWvmvyvHu8r8brYBNH82e/4cJ7KKmbgM + LQgEk+hol4G/bjUA2Cnmb6P5W2l+AqA1kUAiFkc8GmMcD+I4gXv0iXq2XQ2YeagO45fqNADcW4vosXLU + DuUQANlMAVkoastgG7Ab2c072AYwBdjuQZGxWJ0ClDtFifnVqT8CIFX9Q5FWLf7r1V9b+0+r/iNq8G8O + s3OL2LdICOrx/5F9Q7+q/r9Pt8/Xf1u2bii5kW/Svqbtqg1YDQAlPQWkIFBFCFSpJCAQoNIQ0M4J19Tb + lSoZ/Qtr6rDDuA27rKwYnt2s/nuRn8hBSWcuynryUNmbj9ChaozcTwBcMmL6YZM6L334CTPjvwVnn3Qx + wveoc9tjo6PqXPeEQGBCSwEyGj4xMYXmSB8qjQlkloexp4Qqi2B3GQFA7dQBINqmA0DtmQi2FFH5Ef5M + HLXWHvgiI+p7dxfKFXkEwMiCGqlXptb3Ynpl8JTk+7pS/b2m46xoRxQAbs+L0MQhhFrHlfEXWe1au8ZR + Z+vC7pIIbs+i4bMCuF3Mn8PHVNr8euXXzO/VzJ9N82e5sKPQwz6chgu0ssfvxkBfH/p6etDb3YMeml+q + f2c7479e/Vul+tP8iViMAIgiGo6gs8+PY48ZcOCxOsw/XIvJy7VMYwTAhSrYZ/NRP5KD6oFsVPRko6Qj + A/lxQjywE1nu7dhr24K9xq2oM1jVuX81798bhq85iuYWrfpHYm2Is/dvbZWpv3LqT6v+QyPjGEuf+z+I + /QeO4shRmQx1Fi8N2dc8Rn8ZsWVeWrZs/De6fb7+G3uZP7mRALhq+U/qsuAqBYCaNAAkBVRWChg0CEgK + SEOAAJCbQcodYVIAkJFhkZwnzqjLwk6J/86daiZZTjiTMTKL1T+H1T8XlYRA874KDBMAk0wAcw/LiLQJ + R6+YcZoJYHqxFUMDwxgZHMLo8LCCgJYE2AoQAqOj46g1JZBVFsZeEQGwt1zMrwOgVMwtKYAqiTIBUEVR + bCuMEBQxlDS1oyU+yoNwkTH8CKamFwmAKDYzCWymaQdG5lVkl1OJytSyl3P2aq9N3EmN5KszDamvj8lp + yGPYf/AwAZDE7blhBQCjpw82fx8BxUQghs9qodlbcHuOZv7bafzbU5Wf0f8OVv47afo7s2n+LA/lxs58 + D8HaApe/VV1JNyD30+/Xzvn3q3P+NL+c9lPml+rfriq/Fv0TCgBi/nhEABBGJBRC37gHhx+vw75H6tkG + 1KCP5vfsK2D/n4Om8VwdAlmEQCaK2wjx8C5k+wgAB9sA890oMVSoRWLcnjCrf0RV/5ZQfKX6CwDaGf9Z + /SX+a73/FCYmZzCrD/4dPHgcx46fxqnT5/Fhcveax+gvIybm+3XrfDM2GP/l/4tU+3ytF/tl9Jn999FY + K4N+q9uAGpTLXgDAFJCCQGUqCVQbCAJCIH1bKCuqKLlEtKi6ATsMW7HLsk1NIc0M7EZ+lAdQezbNn4PK + /nzUDOTBMlGE4YvsPx8ysA9tUuelj181YuEoKzAP7KGBAQwTADK/XWa6yVz3CYHAxAS6uoeQU9bCyh9C + BiUA2EMAiHYTCDsVAChW2R1FEZo/jPzaJByBfgwMz+LA/oOqIosklk9M7cMWwmEz2wEBQP/wvHYGQRn8 + 56WdYlz9tZxxoNTI/lHs54GdX60B4PbcEM0exO2ZNHy2mF7THSnzp2K/Mr5ufhr/zkyp+B7kVrbA6knS + SH18PwhFmfSjpvsKAMT8jNY0f68e/RUAVg38termTzD6i/ljkQjNrwEg3BLEyKIdC4/WoOdMKXwLebBP + 58E0KQDIQd1wNj8rAqA3E2VMAYVMAbktO5gCtmKP9W5kGneg0eRU8d8nq/7IqT+p/nLqT6/+7Z1y7n8A + fXzugwS3VP+p6QXMzWnn/mU1JKn+59lO/cTzx2seo19aMvhn/XaWbp1vzrZk33h5zRf8JbTMNynRUKQA + cO1YgECAXxMAFQSAQECBgACo1JNApQ4BWRlGLhCRy0Sza/NY/XmAOLerCSR54QwUtWYx/kuczEFVfx77 + yzw0DechcqgcU5caGf8NjP8G7D/nV9VMqtrgQD+GBwa1FKAgMKJmvUkrMMEkEIr1oMYUR2F1GDkVQWSU + EQai0hCyCYSCqijKmlph9bEC9YzzgJNThtrZAunBZeRdnTYkBMYnF3QAMAXkhdE7NIvUfAJtTsEqydcp + pb/W+vtUj79v3wHkVSVofhpfzK8kAEiZfsX4mumpLB/uyPDgbpo/szQAWUI90UbTs2pKApK5/iNDQwqK + AseU+ft6WP1p/p+L/tL769Vf6/216h9j/I/qAAg0y41eXQiOVKJ5IQee+Rw4KetMDiGQi8YxDQJV/Zko + 7+LnmNiN3OB2ZHm3Yq/9HqaAzagy1anVfwJS/YOrqn+ySw3+Se/f06f1/sPs/aX6y6k/7dz/MRX/T506 + j8cXB294/69u9un8vX+o2+absy1ZN7at9YK/rI4btkCWCJfR/xQAyvUUIBAQAIhSKaCyWvYCAkKgWm4R + LZeImlDKf9vdsB27rVvV/PGswC5W/wyUtGehvJsHUl+Oqv4NI/kwjEkKyEfiSJkaiT74gAO9vZ3oZS8r + B7ZAYIhVLpUCRvXxAIGADAqm5sH3DYyis2cYbZ1DaOsaZtwc4fcmMDI6pSYOLe7bpy6mkTMFqYlD2gxC + be6AgGBsYo4ACKsVeDbnhdA7OKNNy2U1P0pzqwlGyuD6QN5qqSQhMxFTc/gPYWFhPyt3fMX4rParK35K + yvgy4p/pZV/frIAWTfRhkL2ydoXf2HXmH0ybX/r+fjG/iv5S/TsJgA69+ut9/xrVX8zf7G9Rl+5WVFvV + +v/FVQZ4mch8hICLAHDMZsM8paWA+pEs1Axmoao3A6Ude1EY24W8AOHu3oK91s3INe1V04AD0vuHEqz+ + 7ez95dQfe/9O9v5S/WXij977y3X/s3P7Wf2P8P0/oQb/zpy9F2/0N6x5bP4yYlK+dW/2+ctscjkjbuB0 + yddt/w51siLQqsFA1QLQ/AIATfXpJFBOAFQQACIBQAVVXmlg7C3BbhP7Q/s2ZPp2qlNHRYlMHjhZ7Pt5 + IPXzgBrORdNoPkzjebBN5cFFReZLEErIeesOdTBLVRMIyIEuF7doENDHA1Q7sHJmQM0RmJzCzKp5AnKa + UKbOyhRamUcvk4bSIFApQJtwc0CB4BBGx2c1ABRQBEDPwJSeDjQd1s2dMvo1hheISKKg1KW7+vn83MqY + Mn66z0+ZP0szvWhnfjPKGmMIRHrVzDhJNtLiSMqRlkeZn+ATAIr5V8d+VflTfb9ufnXOX/r+1MBfqvrT + /IFAUK3UW1XnUKbPKzYhr0S/A1C5GeXmejTP58MrEJhjCpjOgXEiG42jWagbzFQAKOtkG5AkAELbkc0U + kMEUsNd8NxrMZnjZAoQjbYjFVqq/dupvZeR/XKr/zKrqf+QUTp48p+6j8EX4b9Y8Nr+sbvmbff4y27Ll + O/9sybbhp2u98C+jn9m/A19jpZ4CtDagvJwJQKTMX4sy7st0CGgiBESsHuVUKR/vrdupAcCxDVn+HWoG + WUlrBso7WUEEAAM5rP55MIr5J/PhmM6FeyYfNW6DWi6spskPty+qbhwpB/cKBCQJsB2QVoCGGCcEJqQd + YJW8FgLaGQK5Yk6bMKRBIA0CgcC+RR0EWiIQjYzNqEU2FQAY27v7J3EwlRB0c682eWovk3fUJbtqIpIO + FSYNublFbmVkxfSrjC8TegprI/C0sGr3jvC5T6nLeuU1rGl+Qk9Vft382oi/Zn6J/um+n9Ff6/uT6VH/ + KI0vC3PKxKzCMguyCk3IERWvvv+fWa3+W1xpRYO/Dv59GgBsM9lsA7IJ6yw0DGeilm1AZddefp67URDZ + jhz/VmQ6BACbUWoqhMMVWKn+NH87q7/q/QdGtGm/qvprE3+k+h88pJ36O33mAh4+usBW9MYuAbZk33RE + t8s3b9NWB9p0Za0X/qXE3mvRuAu1deztV7cBCgBaGhAAqBRApdKAAKC8son/1oTCimrsarobeyxbGA+3 + ITuwEwVRAcBeVHRl0vzZPJByGf1zYZ7IVdXfPcM0EKtBUaUTRVVOFFa6+NiNkhov6k0trCqsYMlO9HT3 + quonSUDGA7QkoI0JTAoEZKIQtRoCGgj0NEDJ7EGZN6BNI141lZgwGBmdwTZ9wc178oLo6ptQE4tkJZ4V + idlp9HSCSEkzvUAlpWke6LkVAgC/Mv89OX7kVIRg8TDh0PTTci0/JeYXpY0/NqaZXyK/Mn6q59eqvwBx + ZcR/tflXRv0TsQT8/rC6RLugzIrMApNSVpEZ2TS+mD+XlT8FALkFeBHNX1JFVdtgaa+CJ5UCprIJ60x+ + bhkEQAYhvhflHbtRHCfcW/gZsw3IYBuQZdoGi93NBNCqqn97e68+8j+EweExVf1lzb/Vvf/hIyfVzL9z + 5y/i1ZEbfPpPBv8sG+7Q7fLN3JbsG2JrvvgvqVds/x71DQbUyJoAhMDKQGAqBTABlNddA4DyihUIZFfn + YJdhM/bYCADPNuQGdynzl3ewcvQQAP2sJEOMlQSAdTKX1T8PVlkJqMpG4zs0CFCFVW6lgkqPUnG1D9WN + AXXDUV+A0Za9ZX+fwGCYiWBEtQTpJKBAIGkgNV9Ag8G8agsoSQQKBJrk8QKrdW//BLYWtOCe/CABEEBn + z5iWEsTYChLXGlyJ35c5+5IqRJIwlAiYSUbd3Iqw6vFlVp/Z06nWvZMWRZbx0swvFX9V1af5peor86vI + rxl/pedfGfG/1vxa5Q+HY5DbtRXzvcwqNGNvngl7803I4ONMMX+RVvlzGP1zS0zp6C/ml+pfSgCU19hR + VW+FY7gEzrlspoAsWJgCDGPy2WWguncPP89dKIrvRH5wG3K8/Kztd2GP+U7UWhvUIKBUf+n909Vfev9x + rffXRv6Pqup/9Jh26u/ChYv4PHLHmsfkl9WSc+MLt/zNPn/ZTd0t+AaOA/yMESzYVKluEiIAkHkAKxBg + AigXaRAQAEg7oO0blHbXb8Me093Y69yKbIn/YVaK5G4eMHLgZKN2kHFymLFyjJVlIgeO0UIU1xvVAVtY + aeeBqEFAUkAhU0CBDoH8Si/lo6G8yCunuJebilY1yU1IY3D52hAIdyLe2ou2jn50dg2gu2cQvX2yRt4I + +iipuj29Mlg4grbOYYTi/XAHe9Fob0NJfRx7yqT60/yEwObcZrR3j6XHDuRyXDWGoB7rJl8tGl61GQom + Apg5TDDu5pYHGft9uCvDC0+wR6v6quKvxH0Zx1ip+qnBvhXzr+75pfL3pc2v9fyxaJLRO4SyGjeNbsWu + XDN255mxp4AAYNUXZRIAq6v/6uhfyOgvlV+Zn9VfpnDLTM46qwWu6XzYpwmA8f9/e98BHed5Xemzm012 + k5zd7NmSTdmTbI6ztiUAsh0n2iS2bCuSLImiWEGwoBCFKCRBdGCAaei9gxXsXaRIiiIlqlCixCY2UXKN + HUebxImcVeISx3YsWTbm7b3v+76Zf8BRLJMARYr/O+eefwYEQXD+/9533/sa7tv2JVK9ZbFUbFyEMmCR + lI5mSUEf+wCzjQAEZkhRY660tfXIKLL/2vWbbO2/04z72+x/8NBRT/ZH7f/CGXnlqQNTbv9visM+rzVi + Nb/+KygDvpvqA7haHG+cp6cEc4twrgx0IkAXYATgShEoW14thSuWy4K6h2Qh6kFOEslrZ/2/EA5gkaxY + SwFgIykHAsAHCuTfnS8rwjWoPYMgfROuIVzDID4FIAriN1u0gPwtkg8hyF/BMfE2WOl2yS1rk5xSg+yS + NllS0o7XHfh6J4jXKXlA/oouoBvvuyWnrEuH1hYVd8mCoi6Zz730C7ildqfMIQq7FLMLgKUdOpqghFan + YAkeJ3kCrryIOwyAZceuXXvxO1AA2mRmdqu0dK9TZ6Kkt/AS31l+1+xz5HdZ39l+Zv01Y2ulrWNAt1rL + K+aqvyZZAOJngfgLC0j+JhC/0WT+SeR31r+wrAnWn597k5K/DORfodk/IqtquLirRQJdtRLdBxewJwcO + IFuqty6WVRvoAHBfRzKlsB8ur2O25ETh+iAAS+D+Ii2tMrKavY0tssHO+d+5e58Z9+ein8eekCNPPCNP + PWVq/5OnXpLXt9SnfBavFnDGP5Tobf/D0uT9HbA6h1J9CFeLb4f/WBrrAuoCuEcgRcC5AEP6KimdJASl + EICc8mxZUP8Q6v+HUf/PlbwuPCCDWVI2xvp/CTIH6sitORLYnitBZJTqvhWm9uTRUxQBCECRwohA4QqD + AkUziEy0wAW0QgBaJXc5AQGAEGSXtSuWlLbLYgjCIogBsbCkQ7KKO2QBkLmsM475DhCCecAciIHDbIgB + BWB07VYlMhuJCr6+ArbZCNDas9SgvWfpwX3u8yA6M3Jb4QBaVADiVn9HMvHZz3BZ3w3zkfiO/Gz4rV2z + DvZ6WGoDXZJbEpFMkD5zaRDANb9JsgqalPwLJ5E/uygQt/5x8oP4av1t448CQPKvrCL5o1LBZd3c5SnQ + KqF1KyW8Z4kEdiyRmm2LpGrTYilfvxAOgP2dubK0c67kRCD6jTNlYf2DUh2qFB7+Ob5pG2r/XbID1n/3 + 3gOy79HDV2T/Ey+clrOnzshbnZ9J+SxeLSYi6TstPd7/MaU7BBH4WVsCRXABDXpsuG4OAhEg2BCMu4Ay + IwCluJZCFBZWzUH9/5DOEVcB6MnUSSNlqxfLyvWLpXLjEqmjAOzIkYYNRXj4eN58QEWANrRoBa8hkJ4i + EMGVcAIQNQKwvBnZvAXEagH5AVxzylqR2VvhAFplsaINIkABaIMAtEMADBYsM8hcBjEo6gD5O2QuUchD + NXjtgBPogAAAee3IYptt/yAVLNEd4tbeYY9s377TIwDN0ty5xhIfdX6c+Am7nyrrs/E5NLxaj1wvwP83 + a2lI5uUGZT7Jnw/yg/gLFMj+JL9m/+TMr9mfAvAO5GfmZ92/sjKi2b8CAlBdZ8hfH2iXhkirRLcVoWTD + /dsOB7BxIUoA3NexBbJsaL4UdEMAmiH6EP6sepQBDdm6ByCt//YdHPYD+fcfRvY/IodR+x994lmb/VH7 + nzorX3tsw5RO/tFNPxpvksM+pyK4xFEtT4oP42rx1dA9Ul/XKDWoz7k3oPYD1AUY8idcAAWgAg/Tcsmq + gf1vmKnjwrltcyW/FwIwlCXLVy+CbUT9CAGo3YxMsjVPymph/Zc3KIqIFRQCAE6gUAEhWB4G8SN48COS + XxYG+SOytCwKNINYzZJbGgWaYftbUAIATgSKW1QIFhVDAJa1Am2SBSywyCxqA/nbZV5hWxzuZB1iTj6Q + 1yYdvetk545ddniOw3Qe2P34lOx6BTzWns3IrVt34PfkvP4WeXhJVKIdq5X4rPFTEZ9DfI74I6NrJdo2 + KCWr8PuC9HNzgjIvLyTzKQDI+vOZ9V3m1+xvbD8FINn6I/vbzE8UwPZTAGj9NfOD/Gr9UfevrELtD/Jz + Pwfu78jzHnjuYzDcJcGesARRAtTDAVRvXiQV4wtlxWonAHMkt3WWZIdQBjTMkMW1M6Wts1sFgI2/PY8c + kv2PGuv/+BHT+DOd/9Ny5uwF+SeUiKmewasFSuLLHCGz9Lg1Av/px1N9GFcLzgkYCFRIfW1johQod70A + IwAUApK/BA4gtzxPsmph/wMPQwBmof6fh/o/EzYR9f/YQilfC+s4vkTq2UVuXS7LyuqlCFi2nFeePGsE + QM+jR2YqXB4E8UOK/DICAgAsLYuAVFFFbmlERSDHIwJLABUAYFExyW+QBSwoIpwAWFAAClqtCLSB/Aks + wPvC8m5piI7IGOfgb+NiJDPSQBvPCTsGZpUi/8zV9MzyWzZvlbzSDpmZ2yyzsiEA7WNKejeV10v8TeOb + ZN3aDdLRPSLLqztB4Ihm+rkW8zzEN2i05E9k/ivJb+v+kiYz2ceRXzN/CLbfkp91P61/tdnLgdu6cfiQ + Jz83hTolHO2WaEu/hNZUSsN2IwCrNmRBADKlZDhTivo4EgABCFMAHpQFNfdLY0uTlgC0/iQ/rT9X/B2F + 9X/6mROa/U+h9v/88cclNpWbf3LoL5hWYmlx60QslD5/SssA4EJopgTqm2xD0IiANgRZCsQFwLiAxRWZ + EICZOiEkOwoB6IAD6JsvxcNZsnJ1lqyCZawaXyxVI/kgfY0Ul9WpCBghsAKgImA603xQC8qCID0eXr2G + ZGlpCITihhdhS/6I5KAWzimJgvxRWVIMlDSD/AaLIAILlxHNes0qMqAQZBa2gvwtAMkPQATmEvmtIL/B + bELX3Js999hUrA8PSf/QBtm4cYsO1xnCJyy9AzP8JnzPUpQiD6sARCAAownSW+KPw+J3945JVUO3ZOP3 + n4NMPycHGR/Zfm4eyA8Y4ifIP9n2L7LkX1Rohvvitt+SPynzw12R/CWW/Gr9Xd0P8tP6k/w88p3DiaFI + l0Sae6S5rV9auvqkcVOB1GzCvVy/APcVAjCUKYU9KPdaH5YcOxKQVfM5WdFUoguAHtl3WPYfeFzP+nv8 + KDf8eE6ePf6ijvsz+//DxpUpn72rBQ/75EI5JcWtFLL8tl+dCOM/n+JDuVq8FfmYdDXVxUsBPTjU9gPc + 9ODS5RWo/ysks2qmjgCwEUQBWNo5R5b1z5fSoQWyYjRLKtYulNrxHCmpXgXS11pMFgEjBIUEh6kgBHxw + KQJLS5tA/CAcgBGB3JIQBCAM8htkQwiWFBNRWbwsAgGIyqJlUSV/VlEUaAbxHVogACR/s8wvaAb5WxRz + 7Z56bn89grvtzLa77swmkXO45VazjjpUNvRJd98aGR+3axVsI89Z+434+tLSNpmVS2JDANpGtL4f37BR + V8k1hPrw/4EY5YVldnZQZpP8lvhzLPnnotaf54gPkPi0/JNrfmZ+N9yn4/0e8ru63zRaOdknQX7u2Ezy + M/NzL0e1/o2W/LD+Yd3gs19a2weko2tI2obgDjZByCEA5WPzpWRwvhT1zpGl7RQA3P+AcQC5dZkyNLJG + ya/W/+jT8sSx4/L00yfk+ROn5dTpc3L55HPy05Y/TPnsXS1uusM+pzImwmlrU30o14JT4XnS2BCypUC9 + 6NmBdn6Amx1YsnK5zK+6HwLwoCxqmik5LbMlr3MuHox5UgYBWLV6oVSuXyQrW4ulqBS1vxOA0lq852uv + AFgRKDWTVAg+wEsBPtAKCEEe3ABFIEcBASgOg/wEyR8GIhAAg4UQAIJCsKDQIBOYTxSA0Aq3px6A13Py + QVpAiZ9nrrNwTQJIzcy+COXFqvpeae8ekzVrxuMZnkSnAMzOjcic7LDUh/pBpiFZtqodpHakD8mcXMCS + nmDGn8uMn8/XEIC8xnjmz5xk+Ul+l/lTkV8zP0hP26/kR/Yn8U3mj0o5bD+nCFfXm7qfh7w2BE3dH472 + SLS1T6dlt3UOSmfPsPT0jUpwbbkVgEwpG7YC0GYEYEnjDBWArKoHpWdwAAJwWE9C0mG/p5+X48+dlBdP + npWXzl2Sb24PpHzmrhbI/j+NNWakWTrcehGLpn1iIpwxkerDuVq8Gfm4dDfVS6AhKLVWBNwsQSMCVVKA + +n9+1QOSBQFY3PiQZDfTAcyTkn4+IJlwABCBoWxY/wqQvhowIqDkVxGoAyACQGEcDSB/A8jPxSoGppHV + hAccsNccILs4aBFC9g8CvIZBTIOFRWHJKgRwXVAYAfkj8avungvMyycgBAC31XaYk0dAAJIQsbDvKQQ5 + YRAZwgOHUVrZCdIM63TYpaUoI/B1IhOknwuyM9Mr8eM23whAIuNb4gMm85t632X9yZn/nWx/vi2lXM1v + Mr8hPzM/yV8J8rumn9b9IH9TqAvWv1siLb2a/ds6BjX7d/eOSm//mPQMD0rN2sUQdtzfoXkQAJR7HbMl + 1+MA5lfcK9HOiOx79JBm/yet9T/xAqz/mQty+fQL8pPWO1M+c1cLCMAJS4VbM+zJwVO2R4DDGbiAYGNY + GuqDUmP7AXQCRgSqJWfVQplfCdWHACxBCZDXOks7w8V9cACDmbISAlBSVwayV4LkVSoCdAIGphRwIlBY + UqcCUKAwIqAuQAWAY9l2KqsKAB94KwIgPrG4KChL7HVRUUixsNAgC1hQABEAMi24dbaDEQEAxCfmkrBX + iEECCSFwMEQnuWdn89/iz8F7fH2O/pkjfYL8ceLbrD+PAgCYet8QnwKg5L/C9icy/79a89vMb8gfidf8 + q5j563iSkyF/fRPIj8xvyG/qfk424rbi3b0jyP5jdqHPWmkZa4Kw0+HxPs+Vgk4IQAQOoIE9gPtREt4r + dS1VOvtPrf8zLxjrf+qcnDv3svz99oaUz9pVg82/8E162OdURiyYlp/yA7oG/DjyMRkM1UlTADa2LtEU + 1H7AqlpZuGo2bvj9srB+ho4F57Y8LPkQgGV4MEpRIy7vyJVlJRUgOASgzImAEwAjAoUKkJ8CAKgA8FpS + D/I34KEGig2cCBgBcNkvIQJLipogAARFACgkIAAFQSMEBR4hyA+lFgMQlzAi4IEl87sCCe8Qz/BeuGzv + rL4hvRLfwZJ+QX4AxA9ow0+n94L0Sn6b+bU0ghCazG9GUSgASn5vze8hP2f6MfPXwvaT/I0284ebYf1Z + 9zPzw/p3WevvyD88ul5GV6+TqpFcKR3Afe6dDQeA+x6daR3A55AQ7pWVwSI99IN1P7M/rf/Zly7KqyeP + T33tH0n7K4ne9ouWBrduxGoyfkV3QEnxIV0LvhiZIaFgFKVASEUg3hSsrJbM8ge1B7CwHhkgyB4ABKBj + jhT1zJGS3kwpqVwpxSA/QRewrIwOoEqKSqpBdr4mIAAlBgVAPshPqAAUWxHA1QhAsgg4+2tEoEkFICEC + TVYASH4DCgGxQIUAAkAR8GA+wWE3XJ0QcBjOdOavRCKrk9SeP9O/423oGdIrXLb3WH0v8ZnxF9hs77K+ + a/TF6/0is7rPkN8Qf3K33w31Ta75SX4d7rM1f5z8nrqf5O9U6z9i1vgPrZHhkfUytnpcxtZuku417cj+ + s/U+57fPVAewOPCALIQALIAAFNQukK3bdhrrj+x/+sx5OX/hsvzjpvKUz9i14JaY9/9uQ8LpzVM9JDgR + uUM2hVdJsCkigUBI6mp5TiAPCqmS+eWfMw6gbgZKgIckO/qwjgsXdEIAQrlSUlYFVBsBKLEiACjx4wJA + MahR8hsBSIiAQslfZ0WgXvKWARABznAjOOElm7DkMAJgSaMiYKAiwCmzXiHIN2KQEAA77MarioAZgzdX + AyU3QVK7K0CyG8Ibos9Lem2RRPrkrK/Ed3Zfsz7sviU/ie9A4qvl16zfJPmllvwgvnb74+R3DT9m/mZD + frX9bSB/u070aeREH4ALikh+dvzbOoe07u8h+ZH5lfzD65D9zRr/tRu2yIZN26Wyv0AKO2ZJfiscAHsA + DQ/qMOD8intkceXDugvQiRNn5CQbf+cvyVeee2xqx/0B3e+/8aP/zT7+fnARxEQk4/upPqxrwd9HPi0t + kWYVgQY4AYrAqupKmbvyHli++2D9HtSZYNnBhyS3eaYUtM2R0lXlUrqcAlCVcAFWBIpK6AIMChU1KUSg + FoQnSP46PPAkvoWKQAMEoEFyigxUBIAlyI6OLCZzsm52IsAZc2bufAIeMQDMLDuvEHigYpCMeFbX1424 + egivwNe0m286+kp4W9/T5seJbzO+I78RMPP/8GZ9Q347t18zP2dPNinxkzO/afZpww9ZXzN/vNvfacjv + Mn+LyfztID7JT+vPpl//4BoZGgH5xzbI2BpH/m2yadsuGRwfkKVwfHmw/9nBGbK4HgJQDQEov0eyyh+Q + DRs3K/lp/S9evCzfH1mQ8tm6FtzSQ3/vFCgDpnS/QAVcxVPRPImEW6SJIlAfxINVIbOX/5nMK78XLuBz + klXLRiBcQGimFDbkCPcK4GpBigCRVApoGZAQAiMC1VJQTNQg6wMUAVwpAvlWBFQIltWB+EQ9CEFAAIBs + JwRxAcAVtplDZTpkZjMqyeWgAkACWjFYACEwQ24JJLK1yd5JBJ/83sJ8L8XAET+gSLL5ioCS3vwutta3 + v3N8bJ+wTscQ/8pmnxvmS2T+iKwE8Zn5lfzM/PWo95n5veRnzU/b32GG++Idf0/Tj5mf5F+zfjNIvU02 + b90l23bulV1798uqzqWS3fQAsv8DWv/T/s9b+Wcyf/m9sm58g074OQ/y//WhsSmd808g+78pgfTfs4+9 + Hy5iwYz/NRFO+5dUH9q14M3IH8hoS6OKQCAAa1m9UmaV3CNzyuACVt2npUBWLUqBwExZUcnjxmqEm4dc + IQCuFKAA4OoVgYJiohqEhxDAEagQKJwbqFUBmCwC6gRUBOolu7Ae5G8wAmBFgGRyxFpkiRbPuBZKSFxN + VrYCQMLivREDc3W23SEhFF6y2z9TgPgguvn7hvRKfJvpzdX8brwm1fra3zBz+uNDfKUgP4jvtfwl5eG4 + 5ecwn5f88W5/Y4dO8mkMd9uGH2w/Z/l1DEprPPOPKPkHmPlJftT9o2vGZfW6TSD0Vtm4ZYds27FHdu7e + L3v2HZTh8SFk/gdw33H/K+9R8s8pu1vmlt4jayAA5y68LK+ePSVvd3wq5TN1LZiIpG23j7wfk2MimL4u + 1Yd2rXgtep+0NrdrU3BVTYXMKrobInC3zC6jE4AQQATyahaaswS5fbgVAecEXD+AKCrh3ABciyul0IFC + QBGwboBCYEAXAAFYZkqCPCAXrykCOUW1IAmvIL/FEofCBhAKgBDwuogoaFCiOZCACktGR1AKgiGsI7G9 + Ouh797Xk1/z77vv1tb3G/y3A/fv8fbS7b4lP0SLpvcTXRh+JT8tP8i/3Zn1H/oh2+mn5HfmZ9WtR87vM + 74b6Qi2G/Kz521Hzu4ZfL7L/wMAa1P2G/GNjjvxbZJy7+yj5ub7/Mdn36OPy6KEjUhhcAPLfK/NRDpL8 + s4s/K3OK7oFb2CQXL70q39lYlvJZuhbA5b4da/zwrTvx52dFLPiR34FCTukqQQVs3LHmAolEeAx4tcws + +Kw8bEVgjorAfbKyhrsKNciqCu4vWKsisBxwToALiIwIVHl6AlYAlnlEIEkACJQDywi6AIPcohoAApBK + BArrQCaiHuQiSLR6iIADhYCiYIXAQQnaoNcFuBo4USCxcbWEfmfYv4fvcz/PEV5Jj38zFfFp9Ul6b51v + sr4jPi0/N0/xZn2exRiVlVXNUs5mH4jP49mZ+WvtGH8g1AXyg/io98Mkf6uZ5MOGH4/yYubvAfn7kPkH + re3nQSS6sSfJv2m7bNb1/ST/ISX/gUNP6Ey/7rF2mbsCxC/9rMxaBhR+VuYtu1e2bd8hrz2xecp3+yFg + /3fZR92Pdwp8SH2pPrxrxVsoBdZEG5BVAjJz6aflYYjATIjAbIhA1sqZUlffJDU1PEEYImBdgIqAdQFc + QJTUGLRgOUARSPQE6ASq4uTPX1YN8jvUQAAM1AlYIeBrIwQgfmGtikC2viacEID8BQbJriCBrPx6iAGv + AK/2tSF2vV69AuEVDfP99r2H9O5n67+nYuRqfFOquKxP4juYWt/M6iMSjT6P5UfWp+Un+ePNPmZ+JX8n + yN+p9X4oCtuvM/wG1PZr5gf5u63tZ81P8g+NrpeR1QnbT/Jv2bZbtoP8u7m5x35k/oNH43v7HTx8WGv+ + h4s+I7MKgPxPS2bx/fLYrs3yduc0WP9wxlvSmPZh+5j78U4h1f/7v06E07+V6kO8Vrwe+axEQ0F5OO9u + mZF7l8zMh/JDBIqq8iUQiEqdzhcImBOFeYoQnIDbTDTRGKy2JQEnBzkRmDw64OkLgPgOS/F+qXUEcSFQ + EagxbiAOCICS34hBQgjqZHEBoESkGNTFRcEAZAXRlbS8gsxGGAh+nQQ3f86vGXJbksffG2FRWMKzFHG9 + CTdqEbf6HtIbu59YyOPG9l3WJ7TW5/g+iK+Wn1nfWn7W+9rsQ+Y35Gezr19tPzO/dvt7hqWr15JfM78Z + 6nPkZ8c/Tv6dZmefR7i5h4f8x449J88+96KsDBUiEXwGz8Nd8lDupyR3xRz5u565KZ+da8VE5I7N9hH3 + 42dFLHR7xVR3XxX4mecjcyWz4CF5MBs3PefT6gZqGuukKRiVhkBY6mqvFAHtCQAUAbedGEWgxIlAvDFY + ndwTwOv8ZXADCo8I8ArSTxaBhBCYHkE2oSIAFBgxUBFQQBAoBioCQL69esXAIw5eYYgTnF/nn6ubMM4i + DpA9QXwzSjE525P0nNvg6nxD/Mkd/uRaPz6+z6yvjT6T9bXZB+Kz2Rdk1m/ulUhLn1nZ5zK/JT/H+ftd + zc9uP8mvO/pa2287/kp+Xd57RA499qRu7vHksePylK7vPyWjG4dlRs6n5KHsT8mMJX8qu6vvnvKuP8Gy + luWtfbz9+FkRK//gL+FD+3KqD/NaEcMNXo2a//5Fn5QHF98ls5feK9HmNgmHW6Sx0cwX4CKiaicCFXUJ + IaAjUCFgb6DGiADdAEsDwAwTWicAAVDQDUAYnAgsdVcrBHkUAisGRgB49boBKwSEcwQqBrVWCDywgmCQ + IL8Bv4ei4YjOq/kz12wkdCQCVw5P6hAlM72H9HydqPFdxjfTeL3ETyzkYa1v7X61mdhTWZcY4qsNtGu9 + z6zPYT5afhKfmb8Ftr+tA1kflp/k7+5Dvd8P8jPzW/K7mt9lftb8hvyPIvM/Zsh/6Emt+5/g1l5c4fc8 + p/meliPHngDx78Jz8Empy79T3p6Gut8gvds+2n6824gFb7+PZ6Sn/kCvDW9GPiYr8u6UBxb+iSxZNk/a + 27qlGSIQCiVEwDkBNgYrKr3NQSMCnC9AEfCiGGKQmDZMQaAjoAiYKcQsCVyTUIXAuQGFEYLcwmqQLCEG + OYXJ5YETAgdTHrirQUIU2FRMYPJ7BxLdXR3pDfE5aYnkN+DiJt2bn6S3Gd9L/CvqfDb5LPGTsn7c8tvx + fU+zz2T9AWltR9a35Gezz5F/YHCtsf1jID+In1Tzb3W2/6Cx/QeOykFkfpKfp/keA/mfOW429jx95pyc + OXte5hc+IEuW/B/5dtP0kB/l7Dclesev2cfaj58nJJK+P9WHOhX4+8Y7JGvRnVJUvlQ62nukrbVTItE2 + CQabVQTqG4LaE6itMW6gsoqOwAoBm4ReRzBJBFQI7LThZYBbQ6Ai4GCFwAt1BFYI1BGoEEAQnCtwYsCG + IZAQA9MzYONQgdcUBTeq4L1OhndSEpGK8Lq82e13oMR3m6KaNfuT5/BPHtojSPx4rR8wWT9u+d34Pif3 + MOuT/Jzaa8mvs/tg+804/zqt90fXJMjPg1ZZ87Pbv8eSn5nfkZ+Z/9hThvy0/tzW+9y5S/Ly5c/jd8yW + r9R+NOUzcs2A24yF0ovs4+zHzxuxug/95kQ44zspP9wpwJdr7pDqmhLp7OiR9vZuaW3t0KHCYMiIAHsC + 9fVBFQGOELiywJUGTgjoBpavqEVpYFDiFQIrBioIupLQ4wY4jbiYU4k5aciKgAqBGTY0Q4cUA44UWEHQ + 10SdioIpF8wEI9M7IEBqReK1mX6cTHY3LTnPvnarFx3p3QYnhvjM+iR+ItsnZvFZ4sPqG+Ib0hPxGX2s + 9d8x65shPpKfWZ/NPs36dnafyfyc3rteRsYM+TnDz2X+rdv3yHbdyvtK8nNHX93UE+Tn8l6u8ONMvwuX + Lsurr35BvtY9J+WzMRXQpe7RD/yCfZz9uJpA/VSc6sOdEkChv9z8oPR09UgHRaCtS1pbrAjACTQ1RSWg + bgAlQR03GDFDhVUeR1BOIQCMG6izZw7WJkoDCkIZBAHkT15SbNYRqDOgCHDI0MEzm1DFwE4mohjorEI7 + tTg+u5BCwGsK0Clw5qGuQ9DZh3ZdgoUjvdvEpMBDfCU8YZt7iT35Dekd8Vnjx4f1AK3zPXY/sZAnQXyX + 9Z3ln5z1u0H8eKd/yHb6OcHH1vvrN27TzE/ya+Z/hPv4P6bd/kOHQf4j1vYf446+JD8y/8mX5OzZi3L+ + wsty+fIX5Y1d4Wlp+hFIXD+ONaV9wj7GflxtQEH/DeqoZ1J9yFOFV1ozIQJ90tkJIaATgAhEUQ6ErRA0 + NkaloYFuICS1LAviQtAoFZw3AEdQXgGoI6iLC4ETAyMIFIJauAIDCoDZZcgJAcHlxYnFRbrAyM4mjM8q + 1LUF7mpWHlIQzHuz8pArEQ25PbB7FHCZMlGglj4ZZnNTs9EpszwJzxOQSHo29dxpPF7is6tvrL4hvtb5 + AO0+ye8yvk7nBfnd8J6b2GMafbbL380u/6hu5BFv9rlhPju115F/05ZdhvzeGX4kv7P9TyLzP20y/3Mk + /6kzlvyXYf2/IK8fGOCGHCmfh6nARCR9xD7CflxrSMMdvzsRSvunVB/0lABZ4FxbtvT2DEAEevFAdmtP + oLm5XfsCbA7GhYBDhSgL1BFADKpqAAhBZRVBVxCAENS/gxDUqRCoGAAUgpLldXFR0E1HueMQYDYd4W5D + HoDsuvmIhVt6nLwZCV87gOgWumWZvTokdjYOKNl50InJ8pb0mu2TSe+Iz225XY2flPHjVj+xaYcSn3a/ + GcT3ZH03vMf5/K7L7836avltve8sP5f0cpjPTO/dn0R+jvPrKT72IA+1/S/A9r9obL8j/zcOr5FYdJrq + fgDW/69vyZ1+pzMklL50uuwawWxwtj3XiEB3nzoBlgQtzSgJ6AbCrRIKtkgTRCAQYH8ApQEcgRGCoFRD + CIhKdQUBuAIjBCoGwIpyAyMGCZQCFIHSFfV6NYKQgNmJOAHvfoTJexImY/KmpUlwWR4ojhO+SQnvDt0k + ePCmEt6CJ/EkMn6C+Jy+qzv06ni+Ib4jv9b5avfdpJ4BabEdftb6Juub7btcl5+NPjO5Z6OMwfKT/Mz6 + 47bZx07/rj0c5jscn957yJKf4/yTa35m/gsXX1Hy/82R9RJr/njKZ2AqwJGrWFP6A/ax9WOqQvcPDGXs + SfWhTxUoAmfa86S3d1C6u/ulC27A9AXgBqLGDcSFoKlZAuoIjBDUslkIIahBeUAhqFJHADGAEFAMiJUV + DQarGiAGDbJcBaE+LgQUgSQspygkUJwCbptyopgnF4HwxczoXqwIgOgkewIlSnhzyGYS4S0c6XkCjzuE + g+AxXLoltyU9V+wZ4tvO/qQGH4kfH9fnxh2erB9v9IH4XvKPjI4nzezTen/LTl3Rx3rfzO4zY/wkv2Z+ + buT55HHN/NzRh5lfa/6XYPsvXtaa/2+OjoP8U7u5x2RMhNI32UfWj6kOCaT/Z4jA/031wU8lznfkSH/f + oPTADXR1wQ2gJHBuoBnQ/gCFINSqQsDSwLmCuoawikFNLTckDaI8YInQlCQE5UQFBQGgGFhQEMogCMvx + mtcyiABRuqLhCpQ4rDTXUpC8ZCWAaymvcTSC3CS6QdkqWnqS3YFkN0dsK6oSVx65bep6Z/FZ25utudyu + vHHie60+M763u2+J73btUbsP4rPRFx/bZ6NvxDT6zPi+7fIj6+vMvh17Qf79soeWf//j8U7/Y48nyM8T + fDjF98SLZ3Soj1t5M/OT/H97ePW0Zn5iIprxmm/9pzligY/cORFOn/J9AybjlY6FMtg/KH3WDbA3wKHC + tlYrBHAE0Uh7Qghcj0BdQVTqIQR12jTkzMJQkhhUUhDgDlZVWlQ0QhAaIQgOAZAyAPsNrLKAYygrD0xC + I8gM8KoEN9fljuj2tSM7iT4ZJHp5dQJmA05meWR7EN+Qnt18Q3oewOmIz735zHLdbkN8ncKbIP7kOp8Z + X+0+V/DZJt/AELI+av1hEH8Etf7YpKy/ZZsZ4qPl37vPWP79B4/YTj8P7jSdfs7wU/K/cEZOnYbtR+a/ + cAnkf+WL8vqB/mmt+Qkkph9L8PbP2MfUj+mMWDh9eaqbMKWIZMhftM2W0YEB6e0b0t5AlwqBmzPQqUJA + RCEG4XCbhIBgCOUBSoTGxmYVgoYGDiPCGdTDGUAMaigGQDUFQUUhqIJQWWVQAayqtKgKwi00GVQ0QRgS + V2KFolGv5mskubl6UV4ZSsIqZncS316NrTfWnoSv4lHbkzM9wOO3uCdfYhzfrtO3NX6kFVa/3ZPxSX4Q + XxfwWLvfxyafncc/udYn8V2jbxMbfTrEtx+W/1B8fN/U+4b87PRrs+9Z0+l/4cWzcurMec38XNP/yitf + kDd2h6e126/AszIRSW+xj6cf1yMmIhkbp7MpqMDPf731Ptkw0IOHdljdQKIs4LwB4wi0R6BC0CHhCIWA + k4noCiAE2isAksQggjKBCBsxcKgJqSAYUUiggoAYUBAqqkhgg/jrSv5Z4utxIKNX1HgRkUoFyG5JX0WQ + 8Nbe1wJ1SnpD/HruxWdre4KHcHBDTmb7ULMZy+cMPj2LD8RP6uyzwQfys8HX0w+7D+JrxnfER9Yn8a/I + +pzYs/MR2bmbWT/R5VfLn6LeV/KfPKu7+J47/7JcuvR5+cKll+W7m8qmbZzfC5D/hBT/wb+zj6Yf1yMk + +ge/PBFJO5/qhkw1vtfySdkx0CaDg9x5hjvQoCywQ4YdHSwNOJXYCAERhRhEVAzarSvgFGP2C4wzoCCY + MiEKshkYQYhITR0BYQCqa3mNgKQQBoICQej7MEgcAsL4Gr/HkJtXfa0ZHa/rSPAEqol6nqjbrGSvbbCE + t1DC66Qdkp6dfHPyDrN9MMLjt7r18M1oK9fom4xP0nNvPjOW74jPzr5p8LlpvBzTH0Kdb+w+yO8hvqn1 + d9tan40+M6tPyX/IDPHF5/R7LL92+lHvm2E+kP/lz8uXzp2WH45kpryXU42JcMb/i9Wn/7Z9LP24nhFr + +vBv4AZ8I9WNmWq81fwJOdZXLcMjq1UI+lEW9PRYIYAjaFch6NZ1BXQGFIIWdQYUhM64GITC7eoO4oIA + qENwJUOg2YoCCUphMKihOMTB9ySzfQ1Sx0Fy41qrBLdQklsgs9c3JtDQxAxPwvOATUd41vXmpF2CB26y + rleL7832ID1hsj1rfDb3TI2v4/nejM86f7Wt8yfbfWR9M513n+zUWv9gvNGnXX7b6NPJPSA/m33Hnz9p + mn2nz6HevyAXLr6sw3xff/6QvN316ZT3cKrBuj8WvO1u+zj68V5ELPSRj02Ep3GSkAcT4Tvk5e6lsmZ0 + TIaGxuAGhiEEw3bYkI6AswkJjzOAGLQQLV0Qgy6UCVx0RHSoGBhBaAPpWqVRSwYnCkYYGgItcdRbNJC8 + nvfxr5Pc9mpeW6LzvVp5kFyJ3q5Eb+S5eiB6U5iHa04mPJt5PRLWTM+GnmcYD+hQmz+YRPxez3JdgsRn + xh+B3eeyXWZ8N6ZP4utU3m17dPkuJ/Vo1t/3eNLEHk7pPXLUZv0Ulv+lcxdNvQ/ys9k30fKJlPduOhAL + ZdTYx9CP9zJiobQHtQub4iZNOVBTfrPtftk20idjo8huEAI6gj42Cnu5SaWdQ9BloELQASGgGACtKgYG + yYIARFg2kIwQBQWFwYiDCkRTMgK8BtuSge8PIKs3hkjyBJpA+KADyB4m0YGIWnrU8iB71KKZWR5o4WYc + jvTM9JrtE6R39T2zfe+gtfk243sX7jjiJ3f3zYQeQ/xDunGH6/B7x/Y16z+FrP8sh/jMUt6E5b+klv8L + 51+Sfxpfdl3q/ThCGds4N8U+gn6818FllxOh9GnZPyAVftRypzwzUCtjq9fLKIRgeBgEGGAGHJE+CEEv + ygMtEawQqBjAHbRzOJGCwDKhFUIAtLZCGHClIDRDGKIUBgsKQ9gKRDgCIFvzGsI1xKt77X0fB2t2S3IF + XjO7A0p2Zndby5PsLbaD38r99l2m12xvjtzqAvGZ6U225xg+p+3yFB6u0QfxeRjHqLH6JL5O5FlvrH6i + zndj+vtk195Jdv/gE8nr9ydnfWv5X3rpklyw03r/8vh++XH33Snv0XRhIpJxKlb12//BPnp+3CiBmxOY + fLOmE9xd6KvdWbJ5zaishhCMjfI4KmZC1r8j0t8/bJ2B6RV0QxA4lKjDiRAEgr2DtnaDdnttbesBIQEI + Q/yqYoHsrM6BImGvfK+Z27xWeL/Ov6NEZ1bvNUTH61Zt3pHs5somXhuyu2Z4eyXhu3ptXa8NPTNxp4/Z + fsjswR8n/RiH88b1MA43gy9R4+/SjB8nPuv8R8zQHrO+Du15JvU88aSZzhuv9V84k8j65y/LxYuvyqsX + L8o/7Gya9pl9kwGn+ZexxrRft4+cHzdawAUgzaW+edOFH7T8iTw90iTr1o1bIVgrI8MgyBDFgKfU8rBK + IwbqDgB1B90QBYDugGLQ0WnQqVe6BYIi0YeMDNICLRCM1nYS2H4N2Ztos19LBi08Cc5NNUly7qdv4Ije + 2W0sfUcPbb2r5xOkZ5bXTM/dd9Xiu9o+MZTnDuFwC3bWj5san809JT5qfEf8PY+wzrfdfV26a7r7JP5R + 2H0d3mOHn9N5T5xOGtu/cMHM5//68Uflzb4Hrq/lB5D534iFPvL79lHz40YMXTMQyRhKdQOnE3QDr3XP + l53rhlUI1q7ZIKvH1snoCE+oBWngCgYBDiP2o0ygO3AOocf2DnpARoduoIvkpGvookgYdBIQDSMWJLIH + 9n0nrklwRNerI7olu23g9fSbDG+yvCG81vTazOOBG6aTP2K33x7TvfgStb1me9b3XLBjh/NY4xviHzCr + 9mD1HfG9Y/q6aYe1+25Sz4kXzc49zPrxsf1zZ+VbWyunfVZfSkTSvhcLZNxpHzM/buTQPQSC6WPXO0MQ + bzX/kZwfXCmbxzfI+g2wwmvHZQ3EYIxiMAoSwRk4d0BBILRcGIBTYP8A6EUG7uvDFSSlW1DH4ICvdQO8 + GuEgic3XSGoltH1vMIzvIzg8x6zuuvXAgCH7gIfszPDxWXogPTv4I9x/j5N2SHy7Os9Let2M09p8LtPl + 1F2exMONOUl8N4vPEV+zvt2wQ3fptcQ//lzC7p8+Y4h/gQt5Lr0if/vYyLTs1/9uwKnnsXDavfbx8uNm + CLORSNpgqhs67YDwfK/9M/Lc6pBs3LRZT5xdtx7ZEmKwWsUAZQIwOrJW4QRBRSFJGFg+eADSEioSILKS + 2INeXkHqXnyve91PkuuVE3ISmZ2kVytvoeP0Snh27zlsx3reED5h79nFT2R6kp678HIM39n8xHAeM76d + vuvN+BzWI/HtTD4lPur8506c1KW7ZmiPi3gua4f/68/slR8NPnzd7b4DSso3Y03ps+xj5cfNFGYJcXrX + RDgjlurmTjvw0L7R+YA8ta4d9TAzJQg0bsRg3TpkUhCMMIJgHMLIqBEFjiyMsHyAOAxDFIZZexODFAqX + qTnRhjBfSwJtuwN+nrni5zsbbzO7ZnX+DgozSccRfnKW5zl7Snw7T5/LcxPZ/oCp7/cbq88deV1zj9ne + 1PiJjG9W7nFYDxn/5Etyyk7o4Wy+iy+/Kl89cUS+t24pSqvp2qr7ZwOl5Fux4O1Z9nHy42aNWCitYWKa + thh/N2B/4I2uGfLM+k7Zum2HisHGTVtlfOMW2YAyYb0VBC0X1CWAjKtJTmbihGMYg0BQJAw4/Ghs+rD9 + 2giB7zMgwfE9NpvHM7oD/r3VFCE6E2DtBm+GBzZx2M4QnqfraqYH4ZX0OnGHtT2X5x6UvfvMuXv7H7U2 + /5DJ9q6552bwsbnnrP7zL3AyD1funTdr9i9c1gk9X3nhqHx3wzLU+de3uz8ZsP1vxsIZ8+wj5MfNHmae + wHWaLPQOoBB8u/M+Ob0mKLu3cxYcLPRWkowZljvcsoO+WbGWpFxPgkIYlKwQBxKWr51Q2KuCpMZ1zH7f + Wtbq9vv1vf48CA2JDqwn2QElOzBOwgMbQfpNW3dqlt+ync08Q/gdyPQE63qt7feZufokvZuyS+Ir6Y88 + rbP33Go9Zntn9ZnxOYsvQXxkfNT4X3v2gHxvbe570+CbBDwnP4g1pc2wj44f75eIhW+fCVv3/VQ3/boC + QvDDtk/Jl0ZWyOFt47JzFwi2c7cVBDoEDqElC8MGugXAENeIhJLZXS2pJxM8FcnjREdmJzZzuI62Xsfq + E4R3WZ41/Z5HDsUbetrJ91h8N5THc/fY0Tc234zjc8GOdvVtc887pHf5/AX5q8Nr5YfDc1QcU35W1xkT + 0Yzv+uv638cBEfjDiVDaN1Pd/OsOPPQ/jX5cvtk7V85saJVH9+yV3XsehSAw23IYjZYbwrAd2VizMuvv + hEB4X1/5NUNuJbj+XQMluiezb9fJOSa7m1qehGc9z+m5ILxdjuvsfXzSzmGX6WHxSXrb1NNsf/wFre+5 + LRezvRvOM8S/LF9+/qi8sbVG3m7/1HvW3EsFPhexpvSP20fFj/drxIK3/0/c8JcnPwDvKUCEt1rulG8M + Zsupzb1ycO8jIB/q60cOqCjs2r1fCUpQHBwoEgoQegcJjde8Ktz34fVOdugVLrObYTrXvNOZeSS8zfBu + 2E6tPRt5yPAJe+/N9CD9s7T4ZtYeJ+9wlR4bexzKI+nPn39ZvnjimPzd7lb50cBD72lj750A8n/JP8Dz + FgqJ3varE5H0nTdSBooDv9OPm/9IXh9YJJc2tsixPdvlgGZh1tzssnOYzWDvvgNajxM8HCP+Gl/3vjfk + JtiwI8k5REeic2KOI7vZV59Tcr2EP2rr+SePPSc8YovNPF2cc/xFO4THiTunkenPymlb2184e06+8vQj + 8vqOkPyof8YNSXoFPuuJcNpT3G/SPhp+3CrBYcJYOK16IpzxVsqH40YAH9DIR+Wfu++Tvx4tkktbOuSZ + fTvlMDfJYP1NS84sjfccbz/A1XQW5mts0BlyH9TvY0bH3zlsiO6W3LrGHcHsrtNyUcfHCR+39iS92XXX + 2XuO3Z8/dVq+9NQ++cbuNvnumjzY+z819v5GFFgLDg/rXJHobb9oHwk/bsWACHx6Iprxt6kekhsOIBSz + 6Y9QP78xuEC+vrZCXt7aJS/u2ypPPXZQjhw5piTm8Bsn3CipvVcPlOTI6prZQXKCZ+erpY+T3Ryrpctw + T56WUy+eknPPPyNfPLpLXtvbK29sXCU/GJojP2m984YnvBe439+PRdLz7CPgx60esWjGf58Ipz95szzA + SYgC+L0nIh+DMNwl3+mfLd8cXSqvra+Ur2yJyud39sulR9bJuQNb5cxje+Tk44/KySOH5OSTR4CjcurY + 43IaeOnJg3Lh6D55+fGd8sWD4/LnjwzJazta5O82Vsq31hTIDwZmyY/bPymxMOy8/TdT/j43Mvg5hTK+ + GmtMy7C33g8/THD6MLJCFWzhtG87ft1AkhJRkhbAa+6SSxfB0sKB73X33Enfq/D+vJsYavmj6Vti0Q/+ + R3vL/fDjypCm2z46EUl75f308N/qmIikfzsWSsu2t9gPP/71kOjv/HuUBK2wi2+meqB83CSAiIP8z3Lo + 195aP/x49xGLpmWgJLjgu4GbD7D835FwejFLO3s7/fDj5w8e+hCLZJRDCK7L7sM+rg1a60fS9saafv+3 + 7C30w49rj1j0Q78p0YxtE6H0n6R68Hy895iIZPw57P599pb54cfURyyc9sd40E75ZcGNg4lQ2rdi4fRK + 9m7sbfLDj+kLHTIM3T4XbuArvhC8d+DS3Ylwen8s8OH/Ym+NH35cv+A00lgoowB151/6QnD9gIz/L3Bh + a/zuvh83RNB66qYj4Yyv+kIwTcDnCsf1zyD+mL9yz48bMnTEIJS2AEJwDg/qe7MX4fsNJH4k7XUJ397s + H8rhx00RXGkowYxPTkQz9tCu+q7g5wfq+4mJaPqZWOj2XB4Hbz9aP/y4uSIWTf/tWCijEY7ga74Q/AxE + QfxwxhsTkfQxfGYfsx+hH37c/CHRD/wCxOAuCMFGuIJ/8MXAghY/nP59EP/RWDh9lp/t/Xjfh0R/45e5 + 8+xE+PatEIQ3bjkxIOkjGd/GdX8scnuWP4znxy0bsfIP/pJuShJM70cmfHUimPYTXW+fijg3K9Tap709 + EbnjlYlQel8smnG3f8S2H36kCA5xof5diDp43UQ0/csQhbduKofA3zVh68+B8AMSSpvNqdT2v+iHH368 + 2+DQFxzCvbFQehCicAiZ9C+AHynR3sudefTfv4OZ/acTkbR/nIhmvITXG2PB28u4/bo0/N5/sv8FP/zw + Y6pChxgrfufX2CXn8VWxYHr9RChtHNn2SeALHDPX7BtMN8ehWaImg1+bDM+fW1HBz4vh57zJpiVHMfBz + X0BG34UypT0WTMvHv32XNHzodzn/wf56fvjhx3sZkvmBf8ttz9U5hNI/FGtK+0QsfMdnY+H0B/B6Dicq + cXccCEhuHMH0Rfje+RCUmfh79yKL/0ks9JHbY013/BYzub9zrh9++OGHH3744Ycffvjhhx9++OGHH374 + 4Ycffvjhhx9++OGHH3744Ycffvjhhx9++OGHH3744Ycffvjhhx9++OGHH3744Ycffvjhhx9++OGHH374 + 4Ycffvjhhx9++OGHH3744Ycffvjhhx9++OGHH3744cd7GB/4wP8HlOWJxxjDymUAAAAASUVORK5CYIIo + AAAAgAAAAAABAAABACAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA/wEAAP8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + f/8CLH3+RS19/Z0ufv3iLn7//y5+//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln7//y5+//8sfP3rLX/9ri18/lokf/4OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAM2b/BS18/nUufv3uLn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln79/i1+/bQsef4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAff/8ILXz9oi5+//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//LH3/8Cx8/lYA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAs + e/5bLH39/C59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8tfv3aJ3/+GgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtf/2YLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln79/i18/k4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuf/2eLn3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//8s + fP9QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAufv5tLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8sfv38J3f/IAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkef4VLX79/C59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Lnz90QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALX79qS59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx4/jkA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALnP+Cy58/f0uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y5+//8vff7/P4X3/1WP7f9hk+b/aZbj/2yY4/9nlub/XpTr/0qL9P82gfv/Ln7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y1+/b4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC55/lgu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y5+//9SjOr/jaHJ/7Swsv+1sa//trCv/7axsP+2sK//trGv/7eysP+4 + s7H/ubOy/7u2tP+8t7X/vbi3/766uf/Bvbv/w7++/8fCwv+tuND/bJvp/zB+/v8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//yx9/foAAP8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtff25Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//OIH4/4acxv+wqqr/rain/6unpf+q + p6X/qaak/6mlpP+ppqT/qaak/6mlpP+tp6X/rKel/62pp/+xqqn/sauq/7Otq/+1r67/t7Gw/7izsv+6 + tLT/vbi3/7+7uf/Bvrz/xsHA/8rGxf+yvNP/UI70/y5+//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//8qf/8YAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALX797C59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + fv7/epfJ/6ilpP+loaD/o5+e/6Kfnf+gnZv/oJ2b/6Ccmv+fm5n/n5uZ/5+bmf+gnJr/oZ2b/6Gdm/+i + npz/pKCe/6Whn/+moqD/qKWj/6umpf+tqaf/sKqo/7Ksqv+1r67/t7Gw/7q1tP+8t7b/v7u5/8S/vv/H + w8L/zMjH/6a32P8zgf3/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8sff45AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAACx8/fsuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//82gfj/lp2s/6Kfnv+fnJr/nZqZ/5uYlv+alpT/mpaU/5qVk/+Z + lJP/mZST/5mUk/+ZlJP/mZWS/5qVk/+alZP/m5aU/5yXlf+dmZb/npqX/5+bmP+gnJr/oZ2b/6Sgnv+n + o6D/qaWj/6yopv+wqqn/sqyq/7awr/+4srH/u7a1/724t//Dvr3/xsLA/8vHx//IyM//RIn4/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8s + ev5RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wEufv//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8zgPr/mJyk/52amf+a + lpX/mZSU/5eSkv+VkZL/lI+P/5WQkP+Ujo7/lI6N/5ONjf+TjYz/k42M/5ONjf+Ujo3/lY6O/5WPjv+V + jo7/l5CP/5eRkP+YkpH/mpOS/5qVk/+cl5T/nZiV/5+bmP+hnJr/pJ+d/6ejoP+qpaP/r6in/7Grqf+1 + r63/t7Gw/7q1tP++uLj/wr68/8TCwP/MyMf/ycnP/ziD/P8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8rff5TAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAP8BLn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8ufv//gpSz/5qXlv+Xk5P/lZCR/5SPj/+SjY3/kIuL/5CLiv+Pior/jomJ/46JiP+O + iIj/joiI/46Ih/+OiIf/joiH/46Ih/+Oh4f/j4mH/4+JiP+Rion/kYuJ/5KLiv+UjYz/lY6O/5WPjv+X + kJD/mZKR/5qVkv+dmJb/n5qX/6Gcmv+moZ//qaWi/62opv+xq6n/tK6s/7axr/+7tbT/vri4/8O+vf/H + w8L/zcnI/7C+1/8ufv//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8te/4+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//R4Tn/5mVlf+VkpL/k46O/5CMjP+O + ion/jomJ/42Ih/+Lhob/i4WF/4uFhP+LhYP/ioSC/4qEgv+JgoD/iYKB/4mCgf+Kg4H/iYKA/4uDgf+L + g4D/jISC/4yEgv+NhoT/jYaF/46IhP+PiIf/kImH/5KLif+UjYv/lY6N/5eQj/+ZkpD/m5WS/56Yl/+g + m5j/pJ+d/6ikov+sp6X/saup/7SvrP+3srD/u7W1/767uf/EwL7/ysXF/9DMy/9fl/H/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8re/4dAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAsfP37Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//4GQq/+UkJH/kY2N/42Jif+NiIn/i4aG/4qFhf+JhIL/iIKC/4iBgP+Gf3//hn9+/4V+ff+E + fXv/hHx7/4R8e/+EfHr/hHx6/4R8ev+EfXr/hX16/4Z9e/+GfX3/h359/4mAfv+Kgn//ioJ//4yDgf+N + hIL/joWE/4+Hhv+QiYf/koqJ/5SNjP+Vj4z/l5GP/5qUkv+cl5T/n5qX/6OenP+no6H/rqim/7Ksqv+1 + rq3/uLOy/723t//Avbv/x8LB/8zKyf+7w9X/Ln7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8zZv8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH796i59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//zF/+/+VkpH/kIyM/46Jif+Lhob/iYWF/4iDg/+H + goH/hX9+/4R+ff+CfHv/gnx6/4F6ef+AeXj/gHd2/4B3dv+Ad3X/f3Z0/4B3dP+Ad3T/gHd1/4B2dP+B + d3X/gXd1/4J4dv+DeXf/hHp3/4V8ef+FfHn/h317/4h/ff+JgX3/i4N//42Egf+OhYP/j4eH/5GJh/+T + i4r/lY6N/5iRj/+alJH/nJeU/6CbmP+ln53/qaSi/6+pqP+zrav/trCv/7u2tf+/urn/xcC//8rHxv/R + zcz/OYT8/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y58/f0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC1+/bQuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9A + gev/kY6N/46Jiv+Kh4b/iIOE/4WAgf+Ef37/g359/4F7ev+AeXn/fnd3/393df9+dnT/fXVz/3x0cv98 + c3H/e3Jw/3tyb/98cm//fHJv/3xyb/99cm//fXJv/31zb/9+dHD/fnRw/390cf+AdXH/gHZz/4F2dP+D + eHb/hHl2/4V6eP+HfHr/h358/4mBfv+Mg3//joWC/4+GhP+QiYf/k4qK/5WNjP+YkI//mpSR/52Ylf+h + nJn/pqGf/6ympP+xq6n/ta+t/7mzsv+9uLf/w7+9/8nFw//QzMv/Xpbx/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59/dgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfP5OLn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//VIXT/42Jiv+Lh4f/iIOE/4WAgf+Efn7/gXt6/4B6ef9+ + d3b/fXZ1/3x0c/97c3L/enJw/3lxb/95cG7/enBu/3pwbP95b2v/eW5r/3lua/95bmr/em5q/3pvav97 + bmr/e25q/3tvbP98b2z/fG9s/31wbP99cW7/fnNv/4B0cP+AdHH/gnZz/4J4dP+Eenb/hnt3/4d9ev+J + f3z/i4J//42Egf+Ph4T/kYmH/5OLiv+Vjo3/mZGP/5uWkv+emZb/o56b/6mkof+wqqj/s62r/7eysP+9 + t7f/wb27/8bDwv/Oysn/hKjm/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y58/l4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAKn//Bi59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//1+Fxv+M + iIn/h4SE/4WAgf+Dfn7/gXt7/354d/98d3b/e3V0/3pycf95cW//eHBu/3dwbf94bmz/dmxq/3Ztav92 + bGn/dmtp/3draP93a2j/dmtn/3drZ/93amb/d2tm/3hrZv93amb/eWtm/3lsZ/96bWf/em1o/3ttaf98 + b2v/fW9r/31xbP9+cm7/gHRv/4F1cP+Cd3P/g3h1/4Z7d/+IfXr/iX99/4yCf/+OhIL/j4aE/5KKh/+U + jIv/lo+O/5qTkf+cl5T/oZyZ/6ahn/+uqKb/sqyq/7awr/+7trX/wLu6/8bCwf/Oysn/mLLh/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//zNm/wUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfv36Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//9ehMX/ioeG/4aCg/+Df37/gHp7/314d/98dnb/enRz/3pycv94 + cW//dm5s/3Vtav91bGr/dWtp/3RqaP91amf/dWpn/3VpZf90aGP/dWll/3ZpZP92aGT/dWdj/3VnYv92 + aGP/dmhi/3doY/93aGP/eGlk/3hoZP94aWT/emtl/3psZv97bWf/fG5o/3xuaf99b2r/fnBr/39zbv+B + dG//gnVy/4R5df+Fenb/iH16/4l/ff+Mgn7/j4aD/4+Ihf+Si4j/lY6N/5mSkP+blpL/n5qX/6Wfnf+q + paP/saup/7awr/+6tbT/v7u5/8bCwP/Oysn/mLLg/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln398wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXz9kS59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//UYLR/4mFhf+F + gYL/gX18/395ef97dnb/eXNz/3lycP92cG7/dW5s/3Vsa/90a2n/dGtp/3NpZv9zaGX/c2hk/3JnY/90 + Z2P/dGdi/3RmYf90ZWD/dGVg/3RmYP91Zl//dWVf/3VlX/91ZWD/dWVe/3ZmX/92ZmD/dmZg/3dnYf93 + Z2H/eGdh/3hoY/96amT/empl/3tsZv98bWj/fW9q/35wa/9/cm3/gHRv/4N2cv+EeHT/hnp3/4h+e/+J + gH3/jYOA/4+GhP+Riof/lIyL/5aQjv+alJH/npmW/6OenP+ppKL/sKqo/7Wvrv+6tbT/v7q5/8XBwf/N + ycj/hanl/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//LHv+YQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9//wguff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y923f+HhIL/hoKD/4F8fP98d3b/enR0/3hycf92cG//dG1s/3Nrav90 + a2n/cmln/3JpZf9zaGX/cmhk/3JnY/9zZmL/c2Zh/3JmYP9zZWD/dGVg/3NlXv9zZF7/dGVe/3VlXv90 + ZF3/dWRd/3ZkXf91ZFz/dmRc/3ZkXP92ZFz/d2Vd/3dlXf93ZV//eGZf/3hnYP95aGL/eWhi/3pqY/97 + a2X/fG1n/35vav9+cGv/f3Jt/4F0b/+DdnP/hHh1/4d8ef+If3z/jIJ//4+Fg/+QiIb/k4uJ/5aOjf+a + k5H/nZiV/6Gdmv+opKH/sKqo/7Wurf+5tLP/v7u5/8XBwP/Oy8n/MHHJ/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALX398S59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8wfvv/O1lJ/3J4cv+B + fXz/fHd3/3dycv92b2//dG1t/3Nsav9zamj/c2po/3FpZv9xZ2T/cWdk/3JnY/9yZWL/cmZh/3FlYP9y + ZWD/dGVf/3NlXv9zZF7/dGRd/3VkXP90Y1z/dWNb/3ViWv91Y1r/dWNa/3ZjWv92Ylr/dWJa/3djWv92 + Y1r/d2Rb/3dkXP93ZFz/eGVd/3hlXv95Zl//eWdg/3loYv96amP/e2tl/31taP99bmn/fnBr/4Bzbf+C + dXH/g3Zz/4Z6dv+IfXr/i4F+/42Egf+PiIX/kouI/5WOjf+ZkpD/nJaU/6Gcmv+opKH/r6qo/7Wvrf+5 + tLP/wLy6/8fFxP86WEj/L3z0/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8v + ff29AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt7/jouff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//2Zxa/8+XUv/TGdV/314eP94cnP/dW5u/3Jra/9yamn/cmpo/3FpZ/9w + aGX/cWdk/3BmY/9xZmL/cmVh/3JmYf9zZmD/c2Vf/3NlXv9zZF3/dGRd/3RjXP90Y1v/dWNb/3ZjWv91 + Yln/dmJZ/3ZiWf92Ylj/dmFY/3diWP92YVj/dmFX/3dhWP92Ylj/d2FY/3djWf94Y1r/eGRa/3hlXP94 + ZV3/eWZf/3lmX/96aGL/empj/3trZP99bWj/fm9q/39xbP+AdG//g3Zz/4V5df+HfXr/iYB9/42EgP+P + h4T/kouH/5WNjP+ZkpD/nJeU/6Gcmv+no6H/sKqo/7awrv+8trX/trey/z5fTf89XEr/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8qf/8GAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9ugKT/VGpc/0JjTf9E + aVH/eXN0/3Vubv9zbGz/cWpo/3FpZ/9waGb/cGhl/3BnY/9xZ2P/cmZi/3JmYf9yZWD/dGVg/3NlX/90 + ZF7/dWVd/3VkXf90Y1v/dmNa/3djWv92Y1r/d2NZ/3diWf93Ylj/d2FX/3dhV/94YVb/d2FW/3dhVv93 + YVb/d2FW/3hhVv93YVb/d2FW/3hiWP93Ylj/eGNa/3hjW/95ZFv/eGRc/3lmXv95Z2D/eWhh/3prY/98 + bGX/fW5p/35wa/+Ac23/gnVx/4N4dP+HfHj/iH58/4yDf/+Ph4T/kYmH/5SOjP+ZkpD/nJeU/6Gcmv+o + pKH/saup/7exsP9ffGr/QGVO/z9hTf+lscr/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//yx+/doAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt7/lcuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//On/t/4B8ff9PaVf/RWpR/0hwVP9kcmf/c2xt/3FqaP9xaWf/cGhm/29nZP9w + ZmP/cWdj/3NmYv9yZmH/c2Zh/3RmYP91Zl//dWVe/3ZlXf93ZV3/dmRc/3dkW/94ZFr/eGNZ/3hjWf95 + Ylj/eGFX/3liV/95YVb/eWBV/3lhVf95YFX/eWBU/3lgVf95YFX/eWBV/3lgVf95YFX/eGBV/3lhVv94 + YVb/eGJX/3hiWf94Y1r/eWRb/3hlXP95Zl//eWdg/3pqYv97a2T/fW1n/31vav+Acmz/gXRw/4N3dP+G + e3f/iH57/4yCgP+Ph4T/kYmH/5SNjP+YkpD/nJeU/6Kdm/+qpqT/sqyq/0d0WP9DbFP/QmZR/7y4t/9P + jvT/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yRt/gcAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//+Cfn//e3d3/1VtXP9H + cFT/S3da/02BX/9ya2n/cWpo/3BnZv9waGX/cWdk/3JnY/9yZ2P/c2di/3RmYf91ZmD/dWVf/3VlXv93 + ZV7/d2Rc/3dkXf94ZFv/eWRa/3hjWf95Yln/eWJY/3piV/96Ylf/e2FW/3pgVf97YVX/emBU/3pgVP97 + YFP/e2BT/3pfU/96X1P/el9T/3pfU/95YFT/emFV/3phVf95YVb/eWFW/3hiV/94Ylj/eWRa/3lkXP94 + ZV3/emdf/3poYf97a2P/fGxm/31uaf9/cmz/gXRw/4J2c/+Ge3f/iH57/4uCf/+OhoP/kYmI/5WOjf+Z + kpH/npmW/6OfnP94kX//S3td/0hzV/9Ca1L/uLSz/87Lyf8ufv//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln790gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt9/jsuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//XX61/3x4eP93cnL/XW5h/0t0Vv9OfVz/UYdi/2Z2Z/9waGb/cWhl/3JoZP9y + aGT/c2dj/3RnYv91Z2H/dWdh/3ZmYP93Z2D/eGZf/3lmXv94ZVz/emVc/3lkW/96ZFr/emNZ/3tjWP97 + Ylf/fGJW/3xiVv97YVX/e2BT/3xgVP98YFL/fGBS/3xgUv98YFL/e19R/3tfUf97X1L/e19R/3tgUv96 + X1L/el9T/3pgVP95YFT/eWFV/3hhVv95Ylj/eWNa/3lkW/95ZFz/emZf/3lnYP97a2P/fGxm/3xuaf9/ + cWz/gHNv/4N2c/+Fe3f/h358/4uCf/+OhoT/koqJ/5WOjv+ak5L/npqW/1CJZP9NgV//SXVZ/0NtU/+3 + tLL/xsPC/4+s3/8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXz99y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+/v99eXr/eHJz/3Nub/9q + bmf/SXJV/05+Xf9SimP/VZBq/3BnZP9xaGT/c2hk/3RoZP91aGP/dmhj/3ZoYv93aGL/d2dg/3hmX/96 + Z1//emVd/3tlXP97ZVv/e2Ra/3xkWf97Ylj/fGJX/31iVv99YlX/fWFU/35hU/9+YVP/fmBS/31gUv9+ + X1H/fl9R/31fUf9+X1H/fl9R/3xeUf98XlH/fF9S/3tfUv97X1L/e19R/3tgU/96YFT/eWBV/3lhVf94 + YVf/eWJZ/3lkWv95ZVz/eWZf/3lnYP96amP/fGxm/3xuaf9+cWz/gHNu/4J3dP+Eenb/iH58/4yDgP+O + hoX/k4uK/5aQj/9sknn/UIxm/0+CYP9JdVf/SHBX/7m1s//Cvbz/y8bG/y5+//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8tfP2cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACp//wYuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Znui/3l0df90b3D/cWxs/3FsbP9Jc1T/T35a/1OIYf9Xkmz/YIlt/3NoZf90 + aWX/dWll/3ZoZP92aGP/eGhi/3loYv95Z2D/emdf/3tnXv97Zlz/fWZc/31mW/99ZVn/fmVY/35kV/9+ + Y1b/f2NV/39iVP+AYlT/f2FS/39hUf9/X1D/f2BQ/39fT/9/Xk//fl1P/4BjV/+RhoL/nJud/3xbUP+A + ZFj/fWFW/3xdUP98XlH/e19R/3tfUv97YFP/emBT/3phVv95Ylb/eWJY/3hjWv95ZFz/eWZe/3lnYP96 + amP/e2tl/3xuaf9+cWz/gHNv/4N3dP+Fe3f/iH99/42DgP+QiIX/ko6J/1aWb/9SjWX/ToBe/0p1WP9g + eGj/trKw/723tv/Ev7//oLTX/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXz9qC59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//96dXf/dXBx/3FsbP9x + a2r/cGpo/0xzVf9Pe1v/U4hh/1iSav9ZmG//cG1l/3VpZf92aWX/eGlk/3hpY/96amP/emlh/3toYP99 + aF//fWhe/31nXf9+Zlv/f2Za/4BmWf+AZVj/gWVX/4FkVv+BY1X/gWJT/4FiUv+BYVH/gmFR/4FgUP+B + XlD/hWhc/5eOi/+hoKL/oaGi/6Cgov+gn6H/fVtO/4RoXv+enZ//mpiZ/4p6df98XlP/e15R/3tfUv97 + YFL/emBU/3phVv95YVb/eWJX/3hjWf95ZFz/eWZe/3lnYP96amP/e2tm/3xuaf9+cWz/gHRv/4J3dP+G + e3j/iYF+/42Egv9cnHf/VZVv/1SNZf9MgF3/SnZY/4GEf/+xrKr/t7Ox/7+5uf/IxMP/Ln7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yt9/kcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAufv//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//W3mv/3Zycv9ybW3/cGtr/3Frav9waWj/UnBZ/096Wv9Uh2D/WZNp/1qYb/9c + oHj/d2pk/3ZrZf94amT/emtk/3xrZP99amP/fWlh/39pYP9/aF//gGhe/4FnXP+BZ1v/gmZZ/4JlWP+C + ZVf/g2RV/4NkU/+DY1P/g2JS/4NhUf+FZVj/nZWT/6Wlpv+mpab/pqWm/6Wlpv+lpab/pKSl/6OjpP9/ + W0z/hWhc/6Cgov+gn6H/np6g/5ybnv+Xk5P/hXFp/3teU/97YFP/e2BU/3pgVP95YVb/eWJX/3ljWf95 + ZFz/eWZe/3lnYf96amP/e2xm/3xvaf9+cW3/gXVw/4N4df+GfHr/eI99/1medP9Wl23/U4xj/09/Xf9J + dlj/lZCO/62opv+zrq3/u7W1/8G/vv+Hp9//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Lnz9+QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXj/ES59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//94c3T/c25v/3Bra/9w + amn/cGpp/3Fqaf9qa2T/TXhY/1SFXv9YkWf/W5pu/12gdf9ok3b/eWpl/3trZP99bGX/fmtk/39rYv+A + a2H/gWpg/4FqX/+CaV3/g2hc/4NoWv+EZ1n/hGdY/4VmVv+FZlX/hWRU/4ZkU/+FY1H/hWJR/41yZ/+p + qKr/qaiq/6moqv+pqKr/qaiq/6ioqf+op6j/p6ao/4BaS/+HaVz/pKOl/6Kho/+hoaP/n56g/56dn/+c + m53/m5qc/5KMi/9/aWD/el9V/3phVf95YVf/emNZ/3ljWv95ZFz/eWZf/3ppYv95amP/e2xn/31vav9+ + c27/gXZx/4J6df9bpXv/WZ1x/1eWa/9Ti2P/Tnxc/0x0Wf+dmZf/qKOi/7Cqqf+3sbD/vri4/8fDwv8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//HHH+CQAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAufP+gLn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//PH3l/3Rwcf9xbGz/b2tr/3Bqaf9xamn/cmtq/3Rraf9NeFj/U4Fc/1iOY/9d + mG3/XZ9y/16le/91dmn/fGxl/35sZf+AbGT/gWxj/4NsYv+Da2D/hGpf/4RqYf+GbWT/jXhv/5B+d/+T + g33/kX53/5F7cv+NcWX/iWhb/4diU/+HY1H/j3No/62srv+tra7/rayu/62srv+srK3/rKut/6uqrP+q + qqz/gVpK/4lpXP+mpqj/pqan/6Skpf+ioqT/oaCi/5+eoP+dnJ7/m5qc/5mYmv+WlZf/jIOC/3xkXf95 + YVb/emNZ/3hjWv95ZV3/eWdg/3loYv95amP/e21n/31va/+Ac2//YKmA/12keP9Zm2//WJVq/1KJYv9M + eVr/cXxx/5uXlf+jn5z/qaak/7KtrP+6tbT/wr69/0iK9f8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff3BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC5+/f4uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9udIP/cm1u/3Bra/9w + a2r/cmtq/3Jrav9zbGv/dWxq/1VxWf9Sflv/V4tg/1yXa/9fnnH/YKR4/2Cof/9+bGb/f2xl/4FsZP+E + b2j/joJ+/5qWl/+fn6H/oaGj/6Sjpf+mpaf/qKep/6moqv+rqqz/rKut/62srv+tra//r66w/4pjUf+R + dWr/sLCx/7Cwsv+wr7H/sK+x/7Cwsf+vr7D/rq6v/62trv+EW0v/h2FQ/6GZlv+pqKn/p6an/6Wlpv+j + o6T/oaGj/5+fof+enZ//nJud/5mYmv+Xlpj/lZSW/5GPkP+EeXb/eWNd/3hjXP95Zl7/eGZf/3loYv97 + bGX/fG5o/2maff9eq37/XaN3/1qbbv9Xkmf/UoZg/0x5Wv+HgYD/mpST/56amP+loqD/rqmo/7axsP+9 + uLj/rrjL/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//3RwcP9wa2z/b2pq/3Fsa/9ya2r/c21r/3Rsa/93bmz/cGxm/1N7WP9W + h17/XJRo/16bbv9hoXT/YqZ8/2Sngv+Kf3v/l5WW/5uanP+enZ//oJ+h/6KhpP+ko6X/pqan/6enqf+q + qav/q6ut/62trv+urq//sK+w/7Gxsf+xsbL/i2NQ/5N2av+zs7T/s7O0/7Oztf+zs7X/s7O0/7Kys/+y + sbL/sbCy/4VbSv+HXkr/hV1K/4RdTP+McGT/op2b/6amp/+kpKX/oqGj/6Cgof+dnZ//m5ud/5mYmv+W + lpj/lJSW/5GQkv+Qj5H/i4iK/39ybv94ZV//eWdh/3lpZP9yf2//X6yC/1+oev9coHP/W5ls/1aOY/9R + gV3/Vnhe/5GLiP+WkZD/m5eV/6GenP+ppqT/sayr/7m0s//Cvr3/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y17/msAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAACp6/zAuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//85fej/cW1u/3Bra/9v + a2r/cmxr/3NsbP91bm3/dW5s/3hvbP94bmr/UXhY/1eEXP9cj2T/X5hq/2GecP9ho3f/dMqq/4HCsv+a + mpz/nZyf/5+eof+hoaP/paSm/6Cbmv+TgHj/j3ds/5N8cv+ej4r/q6em/7Gxsv+ysrP/s7O0/7S0tf+M + Y0//lXZp/7a2t/+3trf/t7a3/7a2t/+2trf/tbW3/7W0tv+0s7X/h1xK/4lfSv+HXkr/h15K/4ZeS/+E + XUv/g11O/5B6cv+hnZ3/o6Kj/5+fof+enZ//m5qd/5mYmv+WlZf/k5OV/5GQk/+PjpD/jYyP/4uKjf+G + goP/eG1p/1+thf9fq37/X6V3/12gcf9al2r/VIhh/098Wv98eXX/j4iI/5SOjf+Zk5P/npqY/6WhoP+t + qan/tbGv/766uf9Bhvf/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln79/gAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK379ny59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//150m/9wbGz/b2tr/3Fra/90bWz/dG1t/3Zvbf94cG3/e3Fv/3xxbv9o + b2D/VHxY/1qIXf9elGX/YZtt/3G7lf93y6n/eNCz/5Cyqv+fnqD/oaGi/6Ojpf+lpKX/iWhc/4pqWv+M + aln/jGhX/4xoVv+NZlT/jWZX/5+Lg/+zsLH/trW3/41jT/+Xd2r/uLi5/7m4uv+5uLn/ubi5/7i4uf+5 + uLn/t7e4/7e2uP+JXEr/jGRQ/4lfT/+IXkr/h19L/4ZeSv+FX0z/hF5L/4JdTP+CYFL/k4R+/56dnv+d + nJ7/m5qc/5iXmf+VlJb/kpKU/5CPkv+OjpD/jIuN/4qJi/9yz7H/asCc/1+meP9fonP/XZxu/1qSZv9T + g13/T3hZ/4V9e/+NhoX/koyK/5aRkP+bmJX/oZ6c/6ilpP+xrKv/urW1/4+o1P8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//JXr+GwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAue/3zLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//cW1v/3BsbP9w + a2v/c25t/3Rtbf92cG7/eHBu/3pxb/98cnD/fXNv/3xvbP9UeVX/WINZ/16QYv9imWn/dcCa/3jKp/96 + zrH/etO8/5yopv+jo6T/paWm/6moqv+qqKr/mYeA/4xpXP+NaFj/jmhV/45nVP+OZ1L/j2ZS/45kUf+Q + aVn/kGRP/5h3a/+6urv/u7u8/7u6vP+7u7v/urq7/7q6u/+6ubr/ubi6/4tdS/+Tbl7/trW3/6+rq/+V + em7/h15M/4deS/+FX0z/hF9M/4NfTf+CX03/gV5P/4FkWP+Siof/mZia/5eXmf+UlJb/kpGU/4+Okf+N + jI//d824/3LMrf9xyKP/bL2U/16dbv9clWf/Volf/1F+Wv9xdmz/h399/4uDgv+PiYj/lI6N/5mUk/+e + m5n/paKg/6+qqf+3srH/wLu7/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8s + fv3eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5///8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y5+//9xbW3/cWxs/3Jtbf91bm//dW9u/3hxb/96cnD/e3Jw/350cf+A + dHD/gHRw/2RyXP9YgFj/Xo1g/2KWZP9ln2//ecij/3vNrf990rj/hNjD/6ampv+np6j/q6qs/62srv+w + sLH/srKz/6+rqv+YfnP/jmZU/5BnU/+QZ1H/kGZQ/5FmT/+QZU//mXlr/7y8vf+8vL3/vby9/7y8vf+8 + vL3/vLu9/7u7vP+6urv/jF5K/5RvX/+4uLn/tra3/7W0tv+ysrP/qaSi/49xZP+EXUz/hV9N/4RgTv+C + YE7/gWBQ/4BhUv99X1P/gWph/5WTlf+TkpX/kJCS/4LFt/900LX/c8qq/3LIoP9vwZb/X5ts/1ySZP9W + hV3/UHtZ/311cv+EfHr/iYGA/42Ghf+RjIv/l5GR/5uYlv+in53/qaal/7Ovrf+9ubj/Ln7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//MX32/3BsbP9x + bGz/cm1t/3Vubv94cXD/enJx/3tycf9+dXL/gHZy/4J3c/+DdnL/fW9q/1Z7V/9chln/YpFh/2SZZf9m + nW3/d8Kf/3/Rtf9/1sD/k93N/6qpq/+trK7/r66w/7Kys/+0s7X/tra2/7i3uP+5ubn/sqqo/5h1Z/+Q + Y1D/k2ZP/5JmT/+beWz/v76//76+v/+/vr//vr6//769v/+9vb7/vb29/7y8vf+NXkv/lnBg/7q6uv+5 + uLn/t7a4/7S0tv+zsrT/sbCx/66trv+hmJb/iWle/4FdT/+BX0//gWBR/39gUv99YVT/hHFp/5WUlf+Q + t7D/eNS+/3fPsv91yqf/c8af/3C/k/9gnGr/W49j/1WCXP9udmb/f3Vz/4J5eP+Hf37/i4WD/4+Kif+V + j4//mZWT/5+cmv+npKP/sKyq/7m1tP81gPv/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59/Y4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABV/wMuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//9Fd83/cGxt/3Jtbv9zbm7/dnBv/3lycf97c3L/fXVy/391cv+B + dnP/gndz/4R2cv+DdW//ZHFa/1qAV/9gjF3/ZJdk/2acaP9nnG7/Z551/3rFqf+J2sj/o+DS/66ur/+x + sLL/tLS1/7a2t/+4uLn/urm7/7y7vf+9vL3/vr6//769vv+voZz/k2ZQ/517bf/AwML/wMDC/8DAwf/A + v8D/wL/A/7+/wP++vr//vr6+/41eS/+XcGD/u7u8/7u6u/+5uLr/uLe4/7W1tv+ysrT/sLCx/62trv+r + q6z/p6ao/6Ogov+dmJj/m5eW/5uZmv+YmJr/l6yp/4TZx/940rr/d82v/3bJpf9ywZf/YZ9s/2CWZf9Y + h13/U35Z/3tvbP9+dHH/gXh2/4R8e/+JgoH/jYiG/5KNjP+Xk5P/nZqY/6Ogn/+sqaf/trKx/2GT5v8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln7//wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALH//KC59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//1lyn/9x + bW3/cm1u/3Rwb/94cXD/e3Nz/311dP9/dnT/gXd0/4J3dP+Dd3P/hXdy/4Z3cf+Ab2n/Wn1W/1+HWv9l + lGD/Zppl/2ebaf9nm27/Z5xy/2icev9+rpP/qtTJ/7Ozs/+1tbf/ubi5/7q6u/+9vL3/vr6//7+/wP/B + wMH/wsHC/8HBwv+VZ1H/nnxu/8PCw//CwcP/wcHC/8HAw//BwcL/wMDB/8DAwP+/v8D/j19L/5ZuXf+8 + u7z/vLu9/7u6vP+5ubr/uLe4/7W0tv+ysrT/sK+x/62trv+pqar/pqao/6OjpP+gn6H/nZ2e/5ylpf+T + 3tD/fdbC/3rRt/9zxKH/Zqh5/2Oha/9im2j/XY5h/1iCW/9vdWX/e3Bt/3xycP9/dnT/gnp5/4eAf/+M + hoT/kYuK/5WQkf+bmJb/oJ6c/6mmpf+zr67/jaTP/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Knr+NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuef5YLn3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//aG5//3Jtbv90b2//dnFw/3lzcv98dHP/fnZ0/4F4dv+C + eHb/gnh0/4R5dP+GeHP/h3dx/4d2b/9scVv/XYFW/2ONXP9nl2H/aJlm/2maa/9omm7/aJt1/2+de/+D + oIL/l5WA/5+If/+2srD/vby9/7+/wP/BwMH/wsLD/8PDxP/Ew8X/xMTG/5ZoUv+hfnD/xMTF/8TExf/E + w8T/w8PE/8LCwv/BwcP/wcHC/8DAwf+QYEz/kmRM/5FiTP+RZ1P/oouB/7Gppv+4uLn/t7e4/7S0tP+y + sbP/r66w/6yrrf+oqKn/paSm/6Kho/+fo6P/n97S/3/Ktf9orpD/Y6F6/2WhdP9loG7/ZJ5o/2GWY/9a + h13/Vn5Z/3hsaP95bmv/e3Fu/310cv+BeXj/hn99/4qEgv+OiYf/lI+P/5qVlf+em5r/pqOi/7Gsq/+t + sLz/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufP3zAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC18/YEuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9w + bW//c25v/3Vxb/94cnH/e3Vz/312df+Ad3b/gnl1/4N4dv+EeXb/hnl0/4d4c/+IeHP/iXhy/4JvaP9c + e1T/YIVW/2aRXP9qlmH/aZdm/2mYa/9qmXD/apt3/3qdfP+PoIT/nY94/5ZvW/+Wbl3/q5eO/8C/wP/F + xMX/xsXG/8bGx//Hx8j/mWtU/6OAcv/Gxsf/xcXG/8XFxv/FxMb/xMTF/8TDxP/CwsP/wcHC/5FhTv+T + ZU3/kmRM/5FkTP+QZEz/kGNM/49iTf+NYE//jWNQ/49rWf+Pb2L/jm9j/4trXf+FZVb/g2NW/5Cokv95 + por/Z6OD/2Whe/9loHX/Zp9v/2Wfa/9knWb/YJFg/1iEWv90cmX/d2tn/3luav97cG3/e3Nw/4B3df+C + fHr/iYKB/42Hh/+SjYz/mJOT/5yZmP+joJ//r6qo/7i0s/8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8Af/8EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALXz9oi59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//3Jub/9zbm//d3Jx/3lzc/97dXT/fnd2/4J5dv+C + eHb/hHp2/4V6dv+HenX/h3l1/4l6dP+KeXL/i3hw/3VvXf9egFT/ZYpZ/2iTXf9qlmH/a5Zk/2qWav9q + l3D/b5l3/4Gbff+WnoP/oIly/5hwW/+ZcFn/mm9Z/5x0YP+3qKD/ycnJ/8nKyv+bbVb/pYR0/8nJyf/J + yMn/x8fH/8bGx//Fxcb/xcXG/8TExP/Dw8T/k2NP/5RmTv+TZU3/kmVN/5JkTP+PYEz/j2VR/5FmVf+M + YU//jWRQ/4tkUP+KY1H/iGRS/4VkUv+aqZD/gqWJ/26hgv9moHv/Z550/2adb/9lnmr/ZZxm/2OUYv9c + h1v/W31Z/3hqZP93amb/eG1p/3pvbP97cnD/f3Z0/4J7ev+Gf3//i4WE/5CMi/+WkZH/m5iX/6Gfnf+p + p6b/trGx/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+/bAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff21Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//cm5v/3Vxcf94c3L/enR0/313dv+AeXj/gnl3/4N6eP+Eenf/hnp2/4d6dv+Je3b/int1/4t6c/+N + enH/h3Np/195Uv9iglX/aI1b/2qUXf9rlGD/a5Rk/2uVaf9qlXD/dZh3/4mbff+dnoL/oYVt/5tyW/+d + c1v/nnNb/6BzW/+fcFr/pH9t/59yWf+ohnf/zMzM/8vLy//Kysr/ycnJ/8jIyP/Gxsf/xcXG/8XFxv+U + ZFH/lWdP/5RmT/+WbFr/s6ml/769v/+8vL3/u7q8/7i4uv+tpaP/jGVU/4tlUf+JZFL/pKmQ/4ukiv90 + oID/Z556/2eddP9nnG//Z5xq/2icZv9ll2L/YItd/1uAV/96bWX/d2lk/3dqZv94bGn/eW5r/3txb/98 + dHL/gHl4/4V+fv+JhIP/j4uJ/5WQkP+alpb/n52b/6impf+zr67/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/cEu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9ybm//dXBx/3l0dP97dnX/f3h3/4F6ef+C + enj/hHt4/4Z7d/+He3j/iXx4/4p8d/+MfHX/jHx0/457c/+Qe3P/f2xg/2B7UP9mhlb/aZBa/2yTXf9s + k2H/bJJl/22Tav9tlHD/fZd2/5Gaff+knoL/o4Jr/590Xf+hdV3/onZe/6N2Xf+kdl3/o3Zd/6yKe//P + z8//z8/P/83Nzf/MzMz/ysrK/8nJyf/Ix8j/xsbH/5ZmUv+XaVH/lmhQ/6qWjf/BwML/v77A/769vv+8 + u7z/ubi6/7i3uf+0s7X/i2ZW/6emjv+To4r/fZ+B/2qcev9om3T/aJpu/2maav9om2b/Z5hi/2KQXf9d + hFn/ZHla/3doYv93aWT/d2pm/3draP94bmv/enBu/3x0cv9/d3b/g3x7/4eBgf+OiYn/lI+P/5mUlf+e + nJr/pqOj/7GtrP8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//K3z+WAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn79xi59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//3NvcP93cnL/eXR0/3x3dv+AeXn/gnt6/4N7eP+Fe3j/hnt3/4l9ef+JfXf/i313/4x8dv+O + fXX/kH11/5F8dP+QeW7/aHJT/2N/Uf9oiVf/a49Z/26SXf9ukWD/bJFl/22Sa/9ylHL/hJd4/5eZff+r + nYP/poNr/6R4X/+meWD/p3hg/6h5YP+oemH/sI1+/9TT0//T0tL/0dDQ/9DPz//Ozc7/zMzM/8rKyv/J + yMn/l2dT/5hrU/+XaVH/rJiO/8LCw//AwMH/v77A/7y8vf+6urr/uLe5/7W0tv/O5+H/nKKJ/4Sfgv9v + m3r/aZp0/2mYbv9pmWr/aZhm/2iXYf9lkl3/YYda/1t+Vf97aWL/eGhj/3dpZP92amb/d2to/3duav96 + cG3/fHNy/393dv+Ce3v/h4CB/4yHh/+Sjo3/mJSV/5yamP+loqL/sKyr/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8sfv38AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + fv/ALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//dHBx/3dyc/96dXX/fnh3/4F6ev+C + fHr/g3x5/4V8ef+HfHn/in56/4t/ef+Nfnj/jn53/5B+d/+Rfnb/kn51/5R+dP+Ib2P/YHdN/2aBUv9r + i1b/bY5Y/22PXP9tkGH/bpFm/26Ra/93k2//iZZ3/52Zff+tnIL/qoVt/6l8Y/+qfGP/q3xj/6t9ZP+1 + kYL/2NfX/9fV1v/V1NT/1NLT/9HR0f/Pz8//zc3N/8vLy/+ZalX/mmxU/5hrU/+tmZD/w8LD/8HBwv+/ + v8D/vb2+/7u6u/+4uLn/2/Lw/8nt6f+Oo43/eJt7/2qYdP9qmG7/apdp/2mXZP9pl2H/Z5Rf/2OLWv9d + f1T/c29e/3ppYP95aWP/eGlk/3dqZv93amj/d25q/3lwbf97cnH/fXZ1/4F6ev+GgID/i4aF/5CMjP+X + k5T/m5mX/6Kgn/+uqqn/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8fb/8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/bEuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//91cnL/eXR1/3x3dv9/eXn/gXp6/4N9e/+DfHn/hn16/4h+e/+Kfnr/jH96/45/ev+P + f3j/kIB5/5J/d/+VgHf/l4B3/5h/dP96a1n/YnlM/2mDUv9sjVf/bo9Z/26OXf9uj2H/b49l/2+Qa/98 + knH/kJZ4/6Oafv+wnIP/r4hw/61/Z/+ugGf/r4Bo/7mVhv/c29v/29na/9jX1//X1tb/1dTU/9PR0v/Q + 0ND/zs3O/5xsV/+cblX/m2xU/66akP/Dw8T/wsHC/7+/wP+9vb//vLu9/9/08v/R8Oz/uurj/4+/q/9s + mHT/a5du/2uVaf9rlmb/apZi/2iSXP9li1n/X4BU/154U/97aWH/emli/3hqY/94aWT/d2pm/3draP92 + bWn/eW9t/3pycP98dXT/f3h4/4R/fv+LhoX/j4uL/5aSk/+bmJj/oZ+e/6ypqP8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+/dAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAK3v9mS59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//3Vycv95dHX/fXh3/4B6ev+C + e3v/g317/4V9e/+GfXv/iH58/4qAe/+NgXv/joB7/4+Ae/+SgXn/lIF5/5WBef+Xgnj/moJ2/5R7bf9m + c03/ZXtO/2mEUf9tjFb/bo1Z/2+NXP9vjWD/bo9l/3GPa/+CknL/lpd6/6aaf/+0nIP/tY10/7KDa/+z + hGv/vZqL/+Hg4P/f3t7/3t3d/9vZ2v/Y19f/1tTV/9TS0//Q0ND/nm5Z/55wV/+cblX/sJyR/8XFxv/C + wsP/wMDB/76/wP/j9fX/2fLw/8Dr5v+q5dv/kdXE/2uVb/9rlWr/a5Vm/2uUYP9pk17/aI9b/2OFVv9d + e1H/fWpf/3xqYv97amP/eWpk/3lrZf93amb/d2to/3dtaf94bmv/enJv/3x0c/9/eHf/hH59/4mFhP+P + i4v/lZGR/5uXl/+hn57/q6in/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAufP5zLn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//dnNy/3p1dv9+eXj/gXt7/4J7e/+EfXz/hn58/4h/ff+Jf3z/jIF8/42BfP+P + gnv/kIJ6/5OCe/+Wg3v/l4R7/5qFef+bhXj/noZ5/4puYP9idUv/aH5P/2yHUv9vjFb/b4xZ/3CMXf9v + jWD/b45m/3aPa/+Hk3T/nJd8/6qagP+4nYT/upJ6/7aIb//BnY//5OTk/+Tj4//i4uL/4N7e/9zb2//a + 2Nn/19XW/9TS0/+gcVz/n3JZ/51wV/+wnpP/xsbG/8PDxP/DxMX/6vf2/97z8//K7+v/sejf/5zh1f+N + 18T/a5Jq/2uTZv9rkmH/a5Re/2mSW/9lhlb/YH1R/3BvWv9+amL/fWpi/3trZP96a2X/eWtm/3dqZv93 + a2j/d21q/3hubP94cW//e3Nz/353dv+DfXz/iIOE/4+Kiv+VkZL/mZaV/5+dnP+op6f/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//LHz+eQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC56/kcuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//90c3n/enV2/395ef+B + e3v/gnx7/4R+e/+Hf33/iH99/4qAff+Mgn3/j4J//5CCff+Sg33/lIN9/5aEff+ZhXz/m4Z7/56He/+h + iXz/o4l7/3prVf9kdkn/aYBP/26JU/9wi1X/cItZ/2+MXv9wjGH/cI1n/3mQbv+MlHX/oJh9/7Cbgv+8 + nYX/vpd+/8Wik//q6On/6Ojn/+fm5v/k4+P/4N/f/93c3P/a2Nn/19bW/6RzX/+idFv/n3JZ/7KflP/G + xsb/ysvN/+349//k9fX/0PHu/7nq5P+k5Nr/kt7O/4zVwf9qkWb/bJJh/2ySXv9rkVv/Z4lW/2KAVP9h + d1L/f2th/39rY/9+a2T/e2tl/3tsZf94a2b/d2xn/3dsaP93bmr/eG5s/3hwb/97c3P/fXd2/4J8fP+H + goP/jomK/5WRkf+alpb/n52c/5agsv8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8ufv//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALHn+Fy59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//2l1jf97d3f/f3p6/4J8fP+DfHz/hH58/4d+ff+JgH3/i4F//46DgP+Q + g4D/kYR//5SFf/+VhX//l4Z//5uIff+diX7/n4p9/6OLfv+njX//oIN0/2lwS/9nekz/bIJP/2+LVP9w + ilf/cIpZ/2+LXv9wjGL/cI1o/36Rb/+RlXf/p5qA/7Wcg/+9nYX/y7Cg/+vr6//r6uv/6+nq/+jn5//l + 4+P/4eDg/9zb2//Z2Nj/pnZh/6V3Xv+idVz/sqCV/9TV1f/r9/b/5fb2/9by8P++6+b/qeXd/5ff0v+Q + 28n/jNK5/2yQY/9skV7/a5Fb/2qNV/9lglP/YHpP/4FsYP+BbWP/f2tj/31rZP98bGX/e2xm/3lsZ/95 + bGn/d2xp/3Ztav93b2z/eHBv/3pzcv99d3b/gnx8/4eCg/+NiYn/lJCP/5mVlv+fnZz/dpXJ/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8t + fP4nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//V3ew/3x3eP+A + e3v/gnx8/4N9fP+Gf37/iIB//4mBf/+LgX//joOA/5CEgP+ThYD/lIaA/5eHgf+ZiID/m4qA/5+Lf/+i + jIH/po6B/6yRg/+vk4X/jnFi/2R1Sf9qfU3/bYVP/3CKVP9wilf/cIpZ/3CKXv9wjGT/dI5q/4KScP+V + lnn/qpuA/7Wcg//Is6T/8/f4/+/u7v/s7Oz/6+rr/+jn5//l5OT/4N/f/9va2v+peWX/p3lh/6J3Xv/H + t6z/6/f3/+L19f/Y8/H/w+3p/63n3v+b4dP/kdzM/5DYwf+LzrL/bJBf/2yRW/9qj1n/ZYRT/2F7T/96 + blv/g21j/4JtZP9/bGX/fWxm/31tZv97bGb/eWxn/3ltaP93bWn/d21r/3dubP94cG//enNy/3x3dv+B + e3v/h4KD/42Jif+Tj5D/mZWW/56cm/9Oief/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+/egAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//9BfNv/fHd4/4B7e/+CfH3/hH59/4Z/fv+IgH//ioF//4yDgP+P + hIH/kYaB/5OHgv+UhoL/l4iC/5qKgf+di4L/oI2C/6WPhP+okYX/rZOG/7GViP+2mYr/gWlW/2Z2Sf9q + fk7/bolR/3CJU/9wiVf/cIpc/3CLX/9wjWb/dY5r/4WSc/+Zl3v/qZqB/7+xov/r9/b/+/n5//Dv7//t + 7ez/6+rq/+jn5//i4uL/3dzc/6p7Z/+pfGP/wZV9/9vPxf/j9fX/3fPz/8ju6/+z6eH/nuLX/5Pezv+R + 2cP/j9W7/4jFo/9tkF3/a5BZ/2iIVP9jfVH/aHVT/4dwZf+EbmX/gm5l/39uZv9+bWf/fW1o/3ttZ/96 + bWn/eW5p/3dtaf93bmv/dm9s/3hwb/96c3L/fHZ2/4F7fP+GgYD/jYmJ/5OPj/+YlZb/npyb/y99/v8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//wAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC5+//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59/P97 + d3j/gHt8/4N9fv+Ff37/hn9//4iBgP+KgoD/jYWB/4+Fg/+Sh4P/lIiD/5aIg/+ZioP/m4yD/56NhP+i + j4X/ppKH/6yVif+xlor/tJmM/7qcj/+1mIj/cW5O/2h5S/9sgU3/b4hR/3CKVf9wilf/cItc/3CMYf9w + jWb/d5Bt/4mUdP+dmH3/s7Cf/+739v/7+fr/+/n6/+/u7v/s7Ov/6ujp/+bl5P/g39//rX5q/8ueh//Q + o4z/49HH/93z8v/J7+v/tuni/6Pk2f+V3tD/kdrG/5DWv/+P0rT/e66E/22QWf9rjFb/ZoBS/2F4Tv+M + c2f/h3Fm/4VwZ/+Db2f/gG9n/39uaP99bmn/e21p/3tuaf95bmr/eG5r/3hubP93cG7/eHFv/3pzcv98 + dnb/gXt8/4aCg/+NiYn/lJCQ/5mVlf+fnZz/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln79mwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn39zS59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//3t4ef+AfH3/gn5+/4V/fv+HgID/iYKB/4uDgf+N + hIH/j4WD/5KIg/+UiIX/lomF/5qMhP+cjYT/oI+G/6SRiP+olIr/rZaL/7Kajf+3nY//vKCS/8Kllv+f + gnL/Z3JJ/2l7S/9uhU//b4lS/3CKVv9xiln/cIpd/3CNYv9wjmn/epFv/4uVd/+orpz/+vn5//v5+v/7 + +fr/+/n6/+7u7v/q6ur/6Ofn/+Lh4f/Mn4z/0aWO/9Gljv/l0cj/zfDt/7nq4/+k5Nr/ld/R/5Hbyf+Q + 17//kNO2/43QsP9vlGT/a45W/2eDUf9ie07/h3Bk/4tzaf+Icmj/hXFo/4Nxaf+AcGj/fm9p/31vav98 + bmr/em5q/3huav94bmv/d29s/3dvbf95cnD/enNz/313d/+Be3z/h4OD/42Jif+Tj4//mZaW/5ucoP8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8ufv//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfP9gLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//d3h9/397fP+Df37/hH5+/4eAgP+JgoH/i4SB/46Fgv+Qh4P/koiE/5WJhv+Xi4b/m4yH/56Ph/+g + kYj/pZSK/6uWjP+vmY7/tJyQ/7ifkv+/pJb/xama/8qtnf+Mbl7/Z3dJ/2p+Tf9uiFD/cIpU/3CKVv9w + i1r/b4te/3CNZP9vjmn/fJJx/5eplP/6+vn/+vn6//v5+v/7+fr/9Pn4/+vu7v/o6Oj/8vj5/82ij//R + ppD/0qeR/+bTyv/Y8u7/p+Tb/5bg0f+R28r/kdjC/4/UuP+O0LH/i8un/2uOWP9ph1P/ZX5R/3lwW/+O + dmv/jHVr/4l0a/+Fcmr/g3Fq/4Fxav9/cGr/fW9q/3xva/96b2v/eW5r/3lvbP93b23/d3Bu/3lycP95 + c3P/fHd3/4B8e/+GgoP/jYmK/5SQkP+Zl5b/Z43M/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8qe/5CAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB//wQu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9Terv/gHx9/4J/fv+FgID/h4GB/4mCgf+M + hIL/jYWD/5CHhf+TiYb/louI/5iMh/+bj4j/npCJ/6KTiv+mlo3/rJiP/7Gbkf+1n5P/u6KW/8Gomv/I + rZ7/zLGi/9O2pv+BaVb/aHhL/2uDTv9uiVL/cIpU/2+KWP9wi1v/b41g/2+OZf9wkGz/s7Ke//r5+v/5 + +vn/+Pn5//P4+P/s9/f/5vb2/+P19f/o9vX/xKOR/8+pk//RqpX/7ODZ//j4+P+X4NH/kdvK/5DYw/+P + 1br/j9Gz/43Pq/9zn27/aotV/2aBUv9qdlL/knpt/411a/+Ldmz/inVt/4Z0a/+Ec2z/gnJr/39xa/9+ + cGv/fHBs/3twbf96cGz/eW9t/3dvbf93cG//eHJw/3p0dP98eHf/gXx8/4eDhP+NiYv/lJCR/5qYl/8x + fvv/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y58/fcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y99+/9/e3z/gn9//4WAgP+GgYH/iYOB/4uEg/+NhoP/j4eE/5OKh/+WjIn/mY2J/5uPif+f + kYr/opOL/6eXj/+tmpD/sp2T/7aglv+8pJn/w6ue/8mvov/OtKX/1Lmq/8uunv90blD/aXtM/2yET/9v + ilT/cItV/2+MWv9wjF3/b41i/22PZ//Zva//8/j4//D4+P/t+Pj/6fb3/+L29v/c8/L/2/Py/+D09P+/ + qJb/yKqU/8eplv/w9vX/9Pj4/5Lbyv+Q2ML/j9W7/43Rs/+N0K3/g7+W/2qKVf9mglL/ZXpQ/5R7b/+O + d2v/jXdt/4t3bv+Kd2//h3Vu/4Rzbf+Cc23/gHJs/31wbP98cG3/e3Bt/3pwbf94cG3/d29t/3dwb/94 + cnH/enR0/314eP+AfXv/h4SE/46KjP+UkJL/m5mY/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yp//wYA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn392y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//357e/+Df3//hICA/4aBgv+I + g4L/i4WC/42Ghf+Ph4b/k4qH/5eNiv+Zjor/m5CK/6CTjP+klY7/p5iQ/66ck/+zn5b/t6KY/72mm//D + rKD/yrGk/8+2qf/WvK7/3cGy/7CSgv9qdEz/aX9N/2yFT/9vi1X/cIxW/2+LWv9ujV7/cI9m/8+8rv/p + 9vX/6fb2/+P19f/f9PT/1/Lw/8/w7v/M8O3/2fPx/9jn4//Jtab/3efj/+f29P/s9vX/wuje/47Vu/+O + 0rP/jc+t/4bEm/9qjFb/aINT/2J8T/+Qd2r/kXht/453bf+OeG7/jHhu/4p4cP+Id3D/hXVv/4N0b/+A + c27/fXJt/31ybv98cW7/enBv/3lxbv94cG//eHFw/3hycf95dHT/fnl5/4F9ff+IhIb/j4uM/5WSlP93 + kLr/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//LX79ugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAre/5GLn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Wnu1/oJ/f/+FgID/h4KD/4iDgf+KhIP/jYaG/5CIhv+Tiof/lo2K/5qPi/+c + kYv/oJSO/6SXj/+ompL/rpyU/7Ogl/+3pJn/vaie/8Ktof/Ks6b/0Lir/9e+r//exLX/48e4/5Z5av9n + eEz/aX5N/22IUv9ujFX/b41Y/26NW/+goYP/xbyu/+L08//f9PP/3PTz/9Ty8P/I7+v/vevn/7nq5P/E + 7en/0fHv/9vz8v/h9PT/3/Tz/+Dz8v/k9PL/jdGz/4vOrf98soX/aoxW/2iGVP9jfVD/h3Nj/5J6bv+Q + eW7/j3lu/456cP+Ne3H/i3ly/4h3cf+Fd3D/g3Vw/4Bzb/9+c2//fXJv/3txbv95cW7/eXFv/3hxb/94 + cXD/eHJy/3p1df9+eXn/gn5//4mFhv+QjI3/lpSV/zJ/+v8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufv7/gn5//4WBgf+H + goP/iIOD/4uFg/+Nh4b/j4mG/5OLiP+WjYv/mo+M/5ySjP+glI7/pJeR/6eakv+unZb/tKKZ/7iknP++ + qp//xK6k/8qzp//PuKz/1r6x/93Et//jyLr/48e4/4puXv9leUz/aIBP/22IUv9tjlf/b45a/7qvmv++ + va//1/Lx/9Px7//Q8O7/wu3p/7bp4/+q5d3/puTc/7Do4P++7Of/ye7r/9Px7//Y8vD/1/Lv/9vx7/+H + w5//bJNh/2qOV/9nh1P/ZH1R/3xzXP+agnX/j3pw/5B6cf+Pe3H/jXty/4x6c/+KenP/iHhy/4V2cf+D + dnL/gXRw/35zb/98cnD/e3Fv/3lxb/94cG//eHFw/3hycf95c3T/enV2/355ef+Df4D/ioaH/5CNjf+X + lpb/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8qe/5fAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACx8/ekuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//93fYz/hYGB/4aBgv+IhIT/ioWD/4yGhv+PiYf/k4uI/5WMi/+a + kIz/nJON/5+Uj/+jl5H/qJuU/66el/+yopr/t6Wc/7ypoP/CrqT/ybSo/8+5rv/Wv7P/28S3/+LJu//k + yrz/4MW2/4NsW/9mek3/aYNR/2uKU/9wkFv/tLGc/7a9r//I7+r/w+3p/7nq5f+u5t//o+PZ/5jg1P+U + 39H/n+LY/6rm3v+z6eP/vevn/8vt6f/B187/s7Sl/5iniP9qkVr/aIhV/2SAUv9udVf/pIx//5N8cf+R + fHL/kHty/498c/+OfHP/jXx0/4p7df+JenX/hXhz/4N2cv+AdXH/fnRw/3xzcP97cnH/eXFw/3lycf94 + cXD/d3Fx/3l0dP97dnf/f3t8/4SBgv+MiYj/k5CR/1OG2v8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y58/f0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAK33+Oy59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//zR99f6E + gIH/hoKD/4iDhP+KhoT/jIaF/4+IiP+Si4n/lY2L/5mQjf+ck47/n5WQ/6OYkv+nm5X/rp6Y/7Kimv+2 + pZ3/u6mh/8Kvpf/Is6n/zbis/9O9sf/Zw7f/4Mm8/+XMv//ly73/1rut/3ttVv9lfE7/aYRS/5enhv+q + sJv/qLus/7np5P+v5+D/pOTZ/5ng1P+Q3s//idrK/4rayP+O3c7/ld7R/5bOwP+Nr5z/lKuX/52wmv+l + s5//p7Wh/2iKVv9lglP/Z3hS/6mRhP+VfnP/kn1y/5F9c/+RfXT/j311/418df+NfXb/i313/4l7dv+F + eXT/g3d0/4B2cv9+dHH/fHNx/3tzcf96cnH/eXJw/3hycf94c3L/enV2/3t3d/+AfH3/hoKE/42Ki/+V + kpP/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yh4/hMAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//3x/iv+GgoP/h4OE/4qFhf+Mh4b/j4iI/5GKif+U + jIv/mI+N/5uTj/+flpD/opiS/6ablf+sn5j/sKGa/7amnv+6qaD/v62l/8ayqf/Mt63/0Lyx/9bBtf/b + xbn/4cq9/+XNwP/lzL//wqmb/3JwVP9kfk//oLKd/5mumP+Wuqf/pOTZ/5zg1v+Q3s//itvL/4bZxv+C + 0br/drib/2mggf9pn3//cKOF/3mmi/+CqpL/iq2V/5Owmv+atJ7/ZoRX/2J7Uf+nj4P/ln91/5R+df+T + f3X/kX52/5B+dv+Pfnf/jn53/41+eP+Lfnj/iXx4/4Z6dv+Cd3X/gHZz/351cv98dXL/fHRz/3pzcv95 + cnH/eHNy/3l0dP96dXb/fHh5/4F9f/+HhIX/j4yN/2OIx/8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//LH390wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfP2cLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//MX75/4aCg/+Hg4T/iYSF/4yHhv+OiIf/kYuI/5SNi/+Wjoz/m5KP/56Wkf+hl5L/ppuW/6qemP+v + oZv/taWe/7ioof+8rKT/wrGo/8i1rP/OurD/0r2z/9fDuP/dyLz/4szA/+TNwP/mzcH/r5aJ/294V/+O + r5f/hqyT/4O2oP+Q3dD/htfF/3nHsP9rqYn/Z5t3/2iacP9om3D/aJ11/2agfP9mooH/a6SH/3CojP94 + q5D/ga6V/4iymv9/pIX/oouA/5iCd/+XgXj/lYB3/5SAd/+Rfnf/kH94/49/ef+Of3n/jX95/4t/ev+J + fXj/hnt3/4N4dv+AdnT/fnZ0/3x0c/97c3P/enNy/3lzc/95c3P/eXR1/3t2d/99enr/g3+A/4qHh/+R + j5D/Ln7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//cICg/4eDhP+JhYX/i4aG/46Iif+P + ion/k4yL/5aPjf+ZkY7/nJWQ/6CXk/+kmpX/qJ6Y/6+hm/+zpJ7/tqeg/7uro/++r6b/xrOs/8q3rv/P + u7H/1L+1/9fDuP/bxrr/38q+/+LLv/+nkYT/hLGZ/3utk/9zqo3/bKiK/2ajhf9lo3//ZaF8/2eed/9o + nHL/aJtu/2iabv9nnXH/Z594/2WifP9kpIL/ZaaH/2mpi/9urI//dK+U/3yymf+Qlob/mIR6/5aCev+U + gXn/koF5/5CAef+QgHj/joB6/46Aev+NgHv/i397/4l9ev+Ge3j/g3l3/4B3df9+dnT/fHV0/3t1dP95 + c3P/eXN0/3l0dP96dXb/e3Z4/357fP+FgoL/jYqK/1uGzv8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8tfP2LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/csuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8ufv//hoKE/4iEhf+Lhob/jYiH/4+Kif+SjIr/lI2N/5iQjv+bk5D/n5eS/6Oalf+n + nZj/q6Cb/7CjnP+0pZ//uami/7yspf/Bsan/xrWs/8u4r//Pu7L/0r+1/9bBt//Zxbr/ppSI/3exlv9x + rpH/a6uM/2Wnh/9jpYP/ZKSA/2WifP9moHf/Zp50/2ecb/9nm2z/aJtq/2edb/9mnnT/ZaJ4/2Sjff9i + poL/Y6mI/2Kqi/9lrI7/aq+S/26ylf+MmYn/loR6/5SCev+Tgnv/kYJ7/5CCe/+PgHv/joF9/4yBe/+K + gHz/iH57/4V8ef+DeXj/gHd2/353df98dnX/enR0/3lzdP94c3P/eXR1/3p1dv97eXn/gH5+/4iFhf+P + jY3/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAFX/Ay59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9Cf+P/h4OF/4mFhf+L + hob/jomJ/5CKiv+UjYv/lpCN/5qSkP+dlZH/oZmV/6Wbl/+on5r/rqKd/7Kln/+2qKH/uquk/76vqP/D + sqr/xrWt/8q5sP/Ou7H/0L20/6SVi/9rsZT/aK+S/2Osjf9iqof/YqeD/2Olf/9kpHv/ZKF4/2Wgcv9m + n3H/Zp1s/2ecaP9nnGj/Zp1r/2afcP9loXX/ZKN4/2SlfP9jqIP/YKmH/2Crif9frYz/YbCQ/2Sylf+D + nYz/lIR9/5ODff+Rgn3/kIJ8/4+Cfv+Pgn//jYJ+/4uBfP+Hfnz/hXx5/4J6eP9/eHb/fXd2/3t2df96 + dHT/enV1/3l0df95dHX/enV3/357e/+DgID/i4iJ/zyB7v8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx9/m4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn39xS59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//9zgaD/iYWF/4uHh/+NiIn/j4qK/5KMi/+UjY3/mJCP/5uVkf+f + mJT/o5qW/6admP+soJv/r6Oe/7Omof+2qKL/uqul/76uqP/Bsqr/xrSs/8i3rv+dl4z/YbKU/1+vj/9h + r43/YKuI/2Gog/9jp3//Y6R7/2Sjd/9lonT/ZqBw/2Wfbf9nnWr/Zp1m/2ecZv9mnmn/ZZ9t/2Wicv9k + o3T/ZKR5/2Omff9iqYL/YauE/2Cth/9fr4z/XrGR/16zlv96oI7/koV+/5CDfv+Qg3//joN+/46Dfv+L + gX3/ioB9/4d+fP+EfHr/gnp5/394dv9+eHf/fHd2/3t1dv96dXb/eXR1/3p1d/97eXn/f3x9/4aDhf97 + iKP/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln7//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//+G + hIj/ioeG/4yIiP+OiYn/kYuL/5ONjP+Wj4//mZKR/5yWkv+gmZX/pZyY/6efmv+top3/sKSe/7Snof+3 + qqP/uqum/7ytpv+/sKn/k5iL/16ykP9dsI3/Xq+L/2CtiP9hqoH/Yqh+/2Kmev9jpnf/ZKR0/2OjcP9k + oG3/ZZ9q/2aeaP9lnGX/ZJtj/2aeZ/9loGr/ZKJv/2Ojcv9kpXX/YqZ4/2Gnfv9gqYD/X6yD/2Cuhv9e + sIv/XLOP/1y0lP9ypo//kYV//5CEgf+PhIH/joSB/4yCf/+JgX7/h399/4N8ev+Benn/f3h3/314d/97 + dXb/e3Z3/3p1dv96dXb/eXZ3/316e/+Cf4D/iYeI/y5+//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//K3z+XgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfP2LLn3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y9+/f+JhYb/i4iG/46Jiv+Pi4v/koyM/5WOjv+X + kZD/m5SR/52Xk/+hmpb/pp6Z/6mgnP+vop7/sKWf/7Onof+2qaP/uayk/4acif9esoz/XrGM/1+vif9f + rob/YKuC/2Gpf/9hqHv/YqZ2/2Oldv9jo3L/ZKJu/2Sha/9joGf/ZJ5m/2KXYf9ilWH/Y5xl/2SgaP9k + omz/ZKNv/2Klcv9hpnX/Yqh5/2CqfP9fq4D/X6yC/16thf9dsIn/XrON/1y1kP9rq43/kIaC/4+Egv+O + hIH/jYSB/4mBf/+Gfn3/g317/4B5ef9+eHf/fHd3/3t3d/97dnf/enV2/3l1d/96d3j/f3x9/4aDhf83 + f/L/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8ufv//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAufv3+Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//zh/8P+Kh4f/jImH/46Jiv+QjIz/k42N/5aQj/+ZkpH/m5aS/56Ylf+jm5f/pp6a/6mgnP+v + o5//sKSf/7Onof92o4f/XbCH/16wiP9dr4b/Xq2E/1+sgf9gq37/YKl6/2Gndv9hpXT/YqRy/2Okb/9j + o23/YqJq/2GbZf9hl2P/X49g/1+NX/9gk2H/YJtl/2Ohav9io2z/Y6Vv/2Gmcv9hqHb/YKl4/2Cqe/9g + rH3/X62A/16ug/9dsIf/XLKL/1yzif9hsIn/kYeD/46Fgv+Mg4H/iIF+/4Z/fv+CfHv/gXt7/354eP98 + d3f/e3Z3/3p1dv95dXf/end4/3x6e/+EgYL/WIHH/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8sff45AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACp//x4u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//0V/3/+MiIf/jYmJ/4+Ki/+R + jYz/lI6O/5aRkP+ZkpD/m5aS/56Ylf+hmpf/p56b/6ihnP+toZ3/ZqyE/1ywhP9dsYT/XrCE/1+ugf9f + rX//X6t8/2Cqef9gqXb/Yadz/2KmcP9ipW//YqVs/2Kiav9hnGb/XpNi/16OYf9ZiF3/Wodc/12MYP9e + kmH/YJlk/2Cfaf9gpG3/YqZv/2Kncv9hqXT/YKt3/1+sev9erXz/Xa9//16vgf9dsoT/W7KH/12zhf9d + s4b/kImG/4qDgv+HgID/hH58/4F8e/+Aenr/fXl5/3x4eP97dnf/enV3/3p3eP97eXr/gH1//3KCof8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//yx9/fYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACx9/bcuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//1CB0v+MiIj/joqL/4+Ki/+SjYz/lY+P/5WRkP+ak5L/nJeT/5+Zlf+i + m5f/oJmW/12tgP9csYD/XLCB/16wgf9drn//Xq5+/1+te/9fq3j/YKp2/2Cpc/9hqHH/YKZu/2CkbP9f + oGj/X5pn/12TY/9ail//WYhd/3eAbf9+dm3/WoZd/1mKYP9bkGL/XZZl/1+eZ/9fpG3/YKZu/2Cocv9g + qnT/YKt2/1+seP9erXr/Xa99/1uxgP9csYL/W7KC/1uzgv9asIH/iY+G/4eAgP+Efn3/gXt8/396ev99 + eXn/e3Z3/3p2eP95dnf/e3l6/357fP96gJD/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx9/fwuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wB//wIA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59/f4uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//1SBzv+N + iYr/j4uM/5GNjP+Tjo3/lY+Q/5aRkP+Zk5L/nJaT/4WYh/9aqXr/XKx8/12vff9esH7/Xa9+/16ve/9e + rnn/YKx2/1+qdP9fqXH/X6dw/1+kbf9foWv/Xpxp/1yWZv9akGT/WItg/12EX/+ekoz/vbGr/6WZk/+M + gHv/Z3xk/1eJXv9YjGH/W5Nl/16baf9dn2r/XqVu/16ocP9eqXT/Xqp0/16sdv9ernn/XbB8/1ywfv9c + sX7/XbGA/1quff9Zq3z/dJmA/4F8ff+BfHz/fnl6/3x4eP96d3j/end4/3p4ef99env/eX6M/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//LXz9jQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALnP+Cy59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//02B1v+NiYr/joqL/5CMjP+Tjo7/lY+Q/5aSj/9g + nHX/WKN2/1qmeP9aqXj/XK15/12ve/9drnn/Xqx3/16rdf9eqHL/XaZw/12ibf9bnmr/W5lp/1uXZ/9c + k2f/WI5i/1eJX/+FhXn/wLWv/6Wblf+kmpX/o5iS/6GWkP+bkYv/g3l0/1uFX/9XjGL/WpJm/1qVZ/9b + m2v/Wp5r/1yibv9dp3H/XKhy/12rdv9drnf/XK95/12wev9crnr/W6t6/1qnd/9XpXf/WZ51/4KBf/99 + eXr/e3h5/3p3eP96d3n/fHl6/3V+kf8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8t + ff3+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALXz+VC59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//z+A6f+NiYv/joqL/5GLjP9xjXj/VJVq/1acb/9ZoHP/WaFz/1qndf9bqXb/XK13/12qdf9d + qHP/W6Vw/1ugbv9anGv/WZlp/1mVaP9YkWX/VY1k/1aMYf92gnL/rqWg/6edmf+lm5f/o5qV/6KYk/+g + l5L/n5aQ/52Uj/+clI//komF/3l3cP9WjGL/VY1j/1WQZf9Wk2f/WZdp/1mcbP9aoG7/WqNw/1uoc/9b + q3b/Wq12/1qsdv9ZqXb/WaN1/1ehcf9VnXD/U5Zs/2SKcf98eXr/end5/3t5ev9ifKr/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALX79ri59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//zJ/+f9mfm7/Snxd/06GYv9R + jmb/VJZr/1aabv9Xnm//WqJw/1mlcv9ZpXH/W6Nw/1qfbf9Zm2v/WJZq/1aSaP9VkGX/VY1j/1OKYf9v + g27/opqW/6ignP+lnJj/o5uW/6GZlf+hmZX/oJiT/5+Xk/+dlZH/nJSQ/5uUj/+bko7/mZCO/4yEgv9x + em3/U4li/1OMYf9Tj2T/VZJn/1aVaf9YmWv/V51t/1qicf9ZpXH/WaVz/1ikcv9Xn3D/VZlu/1OWbP9S + kmn/Tohk/0p+Xv9cemj/Rn3V/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y5z/gsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALnz94y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y5+//9FenL/TYBg/1CKY/9Sjmb/UZFn/1SWa/9WmW7/V5pt/1eabP9W + l2v/VJNo/1OPZv9UjWP/UIxi/1GJYv9xhHP/nZeT/6Wem/+im5f/opuX/6Galf+gmZX/n5iU/56Xk/+d + lpL/nJWR/5uUkP+bk5D/mpKQ/5mRjv+XkI7/lo+O/5WOjf+Jg4H/cnpv/1KIY/9Ri2L/Uo1j/1KPZv9T + k2n/VZhs/1aabf9Wm23/Vptt/1aXbf9Rk2n/UY5n/06LZ/9MhGH/SXtf/y9+9/8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3+NwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALH799C59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//84 + fcr/TINh/06HY/9Qi2T/UI9m/1GSZ/9Skmj/UZFn/1KOZf9Ri2T/UIlj/1WFZP+Ahnz/nZeV/56Zlv+d + l5T/npiV/5+Zlf+fmZX/nZeU/52XlP+clpT/m5WS/5uVkv+bk5L/mpOR/5mSkP+ZkZD/lpCP/5aPj/+V + jo3/lI2L/5ONjP+SjIv/i4WE/3l4dP9Yg2b/UIhk/1GKY/9PjGX/UZBn/1KSaP9Rkmj/UJBn/0+LZv9N + iGP/TIVi/0B/mP8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8re/5XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH79+i59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufv//R397/06FYv9PiWb/T4tk/1CLZf9P + iWT/VIVl/3OEd/+SjIv/mpWV/5qUk/+blZP/m5aU/5uVlP+blpP/m5WT/5uVk/+blZP/m5WR/5uUkf+b + lJH/mZKR/5mSkP+XkZD/lpCP/5aQjv+Vjo7/lI6O/5SOjf+SjIz/koyM/5GMi/+QjIv/j4qL/4yHiP+B + fXz/cnpy/1aDZv9PimT/T4pm/1CKZ/9Oimb/TYZi/0qCZv8vfvX/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yt7/l0AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALH79+i59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//MX7x/2qAef96gnz/h4SE/4+Li/+Tj4//lZCR/5aRkv+WkpL/lpKS/5eTk/+Y + k5P/mZOT/5mTkv+Zk5P/mZOS/5mTkv+Zk5L/mZOS/5eSkf+XkpH/lpCQ/5aQkP+Vj4//lI+O/5SOjf+T + jo7/ko6N/5KNjf+QjIz/kIyM/4+Li/+OiYr/jImH/4qGhv+Hg4X/hICA/3x5ev94dXf/cXly/2N8a/83 + ftT/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Lnz9/i59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//LHr+SwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH399S59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//zuA7/+K + i5P/kY2N/5KOjf+Tj4//k4+P/5SPj/+VkJH/lZCR/5WRkf+WkZL/lpKS/5aSkv+XkpP/lpGS/5aSkv+W + kpL/lZCR/5aRkv+VkJH/lI+Q/5SPj/+Uj4//k46O/5GNjf+SjYz/kIuM/5CMjP+Pi4v/joqL/4yIiP+K + hof/iISG/4SBgf+Bf3//gH1//317fP9GfNb/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8pe/4fAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn394S59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8wfvz/coev/5CNjv+Sjo7/ko6O/5OPj/+T + j4//lJCQ/5SQkf+VkZH/lZCR/5WQkP+VkJD/lZCQ/5SPj/+Uj4//lI+P/5OOjv+Tjo7/ko2N/5KOjP+R + jY3/kYyN/4+MjP+PjIz/j4uM/42Ji/+Lh4j/iIWG/4aDhP+EgYH/gX+A/3N8kv83fu//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXz9qC59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//zuA8P91ia3/kY2O/5KOjv+Sjo7/ko6O/5OPj/+Tj4//k4+P/5OPj/+T + j4//ko6O/5OPj/+Sjo7/kY6N/5GOjf+RjY3/kI2N/5GOjf+QjY3/j4uM/42Ji/+LiIj/iYaF/4eEhf+E + gYL/d4CT/0V+2/8ufv//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufv//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH/+Si59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln7//0WC5P9th7X/jIyU/5KOjv+Sjo7/kY6O/5KOjv+RjY7/ko6N/5KOjv+QjY3/kIyM/5CNjf+P + jI3/jouL/42Ki/+MiIn/iIaI/3OCoP9Of9H/L338/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//yx+/cgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAJG3+Byx+/fouff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + fv//L338/zd/9P8+gez/RILm/0WC5f9Cgef/O4Du/zR+9v8uff//Ln7//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//LnP+FgAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC19/Zgu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y58/fcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5z/gssfP31Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//JHn+FQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAsfP5KLn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y9+/Z0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH7+bS5+//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8sfP3fAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACx7/lsufv3+Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//LX793AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAoev4ZLn390S59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59/ZAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC57/zwt + fv3aLn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y58/fcvb/8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALXj/ES59/YQufP3tLn7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx+/fQrfP4vAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACh4/iYsff5sLn39tSx9/eoufv//Ln///y5+//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufv//LX395S19/moA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzZv8FHHH+CSh4/hMt + f/4cKnj+JCt8/iktfP4tLXz+LSp6/zAqev8wKnr/MCx5/i4tfP4tKnn+Ki5//iYre/4jKXv+Hy96/hss + ef4XJnL/FC9//xAndf4NGWb/Chxx/gkccf4JH3//CB9//wgff/8IHHH+CS14/xElev4bLXz+Jyx6/jQu + e/5CLHz/UC1+/l8tfP5xLHv9hCx9/ZYtff2jL4D9qy99/bMtff25Ln/9ui9//bYuff2vLnz9pCx9/ZAs + fP5zLHr+USt8/ikzZv8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /////////////////AAA/////////////////8AAAAf///////////////wAAAAA///////////////w + AAAAAB//////////////gAAAAAAH/////////////gAAAAAAAf////////////wAAAAAAAB///////// + ///wAAAAAAAAH///////////wAAAAAAAAA///////////4AAAAAAAAAD//////////8AAAAAAAAAAf// + ///////8AAAAAAAAAAD/////////+AAAAAAAAAAAf/////////AAAAAAAAAAAD/////////gAAAAAAAA + AAAf////////wAAAAAAAAAAAD////////4AAAAAAAAAAAAf///////8AAAAAAAAAAAAD///////+AAAA + AAAAAAAAAf///////AAAAAAAAAAAAAD///////wAAAAAAAAAAAAA///////4AAAAAAAAAAAAAH////// + 8AAAAAAAAAAAAAA//////+AAAAAAAAAAAAAAP//////gAAAAAAAAAAAAAB//////wAAAAAAAAAAAAAAP + /////8AAAAAAAAAAAAAAD/////+AAAAAAAAAAAAAAAf/////gAAAAAAAAAAAAAAH/////wAAAAAAAAAA + AAAAA/////8AAAAAAAAAAAAAAAP////+AAAAAAAAAAAAAAAB/////gAAAAAAAAAAAAAAAf////wAAAAA + AAAAAAAAAAH////8AAAAAAAAAAAAAAAA/////AAAAAAAAAAAAAAAAP////gAAAAAAAAAAAAAAAB////4 + AAAAAAAAAAAAAAAAf///+AAAAAAAAAAAAAAAAH////gAAAAAAAAAAAAAAAA////wAAAAAAAAAAAAAAAA + P///8AAAAAAAAAAAAAAAAB////AAAAAAAAAAAAAAAAAf///wAAAAAAAAAAAAAAAAD///8AAAAAAAAAAA + AAAAAA////AAAAAAAAAAAAAAAAAP///wAAAAAAAAAAAAAAAAB///4AAAAAAAAAAAAAAAAAf//+AAAAAA + AAAAAAAAAAAD///gAAAAAAAAAAAAAAAAA///4AAAAAAAAAAAAAAAAAP//+AAAAAAAAAAAAAAAAAB///g + AAAAAAAAAAAAAAAAAf//4AAAAAAAAAAAAAAAAAD//+AAAAAAAAAAAAAAAAAA///wAAAAAAAAAAAAAAAA + AP//8AAAAAAAAAAAAAAAAAB///AAAAAAAAAAAAAAAAAAf//wAAAAAAAAAAAAAAAAAD//8AAAAAAAAAAA + AAAAAAA///AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAB//+AAAAAAAAAAAAAAAAAAf//gAAAAA + AAAAAAAAAAAAD//4AAAAAAAAAAAAAAAAAA//+AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAB//8 + AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAD//4AAAAAAAAAAAAAAAAAA//+AAAAAAAAAAAAAAAA + AAH//gAAAAAAAAAAAAAAAAAB//8AAAAAAAAAAAAAAAAAAP//AAAAAAAAAAAAAAAAAAD//4AAAAAAAAAA + AAAAAAAA//+AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAB//8AAAAAAAAAAAAAAAAAAP//gAAAA + AAAAAAAAAAAAAD//8AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAH//4AAAAAAAAAAAAAAAAAA// + /AAAAAAAAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAD//+AAAAAAAAAAAAAAAAAA///wAAAAAAAAAAAAAA + AAAP//+AAAAAAAAAAAAAAAAAD///wAAAAAAAAAAAAAAAAA///+AAAAAAAAAAAAAAAAAP///wAAAAAAAA + AAAAAAAAD///+AAAAAAAAAAAAAAAAA////wAAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////4AA + AAAAAAAAAAAAAB/////AAAAAAAAAAAAAAAAf////8AAAAAAAAAAAAAAAP/////wAAAAAAAAAAAAAAD// + ////AAAAAAAAAAAAAAB//////8AAAAAAAAAAAAAA///////wAAAAAAAAAAAAAf///////gAAAAAAAAAA + AAf////////AAAAAAAAAAAAf/////////wAAAAAAAAAA//////////////////wAf/////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + ////KAAAAIAAAAAAAQAAAQAIAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8pe///a2Nj/3tra/+M + jIT/jIR7/5SMlP+cnJz/Y5Rj/3tjWv97e3v/Y4Rj/7W1tf/m7+//Y61a/2OESv+traX/3tbm/97Fxf9z + lHv/a+Za/xlrlP8ZKZT/GVLv/xkZ7/9K5lr/GUqU/xkIlP+l5oT/pYxa/4R7a//OtZT/GeYp/1q1Kf8Z + tSn/EHsp/969Kf+cvSn/Sq1a/1rmCP8Z5gj/WrUI/xm1CP8Qewj/3r0I/5y9CP9Ca1L/SmuU/3NjSv+c + reb/c5yc/+bmxf+ca1r/znNa/5xzEP8Za8X/7+aU/0pS7/8p5lr/SimU/ylCKf9KGe//EIxa/xkpxf8p + tVr/KRAp/++9Wv+tvVr/SkqU/6WM5v8ZSsX/zuaU/wjmWv9KCJT/CEIp/xBrWv8ZCMX/CLVa/wgQKf/O + vVr/jL1a/0qMY/9jreb/hGtr/7WUhP9Ka8X/MZTv/zGczv9jxaX/71rv/2Pv7/9j76X/3q3v/+9arf+c + OpT/7xmt/0J7Kf/vGe//3u8p/5zvKf/FWq3/nBCU/8UZrf/FWu//xRnv/5xazv8x3s7/nBnO/+9zGf8Q + nKX/EN6l/xCc7//ejMX/pc7v/3ta7/8Q3u//exnv/86UGf/vWs7/Y87v/2PvhP/ejO//QnsI/+8Zzv/e + 7wj/nO8I/8Vazv/FGc7/EJyE/xDehP9jjMX/nLWM/3NjnP+c3qX/Upyc/5xjpf+tnJz/KUJa/5yUvf+E + QmP/SinF/4RCKf/mQin/hBAp/+YQKf8pEFr/UkIp/7VCKf9SECn/tRAp/0pKxf8IQlr/SgjF/4RCCP/m + Qgj/hBAI/+YQCP8IEFr/UkII/7VCCP9SEAj/tRAI/+ZCSv+EEEr/5hBK/1JCSv+1Qkr/UhBK/7UQSv/e + lJz/hEpK/1qte//v71r/re9a/2uMGf/vvZT/73Na/5yUEP/OlFr/nHMx/87vWv+M71r/a2sZ/2POxf9j + xYT/lGt7/5Tmxf+9xcX/Y63F/zGchP8xnKX/nFrv/zHe7/8x3qX/nBnv/++UGf9j78X/Md6E/5SUhP+E + Y1L/75Ra/5yUMf+17+b/5kJr/4QQa//mEGv/UkJr/7VCa/9SEGv/tRBr/96UhP9SjOb/WpR7/8W1vf+1 + 78X/763F/xCtzv/va4z/ezql/+8pjP/Fa4z/exCl/8UpjP97a87/EO/O/3spzv/Ocyn/EIzO/+9KjP97 + OoT/7wiM/8VKjP97EIT/xQiM/3tKzv8Qzs7/ewjO/85zCP+Uzr3/OnPv/2vmKf8ZGQD/SuYp/0KMSv9z + jOb/lO/m/xlKAP+MjFL/nK29/3Nje/8Qc+//IQAA/ylz7/8pc///AAAI/wAAAP8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/gAAAAD+ + AAAA8f4A/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+ + AP4A/u8BAQHvAQEBAe8B7/7xAADx/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD+AP7+7wHvAVYBVu8BAVYB7wEBAVYBAQEBAe8BAPv+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA/gFWAe9WAQFW7wEBAQFW7wEBVgHvAQHvAe8BAVYBAQFW/v4AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAP4AAe8B7wEBAQHvAQEB7wHvAQEBAe8BVu8BAVYBVgEB7wEBAe8BVgEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAD+Ae8BAVYBAQHvVgEBVu8BVgFWAe9WAQEBAQFW7wEB7wHvAVbvAQEB + 7wEBAQAA/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7+71YBVu8BAe9WAQHvAQEBAe8B7wEBAe8B7wHvAQEBAQEB + VgEBAVbvVgHvVu8BAVYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADxAe9WAQEBAQEB7wEB71YBAe8BAQEBAVbvAVYB + VgFW7wHvAVbvAe8BAQEBAQEBAQFW7wEB/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAe8B7wHvVgFWAQEBAe8BAVbv + Vu8BAQEBAe8BAQEBVu8BAQEBVgHvAQHvVgEB7wEB71YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/gEB7wEBVgEBVgEBAe8B + 7wEBVgFW7wEBAQEBAQEBAQEB7wEBAQFW7wHvAQFWAe8BAe9WAQEBAQHvAfsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7/lbvAQFW7wHv + AQEB7wEBAQFW7wHvAQEBAQEBAQFWAe8BAQEB7wEBAQEBAVbvAe9WAQEB7wHvVu8BVgEBAQEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP4B + AQEBVu8BAVYBAe8BVgHvVu8BAQEBAQEBAdPT9PT09FL0UtNWAQEBAe8BAQEBAQEB7wEBVgEBAQEB7wFW + 7wH7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA/v7vVgHvAQEBAQEB7wFW7wEBAQEBAQEBVvSC+BAMEAwQDAwM1QwM1dW7DDFS0wHvAQEBAQFWAe8B + 7wEB71YBAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAA7wEBAQFWAe9W7wHvAQEBAQHvAQHTghAQEBAQEIgQEBAQEBAQDBAMDNXV1dW7uzFS + AVYBAQEBAQFWAVbvAQHvVu8BVgH+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAFWAQEB7wEBAQEBVgEBAQEB/Vb0BxAHiAeIiAeIiIiIB4gHiIiIEBAQ + EBAM1QzV1bu7MdMBAQEBAe8BAQEBAQEBAe8B7wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAe8B71bvAVbvAVbvAQEBAdMyiAcHBgcGBgYGBgYGBgYH + BogHB4gHiIgQEBAQDAzV1dXVErvTVgEBAQEBAe9WAe9WAQEBVgHxAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7AVYBAQEBAQEBAe8BAQEBAdOKBwcGBgYGBgYG + BgYEBgYGBgQGBgbGBwaIB4gHiBAQEBAM1QzVuxIxUu8B71YB7wEBAe8BAQHvAQEAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQHvVu8BAQHvVgEBAe+CBwYG + BAYEBgQGBgUGBAYEBAYEBgYGBAYGBgYGBogHiIiIEBAMDNXV1RK7MVYBAQEBVu8BAQFW7wEBAQH+AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/vEBAe8BAQEB71YBAQEB + Ae/TBgYGBgYGBAYFBAUEBQUFBQUFBQUFBQQGuQYFBgQGBgbGiAcHiBAQEAwM1dW7ElIB7wEBAVbvAQEB + 71YB7wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7wHvVgFW + 7wFWAQHvAQHvggYGBAYKBAUFBQUFBQUKCgoKBQoFCgUFBQUFBAUEBgQGBgYGBoiIB4gQEAwM1dW7EjFW + AQEBAQEBAe9W7wEBVgHxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + /lYBAQHvAQEBAQEBAQH97zIGBAQEBQUFCgoKCgoKCgoeCh4KCgoeCgoeCh4FBQUFBQQFBgQGxgaIBwcQ + EBAMDNW7u7v0AQEB71YBAQEBAQHvAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAABAQHvVgEBAe8BAe8BAdMEBgQKBAoFCgoKCh4KAx4DAwoDCh4DHh4KHh4KCgoKHgUFBQUE + BAYGBgYGiAeIEBAM1dXVErtSAe9WAQHvVu8BVu8BAQHxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD+/u8BAQEB71YBVgEBAf2CBgQEBQUKCgoKHgoDAwNTCwMeAx4DAwMDAwMDAx4e + Ax4KHgq5BQUFBQYFBARUBgeIiBAQDAzVuxJSAQEBAQEBAQEBAVbvAQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVgFW7wEBAQHvAQEBggYKBAoKCgMKAwoDAwMDAwsDAwMCAwID + AwMDAwMDAwMDHgMeHgoeCh4FBQUGBgYGBgaIiBAQDNXVuxIxAQEBAQFW7wHvAQEBAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+7wHvAQHvVu8BAQEB/YIEBAUKCgMKCh4DCwMDCwMD + AwMCAwMJAwIJAwIDCQMDAwMDAwMeAx4KuQoFCgUEBAYEiMYHiBAQDAzVuxIx71bvAQEBVgEB71YBAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAVYBAQEBAQEBAQGCBAoKCgMDCgMD + AwIDAwIDAgkCAwkCCQIJCQIJCQkCCQkJAwMDAwMeAx4eHgoFBQUFBQYGBgaIB4gMEAzVuxJSAQEBAe8B + 7wEBAQHv/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe8BAQHvAVYBAVbvNwoF + CgoKCgoDCwMDAgMCAwIDAgkCCQIJCQIJCQIJAgkCCQIJCQkDAwkDAx4DAx5TBQUFBQQEBIjGB4gQDAzV + uxJVAQEBVgEB71bvAVYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAVYB71YB + Ae8BAe8uAgUKAwoCAwIDAgMCAwIJAgkJAgIJAgkCCQkCMAIJCQkJCQkCCQIJAwMDAx4eHh4KCgUFBQYG + BgaIiIgQDAzVuy437wEB7wFWAQEBAe/+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADx + AQHvAQHvAQEBAQHvLy4uCgMKAwIDAwIDAgkCAgkLCQIJCQkCCTACCQkJCQkCCQkCCQkJCQkCCQkDCQMD + AwMeBQoFBQQEBsYGB4gQDAwHLi9WAQEBAe8B71YBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAEB71YBAQEBVu8BAYICLi4K+QMCCwMCAgIDAgkLCQICCQIJAgkJCQkJCTAJMAkJMAkJCQkw + AgkJAgkCAwMeHh4eCgUFBQQGBgaIiIgQDAouLooBAVbvAQEBAQHvAfEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD+AQEB7wFW7wEBAQHTCgIuLgsDAwMCCQsJAgkCCQMJCQkJCQkJMAkJMAkJCQkJ + MAkJCTAJCQkJCQkJCQMJAwkDAwMDHgW5BQQEBsYHBxAQLi4uDPQBAQEBVu8BVgEBAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFW7wFWAQHvAQEB7woKLi4LLgMCAgMCAgkDCwkCCQIJAwkJCQkJ + CQkJCccwx8cJqgkwCTAJqgkJCQkJCQkJAwMDHh4eCgoFBQQGBgaIiARRLi4MuwEBAVbvAQEB7wEBAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+AQHvAe8BAQFWAQGCCgoCLlFRCwMCAwIDAgIDCQMJ + AwkJCQkJCQkJCccwCQkwCTAJqgkJxwkJMAkwCQkJCQIJAwkDAwMeHgoFBQQEBsYHUQsuLgy7Me8BAe8B + AQHvVgEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHvAVYBAQEBVu8B7woDAgsuUQhRAwID + AgMJAwkCCQkJCQkJCccJxwnHMAmqCQmqCcfHx8cwxzAJqgkJCQkwCQkJAwMDAx4eCh4FBQQGBhNRUS4L + DNW7VgEBAVbvVgEBAQH7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+VgEB7wFW7wEBAQFVCgoK + Ay4uCwgLAgMCAwIDCR4JAwlTCQkJCccJxwnHCcfHx8fHUwUHxwlTxwnHMAkwCQkJCQkJCR4JAwNTCrkF + BQQE1FELLgsM1dUx7wEBAQEB7wEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7wEBAQHv + AQEB0woLAwIDLlFRUdQLAwkDCQMJAwkJxwkJxwnHU8fHx8fHx8ceBAcHBwcJuQcGBQMJxwkJCTAJCQkC + CQMDHh4eCh4FBNTUUVEuBRAM1btWAQEBAe8BVgHvVv7+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+ + AQEBVu9WAQFWAQFVCgP5AgICUVEICNQDAwkeCVMJAx5Tx1PHCcfHx8fHxzQGB4gQEAcQB8ceBxAHBwZT + CQkJCQkJCQkJAwkDAwMeCgUT1FELUS7GEBDVDDEB7wFWAe8BAQEB7wAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAB7wEB7wEB7wEB7wr5AwILAwsuCwjUqwtTAwNTCR7Hx8cJx1PHNMfHx8fHBRAQ+BCKEIoQ + xx6IBwcHiAcHBFMJCQkJCQkJAwMDHgMeCqurCFFRCwYQEAzVuwFWAQHvAQFW7wFW/gAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAFWAQEB71YBAQFX+QMC+QIDAy4LUQirqwsJHglTU1NTUwW5BQUFuQVTNMe5 + EBAQEBAMEBDHuRAQiPgHEAcHBwYFAwkJCQkDCQkDHgoTCKsICy4KBwcQEAzV0+8BAVYBAQHvAQEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAe8B71YBAQEBAYQDC/kLAwMDLlEL1KvUEx5TUx4EBgeKEIgQ + igwQDBCIx7kMDAwMDBAMEMfHxogQEIgHBwcHBwcGBAoDAgkCAwMDE6ur1FFRUQUGB4gQDNUxAQEB7wEB + 7wFW7wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8QFWAQEBAe8B7wEBCgIDAgP5CwMCD1EICKur1AUG + BwcHiBAQEBAQEBAQDBA0HQwMDAwMDAwQNKrHxx7GEBAHEAcHBwYHBgYEHgMJUxOrq6sICFECBMYHBxAQ + DLvvVgHvAVYBAQFWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe8BAe8BVgEBAdMDC/kDAwIDAwML + UQgIqxNY7gYHBwcQBgUFBcaIDAwMDMe5DAwMDAwMDAzHx8fHqsfHHlQHiAcHBwYGxgYEBgoKqxOrCAhR + LgoEBgaIiBAM1dMBAQFW7wHvAQEB7/4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7wFWAQHvVgEBL/kC + CwIKAwoeCgIuCwgIuO5Y7gcHEAc0U8c0x8c0BhAQNAW7DLsMuwwMDDTHNMfHx6rHx8cFBgcHBwcGBgYE + BlhYq6vUC1ELCgQGxgcHiAwMMQEBAQEBAVbvAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWAQHv + AQEBAQEKAgoD+QMDAwMDAw9RCwi47li6EAf4EAcENFM0xzTHszTHHdXVDAwM1QwMNB4MiAU0x8fHqsfH + UwUGBwYGBgRY7li4CAgL8wMFBQYGBgcQEAz4AQEBAe8BAQEBVu/+/gAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABAe8BAVYBAQEBAfkDAgsDAwoDCh4DCw8LCLhYWLfuEIoQDBAMiMY0xzTHNDQFDLu71bsMuww0HQwM + DBAHucfHx8fHxwkeBgYE7u5YWFgICFELCgoFBQbGBweIDNXTAQEBVu8B7wEBVgEAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAHvAVbvAQHvVu/TAgsK+QMKAwpTuQoDC1EICBOD7rq6DBAMDAwM1QyIBTTHxwXV1bvV + u9XVDDQe1QwMDAwMEAZTx8fHxwkeBu63WFhYgwhRUQIeCgUEBgYGiBAQDNMBVu8B7wFWAQEB7/7+AAAA + AAAAAAAAAAAAAAAAAAAAAAD+VgEBAe8BAQEBAVX5AgMDClMeCgoeHh4CDwgICKsTWO66DAwMDAwM1bvV + DFQ0VLvVu9W7u7sMNAXV1bvVDAwMDBAHiAbGBgf4urpY7rirCAsLAwO5CgUFBgYHiBAM9AEBAQEBAe8B + AQHvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAe9WAQFW7wFWVR4KAwoDCgpTHgpTuQMPCwgIDhMTE4Pu + DNUMu9W71bu71ccdu7u7u7vVu9U0NAwMDAwMDAwQEBCKBwcH+LruWFgTqwgIUQsDCgoKBQYGBgaIEAz0 + AQHvVu8BAVYB7wFW/v4AAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQHvAQEBAQEvAgMDAwpTCgq5Ch4FHgIP + CAgICA6rExPGxhAMu9W7Eru7NMYSuxK7u7u71TTHNDRUiBAMDAwMEBAQBxDu7lirEw4ICAgPAwMDHgoF + BQTGBwcHDPgBAQEBVu8B71YBAe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVbvAQEBVu8BAQoL+QoDCgoe + Ch4FBVMeHg8LCAgIExMTE4MdNB2IDLu7u9U0VLu7u7u7Eru7NDSzx7PHxzQ0HgW5HVMegzITqxMOqwgI + UQIDHgMDCgoFBgYGB4gQ+AEB7wEBAQEBAQEBAVb+AAAAAAAAAAAAAAAAAAAAAAAAAAAB71YBAe8BAQEB + +fkKAx4KHgq5Hh4eBbkeAw8PCAgICBMOxsYFNDQ0VIjVuzRUuxG7Eru7u7s0x8c0xzQ0HjTHx8fHHsaD + qxOrEwgICAsPAwIDAwoDBQoEBAYHBxAMAQFW7wHvVu8B7wEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB + AQHvVgEBAQEKAwMKCgq5Ch4KBbkeBR4eMAsICPcIExMTxoMdNB00NB1UNFQSu7u7u7sSuzQ0NDSIDNUM + DIg0xzTGgxOrEw4TDggIDwIDAx4LAx4KBQUGBgcHEAz9AQEBAVYBAQFWAQHvAQAAAAAAAAAAAAAAAAAA + AAAAAAD+7wEBAQHvAe8BAfkDClMKCgoFCgUeBQU0BR4eDw8ICAgICBMIxlQFNB00NTQdVLszuxESu7u7 + Hcc0VLu71bvVDAw0g4MTExMIEwgICAsPAwkDAgMDCgoKBQTGBgeIDFbvAe8B7wEBAe9WAVYBAAAAAAAA + AAAAAAAAAAAAAAAAAAABAQFW7wEBVgFWCgoKCgq5BQq5BbkFuQW5BbkJDwv3CPcIExPGxlQdHTQduTRU + EbsRu7u7M7s0NDRUu9W71QwMu7sHxqsTDhMOCAgPCwkDAgMDAx4DCgoEBgYHBwcQAQEBVgEBAQFW7wEB + 7wEB+wAAAAAAAAAAAAAAAAAAAAAA/lbvAQFWAQHvAQH5A1MKCgoKBQoFBQUFBQUFHVMPCw8ICAj3CBME + Q1RUNB01HVQREjMREbsRuzQ0NFS7u7vVu7sNyoMTExMICAgICwsPAwMJAwIDAwoDuQoEBAYHiAwBAQHv + AVbvAQEBAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAe8BAQHvAQEBAQoKCgoFCgUKBbkFBbkFuR25BccP + Dwv3CAsIExPGxlQdHVQ0HxERERESErsSHTQ0VLu7u7u7DcrKEAgTCAj3CA8PDwMJAwkLAwMKAwoKBQQG + BgcHEAEB71YBAe8BAe8B71YB7/7+AAAAAAAAAAAAAAAAAAAAAP5WAe8BAVbvVgEB+QoKCgoKuQoFBQUF + BQUFBQUFHgkPDwv3CPcI9xPGVFQdVB2pDTMRMxERuxE0NDSIu7u7uw0NyvXuExMICAgICw8JAwkDAwMD + AgMDCgoKBQbGBwf4AQEBAQEB71YBVgHvAQFWAQAAAAAAAAAAAAAAAAAAAAAAAAEBAVYB7wEBAQEKCgoK + uQUKBQUGuQUFuVQFuR1Uxw8PD/cICwsIHsbGVFRUsh8RDRERMxEzEh00NIgSuxINDcrKuu4ICAgI9wsP + AlMJHgkDAgMDAwoDCgoFBgYGB/gBAQEB7wFWAQHvAQEBVu8BAAAAAAAAAAAAAAAAAAAAAAAAAQHvAQEB + 7wEBAYQKBQoKCgS5BQUFxgUFBVQFuQVUCQ8LD/cI9wgIE/eDVFRUHw0NMw0RERESVDQdVLvKDQ0NynG6 + 7gj3CAgLDw8JAwkDAwMDAwMDAwoKCgUEBgcHilbvAVbvAe8BAQFW7wEB7wEBAAAAAAAAAAAAAAAAAAAA + AAABAVYBAe9WAQEBMgMKCgUFBQoFBQW5xrlUBQVUVFQeMA8P9wsIC/cT98ZUVB8fDQ0NDREzEREdNDSI + EQ0NDcrWuu7uCwgIDw8PAx4JUx4JAwsDAwsKAwoKBAYGBweCAQEBAQEBAVYB7wEBAQFWAQHxAAAAAAAA + AAAAAAAAAAAA+wEB7wEBAQHvAQFVCrkKCgUKBQUFBgUFBAVUBcbGVFQeMA8PC/cPCxMIEx2DVBINDQ0N + DQ0zElQdNLsNDQ3KcfW6uoUI9wgLDwnHUx4JAwMDAwMDAwMKUwoFBAYGiNMB7wHvVgHvAQEBVgHvAe8B + AQAAAAAAAAAAAAAAAAAAAAAAAQEBVgHvAVYBAYIKCgoFCgYFBrkEBcZUuVTGVFRUVIgJDw/3C/cI9wsT + BcZUDA0NDQ0NDRERVDSyEg0NDcr1urruMggIDw8JUx5TCQMDAwMDAwMDAwoKCgQGBgcH0wEBVgEBAe9W + Ae8B7wEBVgEB7/4AAAAAAAAAAAAAAAAAAAAAAe8BVu8BAe8B7woKBAq5CgUFxrkGBQUGxgbGiFRUVFTH + Dw8PCAv3CPcT98YSDQ0NDQ0NDRJUVB8SDcrKcbru7u649w8LDx40Ux5THgMeAwMDAwoDAwoKCgQEBwdW + 7wEB7wEBAQEBAQFWAQHvAVYBAAAAAAAAAAAAAAAAAAAAAAAB7wEBAQEBAVYBCgUECgQEBQYFBgXGVMZU + VFRUiFSIHwUwD/cP9wgLCxMTxhANDQ0NDQ0NDR+pHxINyvW67rruhQgICw8eNFMeU1MDAwMDAwsDAwMK + CgoFBgYGigEBAQEBVu9W7wHvAe8B7wEBAe8BAAAAAAAAAAAAAAAAAAAA/lYBVgHvVu8BAQGECgq5CgUF + BAQFBgXGBsbGVIhUH4ipHx4wDwv3D/cI9wgTDA0NDQ0NDQ0NH9IfMw1xurq6WO6F9w8Pxx4eHlMeUx4D + CgMDAwsDCgMKCgQEBgeCAe9W7wEBAQEBVgFWAQFW7wFWAQEAAAAAAAAAAAAAAAAAAAAAAQHvAe8BAQEB + 74IKBQQGCga5BgUGVAZUxlSIiB+IHwwfH1MPDw8L9wsICxMfDQ0NDQ0NDQ0QHx8RDbq67u7uhRMPC8cF + HjQFUx5TAx4DAwMDAwoDCgoKBQQGB9MBAQEBAQHvAQEB7wEB7wEBAQHvAQH7AAAAAAAAAAAAAAAAAAAB + AQEBVgHvVgEB7woKCgUFBQUGBcYGxsYHVIhUiIipH9UfHzD3D/cICPcIExINDQ0NDQ0NDR8fHw0Nurru + he6DCA8PHjQeuR4FUx5TAwMKAwoDAwMDCgoEBgYHAVbvAe8BAVbvAQEBAQFWAe9WAQFWAQAAAAAAAAAA + AAAAAAAAAAABAVbvAQEBAe9WCgQKBgoGBgUGBsZUBlSIVIiIHx8f1R8SVDAPDwsP9wgTHw0NDQ0NDcoN + EbsRDQ3K7oXuuAgPMB65HgW5Hh5TUwpTCgMDAwoCCgoKCgQGBoIBAQEBVgFW7wEBVu8B7wHvAQEBAe8B + /gAAAAAAAAAAAAAAAAAAAAEBAQEB7wEBAQFVBAoKBQUEBQXGBgbGB1SIiIiI1R8fEh8SxjAP9wgP94O7 + DQ0NDcrKyg3KDQ0NDQ3uWIMLDw8eHQU0Hh65HgUeHgMeAwoDAwoD+QoECgQG0+8BAQHvAQEBAe8BVgFW + AQHvAQEB71YBAAAAAAAAAAAAAAAAAAAAAQEBAe9WAQEBAdMKBAQGCgYGBgZUxohUB4iIHx/VH9USEhKv + Hg8PD/cIELsNDQ3KytZxysrKDQ0NDYUI9w8PHgW5HgW5BR4FU1MKHgMKAwMKAwoKCgoGBIoBAQFW7wEB + AQHvVgEB7wHvAVbvVu8BAQH+AAAAAAAAAAAAAAAAAAD7AVYB7wHvVu8BAYQKBAoFBQQFBsYGxgeIVIgQ + iB/VHxKvEjMfUw8PCPeD1crKynH19bpxysrKytYMxggLDx4FHQW5HgUeuQUeCgNTCgMKAwMKAwoKCgQH + glbvAQFWAe9WAQHvAQEBVgEBAQEBVu8B7wEAAAAAAAAAAAAAAAAAAAABAe8BAVYBAQFW0wUEBAQEBgYG + BlSIVAeIEB8QH9Uf1RISEhIfHg8PxhAMytZx9bq67rq67viDg/iDCAswxrkFuQUduQUFHh65HgpTCgMK + AwMKCgoEBgYBAQEBAe8B7wEB7wFW7wHvAQEB7wEBAQFWAQAAAAAAAAAAAAAAAAAAAAEBVgEB7wHvAQEB + hAoGBQUEBcYGxsYHVIiIiIgMH9USHxIzrxIfCQuDg+7K9bq67u64MqsTgzKDgxAID1QdBR0FuQUFBbkF + Ch4KHgMKAwoDClMKCgQE9O8B71YBAVYBAVYBAQEBAQHvAVYB7wEB7wEBAAAAAAAAAAAAAAAAAAAAAAEB + Ae8BVgEBAQHTBQUKBgYGBgbGiAeIiIgfEB/VH9USEhISMxJUCIMy7u7uWDITqxOrE6syuDKDMsbGxrkF + uQUFBbkFBQq5ClMKCgMKAwoKCgoFBgbvVgEBAQHvAe8B7wEB71bvAVYB7wEBVgHvAVbv/v4AAAAAAAAA + AAAAAAD+7wFWAQEB71YBAQGCBgoEBAUEBgbGiMaIEIiIiAwfHx8SHxISEh8yxrgyuBOrE6sTDhMTqxOr + MrgygwRUBQVUuQUFBQUFBQUKHgpTCgMKA/kKCgoGggEBAe8BVgEBAQFWAQEBAQEB71YBAQHvVgEBAVYA + AAAAAAAAAAAAAAAAAAAAAQHvAe9WAQHvAe8EBQQEBgYGxlQHiIiIiB8QH9XV1dUSEhKIMrgyuDITqxMO + CA4TCKsTq6syuDKrWMYEBQUFBQUFuQUKBQoKUwoDCgMKCgoKBAYBAQHvVgEB7wFW7wHvAe9W7wEBAQEB + 7wEBAQHvAQEAAAAAAAAAAAAAAAAAAAABAVYBAe8BAVYB79MFBAQEBAYGBsYHB4iIEBAQDB/VH9XVgzK4 + Mqurq6sTqxMTEw4TDhOrE6syuDKGuMYFBQS5BQUEBbkFuQoKCgoDClMKCgoE0wEBAQHvAQEBAQEBAVYB + AQFWAe8B71YBVu8BVgHvAQAAAAAAAAAAAAAAAAAAAAABAe8BAQEB7wEBAYIEBAYGBAbGiAdUiIgQiB8Q + H9Uf1YMyqzKrMqsTE6sIqwgOCAirqxOrq6u4q6tYMjLGBQUFBrkKBQoKCgpTCgoK+QoKBIIBAQHvAVYB + Ae9W7wHvAQEB7wEBAVYBAQEB7wEB7wFW7/4AAAAAAAAAAAAAAAAAAAEB71YB71YBAe8BVoQFBAQEBgbG + BwcHiIgQiBAMEAwHhliruKurqw6rE6sIqwgOEwgICKurE6syq7iGuDIEBQUFBgUFBQpTCgoDCgMKCgoG + 0wHvVgEB71YBAQEBAVbvAVbvAQEB7wHvAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQHvVgEB + 0wYEBgYGBgbGB4gHiIgQiB8Qxri4q6syqxOrE6sICA4ICAgIDqurE6urq6uruDK4hjLGBAQFCgUKCgoe + CgMKCgoKBNMBAQEBAQHvAQHvAQFW7wEBAQEBVu8BVgEBVu9W71bvAQEB/gAAAAAAAAAAAAAAAAAAAVbv + Ae8BAQHvAQEB7wQFBATGBgbGVAeIiBAQEDIyqzK4q6urq6urCKsOCAgIUQgICA4IDhOrE6urq7gyq6sE + BAUFBbkKCgoKCgr5CgWCAe8BAQHvAVYBAVbvAQEB7wHvAQEB7wEB7wEBAQEBAVbvAVYAAAAAAAAAAAAA + AAAAAAAAAQEBVgFW7wEBVu8BggYGBgYGxgcHBweIiAcTuKu4q6urEw6rCKsOqwgICAsPCAgIq6urq6ur + q6urq7iruDIEBAUKCgpTCgr5CgoFgv0B7wFW71YBAe8BAe8BAe9WAVYBVu8BAQFWAQHvAQHvAQEBAe/+ + AAAAAAAAAAAAAAAAAAAAAQEB7wFW7wEBVgEBggQEBAYGBsYHBwcHq6u4q6urq6urq6sOqwgICAgLEwoL + CFEICA4Iq6sOq6urq6u4q6sEBQUFCgoKCgoKCjLvAVYBAQEB71YB71YBAVYBAQEB7wEB71bvAe8BAVYB + AVbvAQEBAQAAAAAAAAAAAAAAAAAAAAABAe8BAQEBAQHvAQEBggYEBgQGBgfGBKurq6urq6sOqwirCKsI + CAhRC8YQVAoLCwsI1KurDqurq6urq6urq6sTCgoKCgMKCgqEAQFW7wEB7wEBAQEBAQHvAe8BAQHvAQEB + AQEBAVbvAe8B7wEBVu8BAAAAAAAAAAAAAAAAAAAAAAABVu8BAe9WAQEB7wEBggYEBsYGxtSrCKurq6ur + q6urq6sICAhRCASIiIiIVMYKC1EICFGrCKurDqurq6urq6urCgoKClMKMlbvAQHvVgHvVu8BAe8BAQEB + Vu8BAVYB71YBAe8BAVYBAQFW7wEBVgEBAAAAAAAAAAAAAAAAAAAAAAABAQFW7wEB71YBVgEB08YGBArU + CKurq6urqwirqwhRCAhRCBOIiAeIB8YHxogFHgtRCAjUCKurq6urq6vUJtQICwoK+YIBAQEBAQEBAQEB + AQEBVgFW7wEBAQFW7wEBAQHvVgEB7wEBAe8BAQHvAQH7AAAAAAAAAAAAAAAAAAAAAAEBAQEBAQHvAQHv + AQEB7xNRUVHUUasIq6urJtQICFFRCwrGiAcHVAdUBojGxgfGBQpRUVEI1AhRqyarq6vU1FFRCwuCAQHv + Ae9W7wEBVu9W7wHvAQFW7wHvAQHvAe9WAQHvAQEB71YBAQHvVgEBAQAAAAAAAAAAAAAAAAAAAAAAAAEB + 7wHvVgEBAe8BAVbv7y9RUQgI1AirUQjUCFFRCBPGiAcHBlQHBwaIxgaIxgYGxgUKC1FRUdTUCNQIUQhR + UVEvVgEB7wFWAQEBAQHvAQEBAQEBAe8BAVYBAVYBAQEB7wFW7wEBAe8BVgEBAe9W/gAAAAAAAAAAAAAA + AAAAAAAAAAFWAQEB71YBVu8BAQEBVlVRUVFR1AjUUVFRCwUGiAcHVAeIBojGiAYHxgYGBsYGBgQKCgtR + UVHUUdRRUVHUL1bvAVYB7wEBAe9WAe8BAQHvVu8BVgHvAe8B71bvAVYBAQFW71YBAe8B7wEBAQEAAAAA + AAAAAAAAAAAAAAAAAAAAAAEBAe8BAQEBAQEB71bvAVYvUVFRUVELCgQGB8YHxgcHxgcHxgcGxsYHBsbG + BgQEBgYGBAr5C1FRUVFRL1cBAQEBAe8BAQHvVgHvAVbvAVYBAQEB7wEBVgEBAQEBAe8B7wEBAQHvVgEB + VgHvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBVu8B7wHvVgEBAe8BAQHTLwoKBAbGBwYGBwYHxgYHBsYH + xgcGBsYGBgYGBgQGCgYEBgQKCgoD1IIB71YBAe8BVu9WAQEBAQEBAQHvAQHvAQFWAe8BAe8B7wEBAVYB + Ae8BAQEBAe8B71YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQFWAQEBAe8BVgEBAe9W0wYGBgYGxgbG + B8YGB8YHBgYGBgbGBgbGBgQGBgQGBAQECgQKhIIBAQEBAQHvVgEBAQEB71bvVu8BVgEBVu8BAe8BAVbv + AVYBVu8B7wHvVgFW7wHvAQFWAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAe9W7wFWAQEB71YB7wEB + AdOCBgYGBgYGBgYGBgbGBsYGBgYGBAYEBgQGBgQEBQQKMtMB7wEBVu8BAQEB7wHvAQEBAQEBAe8BAe8B + AVYBAQEBAQEB7wEBVgEBAQEBAQEBAVYB7wEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQHv + AQHvAQEBVgHvAQFW04IGBgYGBsYGBgYGBgYEBgQGBAYEBgQFCgaE0+8B7wFWAQHvAQFW7wEBAVYBVu8B + Ae8BVu8BAVYB7wHvVgHvAQEBAQHvAQFW7wHvAe9W7wEBVgHv/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABAe9WAe9WAQFW7wHvAVYBAe8B7wHTgoKCBgYGBgQEBgYEBgQGBgYGgoLTAVYBAVYBAe9WAQHvAQHv + VgEB7wEBAe9WAQEBAQHvAQEBAe8BAVbvVgHvVgHvAQEBAVYBAQEBAe8BAQAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAABAQEBAQEB7wEBAQEBAQHvAVYBAQEBAQFW79PT09PTgtPT09PvAe8BVgEB7wEBAe8B + AQEB71YBAQEBAQHvAQHvVgEBAe8BVgEBVu9WAQEBAe8BAQEBAQFWAe9WAe8B7wFWAQEBAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAABAQHvVgEBAQHvVu8BVgEB7wFW71YBAe8BAQHvVgEBVu8BAQEBAQHv + AQFW7wEBVgHvVgEB7wHvVu8BAVYBAQEB7wFWAe8B7wEBAe9W7wEBAe9WAe8B7wEB7wEBAVYB7wEBAQEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAe9W71YBAQEB7wHvVgHvAQHvVgEBAe8BAe8B + AQEB71bvAQFWAe8BAe8B7wEBAQEBVgEBAQFW7wHvVu8BAQHvAQFWAe8BAQEBAVbvAQEBAVYBAQEBAVbv + AQHvAVbv/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAQEB7wEB7wFWAQEBAQEBAe8B + Ae9WAQEBVgHvVgEBAVYBAe8BVgEBVgEBAe8B7wEB7wHvAQEBAQEBAVbvAVYBAe8BVgEB7wEBAVbvAQEB + 7wHvVu8BAQEBVgEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBVu8BVu8B + Ae9W7wFWAQEBVu8BAQHvAe8BAQHvAQHvAQEB7wHvAQFW71YBVu8BVgFWAe9W7wHvAQEBAe8BAQEBAe9W + AQHvAe8BVu8BVgEBAQEB7wHvAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + AQEBAQEB71YBAQHvAQHvAQEBAe9WAQFWAQEBVu8BAVYB71YBAVbvAQEBAQEBAQEB7wEBAQFWAQEB71YB + Ae9W7wEBAQHvVgEBAQEBAQHvVgHvVgFWAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQEBAQEBAQHvVgEBVu8BAVbvAQEB7wEB7wHvAQFW7wEBAQHvAQEBAe8B7wEBAe8BAQHv + Ae8B71YBAQHvVgEBAVbvAVYB7wFW7wEB7wEBAe8BAe8BAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAe8BVu8BAe9WAQHvAVYBVgHvAQEBAe9WAQEB71YBVgFW + 71YBVu9WAVYBAQEBAe8BAQEB7wEBAQHvAQEBAQHvVgFWAe9WAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEBAQEBAQEB71YB7wEB7wFW7wFW7wEB + 71bvAQHvAQHvAQHvAQHvAQHvVgHvVgHvVgHvVgHvVu8BVu8BVu8BAe8BAQEBAQEBAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEBAQEBAQEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAA + 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 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + ///////////8AAD/////////////////wAAAB////////////////AAAAAD///////////////AAAAAA + H/////////////+AAAAAAAf////////////+AAAAAAAB/////////////AAAAAAAAH////////////AA + AAAAAAAf///////////AAAAAAAAAD///////////gAAAAAAAAAP//////////wAAAAAAAAAB//////// + //wAAAAAAAAAAP/////////4AAAAAAAAAAB/////////8AAAAAAAAAAAP////////+AAAAAAAAAAAB// + ///////AAAAAAAAAAAAP////////gAAAAAAAAAAAB////////wAAAAAAAAAAAAP///////4AAAAAAAAA + AAAB///////8AAAAAAAAAAAAAP///////AAAAAAAAAAAAAD///////gAAAAAAAAAAAAAf//////wAAAA + AAAAAAAAAD//////4AAAAAAAAAAAAAA//////+AAAAAAAAAAAAAAH//////AAAAAAAAAAAAAAA////// + wAAAAAAAAAAAAAAP/////4AAAAAAAAAAAAAAB/////+AAAAAAAAAAAAAAAf/////AAAAAAAAAAAAAAAD + /////wAAAAAAAAAAAAAAA/////4AAAAAAAAAAAAAAAH////+AAAAAAAAAAAAAAAB/////AAAAAAAAAAA + AAAAAf////wAAAAAAAAAAAAAAAD////8AAAAAAAAAAAAAAAA////+AAAAAAAAAAAAAAAAH////gAAAAA + AAAAAAAAAAB////4AAAAAAAAAAAAAAAAf///+AAAAAAAAAAAAAAAAD////AAAAAAAAAAAAAAAAA////w + AAAAAAAAAAAAAAAAH///8AAAAAAAAAAAAAAAAB////AAAAAAAAAAAAAAAAAP///wAAAAAAAAAAAAAAAA + D///8AAAAAAAAAAAAAAAAA////AAAAAAAAAAAAAAAAAH///gAAAAAAAAAAAAAAAAB///4AAAAAAAAAAA + AAAAAAP//+AAAAAAAAAAAAAAAAAD///gAAAAAAAAAAAAAAAAA///4AAAAAAAAAAAAAAAAAH//+AAAAAA + AAAAAAAAAAAB///gAAAAAAAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAD///AAAAAAAAAAAAAAAAAA///w + AAAAAAAAAAAAAAAAAH//8AAAAAAAAAAAAAAAAAB///AAAAAAAAAAAAAAAAAAP//wAAAAAAAAAAAAAAAA + AD//8AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAH//4AAAAAAAAAAAAAAAAAB//+AAAAAAAAAAA + AAAAAAAP//gAAAAAAAAAAAAAAAAAD//4AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAH//wAAAAA + AAAAAAAAAAAAB//8AAAAAAAAAAAAAAAAAAP//gAAAAAAAAAAAAAAAAAD//4AAAAAAAAAAAAAAAAAAf/+ + AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAA//8AAAAAAAAAAAAAAAAAAP//gAAAAAAAAAAAAAAA + AAD//4AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAA//+AAAAAAAAAA + AAAAAAAAP//wAAAAAAAAAAAAAAAAAB//8AAAAAAAAAAAAAAAAAAf//gAAAAAAAAAAAAAAAAAD//8AAAA + AAAAAAAAAAAAAA///gAAAAAAAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAD///AAAAAAAAAAAAAAAAAA// + /4AAAAAAAAAAAAAAAAAP///AAAAAAAAAAAAAAAAAD///4AAAAAAAAAAAAAAAAA////AAAAAAAAAAAAAA + AAAP///4AAAAAAAAAAAAAAAAD////AAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////gAAAAAAA + AAAAAAAAH////8AAAAAAAAAAAAAAAB/////wAAAAAAAAAAAAAAA//////AAAAAAAAAAAAAAAP/////8A + AAAAAAAAAAAAAH//////wAAAAAAAAAAAAAD///////AAAAAAAAAAAAAB///////+AAAAAAAAAAAAB/// + /////8AAAAAAAAAAAB//////////AAAAAAAAAAD//////////////////AB///////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////8o + AAAAQAAAAIAAAAABACAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + 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 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALXr+OCx7/fsuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8ufv//LXz+ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5+/Y8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx8/e8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALnz9+S59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8Af/8EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt + ff3PLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y19/nwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC1+/Ysuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8z + gPv/rqyx/7Gsq/+vqqn/r6qp/7Gsqv+zrqz/t7Gw/7q0s/++ubj/w7++/8rGxf9Fivf/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln7//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACx9/fUuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln7//6aiov+gnZv/nZqY/5yZl/+bmJX/m5iV/5yYlv+empj/oJya/6Ofnf+oo6L/raim/7Otq/+3 + sbD/vbi3/8XAv//Oysn/Ln7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//nZuZ/5iTk/+Uj5D/ko2N/5GLi/+Ri4r/kYyK/5GLif+Ri4n/koyK/5WOjP+W + kI//mpSS/5yXlf+inZr/p6Og/6+qqP+2sK7/vLa2/8XAv//Oy8r/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/f4u + ff//Ln3//y59//8uff//Ln3//y59//9mi8j/k46O/46Jiv+Lh4X/iYSD/4iCgf+IgYD/h4B//4d/fv+I + gH7/iIB+/4mBf/+LgoD/jYWB/46Hhv+Sion/lY+N/5qTkf+fmpf/pqGf/66pqP+2sK//vbi3/8jEw/+T + r+L/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC18/dUuff//Ln3//y59//8uff//Ln3//y59//+Tj4//jIiH/4eCg/+FgH//gnt7/4B5d/9/ + d3X/fnVz/351cv9+dXL/fnRx/391cv+AdnP/gnh1/4R6d/+GfXr/ioB+/42FgP+PiIb/lI2M/5qTkP+e + mZb/qKOh/7Grqf+6tLT/w7+9/9DNzP8uff//Ln3//y59//8uff//Ln3//y59//8tff3xAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC14/yIuff//Ln3//y59//8uff//Ln3//y59//+Oior/hoKC/4J9fP9+ + eHf/e3Nz/3lxcP94b23/eG5r/3Ztaf93bGj/eGxo/3lsaP95bWj/e25q/3xva/99cWz/f3Nu/4J3c/+E + eXb/iH17/4yDgP+QiIb/lI2L/5qUkP+inZr/rqim/7aysP/BvLr/zsrJ/y59//8uff//Ln3//y59//8u + ff//Ln3//yt7/iMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//+K + hob/gX19/3x3d/95cnH/dm9u/3Vsav90amj/dGll/3RoZP91aGP/dWdi/3VnYf92ZmH/d2dh/3dnYv94 + aGP/eWtk/3tsZ/99b2r/f3Jt/4J1cP+FeXb/iX97/46Egv+Sioj/l5CO/5+al/+qpaP/ta+u/7+7uf/N + yMj/Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAufv//Ln3//y59//8u + ff//Ln3//y59//88V0n/gHx7/3lzc/91bm7/c2tq/3JpZv9yZ2T/c2di/3JmYf9yZF//c2Nd/3RkXf90 + Y1v/dWNb/3VjW/92ZFz/dmRc/3dlXf94Zl//eWhh/3pqY/98bWj/f3Js/4J2cv+Ge3f/i4F+/4+Hhf+V + jo3/nZiV/6ikof+1r67/v7u5/5+loP8uff//Ln3//y59//8uff//Ln3//y1+/foAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + f/8CLn3//y59//8uff//Ln3//y59//99fon/QmRO/3hyc/9ya2v/cWln/3BoZf9xZ2P/cmZh/3NlYP90 + ZF7/dGNc/3VjW/91Yln/dmJZ/3dhWP93YVf/d2FX/3diV/94Ylj/d2JZ/3hkW/94ZV7/eWdg/3trZP99 + bmn/gHNu/4R4df+Jf33/j4eE/5SNjP+blpP/qKSh/7awr/8/Y07/eoaF/y59//8uff//Ln3//y59//8u + ff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8vfv3/e3Z2/0hxVf9ybWv/cWln/3BoZf9x + Z2P/c2Zh/3RmYP91ZV7/d2Vd/3hkXP94Y1n/eWJX/3liV/96YVX/emBU/3lgU/95YFT/eWBU/3lgVP94 + YVb/eGJX/3lkW/95Zl7/emli/31taP9/cmz/gndz/4h+fP+Ph4P/lY6N/5yXlP+qpqP/RnNX/2h8bv8x + f/3/Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//fHd5/3Nubv9L + eFn/U4tm/3BoZP9yZ2P/dWhj/3ZnYv93ZmD/eWZe/3plXP97ZFr/e2NY/3xhVf98YVT/fWBT/3xfUv98 + X1H/fV9R/3tfUf97X1L/emBT/3lgVP95Ylb/eWJZ/3lkXP95aGD/fGxm/35xa/+CdnP/iH58/4+Ghf+V + j47/VI1q/0t7XP+HjIf/ycXE/y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5+//8uff//Ln3//y59//8u + ff//QH7h/3RvcP9wa2r/S3dY/1WMZv9reWr/dWll/3dpZP95aGL/e2hf/3xnXf9+Zlv/f2VZ/4BjVv9/ + YlT/gGFS/4BgUP9/X0//gmdc/5+eoP+ShoP/mpeY/31fU/97X1H/e2BT/3phVf95Ylj/eWRb/3lnYP98 + bGX/fnFs/4J3dP+JgH7/kYmI/1SQa/9Lelv/paGf/724t/9Rj/P/Ln3//y59//8uff//Ln3//y5+/dgA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//Ln3//3dzdP9wa2z/cGlo/0x2WP9XjmP/XJ10/3hqZf96a2T/fmtj/39qYf+B + aF7/gmdb/4NmWP+DZVb/hGRT/4ViUf+mpaf/p6ep/6enqP+mpqf/l4uG/5+dnf+gn6H/nZ2f/5WQkP96 + XVP/emFV/3liWP95ZV3/eWdg/3tsZ/99cW3/g3h2/1qieP9UkWf/TXha/6aiof+1sK//w8HA/y59//8u + ff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAzZv8FLn3//y59//8uff//Ln3//y5+//9xbG3/cGpp/3Jraf9sa2T/Vodf/12bbv9g + pnz/fmxk/4FtZP+Da2H/lImG/6Kho/+npqj/qamr/6mnqP+Nb2H/raus/6+ur/+urq//rayu/52Piv+n + pKP/pqan/6OipP+fn6H/m5qc/5aWmP+Ifnr/eWJZ/3llXf95aGL/e21o/2SlgP9boXT/VY1k/1B4W/+d + mZf/q6im/7u2tf8uff//Ln3//y59//8uff//Ln3//yt8/i8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALX796i59//8uff//Ln3//y59//9pcof/cGxq/3Jrav91 + bmv/eG5r/1SAWv9el2n/YqN2/3bCqf+bmpz/oJ+h/6Skpv+oqKn/q6ut/6+usP+xsbL/l35z/7Oxsv+1 + tbX/tbS2/7OztP+ik43/h19K/4ZeS/+Pd2z/pKSl/5+fof+bm53/lpWX/5GRk/+NjI//fXBt/3VzZ/9f + qXz/XJxu/1SGYP+Gfn7/mJKR/6Ognv+zrq3/p7TM/y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//cGxt/3Fsa/90bW3/eHBu/3xxbv9WdVb/Xo5h/2Wgdf93zKz/lqyn/6Sjpf+koaD/jGpa/45pV/+O + Z1P/j2hX/5qAdP+3tbb/urm7/7q5uv+6ubr/p5iR/6+pqP+HXEr/hl5K/4RfTP+CXk3/koaA/5qZm/+V + lJb/kI+R/4uKjP9wyqr/YKV2/1qUZv9Pelr/ioKB/5ONi/+cmZb/q6in/724uP8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//Ln3//3Ftbf9zbm7/eHFv/3tycf+AdHH/f3Fs/1mCWP9jmGb/e8un/37UvP+n + p6n/ra2v/7Kysv+2tbb/mXtu/5FnUf+SZk//u7q6/769vv+9vL7/vby+/6qalP+2s7L/t7a4/7OytP+j + m5n/hF5O/4NgT/+AYlL/fF9W/5KRlP9207r/csij/2iwg/9YiF//fHJu/4Z+ff+OiIj/mJOS/6Ogn/+3 + srH/Ln3//y59//8uff//Ln3//y59//8tfP37AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//9xbW3/dW9v/3tzc/+AdnP/gnd0/4V3cf9a + eVb/YpBe/2ibaf9nmnL/itC9/7Gwsf+2trb/urq8/729v/+/v8H/ooZ6/7++vf/BwML/wMDB/7+/wP+t + nZb/ubW1/7u6vP+4t7j/srK0/62trv+npqj/oaCi/5uanP+N28z/ec+z/264jf9gmmf/VYFa/3twbv+B + eHf/ioSC/5SPj/+em5r/sayq/y5+//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8xfPf/c25v/3hycv9+ + d3X/gnh2/4N4dP+IeXP/hHNr/1+DVv9olmH/aphr/2ibdv+JoIL/lG1e/7y6u//CwsP/xMTF/6WJe//D + wcL/xcTG/8TDxP/CwsP/r5+Z/5JkS/+PYEz/lG9h/6qdmf+vra7/qaeo/52Xlv+UvKj/ZaKC/2Wgdf9l + n2r/XYte/3ptZ/96b2z/f3Z0/4eAf/+Qi4v/m5iW/6mnpf84gfn/Ln3//y59//8uff//Ln3//y59//8s + ff5yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8u + ff//Q3rS/3Vxcf97dXX/gHl4/4R7eP+HenX/iXp1/4x6c/9nclX/ZotZ/2qVYf9rlWv/cZd1/5qfgv+a + cVr/nHJZ/6F5af+rkIH/yMfG/8nJyf/Hx8j/xcXG/7Kim/+UZk7/kmNO/6ydlf+tpKD/jWRR/4lkUv+h + qZH/caGB/2aedf9nnGr/Y5Zi/1mAV/93aWX/eW5q/3xzcf+Ce3r/jYiH/5mUlP+lo6L/YJDj/y59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn3//y59//8uff//Ln3//0x2vv94c3P/fXd2/4F5eP+Fe3j/iXx3/4t8dv+OfHT/kHtx/2J9Uf9r + kFr/bJFg/2yTa/+Bl3f/qJ2D/6F2X/+leF//pndf/9HOzv/Pz8//zMzM/8rKyv+1pZ7/l2lR/8LBwv+/ + v8D/urq7/7a1t/+po4z/gZ+C/2madf9pmmj/Z5lj/1+GWf94aGL/dmpl/3hsaf96cXD/gHl5/4uGhf+W + kZL/oJ6d/3CW2P8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//9Ld8H/eXR1/4B6ef+Cenn/hn16/4t+ev+O + fnj/kX92/5R/df+DbF//Z4BS/26QWv9uj2H/b5Fs/42Wd/+wnIP/q31l/65/Zv/a19f/2NfX/9TT0//P + z8//uaqi/5psVP/Ew8X/wMDB/7y8vf/c8/H/teff/2uYc/9ql2n/apZg/2SJWf9ndFf/eWli/3hqZf93 + a2n/eXBv/353dv+HgoL/k46P/56cm/9lkdz/Ln3//y59//8uff//Ln3//y59//8uff//Ln7//wAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//QXvZ/3t3d/+B + e3r/hX17/4h+fP+MgHz/j4F8/5OBev+Xg3n/nIV4/2N0S/9sh1L/b4xY/2+NYf9zj2v/mZd6/7achP+1 + hm7/4d/e/+Lh4f/c2tv/19XW/76up/+dcFf/xsXG/8LBw//l9vX/xe7p/5ng0v9slGr/a5Rj/2iPWf9f + e1L/fWpi/3trZP94bGb/dmtp/3hwbf98d3X/hoB//5KOjP+cmpn/R4fv/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8u + ff//Ln3//y98/P99eHj/g318/4Z/fv+JgH7/joN//5KEfv+VhH7/m4d8/6GJfP+kiHr/ZnlL/2+IUv9w + iln/cIxi/3uQbv+jmX7/vJ2F/+nm5v/p6Oj/5ePj/93c3P/FtK3/onVc/8jHx//r9/f/1PHw/6fk2/+Q + 2sb/bJJi/2uSW/9kf1P/gGtg/39sZP97bGX/eGxn/3Ztaf94cG3/e3V0/4R/f/+QjY3/m5mY/y9///8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//LH39twAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//Ln3//y59//8uff//fnl5/4J9fP+HgH7/ioJ//5CEgf+UhoH/mIiB/56LgP+l + j4P/rpOF/4drW/9qfk3/cIpT/2+KW/9wjWX/g5Jx/6ibgf/q9fP/7+7u/+vr6v/k4+P/ybmx/6Z5Yf/r + 9/b/2vPy/7Do4P+S3Mv/jtS5/22RW/9nhlT/b3FW/4NuZP9+bGX/e21n/3ltaf93bmr/d29t/3t0dP+D + f37/kI2M/5uYmv8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//356e/+Dfn3/h4CA/4yDgf+Q + hoL/lYiE/5uMhP+hj4b/q5SJ/7Oajf++oJL/anFL/22DTv9wilT/cIpd/3COZ/+KlXb/1u/t//v5+v/v + 7u7/6ejo/8y9tv/QpIz/6fb0/7bp4v+W39H/kNa+/4zPrf9ri1b/YXtO/4lyZ/+EcGf/f29o/3xuaf95 + bmr/d25r/3dwb/97dXX/gn9+/4+MjP+bmZj/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//JnL/FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn39/i59//8uff//Ln3//y59//99 + eXr/g39+/4iBgP+MhIL/kYeE/5aLh/+cjof/pJSL/66Yjv+3n5P/w6ib/8+yo/9nd0r/b4lR/3CKV/9w + jGD/cY9r//j29v/6+vr/8vn5/+jv7//f2tP/0qiS//n5+f+X39H/kdjC/43Rsf9sj1r/ZX5Q/5B3bP+K + dWv/hXJr/4Bwav99b2v/em9r/3hvbf94cW//enR0/4N/f/+QjI3/nJuZ/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt8/iku + ff//Ln3//y59//8uff//XHqv/4SAgP+HgYH/jIWE/5GJhf+XjYn/nZGK/6aWjv+wnJP/uqSZ/8euof/T + uar/v6KS/2l9Tf9uilP/b4xZ/2+OYf/v9fP/6/f2/+H19P/R8u3/2+/t/8Sol//u9/b/j9jC/47Ss/+H + xZ3/Z4NS/5J5bf+Od23/i3dv/4Z1bv+Bc23/fXFt/3twbv94cG7/eHFw/3t2dv+EgID/ko6P/zR/+P8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//+FgYH/iIOD/4uFg/+RiYf/mI6L/56Tjf+m + mJD/sJ+W/7qmnP/HsKX/07ut/+DHuP+Pc2P/aoBP/26MVv9wjl//3PDu/9jz8v/E7en/ruff/8Hs6P/X + 8vH/2/Px/73m1/9zn2//Z4VU/4FzYP+RenD/jnlw/4x6cv+HeHH/gnVw/31yb/96cW//eHFv/3dxcP97 + d3f/h4OF/5WSk/8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+/egA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//hICB/4eDg/+L + hYT/kYqI/5eOjP+dk47/ppmT/6+gmP+5p57/xbGn/9G6r//exrn/5cu9/35sWf9pg1H/s7Kd/8br5v+0 + 6eL/n+LW/4zczP+a4dX/r+fg/6W1o/+vtKD/aIlW/2t3VP+TfXH/kXxz/458dP+MfHX/h3p0/4F2cv99 + dHH/enJx/3lycP95c3T/fXl5/4iFhv+KkaL/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwef4VLn3//y59//8u + ff//Ln3//y59//+Hg4T/ioaF/4+JiP+VjYz/nJSP/6SZlf+un5n/t6eg/8Gvpv/Nuq7/1sK2/+LLvv/m + zcD/b3NT/5Ovl/+d4NX/jd3O/3/Nt/9pm3P/Z597/26khv9+q5H/jbKa/2F8Uf+XgXb/lH92/5F+d/+P + f3j/jH54/4d8dv+CeHX/fXRz/3tzc/94cnH/eXR1/398fP+Nion/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yt9/kEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//Ln3//y59//8uff//g4GH/4qGhv+OiYj/k4yM/5qTj/+imZT/qp+Z/7Sln/+8 + rKT/xbSs/868sv/Ww7j/3Me7/32xmP9tqoz/ZaWD/2ahe/9nnXH/aZts/2adc/9ko33/ZKiH/2qsjv92 + spf/loN6/5SCev+QgXv/joB7/4yAfP+HfHn/gXh2/312dP96dHT/eHNz/3t2d/+Bf3//goyg/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsfP9QLn3//y59//8uff//Ln3//y59//+IhYX/jYiJ/5CLiv+W + kI//npeT/6admP+vop3/tqii/7+uqP/Gta3/zbux/2exlP9hrY3/YqiD/2Skev9loXT/Zp5t/2ecaP9l + n23/ZaJ0/2Omfv9hq4X/X66L/2Czlv+UhH//kIN+/4+Dfv+LgX7/hn17/4F5eP99d3X/eXR0/3p1dv98 + eXn/iIWH/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//xxx/gkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//Ln7//4uHh/+Piov/lI2N/5uTkv+hmZX/qKCb/7Cln/+2qaP/u66n/1yxkP9fror/YaqC/2Gnev9j + o3T/ZKFu/2WfaP9kmmP/ZKBo/2Sibv9ipXb/YKl9/1+rgv9fsIj/XbST/5CFgP+OhIH/i4KA/4R9e/9/ + eXj/fHh3/3p1dv96dnf/gH1+/y9+/f8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AP8BLn3//y59//8uff//Ln3//y59//8/f+f/jYmI/5GMjP+WkI//m5WS/6ObmP+qoZz/r6Sg/1yxhv9d + r4X/X61//2Cqev9hp3T/Y6Vv/2Kgaf9glGT/XIld/1+SYv9hoWn/YqZw/2Godf9eqnr/YK5//12xhv9b + son/kYmF/4mCgP+EfXv/f3l5/3x3eP95dXf/fHp7/2eCsf8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAACx8/esuff//Ln3//y59//8uff//Ln3//1WBzf+Piov/k46O/5aRkP+b + lpP/lJeQ/1yufv9csID/Xq58/1+sd/9gqHL/X6Rt/1+fav9bkGP/WYdd/8e6tP9cg17/XJBj/16eaP9f + pm//YKty/16sdv9dr33/XLGB/1yxgP9/k4P/gXt8/315eP96dnj/end5/3p/jP8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + fv3+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8u + ff//SIHd/4+MjP+Tjo3/VZlv/1mjdP9bq3f/Xa53/12pdP9dpG//XJxr/1mTZv9WjWL/mpGL/6Wblv+i + mJP/n5WQ/4p/fP9UjGL/WZJn/1qaav9bo27/XKp0/1uueP9arXj/WKR3/1Sccf97eXn/end5/2x8mv8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//Ln3//y59//8uff7/TH9f/1GPZ/9VmGz/V59t/1iebv9Wlmr/VJBm/1KLYv+J + h4D/o5uX/6Galf+gmZT/nZaS/5uUkP+ako//l5CO/396dv9Ri2L/U5Bk/1WUav9Xn27/VqBv/1WYbf9R + kmn/S4Fg/zF85v8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//Ln3//y59//9MgWD/UIpk/1GNZf9R + i2T/UoZi/5WQjv+blpT/nJeU/5yXk/+blpL/m5WR/5uUkf+YkpD/lpCP/5WOjv+TjYz/kYyL/4WAf/9W + hWT/UItk/1COZv9Oimb/TIFh/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y5+//+Oi4z/ko+O/5SQkf+WkZL/l5OS/5eTk/+XkpL/l5KS/5eRkv+WkJH/lI+P/5SPjv+S + jY3/kY2N/4+Li/+MiIj/h4OF/4KAgP98eXr/L339/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y58/f4uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//96iKb/kY6O/5OPj/+Tj4//lJCQ/5SPj/+U + j4//ko6O/5OOj/+Sjo3/j4yN/46KjP+Kh4f/hYKD/3h+iv8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC5+//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln7//1eDz/+Aip//kI2N/5CNjv+Pi43/hYiT/2GCvP8wffv/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufv//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALXn+Qy59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALHz93y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//LX/9ygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH79py59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//LH39wwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1//b4u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC16/jgsfP2DLn39uy58/eEtfP34LXz9/i59//8u + fv//Ln7//y5+//8uff//LXv9/Sx8/fwue/35LXv99yx9/fQtfP3xLH399Cx9/foufv//L3///y5+//8u + ff//Ln3//y59//8uff//Ln3//y5+//8vf///Ln39zSh4/iYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + 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 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////////////////////// + /////////////////////////////////////////////AB////////AAAf//////wAAAf/////8AAAA + f/////gAAAA/////4AAAAA/////AAAAAB////4AAAAAD////AAAAAAH///4AAAAAAP///gAAAAAA///8 + AAAAAAB///gAAAAAAD//+AAAAAAAP//wAAAAAAAf//AAAAAAAB//4AAAAAAAD//gAAAAAAAP/+AAAAAA + AA//wAAAAAAAB//AAAAAAAAH/8AAAAAAAAP/wAAAAAAAA//AAAAAAAAD/8AAAAAAAAH/wAAAAAAAAf/A + AAAAAAAA/8AAAAAAAAD/wAAAAAAAAH/AAAAAAAAAf8AAAAAAAAB/wAAAAAAAAD/gAAAAAAAAP+AAAAAA + AAAf4AAAAAAAAB/wAAAAAAAAH/AAAAAAAAAP+AAAAAAAAA/4AAAAAAAAB/wAAAAAAAAH/AAAAAAAAAP+ + AAAAAAAAA/8AAAAAAAAD/4AAAAAAAAP/wAAAAAAAA//gAAAAAAAD//AAAAAAAAP//AAAAAAAB//+AAAA + AAAH//+AAAAAAA////AAAAAAP////8AAAAH///////////////////////////////////////////// + ////////////////////KAAAAEAAAACAAAAAAQAIAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8p + e///c2tr/0paEP9KKRD/jISE/5ylpf+cjKX/e1oQ/3sQY/9apWv/GWu9/97vrf+c763/7xlr/xkpvf/v + GSn/GWuU/8UZa/8ZKZT/xRkp/5wZEP/ezmv/zlrv/1rOa//OlGv/3s4p/85arf9azin/WqUQ/5zOa//O + Ge//Gc5r/5zOKf/OGa3/Gc4p/xmlEP97GTH/GUq9/97vjP+c74z/7xlK/xkIvf/vGQj/GUqU/8UZSv8Z + CJT/xRkI/97OSv/OWs7/Ws5K/86USv/ezgj/zlqM/1rOCP9ahBD/nM5K/84Zzv8Zzkr/nM4I/84ZjP8Z + zgj/GYQQ/97Ozv9zWlL/3u/v/1Jrvf8Qa+b/nMWt/2Nr5v/exa3/Wozv/1prlP86a+b/lIRS/ykQ5v8I + EOb/CFoQ/wgpEP9KEOb/lJyM/5zOzv9ajK3/WozO/+9aa//vnK3/Wim9/+9aKf8ZKWv/xVpr/1oplP/F + Win/GSlC/5xaEP+cEGP/nKVS/xClY/9aSr3/e1ox/3sxY/9aSpT/71pK/++cjP9aCL3/71oI/xkIa//F + Wkr/WgiU/8VaCP8ZCEL/EIRj/xlKa/8ZSkL/nK3O/1qMjP8ZjO//Y4Rr/1rOrf+UWmv/xZyt/5zvzv+c + 7+//3u/O/5RrjP+cre//3q3O/5zFjP/e72v/71rv/1rva/9a7+//75Rr/5Rr7/9a763/3u8p/+9arf9a + 7yn/WqUx/96lKf/ere//Wq2t/1qt7/+Ua63/nO9r/+8Z7/8Z72v/nO8p/+8Zrf8Z7yn/GaUx/5wZMf8Z + ra3/Ga3v/xnvrf+UKa3/Ge/v/5Qp7/+cpSn/Wq3O/xmtzv9a74z/Wu/O/5Rrzv/epQj/Ga2M/xnvjP+U + KYz/Ge/O/5Qpzv+cpQj/3s7v/97FjP+cjM7/nM7v/5RKjP+cjO//3ozO/97vSv/vWs7/Wu9K/1rO7//v + lEr/lErv/97vCP/vWoz/Wu8I/1qEMf/ehCn/3ozv/5RKrf+c70r/7xnO/xnvSv+c7wj/7xmM/xnvCP8Z + hDH/GYyt/xnOrf+UCK3/Gc7v/5QI7/+chCn/GYzO/1rOjP9azs7/lErO/96ECP8ZjIz/Gc6M/5QIjP8Z + zs7/lAjO/5yECP/FnIz/Silr/ylC5v9KKUL/Sghr/whC5v9KCEL/Skpr/0pKQv9KQub/lJxz/4R7c/9S + hFL/Y6VS/5xaMf+cMWP/MaVj/zGEY/9KCBD/KVoQ/ykpEP9rEOb/GQgQ/xlra/8Za0L/lFpS/3spEP97 + CBD/Smtj/2utjP9rhFL/SmtC/3NrWv9rQub/pZyM/5yEc/9KrYz/EGv//wAIGf8pY///AAgA/wAAAP8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+7P7+/v7+AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v7+/gEBAQEBAQH+/gAA/gAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7+AQEBAQEBAQFHAQEBAQFHAQH+ + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQFHAQEBAQEBAUcB + AQEBAUcB/v7+/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOz+/gFHAQFHAQEBAQEBAQEB + AQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+AQEBAQEBAQEBAQEB + RwEBAQEBAQEBAUcBAQFHAQH+/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v7+AQEBAQEBAQEB + AQEBAQFHjQFHAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBRwEB + AQEBAUesBgZ3Bnd3RkR9cY0BAQEBAQEBAQFHAf4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v4BAQEB + AQEBAQFHrAb4BgcG+AcGBgZ3RHdGcXFHAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + AQFHAQEBAUdSB1AFBQUFBQUF+AX4B/gGd0RGP3FHAQEBAQEBRwH+/gAAAAAAAAAAAAAAAAAAAAAAAAAA + AABHAQEBAQEBAVMHBQUFBQUF4QXhBQUFBQUFB/gGBndGUXxHAQEBAQEBAQAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAQEBAQEBAQcFBQXh4eHh4eHh4eHh4eEFBQX4B/gGd0R9cQEBAQEBAQEB/gAAAAAAAAAAAAAA + AAAAAAAAAOz+AQEBAQEBSVIF4eHhAuECAgICAgIC4QLh4eHhBfkFBwZ3REZxRwEBAUcBAQAAAAAAAAAA + AAAAAAAAAAAAAAAAAQEBRwEBSQUFAuECAgICAgJAdvZ29gICAnbh4eEFBQX4+AZ3P1FHAQEBAQEB/gAA + AAAAAAAAAAAAAAAAAAD+AQEBAQEBAUgFAgICAvYCQAL2Avb29vbv9gL2AgIC4eEFBQX4BndEBgEBAQFH + AQAAAAAAAAAAAAAAAAAAAAAAAAEBRwEBAUjyAgICAvYCAkACQPZA9vZA9vb27wL2duHh4eEFB/gHd3RI + AQEBAQEB/gAAAAAAAAAAAAAAAAAAAAEBAQEBAVN09XT2AgJAAvYCQPb270D270D2QPZA9vb2duHh4QVQ + +AbyBY0BAQEBAQAAAAAAAAAAAAAAAAAAAAABAQEBAQFIAvJ0AgL2Avb27/bv9kBA9kBAQO9AQO/29gIC + 4eH5BVB051BRAQEBAUcB/gAAAAAAAAAAAAAAAAD+RwEBAQFTAgLidHQCdvbh9vb29u/273b5Bfnh4fZA + 9u/29gIC4QUFdOJQd3wBAQEBAQAAAAAAAAAAAAAAAAAAAQEBAQEB4QIC8uIKAgL29u/27/bvQPkGBgYF + +Af4BXZA9kB29uHhcgryBndRAQEBAQEB7AAAAAAAAAAAAAAAAAEBAQEBSQICAnR0CgrhduEFB/gG+PkG + d0R3BfkGBgZQB+ECAgLhdAridPgGd0cBAUcBAQAAAAAAAAAAAAAAAAABAQEBR1ICAgICdHQKUFAGBvj4 + BncF+HdEd1BA7/lQBvgHUAXhdPoKdOEHBgZxAQEBAQEB/gAAAAAAAAAAAAD+RwEBAQFIAgICAvR083VE + Bgf57+/5+fhxRnf4+eHv7/YFUFAFUEQKCuIFUPh3UQEBAQEBAQAAAAAAAAAAAAAAAQEBAQEBAgLh4eEC + 4nTzUUQGd0T470oGRlFE+Ph3RFD5QO/hBnV18+ICBQVQBndzAQFHAQH+AAAAAAAAAAAA7AEBAQEBSQIC + AuHh4XTjdPNERHdEcUb5Bnc/ffj4P3cGdwYHUFFE8wp0AuEFUAZ3RwEBAQEBAQAAAAAAAAAAAAABAQFH + AVMCAgUC4eF29HQK8+D5d0Y/+Xc/cUT473b5+PgF+UTzCgp09uHhBQUHBkcBAQEBRwH+AAAAAAAAAAD+ + AQEBAQFJAgLh4eHh4fT043Tz4O/5+NYGPz8/+Ep2+Pj59lDg8wp09AICAgUF+AZxAQEBAQEBAQAAAAAA + AAAAAAEBAQEBUuHhBeEFBfnh9vQK4eD4+UpqRD8/UdbvBj9EdwbgCgp09OH24QLhBQcHUwEBAQEBAUf+ + AAAAAAAAAABHAQEBAUIC4eHh4eEF+eH09Ap04Pn5+UZ6Pz/WSndEfXpR4HTjdPb2AgLhAgVQBlMBAUcB + AQEBAAAAAAAAAAAAAQEBAQFTAgXhBQUF+fn59vT09ODg1hlGqj8/d0p3P0F5UeMK9PT29gICAuEFBQZT + AQEBAQEBAQH+/gAAAAAAAAEBAQEBUwIF4QUF+QX5+fn09HTj4eDWP0FBP9b5RkFBeFF09PT2dgICAuEC + BVBQR0cBAQFHAQEBAAAAAAAAAAABAQFHAUnhBeEFBfkF+PnWSvT09ODg+D9BQUFG+T9BeVFECvT24fYC + AuEC4QUFB0cBAQEBAQEBAQHsAAAAAAAA/gEBAQEB4eEFBQUF+fj4Btb29PT0dOB6QUFBRtY/eHhRfvT0 + 7+EC4QICAgIF+AYBAQEBAQEBRwEBAAAAAAAAAAABAQEBAQUFBQUF+Pj4+NbW1vT09HThekFBQT/WQXhR + RAr0SuHhdgLhAgLhBQVTAQEBRwEBAQEBAQH+AAAAAADsAQEBAQFCBQUFBQUF+NYG1kb49PTjdKpBQUE/ + RkFRDfP04Xbh4QLhAuEC4eEHUwEBAQEBAQEBAQEBAAAAAAAAAAEBAUcBRwUFBQUH+Ph3d3dGRuD09OB6 + QUF5QUFBeOD04eH54eHh4QLhSOEFUAFHAQEBAUcBAQFHAf7+AAAAAAD+AQEBAQFIBQUFBfgG+H53Rj9G + 4fRQenl4UXhRUX704fnh+eHh4QLhAgLhUFMBAQEBAQEBAQEBAQEBAAAAAAAAAAEBAQEBRwUFUPj4+Ph3 + RndGP0Z0BkRR8/NQ81AGdPn5+eEF4eEC4QLh4QVJAQEBRwEBAQFHAQEBAez+AAAAAAABAUcBAQFSBQUF + B/gG1gZGd0ZGUPPz8woKdArz8/MFBfkF4QUFAuHh4QVTRwEBAQEBAQEBAQEBAQEBAAAAAAAAAAEBAQEB + AQUFUAf4+AZ3RkRG8/PzCnQK4Arz8/Pz8wUFBQXh4eEC4UgFAQEBAQEBAUcBAQEBAUcBAez+AAAAAAAB + AQFHAQFHBQVQB/gG+HcG8/PzCvMK4wp0CgrzCszzBQUF4UgFAuHhRwEBAUcBAQEBAUcBAQEBAQEBAAAA + AAAAAAEBAQEBAVMF+AX4+AYG8wrzCvMKCnR04woKCvPz+vPg4QXhAuF7UgFHAQEBAQEBAQEBAQEBAQEB + Af4AAAAAAAD+AQEBAQEBUwVQB1BQ8/P68woKCgp0UHR0CgoKCvP683IF4eHhUgEBAQEBAQEBRwEBAQFH + AQEBAQEAAAAAAAAAAAEBAUcBAQFTBQUKcgoKCgoK4goF+Pj44XQKCgoK+gpyCgLhUgEBAQEBAQEBAQEB + AQEBAQEBAUcBAQAAAAAAAAAAAQEBAQEBAUfnCgoKCgoKdAUH+Af4B1BQ4XTnCgoKCuJ0UwEBAUcBAUcB + AUcBAQFHAQEBAQEBAQEAAAAAAAAAAAABAQEBRwEBSXJ053R0BVD4B/j4BfgFBwUFBXR04gpycwEBAQEB + AQEBAQEBAQEBAQEBAUcBAQFH/gAAAAAAAAAAAAEBAQEBAQEBU1IFB1AHUFAHUAdQUFAHBQUFBUhTAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAAAAQEBAUcBAQEBR1IHUAUHUAVQBQcFBQUFUkcB + AUcBAUcBAUcBAUcBAUcBAUcBAUcBAQEBAQEAAAAAAAAAAAAAAAABAQEBAQEBAQEBAUdTU1KsUgdSU1NH + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQFHAQEAAAAAAAAAAAAAAAAAAAEBAQEBRwEBRwEBAQEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEBAUcB + AUcBAUcBAUcBAUcBAUcBAUcBAUcBAUcBAUcBAUcBAUcBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//////////////////////////////////////////////////////////// + ///////8AH///////8AAB///////AAAB//////wAAAB/////+AAAAD/////gAAAAD////8AAAAAH//// + gAAAAAP///8AAAAAAf///gAAAAAA///+AAAAAAD///wAAAAAAH//+AAAAAAAP//4AAAAAAA///AAAAAA + AB//8AAAAAAAH//gAAAAAAAP/+AAAAAAAA//4AAAAAAAD//AAAAAAAAH/8AAAAAAAAf/wAAAAAAAA//A + AAAAAAAD/8AAAAAAAAP/wAAAAAAAAf/AAAAAAAAB/8AAAAAAAAD/wAAAAAAAAP/AAAAAAAAAf8AAAAAA + AAB/wAAAAAAAAH/AAAAAAAAAP+AAAAAAAAA/4AAAAAAAAB/gAAAAAAAAH/AAAAAAAAAf8AAAAAAAAA/4 + AAAAAAAAD/gAAAAAAAAH/AAAAAAAAAf8AAAAAAAAA/4AAAAAAAAD/wAAAAAAAAP/gAAAAAAAA//AAAAA + AAAD/+AAAAAAAAP/8AAAAAAAA//8AAAAAAAH//4AAAAAAAf//4AAAAAAD///8AAAAAA/////wAAAAf// + //////////////////////////////////////////////////////////////8oAAAAMAAAAGAAAAAB + ACAAAAAAAABIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALHz+Vi59/bsuff3dLoD9yy17/nwAAP8BAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuf///Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//InP+FgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8sf/3eAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yR//g4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8u + ff//Ln3//zF+/P+2sLD/s66t/7Svrf+3sbD/ubSy/765uP/FwcD/UY7x/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff3+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACN4/iQuff//Ln3//y59//8u + ff//Ln3//y59//+ioJ7/nJmX/5qWlP+alZT/mpaT/5uWlP+empj/oJya/6ejof+uqqj/trCv/764uP/J + xcT/MID+/y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXv+Pi59//8u + ff//Ln3//y59//8uff//mZaV/5KNjf+OiYr/jYeH/4yGhf+LhoP/jIWD/42GhP+PiIf/kYqI/5WPjf+a + k5H/n5qX/6qlov+0rqz/vLe2/8vHxv8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + f/8CLn3//y59//8uff//Ln3//y59//+OiYn/iYWF/4V/f/+Benr/gHh3/392dP9+dXL/gHZz/4F3df+C + eXb/hXx5/4mAfv+OhYL/kYqI/5iQkP+gm5j/rKak/7eysP/Ev77/e6To/y59//8uff//Ln3//y59//8t + fP37AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//4iFhf+Be3v/fHd1/3lxb/94b2z/dmxp/3dsaP93 + a2f/eGtn/3ptaP97bmn/fXBs/39zb/+DeHX/iH16/42Dgf+Tioj/mpOR/6Wfnv+zrqv/v7u5/87Mz/8u + ff//Ln3//y59//8uff//AH//CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uffz/gn9+/3p0dP91b23/dGtp/3JoZf9z + Z2P/cmVh/3RlX/90ZV7/dWVd/3ZlXv92Zl//eGdh/3lqY/98bWf/f3Js/4N3dP+Ifnv/j4aE/5WOjf+g + m5j/saup/765uP/JytD/Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2L+DS59//8uff//Ln3//y59//9AX0z/eHJz/3Jrav9w + aGX/cWdj/3JlYf9zZV//dGRd/3VkW/91Yln/dmFY/3ZhV/93Ylj/d2JY/3hkWv95Zl7/eWli/31taP+A + c27/hnt3/42Egf+VjYz/npmW/7Grqf+Hlor/N4L3/y59//8uff//Ln3//y59/fIAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//397fP9H + cFX/c2tp/3BoZf9xZ2P/dGdh/3ZmYP93ZV3/eGRb/3liWP96Ylb/emFV/3pgU/96X1P/eWBT/3lgVf95 + Ylj/eGNa/3pnX/97a2T/f3Js/4V6dv+NhIH/lI2M/6Gcmv9Jd1r/pKKg/y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZv8FLn3//y59//8u + ff//Ln7+/3Nvb/9Jc1X/VY9p/3NoZf92aGT/eGhi/3pnX/97Zlz/fGRZ/31jVf9+YVP/fmBS/35fUP98 + XVD/fF5S/3xeUP97X1L/emFV/3liWP95Zl7/empj/35wa/+DeXX/jYSB/4WRhf9Mf17/srCu/8vIx/8u + ff//Ln3//y59//8se/3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//dnFx/3Bqaf9McVb/V5Bm/2qIcf94amT/fmti/4BpYP+CaFz/gmVY/4RkVf+E + YlL/o6Kj/6enqP+lpaf/f11S/6Ggov+dnJ//fmNb/3tgU/96Y1j/eGVd/3lqY/99cWz/hXp3/1mbcP9P + fVz/qaWj/724t/8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//8uff//cGtr/3Fqaf91bGr/Vopf/2Cgdf9+bGT/gmtj/5iTk/+k + o6X/qKep/6yrrf+rqKn/r6+w/6+vsP+urq//hV5S/6moqf+kpKX/n56g/5mZm/+TkpX/eGBa/3lnYP97 + bGb/Xqt//1iXbP9MeVn/nZmW/7KtrP9smub/Ln3//y59//8uff//AAD/AgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//9ocYj/cGtq/3RtbP96cG7/U31Y/2Caa/92 + zK3/nJ6f/6Skpf+JaFr/imVW/7Ctrv+zsbH/t7e3/7e3uP+2trj/iV9S/4hfSv+FX0v/hGRW/6Cfof+Z + mJr/kpKU/42Mj/9uv6T/X6R2/1aMYv+EfXz/lpCQ/6ekof++ubn/Ln3//y59//8uff//Ln3//wAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt7/mMuff//Ln3//y59//9xbW3/dG1u/3pycP9/ + dHH/eG9n/2CRYv96yKT/f9W//6qpq/+xsbL/qJ2a/5BnUv+RZk//vLy9/729vv+8vL3/jWFS/7i3uf+z + s7T/hmFR/4NgTv+AYVL/joaE/4yYlv9zyaj/YJ9v/1F+Wv+FfXv/kIqJ/56bmf+zr63/Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC19/f4uff//Ln3//y59//9w + bGz/d3Bv/311c/+DeHX/hndx/1yCV/9om2f/Z51y/5/azf+2trf/u7u8/8C/wP++u7v/wsLD/8HAwv/A + v8D/kGJT/7y7vf+5uLn/srK0/6qqq/+ioaP/m5qc/3rUvv9mqnz/XpFi/3pvav+BeHb/i4WD/5mVk/+s + qaf/Ln3//y59//8uff//Ln3//y58/fcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8u + ff//Ln3//y59//90b3D/e3V0/4J5d/+EeXX/iHl0/39uZf9okV3/apdn/2uZdv+goIb/l2xa/8XDw//F + wsH/x8fI/8bFx//Ew8T/k2ZX/5NlTf+QZE3/jmRP/4liUf+FYlH/d6SH/2afdP9knGb/WYFZ/3drZ/98 + c3H/hn9//5WQkP+koaD/Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//Ln3//y59//91cXH/f3h3/4N7ef+IfHj/i3x2/497c/9he1D/bJJb/2ySZf99 + l3b/rpyD/6J2Xv+ld17/0NDQ/83Mzf/Jycn/l2pb/5RlUP+/vsD/urq7/6mgnv+OoYb/aZt0/2iaZv9i + jFz/eGhi/3drZ/96cG7/gXp6/5CLjP+enJr/L379/y59//8uff//Ln3//y59//8aeP4TAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//95dHX/gXp6/4R8ev+Kfnr/jn53/5N/dv+T + e3D/aIBR/22OW/9ukGf/j5Z3/7eZgP+uf2f/3Nrb/9fW1v/Q0ND/nHBf/5dpU//BwcL/vLu8/8ju6f9r + l3P/apdn/2iQXP9fd1P/eWlj/3drZ/95b23/fnd3/42IiP+bmZf/Ln3+/y59//8uff//Ln3//y59//8u + ff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5+//8uff//Ln3//y59//97dnf/g3x8/4d+ff+M + gXz/kYJ8/5aEfP+dhnr/bW1Q/2yHUv9wi1v/cI5p/52Ye//AnoX/5+fn/+Pi4v/a2Nn/pHdm/5ttV//C + wsP/2PPx/5/i1f9sk2f/a5Jc/2B+Uf9+amP/emtl/3drZ/94b23/fHd1/4qFhf+al5b/Ln3//y59//8u + ff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/cEuff//Ln3//y59//98 + eHj/g319/4mBf/+PhIH/lIaB/5uIgP+jjoL/r5OF/2V3Sf9wilP/cIpc/3iOa/+pm4D/8fj4/+zs6//k + 4+P/q35u/6F0X//f9fP/rufd/5Daxf9tkV3/ZoRV/4VuZP9/bWb/e21n/3dtaf93b2z/e3V1/4iFhf+a + lpf/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//99eXr/hX9+/4qCgf+QhoP/lomE/56Ohv+plIr/tZuP/8Kjlf9rfUz/cIpV/3CMYP9+ + knH/8/f2//v5+v/q6er/w5eI/9Cjj/+36uP/kdzL/4/Stv9rjlb/dnBY/4ZyaP+Ab2j/fG5p/3hua/94 + cG7/e3Z1/4mFhf+alpf/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//9Uebb+hIB//4qDgf+Ph4X/mIyI/6CSiv+tmZD/uqKX/8qwof+K + bFz/bYVP/3CLWP9vjmT/+Pn5/+/49//d9PP/wKiY/9CvoP+R3Mv/j9S3/32yhv9jfFD/jXZr/4h1bf+B + cmz/fHBs/3lvbf93cW//fHd2/4qHh/+bmpj/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx9/n4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//hICA/4mDgv+QiYX/mI6M/6GUjv+v + nZX/vKac/821qf/fxbb/bXFM/22JUv9ujlv/4fTy/9nz8f+36eP/ze/t/93z8v/e8/D/eq6A/2WAUf+R + eW7/jnpx/4p5cv+CdXD/fXJv/3lxb/94cnH/fHh4/4yJif8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArfP27Ln3//y59//8uff//g4CA/4mEhf+P + iYj/mI+M/6GWkP+unpf/uqif/8u2q//bxLf/5cu9/2R6Tf+psJj/vuvm/6Lj2f+K28r/l9/T/5eyoP+m + s5//ZoRU/5+IfP+RfXP/j3x1/4l7dv+Cd3P/fXRy/3pycf94c3P/fnp7/5CNj/8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8u + ff//Ln3//4iEhf+OiIj/lY6N/5+Wkv+qn5n/tqef/8Oxqf/RvbP/3si8/+PMv/+BrZT/fsez/2aee/9o + mm//Z595/2alhv94rZP/q5eK/5WAeP+QgHn/joB6/4p+ef+CeHb/fXZ0/3lzc/95dHX/gX9//zV/9v8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXv9/S59//8uff//Ln3//36BkP+Mh4f/ko2K/5uTkP+lm5f/sKSe/7urpP/Gta3/z7yz/2evkv9i + qYX/ZKR6/2Wgcf9mnGj/ZZ9v/2Skef9gqob/X6+O/5aMg/+Rgn3/j4N//4h/fP+BeXj/fHd2/3p1dv96 + d3j/ioeI/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//+Khob/j4qL/5WOjv+fmZX/qKCc/7Onof+5 + rKb/XbKO/2CthP9hp3n/YqNz/2Sha/9jmWP/Y6Bn/2OkcP9iqHr/X6yC/1yxjP+JlYf/joSB/4iAfv+A + eXj/fHh3/3l0dv9+e3z/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACp7/mcuff//Ln3//y59//8uff//jIiI/5KNjf+Y + kpH/n5mV/6Wdmf9esIP/X6+A/1+reP9hp3D/YaRs/12SY/9ahVz/W4xg/2CfaP9gp3D/YKx2/16ufv9d + soT/Za2D/4Z/f/9+eXn/e3Z3/3t4ef8ufv//Ln3//y59//8uff//Ln3//y59//8uff//Lnv9/S59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8u + ff//Ln3//46Kiv+Tjo7/WJty/1mldf9drnr/Xqt1/12kb/9alWf/Vo5i/7itqP+jmZP/n5WQ/1iIX/9a + lGf/W59s/1uncf9br3n/Wq15/1iidf98eHn/end5/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yl5/j0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn3//y59//8uff//Ln3//y59//9Ke13/Uo9m/1aZbf9Xm27/VZJo/1GMYv+XkIz/o5uX/6CZlf+d + lpL/m5SQ/5iQjv+Si4r/UYli/1KQZf9Wmm3/Vp1v/1GRaP9Lg2D/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//Ln7//02HZP9wg3b/mJOS/5mTk/+a + lJP/mpST/5qUk/+YkpH/lpCQ/5SOjv+SjYz/j4qK/42JiP95eHf/TYdk/0KBjv8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8u + fv//kY6O/5OPj/+UkJD/lJCR/5SPkP+Tjo//k46O/5CMjP+PjI3/i4eI/4SBgf9Ofcr/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y5//bwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//L339/0N/4/9hhMH/VYHO/zeA9P8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXb+Ky59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yJ3/w8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA////////AAD///////8AAP///////wAA////////AAD//+P///8AAP/8AB///wAA//AAA///AAD/ + wAAB//8AAP+AAAB//wAA/wAAAD//AAD+AAAAH/8AAPwAAAAP/wAA+AAAAA//AADwAAAAB/8AAPAAAAAD + /wAA4AAAAAP/AADgAAAAAf8AAMAAAAAB/wAAwAAAAAH/AADAAAAAAP8AAMAAAAAA/wAAgAAAAAB/AACA + AAAAAH8AAIAAAAAAfwAAgAAAAAA/AACAAAAAAD8AAIAAAAAAHwAAwAAAAAAfAADAAAAAAB8AAMAAAAAA + DwAAwAAAAAAPAADgAAAAAAcAAOAAAAAABwAA8AAAAAADAAD4AAAAAAMAAPgAAAAAAwAA/AAAAAABAAD+ + AAAAAAEAAP8AAAAAAQAA/4AAAAADAAD/4AAAAAMAAP/4AAAABwAA//8AAAAfAAD///////8AAP////// + /wAA////////AAD///////8AAP///////wAAKAAAADAAAABgAAAAAQAIAAAAAAAAEgAAAAAAAAAAAAAA + AAAAAAAAAAAAAP8pe///KRAQ/0Jj3v+cjKX/Y2Pm/1qla/97Wkr/75Rr/97vrf+c763/3s5r/85a7/9a + zmv/3s4p/85arf9azin/hBlr/xCUa/+czmv/zhnv/xnOa/+czin/zhmt/xnOKf8Za5T/zhlr/4QZKf8Z + KZT/zhkp/++USv/e74z/nO+M/97OSv/OWs7/Ws5K/97OCP/OWoz/Ws4I/4QZSv8QlEr/nM5K/84Zzv8Z + zkr/nM4I/84ZjP8Zzgj/GUqU/84ZSv+EGQj/GQiU/84ZCP9jhGv/nKWl/5R7c/9aEBD/Wq2M/1prjP/e + zs7/e2tr/5xaSv8IY97/nFpr/2OESv+chFL/Wozv/97v7/9ajM7/75yt/1Ipa/8pOub/GSlr/1IpQv8p + EOb/GSlC/85aa/+EWin/WimU/85aKf+cpVL/WkqU/++cjP9SCGv/CDrm/xkIa/9SCEL/CBDm/xkIQv/O + Wkr/hFoI/1oIlP/OWgj/Ukpr/1JKQv9aOtb/GUpr/1oQ1v8ZSkL/3sWt/5zFrf+crc7/WoyM/1qMrf+c + 787/nM7O/xmM7//e787/Ws6t/5zv7/+Ua4z/Wq2t/1qt7//FlGv/3q3O/xmMrf8ZjM7/3u9r/+9a7/9a + 72v/Wu/v/5Rr7/9a763/3u8p/+9arf9a7yn/WqUp/96lKf/ere//lGut/6UZa/8xlGv/nO9r/+8Z7/8Z + 72v/nO8p/+8Zrf8Z7yn/Ga2t/xmt7/+cre//Ge+t/5Qprf8Z7+//lCnv/xmlKf+cpSn/GWu1/+8Za/+l + GSn/GSm1/+8ZKf9arc7/Ga3O/1rvjP8ZrYz/Wu/O/5Rrzv9apQj/3qUI/xnvjP+UKYz/Ge/O/5Qpzv8Z + pQj/nKUI/97O7//exYz/nMWM/5yMzv+czu//lEqM/8WUSv/ejM7/3u9K/+9azv9a70r/Ws7v/5RK7//e + 7wj/71qM/1rvCP9ahCn/3oQp/96M7/+USq3/pRlK/zGUSv+c70r/7xnO/xnvSv+c7wj/7xmM/xnvCP+c + jO//Gc6t/5QIrf8Zzu//lAjv/xmEKf+chCn/GUq1/+8ZSv+lGQj/GQi1/+8ZCP9azoz/GYyM/1rOzv+U + Ss7/WoQI/96ECP8Zzoz/lAiM/xnOzv+UCM7/GYQI/5yECP/FnK3/QmMQ/whjEP9COhD/CDoQ/ylj3v/F + nIz/Umu1/1JrY/+UnHP/71pr/6VaKf9aKbX/71op/2OlSv9aSrX/71pK/6VaCP9aCLX/71oI/4yEhP9K + a0L/Wjr3/xlra/9aEPf/GWtC/5yljP9jYxD/KWMQ/2M6EP8pOhD/e1Jr/wgQGf+cjIz/EGP//wgQAP8p + Y///CAAA/wAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v7+/vwAAP4A + AAD+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7+/v4BAQEBAQFBAQFBAfz+/gAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAf7+/gAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAPz+QQEBAQFBAQFBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP4BAQEB + AUEBAQEBAQEBAQEBAQEBAUEBAQH+/gAAAAAAAAAAAAAAAAAAAAAA/v7+/gEBAQEBAQEBQUNkNWTZZGSL + QQEBAQEBQQEB/gAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBQWY18/P6NfM1NTVj2WRvAQEBAQEBAf78 + /gAAAAAAAAAAAAAAAAD+/vwBAQEBAQFm8+367frt7e3t+vrz2WNiZEEBAQEBAQEAAAAAAAAAAAAAAAAA + AAAA/gEBAQEBQe3t7e07Ozs7NDY27eL68/M12TpvAQEBQQEB/P4AAAAAAAAAAAAAAP78AQEBAQFD7e07 + Ozs7NDs7Ozs7Ozvt7e36NTViiwEBAQEB/gAAAAAAAAAAAAAAAAABAQEBAUPtOzs7OzvhOzsHOzs7Ozs7 + Nu3t8zU1YpcBAQEBAfz+AAAAAAAAAAAA/v4BAQEBAe47NAfhOwc7BzsHOwc7Owc7Ozs27frz2WVDAQEB + AQAAAAAAAAAAAAAAAAEBQQEBOeE0Ozs7Owc7BzsHOwcHBwc7Ozs77e368zTzAQEBAQH8AAAAAAAAAAAA + /gEBAQFDO+E0OzsHOzsHOwcHPDs7OwcHOwc7OzbtZeHziwEBAQEAAAAAAAAAAAAAAAEBAQFlO+E0NDs7 + Owc7PAf6NTU2Nfo2Bwc7OzvtNDQ12UEBAQEBAAAAAAAAAAAAQQEBAQM7OzQ/BjQ2+vo18zbfY9k2+jU1 + Ne02OzsGBjQ1NWQBAUEB/gAAAAAAAAAAAQEBAWY7Ozs0Bm41NTY2+vo1YmQ2QAc2+jX67TgGNDT6NWQB + AQEBAf7+AAAAAAD8AQEBATk0Ozs0NKdjNdnzNjw1Y2L62TXtPDvtNWsGNO36NdkBAQEBAQAAAAAAAAAA + AQEBATs7O+07NAY4NWNiZN/ZOmQ2NWPZNfM1a/MGOzvt8zVBAQEBAfz+/gAAAAD+AQEBATQ77Ts2O+c0 + Bvo22fM1OmL6PEA2Nu3zBgY/Ozvt+vNBAUEBAQEAAAAAAAAAAQEBQTvtO+02Nj804uLiQD5iOmjfNmJk + 3+0GBjQ7Ozvt7TVBAQEBAQH8/gAAAAD+AQEBATs0Nu02Njs/PzTi30A6OjrfNjpoQuLnND87Ozs77TVD + AQEBAQEBAAAAAAAAAQFBATbtNu027eJAPzTi4nA6Qjrf+jpCZwY0Pzs7OzTt7TVBAQEBQQEB/AAAAAD+ + AQEBATnt7e02+vr6QD80NN9qQqXf80JnaOLnOzs7Ozs07QRBAQEBAQEBAAAAAAAAAQEBAe3t7e36+vPf + +j8/4uI6QkJiYkJoY+c7Ozs7Ozs77TUBAQEBAQEBAfwAAAD8AQEBAeDt7e36+vPf2eI/PzRCQkJiOmdo + OD82NjY7Ozvt7WYBQQEBAUEBAf4AAAAAAQEBQQE27e3689nfYmI2P+JqQmxCQmfiPzY2Ozs7NDvt7UEB + AQEBAQEBAQH8/gAA/gEBAQFm7fr6+vPZY2JiO/NoZ2hoY2M/NjY27e07OzQ7BAEBAQEBAQEBAQEAAAAA + AAEBAQFB7e368zXf2WI6p/NrOOI4OPPz7e027Ts77TvtQQEBQQEBQQEBQQEB/gAAAP4BAQEBZu36+jXf + 2WLZ8zjiBgbiBjg47Tbt7TvtOzTtAQEBAQEBAQEBAQEBAAAAAAABAQEBQWb6+jU1NfM4OAYGBjQGBgY4 + OPPt7TY77TlBAQEBAQEBAQEBAQEB/P4AAAD8AQEBAQHt7fME8zg4OAYGBjQ0BjgGOAY47TntO0MBQQEB + AUEBAUEBAQEBAQAAAAAAAQEBAUEBBO3iBjgGBgY07fPtNAYGBjg4Bjs7QwEBAQEBAQEBAQEBAQFBAf4A + AAAA/gEBAQEBAc40BgYGNO018zX68+00NIIGBoJBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAABAQEBQQFD + ZTT6+vME+vr6+u367TQ04AEBQQEBQQEBQQEBQQEBQQEBAfwAAAAAAAD+AQEBAQEBAUNmBO36+vr67frt + 7UNBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAEBAQEBQQEBQUFDQ0NDQ0EBAQEBAQEBAQEBAQEB + AQEBAQEBAQEBAf4AAAAAAAAAAP4BAQEBAQEBAQFBAQFBAQFBAQFBAQFBAQFBAQFBAQFBAQFBAQEBAQAA + AAAAAAAAAAAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB/gAAAAAAAAAAAAAAAAAA + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////8AAP///////wAA////////AAD/ + //////8AAP//4////wAA//wAH///AAD/8AAD//8AAP/AAAH//wAA/4AAAH//AAD/AAAAP/8AAP4AAAAf + /wAA/AAAAA//AAD4AAAAD/8AAPAAAAAH/wAA8AAAAAP/AADgAAAAA/8AAOAAAAAB/wAAwAAAAAH/AADA + AAAAAf8AAMAAAAAA/wAAwAAAAAD/AACAAAAAAH8AAIAAAAAAfwAAgAAAAAB/AACAAAAAAD8AAIAAAAAA + PwAAgAAAAAAfAADAAAAAAB8AAMAAAAAAHwAAwAAAAAAPAADAAAAAAA8AAOAAAAAABwAA4AAAAAAHAADw + AAAAAAMAAPgAAAAAAwAA+AAAAAADAAD8AAAAAAEAAP4AAAAAAQAA/wAAAAABAAD/gAAAAAMAAP/gAAAA + AwAA//gAAAAHAAD//wAAAB8AAP///////wAA////////AAD///////8AAP///////wAA////////AAAo + AAAAIAAAAEAAAAABACAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff3hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKnH+Ei59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//Ln3//56qw/+8t7X/wr68/2OW6v8uff//Ln3//y59//8uff//Ln3//y58/ecAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8u + ff//nZqZ/5iTk/+WkJH/lpGQ/5qUk/+dmZb/p6Og/7Otq/+/urn/jKzi/y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8u + ff//kJGZ/4uGhv+HgID/gnx6/4J5eP+DeXj/hn16/4qCgP+PiIb/lo+O/6Kdmv+0rqz/xsHA/y59//8u + ff//Ln3//y5+//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8u + ff//Ln3//4uHh/+Aenr/eXFx/3Zsav91amf/dmll/3dpZP95a2b/e21p/4Bzb/+Ge3j/j4aE/5mSkP+r + pqT/v7u5/y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + fv2lLn3//y59//8+Wkn/eHJy/3JqaP9xZ2P/cmVg/3RkXf91Y1r/dmJa/3djWf94ZFv/eWZf/3xsZv+B + dHD/ioB9/5WOjf+no6D/wL27/y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//Ln3//0VvVP9xamj/cmhk/3VmYP94ZV3/emNZ/3thVv97YFP/e19S/3pfUv95 + YFX/eWNa/3poYf9+cWv/iH57/5WPjf9OgmH/xsHB/y59//8uff//LXz+TgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAfb/8QLn3//y59//90cHD/bGtm/1iVbf93aWT/fGlh/4BnXf+BZVj/gmJT/4dsYf+j + o6T/f1xO/5qXmf97X1P/emNY/3lnYP9+cW3/ioJ//1CHY/+yraz/Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//3Brav91bGv/W5Bl/2CqgP+bmpz/pKOl/6urrP+w + r7H/srK0/7Kxsv+GXkr/qKeo/6Cfof+Xlpn/gnZy/3loYv9do3f/UH1b/6Ccmv/AvLv/Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//9Jd8T/dG1t/3xzcP9Ve1b/d8ah/6Gmpv+t + rK7/j2hV/5BmUP+8u73/u7u8/4xgS/+rpaP/hV9N/39eUf+Tk5X/cs6x/1+aav+De3j/lpCQ/7Csq/8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//3Ftbf96c3L/gnd1/4d3cf9l + lGD/aZt0/7Kur/+/vr//wsLD/8TDxP/BwML/kWNM/7u6vP+ysbP/pqWn/5rg0/9koXP/WYZd/310cf+N + h4b/o6Cf/y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//c25v/394d/+G + e3f/i3x0/196Uf9rk2D/eJd1/51zXP+hdFv/zc3N/8nJyf+XaVH/v7/A/7i3uf+lpo//aJx0/2aYYv93 + aGP/enBt/4eAgP+bmJj/Ln3//y59//8uff//LHz95QAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//93 + cnP/gnt6/4l+e/+QgHn/l4F2/2qEUv9ujWD/k5d6/66AaP/e3d3/1tTV/51wV//DwsT/4fT0/26Wdf9q + lmH/XXpR/3hqZP93bmv/gXt6/5iUlP8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//3l0dv+EfXz/jIJ+/5SFgP+fin//lXpr/26JU/9vjGP/qpuA/+3t7f/l5OT/qHph/+v39/+r + 5t3/cpxz/2aDVP+AbGT/emxn/3dua/9/eXn/lZKS/y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//QXzb/4eBgP+OhYP/mYuF/6aUiv+7oJP/ZnVI/3CKVv9wjmn/+vn6/+3u7v/R + pY7/u+rl/5DXwP9sjlf/jHRq/4Jwaf98b2z/eHBu/395ev+Wk5T/Ln3//y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//hYCB/46Hhv+bj4r/rJqT/8Gqn//bwbL/aX5O/26NW//l + 9vT/zfDt/93z8f/n9PP/gryT/4x0Zv+NeW//g3Vw/3xxbv94cW//f3t8/5mWlv8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//+GgoP/joiI/5qRjv+pnZb/vaui/9S/s//l + zL7/bIhX/6nl3f+I2sj/dqiP/5ixm/9lelL/kn50/419dv+DeHT/fHRy/3hzcv+DgIH/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln7//wAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//+Lhob/lY+O/6Sblv+1 + pqD/xrWs/9PAtf9mq43/ZaN8/2eca/9moHT/YqqG/2qylv+Sg3z/jYF8/4N6ef97dXT/eXR1/42KjP8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//zJ/+P+P + i4v/m5WR/6mgnP+2qKP/Xq+H/2Gpe/9jo2//YpZh/2OgaP9hp3b/Xq2B/120jf+NhIH/gnt7/3p1dv99 + env/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8tff3FAAAAAAAAAAAAAAAAAAAAAC5+//8u + ff//Ln3//1KB0P+Tjo7/c5p//12wfP9eq3X/XqJs/1qQZP+rn5n/dXZr/1uYZ/9cqHH/Xq97/1iqef9/ + env/end5/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//Ln3//y59//9RjGX/VZVr/1KLYv+lnpv/n5mV/5yWkv+ZkZD/lY+M/2J/af9S + kGf/UpRq/02GY/8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//9chMf/k4+P/5WQkf+VkJH/lI+Q/5OOjv+Q + jIz/jIiI/4J/f/8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACx+/d4uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC1+/ewuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//LXz+cQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////// + ///////////AP///AA///AAD//gAAf/wAAD/4AAA/8AAAH/AAAB/wAAAP4AAAD+AAAAfgAAAH4AAAA+A + AAAPgAAAD4AAAAeAAAAHwAAAA8AAAAPgAAAB4AAAAfAAAAH4AAAB/AAAAf8AAAP/4AAP//////////// + ////KAAAACAAAABAAAAAAQAIAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8pc/f/WkoZ/5yMjP9a + axn/EBkh/4xza/9ajGv/lFJr/85aa/9aEO//zlop/84Za/8ZEO//zhkp/xlrSv8ZKUr/zlpK/1oQzv/O + Wgj/zhlK/xkQzv/OGQj/GUpK/xkISv+cra3/nIxr/1prSv+Ua0r/a2Pv/1opSv8pShn/WkpK/2tjzv9a + CEr/CEoZ/xlS1v9jGQj/OhkI/1qtjP9ajO//Wq1r/1qMzv/ezs7/3q2t/5ytjP9aa4z/Woyt/97v7/9a + jEr/Wmut/97vzv8ZjO//Wmtr/5ytzv+cjK3/WoyM/5yMzv+czs7/Wq3v/1qtrf/erYz/nO/O/5zOrf/e + 72v/71pr/95r7/9a7+//Wu9r/97vrf9a7yn/Wu+t/97vKf/ea63/WjHv/+9aKf+Uayn/3q3v/96ta/9a + Ka3/3inv/1qtKf/erSn/3imt/+8Za/8ZMe//7xkp/5Qpa/8ZrWv/Ga3v/5yta/8Zra3/nO/v/xlrrf8Z + a2v/nK3v/5zvrf+c72v/nGvv/xnv7/8Z72v/Ge8p/xnvrf+c7yn/nGut/5QpKf8ZKa3/nCnv/xmtKf+c + rSn/nCmt/xkpa/9arUr/Wq3O/5ytSv8Zrc7/nO+M/97vSv/ea87/Wu/O/1rvSv/e74z/Wu8I/1rvjP/e + 7wj/3muM/5RrCP/erc7/3q1K/1opjP/eKc7/Wq0I/96tCP/eKYz/lClK/xmtSv8ZrYz/GWuM/5zvSv+c + a87/Ge/O/xnvSv8Z7wj/Ge+M/5zvCP+ca4z/lCkI/xkpjP+cKc7/Ga0I/5ytCP+cKYz/lEpK/96Mrf9a + Soz/3s7v/1pKrf/ejIz/3s5r/+9aSv/eSu//Ws7v/1rOa//ezq3/Ws4p/1rOrf/ezin/3kqt/1oxzv/v + Wgj/lEop/96M7//ejGv/Wgit/94I7/9ajCn/3owp/94Irf/vGUr/GTHO/+8ZCP+UCGv/GYxr/xmMrf+c + zu//GUqt/xlKa/+cjO//nM5r/5xK7/8Zzu//Gc5r/xnOKf8Zzq3/nM4p/5xKrf+UCCn/GQit/5wI7/8Z + jCn/nIwp/5wIrf8ZCGv/nIxK/xmMzv+czoz/3s5K/95Kzv9azs7/Ws5K/97OjP9azgj/Ws6M/97OCP/e + Soz/lEoI/96Mzv/ejEr/WgiM/94Izv9ajAj/3owI/94IjP+UCEr/GYxK/xmMjP8ZSoz/nM5K/5xKzv8Z + zs7/Gc5K/xnOCP8Zzoz/nM4I/5xKjP+UCAj/GQiM/5wIzv8ZjAj/nIwI/5wIjP9CY+//QmPO/1opa/8p + axn/Wkpr/1oIa/8Iaxn/GXPW/2MZKf86GSn/GVr3/xAZAP8Qc/f/EAAA/wAAAP8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8AP4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+ + /AAAATQBAQD8AAAAAAAAAAAAAAAAAAAAAAAAAAAAADQBNAEoAQEoNAEBAfwAAAAAAAAAAAAAAAAAAAAA + /AEoAQEBAQEBAQEBKDQBAfwAAAAAAAAAAAAAAAAAAAABAQE0ASgocXE2KigBAQEBAQEAAAAAAAAAAAAA + AAD+NAEBASgvNwM3AzcZGSw7KAE0KAEAAAAAAAAAAAAAAAE0KAEqAwYGBgYGBgMDGRk2KAEBAQH8AAAA + AAAAAAAoAQEBLwY1BgY1BgYGNQYDAxksOwE0AQAAAAAAAAAAAAE0ATIGBjUIGwYgBhsGBgYGAxkZ8QEB + KAAAAAAAAAAoAQEqGzU1HDUgBhsc9Rz1BgYGAwcZAQEBAAAAAAAAAAEBATg1BwYGBhwGBgMDBgYbBgY4 + NRkoATQB/AAAAAD8AQHyNTUHBwMDAwMsGRoaGQMGBikHGTYoAQEAAAAAAAEBNCoGBgcnPwMaBiwZAwMG + BgOlKQYDGQEBAfwAAAAAAQEBMjgGBgYnGSwZGSsDnRkDGSkHNQMZKDQBAQAAAAABASgvBgYGBwcaGhos + Kxo3LQMpBwY1AwMoAQEB/AAAADQBATIGAxoGMQcaGisrGhkzLXAGNQYGGSg0AQEBAAAAAQEBLwYDBgMa + ywctKzCdM7gnBjUGNQYtAQEoNAEAAAD8Af0qNQMDAy0GywcwMCwzPikGBgYuBjcBAQEoAQEAAAABASgD + AwMtGSwxBzMwuDMnBgYGNQYGKjQBNAE0AfwAACgBAS8DA50ZoywtOj8/GQYGAwYGNQMoKAEBKAEBAAAA + AQE0KAMDLRksLCdaByktJxoGBjgGKgEBAQE0ATQBAAD+AQEBKgMDNy0nJykHByknJwORBjgoAQE0ASgB + KAEAAAAAAQEBKgMnJykpBwMHKSknJwY4KAE0AQEoATQBNAEAAAA0KAE0KgcpBzgZAwMDBwcH4SgBASgB + NAEBASgBAQAAAAABAQEBASo3AwMDAwM4LyoBAQE0AQEBKDQBATQBAAAAAAABNCgBNCgBKCooKAEBKDQB + ASg0AQEBNCgBAQAAAAAAAAAAAQEBAQE0KAE0ASg0AQEoNAEBKDQBAQEB/AAAAAAAAAAAAAEBAQEBAQEB + AQEBAQEBAQEBAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////// + /////8A///8AD//8AAP/+AAB//AAAP/gAAD/wAAAf8AAAH/AAAA/gAAAP4AAAB+AAAAfgAAAD4AAAA+A + AAAPgAAAB4AAAAfAAAADwAAAA+AAAAHgAAAB8AAAAfgAAAH8AAAB/wAAA//gAA////////////////8o + AAAAGAAAADAAAAABACAAAAAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//LH39/AAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsev2QLn3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//zN/+v+loaD/pKCe/6qmpP+2sK//xMG+/y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8u + ff//jomJ/4mCgv+FfX3/hn17/4qCgP+QiYf/m5aU/7Grqf/GwsD/Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//zF9+f99eHf/dWxr/3RpZv91Z2P/d2di/3lqZf99 + b2r/hXp2/5CIhf+hnJn/v7u5/y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//0txVv9waGX/c2Zh/3ZkXP93Ylj/eGFW/3lhVv94Y1n/eWdg/39zbf+NhIH/n5qX/0FmT/8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//dHBw/0+CXP92aWX/e2hf/35lWv+A + YlT/gF1Q/5+fof+Ebmb/emBV/3llXf9+cGv/joaE/0dyVP8yf/3/Ln3//wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//cWtq/1NzWf9hpHn/n56g/6mpq/+wsLH/tLS0/7Gxsv+DXEv/oJ+h/5OSlf94 + ZmH/XJ5x/5ONi/+3srH/Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAC59//8ugP//eXJw/4N2cv9k + mGT/kd3M/7e2uP+olY3/wL/A/729vv+5ubr/rKyt/4BlWv93z7L/WIZd/4iBf/+joJ//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAC59//9tbnX/gHl4/4h6dv9fd1L/a5Rm/6mchP+ecVr/ysrK/8XFxv+g + hHj/moJ4/4Gjhv9nnGj/d2lk/393df+ZlZT/Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAC59//9v + cnr/hH17/46Ae/+Xgnj/a4RR/2+PZv+9nYT/4N7f/9PS0v/Fxcb/1fDv/2uUZ/9ee1H/eWtm/3tzcv+T + kI//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAC59//8ufv//h4CA/5KGgv+gjoT/uJyN/3CJU/98 + kG7/+/n6/+Hh4f/g9fP/kNrH/2mJVf+Db2b/em1p/3pycf+Rjo3/Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAC59//8uff//hoGB/5WLiP+ml4//xK2g/31oVP9vi1j/6vb2/9Ty8P/r9vX/h8ad/5B4bP+F + dm//e3Fu/3lzc/+UkJH/Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAC59//8uff//hoKD/5KLif+l + mpX/v66l/97Iu/9ke0//ld7S/2ebeP+GrJP/tqCT/5B+eP+Genb/e3Nz/3t2d/8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAuff//Ln3//42Iif+clpL/sqWg/8Gyqv9hq4b/ZaJy/2WeZv9i + pnr/XbCO/4+DgP+EfXv/e3Z2/4SBgv8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAs + fv36Ln3//y59//+SjY3/jZaJ/12uff9fqHH/WZBi/5OIgv9enGj/Xqt1/12yf/+BfHz/enh5/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//UItk/1CLZP+c + l5T/nJeT/5qSkf+Vjo7/fXl3/1GPZv9Mg2H/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//+QjI7/ko6O/5GOjf+Oioz/Sn7U/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn/94i59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA////AP///wD/B/8A+AH/APAAfwDgAD8AwAA/AMAAHwCAAB8AgAAPAIAADwCAAAcAgAAHAIAABwCA + AAMAgAADAMAAAQDAAAEA4AABAPAAAQD8AAEA/4AHAP///wD///8AKAAAABgAAAAwAAAAAQAIAAAAAACA + BAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8ue///Ln7//y59//8ufP//L33+/0mC4f9nh8H/doqw/3mKqv9w + h7H/WYHF/zp97f81fuL/ToyH/2mSdf+GkoX/npeU/5qTkf+RjYr/c4p4/16PcP9DhaH/MX33/0eA3/+O + jpL/f5+H/1+tff9eo3H/bpdx/4GQev9hmWz/Xah2/2Grf/93hXr/bnmR/zV99f88fuz/iomQ/56Wk/+y + pqD/o7Gg/2arhv9lonP/ZZ1p/2One/9pqYr/iomB/4V9e/97dnb/bH6h/3CCpP+TjIr/ppuV/8Cupf/Z + wrb/kZ6C/5HLuP98up7/irSc/4eIcv+Qf3f/hnt2/3t0c/9+eXr/ToLa/zx96f+HgoL/lYuI/6iYkP/E + rKD/m5Z3/3OOX//f7Oj/zuXg/8nh1/99rIT/h3pp/4Z2b/97cW7/e3V0/3eJq/9Qe8b/h4B//5OHgv+i + j4X/nY13/2+HVv+FknD/6enm/9jKw//M0Mb/mdvI/2+JXv+BcGb/em5q/3pzcv+QjpH/Mn78/1d5tf+E + fXv/joF7/5SBdf9whFf/eZFp/6yPdf/a1NH/xbew/7mqo//B4t3/b5lu/218XP95a2b/fHRy/5SQkP9C + hPH/VXay/4B4d/+Ie3b/dX9i/22Vaf+Xj3f/rI19/8XAvv+4qqT/o4V4/6STiv+BmX7/ZZho/3FyZP+b + l5b/RYbx/0t2wP95cnH/fHZu/2eabv+NtaT/sKqo/6WNgf+6tLP/sKOd/7Krqf+ekIr/k46J/3m+ov9k + jGn/iYGA/6aiov83gfr/PHrj/3JsbP9lemT/bJ58/5aSj/+ai4X/oJCJ/6+qqf+lmZX/lX91/5iQjv+O + iIj/fYB4/12ZcP+Fi4L/m6a9/2dyjP9YgGL/c3Fn/3xpYf9/Zlr/gWNU/415cP+Pfnf/jH13/35oXv96 + Zl7/f3Jt/3iMe/92j3z/bpnj/0J83v9dcGP/cmln/3RmYv92ZV3/eGNZ/3lhVv95Y1r/e2lh/4Fzb/+N + hIL/op2a/2iIkP8zf/3/UX7I/395ef94b23/dmtn/3ZpZP94aWP/emtm/39xbP+Ge3f/komH/6Wfnf+y + tL//RIf0/0+C2f+GiJL/iIKB/4Z+ff+Hf33/i4OB/5KLiP+emJb/sKup/6Cvzf9Ch/j/NX/5/2GL0/+E + lbX/m56o/6alqf+jqbj/jqXQ/12T7f8vff//Ln///wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAACAwMDAwMDA+MAAAAAAAAAAAAAAAAAAgMDAwMDAwMDAwMDAwAAAAAAAAAA + AAACAwPa29zd3t/g4eIDAwIAAAAAAAAAAAIDA8/Q0dLT1NXW19jZAwMEAAAAAAAAAgMDwsPExcbHyMnK + y8zNzgMDAAAAAAAAAwO0tba3uLm6uru8vb6/wMEDAgAAAAAAAwOlpqeoqaqrrK2ur7CxsrMDAwAAAAAC + A5WWl5iZmpucnZ6foKGio6QDAwQAAAADA4SFhoeIiYqLjI2Oj5CRkpOUAwMAAAADA3R1dnd4eXp7fH1+ + f4CBdYKDAwMAAAADA2NkZWZnaGlqa2xtbm9wcXJzAwMCAAACA1JTVFVWV1hZWltcXV5fYGFiAwMDAAAC + A0JDREVGR0hJSktMTU5PUFEDAwMDAgAAAwMzNDU2Nzg5Ojs8PT4/QEEDAwMDAwAAAwMlJicoKSorLC0u + LzAxMgMDAwMDAwAAAAMDGBkaGxwdHh8gISIjJAMDAwMDAwIAAAIDAw0ODxAREhMUFRYXAwMDAwMDAwIA + AAACAwMFBgcICQoLDAMDAwMDAwMDAwIAAAAAAgMDAwMDAwMDAwMDAwMDAwMDAwQAAAAAAAABAgMDAwMD + AwMDAwMDAwMDAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/ + //8A////AP8H/wD4Af8A8AB/AOAAPwDAAD8AwAAfAIAAHwCAAA8AgAAPAIAABwCAAAcAgAAHAIAAAwCA + AAMAwAABAMAAAQDgAAEA8AABAPwAAQD/gAcA////AP///wAoAAAAEAAAACAAAAABACAAAAAAAAAIAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/bstfP57AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8u + ff//JH/+DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//5OOjf+MhoX/jYaF/5aPjv+r + pqP/zMfH/y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//3p0df9yaGX/dGVf/3ZlXv95 + amP/g3d0/5aPjv+/urn/Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAALn3//3Nvb/9zaGX/emdf/31jVf9+ + X1D/fF5Q/3liWP9+cWz/hpGG/8vJyP8uff//AAAAAAAAAAAAAAAAAAAAAC59//90bWz/YJts/6Skpf+w + rq//t7e4/4hfSv+gn6H/jYyP/1aMYv+npKH/Ln3//wAAAAAAAAAAAAAAAC59//8uff//gnl3/39uZf9t + mXf/xcTE/8bFx/+TZU3/iWJR/2afdP93bGf/lZCQ/y59//8uff//AAAAAAAAAAAufv//Ln3//4d+ff+W + hHz/bIhT/52YfP/j4uL/m21X/5/i1v9gflH/d2tn/4uGhf8uff//Ln3//wAAAAAAAAAAAAAAAC59//+K + g4H/oJKK/8qwof9wi1j/7/j4/9CvoP99s4b/iHVt/3lvbf+Kh4j/Ln3//y59//8sff5+AAAAAAAAAAAu + ff//iISF/5+Wkv/Esqr/5MzA/2aee/9npYb/lYB4/4p+ef95c3P/Nn/2/y59//8uff//Ln3//wAAAAAA + AAAALn3+aC59//+SjY3/pp6Z/1+reP9dkmP/YKBo/16ufv+Gf3//e3h5/y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAuff//Ln3//02HZP+Zk5P/mpST/5SOjv+NiYj/Q4GP/y59//8uff//Ln3//y59//8u + ff//Ln///wAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAP//AAD9/wAA4D8AAMAPAACADwAAgAcAAIAHAAAAAwAAAAMAAIADAACA + AQAAwAEAAMAAAADwAQAA//8AAP//AAAoAAAAEAAAACAAAAABAAgAAAAAAAACAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/y5+//8uff//MX78/z2A7v87f+//L33+/zF98v9Miab/gpCK/5qUkv+Tjo3/b4iE/0KFtP8v + ffv/OH7z/4aMnf+HpY3/YKh5/3GZcv9nmm//Yap+/3mLfP9oep3/MH39/3GDp/+glpL/xLKp/56slP9+ + uZv/erCR/4aMev+JfXj/e3V0/1eAx/87fer/ioSC/6KTjP+zoY7/doxf/9/t6v/M2M7/gKeF/4Z1a/96 + cW7/foSV/0h70P+Hf33/loR7/3aHXf+WkXL/3trY/72so/+gy7j/cH9e/3ltaf+MiIf/OIH4/0Z4zf+A + eHX/eIBn/4Ceff+umIz/w7++/6iQhf+hmZH/caaB/3N3af+WkZD/PIL3/zp65v91b23/Z5Vz/5qcl/+d + iH//s6+v/52Jgf+ShX//go6G/2aPcf+doKn/L33//1t1if9rdWb/emdf/35jV/+JdGv/hXFp/3xnXv+A + c27/c4p3/2+Vz/8vfv//NXrl/3d3gP91a2j/dmdh/3hnYP98bGX/hXl1/5qSkP+WpLv/MH34/z1/7v92 + h6j/jYeG/4+Ihv+YkY//qaWm/4ai1P83gfz/Lnz//z2C9f9Ui+j/VI3s/zmC+/8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAQICAgIBAAAAAAAAAAABAgJwcXJzAgIBAAAAAAABAmdo + aWprbG1uAm8AAAAAAl1eX2BhYmNkZWYCAAAAAgJSU1RVVldYWVpbAlwAAAJGR0hJSktMTU5PUFECAAAC + Ojs8PT4/QEFCQ0RFAgAAAi4vMDEyMzQ1Njc4OQICAAIjJCUmJygpKissLQICAgABAhkaGxwdHh8gISIC + AgIBAAIPEBESExQVFhcYAgICAgABAgcICQoLDA0OAgICAgIAAAECAgMEBQYCAgICAgICAAAAAAECAgIC + AgICAgICAAAAAAAAAAAAAAAAAAAAAAD//wAA/f8AAOA/AADADwAAgA8AAIAHAACABwAAAAMAAAADAACA + AwAAgAEAAMABAADAAAAA8AEAAP//AAD//wAA + + + \ No newline at end of file diff --git a/VTFXUtil/Form2.Designer.cs b/VTFXUtil/Form2.Designer.cs new file mode 100644 index 0000000..b5f655c --- /dev/null +++ b/VTFXUtil/Form2.Designer.cs @@ -0,0 +1,109 @@ +namespace VTFXUtil +{ + partial class Form2 + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form2)); + this.OKButton = new System.Windows.Forms.Button(); + this.CancelButton = new System.Windows.Forms.Button(); + this.label7 = new System.Windows.Forms.Label(); + this.PlatformCombo = new System.Windows.Forms.ComboBox(); + this.PlatformTooltip = new System.Windows.Forms.ToolTip(this.components); + this.SuspendLayout(); + // + // OKButton + // + this.OKButton.Location = new System.Drawing.Point(63, 33); + this.OKButton.Name = "OKButton"; + this.OKButton.Size = new System.Drawing.Size(75, 23); + this.OKButton.TabIndex = 3; + this.OKButton.Text = "OK"; + this.OKButton.UseVisualStyleBackColor = true; + this.OKButton.Click += new System.EventHandler(this.OKButton_Click); + // + // CancelButton + // + this.CancelButton.Location = new System.Drawing.Point(144, 33); + this.CancelButton.Name = "CancelButton"; + this.CancelButton.Size = new System.Drawing.Size(75, 23); + this.CancelButton.TabIndex = 4; + this.CancelButton.Text = "Cancel"; + this.CancelButton.UseVisualStyleBackColor = true; + this.CancelButton.Click += new System.EventHandler(this.CancelButton_Click); + // + // label7 + // + this.label7.AutoSize = true; + this.label7.Location = new System.Drawing.Point(12, 9); + this.label7.Name = "label7"; + this.label7.Size = new System.Drawing.Size(45, 13); + this.label7.TabIndex = 5; + this.label7.Text = "Platform"; + // + // PlatformCombo + // + this.PlatformCombo.FormattingEnabled = true; + this.PlatformCombo.Items.AddRange(new object[] { + "PlayStation 3", + "Xbox 360"}); + this.PlatformCombo.Location = new System.Drawing.Point(63, 6); + this.PlatformCombo.Name = "PlatformCombo"; + this.PlatformCombo.Size = new System.Drawing.Size(148, 21); + this.PlatformCombo.TabIndex = 6; + // + // PlatformTooltip + // + this.PlatformTooltip.ToolTipTitle = "hello"; + // + // Form2 + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(227, 65); + this.Controls.Add(this.PlatformCombo); + this.Controls.Add(this.label7); + this.Controls.Add(this.CancelButton); + this.Controls.Add(this.OKButton); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.Name = "Form2"; + this.Text = "Platform Selection"; + this.Load += new System.EventHandler(this.Form2_Load); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + private System.Windows.Forms.Button OKButton; + private System.Windows.Forms.Button CancelButton; + private System.Windows.Forms.Label label7; + private System.Windows.Forms.ComboBox PlatformCombo; + private System.Windows.Forms.ToolTip PlatformTooltip; + } +} \ No newline at end of file diff --git a/VTFXUtil/Form2.cs b/VTFXUtil/Form2.cs new file mode 100644 index 0000000..760d758 --- /dev/null +++ b/VTFXUtil/Form2.cs @@ -0,0 +1,44 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +// this will now be a new home for our texture import options + +namespace VTFXUtil +{ + public partial class Form2 : Form + { + public string Platform; + public Form2() + { + InitializeComponent(); + } + + private void OKButton_Click(object sender, EventArgs e) + { + + Platform = PlatformCombo.GetItemText(PlatformCombo.SelectedItem); // yoink our values, is used down below + Form1.MyCodeSucks = Platform; + Close(); + } + + private void Form2_Load(object sender, EventArgs e) + { + Console.WriteLine("EYYY IM WALKIN HERE"); + PlatformTooltip.SetToolTip(PlatformCombo, "Selects the desired target platform for the texture."); + PlatformCombo.SelectedIndex = 0; + } + + + private void CancelButton_Click(object sender, EventArgs e) + { + Close(); // release the user from this janky window + } + } +} diff --git a/VTFXUtil/Form2.resx b/VTFXUtil/Form2.resx new file mode 100644 index 0000000..3669a09 --- /dev/null +++ b/VTFXUtil/Form2.resx @@ -0,0 +1,3348 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + + + AAABAA0AAAAAAAEAIABZ3QAA1gAAAICAAAABACAAKAgBAC/eAACAgAAAAQAIAChMAABX5gEAQEAAAAEA + IAAoQgAAfzICAEBAAAABAAgAKBYAAKd0AgAwMAAAAQAgAKglAADPigIAMDAAAAEACACoDgAAd7ACACAg + AAABACAAqBAAAB+/AgAgIAAAAQAIAKgIAADHzwIAGBgAAAEAIACICQAAb9gCABgYAAABAAgAyAYAAPfh + AgAQEAAAAQAgAGgEAAC/6AIAEBAAAAEACABoBQAAJ+0CAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgG + AAAAXHKoZgAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAA7DAAAOwwHHb6hkAADc + 7klEQVR4Xuz9B3hdZ5qdiZY99lyPx3PvHc94ZnztGd/xbbu7VSSr253d3Q7dbk+3AiXmgJxzBk7OAQcn + n4Occw4Ec44SJZHKpHLOsRRLqlzAuuv79z4HIAvtcalYIqXCfp717AMQBE7Y6/3W9+9///tb69v6tr6t + b+vb+ra+rW/r2/q2vq1v69v6tr6tb+vb+ra+rW/r2/q2vq1v69v6tr6tb+vb+ra+rW/r2/q2vq1v69v6 + tr6tb+vb+ra+rW/r2/q2vq1v69v6tr6tb+vb+ra+rW/r2/q2vq1v69v6tr6tb+vb+ra+rW/r2/q2vq1v + 69v6tr6tb+vb+ra+rW/r2/q2vq1v69v6tr6tb+vb+ra+rW/r2/q2vq1v69v69sts+Na3/g6ct/23KL/t + Hy3X3faPl80b/tdl67f/d5g2/stl22//q2Xbt3972blh07Jz479Ztn/7D5btm/6I//5v0zLxa8t3/nDZ + wn83b9qw7Nz0r9X/tXznny07+fvq/vl/J39D/3Pr2/p2YzY4v/V34fy9f7hs+q3/SQ7YZfNtty1bbvvD + Zeumv+BBeyesG3dwn81/K1u2bqhftm60LNk3epasm0JL9g0JqnPJtrGfGl2yfnuCX0/x32eWHBvmr5F9 + 0+LfqpWfmVP/V4m/x7ZpUn4vbJuGuR/kv/ct2Tb0Llk3dnHfzp9r5T6+ZNkQ47+HYd/Ywu8183te/oxn + 2b7BcY1sG63L9o2Wn5Ntg13+Xf6P+h3q98nv39DH3zcGx8ZZ/u0DS67vHFtybjy75Np0P5ybHuG/P8nv + v0i9yef/Af/PJ0uOTd/j//kBn/uP+fuWYN8EOCjnd34xyf/h/+Xf+BnF37fxM+7fX3JsfGHJ+Z1LfC6H + +PsH+JnwdfHzsW/882Xnb/5/+Hn+Pf2jXd9+nTepFssNm/57VUmsG/8TbBtz5UDnQdq75Nq4sOTcdC8P + 1Kd5wL7BA/hjGvrH3C+nD1h10K56LN9f160p/TPiZ/szgugtfran+TjIlHEXP///RT8k1rdv6rbc9Jv/ + w7Jt0+9KJeAHH19ybjhOYz/HCvG5MnWqoqwb+ddLBDgh/yNJDIS/mQnoN/VDZn37um7Y8a3/Rqr6svW2 + Pfxwu2n2SxIP1w2+rv+iJCE4NvyEBeECj5/dcP6Lf6AfUuvbrb6xH/8/YdmYyx6Q/fWGV9lfLql4vtYH + va51/d9JJYNNLy87NlbI+I9+mK1vt8omo8nLlo1/zMoe4Ad1hbH+p+vVfV03XFoqeIWtwV5Jlvrht77d + jE1Gb2Ukd8mxMSlVft3w6/rKpECw8aycqtQPx/Xtq9pg3vBbNLyP1f7FddOv62aKreXnTAM1cmpYPzzX + t1/Fps67OzZk0PDnVbxf48NY17puiiQN2DcuoOY7/2/9cF3fbtS2bP3tf0HKehm33lmv9uu6lbXk2HQV + ztv+D/3QXd9+mY2xaiPf0CEa/wfrxl/X10VL9k2vyzRm/TBe337RTeZ1L9m/s7Ae89f1dZXMFIXxN/+/ + +iG9vv3XbMvOTRvU3PZ146/rGyCZVSrXiuiH9/r2t23SMy05vjPA6PTjtd7Ida3r6yoWtOMo/r2/rx/q + 69vqTc3Fd2xyLtk3frbWm7eudX3t5diEZft3bPohv76ltmX7hi0ym2p9cG9d33Qx2f5IxrX0Q//Xe5PF + GljxD60bf12/TiIEHvy1njasTdndUA3Hxk/XeoPWta5vtKQVsG7I0O3w67XJOVFW/XPrVX9dv86SswJy + wZpui1+Pbdm2IX/JvuGTtd6Qr7UEZiK5vDit1ctTrfp+6mfX+j3r+vURj4Fly6ZtujW+2Rt7/f9xyblp + 8mt54CtjfwfLfPwT++/iM+e/xbvuv8BLnjvwpHcbHvLuxQV/Pk40l+FooBIHA7VYaGnAfKAR8y1N3Ddh + obkB+5rrcMhfhWP+Mpz2FeB+TwYedW/Hc5478Zb7L/EJf6/8fvk76dWHVj+PdX3jxGJ4RrfIN3eDfePv + Ldk3vbjWG3DLSajM/Q+cf4A3Pf8ZV7w7cLq5mIZuwmDIg/ZIBPFoArFYElHu49zHo/J45euY/lh+JiZ7 + Sr6OhuOIRbiPxNXjSCiGcCiKEBUMRhBsCSMW8KPXb8GstxqnXdm46tqM95z/Dj8mGBQQ1qHwjZKsLrRs + /fb/T7fKN29bdmwsovk/X+vF3xJiJP+Z43fwgfvf4wnvThxtrsRwyInWaEwZORZr1ff647WU+jn9Z6Jx + io81KGgwiAgAxPwpGAgE5PsCgnBMh4EGBIFBC2EQCITgbw6i2d+CiNeFEXcdTjiz8Jzzr/G54w/XgfAN + ET1Sp9vlm7PJ4MaSdWPbLXmA8jl97vwjPOPdgiOBavSGm9MmjqdMvcrQ6vvxtmseX6/V3089VuYXEOgw + kO+ngKBB4DogpFNBDCFCIBQkDBQIgvA1t8BPEPh9AXg9fvjdHvQ563HGsQevO/4CP7X/zjoMvqaS1Yd1 + 23wzNtT/6/+ZVf/ULXVA8rl86vpTPOzdg+mgBYlING3o1VIG1o2cUiLRviL5+rrvrf7Z6xXl75REcP3f + ScNB0gIfpxMCISD7dCogBFoIg0BAA0GAiUAg4PM2w0MQiNwuD6IOM/bbc/Gi4z/hp0w06zD4Gsmx4VM4 + /8k/0u3z9d6WTbf9hjq9sdYL/apFE/zI8Xu46t1G05toevbgekXWjKhX/etMm0hea/hk+nG79ph7UVzX + 6sfXfB2TNKBBQPYpKShEWxHRk4EyvJ4GInyOKUkqkBZBtQYqDbA1UCAIqbZAICByu32UFy6CwOl0I2o3 + 4pg9A+84/pzxco33ZV23lvgZyU1kdAt9fbdl+4Y/YZx5b80X+RVKBvHedf3H5ZPNpeiIhDSTUddHemV2 + 3eSyTyY70mZPJuTx2lIASD1etVdaBYDrwbACAgJAgUDaBB0Gso8wCRAEYQFCCgZqjECHgGoNmAgEAs0C + AaYBv5YGvAoEXgUDl5MgsLvgtDnRa6vCY7Y7tEHE696ndd0iEgDYNuTrNvp6bsuWDXew8n9vzRf4FWnJ + +Tt40XMHpltMqnqmYzZ1TYVP7fVq3qqMf61ak51Kqx//l6T+X2q/SgKFFAC01oJ7Gj+VDmLRVRBQANAg + EAnr0h+H+XqugYC0BYSAtATNvhb4vQSBZyUNSBJwOtxwEAR2mwNBaxNOW3fie/Y/WG8PbkEt2TZGdSt9 + /bZl26bdS/aNP1zrhX0VklH8Zzx3YyTooJFSp+iurfbK7Kqyp/ZiUDE/TUsAXG/o1tYutLZpSur71tZO + tMn3U1L/V/9Z9bX+vYT2fe1vaPtEXFNMh4EAIAUD1Rb8XBLQXoMCgKSCkACAkjRAKQiwJVBjA/qZAoGA + 1+3XUoDrOghYHbBRbosZhyx78Yn9j9ZBcCvJuWlWt9PXa1t2bMhbuknX7S85voOnnLej221kFQwi4A+p + PlkMogCQoMmotPFpuFYxY9q4msTUytg0eVvK7G3dytRtaq8p/Vj2bT36z2hKKghwTwgo8WvZJwiAFWkQ + iCtJIlglgYBqDTQQaFoBgJYIdADoMAiuGiBsVhBgS5BOAhoIHASAna2A1WyD2WiF0WCFockES1M99pu3 + 4VNJBGu8t78OWrJu0m46egtoybXpgm6pr8+2bN1UcFNW62Hletb5+/C5/xqFni0o9m5HmXcPqrx5qHdX + wOIxwO1zoTkQQojGEXOlqvo1xteNLsZeUY+m9t70vrVd/1qXZv61JCBIaRUE+DevBUEnTd+BqCimAUD2 + 6XEBXSoNSCpItQWSBHQAhETBmAYBSQJUM1sCOVUoKUCMb7HYYTJZ0WQ0osFci2pbMcpdWSj17kKhbysK + fHej0nsHDrj+DD8gTNd8r9f1lYjt81XdVl+PbdnKyv9Vm5/G/9Dxb9Du/IvlPO+dyPffhcLAZhS13I2i + 4GYUhu5WUl8HtqDUvwvV3kJYfAZ4m/3KPHGJ++3daFem1s0uWmXy9o4+7bHs1ePrdN33WkVtAgZNSVEa + BBoMEsluBYK4DgDZx5kIBARKCgC61LgAARDRWgJRmBAIEQAhvgZJAwK2VBIQEAjs3O5mWK0uZfoGcz0q + 7UUo8e1FcWArioP3aO8RVcz3qJh7+bqg+S6+j3ei0fN/4ZLzj9fPGtwkLTk3vKBb69bfVM9v+2pj/09Y + oQ47/3S5zHU7cj2bedDyYFbGp8L3oDBCcS+Pi2Uf4tehLTzgt6CghY/9W1Huy0GTtwHeloAynECgvbsf + 7Z26qVOSryn1/evUet1jUZL/J6WEJAQlfk0QJFp7NCkA6CBIdLEFkBRAxcT8unQQRFIAUJIEoKUAgYCc + IQgLAHTj+xn7HQ4vjIz4ddZ6VDgLUOTdgcLmu1Eghlfvzd0oCfN94r6Y71NxeAu/1kBQ2ML3UiDguxN5 + 7jsRcv4F3iZk18cHvlqxjX5Zt9etvS3bNtzOJ/vVDfjxQHzd8Xtwuf4Kuaz6eV6pWHfR1Dx4xehRHtgx + EVuBOA/uxFbtMSX7oigVIQgECAKDAI3RvI0wKGAyMKM5FEOC0b2zZxCdvUNo7yIQlAZ+Th3dg2nJ1238 + uZQUDAiA1D4NBcLgGhCkpQFBQJBSCgTRqEBAA4EoTACEVQqgwklG/hjcngDMVicaLAZUOotR5NvJ13YP + 8gm7AlZ7MbcYvijGx+q90VSa5J7vkXp/+N4VEwQqGQT4vrIdyPPciRL37Tjg/FMF3TU/k3XdcC05vgYJ + YNn67X/7VZ7q+ynNv9/2p8uFzjuU+QuaWa2k6ouZdfPLQV2S3IqythWVt2/jfhtKW7ehRIAQpwiCQqqA + qaBApQKBgSSD3ajzVcPdHGAk70Z33wh6+kcJhKEVw8vjtaSDILVPqa2zX5k/DQJJAyoRUK2EQVJLBHGR + pAE9EaQgIGMDCgBMA2ECICSi+QOBKJyuAKu9A7XWGhR7svieyOvR4CaQ09KQBr+S1i0oa+X7Ie8J34/y + dnl/+D15n/j9koTAgf9HQBGSRMWWQEDAlkBaLKfjr/C6/ffW/GzWdWO1ZN/4uG6zW3PTFvHY8P5aT/5X + oQ/svwuv9S+Q7WBVkqrPmKp6fB6shVEetDzAS3XjV3RsR2XXdlR17UBl905Ude9GRddOfm8n/20HD/zt + hMF2Vr5t/H/bURDZivzINuSFt1JbkBfcygrI3+Evhs3vRiTehe7+MfQPT6KLQOjsHSYQhtHVO5KWfC3S + YKDt27s1tRECrZ2atLZgRQKChCQCKs4kECN0YgoE3Cc6aX5CQPYCAh0AzYEYbM5mNJmtqLKXo9C3G/k0 + fD5hls/nXyCSlBNjZSfsSmnuMkKwolPeF74n8t5070BVj7wn+vf4bxUKlAICwkLaA8JDJYcgE1aztAR3 + oMj+1zhq/ROJqGt+Tuu6QXJuOq9b7dbbls2/80/Y8381l/Oy6l+2/iGKTf8Z2bY7kOO6C3k+GbySSKvF + 11JKVTYewHIwV/XS9KL+naju342qgd2oHNjFx7tQ1bcLlb27UE4wlBEGZW07+Tu2MzWwT45tU6kgXwFB + N1SQpvDnwex3IsRK3Dc4gcHRWQWErr5RaoxAYEKgOgiCtBQENGkQGExDQAOBpIJ+BYE4k4AS04ASE4GA + IErwKABQAoDmljiN70ejyYJyRzFNuUMzvjL8VhRIqqHpiwi2YqYdSTySfASIYvaqvp2o4XtQzfelaoCP + dcn7JO9LFd+Tig7+HyaFUkpAIG2UwKCg5S6mLiYvpq8sy18jbPoP+FSuMVjrM1vXL69bdR4AnP/iH6jl + u9Z60jdYP2PPOWv+C+xu/L+QYf4bVv87keNhNZKRflanEh6cWsWXCibVfgeqeZBX0+w1Q7tRM7IHtaMi + xvrxvfx6N6qH96Ca/6ag0Mdk0LMbZZ27UNq+ixF5B1PEDrYImgqi2wiC7TQY1cL2wZ8Lg9eGUKwLAyMz + GB6fJwjGFQRSSsOgRyAwQvMLADS1dQ3R/AKCQZp/AAkBABXXIRBTEOA+2UsA9CDKVkAAEAgmYHP4UW82 + o4z9fUFgJ5MKE4tASoxPcBXHt6MoyWTTxtdAlXfQzJ00toCQ5pbXLK8/9X40jO9B3dgu1Ml7MyLvl8CS + QOghCPheCggqOtkmSGsgbQFbgjy2ArkuAsD619hr/M+obvprvOr4s/UBwl+Blmy3JXXL3VobK3/vWk/4 + RksW4Jj31yEUZp8bsKvz1TlOxlDfXShib1oUuUdVOIm11axcNb07WM14IFO1NHn9GDWxFw2T1BQ1nYE6 + 7usmuKdqxzJQM5zBZLAHlf17UNHNVNC1m8YhENp300S7mAx2EgQ7WVVZaSM7aDqCILgDJb58mHxORFmt + hycWMDqxD10KBJo6CYKOXtEo2ntEAoIRAkAgMIxWgiCpIDDIBCApgBDQU0BMB0CUAGgJtcHubEG9yYoS + ewmr8E7Gez4HQqkgqqmYwCoWcLXuYqKh6fkaKtnyVPVyz/RTPayBsJ4AVO+FaHovGmeo6T1onCQMJnaj + XkAwpKWDGoFoD5MU2wMBQWmSrYCMJQSYvtx3otixEw2OKtjsdrgsFly2b17zM1zXlxSBumzfVKpb7tbZ + lu0bKr8K2stSWAPN9vS18DLjTab0+iJeVAfztOrP2C99qxyotTxg6wZ5ELPKNYho/kaav4mGb+KB3jSb + gaY5aj4DjbOZPPAzUT+VibrJTNSOazCoHNhLw+xFec8epbKuPSjtpAiDEpqrgCAoIAgKIzuZCAiE8E4m + gmKYfV728YOYmD2EkUmCoG9CqZMg0CAwpiDQJgDQIdBKJTsFAkOs/gNKUv2VCIBgpBMOdwgNJhfK7RU0 + Pnt8SSJRSSVaOhE4FbfuVM9PEkyFjHNIohHTD+1F1fBevi5KIDjF100ANs7Ke7EXxvlMGObk8R4YZqjp + 3WhkImhkQhAI1IoGd6JW0kOX1kbI4GBFcC9M3jpYrTKL0AIzwWQxW2G12HHIlqmmYK/1ea7rF5RTALDx + z3Xb3RobrLf92Vdxuu8N139CR4sPITG+bn514YtMfY20MhK3wZPwoKY1W1Wo2v4daBjchQZWugZWuiYx + Pw/8JlY6w0wGjDS/keaXg964jwe+OvizePATBDNZBEEWahUIslAzmonKIVEGyvsIg74MlHXvJQz2oqRt + L6vtbqXCmMCAMZwwyAszOfjKYPe30PQTmF08gcGxfepxZ69AQFN7zxiNP5JWkhBIEAAJpoC4iBCIxHvg + 9sXRZPagwlKLAt9elTzkbxVGJY0wlSTZrjClKBFS5T18ngSXAKx6JAPVo5JwNLBJ6mkg7Axz2us2EoDG + BZqY74NpQf+aIDASkoYJvndMAY1j8j7uIkwJVb63tUxWlUxDxmAN7A4nzDS8yUTzCwAUBCxpCIzYSpnc + fn/Nz3Vd//Vasm/4gayZqVvv5m9ovO1/W3JuemOtJ3vDxGTxgvt2xAIt6sKWkCyAocyfQFiu4otql86q + S2pl1lyyDa52I+r79rDq70IjD94mHryGce55MBtY/cX8Jh7kpn1ZMPOgN+t7Iw9+w3yWBoK5bAWChuls + goAQEI1loWqEIBjOQvlApgJBKUFQ0qGpqHUP+23u43uQr4Mgn9Wx0lMLdzCO0amDWDh4Br1DMxoIqHZC + oI0QaOseJQBGCQBCoJMQ6Bhi5R+Ar6UNJmszqkwGxuxcBRZJGYWxXShKEDz8myXte1UqUVBiSqmg8SsG + M9RzrR6j6cX4k9LqMOHQ/PL6DPL6F7L4HmTAvJgS3wvuTYSBWYAgkJT3i62AcXyXeh8lDdQzBRjbSuDw + Omlwmt/Eys+qLwAw0fyiFQjYFATa7XX41P7Ha3/G6/qvEr32gG69m7/J3UpIpGNrPdEbqSfd9yDSElIL + XUj1V5e5KgCsmF8umFFX0ekX8MiEnXB7DJaBMhh40MoBbOKBbGbklapmYnWz0PDWxSwqW9vvz4KFj00L + OQRBtlKTAkEO6gmCOkpAUDuZjZrxHFSNZqFCQDCYibLeLJT2ZqKkKwPFHVR7BgqTGazQexQEsoO7kOfP + Rp3HgmCiF/OEwOz+U+jom2QKIAR6JgiBcbR2jyFBCCQIgJZYD8yOIGqNdhQ6ipHNPj83xMgf3YXC+G4U + tdH4/FulnRkoofEFRpV8LhVMKVWs+DWSXCYy+NzF9Fk6zDL5eqTCi/GzCT2Kr928n+/FAYrvgRJBYFnI + gIVtgWl6D8yEhmlS3kcafygLzqgVDocHFouDBnew+ttXIKADIAUBC79ntdjUVYZxuwHfdfzpmp/zuv7v + tWTb4NXtd/O3ZdsG46+07+fvftyzDeGWsKr86hp3Vv+gbn51AYx+vX4aAHK9fqtcuNOjTbPt6IOv2woz + Y6+F5rcw+lsZ+62MvVYCwEbD23nA2/dzzxSgQEBTWPblsAISAvM5rJQ5WhqYJQgkDcwQAFPcT+WgmiCo + HMuh6bJQNkgNZBMEVE8WQZBJk2ogyIvsRi4rd3aAbYKniP1yM7oGZnDk9IMYmTqENoEA1dY9zqo/BJc/ + wT7fg1JTDbK9e5FD48v/z48yYSTYcrDtKO3KVNAp65e/m6VSSSWhVD3B50dQiekbxPiz2Wig+ZvmNaCJ + 8UUa/LJgk9d/IAsO0UF9TyDYmAys87thm9vD900gsBeO/kp4m32w2z2w2dzs+Z06AAQEKxAwGsxKaQio + VoAQsDkRcZjwnuPP1/7M1/W3asmxaXnZ9Nt/pNvv5m7L9m//AZ/Qj9Z6ojdENP+jnu0IBUJq5dvUAhfq + CjdG/9RlsOp6eTE/o79ILqiRK/LE+DIHX8226x5EpCsG+1gRbIy0Dprfxqhv58Hv4MHvpPk1ZcLB7ykQ + 6BAwUcaFXEIgl+bJVRBomM1lVRUY5CoQ1BAElWPZGghGcwiCbKUSpoLiriwUMQ0UJNgSRPfSxLuR1UI1 + s0d318ETbMfM4mkcPX0Jnf3TaI50w2ALopLmyXPlIYvAyA6y8tP4Yn6Bify+km6an7ApG8xB+QiTyIiY + XnsutQIpMT+fayNhJfASGQgAE6EmKccixtfNL++Bm9XfRTkJABcB4DrIx2wFHEwBDrYCttlMeDotcHuD + ND7Nb3XrAHAxBUj/74CJacBEAJiMTAGGlRSgIJAeD7DBIRBwWtYh8AuKfntJbpOnW/DmbXDe9o+WbJue + XetJ3ig97t5G84fVNfvp6h+i+UXXR38xv6r8Yn7tyjyZZ6+m3upTcWVGXltPH7zDDQRABlys/i7GXBdN + 797Pr2mClJwCBkLATvNbxTBsCSxMASZJA4RA0wxBQDVQtdM5qCMIqidzUTXBPVU5qqlsKAcl/RQTQVFH + Fgpbs5Afy2CMZ0UP7lHmzvXwd3k8aGULEEoMoM7oRZGlEpn+vTQ+/11VfqaGBNNEayaKO9lm9DBh0PgV + IwIc+Zs5NL88D2lVpNrzuYn5CSoD2xd5zmJ8ZX4Ftmxlfqd6vZrx3TS852AGvGqvfc8l7wsh4JouhD/p + g8cThNPph93hg40JwEoIiNIAkARAGRUAViCQTgL6eIDNYofD7kTUZcGHt3g7sGTduLRk37S81r991Vqy + bQzoFry5G9+QxFpP8IaIlf8p92aaP6iuXZdr2OVKtpT51fXuUv2V+aXnF/NL5ddiv0ynlQtu1Fx7Vn41 + LbdvFD0DE+gbnER33xha+t1w09Tq4Kc8rHieA9kEQTY8lJsV0kU5aRQHTWOnFAikgtJQRhrLqCCQx4jN + NDCdx8orEKARp/IUCCrHc1ExlovS4VyUDOaiuCcHhZ05KGjLQl4sCzlhGpwgyGrZgww/e3l3NSotFmQ7 + c5EZ2MN+X2L/XrYOmcin+QvbmSQ6swgUJgsxv0CGf0PAI3+7lpLn0SDPiRLzS2IRaInMlJVyyGuS16a/ + dqn8Pr5+Lyu/VwFAk8DAfSADvslKNEfDrPwhuFwBAqCZACAE7F6VBBQA2AYIADTJugI2tZhICgIpAJiM + ZtUeCARkPMDlcKPVbcZnzltzYJBFbnnJenMWsLleS46NP1s2b9qgW/DmbbB++z8sOTb8bK0neSP0gutv + EGpuUSvXyAo215o/QfOz+tP82nJZrPqyok6yW11Fl7rCTgAgF92k5uQr8w9NKfUPT1OziPTF4JsvUMb3 + UV5WQ5FPDMG9ZzGHICAkmAKchIWd5rfRQBZWVtNsHsXqSgg00XT1U/nKfLWTonzUTOQTAnmo5L5iLB/l + o/kKAkW9eSjqJgjasmnqLOTGBQSZUBBgGshg1c8MSDogHMIZyOO/5yezUCDm7yVE+iRVECxifkkb6u/l + oY7Qkb+vAYDPSa/8JrYtYn4Blzx3+4KWbJyUhxCQ1+6n8Ztpdj+rvv9gNpoPZcF/iO8BFRg1IMD33esj + AFj9Xe4WdYGRAMAmAEilAAvbALMOAZMOAFlRaFUSWA2B1KlBaQXcLi963U344fopwv+iCICLugVv3rbc + sOm//1VG/zddf4lYs1+tWBOg+a+p/uz9tbXvJPpr5teqv6ymw8ovA36rYn+68vdPoJeVv2+Y5h+h+Udn + MDi2gMHRfUj29cA3UwY/De+n8ZtZCZv5WORjRPaKSVgxNQjkMg3kEgS5sLKymmk0E2WUassU0Ejz1dH8 + AgPZ10wUMJoXoGo8H5VjeSgbyUfxYB6K+/NQ2JVLU+fQ3DnIZRoQs2cFM5DJqp8VYosQ0VJCfms2Cjpy + UMT0UDKUj9KhPAWUKlb+GgJGYCOq49+Uv980k0/lwUAAmAgqCyEgVd9GANgl8ejJRlKOj5LX20LjB2n2 + FkIgcJjvAb8OEAqBQTv8wSS8/iirfxgeJgC3W1oAJgC2AVa2AVarngAIAHMKACoBrKQAQxPNn1IaAvqp + QaYAp8MFr9uHaU/V+mShv01MxbfE7cFpfma/NZ7gDdBHzj9Fq9+jLVxJAKSqf1Af+FPVX18iWwFAVszR + zS8La6jo38nor1d+uSBHKv+K+WcxMLqAobF9GBpfVBqeOID2gTE0T9TRDDzwafwAq2JAjEGjNFMCAS8h + 4GYL4KKJnGImAkAgYKHRzDS/gRW4iWpkNW6g6nUA1ND8VWOEAFU5WkAIFLAlKEBRXx4KBAKdeTS5QCAb + OdFstgRMBNznJrKRx+8XdhEWPaz8A3koH6FG2V7wdwpY5PeL8QU4DfzbBgLAwOciQDLzeVkJAKn6NgLL + IQDbl0uY5ajK7+frk9cY5GsO0fgCgKAOgsCBXAS6m+FrScDjj8Hj0wAgchIADqYAByFgs/vYAngVBFIA + MJm0cQCj0XYNAFYgsOrMgMmSPjUoS5P7vc047cld89j4dRd7/7eX6/75f6fb8OZsy7bf/vavarbfF84/ + QJfPqi1dLdF/Ve8vq9loS15L9dfNn6r+qvLrsX+V+eWCG6n8PWJ+Fftp/hExf8r4+5X5R6cOY3T6CHqG + 59AybEaQPXELIdCizJHNx4SBVEoCwEfze3S5aCo7TWaj2axiOJrPKBWYxm+kmhj968cLUEvVUCkAlDMF + lHNfOlSAwr58FPbmI58QyGvLo+lzkBMjDJK5yO8QQDAt9BWwdchX6UH+fyV/T/VYoQJLLQHQoP4eIz8B + YOLfF0kyETjZWf0dYn5CQMAl5veJ+ZlsWmh8MX+Epo8y8odp/NChDIT2FaClPQRvQCp/XAHATQCkIKAA + wBZAAKDagBQA9BRgkoFAQsDIBGBMtQFrQGAlBeitgN0FD1NAwBfAVfc9ax4jv85atm1w6ja8ORuc3/q7 + S45Np9d6cr+sfur4XUx4atVy1YEAAaCqf8r8WvVX5/xlqi8BoJlfXy5LB4CYX66rl8trxfxyFd6K+Wdo + /nlV+QcFANeZf2zmKMZnj2GA/xYa8CC0P4dVMYvmyEbkQA6hQBAs5ugQoGgoDw3mIgAcNJtAwKbMlw8j + q3ETE4CAoCEFAd20VVTlSCEqRopUCigeZBIYLERBbwHyOvOR15FP8xMG3Bf0FPD7+Yz9WmIoZ3IQAFRR + NeOFqKP56yVtsA0wcC/wEQhZBEjyvPj8nPIc+VzdTCxe7v18/s3s/QVwIXltNH6ckT9+JAtR7iMLpQgk + aHaa30Pzu31ifg0ASgSAyxOC0yUJIKCuQLTaUwnADTMBYJQEoJQCwLUpYG0I2AgSJ1OAGz6PH9FmH953 + /vs1j5VfR8miOsuW3/qnuhVvzgbrxh2/igk/sqjkUXeBWqdeVqltbllV/VOn/WRBSzXyL6vfypLYHWq6 + r2Z+beBPMz/7/t4R9v0S/SdV9JcBv4GROdXvyxx8Zf7JQ8r8Yynzzx3HxNwJTC6cwDC/H+oLIro/HzFC + QBRlEggTAsFFRmNWUf9CLiHAOM0K6yYAHDSdXVIAq7CZxjfQnMbJAjQSAA3s1+sIgFqp2qMEgK4ygqBk + mBoqZLwvQD4rvYAgt5OPaf6iAX6fgBDzlxEYAo4q/j9V/fn7BCyNNH+T/C3+XQvBYyWAbDS/JBO3SEBF + CbD8TAABVv8g4RbRX1eCpk8eyUTiSAaic1Xws71yNTP2++JwUbJXAPBG4fJGqFQC0ABgd2htgMXmYfyX + 6i9yKgioBCDmJwSU6XUINDWaYdCVbgX0FGBXA4IeNDMFDDRb8WPn+upCoiX7xlbdhjdnUwN/9k0vr/Xk + finR/I+5tujmlxtZpuK/3NeO0gf+ZF07qf4S/ZX542J+WT13xfwS/aX6a+ZP9f3TFKu/Mr9e+ScPYiRd + +Y+x8h/H5NxJZf6pfacxvXiW3z+JcE8C8YV8JMQoTAExVs0IIRAiAILspVsIAb+CQB5cAgFWX7uYkDLR + /KbJQgWCRlbrepq2Tio3VU3TV0kKGC5C2ZCohBG/SBm+qL8Q+b2FKOS+mN+T75fx58qpKkKgWv0O/i4C + oIEAEPObKDP/po3mFwg5KdcMwUQ4eSkBlQCrRZ43n3/K/ElW/7bDGWhn9Y9N18AXaYPTn4BbpIyvQSCV + AlyEgNNDCHjCND8BQAjY7JIABABelQBEJpMGAINREoAGAcN1CSAFgfSgoMwN0GcIyo1JZEBQ0uBxX4k6 + RtY8dn5NtGRjy23a+C91K96cTU33XePJ/bJ6x/kfEPR61dr06kYVqvrLuvUrvX/qKj+t+uvmT0r8l2m+ + 0vtL9NfMr0V/9v1S/eWUn+r792kAkEG/iWvNPzF7gpX/JI1/ijpD85/DzIHzmD14gUA4g1A3/9Z8MVrF + MIzMcRooxioaoZkEBC1iLgLAM5vHJJCvQYAJwEqJMUVNNGsTAVAvxqVqaP5qqejK/MUopUoGS1Dcz/1A + Mc0vMGCLMMh/o8qHixUsqvn/ain5PQ3yOwkW40ShMr+VCcBBufj3XQSAPB8V+Wn8ZlZ+MX+YlT96gJGf + r6WV/X4H1UnzJyYa4Qt10OxJKqHk1uXy0viEgFPMrwDABMAWQAGAsjMFKACoMQCPlgB0AKQgYDBIArCi + aRUAUtJaAa0NUCnA6lBjAXJasNkfQKglhOfdd6557Py6aMmxYUS34c3Zlhv+5f9CCn201pP7ZfQDx++j + 02OFX+5TJ+aX6q8DQKq/AoBEf1Z/Wd1WACDVP9X7r5zzZ/Wn+WV1HVlsQ8wvvb9cadc3PL9S/ccPYERF + /5XKL+afnNfNv/+sbv77MH/4IhaOPoDpA/ci3N2H5Fw52g/mIHkgF/FFGkmHQFgq63wefGI4AkAM6KAh + FQRYoS3j+TBybyIAGqmG0SLU0sy1TAHV3FcQAuU0edkAAaCriCAoJghKqXKmg0oCQH5WzF9HcAgA5HcZ + pfLzd9v4twQ8LiYAz6yIz4W9v6STAJ9bkM8zwucrCSZOtbHydzD6dx0l0EYt8Ia74KD5nSl5E5SYXhSD + g1J7Vn9JALIOgYNtgM0RYAJohtWmJ4AUACiD0YEmMb/SCgBWQ0ClAO7TEFApwK5uRyY3KZGxgBYeF51B + P75w/uGax9A3XUzdP14233abbsWbsy05NobXenK/jKTvX3SXqNtSSfUXAIj5AwH2/quqvwAglOr9ozLy + 36lWxFWr5LL6y5p5Uv1lOa3O3jFV/bsVAKT6z6H/OvOP0Pyj15hfIj+r/n4x/nnMHaLxjzyAfUcvYf/x + y9h/4iHMHX4AYVmhZ6aWEChE6362BYsEwb48xBbyEKLJWthv+1l5vRK/pwvgnKIxWZ1FJlZrE01rkMpN + ANTT0LUiVv4qRvwKMTqNX9JfQtPrSYAq4/crCIcqQqKaqicE6keKlfkNCi4FCjICG2V+AkhAJIkkQAC0 + MAEEWf3DBECcAEgyvbQxxXQezkHvkXxEhx3wBbvh8LcRAK2w0/wOml8kEHB4dAB4RFEFALuL8d/Nw8EZ + VCsRCQQsegtgtngoN4w6ADTzy96GJrYATToEGmn8piZKB0AKAloK0C4ZTqcAX4BtYARHmit/LW9AsmT7 + zrRuw5uzLVu//b8v2Td8sdaT+2V01blZuycdpaK/ngBaBAA0vygUJABCBEBUqv+qgT818q+tmKuqP80v + S2up5bZ0AEj17x+R6r/I6L9fi/6ThzEyfRRjuvknWPmn97Hq0/wzBy6w6t+vmf/YgzT/Qzhw8hEcOPUo + Dp1+nN97COHOMSSmTGg/UEoIFCO5rxiJfYWEQD7CYjoxH03oZQJwTxIClJ0AsDKqm2laBQFW8AaauI5m + FlXT4JVidKn4BECZMj/3OhTk32pofgFGA/9vI2Xk75FEIb/XzhTgImx8/LsCoGaCKEAFWf1DC1pKiTGx + JJhc2qiOQwXoPVyM6KAHnpYeGr8ddm8bzU95k5o8CSquAUBBQB7rEHATAjoAbA4NAFamALMAQCUAAoAt + gGb8VAogAJT5qcYUALQEkNLqVmD1WIDcxlxSQDQcxUueO9Y8lr6pUnfRct72O7oVb87G6s8jYu0n+GX1 + qfOPEfO4tOhPyQ0qVfyn+dP9v1R/EaO/KELzy9LXshJuQtbJT1f/IbWeniyrpZbaUuf9ZeCP1V96/7H9 + BMABDNH8w3r1H5O+X2L/4hm98t+rmf/og5r5TzysjH+Axj905gkcPnsFR85dwf6TjyLYPo7YhAUdB6vR + uliJ5GIF4guliMwXITRXgABN6CcAvKzKAgEXAeCQJDBWBIsYlwZuYvxvYPUX1bD3r1JGL0G5AgCTQB/3 + VCVhIP8mSaGeEGgiMAQgK+YvhGuykMApUOCRv93Cyh8ijMJMJVG2J5JSkosFNH8Rn3Mxug9XItTXDDcr + v93fAZu3nRLzt3KfMn8CViYAgYBdGV/b290aAGyU1SUJIEjz6wCwemESmT0aAHQINBnshMBKAmgkAAQC + KQAIDBQQdAjIlGEBgDY70A2PRwYDZQGYCPpDnl+rswKM/4u6DW/OtmzY+M/Z+3++1pP7spIYN+2qUHej + leqvAKBXfwFAQPX/MSaAOIIq/mvVXw3+yc0wBABtqeo/mAaALK2lVf8p9A7PEgALjP+L6CcAhiYOYXjy + iF79T2BMjfinBvw088+ryn8J+8T8NLpUfWX8s1dx9PxTOEIdvfAUDp65glDHJKJjLnTsb0T7Yj1a99Ug + Nl+B6FwJQjNFaGEL4KcpvQSAWyq0QICGFQiY2QIYWc0baWpRHQFQQ5NX0/gVusp6S7kvVeYXQNQzJTQQ + AEYxP/+/hQAQqMjv9RA0zfxbgZkCBNn/h+byESGIYgsFTCdFhFQJ2vaXo/NgJXoO1SLYG4Iz2Aebr5OG + 76DR22H1tCkIWD1JiuanLDS91U3jK8Vo+ihsTAA2FwHANsDmCsFGAFgIALNNAOCj+VMAcCsANKUAYLCh + kcZuUNVfSwCNDSvGTynVCqgLhdTlwi64XB54/WwDWkKIRGK42Jz3a3FWgL5bWrZs/GPdijdnI4FCaz25 + X0ZXnXcur5g/qI3++0PwEwDNqQQg5mf0D6rBP633FwDEBADs/eNykwxWf1k5t03if88YZIFNif7drP49 + Q1r1F/MPjh9U5lcAmDlOADD6L5zG1L5zmN5/QRvwo/kX2PMvHn8Y+1n5D6bMf/5JZf5j9z6Dk/c/Rz2P + kw+8gMPnn0ZLm0DAj679TAP7TWwH6hGfr6H5WGGny9AyVUwIsDqzQntofhflYAKw0sDmkRIYFATY0w+U + opamr+a+sk9TOQFQxe/VUHVsARoJAQNhYR4tZooogp0AkN8ncBHQCHCCBEB4tpAQKiKMSmj+Cpq/Ch0H + atF9sAG9hwxo6Y7Q/AOw+Lpg8XbS6ASARwOAJgLATQCkRQi4pPLHCYAYHxMAAgJCwOoMwerQEoAAwKQD + wEgAGAiAJqOLctL4AgC7AkBjo5YAlAiAhgaTDgNTGgIrKcCuJgY5HC649RQQDkXRFo3iE/efrXlsfZNE + 753SbXhztmXnbf94ybHp47We3JeVjPrHnPZlL/u6FQBI9Q8TAGE069U/kKr+KQCI+dXgX7d2UwxW/0TH + gA4ALf7LmnpdrP7dgzNMAKz+I4uM/wcIgEOM/1L9jzH+S/U/xfh/BlOq76f5D2nmlx5//wnG/lNi/quM + /FLxn8bx+57FiYs0P41/8sGXcPrSKzj70Ks4eu/z8LVOIjISQvcBNzoX7WhbMCMx34jobC2TQBWNWY7m + 8WL4WPk9lJPmdXBvY5Q3EwCGoRI00Nx1rPR1AgGaXyQQkL18r54AaOLPmIZLCI9i2Pk7nASAl9XfR7gE + CIDQTDHCMyX8u+VsR9iWLNSoZNK5v4nPzUzz2xHoSsARHKTxaX5PJ9UBi7sdZqU2qpVfJ6kEzK642lvV + XoyvmX9FEVh0AJhtAgANAkaLBoAmBQAxv0MXAdDEFMAWQFJAgzK/BoDUfnUKEADIikLqbIA+GOiXFBAM + sxjEcSRY/41OAfTd8rJ5w1/pVrw527JjQ8MNfZP5u445s5e9evVXAJDRfx0AUv0l/stNLFUCUACQG1xq + 1V/ugCM3wkhVfwGALJ+t1tQXADD+dw1I9Z8lAFj9R/crAAxNHFEAGJ2m+WdOYpzmn2T1FwDMHZLofwkL + xy5jkebff/oJ9vzS72vmV8Zn1T8lxr9M4z/8Gs49/DrOPfIG92/iyL0vwBUbR3Qkip4DAXTsc6N1wYHE + nAXRmSYmgVr0H21EF6twaKoMXprXxRhvJwCsBICZVd1AczcoADAJ0PQ1rP7VVI0OgMbBUpgICvl5O/+v + QMRNAPgnihCYLFZpIzxbidhsNeFTx78vbYmJ5reh56ATfQe9rPztyvwmbzfMBICZAFByd8DkEvMLBFpp + /CSV4PcEAmwDBABKGgQsNL/FKeYPKwBYHCEavwUmAsBo8dP8PlZ/DQCNBgFACgJ2Gj8FgJ+HwOpxANUG + EAAmo02lABkMVBcJ+QJsEUMIh6NIxpN42/NXax9n3wCx+j8q62zqVvzqt+Wq3/h/sAe5obP+3nP82XKz + 9HOren8lAQDNvxoAcu15C6t/iNVfA4AM/kn/LwDQqr+sly9r58sKurKabmf/5DUA6FMAOIRBAcDUUVb/ + 4xidZfVn7z+5yOp/8KI6vTd/5DL2HX+Eff/jjP4y4MeeX6/8UvVPX3oZZy6/SsPT9GL8R96k3sL5R9/G + mYfegDs2hYIGVqfxALr3RwiBZrTNe5CYdSI2bcbZJ0J45MUIHngmgGOPODB1romxvJpAKIeTVd3Uzwrf + RwjQ8LV9ZQSASANCAyWAsBAUdgLAxQTgZoLwUoGJMgQnKxGZqUVspp7QaWICYTvCJNK16CaQ/Og/0gJr + 0k3zD6Nr7AQB0AOTu0tXJ40uAGjX1UYlYXLS/GnFNdH8ZicB4CQABAKOML+m7JIAWmC0CgDE/F4FAIOR + AGALIOZvaBLpAKAEAPWia1KAplQroE4NGpkCZMEQ/WyAx+NnoQiqNiAeS2I+bPlmnhbka1q2bsjTrXhz + tmXbpq03svrLBzXhKF32uP3p6u+j+UV+vf8X8zcH9ASg+n8Z/RcAyA0vOxGRG2EmGf+vAYAs7yU31pgg + AKbU4po9QwsEwKIGgPHDGJT+f5rmZ/VX8X/fWUwtXlAAEPMvsO9fPPkYo79e/dnfH7vvOZy4/wVV+c88 + 9Bor/xs4T+Ofp/EvPPYOzf8Ov/cWon1HUFAfwraGKpQnmlhtO2m+BCEQIQRakJjx4t4rrXjy1S5ceaUV + j70cxyMvhXH5hQDOP+nG4YdsGDtjQGS+mm1BGRpZ+et7BADcEwaNBICRALAyAQgsPCMl8I2Wsa2opPlr + EJ5qQHzWhOScVSWP9n1eQiiA3oNhDByOM/rHscOVj3yTA67IOOJ9h2BMAcClAcBA8xucbWhytnKfhNGR + 5J4pwEHJngAQCQDMBICSI0KFYbKHYLBrADAwARjMGgCaCIAGVn8xf+MqACg16CmgwYL6epOSmL/+OgBI + CpA2wGpJtQG+a9qA1kQbXvfevubx9nXWkm3D+yi/7R/pVrw525J9w5m1ntyX1Wv2/wi300uKN6cTgM+r + VX8xv+r/U+ZPDwDKve3lfvcaAOQ2WHKbrbjcIktumdUpd88ZYQsgN9WYQEcaAPvQowBwQAFgaOoYhqeO + Y4TVf3zhLOP/ecb/+zAj8f/oQ6r6KwCcvoLDjP7H7n0Wxy/KYF/K/BL5aX5WfDH/uUfexlmqc/wsiurD + 2F5Xi7uthdjhKaH5+tC7v5sQ6ETnQivaZyN48KkBPP/mMJ55fQBPvdZDELQRBDE8+lIED7/YgkvPN+O+ + Z/04c9WL2Ys2tB9uhHeySi1jbmQSsDAh2AkB90gZfGNVNH8Nzd+A8KQR8Rkaf85D2PjQvtDCvx9F34Ek + Bg61Y/BIN5onAtjqyMMWWx7yaUov00qgbQaNNL9B5Oyg8TUAKNH8Rh0CRgJAEwFAGR0EAGWk+Y12qf4E + gC0EIxOAwdpMADABsAVoMnpY+aUFcBECKfPbWfVXAFAv5lcyo24VBBr0NiAFAQGALDcuKUCOHxk8Vm1A + JIZEvBXzUfs3LgUs2TdGdBvenG3Z8O3fVhMQ1nhyX0byAQ06KlX1vyYB6ADwKQBIC6ADoGUFACECIJUA + BADqvnirACA3zpD182UZbVlJt2twlgBY1AFwUE8AAoATBMBp9v/nGP8vYPrg/Yz/lwiAhwkA9v6nGP/P + XFWj+1L9j1+U6v8KAfA6AaCZX1V9Gv/Mw29jaOFBlDTEsL2mEZsthbjbXoh73MXsy5PoPzCKnsUBdO3r + Red8Bx5+ZgovvzOPF9+awgtvjCoQPPlapwLB4yoRRJgIWvAgdf9zAdxHnX7Sj0MPuTBxxoS2fbWs+pXw + DVfDP1rP6G+g+a2ITTmRnPXT+CHCJkroJNF7oAMDB3swfHgII0eHUdluxDZ3IbY687GVkCo0soomZ5gG + xtDo7KT5O9DoaFNqkhTgaEWTnQlAUoA9QYnxNRlsUX4/yseUPcLqH6b5g6z+BIBFEkAzGtkCNAoACJt6 + AqCe1b+eAKjXAaAkAKiXMQArza8BIAWBVApQLYCeAiQBqHEAh7SPWhsQYhsQiybQ1tqON3zfnBSw5Nj4 + k2Xbxt/UrXhzNtg3tqz15L6sXnL85bIM4rhp/lT193q0FiAFAF8aAOz9RSH2/+G2FQDILbAJALknntwe + S+6UowFgVAfApA6AOXRLAhjZrwGA/b8CwPRJBYAxAmBq8T5MHxAAXNYAcEKq/1UC4CkcufAso/+LrP4v + s/d/TfX4UvFFYvzTD72F6aNPoMzYip3VRtxlFvMXY4urFFv9ZajqcmHw0BwhME0IjKFrfhCPP78fb7x3 + FK+9ewCvEAQvEQTPvUkQvCGJINUaxJgGQrj8YpCJoAUPPK/tH3ohSEBE8eCzERy7HMTYcR/N7kFi0ovk + VADtczF+3UbYdLLy96H/4CDNP67Ud2gEeyJl2OEvxjZPEbY48rHFXIwSI1NX6wzM/n4aXwDQjgYdAo32 + ViqpQYAAaCIABAJN9lgaAAa7AIDml/hvDaKJ5m8S87P6Nxo1ADQwAdQ3OZXqxPwCgQYb6lT11wBQp2RG + rQ4ABQFJAavbABkHMMm1ATIO4IGHbUAzjxtZHj4aiSPJNmB/9JszFsDqf0K34c3Z4Lztv11y3Ljbey1T + w/aKZRc/OAGA1gJo1V9J9f9yClADQCCgtQCrARCJsv+PdyMqd8OVu+K2yRmAIXXHHAFAW4/cSCMFgHl0 + KQAcIAAOoW9cAHAcQwTA6BwBsMAEsP8iE8ADmD3yEOZY/fcx/u9n/D907mkcvVeqPwFw6VWcvizV/610 + 1Rfz7z/7PGodPdhTZcedxiJsthXjHmcJtvjKsC1YgYx4DWO4AIAJZP8CehamcPWlU3j3u+fxzgen8eZ7 + x/DaewcVCF58e5KtwQgTQT+uMhE8QRA8qkAQxkOEgQwcPv5yAldebScouvmzQ3jhzTFcfXkMDz45gkP3 + 0uwHe9G30IvexSH+zUnCZxpDh6YwcmQOLTPt2BUtxY5wKbYLBJgEttjzsd1UhnJTVEGgyd2Nens76uxt + 3LcRBK1ooPlFjTYBQIL7GJpsKxBoIgAMtjAVQlMaAAECwK8SQEMaAC7UpQBA1QkA6ln1VeVfDYCVFCC6 + BgByNiA9DuBWqwXJ2QAZB5B7QgoAOto68L7nL9c8/r5WIsSWLRu26Fa8Oduy9dv/+UYO/r3p+PdqyWeX + y6sBQElSgDYA6GMC8Pq0FiCgAyDA+N/C+B+k+UORDgUAqf6RNADkTrmDBIDcPFMSAAHQN4WO/hl0Diww + AbAFGDmI3jQATqwCwHlMLF7EFAEww+o/f4wAOPEEE8CTjP/PEgAv4Pj9L+OUqv5vpo1/6vJbOHLfKzA2 + j2JvpRt3Gkqw2VqEu52l2OItw9ZAObaFK7E7Vgn/ZD/NeJgAOEgAzOPJl8/jg48v4f2P7sd7H57DO989 + gzffZyJ474DeGkziuTcEBH24+qoGgsdeofHZIjxN4z/7Rj+NP4KX357Ba/z51/n/3nr/CN7+4BSTxTk8 + 9txJHL14GJNHFzF0YB+GDx3A2NHDqO6zY3eynBAow85QGbb7itkKFBACBdhhqESVpRWe+CTN34E6GwGg + RADYxPxJPk7wcZyPRTEmA0pSgECAAGiyphJACxrMzWgw+Wl+nwJAXaPE/xUAKOkAqKXxlepofpGeAmrr + jGkAyFhAqg0QAMgdh+wyKzA1DtASYoGIqbMBAoBTkdqv/bwAtt2vytk33Yo3Z5Prjtd6cl9K/EDmbPkq + /qcSgLQAqQTgFUkL4GcCoPmbxfyM/4EgARBqRYsOgLCcAYj3MAH0KQBEmQDi7UOId8idcwkAuZde7xQh + oAGga1ASwEEmAJpw/CjbgOMYmDqJ4dmzBMAFTDABTB18EDNHBACPYfHkVRxg/D984Tl1Xv/EA68yAbxO + 07+pzH/y0ps4/sDr8LQuILPKj7say3CnhdXfXsq+X8xfQfNXYEe0igCoQnWPjwA4jt79R9C7cBDPvXIZ + 3/3kMXzwyWUFgg8+FhBcIAiYCAQE7+7HS+/M4oW3xvEsq7wMFAoIniYQnqPxBRCvvD3H9HCIxj/GJHEK + 7310Ht/l7/rwk0fx8adX8eHHV/Da24/i8tX7sHD6JAaYQLKT1cggAPYmK7ArUo7tgRJsUxAguGz52NVY + h1pbB+yhEe7bqVaCgLLS/NaErriCQL01xlRAWaOEQCQNgCaLDgBTM+qNGgDqDV4a341aQqCu0cm9A7U0 + v5IAoG4tAMhjSQBGtgeUngJS8wFklWEBgJPHkhxDqXEAAUBrawd62tvwhetP1j4Ovw6S6m/bYNdteHM2 + dZcfx6YP13yCX0Kf2P9o2Wu380PzKgCkqr+0AWkAsPqnACDVv1kBQFoAAkC1AEwAsS4NAIk+RBQABhAj + AGIdI+rmmZIAWntWANA5mEoAGgD6J05gcPoURubOYXT+XrYADxAAlwiAR7QEcPIKW4CncOi8AOBFmv1V + nHhQA4CY/8SDbyI+eBJZVS24q74Kd4j5Gf3vdpUx+tP8oSpl/l00/+5YNbLitejcd4ix/Bi65w/j+Vcf + xaefPUOjPomPPn2ceox6lOa9TBCcZyU/iTdY0V95dx/bghlG/VEmgmEFBKn6r767SFAcUcCQn/+ASeKj + Tx/BJ59ewSefPYlPv/cM909T8jeeZdJgknl4HlX9dchMVCgA7I6XsxVgCgiUYqunGFschbjbWoAMmqzB + 1QOjfwA1TAQ1lgRqafw67lMAqLPEUC+i+RssEUKAsoTRSAA0moM0fwvqjAIAMb8PdQRArQ6A2jQA7GkA + 1AgAlNYAgIKApABtYpA2DiAA0MYBZI0ABQB9HCAWSSCZZBvQ0YVHg3lrHodfBy1ZN/5w2fAb/1y34s3Z + lm0bN9/IGHXetm1Z+rZU9ddaAC0BiPk9viA8/hBTQFgfBNQA0CwtQChJaQAI6wCIxHvZBggE+gkBAqCd + AGACSHZpAGgjADoG9lGL6B5m/CYAesZSADiNodlzTAD3YWzxfkweuKwAMMcEMH+CADjzNA6eew6HCYBj + CgBvaJWf5u+fexC5tVFsrq7HHaZimr9Emf8emn9rSyW2R6qwM1pNAFQTADXIIAy8owPoXjiJ7rnjeO7V + q/jse8/rek4Z9rPviWFZuT95iIa9iHc/PIs3PziO1989pNqCl96epvEXGPel6p/gv59jxX8AH33ysPp/ + n372lPpdn30uv/NF/s4XqJeol/G9z1/FuecGMfFQC8JH7CjursEeAmB3nClFIOBnEnBpELjHUojsBiea + 3H1odHURAEnUWsT0shcQaACoNQsEoisQIAAazCHUm1YAUGfwUz6a30PTawCo4e+uqbcr1dbbaP4VANQw + BdQQADW1Ju6lBaD0VkA7LWhWVwxq4wB2yK3HBQBSSBQAWsLq1vDaOEAnJlqDWPqa3k9gyb5pTrfhzduW + 7Dcu/i85voOErV4HAPt/QsDlWgGAhwCQm0t6CQEBgAwANjdTBIBfbwGC4VQLQADEuhFOA2AAUUkABECc + AEh0TyKpADCL9v4FdDABdA0dRPeIAOAYU8AJ9E9qABiZv4CxfRoApg8/gpmjjyoALAoAzj/PPv9lHL1f + A4CYf/rYkyhuasXWKiPNX8Toz8rvLKf5K7ElUIXtoWqaitWfANgdqcFe7jMJgpouH3r2nUfXzCk8/9rT + +N4Xr9GYNOcXr3D/IvUC9TwN+xQh8DDbggcY6+9jlT+ltQXv0/gfHGM6OENA3KtA8fFnV/jz/F3q/8rv + ELO/TAiIXuVj6os38N3PCLKrcey/EsbC42GMPBCAZcaEzGQldkeZBEJl2EYISBK4RyBgLkR+gx8Gbx9q + rG2oNidRY06gmgCoMceV+QUCWhIgBAiAegKgXgdAPQFQKwBgC1DXpAGghgBQ5qeqdQDU1NlQrQNAVC3m + 11NAGgB6AkilgBUAaPMBBABufSCwJSAAkHGAVrSzDejs7MabzV+/9QLUvH/7t/+jbsObs2mj/xvfWesJ + fhm9Yv+P6tytfGAycCPmTwHAIwDQIeDVE4BfzC8JIMAWgNU/IC2AJIBoJ9WlzB+O9yGk2gACgAkgSgDE + OkYJgXEFgNbeWUJgAe1MAF1Dh9BFAHSPHkUvATDAFmBw5hyG5y5gdN9FTBAAE4cfxuzRJzB34irm2QIs + qgTwMo5cfI3mfwP7z72IGkcftlfYcKexFHdZS3CXvQybvRXY0lKN7WGaP1KNnTT+7qhm/gwqi48LYrVo + nT2OTkLnhdeex+dfvIkvvi96A18QBp8TBJ9/IQaWyv00PmRbkAKBVPt3aPz3PrrArx9ULcMn35MU8az6 + +e9/8Tq+//23+Hvkd73O3yN6g3qLAHgHL7xzDkefjBACUex/IkIIRDD9aAixEy7kt8vzJQSChEBzKbY4 + CQB7PraYylDYyH7e3asAUC0AMCVQZYorCNQQArXmKFNBlCCIoM4UpjQA1BoDqGH1r1XV30vzCwBcqG6g + 6gUCDgWAagIgDYFacxoAmlalAB0CkgJk3QBZTFQSgNx4ND0Q6A3wWAmpMwGxaBJtAoCObpyJNXztBgOX + 7N958qbO+5dt2fztPxUSrfUEf2HxA9hvzdQGbRweNQbglDZgNQDcegvgWwGAXwdAc0uCbYCMAbQjGBEA + dCMU60GIEAgqAAwiQgBE2oaZApgA2AJoKWAGbUwAbQRAx+ABDQAjR9BDAPRNnkL/1FkC4F4C4AGM77+M + yUMPMwE8htnjV7Bw6mka/nkcJAAO3/eqki08jV3lHtzZVMa+n+Z3lOFuD6t/cyX7fjF/Dat/DQ1Vy+pf + S/PXIJPKZgLIi7ENGBlF58xFvPD6SzT+u/j+D1J6mwZ+gxLjvsLqLRB4Ro0PfCwg+FhrCwQIH0vc16P+ + ex+8gCvPPY3nX3mJrQDNr4BCEHz/Hep96gN88YP3cfnlUZx6KoZjT8Zw6GqMEIgqCMw8FkH3eR9Keuu0 + QcFgOVOAQICpxlaAbU2VKDWwyju7UWVcAUC1UlRBoNocQa0yf5j7EKu+BoBaQzNqWP1rGjUAKPMrADhQ + VUfz6wCorrXqANASgJK0AKvbAAEApcYB9BSgAJAeCNQAoGYEqglBSbQm2tHR3oXBzrav3YIhy/ZN1boN + b962ZNvgXevJfRn91P47CFia1IflIACkBZDq76b5U/J4NACI+T1qDEAAINIBEGxFIA2ALgQVBDQAhJL9 + CLdqAIgSAPHOCcS7JpEgAFqZANr6ZRzgIDqHDqNz+Ai6xwiAidMKAIOz92Fk4X6MLjIBHHwYk9IGHLuC + eQJg35nncODCSzh07ysI9R7D3vJm3FlfiTvMpdjMyn+3pwJ30/xS/bfpxt+laze/ziQQcgiA3JgkgGrU + d/jRNfswXnzjLZr+Q/zgh5Tsf/AB9R5+QON+/wdiYonvEuOfU4N6H336hF712efT+N/7/CW8/+ELmDp6 + H1uK+9A7d5HgehCvvvUq///7uj6k+T/EJ5+/gXufS+DsM3ENAk/FFQQWVRKIYubRMPrvD6Csr47wkjMD + TALeEkKgSA0K7m5oQIWJ/b+tA5WEgACgykjjEwDVJtlHUG0U81PGECt/C6UlgOpGH+Wl8d2oovmrWP2r + BADK/HaCYAUASnoKEAAoCFwHAEkAKQBoA4GOlQlBcirQH4TcLl4AkCQA2ts70dXVi5cCW9c8Lm9JOTZ8 + ivp//T/rNrx5G/v/y2s+wS+hl+x/oZZz0gDg1s8CEAA6BDzuVQmA5pc7zgoAvM0x+AgAv54AAqF2poBO + ml8A0KPUwjYgmCAAkoOEwDDCbSOIdowj1qkBINm7gGTfPrYBB9A+eIgAOIqu0eNMAaeYAs5iYPZeDM/f + j5HFSxg78BAmDj2CqSNsA04+hYXTz2L/+ZfQPX0/sqsj2FxTi9tNxbjLVo7NLlZ+fyW2Bmtofon/tdhJ + ifH30vgZVBaVS+UTAIUEQFm8FsnJ+/Dym+/hhz/6Hn74w8/wox99yv2H1Ef8nuxpXlbxVBqQ3v7Tz59N + 9/qqVSAgLj72KNonz6F99n50zl1ia/EAJo5cxnc//oC/h79T/f4v8MZ378cDzyd0CCRw6mlJAhoEJAnM + CwSYBPru8yO/kykmXKEgsEUgIOMBcmagnua0tKPK3IoKJoJKAkAgUGWMKCkAUDUCAGMLqpuaaXw/Ta8B + oEoAUO9GZZ2T0hJAVa0tDYAqgYAkAAGAkg6AWiP3Bg0C+jjAWgBwrDoVGBYARBJIJNrQ3qYB4ETC+LVp + A5i6+3QL3rxt2fw7/2TJvvFHaz3BX1h84w9Y9iynAKBaAMZ/kRoHUAmA5vcEIfeZ99D8Xn+E5o/qKUAH + ABNAswAg1IGWSBfVTa0AIEgAhJJDhMAIIu1jiEoK6J6h5gmBfWjtP4A2AqB96Ag6R44zBZxEz8QZ9E9f + YAq4qObyjzAFjB14hCngcUwfu0oIPIPxw1dQ1NSGLZVG3G4sxp1W9vxOVn5vFe4JsPKHJPbXYnuIlZ/7 + vQRABhNAJvfZVB4TQCEBUBwnABJsAwYm8MqbH9H4P6S+oD6nCIIff0LTyvc/YjJ4n4ngHYppQMYHWPFl + fEDMr3p8VvX5kw+idfIi2mYuEwICgIeYBh7BY8++of/e7ys98/okHnoxgQdeSEEgjpNPx5kE2A5ckYFB + tgNMA9OPRhA/6UJGvJKvpRzbmpkE9NOD91iKkFPnRrW1DRXGOCEQVao0rACgyhBCtSGIqqYWKoAqHQBV + DQRAvQeVAoB6lwJAZa2dIgCUBABifovaV9WYuRfjUzXavqbOqE4Lps8ENBIAJg0AFh5TdgJAEoCsIxlq + iaopwfF4qwJAZ2cPBrs72Abc+rcYX7LLkl8bfl+34c3blm3fvhPOtZ/kLyoZ/Y+Ya5YVqe2s/gSAEDsF + ALerGS7Gf9cqAHh8BICfAPCvJAB/CwEQ1AHAFCAQCAgAohoAWhIDCgAhAiDcNoZIxwRiXdOI98wxCUgK + 2E8IHCQEDqNj+Bg6Rk6ga/w0U8B59DNGD849gCECYPTAwxg/9Bgmj16lnkSNcwA7yhz4m6ZS9v2lqu/f + 7K1U5t9K82+j6QUAOwUA1B5KKn+OVH+aP58qjtew+tegMlELY3sLXnrrY/z4xz/BT378Y+5/RP2A+gI/ + Jgx+rCo304C0B5IGfvC2gsAXX7zK1uANfv0W24K3CKlLaJ16kAB4mHoEHbOPo2P6cRy68AJ+8pMf0fw/ + ZFJ4D1df7cGjL7fioZeSTAJJ3CcQeJbtACFwVE8C0g7MMgkIBKyzZrYyFdhBCKg5Au4S3GMvwD3GEhTW + s7pb2lCuA6CiSQNAlSFM84dofA0AlY3NqGzQAFBZ70UF4VFR56K0BPBzAKjRzU9VCgBqTJSYX5IAAUAJ + AFbmA8hAoA1yt2GrVSsqcipQFpMJtmjXBMiVgWogkADo7u3D64G71zw+byURAA/iW9/6O7oNb962ZN0Y + WesJfhl91/4nsKp7vGlzt2UMQAHAKSlAABBQCcBFuQkBr3cFAF4CwN8cJwRWABAgAAIEQCAFgFgfAlQw + McgUMIQg24CQAKB9ApHOacS656gFxHrknv8H0TpwGG1MAQKAztHT6GYb0Dt9L1uB+zG4cAlD+wQCj2Ly + yFU4YvPYXe7DHfXlrP4luNNG87sr2ffT/EGp/rVKOyiJ/rsJhL2Egar8Ev316l9CVTD+V7c2oT5px/Ov + vakD4Cdq/+OfEATUT3T96MeEwI8+JgS+S8n4wLus/m+pVCD9/affe18NWCanHkHr9BNom75CCFxF+/RV + TBx9jv9XoPJjvP/xE3jmjUFcfa1Lg8CLhMALyXQ7cFJvBw4wCexjOzBHCAzcH0BhVw12xdgKSBLwaYOC + m9kKbG+sRHFDGJWmJMqbNABUMAVUNvF7TSGlisYAKmh+kTI/q395CgC1TioFAKrGqokQqCQExPwpAFQS + AAKB9GAgzS9KA6DJmgaAHFMKAL4WyP0j1anAeBvaktqZgK6ePtwbr1vz+LxlJC2KbWOubsGbuy05N15c + 80l+CV223MGoJrd30k4BivkdchaAANBagAD3lEAgnQIilAYAHwHg1QHgD7axDeggCAQCGgCao70UIRAf + YAoYQkuSAGgdQ5gACHdMEQKziHYtMAksItF7AIn+Q0gOHiEEjqN99CQ6x88QAhfQO3MR/bMPEgKXMbz/ + EcQGTyGjMog7a6pp/lLcaSlj9Zfz/VVa358yv17996j4z+pP5RAA+dFaFFIlhEC5mD9J87fa0JT04MqL + j2nG1yHw85Jk8DmNzLbghx/j408+wAcfvIfPPpOxgw/x2fc+IgCuIjH5BCFwhbpKEFxFG/cjB59hUvgh + //+P8NYHZ/Di21NpCDymJ4H72Q5ceC6pksDxp+JqjsABtgL7CIDZx6JwL9qwhwDYSW1rKcNWTwm2yOXN + 1nzsrmtCWaMkgLiCQLlAQAdARWMQ5Q0BlNcTAPU+agUA5cr8TpTX2FFBaQCwUVZ+bUFFtWZ+DQCyFwAY + VBsgENDGAbQ2QACgnQlwpAEgk8qkBVAAkFOBsVY1JVhmBAoAZrpjKo2udYzeClKLfjhv8qIfsi03/eb/ + sGTb+NlaT/IXFqk2acrWVnEhAGQMwG7X4r/DIQBg/E+ZXymobjPtljZATwApAPgCyRUAKHWhOdyN5kgv + /ARAc6yfEBhEIDFMCIwg2DaOUPskQh3ThMA8ot37EOvdjzhTQHLgCHWMEDhBCJxmK3CBELiXEHgA/TKg + Nnkf8uvi2FzZyOhfjDvMND/7/s0evfqHqlXPL5U/Ff0180vfX4vciGb+YqqM1b8q0Yhamr+xzQdTWxiP + PnuOFV+r/Jrhf3qd+D3+mwzkffTxd2l+AuD9D/DOO+/g448/wPe++AITB59GfOKKUmJSU5Ia2PckAfED + fP+Hn+Dt757Cq+8eUOsOPP36AK4oCLSlk4BA4PQzcZwgBI7IRKEnYmpQcIgpILetGrvilWpQUMYDBAKy + xsFmUz6yaN40ABoJgMYwjR9EWUML980oq/MRAj6U1Yr5RS5NNQ4FgBQEKgiAilUAqNABoFRNAKixAGkD + DHoKIAAatLUD5Z4CMg5gsWjHlAAgnQB0AEgC6GjvRndPL/r7B/CJ7z+sfZzeAqLnoroFb+62bP/2H9yo + EVP2NAgaa2BRUU0HgLQAqg2QFkAHgA4BNwHgVgCIUBoAvDoAvASAjwDwsw3wMwH4g53wEwK+cE8aAM2x + ATTHh9CsIDCGltYJQmAKYaaAcOeCDoEDhMBhJoGjTALH0Tp8Cu1jZ5kEzqNr6iJ6Zh5EhbUH28rs+JvG + EvyNDPzZynG3pwp3s++XU35baXg16EftDkrfX4dMKptfi/kLKM38taiMN6AmyYO2zQtjB3vsjg489twZ + ZW4tAVxvfk0/Yoz/6KOP8d3vCgC+i/ffIwDefhdvvPEm3nzrXYwfeBrR8ScQIwBECgRUvw6A733xupo7 + 8NYHJ/HKu4t4/q0JQqAfT7zaqZLAZULg4vNJnHs2gdMyKKjGA7RBQYFA41iTupJxF7U9zFbAX6pmCW5m + CrjbWIT8Wpq8Kc40QPNTZQoAAZTVCwD8CgJltV7KTbkoqf4rACivFvNT1VZ+beHXBMBqCOgA0MYCZCBw + BQBaApDJQA5tMhCPJ5dKAKFrE0BSmwvQ3S0AGMSz4cw1j9ObLVlsZ9n27d/WLXhzN9g3Ft8oAHxs/yOY + DWYFABkEtNvdOgCYAAgAh9PPVmAlBSjzswVwe1cBwE8AyL3pBQAtbUoCAB8B4BMAhHrgi/Qp+aM6AOLD + TAICgHG1Vn+oXQNAiIp070e05xAhcARxpoDk4ElC4AwhcB6dE/fBHJzCrjIvbq8vxd8YWP0Z/e90VOBu + Pfpvl4G/YJ3W91My6JdBqehP4+dTRYz9JTR/Bc1fneRB2+qGoSMMa1cHnJ0DuPr8/Wqizo/XML7ohz/4 + ET75+BN8+OFK9X/v3ffx9tvvEABv4dnnX0S07xzCo48pCCjpIOibl4uBvq8mE8kFRu9/eB/e/OAYXnln + H55/cxxPvd6HK692qDGBS4TAfc+3shVI4ORTiTQEFp+IInbMhb00/55EJXZGtVOD2kVD2pWD2xorUFTH + yM92oLQhROO3oLQ+gNK6ZpQQAKUERCkBUMoUUFpDANQ4UVotANAgUEYAlNP8ZQKA6hQATLqMCgDSBqiz + AelxgFUASM8G1IqKXF8iCUBuIx8OxxCVqwJVAiAAunrR2zeAc21mrde+7ji92VpybDyp2+/mb6RR71pP + 8svoKetfwWiQddx+HgB2BQE/1axBIN0CiMIKAB4dAB6/lgC8gVZ4W9oJAQJAFNQBEO6FVyAQ7YcvNgh/ + bAj++Aiak+MItE4SAlMIts8j2LGAcNd+hLsPINJ7mDqKeP9xJNjvt46chb/9ADJV319F85eoCT932ctV + 9L9HDfwJAFZFf1b/tPkpMX8hJeYvj9Ux+ptQR/M3tQdh6WyDo2cQ7u5xPPnCQ5CpwCtjACvm//73f8CY + /yk+/OijdPV/77338e6777Hyv4XXX38Tzz73Enytx1AbOIzg8KOIjD2BiECA+975q/jk00+YAF5Wswll + 9uC7H57HG+8fVRcVPf/WqLqs+AlC4JGXWvVBwaQ+KMhWQAYFCYCB+5qR21qNvXG5qIkQ0OcHbPPK9QIF + 2GzOxe66RjUoWEqV1LVQAYoAqNUAUFLjodwoqRbzO2l2B6WZX5OYfwUA5TR/OY2fBgCVOiWoxgHkTIC0 + AHoCMBp/HgCSAAQAWgLoQHtbFzp1AMz1JrF8q40DqMG/Dffo9rv5240cADxh2pq+oYNcuWWz6WcBHF5l + frvj2gTgdGkDgQIAF9sAl0DAF9MA0JxkCmiFW0FAA4C3pRNeQsAb7IE33EcI9MMTGYA3OkgQEABMAc3J + CTQTAoG2WbQIBDoXmQQOINR1EOGeI4TAMcQGTiJMGOTXx3E3+/6/birC7Sbd/DLqz+q/hebfSsOL+VX0 + p/Yy9qcAkCfml0E/mr+M5q+MG9n3O9n3t8Dc2Qpbdz9cfeMEAPvxl55QU39/pE7/pcz/E3zx+Rc0/yd6 + 9P8wHf3F/O+o6v8mXn31dTzz7IvwJI6i1L0P5Z598Pdf1iBA9cxdxcefvk/AyMVGclXgU/jux5fV9QTq + EmOBwJujao2BJ15px0OEgAwKCgRkPOA4ASCDgjMPBVHRw9cYr1IpQCWBiCwiIhOEtFmCm435yKy1o6Q+ + pABQTPMX0/wlNH9xjZfyUC4CwKUAUFLl4J4AqLKhtEqr/kpVFu4FAKtTgEkDgEoBMilo9RjAdQCwrQaA + lgAEAEkBABNACgCDg0P43Htr3UFoyb7xVbnuRrffzd1Q/K2/r0Yj13iiv7CcmzBszNUAoG7vrAFABmzs + dq+WAAgAkXM1ANwhOCkX2wABgFsHgIcAcIsCbUregAYADwHgaenmvhceQkADwBA1DG9sFP7EODVJCMxQ + cwi0LxAEi2ghBIJdhxDqJgT6jqHS1oPt5Xb8dWMx+/4SbcKPqwL3+Nn30/xbaP5tNPwO7nezBcig6TNp + fpH0/fmRGr3vr2P0b0JNws6+vxmmjgRsPAAdvaNw9U7D27OIZ15+Sp3a++GPPlMpQPQ5zf/JJzT/xx8z + +uvV/31Wf0b/d995D2+99Tar/+t45ZVX8dQzL8AdP4IS5zyK7LNKrq6LiIw+ga7ZK/j4E7m24C01cUgm + EH3yvafx3U8EAmfVOgIvvzOL594c1s8MaIOC9zMJyHiAzA+QMwP7H4+gabQJmfFKZCSrtEVE5NRgS6lK + ATJBaLMlD1sMhcgToxMARbXNKKohAGo0ABRVs/ozARTr5tdEYOgA0ETzK2kJoKzKiHKqgqqsNuhnA1bO + BEgCEAioQUABgFk7ruSMkqwoJQkgFNJagGRSpgMTAJ296Ontx+DQCN4Mbln7eL1JWnbc5EU/Vm/6bb9/ + ttYT/UUla/9FDZUKAKkrtxQASGu7JADVAjSrFCB7ByEgAHDqZwKclMsrAIhrIgTc/iRczW2EgaidiaCD + 5icAmADcBIA71Ad3uJ8agIcQ8BACvtgYvPEJ+AgBX3IG/tZ5NLctEAT7Eeg8iCABYGwex95yH26v0/t+ + mesvfb9Xm+evJvzQ6BL/1Sk/if7hGmTxcU64Tu/75ZQf+/5YE6O/lX2/j31/jH1/Dxzdw3D3zsDbvx8+ + th7PvvKCug7gR/pA4GeffU7zf8rKz77/mujP6k/zS+//5ptv4rVXX8PLL72CJ59+Hq7YIRQ75lBgn0G+ + ZRp55glYW88RAI+zBZALjN4jBLSZhJIEPvlMksAltfyYLCH20tvamQE1R+CVVlwiAO5Tg4LaTMGjTAHu + WTNyCIBMAQATwO5EBXZGtQlC29yyqGgB7iYEtjdUIL/aT/MTANVifh/3HgWAoioXiquc1AoASgmAkhQA + GP9LK806AGQvbUBqHODaFCAAUAmgUbursNxiPHUWQM4sefzaGICsCaBaAP2CoG4CoLdPA8AT8bI1j9eb + oSXHhh+I53T73fxt2f7bfw7njemRfmz7HdgaG9UYwPUAsKVSgF3GAtgKyDjAKgCI+Z1sA5wepgBvTIdA + Ai4BgL+VYgogANzNBECgk4mgC+6WHrhaeuEiBFyhATjDg3BGhuCOjMATG4eHEPAmZgiBOfbP8/C3LaK5 + /SBc8XlkV4ewubqG5i+k+eUSXy3639MsA3/ahB85358a9d/LvVT+a8yv+n4xv4XRX/r+CKN/F+zdI4z+ + NP8AzT9wFP7eE3j+1VdpfrkO4At8+umneuz/iOb/UIv+BMB772vRXzO/9P5a9X/xxZfx5FPPwRk9hELb + LAqsBIB5CrmmcWQ3MWW0naDZ5ZoCuciIICAEPv++XGH4HFuDK3j/4/v104P78IKcGXijH4+/0oGHX0ri + QX268Bk1XTiGyAErcmn8LAIgI8k2QNYPiBMCamXhEmx1yipC+Wo8YE9tIwoIgUICoKDKi8IqD0UAVGoA + KKp0cG9HcaWWAAQAJZU0P6t/CgBifkkAIgFAaizgbweAHWYFAO3aEkkAAb0FiKoWQEsACgBMAAODwzjf + 5VLpdK1j9qvWku0707r1bo1t2Xpbzo0aJf3A9icwNBq1O7sSAGYdADYdADZ+aCJV/ZUCTAEt3AsEpA0g + ANgGOJkCXN64JgWBVjgJAKe/nY81CAgAXGwDnIFedZtrZ6hf3fHWGRoiCEYIgTG4YxOEwBR75xlqHt7W + BaXipiS2VZjxNw2FjP5F6kKfu2XQz0/zy1V+rP6pU34y4p8yf6rvL2D0l8pfFqun+c2oa/WgqS0EU2c7 + zT/M2D8LDyu/t/8w/AMn4O87TQC8zgTwPRr/Y834jPwffijm10/56eZ/5513VfRP9f4vv/wKXnzhJVy5 + +gzs4QPK/HkWMf8kcozjyGoaQYmV/f0zz+JHP/5MzSRUswe/L2sDvApZMUjODMi6AnJmQFYYkjUGn3yt + hxCQVkCuGZD5AQKBGDqOu5BPAOQQAFk0v7QCGanlxILSChSpRUXvsebiHmM+smnw/EqvAoAGATcKCYCi + Sh0ANL8GABEBoCBgViqtFPMTApUCAAPbAIPeBshAoHZxkCwUou4foAPAaHLoAJAxALm/RGomoJYA1BhA + W5e6IEhaAAHAgYG2W2PJcHkO1m//B916t8YG+0a+m9c90S+pF63/EU2NJh0ANgUAmbV1PQBskgLUgKC0 + ARoA7EwBDgLAISlAASCmAOAkADS1wuHTIOD0d7At6ISzuYsA6IGzpQ8OUZAQCA3CERpWEHASAs7IOKPz + FPvnWbgJAVncY3eZG7fXl+in/EoY/QkAn1zlJ5N9Vkb9UwDIpPG16L/6fL8+6Jd0su9vgbFDBv0G4Gbl + 9/QfWDH/4Fk0953Dsy+/oQy/YnyKxhelB/1o/jffTJn/Nbzy8qt4idX/hRdexBNXnoYtdICxf5rmn0K2 + mN8wisxGAsAygvMX7sOzzz6DH/1QZhLqEPiBNibwmToz8JAaFHz9/SNsBWbw7JvDhED3ykzB5+M491wc + vadoXgIgr7UK2QSArCCkkkBCVhbWILCdEJD7C9xtycW2hhLkVboJAQ8BoCWAggonIaABoEgHQHElEwBV + XKmlgBKaXwFAWgACQMYA1DiAngC004HXAUC1ljIP4FoABNRZgFUAYAIQAKhBQLYAUyPD+LHrD9Y8Zr9K + Ldk23PxFP67fYNswvNaT/TJ6yPzXaFwNALM2bdNmZQoQACgQEACqBdABICmAALC5BAAhgkAgECUEdAB4 + EzS+6FoAOP2dcIiau+FgCrAH+mAnBOwtA7AFB2EnBGSlW0d4nBCYgCMyBVPzKLIqg7irphK3M/rfaS7W + F/iowBZG/9RVfnKFn4z4i2TgT2b7pc73a6f8alTfrwb9WpthaE/A2s0k0svE0b9I8x9h9Kf5B86gefAC + 3F3n8MiVl9PVPiWp+qnTfavN/9prjP5i/pc08z/33At4/ImnYGlZRI4y/wTNP4ZMxv+MhmEUmxlzL1zE + gw8+iKtXr9D40g5o1xN8//tv43ufv6JOD8pqxG9/cBqvv3cQL749jWdluvCrnXj05SQuMQncRwAMn3Oj + hH1/AQGQ2yqtACHAx7KysAYBtgIBub9AEe6x5eFucw521VUjt0IgQPOz+qcAUFjhoOwoqrARBCKrDoCV + BFAq1V9JEgAhwP1qAMhKQSsAsKkEYOXxJGNKcll5ahAwHCIA4tpU4OsBMDY+iU/9N/meAaz+y5YNlbrt + bp1tybnp5JpP+EvopPEelQAMspSzGqxxqhFb+cDS5qesak6ADAQGCAIRUwABYHdSOgAcBIBTB4Cde7sv + qQBg91K+dj7u4J4iBOz+btiae2EjBKyBfthaBqkhWFsIgfAYK+e4UkF9lNHfgL9pLMTtKvqXsu8v18yv + T/hJAUCMr0b9xfzcp075FatTfg2oZt9fJ4N+7XH2/d2q73f3zcPTd5DmP6ab/zyc3edgiJzEQ0+8rCb3 + KNNfZ/y330r1/G/o5n9FmV+i/3PPPc/K/hweIwDMgX0/Z/49dYMoMg3hnA6A+++/H4899gi++EIuKiII + fvABgfAOIfCyWllIVhPWxgP2q6XGtfEAtgLqysE4Ju/1oIyRv7CtEvkEQC4BoJIAH2fy+7Kw6K5QCXb4 + irDNlU8I5GKLKReZrOR5FWwflJwKAgU6AKT6KwBUaAAoZvslCSCVAlIQSM0HUClAzgLQ/KkEILcUb5QE + kDqeeBxpANCuBZAEoC4Gau3UAEAgrwbAW+Ftax6zX5lk0Q/Txv9Rt92tsxEAV9d8wr+oSLgFwy6VAFJ3 + c1HXbq8CgDUNAZ+WApgAbJQAQBMB4JIUEIGdELB7YoQBza+UgM2bVACwKbVTnZp8BICvB9bmPliUBpSs + hIClZYT7MVSY27Gn3InbG4poflZ/SzGjv76qb7CKxteW99pFw8tFPqry65f3ygIfhTLTj0r1/dqgX5jm + 59/vHoKzZ4rml75fqv9JVfntnWfRQPM3BI/j0mMvKsOnJcZ/5232+9q5fjG/xP6XX345HfufZ+UX8z/z + 9LN45LGrTDALNP+Ebv4R7Kkfwu7aARQaCYDz9ykAPEAA3H/fRTz80CV89pksFKJdZiyXFX+qBgUfx3sf + 3Yu3Pjiu5gc8++YIrrzahUcJgMsvxjF9rxsVrRUobqtCASGQR+W2VSCb+0x+fy9TwJ5YmYLAToGAkxCw + ZmMrE1U2TZ/H91gBoNyhAFCgJ4BCmn8FANICEAIVhECFEaVUGgCqDZBLg1eNATRodxJeKwH4FQCiBEBC + AUBNBGrvVgDo6x9UABgfn8Lzsfy1j9uvSEvWTT265W6dTfqRJfuGt9Z6wr+wnJswashWAEjdzEHWcU8B + QIMAq78OASshYLX7FQBsDi0FKAA4Q7AyBdgIAaskAR0ANgGAOwGLJ8nvs98mACzeDgUAq6+Lj7thJgQs + /j6Ym/upAWqQVXMY9a4+ZFc2Y3NNGe6Q6K9W9S3F3d5ybAvIYhj6op6s8nu4l8U9Utf357HqF7LqFzH2 + a/P8tb6/sS0IUwdB1NVP84+z+u8jAA7R/MdZ/c/B2nYKtcGjqAsdR33gGB545Hl1YY9M7pGKLwN9UvXT + kf8Vred/8cWXrqn8zzzzLJ566mk8/OgVGPxz15h/V+0gNYB8wwDOnr93BQAXL+K+e/n1A/fjk4+1qwnV + 5cV6K/DhJ4/gHRkPeO+wunLw6dcH1fUCD7+UwOQFF6po9BIavpgqpPnzqRx+L4v7TCqjTSBQip1sBba7 + C7DVzhRgycauesKCxs9LAaDcrlSYBoCFMqsEUKzMvwoAIhkIlOqvA0AGAq8BAFOl0aQdTzKpTNaW1BJA + FBECIJFo1xNANzq7+64BwBPtddog3FrH7q9Ycpp92fbbv6vb7tbZ5FJE2BlN1njSv7AIgK6mfH5YhjQA + ZBzAJCnA4tIhwBQg0lOAAMCqA8Dm0ABgE+kpwOaOwuqimASsAgEBACUAsHjaKELAQwAQAhZvF8wKAr0w + EQImfz81AIN3AAV1UWyvbMTtjXm4I3UvP085tqolvaX6s/KzuqtFPWn6axf30Ob5q8U9ZLJPUpvsY+zk + c5HJPj1j7P1naP4DWvQfPAtT8gSqA0dQEziqyXcYFx96Rhn+rbfe4v5NvEnjv6FXfTnVpyI/zf/C89Lz + a+Z/+ulnlPmfvPoULj/8OJq8MyuVn9FfzL+zph/5TRoAHnjggTQALt57H+69cAEX77sXH34o6wrIHIG3 + 2Aq8xFbgSbz/8SWmgFPpi4aeeq0Xj73SivFzLtTQ5OXtlSjlvkiHQEF7BdMAkwD3mW1lCgC7wkwB/kJs + Zyuw1ZaDLeZsZFY1KQjkK9mVCnQAFJYLACwaABj9i2n6YrZk0gIoCMgYgGoBrgOAGgOwqVOAqRZAAKAS + gFwMFIwhJAlAB0BHR086AQwNj2J8YgoP9jhvJgDu0y13a23L5t/4J3xyP1nrSf/Ccn4HMcbrhgZj+tbO + cipQAGBWH5oHlhQEpB1IAUBpBQIpANhckgJ0ALgJAHecjymVAggAdxvM7naYPR0KAmbK5OlWMnp71fr2 + Bl8/yo1J7GUMvZN9/x3GAmy2yL38SrDVX4HtjP47I9XK/Hui1WpdP7Wir5ifKmDVL6LxS6mKeL26wq++ + 1QtDRxQW6ft7RuDolegvA39HCYDTMMSOocJ3EJX+Q9RhVDVT3oO499LTqtq/8cYbeJ0V/7VXtXP86jSf + XvVTkf/ZZ641/5UrT+LyQ4+i0TNN8w/r5h9U5t9R3Yc8AuDMOQJAN7+0AJIALhAA58+dx4Xz5/Huey8r + AMipQVlhWG4l9u6H9zIFHMVL78zh2TekFejG4DEbatvLUdlRgTKBAA1fwseFAgAqh8piAshMlmFvvBS7 + Q0VsBQqxzcUUYMvGNkMecmn43DI72wEBgE2pQAdAIc1fWC7mlxRgTCcArQ3QBgIrZXEQQkAWC03dSVji + v8GonQKU40clAE8Azc1hBINsASJJAkAbA1AA6OlD/8BQGgAXBkLqGF3z2P1VSgb/bBv36pa7tbZl66b/ + c80n/WXEFxqoLyOtDQoAKgUYtdM2AgAxfwoAFj0FpCBgWQUAq4gQsKpWIAKLk62AKwYLJQCQBGB2Ue5W + SoOAydUBk7sTRncXAdAFg7sbTZ5e1Do6kVPpx9115bjTlI+7rUXaXXy9Zeouvjsj2s089sSq1Vr+yvzc + y6q+yvz8fmm8Wq3sU5U00vwumj9E87fD1jMIZ98ko/8CzX8IXvb9DZFDKHMvotxzQKmCxldy78f5B66q + qP+qRP1Vxpdef3XVT0X+J598GleV+a/iiSeewIOXH0a9e/I681NVfcht7CcALuCBi3r1v0+r/qIL587h + 3JmzOHf2LNPH82osQG4iIhD44JOH8fZ3z+G19w7hhbemmQL60bHfhnoavrazAlVUOR+XUkU0fr5AgI9z + qOz2MmS2liFDIBAswg4fU4AjG1stWXyOlcgRAJRp5s8vtxIAFrYDNL8OgCKBQLkGgJVxAA0A14wBsPpr + ALBrADDLaWVZYr5Z3VnKHxAAxBCNJlUL0KrWBOxFtw6A4ZExTExM4/RI+01JAOo+G8X/9B/qlru1tmXn + b21Y60l/Gck0YG9dBQGgJYAUAIwyIUgAQHJbLISASCUAL/eUAMAmKSCgSUEgSOMTADS/AMDCFCAAEJmY + BAQAJleSaqXaYHC1w0gIGF0aBJpcXWh0dqOoNoQdlU24y5CPuyz5apmrbX45l62bP1alzL+XZs/iPofK + o8T8qTX9KhI1NH8j6lodaGoPwNyZhI39paN3TI36exn9Pf3HUBvaj2LnAkpdi+qCnVKCoIzGL/NQzkWc + ve8JZXqZ1puu+M+/kDa+Mv/TuvmvivmfVOZ//PHHlR548CHUuSb02D+gmZ/Vf3tlL3IaCIAzAgAx/0r1 + l8p//uw56izOnj5Dncbrrz/LFPAaIfASPlKtwANsBU6zFTiAKy8NIzxhRWNXFeq7KlDTWY4KAYAkgY5y + FBEIBdzn8fu5fCwQyEiWYk+4CLv8BdjhzmUroEEgS1qBUqsCQF6ZmF8HgDK/+W8FgLogSJlfWy68LgWA + JjuPJy0ByBiSAoBPA0CIAIgwASRSVwIKAHr7VwAwOY1j4/1rHre/ai3ZNgV1u91627Lltj+8UVT8GeUk + +SUBpO/tbtAAkJq9lQaApABCwGz1wmzzKQBICrCsBoCDlZbmNzsEAlGYnTEYHTHuNQAYnUlNhIDBKRDo + 4L6TEvN3qdVrMiuc2Mzof6eZ1d9WiC2uUmwLyLlsOZ1VpS57zaSyCIJsmj2Pjwuo4gQrP6WZvwG1rRY0 + tvtg6ozR/N3s+Ufh6ptl5ddG/Wta9qHIPqdU7FhQIChx7kMJYaBkm8epC48r00u114y/Evel6kvkl6ov + 5k9VfdFjjz2GRx99FBcfuIRa5/jPmX9bRQ9y6vsIgPN69L9PAUCr/hoAJAEIAE6fOk2x73/lSXz2hZwW + fBbf/eRxtgL34Y33j+Ph58bhHeTn1V2Phu4K1BEC1VQlzV5GlXSVo5jmL6DydABktZUiI1FCCBQSAnmE + QA622TOxw5iPPLYCeWXWFQCUCQCospUEkIJAOgEoAND8lNw6TFoA6f8lAQgA5PiRi8pkZWkZAGwORBQA + ogRAMrEyC1AAILMAR0bHMTk1g0NTo6pIrXXs/qq05Njwk2Xbb/8r3W633rZs3fjvbhQAfmr/Dux11air + a1IpQACQWstdruCSwRuJb/IBmpUIAMrCNkAAYFYQCFAEgJ0AsIdofooQMBEAJkdUAcBEAJicCTQ5KALA + 4GzlY4oQaHS0c9+BWmsb8quasaW2AneZ8tQKt7LS7fbmMshyV7LYhQAgM1GFLBo+h4/zqAKqSDd/ZauY + vw61bSaa3w1jZxiW7g5W/iG4+qf1CT8H2ePPodA2reboF9rkMUUQFNrnFQyKBAjWOZw8/6jq8VXFp+lX + G/8pMf6TT6WrvhhfVf7HHscjjzyidN/9l1BjH1Pm387YnzL/tvJu5NT14jQBINFfAKDML9V/FQDOnBEA + nMKpk6dw8sQJvPjS40wBL+KjT59mCnhItQInH5IBTaazPqa3nho0dpejjqqm8SuoUhpfAFBI5XeVIZff + y+4oRXZbCd/LYuwlBHb787HdlY3ttgxk1FerBJBLAOTT/PmlZkLA9F8FAFkjUG4emgKAGgA0aa2kzCFx + uwPw+UMIEAByCjAaXb0WQN91AJjFwZlJLPEYXevY/VWJ8f+wbrVbc1u2bvqLGwWAn9h/B9baqjQAJAXI + QKBKAdcDgB+iWY0FSAKQVkAA0AyTVVJACxWEWSkEowKBDgC7BgGjIw6DAEBkT9L4rVQbGpTaUVIXxK5K + IzYb89SVa3IvfLkR5s5wOXbHxPyVrFqs/joA8vi4kCpOVqOMqqCqCICa1iY0tLPydBJM3UnY2Ve6+ydp + /gU13bfSJ1flTVJTyLdOUzMoUBfrUARBWqZpHD/zsDJ82vSM+iLp81cbP1X1H3v0MWX8hx9+GA899BDu + vfgAqm0jbGmuNf/Wsi5kCwBOn8N90vunqr8OAOn9z9L8Zxj/VwPg+LFjeO75R/HJ957XU8CDGDw4CM9A + CM4BJyHQBGNvJRp7ylDbU44qgkAgUEaVdJehmCrk9/K5z+sqRU4HIRAvwp6WAuz05GK7PQM7LJnIqzSx + FTAjj1oNgMIyzfzXAECdBdATQK1292B1CrBJGwA08fiRMSQBgNxVSgCgzQGQacD6AGCbdgpQJgEJAEbH + JjA1PYcDc7P4qePfrHns/kpEXy3bNtyuW+3W3JbtG/7qRgLAUqslgLo6rQ3Q7u2uXcKpncK5LgHwwxQA + mK0+yq8AYLKxz7a1KACYbCkIhKmIAoDBHlNqssfRqJREg8hGEQCydn1upRv3NBaotezkwhW5ln1nsJTR + v1wzv7rQpUpd8JJHCORTRVQpv65sq0JNWw3q2hvR2MH00smE0h2DvbeHsX8M3gH2/QMywDeprsbLNU0g + zzxJTal5+nlyma4S4UAQyD7POIUjpy6lTf+kqvYrxr9y5Uq66qeMv9r8ly9fxoX77ke1dRjbK3TzV9D8 + BMAWAiCrthunThEAevW/93wKAKuqPwFwSgHgJE4cP64AcOzIUTzz7CW2Ak/j8efOIjY2CP9IK7xDATgG + rLD01RECFQoCdYRANVVJw5fz61KqhCqk8pgGBABZySJkRAqwN5CH3e5s7HBkYo+hiPHfpsx/LQDWSADX + AaCu3op6Vv/G1QOA7P/lQjIBgD99BkAmAemnANt7NADocwBkFuD0zDwBMIeffoU3CmHv/yKKf+/v61a7 + Nbdl67f/8w0FQE0VamsaVwAgYwEqBQgAbCrCyYe4ugUwMQWYBABMAMZVADARAAYFAQJARAgYbGE02SI0 + vwAgpgHAlqD5RUnUWRMorG7GToJoszkHW+yMo74iZf49NP/eRIW6sEUucBHz51L5VBG/Lm2tQkVrJaoJ + gNr2WjR2mmHq9sLaE2Hs76T5h2j8GVbIRWX+HMMIcoyj1BhyCIIcgkAu0hHJfH1RrlyySyjkNE3g0IkH + 1Cm9q1dXDJ+O+mJ8vddPGX+1+RUA7r0flZZhrerrlV/Mf09pJzJrunHy5Jl0768AoMf/lepPAND8Uv0V + AI5qADhy6DAeu3I/Jo8dRmh8FMGxXjSPxuAZotEGTDD3V8PYV4amXkKAqqbhK3tKUaYDoIhAKODX+d0l + yO0sYjtQhMxoAfYEcrHLk6kgkFPfoMYBUgAoKDWisNzANsCwAgCZDrwGALT+36EmAGlXAfrUilJyV+lU + /68GABUAGP87etUpQAFA6hTgzOw8Ds7PEwBf0Q1Dtepv1G12627L9o1/eaMAIGMA1poKAqABdbXSBqQG + A7WlnCQBqA+RADDxg0xBIAUATRoATFZKIGCldAAYlAgAJoFGK2UjAKgGWxz1VlECpQ0tyKy04G72/Vts + edjuLlQXruyKyDnrcmTIxS1UDk2ex73MdS+k8Yu5L+f3qtsrUdtRg/oOxt8u9ps9LXD0tcHZ3w/P4CR8 + gwso94wjq3EY2U0UIZBtGNVEEMgVepom0soy8OuGURw8fjFt+rTx2eOvVfFXG//SpUu49OCDaqpvhXlI + GT9V+cX895RoADhBANx7gQBYZX41+HdN/BcAMAEcWwHA4YOH4IsMwBAcQmRyGuHxIUKgE80jYULABcdg + Eyz9FQoCjVQKAhXcl1ElvaUo0lXQIxAoRnayEJnhfOzxZ2OnKwO7rTnIr5QEQPOXGTQAXN8CKACY1ArB + qduGKQAw/jcSAKn0KBPIZDk5ry+o+v9QKK76/0SiIw0A6f9Tk4DkDMDs3MJXCoAlx4Yvls0b/lfdZrfu + Jtcm3ygAyFkAR005aqob0imgXm8D1P3d9TZAICAfpsns1mQhACwaAIzcSwpQSYAQMBIARrYBCgBWDQCN + ShE0EAINVgKAqicEqo0R5Fd5sKO+BPfwgNvqzMMOfzF2h1n943LOWiawiPm1+e0yz10ueClRs96qUEXz + 11D1HfVo6rLA3ONj7I/D1d/Dyj9K88+z8o8js2GAGtTUOEQNI6tpVEmm6a5oDBmNo5rqhrD/6L2a4aW/ + X6Pa/23mf/CBB6kHcO7cvagwDV5T+e8p7SAAOpBZ3cV4TwCsMn968E9G/wUANP8pVv+Tx5kACABlflb/ + cOsodpZEsLWICSs8hNjkJCITfUwDSbYDrLRDVtgHa2EZKIWxvwSN/WWo7StFNQ1fxX05VcrHxdwX9pYg + v6sYue2FyIrnIzOYgz1eQsC5l+9PhToNmDL/9QBQqwLJHAC9+tfUWXUA2NFk1I4ZmQCkDQBq/b9cBiwA + iLH6a+sAsP+XpcDY//frA4ACgLn5RRxemMfPHL+75rF7o7Vk2ziuW+zW3tgC/NsbBQA5xeKuKdUAUCsA + WBkMVHd3NchcbjmV41wFAQ+MlMnspflFAgE/DJZmGl6SQAv3IrYDVBMh0Eg1UPUEQL01ijqLKIaS2mZk + VDdii1yY4sjFDm8BdrUUY2+sVF3KKnPYZRabXNgic9uLaPYSfl1OVXVUoK6jEg2dNaz8RkZ/Vpq+ICt/ + Oyv/EPxDM6j0jSCjvo/qRwYhkEEAaBqihnXJz3Bfx3Qge35vr6hmEAuHz61p+pTxU6ZXxn+QxmfVF+OL + ZIbf2bMXUG4cwJZSzfx30/gCgLuL27GjrAM9Q/tw4sRpNeinpJ/6S8d/Vv4UAI4dPYrFxUPwhAaxszhK + 82sA2FZE2EYGEZ8eZxroYRKIwj/qgXvYCPtQFSyDhMBACRr6S1FH1VCVfSUoJxhK+biYjwv7ilHQrUMg + koeMQDZ2uZkC7BkoqDUSANoA4JoAYPxfAYB2BkCqf5M6/+9W8T/V//v8YW0AUO//k8lOtMsMwK4+BYAB + 9v8yACinAOfn9+PYwtxXchpwyb5pedn+7T/VLXZrb3KBwlov4kuJIGmuLf45AGgpQFvXXUsBWj8nADAy + ARiuA4BBSYeAJaAA0GRJKagA0GghBCxh1FsiqDNHUdnYwojpxLYmmZOezeifj12BQuyNljDylyG7vVzN + XsvrKFdz2ou4XzE/U0tnOeo7K2HoboCl187K3wLXQCvN3w//8BSq/TR2XS8lANAgsLd+QNegJpp8b+0A + KmxjCHbux8DEUf6cNmtvV1Uf5g+evcbwP2d6PeprxtfML8bXpvfejzNnzysAKPOL8QkAMb9oc1Eb7i5o + RWFjDwLJKYxOHcShwyeU8c8w+p8+yfhP80vVn5k9gFj7BIoa2rClIIItNP89NP/WohABEMLWwhaYY4NI + zIwhOtmO4HgLIWCHa7ieECiHdbAEpqESGAaLUT/Az5tAqKI0CJSgSCDQW4y8rkJkJ/KQGcrBbl8mdrv2 + ItNcpK4FuB4Aqfgv6wPK/QKraf5aGQBs0OK/0aS1jDIAKPHf4w3C3xxBIMT+n/FfANAqFwGpawCuHQCU + MwDzCwdwcm7yq5kH4Nj0CJzf+ru6xW7tDc4Nv7Xmi/gykmsB6vIJgPqfawNSN3eUsQBJASkICACa9BRg + JAQMCgJifg0ATUwBTYTANQAwB2l+JgCzBoAaU0itRruntpp9fxa2ORk5vflqempmopSxX0aoyzXzUzKb + rYT7cpq+qkub7NJANXXXMvabWPl5kPXHaP4uRuBR1LWwktd2Uz38G73YQwgo1VI1hAFVZBiCMzqDifmT + OH3uojL08VP38mf61cSdnZW9mN1/+udMnzL+atOvNv7K1N6L6jx/qaFfGX+zSDe+6K6UCpK4Kz+B7UVJ + ZFd3oNQkU6KHYPQOodE9gJImtgvlSWwtiNL8VBFVGKZCVJDmF7VgW2EzbMkBJGaHEJ1KIDjhQ/OYBZ7R + WjiGS2EhAEwEQCMBUEfzpyEwUIRSqri/mBAoRH4nIRDPRWZLFnZ7mQKcu1FQ36BmAwoAiijV/+vml7sE + Sf8v8V8AIPG/0aAVC5k4JvFf7ivpYf/vVwOAcQUANQCox//uHvb/q64BmJ5ZwD6mnXMzw2sftzdSMvhn + 3Vik2+vW35Yt/+qfLdk2La/5Yn5RydWAdVkKANVV9QoAtbVN7OO0FKAgoC/qoOZ1CwBMbt38Hn5NEQJN + Zh+NTpn93BMCAgBzgMZv0RWk+UOs/GHUmsLqppR51VZss2jm3+XLw95QoTJ/TkcZcmXSikxe6dImschs + Ns385cr8MtnF0FMFc28T7H1OuAdD8A61IzBC04QY72s6qS5W926KEKgSdSO3oQ+WwAR6xw7j5OkLWgXX + JcY+cuI8dlX3qrn6Oyp6MLN4auVnGPFVtVem141/v6aVqq8ZX9N9OHXmHA3cd03VTxtfqRV3FbbizsKk + rgSBEMfmvJjS3flUAVUYZcWPUdynzF+gAWALzS8A2FrQTAj44WjrYRLoIgQYtydc8I81EQIVcIwUwzZc + BNMwIUAQ1FE1Q8Wo4r6cKqGK+4vYChQiN5mH7HA29vozsce1B3stuSiusqBoVfwv1VcHVtW/1ooamr+O + 1V/r/7Xqb5X5/4z/6f4/ENUGAGNtagqwAoDE/16t/x8e0fr/mdl9WNx/GPdPdaljdM1j9wZpybHxw2Xn + b/w/dXvd+tuy87Z/vGTd+MO1XswvLNJvtH43zV+3CgCNjHMGQkADgNzdRQFAUgABYGC0M+gQkCSgAGAS + CKRA0EzDiwJo0AHQYGpBvSmIOlb+akMLiqvd2F1fgu22TOxwEQD+fOyNsP9sZR/aWapmrBVSYvxSmczS + XYpq7uW8tpzflvPc5r4G2AdscA02wzecRMtoHwxR9vnK/FQ1VdWJ3Jpu1DqH0da/DwePnFbr8IlZlXl1 + M4uxxeSHj51l9O/Bdpm4U9aN6X0n0v+eqvTXV/u1jK/N7ruXkDmLksbenzP+nTS9mF+ZnglA29P8AoAU + BGh+0d35Ue4Z+Rn978mn6fMY+/ODFKt+XgBb85o15fuUthd44ensQnKmnRBoQWjShubxOnhHy+AaKYR1 + pAhGQqBhqAh1BEA1jV85WEQI6Emgr5AQyCcEcpEVEgjsxW73LuQ3VWnrAqT7/1UAYPVXAFDn/7VjRIv/ + cl9JLf5r/X9MXQEoE4C0dQC1/l/iv+r/RycwMTWLOfb/+w8cwcPj8V/51YBL9o2turW+Hhuc//QfMgF8 + tNaL+YVFACw2bkW1ngBSbUCNAoBRh4C2tlujQTu3Kx+uEF4g0KQnAEMKANw3MgVoAGim8TUINEgCUAAI + oqzOizzGx+2WTGx3ZGGnLwd7ggXIShQjp70EeZ1lPABZ+bvLUKbMX4YqqobGb+jVzm2b+6tg6zfQ/G54 + hyM0fxcsyX6avg0Zle3IZJSusvYh1MZqMn8E586dV4bUzHlR9eeitJEVDB7AoaNnWPm7sK28B9tKuzA1 + f1w3/PURP7Wn4dPm14yvTutR9124oM7zFxMAq42/opT5E9zHcWdeHHflRHEXK/9WVvuMilb2/O2otffC + 5JUVlAcQiA8jmBxBtHUYkeQQQvEB+CN98AZ7IWstNMqZFUNU3f03MdKNjnlW2ykPwhNGQqAK3rFiOMeK + YKPMTARNhEE9YVDLZFA1XIgKQqFsqBBF/QVMYHnIjeWwFcjAHs9u7LVnoKRGWxBEWxlYawGqpPrX2VCr + V38BgPT/Kv47/XCy+nt8IdX/Bxn/1SXAqv/vUv1/T3e/1v8z/o+NSf8/jzn2/wcPHsPVIa86Rtc8dm+A + lmwbf7ps+863dWt9PTZ861t/Z8m+4dW1XtCX0dmm21HFBCBKpYAaGRCsN6C2TloBWd3Fgnp1blfinUN9 + yBoE9DZAACDmNwoAfAoCDToA6qk6PQFUNfnV3Wd2NxViuz0TuzysMC35yIwV0PxFyOsqofnLUNRTyspf + qmavVdHwNb2laOgrg6GvlOYvh22gDs5BK83vR2A0CRujZG5NK0oMnfCERzE6eQCHjxxXp9Pk1JqcZpPJ + NmJKBQLqft2wYmKRGPrg4VPYUd6Jraz+W4s7MDl3TKvyutnF+GL41RVfpvLK70xJTekVndcB0NBzjfHv + kD17/jvzEqzscWwvjBNabQRWD7zRUXQPzmFyej/mFw4yBh/CoYOHcfjQIXXu/9CBAziwyOq4bxEL8wuY + n5vD3MwMZqanMTU5ifGxMYywksoddvv6+/Hg47O4/6kBHHogjMFjZsTnKgiCIjhHi2BhGjCOFKCREKgj + AKpp/kruSwcL2QoUMIHlIy+Rg6xgJvb6dmOPcxdyjUxkamFQs1oZWG4XXkUJACT+p44LOVUsl4075K7S + nhZ4Wf2bJf6n+n91ARABJRcApfr/kTH2/9OYZvxf2HcQBw8dw4vd9WseszdK9NEZ3VZfr4190SNrvaAv + o8dN/+kaAEgKqFZnBZoIAIGAfpMHqlERnmoiBPhBNxm1FNBk9PBrEQFAEDSYfJQfdcZmDQDGAGoNAVZ/ + N3L4u3dYM7DDyf7Sn4OMUD6ykzR/ZzHyafximajCfTn3VTS+TGCpkwkt/VL5S2EdqIJj0KAmvDQPBREc + 7IK9pR/dAzPYT8OckNNmJ0+qSTQCgLNnzjIBnFNz7O89L1oBgQYDDQSiA4dPYjsBIKftthS1Y2L22DVm + TxlefjZteNnrcJHfnZIAQE7xFa0CwB00vVT6vUwptY5+RDqmMDZFWB0+pp/zP6md8z9+XDvvf/QojhwW + ABwmCGiK/Qewf3ERiws0yRwr5ewsZqdnMD05hakJxuexcYyPjhICwxgaHGRFHcSTL87gqdcH8fjLSdz/ + rA9HHjZi9EwtYvvL4JgohGFYIFCIWoKgmmCo4OPSwQK2AnkoaM9FbjQLWc17kME2YK99N0pq5QyAdnuw + SjX5x6qqf12jHQ0q/mtXjqbiv9sTVADwt0QRDCdU/G+V038y/Ved/htc6f+nCDMCQAYADx8+gbfafoVr + Asrgn2XTNt1SX69tybXpyJov6kvoNeufpQEgEgDU6CmgplYDQF3qZo/s8dQsLwEA24EUBDTzEwR6ChAA + 1BMAojqjBoKqBi8jpAO7DLnYyTi5y5PF6s8+M1qAPFb/gq5iFPWWoKSvBGXcy6y1alZ8mcDSQPMbaX4L + 946BGrSMWdF3MIaj908wLrK3P3AIx44cUTPlxDwydVZm0KlTamfOqPPrapKNTLYhCGTOvZp+K3FdN7Jo + /8ET2FbWQQAQAgTA+MwR3ewpw2v71MU7KZismF5+t6zoI3/nHI6fPI3C+m7cIVGfVb/MzAN+eB/722M4 + fpzPT5/tp53yO6ngdYIAUHP++VqOHj6CI6z+hw6smH8fX++++Xm9+s9iZopVk9V/cnyC5h/D6MgIhnUA + DDIFjI8P4OqL47j6ahcefjGEi8+5cP5pK44+YcbcJQM6TlTDPVcKA81fw0RQRZUTCqUDeSjuyUd+Ihs5 + ob3I8LMNcO1ErqmY1d+iVX+av1qP//X64J/MExEAyOKx6vQf479U/1T/H48x/qfO/7P69/YP6f0/X8O0 + 1v8fOHCUCe4EPopuXfOYvRFiG/06nP/iH+iW+nptS/ZNfWu9qC+jT22/j5qqGg0AlVoKqKphClAQaKKM + q1KANs9ber0GQkCI36gAoEkA0GDwop4QqDcSArr5aw1+lNW6kFtbi522vdjpZF/pz0ZGOA85bYU0fxFj + fzFKafYyAqCSZq+mavtL0DBQAgP3tsFSRthaTJ/34f6ne/Dsqws4dmw/zX9QRWQxi1TM46ycYiKBgFRV + lQQIApleq9LAWcJATwQKBMq4AoMLWDwgAGjHFpmwU9iGsenDuvEpfcquMvw1pqfh1UU814sAOHEqDYDN + rPyJnrn0RB95Tsr4fI4y1VcB4BrzH1Zz/g9L5dejv1T+fQsr0X+WWl39x0ZY/YcFAIzUA4MY6B9Af28f + Jib7cOWlATz2cgIPPufFhWesOHXVgsOPW7D4qBnTDxnQe64B3sVy1I0xBQwRAgP5KOnNQ2F7NnIjGchU + KWAn9th3ooztoTb9V+v/66T683iQ6i8AsNq0yT+p6q+N/ie00f94B1rbuhj/tdF/AUA6/s/wten9/7Gj + J/FD/5+veczeCC3bNjl1O339tmX7RtuNGhz5mW0TrNXlqKysTUOgSm8DtCSgjQWoWz7rK73I1V4CgXoF + ARfTAKUngQYDJQAw+FAnIgSqGuT+83bsbMpi9d+DXe5MZATYX0bZZ7bLqLMAgP0nzV9BVYn5uW/oK4Zj + rBxdR+pw5BE7I2wYj7/Sjadem8SxEwusiAKAAyoeS0w+whQgEJD4LFoTAtIWqJl3hIDAQKUCuQDnLCZn + DmNrSRvuKWnHPTTt6PQhmnylbVgxvQYPNYVXzJ8GgKQMDTDy+48dJwDqOhUA7sqNI9Y1s1L1Ke0y31UX + ++ix/yhfhwBA+n5l/v1a3y/mX5DqPzvH6E/DTIn5V6r/yDArf6r6DwxgoI/9dW8veru7aa5uPP5SFy6/ + EMC9z9pw+kkzjl0x48DjJsw/YsTUQ0aMPGhA+7k6WOdLUTmUjzKVAvKQ35qJnOBeZPrYBri2I89USABo + 1b+mXqq/lgYFAHKtiM0u5/5b4PYRAM1htQCoXP+fiv9t+grA3er03whGRvn8CYCZ2UXV/x86fBxnD+3H + kvNXMw2YBfRHMN72f+h2+vpty9YNGTdsdJS/J1ablwZApZ4CFACqG5kEJAWsagVWQUBin6SA+ianAkGD + wU3jCwT0FEAA1PJxRa0DOTXV7P13YZdL4iT7ykgO8lrzUUjzl/TS/KzyFYPFqGbFrx0ohmuyAr2nm1il + HKxYHjzwXACPvNzKKDuIE6dnGYMJgH37WBkXdQgcUv2ylgTYCqgksKod0EFw9pRUYEkD0hqc4c+cwsDY + ftgCo8iu6cQ9xa24u1hm6REAU4do8nNpw99Lk6dNrwyvmT5leE3axTyio8dOoKCWAGD835wbQ6xzBqfU + HH+t8q/0/FL5dfPz+SvzM9Vca372/Xr0l75/fGySMXoAzeFu2DxJdal1rTlGRWCwR+H0xRGKtqG7sws9 + XV3o6uzE3GIHHnkxhvvZBpx5yowTV004+LiRADAwBTRh7FITBu9vRPe9DXAtlvHzyNVSQFs28iIEQPNu + ZLh2YK9tO8ob5F6Aqeqv9f4mml+WjJObyEr19/hDavKPjP5HIjL7j9Vfjf7L1X+p+D+KUb4WWQBkbv6A + Ov8v8f/S3MCvbA7Akv07C7qVvp6buh7gRp0fJQAm63fq5q9VAEi3AioJEAA1Bq0VIAAEArLmm8z5lvO+ + AgEBgCaBgId7D+ooAUBVg4vV34rdUv1tu7HbQwAEspEdY2VpIwC6ClDcW8joX4zKgSKYJ1jxTzdi/mEb + jl5x4vRTLlYsNy69INW/C6fPTWJudl71wYusiAoCNInWCjAFCASOHFUQEK20BDSbmI46cuQ4JqYPwhMZ + Q0F9F3aUtDLyJ3FPkWb+zbIvSGBk8oBmat3gP292kT6PX5cYX8YdFACOCgA6CADtFJ8CgKr8K8bXKr88 + V838YnyBmfT98rpS0V8G/cbGp9DaMaQuo84sC2BHnhdbczy4J8eNLaJcF7bmOikHdlB78u0orfGpWXdd + Hey729qx77DcYrwZ5582sw0w4vATRux/zIDZh5swebkJI5ca0X9/Azov1MG2UIzy/hwUd+YgPyEpYDcy + PTuwx7EVuaYClQDqGrUUqFV/WTTWr+4e7fKGtPjP3j8YktF/Lf6rq//U+n8D6BtgWhlm68LXNTUj03/5 + mg/yfTh2Cs+M+H4lpwCXHDLvf+Nf6lb6em7Lht/453LjgrVe4JfRfcbbaXgNAKoFUNJSQLWkAIEAU0AN + U4AoDQB98odUAQFAXaMGAUkBAoBaqpzVP5fVf6dlJ3Y5dmGPd6+aYJKbYGXpyEdxdyFKmQBqhosROlyL + iUtW9qV2HHrCwQrlxNmnnLiPfetDrFxnLg6p6Ds7O0tDzKkUIOaQCqnMwlbgEA0kEEi1A2IugYBoauYA + gq0TqDD3YEdZK7YUJljxaXwBgKr8mgQAcopueGK/nhTE2CmDU7IXw8v31L9phtcW8dR7fOrI0eMaAGRm + X24U0Y5pDUS68ZX5BVQS+SkB2OrYv8jXNU/jd/SOwuzuQE5FmGb3YXOWF3dzf3cu97keiubP07Q1jxDI + c2J7vgPb89h25dhYhWPo6OhAR2sb2pJJHDwVxcVnHTj1pBFHrhiw/1ECgAlg/HIjhh9sQP/FenRdqEf0 + eCWqh/JQ2p3NFJDJFLAHWf6dTAHbsce2DRVMAfLZG9j+ycQwVf3V4J+c+w9fc+4/RvMnE1r871Bz/4fS + 8X9iclaL/4sEH+P/8eNn8GZn6ZrH6i+rJefGp+D81t/TrfT13PDvv/X3lmyb3l3rBX4ZvWb7c5qcFV/G + APQ2oEraAKVrU4AAQG78IEs/CwBk/recA5ZKIACoa3TR/G4FgBpW/1Kp/o0Z2GndqWaUZQZ4IMVzUNAu + 5i+g+QvQMFqC9jONmHjIitlHCIDHbDh8xY6TTzpw7mknHng+gLOXe9W5bul7ZfBLToFJVUynAL0VUElA + 2gF16uwwTb8Pya4JVFu7kVGexI7iOLZSW0qSaQkE7k6pKEkAyPz8OIbGF5WRUwZPGftvM3xaMsDHSn/4 + yDEFgNvzY0wAEXXa7/rIr8yvRvu12C+Vf25uHwaGp+EK9CK3KsIq78ddWT7+DppflCtKmZ8JQMwv1V83 + /zZW/+05duwtsKPR0qIqfwfVrgDQSiPGceTeANsAI45facLBx5i4HmnA1OUGjF6qZxtQzzagDsnTVTBM + 8DMiAIraM5Ef3YPswC5kuLdhj30L8o1F6gyAmF/WiJDqL/eOdLu1wb9mgicog3+s/gKAdPzXB/9S8X9q + ak7F/316/D9x8iw+i9y55rH6S4mJYtm+oVq30dd7I8kurvkiv4R+YP83aKqu1lsAXRUyJiBQWJUCCIFq + BQLtDrCy/psAQKnBjlpCoJYQqCUERJW1duSz+m+3sGLYpfqzgrRkIS+WjYK2PEbLfFT2FSJ5sh6jD5rY + h1p4IFqw/3ErK5Mdp56y4cKzLpx/tBWTE2PUhIKAnPqam5lVg2H7CIGV8QC2AvsPsGruQ1v3OAzuHuRW + J7CzJEbjx7CtNI5tJQlspbYIBIolAWi6W1SkaTMlM/IEADJod63BdcPLKUZdqUG9tNjjiw4dOoqCmnbc + zt+lANA+tVL10+YX42vn+cfG59AcHURJA59fQQvuzPThzmw/7iQA7qTxFQBo/rsY+zeL9Op/D82/RczP + +L+Nxs8pZSS3BhEKJ1X072rXqn87zd+WSCIZjzOKR3H8sqSsBhx8vAELBMD05XqMEQBDD9Si975atJ2p + gpEAqOjLQWkXU0CSbUCIbYBvB/YSAHssW1HdZFKn/2SlaKn+Ev9T1b+F1T/I5xCNaZf+trX1aKP/6tz/ + CIb1wT81+r9P4v8xFf/P8j36qevGLwW2ZNv42bLpt/4n3UJf7+1GngoUMkbqCvXqX4sKml+kJYEGqlEp + 1QpUMwmkbgMt14CLpBKsQMCF6noHKmqt2FMvC03uwG7nLuz170FOOAv5SfaVHXko686Hc64cww8YMHHZ + xOpvxr5HLTj4hBXHr1pZoaw4f6UFk5ODapbb5Pi4GvGWFDAzzRRACCwIBAiAqalZ9PRPwO7vQWFdAhml + UeyidpTS/NR2mn87QbBVSU8BKRXFcU9BDPcUxlYgkBfF4Ng+zcwpU69ldP2xGtRbJYn6BwmA/Jo2tgBR + mjaMcNsEzb9S9aXXn5xaQKJjDGWGNmwrCOKu7ADuyG5W0oxPZWvmvyvHu8r8brYBNH82e/4cJ7KKmbgM + LQgEk+hol4G/bjUA2Cnmb6P5W2l+AqA1kUAiFkc8GmMcD+I4gXv0iXq2XQ2YeagO45fqNADcW4vosXLU + DuUQANlMAVkoastgG7Ab2c072AYwBdjuQZGxWJ0ClDtFifnVqT8CIFX9Q5FWLf7r1V9b+0+r/iNq8G8O + s3OL2LdICOrx/5F9Q7+q/r9Pt8/Xf1u2bii5kW/Svqbtqg1YDQAlPQWkIFBFCFSpJCAQoNIQ0M4J19Tb + lSoZ/Qtr6rDDuA27rKwYnt2s/nuRn8hBSWcuynryUNmbj9ChaozcTwBcMmL6YZM6L334CTPjvwVnn3Qx + wveoc9tjo6PqXPeEQGBCSwEyGj4xMYXmSB8qjQlkloexp4Qqi2B3GQFA7dQBINqmA0DtmQi2FFH5Ef5M + HLXWHvgiI+p7dxfKFXkEwMiCGqlXptb3Ynpl8JTk+7pS/b2m46xoRxQAbs+L0MQhhFrHlfEXWe1au8ZR + Z+vC7pIIbs+i4bMCuF3Mn8PHVNr8euXXzO/VzJ9N82e5sKPQwz6chgu0ssfvxkBfH/p6etDb3YMeml+q + f2c7479e/Vul+tP8iViMAIgiGo6gs8+PY48ZcOCxOsw/XIvJy7VMYwTAhSrYZ/NRP5KD6oFsVPRko6Qj + A/lxQjywE1nu7dhr24K9xq2oM1jVuX81798bhq85iuYWrfpHYm2Is/dvbZWpv3LqT6v+QyPjGEuf+z+I + /QeO4shRmQx1Fi8N2dc8Rn8ZsWVeWrZs/De6fb7+G3uZP7mRALhq+U/qsuAqBYCaNAAkBVRWChg0CEgK + SEOAAJCbQcodYVIAkJFhkZwnzqjLwk6J/86daiZZTjiTMTKL1T+H1T8XlYRA874KDBMAk0wAcw/LiLQJ + R6+YcZoJYHqxFUMDwxgZHMLo8LCCgJYE2AoQAqOj46g1JZBVFsZeEQGwt1zMrwOgVMwtKYAqiTIBUEVR + bCuMEBQxlDS1oyU+yoNwkTH8CKamFwmAKDYzCWymaQdG5lVkl1OJytSyl3P2aq9N3EmN5KszDamvj8lp + yGPYf/AwAZDE7blhBQCjpw82fx8BxUQghs9qodlbcHuOZv7bafzbU5Wf0f8OVv47afo7s2n+LA/lxs58 + D8HaApe/VV1JNyD30+/Xzvn3q3P+NL+c9lPml+rfriq/Fv0TCgBi/nhEABBGJBRC37gHhx+vw75H6tkG + 1KCP5vfsK2D/n4Om8VwdAlmEQCaK2wjx8C5k+wgAB9sA890oMVSoRWLcnjCrf0RV/5ZQfKX6CwDaGf9Z + /SX+a73/FCYmZzCrD/4dPHgcx46fxqnT5/Fhcveax+gvIybm+3XrfDM2GP/l/4tU+3ytF/tl9Jn999FY + K4N+q9uAGpTLXgDAFJCCQGUqCVQbCAJCIH1bKCuqKLlEtKi6ATsMW7HLsk1NIc0M7EZ+lAdQezbNn4PK + /nzUDOTBMlGE4YvsPx8ysA9tUuelj181YuEoKzAP7KGBAQwTADK/XWa6yVz3CYHAxAS6uoeQU9bCyh9C + BiUA2EMAiHYTCDsVAChW2R1FEZo/jPzaJByBfgwMz+LA/oOqIosklk9M7cMWwmEz2wEBQP/wvHYGQRn8 + 56WdYlz9tZxxoNTI/lHs54GdX60B4PbcEM0exO2ZNHy2mF7THSnzp2K/Mr5ufhr/zkyp+B7kVrbA6knS + SH18PwhFmfSjpvsKAMT8jNY0f68e/RUAVg38termTzD6i/ljkQjNrwEg3BLEyKIdC4/WoOdMKXwLebBP + 58E0KQDIQd1wNj8rAqA3E2VMAYVMAbktO5gCtmKP9W5kGneg0eRU8d8nq/7IqT+p/nLqT6/+7Z1y7n8A + fXzugwS3VP+p6QXMzWnn/mU1JKn+59lO/cTzx2seo19aMvhn/XaWbp1vzrZk33h5zRf8JbTMNynRUKQA + cO1YgECAXxMAFQSAQECBgACo1JNApQ4BWRlGLhCRy0Sza/NY/XmAOLerCSR54QwUtWYx/kuczEFVfx77 + yzw0DechcqgcU5caGf8NjP8G7D/nV9VMqtrgQD+GBwa1FKAgMKJmvUkrMMEkEIr1oMYUR2F1GDkVQWSU + EQai0hCyCYSCqijKmlph9bEC9YzzgJNThtrZAunBZeRdnTYkBMYnF3QAMAXkhdE7NIvUfAJtTsEqydcp + pb/W+vtUj79v3wHkVSVofhpfzK8kAEiZfsX4mumpLB/uyPDgbpo/szQAWUI90UbTs2pKApK5/iNDQwqK + AseU+ft6WP1p/p+L/tL769Vf6/216h9j/I/qAAg0y41eXQiOVKJ5IQee+Rw4KetMDiGQi8YxDQJV/Zko + 7+LnmNiN3OB2ZHm3Yq/9HqaAzagy1anVfwJS/YOrqn+ySw3+Se/f06f1/sPs/aX6y6k/7dz/MRX/T506 + j8cXB294/69u9un8vX+o2+absy1ZN7at9YK/rI4btkCWCJfR/xQAyvUUIBAQAIhSKaCyWvYCAkKgWm4R + LZeImlDKf9vdsB27rVvV/PGswC5W/wyUtGehvJsHUl+Oqv4NI/kwjEkKyEfiSJkaiT74gAO9vZ3oZS8r + B7ZAYIhVLpUCRvXxAIGADAqm5sH3DYyis2cYbZ1DaOsaZtwc4fcmMDI6pSYOLe7bpy6mkTMFqYlD2gxC + be6AgGBsYo4ACKsVeDbnhdA7OKNNy2U1P0pzqwlGyuD6QN5qqSQhMxFTc/gPYWFhPyt3fMX4rParK35K + yvgy4p/pZV/frIAWTfRhkL2ydoXf2HXmH0ybX/r+fjG/iv5S/TsJgA69+ut9/xrVX8zf7G9Rl+5WVFvV + +v/FVQZ4mch8hICLAHDMZsM8paWA+pEs1Axmoao3A6Ude1EY24W8AOHu3oK91s3INe1V04AD0vuHEqz+ + 7ez95dQfe/9O9v5S/WXij977y3X/s3P7Wf2P8P0/oQb/zpy9F2/0N6x5bP4yYlK+dW/2+ctscjkjbuB0 + yddt/w51siLQqsFA1QLQ/AIATfXpJFBOAFQQACIBQAVVXmlg7C3BbhP7Q/s2ZPp2qlNHRYlMHjhZ7Pt5 + IPXzgBrORdNoPkzjebBN5cFFReZLEErIeesOdTBLVRMIyIEuF7doENDHA1Q7sHJmQM0RmJzCzKp5AnKa + UKbOyhRamUcvk4bSIFApQJtwc0CB4BBGx2c1ABRQBEDPwJSeDjQd1s2dMvo1hheISKKg1KW7+vn83MqY + Mn66z0+ZP0szvWhnfjPKGmMIRHrVzDhJNtLiSMqRlkeZn+ATAIr5V8d+VflTfb9ufnXOX/r+1MBfqvrT + /IFAUK3UW1XnUKbPKzYhr0S/A1C5GeXmejTP58MrEJhjCpjOgXEiG42jWagbzFQAKOtkG5AkAELbkc0U + kMEUsNd8NxrMZnjZAoQjbYjFVqq/dupvZeR/XKr/zKrqf+QUTp48p+6j8EX4b9Y8Nr+sbvmbff4y27Ll + O/9sybbhp2u98C+jn9m/A19jpZ4CtDagvJwJQKTMX4sy7st0CGgiBESsHuVUKR/vrdupAcCxDVn+HWoG + WUlrBso7WUEEAAM5rP55MIr5J/PhmM6FeyYfNW6DWi6spskPty+qbhwpB/cKBCQJsB2QVoCGGCcEJqQd + YJW8FgLaGQK5Yk6bMKRBIA0CgcC+RR0EWiIQjYzNqEU2FQAY27v7J3EwlRB0c682eWovk3fUJbtqIpIO + FSYNublFbmVkxfSrjC8TegprI/C0sGr3jvC5T6nLeuU1rGl+Qk9Vft382oi/Zn6J/um+n9Ff6/uT6VH/ + KI0vC3PKxKzCMguyCk3IERWvvv+fWa3+W1xpRYO/Dv59GgBsM9lsA7IJ6yw0DGeilm1AZddefp67URDZ + jhz/VmQ6BACbUWoqhMMVWKn+NH87q7/q/QdGtGm/qvprE3+k+h88pJ36O33mAh4+usBW9MYuAbZk33RE + t8s3b9NWB9p0Za0X/qXE3mvRuAu1deztV7cBCgBaGhAAqBRApdKAAKC8son/1oTCimrsarobeyxbGA+3 + ITuwEwVRAcBeVHRl0vzZPJByGf1zYZ7IVdXfPcM0EKtBUaUTRVVOFFa6+NiNkhov6k0trCqsYMlO9HT3 + quonSUDGA7QkoI0JTAoEZKIQtRoCGgj0NEDJ7EGZN6BNI141lZgwGBmdwTZ9wc178oLo6ptQE4tkJZ4V + idlp9HSCSEkzvUAlpWke6LkVAgC/Mv89OX7kVIRg8TDh0PTTci0/JeYXpY0/NqaZXyK/Mn6q59eqvwBx + ZcR/tflXRv0TsQT8/rC6RLugzIrMApNSVpEZ2TS+mD+XlT8FALkFeBHNX1JFVdtgaa+CJ5UCprIJ60x+ + bhkEQAYhvhflHbtRHCfcW/gZsw3IYBuQZdoGi93NBNCqqn97e68+8j+EweExVf1lzb/Vvf/hIyfVzL9z + 5y/i1ZEbfPpPBv8sG+7Q7fLN3JbsG2JrvvgvqVds/x71DQbUyJoAhMDKQGAqBTABlNddA4DyihUIZFfn + YJdhM/bYCADPNuQGdynzl3ewcvQQAP2sJEOMlQSAdTKX1T8PVlkJqMpG4zs0CFCFVW6lgkqPUnG1D9WN + AXXDUV+A0Za9ZX+fwGCYiWBEtQTpJKBAIGkgNV9Ag8G8agsoSQQKBJrk8QKrdW//BLYWtOCe/CABEEBn + z5iWEsTYChLXGlyJ35c5+5IqRJIwlAiYSUbd3Iqw6vFlVp/Z06nWvZMWRZbx0swvFX9V1af5peor86vI + rxl/pedfGfG/1vxa5Q+HY5DbtRXzvcwqNGNvngl7803I4ONMMX+RVvlzGP1zS0zp6C/ml+pfSgCU19hR + VW+FY7gEzrlspoAsWJgCDGPy2WWguncPP89dKIrvRH5wG3K8/Kztd2GP+U7UWhvUIKBUf+n909Vfev9x + rffXRv6Pqup/9Jh26u/ChYv4PHLHmsfkl9WSc+MLt/zNPn/ZTd0t+AaOA/yMESzYVKluEiIAkHkAKxBg + AigXaRAQAEg7oO0blHbXb8Me093Y69yKbIn/YVaK5G4eMHLgZKN2kHFymLFyjJVlIgeO0UIU1xvVAVtY + aeeBqEFAUkAhU0CBDoH8Si/lo6G8yCunuJebilY1yU1IY3D52hAIdyLe2ou2jn50dg2gu2cQvX2yRt4I + +iipuj29Mlg4grbOYYTi/XAHe9Fob0NJfRx7yqT60/yEwObcZrR3j6XHDuRyXDWGoB7rJl8tGl61GQom + Apg5TDDu5pYHGft9uCvDC0+wR6v6quKvxH0Zx1ip+qnBvhXzr+75pfL3pc2v9fyxaJLRO4SyGjeNbsWu + XDN255mxp4AAYNUXZRIAq6v/6uhfyOgvlV+Zn9VfpnDLTM46qwWu6XzYpwmA8f9/e98BHed5Xemzm012 + k5zd7NmSTdmTbI6ztiUAsh0n2iS2bCuSLImiWEGwoBCFKCRBdGCAaei9gxXsXaRIiiIlqlCixCY2UXKN + HUebxImcVeISx3YsWTbm7b3v+76Zf8BRLJMARYr/O+eefwYEQXD+/9533/sa7tv2JVK9ZbFUbFyEMmCR + lI5mSUEf+wCzjQAEZkhRY660tfXIKLL/2vWbbO2/04z72+x/8NBRT/ZH7f/CGXnlqQNTbv9visM+rzVi + Nb/+KygDvpvqA7haHG+cp6cEc4twrgx0IkAXYATgShEoW14thSuWy4K6h2Qh6kFOEslrZ/2/EA5gkaxY + SwFgIykHAsAHCuTfnS8rwjWoPYMgfROuIVzDID4FIAriN1u0gPwtkg8hyF/BMfE2WOl2yS1rk5xSg+yS + NllS0o7XHfh6J4jXKXlA/oouoBvvuyWnrEuH1hYVd8mCoi6Zz730C7ildqfMIQq7FLMLgKUdOpqghFan + YAkeJ3kCrryIOwyAZceuXXvxO1AA2mRmdqu0dK9TZ6Kkt/AS31l+1+xz5HdZ39l+Zv01Y2ulrWNAt1rL + K+aqvyZZAOJngfgLC0j+JhC/0WT+SeR31r+wrAnWn597k5K/DORfodk/IqtquLirRQJdtRLdBxewJwcO + IFuqty6WVRvoAHBfRzKlsB8ur2O25ETh+iAAS+D+Ii2tMrKavY0tssHO+d+5e58Z9+ein8eekCNPPCNP + PWVq/5OnXpLXt9SnfBavFnDGP5Tobf/D0uT9HbA6h1J9CFeLb4f/WBrrAuoCuEcgRcC5AEP6KimdJASl + EICc8mxZUP8Q6v+HUf/PlbwuPCCDWVI2xvp/CTIH6sitORLYnitBZJTqvhWm9uTRUxQBCECRwohA4QqD + AkUziEy0wAW0QgBaJXc5AQGAEGSXtSuWlLbLYgjCIogBsbCkQ7KKO2QBkLmsM475DhCCecAciIHDbIgB + BWB07VYlMhuJCr6+ArbZCNDas9SgvWfpwX3u8yA6M3Jb4QBaVADiVn9HMvHZz3BZ3w3zkfiO/Gz4rV2z + DvZ6WGoDXZJbEpFMkD5zaRDANb9JsgqalPwLJ5E/uygQt/5x8oP4av1t448CQPKvrCL5o1LBZd3c5SnQ + KqF1KyW8Z4kEdiyRmm2LpGrTYilfvxAOgP2dubK0c67kRCD6jTNlYf2DUh2qFB7+Ob5pG2r/XbID1n/3 + 3gOy79HDV2T/Ey+clrOnzshbnZ9J+SxeLSYi6TstPd7/MaU7BBH4WVsCRXABDXpsuG4OAhEg2BCMu4Ay + IwCluJZCFBZWzUH9/5DOEVcB6MnUSSNlqxfLyvWLpXLjEqmjAOzIkYYNRXj4eN58QEWANrRoBa8hkJ4i + EMGVcAIQNQKwvBnZvAXEagH5AVxzylqR2VvhAFplsaINIkABaIMAtEMADBYsM8hcBjEo6gD5O2QuUchD + NXjtgBPogAAAee3IYptt/yAVLNEd4tbeYY9s377TIwDN0ty5xhIfdX6c+Am7nyrrs/E5NLxaj1wvwP83 + a2lI5uUGZT7Jnw/yg/gLFMj+JL9m/+TMr9mfAvAO5GfmZ92/sjKi2b8CAlBdZ8hfH2iXhkirRLcVoWTD + /dsOB7BxIUoA3NexBbJsaL4UdEMAmiH6EP6sepQBDdm6ByCt//YdHPYD+fcfRvY/IodR+x994lmb/VH7 + nzorX3tsw5RO/tFNPxpvksM+pyK4xFEtT4oP42rx1dA9Ul/XKDWoz7k3oPYD1AUY8idcAAWgAg/Tcsmq + gf1vmKnjwrltcyW/FwIwlCXLVy+CbUT9CAGo3YxMsjVPymph/Zc3KIqIFRQCAE6gUAEhWB4G8SN48COS + XxYG+SOytCwKNINYzZJbGgWaYftbUAIATgSKW1QIFhVDAJa1Am2SBSywyCxqA/nbZV5hWxzuZB1iTj6Q + 1yYdvetk545ddniOw3Qe2P34lOx6BTzWns3IrVt34PfkvP4WeXhJVKIdq5X4rPFTEZ9DfI74I6NrJdo2 + KCWr8PuC9HNzgjIvLyTzKQDI+vOZ9V3m1+xvbD8FINn6I/vbzE8UwPZTAGj9NfOD/Gr9UfevrELtD/Jz + Pwfu78jzHnjuYzDcJcGesARRAtTDAVRvXiQV4wtlxWonAHMkt3WWZIdQBjTMkMW1M6Wts1sFgI2/PY8c + kv2PGuv/+BHT+DOd/9Ny5uwF+SeUiKmewasFSuLLHCGz9Lg1Av/px1N9GFcLzgkYCFRIfW1johQod70A + IwAUApK/BA4gtzxPsmph/wMPQwBmof6fh/o/EzYR9f/YQilfC+s4vkTq2UVuXS7LyuqlCFi2nFeePGsE + QM+jR2YqXB4E8UOK/DICAgAsLYuAVFFFbmlERSDHIwJLABUAYFExyW+QBSwoIpwAWFAAClqtCLSB/Aks + wPvC8m5piI7IGOfgb+NiJDPSQBvPCTsGZpUi/8zV9MzyWzZvlbzSDpmZ2yyzsiEA7WNKejeV10v8TeOb + ZN3aDdLRPSLLqztB4Ihm+rkW8zzEN2i05E9k/ivJb+v+kiYz2ceRXzN/CLbfkp91P61/tdnLgdu6cfiQ + Jz83hTolHO2WaEu/hNZUSsN2IwCrNmRBADKlZDhTivo4EgABCFMAHpQFNfdLY0uTlgC0/iQ/rT9X/B2F + 9X/6mROa/U+h9v/88cclNpWbf3LoL5hWYmlx60QslD5/SssA4EJopgTqm2xD0IiANgRZCsQFwLiAxRWZ + EICZOiEkOwoB6IAD6JsvxcNZsnJ1lqyCZawaXyxVI/kgfY0Ul9WpCBghsAKgImA603xQC8qCID0eXr2G + ZGlpCITihhdhS/6I5KAWzimJgvxRWVIMlDSD/AaLIAILlxHNes0qMqAQZBa2gvwtAMkPQATmEvmtIL/B + bELX3Js999hUrA8PSf/QBtm4cYsO1xnCJyy9AzP8JnzPUpQiD6sARCAAownSW+KPw+J3945JVUO3ZOP3 + n4NMPycHGR/Zfm4eyA8Y4ifIP9n2L7LkX1Rohvvitt+SPynzw12R/CWW/Gr9Xd0P8tP6k/w88p3DiaFI + l0Sae6S5rV9auvqkcVOB1GzCvVy/APcVAjCUKYU9KPdaH5YcOxKQVfM5WdFUoguAHtl3WPYfeFzP+nv8 + KDf8eE6ePf6ijvsz+//DxpUpn72rBQ/75EI5JcWtFLL8tl+dCOM/n+JDuVq8FfmYdDXVxUsBPTjU9gPc + 9ODS5RWo/ysks2qmjgCwEUQBWNo5R5b1z5fSoQWyYjRLKtYulNrxHCmpXgXS11pMFgEjBIUEh6kgBHxw + KQJLS5tA/CAcgBGB3JIQBCAM8htkQwiWFBNRWbwsAgGIyqJlUSV/VlEUaAbxHVogACR/s8wvaAb5WxRz + 7Z56bn89grvtzLa77swmkXO45VazjjpUNvRJd98aGR+3axVsI89Z+434+tLSNpmVS2JDANpGtL4f37BR + V8k1hPrw/4EY5YVldnZQZpP8lvhzLPnnotaf54gPkPi0/JNrfmZ+N9yn4/0e8ru63zRaOdknQX7u2Ezy + M/NzL0e1/o2W/LD+Yd3gs19a2weko2tI2obgDjZByCEA5WPzpWRwvhT1zpGl7RQA3P+AcQC5dZkyNLJG + ya/W/+jT8sSx4/L00yfk+ROn5dTpc3L55HPy05Y/TPnsXS1uusM+pzImwmlrU30o14JT4XnS2BCypUC9 + 6NmBdn6Amx1YsnK5zK+6HwLwoCxqmik5LbMlr3MuHox5UgYBWLV6oVSuXyQrW4ulqBS1vxOA0lq852uv + AFgRKDWTVAg+wEsBPtAKCEEe3ABFIEcBASgOg/wEyR8GIhAAg4UQAIJCsKDQIBOYTxSA0Aq3px6A13Py + QVpAiZ9nrrNwTQJIzcy+COXFqvpeae8ekzVrxuMZnkSnAMzOjcic7LDUh/pBpiFZtqodpHakD8mcXMCS + nmDGn8uMn8/XEIC8xnjmz5xk+Ul+l/lTkV8zP0hP26/kR/Yn8U3mj0o5bD+nCFfXm7qfh7w2BE3dH472 + SLS1T6dlt3UOSmfPsPT0jUpwbbkVgEwpG7YC0GYEYEnjDBWArKoHpWdwAAJwWE9C0mG/p5+X48+dlBdP + npWXzl2Sb24PpHzmrhbI/j+NNWakWTrcehGLpn1iIpwxkerDuVq8Gfm4dDfVS6AhKLVWBNwsQSMCVVKA + +n9+1QOSBQFY3PiQZDfTAcyTkn4+IJlwABCBoWxY/wqQvhowIqDkVxGoAyACQGEcDSB/A8jPxSoGppHV + hAccsNccILs4aBFC9g8CvIZBTIOFRWHJKgRwXVAYAfkj8avungvMyycgBAC31XaYk0dAAJIQsbDvKQQ5 + YRAZwgOHUVrZCdIM63TYpaUoI/B1IhOknwuyM9Mr8eM23whAIuNb4gMm85t632X9yZn/nWx/vi2lXM1v + Mr8hPzM/yV8J8rumn9b9IH9TqAvWv1siLb2a/ds6BjX7d/eOSm//mPQMD0rN2sUQdtzfoXkQAJR7HbMl + 1+MA5lfcK9HOiOx79JBm/yet9T/xAqz/mQty+fQL8pPWO1M+c1cLCMAJS4VbM+zJwVO2R4DDGbiAYGNY + GuqDUmP7AXQCRgSqJWfVQplfCdWHACxBCZDXOks7w8V9cACDmbISAlBSVwayV4LkVSoCdAIGphRwIlBY + UqcCUKAwIqAuQAWAY9l2KqsKAB94KwIgPrG4KChL7HVRUUixsNAgC1hQABEAMi24dbaDEQEAxCfmkrBX + iEECCSFwMEQnuWdn89/iz8F7fH2O/pkjfYL8ceLbrD+PAgCYet8QnwKg5L/C9icy/79a89vMb8gfidf8 + q5j563iSkyF/fRPIj8xvyG/qfk424rbi3b0jyP5jdqHPWmkZa4Kw0+HxPs+Vgk4IQAQOoIE9gPtREt4r + dS1VOvtPrf8zLxjrf+qcnDv3svz99oaUz9pVg82/8E162OdURiyYlp/yA7oG/DjyMRkM1UlTADa2LtEU + 1H7AqlpZuGo2bvj9srB+ho4F57Y8LPkQgGV4MEpRIy7vyJVlJRUgOASgzImAEwAjAoUKkJ8CAKgA8FpS + D/I34KEGig2cCBgBcNkvIQJLipogAARFACgkIAAFQSMEBR4hyA+lFgMQlzAi4IEl87sCCe8Qz/BeuGzv + rL4hvRLfwZJ+QX4AxA9ow0+n94L0Sn6b+bU0ghCazG9GUSgASn5vze8hP2f6MfPXwvaT/I0284ebYf1Z + 9zPzw/p3WevvyD88ul5GV6+TqpFcKR3Afe6dDQeA+x6daR3A55AQ7pWVwSI99IN1P7M/rf/Zly7KqyeP + T33tH0n7K4ne9ouWBrduxGoyfkV3QEnxIV0LvhiZIaFgFKVASEUg3hSsrJbM8ge1B7CwHhkgyB4ABKBj + jhT1zJGS3kwpqVwpxSA/QRewrIwOoEqKSqpBdr4mIAAlBgVAPshPqAAUWxHA1QhAsgg4+2tEoEkFICEC + TVYASH4DCgGxQIUAAkAR8GA+wWE3XJ0QcBjOdOavRCKrk9SeP9O/423oGdIrXLb3WH0v8ZnxF9hs77K+ + a/TF6/0is7rPkN8Qf3K33w31Ta75SX4d7rM1f5z8nrqf5O9U6z9i1vgPrZHhkfUytnpcxtZuku417cj+ + s/U+57fPVAewOPCALIQALIAAFNQukK3bdhrrj+x/+sx5OX/hsvzjpvKUz9i14JaY9/9uQ8LpzVM9JDgR + uUM2hVdJsCkigUBI6mp5TiAPCqmS+eWfMw6gbgZKgIckO/qwjgsXdEIAQrlSUlYFVBsBKLEiACjx4wJA + MahR8hsBSIiAQslfZ0WgXvKWARABznAjOOElm7DkMAJgSaMiYKAiwCmzXiHIN2KQEAA77MarioAZgzdX + AyU3QVK7K0CyG8Ibos9Lem2RRPrkrK/Ed3Zfsz7sviU/ie9A4qvl16zfJPmllvwgvnb74+R3DT9m/mZD + frX9bSB/u070aeREH4ALikh+dvzbOoe07u8h+ZH5lfzD65D9zRr/tRu2yIZN26Wyv0AKO2ZJfiscAHsA + DQ/qMOD8intkceXDugvQiRNn5CQbf+cvyVeee2xqx/0B3e+/8aP/zT7+fnARxEQk4/upPqxrwd9HPi0t + kWYVgQY4AYrAqupKmbvyHli++2D9HtSZYNnBhyS3eaYUtM2R0lXlUrqcAlCVcAFWBIpK6AIMChU1KUSg + FoQnSP46PPAkvoWKQAMEoEFyigxUBIAlyI6OLCZzsm52IsAZc2bufAIeMQDMLDuvEHigYpCMeFbX1424 + egivwNe0m286+kp4W9/T5seJbzO+I78RMPP/8GZ9Q347t18zP2dPNinxkzO/afZpww9ZXzN/vNvfacjv + Mn+LyfztID7JT+vPpl//4BoZGgH5xzbI2BpH/m2yadsuGRwfkKVwfHmw/9nBGbK4HgJQDQEov0eyyh+Q + DRs3K/lp/S9evCzfH1mQ8tm6FtzSQ3/vFCgDpnS/QAVcxVPRPImEW6SJIlAfxINVIbOX/5nMK78XLuBz + klXLRiBcQGimFDbkCPcK4GpBigCRVApoGZAQAiMC1VJQTNQg6wMUAVwpAvlWBFQIltWB+EQ9CEFAAIBs + JwRxAcAVtplDZTpkZjMqyeWgAkACWjFYACEwQ24JJLK1yd5JBJ/83sJ8L8XAET+gSLL5ioCS3vwutta3 + v3N8bJ+wTscQ/8pmnxvmS2T+iKwE8Zn5lfzM/PWo95n5veRnzU/b32GG++Idf0/Tj5mf5F+zfjNIvU02 + b90l23bulV1798uqzqWS3fQAsv8DWv/T/s9b+Wcyf/m9sm58g074OQ/y//WhsSmd808g+78pgfTfs4+9 + Hy5iwYz/NRFO+5dUH9q14M3IH8hoS6OKQCAAa1m9UmaV3CNzyuACVt2npUBWLUqBwExZUcnjxmqEm4dc + IQCuFKAA4OoVgYJiohqEhxDAEagQKJwbqFUBmCwC6gRUBOolu7Ae5G8wAmBFgGRyxFpkiRbPuBZKSFxN + VrYCQMLivREDc3W23SEhFF6y2z9TgPgguvn7hvRKfJvpzdX8brwm1fra3zBz+uNDfKUgP4jvtfwl5eG4 + 5ecwn5f88W5/Y4dO8mkMd9uGH2w/Z/l1DEprPPOPKPkHmPlJftT9o2vGZfW6TSD0Vtm4ZYds27FHdu7e + L3v2HZTh8SFk/gdw33H/K+9R8s8pu1vmlt4jayAA5y68LK+ePSVvd3wq5TN1LZiIpG23j7wfk2MimL4u + 1Yd2rXgtep+0NrdrU3BVTYXMKrobInC3zC6jE4AQQATyahaaswS5fbgVAecEXD+AKCrh3ABciyul0IFC + QBGwboBCYEAXAAFYZkqCPCAXrykCOUW1IAmvIL/FEofCBhAKgBDwuogoaFCiOZCACktGR1AKgiGsI7G9 + Ouh797Xk1/z77vv1tb3G/y3A/fv8fbS7b4lP0SLpvcTXRh+JT8tP8i/3Zn1H/oh2+mn5HfmZ9WtR87vM + 74b6Qi2G/Kz521Hzu4ZfL7L/wMAa1P2G/GNjjvxbZJy7+yj5ub7/Mdn36OPy6KEjUhhcAPLfK/NRDpL8 + s4s/K3OK7oFb2CQXL70q39lYlvJZuhbA5b4da/zwrTvx52dFLPiR34FCTukqQQVs3LHmAolEeAx4tcws + +Kw8bEVgjorAfbKyhrsKNciqCu4vWKsisBxwToALiIwIVHl6AlYAlnlEIEkACJQDywi6AIPcohoAApBK + BArrQCaiHuQiSLR6iIADhYCiYIXAQQnaoNcFuBo4USCxcbWEfmfYv4fvcz/PEV5Jj38zFfFp9Ul6b51v + sr4jPi0/N0/xZn2exRiVlVXNUs5mH4jP49mZ+WvtGH8g1AXyg/io98Mkf6uZ5MOGH4/yYubvAfn7kPkH + re3nQSS6sSfJv2m7bNb1/ST/ISX/gUNP6Ey/7rF2mbsCxC/9rMxaBhR+VuYtu1e2bd8hrz2xecp3+yFg + /3fZR92Pdwp8SH2pPrxrxVsoBdZEG5BVAjJz6aflYYjATIjAbIhA1sqZUlffJDU1PEEYImBdgIqAdQFc + QJTUGLRgOUARSPQE6ASq4uTPX1YN8jvUQAAM1AlYIeBrIwQgfmGtikC2viacEID8BQbJriCBrPx6iAGv + AK/2tSF2vV69AuEVDfP99r2H9O5n67+nYuRqfFOquKxP4juYWt/M6iMSjT6P5UfWp+Un+ePNPmZ+JX8n + yN+p9X4oCtuvM/wG1PZr5gf5u63tZ81P8g+NrpeR1QnbT/Jv2bZbtoP8u7m5x35k/oNH43v7HTx8WGv+ + h4s+I7MKgPxPS2bx/fLYrs3yduc0WP9wxlvSmPZh+5j78U4h1f/7v06E07+V6kO8Vrwe+axEQ0F5OO9u + mZF7l8zMh/JDBIqq8iUQiEqdzhcImBOFeYoQnIDbTDTRGKy2JQEnBzkRmDw64OkLgPgOS/F+qXUEcSFQ + EagxbiAOCICS34hBQgjqZHEBoESkGNTFRcEAZAXRlbS8gsxGGAh+nQQ3f86vGXJbksffG2FRWMKzFHG9 + CTdqEbf6HtIbu59YyOPG9l3WJ7TW5/g+iK+Wn1nfWn7W+9rsQ+Y35Gezr19tPzO/dvt7hqWr15JfM78Z + 6nPkZ8c/Tv6dZmefR7i5h4f8x449J88+96KsDBUiEXwGz8Nd8lDupyR3xRz5u565KZ+da8VE5I7N9hH3 + 42dFLHR7xVR3XxX4mecjcyWz4CF5MBs3PefT6gZqGuukKRiVhkBY6mqvFAHtCQAUAbedGEWgxIlAvDFY + ndwTwOv8ZXADCo8I8ArSTxaBhBCYHkE2oSIAFBgxUBFQQBAoBioCQL69esXAIw5eYYgTnF/nn6ubMM4i + DpA9QXwzSjE525P0nNvg6nxD/Mkd/uRaPz6+z6yvjT6T9bXZB+Kz2Rdk1m/ulUhLn1nZ5zK/JT/H+ftd + zc9uP8mvO/pa2287/kp+Xd57RA499qRu7vHksePylK7vPyWjG4dlRs6n5KHsT8mMJX8qu6vvnvKuP8Gy + luWtfbz9+FkRK//gL+FD+3KqD/NaEcMNXo2a//5Fn5QHF98ls5feK9HmNgmHW6Sx0cwX4CKiaicCFXUJ + IaAjUCFgb6DGiADdAEsDwAwTWicAAVDQDUAYnAgsdVcrBHkUAisGRgB49boBKwSEcwQqBrVWCDywgmCQ + IL8Bv4ei4YjOq/kz12wkdCQCVw5P6hAlM72H9HydqPFdxjfTeL3ETyzkYa1v7X61mdhTWZcY4qsNtGu9 + z6zPYT5afhKfmb8Ftr+tA1kflp/k7+5Dvd8P8jPzW/K7mt9lftb8hvyPIvM/Zsh/6Emt+5/g1l5c4fc8 + p/meliPHngDx78Jz8Empy79T3p6Gut8gvds+2n6824gFb7+PZ6Sn/kCvDW9GPiYr8u6UBxb+iSxZNk/a + 27qlGSIQCiVEwDkBNgYrKr3NQSMCnC9AEfCiGGKQmDZMQaAjoAiYKcQsCVyTUIXAuQGFEYLcwmqQLCEG + OYXJ5YETAgdTHrirQUIU2FRMYPJ7BxLdXR3pDfE5aYnkN+DiJt2bn6S3Gd9L/CvqfDb5LPGTsn7c8tvx + fU+zz2T9AWltR9a35Gezz5F/YHCtsf1jID+In1Tzb3W2/6Cx/QeOykFkfpKfp/keA/mfOW429jx95pyc + OXte5hc+IEuW/B/5dtP0kB/l7Dclesev2cfaj58nJJK+P9WHOhX4+8Y7JGvRnVJUvlQ62nukrbVTItE2 + CQabVQTqG4LaE6itMW6gsoqOwAoBm4ReRzBJBFQI7LThZYBbQ6Ai4GCFwAt1BFYI1BGoEEAQnCtwYsCG + IZAQA9MzYONQgdcUBTeq4L1OhndSEpGK8Lq82e13oMR3m6KaNfuT5/BPHtojSPx4rR8wWT9u+d34Pif3 + MOuT/Jzaa8mvs/tg+804/zqt90fXJMjPg1ZZ87Pbv8eSn5nfkZ+Z/9hThvy0/tzW+9y5S/Ly5c/jd8yW + r9R+NOUzcs2A24yF0ovs4+zHzxuxug/95kQ44zspP9wpwJdr7pDqmhLp7OiR9vZuaW3t0KHCYMiIAHsC + 9fVBFQGOELiywJUGTgjoBpavqEVpYFDiFQIrBioIupLQ4wY4jbiYU4k5aciKgAqBGTY0Q4cUA44UWEHQ + 10SdioIpF8wEI9M7IEBqReK1mX6cTHY3LTnPvnarFx3p3QYnhvjM+iR+ItsnZvFZ4sPqG+Ib0hPxGX2s + 9d8x65shPpKfWZ/NPs36dnafyfyc3rteRsYM+TnDz2X+rdv3yHbdyvtK8nNHX93UE+Tn8l6u8ONMvwuX + Lsurr35BvtY9J+WzMRXQpe7RD/yCfZz9uJpA/VSc6sOdEkChv9z8oPR09UgHRaCtS1pbrAjACTQ1RSWg + bgAlQR03GDFDhVUeR1BOIQCMG6izZw7WJkoDCkIZBAHkT15SbNYRqDOgCHDI0MEzm1DFwE4mohjorEI7 + tTg+u5BCwGsK0Clw5qGuQ9DZh3ZdgoUjvdvEpMBDfCU8YZt7iT35Dekd8Vnjx4f1AK3zPXY/sZAnQXyX + 9Z3ln5z1u0H8eKd/yHb6OcHH1vvrN27TzE/ya+Z/hPv4P6bd/kOHQf4j1vYf446+JD8y/8mX5OzZi3L+ + wsty+fIX5Y1d4Wlp+hFIXD+ONaV9wj7GflxtQEH/DeqoZ1J9yFOFV1ozIQJ90tkJIaATgAhEUQ6ErRA0 + NkaloYFuICS1LAviQtAoFZw3AEdQXgGoI6iLC4ETAyMIFIJauAIDCoDZZcgJAcHlxYnFRbrAyM4mjM8q + 1LUF7mpWHlIQzHuz8pArEQ25PbB7FHCZMlGglj4ZZnNTs9EpszwJzxOQSHo29dxpPF7is6tvrL4hvtb5 + AO0+ye8yvk7nBfnd8J6b2GMafbbL380u/6hu5BFv9rlhPju115F/05ZdhvzeGX4kv7P9TyLzP20y/3Mk + /6kzlvyXYf2/IK8fGOCGHCmfh6nARCR9xD7CflxrSMMdvzsRSvunVB/0lABZ4FxbtvT2DEAEevFAdmtP + oLm5XfsCbA7GhYBDhSgL1BFADKpqAAhBZRVBVxCAENS/gxDUqRCoGAAUgpLldXFR0E1HueMQYDYd4W5D + HoDsuvmIhVt6nLwZCV87gOgWumWZvTokdjYOKNl50InJ8pb0mu2TSe+Iz225XY2flPHjVj+xaYcSn3a/ + GcT3ZH03vMf5/K7L7836avltve8sP5f0cpjPTO/dn0R+jvPrKT72IA+1/S/A9r9obL8j/zcOr5FYdJrq + fgDW/69vyZ1+pzMklL50uuwawWxwtj3XiEB3nzoBlgQtzSgJ6AbCrRIKtkgTRCAQYH8ApQEcgRGCoFRD + CIhKdQUBuAIjBCoGwIpyAyMGCZQCFIHSFfV6NYKQgNmJOAHvfoTJexImY/KmpUlwWR4ojhO+SQnvDt0k + ePCmEt6CJ/EkMn6C+Jy+qzv06ni+Ib4jv9b5avfdpJ4BabEdftb6Juub7btcl5+NPjO5Z6OMwfKT/Mz6 + 47bZx07/rj0c5jscn957yJKf4/yTa35m/gsXX1Hy/82R9RJr/njKZ2AqwJGrWFP6A/ax9WOqQvcPDGXs + SfWhTxUoAmfa86S3d1C6u/ulC27A9AXgBqLGDcSFoKlZAuoIjBDUslkIIahBeUAhqFJHADGAEFAMiJUV + DQarGiAGDbJcBaE+LgQUgSQspygkUJwCbptyopgnF4HwxczoXqwIgOgkewIlSnhzyGYS4S0c6XkCjzuE + g+AxXLoltyU9V+wZ4tvO/qQGH4kfH9fnxh2erB9v9IH4XvKPjI4nzezTen/LTl3Rx3rfzO4zY/wkv2Z+ + buT55HHN/NzRh5lfa/6XYPsvXtaa/2+OjoP8U7u5x2RMhNI32UfWj6kOCaT/Z4jA/031wU8lznfkSH/f + oPTADXR1wQ2gJHBuoBnQ/gCFINSqQsDSwLmCuoawikFNLTckDaI8YInQlCQE5UQFBQGgGFhQEMogCMvx + mtcyiABRuqLhCpQ4rDTXUpC8ZCWAaymvcTSC3CS6QdkqWnqS3YFkN0dsK6oSVx65bep6Z/FZ25utudyu + vHHie60+M763u2+J73btUbsP4rPRFx/bZ6NvxDT6zPi+7fIj6+vMvh17Qf79soeWf//j8U7/Y48nyM8T + fDjF98SLZ3Soj1t5M/OT/H97ePW0Zn5iIprxmm/9pzligY/cORFOn/J9AybjlY6FMtg/KH3WDbA3wKHC + tlYrBHAE0Uh7Qghcj0BdQVTqIQR12jTkzMJQkhhUUhDgDlZVWlQ0QhAaIQgOAZAyAPsNrLKAYygrD0xC + I8gM8KoEN9fljuj2tSM7iT4ZJHp5dQJmA05meWR7EN+Qnt18Q3oewOmIz735zHLdbkN8ncKbIP7kOp8Z + X+0+V/DZJt/AELI+av1hEH8Etf7YpKy/ZZsZ4qPl37vPWP79B4/YTj8P7jSdfs7wU/K/cEZOnYbtR+a/ + cAnkf+WL8vqB/mmt+Qkkph9L8PbP2MfUj+mMWDh9eaqbMKWIZMhftM2W0YEB6e0b0t5AlwqBmzPQqUJA + RCEG4XCbhIBgCOUBSoTGxmYVgoYGDiPCGdTDGUAMaigGQDUFQUUhqIJQWWVQAayqtKgKwi00GVQ0QRgS + V2KFolGv5mskubl6UV4ZSsIqZncS316NrTfWnoSv4lHbkzM9wOO3uCdfYhzfrtO3NX6kFVa/3ZPxSX4Q + XxfwWLvfxyafncc/udYn8V2jbxMbfTrEtx+W/1B8fN/U+4b87PRrs+9Z0+l/4cWzcurMec38XNP/yitf + kDd2h6e126/AszIRSW+xj6cf1yMmIhkbp7MpqMDPf731Ptkw0IOHdljdQKIs4LwB4wi0R6BC0CHhCIWA + k4noCiAE2isAksQggjKBCBsxcKgJqSAYUUiggoAYUBAqqkhgg/jrSv5Z4utxIKNX1HgRkUoFyG5JX0WQ + 8Nbe1wJ1SnpD/HruxWdre4KHcHBDTmb7ULMZy+cMPj2LD8RP6uyzwQfys8HX0w+7D+JrxnfER9Yn8a/I + +pzYs/MR2bmbWT/R5VfLn6LeV/KfPKu7+J47/7JcuvR5+cKll+W7m8qmbZzfC5D/hBT/wb+zj6Yf1yMk + +ge/PBFJO5/qhkw1vtfySdkx0CaDg9x5hjvQoCywQ4YdHSwNOJXYCAERhRhEVAzarSvgFGP2C4wzoCCY + MiEKshkYQYhITR0BYQCqa3mNgKQQBoICQej7MEgcAsL4Gr/HkJtXfa0ZHa/rSPAEqol6nqjbrGSvbbCE + t1DC66Qdkp6dfHPyDrN9MMLjt7r18M1oK9fom4xP0nNvPjOW74jPzr5p8LlpvBzTH0Kdb+w+yO8hvqn1 + d9tan40+M6tPyX/IDPHF5/R7LL92+lHvm2E+kP/lz8uXzp2WH45kpryXU42JcMb/i9Wn/7Z9LP24nhFr + +vBv4AZ8I9WNmWq81fwJOdZXLcMjq1UI+lEW9PRYIYAjaFch6NZ1BXQGFIIWdQYUhM64GITC7eoO4oIA + qENwJUOg2YoCCUphMKihOMTB9ySzfQ1Sx0Fy41qrBLdQklsgs9c3JtDQxAxPwvOATUd41vXmpF2CB26y + rleL7832ID1hsj1rfDb3TI2v4/nejM86f7Wt8yfbfWR9M513n+zUWv9gvNGnXX7b6NPJPSA/m33Hnz9p + mn2nz6HevyAXLr6sw3xff/6QvN316ZT3cKrBuj8WvO1u+zj68V5ELPSRj02Ep3GSkAcT4Tvk5e6lsmZ0 + TIaGxuAGhiEEw3bYkI6AswkJjzOAGLQQLV0Qgy6UCVx0RHSoGBhBaAPpWqVRSwYnCkYYGgItcdRbNJC8 + nvfxr5Pc9mpeW6LzvVp5kFyJ3q5Eb+S5eiB6U5iHa04mPJt5PRLWTM+GnmcYD+hQmz+YRPxez3JdgsRn + xh+B3eeyXWZ8N6ZP4utU3m17dPkuJ/Vo1t/3eNLEHk7pPXLUZv0Ulv+lcxdNvQ/ys9k30fKJlPduOhAL + ZdTYx9CP9zJiobQHtQub4iZNOVBTfrPtftk20idjo8huEAI6gj42Cnu5SaWdQ9BloELQASGgGACtKgYG + yYIARFg2kIwQBQWFwYiDCkRTMgK8BtuSge8PIKs3hkjyBJpA+KADyB4m0YGIWnrU8iB71KKZWR5o4WYc + jvTM9JrtE6R39T2zfe+gtfk243sX7jjiJ3f3zYQeQ/xDunGH6/B7x/Y16z+FrP8sh/jMUt6E5b+klv8L + 51+Sfxpfdl3q/ThCGds4N8U+gn6818FllxOh9GnZPyAVftRypzwzUCtjq9fLKIRgeBgEGGAGHJE+CEEv + ygMtEawQqBjAHbRzOJGCwDKhFUIAtLZCGHClIDRDGKIUBgsKQ9gKRDgCIFvzGsI1xKt77X0fB2t2S3IF + XjO7A0p2Zndby5PsLbaD38r99l2m12xvjtzqAvGZ6U225xg+p+3yFB6u0QfxeRjHqLH6JL5O5FlvrH6i + zndj+vtk195Jdv/gE8nr9ydnfWv5X3rpklyw03r/8vh++XH33Snv0XRhIpJxKlb12//BPnp+3CiBmxOY + fLOmE9xd6KvdWbJ5zaishhCMjfI4KmZC1r8j0t8/bJ2B6RV0QxA4lKjDiRAEgr2DtnaDdnttbesBIQEI + Q/yqYoHsrM6BImGvfK+Z27xWeL/Ov6NEZ1bvNUTH61Zt3pHs5somXhuyu2Z4eyXhu3ptXa8NPTNxp4/Z + fsjswR8n/RiH88b1MA43gy9R4+/SjB8nPuv8R8zQHrO+Du15JvU88aSZzhuv9V84k8j65y/LxYuvyqsX + L8o/7Gya9pl9kwGn+ZexxrRft4+cHzdawAUgzaW+edOFH7T8iTw90iTr1o1bIVgrI8MgyBDFgKfU8rBK + IwbqDgB1B90QBYDugGLQ0WnQqVe6BYIi0YeMDNICLRCM1nYS2H4N2Ztos19LBi08Cc5NNUly7qdv4Ije + 2W0sfUcPbb2r5xOkZ5bXTM/dd9Xiu9o+MZTnDuFwC3bWj5san809JT5qfEf8PY+wzrfdfV26a7r7JP5R + 2H0d3mOHn9N5T5xOGtu/cMHM5//68Uflzb4Hrq/lB5D534iFPvL79lHz40YMXTMQyRhKdQOnE3QDr3XP + l53rhlUI1q7ZIKvH1snoCE+oBWngCgYBDiP2o0ygO3AOocf2DnpARoduoIvkpGvookgYdBIQDSMWJLIH + 9n0nrklwRNerI7olu23g9fSbDG+yvCG81vTazOOBG6aTP2K33x7TvfgStb1me9b3XLBjh/NY4xviHzCr + 9mD1HfG9Y/q6aYe1+25Sz4kXzc49zPrxsf1zZ+VbWyunfVZfSkTSvhcLZNxpHzM/buTQPQSC6WPXO0MQ + bzX/kZwfXCmbxzfI+g2wwmvHZQ3EYIxiMAoSwRk4d0BBILRcGIBTYP8A6EUG7uvDFSSlW1DH4ICvdQO8 + GuEgic3XSGoltH1vMIzvIzg8x6zuuvXAgCH7gIfszPDxWXogPTv4I9x/j5N2SHy7Os9Let2M09p8LtPl + 1F2exMONOUl8N4vPEV+zvt2wQ3fptcQ//lzC7p8+Y4h/gQt5Lr0if/vYyLTs1/9uwKnnsXDavfbx8uNm + CLORSNpgqhs67YDwfK/9M/Lc6pBs3LRZT5xdtx7ZEmKwWsUAZQIwOrJW4QRBRSFJGFg+eADSEioSILKS + 2INeXkHqXnyve91PkuuVE3ISmZ2kVytvoeP0Snh27zlsx3reED5h79nFT2R6kp678HIM39n8xHAeM76d + vuvN+BzWI/HtTD4lPur8506c1KW7ZmiPi3gua4f/68/slR8NPnzd7b4DSso3Y03ps+xj5cfNFGYJcXrX + RDgjlurmTjvw0L7R+YA8ta4d9TAzJQg0bsRg3TpkUhCMMIJgHMLIqBEFjiyMsHyAOAxDFIZZexODFAqX + qTnRhjBfSwJtuwN+nrni5zsbbzO7ZnX+DgozSccRfnKW5zl7Snw7T5/LcxPZ/oCp7/cbq88deV1zj9ne + 1PiJjG9W7nFYDxn/5Etyyk7o4Wy+iy+/Kl89cUS+t24pSqvp2qr7ZwOl5Fux4O1Z9nHy42aNWCitYWKa + thh/N2B/4I2uGfLM+k7Zum2HisHGTVtlfOMW2YAyYb0VBC0X1CWAjKtJTmbihGMYg0BQJAw4/Ghs+rD9 + 2giB7zMgwfE9NpvHM7oD/r3VFCE6E2DtBm+GBzZx2M4QnqfraqYH4ZX0OnGHtT2X5x6UvfvMuXv7H7U2 + /5DJ9q6552bwsbnnrP7zL3AyD1funTdr9i9c1gk9X3nhqHx3wzLU+de3uz8ZsP1vxsIZ8+wj5MfNHmae + wHWaLPQOoBB8u/M+Ob0mKLu3cxYcLPRWkowZljvcsoO+WbGWpFxPgkIYlKwQBxKWr51Q2KuCpMZ1zH7f + Wtbq9vv1vf48CA2JDqwn2QElOzBOwgMbQfpNW3dqlt+ync08Q/gdyPQE63qt7feZufokvZuyS+Ir6Y88 + rbP33Go9Zntn9ZnxOYsvQXxkfNT4X3v2gHxvbe570+CbBDwnP4g1pc2wj44f75eIhW+fCVv3/VQ3/boC + QvDDtk/Jl0ZWyOFt47JzFwi2c7cVBDoEDqElC8MGugXAENeIhJLZXS2pJxM8FcnjREdmJzZzuI62Xsfq + E4R3WZ41/Z5HDsUbetrJ91h8N5THc/fY0Tc234zjc8GOdvVtc887pHf5/AX5q8Nr5YfDc1QcU35W1xkT + 0Yzv+uv638cBEfjDiVDaN1Pd/OsOPPQ/jX5cvtk7V85saJVH9+yV3XsehSAw23IYjZYbwrAd2VizMuvv + hEB4X1/5NUNuJbj+XQMluiezb9fJOSa7m1qehGc9z+m5ILxdjuvsfXzSzmGX6WHxSXrb1NNsf/wFre+5 + LRezvRvOM8S/LF9+/qi8sbVG3m7/1HvW3EsFPhexpvSP20fFj/drxIK3/0/c8JcnPwDvKUCEt1rulG8M + Zsupzb1ycO8jIB/q60cOqCjs2r1fCUpQHBwoEgoQegcJjde8Ktz34fVOdugVLrObYTrXvNOZeSS8zfBu + 2E6tPRt5yPAJe+/N9CD9s7T4ZtYeJ+9wlR4bexzKI+nPn39ZvnjimPzd7lb50cBD72lj750A8n/JP8Dz + FgqJ3varE5H0nTdSBooDv9OPm/9IXh9YJJc2tsixPdvlgGZh1tzssnOYzWDvvgNajxM8HCP+Gl/3vjfk + JtiwI8k5REeic2KOI7vZV59Tcr2EP2rr+SePPSc8YovNPF2cc/xFO4THiTunkenPymlb2184e06+8vQj + 8vqOkPyof8YNSXoFPuuJcNpT3G/SPhp+3CrBYcJYOK16IpzxVsqH40YAH9DIR+Wfu++Tvx4tkktbOuSZ + fTvlMDfJYP1NS84sjfccbz/A1XQW5mts0BlyH9TvY0bH3zlsiO6W3LrGHcHsrtNyUcfHCR+39iS92XXX + 2XuO3Z8/dVq+9NQ++cbuNvnumjzY+z819v5GFFgLDg/rXJHobb9oHwk/bsWACHx6Iprxt6kekhsOIBSz + 6Y9QP78xuEC+vrZCXt7aJS/u2ypPPXZQjhw5piTm8Bsn3CipvVcPlOTI6prZQXKCZ+erpY+T3Ryrpctw + T56WUy+eknPPPyNfPLpLXtvbK29sXCU/GJojP2m984YnvBe439+PRdLz7CPgx60esWjGf58Ipz95szzA + SYgC+L0nIh+DMNwl3+mfLd8cXSqvra+Ur2yJyud39sulR9bJuQNb5cxje+Tk44/KySOH5OSTR4CjcurY + 43IaeOnJg3Lh6D55+fGd8sWD4/LnjwzJazta5O82Vsq31hTIDwZmyY/bPymxMOy8/TdT/j43Mvg5hTK+ + GmtMy7C33g8/THD6MLJCFWzhtG87ft1AkhJRkhbAa+6SSxfB0sKB73X33Enfq/D+vJsYavmj6Vti0Q/+ + R3vL/fDjypCm2z46EUl75f308N/qmIikfzsWSsu2t9gPP/71kOjv/HuUBK2wi2+meqB83CSAiIP8z3Lo + 195aP/x49xGLpmWgJLjgu4GbD7D835FwejFLO3s7/fDj5w8e+hCLZJRDCK7L7sM+rg1a60fS9saafv+3 + 7C30w49rj1j0Q78p0YxtE6H0n6R68Hy895iIZPw57P599pb54cfURyyc9sd40E75ZcGNg4lQ2rdi4fRK + 9m7sbfLDj+kLHTIM3T4XbuArvhC8d+DS3Ylwen8s8OH/Ym+NH35cv+A00lgoowB151/6QnD9gIz/L3Bh + a/zuvh83RNB66qYj4Yyv+kIwTcDnCsf1zyD+mL9yz48bMnTEIJS2AEJwDg/qe7MX4fsNJH4k7XUJ397s + H8rhx00RXGkowYxPTkQz9tCu+q7g5wfq+4mJaPqZWOj2XB4Hbz9aP/y4uSIWTf/tWCijEY7ga74Q/AxE + QfxwxhsTkfQxfGYfsx+hH37c/CHRD/wCxOAuCMFGuIJ/8MXAghY/nP59EP/RWDh9lp/t/Xjfh0R/45e5 + 8+xE+PatEIQ3bjkxIOkjGd/GdX8scnuWP4znxy0bsfIP/pJuShJM70cmfHUimPYTXW+fijg3K9Tap709 + EbnjlYlQel8smnG3f8S2H36kCA5xof5diDp43UQ0/csQhbduKofA3zVh68+B8AMSSpvNqdT2v+iHH368 + 2+DQFxzCvbFQehCicAiZ9C+AHynR3sudefTfv4OZ/acTkbR/nIhmvITXG2PB28u4/bo0/N5/sv8FP/zw + Y6pChxgrfufX2CXn8VWxYHr9RChtHNn2SeALHDPX7BtMN8ehWaImg1+bDM+fW1HBz4vh57zJpiVHMfBz + X0BG34UypT0WTMvHv32XNHzodzn/wf56fvjhx3sZkvmBf8ttz9U5hNI/FGtK+0QsfMdnY+H0B/B6Dicq + cXccCEhuHMH0Rfje+RCUmfh79yKL/0ks9JHbY013/BYzub9zrh9++OGHH3744Ycffvjhhx9++OGHH374 + 4Ycffvjhhx9++OGHH3744Ycffvjhhx9++OGHH3744Ycffvjhhx9++OGHH3744Ycffvjhhx9++OGHH374 + 4Ycffvjhhx9++OGHH3744Ycffvjhhx9++OGHH3744cd7GB/4wP8HlOWJxxjDymUAAAAASUVORK5CYIIo + AAAAgAAAAAABAAABACAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA/wEAAP8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + f/8CLH3+RS19/Z0ufv3iLn7//y5+//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln7//y5+//8sfP3rLX/9ri18/lokf/4OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAM2b/BS18/nUufv3uLn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln79/i1+/bQsef4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAff/8ILXz9oi5+//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//LH3/8Cx8/lYA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAs + e/5bLH39/C59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8tfv3aJ3/+GgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtf/2YLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln79/i18/k4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuf/2eLn3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//8s + fP9QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAufv5tLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8sfv38J3f/IAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkef4VLX79/C59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Lnz90QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALX79qS59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx4/jkA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALnP+Cy58/f0uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y5+//8vff7/P4X3/1WP7f9hk+b/aZbj/2yY4/9nlub/XpTr/0qL9P82gfv/Ln7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y1+/b4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC55/lgu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y5+//9SjOr/jaHJ/7Swsv+1sa//trCv/7axsP+2sK//trGv/7eysP+4 + s7H/ubOy/7u2tP+8t7X/vbi3/766uf/Bvbv/w7++/8fCwv+tuND/bJvp/zB+/v8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//yx9/foAAP8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtff25Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//OIH4/4acxv+wqqr/rain/6unpf+q + p6X/qaak/6mlpP+ppqT/qaak/6mlpP+tp6X/rKel/62pp/+xqqn/sauq/7Otq/+1r67/t7Gw/7izsv+6 + tLT/vbi3/7+7uf/Bvrz/xsHA/8rGxf+yvNP/UI70/y5+//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//8qf/8YAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALX797C59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + fv7/epfJ/6ilpP+loaD/o5+e/6Kfnf+gnZv/oJ2b/6Ccmv+fm5n/n5uZ/5+bmf+gnJr/oZ2b/6Gdm/+i + npz/pKCe/6Whn/+moqD/qKWj/6umpf+tqaf/sKqo/7Ksqv+1r67/t7Gw/7q1tP+8t7b/v7u5/8S/vv/H + w8L/zMjH/6a32P8zgf3/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8sff45AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAACx8/fsuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//82gfj/lp2s/6Kfnv+fnJr/nZqZ/5uYlv+alpT/mpaU/5qVk/+Z + lJP/mZST/5mUk/+ZlJP/mZWS/5qVk/+alZP/m5aU/5yXlf+dmZb/npqX/5+bmP+gnJr/oZ2b/6Sgnv+n + o6D/qaWj/6yopv+wqqn/sqyq/7awr/+4srH/u7a1/724t//Dvr3/xsLA/8vHx//IyM//RIn4/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8s + ev5RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wEufv//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8zgPr/mJyk/52amf+a + lpX/mZSU/5eSkv+VkZL/lI+P/5WQkP+Ujo7/lI6N/5ONjf+TjYz/k42M/5ONjf+Ujo3/lY6O/5WPjv+V + jo7/l5CP/5eRkP+YkpH/mpOS/5qVk/+cl5T/nZiV/5+bmP+hnJr/pJ+d/6ejoP+qpaP/r6in/7Grqf+1 + r63/t7Gw/7q1tP++uLj/wr68/8TCwP/MyMf/ycnP/ziD/P8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8rff5TAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAP8BLn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8ufv//gpSz/5qXlv+Xk5P/lZCR/5SPj/+SjY3/kIuL/5CLiv+Pior/jomJ/46JiP+O + iIj/joiI/46Ih/+OiIf/joiH/46Ih/+Oh4f/j4mH/4+JiP+Rion/kYuJ/5KLiv+UjYz/lY6O/5WPjv+X + kJD/mZKR/5qVkv+dmJb/n5qX/6Gcmv+moZ//qaWi/62opv+xq6n/tK6s/7axr/+7tbT/vri4/8O+vf/H + w8L/zcnI/7C+1/8ufv//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8te/4+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//R4Tn/5mVlf+VkpL/k46O/5CMjP+O + ion/jomJ/42Ih/+Lhob/i4WF/4uFhP+LhYP/ioSC/4qEgv+JgoD/iYKB/4mCgf+Kg4H/iYKA/4uDgf+L + g4D/jISC/4yEgv+NhoT/jYaF/46IhP+PiIf/kImH/5KLif+UjYv/lY6N/5eQj/+ZkpD/m5WS/56Yl/+g + m5j/pJ+d/6ikov+sp6X/saup/7SvrP+3srD/u7W1/767uf/EwL7/ysXF/9DMy/9fl/H/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8re/4dAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAsfP37Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//4GQq/+UkJH/kY2N/42Jif+NiIn/i4aG/4qFhf+JhIL/iIKC/4iBgP+Gf3//hn9+/4V+ff+E + fXv/hHx7/4R8e/+EfHr/hHx6/4R8ev+EfXr/hX16/4Z9e/+GfX3/h359/4mAfv+Kgn//ioJ//4yDgf+N + hIL/joWE/4+Hhv+QiYf/koqJ/5SNjP+Vj4z/l5GP/5qUkv+cl5T/n5qX/6OenP+no6H/rqim/7Ksqv+1 + rq3/uLOy/723t//Avbv/x8LB/8zKyf+7w9X/Ln7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8zZv8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH796i59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//zF/+/+VkpH/kIyM/46Jif+Lhob/iYWF/4iDg/+H + goH/hX9+/4R+ff+CfHv/gnx6/4F6ef+AeXj/gHd2/4B3dv+Ad3X/f3Z0/4B3dP+Ad3T/gHd1/4B2dP+B + d3X/gXd1/4J4dv+DeXf/hHp3/4V8ef+FfHn/h317/4h/ff+JgX3/i4N//42Egf+OhYP/j4eH/5GJh/+T + i4r/lY6N/5iRj/+alJH/nJeU/6CbmP+ln53/qaSi/6+pqP+zrav/trCv/7u2tf+/urn/xcC//8rHxv/R + zcz/OYT8/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y58/f0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC1+/bQuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9A + gev/kY6N/46Jiv+Kh4b/iIOE/4WAgf+Ef37/g359/4F7ev+AeXn/fnd3/393df9+dnT/fXVz/3x0cv98 + c3H/e3Jw/3tyb/98cm//fHJv/3xyb/99cm//fXJv/31zb/9+dHD/fnRw/390cf+AdXH/gHZz/4F2dP+D + eHb/hHl2/4V6eP+HfHr/h358/4mBfv+Mg3//joWC/4+GhP+QiYf/k4qK/5WNjP+YkI//mpSR/52Ylf+h + nJn/pqGf/6ympP+xq6n/ta+t/7mzsv+9uLf/w7+9/8nFw//QzMv/Xpbx/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59/dgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfP5OLn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//VIXT/42Jiv+Lh4f/iIOE/4WAgf+Efn7/gXt6/4B6ef9+ + d3b/fXZ1/3x0c/97c3L/enJw/3lxb/95cG7/enBu/3pwbP95b2v/eW5r/3lua/95bmr/em5q/3pvav97 + bmr/e25q/3tvbP98b2z/fG9s/31wbP99cW7/fnNv/4B0cP+AdHH/gnZz/4J4dP+Eenb/hnt3/4d9ev+J + f3z/i4J//42Egf+Ph4T/kYmH/5OLiv+Vjo3/mZGP/5uWkv+emZb/o56b/6mkof+wqqj/s62r/7eysP+9 + t7f/wb27/8bDwv/Oysn/hKjm/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y58/l4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAKn//Bi59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//1+Fxv+M + iIn/h4SE/4WAgf+Dfn7/gXt7/354d/98d3b/e3V0/3pycf95cW//eHBu/3dwbf94bmz/dmxq/3Ztav92 + bGn/dmtp/3draP93a2j/dmtn/3drZ/93amb/d2tm/3hrZv93amb/eWtm/3lsZ/96bWf/em1o/3ttaf98 + b2v/fW9r/31xbP9+cm7/gHRv/4F1cP+Cd3P/g3h1/4Z7d/+IfXr/iX99/4yCf/+OhIL/j4aE/5KKh/+U + jIv/lo+O/5qTkf+cl5T/oZyZ/6ahn/+uqKb/sqyq/7awr/+7trX/wLu6/8bCwf/Oysn/mLLh/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//zNm/wUAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfv36Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//9ehMX/ioeG/4aCg/+Df37/gHp7/314d/98dnb/enRz/3pycv94 + cW//dm5s/3Vtav91bGr/dWtp/3RqaP91amf/dWpn/3VpZf90aGP/dWll/3ZpZP92aGT/dWdj/3VnYv92 + aGP/dmhi/3doY/93aGP/eGlk/3hoZP94aWT/emtl/3psZv97bWf/fG5o/3xuaf99b2r/fnBr/39zbv+B + dG//gnVy/4R5df+Fenb/iH16/4l/ff+Mgn7/j4aD/4+Ihf+Si4j/lY6N/5mSkP+blpL/n5qX/6Wfnf+q + paP/saup/7awr/+6tbT/v7u5/8bCwP/Oysn/mLLg/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln398wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXz9kS59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//UYLR/4mFhf+F + gYL/gX18/395ef97dnb/eXNz/3lycP92cG7/dW5s/3Vsa/90a2n/dGtp/3NpZv9zaGX/c2hk/3JnY/90 + Z2P/dGdi/3RmYf90ZWD/dGVg/3RmYP91Zl//dWVf/3VlX/91ZWD/dWVe/3ZmX/92ZmD/dmZg/3dnYf93 + Z2H/eGdh/3hoY/96amT/empl/3tsZv98bWj/fW9q/35wa/9/cm3/gHRv/4N2cv+EeHT/hnp3/4h+e/+J + gH3/jYOA/4+GhP+Riof/lIyL/5aQjv+alJH/npmW/6OenP+ppKL/sKqo/7Wvrv+6tbT/v7q5/8XBwf/N + ycj/hanl/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//LHv+YQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9//wguff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y923f+HhIL/hoKD/4F8fP98d3b/enR0/3hycf92cG//dG1s/3Nrav90 + a2n/cmln/3JpZf9zaGX/cmhk/3JnY/9zZmL/c2Zh/3JmYP9zZWD/dGVg/3NlXv9zZF7/dGVe/3VlXv90 + ZF3/dWRd/3ZkXf91ZFz/dmRc/3ZkXP92ZFz/d2Vd/3dlXf93ZV//eGZf/3hnYP95aGL/eWhi/3pqY/97 + a2X/fG1n/35vav9+cGv/f3Jt/4F0b/+DdnP/hHh1/4d8ef+If3z/jIJ//4+Fg/+QiIb/k4uJ/5aOjf+a + k5H/nZiV/6Gdmv+opKH/sKqo/7Wurf+5tLP/v7u5/8XBwP/Oy8n/MHHJ/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALX398S59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8wfvv/O1lJ/3J4cv+B + fXz/fHd3/3dycv92b2//dG1t/3Nsav9zamj/c2po/3FpZv9xZ2T/cWdk/3JnY/9yZWL/cmZh/3FlYP9y + ZWD/dGVf/3NlXv9zZF7/dGRd/3VkXP90Y1z/dWNb/3ViWv91Y1r/dWNa/3ZjWv92Ylr/dWJa/3djWv92 + Y1r/d2Rb/3dkXP93ZFz/eGVd/3hlXv95Zl//eWdg/3loYv96amP/e2tl/31taP99bmn/fnBr/4Bzbf+C + dXH/g3Zz/4Z6dv+IfXr/i4F+/42Egf+PiIX/kouI/5WOjf+ZkpD/nJaU/6Gcmv+opKH/r6qo/7Wvrf+5 + tLP/wLy6/8fFxP86WEj/L3z0/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8v + ff29AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt7/jouff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//2Zxa/8+XUv/TGdV/314eP94cnP/dW5u/3Jra/9yamn/cmpo/3FpZ/9w + aGX/cWdk/3BmY/9xZmL/cmVh/3JmYf9zZmD/c2Vf/3NlXv9zZF3/dGRd/3RjXP90Y1v/dWNb/3ZjWv91 + Yln/dmJZ/3ZiWf92Ylj/dmFY/3diWP92YVj/dmFX/3dhWP92Ylj/d2FY/3djWf94Y1r/eGRa/3hlXP94 + ZV3/eWZf/3lmX/96aGL/empj/3trZP99bWj/fm9q/39xbP+AdG//g3Zz/4V5df+HfXr/iYB9/42EgP+P + h4T/kouH/5WNjP+ZkpD/nJeU/6Gcmv+no6H/sKqo/7awrv+8trX/trey/z5fTf89XEr/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8qf/8GAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9ugKT/VGpc/0JjTf9E + aVH/eXN0/3Vubv9zbGz/cWpo/3FpZ/9waGb/cGhl/3BnY/9xZ2P/cmZi/3JmYf9yZWD/dGVg/3NlX/90 + ZF7/dWVd/3VkXf90Y1v/dmNa/3djWv92Y1r/d2NZ/3diWf93Ylj/d2FX/3dhV/94YVb/d2FW/3dhVv93 + YVb/d2FW/3hhVv93YVb/d2FW/3hiWP93Ylj/eGNa/3hjW/95ZFv/eGRc/3lmXv95Z2D/eWhh/3prY/98 + bGX/fW5p/35wa/+Ac23/gnVx/4N4dP+HfHj/iH58/4yDf/+Ph4T/kYmH/5SOjP+ZkpD/nJeU/6Gcmv+o + pKH/saup/7exsP9ffGr/QGVO/z9hTf+lscr/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//yx+/doAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt7/lcuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//On/t/4B8ff9PaVf/RWpR/0hwVP9kcmf/c2xt/3FqaP9xaWf/cGhm/29nZP9w + ZmP/cWdj/3NmYv9yZmH/c2Zh/3RmYP91Zl//dWVe/3ZlXf93ZV3/dmRc/3dkW/94ZFr/eGNZ/3hjWf95 + Ylj/eGFX/3liV/95YVb/eWBV/3lhVf95YFX/eWBU/3lgVf95YFX/eWBV/3lgVf95YFX/eGBV/3lhVv94 + YVb/eGJX/3hiWf94Y1r/eWRb/3hlXP95Zl//eWdg/3pqYv97a2T/fW1n/31vav+Acmz/gXRw/4N3dP+G + e3f/iH57/4yCgP+Ph4T/kYmH/5SNjP+YkpD/nJeU/6Kdm/+qpqT/sqyq/0d0WP9DbFP/QmZR/7y4t/9P + jvT/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yRt/gcAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//+Cfn//e3d3/1VtXP9H + cFT/S3da/02BX/9ya2n/cWpo/3BnZv9waGX/cWdk/3JnY/9yZ2P/c2di/3RmYf91ZmD/dWVf/3VlXv93 + ZV7/d2Rc/3dkXf94ZFv/eWRa/3hjWf95Yln/eWJY/3piV/96Ylf/e2FW/3pgVf97YVX/emBU/3pgVP97 + YFP/e2BT/3pfU/96X1P/el9T/3pfU/95YFT/emFV/3phVf95YVb/eWFW/3hiV/94Ylj/eWRa/3lkXP94 + ZV3/emdf/3poYf97a2P/fGxm/31uaf9/cmz/gXRw/4J2c/+Ge3f/iH57/4uCf/+OhoP/kYmI/5WOjf+Z + kpH/npmW/6OfnP94kX//S3td/0hzV/9Ca1L/uLSz/87Lyf8ufv//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln790gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt9/jsuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//XX61/3x4eP93cnL/XW5h/0t0Vv9OfVz/UYdi/2Z2Z/9waGb/cWhl/3JoZP9y + aGT/c2dj/3RnYv91Z2H/dWdh/3ZmYP93Z2D/eGZf/3lmXv94ZVz/emVc/3lkW/96ZFr/emNZ/3tjWP97 + Ylf/fGJW/3xiVv97YVX/e2BT/3xgVP98YFL/fGBS/3xgUv98YFL/e19R/3tfUf97X1L/e19R/3tgUv96 + X1L/el9T/3pgVP95YFT/eWFV/3hhVv95Ylj/eWNa/3lkW/95ZFz/emZf/3lnYP97a2P/fGxm/3xuaf9/ + cWz/gHNv/4N2c/+Fe3f/h358/4uCf/+OhoT/koqJ/5WOjv+ak5L/npqW/1CJZP9NgV//SXVZ/0NtU/+3 + tLL/xsPC/4+s3/8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXz99y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+/v99eXr/eHJz/3Nub/9q + bmf/SXJV/05+Xf9SimP/VZBq/3BnZP9xaGT/c2hk/3RoZP91aGP/dmhj/3ZoYv93aGL/d2dg/3hmX/96 + Z1//emVd/3tlXP97ZVv/e2Ra/3xkWf97Ylj/fGJX/31iVv99YlX/fWFU/35hU/9+YVP/fmBS/31gUv9+ + X1H/fl9R/31fUf9+X1H/fl9R/3xeUf98XlH/fF9S/3tfUv97X1L/e19R/3tgU/96YFT/eWBV/3lhVf94 + YVf/eWJZ/3lkWv95ZVz/eWZf/3lnYP96amP/fGxm/3xuaf9+cWz/gHNu/4J3dP+Eenb/iH58/4yDgP+O + hoX/k4uK/5aQj/9sknn/UIxm/0+CYP9JdVf/SHBX/7m1s//Cvbz/y8bG/y5+//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8tfP2cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACp//wYuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Znui/3l0df90b3D/cWxs/3FsbP9Jc1T/T35a/1OIYf9Xkmz/YIlt/3NoZf90 + aWX/dWll/3ZoZP92aGP/eGhi/3loYv95Z2D/emdf/3tnXv97Zlz/fWZc/31mW/99ZVn/fmVY/35kV/9+ + Y1b/f2NV/39iVP+AYlT/f2FS/39hUf9/X1D/f2BQ/39fT/9/Xk//fl1P/4BjV/+RhoL/nJud/3xbUP+A + ZFj/fWFW/3xdUP98XlH/e19R/3tfUv97YFP/emBT/3phVv95Ylb/eWJY/3hjWv95ZFz/eWZe/3lnYP96 + amP/e2tl/3xuaf9+cWz/gHNv/4N3dP+Fe3f/iH99/42DgP+QiIX/ko6J/1aWb/9SjWX/ToBe/0p1WP9g + eGj/trKw/723tv/Ev7//oLTX/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXz9qC59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//96dXf/dXBx/3FsbP9x + a2r/cGpo/0xzVf9Pe1v/U4hh/1iSav9ZmG//cG1l/3VpZf92aWX/eGlk/3hpY/96amP/emlh/3toYP99 + aF//fWhe/31nXf9+Zlv/f2Za/4BmWf+AZVj/gWVX/4FkVv+BY1X/gWJT/4FiUv+BYVH/gmFR/4FgUP+B + XlD/hWhc/5eOi/+hoKL/oaGi/6Cgov+gn6H/fVtO/4RoXv+enZ//mpiZ/4p6df98XlP/e15R/3tfUv97 + YFL/emBU/3phVv95YVb/eWJX/3hjWf95ZFz/eWZe/3lnYP96amP/e2tm/3xuaf9+cWz/gHRv/4J3dP+G + e3j/iYF+/42Egv9cnHf/VZVv/1SNZf9MgF3/SnZY/4GEf/+xrKr/t7Ox/7+5uf/IxMP/Ln7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yt9/kcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAufv//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//W3mv/3Zycv9ybW3/cGtr/3Frav9waWj/UnBZ/096Wv9Uh2D/WZNp/1qYb/9c + oHj/d2pk/3ZrZf94amT/emtk/3xrZP99amP/fWlh/39pYP9/aF//gGhe/4FnXP+BZ1v/gmZZ/4JlWP+C + ZVf/g2RV/4NkU/+DY1P/g2JS/4NhUf+FZVj/nZWT/6Wlpv+mpab/pqWm/6Wlpv+lpab/pKSl/6OjpP9/ + W0z/hWhc/6Cgov+gn6H/np6g/5ybnv+Xk5P/hXFp/3teU/97YFP/e2BU/3pgVP95YVb/eWJX/3ljWf95 + ZFz/eWZe/3lnYf96amP/e2xm/3xvaf9+cW3/gXVw/4N4df+GfHr/eI99/1medP9Wl23/U4xj/09/Xf9J + dlj/lZCO/62opv+zrq3/u7W1/8G/vv+Hp9//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Lnz9+QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXj/ES59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//94c3T/c25v/3Bra/9w + amn/cGpp/3Fqaf9qa2T/TXhY/1SFXv9YkWf/W5pu/12gdf9ok3b/eWpl/3trZP99bGX/fmtk/39rYv+A + a2H/gWpg/4FqX/+CaV3/g2hc/4NoWv+EZ1n/hGdY/4VmVv+FZlX/hWRU/4ZkU/+FY1H/hWJR/41yZ/+p + qKr/qaiq/6moqv+pqKr/qaiq/6ioqf+op6j/p6ao/4BaS/+HaVz/pKOl/6Kho/+hoaP/n56g/56dn/+c + m53/m5qc/5KMi/9/aWD/el9V/3phVf95YVf/emNZ/3ljWv95ZFz/eWZf/3ppYv95amP/e2xn/31vav9+ + c27/gXZx/4J6df9bpXv/WZ1x/1eWa/9Ti2P/Tnxc/0x0Wf+dmZf/qKOi/7Cqqf+3sbD/vri4/8fDwv8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//HHH+CQAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAufP+gLn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//PH3l/3Rwcf9xbGz/b2tr/3Bqaf9xamn/cmtq/3Rraf9NeFj/U4Fc/1iOY/9d + mG3/XZ9y/16le/91dmn/fGxl/35sZf+AbGT/gWxj/4NsYv+Da2D/hGpf/4RqYf+GbWT/jXhv/5B+d/+T + g33/kX53/5F7cv+NcWX/iWhb/4diU/+HY1H/j3No/62srv+tra7/rayu/62srv+srK3/rKut/6uqrP+q + qqz/gVpK/4lpXP+mpqj/pqan/6Skpf+ioqT/oaCi/5+eoP+dnJ7/m5qc/5mYmv+WlZf/jIOC/3xkXf95 + YVb/emNZ/3hjWv95ZV3/eWdg/3loYv95amP/e21n/31va/+Ac2//YKmA/12keP9Zm2//WJVq/1KJYv9M + eVr/cXxx/5uXlf+jn5z/qaak/7KtrP+6tbT/wr69/0iK9f8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff3BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC5+/f4uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9udIP/cm1u/3Bra/9w + a2r/cmtq/3Jrav9zbGv/dWxq/1VxWf9Sflv/V4tg/1yXa/9fnnH/YKR4/2Cof/9+bGb/f2xl/4FsZP+E + b2j/joJ+/5qWl/+fn6H/oaGj/6Sjpf+mpaf/qKep/6moqv+rqqz/rKut/62srv+tra//r66w/4pjUf+R + dWr/sLCx/7Cwsv+wr7H/sK+x/7Cwsf+vr7D/rq6v/62trv+EW0v/h2FQ/6GZlv+pqKn/p6an/6Wlpv+j + o6T/oaGj/5+fof+enZ//nJud/5mYmv+Xlpj/lZSW/5GPkP+EeXb/eWNd/3hjXP95Zl7/eGZf/3loYv97 + bGX/fG5o/2maff9eq37/XaN3/1qbbv9Xkmf/UoZg/0x5Wv+HgYD/mpST/56amP+loqD/rqmo/7axsP+9 + uLj/rrjL/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//3RwcP9wa2z/b2pq/3Fsa/9ya2r/c21r/3Rsa/93bmz/cGxm/1N7WP9W + h17/XJRo/16bbv9hoXT/YqZ8/2Sngv+Kf3v/l5WW/5uanP+enZ//oJ+h/6KhpP+ko6X/pqan/6enqf+q + qav/q6ut/62trv+urq//sK+w/7Gxsf+xsbL/i2NQ/5N2av+zs7T/s7O0/7Oztf+zs7X/s7O0/7Kys/+y + sbL/sbCy/4VbSv+HXkr/hV1K/4RdTP+McGT/op2b/6amp/+kpKX/oqGj/6Cgof+dnZ//m5ud/5mYmv+W + lpj/lJSW/5GQkv+Qj5H/i4iK/39ybv94ZV//eWdh/3lpZP9yf2//X6yC/1+oev9coHP/W5ls/1aOY/9R + gV3/Vnhe/5GLiP+WkZD/m5eV/6GenP+ppqT/sayr/7m0s//Cvr3/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y17/msAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAACp6/zAuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//85fej/cW1u/3Bra/9v + a2r/cmxr/3NsbP91bm3/dW5s/3hvbP94bmr/UXhY/1eEXP9cj2T/X5hq/2GecP9ho3f/dMqq/4HCsv+a + mpz/nZyf/5+eof+hoaP/paSm/6Cbmv+TgHj/j3ds/5N8cv+ej4r/q6em/7Gxsv+ysrP/s7O0/7S0tf+M + Y0//lXZp/7a2t/+3trf/t7a3/7a2t/+2trf/tbW3/7W0tv+0s7X/h1xK/4lfSv+HXkr/h15K/4ZeS/+E + XUv/g11O/5B6cv+hnZ3/o6Kj/5+fof+enZ//m5qd/5mYmv+WlZf/k5OV/5GQk/+PjpD/jYyP/4uKjf+G + goP/eG1p/1+thf9fq37/X6V3/12gcf9al2r/VIhh/098Wv98eXX/j4iI/5SOjf+Zk5P/npqY/6WhoP+t + qan/tbGv/766uf9Bhvf/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln79/gAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK379ny59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//150m/9wbGz/b2tr/3Fra/90bWz/dG1t/3Zvbf94cG3/e3Fv/3xxbv9o + b2D/VHxY/1qIXf9elGX/YZtt/3G7lf93y6n/eNCz/5Cyqv+fnqD/oaGi/6Ojpf+lpKX/iWhc/4pqWv+M + aln/jGhX/4xoVv+NZlT/jWZX/5+Lg/+zsLH/trW3/41jT/+Xd2r/uLi5/7m4uv+5uLn/ubi5/7i4uf+5 + uLn/t7e4/7e2uP+JXEr/jGRQ/4lfT/+IXkr/h19L/4ZeSv+FX0z/hF5L/4JdTP+CYFL/k4R+/56dnv+d + nJ7/m5qc/5iXmf+VlJb/kpKU/5CPkv+OjpD/jIuN/4qJi/9yz7H/asCc/1+meP9fonP/XZxu/1qSZv9T + g13/T3hZ/4V9e/+NhoX/koyK/5aRkP+bmJX/oZ6c/6ilpP+xrKv/urW1/4+o1P8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//JXr+GwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAue/3zLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//cW1v/3BsbP9w + a2v/c25t/3Rtbf92cG7/eHBu/3pxb/98cnD/fXNv/3xvbP9UeVX/WINZ/16QYv9imWn/dcCa/3jKp/96 + zrH/etO8/5yopv+jo6T/paWm/6moqv+qqKr/mYeA/4xpXP+NaFj/jmhV/45nVP+OZ1L/j2ZS/45kUf+Q + aVn/kGRP/5h3a/+6urv/u7u8/7u6vP+7u7v/urq7/7q6u/+6ubr/ubi6/4tdS/+Tbl7/trW3/6+rq/+V + em7/h15M/4deS/+FX0z/hF9M/4NfTf+CX03/gV5P/4FkWP+Siof/mZia/5eXmf+UlJb/kpGU/4+Okf+N + jI//d824/3LMrf9xyKP/bL2U/16dbv9clWf/Volf/1F+Wv9xdmz/h399/4uDgv+PiYj/lI6N/5mUk/+e + m5n/paKg/6+qqf+3srH/wLu7/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8s + fv3eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5///8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y5+//9xbW3/cWxs/3Jtbf91bm//dW9u/3hxb/96cnD/e3Jw/350cf+A + dHD/gHRw/2RyXP9YgFj/Xo1g/2KWZP9ln2//ecij/3vNrf990rj/hNjD/6ampv+np6j/q6qs/62srv+w + sLH/srKz/6+rqv+YfnP/jmZU/5BnU/+QZ1H/kGZQ/5FmT/+QZU//mXlr/7y8vf+8vL3/vby9/7y8vf+8 + vL3/vLu9/7u7vP+6urv/jF5K/5RvX/+4uLn/tra3/7W0tv+ysrP/qaSi/49xZP+EXUz/hV9N/4RgTv+C + YE7/gWBQ/4BhUv99X1P/gWph/5WTlf+TkpX/kJCS/4LFt/900LX/c8qq/3LIoP9vwZb/X5ts/1ySZP9W + hV3/UHtZ/311cv+EfHr/iYGA/42Ghf+RjIv/l5GR/5uYlv+in53/qaal/7Ovrf+9ubj/Ln7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//MX32/3BsbP9x + bGz/cm1t/3Vubv94cXD/enJx/3tycf9+dXL/gHZy/4J3c/+DdnL/fW9q/1Z7V/9chln/YpFh/2SZZf9m + nW3/d8Kf/3/Rtf9/1sD/k93N/6qpq/+trK7/r66w/7Kys/+0s7X/tra2/7i3uP+5ubn/sqqo/5h1Z/+Q + Y1D/k2ZP/5JmT/+beWz/v76//76+v/+/vr//vr6//769v/+9vb7/vb29/7y8vf+NXkv/lnBg/7q6uv+5 + uLn/t7a4/7S0tv+zsrT/sbCx/66trv+hmJb/iWle/4FdT/+BX0//gWBR/39gUv99YVT/hHFp/5WUlf+Q + t7D/eNS+/3fPsv91yqf/c8af/3C/k/9gnGr/W49j/1WCXP9udmb/f3Vz/4J5eP+Hf37/i4WD/4+Kif+V + j4//mZWT/5+cmv+npKP/sKyq/7m1tP81gPv/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59/Y4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABV/wMuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//9Fd83/cGxt/3Jtbv9zbm7/dnBv/3lycf97c3L/fXVy/391cv+B + dnP/gndz/4R2cv+DdW//ZHFa/1qAV/9gjF3/ZJdk/2acaP9nnG7/Z551/3rFqf+J2sj/o+DS/66ur/+x + sLL/tLS1/7a2t/+4uLn/urm7/7y7vf+9vL3/vr6//769vv+voZz/k2ZQ/517bf/AwML/wMDC/8DAwf/A + v8D/wL/A/7+/wP++vr//vr6+/41eS/+XcGD/u7u8/7u6u/+5uLr/uLe4/7W1tv+ysrT/sLCx/62trv+r + q6z/p6ao/6Ogov+dmJj/m5eW/5uZmv+YmJr/l6yp/4TZx/940rr/d82v/3bJpf9ywZf/YZ9s/2CWZf9Y + h13/U35Z/3tvbP9+dHH/gXh2/4R8e/+JgoH/jYiG/5KNjP+Xk5P/nZqY/6Ogn/+sqaf/trKx/2GT5v8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln7//wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALH//KC59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//1lyn/9x + bW3/cm1u/3Rwb/94cXD/e3Nz/311dP9/dnT/gXd0/4J3dP+Dd3P/hXdy/4Z3cf+Ab2n/Wn1W/1+HWv9l + lGD/Zppl/2ebaf9nm27/Z5xy/2icev9+rpP/qtTJ/7Ozs/+1tbf/ubi5/7q6u/+9vL3/vr6//7+/wP/B + wMH/wsHC/8HBwv+VZ1H/nnxu/8PCw//CwcP/wcHC/8HAw//BwcL/wMDB/8DAwP+/v8D/j19L/5ZuXf+8 + u7z/vLu9/7u6vP+5ubr/uLe4/7W0tv+ysrT/sK+x/62trv+pqar/pqao/6OjpP+gn6H/nZ2e/5ylpf+T + 3tD/fdbC/3rRt/9zxKH/Zqh5/2Oha/9im2j/XY5h/1iCW/9vdWX/e3Bt/3xycP9/dnT/gnp5/4eAf/+M + hoT/kYuK/5WQkf+bmJb/oJ6c/6mmpf+zr67/jaTP/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Knr+NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuef5YLn3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//aG5//3Jtbv90b2//dnFw/3lzcv98dHP/fnZ0/4F4dv+C + eHb/gnh0/4R5dP+GeHP/h3dx/4d2b/9scVv/XYFW/2ONXP9nl2H/aJlm/2maa/9omm7/aJt1/2+de/+D + oIL/l5WA/5+If/+2srD/vby9/7+/wP/BwMH/wsLD/8PDxP/Ew8X/xMTG/5ZoUv+hfnD/xMTF/8TExf/E + w8T/w8PE/8LCwv/BwcP/wcHC/8DAwf+QYEz/kmRM/5FiTP+RZ1P/oouB/7Gppv+4uLn/t7e4/7S0tP+y + sbP/r66w/6yrrf+oqKn/paSm/6Kho/+fo6P/n97S/3/Ktf9orpD/Y6F6/2WhdP9loG7/ZJ5o/2GWY/9a + h13/Vn5Z/3hsaP95bmv/e3Fu/310cv+BeXj/hn99/4qEgv+OiYf/lI+P/5qVlf+em5r/pqOi/7Gsq/+t + sLz/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufP3zAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC18/YEuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9w + bW//c25v/3Vxb/94cnH/e3Vz/312df+Ad3b/gnl1/4N4dv+EeXb/hnl0/4d4c/+IeHP/iXhy/4JvaP9c + e1T/YIVW/2aRXP9qlmH/aZdm/2mYa/9qmXD/apt3/3qdfP+PoIT/nY94/5ZvW/+Wbl3/q5eO/8C/wP/F + xMX/xsXG/8bGx//Hx8j/mWtU/6OAcv/Gxsf/xcXG/8XFxv/FxMb/xMTF/8TDxP/CwsP/wcHC/5FhTv+T + ZU3/kmRM/5FkTP+QZEz/kGNM/49iTf+NYE//jWNQ/49rWf+Pb2L/jm9j/4trXf+FZVb/g2NW/5Cokv95 + por/Z6OD/2Whe/9loHX/Zp9v/2Wfa/9knWb/YJFg/1iEWv90cmX/d2tn/3luav97cG3/e3Nw/4B3df+C + fHr/iYKB/42Hh/+SjYz/mJOT/5yZmP+joJ//r6qo/7i0s/8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8Af/8EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALXz9oi59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//3Jub/9zbm//d3Jx/3lzc/97dXT/fnd2/4J5dv+C + eHb/hHp2/4V6dv+HenX/h3l1/4l6dP+KeXL/i3hw/3VvXf9egFT/ZYpZ/2iTXf9qlmH/a5Zk/2qWav9q + l3D/b5l3/4Gbff+WnoP/oIly/5hwW/+ZcFn/mm9Z/5x0YP+3qKD/ycnJ/8nKyv+bbVb/pYR0/8nJyf/J + yMn/x8fH/8bGx//Fxcb/xcXG/8TExP/Dw8T/k2NP/5RmTv+TZU3/kmVN/5JkTP+PYEz/j2VR/5FmVf+M + YU//jWRQ/4tkUP+KY1H/iGRS/4VkUv+aqZD/gqWJ/26hgv9moHv/Z550/2adb/9lnmr/ZZxm/2OUYv9c + h1v/W31Z/3hqZP93amb/eG1p/3pvbP97cnD/f3Z0/4J7ev+Gf3//i4WE/5CMi/+WkZH/m5iX/6Gfnf+p + p6b/trGx/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+/bAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff21Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//cm5v/3Vxcf94c3L/enR0/313dv+AeXj/gnl3/4N6eP+Eenf/hnp2/4d6dv+Je3b/int1/4t6c/+N + enH/h3Np/195Uv9iglX/aI1b/2qUXf9rlGD/a5Rk/2uVaf9qlXD/dZh3/4mbff+dnoL/oYVt/5tyW/+d + c1v/nnNb/6BzW/+fcFr/pH9t/59yWf+ohnf/zMzM/8vLy//Kysr/ycnJ/8jIyP/Gxsf/xcXG/8XFxv+U + ZFH/lWdP/5RmT/+WbFr/s6ml/769v/+8vL3/u7q8/7i4uv+tpaP/jGVU/4tlUf+JZFL/pKmQ/4ukiv90 + oID/Z556/2eddP9nnG//Z5xq/2icZv9ll2L/YItd/1uAV/96bWX/d2lk/3dqZv94bGn/eW5r/3txb/98 + dHL/gHl4/4V+fv+JhIP/j4uJ/5WQkP+alpb/n52b/6impf+zr67/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/cEu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9ybm//dXBx/3l0dP97dnX/f3h3/4F6ef+C + enj/hHt4/4Z7d/+He3j/iXx4/4p8d/+MfHX/jHx0/457c/+Qe3P/f2xg/2B7UP9mhlb/aZBa/2yTXf9s + k2H/bJJl/22Tav9tlHD/fZd2/5Gaff+knoL/o4Jr/590Xf+hdV3/onZe/6N2Xf+kdl3/o3Zd/6yKe//P + z8//z8/P/83Nzf/MzMz/ysrK/8nJyf/Ix8j/xsbH/5ZmUv+XaVH/lmhQ/6qWjf/BwML/v77A/769vv+8 + u7z/ubi6/7i3uf+0s7X/i2ZW/6emjv+To4r/fZ+B/2qcev9om3T/aJpu/2maav9om2b/Z5hi/2KQXf9d + hFn/ZHla/3doYv93aWT/d2pm/3draP94bmv/enBu/3x0cv9/d3b/g3x7/4eBgf+OiYn/lI+P/5mUlf+e + nJr/pqOj/7GtrP8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//K3z+WAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn79xi59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//3NvcP93cnL/eXR0/3x3dv+AeXn/gnt6/4N7eP+Fe3j/hnt3/4l9ef+JfXf/i313/4x8dv+O + fXX/kH11/5F8dP+QeW7/aHJT/2N/Uf9oiVf/a49Z/26SXf9ukWD/bJFl/22Sa/9ylHL/hJd4/5eZff+r + nYP/poNr/6R4X/+meWD/p3hg/6h5YP+oemH/sI1+/9TT0//T0tL/0dDQ/9DPz//Ozc7/zMzM/8rKyv/J + yMn/l2dT/5hrU/+XaVH/rJiO/8LCw//AwMH/v77A/7y8vf+6urr/uLe5/7W0tv/O5+H/nKKJ/4Sfgv9v + m3r/aZp0/2mYbv9pmWr/aZhm/2iXYf9lkl3/YYda/1t+Vf97aWL/eGhj/3dpZP92amb/d2to/3duav96 + cG3/fHNy/393dv+Ce3v/h4CB/4yHh/+Sjo3/mJSV/5yamP+loqL/sKyr/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8sfv38AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + fv/ALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//dHBx/3dyc/96dXX/fnh3/4F6ev+C + fHr/g3x5/4V8ef+HfHn/in56/4t/ef+Nfnj/jn53/5B+d/+Rfnb/kn51/5R+dP+Ib2P/YHdN/2aBUv9r + i1b/bY5Y/22PXP9tkGH/bpFm/26Ra/93k2//iZZ3/52Zff+tnIL/qoVt/6l8Y/+qfGP/q3xj/6t9ZP+1 + kYL/2NfX/9fV1v/V1NT/1NLT/9HR0f/Pz8//zc3N/8vLy/+ZalX/mmxU/5hrU/+tmZD/w8LD/8HBwv+/ + v8D/vb2+/7u6u/+4uLn/2/Lw/8nt6f+Oo43/eJt7/2qYdP9qmG7/apdp/2mXZP9pl2H/Z5Rf/2OLWv9d + f1T/c29e/3ppYP95aWP/eGlk/3dqZv93amj/d25q/3lwbf97cnH/fXZ1/4F6ev+GgID/i4aF/5CMjP+X + k5T/m5mX/6Kgn/+uqqn/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8fb/8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/bEuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//91cnL/eXR1/3x3dv9/eXn/gXp6/4N9e/+DfHn/hn16/4h+e/+Kfnr/jH96/45/ev+P + f3j/kIB5/5J/d/+VgHf/l4B3/5h/dP96a1n/YnlM/2mDUv9sjVf/bo9Z/26OXf9uj2H/b49l/2+Qa/98 + knH/kJZ4/6Oafv+wnIP/r4hw/61/Z/+ugGf/r4Bo/7mVhv/c29v/29na/9jX1//X1tb/1dTU/9PR0v/Q + 0ND/zs3O/5xsV/+cblX/m2xU/66akP/Dw8T/wsHC/7+/wP+9vb//vLu9/9/08v/R8Oz/uurj/4+/q/9s + mHT/a5du/2uVaf9rlmb/apZi/2iSXP9li1n/X4BU/154U/97aWH/emli/3hqY/94aWT/d2pm/3draP92 + bWn/eW9t/3pycP98dXT/f3h4/4R/fv+LhoX/j4uL/5aSk/+bmJj/oZ+e/6ypqP8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+/dAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAK3v9mS59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//3Vycv95dHX/fXh3/4B6ev+C + e3v/g317/4V9e/+GfXv/iH58/4qAe/+NgXv/joB7/4+Ae/+SgXn/lIF5/5WBef+Xgnj/moJ2/5R7bf9m + c03/ZXtO/2mEUf9tjFb/bo1Z/2+NXP9vjWD/bo9l/3GPa/+CknL/lpd6/6aaf/+0nIP/tY10/7KDa/+z + hGv/vZqL/+Hg4P/f3t7/3t3d/9vZ2v/Y19f/1tTV/9TS0//Q0ND/nm5Z/55wV/+cblX/sJyR/8XFxv/C + wsP/wMDB/76/wP/j9fX/2fLw/8Dr5v+q5dv/kdXE/2uVb/9rlWr/a5Vm/2uUYP9pk17/aI9b/2OFVv9d + e1H/fWpf/3xqYv97amP/eWpk/3lrZf93amb/d2to/3dtaf94bmv/enJv/3x0c/9/eHf/hH59/4mFhP+P + i4v/lZGR/5uXl/+hn57/q6in/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAufP5zLn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//dnNy/3p1dv9+eXj/gXt7/4J7e/+EfXz/hn58/4h/ff+Jf3z/jIF8/42BfP+P + gnv/kIJ6/5OCe/+Wg3v/l4R7/5qFef+bhXj/noZ5/4puYP9idUv/aH5P/2yHUv9vjFb/b4xZ/3CMXf9v + jWD/b45m/3aPa/+Hk3T/nJd8/6qagP+4nYT/upJ6/7aIb//BnY//5OTk/+Tj4//i4uL/4N7e/9zb2//a + 2Nn/19XW/9TS0/+gcVz/n3JZ/51wV/+wnpP/xsbG/8PDxP/DxMX/6vf2/97z8//K7+v/sejf/5zh1f+N + 18T/a5Jq/2uTZv9rkmH/a5Re/2mSW/9lhlb/YH1R/3BvWv9+amL/fWpi/3trZP96a2X/eWtm/3dqZv93 + a2j/d21q/3hubP94cW//e3Nz/353dv+DfXz/iIOE/4+Kiv+VkZL/mZaV/5+dnP+op6f/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//LHz+eQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC56/kcuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//90c3n/enV2/395ef+B + e3v/gnx7/4R+e/+Hf33/iH99/4qAff+Mgn3/j4J//5CCff+Sg33/lIN9/5aEff+ZhXz/m4Z7/56He/+h + iXz/o4l7/3prVf9kdkn/aYBP/26JU/9wi1X/cItZ/2+MXv9wjGH/cI1n/3mQbv+MlHX/oJh9/7Cbgv+8 + nYX/vpd+/8Wik//q6On/6Ojn/+fm5v/k4+P/4N/f/93c3P/a2Nn/19bW/6RzX/+idFv/n3JZ/7KflP/G + xsb/ysvN/+349//k9fX/0PHu/7nq5P+k5Nr/kt7O/4zVwf9qkWb/bJJh/2ySXv9rkVv/Z4lW/2KAVP9h + d1L/f2th/39rY/9+a2T/e2tl/3tsZf94a2b/d2xn/3dsaP93bmr/eG5s/3hwb/97c3P/fXd2/4J8fP+H + goP/jomK/5WRkf+alpb/n52c/5agsv8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8ufv//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALHn+Fy59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//2l1jf97d3f/f3p6/4J8fP+DfHz/hH58/4d+ff+JgH3/i4F//46DgP+Q + g4D/kYR//5SFf/+VhX//l4Z//5uIff+diX7/n4p9/6OLfv+njX//oIN0/2lwS/9nekz/bIJP/2+LVP9w + ilf/cIpZ/2+LXv9wjGL/cI1o/36Rb/+RlXf/p5qA/7Wcg/+9nYX/y7Cg/+vr6//r6uv/6+nq/+jn5//l + 4+P/4eDg/9zb2//Z2Nj/pnZh/6V3Xv+idVz/sqCV/9TV1f/r9/b/5fb2/9by8P++6+b/qeXd/5ff0v+Q + 28n/jNK5/2yQY/9skV7/a5Fb/2qNV/9lglP/YHpP/4FsYP+BbWP/f2tj/31rZP98bGX/e2xm/3lsZ/95 + bGn/d2xp/3Ztav93b2z/eHBv/3pzcv99d3b/gnx8/4eCg/+NiYn/lJCP/5mVlv+fnZz/dpXJ/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8t + fP4nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//V3ew/3x3eP+A + e3v/gnx8/4N9fP+Gf37/iIB//4mBf/+LgX//joOA/5CEgP+ThYD/lIaA/5eHgf+ZiID/m4qA/5+Lf/+i + jIH/po6B/6yRg/+vk4X/jnFi/2R1Sf9qfU3/bYVP/3CKVP9wilf/cIpZ/3CKXv9wjGT/dI5q/4KScP+V + lnn/qpuA/7Wcg//Is6T/8/f4/+/u7v/s7Oz/6+rr/+jn5//l5OT/4N/f/9va2v+peWX/p3lh/6J3Xv/H + t6z/6/f3/+L19f/Y8/H/w+3p/63n3v+b4dP/kdzM/5DYwf+LzrL/bJBf/2yRW/9qj1n/ZYRT/2F7T/96 + blv/g21j/4JtZP9/bGX/fWxm/31tZv97bGb/eWxn/3ltaP93bWn/d21r/3dubP94cG//enNy/3x3dv+B + e3v/h4KD/42Jif+Tj5D/mZWW/56cm/9Oief/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+/egAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//9BfNv/fHd4/4B7e/+CfH3/hH59/4Z/fv+IgH//ioF//4yDgP+P + hIH/kYaB/5OHgv+UhoL/l4iC/5qKgf+di4L/oI2C/6WPhP+okYX/rZOG/7GViP+2mYr/gWlW/2Z2Sf9q + fk7/bolR/3CJU/9wiVf/cIpc/3CLX/9wjWb/dY5r/4WSc/+Zl3v/qZqB/7+xov/r9/b/+/n5//Dv7//t + 7ez/6+rq/+jn5//i4uL/3dzc/6p7Z/+pfGP/wZV9/9vPxf/j9fX/3fPz/8ju6/+z6eH/nuLX/5Pezv+R + 2cP/j9W7/4jFo/9tkF3/a5BZ/2iIVP9jfVH/aHVT/4dwZf+EbmX/gm5l/39uZv9+bWf/fW1o/3ttZ/96 + bWn/eW5p/3dtaf93bmv/dm9s/3hwb/96c3L/fHZ2/4F7fP+GgYD/jYmJ/5OPj/+YlZb/npyb/y99/v8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//wAA/wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC5+//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59/P97 + d3j/gHt8/4N9fv+Ff37/hn9//4iBgP+KgoD/jYWB/4+Fg/+Sh4P/lIiD/5aIg/+ZioP/m4yD/56NhP+i + j4X/ppKH/6yVif+xlor/tJmM/7qcj/+1mIj/cW5O/2h5S/9sgU3/b4hR/3CKVf9wilf/cItc/3CMYf9w + jWb/d5Bt/4mUdP+dmH3/s7Cf/+739v/7+fr/+/n6/+/u7v/s7Ov/6ujp/+bl5P/g39//rX5q/8ueh//Q + o4z/49HH/93z8v/J7+v/tuni/6Pk2f+V3tD/kdrG/5DWv/+P0rT/e66E/22QWf9rjFb/ZoBS/2F4Tv+M + c2f/h3Fm/4VwZ/+Db2f/gG9n/39uaP99bmn/e21p/3tuaf95bmr/eG5r/3hubP93cG7/eHFv/3pzcv98 + dnb/gXt8/4aCg/+NiYn/lJCQ/5mVlf+fnZz/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln79mwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn39zS59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//3t4ef+AfH3/gn5+/4V/fv+HgID/iYKB/4uDgf+N + hIH/j4WD/5KIg/+UiIX/lomF/5qMhP+cjYT/oI+G/6SRiP+olIr/rZaL/7Kajf+3nY//vKCS/8Kllv+f + gnL/Z3JJ/2l7S/9uhU//b4lS/3CKVv9xiln/cIpd/3CNYv9wjmn/epFv/4uVd/+orpz/+vn5//v5+v/7 + +fr/+/n6/+7u7v/q6ur/6Ofn/+Lh4f/Mn4z/0aWO/9Gljv/l0cj/zfDt/7nq4/+k5Nr/ld/R/5Hbyf+Q + 17//kNO2/43QsP9vlGT/a45W/2eDUf9ie07/h3Bk/4tzaf+Icmj/hXFo/4Nxaf+AcGj/fm9p/31vav98 + bmr/em5q/3huav94bmv/d29s/3dvbf95cnD/enNz/313d/+Be3z/h4OD/42Jif+Tj4//mZaW/5ucoP8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8ufv//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfP9gLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//d3h9/397fP+Df37/hH5+/4eAgP+JgoH/i4SB/46Fgv+Qh4P/koiE/5WJhv+Xi4b/m4yH/56Ph/+g + kYj/pZSK/6uWjP+vmY7/tJyQ/7ifkv+/pJb/xama/8qtnf+Mbl7/Z3dJ/2p+Tf9uiFD/cIpU/3CKVv9w + i1r/b4te/3CNZP9vjmn/fJJx/5eplP/6+vn/+vn6//v5+v/7+fr/9Pn4/+vu7v/o6Oj/8vj5/82ij//R + ppD/0qeR/+bTyv/Y8u7/p+Tb/5bg0f+R28r/kdjC/4/UuP+O0LH/i8un/2uOWP9ph1P/ZX5R/3lwW/+O + dmv/jHVr/4l0a/+Fcmr/g3Fq/4Fxav9/cGr/fW9q/3xva/96b2v/eW5r/3lvbP93b23/d3Bu/3lycP95 + c3P/fHd3/4B8e/+GgoP/jYmK/5SQkP+Zl5b/Z43M/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8qe/5CAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB//wQu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9Terv/gHx9/4J/fv+FgID/h4GB/4mCgf+M + hIL/jYWD/5CHhf+TiYb/louI/5iMh/+bj4j/npCJ/6KTiv+mlo3/rJiP/7Gbkf+1n5P/u6KW/8Gomv/I + rZ7/zLGi/9O2pv+BaVb/aHhL/2uDTv9uiVL/cIpU/2+KWP9wi1v/b41g/2+OZf9wkGz/s7Ke//r5+v/5 + +vn/+Pn5//P4+P/s9/f/5vb2/+P19f/o9vX/xKOR/8+pk//RqpX/7ODZ//j4+P+X4NH/kdvK/5DYw/+P + 1br/j9Gz/43Pq/9zn27/aotV/2aBUv9qdlL/knpt/411a/+Ldmz/inVt/4Z0a/+Ec2z/gnJr/39xa/9+ + cGv/fHBs/3twbf96cGz/eW9t/3dvbf93cG//eHJw/3p0dP98eHf/gXx8/4eDhP+NiYv/lJCR/5qYl/8x + fvv/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y58/fcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y99+/9/e3z/gn9//4WAgP+GgYH/iYOB/4uEg/+NhoP/j4eE/5OKh/+WjIn/mY2J/5uPif+f + kYr/opOL/6eXj/+tmpD/sp2T/7aglv+8pJn/w6ue/8mvov/OtKX/1Lmq/8uunv90blD/aXtM/2yET/9v + ilT/cItV/2+MWv9wjF3/b41i/22PZ//Zva//8/j4//D4+P/t+Pj/6fb3/+L29v/c8/L/2/Py/+D09P+/ + qJb/yKqU/8eplv/w9vX/9Pj4/5Lbyv+Q2ML/j9W7/43Rs/+N0K3/g7+W/2qKVf9mglL/ZXpQ/5R7b/+O + d2v/jXdt/4t3bv+Kd2//h3Vu/4Rzbf+Cc23/gHJs/31wbP98cG3/e3Bt/3pwbf94cG3/d29t/3dwb/94 + cnH/enR0/314eP+AfXv/h4SE/46KjP+UkJL/m5mY/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yp//wYA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn392y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//357e/+Df3//hICA/4aBgv+I + g4L/i4WC/42Ghf+Ph4b/k4qH/5eNiv+Zjor/m5CK/6CTjP+klY7/p5iQ/66ck/+zn5b/t6KY/72mm//D + rKD/yrGk/8+2qf/WvK7/3cGy/7CSgv9qdEz/aX9N/2yFT/9vi1X/cIxW/2+LWv9ujV7/cI9m/8+8rv/p + 9vX/6fb2/+P19f/f9PT/1/Lw/8/w7v/M8O3/2fPx/9jn4//Jtab/3efj/+f29P/s9vX/wuje/47Vu/+O + 0rP/jc+t/4bEm/9qjFb/aINT/2J8T/+Qd2r/kXht/453bf+OeG7/jHhu/4p4cP+Id3D/hXVv/4N0b/+A + c27/fXJt/31ybv98cW7/enBv/3lxbv94cG//eHFw/3hycf95dHT/fnl5/4F9ff+IhIb/j4uM/5WSlP93 + kLr/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//LX79ugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAre/5GLn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Wnu1/oJ/f/+FgID/h4KD/4iDgf+KhIP/jYaG/5CIhv+Tiof/lo2K/5qPi/+c + kYv/oJSO/6SXj/+ompL/rpyU/7Ogl/+3pJn/vaie/8Ktof/Ks6b/0Lir/9e+r//exLX/48e4/5Z5av9n + eEz/aX5N/22IUv9ujFX/b41Y/26NW/+goYP/xbyu/+L08//f9PP/3PTz/9Ty8P/I7+v/vevn/7nq5P/E + 7en/0fHv/9vz8v/h9PT/3/Tz/+Dz8v/k9PL/jdGz/4vOrf98soX/aoxW/2iGVP9jfVD/h3Nj/5J6bv+Q + eW7/j3lu/456cP+Ne3H/i3ly/4h3cf+Fd3D/g3Vw/4Bzb/9+c2//fXJv/3txbv95cW7/eXFv/3hxb/94 + cXD/eHJy/3p1df9+eXn/gn5//4mFhv+QjI3/lpSV/zJ/+v8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufv7/gn5//4WBgf+H + goP/iIOD/4uFg/+Nh4b/j4mG/5OLiP+WjYv/mo+M/5ySjP+glI7/pJeR/6eakv+unZb/tKKZ/7iknP++ + qp//xK6k/8qzp//PuKz/1r6x/93Et//jyLr/48e4/4puXv9leUz/aIBP/22IUv9tjlf/b45a/7qvmv++ + va//1/Lx/9Px7//Q8O7/wu3p/7bp4/+q5d3/puTc/7Do4P++7Of/ye7r/9Px7//Y8vD/1/Lv/9vx7/+H + w5//bJNh/2qOV/9nh1P/ZH1R/3xzXP+agnX/j3pw/5B6cf+Pe3H/jXty/4x6c/+KenP/iHhy/4V2cf+D + dnL/gXRw/35zb/98cnD/e3Fv/3lxb/94cG//eHFw/3hycf95c3T/enV2/355ef+Df4D/ioaH/5CNjf+X + lpb/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8qe/5fAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACx8/ekuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//93fYz/hYGB/4aBgv+IhIT/ioWD/4yGhv+PiYf/k4uI/5WMi/+a + kIz/nJON/5+Uj/+jl5H/qJuU/66el/+yopr/t6Wc/7ypoP/CrqT/ybSo/8+5rv/Wv7P/28S3/+LJu//k + yrz/4MW2/4NsW/9mek3/aYNR/2uKU/9wkFv/tLGc/7a9r//I7+r/w+3p/7nq5f+u5t//o+PZ/5jg1P+U + 39H/n+LY/6rm3v+z6eP/vevn/8vt6f/B187/s7Sl/5iniP9qkVr/aIhV/2SAUv9udVf/pIx//5N8cf+R + fHL/kHty/498c/+OfHP/jXx0/4p7df+JenX/hXhz/4N2cv+AdXH/fnRw/3xzcP97cnH/eXFw/3lycf94 + cXD/d3Fx/3l0dP97dnf/f3t8/4SBgv+MiYj/k5CR/1OG2v8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y58/f0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAK33+Oy59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//zR99f6E + gIH/hoKD/4iDhP+KhoT/jIaF/4+IiP+Si4n/lY2L/5mQjf+ck47/n5WQ/6OYkv+nm5X/rp6Y/7Kimv+2 + pZ3/u6mh/8Kvpf/Is6n/zbis/9O9sf/Zw7f/4Mm8/+XMv//ly73/1rut/3ttVv9lfE7/aYRS/5enhv+q + sJv/qLus/7np5P+v5+D/pOTZ/5ng1P+Q3s//idrK/4rayP+O3c7/ld7R/5bOwP+Nr5z/lKuX/52wmv+l + s5//p7Wh/2iKVv9lglP/Z3hS/6mRhP+VfnP/kn1y/5F9c/+RfXT/j311/418df+NfXb/i313/4l7dv+F + eXT/g3d0/4B2cv9+dHH/fHNx/3tzcf96cnH/eXJw/3hycf94c3L/enV2/3t3d/+AfH3/hoKE/42Ki/+V + kpP/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yh4/hMAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//3x/iv+GgoP/h4OE/4qFhf+Mh4b/j4iI/5GKif+U + jIv/mI+N/5uTj/+flpD/opiS/6ablf+sn5j/sKGa/7amnv+6qaD/v62l/8ayqf/Mt63/0Lyx/9bBtf/b + xbn/4cq9/+XNwP/lzL//wqmb/3JwVP9kfk//oLKd/5mumP+Wuqf/pOTZ/5zg1v+Q3s//itvL/4bZxv+C + 0br/drib/2mggf9pn3//cKOF/3mmi/+CqpL/iq2V/5Owmv+atJ7/ZoRX/2J7Uf+nj4P/ln91/5R+df+T + f3X/kX52/5B+dv+Pfnf/jn53/41+eP+Lfnj/iXx4/4Z6dv+Cd3X/gHZz/351cv98dXL/fHRz/3pzcv95 + cnH/eHNy/3l0dP96dXb/fHh5/4F9f/+HhIX/j4yN/2OIx/8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//LH390wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfP2cLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//MX75/4aCg/+Hg4T/iYSF/4yHhv+OiIf/kYuI/5SNi/+Wjoz/m5KP/56Wkf+hl5L/ppuW/6qemP+v + oZv/taWe/7ioof+8rKT/wrGo/8i1rP/OurD/0r2z/9fDuP/dyLz/4szA/+TNwP/mzcH/r5aJ/294V/+O + r5f/hqyT/4O2oP+Q3dD/htfF/3nHsP9rqYn/Z5t3/2iacP9om3D/aJ11/2agfP9mooH/a6SH/3CojP94 + q5D/ga6V/4iymv9/pIX/oouA/5iCd/+XgXj/lYB3/5SAd/+Rfnf/kH94/49/ef+Of3n/jX95/4t/ev+J + fXj/hnt3/4N4dv+AdnT/fnZ0/3x0c/97c3P/enNy/3lzc/95c3P/eXR1/3t2d/99enr/g3+A/4qHh/+R + j5D/Ln7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//cICg/4eDhP+JhYX/i4aG/46Iif+P + ion/k4yL/5aPjf+ZkY7/nJWQ/6CXk/+kmpX/qJ6Y/6+hm/+zpJ7/tqeg/7uro/++r6b/xrOs/8q3rv/P + u7H/1L+1/9fDuP/bxrr/38q+/+LLv/+nkYT/hLGZ/3utk/9zqo3/bKiK/2ajhf9lo3//ZaF8/2eed/9o + nHL/aJtu/2iabv9nnXH/Z594/2WifP9kpIL/ZaaH/2mpi/9urI//dK+U/3yymf+Qlob/mIR6/5aCev+U + gXn/koF5/5CAef+QgHj/joB6/46Aev+NgHv/i397/4l9ev+Ge3j/g3l3/4B3df9+dnT/fHV0/3t1dP95 + c3P/eXN0/3l0dP96dXb/e3Z4/357fP+FgoL/jYqK/1uGzv8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8tfP2LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/csuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8ufv//hoKE/4iEhf+Lhob/jYiH/4+Kif+SjIr/lI2N/5iQjv+bk5D/n5eS/6Oalf+n + nZj/q6Cb/7CjnP+0pZ//uami/7yspf/Bsan/xrWs/8u4r//Pu7L/0r+1/9bBt//Zxbr/ppSI/3exlv9x + rpH/a6uM/2Wnh/9jpYP/ZKSA/2WifP9moHf/Zp50/2ecb/9nm2z/aJtq/2edb/9mnnT/ZaJ4/2Sjff9i + poL/Y6mI/2Kqi/9lrI7/aq+S/26ylf+MmYn/loR6/5SCev+Tgnv/kYJ7/5CCe/+PgHv/joF9/4yBe/+K + gHz/iH57/4V8ef+DeXj/gHd2/353df98dnX/enR0/3lzdP94c3P/eXR1/3p1dv97eXn/gH5+/4iFhf+P + jY3/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAFX/Ay59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//9Cf+P/h4OF/4mFhf+L + hob/jomJ/5CKiv+UjYv/lpCN/5qSkP+dlZH/oZmV/6Wbl/+on5r/rqKd/7Kln/+2qKH/uquk/76vqP/D + sqr/xrWt/8q5sP/Ou7H/0L20/6SVi/9rsZT/aK+S/2Osjf9iqof/YqeD/2Olf/9kpHv/ZKF4/2Wgcv9m + n3H/Zp1s/2ecaP9nnGj/Zp1r/2afcP9loXX/ZKN4/2SlfP9jqIP/YKmH/2Crif9frYz/YbCQ/2Sylf+D + nYz/lIR9/5ODff+Rgn3/kIJ8/4+Cfv+Pgn//jYJ+/4uBfP+Hfnz/hXx5/4J6eP9/eHb/fXd2/3t2df96 + dHT/enV1/3l0df95dHX/enV3/357e/+DgID/i4iJ/zyB7v8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx9/m4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn39xS59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//9zgaD/iYWF/4uHh/+NiIn/j4qK/5KMi/+UjY3/mJCP/5uVkf+f + mJT/o5qW/6admP+soJv/r6Oe/7Omof+2qKL/uqul/76uqP/Bsqr/xrSs/8i3rv+dl4z/YbKU/1+vj/9h + r43/YKuI/2Gog/9jp3//Y6R7/2Sjd/9lonT/ZqBw/2Wfbf9nnWr/Zp1m/2ecZv9mnmn/ZZ9t/2Wicv9k + o3T/ZKR5/2Omff9iqYL/YauE/2Cth/9fr4z/XrGR/16zlv96oI7/koV+/5CDfv+Qg3//joN+/46Dfv+L + gX3/ioB9/4d+fP+EfHr/gnp5/394dv9+eHf/fHd2/3t1dv96dXb/eXR1/3p1d/97eXn/f3x9/4aDhf97 + iKP/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln7//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//+G + hIj/ioeG/4yIiP+OiYn/kYuL/5ONjP+Wj4//mZKR/5yWkv+gmZX/pZyY/6efmv+top3/sKSe/7Snof+3 + qqP/uqum/7ytpv+/sKn/k5iL/16ykP9dsI3/Xq+L/2CtiP9hqoH/Yqh+/2Kmev9jpnf/ZKR0/2OjcP9k + oG3/ZZ9q/2aeaP9lnGX/ZJtj/2aeZ/9loGr/ZKJv/2Ojcv9kpXX/YqZ4/2Gnfv9gqYD/X6yD/2Cuhv9e + sIv/XLOP/1y0lP9ypo//kYV//5CEgf+PhIH/joSB/4yCf/+JgX7/h399/4N8ev+Benn/f3h3/314d/97 + dXb/e3Z3/3p1dv96dXb/eXZ3/316e/+Cf4D/iYeI/y5+//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//K3z+XgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtfP2LLn3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y9+/f+JhYb/i4iG/46Jiv+Pi4v/koyM/5WOjv+X + kZD/m5SR/52Xk/+hmpb/pp6Z/6mgnP+vop7/sKWf/7Onof+2qaP/uayk/4acif9esoz/XrGM/1+vif9f + rob/YKuC/2Gpf/9hqHv/YqZ2/2Oldv9jo3L/ZKJu/2Sha/9joGf/ZJ5m/2KXYf9ilWH/Y5xl/2SgaP9k + omz/ZKNv/2Klcv9hpnX/Yqh5/2CqfP9fq4D/X6yC/16thf9dsIn/XrON/1y1kP9rq43/kIaC/4+Egv+O + hIH/jYSB/4mBf/+Gfn3/g317/4B5ef9+eHf/fHd3/3t3d/97dnf/enV2/3l1d/96d3j/f3x9/4aDhf83 + f/L/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8ufv//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAufv3+Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//zh/8P+Kh4f/jImH/46Jiv+QjIz/k42N/5aQj/+ZkpH/m5aS/56Ylf+jm5f/pp6a/6mgnP+v + o5//sKSf/7Onof92o4f/XbCH/16wiP9dr4b/Xq2E/1+sgf9gq37/YKl6/2Gndv9hpXT/YqRy/2Okb/9j + o23/YqJq/2GbZf9hl2P/X49g/1+NX/9gk2H/YJtl/2Ohav9io2z/Y6Vv/2Gmcv9hqHb/YKl4/2Cqe/9g + rH3/X62A/16ug/9dsIf/XLKL/1yzif9hsIn/kYeD/46Fgv+Mg4H/iIF+/4Z/fv+CfHv/gXt7/354eP98 + d3f/e3Z3/3p1dv95dXf/end4/3x6e/+EgYL/WIHH/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8sff45AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACp//x4u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//0V/3/+MiIf/jYmJ/4+Ki/+R + jYz/lI6O/5aRkP+ZkpD/m5aS/56Ylf+hmpf/p56b/6ihnP+toZ3/ZqyE/1ywhP9dsYT/XrCE/1+ugf9f + rX//X6t8/2Cqef9gqXb/Yadz/2KmcP9ipW//YqVs/2Kiav9hnGb/XpNi/16OYf9ZiF3/Wodc/12MYP9e + kmH/YJlk/2Cfaf9gpG3/YqZv/2Kncv9hqXT/YKt3/1+sev9erXz/Xa9//16vgf9dsoT/W7KH/12zhf9d + s4b/kImG/4qDgv+HgID/hH58/4F8e/+Aenr/fXl5/3x4eP97dnf/enV3/3p3eP97eXr/gH1//3KCof8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//yx9/fYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACx9/bcuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//1CB0v+MiIj/joqL/4+Ki/+SjYz/lY+P/5WRkP+ak5L/nJeT/5+Zlf+i + m5f/oJmW/12tgP9csYD/XLCB/16wgf9drn//Xq5+/1+te/9fq3j/YKp2/2Cpc/9hqHH/YKZu/2CkbP9f + oGj/X5pn/12TY/9ail//WYhd/3eAbf9+dm3/WoZd/1mKYP9bkGL/XZZl/1+eZ/9fpG3/YKZu/2Cocv9g + qnT/YKt2/1+seP9erXr/Xa99/1uxgP9csYL/W7KC/1uzgv9asIH/iY+G/4eAgP+Efn3/gXt8/396ev99 + eXn/e3Z3/3p2eP95dnf/e3l6/357fP96gJD/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx9/fwuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wB//wIA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59/f4uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//1SBzv+N + iYr/j4uM/5GNjP+Tjo3/lY+Q/5aRkP+Zk5L/nJaT/4WYh/9aqXr/XKx8/12vff9esH7/Xa9+/16ve/9e + rnn/YKx2/1+qdP9fqXH/X6dw/1+kbf9foWv/Xpxp/1yWZv9akGT/WItg/12EX/+ekoz/vbGr/6WZk/+M + gHv/Z3xk/1eJXv9YjGH/W5Nl/16baf9dn2r/XqVu/16ocP9eqXT/Xqp0/16sdv9ernn/XbB8/1ywfv9c + sX7/XbGA/1quff9Zq3z/dJmA/4F8ff+BfHz/fnl6/3x4eP96d3j/end4/3p4ef99env/eX6M/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//LXz9jQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALnP+Cy59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//02B1v+NiYr/joqL/5CMjP+Tjo7/lY+Q/5aSj/9g + nHX/WKN2/1qmeP9aqXj/XK15/12ve/9drnn/Xqx3/16rdf9eqHL/XaZw/12ibf9bnmr/W5lp/1uXZ/9c + k2f/WI5i/1eJX/+FhXn/wLWv/6Wblf+kmpX/o5iS/6GWkP+bkYv/g3l0/1uFX/9XjGL/WpJm/1qVZ/9b + m2v/Wp5r/1yibv9dp3H/XKhy/12rdv9drnf/XK95/12wev9crnr/W6t6/1qnd/9XpXf/WZ51/4KBf/99 + eXr/e3h5/3p3eP96d3n/fHl6/3V+kf8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8t + ff3+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALXz+VC59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//z+A6f+NiYv/joqL/5GLjP9xjXj/VJVq/1acb/9ZoHP/WaFz/1qndf9bqXb/XK13/12qdf9d + qHP/W6Vw/1ugbv9anGv/WZlp/1mVaP9YkWX/VY1k/1aMYf92gnL/rqWg/6edmf+lm5f/o5qV/6KYk/+g + l5L/n5aQ/52Uj/+clI//komF/3l3cP9WjGL/VY1j/1WQZf9Wk2f/WZdp/1mcbP9aoG7/WqNw/1uoc/9b + q3b/Wq12/1qsdv9ZqXb/WaN1/1ehcf9VnXD/U5Zs/2SKcf98eXr/end5/3t5ev9ifKr/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALX79ri59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//zJ/+f9mfm7/Snxd/06GYv9R + jmb/VJZr/1aabv9Xnm//WqJw/1mlcv9ZpXH/W6Nw/1qfbf9Zm2v/WJZq/1aSaP9VkGX/VY1j/1OKYf9v + g27/opqW/6ignP+lnJj/o5uW/6GZlf+hmZX/oJiT/5+Xk/+dlZH/nJSQ/5uUj/+bko7/mZCO/4yEgv9x + em3/U4li/1OMYf9Tj2T/VZJn/1aVaf9YmWv/V51t/1qicf9ZpXH/WaVz/1ikcv9Xn3D/VZlu/1OWbP9S + kmn/Tohk/0p+Xv9cemj/Rn3V/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y5z/gsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALnz94y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y5+//9FenL/TYBg/1CKY/9Sjmb/UZFn/1SWa/9WmW7/V5pt/1eabP9W + l2v/VJNo/1OPZv9UjWP/UIxi/1GJYv9xhHP/nZeT/6Wem/+im5f/opuX/6Galf+gmZX/n5iU/56Xk/+d + lpL/nJWR/5uUkP+bk5D/mpKQ/5mRjv+XkI7/lo+O/5WOjf+Jg4H/cnpv/1KIY/9Ri2L/Uo1j/1KPZv9T + k2n/VZhs/1aabf9Wm23/Vptt/1aXbf9Rk2n/UY5n/06LZ/9MhGH/SXtf/y9+9/8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3+NwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALH799C59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//84 + fcr/TINh/06HY/9Qi2T/UI9m/1GSZ/9Skmj/UZFn/1KOZf9Ri2T/UIlj/1WFZP+Ahnz/nZeV/56Zlv+d + l5T/npiV/5+Zlf+fmZX/nZeU/52XlP+clpT/m5WS/5uVkv+bk5L/mpOR/5mSkP+ZkZD/lpCP/5aPj/+V + jo3/lI2L/5ONjP+SjIv/i4WE/3l4dP9Yg2b/UIhk/1GKY/9PjGX/UZBn/1KSaP9Rkmj/UJBn/0+LZv9N + iGP/TIVi/0B/mP8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8re/5XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH79+i59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufv//R397/06FYv9PiWb/T4tk/1CLZf9P + iWT/VIVl/3OEd/+SjIv/mpWV/5qUk/+blZP/m5aU/5uVlP+blpP/m5WT/5uVk/+blZP/m5WR/5uUkf+b + lJH/mZKR/5mSkP+XkZD/lpCP/5aQjv+Vjo7/lI6O/5SOjf+SjIz/koyM/5GMi/+QjIv/j4qL/4yHiP+B + fXz/cnpy/1aDZv9PimT/T4pm/1CKZ/9Oimb/TYZi/0qCZv8vfvX/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yt7/l0AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALH79+i59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//MX7x/2qAef96gnz/h4SE/4+Li/+Tj4//lZCR/5aRkv+WkpL/lpKS/5eTk/+Y + k5P/mZOT/5mTkv+Zk5P/mZOS/5mTkv+Zk5L/mZOS/5eSkf+XkpH/lpCQ/5aQkP+Vj4//lI+O/5SOjf+T + jo7/ko6N/5KNjf+QjIz/kIyM/4+Li/+OiYr/jImH/4qGhv+Hg4X/hICA/3x5ev94dXf/cXly/2N8a/83 + ftT/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Lnz9/i59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//LHr+SwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH399S59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//zuA7/+K + i5P/kY2N/5KOjf+Tj4//k4+P/5SPj/+VkJH/lZCR/5WRkf+WkZL/lpKS/5aSkv+XkpP/lpGS/5aSkv+W + kpL/lZCR/5aRkv+VkJH/lI+Q/5SPj/+Uj4//k46O/5GNjf+SjYz/kIuM/5CMjP+Pi4v/joqL/4yIiP+K + hof/iISG/4SBgf+Bf3//gH1//317fP9GfNb/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8pe/4fAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn394S59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8wfvz/coev/5CNjv+Sjo7/ko6O/5OPj/+T + j4//lJCQ/5SQkf+VkZH/lZCR/5WQkP+VkJD/lZCQ/5SPj/+Uj4//lI+P/5OOjv+Tjo7/ko2N/5KOjP+R + jY3/kYyN/4+MjP+PjIz/j4uM/42Ji/+Lh4j/iIWG/4aDhP+EgYH/gX+A/3N8kv83fu//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXz9qC59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//zuA8P91ia3/kY2O/5KOjv+Sjo7/ko6O/5OPj/+Tj4//k4+P/5OPj/+T + j4//ko6O/5OPj/+Sjo7/kY6N/5GOjf+RjY3/kI2N/5GOjf+QjY3/j4uM/42Ji/+LiIj/iYaF/4eEhf+E + gYL/d4CT/0V+2/8ufv//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufv//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH/+Si59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln7//0WC5P9th7X/jIyU/5KOjv+Sjo7/kY6O/5KOjv+RjY7/ko6N/5KOjv+QjY3/kIyM/5CNjf+P + jI3/jouL/42Ki/+MiIn/iIaI/3OCoP9Of9H/L338/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//yx+/cgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAJG3+Byx+/fouff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + fv//L338/zd/9P8+gez/RILm/0WC5f9Cgef/O4Du/zR+9v8uff//Ln7//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//LnP+FgAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC19/Zgu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y58/fcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5z/gssfP31Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//JHn+FQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAsfP5KLn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y9+/Z0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH7+bS5+//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8sfP3fAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACx7/lsufv3+Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//LX793AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAoev4ZLn390S59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59/ZAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC57/zwt + fv3aLn7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y58/fcvb/8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALXj/ES59/YQufP3tLn7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx+/fQrfP4vAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACh4/iYsff5sLn39tSx9/eoufv//Ln///y5+//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufv//LX395S19/moA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzZv8FHHH+CSh4/hMt + f/4cKnj+JCt8/iktfP4tLXz+LSp6/zAqev8wKnr/MCx5/i4tfP4tKnn+Ki5//iYre/4jKXv+Hy96/hss + ef4XJnL/FC9//xAndf4NGWb/Chxx/gkccf4JH3//CB9//wgff/8IHHH+CS14/xElev4bLXz+Jyx6/jQu + e/5CLHz/UC1+/l8tfP5xLHv9hCx9/ZYtff2jL4D9qy99/bMtff25Ln/9ui9//bYuff2vLnz9pCx9/ZAs + fP5zLHr+USt8/ikzZv8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /////////////////AAA/////////////////8AAAAf///////////////wAAAAA///////////////w + AAAAAB//////////////gAAAAAAH/////////////gAAAAAAAf////////////wAAAAAAAB///////// + ///wAAAAAAAAH///////////wAAAAAAAAA///////////4AAAAAAAAAD//////////8AAAAAAAAAAf// + ///////8AAAAAAAAAAD/////////+AAAAAAAAAAAf/////////AAAAAAAAAAAD/////////gAAAAAAAA + AAAf////////wAAAAAAAAAAAD////////4AAAAAAAAAAAAf///////8AAAAAAAAAAAAD///////+AAAA + AAAAAAAAAf///////AAAAAAAAAAAAAD///////wAAAAAAAAAAAAA///////4AAAAAAAAAAAAAH////// + 8AAAAAAAAAAAAAA//////+AAAAAAAAAAAAAAP//////gAAAAAAAAAAAAAB//////wAAAAAAAAAAAAAAP + /////8AAAAAAAAAAAAAAD/////+AAAAAAAAAAAAAAAf/////gAAAAAAAAAAAAAAH/////wAAAAAAAAAA + AAAAA/////8AAAAAAAAAAAAAAAP////+AAAAAAAAAAAAAAAB/////gAAAAAAAAAAAAAAAf////wAAAAA + AAAAAAAAAAH////8AAAAAAAAAAAAAAAA/////AAAAAAAAAAAAAAAAP////gAAAAAAAAAAAAAAAB////4 + AAAAAAAAAAAAAAAAf///+AAAAAAAAAAAAAAAAH////gAAAAAAAAAAAAAAAA////wAAAAAAAAAAAAAAAA + P///8AAAAAAAAAAAAAAAAB////AAAAAAAAAAAAAAAAAf///wAAAAAAAAAAAAAAAAD///8AAAAAAAAAAA + AAAAAA////AAAAAAAAAAAAAAAAAP///wAAAAAAAAAAAAAAAAB///4AAAAAAAAAAAAAAAAAf//+AAAAAA + AAAAAAAAAAAD///gAAAAAAAAAAAAAAAAA///4AAAAAAAAAAAAAAAAAP//+AAAAAAAAAAAAAAAAAB///g + AAAAAAAAAAAAAAAAAf//4AAAAAAAAAAAAAAAAAD//+AAAAAAAAAAAAAAAAAA///wAAAAAAAAAAAAAAAA + AP//8AAAAAAAAAAAAAAAAAB///AAAAAAAAAAAAAAAAAAf//wAAAAAAAAAAAAAAAAAD//8AAAAAAAAAAA + AAAAAAA///AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAB//+AAAAAAAAAAAAAAAAAAf//gAAAAA + AAAAAAAAAAAAD//4AAAAAAAAAAAAAAAAAA//+AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAB//8 + AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAD//4AAAAAAAAAAAAAAAAAA//+AAAAAAAAAAAAAAAA + AAH//gAAAAAAAAAAAAAAAAAB//8AAAAAAAAAAAAAAAAAAP//AAAAAAAAAAAAAAAAAAD//4AAAAAAAAAA + AAAAAAAA//+AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAB//8AAAAAAAAAAAAAAAAAAP//gAAAA + AAAAAAAAAAAAAD//8AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAH//4AAAAAAAAAAAAAAAAAA// + /AAAAAAAAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAD//+AAAAAAAAAAAAAAAAAA///wAAAAAAAAAAAAAA + AAAP//+AAAAAAAAAAAAAAAAAD///wAAAAAAAAAAAAAAAAA///+AAAAAAAAAAAAAAAAAP///wAAAAAAAA + AAAAAAAAD///+AAAAAAAAAAAAAAAAA////wAAAAAAAAAAAAAAAAP////AAAAAAAAAAAAAAAAD////4AA + AAAAAAAAAAAAAB/////AAAAAAAAAAAAAAAAf////8AAAAAAAAAAAAAAAP/////wAAAAAAAAAAAAAAD// + ////AAAAAAAAAAAAAAB//////8AAAAAAAAAAAAAA///////wAAAAAAAAAAAAAf///////gAAAAAAAAAA + AAf////////AAAAAAAAAAAAf/////////wAAAAAAAAAA//////////////////wAf/////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + ////KAAAAIAAAAAAAQAAAQAIAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8pe///a2Nj/3tra/+M + jIT/jIR7/5SMlP+cnJz/Y5Rj/3tjWv97e3v/Y4Rj/7W1tf/m7+//Y61a/2OESv+traX/3tbm/97Fxf9z + lHv/a+Za/xlrlP8ZKZT/GVLv/xkZ7/9K5lr/GUqU/xkIlP+l5oT/pYxa/4R7a//OtZT/GeYp/1q1Kf8Z + tSn/EHsp/969Kf+cvSn/Sq1a/1rmCP8Z5gj/WrUI/xm1CP8Qewj/3r0I/5y9CP9Ca1L/SmuU/3NjSv+c + reb/c5yc/+bmxf+ca1r/znNa/5xzEP8Za8X/7+aU/0pS7/8p5lr/SimU/ylCKf9KGe//EIxa/xkpxf8p + tVr/KRAp/++9Wv+tvVr/SkqU/6WM5v8ZSsX/zuaU/wjmWv9KCJT/CEIp/xBrWv8ZCMX/CLVa/wgQKf/O + vVr/jL1a/0qMY/9jreb/hGtr/7WUhP9Ka8X/MZTv/zGczv9jxaX/71rv/2Pv7/9j76X/3q3v/+9arf+c + OpT/7xmt/0J7Kf/vGe//3u8p/5zvKf/FWq3/nBCU/8UZrf/FWu//xRnv/5xazv8x3s7/nBnO/+9zGf8Q + nKX/EN6l/xCc7//ejMX/pc7v/3ta7/8Q3u//exnv/86UGf/vWs7/Y87v/2PvhP/ejO//QnsI/+8Zzv/e + 7wj/nO8I/8Vazv/FGc7/EJyE/xDehP9jjMX/nLWM/3NjnP+c3qX/Upyc/5xjpf+tnJz/KUJa/5yUvf+E + QmP/SinF/4RCKf/mQin/hBAp/+YQKf8pEFr/UkIp/7VCKf9SECn/tRAp/0pKxf8IQlr/SgjF/4RCCP/m + Qgj/hBAI/+YQCP8IEFr/UkII/7VCCP9SEAj/tRAI/+ZCSv+EEEr/5hBK/1JCSv+1Qkr/UhBK/7UQSv/e + lJz/hEpK/1qte//v71r/re9a/2uMGf/vvZT/73Na/5yUEP/OlFr/nHMx/87vWv+M71r/a2sZ/2POxf9j + xYT/lGt7/5Tmxf+9xcX/Y63F/zGchP8xnKX/nFrv/zHe7/8x3qX/nBnv/++UGf9j78X/Md6E/5SUhP+E + Y1L/75Ra/5yUMf+17+b/5kJr/4QQa//mEGv/UkJr/7VCa/9SEGv/tRBr/96UhP9SjOb/WpR7/8W1vf+1 + 78X/763F/xCtzv/va4z/ezql/+8pjP/Fa4z/exCl/8UpjP97a87/EO/O/3spzv/Ocyn/EIzO/+9KjP97 + OoT/7wiM/8VKjP97EIT/xQiM/3tKzv8Qzs7/ewjO/85zCP+Uzr3/OnPv/2vmKf8ZGQD/SuYp/0KMSv9z + jOb/lO/m/xlKAP+MjFL/nK29/3Nje/8Qc+//IQAA/ylz7/8pc///AAAI/wAAAP8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/gAAAAD+ + AAAA8f4A/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+ + AP4A/u8BAQHvAQEBAe8B7/7xAADx/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD+AP7+7wHvAVYBVu8BAVYB7wEBAVYBAQEBAe8BAPv+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAA/gFWAe9WAQFW7wEBAQFW7wEBVgHvAQHvAe8BAVYBAQFW/v4AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAP4AAe8B7wEBAQHvAQEB7wHvAQEBAe8BVu8BAVYBVgEB7wEBAe8BVgEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAD+Ae8BAVYBAQHvVgEBVu8BVgFWAe9WAQEBAQFW7wEB7wHvAVbvAQEB + 7wEBAQAA/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7+71YBVu8BAe9WAQHvAQEBAe8B7wEBAe8B7wHvAQEBAQEB + VgEBAVbvVgHvVu8BAVYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADxAe9WAQEBAQEB7wEB71YBAe8BAQEBAVbvAVYB + VgFW7wHvAVbvAe8BAQEBAQEBAQFW7wEB/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAe8B7wHvVgFWAQEBAe8BAVbv + Vu8BAQEBAe8BAQEBVu8BAQEBVgHvAQHvVgEB7wEB71YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/gEB7wEBVgEBVgEBAe8B + 7wEBVgFW7wEBAQEBAQEBAQEB7wEBAQFW7wHvAQFWAe8BAe9WAQEBAQHvAfsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7/lbvAQFW7wHv + AQEB7wEBAQFW7wHvAQEBAQEBAQFWAe8BAQEB7wEBAQEBAVbvAe9WAQEB7wHvVu8BVgEBAQEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP4B + AQEBVu8BAVYBAe8BVgHvVu8BAQEBAQEBAdPT9PT09FL0UtNWAQEBAe8BAQEBAQEB7wEBVgEBAQEB7wFW + 7wH7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA/v7vVgHvAQEBAQEB7wFW7wEBAQEBAQEBVvSC+BAMEAwQDAwM1QwM1dW7DDFS0wHvAQEBAQFWAe8B + 7wEB71YBAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAA7wEBAQFWAe9W7wHvAQEBAQHvAQHTghAQEBAQEIgQEBAQEBAQDBAMDNXV1dW7uzFS + AVYBAQEBAQFWAVbvAQHvVu8BVgH+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAFWAQEB7wEBAQEBVgEBAQEB/Vb0BxAHiAeIiAeIiIiIB4gHiIiIEBAQ + EBAM1QzV1bu7MdMBAQEBAe8BAQEBAQEBAe8B7wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAe8B71bvAVbvAVbvAQEBAdMyiAcHBgcGBgYGBgYGBgYH + BogHB4gHiIgQEBAQDAzV1dXVErvTVgEBAQEBAe9WAe9WAQEBVgHxAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7AVYBAQEBAQEBAe8BAQEBAdOKBwcGBgYGBgYG + BgYEBgYGBgQGBgbGBwaIB4gHiBAQEBAM1QzVuxIxUu8B71YB7wEBAe8BAQHvAQEAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQHvVu8BAQHvVgEBAe+CBwYG + BAYEBgQGBgUGBAYEBAYEBgYGBAYGBgYGBogHiIiIEBAMDNXV1RK7MVYBAQEBVu8BAQFW7wEBAQH+AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/vEBAe8BAQEB71YBAQEB + Ae/TBgYGBgYGBAYFBAUEBQUFBQUFBQUFBQQGuQYFBgQGBgbGiAcHiBAQEAwM1dW7ElIB7wEBAVbvAQEB + 71YB7wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7wHvVgFW + 7wFWAQHvAQHvggYGBAYKBAUFBQUFBQUKCgoKBQoFCgUFBQUFBAUEBgQGBgYGBoiIB4gQEAwM1dW7EjFW + AQEBAQEBAe9W7wEBVgHxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + /lYBAQHvAQEBAQEBAQH97zIGBAQEBQUFCgoKCgoKCgoeCh4KCgoeCgoeCh4FBQUFBQQFBgQGxgaIBwcQ + EBAMDNW7u7v0AQEB71YBAQEBAQHvAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAABAQHvVgEBAe8BAe8BAdMEBgQKBAoFCgoKCh4KAx4DAwoDCh4DHh4KHh4KCgoKHgUFBQUE + BAYGBgYGiAeIEBAM1dXVErtSAe9WAQHvVu8BVu8BAQHxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD+/u8BAQEB71YBVgEBAf2CBgQEBQUKCgoKHgoDAwNTCwMeAx4DAwMDAwMDAx4e + Ax4KHgq5BQUFBQYFBARUBgeIiBAQDAzVuxJSAQEBAQEBAQEBAVbvAQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVgFW7wEBAQHvAQEBggYKBAoKCgMKAwoDAwMDAwsDAwMCAwID + AwMDAwMDAwMDHgMeHgoeCh4FBQUGBgYGBgaIiBAQDNXVuxIxAQEBAQFW7wHvAQEBAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+7wHvAQHvVu8BAQEB/YIEBAUKCgMKCh4DCwMDCwMD + AwMCAwMJAwIJAwIDCQMDAwMDAwMeAx4KuQoFCgUEBAYEiMYHiBAQDAzVuxIx71bvAQEBVgEB71YBAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAVYBAQEBAQEBAQGCBAoKCgMDCgMD + AwIDAwIDAgkCAwkCCQIJCQIJCQkCCQkJAwMDAwMeAx4eHgoFBQUFBQYGBgaIB4gMEAzVuxJSAQEBAe8B + 7wEBAQHv/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe8BAQHvAVYBAVbvNwoF + CgoKCgoDCwMDAgMCAwIDAgkCCQIJCQIJCQIJAgkCCQIJCQkDAwkDAx4DAx5TBQUFBQQEBIjGB4gQDAzV + uxJVAQEBVgEB71bvAVYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAVYB71YB + Ae8BAe8uAgUKAwoCAwIDAgMCAwIJAgkJAgIJAgkCCQkCMAIJCQkJCQkCCQIJAwMDAx4eHh4KCgUFBQYG + BgaIiIgQDAzVuy437wEB7wFWAQEBAe/+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADx + AQHvAQHvAQEBAQHvLy4uCgMKAwIDAwIDAgkCAgkLCQIJCQkCCTACCQkJCQkCCQkCCQkJCQkCCQkDCQMD + AwMeBQoFBQQEBsYGB4gQDAwHLi9WAQEBAe8B71YBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAEB71YBAQEBVu8BAYICLi4K+QMCCwMCAgIDAgkLCQICCQIJAgkJCQkJCTAJMAkJMAkJCQkw + AgkJAgkCAwMeHh4eCgUFBQQGBgaIiIgQDAouLooBAVbvAQEBAQHvAfEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD+AQEB7wFW7wEBAQHTCgIuLgsDAwMCCQsJAgkCCQMJCQkJCQkJMAkJMAkJCQkJ + MAkJCTAJCQkJCQkJCQMJAwkDAwMDHgW5BQQEBsYHBxAQLi4uDPQBAQEBVu8BVgEBAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFW7wFWAQHvAQEB7woKLi4LLgMCAgMCAgkDCwkCCQIJAwkJCQkJ + CQkJCccwx8cJqgkwCTAJqgkJCQkJCQkJAwMDHh4eCgoFBQQGBgaIiARRLi4MuwEBAVbvAQEB7wEBAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+AQHvAe8BAQFWAQGCCgoCLlFRCwMCAwIDAgIDCQMJ + AwkJCQkJCQkJCccwCQkwCTAJqgkJxwkJMAkwCQkJCQIJAwkDAwMeHgoFBQQEBsYHUQsuLgy7Me8BAe8B + AQHvVgEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHvAVYBAQEBVu8B7woDAgsuUQhRAwID + AgMJAwkCCQkJCQkJCccJxwnHMAmqCQmqCcfHx8cwxzAJqgkJCQkwCQkJAwMDAx4eCh4FBQQGBhNRUS4L + DNW7VgEBAVbvVgEBAQH7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+VgEB7wFW7wEBAQFVCgoK + Ay4uCwgLAgMCAwIDCR4JAwlTCQkJCccJxwnHCcfHx8fHUwUHxwlTxwnHMAkwCQkJCQkJCR4JAwNTCrkF + BQQE1FELLgsM1dUx7wEBAQEB7wEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7wEBAQHv + AQEB0woLAwIDLlFRUdQLAwkDCQMJAwkJxwkJxwnHU8fHx8fHx8ceBAcHBwcJuQcGBQMJxwkJCTAJCQkC + CQMDHh4eCh4FBNTUUVEuBRAM1btWAQEBAe8BVgHvVv7+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+ + AQEBVu9WAQFWAQFVCgP5AgICUVEICNQDAwkeCVMJAx5Tx1PHCcfHx8fHxzQGB4gQEAcQB8ceBxAHBwZT + CQkJCQkJCQkJAwkDAwMeCgUT1FELUS7GEBDVDDEB7wFWAe8BAQEB7wAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAB7wEB7wEB7wEB7wr5AwILAwsuCwjUqwtTAwNTCR7Hx8cJx1PHNMfHx8fHBRAQ+BCKEIoQ + xx6IBwcHiAcHBFMJCQkJCQkJAwMDHgMeCqurCFFRCwYQEAzVuwFWAQHvAQFW7wFW/gAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAFWAQEB71YBAQFX+QMC+QIDAy4LUQirqwsJHglTU1NTUwW5BQUFuQVTNMe5 + EBAQEBAMEBDHuRAQiPgHEAcHBwYFAwkJCQkDCQkDHgoTCKsICy4KBwcQEAzV0+8BAVYBAQHvAQEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAe8B71YBAQEBAYQDC/kLAwMDLlEL1KvUEx5TUx4EBgeKEIgQ + igwQDBCIx7kMDAwMDBAMEMfHxogQEIgHBwcHBwcGBAoDAgkCAwMDE6ur1FFRUQUGB4gQDNUxAQEB7wEB + 7wFW7wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8QFWAQEBAe8B7wEBCgIDAgP5CwMCD1EICKur1AUG + BwcHiBAQEBAQEBAQDBA0HQwMDAwMDAwQNKrHxx7GEBAHEAcHBwYHBgYEHgMJUxOrq6sICFECBMYHBxAQ + DLvvVgHvAVYBAQFWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe8BAe8BVgEBAdMDC/kDAwIDAwML + UQgIqxNY7gYHBwcQBgUFBcaIDAwMDMe5DAwMDAwMDAzHx8fHqsfHHlQHiAcHBwYGxgYEBgoKqxOrCAhR + LgoEBgaIiBAM1dMBAQFW7wHvAQEB7/4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7wFWAQHvVgEBL/kC + CwIKAwoeCgIuCwgIuO5Y7gcHEAc0U8c0x8c0BhAQNAW7DLsMuwwMDDTHNMfHx6rHx8cFBgcHBwcGBgYE + BlhYq6vUC1ELCgQGxgcHiAwMMQEBAQEBAVbvAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFWAQHv + AQEBAQEKAgoD+QMDAwMDAw9RCwi47li6EAf4EAcENFM0xzTHszTHHdXVDAwM1QwMNB4MiAU0x8fHqsfH + UwUGBwYGBgRY7li4CAgL8wMFBQYGBgcQEAz4AQEBAe8BAQEBVu/+/gAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABAe8BAVYBAQEBAfkDAgsDAwoDCh4DCw8LCLhYWLfuEIoQDBAMiMY0xzTHNDQFDLu71bsMuww0HQwM + DBAHucfHx8fHxwkeBgYE7u5YWFgICFELCgoFBQbGBweIDNXTAQEBVu8B7wEBVgEAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAHvAVbvAQHvVu/TAgsK+QMKAwpTuQoDC1EICBOD7rq6DBAMDAwM1QyIBTTHxwXV1bvV + u9XVDDQe1QwMDAwMEAZTx8fHxwkeBu63WFhYgwhRUQIeCgUEBgYGiBAQDNMBVu8B7wFWAQEB7/7+AAAA + AAAAAAAAAAAAAAAAAAAAAAD+VgEBAe8BAQEBAVX5AgMDClMeCgoeHh4CDwgICKsTWO66DAwMDAwM1bvV + DFQ0VLvVu9W7u7sMNAXV1bvVDAwMDBAHiAbGBgf4urpY7rirCAsLAwO5CgUFBgYHiBAM9AEBAQEBAe8B + AQHvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAe9WAQFW7wFWVR4KAwoDCgpTHgpTuQMPCwgIDhMTE4Pu + DNUMu9W71bu71ccdu7u7u7vVu9U0NAwMDAwMDAwQEBCKBwcH+LruWFgTqwgIUQsDCgoKBQYGBgaIEAz0 + AQHvVu8BAVYB7wFW/v4AAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQHvAQEBAQEvAgMDAwpTCgq5Ch4FHgIP + CAgICA6rExPGxhAMu9W7Eru7NMYSuxK7u7u71TTHNDRUiBAMDAwMEBAQBxDu7lirEw4ICAgPAwMDHgoF + BQTGBwcHDPgBAQEBVu8B71YBAe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVbvAQEBVu8BAQoL+QoDCgoe + Ch4FBVMeHg8LCAgIExMTE4MdNB2IDLu7u9U0VLu7u7u7Eru7NDSzx7PHxzQ0HgW5HVMegzITqxMOqwgI + UQIDHgMDCgoFBgYGB4gQ+AEB7wEBAQEBAQEBAVb+AAAAAAAAAAAAAAAAAAAAAAAAAAAB71YBAe8BAQEB + +fkKAx4KHgq5Hh4eBbkeAw8PCAgICBMOxsYFNDQ0VIjVuzRUuxG7Eru7u7s0x8c0xzQ0HjTHx8fHHsaD + qxOrEwgICAsPAwIDAwoDBQoEBAYHBxAMAQFW7wHvVu8B7wEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB + AQHvVgEBAQEKAwMKCgq5Ch4KBbkeBR4eMAsICPcIExMTxoMdNB00NB1UNFQSu7u7u7sSuzQ0NDSIDNUM + DIg0xzTGgxOrEw4TDggIDwIDAx4LAx4KBQUGBgcHEAz9AQEBAVYBAQFWAQHvAQAAAAAAAAAAAAAAAAAA + AAAAAAD+7wEBAQHvAe8BAfkDClMKCgoFCgUeBQU0BR4eDw8ICAgICBMIxlQFNB00NTQdVLszuxESu7u7 + Hcc0VLu71bvVDAw0g4MTExMIEwgICAsPAwkDAgMDCgoKBQTGBgeIDFbvAe8B7wEBAe9WAVYBAAAAAAAA + AAAAAAAAAAAAAAAAAAABAQFW7wEBVgFWCgoKCgq5BQq5BbkFuQW5BbkJDwv3CPcIExPGxlQdHTQduTRU + EbsRu7u7M7s0NDRUu9W71QwMu7sHxqsTDhMOCAgPCwkDAgMDAx4DCgoEBgYHBwcQAQEBVgEBAQFW7wEB + 7wEB+wAAAAAAAAAAAAAAAAAAAAAA/lbvAQFWAQHvAQH5A1MKCgoKBQoFBQUFBQUFHVMPCw8ICAj3CBME + Q1RUNB01HVQREjMREbsRuzQ0NFS7u7vVu7sNyoMTExMICAgICwsPAwMJAwIDAwoDuQoEBAYHiAwBAQHv + AVbvAQEBAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAe8BAQHvAQEBAQoKCgoFCgUKBbkFBbkFuR25BccP + Dwv3CAsIExPGxlQdHVQ0HxERERESErsSHTQ0VLu7u7u7DcrKEAgTCAj3CA8PDwMJAwkLAwMKAwoKBQQG + BgcHEAEB71YBAe8BAe8B71YB7/7+AAAAAAAAAAAAAAAAAAAAAP5WAe8BAVbvVgEB+QoKCgoKuQoFBQUF + BQUFBQUFHgkPDwv3CPcI9xPGVFQdVB2pDTMRMxERuxE0NDSIu7u7uw0NyvXuExMICAgICw8JAwkDAwMD + AgMDCgoKBQbGBwf4AQEBAQEB71YBVgHvAQFWAQAAAAAAAAAAAAAAAAAAAAAAAAEBAVYB7wEBAQEKCgoK + uQUKBQUGuQUFuVQFuR1Uxw8PD/cICwsIHsbGVFRUsh8RDRERMxEzEh00NIgSuxINDcrKuu4ICAgI9wsP + AlMJHgkDAgMDAwoDCgoFBgYGB/gBAQEB7wFWAQHvAQEBVu8BAAAAAAAAAAAAAAAAAAAAAAAAAQHvAQEB + 7wEBAYQKBQoKCgS5BQUFxgUFBVQFuQVUCQ8LD/cI9wgIE/eDVFRUHw0NMw0RERESVDQdVLvKDQ0NynG6 + 7gj3CAgLDw8JAwkDAwMDAwMDAwoKCgUEBgcHilbvAVbvAe8BAQFW7wEB7wEBAAAAAAAAAAAAAAAAAAAA + AAABAVYBAe9WAQEBMgMKCgUFBQoFBQW5xrlUBQVUVFQeMA8P9wsIC/cT98ZUVB8fDQ0NDREzEREdNDSI + EQ0NDcrWuu7uCwgIDw8PAx4JUx4JAwsDAwsKAwoKBAYGBweCAQEBAQEBAVYB7wEBAQFWAQHxAAAAAAAA + AAAAAAAAAAAA+wEB7wEBAQHvAQFVCrkKCgUKBQUFBgUFBAVUBcbGVFQeMA8PC/cPCxMIEx2DVBINDQ0N + DQ0zElQdNLsNDQ3KcfW6uoUI9wgLDwnHUx4JAwMDAwMDAwMKUwoFBAYGiNMB7wHvVgHvAQEBVgHvAe8B + AQAAAAAAAAAAAAAAAAAAAAAAAQEBVgHvAVYBAYIKCgoFCgYFBrkEBcZUuVTGVFRUVIgJDw/3C/cI9wsT + BcZUDA0NDQ0NDRERVDSyEg0NDcr1urruMggIDw8JUx5TCQMDAwMDAwMDAwoKCgQGBgcH0wEBVgEBAe9W + Ae8B7wEBVgEB7/4AAAAAAAAAAAAAAAAAAAAAAe8BVu8BAe8B7woKBAq5CgUFxrkGBQUGxgbGiFRUVFTH + Dw8PCAv3CPcT98YSDQ0NDQ0NDRJUVB8SDcrKcbru7u649w8LDx40Ux5THgMeAwMDAwoDAwoKCgQEBwdW + 7wEB7wEBAQEBAQFWAQHvAVYBAAAAAAAAAAAAAAAAAAAAAAAB7wEBAQEBAVYBCgUECgQEBQYFBgXGVMZU + VFRUiFSIHwUwD/cP9wgLCxMTxhANDQ0NDQ0NDR+pHxINyvW67rruhQgICw8eNFMeU1MDAwMDAwsDAwMK + CgoFBgYGigEBAQEBVu9W7wHvAe8B7wEBAe8BAAAAAAAAAAAAAAAAAAAA/lYBVgHvVu8BAQGECgq5CgUF + BAQFBgXGBsbGVIhUH4ipHx4wDwv3D/cI9wgTDA0NDQ0NDQ0NH9IfMw1xurq6WO6F9w8Pxx4eHlMeUx4D + CgMDAwsDCgMKCgQEBgeCAe9W7wEBAQEBVgFWAQFW7wFWAQEAAAAAAAAAAAAAAAAAAAAAAQHvAe8BAQEB + 74IKBQQGCga5BgUGVAZUxlSIiB+IHwwfH1MPDw8L9wsICxMfDQ0NDQ0NDQ0QHx8RDbq67u7uhRMPC8cF + HjQFUx5TAx4DAwMDAwoDCgoKBQQGB9MBAQEBAQHvAQEB7wEB7wEBAQHvAQH7AAAAAAAAAAAAAAAAAAAB + AQEBVgHvVgEB7woKCgUFBQUGBcYGxsYHVIhUiIipH9UfHzD3D/cICPcIExINDQ0NDQ0NDR8fHw0Nurru + he6DCA8PHjQeuR4FUx5TAwMKAwoDAwMDCgoEBgYHAVbvAe8BAVbvAQEBAQFWAe9WAQFWAQAAAAAAAAAA + AAAAAAAAAAABAVbvAQEBAe9WCgQKBgoGBgUGBsZUBlSIVIiIHx8f1R8SVDAPDwsP9wgTHw0NDQ0NDcoN + EbsRDQ3K7oXuuAgPMB65HgW5Hh5TUwpTCgMDAwoCCgoKCgQGBoIBAQEBVgFW7wEBVu8B7wHvAQEBAe8B + /gAAAAAAAAAAAAAAAAAAAAEBAQEB7wEBAQFVBAoKBQUEBQXGBgbGB1SIiIiI1R8fEh8SxjAP9wgP94O7 + DQ0NDcrKyg3KDQ0NDQ3uWIMLDw8eHQU0Hh65HgUeHgMeAwoDAwoD+QoECgQG0+8BAQHvAQEBAe8BVgFW + AQHvAQEB71YBAAAAAAAAAAAAAAAAAAAAAQEBAe9WAQEBAdMKBAQGCgYGBgZUxohUB4iIHx/VH9USEhKv + Hg8PD/cIELsNDQ3KytZxysrKDQ0NDYUI9w8PHgW5HgW5BR4FU1MKHgMKAwMKAwoKCgoGBIoBAQFW7wEB + AQHvVgEB7wHvAVbvVu8BAQH+AAAAAAAAAAAAAAAAAAD7AVYB7wHvVu8BAYQKBAoFBQQFBsYGxgeIVIgQ + iB/VHxKvEjMfUw8PCPeD1crKynH19bpxysrKytYMxggLDx4FHQW5HgUeuQUeCgNTCgMKAwMKAwoKCgQH + glbvAQFWAe9WAQHvAQEBVgEBAQEBVu8B7wEAAAAAAAAAAAAAAAAAAAABAe8BAVYBAQFW0wUEBAQEBgYG + BlSIVAeIEB8QH9Uf1RISEhIfHg8PxhAMytZx9bq67rq67viDg/iDCAswxrkFuQUduQUFHh65HgpTCgMK + AwMKCgoEBgYBAQEBAe8B7wEB7wFW7wHvAQEB7wEBAQFWAQAAAAAAAAAAAAAAAAAAAAEBVgEB7wHvAQEB + hAoGBQUEBcYGxsYHVIiIiIgMH9USHxIzrxIfCQuDg+7K9bq67u64MqsTgzKDgxAID1QdBR0FuQUFBbkF + Ch4KHgMKAwoDClMKCgQE9O8B71YBAVYBAVYBAQEBAQHvAVYB7wEB7wEBAAAAAAAAAAAAAAAAAAAAAAEB + Ae8BVgEBAQHTBQUKBgYGBgbGiAeIiIgfEB/VH9USEhISMxJUCIMy7u7uWDITqxOrE6syuDKDMsbGxrkF + uQUFBbkFBQq5ClMKCgMKAwoKCgoFBgbvVgEBAQHvAe8B7wEB71bvAVYB7wEBVgHvAVbv/v4AAAAAAAAA + AAAAAAD+7wFWAQEB71YBAQGCBgoEBAUEBgbGiMaIEIiIiAwfHx8SHxISEh8yxrgyuBOrE6sTDhMTqxOr + MrgygwRUBQVUuQUFBQUFBQUKHgpTCgMKA/kKCgoGggEBAe8BVgEBAQFWAQEBAQEB71YBAQHvVgEBAVYA + AAAAAAAAAAAAAAAAAAAAAQHvAe9WAQHvAe8EBQQEBgYGxlQHiIiIiB8QH9XV1dUSEhKIMrgyuDITqxMO + CA4TCKsTq6syuDKrWMYEBQUFBQUFuQUKBQoKUwoDCgMKCgoKBAYBAQHvVgEB7wFW7wHvAe9W7wEBAQEB + 7wEBAQHvAQEAAAAAAAAAAAAAAAAAAAABAVYBAe8BAVYB79MFBAQEBAYGBsYHB4iIEBAQDB/VH9XVgzK4 + Mqurq6sTqxMTEw4TDhOrE6syuDKGuMYFBQS5BQUEBbkFuQoKCgoDClMKCgoE0wEBAQHvAQEBAQEBAVYB + AQFWAe8B71YBVu8BVgHvAQAAAAAAAAAAAAAAAAAAAAABAe8BAQEB7wEBAYIEBAYGBAbGiAdUiIgQiB8Q + H9Uf1YMyqzKrMqsTE6sIqwgOCAirqxOrq6u4q6tYMjLGBQUFBrkKBQoKCgpTCgoK+QoKBIIBAQHvAVYB + Ae9W7wHvAQEB7wEBAVYBAQEB7wEB7wFW7/4AAAAAAAAAAAAAAAAAAAEB71YB71YBAe8BVoQFBAQEBgbG + BwcHiIgQiBAMEAwHhliruKurqw6rE6sIqwgOEwgICKurE6syq7iGuDIEBQUFBgUFBQpTCgoDCgMKCgoG + 0wHvVgEB71YBAQEBAVbvAVbvAQEB7wHvAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQHvVgEB + 0wYEBgYGBgbGB4gHiIgQiB8Qxri4q6syqxOrE6sICA4ICAgIDqurE6urq6uruDK4hjLGBAQFCgUKCgoe + CgMKCgoKBNMBAQEBAQHvAQHvAQFW7wEBAQEBVu8BVgEBVu9W71bvAQEB/gAAAAAAAAAAAAAAAAAAAVbv + Ae8BAQHvAQEB7wQFBATGBgbGVAeIiBAQEDIyqzK4q6urq6urCKsOCAgIUQgICA4IDhOrE6urq7gyq6sE + BAUFBbkKCgoKCgr5CgWCAe8BAQHvAVYBAVbvAQEB7wHvAQEB7wEB7wEBAQEBAVbvAVYAAAAAAAAAAAAA + AAAAAAAAAQEBVgFW7wEBVu8BggYGBgYGxgcHBweIiAcTuKu4q6urEw6rCKsOqwgICAsPCAgIq6urq6ur + q6urq7iruDIEBAUKCgpTCgr5CgoFgv0B7wFW71YBAe8BAe8BAe9WAVYBVu8BAQFWAQHvAQHvAQEBAe/+ + AAAAAAAAAAAAAAAAAAAAAQEB7wFW7wEBVgEBggQEBAYGBsYHBwcHq6u4q6urq6urq6sOqwgICAgLEwoL + CFEICA4Iq6sOq6urq6u4q6sEBQUFCgoKCgoKCjLvAVYBAQEB71YB71YBAVYBAQEB7wEB71bvAe8BAVYB + AVbvAQEBAQAAAAAAAAAAAAAAAAAAAAABAe8BAQEBAQHvAQEBggYEBgQGBgfGBKurq6urq6sOqwirCKsI + CAhRC8YQVAoLCwsI1KurDqurq6urq6urq6sTCgoKCgMKCgqEAQFW7wEB7wEBAQEBAQHvAe8BAQHvAQEB + AQEBAVbvAe8B7wEBVu8BAAAAAAAAAAAAAAAAAAAAAAABVu8BAe9WAQEB7wEBggYEBsYGxtSrCKurq6ur + q6urq6sICAhRCASIiIiIVMYKC1EICFGrCKurDqurq6urq6urCgoKClMKMlbvAQHvVgHvVu8BAe8BAQEB + Vu8BAVYB71YBAe8BAVYBAQFW7wEBVgEBAAAAAAAAAAAAAAAAAAAAAAABAQFW7wEB71YBVgEB08YGBArU + CKurq6urqwirqwhRCAhRCBOIiAeIB8YHxogFHgtRCAjUCKurq6urq6vUJtQICwoK+YIBAQEBAQEBAQEB + AQEBVgFW7wEBAQFW7wEBAQHvVgEB7wEBAe8BAQHvAQH7AAAAAAAAAAAAAAAAAAAAAAEBAQEBAQHvAQHv + AQEB7xNRUVHUUasIq6urJtQICFFRCwrGiAcHVAdUBojGxgfGBQpRUVEI1AhRqyarq6vU1FFRCwuCAQHv + Ae9W7wEBVu9W7wHvAQFW7wHvAQHvAe9WAQHvAQEB71YBAQHvVgEBAQAAAAAAAAAAAAAAAAAAAAAAAAEB + 7wHvVgEBAe8BAVbv7y9RUQgI1AirUQjUCFFRCBPGiAcHBlQHBwaIxgaIxgYGxgUKC1FRUdTUCNQIUQhR + UVEvVgEB7wFWAQEBAQHvAQEBAQEBAe8BAVYBAVYBAQEB7wFW7wEBAe8BVgEBAe9W/gAAAAAAAAAAAAAA + AAAAAAAAAAFWAQEB71YBVu8BAQEBVlVRUVFR1AjUUVFRCwUGiAcHVAeIBojGiAYHxgYGBsYGBgQKCgtR + UVHUUdRRUVHUL1bvAVYB7wEBAe9WAe8BAQHvVu8BVgHvAe8B71bvAVYBAQFW71YBAe8B7wEBAQEAAAAA + AAAAAAAAAAAAAAAAAAAAAAEBAe8BAQEBAQEB71bvAVYvUVFRUVELCgQGB8YHxgcHxgcHxgcGxsYHBsbG + BgQEBgYGBAr5C1FRUVFRL1cBAQEBAe8BAQHvVgHvAVbvAVYBAQEB7wEBVgEBAQEBAe8B7wEBAQHvVgEB + VgHvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBVu8B7wHvVgEBAe8BAQHTLwoKBAbGBwYGBwYHxgYHBsYH + xgcGBsYGBgYGBgQGCgYEBgQKCgoD1IIB71YBAe8BVu9WAQEBAQEBAQHvAQHvAQFWAe8BAe8B7wEBAVYB + Ae8BAQEBAe8B71YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQFWAQEBAe8BVgEBAe9W0wYGBgYGxgbG + B8YGB8YHBgYGBgbGBgbGBgQGBgQGBAQECgQKhIIBAQEBAQHvVgEBAQEB71bvVu8BVgEBVu8BAe8BAVbv + AVYBVu8B7wHvVgFW7wHvAQFWAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAe9W7wFWAQEB71YB7wEB + AdOCBgYGBgYGBgYGBgbGBsYGBgYGBAYEBgQGBgQEBQQKMtMB7wEBVu8BAQEB7wHvAQEBAQEBAe8BAe8B + AVYBAQEBAQEB7wEBVgEBAQEBAQEBAVYB7wEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQHv + AQHvAQEBVgHvAQFW04IGBgYGBsYGBgYGBgYEBgQGBAYEBgQFCgaE0+8B7wFWAQHvAQFW7wEBAVYBVu8B + Ae8BVu8BAVYB7wHvVgHvAQEBAQHvAQFW7wHvAe9W7wEBVgHv/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABAe9WAe9WAQFW7wHvAVYBAe8B7wHTgoKCBgYGBgQEBgYEBgQGBgYGgoLTAVYBAVYBAe9WAQHvAQHv + VgEB7wEBAe9WAQEBAQHvAQEBAe8BAVbvVgHvVgHvAQEBAVYBAQEBAe8BAQAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAABAQEBAQEB7wEBAQEBAQHvAVYBAQEBAQFW79PT09PTgtPT09PvAe8BVgEB7wEBAe8B + AQEB71YBAQEBAQHvAQHvVgEBAe8BVgEBVu9WAQEBAe8BAQEBAQFWAe9WAe8B7wFWAQEBAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAABAQHvVgEBAQHvVu8BVgEB7wFW71YBAe8BAQHvVgEBVu8BAQEBAQHv + AQFW7wEBVgHvVgEB7wHvVu8BAVYBAQEB7wFWAe8B7wEBAe9W7wEBAe9WAe8B7wEB7wEBAVYB7wEBAQEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAe9W71YBAQEB7wHvVgHvAQHvVgEBAe8BAe8B + AQEB71bvAQFWAe8BAe8B7wEBAQEBVgEBAQFW7wHvVu8BAQHvAQFWAe8BAQEBAVbvAQEBAVYBAQEBAVbv + AQHvAVbv/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAQEB7wEB7wFWAQEBAQEBAe8B + Ae9WAQEBVgHvVgEBAVYBAe8BVgEBVgEBAe8B7wEB7wHvAQEBAQEBAVbvAVYBAe8BVgEB7wEBAVbvAQEB + 7wHvVu8BAQEBVgEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBVu8BVu8B + Ae9W7wFWAQEBVu8BAQHvAe8BAQHvAQHvAQEB7wHvAQFW71YBVu8BVgFWAe9W7wHvAQEBAe8BAQEBAe9W + AQHvAe8BVu8BVgEBAQEB7wHvAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + AQEBAQEB71YBAQHvAQHvAQEBAe9WAQFWAQEBVu8BAVYB71YBAVbvAQEBAQEBAQEB7wEBAQFWAQEB71YB + Ae9W7wEBAQHvVgEBAQEBAQHvVgHvVgFWAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQEBAQEBAQHvVgEBVu8BAVbvAQEB7wEB7wHvAQFW7wEBAQHvAQEBAe8B7wEBAe8BAQHv + Ae8B71YBAQHvVgEBAVbvAVYB7wFW7wEB7wEBAe8BAe8BAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAe8BVu8BAe9WAQHvAVYBVgHvAQEBAe9WAQEB71YBVgFW + 71YBVu9WAVYBAQEBAe8BAQEB7wEBAQHvAQEBAQHvVgFWAe9WAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEBAQEBAQEB71YB7wEB7wFW7wFW7wEB + 71bvAQHvAQHvAQHvAQHvAQHvVgHvVgHvVgHvVgHvVu8BVu8BVu8BAe8BAQEBAQEBAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEBAQEBAQEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAA + 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 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + ///////////8AAD/////////////////wAAAB////////////////AAAAAD///////////////AAAAAA + H/////////////+AAAAAAAf////////////+AAAAAAAB/////////////AAAAAAAAH////////////AA + AAAAAAAf///////////AAAAAAAAAD///////////gAAAAAAAAAP//////////wAAAAAAAAAB//////// + //wAAAAAAAAAAP/////////4AAAAAAAAAAB/////////8AAAAAAAAAAAP////////+AAAAAAAAAAAB// + ///////AAAAAAAAAAAAP////////gAAAAAAAAAAAB////////wAAAAAAAAAAAAP///////4AAAAAAAAA + AAAB///////8AAAAAAAAAAAAAP///////AAAAAAAAAAAAAD///////gAAAAAAAAAAAAAf//////wAAAA + AAAAAAAAAD//////4AAAAAAAAAAAAAA//////+AAAAAAAAAAAAAAH//////AAAAAAAAAAAAAAA////// + wAAAAAAAAAAAAAAP/////4AAAAAAAAAAAAAAB/////+AAAAAAAAAAAAAAAf/////AAAAAAAAAAAAAAAD + /////wAAAAAAAAAAAAAAA/////4AAAAAAAAAAAAAAAH////+AAAAAAAAAAAAAAAB/////AAAAAAAAAAA + AAAAAf////wAAAAAAAAAAAAAAAD////8AAAAAAAAAAAAAAAA////+AAAAAAAAAAAAAAAAH////gAAAAA + AAAAAAAAAAB////4AAAAAAAAAAAAAAAAf///+AAAAAAAAAAAAAAAAD////AAAAAAAAAAAAAAAAA////w + AAAAAAAAAAAAAAAAH///8AAAAAAAAAAAAAAAAB////AAAAAAAAAAAAAAAAAP///wAAAAAAAAAAAAAAAA + D///8AAAAAAAAAAAAAAAAA////AAAAAAAAAAAAAAAAAH///gAAAAAAAAAAAAAAAAB///4AAAAAAAAAAA + AAAAAAP//+AAAAAAAAAAAAAAAAAD///gAAAAAAAAAAAAAAAAA///4AAAAAAAAAAAAAAAAAH//+AAAAAA + AAAAAAAAAAAB///gAAAAAAAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAD///AAAAAAAAAAAAAAAAAA///w + AAAAAAAAAAAAAAAAAH//8AAAAAAAAAAAAAAAAAB///AAAAAAAAAAAAAAAAAAP//wAAAAAAAAAAAAAAAA + AD//8AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAH//4AAAAAAAAAAAAAAAAAB//+AAAAAAAAAAA + AAAAAAAP//gAAAAAAAAAAAAAAAAAD//4AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAH//wAAAAA + AAAAAAAAAAAAB//8AAAAAAAAAAAAAAAAAAP//gAAAAAAAAAAAAAAAAAD//4AAAAAAAAAAAAAAAAAAf/+ + AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAA//8AAAAAAAAAAAAAAAAAAP//gAAAAAAAAAAAAAAA + AAD//4AAAAAAAAAAAAAAAAAAf//AAAAAAAAAAAAAAAAAAH//wAAAAAAAAAAAAAAAAAA//+AAAAAAAAAA + AAAAAAAAP//wAAAAAAAAAAAAAAAAAB//8AAAAAAAAAAAAAAAAAAf//gAAAAAAAAAAAAAAAAAD//8AAAA + AAAAAAAAAAAAAA///gAAAAAAAAAAAAAAAAAP//4AAAAAAAAAAAAAAAAAD///AAAAAAAAAAAAAAAAAA// + /4AAAAAAAAAAAAAAAAAP///AAAAAAAAAAAAAAAAAD///4AAAAAAAAAAAAAAAAA////AAAAAAAAAAAAAA + AAAP///4AAAAAAAAAAAAAAAAD////AAAAAAAAAAAAAAAAA////8AAAAAAAAAAAAAAAAP////gAAAAAAA + AAAAAAAAH////8AAAAAAAAAAAAAAAB/////wAAAAAAAAAAAAAAA//////AAAAAAAAAAAAAAAP/////8A + AAAAAAAAAAAAAH//////wAAAAAAAAAAAAAD///////AAAAAAAAAAAAAB///////+AAAAAAAAAAAAB/// + /////8AAAAAAAAAAAB//////////AAAAAAAAAAD//////////////////AB///////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////8o + AAAAQAAAAIAAAAABACAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + 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 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALXr+OCx7/fsuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8ufv//LXz+ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5+/Y8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx8/e8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALnz9+S59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8Af/8EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt + ff3PLn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y19/nwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC1+/Ysuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8z + gPv/rqyx/7Gsq/+vqqn/r6qp/7Gsqv+zrqz/t7Gw/7q0s/++ubj/w7++/8rGxf9Fivf/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln7//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACx9/fUuff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln7//6aiov+gnZv/nZqY/5yZl/+bmJX/m5iV/5yYlv+empj/oJya/6Ofnf+oo6L/raim/7Otq/+3 + sbD/vbi3/8XAv//Oysn/Ln7//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//nZuZ/5iTk/+Uj5D/ko2N/5GLi/+Ri4r/kYyK/5GLif+Ri4n/koyK/5WOjP+W + kI//mpSS/5yXlf+inZr/p6Og/6+qqP+2sK7/vLa2/8XAv//Oy8r/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/f4u + ff//Ln3//y59//8uff//Ln3//y59//9mi8j/k46O/46Jiv+Lh4X/iYSD/4iCgf+IgYD/h4B//4d/fv+I + gH7/iIB+/4mBf/+LgoD/jYWB/46Hhv+Sion/lY+N/5qTkf+fmpf/pqGf/66pqP+2sK//vbi3/8jEw/+T + r+L/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC18/dUuff//Ln3//y59//8uff//Ln3//y59//+Tj4//jIiH/4eCg/+FgH//gnt7/4B5d/9/ + d3X/fnVz/351cv9+dXL/fnRx/391cv+AdnP/gnh1/4R6d/+GfXr/ioB+/42FgP+PiIb/lI2M/5qTkP+e + mZb/qKOh/7Grqf+6tLT/w7+9/9DNzP8uff//Ln3//y59//8uff//Ln3//y59//8tff3xAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC14/yIuff//Ln3//y59//8uff//Ln3//y59//+Oior/hoKC/4J9fP9+ + eHf/e3Nz/3lxcP94b23/eG5r/3Ztaf93bGj/eGxo/3lsaP95bWj/e25q/3xva/99cWz/f3Nu/4J3c/+E + eXb/iH17/4yDgP+QiIb/lI2L/5qUkP+inZr/rqim/7aysP/BvLr/zsrJ/y59//8uff//Ln3//y59//8u + ff//Ln3//yt7/iMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//+K + hob/gX19/3x3d/95cnH/dm9u/3Vsav90amj/dGll/3RoZP91aGP/dWdi/3VnYf92ZmH/d2dh/3dnYv94 + aGP/eWtk/3tsZ/99b2r/f3Jt/4J1cP+FeXb/iX97/46Egv+Sioj/l5CO/5+al/+qpaP/ta+u/7+7uf/N + yMj/Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAufv//Ln3//y59//8u + ff//Ln3//y59//88V0n/gHx7/3lzc/91bm7/c2tq/3JpZv9yZ2T/c2di/3JmYf9yZF//c2Nd/3RkXf90 + Y1v/dWNb/3VjW/92ZFz/dmRc/3dlXf94Zl//eWhh/3pqY/98bWj/f3Js/4J2cv+Ge3f/i4F+/4+Hhf+V + jo3/nZiV/6ikof+1r67/v7u5/5+loP8uff//Ln3//y59//8uff//Ln3//y1+/foAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + f/8CLn3//y59//8uff//Ln3//y59//99fon/QmRO/3hyc/9ya2v/cWln/3BoZf9xZ2P/cmZh/3NlYP90 + ZF7/dGNc/3VjW/91Yln/dmJZ/3dhWP93YVf/d2FX/3diV/94Ylj/d2JZ/3hkW/94ZV7/eWdg/3trZP99 + bmn/gHNu/4R4df+Jf33/j4eE/5SNjP+blpP/qKSh/7awr/8/Y07/eoaF/y59//8uff//Ln3//y59//8u + ff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8vfv3/e3Z2/0hxVf9ybWv/cWln/3BoZf9x + Z2P/c2Zh/3RmYP91ZV7/d2Vd/3hkXP94Y1n/eWJX/3liV/96YVX/emBU/3lgU/95YFT/eWBU/3lgVP94 + YVb/eGJX/3lkW/95Zl7/emli/31taP9/cmz/gndz/4h+fP+Ph4P/lY6N/5yXlP+qpqP/RnNX/2h8bv8x + f/3/Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//fHd5/3Nubv9L + eFn/U4tm/3BoZP9yZ2P/dWhj/3ZnYv93ZmD/eWZe/3plXP97ZFr/e2NY/3xhVf98YVT/fWBT/3xfUv98 + X1H/fV9R/3tfUf97X1L/emBT/3lgVP95Ylb/eWJZ/3lkXP95aGD/fGxm/35xa/+CdnP/iH58/4+Ghf+V + j47/VI1q/0t7XP+HjIf/ycXE/y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5+//8uff//Ln3//y59//8u + ff//QH7h/3RvcP9wa2r/S3dY/1WMZv9reWr/dWll/3dpZP95aGL/e2hf/3xnXf9+Zlv/f2VZ/4BjVv9/ + YlT/gGFS/4BgUP9/X0//gmdc/5+eoP+ShoP/mpeY/31fU/97X1H/e2BT/3phVf95Ylj/eWRb/3lnYP98 + bGX/fnFs/4J3dP+JgH7/kYmI/1SQa/9Lelv/paGf/724t/9Rj/P/Ln3//y59//8uff//Ln3//y5+/dgA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//Ln3//3dzdP9wa2z/cGlo/0x2WP9XjmP/XJ10/3hqZf96a2T/fmtj/39qYf+B + aF7/gmdb/4NmWP+DZVb/hGRT/4ViUf+mpaf/p6ep/6enqP+mpqf/l4uG/5+dnf+gn6H/nZ2f/5WQkP96 + XVP/emFV/3liWP95ZV3/eWdg/3tsZ/99cW3/g3h2/1qieP9UkWf/TXha/6aiof+1sK//w8HA/y59//8u + ff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAzZv8FLn3//y59//8uff//Ln3//y5+//9xbG3/cGpp/3Jraf9sa2T/Vodf/12bbv9g + pnz/fmxk/4FtZP+Da2H/lImG/6Kho/+npqj/qamr/6mnqP+Nb2H/raus/6+ur/+urq//rayu/52Piv+n + pKP/pqan/6OipP+fn6H/m5qc/5aWmP+Ifnr/eWJZ/3llXf95aGL/e21o/2SlgP9boXT/VY1k/1B4W/+d + mZf/q6im/7u2tf8uff//Ln3//y59//8uff//Ln3//yt8/i8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALX796i59//8uff//Ln3//y59//9pcof/cGxq/3Jrav91 + bmv/eG5r/1SAWv9el2n/YqN2/3bCqf+bmpz/oJ+h/6Skpv+oqKn/q6ut/6+usP+xsbL/l35z/7Oxsv+1 + tbX/tbS2/7OztP+ik43/h19K/4ZeS/+Pd2z/pKSl/5+fof+bm53/lpWX/5GRk/+NjI//fXBt/3VzZ/9f + qXz/XJxu/1SGYP+Gfn7/mJKR/6Ognv+zrq3/p7TM/y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//cGxt/3Fsa/90bW3/eHBu/3xxbv9WdVb/Xo5h/2Wgdf93zKz/lqyn/6Sjpf+koaD/jGpa/45pV/+O + Z1P/j2hX/5qAdP+3tbb/urm7/7q5uv+6ubr/p5iR/6+pqP+HXEr/hl5K/4RfTP+CXk3/koaA/5qZm/+V + lJb/kI+R/4uKjP9wyqr/YKV2/1qUZv9Pelr/ioKB/5ONi/+cmZb/q6in/724uP8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//Ln3//3Ftbf9zbm7/eHFv/3tycf+AdHH/f3Fs/1mCWP9jmGb/e8un/37UvP+n + p6n/ra2v/7Kysv+2tbb/mXtu/5FnUf+SZk//u7q6/769vv+9vL7/vby+/6qalP+2s7L/t7a4/7OytP+j + m5n/hF5O/4NgT/+AYlL/fF9W/5KRlP9207r/csij/2iwg/9YiF//fHJu/4Z+ff+OiIj/mJOS/6Ogn/+3 + srH/Ln3//y59//8uff//Ln3//y59//8tfP37AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//9xbW3/dW9v/3tzc/+AdnP/gnd0/4V3cf9a + eVb/YpBe/2ibaf9nmnL/itC9/7Gwsf+2trb/urq8/729v/+/v8H/ooZ6/7++vf/BwML/wMDB/7+/wP+t + nZb/ubW1/7u6vP+4t7j/srK0/62trv+npqj/oaCi/5uanP+N28z/ec+z/264jf9gmmf/VYFa/3twbv+B + eHf/ioSC/5SPj/+em5r/sayq/y5+//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8xfPf/c25v/3hycv9+ + d3X/gnh2/4N4dP+IeXP/hHNr/1+DVv9olmH/aphr/2ibdv+JoIL/lG1e/7y6u//CwsP/xMTF/6WJe//D + wcL/xcTG/8TDxP/CwsP/r5+Z/5JkS/+PYEz/lG9h/6qdmf+vra7/qaeo/52Xlv+UvKj/ZaKC/2Wgdf9l + n2r/XYte/3ptZ/96b2z/f3Z0/4eAf/+Qi4v/m5iW/6mnpf84gfn/Ln3//y59//8uff//Ln3//y59//8s + ff5yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8u + ff//Q3rS/3Vxcf97dXX/gHl4/4R7eP+HenX/iXp1/4x6c/9nclX/ZotZ/2qVYf9rlWv/cZd1/5qfgv+a + cVr/nHJZ/6F5af+rkIH/yMfG/8nJyf/Hx8j/xcXG/7Kim/+UZk7/kmNO/6ydlf+tpKD/jWRR/4lkUv+h + qZH/caGB/2aedf9nnGr/Y5Zi/1mAV/93aWX/eW5q/3xzcf+Ce3r/jYiH/5mUlP+lo6L/YJDj/y59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn3//y59//8uff//Ln3//0x2vv94c3P/fXd2/4F5eP+Fe3j/iXx3/4t8dv+OfHT/kHtx/2J9Uf9r + kFr/bJFg/2yTa/+Bl3f/qJ2D/6F2X/+leF//pndf/9HOzv/Pz8//zMzM/8rKyv+1pZ7/l2lR/8LBwv+/ + v8D/urq7/7a1t/+po4z/gZ+C/2madf9pmmj/Z5lj/1+GWf94aGL/dmpl/3hsaf96cXD/gHl5/4uGhf+W + kZL/oJ6d/3CW2P8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//9Ld8H/eXR1/4B6ef+Cenn/hn16/4t+ev+O + fnj/kX92/5R/df+DbF//Z4BS/26QWv9uj2H/b5Fs/42Wd/+wnIP/q31l/65/Zv/a19f/2NfX/9TT0//P + z8//uaqi/5psVP/Ew8X/wMDB/7y8vf/c8/H/teff/2uYc/9ql2n/apZg/2SJWf9ndFf/eWli/3hqZf93 + a2n/eXBv/353dv+HgoL/k46P/56cm/9lkdz/Ln3//y59//8uff//Ln3//y59//8uff//Ln7//wAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//QXvZ/3t3d/+B + e3r/hX17/4h+fP+MgHz/j4F8/5OBev+Xg3n/nIV4/2N0S/9sh1L/b4xY/2+NYf9zj2v/mZd6/7achP+1 + hm7/4d/e/+Lh4f/c2tv/19XW/76up/+dcFf/xsXG/8LBw//l9vX/xe7p/5ng0v9slGr/a5Rj/2iPWf9f + e1L/fWpi/3trZP94bGb/dmtp/3hwbf98d3X/hoB//5KOjP+cmpn/R4fv/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8u + ff//Ln3//y98/P99eHj/g318/4Z/fv+JgH7/joN//5KEfv+VhH7/m4d8/6GJfP+kiHr/ZnlL/2+IUv9w + iln/cIxi/3uQbv+jmX7/vJ2F/+nm5v/p6Oj/5ePj/93c3P/FtK3/onVc/8jHx//r9/f/1PHw/6fk2/+Q + 2sb/bJJi/2uSW/9kf1P/gGtg/39sZP97bGX/eGxn/3Ztaf94cG3/e3V0/4R/f/+QjY3/m5mY/y9///8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//LH39twAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//Ln3//y59//8uff//fnl5/4J9fP+HgH7/ioJ//5CEgf+UhoH/mIiB/56LgP+l + j4P/rpOF/4drW/9qfk3/cIpT/2+KW/9wjWX/g5Jx/6ibgf/q9fP/7+7u/+vr6v/k4+P/ybmx/6Z5Yf/r + 9/b/2vPy/7Do4P+S3Mv/jtS5/22RW/9nhlT/b3FW/4NuZP9+bGX/e21n/3ltaf93bmr/d29t/3t0dP+D + f37/kI2M/5uYmv8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//356e/+Dfn3/h4CA/4yDgf+Q + hoL/lYiE/5uMhP+hj4b/q5SJ/7Oajf++oJL/anFL/22DTv9wilT/cIpd/3COZ/+KlXb/1u/t//v5+v/v + 7u7/6ejo/8y9tv/QpIz/6fb0/7bp4v+W39H/kNa+/4zPrf9ri1b/YXtO/4lyZ/+EcGf/f29o/3xuaf95 + bmr/d25r/3dwb/97dXX/gn9+/4+MjP+bmZj/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//JnL/FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn39/i59//8uff//Ln3//y59//99 + eXr/g39+/4iBgP+MhIL/kYeE/5aLh/+cjof/pJSL/66Yjv+3n5P/w6ib/8+yo/9nd0r/b4lR/3CKV/9w + jGD/cY9r//j29v/6+vr/8vn5/+jv7//f2tP/0qiS//n5+f+X39H/kdjC/43Rsf9sj1r/ZX5Q/5B3bP+K + dWv/hXJr/4Bwav99b2v/em9r/3hvbf94cW//enR0/4N/f/+QjI3/nJuZ/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt8/iku + ff//Ln3//y59//8uff//XHqv/4SAgP+HgYH/jIWE/5GJhf+XjYn/nZGK/6aWjv+wnJP/uqSZ/8euof/T + uar/v6KS/2l9Tf9uilP/b4xZ/2+OYf/v9fP/6/f2/+H19P/R8u3/2+/t/8Sol//u9/b/j9jC/47Ss/+H + xZ3/Z4NS/5J5bf+Od23/i3dv/4Z1bv+Bc23/fXFt/3twbv94cG7/eHFw/3t2dv+EgID/ko6P/zR/+P8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//+FgYH/iIOD/4uFg/+RiYf/mI6L/56Tjf+m + mJD/sJ+W/7qmnP/HsKX/07ut/+DHuP+Pc2P/aoBP/26MVv9wjl//3PDu/9jz8v/E7en/ruff/8Hs6P/X + 8vH/2/Px/73m1/9zn2//Z4VU/4FzYP+RenD/jnlw/4x6cv+HeHH/gnVw/31yb/96cW//eHFv/3dxcP97 + d3f/h4OF/5WSk/8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+/egA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//hICB/4eDg/+L + hYT/kYqI/5eOjP+dk47/ppmT/6+gmP+5p57/xbGn/9G6r//exrn/5cu9/35sWf9pg1H/s7Kd/8br5v+0 + 6eL/n+LW/4zczP+a4dX/r+fg/6W1o/+vtKD/aIlW/2t3VP+TfXH/kXxz/458dP+MfHX/h3p0/4F2cv99 + dHH/enJx/3lycP95c3T/fXl5/4iFhv+KkaL/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwef4VLn3//y59//8u + ff//Ln3//y59//+Hg4T/ioaF/4+JiP+VjYz/nJSP/6SZlf+un5n/t6eg/8Gvpv/Nuq7/1sK2/+LLvv/m + zcD/b3NT/5Ovl/+d4NX/jd3O/3/Nt/9pm3P/Z597/26khv9+q5H/jbKa/2F8Uf+XgXb/lH92/5F+d/+P + f3j/jH54/4d8dv+CeHX/fXRz/3tzc/94cnH/eXR1/398fP+Nion/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yt9/kEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//Ln3//y59//8uff//g4GH/4qGhv+OiYj/k4yM/5qTj/+imZT/qp+Z/7Sln/+8 + rKT/xbSs/868sv/Ww7j/3Me7/32xmP9tqoz/ZaWD/2ahe/9nnXH/aZts/2adc/9ko33/ZKiH/2qsjv92 + spf/loN6/5SCev+QgXv/joB7/4yAfP+HfHn/gXh2/312dP96dHT/eHNz/3t2d/+Bf3//goyg/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsfP9QLn3//y59//8uff//Ln3//y59//+IhYX/jYiJ/5CLiv+W + kI//npeT/6admP+vop3/tqii/7+uqP/Gta3/zbux/2exlP9hrY3/YqiD/2Skev9loXT/Zp5t/2ecaP9l + n23/ZaJ0/2Omfv9hq4X/X66L/2Czlv+UhH//kIN+/4+Dfv+LgX7/hn17/4F5eP99d3X/eXR0/3p1dv98 + eXn/iIWH/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//xxx/gkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//Ln7//4uHh/+Piov/lI2N/5uTkv+hmZX/qKCb/7Cln/+2qaP/u66n/1yxkP9fror/YaqC/2Gnev9j + o3T/ZKFu/2WfaP9kmmP/ZKBo/2Sibv9ipXb/YKl9/1+rgv9fsIj/XbST/5CFgP+OhIH/i4KA/4R9e/9/ + eXj/fHh3/3p1dv96dnf/gH1+/y9+/f8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AP8BLn3//y59//8uff//Ln3//y59//8/f+f/jYmI/5GMjP+WkI//m5WS/6ObmP+qoZz/r6Sg/1yxhv9d + r4X/X61//2Cqev9hp3T/Y6Vv/2Kgaf9glGT/XIld/1+SYv9hoWn/YqZw/2Godf9eqnr/YK5//12xhv9b + son/kYmF/4mCgP+EfXv/f3l5/3x3eP95dXf/fHp7/2eCsf8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAACx8/esuff//Ln3//y59//8uff//Ln3//1WBzf+Piov/k46O/5aRkP+b + lpP/lJeQ/1yufv9csID/Xq58/1+sd/9gqHL/X6Rt/1+fav9bkGP/WYdd/8e6tP9cg17/XJBj/16eaP9f + pm//YKty/16sdv9dr33/XLGB/1yxgP9/k4P/gXt8/315eP96dnj/end5/3p/jP8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + fv3+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8u + ff//SIHd/4+MjP+Tjo3/VZlv/1mjdP9bq3f/Xa53/12pdP9dpG//XJxr/1mTZv9WjWL/mpGL/6Wblv+i + mJP/n5WQ/4p/fP9UjGL/WZJn/1qaav9bo27/XKp0/1uueP9arXj/WKR3/1Sccf97eXn/end5/2x8mv8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//Ln3//y59//8uff7/TH9f/1GPZ/9VmGz/V59t/1iebv9Wlmr/VJBm/1KLYv+J + h4D/o5uX/6Galf+gmZT/nZaS/5uUkP+ako//l5CO/396dv9Ri2L/U5Bk/1WUav9Xn27/VqBv/1WYbf9R + kmn/S4Fg/zF85v8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//Ln3//y59//9MgWD/UIpk/1GNZf9R + i2T/UoZi/5WQjv+blpT/nJeU/5yXk/+blpL/m5WR/5uUkf+YkpD/lpCP/5WOjv+TjYz/kYyL/4WAf/9W + hWT/UItk/1COZv9Oimb/TIFh/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8u + ff//Ln3//y5+//+Oi4z/ko+O/5SQkf+WkZL/l5OS/5eTk/+XkpL/l5KS/5eRkv+WkJH/lI+P/5SPjv+S + jY3/kY2N/4+Li/+MiIj/h4OF/4KAgP98eXr/L339/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y58/f4uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//96iKb/kY6O/5OPj/+Tj4//lJCQ/5SPj/+U + j4//ko6O/5OOj/+Sjo3/j4yN/46KjP+Kh4f/hYKD/3h+iv8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC5+//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln7//1eDz/+Aip//kI2N/5CNjv+Pi43/hYiT/2GCvP8wffv/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8ufv//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALXn+Qy59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALHz93y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//LX/9ygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALH79py59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//LH39wwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1//b4u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC16/jgsfP2DLn39uy58/eEtfP34LXz9/i59//8u + fv//Ln7//y5+//8uff//LXv9/Sx8/fwue/35LXv99yx9/fQtfP3xLH399Cx9/foufv//L3///y5+//8u + ff//Ln3//y59//8uff//Ln3//y5+//8vf///Ln39zSh4/iYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + 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 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////////////////////// + /////////////////////////////////////////////AB////////AAAf//////wAAAf/////8AAAA + f/////gAAAA/////4AAAAA/////AAAAAB////4AAAAAD////AAAAAAH///4AAAAAAP///gAAAAAA///8 + AAAAAAB///gAAAAAAD//+AAAAAAAP//wAAAAAAAf//AAAAAAAB//4AAAAAAAD//gAAAAAAAP/+AAAAAA + AA//wAAAAAAAB//AAAAAAAAH/8AAAAAAAAP/wAAAAAAAA//AAAAAAAAD/8AAAAAAAAH/wAAAAAAAAf/A + AAAAAAAA/8AAAAAAAAD/wAAAAAAAAH/AAAAAAAAAf8AAAAAAAAB/wAAAAAAAAD/gAAAAAAAAP+AAAAAA + AAAf4AAAAAAAAB/wAAAAAAAAH/AAAAAAAAAP+AAAAAAAAA/4AAAAAAAAB/wAAAAAAAAH/AAAAAAAAAP+ + AAAAAAAAA/8AAAAAAAAD/4AAAAAAAAP/wAAAAAAAA//gAAAAAAAD//AAAAAAAAP//AAAAAAAB//+AAAA + AAAH//+AAAAAAA////AAAAAAP////8AAAAH///////////////////////////////////////////// + ////////////////////KAAAAEAAAACAAAAAAQAIAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8p + e///c2tr/0paEP9KKRD/jISE/5ylpf+cjKX/e1oQ/3sQY/9apWv/GWu9/97vrf+c763/7xlr/xkpvf/v + GSn/GWuU/8UZa/8ZKZT/xRkp/5wZEP/ezmv/zlrv/1rOa//OlGv/3s4p/85arf9azin/WqUQ/5zOa//O + Ge//Gc5r/5zOKf/OGa3/Gc4p/xmlEP97GTH/GUq9/97vjP+c74z/7xlK/xkIvf/vGQj/GUqU/8UZSv8Z + CJT/xRkI/97OSv/OWs7/Ws5K/86USv/ezgj/zlqM/1rOCP9ahBD/nM5K/84Zzv8Zzkr/nM4I/84ZjP8Z + zgj/GYQQ/97Ozv9zWlL/3u/v/1Jrvf8Qa+b/nMWt/2Nr5v/exa3/Wozv/1prlP86a+b/lIRS/ykQ5v8I + EOb/CFoQ/wgpEP9KEOb/lJyM/5zOzv9ajK3/WozO/+9aa//vnK3/Wim9/+9aKf8ZKWv/xVpr/1oplP/F + Win/GSlC/5xaEP+cEGP/nKVS/xClY/9aSr3/e1ox/3sxY/9aSpT/71pK/++cjP9aCL3/71oI/xkIa//F + Wkr/WgiU/8VaCP8ZCEL/EIRj/xlKa/8ZSkL/nK3O/1qMjP8ZjO//Y4Rr/1rOrf+UWmv/xZyt/5zvzv+c + 7+//3u/O/5RrjP+cre//3q3O/5zFjP/e72v/71rv/1rva/9a7+//75Rr/5Rr7/9a763/3u8p/+9arf9a + 7yn/WqUx/96lKf/ere//Wq2t/1qt7/+Ua63/nO9r/+8Z7/8Z72v/nO8p/+8Zrf8Z7yn/GaUx/5wZMf8Z + ra3/Ga3v/xnvrf+UKa3/Ge/v/5Qp7/+cpSn/Wq3O/xmtzv9a74z/Wu/O/5Rrzv/epQj/Ga2M/xnvjP+U + KYz/Ge/O/5Qpzv+cpQj/3s7v/97FjP+cjM7/nM7v/5RKjP+cjO//3ozO/97vSv/vWs7/Wu9K/1rO7//v + lEr/lErv/97vCP/vWoz/Wu8I/1qEMf/ehCn/3ozv/5RKrf+c70r/7xnO/xnvSv+c7wj/7xmM/xnvCP8Z + hDH/GYyt/xnOrf+UCK3/Gc7v/5QI7/+chCn/GYzO/1rOjP9azs7/lErO/96ECP8ZjIz/Gc6M/5QIjP8Z + zs7/lAjO/5yECP/FnIz/Silr/ylC5v9KKUL/Sghr/whC5v9KCEL/Skpr/0pKQv9KQub/lJxz/4R7c/9S + hFL/Y6VS/5xaMf+cMWP/MaVj/zGEY/9KCBD/KVoQ/ykpEP9rEOb/GQgQ/xlra/8Za0L/lFpS/3spEP97 + CBD/Smtj/2utjP9rhFL/SmtC/3NrWv9rQub/pZyM/5yEc/9KrYz/EGv//wAIGf8pY///AAgA/wAAAP8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+7P7+/v7+AAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v7+/gEBAQEBAQH+/gAA/gAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7+AQEBAQEBAQFHAQEBAQFHAQH+ + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQFHAQEBAQEBAUcB + AQEBAUcB/v7+/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOz+/gFHAQFHAQEBAQEBAQEB + AQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+AQEBAQEBAQEBAQEB + RwEBAQEBAQEBAUcBAQFHAQH+/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v7+AQEBAQEBAQEB + AQEBAQFHjQFHAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBRwEB + AQEBAUesBgZ3Bnd3RkR9cY0BAQEBAQEBAQFHAf4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v4BAQEB + AQEBAQFHrAb4BgcG+AcGBgZ3RHdGcXFHAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB + AQFHAQEBAUdSB1AFBQUFBQUF+AX4B/gGd0RGP3FHAQEBAQEBRwH+/gAAAAAAAAAAAAAAAAAAAAAAAAAA + AABHAQEBAQEBAVMHBQUFBQUF4QXhBQUFBQUFB/gGBndGUXxHAQEBAQEBAQAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAQEBAQEBAQcFBQXh4eHh4eHh4eHh4eEFBQX4B/gGd0R9cQEBAQEBAQEB/gAAAAAAAAAAAAAA + AAAAAAAAAOz+AQEBAQEBSVIF4eHhAuECAgICAgIC4QLh4eHhBfkFBwZ3REZxRwEBAUcBAQAAAAAAAAAA + AAAAAAAAAAAAAAAAAQEBRwEBSQUFAuECAgICAgJAdvZ29gICAnbh4eEFBQX4+AZ3P1FHAQEBAQEB/gAA + AAAAAAAAAAAAAAAAAAD+AQEBAQEBAUgFAgICAvYCQAL2Avb29vbv9gL2AgIC4eEFBQX4BndEBgEBAQFH + AQAAAAAAAAAAAAAAAAAAAAAAAAEBRwEBAUjyAgICAvYCAkACQPZA9vZA9vb27wL2duHh4eEFB/gHd3RI + AQEBAQEB/gAAAAAAAAAAAAAAAAAAAAEBAQEBAVN09XT2AgJAAvYCQPb270D270D2QPZA9vb2duHh4QVQ + +AbyBY0BAQEBAQAAAAAAAAAAAAAAAAAAAAABAQEBAQFIAvJ0AgL2Avb27/bv9kBA9kBAQO9AQO/29gIC + 4eH5BVB051BRAQEBAUcB/gAAAAAAAAAAAAAAAAD+RwEBAQFTAgLidHQCdvbh9vb29u/273b5Bfnh4fZA + 9u/29gIC4QUFdOJQd3wBAQEBAQAAAAAAAAAAAAAAAAAAAQEBAQEB4QIC8uIKAgL29u/27/bvQPkGBgYF + +Af4BXZA9kB29uHhcgryBndRAQEBAQEB7AAAAAAAAAAAAAAAAAEBAQEBSQICAnR0CgrhduEFB/gG+PkG + d0R3BfkGBgZQB+ECAgLhdAridPgGd0cBAUcBAQAAAAAAAAAAAAAAAAABAQEBR1ICAgICdHQKUFAGBvj4 + BncF+HdEd1BA7/lQBvgHUAXhdPoKdOEHBgZxAQEBAQEB/gAAAAAAAAAAAAD+RwEBAQFIAgICAvR083VE + Bgf57+/5+fhxRnf4+eHv7/YFUFAFUEQKCuIFUPh3UQEBAQEBAQAAAAAAAAAAAAAAAQEBAQEBAgLh4eEC + 4nTzUUQGd0T470oGRlFE+Ph3RFD5QO/hBnV18+ICBQVQBndzAQFHAQH+AAAAAAAAAAAA7AEBAQEBSQIC + AuHh4XTjdPNERHdEcUb5Bnc/ffj4P3cGdwYHUFFE8wp0AuEFUAZ3RwEBAQEBAQAAAAAAAAAAAAABAQFH + AVMCAgUC4eF29HQK8+D5d0Y/+Xc/cUT473b5+PgF+UTzCgp09uHhBQUHBkcBAQEBRwH+AAAAAAAAAAD+ + AQEBAQFJAgLh4eHh4fT043Tz4O/5+NYGPz8/+Ep2+Pj59lDg8wp09AICAgUF+AZxAQEBAQEBAQAAAAAA + AAAAAAEBAQEBUuHhBeEFBfnh9vQK4eD4+UpqRD8/UdbvBj9EdwbgCgp09OH24QLhBQcHUwEBAQEBAUf+ + AAAAAAAAAABHAQEBAUIC4eHh4eEF+eH09Ap04Pn5+UZ6Pz/WSndEfXpR4HTjdPb2AgLhAgVQBlMBAUcB + AQEBAAAAAAAAAAAAAQEBAQFTAgXhBQUF+fn59vT09ODg1hlGqj8/d0p3P0F5UeMK9PT29gICAuEFBQZT + AQEBAQEBAQH+/gAAAAAAAAEBAQEBUwIF4QUF+QX5+fn09HTj4eDWP0FBP9b5RkFBeFF09PT2dgICAuEC + BVBQR0cBAQFHAQEBAAAAAAAAAAABAQFHAUnhBeEFBfkF+PnWSvT09ODg+D9BQUFG+T9BeVFECvT24fYC + AuEC4QUFB0cBAQEBAQEBAQHsAAAAAAAA/gEBAQEB4eEFBQUF+fj4Btb29PT0dOB6QUFBRtY/eHhRfvT0 + 7+EC4QICAgIF+AYBAQEBAQEBRwEBAAAAAAAAAAABAQEBAQUFBQUF+Pj4+NbW1vT09HThekFBQT/WQXhR + RAr0SuHhdgLhAgLhBQVTAQEBRwEBAQEBAQH+AAAAAADsAQEBAQFCBQUFBQUF+NYG1kb49PTjdKpBQUE/ + RkFRDfP04Xbh4QLhAuEC4eEHUwEBAQEBAQEBAQEBAAAAAAAAAAEBAUcBRwUFBQUH+Ph3d3dGRuD09OB6 + QUF5QUFBeOD04eH54eHh4QLhSOEFUAFHAQEBAUcBAQFHAf7+AAAAAAD+AQEBAQFIBQUFBfgG+H53Rj9G + 4fRQenl4UXhRUX704fnh+eHh4QLhAgLhUFMBAQEBAQEBAQEBAQEBAAAAAAAAAAEBAQEBRwUFUPj4+Ph3 + RndGP0Z0BkRR8/NQ81AGdPn5+eEF4eEC4QLh4QVJAQEBRwEBAQFHAQEBAez+AAAAAAABAUcBAQFSBQUF + B/gG1gZGd0ZGUPPz8woKdArz8/MFBfkF4QUFAuHh4QVTRwEBAQEBAQEBAQEBAQEBAAAAAAAAAAEBAQEB + AQUFUAf4+AZ3RkRG8/PzCnQK4Arz8/Pz8wUFBQXh4eEC4UgFAQEBAQEBAUcBAQEBAUcBAez+AAAAAAAB + AQFHAQFHBQVQB/gG+HcG8/PzCvMK4wp0CgrzCszzBQUF4UgFAuHhRwEBAUcBAQEBAUcBAQEBAQEBAAAA + AAAAAAEBAQEBAVMF+AX4+AYG8wrzCvMKCnR04woKCvPz+vPg4QXhAuF7UgFHAQEBAQEBAQEBAQEBAQEB + Af4AAAAAAAD+AQEBAQEBUwVQB1BQ8/P68woKCgp0UHR0CgoKCvP683IF4eHhUgEBAQEBAQEBRwEBAQFH + AQEBAQEAAAAAAAAAAAEBAUcBAQFTBQUKcgoKCgoK4goF+Pj44XQKCgoK+gpyCgLhUgEBAQEBAQEBAQEB + AQEBAQEBAUcBAQAAAAAAAAAAAQEBAQEBAUfnCgoKCgoKdAUH+Af4B1BQ4XTnCgoKCuJ0UwEBAUcBAUcB + AUcBAQFHAQEBAQEBAQEAAAAAAAAAAAABAQEBRwEBSXJ053R0BVD4B/j4BfgFBwUFBXR04gpycwEBAQEB + AQEBAQEBAQEBAQEBAUcBAQFH/gAAAAAAAAAAAAEBAQEBAQEBU1IFB1AHUFAHUAdQUFAHBQUFBUhTAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAAAAQEBAUcBAQEBR1IHUAUHUAVQBQcFBQUFUkcB + AUcBAUcBAUcBAUcBAUcBAUcBAUcBAQEBAQEAAAAAAAAAAAAAAAABAQEBAQEBAQEBAUdTU1KsUgdSU1NH + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQFHAQEAAAAAAAAAAAAAAAAAAAEBAQEBRwEBRwEBAQEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEBAUcB + AUcBAUcBAUcBAUcBAUcBAUcBAUcBAUcBAUcBAUcBAUcBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA//////////////////////////////////////////////////////////// + ///////8AH///////8AAB///////AAAB//////wAAAB/////+AAAAD/////gAAAAD////8AAAAAH//// + gAAAAAP///8AAAAAAf///gAAAAAA///+AAAAAAD///wAAAAAAH//+AAAAAAAP//4AAAAAAA///AAAAAA + AB//8AAAAAAAH//gAAAAAAAP/+AAAAAAAA//4AAAAAAAD//AAAAAAAAH/8AAAAAAAAf/wAAAAAAAA//A + AAAAAAAD/8AAAAAAAAP/wAAAAAAAAf/AAAAAAAAB/8AAAAAAAAD/wAAAAAAAAP/AAAAAAAAAf8AAAAAA + AAB/wAAAAAAAAH/AAAAAAAAAP+AAAAAAAAA/4AAAAAAAAB/gAAAAAAAAH/AAAAAAAAAf8AAAAAAAAA/4 + AAAAAAAAD/gAAAAAAAAH/AAAAAAAAAf8AAAAAAAAA/4AAAAAAAAD/wAAAAAAAAP/gAAAAAAAA//AAAAA + AAAD/+AAAAAAAAP/8AAAAAAAA//8AAAAAAAH//4AAAAAAAf//4AAAAAAD///8AAAAAA/////wAAAAf// + //////////////////////////////////////////////////////////////8oAAAAMAAAAGAAAAAB + ACAAAAAAAABIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALHz+Vi59/bsuff3dLoD9yy17/nwAAP8BAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuf///Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//InP+FgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8sf/3eAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yR//g4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//y59//8u + ff//Ln3//zF+/P+2sLD/s66t/7Svrf+3sbD/ubSy/765uP/FwcD/UY7x/y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff3+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACN4/iQuff//Ln3//y59//8u + ff//Ln3//y59//+ioJ7/nJmX/5qWlP+alZT/mpaT/5uWlP+empj/oJya/6ejof+uqqj/trCv/764uP/J + xcT/MID+/y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXv+Pi59//8u + ff//Ln3//y59//8uff//mZaV/5KNjf+OiYr/jYeH/4yGhf+LhoP/jIWD/42GhP+PiIf/kYqI/5WPjf+a + k5H/n5qX/6qlov+0rqz/vLe2/8vHxv8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + f/8CLn3//y59//8uff//Ln3//y59//+OiYn/iYWF/4V/f/+Benr/gHh3/392dP9+dXL/gHZz/4F3df+C + eXb/hXx5/4mAfv+OhYL/kYqI/5iQkP+gm5j/rKak/7eysP/Ev77/e6To/y59//8uff//Ln3//y59//8t + fP37AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//4iFhf+Be3v/fHd1/3lxb/94b2z/dmxp/3dsaP93 + a2f/eGtn/3ptaP97bmn/fXBs/39zb/+DeHX/iH16/42Dgf+Tioj/mpOR/6Wfnv+zrqv/v7u5/87Mz/8u + ff//Ln3//y59//8uff//AH//CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uffz/gn9+/3p0dP91b23/dGtp/3JoZf9z + Z2P/cmVh/3RlX/90ZV7/dWVd/3ZlXv92Zl//eGdh/3lqY/98bWf/f3Js/4N3dP+Ifnv/j4aE/5WOjf+g + m5j/saup/765uP/JytD/Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2L+DS59//8uff//Ln3//y59//9AX0z/eHJz/3Jrav9w + aGX/cWdj/3JlYf9zZV//dGRd/3VkW/91Yln/dmFY/3ZhV/93Ylj/d2JY/3hkWv95Zl7/eWli/31taP+A + c27/hnt3/42Egf+VjYz/npmW/7Grqf+Hlor/N4L3/y59//8uff//Ln3//y59/fIAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//Ln3//397fP9H + cFX/c2tp/3BoZf9xZ2P/dGdh/3ZmYP93ZV3/eGRb/3liWP96Ylb/emFV/3pgU/96X1P/eWBT/3lgVf95 + Ylj/eGNa/3pnX/97a2T/f3Js/4V6dv+NhIH/lI2M/6Gcmv9Jd1r/pKKg/y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZv8FLn3//y59//8u + ff//Ln7+/3Nvb/9Jc1X/VY9p/3NoZf92aGT/eGhi/3pnX/97Zlz/fGRZ/31jVf9+YVP/fmBS/35fUP98 + XVD/fF5S/3xeUP97X1L/emFV/3liWP95Zl7/empj/35wa/+DeXX/jYSB/4WRhf9Mf17/srCu/8vIx/8u + ff//Ln3//y59//8se/3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//8uff//dnFx/3Bqaf9McVb/V5Bm/2qIcf94amT/fmti/4BpYP+CaFz/gmVY/4RkVf+E + YlL/o6Kj/6enqP+lpaf/f11S/6Ggov+dnJ//fmNb/3tgU/96Y1j/eGVd/3lqY/99cWz/hXp3/1mbcP9P + fVz/qaWj/724t/8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//8uff//cGtr/3Fqaf91bGr/Vopf/2Cgdf9+bGT/gmtj/5iTk/+k + o6X/qKep/6yrrf+rqKn/r6+w/6+vsP+urq//hV5S/6moqf+kpKX/n56g/5mZm/+TkpX/eGBa/3lnYP97 + bGb/Xqt//1iXbP9MeVn/nZmW/7KtrP9smub/Ln3//y59//8uff//AAD/AgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//9ocYj/cGtq/3RtbP96cG7/U31Y/2Caa/92 + zK3/nJ6f/6Skpf+JaFr/imVW/7Ctrv+zsbH/t7e3/7e3uP+2trj/iV9S/4hfSv+FX0v/hGRW/6Cfof+Z + mJr/kpKU/42Mj/9uv6T/X6R2/1aMYv+EfXz/lpCQ/6ekof++ubn/Ln3//y59//8uff//Ln3//wAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt7/mMuff//Ln3//y59//9xbW3/dG1u/3pycP9/ + dHH/eG9n/2CRYv96yKT/f9W//6qpq/+xsbL/qJ2a/5BnUv+RZk//vLy9/729vv+8vL3/jWFS/7i3uf+z + s7T/hmFR/4NgTv+AYVL/joaE/4yYlv9zyaj/YJ9v/1F+Wv+FfXv/kIqJ/56bmf+zr63/Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC19/f4uff//Ln3//y59//9w + bGz/d3Bv/311c/+DeHX/hndx/1yCV/9om2f/Z51y/5/azf+2trf/u7u8/8C/wP++u7v/wsLD/8HAwv/A + v8D/kGJT/7y7vf+5uLn/srK0/6qqq/+ioaP/m5qc/3rUvv9mqnz/XpFi/3pvav+BeHb/i4WD/5mVk/+s + qaf/Ln3//y59//8uff//Ln3//y58/fcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8u + ff//Ln3//y59//90b3D/e3V0/4J5d/+EeXX/iHl0/39uZf9okV3/apdn/2uZdv+goIb/l2xa/8XDw//F + wsH/x8fI/8bFx//Ew8T/k2ZX/5NlTf+QZE3/jmRP/4liUf+FYlH/d6SH/2afdP9knGb/WYFZ/3drZ/98 + c3H/hn9//5WQkP+koaD/Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//Ln3//y59//91cXH/f3h3/4N7ef+IfHj/i3x2/497c/9he1D/bJJb/2ySZf99 + l3b/rpyD/6J2Xv+ld17/0NDQ/83Mzf/Jycn/l2pb/5RlUP+/vsD/urq7/6mgnv+OoYb/aZt0/2iaZv9i + jFz/eGhi/3drZ/96cG7/gXp6/5CLjP+enJr/L379/y59//8uff//Ln3//y59//8aeP4TAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//95dHX/gXp6/4R8ev+Kfnr/jn53/5N/dv+T + e3D/aIBR/22OW/9ukGf/j5Z3/7eZgP+uf2f/3Nrb/9fW1v/Q0ND/nHBf/5dpU//BwcL/vLu8/8ju6f9r + l3P/apdn/2iQXP9fd1P/eWlj/3drZ/95b23/fnd3/42IiP+bmZf/Ln3+/y59//8uff//Ln3//y59//8u + ff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5+//8uff//Ln3//y59//97dnf/g3x8/4d+ff+M + gXz/kYJ8/5aEfP+dhnr/bW1Q/2yHUv9wi1v/cI5p/52Ye//AnoX/5+fn/+Pi4v/a2Nn/pHdm/5ttV//C + wsP/2PPx/5/i1f9sk2f/a5Jc/2B+Uf9+amP/emtl/3drZ/94b23/fHd1/4qFhf+al5b/Ln3//y59//8u + ff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/cEuff//Ln3//y59//98 + eHj/g319/4mBf/+PhIH/lIaB/5uIgP+jjoL/r5OF/2V3Sf9wilP/cIpc/3iOa/+pm4D/8fj4/+zs6//k + 4+P/q35u/6F0X//f9fP/rufd/5Daxf9tkV3/ZoRV/4VuZP9/bWb/e21n/3dtaf93b2z/e3V1/4iFhf+a + lpf/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//y59//99eXr/hX9+/4qCgf+QhoP/lomE/56Ohv+plIr/tZuP/8Kjlf9rfUz/cIpV/3CMYP9+ + knH/8/f2//v5+v/q6er/w5eI/9Cjj/+36uP/kdzL/4/Stv9rjlb/dnBY/4ZyaP+Ab2j/fG5p/3hua/94 + cG7/e3Z1/4mFhf+alpf/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//9Uebb+hIB//4qDgf+Ph4X/mIyI/6CSiv+tmZD/uqKX/8qwof+K + bFz/bYVP/3CLWP9vjmT/+Pn5/+/49//d9PP/wKiY/9CvoP+R3Mv/j9S3/32yhv9jfFD/jXZr/4h1bf+B + cmz/fHBs/3lvbf93cW//fHd2/4qHh/+bmpj/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yx9/n4A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//hICA/4mDgv+QiYX/mI6M/6GUjv+v + nZX/vKac/821qf/fxbb/bXFM/22JUv9ujlv/4fTy/9nz8f+36eP/ze/t/93z8v/e8/D/eq6A/2WAUf+R + eW7/jnpx/4p5cv+CdXD/fXJv/3lxb/94cnH/fHh4/4yJif8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArfP27Ln3//y59//8uff//g4CA/4mEhf+P + iYj/mI+M/6GWkP+unpf/uqif/8u2q//bxLf/5cu9/2R6Tf+psJj/vuvm/6Lj2f+K28r/l9/T/5eyoP+m + s5//ZoRU/5+IfP+RfXP/j3x1/4l7dv+Cd3P/fXRy/3pycf94c3P/fnp7/5CNj/8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8u + ff//Ln3//4iEhf+OiIj/lY6N/5+Wkv+qn5n/tqef/8Oxqf/RvbP/3si8/+PMv/+BrZT/fsez/2aee/9o + mm//Z595/2alhv94rZP/q5eK/5WAeP+QgHn/joB6/4p+ef+CeHb/fXZ0/3lzc/95dHX/gX9//zV/9v8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALXv9/S59//8uff//Ln3//36BkP+Mh4f/ko2K/5uTkP+lm5f/sKSe/7urpP/Gta3/z7yz/2evkv9i + qYX/ZKR6/2Wgcf9mnGj/ZZ9v/2Skef9gqob/X6+O/5aMg/+Rgn3/j4N//4h/fP+BeXj/fHd2/3p1dv96 + d3j/ioeI/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//+Khob/j4qL/5WOjv+fmZX/qKCc/7Onof+5 + rKb/XbKO/2CthP9hp3n/YqNz/2Sha/9jmWP/Y6Bn/2OkcP9iqHr/X6yC/1yxjP+JlYf/joSB/4iAfv+A + eXj/fHh3/3l0dv9+e3z/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACp7/mcuff//Ln3//y59//8uff//jIiI/5KNjf+Y + kpH/n5mV/6Wdmf9esIP/X6+A/1+reP9hp3D/YaRs/12SY/9ahVz/W4xg/2CfaP9gp3D/YKx2/16ufv9d + soT/Za2D/4Z/f/9+eXn/e3Z3/3t4ef8ufv//Ln3//y59//8uff//Ln3//y59//8uff//Lnv9/S59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8u + ff//Ln3//46Kiv+Tjo7/WJty/1mldf9drnr/Xqt1/12kb/9alWf/Vo5i/7itqP+jmZP/n5WQ/1iIX/9a + lGf/W59s/1uncf9br3n/Wq15/1iidf98eHn/end5/y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yl5/j0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn3//y59//8uff//Ln3//y59//9Ke13/Uo9m/1aZbf9Xm27/VZJo/1GMYv+XkIz/o5uX/6CZlf+d + lpL/m5SQ/5iQjv+Si4r/UYli/1KQZf9Wmm3/Vp1v/1GRaP9Lg2D/Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//Ln7//02HZP9wg3b/mJOS/5mTk/+a + lJP/mpST/5qUk/+YkpH/lpCQ/5SOjv+SjYz/j4qK/42JiP95eHf/TYdk/0KBjv8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y5+//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8u + fv//kY6O/5OPj/+UkJD/lJCR/5SPkP+Tjo//k46O/5CMjP+PjI3/i4eI/4SBgf9Ofcr/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y5//bwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn7//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//L339/0N/4/9hhMH/VYHO/zeA9P8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXb+Ky59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//yJ3/w8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA////////AAD///////8AAP///////wAA////////AAD//+P///8AAP/8AB///wAA//AAA///AAD/ + wAAB//8AAP+AAAB//wAA/wAAAD//AAD+AAAAH/8AAPwAAAAP/wAA+AAAAA//AADwAAAAB/8AAPAAAAAD + /wAA4AAAAAP/AADgAAAAAf8AAMAAAAAB/wAAwAAAAAH/AADAAAAAAP8AAMAAAAAA/wAAgAAAAAB/AACA + AAAAAH8AAIAAAAAAfwAAgAAAAAA/AACAAAAAAD8AAIAAAAAAHwAAwAAAAAAfAADAAAAAAB8AAMAAAAAA + DwAAwAAAAAAPAADgAAAAAAcAAOAAAAAABwAA8AAAAAADAAD4AAAAAAMAAPgAAAAAAwAA/AAAAAABAAD+ + AAAAAAEAAP8AAAAAAQAA/4AAAAADAAD/4AAAAAMAAP/4AAAABwAA//8AAAAfAAD///////8AAP////// + /wAA////////AAD///////8AAP///////wAAKAAAADAAAABgAAAAAQAIAAAAAAAAEgAAAAAAAAAAAAAA + AAAAAAAAAAAAAP8pe///KRAQ/0Jj3v+cjKX/Y2Pm/1qla/97Wkr/75Rr/97vrf+c763/3s5r/85a7/9a + zmv/3s4p/85arf9azin/hBlr/xCUa/+czmv/zhnv/xnOa/+czin/zhmt/xnOKf8Za5T/zhlr/4QZKf8Z + KZT/zhkp/++USv/e74z/nO+M/97OSv/OWs7/Ws5K/97OCP/OWoz/Ws4I/4QZSv8QlEr/nM5K/84Zzv8Z + zkr/nM4I/84ZjP8Zzgj/GUqU/84ZSv+EGQj/GQiU/84ZCP9jhGv/nKWl/5R7c/9aEBD/Wq2M/1prjP/e + zs7/e2tr/5xaSv8IY97/nFpr/2OESv+chFL/Wozv/97v7/9ajM7/75yt/1Ipa/8pOub/GSlr/1IpQv8p + EOb/GSlC/85aa/+EWin/WimU/85aKf+cpVL/WkqU/++cjP9SCGv/CDrm/xkIa/9SCEL/CBDm/xkIQv/O + Wkr/hFoI/1oIlP/OWgj/Ukpr/1JKQv9aOtb/GUpr/1oQ1v8ZSkL/3sWt/5zFrf+crc7/WoyM/1qMrf+c + 787/nM7O/xmM7//e787/Ws6t/5zv7/+Ua4z/Wq2t/1qt7//FlGv/3q3O/xmMrf8ZjM7/3u9r/+9a7/9a + 72v/Wu/v/5Rr7/9a763/3u8p/+9arf9a7yn/WqUp/96lKf/ere//lGut/6UZa/8xlGv/nO9r/+8Z7/8Z + 72v/nO8p/+8Zrf8Z7yn/Ga2t/xmt7/+cre//Ge+t/5Qprf8Z7+//lCnv/xmlKf+cpSn/GWu1/+8Za/+l + GSn/GSm1/+8ZKf9arc7/Ga3O/1rvjP8ZrYz/Wu/O/5Rrzv9apQj/3qUI/xnvjP+UKYz/Ge/O/5Qpzv8Z + pQj/nKUI/97O7//exYz/nMWM/5yMzv+czu//lEqM/8WUSv/ejM7/3u9K/+9azv9a70r/Ws7v/5RK7//e + 7wj/71qM/1rvCP9ahCn/3oQp/96M7/+USq3/pRlK/zGUSv+c70r/7xnO/xnvSv+c7wj/7xmM/xnvCP+c + jO//Gc6t/5QIrf8Zzu//lAjv/xmEKf+chCn/GUq1/+8ZSv+lGQj/GQi1/+8ZCP9azoz/GYyM/1rOzv+U + Ss7/WoQI/96ECP8Zzoz/lAiM/xnOzv+UCM7/GYQI/5yECP/FnK3/QmMQ/whjEP9COhD/CDoQ/ylj3v/F + nIz/Umu1/1JrY/+UnHP/71pr/6VaKf9aKbX/71op/2OlSv9aSrX/71pK/6VaCP9aCLX/71oI/4yEhP9K + a0L/Wjr3/xlra/9aEPf/GWtC/5yljP9jYxD/KWMQ/2M6EP8pOhD/e1Jr/wgQGf+cjIz/EGP//wgQAP8p + Y///CAAA/wAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v7+/vwAAP4A + AAD+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7+/v4BAQEBAQFBAQFBAfz+/gAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAf7+/gAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAPz+QQEBAQFBAQFBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP4BAQEB + AUEBAQEBAQEBAQEBAQEBAUEBAQH+/gAAAAAAAAAAAAAAAAAAAAAA/v7+/gEBAQEBAQEBQUNkNWTZZGSL + QQEBAQEBQQEB/gAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBQWY18/P6NfM1NTVj2WRvAQEBAQEBAf78 + /gAAAAAAAAAAAAAAAAD+/vwBAQEBAQFm8+367frt7e3t+vrz2WNiZEEBAQEBAQEAAAAAAAAAAAAAAAAA + AAAA/gEBAQEBQe3t7e07Ozs7NDY27eL68/M12TpvAQEBQQEB/P4AAAAAAAAAAAAAAP78AQEBAQFD7e07 + Ozs7NDs7Ozs7Ozvt7e36NTViiwEBAQEB/gAAAAAAAAAAAAAAAAABAQEBAUPtOzs7OzvhOzsHOzs7Ozs7 + Nu3t8zU1YpcBAQEBAfz+AAAAAAAAAAAA/v4BAQEBAe47NAfhOwc7BzsHOwc7Owc7Ozs27frz2WVDAQEB + AQAAAAAAAAAAAAAAAAEBQQEBOeE0Ozs7Owc7BzsHOwcHBwc7Ozs77e368zTzAQEBAQH8AAAAAAAAAAAA + /gEBAQFDO+E0OzsHOzsHOwcHPDs7OwcHOwc7OzbtZeHziwEBAQEAAAAAAAAAAAAAAAEBAQFlO+E0NDs7 + Owc7PAf6NTU2Nfo2Bwc7OzvtNDQ12UEBAQEBAAAAAAAAAAAAQQEBAQM7OzQ/BjQ2+vo18zbfY9k2+jU1 + Ne02OzsGBjQ1NWQBAUEB/gAAAAAAAAAAAQEBAWY7Ozs0Bm41NTY2+vo1YmQ2QAc2+jX67TgGNDT6NWQB + AQEBAf7+AAAAAAD8AQEBATk0Ozs0NKdjNdnzNjw1Y2L62TXtPDvtNWsGNO36NdkBAQEBAQAAAAAAAAAA + AQEBATs7O+07NAY4NWNiZN/ZOmQ2NWPZNfM1a/MGOzvt8zVBAQEBAfz+/gAAAAD+AQEBATQ77Ts2O+c0 + Bvo22fM1OmL6PEA2Nu3zBgY/Ozvt+vNBAUEBAQEAAAAAAAAAAQEBQTvtO+02Nj804uLiQD5iOmjfNmJk + 3+0GBjQ7Ozvt7TVBAQEBAQH8/gAAAAD+AQEBATs0Nu02Njs/PzTi30A6OjrfNjpoQuLnND87Ozs77TVD + AQEBAQEBAAAAAAAAAQFBATbtNu027eJAPzTi4nA6Qjrf+jpCZwY0Pzs7OzTt7TVBAQEBQQEB/AAAAAD+ + AQEBATnt7e02+vr6QD80NN9qQqXf80JnaOLnOzs7Ozs07QRBAQEBAQEBAAAAAAAAAQEBAe3t7e36+vPf + +j8/4uI6QkJiYkJoY+c7Ozs7Ozs77TUBAQEBAQEBAfwAAAD8AQEBAeDt7e36+vPf2eI/PzRCQkJiOmdo + OD82NjY7Ozvt7WYBQQEBAUEBAf4AAAAAAQEBQQE27e3689nfYmI2P+JqQmxCQmfiPzY2Ozs7NDvt7UEB + AQEBAQEBAQH8/gAA/gEBAQFm7fr6+vPZY2JiO/NoZ2hoY2M/NjY27e07OzQ7BAEBAQEBAQEBAQEAAAAA + AAEBAQFB7e368zXf2WI6p/NrOOI4OPPz7e027Ts77TvtQQEBQQEBQQEBQQEB/gAAAP4BAQEBZu36+jXf + 2WLZ8zjiBgbiBjg47Tbt7TvtOzTtAQEBAQEBAQEBAQEBAAAAAAABAQEBQWb6+jU1NfM4OAYGBjQGBgY4 + OPPt7TY77TlBAQEBAQEBAQEBAQEB/P4AAAD8AQEBAQHt7fME8zg4OAYGBjQ0BjgGOAY47TntO0MBQQEB + AUEBAUEBAQEBAQAAAAAAAQEBAUEBBO3iBjgGBgY07fPtNAYGBjg4Bjs7QwEBAQEBAQEBAQEBAQFBAf4A + AAAA/gEBAQEBAc40BgYGNO018zX68+00NIIGBoJBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAABAQEBQQFD + ZTT6+vME+vr6+u367TQ04AEBQQEBQQEBQQEBQQEBQQEBAfwAAAAAAAD+AQEBAQEBAUNmBO36+vr67frt + 7UNBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAAAAAAAAAEBAQEBQQEBQUFDQ0NDQ0EBAQEBAQEBAQEBAQEB + AQEBAQEBAQEBAf4AAAAAAAAAAP4BAQEBAQEBAQFBAQFBAQFBAQFBAQFBAQFBAQFBAQFBAQFBAQEBAQAA + AAAAAAAAAAAAAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB/gAAAAAAAAAAAAAAAAAA + AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEBAQEB + AQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////8AAP///////wAA////////AAD/ + //////8AAP//4////wAA//wAH///AAD/8AAD//8AAP/AAAH//wAA/4AAAH//AAD/AAAAP/8AAP4AAAAf + /wAA/AAAAA//AAD4AAAAD/8AAPAAAAAH/wAA8AAAAAP/AADgAAAAA/8AAOAAAAAB/wAAwAAAAAH/AADA + AAAAAf8AAMAAAAAA/wAAwAAAAAD/AACAAAAAAH8AAIAAAAAAfwAAgAAAAAB/AACAAAAAAD8AAIAAAAAA + PwAAgAAAAAAfAADAAAAAAB8AAMAAAAAAHwAAwAAAAAAPAADAAAAAAA8AAOAAAAAABwAA4AAAAAAHAADw + AAAAAAMAAPgAAAAAAwAA+AAAAAADAAD8AAAAAAEAAP4AAAAAAQAA/wAAAAABAAD/gAAAAAMAAP/gAAAA + AwAA//gAAAAHAAD//wAAAB8AAP///////wAA////////AAD///////8AAP///////wAA////////AAAo + AAAAIAAAAEAAAAABACAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff3hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKnH+Ei59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//8u + ff//Ln3//56qw/+8t7X/wr68/2OW6v8uff//Ln3//y59//8uff//Ln3//y58/ecAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8u + ff//nZqZ/5iTk/+WkJH/lpGQ/5qUk/+dmZb/p6Og/7Otq/+/urn/jKzi/y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8u + ff//kJGZ/4uGhv+HgID/gnx6/4J5eP+DeXj/hn16/4qCgP+PiIb/lo+O/6Kdmv+0rqz/xsHA/y59//8u + ff//Ln3//y5+//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8u + ff//Ln3//4uHh/+Aenr/eXFx/3Zsav91amf/dmll/3dpZP95a2b/e21p/4Bzb/+Ge3j/j4aE/5mSkP+r + pqT/v7u5/y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + fv2lLn3//y59//8+Wkn/eHJy/3JqaP9xZ2P/cmVg/3RkXf91Y1r/dmJa/3djWf94ZFv/eWZf/3xsZv+B + dHD/ioB9/5WOjf+no6D/wL27/y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//Ln3//0VvVP9xamj/cmhk/3VmYP94ZV3/emNZ/3thVv97YFP/e19S/3pfUv95 + YFX/eWNa/3poYf9+cWv/iH57/5WPjf9OgmH/xsHB/y59//8uff//LXz+TgAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAfb/8QLn3//y59//90cHD/bGtm/1iVbf93aWT/fGlh/4BnXf+BZVj/gmJT/4dsYf+j + o6T/f1xO/5qXmf97X1P/emNY/3lnYP9+cW3/ioJ//1CHY/+yraz/Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//3Brav91bGv/W5Bl/2CqgP+bmpz/pKOl/6urrP+w + r7H/srK0/7Kxsv+GXkr/qKeo/6Cfof+Xlpn/gnZy/3loYv9do3f/UH1b/6Ccmv/AvLv/Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//9Jd8T/dG1t/3xzcP9Ve1b/d8ah/6Gmpv+t + rK7/j2hV/5BmUP+8u73/u7u8/4xgS/+rpaP/hV9N/39eUf+Tk5X/cs6x/1+aav+De3j/lpCQ/7Csq/8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//3Ftbf96c3L/gnd1/4d3cf9l + lGD/aZt0/7Kur/+/vr//wsLD/8TDxP/BwML/kWNM/7u6vP+ysbP/pqWn/5rg0/9koXP/WYZd/310cf+N + h4b/o6Cf/y59//8uff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//c25v/394d/+G + e3f/i3x0/196Uf9rk2D/eJd1/51zXP+hdFv/zc3N/8nJyf+XaVH/v7/A/7i3uf+lpo//aJx0/2aYYv93 + aGP/enBt/4eAgP+bmJj/Ln3//y59//8uff//LHz95QAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//93 + cnP/gnt6/4l+e/+QgHn/l4F2/2qEUv9ujWD/k5d6/66AaP/e3d3/1tTV/51wV//DwsT/4fT0/26Wdf9q + lmH/XXpR/3hqZP93bmv/gXt6/5iUlP8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//3l0dv+EfXz/jIJ+/5SFgP+fin//lXpr/26JU/9vjGP/qpuA/+3t7f/l5OT/qHph/+v39/+r + 5t3/cpxz/2aDVP+AbGT/emxn/3dua/9/eXn/lZKS/y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//QXzb/4eBgP+OhYP/mYuF/6aUiv+7oJP/ZnVI/3CKVv9wjmn/+vn6/+3u7v/R + pY7/u+rl/5DXwP9sjlf/jHRq/4Jwaf98b2z/eHBu/395ev+Wk5T/Ln3//y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAALn3//y59//8uff//hYCB/46Hhv+bj4r/rJqT/8Gqn//bwbL/aX5O/26NW//l + 9vT/zfDt/93z8f/n9PP/gryT/4x0Zv+NeW//g3Vw/3xxbv94cW//f3t8/5mWlv8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//+GgoP/joiI/5qRjv+pnZb/vaui/9S/s//l + zL7/bIhX/6nl3f+I2sj/dqiP/5ixm/9lelL/kn50/419dv+DeHT/fHRy/3hzcv+DgIH/Ln3//y59//8u + ff//Ln3//y59//8uff//Ln7//wAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//+Lhob/lY+O/6Sblv+1 + pqD/xrWs/9PAtf9mq43/ZaN8/2eca/9moHT/YqqG/2qylv+Sg3z/jYF8/4N6ef97dXT/eXR1/42KjP8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//zJ/+P+P + i4v/m5WR/6mgnP+2qKP/Xq+H/2Gpe/9jo2//YpZh/2OgaP9hp3b/Xq2B/120jf+NhIH/gnt7/3p1dv99 + env/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8tff3FAAAAAAAAAAAAAAAAAAAAAC5+//8u + ff//Ln3//1KB0P+Tjo7/c5p//12wfP9eq3X/XqJs/1qQZP+rn5n/dXZr/1uYZ/9cqHH/Xq97/1iqef9/ + env/end5/y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//Ln3//y59//9RjGX/VZVr/1KLYv+lnpv/n5mV/5yWkv+ZkZD/lY+M/2J/af9S + kGf/UpRq/02GY/8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//wAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//9chMf/k4+P/5WQkf+VkJH/lI+Q/5OOjv+Q + jIz/jIiI/4J/f/8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACx+/d4uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC1+/ewuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8uff//LXz+cQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////// + ///////////AP///AA///AAD//gAAf/wAAD/4AAA/8AAAH/AAAB/wAAAP4AAAD+AAAAfgAAAH4AAAA+A + AAAPgAAAD4AAAAeAAAAHwAAAA8AAAAPgAAAB4AAAAfAAAAH4AAAB/AAAAf8AAAP/4AAP//////////// + ////KAAAACAAAABAAAAAAQAIAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8pc/f/WkoZ/5yMjP9a + axn/EBkh/4xza/9ajGv/lFJr/85aa/9aEO//zlop/84Za/8ZEO//zhkp/xlrSv8ZKUr/zlpK/1oQzv/O + Wgj/zhlK/xkQzv/OGQj/GUpK/xkISv+cra3/nIxr/1prSv+Ua0r/a2Pv/1opSv8pShn/WkpK/2tjzv9a + CEr/CEoZ/xlS1v9jGQj/OhkI/1qtjP9ajO//Wq1r/1qMzv/ezs7/3q2t/5ytjP9aa4z/Woyt/97v7/9a + jEr/Wmut/97vzv8ZjO//Wmtr/5ytzv+cjK3/WoyM/5yMzv+czs7/Wq3v/1qtrf/erYz/nO/O/5zOrf/e + 72v/71pr/95r7/9a7+//Wu9r/97vrf9a7yn/Wu+t/97vKf/ea63/WjHv/+9aKf+Uayn/3q3v/96ta/9a + Ka3/3inv/1qtKf/erSn/3imt/+8Za/8ZMe//7xkp/5Qpa/8ZrWv/Ga3v/5yta/8Zra3/nO/v/xlrrf8Z + a2v/nK3v/5zvrf+c72v/nGvv/xnv7/8Z72v/Ge8p/xnvrf+c7yn/nGut/5QpKf8ZKa3/nCnv/xmtKf+c + rSn/nCmt/xkpa/9arUr/Wq3O/5ytSv8Zrc7/nO+M/97vSv/ea87/Wu/O/1rvSv/e74z/Wu8I/1rvjP/e + 7wj/3muM/5RrCP/erc7/3q1K/1opjP/eKc7/Wq0I/96tCP/eKYz/lClK/xmtSv8ZrYz/GWuM/5zvSv+c + a87/Ge/O/xnvSv8Z7wj/Ge+M/5zvCP+ca4z/lCkI/xkpjP+cKc7/Ga0I/5ytCP+cKYz/lEpK/96Mrf9a + Soz/3s7v/1pKrf/ejIz/3s5r/+9aSv/eSu//Ws7v/1rOa//ezq3/Ws4p/1rOrf/ezin/3kqt/1oxzv/v + Wgj/lEop/96M7//ejGv/Wgit/94I7/9ajCn/3owp/94Irf/vGUr/GTHO/+8ZCP+UCGv/GYxr/xmMrf+c + zu//GUqt/xlKa/+cjO//nM5r/5xK7/8Zzu//Gc5r/xnOKf8Zzq3/nM4p/5xKrf+UCCn/GQit/5wI7/8Z + jCn/nIwp/5wIrf8ZCGv/nIxK/xmMzv+czoz/3s5K/95Kzv9azs7/Ws5K/97OjP9azgj/Ws6M/97OCP/e + Soz/lEoI/96Mzv/ejEr/WgiM/94Izv9ajAj/3owI/94IjP+UCEr/GYxK/xmMjP8ZSoz/nM5K/5xKzv8Z + zs7/Gc5K/xnOCP8Zzoz/nM4I/5xKjP+UCAj/GQiM/5wIzv8ZjAj/nIwI/5wIjP9CY+//QmPO/1opa/8p + axn/Wkpr/1oIa/8Iaxn/GXPW/2MZKf86GSn/GVr3/xAZAP8Qc/f/EAAA/wAAAP8AAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8AP4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+ + /AAAATQBAQD8AAAAAAAAAAAAAAAAAAAAAAAAAAAAADQBNAEoAQEoNAEBAfwAAAAAAAAAAAAAAAAAAAAA + /AEoAQEBAQEBAQEBKDQBAfwAAAAAAAAAAAAAAAAAAAABAQE0ASgocXE2KigBAQEBAQEAAAAAAAAAAAAA + AAD+NAEBASgvNwM3AzcZGSw7KAE0KAEAAAAAAAAAAAAAAAE0KAEqAwYGBgYGBgMDGRk2KAEBAQH8AAAA + AAAAAAAoAQEBLwY1BgY1BgYGNQYDAxksOwE0AQAAAAAAAAAAAAE0ATIGBjUIGwYgBhsGBgYGAxkZ8QEB + KAAAAAAAAAAoAQEqGzU1HDUgBhsc9Rz1BgYGAwcZAQEBAAAAAAAAAAEBATg1BwYGBhwGBgMDBgYbBgY4 + NRkoATQB/AAAAAD8AQHyNTUHBwMDAwMsGRoaGQMGBikHGTYoAQEAAAAAAAEBNCoGBgcnPwMaBiwZAwMG + BgOlKQYDGQEBAfwAAAAAAQEBMjgGBgYnGSwZGSsDnRkDGSkHNQMZKDQBAQAAAAABASgvBgYGBwcaGhos + Kxo3LQMpBwY1AwMoAQEB/AAAADQBATIGAxoGMQcaGisrGhkzLXAGNQYGGSg0AQEBAAAAAQEBLwYDBgMa + ywctKzCdM7gnBjUGNQYtAQEoNAEAAAD8Af0qNQMDAy0GywcwMCwzPikGBgYuBjcBAQEoAQEAAAABASgD + AwMtGSwxBzMwuDMnBgYGNQYGKjQBNAE0AfwAACgBAS8DA50ZoywtOj8/GQYGAwYGNQMoKAEBKAEBAAAA + AQE0KAMDLRksLCdaByktJxoGBjgGKgEBAQE0ATQBAAD+AQEBKgMDNy0nJykHByknJwORBjgoAQE0ASgB + KAEAAAAAAQEBKgMnJykpBwMHKSknJwY4KAE0AQEoATQBNAEAAAA0KAE0KgcpBzgZAwMDBwcH4SgBASgB + NAEBASgBAQAAAAABAQEBASo3AwMDAwM4LyoBAQE0AQEBKDQBATQBAAAAAAABNCgBNCgBKCooKAEBKDQB + ASg0AQEBNCgBAQAAAAAAAAAAAQEBAQE0KAE0ASg0AQEoNAEBKDQBAQEB/AAAAAAAAAAAAAEBAQEBAQEB + AQEBAQEBAQEBAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////// + /////8A///8AD//8AAP/+AAB//AAAP/gAAD/wAAAf8AAAH/AAAA/gAAAP4AAAB+AAAAfgAAAD4AAAA+A + AAAPgAAAB4AAAAfAAAADwAAAA+AAAAHgAAAB8AAAAfgAAAH8AAAB/wAAA//gAA////////////////8o + AAAAGAAAADAAAAABACAAAAAAAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//LH39/AAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsev2QLn3//y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//zN/+v+loaD/pKCe/6qmpP+2sK//xMG+/y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn3//y59//8u + ff//jomJ/4mCgv+FfX3/hn17/4qCgP+QiYf/m5aU/7Grqf/GwsD/Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//zF9+f99eHf/dWxr/3RpZv91Z2P/d2di/3lqZf99 + b2r/hXp2/5CIhf+hnJn/v7u5/y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu + ff//Ln3//0txVv9waGX/c2Zh/3ZkXP93Ylj/eGFW/3lhVv94Y1n/eWdg/39zbf+NhIH/n5qX/0FmT/8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//dHBw/0+CXP92aWX/e2hf/35lWv+A + YlT/gF1Q/5+fof+Ebmb/emBV/3llXf9+cGv/joaE/0dyVP8yf/3/Ln3//wAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAC59//8uff//cWtq/1NzWf9hpHn/n56g/6mpq/+wsLH/tLS0/7Gxsv+DXEv/oJ+h/5OSlf94 + ZmH/XJ5x/5ONi/+3srH/Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAC59//8ugP//eXJw/4N2cv9k + mGT/kd3M/7e2uP+olY3/wL/A/729vv+5ubr/rKyt/4BlWv93z7L/WIZd/4iBf/+joJ//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAC59//9tbnX/gHl4/4h6dv9fd1L/a5Rm/6mchP+ecVr/ysrK/8XFxv+g + hHj/moJ4/4Gjhv9nnGj/d2lk/393df+ZlZT/Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAC59//9v + cnr/hH17/46Ae/+Xgnj/a4RR/2+PZv+9nYT/4N7f/9PS0v/Fxcb/1fDv/2uUZ/9ee1H/eWtm/3tzcv+T + kI//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAC59//8ufv//h4CA/5KGgv+gjoT/uJyN/3CJU/98 + kG7/+/n6/+Hh4f/g9fP/kNrH/2mJVf+Db2b/em1p/3pycf+Rjo3/Ln3//y59//8uff//AAAAAAAAAAAA + AAAAAAAAAC59//8uff//hoGB/5WLiP+ml4//xK2g/31oVP9vi1j/6vb2/9Ty8P/r9vX/h8ad/5B4bP+F + dm//e3Fu/3lzc/+UkJH/Ln3//y59//8uff//Ln3//wAAAAAAAAAAAAAAAC59//8uff//hoKD/5KLif+l + mpX/v66l/97Iu/9ke0//ld7S/2ebeP+GrJP/tqCT/5B+eP+Genb/e3Nz/3t2d/8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAuff//Ln3//42Iif+clpL/sqWg/8Gyqv9hq4b/ZaJy/2WeZv9i + pnr/XbCO/4+DgP+EfXv/e3Z2/4SBgv8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAs + fv36Ln3//y59//+SjY3/jZaJ/12uff9fqHH/WZBi/5OIgv9enGj/Xqt1/12yf/+BfHz/enh5/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAALn3//y59//8uff//UItk/1CLZP+c + l5T/nJeT/5qSkf+Vjo7/fXl3/1GPZv9Mg2H/Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAAAAAAAAAAAC59//8uff//Ln3//y59//+QjI7/ko6O/5GOjf+Oioz/Sn7U/y59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAALn3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//y59//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALn/94i59//8u + ff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAA////AP///wD/B/8A+AH/APAAfwDgAD8AwAA/AMAAHwCAAB8AgAAPAIAADwCAAAcAgAAHAIAABwCA + AAMAgAADAMAAAQDAAAEA4AABAPAAAQD8AAEA/4AHAP///wD///8AKAAAABgAAAAwAAAAAQAIAAAAAACA + BAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8ue///Ln7//y59//8ufP//L33+/0mC4f9nh8H/doqw/3mKqv9w + h7H/WYHF/zp97f81fuL/ToyH/2mSdf+GkoX/npeU/5qTkf+RjYr/c4p4/16PcP9DhaH/MX33/0eA3/+O + jpL/f5+H/1+tff9eo3H/bpdx/4GQev9hmWz/Xah2/2Grf/93hXr/bnmR/zV99f88fuz/iomQ/56Wk/+y + pqD/o7Gg/2arhv9lonP/ZZ1p/2One/9pqYr/iomB/4V9e/97dnb/bH6h/3CCpP+TjIr/ppuV/8Cupf/Z + wrb/kZ6C/5HLuP98up7/irSc/4eIcv+Qf3f/hnt2/3t0c/9+eXr/ToLa/zx96f+HgoL/lYuI/6iYkP/E + rKD/m5Z3/3OOX//f7Oj/zuXg/8nh1/99rIT/h3pp/4Z2b/97cW7/e3V0/3eJq/9Qe8b/h4B//5OHgv+i + j4X/nY13/2+HVv+FknD/6enm/9jKw//M0Mb/mdvI/2+JXv+BcGb/em5q/3pzcv+QjpH/Mn78/1d5tf+E + fXv/joF7/5SBdf9whFf/eZFp/6yPdf/a1NH/xbew/7mqo//B4t3/b5lu/218XP95a2b/fHRy/5SQkP9C + hPH/VXay/4B4d/+Ie3b/dX9i/22Vaf+Xj3f/rI19/8XAvv+4qqT/o4V4/6STiv+BmX7/ZZho/3FyZP+b + l5b/RYbx/0t2wP95cnH/fHZu/2eabv+NtaT/sKqo/6WNgf+6tLP/sKOd/7Krqf+ekIr/k46J/3m+ov9k + jGn/iYGA/6aiov83gfr/PHrj/3JsbP9lemT/bJ58/5aSj/+ai4X/oJCJ/6+qqf+lmZX/lX91/5iQjv+O + iIj/fYB4/12ZcP+Fi4L/m6a9/2dyjP9YgGL/c3Fn/3xpYf9/Zlr/gWNU/415cP+Pfnf/jH13/35oXv96 + Zl7/f3Jt/3iMe/92j3z/bpnj/0J83v9dcGP/cmln/3RmYv92ZV3/eGNZ/3lhVv95Y1r/e2lh/4Fzb/+N + hIL/op2a/2iIkP8zf/3/UX7I/395ef94b23/dmtn/3ZpZP94aWP/emtm/39xbP+Ge3f/komH/6Wfnf+y + tL//RIf0/0+C2f+GiJL/iIKB/4Z+ff+Hf33/i4OB/5KLiP+emJb/sKup/6Cvzf9Ch/j/NX/5/2GL0/+E + lbX/m56o/6alqf+jqbj/jqXQ/12T7f8vff//Ln///wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAACAwMDAwMDA+MAAAAAAAAAAAAAAAAAAgMDAwMDAwMDAwMDAwAAAAAAAAAA + AAACAwPa29zd3t/g4eIDAwIAAAAAAAAAAAIDA8/Q0dLT1NXW19jZAwMEAAAAAAAAAgMDwsPExcbHyMnK + y8zNzgMDAAAAAAAAAwO0tba3uLm6uru8vb6/wMEDAgAAAAAAAwOlpqeoqaqrrK2ur7CxsrMDAwAAAAAC + A5WWl5iZmpucnZ6foKGio6QDAwQAAAADA4SFhoeIiYqLjI2Oj5CRkpOUAwMAAAADA3R1dnd4eXp7fH1+ + f4CBdYKDAwMAAAADA2NkZWZnaGlqa2xtbm9wcXJzAwMCAAACA1JTVFVWV1hZWltcXV5fYGFiAwMDAAAC + A0JDREVGR0hJSktMTU5PUFEDAwMDAgAAAwMzNDU2Nzg5Ojs8PT4/QEEDAwMDAwAAAwMlJicoKSorLC0u + LzAxMgMDAwMDAwAAAAMDGBkaGxwdHh8gISIjJAMDAwMDAwIAAAIDAw0ODxAREhMUFRYXAwMDAwMDAwIA + AAACAwMFBgcICQoLDAMDAwMDAwMDAwIAAAAAAgMDAwMDAwMDAwMDAwMDAwMDAwQAAAAAAAABAgMDAwMD + AwMDAwMDAwMDAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/ + //8A////AP8H/wD4Af8A8AB/AOAAPwDAAD8AwAAfAIAAHwCAAA8AgAAPAIAABwCAAAcAgAAHAIAAAwCA + AAMAwAABAMAAAQDgAAEA8AABAPwAAQD/gAcA////AP///wAoAAAAEAAAACAAAAABACAAAAAAAAAIAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC59/bstfP57AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8u + ff//JH/+DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//5OOjf+MhoX/jYaF/5aPjv+r + pqP/zMfH/y59//8uff//AAAAAAAAAAAAAAAAAAAAAAAAAAAuff//Ln3//3p0df9yaGX/dGVf/3ZlXv95 + amP/g3d0/5aPjv+/urn/Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAALn3//3Nvb/9zaGX/emdf/31jVf9+ + X1D/fF5Q/3liWP9+cWz/hpGG/8vJyP8uff//AAAAAAAAAAAAAAAAAAAAAC59//90bWz/YJts/6Skpf+w + rq//t7e4/4hfSv+gn6H/jYyP/1aMYv+npKH/Ln3//wAAAAAAAAAAAAAAAC59//8uff//gnl3/39uZf9t + mXf/xcTE/8bFx/+TZU3/iWJR/2afdP93bGf/lZCQ/y59//8uff//AAAAAAAAAAAufv//Ln3//4d+ff+W + hHz/bIhT/52YfP/j4uL/m21X/5/i1v9gflH/d2tn/4uGhf8uff//Ln3//wAAAAAAAAAAAAAAAC59//+K + g4H/oJKK/8qwof9wi1j/7/j4/9CvoP99s4b/iHVt/3lvbf+Kh4j/Ln3//y59//8sff5+AAAAAAAAAAAu + ff//iISF/5+Wkv/Esqr/5MzA/2aee/9npYb/lYB4/4p+ef95c3P/Nn/2/y59//8uff//Ln3//wAAAAAA + AAAALn3+aC59//+SjY3/pp6Z/1+reP9dkmP/YKBo/16ufv+Gf3//e3h5/y59//8uff//Ln3//y59//8A + AAAAAAAAAAAAAAAuff//Ln3//02HZP+Zk5P/mpST/5SOjv+NiYj/Q4GP/y59//8uff//Ln3//y59//8u + ff//Ln///wAAAAAAAAAAAAAAAAAAAAAuff//Ln3//y59//8uff//Ln3//y59//8uff//Ln3//y59//8u + ff//Ln3//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAP//AAD9/wAA4D8AAMAPAACADwAAgAcAAIAHAAAAAwAAAAMAAIADAACA + AQAAwAEAAMAAAADwAQAA//8AAP//AAAoAAAAEAAAACAAAAABAAgAAAAAAAACAAAAAAAAAAAAAAAAAAAA + AAAAAAAA/y5+//8uff//MX78/z2A7v87f+//L33+/zF98v9Miab/gpCK/5qUkv+Tjo3/b4iE/0KFtP8v + ffv/OH7z/4aMnf+HpY3/YKh5/3GZcv9nmm//Yap+/3mLfP9oep3/MH39/3GDp/+glpL/xLKp/56slP9+ + uZv/erCR/4aMev+JfXj/e3V0/1eAx/87fer/ioSC/6KTjP+zoY7/doxf/9/t6v/M2M7/gKeF/4Z1a/96 + cW7/foSV/0h70P+Hf33/loR7/3aHXf+WkXL/3trY/72so/+gy7j/cH9e/3ltaf+MiIf/OIH4/0Z4zf+A + eHX/eIBn/4Ceff+umIz/w7++/6iQhf+hmZH/caaB/3N3af+WkZD/PIL3/zp65v91b23/Z5Vz/5qcl/+d + iH//s6+v/52Jgf+ShX//go6G/2aPcf+doKn/L33//1t1if9rdWb/emdf/35jV/+JdGv/hXFp/3xnXv+A + c27/c4p3/2+Vz/8vfv//NXrl/3d3gP91a2j/dmdh/3hnYP98bGX/hXl1/5qSkP+WpLv/MH34/z1/7v92 + h6j/jYeG/4+Ihv+YkY//qaWm/4ai1P83gfz/Lnz//z2C9f9Ui+j/VI3s/zmC+/8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8A + AAD/AAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAQICAgIBAAAAAAAAAAABAgJwcXJzAgIBAAAAAAABAmdo + aWprbG1uAm8AAAAAAl1eX2BhYmNkZWYCAAAAAgJSU1RVVldYWVpbAlwAAAJGR0hJSktMTU5PUFECAAAC + Ojs8PT4/QEFCQ0RFAgAAAi4vMDEyMzQ1Njc4OQICAAIjJCUmJygpKissLQICAgABAhkaGxwdHh8gISIC + AgIBAAIPEBESExQVFhcYAgICAgABAgcICQoLDA0OAgICAgIAAAECAgMEBQYCAgICAgICAAAAAAECAgIC + AgICAgICAAAAAAAAAAAAAAAAAAAAAAD//wAA/f8AAOA/AADADwAAgA8AAIAHAACABwAAAAMAAAADAACA + AwAAgAEAAMABAADAAAAA8AEAAP//AAD//wAA + + + \ No newline at end of file diff --git a/VTFXUtil/Formats.cs b/VTFXUtil/Formats.cs new file mode 100644 index 0000000..4d62fec --- /dev/null +++ b/VTFXUtil/Formats.cs @@ -0,0 +1,50 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace VTFXUtil +{ + // format handling/construction type things should go here from now on + public class Formats + { + public class VTFFile + { + public readonly byte[] Magic = { 0x56, 0x54, 0x46, 0x00 }; + public byte[] FileVersion = new byte[8]; + public int HeaderLength; // may vary upon how many resources the image contains, but a 7.3 header has a length of 0x50 when resource info is stripped + public int Width; + public int Height; + public byte[] Flags = new byte[4]; + public int Frames; + public int FirstFrame = 0; // will usually be zero, so it should be fine to hardcode it here + // 4 bytes of padding + public byte[] ReflectivityVector = new byte[12]; // contains three 4 byte floats + // another 4 bytes of padding + public float BumpScale; // single float + public byte[] Format = new byte[4]; + public int MipmapCount; // 8-bit integer + public byte[] ThumbFormat = new byte[4]; + public int ThumbWidth; + public int ThumbHeight; + public int ImageDepth; // all 3 of these are also 8-bit integers, depth will only apply to 7.2 and above + // another 4 bytes of padding + public int ResourceCount; // will only apply to 7.3 and above + // 8 bytes of padding + public List Resources = new List(); // also only applies to 7.3 and above + + public bool CheckMagic(byte[] Magic) + { + if (Magic.Equals(this.Magic)) + { + return true; + } + else + { + return false; + } + } + } + } +} diff --git a/VTFXUtil/ImageImportProperties.cs b/VTFXUtil/ImageImportProperties.cs new file mode 100644 index 0000000..be687f6 --- /dev/null +++ b/VTFXUtil/ImageImportProperties.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace VTFXUtil +{ + public class ImageImportProperties + { + public string OutAlphaFmt; + public string OutNoAlphaFmt; + public string OutTexType; + public bool DemandedResize; + public bool DemandedClamps; + public bool CanGenerateMips; + public string Ree; + public int ClampingWidth; + public int ClampingHeight; + public string Platform; + + public ImageImportProperties(string Alphafmt, string Regfmt, string Textype, bool Resizetrig, bool Clampable, bool Genmips, string Resmethod, int Clampwidth, int Clampheight, string Plat) + { + OutAlphaFmt = Alphafmt; + OutNoAlphaFmt = Regfmt; + OutTexType = Textype; + DemandedResize = Resizetrig; + DemandedClamps = Clampable; + CanGenerateMips = Genmips; + Ree = Resmethod; + ClampingWidth = Clampwidth; + ClampingHeight = Clampheight; + Platform = Plat; + } + } +} diff --git a/VTFXUtil/ImageImporter.cs b/VTFXUtil/ImageImporter.cs new file mode 100644 index 0000000..ac27bed --- /dev/null +++ b/VTFXUtil/ImageImporter.cs @@ -0,0 +1,292 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +// image importing methods will be left up to this thing, as i may have cluttered the fuck out of Form1.cs + +namespace VTFXUtil +{ /// +/// Handles methods for general texture import/export/manipulation uses. +/// + class ImageImporter + { + + /// + /// Decompresses LZMA compressed files. Primarily used on Xbox 360 textures. + /// + /// + /// + /// + /// + public static byte[] LZMADecompress(byte[] inData, string inPath, string outPath) + { + System.IO.FileStream TempLZMAIn = new System.IO.FileStream(inPath, System.IO.FileMode.Create); + TempLZMAIn.Write(inData, 0, inData.Length); + TempLZMAIn.Close(); + TempLZMAIn = new System.IO.FileStream(inPath, System.IO.FileMode.Open); + System.IO.FileStream TempLZMAOut = new System.IO.FileStream(outPath, System.IO.FileMode.Create); + byte[] HeaderBytes = new byte[4]; + byte[] UncompressedSizeBytes = new byte[4]; + byte[] CompressedSizeBytes = new byte[4]; + byte[] DecoderProperties = new byte[5]; + TempLZMAIn.Read(HeaderBytes, 0, 4); + TempLZMAIn.Read(UncompressedSizeBytes, 0, 4); + TempLZMAIn.Read(CompressedSizeBytes, 0, 4); + TempLZMAIn.Read(DecoderProperties, 0, 5); + int UncompressedSize = System.BitConverter.ToInt32(UncompressedSizeBytes, 0); + int CompressedSize = System.BitConverter.ToInt32(CompressedSizeBytes, 0); + SevenZip.Compression.LZMA.Decoder LZMADec = new SevenZip.Compression.LZMA.Decoder(); + LZMADec.SetDecoderProperties(DecoderProperties); + LZMADec.Code(TempLZMAIn, TempLZMAOut, CompressedSize, UncompressedSize, null); + TempLZMAIn.Flush(); + TempLZMAOut.Flush(); + TempLZMAOut.Close(); + TempLZMAOut = new System.IO.FileStream(outPath, System.IO.FileMode.Open, System.IO.FileAccess.Read); + byte[] Texture = new byte[UncompressedSize]; + using (TempLZMAOut) + { + TempLZMAOut.Read(Texture, 0, UncompressedSize); + } + TempLZMAOut.Close(); + TempLZMAIn.Close(); + return Texture; + } + + /// + /// Returns an LZMA compressed version of the input data as a MemoryStream. + /// + /// + /// + public static System.IO.MemoryStream LZMACompress(byte[] InData) + { + SevenZip.CoderPropID[] Properties = { SevenZip.CoderPropID.DictionarySize, SevenZip.CoderPropID.PosStateBits, SevenZip.CoderPropID.LitContextBits, SevenZip.CoderPropID.LitPosBits, SevenZip.CoderPropID.Algorithm, SevenZip.CoderPropID.NumFastBytes, SevenZip.CoderPropID.MatchFinder, SevenZip.CoderPropID.EndMarker }; + object[] Props2 = { (1 << 23), 2, 3, 0, 2, 128, "bt4", false }; // default properties + SevenZip.Compression.LZMA.Encoder LZMAEnc = new SevenZip.Compression.LZMA.Encoder(); + LZMAEnc.SetCoderProperties(Properties, Props2); + System.IO.MemoryStream TempInStream = new System.IO.MemoryStream(); + TempInStream.Write(InData, 0, InData.Length); + TempInStream.Position = 0; + System.IO.MemoryStream TempOutStream = new System.IO.MemoryStream(); + System.IO.MemoryStream CompressedTexture = new System.IO.MemoryStream(); + LZMAEnc.Code(TempInStream, CompressedTexture, -1, -1, null); + long CompressedSize = CompressedTexture.Length; + byte[] LZMAIdent = { 0x4c, 0x5a, 0x4d, 0x41 }; // "LZMA", had to make this a byte array, as you can't copy string values to a stream + TempOutStream.Write(LZMAIdent, 0, 4); + TempOutStream.Write(System.BitConverter.GetBytes(InData.Length), 0, 4); + TempOutStream.Write(System.BitConverter.GetBytes(CompressedSize), 0, 4); + LZMAEnc.WriteCoderProperties(TempOutStream); + TempOutStream.Write(CompressedTexture.ToArray(), 0, CompressedTexture.ToArray().Length); // had to manually append the contents of the texture stream onto the other stream, as apparently resetting the stream screws up with the LZMA coder, which then refuses to properly write the texture + CompressedTexture.Dispose(); // free resources + return TempOutStream; + } + + /// + /// Just a simple endian swap. Nothing more, nothing less. + /// + /// + /// + /// + public static byte[] EndianSwap(byte[] Data, int BufferSize) + { + byte[] ByteBuffer = new byte[BufferSize]; //create bytebuffer for endianswapping + byte[] TextureTemp = new byte[Data.Length]; + for (int i = 0; i < Data.Length; i += ByteBuffer.Length) + { + Array.Copy(Data, i, ByteBuffer, 0, ByteBuffer.Length); + Array.Reverse(ByteBuffer); + Array.Copy(ByteBuffer, 0, TextureTemp, i, ByteBuffer.Length); + } + return TextureTemp; + } + + /// + /// Arranges any Block Compressed texture formats from a format usable by the Xbox 360 into one that a PC can comprehend + /// + /// + /// + /// + public static byte[] RearrangeCompressedTexture(byte[] TexData, int Format) //compressed textures on the 360 need to be endianswapped, yet the PS3 counterparts don't + { + byte[] NewTexData = new byte[TexData.Length]; + int ColorValLen = 0; + int ColorBlendLen = 0; + int AlphaValLen = 0; + if (Format == (int)VTFGeneral.TEXTURE_FORMATS.IMAGE_FORMAT_DXT1) + { + ColorValLen = 2; //will be doubled!!! + ColorBlendLen = 4; + AlphaValLen = 0; + } + else if (Format == (int)VTFGeneral.TEXTURE_FORMATS.IMAGE_FORMAT_DXT3 || Format == (int)VTFGeneral.TEXTURE_FORMATS.IMAGE_FORMAT_DXT5) + { + AlphaValLen = 8; + ColorValLen = 2; //will be doubled!! + ColorBlendLen = 4; + } + else + { + return TexData; + } + int BlockLength = (ColorValLen * 2) + ColorBlendLen + AlphaValLen; + byte[] EditingBlock = new byte[BlockLength]; + for (int i = 0; i < TexData.Length; i += BlockLength) + { + byte[] Color0 = new byte[ColorValLen]; + byte[] Color1 = new byte[ColorValLen]; + byte[] ColorBlendInfo = new byte[ColorBlendLen]; + if (Format == (int)VTFGeneral.TEXTURE_FORMATS.IMAGE_FORMAT_DXT1) + { + Array.Copy(TexData, i, Color0, 0, ColorValLen); + Array.Copy(TexData, i + ColorValLen, Color1, 0, ColorValLen); + Array.Copy(TexData, i + BlockLength - AlphaValLen - ColorBlendLen, ColorBlendInfo, 0, ColorBlendLen); + Array.Reverse(Color0); + Array.Reverse(Color1); // reverse color data, as our endianness is not the same as the Xenon + byte[] DuplicateOfColorLayout = new byte[4]; + Array.Copy(ColorBlendInfo, DuplicateOfColorLayout, 4); + ColorBlendInfo[0] = DuplicateOfColorLayout[1]; + ColorBlendInfo[1] = DuplicateOfColorLayout[0]; + ColorBlendInfo[2] = DuplicateOfColorLayout[3]; + ColorBlendInfo[3] = DuplicateOfColorLayout[2]; // color layout inside of the 4x4 blocks is arranged strangely, as [row 2, row 1, row 3, row 4] + Array.Copy(Color0, 0, EditingBlock, 0, ColorValLen); + Array.Copy(Color1, 0, EditingBlock, ColorValLen, ColorValLen); + Array.Copy(ColorBlendInfo, 0, EditingBlock, ColorValLen * 2, ColorBlendLen); //copy new values into the newly created block + } + else //for formats with alpha + { + byte[] AlphaInfo = new byte[AlphaValLen]; + Array.Copy(TexData, i, AlphaInfo, 0, AlphaValLen); + byte[] NewAlphaInfo = new byte[AlphaValLen]; // make this for reversible alphas + //Array.Reverse(AlphaInfo); + Array.Copy(TexData, i + AlphaValLen, Color0, 0, ColorValLen); + Array.Copy(TexData, i + AlphaValLen + ColorValLen, Color1, 0, ColorValLen); + Array.Copy(TexData, i + AlphaValLen + BlockLength - AlphaValLen - ColorBlendLen, ColorBlendInfo, 0, ColorBlendLen); + if (Format == (int)VTFGeneral.TEXTURE_FORMATS.IMAGE_FORMAT_DXT5) // the 360's DXT5 type files are reversed in an odd kind of way, i personally haven't encountered many DXT3 files, and will have to be added later if i find one + { + for (int k = 1; k < AlphaValLen; k += 2) + { + NewAlphaInfo[k - 1] = AlphaInfo[k]; + NewAlphaInfo[k] = AlphaInfo[k - 1]; + } + AlphaInfo = NewAlphaInfo; + } + Array.Reverse(Color0); + Array.Reverse(Color1); + byte[] DuplicateOfColorLayout = new byte[4]; + Array.Copy(ColorBlendInfo, DuplicateOfColorLayout, 4); + ColorBlendInfo[0] = DuplicateOfColorLayout[1]; + ColorBlendInfo[1] = DuplicateOfColorLayout[0]; + ColorBlendInfo[2] = DuplicateOfColorLayout[3]; + ColorBlendInfo[3] = DuplicateOfColorLayout[2]; // cloned from dxt1 + Array.Copy(AlphaInfo, 0, EditingBlock, 0, AlphaValLen); + Array.Copy(Color0, 0, EditingBlock, AlphaValLen, ColorValLen); + Array.Copy(Color1, 0, EditingBlock, AlphaValLen + ColorValLen, ColorValLen); + Array.Copy(ColorBlendInfo, 0, EditingBlock, AlphaValLen + ColorValLen * 2, ColorBlendLen); + } + Array.Copy(EditingBlock, 0, NewTexData, i, BlockLength); //reconstruct texture data with new stuff + } + return NewTexData; + } + + /// + /// Outputs a MemoryStream with the specified texture data, and reverses the mipmap order, for use in VTF/VTFX or other smallest-mip-first formats. + /// + /// + /// + /// + /// + /// + /// + public static System.IO.MemoryStream ReverseMipsIntoMemoryStream(byte[] TexData, int Width, int Height, int Format, MipMaker.MipMap[] MipList) + { + System.IO.MemoryStream CurrentTexture = new System.IO.MemoryStream(); + List Mips = new List(); + CurrentTexture.Write(TexData, 0, TexData.Length); + CurrentTexture.Position = 0; // reset back to beginning of the stream, we will need this for what comes next + for (int i = 0; i < MipList.Length; i++) + { + byte[] CurrentMip = new byte[MipList[i].TotalBytes]; + CurrentTexture.Read(CurrentMip, 0, MipList[i].TotalBytes); + Mips.Add(CurrentMip); // take the texture data from the stream, and shove it into the list + } + CurrentTexture.Flush(); + CurrentTexture.Dispose(); + Mips.Reverse(); + CurrentTexture = new System.IO.MemoryStream(); + foreach (byte[] Mip in Mips) + { + CurrentTexture.Write(Mip, 0, Mip.Length); + } + return CurrentTexture; + } + + /// + /// Converts and outputs texture data as a TIF file in a MemoryStream. + /// + /// + /// + /// + /// + /// + public static System.IO.MemoryStream GenerateImage(byte[] Texture, int Mipcount, int Format, VTFXHandler.VTFXFile Imported) + { + System.IO.MemoryStream TextureStream = new System.IO.MemoryStream(); + TextureStream.Write(Texture, 0, Texture.Length); + CSharpImageLibrary.ImageEngineFormat ParsedEnum = (CSharpImageLibrary.ImageEngineFormat)Enum.Parse(typeof(VTFGeneral.TEXTURE_FORMATS_INTEROP), Enum.GetName(typeof(VTFGeneral.TEXTURE_FORMATS), Format)); + Console.WriteLine(ParsedEnum); + + CSharpImageLibrary.Headers.DDS_Header newDDSHeader = new CSharpImageLibrary.Headers.DDS_Header(Mipcount, Imported.ImageHeight, Imported.ImageWidth, ParsedEnum, CSharpImageLibrary.Headers.DDS_Header.DXGI_FORMAT.DXGI_FORMAT_UNKNOWN); + byte[] DDSHeader = new byte[newDDSHeader.dwSize + 4]; + newDDSHeader.WriteToArray(DDSHeader, 0); + byte[] RealTexture = new byte[DDSHeader.Length + Texture.Length]; + Array.Copy(DDSHeader, 0, RealTexture, 0, DDSHeader.Length); + Array.Copy(Texture, 0, RealTexture, DDSHeader.Length, Texture.Length); + TextureStream.Flush(); + TextureStream.Write(RealTexture, 0, RealTexture.Length); + CSharpImageLibrary.ImageEngineImage CSILImage = new CSharpImageLibrary.ImageEngineImage(RealTexture); + //Console.WriteLine(CSILImage.ToString()); + CSharpImageLibrary.ImageFormats.ImageEngineFormatDetails DestinationDetails = new CSharpImageLibrary.ImageFormats.ImageEngineFormatDetails(CSharpImageLibrary.ImageEngineFormat.TIF); + bool AlphaRemovalFlag = !(VTFGeneral.HasAlpha(Format)); + byte[] ConvertedToPNG = CSILImage.Save(DestinationDetails, CSharpImageLibrary.MipHandling.KeepTopOnly, 8192, 0, false); //show only the first mip, as this is just a preview + System.IO.MemoryStream PNGStream = new System.IO.MemoryStream(); //import our file into ram + PNGStream.Write(ConvertedToPNG, 0, ConvertedToPNG.Length); + return PNGStream; + } + + /// + /// Converts and outputs texture data as a TIF file in a MemoryStream. + /// + /// + /// + /// + /// + /// + public static System.IO.MemoryStream GenerateImage(byte[] Texture, int Mipcount, int Format, Formats.VTFFile Imported) + { + System.IO.MemoryStream TextureStream = new System.IO.MemoryStream(); + TextureStream.Write(Texture, 0, Texture.Length); + CSharpImageLibrary.ImageEngineFormat ParsedEnum = (CSharpImageLibrary.ImageEngineFormat)Enum.Parse(typeof(VTFGeneral.TEXTURE_FORMATS_INTEROP), Enum.GetName(typeof(VTFGeneral.TEXTURE_FORMATS), Format)); + Console.WriteLine(ParsedEnum); + + CSharpImageLibrary.Headers.DDS_Header newDDSHeader = new CSharpImageLibrary.Headers.DDS_Header(Mipcount, Imported.Height, Imported.Width, ParsedEnum, CSharpImageLibrary.Headers.DDS_Header.DXGI_FORMAT.DXGI_FORMAT_UNKNOWN); + byte[] DDSHeader = new byte[newDDSHeader.dwSize + 4]; + newDDSHeader.WriteToArray(DDSHeader, 0); + byte[] RealTexture = new byte[DDSHeader.Length + Texture.Length]; + Array.Copy(DDSHeader, 0, RealTexture, 0, DDSHeader.Length); + Array.Copy(Texture, 0, RealTexture, DDSHeader.Length, Texture.Length); + TextureStream.Flush(); + TextureStream.Write(RealTexture, 0, RealTexture.Length); + CSharpImageLibrary.ImageEngineImage CSILImage = new CSharpImageLibrary.ImageEngineImage(RealTexture); + //Console.WriteLine(CSILImage.ToString()); + CSharpImageLibrary.ImageFormats.ImageEngineFormatDetails DestinationDetails = new CSharpImageLibrary.ImageFormats.ImageEngineFormatDetails(CSharpImageLibrary.ImageEngineFormat.TIF); + bool AlphaRemovalFlag = !(VTFGeneral.HasAlpha(Format)); + byte[] ConvertedToPNG = CSILImage.Save(DestinationDetails, CSharpImageLibrary.MipHandling.KeepTopOnly, 8192, 0, false); //show only the first mip, as this is just a preview + System.IO.MemoryStream PNGStream = new System.IO.MemoryStream(); //import our file into ram + PNGStream.Write(ConvertedToPNG, 0, ConvertedToPNG.Length); + return PNGStream; + } + + + } +} diff --git a/VTFXUtil/MipMaker.cs b/VTFXUtil/MipMaker.cs new file mode 100644 index 0000000..c6aa9a9 --- /dev/null +++ b/VTFXUtil/MipMaker.cs @@ -0,0 +1,231 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +/* + HOLY FUCK + ALL OF THIS CODE ALMOST WORKED ON THE FIRST TRY + HOW THE FUCK +*/ +namespace VTFXUtil +{ + class MipMaker + { + readonly private static int[] OneByteFormats = { 5, 7, 8 }; + readonly private static int[] TwoByteFormats = { 4, 6, 17, 18, 19, 21, 22 }; + readonly private static int[] ThreeByteFormats = {2, 3, 9, 10}; + readonly private static int[] FourByteFormats = { 0, 1, 11, 12, 16, 23, 26, 27 }; + readonly private static int[] DXTFormats = { 13, 14, 15 }; + public class MipMap + { + /// + /// Width of the current mip. + /// + public int Width; + /// + /// Height of the current mip. + /// + public int Height; + /// + /// Total number of bytes in the current mip. + /// + public int TotalBytes; + + public MipMap(int w, int h, int tb) + { + Width = w; + Height = h; + TotalBytes = tb; + } + } + /// + /// Generates information on every possible mip within the current image. + /// + /// + /// + /// + /// + public static MipMap[] GenMipInfo(int SrcWidth, int SrcHeight, int TexFormat) + { + double ChunkMult = 1; + bool ImageIsTall = false; + bool ImageIsWide = false; + if (SrcWidth > SrcHeight) + { + ImageIsWide = true; + } + else if (SrcHeight > SrcWidth) + { + ImageIsTall = true; + } + + List MipList = new List(); + + //begin chunknum estimation + + if (TwoByteFormats.Contains(TexFormat)) + { + ChunkMult = 2; + } + if (ThreeByteFormats.Contains(TexFormat)) + { + ChunkMult = 3; + } + else if (FourByteFormats.Contains(TexFormat)) + { + ChunkMult = 4; + } + else + { + if (DXTFormats.Contains(TexFormat)) + { + if (TexFormat == (int)VTFGeneral.TEXTURE_FORMATS.IMAGE_FORMAT_DXT1) + { + ChunkMult = 0.25; + } + else + { + //ChunkMult = 0.5; //ignore trying to change values for these, as they do nothing but fuck up mip calculations + } + } + } + + bool AttemptedPast1x1 = false; + double TempWidth = SrcWidth; + double TempHeight = SrcHeight; + while (!AttemptedPast1x1) + { + if (DXTFormats.Contains(TexFormat)) + { + double CurrentMipSize; + if (TexFormat == (int)VTFGeneral.TEXTURE_FORMATS.IMAGE_FORMAT_DXT1) + { + double HorChunkNum = TempWidth * ChunkMult; + if (TempWidth < 4) + { + HorChunkNum = 4 * ChunkMult; + } + double VerChunkNum = TempHeight * ChunkMult; + if (TempHeight < 4) + { + VerChunkNum = 4 * ChunkMult; + } + double TotalChunkNum = HorChunkNum * VerChunkNum; + CurrentMipSize = TotalChunkNum * 8; + } + else + { + CurrentMipSize = TempWidth * TempHeight; //for some strange reason, DXT3 and DXT5's byte size for a single image somehow manages to be just the width multiplied by the height + //thinking about that actually makes sense, in a dumb way + //as each 4x4 chunk is 16 bytes + //so if you think about it like a dumbass, you could get a weird analogy of "hurr each 4 byte is like 1 lines of pixels" + if(CurrentMipSize < 16) + { + CurrentMipSize = 16; //has to be added here, because code would crash otherwise + } + } + Console.WriteLine(TempWidth + "x" + TempHeight + " | Chunk size: " + CurrentMipSize); + MipList.Add(new MipMap((int)TempWidth, (int)TempHeight, (int)CurrentMipSize)); + } + else + { + double CurrentMipSizeNoMult = TempWidth * TempHeight; + double CurrentMipSize = CurrentMipSizeNoMult * ChunkMult; + MipList.Add(new MipMap((int)TempWidth, (int)TempHeight, (int)CurrentMipSize)); + } + + TempWidth *= .5; + TempHeight *= .5; + + if (ImageIsTall) + { + if(TempWidth < 1) + { + TempWidth = 1; + } + if(TempHeight < 1) + { + AttemptedPast1x1 = true; + } + } + else if (ImageIsWide) + { + if(TempHeight < 1) + { + TempHeight = 1; + } + if(TempWidth < 1) + { + AttemptedPast1x1 = true; + } + } + else + { + if(TempWidth < 1 && TempHeight < 1) + { + AttemptedPast1x1 = true; + } + } + } + + MipMap[] TheList = MipList.ToArray(); + Array.Reverse(TheList); // miplist must be reversed, as VTF is a cursed format that has the mips backwards + return TheList; + + } + /// + /// Checks to see if the current image is mipmapped. + /// + /// + /// + /// + /// + /// + public static bool IsMipped(int SrcWidth, int SrcHeight, int TexFormat, int RealTexSize) + { + double ChunkMult = 1; + double PixelCount = SrcWidth * SrcHeight; + double EstimatedSize; + if (TwoByteFormats.Contains(TexFormat)) + { + ChunkMult = 2; + } + if (ThreeByteFormats.Contains(TexFormat)) + { + ChunkMult = 3; + } + else if (FourByteFormats.Contains(TexFormat)) + { + ChunkMult = 4; + } + else + { + if (DXTFormats.Contains(TexFormat)) + { + if(TexFormat == (int)VTFGeneral.TEXTURE_FORMATS.IMAGE_FORMAT_DXT1) + { + ChunkMult = 0.5; // for some reason, setting this to 0.5 works for dxt1, but doing it in the actual mip detection code causes it to break + } + else + { + //ChunkMult = 0.5; // disregard, screws up mipinfo for non-mipped textures + } + } + } + EstimatedSize = PixelCount * ChunkMult; + if(RealTexSize > (int)EstimatedSize) + { + Console.WriteLine("We believe we can mipmap this. Real size: " + RealTexSize + " bytes."); + Console.WriteLine("Estimated size: " + EstimatedSize + " bytes."); + Console.WriteLine(RealTexSize + " > " + EstimatedSize); + return true; + } + else + { + return false; + } + } + } +} diff --git a/VTFXUtil/Program.cs b/VTFXUtil/Program.cs new file mode 100644 index 0000000..01b9e08 --- /dev/null +++ b/VTFXUtil/Program.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace VTFXUtil +{ + static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new Form1()); + } + } +} diff --git a/VTFXUtil/Properties/AssemblyInfo.cs b/VTFXUtil/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..7ae364e --- /dev/null +++ b/VTFXUtil/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("VTFXUtil")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("VTFXUtil")] +[assembly: AssemblyCopyright("Copyright © 2020")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("ac6b703c-9018-4420-8ebb-e57e7a1d2562")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/VTFXUtil/Properties/Resources.Designer.cs b/VTFXUtil/Properties/Resources.Designer.cs new file mode 100644 index 0000000..d28c7af --- /dev/null +++ b/VTFXUtil/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace VTFXUtil.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("VTFXUtil.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/VTFXUtil/Properties/Resources.resx b/VTFXUtil/Properties/Resources.resx new file mode 100644 index 0000000..fec25bb --- /dev/null +++ b/VTFXUtil/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + diff --git a/VTFXUtil/Properties/Settings.Designer.cs b/VTFXUtil/Properties/Settings.Designer.cs new file mode 100644 index 0000000..970e175 --- /dev/null +++ b/VTFXUtil/Properties/Settings.Designer.cs @@ -0,0 +1,26 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace VTFXUtil.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.9.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + } +} diff --git a/VTFXUtil/Properties/Settings.settings b/VTFXUtil/Properties/Settings.settings new file mode 100644 index 0000000..820ff06 --- /dev/null +++ b/VTFXUtil/Properties/Settings.settings @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/VTFXUtil/VTFGeneral.cs b/VTFXUtil/VTFGeneral.cs new file mode 100644 index 0000000..cb213b5 --- /dev/null +++ b/VTFXUtil/VTFGeneral.cs @@ -0,0 +1,243 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace VTFXUtil +{ + public class VTFGeneral + { + public struct VTFResource + { + public byte[] ResourceType; + public byte ResourceFlag; + public int Offset; + + public VTFResource(byte[] Kind, byte Flag, int Off) + { + ResourceType = Kind; + ResourceFlag = Flag; + Offset = Off; + } + } + + public static readonly string[] TexFmtStrArr = { "RGBA8888", "ABGR8888", "RGB888", "BGR888", "RGB565", "I8", "IA88", "P8", "A8", "RGB888 Bluescreen", "BGR888 Bluescreen", "ARGB8888", "BGRA8888", "DXT1", "DXT3", "DXT5", "BGRX8888", "BGR565", "BGRX5551", "BGRA4444", "DXT1 One Bit Alpha", "BGRA5551", "UV88", "UVWQ8888", "RGBA16161616F", "RGBA16161616", "UVLX8888", "R32F", "RGB323232F", "RGBA32323232F", "NVIDIA DST16", "NVIDIA DST24", "NVIDIA INTZ", "NVIDIA RAWZ", "ATI DST16", "ATI DST24", "NVIDIA NULL", "ATI1N", "ATI2N", "Xbox 360 DST16", "Xbox 360 DST24", "Xbox 360 DST24F", "Linear BGRX8888", "Linear RGBA8888", "Linear ABGR8888", "Linear ARGB8888", "Linear BGRA8888", "Linear RGB888", "Linear BGR888", "Linear BGRX5551", "Linear I8", "Linear RGBA16161616", "LE BGRX8888", "LE BGRA8888" }; + public static readonly Dictionary VTFFlags = new Dictionary() { { 0x1, "Point Sample" }, { 0x2, "Trilinear" }, { 0x4, "Clamp S" }, { 0x8, "Clamp T" }, { 0x10, "Anisotropic" }, { 0x20, "Hint DXT5" }, { 0x40, "PWL Corrected" }, { 0x80, "Normal Map" }, { 0x100, "No Mipmap" }, { 0x200, "No Level of Detail" }, { 0x400, "All Mipmaps" }, { 0x800, "All Procedural" }, { 0x1000, "One Bit Alpha" }, { 0x2000, "Eight Bit Alpha" }, { 0x4000, "Environment Map" }, { 0x8000, "Rendertarget" }, { 0x10000, "Depth Rendertarget" }, { 0x20000, "No Debug Override" }, { 0x40000, "Single Copy" }, { 0x80000, "Pre sRGB" }, { 0x100000, "Unused" }, { 0x200000, "Unused" }, { 0x400000, "Unused" }, { 0x800000, "No Depth Buffer" }, { 0x1000000, "Unused" }, { 0x2000000, "Clamp U" }, { 0x4000000, "Vertex Texture" }, { 0x8000000, "SS Bump" }, { 0x10000000, "Unused" }, { 0x20000000, "Border" }, { 0x40000000, "Unused" }, { 0x80000000, "Unused" } }; + // enum list below is from the Source SDK's imageformat.h "/sp/src/public/bitmap/imageformat.h" https://github.com/ValveSoftware/source-sdk-2013 + public enum TEXTURE_FORMATS + { + IMAGE_FORMAT_RGBA8888, + IMAGE_FORMAT_ABGR8888, + IMAGE_FORMAT_RGB888, + IMAGE_FORMAT_BGR888, + IMAGE_FORMAT_RGB565, + IMAGE_FORMAT_I8, + IMAGE_FORMAT_IA88, + IMAGE_FORMAT_P8, + IMAGE_FORMAT_A8, + IMAGE_FORMAT_RGB888_BLUESCREEN, + IMAGE_FORMAT_BGR888_BLUESCREEN, + IMAGE_FORMAT_ARGB8888, + IMAGE_FORMAT_BGRA8888, + IMAGE_FORMAT_DXT1, + IMAGE_FORMAT_DXT3, + IMAGE_FORMAT_DXT5, + IMAGE_FORMAT_BGRX8888, + IMAGE_FORMAT_BGR565, + IMAGE_FORMAT_BGRX5551, + IMAGE_FORMAT_BGRA4444, + IMAGE_FORMAT_DXT1_ONEBITALPHA, + IMAGE_FORMAT_BGRA5551, + IMAGE_FORMAT_UV88, + IMAGE_FORMAT_UVWQ8888, + IMAGE_FORMAT_RGBA16161616F, + IMAGE_FORMAT_RGBA16161616, + IMAGE_FORMAT_UVLX8888, + IMAGE_FORMAT_R32F, + IMAGE_FORMAT_RGB323232F, + IMAGE_FORMAT_RGBA32323232F, + IMAGE_FORMAT_NV_DST16, + IMAGE_FORMAT_NV_DST24, + IMAGE_FORMAT_NV_INTZ, + IMAGE_FORMAT_NV_RAWZ, + IMAGE_FORMAT_ATI_DST16, + IMAGE_FORMAT_ATI_DST24, + IMAGE_FORMAT_NV_NULL, + IMAGE_FORMAT_ATI1N, + IMAGE_FORMAT_ATI2N, + IMAGE_FORMAT_X360_DST16, + IMAGE_FORMAT_X360_DST24, + IMAGE_FORMAT_X360_DST24F, + IMAGE_FORMAT_LINEAR_BGRX8888, + IMAGE_FORMAT_LINEAR_RGBA8888, + IMAGE_FORMAT_LINEAR_ABGR8888, + IMAGE_FORMAT_LINEAR_ARGB8888, + IMAGE_FORMAT_LINEAR_BGRA8888, + IMAGE_FORMAT_LINEAR_RGB888, + IMAGE_FORMAT_LINEAR_BGR888, + IMAGE_FORMAT_LINEAR_BGRX5551, + IMAGE_FORMAT_LINEAR_I8, + IMAGE_FORMAT_LINEAR_RGBA16161616, + IMAGE_FORMAT_LE_BGRX8888, + IMAGE_FORMAT_LE_BGRA8888 + } + private static readonly byte[] LRImgBytes = { 0x1, 0x0, 0x0 }; + private static readonly byte[] HRImgBytes = { 0x30, 0x0, 0x0 }; + private static readonly byte[] PSDatBytes = { 0x10, 0x0, 0x0 }; + private static readonly byte[] CRCBytes = { 0x43, 0x52, 0x43 }; + private static readonly byte[] LODBytes = { 0x4c, 0x4f, 0x44 }; + private static readonly byte[] ExtVTFFlagsBytes = { 0x54, 0x53, 0x4f }; + private static readonly byte[] ArbKVFlags = { 0x4b, 0x56, 0x44 }; + public static readonly Dictionary ResourceTypes = new Dictionary() { { Encoding.UTF8.GetString(LRImgBytes), "Low Resolution Image Data" }, { Encoding.UTF8.GetString(HRImgBytes), "High Resolution Image Data" }, { Encoding.UTF8.GetString(PSDatBytes), "Particle Sheet Data" }, { Encoding.UTF8.GetString(CRCBytes), "File CRC" }, { Encoding.UTF8.GetString(LODBytes), "Texture LOD Information" }, { Encoding.UTF8.GetString(ExtVTFFlagsBytes), "Extended VTF Flags" }, { Encoding.UTF8.GetString(ArbKVFlags), "Arbitrary KeyValue Flags" } }; + + public static string GetResourceType(byte[] ByteArray) + { + return ResourceTypes[Encoding.UTF8.GetString(ByteArray)]; + } + + /// + /// Determines if the specified format has an alpha channel. + /// + /// + /// + public static bool HasAlpha(int Format) + { + string[] ValidAlphaFormats = { "RGBA8888", "ABGR8888", null, null, null, null, "IA88", null, "A8", null, null, "ARGB8888", "BGRA8888", null, "DXT3", "DXT5", "BGRX8888", null, "BGRX5551", "BGRA4444", "DXT1 One Bit Alpha", "BGRA5551", null, null, "RGBA16161616F", "RGBA16161616", null, null, null, "RGBA32323232F", null, null, null, null, null, null, null, null, null, null, null, null, "Linear BGRX8888", "Linear RGBA8888", "Linear ABGR8888", "Linear ARGB8888", "Linear BGRA8888", null, null, "Linear BGRX5551", null, "Linear RGBA16161616", "LE BGRX8888", "LE BGRA8888" }; + if (ValidAlphaFormats[Format] != null) + { + return true; + } + return false; + } + public class VTFFormatProps + { + public int Format; + public bool IsInCSIL; + public bool IsInTIN; + public int bpp; + public bool IsCompressed; + public bool IsCurrentlySupported; + public int ColorByteAmount; + public VTFFormatProps() + { + Format = -1; + IsInCSIL = false; + IsInTIN = false; + bpp = 0; + IsCompressed = false; + IsCurrentlySupported = false; + ColorByteAmount = 0; + } + public VTFFormatProps(int format, bool SupportsCSIL, bool SupportsTIN, int BPP, bool Compressed, bool CurrentlySupported, int ColBytes) + { + Format = format; + IsInCSIL = SupportsCSIL; + IsInTIN = SupportsTIN; + bpp = BPP; + IsCompressed = Compressed; + IsCurrentlySupported = CurrentlySupported; + ColorByteAmount = ColBytes; + } + } + public static readonly VTFFormatProps[] FormatTable = + { + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_RGBA8888, true, true, 32, false, true, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_ABGR8888, true, true, 32, false, true, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_RGB888, true, true, 24, false, true, 3), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_BGR888, true, true, 24, false, true, 3), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_RGB565, true, true, 16, false, true, 2), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_I8, false, false, 8, false, true, 1), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_IA88, false, false, 16, false, true, 2), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_P8, false, false, 8, false, true, 1), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_A8, true, false, 8, false, true, 1), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_RGB888_BLUESCREEN, true, false, 24, false, true, 3), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_BGR888_BLUESCREEN, true, false, 24, false, true, 3), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_ARGB8888, true, false, 32, false, true, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_BGRA8888, true, false, 32, false, true, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_DXT1, true, false, 4, true, true, 4), //define color bits as negative for compressed textures, so program can ignore it, dxt1 has a fit so it needs to be defined + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_DXT3, true, false, 8, true, true, -1), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_DXT5, true, false, 8, true, true, -1), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_BGRX8888, true, false, 32, false, true, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_BGR565, true, true, 16, false, true, 3), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_BGRX5551, true, true, 16, false, true, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_BGRA4444, true, true, 16, false, true, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_DXT1_ONEBITALPHA, false, true, 4, true, true, -1), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_BGRA5551, false, true, 16, false, true, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_UV88, true, false, 16, false, true, 2), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_UVWQ8888, false, false, 32, false, false, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_RGBA16161616F, true, false, 64, false, true, 8), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_RGBA16161616, true, false, 64, false, true, 8), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_UVLX8888, false, false, 32, false, false, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_R32F, false, false, 32, false, false, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_RGB323232F, true, false, 96, false, true, 12), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_RGBA32323232F, true, false, 128, false, true, 16), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_NV_DST16, false, false, 16, false, false, 2), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_NV_DST24, false, false, 24, false, false, 3), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_NV_INTZ, false, false, 32, false, false, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_NV_RAWZ, false, false, 32, false, false, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_ATI_DST16, false, false, 16, false, false, 2), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_ATI_DST24, false, false, 24, false, false, 3), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_NV_NULL, false, false, 32, false, false, 4), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_ATI1N, true, false, 4, true, true, -1), + new VTFFormatProps((int) TEXTURE_FORMATS.IMAGE_FORMAT_ATI2N, true, false, 8, true, true, -1), + }; + public enum TEXTURE_FORMATS_INTEROP + { + IMAGE_FORMAT_RGBA8888 = CSharpImageLibrary.ImageEngineFormat.DDS_ARGB_8, //move rgb values down, alpha to end + IMAGE_FORMAT_ABGR8888 = CSharpImageLibrary.ImageEngineFormat.DDS_ABGR_8, + IMAGE_FORMAT_RGB888 = CSharpImageLibrary.ImageEngineFormat.DDS_RGB_8, + IMAGE_FORMAT_BGR888 = CSharpImageLibrary.ImageEngineFormat.DDS_RGB_8, //reverse color order + IMAGE_FORMAT_RGB565 = CSharpImageLibrary.ImageEngineFormat.DDS_R5G6B5, + IMAGE_FORMAT_I8 = CSharpImageLibrary.ImageEngineFormat.Unknown, //will reparse unknowns later in code + IMAGE_FORMAT_IA88 = CSharpImageLibrary.ImageEngineFormat.Unknown, + IMAGE_FORMAT_P8 = CSharpImageLibrary.ImageEngineFormat.Unknown, + IMAGE_FORMAT_A8 = CSharpImageLibrary.ImageEngineFormat.DDS_A8, + IMAGE_FORMAT_RGB888_BLUESCREEN = CSharpImageLibrary.ImageEngineFormat.DDS_RGB_8, + IMAGE_FORMAT_BGR888_BLUESCREEN = CSharpImageLibrary.ImageEngineFormat.DDS_RGB_8, //reverse these too!! + IMAGE_FORMAT_ARGB8888 = CSharpImageLibrary.ImageEngineFormat.DDS_ARGB_8, + IMAGE_FORMAT_BGRA8888 = CSharpImageLibrary.ImageEngineFormat.DDS_ARGB_8, // reverse!! + IMAGE_FORMAT_DXT1 = CSharpImageLibrary.ImageEngineFormat.DDS_DXT1, + IMAGE_FORMAT_DXT3 = CSharpImageLibrary.ImageEngineFormat.DDS_DXT3, + IMAGE_FORMAT_DXT5 = CSharpImageLibrary.ImageEngineFormat.DDS_DXT5, + IMAGE_FORMAT_BGRX8888 = CSharpImageLibrary.ImageEngineFormat.DDS_ARGB_8, //reverse!! + IMAGE_FORMAT_BGR565 = CSharpImageLibrary.ImageEngineFormat.DDS_R5G6B5, //reverse!! + IMAGE_FORMAT_BGRX5551 = CSharpImageLibrary.ImageEngineFormat.DDS_CUSTOM, //will need to possibly redefine!!! + IMAGE_FORMAT_BGRA4444 = CSharpImageLibrary.ImageEngineFormat.DDS_ARGB_4, //reverse!! + IMAGE_FORMAT_DXT1_ONEBITALPHA = TeximpNet.Compression.CompressionFormat.DXT1a, //no idea if CSharpImageLibrary has this + IMAGE_FORMAT_BGRA5551 = TeximpNet.Compression.CompressionFormat.BGRA, + IMAGE_FORMAT_UV88 = CSharpImageLibrary.ImageEngineFormat.DDS_V8U8, //reverse these!! + IMAGE_FORMAT_UVWQ8888, + IMAGE_FORMAT_RGBA16161616F = CSharpImageLibrary.ImageEngineFormat.DDS_CUSTOM, //possible define + IMAGE_FORMAT_RGBA16161616 = CSharpImageLibrary.ImageEngineFormat.DDS_CUSTOM, + IMAGE_FORMAT_UVLX8888, + IMAGE_FORMAT_R32F, + IMAGE_FORMAT_RGB323232F = CSharpImageLibrary.ImageEngineFormat.DDS_CUSTOM, + IMAGE_FORMAT_RGBA32323232F = CSharpImageLibrary.ImageEngineFormat.DDS_CUSTOM, + IMAGE_FORMAT_NV_DST16, + IMAGE_FORMAT_NV_DST24, + IMAGE_FORMAT_NV_INTZ, + IMAGE_FORMAT_NV_RAWZ, + IMAGE_FORMAT_ATI_DST16, + IMAGE_FORMAT_ATI_DST24, + IMAGE_FORMAT_NV_NULL, + IMAGE_FORMAT_ATI1N = CSharpImageLibrary.ImageEngineFormat.DDS_ATI1, + IMAGE_FORMAT_ATI2N = CSharpImageLibrary.ImageEngineFormat.DDS_ATI2_3Dc, + IMAGE_FORMAT_X360_DST16, + IMAGE_FORMAT_X360_DST24, + IMAGE_FORMAT_X360_DST24F, + IMAGE_FORMAT_LINEAR_BGRX8888, + IMAGE_FORMAT_LINEAR_RGBA8888, + IMAGE_FORMAT_LINEAR_ABGR8888, + IMAGE_FORMAT_LINEAR_ARGB8888, + IMAGE_FORMAT_LINEAR_BGRA8888, + IMAGE_FORMAT_LINEAR_RGB888, + IMAGE_FORMAT_LINEAR_BGR888, + IMAGE_FORMAT_LINEAR_BGRX5551, + IMAGE_FORMAT_LINEAR_I8, + IMAGE_FORMAT_LINEAR_RGBA16161616, + IMAGE_FORMAT_LE_BGRX8888, + IMAGE_FORMAT_LE_BGRA8888 + } + } +} diff --git a/VTFXUtil/VTFXHandler.cs b/VTFXUtil/VTFXHandler.cs new file mode 100644 index 0000000..b3b9594 --- /dev/null +++ b/VTFXUtil/VTFXHandler.cs @@ -0,0 +1,323 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace VTFXUtil +{ + class VTFXHandler + { + readonly private static string FileMagicVTFX = "VTFX"; + public static readonly byte[] VTFXMagicByte = { 0x56, 0x54, 0x46, 0x58 }; + + /// + /// Represents a VTFX file. + /// + public class VTFXFile + { + public string FileMagic; //VTFX + public byte[] VersionNum = new byte[8]; // major version is 0x00000360 for Xbox 360 files, 0x00000333 for PS3 files, minor version always 0x00000008 + public int HeaderSize; //usually 0x44 or 68 in base 10 + public byte[] VTFFlags = new byte[4]; //same as standard VTF, endianswapped + public int ImageWidth; //ditto + public int ImageHeight; //ditto + public int BitDepth; // this is incorrectly named, this is actually for how much depth a volume texture has + public int FrameCount; // oh come on its obvious + public int PreloadSize; //the size of the preload chunk that exists in __preload_section.pre for this texture + public int MipSkipCount; // basically used for forced texture quality reduction + public int ResourceCount; //same as normal VTF, also needs endianswapping + public byte[] ReflectivityVec = new byte[12]; //ditto + public float BumpScale; //ditto + public byte[] TextureFormat = new byte[4]; //ditto + public byte[] LowResSamplingAmt = new byte[4]; // also misnamed by me, turns out this is for doing light sampling with VRAD + public int CompressedSize; //exact size of the texture data itself once compressed, PS3 files will have this section zeroed out, due to textures being compressed outside of the file + public Dictionary Resources; //contains resource data + public byte[] FileData; //data contained in the file + } + + /// + /// Returns an imported VTFX file from a path. + /// + /// + /// + public static VTFXFile ImportVTFX(string PathToFile) // why did i make this import from a fucking file path + { + if (PathToFile.Equals("")) + { + return null; + } + System.IO.FileStream ImportFile = new System.IO.FileStream(PathToFile, System.IO.FileMode.Open, System.IO.FileAccess.Read); + byte[] TempAll = System.IO.File.ReadAllBytes(PathToFile); + byte[] HeaderLenArr = new byte[4]; + //Array.Copy(TempAll, 0xc, HeaderLenArr, 0, 4); + HeaderLenArr[3] = 0x44; + Array.Reverse(HeaderLenArr); + int BufferLen = System.BitConverter.ToInt32(HeaderLenArr, 0); + byte[] Header = new byte[BufferLen]; + using (ImportFile) + { + ImportFile.Read(Header, 0, BufferLen); + } + + byte[] FileMagicBytes = new byte[4]; + Array.Copy(Header, 0, FileMagicBytes, 0, 4); + //Console.WriteLine(FileMagic); + if (FileMagicBytes.SequenceEqual(VTFXMagicByte)) + { + string FileMagic = System.Text.Encoding.UTF8.GetString(Header).Substring(0, 4); + VTFXFile InMem = new VTFXFile(); + InMem.FileMagic = FileMagic; + Array.Copy(Header, 4, InMem.VersionNum, 0, 8); + byte[] TempLen = new byte[4]; + Array.Copy(Header, 12, TempLen, 0, 4); + Array.Reverse(TempLen); // yay endianswapping + InMem.HeaderSize = System.BitConverter.ToInt32(TempLen, 0); + byte[] TempVTFFlags = new byte[4]; + Array.Copy(Header, 16, TempVTFFlags, 0, 4); + Array.Reverse(TempVTFFlags); + InMem.VTFFlags = TempVTFFlags; + byte[] TempWidth = new byte[2]; + Array.Copy(Header, 20, TempWidth, 0, 2); + Array.Reverse(TempWidth); + InMem.ImageWidth = System.BitConverter.ToInt16(TempWidth, 0); + byte[] TempHeight = new byte[2]; + Array.Copy(Header, 22, TempHeight, 0, 2); + Array.Reverse(TempHeight); + InMem.ImageHeight = System.BitConverter.ToInt16(TempHeight, 0); + byte[] TempDepth = new byte[2]; + Array.Copy(Header, 24, TempDepth, 0, 2); + Array.Reverse(TempDepth); + InMem.BitDepth = System.BitConverter.ToInt16(TempDepth, 0); + byte[] TempFC = new byte[2]; + Array.Copy(Header, 25, TempFC, 0, 2); + InMem.FrameCount = System.BitConverter.ToInt16(TempFC, 0); + byte[] TempPreload = new byte[2]; + Array.Copy(Header, 28, TempPreload, 0, 2); + Array.Reverse(TempPreload); + InMem.PreloadSize = System.BitConverter.ToInt16(TempPreload, 0); + byte TempMip = Header[30]; + InMem.MipSkipCount = Convert.ToSByte(TempMip); + InMem.ResourceCount = Convert.ToSByte(Header[31]); + byte[] TempVec = new byte[12]; + byte[] Vec1 = new byte[4]; + Array.Copy(Header, 32, Vec1, 0, 4); + byte[] Vec2 = new byte[4]; + Array.Copy(Header, 36, Vec2, 0, 4); + byte[] Vec3 = new byte[4]; + Array.Copy(Header, 40, Vec3, 0, 4); + Array.Reverse(Vec1); + Array.Reverse(Vec2); + Array.Reverse(Vec3); + Array.Copy(Vec1, 0, TempVec, 0, 4); + Array.Copy(Vec2, 0, TempVec, 4, 4); + Array.Copy(Vec3, 0, TempVec, 8, 4); + InMem.ReflectivityVec = TempVec; + byte[] TempBump = new byte[4]; + Array.Copy(Header, 44, TempBump, 0, 4); + Array.Reverse(TempBump); + InMem.BumpScale = System.BitConverter.ToSingle(TempBump, 0); + Array.Copy(Header, 48, InMem.TextureFormat, 0, 4); + Array.Reverse(InMem.TextureFormat); + Array.Copy(Header, 52, InMem.LowResSamplingAmt, 0, 4); + byte[] TempCompSize = new byte[4]; + Array.Copy(Header, 56, TempCompSize, 0, 4); + Array.Reverse(TempCompSize); + InMem.CompressedSize = System.BitConverter.ToInt32(TempCompSize, 0); + InMem.Resources = ParseResourceInfo(InMem, PathToFile); + InMem.FileData = new byte[TempAll.Length - InMem.HeaderSize]; + Array.Copy(TempAll, InMem.HeaderSize, InMem.FileData, 0, TempAll.Length - InMem.HeaderSize); + GC.Collect(); + return InMem; + } + else + { + MessageBox.Show("Specified file was not in the VTFX format."); + return null; + } + } + + /// + /// Returns a VTFX file from the given MemoryStream. + /// + /// + /// + public static VTFXFile ImportVTFX(System.IO.MemoryStream ImportFile) // this is better, but the way i handled this is fucking terrible + { + byte[] TempAll = ImportFile.ToArray(); + byte[] HeaderLenArr = new byte[4]; + Array.Copy(TempAll, 0xc, HeaderLenArr, 0, 4); + Array.Reverse(HeaderLenArr); + int BufferLen = System.BitConverter.ToInt32(HeaderLenArr, 0); + byte[] Header = new byte[BufferLen]; + using (ImportFile) + { + ImportFile.Read(Header, 0, BufferLen); + } + string FileMagic = System.Text.Encoding.UTF8.GetString(Header).Substring(0, 4); + Console.WriteLine(FileMagic); + if (FileMagic.Equals(FileMagicVTFX)) + { + VTFXFile InMem = new VTFXFile(); + InMem.FileMagic = FileMagic; + Array.Copy(Header, 4, InMem.VersionNum, 0, 8); + byte[] TempLen = new byte[4]; + Array.Copy(Header, 12, TempLen, 0, 4); + Array.Reverse(TempLen); // yay endianswapping + InMem.HeaderSize = System.BitConverter.ToInt32(TempLen, 0); + byte[] TempVTFFlags = new byte[4]; + Array.Copy(Header, 16, TempVTFFlags, 0, 4); + Array.Reverse(TempVTFFlags); + InMem.VTFFlags = TempVTFFlags; + byte[] TempWidth = new byte[2]; + Array.Copy(Header, 20, TempWidth, 0, 2); + Array.Reverse(TempWidth); + InMem.ImageWidth = System.BitConverter.ToInt16(TempWidth, 0); + byte[] TempHeight = new byte[2]; + Array.Copy(Header, 22, TempHeight, 0, 2); + Array.Reverse(TempHeight); + InMem.ImageHeight = System.BitConverter.ToInt16(TempHeight, 0); + byte[] TempDepth = new byte[2]; + Array.Copy(Header, 24, TempDepth, 0, 2); + Array.Reverse(TempDepth); + InMem.BitDepth = System.BitConverter.ToInt16(TempDepth, 0); + byte[] TempFC = new byte[2]; + Array.Copy(Header, 25, TempFC, 0, 2); + InMem.FrameCount = System.BitConverter.ToInt16(TempFC, 0); + byte[] TempPreload = new byte[2]; + Array.Copy(Header, 28, TempPreload, 0, 2); + Array.Reverse(TempPreload); + InMem.PreloadSize = System.BitConverter.ToInt16(TempPreload, 0); + byte TempMip = Header[30]; + InMem.MipSkipCount = Convert.ToSByte(TempMip); + InMem.ResourceCount = Convert.ToSByte(Header[31]); + byte[] TempVec = new byte[12]; + byte[] Vec1 = new byte[4]; + Array.Copy(Header, 32, Vec1, 0, 4); + byte[] Vec2 = new byte[4]; + Array.Copy(Header, 36, Vec2, 0, 4); + byte[] Vec3 = new byte[4]; + Array.Copy(Header, 40, Vec3, 0, 4); + Array.Reverse(Vec1); + Array.Reverse(Vec2); + Array.Reverse(Vec3); + Array.Copy(Vec1, 0, TempVec, 0, 4); + Array.Copy(Vec2, 0, TempVec, 4, 4); + Array.Copy(Vec3, 0, TempVec, 8, 4); + InMem.ReflectivityVec = TempVec; + byte[] TempBump = new byte[4]; + Array.Copy(Header, 44, TempBump, 0, 4); + Array.Reverse(TempBump); + InMem.BumpScale = System.BitConverter.ToSingle(TempBump, 0); + Array.Copy(Header, 48, InMem.TextureFormat, 0, 4); + Array.Reverse(InMem.TextureFormat); + Array.Copy(Header, 52, InMem.LowResSamplingAmt, 0, 4); + byte[] TempCompSize = new byte[4]; + Array.Copy(Header, 56, TempCompSize, 0, 4); + Array.Reverse(TempCompSize); + InMem.CompressedSize = System.BitConverter.ToInt32(TempCompSize, 0); + InMem.Resources = ParseResourceInfo(InMem, ImportFile); + InMem.FileData = new byte[TempAll.Length - InMem.HeaderSize]; + Array.Copy(TempAll, InMem.HeaderSize, InMem.FileData, 0, TempAll.Length - InMem.HeaderSize); + GC.Collect(); + return InMem; + } + else + { + MessageBox.Show("Specified file was not in the VTFX format.\nMagic expected was \"VTFX\", magic returned was {0}", FileMagic); + return new VTFXFile(); + } + } + + public static VTFXFile ConvertVTFToVTFX(Formats.VTFFile Input, byte[] TextureData, byte[] Platform, byte[] ColorSamplingBytes) + { + //byte[] FourBytePadding = { 0x00, 0x00, 0x00, 0x00 }; + Dictionary VTFXResources = new Dictionary(); + foreach(var Resource in Input.Resources) + { + VTFXResources.Add(Resource.ResourceType, Resource.Offset); + } + VTFXFile Amalgamation = new VTFXFile + { + BitDepth = Input.ImageDepth, + BumpScale = Input.BumpScale, + // do some stuff with an if statement here for PS3 files, they don't compress anything + FileData = TextureData, + FileMagic = "VTFX", // i shouldn't have made this property for the VTFXFile object + FrameCount = Input.Frames, + HeaderSize = 0x44, + ImageHeight = Input.Height, + ImageWidth = Input.Width, + LowResSamplingAmt = ColorSamplingBytes, // this is apparently for color sampling, so i need to go and do some code refactors + MipSkipCount = 0, // basically just a built in texture quality setting, and i had no idea that something like this was even a thing + PreloadSize = 0, // make this zero, as i don't understand the format of __preload_section.pre, i hope to fuck this works + ReflectivityVec = Input.ReflectivityVector, + ResourceCount = 1, + Resources = VTFXResources, + TextureFormat = Input.Format, + VTFFlags = Input.Flags, + VersionNum = Platform + }; + if (Platform.SequenceEqual(Form1.XBoxBytes)) + { + Array.Copy(Form1.XBoxBytes, 0, Amalgamation.VersionNum, 0, 4); + } + else if (Platform.SequenceEqual(Form1.PS3Bytes)) + { + Array.Copy(Form1.PS3Bytes, 0, Amalgamation.VersionNum, 0, 4); + } + //Amalgamation.VersionNum[7] = 0x08; + return Amalgamation; + } + + public static Dictionary ParseResourceInfo(VTFXFile File, string PathToFile) + { + int ResourceBuffer = 8; + System.IO.FileStream ImportFile = new System.IO.FileStream(PathToFile, System.IO.FileMode.Open, System.IO.FileAccess.Read); + byte[] Temp = new byte[File.HeaderSize]; + byte[] Header = new byte[File.HeaderSize - 0x3c]; + using (ImportFile) + { + ImportFile.Read(Temp, 0, File.HeaderSize); + } + Array.Copy(Temp, 0x3c, Header, 0, File.HeaderSize - 0x3c); + Dictionary Resources = new Dictionary(); + for(int i = 0; i < File.ResourceCount; i++) + { + byte[] ResType = new byte[3]; + byte[] OffsetArray = new byte[4]; + Array.Copy(Header, ResourceBuffer * i, ResType, 0, 3); + Array.Copy(Header, ResourceBuffer * i + 4, OffsetArray, 0, 4); + Array.Reverse(OffsetArray); + Console.WriteLine(System.BitConverter.ToInt32(OffsetArray, 0)); + Resources.Add(ResType, (int)System.BitConverter.ToInt32(OffsetArray, 0)); + } + return Resources; + } + + public static Dictionary ParseResourceInfo(VTFXFile File, System.IO.MemoryStream ImportFile) + { + int ResourceBuffer = 8; + byte[] Temp = new byte[File.HeaderSize]; + byte[] Header = new byte[File.HeaderSize - 0x3c]; + using (ImportFile) + { + ImportFile.Read(Temp, 0, File.HeaderSize); + } + Array.Copy(Temp, 0x3c, Header, 0, File.HeaderSize - 0x3c); + Dictionary Resources = new Dictionary(); + for (int i = 0; i < File.ResourceCount; i++) + { + byte[] ResType = new byte[3]; + byte[] OffsetArray = new byte[4]; + Array.Copy(Header, ResourceBuffer * i, ResType, 0, 3); + Array.Copy(Header, ResourceBuffer * i + 4, OffsetArray, 0, 4); + Array.Reverse(OffsetArray); + Console.WriteLine(System.BitConverter.ToInt32(OffsetArray, 0)); + Resources.Add(ResType, (int)System.BitConverter.ToInt32(OffsetArray, 0)); + } + return Resources; + } + } +} diff --git a/VTFXUtil/VTFXUtil.csproj b/VTFXUtil/VTFXUtil.csproj new file mode 100644 index 0000000..b53efe1 --- /dev/null +++ b/VTFXUtil/VTFXUtil.csproj @@ -0,0 +1,144 @@ + + + + + Debug + AnyCPU + {AC6B703C-9018-4420-8EBB-E57E7A1D2562} + WinExe + VTFXUtil + VTFXUtil + v4.6.2 + 512 + true + + + + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + true + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + vtfxedit_icon.ico + + + + ..\packages\CSharpImageLibrary.4.2.0\lib\net462\CSharpImageLibrary.dll + + + ..\packages\Microsoft.IO.RecyclableMemoryStream.1.4.0\lib\net46\Microsoft.IO.RecyclableMemoryStream.dll + + + + ..\packages\LZMA-SDK.19.0.0\lib\net20\SevenZip.dll + + + + + + ..\packages\System.Numerics.Vectors.4.5.0\lib\net46\System.Numerics.Vectors.dll + + + ..\packages\Microsoft.Tpl.Dataflow.4.5.24\lib\portable-net45+win8+wpa81\System.Threading.Tasks.Dataflow.dll + + + ..\packages\System.ValueTuple.4.5.0\lib\net461\System.ValueTuple.dll + + + + + + + + + + + + ..\packages\TeximpNet.1.4.3\lib\net40\TeximpNet.dll + + + ..\packages\UsefulCSharpThings.1.7.3\lib\net462\UsefulThings.dll + + + + + Form + + + Form1.cs + + + Form + + + Form2.cs + + + + + + + + + + + Form1.cs + + + Form2.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + Designer + + + + + + + + + + This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}. + + + + \ No newline at end of file diff --git a/VTFXUtil/packages.config b/VTFXUtil/packages.config new file mode 100644 index 0000000..f49ac5f --- /dev/null +++ b/VTFXUtil/packages.config @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/VTFXUtil/vtfxedit_icon.ico b/VTFXUtil/vtfxedit_icon.ico new file mode 100644 index 0000000000000000000000000000000000000000..748815cbe16d02658b56668b50a7eeb40f879eef GIT binary patch literal 193167 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