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 0000000..748815c Binary files /dev/null and b/VTFXUtil/vtfxedit_icon.ico differ