diff --git a/Switch_Toolbox/App.config b/Switch_Toolbox/App.config new file mode 100644 index 00000000..dae4d8c9 --- /dev/null +++ b/Switch_Toolbox/App.config @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/Switch_Toolbox/Assimp32.dll b/Switch_Toolbox/Assimp32.dll new file mode 100644 index 00000000..1f8b10dd Binary files /dev/null and b/Switch_Toolbox/Assimp32.dll differ diff --git a/Switch_Toolbox/Assimp64.dll b/Switch_Toolbox/Assimp64.dll new file mode 100644 index 00000000..fd87b2d1 Binary files /dev/null and b/Switch_Toolbox/Assimp64.dll differ diff --git a/Switch_Toolbox/Config.cs b/Switch_Toolbox/Config.cs new file mode 100644 index 00000000..37886e14 --- /dev/null +++ b/Switch_Toolbox/Config.cs @@ -0,0 +1,125 @@ +using System; +using System.Collections.Generic; +using System.Xml; +using System.Drawing; +using System.IO; +using Switch_Toolbox.Library; + +namespace Switch_Toolbox +{ + //Based on + // https://github.com/jam1garner/Smash-Forge/blob/26e0dcbd84cdf8a4ffe3fbe0b0317520a4099286/Smash%20Forge/Filetypes/Application/Config.cs + class Config + { + public static void StartupFromFile(string fileName) + { + if (!File.Exists(fileName)) + { + Save(); + return; + } + + ReadConfigFromFile(fileName); + } + + private static void ReadConfigFromFile(string fileName) + { + int discordImageKey; + XmlDocument doc = new XmlDocument(); + doc.Load(fileName); + Queue que = new Queue(); + + foreach (XmlNode node in doc.ChildNodes) + que.Enqueue(node); + + while (que.Count > 0) + { + XmlNode node = que.Dequeue(); + + foreach (XmlNode n in node.ChildNodes) + que.Enqueue(n); + + switch (node.Name) + { + case "OpenStartupWindow": + bool.TryParse(node.InnerText, out Runtime.OpenStartupWindow); + break; + case "RenderModels": + bool.TryParse(node.InnerText, out Runtime.RenderModels); + break; + case "RenderModelSelection": + bool.TryParse(node.InnerText, out Runtime.RenderModelSelection); + break; + case "RenderModelWireframe": + bool.TryParse(node.InnerText, out Runtime.RenderModelWireframe); + break; + case "viewportShading": + if (node.ParentNode != null && node.ParentNode.Name.Equals("RENDERSETTINGS")) + Enum.TryParse(node.InnerText, out Runtime.viewportShading); + break; + case "thumbnailSize": + if (node.ParentNode != null && node.ParentNode.Name.Equals("OBJLISTSETTINGS")) + Enum.TryParse(node.InnerText, out Runtime.thumbnailSize); + break; + case "stereoscopy": bool.TryParse(node.InnerText, out Runtime.stereoscopy); + break; + case "CameraFar": + float.TryParse(node.InnerText, out Runtime.CameraFar); + break; + case "CameraNear": + float.TryParse(node.InnerText, out Runtime.CameraNear); + break; + case "PreviewScale": + float.TryParse(node.InnerText, out Runtime.previewScale); + break; + } + } + } + public static void Save() + { + XmlDocument doc = CreateXmlFromSettings(); + doc.Save(MainForm.executableDir + "\\config.xml"); + } + private static XmlDocument CreateXmlFromSettings() + { + XmlDocument doc = new XmlDocument(); + XmlNode mainNode = doc.CreateElement("FORGECONFIG"); + doc.AppendChild(mainNode); + + AppendMainFormSettings(doc, mainNode); + AppendObjectlistSettings(doc, mainNode); + AppendRenderSettings(doc, mainNode); + + return doc; + } + private static void AppendMainFormSettings(XmlDocument doc, XmlNode parentNode) + { + XmlNode mainSettingsNode = doc.CreateElement("MAINFORM"); + parentNode.AppendChild(mainSettingsNode); + mainSettingsNode.AppendChild(createNode(doc, "OpenStartupWindow", Runtime.OpenStartupWindow.ToString())); + } + + private static void AppendObjectlistSettings(XmlDocument doc, XmlNode parentNode) + { + XmlNode objlistSettingsNode = doc.CreateElement("OBJLISTSETTINGS"); + parentNode.AppendChild(objlistSettingsNode); + objlistSettingsNode.AppendChild(createNode(doc, "thumbnailSize", Runtime.thumbnailSize.ToString())); + } + private static void AppendRenderSettings(XmlDocument doc, XmlNode parentNode) + { + XmlNode renderSettingsNode = doc.CreateElement("RENDERSETTINGS"); + parentNode.AppendChild(renderSettingsNode); + renderSettingsNode.AppendChild(createNode(doc, "viewportShading", Runtime.viewportShading.ToString())); + renderSettingsNode.AppendChild(createNode(doc, "stereoscopy", Runtime.stereoscopy.ToString())); + renderSettingsNode.AppendChild(createNode(doc, "CameraFar", Runtime.CameraFar.ToString())); + renderSettingsNode.AppendChild(createNode(doc, "CameraNear", Runtime.CameraNear.ToString())); + renderSettingsNode.AppendChild(createNode(doc, "PreviewScale", Runtime.previewScale.ToString())); + } + public static XmlNode createNode(XmlDocument doc, string el, string v) + { + XmlNode floorstyle = doc.CreateElement(el); + floorstyle.InnerText = v; + return floorstyle; + } + } +} diff --git a/Switch_Toolbox/FodyWeavers.xml b/Switch_Toolbox/FodyWeavers.xml new file mode 100644 index 00000000..d22a8ac3 --- /dev/null +++ b/Switch_Toolbox/FodyWeavers.xml @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/Switch_Toolbox/GUI/Credits.Designer.cs b/Switch_Toolbox/GUI/Credits.Designer.cs new file mode 100644 index 00000000..7fa03a3c --- /dev/null +++ b/Switch_Toolbox/GUI/Credits.Designer.cs @@ -0,0 +1,120 @@ +namespace Switch_Toolbox +{ + partial class CreditsWindow + { + /// + /// 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(CreditsWindow)); + this.label1 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.richTextBox1 = new System.Windows.Forms.RichTextBox(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.SuspendLayout(); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.ForeColor = System.Drawing.Color.White; + this.label1.Location = new System.Drawing.Point(12, 9); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(42, 13); + this.label1.TabIndex = 0; + this.label1.Text = "Credits!"; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.ForeColor = System.Drawing.Color.White; + this.label2.Location = new System.Drawing.Point(12, 36); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(149, 13); + this.label2.TabIndex = 1; + this.label2.Text = "Main Developer: KillzXGaming"; + this.label2.Click += new System.EventHandler(this.label2_Click); + // + // label3 + // + this.label3.AutoSize = true; + this.label3.ForeColor = System.Drawing.Color.White; + this.label3.Location = new System.Drawing.Point(12, 76); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(169, 13); + this.label3.TabIndex = 2; + this.label3.Text = "Special Thanks and Contributions:"; + this.label3.Click += new System.EventHandler(this.label3_Click); + // + // richTextBox1 + // + this.richTextBox1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(50)))), ((int)(((byte)(50)))), ((int)(((byte)(50))))); + this.richTextBox1.BorderStyle = System.Windows.Forms.BorderStyle.None; + this.richTextBox1.ForeColor = System.Drawing.Color.White; + this.richTextBox1.Location = new System.Drawing.Point(15, 107); + this.richTextBox1.Name = "richTextBox1"; + this.richTextBox1.Size = new System.Drawing.Size(414, 311); + this.richTextBox1.TabIndex = 4; + this.richTextBox1.Text = resources.GetString("richTextBox1.Text"); + // + // pictureBox1 + // + this.pictureBox1.Image = global::Switch_Toolbox.Properties.Resources.Logo; + this.pictureBox1.Location = new System.Drawing.Point(327, 12); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.Size = new System.Drawing.Size(108, 89); + this.pictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom; + this.pictureBox1.TabIndex = 5; + this.pictureBox1.TabStop = false; + // + // CreditsWindow + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(45)))), ((int)(((byte)(45)))), ((int)(((byte)(45))))); + this.ClientSize = new System.Drawing.Size(447, 430); + this.Controls.Add(this.pictureBox1); + this.Controls.Add(this.richTextBox1); + this.Controls.Add(this.label3); + this.Controls.Add(this.label2); + this.Controls.Add(this.label1); + this.Name = "CreditsWindow"; + this.Text = "Credits"; + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.RichTextBox richTextBox1; + private System.Windows.Forms.PictureBox pictureBox1; + } +} \ No newline at end of file diff --git a/Switch_Toolbox/GUI/Credits.cs b/Switch_Toolbox/GUI/Credits.cs new file mode 100644 index 00000000..d9c09f91 --- /dev/null +++ b/Switch_Toolbox/GUI/Credits.cs @@ -0,0 +1,35 @@ +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; + +namespace Switch_Toolbox +{ + public partial class CreditsWindow : Form + { + public CreditsWindow() + { + InitializeComponent(); + } + + private void label2_Click(object sender, EventArgs e) + { + + } + + private void label4_Click(object sender, EventArgs e) + { + + } + + private void label3_Click(object sender, EventArgs e) + { + + } + } +} diff --git a/Switch_Toolbox/GUI/Credits.resx b/Switch_Toolbox/GUI/Credits.resx new file mode 100644 index 00000000..94553802 --- /dev/null +++ b/Switch_Toolbox/GUI/Credits.resx @@ -0,0 +1,132 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + - Smash Forge Devs (SMG, Ploaj, jam1garner, smb123w64gb, etc) for some code ported over. Specifically animation stuff and some rendering. +- Assimp devs for their massive asset library! +- Wexos (helped figure out a few things, ie format list to assign each attribute) +- JuPaHe64 for the base 3D renderer. +- Every File Explorer devs (Gericom) for Yaz0 stuff +- Exelix for Byaml, Sarc and KCL library +- Syroot for helpful IO extensions and libraies +- GDK Chan for some DDS decode methods +- AboodXD for BNTX texture swizzling +- MelonSpeedruns for logo. + + \ No newline at end of file diff --git a/Switch_Toolbox/GUI/PluginManager.Designer.cs b/Switch_Toolbox/GUI/PluginManager.Designer.cs new file mode 100644 index 00000000..de9b659d --- /dev/null +++ b/Switch_Toolbox/GUI/PluginManager.Designer.cs @@ -0,0 +1,90 @@ +namespace Switch_Toolbox +{ + partial class PluginManager + { + /// + /// 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(); + this.listView1 = new System.Windows.Forms.ListView(); + this.Plugin = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.Version = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.imageList1 = new System.Windows.Forms.ImageList(this.components); + this.SuspendLayout(); + // + // listView1 + // + this.listView1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(64)))), ((int)(((byte)(64)))), ((int)(((byte)(64))))); + this.listView1.BorderStyle = System.Windows.Forms.BorderStyle.None; + this.listView1.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.Plugin, + this.Version}); + this.listView1.Dock = System.Windows.Forms.DockStyle.Fill; + this.listView1.ForeColor = System.Drawing.Color.White; + this.listView1.Location = new System.Drawing.Point(0, 0); + this.listView1.Name = "listView1"; + this.listView1.Size = new System.Drawing.Size(292, 356); + this.listView1.TabIndex = 0; + this.listView1.UseCompatibleStateImageBehavior = false; + this.listView1.View = System.Windows.Forms.View.List; + // + // Plugin + // + this.Plugin.Text = "Plugin"; + this.Plugin.Width = 113; + // + // Version + // + this.Version.Text = "Version"; + this.Version.Width = 175; + // + // imageList1 + // + this.imageList1.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit; + this.imageList1.ImageSize = new System.Drawing.Size(16, 16); + this.imageList1.TransparentColor = System.Drawing.Color.Transparent; + // + // PluginManager + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(64)))), ((int)(((byte)(64)))), ((int)(((byte)(64))))); + this.ClientSize = new System.Drawing.Size(292, 356); + this.Controls.Add(this.listView1); + this.Name = "PluginManager"; + this.Text = "PluginManager"; + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.ListView listView1; + private System.Windows.Forms.ColumnHeader Plugin; + private System.Windows.Forms.ColumnHeader Version; + private System.Windows.Forms.ImageList imageList1; + } +} \ No newline at end of file diff --git a/Switch_Toolbox/GUI/PluginManager.cs b/Switch_Toolbox/GUI/PluginManager.cs new file mode 100644 index 00000000..ab9590ea --- /dev/null +++ b/Switch_Toolbox/GUI/PluginManager.cs @@ -0,0 +1,35 @@ +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; +using Switch_Toolbox.Library; + +namespace Switch_Toolbox +{ + public partial class PluginManager : Form + { + public PluginManager() + { + InitializeComponent(); + imageList1.Images.Add("DLL", System.Drawing.SystemIcons.Question.ToBitmap()); + imageList1.ImageSize = new Size(24, 24); + listView1.FullRowSelect = true; + listView1.SmallImageList = imageList1; + + + foreach (var plugin in GenericPluginLoader._Plugins) + { + ListViewItem item = new ListViewItem(); + item.Text = plugin.Key; + item.ImageKey = "DLL"; + item.SubItems.Add(plugin.Value.Version); + listView1.Items.Add(item); + } + } + } +} diff --git a/Switch_Toolbox/GUI/PluginManager.resx b/Switch_Toolbox/GUI/PluginManager.resx new file mode 100644 index 00000000..9266b25f --- /dev/null +++ b/Switch_Toolbox/GUI/PluginManager.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + \ No newline at end of file diff --git a/Switch_Toolbox/GUI/Settings.Designer.cs b/Switch_Toolbox/GUI/Settings.Designer.cs new file mode 100644 index 00000000..444bbd83 --- /dev/null +++ b/Switch_Toolbox/GUI/Settings.Designer.cs @@ -0,0 +1,408 @@ +namespace Switch_Toolbox +{ + partial class Settings + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.label1 = new System.Windows.Forms.Label(); + this.chkBoxSpecular = new System.Windows.Forms.CheckBox(); + this.chkBoxNormalMap = new System.Windows.Forms.CheckBox(); + this.shadingComboBox = new System.Windows.Forms.ComboBox(); + this.panel2 = new System.Windows.Forms.Panel(); + this.chkBoxDisplayPolyCount = new System.Windows.Forms.CheckBox(); + this.label5 = new System.Windows.Forms.Label(); + this.camFarNumUD = new System.Windows.Forms.NumericUpDown(); + this.label4 = new System.Windows.Forms.Label(); + this.camNearNumUD = new System.Windows.Forms.NumericUpDown(); + this.label3 = new System.Windows.Forms.Label(); + this.camMoveComboBox = new System.Windows.Forms.ComboBox(); + this.chkBoxDisplayBones = new System.Windows.Forms.CheckBox(); + this.chkBoxDisplayWireframe = new System.Windows.Forms.CheckBox(); + this.chkBoxDisplayModels = new System.Windows.Forms.CheckBox(); + this.chkBoxStereoscopy = new System.Windows.Forms.CheckBox(); + this.label2 = new System.Windows.Forms.Label(); + this.panel1 = new System.Windows.Forms.Panel(); + this.GLSLVerLabel = new System.Windows.Forms.Label(); + this.openGLVerLabel = new System.Windows.Forms.Label(); + this.btnSave = new System.Windows.Forms.Button(); + this.label6 = new System.Windows.Forms.Label(); + this.previewScaleUD = new System.Windows.Forms.NumericUpDown(); + this.panel2.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.camFarNumUD)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.camNearNumUD)).BeginInit(); + this.panel1.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.previewScaleUD)).BeginInit(); + this.SuspendLayout(); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.ForeColor = System.Drawing.Color.White; + this.label1.Location = new System.Drawing.Point(255, 55); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(90, 13); + this.label1.TabIndex = 0; + this.label1.Text = "Viewport Shading"; + // + // chkBoxSpecular + // + this.chkBoxSpecular.AutoSize = true; + this.chkBoxSpecular.ForeColor = System.Drawing.Color.White; + this.chkBoxSpecular.Location = new System.Drawing.Point(258, 116); + this.chkBoxSpecular.Name = "chkBoxSpecular"; + this.chkBoxSpecular.Size = new System.Drawing.Size(104, 17); + this.chkBoxSpecular.TabIndex = 3; + this.chkBoxSpecular.Text = "Enable Specular"; + this.chkBoxSpecular.UseVisualStyleBackColor = true; + // + // chkBoxNormalMap + // + this.chkBoxNormalMap.AutoSize = true; + this.chkBoxNormalMap.ForeColor = System.Drawing.Color.White; + this.chkBoxNormalMap.Location = new System.Drawing.Point(258, 93); + this.chkBoxNormalMap.Name = "chkBoxNormalMap"; + this.chkBoxNormalMap.Size = new System.Drawing.Size(124, 17); + this.chkBoxNormalMap.TabIndex = 2; + this.chkBoxNormalMap.Text = "Enable Normal Maps"; + this.chkBoxNormalMap.UseVisualStyleBackColor = true; + this.chkBoxNormalMap.CheckedChanged += new System.EventHandler(this.checkBox1_CheckedChanged); + // + // shadingComboBox + // + this.shadingComboBox.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(64)))), ((int)(((byte)(64)))), ((int)(((byte)(64))))); + this.shadingComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.shadingComboBox.ForeColor = System.Drawing.Color.White; + this.shadingComboBox.FormattingEnabled = true; + this.shadingComboBox.Location = new System.Drawing.Point(351, 52); + this.shadingComboBox.Name = "shadingComboBox"; + this.shadingComboBox.Size = new System.Drawing.Size(165, 21); + this.shadingComboBox.TabIndex = 1; + this.shadingComboBox.SelectedIndexChanged += new System.EventHandler(this.shadingComboBox_SelectedIndexChanged); + // + // panel2 + // + this.panel2.Controls.Add(this.label6); + this.panel2.Controls.Add(this.previewScaleUD); + this.panel2.Controls.Add(this.chkBoxDisplayPolyCount); + this.panel2.Controls.Add(this.label5); + this.panel2.Controls.Add(this.camFarNumUD); + this.panel2.Controls.Add(this.label4); + this.panel2.Controls.Add(this.camNearNumUD); + this.panel2.Controls.Add(this.label3); + this.panel2.Controls.Add(this.chkBoxSpecular); + this.panel2.Controls.Add(this.camMoveComboBox); + this.panel2.Controls.Add(this.chkBoxNormalMap); + this.panel2.Controls.Add(this.chkBoxDisplayBones); + this.panel2.Controls.Add(this.shadingComboBox); + this.panel2.Controls.Add(this.chkBoxDisplayWireframe); + this.panel2.Controls.Add(this.label1); + this.panel2.Controls.Add(this.chkBoxDisplayModels); + this.panel2.Controls.Add(this.chkBoxStereoscopy); + this.panel2.Controls.Add(this.label2); + this.panel2.Location = new System.Drawing.Point(12, 156); + this.panel2.Name = "panel2"; + this.panel2.Size = new System.Drawing.Size(534, 246); + this.panel2.TabIndex = 4; + // + // chkBoxDisplayPolyCount + // + this.chkBoxDisplayPolyCount.AutoSize = true; + this.chkBoxDisplayPolyCount.ForeColor = System.Drawing.Color.White; + this.chkBoxDisplayPolyCount.Location = new System.Drawing.Point(120, 162); + this.chkBoxDisplayPolyCount.Name = "chkBoxDisplayPolyCount"; + this.chkBoxDisplayPolyCount.Size = new System.Drawing.Size(114, 17); + this.chkBoxDisplayPolyCount.TabIndex = 13; + this.chkBoxDisplayPolyCount.Text = "Display Poly Count"; + this.chkBoxDisplayPolyCount.UseVisualStyleBackColor = true; + this.chkBoxDisplayPolyCount.CheckedChanged += new System.EventHandler(this.chkBoxDisplayPolyCount_CheckedChanged); + // + // label5 + // + this.label5.AutoSize = true; + this.label5.ForeColor = System.Drawing.Color.White; + this.label5.Location = new System.Drawing.Point(10, 222); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(61, 13); + this.label5.TabIndex = 12; + this.label5.Text = "Camera Far"; + // + // camFarNumUD + // + this.camFarNumUD.DecimalPlaces = 3; + this.camFarNumUD.Location = new System.Drawing.Point(110, 220); + this.camFarNumUD.Maximum = new decimal(new int[] { + 1316134912, + 2328, + 0, + 0}); + this.camFarNumUD.Name = "camFarNumUD"; + this.camFarNumUD.Size = new System.Drawing.Size(171, 20); + this.camFarNumUD.TabIndex = 11; + this.camFarNumUD.ValueChanged += new System.EventHandler(this.camFarNumUD_ValueChanged); + // + // label4 + // + this.label4.AutoSize = true; + this.label4.ForeColor = System.Drawing.Color.White; + this.label4.Location = new System.Drawing.Point(10, 196); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(69, 13); + this.label4.TabIndex = 10; + this.label4.Text = "Camera Near"; + // + // camNearNumUD + // + this.camNearNumUD.DecimalPlaces = 3; + this.camNearNumUD.Increment = new decimal(new int[] { + 5, + 0, + 0, + 131072}); + this.camNearNumUD.Location = new System.Drawing.Point(110, 194); + this.camNearNumUD.Maximum = new decimal(new int[] { + 1, + 0, + 0, + 0}); + this.camNearNumUD.Minimum = new decimal(new int[] { + 1, + 0, + 0, + 65536}); + this.camNearNumUD.Name = "camNearNumUD"; + this.camNearNumUD.Size = new System.Drawing.Size(171, 20); + this.camNearNumUD.TabIndex = 9; + this.camNearNumUD.Value = new decimal(new int[] { + 1, + 0, + 0, + 65536}); + this.camNearNumUD.ValueChanged += new System.EventHandler(this.camNearNumUD_ValueChanged); + // + // label3 + // + this.label3.AutoSize = true; + this.label3.ForeColor = System.Drawing.Color.White; + this.label3.Location = new System.Drawing.Point(3, 55); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(43, 13); + this.label3.TabIndex = 8; + this.label3.Text = "Camera"; + // + // camMoveComboBox + // + this.camMoveComboBox.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(64)))), ((int)(((byte)(64)))), ((int)(((byte)(64))))); + this.camMoveComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.camMoveComboBox.ForeColor = System.Drawing.Color.White; + this.camMoveComboBox.FormattingEnabled = true; + this.camMoveComboBox.Location = new System.Drawing.Point(59, 52); + this.camMoveComboBox.Name = "camMoveComboBox"; + this.camMoveComboBox.Size = new System.Drawing.Size(156, 21); + this.camMoveComboBox.TabIndex = 4; + this.camMoveComboBox.SelectedIndexChanged += new System.EventHandler(this.camMoveComboBox_SelectedIndexChanged); + // + // chkBoxDisplayBones + // + this.chkBoxDisplayBones.AutoSize = true; + this.chkBoxDisplayBones.ForeColor = System.Drawing.Color.White; + this.chkBoxDisplayBones.Location = new System.Drawing.Point(6, 162); + this.chkBoxDisplayBones.Name = "chkBoxDisplayBones"; + this.chkBoxDisplayBones.Size = new System.Drawing.Size(93, 17); + this.chkBoxDisplayBones.TabIndex = 7; + this.chkBoxDisplayBones.Text = "Display Bones"; + this.chkBoxDisplayBones.UseVisualStyleBackColor = true; + // + // chkBoxDisplayWireframe + // + this.chkBoxDisplayWireframe.AutoSize = true; + this.chkBoxDisplayWireframe.ForeColor = System.Drawing.Color.White; + this.chkBoxDisplayWireframe.Location = new System.Drawing.Point(6, 139); + this.chkBoxDisplayWireframe.Name = "chkBoxDisplayWireframe"; + this.chkBoxDisplayWireframe.Size = new System.Drawing.Size(111, 17); + this.chkBoxDisplayWireframe.TabIndex = 6; + this.chkBoxDisplayWireframe.Text = "Display Wireframe"; + this.chkBoxDisplayWireframe.UseVisualStyleBackColor = true; + this.chkBoxDisplayWireframe.CheckedChanged += new System.EventHandler(this.chkBoxDisplayWireframe_CheckedChanged); + // + // chkBoxDisplayModels + // + this.chkBoxDisplayModels.AutoSize = true; + this.chkBoxDisplayModels.ForeColor = System.Drawing.Color.White; + this.chkBoxDisplayModels.Location = new System.Drawing.Point(6, 116); + this.chkBoxDisplayModels.Name = "chkBoxDisplayModels"; + this.chkBoxDisplayModels.Size = new System.Drawing.Size(97, 17); + this.chkBoxDisplayModels.TabIndex = 5; + this.chkBoxDisplayModels.Text = "Display Models"; + this.chkBoxDisplayModels.UseVisualStyleBackColor = true; + this.chkBoxDisplayModels.CheckedChanged += new System.EventHandler(this.chkBoxDisplayModels_CheckedChanged); + // + // chkBoxStereoscopy + // + this.chkBoxStereoscopy.AutoSize = true; + this.chkBoxStereoscopy.ForeColor = System.Drawing.Color.White; + this.chkBoxStereoscopy.Location = new System.Drawing.Point(6, 93); + this.chkBoxStereoscopy.Name = "chkBoxStereoscopy"; + this.chkBoxStereoscopy.Size = new System.Drawing.Size(121, 17); + this.chkBoxStereoscopy.TabIndex = 4; + this.chkBoxStereoscopy.Text = "Enable Stereoscopy"; + this.chkBoxStereoscopy.UseVisualStyleBackColor = true; + this.chkBoxStereoscopy.CheckedChanged += new System.EventHandler(this.checkBox1_CheckedChanged_1); + // + // label2 + // + this.label2.AutoSize = true; + this.label2.ForeColor = System.Drawing.Color.White; + this.label2.Location = new System.Drawing.Point(56, 21); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(89, 13); + this.label2.TabIndex = 4; + this.label2.Text = "Viewport Settings"; + // + // panel1 + // + this.panel1.Controls.Add(this.GLSLVerLabel); + this.panel1.Controls.Add(this.openGLVerLabel); + this.panel1.Location = new System.Drawing.Point(12, 13); + this.panel1.Name = "panel1"; + this.panel1.Size = new System.Drawing.Size(534, 137); + this.panel1.TabIndex = 5; + // + // GLSLVerLabel + // + this.GLSLVerLabel.AutoSize = true; + this.GLSLVerLabel.ForeColor = System.Drawing.Color.White; + this.GLSLVerLabel.Location = new System.Drawing.Point(3, 38); + this.GLSLVerLabel.Name = "GLSLVerLabel"; + this.GLSLVerLabel.Size = new System.Drawing.Size(72, 13); + this.GLSLVerLabel.TabIndex = 10; + this.GLSLVerLabel.Text = "GLSL Version"; + // + // openGLVerLabel + // + this.openGLVerLabel.AutoSize = true; + this.openGLVerLabel.ForeColor = System.Drawing.Color.White; + this.openGLVerLabel.Location = new System.Drawing.Point(3, 13); + this.openGLVerLabel.Name = "openGLVerLabel"; + this.openGLVerLabel.Size = new System.Drawing.Size(91, 13); + this.openGLVerLabel.TabIndex = 9; + this.openGLVerLabel.Text = "Open GL Version:"; + // + // btnSave + // + this.btnSave.Location = new System.Drawing.Point(397, 408); + this.btnSave.Name = "btnSave"; + this.btnSave.Size = new System.Drawing.Size(149, 23); + this.btnSave.TabIndex = 6; + this.btnSave.Text = "Save"; + this.btnSave.UseVisualStyleBackColor = true; + this.btnSave.Click += new System.EventHandler(this.btnSave_Click); + // + // label6 + // + this.label6.AutoSize = true; + this.label6.ForeColor = System.Drawing.Color.White; + this.label6.Location = new System.Drawing.Point(285, 196); + this.label6.Name = "label6"; + this.label6.Size = new System.Drawing.Size(75, 13); + this.label6.TabIndex = 15; + this.label6.Text = "Preview Scale"; + // + // previewScaleUD + // + this.previewScaleUD.DecimalPlaces = 3; + this.previewScaleUD.Increment = new decimal(new int[] { + 1, + 0, + 0, + 131072}); + this.previewScaleUD.Location = new System.Drawing.Point(363, 194); + this.previewScaleUD.Minimum = new decimal(new int[] { + 1, + 0, + 0, + 131072}); + this.previewScaleUD.Name = "previewScaleUD"; + this.previewScaleUD.Size = new System.Drawing.Size(171, 20); + this.previewScaleUD.TabIndex = 14; + this.previewScaleUD.Value = new decimal(new int[] { + 1, + 0, + 0, + 65536}); + this.previewScaleUD.ValueChanged += new System.EventHandler(this.numericUpDown1_ValueChanged); + // + // Settings + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(40)))), ((int)(((byte)(40)))), ((int)(((byte)(40))))); + this.ClientSize = new System.Drawing.Size(551, 443); + this.Controls.Add(this.btnSave); + this.Controls.Add(this.panel1); + this.Controls.Add(this.panel2); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.Name = "Settings"; + this.Text = "Settings"; + this.Load += new System.EventHandler(this.Settings_Load); + this.panel2.ResumeLayout(false); + this.panel2.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.camFarNumUD)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.camNearNumUD)).EndInit(); + this.panel1.ResumeLayout(false); + this.panel1.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.previewScaleUD)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Label label1; + private System.Windows.Forms.CheckBox chkBoxSpecular; + private System.Windows.Forms.CheckBox chkBoxNormalMap; + private System.Windows.Forms.ComboBox shadingComboBox; + private System.Windows.Forms.Panel panel2; + private System.Windows.Forms.CheckBox chkBoxStereoscopy; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.CheckBox chkBoxDisplayBones; + private System.Windows.Forms.CheckBox chkBoxDisplayWireframe; + private System.Windows.Forms.CheckBox chkBoxDisplayModels; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.ComboBox camMoveComboBox; + private System.Windows.Forms.Panel panel1; + private System.Windows.Forms.Label openGLVerLabel; + private System.Windows.Forms.Label GLSLVerLabel; + private System.Windows.Forms.Button btnSave; + private System.Windows.Forms.Label label5; + private System.Windows.Forms.NumericUpDown camFarNumUD; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.NumericUpDown camNearNumUD; + private System.Windows.Forms.CheckBox chkBoxDisplayPolyCount; + private System.Windows.Forms.Label label6; + private System.Windows.Forms.NumericUpDown previewScaleUD; + } +} \ No newline at end of file diff --git a/Switch_Toolbox/GUI/Settings.cs b/Switch_Toolbox/GUI/Settings.cs new file mode 100644 index 00000000..1cb46bd9 --- /dev/null +++ b/Switch_Toolbox/GUI/Settings.cs @@ -0,0 +1,131 @@ +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; +using Switch_Toolbox.Library; +using WeifenLuo.WinFormsUI.Docking; +using GL_Core; +using GL_Core.Public_Interfaces; +using GL_Core.Cameras; + +namespace Switch_Toolbox +{ + public partial class Settings : Form + { + MainForm mainForm; + + public Settings(MainForm main) + { + mainForm = main; + + InitializeComponent(); + + foreach (Runtime.ViewportShading shading in Enum.GetValues(typeof(Runtime.ViewportShading))) + { + shadingComboBox.Items.Add(shading.ToString()); + } + foreach (Runtime.CameraMovement shading in Enum.GetValues(typeof(Runtime.CameraMovement))) + { + camMoveComboBox.Items.Add(shading.ToString()); + } + + chkBoxNormalMap.Checked = Runtime.useNormalMap; + chkBoxDisplayModels.Checked = Runtime.RenderModels; + chkBoxDisplayWireframe.Checked = Runtime.RenderModelWireframe; + chkBoxSpecular.Checked = Runtime.renderSpecular; + chkBoxStereoscopy.Checked = Runtime.stereoscopy; + chkBoxDisplayPolyCount.Checked = Runtime.DisplayPolyCount; + camNearNumUD.Value = (decimal)Runtime.CameraNear; + camFarNumUD.Value = (decimal)Runtime.CameraFar; + previewScaleUD.Value = (decimal)Runtime.previewScale; + + GLSLVerLabel.Text = $"Open GL Version: {Runtime.GLSLVersion}"; + openGLVerLabel.Text = $"GLSL Version: {Runtime.openGLVersion}"; + + shadingComboBox.SelectedIndex = (int)Runtime.viewportShading; + camMoveComboBox.SelectedIndex = (int)Runtime.cameraMovement; + } + + private void shadingComboBox_SelectedIndexChanged(object sender, EventArgs e) + { + Runtime.viewportShading = (Runtime.ViewportShading)shadingComboBox.SelectedIndex; + Viewport.Instance.UpdateViewport(); + } + + private void checkBox1_CheckedChanged(object sender, EventArgs e) + { + Runtime.useNormalMap = chkBoxNormalMap.Checked; + Viewport.Instance.UpdateViewport(); + } + + private void chkBoxDisplayModels_CheckedChanged(object sender, EventArgs e) + { + Runtime.RenderModels = chkBoxDisplayModels.Checked; + Viewport.Instance.UpdateViewport(); + } + + private void chkBoxDisplayWireframe_CheckedChanged(object sender, EventArgs e) + { + Runtime.RenderModelWireframe = chkBoxDisplayWireframe.Checked; + Viewport.Instance.LoadViewportRuntimeValues(); + Viewport.Instance.UpdateViewport(); + } + + private void camMoveComboBox_SelectedIndexChanged(object sender, EventArgs e) + { + Runtime.cameraMovement = (Runtime.CameraMovement)camMoveComboBox.SelectedIndex; + Viewport.Instance.LoadViewportRuntimeValues(); + Viewport.Instance.UpdateViewport(); + } + + private void checkBox1_CheckedChanged_1(object sender, EventArgs e) + { + Runtime.stereoscopy = chkBoxStereoscopy.Checked; + Viewport.Instance.LoadViewportRuntimeValues(); + Viewport.Instance.UpdateViewport(); + } + private void camNearNumUD_ValueChanged(object sender, EventArgs e) + { + Runtime.CameraNear = (float)camNearNumUD.Value; + Viewport.Instance.LoadViewportRuntimeValues(); + Viewport.Instance.UpdateViewport(); + } + + private void camFarNumUD_ValueChanged(object sender, EventArgs e) + { + Runtime.CameraFar = (float)camFarNumUD.Value; + Viewport.Instance.LoadViewportRuntimeValues(); + Viewport.Instance.UpdateViewport(); + } + + private void btnSave_Click(object sender, EventArgs e) + { + Viewport.Instance.UpdateViewport(); + + Config.Save(); + this.Close(); + } + + private void chkBoxDisplayPolyCount_CheckedChanged(object sender, EventArgs e) + { + Runtime.DisplayPolyCount = chkBoxDisplayPolyCount.Checked; + } + + private void Settings_Load(object sender, EventArgs e) + { + + } + + private void numericUpDown1_ValueChanged(object sender, EventArgs e) + { + Runtime.previewScale = (float)previewScaleUD.Value; + Viewport.Instance.LoadViewportRuntimeValues(); + Viewport.Instance.UpdateViewport(); + } + } +} diff --git a/Switch_Toolbox/GUI/Settings.resx b/Switch_Toolbox/GUI/Settings.resx new file mode 100644 index 00000000..1af7de15 --- /dev/null +++ b/Switch_Toolbox/GUI/Settings.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Switch_Toolbox/GUI/Startup Window.Designer.cs b/Switch_Toolbox/GUI/Startup Window.Designer.cs new file mode 100644 index 00000000..27706eb8 --- /dev/null +++ b/Switch_Toolbox/GUI/Startup Window.Designer.cs @@ -0,0 +1,141 @@ +namespace Switch_Toolbox +{ + partial class Startup_Window + { + /// + /// 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.checkBox1 = new System.Windows.Forms.CheckBox(); + this.richTextBox1 = new System.Windows.Forms.RichTextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.listView1 = new System.Windows.Forms.ListView(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.SuspendLayout(); + // + // checkBox1 + // + this.checkBox1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left))); + this.checkBox1.AutoSize = true; + this.checkBox1.Location = new System.Drawing.Point(12, 364); + this.checkBox1.Name = "checkBox1"; + this.checkBox1.Size = new System.Drawing.Size(127, 17); + this.checkBox1.TabIndex = 0; + this.checkBox1.Text = "Don\'t show this again"; + this.checkBox1.UseVisualStyleBackColor = true; + this.checkBox1.CheckedChanged += new System.EventHandler(this.checkBox1_CheckedChanged); + // + // richTextBox1 + // + this.richTextBox1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.richTextBox1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(55)))), ((int)(((byte)(55)))), ((int)(((byte)(55))))); + this.richTextBox1.BorderStyle = System.Windows.Forms.BorderStyle.None; + this.richTextBox1.ForeColor = System.Drawing.Color.White; + this.richTextBox1.Location = new System.Drawing.Point(12, 25); + this.richTextBox1.Name = "richTextBox1"; + this.richTextBox1.ReadOnly = true; + this.richTextBox1.Size = new System.Drawing.Size(590, 86); + this.richTextBox1.TabIndex = 1; + this.richTextBox1.Text = ""; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(13, 6); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(59, 13); + this.label1.TabIndex = 2; + this.label1.Text = "Useful tips!"; + // + // label2 + // + this.label2.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left))); + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(9, 123); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(137, 13); + this.label2.TabIndex = 3; + this.label2.Text = "Recent (Not Working ATM)"; + // + // listView1 + // + this.listView1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.listView1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(55)))), ((int)(((byte)(55)))), ((int)(((byte)(55))))); + this.listView1.BorderStyle = System.Windows.Forms.BorderStyle.None; + this.listView1.ForeColor = System.Drawing.Color.White; + this.listView1.Location = new System.Drawing.Point(12, 140); + this.listView1.Name = "listView1"; + this.listView1.Size = new System.Drawing.Size(694, 218); + this.listView1.TabIndex = 4; + this.listView1.UseCompatibleStateImageBehavior = false; + this.listView1.MouseClick += new System.Windows.Forms.MouseEventHandler(this.listView1_MouseClick); + // + // pictureBox1 + // + this.pictureBox1.Image = global::Switch_Toolbox.Properties.Resources.Logo; + this.pictureBox1.Location = new System.Drawing.Point(608, 25); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.Size = new System.Drawing.Size(98, 86); + this.pictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom; + this.pictureBox1.TabIndex = 5; + this.pictureBox1.TabStop = false; + // + // Startup_Window + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(64)))), ((int)(((byte)(64)))), ((int)(((byte)(64))))); + this.ClientSize = new System.Drawing.Size(718, 393); + this.Controls.Add(this.pictureBox1); + this.Controls.Add(this.listView1); + this.Controls.Add(this.label2); + this.Controls.Add(this.label1); + this.Controls.Add(this.richTextBox1); + this.Controls.Add(this.checkBox1); + this.ForeColor = System.Drawing.Color.White; + this.Name = "Startup_Window"; + this.Text = "Startup"; + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.CheckBox checkBox1; + private System.Windows.Forms.RichTextBox richTextBox1; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.ListView listView1; + private System.Windows.Forms.PictureBox pictureBox1; + } +} \ No newline at end of file diff --git a/Switch_Toolbox/GUI/Startup Window.cs b/Switch_Toolbox/GUI/Startup Window.cs new file mode 100644 index 00000000..0c3bf4ef --- /dev/null +++ b/Switch_Toolbox/GUI/Startup Window.cs @@ -0,0 +1,52 @@ +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; +using Switch_Toolbox.Library; + +namespace Switch_Toolbox +{ + public partial class Startup_Window : Form + { + public Startup_Window() + { + InitializeComponent(); + + CreateTipList(); + richTextBox1.Text = GetRandomTip(); + } + List Tips = new List(); + private void CreateTipList() + { + Tips.Add("You can view every model and texture in a .bea file by right clicking it in the tree and clicking ''Preview''."); + Tips.Add("Bfres materials have an option to be copied when right clicked on. Use this to easily transfer new materials!"); + Tips.Add("Most sections in a bfres can be exported and replaced!"); + Tips.Add("For MK8D and Splatoon 2, in the material editor, if the gsys_pass in render info is set to seal on an object ontop of another, you can prevent z fighting!"); + } + private string GetRandomTip() + { + var shuffledTips = Tips.OrderBy(a => Guid.NewGuid()).ToList(); + return shuffledTips[0]; + } + + private void checkBox1_CheckedChanged(object sender, EventArgs e) + { + Runtime.OpenStartupWindow = !checkBox1.Checked; + Config.Save(); + } + + private void listView1_MouseClick(object sender, MouseEventArgs e) + { + if (listView1.SelectedItems.Count > 0) + { + string fileName = listView1.SelectedItems[0].Text; + Close(); + } + } + } +} diff --git a/Switch_Toolbox/GUI/Startup Window.resx b/Switch_Toolbox/GUI/Startup Window.resx new file mode 100644 index 00000000..1af7de15 --- /dev/null +++ b/Switch_Toolbox/GUI/Startup Window.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Switch_Toolbox/Lib/AssimpNet.dll b/Switch_Toolbox/Lib/AssimpNet.dll new file mode 100644 index 00000000..bc6a8c7a Binary files /dev/null and b/Switch_Toolbox/Lib/AssimpNet.dll differ diff --git a/Switch_Toolbox/Lib/AssimpNet.pdb b/Switch_Toolbox/Lib/AssimpNet.pdb new file mode 100644 index 00000000..9927f61c Binary files /dev/null and b/Switch_Toolbox/Lib/AssimpNet.pdb differ diff --git a/Switch_Toolbox/Lib/BarsLibrary.dll b/Switch_Toolbox/Lib/BarsLibrary.dll new file mode 100644 index 00000000..3bb7dc27 Binary files /dev/null and b/Switch_Toolbox/Lib/BarsLibrary.dll differ diff --git a/Switch_Toolbox/Lib/BezelEngineArchive_Lib.dll b/Switch_Toolbox/Lib/BezelEngineArchive_Lib.dll new file mode 100644 index 00000000..f2e84734 Binary files /dev/null and b/Switch_Toolbox/Lib/BezelEngineArchive_Lib.dll differ diff --git a/Switch_Toolbox/Lib/ByamlExt.dll b/Switch_Toolbox/Lib/ByamlExt.dll new file mode 100644 index 00000000..31156b68 Binary files /dev/null and b/Switch_Toolbox/Lib/ByamlExt.dll differ diff --git a/Switch_Toolbox/Lib/Costura.dll b/Switch_Toolbox/Lib/Costura.dll new file mode 100644 index 00000000..a04e747c Binary files /dev/null and b/Switch_Toolbox/Lib/Costura.dll differ diff --git a/Switch_Toolbox/Lib/CsvHelper.dll b/Switch_Toolbox/Lib/CsvHelper.dll new file mode 100644 index 00000000..d0b3eb74 Binary files /dev/null and b/Switch_Toolbox/Lib/CsvHelper.dll differ diff --git a/Switch_Toolbox/Lib/EditorCoreCommon.dll b/Switch_Toolbox/Lib/EditorCoreCommon.dll new file mode 100644 index 00000000..6ad18a75 Binary files /dev/null and b/Switch_Toolbox/Lib/EditorCoreCommon.dll differ diff --git a/Switch_Toolbox/Lib/GL_Core.dll b/Switch_Toolbox/Lib/GL_Core.dll new file mode 100644 index 00000000..46d9745b Binary files /dev/null and b/Switch_Toolbox/Lib/GL_Core.dll differ diff --git a/Switch_Toolbox/Lib/Licenses/Assimp COPYRIGHT.txt b/Switch_Toolbox/Lib/Licenses/Assimp COPYRIGHT.txt new file mode 100644 index 00000000..8e72449f --- /dev/null +++ b/Switch_Toolbox/Lib/Licenses/Assimp COPYRIGHT.txt @@ -0,0 +1,78 @@ +Open Asset Import Library (assimp) + +Copyright (c) 2006-2016, assimp team +All rights reserved. + +Redistribution and use of this software in source and binary forms, +with or without modification, are permitted provided that the +following conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of the assimp team, nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission of the assimp team. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + + +****************************************************************************** + +AN EXCEPTION applies to all files in the ./test/models-nonbsd folder. +These are 3d models for testing purposes, from various free sources +on the internet. They are - unless otherwise stated - copyright of +their respective creators, which may impose additional requirements +on the use of their work. For any of these models, see +.source.txt for more legal information. Contact us if you +are a copyright holder and believe that we credited you inproperly or +if you don't want your files to appear in the repository. + + +****************************************************************************** + +Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors +http://code.google.com/p/poly2tri/ + +All rights reserved. +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. +* Neither the name of Poly2Tri nor the names of its contributors may be + used to endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/Switch_Toolbox/Lib/Licenses/SFGraphics COPYRIGHT.txt b/Switch_Toolbox/Lib/Licenses/SFGraphics COPYRIGHT.txt new file mode 100644 index 00000000..7583cfb6 --- /dev/null +++ b/Switch_Toolbox/Lib/Licenses/SFGraphics COPYRIGHT.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 SMG + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/Switch_Toolbox/Lib/Licenses/SmashForge COPYRIGHT.txt b/Switch_Toolbox/Lib/Licenses/SmashForge COPYRIGHT.txt new file mode 100644 index 00000000..0ddd215e --- /dev/null +++ b/Switch_Toolbox/Lib/Licenses/SmashForge COPYRIGHT.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2016 jam1garner + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/Switch_Toolbox/Lib/Licenses/ZSTD NET COPYRIGHT.txt b/Switch_Toolbox/Lib/Licenses/ZSTD NET COPYRIGHT.txt new file mode 100644 index 00000000..24282a4e --- /dev/null +++ b/Switch_Toolbox/Lib/Licenses/ZSTD NET COPYRIGHT.txt @@ -0,0 +1,30 @@ +BSD License + +For ZstdNet software + +Copyright (c) 2016-2018, SKB Kontur. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + * Neither the name SKB Kontur nor the names of its contributors may be used to + endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/Switch_Toolbox/Lib/NAudio.dll b/Switch_Toolbox/Lib/NAudio.dll new file mode 100644 index 00000000..9425d402 Binary files /dev/null and b/Switch_Toolbox/Lib/NAudio.dll differ diff --git a/Switch_Toolbox/Lib/Octokit.dll b/Switch_Toolbox/Lib/Octokit.dll new file mode 100644 index 00000000..66990897 Binary files /dev/null and b/Switch_Toolbox/Lib/Octokit.dll differ diff --git a/Switch_Toolbox/Lib/OpenTK.GLControl.dll b/Switch_Toolbox/Lib/OpenTK.GLControl.dll new file mode 100644 index 00000000..9d928cfb Binary files /dev/null and b/Switch_Toolbox/Lib/OpenTK.GLControl.dll differ diff --git a/Switch_Toolbox/Lib/OpenTK.dll b/Switch_Toolbox/Lib/OpenTK.dll new file mode 100644 index 00000000..52feb21b Binary files /dev/null and b/Switch_Toolbox/Lib/OpenTK.dll differ diff --git a/Switch_Toolbox/Lib/Plugins/Blank.txt b/Switch_Toolbox/Lib/Plugins/Blank.txt new file mode 100644 index 00000000..5f282702 --- /dev/null +++ b/Switch_Toolbox/Lib/Plugins/Blank.txt @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Switch_Toolbox/Lib/README.txt b/Switch_Toolbox/Lib/README.txt new file mode 100644 index 00000000..0aa0c612 --- /dev/null +++ b/Switch_Toolbox/Lib/README.txt @@ -0,0 +1 @@ +Note if you hae an issue with your libray being in this repo please contact me and i will remove it!. \ No newline at end of file diff --git a/Switch_Toolbox/Lib/SARCExt.dll b/Switch_Toolbox/Lib/SARCExt.dll new file mode 100644 index 00000000..1aae2224 Binary files /dev/null and b/Switch_Toolbox/Lib/SARCExt.dll differ diff --git a/Switch_Toolbox/Lib/SFGraphics.Utils.dll b/Switch_Toolbox/Lib/SFGraphics.Utils.dll new file mode 100644 index 00000000..6a38937a Binary files /dev/null and b/Switch_Toolbox/Lib/SFGraphics.Utils.dll differ diff --git a/Switch_Toolbox/Lib/SFGraphics.dll b/Switch_Toolbox/Lib/SFGraphics.dll new file mode 100644 index 00000000..c66d10cb Binary files /dev/null and b/Switch_Toolbox/Lib/SFGraphics.dll differ diff --git a/Switch_Toolbox/Lib/Switch_Toolbox.Library.dll b/Switch_Toolbox/Lib/Switch_Toolbox.Library.dll new file mode 100644 index 00000000..3637346c Binary files /dev/null and b/Switch_Toolbox/Lib/Switch_Toolbox.Library.dll differ diff --git a/Switch_Toolbox/Lib/Switch_Toolbox.Library.dll.config b/Switch_Toolbox/Lib/Switch_Toolbox.Library.dll.config new file mode 100644 index 00000000..76c295c3 --- /dev/null +++ b/Switch_Toolbox/Lib/Switch_Toolbox.Library.dll.config @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/Switch_Toolbox/Lib/Switch_Toolbox.Library.pdb b/Switch_Toolbox/Lib/Switch_Toolbox.Library.pdb new file mode 100644 index 00000000..de399f47 Binary files /dev/null and b/Switch_Toolbox/Lib/Switch_Toolbox.Library.pdb differ diff --git a/Switch_Toolbox/Lib/Syroot.BinaryData.dll b/Switch_Toolbox/Lib/Syroot.BinaryData.dll new file mode 100644 index 00000000..2e6c9155 Binary files /dev/null and b/Switch_Toolbox/Lib/Syroot.BinaryData.dll differ diff --git a/Switch_Toolbox/Lib/Syroot.Maths.dll b/Switch_Toolbox/Lib/Syroot.Maths.dll new file mode 100644 index 00000000..70be2baf Binary files /dev/null and b/Switch_Toolbox/Lib/Syroot.Maths.dll differ diff --git a/Switch_Toolbox/Lib/VGAudio.dll b/Switch_Toolbox/Lib/VGAudio.dll new file mode 100644 index 00000000..5769ab79 Binary files /dev/null and b/Switch_Toolbox/Lib/VGAudio.dll differ diff --git a/Switch_Toolbox/Lib/VisualStudioTabControl.dll b/Switch_Toolbox/Lib/VisualStudioTabControl.dll new file mode 100644 index 00000000..46c532d4 Binary files /dev/null and b/Switch_Toolbox/Lib/VisualStudioTabControl.dll differ diff --git a/Switch_Toolbox/Lib/WeifenLuo.WinFormsUI.Docking.ThemeVS2015.dll b/Switch_Toolbox/Lib/WeifenLuo.WinFormsUI.Docking.ThemeVS2015.dll new file mode 100644 index 00000000..9f9703c5 Binary files /dev/null and b/Switch_Toolbox/Lib/WeifenLuo.WinFormsUI.Docking.ThemeVS2015.dll differ diff --git a/Switch_Toolbox/Lib/WeifenLuo.WinFormsUI.Docking.dll b/Switch_Toolbox/Lib/WeifenLuo.WinFormsUI.Docking.dll new file mode 100644 index 00000000..2d074bbd Binary files /dev/null and b/Switch_Toolbox/Lib/WeifenLuo.WinFormsUI.Docking.dll differ diff --git a/Switch_Toolbox/Lib/ZstdNet.dll b/Switch_Toolbox/Lib/ZstdNet.dll new file mode 100644 index 00000000..49bd203a Binary files /dev/null and b/Switch_Toolbox/Lib/ZstdNet.dll differ diff --git a/Switch_Toolbox/MainForm.Designer.cs b/Switch_Toolbox/MainForm.Designer.cs new file mode 100644 index 00000000..28579569 --- /dev/null +++ b/Switch_Toolbox/MainForm.Designer.cs @@ -0,0 +1,377 @@ +namespace Switch_Toolbox +{ + partial class MainForm + { + /// + /// 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(MainForm)); + this.panel1 = new System.Windows.Forms.Panel(); + this.menuStrip1 = new Switch_Toolbox.Library.Forms.ContextMenuStripDark(); + this.fileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.newToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.openToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.recentToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.exportShaderErrorsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.saveConfigToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.saveToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.saveAsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.exitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.clearWorkspaceToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.editToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.windowsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.compressionToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.yaz0ToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.yaz0DecompressToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.yaz0CompressToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.gzipToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.gzipCompressToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.gzipDecompressToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.pluginsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.settingsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.aboutToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.experimentalToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.showObjectlistToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.dockPanel1 = new Switch_Toolbox.Library.Forms.DockPanelCustom(); + this.panel1.SuspendLayout(); + this.menuStrip1.SuspendLayout(); + this.SuspendLayout(); + // + // panel1 + // + this.panel1.Controls.Add(this.menuStrip1); + this.panel1.Dock = System.Windows.Forms.DockStyle.Top; + this.panel1.Location = new System.Drawing.Point(0, 0); + this.panel1.Name = "panel1"; + this.panel1.Size = new System.Drawing.Size(779, 38); + this.panel1.TabIndex = 0; + // + // menuStrip1 + // + this.menuStrip1.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(35)))), ((int)(((byte)(35)))), ((int)(((byte)(35))))); + this.menuStrip1.Dock = System.Windows.Forms.DockStyle.Fill; + this.menuStrip1.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(255)))), ((int)(((byte)(255))))); + this.menuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.fileToolStripMenuItem, + this.editToolStripMenuItem, + this.windowsToolStripMenuItem, + this.toolsToolStripMenuItem, + this.pluginsToolStripMenuItem, + this.settingsToolStripMenuItem, + this.aboutToolStripMenuItem, + this.experimentalToolStripMenuItem}); + this.menuStrip1.Location = new System.Drawing.Point(0, 0); + this.menuStrip1.Name = "menuStrip1"; + this.menuStrip1.Size = new System.Drawing.Size(779, 38); + this.menuStrip1.TabIndex = 0; + this.menuStrip1.Text = "menuStrip1"; + this.menuStrip1.ItemClicked += new System.Windows.Forms.ToolStripItemClickedEventHandler(this.menuStrip1_ItemClicked_1); + // + // fileToolStripMenuItem + // + this.fileToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.newToolStripMenuItem, + this.openToolStripMenuItem, + this.recentToolStripMenuItem, + this.exportShaderErrorsToolStripMenuItem, + this.saveConfigToolStripMenuItem, + this.saveToolStripMenuItem, + this.saveAsToolStripMenuItem, + this.exitToolStripMenuItem, + this.clearWorkspaceToolStripMenuItem}); + this.fileToolStripMenuItem.ImageAlign = System.Drawing.ContentAlignment.TopCenter; + this.fileToolStripMenuItem.ImageScaling = System.Windows.Forms.ToolStripItemImageScaling.None; + this.fileToolStripMenuItem.Name = "fileToolStripMenuItem"; + this.fileToolStripMenuItem.Size = new System.Drawing.Size(37, 34); + this.fileToolStripMenuItem.Text = "File"; + this.fileToolStripMenuItem.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageAboveText; + // + // newToolStripMenuItem + // + this.newToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.newToolStripMenuItem.Name = "newToolStripMenuItem"; + this.newToolStripMenuItem.Size = new System.Drawing.Size(179, 22); + this.newToolStripMenuItem.Text = "New"; + // + // openToolStripMenuItem + // + this.openToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.openToolStripMenuItem.Name = "openToolStripMenuItem"; + this.openToolStripMenuItem.Size = new System.Drawing.Size(179, 22); + this.openToolStripMenuItem.Text = "Open"; + this.openToolStripMenuItem.Click += new System.EventHandler(this.openToolStripMenuItem_Click); + // + // recentToolStripMenuItem + // + this.recentToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.recentToolStripMenuItem.Name = "recentToolStripMenuItem"; + this.recentToolStripMenuItem.Size = new System.Drawing.Size(179, 22); + this.recentToolStripMenuItem.Text = "Recent"; + // + // exportShaderErrorsToolStripMenuItem + // + this.exportShaderErrorsToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.exportShaderErrorsToolStripMenuItem.Name = "exportShaderErrorsToolStripMenuItem"; + this.exportShaderErrorsToolStripMenuItem.Size = new System.Drawing.Size(179, 22); + this.exportShaderErrorsToolStripMenuItem.Text = "Export Shader Errors"; + this.exportShaderErrorsToolStripMenuItem.Click += new System.EventHandler(this.exportShaderErrorsToolStripMenuItem_Click); + // + // saveConfigToolStripMenuItem + // + this.saveConfigToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.saveConfigToolStripMenuItem.Name = "saveConfigToolStripMenuItem"; + this.saveConfigToolStripMenuItem.Size = new System.Drawing.Size(179, 22); + this.saveConfigToolStripMenuItem.Text = "Save Config"; + this.saveConfigToolStripMenuItem.Click += new System.EventHandler(this.saveConfigToolStripMenuItem_Click); + // + // saveToolStripMenuItem + // + this.saveToolStripMenuItem.Enabled = false; + this.saveToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.saveToolStripMenuItem.Name = "saveToolStripMenuItem"; + this.saveToolStripMenuItem.Size = new System.Drawing.Size(179, 22); + this.saveToolStripMenuItem.Text = "Save"; + this.saveToolStripMenuItem.Click += new System.EventHandler(this.saveToolStripMenuItem_Click); + // + // saveAsToolStripMenuItem + // + this.saveAsToolStripMenuItem.Enabled = false; + this.saveAsToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.saveAsToolStripMenuItem.Name = "saveAsToolStripMenuItem"; + this.saveAsToolStripMenuItem.Size = new System.Drawing.Size(179, 22); + this.saveAsToolStripMenuItem.Text = "Save As"; + this.saveAsToolStripMenuItem.Click += new System.EventHandler(this.saveAsToolStripMenuItem_Click); + // + // exitToolStripMenuItem + // + this.exitToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.exitToolStripMenuItem.Name = "exitToolStripMenuItem"; + this.exitToolStripMenuItem.Size = new System.Drawing.Size(179, 22); + this.exitToolStripMenuItem.Text = "Exit"; + this.exitToolStripMenuItem.Click += new System.EventHandler(this.exitToolStripMenuItem_Click_1); + // + // clearWorkspaceToolStripMenuItem + // + this.clearWorkspaceToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.clearWorkspaceToolStripMenuItem.Name = "clearWorkspaceToolStripMenuItem"; + this.clearWorkspaceToolStripMenuItem.Size = new System.Drawing.Size(179, 22); + this.clearWorkspaceToolStripMenuItem.Text = "Clear Workspace"; + this.clearWorkspaceToolStripMenuItem.Click += new System.EventHandler(this.clearWorkspaceToolStripMenuItem_Click); + // + // editToolStripMenuItem + // + this.editToolStripMenuItem.Checked = true; + this.editToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked; + this.editToolStripMenuItem.Enabled = false; + this.editToolStripMenuItem.Name = "editToolStripMenuItem"; + this.editToolStripMenuItem.Size = new System.Drawing.Size(39, 34); + this.editToolStripMenuItem.Text = "Edit"; + // + // windowsToolStripMenuItem + // + this.windowsToolStripMenuItem.Name = "windowsToolStripMenuItem"; + this.windowsToolStripMenuItem.Size = new System.Drawing.Size(68, 34); + this.windowsToolStripMenuItem.Text = "Windows"; + // + // toolsToolStripMenuItem + // + this.toolsToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.compressionToolStripMenuItem}); + this.toolsToolStripMenuItem.Name = "toolsToolStripMenuItem"; + this.toolsToolStripMenuItem.Size = new System.Drawing.Size(47, 34); + this.toolsToolStripMenuItem.Text = "Tools"; + // + // compressionToolStripMenuItem + // + this.compressionToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.yaz0ToolStripMenuItem, + this.gzipToolStripMenuItem}); + this.compressionToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.compressionToolStripMenuItem.Name = "compressionToolStripMenuItem"; + this.compressionToolStripMenuItem.Size = new System.Drawing.Size(144, 22); + this.compressionToolStripMenuItem.Text = "Compression"; + // + // yaz0ToolStripMenuItem + // + this.yaz0ToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.yaz0DecompressToolStripMenuItem, + this.yaz0CompressToolStripMenuItem}); + this.yaz0ToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.yaz0ToolStripMenuItem.Name = "yaz0ToolStripMenuItem"; + this.yaz0ToolStripMenuItem.Size = new System.Drawing.Size(99, 22); + this.yaz0ToolStripMenuItem.Text = "Yaz0"; + // + // yaz0DecompressToolStripMenuItem + // + this.yaz0DecompressToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.yaz0DecompressToolStripMenuItem.Name = "yaz0DecompressToolStripMenuItem"; + this.yaz0DecompressToolStripMenuItem.Size = new System.Drawing.Size(139, 22); + this.yaz0DecompressToolStripMenuItem.Text = "Decompress"; + this.yaz0DecompressToolStripMenuItem.Click += new System.EventHandler(this.yaz0DecompressToolStripMenuItem_Click); + // + // yaz0CompressToolStripMenuItem + // + this.yaz0CompressToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.yaz0CompressToolStripMenuItem.Name = "yaz0CompressToolStripMenuItem"; + this.yaz0CompressToolStripMenuItem.Size = new System.Drawing.Size(139, 22); + this.yaz0CompressToolStripMenuItem.Text = "Compress"; + this.yaz0CompressToolStripMenuItem.Click += new System.EventHandler(this.yaz0CompressToolStripMenuItem_Click); + // + // gzipToolStripMenuItem + // + this.gzipToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.gzipCompressToolStripMenuItem, + this.gzipDecompressToolStripMenuItem}); + this.gzipToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.gzipToolStripMenuItem.Name = "gzipToolStripMenuItem"; + this.gzipToolStripMenuItem.Size = new System.Drawing.Size(99, 22); + this.gzipToolStripMenuItem.Text = "GZIP"; + // + // gzipCompressToolStripMenuItem + // + this.gzipCompressToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.gzipCompressToolStripMenuItem.Name = "gzipCompressToolStripMenuItem"; + this.gzipCompressToolStripMenuItem.Size = new System.Drawing.Size(139, 22); + this.gzipCompressToolStripMenuItem.Text = "Compress"; + this.gzipCompressToolStripMenuItem.Click += new System.EventHandler(this.gzipCompressToolStripMenuItem_Click); + // + // gzipDecompressToolStripMenuItem + // + this.gzipDecompressToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.gzipDecompressToolStripMenuItem.Name = "gzipDecompressToolStripMenuItem"; + this.gzipDecompressToolStripMenuItem.Size = new System.Drawing.Size(139, 22); + this.gzipDecompressToolStripMenuItem.Text = "Decompress"; + this.gzipDecompressToolStripMenuItem.Click += new System.EventHandler(this.gzipDecompressToolStripMenuItem_Click); + // + // pluginsToolStripMenuItem + // + this.pluginsToolStripMenuItem.Name = "pluginsToolStripMenuItem"; + this.pluginsToolStripMenuItem.Size = new System.Drawing.Size(58, 34); + this.pluginsToolStripMenuItem.Text = "Plugins"; + this.pluginsToolStripMenuItem.Click += new System.EventHandler(this.pluginsToolStripMenuItem_Click); + // + // settingsToolStripMenuItem + // + this.settingsToolStripMenuItem.Name = "settingsToolStripMenuItem"; + this.settingsToolStripMenuItem.Size = new System.Drawing.Size(61, 34); + this.settingsToolStripMenuItem.Text = "Settings"; + this.settingsToolStripMenuItem.Click += new System.EventHandler(this.settingsToolStripMenuItem_Click); + // + // aboutToolStripMenuItem + // + this.aboutToolStripMenuItem.Name = "aboutToolStripMenuItem"; + this.aboutToolStripMenuItem.Size = new System.Drawing.Size(52, 34); + this.aboutToolStripMenuItem.Text = "About"; + this.aboutToolStripMenuItem.Click += new System.EventHandler(this.aboutToolStripMenuItem_Click); + // + // experimentalToolStripMenuItem + // + this.experimentalToolStripMenuItem.Name = "experimentalToolStripMenuItem"; + this.experimentalToolStripMenuItem.Size = new System.Drawing.Size(87, 34); + this.experimentalToolStripMenuItem.Text = "Experimental"; + // + // showObjectlistToolStripMenuItem + // + this.showObjectlistToolStripMenuItem.ForeColor = System.Drawing.Color.White; + this.showObjectlistToolStripMenuItem.Name = "showObjectlistToolStripMenuItem"; + this.showObjectlistToolStripMenuItem.Size = new System.Drawing.Size(180, 22); + this.showObjectlistToolStripMenuItem.Text = "Show Objectlist"; + this.showObjectlistToolStripMenuItem.Click += new System.EventHandler(this.showObjectlistToolStripMenuItem_Click); + // + // dockPanel1 + // + this.dockPanel1.AllowDrop = true; + this.dockPanel1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.dockPanel1.DockBackColor = System.Drawing.Color.FromArgb(((int)(((byte)(45)))), ((int)(((byte)(45)))), ((int)(((byte)(48))))); + this.dockPanel1.Location = new System.Drawing.Point(0, 38); + this.dockPanel1.Name = "dockPanel1"; + this.dockPanel1.Padding = new System.Windows.Forms.Padding(6); + this.dockPanel1.ShowAutoHideContentOnHover = false; + this.dockPanel1.Size = new System.Drawing.Size(780, 422); + this.dockPanel1.TabIndex = 1; + this.dockPanel1.DockChanged += new System.EventHandler(this.dockPanel1_DockChanged); + this.dockPanel1.DragDrop += new System.Windows.Forms.DragEventHandler(this.dockPanel1_DragDrop); + this.dockPanel1.DragEnter += new System.Windows.Forms.DragEventHandler(this.dockPanel1_DragEnter); + // + // MainForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(64)))), ((int)(((byte)(64)))), ((int)(((byte)(64))))); + this.ClientSize = new System.Drawing.Size(779, 460); + this.Controls.Add(this.dockPanel1); + this.Controls.Add(this.panel1); + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.IsMdiContainer = true; + this.KeyPreview = true; + this.Name = "MainForm"; + this.Text = "Switch Toolbox"; + this.Load += new System.EventHandler(this.Form4_Load); + this.KeyDown += new System.Windows.Forms.KeyEventHandler(this.MainForm_KeyDown); + this.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.MainForm_KeyPress); + this.panel1.ResumeLayout(false); + this.panel1.PerformLayout(); + this.menuStrip1.ResumeLayout(false); + this.menuStrip1.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Panel panel1; + private Switch_Toolbox.Library.Forms.ContextMenuStripDark menuStrip1; + private System.Windows.Forms.ToolStripMenuItem editToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem toolsToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem settingsToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem fileToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem newToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem openToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem recentToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem saveToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem saveAsToolStripMenuItem; + private Switch_Toolbox.Library.Forms.DockPanelCustom dockPanel1; + private System.Windows.Forms.ToolStripMenuItem exitToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem pluginsToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem windowsToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem showObjectlistToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem saveConfigToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem exportShaderErrorsToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem clearWorkspaceToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem compressionToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem yaz0ToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem yaz0DecompressToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem yaz0CompressToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem gzipToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem gzipCompressToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem gzipDecompressToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem experimentalToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem aboutToolStripMenuItem; + } +} \ No newline at end of file diff --git a/Switch_Toolbox/MainForm.cs b/Switch_Toolbox/MainForm.cs new file mode 100644 index 00000000..cac68b75 --- /dev/null +++ b/Switch_Toolbox/MainForm.cs @@ -0,0 +1,598 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using Switch_Toolbox.Library.Forms; +using WeifenLuo.WinFormsUI.Docking; +using Switch_Toolbox.Library; +using Smash_Forge.Rendering; +using Switch_Toolbox.Library.IO; +using System.Net; + + +namespace Switch_Toolbox +{ + public partial class MainForm : Form + { + public static string executableDir = null; + public DockContentST dockContent; + public string LatestUpdateUrl = ""; + + List RecentFiles = new List(); + + public ObjectList objectList = null; + IFileFormat[] SupportedFormats; + IFileMenuExtension[] FileMenuExtensions; + + public MainForm() + { + InitializeComponent(); + + ShaderTools.executableDir = executableDir; + + Config.StartupFromFile(MainForm.executableDir + "\\config.xml"); + dockContent = new DockContentST(); + dockContent = Viewport.Instance; + + GenericPluginLoader.LoadPlugin(); + + foreach (var plugin in GenericPluginLoader._Plugins) + { + plugin.Value.MainForm = this; + plugin.Value.DockedEditor = dockContent; + plugin.Value.Load(); + LoadPluginContextMenus(plugin.Value.Types); + } + Settings settings = new Settings(this); + settings.Close(); + Reload(); + LoadPluginFileContextMenus(); + } + private List menuExtentions = new List(); + private void LoadPluginContextMenus(Type[] types) + { + foreach (Type T in types) + { + Type[] interfaces_array = T.GetInterfaces(); + for (int i = 0; i < interfaces_array.Length; i++) + { + if (interfaces_array[i] == typeof(IMenuExtension)) + { + menuExtentions.Add((IMenuExtension)Activator.CreateInstance(T)); + } + } + } + foreach (IMenuExtension ext in menuExtentions) + { + if (ext.FileMenuExtensions != null) + RegisterMenuExtIndex(fileToolStripMenuItem, ext.FileMenuExtensions, fileToolStripMenuItem.DropDownItems.Count); //last items are separator and settings + if (ext.ToolsMenuExtensions != null) + RegisterMenuExtIndex(toolsToolStripMenuItem, ext.ToolsMenuExtensions); + if (ext.TitleBarExtensions != null) + RegisterMenuExtIndex(menuStrip1, ext.TitleBarExtensions, menuStrip1.Items.Count); + + } + } + private void LoadPluginFileContextMenus() + { + foreach (IFileMenuExtension ext in FileMenuExtensions) + { + if (ext.NewFileMenuExtensions != null) + RegisterMenuExtIndex(newToolStripMenuItem, ext.NewFileMenuExtensions, newToolStripMenuItem.DropDownItems.Count); + if (ext.ToolsMenuExtensions != null) + RegisterMenuExtIndex(toolsToolStripMenuItem, ext.ToolsMenuExtensions); + if (ext.TitleBarExtensions != null) + RegisterMenuExtIndex(menuStrip1, ext.TitleBarExtensions, menuStrip1.Items.Count); + if (ext.ExperimentalMenuExtensions != null) + RegisterMenuExtIndex(experimentalToolStripMenuItem, ext.ExperimentalMenuExtensions, experimentalToolStripMenuItem.DropDownItems.Count); + if (ext.CompressionMenuExtensions != null) + RegisterMenuExtIndex(compressionToolStripMenuItem, ext.CompressionMenuExtensions, compressionToolStripMenuItem.DropDownItems.Count); + } + } + void RegisterMenuExtIndex(ToolStripMenuItem target, ToolStripItemDark[] list, int index = 0) + { + foreach (var i in list) + target.DropDownItems.Insert(index++, i); + } + void RegisterMenuExtIndex(ToolStrip target, ToolStripItemDark[] list, int index = 0) + { + foreach (var i in list) + target.Items.Insert(index++, i); + } + + public void Reload() + { + SupportedFormats = FileManager.GetFileFormats(); + FileMenuExtensions = FileManager.GetMenuExtensions(); + } + + private void Form4_Load(object sender, EventArgs e) + { + LoadObjectList(); + LoadRecentList(); + foreach (string item in RecentFiles) + { + ToolStripMenuItem fileRecent = new ToolStripMenuItem(); + fileRecent.Click += RecentFile_click; + fileRecent.Text = item; + fileRecent.Size = new System.Drawing.Size(170, 40); + fileRecent.AutoSize = true; + fileRecent.Image = null; + fileRecent.ForeColor = Color.White; + recentToolStripMenuItem.DropDownItems.Add(fileRecent); //add the menu to "recent" menu + } + dockContent.Show(dockPanel1, DockState.Document); + + if (OpenTK.Graphics.GraphicsContext.CurrentContext != null) + { + OpenTKSharedResources.InitializeSharedResources(); + } + + if (Runtime.OpenStartupWindow) + { + Startup_Window window = new Startup_Window(); + window.TopMost = true; + window.Show(); + } + } + const int MRUnumber = 6; + private void SaveRecentFile(string path) + { + recentToolStripMenuItem.DropDownItems.Clear(); + LoadRecentList(); //load list from file + if (!(RecentFiles.Contains(path))) //prevent duplication on recent list + RecentFiles.Insert(0, path); //insert given path into list + + //keep list number not exceeded the given value + while (RecentFiles.Count > MRUnumber) + { + RecentFiles.RemoveAt(MRUnumber); + } + foreach (string item in RecentFiles) + { + //create new menu for each item in list + ToolStripMenuItem fileRecent = new ToolStripMenuItem(); + fileRecent.Click += RecentFile_click; + fileRecent.Text = item; + fileRecent.Size = new System.Drawing.Size(170, 40); + fileRecent.AutoSize = true; + fileRecent.Image = null; + fileRecent.ForeColor = Color.White; + + //add the menu to "recent" menu + recentToolStripMenuItem.DropDownItems.Add(fileRecent); + } + //writing menu list to file + //create file called "Recent.txt" located on app folder + StreamWriter stringToWrite = + new StreamWriter(System.Environment.CurrentDirectory + "\\Recent.txt"); + foreach (string item in RecentFiles) + { + stringToWrite.WriteLine(item); //write list to stream + } + stringToWrite.Flush(); //write stream to file + stringToWrite.Close(); //close the stream and reclaim memory + } + private void LoadRecentList() + {//try to load file. If file isn't found, do nothing + RecentFiles.Clear(); + try + { + StreamReader listToRead = new StreamReader(System.Environment.CurrentDirectory + "\\Recent.txt"); //read file stream + string line; + while ((line = listToRead.ReadLine()) != null) //read each line until end of file + { + if (File.Exists(line)) + RecentFiles.Add(line); //insert to list + } + listToRead.Close(); //close the stream + } + catch (Exception) + { + + //throw; + } + + } + private void LoadObjectList() + { + objectList = new ObjectList(); + objectList.Show(dockPanel1, Runtime.objectListDockState); + } + public void SaveFile(IFileFormat format, string FileName) + { + byte[] data = format.Save(); + int Alignment = format.Alignment; + Console.WriteLine(Alignment); + + SaveCompressFile(data, FileName, Alignment); + } + private void SaveCompressFile(byte[] data, string FileName, int Alignment = 0, bool EnableDialog = true) + { + if (EnableDialog) + { + DialogResult save = MessageBox.Show("Compress file?", "File Save", MessageBoxButtons.YesNo); + + if (save == DialogResult.Yes) + data = EveryFileExplorer.YAZ0.Compress(data, 3, (uint)Alignment); + } + File.WriteAllBytes(FileName, data); + MessageBox.Show($"File has been saved to {FileName}"); + Cursor.Current = Cursors.Default; + } + public void OpenFile(string FileName, byte[] data = null, bool Compressed = false, + CompressionType CompType = CompressionType.None) + { + if (data == null) + data = File.ReadAllBytes(FileName); + + if (File.Exists(FileName)) + SaveRecentFile(FileName); + + FileReader f = new FileReader(data); + string Magic = f.ReadMagic(0, 4); + string Magic2 = f.ReadMagic(0, 2); + + //Determine if the file is compressed or not + if (Magic == "Yaz0") + { + data = EveryFileExplorer.YAZ0.Decompress(data).ToArray(); + OpenFile(FileName, data, true, CompressionType.Yaz0); + return; + } + if (Magic == "ZLIB") + { + data = FileReader.InflateZLIB(f.getSection(64, data.Length - 64)); + OpenFile(FileName, data, true, CompressionType.Zlib); + return; + } + + f.Dispose(); + f.Close(); + + foreach (IFileFormat format in SupportedFormats) + { + Console.WriteLine(format.Magic.Reverse()); + Console.WriteLine(Magic2); + + if (format.Magic == Magic || format.Magic == Magic2 || format.Magic.Reverse() == Magic2) + { + format.CompressionType = CompType; + format.FileIsCompressed = Compressed; + format.Data = data; + format.FileName = Path.GetFileName(FileName); + format.Load(); + format.FilePath = FileName; + + if (format.EditorRoot != null) + { + objectList.treeView1.Nodes.Add(format.EditorRoot); + } + + if (format.CanSave) + { + saveAsToolStripMenuItem.Enabled = true; + saveToolStripMenuItem.Enabled = true; + } + if (format.UseEditMenu) + editToolStripMenuItem.Enabled = true; + } + if (format.Magic == String.Empty) //Load by extension if magic isn't defined + { + foreach (string ext in format.Extension) + { + if (ext.Remove(0, 1) == Path.GetExtension(FileName)) + { + format.CompressionType = CompType; + format.FileIsCompressed = Compressed; + format.Data = data; + format.FileName = Path.GetFileName(FileName); + format.FilePath = FileName; + format.Load(); + + if (format.EditorRoot != null) + { + objectList.treeView1.Nodes.Add(format.EditorRoot); + } + + if (format.CanSave) + { + saveAsToolStripMenuItem.Enabled = true; + saveToolStripMenuItem.Enabled = true; + } + if (format.UseEditMenu) + editToolStripMenuItem.Enabled = true; + } + } + } + } + } + private void DisposeControls() + { + + } + private void RecentFile_click(object sender, EventArgs e) + { + OpenFile(sender.ToString()); + } + private void menuStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e) + { + + } + + private void exitToolStripMenuItem_Click(object sender, EventArgs e) + { + this.Close(); + } + + private void menuStrip1_ItemClicked_1(object sender, ToolStripItemClickedEventArgs e) + { + + } + + private void exitToolStripMenuItem_Click_1(object sender, EventArgs e) + { + Close(); + } + + private void pluginsToolStripMenuItem_Click(object sender, EventArgs e) + { + PluginManager pluginManager = new PluginManager(); + pluginManager.Show(); + } + + private void openToolStripMenuItem_Click(object sender, EventArgs e) + { + OpenFileDialog ofd = new OpenFileDialog(); + ofd.Filter = Utils.GetAllFilters(SupportedFormats); + ofd.Multiselect = true; + + if (ofd.ShowDialog() == DialogResult.OK) + { + foreach (string file in ofd.FileNames) + OpenFile(file); + } + } + + private void showObjectlistToolStripMenuItem_Click(object sender, EventArgs e) + { + if (objectList == null) + LoadObjectList(); + } + + private void dockPanel1_DragDrop(object sender, DragEventArgs e) + { + string[] files = (string[])e.Data.GetData(DataFormats.FileDrop); + foreach (string filename in files) + { + OpenFile(filename); + } + } + + private void dockPanel1_DragEnter(object sender, DragEventArgs e) + { + if (e.Data.GetDataPresent(DataFormats.FileDrop)) + e.Effect = DragDropEffects.All; + else + { + String[] strGetFormats = e.Data.GetFormats(); + e.Effect = DragDropEffects.None; + } + } + + private void saveAsToolStripMenuItem_Click(object sender, EventArgs e) + { + SaveFile(true); + } + + private void MainForm_KeyPress(object sender, KeyPressEventArgs e) + { + + } + + private void SaveFile(bool UseSaveDialog) + { + foreach (IFileFormat format in SupportedFormats) + { + if (format.CanSave) + { + List f = new List(); + f.Add(format); + + if (UseSaveDialog) + { + SaveFileDialog sfd = new SaveFileDialog(); + sfd.Filter = Utils.GetAllFilters(f); + sfd.FileName = format.FileName; + + if (sfd.ShowDialog() == DialogResult.OK) + { + Cursor.Current = Cursors.WaitCursor; + SaveFile(format, sfd.FileName); + } + } + else + { + SaveFile(format, format.FilePath); + } + } + } + } + + private void MainForm_KeyDown(object sender, KeyEventArgs e) + { + if (e.Control && e.KeyCode == Keys.S) // Ctrl-S Save + { + // Do what you want here + SaveFile(true); + + e.SuppressKeyPress = true; // Stops other controls on the form receiving event. + + } + } + + private void saveToolStripMenuItem_Click(object sender, EventArgs e) + { + SaveFile(false); + } + + private void saveConfigToolStripMenuItem_Click(object sender, EventArgs e) + { + Config.Save(); + + // dockPanel1.SaveAsXml("DockStates/" + dockPanel1.Text + ".xml"); + } + + private void dockPanel1_DockChanged(object sender, EventArgs e) + { + Console.WriteLine(e.ToString()); + } + + private void settingsToolStripMenuItem_Click(object sender, EventArgs e) + { + Settings settings = new Settings(this); + settings.Show(); + } + + private void exportShaderErrorsToolStripMenuItem_Click(object sender, EventArgs e) + { + ShaderTools.SaveErrorLogs(); + } + + private void clearWorkspaceToolStripMenuItem_Click(object sender, EventArgs e) + { + foreach (var plugin in GenericPluginLoader._Plugins) + { + plugin.Value.Unload(); + + foreach (IFileFormat format in SupportedFormats) + { + if (format.IsActive) + { + format.Unload(); + } + } + } + Viewport.Instance.Dispose(); + GC.Collect(); + } + + public void CompressData(CompressionType CompressionType, byte[] data) + { + switch (CompressionType) + { + case CompressionType.Yaz0: + SaveFileForCompression(EveryFileExplorer.YAZ0.Compress(data)); + break; + case CompressionType.Zlib: + break; + case CompressionType.Gzip: + SaveFileForCompression(STLibraryCompression.GZIP.Compress(data)); + break; + case CompressionType.Zstb: + break; + } + } + public void DecompressData(CompressionType CompressionType, byte[] data) + { + try + { + switch (CompressionType) + { + case CompressionType.Yaz0: + SaveFileForCompression(EveryFileExplorer.YAZ0.Decompress(data)); + break; + case CompressionType.Zlib: + break; + case CompressionType.Gzip: + SaveFileForCompression(STLibraryCompression.GZIP.Decompress(data)); + break; + case CompressionType.Zstb: + break; + } + } + catch + { + MessageBox.Show($"File not compressed with {CompressionType} compression!"); + } + + } + + private void yaz0DecompressToolStripMenuItem_Click(object sender, EventArgs e) + { + OpenFileForCompression(CompressionType.Yaz0, false); + } + private void yaz0CompressToolStripMenuItem_Click(object sender, EventArgs e) + { + OpenFileForCompression(CompressionType.Yaz0, true); + } + private void gzipCompressToolStripMenuItem_Click(object sender, EventArgs e) + { + OpenFileForCompression(CompressionType.Gzip, true); + } + private void gzipDecompressToolStripMenuItem_Click(object sender, EventArgs e) + { + OpenFileForCompression(CompressionType.Gzip, false); + } + + private void SaveFileForCompression(byte[] data) + { + SaveFileDialog sfd = new SaveFileDialog(); + sfd.Filter = "All files(*.*)|*.*"; + + Cursor.Current = Cursors.Default; + if (sfd.ShowDialog() == DialogResult.OK) + { + SaveCompressFile(data, sfd.FileName, 0, false); + } + } + private void OpenFileForCompression(CompressionType compressionType, bool Compress) + { + OpenFileDialog ofd = new OpenFileDialog(); + ofd.Filter = "All files(*.*)|*.*"; + ofd.Multiselect = true; + + if (ofd.ShowDialog() == DialogResult.OK) + { + Cursor.Current = Cursors.WaitCursor; + foreach (string file in ofd.FileNames) + { + if (Compress) + CompressData(compressionType, File.ReadAllBytes(ofd.FileName)); + else + DecompressData(compressionType, File.ReadAllBytes(ofd.FileName)); + } + } + } + + private void checkUpdatesToolStripMenuItem_Click(object sender, EventArgs e) + { + if (LatestUpdateUrl == "") + return; + + using (var webClient = new WebClient()) + { + webClient.DownloadFile(LatestUpdateUrl, "update.zip"); + webClient.DownloadDataCompleted += UpdateDownloadCompleted; + } + } + void UpdateDownloadCompleted(object sender, DownloadDataCompletedEventArgs e) + { + MessageBox.Show("Update downloaded!"); + + System.IO.Compression.ZipFile.ExtractToDirectory("update.zip", "update/"); + } + + private void aboutToolStripMenuItem_Click(object sender, EventArgs e) + { + CreditsWindow credits = new CreditsWindow(); + credits.TopMost = true; + credits.Show(); + } + } +} diff --git a/Switch_Toolbox/MainForm.resx b/Switch_Toolbox/MainForm.resx new file mode 100644 index 00000000..d7f801ed --- /dev/null +++ b/Switch_Toolbox/MainForm.resx @@ -0,0 +1,2502 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + AAABAAQAMDAAAAEAIACoJQAARgAAAEBAAAABACAAKEIAAO4lAACAgAAAAQAgACgIAQAWaAAAAAAAAAEA + IAD9uwAAPnABACgAAAAwAAAAYAAAAAEAIAAAAAAAACQAABMLAAATCwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAAAAsAAAAEAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAsAAAADAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjAAAAHQ0AACZWAAAnjQAAG4YAAAdbAAAAIgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKR0AAB4VABMmGwBdJhsAjhkS + AIUFAwBXAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUwAAAE8AAABQGAAAT54AAGH1AABo/gAA + WfcAAD3UAAAUigAAADEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEkzAABCLgAARDAAJ0cy + ALJZPwD3aUoA/mJFAPY/LADMEQwAfAAAACIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbwAAAGwOAABwpAAA + i/8AAJP/AACC/wAAfP8AAGv/AABG4wAAFIkAAAArAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAEAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASDIAAEkz + AABHMgAkUTkAwmtLAP99VwD/glsA/5RnAP+NYwD/WT8A1Q8LAG0AAAALAAAAAAAAAAAAAAAAAACFAAAA + fgAAAH5XAACb+AAAov8AAHP/AABm/AAAav0AAHj/AABt/wAAQ94AABCCAAAAJQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAANzUvAD07NQ4aGRZQAQEBVAAAACUAAAAJAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAASDMAAEYxAB1QOAC3bUwA/3pVAP9rSwD9Z0gA/HNQAP+icQD/m20A/EQwAKoAAAAiAAAAAAAA + AAAAAAAAAACOAAAAqQAAAJOKAAC2/wAAiP8AAFvNAABkWwAAZGoAAG/lAACE/wAAbP8AAEDYAAAOewAA + AB8AAAAAAAAAAAAAAAQAAAALAAAAFQAAAAsAAAAAOjkzADw6NCtwcm3aYmRg1SsrKKUIBwZwAAAAOQAA + AAYAAAAAAAAAAAAAAABIMwAARjEAFk83AKtrSwD/hV0A/2tLAPRFMACdY0UAW2VHALeIXwD/uIEA/2xM + AMQAAAAkAgEAAAAAAAAAAAAAAACRAAAAngAAAJd4AAC5/wAAifoAADKbAAAAOgAAO1QAAHTnAACM/wAA + f/8AAGr/AAA80gEBC3YPDwtIGxsYaSgoJYQ5OTaeLi4roQcGBW0AAAAtAAAABSMfGRKKjonGwcjE/6ux + rPx4e3fnICAenQAAAC0AAAAAKy0yACI1XwIeFwUrSjQApmpKAP1/WQD/jWMA/3BPAPQjGQCWAAAAQUkz + AGaLYQD1uoIA/3FPAKgAAAANAgEAAAAAAAAAAAAAAAAAAAAAigAAAIgwAACg4AAAsP8AAIPoAABm0gAA + eewAAJj/AAB7/wAAbv8AAH//AABo/QICN9krKyzbfIB89p6jn/yqsKz/oqik/GlrZ94lJCKiAQEBXQAA + ACttb2qowMfD/8vTz//Gzcn/a25q3QQDAm0AAAAMLigaADgzJTxCMQrPZ0gA/YBZAP9vTgD/e1YA/5pr + AP96VgDuZkgA0oNcAOaxewD/nG0A6mFEAEfBiAAAAAAAAAAAAAAAAAAAAAAAAAAAiwAAAP8AAAB2YwAA + n/IAAL//AAC3/wAAqv8AAIb/AABu/wAAa/8AAHD/AACA/wAAZvwMDDjoXF5e9bC3s/+/xsP/wMfE/7zD + v/+an5v4X2Fd1k5PS8WZnprzxs7K/8fOy//K0c7/rLKu/DQ0MbEAAAA7QS8DCUg1CKJlRwL/gVsA/3JQ + AP9sSwD/b04A/4ZeAP+qdwD/t4AA/8CGAP+hcAD0cE4AbRkTAAJXPQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAGoAAABdBQAAdXAAAKDxAADD/wAAlP8AAHf/AAB5/wAAdP8AAG3/AABz/wAAgf8AAGP6FhY79HB0 + c/+yuLX/vcTB/77Fwv/AyMT/u8K//7i/u//Cycb/xMvI/8XNyf/Gzsr/x8/L/3+Df+kUExCMPSsAk2VH + APaCWwD/dVIA/25NAP90UQD/elUA/3dUAP+UZwD/xIkA/6JxAPJ3UwBzXkIABmtLAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABtAAAAXQQAAHdnAACh7QAAvv8AAJf/AAB//wAAe/8AAHb/AABv/wAA + dv8AAIL/AgJh/zI0U/96f33/s7q3/73EwP+9xMH/v8bC/8DHxP/ByMX/wsrG/8PLx//FzMj/x8/L/7vC + vv5hWD/vXkEA+YNcAP93UwD/cE4A/3ZTAP97VgD/f1kA/5dpAP++hQD/o3IA73lVAGpfQwAFbk0AAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbgAAAFUDAAB6XwAAo+kAAL//AACY/wAA + gP8AAHz/AAB3/wAAcf8AAHj/AACD/wUGYf84Olb/f4SB/7W8uP+8w8D/vcTA/77Fwv+/xsP/wMjE/8LJ + xf/Dy8f/xMzI/5iUf/9oTg//g1wA/3pVAP9yUAD/eFQA/31XAP+AWgD/l2oA/7+FAP+lcwDrfFYAYlg+ + AANvTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHQAAABZAQIB + d1oCAp/wAAC//wAAmf8AAIH/AAB+/wAAef8AAHP/AAB7/wAAg/8HCF7/PT9X/4SJhv+2vbr/u8O//7zD + wP+9xcH/v8bC/8DHxP/Cysb/m5mG/2dOEv+DWwD/fVcA/3RRAP96VQD/flgA/4JbAP+YagD/v4UA/6d0 + AOd+WABZFxAABV5BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA4NioAGRQAA0ZFPWxTVXz1ExOm/wAAv/8AAJn/AACD/wAAf/8AAHv/AAB0/wAAfv8AAIP/CQpd/0JF + WP+Ijor/t767/7vCv/+8w7//vcTB/7/HxP+enY3/Z1AW/4JbAP9/WQD/dVIA/3tWAP+AWQD/g1wA/5lr + AP/AhgD/qHYA5X1XAVcVFRVCBAQEOREREAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAA2NC4AJyQeBENCO0RkZl+SMTJptAMDoPIAAL//AACa/wAAhP8AAIH/AAB8/wAA + dv8AAID/AACC/wwMW/9HSlr/jZKP/7i/u/+6wr7/vcTB/6Ghk/9oUhz/gVoA/4JbAP93UwD/fVcA/4Fa + AP+EXQD/mWsA/8CFAP+lcgDreFIAWV9hXWVVVlLVCQkIXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHBgLCC8vaLITE6f/AAC//wAA + mv8AAIX/AACC/wAAfv8AAHf/AACD/wAAgf8PD1n/TE9c/5GXk/+5wL7/o6WY/2lVIv+AWQD/hF0A/3hU + AP9+WAD/glsA/4VdAP+abAD/wIUA/6h6D/9TQRfCLCwqipugm+mPk4/yDw4NcAAAAAQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUEAwAAAAAEKSgjRHh7 + dtd1eqH/FBWr/wAAv/8AAJv/AACG/wAAg/8AAH//AAB4/wAAhf8AAID/EhJX/1FVX/+GiH7/bFkp/39Y + AP+HXgD/eVUA/39ZAP+EXAD/hl4A/5psAP/AhQD/r4EW/7Gph/+eo6D3n6Sg+cfOyv+eo5/4HBsZhQAA + AAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcW + EiNERUCLdXh06Z6kof+orqr/d3uj/xUVrP8AAL//AACb/wAAh/8AAIX/AACA/wAAev8AAIj/AAB+/xQU + VP8zKx//aUkA/4lgAP96VgD/gVoA/4VdAP+HXwD/m2wA/8CFAP+wghf/s6uK/8PLyP/Gzsr/x8/L/8jQ + zP+rsKz9LCwpmQAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIv + KQAAAAAAQ0I9R2NlYc6Nko/+oqil/6Sqp/+kq6j/p62p/3h8pP8VFq7/AADA/wAAnP8AAIj/AACG/wAA + gv8AAHv/AACK/wAAfP8RDDv/RTAI/2tLAP+CWwD/hl4A/4hfAP+bbAD/wIUA/7GDF/+yqon/wMjF/8HJ + xf/Cysb/w8vH/8fOy/+kqqX9NzczdwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAADk3MQAwLScacHNv0Jqgnf+gpqT/oKak/6Gopf+jqab/pKqn/6etqf94faX/Fhev/wAA + wP8AAJz/AACI/wAAh/8AAIP/AAB8/wAAjP8AAHv/FA43/0UwBv93UwD/iWAA/5ttAP/AhQD/soQX/7Gp + iP+9xcL/vsXC/7/Hw//ByMT/wsrG/73Ewf9wcm3JEQ8LHiQjHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAMzAqAFpbVgBMTEdXiI2K+Z6kof+do6H/nqWi/6Cmo/+hp6T/oqim/6Sq + p/+mraj/eX6l/xcYsP8AAMD/AACc/wAAif8AAIj/AACD/wAAfv8AAI7/AAB4/xkRM/9MNQT/jWMA/8GG + AP+yhBj/sKiH/7rCv/+7wr//vMTA/77Fwf+/xsP/wcnF/5OXk/QzMy9aiouDAAEAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuAAAAAAVkZmGmkJWT/5GWk/+Zn5z/naOg/56k + of+fpaP/oaek/6Kopf+jqab/pqyo/3p/pv8XGLH/AADB/wAAnf8AAIn/AACI/wAAhP8AAH//AACQ/wEA + dv8gFy//cE4C/6V7F/+wqIf/t7+8/7i/vP+5wb3/u8K+/7zDwP++xcL/try5/1ZXU8EAAAAaBwcGAAAA + AAEAAAAIAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANzUvADQyLCZYWFTFZWZip1ZX + UnxzdXLRmJ6b/52joP+epKH/n6Wi/6Cmo/+hp6X/o6mm/6asqP94fKL/EhGm/wAAwv8AAJ3/AACK/wAA + if8AAIX/AACB/wAAkv8DAnP/Kh8x/2plVP+psK3/tr26/7e+uv+4v7v/ucC9/7rBvv+9xMD/q7Gt/zc3 + NK8AAAA2ERAONB0dGnANDQtXAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADc1 + LxE0MiwjFBAMBZecmQBVVlF+kJWS/5uhn/+cop//naOg/56kov+gpqP/oqil/6GnpP+BeVr/WUAv/xgQ + mv8AAMP/AACd/wAAiv8AAIr/AACF/wAAgv8AAJP/AwN0/y4wWP9ydnX/q7Gu/7a9uv+2vbr/t767/7nA + vP+6wb7/tr25/3J1ceRFRkLAeXx442JkX+kXFhNKMjErAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAANTMtACEeFxBpa2e7lZuY/5mfnP+aoJ7/m6Gf/52jof+fpaP/l52b/312 + XP92VQn/lWgA/2VHKf8UDpr/AADD/wAAnf8AAIv/AACK/wAAhf8AAIT/AACU/wQEc/8zNVn/dHh2/6Ko + pP+zurf/t766/7e+u/+4v7z/usG+/7e+u/+xuLT/s7m1/1pcWLgAAAASCwoJAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArKCIAa21pAExMR12Ch4P4l52a/5edm/+Zn5z/mqGf/5KY + lf95em7/ZFcz/3JSB/+VaAD/h18A/4ZeAP9qSij/Fg+a/wAAw/8AAJ3/AACL/wAAi/8AAIX/AACG/wAA + lf8FBnP/JihZ/1BTX/98gX//oaej/7S7t/+4v7v/uL+8/7nAvf+9xMH/k5iU+SsrJ2fMzL4AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6OTMALSskFWlrZ8SRl5T/lZuY/5ac + mv+Ok5D/dHRp/1xQMP9jSAn/gVoA/5prAP+LYQD/hF0A/4thAP+NYwD/eVUn/yEXmf8AAML/AACd/wAA + i/8AAIv/AACE/wAAiv8AAJn/AACC/wkJY/8lJlP/TlFd/3p/ff+gpqP/tLu4/7nBvf+yuLX/am1oxAIA + AB0VFRIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSUk4ASUlEVX+D + gPqTmZf/jZKP/3FxZf9YTSz/W0II/3ZTAP+LYQD/k2cA/6VzAP+MYgD/imEA/4thAP+cbgD/w4gA/41q + Pf8bG7L/AADC/wAAnf8AAIv/AACL/wAAi/8AAKT/AACT/wAAiv8AAHf/CAhc/yMlUv9NUF3/eH17/42S + jvh2eHS3SklEOHh6dAAZGBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABSU08ATExIVnyAffx0dWz/Wk8x/1c/B/9tTAD/hV0A/4xiAP+KYgH/elYC/6Z0AP+odQD/lGgA/6Bw + AP/ChwD/tYcZ/6Weff9/hKf/HR63/wAAwv8AAKH/AACU/wAApv8AAKb/AgJ6/wEBiv8AAIv/AACE/wAA + bf8ICFj/GhtG+hcXJLsGBgZWAAAAEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAABcRAABEPi4AOzQjTlJIK/hcRAz/YUQA/3ZTAP+IYAD/hl4A/4NdA/+ccAb/nXAF/5Fm + Af/CiAD/w4gA/8yOAP+1ggr/lY1u/6Cmpf+jqaT/fIGn/xMUvP8AAMv/AADC/wAAwv8BAZH/Bged/wcH + nv8EBIP/AACF/wAAiP8AAHb/AABh/gAAV+4AADTBAAAOewAAAC8AAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAARzIAAEEuAABBLgA0VTsAyH5YAP+TZwD/gFoA/4BaAP+VaAD/kGUA/4Nd + Av+GYAb/qnoG/49lA/+5gQD/0ZEA/8yOAP+PdTL/k5mY/56kov+fpaL/oqij/1BTrf8AAMv/AADQ/wAA + uv8DA4//CAis/wcIiP8CAoT/AACP/wAAlf8AAID/AAB//wAAkv8AAID+AABM4QAAGJQAAAA7AAAAAwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKNAAASDMAAEQwADNgRADRm2wA/696AP+fbwD/jWMA/4Nc + AP+ebgD/qHUA/41jAP+GYAT/lGoG/6Z3Bf+gcAH/05MA/7+HA/96cVH/l56d/5yioP+do6H/oaei/3uA + pv8JCcT/AADS/wEBoP8GBqb/CAiW/wUFh/8AAIz/AACn/wAAnv8AAIL/AACM/wAAnv8AAK3/AACc/wAA + WOoAABmVAAAAMAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIMwAAQC0AGF1BAL6jcgD/wIYA/7F7 + AP+kcwD/k2cA/4xiAP+jcgD/tX4A/6Z1AP+KYgH/hF8G/6h4BP+ldAD/zo8A/7aCB/9xblv/l52c/5ug + nv+cop//nqSg/4qPo/8SE8D/AADN/wAApf8EBKn/BweF/wICi/8AAKX/AAC0/wAAo/8AAIz/AACS/wAA + o/8AAK//AAC+/wAApf8AAFHiAAAOewAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAEo0AACfcAAATzcAepNn + AP7HiwD/wIYA/7J9AP+qdgD/lGgA/6NyAP2qdwD/vIMA/8CGAP+XagD/jGMC/656Af/RkgD/15YA/7aC + B/9rZ1X/k5mY/5mfnP+aoJ3/naOe/4iNov8SE8D/AADW/wAA0f8BAa7/AgKN/wAAlv8AAL//AAC7/wAA + qf8BAaH/AACT/wAAqf8AALH/AAC//wAAxv8AAJT/AAA0wAAAAEQAAE8AAAAAAAAAAAAAAAAAAAAAAEo0 + AAA8KgAcbU0A1b6FAP/JjAD/wIYA/655AP+cbQDpjGMAmohhBGOIZRHcuoMC/8uNAP/AhgD/voUA/9OT + AP/YlgD/2ZcA/7+HBP9rYkX/jJKR/5idm/+Ynpz/nKGd/3p/ov8KCsT/AADY/wAA1/8AANL/AAC+/wAA + v/8AAMr/AAC6/woKf+EaGWeiAQGJnAAAm+gAAKz/AAC//wAAx/8AAL//AABl7QAAD3kAAAALAAAAAAAA + AAAAAAAARzIAAE43AABJMwBTkmYA+sqNAP+6ggD/oXEA54xjAJaBWwA2f1kABAAASgNaTzGRpXcL/9CQ + AP/UlAD/15YA/9iWAP/YlgD/2ZcA/8uOAP90ZDb/hYuK/5acmv+XnZr/m6Gb/2VppP8CAsv/AADY/wAA + 1/8AANf/AADW/wAA0/8AAM7/AACp7AYGUE2DfwAEAACABAAAgTQAAIyUAACg5gAAuf8AAMn/AACS/QAA + J6YAAAAeAAAAAAAAAAAAAAAAUzoAAHRRAABeQgCDo3IA/6RzAOeIYACTdlQAMmBFAARrTAAAFg8IAEE8 + LgAwMTEcj2kNxcyOAP/WlQD/2JYA/9iWAP/YlgD/3JkA/9aWAP98ZzD/g4mJ/5KYlf+Ok5D/kpiS/1lc + pf8AANX/AADb/wAA1/8AANf/AADX/wAA1f8AAM3/AACExgAAACcAAA0AAAAAAAAAawAAAF8EAAB2MQAA + h5EAAKLmAACk/wAARrgAAAAdAAABAAAAAAAAAAAAVj0AAHlUAABmSABQfVgAmHFQADhFMQADWT8AAAAA + AAAAAAAAAAAAAG1PBgAAAJEArnsBmc6QAP/YlgD/2JYA/9iWAP/YlgD/458A/9iXAP99aTb/hIqK/2Jk + YOJQUUyQYWJYl0BCi+kBAdf/AADj/wAA1/8AANf/AADX/wAA1/8AAND/AACHywAAAEEAAAAEAAAAAAAA + AAAAAAAAAABYAAAAQwMAAHA2AAB9lwAAYlcAAAAAAAAHAAAAAAAAAAAAAAAAAEo1AABIMwABJBsAAnNS + AAAAAAAAAAAAAAAAAAAAAAAAAAAAADQlABhyUABmrnsA3dSUAP/YlgD/2JYA/9iWAP/amAD/66UA/8uP + Av96b03/hImI/zg4Nb4AAAA1//8AAA8OjFsAAM/2AADq/wAA2f8AANf/AADX/wAA1/8AANT/AACo6QAA + TZ0AAA9dAAAAJQAAAAUAAAAAAAAAAAAAAAAAAFcAAAAlAgAARgEAAEgAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1JgAYcVAAZplsAMS5ggD4z5AA/9iWAP/YlgD/2JYA/9iW + AP/jnwD/66UA/618Bvhsalv1h42L/1lbWOQIBwZiAAAAAQAArBcAAMTQAADp/wAA4/8AANf/AADX/wAA + 1/8AANf/AADP/wAAuvgAAI/WAABMnQAAD10AAAAlAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAD//wAANSUAGHBPAGWYawDEt4EA+M6QAP/XlgD/2JYA/9iW + AP/YlgD/2JYA/+CcAP/upwD/15cA/5NoAZ49PTpKXl9bn1dYVNQdHBlNAAAAAQAAvwAAALd5AADX/gAA + 7v8AAOD/AADX/wAA1/8AANf/AADX/wAA1v8AAM7/AAC5+AAAjdYAAEqdAAAOXQAAACUAAAAFAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqHcAAIBZAACecAA7mm0AvrV/APjMjgD/1pUA/9iW + AP/YlgD/2JYA/9mXAP/emwD/56IA/+6oAP/hngD/vIQAxoFbACSPZgMAGhYSBTUyLCY4NjAONzUvAAAA + sgAAAK0ZAADAvwAA4P8AAO7/AADn/wAA3f8AANn/AADX/wAA1/8AANf/AADV/wAAzP8AALf4AACM1gAA + QZgAAAApAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqngAAP/uAACuewCTxIkA/9SU + AP/XlgD/2JYA/9qXAP/fmwD/5aAA/+ulAP/tpgD/6KMA/9eWAPvAhwC5sHwALr2FAACSaAAAAAAAAAAA + AAAAAAAAAAAAAAAArAAAALcAAACxLAAAwLYAANb7AADn/wAA7P8AAOr/AADl/wAA3v8AANn/AADX/wAA + 1v8AANP/AADG/wAAlLQAAAIWAAASAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArXoAALJ+ + AACvfAAwu4QArMSJANfHiwDjyo0A7tCRAPbXlwD515cA+NOUAPDLjwDdwYgAtLaAAGareQAUtH8AAJpu + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgAAAC1AAAArBMAALdkAADBswAAy9wAANLvAADX+AAA + 1/kAAND2AADJ7gAAx+MAAMTYAAC8rgAArjMAAM8AAAA1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAHtYAAC4ggAApXUACKt5ABiuewAksH0AM7J+AEOzfgBMsn0AR698ADaqeAAen3EACP/M + AAB8WwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeQAAAP8AAACgCAAA + qx4AALA1AACzRwAAtEwAALNEAACyMwAAryQAAKwYAACnCAAAwwAAAH0AAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////8AAP4/////HwAA+A////wPAADwB///+AcAAOAH + /z/wAwAA4AP+D+ADAADgAYYDwAMAAOAAAAMAAwAA4AAAAQAHAADwAAAAAAcAAPAAAAAADwAA+AAAAAAf + AAD8AAAAAD8AAP4AAAAAfwAA/gAAAAB/AAD+AAAAAH8AAP/AAAAAPwAA/4AAAAA/AAD/AAAAAD8AAP4A + AAAAPwAA/AAAAAB/AAD8AAAAAP8AAPgAAAAAjwAA+AAAAAAPAAD4gAAAAB8AAP8AAAAAHwAA/wAAAAA/ + AAD+AAAAAD8AAP4AAAAAfwAA/gAAAAB/AAD+AAAAAB8AAPwAAAAADwAA+AAAAAAPAADwAAAAAAcAAPAA + AAAABwAA4AAAAAADAADgAAAAAAMAAOBwAAAOAwAA4fgAAAeHAADn4ABAAecAAP+AAAAAfwAA/gAAIAAf + AAD8AARgAB8AAPwAD/AAHwAA/AAf+AA/AAD+AH/+AH8AAP///////wAA////////AAAoAAAAQAAAAIAA + AAABACAAAAAAAABAAAATCwAAEwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAASAAAAJQAAACUAAAATAAAAAgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAABQAAAAmAAAAJQAAABEAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhAAAAGhAAACNdAAAongAA + J6sAABmXAAAGdQAAAEgAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCAAAyIwAAGBEAGSMZAGgpHQChJhsAqhcQ + AJUEAwBxAAAAPwAAAAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFUAAABAAAAA + Rx4AAEOjAABS9AAAX/8AAF3+AABP9gAAOtMAABaYAAAAYgAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEkzAAAoHAAAPywANEEu + ALpONwD3XEEA/2BEAP5TOgD0NycAyxALAI4AAABSAAAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAABjAAAAZB8AAF+3AAB0/wAAkP8AAI//AACF/wAAeP8AAGD/AABG6gAAHKAAAABgAAAAEgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0 + AABJMwAASTMAOkw1ANNgQwD/eFQA/4ZeAP+QZQD/kWUA/3ZTAP9ROQDdFxAAkQAAAEYAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAB2AAAAdggAAHGcAACL/wAAp/8AAJP/AAB4/wAAcv8AAHn/AAB7/wAA + Zf8AAEXoAAAYmgAAAFoAAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALAAAAFQAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAEo0AABJMwAASTMAME02AM9lRgD/fFcA/3pWAP9zUAD/eFQA/5NnAP+odQD/jmQA/1g+ + ANEJBgB5AAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfwAAAHw7AACN7QAAs/8AAJr/AABs/wAA + Zf8AAGX+AABn/wAAdf8AAH3/AABk/wAAQ+QAABWVAAAAVAAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0LgA7ODIWIR8bVQICAXUAAABRAAAAKQAAAAsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0AABJMwAASTMAJ0w1AMRjRQD/flgA/3dTAP9oSQD/ZkgA/mZH + AP9tTAD/mWsA/7V+AP+KYQD3MiMAnwAAAC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAkAAAAIgAAACHaAAA + p/8AALr/AAB8/wAAYvAAAGOQAABnYgAAZYsAAGrqAACE/wAAfv8AAGL/AABA3wAAEZAAAABOAAAACQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAYAAAABAAAAAAAAAAA4NjAANjQuNWJjXuJcXVncKikmtAoJ + CI0AAABnAAAAPwAAABMAAAAAAAAAAAAAAAAAAAAAAAAAAEo0AABJMwAASTMAIEs1ALphRAD/flgA/4Vd + AP9nSAD2TjcAuWFEAGloSQCJZkcA53tWAP+6ggD/qXcA/1I6ALYAAAAvAQAAAAAAAAAAAAAAAAAAAAAA + AAAAAJEAAACQAAAAj2gAAK//AAC8/wAAc/0AADutAAAALAAA/wAAAEUbAABe0QAAiv8AAIj/AAB9/wAA + YP8AAD7ZAAAOjAAAAEcAAAAOAAAAHAAAACsAAAA8AQEATwQEA2IBAQBiAAAAOQAAAAwAAAAANzUvACYj + HB6ChYDbwMjE/6Sqpf13eXXtQ0M/yxQTEZwAAABcAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAEOSgAH0s0 + AK5fQwD/fVgA/4lgAP+MYgD/Vz0A6hALAIYAAAA0AAAABl9CAGd0UQD5u4MA/7F8AP9aQACuAAAAGgEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlAAAAJA7AACg7gAAwv8AAIX8AABJuAAAEYAAABluAABMqgAA + d/oAAJf/AAB6/wAAff8AAH3/AABe/wAAO9MEBA2RFBMQgioqJ6Y6Oja/SktH0FxdWeBlZ2LoOjs3xQsK + CZAAAABiAAAALAAAAAYAAAAEXFxXl7O5tf/M1ND/ydHN/7e9uf9kZmHlCAcGiwAAADMAAAAAAAAAADQz + MAA3OToKIBoNSz8sAL5eQgD9flgA/35ZAP96VgD/mGoA/3hUAP1EMADEFQ8AiRQOAG1UOwCahV0A+cOI + AP+dbgD5UTkAcQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJgAAACdCQAAhKAAAK7/AAC4/wAA + kvoAAHfnAABx7AAAhf0AAKP/AACL/wAAaP8AAGv/AACA/wAAff8AAFz9AwM23iEhI+dtcW3+qK6q/7O6 + tv+6wb3/vcTB/6asqP5sb2rqLCwotwUFBIYAAABWAAAAK01MR5KvtbD/ydHN/8jQzP/M1ND/qa+r/jU1 + Mb8AAABpAAAAEAEBAQA9NB4AOTQoWkAxDudbQAD9fVgA/4FaAP9tTAD/aUkA/4thAP+kcwD/h18A/HJR + AOt2UwDokGUA+riAAP+wewD/eFQAuEMvABhZPwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADPAAAA + aAAAAHAkAAB8yQAAsf8AAMX/AAC3/wAAs/8AALP/AACT/wAAbv8AAGz/AABp/wAAbf8AAIL/AAB9/wAA + WvwHBjThOTo77pGWk/+8xMD/vcTB/77Fwv/AyMT/vcTA/5ugnP1eX1vgLCwpty4tKrd/gn7ww8vH/8bO + yv/Hz8v/yNDM/8jPy/96fXjvDw4NlwAAAEH/+UMAQzQRD0Q0DLlZPwL/fVcA/4NcAP9vTQD/akoA/21N + AP9vTQD/k2cA/7R9AP+0fgD/uIEA/8WKAP+zfQD/e1YA0Vk+ADJtTAAAMCIAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAHEAAABrAAAAazkAAHzTAACw/wAAyv8AALn/AACG/wAAcP8AAHX/AAB1/wAA + cP8AAGv/AABv/wAAhP8AAHz/AABX+ggIMORGSEf5mZ6b/7zDv/+9xMD/vcXB/7/Gwv/ByMX/ucC8/6Sp + pf+kqqb+vsXB/8TMyP/FzMn/xs3K/8fOy//J0c3/tLq2/0VFQc0AAAB2CgcALkgzAH5YPgD5fFcA/4Vd + AP9xTwD/a0sA/3FPAP91UgD/dlMA/3FPAP+GXQD/uYEA/8uOAP+zfQD/flgA1mxLAD6BWgAAVjwAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfQAAAF8AAABuNgAAfs0AALD/AADE/wAA + mv8AAID/AAB9/wAAev8AAHb/AABx/wAAbP8AAHH/AACF/wAAe/8AAFP8ISFC/WJmZf+cop//vMO//7zD + wP+9xMH/vsXC/7/Hw//CycX/wsrG/8LKxv/Dysb/xMvH/8XMyP/Fzcn/xs7K/8jQzP+QlJD4LCsnti4g + AbRVPAD1elYA/4deAP9zUQD/bUwA/3JQAP93UwD/e1YA/35YAP+AWgD/mWsA/8SJAP+zfQD/f1kA0G9O + ADpdQAAAfVcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACFAAAA + ZwAAAHAwAAB/xgAAsf8AAMf/AACh/wAAgv8AAH7/AAB7/wAAd/8AAHP/AABt/wAAdP8AAIf/AAB5/wUF + Vf82OFT/Zmpp/6Cmo/+8w7//vMPA/73EwP++xcH/v8bC/8DHw//AyMT/wcnF/8LKxv/Dy8f/xMzI/8XN + yf/Hzsv/w8rH/3RuV/tROQD7eVUA/4hfAP91UgD/bk0A/3RRAP94VAD/fFcA/39ZAP+CWwD/oHAA/8eL + AP+zfQD/gVoAyXFPADNmRwAAglsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAHsAAABwAAAAcSkAAIG/AACx/wAAx/8AAKL/AACD/wAAf/8AAHz/AAB5/wAA + dP8AAG//AAB2/wAAif8AAHf/BwdU/zo8Vf9qbmz/pKqn/7zDv/+7w7//vMTA/73Fwf++xsL/v8fD/8DI + xP/ByMX/wsnG/8PKx//EzMj/xc3K/5uZhf9dRxL/d1MA/4pgAP94VAD/b04A/3VSAP95VQD/fVcA/4BZ + AP+DXAD/oXAA/8eLAP+zfQD/g1sAwnJQACxsTAAAi2IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfgAAAHIAAAByJAAAg7cAALL+AADH/wAA + ov8AAIT/AACA/wAAff8AAHr/AAB2/wAAcP8AAHj/AACK/wAAdv8JCVP/PkBW/21xb/+nrqv/u8K//7vC + v/+8w8D/vcTB/77Fwv+/xsP/wMfE/8HIxf/Cycb/xMvI/5+ejf9dSBX/dFEA/4thAP96VQD/cU8A/3dT + AP97VgD/flgA/4FaAP+EXQD/oXEA/8eLAP+zfQD/hF0Au3VSACZuTQAAlWkAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB9ABIR + UAAQD1E2Dg514gECsv8AAMf/AACi/wAAhf8AAIH/AAB+/wAAe/8AAHf/AABx/wAAe/8AAIv/AAB0/wsM + Uv9CRVb/cXVy/6qxrv+7wr//u8K+/7zDv/+9xMD/vsXB/7/Gwv+/x8P/wsnG/6OjlP9fSxv/ck8A/4xi + AP98VwD/clAA/3hUAP98VwD/f1kA/4JbAP+FXQD/onEA/8eLAP+0fQD/h14AtXdSACAAAAARAAAABgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAADY0LgAvLScWRUQ9o3J2f/w2OJP/AQGy/wAAx/8AAKP/AACG/wAAgv8AAH//AAB8/wAA + ef8AAHL/AAB9/wAAjP8AAHH/Dg9R/0ZIV/90eXb/rbSw/7rCvv+6wr7/u8O//7zEwP+9xcH/wMfE/6an + mv9hTyH/cE4A/41jAP9+WQD/c1AA/3lVAP99VwD/gFoA/4NbAP+GXgD/onEA/8eLAP+0fgD/iWAAs3RQ + AB8dHBtDCQkIbgAAABUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NC4AMzAqEkA/OWZhYlyzWVpl0RERd+cAALP/AADH/wAA + o/8AAIf/AACD/wAAgP8AAH3/AAB6/wAAc/8AAH//AACN/wAAb/8RElD/SUxY/3h9ev+vtrP/usG+/7rB + vv+7wr//vcXC/6mrn/9kUyf/bUwA/41jAP+BWgD/dFEA/3tWAP9+WAD/gVoA/4RcAP+HXgD/onEA/8iL + AP+1fgD/i2IAsndUAB5JSkddU1RO3xYVE5cAAAAfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAOCoAFREMCSwo + EBMjIUtHERF36AICs/8AAMf/AACj/wAAh/8AAIT/AACC/wAAfv8AAHv/AAB0/wAAgv8AAI3/AABs/xUV + UP9NUFn/fIF+/7G4tf+6wb3/u8LA/6uupP9nVy//akoA/45jAP+EXAD/dVIA/3xXAP9/WQD/glsA/4Vd + AP+HXwD/o3IA/8iLAP+0fQD/c1AA2iQYAF0oKCVWio6J6Jufm/4gHxymAAAALAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAzMCYAJyQRF1dZZNE4Opj/AQG0/wAAx/8AAKT/AACI/wAAhf8AAIP/AAB//wAA + fP8AAHX/AACE/wAAjf8AAGn/GBlQ/1BTWv+AhYL/tLu4/62xqP9qXDb/aEgA/45jAP+GXgD/dlIA/3xX + AP+AWgD/g1wA/4VdAP+IXwD/o3IA/8iLAP+2fwH/mH03/1lURdkrKym2bG5p5sDHw/+ts6//LS0qtgAA + ADoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACggGIDk4NI+FiYT3mZ+p/zo8m/8BAbT/AADH/wAA + pP8AAIj/AACG/wAAhP8AAIH/AAB9/wAAdv8AAIf/AACN/wAAZ/8cHVD/U1dc/32Be/9tYD3/ZkcA/41j + AP+IXwD/dlMA/31YAP+BWgD/hFwA/4ZeAP+IXwD/o3IA/8iLAP+2fwH/o4dB/77BtP+1vLj/qK6q/8DH + w//K0s7/tr25/z4+OsUAAABKFBMRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4MCQABAAAOIiEdXExNSMiBhIH8pKqn/6iu + qv+Znqj/Oz2c/wEBtf8AAMf/AACk/wAAif8AAIf/AACF/wAAgv8AAH3/AAB2/wAAif8AAIz/AABk/x8g + Tv82MCX/SzQB/4thAP+LYQD/d1MA/35YAP+CWwD/hV0A/4deAP+JYAD/o3IA/8iLAP+2fwH/pIhC/73A + s//EzMn/xc3J/8fOy//Gzsr/x8/L/77Fwf9PUEzUAAAAWQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgkGADs8NwAcGhYtPDw3pmxu + avKXnJn/pKqo/6SqqP+lq6j/p66p/5mfqP88Pp7/AQG1/wAAx/8AAKT/AACJ/wAAh/8AAIb/AACD/wAA + fv8AAHf/AACM/wAAjP8AAGH/FA4r/0UwBP9tTAD/eFQA/35YAP+DXAD/hl4A/4dfAP+JYAD/o3IA/8iL + AP+3gAH/pYlC/7y/sv/Bycf/wsnG/8PKx//Ey8j/xczI/8bNyv/CycX/XV5a3QAAAEWnoo8AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANzUwAEJB + OwA7OTM5Xl9b0IiNif+gpqP/oqil/6Kopf+jqab/pKqn/6SrqP+nran/mZ+o/z0/n/8BAbb/AADH/wAA + pP8AAIr/AACI/wAAhv8AAIT/AAB+/wAAef8AAI7/AACL/wIBXv8gFij/PSsD/2VHAP+EXAD/hl4A/4hf + AP+KYAD/pHIA/8iLAP+3gAH/pYpD/7q9sP+/x8T/wMfD/8HIxP/BycX/wsrG/8PLx//Gzsr/qK6p/0RE + P6gAAAAPDg0MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAADUzLQAAAAADUlJNnJCVkv+fpaP/n6Wi/5+mo/+gp6T/oail/6Kopv+jqaf/pKqo/6et + qf+Zn6j/PkCh/wICtv8AAMf/AACl/wAAiv8AAIj/AACH/wAAhf8AAH//AAB6/wAAkP8AAIr/AQFb/yAW + JP9GMQL/b04A/4hgAP+KYQD/pHIA/8iLAP+4gAH/potD/7m7r/+9xcL/vcXB/77Gwv+/x8P/wMjE/8HJ + xf/Dysb/vsXB/2prZ+EWFBE7LiwnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3NS8ALislJGttaN2boZ7/nKKg/52jof+epKL/n6Wj/6Cm + o/+hp6T/oqil/6Oppv+kqqf/pq2o/5qgqP8/QaL/AgK3/wAAx/8AAKX/AACL/wAAif8AAIj/AACG/wAA + f/8AAHv/AACS/wAAif8DAlj/JRoh/0o0Af91UgD/pXMA/8iLAP+4gQH/p4tE/7e6rv+7wsD/u8K//7zD + wP+9xMH/vsXC/7/Gw//Ax8T/wsrG/5GVkfsxMCyAAAAAAwYGBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NC4AVlZRAERDPWeChoL9naOg/5yi + oP+do6D/naOg/56kof+fpaL/oKaj/6GnpP+iqKX/o6mm/6Oqp/+mrKj/mqCo/0BDo/8CArf/AADH/wAA + pf8AAIv/AACJ/wAAiP8AAIf/AAB//wAAff8AAJT/AACH/wQDVv8pHR3/XEAB/615AP+6ggL/p4xF/7W4 + rP+4wL3/ucC9/7rBvv+7wr//vMPA/73Ewf++xcH/v8fD/7K4tP9PUEzPBAMBKRERDgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuABcS + CwpZWlW1i5CN/4SIhf1+gn76kZaT/5yin/+do6D/nqSh/5+lov+fpqP/oKek/6Gnpf+iqKb/o6mn/6Ws + qP+aoKj/QUSk/wICuf8AAMj/AACl/wAAi/8AAIr/AACI/wAAh/8AAH//AAB//wAAlv8AAIb/BwVU/0At + Gv9rSgD/lX0+/7S3q/+2vrv/t766/7i/u/+5wLz/usG9/7vCvv+7w7//vMTA/7/Hw/+VmZX8ISAdngAA + ABcAAAAAAAAAAgAAAAwAAAAeAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAADY0LgA0MiwzTUxH1FlaVbVFRD9sPDs1U1laVbiOk5D/nKKf/5yioP+do6H/nqSi/5+l + ov+gpqP/oaek/6Kopf+jqab/paun/5qgqP85OZP/AAC2/wAAyP8AAKX/AACM/wAAiv8AAIn/AACI/wAA + f/8AAIH/AACX/wAAhP8KBlH/OjEw/2psZf+jqqj/tr25/7a8uf+2vbr/t767/7i/vP+5wL3/usG+/7vC + v/++xsL/io6K+RUUEpwAAABIAwMCJxAPDF0cGxiRDg4MfAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NC4ANjQuGjMxKy8bGBIJU0s9AD49NwA7OTNQfIB8+Zyh + n/+boZ7/nKKf/52joP+epKH/n6Wi/6Cmo/+hp6T/oqil/6OqqP+Qj37/YU0j/zQkYP8DArj/AADI/wAA + pf8AAIz/AACK/wAAif8AAIj/AAB//wAAhP8AAJn/AACC/wwMW/9BRFf/bnJw/6asqf+1vLn/tby5/7a9 + uv+3vrv/uL+8/7nAvf+6wb7/vMPA/6Wrp/9LTEjVHx4bqklJRcp3enXxWFlU8RcWE2YAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMx + KgD///8ASUlDf4aLh/+aoJ3/mqCd/5uhnv+cop//naOg/56jof+epaL/oKaj/6Gopv+RkYP/Z1Ie/39Z + AP+RZQr/OShh/wIBuP8AAMj/AACl/wAAjP8AAIv/AACK/wAAiP8AAH//AACG/wAAmv8AAID/Dw9b/0VH + V/9ydnP/p62q/7W8uf+2vLn/tr26/7e+uv+4v7v/ucC8/7rBvf+7wr7/q7Gt/5WZlf2ssq7/sri0/05P + S8sAAAAlDQwLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAA4NjAALy0nJmVnYtmVmpj/mJ2b/5ienP+Zn53/mqCe/5uhn/+do6D/nqSi/5Sa + mP97em7/ZVEe/31XAP+bbAD/i2EA/3hUCv86KWH/AgK4/wAAyP8AAKX/AACM/wAAi/8AAIr/AACJ/wAA + fv8AAIj/AACb/wAAfv8SElz/RklY/2pubP+Ok5D/qrGu/7W8uf+2vbr/tr26/7e+u/+4v7z/ucC9/7vC + v/+9xMH/v8bD/4yQjPskJCCDAAAABQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMSoAAAAAAUlJRIWDh4T/lpya/5acmv+XnZr/mJ6b/5qg + nf+aoJ7/kJWT/3V2bP9cUjX/XEUM/3xXAP+cbQD/jWIA/35YAP+KYAD/hFwK/zwqYf8DArn/AADI/wAA + pf8AAIz/AACL/wAAi/8AAIn/AAB+/wAAi/8AAJv/AAB9/wwNXv8rLFX/TE5Z/2ltbP+MkY7/qrCt/7a9 + uf+3vrv/t767/7i/vP+5wL3/usG+/7W8uP9cXlneBwYEOhwbFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTgyADMxKi5naWXgkpiV/5Sa + l/+Vm5j/l5ya/5edm/+Mko//cXJo/1dNMf9VPwv/bUwA/4lgAP+dbQD/kGUA/35YAP+JYAD/i2EA/41i + AP+GXgn/SDJg/wUDuf8AAMn/AACl/wAAjP8AAIz/AACL/wAAif8AAH7/AACP/wAAnP8AAIn/AABu/wsM + V/8pKlH/Sk1Y/2hsa/+LkI3/qrCt/7a9uv+3v7v/uL+8/7vDv/+Znpr+NDMvlwAAAAwCAgIAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuAAAA + AANMTEeQg4eE/5OYlv+TmZf/lJqY/4mOi/9ubmT/VEou/1A7Cf9lRwD/glsA/5ZpAP+fbwD/o3IA/4Vd + AP+IXwD/jGIA/4xiAP+MYgD/pXQA/76ECP9UO2D/AwO6/wAAyP8AAKX/AACM/wAAjP8AAIz/AACI/wAA + hP8AAKH/AACe/wAAlf8AAIL/AABm/wsLUv8nKVD/SUxY/2hsav+Kj4z/qrGu/7O6t/+an5v9ZWZhwycl + ICVKRz8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAADY0LgAaFg8NW1xXw42TkP+Rl5X/i5CO/3JyZ/9TSCv/TjoI/2BDAP96VQD/jGIA/41i + AP98VgD/lWgA/615AP+TZwD/i2EA/4tiAP+MYgD/pHMA/8mMAP+/hgL/oYhN/0pMpv8EBL3/AADI/wAA + pf8AAIz/AACL/wAAi/8AAJL/AACs/wAAlv8AAHv/AACL/wAAjP8AAHn/AABg/woKUf8mKFD/SEtX/1te + Xf5dX1vlRkZBfy8sJRssLzEAQD00AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NC4AAAAABlZXU7CEiYf/cXNs/1ZONv9POgr/XEAA/3JQ + AP+DXAD/jmQA/4lgAP+LYgD/hF4D/3dUAf+xfAD/sXsA/5lrAP+UaAD/qHYA/8mMAP+9hQL/pYtG/6Om + nP+boqb/S06q/wQEvv8AAMj/AACp/wAAlP8AAJj/AACv/wAAsf8BAXj/AwOE/wAAjP8AAIj/AACN/wAA + g/8AAHL/AABd/wkJT/8PDzTnBAQQngAAAGIAAAAuAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKighAAAAAAFDQDabVU43/088 + Df9XPQH/Y0UA/3pVAP+FXQD/imEA/4ZeAP+AWwT/mW4G/7OAB/98WAP/nm4A/8OIAP/ChwD/w4kA/86Q + AP/EiQD/l3ox/5uelv+gp6X/oqik/5yipf9GSav/AQHE/wAAzf8AAMP/AADB/wAAwv8AAJ//AwR7/wgJ + tP8HB5z/BQaA/wAAhf8AAIn/AACE/wAAef8AAGP/AABX/AAASeoAAC28AAAMiAAAAFQAAAAVAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOikAACoe + AAA7KgBDRTEC1mNGAf+FXQD/g1wA/3FPAP+CWwD/j2QA/5RoAP96VgD/imID/39cBv+tfAb/n3IF/4Nc + Af/BhwD/y44A/8+QAP/QkQD/pHgP/4OCc/+epKP/n6Wi/6Cmo/+iqKT/kZal/yAis/8AAM7/AADP/wAA + y/8AAML/AQGE/wcHn/8ICLD/CAiC/wQEiv8AAHr/AACT/wAAjv8AAIL/AABx/wAAgv8AAIX/AABl/QAA + Qd8AABqeAAAAaAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAASjQAAFs/AAFGMQBQUTkA4IBZAP+jcgD/n28A/49kAP99WAD/hV0A/5hqAP+gcAD/j2UA/4Ve + Af+DXgX/kGcG/7aCBv+IYQP/qXYA/9CRAP/TkwD/x4sA/4JqLf+Jj47/naOh/52jof+epKL/n6Wj/6Ko + o/9WWar/AADG/wAA0v8AAM//AACr/wMDiP8HCLj/CAiT/wYHhP8BAYb/AACO/wAAn/8AAJf/AACF/wAA + fP8AAI7/AACd/wAAo/8AAIH/AABO7wAAIqsAAAFtAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAASjQAAEUxAABHMgBLVj0A5JJmAP+2fwD/rnkA/6BwAP+XagD/hl4A/4Jb + AP+ebwD/qXYA/6l2AP+EXQD/j2YD/31aBv+mdwb/q3oF/4tiAf/MjgD/1ZQA/7uEA/9vZUT/j5aV/5yi + n/+cop//naOg/56kof+hp6L/en6m/wgJvv8AANT/AADM/wEBjf8FBqv/Bwip/wcIfv8EBJD/AACD/wAA + qP8AAKj/AACe/wAAgv8AAIX/AACW/wAAn/8AAKz/AAC1/wAAk/8AAFPzAAAhqQAAAGQAAAARAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASjQAAEkzAABGMQAtUzoA1ZVoAP/AhgD/u4IA/656 + AP+kcwD/nW4A/4hgAP+GXgD/n28A/7B7AP+2fwD/nm8A/4ZfAf+JYgX/iGIG/7eDBP+abAH/tn8A/9eW + AP+yfwf/Z2FN/5CWlf+aoJ7/m6Ge/5yin/+do6D/n6Wh/4iNo/8SE7r/AADW/wAAt/8BAZn/BAS4/wcH + iv8GB4n/AQGH/wAAnf8AALX/AACw/wAAn/8AAIb/AACI/wAAm/8AAKP/AACt/wAAuv8AAL//AACX/wAA + TewAABaZAAAASgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0AABGMQAJSzUApIZe + AP/EiQD/xIkA/7uDAP+vegD/qXYA/59vAP+PZQD/qncA/6VzAP+1fgD/vYQA/7iBAP+NYwD/jmUD/4Bc + BP+qeAH/w4kA/82PAP/XlgD/r34I/2FdTP+Nk5H/mZ+d/5qfnf+aoJ7/m6Gf/56koP+KkKL/FRW5/wAA + 1v8AAM3/AADC/wEBrP8FBYD/AwOO/wAAjP8AALf/AAC8/wAAtP8AAKX/AACq/wAAkP8AAJ3/AACo/wAA + rv8AALr/AADC/wAAw/8AAIj/AAA81QAABnwAAAAfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0 + AABJNAAARTEASmdIAPK7gwD/yIwA/8SJAP+7gwD/snwA/615AP+dbgD/jWMA9KNyAOqjcwD8tH4A/8OI + AP/HigD/qXcA/41jAP+gcAD/yIsA/9iXAP/YlgD/2JYA/7SABv9gWkP/hIqJ/5ienP+Ynpz/mZ+c/5qg + nf+do57/g4ii/w8Qu/8AANb/AADX/wAA1/8AAMj/AACg/wAAjf8AAKj/AADG/wAAw/8AALT/AgKh/wYG + mv4CAYr7AACb/wAArP8AALH/AAC6/wAAw/8AAMf/AAC8/wAAZ/kAACGpAAAASgAAAAEAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABKNAAAQi4ABUw2AKOVaQD/yo0A/8iMAP/FigD/u4MA/6t3AP+YawDzi2IAs4df + AFB6WAc2cVgczah4Bv/HiwD/zI4A/8mMAP/EiQD/0ZIA/9eWAP/YlgD/2JYA/9iWAP++hgL/Z1s3/3h9 + ff+XnZv/l52a/5iem/+Zn5z/nKKd/3J2o/8GB8D/AADX/wAA1/8AANf/AADW/wAA0f8AAMP/AADI/wAA + y/8AAMf/AACo+xIRYtMrKU2cCgl3XwAAi68AAJfyAACq/wAAuv8AAMT/AADH/wAAyf8AAJn/AAA91QAA + BG8AAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASjQAAEIuACNgQwDeuYEA/8qNAP/GiwD/tH4A/5ls + APGHXwCugFoATH5aAAxfSRMAAAAVAklGOo6Naxr/xIgA/9CRAP/TkwD/1ZUA/9eVAP/YlgD/2JYA/9iW + AP/ZlgD/yIwA/3ZhKv9vdHT/lpyZ/5abmf+XnJr/mJ2b/5uhnP9aXqX/AADH/wAA2P8AANf/AADX/wAA + 1/8AANb/AADV/wAA0v8AAM//AADE/wAAkNQJCCkzbWgABAMDbAAAAH8LAACASQAAh6wAAJjwAACy/wAA + xf8AAMn/AAC6/wAAW/EAABKOAAAAIQAAAAAAAAAAAAAAAAAAAAAAAAAAUTkAAE03AABHMgBOfFcA+MeL + AP+3gAD/mmwA8INcAKp4VABHc1IACnhVAABqSwAAAAAAADY1MAAqLjUdZVEfwbJ+A//SkwD/1ZQA/9aV + AP/YlgD/2JYA/9iWAP/YlgD/3JkA/9KTAP+AZSL/bXJx/5SamP+Vm5n/l5ya/5idm/+an5v/Sk2n/wAA + z/8AANv/AADX/wAA1/8AANf/AADX/wAA1f8AANT/AADS/wAAtvsAAFyWAAAADAAAAwAAAAAAAABlAAAA + eAAAAHMJAAB4RQAAgqgAAJnvAAC2/wAAxv8AAH39AAAjqgAAAC8AAAAAAAAAAAAAAAAAAAAAAAAAAFQ7 + AABZPwAAVDwAaYlgAP+fcAD2flgAq29PAEVnSgAJcE8AAEk1AAAAAAAAAAAAAAAAAAAsKysAlW0LAGtT + GEaregTx0pIA/9eWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/+WgAP/XlgD/g2cg/3B1dP+TmZf/h4uI/3+D + gP5+gn/9jJCM/0dJqP8AANT/AADl/wAA1/8AANf/AADX/wAA1/8AANf/AADW/wAA0v8AAKvxAAAviAAA + ABcAAAAAAAAAAAAAAAAAAAAAAAA/AAAAbwAAAGcIAABvQwAAfagAAJ71AACK/wAAP5YAAAASAAABAAAA + AAAAAAAAAAAAAAAAAABUOwAAYUQAAF9DACdtTQCLbk4AWmBEAAtrSwAAMSYAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAK98AACodgA6uoMA8NWUAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9uYAP/spgD/05MA/35l + Jv94fn3/houI/0REQNQ3NjF0QUA6XlVVTKQ0NYv1AADR/wAA7P8AANr/AADX/wAA1/8AANf/AADX/wAA + 1/8AANX/AAC3+QAARZsAAAA0AAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAagAAAF8KAABuVwAA + bowAAF8qAABjAAAAOQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAADAkAAAAAAAc3JwA0iGAAn76FAP3YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/ingD/7acA/8iMAP91ZDb/hIqK/3R4dPwcHBmmAAAAOR8dGAA8OAAIDg6LeQAAyPwAAO3/AADi/wAA + 1/8AANf/AADX/wAA1/8AANf/AADX/wAAwP4AAHbAAAAYgwAAAFgAAAAmAAAABgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCQAAAAAABz0rADZ0UgCOnG4A3biBAP3OjwD/2JYA/9iW + AP/YlgD/2JYA/9iWAP/bmAD/7KYA/+iiAP+zfwX/cGpT/42Tkv+BhYL/NjYzyQAAAGoAAAAKAACOAAAA + ryoAAL/kAADm/wAA7P8AANr/AADX/wAA1/8AANf/AADX/wAA1/8AAM7/AAC6/AAAm+IAAGCyAAAahAAA + AFgAAAAnAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0JAAAAAAAHPSsANXRSAI6bbgDdt4EA/cuO + AP/WlQD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/5aEA/++pAP/ZmAD/kWgG41FQSNB0d3T4h4yJ/1td + We0KCQh+AAAAEQAANgAAAKoGAAC2pwAA1v8AAO//AADl/wAA2P8AANf/AADX/wAA1/8AANf/AADX/wAA + 1f8AAMv/AAC5/AAAmuIAAF+yAAAahQAAAFgAAAAmAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgcAAAAAAAY8KgA1c1EAjZps + AN22gAD9yo0A/9WUAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/ZlwD/5J8A/++pAP/nogD/voUA+HhV + AHAUGCEYPz04WVVWUbJPT0rdIB8bTgAAAAcAAAMAAACzAAAAsUcAAMPvAADm/wAA8P8AAOT/AADY/wAA + 1/8AANf/AADX/wAA1/8AANf/AADX/wAA1P8AAMr/AAC4/AAAmeIAAF6yAAAahAAAAFgAAAAmAAAABQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACndgAAo3MAAKZ2 + ABCDXQB5mGsA3bR/AP3IjAD/05MA/9eWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9qXAP/fnAD/6aMA//Cp + AP/rpQD/z5EA/6Z1AKVMNgARZEYAADo2LQAiHxgKNDIsNjc1LxQ3NS4AAAAAAAAAsgAAAKsGAAC1kgAA + zf8AAOr/AADw/wAA6f8AAN//AADZ/wAA1/8AANf/AADX/wAA1/8AANf/AADW/wAA0/8AAMj/AAC2/AAA + l+IAAF2xAAAXhAAAADUAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAqXcAAKx5AACqeAB3s34A+8aLAP/SkgD/1pUA/9eWAP/YlgD/2JYA/9iWAP/amAD/3psA/+Sg + AP/rpQD/8KkA//CpAP/moQD/zZAA/beBALCpdwAduIIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAACxAAAArxoAALisAADM/AAA5f8AAO//AADw/wAA6/8AAOT/AADe/wAA2f8AANf/AADX/wAA + 1/8AANb/AADV/wAA0f8AAMf/AAC0/gAAcrwAAAAvAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKt4AACuewAArHkAYLyEAPjQkQD/1JQA/9aVAP/YlgD/2JYA/92a + AP/koAD/66UA/+6nAP/tpwD/6qQA/+KeAP/TlAD/wogA57R/AIatewAWr3wAAK57AAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArwAAALAAAACuFAAAtYIAAMHmAADT/wAA4f8AAOn/AADt/wAA + 7v8AAOv/AADk/wAA3P8AANj/AADX/wAA1v8AANP/AADP/wAAvfkAAJZ1AAAABAAADQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArnsAAK16AAqxfQBquYIAvb6F + ANbAhwDhw4kA7caLAPbNkAD70ZMA/dCSAP3NkAD6yIwA8sKIAOC7gwC+tH8Agq97ADSodwAEq3kAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArAAAAKkDAACwMgAA + tYAAALu9AADC3wAAyPEAAM36AADQ/QAA0f0AAM37AADG9gAAw+0AAMHiAAC+1wAAur4AALJtAACtDAAA + rwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACjdAAAn3EAAKl4AAureQAZrHoAI657ADKvfABEsHwAVbF9AF6xfQBdsHwAUK57ADusegAjp3cADJJp + AAGabgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAmgAAAI8AAACpCwAArSIAAK87AACxUAAAsVwAALFeAACxVQAAsUQAAK8zAACuIwAA + rBkAAKsMAACkAQAApgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//////////////////////A//////wP/4B + /////+Af/AD/////wA/4AH////+AB/AAP/8f/wAH8AAf/gf+AAfwAA+OAfwAB/AgAAYA8AAH8AAAAADg + AAfwAAAAAGAAD/gAAAAAQAAf/AAAAAAAAD/+AAAAAAAAf/8AAAAAAAD//4AAAAAAAf//wAAAAAAD///g + AAAAAAH//8AAAAAAAf//wAAAAAAB///wAAAAAAH///wAAAAAAf//+AAAAAAB///gAAAAAAD//8AAAAAA + Af//gAAAAAAB//8AAAAAAAP//wAAAAAAA///AAAAAAAH//4AAAAAAAQ//gAAAAAAAD/+MAAAAAAAf//w + AAAAAAB//+AAAAAAAH//wAAAAAAA///AAAAAAAD//4AAAAAAAf//gAAAAAAD//+AAAAAAAH//4AAAAAA + AP//gAAAAAAAf/4AAAAAAAA//gAAAAAAAB/8AAAAAAAAD/gAAAAAAAAP+AAAAAAAAAfwAAAAAAAAB/AC + AAAAAEAH8A8AAAAA8AfwP4AAAAD8B/D/gAAAAH8P//4AAEAAH///+AAAIAAH///gAAAgAAH//4AAADAA + AH//AAAMcAAAf/8AAB/4AAB//wAAP/wAAH//AAB//gAA///AAf//wAH///////////////////////// + ////////KAAAAIAAAAAAAQAAAQAgAAAAAAAAAAEAEwsAABMLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAPAAAAKQAAAD8AAABKAAAASQAA + AD0AAAAnAAAADgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAEgAAACwAAABAAAAASgAAAEkAAAA7AAAAIwAA + AAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAMAAAAOQAAA2gAAAZ/AAAGhQAAA4MAAACAAAAAfwAAAHoAAABmAAAAPAAAABAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAFgAA + AEUDAgBtBgQAgAYEAIUCAgCDAAAAgAAAAH8AAAB4AAAAXwAAAC8AAAAHAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKHwAAGnAAACqvAAA2ywAAO9YAADzWAAA4zAAA + LLcAABmaAAAFhQAAAIAAAAB/AAAAYwAAACgAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAABAQAAAAAABgoHADgbEwCFLB8AtTcnAM08KgDWPCoA1jcmAMsrHgCzFQ8AlQMC + AIIAAACBAAAAewAAAFAAAAATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4AAAAAAQAA + KTcAADesAABD7AAASPwAAEv/AABM/wAATP8AAEv/AABJ/QAARvEAADnPAAAcnQAAA4IAAACBAAAAdQAA + ADgAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHRQAABcPAAwpHQBjOSgAx0Uw + APFJMwD9SzQA/0w1AP9MNQD/SzUA/0kzAPxEMADsMyQAwhIMAJAAAACAAAAAgAAAAGEAAAAaAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAABPAAAAYgEAAEdHAABGzwAASf4AAFH/AABi/wAAb/8AAHP/AABw/wAA + Z/8AAFr/AABO/wAASv8AAEXwAAAvuwAACYgAAACAAAAAeQAAADoAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAEAtAABALQAQPywAg0UxAOxKNAD/TjcA/1k/AP9nSAD/cE4A/3RRAP9wTwD/Y0UA/1I6 + AP9JNAD9Qi4A4iIYAKICAQCBAAAAgQAAAGQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXwAAAGUCAABbUQAA + VdoAAFP/AABm/wAAhf8AAJH/AACQ/wAAjf8AAIj/AACC/wAAe/8AAG7/AABa/wAATP8AAEn7AAA4zAAA + DYwAAACAAAAAdwAAADIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKNAAASjQAFUo0AJNJMwD2TDUA/1k/ + AP9tTAD/e1YA/4NbAP+IYAD/jWMA/5FmAP+TZwD/h18A/2hJAP9TOwD/TzgA7i8hAKwCAgCBAAAAgQAA + AFsAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAGkAAADZAAAAZksAAGDeAABg/wAAff8AAJv/AACe/wAAmf8AAJX/AACR/wAA + jP8AAIf/AACC/wAAff8AAHb/AABk/wAAT/8AAEn9AAA4zgAAC4kAAACAAAAAdAAAACwAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAASjQAAEo0ABFKNACUSjQA+U43AP9jRQD/dlMA/35YAP+DXAD/iF8A/41jAP+RZgD/lmkA/5ps + AP+ebwD/nW4A/4BZAP9hRQD/W0AA8TIjAKkBAQCAAAAAfgAAAD4AAAABAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsAAAAbgAAAG8sAABrzgAA + a/8AAIv/AACn/wAApv8AAKL/AACb/wAAjP8AAH3/AAB4/wAAfP8AAIL/AACC/wAAff8AAHj/AABo/wAA + UP8AAEn8AAA1xgAACIYAAACAAAAAcAAAACcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0AABKNAAMSjQAhUo0APdPOAD/Z0gA/3hU + AP9+WAD/g1wA/4NcAP99WAD/eVUA/31YAP+MYgD/m2wA/6NxAP+ndAD/qHYA/45jAP9sTAD/YUUA6iUa + AJkAAACAAAAAbAAAABUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAHYAAAB4CQAAdJkAAHH/AACO/wAArv8AAK7/AACq/wAAmv8AAHz/AABq/wAA + Zv8AAGX/AABn/wAAbP8AAHf/AACA/wAAfv8AAHj/AABo/wAAT/8AAEj6AAAywAAABoUAAACBAAAAbQAA + ACIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAEAAAAlAAAALwAAABAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABKNAAASjQACEo0AHhKNADzTjcA/2dIAP95VAD/flgA/4FaAP95VQD/bUwA/2hJAP9mSAD/ZkgA/2pK + AP98VgD/mWsA/6p3AP+uegD/sHsA/5FmAP9yUQD/WkAA0QsIAIYAAAB+AAAANQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8AAAAewAAAHw9AAB45wAA + hv8AALD/AAC0/wAAsf8AAJz/AABz/wAAZf8AAGb/AABm/wAAZv8AAGb/AABm/wAAZ/8AAHP/AACA/wAA + fv8AAHj/AABm/wAATv8AAEj4AAAvugAABIMAAACBAAAAaAAAAB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAANjQuADY0LQA4NjADR0Q8AgAAAD8AAAB8AAAAaQAAAEUAAAAgAAAABwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASjQAAEo0AAVKNABsSjQA7k02AP9lRwD/eVQA/35Y + AP+BWwD/dFIA/2hJAP9nSAD/Z0gA/2dIAP9nSAD/Z0gA/2dIAP9yUAD/m2wA/7J8AP+1fgD/snwA/4lh + AP90UgD1NSYAogAAAIAAAABPAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAIQAAACVAQAAgYEAAID/AACl/wAAu/8AALf/AACp/wAAd/8AAGX/AABm/wAA + Zv8AAGb/AABm/wAAZv8AAGb/AABm/wAAZ/8AAHn/AACD/wAAfv8AAHj/AABk/wAATf8AAEf2AAArtAAA + A4IAAACBAAAAZAAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NC8ANjQtADY0 + Lkk2My1+HBsXZwUEBIQAAACAAAAAfwAAAHYAAABaAAAANAAAABIAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0 + AABKNAADSjQAYUo0AOlMNgD/Y0YA/3hUAP9/WQD/hFwA/3tWAP9oSQD/Z0gA/2dIAP9nSAD/Z0gA/2dI + AP9nSAD/Z0gA/2ZHAP91UgD/qHUA/7iBAP+8gwD/qHYA/4FcAP9bQQDFAwIAgwAAAFsAAAAGAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiAAAAIoLAACGsAAA + jf8AALj/AAC+/wAAuv8AAJH/AABm/wAAZv8AAGb/AABm8wAAZssAAGasAABmrwAAZs4AAGbxAABm/wAA + b/8AAIX/AACD/wAAfv8AAHj/AABi/wAATP8AAEbzAAAorgAAAoEAAACBAAAAXwAAABQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0LgA2NC0ANTMtYkA/OfdJSEPvLy0p1hsaFrALCwmQAQEBggAA + AIAAAAB9AAAAbAAAAEkAAAAjAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKNAAASjQAAUo0AFZKNADkTDUA/2FEAP94VAD/f1kA/4Rc + AP+HXgD/cVAA/2dIAP9kRgD5YkQA22dIALFnSACsZ0gAyGdIAPFnSAD/Z0gA/2dIAP+PZAD/u4IA/76F + AP+6ggD/kGUA/3FPANwPCgCJAAAAXAAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACMAAAAjRMAAInEAACZ/wAAwP8AAMH/AAC6/wAAgP8AAGX/AABm/wAA + XeEAAFlnAABoGQAAZgoAAGYLAABmGwAAZlEAAGLGAABq/wAAh/8AAIn/AACD/wAAfv8AAHj/AABg/wAA + TP8AAEXxAAAkqQAAAYAAAACAAAAAWgAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUz + LQAwLSdFVVVQ8Kasp/+MkIv/X2Ba+zw7NuglJB/FExIQoAYFBYcAAACAAAAAgAAAAHcAAABeAAAANAAA + AAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASjQAAEo0 + AAFKNABLSjQA3Us1AP9fQwD/eFQA/39ZAP+EXAD/iWAA/4lgAP9sTAD/WD0A5jMkAKwbEwBvOSgAFHBO + AAlnSAAYZ0gAVWdIAMhnSAD+ZkcA/31XAP+5gQD/wocA/8KIAP+cbgD/e1cA5hgRAI4AAABSAAAABAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI8AAACQEwAA + jcQAAJ7/AADD/wAAxP8AALn/AAB4/wAAZf8AAFzqAAAnkgAAACAAAAcAAAAAAAAAAAAAAE8AAABOBQAA + TpsAAFz/AACJ/wAAjv8AAIn/AACE/wAAf/8AAHf/AABf/wAAS/8AAETtAAAhowAAAIAAAACAAAAAVAAA + AA0AAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAJAAAAEQAAABsAAAAnAAAANAAAAEMAAABSAAAATgAA + ACEAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTMtAC8sJixMS0Xhs7q2/8zU0P/Ax8P/o6ik/3d5 + dP5NTUj1MS8q2h0bGLMMDAqSAgICgwAAAIEAAAB6AAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0AABKNAAASjQAQUo0ANZLNAD/XUIA/3dUAP9/WQD/hF0A/4lg + AP+OZAD/i2IA/19DAP8+KwDSBQMAggAAAHgAAAAxAAAAASgcAABlRgAAZ0gAMWdIAMxmRwD/dlIA/7iA + AP/FigD/xYoA/6JyAP9+WQDmGRIAjAAAADsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkgAAAJMLAACQrwAAnP8AAMP/AADH/wAAvP8AAHn/AABk/AAA + PbUAAAB/AAAAXQAAABsAAAAEAAAAAQAAAAAAAEomAABRzgAAX/8AAJD/AACS/wAAjf8AAIf/AACE/wAA + f/8AAHf/AABd/wAAS/8AAEPpAAAdngAAAH8AAAB/AAAATgAAAA4AAAAaAAAAKgAAADcAAABGAAAAUwAA + AGAAAABrAAAAdQICAn0FBQSFBgUFiQEBAYIAAACBAAAAdAAAAEkAAAAXAAAAAQAAAAAAAAAAAAAAAAAA + AAA2NC4ALy0nF0A/Ocmeo57/ytLP/8rRzv/L08//yNDM/7a8uP+QlI//Y2Rf/D8+OesnJSHGCwsKjgAA + AIEAAABkAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAAAAEEs0 + ADZKNADNSjQA/1tAAP93UwD/gFkA/4RdAP+HXwD/jmMA/5NnAP+SZgD/YkUA/0o0AOoXEACSAAAAfwAA + AHIAAAAzAAAACgAAAAHAhgAAY0UAZWZHAPd2UwD/uoIA/8iLAP/FiQD/n3AA/3lVANwRDAB7AAAAHAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACVAAAA + mQEAAJSAAACR/gAAuP8AAMn/AADC/wAAhf8AAGb7AABCsQAAAH8AAAB/AAAAcAAAAFMAAABDAAAMUAAA + SakAAFj7AAB3/wAAmv8AAJf/AACJ/wAAdP8AAIP/AACE/wAAf/8AAHb/AABb/wAASv8AAELlAAAZmQAA + AH8AAAB8AAAASwEBAUsDAwJ8BQUEhwoJCJAPDw2aFRQSphsaF7MiIR3BKikkzzMxLNwyMCvdHRwYsgcH + BooAAACAAAAAgAAAAG0AAAA8AAAADwAAAAAAAAAAAAAAADY0LgAxLygENTMsg2lqZfy/x8P/ydHN/8nQ + zf/J0c3/y9PP/8zT0P/Dysb/p62o/2JjXf4kIx/CAgIBggAAAH4AAAA+AAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAD8cFAB3STMAxko0AP9ZPwD/dlMA/4BaAP+FXQD/hF0A/3VS + AP+JYAD/mGoA/5tsAP96VgD/WT4A/UMvAMYJBgCFAAAAfwAAAHoAAABgAAAASAAAAERONwCKaEkA94Fb + AP/ChwD/yo0A/7uDAP+SZwD/aEkAxgUDAFAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJoAAACXAAAAmT0AAIroAACd/wAAyv8AAMn/AACh/wAA + cv8AAHbrAABErAAAE4oAAAeEAAAJhgAAHZQAAEnFAABg+AAAbP8AAJf/AACg/wAAmf8AAHn/AABm/wAA + cf8AAIX/AACF/wAAf/8AAHX/AABZ/wAASv8AAEDgAQEWmAsKCJ8QEA6wHRwZpSwrJss0My7ePj036UlI + Q/NWVlH5ZGVg/HR2cf+DhoL/k5eS/4uPiv9YWFP6MC8q2hcWE6YEBAOFAAAAgAAAAH4AAABjAAAALwAA + AAkAAAAAAAAAADUzLQAxLykjPj03zZablv/J0c3/yNDM/8nQzf/J0c3/ytHN/8vSz//N1tL/qa+r/0RE + PvASEQ+cAAAAgAAAAG4AAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADg2Lx0pKCVKFxEBfT4r + AN5KNAD/WD4A/3VSAP+AWgD/hV0A/4ZeAP9zUQD/Z0gA/3hUAP+ZawD/oHAA/5lrAP9uTQD/YUQA+Uw1 + AMcgFgCVCQYAhQcFAIQSDQCLQC0Aq3RSAOpzUAD/nm4A/8mMAP/LjQD/onEA/4NdAPdLNQCQAAAAGQMC + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAJoAAACkCgAAjZ4AAH7/AAC4/wAAzP8AAMH/AACW/wAAh/8AAH/4AABv4QAAYdIAAGDWAABo6wAA + bP0AAHP/AACW/wAAp/8AAKP/AACJ/wAAaf8AAGb/AABm/wAAc/8AAIb/AACF/wAAgP8AAHT/AABX/wAA + Sv8AAD7cDg0ZxBoaFvQvMC3/X2Je/5CUkP+gpqL/q7Gu/7S6t/+6wb3/vsXB/8DHxP/BycX/wcnF/7K5 + tf+Dh4L/TExH9iooJM8SEQ+bAgICggAAAIAAAAB7AAAAWQAAACQAAAAGZ2RYAC8tJxQ8OjS/lJiT/8nR + zf/Hz8v/yNDM/8jQzP/J0c3/ydHN/8rSzv/I0Mz/fH55/yopJNAEBASFAAAAgAAAAEsAAAAEAAAAAAAA + AAAAAAAAAAAAADY0LgA0NCoANjQvcjUxJeE/LQTfSTQA/lY8AP90UQD/gFoA/4ZdAP+HXwD/dVIA/2dI + AP9nSAD/aUoA/4hfAP+kcgD/qHUA/5hrAP91UgD/bE0A/WlKAO1hRADXYUQA0m5NAOB+WQD3h18A/5Vp + AP/BhgD/zY4A/7yDAP+BWgD/dFIAyisfADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnwAAAIoAAACUMwAAddYAAIf/AADB/wAA + y/8AAMP/AACp/wAAkv8AAIf/AACB/wAAff8AAH7/AACK/wAAov8AAK//AACs/wAAlv8AAG7/AABm/wAA + aP8AAGb/AABm/wAAdf8AAIf/AACF/wAAgP8AAHP/AABV/wAASv4BATvZEA8YyikpJfhYW1n/lpya/7zD + wP+9xcH/vcTB/73Fwf++xcH/vsXC/77Gwv+/xsP/wMjE/8DHxP+qsaz/dnhz/0NCPPAkIh7DDQwLkwEB + AYAAAACAAAAAdgAAAFkAAABCISAbdFNTTvC1u7f/x8/L/8fOy//Hz8v/yM/M/8jQzP/J0M3/ydHN/8vT + z/+0urb/UFBK9xgXFKgAAAB/AAAAdgAAACMAAAAAAAAAAAAAAAAAAAAANjQvADQ0Mhs5NCnGQzQR/0o0 + Af9UOwD/clAA/4FaAP+GXgD/iF8A/3dTAP9oSQD/Z0gA/2lJAP9nSAD/bk0A/5VoAP+teAD/sHsA/6Rz + AP+LYgD/flkA/31ZAP+BWwD/hl8A/5FmAP+odgD/w4gA/8yOAP/EiQD/jGIA/21NAOpdQgBcAAAAAhgR + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAlwAAAP8BAAB4VgAAaucAAIr/AADB/wAAy/8AAMj/AAC+/wAAsv8AAKr/AACp/wAA + r/8AALX/AAC2/wAAsv8AAJz/AABy/wAAZv8AAGr/AABr/wAAaf8AAGf/AABn/wAAd/8AAIj/AACF/wAA + gP8AAHL/AABU/wAASf0BATnVERAWzSsrJ/paXVv/mJ6c/7vCv/+8w8D/vMTA/73Ewf+9xcH/vsXB/77G + wv+/xsL/v8fD/8HIxf++xcL/oaai/2lqZf06OTPoHh0ZtgoKCI8DAwKEAgIBhA4NC5YxMCvfhoqF/8XN + yf/Gzcr/xs7K/8fOyv/Hz8v/yM/M/8jQzP/I0Mz/ydHN/8rSzv+Lj4r/MjEr3AgIB4sAAACBAAAAWAAA + AAkAAAAAAAAAADM0MwBLNAAAOjQmYUI0EvdJNAH/UjoA/3FPAP+BWgD/hl4A/4lgAP95VQD/aEkA/2hI + AP9qSgD/bEwA/2xLAP9nSAD/ck8A/5tsAP+zfQD/t4AA/7d/AP+wewD/qXcA/6p3AP+yfQD/v4UA/8iM + AP/MjgD/xIkA/49kAP9oSQDzWj8AfCYbAAo/LQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcgAAAHcFAABuegAA + a/cAAIr/AADB/wAAy/8AAMn/AADH/wAAxf8AAML/AADA/wAAvf8AALX/AACY/wAAcf8AAGb/AABt/wAA + cP8AAG//AABs/wAAav8AAGf/AABo/wAAef8AAIn/AACG/wAAgP8AAHD/AABS/wAASfwCAjbREhIV0C0t + KvteYmD/naOg/7vDv/+8w8D/vMPA/73EwP+9xMH/vsXB/77Fwv++xsL/v8bD/8DHxP/BycX/u8K+/5WZ + lf9dXVj7Ojk05y0rJ9MrKiXQOjk06HFzb/66wb3/xc3J/8XNyf/Gzcn/xs7K/8fOyv/Hz8v/x8/L/8jQ + zP/I0Mz/ytLO/7zDv/9dXlj7Hh0ZtQAAAIAAAAB7AAAAMAAAAAAAAAAARDQOAEQ0DhVFNAu4STQC/1E5 + AP9vTgD/gVoA/4ZeAP+KYQD/e1YA/2lJAP9oSQD/a0sA/21MAP9vTgD/cU8A/25NAP9nSAD/cE4A/5Zp + AP+1fgD/voQA/8CGAP/DiQD/xooA/8iMAP/KjQD/zI8A/8SIAP+OYwD/bEwA+WZIAI84JwAPTDUAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdQAAAHYRAABxkwAAbPkAAIr/AADB/wAAy/8AAMj/AADG/wAA + xP8AALv/AACn/wAAhf8AAGr/AABn/wAAcP8AAHb/AAB0/wAAcv8AAG//AABt/wAAa/8AAGj/AABo/wAA + e/8AAIr/AACG/wAAgP8AAG7/AABR/wAASfoDAjPOFBQV1jY3NP5na2n/oKaj/7vDv/+8w7//vMPA/7zE + wP+9xMH/vcXB/77Fwv++xsL/v8bD/7/Hw//AyMT/wsnF/7e9uv+eo57/io2J/4eKhv+coZ3/vMO//8TM + yP/Ey8j/xMzI/8XNyf/Fzcn/xs7K/8bOyv/Hzsv/x8/L/8jPzP/I0Mz/ytLO/5qfmv86OTTnDQwLkwAA + AIAAAABmAAAAFSgcAABKNAALSjQAgkk0APdPOAD/bU0A/4FaAP+GXgD/imEA/31YAP9qSgD/aUkA/2tL + AP9uTQD/cE4A/3NQAP91UgD/d1MA/3JPAP9pSQD/akoA/4RcAP+mdAD/u4MA/8WKAP/HiwD/yYwA/8yP + AP/DiAD/jmMA/21MAPpyTwCcc1AAFXNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + dgAAAHgTAABzkQAAbfcAAIn/AADA/wAAy/8AAMj/AADG/wAAoP8AAG7/AABn/wAAbf8AAHb/AAB7/wAA + ef8AAHf/AAB1/wAAcv8AAHD/AABu/wAAa/8AAGj/AABp/wAAff8AAIr/AACG/wAAgP8AAGz/AABP/wAA + SPgGBTDWIB8f8k5QTv9tcW//pKqn/7zDv/+7w7//vMPA/7zEwP+9xMH/vcXB/77Fwf++xcL/v8bC/7/G + w//Ax8P/wcjF/8LKxv/Dysf/w8vH/8TLyP/Dy8f/w8rH/8PLx//Ey8j/xMzI/8XMyf/Fzcn/xs3K/8bO + yv/Hzsr/x8/L/8jPy//J0M3/wsrG/2xtaP4kIh7DAgIBgQAAAIAAAABdDwsAJEk0AHZKNADxTjcA/2tL + AP+BWgD/h14A/4tiAP9/WQD/a0sA/2lKAP9sTAD/b00A/3FPAP9zUQD/dlIA/3hUAP96VQD/e1cA/3dU + AP9uTQD/aEkA/25NAP+dbgD/xooA/8mMAP/MjwD/w4gA/41iAP9uTQD5c1EAmXlVABd0UQAAs4EAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdwAAAHkRAAB0iAAAbvQAAIn/AADA/wAA + y/8AAMn/AAC9/wAAkP8AAHr/AAB+/wAAf/8AAH3/AAB7/wAAev8AAHj/AAB2/wAAc/8AAHH/AABv/wAA + bP8AAGn/AABq/wAAf/8AAIv/AACG/wAAgf8AAGv/AABO/wAAR/oPDi75QEJB/1xgXv9vc3H/p62q/7zD + v/+7wr//vMO//7zDwP+9xMD/vcTB/77Fwf++xcL/vsbC/7/Gw/+/x8P/wMfE/8DIxP/ByMX/wcnF/8LJ + xv/Cysb/w8rH/8PLx//Ey8j/xMzI/8XMyP/Fzcn/xc3J/8bOyv/Gzsr/x8/L/8fPy//J0c3/qK2p/0ZF + P/IWFRKlAAAAfwMCAIIuIACqSTMA8E03AP9pSgD/gVoA/4deAP+MYgD/gVsA/2xMAP9qSgD/bUwA/29O + AP9yUAD/dFEA/3ZTAP95VAD/elYA/3xXAP9+WAD/f1kA/39ZAP97VgD/j2QA/72EAP/JjQD/zI8A/8OI + AP+NYgD/b04A93RRAJF6VQAUeFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAeAAAAHoOAAB1gAAAb/IAAIn/AADA/wAAzP8AAMr/AADB/wAAnf8AAIP/AACA/wAA + f/8AAH3/AAB8/wAAev8AAHn/AAB2/wAAdP8AAHL/AABv/wAAbf8AAGn/AABr/wAAgf8AAIv/AACG/wAA + gP8AAGj/AABN/wICRv8tL0v/W19e/1xgXf9ydnT/qrGt/7zDv/+7wr//vMO//7zDwP+9xMD/vcTB/73F + wf++xcL/vsbC/7/Gw/+/x8P/wMfE/8DIxP/ByMX/wcnF/8LJxf/Cysb/w8rG/8PKx//Ey8f/xMzI/8TM + yP/Fzcn/xc3J/8bNyv/Gzsr/x87L/8fPy//Gzsr/jZCM/z09N+wdHBixKh4Ds0YxAPNNNgD/Z0gA/4Fa + AP+HXwD/jGIA/4NcAP9tTAD/akoA/25NAP9wTgD/c1AA/3VSAP93VAD/eVUA/3tWAP99VwD/flgA/4BZ + AP+BWgD/g1wA/5xtAP/BhwD/yo0A/8yPAP/CiAD/jWIA/3BOAPR1UgCIe1YAEXlVAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeQAAAHwLAAB2eAAA + cO8AAIn/AAC//wAAzP8AAMr/AADB/wAAnv8AAIT/AACB/wAAgP8AAH7/AAB8/wAAe/8AAHn/AAB3/wAA + df8AAHP/AABw/wAAbv8AAGr/AABs/wAAg/8AAIz/AACH/wAAgP8AAGb/AABM/wkJTP88Plf/XF9e/1xg + Xf92enj/rbOw/7vDv/+7wr//u8O//7zDwP+8xMD/vcTA/73Ewf++xcL/vsbC/7/Gwv+/x8P/wMfD/8DH + xP/AyMT/wcjF/8HJxf/Cycb/wsrG/8PKx//Dy8f/xMvI/8TMyP/FzMn/xc3J/8bNyf/Gzsr/x87K/8jP + zP/FzMn/lpuW/09INPpGMgL5TDUA/2VHAP+AWgD/h18A/4xiAP+FXQD/bk0A/2tLAP9vTQD/cU8A/3NR + AP92UgD/eFQA/3pVAP98VwD/fVgA/39ZAP+AWgD/gVsA/4NcAP+cbQD/wYcA/8uNAP/NjwD/wocA/41i + AP9xTwDyd1MAgHxXAA56VQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAegAAAH0JAAB3cAAAcewAAIn/AAC//wAAzP8AAMr/AADC/wAA + nv8AAIT/AACC/wAAgP8AAH//AAB9/wAAe/8AAHr/AAB4/wAAdv8AAHP/AABx/wAAb/8AAGr/AABt/wAA + hf8AAIz/AACH/wAAgP8AAGT/AABL/wsMTP9AQlj/XGBe/1xgXv96fnz/r7az/7vCv/+7wr//u8K//7zD + v/+8w8D/vcTA/73Ewf++xcH/vsXC/7/Gwv+/xsP/v8fD/8DHxP/AyMT/wcjF/8HJxf/Cycb/wsrG/8PK + xv/Dy8f/xMvI/8TMyP/FzMj/xc3J/8bNyf/Gzsr/xs7K/8jQzP+lpZT/WUca/0o0AP9jRQD/gFkA/4hf + AP+NYwD/h14A/29OAP9qSgD/b04A/3JQAP90UQD/dlMA/3lVAP96VgD/fFcA/31YAP9/WQD/gVoA/4Jb + AP+EXAD/nG0A/8GHAP/LjQD/zY8A/8KHAP+NYgD/clAA73hUAHh9WAALe1YAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ewAAAH4HAAB4ZwAAcugAAIn/AAC//wAAzP8AAMr/AADC/wAAnv8AAIX/AACC/wAAgf8AAH//AAB9/wAA + fP8AAHr/AAB5/wAAdv8AAHT/AABy/wAAb/8AAGr/AABv/wAAh/8AAIz/AACH/wAAf/8AAGL/AABL/w4O + Tf9ERlj/XGBe/1xgXv99g4D/sbi1/7vCv/+7wr7/u8K//7vDv/+8w8D/vMTA/73Ewf+9xcH/vsXC/77G + wv+/xsP/v8fD/8DHw//AyMT/wcjE/8HJxf/CycX/wsnG/8LKxv/Dy8f/xMvH/8TMyP/EzMj/xczJ/8XN + yf/Hz8v/qama/19OI/9KMwD/YEQA/39ZAP+IXwD/jWMA/4lgAP9xTwD/a0sA/3BOAP9zUAD/dVIA/3dU + AP95VQD/e1YA/31XAP9+WAD/f1kA/4FaAP+CWwD/hFwA/5xtAP/BhwD/y40A/82PAP/ChwD/jWIA/3NR + AOx5VABwf1gACXxXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfAAAAH8FAAB5YAAAdOQAAIn/AAC//wAA + zP8AAMr/AADC/wAAnv8AAIX/AACD/wAAgf8AAID/AAB+/wAAfP8AAHv/AAB5/wAAd/8AAHX/AABz/wAA + cP8AAGr/AABw/wAAiP8AAIz/AACH/wAAfv8AAF//AABK/xERTf9HSVn/XGBe/11hX/+Ch4T/s7q3/7vC + vv+6wr7/u8K//7vDv/+8w8D/vMPA/73Ewf+9xMH/vsXB/77Gwv+/xsL/v8bD/8DHw//Ax8T/wcjE/8HI + xf/BycX/wsnG/8LKxv/Dysf/w8vH/8TLyP/EzMj/xs7K/62uof9jUyr/STMA/15CAP9+WAD/iF8A/41j + AP+KYQD/c1AA/2tLAP9xTwD/c1EA/3ZSAP94VAD/elUA/3xXAP99WAD/f1kA/4BaAP+CWwD/g1wA/4Vd + AP+cbQD/wYcA/8uNAP/NjwD/wYcA/41iAP91UgDoeVUAaIBZAAd9VwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAfQAAAIIEAAB6WAAAdeAAAIr/AAC+/wAAzP8AAMr/AADC/wAAn/8AAIb/AACD/wAA + gv8AAID/AAB//wAAff8AAHv/AAB6/wAAeP8AAHb/AABz/wAAcP8AAGr/AABy/wAAiv8AAI3/AACI/wAA + fv8AAF3/AABK/xQVTv9KTVr/XF9d/15hYP+Gi4n/tby5/7rCvv+6wb7/u8K+/7vCv/+8w7//vMPA/73E + wP+9xMH/vcXB/77Fwv++xsL/v8bD/7/Hw//Ax8T/wMjE/8HIxf/BycX/wsnG/8LKxv/Dysf/w8vH/8XN + yf+ws6f/Z1gx/0kzAP9bQAD/fVgA/4lfAP+NYwD/jGIA/3RRAP9rSwD/cU8A/3RRAP93UwD/eVUA/3pW + AP98VwD/fVgA/39ZAP+BWgD/glsA/4NcAP+FXQD/nW4A/8GHAP/LjQD/zY8A/8GHAP+NYwD/dlIA5HpW + AGCBWwAFflgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfgAAAIQCAAB7UAAA + dtsAAIr/AAC+/wAAzP8AAMr/AADC/wAAn/8AAIb/AACE/wAAgv8AAIH/AAB//wAAfv8AAHz/AAB6/wAA + ef8AAHb/AAB0/wAAcf8AAGr/AAB0/wAAi/8AAI3/AACI/wAAfP8AAFv/AABK/xcYT/9NUFr/XF9d/19i + Yf+KkI3/tr26/7rBvv+6wb7/u8K+/7vCv/+8w7//vMPA/7zEwP+9xMH/vcXB/77Fwv++xsL/v8bC/7/H + w//Ax8T/wMjE/8HIxP/ByMX/wsnF/8LKxv/Ey8j/s7as/2xeOf9JMwD/WT8A/3xXAP+JYAD/jmMA/41j + AP92UwD/a0sA/3JQAP91UgD/d1QA/3lVAP97VgD/fVcA/35YAP9/WQD/gVoA/4NbAP+EXAD/hl4A/51u + AP/BhwD/y40A/82PAP/BhgD/jmMA/3dTAOB7VgBYhFwABH9ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgwAAAJsBAAB9SQAAddoAAIv/AAC+/wAAzP8AAMr/AADC/wAA + n/8AAIb/AACE/wAAg/8AAIH/AACA/wAAfv8AAHz/AAB7/wAAef8AAHf/AAB1/wAAcv8AAGr/AAB2/wAA + jf8AAI3/AACI/wAAe/8AAFn/AABK/xscT/9QU1r/XF9d/2BkYv+PlJH/t767/7rBvv+6wb7/usK+/7vC + v/+7wr//vMO//7zDwP+9xMH/vcXB/77Fwf++xcL/v8bC/7/Gw/+/x8P/wMfE/8DIxP/ByMX/wsrH/7W5 + sf9xZEH/SjMB/1c9AP96VgD/iWAA/45jAP+PZAD/eVQA/2tLAP9yUAD/dlIA/3hUAP96VQD/fFcA/31Y + AP9/WQD/gFoA/4JbAP+DXAD/hF0A/4ZeAP+dbgD/wYcA/8uNAP/NjwD/wYYA/45jAP94VADcfFcAUYdd + AAJqSgAAAAAAAgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg0AAP// + /wAcGxcwHRxExA0NcP8AAIz/AAC+/wAAzP8AAMr/AADB/wAAnv8AAIf/AACF/wAAg/8AAIL/AACA/wAA + f/8AAH3/AAB7/wAAev8AAHj/AAB2/wAAcv8AAGv/AAB4/wAAjv8AAI3/AACJ/wAAev8AAFb/AQFK/x8g + UP9SVlv/W19c/2JlZP+TmJb/uL+7/7rBvf+6wb3/usG+/7vCvv+7wr//vMO//7zDwP+9xMD/vcTB/73F + wf++xcL/vsbC/7/Gw/+/x8P/wMfE/8HJxv+3vLT/dmtJ/0o0Av9VOwD/eVQA/4lgAP+OZAD/j2QA/3tW + AP9sSwD/c1AA/3dTAP95VQD/e1YA/3xXAP99WAD/f1kA/4FaAP+CWwD/hFwA/4VdAP+HXgD/nW4A/8GH + AP/LjQD/zY8A/8GGAP+PZAD/eVUA2X5YAEyQYgABNSUAAAAAABAAAAA4AAAADAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0LgBycGEAMjArMTU0Lr5bW1b9b3KQ/x8ghP8AAIz/AAC+/wAA + zP8AAMr/AADB/wAAn/8AAIf/AACF/wAAhP8AAIL/AACB/wAAf/8AAH7/AAB8/wAAev8AAHn/AAB3/wAA + cv8AAGv/AAB7/wAAj/8AAI3/AACJ/wAAeP8AAFX/AQFK/yMkUf9UWFv/W19c/2RnZv+XnZr/uL+8/7nB + vf+6wb3/usG+/7rCvv+7wr//u8O//7zDwP+8xMD/vcTB/73Fwf++xcL/vsbC/7/Gwv/AyMT/uL63/3tx + Uv9LNgT/UzoA/3dTAP+KYAD/jmQA/5BlAP99VwD/bEsA/3NRAP94VAD/eVUA/3tWAP98VwD/flgA/39Z + AP+BWgD/g1sA/4RcAP+FXQD/h18A/51uAP/BhwD/y40A/82PAP/BhgD/j2QA/3tWANiAWgBJnmsAAf// + bQAODQweAwICXwAAAHEAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NC4ANjQuADY0 + LkI1My3OU1NO/5Walv+rsa7/gYak/yAih/8AAI3/AAC+/wAAzP8AAMr/AADC/wAAn/8AAIf/AACG/wAA + hP8AAIP/AACB/wAAgP8AAH7/AAB8/wAAe/8AAHn/AAB3/wAAc/8AAGv/AAB9/wAAkP8AAI7/AACJ/wAA + dv8AAFP/AgJK/ycoUv9WWVz/W19c/2ZqaP+boZ7/ucC8/7nAvf+5wb3/usG+/7rBvv+7wr//u8O//7zD + wP+8xMD/vcTA/73Ewf++xcH/v8bD/7m/uv+AeFr/TDcG/1E5AP91UgD/iWAA/45kAP+RZgD/f1kA/2xM + AP9zUAD/eFQA/3pVAP98VwD/fVgA/39ZAP+AWgD/glsA/4NcAP+FXQD/hl4A/4dfAP+dbgD/wYcA/8uN + AP/NjwD/wIYA/5BkAP99WADXhFwASMSKAAEAAAABHx4aOCknI6sQDw2XAAAAeAAAACIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0LgA2NC4BNjQuNjY0LpA/PjjRVlZR9nR2cv+Hi4f/X2F+/xAQ + df8AAI3/AAC+/wAAzf8AAMv/AADC/wAAn/8AAIj/AACG/wAAhf8AAIP/AACC/wAAgP8AAH//AAB9/wAA + e/8AAHr/AAB4/wAAc/8AAGz/AAB//wAAkf8AAI7/AACJ/wAAdP8AAFH/AwNK/ystU/9XW1z/W19c/2hs + av+fpaL/ucC9/7nAvf+5wL3/usG9/7rBvv+7wr7/u8K//7zDv/+8w8D/vMTA/77Fwv+6wLv/hX5j/045 + CP9QOAD/c1AA/4pgAP+PZAD/kmYA/4JbAP9tTAD/c1EA/3lVAP97VgD/fFcA/31YAP9/WQD/gVoA/4Jb + AP+EXAD/hV0A/4ZeAP+HXwD/nW4A/8KHAP/LjQD/zY8A/8CGAP+QZQD/f1kA1YZfAEbYkwABMUBfAC4s + Jzw1My7LODYx+BgXFKQAAAB7AAAALgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA1My0ANjQvBDIwKiAyMClcNzUvoj07NcA+PDW+KCdLzgkJc/gAAI7/AAC9/wAAzf8AAMv/AADC/wAA + n/8AAIj/AACG/wAAhf8AAIT/AACC/wAAgf8AAH//AAB+/wAAfP8AAHr/AAB5/wAAc/8AAGz/AACB/wAA + kv8AAI7/AACJ/wAAcf8AAFD/BARK/zAxVP9YXFz/W15c/2tvbf+iqaX/ucC9/7nAvP+5wL3/usG9/7rB + vv+7wr7/u8K//7vDv/+8xMD/usG9/4qEbP9POwv/TjcA/3BPAP+KYAD/j2QA/5NnAP+EXAD/bUwA/3NR + AP96VQD/e1YA/3xXAP9+WAD/f1kA/4FaAP+DWwD/hFwA/4ZeAP+GXgD/iF8A/51uAP/ChwD/zI0A/86P + AP/AhgD/kWUA/4BaANWLYQBE/+oAACovNwEzMStQQ0I81n1/ev9fX1r8GxoWsAAAAH4AAAA8AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMS8oADIxKgAxLigILy0nEDEu + JQ85NykdIB9VkAoKc/oAAI//AAC9/wAAzf8AAMv/AADC/wAAn/8AAIj/AACH/wAAhv8AAIT/AACD/wAA + gf8AAID/AAB+/wAAfP8AAHv/AAB5/wAAc/8AAGz/AACE/wAAkv8AAI7/AACJ/wAAb/8AAE7/BgZL/zQ2 + Vf9ZXF3/Wl5c/25zcP+lrKn/ucC9/7jAvP+5wL3/ucC9/7rBvv+6wb7/u8K//7rBvf+PinT/Uj4P/002 + AP9uTQD/iWAA/49kAP+TZwD/hl4A/25NAP9zUAD/elUA/3xXAP99WAD/flkA/4BaAP+CWwD/g1wA/4Vd + AP+GXgD/h18A/4hfAP+dbgD/wocA/8yNAP/OjwD/wIYA/5JmAP92UgDqTTYAewgGAA1ORzUALy0nL0FA + OtOPk4//yM/L/3d5dP8hHxu9AAAAgQAAAEoAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQyNAA4NisjKCdK0hEReP8BAZD/AAC9/wAA + zf8AAMv/AADC/wAAn/8AAIj/AACH/wAAhv8AAIX/AACD/wAAgv8AAID/AAB//wAAff8AAHv/AAB6/wAA + cv8AAG3/AACG/wAAkv8AAI7/AACJ/wAAbf8AAE3/CAhL/zg6Vf9aXVz/W15c/3F2dP+or6z/ucC8/7i/ + vP+5wLz/ucC9/7rBvv+6wb3/k5B8/1RBE/9MNQD/a0sA/4lgAP+PZAD/k2cA/4lgAP9vTgD/c1AA/3tW + AP98VwD/flgA/39ZAP+AWgD/glsA/4RcAP+FXQD/hl4A/4dfAP+IXwD/nW4A/8KHAP/MjgD/zo8A/8CG + AP+SZQD/d1QB7DspAKABAAB8AAAAXAgHBkwvLSixdHZx/sbOyv/N1dH/homE/ygnIssBAQGDAAAAVwAA + AAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAANzQtADEvJQs6OTKvWVx4/yUmkP8AAI//AAC9/wAAzf8AAMv/AADC/wAAn/8AAIn/AACH/wAA + h/8AAIX/AACE/wAAgv8AAIH/AAB//wAAfv8AAHz/AAB6/wAAcv8AAG7/AACI/wAAk/8AAI//AACI/wAA + av8AAEz/CQpM/zw+Vv9bXlz/W15c/3V6eP+rsq//ucC8/7i/vP+5wL3/ucG9/5eVhP9XRBf/SzQA/2hJ + AP+IYAD/j2UA/5RnAP+LYQD/cE8A/3JQAP97VgD/fVgA/35YAP+AWQD/gVoA/4NbAP+EXAD/hl4A/4df + AP+HXwD/iF8A/51uAP/ChwD/zI4A/86PAP/AhgD/k2YA/4NjFv9OQSHmEA8OmQICAoMKCQiQISAcwVJT + TfmzubX/y9PP/8zV0f+VmpX/MC8q2AQDA4cAAABjAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzMSsAKykkFjs5M8CEh4P/houp/yQl + kP8AAJD/AAC9/wAAzf8AAMv/AADC/wAAn/8AAIn/AACH/wAAh/8AAIb/AACE/wAAg/8AAIH/AACA/wAA + fv8AAH3/AAB7/wAAcf8AAHD/AACK/wAAk/8AAI//AACI/wAAZ/8AAEv/DAxM/0BCV/9bXlz/W15d/3l+ + fP+ttLH/uMC8/7nAvf+bm4r/Wkgc/0ozAP9lRwD/h18A/5BlAP+UaAD/jWMA/3JPAP9yTwD/e1cA/31Y + AP9/WQD/gFoA/4FbAP+DXAD/hV0A/4ZeAP+HXwD/h18A/4hfAP+ebgD/wocA/8yOAP/OjwD/wIUA/5Jm + AP+TdCb/sqyQ/3l8eP4+PTfrLSwn1Dk4M+ViY138p62p/8nRzf/J0c3/zNTQ/6OppP85ODPjBwcGjAAA + AG0AAAARAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAgYFBR0mJB+HTk5J9Jqfm/+qsKz/hYqn/yUmkf8AAJH/AAC9/wAAzf8AAMv/AADC/wAA + n/8AAIn/AACI/wAAh/8AAIb/AACF/wAAg/8AAIL/AACA/wAAf/8AAH3/AAB7/wAAcf8AAHH/AACN/wAA + lP8AAI//AACH/wAAZf8AAEv/Dg9N/0NGV/9bXlz/XF9d/32CgP+wt7T/n6CR/15NIv9JMwD/Y0UA/4df + AP+QZQD/lGgA/49kAP9zUQD/cU8A/3tXAP9+WAD/f1kA/4BaAP+CWwD/hFwA/4VdAP+GXgD/h18A/4hf + AP+JXwD/nm4A/8KHAP/MjgD/zpAA/8CGAP+TZgD/lHQn/7m1mf/Gzsv/wMjE/6Kno/+NkYz/nqOe/73E + wP/J0c3/yNDM/8nQzf/L08//sLay/0NDPe0MCwqTAAAAdAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////AAAAAA4MDApIISAcp0FAOvKDh4P/p62q/6et + qv+pr6v/houo/yYnk/8AAJH/AAC8/wAAzf8AAMv/AADC/wAAn/8AAIn/AACI/wAAh/8AAIf/AACG/wAA + hP8AAIL/AACB/wAAf/8AAH7/AAB7/wAAcP8AAHP/AACO/wAAlP8AAI//AACG/wAAYv8AAEr/ERJN/0dK + WP9bXlz/XWBf/3Jzav9fTyj/SjMA/2BDAP+GXQD/kGUA/5VoAP+RZQD/dVIA/3BPAP98VwD/flgA/4BZ + AP+BWgD/g1sA/4RcAP+GXgD/h18A/4dfAP+IXwD/iWAA/55uAP/ChwD/zI4A/86QAP+/hQD/k2YA/5Z2 + J/+5tZn/xMzJ/8TMyP/Fzcn/x8/L/8jPzP/I0Mz/x8/L/8fPy//Hz8v/yNDM/8nRzf+6wLz/T09K9RER + Dp0AAAB5AAAAJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAUHBwYvGRgVgy4sKNZQUEv7hYmF/6WrqP+mrKn/pqyq/6etqv+pr6v/h4yo/ycolf8AAJL/AAC8/wAA + zf8AAMv/AADC/wAAn/8AAIn/AACI/wAAiP8AAIf/AACG/wAAhP8AAIP/AACB/wAAgP8AAH7/AAB8/wAA + cP8AAHX/AACQ/wAAlP8AAJD/AACF/wAAX/8AAEr/FBVO/0pNWf9SVE3/MywX/zUlAP9cQAD/hF0A/5Bl + AP+VaAD/kmYA/3dTAP9wTgD/fFcA/39ZAP+AWgD/gVsA/4NcAP+FXQD/hl4A/4dfAP+IXwD/iF8A/4lg + AP+ebgD/wocA/8yOAP/OkAD/v4UA/5RnAP+Xdyj/ubWa/8PLyP/Dy8f/xMvH/8TMyP/FzMj/xc3J/8XN + yf/Gzsr/xs7K/8fPy//Hz8v/yNDM/8DIxP9dXln6FxYTqAAAAH0AAAA0AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQEbEhIQZCYlIL1BQTv0bnFs/5idmv+lq6j/pauo/6Wr + qP+mrKn/pqyp/6etqv+pr6v/h4yp/ygplv8AAJP/AAC8/wAAzf8AAMv/AADC/wAAoP8AAIr/AACI/wAA + iP8AAIf/AACG/wAAhf8AAIP/AACC/wAAgP8AAH//AAB7/wAAb/8AAHf/AACS/wAAlP8AAJD/AACD/wAA + Xf8AAEr/FhdM/y0nIv8lGgD/LyEA/2NFAP+OZAD/lWgA/5NnAP95VQD/b04A/3xXAP9/WQD/gVoA/4Jb + AP+EXAD/hV0A/4ZeAP+HXwD/iF8A/4hfAP+JYAD/nm4A/8KHAP/MjgD/zpAA/7+FAP+UZwD/mXkp/7m1 + mv/Cysf/wsrG/8LKxv/Dy8f/w8vH/8TMyP/EzMj/xczJ/8XNyf/Gzcr/xs7K/8fOy//Hz8v/xczI/2xt + aP0dHBi1AAAAfwAAAEEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFBAAAAAAMDAwKRh8e + GqA2NTDnXV5Z/ouQjP+iqKX/pKqn/6Sqp/+kqqf/pKuo/6WrqP+lrKn/pqyp/6atqv+or6v/iI2p/ykq + mP8AAJP/AAC8/wAAzf8AAMz/AADC/wAAn/8AAIr/AACJ/wAAiP8AAIf/AACH/wAAhv8AAIT/AACC/wAA + gf8AAH//AAB8/wAAbv8AAHn/AACU/wAAlP8AAJD/AACC/wAAWv8AAEn/Cwgz/yccCf9ALQD/TDUA/3RR + AP+TZwD/fFcA/29NAP98VwD/gFoA/4FaAP+CWwD/hFwA/4ZeAP+HXwD/h18A/4hfAP+JYAD/iWAA/55u + AP/ChwD/zI4A/86QAP+/hQD/lWgA/5p6Kv+5tZr/wcnG/8HIxf/BycX/wsnG/8LKxv/Dysf/w8vH/8TL + yP/EzMj/xczJ/8XNyf/Gzcn/xs7K/8fOy//Hz8v/fH55/yQjHsQAAAB6AAAALgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAYGBUAGRgVDBsaF3MtLCfUTU1I+nx/e/+cop//o6mm/6Kopv+iqab/o6mm/6Oq + p/+kqqf/pKuo/6WrqP+lq6n/pqyp/6atqv+or6r/iY6p/yormf8AAJT/AAC8/wAAzf8AAMz/AADC/wAA + n/8AAIr/AACJ/wAAiP8AAIj/AACH/wAAhv8AAIX/AACD/wAAgf8AAID/AAB7/wAAbv8AAHv/AACV/wAA + lP8AAJD/AACA/wAAWP8AAEn/FxAw/0EuB/9KNAD/UDgA/2VHAP9uTQD/fFcA/4BaAP+CWwD/g1wA/4Vd + AP+GXgD/h18A/4hfAP+IXwD/iWAA/4phAP+ebgD/wocA/82OAP/OkAD/v4UA/5ZoAP+beyv/uLSa/8DH + xf/Ax8T/wMjE/8HIxf/BycX/wsnG/8LKxv/Dysf/w8vH/8TLx//EzMj/xMzI/8XNyf/Gzcn/xs7K/8jP + zP+ChYH/KScjzwMDAlcAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NC4AMzErADUzLR80MiyIQUE77Gpt + aP+TmJX/oaek/6GnpP+hp6T/oael/6Kopf+iqKb/o6mm/6Opp/+kqqf/pKqn/6WrqP+lq6n/payp/6as + qf+orqr/iY+p/yosmv8AAJX/AAC8/wAAzf8AAMz/AADC/wAAn/8AAIr/AACJ/wAAif8AAIj/AACH/wAA + hv8AAIX/AACD/wAAgv8AAID/AAB7/wAAbv8AAH7/AACW/wAAlP8AAJD/AAB+/wAAVv8BAUn/HhUt/0Yw + Bv9ALAD/PCoA/2ZHAP+BWgD/glsA/4NcAP+FXQD/hl4A/4dfAP+IXwD/iV8A/4lgAP+KYQD/nm4A/8KH + AP/NjgD/z5AA/7+FAP+WaQD/nXwr/7i0mv+/xsT/v8bD/7/Hw//Ax8T/wMjE/8HIxP/ByMX/wsnF/8LK + xv/Dysb/w8vH/8PLx//Ey8j/xMzI/8XMyf/Gzsr/t766/1laVPwgHxukAAAAHQoKCQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAADY0LgAzMSsKNzUwnlZXUv2Hi4f/naOh/6Cmo/+fpaP/oKaj/6CmpP+hp6T/oaek/6Ko + pf+iqKb/oqmm/6Oppv+kqqf/pKqn/6SrqP+lq6j/payp/6asqf+orqr/io+p/ystm/8AAJb/AAC7/wAA + zf8AAMz/AADC/wAAoP8AAIr/AACJ/wAAif8AAIj/AACH/wAAh/8AAIb/AACE/wAAgv8AAIH/AAB7/wAA + bv8AAID/AACX/wAAlP8AAJH/AAB8/wAAVf8CAUj/HRQp/zQlBP89KwD/SDIA/29NAP+EXQD/hl4A/4df + AP+HXwD/iF8A/4lgAP+JYAD/imEA/55uAP/ChwD/zY4A/86QAP++hAD/l2kA/559LP+3tJv/vcXD/77F + wf++xcL/v8bC/7/Gw/+/x8P/wMfE/8HIxP/ByMX/wcnF/8LJxv/Cysb/w8rH/8PLx//Ey8j/xMzI/8TL + yP+BhH//Ly4p1g4NC0kAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANTMtADIwKjRERD7jio6L/5+l + o/+epKH/nqSh/5+lov+fpaP/oKaj/6Cmo/+gp6T/oaek/6Gopf+iqKX/oqmm/6Oppv+jqaf/pKqn/6Sr + qP+lq6j/payp/6asqf+orqr/i5Cp/ywunf8AAJf/AAC7/wAAzf8AAMz/AADC/wAAoP8AAIr/AACJ/wAA + if8AAIj/AACI/wAAh/8AAIb/AACF/wAAg/8AAIH/AAB6/wAAbv8AAIP/AACY/wAAlf8AAJH/AAB6/wAA + VP8CAUf/HhUm/z4sA/9BLgD/TDUA/3VSAP+HXwD/iF8A/4hfAP+JYAD/imEA/4phAP+ebgD/wocA/82O + AP/OkAD/voQA/5hqAP+ffi3/t7Ob/7zEwv+9xMD/vcTB/77Fwf++xcL/vsbC/7/Gw/+/x8P/wMfE/8DI + xP/ByMX/wcnF/8LJxf/Cysb/w8rH/8PLx//Fzcn/pqyn/0ZFQPMZGBWEAAAADgQDAwAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAADY0LgAPCgkANDIreFxdWP2Zn5z/naOg/52joP+do6H/nqSh/5+lov+fpaL/n6aj/6Cm + o/+gpqT/oaek/6Gnpf+iqKX/oqim/6Oppv+jqaf/pKqn/6Sqp/+lq6j/pauo/6asqf+orqn/i5Gp/y0v + nv8AAJf/AAC7/wAAzf8AAMz/AADC/wAAoP8AAIv/AACK/wAAif8AAIj/AACI/wAAh/8AAIf/AACF/wAA + g/8AAIL/AAB6/wAAbv8AAIb/AACZ/wAAlf8AAJH/AAB4/wAAU/8DAkf/Ixki/0EtAv9DLwD/UDgA/3lU + AP+JYAD/iWAA/4phAP+KYQD/nm4A/8KHAP/NjgD/zpAA/76EAP+YagD/oH8u/7azm/+7w8H/u8O//7zD + wP+8xMD/vcTB/73Fwf++xcL/vsbC/7/Gwv+/x8P/wMfE/8DHxP/ByMT/wcnF/8HJxf/Cycb/w8vH/7zD + wP9pamX/JiQgvQYGBS4nJiEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADIvKRQ7OTO/eHt3/52j + oP+cop//nKKg/52joP+do6H/nqSh/56kov+fpaL/n6Wj/6Cmo/+gpqT/oaek/6Gnpf+iqKX/oqil/6Kp + pv+jqab/o6qn/6Sqp/+kq6j/pauo/6Wsqf+nrqn/jJGp/y4wn/8AAJj/AAC7/wAAzf8AAMz/AADC/wAA + oP8AAIv/AACK/wAAif8AAIn/AACI/wAAh/8AAIf/AACG/wAAhP8AAIP/AAB5/wAAbv8AAIn/AACZ/wAA + lf8AAJD/AAB1/wAAUv8FA0b/Jxwf/0IuAf9ELwD/UzoA/31XAP+LYQD/i2EA/55uAP/ChwD/zY8A/8+Q + AP++hAD/mWsA/6GAL/+2s5v/usK//7rCvv+7wr//u8O//7zDv/+8xMD/vcTA/73Ewf++xcH/vsXC/7/G + wv+/xsP/wMfD/8DHxP/AyMT/wcjF/8HJxf/Dysf/kZWQ/zg2MeYTEQ9hAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAADY0LgA1My0AMjApR0tKRe6PlJH/nKKf/5uhn/+cop//nKKg/52joP+do6D/nqSh/56k + ov+fpaL/n6Wi/6Cmo/+gpqP/oaek/6GnpP+hqKX/oqil/6Kopv+jqab/o6qn/6Sqp/+kq6j/pauo/6Ws + qf+nrqn/jZKp/y8xoP8BAZn/AAC7/wAAzf8AAMz/AADC/wAAoP8AAIv/AACK/wAAiv8AAIn/AACI/wAA + iP8AAIf/AACG/wAAhf8AAIP/AAB4/wAAb/8AAIv/AACZ/wAAlf8AAJD/AABz/wAAUv8GBET/Kx4c/0Qw + Af9EMAD/Vz0A/4BaAP+fbwD/wocA/82PAP/PkAD/voQA/5prAP+igS//tbKb/7nBvv+5wL3/usG9/7rB + vv+7wr7/u8K//7zDv/+8w8D/vMTA/73Ewf++xcH/vsXC/77Gwv+/xsP/v8fD/8DHxP/AyMT/wsnG/7C2 + sv9TU076Hx0ZngAAABkJCQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADEvKQQ1My2QZGVh/5mf + nP+aoJ7/m6Ge/5uhn/+cop//nKKf/52ioP+do6D/naSh/56kof+epaL/n6Wi/5+mo/+gpqP/oKak/6Gn + pP+hp6X/oqil/6Kopv+jqab/o6mm/6Sqp/+kqqj/pKuo/6WrqP+nran/jZOp/zAyof8BAZr/AAC7/wAA + zf8AAMz/AADC/wAAoP8AAIv/AACK/wAAiv8AAIn/AACI/wAAiP8AAIf/AACH/wAAhf8AAIP/AAB3/wAA + cP8AAI7/AACa/wAAlf8AAI//AABx/wAAUv8IBUP/LiEY/0UwAP9FMAD/Z0gA/7Z/AP/OkAD/z5AA/76E + AP+bbAD/o4Iw/7Sym/+4v73/uL+8/7nAvP+5wL3/usG9/7rBvv+7wr7/u8K//7vDv/+8w8D/vMTA/73E + wf+9xcH/vsXB/77Gwv+/xsP/v8bD/8DHxP++xcL/eXx3/ywqJtQKCQhQAAAAAQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAA2NC4AMjAqIT89ONF/g3//mqCe/5qfnf+aoJ3/m6Ge/5uhnv+boZ//nKKf/5yi + oP+do6D/naOh/56kof+epKL/n6Wi/5+lo/+gpqP/oKaj/6GnpP+hp6X/oqil/6Kopf+jqab/o6mm/6Oq + p/+kqqf/pKuo/6WrqP+nran/jpOp/zEzov8BAZv/AAC7/wAAzf8AAMz/AADD/wAAoP8AAIv/AACL/wAA + iv8AAIn/AACJ/wAAiP8AAIf/AACH/wAAhv8AAIT/AAB2/wAAcv8AAJD/AACa/wAAlv8AAI//AABv/wAA + Uv8KB0L/MiMW/083AP9hRAD/iWAA/8SJAP++hQD/nG0A/6SDMf+0sZv/t768/7e+u/+3v7v/uL+8/7jA + vP+5wL3/ucC9/7rBvv+6wr7/u8K+/7vDv/+8w8D/vMPA/73EwP+9xMH/vsXB/77Fwv++xsL/wMjF/6Sq + pv9EQz7xExIQmgAAACwBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADY0LgAzMCpdUVFM95KX + lP+Zn53/mqCe/5qgnf+Zn5z/m6Ge/5yin/+coZ//nKKf/5yioP+do6D/naOg/56kof+epKL/n6Wi/5+l + ov+fpqP/oKaj/6CnpP+hp6T/oail/6Kopf+iqKb/o6mm/6Oqp/+kqqf/pKuo/6WrqP+nran/jpSp/zI0 + o/8BAZz/AAC6/wAAzf8AAMz/AADD/wAAoP8AAIz/AACL/wAAiv8AAIr/AACJ/wAAiP8AAIj/AACH/wAA + hv8AAIT/AAB1/wAAc/8AAJL/AACb/wAAlv8AAI7/AABt/wAAUv8NCUD/STMT/2dHAP9oSQD/g1sA/5dq + Af+lhDL/s7Gb/7a9u/+2vbr/tr26/7e+u/+3vrv/uL+7/7i/vP+5wL3/ucC9/7rBvf+6wb7/u8K+/7vC + v/+8w7//vMPA/7zEwP+9xMH/vcXB/77Fwv+/x8P/goWB/ysqJdIDAwN7AAAAIAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAA2NC4AMi8pCjc2MKdsb2v/mJ6c/5KXlf+ChoP/amxo/2BhXf5rbWn/hYmG/5mf + nP+boZ//nKGf/5yin/+do6D/naOg/56kof+epKH/nqSi/5+lov+fpaP/oKaj/6CmpP+hp6T/oael/6Ko + pf+iqKb/o6mm/6Opp/+kqqf/pKqn/6WrqP+nraj/j5Wp/zM1pP8BAZ3/AAC6/wAAzv8AAM3/AADD/wAA + oP8AAIz/AACL/wAAi/8AAIr/AACJ/wAAiP8AAIj/AACH/wAAh/8AAIT/AAB0/wAAdf8AAJT/AACb/wAA + lv8AAI3/AABq/wAAU/8VDj7/UjkQ/19CAP9PNwD/dl8l/62rlv+1vbr/tby5/7W8uf+2vbn/tr26/7e+ + uv+3vrv/uL+7/7i/vP+5wLz/ucC9/7nBvf+6wb7/u8K+/7vCv/+7w7//vMPA/7zEwP+9xMH/vsXB/7vC + v/9pa2b+Hh0ZuAAAAHgAAAAkAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAIAAAAFAAAACgAAAA/AAAAJwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0LgAzMSsyQD854XBz + b/9rbWn/UlJN90A/Odc2NC6dMzErejY0Lp5DQjzibnFt/5idm/+boZ//m6Gf/5yin/+coqD/naOg/52j + of+epKH/nqSi/5+lov+fpaP/oKaj/6CmpP+hp6T/oaek/6Gopf+iqKX/o6mm/6Oppv+jqqf/pKqn/6Sr + qP+mraj/kJWp/zU3pf8CAp//AAC6/wAAzv8AAM3/AADD/wAAoP8AAIz/AACL/wAAi/8AAIr/AACJ/wAA + if8AAIj/AACH/wAAh/8AAIT/AABz/wAAd/8AAJb/AACb/wAAlv8AAIz/AABp/wAAU/8XEDz/Qi4O/1ND + Gf9bWlH/hYqJ/7C3tP+1vLj/tby4/7W8uf+2vbn/tr26/7e+uv+3vrv/uL67/7i/vP+4wLz/ucC9/7nB + vf+6wb7/usK+/7vCv/+7wr//vMO//7zDwP+9xMH/t767/11eWfsYFxSrAAAAfgAAAEwAAAAKAAAAAAAA + AAAAAAAVAAAAQgAAAF0CAgJxAwMDfwAAAHwAAAAuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAA2NC4ANjQuADY0LnM5NzL1Pz442jc1L6EzMCpeMi8pJTEvKQc9OzYAMS4oBjIv + KUY+PTfWen56/5uhn/+boZ7/m6Gf/5yin/+cop//naOg/52jof+epKH/nqSh/5+lov+fpaL/oKaj/6Cm + o/+gpqT/oaek/6Gopf+iqKX/oqmm/6Oppv+jqaf/pKqn/6SqqP+nrqn/hoiW/yIdgP8AAJ3/AAC7/wAA + zv8AAM3/AADD/wAAoP8AAIz/AACL/wAAi/8AAIr/AACK/wAAif8AAIj/AACI/wAAh/8AAIT/AABy/wAA + ev8AAJj/AACb/wAAl/8AAIv/AABn/wAAU/8XE0H/TEtM/1ldW/9dYF//iY6M/7G4tf+0u7j/tLu4/7W8 + uf+2vLn/tr26/7a9uv+3vrr/t767/7i/vP+4v7z/ucC8/7nAvf+6wb3/usG+/7vCvv+7wr//u8O//7zE + wP+4v7v/YmNe/BwaF7IAAAB+AAAAfAAAAFsAAAA2BQUEPQoKCHYREA6cGxoXsycmIssgHxu3AgICZwAA + AA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0LgA2NC4CNjQuVDY0 + LmQzMCooMS8pCC4oIwAxLykAAAAAAAAAAAA2NC4ALSokATMxK4RiY1//mZ+d/5qgnv+boJ7/m6Ge/5yi + n/+cop//nKOg/52joP+eo6H/nqSh/56kov+fpaL/n6Wj/6Cmo/+gpqT/oaek/6Gnpf+iqKX/oqil/6Op + pv+jqab/pKuo/5ygmP9vYjv/SzUY/yAXb/8CAZ//AAC7/wAAzv8AAM3/AADD/wAAoP8AAIz/AACM/wAA + i/8AAIv/AACK/wAAif8AAIj/AACI/wAAiP8AAIP/AABy/wAAfP8AAJr/AACb/wAAl/8AAIr/AABm/wAB + VP8dHlT/T1JZ/1lcWv9eYmD/jZKQ/7K5tv+0u7j/tLu4/7W8uf+1vLn/tr25/7a9uv+3vrr/t767/7i/ + u/+4v7z/ucC8/7nAvf+6wb3/usG+/7rCvv+7wr//u8O//7zEwP+ChYH/MC8p3Q4ODJUBAQGBAQEBgREQ + DpgoJyLJOjgz50xMR/VdXVj8QD85/R8eG7UAAAA9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAANjQuADY0LgA2NC4CNjQuADY0LgAAAAAAAAAAAAAAAAAAAAAAAAAAADY0 + LgAAAAAANDIsgWJkX/+Zn5z/mqCd/5qgnf+boJ7/m6Ge/5uhn/+cop//nKKg/52joP+do6H/nqSh/56k + ov+fpaL/n6Wi/6Cmo/+gpqT/oaek/6GnpP+hqKX/oqil/6Oqp/+doZr/cmZC/1U9A/9kRgD/d1MV/zMk + b/8CAaD/AAC6/wAAzv8AAM3/AADD/wAAoP8AAIz/AACM/wAAi/8AAIv/AACK/wAAif8AAIn/AACI/wAA + iP8AAIP/AABx/wAAf/8AAJv/AACc/wAAl/8AAIj/AABk/wEBVP8gIlX/UVRZ/1lcWv9gY2L/kZaU/7O5 + tv+0u7j/tLu4/7W8uP+1vLn/tr25/7a9uv+2vbr/t767/7i/u/+4v7z/uMC8/7nAvf+5wb3/usG9/7rB + vv+7wr7/vMPA/7G3tP9vcWz+Ozo16SYkIMgjIh7DPTw363Fzbv+coZz/sbez/5icmP88OzbqDg0MggAA + ABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADIvKQ85NzG0cnVx/5qfnf+Zn5z/mZ+d/5qg + nf+aoJ7/m6Ge/5uhn/+cop//nKKf/52joP+do6D/nqSh/56kof+epaL/n6Wi/6Clo/+gpqP/oKak/6Gn + pP+iqKb/nqKd/3ZrSv9WPgT/YkUA/4VeAP+aawD/i2EU/zYmbv8BAaD/AAC7/wAAzv8AAM3/AADD/wAA + oP8AAIz/AACM/wAAjP8AAIv/AACK/wAAiv8AAIn/AACI/wAAiP8AAIL/AABw/wAAgv8AAJ3/AACb/wAA + l/8AAIb/AABj/wICVf8kJlb/UlZZ/1lcWv9iZWT/lZqY/7O6t/+0u7f/tLu4/7S7uP+1vLn/tby5/7a9 + uv+2vbr/t766/7e+u/+4v7z/uL+8/7nAvP+5wL3/usG9/7rBvv+7wr7/vMPA/7a9uf+XnJj/eHt2/3Fz + bv+Vmpb/u8K+/8HIxf++xcH/cHNt/yUjH8UCAgJOAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0 + LgA1My0AMzAqSEhHQuuJjov/mZ+c/5ienP+Zn5z/mZ+d/5qfnf+aoJ3/m6Ge/5uhnv+cop//nKKf/52i + oP+do6D/naOh/56kof+epKL/n6Wi/5+lo/+gpqP/oail/52inv95cFH/WEAG/2FEAP+EXAD/mGoA/5xt + AP+gcAD/eVQU/yYbbv8CAaL/AAC7/wAAzv8AAM3/AADD/wAAoP8AAIz/AACM/wAAjP8AAIv/AACL/wAA + iv8AAIn/AACJ/wAAiP8AAIH/AABw/wAAhf8AAJ7/AACb/wAAl/8AAIX/AABi/wIDVv8oKlf/VFda/1hc + Wf9laGb/mJ2b/7K5tv+0u7j/tLu4/7S7uP+1vLj/tby5/7a9uf+2vbr/t766/7e+u/+4v7v/uL+8/7jA + vP+5wL3/usG9/7rBvv+6wr7/u8O//73Ewf+8w8D/u8O//77Fwv++xcH/v8bD/6iuqv9HR0LzExIQlAAA + ACIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADMxKg84NjCraGpm/5acmf+XnZr/mJ2b/5ie + m/+Znpz/mZ+c/5mfnf+aoJ3/m6Ce/5uhnv+boZ//nKKf/5yioP+do6D/naOh/56kof+epaL/oKaj/5yi + oP+MkY3/cWhM/1pCCP9gRAD/glsA/5hqAP+cbQD/n3AA/4phAP9yUAD/cU8T/zAibf8CAaL/AAC7/wAA + zv8AAM3/AADD/wAAoP8AAIz/AACM/wAAjP8AAIv/AACL/wAAiv8AAIn/AACJ/wAAif8AAID/AABw/wAA + h/8AAJ//AACc/wAAl/8AAIP/AABi/wQEV/8sLlf/VVla/1hcWf9jZmX/g4iG/6Kopv+yubb/tby4/7S7 + uP+1vLj/tby5/7a8uf+2vbr/tr26/7e+u/+3v7v/uL+8/7jAvP+5wL3/ucC9/7rBvv+6wb7/u8K+/7vC + v/+8w8D/vMPA/73EwP++xcH/gIN+/ywrJtUFBQVhAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0 + LgA1My0AMzAqUklJRPCJjYv/l52a/5ecmv+XnZr/mJ2b/5iem/+Ynpz/mZ+c/5mfnf+aoJ3/mqCe/5uh + nv+boZ7/nKKf/5yioP+do6D/nqSh/5qgnv+Ijoz/bG9r/1lQNv9XPwb/YEMA/4BaAP+YagD/nW0A/6Fw + AP+NYwD/cU8A/35YAP+KYAD/e1YT/zIjbP8CAaP/AAC7/wAAzf8AAM3/AADD/wAAn/8AAIz/AACM/wAA + jP8AAIz/AACL/wAAiv8AAIr/AACJ/wAAiP8AAH//AABw/wAAiv8AAKD/AACc/wAAl/8AAIH/AABh/wUF + WP8wMVj/U1da/1hcWf9ZXVr/ZWhm/4GGg/+gp6T/srm1/7W8uf+1vLj/tby5/7W8uf+2vbn/tr26/7e+ + u/+3vrv/uL+7/7i/vP+5wLz/ucC9/7rBvf+6wb7/u8K+/7vCv/+7w7//vcTB/7C3s/9UVU/6GRgVpwAA + ADEFBQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADMxKxM4NzG1a25q/5WbmP+Wm5n/lpyZ/5ac + mv+XnZr/l52b/5iem/+Ynpv/mZ6c/5mfnf+aoJ3/mqCd/5uhnv+boZ//nKKg/5ienP+Gi4n/aWtn/1VQ + Pv9SQxv/Vz8E/2BDAP9+WAD/mGoA/51uAP+hcAD/kGUA/3JPAP99VwD/iF8A/4lgAP+LYgD/fVcS/zMk + a/8CAaT/AAC7/wAAzf8AAM3/AADD/wAAn/8AAIz/AACM/wAAjP8AAIz/AACL/wAAiv8AAIr/AACJ/wAA + if8AAH7/AABw/wAAjv8AAKD/AACc/wAAl/8AAH//AABh/wQEWf8cHlf/PD9Y/1JWWf9ZXFn/WVxa/2Nn + Zf9/hIH/n6Wj/7K4tf+1vLn/tby5/7W8uf+2vbn/tr26/7e+uv+3vrv/uL+7/7i/vP+4wLz/ucC9/7nB + vf+6wb7/usK+/7vCv/+9xMH/j5OO/zQzLuIKCghzAAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0 + LgA2NC0AMzErXUxMR/SKj4z/lZuY/5WamP+Vm5j/lpuZ/5acmv+XnJr/l52a/5idm/+Ynpv/mZ6c/5mf + nP+aoJ3/m6Ge/5acmv+DiIf/Zmhk/1NOO/9PQBj/UzwF/1k/AP9lRwD/f1kA/5dqAP+dbgD/onEA/5Nn + AP9yUAD/e1YA/4lgAP+JYAD/imEA/4thAP+NYgD/f1kR/zQla/8CAqX/AAC7/wAAzv8AAM7/AADD/wAA + n/8AAIz/AACM/wAAjP8AAIz/AACL/wAAi/8AAIr/AACJ/wAAif8AAHz/AABx/wAAkP8AAKD/AACc/wAA + l/8AAID/AABm/wAAWv8FBVX/GhtU/zo8Vv9SVVn/WVxa/1lcW/9iZmT/fYKA/56kof+xuLX/tr25/7W8 + uf+2vbn/tr26/7e9uv+3vrv/t7+7/7i/vP+4v7z/ucC8/7nAvf+6wb7/u8K+/7W8uP9jZF/9IB4auQAA + AEEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADMxKxk6ODK/b3Ft/5Sal/+UmZf/lJqX/5Wa + mP+Vm5j/lpuZ/5acmf+WnJr/l52a/5idm/+Ynpz/mZ+c/5SamP+AhoT/ZGZh/1FLOP9MPBb/TzkE/1U8 + AP9hRQD/dlMA/4thAP+YawD/nW4A/6JxAP+WaQD/dFEA/3pVAP+IYAD/imEA/4phAP+LYQD/jGIA/4xi + AP+NYwD/f1kR/zUlav8DAqX/AAC7/wAAzv8AAM7/AADD/wAAn/8AAIz/AACM/wAAjP8AAIz/AACM/wAA + i/8AAIr/AACK/wAAif8AAHv/AABy/wAAk/8AAKH/AACc/wAAmP8AAIv/AAB2/wAAYv8AAFX/BARQ/xga + UP84O1T/UVVZ/1lcWv9ZXFr/YWVj/3yBfv+do6D/sbi1/7a9uv+2vbn/tr26/7a9uv+3vrr/t767/7i/ + u/+4v7z/ucC8/7nAvf+7wr//m6Cc/z49OO0PDg2HAAAAGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0 + LgA/PzoAMzEraE9PSveKj43/k5mW/5OZlv+UmZf/lJqX/5WamP+Vm5j/lZuZ/5acmf+XnJr/mJ2b/5KY + lv9+g4H/YmRe/09JNv9KOxX/TDYD/1E5AP9eQgD/c1EA/4hgAP+UaAD/mWsA/51uAP+icQD/mmsA/3ZS + AP95VAD/iGAA/4phAP+KYQD/i2EA/4xiAP+MYgD/jGIA/4xiAP+NYwD/kGUQ/0w1af8EA6b/AAC8/wAA + zv8AAM7/AADD/wAAn/8AAIz/AACM/wAAjP8AAIz/AACM/wAAi/8AAIr/AACK/wAAif8AAHn/AAB0/wAA + l/8AAKH/AACd/wAAmf8AAJT/AACI/wAAdP8AAF7/AABR/wQETf8XGE7/ODpU/1FUWf9ZXFr/WV1a/2Fl + Y/97gH3/naOg/7G4tf+2vbr/tr26/7a9uv+3vrr/t767/7i/u/+4v7z/ucC9/7nAvP9ydG//KCcivwMD + A0QAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADMxKx87OjTIcXRw/5KYlv+SmJX/k5iW/5OZ + lv+TmZf/lJqX/5SamP+Vm5j/lpyZ/5CWlP98gX//YGJc/05INP9JOhP/SjUD/002AP9aPwD/cE8A/4Vd + AP+RZgD/lmkA/5lrAP+dbgD/onEA/6VzAP+FXQD/dlMA/4hgAP+KYQD/i2EA/4thAP+MYgD/jGIA/4xi + AP+MYgD/jGIA/51uAP/EiQD/vYQQ/1I5aP8EA6b/AAC8/wAAzv8AAM7/AADD/wAAn/8AAIz/AACM/wAA + jP8AAIz/AACM/wAAi/8AAIv/AACK/wAAif8AAHf/AACB/wAApP8AAKH/AACd/wAAmf8AAJX/AACQ/wAA + hf8AAHD/AABb/wAATv8DA0v/FhdO/zY4VP9QU1n/WV1a/1ldWv9hZGL/en98/5yhn/+xuLX/tr66/7a9 + uv+2vrr/t767/7nAvf+2vbr/l5yY/0pJROspJyJOAAAAAwMCAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0 + LgAtKyUBNDIsc1JTTvqLkI3/kZeV/5GXlP+Sl5X/kpiW/5OYlv+TmZb/lJqX/46Ukv96fn3/XmBa/01H + Mv9JOhL/STQD/0s1AP9WPQD/bEwA/4FaAP+NYwD/kWYA/5VoAP+abAD/nm8A/6JxAP+mdAD/qHUA/4Nc + AP+EXAD/i2EA/4thAP+MYgD/jGIA/4xiAP+MYgD/jGIA/4xiAP+dbgD/wogA/8+QAP/RkQD/rnoP/0Qw + Z/8EA6f/AAC8/wAAzv8AAM7/AADD/wAAn/8AAIz/AACM/wAAjP8AAIz/AACM/wAAjP8AAIv/AACL/wAA + hP8AAIH/AACm/wAApf8AAKH/AACd/wAAmv8AAJX/AACR/wAAjP8AAIH/AABt/wAAV/8AAEv/AwNK/xUV + Tv81N1T/UFNZ/1ldWv9ZXVr/YWRi/3l+fP+boZ7/sbi1/7i/u/+1vLn/oKWh/3Fzbv9HR0HkNjQugjUz + LQs2NC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADIvKQk3NjCramxo/5GWlP+QlpP/kZaU/5GX + lP+Sl5X/k5mW/5KYlv97gH7/XV5X/01GMP9JORH/STQC/0s0AP9UOwD/aEkA/31XAP+IXwD/jWMA/5Jm + AP+XaQD/mGoA/5JmAP+cbQD/pnQA/6p3AP+teQD/j2QA/4deAP+LYQD/jGIA/4xiAP+MYgD/jGIA/4xi + AP+MYgD/nW4A/8KIAP/PkAD/z5AA/76EAP+reQL/moBI/0NDpP8EBKv/AAC8/wAAzv8AAM7/AADD/wAA + n/8AAIz/AACM/wAAjP8AAIz/AACM/wAAjP8AAIv/AACH/wAAjP8AAKv/AACp/wAApf8AAJz/AACR/wAA + l/8AAJb/AACR/wAAjf8AAIf/AAB9/wAAaf8AAFX/AABL/wIDSv8UFU7/NDZU/09SWf9ZXVv/Wl1a/2Fk + Y/94fXv/kJWS/3V3c/5KSkTnNjQumjEvKTs0MiwHMzErAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA2NC4AMC0nBTY1L5tnaWX/kJaT/5CVk/+QlpP/kpeV/5CVk/+EiYf/cHJq/1FKNP9JOBD/STQC/0s0 + AP9TOwD/ZUcA/3hUAP+DXAD/iWAA/41jAP+SZgD/lWgA/4thAP9xTwD/W0AA/3ZTAP+ndQD/rnoA/7J8 + AP+jcgD/i2EA/4xiAP+MYgD/jGIA/4xiAP+MYgD/jGIA/51uAP/CiAD/z5AA/8+QAP++hQD/q3kD/6eK + P/+lpZb/l52n/0NGqv8EBKv/AAC8/wAAzv8AAM7/AADD/wAAn/8AAIz/AACM/wAAjP8AAIz/AACM/wAA + jP8AAIr/AACg/wAAsf8AAK7/AACo/wAAef8AAFr/AABu/wAAif8AAJT/AACS/wAAjf8AAIj/AACD/wAA + eP8AAGb/AABU/wAAS/8CAkr/ExRO/zM1VP9OUln/UVNR/zs8Ov8sLCn2KSgjwyclIVMqKCMKKSciAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0LgD8//8ANDIsgl5fW/+OlJL/kJWT/46U + kv+BhoT/Z2po/1JMOv9KOhH/STQC/0s0AP9TOgD/Y0YA/3RSAP9+WQD/hFwA/4lgAP+OYwD/kWYA/4pg + AP9zUQD/XkIA/1Y9A/9WPgT/W0AA/5dpAP+zfQD/tX4A/7V+AP+fbwD/jWMA/4tiAP+MYgD/i2EA/4xi + AP+ebwD/wogA/8+QAP/PkAD/v4UA/6t5A/+nij//oqOW/6Kop/+jqqb/l52n/0VHqv8EBKz/AAC9/wAA + zv8AAM7/AADD/wAAn/8AAIz/AACL/wAAjP8AAIv/AACM/wAAnf8AALT/AAC0/wAAsv8AAJn/AABc/wQE + Vv8EBFf/AABd/wAAcv8AAIj/AACQ/wAAjf8AAIj/AACD/wAAfv8AAHT/AABk/wAAU/8AAEv/AgJK/xES + TP8bHDX7FhUU1QsKB6ICAgGCAAAAaAAAAD8AAAAUAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAANjQuADY0LgAzMStpVldS+4ySkP+Fion/aWxp/1BOQP9JPiP/STYH/0s0AP9SOgD/YUQA/3BP + AP96VQD/f1kA/4RcAP+JYAD/jmQA/49kAP+DWwD/gFoA/5NoAP+wfAD/vocD/7F+A/9gRAH/dVIA/7F7 + AP+4gAD/u4MA/7qCAP+ndQD/lmkA/5NnAP+ZawD/rHgA/8WJAP/PkAD/z5AA/8CGAP+qeAH/oIM6/6Ch + lf+hp6X/oaek/6Gopf+jqqX/l52n/0ZJqv8FBaz/AAC+/wAAzv8AAM7/AADF/wAArf8AAJn/AACT/wAA + lf8AAKX/AAC5/wAAuv8AALf/AACx/wAAef8BAV7/AwSu/wQEwP8AALH/AACU/wAAgP8AAIH/AACO/wAA + jf8AAIj/AACD/wAAfv8AAHn/AABw/wAAYf8AAFP/AABL/wEBRfgBATPKAAAengAABoUAAACAAAAAfwAA + AGoAAAA3AAAACwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACmoJQANTMtADMxKlJNTUj1cXVy/1dU + Rv9JPBv/STUG/0k0AP9JNAD/VDsA/2xMAP91UgD/elUA/39ZAP+EXAD/iWAA/41jAP+JYAD/qHYA/4Ve + Af+CXAL/pnYC/8SLA//NkQT/s4AH/19GB/9cQQD/nG0A/7yDAP++hQD/wYcA/8OIAP/AhgD/v4UA/8WJ + AP/MjgD/zpAA/9CRAP/GigD/rHkA/5F0Kv+Vlor/oKal/6Cmo/+gp6T/oaek/6Gnpf+jqaX/mJ6m/0ZI + qv8DBK7/AADE/wAAz/8AAM3/AADL/wAAxP8AAL7/AAC//wAAwv8AAMH/AAC9/wAAu/8AAJ//AABe/wgI + Xv8JCbH/BQXO/wQExv8DA6j/AgKD/wEBgv8AAKj/AACK/wAAjP8AAIj/AACD/wAAfv8AAHn/AAB0/wAA + bP8AAFb/AABK/wAASv8AAEb0AAA60gAAIKIAAAWEAAAAgAAAAH0AAABaAAAAHwAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAtKyQALCokQTcyJu9JPiH/STUH/0ozAP9ROQD/YUQA/2RHAP9aPwD/clAA/3pV + AP9/WQD/hF0A/4lgAP+PZAD/i2EA/2pKAP9+WQD/elgH/2JJC/9uUQv/hGEL/5pwCv+idgr/oXMG/25N + AP94VAD/uYIA/8KHAP/EiQD/xooA/8iMAP/LjgD/zI8A/86QAP/QkQD/zY8A/7V/AP+Rbhj/fn1v/52j + ov+fpaL/n6Wj/6Cmo/+gpqT/oaek/6Gnpf+jqaX/lZqm/zU3q/8AALT/AADM/wAA0P8AAM7/AADM/wAA + yv8AAMj/AADG/wAAw/8AAMH/AAC6/wAAfP8AAGv/Bweh/w0Npv8NDp7/Dg6J/w4Pcv8PD2X/Cgp6/wEB + f/8AAGn/AACJ/wAAjv8AAIn/AACE/wAAfv8AAHn/AABy/wAAW/8AAGT/AABh/wAAUv8AAEr/AABG9AAA + N8sAABaWAAABgAAAAIEAAABwAAAANQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOyoAAB4VABc0JgONQi8D+Ekz + AP9ROQD/bEsA/4VdAP+EXQD/g1wA/2hJAP9tTAD/gFkA/4RdAP+KYAD/jmQA/5RoAP+TZwD/b04A/2tM + AP+2gQH/jmQC/35ZAf+jcwH/yY4B/9ybAf/UlgL/e1kE/1xCAP+icQD/xYoA/8eKAP/JjAD/y40A/82P + AP/OkAD/0JEA/9KSAP/AhgD/onUI/29lRv+Nk5P/n6Wi/56kov+fpaL/n6Wi/6Cmo/+gpqT/oaek/6Gn + pP+jqqX/f4Sn/xUWrf8AAL7/AADR/wAA0P8AAM7/AADM/wAAyv8AAMj/AADG/wAAxf8AAKX/AABf/wUF + d/8DA9L/AgLc/wICy/8CAqX/AgJ//wICi/8CArf/AABv/wAAbP8AAJL/AACT/wAAjv8AAIn/AACE/wAA + f/8AAG7/AABm/wAAgv8AAIT/AACF/wAAbf8AAFL/AABJ/gAAQ+kAACmxAAAHhQAAAIAAAAB6AAAARwAA + AAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAJxsAAE02AAA0JQAkPywApUcyAPdMNQD/Y0UA/4hfAP+cbQD/mmsA/4phAP+EXQD/elYA/2lJ + AP+CWwD/imEA/49kAP+TZwD/l2oA/5xtAP+JYAD/aEoA/5FmAP+HYAX/ZUoK/29SCv+DYAv/kmsL/5Zu + C/+LZQn/clEB/3xXAP/BhgD/yowA/8uNAP/NjwD/z5AA/9GRAP/TkwD/zY8A/7N+AP+DZyH/am1p/5qg + nv+do6H/nqSh/56kof+epaL/n6Wi/6Clo/+gpqP/oKak/6GnpP+gpqX/TE+q/wEBsv8AAMv/AADS/wAA + 0P8AAM7/AADM/wAAyv8AAMj/AADB/wAAgP8BAXD/CguM/w8Pmv8ODpf/Dg6H/w0Oc/8MDWf/BweG/wAA + k/8AAGj/AACG/wAAm/8AAJb/AACS/wAAjv8AAIn/AACC/wAAaf8AAHj/AACE/wAAif8AAJj/AACc/wAA + if8AAGT/AABN/wAAR/gAADbJAAAPjgAAAIAAAAB+AAAAUQAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEgzAAA9KgAARDAALEYxALhIMwD9UzoA/3lV + AP+ebwD/pnQA/6FwAP+aawD/kWYA/4ZeAP+DXAD/cE8A/35YAP+PZAD/k2cA/5dqAP+bbQD/oHAA/5tt + AP94VQD/Y0UA/6N0A/+OZQX/dVQD/5ZrAv+/hwL/2poB/+GfAf+gcQH/YUUA/6Z0AP/MjgD/zY8A/8+Q + AP/RkQD/05MA/9STAP/DiQD/pncH/2VbPf95fn7/naOg/52ioP+do6D/naOh/56kof+epKL/n6Wi/5+l + o/+gpqP/oKak/6OppP+Ahaf/EhKu/wAAwf8AANL/AADS/wAA0P8AAM7/AADM/wAAy/8AAKn/AABi/wEB + mv8BAeD/AgLb/wIDwf8DA5n/BAV3/wYGjf8EBKb/AABk/wAAdv8AAJr/AACf/wAAmv8AAJb/AACS/wAA + jv8AAH//AABv/wAAgv8AAIX/AACQ/wAAmP8AAJ//AACl/wAAnv8AAHv/AABU/wAASf0AAD3aAAAXlgAA + AH8AAAB/AAAAUwAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABKNAAASTQAAEo0ADBJNAC/STMA/1xAAP+NYgD/rHgA/656AP+odQD/oXAA/5tsAP+XagD/i2IA/4Vd + AP98VwD/d1QA/5FmAP+XagD/nG0A/6BwAP+kcgD/pnQA/5BmAP9uTgD/o3MA/6FyAv9uTwf/dlUI/4xm + Cf+ccQr/nnML/4RhCv9sTQL/f1kA/8WKAP/QkAD/0ZEA/9OTAP/UkwD/0pMA/7qDAP+Tbxb/V1dP/4aM + iv+coqD/nKKf/5yioP+do6D/naOh/56kof+epKH/n6Wi/5+lo/+gpqP/oaej/5qgpP8zNav/AAC4/wAA + 0f8AANP/AADS/wAA0P8AAM7/AADG/wAAg/8CAmz/DAyE/w0NoP8MDJ//CwuQ/wkKef8ICG7/AwOe/wAA + pv8AAG7/AACO/wAApf8AAKP/AACf/wAAm/8AAJf/AACR/wAAeP8AAHv/AACE/wAAiv8AAJb/AACZ/wAA + oP8AAKf/AACt/wAAq/8AAI7/AABd/wAASv8AAEDiAAAamgAAAH8AAAB/AAAATQAAAAkAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASjQAAEo0AABKNAAtSjQAwko0AP9iRQD/mmwA/7R+ + AP+2fwD/sHsA/6p2AP+icQD/nW0A/5psAP+TZwD/h18A/4RdAP94VAD/jGIA/5xtAP+gcAD/pHIA/6h1 + AP+seAD/onIA/4FbAP9kRgD/iWID/4diCP9rTQf/g14G/6l5Bf/JjwT/15gC/7qDAP9qSwD/qHUA/9KS + AP/TkwD/05MA/9WUAP/OkAD/tH8A/35lJv9WWVj/jpOR/5uhn/+boZ7/nKKf/5yioP+do6D/naOg/56k + of+epKH/n6Si/5+lov+fpqP/oaej/1ZZqf8BAbP/AADN/wAA1P8AANP/AADS/wAA0f8AAKz/AABq/wAA + tf8DA9j/BQXL/wYGrP8ICIf/CQlu/woKh/8FBY3/AABk/wAAf/8AAKH/AACr/wAAp/8AAKP/AACf/wAA + m/8AAI3/AAB3/wAAg/8AAIb/AACR/wAAmf8AAJz/AACg/wAAqP8AAK//AAC0/wAAs/8AAJz/AABl/wAA + Sv8AAEHkAAAZmQAAAH8AAAB9AAAAPgAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0 + AABKNAAASjQAIEo0ALdJNAD/ZUcA/6JxAP+6ggD/u4MA/7eAAP+yfAD/qncA/6JyAP+fbwD/nG0A/5lq + AP+LYgD/hF0A/3hUAP+CWwD/n28A/6RzAP+odQD/rHgA/7B7AP+uegD/mGsA/3BPAP+jcwD/u4UB/3xY + A/98WQT/mm4F/7B+Bv+0gQf/mG4I/2hKAv+AWgD/yo0A/9SUAP/UlAD/1pUA/8qNAP+ufAP/bV0z/1hc + Xf+Rl5T/m6Ge/5uhnv+boZ7/m6Gf/5yin/+doqD/naOg/52jof+epKH/nqSi/5+lov+iqKL/cHWn/wcI + sf8AAMj/AADV/wAA0/8AANP/AADL/wAAhP8CAmf/CQmW/wgItP8HB7H/Bgac/wUFf/8DBHr/AQG4/wAA + qP8AAG//AACW/wAArf8AAK//AACr/wAAp/8AAKP/AACe/wAAg/8AAHf/AACE/wAAiv8AAJf/AACb/wAA + nv8AAKH/AACp/wAAsP8AALb/AAC6/wAAuf8AAKP/AABo/wAASv8AAD/fAAATkgAAAIAAAAB2AAAAKAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASjQAAEo0ABBKNACcSTMA/WJFAP+kcgD/voUA/8CG + AP+8gwD/uIAA/7N9AP+qdgD/pHIA/6FxAP+fbwD/m2wA/4xjAP+DXQD/e1YA/39ZAP+abAD/qXYA/6x4 + AP+wewD/s30A/7V+AP+odgD/iWAA/29OAP+BXAP/fVsK/2VKCv9zVAn/kWkI/619B/+8hwb/u4QC/3dU + AP+pdgD/1ZQA/9WUAP/XlQD/xosA/6p6Bv9iWDr/Wl5e/5KYlf+aoJ3/mqCd/5qgnv+boZ7/m6Gf/5yi + n/+coqD/naOg/52jof+epKH/nqSh/6Gnov+AhaX/DxCw/wAAxP8AANX/AADU/wAA1P8AAK3/AAB2/wIC + uf8GB77/CAiv/wkJk/8LC3b/DQ1n/w0Nf/8EBIP/AABv/wAAhv8AAKf/AAC0/wAAsv8AAK//AACs/wAA + qP8AAJv/AAB//wAAev8AAIP/AACL/wAAmv8AAJ7/AACg/wAAo/8AAKj/AACx/wAAt/8AALv/AAC//wAA + vv8AAKX/AABl/wAASf8AADrSAAALiQAAAIEAAABkAAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0 + AABKNAACSjQAbkkzAPVaPwD/n28A/8CGAP/DiQD/wYcA/72EAP+5gQD/sn0A/6p3AP+mdAD/pHIA/6Fx + AP+cbQD/i2IA/4JcAP+MYgD/jmQA/5JmAP+rdwD/sHsA/7N9AP+2fwD/uYEA/7V/AP+ebwD/c1EA/41k + AP/HjQH/i2IB/39ZAv+icwL/w4oB/9GTAP/CiQD/dVIA/45jAP/UkwD/1pUA/9eWAP/EiQD/pngI/1xV + P/9ZXV3/kZeU/5mfnf+Zn53/mqCd/5qgnv+boZ7/m6Gf/5yin/+cop//naOg/52joP+do6H/n6Wh/4iN + pP8WF6//AADC/wAA1v8AANX/AADU/wAAk/8AAHL/AAC//wAA0f8BAcX/AgKk/wICgP8CAoj/AQHG/wAA + k/8AAHH/AACc/wAAtP8AALn/AAC1/wAAsv8AAK//AACr/wAAk/8AAI3/AACM/wAAgv8AAIr/AACa/wAA + oP8AAKL/AACl/wAAqP8AALH/AAC4/wAAvP8AAMD/AADC/wAAwP8AAKL/AABd/wAASPsAAC+7AAACgQAA + AH8AAABDAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKNAAASjQAAEo0ADZJNADcUDgA/5JmAP/BhwD/xooA/8SJ + AP/ChwD/voUA/7qBAP+xewD/q3gA/6l2AP+mdAD/pHIA/5xtAP+KYAD/hl4A/6RzAP+lcwD/lmkA/6d0 + AP+0fQD/tn8A/7mBAP+9hAD/voUA/616AP+PZQD/eFQA/49mAv97Wgr/YkkL/21QCf+MYwP/pXQA/657 + AP+reAD/voQA/9aVAP/XlgD/2JYA/8OIAP+kdwr/WlRB/1ZaWv+OlJL/mZ+c/5menP+Zn5z/mqCd/5qg + nf+boJ7/m6Ge/5yhn/+cop//nKKg/52joP+fpaH/io+j/xkar/8AAMH/AADW/wAA1v8AANX/AAC//wAA + q/8AAK7/AACm/wMDjv8JCnD/DA1j/wsLe/8DA5D/AAB5/wAAjf8AAK3/AAC9/wAAvP8AALn/AAC1/wAA + s/8AAKf/AACV/wAAo/8AAKX/AACH/wAAiP8AAJv/AACi/wAApf8AAKj/AACq/wAAr/8AALj/AAC9/wAA + wf8AAMP/AADE/wAAwf8AAJX/AABS/wAARfAAAB2eAAAAgAAAAHAAAAAaAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0 + AABKNAAMSjQAoUo0AP95VQD/voUA/8iMAP/HiwD/xYkA/8KIAP+/hQD/uYEA/7B7AP+ueQD/q3cA/6h2 + AP+mdAD/nG0A/4hfAP+VaAD/vYQA/7iBAP+odgD/oHEA/7V+AP+6ggD/vYQA/8CGAP/DiAD/u4MA/6Rz + AP95VQD/c1EA/72GAv+UaQL/e1cB/6BxAP/LjwD/3ZsA/9qYAP/XlgD/15YA/9iWAP/YlgD/w4gA/6V3 + Cf9bVUD/UlZW/4mPjP+Ynpz/mJ6b/5ienP+Zn5z/mp+d/5qgnf+aoJ7/m6Ge/5uhn/+cop//nKKg/56k + oP+IjaP/Fxiv/wAAwf8AANf/AADX/wAA1v8AANb/AADZ/wAA3f8AAM3/AACi/wEBfP8CApH/AgK+/wEB + d/8AAHf/AACi/wAAuv8AAML/AAC//wAAvP8AALn/AAC1/wAAof8AAKf/AAC3/wAAvP8AAJf/AACH/wAA + mv8AAKX/AACn/wAAqv8AAK3/AACv/wAAt/8AAL7/AADB/wAAxP8AAMX/AADH/wAAvv8AAH7/AABL/wAA + O9UAAAmHAAAAgAAAAEgAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKNAAASjQAAEo0AExJMwDtXUIA/696AP/IjAD/yIwA/8eL + AP/FigD/w4gA/8CGAP+3gAD/sXwA/696AP+teQD/q3cA/6h1AP+bbAD/h18A/5RoAP+vegD/tn8A/7Z/ + AP+ldAD/sXwA/72EAP/AhgD/w4gA/8aKAP/FigD/sn0A/5VpAP91UwD/pHMA/49lAP+BWgD/r3oA/8+Q + AP/WlQD/1pUA/9eWAP/YlgD/2JYA/9iWAP/FiQD/qHkH/19XPP9NUVH/gYaE/5iem/+XnZv/mJ6b/5ie + nP+Zn5z/mZ+d/5qgnf+aoJ3/m6Ge/5uhn/+cop//nqSf/4KHo/8RErD/AADD/wAA1/8AANf/AADX/wAA + 1v8AANX/AADV/wAAz/8AALD/AACB/wAAjf8AAKX/AAB3/wAAk/8AALH/AADE/wAAxf8AAML/AAC//wAA + vP8AALH/AACl/wAAtf8AALb/AACv/wAAlf8AAIf/AACZ/wAAp/8AAKr/AACs/wAArv8AALD/AAC2/wAA + v/8AAML/AADE/wAAxv8AAMf/AADH/wAAsf8AAGH/AABH+AAAJaoAAACAAAAAbgAAABUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0 + AABKNAAMSjQAqUs1AP+MYgD/x4sA/8iMAP/IjAD/x4sA/8WKAP/EiQD/wIYA/7d/AP+zfQD/sXwA/696 + AP+teQD/p3UA/5RoAP+GXwD/iGAA8YxjAOSSZwD0m20A/p1uAP+ndQD/v4UA/8OIAP/GigD/yIsA/8qM + AP/AhgD/qHYA/4ZeAP9zUQD/l2kA/8GHAP/UkwD/1pUA/9aVAP/XlgD/2JYA/9iWAP/YlgD/2JYA/8eL + AP+sewT/Z1o2/0lNTv91eXj/l52b/5edmv+XnZr/mJ6b/5ienP+Zn5z/mZ+c/5qfnf+aoJ3/m6Ce/5uh + nv+epJ//dnqk/woLsf8AAMX/AADX/wAA1/8AANf/AADX/wAA1v8AANX/AADV/wAA0/8AAML/AACZ/wAA + dP8AAIP/AACn/wAAvv8AAMn/AADH/wAAxf8AAML/AAC//wAAqP8AAJ3/AQGc/wUFkv8GBoP/AwOD/gAA + hv8AAJL/AACm/wAArP8AAK7/AACw/wAAsv8AALX/AAC+/wAAw/8AAMT/AADG/wAAx/8AAMf/AADG/wAA + kf8AAE3/AAA92QAACYgAAAB+AAAANwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKNAAASjQAAEo0AD5JMwDpYEQA/7eAAP/JjQD/yIwA/8iM + AP/HiwD/xooA/8SJAP/AhgD/uIAA/7V/AP+zfQD/rXkA/59vAP+OZAD/h18A8YdfALSKYQBWjWMAMI5k + AVJyVhC+hGAL/59wAP+7gwD/xooA/8iLAP/KjAD/zI4A/8uNAP+6ggD/vIMA/8OIAP/SkgD/1pUA/9WU + AP/WlQD/15YA/9iWAP/YlgD/2JYA/9iWAP/ZlgD/y44A/7F9Af90YC3/SExM/2lta/+Vmpj/lpya/5ec + mv+XnZr/mJ2b/5iem/+Znpz/mZ+c/5mfnf+aoJ3/mqCe/52jnv9jZ6b/BAWy/wAAyf8AANf/AADX/wAA + 1/8AANf/AADX/wAA1v8AANX/AADU/wAA1f8AANH/AADD/wAAvP8AALn/AADJ/wAAy/8AAMn/AADH/wAA + xf8AALz/AACh/wUFf/8aGmD/MTBb/ywqRNoUFGeDAACIrQAAhu8AAI3/AACd/wAArP8AALL/AAC0/wAA + tv8AAL7/AADD/wAAxf8AAMb/AADH/wAAx/8AAMj/AAC5/wAAZP8AAEb2AAAgowAAAIAAAABaAAAABwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEo0 + AABKNAACSjQAh0o0AP+IXwD/yIwA/8iMAP/IjAD/yIwA/8iMAP/GigD/w4gA/76FAP+6gQD/snwA/6Bw + AP+NYwD/g10A74NdALCGXwBTiWEAEZpwAAA7NysAHSEtAjU0MI9mWTb/nXIL/7B7AP/HiwD/yowA/8yO + AP/OjwD/0JEA/9CRAP/TkwD/1ZQA/9WUAP/VlAD/1pUA/9eWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9mW + AP/QkQD/tYAA/4RoIf9KTEr/X2Jh/5GXlP+Wm5n/lpyZ/5ecmv+XnZr/l52b/5iem/+Ynpz/mZ+c/5mf + nf+aoJ3/mqCe/0pNqP8AALX/AADO/wAA2P8AANf/AADX/wAA1/8AANf/AADX/wAA1v8AANX/AADU/wAA + 1P8AANT/AADS/wAAz/8AAM//AADN/wAAy/8AAMn/AADG/wAAsv8AAJr6CwtLzCopIZo5Ny2LOTcqPlhU + FwIAAIsPAACGTgAAg6sAAIPtAACM/wAAnv8AALD/AAC4/wAAvf8AAML/AADF/wAAx/8AAMf/AADH/wAA + x/8AAMf/AACN/wAAS/8AADbIAAACgwAAAHEAAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASjQAAEo0ABdJMwDGVjwA/615AP/KjQD/yIwA/8iM + AP/IjAD/x4wA/8SJAP/AhgD/tn8A/6FxAP+KYQD/gFoA7YBaAKuDXABOhl8AEP/NAACIYQAAAAAAADY0 + LgAkIhwANDItelJQRv2TdSn/p3UA/8KHAP/MjgD/zo8A/9CRAP/SkgD/05MA/9SUAP/VlAD/1ZQA/9aV + AP/XlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9SUAP+6gwD/k28W/05ORv9YXFr/jpOR/5Wb + mf+Vm5n/lpuZ/5acmv+XnZr/l52b/5iem/+Ynpv/mZ6c/5qfnP+Ump7/MjSr/wAAuP8AANL/AADX/wAA + 1/8AANf/AADX/wAA1/8AANf/AADX/wAA1v8AANX/AADV/wAA1P8AANP/AADS/wAA0f8AAM//AADN/wAA + y/8AAML/AACp/wAAhdsBAR5gEhEACT06MQIuLSkALy0oAAAAigAAAGIAAACGDgAAg0oAAICnAACA6wAA + if8AAJ//AAC0/wAAvv8AAMP/AADG/wAAx/8AAMf/AADH/wAAyP8AALH/AABZ/wAAQecAAA+PAAAAfAAA + AC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE44 + AABKNAAASjQAQUgzAO1vTgD/w4gA/8mMAP/IjAD/yIwA/8iMAP/GigD/u4MA/6NyAP+IYAD/fFgA63xY + AKd/WgBLg1wADmJDAACFXgAAAAAAAAAAAAAAAAAANjQuADY0LgA0MiwiOTg0v2pcNv+idAj/t4AA/82P + AP/QkQD/0pIA/9OTAP/UlAD/1ZQA/9aVAP/WlQD/15YA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/YlgD/15UA/76FAP+edA7/U1BC/1RXV/+KkI3/lZuY/5WamP+Vm5j/lpuZ/5acmf+XnJr/l52a/5id + m/+Ynpv/mZ+c/4yRnv8hIq3/AAC8/wAA1f8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA + 1v8AANX/AADV/wAA1P8AANP/AADS/wAA0f8AAM//AADN/wAAuf8AAKL5AABYowAAACYAAA4AAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAIYAAAB0AAAAgwwAAH9GAAB8ogAAfOkAAIf/AACh/wAAuf8AAMX/AADH/wAA + x/8AAMf/AADH/wAAw/8AAHT/AABH+AAAIaQAAAB/AAAARAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASjQAAEw1AABKNABwTDYA/I5jAP/KjQD/yIwA/8mM + AP/JjAD/voUA/6NyAP+GXwD/eVUA6nhUAKN7VwBGf1oADHFPAACCXQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAANjQuADQyLAAzMi1BQTww3oZkE/+uewD/yIwA/9KSAP/TkwD/1JQA/9WUAP/WlQD/1pUA/9eW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9qYAP/dmgD/wogA/6V3Cf9aUz3/UVZV/4mO + jP+Umpj/lJqX/5WamP+Vm5j/lZuZ/5acmf+WnJr/l52a/5edm/+Zn5v/g4if/xYXrv8AAMD/AADc/wAA + 2f8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1v8AANX/AADV/wAA1P8AANP/AADS/wAA + 0f8AAMn/AACw/wAAjNwAAB5rAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAAAA + dgAAAH8LAAB7QgAAeJ4AAHjnAACF/wAAof8AALz/AADH/wAAyP8AAMf/AADJ/wAAk/8AAE3/AAAwvQAA + AIEAAABXAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABNNwAATDUABk03AJ1WPQD/qXYA/8yOAP/JjAD/wIYA/6RyAP+EXQD/dVMA6HRSAKB3VABDe1cAC3NQ + AACAWwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjQuADQzLwIzMi9nXEof8aR0 + A/+9hQD/0pMA/9SUAP/VlAD/1pUA/9aVAP/XlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/YlgD/4Z0A/+WgAP/FigD/qHkG/15VOv9SVlb/iY6M/5SZl/+TmZf/lJqX/5SamP+Vmpj/lZuZ/5ac + mf+WnJr/l5ya/5mfmv99gp//EBGv/wAAw/8AAOT/AADi/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA + 1/8AANf/AADX/wAA1v8AANb/AADV/wAA1P8AANP/AADS/wAAv/8AAKj5AABZrQAAAGcAAAAOAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAHcAAAB7CQAAeD8AAHSbAAB15gAA + gv8AAKH/AAC+/wAAx/8AAMr/AACt/wAAWf8AAD3TAAAFhgAAAFwAAAAGAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFI6AABROgAQUjoAvmVHAP+9hAD/yYwA/6d1 + AP+CXAD/clAA6HBPAJ50UgBBeFUACnBPAAB+WgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAANDMvACQqNQxKQCaSl20J/LWAAP/QkQD/1ZQA/9aVAP/WlQD/15YA/9iW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9qYAP/qpQD/5qEA/8aLAP+qeQX/X1U4/1RY + WP+Kj43/k5iW/5OYlv+UmZf/lZuY/5abmf+WnJn/lpya/5ecmv+XnZr/mZ6a/3p/n/8OD7D/AADE/wAA + 5f8AAOv/AADa/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1v8AANb/AADV/wAA + 1P8AAND/AAC3/wAAnuoAACeQAAAAdgAAAB8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAIYAAAByAAAAeAkAAHQ9AABxmQAAceUAAID/AACk/wAAx/8AAMD/AABp/wAA + SOMAAA2CAAAANwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAVz4AAFY9ABJYPgDBbUwA/6p3AP+SZwD/cVAA821NAKRwTwBBdFIACW5NAAB8WQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAl20JAI5o + DDuodwLqt4EA/9KSAP/WlQD/15YA/9eWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/YlgD/4JwA/++oAP/loQD/xosA/6l5Bv9dVDn/WF1d/4ySj/+SmJX/k5iW/4uQjf91eHX/cnVx/3J1 + cf9vcW7/a21p/3t/fP+Vm5b/fYGf/xAQr/8AAMT/AADk/wAA7/8AAOD/AADX/wAA1/8AANf/AADX/wAA + 1/8AANf/AADX/wAA1/8AANf/AADX/wAA1v8AANb/AADV/wAA0v8AALn/AACl8gAAO5oAAAB7AAAALAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKAAAA + cAAAAHUIAABwPAAAbZ4AAHDxAACP/wAAqv8AAHD/AABU0gAAJjUAAAAEAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbQAAAVDwAAl5CAGplRwDkbU0A8WxM + AMttTQBlcVAADm1MAAB3VQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvfAAAr3wATq57APO+hQD/1ZQA/9eWAP/XlgD/2JYA/9iW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9mXAP/oowD/8KkA/+OfAP/EiQD/pXcI/1lS + PP9hZWX/j5SS/5KXlf+Ok5D/XF5Z/jQyLeU1My6/OTcxrjg2MKc2NC6kPz452WJjXf5zd43/FRau/wAA + wv8AAOH/AADw/wAA6f8AANn/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA + 1v8AANb/AADU/wAAwP8AAK37AABarAAAAH0AAAA3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhQAAAG0AAABxDAAAbV8AAGzHAABt8AAA + ZecAAF5zAABYBAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABlRwAAZEYACGZIADZpSgBFbU0AHnNRAAJwTwAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc1EAANub + AACreQBrr3wA+8SJAP/XlgD/15YA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/YlgD/3psA/+6nAP/wqQD/4JwA/8GHAP+edA3/U09B/2xxcP+QlpT/kpeV/3d6d/83NjDoEA8NlAgI + BzY6NzAJMC4nCDEvKQczMCozODYuoUA/S/EREZz/AADA/wAA3v8AAO//AADu/wAA3v8AANf/AADX/wAA + 1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1v8AANb/AADG/wAAsf4AAG66AAAAfwAA + AGEAAAAnAAAABwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAHAAAAB1AQAAbRsAAGlEAABmOAAAZAkAAGUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAwIAMYhgAKmxfQD/yY0A/9iWAP/YlgD/2JYA/9iW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/moQD/8KkA/+6nAP/bmQD/vYUA/5Nu + FP9QUEj/en99/5CWlP+QlZP/YWNf/yYkIMYBAQGBAAAATgAAAAUAAAAANjQuADMxKgA3NSINLiw5XQsK + l9oAALz/AADZ/wAA7f8AAPD/AADm/wAA2P8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA + 1/8AANf/AADX/wAA1/8AAMr/AACz/wAAfsYAAASAAAAAgAAAAHgAAABYAAAAKAAAAAgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBQMAMjAi + AHBsTACzoXEA7LJ+AP/MjgD/2ZYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/YlgD/3JkA/+2nAP/wqQD/66UA/9WUAP+4gQD/gWUf/1VXVf+GjIn/j5WT/46Tkf9ZWlb+ISAbvAAA + AIAAAAB4AAAAKwAAAAAAAAAAAAAAAAYGowAXFXwCAQGvhwAAtv8AANL/AADq/wAA8P8AAO3/AADc/wAA + 1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADY/wAAzf8AALT/AACk7QAA + brkAACmQAAADgQAAAIAAAAB5AAAAWAAAACkAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAMBgQAMzEjAHFtTQC0m20A5q57APyzfgD/u4MA/9KSAP/YlgD/2JYA/9iW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/loAD/8KkA//CpAP/moQD/zY8A/7B9 + Av9sWy7/ZGlp/42SkP+OlJH/j5SS/2xua/8yMCvgCgoJjgAAAIEAAABXAAAABQAAAAAAAAAAAADIAAAA + sAAAALJSAACz9AAAyv8AAOT/AADw/wAA8P8AAOb/AADY/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA + 1/8AANf/AADX/wAA1/8AANf/AADS/wAAvf8AALT/AACw/AAAnucAAG+6AAArkQAAA4EAAACAAAAAeQAA + AFkAAAApAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBgQAMzIjAHJuTgC1m24A5657 + APyzfgD/u4MA/8iMAP/UkwD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/YlgD/3ZoA/+2nAP/wqQD/7qgA/96bAP/DiQD/oXUJ/1xWQv97gID/jpSR/46Tkf+OlJL/iI2L/1JS + Tf0jIR29AQEBgwAAAGUAAAALAAAAAAAAAAAAAAAAAACyAAAAsiIAALLTAADB/wAA3P8AAO7/AADw/wAA + 7v8AAN7/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADU/wAA + yf8AALz/AAC0/wAAr/0AAJ7nAABwuwAAK5EAAAOBAAAAgAAAAHkAAABZAAAAKQAAAAgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAALBgQAMzIjAHJuTgC1mm0A5617AP2yfgD/uoMA/8mMAP/UlAD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9qXAP/oowD/8KkA//CpAP/ppAD/1ZQA/7qC + AP97Wgv8QEA6/nN3dP+Ijov/jpOR/46Tkf+PlJL/dHd0/zU0L+QICAeNAAAAbQAAABIAAAAAAAAAAAAA + AAAAALIAAACyBQAAsZQAALf/AADT/wAA6P8AAPD/AADw/wAA6f8AANn/AADX/wAA1/8AANf/AADX/wAA + 1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1P8AAMn/AAC7/wAAs/8AAK/9AACe6AAA + cLsAACuRAAADgQAAAIAAAAB5AAAAWQAAACkAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALBgQAMjIjAHJuTQC1mm0A5616AP2xfQD/uoIA/8iM + AP/TlAD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/ZlgD/5J8A/++pAP/wqQD/76gA/+CdAP/IjAD/rXoA+FU9BrAoJyWXPz041lJTTvpucW3/hImG/46U + kf+BhYL/Pj047g4NC5IAAAB1AAAAGwAAAAAAAAAAAAAAAAAAsgAAALIAAACyRAAAs+sAAMb/AADf/wAA + 7v8AAPD/AADw/wAA5P8AANj/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA + 1/8AANf/AADX/wAA1/8AANP/AADI/wAAu/8AALL/AACu/QAAnegAAHC7AAArkQAAA4EAAACAAAAAeQAA + AFkAAAApAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALBgQAMjEj + AHFtTQC1mWwA56x5AP2xfQD/uYIA/8eLAP/TkwD/15YA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2ZYA/+OeAP/uqAD/8KkA//CpAP/oowD/1ZQA/7qD + AP+RZgDXJhsATAgPHgczMSonNDIscDo5M8BKSkXyZWdj/3Z5df9FRD/vHhwZZAAAAEsAAAAZAAAAAAAA + AAAAAAAAAAAAAAAAsgAAALIMAACxpgAAuf8AANP/AADn/wAA8P8AAPD/AADv/wAA4/8AANj/AADX/wAA + 1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANb/AADS/wAA + yP8AALr/AACy/wAArf0AAJ3oAABvuwAAKpEAAAOBAAAAgAAAAHkAAABYAAAAKAAAAAgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAALBQQAMjEiAHBsTAC0mGsA56t5AP2wfAD/uIIA/8eLAP/SkgD/1pUA/9eW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9qY + AP/koAD/7qgA//CpAP/wqQD/7aYA/92aAP/GigD/qngA9mNGAIUAAAAPDwsAADIwKgAxLykBMzAqFjMx + KlQ4NTCmQUA75zs5M/M1My1QAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAACyAAAAsgAAALJCAACy5QAA + xP8AANv/AADs/wAA8P8AAPD/AADv/wAA5P8AANn/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA + 1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANb/AADW/wAA0v8AAMf/AAC5/wAAsf8AAK39AACc5wAA + brsAACqRAAADgAAAAIAAAAB5AAAAWAAAACgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVDwAACwgAFTEjAGxrSwC0mGsA56p4 + APyvfAD/t4EA/8aKAP/RkgD/1pQA/9aVAP/XlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9mXAP/fmwD/6aMA/++pAP/wqQD/8KkA/+6oAP/inQD/zpAA/7R/ + AP+OZAC1Kh4AI4VeAAAAAAAAAAAAAAAAAAAyMSoAOS0qADIwKgszMSs7NjQufzY0Ljo2NC4AODYvAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACyAAAAsgYAALKIAAC2/AAAzP8AAOD/AADu/wAA8P8AAPD/AADw/wAA + 6f8AAN7/AADY/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA + 1/8AANb/AADV/wAA1f8AANH/AADG/wAAuP8AALD/AACs/QAAm+cAAG26AAApkQAAA4AAAACAAAAAeQAA + AE8AAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACmdwAApHUAAat5AB6XagB9mGsA5Kl3AP2uewD/toAA/8WKAP/QkgD/1ZQA/9aUAP/WlQD/15YA/9iW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9qYAP/gnAD/6KMA/+6n + AP/wqQD/8KkA//CpAP/upwD/458A/9OTAP+7gwD/qXgAzHJRADf//wAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAADY0LgA2NC4CNjQuAjY0LwA2NC0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyAAAA + sh4AALK7AAC6/wAA0f8AAOL/AADu/wAA8P8AAPD/AADw/wAA7v8AAOj/AADf/wAA2v8AANf/AADX/wAA + 1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANb/AADV/wAA1f8AANT/AADQ/wAA + xf8AALj/AACw/wAAq/0AAJrnAABrugAAJ5AAAAKCAAAAcgAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKh3AACodwAfqHcAu6p4APquegD/tn8A/8SJ + AP/PkQD/1JQA/9WUAP/VlAD/1pUA/9eWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iW + AP/YlgD/2pgA/96bAP/koAD/66UA/++oAP/wqQD/8KkA//CpAP/wqQD/7KYA/+CcAP/SkgD/vYQA/7F9 + ANmuewBD//8AAJZqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIAAACyAAAAsjoAALLTAAC8/wAA0P8AAN//AADr/wAA + 8P8AAPD/AADw/wAA8P8AAO//AADr/wAA5P8AAN7/AADZ/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA + 1/8AANf/AADX/wAA1/8AANb/AADV/wAA1P8AANT/AADT/wAAz/8AAMX/AAC3/wAAr/8AAKr9AACT4QAA + K5QAAABnAAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAqngAAKp4ADaqeADqsXwA/8KIAP/PkAD/05MA/9SUAP/VlAD/1ZQA/9aVAP/XlgD/2JYA/9iW + AP/YlgD/2JYA/9iWAP/YlgD/2JYA/9iWAP/bmAD/35wA/+WgAP/qpQD/7qgA//CpAP/wqQD/8KkA//Cp + AP/wqQD/7qcA/+eiAP/bmQD/zI4A/7iCAP6xfQDNsX0ASbF9AAGxfQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAALIAAACzAQAAskIAALLHAAC4/gAAyv8AANr/AADm/wAA7v8AAPD/AADw/wAA8P8AAPD/AADw/wAA + 7v8AAOv/AADl/wAA3/8AANr/AADX/wAA1/8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANb/AADV/wAA + 1P8AANT/AADT/wAA0v8AAM7/AADD/wAAs/8AAKb3AABFnQAAADwAAAACAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACseQAArHkAIax5ANO1fwD/z5AA/9SU + AP/UlAD/1ZQA/9WUAP/WlQD/15YA/9iWAP/YlgD/2JYA/9iWAP/YlgD/2JYA/9qYAP/fnAD/5qEA/+um + AP/vqAD/8KkA//CpAP/wqQD/8KkA//CpAP/vqAD/7KYA/+eiAP/emwD/0pIA/8KIAP+0fwD3sH0AqbF9 + AC2zfgAAsX0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIAAACHAAAAsigAALKiAAC19QAA + wf8AAND/AADc/wAA5v8AAOz/AADv/wAA8P8AAPD/AADw/wAA8P8AAPD/AADv/wAA6/8AAOb/AADf/wAA + 2v8AANf/AADX/wAA1/8AANf/AADX/wAA1/8AANb/AADV/wAA1P8AANT/AADT/wAA0/8AAM//AAC4/wAA + pOYAAExbAAAACQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAK16AACseQAErXoAeq97APe+hQD/zpAA/9STAP/VlAD/1pUA/9iWAP/ZlgD/2ZYA/9mW + AP/YlgD/2JYA/9uZAP/jnwD/66UA/++oAP/wqQD/8KkA//CpAP/vqAD/7qcA/+ymAP/ppAD/5aAA/9+c + AP/XlgD/zY8A/8GHAP+2gAD7sX0A0rB9AG6xfQATsX0AALF9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAALIAAACyAAAAshEAALJoAACyzgAAtvoAAMD/AADM/wAA1v8AAN7/AADk/wAA + 6f8AAOz/AADu/wAA7/8AAPD/AADw/wAA8P8AAO//AADr/wAA4/8AANv/AADX/wAA1/8AANf/AADY/wAA + 1/8AANf/AADW/wAA1f8AANP/AADO/wAAv/8AALD5AACrhgAAbwgAAJIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK57AACuewARr3sAgbB8 + AOS2gAD9vYUA/8KIAP/FigD/x4wA/8qNAP/NjwD/0JEA/9KSAP/VlAD/3JkA/+KeAP/jnwD/458A/+Of + AP/hnQD/35wA/9yaAP/YlwD/05MA/82PAP/GigD/v4YA/7iCAP2zfgDvsX0Aw7B9AHaxfQAmsX0AArF9 + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyAAAA + sgIAALIjAACxcQAAssAAALTtAAC5/QAAv/8AAMb/AADM/wAA0v8AANf/AADb/wAA3v8AAOH/AADi/wAA + 4/8AAOP/AADi/wAA2/8AANT/AADS/wAA0P8AAM3/AADK/wAAx/8AAMX/AADC/wAAvv8AALf+AACx5gAA + r4gAAK8VAACvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAALB8AACwfAAHsHwAOLB9AHywfQCrsX0Aw7F9AM+xfQDZsn4A5bN+ + AO+1fwD2t4EA+7iCAP67gwD/vIUA/76FAP++hgD/voUA/72FAP+8hAD/uYMA/7eBAPy1fwD1sn4A6bF9 + ANGwfQCtsHwAfbB9AEaxfQAXsn0AArF9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsgAAALIBAACyFAAAsUIAALF6AACxqwAA + ss8AALPoAAC19QAAt/wAALr/AAC8/wAAvv8AAL7/AAC//wAAvv8AAL3/AAC7/wAAuf8AALj7AAC29gAA + tO8AALPmAACy2gAAstAAALLEAACxrQAAsX8AALE8AACxCAAAsQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACxfQAAsX0AAbF9AAqxfQATsX0AGrF9ACOwfQAwsH0AQrB9AFSwfQBpsHwAfLB8AI6wfACbsHwApLB8 + AKiwfACnsHwAobB8AJWwfACDsHwAbbB9AFOwfQA3sX0AHLF9AAqyfQABsX0AAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACyAAAAswEAALIKAACyGwAAsTUAALFRAACxawAAsYIAALGUAACxoAAA + sacAALGoAACxpAAAsZwAALGPAACxfQAAsWoAALFVAACxQwAAsTEAALIjAACyGwAAshMAALIKAACyAgAA + sgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAALJ9AACzfQAAsn0AArF9AAWxfQAHsX0ACLF9AAixfQAGsX0AA7J9AAGyfQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAALMAAAC0AQAAswMAALIGAACyCAAAsggAALIHAACyBQAAswIAALQAAACzAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAD///////////////////////////////////////////////////////////////////////////// + ///////////5//////////////n/////gB////////////+AP////wAP///////////+AA////4AA/// + /////////AAH///4AAH///////////gAA///8AAA///////////wAAH//+AAAH//////////4AAA///g + AAA//////////8AAAH//wAAAP/////////+AAAB//4AAAB////8H////AAAAf/+AAAAP///+Af///gAA + AD//AAAAB////gA///wAAAA//wAAAAP///4AD//4AAAAP/8AAAAB/+P+AAP/8AAAAD//AB4AAPAA/gAD + //AADAB//wACAAAAAD4AAf+AAAIAf/8AAAAAAAAeAAD/AAAAAH//gAAAAAAABwAA/gAAAAD//4AAAAAA + AAEAAH4AAAAB///AAAAAAAAAAAB8AAAAAf//wAAAAAAAAAAAPAAAAAP//+AAAAAAAAAAADgAAAAH///w + AAAAAAAAAAAQAAAAD///+AAAAAAAAAAAAAAAAB////wAAAAAAAAAAAAAAAA////+AAAAAAAAAAAAAAAA + f////wAAAAAAAAAAAAAAAP////+AAAAAAAAAAAAAAAH/////wAAAAAAAAAAAAAAD/////+AAAAAAAAAA + AAAAB//////wAAAAAAAAAAAAAA//////+AAAAAAAAAAAAAAf//////wAAAAAAAAAAAAAJ//////+AAAA + AAAAAAAAAEf//////AAAAAAAAAAAAACH//////gAAAAAAAAAAAAAB//////wAAAAAAAAAAAAAgf///// + /AAAAAAAAAAAAAgH//////+AAAAAAAAAAAAIA///////+AAAAAAAAAAAAAP///////gAAAAAAAAAAAAD + ///////4AAAAAAAAAAAAA///////4AAAAAAAAAAAAAP//////8AAAAAAAAAAAAAD//////8AAAAAAAAA + AAAAA//////8AAAAAAAAAAAAAAP/////+AAAAAAAAAAAAAAD//////AAAAAAAAAAAAAAA//////gAAAA + AAAAAAAAAAf/////wAAAAAAAAAAAAAAH/////8AAAAAAAAAAAAAAD//////AAAAAAAAAAAAAAB////// + gAAAAAAAAAAAAAAf/////4AAAAAAAAAAAAAAP/////8AAAAAAAAAAAAAAD//////AAAAAAAAAAAAAAB/ + /////wAAAAAAAAAAAAAAf5////4AAAAAAAAAAAAAAHgf///+AAAAAAAAAAAAAAAwH////gIAAAAAAAAA + AAAAAB////wfAAAAAAAAAAAAAAA////+/4AAAAAAAAAAAAAAP/////8AAAAAAAAAAAAAAD//////AAAA + AAAAAAAAAAB//////gAAAAAAAAAAAAAAf/////4AAAAAAAAAAAAAAP/////8AAAAAAAAAAAAAAD///// + /AAAAAAAAAAAAAAA//////gAAAAAAAAAAAAAAf/////4AAAAAAAAAAAAAAH/////8AAAAAAAAAAAAAAD + /////+AAAAAAAAAAAAAAB//////gAAAAAAAAAAAAAA//////4AAAAAAAAAAAAAA///////AAAAAAAAAA + AAAAD//////wAAAAAAAAAAAAAAf/////8AAAAAAAAAAAAAAB//////AAAAAAAAAAAAAAAP/////gAAAA + AAAAAAAAAAB/////wAAAAAAAAAAAAAAAP////4AAAAAAAAAAAAAAAB////8AAAAAAAAAAAAAAAAP///+ + AAAAAAAAAAAAAAAAB////AAAAAAAAAAAAAAAAAf///gAAAAAAAAAAAAAAAAD///wAAAAAAAAAAAAAAAA + Af//8AAAAAAAAAAAAAAAAAH//+AAAAAAAAAAAAAAAAAA///gAAAAAAAAAAAAAAAAAP//wAAAAAAAAAAA + AAAAAAD//8AAAAAAAAAAAAAAAAAAf/+AAAYAAAAAAAAAAAAAAH//gAAfAAAAAAAAAAB4AAB//4AAfwAA + AAAAAAAB/gAAP/+AAf+AAAAAAAAAAf+AAD//AAf/gAAAAAAAAAH/4AA//wAf/8AAAAAAAAAB//gAP/8A + f//gAAAAAAAAAf/+AH//Af//4AAAAAAAAAH//4D//4P//+AAAAAAAAAAf//B//////+AAAAAOAAAAB// + ///////+AAAAADwAAAAH////////+AAAAAAeAAAAAf///////+AAAAAAHgAAAAB///////+AAAAAAB4A + AAAAH//////+AAAAAAAfAAAAAAf/////+AAAAAAAHwAAAAAB/////+AAAAAAwF+AAAAAAH/////AAAAA + Afh/gAAAAAA/////AAAAAAP+f8AAAAAAP////wAAAAAH///gAAAAAD////8AAAAAB///4AAAAAA///// + AAAAAB////gAAAAAf////wAAAAA////8AAAAAP////+AAAAAf////gAAAAH/////wAAAAf////+AAAAD + //////AAAA//////8AAAD////////AP////////AP/////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /////////////4lQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAgABJREFUeNrs/XecJOtd + 34u/n6rq3JPzzOac09kTJSyQECAwOV0wxgZjkF7X12CuwzXpYpLDvT/Ha2OwJAQiS6CAcjhIOkFHJ4c9 + m3OYnLqnc1fV8/vjW9VV3dM9YWd2d1ba7756u6umq7rS5/N88wMP5IE8kAfyQB7IA3kgD+SBPJAH8kAe + yAN5IA/kgTyQB/JAHsgDeSAP5IE8kAfyQB7IA3kgD+SBPJAH8kAeyAN5IA/kgTyQB/JAHsgDeSAP5IE8 + kAfyQB7IA9nYou71Adwx+eWPgFIKpSwgDiSAFNAOpL1XylsfAyzAADRgA2WgCOSABSDrvRaAAlABNL/5 + vff6TL+h5ePypoAIkATavFeH955m8T12kXtcQe5xgeA+L3ifC0DZhSqgv+9en+gdkvuHAH7pw2BFQWsD + uZER7xUjAHY30Af0AwPAoPe5B+hEHoikt02E4IFodh00wYNSRR6UPDAHTAI3gSvAZe91C5gGSgAPiGF9 + 5ePBxxhyn0eA7cBOYBuwGbnX3QSgj7Kye+wg97iMAH8ByAAzyL2eAMa9z1Pe+izyPJS9batA1QS3DPzA + vb5gK5SNSwC/9Tlo64GZW+1ovQs4BOwFtiCA9sGcRAggPJobi3eob/P09XLbOMiDMIkQwpvAq8DrwGWU + yqL1A01hlfJx5MorAfN24DBwDHkOdiAE3waY4e2WvVtNZBXbuCzWGgqhzzPIwHAeOKXgfBLmq6C/415f + 0Bay8QjgVz4KKAV6J0r9IPB3gQPICL4CYKvgXSlQBhiG927KK7xOGfK9ukuhQfsvV16uU//SDrja+33d + 8Nu4wDxwAXgG+CLwIjJ6PCCDFhICfTdwHHgH8FZgH7LOhMVX2/BeZsPLXx++uyq0vT/8a4TFXQJ1wA29 + dMM2YWkBII1oCOeAT2v4EHAGcDfand9YBPArHwFh9Z8G9U+AnShVf4x14FUBiH1wGyYYFpgmKH/Z+w7K + ++w9EqrZJdDeXQ6/e7e9kRAcG5wK2BWwq+BUwbW97+vwvkt4DwPwEeA1oIxlwf/9Xff6qt9z8dR7CyH6 + 7wO+CziIaHW1K6kQYPu2X5TAjgsDntD3w8APv/sSBnaYEMK2Qfhl05wgmpFFaP83NPw+8LvAjIWMahtB + NgYB/ManoVwE6AX+PUr9feTeCnAjcYgmIBIDMxKM4j4B+KN901Nq4OxYHGJJbx8tjscf/dEyymsX3LAW + 4C2Hv+eTgl0FuwzVIlTLsowbPq4Z4AvA+0F9BUUJrb/hfAYfD65IRMOjwE8D70L8NjXQ+06eOIHjxgc7 + 3ncMFmsB4XWNZNBMHESvL7L0KN9IGI1kEfYel711nrgaPgb8PHAjirDcvZaNQQC/9FcACVD/CcXPAgql + IJqEVKeAX5kEo7Z/9K1Av8wpRyIQS0A05hHIKkW7cjtrWoD/cjwNwXssHFtIoJyDckE0hEAzWAA+BfwX + UM+Ddr5RSMADv9JwBPg/gO9HVHxARnTfuRP3ln0A+yC3Qi8f8MuBvFEUAlzf8ydhnZWLXuKzi6h9GcRB + FPr7hzX8Y2B+IzgK7z0B/Ms/BSsO6B8D3gckUAqSHZDuAdNqfrg++G+LBDyxIhCNCxHU/c5tiNaiFThV + GfWrFSEA33xwqlDOQzELlRKhR2IS+D3g/wMm0Rp+6/vu3vW/ixLy5HcCPwP8U8R7D8gI34bo/RECQFuI + uu+79L2hYE3iEIzUPi2vRpr5BJqtc5Cw0Xyw3qnAv/zf4D+dBP3iHbjOqxFz7btYo/ydHwN0Gvi3KLUP + EFC299eDshnQ10oCritArZS80ZmQWbFKUZ5/wbTEVInF5d0wPBJQYsrE07LescVfIM/7NyFq8HngJm/7 + MfjKn9+rO3JH5GPU1PajCNm9G+gCAX4PYv8lCUb4BEEg39cEWsXzViL+aJ9H1K8idSr6ikW3eG+2Tnnn + V0GIBjBysPcyXH8Vrger743cewL4ph8G2AfqX+E5fUh1iZ0OIXBzZ0gABKCOLURQLYNtB/u8HTLwtzVN + AbuvYfjmQSQG8TbxQzgV0K5CYtnfhlJzwGne9mPO1wsJeCq/iTj4fg94HDl7upDEjSQCbgt5CPwYr6/+ + 3644CPjySJzudkd8X1YDfv+zH3nwTQETUueheln+dAPhpXsia9R710FERR5B0VG71bbnWTfFD1gDt9be + 55CH3V/X7G+3I44DTlGckqYpZkIkJu/mbSqfhgnxpGg2lRKU8rI+3S1EtzAlPgJRh/8bMkr+O371YxPA + fesg/Ci1Ub8T+AVE5e8CGdF7EJCDsEMSGfXXMir5IT0/q6fqLd8u4Bv33ex9qXXhtFL/byZEBiVxbR/C + T5/gHmkCtzm8raOIJ91FuxrtBVIKGZgbhfyc2NNa139fPixeV/e3dbjljgPlEuQykJ2FhXkBb+MxrVQM + Q4igrUuckMozCzqHxdkpRJdGPMXvRbQC+NWP3aWbsX4SUvn7EVL7FTzwtwFDBOCPe39Ic3vg90FWQGzt + We+96K2/V+C3ESfgOIEPIBwy9BYPAnvW4RBvS+69BiCXbQZNETGXZJC1K7AwLU6zZDvE22UUhhVqArBm + bSAsrguVsryUAZZn60eiot6rVfyOaUG6HcpRKORkXVu/OENzM+BUFRIqVojHeOwe3ZzbFs+B16Xh/wf8 + Pbw4Tjcy9PkhujRCBKu9Sz7AKgQjvXuHzmW14LcRcyNLoNuHhyQXnDmxCEB8m4eBs9yeS2JNcu99AG/5 + QYACihSS4tkGBEk6rgOVIlQKYkOblmc9hkOCS/kEGv6+LuKFAKsVIQS7IsfmJymtSJRnXkS8aIEr2kAk + JuerXZCRoYdy4Um++e9VeOov7tZdWZN43v4o8OvAz+LdsX4E/L5nvwNR+Vdzd2wkvJZDEFRi/VT8RlnJ + KB8WB3EuznjvdpPvlaBwDk59Fk5lhb/8y3Gae+ALuPcE8MxfwVt+qITWT6LUF4AqWm9DGek6EPtEUC4A + 2ht1zXtIAr6EyaAkYEZ5iUYr+E3DFN8AWkwLMyJFT+W8b2YcIjsV43/9s6+x40SZ6Rt3467ctvwNAgQD + /iHwa0DUQMDf5n0ngTgFIiu/wosceXcK9OHfbPzcCvw2AvhpZNS3m+yvBIXzcOpD8Pm/gJfnhLv8SKcG + ThFoBXdN7j0BgJDAs3+leesPjfOuH/0sf/w7o1RLm0m1d2BFo3Xf1a6QwCKNAO4dCfjHFkr+sb20kpUQ + gVJiSmiPBKyoaBKVAoCBGTmGYdo8//FXMa2ypx1sOPkK8lQbcBIJ9fWBqP2d3nfiyMi/kgfPT6ZZQJCx + Fu/9amSl4PeBHx7xG4+vCEUf+H8GL12BOU/PD4etSsAriBvjrsq9TwRqLkcxre9n54lhTnzbMUb27CeW + Stdy88PgtqKQ6IBEm5c3cI9JoFGsSBABWI4ItAs5L1FIa1iYhPy8bDc7dpO/+W+/wbVTf8IaHpRjDz9G + xLQo25V+JNqQ1fAC4L7x4vNrOlVP9e8EPoiX7t6GjP4GYhN0sjz4NUG8vrLmG7A6WQ78sNjGbxb7L0Lx + Mpz7Arz8HNwqy2bN7EMT8fH8Id+wGsBiWUC7eWZuac48O870zask0i7JJhqB68hIGTYNjNBp3WsS8J2H + jr342BpFeX4BuypkYMXF7HFsSKTbiSU7OffcKNq9zCp9XkdOPsLA8Iip0Xsc1/nHwO8AvwikDaU+glJ6 + YvTWbZ9mKMvvZ4H/HTCiCPj97L1Olvc6Vwk6ctxtj9hKnHv+iN9M1VdAWUb8Nz8Mn/9TePHS4hHfFwPh + t/OI8jR5l08X2LgEUEUSJC6g3QVmbsGZZ8eYuXmVeJtLsr0TKxIQgfKchTXTQHtFQ0bw9/C7LNzdM3Ic + MQ2UkghCq983DMk3qFS8ZCLLyxvQ0N7XS3amwsSVW8Docj/50ONP0DswyODIpiTwBPAvgd/UWn+/UmoY + eQi/qDWfMZRiLQTwY/J2APjPQK8iyOxTiPMvtsw+ikjY7G6P+rA0+MPOvVY2fhmKF+D0h+Hzf7Iy4F8A + Pg88i7gP7olsVALwpYwQwXm0u8D0TY8Ibl2raQSmrxHogAgqISKwIg3OQtaWNbgW0VqchdoV738rk8C0 + PH9ARY7fsaFaAisSpb0nydnnMlTL15DncZEceehhBgaHcbUeUEp9P/AbWvOvQL/FsqyOvr4eZShFuVxB + KfURpXgGNBOjy3JKUwmV8/4a8O0aCe/1eFc46S23vCwE/bjuhXejlXPP8Y6rmXPPDzCXoXjRA/4fwwsX + YXYFwP8CAvype3TKNdnoBOBLmAhyTN/UnH52jJnRgAjCGgFInr1vGuglTIN74Qaxq2IaRKJLk4Bdke/5 + UQHXgVRHJ+V8hhtnSsjDVHsuj5x8hIGhYROl9mOonwV+R2v9j4F9iXg8tnXzCCeOHebQgb2Mjk+ykMtp + pdQfvf7i86cnRkf3ID4BjeStrEg+Q01VfwL4LSBpIaq/X6vvx/2biSZw8t0LWc65l6H5iF+B0oUQ8C8s + D/yLbCDg+7IBEoFWJRngaeAUTvUQZ589wsUXRtn98Kuc+PbjDO/aRzSRqtvCLoszrZhpcBb6so7JQqsR + 6X8Aqbbm9QaGAYmUZCFaUUmGWpgB04pw+FtO8NqTF8nNXUap5/YeOkIsFksBj6LUjwHv0loPK6VUR0c7 + W7eMsH3rZrq7OrEsi2KpRKlcAqjOTE0OIok6mxE/XRa4utLT8NT1KGL790BQvAOS19/qIdto4PdH/Ebn + ni+eu750Fc5/Hl5+Bm6UAude4000vN1cAV5C+kbe08KfZnK/EYAv8/hEYFcPc+bZI1x4YYw9j7zK8W87 + xvDufcQSqTps22XJua9lFrYFmYX3kgSUgmRbc00g6hUSlUtCXsWsaA89w1s58vYdPPtXJwdHNi3E4/GH + tNY/rrV+AmizLIu+3m62b9vC5k1DpFMplFJo71+1UqVSqaJd18llMrsJNHSbFmbFMvIwXn8LEwnzgbBC + YomN8mwM8NvecWRYDHz/yfCB/wV4+enVAf8K98atsSK5XwnAl3ngKeAN7OphTj9zhPPPj7L7kVc5ESKC + mmiwS5AtC5gS7Z5GEOGekUCpIBpJPNnkj0qKhSplOcZ4u6QKm5GIsf+xh9PnnxqMRWO/6LruJiCSSMQZ + Hhpgx/atDA70EouK201rAb5knSjKlQrVahWtdblarRZCJ19lFZj8G9lIueID7PZt/5i3s9QSV9Tvt34v + JKzq5xHGq+vQEJIKlK6sHPgVBPAvssGB78v9TgC+zBMQwRHOPHOYC8+PsvuRV3iohWlQLYPt1RrUTIOV + 5qatsxRzXh+B6OK/RaIhLaBNCqVcB3pGdlrDO3dWZm6QTMTYs3sXW7dsorurA9M0vBor75FWAnyQqRJK + pTK27eC6bsm2q/5Dqgg63q5IvPz2XYRGfz/bL0prr78f6rsbST3NZKWq/m0A31f1NzzwfblfnIArlRJw + DbiI6+aZvgGnnx5lZvQqiTa9dB5Bvrmz8G6I9tKJI7HmpoBSogUYhpgydgkdiZFwSmxxZtm7eycnThwh + lUp6m4eToQLwA7ja5fSZ80xOzVCtlG9NT0y8obXfsYQMMnota6uG4v4/BvyYBpVEYv0KIYJmdOq3y70X + xrBv37RK2fW8+jXn3h/B8+dh1g7+HBbDO41LiHPvGWT+gLte0LMW+XojAF98IriA6+aZ8ohgevQqibbm + UQMdJgI3aD56t8R1wFDNtQDDDCICIHkBCqLJNNvL4+hKiZ7eHhLxOLXn1O+KHlo2DMWt0XFeeuUNbNup + zE5NfSWXzU4QtNubQlJSl/VQe3H/BFLmu1sh4E8gwG+jufrvz65yN2U54EMtjn/mNoD/NPch8H35eiUA + X+qJYPqG5vTTY5JZ2OaSbG9vmlB0r4jAsYUAGn/PL3OuliWnoZwD18G2YvQs3CKWnyESidDT2+t93wd+ + mAwU5VKFr37tZebnMxTy+TdGr1/7qq7ZCShkdqM3WYF27hHAIeBfASkLCQH4jT3iTbZxEADerfhXI/Ab + EerH8S/A6b+Ez38QXlgB8C8i8zzc18D35eudAHxpNA00p58eZeqGpBinOlqbBqWcp56vIJd/reJjMdoE + Pr4ZoJTXdryENiwS5QV6Fm5SrdoMDPQTiUTqVH6fDJRSnD5zgXMXLuHY9tzYzeufKRWLC9QXpVxGUlOX + lI9QM4R/EPhhjYDeL/JZNF2PJ3757p0WP5FhGvE1tAL+OXjTA/6LF1YO/PtS1W8lXy9OwJXKHJJ3LVGD + s189zIUXxtj10Cs89B3HGNm3n3iyrW4LpyqedysmUYM77bqqlKCaWGwKmJaELSuOtEsvZADFfNsgjhml + UMgzOzvLpk2bxPlXa5cg4J+bz/Dm2fO4rutm5ueez87P+6q/Ly4rzEc35SqYSmbtQRHU9futuhvFZhXe + xTWIQiqlZmh+p0pQuAjnPgevfLW+SOfryrm3UvlGIwBfAiJw7MOc+9phLr40zs4Tr3LiO46wed8B4qn2 + 4OtamnfeDdFashdbRQQqJa/bsAmuQy7eRSmaJlWYZWpymuHhYZRR8/nL/0oxn8mSzxewbXtqemL8jYY9 + G8iDfmalh6kk2e+ov7Gvs0RpbvsXuHtDZouy3PwFOPt5ePU5GC0vH8e/ytcx8H35RiUAX3wieB3HPsz5 + 549w8aUxth95hUe/5wTbj57EMEWbdf2Jn+6CVLymqFYDCVgRyRo0I/JyHSpWgny8m3Rxjvn5eYqlIulU + ijrLXoFpGJIMpF3bsf2uJbVvFBHVdjX+uR3AJgim61IIATSK38Xnboif0Rda1mfgtY/B8y/CeLXWr+T+ + TuBZL/lGJwBf5vHzCFznEJdeOUy1UmFk7wHiqTYJeId70NxpX4Arcf9GAjBNeWlXTJJqEW2YLCR7GJi/ + TKlcJjOfJZ1Ky7w7eM5ADfF4DNM0MQ0zFYlG49Vqxe9IA/AG4tVeUg6fOIlhWrwnFt38c2dO/6NjM9Nt + GgG9PyVXswfqdvvv3674VO1lNpU/Cc9/VWbtDc8q5osP/MsEwN9wKbt3Sh4QQL3MI97d10l1vBWlfgit + xSfgOuvXenwlUilJdmDd5CjexCN+1yBveM/HO9HKANdlbm6O4ZGhOhMAIJ1OkUomKJfL6VRbW38hn5sj + CP19lSUw+ujJb6YoPUgSWrvf210q/cu8ZR0zvI380b8Zuhzu7ugP9WE+G2yv91740PwQSYkA+Ff5BgK+ + Lw8IoJn88l9lgadRxk3QI0DQuFP5/u07TAKuKySQaCiktSwZr0J1DMVoG65hYTgVspksjm1j+X9X8p1k + IkF/Xy9z8xmrvbNz/8zkxEXXdX3P/0yrwzj80MPk3AVlGuYh4F9o+EHTdZPdlXJt9/6RNOtyUKZ53H09 + pVk7bn9dBcqZxap8CdF4XkaiQ99wwPdl/Qjg238GtGtgWIdQxjdhGF0o4xbK+BqGOo/G5uP/5V6f7wpF + gWiuU7VVji2g9GclBu44CZRL3kzGocHL8FqQG5Yci9ZUIklsM0rMqVAsFimVyrS1Rb38fzk+w1Ts3LmV + y1evk0im9vf0D5ydGh87T4tK3cOPPIKSgH2nqcx/APy81np7PB7j4NbNbBq7VTt7K/QeFs2d9/w3m5Qz + TDglbzZGglE/i5QxXObOc9Ntyc/LgZou7HDhERe2uZBz4VkHXlFgv3edfmt9CODtPwnlooUV/TlwfwmD + YbkzykXpcTSfAPXf+Z5/+gag+fh/vTdXdqWiFGi3iuZGbdm1JSToN+u4GyTgNxiNhWrqDG92PMPwj5Oq + GaVqxoiTp1KtUigUaG9vAx0kAqE1I0OD7Ny+lbPnL8b7Boe+LZlKbTJN60C6vf0hBDsVxGFfwGUe0ep/ + Smv9DqVUZNPIEA+dOMrWZILkF7+IJpitFxbH/kPz4d0RaVXLH0b1AiwsBIfhpztfYwOC/58C/wX4Bdjt + wrs1/KCGTVrIABemXfgvNvy/PwmlP1qH31w7AXzL3/MB8W24zm8DHbXuPNo20MYwpvmzKOPbUcZ/APUB + vvcXCnzsP9/La73MVYlJBx4/KUZ7Y4tdlqnK/XV3gwTKpfqGoj7wleH1EXBwlYVtRkGBdl3y+QK1btOh + fADLsjj50BGyuRy3bo31tHV2fRMaXNf94UW/q5Tj5R9a7ekUhw/t58D+PSSSSYzRUVSp5O01mLCzUZUo + cufiJq26+FSobxk+DTOe59+/Qf5UAhtKfkEOMPrP4Ec0/IqGvU7oQB3AhV4HflnDdQV/9OPAn67xd9dO + ALYN1YoiFv9hlO5Aa0j1wL4npMpt/KJM8aXYisF/RBmPoNR/5vv/zzfQ2uGj//FeXvfm8uvfCb/8EYA3 + QBeAJFp7NrlfYXcHZyGqu74Vcfr5eQFK1b8AVxk4ZgTlKf3FQgHdAH45Qk17W5pv+abHeeP0OSqVCoZn + XmitcV0Xx3ao2jbVatWsVKp0d3dy/Ogh+vukwZdGoyoVqNq1PfuvMAH4c/PdCVmqf1+JINXYBX1dkpvC + N+dupiQsK78IGKAc2KPhn7jwD11IO0gnpR1IW/UXkNbBLsRd+NEF+EtrHfyraycA7YJlxXGdLSgt1eFW + DAZ2iqNqeDdcex1unQPHiWHyD8B4J7h/gVJ/wA/8izdBu/z1/3tv70RIDj/0CLduvkJ8Ycqd3P64bcfT + SC+BcjAD0J2eiqx2fbU0DqklBvnAD3L9tVI4RnArS6USWmsMv9NQvSVAR0c7b338ZGh/4d8LkYHrELEi + WBHLKy0Wn4Kq2ig3yOivPxrvGLgzOf9Lgd9vJx5q4lE4K1PzhQ/tXlYi1+SfUwP+Lgd+UsNPuLDNV1X2 + AMeQORM1UqDh2yxFOPgV+ME54YVLrIHQ1k4AEh6rYhhZIQBD2m+V82B1QDwNux6Bth64+rqksCo9jGH+ + M1A/4hHBB/ihf3karR3+6v+5pzcGBF+bT31q0DUjv5zr2daeje8JSnZ9AoB6EvA3vBMkUA21Fa/9Tt0R + SxjQk0qliuu4GJaxSAuQtIDAOVj/puSpRGGaBhEV8U5TB39XSsDfMDlJ+IjuVOhvubbdLvVIWIC5K+L0 + U6GvzN+BQ1ux/AtqwN/twE9o+HsatjsydJJCKqz2IPkV2ruW8wT5DSUwCjKf4DYkgespbpME1oEAXDAM + G9e5gtJgaCjmBejJDnGeaQcGdkBHP4xfhvFLUmSj9AiG8Ytg/ChafwjUB/jhf30KrR0+/O/uyQ06cvIR + gJhW6l9rZbzdNTynHx651WZyQj6HNYA7lSfguqIF1JUphKebDIvCtm1c1w3xRKgqsGFZ3lqQAQ3LdX1U + g783HkWJ9fewLTfy+0dkhpYNsJJgzQbTcNksEfK8k/J/yQEYjjj4/r6GH9cy4isHKabajnRXafPOoYqQ + gN+8xPdtFGG+IspOFGnGeoMVJHI1k7VPD/7cR/0Q2TlcRx7WahGyXgStNnW3C/EUbDsCR78Vth6RZdcB + 1xnBdX8B9KfQ7n9CcZwf+SWTH/7Xd/UmHTn5iG8T/4TS+mdy3VtUoWNYjl0jfQRVg74cPse6z+usZZa9 + eQdr1oau+y1Du/h/dFwXV7uBqRB6a1xWDeSg6r+8CPwK6mZDbqQhh/Wf32ol4PePLU1A0Z3Q/60ymPqM + nENmD79r8kvALwvO9rvwWxo+48IvubDdBhVHJlP4VuA4AfjDMoPkaPsaTh5mdMAHccRVcFuyPmFA1wE4 + g1I5II3rwOyYZ9GExB9JE2nYdhQGtsPkFZi8Kk0utB7G5P8A44fB/SuU8X5+9FdeB23zF799R2/U4Yce + kVNx3SeAX3PMaHJ2+DCu3y8wEhdzxj+PRrv/TmsCriP9A30tQAfQU1pjunYNp1q7aFfUfB1OCYalgb3s + snzS0QjaNGtACz+wRdZ39G8G9KXWJRBEFAADjIfh+Gfg7LhoAZOID+COyy/LNTNc2OfCP9Dwoy5s8VX9 + BNKGeQdBF6VmPhONODF834YDbmZx1eZSvVeXlPUhABmJLqP1OLALFMyO+pNZLKa0GhG0wdbD0LcNpq7J + q5wHpQcxzP8d9A+B+xGUej8/9muvonWVP//Ndb1RvnjYHQH+rdLullLvVnJdW7waACXHaizj/LvTJFD2 + KgG19rQSeWQM7WC61eB3Qjqx4H85E6Duj8ssa4hGZWITguIbX2Vdz9F/teD38xLaCFz9PTDyrbDnj+E1 + pEXAHY0A/KpcKdOBAx7wf8SFzV4YjwRSQbUN6Z9g0NqYw7umt+qvcTEjSkH4obrtJkvrQwDy0E+h9Vlc + dxdKQXYacrPQNbjEhp4am0jD5gPQtwWmb8DUdZ8IBjDMdwM/iHY/jlLv48f/75fQukJnJ/zuL67L4Xt2 + fxz4Fa3130m0dTC982Fc0wJXS1POWKpe1b8XJKBdKC7IMfm1CShM1ybiVAJ/ZJ1LvgmQ61avngx0PI6O + x2pn7T/czZpv3PapNryvZJ3/SiANSb1sCONhOP5ZuDAlEbUIdyA/6dfktywNh12ZGv0HNYyEgT8CbEXC + e+GnppX4WUvjBNpBBeaysjrs2Lxts2btPgAQu1/rMvA1OSstTr6p6yz74IcBFE/ByF7JIdi0P+wj6MN1 + /xFa/w1a/z5KfRPZhRg//uvwU2sLHx45+Qj5/Z8F+GkN/zAejdCx/wQzif6gBDjeJvX3vuYStr91k8fx + TvoEbC8l2anW9h1xKkScSuD8UgaGMkTtbwbkpfwB0khwCX+AEICbDmoU/Nz79ULVWsAf1gJA0NEDm94h + /rVtCAbXTX4d+DdgKXhYw3914VMa/qnjgT8B7AYeQ2z9sI2/3JBgIBNAzoe2ycNoqT7FosIaHJvrQwAv + fdr/9By+Fug6MHZJklhWQgJ+bF27kvo6tEvChyN7hQi0C67Tg3b/AVp/DK3fj1Jvp1qM8xO/AT/5W6s+ + 7KMnHwYgdebb3wb8sgHxHXt2M9a9i5JD0BMwngpA34oEGoF+Rx2D2ruuomHE7AKW66e7g2GYGKYolyt2 + 7C1DFjVyAIhGcLs6a2dUWd8zW3SlVgN+vx4ggbjIXcAA82E43iMawAnWQfP9DeA3IaLgcQ3/Q8MnXXiP + C4MOok7uRGZM2Ys4J8MEtRJ90EFc+z6xanDnxePvKwS+Y3P+ds9jvasBX0d6px0BBTM3ZTqrjr6GkbKJ + KOV1udHgePZtNC6Ows5BmB+HuTHplqN0FwY/DsZ3gf4cSr0XzVP8xG8WiUbh/f9qRQfrRbcHgd/WWg9v + 3TxMcsdBLizEPfta1Y/+DRHA4HMLlT+cH7Cu5oCu61CUqCyIE9A7MCtiYZomjUP3epkAWBZOf19tuUoN + aGs9q7r3laxr9VIEvgAX6IXN3wI7Pyzq8lZuI2z276mBMarhUS1a43e70BN2yQ8AQwQTo/jxGb9nwkru + voGYVFdD36/CwrQoBeGA7CxrcL2sMwG4k2A8DRxBKbFXxy9J/H8l4le5aTuwc0EcX31bZD+ZSZif8Gf/ + 7cDgh8H4DuALGMZ7cZwv85O/nceyVkoEW7TmcCIRZ/+hA3y+2iGjv9JgRsXzX2f7szoSCK9bLxJwHUkR + 9kgmXZpHaS3JQEoTjUYwjcVZgKvRApb8jmHgDA3WzskvwGnWDWilshLwN/5tuVeDL8B8GI4/CRdmJcnu + Kit0Wfx774sOxBQ84cI/0vCdLnQ5od/q917+lOg+8P2CqZWC37/W1xB0+y6dItzKyGgf3s0oawi8rB8B + xKJQroBMGPvTQBztws2zsOPY4u42S4lhBoByPQtTa9lHzwi090J2BrKT/uy/bRjG96P5NjD+FqXei6u/ + yD/4nRxWFN73z5e51ppYxGJCtXE2bwWjf6LN68CjF21x70hAST6AI/fc0A7p0lzwlGiIx+IYhnnb4G8Z + AgydnzM0iI7HUcUiDjIyxuC2TIHlgN5s3UpeBqJ6h7WAt1jW8c9EY239vb1278DQlNaugYQITwOF1198 + vvY7/4nalGEJBW914We0TH/eEQZ+n+wbf1aG8O/7XZLCKWQruetVpEGj37hQg56Bi06wyv/azdu45DVZ + PwJ45qNw8jtBHIFngOMoA2ZvwdQNqQnQ7tL7CNvSSgUJJ07VdzTKpTAjEl1o64LcnCQdlYvgOikUfxfD + eDvor6CM96Ldz/MP/10WKwrvbYwaaNBohabqwtcWohQ18rhY8frRPwz0xmXlH7sKavfvJAnYlRpJRewS + qXIGVNAMPJFMoIxwSIB1CgH6kUCN29uL29mBWSzW/AC3I6sFv9uwfrlXEtFMvLwA65BhvuOV9vZvJhL5 + Kcd1HAVKKVVFCut+88jJR8aHs1nefv4sNiQVvE3Dz7jwThfa/N9PIPMgdBPMhRg+Tr9PosniR2U5UYjn + /2ro+1XRe8Or/CDBxG1eemC9nIBh0XoS+ERtuVqWGgBnNT7iUGRUGaCaeOC1K+ZCex8M7oLeLRKqQ4Pr + JNHud6D1H+O6f41S/xuO3clP/Xv4aS9q8HP/je958QXybQPJUrJb3WzbwqVKPCCaeDqo/fd/t+73G5YL + GchMiNmjNfVTfjdxCN62Y1B76r/4JBLVHHHbL/8FwzBkirB6D96yXn9YBRkAOp2q+QH8CMBtnEnT98bP + /pXMIx1a5gmIYKVaAIgav7laMR8t5KM9+XyiTZHu6e5KRWOxTlep92il/rhiWsfffuFcSsP3OPDnGv7S + hR9woc238UcQB18/AvJWv2s0OZeViAuc8s7XV+yycHmuXv1XSIrAmhKb1tcH8OKnfC3go8DPAf0oJSXB + M6PQt3nl+9I0gKSVF16LyZDuFpW9mBWtoFoC7cQxzHcAb0Wp51DG76J4gZ/5jztw7UO/9XP/9aihnROG + 66acSAytPPXfigWjf3igDr/7ohCPfGlBshnzc+K0LBcg3SVOxDrXFC00AVixNuAE/S1S5SxWiFwty5Sm + oKHdrVnl99eF06AjEdzBQXhNOoz7BLBSfWYl4FcEPf4TCPhdgpmHWoGvmRYQ8fZlas3bs1kez+VxqhWi + 7hZuGSanswsqE4u/oyef+0tbqZum1g9rSPlEE0Mq89oJeiAuBWzNqu9qTaaBs+HbDZVxOK2Djsbeai6x + xqLLO9UT8A3EF/CToAQYl1+B7qF6+35F0gCcVkSgtajfyQ4J2xWy4jN1XTBUDHgbGA8Bc6B7gQSui6sM + SfjRhDz/aS8i4eXTG0Zr9R8kaala9oBpwGtfgLlxqYDcfhSGdktoUy9FAg3n2vJyuDX7HzTJShZDu2il + 0FoTi8VJJBPUYhzrofI3IwfDwBnor62zkSdxJVNNLQd+RdCm93VEHe5BquRAzI08AkZ/m1bhwLAWkA/9 + Vsx10DMz6JkZNgEDhkHBsjAdZ5fpuru8Djzg/XYHKwN++BFZrfjH/TrBUO+R4PUxCf8Zod3PI37CNcn6 + E4CUy1aBDwLfB7SjlPQD2HYY+rc2vzzLhQn9S98K/LVlD8SxlDQkccpeQo8L6DTaSEvVoiEvKyJ5/tF4 + UHYb821/b18uninCYuefawsB+Ik5mXGYvi5RjNlbYrldPw07jsPgdtEuwmbAaknAL0v2IgCJSi60jSKV + ThONRoKDXO0ov+L8AIXb3SVOUsfBv8JLEcBy9j3IsHYdmaH0OkE73zEEhJsIUo4TyAO8FPj9d18LwPtc + 8l61DkKuS7xSqWU2+sRhIeE8g5WHOpeK8y+lFWgkyf9UaJ0Lzji85lX/hQngCutQ2rz+BPDSZ3wz4Gng + c8APgRKQXHhB1ONmE2BCAORF6wiAspwtHnYkGga4ng/V9fIKYkkZ4WMp+Wx5vG5XYeaGaA9mKBJQu/Xe + dVdG/V0s570puyuSvzB5Vb4zvF2clYWsmAWvfR5ubhIi6BkR/4V/fqshgboaAJdY1bf/FShNW1sa0zQb + /X+sVeVftKw1uqMdHYmgHKcGtlayHPgdxJv1KoGnqw8Z5TWiDdxA7G6NPLh5goy/VuBv1ALmvX32edtV + CWYsziHE4vcy8O34MO+vhASa3cXlzAHXO5YXCfJ8lRzXjRuSWxPetIJELVbrXlgkd8YEkCtWAn4PeCfQ + gTJg7CKMnoPNB/HjyU1F68WnZoRcKnWZd1DnGGwkgNqVN2DTAbHLUaAdL5xWFfDnZuQ9nm4C/oZ35f3N + scXWt70oRWYScvPQ2Q9v+3EhuembMHoebp6TaMXV14Q0uobEXFltd6GalgNKO0ScSs2RZ6BoS6fr/Arr + HgIMrdPJJDoaRZVKNcA1U5GXAr9GvFhjiEE7htj3e5AMus2IF/+9yJA36q2rIMCNU68FhEHf+J5CpoKa + QcJ2EUSLaCMA9QJCQn56s9lwvI2fG0VRTxAr8QP4Zb7XEFSH1ttj8FKxFsQA7/0WeA1r1yjrHwUAeOFT + /qevAH9dW29X4dxzMiI69jJqf4P33R99674SAn2jeeA7B9FBKLHsFU3ZFenv57/KeXEcxlNgRIJIgG71 + 7r0qRW+m3rKc29R1+U6iTZKXygVxSi7Myt+THfI315aeCbhSVRfuKqSXedR0EAgztIulxQGoANM0Pft/ + sZffH1Fuy+uvVGifBGQQjUI0qApsdjdbgV8RqOR+A5EUUhrrV7dkkSffItAEbiG6cJmABNyGl27x7msB + GWS0L3nb+6aA9j6HdW3/PRx1CH9uPFefAFpdj2bXx/aO56ve8fjXOQeXr0lj2vCD7yA+tnVpunRnCKB2 + alSA/wah9trzE3D+BUlltVeYRe5/xS/HXaTuNxKB97k2iYcHsPlxAWW1VE8AuTkBpT/6a1dIwG991YwE + fEKpVoTMMlOi7qOgWkZlp1HZaXEGZqbF7Em2CQEk2iHZLlWQiTQk0/WTgbYkAVW3ytAuhuvU8GhaJrF4 + bIVAbhICXNFyyLVoWfJqcqSNy+HPEQSIbQjo2xCAt3mvBEIAY8C0UkwrVQNGwVvvIEAtEkQg3BW8e4Fi + 5gjAH36NU58e6HcYWs7RqJt8f6nH2f97FSGAV6n38tlQvA7PleuBrhBL6RzrJHduZqAXPy2+gGrsFSLl + /wn8Jl7HOa69Dj3DMLxXLoEVaa4N6IbL7bfCrmUHepd/qaiAr5Qapqjn+Yw8tHZVCKha9tqXtYvNrhtU + ftf17kqDGVD1R/+S7GvaS8iyIlgzN0l/+r+AYaKrZdxKCR1LUcH1HlZPK1GGRAesaJD0VK0E576kOSCk + ZniPktaaiGURrZsR6M6EAGvLhkK3iOi0Ar8/j2AFGfWKiEo+hYS/JqMRJmMxcobBhGHwkmGgUVQXFohU + KjiIGdDr7S+CICRBa9A30wJmkYc/QZDGXPKOJeydMkLHH7b/m51fo/MvpLvWrfOXffBfR+Ymc0N/m4XX + bog7pNGieIV1bGpyZ6cGC/IC/hfS9ehb5MwrcPoZscfbvVtpepZcIxE0Go2GAc4Szr+wml7rnuvKduWi + hAaTnYHjrpSTbeJti8G/iAS82+Nq2Zc/+menpE3D7kdgz8PouTHK4xcxpq5hFBZQpoXp2pgLE5jFDKWZ + W0ETT78IyoqK2RBPwb63NGQhNljWCvwcBR16vCwrgmlZoYdM1T19TYG8CjJYRA66/uH2j7IZOEqIijuP + gN/3vvuOQ60UxXicYjyGoxQRram4LinbZqur2eG6bEJs5C8jI/Vmb78R6kN0rcDvH1sa0QAy3vooQSuz + IhLz98VocT5hMvA/h/0FrbQh/3rZiAaTRTp6FkJ/K0nmzNfcek4wkLTfN1lHufNzA4p9O4VoAAfxk4MW + ZuDNp+H4OyHqymU3Q57xxuw7/72mBVSbg77OD+CprJogjLcwIx54uyIkUMxBqtMb/cPjRDMS8B6Hqmf3 + VzwSmLkl+992GIZ24kSTFF2gVAIjAW3d0N6DautCpTrl9yJxTwMpiVby6hdh8pqQQfcm2HIoeGzC2kCN + 1EBjCJFoebRMy8Qw1PqO8iyxjeuA49T+3qgLhB/6MUTNrSJq/juQUTzmvSrAfLnMfKnErNbMIKOx3yxz + J5KBF0GIZIxAC/BH7zjL+wH8iEAK0TiU9/t+t9AwsP1zCoO5lRbQ6vybaQE++Cuhc1HB/ss34CtzoqQ0 + TrXwPKI4rZvcQR+AJy980v/0JeA/4lcuKQUTl+Hc10SFrpRCCS7LHXUo374O9CGe9+sOjJAabVgy4hez + Yr8XFwKnnW/3+z6AZna/6yXhVIuB6p+Z8jocGwLeYk66Ic3eEmDHEp6t34ZOduK296I7ByRS0LtZaiR2 + HIeuAWqEFS4q8iXcmdjTHlxlYPtzBSpJA1b+3IW369hbajm8jVIyOUglcEKGnV+Nipv/d4Vk1J1APP1b + kNDegNb0uS6dWtf8ASnkab+FmAjZ0H58e71KYL/7yUjL+QF8X4DnaCOP6NQL1I/izRyArez/MCksZf87 + BH6Ll5GimTA5TMPLl8XGD2PTQIIkZ1YGkJXL3ZkdWEwBDfwu0vz0R2t/u/aGqL3bj4mDLprw6u+9y9lU + G/Ae21ZRgLqiopASZ5gyaucz3t2oQLonFPdH8gaMcL8F//p73O9UQ6N/WXoUuC7oKua5r2JNDaCzs+jp + m7hOBW21g2WhI1F0LCHnakXrRnJcBype28eOfkmZ9o+nzhdAHRBdw6Rq+TV4CiNMHqx0VF+Fyk89Gahi + UWYJgiU1ABdpujCMxPP9OQPjoW0iyGifAGJKEfFejmFww0vamjQMZisVStUqLuIN6/HuTtR7RVge/H7C + UhpJvPHL68oEdQPh8w/rhbBYC2iW+NNIFooA/C6C5Ea7Pw+Xz8IzTv1UZgrhpme4A5Mt3e3pwbPAryAa + nUxN49pw4XkBxeb9IRIwaG5I+SE+zxcQHvGb+gGMYFt/Xr1STt6tqDf6awGh4e3LNUH5Kr9PBgZoB2wv + clCtyOhfLsDgTohEiU5fI3n1RdEOHEe2n78JkSg6msCNt6FTnbjJdtx4Gh1vo5Luxq7akkNgmNIkta4H + QSg/wH/3GpS4yqRsJQNV1bs+66byL2UCKIWRzYKXPecnzTSO/P57DDiCGLHzyOjXZlnMxqJkDYO8YZBV + BvOGwYKhKBkGtmliK4WL5pqGuNZ0FgrsqorWcREhgU0IsKIsHrVdmhOArwWYBN00wgU8sFjVbxXSbBz9 + m2kAvo/BRfIZvkowZTHyeeYcfD4nYG90/L2A+ArXXe4eAbz4KXj4u0Dri8iUaB8EtkrYrAJnnxXADO0W + 9Twa98J4jV5+6p1jbjNHYOjl+wD822JaMtoqJba4FfHAb9R3cMBbDpOA63ijf0FIYG4cOnrh7T8BZoTS + 5FXKN8+hbp1DaReVbMeIJTAiUZRpygNWLWEUMlhzYxhzo9iuCVZCiLB7REwCN+xd88aPsFPTb1WOohht + qz1Grt8odL1G+aWWAWN6Bmy7lpkXHjHD73hXcCviuLuMFIpUlKKSTDLsalKuS0q7bLOrKNfFccUJWHBd + FrRMVbZLa/ZpzTYE7L+PEEo3AuSYdxwmrUd/J/TZQkb8HEGRUdjmb7T/m30O+wka/+6/bIKJUq+z2Onn + QOEKfH5c3AGNHHQRsf2XsixuW+6uBvDCJyUqoPVTKPUvgP8B9KKUAOr0MzJ6D+2WHvjROIuSf5o5xlpF + AbQb9M6rXVIvTGYYEo+vqf401/HCJGCXxftfKYudX87Dpr2yn+w0uphD5zOycVuPtELr6JWS5Y5eSHV5 + ROOi0Bjnn8N97m88AvJG/6gX0NIsDgP65xxqrpKLdeAqA7SLbTu4bnCua/X6t9yHp40Yo2O19Y2FMs3A + EkXms7qBp3bbNt81N8/bHQdD65qhlUVsfj80OIU46DIE6brtyMh/EVHj/Zr/CGJahMEfBn0zLSCC6NYR + 6qXqbev7BZo9Io3gbyQCm2CexBsI+HOha+1C5SY86dn9jUGVeeBJ1n+ulZrceSdgo7z4Kd9J9WFk/oSs + nK4Su/rMs3DjtNjapbzX/KKJje9fbf8yNmYBomUf4T4ENb+CK7UAVqQ+4afxczgpyLFl9C8X5JWZpJYN + 6Cf9zI5JlCEa9xJ+0qLOJ7zag1qbLgNtRnBibRJH167USAzsCPk0qD9XQufs+xC0JhfroGrGUChsx8Z2 + bJTfHKSp7b7ccnPn4KLlchnj5q06FZ/6I6377ANxM+L4c73zS9s2UQ/8/gOZQEbm8CuJoGEUmPKSg/x6 + +Rnq8/h9Z2DjiN/s5Rf7uE2OvUqQIdjstZTGowmKlmzEg/cV6sGvJdX3qbPwcsPwrrzNv8QaO/4sJ3fb + ByASOAXfjxD2bwPpmiZw7jl533JQAGFFg+IZGkgAFTILGkb/ainkTPP+qxRDnn8dxPib0XvduqoAv1IU + kFdKclzjl0l/5v8j4tq4lTLaruDGUrhOEV3N4VYLaLciDsFYCh2Joc0I2oqKD8F15dy2HhbiqOs/GNJw + wrkAZkQ0BsemEElTiLURc4pUqzbVShWVUuj1DgGq0N4MhTE3hzE2DgROuFY5AGHQRJCy3uvIqDvlvdtK + UTUUFWVQNAymDYNxw2DKMJgxDTKGQc4wmDEM3jQMjGqV/Ny85AsgmoLf/y/sDFzJK00w/VYn9eD2NYNm + WkCrc4RgenQHuIA4/ErUg38CnnkTvurU+wL93T2PTGZyR+XeEAD4JGAjkQGQPIH2Wt7+pZfFWbf9GEQd + eejNSADkRUlDDRqCHRr9/W0cW0J/fq6+7/hz9dIkoHRQM1AuCHC7BuHh70IVstgTF9CTVzHsHIZpYblV + jNwUKjcJY6e92XkAw0AbJm40QTY1gJOZETLq3gT926gVIdUZok1IwLSkZZm9QNWMMpfsp6swiWPbFItF + urq7qCXprMIfUFu37LKBceUaaj6DRgBn0XokbAydjSBawAUkN2DMMJjp6KAYjaJNQ8pxtefM9OsyXBfl + upSrVWKuy2bbYaeCXg1fQAppOrzjiBM4JFdCABFEC5glMAl8ErARMIdB70cRWp2jH+OvIFk7/tTeYfCP + wzOn4Cm7/k/+JT7FGmb8XY3cOwIAnwSqKP4HWleA3wHVJaO6Kw1FCwuw87hkDYanyNYNnNvoB7DLBFWF + 3ndKOSGGRHugMdSN9ro5CWjXU/2LUtjjVOHAW2DrIfTsKCXHhkIBIm3Q3iNJP+kuVLoTEm0YpoWqllCV + ojj/Xv40bmZBnJxmRDQdf8ovX5YkASX5BaUFQDGVGmbb7DmUa5PL5dZnlF9qH46D+cabaK8MOAF1OQC+ + tFKdTQItIA9cdF1su8o7q1W2VqsktEvc1bhas6A181oz5yUHTXsP7RZklg+/P8AfEmgBeYJReyng++aB + RvIOZhB7tCd0/IpACwiTgGpxjmXveBaQ4ftaaD/eI1UZg6fehK82Ab8f7/8c4je843JvCQCEBI683ca1 + fx/TKmFG/gOG2Vf7+8xNSdzZdkQSZ6xIfS19s7Jg3/YPg9+xpRYglgyN/t4tXZT8p72QoLe5XRbyKOWF + AKyYNDYp5aTQZ2ZUPifag6SfVCe6vQ/S3bi+004pKoO7UVdPo6dvyM67h6Bva4vRnxYkAESTXtcih7lE + H7lYB+2FaTLzWVxXS1NQ1knlD/+nFMb0NOYZaVplIPb5SsHvvwaRqIDv+RrM5fkmoFPrOjU67n32s+eK + iC/gFqKu+85Av9a/g8ARmKA16FtpAXMIGURD52Ejo7nv52gFft//MIZ09ZmlHt0OFG7Ak+fg5SZqv4H4 + CT+F+Dvviqykg9Odl4krYFqay6+9TrrrOqb1KIbZAciD6SfcVEteu64QF9clAjmB7e/4fV0AFOTnpein + c0AIoFHpCr/X1itR/4sLkM9Kzn8hC66DQhNdmMGcvIwxfV3Cfok0KtEOqQ5Id0qYMZaQSIYPsEpJsh+L + OSGzvY9J8o9ucjyLPocWDFPOs1rGMSPE7SK9BbHJhzcNE4lYy2b9NS5Tt6yaL5sG1le/hvXUM7XRv7Ph + si0Hfj92HkOqXaoI4E5Qn4hT632tFGUluQEl06BgWmQjESrRKPPRCBcclwta16oC/R4BPoiXcwT6L0Uw + yV6qyWPqRzr8Tr/h5Ccb0TzOIiN/2NkHUIHZy/CpC/CGu/jO+nn+H2fxzL93VO69BuDL2CWIJV3OP/8X + bNqXpbP/3xJPH5FLpWQEv3VORtxN+6Shhj/zsJ8dqJF4emPoz6lK2C6akBx81wZMAXeznh/4n00hn2JO + RvjcnJginQOY45dIX3oOo1IU4jEMdOY6jMUk6cfTAtxEkPRjJzuoFLzeA2joHoaezcHo30gCS2kCSonG + UcqBhtH2bWydP49ZKJDNZEkmEjVHoL+L21b5a39SqFwe85mvoj3NK83iBKCVvgYQLeAsApgXgb5olEwk + QiFikTdMFgzlJQcZFJSiolRtJqIbQNx16bTn2Fmp1OoH/BE8Tn1IcDlTwM9GnEE0iXBkw/cFhJON/P1W + ENSeRZyaYZUfIA9Xz8Pnxupn9fHFH/k/zhpbfN+ObBwCALGzQXPz7KfJzc3Tt+XXaOv5FgzD16HFA3/h + eejZBEM7ZZT1qowBAWzj/AP5edm3P0WZ28DBjSSgANPzQ5RC4HdsOPHtsOMYzsRV5m+eQY1eRJkGRqIN + VZf0ozEqRYzcHNbsTazpG5Rsh0qkzTOEI9IZyYoEiT+NmSdLkYDWAaGVCyzEOrnVvp2d06eYmppiYHCg + bjfrYgIYBsbLr2Gcv4hGAJLi9sDvawH7ES2ghDjzCrEoOp1mu+uStB2SjsNItYrhuDiuS1m7FF2XBVdT + 0Zrt2uWAq9mBJBh9AFHjfRPAd+gtBf6whtCOEMAsMr0XoXOrEGgVyvv+vPe7fv/CsFagoToDr56BryyI + e6Ex7K4Qm/+TiAvjrsvGIoBANPMTz5Kf/0UGtv1TekZ+gEjcm4zO0wYmrkgf/r6t8kq0UWvzFexFRvv5 + CVH7w6M/odEfFmsAKuL1ClgQDSA/L3b/9iNQKqCLC+hcRoDc1i3k0h5K/El1eJmK4mZKvPxJ7Jc/H/gp + ekakJ0Lj6L8kCWhkWPcLfkzpMlSRyTmude5hKHudqYlJyrtLxBMJwglTa/IHKAM1n8H63BdkhmIELI0l + sKt99SHOvNPez5jFEo+5mh8uFDC9/ACNONXCiUH+5wyCrBxSXLQHcaGnEYLypwdrNeo3vkcRLWCSYNIP + X/z6/QSi7l9HnHwL1AMfROW/CV+5CKfs+tl8wnf1FOLwu2s2f6NsDB9AK7EiU8xNvBxzyrFIJPKoE4kb + dSqwU5UpwjKT4tTzk2p8QCkgNwtzE2JnRxOhnTfGwkKfDQNMQ2z/3JxoHaWczFg8vFsIZfKq7DeWFLMg + 3RXY/cmOIFqBAtPCmR3DuXnePy/Y86jMZRCeecj/oBoYILzc6BOwIl5lYoWKFUcp6Jy/Rkd7O53eDL61 + zRZV9MGK/QFKEfnM5zC/8nTNzu5lcQXgal6+shVHgFQFcF32Ow4HdNDpwKM8HKjNQ+hPR5bz/pZQigRS + IXjZ278fnoxTP9Iv964QcokSTOddUzC933gD0dvLDbdEg52B06fhk9fhkrvYIvCTfL4GfJ51Lu9drWxU + DUCkUmLfoSOjjmM/V67MUnCLVDqHWXD8PjjedS1kpaowlpQGI23dkqRTKUqtfiQm4HedBnB50uiOcV1J + 9y15cf/igvgDrr9JdG6UJBV0uYh2bNx4G65T8JJ+8minjOuU0dFkLekH00JnpgJy6tkkeQQ+afmDg6JJ + NGCJ6ID2CpZS3eJcdB2ud+yiNzdG//UbDI0ME/Fbdt2u1x/AMDDPnMX8zOdq8fkulm+XtRz4/RBcD4EW + oIFp16WolGTTGQYVQ1FSkgQ04VUFzpgG84ZZSw46byjMhRyzhQImMkLnCSoMoV7VD4O+lRYw5r2nEMTO + IcSQD+5K3aNThslb8OxleLMimzSz9zNIT5NXWcOknuslG5sAgFgigda6J5ZwrcFYhM4ekytZm5tlg6IT + 0gZAEnWmChIxsKJe049qMDtxLfEH6vTsxtuELZ77RLuAH6SGIdmBnryEPXUV5TgYZgTLqWAsTKKyE3Dr + TVSoI7E2THQkTiHWQWnOaz9hRWFkr1fR18T72Mrub/Y3kH1EE2JyLMxSNaKc6T9B+8TTbBsbZ9PWLTWH + XW2zVWX9Gajpaaw/+xDMzaMR1d+3/X0QN2Rl1P0N6oHf+A6iul9BMvnOAr8bjZJrb8OORHAMA8fVaC/Z + S/lmlOtiuC7VahXbdRlxHR6Xu8cnEPu/g6Xt/mbvGjEhxpAwZYz6tOBG4NvSU/rVS/DifP2cHo1P2FXg + i6zDhB7rJRuaAA6ffMR/eIdRis1btnBw3056LlxkYCrDjZJivGxQrvn8vOvs9/vzQ2CmJf4Bv1BmES/r + 4EmsrUMmvUh3S9B63+NQLVN1qlTzeYh3SdJPW9DpRyXaBDBe0k9k6irxFz6G7U7JVONoGf07+r3Rv0UI + wgd6OOzn5zQ0IwilINkliUrlAtlYF692n6Dv+nn6BvqIxX1fQHDyi0Z5mpCBYaCyWawP/hnq7Lma46/b + +/tS4G/MCQh/txkJdBJoASXgkm1TRvGufJ695Qox1yXhumityTVJDtJIhuEOb18XkIc7QlAbsBToG9eZ + 3t3wvf+NkWIlfytm4Ow1eGEcxvRidd9/kkpIBfQzrGM/v/WQDU0AhlI4jothqGEFJJMJevv7SLe10X31 + Ol03bjBcqDJaMpgoK0p1IA4lzpRy4qyLeC6dsPOv9mMs1gxAGnhE49LJOBKV5p+Votj78cakny6vVBdQ + Bk73Jtyzz2EvZGS/VgyG9wjwWzUb9R18riO2vd+KzIx6nYM9n0DdYbqiUbT1QuUGaJep9AhP5jWDN6c5 + sXMk6EHI8iq/AvDB/4E/xnju+Rp4u72HphH8oSOpjZb+RHZ+Fl0r8Pvb70KGyDxgOA5duRyPV6tssu3a + 7bIJhlg/OaiEeO1vIsB1vOP0AbxS0Psvv2Fpo7LliyNZIReuw8vjcCvUwKNx1NcERYAXuAupvauVDU0A + aI1pqIj2IjKpZEKcRvE4e/buprevh6uXr9I1Pc2mist4RTFVNig6UA0/lYWsjI6JNun+G403J4FFpoAX + KTBM2YddkWxCpSQb0YrKvqLJYEahWsYcuI5Nyb/l2oXeTeKj8Ef/xmajeB2Ps57jsVwMfAJWRI6/vTcg + mvDkpXimQMcAzI0CmvHUCB9eiNM9X2J7dzJoM7Cc/W8YqEwW6wMfxHj2ObTWOEjrrjTNwe8gwJxGvPJh + dTmBALKL4LI3koCLqOvbCE2NVSrVhdY08sD6dn2coMuw4f3uKKKlGLAiez/8XiZoDdY43bkLpSpks3Dp + JpyahHEn8O43G/WzyKj/Ahts1A/LhiYA7+FKAP2GYZD0Jr3QaJSC3t5eOjo6GB8f5/rV67RnF9iWcCi4 + ijMLBvPhGcmdqkQEigvSnz/Z6fUbIDANmpEC1GLgxBIQHZF9zE/A+CXRKlId4v1PtBGJxbHiCXQ8TWVm + HLeY81zScYki1CYB8Ub7cLNRuwyzo3Kc/sSkteOviFMyMyUE0LdZftNHmU8CyQ7Z/9woGHDd6uGDk0V+ + NukwFAd3KZUfwPTCfX/wQYyvfg2tNTYC/i6ag38BCYnNEni1GkJiZBEn2ggC2rATMLzPHYgvIAeUtOZ5 + w2A6HiNvmpQch3ypLCYA4k0reg/IAOKb8KMFK7X3XUSDyBIQV+OtLymVvQB/M6P1rQIUQ6p+Y1zfV/fP + Ac8hfNTE67xxZEMTgCdpoMcyTRIJyQz3xyqtNVbEYvOWzfT19TE6OsbNm7eI53LsSbm8uWCQb1S6nKrk + 8xcWRBtId8oIXvN46yXMA2Tk9sDOwgxMXZNIgzdSO0phKZeY0lQNL29MI3UM6e4QsMMdhzW4Zal7KGQI + p+8G4kcCXMlqLC4IoXT2LzYHUp3yce4WGHCukuAPbtn89OYKgzEdmjdwcaKPmstg/cEfYXz1a7gIoAeQ + EbyZvT+D6LbhGW1YfOSAaAg20hMgnKATfm9DtIA3vOUvAZ+Px6FqY1SqaK1rHvhOpCioD3mQVxPqcxCk + ztMc+L6UDIObHR2JBSty1MnnqxQLN9A6XMTjn7Y/ofGLCIfdcw//SmRD5wEMDI8AbNFavzsWj6UO7N9N + PB4PvqDAb4IdiUTo7ulioL+fWCyG5VZop4KhNSUXbN3waGpXbPliTkZX0/Ji96r5Uxz8oIjfUahrSIjE + Ecej1mAri4oyg9E2mpDOv7Hk4v35xzJ9U1xKrX88tJkSU6GQkeSmeJPM9WhC/AaFDCiYrFrcLCr2pFza + LdDNwD87j/X+P8J47vmaLT+IhOlagf889XXuSx42wXRe4Uk9G0kggXjgywBaY5TLGJVKXQjST/rp9Paz + kiQf/72INwkJor00M8yNRILIju1khoeZ0phAfywe3xeLxXu1Ju849oJ3uGXvMnwReBbJUWqmR25IuR8I + 4ADwU+lUKrJ/724ikUiNc1X4sfOWo9Eo3d3dDAwM0NORZiBp0RvVaKdKqdE3AAK+clE0AtsjAr/Vdv3O + Q4uhBcMQtbtrUIDozxYU/IA0DR3YTpB8pOr3lZ2VacuM1ShknqNwORKwPBIApmyLG0VDSKA2g7gCw0TN + zmG97w8xnn+h5ggbQsDfTO1fLfhDR403Q2OdPyFsElje7/uJ8f5vtiGOwr3URyJWCv4CAvoJlgB+MkF0 + 506SJ48R27WTjoF+ujrb0a6mVCpbKDUYTyT2pdvbO6Px+OvVauUvXNd9FuGU+wb4vtwPBPAY8COdnR3G + 3t07MEzDw3+QyadU/TJAxIrQ0dnJ4NAgw/09qNwMHbpM1ISSo1oQQV7A4hOBGaFe0wu9N6rohik9/7oG + BXjVsqQlt3XDlsNeBCKcexCKUkxclnfDXB2aVkoCkaikMishges+CUQV2jBQMzMC/hdeqmXYLQf+C6we + /IT2kfH2r1jsD3ARR59v4ycR38B+RN0Pb9MK/I3An0Ay+FoDP0ls104SDx0ntnM7RjLp3SZFIpGgr7eH + jo42HMfBisYibR2dw51d3Qf7h4ZTA8MjN/uHhqcHhkf05NjoKq/IvZUNSwDHHn7Uf1jeqbV+10B/Lzt3 + bMVQIaerqrNia8uN5BCPx0ilUlQKedp0mb4YRA0JG1YbQ4c+EeQzMpqblnjg67SAxjTi0N9MS+Ya6B6S + 1+AOiCfrfiL4rLzkpWvyHdWCXJaUlZJA3KtChOmqybWSwa40dGRmsN77AYwXX8ZBRt5hlge/b/OvRsJh + tQwyovuz+WjqnXcmAvZ+pGJwgCDEt9yo77/yCOhHETu/KfBTKWK7d5F46DjRHdswkonQUdbpmHR2dvDY + Y4/w+OOPUrUd5jPZNtu2H1dKfbdSql8pdb13cGh2cGSEydH7gwg2LAEMjmySsJXincC3pNMpdmzbgmEY + DSbA0mTg/59KpRgY6CeZTIJdJU2F/qgmZirKLYmgAIV5aVvu+whUo0bAYmIA+W4sFaoJoIkyoQSUmUnJ + KVCN+10pxFZIAlGPBBRMOxGy4zM8/JfvI/LyK7WmF5tYf/DrJp8XEPC3s3R9vl/b36qmv5mq7wP/FkI0 + TYGfThHbs5vEieNEd2zFSDSpEwHQmmgsypatmzn+0HH27dvL8MgwBw/sZXhogEKhSCab7XAc5y1Kqe8y + lOpUqOtDm7dmBoZHmBi9oz091ywblgAGRjb5H22l1PcUiqVUb08X3V0dQIPKHyaD0FvjciQSoauri4HB + flLJJNquktblJYgA8dqXC6IRVMuSHWhFqLUrb8IHi4HM4s8Kz/6fkWhCoq0FudwBEsjP05uZ4gc/8T42 + n36lFgPfjNjWzcA/y/qBXyMjcpwgtLiaVystIIc4D33gN3PDG21pYnv3CPC3bsFIxhu+EZhmsViMrdu2 + 8tDJ4+zbv4+OjnaUYUj0yTQZGhrg4MF9DPT3k8sXVDab7XIc921KqXdp7aZAXx4YHsn1b97E5K1bq7hq + d082LAFMjN5iYHgEpRgFtjmO83ClUmXblk2YpnfYzVR+GsigyXLEEiIYHBwglfKJoEJfTJMwaWIaEGgE + +aw4+Qyvn1+otXZzoKul/5bPSKeheIO2sCYSyAYzDTdKLEVffp6f++h/5OSVV2vda7ewNPjPsz7gBwHm + HDL6r4YAmgHfRrSJUe/lA7/RxWO0tRHbt5fkiWNEt2zGiMcbTkbVNorHY2zdto0TJ4+zb98e2tvbZS5E + VadzopFBZdPIEIcO7KO3p4eFhZxaWMj1avhWBf1a60/iamej+gY2LAFAjQQ0cEsp9d25fKG9q6uDnp4u + YGmVvxk50LBsWSZdXZ0MDg6Sbkuh7SopTyNImFB2odKUCIoy0laKEgWozfVH69F+USTB+69akqQiv8FH + s/h/7eMKg22u3ZwEDIP+mZv83F//Bx66+CIVxJG3lfUFfyvg+8vziGOuH/EDrBb4vr8gDPws9ZOD+tfL + aG8ntj8AvorFFp2IXyuViMfZtn0bJ06eYO/ePbS3twnwvX3V80WwrLUmGo2yecsmDh3cRyqV5Nq1G9i2 + PaKUelIpdWti9IEGcFsyMDKCVkwoGHRd9y2lUoltWzcTiYRi9is0AVQLsjAtk04vYtCWbkM7VZJafARJ + S9UTgZ9+62ohgBoRmN78BQ3JYU2DCOEwogkL06JdKAVRr15BNWMSbo8EYikwDQamb/Jzf/lbHD/7LBVk + 5N9Gc/BrZJReL/CHvf9zSCLQVlr372822vvAzyBq/i3qgV8Dv1KYHR3E9+8lceIY0c2bBPi1gqjgVgIk + Egl27tzOiZMn2LNnN21t6ZA1purB75luTclAa2LxGFs2beL69ZtMTk4lq9WK+eYrL7+AcN6Gywrc8AQw + MXqLQQkH3lBKfWe+UOxqb0/T3yezw7ce5cMmACxHDqAwLZOOzg6GhgZpa2sD1ybplumPaVKWouJCWZrW + h/RALaN43iMCf+qu8JRmzdDjr/MjDPl52Y8yxE6H9SOBWIKB7Cw/95e/zbFzz1FGwL+d5um9dwr8C4gj + USP+hj5WD/ybyIi/wOJCH5TC7OokfmA/8eNHiW4awYhGFzVd0V4qZDKZYOfOHTx08gS7du8iHQa+t7+w + yu83R6lbbiQHFBHLQmuXN0+fw3XcLYV83qhWKhGCeVA2jGx4AgAYHBnBddxpZagOrfW3FApFtm3ZRDTq + VcfBKvwBLLtsWpYQweAg7e1t4NgkXDEN0pai4irKjg51JFeAlqYchUwwmltRZIJT6lHUqA0kvby4sDYR + CTWjum0ikGjG4Ngl3v2Z/8nRiy9RQrz96wn+5YAP4pn3M2WGEc0DWoPePy6bAPhjNAe+qxRmdxfxQ/uJ + HztKZHh4MfAVtb4IyWSKXbt28NDJ4+zctZNUOr3IQms1yqsllsPk0NaW5ty5iyzkcgm0zi1kMn4U8/IK + Luldk/uCACZGbzG4aRPAdaXUOwvFYn8qmWRwoH/ZUX2xCbByMjBNk46ODgaHB2nv6ADHJu6W6Ytp2ixF + 1dWLicDXCApZKd5RBFGDliRgSDqx68p2lZI4BCPR0PdvgwSUwVBminc/9eccuXGGIgL+nQRTYN0N8BcQ + 8NtIavFOFhftNALf78BzEwnp5WgCfMPA6O4iduggiWNHsIaGUJFI0JSldktkOZVKsXv3rhrwk8lkcyCr + JUZ5b91y5BCPx8jl81y4eFmZESuSnZ876zpOlCCBckPIfUEA4IUFNfMoYlrrd+byBbV16ybisdjqgB0m + A8+Dvxw5mIZBR3s7g8NDdHR2ohybuCMaQXtEYbuakqNDD72nEVTLMqoXvbZvljenX/hr/rsypKrQn76s + WpIog3WbJKAMhjMTvPvpD3N4/BJFRPfchZTd3i3w+3n3VUTl30XrhB4f+DOIfT+OkMeiVl6GgertIXb4 + IPFjh7EGBzzg1x+3f0fS6TS79+zmxMnj7Ny5Q4CPCt/u2nVcPKovRQ60XFaGIpVMcurNs1Qq1ZRTrd4s + 5HMFxK+6YUIC9w0BTIzeYmBkBOCaUupbiqXycDwWZWR4UL6wBpV/KXKofUcpDMOgo72NoaFBOrq6UK5D + zCnTH3HpiChsjRBBYzcfpxJoBIblTUzSEDVQiLmQ6hDwFxckE9GKen6CkCxHBMpgZH6Cdz/zIQ6NX6aA + jPzrBf6VAB9kmJv2frsb2I04/VqN/BmkrHiCAPh1iT6mgerrJXrkELEjh7EG+lCWVWuUFByHHElbWxt7 + 9+7hxMnj7Ni+jWQilOVXB/7Wo/xKVX7fnAvvI5VKMTExyY2bo6ZlWe7c7MxFtLaAM2yQ5iD3DQEADAwN + g1LSrEXrdy3k8saWzSMkkvFlVf7bJYcaGRDcfMM0aWsTIujq6kKhiTgl+iMOnRFwtWgEbiMi7IpMc6YM + Cc81IwHDIwG/UtEuSychs6FQqBUJGB74n/4QByeukEcAuIe7C/4KgcerEwF/jNbgn0Ia5eVpktNvmqiB + ASJHDxM9fAizrxcVuh6BP1ajlKK9vZ19+/Zy/KHjbN22NQR8uW7h1I2wFhgsr8zrX08OahE5WKZJJGLx + +htn0JAuFYsXy6WSRhScWTaA3FcEMDE26hcIXVNKvaVcLm+1IhabR4ZYrde/6Si/InIIyMAwTdJtbQwO + DdLd3YWhNZFqiT7Lpisi41DJDfqNiGXgtSgzvFThZogzLSGBckG0BrsiWoNh1X9/UcWiwaa5cd7z9Ic4 + MHmVHKJS7yFIuQ3H+H3wrzTDb6XgryKALiFx/j1IiW8r8M8QTKxRB/yIhRoewjp6GOvQAczebpRZm7ih + BkIf+B2dHew7sJcTJ46zZesW4vF46JzWaZRfqQmAaCLt7W1cuXKN6ZnZqGEY+czc7E3vNM83uXR3Xe4r + AgAYGNoEiiLyfP3d3ELO2jQyTCrtVW+tZZQPOKKpCdBqH4ZSARH09mAAVrVEr2XTG5WuAHlHhTQCLUVA + VkSakTQbzM2IOAZLOSECu+J1MPJTkBtUf2WweW6M9zzzIfZNXqs5zZqB3z8MH/wFlgb/SoHvh+umvX2m + vN9P0Rr8c8jIXw6tc0wTNm/CPHEMa/8+jO4ulBEA37/LPvA7uzo5cHA/J04cY/PmzcRiDem9jaP8EmTQ + uLxilb/FcjQSwbZtTp85h2FayfxC9qxdrVpINOCezgkA9yEBTIzd8rWA60qphyuV6i6lFFs3j6BC+flr + 8wcEo3wN/IS+04wcAKUU6VSKwaFBevp6MQ2FUSnSa1ZJmy5zVfETgBKPfykvoI7ECeYrCD2plkcChQUh + Acf2+hk2kIAy2DI3xnue+TB7p67XQmX7uDvgD/cF9PvmJxC1v52lbf6rCJPX7PxYDOPEMcwjh1CdHWA0 + YUetMQyDru4uDh46wPETx9i0aYRoNLq4LW9TL/+dUflbkUFbe5rTZ86TzxcSWuupXDYz6136q9xjue8I + AKB/0yaUpowkgn3PQi4XHR4apK1d5pa9Uyq/WiE5KKVIpZIMDg7Q19+HaRpEq0Ust8J0GRz/d1zHIwGv + XLeZeh+JypTjhayQgGt7KcMeCRgGW2cF/Humb9Sq3/YRpNk2gn+e9Qe/ixi1C4itvwux/Zsl+mjve1e8 + Y6j93bIwjh/F2L1LZmaqE2kBZxoGPb09HDx8kGPHjzA8PCzA19QD+x6o/ME+67+TSCTIZrJcunxVWZYV + yczOnXddN4pMgdCqG9ldkfuSACZv1bSAG0qpI5WqvV+7mm1bNwX9Au6gyr9STUEZBslkkoGBfvoH+ulJ + WLjlImO5qmcOKCGBcl6cglYs/APBezQu7cT87sauC7E4GBbbZm/xnmc/zO7pm8wj4FoO/OdZGvyrUfmh + HvwRJM7vlxQ3ZvhpREPwG38GHn4T4/AhzL17Fo36WoNlmgwM9HP4yGGOHD3C0NAAkUhEYvzLOfZuU+Vf + zSjfmhwkepRIxnn99dNUbSdVrVauF/N5P0gyzj2U+5IAAAaGhwBVBWaVUt+zkMvFBwf66exsr31nXUf5 + pchhuTn3DEUikaS/v599mweImAaXJzM4/izFji2jezwdxP0bSSCW9Ep5MxIm1LB9YZr3PPvX7Jy5xbz3 + tf3cefA3fp5H1HkT6dzTT/PUXk2g92bDfzcM1IF9WAcPNIz8cpT9fb0cf+g4h48cpr+/Dyti+kn/KwPy + alT+FZoAq/EHaDTpdJpbo2PcGh2zLNOy52dnrniX7Cz3MCR43xLAxKhEBDTcVLC3WnWO2rbNju1bMA1j + ZaP8evkDFi2r0HLd3ojHY+we7kNrzYXRGVx/9l67CpWCqPu1yUWof4+nxCQoZtkxdZ33vPQZdsyNMed9 + ZT+t+/bPc2fAn/H2bSDpvYMs7u7jH08JGfnnQ+sdpTD27MY6ehis8OOoQGu2bNnM4295jIGBfsxGcrgb + jr2lVP7QKL8cGVimiWmavP7GaVCki/nChUq5rJGJQ+a4R3LfEgBA7+atGNp1gEml1Pfm8oXkyPAgHR3N + tIDbGdVXsA+WIwfVsAymodg12E3Ztrk0PhskDtllSQNOtEnjkeDHA0m0s3N2jPc8/3G2ZaeYQ8C3FvCv + VuX3P/u9/kH6CQx7n5s5/SqIt3+Wes1A7dyBdeIoKlrrUooP/sGhQR557BHSbWmoS+9dZSzf36bJ8ppU + fhSGlyCmDIUyGoi/YZu29jQXLlxmdm4+Zigjm5mfG0X8tRe4R3JfE8DUrRu+L2ACOG47zsFEIs7WLdJN + aD0de0up/IHev3JNwbIMdg91kyuWuTo5R82LZZfllWgP0ob9TQ2DneOXePdX/oytc+PMIDfwAHcW/M0+ + 5xAwa6SN2GZvfTPwV5E4/xT1ST5q62YiJ08Epbr+EWpNb18vjz3+KO0d7SHwr1DlZwkyWBeVX2EYJtp1 + WcjlmJiYYnxikmwmSyKRIBqLegWjqk4LjEdjlCsVTp85j2lZiYXM/FnHtiPARe8W3XW5rwkAoH9kMwrt + IOHm79Ggdu/chuX377vrKv8y/oDQctQy2TPcw0y2wI3pTLDXaklMgmR7EPIzDHaNX+I9X/wDtkzfYAZx + uB3wTvxugr+AJO+4iMq/1dt/q449NxCGDqf2quEhIo+eRCUSNfArAK3p6uri8Sceo7u7qwH8a1f5lx3l + l1H5lWHgOi4XL13m81/8Mp/93N/y1NPP8cILr/DiS69y48Ytenq66erq9LoIUfcb6bY0p948Q6FYSmrX + ncgtZDMEkyvddbnvCWBy9KavBbjAD7uum9q1czvJlKR/1o3yS/kDlnPs+etYCzmwaDkWibBnuJvxuRxj + s9lgH5WiRAgSbWBa7B6/xHv+9o/YPHOLaWR6rdsF/2qBH14uIuD3pwvbTuvKPpugjDdcyaf6+4g+9jAq + na458xSS2NPe3s5jTzxKX19vMK15E5V/Scee/50VLK9G5TeUwdzcPH/zyc/yiU99jkuXr7KwkHMq5XKu + Uq1kHNthYnI6evr0ORzbZnCwn0Q8juEdrAZSiQSzs/NcvnLNsCzLnJ+dOa+19kOC4cns7orc9wQA0D8k + 1qdS6oeBvh07ttLZ0RbyFMv31jTK16n8y4zyLffZnAySUSGBG9MZJudyslojTkFgT2aK93z5TxiZHWUa + ibPfLfCHP5cQ8FeBXsTj36pjr0PQoDMMfnq6iT7+CEZHR62Ixwd/Kp3isccfZWhosNa047aAvFQ573Kj + fG2fi8E/MzPLn/zph3n5lTeoVqvlUrFwZnZ66stT42PPTE9OvFgqFi/HE/G07bidFy5eNi5fuU4mk6VU + LqOUIhKJEI1GSSaTvPraKRzHTVcq5SulQqGCzFkyyV2WezI34JGTj4C0et8HvGHblTnDMPWpl19ay24d + wNZao12NQhGeDWxlJgD1QA8t19Ytu1y397rl4Ov122g0/R1pfvodx/ndz7zAhbFZoWYFe6+8xs9deomh + 7AxTSCfdg8hkGatN8lkL+MsI+CtII5HtLA3+cUT1twlUfzo6iD1yEqNTVHv/+LTWJBIJHn74IYaHh2qx + /UVXSrEiMlhquf7eyn8rWXYch8994UucO38R13VnpifGvzA9MX7edd3aPIGVcjmfW8j+df/Q8NHOru7H + L1y83Hnx4mUikQhtbWn6+nrYvGmEoaEBenq6yOVy8c7unoNz09O3gENIleBdnVPwnmgAnsp+DPgw8D2G + YW5TyrAHhkcy/UNDpYFVTqwwOLIJpdQ+rfW7Y7Fo6sih/aRSfm3A7an86+MPqNtbHfjrNQeFBjpTcXYM + dnPh1jSZQol92WnefeEFhnLzTCHptSsBf556oKxF5QcB/QxCAu1Ill94ht9WlX1VQiN/Ok308Ucw+/vr + wY+0337o4RNs27a1dt0XjchLqfy36fVfKfgNQ3FrdIJPfPJzlMuVytT42Ccnx0bPeCaKCr9cx3EXMvOj + pWLxqpJASdF1NaViyZqemTUvX76q3jx9joWFnNde3EoVcrnz1UrF8C5bhrso93J2YN+UPAmc1Fr/E6XU + m0oZnwc+d+TkI69jkMWF1198vuVOPG2iDfh5rXV/X2+PJAPp0PSXLUb52rq1jvK3s02TZVfD9oEufvrb + HuaLf/o3fP+FFxko5ZhEQH83wN+ssm8GUf/TSJZfjNaJPtNIok8l9DcnkSD+yEOYAwN13Xo0mkgkwrHj + R9mxY3uTUZ/bGNVXOco33WfjNgY3btwil8tjVytjs9NTV2g+Nbh/uWYWMvMvL2TmTynDGIhGY4lEMtmZ + TKX648nkUDQaG7Asq8swzaRpWR3JdLo3n1uY9W7xXXUG3ksCuIzMpvpDsWgUK2K15fOFx1xXP6YUP6+U + eh2XzwGfP3LykVMVHcnFVIXXXnwBgEMnHiYSsXAcZwT4Va31jycScY4fO0QsGq1TI2FjqfxL7UOj2Dc3 + wa7Lr6I98KeRJyPB3QO/349vhmB+vp2hY2iW6DOLJPqUQuuLkRjnth9lU+cQW3Q9vZimyeEjh9i9Z9cK + VP7bMwHq7638t9plgNnZOVzXpVqpTtvVamP+vgYuAS8gAPZLHPq0676lXCoeLJeKufnZmeuAYUUisUQi + 2ZZIpXoTyeRgpVzKevvZA3yNu9gr4J4QgOs4GKZZAT6mtf6+ZDJhffPfeZz5TJar124yMTnVXigU3+q6 + +q1K8YtKqVejqvpZjfrCkZOPXEY00BHHcd4G/ITW+mgsGjUef/Qk27dtWdSR57ZG+dC69RzllyQHw4A3 + TsHvvQ9ncpIZRLVpBX4/E68R/Gsd9f1MvjnkSY4jDr9WZb1+OvBlhCz89SUzwpvDu7nRPsj4tI3qMdmS + MtAKlFIcOHiA/fv3yXRvYVntKN9im9WN8q2XFZpKVRz0rutUvFMOX+6vAV/2Tj8sU8AnEHJ4C97cpna1 + Wl2oZqYXsplJxO7399WFTH78Ve6S3BMCOPXKS77q/mWl1MVMdmFfqVzmyKED7Nu7m0wmy63RMa5dv8XE + 5FRnsVj6ZtfVb1OKf66UugnEtNYDWtOpDKV6e7p55OHj7Nm1HbUuQF7lKL/GfSiQHPjX3oDfex+l8Qlm + EHv7IPUTaN5J8IfLeueQZJ8o4vBrVdbrZwRe9o6jlvlnRji7+yQ3OwegXKCoE7wwI9/f1mawZ+8eDh8+ + GMzyFLo3d3WUX9E+VK0DtTKMUCtqDETpaQZ+X2zgDcS+H0JSJ4aQQEq7d4nDDHgAeIW71Dj0npkAXljk + RqVS+bxt2/suXb7Gjm1bsUyD3p4u+nq7OXhgL/PzWW7cHOXa9Ztqamqmp1Kp9CjDIBaL0tXVwfatW9i9 + azsd7W11D3NzlX89/AF1e7tNEyC0jXiZ4NXX4ffeR3FCRv5O5EmI07yNV5b1B79GwDuPgD+C5Pd30bqm + P48MbwuhdVXD5PyOY1zbeli0sewUlPMU0Tw/HWVg2w6OHjuKFYmEWncvZwJw11T++mVZ09HRhmEoLCvS + bhim6bqOX9l8idbgD0vWe51DnO8JpFXiAEII/d6yP2ny1zcBGEpTqVQAPq6U+ulbo+OpTDZLd1cnWouD + yDJN+nq76e/r4fCh/czPZygUClhWhFQqSTqdJBqRHPJF4L8fVH4f/K+8Br/3fgqe2t+FjPwxWoP/PAH4 + 10PlD+97AXlCtyJlva3AX0Se/kxona0MLm09zOVtR3H9yEp7r+y4tEC5e5gvRvexe07xzQNe+861OvZa + 7GM9yaGvt4dIxMKuWl3RWDRRKhYXCFwfqxV/LtMc4jNQiCbQ4b1WQijrIvcsEWg8qOmfVUq9vVqtbuns + 7GBosL/2gPq3TCOtudOpJF1dnXS0txFPxDGNxbX/K87tb1xeKrdfNWwTrGzYZ2syaBoCNAx4+VX077+f + wuQUM8gQcLfAH3Yk+vvOIvroZmRoahXqKyHgnw2tc5Ti2qb9nN99EseMEGT6GNLEpL0XejdRMpOcWlD0 + xg22t1lNgauWWF4E1HVI9FmODAzD4JVX36BYKlmlUulSsZD366DeRGz9tYo/s/ksd7E82Fj7LtYiCkTj + /ITrai5fvU65Uq0HckgN1EjHXVdrUR3vSgVf3d6WiOV7+2gkB7V4H/jgf+kV9O+9j7wH/h4C8Dfa2XcK + /P5rgSAAPYIYqq3AX0EM3xmCJB8HuNE9zLmth7BNf8Y/5D5pF3o3wVt+BPq3QW6W+cwCv3u2xJNjleDC + 3Y0KvqbkECraabaNhs6OdjZtGgaItrW3b/PvIqKu37dyT1OB/SnAgZxS6vtLpXJ68+ZhmY7Lk+ZAVqxs + VG9cXmKUb7WPtY7yNJKBkhHxxZfRv/9+ctMzzCIeoQME4G8M9YXBH5a1qvx4+5z3locRAoDm4K8i4PeL + e/z1Yx39nN60jwpauhqbkYClOvvh0NtEA0h3S7FTZpqyqzi1YNIVM9jZbtYDed0r+Fjhcj0Z+N+wIhaF + fIE3T5/DtMx4PrdwwQsHTnqX5L6Ue14L4OXxzymlHrVte38ymWDLZnkEA/DTcvm2VX6WIIPlTIBW+1gJ + OSgFL7yE/l9/wMKMgL+P+pH/ToG/UeXXiLE55/3uAKL6K5r38bMRV/YYwaivgcm2Ht7cvJ9SJC4FTHZF + CMC0BPCHvhna+0QTMExo65FZk7JTlB04lQuRwO0AeZkKvttR+Qlv4S23taU5e+4CuVwhHY1G7Mzc3DXv + Ep5hMc/eF3LPCWBweBilDAdRpb67WrWNXTu3EotGl1fx74jKv4JR/nZUfv/Ynn8R971/QHZmljnE9XuQ + ILX2ToM/TAAlBPwOQkJbEZ22WaKPg3irbhIU92hgJtXJqc0HKMSSgUffdQXgbT1w9B3Q5RsUnhgmtHUL + UWSnKNuaN3ImnTGDXe0hv/R6qPysQuVXS+8jlUoSiVi8efoclmX1VCuVm6ViYQHx7G+Y+f5WI/ecAEKT + fcwrpb67VC73DA7009vbLX3fWcUovxqVv+Wo3ri8VpXfW6cUfO153Pf+AZnZOeaREfcAqwP/WlV+/29l + BPw24njcRus5+1ykqu86QXGPBjKJNt7YcoBcoq2+Yw9aehsO74bBHdLxOLhUsrFpinZgVyAzRcV2OZWz + aI8Z7G63appA+OKuzh8AKyOH+qYdS5ID0N/fx9jYOGPjk9F4PJ7IzM9dd133Bvegkm895J4TAEhxkIvK + KtjnOM7DkYjF9m1bpI66qQmwVpW/fvmOqvxIm3Ce+xrOe/+QzNwcGVYO/hz1uGGVn3WTzxUE/FUk5rSD + pefsG0Py+/3iHg3kYine2LKfbLKjvpuPD/7N+wXghazX0DQRvon1JOBUITtFxXZ4Y8GkPWayu8MSD/Vt + e/3XGv9vJAf5EI1E6O7u4o1TZ7Adp0sZRtbr83+Bu1zJtx6yIQiga/s2LMcBeQZ/oFwuR3Zu30oiGczp + tpJRfuUqf+PyylT++uUWKv+iZYX+6nM47/tD5ufmySBZH3cL/I0E4E+7XUEyTnZ4x9EK/BNIuM+ftksD + hWiCNzbvZy7dxSJ9w4zAyF7oHpJlp7pqEji1YNIWNdjdEcFQYfyth8q/Aq//EmSg0XR1dVIqlbh46YoR + i8W6Cvn8dLVSmUIUpftKNgQBTN+4Ec4JeEelUt3c1dXJ0FB/LZS8+li+otWovnJ/ACxLDo0qf92yQj/7 + Vez3/SHz8xmyrB7866Xy+068eUT9TyHgj9Ma/NNIszp/2i6AUiTGqU17mW7rqf9Rhdj2w7sk5Bf+QzMS + 8LfxSaCtR9qgZaeoVG3eyJmkoyZ7Oi2ZJmDdVP7G5RX6A0LLhlIMDvRz/sIlMtlcKhqNqszcXAb0Je5R + b7/blQ1BAAB9g8MopUrAkOvqt4Nm185tkit+J0b5VSf6wMrIwOcehX7mWez3/RGzGQH/MAJ+P0q+3uBv + NuL7yz74S0gO6naWnrPP12n94h6Q/P7TI3sY7+gP/aqvkhli7/dtCV3E0HfsqsyM7JOACm2ukbyIth6Z + IyEzRbVqc2rBIBU12eNpAuGLvfQoLx/WqvI3MwH85WQyQSIe59SbZzBMs8exq3PFQj6LKEz3TURgwxDA + ZOAMzKHUD5RKpdTWzZtqOQFNR3l/Heus8jc1AcIq/jImAAr91DNU3/9HzGay5Lh74G9GAP48fEUk1Lgd + Uf+XmrPPdz76+7BNi7NDu7jVNdgAbu+k+7bCwLagiWnDtUetggRcG7JTVCs2bywYJKMme7siNZ/Q6kb1 + 2/X6h23NJmSgob+/l4nJKW7eGovEE/H0QiYz6zjOLSRH6r6QDUMAUOsUNKfgMdu296ZSSbZsHtmAKr+3 + jxYmgP7K01T/4IPMZAX8I6wc/GFZq8ofBn8BMTu2IY6/Vll+fkxrIbwPw+D8wHau944E5x8Gd+8mGNoV + tDFv/LsKgcm260kgfEM0okm09Ug+QXaKarXKqQWDRMRkX2cEM0wa6z3KtyQHtXgZSQ7q7e3h1JtnKFfs + TsM0SguZeb9O6643+Lwd2VAE0D88ghJtNQl8d7VaVXt2bifqTRpxJ1T+pqN8q30spymg0F9+isoHPshM + doE80jP/ToG/1Yjvr/MBnUeqvrYihUatJuzMI+CfD+9XGVzq38KV3i1oVYc+ke5hGNkTTGRCE+CHPy9H + AhAiAdfTBCq8sWAQj5rs8zSBlqN86F6thAzCv7uUyr9oWUnwo6ujg6ptc+7cBRWNxbpLhcJMpVye4R61 + +V6tbCgCmAxSg+eUUt9dLpe7h4YG6O3tCeX+344/YJWj/KoTfWSl/tuvUP7AHzOzsEABAf9+7iz4W9n8 + LkG5mYHM3NNL6wk7C96xzNbtU3G1e4iLA9twa6q9CgDR0S8efytah/vVkUBqCRLoluzB7BR2ucyprEE0 + YrG/KypTCDYD9mpU/iaj+mr9AcpQDA72c+nSVWbn5hPRWMzKzM3Oa62vNLm1G042FAGAmAFak1GKA67r + nsznC/R0d5FuS6OWUPmXGuXrtrlNlb9+udEfAPrJL1H6wz9mJpejgKTUHkBG3majczPwr4fK77/yBP6E + TUjGoab1nH3nEa9/8FuKGx29nO8exjEMb4QPgbmtBzbthUis/ggbnX/N1vvhXNuGYsYjgfjizepIYBq7 + UuZUVgkJdEcx1fo69lZGDov3kYgnSLeleP2N0yhldLuumynkclkkiBJKgdx4suEIoGdoxLfzikqpb8tk + F9KXr16nUq3S3dVJIh5rUfu/slG9qcqvlt/HUuSgv/i3FP/oT5jJ5Skio+0B7+IuBf4FgudwPVR+/3PB + 2zcELWigOfjLyFM62fBboz0jnBneg60dscchsPFTnbBpH8QSLKYnVkkCvmMwvQwJaI8ESpzKKCIRiwPd + EcxaosDqc/tXq/Iv9gfIGo2mr7eX2dlZrl2/acXj8baFbHbGse0xNniG4IYjgKmxW54WoK8rpZ5TSvVV + KpVtN2+NmTdvjRKNRenq7MCqTZ653Ci/cls++PoSKn/dskZ/4W8p/NGfMp0X8G9F1P47Bf7lCKDo/YZG + gL/UhJ1VpJXXWGgfCpjsHODNrYeoJLyqTLsSkIAP/ngqSP+tU//DF7Luzixe72txKyIBzwzMTmGXS7yZ + BdOKcCCsCaxK5a97aFanKYS/4S1blkl/fx9vvnmGYrHcYVlmJTs/5zsEy2xQ2XAEAFImPDiySQPXlVKf + cB1n1HXdY/lCsf3ylWvMzs7T0dFOWzoVVI+1VPkbl9eo8vt/1Rr9hSfJf/BPmc4XKLM0+DUC+jD4VxPq + WwkBlAjA34eo/orW03ZdQYp7wuCfbuvh1LZDlKLe6G55Kr5dEVt/ZDfUMgDDYG5xM1dKBLVkoVYkoIQE + 8DSBUplTWY0ZiXCwJyqawHqq/Kr1PprtE00tZH3mzHkViUZ6yqXSTLlUmkWKKDekbEgCACGBidFbzM1M + V8Zu3nitXCpWTcvqMa1I9/TMbOTylWtUqzbd3Z3EY7G6h3jZ3P4VOfbql8PlvEpr9Oe/SO6Df8Z0oUCF + Owf+laj8IENMFgF7D+KDaDVnn4M8kTeoB/9cqpM3th6iEE8Ff1FAJCq2fveQgFOZUurbdORvtm6FJOBr + AvHlSADITuGUS7yZ0RiRCAe7Y1hhJ+MaHHtNR/nQNovIQfmPhqKvr4/Tp88yn8nGHdseW8hmKt6lzrIB + ZcMSgC+O1Ai45VIpk52fK1er1dlYLJ5yXLfjxs1R4+atMeLxGJ2dHViW76haq2OP5stKoVyN+9nPs/DH + f14D/3buHPhXQgAVJNZvI2G+LSw9bdcNpLjH904pIBtL8saWg+SS7Q2qvYZoEnY/JLMVl/LgVIQAGqcv + h+bLtQvZ5AvNSKCwHAl0y+fsNE65xKl5F2VFONQb1gTCt3X1jr3lVP7Fy0IAruvy3HMvMjc772Qz868W + crkFJKx9nrvY6mulsuEJICTTWutLxUI+m83MzyjDKEZjse58vpC8dPka8/MZOjs7SIfMgnXN7VcK5bq4 + n/kc2T/5C6aLRaoI+PexMvCHZT1Ufr+4J4uAvx3RRFpV9jnAKGL3h8GfsyK80TlAJp6WkV6FjsaKwtZD + kuwTT4spUCqIym5a8mq4ljR8rJOVEIHTjAR0iASMEAl4msC8g7aiHO6JYRlqGSCzmAxajOqhbyxLDspQ + ZLILPPm3T5HP5yvzs9MvlIrFLFJxPY9Mmbih5H4iAPC6ULuOc2shk8kV8vmpSDRqmKbVMzU1Y126fA3H + dujp7iQWj9V3nL5dlR9hduU6OJ/+HNk//csa+Hew9MifY/XgX8mI7y/74K8iswdtRVJ9l6vsqxI8u0XT + 4lTnALPRhLTqUoYX2kMq+zbtE/BrZMRPtMn3ykVJ2TUt2cY/wvXSBpzlNAGPBJRRI4HTczauFeVwbwxL + GWt27NW+sQQ5EFo2DIPJiWm+8tSzlMvl/MzU5AvVSqXkPSJdSJ7VhnII3m8EAPIszwDnq5XKTHZuLmPb + 1blYPJ62Hbfj2vWb6uboOIl4nK7ODswgY2QJlX8pE0CB6+B88rNk/uwvmS6WsJFpsvYTdNBpBGmOIKU2 + LOuh8vvx/AVE/U8i4PcnEGmW6DOFuKMrhJ7dWIwLPUOMRkKJONWyAD0Wl/Te/q3eRfGOwrQgkRYCqBTB + ccCKCBDrbPCQ3BUSmMYpFXlzzsaxYkICdSHCO6Dy++D3xDAMrl69wVefewG7Wp2bmZh4yXEcf/ZgA+kg + 3Njc6Z7K/UgAvlSBm1rry8V8PruQycwYnlmQy+UTFy9dJTOfobOrk3RKzIKlRnloRg4e+D/xaeb+/ENM + l0o4CPj3UQ/+MFCbgX+9VP4w+MsI6LcSTBrabMLOGUQTKYXOVkWjpB85SWTbFibmFrBtJwB6tQwD22X0 + r7PRvXczAokUlAtQKYkm4JNA3XfXwSRYMQmYkJ3CLRc5PVvFNqMc7o0T8TMY74DK30gGhmHw5pmzvPra + KaqVytj05PgbWte6pWSBF3mgAay75ICLjuOMLmTmF4qF/FQ0GjMN0+yemJy2Ll++itYuvT3dRCJRoLkJ + sMg5aHjg/5tPMfsXH2a2VMZGpsZeCfizBM/Heqj8jSm+JUTd34qo/60m7JxHwF8IHY+KWCRPHCO2eycd + qQTJWJSJuQVxuCoFyQ5J8kmk66v2CO3EikoufzkPlbLkCViRBkCvk0ngVFZAAl2SrZiZwi2XOD1boWLG + ONIXJxKqIFrxKL8UOajm+1BK8dJLr3Hu3AXK5dKV2empc96XDEQJe4UN5gj8eiAACPpXXKiUy7OZudl5 + x7HnY7F4W9V22q9eu6mmpmcYGugnlUqyrNffUGA72B//JDN/8VfMlss4wG7WH/yrsfnD4I8g3v5Wc/aF + K/vCnYUwTZJHDhPfv7cGsM50glg0wsRcFjfRBh29kn7rgy4Sb04CkZgQRTEnWoN2vboAHy3rZRKolZFA + 2iOBrEcCM2UqVpQjfQmiplH3/TX5A8LfCJGB1ppnn/0a12/coljIn83MzV0NPWw3gVMNj8E9l68XAvCl + AtzQWl8p5PMLC5n5adM0K9FYrG9ubj42OjbByPCQRApYwh9gO9gf+wTTH/pr5splXAT8e1k5+Fej8q/U + DMgjmX4mEufvYuk5+xrJCMMgcegAiUMH6uv2UfS0pegdGmKsGsV2vY3sKpQWxPFnxfyv1r9H4gLIYg7s + soQQzUZNgJWRQO0mNPmSUhKBWC5PIN0tfgrPHDgzXaJsxjjSlyBi+SHCFTj2YHVkoBS2bfO3X3qGqalp + nctmX89ls+OhB+wi4obZUPL1RgC++GbBWHZ+fsGx7VwynRrO5Yup6elZdm7fQjweY5EJ4IG/+tG/YfrD + f81cuYKLTNq+XuBfrcofzu8veMcwgiT7tKrpLyJq/zzhZ1gR37eHxLEjqLrSXQVas2XLZr73O78VKxrl + 9NVRXFfL9ahWoJSTHAArGmwWlmhc/lZcENJoRQLNtl2tNrAiEujySGAat1LizHSRkhHlaF+SqLlCx96S + Xv8m2xiKfL7Ak08+RSaTdTJzsy9604f533wT0QI2lHy9EgAIFqaAC8VCYcKx7Uo63bZ3YSGX0MCO7Vsl + vOffXGVA1ab60Y8z+eGPMFepoBHgryf4b4cACgTTgQ0jab5Lzdl3EXH8hWEU27WT5EPHUN5kqrVRTmuG + hod47PFHaW9Ps3/zAOWqzdnr43IMSol6Xy5Aql2ADU1IICGgK3kkAA05AqyfSbBSTcCKQHYSt1zi7HSR + ohHh6EBKSKBhlDcMCRvajo3rupiGuWjq8kavvwqRgWEYzM7O8eSXnqJYLBVnp6dfqJRLvutFI/b/eswh + uK7y9UwAvlSA66Vi4fVkOq1j8cSj8/MZa8f2rbS3p+UbyoBqlcpff4zJv/oYmdsAf1jWS+UHGc39p2jA + e2mag7+MJPlMUY+p6LYtpB5+CBWL4bfwVojN2tffx+NveYyO9na0lhmZD2wbIlsoceGmV8imFFSL4vFP + dQTNPxojBLGUeONLOQGpUotJIPz9pZZr61sQQau04fBXfRLITIkmMFUgr6IcG0gRMwPHndaay5ev8YUn + v8IXvvBlvva1l7h0+QrVapX29jZPW2TRqB9eNgyD0dFxnnr6q1TKlYWZyckXbbvqR12rSAQgs7JH9u7J + NwIBAHDg6PGcaVovWpHIo5VKdWdXZwdbt25Co1DVKpW/+ijjH/kYmUoVjcT493rbNgPmSsF/uyq/RgDt + 9+XrQ0p7oXmGnz9nX2OqWWRkmNRjD2MkEt6PBODv7unmibc8TndXFzqUNRW1LA5uG2Iqk+PK6HTgiKsU + RRtIdYTSgBtIIJ6S91JeQKqM1iTQbN1qtIFmJND41RAJ6GqZs1N5ckQ4Npgibpnk8gX+5hOf5UMf/hhv + nj7L5OQUk1PT+srV6+qVV9/gwoVLJBIJBgb6PI2gRQjQNLhw8RJfe/5l7Gp1enpi4lXXdX1vSgF4gbs4 + 7fdK5RuGAIa2bsUyrQqwVWv99nQ6xb69u1F2ldKHP8L4Rz5Otiqq637E7oe1g/92CaBCAP4eRPVXNE/0 + Cc/ZFxZroJ/0449gpNO1iJwP/o6Odp54y2P09fUK+L3SXP+5jsciHNo+zK3peW5MzgYgLHtpwMmOIO4f + so9RKigVLuXku4YBRnjKrxbvtFiG29cEwCOBqJBApcS5qTwLOsruNsVf/9VH+dsvPU25XK6WS6UL2fm5 + 5wq5/Fm0zhmGkZyZnYu//sZp8vk827dtDbQB7zhqJoBSvPb6m7xx6gyVcvnmzNTEqdDBziMawIbrE/gN + QwATt2rtxo5qrb+zp7ebAzu3C/g/+gkW1gD+21H5lzIDKt7vOIinfxOBGdIIfr+452bDcVi9PaSeeAyz + o6MuHK+1Jt2W4vEnHmNwcLAG/no/l0IDqViUA9uGuDo+y9j0fADCUk5Cfsn2Jsk/yLp4SnIDygVp9W0Y + DU1DwxuwNpNgKRLwv57ukqrGzCS6Wub8dJ7Xr4xx48WncSvlwuz01OdvXr38pez83I1cNjM2PztzsVDI + X4pGY0oZRt/ly9fMcqXCwYP7MAyzqT/ga8+/xMVLVyiVihfnZ2Yuer9uIIrZq2zA7kDfMARw4tHHcUXN + fZeGb97U38PW115n7KOfYMGWGZ0OsjLwZ2gd518rAVSRkd9BuvduRm5Sqwk7/Tn7wsdhdnaQevxRrG7p + pBMcqyaRTPDYY4+wafMmNLpu1AfqyEADbakE+7cMcf7mJFNzC/UkAEICYZXYfzcMSSSybaj4JGA2IYEG + uV1twK5IFMInAd1kH+kuCVtmJnErJSYqBtVEu67cOPel8SsXn3eDrD0FUCmX85m52cumaeYTydS2sfEJ + a9PIMJs2Dcu1qx2OVAF++alnuTU6TjGXezObmb8R2tdV4PQKHtO7Lt8wBNA7OISCiFbqPVGtDxy8eAn9 + wgvkqgH4d3vfXQv4V+vkCy/bCPhtpG//ZpYu6x2nvqwXwGhLk37iMaz+flQD+GOxGA8/cpJt27d5a5s1 + 1KxfRkNnW4K9mwc4fW2c2Uw+AGBxQUb7hO9MbfDyG6ZHAmXxH7iOOBDDWkP4+2uKEqjVkcD8JNhViolO + lW8fzOqxi9cpF8J1Ugpwtdb5fG5hLJVu61KGMTI9PcPRIwdJJBLeYcg1K5fLfPHJrzAzM+cuZOZfyecW + poID4xziotlw8g1BAEcfOYmrTBzDOBx3nP/r5OittsGbNyhIrwEOsTrwr7fKrxFA5xENIIWAv9WcfQ7i + 6b9C/WyURjJJ6rFHiA4PoUKz9Wo0kUiEEw8dZ/fuXU1V/kVkEFrWQG9Hmp3DfbxxZZRsrkitbqC4IE6+ + +BIkEE9JunCNBKzWJLDS5bpjD32pukISiIomgF2GZMcgQ7tSjF8Kk8BN4EngKa3165Fo9Hy6re3k3Hym + x7JMDhzYGzSpVYqFhRxf/OJXyOVylfnZmRdLxWL4cXmdxS6aDSHfEATQNbKVQsRq6yqXf+v42Ohbt06M + U/IAcpi1gX8tBOCvC4M/gYC/2Zx9/vIMwYSdteEqHif1yEliWzZT19BDgWVZHDt2lH0H9nk99Qn9fTEZ + 1PfY95OFYKC7nS0DPbx2+Sb5YtnTELTY31ZUwoC1bUI7NS2PBLxQom5BAiupHVhOG1CNJBBrTQKxBMxP + gF1RJNsHGdqZZvzKdcr514CPI9ZV4fCJh3LtnV0XUCoLvGt0bNzavn0LQ4MDaK0xDIOpqWme/NJTlEvl + wuzUlF8GrLzb9hLScX3DydcNARx++CQDI8MMDG9Sg8MjamB4RA2MbGJfupN8Iralu1T6rWNjo39/y+SE + WfJU48NIcQ/cPvjXovL78fw8AuYYAv4krcE/j4C/sbIvefIE8ZpqH/xRKcWhwwc5dPgQptHosFveBFDB + V9EoRno7Gerp4NWLNyiWvVi/doQEoonQDMANSDUjXvFQQUKJNU2gAbyhY288l5bLjb9XRwJtQX+Dxu0z + 2lCvAAA7uElEQVRTnfUkkGgbZPN+Rc/I77LtyBjXxJE/OTbmO5AvKKX2VCqVw1evXqe/r5eBgQFM0+Dq + tRs888zXqFYqc9OTEy85jlNFHIAlJAS4IecIuK8J4NBDj7B18yC9Q5vbFepxhXqPgp8Cvs97fU8xHvuB + ZLX6L46NjX7H5skJs+yNjkdoDX5NkEvfmLmxXiq/D/4CAv4oAv40rcHvN5qvq+yzLJLHjxLfszs4yBAW + 9h/Yx7Hjx7x2af7fm4/yrUyAxuWtAz30dKR59cJNytWqbO86ArhYUmzsun17YkUFcOW8ANR1F5NAk3NY + 0XLj7yk8EshKLcNyJJARnwDx1AiDO7rZvP8pTnxHgf/wCfjDf8PmbdtwHLcKnFFKncxkspvefPMs0ViE + bVs3c/78JV586VWqlcr49OTEa6Ey4BxCABuqDNiX+44Admzfw6ZdOxkYGokaigOONn4S+HWt9S9qrd+O + DOxHtOaohmMx1z16YvRm/6bJSVX2Rv6j3D7410Pl98FfRMAfQUJ9bTS39/0qwIs0r+xLHPDq9ut0edi1 + excPnTxBJBKRH20c5YHV+gPE4a/YOdxHOhnntUs3qPq9BFxbioL81mJ1+/TEioqWUPZ6C2qPBFohei3a + wKpIIAnz41CtKFznCK47Qiz+FG88V+AH/k9GP/BbDAwPA2oKeFIpNVQql/eePn3OKBSKzM7OcenyVSql + 0rXZqcmz3p4NpEr1JTZYGXDtdtzrA1ipHH7oYUAbShkjwNtQfK+Gt2rXHVBKqbZ0mi1bRhgaGkAmawAn + n8f49GfpmJioqcxHkYYecHvgX6vK77+KyJBgIhl+7TQHvq8lXKJ+LgEMg8T+fSQO7ieYO9v7TQ3bt2/j + 5MkTxKLRINEnvP0yo/yi5dA6kN393ScOUyhXeP8nn6ZctWVluQDjF2F4j4DOD1H4iQwG4g/oGYHpG17d + QNGbZMSoRR5o/F29imX/AP2/FXNw6yyM7JOwZbNt+7bI54svQbWkQP842jVItP0CV09N8oLm9YcVR04+ + CujLCn5Wa325Wqn8wmc/92Q8EomglKJqVzOhM8W7bRsuAciXDa8BHD35KAPDwyiljiilfg34dUTNPxSP + RdObNw2rRx4+wTe/7QkeOnGE7du2sGXrZrb2dpP+ylM4L72MP/IfY/XgX68RP6z2l72XgYC/m9bgLyL5 + /fPUj9LxPbtJHj+Ksuo5XGvN5s2befTxR0gmEi0TfVYF/prmEC6gURiGYv+WIVytOXUlVEFoVyQVONEm + abj+lQiH+yJx+VspJzkCEEw/1hgWDG+70uXwuTbVBHTDtko0gXhKfALVikK7h9DOFiLxp3jx2Tzf+/NM + /Ol/YGL0FkqpcjYz/5zWbsKyIke01jGAhWzm9Vw2M+ZfNYS7z6/kWb8XsuEJYGB4k/+xG/hx4GGttdnZ + 2cF3veud/J1vepzt27aQTiVRykCjcPN5pj7wx4x99guUXBcDOM7KwD9PfZx/PVV+jQDf10YGkTRf/++N + GX4VBPyz1D/fsZ07SJ08gYpGCT/IWmuGhoZ4/IlHSafTixN9VuT1l/9WumyaBge3DVOoVDl7bcw7GuXF + /ksCOL8WoDFhKJqUFOFGEmgczcNyuyaBQpyPxYUlzAGfBNJiDtgVhXYP4jrbiMSeYm4ix2c/Cf/Pb5Jb + yFKtVqqz01OvA5VYLL7HMM1UZnb2pUI+H75lZ9jAMwVveAKYGL3F4OatoN1p4LNATCl1tFqtRhzHZdPw + IKlUQiJfhkLn80z94R8z/oUnKXvgP0EAfl8j1aHPS4F/vVR+jQDa9wT103zCTv9zFUnymW64HtEtm0k9 + +jBGvH4U0xr6+vp44i2P0dHRUQPi8qN643K4bfbKNIWIZXJo+zBzuQIXbkwEf6x6xUOJ9vrpw8MkEEtK + 1mAp75GA8pqVtIgINFu3YhJQAQkkl/EJxNMw55MAB3Hd7ViRp/jcMzm+/WfhmQ/hOg5KqXw+t/CybVfH + LSsylM1krlfKJb96WyMpwBt2fsANTwAAE7duMCFThxeAvwUmtNYPTU1Nt12/cYuuzk66e7rRuTwTH/gg + 41/8EmXXxSQAf3gUDgO2EfzrrfL7v1tFRn6NTNM94H23FfivI228wxIZHiL92CMYqWQQ60c+dnd1SWVf + T3fg7/O/cDsqP/UhwOWm3Y5FLA7vGGFiboHLo1NB/kClKAVBifZQF6ImJICS+QZcz5fQ9LvrZBKslASS + bT4JAPoA2t2OaT5NdmaBd/83+OR/97eqlIrFN/O5hfPlYrFTa+2rPDZSBDTPBpX7ggB8mRi9hWGYzvTE + +Kuu45QikchDhWIpfenKdeJ2FT79WSae/DIVb+Q/yerBv94qv6Ye/F2I3e9niDSr7LtJk8q+/j7STzyK + 2dYWAr9Ca+hob+OJtzxG/0A/OpxLcwdU/mC5vqGGRpGMRTm0Y4Qbk7PcmGisIHQaiodU/YH6FYTlgoQU + lQrqBu6ESbASEkh2eCQw5pEA+9F6J4b5NNdPL/DWH4IXPulv5TqOc01rPeXd4hTiv33ee9+Qcl8RAEAu + m6FaKevM/NxFu1qZisYT2yLVam/6qaeVceY0ZVdjIuDfwerBv54qv0YAXfaOoRMp622csy9s948iBT7h + Z97q6Sb9lscwOzvrwI/WpFMpHn/iUYZGhtGh3P/bVflvjxxU7RqmE3EObR/h4q2phgrCvIT8Em3UVxCG + VIFaBaGXMqyMht6FtAD0Kpf9310xCbSLJlAtg1L70Ho3hnqaYj7L4z8IL306vOU0osD1erf6RcT625By + 3xEA4DevKJaKxdf68/n5h+dn3zaUySTLWmMBDyPgbwR+M/DX9snaRvywuu9/dpCR30HCfMPeBW8F/nHq + J+wEMDs6pLinp2cR+OOJOI8+9ghbtm6BOvCvwyi/jMrfah9o6EglOLB9mDPXxppUEKqgeChsB/g+h3ha + TIZKKSCBxnz/9TQJ/AKiZUmgQxyDlRIotRf0XpTxDOV8hofeBa99IbxlDinVyCOcvuHKgH25Lwngd4C3 + AW+H/v3V6s8nK5WTFVAm8AgyX99S4PcbZsLawO6va/ZbYfCnkUae4Tn7Gt8nkaYedZV96TTpJx4lMtAP + 4UpVrYnGojz8yEl27NgebLDcKA9r8AcsMc1WAzlooKc9xd7Ng7xx5RZzdRWEuaBAyP8BFXpXRjAHYbUk + 2YLKqNca1tMkqPUYXAEJpDrEHBBNYDeogyjjWZzqHEffCW88Gd6yjHD6hkwA8uW+I4DfoqZSb3bgv9vw + gxVQFsuDv4CAf85bvhMqf7g/n4Pk9Y9QX9nX+D6DgL++si8hlX0jw4T7+KGDyr49e/fcxqi+Qsfekvus + 99A367GPhr7uNnYO9/HqpZvNKwj94iFC2ylE7fcrCO0QCdR5Dhd/bLluXUmgU0igUgZl7ERxBKW+hutM + c+Qd8Mbfcj/JfUUA/4baxJY7XPifDvzdMpLO+BjLg/8czcG/Xip/ONHHRir6RpAin2Yqv+sdzxUaKvti + Mans27bF+9FQ3N0yOXLsCAcO7scITcCx7qP8Uiq/ogUZ1O9Daxju7WTLQA8vX7hOvhCuIFyQDj3RZGj7 + 0PEbphBEpeTNN+DWhwcJHfx6mAQrJoH2gARkMtVtoB5CGc/jOpMcfQe88SXuF7lvCCAE/r0aft+Gd5YR + tfoxYBvLgz9cj7neKn8j+GMI+BO0Bn8GAX9dZV8kQurkcWI7d9TW1v5mKA4dOsiRo4cxTGMJlX89QoD1 + WX9LzqSzBDloYEt/N4M9Hbx8/jqlugrCBW9ikdDkpGFCMS2vgrDo1Q3o5iSwniaBvYRj0JdkO6Q7xTFY + KYJSm1HqEZTxMq4zytG33zckcF8QwL9BRkgDDrvwXhu+qYyo1Y+zOvCvBvDNvtMM9OFYv4OQ0jASB2oG + fH/ariu0qOzbu6cJkGHfvr0cP3EMywoy6+6Oyt+4vPppt3cM9dLVnuLl89eo+HUDriOOwVhSwFb/Qx4J + RKROoOQ1I9Xa8wmEbtK6mgTLRAd8SbRLT4EaCRjDKPUEyngdp3qDI++AU19io8uGJ4BfQ0ZUA0564H/E + nxjzcWRyzKXAf5aV2fy3q/KHwW97F3SYoLKvGfjzCPjrKvsMg+ThgyQOyrRdjc/kzl07OXnyIaLRKL5H + YL1V/rWbAEuTwe5NAyTjMV65cD2Yjdi1JUQYT3kzD2nqdgiyPhL3EoXCJNAC7WslgVYhwsZtaiQwJlqK + Uv0o9VYM8zR29QpH3wGnvsxGlg1NAL+GAMuAt3jgP+aP/G9h5eBfi5MPllb5/UQfj6QYQpp5Ngv1+ZV9 + V2mYs08pEgf2kzh6GMM0G3xpmm3btvLIow8Tj8drWX7+35cc5WFVZNC4vNyo3pQMQmpLs2m29m8dwjQN + Xrt4A8dxBWxOVRKA4mmveCgkPsgjMfEZ+IlCPglQdyLBTWxY1exrSy4vlyfgS6Id0j0w75GAoXpQxt/B + NC/w579xgR/7tQ1NAhuWAH4NqYSLwNtd+F9V2F9GRv63IDPjLgf+sNoPywO+2Xdagd5/+eBXSHFPJ4sr + +3wCKCPgn6ce/PHdu0g+dBwjEnr4leQ7jGwa4fHHHyWZSi4G/4pMgNXH8tdD5a+fPCNYNgyDg9tGsB2H + U5dveZ2aPQdcuSg5AuHiIe8aAdLey4xILwHXCf1N1d/o9TQJqmVvbsSlSKAN2no8TaAAyuhCqbdx6G1X + icXPceCtG5YENiQB/Crwm8C3wLtc+L0q7CojXvW3snrwr7fK76+3CcDfR/2EnY2qfwUJ9c1R/3zFdmwn + 9fBDGNEotTxeD/wDgwM88cRjtLVLDfsddezdAZW/1bJlmhzaOcJCscyZq6PedVfigKv6FYThCUwJSCAW + lwhBqdBAAnU/Ui9r6jikVk4C7b0eCeRBGe0o4204ziim9SYH/47eiCSw4QjgV+H/396ZB8lxX/f98+ue + c3d2d3axABYAcRAnAZCQCAIkQZAUFUu2LDt2VIlScdmVOLHLRxw7rkosV2yX4zhVOVw5ykqVc7kcW1Wx + 5ViWKB6iSEq8QIIACBLX4j52sfc5OzM790x354/Xv52entnFYg8ClOdVzc5Oz/T169/7vvv9CIM6Al+y + 4Y/KsLWAeNOfRtpm3S3zr7TKrxN9dNy+233p3/iZv4xk+E377jW0+QEp7olE8CbxO47Dmu41HD16hHhn + J7VNPldK5fd/Xq7Krxqq/PMdIxgI8Kkdm5lOZXwVhEW3grCtdg0B8GgCLcw1H7Hd1Km6BqMraRJoc2Cx + IDDmgoCKodRzOM4khnGeh5916H2H+4nuKwD4HSAARhF+yoKvlmFjAUmmeYbFM/9yJP5ipL9eiw+kScFa + 9/9GzK+Le/z1oMENPcSOPIHZ2lrH/PF4nKNPP0V3d3ct89+1yr/0RJ+7V/n9nxf2B4AiGg5yYOdmhqeS + 9M1VECKxf6tcXzcAHk3AzR8o5iVHYO67Boy/IiaB1yfQLv6IRhRtg461kjZcyIJSLWB8Bpw0yjjD/mds + Lt4/IHDfAMDvAAaYZfhZG/5LCdYVkFDas0jPvPkYMo8wv5awq6Xye1V/EGffemR+zMf8I9SX9QbWdtP2 + 1JOY7e14dXvHcWhra+Opp5+iZ/36mgU7V1zK343Kv4BUv3t/QBUMHKAlHOLTu7bSPz7NwFii+jst3aOx + esZ2x4RwizB/yQUBXfPvOVNDWo5JsBgQiMSgfa10FipkQBFBGc8ABQzjQ/Y/a90vIHBfAMBvAwYELPgl + C/5jCbqKVJl/E3fH/Hfj5IPFqfxe5neQMF8P1VZ3Xmef/n8cKev15qkEujqJHT1CoLOz5hvHcWhpaeHI + U0/ywAOb3FZegLqzlF8Jlf+uGHmRXv/FOAcNw6BczJMYGeRy/wglPBK/kJMxisaoOdHcCQ2ItEipcbkw + DwhQu4+eBL5NjX7W+PMiNYFIzNUExsV0QIUx1NOgHJRxioefrdwPIHDPAeC3AQUhC37Ngn9bgo4iUkDz + GZbO/Cup8vsdezEk3Oet7PO/TyKqv7e4x2xvp+2pIwTWduNn/khEKvu2bdtaZf5FMvaiVP4FTYDlO/bm + k/LzgYNCYShF76XL/Omf/QXnz54j6pTtjBMoW8qszstCFjA8xUPeG8YDAmVhTI8jteam9IP3b1sqCJQW + CwLrXE1gFlBBlDoKBFHqJPufKXPxGPeS7ikA/BbyaC34DQt+twSxAlI6+xkkoeZOzO9tmbUaKr/fsdeK + ML93zT7/+xTi9PMyvxOJ0PbUkwQ39uDv5hMKhTl8+BA7dm6fx7G3ClJ+USr/SoQAmQccFCdOnebPvvaX + jI6OY1Uqk5npiXeyM1MfWi0dPZiBKscX3ApC3Tmo5nxUv6uUdPcefChA/U7ezUsxCRqBgOP7kVMFgdQE + 5GYBAhjqCVAxlPE++58p3ksQuGcA8FuAglYLfseC3yxBtMjimF87/PySHxYHAPNl880HBJqxowjz+yv7 + vIk+Mwjzeyv7yobBZE8Pa/buwTRrnVrBQICDBz/Nnr27UW7FW73KvxJe/2VI+UWq/GqRYGCYBhcuXOLP + vvZ1UqlZp1jIXxm63ffC9OTEdSubmsauTBHr2ophRueeYiEjSUKhqOcEngNrECgXdPeexr4Dz5XM0XJM + gnLBjQ60zxMdcEEgvl5AIJ8GMFHqMEqtQanj7H+mcK9A4J4AwL8CFLTb8PsV+PUShItIEs1zCJP5JbB+ + RhngIstL770b6a+ZO+xeV5h6e18zfwqJ9Xsr+yzDcAbaO1Qu3sGmTRswPdqtYZgc+NQjPPzIfpTb+eau + GHtFVP4VlvIL+QOUQhmKRCLJn37tLxgbm6BYyF8euHXz5Xwul0RcKopcOonjzBDr3IZhCFc5GgTCsrBn + IxAwA1I3UCpK8RBUpXsj9b9GYDfQLBrsUvdZKQGBTFIiAKFIgwM4UtkYXw+pScilAQyU8SioDSjjOPue + yUnq8Ft8nPSxAsDvI5V7Cjot+A8V+OUSBEsI838GcaxZ1DOlQgpojiNMpsNweo6tpMrvtfsdROJvQDSA + +Zh/1r0ub2WfDYXh1lhqqrW1JR5vZ+OGHndFWYWhDPbt38enHn0E003/vTcqv//zwl7/pav8+tYUr772 + BidOfYhdqUwM3e57IZ/LpcHr/cMgm5wmGBokFt8GSjQBxy0eCkUaFw+BZAqGotVmpDVj6qdFaAfzbVII + KJVLck2pCWHu9m7XVGlgDmgQmHVBwHEMlPoUSm3FUO9hVzIc/FE4/wYfF31sAPDvmSt+WWvDf6rAPy5C + oITE0p9jfuYHka7HkbCaQ7XRpm62pmfPSqj83veAe12tzM/8GYT581TniQPlEcM4NdYRbzNMs33zA5vo + 6upEM9Ceh3Zz8LFHZdkuTXdS+ReU6v7PK+jYW0jlVywABrWfDcNgYGCYv/yr58nlctbM9PRbicmJm9Qy + v3KH8gTZ1NfYsGMIkQ0RUG4FYVaYPBBqzMOBoICE7i1YQ8tg+rltTnXx0UJGTA6toaSnBQRCLQ3294BA + ekprAgrUwyi1E2W8h1VKSyXh23wc9LEAwJ8gjKugx4KvVuCni2CUEeb/DBJPb8T8moknkWQanXuvyaLa + fcddV2ZZKr/3s+leV4x6Z5/+P48wv24Ej+xrjcO7fW3t6UA4fDAajRq7dm4nFAqC47Bj53YOP3GIUNiz + dPVSpPwSpLriDpoCvmPgO4b3F42kfI3KX3sOy7L41vMvcfnKNcqlYt/wQP9btmVZnr0UgvUvA6fYcTBP + pPU84vZ5BhCOtytu8VCLSHxqLlaeQCAk5oLOJ3Co1QKWYhIoDwB5FzMBAYBASKR/tE2ahvj31ycJt0K8 + R8Ail3IjF+ohlNqHUsexKzMc/BE4/yarTR8LADwk47DBbeH15RKoEpI++xwLM79+xZAagPWIVM4z1yAE + EFDQtrfJ3TO9f5uBLNzRTuM4v41oIAP41uwDewpOXQ6HL0ba2z5nGEbb1i0PsKFnHY7jsGXbFp588nEi + 0Wg1GrBKTTuUMjANA2UoLMumXK5QKVdEswmYGDrVdgGV/86OvQVCgJ7Phmlw8eIVnn/hFcrlcnFybOy1 + TDo1TlX6K4TRX0ZW04HECGzc5QAfub85Ko9f1VYQ+ouH9HswLExZzEmOwBzYqgaMWXOTvs3u9kpJHH7a + yQhuGCcC67bB9k/Dlv1SGKQWOqwjvop4D8x6QAB2otQjGMZ7VEozHHiO1U4dXnUA+Ircf5cNf1iGv19C + GFcz/zruzPxeTaAFAQG9qk7G3V9L/jJV6b0U6a/9DWupVvY1Yv4i4u2vKesFJwFneoPBU9F4/HOmYW7t + 6Gjnod27MAMmGzdt5MjRJ4l5039XoWmHUgrDMMlmsly7cZOTJz/knWPvc+zY+xw/8QFnzp6nv38Ax7Hp + 7Iy7DUYaq/wLmQCL1RSUocjl83z9699kaHiEfC57YXRw4KTj1Inc95GltKs0ch027rLd7VHgCWQVUXH0 + lfJ3AIEIBAIuCPjtcnz7zLPNQXIMim5rc5BjmSZ0b4Ydj8KGHfMvfjLfKcJR6NwAswnIzmkCDwJ7sCpv + 4ZAmOQaZGVaLVhUA/qXcd8iC3yvDz5dAVRDmes59Xyzz275XBAGBNoQJi54x1tl6Botnei/zr0EW8Fio + sm+Y+uVeUnDxQiDwbriz67lAILA3Go2wb+8e2ttirFu3jqeePkJHe/tdJvrUgsGdTADDMCkUCpw+fYa/ + +sa3efPNd7l0+Tojo2NMJ2acmUTSmZyapq9/QJ09d5Hx8Um2btlMLNbiuZO7kPILgYMraQ3D4PjxU3z/ + jXewLCs9Njz4aiGf92KnQhInX0MUq1oauU5o4/ZKCPt0CPuJCsb2ud0qRbHHo631xUP6yEG3grCY9z1p + Dy1kElRKUp+gNziOJCZtfRge2CsA5LH/aqoT7wQCoSh09giTaxBA7cSqbOb2hbfYsCPHwEVWi1YNAP4F + c4z4MxUBgJCX+btZmBHnc8p530FMg27EJMh6zq9dP3rM76Tya+pyX/4cAG9l3wj1lX2zcO2CaX4/0Nn1 + VDAYPBAOh9X+fQ/R3d3FmjVdHH36Kbo6O6ku2LncWH4tOBiGgWXZXL58jb/+5ou88da7TE8nnHK5nCoW + Cjeymdlzs6nkmcxs+nyxULilFHmlVMfwyGhwYmKSfXv3EImEV9YfgGgjicQMf/7nf01iZoZMOnVifGSk + l1p2sJEl3/rmm0+HejqwlFFYQz5sYXyxQMCYG4xyUZYZj/hBwMOI4agwZinvbnOqb/OaBMhxy0XPBkec + fA9+WhhXdzr2ax6LBQEH1xzYABlXE8AGw9yLY7fx3jeOE+8pyJoKK0+rAgBvAu8A6+CxvKj+PZZ85jmq + dfONVHw9Jt4wnHd7IzAIuscsIdqAJi8ILCT9NcWplvU2yvKzkNz+Sd/9ZqHvgmG8RmfXY6FQ6FAoFFT7 + 9u5m/fq1dHR0cPTpp1i7tluY38/Yy2zaoQzZe3BwhBdf/C4vv/Iaw8OjWJY1m5lNnxodHHhtYmT4TGpm + 5nZ2dnYil8lMZdKp0eT09HXbtsdbY7Etk1PTEaUM9j60G2WoO0h17g4MlOK7r77BqQ8+olKpjI0M3H69 + XC57o6UGsgjyW9T6d2toeHSUBzeuI4I1GsH6fBmzp+idvqWCOOUirWB4L9LzrpuPzoGAZ3LUkLuPbdXa + +yCMuu0RKQuuMykUNbUIjmeGzW1vAAgO0uegcwNkXU0ARxGK7CXcYjPQe4ZIa5FKmZWmFQeAP0JSYXfA + 7gT8cRYOWIjd/hyNmR+EuTLuvrqIZhxhtiRVvVBbWF6AsN3tXdSDQE06LvMzfzvVst75mH+c+rLePAxf + VOo7lc6u/eFw+EggEDD27N7Fxo09xGIxjh49Qs+GnsbMf7eOPc8+SoljLZGY4fXvv8O3vvUSV6/folwu + F/O5XO/Y8NCrE6MjF0rFYs5zBu+LXDYzHQgEitHW1p0TE5PGrt076F7T5bon7uzYm0/ln5tchsntwUH+ + 8v9J2C85PfVWYmqqj1rHXxFZ9fmOK+iu37gJByNj4sRbKH+uSIBSDQi4VYHhGLUX65HKYXdh1ZLX0mhg + EtiORBu8FF8Pm/e5yT5+qe9ycqkgkjw5JjUAqQmYnRJHnwYeM9DYXAlpEEjKSxkhunoeIdqWY/jqOZRa + cQRYcQD4EhCDeAK+OgGfL1OV/F3Uq90Wok73Ix51zfAZ95VGsv4mEQacdS9aZ157QUAhjFx099XUKCHI + SzH3GhXzM/8kssyLd98ijF9S6qVCvHNHJBJ5xjRNc/eu7WzZsomWlhaePPIEmzc/MMf6d6/y+z8rt2W+ + QTaX5/0TH/BX33iBj86cJ5/PW+VSsW9ybOy10aGBkwVJrqlhUfd/XcBYBHKFXH64Pd7ZU7GsHqUUBx7e + h2GoWsa+C5W/+llRsSp885vesN/tt31hPwM4D5xs8FjqaHxkhPUbNwGMBXC+GKXSVVBByt40glJejhTx + 1A14SYOAbdWr9jWTxfJIeAfauuGBh6Qtmd/OB4npT/TBeJ8wfzYJxYw4H4tZyRnIzggY5F0RFYyAMmsv + M+TTBEyzhXVb91DIDDAzdmUx43Q3tKIA8L8RyR2FX52EX5kBo53GNj9IzOcWwvgZRP/zO/u8qnsJCRJP + ILO3leps1i+FMHSG2sQc32OeIx1V8C7Y6c/vn3bvy6tNlCFxBV6ajcc3RKPRz5qmGdyxfRvbtm0hGo3w + +BOHefDBbbWypaHKv3ivv2EYlCtlLvRe5hvfeIFj754gmUo7VqU8PjM99ebwwO23M+nUuOtd99+6geBn + L3DCfX1g2/aptT0bRsxA4MfS6dnQgUf20dHRNqcF3LXKT9Xx13vxMs9/e8GwXxr4LrVK24K0fuMmBiYn + ZjpaWzcFcZ5uURY5glS8ICAtuXzFQ96L1BWElXoVX1GrujuOqPub9rgmhGcGKSXHmLwNI9fEkWdrF7RX + 5fcMou5fkJkRcNAt0b0TMxRxqwjHBCxaOuJ0bVhH/4Vz7H1qlInbix2uO9KKAsDfBtrh02X4ryOS7suT + 1HfvBZHqlxBpPx/DWzJcyu8TqCCdf2aRKEDAdwwDiRelqM0V8FMEYX5d1tsoyy+BOP28+WQVSF+HlxId + HR0tLa2fV0qFu7vXsG3bZsLhEIcOP8aeh3ZjGAaGqqrGSt2lCeD+YxgKHOjrv83z336F7776BmPjE1iV + Smo2lTw+MnD79ZnpqX5Xuvp7YxkIXvYCrwAfIsrMLFA4cOjxkmmaQ0qpZwuFwra1a7vZtXN7nVZ8Z5W/ + 9j5zuTx/8fW/vlPY7wRw4W7m2PjIMLt37QaxFn8yiN0WdirWrBMo2sqoplUWs6Jmz1c8pAGiUmJB2zoY + dkN8bdXZqx9QuQjDl2FqUBi/zvHnuH+U166r/q6UkxBgMOwuj+45bzgqIDU5KNe3ftt6KqUy59+45E7t + FaEVA4D/KbdnOvC7efihMYTxD1LrhHMQyfweAvshqsxWhvIMjA7Axetw7hb0jsKNWZhwwDKFrwPe/PtZ + xHlnUgsCAfeVorHOFEZSfPWCnY2YP4mE+3yZh9lb8Mp4W3uwtTX2o0pJnnqpVGRiYopcoUwmX6C/f5DR + sXGSyRS5Ql5aYDsiGU3TxDRMDEO5TjeFj5cAqRdQhmJiYopXX3uD5194hVu3+qlUKvlcNnNudGjwu5Nj + o5cq5XIRXUhTJeXexi0kvHai0cTpXr8ewwgUgfWO43xeoXjssU9jBkzPgRbpD3DJMAyOv3+K733/7YXC + fmPudRW5S1q/cRNKqUlgN/CYnZ99PzExftJpjW/GMKUax3EkY88MVgt0asMZbgVhVEKJVgP/o1LQ/YB4 + /WueDZKDMHRJ+v/p7ZIpWCKXGmZ6uJexvnNM9PcyM3aTQnYKpRwCwZa5DCylxHSYHIKuDVXzQlNLhwDZ + zCjEugK0d8W5dSZDpdRHbdBryRRY/iGqZMMBBX/HbefNw1SlsxcAriKMpX0CNjhTMPARnDgP/SnBCO9Q + qCiEdsCmfXC4S5YHM23EHDCAvVRnvH7FEaej32sfQmz+hZg/7V6jt7LPhsJteP2WUtdaFPvLpVKvYRjt + yjDaHNuOhiJRI1cotp4/fzEgz1dhmibBYJBoNEIs1kpHexudnXG6OuN0dnXSGe+gvb2N1pYWwpEwwWAA + wzBRCtLpWU6d+oh33n2f8fFJHMeplAqFm1OTEyeS01O3bdu2qVdwNN6OIbb1JRrF1l0yDBPHsZRSxhqA + fKFApVImHA65eSm1h/bzkB8cDMNgejrB66+/RblcIZNOnUnNzIz5rtMCTrFESXb+9CkOHHrcAv4vsD6d + Sv2BNTZ0BJRiw84fxwzI+uO2BYlhSc7RqbkG4uADGSYjIOr2zLhU9c2RA62dktVn22C4s9dGdNKR6zA9 + IslAtgIcm9mZWwxePsnItUEKWU/igDtUkViYrfs3s/PQk3Su3w4Y2LYUEQ1chN2Pi2ai9zIM2LIPJm4L + EHRteJAdjx2m9+1J4HmET5ZFKwIA/4O5hTG+5EBPAannX0e96p8Bbrj/66W0BqH32/DaRDWxzu+8Ig/l + Xui7CcNPwOEH4RklzUQYRvrz6R4CmpkdxLOvE4X0Da+lcVmv/j+LdPPxJhfZUBqCN6/COcdxyKTT54Bz + SqmAYRiBUDhyNtoaS0+Nj/29QCCwMRgKdQSCwQ7TDLSVSqXWXC4XTSRmQrhal2TrGQSDQSKRMLHWVtrb + Y8Tjcdas6SQcDnP23AX6+gawLNuuVEojyenpk1Pj41crlXklvkIUl4/c14K29cHHn6QiGHIU+NlgMMhn + P3OU1tYYOE6dlMcPBj7oUe6Gt98+zsDQMJZVGZsYG/2IWoNCh/1WIrvlhFLqF8eGhyaBHsZutWEGXmX9 + g1+c6yVgVWB6SBirpb06UnNUEa98fK2AgPYJmCEBBp3/7yYfYipITsFEfzWbE7vM+NAJrrx/nPxszvNs + akeokClx9eQNhq4O88RPfJaNOw9RKYnJNt4HG3cJ4OC4drAtILRuK6TGwTDD7Dy4l4vHbuLYjwHvLncA + VwQAXDHU6cCPaEbfRtVB5wUAbXwqBACmYOhFeH1CNjeyX3WGbwmw81B4B94rgr0DfggIVJAZ1Ultpx4b + kfJdiBPPRJg/QpXh/dI/hzC/N1DtQGUMjl2G014XEIDjOJZlWSfzueyJ2zev/zBSG3QbUEop0wwEAsFg + KBIKh1pCoXBbMBxuDwk4xM1AoL1cKrXm8/mWZDIVYtitZ/L4CizLSqSTM6cnx8bOFwt5PUaNximHMNUp + RDG6o7dYmJ924Cu2ba87ePBTHD58UHZdhKPP+9kwDZRS3Lhxi7ePHcexbSuVSJzKZ7NJah1/BSTlt8Ay + 6PzpUyAY7ergnAP2MHL9IsFwme7NX3TvTZh6egjUZrfdOLUeXZCagY61kJyQ38fiYpvbloCHdi6VLRi/ + Jfa/GQDLsZkaOs7Fd9/BKs/ng6mZw2STBU6+8Aaf+akuAuGdkqCUg+lhiHVVR0pHG9ZtleiBbUFnzzbW + bu5g4vZh4Dr1PWfvilYEANyZ9pADe3TbLL/0169JhNkMdzSuwdkxUQX9JaFauF9HeHLW3RayofMsnO2E + UAd8VnfimUScev5Igk4XjiFe//laeRXcE3oX7ATsCTjRC+9b1bID73VeQCqVPwvs8X7vOI5TKZdLlXK5 + mM9lU4g/EQQcDNM0A4FgMBwMhVtC4XAsVAWHjkAg0F4qFicmx8Y+zMymdeezRpOrLMPICQR4/PWvDemR + xw7rf7/sOM6PdHbG+eIXPkc0GsHWvfbvoPJrLaZcLjMwOMSZsxc4cfI0MzNJyqVi3+T42KUG43UJweuV + pgFgEMfZyPC136N7ywfg/Ft55ErU++kh6N7iJgvhMQVcCkWgo1vCby0d4oLWRpYBOEpi/KlJV/pbkE1d + 4+rJ4y7z+++1gpSMXHOnVgbdXyabjDNxu8DaLdIN33EgPSnORMOs6kyOLaDQ0i7NT0PROBt3r2fidgp4 + DHHsLjk0uGIaAHDAgQ4bkcQ6YOJ9VaitnHPkAtobDFwaUW8uIPzop5ExuPjTMGTBtyzYXEFEgQ43+qMC + C8X5dVB8mNqyXsQ3cfoCvFOpLgLkvc6rSBJLETgD3ESskThyX20I5oTdsdYVywIOQuVCPj9LVZIBGKZp + BmzbrjiO4+BXJavyYRCx869QbY2wKHLV9SDw40Do6FNPsGP71jnmX0jlNwwDx4FUKsXlK9c5ffoMV65e + J52exXEcx7btxNTExPFyqZSnVvqn3OtdFEjdJZWQCMcVysWrKPpwaEcaUEkZcSnvgsBmiQDU3J/LQ6Go + xOdN07X93a9t9xaSrq/ADEDZyjN05X2KuQL1AmwKmcOX8Ws7P/nrkM8Mo4wfwnGqJZmFjFQ5+tdCCIbF + EZlNghEwWbt5AzL3HkKKpPxurkXTsgHgD5kDyT06XNdG40Ici/pZuhEeeQDOD8mA6Vj1iwhqzks/D7TD + mQK8asPPay2gSH1EQGsc88X5S4honvWdYwbOXYA3SrW+QKjasd/x7OaXagHE39iCKEXt1INDKwIOQTzg + AGBJSA/qQQckOnkaUXuXmCTuAMRAbQkEAuzatR3DNLEsq7HX35AwX7FYYnBwmI/OnOfsuQuMjo5TLpcB + iuVScTiTTl+eSUzf8Kn+mj5CrLHVoivV23NKwB+44/xr6DLiYlZU7e7NIvH9poCBJOdo5rcd1wEIWLaE + 7bRZkE8PMDk4TD3zDwIvUQvqVSrmwTA3Af+o5vlWyuKzCIT0PcihDSWVhpkZVyOIr8EwDGy7A4mE3DsA + cMWTYcMmDQAB5i/o8VMYOg/C0Un4TlEY7X3uwPwwZ1DZwFs2/BPLbTBSkmPOW8nXiPlHqXdHp+HSBXg9 + X+sOQJ4Ig0jdenKBS9RLB+aobV4M1WTGCPXg0EEVHCIIOATca8ggWtEHDY65FOpyHGdtJBymM96B4zhz + jjyo2vaObZNIzHDx0hVOnz7L9Ru3mM1kwXFs27IS+VzuRmomcTmdnBmtVCrad+oHrjGqdf2rRdUpdvo7 + cOiLOeDfuOP5c2hPXiEj0YE1D0g3X//ErMbwq/4CQ1UTh2xbHm060Y9VdhewnttzAhFgjW3zL/wi7vP8 + VeDRuu8d2y05dhOIHBsc0y13duTcoWgbwUiAYs4CdiB+nyWlCS8bANynHLChzevsa1R8o+Y54Xp45CjM + HIPXy2Lz35GeB35M/r2uYLYFOjpYmPH97xX3Kc34jp2BGxfgu5k6iwADmcgvsQzUdU+fd1/+0xsI02tw + aENAoQXRMvzLDSyRFEAPOJ2tsRba29uq3yjJQcgXCty+PciHH53j/PmLjE9MUqlUwHHypVJxcDaVvpxM + TN8q5HNpx3G0tdVokT6bZYT9lkwCAmnEDIgBPzX3XS4NagTWbHLjMn73ru+J2C4ztrSLpC5mLXIpPwiX + kTq4BZjfMUH9HPBP685kBuRktscJq/0AUNVKlBEkEDQoojPt4yxxPi4bALSPxJutV6Fe8uvhjTY4hoLA + dngmBMFr8F4YJoJIkngj+pJ71yEIptyAgzayvdexEPNbCFQnfMfOwUAvfCdV1+tjzq57idVVY7VLosjq + M8xmx3FaOjo6aG1tcUuKLSYnp+m9eJnTH57l1q1+stkciFUync9mriUTiSuzqdS4ZVW0aaTdZF7SsjOJ + OP5Wr6h9QboE7JtGKtRjSMKqUDYpsfbODQjm6it3GpsGji0OulhczIf2tXGmh0OUiyUERvoQ27yW/u5X + pGswdID6ZeA3EWCvpVBUrkdrAHpIlSPah2OLI1L+aGqhcbrLomjZAODa15YNGc14OgOikfrfQePUXAOC + m+GZHvjDIPxnBd9/AiYU2GNI1p7nmnscOFKEL0fgc3owDc81LaT66+KeKWrdpwUYvQQvJyT932/XpRCb + f2C5Y3av6eHHDul/H3Qcx+ju7sKybC70XuLDD89xofcyU1PTWJaF4zjZUrFwezaVupxMTPe7DkvXOG0o + 7XWobxhxgN2gmvH98dPpfnj8YbDtUcQX0Ar8rbnvZxNiz3f2UMMOc6FCn4PdXbuBUNRk24HPs3bLLiYH + LjLRP0B+9jqOXaJ7i9QGfOEXwHEU2dQalHoa+CX33MGG1xp18xTmlCn33XHE8ajzvirlEpWyHk8TiXQv + iVZEAyhJmu6oBoAM1Rx8vxkQd+++kcGigJDYRX+CqPangas9oiYHkCjfQ8ABRPLPrcnkRhTqPP2NgGAa + AQDvoy3B5BV4aUJUfD/zZ5Fwyw1+AEgpg1jQIVNWDxqGwejIGF/9b/+Lvv7b5PMFgIpVqUxmM5mrqZnp + q7Pp9KRtWfqRNrLv9bAn3DG6TDWR8t7TqZfg8I+B4/QDvwL8KdJaTGh2WiRvxzpqWKIu9mJIx2HdzsAw + QrSv2U1b5042701hmHswA2eAMQ58tgS0o9QuJFy3FzHrGpNpQltXbSGSvgDLkWpC28JdFj1LuVjx/Ci2 + 1KFZNgB8Bfh3gA3XvDn6OUQ38ZsBbYi+MkpjTcClELDffS2KFNXQ40Kq/wyi+vsq+2auwcsjYl83alH9 + GrpR5Q8AKSBTVhFgq1KKvv4BHKF0sZAfSCeTl1IziYFioZD17DKftNe5Uzq+P1/5xb2lD16GQz8KqCvA + LyMgcAAQpktNCoO3r6XOAajJQNT0vCfwIlFag2C4E/iC+7o7chxoiUu68pz6r7UAR2oVcmk3L8GG2cQ0 + tuVNAw/e9TldWsk8gHMOzNrQVkakbJR6ADAQ0T3NEt2W85BJFXDmY/4UIt59lX2zN+GVAWlJ4Gf+EvAG + Em77gSF31rQ5olEVlFJnlFLPD/bdqqRmEp22bXulvX9XneAyjThsL7vDuvLtalaaTr8Cj/842PYZxAn3 + f4BdgAsCE6IJxNZU9/H7A0IR0QJWsjuPacL6bXJc2xYpr30Bhpt8VMy65cdli+khvei0J1N9abQiAOCm + QF224YoNh3XrrLVUY/JeEOhGQGBR7v5FUhuNy3r1/zrTxsv8FuT64NVbEnZslMX1NmKG3H8SbRnk3kwW + +A2grJQ6d+6Dk7PAP0CstEbSXu8zgEj7PsTa+2SNzamX4NAXAec9UP8M+GNgMyDMNzMumkBrZ/3d44gT + MNouZsNK0ZrN4oPQzI/hevwNSQxKjIgT0DChVEgxetOvQC85rXrFNIAyTJvwigOHdVLOKLK8d6OIwDZE + tx5agfNHEQCYz+7PuNfixWwbigPwvRvinfZLOgtJ7z3BvXJerSK5efQ54HXP5lbER+s1QHXJxiQCklcQ + C6qy2HPdlyThQXB4DcU/B/47og2JnT0z5hYPdcjv/aZApEVqAZbdqNORtQE27gSUR/3H/axEK0lPMVea + OTN2i+kRb4RKF68uiVakH8DbyLItQMKGn7Ch3ULERRf14Tmtu3QgnDZLrT5zNxR1z6G9UI2Ke0aorexz + oDwMb16GD+cRX6eQJpX3v1q7ctQJPI7kUYE8lqvAMSS2fc3d9oMBiCPXYdMuUFxF4vbPoaPUji3FOXph + kRpyE3RCEbdp6DKmSOcGaTNWs6qwBwAqRRi+Ip2DpPtQgasn3iAxmvD8sIykVyeXcgkr1hDEXbJlsiwZ + gUd0OFCv/Qf1WoCiGhXIsXD3Hi857oW3IbNWp/n6mT+PSH7fmn3WGBzrhfftxurrWeB7LKFRxSecuoCd + iG1/GvF9fIQwxw8mEMqiIyDdktLIKnXC8bYttQPBiGf5MQ8pw13/z5DmIDXSewFyHGH4tVth/YMuwOhO + Q17p78DYDVcbcb9LjF3i/JsfeNY7VEjk5X2WGHFZMQB4F3hcLrvPhs/b0K11Ey3tvVqAVxuIUV2Cq0B9 + T/+5saPq7OtCdFZP+7C64p5R6lL57Ek4eQGOzVPccwnpUbfsRgufQMojDr2PkKKmLJ80+34pJCDgoNQZ + ZE48jTaN7Yqo+uGoZ+UhqGntFYrI9477+0ZAoEN7hgnta2D9duk/oIt+amaha3lNDwkA6OOVS7NcevdV + kuMpzx4GMmd7l3r7K9oT8AmgJBIk58APWxDUobcAIrEbgYCuH2h3X15nno4chKlKfP2bRoyvmX+MudWI + 5x7DNHx0vnFxj0J8ki+z5OKaTzxp/P1k2/dLoeryY6cRhfQIIO16rYrE/UNR8db7+wsqJRpCpFUqDDVQ + 2Hr2uiDRtkYKkOJu6y9qD1N9V9ICbOiynFu224xce5erJ/3l1SXEAl+yR3JFAeAEc9kVVyxYZ7sOQbfx + xxwI2PO8dDJPDGH0uOfVgUh8L+M3Yv4CVeb3UhIunIfXCo2Le/qRFN/kSo5Hkz5BJCBgIfZ0B3AIHQ2x + ygICukx4jtxppPUkDQQt7urAsS5pMtKxTqIKwXBVzW9U46kQ5h/o9bQnU5CauMS5N9+iUvJqrQYSiTnO + MsqrV3xdgFPAoyJFPrRgnw27LKquZBAJPp8moBnam2s61x2HhZN8coja728gkIEb5+E78xT3DAMvsDLV + dU36JJOAgHaqbQMemftOr0ZshqSC0Et1XVOUaAKBoKj9db3T3D81BT8OTA64zO+6rJWC/Owgve+8TCbh + U2gpIb6qZXUEWpWlwQ4AtjDbKQsetWCr1gQmEBHsVeP9UrwRICz0XkFE9xj1nju3uOelpPzEz/zjCPM3 + rttu0t88EqdgAVFodyFdnoRsSxJywJXmnnSJhfx/80l70Mk9MHIVhq5KubF2+hVy41w98SJTQ5PUz90L + rECYelUA4AzwKWTxDAdOWPCIDVt1Ce404rqMILb9nbSBher5cwgXT1GvB+Xgdi+8NC1f+x/DDFK3Pbga + Y9CkTyhVIwOziG97B9J0Q+aPYwsIlIui8psBGnB19Xi1nVWr79rZl52B/vPS+dexq9uLuTFunH6R8f4R + 6ufuJFKbsmx/1aqtDnwW2AdYwnzHKrDThl2aiWcRdb1ItV+WHwjmk/g6xDeFiO4GPcOcNFy5UK3s8w/g + LGLz31yt+2/SJ5hGrsMDu8EhDbyF46xFqUfwZkiWC1KgY5WltbgRoMHiDlWa+87dXszB2C0RUbPTtUCR + zwxw48MXmRz0Z/zp2pRXkP6Py6ZVAwCQ2MROIA0zZXirLCmXex2pcJ6rzJugGnPypjd5mb6MgMUsIvH1 + OoF+/ceG4oSE+r43W9uCUA9gASnuuUf16U36RNDwdQGC9u4Mpfxb2JUYZuBTKMN187uZe8VcdeFPB8nd + V0ZVks/Z+o6o97mk2PpDV8XhZ3nqZh1ssjMXufnRyyQnGmmtZVa4NmUpyXdLor1ADnrWwb+Ow88EPSWM + c05UxCyIItkY3n7KukOGXkug0YUXYGwAjvVJFKJRl9Yi4jg5zQ9KRluTVp/i66BU6GDNA79GfN0vEG7Z + hH8KOo7k7gdC4h8IhsVEUG5RT6UkIKGXMa9xHCqwKzmS4ycYunKSUqFI/dytIBmZ77KCTVU/NgAA4fiC + LLb0C5vgH7bDDgMC3myThTJP5rvYiihR527C6WS9s0/vmgO+jyS6NJm/SXdHSoHjtBHr+jLrtvw07WsP + EgjGG/7WmWcW+6MF8mOLQraf8f53mRrsp74LtK5KPYaE/FY0T2NVTQA/yaoI5JJwfgrGK+CEIBqAVkOv + mLPAq2YcwSlDMgFnr0lRz4UGMX4QRSKB2E3n+ZuQ3dak1aISpfxVkuOj5FJZDLNEMNQq6xF6u6mqxq+a + Qh+nQik/xNTQOwxcepvZae3p9091LbhWpZ36x6oB+CgKPB2Gp3tg+zrY1QZbghA3IKzqS1IdG8oVyORh + bAZujkJfEmacxrVEuiHRLUTtH7njFTWpSYujIPBplHqWaNtmujZsoW3NDkItGwkE2lBGiEaZ7LZdxCqn + KGSGSE1eIzE6QCmv16FpJLgmkIrNa6yS4LqXAAAi9fcj6/yti0qldUcM4hFoCwgQKEuCLtksJNOQzELG + qubyz9e0Io3Y+qdovLhIk5q0HFJItfuzwHaUESbSGqWlPU6kNU4wHMMw3cIiq0ipkKGQTZJLzVDM5XDm + igYazV8LKb1+k+V1n17UTdwP1A08iYCBd1Gh+a5ZLbA9hyDmSUTqN1X+Jq0mhZF5ewjpXdto5UEvzTd/ + 9X4TSIJPLx9DT8X7BQBAtIFNSFPQHUiyoA4EQD0jewdSd/y6idj5Q6zO8lNNatJ8FEMShh5G5nGEqhkK + C8/fEsL4vUh4OvVxXfT9BACaDKTa90FgK9JZLIbYXd7O3zotYILqirwpmh7+Jt1bCiHdhR5EgGANUsEe + pAoIev4mES21DxFaH7upej8CgJcMqivkRKkmDJaRwcohA9lU85t0P5KJzFu9zJuJzNUi1fl7f7ROb1KT + mtSkJjWpSU1qUpOa1KQmNalJTWpSk5rUpCY1qUlNalKTmtSkJjWpSU1qUpOa1KQmNalJn0D6/19rJipw + d5HWAAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/Switch_Toolbox/Program.cs b/Switch_Toolbox/Program.cs new file mode 100644 index 00000000..0c10eaec --- /dev/null +++ b/Switch_Toolbox/Program.cs @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace Switch_Toolbox +{ + static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + MainForm.executableDir = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location); + + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new MainForm()); + } + } +} diff --git a/Switch_Toolbox/Projects/Recent/DUMMY.txt b/Switch_Toolbox/Projects/Recent/DUMMY.txt new file mode 100644 index 00000000..5f282702 --- /dev/null +++ b/Switch_Toolbox/Projects/Recent/DUMMY.txt @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Switch_Toolbox/Properties/AssemblyInfo.cs b/Switch_Toolbox/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..67a7d43c --- /dev/null +++ b/Switch_Toolbox/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("Switch_Toolbox")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Switch_Toolbox")] +[assembly: AssemblyCopyright("Copyright © 2018")] +[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("e861c28b-b039-48f7-9a4f-c83f67c0adde")] + +// 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/Switch_Toolbox/Properties/Resources.Designer.cs b/Switch_Toolbox/Properties/Resources.Designer.cs new file mode 100644 index 00000000..d175e596 --- /dev/null +++ b/Switch_Toolbox/Properties/Resources.Designer.cs @@ -0,0 +1,83 @@ +//------------------------------------------------------------------------------ +// +// 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 Switch_Toolbox.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("Switch_Toolbox.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; + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap Logo { + get { + object obj = ResourceManager.GetObject("Logo", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap Tool { + get { + object obj = ResourceManager.GetObject("Tool", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + } +} diff --git a/Switch_Toolbox/Properties/Resources.resx b/Switch_Toolbox/Properties/Resources.resx new file mode 100644 index 00000000..ef298391 --- /dev/null +++ b/Switch_Toolbox/Properties/Resources.resx @@ -0,0 +1,127 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\Tool.ico;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\Logo.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/Switch_Toolbox/Properties/Settings.Designer.cs b/Switch_Toolbox/Properties/Settings.Designer.cs new file mode 100644 index 00000000..582edda1 --- /dev/null +++ b/Switch_Toolbox/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 Switch_Toolbox.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.8.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/Switch_Toolbox/Properties/Settings.settings b/Switch_Toolbox/Properties/Settings.settings new file mode 100644 index 00000000..39645652 --- /dev/null +++ b/Switch_Toolbox/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/Switch_Toolbox/Resources/Logo.png b/Switch_Toolbox/Resources/Logo.png new file mode 100644 index 00000000..87f206a0 Binary files /dev/null and b/Switch_Toolbox/Resources/Logo.png differ diff --git a/Switch_Toolbox/Shader/Bfres/BFRES.frag b/Switch_Toolbox/Shader/Bfres/BFRES.frag new file mode 100644 index 00000000..e5beb86b --- /dev/null +++ b/Switch_Toolbox/Shader/Bfres/BFRES.frag @@ -0,0 +1,152 @@ +#version 330 + +in vec2 f_texcoord0; +in vec2 f_texcoord1; +in vec2 f_texcoord2; +in vec2 f_texcoord3; + +in vec3 objectPosition; + +in vec3 normal; +in vec3 viewNormal; +in vec4 vertexColor; +in vec3 tangent; +in vec3 bitangent; + +in vec3 boneWeightsColored; + +uniform sampler2D DiffuseMap; +uniform sampler2D BakeShadowMap; +uniform sampler2D SpecularMap; +uniform sampler2D NormalMap; +uniform sampler2D BakeLightMap; +uniform sampler2D UVTestPattern; +uniform sampler2D TransparencyMap; +uniform sampler2D EmissionMap; +uniform sampler2D DiffuseLayer; +uniform sampler2D MetalnessMap; +uniform sampler2D RoughnessMap; +uniform sampler2D MRA; +uniform sampler2D BOTWSpecularMap; +uniform sampler2D SphereMap; +uniform sampler2D SubSurfaceScatteringMap; + +// Viewport Camera/Lighting +uniform mat4 mvpMatrix; +uniform vec3 difLightDirection; + +// Viewport Settings +uniform int uvChannel; +uniform int renderType; +uniform int useNormalMap; +uniform vec4 colorSamplerUV; +uniform int renderVertColor; +uniform vec3 difLightColor; +uniform vec3 ambLightColor; +uniform int colorOverride; +uniform float DefaultMetalness; +uniform float DefaultRoughness; + +uniform int isTransparent; + +// Texture Map Toggles +uniform int HasDiffuse; +uniform int HasNormalMap; +uniform int HasSpecularMap; +uniform int HasShadowMap; +uniform int HasAmbientOcclusionMap; +uniform int HasLightMap; +uniform int HasTransparencyMap; +uniform int HasEmissionMap; +uniform int HasDiffuseLayer; +uniform int HasMetalnessMap; +uniform int HasRoughnessMap; +uniform int HasMRA; +uniform int HasSubSurfaceScatteringMap; + +uniform vec4 const_color0; +uniform vec4 base_color_mul_color; + +struct VertexAttributes { + vec3 objectPosition; + vec2 texCoord; + vec2 texCoord2; + vec2 texCoord3; + vec4 vertexColor; + vec3 normal; + vec3 viewNormal; + vec3 tangent; + vec3 bitangent; + }; + +out vec4 fragColor; + +#define gamma 2.2 + +// Defined in Utility.frag. +float Luminance(vec3 rgb); + +vec3 CalcBumpedNormal(vec3 normal, sampler2D normalMap, VertexAttributes vert, float texCoordIndex); + +void main() +{ + fragColor = vec4(vec3(0), 1); + + VertexAttributes vert; + vert.objectPosition = objectPosition; + vert.texCoord = f_texcoord0; + vert.texCoord2 = f_texcoord1; + vert.texCoord3 = f_texcoord2; + vert.vertexColor = vertexColor; + vert.normal = normal; + vert.viewNormal = viewNormal; + vert.tangent = tangent; + vert.bitangent = bitangent; + + // Wireframe color. + if (colorOverride == 1) + { + if (renderVertColor == 1) + fragColor = vec4(vertexColor); + else + fragColor = vec4(1); + + return; + } + + // Calculate shading vectors. + vec3 I = vec3(0,0,-1) * mat3(mvpMatrix); + + vec3 N = normal; + if (HasNormalMap == 1 && useNormalMap == 1) + N = CalcBumpedNormal(normal, NormalMap, vert, 0); + + // Diffuse lighting. + float halfLambert = dot(difLightDirection, N) * 0.5 + 0.5; + + vec4 diffuseMapColor = vec4(texture(DiffuseMap, f_texcoord0).rgb, 1); + diffuseMapColor *= halfLambert; + + // vec3 displayNormal = (N * 0.5) + 0.5; + + + // fragColor = vec4(displayNormal,1); + + fragColor.rgb += diffuseMapColor.rgb; + + vec3 color = vec3(1); + vec3 normal = texture(NormalMap, f_texcoord0).rgb; + vec3 specular = texture(SpecularMap, f_texcoord0).rgb; + + fragColor.a *= texture(DiffuseMap, f_texcoord0).a; + + if (renderVertColor == 1) + fragColor *= min(vert.vertexColor, vec4(1)); + + fragColor *= min(const_color0, vec4(1)); + fragColor *= min(base_color_mul_color, vec4(1)); + + +// if (isTransparent != 1) + // fragColor.a = 1; +} diff --git a/Switch_Toolbox/Shader/Bfres/BFRES.vert b/Switch_Toolbox/Shader/Bfres/BFRES.vert new file mode 100644 index 00000000..f13028a7 --- /dev/null +++ b/Switch_Toolbox/Shader/Bfres/BFRES.vert @@ -0,0 +1,129 @@ +#version 330 + +uniform mat4 mvpMatrix; + +in vec3 vPosition; +in vec3 vNormal; +in vec3 vTangent; +in vec3 vBitangent; +in vec2 vUV0; +in vec4 vColor; +in vec4 vBone; +in vec4 vWeight; +in vec2 vUV1; +in vec2 vUV2; +in vec3 vPosition2; +in vec3 vPosition3; + +out vec2 f_texcoord0; +out vec2 f_texcoord1; +out vec2 f_texcoord2; +out vec2 f_texcoord3; + +out vec3 objectPosition; + +out vec3 normal; +out vec3 viewNormal; +out vec4 vertexColor; +out vec3 tangent; +out vec3 bitangent; + +out vec3 boneWeightsColored; + +// Shader Options +uniform vec4 gsys_bake_st0; +uniform vec4 gsys_bake_st1; + +// Skinning uniforms +uniform mat4 bones[200]; + //Meshes have a bone index and will use their transform depending on skin influence amount +uniform mat4 singleBoneBindTransform; +uniform int NoSkinning; +uniform int RigidSkinning; + +vec4 skin(vec3 pos, ivec4 index) +{ + vec4 newPosition = vec4(pos.xyz, 1.0); + + newPosition = bones[index.x] * vec4(pos, 1.0) * vWeight.x; + newPosition += bones[index.y] * vec4(pos, 1.0) * vWeight.y; + newPosition += bones[index.z] * vec4(pos, 1.0) * vWeight.z; + if (vWeight.w < 1) //Necessary. Bones may scale weirdly without + newPosition += bones[index.w] * vec4(pos, 1.0) * vWeight.w; + + return newPosition; +} + +vec3 skinNRM(vec3 nr, ivec4 index) +{ + vec3 newNormal = vec3(0); + + newNormal = mat3(bones[index.x]) * nr * vWeight.x; + newNormal += mat3(bones[index.y]) * nr * vWeight.y; + newNormal += mat3(bones[index.z]) * nr * vWeight.z; + newNormal += mat3(bones[index.w]) * nr * vWeight.w; + + return newNormal; +} + +vec2 rotateUV(vec2 uv, float rotation) +{ + float mid = 0.5; + return vec2( + cos(rotation) * (uv.x - mid) + sin(rotation) * (uv.y - mid) + mid, + cos(rotation) * (uv.y - mid) - sin(rotation) * (uv.x - mid) + mid + ); +} + +void main() +{ + ivec4 index = ivec4(vBone); + + vec4 objPos = vec4(vPosition.xyz, 1.0); + objectPosition = vPosition.xyz; + if (vBone.x != -1.0) + objPos = skin(vPosition, index); + + gl_Position = mvpMatrix * vec4(objPos.xyz, 1.0); + + normal = vNormal; + + if(vBone.x != -1.0) + normal = normalize((skinNRM(vNormal.xyz, index)).xyz); + + + + if (RigidSkinning == 1) + { + gl_Position = mvpMatrix * bones[index.x] * vec4(vPosition, 1.0); + normal = vNormal; + normal = mat3(bones[index.x]) * vNormal.xyz * 1; + } + if (NoSkinning == 1) + { + gl_Position = mvpMatrix * singleBoneBindTransform * vec4(vPosition, 1.0); + normal = mat3(singleBoneBindTransform) * vNormal.xyz * 1; + normal = normalize(normal); + } + + f_texcoord0 = vUV0; + + vec4 sampler2 = gsys_bake_st0; + vec4 sampler3 = gsys_bake_st1; + + if (sampler2.x != 0 && sampler2.y != 0) + f_texcoord1 = vec2((vUV1 * sampler2.xy) + sampler2.zw); + else + f_texcoord1 = vec2((vUV1 * vec2(1)) + sampler2.zw); + + if (sampler3.x != 0 && sampler3.y != 0) + f_texcoord2 = vec2((vUV1 * sampler3.xy) + sampler3.zw); + else + f_texcoord2 = vec2((vUV1 * vec2(1)) + sampler3.zw); + + f_texcoord3 = vUV2; + + tangent = vTangent; + bitangent = vBitangent; + vertexColor = vColor; +} diff --git a/Switch_Toolbox/Shader/Bfres/BFRES_Botw.frag b/Switch_Toolbox/Shader/Bfres/BFRES_Botw.frag new file mode 100644 index 00000000..87bd63d5 --- /dev/null +++ b/Switch_Toolbox/Shader/Bfres/BFRES_Botw.frag @@ -0,0 +1,352 @@ +#version 330 + +in vec2 f_texcoord0; +in vec2 f_texcoord1; +in vec2 f_texcoord2; +in vec2 f_texcoord3; + +in vec3 objectPosition; + +in vec3 normal; +in vec4 vertexColor; +in vec3 tangent; +in vec3 bitangent; + +in vec3 boneWeightsColored; + +// Viewport Camera/Lighting +uniform mat4 mvpMatrix; +uniform vec3 specLightDirection; +uniform vec3 difLightDirection; +uniform mat4 projMatrix; +uniform mat4 normalMatrix; +uniform mat4 modelViewMatrix; +uniform mat4 rotationMatrix; + +uniform int useImageBasedLighting; +uniform int enableCellShading; + +uniform vec3 camPos; + +uniform vec3 light1Pos; + +const float levels = 3.0; + +// Viewport Settings +uniform int uvChannel; +uniform int renderType; +uniform int useNormalMap; +uniform vec4 colorSamplerUV; +uniform int renderVertColor; +uniform vec3 difLightColor; +uniform vec3 ambLightColor; +uniform int colorOverride; +uniform float DefaultMetalness; +uniform float DefaultRoughness; + +// Channel Toggles +uniform int renderR; +uniform int renderG; +uniform int renderB; +uniform int renderAlpha; + +// Texture Samplers +uniform sampler2D tex0; +uniform sampler2D BakeShadowMap; +uniform sampler2D normalMap; +uniform sampler2D BakeLightMap; +uniform sampler2D UVTestPattern; +uniform sampler2D TransparencyMap; +uniform sampler2D EmissionMap; +uniform sampler2D SpecularMap; +uniform sampler2D DiffuseLayer; +uniform sampler2D MetalnessMap; +uniform sampler2D RoughnessMap; +uniform sampler2D MRA; +uniform sampler2D TeamColorMap; +uniform sampler2D SphereMap; + +uniform samplerCube irradianceMap; +uniform samplerCube specularIbl; +uniform sampler2D brdfLUT; + +// Shader Params +uniform float normal_map_weight; +uniform float ao_density; +uniform float emission_intensity; +uniform vec4 fresnelParams; +uniform vec4 base_color_mul_color; +uniform vec3 emission_color; +uniform vec3 specular_color; + +// Shader Options +uniform float uking_texture2_texcoord; +uniform float bake_shadow_type; +uniform float enable_fresnel; +uniform float enable_emission; +uniform float cSpecularType; + +// Texture Map Toggles +uniform int HasDiffuse; +uniform int HasNormalMap; +uniform int HasSpecularMap; +uniform int HasShadowMap; +uniform int HasAmbientOcclusionMap; +uniform int HasLightMap; +uniform int HasTransparencyMap; +uniform int HasEmissionMap; +uniform int HasDiffuseLayer; +uniform int HasMetalnessMap; +uniform int HasRoughnessMap; +uniform int HasMRA; + +uniform int roughnessAmount; + +uniform int UseAOMap; +uniform int UseCavityMap; +uniform int UseMetalnessMap; +uniform int UseRoughnessMap; + +int isTransparent; + +uniform int renderDiffuse; +uniform int renderSpecular; +uniform int renderFresnel; + +struct VertexAttributes +{ + vec3 objectPosition; + vec2 texCoord; + vec2 texCoord2; + vec2 texCoord3; + vec4 vertexColor; + vec3 normal; + vec3 viewNormal; + vec3 tangent; + vec3 bitangent; +}; + +out vec4 fragColor; + +#define gamma 2.2 +const float PI = 3.14159265359; + +// Defined in BFRES_Utility.frag. +vec3 CalcBumpedNormal(vec3 normal, sampler2D normalMap, VertexAttributes vert, float uking_texture2_texcoord); +float AmbientOcclusionBlend(sampler2D BakeShadowMap, VertexAttributes vert, float ao_density); +vec3 EmissionPass(sampler2D EmissionMap, float emission_intensity, VertexAttributes vert, float uking_texture2_texcoord, vec3 emission_color); + +// Shader code adapted from learnopengl.com's PBR tutorial: +// https://learnopengl.com/PBR/Theory + +vec3 fresnelSchlick(float cosTheta, vec3 F0) +{ + return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0); +} + +vec3 fresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness) +{ + return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0); +} + +float DistributionGGX(vec3 N, vec3 H, float roughness) +{ + float a = roughness*roughness; + float a2 = a*a; + float NdotH = max(dot(N, H), 0.0); + float NdotH2 = NdotH*NdotH; + + float num = a2; + float denom = (NdotH2 * (a2 - 1.0) + 1.0); + denom = PI * denom * denom; + + return num / denom; +} + +float GeometrySchlickGGX(float NdotV, float roughness) +{ + float r = (roughness + 1.0); + float k = (r*r) / 8.0; + + float num = NdotV; + float denom = NdotV * (1.0 - k) + k; + + return num / denom; +} + +float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) +{ + float NdotV = max(dot(N, V), 0.0); + float NdotL = max(dot(N, L), 0.0); + float ggx2 = GeometrySchlickGGX(NdotV, roughness); + float ggx1 = GeometrySchlickGGX(NdotL, roughness); + + return ggx1 * ggx2; +} + +vec3 saturation(vec3 rgb, float adjustment) +{ + const vec3 W = vec3(0.2125, 0.7154, 0.0721); + vec3 intensity = vec3(dot(rgb, W)); + return mix(intensity, rgb, adjustment); +} + +vec3 DiffusePass(vec3 albedo, vec3 N, vec3 L, vec3 R) +{ + float lambert = max(dot(N, L), 0.0); + + // Higher blend values make the dark region smoother and larger. + float smoothness = 0.1; + float center = 0.5; + float edgeL = center; + float edgeR = center + (smoothness * 0.5); + float smoothLambert = smoothstep(edgeL, edgeR, lambert); + + float ambient = 0.6; + smoothLambert = clamp(smoothLambert + ambient, 0, 1); + + vec3 diffuseTerm = albedo; + diffuseTerm *= smoothLambert; + + return diffuseTerm * 1.5; +} + +vec3 SpecularPass(vec3 albedo, vec3 N, vec3 H, vec3 R, float metallic, float specularMapIntensity) +{ + // Specular pass + vec3 specularTerm = vec3(0); + + // TODO: Metalness + vec3 specularColor = albedo; + + specularTerm = specularColor; + + // Hack something together for now. + vec3 specularLighting = texture(irradianceMap, R).rrr; + float center = 0.375; + float smoothness = 0.035; + specularLighting = smoothstep(vec3(center - smoothness), vec3(center + smoothness), specularLighting); + + specularTerm *= specularLighting; + specularTerm *= specularMapIntensity; + + return specularTerm; +} + +vec3 FresnelPass(vec3 N, vec3 I) +{ + // Fake edge lighting + float nDotI = clamp(dot(N, I), 0, 1); + float fresnel = 1 - nDotI; + + // TODO: Extract cel shade function. + float center = 0.75; + float smoothness = 0.015; + fresnel = smoothstep(center - smoothness, center + smoothness, fresnel); + + vec3 fresnelTerm = vec3(1, 1, 0.75) * fresnel * 0.2; + return fresnelTerm; +} + +void main() +{ + fragColor = vec4(1); + + // Create a struct for passing all the vertex attributes to other functions. + VertexAttributes vert; + vert.objectPosition = objectPosition; + vert.texCoord = f_texcoord0; + vert.texCoord2 = f_texcoord1; + vert.texCoord3 = f_texcoord2; + vert.vertexColor = vertexColor; + vert.normal = normal; + vert.tangent = tangent; + vert.bitangent = bitangent; + + vec3 lightColor = vec3(10); + + // Wireframe color. + if (colorOverride == 1) + { + fragColor = vec4(1); + return; + } + + vec3 albedo = pow(texture(tex0, f_texcoord0).rgb, vec3(gamma)); + + float metallic = DefaultMetalness; + if (HasMetalnessMap == 1) + metallic = texture(MetalnessMap, f_texcoord0).r; + + float roughness = DefaultRoughness; + if (HasRoughnessMap == 1) + roughness = texture(RoughnessMap, f_texcoord0).r; + + float ao = 1; + if (HasShadowMap == 1 && UseAOMap == 1) + ao = texture(BakeShadowMap, f_texcoord1).r; + + float shadow = 1; + if (HasShadowMap == 1) + shadow = texture(BakeShadowMap, f_texcoord1).g; + + float cavity = 1; + + vec3 lightMapColor = vec3(1); + float lightMapIntensity = 0; + if (HasLightMap == 1) + { + lightMapColor = texture(BakeLightMap, f_texcoord1).rgb; + lightMapIntensity = texture(BakeLightMap, f_texcoord1).a; + } + + // TODO: Extract function. + float specularMapIntensity = 1; + if (HasSpecularMap == 1) + { + if (uking_texture2_texcoord == 1) + { + metallic = texture(SpecularMap, f_texcoord1).g; + specularMapIntensity = texture(SpecularMap, f_texcoord1).r; + } + else + { + metallic = texture(SpecularMap, f_texcoord0).g; + specularMapIntensity = texture(SpecularMap, f_texcoord0).r; + } + } + + vec3 I = vec3(0,0,-1) * mat3(mvpMatrix); + + vec3 N = normal; + if (HasNormalMap == 1 && useNormalMap == 1) + N = CalcBumpedNormal(normal, normalMap, vert, uking_texture2_texcoord); + + vec3 V = normalize(I); //Eye View + vec3 L = normalize(specLightDirection); //Light + vec3 H = normalize(specLightDirection + I); //Half Angle + vec3 R = reflect(I, N); // reflection + + // Render passes + vec3 outputColor = vec3(0); + float kDiffuse = clamp(1.0 - metallic, 0, 1); + outputColor += DiffusePass(albedo, N, L, R) * renderDiffuse; + outputColor += SpecularPass(albedo, N, H, R, metallic, specularMapIntensity) * renderSpecular; + outputColor += FresnelPass(N, I) * renderFresnel; + if (HasEmissionMap == 1 || enable_emission == 1) //Can be without texture map + outputColor.rgb += EmissionPass(EmissionMap, emission_intensity, vert, uking_texture2_texcoord, emission_color); + + outputColor *= ao; + outputColor *= (0.6 + shadow); + + float cavityStrength = 1.0; + outputColor *= cavity * cavityStrength + (1.0 - cavityStrength); + + // TODO: Renders as black? + // if (renderVertColor == 1) + // fragColor *= min(vertexColor, vec4(1)); + + outputColor = pow(outputColor, vec3(1.0 / gamma)); + float alpha = texture(tex0, f_texcoord0).a; + fragColor = vec4(outputColor, alpha); +} diff --git a/Switch_Toolbox/Shader/Bfres/BFRES_Debug.frag b/Switch_Toolbox/Shader/Bfres/BFRES_Debug.frag new file mode 100644 index 00000000..b9aaeaa6 --- /dev/null +++ b/Switch_Toolbox/Shader/Bfres/BFRES_Debug.frag @@ -0,0 +1,304 @@ +#version 330 + +in vec2 f_texcoord0; +in vec2 f_texcoord1; +in vec2 f_texcoord2; +in vec2 f_texcoord3; + +in vec3 objectPosition; + +in vec3 normal; +in vec3 viewNormal; +in vec4 vertexColor; +in vec3 tangent; +in vec3 bitangent; + +in vec3 boneWeightsColored; + +// Viewport Camera/Lighting +uniform mat4 mvpMatrix; +uniform vec3 specLightDirection; +uniform vec3 difLightDirection; +uniform mat4 projMatrix; +uniform mat4 normalMatrix; +uniform mat4 modelViewMatrix; +uniform mat4 rotationMatrix; + +uniform int useImageBasedLighting; +uniform int enableCellShading; + +uniform vec3 camPos; + +uniform vec3 light1Pos; + +const float levels = 3.0; + +// Viewport Settings +uniform int uvChannel; +uniform int renderType; +uniform int useNormalMap; +uniform vec4 colorSamplerUV; +uniform int renderVertColor; +uniform vec3 difLightColor; +uniform vec3 ambLightColor; +uniform int colorOverride; +uniform float DefaultMetalness; +uniform float DefaultRoughness; + +// Channel Toggles +uniform int renderR; +uniform int renderG; +uniform int renderB; +uniform int renderAlpha; + +// Texture Samplers +uniform sampler2D DiffuseMap; +uniform sampler2D BakeShadowMap; +uniform sampler2D NormalMap; +uniform sampler2D BakeLightMap; +uniform sampler2D UVTestPattern; +uniform sampler2D TransparencyMap; +uniform sampler2D EmissionMap; +uniform sampler2D SpecularMap; +uniform sampler2D DiffuseLayer; +uniform sampler2D MetalnessMap; +uniform sampler2D RoughnessMap; +uniform sampler2D MRA; +uniform sampler2D TeamColorMap; +uniform sampler2D SphereMap; +uniform sampler2D SubSurfaceScatteringMap; + +uniform samplerCube irradianceMap; +uniform samplerCube specularIbl; +uniform sampler2D brdfLUT; + +// Shader Params +uniform float normal_map_weight; +uniform float ao_density; +uniform float emission_intensity; +uniform vec4 fresnelParams; +uniform vec4 base_color_mul_color; +uniform vec3 emission_color; +uniform vec3 specular_color; + +// Shader Options +uniform float uking_texture2_texcoord; +uniform float bake_shadow_type; +uniform float enable_fresnel; +uniform float enable_emission; +uniform float cSpecularType; + + +// Texture Map Toggles +uniform int HasDiffuse; +uniform int HasNormalMap; +uniform int HasSpecularMap; +uniform int HasShadowMap; +uniform int HasAmbientOcclusionMap; +uniform int HasLightMap; +uniform int HasTransparencyMap; +uniform int HasEmissionMap; +uniform int HasDiffuseLayer; +uniform int HasMetalnessMap; +uniform int HasRoughnessMap; +uniform int HasMRA; +uniform int HasSubSurfaceScatteringMap; + +uniform int roughnessAmount; + +uniform int UseAOMap; +uniform int UseCavityMap; +uniform int UseMetalnessMap; +uniform int UseRoughnessMap; + +int isTransparent; + +struct VertexAttributes { + vec3 objectPosition; + vec2 texCoord; + vec2 texCoord2; + vec2 texCoord3; + vec4 vertexColor; + vec3 normal; + vec3 viewNormal; + vec3 tangent; + vec3 bitangent; + }; + +out vec4 fragColor; + +#define gamma 2.2 + +// Defined in Utility.frag. +float Luminance(vec3 rgb); + +// Defined in BFRES_Utility.frag. +vec3 CalcBumpedNormal(vec3 normal, sampler2D normalMap, VertexAttributes vert, float texCoordIndex); +float AmbientOcclusionBlend(sampler2D BakeShadowMap, VertexAttributes vert, float ao_density); +vec3 EmissionPass(sampler2D EmissionMap, float emission_intensity, VertexAttributes vert, float texCoordIndex, vec3 emission_color); + +vec2 displayTexCoord = f_texcoord0; + +void main() +{ + fragColor = vec4(vec3(0), 1); + + // Create a struct for passing all the vertex attributes to other functions. + VertexAttributes vert; + vert.objectPosition = objectPosition; + vert.texCoord = f_texcoord0; + vert.texCoord2 = f_texcoord1; + vert.texCoord3 = f_texcoord2; + vert.vertexColor = vertexColor; + vert.normal = normal; + vert.viewNormal = viewNormal; + vert.tangent = tangent; + vert.bitangent = bitangent; + + vec3 N = normal; + if (HasNormalMap == 1 && useNormalMap == 1) + N = CalcBumpedNormal(normal, NormalMap, vert, uking_texture2_texcoord); + + if (renderType == 1) // normals vertexColor + { + vec3 displayNormal = (N * 0.5) + 0.5; + fragColor = vec4(displayNormal,1); + } + else if (renderType == 2) // Lighting + { + float halfLambert = dot(difLightDirection, N) * 0.5 + 0.5; + fragColor = vec4(vec3(halfLambert), 1); + } + else if (renderType == 4) //Display Normal + { + if (uking_texture2_texcoord == 1) + fragColor.rgb = texture(NormalMap, f_texcoord1).rgb; + else + fragColor.rgb = texture(NormalMap, displayTexCoord).rgb; + } + else if (renderType == 3) //DiffuseColor + fragColor = vec4(texture(DiffuseMap, displayTexCoord).rgb, 1); + else if (renderType == 5) // vertexColor + fragColor = vertexColor; + else if (renderType == 6) //Display Ambient Occlusion + { + if (HasShadowMap == 1) + { + float ambientOcclusionBlend = AmbientOcclusionBlend(BakeShadowMap, vert, ao_density); + fragColor = vec4(vec3(ambientOcclusionBlend), 1); + } + else + { + fragColor = vec4(1); + } + } + else if (renderType == 7) // uv coords + fragColor = vec4(displayTexCoord.x, displayTexCoord.y, 1, 1); + else if (renderType == 8) // uv test pattern + { + fragColor = vec4(texture(UVTestPattern, displayTexCoord).rgb, 1); + } + else if (renderType == 9) //Display tangents + { + vec3 displayTangent = (tangent * 0.5) + 0.5; + if (dot(tangent, vec3(1)) == 0) + displayTangent = vec3(0); + + fragColor = vec4(displayTangent,1); + } + else if (renderType == 10) //Display bitangents + { + vec3 displayBitangent = (bitangent * 0.5) + 0.5; + if (dot(bitangent, vec3(1)) == 0) + displayBitangent = vec3(0); + + fragColor = vec4(displayBitangent,1); + } + + else if (renderType == 12) + { + fragColor.rgb = boneWeightsColored; + } + else if (renderType == 11) //Light map + { + if (HasLightMap == 1) + { + vec3 lightMap = texture(BakeLightMap, f_texcoord2).rgb; + fragColor = vec4(lightMap, 1); + } + else + { + fragColor = vec4(1); + } + } + else if (renderType == 14) //Shadow + { + if (HasShadowMap == 1) + { + float Shadow = texture(BakeShadowMap, f_texcoord1).g; + fragColor = vec4(vec3(Shadow), 1); + } + else + { + fragColor = vec4(1); + } + } + else if (renderType == 15) //MetalnessMap + { + if (HasMetalnessMap == 1) + { + float mtl = texture(MetalnessMap, displayTexCoord).r; + fragColor = vec4(vec3(mtl), 1); + } + else + { + fragColor = vec4(1); + } + } + else if (renderType == 16) //RoughnessMap + { + if (HasRoughnessMap == 1) + { + float rgh = texture(RoughnessMap, displayTexCoord).r; + fragColor = vec4(vec3(rgh), 1); + } + else + { + fragColor = vec4(1); + } + } + else if (renderType == 17) //SubSurfaceScatteringMap + { + if (HasSubSurfaceScatteringMap == 1) + { + vec3 sss = texture(SubSurfaceScatteringMap, displayTexCoord).rgb; + fragColor = vec4(sss, 1); + } + else + { + fragColor = vec4(1); + } + } + else if (renderType == 18) //EmmissionMap + { + if (HasEmissionMap == 1) + { + vec3 emm = texture(EmissionMap, displayTexCoord).rgb; + fragColor = vec4(emm, 1); + } + else + { + fragColor = vec4(1); + } + } + + // Toggles rendering of individual color channels for all render modes. + fragColor.rgb *= vec3(renderR, renderG, renderB); + if (renderR == 1 && renderG == 0 && renderB == 0) + fragColor.rgb = fragColor.rrr; + else if (renderG == 1 && renderR == 0 && renderB == 0) + fragColor.rgb = fragColor.ggg; + else if (renderB == 1 && renderR == 0 && renderG == 0) + fragColor.rgb = fragColor.bbb; + +} diff --git a/Switch_Toolbox/Shader/Bfres/BFRES_PBR.frag b/Switch_Toolbox/Shader/Bfres/BFRES_PBR.frag new file mode 100644 index 00000000..7423d61e --- /dev/null +++ b/Switch_Toolbox/Shader/Bfres/BFRES_PBR.frag @@ -0,0 +1,307 @@ +#version 330 + +in vec2 f_texcoord0; +in vec2 f_texcoord1; +in vec2 f_texcoord2; +in vec2 f_texcoord3; + +in vec3 objectPosition; + +in vec3 normal; +in vec4 vertexColor; +in vec3 tangent; +in vec3 bitangent; + +in vec3 boneWeightsColored; + +// Viewport Camera/Lighting +uniform mat4 mvpMatrix; +uniform vec3 specLightDirection; +uniform vec3 difLightDirection; +uniform mat4 projMatrix; +uniform mat4 normalMatrix; +uniform mat4 modelViewMatrix; +uniform mat4 rotationMatrix; + +uniform int useImageBasedLighting; +uniform int enableCellShading; + +uniform vec3 camPos; + +uniform vec3 light1Pos; + +const float levels = 3.0; + +// Viewport Settings +uniform int uvChannel; +uniform int renderType; +uniform int useNormalMap; +uniform vec4 colorSamplerUV; +uniform int renderVertColor; +uniform vec3 difLightColor; +uniform vec3 ambLightColor; +uniform int colorOverride; +uniform float DefaultMetalness; +uniform float DefaultRoughness; + +// Channel Toggles +uniform int renderR; +uniform int renderG; +uniform int renderB; +uniform int renderAlpha; + +// Texture Samplers +uniform sampler2D tex0; +uniform sampler2D BakeShadowMap; +uniform sampler2D spl; +uniform sampler2D normalMap; +uniform sampler2D BakeLightMap; +uniform sampler2D UVTestPattern; +uniform sampler2D TransparencyMap; +uniform sampler2D EmissionMap; +uniform sampler2D SpecularMap; +uniform sampler2D DiffuseLayer; +uniform sampler2D MetalnessMap; +uniform sampler2D RoughnessMap; +uniform sampler2D MRA; +uniform sampler2D BOTWSpecularMap; +uniform sampler2D SphereMap; +uniform sampler2D SubSurfaceScatteringMap; + +uniform samplerCube irradianceMap; +uniform samplerCube specularIbl; +uniform sampler2D brdfLUT; + +// Shader Params +uniform float normal_map_weight; +uniform float ao_density; +uniform float emission_intensity; +uniform vec4 fresnelParams; +uniform vec4 base_color_mul_color; +uniform vec3 emission_color; +uniform vec3 specular_color; + +// Shader Options +uniform float uking_texture2_texcoord; +uniform float bake_shadow_type; +uniform float enable_fresnel; +uniform float enable_emission; +uniform float cSpecularType; + + +// Texture Map Toggles +uniform int HasDiffuse; +uniform int HasNormalMap; +uniform int HasSpecularMap; +uniform int HasShadowMap; +uniform int HasAmbientOcclusionMap; +uniform int HasLightMap; +uniform int HasTransparencyMap; +uniform int HasEmissionMap; +uniform int HasDiffuseLayer; +uniform int HasMetalnessMap; +uniform int HasRoughnessMap; +uniform int HasMRA; +uniform int HasBOTWSpecularMap; +uniform int HasSubSurfaceScatteringMap; + +uniform int roughnessAmount; + +uniform int UseAOMap; +uniform int UseCavityMap; +uniform int UseMetalnessMap; +uniform int UseRoughnessMap; + +int isTransparent; + +struct VertexAttributes { + vec3 objectPosition; + vec2 texCoord; + vec2 texCoord2; + vec2 texCoord3; + vec4 vertexColor; + vec3 normal; + vec3 viewNormal; + vec3 tangent; + vec3 bitangent; + }; + +out vec4 fragColor; + +#define gamma 2.2 +const float PI = 3.14159265359; + +// Defined in BFRES_Utility.frag. +vec3 CalcBumpedNormal(vec3 normal, sampler2D normalMap, VertexAttributes vert, float texCoordIndex); +float AmbientOcclusionBlend(sampler2D BakeShadowMap, VertexAttributes vert, float ao_density); +vec3 EmissionPass(sampler2D EmissionMap, float emission_intensity, VertexAttributes vert, float texCoordIndex, vec3 emission_color); + +// Shader code adapted from learnopengl.com's PBR tutorial: +// https://learnopengl.com/PBR/Theory + +vec3 FresnelSchlick(float cosTheta, vec3 F0) +{ + return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0); +} + +vec3 FresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness) +{ + return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0); +} + +float DistributionGGX(vec3 N, vec3 H, float roughness) +{ + float a = roughness*roughness; + float a2 = a*a; + float NdotH = max(dot(N, H), 0.0); + float NdotH2 = NdotH*NdotH; + + float num = a2; + float denom = (NdotH2 * (a2 - 1.0) + 1.0); + denom = PI * denom * denom; + + return num / denom; +} + +float GeometrySchlickGGX(float NdotV, float roughness) +{ + float r = (roughness + 1.0); + float k = (r*r) / 8.0; + + float num = NdotV; + float denom = NdotV * (1.0 - k) + k; + + return num / denom; +} + +float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) +{ + float NdotV = max(dot(N, V), 0.0); + float NdotL = max(dot(N, L), 0.0); + float ggx2 = GeometrySchlickGGX(NdotV, roughness); + float ggx1 = GeometrySchlickGGX(NdotL, roughness); + + return ggx1 * ggx2; +} + +vec3 saturation(vec3 rgb, float adjustment) +{ + const vec3 W = vec3(0.2125, 0.7154, 0.0721); + vec3 intensity = vec3(dot(rgb, W)); + return mix(intensity, rgb, adjustment); +} + +void main() +{ + fragColor = vec4(1); + + // Create a struct for passing all the vertex attributes to other functions. + VertexAttributes vert; + vert.objectPosition = objectPosition; + vert.texCoord = f_texcoord0; + vert.texCoord2 = f_texcoord1; + vert.texCoord3 = f_texcoord2; + vert.vertexColor = vertexColor; + vert.normal = normal; + vert.tangent = tangent; + vert.bitangent = bitangent; + + vec3 lightColor = vec3(10); + + // Wireframe color. + if (colorOverride == 1) + { + fragColor = vec4(1); + return; + } + + vec3 albedo = vec3(1); + if (HasDiffuse == 1) + albedo = pow(texture(tex0, f_texcoord0).rgb, vec3(gamma)); + + float metallic = 0; + if (HasMetalnessMap == 1) + metallic = texture(MetalnessMap, f_texcoord0).r; + + float roughness = 0.5; + if (HasRoughnessMap == 1) + roughness = texture(RoughnessMap, f_texcoord0).r; + + float ao = 1; + if (HasShadowMap == 1 && UseAOMap == 1) + ao = texture(BakeShadowMap, f_texcoord1).r; + + float shadow = 1; + if (HasShadowMap == 1) + shadow = texture(BakeShadowMap, f_texcoord1).g; + + float cavity = 1; + + vec3 emission = vec3(0); + if (HasEmissionMap == 1 || enable_emission == 1) //Can be without texture map + emission.rgb += EmissionPass(EmissionMap, emission_intensity, vert, 0, emission_color); + + vec3 lightMapColor = vec3(1); + float lightMapIntensity = 0; + if (HasLightMap == 1) + { + lightMapColor = texture(BakeLightMap, f_texcoord1).rgb; + lightMapIntensity = texture(BakeLightMap, f_texcoord1).a; + } + + float specIntensity = 0; + + if (HasMRA == 1) //Kirby Star Allies PBR map + { + //Note KSA has no way to tell if one gets unused or not because shaders :( + //Usually it's just metalness with roughness and works fine + metallic = texture(MRA, f_texcoord0).r; + roughness = texture(MRA, f_texcoord0).g; + specIntensity = texture(MRA, f_texcoord0).b; + ao = texture(MRA, f_texcoord0).a; + } + + // Calculate shading vectors. + vec3 I = vec3(0,0,-1) * mat3(mvpMatrix); + vec3 N = normal; + if (HasNormalMap == 1 && useNormalMap == 1) + N = CalcBumpedNormal(normal, normalMap, vert, 0); + + vec3 V = normalize(I); // view + vec3 L = normalize(specLightDirection); // Light + vec3 H = normalize(specLightDirection + I); // half angle + vec3 R = reflect(I, N); // reflection + + // Diffuse pass + vec3 diffuseIblColor = texture(irradianceMap, N).rgb; + vec3 diffuseTerm = albedo * diffuseIblColor; + diffuseTerm *= cavity; + diffuseTerm *= ao; + diffuseTerm *= shadow; + + // Adjust for metalness. + diffuseTerm *= clamp(1 - metallic, 0, 1); + + // Specular pass. + int maxSpecularLod = 8; + vec3 specularIblColor = textureLod(specularIbl, R, roughness * maxSpecularLod).rgb; + vec3 f0 = mix(vec3(0.04), albedo, metallic); // dialectric + vec3 kS = FresnelSchlickRoughness(max(dot(N, H), 0.0), f0, roughness); + + vec3 specularTerm = specularIblColor * kS; + + // Add render passes. + fragColor.rgb = vec3(0); + fragColor.rgb += diffuseTerm; + fragColor.rgb += specularTerm; + + // Global brightness adjustment. + fragColor.rgb *= 2.5; + + // Convert back to sRGB. + fragColor.rgb = pow(fragColor.rgb, vec3(1 / gamma)); + + // Alpha calculations. + float alpha = texture(tex0, f_texcoord0).a; + fragColor.a = alpha; +} diff --git a/Switch_Toolbox/Shader/Bfres/BFRES_utility.frag b/Switch_Toolbox/Shader/Bfres/BFRES_utility.frag new file mode 100644 index 00000000..39aacc0f --- /dev/null +++ b/Switch_Toolbox/Shader/Bfres/BFRES_utility.frag @@ -0,0 +1,135 @@ +#version 330 + +// A struct is used for what would normally be attributes from the vert/geom shader. +struct VertexAttributes +{ + vec3 objectPosition; + vec2 texCoord; + vec2 texCoord2; + vec2 texCoord3; + vec4 vertexColor; + vec3 normal; + vec3 viewNormal; + vec3 tangent; + vec3 bitangent; +}; + +uniform mat4 sphereMatrix; +uniform sampler2D SphereMap; +uniform samplerCube specularIbl; +uniform int HasSphereMap; +uniform int hasTangents; + +// Defined in Utility.frag. +float Luminance(vec3 rgb); + +vec3 SpecularPass(vec3 I, vec3 normal, int HasSpecularMap, sampler2D SpecularMap, vec3 SpecColor, VertexAttributes vert, float texcoord2) +{ + float specBrdf = max(dot(I, normal), 0); + float exponent = 8; + + if (SpecColor == vec3(0)) //Color shouldn't be black unless it's not set + SpecColor = vec3(1); + + if (HasSpecularMap == 0) + { + return 0.1 * SpecColor * pow(specBrdf, exponent); + } + + // TODO: Different games use the channels for separate textures. + vec3 specularTex = vec3(1); + if (texcoord2 == 1) + specularTex = texture(SpecularMap, vert.texCoord2).rrr; + else + specularTex = texture(SpecularMap, vert.texCoord).rrr; + + vec3 result = specularTex * SpecColor * pow(specBrdf, exponent); + result *= SpecColor.rgb; + + float intensity = 0.3; + return result * intensity; +} + +vec3 EmissionPass(sampler2D EmissionMap, float emission_intensity, VertexAttributes vert, float texCoordIndex, vec3 emission_color) +{ + vec3 result = vec3(0); + + // BOTW somtimes uses second uv channel for emission map + vec3 emission = vec3(1); + if (texCoordIndex == 1) + emission = texture2D(EmissionMap, vert.texCoord2).rgb; + else + emission = texture2D(EmissionMap, vert.texCoord).rgb; + + // If tex is empty then use full brightness. + //Some emissive mats have emission but no texture + // if (Luminance(emission.rgb) < 0.01) + // result += vec3(emission_intensity) * emission_color; + + result += emission.rgb; + + return result; +} + +vec3 SphereMapColor(vec3 viewNormal, sampler2D spheremap) { + // Calculate UVs based on view space normals. + vec2 sphereTexcoord = vec2(viewNormal.x, (1 - viewNormal.y)); + return texture(spheremap, sphereTexcoord * 0.5 + 0.5).rgb; +} + +vec3 ReflectionPass(vec3 N, vec3 I, vec4 diffuseMap, float aoBlend, vec3 tintColor, VertexAttributes vert) { + vec3 reflectionPass = vec3(0); + // cubemap reflection + vec3 R = reflect(I, N); + R.y *= -1.0; + + vec3 cubeColor = texture(specularIbl, R).aaa; + + // reflectionPass += diffuseMap.aaa * cubeColor * tintColor; + + vec3 viewNormal = mat3(sphereMatrix) * normalize(N.xyz); + vec3 sphereMapColor = SphereMapColor(vert.viewNormal, SphereMap); + + reflectionPass += sphereMapColor * HasSphereMap; + reflectionPass = max(reflectionPass, vec3(0)); + + return reflectionPass; +} + +float AmbientOcclusionBlend(sampler2D BakeShadowMap, VertexAttributes vert, float ao_density) +{ + float aoMap = texture(BakeShadowMap, vert.texCoord2).r; + return mix(aoMap, 1, ao_density); +} + +vec3 CalcBumpedNormal(vec3 inputNormal, sampler2D normalMap, VertexAttributes vert, float texCoordIndex) +{ + if (hasTangents == 0) + return inputNormal; + + float normalIntensity = 1; + + //if (normal_map_weight != 0) //MK8 and splatoon 1/2 uses this param + // normalIntensity = normal_map_weight; + + // Calculate the resulting normal map and intensity. + vec3 normalMapColor = vec3(1); + if (texCoordIndex == 1) + normalMapColor = vec3(texture(normalMap, vert.texCoord2).rg, 1); + else + normalMapColor = vec3(texture(normalMap, vert.texCoord).rg, 1); + normalMapColor = mix(vec3(0.5, 0.5, 1), normalMapColor, normalIntensity); + + // Remap the normal map to the correct range. + vec3 normalMapNormal = 2.0 * normalMapColor - vec3(1); + + // TBN Matrix. + vec3 T = vert.tangent; + vec3 B = vert. bitangent; + if (Luminance(B) < 0.01) + B = normalize(cross(T, vert.normal)); + mat3 tbnMatrix = mat3(T, B, vert.normal); + + vec3 newNormal = tbnMatrix * normalMapNormal; + return normalize(newNormal); +} diff --git a/Switch_Toolbox/Shader/Bfres/Normals.frag b/Switch_Toolbox/Shader/Bfres/Normals.frag new file mode 100644 index 00000000..0dd298c9 --- /dev/null +++ b/Switch_Toolbox/Shader/Bfres/Normals.frag @@ -0,0 +1,7 @@ +#version 330 core +out vec4 FragColor; + +void main() +{ + FragColor = vec4(1.0, 1.0, 0.0, 1.0); +} \ No newline at end of file diff --git a/Switch_Toolbox/Shader/Bfres/Normals.geom b/Switch_Toolbox/Shader/Bfres/Normals.geom new file mode 100644 index 00000000..a7482a0a --- /dev/null +++ b/Switch_Toolbox/Shader/Bfres/Normals.geom @@ -0,0 +1,25 @@ +#version 330 core +layout (triangles) in; +layout (line_strip, max_vertices = 6) out; + +in VS_OUT { + vec3 normal; +} gs_in[]; + +const float MAGNITUDE = 0.4; + +void GenerateLine(int index) +{ + gl_Position = gl_in[index].gl_Position; + EmitVertex(); + gl_Position = gl_in[index].gl_Position + vec4(gs_in[index].normal, 0.0) * MAGNITUDE; + EmitVertex(); + EndPrimitive(); +} + +void main() +{ + GenerateLine(0); // first vertex normal + GenerateLine(1); // second vertex normal + GenerateLine(2); // third vertex normal +} \ No newline at end of file diff --git a/Switch_Toolbox/Shader/Bfres/Normals.vert b/Switch_Toolbox/Shader/Bfres/Normals.vert new file mode 100644 index 00000000..d3940a22 --- /dev/null +++ b/Switch_Toolbox/Shader/Bfres/Normals.vert @@ -0,0 +1,29 @@ +#version 330 core + +in vec3 vPosition; +in vec3 vNormal; +in vec3 vTangent; +in vec3 vBitangent; +in vec2 vUV0; +in vec4 vColor; +in vec4 vBone; +in vec4 vWeight; +in vec2 vUV1; +in vec2 vUV2; +in vec3 vPosition2; +in vec3 vPosition3; + +out VS_OUT { + vec3 normal; +} vs_out; + +uniform mat4 projection; +uniform mat4 view; +uniform mat4 model; + +void main() +{ + gl_Position = projection * view * model * vec4(vPosition, 1.0); + mat3 normalMatrix = mat3(transpose(inverse(view * model))); + vs_out.normal = normalize(vec3(projection * vec4(normalMatrix * vNormal, 0.0))); +} \ No newline at end of file diff --git a/Switch_Toolbox/Shader/HDRSkyBox/HDRSkyBox.frag b/Switch_Toolbox/Shader/HDRSkyBox/HDRSkyBox.frag new file mode 100644 index 00000000..80d0578e --- /dev/null +++ b/Switch_Toolbox/Shader/HDRSkyBox/HDRSkyBox.frag @@ -0,0 +1,16 @@ +#version 330 core +out vec4 FragColor; + +in vec3 TexCoords; + +uniform samplerCube environmentMap; + +void main() +{ + vec3 envColor = textureLod(environmentMap, TexCoords, 0.0).rgb; + + envColor = envColor / (envColor + vec3(1.0)); + envColor = pow(envColor, vec3(1.0/2.2)); + + FragColor = vec4(envColor, 1.0); +} \ No newline at end of file diff --git a/Switch_Toolbox/Shader/HDRSkyBox/HDRSkyBox.vert b/Switch_Toolbox/Shader/HDRSkyBox/HDRSkyBox.vert new file mode 100644 index 00000000..e1543f87 --- /dev/null +++ b/Switch_Toolbox/Shader/HDRSkyBox/HDRSkyBox.vert @@ -0,0 +1,15 @@ +#version 330 core +layout (location = 0) in vec3 aPos; + +uniform mat4 projection; +uniform mat4 rotView; + +out vec3 TexCoords; + +void main() +{ + TexCoords = aPos; + vec4 clipPos = rotView * projection * vec4(aPos, 1.0); + + gl_Position = clipPos.xyww; +} \ No newline at end of file diff --git a/Switch_Toolbox/Shader/Legacy/BFRES.frag b/Switch_Toolbox/Shader/Legacy/BFRES.frag new file mode 100644 index 00000000..7b09c9e2 --- /dev/null +++ b/Switch_Toolbox/Shader/Legacy/BFRES.frag @@ -0,0 +1,36 @@ +#version 110 + +varying vec2 f_texcoord0; +varying vec2 f_texcoord1; +varying vec2 f_texcoord2; +varying vec2 f_texcoord3; + +varying vec3 objectPosition; + +varying vec3 normal; +varying vec3 viewNormal; +varying vec4 vertexColor; +varying vec3 tangent; +varying vec3 bitangent; + +varying vec3 boneWeightsColored; + +uniform sampler2D DiffuseMap; + + +uniform int isTransparent; + +#define gamma 2.2 + +void main() +{ + vec4 fragColor = vec4(vec3(0), 1); + vec4 diffuseMapColor = vec4(texture2D(DiffuseMap, f_texcoord0).rgb, 1); + fragColor.rgb += diffuseMapColor.rgb; + fragColor.a *= texture2D(DiffuseMap, f_texcoord0).a; + + if (isTransparent != 1) + fragColor.a = 1.0; + + gl_FragColor = fragColor; +} diff --git a/Switch_Toolbox/Shader/Legacy/BFRES.vert b/Switch_Toolbox/Shader/Legacy/BFRES.vert new file mode 100644 index 00000000..0f476b2c --- /dev/null +++ b/Switch_Toolbox/Shader/Legacy/BFRES.vert @@ -0,0 +1,50 @@ +#version 110 + +uniform mat4 mvpMatrix; + +attribute vec3 vPosition; +attribute vec3 vNormal; +attribute vec3 vTangent; +attribute vec3 vBitangent; +attribute vec2 vUV0; +attribute vec4 vColor; +attribute vec4 vBone; +attribute vec4 vWeight; +attribute vec2 vUV1; +attribute vec2 vUV2; +attribute vec3 vPosition2; +attribute vec3 vPosition3; + +varying vec2 f_texcoord0; +varying vec2 f_texcoord1; +varying vec2 f_texcoord2; +varying vec2 f_texcoord3; + +varying vec3 normal; +varying vec4 vertexColor; +varying vec3 tangent; +varying vec3 bitangent; + +// Shader Options +uniform vec4 gsys_bake_st0; +uniform vec4 gsys_bake_st1; + +// Skinning uniforms +uniform mat4 bones[200]; + //Meshes have a bone index and will use their transform depending on skin influence amount +uniform mat4 singleBoneBindTransform; +uniform int NoSkinning; +uniform int RigidSkinning; + +void main() +{ + gl_Position = mvpMatrix * vec4(vPosition.xyz, 1.0); + normal = vNormal; + f_texcoord0 = vUV0; + f_texcoord1 = vUV1; + f_texcoord2 = vUV1; + f_texcoord3 = vUV2; + tangent = vTangent; + bitangent = vBitangent; + vertexColor = vColor; +} \ No newline at end of file diff --git a/Switch_Toolbox/Shader/Utility/Utility.frag b/Switch_Toolbox/Shader/Utility/Utility.frag new file mode 100644 index 00000000..2e7c7b8f --- /dev/null +++ b/Switch_Toolbox/Shader/Utility/Utility.frag @@ -0,0 +1,21 @@ +#version 330 + +float Luminance(vec3 rgb) +{ + const vec3 W = vec3(0.2125, 0.7154, 0.0721); + return dot(rgb, W); +} + +// The hardware conversion doesn't work on all drivers. +// http://entropymine.com/imageworsener/srgbformula/ +float SrgbToLinear(float x) +{ + if (x < 0.03928) + return x * 0.0773993808; // 1.0 / 12.92 + else + return pow((x + 0.055) / 1.055, 2.4); +} + +vec3 SrgbToLinear(vec3 color) { + return vec3(SrgbToLinear(color.r), SrgbToLinear(color.g), SrgbToLinear(color.b)); +} diff --git a/Switch_Toolbox/Shader/Utility/Wireframe.frag b/Switch_Toolbox/Shader/Utility/Wireframe.frag new file mode 100644 index 00000000..df0ff32c --- /dev/null +++ b/Switch_Toolbox/Shader/Utility/Wireframe.frag @@ -0,0 +1,16 @@ +#version 330 + +float WireframeIntensity(vec3 distanceToEdges) { + float minDistance = min(min(distanceToEdges.x, distanceToEdges.y), distanceToEdges.z); + + // Constant wireframe thickness relative to the screen size. + float thickness = 0.5; + float smoothAmount = 0.5; + + float delta = fwidth(minDistance); + float edge0 = delta * thickness; + float edge1 = edge0 + (delta * smoothAmount); + float smoothedDistance = smoothstep(edge0, edge1, minDistance); + + return 1 - smoothedDistance; +} diff --git a/Switch_Toolbox/Switch_Toolbox.csproj b/Switch_Toolbox/Switch_Toolbox.csproj new file mode 100644 index 00000000..d6cb350a --- /dev/null +++ b/Switch_Toolbox/Switch_Toolbox.csproj @@ -0,0 +1,374 @@ + + + + + + Debug + AnyCPU + {E861C28B-B039-48F7-9A4F-C83F67C0ADDE} + WinExe + Switch_Toolbox + Switch_Toolbox + v4.6.2 + 512 + true + true + + + + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + Tool.ico + + + + False + ..\..\ConsoleApp1\BarsLibrary\bin\Release\BarsLibrary.dll + False + + + ..\..\..\..\Documents\Visual Studio 2017\Projects\WindowsFormsApp2\WindowsFormsApp2\Lib\BevelEngineArchive_Lib.dll + False + + + ..\..\..\..\Documents\Visual Studio 2017\Projects\WindowsFormsApp2\WindowsFormsApp2\Lib\ByamlExt.dll + False + + + ..\packages\Costura.Fody.3.1.4\lib\net46\Costura.dll + False + + + ..\packages\CsvHelper.8.0.0-beta01\lib\net45\CsvHelper.dll + False + + + ..\..\..\..\Documents\Visual Studio 2017\Projects\WindowsFormsApp2\WindowsFormsApp2\Lib\EditorCoreCommon.dll + False + + + ..\Switch_FileFormatsMain\Externals\NAudio.dll + False + + + ..\..\..\..\Documents\Visual Studio 2017\Projects\WindowsFormsApp2\WindowsFormsApp2\Lib\OpenTK.dll + False + + + ..\..\..\..\Documents\Visual Studio 2017\Projects\WindowsFormsApp2\WindowsFormsApp2\Lib\OpenTK.GLControl.dll + False + + + ..\..\..\..\Documents\Visual Studio 2017\Projects\WindowsFormsApp2\WindowsFormsApp2\Lib\SARCExt.dll + False + + + ..\..\..\..\Documents\Visual Studio 2017\Projects\WindowsFormsApp2\WindowsFormsApp2\Lib\SFGraphics.dll + False + + + ..\..\..\..\Documents\Visual Studio 2017\Projects\WindowsFormsApp2\WindowsFormsApp2\Lib\SFGraphics.Utils.dll + False + + + ..\..\..\..\Documents\Visual Studio 2017\Projects\WindowsFormsApp2\WindowsFormsApp2\Lib\Syroot.BinaryData.dll + False + + + ..\..\..\..\Documents\Visual Studio 2017\Projects\WindowsFormsApp2\WindowsFormsApp2\Lib\Syroot.Maths.dll + False + + + False + ..\Switch_FileFormatsMain\Externals\Syroot.NintenTools.NSW.Bfres.dll + False + + + False + ..\..\..\..\Documents\GitHub\Nintendo_Switch_BFRES_Library\src - Copy (2)\Syroot.NintenTools.Bntx\bin\Release\net45\Syroot.NintenTools.NSW.Bntx.dll + False + + + + + + + ..\packages\System.ValueTuple.4.5.0\lib\net461\System.ValueTuple.dll + False + + + + + + + + + + + + ..\Switch_FileFormatsMain\Externals\VGAudio.dll + False + + + ..\packages\DockPanelSuite.3.0.4\lib\net40\WeifenLuo.WinFormsUI.Docking.dll + False + + + ..\packages\DockPanelSuite.ThemeVS2015.3.0.4\lib\net40\WeifenLuo.WinFormsUI.Docking.ThemeVS2015.dll + False + + + + + + Form + + + Credits.cs + + + + Form + + + Settings.cs + + + Form + + + Startup Window.cs + + + Form + + + MainForm.cs + + + Form + + + PluginManager.cs + + + + + Credits.cs + + + Settings.cs + + + Startup Window.cs + + + MainForm.cs + + + PluginManager.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + + + PreserveNewest + + + PreserveNewest + + + + + Designer + + + + + + + + {29647ba5-2859-46f0-a99e-c3a387a9447a} + GL_Core + False + + + {96820047-2a39-4e5a-bfa4-e84fff5c66cf} + Switch_Toolbox_Library + False + + + {d82a2c08-2a65-43af-bda6-a36cc27aa003} + Updater + + + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + PreserveNewest + + + + + + + + + + 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/Switch_Toolbox/Tool.ico b/Switch_Toolbox/Tool.ico new file mode 100644 index 00000000..b8bae4b5 Binary files /dev/null and b/Switch_Toolbox/Tool.ico differ diff --git a/Switch_Toolbox/libzstd.dll b/Switch_Toolbox/libzstd.dll new file mode 100644 index 00000000..3ec45c69 Binary files /dev/null and b/Switch_Toolbox/libzstd.dll differ diff --git a/Switch_Toolbox/packages.config b/Switch_Toolbox/packages.config new file mode 100644 index 00000000..4f860e43 --- /dev/null +++ b/Switch_Toolbox/packages.config @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file