From 204426d2a3161da1497df919e93f3a487795d8ae Mon Sep 17 00:00:00 2001 From: Mentrillum Date: Tue, 7 Nov 2023 01:16:10 -0700 Subject: [PATCH] Init --- .github/FUNDING.yml | 2 - Form1.Designer.cs | 157 + Form1.cs | 2243 +++++++++++++ Form1.resx | 2417 ++++++++++++++ Program.cs | 2927 +---------------- SF2MConfigRewrite.csproj | 16 - SF2MConfigRewriteV2.csproj | 32 + ...nfigRewrite.sln => SF2MConfigRewriteV2.sln | 14 +- scripting/KeyValues.cs | 700 +++- scripting/Stocks.cs | 2116 +++++------- sf2m.ico | Bin 4286 -> 137338 bytes 11 files changed, 6340 insertions(+), 4284 deletions(-) delete mode 100644 .github/FUNDING.yml create mode 100644 Form1.Designer.cs create mode 100644 Form1.cs create mode 100644 Form1.resx delete mode 100644 SF2MConfigRewrite.csproj create mode 100644 SF2MConfigRewriteV2.csproj rename SF2MConfigRewrite.sln => SF2MConfigRewriteV2.sln (61%) diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml deleted file mode 100644 index f256925..0000000 --- a/.github/FUNDING.yml +++ /dev/null @@ -1,2 +0,0 @@ -patreon: Mentrillum -ko_fi: Mentrillum diff --git a/Form1.Designer.cs b/Form1.Designer.cs new file mode 100644 index 0000000..0dcae82 --- /dev/null +++ b/Form1.Designer.cs @@ -0,0 +1,157 @@ +namespace SF2MConfigRewriteV2 +{ + partial class FormMain + { + /// + /// 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(FormMain)); + openFileDialog1 = new OpenFileDialog(); + rewriteButton = new Button(); + configsList = new ListBox(); + openButton = new Button(); + textBox1 = new TextBox(); + progressBox = new TextBox(); + clearButton = new Button(); + SuspendLayout(); + // + // openFileDialog1 + // + openFileDialog1.FileName = "openFileDialog1"; + // + // rewriteButton + // + rewriteButton.BackgroundImageLayout = ImageLayout.Center; + rewriteButton.FlatAppearance.BorderColor = Color.White; + rewriteButton.FlatAppearance.BorderSize = 3; + rewriteButton.FlatStyle = FlatStyle.Flat; + rewriteButton.Font = new Font("Segoe UI", 27.75F, FontStyle.Bold, GraphicsUnit.Point); + rewriteButton.ForeColor = Color.White; + rewriteButton.Location = new Point(405, 198); + rewriteButton.Name = "rewriteButton"; + rewriteButton.Size = new Size(184, 96); + rewriteButton.TabIndex = 0; + rewriteButton.Text = "Rewrite"; + rewriteButton.UseVisualStyleBackColor = true; + rewriteButton.Click += rewriteButton_Click; + // + // configsList + // + configsList.BackColor = Color.Black; + configsList.ForeColor = Color.White; + configsList.FormattingEnabled = true; + configsList.ItemHeight = 15; + configsList.Location = new Point(27, 96); + configsList.Name = "configsList"; + configsList.Size = new Size(372, 334); + configsList.TabIndex = 2; + // + // openButton + // + openButton.BackgroundImageLayout = ImageLayout.Center; + openButton.FlatAppearance.BorderColor = Color.White; + openButton.FlatAppearance.BorderSize = 3; + openButton.FlatStyle = FlatStyle.Flat; + openButton.Font = new Font("Segoe UI", 27.75F, FontStyle.Bold, GraphicsUnit.Point); + openButton.ForeColor = Color.White; + openButton.Location = new Point(405, 96); + openButton.Name = "openButton"; + openButton.Size = new Size(184, 96); + openButton.TabIndex = 3; + openButton.Text = "Open"; + openButton.UseVisualStyleBackColor = true; + openButton.Click += openButton_Click; + // + // textBox1 + // + textBox1.BackColor = Color.Black; + textBox1.BorderStyle = BorderStyle.None; + textBox1.Font = new Font("Segoe UI", 15F, FontStyle.Bold, GraphicsUnit.Point); + textBox1.ForeColor = Color.White; + textBox1.Location = new Point(405, 404); + textBox1.Name = "textBox1"; + textBox1.Size = new Size(356, 27); + textBox1.TabIndex = 4; + textBox1.Text = "Back up your config files just in case"; + // + // progressBox + // + progressBox.BackColor = Color.Black; + progressBox.BorderStyle = BorderStyle.None; + progressBox.Font = new Font("Segoe UI", 15F, FontStyle.Bold, GraphicsUnit.Point); + progressBox.ForeColor = Color.White; + progressBox.Location = new Point(405, 63); + progressBox.Name = "progressBox"; + progressBox.ReadOnly = true; + progressBox.Size = new Size(356, 27); + progressBox.TabIndex = 5; + // + // clearButton + // + clearButton.BackgroundImageLayout = ImageLayout.Center; + clearButton.FlatAppearance.BorderColor = Color.White; + clearButton.FlatAppearance.BorderSize = 3; + clearButton.FlatStyle = FlatStyle.Flat; + clearButton.Font = new Font("Segoe UI", 27.75F, FontStyle.Bold, GraphicsUnit.Point); + clearButton.ForeColor = Color.White; + clearButton.Location = new Point(405, 302); + clearButton.Name = "clearButton"; + clearButton.Size = new Size(184, 96); + clearButton.TabIndex = 6; + clearButton.Text = "Clear"; + clearButton.UseVisualStyleBackColor = true; + clearButton.Click += clearButton_Click; + // + // FormMain + // + AutoScaleDimensions = new SizeF(7F, 15F); + AutoScaleMode = AutoScaleMode.Font; + BackColor = Color.Black; + ClientSize = new Size(800, 450); + Controls.Add(clearButton); + Controls.Add(progressBox); + Controls.Add(textBox1); + Controls.Add(openButton); + Controls.Add(configsList); + Controls.Add(rewriteButton); + Icon = (Icon)resources.GetObject("$this.Icon"); + Name = "FormMain"; + Text = "SF2M Config Rewriter"; + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private OpenFileDialog openFileDialog1; + private Button rewriteButton; + private ListBox configsList; + private Button openButton; + private TextBox textBox1; + private TextBox progressBox; + private Button clearButton; + } +} \ No newline at end of file diff --git a/Form1.cs b/Form1.cs new file mode 100644 index 0000000..ce95156 --- /dev/null +++ b/Form1.cs @@ -0,0 +1,2243 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Runtime.Serialization; +using System.Text; +using Stocks; +using static System.Net.Mime.MediaTypeNames; +using static Stocks.Stock; +using SF2MConfigRewriteV2.Keys; +using System.Xml.Linq; +using System.DirectoryServices.ActiveDirectory; +using System.Windows.Forms; +using static System.Collections.Specialized.BitVector32; + +namespace SF2MConfigRewriteV2 +{ + public partial class FormMain : Form + { + List files = new List(); + public FormMain() + { + InitializeComponent(); + } + + private void openButton_Click(object sender, EventArgs e) + { + OpenFileDialog ofd = new OpenFileDialog(); + ofd.InitialDirectory = "c:\\"; + ofd.Filter = "Config files (*.cfg)|*.cfg"; + ofd.FilterIndex = 0; + ofd.RestoreDirectory = true; + ofd.Multiselect = true; + if (ofd.ShowDialog() == DialogResult.OK) + { + files.Clear(); + foreach (string s in ofd.FileNames) + { + files.Add(s); + } + foreach (string s in ofd.SafeFileNames) + { + configsList.Items.Add(s); + } + } + } + + private void rewriteButton_Click(object sender, EventArgs e) + { + if (configsList.Items.Count <= 0) + { + return; + } + + KeyValues kv = new KeyValues(); + List globalLine; + int index = 0; + for (int file = 0; file < configsList.Items.Count; file++) + { + string fileName = files[file]; + progressBox.Text = "Rewriting " + configsList.Items[file]; + globalLine = File.ReadAllLines(fileName).ToList(); + // Delete any unused key values + for (int i = 0; i < globalLine.Count; i++) + { + if (globalLine[i].Contains("\"jump_speed\"") || globalLine[i].Contains("\"airspeed\"") || globalLine[i].Contains("\"jump_cooldown\"") || + globalLine[i].Contains("\"random_attacks\"") || globalLine[i].Contains("\"enable_boss_tilting\"") || globalLine[i].Contains("\"think_time_min\"") + || globalLine[i].Contains("\"think_time_max\"") || globalLine[i].Contains("\"anger_start\"") || globalLine[i].Contains("\"anger_page_time_diff\"") || globalLine[i].Contains("\"anger_page_add\"") || globalLine[i].Contains("\"appear_chance_threshold\"") || globalLine[i].Contains("\"appear_chance_min\"") + || globalLine[i].Contains("\"appear_chance_max\"") || globalLine[i].Contains("\"proxies_teleport_enabled\"") + || globalLine[i].Contains("\"attack_props\"") || globalLine[i].Contains("\"attack_damageforce\"") || globalLine[i].Contains("\"attack_damage_vs_props\"") || globalLine[i].Contains("\"use_engine_sounds\"") || globalLine[i].Contains("\"difficulty_affects_animations\"") + || globalLine[i].Contains("\"multi_miss_sounds\"") || globalLine[i].Contains("\"multi_hit_sounds\"") || globalLine[i].Contains("\"multi_attack_sounds\"") || + globalLine[i].Contains("\"speed_max\"") || globalLine[i].Contains("\"walkspeed_max\"") || globalLine[i].Contains("\"use_alert_walking_animation\"") || + globalLine[i].Contains("\"spawn_animation\"") || globalLine[i].Contains("\"use_chase_initial_animation\"") + || globalLine[i].Contains("\"chase_persistency_time_init\"") || globalLine[i].Contains("\"chase_persistency_time_init_attack\"") + || globalLine[i].Contains("\"chase_persistency_time_add_attack\"") || globalLine[i].Contains("\"chase_persistency_time_init_newtarget\"") + || globalLine[i].Contains("\"chase_persistency_time_add_newtarget\"") || globalLine[i].Contains("\"chase_persistency_time_add_visible_min\"") + || globalLine[i].Contains("\"chase_persistency_time_add_visible_max\"") || globalLine[i].Contains("\"chase_persistency_time_init_stun\"") + || globalLine[i].Contains("\"chase_persistency_time_add_stun\"") || globalLine[i].Contains("\"walkspeed_max_hard\"") + || globalLine[i].Contains("\"walkspeed_max_insane\"") || globalLine[i].Contains("\"walkspeed_max_nightmare\"") + || globalLine[i].Contains("\"walkspeed_max_apollyon\"") || globalLine[i].Contains("\"speed_max_hard\"") || globalLine[i].Contains("\"speed_max_insane\"") + || globalLine[i].Contains("\"speed_max_nightmare\"") || globalLine[i].Contains("\"speed_max_apollyon\"")) + { + globalLine.RemoveAt(i); + i--; + if (!globalLine[i].Contains('\"') && !globalLine[i].Contains('/') && !globalLine[i].Contains('{') && !globalLine[i].Contains('}')) + { + globalLine.RemoveAt(i); + i--; + } + } + } + + for (int i = 0; i < globalLine.Count; i++) + { + if (globalLine[i].Contains("\"cancel_distance\"")) + { + globalLine[i] = globalLine[i].Replace("\"cancel_distance\"", "\"cancel_distance_max\""); + } + } + File.WriteAllLines(fileName, globalLine); + + string text = File.ReadAllText(fileName); + + ReplaceAnimationNames(fileName, text, "animation_idle"); + + ReplaceAnimationNames(fileName, text, "animation_walk"); + + ReplaceAnimationNames(fileName, text, "animation_walkalert"); + + ReplaceAnimationNames(fileName, text, "animation_run"); + + ReplaceAnimationNames(fileName, text, "animation_attack"); + + ReplaceAnimationNames(fileName, text, "animation_stun"); + + ReplaceAnimationNames(fileName, text, "animation_shoot"); + + ReplaceAnimationNames(fileName, text, "animation_deathcam"); + + ReplaceAnimationNames(fileName, text, "animation_chaseinitial"); + + ReplaceAnimationNames(fileName, text, "animation_spawn"); + + ReplaceAnimationNames(fileName, text, "animation_crawlwalk"); + + ReplaceAnimationNames(fileName, text, "animation_crawlrun"); + + ReplaceAnimationNames(fileName, text, "animation_heal"); + + ReplaceAnimationNames(fileName, text, "animation_fleestart"); + + ReplaceAnimationNames(fileName, text, "animation_rage"); + + ReplaceAnimationNames(fileName, text, "animation_jump"); + + ReplaceAnimationNames(fileName, text, "animation_death"); + globalLine = File.ReadAllLines(fileName).ToList(); + + kv.ReadFromFile(fileName); + + if (kv.JumpToKey("animations")) + { + if (kv.JumpToKey("walkalert")) + { + List walkAnimations = new List(); + StoreAnimationData(ref walkAnimations, kv); + + int bracket = 0, endIndex = 0; + index = 0; + index = kv.GetSectionIndex("walkalert"); + endIndex = index; + while (!globalLine[endIndex].Contains('{')) + { + endIndex++; + } + endIndex++; + while (bracket >= 0) + { + if (globalLine[endIndex].Contains('}')) + { + bracket--; + } + else if (globalLine[endIndex].Contains('{')) + { + bracket++; + } + endIndex++; + } + + while (index != endIndex) + { + globalLine.RemoveAt(index); + endIndex--; + } + kv.GoBack(); + + index = kv.GetSectionIndex("animations"); + InsertKeyValue(ref globalLine, ref index, "\"postures\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertKeyValue(ref globalLine, ref index, "\"alert\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertKeyValue(ref globalLine, ref index, "\"conditions\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertKeyValue(ref globalLine, ref index, "\"on_alert\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + + InsertKeyValue(ref globalLine, ref index, "\"animations\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertAnimationSection(ref globalLine, ref index, "walk", walkAnimations, kv); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + InsertKeyValue(ref globalLine, ref index, ""); + + File.WriteAllLines(fileName, globalLine); + kv.ReadFromFile(fileName); + } + else + { + kv.GoBack(); + } + } + + bool copiesAlert = false, companionsAlert = false; + if (kv.JumpToKey("attributes")) + { + if (kv.JumpToKey("alert companions")) + { + companionsAlert = true; + kv.GoBack(); + index = kv.GetSectionIndex("alert companions"); + do + { + globalLine.RemoveAt(index); + } + while (!globalLine[index].Contains('}')); + globalLine.RemoveAt(index); + } + + if (kv.JumpToKey("alert copies")) + { + copiesAlert = true; + kv.GoBack(); + index = kv.GetSectionIndex("alert copies"); + do + { + globalLine.RemoveAt(index); + } + while (!globalLine[index].Contains('}')); + globalLine.RemoveAt(index); + } + + kv.GoBack(); + + if (copiesAlert || companionsAlert) + { + index = kv.GetSectionIndex("attributes"); + + InsertKeyValue(ref globalLine, ref index, "\"chase\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertKeyValue(ref globalLine, ref index, "\"chase_together\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"enabled\" \"1\""); + if (copiesAlert) + { + InsertKeyValue(ref globalLine, ref index, "\"copies\" \"1\""); + } + if (companionsAlert) + { + InsertKeyValue(ref globalLine, ref index, "\"companions\" \"1\""); + } + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + InsertKeyValue(ref globalLine, ref index, ""); + } + + File.WriteAllLines(fileName, globalLine); + kv.ReadFromFile(fileName); + } + + if (kv.GetKeyValue("shockwave", false)) + { + ShockwaveData shockwaveData = new ShockwaveData(); + shockwaveData.Enabled = true; + kv.GetDifficultyValues("shockwave_height", out shockwaveData.Height, shockwaveData.Height); + kv.GetDifficultyValues("shockwave_range", out shockwaveData.Range, shockwaveData.Range); + kv.GetDifficultyValues("shockwave_drain", out shockwaveData.DrainAmount, shockwaveData.DrainAmount); + kv.GetDifficultyValues("shockwave_force", out shockwaveData.Force, shockwaveData.Force); + shockwaveData.Stun = kv.GetKeyValue("shockwave_stun", false); + kv.GetDifficultyValues("shockwave_stun_duration", out shockwaveData.StunDuration, shockwaveData.StunDuration); + kv.GetDifficultyValues("shockwave_stun_slowdown", out shockwaveData.StunSlowdown, shockwaveData.StunSlowdown); + InsertAttackIndexes(ref shockwaveData.AttackIndexex, kv.GetKeyValue("shockwave_attack_index", "1")); + shockwaveData.Width1 = kv.GetKeyValue("shockwave_width_1", shockwaveData.Width1); + shockwaveData.Width2 = kv.GetKeyValue("shockwave_width_2", shockwaveData.Width2); + shockwaveData.Amplitude = kv.GetKeyValue("shockwave_amplitude", shockwaveData.Amplitude); + float[] color3 = new float[3]; + for (int i2 = 0; i2 < 3; i2++) + { + color3[i2] = shockwaveData.Color1[i2]; + } + kv.GetKeyValue("shockwave_color_1", out color3, color3); + for (int i2 = 0; i2 < 3; i2++) + { + shockwaveData.Color1[i2] = Convert.ToInt32(Math.Round(color3[i2])); + } + for (int i2 = 0; i2 < 3; i2++) + { + color3[i2] = shockwaveData.Color2[i2]; + } + kv.GetKeyValue("shockwave_color_2", out color3, color3); + for (int i2 = 0; i2 < 3; i2++) + { + shockwaveData.Color2[i2] = Convert.ToInt32(Math.Round(color3[i2])); + } + shockwaveData.Color1[3] = kv.GetKeyValue("shockwave_alpha_1", shockwaveData.Color1[3]); + shockwaveData.Color2[3] = kv.GetKeyValue("shockwave_alpha_2", shockwaveData.Color2[3]); + shockwaveData.BeamSprite = kv.GetKeyValue("shockwave_beam_sprite", shockwaveData.BeamSprite); + shockwaveData.HaloSprite = kv.GetKeyValue("shockwave_halo_sprite", shockwaveData.HaloSprite); + if (kv.JumpToKey("attacks")) + { + int atkIndex = 0; + if (kv.GotoFirstSubKey()) + { + do + { + atkIndex++; + if (!shockwaveData.AttackIndexex.Contains(atkIndex)) + { + continue; + } + string section = kv.GetSectionName(); + index = kv.GetSectionIndex(section); + int bracket = 0, endIndex = index; + while (!globalLine[endIndex].Contains('{')) + { + endIndex++; + } + endIndex++; + while (bracket >= 0) + { + if (globalLine[endIndex].Contains('}')) + { + bracket--; + } + else if (globalLine[endIndex].Contains('{')) + { + bracket++; + } + endIndex++; + } + endIndex--; + InsertKeyValue(ref globalLine, ref endIndex, ""); + InsertKeyValue(ref globalLine, ref endIndex, "\"shockwave\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + + float height = 80.0f, range = 200.0f, force = 600.0f, drain = 0.0f; + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (shockwaveData.Height[i2] != height) + { + height = shockwaveData.Height[i2]; + InsertKeyValue(ref globalLine, ref endIndex, "\"" + kv.GetProfileKeyWithDifficultySuffix("height", (Difficulty)i2) + "\" \"" + kv.FormatFloat(height) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (shockwaveData.Range[i2] != range) + { + range = shockwaveData.Range[i2]; + InsertKeyValue(ref globalLine, ref endIndex, "\"" + kv.GetProfileKeyWithDifficultySuffix("range", (Difficulty)i2) + "\" \"" + kv.FormatFloat(range) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (shockwaveData.Force[i2] != force) + { + force = shockwaveData.Force[i2]; + InsertKeyValue(ref globalLine, ref endIndex, "\"" + kv.GetProfileKeyWithDifficultySuffix("force", (Difficulty)i2) + "\" \"" + kv.FormatFloat(force) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (shockwaveData.DrainAmount[i2] != drain) + { + drain = shockwaveData.DrainAmount[i2]; + InsertKeyValue(ref globalLine, ref endIndex, "\"" + kv.GetProfileKeyWithDifficultySuffix("battery_drain", (Difficulty)i2) + "\" \"" + kv.FormatFloat(drain) + "\""); + } + } + + if (shockwaveData.Stun) + { + InsertKeyValue(ref globalLine, ref endIndex, ""); + InsertKeyValue(ref globalLine, ref endIndex, "\"apply_conditions\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + + InsertKeyValue(ref globalLine, ref endIndex, "\"stun\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + + float duration = 8.0f, slowdown = 0.5f; + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (shockwaveData.StunDuration[i2] != duration) + { + duration = shockwaveData.StunDuration[i2]; + InsertKeyValue(ref globalLine, ref endIndex, "\"" + kv.GetProfileKeyWithDifficultySuffix("duration", (Difficulty)i2) + "\" \"" + kv.FormatFloat(duration) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (shockwaveData.StunSlowdown[i2] != slowdown) + { + slowdown = shockwaveData.StunSlowdown[i2]; + InsertKeyValue(ref globalLine, ref endIndex, "\"" + kv.GetProfileKeyWithDifficultySuffix("slow_multiplier", (Difficulty)i2) + "\" \"" + kv.FormatFloat(slowdown) + "\""); + } + } + InsertKeyValue(ref globalLine, ref endIndex, "}"); + + InsertKeyValue(ref globalLine, ref endIndex, "}"); + } + + InsertKeyValue(ref globalLine, ref endIndex, ""); + InsertKeyValue(ref globalLine, ref endIndex, "\"effects\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + + InsertKeyValue(ref globalLine, ref endIndex, "\"ring_1\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + InsertKeyValue(ref globalLine, ref endIndex, "\"type\" \"te_beamring\""); + InsertKeyValue(ref globalLine, ref endIndex, ""); + string insert = string.Empty; + for (int i2 = 0; i2 < shockwaveData.Color1.Length; i2++) + { + insert += shockwaveData.Color1[i2].ToString(); + if (i2 != shockwaveData.Color1.Length - 1) + { + insert += " "; + } + } + InsertKeyValue(ref globalLine, ref endIndex, "\"color\" \"" + insert + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"beam_sprite\" \"" + shockwaveData.BeamSprite + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"halo_sprite\" \"" + shockwaveData.HaloSprite + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"origin\" \"0 0 5\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"width\" \"" + kv.FormatFloat(shockwaveData.Width1) + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"end_radius\" \"" + kv.FormatFloat(shockwaveData.Range[1]) + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"amplitude\" \"" + kv.FormatFloat(shockwaveData.Amplitude) + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"framerate\" \"30\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"lifetime\" \"0.2\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"speed\" \"" + Convert.ToInt32(Math.Floor(shockwaveData.Range[1])) + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "}"); + InsertKeyValue(ref globalLine, ref endIndex, ""); + + InsertKeyValue(ref globalLine, ref endIndex, "\"ring_2\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + InsertKeyValue(ref globalLine, ref endIndex, "\"type\" \"te_beamring\""); + InsertKeyValue(ref globalLine, ref endIndex, ""); + insert = string.Empty; + for (int i2 = 0; i2 < shockwaveData.Color2.Length; i2++) + { + insert += shockwaveData.Color2[i2].ToString(); + if (i2 != shockwaveData.Color2.Length - 1) + { + insert += " "; + } + } + InsertKeyValue(ref globalLine, ref endIndex, "\"color\" \"" + insert + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"beam_sprite\" \"" + shockwaveData.BeamSprite + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"halo_sprite\" \"" + shockwaveData.HaloSprite + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"origin\" \"0 0 5\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"width\" \"" + kv.FormatFloat(shockwaveData.Width2) + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"end_radius\" \"" + kv.FormatFloat(shockwaveData.Range[1]) + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"amplitude\" \"" + kv.FormatFloat(shockwaveData.Amplitude) + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"framerate\" \"30\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"lifetime\" \"0.2\""); + InsertKeyValue(ref globalLine, ref endIndex, "\"speed\" \"" + Convert.ToInt32(Math.Floor(shockwaveData.Range[1])) + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "}"); + + InsertKeyValue(ref globalLine, ref endIndex, "}"); + + InsertKeyValue(ref globalLine, ref endIndex, "}"); + kv.ReadFromFile(globalLine); + kv.JumpToKey("attacks"); + kv.JumpToKey(section); + } + while (kv.GotoNextKey()); + + kv.GoBack(); + } + kv.GoBack(); + } + for (int i = 0; i < globalLine.Count; i++) + { + if (globalLine[i].Contains("\"shockwave\" \"1\"") || globalLine[i].Contains("\"shockwave_")) + { + globalLine.RemoveAt(i); + i--; + } + } + File.WriteAllLines(fileName, globalLine); + kv.ReadFromFile(fileName); + } + + if (kv.GetKeyValue("player_damage_effects", false)) + { + List datas = new List(); + int stunType = kv.GetKeyValue("player_stun_type", 0); + bool attach = kv.GetKeyValue("player_attach_particle", true); + if (kv.GetKeyValue("player_jarate_on_hit", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Jarate); + effect.Particle = "peejar_impact"; + effect.Sound = ")weapons/jar_single.wav"; + kv.GetDifficultyValues("player_jarate_duration", out effect.Duration, effect.Duration); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_jarate_attack_indexs", "1")); + effect.Particle = kv.GetKeyValue("player_jarate_particle", effect.Particle); + effect.Beam = kv.GetKeyValue("player_jarate_beam_particle", false); + effect.Sound = kv.GetKeyValue("player_jarate_sound", effect.Sound); + effect.AttachParticle = attach; + datas.Add(effect); + } + + if (kv.GetKeyValue("player_milk_on_hit", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Milk); + effect.Particle = "peejar_impact"; + effect.Sound = ")weapons/jar_single.wav"; + kv.GetDifficultyValues("player_milk_duration", out effect.Duration, effect.Duration); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_milk_attack_indexs", "1")); + effect.Particle = kv.GetKeyValue("player_milk_particle", effect.Particle); + effect.Beam = kv.GetKeyValue("player_milk_beam_particle", false); + effect.Sound = kv.GetKeyValue("player_milk_sound", effect.Sound); + effect.AttachParticle = attach; + datas.Add(effect); + } + + if (kv.GetKeyValue("player_gas_on_hit", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Gas); + effect.Particle = "peejar_impact"; + effect.Sound = ")weapons/jar_single.wav"; + kv.GetDifficultyValues("player_gas_duration", out effect.Duration, effect.Duration); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_gas_attack_indexs", "1")); + effect.Particle = kv.GetKeyValue("player_gas_particle", effect.Particle); + effect.Beam = kv.GetKeyValue("player_gas_beam_particle", false); + effect.Sound = kv.GetKeyValue("player_gas_sound", effect.Sound); + effect.AttachParticle = attach; + datas.Add(effect); + } + + if (kv.GetKeyValue("player_mark_on_hit", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Mark); + kv.GetDifficultyValues("player_mark_duration", out effect.Duration, effect.Duration); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_mark_attack_indexs", "1")); + datas.Add(effect); + } + + if (kv.GetKeyValue("player_silent_mark_on_hit", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Mark); + kv.GetDifficultyValues("player_silent_mark_duration", out effect.Duration, effect.Duration); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_silent_mark_attack_indexs", "1")); + effect.MarkSilent = true; + datas.Add(effect); + } + + if (kv.GetKeyValue("player_ignite_on_hit", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Ignite); + kv.GetDifficultyValues("player_ignite_duration", out effect.Duration, effect.Duration); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_ignite_attack_indexs", "1")); + datas.Add(effect); + } + + if (kv.GetKeyValue("player_bleed_on_hit", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Bleed); + kv.GetDifficultyValues("player_bleed_duration", out effect.Duration, effect.Duration); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_bleed_attack_indexs", "1")); + datas.Add(effect); + } + + if (kv.GetKeyValue("player_smite_on_hit", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Smite); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_smite_attack_indexs", "1")); + effect.SmiteMessage = kv.GetKeyValue("player_smite_message", false); + kv.GetDifficultyValues("player_smite_damage", out effect.SmiteDamage, effect.SmiteDamage); + kv.GetDifficultyValues("player_smite_damage_type", out effect.SmiteDamageType, effect.SmiteDamageType); + effect.SmiteSound = kv.GetKeyValue("player_smite_sound", effect.SmiteSound); + effect.SmiteColor[0] = kv.GetKeyValue("player_smite_color_r", effect.SmiteColor[0]); + effect.SmiteColor[1] = kv.GetKeyValue("player_smite_color_g", effect.SmiteColor[1]); + effect.SmiteColor[2] = kv.GetKeyValue("player_smite_color_b", effect.SmiteColor[2]); + effect.SmiteColor[3] = kv.GetKeyValue("player_smite_transparency", effect.SmiteColor[3]); + datas.Add(effect); + } + + if (kv.GetKeyValue("player_stun_on_hit", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Stun); + effect.Particle = "xms_icicle_melt"; + effect.Sound = ")weapons/icicle_freeze_victim_01.wav"; + kv.GetDifficultyValues("player_stun_duration", out effect.Duration, effect.Duration); + kv.GetDifficultyValues("player_stun_slowdown", out effect.StunSlowdown, effect.StunSlowdown); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_stun_attack_indexs", "1")); + effect.Particle = kv.GetKeyValue("player_stun_particle", effect.Particle); + effect.Beam = kv.GetKeyValue("player_stun_beam_particle", false); + effect.Sound = kv.GetKeyValue("player_stun_sound", effect.Sound); + effect.AttachParticle = attach; + switch (stunType) + { + case 0: + effect.StunFlag = "slow"; + break; + case 1: + effect.StunFlag = "slow"; + break; + case 2: + effect.StunFlag = "loser"; + break; + case 3: + effect.StunFlag = "stuck no_fx"; + break; + case 4: + effect.StunFlag = "boo"; + break; + } + datas.Add(effect); + } + + if (kv.GetKeyValue("player_electric_slow_on_hit", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Stun); + effect.Particle = "electrocuted_gibbed_red"; + effect.Sound = string.Empty; + kv.GetDifficultyValues("player_electric_slow_duration", out effect.Duration, effect.Duration); + kv.GetDifficultyValues("player_electric_slow_slowdown", out effect.StunSlowdown, effect.StunSlowdown); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_electrocute_attack_indexs", "1")); + effect.Particle = kv.GetKeyValue("player_electric_red_particle", effect.Particle); + effect.Beam = kv.GetKeyValue("player_electric_beam_particle", false); + effect.AttachParticle = attach; + switch (stunType) + { + case 0: + effect.StunFlag = "slow"; + break; + case 1: + effect.StunFlag = "slow"; + break; + case 2: + effect.StunFlag = "loser"; + break; + case 3: + effect.StunFlag = "stuck no_fx"; + break; + case 4: + effect.StunFlag = "boo"; + break; + } + datas.Add(effect); + } + + if (kv.GetKeyValue("player_damage_random_effects", false)) + { + DamageEffectData effect = new DamageEffectData(DamageType.Random); + kv.GetDifficultyValues("player_random_duration", out effect.Duration, effect.Duration); + kv.GetDifficultyValues("player_random_slowdown", out effect.StunSlowdown, effect.StunSlowdown); + InsertAttackIndexes(ref effect.AttackIndexex, kv.GetKeyValue("player_random_attack_indexes", "1")); + switch (kv.GetKeyValue("player_random_stun_type", 0)) + { + case 0: + effect.StunFlag = "slow"; + break; + case 1: + effect.StunFlag = "slow"; + break; + case 2: + effect.StunFlag = "loser"; + break; + case 3: + effect.StunFlag = "stuck no_fx"; + break; + case 4: + effect.StunFlag = "boo"; + break; + } + datas.Add(effect); + } + + if (kv.JumpToKey("attacks")) + { + int atkIndex = 0; + if (kv.GotoFirstSubKey()) + { + do + { + atkIndex++; + bool skip = true; + for (int i = 0; i < datas.Count; i++) + { + if (datas[i].AttackIndexex.Contains(atkIndex)) + { + skip = false; + break; + } + } + if (skip) + { + continue; + } + string section = kv.GetSectionName(); + index = kv.GetSectionIndex(section); + int bracket = 0, endIndex = index; + while (!globalLine[endIndex].Contains('{')) + { + endIndex++; + } + endIndex++; + while (bracket >= 0) + { + if (globalLine[endIndex].Contains('}')) + { + bracket--; + } + else if (globalLine[endIndex].Contains('{')) + { + bracket++; + } + endIndex++; + } + endIndex--; + InsertKeyValue(ref globalLine, ref endIndex, ""); + InsertKeyValue(ref globalLine, ref endIndex, "\"apply_conditions\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + bool addSpace = false; + + for (int i = 0; i < datas.Count; i++) + { + if (!datas[i].AttackIndexex.Contains(atkIndex) || datas[i].Type == DamageType.Invalid) + { + continue; + } + if (addSpace) + { + InsertKeyValue(ref globalLine, ref endIndex, ""); + } + addSpace = true; + switch (datas[i].Type) + { + case DamageType.Jarate: + InsertKeyValue(ref globalLine, ref endIndex, "\"jarate\""); + break; + + case DamageType.Milk: + InsertKeyValue(ref globalLine, ref endIndex, "\"milk\""); + break; + + case DamageType.Gas: + InsertKeyValue(ref globalLine, ref endIndex, "\"gas\""); + break; + + case DamageType.Ignite: + InsertKeyValue(ref globalLine, ref endIndex, "\"ignite\""); + break; + + case DamageType.Mark: + InsertKeyValue(ref globalLine, ref endIndex, "\"mark\""); + break; + + case DamageType.Bleed: + InsertKeyValue(ref globalLine, ref endIndex, "\"bleed\""); + break; + + case DamageType.Smite: + InsertKeyValue(ref globalLine, ref endIndex, "\"smite\""); + break; + + case DamageType.Stun: + InsertKeyValue(ref globalLine, ref endIndex, "\"stun\""); + break; + + case DamageType.Random: + InsertKeyValue(ref globalLine, ref endIndex, "\"random\""); + break; + } + InsertKeyValue(ref globalLine, ref endIndex, "{"); + + float duration = 8.0f, slowdown = 0.5f, damage = 9001.0f; + int damageType = 1048576; + int[] color = { 255, 255, 255, 255 }; + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (datas[i].Duration[i2] != duration) + { + duration = datas[i].Duration[i2]; + InsertKeyValue(ref globalLine, ref endIndex, "\"" + kv.GetProfileKeyWithDifficultySuffix("duration", (Difficulty)i2) + "\" \"" + kv.FormatFloat(duration) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (datas[i].StunSlowdown[i2] != slowdown) + { + slowdown = datas[i].StunSlowdown[i2]; + InsertKeyValue(ref globalLine, ref endIndex, "\"" + kv.GetProfileKeyWithDifficultySuffix("slow_multiplier", (Difficulty)i2) + "\" \"" + kv.FormatFloat(slowdown) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (datas[i].SmiteDamage[i2] != damage) + { + damage = datas[i].SmiteDamage[i2]; + InsertKeyValue(ref globalLine, ref endIndex, "\"" + kv.GetProfileKeyWithDifficultySuffix("damage", (Difficulty)i2) + "\" \"" + kv.FormatFloat(damage) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (datas[i].SmiteDamageType[i2] != damageType) + { + damageType = datas[i].SmiteDamageType[i2]; + InsertKeyValue(ref globalLine, ref endIndex, "\"" + kv.GetProfileKeyWithDifficultySuffix("damagetype", (Difficulty)i2) + "\" \"" + damageType + "\""); + } + } + + for (int i2 = 0; i2 < 4; i2++) + { + if (datas[i].SmiteColor[i2] != color[i2]) + { + string insert = string.Empty; + for (int i3 = 0; i3 < datas[i].SmiteColor.Length; i3++) + { + insert += datas[i].SmiteColor[i3].ToString(); + if (i3 != datas[i].SmiteColor.Length - 1) + { + insert += " "; + } + } + InsertKeyValue(ref globalLine, ref endIndex, "\"color\" \"" + insert + "\""); + break; + } + } + + + if (datas[i].SmiteMessage) + { + InsertKeyValue(ref globalLine, ref endIndex, "\"message\" \"1\""); + } + + if (datas[i].SmiteSound != ")ambient/explosions/explode_9.wav" && datas[i].SmiteSound != "ambient/explosions/explode_9.wav") + { + InsertKeyValue(ref globalLine, ref endIndex, "\"hit_sound\" \"" + datas[i].SmiteSound + "\""); + } + + if (datas[i].MarkSilent) + { + InsertKeyValue(ref globalLine, ref endIndex, "\"silent\" \"1\""); + } + + if (datas[i].StunFlag != "slow") + { + InsertKeyValue(ref globalLine, ref endIndex, "\"flags\" \"" + datas[i].StunFlag + "\""); + } + + if (datas[i].Type == DamageType.Random) + { + InsertKeyValue(ref globalLine, ref endIndex, "\"random_types\" \"ignite gas bleed mark jarate milk stun\""); + } + + if (datas[i].Sound != string.Empty) + { + InsertKeyValue(ref globalLine, ref endIndex, ""); + InsertKeyValue(ref globalLine, ref endIndex, "\"sounds\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + + InsertKeyValue(ref globalLine, ref endIndex, "\"paths\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + InsertKeyValue(ref globalLine, ref endIndex, "\"1\" \"" + datas[i].Sound + "\""); + InsertKeyValue(ref globalLine, ref endIndex, "}"); + + InsertKeyValue(ref globalLine, ref endIndex, "}"); + } + + if (datas[i].Particle != string.Empty) + { + InsertKeyValue(ref globalLine, ref endIndex, ""); + InsertKeyValue(ref globalLine, ref endIndex, "\"particles\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + + InsertKeyValue(ref globalLine, ref endIndex, "\"base\""); + InsertKeyValue(ref globalLine, ref endIndex, "{"); + InsertKeyValue(ref globalLine, ref endIndex, "\"particle\" \"" + datas[i].Particle + "\""); + if (!datas[i].AttachParticle) + { + InsertKeyValue(ref globalLine, ref endIndex, "\"beam\" \"0\""); + } + if (datas[i].Beam) + { + InsertKeyValue(ref globalLine, ref endIndex, "\"beam\" \"1\""); + } + InsertKeyValue(ref globalLine, ref endIndex, "}"); + + InsertKeyValue(ref globalLine, ref endIndex, "}"); + } + InsertKeyValue(ref globalLine, ref endIndex, "}"); + } + + InsertKeyValue(ref globalLine, ref endIndex, "}"); + + kv.ReadFromFile(globalLine); + kv.JumpToKey("attacks"); + kv.JumpToKey(section); + } + while (kv.GotoNextKey()); + + kv.GoBack(); + } + kv.GoBack(); + } + + for (int i = 0; i < globalLine.Count; i++) + { + if (globalLine[i].Contains("\"player_damage_effects\"") || globalLine[i].Contains("\"player_jarate_") || globalLine[i].Contains("\"player_milk_") || globalLine[i].Contains("\"player_ignite_") || globalLine[i].Contains("\"player_stun_") || globalLine[i].Contains("\"player_smite_") || globalLine[i].Contains("\"player_electric_") || globalLine[i].Contains("\"player_electrocute_") || globalLine[i].Contains("\"player_bleed_") || globalLine[i].Contains("\"player_attach_particle\"") || globalLine[i].Contains("\"player_damage_random_effects\"") || globalLine[i].Contains("\"player_random_") || globalLine[i].Contains("\"player_gas_") || globalLine[i].Contains("\"player_mark_") || globalLine[i].Contains("\"player_silent_mark_")) + { + globalLine.RemoveAt(i); + i--; + } + } + File.WriteAllLines(fileName, globalLine); + kv.ReadFromFile(fileName); + } + + if (kv.GetKeyValue("cloak_enable", false)) + { + CloakData data = new CloakData(); + data.Enabled = true; + kv.GetDifficultyValues("cloak_range", out data.CloakRange, data.CloakRange); + kv.GetDifficultyValues("cloak_decloak_range", out data.DecloakRange, data.DecloakRange); + kv.GetDifficultyValues("cloak_duration", out data.CloakDuration, data.CloakDuration); + kv.GetDifficultyValues("cloak_cooldown", out data.Cooldown, data.Cooldown); + kv.GetDifficultyValues("cloak_speed_multiplier", out data.SpeedMultiplier, data.SpeedMultiplier); + kv.GetKeyValue("cloak_rendercolor", out data.RenderColor, data.RenderColor); + data.RenderMode = kv.GetKeyValue("cloak_rendermode", data.RenderMode); + data.CloakParticle = kv.GetKeyValue("cloak_particle", data.CloakParticle); + data.CloakOnSound = kv.GetKeyValue("cloak_on_sound", data.CloakOnSound); + data.CloakOffSound = kv.GetKeyValue("cloak_off_sound", data.CloakOffSound); + index = kv.GetKeyIndex("cloak_enable"); + InsertKeyValue(ref globalLine, ref index, "\"cloaking\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"enabled\" \"1\""); + InsertKeyValue(ref globalLine, ref index, ""); + + float range = 350.0f, decloakRange = 150.0f, duration = 10.0f, cooldown = 8.0f; + int[] renderColor = { 0, 0, 0, 0 }; + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.CloakRange[i2] != range) + { + range = data.CloakRange[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("cloak_range", (Difficulty)i2) + "\" \"" + kv.FormatFloat(range) + "\""); + } + } + + InsertKeyValue(ref globalLine, ref index, ""); + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.DecloakRange[i2] != decloakRange) + { + decloakRange = data.DecloakRange[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("decloak_range", (Difficulty)i2) + "\" \"" + kv.FormatFloat(decloakRange) + "\""); + } + } + + InsertKeyValue(ref globalLine, ref index, ""); + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.CloakDuration[i2] != duration) + { + duration = data.CloakDuration[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("duration", (Difficulty)i2) + "\" \"" + kv.FormatFloat(duration) + "\""); + } + } + + InsertKeyValue(ref globalLine, ref index, ""); + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.Cooldown[i2] != cooldown) + { + cooldown = data.Cooldown[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("cooldown", (Difficulty)i2) + "\" \"" + kv.FormatFloat(cooldown) + "\""); + } + } + + InsertKeyValue(ref globalLine, ref index, ""); + + for (int i2 = 0; i2 < 4; i2++) + { + if (data.RenderColor[i2] != renderColor[i2]) + { + string insert = string.Empty; + for (int i3 = 0; i3 < data.RenderColor.Length; i3++) + { + insert += data.RenderColor[i3].ToString(); + if (i3 != data.RenderColor.Length - 1) + { + insert += " "; + } + } + InsertKeyValue(ref globalLine, ref index, "\"color\" \"" + insert + "\""); + break; + } + } + + if (data.RenderMode != 1) + { + InsertKeyValue(ref globalLine, ref index, "\"rendermode\" \"" + data.RenderMode + "\""); + } + + InsertKeyValue(ref globalLine, ref index, ""); + + InsertKeyValue(ref globalLine, ref index, "\"effects\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertKeyValue(ref globalLine, ref index, "\"cloak\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertKeyValue(ref globalLine, ref index, "\"sound\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"type\" \"sound\""); + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"paths\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"1\" \"" + data.CloakOnSound + "\""); + InsertKeyValue(ref globalLine, ref index, "}"); + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + + InsertKeyValue(ref globalLine, ref index, "\"particle\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"type\" \"particle\""); + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"particlename\" \"" + data.CloakParticle + "\""); + InsertKeyValue(ref globalLine, ref index, "\"origin\" \"0 0 35\""); + InsertKeyValue(ref globalLine, ref index, "\"lifetime\" \"0.1\""); + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + + InsertKeyValue(ref globalLine, ref index, "\"decloak\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertKeyValue(ref globalLine, ref index, "\"sound\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"type\" \"sound\""); + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"paths\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"1\" \"" + data.CloakOffSound + "\""); + InsertKeyValue(ref globalLine, ref index, "}"); + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + + InsertKeyValue(ref globalLine, ref index, "\"particle\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"type\" \"particle\""); + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"particlename\" \"" + data.CloakParticle + "\""); + InsertKeyValue(ref globalLine, ref index, "\"origin\" \"0 0 35\""); + InsertKeyValue(ref globalLine, ref index, "\"lifetime\" \"0.1\""); + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + kv.ReadFromFile(globalLine); + float[] speed = new float[(int)Difficulty.Max]; + kv.GetDifficultyValues("speed", out speed, speed); + float defSpeed = speed[1]; + bool goSearch = false; + for (int i = 0; i < (int)Difficulty.Max; i++) + { + if (data.SpeedMultiplier[i] != 1.0f) + { + goSearch = true; + break; + } + } + if (goSearch && kv.JumpToKey("postures")) + { + if (kv.GotoFirstSubKey()) + { + while (kv.GotoNextKey()) ; + + string section = kv.GetSectionName(); + index = kv.GetSectionIndex(section); + int bracket = 0; + while (!globalLine[index].Contains('{')) + { + index++; + } + index++; + while (bracket >= 0) + { + if (globalLine[index].Contains('}')) + { + bracket--; + } + else if (globalLine[index].Contains('{')) + { + bracket++; + } + index++; + } + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"cloaked\""); + InsertKeyValue(ref globalLine, ref index, "{"); + defSpeed = speed[1] * data.SpeedMultiplier[1]; + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (speed[i2] != defSpeed) + { + defSpeed = speed[i2] * data.SpeedMultiplier[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("speed", (Difficulty)i2) + "\" \"" + kv.FormatFloat(defSpeed) + "\""); + } + } + InsertKeyValue(ref globalLine, ref index, ""); + + InsertKeyValue(ref globalLine, ref index, "\"conditions\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"on_cloak\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "}"); + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + } + kv.GoBack(); + } + else + { + index = kv.GetSectionIndex("animations"); + InsertKeyValue(ref globalLine, ref index, "\"postures\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertKeyValue(ref globalLine, ref index, "\"cloaked\""); + InsertKeyValue(ref globalLine, ref index, "{"); + defSpeed = speed[1] * data.SpeedMultiplier[1]; + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (speed[i2] != defSpeed) + { + defSpeed = speed[i2] * data.SpeedMultiplier[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("speed", (Difficulty)i2) + "\" \"" + kv.FormatFloat(defSpeed) + "\""); + } + } + InsertKeyValue(ref globalLine, ref index, ""); + + InsertKeyValue(ref globalLine, ref index, "\"conditions\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"on_cloak\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "}"); + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + InsertKeyValue(ref globalLine, ref index, ""); + } + + for (int i = 0; i < globalLine.Count; i++) + { + if (globalLine[i].Contains("\"cloak_") && !globalLine[i].Contains("\"cloak_to_heal\"")) + { + globalLine.RemoveAt(i); + i--; + } + } + + File.WriteAllLines(fileName, globalLine); + kv.ReadFromFile(fileName); + } + + if (kv.GetKeyValue("copy", false) || kv.GetKeyValue("copy_hard", false) + || kv.GetKeyValue("copy_insane", false) || kv.GetKeyValue("copy_nightmare", false) + || kv.GetKeyValue("copy_apollyon", false)) + { + CopyData data = new CopyData(); + kv.GetDifficultyValues("copy", out data.Enabled, data.Enabled); + kv.GetDifficultyValues("copy_max", out data.MaxCopies, data.MaxCopies); + kv.GetDifficultyValues("copy_teleport_dist_from_others", out data.TeleportDistance, data.TeleportDistance); + kv.GetDifficultyValues("fake_copies", out data.Fakes, data.Fakes); + index = kv.GetKeyIndex("copy"); + if (index == 0) + { + index = kv.GetKeyIndex("copy_hard"); + } + if (index == 0) + { + index = kv.GetKeyIndex("copy_insane"); + } + if (index == 0) + { + index = kv.GetKeyIndex("copy_nightmare"); + } + if (index == 0) + { + index = kv.GetKeyIndex("copy_apollyon"); + } + InsertKeyValue(ref globalLine, ref index, "\"copies\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + bool enabled = false, fakes = false; + int max = 1; + float distance = 800.0f; + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.Enabled[i2] != enabled) + { + enabled = data.Enabled[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("enabled", (Difficulty)i2) + "\" \"" + kv.FormatBool(enabled) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.MaxCopies[i2] != max) + { + max = data.MaxCopies[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("max", (Difficulty)i2) + "\" \"" + max + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.TeleportDistance[i2] != distance) + { + distance = data.TeleportDistance[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("teleport_spacing_between", (Difficulty)i2) + "\" \"" + kv.FormatFloat(distance) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.Fakes[i2] != fakes) + { + fakes = data.Fakes[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("fakes", (Difficulty)i2) + "\" \"" + kv.FormatBool(fakes) + "\""); + } + } + + InsertKeyValue(ref globalLine, ref index, "}"); + for (int i = 0; i < globalLine.Count; i++) + { + if (globalLine[i].Contains("\"copy") || globalLine[i].Contains("\"fake_copies\"")) + { + globalLine.RemoveAt(i); + i--; + } + } + + File.WriteAllLines(fileName, globalLine); + kv.ReadFromFile(fileName); + } + + if (kv.GetKeyValue("auto_chase_enabled", false)) + { + AutoChaseData data = new AutoChaseData(); + kv.GetDifficultyValues("auto_chase_enabled", out data.Enabled, data.Enabled); + kv.GetDifficultyValues("auto_chase_sound_threshold", out data.Threshold, data.Threshold); + kv.GetDifficultyValues("auto_chase_sprinters", out data.Sprinters, data.Sprinters); + kv.GetDifficultyValues("auto_chase_sound_add", out data.AddOnStateChange, data.AddOnStateChange); + kv.GetDifficultyValues("auto_chase_sound_add_footsteps", out data.AddFootsteps, data.AddFootsteps); + kv.GetDifficultyValues("auto_chase_sound_add_footsteps_loud", out data.AddLoudFootsteps, data.AddLoudFootsteps); + kv.GetDifficultyValues("auto_chase_sound_add_footsteps_quiet", out data.AddQuietFootsteps, data.AddQuietFootsteps); + kv.GetDifficultyValues("auto_chase_sound_add_voice", out data.AddVoice, data.AddVoice); + kv.GetDifficultyValues("auto_chase_sound_add_weapon", out data.AddWeapon, data.AddWeapon); + index = kv.GetKeyIndex("auto_chase_enabled"); + + InsertKeyValue(ref globalLine, ref index, "\"autochase\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + bool enabled = false, sprinters = false; + int threshold = 100, addState = 0, addFootsteps = 2, addLoudFootsteps = 2, addQuietFootsteps = 0, addVoice = 8, addWeapon = 4; + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.Enabled[i2] != enabled) + { + enabled = data.Enabled[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("enabled", (Difficulty)i2) + "\" \"" + kv.FormatBool(enabled) + "\""); + } + } + + InsertKeyValue(ref globalLine, ref index, ""); + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.Threshold[i2] != threshold) + { + threshold = data.Threshold[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("threshold", (Difficulty)i2) + "\" \"" + threshold + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.Sprinters[i2] != sprinters) + { + sprinters = data.Sprinters[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("sprinters", (Difficulty)i2) + "\" \"" + kv.FormatBool(sprinters) + "\""); + } + } + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"add\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.AddOnStateChange[i2] != addState) + { + addState = data.AddOnStateChange[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("on_state_change", (Difficulty)i2) + "\" \"" + addState + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.AddFootsteps[i2] != addFootsteps) + { + addFootsteps = data.AddFootsteps[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("footsteps", (Difficulty)i2) + "\" \"" + addFootsteps + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.AddLoudFootsteps[i2] != addLoudFootsteps) + { + addLoudFootsteps = data.AddLoudFootsteps[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("footsteps_loud", (Difficulty)i2) + "\" \"" + addLoudFootsteps + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.AddQuietFootsteps[i2] != addQuietFootsteps) + { + addQuietFootsteps = data.AddQuietFootsteps[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("footsteps_quiet", (Difficulty)i2) + "\" \"" + addQuietFootsteps + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.AddVoice[i2] != addVoice) + { + addVoice = data.AddVoice[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("voice", (Difficulty)i2) + "\" \"" + addVoice + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (data.AddWeapon[i2] != addWeapon) + { + addWeapon = data.AddWeapon[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("weapon", (Difficulty)i2) + "\" \"" + addWeapon + "\""); + } + } + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + for (int i = 0; i < globalLine.Count; i++) + { + if (globalLine[i].Contains("\"auto_chase_")) + { + globalLine.RemoveAt(i); + i--; + } + } + + File.WriteAllLines(fileName, globalLine); + kv.ReadFromFile(fileName); + } + + if (kv.GetKeyValue("boxing_boss", false)) + { + List rageAnimations = new List(); + List healAnimations = new List(); + List fleeAnimations = new List(); + if (kv.JumpToKey("animations")) + { + if (kv.JumpToKey("rage")) + { + StoreAnimationData(ref rageAnimations, kv); + + int bracket = 0, endIndex = 0; + index = 0; + index = kv.GetSectionIndex("rage"); + endIndex = index; + while (!globalLine[endIndex].Contains('{')) + { + endIndex++; + } + endIndex++; + while (bracket >= 0) + { + if (globalLine[endIndex].Contains('}')) + { + bracket--; + } + else if (globalLine[endIndex].Contains('{')) + { + bracket++; + } + endIndex++; + } + + while (index != endIndex) + { + globalLine.RemoveAt(index); + endIndex--; + } + kv.ReadFromFile(globalLine); + kv.JumpToKey("animations"); + } + + if (kv.JumpToKey("heal")) + { + StoreAnimationData(ref healAnimations, kv); + + int bracket = 0, endIndex = 0; + index = 0; + index = kv.GetSectionIndex("heal"); + endIndex = index; + while (!globalLine[endIndex].Contains('{')) + { + endIndex++; + } + endIndex++; + while (bracket >= 0) + { + if (globalLine[endIndex].Contains('}')) + { + bracket--; + } + else if (globalLine[endIndex].Contains('{')) + { + bracket++; + } + endIndex++; + } + + while (index != endIndex) + { + globalLine.RemoveAt(index); + endIndex--; + } + kv.ReadFromFile(globalLine); + kv.JumpToKey("animations"); + } + + if (kv.JumpToKey("fleestart")) + { + StoreAnimationData(ref fleeAnimations, kv); + + int bracket = 0, endIndex = 0; + index = 0; + index = kv.GetSectionIndex("fleestart"); + endIndex = index; + while (!globalLine[endIndex].Contains('{')) + { + endIndex++; + } + endIndex++; + while (bracket >= 0) + { + if (globalLine[endIndex].Contains('}')) + { + bracket--; + } + else if (globalLine[endIndex].Contains('{')) + { + bracket++; + } + endIndex++; + } + + while (index != endIndex) + { + globalLine.RemoveAt(index); + endIndex--; + } + kv.ReadFromFile(globalLine); + kv.JumpToKey("animations"); + } + kv.GoBack(); + } + + List rageSounds = new List(); + if (kv.JumpToKey("sound_rage")) + { + ProfileSound rageSound = new ProfileSound(); + rageSound.GetValues(kv); + kv.GoBack(); + rageSounds.Add(rageSound); + } + + if (kv.JumpToKey("sound_rage_2")) + { + ProfileSound rageSound = new ProfileSound(); + rageSound.GetValues(kv); + kv.GoBack(); + rageSounds.Add(rageSound); + } + + if (kv.JumpToKey("sound_rage_3")) + { + ProfileSound rageSound = new ProfileSound(); + rageSound.GetValues(kv); + kv.GoBack(); + rageSounds.Add(rageSound); + } + ProfileSound healSound = new ProfileSound(); + if (kv.JumpToKey("sound_heal_self")) + { + healSound.GetValues(kv); + kv.GoBack(); + } + + index = kv.GetKeyIndex("boxing_boss"); + bool goHeal = kv.GetKeyValue("self_heal_enabled", false); + float healPercent = kv.GetKeyValue("health_percentage_to_heal", 0.35f); + float healTimer = kv.GetKeyValue("heal_timer", 0.0f); + float healDuration = kv.GetKeyValue("heal_timer_animation", 0.0f) - healTimer; + float[] heals = new float[3]; + heals[0] = kv.GetKeyValue("heal_percentage_one", 0.75f); + heals[1] = kv.GetKeyValue("heal_percentage_two", 0.5f); + heals[2] = kv.GetKeyValue("heal_percentage_three", 0.25f); + float[] ranges = new float[2]; + ranges[0] = kv.GetKeyValue("heal_range_min", 600.0f); + ranges[1] = kv.GetKeyValue("heal_range_max", 1200.0f); + bool cloak = kv.GetKeyValue("cloak_to_heal", false); + + if (!kv.JumpToKey("rages")) + { + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"rages\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertKeyValue(ref globalLine, ref index, "\"1\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + if (!goHeal) + { + InsertKeyValue(ref globalLine, ref index, "\"health_percent\" \"0.75\""); + InsertKeyValue(ref globalLine, ref index, "\"invincible\" \"1\""); + } + else + { + InsertKeyValue(ref globalLine, ref index, "\"health_percent\" \"" + kv.FormatFloat(healPercent) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"heal\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"delay\" \"" + kv.FormatFloat(healTimer) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"duration\" \"" + kv.FormatFloat(healDuration) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"flee_range_min\" \"" + kv.FormatFloat(ranges[0]) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"flee_range_max\" \"" + kv.FormatFloat(ranges[1]) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"amount\" \"" + kv.FormatFloat(heals[0]) + "\""); + + if (cloak) + { + InsertKeyValue(ref globalLine, ref index, "\"cloak\" \"1\""); + } + InsertKeyValue(ref globalLine, ref index, "}"); + } + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"animations\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + List animations = rageAnimations; + if (goHeal) + { + animations = fleeAnimations; + } + InsertAnimationSection(ref globalLine, ref index, "start", animations, kv); + + if (goHeal) + { + InsertKeyValue(ref globalLine, ref index, ""); + animations = healAnimations; + InsertAnimationSection(ref globalLine, ref index, "healing", animations, kv); + } + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"sounds\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + ProfileSound sound = rageSounds[0]; + sound.InsertSection("start", ref globalLine, ref index, kv); + + if (goHeal) + { + InsertKeyValue(ref globalLine, ref index, ""); + healSound.InsertSection("healing", ref globalLine, ref index, kv); + } + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"2\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + if (!goHeal) + { + InsertKeyValue(ref globalLine, ref index, "\"health_percent\" \"0.5\""); + InsertKeyValue(ref globalLine, ref index, "\"invincible\" \"1\""); + } + else + { + InsertKeyValue(ref globalLine, ref index, "\"health_percent\" \"" + kv.FormatFloat(healPercent) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"heal\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"delay\" \"" + kv.FormatFloat(healTimer) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"duration\" \"" + kv.FormatFloat(healDuration) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"flee_range_min\" \"" + kv.FormatFloat(ranges[0]) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"flee_range_max\" \"" + kv.FormatFloat(ranges[1]) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"amount\" \"" + kv.FormatFloat(heals[1]) + "\""); + + if (cloak) + { + InsertKeyValue(ref globalLine, ref index, "\"cloak\" \"1\""); + } + InsertKeyValue(ref globalLine, ref index, "}"); + } + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"animations\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + animations = rageAnimations; + if (goHeal) + { + animations = fleeAnimations; + } + InsertAnimationSection(ref globalLine, ref index, "start", animations, kv); + + if (goHeal) + { + InsertKeyValue(ref globalLine, ref index, ""); + animations = healAnimations; + InsertAnimationSection(ref globalLine, ref index, "healing", animations, kv); + } + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"sounds\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + sound = rageSounds[0]; + if (rageSounds.Count > 1) + { + sound = rageSounds[1]; + } + sound.InsertSection("start", ref globalLine, ref index, kv); + + if (goHeal) + { + InsertKeyValue(ref globalLine, ref index, ""); + healSound.InsertSection("healing", ref globalLine, ref index, kv); + } + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"3\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + if (!goHeal) + { + InsertKeyValue(ref globalLine, ref index, "\"health_percent\" \"0.25\""); + InsertKeyValue(ref globalLine, ref index, "\"invincible\" \"1\""); + } + else + { + InsertKeyValue(ref globalLine, ref index, "\"health_percent\" \"" + kv.FormatFloat(healPercent) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"heal\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"delay\" \"" + kv.FormatFloat(healTimer) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"duration\" \"" + kv.FormatFloat(healDuration) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"flee_range_min\" \"" + kv.FormatFloat(ranges[0]) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"flee_range_max\" \"" + kv.FormatFloat(ranges[1]) + "\""); + InsertKeyValue(ref globalLine, ref index, "\"amount\" \"" + kv.FormatFloat(heals[2]) + "\""); + + if (cloak) + { + InsertKeyValue(ref globalLine, ref index, "\"cloak\" \"1\""); + } + InsertKeyValue(ref globalLine, ref index, "}"); + } + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"animations\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + animations = rageAnimations; + if (goHeal) + { + animations = fleeAnimations; + } + InsertAnimationSection(ref globalLine, ref index, "start", animations, kv); + + if (goHeal) + { + InsertKeyValue(ref globalLine, ref index, ""); + animations = healAnimations; + InsertAnimationSection(ref globalLine, ref index, "healing", animations, kv); + } + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"sounds\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + sound = rageSounds[0]; + if (rageSounds.Count > 2) + { + sound = rageSounds[2]; + } + sound.InsertSection("start", ref globalLine, ref index, kv); + + if (goHeal) + { + InsertKeyValue(ref globalLine, ref index, ""); + healSound.InsertSection("healing", ref globalLine, ref index, kv); + } + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + InsertKeyValue(ref globalLine, ref index, ""); + + for (int i = 0; i < globalLine.Count; i++) + { + if (globalLine[i].Contains("\"heal_timer_animation\"") || globalLine[i].Contains("\"heal_timer\"") + || globalLine[i].Contains("\"heal_range_min\"") || globalLine[i].Contains("\"heal_range_max\"") + || globalLine[i].Contains("\"heal_time_min\"") || globalLine[i].Contains("\"heal_time_max\"") + || globalLine[i].Contains("\"self_heal_enabled\"") || globalLine[i].Contains("\"health_percentage_to_heal\"") + || globalLine[i].Contains("\"heal_percentage_one\"") || globalLine[i].Contains("\"heal_percentage_two\"") + || globalLine[i].Contains("\"heal_percentage_three\"") || globalLine[i].Contains("\"cloak_to_heal\"")) + { + globalLine.RemoveAt(i); + i--; + } + } + + File.WriteAllLines(fileName, globalLine); + kv.ReadFromFile(fileName); + } + else + { + // Fuck go back + kv.GoBack(); + } + } + + if (kv.GetKeyValue("crawling_enabled", false)) + { + List walkAnimations = new List(); + List runAnimations = new List(); + float[] speedMultiplier = new float[(int)Difficulty.Max]; + float[] speed = new float[(int)Difficulty.Max]; + float[] walkSpeed = new float[(int)Difficulty.Max]; + float[] mins = new float[3]; + float[] maxs = new float[3]; + for (int i = 0; i < (int)Difficulty.Max; i++) + { + speedMultiplier[i] = 0.5f; + } + kv.GetKeyValue("crawl_detect_mins", out mins, mins); + kv.GetKeyValue("crawl_detect_maxs", out maxs, maxs); + kv.GetDifficultyValues("crawl_multiplier", out speedMultiplier, speedMultiplier); + kv.GetDifficultyValues("speed", out speed, speed); + kv.GetDifficultyValues("walkspeed", out walkSpeed, walkSpeed); + if (kv.JumpToKey("animations")) + { + if (kv.JumpToKey("crawlwalk")) + { + StoreAnimationData(ref walkAnimations, kv); + + int bracket = 0, endIndex = 0; + index = 0; + index = kv.GetSectionIndex("crawlwalk"); + endIndex = index; + while (!globalLine[endIndex].Contains('{')) + { + endIndex++; + } + endIndex++; + while (bracket >= 0) + { + if (globalLine[endIndex].Contains('}')) + { + bracket--; + } + else if (globalLine[endIndex].Contains('{')) + { + bracket++; + } + endIndex++; + } + + while (index != endIndex) + { + globalLine.RemoveAt(index); + endIndex--; + } + kv.ReadFromFile(globalLine); + kv.JumpToKey("animations"); + } + + if (kv.JumpToKey("crawlrun")) + { + StoreAnimationData(ref runAnimations, kv); + + int bracket = 0, endIndex = 0; + index = 0; + index = kv.GetSectionIndex("crawlrun"); + endIndex = index; + while (!globalLine[endIndex].Contains('{')) + { + endIndex++; + } + endIndex++; + while (bracket >= 0) + { + if (globalLine[endIndex].Contains('}')) + { + bracket--; + } + else if (globalLine[endIndex].Contains('{')) + { + bracket++; + } + endIndex++; + } + + while (index != endIndex) + { + globalLine.RemoveAt(index); + endIndex--; + } + kv.ReadFromFile(globalLine); + kv.JumpToKey("animations"); + } + + kv.GoBack(); + } + + if (kv.JumpToKey("postures")) + { + if (kv.GotoFirstSubKey()) + { + while (kv.GotoNextKey()) ; + + string section = kv.GetSectionName(); + index = kv.GetSectionIndex(section); + int bracket = 0; + while (!globalLine[index].Contains('{')) + { + index++; + } + index++; + while (bracket >= 0) + { + if (globalLine[index].Contains('}')) + { + bracket--; + } + else if (globalLine[index].Contains('{')) + { + bracket++; + } + index++; + } + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"crawling\""); + InsertKeyValue(ref globalLine, ref index, "{"); + float defSpeed = speed[1] * speedMultiplier[1]; + float defWalkSpeed = walkSpeed[1] * speedMultiplier[1]; + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (walkSpeed[i2] != defWalkSpeed) + { + defWalkSpeed = walkSpeed[i2] * speedMultiplier[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("walkspeed", (Difficulty)i2) + "\" \"" + kv.FormatFloat(defWalkSpeed) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (speed[i2] != defSpeed) + { + defSpeed = speed[i2] * speedMultiplier[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("speed", (Difficulty)i2) + "\" \"" + kv.FormatFloat(defSpeed) + "\""); + } + } + InsertKeyValue(ref globalLine, ref index, ""); + + InsertKeyValue(ref globalLine, ref index, "\"conditions\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"within_bounds\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + string insert = string.Empty; + for (int i3 = 0; i3 < mins.Length; i3++) + { + insert += mins.ToString(); + if (i3 != mins.Length - 1) + { + insert += " "; + } + } + InsertKeyValue(ref globalLine, ref index, "\"mins\" \"" + insert + "\""); + insert = string.Empty; + for (int i3 = 0; i3 < maxs.Length; i3++) + { + insert += maxs.ToString(); + if (i3 != maxs.Length - 1) + { + insert += " "; + } + } + InsertKeyValue(ref globalLine, ref index, "\"maxs\" \"" + insert + "\""); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"animations\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertAnimationSection(ref globalLine, ref index, "walk", walkAnimations, kv); + + InsertKeyValue(ref globalLine, ref index, ""); + InsertAnimationSection(ref globalLine, ref index, "run", runAnimations, kv); + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + } + kv.GoBack(); + } + else + { + index = kv.GetSectionIndex("animations"); + InsertKeyValue(ref globalLine, ref index, "\"postures\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + InsertKeyValue(ref globalLine, ref index, "\"crawling\""); + InsertKeyValue(ref globalLine, ref index, "{"); + float defSpeed = speed[1] * speedMultiplier[1]; + float defWalkSpeed = walkSpeed[1] * speedMultiplier[1]; + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (walkSpeed[i2] != defWalkSpeed) + { + defWalkSpeed = walkSpeed[i2] * speedMultiplier[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("walkspeed", (Difficulty)i2) + "\" \"" + kv.FormatFloat(defWalkSpeed) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (speed[i2] != defSpeed) + { + defSpeed = speed[i2] * speedMultiplier[i2]; + InsertKeyValue(ref globalLine, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("speed", (Difficulty)i2) + "\" \"" + kv.FormatFloat(defSpeed) + "\""); + } + } + InsertKeyValue(ref globalLine, ref index, ""); + + InsertKeyValue(ref globalLine, ref index, "\"conditions\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertKeyValue(ref globalLine, ref index, "\"within_bounds\""); + InsertKeyValue(ref globalLine, ref index, "{"); + + string insert = string.Empty; + for (int i3 = 0; i3 < mins.Length; i3++) + { + insert += mins[i3].ToString(); + if (i3 != mins.Length - 1) + { + insert += " "; + } + } + InsertKeyValue(ref globalLine, ref index, "\"mins\" \"" + insert + "\""); + insert = string.Empty; + for (int i3 = 0; i3 < maxs.Length; i3++) + { + insert += maxs[i3].ToString(); + if (i3 != maxs.Length - 1) + { + insert += " "; + } + } + InsertKeyValue(ref globalLine, ref index, "\"maxs\" \"" + insert + "\""); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, ""); + InsertKeyValue(ref globalLine, ref index, "\"animations\""); + InsertKeyValue(ref globalLine, ref index, "{"); + InsertAnimationSection(ref globalLine, ref index, "walk", walkAnimations, kv); + + InsertKeyValue(ref globalLine, ref index, ""); + InsertAnimationSection(ref globalLine, ref index, "run", runAnimations, kv); + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + + InsertKeyValue(ref globalLine, ref index, "}"); + InsertKeyValue(ref globalLine, ref index, ""); + } + + for (int i = 0; i < globalLine.Count; i++) + { + if (globalLine[i].Contains("\"crawling_enabled\"") || globalLine[i].Contains("\"crawl_multiplier") + || globalLine[i].Contains("\"crawl_detect_mins\"") || globalLine[i].Contains("\"crawl_detect_maxs\"")) + { + globalLine.RemoveAt(i); + i--; + } + } + + File.WriteAllLines(fileName, globalLine); + kv.ReadFromFile(fileName); + } + + // Delete empty globalLines having increments greater than 1 + for (int i = 0; i < globalLine.Count - 1; i++) + { + if (!globalLine[i + 1].Contains('\"') && !globalLine[i + 1].Contains('{') && !globalLine[i + 1].Contains('}') && + !globalLine[i].Contains('\"') && !globalLine[i].Contains('{') && !globalLine[i].Contains('}')) + { + globalLine.RemoveAt(i + 1); + i--; + } + } + + // Finally auto-indent + int curlyIndex = 0; + StringBuilder sb, charBuilder; + for (int i = 0; i < globalLine.Count; i++) + { + bool commentFound = false; + charBuilder = new StringBuilder(); + globalLine[i] = globalLine[i].Replace("\t", ""); + List charList = new List(); + charList.AddRange(globalLine[i]); + for (int i2 = 0; i2 < charList.Count; i2++) + { + bool skipSpace = false; + if (charList[i2] == ' ' && charList[i2] != '{' && charList[i2] != '}') + { + if ((i2 - 1 > 0 && (charList[i2 - 1] != ' ')) && + (i2 + 1 < charList.Count && (charList[i2 + 1] != ' '))) + { + skipSpace = true; + } + if (charList[i2] == '/' && (i2 + 1 < charList.Count && charList[i2 + 1] == '/')) + { + commentFound = true; + } + if (!commentFound && !skipSpace) + { + charList.RemoveAt(i2); + i2--; + continue; + } + } + charBuilder.Append(charList[i2]); + } + globalLine[i] = charBuilder.ToString(); + charBuilder = new StringBuilder(); + charList = new List(); + charList.AddRange(globalLine[i]); + for (int i2 = 0; i2 < charList.Count; i2++) + { + if (charList[i2] == '\"' && (i2 + 1 < charList.Count && charList[i2 + 1] == '\"')) + { + charList.Insert(i2 + 1, ' '); + } + charBuilder.Append(charList[i2]); + } + globalLine[i] = charBuilder.ToString(); + } + for (int i = 0; i < globalLine.Count; i++) + { + if (globalLine[i].Contains('}') && curlyIndex != 0 && !globalLine[i].Contains('\"')) + { + curlyIndex--; + } + sb = new StringBuilder(globalLine[i]); + if (globalLine[i].Length > 0) + { + for (int i2 = 0; i2 < curlyIndex; i2++) + { + sb.Insert(0, "\t"); + } + globalLine[i] = sb.ToString(); + } + if (globalLine[i].Contains('{') && !globalLine[i].Contains('\"')) + { + curlyIndex++; + } + } + + for (int i = 0; i < globalLine.Count; i++) + { + char[] arr = globalLine[i].ToCharArray(); + if (arr.Length > 0 || globalLine[i].Contains('{') || globalLine[i].Contains('}')) + { + continue; + } + globalLine[i] = string.Empty; + } + + // Check any missing curly brackets + curlyIndex = 0; + for (int i = 0; i < globalLine.Count; i++) + { + bool doContinue = false; + if (globalLine[i].Contains('{') || globalLine[i].Contains('}')) + { + List charList = new List(); + charList.AddRange(globalLine[i]); + for (int i2 = 0; i2 < charList.Count; i2++) + { + if (char.IsLetterOrDigit(charList[i2])) + { + doContinue = true; + break; + } + } + } + if (doContinue) + { + continue; + } + + if (globalLine[i].Contains('{')) + { + curlyIndex++; + } + if (globalLine[i].Contains('}')) + { + curlyIndex--; + } + } + if (curlyIndex > 0) + { + for (int i = 0; i < curlyIndex; i++) + { + globalLine.Add("}"); + } + } + else if (curlyIndex < 0) + { + for (int i = globalLine.Count - 1; i >= 0; i--) + { + if (curlyIndex == 0) + { + break; + } + bool doContinue = false; + if (globalLine[i].Contains('}')) + { + List charList = new List(); + charList.AddRange(globalLine[i]); + for (int i2 = 0; i2 < charList.Count; i2++) + { + if (char.IsLetterOrDigit(charList[i2])) + { + doContinue = true; + break; + } + } + } + if (doContinue) + { + continue; + } + + if (globalLine[i].Contains('}')) + { + globalLine.RemoveAt(i); + curlyIndex++; + } + } + } + File.WriteAllLines(fileName, globalLine); + GC.Collect(); + GC.WaitForPendingFinalizers(); + } + + progressBox.Text = "Finished rewriting " + configsList.Items.Count + " config(s)!"; + } + + private void clearButton_Click(object sender, EventArgs e) + { + configsList.Items.Clear(); + } + } +} \ No newline at end of file diff --git a/Form1.resx b/Form1.resx new file mode 100644 index 0000000..34681ee --- /dev/null +++ b/Form1.resx @@ -0,0 +1,2417 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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, 21 + + + + + AAABAAYAEBAAAAEAIABoBAAAZgAAACAgAAABACAAqBAAAM4EAAAwMAAAAQAgAKglAAB2FQAAQEAAAAEA + IAAoQgAAHjsAAICAAAABACAAKAgBAEZ9AAAAAAAAAQAgAAyTAABuhQEAKAAAABAAAAAgAAAAAQAgAAAA + AAAABAAAEwsAABMLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAgICMwICAlsDAwN6CQkJnQkJ + CWwGBQUqAAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAICAgAAAAA4BgYGmhAQEOUKCgrVBgYGrxcX + F/8XFxf8BwcH3gICArgBAQFxAAAACQAAAAAAAAAAAAAAAAkJCQAGBgYnDg4OyAsLC/8JCQn/BwcH5QUF + BZ4aGhr/ExQU/w8PD/8cHBz/ExMT9wUFBVwLCwsAAAAAAAUFBQACAgIWEBAQuBkZGf8ZGRn/EBAQ/wcH + B/ICAgKvDg4O/BISEv8TExP/KCgo/ykpKf8cHBzMBgYGIQoKCgD///8ADQ0NfRgYGP4aGhr/Gxsb/xcX + F/8LCwv8AQEBtgkJCfIfHx//EhIS/yEhIf8uLi7/LS0t/xcXF5cAAAAFAAAANwwMDNsSEhL/FRUV/xoa + Gv8eHh7/GBgY/AkJCb0SEhLzJCQk/yAgIP8bGxv/MjIy/zU1Nf8mJibqBAQEPwICArsLCwv/ERER/xIS + Ev8QEBD/ExMT/w0NDdV7e3vWdnZ27w8PD+gPDw/9GRkZ9yMjI+0fHx/gFhYW0QQEBGQICAieFhYW/xgY + GP8XFxf7EhIS/AUFBfITExPlu7u79cXFxfcyMjJ9AAAAkAICApoFBQWgCwsLrBISEr4ICAiCAwMDdQYG + BqwFBQWcAwMDnAEBAd4CAgK1KSkprMjIyPvT09P9OTk5xwsLC+IPDw/1EBAQ/RYWFv8aGxv/CwsLqgIC + AlcMDAzODg4O4QcHB+8ODg79EBAQ/Q8PD/N2dnb9g4OD9xwcHPgZGRn/LCws/zk5Of86Ojr/MDAw+wwM + DHgCAgI0ERIS5A8PD/8aGhr/FxcX/xMTE/8mJib/EBAQ8ggICK0sLCz8LCws/yIiIv9DQ0P/SEhI/zMz + M+MFBQUsAAAAAgQEBYkTExP/KCgo/xgYGP8ZGRn/LCws/wkJCfUBAQG2GRkZ+yoqKv8fHx//Kysr/z9A + QP8UFBTbAAAAIQAAAAAAAAAqEBER4igoKP8qKir/FhYW/xoaGv8QEBD+AgICvyAgIO8jIyP/MDAw/yYm + Jv4QEBDpAwMDgQAAAAUAAAAAAAAABAUFBEEcHBy2LS0t/S8vL/8VFRX/Ly8v/wwMDKInJyfbOTk5/yUl + Jf4uLi6+BQUFPgAAAAYAAAAAAAAAAAAAAAAVFRUABAQEHBUVFY0aGhrwFxcX+jMzM/8RERG0GhoayCUl + JfUJCQmhBAQERwAAABYAAAAAAAAAAAAAAAAAAAAAAQEBAwAAACIAAABKAAAAXgwMDGEUFBSQBwcHdwMD + A1ECAgJbAAAAaAAAACsBAQEBAAAAAAAAAADwBwAA4AMAAMADAACAAQAAgAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACAAAAAgAEAAOADAADAAwAAKAAAACAAAABAAAAAAQAgAAAAAAAAEAAAEwsAABML + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAUAAAAMAAAAIAAAAEQAAAA7AAAAJwAAAA8AAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ABoAAABeAQEBqgAAAIkAAABqAwMD8wgICO4HBwfhBgYGxAMDA48AAABKAAAAEAAAAAABAQEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwAA + ACYBAQFuBQUF0gwMDPsNDQ3/AgICwAAAAFsICAj6Ghoa/xoaGv8ZGRn/FhcW/w4ODvcCAgLDAAAAiAAA + AH8AAABKAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ABAAAACuAAAA5wsLC/oXFxf/GRkZ/xYWFv8DAwPVAAAATAYGBu4aGhr/HB0d/x4eHv8aGhr/CAgJ/wAA + AP8BAQH/AQEB/wAAAPUAAACJAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACAQEBZQgICPcHBwf/BwcH/xEREf8ICAj/DQ0N/wUFBecAAABHBAQE2xgYGP8dHR3/Hh4e/wwM + DP8BAQH/Dg4O/xgYGP8YGBj/Dg4O/wICAvgAAABpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQICAmINDQ3uGBgY/xUVFf8FBQX/AQEB/wEBAf8FBQX/BQUF9AAAAE0CAgLEFxcX/x8f + H/8dHR3/BgYG/wkJCf8iIiL/JSUl/yYmJv8mJib/FxcX/wMDA9MAAAAbAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAgICAABAQFRDQ0N6xkZGf8aGhr/Ghoa/xYWFv8TExP/DAwM/wUFBf8ICAj9AAAAWwEB + AaYSEhL/HBwc/x4eHv8ICAj/CQkJ/yMjI/8lJiX/Jycn/ykpKf8qKir/GRkZ/AQEBHgAAAACAAAAAAAA + AAAAAAAAAAAAAAEBAQABAQEAAAAALQsLC9kYGBj/Ghoa/xoaGv8aGhr/Ghoa/xsbG/8ODg7/CAgI/wsL + C/8AAACiAAAAxAQEBP8FBQX/FxcX/xISEv8CAgL/Gxwc/ycnJ/8oKCj/Kioq/ywsLP8sLCz/FhYW7gEB + AVAFBQUAAAAAAAAAAAAAAAAAAAAAAAAAAAoGBganFhYW/xoaGv8aGhr/Ghoa/xoaGv8aGxv/Gxsb/w0N + Df8DAwP/BAQE/wAAAOEAAADDBAQE/gYGBv8cHBz/ISEh/wkJCf8KCgr/JSUl/yoqKv8sLCz/LS0t/y8v + L/8sLCz/Dg4O0AAAACEAAAAAAAAAAAEBAQACAgIAAQEBUw8PD/YaGhr/Ghoa/xoaGv8aGhr/Ghsb/xsb + G/8cHBz/GBgY/xEREf8NDQ3/AQEBqQAAAFIBAQH6ExMT/yQkJP8mJib/Hx8f/wYGBv8UFBT/Kysr/y0t + Lf8vLy//MTEx/zMzM/8iIiL/AwMDigAAAAEAAAAAAAAAAAAAAAsHBwe3FxcX/xoaGv8aGhr/Gxsb/xsb + G/8bGxv/HBwc/xwcHP8dHR3/Hx8f/xcXF/8CAgK/AAAAcgUFBf0gICD/JiYm/ycnJ/8pKSn/Ghoa/wcH + B/8oKCj/Ly8v/zExMf8yMjL/NDQ0/zIyMv8PDw/jAAAAKwAAAAAAAAAKAAAAVwcHB/IODg7/DAwM/wwM + DP8ODg7/FRUV/xoaGv8dHR3/HR0d/x4eHv8gICD/GBgY/wICAtoFBQXBBgYG/xEREf4gICD/KSkp/ysr + K/8iIiL/BwcH/ygoKP8xMTH/MjMz/zQ0NP82Njb/OTk5/x8fH/8AAAB5AgICAAAAAJ8AAADyAQEB/wMD + A/8GBgb/CAgI/wgICP8GBgb/CAgI/xEREf8aGhr/Hx8f/xgYGP8GBgbmFBQUsnh4ePF4eHj/FxcXzwUF + BecbGxv/ISEh/w4ODv8QEBD/Ly8v/zIyMv8yMjL/MTEx/y8vL/8sLCz/HBwc/wICAr8AAAAOAAAAiwMD + A/YQEBD/FhcX/xkZGf8bGxv/Gxsb/xkZGf8SEhL/CQkJ/wcHB/8NDQ3/BgYG9gAAAGh+fn6o1tbW/9zc + 3P92dnbfAQEB2wICAvsCAgL/BgYG/xYWFv8YGBj/ExMT/g8PD/cKCgrqBwcH2AQEBMIBAQGqAAAAfgAA + ABIAAAAlBwcH3xkZGf8bGxv/Gxsb/xwcHP8dHR3/Hh4e/x8fH/8dHR3/EhIS/wUFBf8AAAD5CgoKx56e + nu7g4OD/4eHh/6ioqP4hISGIAAAAbAAAAMoBAQG0AQEBmQAAAH4AAABmAAAAVwAAAFEAAABVAAAAZAAA + AHwAAACOAAAAKAAAADYHBwfrGRkZ/xkZGf8YGBj/FhYW/xQUFP8RERH/Dg4O/woKCv8DAwP9AQEB+gAA + AP4TEhP/n5+f/9/f3//g4OD/tbW1/0RERH4AAAAKAAAAQgAAAFYAAABvAQEBjQMDA6wGBgbICgoK4BAQ + EPEXFxf8Hh4e/woKCvAAAABAAAAAPwMDA/AICAj7BgYG7wQEBN8DAwPJAQEBrwAAAJIAAADSAAAA9QAA + AIsAAABmAAAAeiwsLMfBwcH/4ODg/9/f3//S0tL/V1dXxwAAAIQAAADnAAAA+wAAAP8CAgL/CwsL/xQU + FP8bGxv/IyMj/ywsLP8zMzP/ERER7AAAADcAAAAdAAAAZAAAAFQAAABFAAAAQAAAAEUAAABTAAAAbgAA + ANsBAQHyAgICxQQEBNUAAAB2PDw8j8DAwP/g4OD/39/f/9bW1v9OT0/rAAAA8BQUFP8dHR3/FxcX/xER + Ef8NDQ3/CQkJ/wcHB/8HBwf/BgYG/wYGBv8CAgL2AAAAXwAAAAoAAAB3AQEBrwICAsgEBATeBwcH7woK + CvoHBwf/AQEB/w4ODv8dHR3/FRUV/wEBAfYMDAz4j4+P/97e3v/f39//ra2t/yIiIukBAQHyHBwc/yoq + Kv80NTX/Ojo6/zk6Ov85OTn/ODg5/zk5Of84ODj/LCws/wYGB9gAAAA/AAAABQAAAKkNDQ3/GBgY/xoa + Gv8TExP/CgoK/wMDBP8ICAj/Hx8f/xkZGf8EBAT/BgYG/wcHB/8cHBz/ZWVl/29vb/UsLCz5CgoK/xYW + Fv8SEhL/CgoK/xMTE/86Ojr/Pz8//0FBQf9DQ0P/RUVF/0hISP81NTX/BgYGhBcXFwAAAAAAAAAAYA4O + DvwfHx//EBAQ/wMDA/8KCgr/FRUV/yIiIv8ZGRn/AwMD/wwMDP8kJCT/KSkp/xYWFv8BAQH/AAAAlwMC + A8wmJib/ODg4/zk5Of8hISH/DAwM/zs7O/9BQUH/Q0ND/0RERP9GRkb/SEhI/yUlJfEAAAA/AQEBAAAA + AAAAAAAaBwcH0RgYGP8FBQX/FBQU/yMjI/8mJib/JCQk/wgICP8LCwv/Jyco/y4uLv8wMDD/HBwc/wAA + APsAAABWAgICrSYmJv87Ozv/PT09/yoqKv8ICAj/MTEx/0RERP9ERET/RkZG/0hJSf9CQkL/EBAQ1QAA + ABcAAAAAAAAAAAQEBAACAgJuCgoK/AUFBf8fHx//JiYm/ycnJ/8jIyP/BAQE/xYWFv8uLi7/Ly8v/zAw + MP8QEBD/AAAA/wAAAGYAAACSHBwc/zQ0NP86Ojr/PD09/xUVFf8LCwv/NDQ0/0dHR/9ISEj/S0tL/ysr + K/8BAQHlAAAAJQAAAAAAAAAAAAAAAAAAABMAAAC6BgYG/yIiIv8nJyf/KCkp/ygoKP8ODg7/BQUF/yEh + If8xMTH/LS0t/wgICP8BAQH/AAAAxgAAANUEBAT/CAgI/w4OD/8rKyv/Ojo6/xMTE/8ICAj/LS0t/0lJ + Sf9AQED/DAwM/wAAANoAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAEwFBQX3IiIi/ykpKf8qKir/LCws/yYm + Jv8LCwv/BAQE/yAgIP8qKir/BAQE/wAAAP8AAADvAAAAxw4ODvwsLCz/HR0d/wgICP8zMzP/QEBA/xsb + G/8EBAT/Gxsb/xUVFf8AAAD+AAAAhQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAHwEBAdoSEhL/KCgo/yws + LP8tLS3/Ly8v/ysrK/8QEBD/BAQE/yIiIv8ZGRn/FBQU/wMDA8UAAABMEBAQ8z8/P/9CQkL/GRkZ/xkZ + Gf9ISEj/R0dH/ycnJ/8DAwP1AAAA3AAAAI0AAAASAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAAAARwIC + ApkVFRXoKioq/y8wMP8xMTH/MzMz/y8vL/8KCwv/EhIS/zk5Of8zMzP/CAgI2gAAAEIKCgrkOzs7/0ZG + Rv8wMDD/DQ0N/0NDQ/9ISEj/Jycn7QQEBGgAAAAaAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQICAkkSEhLTJygo/zMzM/81NTX/NjY2/xISEv8NDQ3/OTk5/zk5Of8NDQ3tAAAARgYG + Bs83Nzf/SEhI/zo6Ov8LCwv/MzMz/x8fH+MEBARYAAAAGwAAAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABAQEAAAAACYLCwueHR0d8jAwMP8uLi7/BwcH/xsbG/8+Pj7/Pj4+/xQU + FPoAAABWAwMDtTIyMv9KSkr/Kysr/wMDA/wKCgq9AQEBNwAAACEAAABJAAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAADAQEBAQAAAAsBAQFdCgoK3goKCv8GBgb/Kysr/zo6 + Ov89PT3/Ghoa/wAAAG4BAQGZGxsb/yAgIPsJCQn5AAAAjwAAABMAAAA3AAAAbAAAABUAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAADIAAABXAAAAdQAAAJUAAACvAAAAhAMD + A3kJCQmwDg4O0xAQEOQHBwftAAAAfgAAAGUAAACpAAAAXQAAAJAAAACoAAAAhQAAAHgAAAAYAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAA0AAAAWAAAAFwAA + AAsBAQEBAAAAAAAAAAYAAAAZAAAAKgAAADMAAAAeAAAABwAAAAUAAAAAAAAAFAAAAFcAAABBAAAACQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/8A///8AD//4AAD/8AAAf+AAAH/AAAA/wAAAH4AAAB8AA + AAPAAAABgAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAGAAAABwAAAAcAA + AAHgAAAB4AAAA+AAAAf4AAAP/gAAD/gAAB/4AAA//AgIfygAAAAwAAAAYAAAAAEAIAAAAAAAACQAABML + AAATCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABwAAAAgAAAAFAQEBAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAEBAQIAAAAbAAAASAAAADEAAAAsAAAArgAA + ALgAAACvAAAAnAAAAH4AAABVAAAAKwAAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAAAAAAAAAMAAAARwAAAJoAAADYAAAA+wAA + AI8AAAAsAAAA7AUFBf8KCgr/CQkJ/wgICP8GBgb8AwMD6QEBAb0AAAB4AAAALgAAAAUAAAAABAQEAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAwAAAAAAAAAACgAAAFEAAAC5AgIC9QcH + B/8MDAz/BAQE/wAAAKsAAAAcAAAA2AwMDP8bGxv/Gxsb/xsbG/8aGhr/GBgY/xMTE/8MDAz+BQUF6AAA + AJ8AAABUAAAAUAAAAEcAAAAgAQEBAgEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAAHEAAACHAQEBqgQE + BPUMDAz/FBUV/xkZGf8aGhr/CQkJ/wAAAMQAAAAWAAAAvwkJCf8bGxv/HBwc/xwcHP8dHR3/HR4d/x4e + Hv8YGBj/CAgI/wAAAP8AAAD7AAAA/AAAAPkAAADcAAAAdwAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYQAA + APoAAAD/AwMD/xQUFP8aGhr/Ghoa/xkaGv8aGhr/CwsL/wAAANkBAQEbAAAAogYGBv8aGhr/HBwc/x0d + Hf8dHR3/Hh4e/xYWFv8EBAT/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA+wAAAJMAAAALAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAA + AAAAAAATAAAAugUFBf8FBQX/AAAA/wsLC/8YGBj/ERER/wgICP8PDw//Dg4O/wAAAOoAAAAoAAAAgQQE + BP8ZGRn/HR0d/x0dHf8eHh7/HBwc/wcHB/8AAAD/AgIC/wsLC/8SExP/FBQU/xISEv8KCgr/AQEB/wAA + APkAAABvAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAABgBAQGlCgoK/RUVFf8UFBT/AwMD/wEBAf8GBgb/AgIC/wAAAP8CAgL/DAwM/wEB + AfYAAAA8AAAAYAICAv8XFxf/HR4e/x4eHv8fHx//FxcX/wEBAf8BAQH/EhIS/yEhIf8kJCT/JSUl/yUl + Jf8kJCT/FBQU/wICAv8AAADgAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAQEBAAAAAAAAAAAFQEBAakMDAz/GRkZ/xoaGv8aGhr/EBAQ/wICAv8AAAD/AQEB/wIC + Av8BAQH/CwsL/wICAv0AAABVAAAAQQEBAfgUFBT/Hh4e/x4eHv8gICD/FBQU/wAAAP8DAwP/HR0d/yMk + JP8kJCT/JSUl/yYmJv8nJyf/KCgo/xkZGf8DAwP/AAAAhQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAQEBnAwMDP4ZGRn/Ghoa/xoaGv8aGhr/Ghoa/xQU + FP8ODg7/EhIS/woKCv8BAAD/Dg4O/wMDA/8AAAByAAAAKAAAAOoRERH/Hx8f/x8fH/8hISH/FhYW/wEB + Af8DAwP/HR0d/yQkJP8lJSX/JiYm/ycnJ/8oKCj/KSkp/yoqKv8aGhr/AwMD1gAAACcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAB8CgoK+xkZGf8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8bGxv/Gxsb/woKCv8BAQH/ERER/wUFBf8AAACPAAAAFwAAANkJCQn/EBAQ/w8P + D/8bGxv/HR0d/wQEBP8AAAD/FRUV/yUlJf8mJib/Jycn/ygoKP8pKSn/Kioq/ysrK/8sLCz/GBgY/wIC + ArIAAAAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwHBwfuFxcX/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8bGxv/Ghoa/wgICP8CAgL/FRUV/wcHB/8AAADJAAAAmgAA + APIBAQH/AgIC/wAAAP8ODg7/IiIi/w8PD/8AAAD/BwcH/yIiIv8nJyf/KCgo/ykpKf8qKir/Kysr/yws + LP8tLS3/LS0t/xISEv4AAACLAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGwMD + A8kTExP/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xobGv8bGxv/Ghoa/wYGBv8BAQH/CQkJ/wMD + A/8AAAD/AAAA6wAAAOkEBAT/CQkJ/wICAv8XFxf/JCQk/x4fH/8GBgb/AAAA/xEREf8nJyf/KSkp/yoq + Kv8rKyv/LCws/y0tLf8uLi7/MDAw/yoqKv8JCQnyAAAAUgAAAAABAQEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAgQwMDP8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghsb/xsbG/8bGxv/Gxsb/wwM + DP8BAQH/AgIC/wMDA/8AAADnAAAAPgAAAIcBAQH/AQEB/w4NDv8iIiL/JCQk/yUlJf8aGhr/AwMD/wIC + Av8bGxv/Kioq/ysrK/8sLCz/LS0t/y4uLv8vLy//MTEx/zIyMv8fHx//AgICygAAABoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAtBQUF4hYWFv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGxv/Gxsb/xsb + G/8cHBz/HBwc/xsbG/8XFxf/GRkZ/w8PD/8AAADoAAAAJQAAAGAAAAD/BQUF/x4eHv8kJCT/JSUl/yYm + Jv8nJyf/FxcX/wEBAf8ICAj/JiYm/ywsLP8tLS3/Li4u/y8wL/8xMTH/MjIy/zMzM/8xMTH/Dg4O/gAA + AHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACLDQ0N/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xob + G/8bGxv/Gxsb/xwcHP8cHBz/HR0d/x0dHf8eHh7/Hx8f/xQUFP8BAQH1AAAAPQAAAHYAAAD/EhIS/yQk + JP8lJSX/JiYm/ycnJ/8oKCj/KCgo/xISEv8AAAD/Ghoa/y4uLv8uLi7/LzAw/zExMf8yMjL/MzMz/zQ0 + NP82Njb/IiIi/wEBAdcAAAAgAAAAAAAAAAAAAAAAAAAAAAAAACIDAwPbFRUV/xoaGv8ZGRn/GRkZ/xkZ + Gf8aGhr/Gxsb/xsbG/8bGxv/HBwc/xwcHP8dHR3/HR0d/x4eHv8eHh7/ICAg/xgYGP8CAgL8AAAAaAAA + AMIAAAD/FBQU/yUlJf8mJib/Jycn/ygoKP8pKSn/Kysr/yAhIf8BAQH/EhIS/y4vL/8vMDD/MTEx/zIy + Mv8zMzP/NDQ0/zU1Nf83Nzf/MjIy/wkJCf4AAABuAAAAAAAAAAAAAAADAAAAHAAAAIADAwP9CwsL/wkJ + Cf8HBwf/BgYG/wcHB/8JCQn/Dg4O/xUVFf8aGhr/HB0d/x0dHf8dHR3/Hh4e/x4eHv8fHx//ICAg/xcX + F/8CAgL+AAAAogQEBOgDAwP/BAQE/w4ODv8cHBz/Jycn/ykpKf8qKir/LCws/yAgIP8BAQH/FRUV/zAw + MP8xMTH/MjIy/zMzM/80NDT/NTU1/zY3N/84ODj/OTk5/xgYGP8AAAC/AAAADQAAAAAAAABjAAAA2wAA + APkAAAD/AAAA/wAAAP8AAAD/AQEB/wICAv8CAgL/AQEB/wICAv8HBwf/ERER/xoaGv8eHh7/Hx8f/x8f + H/8fHx//EhIS/wQEBPwAAADDHx8fxmtra/xubm7/ISEh8QAAANcCAgL7ExMT/ycoKP8qKyv/JCUl/w0N + Df8CAgL/ISEh/zExMf8yMjL/MzQ0/zU1Nf82Njb/Nzc3/zg4OP84ODj/Nzc3/yEhIf8AAADuAAAANgAA + AAAAAACrAAAA/wAAAP8DAwP/CAgI/w0NDf8SEhL/FRUV/xcXF/8XFxf/FRUV/w0NDf8FBQX/AQEB/wQE + BP8NDQ3/GBgY/x8fH/8TExP/AQEB+wAAAJEbGxtbhoaG8NfX1//c3Nz/lJSU+iIjI48AAACqAQEB/w0N + Df8PDw//BQUF/wICAv8VFRX/Ly8v/zAwMP8uLi7/Kysr/ygoKP8jIyP/HR0d/xcXF/8RERH/DAwM/wYG + Bv8BAQH/AAAAawAAAAAAAAA+AAAAxgQEBP8UFBT/GRkZ/xsbG/8bGxv/Gxsb/xsbG/8cHBz/HB0d/x0d + Hf8aGhr/ExMT/wkJCf8CAgL/AgIC/wgICP8DAwP/AAAAsgAAABNUVFSexsbG/+Dg4P/f39//0dHR/1hY + WPAAAADrAAAA/QAAAP0AAAD/AQEB/wsLC/8UFBT/ERER/wwMDP8ICAj/BQUF/wICAv0BAQH0AAAA5wAA + ANQAAAC8AAAAoAAAAIEAAABkAAAAKwAAAAAAAAAAAAAAdQcHB/8ZGRn/Ghoa/xobGv8bGxv/Gxsb/xwc + HP8cHBz/HR0d/x0dHf8eHh7/Hx8f/x8fH/8ZGRn/Dg4O/wICAv8AAAD/AAAA3wEBAaB8fHzl3Nzc/97e + 3v/e3t7/39/f/5CRkf8RERGxAAAAVgAAAKQAAAD/AQEB+QEBAe0AAADdAAAAyAAAAK4AAACQAAAAcQAA + AFMAAAA6AAAAJwAAAB4AAAAgAAAALQAAAEQAAABkAAAAVAAAAAIAAAAAAAAAkwgICP8aGhr/Gxsb/xsb + G/8bGxv/HBwc/xwdHf8dHR3/HR4e/x4eHv8dHR3/HR0d/xgYGP8NDQ3/CAgI/wICAv8AAAD/AAAA/xER + Ef+UlJT/2NjY/9/f3//e3t7/3t7e/6ampv9AQECOmpqaAAAAACMAAABfAAAARAAAACwAAAAcAAAAFAAA + ABcAAAAkAAAAOwAAAFkAAAB7AAAAnQAAALwAAADXAAAA6wICAvgBAQH/AAAAsgAAAAYAAAADAAAAqAkJ + Cf8aGhr/Gxsb/xoaGv8ZGRn/FxcX/xUVFf8SEhL/Dw8P/wsLC/8ICAj/BgYG/wICAv8AAAD/AAAA/wAA + AP8AAAD/AAAA/xQUFP+EhIT/19fY/9/f3//e3t7/39/f/6enp/81NTXCAAAADAEBAQgAAAAyAAAAUQAA + AHIAAACVAAAAtQAAANEBAQHmAgIC9QQEBP4ICAj/DQ0N/xQUFP8cHBz/JSUl/y0tLf8RERH/AAAAswAA + AAYAAAAFAAAAsQQEBP8MDAz/CQkJ/wYGBv8EBAT/AgIC/wEBAfoAAADwAAAA4AAAAMoAAADUAAAA/wAA + AP4AAAC/AAAAagAAAGsAAACUAAAAyigoKPa/v7//4ODg/97e3v/e3t7/39/f/9bW1v9jY2PkAAAAQgAA + AF4AAADsAAAA/AAAAP8AAAD/AAAA/wUFBf8PDw//GBgY/yEhIf8oKCj/Li4u/zU1Nf87Ozv/P0BA/0ND + Q/8YGBj/AAAAqAAAAAMAAAAFAAAAqgAAAO8AAADZAAAAwgAAAKYAAACIAAAAaAAAAEoAAAAwAAAAHAAA + ABAAAACWAAAA/wAAANoAAABbAAAAVAAAAHMAAAA8AAAADEhISKvDw8P/4ODg/97e3v/e3t7/39/f/9ra + 2v9ra2v+AgIC8AAAAPIBAQH/AwMD/wICAv8AAAD/AAAA/wAAAP8CAgL/AwMD/wQEBP8EBAT/BQUF/wcH + B/8KCgr/EBAQ/xgYGP8KCgv/AAAAngEBAQIAAAABAAAAKAAAACkAAAAXAAAADgAAAA8AAAAZAAAAKwAA + AEQAAABhAAAAgAAAAKEAAADnAAAA/wAAAPcBAQHzAgIC/QMDA/8BAQG/AAAAQi8vL8K4uLj/4ODg/97e + 3v/e3t7/39/f/9fX1/9kZGTzAAAAxQAAAPoUFBT/Kioq/ycnJ/8iIiL/HBwc/xUVFf8QEBD/DAwM/wkJ + Cf8HBwf/BgYG/wUFBf8DAwP/AQEB/wAAAP8AAAD/AAAA4gAAADQAAAAAAAAAJAAAAG0AAACNAAAAqwAA + AMYAAADcAAAA7QEBAfkCAgL+BQUF/wUFBf8BAQH/AQEB/w8PD/8YGBj/HR0d/xkZGf8DAwP8AAAA8hAQ + EP6Tk5P/39/f/9/f3//f39//4eHh/729vf84ODjsAAAAxwMDA/4lJSX/MzQ0/zc3N/86Ojr/Ozs7/zs7 + O/87Ozv/Ojo6/zk5Of84ODj/Nzg4/zc3N/81NTX/MTEy/ycnJ/8GBgb9AAAAuQAAACMAAAAAAAAASQAA + APgDAwP/BwcH/woKCv8ODg7/EhIS/xYWFv8XFxf/EhIS/wgICP8AAAD/BQUF/yEhIf8nJyf/Hh4e/woK + Cv8AAAD/AAAA/wAAAP81NTX/o6Oj/9LS0v/R0dH/uLi4/1dXWP8GBgb+AAAA/wEBAf8GBgb/CQkJ/w4O + Dv8eHh7/ODg4/z09Pf8+Pj7/Pz8//0FBQf9CQkL/Q0ND/0RFRf9GRkb/SEhI/zk6Ov8GBgbgAAAAJgAA + AAAAAAAAAAAAHQAAANoNDQ3/HR0d/x4eHv8gICD/Gxsb/w8PD/8GBgb/AQEB/wAAAP8EBAT/GBgY/yYm + Jv8ZGRn/BAUF/wAAAP8DAwP/Dw8P/wcHB/8BAQH/HBwc/0hISP9LS0v6LS0t6wUFBf8GBgb/HBwc/yAg + IP8YGBj/EhIS/wcHB/8BAQH/Jycn/z8/P/8/Pz//QEBA/0FBQf9DQ0P/RERE/0VFRf9GRkb/SUlJ/ysr + K/8AAACtAAAABQAAAAAAAAAAAAAAAgAAAJsICAj/HR0d/x8gIP8ZGRn/BQUF/wAAAP8CAgL/CAgI/xIS + Ev8fHx//JiYm/xoaGv8DAwP/AAAA/wgICP8eHh7/Kysr/yYmJv8YGBj/BQUF/wAAAP8AAADHAAAAdgEB + AfwjIyP/Nzc3/zk5Of85OTn/Ojo6/xoaGv8AAAD/KCgo/0BAQP9AQED/QUFB/0NDQ/9ERET/RUVF/0ZG + Rv9HSEj/R0dH/xkZGf0AAABlAAAAAAAAAAABAQEAAAAAAAAAAEkDAwP1GRkZ/x8fH/8KCgr/AAAA/wwM + DP8bGxv/IiIi/yUlJf8nJyf/ISEh/wYGBv8AAAD/CgoK/yQkJP8tLS3/LS0t/y8vL/8sLCz/CQkJ/wAA + AP8AAAB+AAAAPQEBAfUkJCT/OTk5/zk5Of86Ojr/PDw8/xkZGf8AAAD/Kioq/0FBQf9BQUH/Q0ND/0RE + RP9FRUX/RkZG/0dHR/9JSUn/PT09/wkJCdsAAAAhAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAC4Dw8P/xsb + G/8DAwP/BgYG/yAgIP8lJSX/JSUl/yYmJv8nJyf/FhYW/wAAAP8GBgb/IyMk/y0tLf8tLS3/Li4u/zAw + MP8jIyP/AgIC/wAAAP8AAABpAAAAJAAAAOgeHh7/Ojo6/zo6Ov87Ozv/PT09/ygoKP8BAQH/EBAQ/zs7 + O/9DQ0P/RERE/0VFRf9GRkb/R0dH/0lJSf9KSkr/JiYm/wAAAMoAAAAQAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABRBQUF9RISEv8BAQH/Dg4O/yQkJP8lJSX/JiYm/ycnJ/8oKCj/ERER/wAAAP8QEBD/LCws/y0t + Lf8uLi7/LzAv/zExMf8YGBj/AAAA/wAAAP8AAACKAAAAEwAAANQYGBj/Ozs7/zw8PP8+Pj7/Pj4//zs7 + O/8TExP/AAAA/xUVFf88PDz/RkZG/0ZGRv9HR0f/SUlJ/0pKSv9BQUH/DAwM/wAAAOgAAAAoAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAJAQEBpgQEBP8AAAD/ExMT/yUlJf8mJib/Jycn/ygoKP8pKSn/FxcX/wAA + AP8HBwf/JCQk/y8vL/8vMDD/MTEx/zAwMP8ODg7/AAAA/wAAAP8AAACsAAAAJQAAAM0JCQn/Ghsb/x0d + Hf8oKCj/ODg4/0FBQf82Njb/DAwM/wAAAP8RERH/ODg4/0hISP9JSUn/SkpK/0tLS/8kJCT/AAAA/wAA + AOoAAAAqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALwAAAN0AAAD/FRUV/yYnJ/8nJyf/KCgo/ykp + Kf8qKir/JSUl/wgICP8AAAD/CQkJ/yUlJf8xMTH/MjIy/y0tLf8HBwf/AAAA/wICAv8AAADsAAAA2QAA + APsAAAD/AAAA/wAAAP8AAAD/CwsL/ywsLP9DQ0P/NjY2/w4ODv8AAAD/CQkJ/y4uLv9ISUn/TU1N/zk5 + Ov8HBwf/AAAA/wAAAM8AAAAVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAAAHIAAAD/FRUV/ygo + KP8oKCj/KSkp/yoqKv8rKyv/LC0t/yEhIf8GBgb/AAAA/wYGBv8iIiL/NDQ0/ykpKf8DAwP/AAAA/wEB + Af8AAAD/AAAA9AAAAOgEBAT/ISEh/yYmJv8YGBj/AwMD/wcHB/80NDT/R0dH/zs7O/8VFRX/AAAA/wMD + A/8fHx//NDQ0/xISEv8AAAD/AAAA/gAAAHoAAAAAAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AD4AAAD0DAwM/yYmJv8pKSn/Kioq/ysrK/8sLCz/LS0t/y8vL/8kJSX/CgoK/wAAAP8EBAT/IyMj/yoq + Kv8EBAT/AAAA/wEBAf8BAQH5AAAAZQAAAG4EBAT/MjIy/0JCQv9BQUH/JSYm/wEBAf8XFxf/REVF/0hI + SP9DQ0P/Hx8f/wMDA/8AAAD/AgIC/wAAAP8AAAD/AAAAqwAAABMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAABgAAADOAQEB/xISEv8oKCj/Kysr/ywsLP8tLS3/Li4u/y8vL/8xMTH/Kioq/w4O + Dv8AAAD/CAgI/yssLP8iIiL/HBwc/x4eHv8CAgL7AAAATAAAAEMBAQH4LCws/0JCQv9DQ0P/QEBA/xAQ + EP8FBQX/Ojs7/0lJSf9KSkr/SUlJ/y0tLf8FBQX9AAAA6QAAANUAAACIAAAAGAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAABDAAAAsgEBAdcTExP7Kioq/y4uLv8uLi7/LzAv/zEx + Mf8yMjL/NDQ0/y0tLf8KCgr/AAAA/xsbG/86Ojr/Ozs7/zIyMv8FBQX/AAAAbgAAACoAAADsJSUl/0RE + RP9ERET/RkZG/yQkJP8AAAD/LS0t/0tLS/9MTEz/SUlJ/yUlJf8DAwOrAAAALAAAABYAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAAAAAQEBBgAAABoBAQGREBAQ+Cgo + KP8wMDD/MTEx/zIyMv8zMzP/NDQ0/zY2Nv8bGxv/AAAA/xEREf85OTn/PDw8/zc3N/8KCgr/AAAAkAAA + ABkAAADbHh4e/0RERP9FRUX/R0dH/zQ0NP8BAQH/ISEh/01NTf9ERUX/Hh4e/QMDA6YAAAAYAAAABwAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAJAAAAbgsLC+giIiL/MTEx/zM0NP80NDT/NTU1/zc3N/8ZGhr/AAAA/xMTE/86Ozv/PT09/zw8 + PP8QEBD/AAAAsAAAABEAAADEFhYW/0RERP9GRkb/SEhI/zk5Of8DAwP/HBwc/zk5Of8TExP3AQEBkAAA + ABEAAAATAAAAPAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAD8EBAS+FRUV/CsrK/81NTX/ODg4/zIzM/8LCwv/AAAA/yAg + IP89PT3/Pj4+/z8/P/8YGBj/AAAAzAAAABMAAACoDxAP/0NDQ/9ISEj/SkpK/yYmJv8AAAD/CgoK/wgI + COEAAABmAAAABwAAAAwAAABmAAAAJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAcQcHB9cYGBj9Kysr/xoa + Gv8AAAD/CwsL/zU1Nf8/Pz//Pz8//0FBQf8hISH/AAAA4gAAACAAAACJCgoK/0BAQP9GRkb/ODg4/w0N + Df8AAAD2AAAAqgAAADIAAAAAAAAADwAAAHoAAABPAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA + ADEAAAC0AwMD/wICAv8BAQH/HBwc/zU1Nf87Ozv/Pj4+/0BBQf8oKCj/AQEB8gAAADYAAABpBAQE/xsb + G/8TExP/BQUF+QAAAP8AAACUAAAABgAAAAAAAAAoAAAAmAAAAGcAAAADAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAA8AAAAWAAA + AGoAAAB+AAAAmwAAAMUAAADnAAAA4wAAAKgBAQGdAwMD0gcHCPEMDAz+EBAQ/xISEv8MDAz/AQEB/QAA + AFMAAABLAAAA8wAAANkAAACZAAAAWgAAANYAAACtAAAATAAAAIIAAAC8AAAAYQAAAAQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAMAAAASAAAAKAAAAD8AAABTAAAAXgAAAFkAAABFAAAAJAAAAAYAAAACAAAAFQAAADgAAABdAAAAfQAA + AJMAAACdAAAAnQAAAD8AAAAVAAAAQgAAABsBAQECAQEBAAAAAFgAAADLAAAAzQAAAJsAAAA0AQEBAQEB + AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAGdnZwADAwMAAwMDAAAAAAAAAAAAAQEBAAAAAAAAAAAAAQEBAAEBAQEAAAAUAAAAFwEB + AQQAAAAABwcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///g///8AAP// + gAP//wAA//4AAH//AAD/+AAAA/8AAP/AAAAB/wAA/8AAAAD/AAD/gAAAAP8AAP8AAAAAfwAA/gAAAAB/ + AAD8AAAAAD8AAPgAAAAAHwAA+AAAAAAPAADwAAAAAA8AAPAAAAAABwAA4AAAAAAHAADgAAAAAAMAAMAA + AAAAAwAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAACAAAAAAAAAAIAAAAgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAIAAAAAAAQAAgAAAAAABAACAAAAAAAMAAMAA + AAAAAwAAwAAAAAADAADgAAAAAAMAAOAAAAAAAwAA8AAAAAADAAD4AAAAAAcAAPgAAAAABwAA+AAAAAAP + AAD8AAAAAB8AAP4AAAAAPwAA/4AAAAA/AAD/wAAAAH8AAP/wAAAI/wAA//gAABD/AAD/AAAAAf8AAP8A + AAED/wAA/////w//AAAoAAAAQAAAAIAAAAABACAAAAAAAABAAAATCwAAEwsAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEAAAAACAAA + AAUAAAAJAAAASwAAAF8AAABeAAAAVQAAAEYAAAAxAAAAGwAAAAkBAQEAAQEBAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEAAQEBAQEB + ARQAAABGAAAAhAAAALgAAABNAAAAEAAAANEAAAD/AAAA/wAAAP0AAAD4AAAA7gAAANsAAAC8AAAAjQAA + AFUAAAAiAAAABAAAAAACAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB + AQABAQEEAAAAMAAAAIIAAADNAAAA9gAAAP8AAAD/AAAAdwAAAAMAAAC5AQEB/wgICP8MDAz/DAwM/wsL + C/8JCQn/BwcH/wQEBP8BAQH7AAAA4AAAAKYAAABXAAAAFwEBAQABAQEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAMAAAA2AAAAmwAAAOgBAQH/BAQE/wkJCf8HBwf/AAAA/wAAAJMAAAAAAAAAmwAA + AP8QEBD/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8ZGRn/FRUV/xAQEP8ICAj/AwMD+gEBAc8AAAB3AAAAKgAA + ACQAAAAmAAAAGwEBAQcAAAAAAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAQEBAAEBAQIBAQEkAAAAKgAAACcAAACNAAAA6QICAv8JCQn/ERER/xcXF/8aGhr/ERER/wEB + Af8AAACuAAAAAAAAAHsAAAD/DQ0N/xsbG/8bGxv/HBwc/xwcHP8cHBz/HR0d/x4eHv8eHh7/HR0d/xQU + FP8EBAT/AAAA/QAAAOcAAADlAAAA5gAAANwAAACvAAAAUAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAAAAAAAABZAAAA4AAAAOgAAADhAwMD/gsLC/8VFRX/GRkZ/xoa + Gv8aGhr/Ghoa/xMTE/8BAQH/AAAAxgAAAAgAAABaAAAA/gkJCf8bGxv/HBwc/xwcHP8cHBz/HR0d/x0d + Hf8eHh7/Hh4e/xMTE/8FBQX/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAPUAAACQAAAAEQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWAAAAzQAAAP8AAAD/AAAA/wkJ + Cf8ZGRn/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8WFhb/AwMD/wAAANoAAAAWAAAAPQAAAPQHBwf/Ghoa/xwc + HP8cHBz/HR0d/x0dHf8eHh7/Hh4e/xISEv8CAgL/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/QAAAJkAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAAAAAAAAUwAA + APgDAwP/BAQE/wAAAP8CAgL/EBAQ/xoaGv8YGBj/Dw8P/woKCv8QEBD/FxcX/wQEBP8AAADqAAAAKQAA + ACMAAADmBAQE/xkZGf8cHR3/HR0d/x0dHf8eHh7/Hh4e/xkZGf8EBAT/AAAA/wAAAP8BAQH/BwcH/w0N + Df8QEBD/Dw8P/wwMDP8FBQX/AAAA/wAAAP8AAAD6AAAAcwEBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAQgEBAdYFBQX/EhIS/xMTE/8CAgL/AAAA/wMDA/8PDw//CQkJ/wEBAf8AAAD/AQEB/xAQ + EP8HBwf/AAAA9gAAAEAAAAAQAAAA0QICAv8XFxf/HR0d/x0dHf8eHh7/Hh4e/x8fH/8QEBD/AAAA/wAA + AP8CAgL/ExMT/x8gIP8jIyP/JCQk/yQkJP8kJCT/ISEh/xEREf8CAgL/AAAA/wAAAOUAAAA3AAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBAQAAAAAAAAAASgEBAd8LCwv/FxcX/xoaGv8aGhr/Dg4O/wEBAf8AAAD/AQEB/wAA + AP8AAAD/AAAA/wAAAP8JCQn/CQkJ/wAAAP0AAABaAAAAAwAAALcBAQH/FBQU/x4eHv8eHh7/Hh4e/x8f + H/8eHh7/CgoK/wAAAP8AAAD/DQ0N/yIiIv8jIyP/IyMj/yQkJP8lJSX/JSUl/yYnJ/8mJib/FxcX/wMD + A/8AAAD/AAAAogAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARQEBAeAMDAz/GRkZ/xoaGv8aGhr/Ghoa/xkZ + Gf8MDAz/AQEB/wAAAP8AAAD/AgIC/wICAv8AAAD/CAgI/wsLC/8AAAD/AAAAdgEBAQAAAACaAAAA/xER + Ef8eHh7/Hh4e/x8fH/8fHx//Hh4e/wgICP8AAAD/AAAA/xUVFf8jIyP/IyMj/yQkJP8lJSX/JSUl/yYm + Jv8nJyf/KCgo/ygoKP8bGxv/BAQE/wAAAOoAAAAyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANwEBAdkMDAz/GRkZ/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/GRkZ/xEREf8LCwv/DAwM/xMTE/8GBgb/AAAA/wgICP8ODg7/AAAA/wAA + AJIAAAAAAAAAeQAAAP8ODg7/Hx8f/x8fH/8fHx//ICAg/x8fH/8KCgr/AAAA/wAAAP8UFBT/JCQk/yQk + JP8lJSX/JSUl/yYmJv8nJyf/KCgo/ygoKP8pKSn/Kioq/xwcHP8EBAT/AAAAhAEBAQIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIQAA + AMYLCwv/GRkZ/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xsbG/8ZGRn/BgYG/wAA + AP8KCgr/EhIS/wEBAf8AAACsAAAAAAAAAFkAAAD9CgoK/xwcHP8aGhr/Gxsb/yAgIP8hISH/EBAQ/wAA + AP8AAAD/DAwM/yMjI/8lJSX/JSUl/yYmJv8nJyf/KCgo/ygoKP8pKSn/Kioq/ysrK/8sLCz/Gxsb/wMD + A+8AAABaAAAAAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAADAAAAKQICAj/GBgY/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8bGxv/GRkZ/wUFBf8AAAD/DAwM/xUVFf8BAQH/AAAAxAAAAAwAAABPAAAA9wMDA/8GBgb/AwMD/wQE + BP8SEhL/ISEh/xkZGf8CAgL/AAAA/wMDA/8dHR3/JiYm/yYmJv8nJyf/KCgo/ygoKP8pKSn/Kioq/ysr + K/8sLCz/LC0t/y0tLf8WFhb/AQEB4QAAADsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAEBAT6FRUV/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGxv/Gxsb/xgYGP8EBAT/AAAA/w8PD/8YGBj/AwMD/wAAAOgAAAClAAAA3AAA + AP4AAAD/AgIC/wICAv8AAAD/CAgI/yAgIP8iIiL/DAwM/wAAAP8AAAD/Dg4O/yUlJf8nJyf/KCgo/ygo + KP8pKSn/Kioq/ysrK/8rLCz/LCws/y0tLf8uLi7/LCws/w8PD/8AAADDAAAAGwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUBAQHjEBAQ/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Gxsb/xsbG/8WFhb/AgIC/wAAAP8KCgr/CwsL/wEB + Af8AAAD/AAAA/wAAAPkAAAD6AgIC/w8PD/8EBAT/AAAA/xISEv8jIyP/JCQk/xwcHP8EBAT/AAAA/wIC + Av8ZGRn/KCgo/ygoKP8pKSn/Kioq/ysrK/8sLCz/LCws/y0tLf8uLi7/Ly8v/zAwMP8nKCj/BgYG/wAA + AI8AAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsAAACrCQkJ/xkZ + Gf8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGxv/Gxsb/xsbG/8bHBz/FxcX/wMD + A/8AAAD/AAAA/wAAAP8AAAD/AAAA/gAAALEAAABSAAAAvwEBAf8FBQX/AAAA/wgICP8gICD/IyQk/yQk + JP8lJSX/FhYW/wEBAf8AAAD/BgYG/yEhIf8qKir/Kioq/ysrK/8sLCz/LCws/y0tLf8uLi7/Ly8v/zAw + MP8xMTH/MjIy/xwcHP8BAQHwAAAASwAAAAABAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAA + AAAAAABXAwMD9hUVFf8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGxv/Gxsb/xsb + G/8bGxv/HBwc/xsbG/8QEBD/BQUF/wYGBv8KCgr/BQUF/wAAAP0AAABaAQEBAAAAAJgAAAD/AAAA/wMD + A/8ZGRn/JCQk/yQkJP8lJSX/JSYm/yUlJf8SEhL/AQEB/wAAAP8NDQ3/KCgo/ysrK/8sLCz/LCws/y0t + Lf8uLi7/Ly8v/zAwMP8xMTH/MTIy/zMzM/8vLy//DAwM/wAAAL8AAAATAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAASAAAAwQwMDP8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGxv/Gxsb/xsbG/8bGxv/HBwc/xwcHP8cHBz/HR0d/xsbG/8bHBz/Hh4e/w0NDf8AAAD/AAAAdAAA + AAAAAAB4AAAA/wAAAP8PDw//IyMj/yQkJP8lJSX/JSUl/yYmJv8nJyf/JSUl/w8PD/8AAAD/AQEB/xoa + Gv8sLCz/LCws/y0tLf8uLi7/Ly8v/zAwMP8xMTH/MTIy/zIyMv8zMzP/NTU1/yIiIv8BAQH7AAAAZwAA + AAABAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXAMDA/oVFRX/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGxv/Gxsb/xsbG/8bGxv/HBwc/xwcHP8cHBz/HR0d/x0dHf8eHh7/Hh4e/x8f + H/8RERH/AAAA/wAAAJABAQEAAAAAjAAAAP8FBQX/Hh4e/yQkJP8lJSX/JSUl/yYmJv8nJyf/KCgo/ykp + Kf8lJSX/CQkJ/wAAAP8LCwv/Kioq/y0tLf8uLi7/Ly8v/zAwMP8xMTH/MTIy/zIyMv8zMzP/NDQ0/zU1 + Nf8yMjL/DAwM/wAAAMoAAAAWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAALkKCgr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGxv/Gxsb/xsbG/8bGxv/HBwc/xwcHP8cHBz/HR0d/x0d + Hf8eHh7/Hh4e/x8fH/8gICD/FBQU/wEBAf8AAACpAAAAIAAAANcAAAD/CAgI/yIiIv8lJSX/JSUl/yYm + Jv8nJyf/KCgo/ygoKP8pKSn/Kysr/xoaGv8AAAD/BAQE/yUlJf8vLy//Ly8v/zAwMP8xMTH/MTIy/zIy + Mv8zMzP/NDQ0/zU1Nf82Njb/Nzg4/x4eHv8AAAD7AAAAXwAAAAABAQEAAAAAAAAAAAAAAAAAAAAAAAAA + AEEBAQHyEhIS/xkZGf8XFxf/FhYW/xUVFf8VFRX/FhYW/xgYGP8ZGhr/Gxsb/xsbG/8bGxv/HBwc/xwc + HP8cHBz/HR0d/x0dHf8eHh7/Hh4e/x8fH/8fHx//ICAg/xgYGP8CAgL/AAAAvwAAAF0AAAD5AAAA/wQE + BP8cHBz/JCQk/ycnJ/8nJyf/KCgo/ygoKP8pKSn/Kioq/ysrK/8hISH/AgIC/wICAv8kJCT/LzAw/zAw + MP8xMTH/MTIy/zIyMv8zMzP/NDQ0/zU1Nf82Njb/Nzc3/zg4OP8vLy//BQUF/wAAALYAAAAKAAAAAAAA + AAABAQEAAAAADQAAADMAAACnAQEB/wcHB/8GBgb/BAQE/wMDA/8CAgL/AgIC/wMDA/8EBAT/BwcH/w0N + Df8VFRX/Ghoa/xwcHP8dHR3/HR0d/x0dHf8eHh7/Hh4e/x8fH/8fHx//ICAg/yAgIP8VFRX/AgIC/wAA + ANUAAACZBAQE/wMDA/8AAAD/AwMD/wkJCv8XFxf/JSUl/ykpKf8pKSn/Kioq/ysrK/8sLS3/HB0d/wEB + Af8EBAT/Jycn/zAwMP8xMTH/MTIy/zIyMv8zMzP/NDQ0/zU1Nf82Njb/Nzc3/zg4OP85OTn/ODg4/xER + Ef8AAADtAAAANwAAAAAAAAAAAAAALgAAALYAAADvAAAA/gAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AgIC/wgICP8RERH/GRkZ/x0dHf8eHh7/Hh4e/x8fH/8fHx//ICAg/x0d + Hf8ODg7/AgIC/wAAAOoAAAC0JCQk22BgYf9iYmL/JSUm/wEBAeYAAADyAQEB/wwMDP8iIiL/Kysr/ysr + K/8sLCz/JiYm/wsLC/8AAAD/Dg4O/y4uLv8xMTH/MTIy/zIyMv8zMzP/NDQ0/zU1Nf82Njb/Nzc3/zg5 + Of86Ojr/Ojs6/zw8PP8eHh7/AAAA/wAAAHkAAAAAAAAAAAAAAI8AAAD/AAAA/wAAAP8AAAD/AAAA/wIC + Av8EBAT/CAgI/wsLC/8ODg7/EBAQ/xAQEP8ODg7/CAgI/wICAv8AAAD/AAAA/wQEBP8NDQ3/FxcX/x4e + Hv8gICD/ICAg/x0eHv8LCwv/AAAA/wAAAM8AAABOLCwsqoyMjP/Oz8//09PT/5+fn/81NTXRAAAAbgAA + AMUAAAD+CAgI/x8fH/8gICD/FRUV/wcHB/8AAAD/BAQE/yIiIv8xMjL/MjIy/zMzM/80NDT/NTU1/zU1 + Nf80NDT/MzMz/zAwMP8sLCz/Jycn/yEhIf8bGxv/Dg4O/wAAAP8AAAC4AAAACAAAAAAAAAB1AAAA+gAA + AP8BAQH/BwcH/w4ODv8UFBT/GBgY/xoaGv8bGxv/Gxsb/xsbG/8cHBz/HBwc/xsbG/8XFxf/Dw8P/wYG + Bv8BAQH/AAAA/wICAv8JCgr/FBQU/xwcHP8ODg7/AAAA/wAAAMwAAAArEBAQQnBwcPLU1NT/4ODg/9/f + 3//b29v/hYWF/x8fH5kAAACGAAAA9QAAAP8DAwP/AgIC/wAAAP8AAAD/BwcH/x4dHv8uLi7/LCws/ykp + Kf8lJSX/ICAg/xoaGv8VFRX/Dw8P/woKCv8GBgb/AwMD/wEBAf8AAAD/AAAA/wAAAP4AAAD4AAAAzQAA + ABsAAAAAAAAAEQAAAHwAAADsBQUF/xcXF/8aGhr/Ghoa/xoaGv8bGxv/Gxsb/xsbG/8bGxv/HBwc/xwc + HP8cHBz/HR0d/x0dHf8bGxv/FBQU/woKCv8DAwP/AAAA/wEBAf8FBQX/AgIC/wAAAO0AAABH397fADMz + M5SsrKz/4ODg/97e3v/e3t7/4ODg/8DAwP9FRUX9AAAA/gAAAP8AAAD+AAAA/wAAAP8AAAD/BAQE/w4O + Dv8QEBD/CwsL/wcHB/8EBAT/AgIC/wAAAP8AAAD/AAAA/wAAAPoAAADwAAAA4QAAAM0AAAC0AAAAmAAA + AHoAAABbAAAAPwAAACUAAAAFAAAAAAAAAAAAAAAUAAAA0QcHB/8ZGRn/Ghoa/xoaGv8aGhr/Gxsb/xsb + G/8bGxv/HBwc/xwcHP8cHBz/HR0d/x0dHf8eHh7/Hh4e/x8fH/8eHh7/Ghoa/xAQEP8GBgb/AQEB/wAA + AP8AAAD3AAAAtwAAAHlYWFjaz8/P/9/f3//e3t7/3t7e/9/f3//Y2dn/eHh4/wsLC9MAAACFAAAAZwAA + ANAAAAD/AAAA/wEBAf8AAAD/AAAA/QAAAPUAAADoAAAA1gAAAL8AAAClAAAAhwAAAGkAAABMAAAAMgAA + ABwBAQEMAQEBAwAAAAMAAAALAAAAHAAAADQAAABRAAAAHgAAAAAAAAAAAAAAJwAAAOcJCQn/Ghoa/xoa + Gv8aGxv/Gxsb/xsbG/8bGxv/HBwc/xwcHP8cHBz/HR0d/x0dHf8eHh7/Hh4e/x8fH/8gICD/Hx8f/xoa + Gv8UFBT/Dg4O/wICAv8AAAD/AAAA/wAAAP8HBwf+goKC/9vb2//e3t7/3t7e/97e3v/e3t7/3d3d/5+f + n/8xMTGcAAAAAQAAAAAAAABeAAAAygAAALEAAACVAAAAdwAAAFkAAAA+AAAAJgAAABMBAQEFAQEBAAEB + AQABAQEHAAAAFwAAAC4AAABKAAAAawAAAI0AAACuAAAAygAAAOEAAADyAAAA+QAAAFMAAAAAAAAAAAAA + ADsAAAD0CwsL/xoaGv8aGxv/Gxsb/xsbG/8bGxv/HBwc/xwcHP8dHR3/HR0d/x0dHf8dHR3/HBwc/xob + G/8YGBj/FRUV/wwMDP8DAwP/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/Gxsb/4uLi/+6urr/39/g/97e + 3v/e3t7/39/f/9bW1v+SkpL/Q0NDzwAAABMBAQEAAAAABQAAAAsBAQEBAQEBAAAAAAABAQEEAAAAEgAA + ACgAAABDAAAAYwAAAIQAAAClAAAAwwAAANsAAADuAAAA+gAAAP8AAAD/AQEB/wQEBP8ICAj/BQUF/wAA + AP4AAABZAAAAAAAAAAAAAABLAAAA+gsLC/8bGxv/Gxsb/xsbG/8aGhr/GRkZ/xcXF/8VFRX/EhIS/w8P + D/8MDAz/CQkJ/wYGBv8EBAT/AgIC/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/xQU + FP9sbGz/zs7O/9/f3//e3t7/3t7e/97e3v/f39//oKCg/y8vL+8AAAA1AgICAAEBAQwAAAA7AAAAWgAA + AHsAAACcAAAAuwAAANUAAADpAAAA9wAAAP4AAAD/AQEB/wMDA/8GBgb/CwsL/xISEv8aGhr/IiIi/ysr + K/8zMzP/Ojo6/xoaGv8AAAD9AAAAVwAAAAAAAAAAAAAAVQAAAP0HBwf/EBAQ/w0NDf8KCgr/BwcH/wUF + Bf8DAwP/AQEB/wEBAf8AAAD/AAAA/wAAAPoAAADvAAAA5gAAAPwAAAD/AAAA/wAAAO4AAACjAAAAgQAA + AJAAAAC2AAAA4AAAAPopKSn/u7u7/+Hh4f/e3t7/3t7e/97e3v/e3t7/39/f/9nZ2f9ra2z8DQ0NXP// + /wAAAABRAAAA8AAAAP0AAAD/AAAA/wAAAP8AAAD/AQEB/wYGBv8PDw//GBgY/yEhIf8pKSn/MDAw/zY2 + Nv87Ozv/Pj4+/0FBQf9DQ0P/RERE/0VFRf8eHh//AAAA+gAAAEwAAAAAAAAAAAAAAFcAAAD9AAAA/wAA + AP8AAAD/AAAA/gAAAPcAAADqAAAA2AAAAMEAAACmAAAAiQAAAGoAAABNAAAALwAAAGoAAAD6AAAA/wAA + AOcAAABWAQEBBQEBAQkAAAAaAAAAGAAAACAAAABeRUVF48TExP/g4OD/3t7e/97e3v/e3t7/3t7e/97e + 3v/b29v/gYGB/w4ODtoAAAC5AAAA2AAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf8EBAT/BwcH/woK + Cv8MDAz/DQ0N/w0NDf8ODg7/ERER/xUVFf8aGhr/ISEh/ykpKf8zMzP/GRkZ/wAAAPMAAAA7AAAAAAAA + AAAAAABGAAAAzQAAALgAAACbAAAAfQAAAF8AAABDAAAAKgAAABYAAAAHAQEBAAEBAQAAAAAAAAAAAwAA + AA0AAACaAAAA/wAAAP8AAADMAAAAjQAAAKsAAADGAAAA3wAAAJMAAAADAAAADEZGRsa9vb3/4ODg/97e + 3v/e3t7/3t7e/97e3v/e3t7/2tvb/4GBgf8NDQ3/AAAA/wAAAP8CAgL/CQkJ/wkJCf8HBwf/AwMD/wEB + Af8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8BAQH/AwMD/wMD + A/8AAAD2AAAAVwAAAAAAAAAAAAAACAAAAA8BAQEDAQEBAAAAAAAAAAAAAQEBBgAAABUAAAAoAAAAQQAA + AF0AAAB7AAAAmQAAALYAAADPAAAA8wAAAP8AAAD/AAAA/wAAAP8BAQH/AgIC/wICAv8AAADtAAAAWQAA + AGksLCzor6+v/+Dg4P/e3t7/3t7e/97e3v/e3t7/39/f/9fX1/9zc3P+CgoKswAAAMUAAAD/ERER/zAx + Mf8yMjL/MDAw/ywsLP8nJyf/ICAg/xoaGv8UFBT/EBAQ/wwMDP8JCQn/CAgI/wYGBv8FBQX/BAQE/wMD + A/8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAMgAAAATAAAAAAAAAAMAAAArAAAATAAAAGgAAACHAAAApQAA + AMAAAADXAAAA6QAAAPYAAAD+AAAA/wAAAP8BAQH/AgIC/wEBAf8AAAD/AgIC/w4ODv8TFBT/GBgY/x0d + Hf8ZGRn/AgIC/wAAAPIAAAD6FBQU/46Pj//c3Nz/39/f/97e3v/e3t7/3t7e/+Dg4P/ExMT/SkpK+wAA + AKAAAADeAwMD/yYmJv83Nzf/ODg4/zk5Of86Ojr/Ojs7/zs7O/88PDz/PDw8/zs7O/86Ojr/OTk5/zg4 + OP83Nzf/NjY2/zU1Nf8zMzP/Ly8v/yoqKv8fHx//BQUF/wAAAPoAAACiAAAACwAAAAAAAAAIAAAAsQAA + AP0AAAD/AAAA/wAAAP8BAQH/AwMD/wUFBf8HBwf/CwsL/w8PD/8TExP/FBQU/wsLC/8BAQH/AAAA/wgI + CP8jIyP/JiYm/ycnJ/8jIyP/ERER/wEBAf8AAAD/AAAA/wMDA/9KSkr/s7Oz/97e3v/g4OD/4ODg/+Dg + 4P/Ozs7/eXp6/xMTE/8AAAD/AAAA/wMDA/8RERH/FxcX/xwcHP8jIyP/Ly8v/zo6Ov87Ozv/PDw8/z09 + Pf8+Pj7/Pz8//0BAQP9BQUH/QkJC/0NDQ/9ERET/RUVF/0ZGRv9ISEj/PDw9/wcHB/8AAACOAAAADwAA + AAAAAAAAAAAAAAAAAIkAAAD/BgYG/w8PD/8SEhL/FhYW/xkZGf8cHBz/Hx8f/x4eHv8ZGRn/EBAQ/wcH + B/8BAQH/AAAA/wEBAf8UFBT/JiYm/yYmJv8eHh7/CQkJ/wAAAP8AAAD/AAAA/wAAAP8AAAD/CAgI/0RE + RP+YmJj/ubm5/7a2tv+kpKT/ampr/xkZGf4AAAD+AQEB/wQEBP8CAgL/AAAA/wAAAP8AAAD/AAAA/wYG + Bv8kJCT/PDw8/z09Pf8+Pj7/Pz8//0BAQP9BQUH/QkJC/0NDQ/9DRET/RERE/0VFRf9GRkb/SEhI/zEx + Mf8CAgL0AAAAQgAAAAAAAAAAAAAAAAAAAAAAAABJAAAA9wkJCf8dHR3/Hx8f/x8fH/8gICD/Hh4e/xMT + E/8ICAj/AgIC/wAAAP8AAAD/AAAA/wMDA/8RERH/JCQk/yYmJv8bGxv/BQUF/wAAAP8AAAD/AQEB/w4O + Dv8TExP/BAQE/wAAAP8CAgL/GBgY/zAxMf8xMjL/IyMj5gkJCfMAAAD/BAQE/xcXF/8rKyv/Jycn/yAg + IP8aGhr/FBQU/wcHB/8AAAD/DQ0N/zo6Ov8+Pj7/Pz8//0BAQP9BQUH/QkJC/0NDQ/9DRET/RERE/0VF + Rf9GRkb/R0dH/0hJSf8gICH/AAAAzwAAABUAAAAAAAAAAAAAAAAAAAAAAAAAFgAAAM8EBAT/Ghoa/x8f + H/8fHx//Hh4e/w0NDf8BAQH/AAAA/wAAAP8BAQH/BQUF/w8PD/8cHBz/JSUl/ycnJ/8bGxv/BAQE/wAA + AP8AAAD/BAQE/xgYGP8pKir/LCws/yQkJP8UFBT/CAgI/wAAAP8AAAD/AAAA9AAAAFoAAAC/AQEB/x8f + H/81NTX/ODg4/zk5Of85Ojr/Ojo6/zk5Of8UFBT/AAAA/w8PD/87Ozv/Pz8//0BAQP9BQUH/QkJC/0ND + Q/9DRET/RERE/0VFRf9GRkb/R0dH/0hISP9ERET/Dw8P/wAAAI0BAQEAAAAAAAAAAAAAAAAAAAAAAAEB + AQAAAACEAQEB/xQUFP8gICD/ICAg/xMTE/8BAQH/AAAA/wQEBP8ODg7/FxcY/yAgIP8kJCT/JiYm/ycn + J/8hISH/BwcH/wAAAP8AAAD/BwcH/x8fH/8sLCz/LS0t/y0tLf8vLy//LzAw/xoaGv8AAAD/AAAA/wAA + AMUAAAASAAAAowAAAP8iIiL/ODg4/zg4OP85OTn/OTo6/zs7O/85OTn/Dg4O/wAAAP8YGBj/Pz8//0BA + QP9BQUH/QkJC/0NDQ/9DRET/RERE/0VFRf9GRkb/R0dH/0hISP9KSkr/NTU2/wQEBPEAAABAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAMgAAAOgLCwv/Hx8f/x4eHv8HBwf/AAAA/wUFBf8bGxv/IyMj/yQl + Jf8lJSX/JSUl/yYmJv8nJyf/ERER/wAAAP8AAAD/BwcH/yIiIv8sLCz/LCws/y0tLf8uLi7/Ly8v/y8v + L/8QEBD/AAAA/wAAAP8AAACIAAAAAAAAAIYAAAD/Gxsb/zg4OP85OTn/OTo6/zo6Ov87Ozv/Ozs7/xMT + E/8AAAD/DQ0N/zo6Ov9BQUH/QkJC/0NDQ/9DRET/RERE/0VFRf9GRkb/R0dH/0hISP9JSUn/SUlJ/x4e + Hv8AAAC9AAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAACaAwMD/xoaGv8ZGRr/AgIC/wAA + AP8SEhL/JCQk/yQkJP8lJSX/JSUl/yYmJv8nJyf/IyMj/wYGBv8AAAD/AgIC/x0dHf8sLCz/LCws/y0t + Lf8uLi7/Ly8v/zAwMP8qKir/BgYG/wAAAP8AAAD/AAAAjQAAAAAAAABnAAAA/xUVFf84ODj/Ojo6/zo6 + Ov87Ozv/PDw8/z4+Pv8mJib/AQEB/wAAAP8cHBz/QEBA/0NDQ/9DRET/RERE/0VFRf9GRkb/R0dH/0hI + SP9JSUn/SktL/z4+Pv8ICAj/AAAAxAEBAQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANgAA + AOgODg7/FBQU/wAAAP8CAgL/Gxsb/yQkJP8lJSX/JSUl/yYmJv8nJyf/KCgo/yAgIP8DAwP/AAAA/woK + Cv8pKSn/LS0t/y0tLf8uLi7/Ly8v/zAwMP8xMTH/ISEh/wEBAf8AAAD/AAAA/wAAAK4AAAAAAAAASgAA + APkPDw//ODg4/zs7O/88PDz/PD09/z09Pf8+Pj7/Ozs7/xEREf8AAAD/AgIC/x8fH/9BQUH/RUVF/0VF + Rf9GRkb/R0dH/0hISP9JSUn/SkpK/0tLS/8jIyP/AAAA/wAAAOgAAAApAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAIAAACLBAQE/woKCv8AAAD/BAQE/x8fH/8lJSX/JSUl/yYmJv8nJyf/KCgo/ykp + Kf8jIyP/BAQE/wAAAP8FBQX/JSUl/y4uLv8uLi7/Ly8v/zAwMP8xMTH/MjIy/xYWFv8AAAD/AAAA/wAA + AP8AAADKAAAADAAAADAAAADtCQkJ/y4uLv8yMjL/NDQ0/zo6Ov8/Pz//P0BA/0FBQf8yMjL/CQkJ/wAA + AP8CAgL/Gxsb/z8/P/9HR0f/R0dH/0hISP9JSUn/SkpK/0tMTP89PT3/CAgI/wAAAP8AAADwAAAAMwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIQAAANEBAQH/AAAA/wYGBv8iIiL/JiYm/yYm + Jv8nJyf/KCgo/ygoKP8pKSn/KCgo/w0NDf8AAAD/AAAA/w0NDf8pKSn/LzAw/zAwMP8xMTH/MjIy/zAw + MP8NDQ3/AAAA/wAAAP8AAAD/AAAA4gAAAEkAAAB9AAAA8wEBAf8FBQX/BQUF/wcHB/8PDw//HyAg/zc3 + N/9BQUH/QkJC/y4uLv8HBwf/AAAA/wAAAP8TExP/Ojo6/0lJSf9JSUn/SkpK/0tLS/9JSkr/HBwc/wAA + AP8AAAD/AAAA5wAAACcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABXAAAA8wAA + AP8HBwf/IyMj/yYmJv8nJyf/KCgo/ygoKP8pKSn/Kioq/ysrK/8gICD/BAQE/wAAAP8AAAD/DAwM/ygo + KP8xMTH/MTIy/zMzM/8sLCz/BgYG/wAAAP8CAgL/AwMD/wAAAPsAAADvAAAA/gAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8KCgv/Li8v/0NDQ/9ERET/MDAw/wkJCf8AAAD/AAAA/woKCv8vLy//SUlJ/0tM + TP9NTU3/MTEx/wMDA/8AAAD/AAAA/wAAAMIAAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABQAAAJkAAAD/BgYG/yMjI/8nJyf/KCgo/ygoKP8pKSn/Kioq/ysrK/8sLCz/LCws/xsb + G/8DAwP/AAAA/wAAAP8JCQn/JSUl/zMzM/80NDT/KCgo/wMDA/8AAAD/AQEB/wEBAf8AAAD/AAAA/wAA + AP0AAAD6AAAA/xISEv8hISH/HR0d/xEREf8DAwP/AAAA/wkJCf82Njb/RUVF/0ZGRv82Njb/Dw8P/wAA + AP8AAAD/BAQE/yEhIf9AQED/Ozs7/wwMDP8AAAD/AAAA/wAAAPwAAABrAAAAAAEBAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcAAAA/gQEBP8hISH/KCgo/ygoKP8pKSn/Kioq/ysr + K/8sLCz/LCws/y0tLf8uLi7/HR0d/wUFBf8AAAD/AAAA/wYGBv8kJCT/NTU1/yUlJf8BAQH/AAAA/wAA + AP8AAAD/AAAA/wAAANoAAABvAAAApQAAAP8hIiL/QUFB/0FBQf8+Pj7/KCgo/wUFBf8AAAD/GBgY/0ND + RP9GRkb/SEhI/z4+Pv8YGBj/AQEB/wAAAP8BAQH/CAgI/wcHB/8AAAD/AAAA/wAAAP8AAACtAAAAEQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAAAAPEAAAD/Dw8P/yYm + Jv8pKSn/Kioq/ysrK/8sLCz/LCws/y0tLf8uLi7/Ly8v/zAwMP8jIyP/CAgI/wAAAP8AAAD/BgYG/ykp + Kf8tLi7/CAgI/wAAAP8DAwP/BgYG/wEBAf8AAACXAAAAAAAAAHAAAAD/Ghoa/0BAQP9BQUH/QkJC/0ND + Q/8gICD/AAAA/wUFBf82Njb/SEhI/0hISP9KSkr/RUVF/yMjJP8EBAT/AAAA/wAAAP8AAAD/AAAA/wAA + AP4AAAC6AAAAIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ABEAAAC/AAAA/wEBAf8SEhL/KCgo/ysrK/8sLCz/LCws/y0tLf8uLi7/Ly8v/zAwMP8xMTH/MjIy/ykp + Kf8LCwv/AAAA/wAAAP8ODg7/MzMz/ywsLP8gICD/Kioq/yUlJf8BAQH/AAAAswEBAQEAAABSAAAA+xMT + E/8/Pz//QkJC/0NDQ/9ERET/Ojo6/wgICP8AAAD/IyMj/0lJSf9JSUn/SkpK/0tLS/9LS0v/MjIz/wcH + B/8AAADyAAAA5AAAAMsAAAB+AAAAGQAAAAABAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBAQAAAAAAAAAAOAAAAL4AAADuAQEB+BISEv8pKSn/LS0t/y0tLf8uLi7/Ly8v/zAw + MP8xMTH/MTEx/zIyMv80NDT/Kioq/wgICP8AAAD/AQEB/yUlJf86Ojr/Ojo6/zw8PP8vMDD/BAQE/wAA + AM4AAAAOAAAANwAAAPINDQ3/PT09/0NDQ/9DRET/REVF/0RERP8YGBj/AAAA/xMTE/9GRkb/SkpK/0tL + S/9MTEz/SkpK/yYmJv8DAwPhAAAAUgAAACEAAAARAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAAAPAAAALwAAAFMBAQHPEBAQ/ygo + KP8vLy//Ly8v/zAwMP8xMTH/MTIy/zIyMv8zMzP/NDQ0/zY2Nv8dHR3/AAAA/wAAAP8YGBj/Ojo6/zo6 + Ov88PDz/NTU1/wgICP8AAADkAAAAIgAAACAAAADiCAgI/zo6Ov9ERET/RERE/0VFRf9HR0f/KSkp/wAA + AP8JCQn/QEBA/0tLS/9MTEz/R0dH/yAgIP8CAgLgAAAASwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB + AQAAAAAAAAAAKwAAALoLCwv+JCQk/zAwMP8xMTH/MTIy/zIyMv8zMzP/NDQ0/zU1Nf83Nzf/JiYm/wEB + Af8AAAD/FBQU/zo6Ov87Ozv/PD09/zo6Ov8ODg7/AAAA9AAAADsAAAAOAAAAzgQEBP81NTX/RUVF/0VF + Rf9GRkb/SEhI/zU1Nf8CAgL/BAQE/zs7O/9NTU3/Pz8//xcXF/8BAQHWAAAAQwAAAAAAAAAPAAAAFQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXAAAAkwYGBvUbGxv/Ly8v/zMzM/8zMzP/NDQ0/zU1 + Nf82Njb/ODg4/x8fH/8AAAD/AAAA/xgYGP87PDz/PDw8/z09Pf89PT3/FRUV/wAAAP0AAABZAAAAAQAA + ALQBAQH/Ly8v/0ZGRv9GRkb/R0dH/0lJSf83Nzf/AwMD/wQEBP84ODj/MTEx/wwMDP4AAADAAAAAMQAA + AAAAAAAEAAAAVwAAACIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAABdAQEB1w8P + D/8mJib/MzMz/zY2Nv82Njb/Nzc3/zU1Nf8PDw//AAAA/wEBAf8mJib/PT09/z09Pf8+Pj7/QEBA/x0d + Hf8AAAD/AAAAegAAAAAAAACYAAAA/ycnJ/9HR0f/R0dH/0hISP9JSUn/ICAg/wAAAP8EBAT/ExMT/wQE + BPYAAACXAAAAGwAAAAABAQEAAAAAVwAAAGYBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAACYAAACXBAQE7xQUFP8pKSn/NTU1/zk5Of8jIyP/AgIC/wAAAP8LCwv/NjY2/z4+ + Pv8+Pj7/Pz8//0FBQf8mJib/AAAA/wAAAJoAAAAAAAAAeQAAAP8fHx//SEhI/0lJSf9KS0v/QUFB/wsL + C/8AAAD/AAAA/wAAANYAAABdAQEBCAEBAQABAQEBAAAAVQAAAJYAAAASAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAEIAAACsBAQE8BISEv8dHR3/BwcH/wAA + AP8EBAT/KCgo/z4+Pv8+Pj7/Pz8//0BAQP9CQkL/Ly8v/wICAv8AAAC5AAAAAwAAAFoAAAD9FxcX/0VF + Rf8/Pz//Ly8v/xYWFv8BAQH/AAAA8QAAAJEAAAAjAAAAAAAAAAABAQEFAAAAZAAAALMAAAAoAAAAAAEB + AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAAAAAAAAGAAA + AIUAAAD2AAAA/wAAAP8AAAD/Dg4O/y0tLf82Njb/Ozs7/z4+Pv9AQED/QkJC/zU1Nf8FBQX/AAAA0wAA + ABEAAAA+AAAA9QgICP8UFBT/CQkJ/wEBAf4AAAD4AAAA/wAAAKcAAAAEAAAAAAEBAQAAAAAZAAAAjQAA + AMMAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAAAUAAAAOAAAAEUAAABMAAAAUwAA + AF8AAABzAAAAmQAAAMwAAADzAAAA/wAAAPYAAADGAAAAvQEBAekDAwP9CAgI/w0NDf8SEhL/FRUV/xYW + Fv8RERH/AgIC/wAAAOgAAAAmAAAAJQAAAOcAAAD/AAAA9gAAAM4AAACAAAAAdwAAAPwAAAC2AAAAIwAA + ACgAAABoAAAAzAAAAL8AAAAvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEAAAAACgAA + ACwAAABRAAAAdAAAAJIAAACqAAAAuwAAAMEAAAC4AAAAowAAAH8AAABIAAAAEQAAAAoAAAAtAAAAXwAA + AJEAAAC6AAAA1QAAAOYAAADwAAAA9AAAAPUAAADpAAAAOwAAAA8AAACXAAAAhQAAAEYBAQEUAAAAAAAA + ABYAAAC9AAAA/QAAAOcAAADqAAAA5wAAAI4BAQEZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQABAQEAAQEBAwAAAAcAAAAIAAAABgEBAQEBAQEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABYAAAAmAAAAMwAAADwAAAA9AAAANwAAAA8FBQUAAQEBBAEB + AQABAQEAAAAAAAEBAQAAAAAAAAAAIgAAAHsAAACXAAAAdwAAADEAAAAEAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP// + ////////////wAf///////wAAH//////8AAAH//////ACAAAf////AAIAAAf///8AAAAAA////gAAAAA + B///+AAAAAAD///wAAAAAAP//+AAAAAAAf//wAAEAAAB//+AAAQAAAD//wAABAAAAP/+AAAAAAAAf/4A + AAAAAAA//AAAAAAAAB/4AAAAAAAAH/gAAAIAAAAP8AAAAgAAAA/wAAACAAAAB+AAAAAAAAAH4AAAAAAA + AAOAAAAAAAAAAwAAAAAAAAADAAAAAAAAAAEAAAAAAAAAAQAAABAAAAABgAAAAAAAAAGAAAAAAgBgAYAA + AAACMAABgAAAAAIAAAGAAAAAAgAAAYAAAAAAAAABgBwAAAAAAAGOAAAAAAAAAIAAAAAAAAAAgAAAAAAA + AAHAAAAAAAAAA8AAAAAAAAADwAAAAAAAAAfgAAAAAAAAB+AAAABAAAAH4AAAAEAAAAfwAAAAQAAAB/AA + AAAAAAAH+AAAAAAAAAf8AAAAAAAAB/wAAAAAAAAP/gAAAAAAAA/+AAAAIAAAH/4AAAAAAAA//wAAAAAA + AH//gAAAAAAH///wAAAAAAn///gAAAAAEf///AAAEAAx////AAAQAEP///+AAAABh////+AAAAMP///g + AAAAAB///+AAAABAP////wfwC+B/////////////KAAAAIAAAAAAAQAAAQAgAAAAAAAAAAEAEwsAABML + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAADQ0NAAICAgEBAQEDAQEBBAEBAQQBAQEDAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAYCAgIAAAAAAAAAABEAAACDAAAAogAAAKsAAACvAAAArQAA + AKsAAACiAAAAlAAAAIQAAABuAAAAVAAAADwAAAAjAAAADwEBAQMAAAAAAQEBAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQIAAAAUAAAAPQAAAG4AAACkAAAAeAEB + AQAAAAAAAAAAEwAAANAAAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD8AAAA8wAA + AOIAAADIAAAApgAAAHcAAABIAQEBIQEBAQcBAQEAAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEAAQEBAgAA + ABsBAQFVAAAAmAAAAM8AAADzAAAA/wAAAP8AAAC0AAAABgAAAAAAAAAGAAAAtQEBAf8AAAD/AQEB/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAPgAAADgAAAAswAA + AHgAAAA+AAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBAQAAAAAAAAAADgAAAEcAAACWAQEB1wAAAPoAAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AMsBAQEQAAAAAAEBAQAAAACXAAAA/wAAAP8AAAD/AQEB/wICAv8CAgL/AgIC/wICAv8CAgL/AgIC/wEB + Af8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAPIAAADJAAAAhwAAAEAAAAANAAAAAAEB + AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQABAQEBAAAAHgAAAG0AAADBAAAA9AAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA3gAAAB4AAAAAAAAAAAAAAHcAAAD/AAAA/wAA + AP8ICAj/FBQU/xYWFv8WFhb/FhYW/xYWFv8VFRX/FBQU/xISEv8PDw//DQ0N/wkJCf8GBgb/AwMD/wEB + Af8AAAD/AAAA/wAAAP8AAAD/AAAA8gAAAMAAAAByAAAAJwEBAQMBAQEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAABAAAAJwAAAH8AAADXAAAA/QAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/wICAv8BAQH/AAAA/wAA + AP8AAADtAQEBMQEBAQAAAAAAAAAAWAAAAP0AAAD/AAAA/wkJCf8aGhr/Gxsb/xsbG/8bGxv/Gxsb/xsb + HP8cHBz/HBwc/xwcHP8cHBz/HBsc/xoaGv8XFxf/ExMT/w4ODv8ICAj/AwMD/wEBAf8AAAD/AAAA/wAA + AP4AAADhAAAAlQAAADwAAAAHAAAAAAICAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEAAAAAIQAAAIEAAADeAAAA/gAAAP8AAAD/AAAA/wAA + AP8CAgL/BgYG/wwMDP8RERH/FBQU/wYGBv8AAAD/AAAA/wAAAPgAAABHAAAAAAAAAAAAAAA7AAAA8wAA + AP8AAAD/BgYG/xkZGf8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8cHBz/HBwc/xwcHP8cHBz/HBwc/x0d + Hf8dHR3/HR0d/xwcHP8ZGBn/EhIS/woKCv8EBAT/AAAA/wAAAP8AAAD/AAAA7wAAAKgAAABGAAAAHQAA + ACcBAQEzAAAAMQAAACgAAAAgAAAAEwEBAQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAA + AHEAAADYAAAA/gAAAP8AAAD/AAAA/wICAv8HBwf/Dg4O/xQUFP8YGBj/Ghoa/xoaGv8aGhr/CQkJ/wAA + AP8AAAD/AAAA/wAAAGEAAAAAAAAAAAAAACQAAADjAAAA/wAAAP8EAwP/FxcX/xsbG/8bGxv/Gxsb/xsb + G/8bGxv/HBwc/xwcHP8cHBz/HBwc/xwcHP8cHRz/HR0d/x0dHf8dHR3/HR4e/x4eHv8eHh7/Hh4e/xoa + Gv8SEhL/CAgI/wEBAf8AAAD/AAAA/wAAAPIAAADeAAAA5wAAAO8AAADuAAAA6AAAAOEAAADQAAAAmgAA + AFMAAAAQAAAAAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB + AQAAAAAXAQEBTAAAAE4BAQEqAAAACwAAAE4AAADCAAAA+wAAAP8AAAD/AAAA/wQEBP8LCwv/FBQU/xgZ + Gf8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8LCwv/AAAA/wAAAP8AAAD/AAAAfAAAAAAAAAAAAAAAEgAA + AM4AAAD/AAAA/wICAv8VFRX/Gxsb/xsbG/8bGxv/Gxsb/xwcHP8cHBz/HBwc/xwcHP8cHBz/HBwc/x0d + Hf8dHR3/HR0d/x0eHv8eHh7/Hh4e/x4eHv8fHx//HR0d/xUVFf8JCQn/AQEB/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA+AAAAL4AAABSAAAABwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgIAAAAARQEBAccAAAD6AAAA+gAAAOMAAAC7AQEB8AAA + AP8AAAD/AQEB/wUFBf8ODg7/FhYW/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/w4O + Dv8AAAD/AAAA/wAAAP8AAACYAAAAAAAAAAAAAAAGAAAAtAAAAP8AAAD/AQEB/xISEv8cHBz/Gxsb/xsb + G/8bHBz/HBwc/xwcHP8cHBz/HBwc/xwdHP8dHR3/HR0d/x0dHf8dHR3/Hh4e/x4eHv8eHh7/Hh4e/xgY + GP8KCgr/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAPMAAACPAQEBFwEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AC8AAADcAAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/wUFBf8PDw//FxcX/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/ERER/wAAAP8AAAD/AAAA/wAAALIBAQEFAAAAAAEB + AQABAQGWAAAA/wEBAf8AAAD/Dw8P/xwcHP8bGxv/HBwc/xwcHP8cHBz/HBwc/xwcHP8dHR3/HR0d/x0d + Hf8dHR3/HR0d/x4eHv8eHh7/Hh4e/x4eHv8UFBT/BAQE/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP4AAACyAAAAIAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQECAAAAlAAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8FBAT/FhYW/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8TExP/AQEB/wAAAP8AAAD/AAAAygAAAA8AAAAAAQEBAAAAAHUAAAD/AAAA/wAAAP8MDAz/HBwc/xwc + HP8cHBz/HBwc/xwcHP8cHBz/HB0c/x0dHf8dHR3/HR0d/x0dHf8eHh7/Hh4e/x4eHv8eHh7/ExQU/wMD + A/8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAC5AAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ACMAAADeAAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf8ODg7/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xUVFv8CAgL/AAAA/wAAAP8BAQHdAQEBHQEB + AQAAAAAAAAAAVgAAAPwAAAD/AAAA/wkJCf8bGxv/HBwc/xwcHP8cHBz/HBwc/x0dHf8dHR3/HR0d/x0d + Hf8dHR3/Hh4e/x4eHv8eHh7/Hx8f/xcXF/8DAwP/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAACpAAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXwAAAP0AAAD/AAAA/wAAAP8BAQH/AAAA/wAA + AP8AAAD/AAAA/wICAv8SEhL/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8ZGhr/FhYW/xAQEP8RERH/FhYW/xkZ + Gf8aGhr/FxcX/wQEBP8AAAD/AAAA/wAAAO0AAAAwAAAAAAAAAAAAAAA6AAAA8gAAAP8AAAD/BgYG/xoa + Gv8cHBz/HBwc/xwcHP8cHBz/HR0d/x0dHf8dHR3/HR0d/x4eHv8eHh7/Hh4e/x4fH/8cHBz/CAgI/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf8CAgL/AwMD/wMDA/8DAwP/AgIC/wEB + Af8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP0AAACDAQEBAwEBAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAA + AAwAAACrAAAA/wAAAP8AAAD/CQkJ/wwMDP8BAQH/AAAA/wAAAP8AAAD/AAAA/wQEBP8VFRX/Ghoa/xoa + Gv8aGhr/FxcX/wsLC/8DAwP/AQEB/wEBAf8DAwP/DAwM/xkaGv8ZGRn/BgYG/wAAAP8AAAD/AAAA9wAA + AEYAAAAAAAAAAAAAACMAAADiAAAA/wAAAP8EBAT/GBgY/xwcHP8cHBz/HBwc/x0dHf8dHR3/HR0d/x0d + Hf8eHh7/Hh4e/x4eHv8eHh7/Hx8f/xISEv8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/wYG + Bv8PDw//FhYW/xoaGv8cHBz/HR0d/xwcHP8aGhr/GBgY/xQUFP8KCgr/AgIC/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAO4BAQFOAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAgICAAAAAAABAQEUAAAAlQAAAPkAAAD/AAAA/wYGBv8XFxf/GRkZ/wkJ + Cf8AAAD/AAAA/wAAAP8AAAD/AAAA/wYGBv8WFhb/Ghoa/xUVFf8HBwf/AAAA/wAAAP8AAAD/AAAA/wAA + AP8BAQH/Dw8P/xoaGv8JCQn/AAAA/wAAAP8AAAD+AAAAYAAAAAAAAAAAAAAAEQAAAM0AAAD/AAAA/wIC + Av8WFhb/HR0d/x0dHf8dHR3/HR0d/x0dHf8dHR3/Hh4e/x4eHv8eHh7/Hh4e/x8fH/8dHR3/CAgI/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wMDA/8SEhL/Hh4e/yIiIv8jIyP/IyMj/yMjI/8kJCT/JCQk/yQk + JP8lJSX/JSUl/yMjI/8cHBz/DAwM/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAM0AAAAfAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgAA + AKoAAAD9AAAA/wQEBP8KCgr/FRUV/xoaGv8aGhr/FhYW/wQEBP8AAAD/AAAA/wAAAP8AAAD/AAAA/wUF + Bf8PDw//BQUF/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8EBAX/GBgY/wsLC/8AAAD/AAAA/wAA + AP8AAAB7AAAAAAEBAQABAQEGAAAAswAAAP8AAAD/AQEB/xMTE/8dHR3/HR0d/x0dHf8dHR3/HR0d/x4e + Hv8eHh7/Hh4e/x4eHv8fHx//Hx8f/xgYGP8CAgL/AAAA/wAAAP8AAAD/AAAA/wAAAP8DAwP/FxcX/yIi + Iv8iIiL/IiIi/yMjI/8jIyP/IyMj/yQkJP8kJCT/JCQk/yUlJf8lJSX/JSYm/yYmJv8kJCT/ExMT/wIC + Av8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAIcBAQECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAACzAAAA/wAAAP8ICAj/FhYW/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/ERER/wICAv8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wEBAf8TExP/Dw8P/wAAAP8AAAD/AAAA/wAAAJYBAQEAAAAAAAEBAQAAAACUAAAA/wAA + AP8AAAD/EBAQ/x0dHf8dHR3/HR0d/x0dHf8eHh7/Hh4e/x4eHv8eHh7/Hx8f/x8fH/8gICD/ExMT/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/xEREf8iIiL/IiIi/yIiIv8jIyP/IyMj/yMjI/8kJCT/JCQk/yQk + JP8lJSX/JSUl/yUlJf8mJib/JiYm/ycnJ/8mJib/GBgY/wQEBP8AAAD/AAAA/wAAAP8AAAD/AAAA5gAA + ADIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAAAAAAAAAhAAAAugAA + AP8BAQH/CgoK/xgXGP8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8ZGRn/DAwM/wEBAf8AAAD/AAAA/wAA + AP8AAAD/AAAA/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/xAQEP8RERH/AQAA/wAA + AP8AAAD/AAAAsQAAAAUAAAAAAAAAAAAAAHQBAQH/AQEB/wAAAP8MDAz/HR0d/x0dHf8dHR3/Hh4e/x4e + Hv8eHh7/Hh4e/x8fH/8fHx//Hx8f/yAgIP8PDw//AAAA/wAAAP8AAAD/AAAA/wAAAP8EBAT/HR0d/yIi + Iv8iIiL/IyMj/yMjI/8jIyP/JCQk/yQkJP8kJCT/JSUl/yUlJf8lJSX/JiYm/yYmJv8mJib/Jycn/ycn + J/8oKCj/HB0d/wYGBv8AAAD/AAAA/wAAAP8AAAD/AAAAkgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAHgAAALcAAAD/AQEB/wwMDP8YGBn/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8YGBj/CgoK/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/DQ0N/xQUFP8BAQH/AAAA/wEBAf8BAQHIAQEBDgEBAQAAAAAAAAAAVQAA + APwAAAD/AAAA/wkJCf8cHBz/HR0d/x4eHv8eHh7/Hh4e/x4eHv8fHx//Hx8f/x8fH/8fHx//ICAg/wwM + DP8AAAD/AAAA/wAAAP8BAQH/AAAA/wkJCf8hISH/IiIi/yMjI/8jIyP/IyMj/yQkJP8kJCT/JCQk/yUl + Jf8lJSX/JSUl/yYmJv8mJib/Jicn/ycnJ/8nJyf/KCgo/ygoKP8pKSn/ICAg/wgICP8AAAD/AQEB/wAA + AP8AAADgAAAAJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEAAQEBAAEBARkAAACxAAAA/wEB + Af8MDAz/GRkZ/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8YGBj/CgoK/wEB + Af8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8FBQX/BQUF/wAAAP8AAAD/AAAA/wAAAP8NDQ3/FhYW/wIC + Av8AAAD/AQEB/wAAANwAAAAcAAAAAAAAAAAAAAA5AAAA8gAAAP8AAAD/BgYG/xsbG/8eHh7/Hh4e/x4e + Hv8eHh7/Hh8f/x8fH/8fHx//Hx8f/yAgIP8gICD/DQ0N/wAAAP8AAAD/AAAA/wAAAP8AAAD/CwsL/yIi + Iv8jIyP/IyMj/yMjI/8kJCT/JCQk/yQkJP8lJSX/JSUl/yUlJf8mJib/JiYm/yYmJv8nJyf/Jycn/ygo + KP8oKCj/KCgo/ykpKf8qKir/ISEh/wkJCf8AAAD/AAAA/wAAAP8AAABuAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAQAAAAoQAAAP8BAQH/DAwM/xkZGf8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8ZGRn/EA8P/wUFBf8CAgL/AQEB/wEBAf8EBAT/CwsL/xcX + F/8KCgr/AAAA/wAAAP8AAAD/AAAA/w0MDP8YGBj/BAQE/wAAAP8AAAD/AAAA7AAAAC4AAAAAAAAAAAAA + ACIAAADiAAAA/wAAAP8EBAT/Ghoa/x4eHv8eHh7/Hh4e/x8fH/8fHx//Hx8f/x8fH/8gICD/ICAg/yAg + IP8ODg7/AAAA/wAAAP8AAAD/AAAA/wAAAP8KCgr/IiIi/yMjI/8jIyP/JCQk/yQkJP8kJCT/JSUl/yUl + Jf8lJSX/JiYm/yYmJv8mJyf/Jycn/ycnJ/8oKCj/KCgo/ygoKP8pKSn/KSkp/ykqKv8qKir/IiIi/wgI + CP8AAAD/AAAA/wAAALMBAQEIAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBCAAAAI0AAAD8AQEB/wwM + DP8ZGRn/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/GBgY/xUVFf8RERH/FBQU/xgYGP8aGhr/Gxsb/woKCv8AAAD/AAAA/wAAAP8AAAD/DQ0N/xoa + Gv8GBgb/AAAA/wAAAP8AAAD3AAAARQAAAAAAAAAAAAAAEQAAAMwAAAD/AAAA/wICAv8XFxf/Hx8f/x4e + Hv8fHx//Hx8f/x8fH/8fHx//ICAg/yAgIP8gICD/ISEh/xMTE/8AAAD/AQEB/wAAAP8AAAD/AAAA/wYG + Bv8gICD/IyQk/yQkJP8kJCT/JCQk/yUlJf8lJSX/JSUl/yYmJv8mJib/JiYm/ycnJ/8nJyf/KCgo/ygo + KP8oKCj/KSkp/ykpKf8pKir/Kioq/yoqKv8rKyv/IiIi/wcHB/8AAAD/AAAA8AAAAFkAAAAAAQEBAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAEAAABvAAAA9wAAAP8KCgr/GBgY/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xsbG/8bGxv/Ghoa/xoa + Gv8aGhr/CgoK/wAAAP8AAAD/AAAA/wAAAP8PDw//Gxsb/wkJCf8AAAD/AAAA/wAAAP4AAABeAAAAAAAA + AAAAAAAFAAAAsQAAAP8AAAD/AQEB/xQUFP8fHx//Hx8f/x8fH/8gICD/ICAg/yAgIP8gICD/ICAg/yAg + IP8hISH/GBgY/wICAv8AAAD/AAAA/wAAAP8AAAD/AgIC/xoaGv8kJCT/JCQk/yQkJP8lJSX/JSUl/yUl + Jf8mJib/JiYm/yYnJ/8nJyf/Jycn/ygoKP8oKCj/KCgo/ykpKf8pKSn/Kioq/yoqKv8qKir/Kysr/ysr + K/8sLCz/ISEh/wUFBf8AAAD/AAAA4gAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATgAAAOsAAAD/CAgI/xcX + F/8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Gxsb/xoaGv8JCQn/AAAA/wAAAP8AAAD/AAAA/xER + Ef8cHBz/DAwM/wAAAP8AAAD/AAAA/wAAAHkBAQEAAQEBAAAAAAAAAACTAAAA/wAAAP8AAAD/ERER/x8f + H/8cHBz/GRkZ/xcXF/8YGBj/Gxsb/yAgIP8hISH/ISEh/yEhIf8eHh7/BgYG/wAAAP8AAAD/AAAA/wAA + AP8AAAD/EBAQ/yQkJP8kJCT/JSUl/yUlJf8lJSX/JiYm/yYmJv8mJib/Jycn/ycnJ/8oKCj/KCgo/ygo + KP8pKSn/KSkp/yoqKv8qKir/Kioq/ysrK/8rKyv/LCws/ywsLP8tLS3/Hh4e/wMDA/8AAAD/AAAA1AAA + AC8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABAQEAAAAAAAAAACwAAADWAAAA/wUFBf8WFhb/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xob + G/8bGxv/Ghoa/wcHB/8AAAD/AAAA/wAAAP8BAQH/ExMT/x0dHf8PDw//AAAA/wAAAP8AAAD/AAAAlQEB + AQAAAAAAAQEBAAAAAHIAAAD/AAAA/wAAAP8HBwf/CwsL/wYGBv8DAwP/AQIC/wICAv8EBAT/EhIS/yAg + IP8hISH/ISEh/yIiIv8PDw//AAAA/wAAAP8AAAD/AAAA/wAAAP8FBQX/ICAg/yUlJf8lJSX/JSUl/yYm + Jv8mJib/JiYm/ycnJ/8nJyf/KCgo/ygoKP8oKCj/KSkp/ykpKf8pKir/Kioq/yoqKv8rKyv/Kysr/yws + LP8sLCz/LCws/y0tLf8tLS3/GRkZ/wEBAf8AAAD/AQEBugAAABkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARAAAAsAAAAP8DAwP/ExMT/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8bGxv/Gxsb/xsbG/8ZGRn/BgYG/wAAAP8AAAD/AAAA/wIC + Av8WFhb/HR0d/xISEv8BAQH/AAAA/wAAAP8AAACvAAAABAAAAAABAQEHAQEBcQEBAf4AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8BAQH/EhIS/yEhIf8iIiL/IiIj/xkZGf8CAgL/AAAA/wAA + AP8AAAD/AAAA/wAAAP8TExP/JSUl/yUlJf8mJib/JiYm/yYnJv8nJyf/Jycn/ygoKP8oKCj/KCgo/ykp + Kf8pKSn/KSoq/yoqKv8qKir/Kysr/ysrK/8rLCz/LCws/ywsLP8tLS3/LS0t/y4uLv8sLS3/ExMT/wAA + AP8AAAD/AAAAmAAAAAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAgAAAH8AAAD8AQEB/w8PD/8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Gxsb/xsb + G/8bGxv/Gxsb/xgYGP8EBAT/AAAA/wAAAP8AAAD/AwMD/xgYGP8dHR3/FRUV/wEBAf8AAAD/AQEB/wAA + AMoAAAA2AAAAbAAAALgAAADtAAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8KCgr/ISEh/yIiIv8iIiL/ISEi/wsLC/8AAAD/AQEB/wAAAP8AAAD/AAAA/wUFBf8fHx//JiYm/yYm + Jv8mJyf/Jycn/ycnJ/8oKCj/KCgo/ygoKP8pKSn/KSkp/yoqKv8qKir/Kioq/ysrK/8rKyv/Kyws/yws + LP8sLCz/LS0t/y0tLf8uLi7/Li4u/y8vL/8qKir/CwsL/wAAAP8AAAD3AAAAaQAAAAABAQEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFAAAA6wAAAP8KCgr/GRkZ/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8bGxv/Gxsb/xsbG/8bGxv/FxcX/wMDA/8AAAD/AAAA/wAA + AP8GBgb/Ghoa/x0dHf8YGBj/AwMD/wAAAP8AAAD/AAAA9wAAAOkAAAD9AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wICAv8EBAT/AQEB/wAAAP8AAAD/AAAA/wwMDP8hIiL/IiIi/yMjI/8jIyP/Ghoa/wMD + A/8AAAD/AAAA/wAAAP8AAAD/AAAA/w8PD/8lJSX/Jycn/ycnJ/8nJyf/Jygo/ygoKP8oKCj/KSkp/ykp + Kf8pKSn/Kioq/yoqKv8rKyv/Kysr/yssLP8sLCz/LCws/y0tLf8tLS3/Li4u/y4uLv8uLy//Ly8v/zAw + MP8kJCT/BQUF/wAAAP8AAADiAAAAOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAGQAAAMIAAAD/BQUF/xYWFv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Gxsb/xsb + G/8bGxv/Gxsb/xscG/8VFRX/AgIC/wAAAP8AAAD/AAAA/wkJCf8aGhr/GBgY/xAQEP8CAgL/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf8NDQ3/GBgY/wwMDP8AAAD/AAAA/wAA + AP8BAQH/FxcX/yMjI/8jIyP/IyMj/yMjI/8jIyP/EBAQ/wAAAP8AAAD/AAAA/wAAAP8AAAD/AgIC/xkZ + Gf8nJyf/Jycn/ygoKP8oKCj/KCgo/ykpKf8pKSn/Kioq/yoqKv8qKir/Kysr/ysrK/8sLCz/LCws/yws + LP8tLS3/LS0t/y4uLv8uLi7/Li8v/y8vL/8vLy//MDAw/zAwMP8aGhr/AQEB/wAAAP8AAAC8AAAAFQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAACDAAAA/gEBAf8RERH/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xsbG/8bGxv/Gxsb/xsbG/8bGxv/HBwc/xMTE/8BAQH/AAAA/wAA + AP8AAAD/BAQE/wYGBv8DAwP/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD6AAAA+AAA + AP8AAAD/AQEB/xYWFv8VFRX/AgIC/wAAAP8AAAD/AAAA/wwMDP8hISH/IyMj/yMjI/8jIyP/JCQk/yQk + JP8gICD/CAgI/wAAAP8AAAD/AAAA/wAAAP8AAAD/BgYG/yEhIf8oKCj/KCgo/ygoKP8pKSn/KSkp/yoq + Kv8qKir/Kioq/ysrK/8rKyv/LCws/ywsLP8sLCz/LS0t/y0tLf8uLi7/Li4u/y4uLv8vLy//Ly8v/zAw + MP8wMDD/MTEx/y4uLv8ODg7/AAAA/wAAAP0AAAB9AAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB + AQAAAAAAAAAAOwAAAOgAAAD/CgoK/xkZGf8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8bGxv/Gxsb/xsb + G/8bGxv/Gxsb/xsbG/8cHBz/ExMU/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAADrAAAAsAAAAFwBAQGjAAAA/wAAAP8AAAD/CwsL/wUFBf8AAAD/AAAA/wAA + AP8FBQX/HBwc/yMjI/8jIyP/IyMj/yQkJP8kJCT/JCQk/yUlJf8bGxv/BAQE/wAAAP8AAAD/AAAA/wAA + AP8AAAD/DQ0N/yYmJv8pKSn/KSkp/ykpKf8qKir/Kioq/yoqKv8rKyv/Kysr/ywsLP8sLCz/LCws/y0t + Lf8tLS3/Li4u/y4uLv8uLy//Ly8v/y8vL/8wMDD/MDAw/zExMf8xMTH/MjIy/yYmJv8EBAT/AAAA/wAA + AOgAAAA+AAAAAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAEBAQ0AAACwAAAA/wQEBP8VFRX/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xwcHP8ZGRn/BAQE/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAAsgAAADIAAAAIAAAAAAAA + AHEAAAD/AAAA/wAAAP8BAQH/AAAA/wAAAP8AAAD/AQEB/xQUFP8jIyP/IyMj/yMjI/8kJCT/JCQk/yQk + JP8lJSX/JSUl/yUlJf8WFhb/AgIC/wAAAP8AAAD/AAAA/wAAAP8BAQH/FhYW/ykpKf8pKSn/KSoq/yoq + Kv8qKir/Kysr/ysrK/8sLCz/LCws/ywsLP8tLS3/LS0t/y4uLv8uLi7/Li4u/y8vL/8vLy//MDAw/zAw + MP8xMTH/MTEx/zExMf8yMjL/MjIy/xcXF/8AAAD/AAAA/wAAALQBAQEOAQEBAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABAQEAAAAAWwAAAPgAAAD/Dg4O/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Gxsb/xsbG/8bGxv/Gxsb/xsb + G/8bGxv/Gxsb/xsbG/8cHBz/HBwc/xwcHP8NDQ3/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/wIC + Av8AAAD/AAAA/wAAAP8AAACSAAAAAAEBAQAAAAAAAAAAUgAAAPsAAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8MCwv/ISEh/yMjI/8jIyP/JCQk/yQkJP8kJCT/JSUl/yUlJf8lJSX/JiYm/yUlJf8REhH/AQEB/wAA + AP8AAAD/AAAA/wAAAP8EBAT/Hx8f/yoqKv8qKir/Kioq/ysrK/8rKyv/LCws/ywsLP8sLCz/LS0t/y0t + Lf8uLi7/Li4u/y4vL/8vLy//Ly8v/zAwMP8wMDD/MTEx/zExMf8xMjL/MjIy/zIyMv8zMzP/LCws/wgI + CP8AAAD/AAAA+QAAAGUBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcAAADHAAAA/wUFBf8XFxf/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/HBwc/xwcHP8cHBz/HBwc/xsb + G/8UFBT/CQkJ/wUFBf8HBwf/CQkJ/w8PD/8WFhb/ERAR/wEBAf8AAAD/AAAA/wAAAK4AAAAEAAAAAAAA + AAAAAAA3AAAA8AAAAP8AAAD/AAAA/wAAAP8AAAD/BAQE/xwcHP8jIyP/IyMj/yQkJP8kJCT/JCQk/yUl + Jf8lJSX/JSUl/yYmJv8mJib/Jycn/yQlJf8ODg7/AAAA/wAAAP8AAAD/AAAA/wAAAP8LCwv/Jycn/yor + K/8rKyv/Kysr/ywsLP8sLCz/LCws/y0tLf8tLS3/Li4u/y4uLv8uLi7/Ly8v/y8vL/8wMDD/MDAw/zEx + Mf8xMTH/MTIy/zIyMv8yMjL/MzMz/zMzM/80NDT/HR0d/wEBAf8AAAD/AAAA0gAAAB8AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB + AQAAAAAAAAAAbwAAAP0BAQH/EBAQ/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGxv/Gxsb/xsbG/8bGxv/Gxsb/xsb + G/8bGxv/Gxsb/xwcHP8cHBz/HBwc/xwcHP8cHBz/HR0d/x0dHf8cHBz/Gxsb/xwcHP8dHR3/Hh4e/x8f + H/8WFhb/AQEB/wAAAP8AAAD/AAAAxgAAAA0AAAAAAAAAAAAAACAAAADgAAAA/wAAAP8AAAD/AAAA/wEB + Af8TExP/IyMj/yMjI/8kJCT/JCQk/yQkJP8lJSX/JSUl/yUlJf8mJib/JiYm/yYnJ/8nJyf/KCgo/yQk + JP8LCwv/AAAA/wAAAP8AAAD/AAAA/wEBAf8XFxf/Kysr/ysrK/8sLCz/LCws/ywsLP8tLS3/LS0t/y4u + Lv8uLi7/Li4u/y8vL/8vLy//MDAw/zAwMP8xMTH/MTEx/zEyMv8yMjL/MjIy/zMzM/8zMzP/NDQ0/zQ1 + Nf8vMDD/CgoK/wAAAP8AAAD/AAAAfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsAAADQAAAA/wYGBv8YGBj/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8cHBz/HBwc/xwcHP8cHBz/HBwc/xwd + Hf8dHR3/HR0d/x0dHf8dHR3/Hh4e/x4eHv8eHh7/Hx8f/xkZGf8DAwP/AAAA/wAAAP8AAADaAAAAGgAA + AAAAAAAAAAAADwAAAMkAAAD/AAAA/wAAAP8AAAD/CAgI/yAgIP8jJCT/JCQk/yQkJP8kJCT/JSUl/yUl + Jf8lJSX/JiYm/yYmJv8mJyf/Jycn/ycnJ/8oKCj/KCkp/yIiIv8ICAj/AAAA/wAAAP8AAAD/AAAA/wYG + Bv8lJSX/LCws/ywsLP8sLCz/LS0t/y0tLf8uLi7/Li4u/y4vL/8vLy//Ly8v/zAwMP8wMDD/MTEx/zEx + Mf8xMjL/MjIy/zIyMv8zMzP/MzMz/zQ0NP80NDT/NTU1/zY2Nv8eHh7/AQEB/wAAAP8AAADeAAAAKQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB + AQAAAAAAAQEBbwAAAP0BAQH/EBAQ/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsb + G/8bGxv/HBwc/xwcHP8cHBz/HBwc/xwcHP8dHR3/HR0d/x0dHf8dHR3/HR0d/x4eHv8eHh7/Hh4e/x4e + Hv8fHx//Gxsb/wQEBP8AAAD/AAAA/wAAAOoAAAAsAAAAAAAAAAAAAAAUAAAAzQEBAf8AAAD/AAAA/wEB + Af8XFxf/JCQk/yQkJP8kJCT/JCQk/yUlJf8lJSX/JSUl/yYmJv8mJib/Jicn/ycnJ/8nJyf/KCgo/ygo + KP8oKCj/KSkp/x8fH/8FBQX/AAAA/wAAAP8AAAD/AAAA/xcXF/8sLCz/LCws/y0tLf8tLS3/Li4u/y4u + Lv8uLy//Ly8v/y8vL/8wMDD/MDAw/zExMf8xMTH/MTIy/zIyMv8yMjL/MzMz/zMzM/80NDT/NDQ0/zU1 + Nf81NTX/NjY2/zAwMP8JCQn/AAAA/wAAAP8AAACGCAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcAAADMAAAA/wUFBf8YFxf/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xwcHP8cHBz/HBwc/xwcHP8cHBz/HB0d/x0d + Hf8dHR3/HR0d/x0dHf8eHh7/Hh4e/x4eHv8eHh7/Hx8f/x8fH/8dHR3/BwcH/wAAAP8AAAD/AAAA9gAA + AEIAAAAAAQEBAAAAAFcAAAD4AAAA/wAAAP8AAAD/CgoK/yEhIv8kJCT/JCQk/yQkJP8lJSX/JSUl/yUl + Jf8mJib/JiYm/yYnJ/8nJyf/Jycn/ygoKP8oKCj/KCgo/ykpKf8pKSn/Kioq/xcXF/8BAQH/AAAA/wAA + AP8AAAD/CgoK/yoqKv8tLS3/LS0t/y4uLv8uLi7/Li8v/y8vL/8vLy//MDAw/zAwMP8xMTH/MTEx/zEy + Mv8yMjL/MjIy/zMzM/8zMzP/NDQ0/zQ0NP81NTX/NTU1/zU1Nf82Njb/Nzc3/xsbG/8AAAD/AAAA/wAA + ANwAAAAmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAXgAAAPsAAAD/Dg4O/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsb + G/8cHBz/HBwc/xwcHP8cHBz/HBwc/xwcHP8dHR3/HR0d/x0dHf8dHR3/Hh4e/x4eHv8eHh7/Hh4e/x8f + H/8fHx//Hx8f/x8fH/8KCgr/AAAA/wAAAP8AAAD9AAAAWwAAAAAAAAAIAAAAsgAAAP8AAAD/AAAA/wAA + AP8ODg7/JCQk/yQkJP8kJCT/JSUl/yUlJf8lJSX/JiYm/yYmJv8mJyf/Jycn/ycnJ/8oKCj/KCgo/ygo + KP8pKSn/KSkp/yoqKv8qKir/JiYm/wgICP8AAAD/AAAA/wAAAP8EBAT/JSUl/y4uLv8uLi7/Li4u/y4v + L/8vLy//Ly8v/zAwMP8wMDD/MTEx/zExMf8xMjL/MjIy/zIyMv8zMzP/MzMz/zQ0NP80NDT/NDU1/zU1 + Nf81NTX/NjY2/zY2Nv83Nzf/LS0t/wUFBf8AAAD/AAAA/wAAAHwBAQEAAQEBAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAC5AAAA/wMDA/8WFhb/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xsb + G/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/HBwc/xwcHP8cHBz/HBwc/xwcHP8cHRz/HR0d/x0d + Hf8dHR3/HR0d/x4eHv8eHh7/Hh4e/x4eHv8fHx//Hx8f/x8fH/8fHx//ICAg/w0NDf8AAAD/AAAA/wAA + AP8AAAB2AAAAAAAAADEAAADqAAAA/wAAAP8AAAD/AAAA/woKCv8jIyP/JCQk/yUlJf8lJSX/JSUl/yYm + Jv8mJib/Jicm/ycnJ/8nJyf/KCgo/ygoKP8oKCj/KSkp/ykpKf8pKir/Kioq/yoqKv8rKyv/ExMT/wAA + AP8AAAD/AAAA/wEBAf8fHx//Li4u/y4uLv8vLy//Ly8v/y8vL/8wMDD/MDAw/zExMf8xMTH/MjIy/zIy + Mv8yMjL/MzMz/zMzM/80NDT/NDQ0/zU1Nf81NTX/NTY2/zY2Nv82Njb/Nzc3/zc3N/83Nzf/ExMT/wAA + AP8AAAD/AAAA0AAAABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABAQEAAQEBQQAAAPIAAAD/CgoK/xkZGf8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxwb/xwc + HP8cHBz/HBwc/xwcHP8cHBz/HR0d/x0dHf8dHR3/HR0d/x0dHf8eHh7/Hh4e/x4eHv8eHh7/Hx8f/x8f + H/8fHx//Hx8f/yAgIP8gICD/ERER/wAAAP8AAAD/AAAA/wAAAJIAAAAAAAAAdQAAAP8AAAD/AAAA/wAA + AP8AAAD/BwcH/yIiIv8lJSX/JSUl/yUlJf8mJib/JiYm/yYnJ/8nJyf/Jycn/ygoKP8oKCj/KCgo/ykp + Kf8pKSn/KSoq/yoqKv8qKir/Kysr/ywsLP8aGhr/AAAA/wAAAP8AAAD/AAAA/x0dHf8vLy//Li8u/y8v + L/8vLy//MDAw/zAwMP8xMTH/MTEx/zIyMv8yMjL/MjIy/zMzM/8zMzP/NDQ0/zQ0NP81NTX/NTU1/zU1 + Nf82Njb/NjY2/zc3N/83Nzf/ODg4/zk5Of8kJCT/AQEB/wAAAP8AAAD6AAAAXAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRAAAA/wEBAf8SEhL/Ghoa/xoa + Gv8ZGRn/GBgY/xcXF/8WFhb/FRUV/xQUFP8UFBT/FBQU/xQUFP8VFRX/FhYW/xcXF/8ZGRn/Ghoa/xsb + G/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8cHBz/HBwc/xwcHP8cHBz/HBwc/xwcHP8dHR3/HR0d/x0d + Hf8dHR3/Hh4e/x4eHv8eHh7/Hh4e/x8fH/8fHx//Hx8f/x8fH/8gICD/ICAg/yEhIf8UFBT/AAAA/wAA + AP8AAAD/AAAArAAAAAgBAQGtAQEB/wAAAP8AAAD/AAAA/wAAAP8DAwP/GBgY/x8fH/8kJCT/JiYm/yYn + J/8mJyf/Jycn/ycnJ/8oKCj/KCgo/ygoKP8pKSn/KSkp/ykqKv8qKir/Kioq/ysrK/8rKyv/LCws/xwc + HP8AAAD/AAAA/wAAAP8BAAH/HR0d/y8vL/8vLy//Ly8v/zAwMP8wMDD/MTEx/zExMf8xMjL/MjIy/zIy + Mv8zMzP/MzMz/zQ0NP80NDT/NTU1/zU1Nf81NTX/NjY2/zY2Nv83Nzf/Nzc3/zg4OP84ODj/OTk5/zIy + Mv8ICAj/AAAA/wAAAP8AAACxAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAHgAAANgAAAD/AwMD/w4ODv8NDQ3/CgoK/wcHB/8FBQX/BAQE/wMDA/8CAgL/AgIC/wEB + Af8BAQH/AQIB/wICAv8CAgL/BAQE/wYGBv8JCQn/Dg4O/xUVFf8ZGRn/Gxsb/xwcHP8bHBz/HBwc/xwc + HP8cHBz/HBwc/xwcHP8dHR3/HR0d/x0dHf8dHR3/HR0d/x4eHv8eHh7/Hh4e/x4eHv8fHx//Hx8f/x8f + H/8fHx//ICAg/yAgIP8gICD/ISEh/xgYGP8BAQH/AAAA/wAAAP8AAADDAAAAJAAAANQAAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8CAgL/BAQE/wkJCv8UFBT/ICEh/ycnJ/8nKCj/KCgo/ygoKP8oKCj/KSkp/ykp + Kf8qKir/Kioq/yoqKv8rKyv/Kysr/ywsLP8tLS3/FxcX/wAAAP8AAAD/AAAA/wIBAf8hISH/MDAw/y8v + L/8wMDD/MDAw/zExMf8xMTH/MTIy/zIyMv8yMjL/MzMz/zMzM/80NDT/NDQ0/zU1Nf81NTX/NTU1/zY2 + Nv82Njb/Nzc3/zc3N/84ODj/ODg4/zk5Of85OTn/OTk5/xUVFf8AAAD/AAAA/wAAAOkAAAAxAQEBAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAANgAAAGgAAACsAAAA+wAAAP8AAAD/AQEB/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AgIC/wYGBv8NDQ7/FRUV/xsbG/8cHBz/HBwc/xwcHP8cHBz/HB0d/x0dHf8dHR3/HR0d/x0d + Hf8eHh7/Hh4e/x4eHv8eHh7/Hx8f/x8fH/8fHx//Hx8f/yAgIP8gICD/ICAg/yAgIP8ZGRn/DAwM/wEB + Af8AAAD/AAAA/wAAANcAAABKAAAA6wAAAP8CAgL/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8FBQX/ExMT/yMjI/8oKCj/KCgo/ykpKf8pKSn/Kioq/yoqKv8qKir/Kysr/ysrK/8sLCz/LCws/yoq + Kv8LCwz/AAAA/wAAAP8AAAD/BQUF/ygoKP8wMDD/MDAw/zAwMP8xMTH/MTEx/zEyMv8yMjL/MjIy/zMz + M/8zMzP/NDQ0/zQ0NP81NTX/NTU1/zU2Nv82Njb/NjY2/zc3N/83Nzf/ODg4/zg4OP85OTn/OTk5/zo6 + Ov87Ozv/IyMj/wEBAf8AAAD/AAAA/wAAAHYAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQABAQEIAAAAaAAA + AMIAAADuAAAA/gAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8CAgL/CAgI/xER + Ef8ZGRn/HBwc/x0dHf8dHR3/HR0d/x0dHf8dHR3/Hh4e/x4eHv8eHh7/Hh4e/x8fH/8fHx//Hx8f/x8f + H/8gICD/ICAg/yEhIf8dHR3/Dg4O/wICAv8AAAD/AAAA/wAAAP8AAAD+AAAAzwAAAIsICAj4MzIz/1FR + Uv9NTU3/Li4u/woKCv8AAAD/AAAA/gAAAP8AAAD/AAAA/wAAAP8AAAD/CAgI/xwcHP8pKSn/KSkp/yoq + Kv8qKir/Kioq/ysrK/8rKyv/LCws/ywsLP8tLS3/HBwc/wICAv8AAAD/AAAA/wAAAP8ODg7/Li4u/zAw + MP8wMDD/MTEx/zExMf8xMjL/MjIy/zIyMv8zMzP/MzMz/zQ0NP80NDT/NDU1/zU1Nf81Njb/NjY2/zY2 + Nv83Nzf/Nzc3/zg4OP84ODj/OTk5/zk5Of85Ojr/Ojo6/zs7O/8wMDD/BQUF/wAAAP8AAAD/AAAAvQEB + AQsBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAGkAAAD1AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/wQEBP8MDQz/FhYW/xwcHP8eHh7/Hh4e/x4e + Hv8eHh7/Hh4e/x4eHv8eHx//Hx8f/x8fH/8fHx//ICAg/yAgIP8hISH/Ghoa/wgICP8AAAD/AAAA/wAA + AP8AAAD/AAAA3QAAAHYAAACEEBAQ8FFQUf97e3z/jY2N/5KSkv9/f3//XFxc/xsbG/8AAADfAAAAvQAA + APQAAAD/AAAA/wAAAP8AAAD/AwMD/xUVFf8oKCj/Kioq/yoqKv8rKyv/Kysr/ywsLP8tLS3/Kyss/x4e + Hv8FBQb/AAAA/wAAAP8AAAD/AQEB/x4eHv8wMDD/MDAw/zExMf8xMTH/MTIy/zIyMv8yMjL/MzMz/zMz + M/80NDT/NDQ0/zQ1Nf81NTX/NTU1/zY2Nv82Njb/Nzc3/zc3N/84ODj/ODg4/zk5Of85OTn/Ojo6/zo6 + Ov87Ozv/PDw8/zg4OP8NDQ3/AAAA/wAAAP8AAADqAAAALwAAAAAAAAAAAAAAAAAAAAAAAAAaAAAA0QAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8BAQH/AgIC/wQEBP8FBQX/BgYG/wcHB/8HBwf/BgYG/wUFBf8DAwP/AQEB/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8CAgL/CQkJ/xISEv8bGxv/Hh4e/x4eHv8eHh7/Hx8f/x8fH/8fHx//Hx8f/yAg + IP8gICD/ISEh/xkZGf8GBgb/AAAA/wAAAP8AAAD/AAAA+wAAAKkAAAAoAAAAOBEREeJYWFj/jY2N/7m5 + uf/U1NT/19fX/8fHx/+lpaX/bW1t/x4eHvYAAAB5AAAAUAAAAL8AAAD8AAAA/wAAAP8AAAD/AQEB/xIS + Ev8oKCn/Kysr/ywsLP8sLCz/KSkp/x8gIP8QEBD/AwMD/wAAAP8AAAD/AAAA/wAAAP8NDQ3/LS0t/zAw + MP8xMTH/MTEx/zEyMv8yMjL/MjIy/zMzM/8zMzP/NDQ0/zQ0NP81NTX/NTU1/zU2Nv82Njb/NjY2/zc3 + N/84ODj/ODg4/zk5Of85Ojr/Ojo6/zk5Of84ODj/NTY2/zIyMv8tLS3/Jycn/wwMDP8AAAD/AAAA/wAA + AP8AAABoAAAAAAAAAAAAAAAAAAAAAAAAADQAAADqAAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8BAQH/AwMD/wcHB/8LCwv/Dw8P/xMTE/8VFRX/FxcX/xkZGf8ZGRn/Ghoa/xoa + Gv8aGhr/GRkZ/xcXF/8SEhL/CgoK/wQEBP8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/wUF + Bf8PDw//GBgY/x4eHv8fHx//Hx8f/x8fH/8gICD/ICAg/yEhIf8aGxv/BgYG/wAAAP8AAAD/AAAA/wAA + APUAAACDAAAADgAAAAkHBweuTUxM/5OTk//MzMz/39/f/9/f3//f39//4ODg/9ra2v+vr6//ZWVl/xQU + FOgAAABCAAAAEQAAAHoAAADpAAAA/wAAAP8AAAD/AQEB/xMTE/8iIiL/HBwc/xMTE/8JCQn/AgIC/wAA + AP8AAAD/AAAA/wAAAP8AAAD/BgYG/yUlJf8xMTH/MTEx/zExMf8xMjL/MjIy/zIyMv8zMzP/MzMz/zQ0 + NP80NDT/NTU1/zY2Nv82Njb/Nzc3/zc3N/82Njb/NDQ0/zExMf8tLS3/KCgo/yIiIv8bHBz/FRUV/w8P + D/8KCgr/BgYG/wMDA/8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAKMAAAACAQEBAAAAAAAAAAAAAAAAJQAA + ANoAAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wMDA/8HBwf/DQ0N/xISEv8XFxf/GRkZ/xoa + Gv8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bHBz/HBwc/xwcHP8cHBz/GBgY/xAQ + EP8ICAj/AgIC/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8DAwP/CwsL/xUVFf8dHR3/ICAg/yAg + IP8gISH/HR0e/wkJCf8AAAD/AAAA/wAAAP8AAADzAAAAdAAAAAYAAAAAAAAARioqKvJ+fn7/xcXF/+Dg + 4P/e3t7/3t7e/97e3v/e3t7/39/f/9fX1/+YmJj/T09P/wgJCcEAAAAUAAAAAwAAAF0AAADqAAAA/wAA + AP8AAAD/AQEB/wMDA/8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wYGBv8hISH/MDAw/zEx + Mf8xMTH/MjIy/zMzM/8zMzP/NDQ0/zQ0NP8zMzP/MjIy/zAwMP8sLCz/KCgo/yMjI/8dHR3/FxcX/xER + Ef8MDAz/BwcH/wQEBP8CAgL/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA0QEBARUBAQEAAAAAAAAAAAAAAAACAAAAkwAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/wcH + B/8PDw//FRUV/xkZGf8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGxv/Gxsb/xsbG/8bGxv/Gxsb/xsb + G/8bGxv/Gxsb/xwcHP8cHBz/HBwc/xwcHP8dHR3/HR0d/xsbG/8WFhb/DAwM/wQEBP8BAAH/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AQEB/wcHB/8RERH/Gxsb/x8gIP8PDw//AAAA/wAAAP8AAAD/AAAA+AAA + AHwBAQEFAAAAAAAAAAIICAibV1dX/6+vr//e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/39/f/729 + vf98fHz/MTIy+gAAAKIAAAChAAAA0QAAAPcAAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wICAv8PDw//JiYm/zExMf8xMTH/MDAw/y4uLv8rKyz/KCgo/yMjI/8eHh7/GBgY/xIS + Ev8NDQ3/CQkJ/wUFBf8CAgL/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/gAAAPgAAADbAAAALAAAAAAAAAAAAAAAAAAA + AAAAAAAcAAAApAAAAPkAAAD/AAAA/wAAAP8FBQX/FxcX/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGhr/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8cHBz/HBwc/xwcHP8cHBz/HBwc/xwc + HP8dHR3/HR0d/x4eHv8dHR3/Ghoa/xEREf8ICAj/AgIC/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8EBAT/CgoK/wMDA/8AAAD/AAAA/wAAAP8AAACXAAAACgAAAAAAAAAAAAAAJCEhId6CgoL/1NTU/9/f + 3//e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/f39//2dnZ/5mZmf9gYGH/CwsL/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AQEB/wAAAP8AAAD/AAAA/wICAv8KCgr/FxcX/yEhIf8fHx//GRkZ/xQU + FP8PDw//CgoK/wYGBv8DAwP/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEB + Af8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAPsAAADxAAAA4gAAAM8AAAC3AAAAmwAA + AH4AAABgAAAARQAAAC0AAAAJAAAAAAAAAAAAAAAABQUFAAAAAAAAAAAOAAAATQAAAMIAAAD/AAAA/wgI + CP8ZGRn/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsb + G/8bGxv/HBwc/xwcHP8cHBz/HBwc/xwcHP8dHR3/HR0d/x0dHf8dHR3/HR0d/x4eHv8eHh7/Hh4e/x0d + Hf8WFhb/DAwM/wQEBP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA0gEB + ASMBAQEAAQEBAAMDAwAAAABjQUFB/aSkpP/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e + 3v/f4OD/ubm5/3l5ef8oKSn/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AwMD/wYGBv8FBQX/AgIC/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP0AAAD2AAAA6gAAANgAAADCAAAAqAAA + AIsAAABtAAAAUQAAADcBAQEiAAAAEgAAAAcBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAABAQEEAQEBrAAAAP8AAAD/CwsL/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8aGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xwcHP8cHBz/HBwc/xwcHP8cHBz/HB0d/x0d + Hf8dHR3/HR0d/x0dHf8eHh7/Hh4e/x4eHv8eHh7/Hx8f/x8fH/8fHx//Gxsb/xEREf8HBwf/AQEB/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAADwAAAArgAAAF8AAAAgAAAACQ8PD6xkZGT/wMDA/+Dg + 4P/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/9/f3//U1NT/j4+P/0tLS/8BAQH/AAAA/gAA + APEAAADXAAAAuQAAAKYAAADrAAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD6AAAA8AAAAOAAAADMAAAAtAAA + AJgAAAB6AAAAXQAAAEIAAAArAQEBGQEBAQsAAAADAgICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAICAgABAQEDAQEBBAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAADOAAAA/wAA + AP8ODg7/Ghoa/xoaGv8aGhr/Ghoa/xoaGv8aGhr/Ghoa/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsc + G/8cHBz/HBwc/xwcHP8cHBz/HBwc/x0dHf8dHR3/HR0d/x0dHf8dHR3/Hh4e/x4eHv8eHh7/Hh4e/x8f + H/8fHx//Hx8f/x8fH/8gICD/ICAg/x4eHv8XFxf/DQwM/wQEBP8BAQH/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA+wAAANwAAACsJCQk6omJif/W1tb/39/f/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e + 3v/e3t7/3t7e/97e3v+qqqr/ZmZm/w8PD+sAAAB2AAAAOgAAABgAAAAIAAAAAgEBAYQAAAD+AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD9AAAA9QAAAOgAAADWAAAAvwAA + AKQAAACHAQEBagAAAE4AAAA1AAAAIAAAABAAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAABAQEAAQEBAQEBAQkAAAAYAAAALQAAAEgAAABnAAAAiAAAAKsAAABjAAAAAAEB + AQAAAAAAAAAAAAAAAAAAAAAAAAAAJwAAAOYAAAD/AAAA/xAQEP8aGxv/Ghoa/xoaGv8aGhr/Ghoa/xoa + Gv8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/HBwc/xwcHP8cHBz/HBwc/xwcHP8dHR3/HR0d/x0d + Hf8dHR3/HR0d/x0eHv8eHh7/Hh4e/x4eHv8fHx//Hx8f/x8fH/8fHx//ICAg/yAgIP8hISH/ICAg/yAg + IP8eHh7/FxcX/wQEBP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP9DQ0P/qamp/9/f + 3//e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/4ODg/8LCwv96enr/Jycn6wAA + ADAAAAAAAAAAAAAAAAAAAAAAAAAAHwAAANYAAAD/AAAA/wAAAP8AAAD/AAAA+QAAAO4AAADeAAAAygAA + ALEAAACUAAAAdwEBAVoAAAA/AAAAKQAAABcBAQEKAQEBAgEBAQACAgIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAQEBAAEBAQAAAAAHAAAAFAEBAScAAABAAAAAXgAAAH8AAACgAAAAvgAA + ANcAAADrAAAA+AAAAP4AAAD/AAAA/wAAAJABAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9AAAA9AAA + AP8BAQH/EhIS/xsbG/8aGhr/Ghoa/xoaGv8aGhr/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xwc + HP8cHBz/HBwc/xwcHP8cHBz/HR0d/x0dHf8dHR3/HR0d/x0dHf8eHh7/Hh4e/x4eHv8eHh7/Hx8f/x8f + H/8fHx//Hx8f/yAgIP8gICD/Gxsb/xEREf8MDAz/CAgI/wYGBv8FBQX/AQEB/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/CQkJ/2ZmZv/ExMT/29vb/93d3f/e3t7/3t7e/97e3v/e3t7/3t7e/97e + 3v/e3t7/3t7e/97f3//Z2dn/zs7O/4uLi/9AQED/AAAAZwICAgABAQEAAAAAAAAAAAAAAAAAAAAAdwAA + AL8AAAChAAAAhAEBAWYAAABLAAAAMgAAAB4AAAAPAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQABAQEAAQEBBAAAAA8BAQEhAAAAOAAAAFUBAQF2AAAAlwAA + ALYAAADRAAAA5gAAAPUAAAD9AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAAnWlp + aQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFYAAAD8AAAA/wEBAf8TExP/Gxsb/xoaGv8aGhr/Ghoa/xsb + G/8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8cHBz/HBwc/xwcHP8cHBz/HBwc/xwdHf8dHR3/HR0d/x0d + Hf8dHR3/Hh4e/x4eHv8eHh7/Hx8f/x8fH/8fHx//ICAg/yAgIP8gICD/Gxsb/w4ODv8EBAT/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8cHBz/g4OD/8/P + z/+dnZ3/1NTU/9/f3//e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/39/f/87Ozv+tra3/oqKi/1lZ + Wf8JCQmhAAAAAgEBAQAAAAAAAAAAAAEBAQABAQEHAAAACQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAEBAQIBAQEMAAAAGwAAADEAAABNAQEBbQAA + AI4AAACuAAAAygAAAOEAAADxAAAA/AAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8BAQGjAAAAAQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAbQAA + AP8AAAD/AQEB/xQUFP8bGxv/Ghoa/xobGv8bGxv/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8bGxv/HBwc/xwc + HP8cHBz/HBwc/xwcHP8dHR3/HR0d/x0dHf8dHR3/Hh4e/x4eHv8eHh7/Hh4e/x0dHf8bGxv/GRkZ/xYW + Fv8TExP/EBAQ/wwMDP8FBQX/AAAA/wAAAP8AAAD/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/zU1Nf+Tk5P/np6e/3V1df/b29v/3t7e/97e3v/e3t7/3t7e/97e + 3v/e3t7/3t7e/97e3v/e3t7/3Nzc/4KCgv92dnb/bm5u/xsbG9IAAAAWAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQABAQEBAAAACAEBARcAAAArAAAARQAA + AGQAAACFAAAApQAAAMMAAADbAAAA7gAAAPoAAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AgIC/wUFBf8LCwv/CwsL/wEBAf8AAAD/AAAA/wAA + AKMAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+AAAA/wAAAP8BAQH/FBQU/xsbG/8aGhr/Gxsb/xsb + G/8bGxv/Gxsb/xsbG/8bGxv/HBwc/xwcHP8cHBz/HBwc/x0dHf8dHR3/HR0d/xwcHP8bGxv/GRkZ/xcX + F/8UFBT/ERER/w0NDf8KCgr/BwcH/wQFBf8DAwP/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8BAQH/PDw8/zg4 + OP8/Pz//tLS0/+Dg4P/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/g4OD/ubm5/zY2 + Nv8yMjP/Gxsb8QAAADoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEAAQEBAAEBAQYAAAASAAAAJQAA + AD0AAABbAQEBfAAAAJ0AAAC7AAAA1QAAAOkAAAD3AAAA/gAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf8EBAT/CAgI/w4ODv8WFhb/Hh4e/yYm + Jv8uLi//NjY2/zw8PP8uLi7/AgIC/wAAAP8AAAD/AAAAogEBAQEAAAAAAAAAAAAAAAABAQEAAAAAAAAA + AI4AAAD/AAAA/wEBAf8UFBT/Gxsb/xsbG/8bGxv/Gxsb/xsbG/8cHBz/HBwc/xsbG/8aGxv/GRkZ/xcX + F/8VFRX/EhIS/w8PD/8MDAz/CAgI/wYGBv8EBAT/AgIC/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf8LCwv/Pj4+/7u7u//g4OD/3t7e/97e3v/e3t7/3t7e/97e + 3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/g4OD/uLi4/zg4OP8EBAT/AAAAZQAAAAABAQEAAAAAAAEB + AQABAQEcAAAAUwAAAHIAAACUAAAAswAAAM8AAADkAAAA9AAAAP0AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8BAQH/AwMD/wcHB/8MDAz/ExMT/xoa + Gv8jIyP/Kior/zIyMv84ODj/PDw8/z8/P/9BQUH/QkJC/0JCQv9CQkL/Q0ND/zQ0NP8EBAT/AAAA/wAA + AP8AAACbAwMDAAAAAAAAAAAAAAAAAAEBAQAAAAAAAAAAmQAAAP8AAAD/AQEB/xMTE/8bGxv/GRkZ/xgY + GP8WFhb/ExMT/xAQEP8NDQ3/CgoK/wcHB/8FBQX/AwMD/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/QAAAO8AAADiAAAA4gAAAOwAAAD3AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/ykp + Kf+kpKT/4eHh/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e + 3v/c3Nz/j5CQ/zMzM/8AAACLBgYGAAAAAAAAAAAAAQEBAAAAAHoAAAD+AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/wMDA/8GBgb/CgoK/xAQ + EP8XFxf/Hx8f/ycnJ/8uLi7/NDQ0/zk5Of88PDz/Pj4+/z8/P/8/QED/QEBA/0BAQP9AQED/QEBA/0FB + Qf9BQUH/QkJC/0JCQv9DQ0P/NjY2/wUFBf8AAAD/AAAA/wAAAI8BAQEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAACdAAAA/wAAAP8BAQH/CAgI/wkJCf8GBgb/BAQE/wICAv8BAQH/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD9AAAA9QAA + AOcAAADfAAAA+wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAOEAAAB7AAAANQAAACIBAQEiAAAALgAA + AEUAAABuAAAAmwAAAM0AAADxAAAA/gAAAP8ICAj/YWBh/7a2tv/f39//3t7e/97e3v/e3t7/3t7e/97e + 3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/9zc3P+cnJz/W1tb/wkJCaoAAAAEAQEBAAEB + AQABAQEBAAAAmwAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8CAgL/CQkJ/xITE/8cHBz/JCQk/ywsLP8xMjL/NjY2/zk5Of87Ozv/Ozs7/zw8PP88PDz/PT09/z4+ + Pv8+Pj7/Pz8//0BAQP9BQUH/QUFB/0FBQf9BQUH/QkJC/0JCQv9CQkL/Q0ND/0RERP82Njb/BQUF/wAA + AP8AAAD/AAAAgQEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAKAAAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA+wAA + APEAAADhAAAAzQAAALQAAACXAAAAeQAAAFsAAABAAAAAJQAAAG0AAAD7AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAADLAAAAOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQABAQEBAAAAEgEBAToAAAB1AAAAugwM + DPRnZ2f/tbW1/9/f3//e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e + 3v/e3t7/3d3d/6CgoP9jY2P/CwsL5wAAAKEAAACMAAAAhgAAAJoAAADmAAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf8DAwP/BgYG/wgICP8KCgr/CwsL/wwN + Df8ODg7/Dw8P/xEREf8SEhL/ExMT/xMUFP8VFRX/FxcX/xoaGv8eHh7/IiIi/ycnJ/8sLS3/MjIy/zc3 + N/88PDz/QEBA/0JCQv9ERET/RUVF/zc3N/8FBQX/AAAA/wAAAP8AAABtAAAAAAEBAQAAAAAAAAAAAAAA + AAAAAAAAAAAAngAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/gAA + APgAAADrAAAA2gAAAMQAAACpAAAAjAAAAG0AAABRAAAANwAAACEBAQERAAAABgEBAQABAQEAAAAAAAAA + AAAAAAAIAAAAsQAAAP8AAAD/AAAA/wAAAP8AAAD/AAAAzgAAAC0AAAAAAAAAAAEBAQACAgIAAQEBBQAA + ABAAAAAhAAAAJwAAAAMAAAAAAAAAAAEBAQAAAAAPDw4PumRkZP+wsLD/39/f/97e3v/e3t7/3t7e/97e + 3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/d3d3/oqKi/2hoaP8ODg7/AAAA/wAA + AP8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wICAv8DAwP/BgYH/wsLC/8RERH/GRkZ/yIjI/8uLi7/Kioq/wMD + A/8AAAD/AAAA/AAAAFUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACVAAAA/wAAAP8AAAD/AAAA/wAA + APwAAAD0AAAA5QAAANIAAAC6AAAAngAAAIAAAABiAAAARgAAAC4AAAAaAAAADAEBAQMBAQEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoAAADnAAAA/wEBAf8BAQH/AAAA/wAA + APIAAABdAAAAJAAAAD8BAQFaAQEBeAAAAJYAAACzAAAAzAAAAOIAAADVAAAAKAAAAAAAAAAAAAAAAAAA + AAMMDAyqYGBg/62trf/f39//3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e + 3v/e3t7/3t7e/93d3f+hoaH/aWlp/w8PD/8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf8DAwP/AQEB/wAAAP8AAAD2AQEBRAEBAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAHcAAADNAAAAsAAAAJMAAAB1AAAAVwAAAD0AAAAmAAAAFAEBAQgAAAABAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEAAgICAAEB + AQQAAAAKAAAAZAAAAPwAAAD/AAAA/wAAAP8AAAD/AAAA9gAAANgAAADnAAAA9QEBAf0AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAB8AAAAAAAAAAAAAAAAAAAAAAgICJ1YWVj/pKSk/93d3f/e3t7/3t7e/97e + 3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3d3d/5+fn/9mZmb/DAwM/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wQEBP8NDQ3/Dg4O/w0NDf8LCwv/CAgI/wUFBf8CAgL/AAAB/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP4AAAC4AAAAJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQAAABAAAAAFAQEBAAEB + AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAEB + AQEAAAAHAAAAEwAAACMAAAA5AAAAVAAAAHEAAACPAAAArAAAAMYAAADnAAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAOIAAAA0AAAAAAAA + AAIAAAAqAgICu05OTv+ZmZn/2tra/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e + 3v/e3t7/3t7e/97e3v/c3Nz/mpqa/15eXv8HBwf9AAAA7QAAANEAAADvAAAA/wAAAP8AAAD/FRUV/zMz + M/8zMzP/MzMz/zIyMv8xMTH/Li0u/ykpKf8jIyP/HBwc/xUVFf8PDw//CQkJ/wUFBf8DAwP/AQEB/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAACfAQEBBAEB + AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUFAAAA + AAABAQECAAAACwAAABgAAAArAAAAQwAAAF8AAAB9AAAAmwAAALcAAADQAAAA4wAAAPIAAAD8AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8BAQH/AgIC/wEBAf8AAAD/AAAA/wAAALUAAAA0AAAAgwAAAOEAAAD/P0BA/4uLi//R0dH/39/f/97e + 3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/39/f/9LS0v+Li4v/TExM/wIC + ArwAAAAwAQEBVQAAAO4AAAD/AAAA/wMDA/8nJif/NjY2/zY2Nv82Njb/Nzc3/zc3N/84ODj/OTk5/zk5 + Of85OTn/OTk5/zc3N/81NTX/MTEx/ywsLP8nJyf/IiIi/xwcHP8YGBj/FBMU/xAQEP8MDAz/CgoK/wgI + CP8GBgb/BQUF/wQEBP8EBAT/AwMD/wICAv8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAM0BAQERAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABAQEAAQEBBQEBAQ8AAAAfAAAANAAAAE0AAABqAAAAiAAAAKYAAADBAAAA2AAAAOoAAAD2AAAA/gAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AQEB/wICAv8FBQX/BwcH/wsLC/8PDw//FBQU/xgYGf8dHR3/EBAQ/wAAAP8AAAD/AAAA+wAA + AOoAAAD9AAAA/wAAAP8qKir/e3t7/729vf/g4OD/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e + 3v/e3t7/3t7e/97e3v/g4OD/wsLC/319ff8wMDD/AAAAhAAAABcAAAC/AAAA/wAAAP8AAAD/EBAQ/zMz + M/82Njb/NjY2/zY2Nv83Nzf/Nzc3/zg4OP84ODj/OTk5/zk5Of85Ojr/Ojo6/zs7O/87PDz/PDw8/z09 + Pf89PT3/PT09/z09Pf89PT3/PDw8/zo6Ov85OTn/ODg4/zY2Nv80NDT/MzMz/zMzM/8xMTH/MDAw/y0t + Lf8qKir/JSUl/yEhIf8bGxv/FhUW/xAPEP8KCgr/BQUF/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAAtgAA + AAoAAAAAAAAAAAAAAAAAAAAAAAAAAgAAADIAAABZAAAAdgAAAJQAAACxAAAAygAAAN8AAADvAAAA+gAA + AP8AAAD/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wEBAf8BAQH/AAAA/wAAAP8AAAD/AAAA/wQEBP8XFxf/HR0d/yAgIP8jIyP/JCUl/yYm + Jv8nJyf/Jycn/ygoKP8fHx//AwMD/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/xISEv9ra2v/pKSk/93d + 3f/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/3t7e/97e3v/e3t7/39/f/9zc3P+lpaX/ZWVl/w4O + Dv8AAADfAAAAwgAAAPwAAAD/AAAA/wQEBP8oKCj/Nzc3/zc3N/83Nzf/Nzc3/zg4OP84ODj/ODg4/zg5 + Of85OTn/Ojo6/zo6Ov86Ojr/Ozs7/zs7O/88PDz/PDw8/z09Pf89PT3/Pj4+/z4+Pv8/Pz//Pz8//0BA + QP9AQED/QUFB/0FCQv9CQkL/QkND/0NDQ/9ERET/RERE/0VFRf9FRUX/RUVF/0VFRf9ERET/QkJC/z8/ + P/82NTb/CwsL/wAAAP8AAAD/AAAA/AAAANEAAABCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAApAAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wEBAf8CAgL/BAQE/wYGBv8JCQn/DQ0N/xEREf8VFRX/Dw8P/wICAv8AAAD/AAAA/wAA + AP8AAAD/CQkJ/yMjI/8lJSX/JSUl/yUmJv8mJib/JiYm/ycnJ/8nJyf/IyQk/xMTE/8CAgL/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AQEB/0RERP+CgoL/uLi4/9/f3//e3t7/3t7e/97e3v/e3t7/3t7e/97e + 3v/e3t7/3t7e/9/f3//d3d3/s7Oz/3t7fP8wMDD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/BwcH/x0d + Hf8jIyP/Jycn/ysrK/8vLy//MjIy/zU2Nv84ODj/Ojo6/zo6Ov86Ojr/Ojs6/zs7O/87Ozv/PDw8/zw8 + PP89PT3/PT09/z4+Pv8+Pj7/Pj8//z8/P/8/QED/QEBA/0BAQP9BQUH/QUFB/0JCQv9CQkL/Q0ND/0ND + Q/9DQ0P/RERE/0RFRP9FRUX/RUVF/0ZGRv9GRkb/SEhI/z4+Pv8JCQn/AAAA/wAAAO0AAABpAAAAHgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAAB4AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8BAQH/AgIC/wQEBP8HBwf/CgoK/w0NDf8RERH/FRUV/xkZGf8cHBz/Hh4e/yAg + If8hISH/HBwc/xAQEP8EBAT/AAAA/wAAAP8AAAD/AAAA/wAAAP8QEBD/JSUl/yUlJf8lJSX/JiYm/yYm + Jv8nJyf/Jycn/x4eHv8KCgr/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/Dg4O/1lZ + Wf+EhYX/u7u7/97e3v/f39//3t7e/97e3v/e3t7/3t7f/9/f3//g4OD/3Nzc/7CwsP9/f3//RERE/wQE + BP8AAAD/AAAA/wAAAP8AAAD/AQEB/wAAAP8AAAD/AAAA/wEBAf8CAgL/BAQE/wYGBv8ICAj/DQ0N/xUV + Ff8iIyP/MjIy/zs7O/87Ozv/Ozs7/zw8PP88PDz/PT09/z09Pf8+Pj7/Pj4+/z8/P/8/Pz//P0BA/0BA + QP9AQED/QUFB/0FBQf9CQkL/QkJC/0NDQ/9DQ0P/Q0RE/0RERP9ERET/RUVF/0VFRf9GRkb/RkZG/0dH + R/9ISEj/NDQ0/wMDA/8AAAD/AAAAwgAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AEUAAAD2AAAA/wAAAP8AAAD/AQEB/wMDA/8FBQX/CAcI/wsLC/8ODg7/EhIS/xUVFf8YGBj/Gxsb/x0d + Hf8fHx//ICAg/yAgIP8hISH/ISEh/yEhIf8eHh7/FxcY/w0NDf8EBAT/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AgIC/xsbG/8lJib/JSUl/yYmJv8mJib/Jycn/yUlJf8WFhb/BAQE/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD+Dw8P/05OTv9/f3//sLCw/9HR0f/c3Nz/3d3d/9vb + 2//Z2dn/1NTU/8PDw/+lpaX/e3t7/0RERP8HBwf+AAAA+AAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8JCQn/Jycn/zs7O/88PDz/PDw8/z09 + Pf89PT3/Pj4+/z4+Pv8+Pz//Pz8//z8/P/9AQED/QEBA/0FBQf9BQUH/QkJC/0JCQv9DQ0P/Q0ND/0RE + RP9ERET/REVF/0VFRf9FRUX/RkZG/0ZGRv9HR0f/R0dH/0lJSf8nJyf/AAAA/wAAAP8AAACLAAAAAAEB + AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgAAANYAAAD/AAAA/wICAv8RERH/GRkZ/xsb + G/8cHBz/Hh4e/x4eHv8fHx//Hx8f/x8fH/8fHx//ICAg/yAgIP8gICD/ICEg/x4eHv8YGBj/Dw8P/wcH + B/8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8QDxD/JCQk/yUlJf8mJib/JiYm/ycn + J/8kJCT/EBAQ/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/BgYG/zU1Nf9ra2v/iYmJ/5ycnP+fn5//mZmZ/5SUlP+LjIz/fn5+/2ZmZv8xMTL/BAUF/wAA + AP8AAAD+AAAA/wAAAP8AAAD/AwMD/wMDA/8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8EBAT/LCws/z09Pf89PT3/PT09/z4+Pv8+Pj7/Pj8//z8/P/8/Pz//QEBA/0BA + QP9BQUH/QUFB/0JCQv9CQkL/Q0ND/0NDQ/9DRET/RERE/0RERP9FRUX/RUVF/0ZGRv9GRkb/R0dH/0dH + R/9ISEj/R0dH/xgYGP8AAAD/AAAA+QAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAACAAAAngAAAP8AAAD/AQEB/xMTE/8eHh7/Hh4e/x4eHv8eHh7/Hh4e/x8fH/8fHx//Hx8f/x8f + H/8gICD/ICAg/xsbG/8RERH/BwcH/wICAv8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/DQwN/yIhIv8mJib/JiYm/yYmJv8nJyf/ISEh/wwMDP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wQEBP8KCgr/AgIC/wAAAP8AAAD/AQEB/wAAAP8AAAD/AQEB/xMTE/84ODj/UVFR/1xc + XP9dXV3/VVZV/0RERP8rKyv/Dw8P/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/w0NDf8oKCj/KCgo/x4e + Hv8WFhb/Dw8P/woKCv8GBgb/AwMD/wEBAf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8ZGRn/PD09/z09 + Pf8+Pj7/Pj4+/z4/P/8/Pz//Pz8//0BAQP9AQED/QUFB/0FBQf9CQkL/QkJC/0NDQ/9DQ0P/Q0RE/0RE + RP9ERET/RUVF/0VFRf9GRkb/RkZG/0dHR/9HR0f/R0hI/0hJSf9AQED/CwsL/wAAAP8AAADZAAAAHQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAAAAAAAABcAAAA/AAAAP8AAAD/DQ0N/x4e + Hv8eHh7/Hh4e/x4eHv8eHx//Hx8f/x8fH/8fHx//ICAg/x0dHf8QEBD/BAQE/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/BAQE/xMSE/8jIyP/JiYm/yYmJv8mJib/Jycn/yAg + IP8JCQn/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf8LCwv/ICAg/ykpKf8bGxv/BwcH/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8CAgL/BgYG/wYGBv8DAwP/AAAA9QAAAMEAAADlAAAA/wAA + AP8AAAD/AAAA/wUFBf8YGBj/MDAw/zc3N/83Nzf/ODg4/zc3N/82Njb/NDQ0/zAwMP8sLCz/JyYm/x8f + H/8TExP/AgIC/wAAAP8AAAD/AAAA/w0NDf86Ojr/Pj4+/z4+Pv8+Pj7/Pz8//z8/P/9AQED/QEBA/0FB + Qf9BQUH/QkJC/0JCQv9DQ0P/Q0ND/0NERP9ERET/RERE/0VFRf9FRUX/RkZG/0ZGRv9HR0f/R0dH/0dI + SP9ISEj/SkpK/zMzM/8CAgL/AAAA/wAAAJ8AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAACAAAADbAAAA/wAAAP8HBwf/HBwc/x4eHv8eHh7/Hx8f/x8fH/8fHx//Hx8f/yAg + IP8cHBz/CQkJ/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/BAQE/w8P + D/8eHh7/JSUl/yYmJv8mJib/JiYm/ycnJ/8hISH/CQkJ/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8DAwP/FRUV/ygoKP8sLCz/LCws/y0tLf8nJyf/FhYW/wcHB/8BAQH/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAACkAAAADgAAAKYAAAD/AAAA/wAAAP8RERH/Kysr/zU1Nf82Njb/NjY2/zc3 + N/83Nzf/ODg4/zg4OP85OTn/OTo6/zo6Ov87Ozv/PDw8/ywsLP8DAwP/AAAA/wAAAP8AAAD/ExMT/zw8 + PP8+Pj7/Pj8//z8/P/8/Pz//QEBA/0BAQP9BQUH/QUFB/0JCQv9CQkL/Q0ND/0NDQ/9DRET/RERE/0RE + RP9FRUX/RUVF/0ZGRv9GRkb/R0dH/0dHR/9HSEj/SEhI/0hISP9JSUn/ICAg/wAAAP8AAAD6AAAAWAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAJoAAAD/AAAA/wIC + Av8YGBj/Hx8f/x8fH/8fHx//Hx8f/x8fH/8gICD/Hh4e/wsLC/8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8DAwP/CQkJ/xQUFP8eHx//JCQk/yUlJf8lJSX/JiYm/yYmJv8nJyf/IiIi/woK + Cv8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/CQgJ/x8eH/8rKyv/LCws/ywsLP8sLCz/LS0t/y4u + Lv8uLi7/KCgo/x0cHP8RERH/BwcH/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA9wAAAE4AAAAAAAAAiAAA + AP8AAAD/AAAA/xkZGf83Nzf/NjY2/zY2Nv83Nzf/Nzc3/zg4OP84ODj/OTk5/zk5Of85Ojr/Ojo6/zo6 + O/87Ozz/Hh4e/wAAAP8AAAD/AAAA/wAAAP8fHx//Pz8//z4/P/8/Pz//Pz8//0BAQP9AQED/QUFB/0FB + Qf9CQkL/QkJC/0NDQ/9DQ0P/Q0RE/0RERP9ERET/RUVF/0VFRf9GRkb/RkZG/0dHR/9HR0f/R0hI/0hI + SP9ISEj/SUlJ/0NDQ/8ODg7/AAAA/wAAANYAAAAbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAPYAAAD/AAAA/xAQEP8fHx//Hx8f/x8fH/8fHx//ICAg/yAg + IP8QEBH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wMDA/8KCgr/ExMT/xwcHP8iIiL/JSUl/yUl + Jf8lJSX/JSUl/yYmJv8mJib/Jycn/yYmJv8QEBD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/w0N + Df8lJSX/LCws/ywsLP8sLCz/LCws/y0tLf8tLS3/Li4u/y4uLv8vLy//MDAw/y8vL/8SEhL/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAADKAQEBEwAAAAAAAABpAAAA/wAAAP8AAAD/ExMT/zU1Nf82Njb/Nzc3/zc3 + N/84ODj/ODg4/zk5Of85OTn/OTo6/zo6Ov86Ojr/Ozs7/zs7O/8WFhb/AAAA/wAAAP8AAAD/AgIC/yws + LP8/QED/Pz8//z8/P/9AQED/QEBA/0FBQf9BQUH/QkJC/0JCQv9DQ0P/Q0ND/0NERP9ERET/RERE/0VF + Rf9FRUX/RkZG/0ZGRv9HR0f/R0dH/0dISP9ISEj/SElJ/0lJSf9KSkr/NDQ0/wMDA/8AAAD/AAAAkAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARAAAAwwAA + AP8AAAD/CAgI/x0dHf8fHx//Hx8f/yAgIP8gICD/Gxsb/wQEBP8AAAD/AAAA/wAAAP8AAAD/AQEB/wgI + CP8TExP/HBwc/yIiIv8kJCT/JCQk/yQkJP8lJSX/JSUl/yUlJf8mJib/JiYm/ycnJ/8nJyf/GBgY/wEB + Af8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf8SEhL/KCgo/ywsLP8rKyz/LCws/ywsLP8tLS3/LS0t/y4u + Lv8uLi7/Li4u/y8vL/8wMDD/Kysr/wgICP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAIIAAAAAAAAAAAAA + AEwAAAD5AAAA/wAAAP8NDQ3/NDQ0/zc3N/83Nzf/ODg4/zg4OP85OTn/OTk5/zk6Ov86Ojr/Ojs7/zs7 + O/87Ozv/Ozw8/xYWFv8AAAD/AAAA/wAAAP8CAgL/LCws/0BAQP8/Pz//QEBA/0BAQP9BQUH/QUFB/0JC + Qv9CQkL/QkND/0NDQ/9ERET/RERE/0RERf9FRUX/RUVF/0ZGRv9GRkb/R0dH/0dHR/9ISEj/SEhI/0hI + SP9JSUn/SUlJ/0lJSf8dHR3/AAAA/wAAAPEAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAABvAAAA/gAAAP8CAgL/FxcX/yAgIP8gICD/ICAg/yAg + IP8PDw//AAAA/wAAAP8AAAD/AAAA/wEBAf8QEBD/ICAg/yMjJP8kJCT/JCQk/yQkJP8kJCT/JSUl/yUl + Jf8lJSX/JiYm/yYmJv8mJib/Jycn/yMjI/8HBwf/AAAA/wAAAP8AAAD/AAAA/wAAAP8BAQH/ExMT/ykp + Kf8sLCz/LCws/ywsLP8sLCz/LS0t/y0tLf8uLi7/Li4u/y4uLv8vLy//Ly8v/zExMf8hISH/AQEB/wAA + AP8AAAD/AAAA/wAAAP8AAADvAAAAOgAAAAAAAAAAAAAAMwAAAO4AAAD/AAAA/wkJCf8xMTH/ODg4/zg4 + OP84ODj/OTk5/zk5Of85Ojr/Ojo6/zo6Ov87Ozv/Ozs7/zw8PP88PT3/Ghoa/wAAAP8AAAD/AAAA/wAA + AP8eHh7/QEBA/0BAQP9AQED/QUFB/0FBQf9CQkL/QkJC/0NDQ/9DQ0P/RERE/0RERP9ERUX/RUVF/0VF + Rf9GRkb/RkZG/0dHR/9HR0f/R0hI/0hISP9ISEj/SUlJ/0lJSf9KSkr/Pz8//wkJCv8AAAD/AAAAtQAA + AAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ACEAAADYAAAA/wAAAP8NDQ3/HyAg/yAgIP8gICD/Hh4e/wYGBv8AAAD/AAAA/wAAAP8AAAD/CwsL/yEh + If8jIyP/IyMj/yQkJP8kJCT/JCQk/yUlJf8lJSX/JSUl/yYmJv8mJib/Jicn/ycnJ/8oKCj/FxcX/wEB + Af8AAAD/AAAA/wAAAP8AAAD/AAAA/xISEv8pKSn/Kysr/yssLP8sLCz/LCws/y0tLf8tLS3/Li4u/y4u + Lv8uLi7/Ly8v/y8vL/8wMDD/MDAw/xUVFf8AAAD/AAAA/wEBAf8BAQH/AAAA/wAAANgAAAAZAAAAAAEB + AQABAQEeAAAA3gAAAP8AAAD/BQUF/y4uLv84ODj/ODg4/zk5Of85OTn/OTo6/zo6Ov86Ojr/Ozs7/zs7 + O/88PDz/PDw8/z4+Pv8oKCj/AQEB/wAAAP8AAAD/AAAA/wgICP80NDT/QUFB/0FBQf9BQUH/QkJC/0JC + Qv9DQ0P/Q0ND/0NERP9ERET/RERE/0VFRf9FRUX/RkZG/0ZGRv9HR0f/R0dH/0dISP9ISEj/SElJ/0lJ + Sf9JSUn/SkpK/0tLS/8pKSn/AAAA/wAAAP4AAABmAAAAAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH8AAAD/AAAA/wQEBP8bGxv/ICAg/yEh + If8YGBj/AQEC/wAAAP8AAAD/AAAA/wICAv8aGhr/JCQk/yMjI/8kJCT/JCQk/yQkJP8lJSX/JSUl/yUl + Jf8mJib/JiYm/yYmJv8nJyf/Jycn/yUlJf8JCQn/AAAA/wAAAP8AAAD/AAAA/wAAAP8LCwv/Jycn/yws + LP8sLCz/LCws/ywtLf8tLS3/LS0t/y4uLv8uLi7/Li8v/y8vL/8vLy//MDAw/zAxMf8tLS3/CQkJ/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA5gAAACgAAAAAAAAAAAAAAA8AAADIAAAA/wAAAP8CAgL/KSkp/zk5 + Of85OTn/OTk5/zo6Ov86Ojr/Ojo6/zs7O/87Ozv/PDw8/zw8PP89PT3/Pj4+/zY2Nv8KCgr/AAAA/wAA + AP8AAAD/AAAA/xQUFP88PDz/QkJC/0JCQv9CQkL/Q0ND/0NDQ/9DRET/RERE/0RERP9FRUX/RUVF/0ZG + Rv9GRkb/R0dH/0dHR/9HSEj/SEhI/0hISP9JSUn/SUlJ/0pKSv9LS0v/RUVF/xAQEP8AAAD/AAAA/wAA + AH4BAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAJwAAAN0AAAD/AAAA/xEREf8hISH/ISEh/xEREv8AAAD/AAAA/wAAAP8AAAD/CgoK/yIi + Iv8jIyP/JCQk/yQkJP8kJCT/JSUl/yUlJf8lJSX/JiYm/yYmJv8mJib/Jycn/ycnJ/8oKCj/ISEh/wMD + A/8AAAD/AAAA/wAAAP8AAAD/AwMD/yAgIP8sLCz/LCws/ywsLP8sLCz/LS0t/y0tLf8uLi7/Li4u/y4u + Lv8vLy//Ly8v/zAwMP8wMDD/MTEx/yQlJf8CAgL/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD1AAAAQQAA + AAABAQEAAQEBBAAAAK4AAAD/AAAA/wAAAP8jIyP/OTo6/zk5Of85Ojr/Ojo6/zo6Ov87Ozv/Ozs7/zw8 + PP88PDz/PT09/z09Pf8+Pj7/Pj4+/yAgIP8AAAD/AAAA/wAAAP8AAAD/AQEB/xwbHP8/Pz//Q0ND/0ND + Q/9DQ0P/Q0RE/0RERP9ERET/RUVF/0VFRf9GRkb/RkZG/0dHR/9HR0f/R0hI/0hISP9ISEj/SUlJ/0lJ + Sf9KSkr/SkpK/0xMTP8vLy//AgIC/wAAAP8AAAD/AAAAyAEBARIBAQEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCgoAAAAAgAAAAP8AAAD/BgYG/x0d + Hf8hISH/DAwM/wAAAP8AAAD/AAAA/wAAAP8SEhL/JCQk/yQkJP8kJCT/JCQk/yUlJf8lJSX/JSUl/yYm + Jv8mJib/Jycn/ycnJ/8nJyf/KCgo/ykpKf8eHh7/AgIC/wAAAP8AAAD/AAAA/wAAAP8NDQ3/Kioq/yws + LP8sLCz/LCws/y0tLf8tLS3/Li4u/y4uLv8uLy//Ly8v/y8vL/8wMDD/MDAw/zExMf8yMjL/Ghoa/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEBAf4AAABfAQEBAAEBAQAAAAAAAAAAkQAAAP8AAAD/AAAA/x0d + Hf86Ojr/OTo6/zo6Ov86Ozv/Ozs7/zs7O/88PDz/PDw8/z09Pf89PT3/Pj4+/z4+Pv8/Pz//Nzc3/wsL + C/8AAAD/AAAA/wAAAP8AAAD/AQEB/x4eHv9AQED/RERE/0NERP9ERET/REVE/0VFRf9FRUX/RkZG/0ZG + Rv9HR0f/R0dH/0hISP9ISEj/SEhI/0lJSf9JSUn/SkpK/0pKSv9LS0v/RkZG/xISEv8AAAD/AAAA/wAA + AP8AAADqAAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBAQABAQEhAAAA1AAAAP8BAQH/EhIS/yAgIP8ICAj/AAAA/wAAAP8AAAD/AQEB/xkZ + Gf8kJCT/JCQk/yQkJP8lJSX/JSUl/yUlJf8mJib/JiYm/yYmJv8nJyf/Jycn/ygoKP8oKCj/KSkp/xsb + G/8BAQH/AAAA/wAAAP8AAAD/AAAA/xISEv8sLCz/LCws/ywsLP8tLS3/LS0t/y4uLv8uLi7/Li4u/y8v + L/8vLy//MDAw/zAwMP8xMTH/MTEx/zAwMP8ODw//AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEB + AX8AAAAAAAAAAAEBAQAAAAByAAAA/wAAAP8AAAD/FhYW/zk5Of86Ojr/Ojs7/zs7O/87Ozv/PDw8/zw8 + PP89PT3/PT09/z4+Pv8+Pj7/Pj8//z8/P/9AQED/KCgo/wMDA/8AAAD/AAAA/wAAAP8AAAD/AgEC/x0d + Hf9AQED/RUVF/0RFRP9FRUX/RUVF/0ZGRv9GRkb/R0dH/0dHR/9HSEj/SEhI/0hISP9JSUn/SUlJ/0pK + Sv9KSkr/S0tL/0xMTP8vLy//AgIC/wAAAP8AAAD/AAAA/wAAAPUAAAA/AAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAABuAAAA/AAA + AP8GBgb/Ghoa/wYGBv8AAAD/AAAA/wAAAP8DAwP/HR0d/yQkJP8kJCT/JSUl/yUlJf8lJSX/JiYm/yYm + Jv8mJib/Jycn/ycnJ/8oKCj/KCgo/ygoKP8pKSn/Hh4e/wICAv8AAAD/AAAA/wAAAP8AAAD/CwsL/yoq + Kv8sLS3/LS0t/y0tLf8uLi7/Li4u/y4vL/8vLy//Ly8v/zAwMP8wMDD/MTEx/zExMf8yMjL/Kysr/wYG + Bv8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAAnwEBAQEAAAAAAAAAAAAAAFQAAAD8AAAA/wAA + AP8QEBD/OTk5/zs7O/88PDz/PDw8/zw9Pf89PT3/PT09/z09Pf89Pj7/Pj4+/z4/P/8/Pz//Pz8//0BA + QP8/Pz//Gxsb/wAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/xkYGP89PT3/RkZG/0VFRf9GRkb/RkZG/0dH + R/9HR0f/SEhI/0hISP9ISEj/SUlJ/0lJSf9KSkr/SkpK/0tLS/9LTEz/RUVF/xAQEP8AAAD/AAAA/wAA + AP8AAAD/AAAA+wAAAE8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMAAAC9AAAA/wEBAf8MDAz/BAQE/wAAAP8AAAD/AAAA/wUF + Bf8gICD/JSUl/yUlJf8lJSX/JSUl/yYmJv8mJib/JiYm/ycnJ/8nJyf/KCgo/ygoKP8oKCj/KSkp/ykq + Kv8kJCT/BgYG/wAAAP8AAAD/AAAA/wAAAP8BAQH/Gxsb/y0tLf8tLS3/Li4u/y4uLv8uLy//Ly8v/y8v + L/8wMDD/MDAw/zExMf8xMTH/MTEx/zMzM/8jIyP/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAC9AAAACQAAAAAAAAAAAAAAOQAAAPIAAAD/AAAA/wkJCf8tLS3/Ly8v/y4uLv8vLy//MjIy/zY2 + Nv87Ozv/Pj4+/z8/P/8/Pz//Pz8//z8/P/9AQED/QEBA/0FBQf88PDz/FBQU/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/xISEv84ODj/R0dH/0ZGRv9HR0f/R0dH/0dHR/9ISEj/SEhI/0lJSf9JSUn/SkpK/0pK + Sv9LS0v/S0tL/0xMTP8pKSr/AQEB/wAAAP8AAAD/AAAA/wAAAP8AAAD6AAAATgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAA + AEkAAADvAAAA/wEBAf8BAQH/AAAA/wAAAP8AAAD/BwcH/yIiIv8lJSX/JSUl/yUlJf8mJib/JiYm/yYm + Jv8nJyf/Jycn/ygoKP8oKCj/KCgo/ykpKf8pKSn/Kioq/ykpKf8NDQ3/AAAA/wAAAP8AAAD/AAAA/wAA + AP8FBQX/ISEh/y4uLv8uLi7/Li8v/y8vL/8vLy//MDAw/zAwMP8xMTH/MTEx/zEyMv8yMjL/MzMz/xkZ + Gf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAANcAAAAYAAAAAAEBAQUAAABDAAAA6wAA + AP8AAAD/AQEB/wUFBf8EBAT/AwMD/wMEBP8FBQX/CQkJ/xAQEP8dHR3/Li4u/zw8PP9AQED/QEBA/0BA + QP9BQUH/QUFB/0JCQv85OTn/EBAQ/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wsLC/8wMDD/RkZG/0hI + SP9HSEj/SEhI/0hISP9JSUn/SUlJ/0pKSv9KSkr/S0tL/0tLS/9MTEz/Pz8//woKCv8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAPQAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEAAQEBBQAAAJAAAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8ICAj/IyMj/yUlJf8lJSX/JiYm/yYmJv8mJyf/Jycn/ycnJ/8oKCj/KCgo/ygoKP8pKSn/KSkp/yoq + Kv8qKir/Kysr/xwcHP8CAgL/AAAA/wAAAP8AAAD/AAAA/wAAAP8HBwf/IiIi/y8vL/8vLy//Ly8v/zAw + MP8wMDD/MTEx/zExMf8xMTH/MjIy/zIzM/8yMjL/Dw8P/wAAAP8AAAD/AQEB/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA6gAAAEcAAABcAAAArAAAAOQAAAD9AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8DAwP/ERER/yoqKv8+Pj7/QUFB/0FBQf9CQkL/QkJC/0NDQ/84OTj/EBAQ/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wUFBf8lJSX/RERE/0lJSf9ISEj/SUlJ/0lJSf9KSkr/SkpK/0tL + S/9LS0v/TExM/0pKSv8eHh7/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA5wAAACgAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAHgAAAMsAAAD/AAAA/wAAAP8AAAD/AAAA/wkJCf8kJCT/JSYm/yYmJv8mJib/Jicn/ycn + J/8nJyf/KCgo/ygoKP8oKCj/KSkp/ykpKf8qKir/Kioq/yoqKv8rKyv/Kioq/w8PD/8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8GBgb/ICAg/y8vL/8wMDD/MDAw/zExMf8xMTH/MTIy/zIyMv8yMjL/MzMz/y4u + Lv8ICAj/AAAA/wAAAP8AAAD/AAAA/wICAv8DAwP/AAAA/wAAAP8AAAD8AAAA5wAAAPoAAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8BAQH/AAAA/wAAAP8AAAD/AgIC/xgY + GP85OTn/QkJC/0JCQv9DQ0P/Q0ND/0RERP85Ojn/EhIS/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wEB + Af8YGBj/PT09/0pKSv9JSUr/SkpK/0pKSv9LS0v/S0tL/0tMTP9NTU3/MjIy/wMDA/8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAADCAAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATwAAAO8AAAD/AAAA/wAA + AP8AAAD/CQkJ/yQkJP8mJib/JiYm/yYmJv8nJyf/Jycn/ygoKP8oKCj/KCgo/ykpKf8pKSn/KSoq/yoq + Kv8qKir/Kysr/ysrK/8sLCz/JCQk/wcHB/8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8EBAT/Gxsb/y8v + L/8xMTH/MTEx/zEyMv8yMjL/MjIy/zMzM/80NDT/KSkp/wQEBP8AAAD/AAAA/wAAAP8AAAD/BgYG/wsL + C/8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/xAQEP84ODj/Q0ND/0NDQ/9DQ0P/RERE/0VF + Rf89PT3/FhYW/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8NDQ3/MjIz/0lJSf9LS0v/S0tL/0tL + S/9LTEz/TU1N/0JCQv8ODg7/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAIABAQEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAEAAAAhAAAAP0AAAD/AAAA/wAAAP8JCQn/JCQk/yYmJv8mJyb/Jycn/ycn + J/8oKCj/KCgo/ygoKP8pKSn/KSkp/yoqKv8qKir/Kioq/ysrK/8rKyv/LCws/ywsLP8tLS3/ICAg/wUF + Bf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8CAgL/FhYW/y4uLv8yMjL/MjIy/zIyMv8zMzP/MzMz/zU1 + Nf8jIyP/AQEB/wAAAP8AAAD/AAAA/wAAAP8BAQH/AgIC/wAAAP8BAQH/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AgIC/wcHB/8JCQn/CgoK/wcHB/8EBAT/AQEB/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/xMTE/89PT7/RERE/0RERP9ERET/RUVF/0ZGRv9AQED/HR0d/wICAv8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8FBQX/JSUl/0ZGRv9MTEz/TExM/01NTf9KSkr/HR0d/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAADkAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQABAQEaAQEB0wAA + AP8AAAD/AAAA/wcHB/8jIyP/Jycn/ycnJ/8nJyf/KCgo/ygoKP8oKCj/KSkp/ykpKf8pKir/Kioq/yoq + Kv8rKyv/Kysr/ywsLP8sLCz/LCws/y0tLf8tLS3/Hh4e/wUFBf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8BAQH/ERER/ywsLP8zMzP/MzMz/zMzM/80NDT/NTU1/x4eHv8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAPwAAAD/AAAA/wAAAP8PDw//NDQ0/zg4 + OP84ODj/Nzc3/zExMf8lJSX/EhIS/wMDA/8AAAD/AAAA/wAAAP8AAAD/AAAA/yAgIP9DQ0P/REVF/0VF + Rf9FRUX/RkZG/0dHR/9ERET/JSYm/wUFBf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8BAQH/FBQU/zU1 + Nf9FRUX/RUVF/ygoKP8DAwP/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAIkAAAABAQEBAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAC2AAAA/wAAAP8AAAD/BgUF/yIiIv8nJyf/Jycn/ygo + KP8oKCj/KCgo/ykpKf8pKSn/KSoq/yoqKv8qKir/Kysr/ysrK/8sLCz/LCws/ywsLP8tLS3/LS0t/y4u + Lv8uLi7/ISEh/wYGBv8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/DQ0N/ysrK/80NDT/NDQ0/zQ0 + NP81NTX/GRka/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AOcAAACdAAAAfwAAAPYAAAD/AAAA/w0NDf87Ozv/Pz8//z8/P/9AQED/QUFB/0FBQf8+Pj7/Kysr/wsL + C/8AAAD/AAAA/wAAAP8AAAD/BgYG/zU1Nf9GRkb/RUVF/0ZGRv9GRkb/R0dH/0dHR/9HR0f/LzAw/woK + Cv8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AwMD/wwMDP8MDAz/AgIC/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAADFAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAA + AJcAAAD/AAAA/wAAAP8DAwP/HR0d/ygoKP8oKCj/KCgo/ygoKP8pKSn/KSkp/ykqKv8qKir/Kioq/ysr + K/8rKyv/LCws/ywsLP8sLCz/LS0t/y0tLf8uLi7/Li4u/y8vL/8vLy//JCQk/woKCv8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/DAwM/ysrK/81NTX/NTU1/zU1Nf8WFhb/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAPcAAACQAAAALgEBAQIAAAApAAAA6AAAAP8AAAD/CAgI/zY3 + N/8/QED/P0BA/0BAQP9AQED/QUFB/0FCQv9DQ0P/MzQ0/wkKCv8AAAD/AAAA/wAAAP8AAAD/GRkZ/0RE + RP9GRkb/RkZG/0dHR/9HR0f/SEhI/0hISP9JSUn/OTk5/xEREf8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA4AAAADwAAAAAAQEBAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQABAQEAAAAAbwAAAP8AAAD/AAAA/wAAAP8JCQn/IiIi/ygo + KP8oKCj/KSkp/ykpKf8pKir/Kioq/yoqKv8rKyv/Kysr/ywsLP8sLCz/LCws/y0tLf8tLS3/Li4u/y4u + Lv8uLi7/Ly8v/y8vL/8wMDD/KSkp/w8PD/8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/Dg4O/y8v + L/81Njb/NjY2/yEiIv8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA7QAA + ADEAAAAAAAAAAAAAABcAAADVAAAA/wAAAP8EBAT/MjIy/0BAQP9AQED/QEBA/0FBQf9BQUH/QkJC/0JC + Qv9DRET/Kioq/wICAv8AAAD/AAAA/wAAAP8GBgb/Nzg4/0dHR/9HR0f/R0dH/0dISP9ISEj/SEhI/0lJ + Sf9KSkr/QUFB/xscHP8CAgL/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAOoAAABXAAAAAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAABCAAAA9QAAAP8AAAD/AAAA/wAAAP8MDAz/JSUl/ykpKf8pKSn/Kioq/yoqKv8qKir/Kysr/ysr + K/8sLCz/LCws/ywsLP8tLS3/LS0t/y4uLv8uLi7/Li8v/y8vL/8vLy//MDAw/zAwMP8xMTH/LS0t/xQU + FP8BAQH/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/FBQU/zMzM/82Nzf/MjIy/wwMDP8AAAD/AAAA/wAA + AP8AAAD/AgIC/wsLC/8HBwf/AAAA/wAAAP8AAAD5AAAASwAAAAAAAAAAAAAACQAAAL4AAAD/AAAA/wEB + Af8sLCz/QUFB/0BAQP9BQUH/QUFB/0JCQv9CQkL/Q0ND/0NDQ/9AQED/FBQU/wAAAP8AAAD/AAAA/wAA + AP8iIiL/R0dH/0dHR/9ISEj/SEhI/0hJSf9JSUn/SUlJ/0pKSv9LS0v/R0dH/ycnJ/8FBQb/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAADgAAAAVAAAAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAADSAAAA/wAAAP8AAAD/AAAA/wAA + AP8PDw//JiYm/yoqKv8qKir/Kioq/ysrK/8rKyv/Kyws/ywsLP8sLCz/LS0t/y0tLf8uLi7/Li4u/y4v + L/8vLy//Ly8v/zAwMP8wMDD/MTEx/zExMf8yMjL/MDAw/xkZGf8CAgL/AAAA/wAAAP8AAAD/AAAA/wAA + AP8BAQH/ICAg/zc3N/83Nzf/Li4u/xsaGv8LCwv/CwsL/xQUFP8mJib/NTU1/xYWFv8AAAD/AAAA/wAA + AP8AAABrAAAAAAEBAQAAAAABAAAAogAAAP8AAAD/AAAA/yUlJf9BQUH/QUFB/0FBQf9CQkL/QkJC/0ND + Q/9DQ0P/Q0RE/0VFRf8uLi7/AgIC/wAAAP8AAAD/AAAA/w8PD/9CQkL/SEhI/0hISP9ISEj/SUlJ/0lJ + Sf9KSkr/SkpK/0tLS/9LS0z/S0tL/zc3N/8UFBT/AgIC/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD2AAAArwAAADgBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAG8AAAD5AAAA/wAAAP8AAAD/AAAA/wAAAP8QEBD/Jycn/ysrK/8rKyv/Kysr/yws + LP8sLCz/LCws/y0tLf8tLS3/Li4u/y4uLv8uLi7/Ly8v/y8vL/8wMDD/MDAw/zExMf8xMTH/MTEx/zIy + Mv8zMzP/MjIy/xwcHP8CAgL/AAAA/wAAAP8AAAD/AAAA/wAAAP8KCgr/MDAw/zg4OP84ODj/ODg4/zQ0 + Nf81NTX/OTk5/zs7O/88PDz/Hh4e/wAAAP8AAAD/AAAA/wAAAIsAAAAAAQEBAAAAAAAAAACEAAAA/wAA + AP8AAAD/HR0d/0FBQf9BQUH/QkJC/0JCQv9DQ0P/Q0ND/0NERP9ERET/RUVF/0BAQP8ODg7/AAAA/wAA + AP8AAAD/BAQE/zY2Nv9JSUn/SElJ/0lJSf9JSUn/SkpK/0pKSv9LS0v/S0tL/0tMTP9MTEz/Tk5O/0VF + Rf8SEhL/AAAA/wAAAP0AAADvAAAA6wAAAOYAAADOAAAAlwAAAE8AAAAMAAAAAAEBAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAJwAAAD7AAAA/wAA + AP8AAAD/AAAA/wEBAf8QEBD/Jycn/ywsLP8sLCz/LCws/ywsLP8tLS3/LS0t/y4uLv8uLi7/Li8v/y8v + L/8vLy//MDAw/zAwMP8xMTH/MTEx/zExMf8yMjL/MjIy/zMzM/8zNDT/MzMz/xoaGv8BAQH/AAAA/wAA + AP8AAAD/AAAA/wAAAP8dHR3/ODg4/zg4OP85OTn/OTk5/zo6Ov86Ojr/Ojo6/zw8PP8mJib/AQEB/wAA + AP8AAAD/AAAAqwEBAQMBAQEAAAAAAAAAAGUAAAD/AAAA/wAAAP8WFhb/QEFB/0JCQv9CQkL/Q0ND/0ND + Q/9DRET/RERE/0RERP9FRUX/RkZG/yEhIv8AAAD/AAAA/wAAAP8AAAD/JiYm/0lJSf9JSUn/SUlJ/0pK + Sv9KSkr/S0tL/0tLS/9LTEz/TExM/01NTf9KSkr/JiYm/wMDA/8AAAD/AAAAsgAAADcAAAAsAQEBJgEB + ARMAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAGgAAADNAAAA8AAAAPwAAAD/AAAA/wAAAP8PDw7/Jycn/y0t + Lf8sLCz/LS0t/y0tLf8uLi7/Li4u/y4uLv8vLy//Ly8v/zAwMP8wMDD/MTEx/zExMf8xMTH/MjIy/zIy + Mv8zMzP/MzMz/zQ0NP80NDT/MjIy/xISEv8AAAD/AAAA/wAAAP8AAAD/AAAA/w4ODv82Njb/OTk5/zk5 + Of85Ojr/Ojo6/zo6Ov87Ozv/PDw8/y0tLf8DAwP/AAAA/wAAAP8AAADHAAAADgAAAAAAAAAAAAAASQAA + APgAAAD/AAAA/w8PD/8+Pz//QkJC/0NDQ/9DQ0P/RERE/0RERP9ERET/RUVF/0VFRf9HR0f/MzMz/wMD + A/8AAAD/AAAA/wAAAP8XFxf/R0hI/0lJSf9KSkr/SkpK/0tLS/9LS0v/S0xM/0xMTP9NTU3/SUlJ/yMj + I/8CAgL/AAAA/wAAALoAAAAfAAAAAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEAAgICAQEB + ARUBAQE2AQEBVwAAAGIAAACgAAAA+gAAAP8MDAz/JSUl/y0tLf8tLS3/Li4u/y4uLv8uLy//Ly8v/y8v + L/8wMDD/MDAw/zExMf8xMTH/MTIy/zIyMv8yMjL/MzMz/zMzM/80NDT/NDQ0/zQ1Nf82Njb/Kioq/wUF + Bf8AAAD/AAAA/wAAAP8AAAD/BQUF/y8vL/86Ojr/Ojo6/zo6Ov86Ojr/Ozs7/zs7O/88PDz/MzMz/wYG + Bv8AAAD/AAAA/wAAAN8AAAAfAAAAAAAAAAAAAAAwAAAA7QAAAP8AAAD/CgoK/zs7O/9DQ0P/Q0ND/0NE + RP9ERET/RERE/0VFRf9FRUX/RkZG/0dHR/9AQED/CwsL/wAAAP8AAAD/AAAA/wwMDP9DQ0P/SkpK/0pK + Sv9LS0v/S0tL/0tMTP9MTEz/TU1N/0ZGRv8eHh7/AQEB/wAAAP8AAAC7AQEBIwAAAAABAQEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAACGAAAA9QAA + AP8JCQn/IiIi/y4uLv8uLi7/Ly8v/y8vL/8vLy//MDAw/zAwMP8xMTH/MTEx/zEyMv8yMjL/MjIy/zMz + M/8zMzP/NDQ0/zQ0NP80NTX/NTU1/zY2Nv81NTX/ERER/wAAAP8AAAD/AAAA/wAAAP8BAQH/JSUl/zo7 + O/86Ojr/Ojo6/zs7O/87Ozv/PDw8/zw9Pf84ODj/CwsL/wAAAP8AAAD/AAAA8AAAADUAAAAAAAAAAAEB + ARwAAADbAAAA/wAAAP8FBQX/NjY2/0RERP9ERET/RERE/0RERP9FRUX/RUVF/0ZGRv9GRkb/R0dH/0ZG + Rv8XFxf/AAAA/wAAAP8AAAD/BgYG/zw8PP9LS0v/S0tL/0tLS/9LTEz/TExM/01NTf9BQUH/FxcX/wEB + Af8AAAD/AAAAtwAAACEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcAAABtAAAA7AAAAP8FBQX/HBwc/y4uLv8vLy//Ly8v/zAw + MP8wMDD/MTEx/zExMf8yMjL/MjIy/zIyMv8zMzP/MzMz/zQ0NP80NDT/NTU1/zU1Nf81Njb/NjY2/zc3 + N/8aGhr/AAAA/wAAAP8AAAD/AAAA/wAAAP8kJCT/Ozs7/zo7O/87Ozv/Ozs7/zw8PP88PDz/PT09/zw8 + PP8SEhL/AAAA/wAAAP8AAAD7AAAAUQAAAAAAAAAAAQEBDQAAAMUAAAD/AAAA/wICAv8wMDD/RUVF/0RE + RP9ERET/RUVF/0VFRf9GRkb/RkZG/0dHR/9HR0f/SEhI/yMjI/8AAAD/AAAA/wAAAP8CAgL/NTU1/0xM + TP9LS0v/S0xM/0xMTP9NTU3/OTk5/w8PD/8AAAD/AAAA/QAAAKwAAAAdAAAAAAAAAAAAAAAAAAAAAgAA + AAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAEB + AQIAAABRAAAA2QAAAP8CAgL/FRQV/ysrK/8wMDD/MDAw/zExMf8xMTH/MTIy/zIyMv8yMjL/MzMz/zMz + M/80NDT/NDQ0/zU1Nf81NTX/NTU1/zY2Nv82Njb/Nzc4/xoaGv8AAAD/AAAA/wAAAP8AAAD/AQEB/yYl + Jv87Ozv/Ozs7/zs7O/88PDz/PDw8/z09Pf89PT3/Pj4+/xkZGf8AAAD/AAAA/wAAAP8AAABxAAAAAAAA + AAAAAAADAAAAqgAAAP8AAAD/AAAA/ykpKf9FRUX/RERE/0VFRf9FRUX/RkZG/0ZGRv9HR0f/R0dH/0dI + SP9JSUn/LCws/wAAAP8AAAD/AAAA/wEBAf8vLy//TExM/0tMTP9NTU3/SkpK/ywsLP8ICAj/AAAA/wAA + APoAAACZAAAAFAAAAAABAQEAAAAAAAAAAAAAAAAfAAAAUQAAAAABAQEAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAAAxAQEBvAAAAP4AAAD/DAwM/yQk + JP8xMTH/MTEx/zExMf8yMjL/MjIy/zMzM/8zMzP/NDQ0/zQ0NP81NTX/NTU1/zU2Nv82Njb/NjY2/zc3 + N/82Njb/EhIS/wAAAP8AAAD/AAAA/wAAAP8BAQH/Jycn/zw8PP87Ozv/PDw8/zw8PP89PT3/PT09/z4+ + Pv8/Pz//IiIi/wAAAP8AAAD/AAAA/wAAAJIBAQEAAAAAAAAAAAAAAACMAAAA/wAAAP8AAAD/ISEh/0VF + Rf9FRUX/RUVF/0ZGRv9GRkb/R0dH/0dHR/9HSEj/SEhI/0pKSv8yMjL/AgIC/wAAAP8AAAD/AAAA/y0t + Lf9NTU3/TU1N/0FBQf8cHR3/AgIC/wAAAP8AAADyAAAAgAEBAQ0AAAAAAAAAAAAAAAABAQEAAQEBBAAA + AIAAAABQAAAAAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAQEBAAAAAAAAAAAYAAAAjgAAAPMAAAD/BAQE/xkZGf8tLi7/MzMz/zIzM/8zMzP/MzMz/zQ0 + NP80NDT/NDU1/zU1Nf81NTX/NjY2/zY2Nv83Nzf/ODg4/zAwMP8HBwf/AAAA/wAAAP8AAAD/AAAA/wQE + BP8vLy//PDw8/zw8PP88PDz/PT09/z09Pf8+Pj7/Pj4+/0BAQP8qKir/AQEB/wAAAP8AAAD/AAAAsQEB + AQUBAQEAAAAAAAAAAG4AAAD/AAAA/wAAAP8ZGRn/RUVF/0VFRf9GRkb/RkZG/0dHR/9HR0f/SEhI/0hI + SP9ISUn/SkpK/ykpKf8AAAD/AAAA/wAAAP8BAQH/MTAx/0tLS/8xMTH/DQ0N/wAAAP8AAAD/AAAA4gAA + AF0AAAAFAAAAAAAAAAAAAAAAAAAAAAEBAQAAAABcAAAArwAAABIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAWQAA + ANcAAAD/AQEB/wwMDP8jIyP/MjIy/zQ0NP80NDT/NDQ0/zU1Nf81NTX/NTU1/zY2Nv82Njb/Nzc3/zc3 + N/85OTn/IiIi/wEBAf8AAAD/AAAA/wAAAP8AAAD/Dg4O/zg4OP88PDz/PDw8/z09Pf89PT3/Pj4+/z4+ + Pv8+Pz//QEBA/zExMf8EBAT/AAAA/wAAAP8AAADMAAAAEQAAAAAAAAAAAAAAUAAAAPsAAAD/AAAA/xIS + Ev9DQ0P/RkZG/0ZGRv9HR0f/R0dH/0hISP9ISEj/SEhI/0lJSf9CQkL/Dg4O/wAAAP8AAAD/AAAA/wUF + Bf8sLCz/HBwc/wMDA/8AAAD/AAAA/gAAAMMAAAA7AAAAAAAAAAAAAAAAAAAAAAEBAQAAAAAAAAAAPgAA + ANIAAABOAAAAAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQABAQEAAAAAJwAAAJ8AAAD1AAAA/wMDA/8UFBT/KSkp/zQ0 + NP81NTX/NTU1/zU1Nf82Njb/NjY2/zc3N/83Nzf/ODg4/zU1Nf8PDw//AAAA/wAAAP8AAAD/AAAA/wAA + AP8dHR3/PDw8/zw8PP89PT3/PT09/z4+Pv8+Pj7/Pj8//z8/P/9AQED/Nzc3/wgICP8AAAD/AAAA/wAA + AOIAAAAiAAAAAAAAAAAAAAA2AAAA8AAAAP8AAAD/DAwM/0BAQP9HR0f/R0dH/0dHR/9ISEj/SEhI/0hI + SP9JSUn/SkpK/yssLP8BAQH/AAAA/wAAAP8AAAD/AwMD/wYGBv8AAAD/AAAA/wAAAPUAAACVAAAAGwAA + AAAAAAAAAAAAAAAAAAABAQEAAQEBAAEBAS8AAADRAAAAkwAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAACQAAAFoAAADPAAAA/gAAAP8FBQX/GBgY/ywsLP81NTX/Nzc3/zY2Nv83Nzf/Nzc3/zg4 + OP85OTn/JCQk/wICAv8AAAD/AAAA/wAAAP8AAAD/BAQE/y4uLv89PT3/PT09/z09Pf8+Pj7/Pj4+/z4/ + P/8/Pz//Pz8//0BAQP88PDz/DQ0N/wAAAP8AAAD/AAAA8gAAADoAAAAAAAAAAAAAACEAAADhAAAA/wAA + AP8HBwf/Ozs7/0dHR/9HR0f/R0hI/0hISP9ISEj/SUlJ/0lKSv9GRkf/ExMU/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAADWAAAAWwEBAQcBAQEAAAAAAAAAAAAAAAAAAQEBAAAAAAAAAAArAAAAyQAA + AMcAAAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgICAAEBAR0AAACFAAAA5wAA + AP8AAAD/BgYG/xgYGP8sLCz/NjY2/zg4OP84ODj/OTk5/y8vL/8KCgr/AAAA/wAAAP8AAAD/AAAA/wAA + AP8ZGBn/Ozs7/z09Pf89PT3/Pj4+/z4+Pv8/Pz//Pz8//z8/P/9AQED/QEBA/0BAQP8UFBT/AAAA/wAA + AP8AAAD8AAAAVwAAAAAAAAAAAAAAEAAAAMwAAAD/AAAA/wMDA/81NTX/SEhI/0dISP9ISEj/SEhI/0lJ + Sf9KSkr/TExM/zs7O/8FBQX/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAADzAAAAnQAAACYAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBAQAAAAAAAAAALQAAAMgAAADjAAAAPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAQEBAAEBAQMAAAA1AAAAnwAAAO8AAAD/AAAA/wUFBf8UFBT/Jycn/zU1 + Nf8xMTH/EBAQ/wAAAP8AAAD/AAAA/wAAAP8AAAD/CgoK/zMzM/89PT3/PT09/z4+Pv8+Pj7/Pz8//z8/ + P/8/Pz//QEBA/0BAQP9BQUH/QkJC/xwcHP8AAAD/AAAA/wAAAP8AAAB3AAAAAAAAAAAAAAAFAAAAsgAA + AP8AAAD/AQEB/y4uLv9JSUn/SEhI/0lJSf9KSkr/SkpK/0VFRf83Nzf/GBgY/wAAAP8AAAD/AAAA/wAA + AP8AAAD8AAAAxgAAAFEAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBAAAAADoAAADOAAAA8gAA + AFwBAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAGAAAAQwAAAKkAAADwAAAA/wAAAP8CAgL/DQ0N/wsLC/8AAAD/AAAA/wAAAP8AAAD/AAAA/wQE + BP8pKSn/PT09/z09Pf8+Pj7/Pj4+/z4/P/8/Pz//P0BA/0BAQP9AQED/QUFB/0FBQf9DQ0P/JSUl/wAA + AP8AAAD/AAAA/wAAAJcCAgIAAAAAAAAAAAAAAACVAAAA/wAAAP8AAAD/JiYm/0pKSv9ISEj/Q0ND/zc3 + N/8lJSX/ERER/wMEA/8AAAD/AAAA/wAAAP8AAAD/AAAA4QAAAHUAAAAXAAAAAAEBAQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBAQIAAABOAAAA3AAAAPcAAAB1AQEBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAgAAAAAAAAAABwEBAT4AAACiAAAA8wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8DAgP/IiIi/z09Pf8+Pj7/Pj4+/z4/P/8/Pz//Pz8//z8/ + P/9AQED/QEBA/0FBQf9BQUH/QkJC/0NDQ/8uLi7/AQEB/wAAAP8AAAD/AAAAtgEBAQcAAAAAAAAAAAAA + AHcAAAD/AAAA/wAAAP8WFhb/LCws/xwdHf8ODg7/BAQE/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAABvAAAAAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAAAAeAAAAO0AAAD6AAAAgQEB + AQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAQEBAAEBAQEAAAAQAAAAOgAAAI8AAADvAAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wMD + A/8TExP/Hx8g/yoqK/8zMzP/OTk5/z09Pf8/Pz//QEBA/0FBQf9CQkL/QkJC/0NDQ/9DQ0P/REVF/zY2 + Nv8FBQX/AAAA/wAAAP8AAADRAAAAFAAAAAAAAAAAAAAAWQAAAP0AAAD/AAAA/wEBAf8BAQH/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD9AAAA/AAAAP8AAAD/AAAA+AAAAEYAAAAAAAAAAAAAAAAAAAAAAAAAAAEB + AQABAQEBAQEBMgAAAKsAAAD7AAAA9wAAAIMAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQAAAAADAwMAAAAAAAAA + AAAAAAAAAAAAAAAAAAABAQEAAAAAAAEBAQMBAQEJAAAAFQAAACsBAQFUAAAAjQAAAMgAAADyAAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/gAAAP4AAAD/AAAA/wAAAP8AAAD/AgIC/wUFBf8KCgr/EBAQ/xYW + Fv8cHBz/ICAg/yQkJP8mJib/Jicn/yYnJ/8kJCT/HBwc/wQEBP8AAAD/AAAA/wAAAOYAAAAnAAAAAAAA + AAAAAAA9AAAA9AAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD2AAAAxAAAAG8AAAC4AAAA/wAA + AP8AAAD4AAAASgAAAAAAAAAAAAAAAAAAAAAAAAABAQEBHwAAAHwAAADjAAAA/wAAAPIAAAB1AAAABwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAA4AAABLAAAAcAAAAHwAAAB/AQEBfwAAAIAAAACCAAAAiAAAAJAAAACcAAAAqwAA + AL4AAADTAAAA6QAAAPoAAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA+gAAANEBAQF5AAAAbAAA + ALAAAADjAAAA+wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA9AAAAD8AAAAAAAAAAAAAACYAAADmAAAA/wAAAP8AAAD/AQEB/wAA + APoAAADZAQEBlgAAAEkAAAAQAAAAAAAAAHUAAAD/AAAA/wAAAP8AAACoAAAALQEBARoAAAAhAAAARAAA + AIoBAQHaAAAA/QAAAP8AAADfAAAAXQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEBARMAAAA3AAAAYwAA + AI4AAACzAAAA0QAAAOYAAAD1AAAA/QAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/gAA + APkAAADrAAAAzwAAAJ0AAABYAAAAGQEBAQABAQEAAQEBBwAAACUAAABWAAAAkQAAAMQAAADlAAAA+QAA + AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD+AAAAXQAA + AAAAAAAAAAAAFAAAANIAAAD/AAAA8gAAANAAAACWAAAAVQEBAR0BAQECAQEBAAAAAAAAAAAAAAAAKwAA + AN8AAAD/AAAA/wAAAP0AAADqAAAA2gAAAOEAAAD2AAAA/wAAAP8AAAD8AAAAuwEBATYBAQEAAQEBAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQUAAAARAAAAIwAAADcAAABMAAAAYAAA + AHMAAACBAAAAjAAAAJEAAACPAAAAhgAAAHcAAABjAAAASwAAAC4AAAATAQEBAgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEBAQAAAAABAQEBDQAAACcAAABNAAAAdgAAAJsAAAC9AAAA1QAAAOUAAADxAAAA+AAA + APwAAAD+AAAA/wAAAP8AAAD/AAAA/gAAAP4AAAB5AAAAAAAAAAAAAAAHAAAAcgAAAG4AAAA7AAAAFQAA + AAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgIAAAAAZgAAAPEAAAD/AAAA/wAAAP8AAAD/AAAA/wAA + AP8AAAD+AAAA2QAAAG8BAQEUAQEBAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAQAAAAkAAAAWAAAAJgAAADgAAABHAAAAUwAAAF8AAABkAAAAZQAAAGUAAABdAAAAUgAA + ACgBAQEAAAAAAAEBAQACAgIABgYGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAFAAAAVQAAAMIAAADvAAAA9wAAAPMAAADoAAAAugEBAXIBAQEjAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAAAAAAAAAAEAAAADUAAABDAAAAOwAA + ACoAAAAKAAAAAAEBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////// + ///////gf//////////////////5gAB/////////////////gYAAB////////////////ACAAAD///// + //////////AAwAAAH/////////////+AAMAAAAP////////////+AADAAAAA/////////////AAAwAAA + AAB///////////AAAMAAAAAAH/////////wAAADAAAAAAAf////////4AAAAwAAAAAAD////////8AAA + AGAAAAAAAf///////+AAAABgAAAAAAD////////gAAAAYAAAAAAAf///////4AAAAGAAAAAAAD////// + /8AAAABgAAAAAAA///////+AAAAAYAAAAAAAH///////AAAAAGAAAAAAAA///////gAAAABwAAAAAAAP + //////wAAAAAMAAAAAAAB//////4AAAAADAAAAAAAAf/////8AAAAAAwAAAAAAAH/////+AAAAAAMAAA + AAAAA//////AAAAAADAAAAAAAAP/////gAAAAAAwAAAAAAAB/////4AAAAAAOAAAAAAAAP////8AAAAA + ADgAAAAAAAB////+AAAAAAAQAAAAAAAAP////AAAAAAAAAAAAAAAAD////wAAAAAAAAAAAAAAAAf///4 + AAAAAAAAAAAAAAAAD///8AAAAAAAAAAAAAAAAAf///AAAAAAAAAAAAAAAAAH///gAAAAAAAEAAAAAAAA + A///4AAAAAAAHAAAAAAAAAP//8AAAAAAAAwAAAAAAAAB///AAAAAAAAMAAAAAAAAAf//gAAAAAAADAAA + AAAAAAD//4AAAAAAAAwAAAAAAAAA//8AAAAAAAAMAAAAAAAAAH//AAAAAAAACAAAAAAAAAB//gAAAAAA + AAgAAAAAAAAAP/4AAAAAAAAIAAAAAAAAAD/+AAAAAAAAAAAAAAAAAAAf/AAAAAAAAAAAAAAAAAAAH+AA + AAAAAAAAAAAAAAAAAB+AAAAAAAAAAAAAAAAAAAAPgAAAAAAAAAAAAAAAAAAADwAAAAAAAAAAAAAAAAAA + AA8AAAAAAAAAAAAAAAAAAAAHAAAAAAAAAIAAAAAAAAAABwAAAAAAAAEAAAAAAAAAAAeAAAAAAAADAAAA + AAAAAAAHwAAAAAAABwAAAAAAAAAA/+AAAAAAAAAAAAAAAAAA/+fgAAAAAAAAAAAAAAAA//AH4AAAAAAA + AAAAPAAAf/wAB+AAAAAAAAAAAD4Af/4AAAfgAAAAAAAAAAAeP/8AAAAD4AAAAAAAAAAAH/+AAAAAA+AA + AAAAAAAAAB/gAAAAAAPgAAAAAAAAAAAeAAAAAAAH4AAAAAAAAAAAHgAAAAAAB+AAAAAAAAAAAAwAAAAA + AAfAAAAAAD+AAAAAAAAAAAAH4AAADwB4OAAAAAAAAAAAB+AAB/8AADgAAAAAAAAAAAfgA//8AAA8AAAA + AAAAAAAD4//8AAAAEAAAAAAAAAAAAf/+AAAAAAAAAAAAAAAAAAH/AAAAAAAAAAAAAAAAAAAB4AAAAAAA + AAAAAAAAAAAAA+AAAAAAAAAAAAAAAAAAAAfwAAAAAAAAAAAAAAAAAAAP8AAAAAAAAAAAAAAAAAAAH/AA + AAAAAAAAAAAAAAAAAB/wAAAAAAAAAAAAAAAAAAAf+AAAAAAAAAAAAAAAAAAAH/gAAAAAAAAAAAAAAAAA + AD/4AAAAAAAAABAAAAAAAAA//AAAAAAAAAAQAAAAAAAAf/wAAAAAAAAAMAAAAAAAAH/+AAAAAAAAADAA + AAAAAAB//gAAAAAAAAAwAAAAAAAA//8AAAAAAAAAMAAAAAAAAP//AAAAAAAAADAAAAAAAAB//4AAAAAA + AAA4AAAAAAAAf/+AAAAAAAAAOAAAAAAAAH//wAAAAAAAABgAAAAAAAB//8AAAAAAAAAYAAAAAAAAf//g + AAAAAAAAEAAAAAAAAH//4AAAAAAAAAAAAAAAAAB///AAAAAAAAAAAAAAAAAAf//4AAAAAAAAAAAAAAAA + AP//+AAAAAAAAAAAAAAAAAD///wAAAAAAAAAAAAAAAAA///8AAAAAAAAAAAAAAAAAf///gAAAAAAAAAA + AAAAAAP///4AAAAAAAAMAAAAAAAH///+AAAAAAAADAAAAAAAB////gAAAAAAAAwAAAAAAB////8AAAAA + AAAOAAAAAAA/////AAAAAAAABgAAAAAA/////4AAAAAAAAYAAAAAH//////AAAAAAAAGAAAAAD////// + /gAAAAAABgAAAAB///////8AAAAAAAYAAAAA5///////gAAAAAAGAAAAAef//////+AAAAAABwAAAAPH + ///////wAAAAAAMAAAAHx///////+AAAAAADAAAAH4////////4AAAAAAwAAAD8P////////AAAAAAMA + AAB+H////////8AAAAADAAAB/D/////////gAAAAAwAAA/h/////////+AAAAAOAAA/gf/////////4A + AAABgAA/wP/////////8AAAAAYAAPwH///////z/gAAAAAGAADwD///////8AAAAAAABgAgAB/////// + /AAAAYAAAYA4AB/////////gAAfwAAGB/AA//////////////4AB//wA////////////////////A/// + /////////////////////////////////////////////4lQTkcNChoKAAAADUlIRFIAAAEAAAABAAgG + AAAAXHKoZgAAgABJREFUeNrt/XmYZNlV2Iv+1ok5cs6szKrMGrqrunpQd6vVQgIhCRBikJixsY19zcPm + 2ozmIQP2wwZjG3w9ADZcD2CMLV8Gg7GZBFwhJAZJSGIQElK3plZP1V1dlZVZOU+RMcd6f+yzI06c2GeI + yKyuqlat78uvKs7ZZ8977TUvuAN34A7cgTtwB+7AHbgDd+AO3IE7cAfuwB24A3fgDrykQW52B+7AHRgV + RATAU9VZ4D4ReVRVx4FDETlU1UOgAjzr/9Vvdp9vNbiDAD5DIZfL0W63RVU9IKOq4h8oUdVuORFp+38d + gHa7fbO73u1/q9U6rap/C/grwD3AFL09rSLSUdW2iKyr6p8D7xKR96nqJaAuIgTH+pkIdxDASwz8TZ0B + isAYMAnMAfPASWAGGPefT/h/Y0DG/94iAAEUqIrIgaoeAPvABvCLwMpNHKYHfC3wT/xbP5NiThCRNrCq + qn8mIr8I/B5w+JmMBD5jEUA2m8XzPJrNZkZVcyJSUNWiiBRVtSAiJSDvb66MiLRVtQk0MIeiqqo1Eamp + al1EWsCLfaN4wLiIzKnqEnAeuOj/ncYc/GkRmVDVEpAnsOYj3oDXgC8Bngg+9KkHgFdikMtTwIaqNj3P + o9PpHHmwAZL/bwA/gUFoqccRQAQAB6r6duA/isiHgNZnIiJ4ySIAEcHfeFlVLYvINHBCVRdEZBE4paon + gQVgRkSmVXUCKAEFHyFkMIfMAzr+XxPDS9aAA2AH2ASWgavAJf/vGrAlIkfeWPZw+Yd4AXPAHwZegeF9 + T/t8cPcmd9VhN7/tj+vgpDhMj4vIlwLrjnIC/Gfgb4nI88AnVfXDwEdE5NOqugq0jjIPqvplwM8Cp6LG + OCRc96mBn1HVp0ft2+0KLyUEICIyrqoLwFkRuQdzUM6r6lnMbTENjIlI3ud97YeE+N6j3ORNYBeDAD4u + In8GfEhVP7WwsLC/vr6eqm4feRWBs5iD/tki8ghwr6qeAsqMuH7DjM9R9ndF5OuAmqOOIvDrwFeE6jgE + XlDVDwHvFZE/BZ4vl8vVSqUyTNfngP8NfHHa/gYok7gxq4h8GviXwK8Bjc8UauC2RACWFARmVPVeDNn5 + SuBlwN3AnE/Kj3xAYHhyPuJgKbANPAa8C3iniDwBNB1lMyKyoKoPAZ/r/z0MLGLI92ObP9fNHx5zxHj+ + C/AdEVWfwPDVr4ypuw2sYiiJ96rqe0TkU6Tjxb8V+EkgFzO2KrCjqgcisoth405jkH/GUT5IEe0BP62q + P+4LDo9rym9ZuC0RAOaQf42IvEFV78HwnBkMid7CHDoN8IwehkLIYiTeGcwmygHZwN+Nng8FVkTk7cAv + AB8G2v4G/RzgS0Tk9ap6N4acB6Jv7KNQKqNQPX6Zfwz8aAQSuaiq78ZQYGmQjAKbIvJB4O2q+h4M+9R0 + NF/C3M5fgRsUeDfwn4AnReQAowLMqeoZ4AHgFSLyhar6CgybN8AWAW0ReRfwA5lM5vFWa2SO5baA2xUB + LPh/bcxmsYfe8unBzSb4fLyIZICsqmYBK/ArYRDIFEYWMO/LBk4BS/6NPIMhb0cGx4HbVNXfxwgVXwvc + RcQtH0XW3qgbKgYZtIBvBP5XxKevB97hz2dk3a6++0LWZeB9wG8Df5TJZNYCwsOHVfVdwFJE1Y9j1IHP + JoxtXlW/CPibIvIFqjod0ccnVfUHgN/E31MvRbhdEcANA8/zLNIoqOqEiJxQ1btF5JXAq4BHfJlCIcxf + xt2iaQ/tEKS481vP8/r+MpmM+b94fastAqpGr9/pdOh0OrTbbZrNZlxbe5gb+I8j2v9rqvo/MdTUUSiX + OvBxjDzht4FPAX8N6NbtgH8LfF9aSgYoq+qrgb8D/GV8pBX6fl1EfkBVfx43VXLbQ/boVby0wL9xFCPl + r6nqus+z/y7mhl70dc9foKqfh5E7TEDyoU17Y8d9Zw91LpejUChQKBTI5/MU8nnyhQK5XI5sNts7+P6f + iJjz7yMYiwBUlU6ng6pSOTjgk098imYjcq/vAtdj+n2WwJ6K0jYEVHFRWoiCiLxaVV8F/D0RebtPqWXD + ZQN1Xk67xn6bhxhq48+Bt4nIP8RQYplA/fOq+u8w1OFP8hK0JLyDAFJAYJM2gMv+329jjGpeAXwp8Cbg + IXxWIbz5096EYSRiD3q5XKZcLlMqlSgWi+Tzef+ge4h4fYc7CiT0PvjbE6FWrdJpd+K+vw5shfsZgLuS + xhccp3SRUa9c6F/BaEG+w7fqi1sb5+8kEJEa8FvAn6nq3wW+3W/T1jUF/AsMhfBjGLnCSwbuIIDRQTGH + 4T3Ae0Tkx33e8h8Ar+kWGoFPLxQKLCwsMD4+TqlUolAo+IZLgotrU1UUENUBJDDAppiHfX0TEWPyV6t1 + DXZcN7SqXsPYPrjasMI2Z/+inosDaYWFc/73XkK9C6MIRQPlrwP/RkR+T1X/hYi8KWBhWAb+EUYw+8Mi + sv9S0RDcQQBHBLv5gbtE5DW+jj7td07odDqUy2Xm5+eB3ibtdHTgkvfN9005UzhUtxJEGq4ytv5arTZw + E4fgeaDhIukxh6NPQBdmXRYXFxER9vb2qFartFqtWEOktHIPv+x9vnD3KGJ7xWhm/jbwDzHqzgn/XQF4 + C8Zi8IeB6hHauWXgDgIYEfyNl8cIBr8J+Bp7+MV1w0aQqq6yzWaTS5cuISJdJBD8ThJI/X4eG2DwG3Ug + gWo1cU/H8dlTGM2Mc8yZTIazZ88yMz1No9nk8PCQ/f19dnd32dnZ4fDwkHa7HXvoE1imRzD2EldGWc/Q + vKwD/1REPqaqP4QxKAOD6P8+hg34MV4CMoHM0av4jIQC8DrgnwL/HPgCjE1+rOTbBVHlO50O+/v7jI+P + UyyGNJACgsTWH6QM4vpgn3U6Ha5duxaHBJrAWwn5ANg6RORe4Fsw+vrBCSsUOHfuHPl8noyXoVgqMj09 + zcL8PCdPnWJubpZSyXxqNRNx4BjLDMYj8DrGCvOobottjCbiT/AtSv3nWYzNRkVEPmS9JG9XuIMAhgDf + kOhzgB8C/hkGCfQZ7ATB8zzK5TILCwvMzMxQq1a77rRxyMJCu92mWq0yPT1NNpt19Sf0G4KHPh1SMM+a + zSZXr16l2YzUAOwDP43xeXDBq4BvIKACDLZfLpc5c+YMmUxwyxmZRTabZWxsnBMnTnDq1Cnm5uYoFot0 + Om2azdaAYDQCPIyxz9dgDMUui8h6ErWUAlaA92Kcqx7w28ljrDTXROSjx9DGTYM7CCAB/I3sYdR934+x + F/88jGDICblcjpmZGc6cPs3p06eZnZ1lYmKCUqnEwcEBrVYrtW6/Xq/TbreZnp7G8wbkYCMigcEy1WqV + a9euDfj7B76/hnH02XHMD8AXi8jXRvVtcnKSpaWlxDFkMhnK5TJzc3OcPHmKmZkZstkszWbTKTNwQAmD + jL5MRLK+g8/hUQ6piOyKyHtFZBx4FHNuir7M5wngtnUiuoMAIkBEmJ6epl6v362q3w38KPBl+KS+q3yx + WGR+fp4zZ85w8uRJxsbH+za8lejv7+8PFVijWq1SKBQYHx9H0T7yf1hS3/VMRNjf3+f69etx7MuTwH/H + 2Ef0vfO/+asi8nlRB21ubo6FhQVnX5zyCSCTzTI+Ps7CwgLz8/McHBxweHiYOC4fZoAvwmhk1jHyi6Ow + BYfA+3y3788G8j5CeAWGTVi9HSmBOwggBIFDMVmv179BVf89xgptJlzG/n9sbIxTp05x5swZ5ubmKBQK + /tt+CTwYUjiTybC7uzuUYVC9XmdmZoZcNncEJNBfLogAdnZ22NjYiOvGnwG/jNssNgP8n8DLo9o+efIk + s7OzCf2LolagWCzSaDRYX19P/C4AHoZ3/yrgjIg8jfE9SDXvjnYawJ/6fgavw1iDLmBkD3+IYZNuK7iD + AALgb4ysiHwe8G9V9S0Y3m9gx3iex9jYGEtLS5w5cyaSTw/U2/1/uVym2WwS5wprSWv712g0yGQyTE1N + OetN83uwLwCCCKytrbOzsxN3mH4XeGfEuzHg2zC8d1//7f+XlpaYnBx0EQjPzeB7+qb/+vXrkdRTTN+L + wKsxFMGuiDzt3+RDg5ioQn+BOeyv8+u+gDEUereI3FYmw3cQQD9cAP6xiPxrVf0sHGpSEWFiYoKlpSVO + nz7N5ORkSLCVfBA9z6NcKrG3txcpdHMZ4tRqNSYnJ/u0AslIAJKoA1VYXV11IqRA2f8JfChi3k4Af8// + dwCy2SxnzpzpSvlj2oj9ncvl2N7eHmADkr4NIKMF4M0YS78nMAFbGAE6IvIRfCQgIkWM2/Ym8MFRKrxZ + cAcBGCgBX49xJf1LIjLm2kjlcpmlpSVzm01MdPn79ORs71k2Z1zad3Z3Y78LQrvdJpvNMj09ndDWcEih + 3W5z7do1arXawHc+AqqLyFsxYb5ccDeGAhhzvczlcl0VoMuOIU47EfydyWRoNhqxrIqLogixWnngs4A3 + isgW8Ix/qw8LHUyko12MUHgMgwT+HLhyu8gDvKNXcdvDAxhHj/+KMSaRsO1+sVhkaWmJixcvsrCwQC6X + JbilXLb+g78B+p/Nzs0xMTFBEgQ30+7uroNqGGw7bKmnBH/3f91qtWg0GgPtBuo48F11o2CRnsXcQJ+t + g9IwFn7hItZx6cT8fCQlEaw7zgfDh5cD/01VfxTfgnGEQ9tS1f8K/CsxgUjOYuxCFm4XU+HPZARQxph8 + /jrGJXQM+jdBNptlYWGBe+65h8XFxe4NZjfjICQdxF4ZVSWXy3HixIm0YasAoxGoVA777ksXcnF3LYQU + /LaajUYfUnEchC1gLab20xi1mHMc1pchPDfJ/R+cz3K5zMmTJ0kCVSWfzzM1NYXR4jphAvguVf0lDD8v + wyIBn+f/T6r6HzDGUl8CfDe3iZXtZyoCuBf4KYxe+8HgC1XF8zwmJyc5f/48Z86coVgqOg+m85ZPQAz9 + yEOZnp4e4OmT2IC9vV2LRvrbTtO/0KESgXqj0SdYc4x1FeMKHPq2y1+fwyEoteMoFApO/T8aNS/hZ/2G + QEtLSwFNSzSoKvfeey8ve9kDlMtl53vMGfhC4JdV9Vt9t+PU4CPSKvBvMMFKBRO67AuGqedmwWeaDCCL + UQn9Z4xOfyC2XLFYZPHUIotLi5RKpcHDmMIM1/XMfaiFTCZDo15n/+CgWy4qlFYQ5ubm8LzB5Usj9Osv + I2xvb7O5uRk3b38sIr8iIuqoV4C/RSgOYBDm5+eZm5vz+f9h+zf4O5/PU6tW2d3djUWYnU6HyYlJLt57 + kbm5OTqdDoeHhwMej/7/p0TkizHxHj7K8Cq9Oob/v88PHjMrIr8jIre0v8BnBAXgb5ITGAePn8VYc/VP + hOcxNzfHhQsXODF/gkwm4+YhHbdSOhlA/zfBvk1NT3c1CVGURnCzHh4edm323bf84PfhMt1nqgPCPwdc + VtW2q15VLfoxDSPnPkjhuKiQwfkk9rfneZw9d5ZSqZTE57N/sE+n02FqaoqXv/zlPPLII111pGONSsC3 + quov4CO0IVmCNeD7VfUx4M2q+lfSOG/dTHhJIwDx7cyBz1LVnwN+QE38/D4oFkucPXuWs2fP+Js1OchE + GhlPEgluN2+5XB50+HHUZTdSs9lkb28v1M5wCMlCRztOBBC4WRXjBhxVxwRwKmqTe543QK6nmzvX7578 + ZGJicsBT0gXNZhP1Ix55nsfp06d59atfxV133dUnlwiMTYAvEpH/ifHwHOqM+NGjvg8TCfq7RGTxVhYI + vqQRgKpm2+3231DV/w18JSHBjL31z5+/m9nZWUS8rpDPUVvis9RygtD7XC7HpK8NiGMdgnVVA777rnpN + 75L71253qNcHqdQAEqkDL8RM8wwwF7XJM5lMV3gaUX+3/8NoUmy0JNec9Y+vTSekERkbG+ehhx7qowZs + PQHV4QMY78e3iMkSlRo8z/sDEfnXwH2q+uZhvn2x4SWJAPyFnMQ47/y0iFwMl8nn85z2nXWKxaLzsCRv + UEiDBMLgKjM5NWUDkqbSCthbbbDewDOXdL2vjNJqtuI8AMEEAr0WNc+YhCuTEe/IZrPdg5rq6k/BHti1 + sSG74+bcsxoA82G3vKUGXvWqV3H69Onu3AfViCIyD/xr4EdEZE78oKuxvTd1KPBzmGSkXy8iY9yi8JJE + AKp6t6r+FMZffzr4zlry3XXXXb4gzSw8mvYGHx4J9PTw0br5QqEQKwcI9j+ujIt/7kNkoTKNZiMJAWxi + nGn6wMpIMCrAssuhB+jGLrRhy9LMZ6o57qjTdiEMXsbrhjwLt6+qjI+P88gjj/DAAw/0sSoBZFBS1e9U + 1Z8EzqSNUqSqe8C/VtXJqFBptwK8pBDA2NgYGH3uLwL/H0ycuu6iZzIZ5ufnOXfuHGNjYwO3Pgxzgw9H + vsZxEPbWTxIWBd/bSL5ufj95rmzMzXq9TqfTiWv7mu8O2/cwoDY8h0m24uxroVAgE7o10wpIB/vbK9Pu + tJ2sSxiy2axjbP1IIJvNcuHCBV75ylcyE7Ky9CED/HVVfauqviy8FmEIBDP5GPA73MLh919KCMCrVCp/ + GZNx5/Xhl5bkP3XqVM8qbcRb3zwj4rs+G0HHN9GhwdKE+oru0/BaCOtl2HGwExZE5CohF+AQnA2UHWi/ + WCwiDrI5rYA0qkyr1UyFAAqFgt+vaHmJRcAL8/N8VoAlCM2DiMibMaT956SU7LcxtgHPpSl8M+C2RwD+ + wcljjC/+C8Y1sw/GxsY4e/Ys09PT9ATbPUhr1TdQIgExpCVngdhDaMcZbDNcPh0r0l9GU6gAVfU5VY0K + e5UXkbPBB+GDYcnqKASUNDeuMgLUavVULECUwZALQXZ8jczLX/5yLl68OKAl8L/5HODnO53OlyY2bvwF + VrmFYwfe1gjA32wTalI4/RiBoJT2/czMDGfPnrXsQVAW1AfpyfpRJP/JG/3w8DCWF09rP+9SCbrLpEIA + HfxAoC4SX0TGVHUx2FZQiOl5nsMGIGmuBufG9eFhpdIVAsapIG37vXrDczO4VrlcjvvuvZeHH364z+8g + QKU9APwMRrN0W8NtiQAsZlbVeVX9MRH5fhHpc0bxPI/5+XkWl5bI5fMDmyjq9k5SnaVFDOmMXXrv9vf3 + ++oNxwMIQ7FYTB1WLKpMu90euEVDbVVJUAH6ATGc7VkVYL/Jb1pVaVhw2f97/+CgD5E5+k4mk+k7wC7k + H4VwxPM4e/Ysjz76KFMBw6FAP85jLEq/NkkzcCvDbdHzQHqrnIgU2u12VkTOAP8RQ/rngxskm81y6tQp + FhYWjACqTwIdz2eS4pZyFUySvrvLmP/X63X2992Wp64+Wk1GlEYglVASYyQTRgChcnsYEjaqX/OqOhW1 + bjaFmTq+TUKQ7nFZ/r/VZwgVfB9EAvl8nkKhMDRFFkQ48ydO8OgrH2Vubs41xHPAT6nqX2EER6JbAW5Z + jyURyavqEnBOVe9V1ZeJyHlVLQJNEVnCBH/0gguaz+c5deoUk5OTqU0wXbp3Z5y6vjKDmbicz0Lhu+zT + bjIPVTY2NrpBLlK4sZLP5ymXywNCQXef6WsrWKYRcAJyIRMR2VDVuDhhS0TEALD9tALXYEai3lz15iE8 + f3GETb1ej42mZKFcLvdiEAy0n2Y9zcOpqWkeffRRPvnJT7riJp7GxJHIAL8qInorW/6F4VZEAB4msMJ3 + YPLtLWBcd/uoFbuAwckuFossLi4G+P1B5xOL7Yc9LFFlwJF+K9imz1b0Dhj+N+a7SqXijHMXhPA4S6WS + Ia1DkMbuPFgmyQtQTSqwOKeYcyKSc30LBgF0bRv8wUsiEkhGxvv7e5EagGA/JgJBW0wr/W2Bq20GngGM + lcs88sgjfPrTn+bKlSth5LsoIv8eEx/gN7iN4JZAAHaDi8gZVf0/gb+jqnfb99FGL/2HYnFxiXK5FCoz + uMnst4OHJbmM66YY3EiuNgf70Gw2uXbtWh8Znub2GB8fx8t4AzKD4Pf9CEedSKoeMicOrwdGAOiUEvpl + zobbDCPkAf44NIFRN69LpWjr39raTkwcYl26g30Kr4sqIP0UWtT6KlAsFHjowQfJZDJcvny5rw++MPTf + AzXP896R1L9bBW4JBOAv0IOq+jMYQx4vptwAlMtlFhcXjUmv81aG6Fs/+QZwP4uvP7yRwr9tGK6dnZ2+ + PiVZ+mUyGcP/k2g6EzuOTqdfAxBhY3DZ1YwNngqcdVFiFlzRkc2Z01hyPOoZGLYlPGcuyOVyJoy6S40Y + wstKNMKx35gHSjaX44EHHsDzPJ577rmuEZX/zVngP6rqoYi893ZgBW4JBIAx1/1hTGy1WAhvtvHxcU6d + OuXwOHNtoMFb2H17h0qkuKVcz6J+qypra2usr6+nti+wMDk56W9sEtqO4rHNs06n5wQUoMCCbbdF5DnX + AfeflYlJBioiARuA0M3rPxxW7gKwv7/fJy+JmrOxsbHuhZDEyqUFuw+y2Sz3338/nudx6dlnafff9vcA + P6mq/xJY8WMotDHRgnYxXoKbQPtWQBA3FQH4Kq5Mp9P5TuBrg8/TkP3Bw3+0m3rwtrT9iKor6hkp+MyN + jQ1WV1edZGwcQrDajXAU4rjxCm6SO6gCDKvTfDgErkathapOYhyBnO/DbsBp2KKkNVRV1tfXu/r/qLYB + Zmamg+riRFlQr0yvnFu9aPqcyWS47777EOCZZ5/tM6dW1YcwFoMtXyKofuDRQ2BDVT8CvA/4oIg8r6rR + YY5vMNxUBOBLu9+EiaE2EJ0n4mYCDIY/eepUn6vpcDc19PGCR2IR4jZW77fdwDYFV1o9vgWbYqz/pu31 + R8Tc7O12u6c6jdBRt5rNWMMjEdkhQgXowwlCyVLCqtiwG3Dc3ATLRCGKWq3WF7kojk2anp4hyCe5+P3w + +vUEtC5KMdg/8/96vU4rWoha8P+C76Z97dUjwDeKyHVV/RjwS8BvA3ue5yXKN44TbjYLkAe+yY/WM3AT + RdxMlMtlc/OnlIRHyQVSIQuShURJlIBgTHfX1tZYXV3tHn4XhA+S/V0oFFhYWIgUXFrd+ObmJtVqteuG + WyqVmJqaYmxsrM8xptFsxqYnU9V1TDDQKFgExsNzbMFGAo6oO4FVcstPtrY2B7IXu2Qm5XLZRFvu6vd7 + GhmchzueDQzuHxGh1WqxurLCpeeeY29vbygkHiib8dXcS5iYhF8P/IdOp/N+INnG+ZjgZiOAs5g8a4lg + D0KpVOJU6OaPUt0kkeepyHrHpnHzkIObyN5urXab69evs7a21sXug4KmwUMf7M/8/HxX9x9su9FosLW1 + xebmJpVKxXl7rKysdBNuzszMUC6XaTQaSTfNMnAQ8/4MgRsuDFYFmHYtktam2WyysjLINrkO3+zsbJ8B + 0IDkH41EwNH9M7C9vc2zzz7L2tpaHwJNE8MhBooi8tWq+npMApYfEZHlF0NGcLMRwKuI8bEOH4RCocDJ + kyedIabS2Pyk0Tv3nkFw08QJ1KL6IGJSel27do3t7e1Ucg1Xmamp6b7wV7YtVWVlZYWVlZXY+Wu32+zv + 73NwcMDq6iqzs7O0momZdl/A4cQSYMvOqapEsWk9L7y4Oe1fGyKk8Z7nsbW1xW4giUoU+5TJZLqh1uNY + w/C+sLxCkB3o61+nw5XlZZ5++ulIKiRq/dKA/90s8J3AReB7ROTTR6kzDdw0BOAv0Gfh4P1DkwIYknJh + YSEyKUR6wV1aEh76LfbcSGBQkNR7f3h4yPLystPMN0ndZ8F4Mp7pRdUJQK1WY2trizRg26vValy7dq2v + nxF9eT5mnj1VPRf8JjyOMAJwzWGaNbNIdHl5uU9uEjVv4+PjTE5OuoyaYlV9rnL2/41Gg0uXLnH58uU+ + AaRjXvoQzzAynkBZEZEvUxO78i0ickNTjd00XwBVLYrIy4MTEAWZTIb5hXkTxEM1dgOE1dZp1WwuffGg + qi3qwA7e4Pv7+1y+fLl7+F1OPUmbo1AocPbs2a46K0wpbG1t9anyghC8mW358O9guVBfmkQgAB+KGBZg + oE37b7QbbvKahX+vra2xvb2das5Onjxp/A+M8D1xvp31Bebm4OCAj3/841y6dGng8LsQZxI1F/42puzn + AD+nqm/gBsLNdAY6gSF1oibAdNDzOHHiBBPjgym03AsK7oUfcTOkiBoUbFNV2dzc5PLly11S0XXIkjZy + Npvl9OnTA6nD7HeNRj3y9g+zTvF9d/ajAlyJ6puYeIuR6XmCKsDoeQ5rB+h6YgYR7cHBAVeuXImUVwQP + UrlcHmCVXOMd8Pgc+G1gfX2dj370o6yurqa6yV2XWJpALzHwgIj8exF5+Y1yNLqZCGBRVU/EFRARpqen + uymxXTd/FBJwH9KBkonP0tz6fm9p+8K+5eXlroptlIXLZDIsLS0xMzMTSe1Uq7WuJZ/LUCc8j1HzG9UF + TFz8ac8dzWcWmHM87/Y/l89FIiHXeqhq35Raaftzz13i4OCg73n4O/ts/sQJPwNQPEXhfN3VARqNzQsv + vMDHPvaxPq/D8GFOy1a4IA6hhNbyUeDHfY3BscPNRABnCSWUHOic5/W5vUZBWj7LTeanO/CDNzh0BUcY + KfXyteWB/PWuuuJuhWw2y5nTZ5ifn48VLg1zswQ3atI3NsgK8H8Dv62q3+ZH/Ql+eAqYiOpDNpsll+2X + WaRB3sGqzOF/jvX1OGfEXj2FQoFTi4s+MuytTXetkigh/99GvcGTTz7JE0880WcqHSV7SKIk49nVeOQc + YDG+BJPUpnzclMCLLgQM3FbniREAQi8OwCAMqmjSmnxG6+xd5Rhop79+s2nrvqR/N5Tq24538LteENCw + oPP06dPMzc0N8PCml8YmQVXJZjJ4nke73U6FAMNqxaiNGXhWBD4feK2qPolJovqbwMdEZElVS1HtBlWA + ZgrTqfvsfNZqNS5fvszKykoqtR/AqVOn+oykBgSO/sMozYTl95988kmniXbSIT6i9D+JihPgm1T105gY + GMemFnjREUBgAw6kkwpPQhQCUB00ce3VbecrUNYh9bft2TLmt6OdGI2BiLFOW15e7iNTXW0lPc/lcpw5 + c4bZ2Zm+931jUrqOK56PAI4LYuwRssBDmCSq3wb8oZoUWpGN5/P5kBtu/5y6LPIQaLfabG1tceXKlaEM + bMrlMqdPn06l8Rnskfn/xsYGTz75pDPQiGuu4vqWzWYpFAqUSiU8z+Pg4IBqtZqK7I9ZhyImz8WnMfkG + jkU9eFPUgKqaEZFT4YGGwY8C5D7Y5uMh1Hz930f0aygqolKpcO3ata5zyqhQLBY5ffq0L+tw9XHwmed5 + kT4BKebfuYkTfouInFTVvxlWdYXLFgrFXr4Fx1CEHnlrnZJ2d3e70v44C8WB6kQ4c+ZMX4CUZM8+7Wv/ + 2vIyzzz7bGR8xKTDFpR92LDzk5MT5HJ5RIRqtcrq6iqXLl0acMCKqivi2UngHwMfVtXYbK5p4aawAMAF + 4BXhCQ4P3iIAMwnp/fqH0/8TqtPVhnkevPkPDw+5evVqmsSafWMM/x4fH+f06dN9QUwC8+R8pqpOBHBc + t0KazRmnaWi3WxwcHJDxqZQgu6MdpdVu0Wg0ODw8ZH9/n/39fWq12gC5n2Y88/PzLC31y8ei2bz+Z61W + i+eff35Avx9l1+GaBwvT09OcP38+pIY0MD4+zsWLF/E8jyeeeKJvnCOs2euBrwP+23Gs981gAcZF5J+o + 6oNxEwoMkLgua7Hg96N477ks0pLkLNaYJiyFT1qQ8PuZ6RmWTvu57kMNJ21ikW7i09RGRVFzNqyKMlw2 + PP7V1VXW19e7CKDLDqh2nZVarVai00saI6kL589H+BwMGm3Z6bSs2zPPPDMgZ0jSqITBamwuXrzoI3Ed + SD9u5+bcuXPs7u5y9erVVPVH7KcchhV7h6ouJ690PLyoCEBERFX/rqr+jZTlnc+jLfdc5WBY+/84dY6x + SV/pI/tdN2EciW2TkvYlKWGQ0A/3P4gARcJpt/vbDj+z7QKRN+1RbxT7bafTodPpJKUcc7bn6ourXC6X + 4/z584yFgn4MkvrB+TP17u/v89RTT7G5uRm71knzUSwWueeeezhz5kzfOvavX6/tbDbLvffey97eXipZ + Q0zbrwT+OvATIy+WD6MxkUNCYHK/0O/0TJryxUKRsfGxyMVJaGvoZ67nwQ3UbrdZXV1NtXhR9Vmf/pMn + Tzp5+DR9tQig0Wiwu7ubWu8/NjbG3NxcV2A56oFPq4pKUj0Oo5oMlsnlcly8eJFTp07FrtdgO7C9vcMT + TzzRtSwMlhnGbHd2dpaHHnqIxcXFPko1qT+FQoFCocD6+voApZA0v4HngvHE/A3iszYlwotiB+BP7ElM + ss4uw5a4kbqvk/XyvZLpyqZQg/m/e883Njecqr4UYwfM4p85c4YT8z1nlfR65UHdcqFQiNCSuMcWNmVN + Ij/jKDBX+bg5iFOHRtUVNmMGc/jvuXiRU4unnH2JNtyC9fUNPvnJT0aGFE8znkwmy7lz53j0Fa9gdnYW + EixMwzYJqHLy5EnOnj3r/CZM+UQhSRF56DgsBF8sFsDDRPn9QtdkhUlW5ySKBrzrYyCgKksHDqGfI5R3 + tVple2t7ZFJ5rFxmKSDsC89DEgvikn/kcjlyuZxTau6qr9lsmnh6KboedcjTqjXDz5K+c5H+4W/Gx8Y5 + f+G88fYbgq1TVa5fv87TTz8dK+kPfuvqb7lc5p577mFpaYlMIChrkqoxKMBWDCt2/vx5tra2BuIbRs2Z + oz/TqvpGEXl/8mpGw4vFArwR+Df41mOO987vCoUC4+PjieWi3rmfQRSJGPW9aofr19eoVqupDn/49pyY + mOD02TMDaaaS+pvUVxFhb3eXuiNHntOQSJVWq+WkknzoAE+ISAcT73/k62UYstalVgyC53ksLCxw3333 + MT09lWpugnNw7do1nn76aWco8ZDFnfO5iDA3N8dDDz0UEZRleNYzn8+Tz+e7MSLC65p+muVtIjJy7sEX + AwGcBP4DMDS5ks/nGRsLyQB8PbJjJqJmaORn9rmNtJP24Ac389TUFKdPn470jks8KKHxBje+tUWIskNw + qR4ToC4i36mqPwmsY5DANBHh2lz/jgJxcz81NcX58+c5e/ascw6T5m95eZlnnnlmQCCZtr/ZbJazZ8/y + wAMPMD4+FjIaS0ZycUh9bGyMer3ujHKcpn8iUsRYZ64nFo4a36gfpgER8VT12/FJ/2HJZmd5nx1w2QP4 + bQ48H91E2JDNW1tbQ8dpExFmpqc5tbhINpeNveFi+xYab1C6LeJRLpdTUyVJ71R1X1WfAx4DHseYnX6O + iHyVqn4+xn6jHJzvKHJ9GNVkuEwmk2F8fJyFhQXm5+e7atK0Gpzgzf/MM8/0JRGN6m/4PZhcE/fccw+L + i4uB6EbRdilp9lqQlfM8jwsXzrO5udkXMyIti6mq48B8YsEYuCEIIDAJrxWRb1NVL6pcnKpHIxe9N4kD + k+Lg36P1/64FhOANa80400Cw/5OTk+bwZ7Mhnju+zV7f4sdrn5VKJTKZjNNX3WX3H0Um+7AJrAU6uiEi + 7wDeicnQ9CWY5BfORHlJcx4HmUyGYqHA5NQUJ+bmmJya6gZBGbQ76J8v15xeu3aNZ599llar5RS4Rhlm + WZiZmeHee+9lZqZnmm2adSHj4dYzWHZsbIzzd9/NJz75ycRLxoHoiqq6wBHghiAAfyIngO/FBI/sm2Br + JpokJOp0OsQhQucmixACprcd6C2WqjptuJMQ1/j4OIuLi2SzGeIMUuKfpRtDoWB4ybAlW7RANfb3qojs + Bp/7/3ZEZBX4VNRa2Xaz2ay/bm7kbW8+mzm4WCwyNjbGxMQEY2NjXT+CfqSFYw5Dt3HAN+T69VWeffbZ + SLI/TvvieR6nTp3innvuCbgW+9/hJD6dt3y6lGegKiydXmLVjxkZB446shjPzJHhRrIAXwd8hWuCJycn + OTg4iAyvZMFspA6q0QKSYVRMSXbh4W/b7XaiqW94IxUKBU6dOuWbg9o+D26GMG8/itGSqpLJZCmVik7D + pOCcpZTqv6CqkeSOGgeu8aj3pVKJey5cAIFWq901CDKyEcOyZLPZ7l8ulwuYC/dUrp1Op8+LMIoC6qOS + /Jnb2tri2Wcv9R1+l+Wia55yuRx333UXZ8+dI9tnzhv4pteh+P5EUgeDiCyXy3PhwgV2dnZoNBqJ6xd6 + f0sigLsxsf6L4RfFYpHx8fFU2V3tTRKEtDfjMBD1faPRcFqzxd2Ac3NzA3ELnYjGeZM4SEXHw2B/RYRy + qcxmTARvl7luBDyP0QREjbkvEnD4IBUKBcb9hJxptQD2ezPMwOHwxx5/gPrdeff393nmmWcikXaYKgrO + RalU4uLFi5w8edLYVoyw75zsSWj9XEgAlLm5OU6fPs1zzz03MLcJlHL5KBacN8IQyMPYKj868MK//TOZ + TKoDa+3G00CUHjrtxLjK1ev1oTzTxsbGmJqa6rY7JPkdeBZY8NhyBkrlcqJnYHDzR9yACjyfsC53xc1v + Pp/vHqpOp0NHe6xAj5rThPlJWq+wUZT5t1ar8vTTTw+4ZVvNTBSVCDA5McmDDz7YtSwcrn/xhj/qLONG + LufOnfPZjvR716XuHQZuBAL4bOBv284FoVwuUywWu3ygazBB6HQ6TjYh3qgk2TowjRVgFP8fBxMTEylc + dAet+gb7ETW2wWfWItCVLnwYEJGqiFyJeIeIZIBzcXWE1XQuYiZpXOEygzfg4CHrdDpcvvxCbKLVqHWc + m5vjoYcf8q36hofo7aGxZVxIYGJigjNnBmKtJlFPjaNQv8eGAPxNUsDc/ovhQdqstpY8TDooFrNFOZRE + H2JX4eRbNPxMVYe6/T3P63PO6a8veTOkpw4GIZvNdm+ONBBxY+wBK1HlVbUkJq2V02hFRMjnB/M1JN1+ + Ue05nroLC92MS32PI0ytg+9PnjzJy172sq5Dkao6L4vwmJIpOzciI8VFdObMmchAsK4xAOvDULphOG4K + 4AuAvxTqIGBvf5utRfpcOF0kqf1/VygSOcD0ByWqbBRJFpXayg1htVSwPmJ/R/U7atO4+jpgMDU8bPh/ + UTCpqt1IwOG2PM8jn7f2QmGEF+pzKioogbT2/1s5qHD58uUBZB1HFosIi4uL3Hf//QZpB9ty9BfnAXON + IQ17EO5Lf5/L5TJnz55NqbHSDn7+xpvKAviNj2Ps/WfC761hR0+/Th8FEIe9bAorM73RN366GzTdDRTs + d3CMYV4y+Ey15/6app10/G4Ushh8WC6XyQ4RIWhQI6IrqroX0+85TOaaPqRp/7WRgF3jH0ACQ9yQg3PR + e9Zut3nhhReGisgkIpw+fZqLFy+S9yMXu6i0vv67/qfRSCmqnvgx9Z4vLS0xOTmZZjh1fLuNm0oB+JP4 + ZjWZfgcGWyqV+lNFo+RyuVRYq+lnsRWRyPPSk74OPh9iFANPgsk0XYKhsEDr4OAg0pjDTV66N0g6ErO/ + H4VCgYLPgsR58rnAL3+ZCNdS//0pYqI4Z7NZspksLioubqzhcSWti61HRNjd3e3LFuyac9t/++/S0hL3 + 3HOPMTLS/npHucHdiCz+WRzLoKoUi0XOOGIcOuBQRDZuBRnANPDtGNvx/gY8j/Hx8QEVmNUBuyBYtt1u + 9zlxxPP+w/H54e/Dz10ht+LAWA3WAnWGd0c6yb/r22iKQbvzPDYWLweIsgL0/y5DLElyBl+t65qHqPUc + VhMSZvei1rXVarGyspJoS2LrtDz/hQsXusE70rAZo2kCRhVE96iqU6dO9TnCRcz7VeBa4gTEwHEhgC/B + xCobAHv7hwecyWQSeWw74MPDw4jw0GlukOhbNUkImAlF3k2iKFqtFjs725G3YPwzN4sTNz6rP7dzNTY2 + 7rSyjJrXQJm2iDwX5czi13cOn4dz1R204HP0PGH86vgVfRDN7b8zENQjDk6cONG9+ePWx82+jYYo+p5F + soXuekqlUl+kYxfyFpHfx5cBjApHQgB+J8Yxar9SuLPm9g8Lp3o3llVdhUnWMH9Zq9Wcrpxp1WVxEHdA + gznu07pr7u7uDgScSC3VHoGctB+qGr+A8JzGzWsAqpjbxNmemErOxY07n893xaBuzUc0EnDxwXHfmNt/ + tWvnn0SZTUxMcM899/QuolSaiaQDnlbuNJxcw5ZRYHFxsS9YbOjbXVV9e3T/08HICCBgffQG/29gg+Xz + eQqFftVYcOJcGWRd0G63jYFHSoFY/O2ebrJUTQw3q5IJ8pNxE97pdFhbWxtwIHLrs9PelulkArlcrk8d + 6Ko/Yr53fCFg1FwUSUjjXigU+g3gBuqIGltwDMnfgEm8anX+SdROoVDgwoULlEqlXrmUsoY0pL2LHUim + IFzIbrDecrnMqZPuFIyq+mHgo0c5/HAEBOA3XFbVb8IhHBIRyuVybPKKQqEQyY/ZOixUDirU6oMyqqhN + Et3vyLE4YWJioi81dxJpLWJi9a2traU0Yoq6WRJuIAYRg4h0U6lZvjdMOkfAOrhtiQNU3qnw8+D/8wHf + BzustLdd/O/BZ7u7u6l4f8/zOHv2rO/Rl3wI09psDI7J9TuJmnHVO9j2qcXFqFgSnwD2jqj6HQ0BBBp9 + HfCljudks9kBm/jwgLPZrNN4pn9SDLTaLXZ2dpzGOS4S0jWpcc+jntmgJMNCpVIZyBPoHmO0TMBRuu+/ + rjLlcrkPYVlIiAdQFZFmTJmBZKDBPnueRzY/6Lrr/j28YDA49na7nToo6/T0NKdO2diBto5k0n6wL0nI + I3n9orUM0YjCWgeemHN6X79ORCIzNKeFkRCAP+CsiPx1EZlylSmVSj7/HH9jlkqlRDYgKAzc3t52qtqM + EA3nczcSGHzu2hAi0vVfSDMvQQOU3d1dJxIY1iqxv8/RZSzCKpdL3d9J5rA+lXCfqj4Q1QffAChSMW2S + gfZUgOkOdKidVDYARh6URu9v4/UHBc2qUYh1+HlP+ia6HhfbE011eJ7H4tJSd/8FZB6vAL4ouWfxcBQh + 4P2+7n9gwJ7ndQ92NK9rngft2NNEy9nb22Nra8ttIhwhSY/rQxJYvWyQt04jELQHbmdnx40Eutg/PH9p + bsfoMkbwOpHw/cDvE8CbwuMJsG+n8SMBRakAvRCCTNduvJTcNdbq4WHf2kfNf7lc9o1p0grmHM8StAWj + yAjSUh1BZDo7M+OnjeuDPPDXVTW9DbgDRkIA/sb4GkyK7wGwAQ+T1GHQsxKME66F69nd3WV1dZXt7W0a + 9Xr3phMhsJGiFiNZEOeiAmZnZ52kddL3QSTQx7dqnOArvg2NOSyqJspMsK9xJrEBeLOI9FlxBiitc/jx + I13jzeVyeOIOTz44/+GxpinTg3bIRTxI5QRhcnKyG5NBHROdiroK9WdYiix6jFHfucvl8nlOLix0ywWQ + w+cDr0qsPAZGQgCdTuckJuAHMKjGKxaLQ8WrHxsbSxXwMQiNRoOtrS1WVldZW1tjd3eXRqMZ2BAu98+4 + yY/va7FYZHZ2NnW8tnBdOzs7XLt2zanOHE3aHC04splp7RwGD0nMnD6iqp8VMTYnord1Bd2A4/qdRp2W + hld2zwMDe3CghmGpkm5Xoqm0NDYmcQg7PBdR4z4xP++Sl80Cf5UjRG8eCgEEJviNwMtdA85kMhSLpWGq + 7cYJGMwF6F704EK3WiYR5cbGBteuXeP69evs7uxQr9cjZQUuSEN9TE1NMTWVyka7r6/2cOzv77O8vDwQ + DCXNLREvy+jvr53PYP+D/0bEA5gQkS8Pzy+G1HQigKC6t7/OeEl6ElnuoopMtUlzlIzo0unl+3uaRqA3 + igFU0tzYcVuqzsYnDIKIvElEYt2042BoCsB3+f06ApFhgpDP58nl4i38XNivVCp1hVeONge+dz1rtVpU + KhXWfWRg2YRg5tk4N9EkJGBYgblI7UZU0IlgvdVqleXlZXZ2dvs2wOBN6DZVTdpotg/j4+NOliUK/O/e + JCKnQ6/G8N273d95PvUWd4DTjiN63vpHmQyVSoWe0c9wWoeoWz08hlEOeBIlEFVvJpPh5MKC65K8qKpf + MKo6cJS8AA8CP0CEY8jExATFYtE/pBBJnYRi4ll/8kaj0bXwCr4L/ht+7gJVE0ugWq1SqVSoVqu02+1u + LII4+4Q4ntmaMLvMk9NCp9Ph8LCCaodisTjgdZjUn/C8WqTWbrc5PDxkZ2eHvb29SCooai5VdRb4GPCx + wPsljJfntGsdstkMCwsLAwFJXGs/2th6v22cxs3NzVRzf+LECTJexllv1BwM27+06zPa3PSXy+ZyrK+v + 0/ATwfjfeEAb+G3/36FgFATwDcBfdXW4G/IrG6g2dNDjJtjzPHK5XGQorjRYLuoWbrVaVKtVDg8Pu3z4 + sIjALkg+nyeTyQwVMchFsVSrVeq1uk815Qbaie+L+d3pdKhUKmxsbLC2tsbGxib7+3tUq9XYQxJRX8b8 + V34LsBLL+4BvJhDfMSjzyeVyLCwsRPp1HPchy2ay7OzuRMhSetDpdJidne3jm+OQy9H6m1wm/CylYLav + j9lslv39fZcdxIyIvEtErjMkDIsAJoAfBC64BpDP57uWaIMD6w0kbuA2YmytVhtZdRc3wZ1Oh0aj0c2o + 0+l0yGazqTwTg7/Nze1Rrdb6WIS4/rje277YiELGoSZ+k4kIrVa7a2ewsbFBpVIxab+GnDNHn04AfwjY + 3POfA/xNIvZKPp9nbnaObJfts+0f8QYcoBDNQ8/zqNVqicZAqsrk5BQTE2GPOlfbgWcRF1bSoZdeRem/ + iTgTURSEiNBpt1lbWxuQ3wDPicgfMyQMiwBeDfwDoMsEBzf22NhYrPVfWoMfm/TSBgMZpo64usPfGpK5 + 2kUEuWwOL+OFvoOozVooFHwk4M4dEP4ddTjb7TaVSoVmo9k1j4ZBWYeI0Ol02N/fZ3V1ha2tLeq+GjRp + rGnmxf93DNgUkT/CRAh+E/CVUd+3220qBwb5WIOgrj425lCNSkrbMlubW3S0EzvWUqk0IDiLPnTDH9YX + j4Uwvy0Lev369a4tRGD8WeBtmCAhqSE1AvAb+Wbgy8Kb0m5Uq3tNrit5EXK5HMVikXa7ncruO4mkipMO + t9ttqtUq1WoVTzzyoWAlcXUXCubWjmIHkqgCC6pKrVajUjnE86TrXhs8SLVajevXr7O+vu48+GnnIgW8 + DJMS7G6Mm/fL4uppNBtdBx3t6IBcI+q7qN+9Td3TLHQ6Her1OgcHB+zu7nJQOUiUA2SzWebm5iIC0ELf + HkyBpG4Uy5BIlYTGtLe7200lFqhrEvg9epRbKkiFAPxGpkTkBwiFhg6S7mmi4qZlBcDw6KVSibyfAntU + oVtaaLfbVA4rNJv9N3G4X8FnImJIdxGqQ7ItbmRkNBmNRoN8zsgGOp0OW1tbrK6udqXbw9zyUW274vf7 + UMYc+i8GHiClnrndbrO/v0+lUvE9QR1RgiMQsQ0B32gYwa096Fubm6ytr7O6usrq6ipr143NR5q9MDY2 + ZlKJRwmRA/2JWpPRkEByGfd3yWyG53k0m03W1wfygZaBp4A/SbNWFlJFvfQ39QMi8mDEuy4fHWWZ1SsP + EK0hCPPTnucxNj5OqVzm8PCQSqXilG5Hkdhxz8PtWfXP/v4+rVaL+RPzFIrurL72W3sQp2dm8DIZNjY2 + jkyxdDoddnd3OTw8ZGZmhkajwe7u7sDcxLkoh8vkcjlmZmZYWJhndmaW8YmJrv7eUkC7u7tsbW2xvb3N + /v4+jUajdw3HzGV4Tvb29qjVapxeOs2J+RN4IuB/2/EpumazSaPeoFY3sR5sEpZWq9VF9mkOeYRNAyLC + zPTMQECXPqoLTEqx2DyD5lmvHRBJ/mZwecPfRO+nvt9mMN0aUGVqaop8Pu8ShH6RiPwUcJj2IkpEAIFF + fx0hj7Dg5A8agySp6VyTFJyu/iSfnud188c1GnUODw3J3mw2uwc3PHmOMTjfByffPq9Wq6xeX2VhYYFy + qRw5piASmJqaIpvNdkn0NO27NrAt32w2E/PFRR1K+6xYLHLxnnt48KGHWFxcpFwu4XnuxCyqJg/D4WGV + ra0tlpeXuXTpEisrK915TguNRoMXrrxAvV5nZnaGer1OpVKhUjmk0ah3D/qwFFNaR6NCocDU9ID9vGOf + 9O/D8IF3fZcGKYTV4K563XsqVI//cXCflEqlbmrxELxSVe/FZHZOBWllAEXgH4rIA1ELMxG4UUTESV5F + fTvMOxEx8oFSkbGxMsVCwQju1J1K7ChksiFJG5THynheUFcPUTKMfD5PqVSKTCvm+maUQ5Bk8eZ5Hnff + fTdf8iVfwmd/9mezMD9vbPZDZL+qop0OHbXpuYxhz8zMDOfOneO+++5jYX6e/f39vqw7aWQrqspB5YCt + re1uCux63Rz+4O0+yholfTM7O8uCbz9/owR46diDNG0PVyaTyVA5OGA7lAgFI8D9FPDnaecxLQK4B/g+ + iXD9tfxku93uYnUNvY+DUd97XoZcPk+5XKZcLlMoFGJj4g0rHQe6RknlUrlfZhSnq85mGRsrdxFIVP2j + HP40UCqV+NzP/Vze+MY3mlx3mQyFQoHFxUXuvfciFy7cw7lz57jrrrtYXFxkemaa+fl55ubmyPpZey0F + ksvlOLmwwD0XLqCqrK2tpSbN7fiGIeVdvx2ailjI5/OcOXNmIFnK8Uj6+8scHxJIj4BEhHarxfVBdaAA + FRH5TRFJJTCLZQECG/RVwFIcn3lwcNDHt9s/azmXyWTM/zNZvEzv/VEgSEJZ+4GxsTFarRb1Wo3DapVa + rdblyYPkepqDZ8vt7e11kUyv7UECp78/OU6ePEkhn2dre7trhZjGQzJuvI6N0sEsvAAsLCzwhje8gYsX + LxrEVS5zz4ULnD5zhhMnTjjDsNkDqqq+EVaLvb19nnrqKba3t9nb22NiYoI3fuEbmZme5v0f+EDQJ38P + QyHmg+OLkwUlkfJx85Q0Z+Pj49x1111MT0+7ZhAGyPQwO5CmDH2/gzItl4wrjUzAZTkb3bYyPjFBoVAY + CD0HPKqqi8ALpIC0FMDfxcgAIhepb2g+1m+32zSbTer1OrVarWuJd3h4SNXn4RuNBo1Goyv4CR6iUW5s + MAioUChQLpcolUrkclk6HXXW76onODYrlBMxUXfDnzj756uURISST5k0mw2azWThYJrxhfqq5r8i9957 + L1/+5V/OuXPnAGMI87mf+7m87MEHmZ6ejrXWs39Wej85OcmZM2c4f/485XK5e9ssLS0xNTXF1atXLXXT + wezmXNycxo0rTh2YFjzP8yP/XuiLh+AyOU87t/G//cqP/E18PW5201DcGxsbLgRQFpH3AM+kmbc0CGAC + +B5Myu8jQxA5tFotGo1GH3KwdvvWZNfyjINqQJtzPg5JiB92rES5XCafz3fbjrqhwjx2t98dZWx8LJV+ + O/zcIKMynU5naGFaChARkQcffJA3vfnNzMzMoKrMzy/wmte8hnPnzo0sB7GRm60ufWN9nXa7zfz8PBMT + 41x54QrNZjMH5EIdGpiH8DqNwgKFIZPJUC6XmZubZWnpNIuLiwP5CaP6M2yZNId3lHpHbcvzPPb39tjZ + 3Q1XlwOeEZH3ppnDNGrA08C9cQWCrECUWiYJgnx7lB9AkLWwbIUl/S2LYd93BZF2oL6dQrlcplKpsLe3 + 18efB9WALmi2jH46MiiIw5Ckq2hSE7H35MmTFIvF6IhGjjntayMCrLBvfHycTqfDyZMnef3rX8+JEyeO + jGyMJ5rHQw89RC6X47HHHqNycMCDDz5EvV7nD/7gDwfGEt4HYQ1LmoNvEYQnguevazab7VIoFqnaGIhB + 2U8yKe0og1qXo4hvXCxfmB0YlOpHaafiyyS3JQITE5NRc/m5fqSgxNhpkQigUChYNcODIjIft2BpIrQc + FdtbbzeLHMJqNosgLCIII4dsNttFDpOTk5RKJXZ2djg4OBg4+FE8aqPRiNZfOtS8YdWPiDA9Pd1FArbt + pHHHzePExARv+IIvYMI//FNTU7z61a8+lsMfHEc2m+X+++8nl8vx4Q9/iIODCo888gpWV6/z0Y9+dKBv + UfMZ3BvZbLabe6H3b5ZsNkcumyUTQu49JG9EHn3tdTo9fXmEym2QLw8smvpLGDrQwx7eqO+SyrhkAnFt + qcLY+BjZbLabOi+AaB/CRHH6dNLaRiKAer1uK3ulquajdOzuDTOI6YcRuqV5Hq7bshZhIxxDCQjiCZmM + h5fJkg0hB5fhjqvNZrNJB0W0VyY0cnCoB8OLXSqVWFxcZG9vl42Nzb72kyiR8PMHH3yQpdOn6agyOTXF + a17zGpaWlo6bzehSAhcuXKDVavHhD3+Yer3O6173OlZXV1lZWYlt0zWu2dlZlvyAl12qrSvpxjmXpi92 + rvtnHk02QgsL8FyC3CRqYdjD6vrGPOnZukTZHxBhqKRqTK6NfKkZPmengB8HngDeJcavo+FanzQygDoG + kzyBsTPeBRp+TzL+n4QnIAhxwraocq7/p+GnXPXbjddud/rkDsN6HHpi8hxmMpnEtpOeGWokw/7+fh/L + M4wQbXx8nDe+8Y3GBNvzeNWrXsW998Zya0cGzzNUjHY6XF9b69r9P/vss+Fbv4nxVZfAs76xNJtNpqem + KRQLjhsSwoc8bFvS+++wfHj4m/7fx1XGicQcrGKy/GGwTkvxbmxsuKIkexi2/XXAVwMLGPuA3XDdaWQA + f+J53p/40vCcz1tMYdxGFzFJI89iSI7TInJSVecwIaZKquql4ffCt0Ma1U8ctRBHgsbVHX4f/N1oNtjY + 2OiSq0EqIkmtOUiC6oAcIm6srj6eXFhgbm6OTqfD5PQ0Z86cSbGcRwNVY1Z873338cKVK6yvr3PPPfdw + 6tRJlpevgbkw3quqvwx8I8afIDAHPdK90WiwurrK+fPn8TJdTWZfW303tv+w3yLPRbYDqdRpBOpJLpMs + A+ivx4iGHIMI8vKOte2NqX8Mlg1utVpGs1atOe1MQvt9WlX/PnC/iHyjqm4Ey6byBQhI35sYCmAXX8+Y + yWSsjtsDiqo6gTEZPqmqpzHIwf4tYhDHlKqO4UuP097CacolsR9p2BfXt1YdaL2wgC7Z2rNxyJANIYeg + 7KGruQBaNt1ZxAZII3M5feZMV7MxNTVFqRSdZOU4QdXEqFtaWmJ9fZ2xsTEefuhhVq6t0FH9NMZr9KqI + fBq4oKrnw/NrYWfXRC+anpmO5JWD8+I/ZZgDHv0Nfc/CH6ZjB/x1M5109DWeUu34lpjGT6JDu9MOaMia + NH01edhnotlsDphSuy66wPsvVtWvAn4u2H4qBBAHlnxV1Q5G6ngIXMeQHAB4nieqmlPVcUxoqXmMYdEZ + DOVwDhN6agGYwageC66ZTitMTHKOibvp09QHPcSYpLXoCSVz5HJG4GXtIyLaUuCSPxezrjK5XI6lpaUu + Ajp58iSZTDY1Mj0q9AK5GuOXu8+fZ2x8nP39/Xn8cHEi8sFOp/MvReQ/aSB+ffBgtdtt1tbXmJic6Msu + 3HdofOOXSAEebgorVuiHA1FE3L79a66odvrkTq4/+75brt2mHXjfarVot9q02q3ugTe/23Q6PYvaJCvK + MJtr/x8uo6o54K8B/xuTDBY4BgSQBjqdjmLkBlvAlqpeCnUwq6olEZlU1RMicsqnHs5hKIfTGOphTlUn + Ma6PmVAdqQSISSyCawKT2nBBUGsRVpPFC6oUTFy+v4uhpL5HVb9QRIrBtkulkuHFtcPExCSLp07FpOe+ + MTA9PUU+X6BWqzE5McHc7KxFAA8DT/gH/X9hMth8Q3icdh729/fZ39/3x2P73y+hNxMX/D4dST7ouRea + f99s3R5MexjNX5tWq9n73WzRarcGPBZdhz6wluG1HRlG1aQFvimKP3j77EVBACk62AL2VXUfWFbVxwOD + FREp+KzFLIZKWKIndzgLLKrqPIa6GPexXd9Ah73dg5NuyxyfWi3WW/I68P3AX/hlPqiqX6mq3yIirwUK + qtq1aVA14crHJybSNn88oMrszCwLC/NcvvwC+XyekydP8vzlyzngWzCJY5/AWKT9uIh8rqreE54HEeOO + vLW1xeTkZD//HMP/974HJ0keKhc83M1ms2uBGiSp7UEP3r7HjVCTDrFLZepijZK0RRF176tq3210SyAA + FwQGpqpaA2qYLLZPQi9tVafTyYnImKpOAfO+HbRlLc6IyBk1ue1mMaRpEfCiWIIoamBYQ5YkiDj8HeCn + PM97Z+A22RWR/6mq71TVrwa+Hficqakpz0binZyc9KPyvni3v2Iy1szNneCFyy8gnsfCyZN2br4UI/zb + BS4Dj/vCp3sG6vHn0cYQCIaUU9UByX/U/JkDa0jtZqtJs9Gk3qh3rUnD8QaOE6EPSxmmfT+M7CquL4Fn + V+kFewXiEUAOmBSRKubwdV5M8jIJgoJJVd0BdjCbjXw+T6PRQEQymAM/iUEAJzHsxDngrKqexVAT96lq + OQ0bkdaKDYj9xoXlgQ+IyH/zWaZw2S3g5zHC19+cmJiYtDIGq5p8sZdHRCgVi4iPjMfGxrp2FSLiqeoM + Ro7xqIho1NwCNBsN9vb2nDElg1Rcl1RvtWj6Kl17wOv1+tCHPMq+ZRiL1iiDoWHncpg9FqcZi+jL88DP + h9fBiQD8Cs6r6s+oakdErqjqFczmu4IhU9cx+ckPgdathBysakRV20DF/1sBPgld6kFUNY/ZoD8LfNko + wkXHvA0lXAyU3wF+FFiNq9/vc75cHusKAMfGxmLlCjcScnk/fqIqRT+Mmis6sao6O9iluoC1tXUTl7Ev + ig9doVin3eny4EGfjqMcuGFUzHF1jfJdVHsuSjRuDHF1+WX2gR9T1Q+FyzoRgF/BBPAIMBvATKqqdeAA + 2AbWVfUaPmLwEcU1YA3YEZEDfKOhWwlB+NSDAnURWVXVx4AvSzO5PlzHIJN5jKBuEhMpedggq8E23gX8 + YQpZxbSI5MbGTXyCbDYbG4n5RoPnZbqxIPKBOIqj3KC1WpVarZpYflRIskw9Cmt3VFZxlO/SXEbAH2Nk + MO9wfRNHARSBbAgzif+8CJwQkXtDlbYwasAdYBNz616lRzlcBa6LyJaq7mFYi6GzmdwA+DOMAcuAK1nQ + CjEwzqaI/JCqfgqY942flnyW4pyInMWYY86r6jQwJiL58AIE/l8DfpWYkM6B9sc8z/NKhSJoLxPzTQFf + CGf3WjC/gktw5RiLay6ORcYSrCeN5ieNcC6qn6Pw7Wk1T64+BOc3gRXoAG8VkbdFtRFHARTt+yRb/MB3 + WcxtOAmcU9VXBsp3fGHePoafvS4iywHW4qqIrKjqOkZ4VBGR5o2mHPz6Pw5cA867Ftox9jPAdwN/B/i0 + GuMXu0CCkZ90BZMYFeZZVQ2qNRcwcokp4CPA+1J2edzzPMn6XonWxuBmgH9fEdS945i3uM0eRykchQx2 + 1Rmn0RmV507qyzCUUOJ8O/ps7E2Edrs/xJo/Rg8/jmcUMo4TAhaJyQk/7ID8zpQx6qGTwMuCkn6MMO8A + Qz2sY6iHoNxhGcNabAMHIlI7Rr7iKvAh4HxwYhN4xK/GxEn4N/g3t1pbUMP2NPy+Pm/fjY+PU6lUMkDJ + t2eYxQght4ENYiDQj5JxjTUIwJrW+mz4iwrW2CnYx06MDUVwHHEHw0Wmx2lphjHiClImcUJJ1/vwd+G2 + j0OIF9cv6xJdyOcplkyMi4mJCQ4ODnj++eej6lyMay8OAaTmaV36yiHPpmDSUM/6fxdC71sY66U9fNZC + VZfpIYhlDMLYFJE9TFjk1KyFiDSAX1XVr1HVRHtaf2w54P8HHIrI/41BYLHf+aa/bYwM5QBDdXwi7Rz7 + 9g0zIh7ZrAnBfhyh1Y4LgggzfNum4XGjyqQ94GnLJVGzw/Qh6dkw58DGPshkMr7FqIl9UCoWKZZKFIsF + CoUi+XzesFv+2q+srka2j2FFM0Sw2pEyAFWVKKybNOAoj6wRqIZgPyf8v9Mi8kiQehCRui/p3ALWfEHk + FRF5QVWvBFiLHczBaxJQmvt1vRv4MPB5Q/S1jMmViKr+JCkCMKQFz/OssLKI0ch8gYi8WVU/TwIeZb18 + DMfV8nAQPPQ2tJv/vIOhgmoi0lBj7OX5spAJQlGEbF1RbSSVse9cvP2o9Y96kG271obB+oz0m4VnuwFO + 8vkcuVy+K88xqfGyZDLmkEs4gYsqiNnAHf8SiDqrIrLga46c0tU4GUDbktjD6jldWHNUHsr1PDRQ8W/t + Ikbodn/om6aqVjByhXUfGQQFk8v01Jq/jXGh9IZAAhOq+sOYjEn/FzFqvDTjBzxVPaGqD4jIa1X184BH + MdaOAxRZLpTG7MUFpd1udQ12bPg24J3AL/lzuo2hkppqPEPLInIBYy34pZE1H5MQMFhXj13q/QUPZ9B/ + o/cniPQ/c9UT/usGL8l4ZLxgQBOvqzkJ1xU7Fw7TSJeZs0NOcAITLjw9AvChHXeA05D6ceRT0vdJgsc0 + lInfRs6XxE+LyF3hMWIk8HsYHryFQXzD0tRFjIXePcCPAB+MmvDwWHwz51ngjKo+JCKvAz5bVe8RkXFT + dBABdgJI+WYhAFVoNPxgFCLBjE2/D/xijPT9LzA+628EsjdCUObaG9lshnLZJLAtlYp95HTUgQze5P0e + fxAXh8BJBUMg6tCgq6/LrLk7N/6E91/EFgnEwhQGAThlTLEIwFIArtu/WCxSLpe7Di/WOSIY3Tf4Fwej + qlPiqIUodU1oYTL+5IzhC0uGVQ8FwAPejEmn/W7gtzCWiduYQAyeGm9Iy8osAQ+q6sswMo9FYDJ4y0e1 + a3LDrbG0tDiQZOPFBFXj02/n9eDggLbhAa5F9T/w7DLGQGvqONnGYDvh71utNnt7exwcHOB5XjcLtY0z + WCwWyecLPkme6wV+cdzQPXlvZA8YuJ27YzK/XHUOOjjFhxdzTU9IdmGp4/RqQB/aGP4a18cm2m6/vEy1 + 50ARRAgu76ngIU27yGnKJbEfadiXKMmuqw3HdzPAXwG+FkNdHGLkDp6IlH12Je/zZQOURprbsN1u85GP + fISlxSVOnjx50xAA9Kwua7Ualy5dAkP5XEvx6ZY/L1NR470RKmC7N6O8NIO5LIKIwQYizedzZLO5vjBm + 7naAhBBfafcWaWIZhCCwh/OqGmkpFmcI1FLVThx2dj2zOunBGPTWf1p9085OH/XgQhBHXWhXf6NIxGEE + nVHPQvVl/Rt/HKPzP1ZEt7Kywjvf9U6mpqdSsUM3AlRN9qBqtcoHP/hBnn/+eTCC1lg5iN/XPRHZUeP2 + HX6XWmsQN2euwxTWWIXbsHux0Wj0hdoKquEM1VCgWOxHDjZSVCaT6SZEtWR/r09RsQziZABufj9uXQL/ + z2OE1U6IowAqGIu3UtLkpxkEWOHIIHJQFO30Aiy0O77dt085BKmJtGxFsJ9R7EBUmWHkEkmLEGdPkGQR + F57bcJ+vXLnCr/7qr/Lwww/zhje84UVFAiLGjfe5557jd3/3d3nqqaesBmAZI/xLgi3gn2KyTtmgMIu+ + PGTC37h98QRHpRKiEOQwcxVEDiaQSy+ak5UfWJaiUChQLBQoFIs+W2Gk+5lMlkzGjwyFHZ2NedBP/4dv + +QEZYIDCSEiymsOwuE6I0wIcAHWXXtd/4JjIdFiqVyf+ZJiovWAs2/LkQAS1sZrRbmYfiwjMn0UQ/bKH + YBtp2IwUgsShkE7auoetJ9iXU6dO0Wg0uHz5Mj/4gz/Id3/3d/PVX/015PO5G44ExBf4/dZv/RY/8zM/ + w/LycldwpqpPY4SqSXPSAN4GvM2Xj9hYk/NiXLjvEpG7VfVuNZGjTmEct8bw9+2wB3iY98Mg02CUn3Cm + HstShGUNxQByyOVyfso8MJH14vsYpnxa7diMU1mGRQB+AxU1prvdhvpIKefEDSeNjhSG9F52681kPKfJ + a5AicMkdghTEsNRDeNKTSNJhIK2dfJQsY2Zmhle84hW85z3v4erVq/zQD/0Qzz33HN/6rd/K5OTkDUMC + IsL+/j4/+ZM/yS/+4i9Sr9dZXFxkYmKCZ555BlX9mIi0h5HX+DYD1jhqWVUfC0jisxiz6lngpEUOGKvN + u0TkNLCgxuy6jEOuMux6DLtH4vaDRQ7NZjOBpch3kUKpWKJQLHQ1FNlMZtAWIADtVjtub3oiUgjOdxDi + WIAqhg0YEtLzKsN8a3XNdgh9ahrpGcWEvwkuQr/MwYR8Csoe4hZ+mMOfJG8Ivwv+DpePamtvb4+lpSW+ + 9mu/lueff57nn3+et771rXiex1ve8hay2RsXH/Btb3sbP/uzP8v4+Dhf+IYv5N577+Xxjz3OU089VQE+ + elzqPL+eFr1AtM8F6rbWo+MYe/dFjJ/F3RifDstS2BiFRXDHmAyvSdS6xPV1GDsZW6afpejvU58gMl+g + WOpRDcVCkVy+lzwlGJMyoi+RBzIOAdSIQQDxQpfhkED/xMeUC5RxyRwGyTgz9kzXvLJnPx9EDqqdPqGk + pR6sii0NgrD1Do5nOLvwtCrTvb09KgcVFhYWePOb38z8/Dy//Mu/zDve8Q6+6qu+ivvvv//YEYDneVy9 + epVf+7Vf47WvfS2vf/3ru67AKysrYPj/p4610Zhpw7CodYx5+FOB+fHwA8GICUC76FMNd2Moh7Ni4k7O + +oLaAXfKYSmAUb6LHJhqNzxZrVbrexdmKYrF4kBeAMf+GwkB1Eng5QYn4sV1SBlVehqcIMNWZHAlzrVC + ySD1UK/XqFQOj6x6G8X4JTjWw8NDNre2ODF/gsPDQ5aWlviWb/lmHn/8cT7w/vdz//3335A5f9/73sdD + Dz3EW97yFh5//HGuXLnC/v4+a2trAB8TE1/hhrSdBvy2O6pqI1SvAh8PhK/P+PKGad9M9jRwt5U3YMLJ + nQSmMSxFqrB5R2UV034XxVK46gv2KwoihYAiUiOkzkkjRe0hgSStQPREJuk4+5s1BzyYZilcNo4iiWtP + RAbYirGxMQqFInt7ewOZfl1kfRypP+xBCSK8VqvFyso17r33Itvb2xweHjI7O8fXfM3X8IlPfIJWq0XG + 844tSqA19Ll69Srf/M3fjIiwtraGiLCxvm7zJXxQVRs3QyWZBAEfhTa9ALRXgL+wOn0/0/G4iMwAp3zh + 43kRuRtj6n3aZykmgZIvvBzagM3O57B7IcLuxFnWvk9ai0js5k/UsquzUR0OP0pWDUa1DQaBQDpWwn34 + B+uLNtqIQhLhAywijI+PUyoVOTysUqlUqNfrSTYBR1JBBesIfre8vEyj0WB/f5/Dw0MmJib4/M///K53 + 4HEeQRFhc3OTRx99lAsXLvDYY49180deXV6m1WrtAX+edmwBM+02JhjqTYNA0tkmsK2q25i8DLafgonG + bJPeLPoyhvMYtuKc/2zOL9PNaXHcZs5p2I2w5WscEkgib5ajGkpLAo+KBNJPih10qtL+YZeIeuKQRP+7 + TMakGx8bG6Na7SEClxHTcS1+GNbX19nZ2WHcJORgfn6+KxM4bhdhVWV8fIzXvOZzaDabrK6udg2Brl27 + BvAcKbLRQnf+5zHOUwWMWXDQMWtDRHaBQ8/zWpYVuxmgPZvfYGTqTwcOl4dxnZ/0x2SDzp73/yxLMYsR + WCZmw0pSSQ6pxeoQE2kqDQJoucoNsyCjI4GuspFkSiC5TJp5i+urSw9ro/KWy+VuuqZeYomeCbT9ptls + dn+nESiG2w5CpVLh6tWrnDp1ivX1de666y6yWYOYjpsEV1VmZma7lMDOzg6e57G7u8vGxgbAX4jIxhDq + vzcA30QvDJt1665g/CfWVHWl3W4vi8gVDIKw8Sa3ReTAV1PfNOrByhvoDzz7MfteRLIYOcI0BgmcwbAS + F/x/T/tyiGlCyW6i7E/SGJSFytjAuE5IQgCrQFVEJo7rVtMEct3VRhpOQBWQ9HXHI4zhtRgiQqFQCL/w + I+T4cgpVrl+/3lX7DKshCH+jqjz//PM88sgjrK6ucnh4eENtACxsbmxQrVYREVZWVqhUKh3gj9VEkE6D + 2Aqq+lfpj8EYdOueAy6G5sAGhdkHNlX1OgYhWORwFVgVkQ1gV1UPxQR6uWnyCDUxEPb8vxcwUafsPFgV + 5qyILKqJJ3m3/3dOVZcwFMWkPydOki7ImkbIBZocAQFc9ydzIsx7dDo61M3eFbaNYiaQlnpQH8EkChHj + 1ZVhs8vo76NvaetF5vk8mFXpWMopSkYQZzoc/g7g2rVr7O7uUi6XWV9fZ3JycsjJHQ5arRZr6+vW758r + V67Q6XSuk4L/D4zzszCuwIlzHIBgUJgl4OXB4hjLwoqq7ojIhoisADac/VXgmohc9/n7fRGpqmonEHjl + RQVV7abKw2RPCkyTFNSEjDvhj9WyFHf5/1/ET3SjIZNpx7w1iQlUk4QAbGy+M4MUQGcE0t5ggGG/S6MZ + 6CufumQaJBFXU7RMwdZhnUqq1WrXdXZYiLhVFdg/ODgYu3LlaubEiROsrKxw/vz5GyZzERGq1SobG+td + rYDP/69iNlrO/zeujgnge1V1IVhvcM5H6RqGmihgwthfCM1ZG6ipiUTdjRolIlc6nc4VEbkKrKofNUpE + rB+M3gTkoNrLhLUGfMoiqSiTaXpqTJfJdIOY2BSRCMBflH1VvSQinx3oHcBIHntHIcV6kvrgDR2x0buU + QJJMQLtqy1G1Fa7P2u02tVqNw8NDarVaZPZgl7VfijnaEZHHgN8FHut0Ov/uuUuXXv7www+zurpKpVK5 + ITIAC5ubm+zu7iEiXL9+ne3tbYAHgd8UkU+oST7xYeBpEdkEqtrfma8HvmpwHW5oPIBw3IeH+ouqvSV3 + MIEzVoDlTqdj2QsbkHYTw4JUC4VC28p4bjQEqMYBk2nriNRut7NiUuTZDFhnROS8P+ZNOydhiFMDIiIt + EXnK9bE1SBg9JHXXro/0TkTBX8M7HSXXGVdHVHu928saZxweHg7YCIRvuTgVTvi9b9TySeD3MAlEHvdv + MwHec23l2sv3dncpFPJcvXqVl73sZaMsSCwIhvy/evVqNwbACy9ctj71BeAB/++vYA7Tiqo+j4mK/Bxw + ybfa+14/SIVznpOeHWkMbmGZNSnOY4yD7g6128HcxvsY4eR1YKVerwdlDysYankHE7H6RUuGY88hIZNp + 6Hkp2n5Yti0IkQggk8nYij+NIaH6TvpxqGZ6x17SCwfDDtYvEkTdUmlu+2Adadvy4TLwByLyW8CfYjC5 + BpCSqurv7+/vf8sLV14ozc7NcuXKFS5evEgud8xegSLs7u6wvLwMQLVa5fLlF2w/gnILwdw6F/0/+76N + IUeLwbmMEnLejHgArvo1EM4ec7M+ECpmqYddn+IJRqy+iqEeVv13e0D1xVJtBuwbIsGJAKx9t5gdtoXh + IcbDk3gU8qe7XkP6DQRi+ab+LkmoZ8qk4fl7ZW0gjCTe/gjxABT4BRH5YY0Ice6X/XCn03nymWeeffTh + hx9mY2ODvb095ubm0s9pqjlUnn/+Mnt7eyYU9cqKVf8ljt2HDEZf3v0mLMEO1pWWLUqrdkxjjJXO0nUA + QeUwPPkURkD3ykBxq4PvptIDrrXb7T7qQUTWfOGlVW2qNV2+0eBEAJ1O5yTw9ar6Okx+wJJLL3nkDnZj + IWjiAQ2D21owyeQ33eF2lhN8X4AGh9VD6rWak6Ry1XeE2fkG4B0i8meuuvxNuAr84bVry49ubW2Rz+dZ + XV09VgRgBX5XrlzpUn7PPPNMlxUI9CV2Tl0HLIn39zyPfD7fDZPeddDS4WRQR1G3usqlZFmskVDJNyG+ + LzTeFiaHxR5GtbkqItdU9Uq73bbCyeuquiF+vgsRacJwdjhxMIAARORhVf0RTLLMvgCV4cVqtVpH9v5V + RhPADVR0TDIB11ibzRa1WrXL299I0i208S5gMg99I+a2cPZTVd95cHDwbc8+8+z4wsIC165d4/777yeb + yRwLt6SqrK2tdY1/tre3ePbZZ51zG/UsSa0ZpcdWNW6z+XyeifEJiqWivyYNGo0mzWbvLxz7Ydh5D7Y5 + zPfDCCtD5YKp9M4ArwhSgL7MpALsqOoaPfbChrRfAdZExMZXrKlqJ5fLDcQ7jIIuAvBJjjep6r+jX8ca + Ca1Wi3anfWy56UaxGOw3BT4elkBE6HQ6XRVeLeVtH/zejsf+Dv4/l8tRLpfJ5XJsb28P1B0iid8A/FMR + +V4RqUSQqX8BPPb0M09/3qOvfGXXRPjEiRNHds8UgWrVBPxsNBt44vHUk0+xs7OTOAdRtg5xczW4Vto9 + 4AcHB5RKJWZnZ5mamurKOaw7d6djrDCbzRbNZpNGo9H9NhggxnXAXRRAXL/C3x7VJdgh8xB6iXjnMCHn + g9DCD2nvs+nXMfKGK81m84qIXPUpiuf8907oIoBOp/OAiPxH9RNrpIFWq8XOzg6lUsmPeZYZ2QMw8ItR + SYpREIhrTLVarcvbD3PbR20aVSWTyVAoFCiXy5RKJbLZDGDiuW1vb8eRlgL8bVVdIZCHMNTutqr+v9ev + X/+85eWrjI2VefLJJ5menj4yclY1xj7Ly8t44rGzs83HPv5xVHUXk4rtpKqOJdmrJ7EHSeXAkL2VSoXD + w0O2traYn59namoKTzwk6yGSo1AYvM2DIbtarSbNZotGo+FEEGniPkSte1L/4+e5f+5SUBVZERlXE89g + CXi4vzptAAeq+l3AL0dWEvjiK/B5lJQdQFWp1+s0Gg0Ty8+PeWZ5tpEO44jnP3iA0lADwY1nbvsm1aov + yW+1TTxCH0bVR5vbPkupVKZcLpPP5/u8s0RgYmK8q0WIgQLwD0VkB/hPmJwN4bG/s9ls/v1PfOITS3ff + fZ5nnnmG+fl57r333uEnM9D/SqXC008/3TVf/shHPmp9//8r8JOqehF4tap+Nka/fhbjUtu3LmnWIs46 + MlyuUqlQq9U4ODhgYWGBQj4f2ZYNCJPP5UDKobZ78R4s5WCpB4sgun4dnXY3eG24/1Hzl3bfjBJHIKaM + iAkDVsNokiLLWgQwiTHOkFAtsVg9uDB2kqrVal/EEksZpPVOM7I9BWEIu/5gnyDp8NtxNZtNarUatVpt + 4LYPIsK0ixIUXPXd9pmMM4iqquJ5Gaanp7sbLwbGVPWfYcxYf04Ccff8Pj6hqr/33HPPfdPKygrnzp3l + 8ccfZ25ujrm5uZEQWKfTYWVlhfX1dTzP49lnn+Xxxx8Hoxp+K4YXfUFE3o2RFz2kqj8BfHEcNZYkkY/b + d8H/t9ttNjY2qNVqnDlzhlKp1L29nbdyIGKN76uLiEcmY7ItG+rBvjVWnoZ6aNNqtWm1mjQaQeTQ6CKN + YGg5V1+T5iDN+owQD+AF4Nm4Oi19+Brge/EziMQ1HLeIFiy5Va/XqdVqXSrBTo69BXv/jxt0d7mGBte3 + nU6Her3O/v4++/v7VA+rtFqtPuybhI3dG9sEDxkbG2N6eprJyQkKhYIJA53gBGFTU9VqtSQDoRLw+b4s + 4DH6M752RKTSbDa/ttNpF++556I/521OL50emhVQVQ4ODvj4xz7G9s4O29vbvOtd72Jra6sB/EsR+d3Q + /DwkIj8sIl9KyGYkPF8iEtuf4N5IA41Gg2q12pWrRLcb2g+OSyY8/cEQXDYb1sTEBNPT08zOzjI3N8vs + 7Byzs7NMT08zMTFBuVz28wRkR2KL48qnqStQ5j0i8ku+BaETbF62OTU2xk44ipWWFabZRbKLb7Oj9kIi + 99JcRw9yCCv/QB02hJJFSNZKT0T6SP3g2JKccizYePA93j4bwtS23/FBR8bGxroylYT5nlHVfwWMich/ + wJja2jb/FHjvU0899bX333c/D7zsAS5deo6TJ09x7733DrURa7Uazz33HCurq9TrNd7//vdZu//fAv5H + oD8F4KuBH1LVh+zcxyHNmZkZpqenaTQaXQrMJhYNzrmLKoi6eKxr9F133dVFAoOUAP0eoylMxpMugkwm + SzY7iHR6sgdDPQRZC3shBuUPQerhqHYPAfiIqrbiLuus/+IKxtRxdpjaXYOO4/3s4toDab+1JovB1Mn2 + //Z9j2pIXjCrOrLpn+r1eqL6Lu2Bt21kMpnujdC96UnKLkRs/ycnJ+l0Ouzt7SUJxyaAf6Ymnt2/wjiy + 4Dux/OdGo/EFH/jAB2bm5+eZOzHHRz7yEZrNJhcvXqRYLCaSpoeHhzzzzDN86lOfolar8ed//iE+9akn + AD4B/AuMuSkiclFVvxdjrzAZ7GvYbsT+npqaYmFhgWw2S7ls7hy7H2q1WlfIF6YY06zLwcEB169fZ2np + NJ43uCfNAwaMz5xzHaIOXCyNEyEFVEw96oHuWIPfmgxZ7T6thUUOPflDk1YrXrUZwU5UgI849k74WwHj + 7feHwH2uiocVgkVhy2HrCP5FpWa2Awz+hUN9J/VvGJVVLpfzs8uWYlNzJ922UWyV1QocHByk6XsH+APg + +/EXG2OZ9uPAd9178V6+/Mu/gonJcXK5HPfeey8PP/wwExMTEUK2Dnt7+zz55JM8/fTTHB4e8vjjj/MH + f/AH1Ov1deCbMSnUp4GvA74HI/hLRVpMTU1x6tQpR9o4f70x57PVanJ4WO0m8hxGBet5HmfPnmVmZiZQ + +SCp72IPo9Yk/rernv5nsW35fYvTXDSbTZqNBvUAgrAepkEIndVPYJLVxuZpzPidaWFytUeKjMOHLg0c + lfcJUgzBSDsuSW1QWnvU3ILhcdrbfnJykqmpKUqlUiJvl+RlGPXcChBVtc/SLqoZjH74izF29s9g7NKf + AD5ne2v77O7uDmfPnCWby7KxscHW1ha1Wq3bjud5VKtVrl+/zqVLl/jkJz/J5cuXqddrfOpTT/Dud7+b + arVaFZF/LiJvA74C+FHgOzHqp8hJCPLyM9MzLJxcIJfLRs+Lf1A8z8z3xMQEExPjiEhqAywr3J2cnByQ + M6Q7vKOUSV7jJOQSpj4tq9yVPYyNMTk5yczMDCdOGKGu74kZ1fbbMeq/2INgEUATY6v8RcBEcOGGgWE2 + uwuZRE1YVH+ShCXhNoZBYPa2HxsbY2pqivHxcQqFfKi+ZFfi2PYiNB2e53VJ9TgkEKh7FngTxoBrGeM5 + +CngDZtbm7MbGxssLi5SLpXZ29vl2rVrXL16le3tba5fX+WTn/gkT3z601y5coWDgwMa9TqPPfY473nP + e6hUKm3g14BPiMgPYtSRL8PXIEXNqb2JPM9jdnaW+YX5vps/7aHJ5fKMj09QKpXSaEoAE3Ytm80xPj4W + W79dw+NBAqOVcY05DaytrXFwcBD1ugX8R+CxpPqCKPIZjLfSG4F8mER0HSbXQNIOZpRBDykBHaktezNO + TEwwOTlJuVyOve3TqR2jy0QhEc8TisUimUxm4PYLayp8yIjI/cBXAg+LyHPAB4HP2t7enl65tsLc3CxT + 09MA1Ot1Njc3uX7dbKS2X//mxgbv/8D7+eAHP2iTUtQx/P3/gTE2yYe1OGFWwkIul2N+fp65ubmujCTN + 3LjmulAoMDY21qX6kqDdbjE1NeXUNoxC1qctl0T+p2MP4su0Wi2uXbsWNw/LIvIjkiJGY18QQhH5hP/z + 5Rj3RysjSFSFucoNyzIcJwzLqgze9oXUtgujIqbeO6vfCJeRbo64YPAJl8wi8GwMeAXwlzBpyf87cG5/ + f3/hueefRzsdJqemKASMtZrNJhsbG3z0ox/lvX/0R1y6dIl2u4twchgKIxfd/0EKrVwuc+rUKSYnJweo + pnS892C5bDZLqVSiUqkkygXa7bbJs1cqOeoeHRElIYFRKAEr3E5Tj4hxxV5ZWRlgiQLr8AHgv2EogVhw + 7co8BtN/OYa3fEREZjUivVCSxdewwr/EDo9Yn6uf9ra3OdcymQxdSVRoltIYJcXf9KMjCRETU9DaLgS9 + MKMQr/9sA8PWvQ74aUA8z2Nubo6lxUXGxsdpNptsbm6ytrZGpVI5sh17JmMMm2ZmZvp08knjTKOjt99u + b2+zvLycqHWanp7m3LlzvkZg1MPseja8TOA4WAYREPFYW7vO008/Ezf+fwD8RJqzErsrxUQDfgB4PfDZ + GMRwRkSmVNXKDyIXYFQY5ZCn/cbo7bMUCubQx0nywzOVDgkML/1P894+r9frHBwcUK32GzC5yqpJ1f0G + jKHXr4hI7jjWyTXXnudRLpeZmZlhbKzM4A0XrgMgzaFgoK52u83ly5epVOJz1xYKBS5cuNAVqh6X5N9d + JtzP42nL9c2lS5dYXV3tex9Yj1XM5f0YKSA2KKia9EkfEpEPYWwGZjEqw28DvjVQLk1bzsGnMZdMc7jj + 3lt9rL3tc7nc8E4yKYxGgv2IKpfssBRtLCRiQo8XCgVarRa7u7vs7+8NWK8F5mJTRPZ9SqCGT8anuhkS + 7DmC5YrFItPT04yPj0emcB/U8ARv2OCzsI6+v5y1wZiamuLw8DB2HNa2wIZrHzAEIl6/P1yZ/r67bD5G + aSu8n5rNpk3D5lwfEfmgqqZK0ALDJT5sYQIjrmH4yq8DTgQ7YA9Zu92m027TUY21boqzY3b9mxas3UA2 + m+06J+VyuT6e3kUyv1hwJCRgOkwul/PdYd0H2q//upoIM5cxxkITaeczUXiUyVAqlbrZkezB721YYMiD + Fj9f/fVZ4Wyr1YpEaNbsu99QB5IMgVxrMAoScJdxUSJp+mPW1LqnR0Ab+B0RqaU9M6kQgAM+AfypiHy1 + 7bDtoL0Fgmm1g4EaXOm2XQc9jf19UDvRNS/OZMj4ZsbDOCGlh/hQ4MPU4z7kvfeuNuxX1gHLNVeBOVwG + WiKyrqpPAfeOyl5ZpFooFCiVSl0LyKj5dY3OeYgI38j2axyHq1ePdTaLYoMsNBqNgc64qI/BQ5h8mF39 + d5VLQy0MmokPtg2wt7cXF4nriqr+0TBrOzQC8DfQIfCbqvrlwTra7TaNRqOLnaPIQfuvNfLpRwQm6Uhc + +3Yzuv4/ysHsLVCyr4Hda0m3V/J7SDJrjqvbzndCmWX/Zw2Tuvsrh2nH8zwmJye7AlLru+GipAbGEcEy + uUxzlYg6XHNqCnYpvCRotVopD6ldD+g/mMR+50IuzhdOBEPot/1YnPuj3Wqxt7fX/e1A5h/AjwicFoZG + AIEJeLeqPgvcH3xXq9UolUqJwiz7b1peXPoroSeqd7tVDnuwrP03KclS/ytX71xzlWY+3X2KGIs1eY6B + johYBICIPE5Enscoft9K9PP5vPN9mr5Gkc5OTzxc/Hn//AaPUZp1ClqFpumHS+bgZmd6z9xlBg+4WyYQ + rMeOa3D+RIRDPwlteM59qAG/iUlokprKOwp9fFlEfi88qdYk97hBg39qyHDzN7pw0NnIMH1SSKYYkh2M + kvtoR94Dy1pZcEiP65iYcbYPn1ST+SZcLrKPloUKvw9Sa+nmyVEuQOoHn4W9M91TM5psyNlnjSoX34dB + wetgZWnkXq7vXN+oKjs7O12ZBwys+WMi8kfDsngjIQC/Q4phA/aC72yc/JsNPS+0m90Ti9FHRwIuRBMO + PtHfnqCqFVVdC9T7LPDhwQ0Y3W7PAlIjNnPUONIJfJ1NpzyQYQQYBS7tg3sOBp/FyaRcnT0uJDDoF2Ac + pMJxGEP1/Iav7RkKjiQhU5MG6k/Dz2u1Gp32TcvaHILReey0ZZNuw+OgVsLvrFAVBnlB//87IrIVOABV + 4B0E0mknkdDWRqKfr03uc29Dp9M2uA5kEqJq+05hSeNIy2KmWfI0t7f7Rk+HPKLXXzg4qHTDxjnKXQZ+ + J+JdLBwJAYjIPvC/RKQZXIRWq5XKXvvFgdFsFMIaiuTyx6Nei0MmqtolkW102xjYVNW9UJn3iMiVuI+C + 6xgWskU1F40EBnnu6D6nuSl7v2v12oAWxIUIekhs+Ju5168wcg3+diOGfoScXMY1D7YtS/7HUDzvAp5k + BDgOHdm7VPXj4RuoWqsOjY1uBNiJ7h2e4fs0LEVw1DKxr/13QQQQUd8qgbTQviDpkqr+cRojHxFxStmT + bDfCz44bgeLXub9/MMAChQWOIkIhX4jsYxpKw1JvSX1NR+on779BCkKo12uRYdhFZBf430B7FJX3cSCA + FRH5lfBDG4XnloIUQjsXDCtHOA7El8QOpOB/VzzPawS/UZMF97dxhxYfODxRaraog53+sKenBAbKinTN + oZMgk8mQL+RTINzhEUNUX5PH3v+du63+b3Z2diLlaqr6HhH5MxEZKWHNUWUA9t/fBJ4LbqBOpzMQseRm + w6gCwSAVMezcxL1PLBNzW6TQtFz1c8qHn/8Bxrw7ts+qgVgERyDb48aaWjAY+mZnZyfycgnWaa1A0/Rl + WBbE9jXplncLGJPn0tbbajbZ3Nxy9llMCLifV9XDUS+dI1MA/s3xNCZYZN+Gs4EebxUIGvGMNlYYhoVI + w3LEIgKNPlAuCiAw9x18I6B+abKAkQ38AjGuopZntp6HajsTMZ+u/qWeo9SIwTyrVCrs7u6mqrtcLgfS + Y4cOWCrh3WhjS8MypBUC7h8cRDo9qer7gXenmowIODIC8DvdEZH/AVwLDsLkCbj5KsFwf0VGQwJp9P79 + H6Qrn9yfQRuAhAAhXRuA8Nj98m9X1cftt8F3wf/bIJ1CtCbgOGQCaZ4JxsZkfX091aWSyWT82Ie2vsEp + TafvTyMn0ERKIDx3vQMf/V2n02FzczOK3asBPy8ie0cxSz82Q3kReVxVfyP8vFo9vKWoADCTP+qkDStM + HOXGcL0P1hNEABHxACoYp62oPq1gzEb76nBZyu3t7dFq96Tt6q5v5LHHlQ0+a3c6rK+v92VQijP/LpfL + FAvFvrnVlGT+cQhyTRnX7zTsgIEEaueDIvJ7w85zGI4FAagqnU6nDfwcoZvH5toLfXEczR65zyP3I6Ve + f9i20gqrwjHkHd/tApsxVXnAVNgK0NV+vV7nYD8gcIsl+49fJmCl/ltbW87D4KrL8zymp6fxMl5/nzQd + teEaaHopf1KZqLoHqYONjY0+WUcA0dWAt6rq1lEFzsdJAeB53mMi4qACqrRbQTLmFjDPIyzcG91eIG1b + KWuMfuVPW5INgG8RthddESXgXFwdQbZid2+3z64j+gAPc8DcYx04MBgp+ObmZkrJvLn9x8bG/H4658ch + A0gr4EvobyRZn1R3/9wfHh72qf5CVM4ficjbj8ON/dgQgKUCVPXnRKSPCmg2m1Rrt5ZGYBBuPFJKhyzE + 3HpOm1jzTxgBODbCdQI2AA6YBE4l9dW20Ww2u8lKBsczGk9vnkW23v3f/v4+GxsbsWbPwfFnMhk/CGkm + 0I6jnxGIwd0XTVEmflxJMoFg3arK5uZmFNI9AP6Lqu4ch7r5WJ3lfSrgo6r6v8PvDg9vPVlAEI40mcfA + 6/a5RUMsqR2kpiKcP65h8gREwQn/LzXYMGRHGHoMYnAfoMPDwz6hX5TqMljv1NTUQBaeqH6mJ9nj24wi + 65PqiqKYbPrzCHgn8PvpZz0eRg0I4gR/0G1MRNKvAi7ad61Wi+phlYnJieNs8lihJyWHXnTQFBFrzMep + BYvWYs1GrLHI0cY2sH+5XI58Lkc2m/P5WX8u24mI9JoZR6Rn2CImvVhqaLfb7Ozs+GnQ+u3rVaP8/u08 + JpU1s9ivQq6xtrY2cAtacI2tUCgwOzvbVf0lufHG990VKyA+voMr96PbxTm6vY4v7Iwwpd8E/jMm7dex + wLEigAB8Cvh/MHnruqM9rB5SLBUjo8XeKmAW80bWr1SrVQ4PD6nX64nkbTabJZ/P+xlnc31qIccBVxw2 + ACE4SyATdNrArrVajb29vf60W4F+pIn71y1rGnbW0Ww2WVtb6wqPg/2Lcl+20Y7z+XyAlDbTERVZKL7v + aeP3QWxkH2UgMIrGXBaVSiUu48+vA3/MMcJxx8sKwi+KyEf7Ipq02yOHnr45MHxQkaSxtVotNjc32dra + olqtxppvWtag0WhwcHDA1tYWG+sbztshMM9OG4BQmbvs4OLiAYS+6aoFo92905H4vZIhXb8f8XdjY4NK + 5bCvjjhNBZjEqpOTk8623H1K+yxZoJdGv588V2at19bWoqwcnwX+E/Gs3dBwIxHAFVX9aVVtQG8j1Wq1 + W8hTMA6OoCaM+a5arVKr1YZGgvagttqtPhsAx01SEZHrUTeMZzxG7u72NIXqMezpub297TROibKmi3/e + A2v4YqPepmWpisUic3NzPumfbHUXNe70gsrhpPq27rDcoB9RCHt7e1F6/7aI/LTneZ847gC2NwwB+Jvz + 14H32AmwfO/BwcFIjgs3A0ZREcZZedXr9aHq6u/H4LMgWezDoapWo+pQ1RJwBtIfsHDb1Wq1LzZdeOzD + zFew7t3dXXZ3d523fZSxUiaT4cSJE32kf/jbYdSTaQWDoxsLuRFFs9nk+vXrUSbe7wd+Ia2R0jAwZHD8 + 9OBvyhpGJfUVmFRjgMH0mUxmwFHjVgWRoDhwFG9C802r1eqm/U6TICRtoNPQ+xLwCCaF967/1wmUmwf+ + HjAfF2k5CZrNJsVCkWzOLUZKigkZflapVNjY2OhLfxZ8HzBj7ns+MzPDzMxMRL2QLvmIu0/H9SypjIiw + sbHOxsZm3zO/zC7wfcBHj/v2hxuIAALwArAgIq8NPmy32+TzBT9p5G0AvlJg6EUIBJ2sVqtdVVrSQYsS + zKVoP4Mh8d+EyQ/4ckBFZFNVD0XkvIh8GyaH4ABks1nK5XJitB0bkss63ESPw05e9BgajcYA75tmnsfG + xlhYmO+2n/aAhgOBuvqYtu/R36ZHArVajeXl5Sg1+c+LyE+JSPtGyM5uOAIQkY6IPKOqbwRO2ueGBVAK + hcIxxNi/8WC7OFJffeRRqVScAp7wbXBcXQamgEeBrwW+FDghIucwqaP6VDG23Xw+z+zsbKrgrq1Wq5vK + PA0yG5xPwxJubGz02fingVwux8mTJ8kHAn5Ezp8jAvHIN3zKusLPo6gRVVhZWemyVKGL4ePA9xDj13FU + eDEQAMA2Rjr9ZkJ5BHLZXCQZeSvDKAe1XquNhACGIacjIAecxiQKfQNQlNDH9qdNjZ7P501sx5DXYbjd + ZrNJsVgkm81GsjZxm9/y/cOA53nMz88zMTGBy1YjfR+Ok8xPW3+vnIiwu7vD6up1F29fAb4fX4Z2o+CG + 098B3u1XReR3gpPT6XTYP9i/pS0EjwtEBC9gQBNWrwVhfHy8m6I8Kr+9yxAmBUIQjIwgsmA2mzWhtAoF + 41CTkE6t1Wqxs7ODDT6S3kdAqFar7OzsxCAOdzcnJiaYnJyMtfV39SFdubR+C1GCwbAgMlo7UK/XWV29 + HuXu+78wev8bCi+GDMBCA3gGQ4p2LUnsDXP7sAIykjxARCI8IwfLjY+PMzk5SalUolQqdRFBlD48CiGk + Hk8AbPJRESGfz3etFeOg1WqRy+W6SThNvRB3I1p9/7BakUKhwMLCwkC4svS39GC/ossO/yyd3MCs1erq + ahT18wnguzFxHW8ovJgIAIyBSgv4EgKsQKvV6qadut0gLRKwRi5pciZks1mKhSJ4Rs2Vy+UolUrk8/kB + 46GIeABD9StM0tvU45YSaLVaiVRap9OhXC6n4ntB/MzG+wP1uNgM+3/P81hYWHDa+ie1l7ReN17q3+uH + If13WV1ddSHtA3zS/8W4EF9sBADwaeBe4OHgw3a7HZts8lYGi9FjF0x6cRJdKq0gZLNZSqXSQBvtVouK + nxI77tZPu8ld36uacGPWR8EinATvQzqdTtdUub9cP48uYoJ6bmxudHNHpFVzTk1NMT09HduP9M8g6aaO + m7fkMtH1NxoNlpeXuwZxgW8V+BngP2Ay/d5wuBmnbR/4N8DT4Ztnf38f7Yyu6tCRLfeOCikyECl44qW6 + mdvtNuowlGqHDqIDtoEnVbWe5OsP8cYsVkbTbDZpNpuRRjYWOp3OAHUTVW5nZ4dWM9rDL0wFqCr5fJ7p + 6elY2UnvWRo/flKVc8GoxkLqm/uurq72aT0C5d4H/BiOqM03Cm4GBQDGOKiKkQfk7KK2223Ek5ENhEY1 + 1DkySLq2Fe3eqElqs1Kp1EcN2ZuzWq0OHOBAXe8FvgH4E+BQRKZEZJJjQvRJyMvKLAa/681NrVZle3s7 + UoAZJdw8ceIEY2Njjrqjbu3B9RhFUp9cdjjqYHNzk42NDRcSuQp8F3Ds5r5xcDP1b78EvAr4djtJqkql + UhkQKKWHmyREVFK5D1p3Xxg8vFEx/7pNaHQk4MC3yyLyHHAJ+C1VvRt4g4h8haq+FjgpIt6oBiVJ30Wx + b9YDTzsd9vb2E2UYYSiXy4yPj8f2KXxoXY7cTk9AZ+rwqOVM6R6ubu+/SqXC2tqaywy+Bvwo8P4083yc + cDMZ7iqGFfjjoHS73W6bQJS3mWowzaIFEUDct9YLMAwWAcS0tWxeK6raymQyzwD/HfibwJuCatijQphM + F5GAytLdv2qtNmDwkxR2y/M8pqamnFmK+78LP0ip5hvKT4DEcr3f/TKTRqPByspKlKffL4nIz4rxJX5R + 4aZK3ETkBeAH8f3XLVh5wO3iMNSD4OK7hHPgBQ5MtN5cabXaA89ccQAC3yuwHKwvUL4uIp/C2JU7+pVe + a+BqX0SYmJigWCzG6uYrlYpzTV0CVPt7bGxsQOo/zA15nK6/UeWSPB3b7TbXr1+Piu//XuCH1WRzHmoN + jgNuKgLwB/xHwI+KSJ8EqVardR1nUtZ2M4fij8eOSXCTioJEGNaEwQRZ7p+rOIQoIg0RueY6yP7NWVbV + s47vuv3opQNPD5lMxnfImXXE4euByRHR84Nw9THcJ8/z/Nj+8eVD43StDOniBEA6JDD4O5oyMdF9w0E+ + fKT7FPCPgCs3ywbmptvg+mTP/6OqjwJ/xz63N4Z1TklR080eShf6N3N/38IygChohw67Sy4Q4p8PibcZ + nwIWo0hWEWF2drYrbLS+ADYNuUt1mcvlmJmZoVQqRR5SO35rWzA4P9EygCihYn/9kvjcVh0sGik7cEYR + ShcxaFBGoOzu7rK+vu4a36aq/hMR+fMb4eabFm46AvAnsiIiP+QLrb4o+G5/f59MJjOkUDBOWJNOkHN8 + 0N+WJ+mIro4f+ddusijBIHRvzF1gI6bKeWC2r2eh2z+fz3dtECzF0W63DSJotcCXYViWIZfLdfX+0YfR + zPmhb78QbDs4hvC4rEVkvyvw4HymRQL+04E1SRv+bZTYgZXKIdevr7qEt3VV/bci8rbklm8s3HQEAN2J + vILxe/5F4AHoWc/t7e4xPTM9hKWgjPjuho2tZ7zjRau7gmBv3a6KtNNOuiW2iM8FsASMR7VrA5F2Z8kX + 6g2DfKN4+Ua93mfyG2fAZJ/n8/mB2z/qsEYigYGAnLad5O+HeWb7HoRarca1a9eo1weiX3Uw8TJ/Sk0A + 3ZsKt5rZ3V9gzCDXoTe5zVaT3d3d204z4IKgwC2O7wuThZ2YdOB+uetiUoJFwVmgGNzEwfot/+8iR+2z + 7rsYROQ62I1mwxnoI+7bYrHodISKIpedyDGim8cZHciMKTReX+IfkR37N0Tkn4tIcn7zFwFuGQQQmNjf + xqgHu0JBq0bZ29uL8py6pUFVu4RH8PBFRbkB30kqKNFvJVIAKxhpf9T7u+M+DjvXxLWlCe/DHnGNRs+S + MA2/aw2heqbEEXOa8pnzOSmfDWn1ZyX+BwcH3bEExvUe4PtUdf1m8fxhuGUQQAA6wM+IyH8hZA9dq9Vu + oHpw+Nh/UeA8gyNUbQ+aqg4IBU07fQ1dxbcBcJTLYCIBm3odpGw2mx3gjpI3abJO3iCAns17lKVcWLhY + KBQCKsWjqf2cz131xtoEuKmi4Bja7TZra2t9Hn6BMo+p6ncDz6UezIsAt4QMwAGHqvp/AQvA3wxOtDWF + nZiYOGbHoeH14EEhWbPZpNPpdL0as9mYPlUbAAASx0lEQVRsl6y2wS/6Wgvwuy47e7vBbLkg5RMhQFuO + 2fxl/ECgzpFbIx4nFT1oKderN1qAZvtu5yf4LCwDCCMkO3fBdsKS+eD400noTR1JEn9Xud5YnfaFgBnn + +vo6W1tbUWa+3wN8bFS37RsFtyoCQES2VPX7MLEDvtw+V9WuNdnkxGRXqPZiQqPZpHJQodls9KX0CvS9 + m9nHuvKGBZhRmyDIh9sycRoA/5s6fjagiHqnCIRjC5fzPM/Jb5uCDCS2CNcTx9e32+0BA6Ykvb4NSuLs + DOmeuwV2pmx6aT4MagwG27JhzVwJTP31eSfG0eeWOvxwCyMAABFZBr5XVWeB1/jPukjAUgIvlhFFp9Ph + 8PCQSqUSK4uwN7b1/69Wq0xMTHbVa0OBKtrR2OxBGIopzgZgQAUYhLAGIGpMoyCBjsODMUoQaSEboe2J + O5jRB7u/7PBbZZBqCCKBTsck8rSH3zGulqr+EX5k5lsNbkUZANDHY31aRN6CSTfWRyJXKhXjQvwiYNVm + q8nOzg77+/tDCSJtJKDd3R329/ecpHx43KEKaHfafQggTEqr6h6wEYMIl4CJKHPbNAjAbzmBx04nWAuP + M9wvb2SEnt5qz20Q5RLuEVmnqna9+4IenmHWDPjzEQd0w+GWRQBBUNU/B74TeDr0nEqlwt7eHp0jxBFI + glarxe7O7kgZfYJk/MHBwUip0aIs8QKwBeyG6w2UPQcUws/DJsDJKr7+MbneD8gzEsxk45BgJFKJEAxG + meSmRVrxyGFwTUws/17q8giNw/u4xQR/QbjlEUBg478X+C4ReT78/vDwkP29vRuiHbBBL4PpzEZlOYLC + vKToM+H4eWHnm9DcXMeRMTawGe8K/g5v0kxABZja8yKlLUASsgsKOy0EEV70oY452CnVecNAn02Gn8F3 + Y2MzKbZDFRPYs3mzbP2T4JZHACF4F/D/xSQb6YKqclg99CmB40MC7Xab3d3dgcOfRo/t0u2H+xwk5aPq + CGsAXOWAFRGJsgHIiMhdofJ9kHWk+z5utioO4YXn1OUyG92foxoADTcOq+oLSvuD6xga52P42XxvNeGf + hdsGAdhJLpfLvwP8feBa+LY8PDw04aaOwWLQ+iGEo9bGLWSIL+8+S3MLhv9v6jLLE5YbOEjUZaIv77Kq + RuYC7Pfjd/UrncFP1Jis70Bq/TwGAbiTj0bx6REGQEMZ9oTZgUEkaPP32VDmwTl01N8BfpV4/4ybDrcN + AoAezw/8FvAWVb0aJodrtRo7OztRgRdSQ6VSiXVfPSrExQMA/+B40rU3CPcjRM5fjUEy05hIQJHtRKoA + E6B3+KIRQSaTGVrD0Gw2Y8KFD7EWQ8gEogV+5mGjUWdlZaUveWm4XGgcn+BFiOt/VLitEIAFEdFcLvfr + wHeo6nPhBWk0Guzs7IycibdWq3WFdWns9i24yPr+G91tyOKCTCaDB30IIKJ8g3gbgHlgNoqsT6cBSKJg + oufDhWCStB9WYDqUaa/jFh8NBgWp1WqVayurAwE9XFJ///8d4H/4AW9uabgtEYCq0mw2efWrX/124Fsw + ocb7oNk0aruwG2oStFqtAVWfy9DH9f9wH4NlwnUksRKFfB78yLxhFWCwnIgcAmsJKsBx1/eQjACSJP9J + 4/E8L9bPIEoGcnh4yOGh05kmsr3eLZ4sxe+tRwxLobC3t8fKygq1anRfgmPx4RPAr9yqfH8QbksEYOHD + H/4wwB9ikMDHw+9tfMGdnR329vYMRZAgvT44OKDZbKYKVmnfi5gEGtaBJU7HnQY8zyPnR0Z2WQEG27Y2 + AFEqQBE5KyKR/rxpogD1qk6DBAbL5HwEEEacUd6Hdtzb29t9AlhHizH9TUYC/WPrn7tOp8PW9hbXr1+P + 9GUYtCBUMBTZT90Otz/c5gjAgoh8QET+DvDB8DubjOPg4MAY8hwcRNoMBNN3x0HYjHZ8fJyZmRmmp6e7 + QSxcZQP9jT101pfA9j8BCW0REevPh/NxrIwlz9PcVmkuNNVBNVyhWOwG9bR9cB38MIJoNOpsbm5GIoFY + VWAEP59GJtBsNllbW2NjY6NPbZvSRuD3uU1uf3jpIACAD4vI3/Yj32rgeRfa7TYHBwccHg66zTebzS7f + mdZhw/M8Jicnu45JNopN0FEpjt91vfM8ry/FVlga7vhmjWgbgKyqngu26XK86f1MgwRS8NndG9iUy+fz + 3VwPaeMBWKhWq6yvr8eycsf1HIz8x+bsG4Zl82ED+AlgJ3EibxF4SSCAQGbaJzHswM+JSDMK2x8cHPRl + sel0Ouzv92cpTiKL7eEPxysUEcbGxpiamuqmzE4SZgVv52B0Xeg3ArLfhWCF6Ewy6bwAw/1KIfRLZo3A + Suw9z+tG90lrYxAsU6/XWVtbY3Nzk3q9niAEHBKk5+OxvrbOysrKQOhy17y5ugy8Fd/p53aBW9oZaBgI + SMpXMJlV6yLy7f4zoD/YxsHBAdlslmw2S6VS6dMYpDH0GRsbiwxYaQNaZDIZ9vb2EvjYXnvhENgpjYCW + gU4EOT2lqiej2rMIoCfoswWsByDEq9009ftSqTSAZEN9jZ33TqfD3t4eh4eHFItFyuUyxUKBjO85OOjn + EN/3TqfTzdZ8cHAwkHQ13L8ky0cReTcmp1/rdiH/4SWEAEKwp6r/E/g/gKkg/2Y3SqPRYHt7m0Kh0CUv + XRvRtfilUonxsbFEKsHms6tWq91Iu66DauPuheUH4PYCDPVz2dW2/26BQCr2MKTRAMQNMc1766Vng43u + 7+8nxgOIm/tWq9X1qbAI3LpdZ7NZP/8ixohKfDVqu9N1qLJemu12uxv5OEoWkeSrEIArwD9X1dVb1eQ3 + Cl6qCACMKuZTwGujSGib+DL8zhWswz4rFArGBTllMJJsNsvExARjY2M0m01qtRqNRqMbhbcXPMRj0M9c + aXfcFEBA4nwtpvk+FWAYRskD4OpHshahlzykVqulNvVNunXt+oUNtlz2FmlvZRdySoC6iPzbQqHwx1Hs + ya0ML1kEICLbqvo+4LX+b8B9yF2/w6Cq3cM8iuWc53kUCgUKhUJXZpHm4CRkS66KyGpwXCHo8wIMQzoV + YKwXYrdMMiJRcrkck5OTXTt615zbZ8F3cVGE++Yqwtkpyggr3Iar/hQH+ldU9WfDmZFvF3hJCAFd4C/c + 74vIfvB5GjI/ymJufHw8MnPxMJjfagySIGgD4NI/i8ieqg7YmgfK3hXxHDgeCqB//NGCODs95XLZKTgN + z2OcijDcblojJVs2qo00xlohKuN9wD8HDsLGTrcLvGQRgH9A/kJVPwqDix+ENA4+5XI5NkvNjeD9+t1i + nZ6DWyIyYANgVYCEEEC4r8NQMmntBOKKWdPgyclJcrlcLO8f/HeUdRu27DAIx//3k8D34vv6364h61+y + CMBfqB0R+U0c11KUy66LVHQL6G48hDUAYUGmqq6p6kEEyVsWkTNRt6uIkM0Me2uls7dPYqXy+Tyzs7Nd + JBA2VIq6oV2QhpVKA2F33oS2rwL/QET+4sgN32R4ySKAAPymiDwRfugi9+J4Ppe0+EZD2AbAAU4bAH9s + 0y4VYPCgeRkvWD6Vbt9Y+h0NVJVisdhFAvZZEsTFVUgqnxSPIFxXDGK5ilEz/97tJvBzwUseAfjegj9H + iqCMUQtaq9XY3t5mb2/vyG7GwxyfjkMDEBJcLYtI1LgWRGQmyi/BqgBH2sSpTILjDYpcSMA+j/vGNZY0 + 5eNUfVEmvo6+XAK+Q0R+I90s3PrwkkYAgQX8WUzGodTkYvj2aLfbVCoVtra2jogI0rVvjIDc2YADY3Pa + APi3V58K0CUA7Jor2/cCafd1krUgKaqySGBubo5isRh5Ywdv47ROWlHzEpq/yPcO+DTwrcDb9aVw9fvw + kkYA0N08GyLyj4B3Aq2EhW4ToBbCG8/6E2xtbXXDhd2I/aCqsbkAgKaqLmu08OouVc1HCdKCGgC1dVsS + P6W9f3oJfPytXigUOHHiBJOTk07npDjJfRzEIY1By8FI9q8tIr8rIt+QzWb/MHXjtwmMFgrmNgQR2cTE + FNwC7heRqdAmaIvI08CPAJ8UkQeAUpSuutPpdCPXtFqtrkXfcQkKrX26Sw3owwHwMxiedKB/qvr1wOui + 6i8Wi4lZf5NNgXvtJdcTXZcwaCeRNvR6mvkOIoIh12cH+PfAPwaevTEp6W4u3J7KyxHAP8QbwI9jEMEb + gVdgLLmeB55T1Y+IyLMYL7rfB/6Bqr4ByEfV2263OTw8pFarkc/nuwdr1DBbFuICgfiwLyIbrneq2qcC + dCGxo/bPMbcxqrMEk2FbCIOYcrmcHxDkcMD5J8qMOK3sIMrkO1g/xsLyQ6r648DbgaMKfm5Z+IxBAAHo + ZLPZj7VarY+JiCciGuTp/P82gXeJyIdU9W9gIhE/gOWSIwJY1Go16vU62UyWQrHgb+ZsN7jnUJ0M5QJw + tBmXC2BMVU8HxxS2ekuDAJIO7mB5jUUCJDgYmW+VTCbTNZ+u1+tdZ50k9960iCDK+hBoYVLUvxUTd3I9 + rWv47QqfiQggmKwyiabb8jzvP3c6nd8DvgP4RkyMvUhQVZqtJs2DJoeHh91Mt4VCISbn3SCEQ5JZCGzI + NVWNyjE/zai5ACPGlLbfSWXjkErvIANKlxVIa5vvogaSBH8Yec+6iHxcVd8G/Lrnedft/L+UDz98hiKA + tBAQPj0D/CPgN4G/B3wFMBkuH958nU6Her1OvV4nk8l0kUHXcy3GoSjKBiDwbBWoRbyP9QKU1KnAbswB + MAcVXJRAp9Oh0WgY8r9Wp9VOZX+xjbGJKGJiIBSBgojkMK7SLQxV17B/InKgqk+IyHtU9U9F5BkRqSS5 + YL/U4A4CSA8tEXk/8GFfLvD3gC8CxmyBuI0aTBZqA2XaSDm5XG7APyDI/0eQocsi0olocynYrzBkUvoi + 9EOS73+gZCqKoT/zkfWUrNVqtFqtVAleRGRTVd+BUfM+ISIFVR3D5EGcVNUJzME/BCoicqiqNaCuqlUR + 2VHVxkudzI+DOwhgCPA3dlVMuucPqOqbgG8HPh9z60RCcJPZW67RaHT58aBvezabjbUtt4FAYgRgdxEj + uBxFW2F5+ED7SV8QhTBUlVar1dWiWE1K+NDHHMzrwP8L/BzwYXxryCRWwWXsE1X2MwXuIIAhIbBZDnyL + sHcDb1LVvy0iX6Cqkf73rg1tD4M98CKC53lJN2ATQwFEbd674j4+uroyDTXQz3vbCDz1eoNGo97N/pNW + eo+xz3gWY9D1KyLyGC9h6fyLBXcQwBEg4HD0KyLyDgwl8LeAN4nIbNSNkwQpeNCqql4PP/QPdY5QMtAw + BI1tRkEESdoBq8JsNls0m41u5J12uz3A2rjGEKJsqiLyEVX9FRF5u6o+jyME2h0YDe4ggGMA3831oNPp + /C7wHuCzgW8AvlxEzqiqF6VzToMkwqS+qu4D6xHdKQOnI971qQBTH36R7n0eZGOskLTdbtNqtWn7lEyr + 3TvsaZ18QuR4R01sx/cBvwb8UT6f3zy6H8YdCMMdBHBMELjZasD7VfVPgYuq+pXAXwZeiTmcI0HIgGUL + R+hp//DMEFIBhqFer9Nut7uCxzjdvWqnS8Lbf+3htn9pvAmjkF2o7X3gIxj+/p3A00BDVRMDq96BO3DL + gojMAF8F/DwmtXlLRFREgg72Cgw8iyjzh0Qjk8/BBArRqDaCdds/z/PU87zu/9N8f0x/FeCjwE+IyBeJ + yFRaFeUduAO3Dfg3bU5E7heRb8XYFKyISDt4yFIeul8UkYzLoQX4Sxg9d2qEciP+EtrdBz4E/Dvgy0Tk + JJ8Bjmm3ItxhAV4kCJgYP+n//QJwH8aW4MswfgnzqhpromdVgBipeN9zv427gFySVdxRISysS4ir2FbV + dUyU5j8F3isij6nqpil6R6B3s+AOArh5UMtkMh9rt9sfE5H/ClzAkO9vAF4N3E2IzA/IAAbiAAQOkVMF + GHf4R/GxD+vQQ992RGQPuKSqHwb+BGNj/zzGi/EzWvd+K8EdBHATIWBvfojJY/AJjJzgJPBy4HOBzwLu + B5ZUddxnGZYjDlAOgzgGbuYoj70kK7iUVnJ1jFbiEiZL80dV9ZMi8qzvhn1HbXeLwh0EcOtBG7jmed61 + bDb7rmazWcCwBheAR1T1ARF5KoK8H1PVpbjAmsPaJoTI+6aI7KsJRX4FuCQiT/s29U9h7PEPLE1/59Df + +nB75TG6AwCeFag5Dtg5jP/6fRihmueXlxg7hA4G6TT9vzpQxTjYbGCcjlYwGYiuAJfFJCPZ8svd4eFv + Y7iDAF5aUMKwDpMiMqaqZREZx8gSMqra8R2IrGS+5bsUH/g3ewWjljvASOoPgXomk2l/JnnI3YE7cAfu + wB24A3fgDtyBO3AH7sAduAN34A7cgTtwB+7AHbgDd+AO3P7w/wd27gwKneMVfwAAAABJRU5ErkJggg== + + + \ No newline at end of file diff --git a/Program.cs b/Program.cs index 91b6d6f..0cf31fb 100644 --- a/Program.cs +++ b/Program.cs @@ -1,2920 +1,17 @@ -using System.Diagnostics; -using System.Text; -using System.Text.RegularExpressions; -using static Stocks; - -namespace SF2MConfigRewrite +namespace SF2MConfigRewriteV2 { - class Program + internal static class Program { - // Variables - static int filesFound = 0; - public static List? globalLine = null; - /*static string[] validConfigChars = { "a", "A", "b", "B", "c", "C", "d", "D", "e", "E", "f", "F", "g", "G", - "h", "H", "i", "I", "j", "J", "k", "K", "l", "L", "m", "M", "n", "N", "o", "O", "p", "P", "q", "Q", "r", "R", - "s", "S", "t", "T", "u", "U", "v", "V", "w", "W", "x", "X", "y", "Y", "z", "Z" }; - static string[] validConfigNumbers = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };*/ - - static void Main(string[] args) - { - // Actual program functions - Console.Title = "Slender Fortress Modified Config Rewriter"; - Console.ForegroundColor = ConsoleColor.Blue; - - Console.WriteLine("Input a directory where all config files are located."); - var directory = Console.ReadLine(); - while (!Directory.Exists(directory)) - { - Console.WriteLine("Invalid directory " + directory + ", input a new directory."); - directory = Console.ReadLine(); - } - Console.WriteLine("Directory is valid, back up your config files just in case, press any key to start the rewriting process"); - Console.ReadKey(true); - Console.WriteLine("Rewriting configs..."); - Stopwatch sw = Stopwatch.StartNew(); - SplitAllConfigs(directory); - ProcessDirectory(directory); - TimeSpan ts = sw.Elapsed; - - string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", - ts.Hours, ts.Minutes, ts.Seconds, - ts.Milliseconds / 10); - Console.WriteLine("Rewrote " + filesFound + " config files in " + elapsedTime); - Console.ReadKey(true); - } - - static void SplitAllConfigs(string targetDirectory) - { - string[] fileEntries = Directory.GetFiles(targetDirectory); - foreach (string fileName in fileEntries) - { - string extension = Path.GetExtension(fileName); - if (extension == ".cfg") - { - if (fileName.Contains("\\profiles.cfg")) // Split this guy up - { - //FixConfig(fileName); - SplitConfig(fileName, targetDirectory, "/profiles/"); - } - else if (fileName.Contains("\\profiles_packs.cfg")) // Search in this - { - SearchPacksConfig(fileName, targetDirectory); - } - else - { - if (!fileName.Contains("\\class_stats.cfg") && !fileName.Contains("\\restrictedweapons.cfg") && !fileName.Contains("\\specialrounds.cfg")) - { - SplitConfig(fileName, targetDirectory); - } - } - } - } - - string[] subdirectoryEntries = Directory.GetDirectories(targetDirectory); - foreach (string subdirectory in subdirectoryEntries) - { - ProcessDirectory(subdirectory); - } - } - - // Functions - static void ProcessDirectory(string targetDirectory) - { - string[] fileEntries = Directory.GetFiles(targetDirectory); - foreach (string fileName in fileEntries) - { - string extension = Path.GetExtension(fileName); - if (extension == ".cfg") - { - if (!fileName.Contains("\\class_stats.cfg") && !fileName.Contains("\\restrictedweapons.cfg") && !fileName.Contains("\\specialrounds.cfg") && !fileName.Contains("\\profiles.cfg") && !fileName.Contains("\\profiles_packs.cfg")) - { - RewriteConfig(fileName); - } - } - } - - string[] subdirectoryEntries = Directory.GetDirectories(targetDirectory); - foreach (string subdirectory in subdirectoryEntries) - { - ProcessDirectory(subdirectory); - } - } - - static void SearchPacksConfig(string fileName, string targetDirectory) - { - KeyValues kv = new KeyValues(); - globalLine = File.ReadAllLines(fileName).ToList(); - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"file\"") && !globalLine[i].Contains("//")) - { - string bossPack = kv.GetString("file", i, fileName); - if (bossPack.Contains(".cfg")) // We got our boss pack - { - string bossDirectory = bossPack.Replace(".cfg", "/"); - string newFile = fileName.Replace("profiles_packs.cfg", "/profiles/packs/" + bossDirectory); - if (!Directory.Exists(newFile)) - { - Directory.CreateDirectory(newFile); - } - string tempFile = fileName.Replace("profiles_packs.cfg", "/profiles/packs/"); - string bossFile = tempFile + bossPack; - SplitConfig(bossFile, targetDirectory, "/profiles/packs/" + bossDirectory + "/", true); - globalLine[i] = globalLine[i].Replace(".cfg\"", "\""); - File.WriteAllLines(fileName, globalLine); - } - } - } - } - - // UNFINISHED - static void FixConfig(string fileName) - { - List globalLine = File.ReadAllLines(fileName).ToList(); - for (int i = 0; i < globalLine.Count; i++) // First find missing quotation marks - { - char quotes = '\"'; - - int expectedCount = globalLine[i].Split(quotes).Length - 1; - if (expectedCount != 0 && expectedCount != 2 && expectedCount != 4) - { - char[] arr = globalLine[i].ToCharArray(); - StringBuilder builder = new StringBuilder(); - for (int character = 1; character < arr.Length; character++) - { - if (char.IsLetterOrDigit(arr[character]) && char.IsLetterOrDigit(arr[character-1])) - { - builder.Append(arr[character]); - } - } - globalLine[i] = builder.ToString(); - } - } - } - - static void SplitConfig(string fileName, string targetDirectory) - { - KeyValues kv = new KeyValues(); - if (!File.Exists(fileName)) - { - return; - } - List globalLine = File.ReadAllLines(fileName).ToList(); - int bracketIndex = 0; - bool doNotDelete = false; - bool splitConfig = false; - bool message = false; - for (int i = 0; i < globalLine.Count; i++) - { - string profileName = string.Empty; - if (globalLine[i].Contains('\"')) - { - int tempLine = i; - while (!globalLine[tempLine].Contains('{')) - { - tempLine++; - } - bracketIndex++; - tempLine++; - char[] arr = globalLine[i].ToCharArray(); - StringBuilder builder = new StringBuilder(); - for (int character = 0; character < arr.Length; character++) - { - if (char.IsLetterOrDigit(arr[character]) || (IsCharSymbol(arr[character]) && arr[character] == '\"')) - { - builder.Append(arr[character]); - } - } - profileName = builder.ToString(); - while (bracketIndex > 0 && tempLine < globalLine.Count) - { - if (globalLine[tempLine].Contains('{')) - { - bracketIndex++; - } - if (globalLine[tempLine].Contains('}')) - { - bracketIndex--; - } - tempLine++; - } - int checkIndex = tempLine; - while (checkIndex < globalLine.Count) - { - if (globalLine[checkIndex].Contains('\"')) - { - splitConfig = true; - break; - } - checkIndex++; - } - if (!splitConfig) - { - return; - } - if (!message) - { - Console.WriteLine("Splitting " + fileName); - message = true; - } - List newLines = new List(); - for (int i2 = i; i2 < tempLine; i2++) - { - newLines.Add(globalLine[i2]); - } - string newDirectory = targetDirectory + "\\" + profileName + ".cfg"; - if (File.Exists(newDirectory)) - { - doNotDelete = true; - } - File.WriteAllLines(newDirectory, newLines); - i = tempLine - 1; - } - } - if (!doNotDelete) - { - File.Delete(fileName); - } - } - - static void SplitConfig(string fileName, string targetDirectory, string newDirectory = "/profiles/", bool deleteFile = false) - { - if (!File.Exists(fileName)) - { - return; - } - List globalLine = File.ReadAllLines(fileName).ToList(); - List brackets = new List(); - for (int i = 2; i < globalLine.Count; i++) - { - // First look for the profile name - if (globalLine[i].Contains('\"') && (globalLine[i + 1].Contains('{') || globalLine[i + 2].Contains('{'))) - { - int startPos = 0; - if (globalLine[i + 1].Contains('{')) - { - startPos = i + 2; - } - else if (globalLine[i + 2].Contains('{')) - { - startPos = i + 3; - } - string profile = globalLine[i]; - int profileEndPos = 0, continueTo = 0; - for (int i2 = startPos; i2 < globalLine.Count; i2++) - { - if (globalLine[i2].Contains('{')) // Found a section that is NOT the end of the profile - { - brackets.Add(globalLine[i2]); - } - if (globalLine[i2].Contains('}') && brackets.Count > 0) - { - brackets.RemoveAt(0); - } - else if (globalLine[i2].Contains('}') && brackets.Count <= 0) // We found our profile - { - profileEndPos = i2 - i; - continueTo = i2; - break; - } - } - char[] arr = profile.ToCharArray(); - string profileFile; - StringBuilder builder = new StringBuilder(); - for (int character = 0; character < arr.Length; character++) - { - if (char.IsLetterOrDigit(arr[character]) || (IsCharSymbol(arr[character]) && arr[character] == '\"')) - { - builder.Append(arr[character]); - } - } - profileFile = builder.ToString(); - if (!Directory.Exists(targetDirectory + newDirectory)) - { - Directory.CreateDirectory(targetDirectory + newDirectory); - } - string newFile = targetDirectory + newDirectory + profileFile + ".cfg"; - List newLines = new List(); - for (int i2 = i; i2 <= continueTo; i2++) - { - newLines.Add(globalLine[i2]); - } - File.WriteAllLines(newFile, newLines); - i = continueTo; - brackets.Clear(); - } - } - List overwrittenFile = new List(); - overwrittenFile.Add("\"Profiles\""); - overwrittenFile.Add("{"); - overwrittenFile.Add("}"); - if (!deleteFile) - { - File.WriteAllLines(fileName, overwrittenFile); - } - else - { - File.Delete(fileName); - } - } - - static void RewriteConfig(string fileName) - { - Console.WriteLine("Rewriting " + fileName); - globalLine = File.ReadAllLines(fileName).ToList(); - KeyValues kv = new KeyValues(); - kv.fileName = fileName; - string chaseInitialDuration = "0.0"; - string spawnAnimationTimer = "0.0"; - string stunDuration = "3.5"; - string rageTimer = "0.0"; - string fleeDelayTimer = "0.0"; - - // Delete any unused key values - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"jump_speed\"") || globalLine[i].Contains("\"airspeed\"") || globalLine[i].Contains("\"jump_cooldown\"") || - globalLine[i].Contains("\"random_attacks\"") || globalLine[i].Contains("\"enable_boss_tilting\"") || globalLine[i].Contains("\"think_time_min\"") - || globalLine[i].Contains("\"think_time_max\"") || globalLine[i].Contains("\"anger_start\"") || globalLine[i].Contains("\"anger_page_time_diff\"") || globalLine[i].Contains("\"anger_page_add\"") || globalLine[i].Contains("\"appear_chance_threshold\"") || globalLine[i].Contains("\"appear_chance_min\"") - || globalLine[i].Contains("\"appear_chance_max\"") || globalLine[i].Contains("\"proxies_teleport_enabled\"") - || globalLine[i].Contains("\"attack_props\"") || globalLine[i].Contains("\"attack_damageforce\"") || globalLine[i].Contains("\"attack_damage_vs_props\"") || globalLine[i].Contains("\"use_engine_sounds\"") || globalLine[i].Contains("\"difficulty_affects_animations\"") - || globalLine[i].Contains("\"multi_miss_sounds\"") || globalLine[i].Contains("\"multi_hit_sounds\"") || globalLine[i].Contains("\"multi_attack_sounds\"")) - { - globalLine.RemoveAt(i); - i--; - if (!globalLine[i].Contains('\"') && !globalLine[i].Contains('/') && !globalLine[i].Contains('{') && !globalLine[i].Contains('}')) - { - globalLine.RemoveAt(i); - i--; - } - } - } - File.WriteAllLines(fileName, globalLine); - - globalLine = File.ReadAllLines(fileName).ToList(); - // Add [PLAYER] in chat_message_upon_death - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"chat_message_upon_death\"")) - { - int bracketCheck = i + 1; - StringBuilder builder = new StringBuilder(); - char[] arr; - while (!globalLine[bracketCheck].Contains('{')) - { - bracketCheck++; - } - bracketCheck++; - while (globalLine[bracketCheck].Contains("\"")) - { - arr = globalLine[bracketCheck].ToCharArray(); - builder.Clear(); - byte quoteCheck = 0; - for (int i2 = 0; i2 < arr.Length; i2++) - { - if (arr[i2] == '\"') - { - quoteCheck++; - } - if (quoteCheck < 3) - { - continue; - } - if (char.IsLetterOrDigit(arr[i2]) || IsCharSymbol(arr[i2]) || arr[i2] == ' ') - { - builder.Append(arr[i2]); - } - } - if (builder.Length > 0) - { - string originalString = builder.ToString(); - string result = builder.ToString(); - if (!result.Contains("[PLAYER]")) - { - arr = result.ToCharArray(); - if (arr[0] != ' ') - { - result = result.Insert(0, "[PLAYER] "); - } - else - { - result = result.Insert(0, "[PLAYER]"); - } - } - else - { - bracketCheck++; - continue; - } - globalLine[bracketCheck] = globalLine[bracketCheck].Replace(originalString, result); - } - bracketCheck++; - } - break; - } - } - - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"mod_precache\"") || globalLine[i].Contains("\"mod_download\"") || globalLine[i].Contains("\"sound_precache\"")) - { - while (!globalLine[i].Contains('}')) - { - globalLine.RemoveAt(i); - } - globalLine.RemoveAt(i); - } - } - - // Add "attacks" section if needed - bool foundAttacks = false; - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"attacks\"")) - { - // Don't do anything - foundAttacks = true; - } - } - if (!foundAttacks) - { - List attackKeys = new List(); - int firstIndex = 0; - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"attack_") && !globalLine[i].Contains("//") && !globalLine[i].Contains("\"attack_props\"") && !globalLine[i].Contains("\"animation_attack") && !globalLine[i].Contains("\"name\"")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - attackKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - } - if (firstIndex != 0 && attackKeys.Count > 0) - { - while (!globalLine[firstIndex].Contains('\"') && !globalLine[firstIndex].Contains('{') && !globalLine[firstIndex].Contains('}')) - { - firstIndex--; - } - globalLine.Insert(firstIndex, "\t\t\"attacks\""); - firstIndex++; - globalLine.Insert(firstIndex, "\t\t{"); - firstIndex++; - globalLine.Insert(firstIndex, "\t\t\t\"1\""); - firstIndex++; - globalLine.Insert(firstIndex, "\t\t\t{"); - firstIndex++; - string newKey = string.Empty; - for (int i = 0; i < attackKeys.Count; i++) - { - newKey = "\t\t" + attackKeys[i]; - globalLine.Insert(firstIndex, newKey); - firstIndex++; - } - globalLine.Insert(firstIndex, "\t\t\t}"); - firstIndex++; - if (!globalLine[firstIndex].Contains('}')) - { - globalLine.Insert(firstIndex, "\t\t}"); - } - - firstIndex++; - if (globalLine[firstIndex].Contains(string.Empty)) - { - globalLine.Insert(firstIndex, string.Empty); - } - } - } - File.WriteAllLines(fileName, globalLine); - - // Replace attack_ with nothing - string text = File.ReadAllText(fileName); - text = text.Replace("\"attack_while_running\"", "\"run_enabled\""); - File.WriteAllText(fileName, text); - - globalLine = File.ReadAllLines(fileName).ToList(); - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"attack_") && !globalLine[i].Contains("\"animation_attack") && - !globalLine[i].Contains("\"attack_weaponsenable\"") && !globalLine[i].Contains("\"attack_custom_deathflag") && !globalLine[i].Contains("\"name\"") && - !globalLine[i].Contains("\"animation_idle") && !globalLine[i].Contains("\"animation_walk") && !globalLine[i].Contains("\"animation_walkalert") && - !globalLine[i].Contains("\"animation_run") && !globalLine[i].Contains("\"animation_stun") && !globalLine[i].Contains("\"animation_shoot") && - !globalLine[i].Contains("\"animation_chaseinitial") && !globalLine[i].Contains("\"animation_heal") && !globalLine[i].Contains("\"animation_crawlwalk") && - !globalLine[i].Contains("\"animation_crawlrun") && !globalLine[i].Contains("\"animation_spawn") && !globalLine[i].Contains("\"animation_jump") && - !globalLine[i].Contains("\"animation_duck") && !globalLine[i].Contains("\"animation_rage") && !globalLine[i].Contains("\"animation_fleestart") && - !globalLine[i].Contains("\"animation_death") && !globalLine[i].Contains("\"name\"")) - { - globalLine[i] = globalLine[i].Replace("\"attack_", "\""); - } - } - File.WriteAllLines(fileName, globalLine); - - globalLine = File.ReadAllLines(fileName).ToList(); - bool foundAnimations = false; - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"animations\"")) - { - // Don't do anything - foundAnimations = true; - } - } - if (!foundAnimations) - { - List idleKeys = new List(); - List walkKeys = new List(); - List walkAlertKeys = new List(); - List runKeys = new List(); - List attackKeys = new List(); - List stunKeys = new List(); - List shootKeys = new List(); - List chaseInitialKeys = new List(); - List rageKeys = new List(); - List fleeKeys = new List(); - List healKeys = new List(); - List deathCamKeys = new List(); - List spawnKeys = new List(); - List crawlWalkKeys = new List(); - List crawlRunKeys = new List(); - List jumpKeys = new List(); - List deathKeys = new List(); - List duckKeys = new List(); - - int firstIndex = 0; - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"animation_idle") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - idleKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_walk") && !globalLine[i].Contains("//") && !globalLine[i].Contains("\"animation_walkalert")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - walkKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_walkalert") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - walkAlertKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_run") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - runKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_attack") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - attackKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_shoot") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - shootKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_stun") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - stunKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_chaseinitial") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - chaseInitialKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_rage") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - rageKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_fleestart") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - fleeKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_heal") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - healKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_deathcam") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - deathCamKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_spawn") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - spawnKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_crawlwalk") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - crawlWalkKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_crawlrun") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - crawlRunKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_death") && !globalLine[i].Contains("//") && !globalLine[i].Contains("\"animation_deathcam")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - deathKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_jump") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - jumpKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_duck") && !globalLine[i].Contains("//")) - { - if (firstIndex == 0) - { - firstIndex = i; - } - duckKeys.Add(globalLine[i]); - globalLine.RemoveAt(i); - i--; - } - } - if (firstIndex != 0) - { - int bracketCheck = 0; - while (globalLine[firstIndex].Contains('\"') || globalLine[firstIndex].Contains('{') || globalLine[firstIndex].Contains('}') || bracketCheck > 0) - { - if (globalLine[firstIndex].Contains('{')) - { - bracketCheck--; - } - if (globalLine[firstIndex].Contains('}')) - { - bracketCheck++; - } - firstIndex--; - } - globalLine.Insert(firstIndex, "\t\t\"animations\""); - firstIndex++; - globalLine.Insert(firstIndex, "\t\t{"); - firstIndex++; - if (idleKeys.Count > 0) - { - WriteAnimationSection(idleKeys, "idle", globalLine, firstIndex, out firstIndex); - } - if (walkKeys.Count > 0) - { - WriteAnimationSection(walkKeys, "walk", globalLine, firstIndex, out firstIndex); - } - if (walkAlertKeys.Count > 0) - { - WriteAnimationSection(walkAlertKeys, "walkalert", globalLine, firstIndex, out firstIndex); - } - if (runKeys.Count > 0) - { - WriteAnimationSection(runKeys, "run", globalLine, firstIndex, out firstIndex); - } - if (attackKeys.Count > 0) - { - WriteAnimationSection(attackKeys, "attack", globalLine, firstIndex, out firstIndex); - } - if (shootKeys.Count > 0) - { - WriteAnimationSection(shootKeys, "shoot", globalLine, firstIndex, out firstIndex); - } - if (stunKeys.Count > 0) - { - WriteAnimationSection(stunKeys, "stun", globalLine, firstIndex, out firstIndex); - } - if (chaseInitialKeys.Count > 0) - { - WriteAnimationSection(chaseInitialKeys, "chaseinitial", globalLine, firstIndex, out firstIndex); - } - if (rageKeys.Count > 0) - { - WriteAnimationSection(rageKeys, "rage", globalLine, firstIndex, out firstIndex); - } - if (fleeKeys.Count > 0) - { - WriteAnimationSection(fleeKeys, "fleestart", globalLine, firstIndex, out firstIndex); - } - if (healKeys.Count > 0) - { - WriteAnimationSection(healKeys, "heal", globalLine, firstIndex, out firstIndex); - } - if (deathCamKeys.Count > 0) - { - WriteAnimationSection(deathCamKeys, "deathcam", globalLine, firstIndex, out firstIndex); - } - if (spawnKeys.Count > 0) - { - WriteAnimationSection(spawnKeys, "spawn", globalLine, firstIndex, out firstIndex); - } - if (crawlWalkKeys.Count > 0) - { - WriteAnimationSection(crawlWalkKeys, "crawlwalk", globalLine, firstIndex, out firstIndex); - } - if (crawlRunKeys.Count > 0) - { - WriteAnimationSection(crawlRunKeys, "crawlrun", globalLine, firstIndex, out firstIndex); - } - if (deathKeys.Count > 0) - { - WriteAnimationSection(deathKeys, "death", globalLine, firstIndex, out firstIndex); - } - if (jumpKeys.Count > 0) - { - WriteAnimationSection(jumpKeys, "jump", globalLine, firstIndex, out firstIndex); - } - if (duckKeys.Count > 0) - { - WriteAnimationSection(duckKeys, "duck", globalLine, firstIndex, out firstIndex); - } - - if (!globalLine[firstIndex].Contains('}')) - { - globalLine.Insert(firstIndex, "\t\t}"); - } - - firstIndex++; - if (globalLine[firstIndex].Contains(string.Empty)) - { - globalLine.Insert(firstIndex, string.Empty); - } - } - } - if (foundAnimations) - { - string idleFootstepInterval = "0.0"; - string walkFootstepInterval = "0.0"; - string runFootstepInterval = "0.0"; - string attackFootstepInterval = "0.0"; - string stunFootstepInterval = "0.0"; - - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"animation_idle_footstepinterval\"")) - { - idleFootstepInterval = kv.GetFloat("animation_idle_footstepinterval", i); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_walk_footstepinterval\"")) - { - walkFootstepInterval = kv.GetFloat("animation_walk_footstepinterval", i); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_run_footstepinterval\"")) - { - runFootstepInterval = kv.GetFloat("animation_run_footstepinterval", i); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_attack_footstepinterval\"")) - { - attackFootstepInterval = kv.GetFloat("animation_attack_footstepinterval", i); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"animation_stun_footstepinterval\"")) - { - stunFootstepInterval = kv.GetFloat("animation_stun_footstepinterval", i); - globalLine.RemoveAt(i); - i--; - } - } - AddFootstepIntervals(globalLine, idleFootstepInterval, "idle"); - - AddFootstepIntervals(globalLine, walkFootstepInterval, "walk"); - - AddFootstepIntervals(globalLine, walkFootstepInterval, "walkalert"); - - AddFootstepIntervals(globalLine, walkFootstepInterval, "crawlwalk"); - - AddFootstepIntervals(globalLine, runFootstepInterval, "run"); - - AddFootstepIntervals(globalLine, runFootstepInterval, "crawlrun"); - - AddFootstepIntervals(globalLine, attackFootstepInterval, "attack"); - - AddFootstepIntervals(globalLine, stunFootstepInterval, "stun"); - } - - // Delete any unneeded key values - List associatedKeys = new List(); - associatedKeys.Add("\"proxies"); - associatedKeys.Add("\"proxy_difficulty_"); - RemoveUnnecessaryKeys(globalLine, "proxies", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"stun_"); - associatedKeys.Add("\"disappear_on_stun\""); - associatedKeys.Add("\"animation_stun\""); - associatedKeys.Add("\"animation_stun_playbackrate\""); - associatedKeys.Add("\"animation_stun_footstepinterval\""); - associatedKeys.Add("\"animation_stun_cycle\""); - RemoveUnnecessaryKeys(globalLine, "stun_enabled", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_random"); - associatedKeys.Add("\"player_jarate"); - associatedKeys.Add("\"player_milk"); - associatedKeys.Add("\"player_gas"); - associatedKeys.Add("\"player_mark"); - associatedKeys.Add("\"player_silent_mark"); - associatedKeys.Add("\"player_ignite"); - associatedKeys.Add("\"player_stun"); - associatedKeys.Add("\"player_bleed"); - associatedKeys.Add("\"player_electric"); - associatedKeys.Add("\"player_smite"); - RemoveUnnecessaryKeys(globalLine, "player_damage_effects", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_damage_random_effects"); - RemoveUnnecessaryKeys(globalLine, "player_damage_random_effects", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_jarate"); - RemoveUnnecessaryKeys(globalLine, "player_jarate_on_hit", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_milk"); - RemoveUnnecessaryKeys(globalLine, "player_milk_on_hit", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_gas"); - RemoveUnnecessaryKeys(globalLine, "player_gas_on_hit", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_mark"); - RemoveUnnecessaryKeys(globalLine, "player_mark_on_hit", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_silent_mark"); - RemoveUnnecessaryKeys(globalLine, "player_silent_mark_on_hit", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_ignite"); - RemoveUnnecessaryKeys(globalLine, "player_ignite_on_hit", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_stun"); - RemoveUnnecessaryKeys(globalLine, "player_stun_on_hit", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_bleed"); - RemoveUnnecessaryKeys(globalLine, "player_bleed_on_hit", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_electric"); - RemoveUnnecessaryKeys(globalLine, "player_electric_slow_on_hit", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"player_smite"); - RemoveUnnecessaryKeys(globalLine, "player_smite_on_hit", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"shockwave_"); - RemoveUnnecessaryKeys(globalLine, "shockwave", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"traps_enabled\""); - associatedKeys.Add("\"trap_"); - RemoveUnnecessaryKeys(globalLine, "traps_enabled", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"copy\""); - associatedKeys.Add("\"copy_"); - associatedKeys.Add("\"teleport_distance_between_copies\""); - RemoveUnnecessaryKeys(globalLine, "copy", associatedKeys, kv); - - associatedKeys.Clear(); - associatedKeys.Add("\"auto_chase_enabled\""); - associatedKeys.Add("\"sound_alert_"); - RemoveUnnecessaryKeys(globalLine, "auto_chase_enabled", associatedKeys, kv); - - // Look for any timers - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"chase_initial_timer\"")) - { - chaseInitialDuration = kv.GetFloat("chase_initial_timer", i); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"spawn_timer\"")) - { - spawnAnimationTimer = kv.GetFloat("\"spawn_timer\"", i); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"stun_duration\"")) - { - stunDuration = kv.GetFloat("\"stun_duration\"", i); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"rage_timer\"")) - { - rageTimer = kv.GetFloat("\"rage_timer\"", i); - globalLine.RemoveAt(i); - i--; - } - if (globalLine[i].Contains("\"flee_delay_time\"")) - { - fleeDelayTimer = kv.GetFloat("\"flee_delay_time\"", i); - globalLine.RemoveAt(i); - i--; - } - } - - File.WriteAllLines(fileName, globalLine); - - // Start replacing key values - text = File.ReadAllText(fileName); - text = text.Replace("\"turnrate\"", "\"maxyawrate\""); - - text = text.Replace("\"ash_ragdoll_on_kill\"", "\"disintegrate_ragdoll_on_kill\""); - - text = text.Replace("\"chance\"", "\"weight\""); - - text = text.Replace("\"auto_chase_count\"", "\"auto_chase_sound_threshold\""); - - text = text.Replace("\"sound_alert_add\"", "\"auto_chase_sound_add\""); - - text = text.Replace("\"sound_alert_add_footsteps\"", "\"auto_chase_sound_add_footsteps\""); - - text = text.Replace("\"sound_alert_add_voice\"", "\"auto_chase_sound_add_voice\""); - - text = text.Replace("\"sound_alert_add_weapon\"", "\"auto_chase_sound_add_weapon\""); - - text = text.Replace("\"chase_upon_look\"", "\"auto_chase_upon_look\""); - - text = text.Replace("\"sound_player_death\"", "\"sound_player_deathcam\""); - - text = text.Replace("\"sound_player_death_all\"", "\"sound_player_deathcam_all\""); - - text = text.Replace("\"engine_sound\"", "\"constant_sound\""); - - text = text.Replace("\"engine_sound_level\"", "\"constant_sound_level\""); - - text = text.Replace("\"engine_sound_volume\"", "\"constant_sound_volume\""); - - text = ReplaceDifficultyKeyValue(text, "search_range", "search_view_distance"); - - text = ReplaceDifficultyKeyValue(text, "search_sound_range", "hearing_range"); - - text = ReplaceDifficultyKeyValue(text, "search_alert_gracetime", "alert_gracetime"); - - text = ReplaceDifficultyKeyValue(text, "search_alert_duration", "alert_duration"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_duration", "chase_duration"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_duration_add_visible_min", "chase_duration_add_visible_min"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_duration_add_visible_max", "chase_duration_add_visible_max"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_persistency_time_init", "chase_persistency_time_init"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_persistency_time_init_attack", "chase_persistency_time_init_attack"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_persistency_time_add_attack", "chase_persistency_time_add_attack"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_persistency_time_init_newtarget", "chase_persistency_time_init_newtarget"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_persistency_time_add_newtarget", "chase_persistency_time_add_newtarget"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_persistency_time_add_visible_min", "chase_persistency_time_add_visible_min"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_persistency_time_add_visible_min", "chase_persistency_time_add_visible_min"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_persistency_time_add_visible_max", "chase_persistency_time_add_visible_max"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_persistency_time_init_stun", "chase_persistency_time_init_stun"); - - text = ReplaceDifficultyKeyValue(text, "search_chase_persistency_time_add_stun", "chase_persistency_time_add_stun"); - - text = ReplaceDifficultyKeyValue(text, "search_wander_range_min", "wander_range_min"); - - text = ReplaceDifficultyKeyValue(text, "search_wander_range_max", "wander_range_max"); - - text = ReplaceDifficultyKeyValue(text, "search_wander_time_min", "wander_time_min"); - - text = ReplaceDifficultyKeyValue(text, "search_wander_time_max", "wander_time_max"); - - File.WriteAllText(fileName, text); - - ReplaceAnimationNames(fileName, text, "animation_idle"); - - ReplaceAnimationNames(fileName, text, "animation_walk"); - - ReplaceAnimationNames(fileName, text, "animation_walkalert"); - - ReplaceAnimationNames(fileName, text, "animation_run"); - - ReplaceAnimationNames(fileName, text, "animation_attack"); - - ReplaceAnimationNames(fileName, text, "animation_stun"); - - ReplaceAnimationNames(fileName, text, "animation_shoot"); - - ReplaceAnimationNames(fileName, text, "animation_deathcam"); - - ReplaceAnimationNames(fileName, text, "animation_chaseinitial"); - - ReplaceAnimationNames(fileName, text, "animation_spawn"); - - ReplaceAnimationNames(fileName, text, "animation_crawlwalk"); - - ReplaceAnimationNames(fileName, text, "animation_crawlrun"); - - ReplaceAnimationNames(fileName, text, "animation_heal"); - - ReplaceAnimationNames(fileName, text, "animation_fleestart"); - - ReplaceAnimationNames(fileName, text, "animation_rage"); - - ReplaceAnimationNames(fileName, text, "animation_jump"); - - ReplaceAnimationNames(fileName, text, "animation_death"); - - text = File.ReadAllText(fileName); - text = text.Replace("\"gesture_attack\"", "\"gesture_name\""); - - text = text.Replace("\"gesture_attack_playbackrate\"", "\"gesture_playbackrate\""); - - text = text.Replace("\"gesture_attack_cycle\"", "\"gesture_cycle\""); - File.WriteAllText(fileName, text); - - // "companions" to the new companions system - globalLine = File.ReadAllLines(fileName).ToList(); - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"chaseinitial\"")) - { - int bracketCheck = i + 1; - byte bracketIndex = 0; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('{')) - { - bracketCheck++; - } - if (bracketCheck >= globalLine.Count) - { - continue; - } - bracketIndex++; - bracketCheck++; - for (int j = bracketCheck; j < globalLine.Count; j++) - { - if (chaseInitialDuration == "0.0" || chaseInitialDuration == "0") - { - break; - } - if (globalLine[j].Contains('}') && bracketIndex == 1) - { - i = j; - break; - } - if (globalLine[j].Contains("\"1") || globalLine[j].Contains("\"2") || globalLine[j].Contains("\"3") || globalLine[j].Contains("\"4") - || globalLine[j].Contains("\"5") || globalLine[j].Contains("\"6") || globalLine[j].Contains("\"7") || globalLine[j].Contains("\"8") - || globalLine[j].Contains("\"9")) - { - j++; - while (!globalLine[j].Contains('{')) - { - j++; - } - bracketIndex++; - j++; - while (!globalLine[j].Contains('}')) - { - j++; - } - bracketIndex--; - if (chaseInitialDuration != "0.0" && chaseInitialDuration != "0") - { - globalLine.Insert(j, "\"duration\" \"" + chaseInitialDuration + "\""); - j++; - } - } - } - } - if (globalLine[i].Contains("\"spawn\"")) - { - int bracketCheck = i + 1; - byte bracketIndex = 0; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('{')) - { - bracketCheck++; - } - if (bracketCheck >= globalLine.Count) - { - continue; - } - bracketIndex++; - bracketCheck++; - for (int j = bracketCheck; j < globalLine.Count; j++) - { - if (spawnAnimationTimer == "0.0" || spawnAnimationTimer == "0") - { - break; - } - if (globalLine[j].Contains('}') && bracketIndex == 1) - { - i = j; - break; - } - if (globalLine[j].Contains("\"1") || globalLine[j].Contains("\"2") || globalLine[j].Contains("\"3") || globalLine[j].Contains("\"4") - || globalLine[j].Contains("\"5") || globalLine[j].Contains("\"6") || globalLine[j].Contains("\"7") || globalLine[j].Contains("\"8") - || globalLine[j].Contains("\"9")) - { - j++; - while (!globalLine[j].Contains('{')) - { - j++; - } - bracketIndex++; - j++; - while (!globalLine[j].Contains('}')) - { - j++; - } - bracketIndex--; - if (spawnAnimationTimer != "0.0" && spawnAnimationTimer != "0") - { - globalLine.Insert(j, "\"duration\" \"" + spawnAnimationTimer + "\""); - j++; - } - } - } - } - if (globalLine[i].Contains("\"stun\"")) - { - int bracketCheck = i + 1; - byte bracketIndex = 0; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('{')) - { - bracketCheck++; - } - if (bracketCheck >= globalLine.Count) - { - continue; - } - bracketIndex++; - bracketCheck++; - for (int j = bracketCheck; j < globalLine.Count; j++) - { - if (stunDuration == "0.0" || stunDuration == "0" || stunDuration == "3.5") - { - break; - } - if (globalLine[j].Contains('}') && bracketIndex == 1) - { - i = j; - break; - } - if (globalLine[j].Contains("\"1") || globalLine[j].Contains("\"2") || globalLine[j].Contains("\"3") || globalLine[j].Contains("\"4") - || globalLine[j].Contains("\"5") || globalLine[j].Contains("\"6") || globalLine[j].Contains("\"7") || globalLine[j].Contains("\"8") - || globalLine[j].Contains("\"9")) - { - j++; - while (!globalLine[j].Contains('{')) - { - j++; - } - bracketIndex++; - j++; - while (!globalLine[j].Contains('}')) - { - j++; - } - bracketIndex--; - if (stunDuration != "0.0" && stunDuration != "0" && stunDuration != "3.5") - { - globalLine.Insert(j, "\"duration\" \"" + stunDuration + "\""); - j++; - } - } - } - } - if (globalLine[i].Contains("\"rage\"")) - { - int bracketCheck = i + 1; - byte bracketIndex = 0; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('{')) - { - bracketCheck++; - } - if (bracketCheck >= globalLine.Count) - { - continue; - } - bracketIndex++; - bracketCheck++; - for (int j = bracketCheck; j < globalLine.Count; j++) - { - if (rageTimer == "0.0" || rageTimer == "0") - { - break; - } - if (globalLine[j].Contains('}') && bracketIndex == 1) - { - i = j; - break; - } - if (globalLine[j].Contains("\"1") || globalLine[j].Contains("\"2") || globalLine[j].Contains("\"3") || globalLine[j].Contains("\"4") - || globalLine[j].Contains("\"5") || globalLine[j].Contains("\"6") || globalLine[j].Contains("\"7") || globalLine[j].Contains("\"8") - || globalLine[j].Contains("\"9")) - { - j++; - while (!globalLine[j].Contains('{')) - { - j++; - } - bracketIndex++; - j++; - while (!globalLine[j].Contains('}')) - { - j++; - } - bracketIndex--; - if (rageTimer != "0.0" && rageTimer != "0") - { - globalLine.Insert(j, "\"duration\" \"" + rageTimer + "\""); - j++; - } - } - } - } - if (globalLine[i].Contains("\"fleestart\"")) - { - int bracketCheck = i + 1; - byte bracketIndex = 0; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('{')) - { - bracketCheck++; - } - if (bracketCheck >= globalLine.Count) - { - continue; - } - bracketIndex++; - bracketCheck++; - for (int j = bracketCheck; j < globalLine.Count; j++) - { - if (fleeDelayTimer == "0.0" || fleeDelayTimer == "0") - { - break; - } - if (globalLine[j].Contains('}') && bracketIndex == 1) - { - i = j; - break; - } - if (globalLine[j].Contains("\"1") || globalLine[j].Contains("\"2") || globalLine[j].Contains("\"3") || globalLine[j].Contains("\"4") - || globalLine[j].Contains("\"5") || globalLine[j].Contains("\"6") || globalLine[j].Contains("\"7") || globalLine[j].Contains("\"8") - || globalLine[j].Contains("\"9")) - { - j++; - while (!globalLine[j].Contains('{')) - { - j++; - } - bracketIndex++; - j++; - while (!globalLine[j].Contains('}')) - { - j++; - } - bracketIndex--; - if (fleeDelayTimer != "0.0" && fleeDelayTimer != "0") - { - globalLine.Insert(j, "\"duration\" \"" + fleeDelayTimer + "\""); - j++; - } - } - } - } - } - List keyvalueName = new List(); - for (int i = 0; i < globalLine.Count; i++) - { - int iterations = 1; - int index = 1; - int startDelete = 0; - if (globalLine[i].Contains("\"companions\"") && !globalLine[i + 2].Contains("\"type\"") && !globalLine[i].Contains("//")) - { - while (!globalLine[i + iterations].Contains('}')) - { - if (globalLine[i + iterations].Contains('{')) - { - startDelete = i + iterations + 1; - } - if (globalLine[i + iterations].Contains("\"" + index.ToString() + "\"")) - { - keyvalueName.Add(globalLine[i + iterations]); - globalLine.RemoveAt(i + iterations); - index++; - iterations--; - } - iterations++; - } - bool spawnType = false; - bool groupName = false; - bool bossGroupName = false; - bool finished = false; - while (!finished) - { - if (!spawnType) - { - globalLine.Insert(startDelete, "\t\t\t\"type\" \"on_spawn on_difficulty_change\""); - startDelete--; - spawnType = true; - } - else - { - if (!groupName) - { - startDelete++; - globalLine.Insert(startDelete, "\t\t\t\"boss_group\""); - startDelete++; - globalLine.Insert(startDelete, "\t\t\t{"); - groupName = true; - } - else - { - if (!bossGroupName) - { - globalLine.Insert(startDelete, "\t\t\t\t\"bosses\""); - startDelete++; - globalLine.Insert(startDelete, "\t\t\t\t{"); - bossGroupName = true; - } - else - { - for (int i2 = 0; i2 < keyvalueName.Count; i2++) - { - keyvalueName[i2] = "\t\t" + keyvalueName[i2]; - globalLine.Insert(startDelete, keyvalueName[i2]); - startDelete++; - } - globalLine.Insert(startDelete, "\t\t\t\t}"); - startDelete++; - globalLine.Insert(startDelete, "\t\t\t}"); - startDelete++; - if (!globalLine[startDelete].Contains("}")) - { - globalLine.Insert(startDelete, "\t\t}"); - } - startDelete++; - globalLine.Insert(startDelete, ""); - finished = true; - } - } - } - - startDelete++; - } - break; - } - } - - // Sound sections - { - File.WriteAllLines(fileName, globalLine); - // Sound sections starting with sound_idle - List floatSoundParams = new List(); - /* - * int Channel; - float Volume; - int Flags; - int Level; - int Pitch; - float CooldownMin; - float CooldownMax; - int PitchRandomMin; - int PitchRandomMax; - */ - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - List intSoundParams = new List(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_idle", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_alertofenemy", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_chasingenemy", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_chaseenemyinitial", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_attack_killed", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_attack_killed_all"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_attack_killed_client"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_rage", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_rage_2", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_rage_3", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_heal_self", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_stun", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_footsteps", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_music"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_music_hard"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_music_insane"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_music_nightmare"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_music_apollyon"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_chase_music"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_chase_visible"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_alert_music"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_idle_music"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_20dollars"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_20dollars_music"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_sight", true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_scare_player"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_player_deathcam_local"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_player_deathcam"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_player_death"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_player_deathcam_all"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_player_death_all"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_spawn_all"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_spawn_local", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_player_deathcam_overlay"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_proxy_spawn", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_proxy_idle", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_proxy_hurt", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_proxy_death", true, true); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_music_outro"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_move"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_move_single"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_jumpscare"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_static"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_static_loop_local"); - - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_static_shake_local"); - File.WriteAllLines(fileName, globalLine); - - globalLine = File.ReadAllLines(fileName).ToList(); - List eventSoundIndexes = new List(); - StringBuilder stringBuilder; - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_event_") && !globalLine[i].Contains("volume\"") && !globalLine[i].Contains("pitch\"") - && !globalLine[i].Contains("flags\"") && !globalLine[i].Contains("level\"")) - { - stringBuilder = new StringBuilder(); - char[] arr = globalLine[i].ToCharArray(); - bool stopLoop = false; - for (int i2 = 0; i2 < arr.Length; i2++) - { - if (char.IsDigit(arr[i2])) - { - stopLoop = true; - stringBuilder.Append(arr[i2]); - } - if (arr[i2] == '\"' && stopLoop) - { - break; - } - } - string result = stringBuilder.ToString(); - eventSoundIndexes.Add(Int32.Parse(result)); - } - } - string keyValue = string.Empty; - for (int i = 0; i < eventSoundIndexes.Count; i++) - { - keyValue = "sound_event_" + eventSoundIndexes[i].ToString(); - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, keyValue); - File.WriteAllLines(fileName, globalLine); - } - - globalLine = File.ReadAllLines(fileName).ToList(); - eventSoundIndexes.Clear(); - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_footsteps_event_") && !globalLine[i].Contains("volume\"") && !globalLine[i].Contains("pitch\"") - && !globalLine[i].Contains("flags\"") && !globalLine[i].Contains("level\"")) - { - stringBuilder = new StringBuilder(); - char[] arr = globalLine[i].ToCharArray(); - bool stopLoop = false; - for (int i2 = 0; i2 < arr.Length; i2++) - { - if (char.IsDigit(arr[i2])) - { - stopLoop = true; - stringBuilder.Append(arr[i2]); - } - if (arr[i2] == '\"' && stopLoop) - { - break; - } - } - string result = stringBuilder.ToString(); - eventSoundIndexes.Add(Int32.Parse(result)); - } - } - for (int i = 0; i < eventSoundIndexes.Count; i++) - { - keyValue = "sound_footsteps_event_" + eventSoundIndexes[i].ToString(); - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, keyValue); - File.WriteAllLines(fileName, globalLine); - } - - globalLine = File.ReadAllLines(fileName).ToList(); - bool splitSections = false, rewriteSections = false; - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_attackenemy_") && !globalLine[i].Contains("_volume\"") && !globalLine[i].Contains("_pitch\"") - && !globalLine[i].Contains("_flags\"") && !globalLine[i].Contains("_level\"") && !globalLine[i].Contains("_cooldown_min\"") - && !globalLine[i].Contains("_cooldown_max\"") && !globalLine[i].Contains("_pitch_random_min\"") && !globalLine[i].Contains("_pitch_random_max\"") - && !globalLine[i].Contains("_channel\"")) - { - splitSections = true; - break; - } - } - if (!splitSections) - { - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_attackenemy\"")) - { - int bracketCheck = i + 1; - bool breakOut = false; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('}')) - { - bracketCheck++; - if (globalLine[bracketCheck].Contains('\"')) - { - if (globalLine[bracketCheck].Contains("\"paths\"")) - { - breakOut = true; - break; - } - } - } - if (breakOut) - { - break; - } - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('{') && !globalLine[bracketCheck].Contains('}')) - { - bracketCheck++; - if (globalLine[bracketCheck].Contains('}')) - { - break; - } - } - int originalPosition = bracketCheck; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('}') && !globalLine[bracketCheck].Contains("\"paths\"")) - { - bracketCheck++; - } - if (globalLine[bracketCheck].Contains("\"paths\"")) - { - break; - } - else - { - int bracketIndex = 0, bracketLine = i; - while (bracketLine < globalLine.Count && !globalLine[bracketLine].Contains('{')) - { - bracketLine++; - } - bracketLine++; - while (bracketIndex >= 0 && bracketLine < globalLine.Count) - { - if (globalLine[bracketLine].Contains('{')) - { - bracketIndex++; - } - else if (globalLine[bracketLine].Contains('}')) - { - bracketIndex--; - } - bracketLine++; - } - bracketLine--; - if (bracketCheck != bracketLine) - { - rewriteSections = true; - } - } - } - } - } - if (splitSections && !rewriteSections) - { - ChangeMultiSoundSections("sound_attackenemy", fileName, globalLine, kv, splitSections); - } - else if (rewriteSections && !splitSections) - { - RewriteMultiSoundSections("sound_attackenemy", fileName, globalLine, floatSoundParams, intSoundParams, kv); - } - else - { - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_attackenemy"); - File.WriteAllLines(fileName, globalLine); - } - globalLine = File.ReadAllLines(fileName).ToList(); - splitSections = false; - rewriteSections = false; - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_hitenemy_") && !globalLine[i].Contains("_volume\"") && !globalLine[i].Contains("_pitch\"") - && !globalLine[i].Contains("_flags\"") && !globalLine[i].Contains("_level\"") && !globalLine[i].Contains("_cooldown_min\"") - && !globalLine[i].Contains("_cooldown_max\"") && !globalLine[i].Contains("_pitch_random_min\"") && !globalLine[i].Contains("_pitch_random_max\"") - && !globalLine[i].Contains("_channel\"")) - { - splitSections = true; - break; - } - } - if (!splitSections) - { - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_hitenemy\"")) - { - int bracketCheck = i + 1; - bool breakOut = false; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('}')) - { - bracketCheck++; - if (globalLine[bracketCheck].Contains('\"')) - { - if (globalLine[bracketCheck].Contains("\"paths\"")) - { - breakOut = true; - break; - } - } - } - if (breakOut) - { - break; - } - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('{') && !globalLine[bracketCheck].Contains('}')) - { - bracketCheck++; - if (globalLine[bracketCheck].Contains('}')) - { - break; - } - } - int originalPosition = bracketCheck; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('}') && !globalLine[bracketCheck].Contains("\"paths\"")) - { - bracketCheck++; - } - if (globalLine[bracketCheck].Contains("\"paths\"")) - { - break; - } - else - { - int bracketIndex = 0, bracketLine = i; - while (bracketLine < globalLine.Count && !globalLine[bracketLine].Contains('{')) - { - bracketLine++; - } - bracketLine++; - while (bracketIndex >= 0 && bracketLine < globalLine.Count) - { - if (globalLine[bracketLine].Contains('{')) - { - bracketIndex++; - } - else if (globalLine[bracketLine].Contains('}')) - { - bracketIndex--; - } - bracketLine++; - } - bracketLine--; - if (bracketCheck != bracketLine) - { - rewriteSections = true; - } - } - } - } - } - if (splitSections && !rewriteSections) - { - ChangeMultiSoundSections("sound_hitenemy", fileName, globalLine, kv, splitSections); - } - else if (rewriteSections && !splitSections) - { - RewriteMultiSoundSections("sound_hitenemy", fileName, globalLine, floatSoundParams, intSoundParams, kv); - } - else - { - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_hitenemy"); - File.WriteAllLines(fileName, globalLine); - } - globalLine = File.ReadAllLines(fileName).ToList(); - splitSections = false; - rewriteSections = false; - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_missenemy_") && !globalLine[i].Contains("_volume\"") && !globalLine[i].Contains("_pitch\"") - && !globalLine[i].Contains("_flags\"") && !globalLine[i].Contains("_level\"") && !globalLine[i].Contains("_cooldown_min\"") - && !globalLine[i].Contains("_cooldown_max\"") && !globalLine[i].Contains("_pitch_random_min\"") && !globalLine[i].Contains("_pitch_random_max\"") - && !globalLine[i].Contains("_channel\"")) - { - splitSections = true; - break; - } - } - if (!splitSections) - { - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_missenemy\"")) - { - int bracketCheck = i + 1; - bool breakOut = false; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('}')) - { - bracketCheck++; - if (globalLine[bracketCheck].Contains('\"')) - { - if (globalLine[bracketCheck].Contains("\"paths\"")) - { - breakOut = true; - break; - } - } - } - if (breakOut) - { - break; - } - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('{') && !globalLine[bracketCheck].Contains('}')) - { - bracketCheck++; - if (globalLine[bracketCheck].Contains('}')) - { - break; - } - } - int originalPosition = bracketCheck; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('}') && !globalLine[bracketCheck].Contains("\"paths\"")) - { - bracketCheck++; - } - if (globalLine[bracketCheck].Contains("\"paths\"")) - { - break; - } - else - { - int bracketIndex = 0, bracketLine = i; - while (bracketLine < globalLine.Count && !globalLine[bracketLine].Contains('{')) - { - bracketLine++; - } - bracketLine++; - while (bracketIndex >= 0 && bracketLine < globalLine.Count) - { - if (globalLine[bracketLine].Contains('{')) - { - bracketIndex++; - } - else if (globalLine[bracketLine].Contains('}')) - { - bracketIndex--; - } - bracketLine++; - } - bracketLine--; - if (bracketCheck != bracketLine) - { - rewriteSections = true; - } - } - } - } - } - if (splitSections && !rewriteSections) - { - ChangeMultiSoundSections("sound_missenemy", fileName, globalLine, kv, splitSections); - } - else if (rewriteSections && !splitSections) - { - RewriteMultiSoundSections("sound_missenemy", fileName, globalLine, floatSoundParams, intSoundParams, kv); - } - else - { - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_missenemy"); - File.WriteAllLines(fileName, globalLine); - } - globalLine = File.ReadAllLines(fileName).ToList(); - splitSections = false; - rewriteSections = false; - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_bulletshoot_") && !globalLine[i].Contains("_volume\"") && !globalLine[i].Contains("_pitch\"") - && !globalLine[i].Contains("_flags\"") && !globalLine[i].Contains("_level\"") && !globalLine[i].Contains("_cooldown_min\"") - && !globalLine[i].Contains("_cooldown_max\"") && !globalLine[i].Contains("_pitch_random_min\"") && !globalLine[i].Contains("_pitch_random_max\"") - && !globalLine[i].Contains("_channel\"")) - { - splitSections = true; - break; - } - } - if (!splitSections) - { - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_bulletshoot\"")) - { - int bracketCheck = i + 1; - bool breakOut = false; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('}')) - { - bracketCheck++; - if (globalLine[bracketCheck].Contains('\"')) - { - if (globalLine[bracketCheck].Contains("\"paths\"")) - { - breakOut = true; - break; - } - } - } - if (breakOut) - { - break; - } - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('{') && !globalLine[bracketCheck].Contains('}')) - { - bracketCheck++; - if (globalLine[bracketCheck].Contains('}')) - { - break; - } - } - int originalPosition = bracketCheck; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('}') && !globalLine[bracketCheck].Contains("\"paths\"")) - { - bracketCheck++; - } - if (globalLine[bracketCheck].Contains("\"paths\"")) - { - break; - } - else - { - int bracketIndex = 0, bracketLine = i; - while (bracketLine < globalLine.Count && !globalLine[bracketLine].Contains('{')) - { - bracketLine++; - } - bracketLine++; - while (bracketIndex >= 0 && bracketLine < globalLine.Count) - { - if (globalLine[bracketLine].Contains('{')) - { - bracketIndex++; - } - else if (globalLine[bracketLine].Contains('}')) - { - bracketIndex--; - } - bracketLine++; - } - bracketLine--; - if (bracketCheck != bracketLine) - { - rewriteSections = true; - } - } - } - } - } - if (splitSections && !rewriteSections) - { - ChangeMultiSoundSections("sound_bulletshoot", fileName, globalLine, kv, splitSections); - } - else if (rewriteSections && !splitSections) - { - RewriteMultiSoundSections("sound_bulletshoot", fileName, globalLine, floatSoundParams, intSoundParams, kv); - } - else - { - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_bulletshoot"); - File.WriteAllLines(fileName, globalLine); - } - globalLine = File.ReadAllLines(fileName).ToList(); - splitSections = false; - rewriteSections = false; - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_attackshootprojectile_") && !globalLine[i].Contains("_volume\"") && !globalLine[i].Contains("_pitch\"") - && !globalLine[i].Contains("_flags\"") && !globalLine[i].Contains("_level\"") && !globalLine[i].Contains("_cooldown_min\"") - && !globalLine[i].Contains("_cooldown_max\"") && !globalLine[i].Contains("_pitch_random_min\"") && !globalLine[i].Contains("_pitch_random_max\"") - && !globalLine[i].Contains("_channel\"")) - { - splitSections = true; - break; - } - } - if (!splitSections) - { - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains("\"sound_attackshootprojectile\"")) - { - int bracketCheck = i + 1; - bool breakOut = false; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('}')) - { - bracketCheck++; - if (globalLine[bracketCheck].Contains('\"')) - { - if (globalLine[bracketCheck].Contains("\"paths\"")) - { - breakOut = true; - break; - } - } - } - if (breakOut) - { - break; - } - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('{') && !globalLine[bracketCheck].Contains('}')) - { - bracketCheck++; - if (globalLine[bracketCheck].Contains('}')) - { - break; - } - } - int originalPosition = bracketCheck; - while (bracketCheck < globalLine.Count && !globalLine[bracketCheck].Contains('}') && !globalLine[bracketCheck].Contains("\"paths\"")) - { - bracketCheck++; - } - if (globalLine[bracketCheck].Contains("\"paths\"")) - { - break; - } - else - { - int bracketIndex = 0, bracketLine = i; - while (bracketLine < globalLine.Count && !globalLine[bracketLine].Contains('{')) - { - bracketLine++; - } - bracketLine++; - while (bracketIndex >= 0 && bracketLine < globalLine.Count) - { - if (globalLine[bracketLine].Contains('{')) - { - bracketIndex++; - } - else if (globalLine[bracketLine].Contains('}')) - { - bracketIndex--; - } - bracketLine++; - } - bracketLine--; - if (bracketCheck != bracketLine) - { - rewriteSections = true; - } - } - } - } - } - if (splitSections && !rewriteSections) - { - ChangeMultiSoundSections("sound_attackshootprojectile", fileName, globalLine, kv, splitSections); - } - else if (rewriteSections && !splitSections) - { - RewriteMultiSoundSections("sound_attackshootprojectile", fileName, globalLine, floatSoundParams, intSoundParams, kv); - } - else - { - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - keyvalueName.Clear(); - ChangeSoundSection(globalLine, keyvalueName, floatSoundParams, intSoundParams, "sound_attackshootprojectile"); - File.WriteAllLines(fileName, globalLine); - } - } - - // Delete empty globalLines having increments greater than 1 - for (int i = 0; i < globalLine.Count - 1; i++) - { - if (!globalLine[i + 1].Contains('\"') && !globalLine[i + 1].Contains('{') && !globalLine[i + 1].Contains('}') && - !globalLine[i].Contains('\"') && !globalLine[i].Contains('{') && !globalLine[i].Contains('}')) - { - globalLine.RemoveAt(i + 1); - i--; - } - } - - // Finally auto-indent - int curlyIndex = 0; - StringBuilder sb, charBuilder; - for (int i = 0; i < globalLine.Count; i++) - { - bool commentFound = false; - charBuilder = new StringBuilder(); - globalLine[i] = globalLine[i].Replace("\t", ""); - List charList = new List(); - charList.AddRange(globalLine[i]); - for (int i2 = 0; i2 < charList.Count; i2++) - { - bool skipSpace = false; - if (charList[i2] == ' ' && charList[i2] != '{' && charList[i2] != '}') - { - if ((i2 - 1 > 0 && (char.IsLetterOrDigit(charList[i2 - 1]) || IsCharSymbol(charList[i2 - 1]))) && - (i2 + 1 < charList.Count && (char.IsLetterOrDigit(charList[i2 + 1]) || IsCharSymbol(charList[i2 + 1])))) - { - skipSpace = true; - } - if (charList[i2] == '/' && (i2 + 1 < charList.Count && charList[i2 + 1] == '/')) - { - commentFound = true; - } - if (!commentFound && !skipSpace) - { - charList.RemoveAt(i2); - i2--; - continue; - } - } - charBuilder.Append(charList[i2]); - } - globalLine[i] = charBuilder.ToString(); - charBuilder = new StringBuilder(); - charList = new List(); - charList.AddRange(globalLine[i]); - for (int i2 = 0; i2 < charList.Count; i2++) - { - if (charList[i2] == '\"' && (i2 + 1 < charList.Count && charList[i2 + 1] == '\"')) - { - charList.Insert(i2 + 1, ' '); - } - charBuilder.Append(charList[i2]); - } - globalLine[i] = charBuilder.ToString(); - } - for (int i = 0; i < globalLine.Count; i++) - { - if (globalLine[i].Contains('}') && curlyIndex != 0 && !globalLine[i].Contains('\"')) - { - curlyIndex--; - } - sb = new StringBuilder(globalLine[i]); - for (int i2 = 0; i2 < curlyIndex; i2++) - { - sb.Insert(0, "\t"); - } - globalLine[i] = sb.ToString(); - if (globalLine[i].Contains('{') && !globalLine[i].Contains('\"')) - { - curlyIndex++; - } - } - - for (int i = 0; i < globalLine.Count; i++) - { - char[] arr = globalLine[i].ToCharArray(); - if (arr.Length > 0 || globalLine[i].Contains('{') || globalLine[i].Contains('}')) - { - continue; - } - globalLine[i] = string.Empty; - } - - // Check any missing curly brackets - curlyIndex = 0; - for (int i = 0; i < globalLine.Count; i++) - { - bool doContinue = false; - if (globalLine[i].Contains('{') || globalLine[i].Contains('}')) - { - List charList = new List(); - charList.AddRange(globalLine[i]); - for (int i2 = 0; i2 < charList.Count; i2++) - { - if (char.IsLetterOrDigit(charList[i2])) - { - doContinue = true; - break; - } - } - } - if (doContinue) - { - continue; - } - - if (globalLine[i].Contains('{')) - { - curlyIndex++; - } - if (globalLine[i].Contains('}')) - { - curlyIndex--; - } - } - if (curlyIndex > 0) - { - for (int i = 0; i < curlyIndex; i++) - { - globalLine.Add("}"); - } - } - else if (curlyIndex < 0) - { - for (int i = globalLine.Count - 1; i >= 0; i--) - { - if (curlyIndex == 0) - { - break; - } - bool doContinue = false; - if (globalLine[i].Contains('}')) - { - List charList = new List(); - charList.AddRange(globalLine[i]); - for (int i2 = 0; i2 < charList.Count; i2++) - { - if (char.IsLetterOrDigit(charList[i2])) - { - doContinue = true; - break; - } - } - } - if (doContinue) - { - continue; - } - - if (globalLine[i].Contains('}')) - { - globalLine.RemoveAt(i); - curlyIndex++; - } - } - } - File.WriteAllLines(fileName, globalLine); - GC.Collect(); - GC.WaitForPendingFinalizers(); - filesFound++; + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + // To customize application configuration such as set high DPI settings or default font, + // see https://aka.ms/applicationconfiguration. + ApplicationConfiguration.Initialize(); + Application.Run(new FormMain()); } } } \ No newline at end of file diff --git a/SF2MConfigRewrite.csproj b/SF2MConfigRewrite.csproj deleted file mode 100644 index 1f1db9a..0000000 --- a/SF2MConfigRewrite.csproj +++ /dev/null @@ -1,16 +0,0 @@ - - - - Exe - net6.0 - enable - enable - sf2m.ico - none - - - - - - - diff --git a/SF2MConfigRewriteV2.csproj b/SF2MConfigRewriteV2.csproj new file mode 100644 index 0000000..7d0e38a --- /dev/null +++ b/SF2MConfigRewriteV2.csproj @@ -0,0 +1,32 @@ + + + + WinExe + net6.0-windows + enable + true + enable + slenderman_128.png + sf2m.ico + + + + none + + + + none + + + + + + + + + True + \ + + + + \ No newline at end of file diff --git a/SF2MConfigRewrite.sln b/SF2MConfigRewriteV2.sln similarity index 61% rename from SF2MConfigRewrite.sln rename to SF2MConfigRewriteV2.sln index fe2f082..283c9c1 100644 --- a/SF2MConfigRewrite.sln +++ b/SF2MConfigRewriteV2.sln @@ -1,9 +1,9 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 -VisualStudioVersion = 17.0.32014.148 +VisualStudioVersion = 17.6.33712.159 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SF2MConfigRewrite", "SF2MConfigRewrite.csproj", "{48B347F3-179C-4095-8BAD-96DD8E27AA30}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SF2MConfigRewriteV2", "SF2MConfigRewriteV2.csproj", "{2973D144-5939-432F-BF4C-72AEAB1E1372}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -11,15 +11,15 @@ Global Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution - {48B347F3-179C-4095-8BAD-96DD8E27AA30}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {48B347F3-179C-4095-8BAD-96DD8E27AA30}.Debug|Any CPU.Build.0 = Debug|Any CPU - {48B347F3-179C-4095-8BAD-96DD8E27AA30}.Release|Any CPU.ActiveCfg = Release|Any CPU - {48B347F3-179C-4095-8BAD-96DD8E27AA30}.Release|Any CPU.Build.0 = Release|Any CPU + {2973D144-5939-432F-BF4C-72AEAB1E1372}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2973D144-5939-432F-BF4C-72AEAB1E1372}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2973D144-5939-432F-BF4C-72AEAB1E1372}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2973D144-5939-432F-BF4C-72AEAB1E1372}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {B8982E10-6A6A-4998-9D50-EBD665F2462E} + SolutionGuid = {37A4FAF8-E632-4D2D-8B0B-A7942DC261D3} EndGlobalSection EndGlobal diff --git a/scripting/KeyValues.cs b/scripting/KeyValues.cs index 705f717..c04e371 100644 --- a/scripting/KeyValues.cs +++ b/scripting/KeyValues.cs @@ -1,147 +1,567 @@ -using System; +using Microsoft.VisualBasic; +using Stocks; +using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; -namespace SF2MConfigRewrite +namespace SF2MConfigRewriteV2.Keys { - public class KeyValues - { - public int currentIndex = 0; - public string fileName = string.Empty; - public string GetFloat(string key, int position = -1) - { - string brokenKey; - string newKey = "\"" + key + "\""; - StringBuilder builder = new StringBuilder(); - char[] arr; - int quoteCheck = 0; - List? line; - line = Program.globalLine; - if (position != -1 && line != null) - { - string tempKey = line[position].Replace(newKey, ""); - arr = tempKey.ToCharArray(); - } - else - { - arr = key.ToCharArray(); - } - - for (int i = 0; i < arr.Length; i++) - { - if (position == -1) - { - if (arr[i] == '\"') - { - quoteCheck++; - } - if (quoteCheck < 2) - { - continue; - } - } - if (char.IsDigit(arr[i]) || arr[i] == '.') - { - builder.Append(arr[i]); - } - } - brokenKey = builder.ToString(); - - return brokenKey; - } - - public int GetNum(string key, int position = -1) - { - string brokenKey; - string newKey = "\"" + key + "\""; - StringBuilder builder = new StringBuilder(); - char[] arr; - int quoteCheck = 0; - List? line; - line = Program.globalLine; - if (position != -1 && line != null) - { - string tempKey = line[position].Replace(newKey, ""); - arr = tempKey.ToCharArray(); - } - else - { - arr = key.ToCharArray(); - } - - for (int i = 0; i < arr.Length; i++) - { - if (position == -1) - { - if (arr[i] == '\"') - { - quoteCheck++; - } - if (quoteCheck < 2) - { - continue; - } - } - if (char.IsDigit(arr[i])) - { - builder.Append(arr[i]); - } - } - brokenKey = builder.ToString(); - if (string.IsNullOrEmpty(brokenKey)) - { - return 0; - } - - return int.Parse(brokenKey); - } - - public string GetString(string key, int position = -1, string optionalFile = "") - { - string newFile = fileName; - if (optionalFile != "") - { - newFile = optionalFile; - } - string brokenKey; - string newKey = "\"" + key + "\""; - StringBuilder builder = new StringBuilder(); - char[] arr; - int quoteCheck = 0; - List? line = Program.globalLine; - if (position != -1 && line != null) - { - string tempKey = line[position].Replace(newKey, ""); - arr = tempKey.ToCharArray(); - } - else - { - arr = key.ToCharArray(); - } - - for (int i = 0; i < arr.Length; i++) - { - if (position == -1) - { - if (arr[i] == '\"') - { - quoteCheck++; - } - if (quoteCheck < 2) - { - continue; - } - } - if (char.IsLetterOrDigit(arr[i]) || arr[i] == '.' || arr[i] == '_' || arr[i] == '-' || ((arr[i] == '/' || arr[i] == '\\') && arr[i] != '\t')) - { - builder.Append(arr[i]); - } - } - brokenKey = builder.ToString(); - - return brokenKey; - } - } + public class KeyValues + { + public string Name; + private List[] Keys; + private List IsSection; + private List Indexes; + Stack Root; + List ParentKeys; + + public KeyValues(string name = "") + { + this.Name = name; + this.Keys = new List[2]; + for (int i = 0; i < 2; i++) + { + this.Keys[i] = new List(); + } + this.IsSection = new List(); + this.Indexes = new List(); + Root = new Stack(); + this.ParentKeys = new List(); + } + + ~KeyValues() + { + this.Keys = null; + this.IsSection = null; + this.Indexes = null; + } + + public KeyValues FindKey(string key) + { + if (key == string.Empty || key.Length == 0) + { + return null; + } + + return null; + } + + public bool ReadFromFile(List content) + { + while (this.Root.Count > 0) + { + this.Root.Pop(); + } + this.IsSection.Clear(); + this.Indexes.Clear(); + this.Keys[0].Clear(); + this.Keys[1].Clear(); + this.ParentKeys.Clear(); + bool wasConditional = false; + KeyValues nextKeys = null; + KeyValues currentKeys = this; + Stack previousKeys = new Stack(); + string section = string.Empty; + int bracket = 0; + StringBuilder builder = new StringBuilder(); + for (int i = 0; i < content.Count; i++) + { + builder.Clear(); + char[] arr; + int quoteCheck = 0; + arr = content[i].ToCharArray(); + if (i == content.Count - 2) + { + + } + for (int i2 = 0; i2 < arr.Length; i2++) + { + if (arr[i2] == '\"') + { + quoteCheck++; + } + if (char.IsWhiteSpace(arr[i2]) && quoteCheck % 2 != 1) + { + continue; + } + builder.Append(arr[i2]); + } + string s = builder.ToString(); + if (s.Length == 0 || s == string.Empty || s == "") + { + continue; + } + // Let's break some keyvalues down + if (s[0] == '\"') + { + int splits = s.Split('\"').Length - 1; + if (splits % 2 != 0 || splits > 4) + { + return false; + } + + string[] splittedKeys = s.Split('\"'); + int index = 0; + for (int i2 = 0; i2 < splittedKeys.Length; i2++) + { + if (splittedKeys[i2].Length == 0 || splittedKeys[i2] == string.Empty || splittedKeys[i2] == "" || splittedKeys[i2].Contains("//")) + { + continue; + } + currentKeys.Keys[index].Add(splittedKeys[i2]); + index++; + + if (splittedKeys.Length == 3) + { + currentKeys.Keys[index].Add(""); + currentKeys.IsSection.Add(true); + section = splittedKeys[i2]; + } + else + { + if (i2 == splittedKeys.Length - 2) + { + currentKeys.IsSection.Add(false); + } + } + } + currentKeys.Indexes.Add(i); + } + + // Now let's split up some sections + if (s[0] == '{') + { + bracket++; + previousKeys.Push(currentKeys); + nextKeys = new KeyValues(); + nextKeys.Name = section; + currentKeys.ParentKeys.Add(nextKeys); + currentKeys = nextKeys; + } + + if (s[0] == '}') + { + bracket--; + currentKeys = previousKeys.Pop(); + } + } + + if (bracket != 0) + { + return false; + } + return this.GotoFirstSubKey(); + } + + public bool ReadFromFile(string content) + { + List strings = new List(); + strings = File.ReadAllLines(content).ToList(); + + return this.ReadFromFile(strings); + } + + string RetrieveKeyValue(string key, out bool success) + { + for (int i = 0; i < this.Root.Peek().Keys[0].Count; i++) + { + if (this.Root.Peek().IsSection[i]) + { + continue; + } + + if (this.Root.Peek().Keys[0][i] == key) + { + success = true; + return this.Root.Peek().Keys[1][i]; + } + } + + success = false; + return string.Empty; + } + + public float GetKeyValue(string key, float def) + { + bool success = false; + string value = RetrieveKeyValue(key, out success); + if (!success) + { + return def; + } + + return float.Parse(value); + } + + public int GetKeyValue(string key, int def) + { + bool success = false; + string value = RetrieveKeyValue(key, out success); + if (!success) + { + return def; + } + + return int.Parse(value); + } + + public string GetKeyValue(string key, string def) + { + bool success = false; + string value = RetrieveKeyValue(key, out success); + if (!success) + { + return def; + } + + return value; + } + + public bool GetKeyValue(string key, bool def) + { + bool success = false; + string value = RetrieveKeyValue(key, out success); + if (!success) + { + return def; + } + + return int.Parse(value) != 0; + } + + public void GetKeyValue(string key, out float[] inp, float[] def) + { + inp = def; + bool success = false; + string value = RetrieveKeyValue(key, out success); + if (!success) + { + return; + } + string[] subKey = value.Split(' '); + int i = 0; + foreach (string index in subKey) + { + inp[i] = float.Parse(index); + i++; + } + } + + public void GetKeyValue(string key, out int[] inp, int[] def) + { + inp = def; + bool success = false; + string value = RetrieveKeyValue(key, out success); + if (!success) + { + return; + } + string[] subKey = value.Split(' '); + int i = 0; + foreach (string index in subKey) + { + inp[i] = int.Parse(index); + i++; + } + } + + public string GetProfileKeyWithDifficultySuffix(string key, Difficulty difficulty) + { + string value = string.Empty; + if (difficulty < Difficulty.Easy || difficulty > Difficulty.Max) + { + return string.Empty; + } + + string[] suffixes = new string[] { "easy", "", "hard", "insane", "nightmare", "apollyon" }; + if (difficulty != Difficulty.Normal) + { + value = key + "_" + suffixes[(int)difficulty]; + } + else + { + value = key; + } + + return value; + } + + public void GetDifficultyValues(string baseKey, out float[] values, float[] defaultValues) + { + values = defaultValues; + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + bool success = false; + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string value = RetrieveKeyValue(key, out success); + if (success) + { + values[i] = this.GetKeyValue(key, defaultValues[i]); + } + else + { + if (i > 0) + { + values[i] = values[i - 1]; + } + } + } + } + + public void GetDifficultyValues(string baseKey, out int[] values, int[] defaultValues) + { + values = defaultValues; + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + bool success = false; + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string value = RetrieveKeyValue(key, out success); + if (success) + { + values[i] = this.GetKeyValue(key, defaultValues[i]); + } + else + { + if (i > 0) + { + values[i] = values[i - 1]; + } + } + } + } + + public void GetDifficultyValues(string baseKey, out bool[] values, bool[] defaultValues) + { + values = defaultValues; + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + bool success = false; + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string value = RetrieveKeyValue(key, out success); + if (success) + { + values[i] = this.GetKeyValue(key, defaultValues[i]); + } + else + { + if (i > 0) + { + values[i] = values[i - 1]; + } + } + } + } + + public void GetDifficultyValues(string baseKey, out string[] values, string[] defaultValues) + { + values = defaultValues; + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + bool success = false; + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string value = RetrieveKeyValue(key, out success); + if (success) + { + values[i] = this.GetKeyValue(key, defaultValues[i]); + } + else + { + if (i > 0) + { + values[i] = values[i - 1]; + } + } + } + } + + public void GetDifficultyValues(string baseKey, out float[][] values, float[][] defaultValues) + { + values = defaultValues; + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + bool success = false; + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string value = RetrieveKeyValue(key, out success); + if (success) + { + this.GetKeyValue(key, out values[i], defaultValues[i]); + } + else + { + if (i > 0) + { + values[i] = values[i - 1]; + } + } + } + } + + public void GetDifficultyValues(string baseKey, out int[][] values, int[][] defaultValues) + { + values = defaultValues; + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + bool success = false; + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string value = RetrieveKeyValue(key, out success); + if (success) + { + this.GetKeyValue(key, out values[i], defaultValues[i]); + } + else + { + if (i > 0) + { + values[i] = values[i - 1]; + } + } + } + } + + public bool JumpToKey(string name) + { + for (int i = 0; i < this.Root.Peek().ParentKeys.Count; i++) + { + if (this.Root.Peek().ParentKeys[i].Name == name) + { + this.Root.Push(this.Root.Peek().ParentKeys[i]); + return true; + } + } + return false; + } + + public bool GoBack() + { + if (this.Root.Count() == 0) + { + return false; + } + this.Root.Pop(); + return true; + } + + public string GetSectionName() + { + return this.Root.Count() == 0 ? this.Name : this.Root.Peek().Name; + } + + public bool GotoFirstSubKey() + { + if (this.Root.Count != 0 && this.Root.Peek().ParentKeys.Count == 0) + { + return false; + } + + if (this.Root.Count == 0) + { + this.Root.Push(this.ParentKeys[0]); + } + else + { + this.Root.Push(this.Root.Peek().ParentKeys[0]); + } + return true; + } + + public bool GotoNextKey() + { + KeyValues kv = this.Root.Peek(); + if (kv == null) + { + return false; + } + + this.Root.Pop(); + int index = this.Root.Peek().ParentKeys.IndexOf(kv); + if (index == -1 || index + 1 >= this.Root.Peek().ParentKeys.Count) + { + // Fuck let's go back + this.Root.Push(kv); + return false; + } + + this.Root.Push(this.Root.Peek().ParentKeys[index + 1]); + return true; + } + + public int GetSectionIndex(string name) + { + if (this.Root.Peek().Name == name) + { + return this.Root.Peek().Indexes[0] - 1; + } + int index = 0; + do + { + index = this.Root.Peek().Keys[0].IndexOf(name); + } + while (!this.Root.Peek().IsSection[index]); + index = this.Root.Peek().Indexes[index]; + return index; + } + + public int GetKeyIndex(string name) + { + int index = 0; + do + { + index = this.Root.Peek().Keys[0].IndexOf(name); + } + while (this.Root.Peek().IsSection[index]); + index = this.Root.Peek().Indexes[index]; + return index; + } + + public string FormatFloat(float value) + { + string result = value.ToString(); + if (!result.Contains('.')) + { + result += ".0"; + } + else + { + if (!char.IsNumber(result[result.Length - 1])) + { + result += "0"; + } + } + return result; + } + + public string FormatBool(bool value) + { + if (value) + { + return "1"; + } + return "0"; + } + + public List GetParentKeys() + { + return this.Root.Peek().ParentKeys; + } + } } diff --git a/scripting/Stocks.cs b/scripting/Stocks.cs index 34e692a..d3570a9 100644 --- a/scripting/Stocks.cs +++ b/scripting/Stocks.cs @@ -1,1206 +1,914 @@ -using System.Diagnostics; + +using SF2MConfigRewriteV2.Keys; +using System.Collections.Generic; using System.Text; -using System.Text.RegularExpressions; -using SF2MConfigRewrite; - -public static class Stocks -{ - public static string BreakMultiSoundDown(string line) - { - StringBuilder stringBuilder = new StringBuilder(); - byte quoteCheck = 0; - char[] arr = line.ToCharArray(); - for (int i2 = 0; i2 < arr.Length; i2++) - { - if (arr[i2] == '\"') - { - quoteCheck++; - if (quoteCheck > 2) - { - break; - } - } - if (char.IsLetterOrDigit(arr[i2]) || arr[i2] == '_') - { - stringBuilder.Append(arr[i2]); - } - } - string returnValue = stringBuilder.ToString(); - return returnValue; - } - public static bool IsCharSymbol(char c) - { - if (c == '-' || c == '/' || c == '{' || c == '}' || c == '[' || c == ']' || c == '(' || c == ')' || c == '<' || c == '>' || c == '!' || - c == '?' || c == '=' || c == '+' || c == '|' || c == '\\' || c == '/' || c == '\'' || c == '@' || c == '#' || c == '$' || c == '%' || c == '^' - || c == '^' || c == '&' || c == '*' || c == '_' || c == '.' || c == '`' || c == '~' || c == ';' || c == ':' || c == ',') - { - return true; - } - return false; - } - - public static void WriteAnimationSection(List keys, string baseKey, List line, int firstIndex, out int storedIndex) - { - line.Insert(firstIndex, "\t\t\t\"" + baseKey + "\""); - firstIndex++; - line.Insert(firstIndex, "\t\t\t{"); - firstIndex++; - line.Insert(firstIndex, "\t\t\t\t\"1\""); - firstIndex++; - line.Insert(firstIndex, "\t\t\t\t{"); - firstIndex++; - - string newKey = string.Empty; - for (int i = 0; i < keys.Count; i++) - { - newKey = "\t\t\t\t\t" + keys[i]; - line.Insert(firstIndex, newKey); - firstIndex++; - } - line.Insert(firstIndex, "\t\t\t\t}"); - firstIndex++; - line.Insert(firstIndex, "\t\t\t}"); - firstIndex++; - storedIndex = firstIndex; - } - - public static void AddFootstepIntervals(List line, string footstepInterval, string baseAnimationName) - { - for (int i = 0; i < line.Count; i++) - { - if (line[i].Contains("\"" + baseAnimationName + "\"")) - { - int bracketIndex = 1; - int bracketCheck = i; - while (!line[bracketCheck].Contains("{")) - { - bracketCheck++; - } - while (!line[bracketCheck].Contains("\"")) - { - bracketCheck++; - } - for (int j = bracketCheck; j < line.Count; j++) - { - if (line[j].Contains("}")) - { - bracketIndex--; - if (bracketIndex <= 0) - { - return; - } - } - if (line[j].Contains("{")) - { - bracketIndex++; - while (!line[j].Contains("}")) - { - j++; - } - bracketIndex--; - if (footstepInterval != "0.0" && footstepInterval != "0") - { - line.Insert(j, "\"animation_" + baseAnimationName + "_footstepinterval\" \"" + footstepInterval + "\""); - } - j++; - } - } - } - } - } - - public static void ReplaceAnimationNames(string fileName, string text, string keyName, bool ignoreDifficulty = false) - { - text = File.ReadAllText(fileName); - text = text.Replace("\"" + keyName + "\"", "\"name\""); - - text = text.Replace("\"" + keyName + "_playbackrate\"", "\"playbackrate\""); - - text = text.Replace("\"" + keyName + "_footstepinterval\"", "\"footstepinterval\""); - - text = text.Replace("\"" + keyName + "_cycle\"", "\"cycle\""); - - if (!ignoreDifficulty) - { - text = text.Replace("\"" + keyName + "_hard\"", "\"name_hard\""); - - text = text.Replace("\"" + keyName + "_hard_playbackrate\"", "\"playbackrate_hard\""); - - text = text.Replace("\"" + keyName + "_hard_footstepinterval\"", "\"footstepinterval_hard\""); - - text = text.Replace("\"" + keyName + "_hard_cycle\"", "\"cycle_hard\""); - - text = text.Replace("\"" + keyName + "_insane\"", "\"name_insane\""); - - text = text.Replace("\"" + keyName + "_insane_playbackrate\"", "\"playbackrate_insane\""); - - text = text.Replace("\"" + keyName + "_insane_footstepinterval\"", "\"footstepinterval_insane\""); - - text = text.Replace("\"" + keyName + "_insane_cycle\"", "\"cycle_insane\""); - - text = text.Replace("\"" + keyName + "_nightmare\"", "\"name_nightmare\""); - - text = text.Replace("\"" + keyName + "_nightmare_playbackrate\"", "\"playbackrate_nightmare\""); - - text = text.Replace("\"" + keyName + "_nightamre_footstepinterval\"", "\"footstepinterval_nightmare\""); - - text = text.Replace("\"" + keyName + "_nightmare_cycle\"", "\"cycle_nightmare\""); - - text = text.Replace("\"" + keyName + "_apollyon\"", "\"name_apollyon\""); - - text = text.Replace("\"" + keyName + "_apollyon_playbackrate\"", "\"playbackrate_apollyon\""); - - text = text.Replace("\"" + keyName + "_apollyon_footstepinterval\"", "\"footstepinterval_apollyon\""); - - text = text.Replace("\"" + keyName + "_apollyon_cycle\"", "\"cycle_apollyon\""); - } - File.WriteAllText(fileName, text); - } - - public static string ReplaceDifficultyKeyValue(string text, string keyValue, string newKeyValue) - { - text = text.Replace("\"" + keyValue + "\"", "\"" + newKeyValue + "\""); - - text = text.Replace("\"" + keyValue + "_easy\"", "\"" + newKeyValue + "_easy\""); - - text = text.Replace("\"" + keyValue + "_hard\"", "\"" + newKeyValue + "_hard\""); - - text = text.Replace("\"" + keyValue + "_insane\"", "\"" + newKeyValue + "_insane\""); - - text = text.Replace("\"" + keyValue + "_nightmare\"", "\"" + newKeyValue + "_nightmare\""); - - text = text.Replace("\"" + keyValue + "_apollyon\"", "\"" + newKeyValue + "_apollyon\""); - - return text; - } - - public static void RewriteMultiSoundSections(string baseKeyName, string fileName, List line, List floatSoundParams, List intSoundParams, KeyValues kv) - { - floatSoundParams.Clear(); - floatSoundParams.Add("1.0"); // Volume - floatSoundParams.Add("1.5"); // Cooldown Min - floatSoundParams.Add("1.5"); // Cooldown Max - intSoundParams.Clear(); - intSoundParams.Add(0); // Channel - intSoundParams.Add(0); // Flags - intSoundParams.Add(90); // Level - intSoundParams.Add(100); // Pitch - intSoundParams.Add(100); // Pitch Random Min - intSoundParams.Add(100); // Pitch Random Max - for (int i = 0; i < line.Count; i++) - { - if (line[i].Contains("\"" + baseKeyName + "_volume\"")) - { - floatSoundParams[0] = kv.GetFloat(baseKeyName + "_volume", i); - } - if (line[i].Contains("\"" + baseKeyName + "_cooldown_min\"")) - { - floatSoundParams[1] = kv.GetFloat(baseKeyName + "_cooldown_min", i); - } - if (line[i].Contains("\"" + baseKeyName + "_cooldown_max\"")) - { - floatSoundParams[2] = kv.GetFloat(baseKeyName + "_cooldown_max", i); - } - if (line[i].Contains("\"" + baseKeyName + "_channel\"")) - { - intSoundParams[0] = kv.GetNum(baseKeyName + "_channel", i); - } - if (line[i].Contains("\"" + baseKeyName + "_flags\"")) - { - intSoundParams[1] = kv.GetNum(baseKeyName + "_flags", i); - } - if (line[i].Contains("\"" + baseKeyName + "_level\"")) - { - intSoundParams[2] = kv.GetNum(baseKeyName + "_level", i); - } - if (line[i].Contains("\"" + baseKeyName + "_pitch\"")) - { - intSoundParams[3] = kv.GetNum(baseKeyName + "_pitch", i); - } - if (line[i].Contains("\"" + baseKeyName + "_pitch_random_min\"")) - { - intSoundParams[4] = kv.GetNum(baseKeyName + "_pitch_random_min", i); - } - if (line[i].Contains("\"" + baseKeyName + "_pitch_random_max\"")) - { - intSoundParams[5] = kv.GetNum(baseKeyName + "_pitch_random_max", i); - } - } - for (int i = 0; i < line.Count; i++) - { - if (line[i].Contains("\"" + baseKeyName + "\"")) - { - byte bracketIndex = 1; - int bracketCheck = i; - while (!line[bracketCheck].Contains('{')) - { - bracketCheck++; - } - while (!line[bracketCheck].Contains('\"')) - { - bracketCheck++; - } - for (int j = bracketCheck; j < line.Count; j++) - { - if (line[j].Contains('}')) - { - bracketIndex--; - if (bracketIndex < 1) - { - break; - } - } - if (line[j].Contains('{')) - { - bracketIndex++; - j++; - bool doSpace = false; - if (floatSoundParams[0] != "1.0" && floatSoundParams[0] != "1") - { - line.Insert(j, "\"volume\" \"" + floatSoundParams[0] + "\""); - j++; - doSpace = true; - } - if (floatSoundParams[1] != "1.5") - { - line.Insert(j, "\"cooldown_min\" \"" + floatSoundParams[1] + "\""); - j++; - doSpace = true; - } - if (floatSoundParams[2] != "1.5") - { - line.Insert(j, "\"cooldown_max\" \"" + floatSoundParams[2] + "\""); - j++; - doSpace = true; - } - if (intSoundParams[0] != 0) - { - line.Insert(j, "\"channel\" \"" + intSoundParams[0] + "\""); - j++; - doSpace = true; - } - if (intSoundParams[1] != 0) - { - line.Insert(j, "\"flags\" \"" + intSoundParams[1] + "\""); - j++; - doSpace = true; - } - if (intSoundParams[2] != 90) - { - line.Insert(j, "\"level\" \"" + intSoundParams[2] + "\""); - j++; - doSpace = true; - } - if (intSoundParams[3] != 100) - { - line.Insert(j, "\"pitch\" \"" + intSoundParams[3] + "\""); - j++; - doSpace = true; - } - if (intSoundParams[4] != 100) - { - line.Insert(j, "\"pitch_random_min\" \"" + intSoundParams[4] + "\""); - j++; - doSpace = true; - } - if (intSoundParams[5] != 100) - { - line.Insert(j, "\"pitch_random_max\" \"" + intSoundParams[5] + "\""); - j++; - doSpace = true; - } - if (doSpace) - { - line.Insert(j, ""); - j++; - } - line.Insert(j, "\"paths\""); - j++; - line.Insert(j, "{"); - j++; - while (!line[j].Contains('}')) - { - j++; - } - line.Insert(j, "}"); - bracketCheck = j; - } - } - } - } - File.WriteAllLines(fileName, line); - } - - public static void ChangeMultiSoundSections(string baseKeyName, string fileName, List line, KeyValues kv, bool splitSections) - { - List> listCeptionSounds = new List>(); - List> listCeptionFloats = new List>(); - List> listCeptionInts = new List>(); - List tempIndexes = new List(); - List attackIndexes = new List(); - StringBuilder stringBuilder; - for (int i = 0; i < line.Count; i++) - { - if (line[i].Contains("\"" + baseKeyName) && (line[i].Contains("_volume\"") || line[i].Contains("_pitch\"") - || line[i].Contains("_flags\"") || line[i].Contains("_level\"") || line[i].Contains("_cooldown_min\"") - || line[i].Contains("_cooldown_max\"") || line[i].Contains("_pitch_random_min\"") || line[i].Contains("_pitch_random_max\"") || line[i].Contains("_channel\""))) - { - List tempFloatSoundParams; - List tempIntSoundParams; - stringBuilder = new StringBuilder(); - byte byteIndex = 0, quoteCheck = 0; - char[] arr = line[i].ToCharArray(); - for (int i2 = 0; i2 < arr.Length; i2++) - { - if (arr[i2] == '\"') - { - quoteCheck++; - if (quoteCheck == 2) - { - break; - } - } - if (char.IsDigit(arr[i2])) - { - stringBuilder.Append(arr[i2]); - } - } - if (stringBuilder.Length <= 0) - { - stringBuilder.Append('1'); - } - byteIndex = byte.Parse(stringBuilder.ToString()); - if (tempIndexes.Count > 0) - { - int index = tempIndexes.IndexOf(byteIndex); - if (index == -1) - { - tempIndexes.Add(byteIndex); - tempFloatSoundParams = new List(); - tempIntSoundParams = new List(); - tempFloatSoundParams.Add("1.0"); // Volume - tempFloatSoundParams.Add("1.5"); // Cooldown Min - tempFloatSoundParams.Add("1.5"); // Cooldown Max - tempIntSoundParams.Add(0); // Channel - tempIntSoundParams.Add(0); // Flags - tempIntSoundParams.Add(90); // Level - tempIntSoundParams.Add(100); // Pitch - tempIntSoundParams.Add(100); // Pitch Random Min - tempIntSoundParams.Add(100); // Pitch Random Max - switch (line[i]) - { - case string a when line[i].Contains("_volume\""): - a = BreakMultiSoundDown(line[i]); - tempFloatSoundParams[0] = kv.GetFloat(a, i).ToString(); - break; - case string a when line[i].Contains("_cooldown_min\""): - a = BreakMultiSoundDown(line[i]); - tempFloatSoundParams[1] = kv.GetFloat(a, i).ToString(); - break; - case string a when line[i].Contains("_cooldown_max\""): - a = BreakMultiSoundDown(line[i]); - tempFloatSoundParams[2] = kv.GetFloat(a, i).ToString(); - break; - case string a when line[i].Contains("_channel\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[0] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_flags\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[1] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_level\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[2] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_pitch\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[3] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_pitch_random_min\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[4] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_pitch_random_max\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[5] = kv.GetNum(a, i); - break; - } - listCeptionFloats.Add(tempFloatSoundParams); - listCeptionInts.Add(tempIntSoundParams); - } - else - { - tempFloatSoundParams = listCeptionFloats[index]; - tempIntSoundParams = listCeptionInts[index]; - switch (line[i]) - { - case string a when line[i].Contains("_volume\""): - a = BreakMultiSoundDown(line[i]); - tempFloatSoundParams[0] = kv.GetFloat(a, i).ToString(); - break; - case string a when line[i].Contains("_cooldown_min\""): - a = BreakMultiSoundDown(line[i]); - tempFloatSoundParams[1] = kv.GetFloat(a, i).ToString(); - break; - case string a when line[i].Contains("_cooldown_max\""): - a = BreakMultiSoundDown(line[i]); - tempFloatSoundParams[2] = kv.GetFloat(a, i).ToString(); - break; - case string a when line[i].Contains("_channel\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[0] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_flags\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[1] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_level\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[2] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_pitch\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[3] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_pitch_random_min\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[4] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_pitch_random_max\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[5] = kv.GetNum(a, i); - break; - } - listCeptionFloats[index] = tempFloatSoundParams; - listCeptionInts[index] = tempIntSoundParams; - } - } - else - { - tempIndexes.Add(byteIndex); - tempFloatSoundParams = new List(); - tempIntSoundParams = new List(); - tempFloatSoundParams.Add("1.0"); // Volume - tempFloatSoundParams.Add("1.5"); // Cooldown Min - tempFloatSoundParams.Add("1.5"); // Cooldown Max - tempIntSoundParams.Add(0); // Channel - tempIntSoundParams.Add(0); // Flags - tempIntSoundParams.Add(90); // Level - tempIntSoundParams.Add(100); // Pitch - tempIntSoundParams.Add(100); // Pitch Random Min - tempIntSoundParams.Add(100); // Pitch Random Max - switch (line[i]) - { - case string a when line[i].Contains("_volume\""): - a = BreakMultiSoundDown(line[i]); - tempFloatSoundParams[0] = kv.GetFloat(a, i).ToString(); - break; - case string a when line[i].Contains("_cooldown_min\""): - a = BreakMultiSoundDown(line[i]); - tempFloatSoundParams[1] = kv.GetFloat(a, i).ToString(); - break; - case string a when line[i].Contains("_cooldown_max\""): - a = BreakMultiSoundDown(line[i]); - tempFloatSoundParams[2] = kv.GetFloat(a, i).ToString(); - break; - case string a when line[i].Contains("_channel\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[0] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_flags\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[1] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_level\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[2] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_pitch\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[3] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_pitch_random_min\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[4] = kv.GetNum(a, i); - break; - case string a when line[i].Contains("_pitch_random_max\""): - a = BreakMultiSoundDown(line[i]); - tempIntSoundParams[5] = kv.GetNum(a, i); - break; - } - listCeptionFloats.Add(tempFloatSoundParams); - listCeptionInts.Add(tempIntSoundParams); - } - line.RemoveAt(i); - i--; - File.WriteAllLines(fileName, line); - } - } - for (int i = 0; i < line.Count; i++) - { - if (line[i].Contains("\"" + baseKeyName) && !line[i].Contains("_volume\"") && !line[i].Contains("_pitch\"") - && !line[i].Contains("_flags\"") && !line[i].Contains("_level\"") && !line[i].Contains("_channel\"") && !line[i].Contains("_cooldown_min\"") - && !line[i].Contains("_cooldown_max\"") && !line[i].Contains("_pitch_random_min\"") && !line[i].Contains("_pitch_random_max\"")) - { - int originalIndex = i; - int bracketCheck = i + 2; - if (line[bracketCheck + 1].Contains('{')) - { - continue; - } - else - { - List attackSoundPaths = new List(); - int index = 1; - while (bracketCheck < line.Count - 1 && !line[bracketCheck].Contains('\"') && !line[bracketCheck].Contains('}')) - { - bracketCheck++; - } - if (line[i].Contains("sound_attackenemy")) - { - - } - while (!line[bracketCheck].Contains('}')) - { - string s1 = kv.GetString(index.ToString(), bracketCheck); - if (s1 == string.Empty) - { - break; - } - attackSoundPaths.Add(s1); - index++; - bracketCheck++; - } - listCeptionSounds.Add(attackSoundPaths); - if (line[i].Contains("\"" + baseKeyName + "_")) - { - int bracketCheck2 = i; - while (!line[bracketCheck2].Contains('{') && bracketCheck2 < line.Count) - { - bracketCheck2++; - } - stringBuilder = new StringBuilder(); - byte byteIndex = 0, quoteCheck = 0; - char[] arr = line[i].ToCharArray(); - for (int i2 = 0; i2 < arr.Length; i2++) - { - if (arr[i2] == '\"') - { - quoteCheck++; - if (quoteCheck == 2) - { - break; - } - } - if (char.IsDigit(arr[i2])) - { - stringBuilder.Append(arr[i2]); - } - } - if (stringBuilder.Length > 0) - { - byteIndex = byte.Parse(stringBuilder.ToString()); - if (attackIndexes.IndexOf(byteIndex) == -1) - { - attackIndexes.Add(byteIndex); - } - } - line.RemoveAt(i); - bracketCheck2--; - while (!line[bracketCheck2].Contains('}')) - { - line.RemoveAt(bracketCheck2); - } - line.RemoveAt(bracketCheck2); - i = bracketCheck2 - 1; - } - else if (line[i].Contains("\"" + baseKeyName + "\"") && splitSections) - { - if (attackIndexes.IndexOf(1) == -1) - { - attackIndexes.Add(1); - } - int removeAt = i; - while (!line[removeAt].Contains('{')) - { - removeAt++; - } - removeAt++; - while (!line[removeAt].Contains('}')) - { - line.RemoveAt(removeAt); - i--; - } - i = originalIndex; - } - File.WriteAllLines(fileName, line); - } - } - } - bool foundSection = false; - for (int i = 0; i < line.Count; i++) - { - if (line[i].Contains("\"" + baseKeyName + "\"")) - { - foundSection = true; - int bracketCheck = i; - while (!line[bracketCheck].Contains('}')) - { - bracketCheck++; - } - for (int j = 0; j < attackIndexes.Count; j++) - { - line.Insert(bracketCheck, "\"" + attackIndexes[j] + "\""); - bracketCheck++; - line.Insert(bracketCheck, "{"); - bracketCheck++; - List attackSoundPaths = listCeptionSounds[j]; - if (attackSoundPaths != null) - { - bool bracketIncrease = false; - if (listCeptionFloats.Count > 0 && listCeptionFloats.Count > j) - { - List tempFloatSoundParams = listCeptionFloats[j]; - for (int k = 0; k < tempFloatSoundParams.Count; k++) - { - if (k == 0) - { - if (tempFloatSoundParams[k] == "1.0" || tempFloatSoundParams[k] == "1") - { - continue; - } - line.Insert(bracketCheck, "\"volume\" \"" + tempFloatSoundParams[k] + "\""); - bracketCheck++; - bracketIncrease = true; - } - else - { - if (tempFloatSoundParams[k] == "1.5") - { - continue; - } - if (k == 1) - { - line.Insert(bracketCheck, "\"cooldown_min\" \"" + tempFloatSoundParams[k] + "\""); - } - else - { - line.Insert(bracketCheck, "\"cooldown_max\" \"" + tempFloatSoundParams[k] + "\""); - } - bracketCheck++; - bracketIncrease = true; - } - } - } - if (listCeptionInts.Count > 0 && listCeptionInts.Count > j) - { - List tempIntSoundParams = listCeptionInts[j]; - for (int k = 0; k < tempIntSoundParams.Count; k++) - { - if (k == 0) - { - if (tempIntSoundParams[k] == 0) - { - continue; - } - line.Insert(bracketCheck, "\"channel\" \"" + tempIntSoundParams[k] + "\""); - bracketCheck++; - bracketIncrease = true; - } - else if (k == 1) - { - if (tempIntSoundParams[k] == 0) - { - continue; - } - line.Insert(bracketCheck, "\"flags\" \"" + tempIntSoundParams[k] + "\""); - bracketCheck++; - bracketIncrease = true; - } - else if (k == 2) - { - if (tempIntSoundParams[k] == 90) - { - continue; - } - line.Insert(bracketCheck, "\"level\" \"" + tempIntSoundParams[k] + "\""); - bracketCheck++; - bracketIncrease = true; - } - else - { - if (tempIntSoundParams[k] == 100) - { - continue; - } - if (k == 3) - { - line.Insert(bracketCheck, "\"pitch\" \"" + tempIntSoundParams[k] + "\""); - } - else if (k == 4) - { - line.Insert(bracketCheck, "\"pitch_random_min\" \"" + tempIntSoundParams[k] + "\""); - } - else - { - line.Insert(bracketCheck, "\"pitch_random_max\" \"" + tempIntSoundParams[k] + "\""); - } - bracketCheck++; - bracketIncrease = true; - } - } - } - if (bracketIncrease) - { - line.Insert(bracketCheck, string.Empty); - bracketCheck++; - } - line.Insert(bracketCheck, "\"paths\""); - bracketCheck++; - line.Insert(bracketCheck, "{"); - bracketCheck++; - for (int k = 0; k < attackSoundPaths.Count; k++) - { - line.Insert(bracketCheck, "\"" + (k + 1) + "\" \"" + attackSoundPaths[k] + "\""); - bracketCheck++; - } - line.Insert(bracketCheck, "}"); - bracketCheck++; - } - line.Insert(bracketCheck, "}"); - bracketCheck++; - } - - } - } - if (!foundSection) - { - int newLine = line.Count - 1; - line.Insert(newLine, "\"" + baseKeyName + "\""); - newLine++; - line.Insert(newLine, "{"); - newLine++; - for (int i = 0; i < attackIndexes.Count; i++) - { - line.Insert(newLine, "\"" + attackIndexes[i] + "\""); - newLine++; - line.Insert(newLine, "{"); - newLine++; - List attackSoundPaths = listCeptionSounds[i]; - if (attackSoundPaths != null) - { - bool bracketIncrease = false; - if (listCeptionFloats.Count > 0 && listCeptionFloats.Count > i) - { - List tempFloatSoundParams = listCeptionFloats[i]; - for (int k = 0; k < tempFloatSoundParams.Count; k++) - { - if (k == 0) - { - if (tempFloatSoundParams[k] == "1.0" || tempFloatSoundParams[k] == "1") - { - continue; - } - line.Insert(newLine, "\"volume\" \"" + tempFloatSoundParams[k] + "\""); - newLine++; - bracketIncrease = true; - } - else - { - if (tempFloatSoundParams[k] == "1.5") - { - continue; - } - if (k == 1) - { - line.Insert(newLine, "\"cooldown_min\" \"" + tempFloatSoundParams[k] + "\""); - } - else - { - line.Insert(newLine, "\"cooldown_max\" \"" + tempFloatSoundParams[k] + "\""); - } - newLine++; - bracketIncrease = true; - } - } - } - if (listCeptionInts.Count > 0 && listCeptionInts.Count > i) - { - List tempIntSoundParams = listCeptionInts[i]; - for (int k = 0; k < tempIntSoundParams.Count; k++) - { - if (k == 0) - { - if (tempIntSoundParams[k] == 0) - { - continue; - } - line.Insert(newLine, "\"channel\" \"" + tempIntSoundParams[k] + "\""); - newLine++; - bracketIncrease = true; - } - else if (k == 1) - { - if (tempIntSoundParams[k] == 0) - { - continue; - } - line.Insert(newLine, "\"flags\" \"" + tempIntSoundParams[k] + "\""); - newLine++; - bracketIncrease = true; - } - else if (k == 2) - { - if (tempIntSoundParams[k] == 90) - { - continue; - } - line.Insert(newLine, "\"level\" \"" + tempIntSoundParams[k] + "\""); - newLine++; - bracketIncrease = true; - } - else - { - if (tempIntSoundParams[k] == 100) - { - continue; - } - if (k == 3) - { - line.Insert(newLine, "\"pitch\" \"" + tempIntSoundParams[k] + "\""); - } - else if (k == 4) - { - line.Insert(newLine, "\"pitch_random_min\" \"" + tempIntSoundParams[k] + "\""); - } - else - { - line.Insert(newLine, "\"pitch_random_max\" \"" + tempIntSoundParams[k] + "\""); - } - newLine++; - bracketIncrease = true; - } - } - } - if (bracketIncrease) - { - line.Insert(newLine, string.Empty); - newLine++; - } - line.Insert(newLine, "\"paths\""); - newLine++; - line.Insert(newLine, "{"); - newLine++; - for (int k = 0; k < attackSoundPaths.Count; k++) - { - line.Insert(newLine, "\"" + (k + 1) + "\" \"" + attackSoundPaths[k] + "\""); - newLine++; - } - line.Insert(newLine, "}"); - newLine++; - } - line.Insert(newLine, "}"); - newLine++; - } - line.Insert(newLine, "}"); - } - File.WriteAllLines(fileName, line); - } - - public static void ChangeSoundSection(List line, List keyvalueName, List floatSoundParams, List intSoundParams, string baseKeyName, bool includeCooldowns = false, bool includePitchRandoms = false) - { - KeyValues kv = new KeyValues(); - bool foundSomething = false; - for (int i = 0; i < line.Count; i++) - { - if (line[i].Contains("\"" + baseKeyName + "\"") && !line[i].Contains("//")) - { - bool noPaths = false; - int findPaths = i + 1; - while (!line[findPaths].Contains('}')) - { - if (line[findPaths].Contains("\"paths\"")) - { - noPaths = true; - break; - } - findPaths++; - } - if (noPaths) - { - return; - } - } - } - for (int i = 0; i < line.Count; i++) - { - if (line[i].Contains("\"" + baseKeyName + "_volume\"") || line[i].Contains("\"" + baseKeyName + "_channel\"") - || line[i].Contains("\"" + baseKeyName + "_flags\"") || line[i].Contains("\"" + baseKeyName + "_level\"") - || line[i].Contains("\"" + baseKeyName + "_pitch\"") || line[i].Contains("\"" + baseKeyName + "_cooldown_min\"") - || line[i].Contains("\"" + baseKeyName + "_cooldown_max\"") || line[i].Contains("\"" + baseKeyName + "_pitch_random_min\"") - || line[i].Contains("\"" + baseKeyName + "_pitch_random_max\"")) - { - string keyValue = line[i]; - if (line[i].Contains("_volume")) - { - floatSoundParams[0] = kv.GetFloat(keyValue); - line.RemoveAt(i); - i--; - foundSomething = true; - } - else if (line[i].Contains("_cooldown_min")) - { - floatSoundParams[1] = kv.GetFloat(keyValue); - line.RemoveAt(i); - i--; - foundSomething = true; - } - else if (line[i].Contains("_cooldown_max")) - { - floatSoundParams[2] = kv.GetFloat(keyValue); - line.RemoveAt(i); - i--; - foundSomething = true; - } - else if (line[i].Contains("_channel")) - { - intSoundParams[0] = kv.GetNum(keyValue); - line.RemoveAt(i); - i--; - foundSomething = true; - } - else if (line[i].Contains("_flags")) - { - intSoundParams[1] = kv.GetNum(keyValue); - line.RemoveAt(i); - i--; - foundSomething = true; - } - else if (line[i].Contains("_level")) - { - intSoundParams[2] = kv.GetNum(keyValue); - line.RemoveAt(i); - i--; - foundSomething = true; - } - else if (line[i].Contains("_pitch\"")) - { - intSoundParams[3] = kv.GetNum(keyValue); - line.RemoveAt(i); - i--; - foundSomething = true; - } - else if (line[i].Contains("_pitch_random_min")) - { - intSoundParams[4] = kv.GetNum(keyValue); - line.RemoveAt(i); - i--; - foundSomething = true; - } - else if (line[i].Contains("_pitch_random_max")) - { - intSoundParams[5] = kv.GetNum(keyValue); - line.RemoveAt(i); - i--; - foundSomething = true; - } - } - } - List itemIndex = new List(); - for (int i = 0; i < line.Count; i++) - { - if (line[i].Contains("\"" + baseKeyName + "\"") && !line[i].Contains("//") && !line[i + 2].Contains("\"volume\"") && !line[i + 2].Contains("\"channel\"") - && !line[i + 2].Contains("\"flags\"") && !line[i + 2].Contains("\"level\"") && !line[i + 2].Contains("\"pitch\"") - && !line[i + 2].Contains("\"cooldown_min\"") && !line[i + 2].Contains("\"cooldown_max\"") && !line[i + 2].Contains("\"pitch_random_min\"") - && !line[i + 2].Contains("\"pitch_random_max\"") && !line[i].Contains("_loop")) - { - if (baseKeyName == "sound_hitenemy") - { - - } - int iterations = 1; - int index = 1; - int startDelete = 0; - while (!line[i + iterations].Contains('}')) - { - if (line[i + iterations].Contains('{')) - { - startDelete = i + iterations + 1; - } - if (itemIndex.Count == 0) - { - if (line[i + iterations].Contains("\"" + index.ToString() + "\"")) - { - keyvalueName.Add(line[i + iterations]); - line.RemoveAt(i + iterations); - itemIndex.Add(index); - index++; - iterations--; - } - } - else - { - for (int listIndex = 0; listIndex < itemIndex.Count; listIndex++) - { - if (line[i + iterations].Contains("\"" + itemIndex[listIndex].ToString() + "\"")) - { - line[i + iterations] = line[i + iterations].Replace("\"" + itemIndex[listIndex].ToString() + "\"", - "\"" + index.ToString() + "\""); - break; - } - } - if (line[i + iterations].Contains("\"" + index.ToString() + "\"")) - { - keyvalueName.Add(line[i + iterations]); - line.RemoveAt(i + iterations); - itemIndex.Add(index); - index++; - iterations--; - } - else - { - if (!line[i + iterations].Contains('{') && !line[i + iterations].Contains('}') && !line[i + iterations].Contains('\"')) - { - line.RemoveAt(i + iterations); - iterations--; - } - } - } - iterations++; - } - bool deleteCurly = false; - bool finished = false; - bool values = false; - bool paths = false; - while (!finished) - { - if (!deleteCurly) - { - line[startDelete] = ""; - startDelete--; - deleteCurly = true; - } - else - { - if (!values) - { - if (intSoundParams[0] != 0) - { - line.Insert(startDelete, "\t\t\t\"channel\" \"" + intSoundParams[0] + "\""); - startDelete++; - } - if (floatSoundParams[0] != "1.0" && floatSoundParams[0] != "1") - { - line.Insert(startDelete, "\t\t\t\"volume\" \"" + floatSoundParams[0] + "\""); - startDelete++; - } - if (intSoundParams[1] != 0) - { - line.Insert(startDelete, "\t\t\t\"flags\" \"" + intSoundParams[1] + "\""); - startDelete++; - } - if (intSoundParams[2] != 90) - { - line.Insert(startDelete, "\t\t\t\"level\" \"" + intSoundParams[2] + "\""); - startDelete++; - } - if (intSoundParams[3] != 100) - { - line.Insert(startDelete, "\t\t\t\"pitch\" \"" + intSoundParams[3] + "\""); - startDelete++; - } - if (floatSoundParams[1] != "1.5" && includeCooldowns) - { - line.Insert(startDelete, "\t\t\t\"cooldown_min\" \"" + floatSoundParams[1] + "\""); - startDelete++; - } - if (floatSoundParams[2] != "1.5" && includeCooldowns) - { - line.Insert(startDelete, "\t\t\t\"cooldown_max\" \"" + floatSoundParams[2] + "\""); - startDelete++; - } - if (intSoundParams[4] != 100 && includePitchRandoms) - { - line.Insert(startDelete, "\t\t\t\"pitch_random_min\" \"" + intSoundParams[4] + "\""); - startDelete++; - } - if (intSoundParams[5] != 100 && includePitchRandoms) - { - line.Insert(startDelete, "\t\t\t\"pitch_random_min\" \"" + intSoundParams[5] + "\""); - startDelete++; - } - startDelete--; - values = true; - } - else - { - if (!paths) - { - if (foundSomething) - { - startDelete++; - } - line.Insert(startDelete, "\t\t\t\"paths\""); - startDelete++; - line.Insert(startDelete, "\t\t\t{"); - paths = true; - } - else - { - for (int i2 = 0; i2 < keyvalueName.Count; i2++) - { - keyvalueName[i2] = "\t" + keyvalueName[i2]; - line.Insert(startDelete, keyvalueName[i2]); - startDelete++; - } - line.Insert(startDelete, "\t\t\t}"); - startDelete++; - line.Insert(startDelete, "\t\t}"); - finished = true; - } - } - } - startDelete++; - } - break; - } - } - } - - public static void RemoveUnnecessaryKeys(List line, string baseKeyName, List associatedKeys, KeyValues kv) - { - bool replace = false; - for (int i = 0; i < line.Count; i++) - { - if (line[i].Contains("\"" + baseKeyName + "\"") && !line[i].Contains("\"animation_")) - { - bool enabled = Convert.ToBoolean(kv.GetNum(line[i])); - if (!enabled) - { - replace = true; - break; - } - } - } - if (replace) - { - for (int i = 0; i < line.Count; i++) - { - for (int i2 = 0; i2 < associatedKeys.Count; i2++) - { - if (line[i].Contains(associatedKeys[i2])) - { - line.RemoveAt(i); - i--; - if (!line[i].Contains('\"') && !line[i].Contains('{') && !line[i].Contains('}')) - { - line.RemoveAt(i); - i--; - } - } - } - } - } - } +using System.Windows.Forms; +using System.Xml.Linq; + +namespace Stocks +{ + public enum Difficulty + { + Easy = 0, + Normal, + Hard, + Insane, + Nightmare, + Apollyon, + Max + }; + + public static class Stock + { + public static void InsertKeyValue(ref List lines, ref int index, string key) + { + lines.Insert(index, key); + index++; + } + + public static void InsertAttackIndexes(ref List indexes, string value) + { + indexes.Clear(); + if (value.Contains(' ')) + { + string[] subKey = value.Split(' '); + foreach (string str in subKey) + { + indexes.Add(int.Parse(str)); + } + } + else + { + char[] arr; + arr = value.ToCharArray(); + for (int k = 0; k < arr.Length; k++) + { + indexes.Add(arr[k] - '0'); + } + } + } + + public static void InsertAnimationSection(ref List lines, ref int index, string section, List animations, KeyValues kv) + { + InsertKeyValue(ref lines, ref index, "\"" + section + "\""); + InsertKeyValue(ref lines, ref index, "{"); + + float cycle = 0.0f; + float rate = 1.0f; + float duration = 0.0f; + float footstep = 0.0f; + string name = string.Empty; + for (int i = 0; i < animations.Count; i++) + { + InsertKeyValue(ref lines, ref index, "\"" + (i + 1) + "\""); + InsertKeyValue(ref lines, ref index, "{"); + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (animations[i].Animations[i2] != name) + { + name = animations[i].Animations[i2]; + InsertKeyValue(ref lines, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("name", (Difficulty)i2) + "\" \"" + name + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (animations[i].Playbackrates[i2] != rate) + { + rate = animations[i].Playbackrates[i2]; + InsertKeyValue(ref lines, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("rate", (Difficulty)i2) + "\" \"" + kv.FormatFloat(rate) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (animations[i].Cycles[i2] != cycle) + { + cycle = animations[i].Cycles[i2]; + InsertKeyValue(ref lines, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("cycle", (Difficulty)i2) + "\" \"" + kv.FormatFloat(cycle) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (animations[i].Durations[i2] != duration) + { + duration = animations[i].Durations[i2]; + InsertKeyValue(ref lines, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("duration", (Difficulty)i2) + "\" \"" + kv.FormatFloat(duration) + "\""); + } + } + + for (int i2 = 1; i2 < (int)Difficulty.Max; i2++) + { + if (animations[i].FootstepIntervals[i2] != footstep) + { + footstep = animations[i].FootstepIntervals[i2]; + InsertKeyValue(ref lines, ref index, "\"" + kv.GetProfileKeyWithDifficultySuffix("footstepinterval", (Difficulty)i2) + "\" \"" + kv.FormatFloat(footstep) + "\""); + } + } + + InsertKeyValue(ref lines, ref index, "}"); + InsertKeyValue(ref lines, ref index, ""); + } + + InsertKeyValue(ref lines, ref index, "}"); + } + + public static void StoreAnimationData(ref List animations, KeyValues kv) + { + if (kv.GotoFirstSubKey()) + { + do + { + ProfileAnimation animation = new ProfileAnimation(); + kv.GetDifficultyValues("name", out animation.Animations, animation.Animations); + kv.GetDifficultyValues("playbackrate", out animation.Playbackrates, animation.Playbackrates); + kv.GetDifficultyValues("cycle", out animation.Cycles, animation.Cycles); + kv.GetDifficultyValues("footstepinterval", out animation.FootstepIntervals, animation.FootstepIntervals); + kv.GetDifficultyValues("duration", out animation.Durations, animation.Durations); + animations.Add(animation); + } + while (kv.GotoNextKey()); + + kv.GoBack(); + } + kv.GoBack(); + } + + public static void ReplaceAnimationNames(string fileName, string text, string keyName, bool ignoreDifficulty = false) + { + text = File.ReadAllText(fileName); + text = text.Replace("\"" + keyName + "\"", "\"name\""); + + text = text.Replace("\"" + keyName + "_playbackrate\"", "\"playbackrate\""); + + text = text.Replace("\"" + keyName + "_footstepinterval\"", "\"footstepinterval\""); + + text = text.Replace("\"" + keyName + "_cycle\"", "\"cycle\""); + + if (!ignoreDifficulty) + { + text = text.Replace("\"" + keyName + "_hard\"", "\"name_hard\""); + + text = text.Replace("\"" + keyName + "_hard_playbackrate\"", "\"playbackrate_hard\""); + + text = text.Replace("\"" + keyName + "_hard_footstepinterval\"", "\"footstepinterval_hard\""); + + text = text.Replace("\"" + keyName + "_hard_cycle\"", "\"cycle_hard\""); + + text = text.Replace("\"" + keyName + "_insane\"", "\"name_insane\""); + + text = text.Replace("\"" + keyName + "_insane_playbackrate\"", "\"playbackrate_insane\""); + + text = text.Replace("\"" + keyName + "_insane_footstepinterval\"", "\"footstepinterval_insane\""); + + text = text.Replace("\"" + keyName + "_insane_cycle\"", "\"cycle_insane\""); + + text = text.Replace("\"" + keyName + "_nightmare\"", "\"name_nightmare\""); + + text = text.Replace("\"" + keyName + "_nightmare_playbackrate\"", "\"playbackrate_nightmare\""); + + text = text.Replace("\"" + keyName + "_nightamre_footstepinterval\"", "\"footstepinterval_nightmare\""); + + text = text.Replace("\"" + keyName + "_nightmare_cycle\"", "\"cycle_nightmare\""); + + text = text.Replace("\"" + keyName + "_apollyon\"", "\"name_apollyon\""); + + text = text.Replace("\"" + keyName + "_apollyon_playbackrate\"", "\"playbackrate_apollyon\""); + + text = text.Replace("\"" + keyName + "_apollyon_footstepinterval\"", "\"footstepinterval_apollyon\""); + + text = text.Replace("\"" + keyName + "_apollyon_cycle\"", "\"cycle_apollyon\""); + } + File.WriteAllText(fileName, text); + } + } + + /*public class KeyValues + { + public List file; + ~KeyValues() + { + file = null; + } + string BreakKeyValueDown(string value) + { + string broken = string.Empty; + StringBuilder builder = new StringBuilder(); + char[] arr; + int quoteCheck = 0; + arr = value.ToCharArray(); + for (int i = 0; i < arr.Length; i++) + { + if (arr[i] == '\"') + { + quoteCheck++; + } + if (quoteCheck < 3) + { + continue; + } + else if (quoteCheck >= 3 && arr[i] == '\"') + { + continue; + } + builder.Append(arr[i]); + } + broken = builder.ToString(); + return broken; + } + + public string GetProfileKeyWithDifficultySuffix(string key, Difficulty difficulty) + { + string value = string.Empty; + if (difficulty < Difficulty.Easy || difficulty > Difficulty.Max) + { + return string.Empty; + } + + string name = this.GetName(key); + if (name == "") + { + name = key; + } + + string[] suffixes = new string[] { "easy", "", "hard", "insane", "nightmare", "apollyon" }; + if (difficulty != Difficulty.Normal) + { + value = name + "_" + suffixes[(int)difficulty]; + } + else + { + value = name; + } + + return value; + } + + // Float + public void GetDifficultyValues(string baseKey, out float[] values, float[] defaultValues) + { + values = defaultValues; + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string result = this.file.FirstOrDefault(s => s.Contains(key)) ?? string.Empty; + if (result != string.Empty) + { + float value = float.Parse(this.GetFloat(result)); + values[i] = value; + } + else // Remember this for Sourcepawn + { + if (i > 0) + { + values[i] = values[i - 1]; + } + } + } + } + + // Int + public void GetDifficultyValues(string baseKey, out int[] values, int[] defaultValues) + { + values = defaultValues; + + if (this.GetName(baseKey) != string.Empty) + { + int value = this.GetNum(baseKey); + for (int i = 0; i < (int)Difficulty.Max; i++) + { + values[i] = value; + } + } + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string result = this.file.FirstOrDefault(s => s.Contains(key)) ?? string.Empty; + if (result != string.Empty) + { + int value = this.GetNum(key); + values[i] = value; + } + } + } + + // Bool + public void GetDifficultyValues(string baseKey, out bool[] values, bool[] defaultValues) + { + values = defaultValues; + + if (this.GetName(baseKey) != string.Empty) + { + bool value = this.GetBool(baseKey); + for (int i = 0; i < (int)Difficulty.Max; i++) + { + values[i] = value; + } + } + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string result = this.file.FirstOrDefault(s => s.Contains(key)) ?? string.Empty; + if (result != string.Empty) + { + bool value = this.GetBool(key); + values[i] = value; + } + } + } + + // String + public void GetDifficultyValues(string baseKey, out string[] values, string[] defaultValues) + { + values = defaultValues; + + if (this.GetName(baseKey) != string.Empty) + { + string value = this.GetString(baseKey); + for (int i = 0; i < (int)Difficulty.Max; i++) + { + values[i] = value; + } + } + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string result = this.file.FirstOrDefault(s => s.Contains(key)) ?? string.Empty; + if (result != string.Empty) + { + string value = this.GetString(key); + values[i] = value; + } + } + } + + // Array + public void GetDifficultyValues(string baseKey, out float[][] values, float[][] defaultValues) + { + values = defaultValues; + float[] temp = new float[3]; + + if (this.GetName(baseKey) != string.Empty) + { + this.GetArray(baseKey, out temp, temp); + for (int i = 0; i < (int)Difficulty.Max; i++) + { + values[i] = temp; + } + } + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string result = this.file.FirstOrDefault(s => s.Contains(key)) ?? string.Empty; + if (result != string.Empty) + { + this.GetArray(baseKey, out temp, temp); + values[i] = temp; + } + } + } + + public void GetDifficultyValues(string baseKey, out int[][] values, int[][] defaultValues) + { + values = defaultValues; + int[] temp = new int[3]; + + if (this.GetName(baseKey) != string.Empty) + { + this.GetArray(baseKey, out temp, temp); + for (int i = 0; i < (int)Difficulty.Max; i++) + { + values[i] = temp; + } + } + + string key; + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + key = GetProfileKeyWithDifficultySuffix(baseKey, (Difficulty)i); + string result = this.file.FirstOrDefault(s => s.Contains(key)) ?? string.Empty; + if (result != string.Empty) + { + this.GetArray(baseKey, out temp, temp); + values[i] = temp; + } + } + } + + public string GetFloat(string key, string def = "0.0") + { + if (key == string.Empty) + { + return def; + } + string result = this.BreakKeyValueDown(key); + if (!result.Contains('.')) + { + result += ".0"; + } + return result; + } + + public int GetNum(string key, int def = 0) + { + if (key == string.Empty) + { + return def; + } + return int.Parse(this.BreakKeyValueDown(key)); + } + + public bool GetBool(string key, bool def = false) + { + if (key == string.Empty) + { + return def; + } + return int.Parse(this.BreakKeyValueDown(key)) != 0; + } + + public string GetString(string key, string def = "") + { + if (key == string.Empty) + { + return def; + } + return this.BreakKeyValueDown(key); + } + + // That's right, we can get 2D vectors, vectors, colors, or whatever + public void GetArray(string key, out float[] values, float[] def) + { + values = def; + if (key == string.Empty) + { + values = def; + return; + } + string value = this.BreakKeyValueDown(key); + string[] subKey = value.Split(' '); + int i = 0; + foreach (string index in subKey) + { + values[i] = float.Parse(index); + i++; + } + } + + public void GetArray(string key, out int[] values, int[] def) + { + values = def; + if (key == string.Empty) + { + values = def; + return; + } + string value = this.BreakKeyValueDown(key); + string[] subKey = value.Split(' '); + int i = 0; + foreach (string index in subKey) + { + values[i] = int.Parse(index); + i++; + } + } + + public string GetName(string key) + { + string broken = string.Empty; + StringBuilder builder = new StringBuilder(); + char[] arr; + int quoteCheck = 0; + arr = key.ToCharArray(); + for (int i = 0; i < arr.Length; i++) + { + if (arr[i] == '\"') + { + quoteCheck++; + } + if (quoteCheck == 0) + { + continue; + } + if (quoteCheck >= 2) + { + break; + } + if (arr[i] == '\"') + { + continue; + } + builder.Append(arr[i]); + } + broken = builder.ToString(); + return broken; + } + + public string FormatFloat(float value) + { + string result = value.ToString(); + if (!result.Contains('.')) + { + result += ".0"; + } + else + { + if (!char.IsNumber(result[result.Length - 1])) + { + result += "0"; + } + } + return result; + } + }*/ + + public enum DamageType + { + Invalid = -1, + Jarate = 0, + Milk, + Gas, + Mark, + Ignite, + Stun, + Bleed, + Smite, + Random + }; + + public class ProfileSound + { + public List Sounds; + public int Channel = 0; + public float Volume = 1.0f; + public int Flags = 0; + public int Level = 90; + public int Pitch = 100; + public float CooldownMin = 1.5f; + public float CooldownMax = 1.5f; + public int PitchRandomMin = 100; + public int PitchRandomMax = 100; + public float Radius = 850.0f; + public float Chance = 1.0f; + + public ProfileSound() + { + this.Sounds = new List(); + } + + ~ProfileSound() + { + this.Sounds = null; + } + + public void GetValues(KeyValues kv) + { + this.Channel = kv.GetKeyValue("channel", this.Channel); + this.Volume = kv.GetKeyValue("volume", this.Volume); + this.Flags = kv.GetKeyValue("flags", this.Flags); + this.Level = kv.GetKeyValue("level", this.Level); + this.Pitch = kv.GetKeyValue("pitch", this.Pitch); + this.CooldownMin = kv.GetKeyValue("cooldown_min", this.CooldownMin); + this.CooldownMax = kv.GetKeyValue("cooldown_max", this.CooldownMax); + this.PitchRandomMin = kv.GetKeyValue("pitch_random_min", this.Pitch); + this.PitchRandomMax = kv.GetKeyValue("pitch_random_max", this.Pitch); + this.Chance = kv.GetKeyValue("chance", this.Chance); + kv.JumpToKey("paths"); + for (int i = 1; ; i++) + { + string path = kv.GetKeyValue(i.ToString(), string.Empty); + if (path == string.Empty) + { + break; + } + + this.Sounds.Add(path); + } + kv.GoBack(); + } + + void InsertKeyValue(ref List lines, ref int index, string key) + { + lines.Insert(index, key); + index++; + } + + public void InsertSection(string section, ref List lines, ref int index, KeyValues kv) + { + InsertKeyValue(ref lines, ref index, "\"" + section + "\""); + InsertKeyValue(ref lines, ref index, "{"); + bool whiteSpace = false; + if (this.Channel != 0) + { + InsertKeyValue(ref lines, ref index, "\"channel\" \"" + this.Channel + "\""); + whiteSpace = true; + } + + if (this.Volume != 1.0f) + { + InsertKeyValue(ref lines, ref index, "\"volume\" \"" + kv.FormatFloat(this.Volume) + "\""); + whiteSpace = true; + } + + if (this.Flags != 0) + { + InsertKeyValue(ref lines, ref index, "\"volume\" \"" + this.Flags + "\""); + whiteSpace = true; + } + + if (this.Level != 90) + { + InsertKeyValue(ref lines, ref index, "\"level\" \"" + this.Level + "\""); + whiteSpace = true; + } + + if (this.Pitch != 100) + { + InsertKeyValue(ref lines, ref index, "\"pitch\" \"" + this.Pitch + "\""); + whiteSpace = true; + } + + if (this.CooldownMin != 1.5f) + { + InsertKeyValue(ref lines, ref index, "\"cooldown_min\" \"" + kv.FormatFloat(this.CooldownMin) + "\""); + whiteSpace = true; + } + + if (this.CooldownMax != 1.5f) + { + InsertKeyValue(ref lines, ref index, "\"cooldown_max\" \"" + kv.FormatFloat(this.CooldownMax) + "\""); + whiteSpace = true; + } + + if (this.PitchRandomMin != this.Pitch || this.PitchRandomMax != this.Pitch) + { + InsertKeyValue(ref lines, ref index, "\"pitch_random_min\" \"" + this.PitchRandomMin + "\""); + InsertKeyValue(ref lines, ref index, "\"pitch_random_max\" \"" + this.PitchRandomMax + "\""); + whiteSpace = true; + } + + if (this.Chance != 1.5f) + { + InsertKeyValue(ref lines, ref index, "\"chance\" \"" + kv.FormatFloat(this.Chance) + "\""); + whiteSpace = true; + } + + if (whiteSpace) + { + InsertKeyValue(ref lines, ref index, ""); + } + InsertKeyValue(ref lines, ref index, "\"paths\""); + InsertKeyValue(ref lines, ref index, "{"); + for (int i = 0; i < this.Sounds.Count; i++) + { + InsertKeyValue(ref lines, ref index, "\"" + (i + 1) + "\" \"" + this.Sounds[i] + "\""); + } + InsertKeyValue(ref lines, ref index, "}"); + + InsertKeyValue(ref lines, ref index, "}"); + } + } + + public class ProfileAnimation + { + public string[] Animations = new string[(int)Difficulty.Max]; + public float[] Playbackrates = new float[(int)Difficulty.Max]; + public float[] FootstepIntervals = new float[(int)Difficulty.Max]; + public float[] Cycles = new float[(int)Difficulty.Max]; + public float[] Durations = new float[(int)Difficulty.Max]; + } + + public class DamageEffectData + { + public DamageType Type; + public bool[] Enabled = new bool[(int)Difficulty.Max]; + public string Particle; + public string Sound; + public bool AttachParticle; + public bool Beam; + public float[] Duration = new float[(int)Difficulty.Max]; + public List AttackIndexex; + public string Search, SearchAlt; + + public bool MarkSilent; + + public string StunFlag; + public float[] StunSlowdown = new float[(int)Difficulty.Max]; + + public float[] SmiteDamage = new float[(int)Difficulty.Max]; + public int[] SmiteDamageType = new int[(int)Difficulty.Max]; + public int[] SmiteColor = { 255, 255, 255, 255 }; + public bool SmiteMessage; + public string SmiteSound; + + public DamageEffectData(DamageType type) + { + this.Type = type; + this.SearchAlt = string.Empty; + this.Search = string.Empty; + this.Sound = string.Empty; + this.Particle = string.Empty; + this.AttackIndexex = new List(); + this.AttackIndexex.Add(1); + this.AttachParticle = true; + this.SmiteSound = ")ambient/explosions/explode_9.wav"; + this.StunFlag = "slow"; + + for (int i = 0; i < 4; i++) + { + this.SmiteColor[i] = 255; + } + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + this.Enabled[i] = true; + this.Duration[i] = 8.0f; + this.StunSlowdown[i] = 0.5f; + this.SmiteDamage[i] = 9001.0f; + this.SmiteDamageType[i] = 1048576; + } + } + + ~DamageEffectData() + { + this.AttackIndexex = null; + } + } + + public class ShockwaveData + { + public bool Enabled = false; + public float[] Height = new float[(int)Difficulty.Max]; + public float[] Range = new float[(int)Difficulty.Max]; + public float[] DrainAmount = new float[(int)Difficulty.Max]; + public float[] Force = new float[(int)Difficulty.Max]; + public bool Stun; + public float[] StunDuration = new float[(int)Difficulty.Max]; + public float[] StunSlowdown = new float[(int)Difficulty.Max]; + public float Width1; + public float Width2; + public float Amplitude; + public int[] Color1 = new int[4]; + public int[] Color2 = new int[4]; + public string BeamSprite; + public string HaloSprite; + + public List AttackIndexex; + + public ShockwaveData() + { + for (int i = 0; i < 3; i++) + { + this.Color1[i] = 128; + this.Color2[i] = 255; + } + + for (int i = 0; i < (int)Difficulty.Max; i++) + { + this.Height[i] = 80; + this.Range[i] = 200; + this.Force[i] = 600; + this.DrainAmount[i] = 0; + this.StunDuration[i] = 2; + this.StunSlowdown[i] = 0.7f; + } + + this.Width1 = 40; + this.Width2 = 20; + + this.Amplitude = 5; + + this.Color1[3] = 255; + this.Color2[3] = 255; + this.BeamSprite = "sprites/laser.vmt"; + this.HaloSprite = "sprites/halo01.vmt"; + this.AttackIndexex = new List(); + this.AttackIndexex.Add(1); + } + + ~ShockwaveData() + { + this.AttackIndexex = null; + } + } + + public class CloakData + { + public bool Enabled = false; + public float[] CloakRange = new float[(int)Difficulty.Max]; + public float[] DecloakRange = new float[(int)Difficulty.Max]; + public float[] CloakDuration = new float[(int)Difficulty.Max]; + public float[] Cooldown = new float[(int)Difficulty.Max]; + public float[] SpeedMultiplier = new float[(int)Difficulty.Max]; + + public int[] RenderColor = new int[4]; + public int RenderMode = 1; + public string CloakParticle = "drg_cow_explosioncore_charged_blue"; + public string CloakOnSound = ")weapons/medi_shield_deploy.wav"; + public string CloakOffSound = ")weapons/medi_shield_retract.wav"; + + public CloakData() + { + for (int i = 0; i < (int)Difficulty.Max; i++) + { + this.CloakRange[i] = 350.0f; + this.DecloakRange[i] = 150.0f; + this.CloakDuration[i] = 10.0f; + this.Cooldown[i] = 8.0f; + this.SpeedMultiplier[i] = 1.0f; + } + for (int i = 0; i < 4; i++) + { + this.RenderColor[i] = 0; + } + } + } + + public class RageData + { + public float PercentThreshold = 0.75f; + public bool IncreaseDifficulty = true; + + public bool Heal = false; + public bool CloakToHeal = false; + public float FleeRange = 1024.0f; + public float HealAmount = 0.5f; + public float HealDelay = 0.0f; + public float HealDuration = 1.0f; + + public ProfileSound StartSounds; + public ProfileSound HealSounds; + + public RageData() + { + StartSounds = new ProfileSound(); + HealSounds = new ProfileSound(); + } + } + + public class CopyData + { + public bool[] Enabled = new bool[(int)Difficulty.Max]; + public int[] MaxCopies = new int[(int)Difficulty.Max]; + public float[] TeleportDistance = new float[(int)Difficulty.Max]; + public bool[] Fakes = new bool[(int)Difficulty.Max]; + + public CopyData() + { + for (int i = 0; i < (int)Difficulty.Max; i++) + { + this.Enabled[i] = false; + this.MaxCopies[i] = 1; + this.TeleportDistance[i] = 800.0f; + this.Fakes[i] = false; + } + } + } + + public class AutoChaseData + { + public bool[] Enabled = new bool[(int)Difficulty.Max]; + public int[] Threshold = new int[(int)Difficulty.Max]; + public bool[] Sprinters = new bool[(int)Difficulty.Max]; + public int[] AddOnStateChange = new int[(int)Difficulty.Max]; + public int[] AddFootsteps = new int[(int)Difficulty.Max]; + public int[] AddLoudFootsteps = new int[(int)Difficulty.Max]; + public int[] AddQuietFootsteps = new int[(int)Difficulty.Max]; + public int[] AddVoice = new int[(int)Difficulty.Max]; + public int[] AddWeapon = new int[(int)Difficulty.Max]; + + public AutoChaseData() + { + for (int i = 0; i < (int)Difficulty.Max; i++) + { + this.Enabled[i] = false; + this.Threshold[i] = 100; + this.Sprinters[i] = false; + this.AddOnStateChange[i] = 0; + this.AddFootsteps[i] = 2; + this.AddLoudFootsteps[i] = 2; + this.AddQuietFootsteps[i] = 0; + this.AddVoice[i] = 8; + this.AddWeapon[i] = 4; + } + } + } } \ No newline at end of file diff --git a/sf2m.ico b/sf2m.ico index 6bdb1242d33dd334f9e6d058c95f9d99977d9796..7daddc84e1c3716b5c53fcd95208654ad9de760f 100644 GIT binary patch literal 137338 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 BDzg9p