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 6bdb124..7daddc8 100644 Binary files a/sf2m.ico and b/sf2m.ico differ