diff --git a/LocalPSM+.sln b/LocalPSM+.sln new file mode 100644 index 0000000..f818cef --- /dev/null +++ b/LocalPSM+.sln @@ -0,0 +1,37 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.28010.2003 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LocalPSM+", "LocalPSM+\LocalPSM+.csproj", "{95A59C38-8F1B-4689-8FEC-976ACF0A4829}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Debug|Any CPU.Build.0 = Debug|Any CPU + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Debug|x64.ActiveCfg = Debug|x64 + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Debug|x64.Build.0 = Debug|x64 + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Debug|x86.ActiveCfg = Debug|x86 + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Debug|x86.Build.0 = Debug|x86 + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Release|Any CPU.ActiveCfg = Release|Any CPU + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Release|Any CPU.Build.0 = Release|Any CPU + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Release|x64.ActiveCfg = Release|x64 + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Release|x64.Build.0 = Release|x64 + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Release|x86.ActiveCfg = Release|x86 + {95A59C38-8F1B-4689-8FEC-976ACF0A4829}.Release|x86.Build.0 = Release|x86 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {019539BA-E246-4BF9-901A-4ACA03D1A258} + EndGlobalSection +EndGlobal diff --git a/LocalPSM+/App.config b/LocalPSM+/App.config new file mode 100644 index 0000000..00bfd11 --- /dev/null +++ b/LocalPSM+/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/LocalPSM+/LocalPSM+.csproj b/LocalPSM+/LocalPSM+.csproj new file mode 100644 index 0000000..b1e43b5 --- /dev/null +++ b/LocalPSM+/LocalPSM+.csproj @@ -0,0 +1,150 @@ + + + + + Debug + AnyCPU + {95A59C38-8F1B-4689-8FEC-976ACF0A4829} + WinExe + LocalPSM_ + LocalPSM+ + v4.6.1 + 512 + true + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + x64 + bin\x64\Debug\ + + + x64 + bin\x64\Release\ + + + x86 + bin\x86\Debug\ + + + x86 + bin\x86\Release\ + + + PSM.ico + + + + + + + + + + + + + + + + + Form + + + PSMKeyGen.cs + + + + + PSMKeyGen.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/LocalPSM+/PSM.ico b/LocalPSM+/PSM.ico new file mode 100644 index 0000000..8c77b97 Binary files /dev/null and b/LocalPSM+/PSM.ico differ diff --git a/LocalPSM+/PSMKeyGen.Designer.cs b/LocalPSM+/PSMKeyGen.Designer.cs new file mode 100644 index 0000000..7a3eb86 --- /dev/null +++ b/LocalPSM+/PSMKeyGen.Designer.cs @@ -0,0 +1,150 @@ +namespace LocalPSM_ +{ + + partial class PSMKeyGen + { + /// + /// 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(PSMKeyGen)); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.DevName = new System.Windows.Forms.TextBox(); + this.TextColor = new System.Windows.Forms.Label(); + this.KeyGen = new System.Windows.Forms.Button(); + this.LicenseGen = new System.Windows.Forms.Button(); + this.Unity = new System.Windows.Forms.CheckBox(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.SuspendLayout(); + // + // pictureBox1 + // + this.pictureBox1.BackColor = System.Drawing.Color.Transparent; + this.pictureBox1.BackgroundImage = global::LocalPSM_.Properties.Resources.Logo; + this.pictureBox1.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Zoom; + this.pictureBox1.Location = new System.Drawing.Point(12, 12); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.Size = new System.Drawing.Size(408, 114); + this.pictureBox1.TabIndex = 0; + this.pictureBox1.TabStop = false; + // + // DevName + // + this.DevName.BackColor = System.Drawing.SystemColors.HotTrack; + this.DevName.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle; + this.DevName.Location = new System.Drawing.Point(12, 156); + this.DevName.MaxLength = 17; + this.DevName.Name = "DevName"; + this.DevName.Size = new System.Drawing.Size(408, 20); + this.DevName.TabIndex = 1; + this.DevName.TextChanged += new System.EventHandler(this.DevName_TextChanged); + // + // TextColor + // + this.TextColor.AutoSize = true; + this.TextColor.BackColor = System.Drawing.Color.Transparent; + this.TextColor.ForeColor = System.Drawing.SystemColors.ControlLightLight; + this.TextColor.Location = new System.Drawing.Point(12, 140); + this.TextColor.Name = "TextColor"; + this.TextColor.Size = new System.Drawing.Size(97, 13); + this.TextColor.TabIndex = 2; + this.TextColor.Text = "Device Name / ID:"; + // + // KeyGen + // + this.KeyGen.BackColor = System.Drawing.SystemColors.Highlight; + this.KeyGen.Enabled = false; + this.KeyGen.FlatStyle = System.Windows.Forms.FlatStyle.Flat; + this.KeyGen.Location = new System.Drawing.Point(12, 182); + this.KeyGen.Name = "KeyGen"; + this.KeyGen.Size = new System.Drawing.Size(201, 26); + this.KeyGen.TabIndex = 3; + this.KeyGen.Text = "Generate Publishing License"; + this.KeyGen.UseVisualStyleBackColor = false; + this.KeyGen.Click += new System.EventHandler(this.KeyGen_Click); + // + // LicenseGen + // + this.LicenseGen.BackColor = System.Drawing.SystemColors.Highlight; + this.LicenseGen.FlatStyle = System.Windows.Forms.FlatStyle.Flat; + this.LicenseGen.Location = new System.Drawing.Point(219, 182); + this.LicenseGen.Name = "LicenseGen"; + this.LicenseGen.Size = new System.Drawing.Size(201, 26); + this.LicenseGen.TabIndex = 4; + this.LicenseGen.Text = "Re-Activate License"; + this.LicenseGen.UseVisualStyleBackColor = false; + this.LicenseGen.Click += new System.EventHandler(this.LicenseGen_Click); + // + // Unity + // + this.Unity.AutoSize = true; + this.Unity.BackColor = System.Drawing.Color.Transparent; + this.Unity.ForeColor = System.Drawing.SystemColors.Control; + this.Unity.Location = new System.Drawing.Point(344, 140); + this.Unity.Name = "Unity"; + this.Unity.Size = new System.Drawing.Size(76, 17); + this.Unity.TabIndex = 5; + this.Unity.Text = "PSM Unity"; + this.Unity.UseVisualStyleBackColor = false; + // + // PSMKeyGen + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackgroundImage = global::LocalPSM_.Properties.Resources.bg; + this.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch; + this.ClientSize = new System.Drawing.Size(432, 236); + this.Controls.Add(this.Unity); + this.Controls.Add(this.LicenseGen); + this.Controls.Add(this.KeyGen); + this.Controls.Add(this.TextColor); + this.Controls.Add(this.DevName); + this.Controls.Add(this.pictureBox1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "PSMKeyGen"; + this.ShowIcon = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "PSM Key Generator"; + this.Load += new System.EventHandler(this.PSMKeyGen_Load); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.PictureBox pictureBox1; + private System.Windows.Forms.TextBox DevName; + private System.Windows.Forms.Label TextColor; + private System.Windows.Forms.Button KeyGen; + private System.Windows.Forms.Button LicenseGen; + private System.Windows.Forms.CheckBox Unity; + } +} + diff --git a/LocalPSM+/PSMKeyGen.cs b/LocalPSM+/PSMKeyGen.cs new file mode 100644 index 0000000..640344d --- /dev/null +++ b/LocalPSM+/PSMKeyGen.cs @@ -0,0 +1,347 @@ +using System; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Media; +using System.Net; +using System.Text.RegularExpressions; +using System.Windows.Forms; + +namespace LocalPSM_ +{ + public partial class PSMKeyGen : Form + { + public PSMKeyGen() + { + InitializeComponent(); + } + + public String UnityURL = "https://nsx.sec.np.dl.playstation.net/nsx/sec/Xz78TMQ1Uf31VCYr/c/NSXVID/NSXVID-PSM.UNITY.WW-GLOBAL.xml"; + public String PsmDevURL = "https://nsx.sec.np.dl.playstation.net/nsx/sec/Xz78TMQ1Uf31VCYr/c/NSXVID/NSXVID-PSS.VT.WW-GLOBAL.xml"; + + + private void PSMKeyGen_Load(object sender, EventArgs e) + { + Stream BGM = Properties.Resources.BGM; + SoundPlayer snd = new SoundPlayer(BGM); + snd.PlayLooping(); + } + + private void Unpack() + { + File.WriteAllBytes("cygwin1.dll", Properties.Resources.cygwin1); + File.WriteAllBytes("cygz.dll", Properties.Resources.cygz); + File.WriteAllBytes("cygcrypto-1.0.0.dll", Properties.Resources.cygcrypto_1_0_0); + File.WriteAllBytes("kconsole_sign.exe", Properties.Resources.kconsole_sign); + File.WriteAllBytes("revoke_sign.exe", Properties.Resources.revoke_sign); + File.WriteAllBytes("reverse.exe", Properties.Resources.reverse); + } + private void DownloadXML(string path) + { + WebClient wc = new WebClient(); + if (Unity.Checked) + { + byte[] XML = wc.DownloadData(UnityURL); + File.WriteAllBytes(path, XML); + } + else + { + byte[] XML = wc.DownloadData(PsmDevURL); + File.WriteAllBytes(path, XML); + } + } + + private void SignXML(string path) + { + Process proc = new Process(); + proc.StartInfo.FileName = "revoke_sign.exe"; + proc.StartInfo.Arguments = path + " " + "psmdrmboot.dat"; + proc.StartInfo.UseShellExecute = false; + proc.StartInfo.RedirectStandardOutput = true; + proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden; + proc.StartInfo.CreateNoWindow = true; + proc.Start(); + proc.WaitForExit(); + moveToCache("psmdrmboot.dat"); + } + + private void CreateKConsole(string path) + { + if(Unity.Checked) + { + File.WriteAllBytes(path, Properties.Resources.unity_kconsole_dat); + } + else + { + File.WriteAllBytes(path, Properties.Resources.psm_kconsole_dat); + } + + } + + private void SignKConsole(string path) + { + Process proc = new Process(); + proc.StartInfo.FileName = "kconsole_sign.exe"; + proc.StartInfo.Arguments = path + " " + "protected_kconsole_cache.dat"; + proc.StartInfo.UseShellExecute = false; + proc.StartInfo.RedirectStandardOutput = true; + proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden; + proc.StartInfo.CreateNoWindow = true; + proc.Start(); + proc.WaitForExit(); + moveToCache("protected_kconsole_cache.dat"); + } + + private void Cleanup() + { + File.Delete("reverse.exe"); + File.Delete("revoke_sign.exe"); + File.Delete("kconsole_sign.exe"); + File.Delete("cygz.dll"); + File.Delete("cygwin1.dll"); + File.Delete("cygcrypto-1.0.0.dll"); + } + + private void CreateCache() + { + if(Unity.Checked) + { + if (!Directory.Exists("cache/PCSI0009/_System/")) + { + Directory.CreateDirectory("cache/PCSI00009/_System/"); + } + } + else + { + if (!Directory.Exists("cache/PCSI00007/_System/")) + { + Directory.CreateDirectory("cache/PCSI00007/_System/"); + } + } + + } + + private void moveToCache(string file) + { + if (Unity.Checked) + { + if (File.Exists("cache/PCSI00009/_System/" + file)) + { + File.Delete("cache/PCSI00009/_System/" + file); + } + File.Move(file, "cache/PCSI00009/_System/" + file); + } + else + { + if (File.Exists("cache/PCSI00007/_System/" + file)) + { + File.Delete("cache/PCSI00007/_System/" + file); + } + File.Move(file, "cache/PCSI00007/_System/" + file); + } + + } + private void LicenseGen_Click(object sender, EventArgs e) + { + KeyGen.Enabled = false; + DevName.Enabled = false; + Unity.Enabled = false; + LicenseGen.Enabled = false; + + CreateCache(); + + Unpack(); + + DownloadXML("temp.xml"); + SignXML("temp.xml"); + + CreateKConsole("kconsole.dat"); + SignKConsole("kconsole.dat"); + + File.Delete("temp.xml"); + File.Delete("kconsole.dat"); + + Cleanup(); + + KeyGen.Enabled = true; + DevName.Enabled = true; + Unity.Enabled = true; + LicenseGen.Enabled = true; + + MessageBox.Show("Refreshed License Created!", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + private void CreateKeys() + { + if (Unity.Checked) + { + if (!Directory.Exists("keys/unity/"+DevName.Text)) + { + Directory.CreateDirectory("keys/unity/" + DevName.Text); + } + } + else + { + if (!Directory.Exists("keys/psm/" + DevName.Text)) + { + Directory.CreateDirectory("keys/psm/" + DevName.Text); + } + } + } + + private void moveToKeys(string file) + { + if (Unity.Checked) + { + if (File.Exists("keys/unity/" + DevName.Text + "/" + file)) + { + File.Delete("keys/unity/" + DevName.Text + "/" + file); + } + File.Move(file, "keys/unity/" + DevName.Text + "/" + file); + } + else + { + if (File.Exists("keys/psm/" + DevName.Text + "/" + file)) + { + File.Delete("keys/psm/" + DevName.Text + "/" + file); + } + File.Move(file, "keys/psm/" + DevName.Text + "/" + file); + } + + } + + private void GenKeys() + { + if(Unity.Checked) + { + byte[] krng = Properties.Resources.UnityDev; + + for (int i = 0x454; i != 0x465; i++) + { + krng[i] = (byte)DevName.Text[i - 0x454]; + } + + File.WriteAllBytes("_PSM_DEFAULT_.krng", krng); + + File.WriteAllBytes("kdev.p12", Properties.Resources.UnityDev_private); + + byte[] Seed = Properties.Resources.UnityDev_seed; + + for (int i = 0x0C; i != 0x1D; i++) + { + Seed[i] = (byte)DevName.Text[i - 0x0C]; + } + + for (int i = 0x2C; i != 0x3D; i++) + { + Seed[i] = (byte)DevName.Text[i - 0x2C]; + } + + File.WriteAllBytes(DevName.Text + ".seed", Seed); + + moveToKeys(DevName.Text + ".seed"); + moveToKeys("_PSM_DEFAULT_.krng"); + moveToKeys("kdev.p12"); + } + else + { + + byte[] krng = Properties.Resources.psmdev; + + for (int i = 0x454; i != 0x465; i++) + { + krng[i] = (byte)DevName.Text[i - 0x454]; + } + + File.WriteAllBytes("+asterisk+.krng", krng); + + File.WriteAllBytes("kdev.p12", Properties.Resources.psmdev_private); + + byte[] Seed = Properties.Resources.psmdev_seed; + + for (int i = 0x0C; i != 0x1D; i++) + { + Seed[i] = (byte)DevName.Text[i - 0x0C]; + } + + for (int i = 0x2C; i != 0x3D; i++) + { + Seed[i] = (byte)DevName.Text[i - 0x2C]; + } + + File.WriteAllBytes(DevName.Text + ".seed", Seed); + + moveToKeys(DevName.Text + ".seed"); + moveToKeys("+asterisk+.krng"); + moveToKeys("kdev.p12"); + } + + } + + private void GenCache() + { + if(Unity.Checked) + { + File.WriteAllBytes("Code", Properties.Resources.unity_Code); + File.WriteAllBytes("protected_kconsole_cache.dat", Properties.Resources.unity_protected_kconsole_cache); + File.WriteAllBytes("target_kdbg_list.dat", Properties.Resources.unity_target_kdbg_list); + File.WriteAllBytes("vseed.dat", Properties.Resources.unity_vseed); + + moveToCache("Code"); + moveToCache("protected_kconsole_cache.dat"); + moveToCache("target_kdbg_list.dat"); + moveToCache("vseed.dat"); + } + else + { + File.WriteAllBytes("activever.dat", Properties.Resources.psm_activever); + File.WriteAllBytes("Code", Properties.Resources.psm_Code); + File.WriteAllBytes("protected_kconsole_cache.dat", Properties.Resources.psm_protected_kconsole_cache); + File.WriteAllBytes("target_kdbg_list.dat", Properties.Resources.psm_target_kdbg_list); + File.WriteAllBytes("vseed.dat", Properties.Resources.psm_vseed); + + moveToCache("activever.dat"); + moveToCache("Code"); + moveToCache("protected_kconsole_cache.dat"); + moveToCache("target_kdbg_list.dat"); + moveToCache("vseed.dat"); + } + + } + + private void KeyGen_Click(object sender, EventArgs e) + { + KeyGen.Enabled = false; + DevName.Enabled = false; + Unity.Enabled = false; + LicenseGen.Enabled = false; + + CreateCache(); + CreateKeys(); + GenKeys(); + GenCache(); + + KeyGen.Enabled = true; + DevName.Enabled = true; + Unity.Enabled = true; + LicenseGen.Enabled = true; + + MessageBox.Show("Keypair & License for "+DevName.Text+" Created!", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information); + } + + private void DevName_TextChanged(object sender, EventArgs e) + { + if(DevName.TextLength == 17) + { + KeyGen.Enabled = true; + } + else + { + KeyGen.Enabled = false; + } + int i = DevName.SelectionStart; + DevName.Text = new String(DevName.Text.Where(char.IsDigit).ToArray()); + DevName.SelectionStart = i; + } + + } +} diff --git a/LocalPSM+/PSMKeyGen.resx b/LocalPSM+/PSMKeyGen.resx new file mode 100644 index 0000000..368e27d --- /dev/null +++ b/LocalPSM+/PSMKeyGen.resx @@ -0,0 +1,710 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + AAABAAEAAAAAAAEAIADwiAAAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAgABJ + REFUeNrtvXe8JUd9J/r9dfdJN83cOzlKIxEkARLJZJGNWWMjsHgLRmD0ng02tjHB771d73p37be7mAxe + 23ifwy42CId9BoHtxSbYGBYBEiiAAIGMhJBmNHnmztxwQnf93h/V3ae6uqq7qs+5oxGo5nPmntM51Pf7 + i/UrwkOt2F58HdAjYMAAA6BGRwkARADa6acLoAdgJv3MAZhV/s5rv2fT7Xrpp5t+2gA66d9Weo7sE6bn + zf4G6dWrn6xx+hHK9dq2UbcVABLlb6x8RgCGAAbp3376WU8/awBWAaykf1cBnNV+r6TbraX79NNjDeU5 + WDR9IYgCYCiAj1/zUB9XGv1Q3e1P/Smwvgh0zvg+oygFXjcF5nz62ZR+FgFsVj6bACxogO6mx+ik4G1p + oP3heheSVFQyGaWfQfrpa8RwBsAygNPK51S6bDklk7MpefTlMSgGmJ2vaLQJ6JwEPvIzDxHAg7K95Lr0 + lpzeeQgpSXspUDMgbwGwFcC29O+W9LOogTqTyK0UxA+1c98ExppHXyOLUwBOpJ/jAI6lf08oxLECqWkM + UxJygAsD1//gaBEPPgJ48YeBMAW4DefMBKIOxlJ6SwroHQB2pp8dKcCX0m3mIKV7G1LiP9R+8Fqcgn0t + Bf8ygJMpMRwBcDj9HEkJ4wSkprEC5gGIuBJGAsDHX/kQAUytXfUBgFpVW4SQUnkbgN0ALgBwUfp3Twr0 + xZQIepDS+qH2UKtrI0jN4CyktnAYwEEA9wC4K/17MCWOM6jSHgICPnL+ksL5RQAv+VDVJbUhJfk+AA8H + cBmARwA4AGAXpO3dO+/uyda49MX8asi0WF9n2Jam/BhUU1q/dvU3T+k+z+83tw6pGdwP4G4A3wHwTQB3 + ArgXUnMYFm+T5DM8zwjhgX/sV11nuBICwAsp2B8F4AoAl6fA3wkp0c8Pu5tNnZvG90Ppd6LxJ0g/FIy/ + B8H4L1H5u/q3cMzsfFQkCNqg+2SVENLfrP5lQOh/Rfl7/pelc18o2+cfhXjqnvMD3wSkxnA4JYKvAbgN + wDcA3AshziBQuiyn/oSPPbD+hHP/+K76MGA2peYAXAjgcQCeCuCxAC6GlPrhAwrqHFxph8uAGQbye2j6 + hON1NoCrYNUlNrm8HjZ+bdwT2LeXkPsDLWkGrJAKS/iYCCIR8nuSyO/6R6R/s30LpMEPNFkkkNrAdwHc + CuCLAG4B8D1IH0SZQs5xmPLcPJKf+rB8meVz70yBfiWApwO4BNIxtzHSvQrYGThVAEcBEIXyk/0OwyKo + VclsBS5XOCxtP8j6lnLBD1K+q5dAlZo1Wx4Jp/+rQpfTDWo1+an3SqomEpOGkaREEWd/s49GIKpGcm6J + QkD6De4A8AUAnwdwKxiHQdqTDQn4q1eem0e9Ye0l12l8KIAw2AMp4X8sBf0ByJDa9EGeq8opqHNAR/Jv + KxwDPArHEl1VtVVkmcDMFahI9wtIAjUkQhAQQiKEASEKxn8jw7IwIIQk9w+UvyauGfdlCVbZvxmCWWKD + Oe33jIRZYoEZiZDbxAJIBOfL4mybdJlg1DPYuSCH2p6svCsV4BlhZBpDrBDEKPseK4QhpGmiahTTJ4c+ + pA/hCwD+HsAXMaSDaCsMTNjQsOPGEMBLrtOz6OYAPBnAVQB+FFK1n9wjn4EvA2uYArwdAe3W+G9LA7gJ + 2CUnl9nezEAcBQFaIaEVBmiHATpRiE4UyE8ov7ejAJ1wvF2UAZuAICCZflfoU5xqxpyCVwWxBGT+nRlC + jMEsUuAmpb8piHNQy3UZ4OP0k62X34E4JQbmiV7OA08M1l5vIQqVIEYJMBwBw3j8N07GJgfzNElhBGkq + fArA9QBuRGYmsJBCbAOIYLoEoEt8GWv/CQCvBPCklAgmALwC9gzonRbQbQOdtvydAV2V4CXnlfoECESp + FA4CtFMg91oReq0QvXaEmVaEmXaIXitCtxWgG4VohwHaodwntwgyTklBjBSsUoiMgcxi/F39ZKAXCriz + 34myzxj8KBGBTgCxsiwDesIoAj/7nh6vHvRc+bN2v/ONEOpIIgN7RgzDGBgMgf4QGCjEkG03eQRmJSWA + DwP4G8i8BOk4DATw0VedhwRQBP9WAC8H8LOQHvxmNn32MINASvFuG+h15KeTSnZVohekOCsYJ0RhgG4r + Qq8VYa7Twly3hflOG/PdNmbbEWbaEvCdFNxSBVd8dcwpqDM1W+Sg5WyZ8hFQviuSnG2Azz6Kmq4TQaKD + vyTxtWWKKl+W8pIcYjE2E6bTfCT/g4gQbMQghNQUBiNgfSA//aFcJsSkhCAgIwl/DOAvIP0Hsk1JG5ic + AF78Z5KVZAsAvBDArwF4mjfwM9U7CIBWBPTawGw3BXxb2vBBOmbFFB4iqWrPtCPMd9tYnOliabaLxZkO + NvU6mOu00G1FaEcBIgpS9Tt1faXsnanf9d8V0BfAPl7nBHhF4heAnwJctdnH3zX1njO1fqwFqCDPfo+l + /ljSs/uLqV00GdAfhGRQQFKq+gmWPoTBEFgbAGt9YH0IjGJJCM1MBgHgBgC/BeDvkA3iCgTwkVc/gARQ + DOnNAPjV9LPJW2CEJEE+1wVmexL0rTAFPIwqfBSGmO1E2DzTxfb5HrbNzWDrXBebeh3MtCO0ohCh0dQb + AzkPQ+XebxvozYDPNABRIAAD4DO7XrfjDVK/BPbcBNABj6KqL7gA9kzyx5qvYPoY87X3HQnhwUoGKrIE + S21gfQCsrgMrfUkOCTdB4DKAd6efNfmYCPjYKye+TP/2sg8Bcb77IoD/DOB1cI3Zcyrpu21gvgfMz0iJ + H4bjrCkNuVEUYlO3jW3zM9i9aRY7N81iabaLuU4L7TAYWwLQTH0l3lwEfUoG2bpczdcAn25jUvlzYGe/ + U6AyNCmv2f2JsizhohNPsEHCa/a9ybaPGUW7fpqg5wl2mtgUeJCTATDu03EiTYSza8DZdfldCB8zIQHw + BwD+LWSastSzP9LMJGhGAC/+IJSspm0A3gvA7QoYUrLP9YDNc1LFjzTQp4AlIsx2WtixMIN9i/PYuziH + rXM9zHZaiFLNoAR2HfQKoKGCHUV1HppkB8wSngtEMJbwrKn1rABZVfVVqV8E+5gUagGv2vW5xB979d2d + eVNkhGlKfus2D3IzwUQGq33g9Aqwsi41BXdEXgfgzZCDluQxP+qvCTQb9TYG/xYA/wXAK5zefTsCNs8C + i/NS8gdBKVZLAWFTr4O9i3M4sHUT9i7OYfNMB+0wKABe2EcC5hKDFfUemnSHps4XCQAWZ15Z3RfacmEA + eFnicx6XT9jmwS8DPtHCdKawnZczj3zAWyM7yAWoenaSaTt1G/ZY9yBqWZ+PQikEF2akJnDqLHB6VUYV + 6ongGkjZ/wYAJ5qyvb8GMPb2zwF4H6Snv54wFueALZukmq+mnaYXPtNpYd/iPB65cxH7lxawqddGFJBd + wpseqALyIuihSXxdypfte2Gx74vfUeHMU2x9ZZndi6/Y8BbAF515yImCwVoO4cakd/Ck4b/afbiBGfAD + YB5kSGRIh+GJZeDUSuo0rG1/DOCNkLUQvKMDfj1lDP4AwK8D+A+o8vQzJOB3LkmWC0gBvjz70mwXl+5c + wqW7lrB9fgatsCHoN9yZZ1L37Wq9UEBsy75LBJTkHA3wqn3P45Bdtq04zzo9Tz38x55mwA8QEQgGzqwB + h09KQqhGqQDwmwD+k/xOwPWv9DqdW/vxjwKd9Qx4VwH4U8ix+PY22wX2bpMkoDnlFme7eOy+bXj07i1Y + nOmAyKFTF3K3VWk/ZWeeKNvywij1i3a70BJzcqkviiBX1fyytM9UexQy9pLcudj0jfpqBey1uJYYNsTu + 5x9sIlgfAvcdk36C6rYM4GcAfBzM0pH+kZ92Oo27D6C9lj3YfQD+fS34F2aAPduATlRQ91tRiMfs2Yqn + XLQLW+e6OZ65crBMWaU3O/PG6r6PM6/Kts/WJaJIAqoqb8rOqwvbJVxMzlHJINbi/OzcYxSgTGwFUPVi + dr2qot1uHjrR1O4nw3J68PsIsmfUawP7dwAHj0mNwN42QWrjN4PoPkfTwaObXP0nQBIByQIQnvnPAP5N + Lfj3bpNOPwX8m2a6eNYj9uAxe7YiDKi6Dz1gzjxNygvNntc9+M7OvLJabwJ9nOcNZG9IGy6s1wIo/TUs + A8pDjm0j7gimIYLFegCq/4Ztf/VlKI3x51KNAVSAXUPHD4tGQJBOwftqSQAA3oozJ/4tFrZIvP71y2sP + 76YBJOlm4ZkrAFxbyVrzPSP4d2yaxYsecwB7F+fsEv+8cOaNY/mF5JyCqj+WzqIC9LFCDHFm47MM5CZE + iEMgBiEBISGAAwKrgwoCpW6AsQgIagqAUFPKN79b2wI2LWaNNNK/YvyX8hF6DE7G3wsftVZAnrpoC1/8 + AGoEWfRszzZAHJW5A/Z3eC0WtvwlgNsQxk6HdzcB5IikayFr75kvtNcG9mwtgh/AbLeNF1x2AfYtzpXt + fBvoa5159nRcW/693ZlnkfSFdFwlRq+CPlP5kQI7ICQBISYgIaR/JcBjZH/lJyu0z0QOIKUaMXEOJFEB + c6Z6BaxsR9VFTaioYZDynVWw64SQZOP+WakBoBFGdm7jOP8HIREwpCm9Zytwz5Eqx+BuANeC8GbXe6zv + OeM6fY8A8EnIgpvlFgbA/u3AptnSA77yYXvw7EfutYPe4MwrpOtycZhsGfAK2C3OPJt9b/LcFwgA2V8J + 6Ex6JynAk6AI7oSBGKmND0Xqc6ruMxydeeT/yibhAf18k2QRmYqcsPMO2m62dYpmkWkIGRmoJCHtqzF5 + 6KXGHkyNIPME7j0q78vc7gHwAsg6hbVhwXoNgATAIQD8pBX8ALC0ACzMltTBzbMdXL53a0rI03HmCU3y + m/Lvc/CDtTTcYlpuktrb+QwVISCIkFCQglwCW2TgB1I1nvO+lgHb+Dfrh3UYsEpLF+3AlTwmIAQXxBsd + kFS9bWmbYo48gSxkoJhAAaTUjwJNwChEoWoLWcGPWKQvMytDdp4TA0MK2NUF4Nhp21YXQA7Bf49LVn49 + AUjwL0CG/syt2wa2bjJe8cO2bsLSTBssRIUzTx1mOyVnnijb9xnIRSCBLYKgAG5BlIJcUe0Nf3MJn5oI + maTPlmXpuAIMUSuxqTngaYO0gQqMV56MXEiBJiYDLpgP2UpFrcpSbdXnGxLykWElDUIxL2KFJGLNvDhf + 2tZNcixBf2jb4iUA/ghIaqfAqiaAceLPFZC1+8xty0Ix3Je2MAxw8bYFEBiCxVSdeZUOPXAOdEGUSvQU + 6KRMcKeAWkCx71WwK78l0McOvljVArKwHTIPPsHuhKsAvQ/gyQGU02rEnuRQk/arlzfnKjLgwqISEQCK + zyGb01EZs08GssgXpsQQAmgxgHB8ukwrECJj9vODGDqRxNzB47YtHpti9vN4yXWVZkA1ATBlL/75kKW4 + yy9+piPzmQ314Dd129gx34UQyRjkUxhbbwI7EyBCSiW7NpOlquoXimsgB22iFNzIl+de+6IdH7Ma2pPr + M99Tteed/EBPVdt4AHwaXMB12kZdmrCBENhwr0YyqCACpKYl1RABdK2BDYVktNLIWUQGYbGAnWpSxCwL + jo4U00JssKORITF38gywZnQIzgN4HoDPVxJ3LQHInecAPMv64jfPydF9hjDR1rkuZlpBTgBezjzFvhei + CHqmVLoHlEp4ddpabYht9tcEfhRBHxskv+rIG4+0Q04oeX8iT2lvNffJH/DksmzCTEBCPcC51Heqt3cl + A1PkAcWKT/5EoGgDRIpjkIrmhO15hyQz7loZjLKyYWlHGqWVgkZZgdEpk0ArBDbPA+snbFs8G8AcmFaa + EcBLP5wx48WQk3MYLiKSST+Wm9s220GAMYCbOPNy8IMl4COCCCmV8Fq8XgO5YLM9L1BU7U3gz9T9WHBh + nSgJJhfgO4DeFbDkQjLTaOSw2kASOljZhRBqyMBRK/AmApNZoBb6ZC4/Dq54IAQgonQu6RBAS3aiUQIM + EqAfjwuBTNoYEnvHl2W1oXK7DHKavK/h6g8Cf/VqTwIY3/wTIIf9ltfPdmUVH9PjIMLiTAuCBYQQ1nAd + G4bTlgpoBgTRIogwUECuSHqoufhKlh5QduIBhcQcFfyxYuvHwhC2owbAr1LvqQZwTcB+LmZ64KprtpFC + BSHY0nsL22vOvkZEoDkKdbNA1wbGFV4tJKef3jC7SkhAGAHdCJhtAWsjYC2eju+g05IYPHXWpIFuTbH7 + NST2TlFtApzYCWw5/GTjmw5IGeFXvpkoDDDXjiCSJM1nLxfS4DpnHrOU9u3UkSdEbvcXJb2umhd/FzLw + 9Kw8LWwXK/uxDmITAG32vZO0dwG9oyZgWzF1QmCbJj4+IdeQAjRCMGoHtjEAWfjPjQjycDNp20yqDRiS + EIv+BcM2UQAsdKQT78xAmgeTtCCQGDy9YusIT8HJ7n/Hln5DAthyeBNs3v9WJNnHEjdthYRuRIiFQCKE + c6HMrKxWAoZoBRDtVOoLodn2ujOPDQ49VII/H3GHsRYwTiTT1HaaQOLXSfu6ST3rMgOdcgOa492NYKoA + QnbJTxoZFLIJ9efqSgSs1Iml9PQKEbhqA2r1X71MnckkMJGA6Rl2QmCpCywPpVnQmItTLbwdyfEC5XYF + lvqbwFj2I4AXfzi76n2Q8/WVT9zrSBKwdJp2GCAkIE6SQrotu2bmdQKIVlCojFsoqsG6lB+DP9bBny0D + ikNteRwOZEVqFHBtlfq+wJ8U9C5Rg2mhXj+ESwiQHPdzJQOTpuFKBLrdP54ujfX8gCptgJQL8zEJdHPA + pA2EAbC5IycXX5uABFqRxOJgZOpHBwDsBbCMF19nnHfQjOBAZA/okQCWjB17tlss6aVfVyDvepSIPPPO + CHitVJZghuiESCKCSERB4pdDdWXpH2shvNjyXcBkeipSvynwq9T8OvXeBuBKL/85SAaqDAGyGymohGDy + C5TIQAfolIhANwt8tAFXk0C/P5tJEJA0CTABCQSBxOLyqmntUorhb9jK9pgJYDyZwaON2wQBMNOtlAxR + EIAFY4SkVDFXHT9fmu2mFUBEVCiCkVgJwCTtU7BDA74Y5wzowCXS1X1T56Vq8GbL6oA/EeinOLrPp5En + OVg9/lRBHAYyYO1dMbsTgQnEulmgawPM2nNmP5OgzjlYRQIJy0iBPztLLAaBqYRYBOAxAD7iRwCUZT/g + MuP6bEouriamWAiQqSS2MBXWkN7+pB0oFXSKBBBrCTxxYXnRiRcrsX6h5nloyTXeUn9DgG8B/TQy/zaC + IAqTsVhOassJqCIDk7NO3Yds5oGBCIySXNmGbE5CwzHU/VXw15FAYZkDCZzsVw3ysb+LTjoPpjk1+DIA + IQQSdwKQbQHAw8onZBn6C6sHGgSQBMCaqp+UCmUqkn4mkqBNhFHiF8pnFez6cZJOJvmlFqiB0Qf8ruo+ + kTuIXaQ9uTj3aohho7WCTHU29UbbgCB2IIMqM8C2nDWQkYtZUNQGmBxIoHBuzS8wDRJoBcBcC1ge+L+P + MJAksD4wCaiLUyyf8iWA7QB2Gd9+r52OwKompmGcyKxJE/D1ApmhHEefxKJUGTcBj8doaCE7Y5KOSWqT + I/B1EBp/68t8gFxDFD4e/6nV//MRNxWnYLIPCNI1JJPdb9UKTHn9GphtiT8F8majNlCOFJhMggq/QNMI + gY6fXgSsx8DQ0xQISDoCTxv9ALtTLDsSwFUfzL7tg5zxp3yybttCdcr7ZMYwEeVx9rYprNtReX56FfDC + DHwJekusXnfI+Up9V3W/KfDJMe2X4LbdhuOfqomBLNuTjRAcyMBEBDWqvZUIiCbQBsjgm6ggAaA+QqCv + D0iSgC8BIMWkOSdnMcXyt/HSDwIffXUNAURhlq54EYBuaX2mbtQkNyfMGMSi6OAz1cMXLCvoBCRVf7VI + JlgBvurw0yQ9WcA3icpfKfV9pDiZt3MN87nmD1R3j0Y1Atg2HqA2+ceFEGxkYHD0TUwEXNYaYCABdiEB + wOgcnBYJdENgJfD0BbDEZBjI2YaKrQsZDoSpgn+ZAMY3cLGR6FuRZfCPRgCC0Y+TYmVcYdYA4k4k1f7R + eGKMWB12qxbKJJt09wG/p4dfl/pOdr4n8I2gd0v2oaprd9rJ8J5RMcEIGQhCV83rCIFr7P6SVjABEbDF + BMiBT4WBRwUSyJ9plXPQkwSqWhjIRKE1DwJgSEy2Itv0Yhfbdi0TgDxvCFMCEFh6G4OgtnPFgtEfCcMs + t3o5bEbcBZJYmepKkfbjYbbNwF8I8U1b6pOrx78iE7AE/GrQO4O9Ml3Xo0NWvuby82Id7KwTgr7eIRqg + 5/RXEUGtf6BCG1CAXUgcmgYJGAnBogV0QjlmwKcFgcTmWt/UcQ4ACMHlSIDNCTgDaTeUW6flJGVGCWM9 + TuQciIILE19k01nnXnwixLFU/7MafGxLxXUF/7RVfhd13xX40wa9STWvGrAzUWNnUmA1HZYsZFClFVSF + /2xEUJMIpNS4qLbtVZOg4BxsSAI+pkArkIOIfEYOEqWmubHtSzF91pUAFgHsNJ6k3apnOEj1fW0kw4BZ + vft82mp1Cuss3TebAKPKCz418Feo/FXnsIG/EfDtoCfb+UwbqJ19I/BuexdcTwy6hpBX8Kkjg1rzgCsA + VJMIRMp5qca2N/oFzgEJhIEcOJR4OANVbJbbzhTTzgSwA7YU4LZbJXEhgPXRWANQJ8VQp7viTmjo2IbM + vCoQu4K/zt4v+QfqiKJmfw/gl/nCAnrWwNAE8FTjzYfDaqojhmpCKJEBU4kIWBCeva2DXgh84nBfCcGT + o1lQIeltacAFv8ADRAIA0A79MwPtwnkpxfT3qwngqj9D6gTYC2C2dIIwkI4Gh8qpCTPWR6Iwv51xCutW + WC0t1YkwClLPkMZJeq04FTW6nqz9JqqQapZtCeUad2y4D1PFKa0jFFPHyQ6+0nnKOAwqQW7ep4RqrtqO + a65PJwQ7GeRmgqYVMBib2gF+/ZELmI8IXz09wtFBUiQBwE4ENsmurjeRQIEoKpyDtlyBaZFAK/ADP7PE + kjkSMJti+ia85EPA9a+yEMDJ5wNbPglIp4E5RBiFTtcjUhMgcwCyqcpSQONSzg7g74SEqy6Yx45elDqb + yCBJSXEawi6yKtNuqwbw1G1DtaP1alX8apRWrv7H40PcvhKPAz5NTQLXtOO6ij9UTQZGrSAF3yv2zuDZ + WzsICbh2/yzecefZ4rmqzAIXbaAySqDtbyQB/V6nQQIZ1gKJD5/CIRk+Y6Ov70IAwPFbSivGbemT2bcL + KxnGiQCAQSyqlcqAxqWa9b5lkPy9KMC/eswSHr+li4eaub3u68u4fSWGW51AG6h9nE/alypCcCQDAcaB + uRC/ctFc3j1ef2AWf3ukj2+cGSkmngGkBW1AIYU6Esj2IV8SmKI5oC4MU+HokxQUBhKj62weGswAtj2+ + CEHDy2wB2G88QavlpVrWdqOM5ay9U7Pl6Qdj5udz0vJnRuMPqj7qvuT+qTuv4R2Of5uPERLh9RfM4bL5 + sXy6cCbCr1w0J4eZG3072vFIOWkhN6Mip8M0lJtQ9vcoYcLxefXnp/dh7W8dmZa0Y5d3ThKj5rYfhEgH + kOkMMwD2GK+uHU3XyxxRxYu0SJiHWj3yyQBsmvLHShYmQqgjgzFwBQNPWWzj2v0zpTt7xd4enrutU6zi + rYLcFDImC5BtpDA1EkB1JMnWrdXzRuT96qWT3rjfbhj8eiYCWASwzXjwTmu6QIwCODn98pfwEAk4dQJU + ARZ+Et4m7a2kULePtoPylYkwGwV4y8Vz2NYud82FKMCvPmwemzthMU/EWRsw9DOTNjAVEiDzczcRAlXh + w/Plt1u2422HYWxPYNlwc2lpkEYApqWEU3qDVAF+MjzIh5rbs7WCeIKHWXc8EyGYyIB0MkBu3l21q4sX + 7ehYL+G5Wzt4xZ6ecf9abUA3Cc4pCVA1CZjINQw8hV5lpu5mGAT7eMuX/mn2zagqyOSEcHpGeEBlh6IN + /A9Jf3+QPlBkAwdV3yAZBQi7uyHefGAWncB+/SEBv3JgDhfNRuWh31XaAFADzCmQAEzHcCQBstysjxLA + kBgNjc9vFplp/9I/MRAA5w6XvdCjA1l2UuirktQQQFA19LZm2O1D7YFvhWq80EBfZfeXtQIi4P/YP4Mn + bm7VnvbS+Qi/eOEsggxcAcrE400C1JAE1C5sSTirKg6rPzsdI76YCwNZrMdQqT/Ftop1lV/yPfYZ33Qr + mi4BhEoEoKT624hhQhX2h7IZjPVp+ABMr8NKCHa7X0p/4IqFFl63v+d8V6/ZN4OnLbbHDsEAlqxPqieB + OvXdRgLqdz0Rqiqr1NkUIJs0r8aV3VTfZ2KFAufANgioFU1Xtczsf535yNK5PFwBzMDofJ7nvUELiDyc + wh4Pq24705x9pgduOhbDHM1R6v8zgE5AeOOFM9jXDZ2fx9a2dBbeemaE1ZhlvN2WA1CI+RvGAZjyBYwz + /WhID9IyVMrxqxOFUJ8foJNJ2CQUaE3X35tiXNgIoAvpAyj3kiwEOC1c6SFAkCFk08wZePvyEP/h9lPo + J1yxP9Xn6Bs6PFHVUF4YquDUgMd4jmK/SQA8Y7GFXzsw6yYQqArgPoh33Fy/BxMhlMggTfllxgu2dfCy + Xf7JXT++o4OrdnZx3X3rCLLUYjWNF5apwUopwHWEoRGEGoek8gCifAQhDMcyDTgyAZ8VnHgRAKpCgXtS + jK/ZCGAeMgpQPmgrwtQYgDLbxkACes9LB/f4jG49MRT4n4fWMUgErI4b9TtZyMCkMgIVqqEBEHWjCk0A + NUjSbkBuT54sIVMf7aGSExxmDSayk4FaXZuALe0Abzkwg7nQX7vsBIQ3XzSHz54Y4uB6giDrK5k2wEVt + w5kESoRRQQLGzL+UBFg5LyrqCjDbsRU2CAW2oqpQ4LxKAPrRN8NUB5BIphhOoxHGWU5W1V9xDtkq+dSc + IgrkeSj7kPKXtGVptIXU7QNKl8mXGRAhCKB8KP2M/ZlyG5LfC9tQeZtwvG9IhDCQn8LxAkodXYTQy/yi + ykS/Ru+sMrPQsi1Q9iEoRMAMXLOri2cuthtf2hM2t/Cz+2c0zq0ZDVpl2+v72fwHVOHkU+cfqOy7VBrJ + WsJDqDnLXVortGFlEVqIXyeArQDmjCwUTSEHQPUAhwbV3/YQJunE+svWX7w1ZXO8HZVevGm8v65ZmEwO + 0nxhpFSkVQekWRxmPmCd1PHnwiA2j38dGUAaoY+YDfHL+2e8+7feXnvBDB67qV0YNzM9EkAFCRj6mct3 + UygUgDF5yJsAWGLVnAswl2LcSgA7AfTMBBBMQftPbyRSbsroucV4XL/+An2IBuQAfhNYFYBWdQAYrsvo + aS5KZDPwFRAxKlJEXe5/ChpAiQNqJD8cySC9vigg/NL+GTx8dnLNcm83xBsvmkUnDApzQVD2Bq0kQNUk + YH3nJsCa96cqP5Yx8qWdKPAkAIbEqtl06EEr9CO3esl12e/dkPUAiwcMw/o6gI7YzwklMGWRGR6czsq+ + HRhV4LczfGl2YNSBn6pjzaR1SB34uX2Jcqx84ujLpAn/tsPVmQLmbEEB4MqlFl61e3qjOq/e1cWPbW+P + n6lG5G5JQrYwINUQvEa8OgkYU5JNqe6mbtUgFBhYk/ZCZE7+FPM6qvcYKSUKMbGept5VpEpdMpCuwXby + 1QJgecFVL68K/FUqv1GlLIO/kPeuA9+2r5FsHMCuD9Bp9CEPyY96MkiduQsR4S0XzGCpNb2w8lxIeMtF + c9jaDhqQAOpJoC6fADUkAItj2ChQtG19HYEBpXU7jCr7bvUUgXaFu4wHtDsV/ECYM1pQoQpVP49GpDMt + 8BtJiCqjAnK68aLUZ/XFcxXwqYIQqvHvvJ2PImA1BxzJgCTx/dSODl6wpbnjz9auXGrjmr096XQnHxJw + zfwje1SHHJ63pY+Uz6Md3zsUWOm03wXiPKSkpAKjDVk3rHxhrQmGAZs6UD7KqawOEWwS33NQEJG9A1uc + Pk7gJ5jZXstzz+185XgMTZ1nODsMm3Cu8RNo0RCXT7qPebAPUD9iUH4RAPZ3A7xpfw/tKSaVZi0g4Jcu + nMEj5yLpEPQlAWvfJXvf8TEFjGZtTT5KAS8emGtZcwF2gClnX/XIPWgeQoeD+TOAbtO4qv4TaYv1L7AW + /AV1nSrCQProMPlfSepbfQYETJr9TBVMYGpc81Hej/qprA9g0AwCIrx2bw9XzEfOtxIzsOZRHvvhsxF+ + +cJZRIEd3FYSqDQXYSY3a5+pEDLWKILFtAh8/UCVQnsbFEe/SgDzsOUARA09tSZmy8uAOcRATSzr0PIi + s46MTeQA/gJw4Ql+9eLIEGpENfA9ciAqJTJqOrNN/bcQg64lWDUDEAQDT1iI8LO7O15d6DMnhvitu9YQ + e0SgrtnTxTO3tMf5rjYSgCMJmIQIbH2yMg3TIpgskaSs+Y4KBCRm7bkA8yYC2Aw5jXCxVTsU3BiAtJsx + pb/Cg319zm9j5CmDXw3tjV+iBn4T+9tUZxSP04x1p9CqfAKalmAjAyagFxLevK+LXR33nrwcM95zzzp+ + 5/vr+PypofN+i60Ab7loFgutQMsgLb5rIkcSqDIFrOE9WCNRZNNobVqAbyiw2nG/ACUZSH0bS5DlwDQC + SGOKvvi3hcuyEKBV+tvs/on0YOP3Wm8/VfggNPCb9mOCqSdUO5I0YtBD1pODmZp/bKRQQQZZWsOPb23j + qm1+jr+/ODzAZ08OsRwz3v29dZz1UANesLWDl+3sFvIC1DEIJRKw9ZOqHAFX30AlOTtoAb7DgrPh++bQ + /QyUOT8CXJXnAGwF0DEeqNEwYIsUD8sSjeBjBjTgAGvcH9UAz58DWe10N/CjGvwGO7rgSG8EdMCreo9T + FMCBEFAkAibCjk6At+zvYsYjnv299QS/c+86hiz7/6dPDPH/HRk4798KgDcemMUFMyFEDQkY+x559Ke6 + /m8MHFH1OfS+EpGfEA6tgruDzNf30g/lg6gAOVAgLFGJnUnqgVd6EEoIMO1AZE2yoGridAa/i9Ovyq63 + qYAO4CdH8KvAJ6o3M2vvuyYtt4kyZYwAGMhF3SYlgtfs7OCpm9wdfwzg9+/r4/aVJB8LMWDgt+9Zx/f7 + 7rPmXr4Q4bX7e2nOmb0/OZsCNpTWmQJ1WYJW4aNpzj7vLdPcywwQIisNNpgpEUC5RU1yACqy5kIH5rOF + Z2hCM8AI3BrwwwX8ZAY/V4BfF8hE5dNOogaUADulLEDT8dVrVd5RAuBRsyF+YU/H6w6+tBzjT+4fFM4R + EOFrKzH+4N51r8fws/tklSFRGqVpMQVs4UFTHkBdOLAqzGjL+rM94yYlwu3Oexnu752B4iUx5QBkBNAQ + c6aMK+VGqGqmW9tvr95ffnGVpZzhCP6q6q86+AmoGkuQ28rGbZtoQXrWnoM24JIFWEVEFs2gHQC/vLeD + A133zrsuGO/5/jqODFlKf6UxEf7boT5uXI6dj7ezE+DNB2bRiwzDqTWSLr56l3wUcjLxLScY90dUkYEi + OH0cgYR6AkhauRMwhCkHAORPAFXSP/dm2lJFax58Ex6oS8RwBb9xr+I6popLprIHmmx1A0z2NU+SiYma + zD64KQF1WYDKMRMGnrPYwiu2+zn+PnZshL89PlK6wzhkHAC4f8B47z3r6HtMmXXVjg5etD2dT6BK6BBV + vt9q4TSpFkDV5/DNBcgJwLjP1hTzOQG0AGzxPEg125luSAln1DtJJ3R71wUB9BCNQ0iHAKstWcg74Opn + QUbfgAn46UHZ88WbgOo05Ff7mMYT2AhBWckAFluEt+zrYpNHGuvhocB77+1jXZgkI+WX9NfHhvibY+5h + wV5IeMuBWezoBnkFrwIx142+bKoR1GIkW1Rn5tI4fO6jCdqF91KK+ZwAujDNBQB4JgFRNZDVeCZR/f5O + iRdVl6NJf1fVjU37A9VFHi33b0oUMoLfAPzCtTRgP5s0b2T266RgeC1K0s/Lt7fw3M2Rz0Xjvx0a4Ctn + 4rGSSGUSIAJWE6kFHB26OwSfstjCa/b26oFa8sVYEoBstQFsWYFGCVRFMjCEAj07gh27iynmcwKYRWUS + kHufsxMBpGfSpGlbR0XZAe0DglqnnxGIZD+t1jHNApq0Y1A5S1AfB2BTE30dgWQgURege5kEKiGM1wsA + F/dCvGFPx2sMy9dWEvzB/YNyiUHD5B9BIB2FHzg08Hokr79gBo+ej8aFQ3SHLdn4oSJRq8z4btpnDVSM + fSCLxrk+1+pkoBmVAOZgqgSU1+5jx0eMSma1ZQEa99dtX4LfzVtBiWr7g4vLycb4JfBX+A2M0oIqUOtA + hj4k0BTwVT4DCxmEAfDzu9u4bMZdcxwx8Nv39XFPn80KokEFFwD+673r+MaK++y5F/ZCvOHCGbRrJSmZ + QWsLEzoRQ91ysieIqfhx7hNcNbPQHNJ04EBnhELLCuDV4Z9QTXnZopAcEvsqsrF8On/+zqiaDEzgrjwt + 1d9zJfhL8T+g6hpdwWwDfpV33xX5xhyA8mYJA0+ej3DtDj/H36dOjvBXx0aleD1VmGkBEe5eF/gv31/3 + Gifwit09PGdLx64FmF8j6p152jst+ZfqVX5jl1L7jxoKrOsPrOC33Hop5nMC2ASg/NacUxDrwnlKKEN/ + s6aCkZ54t1+WPYmnUlPR36mFILgyBdTk7DM5+WCRrNQsaUftcOSj/1exiba/gWSYgLmI8OY9bWzzKPRx + Kma8574+lmMua1swmQMoOFP/8sgAnznp7hBciAi/etEMFttUnGC01O9Icfxa+ozNv+IJFXMfMWwYegJE + nXyn2Dop5nMC2IzUK1hgEN/JCWtyAKg2m6kmGQMNL6Vqrfq8ue4AFl8F14DfmNloABObiMvz9ps8rybO + QO2rYODFSxFetNTyOvV1R4b43HJSljM2x7havIWA0yPg3d9bx2kPNeA5Wzp4+e6eOS/Apd+YWKHSeiOz + JlnlCzCZqt54JFs6cCvFfE4AS7CmAVNz0BeWkVYI1JMZmyDBJcxnOCbB3OEKT6eiXoER/DYHkAn8povx + JYFJwoG2cmKWkwgC9nQIb9rThkfOD/55XeD3Dg0QCwXRFoDY+n0QAJ89FePPD7s7BCMCfuXCGVw8q40T + yN6D6TJ8zHnbBVOdx69GnQg8BUNAVenAiyoBLBoPEIaerFixjGAuBGrahyzU6AoCrmNfw/lT9zMBDglB + WgKAl+S3XJPRTiQDMLzQXyzqMVFWpUYKhS0I//uONn5kzt3xJwC8/9AQ315jzUx1IAENSCMGfuf7fdy1 + 7u4QvHQuwi/sn0m1asv7qHpgdWE7V5CSq4ClcTIQOR6cSGLY3JZUAlgyE0DgeHE2IlDWZjkAJTvXNXnC + vfdy1YEqQjH2bckhvov6acP03zZNhIDKwpNN8Gvghurhv1WkO94uAXDFbIDXeTr+/tdyjA8dHaa3WRUK + rdcEAgK+uZrg/ff2vQbMvWZvD09dbBXmE7CBmCoBWxcNcOxzlYliMNcFqOsWdgwXCGCTeeewcb8rd+om + dq3nzZY6fR25kJ1nKl4i1720unECVoTCEPeGZwZYDQk4G/sWyU9Fou0GhF/Z1ca+jvsFriaM99w3xLER + K4+D3CMrgMEhCHzw/gFuOD1yvo5tbTlOYDaiYt0ANvufrFE+l/wKJ19BTR+1pdJX7WrXAHInYAhTFqA6 + f1/dxdVoAkQm9nJUl6YRDTACr4p1yU5i6vd82jsHyV/lCDQe36VnNQE+/OP/+gFTMhAAfnRzhJdt8cv4 + +8iJGJ88HY+7g36Ntpx6snMFATg6ZLznnr5XDcEXbe/gJTs74+n5qvqcdy4KOa4nA3zInGUY+miGVOU4 + 3IQU4RFMWYBAtQng7PxL/wuoAuB1yJ9A/XV5kWzoTer3inRke5FHg6SvTQQyrKeG910FfN/jGPZjELa2 + CG/Z3fKa2PPgQOC3Dw4t+f6oz7UvPGIq4ekTx4f46FH3sGAnILzpwCx2dwMIrs9BodK7IjfQkyMpVNsG + MLBm9Tu1Y3gT0syCDpQigc4E4NtBQ5NqW/OAppUXQNULqe6lFQa6UOF9OJ2P6kaa+PgmXO+1Om7fSAvQ + fIuv3NrCM+f9Csb+4ZERbllNTIWhzASqh1htfpd0k3UBvO/76zg0cB8n8MRN6gSjdX2h4rerBttE0yUV + R/b+6YHheUBWZ++gMg24Qe8zDX4JPLyXG9W8RmK5hOMcGKBSQlTsPw3fi8EBmI1JsP0zHkpbLBh4RC/A + L+2MvIao37yS4I+PjDSFi6qdpA6p1moLCPjqmRh/dLDv9cRet7+Hxy5EEHZGqjl1Q3+Vsc9gPIbFHdB2 + ArCnA3cDyFFBM0YCCCzjALzUf+XNOBCGK3CbkJE7wAh145XtDqEqDcaS3ERVJINmqdBpB8qqFVsBbiBE + IykoYIwC4Bd3RHiER9B/IID33T/CfYO00Ae5vA838ixPwAL80X193HLWvXDI3m6INx6YRSewZAi69stK + LYKq+1fVsuyZBXX7qo3TAXjGlb2MAHopCVgIYApNdV64AnuqSgLVS/+6ARpwy1F3AnzlfZrCgeRxp5TD + uEQqTT4aKSQAnjEf4lVb/Rx/nzgd4/oTiuPP5vV3cbQZzeDxj4AI9/YFfvuedXiMGMbVO7t4wba2dAja + Wbz+wpzIrWEL/PpDDQH0AsihwOXZGoL0ZOxxo9aXQjBX/HFl1IakY1xeE66jalattABc6srVRQlszjDf + EKjLuAdIn4btox+PAWyKCG/Z1cKSx1jf4zHjvYdGOJuwxmc1WZm2HH0TuDSVmQj4yNEh/u6Eu0NwLiL8 + 6kWz2NrR5hMw+nN9hEeDTktlYjM606vMak4xbJbjHQAzGQGUszjIkgbcRP3PswAdkd0ko8qTDKgWXL7X + 4OpBrgA/LL1u2i4TGoPfSBwaOWRNAPippQgv2OTn+Pvg0Rg3nE0sY1nqoiOOz9rwfs+mE4ucGLmHBa9c + auOaPdp8AnWaHPlcr3bfVdmiphaQXQUl2/ZGBmgDmAsgnQFtI3PQlHoekb/q4koMTZmgxsavJ3gX56HF + bKjMByD3BBOX2zVlXpokvGk/hSgEgP0dwht3RGh7XNMd6wK/f2SEhOEeNqmtvIQKM3t8XwEBXzg1wgfv + d3cIyglGZ8cTjFY+XssQ36nlrlguMPA4B5FtPE9LJYCwnmlMbGhfRqgY6urqPJnKAzWoVXWhxgZmX+Vy + Fz/BVAjOdOxi8o4EtAe5KKroa7dFuGLG3S+UMPC7h0e4sy+U8LUrCfg8Y7vTLWbg/ff28e0193ECD58N + 8UsXzmgTjNb1Sde+65edWiIaU25e1XPICKBMZhGA2cwEKI8EDILpagBOkyxg+upuPeu4nbgwcMhFPTSE + jaruncj/8is3Nkt4Lm2j5CFY4v8JgCfMBvg/tvk5/j57JsGfHU/KXn9yCX/69hFzXkdAhDtXE/zu99eR + eE4weuVSW9EC7KaGmXg9+x857uOrTVNmAhhHBFZoAFXx2VLHr1lG8J/ddDIEGB6w5YU5vR8Xe5yq+2ol + +N07t9sLrzuWCfCGIcGQtfRnAuBNOyPs8ij0cTZhvOf+EU7mhT5qQn+19+1wbpupTcCHDw/wuVPu4wSW + WgF+VZ1gdKMEUxPHd0Du/dPofysSwLzxlBPY7GQczNIwqDqVbED3TL/6Ki9UC3rzWT3BX0dYTR4BOazX + rkGA8C82h7hqs5/j7y9PJPiHZc3x51o+xynZqnoT0ipCnxwx3n2P/wSjV+/sKmHBCmdgnQnrEhqsADTp + 6cDOt2H1ARCA+QoCCOx2jscwYHksH5xOMRbYVKpzzfHIjwjc1F+Uxu2TSx6B873XMACbF+1oEd6yI4KH + 6Y97BozfOTzCgE2X3sDWNwLHQ5NLu+CnTwzxPxpMMLq/F9odgraMvY3sx/n0eg7RA4Itn4eQagCz5ic2 + jYtV04BNeQAbo1fJGhge6n8lOTRTQajuxddeyjSek0Gse+SsM4Cf2RLiqXN+9tsfHI3x9XUuDlyrclx5 + Ofncga9PPDsQwH/5ft9rgtErFiK8bv/MVIJY5us0kJotEYkaYtO+/WwAUxowUJMFWKEJGDenmkNNUGSh + 9iqnFE+vutdi6pjjnPNVj5UmvF67E3CcJ6j9Y/nJOl/CwGVdwuu3hV6X8eUVgQ8ci0v3Tmx43xMC3FsL + IOBrZxtMMLpfmWDUtaqHb//2ebWB54AgO5arCGBC+9s0DqDJPavY4sYs0HAfC3hdx4UbhxtXXyQ1SjTx + 2J5UNMIQDJD/OgHhDdsjHPAo9NEXwPsOx7h/xGOrj0yJUFxz0RU+Eq5ZXzpqGZD//dDAe4LRNx2YRS8k + r4pDk7UqQJN7Gr3dCQikmYAzxiM45aBXpf826cDTSqms6QiVwGzgrLTev4vEV8OF52CUJBuegVYNOQHw + 7PkAr1jyc/z99ekEf3M6Kc3qq77DRl3B1ZdTLlpQ2ikAcGgg8N571rwmGH3Jzi5etKNj7TK00ZIfmiPQ + p7/asWwhgKrU3UYSlerj/y7PaJLcag++cXrI1ODCKpyqdrV/mmllpVE+JSJgBhZD4C07Qvhk/B4ZMd53 + OMZqkgUP7UAlp2HQhoQYhmdoVnuVmUsKwN8c9Z9g9M0XzWJHJxgPGZ6GH6vKrLAd2pakZ3t2do1hJhsO + bDiJj+OnxidAFg+T9VC0gUCoOSw3358cCI6qzkXTvt0KwFs2EwD+5VKI5877Of4+cDzBjauiOHvVpO/Q + mXfrJH/5GCsJ8N7v+U0w+tTFtpxglD20RDaRm9u91r5W12bHcjcrCGI4Sa2nyv1igxqwY0oPxnap7LlD + o5N4HFofJMTNJGJtD/EkNwHgog7hDdtDr4k9b19n/MHRpDZrrniFviP/XNfrEpSNrBES8OXTI3zAo3AI + AfiFC2fxqPn6cQLOR/TtctmYCvJwBNqd8B03ApjICTXJoKIJ0D+p34EnuQaTxkP1GDV5ytm3o3gOt1Za + CODnt4W4rOt+zzEDv3Mkxt0DRuCawG8Ky7Kls9sIo+qd2QobcZnw/t97+/jGirtD8MBMiF+5aFbW0qoj + tab9p87Mmc6AyQoC8FEx6hyAeodust6zMaQty+pvZZnXh2t+5/1UWr5ZJK3qo1rJ5nOS8pvsAKl7CB79 + MGHgybMBrt3ip/r//bLAn59IwADilBDi/LscjJN/AMTMynd53vGH5V+hLEuvLVa+Wz9169VzsHzOd60m + eM/d6xh6iPSX7+7iOVvTCUbJ8flXvQzPYk/jQjGuO1m3bUcw1QKwpw/6X7V+sXVgNz5UP3KIiDAXESIB + c935wqScGcAs67PfehZgFpLKJhO1FgMxLCNC2Z+VHtAwFDYGvKbcMj6yiuG4DGAuBN60I8Q2D91/xMCX + VgUunwmUwSRsAAKXgcHjBczaStb7Aheld0buzOXzsL6RciAun4OZcXQo8N01gUsdZzba1Arwqw+bw5dP + jbA8Eubu6m0iqDvVHID0Ih8122dOQy5t07EQAGCdnsun9zWt5affD/sd64qFCNc/aRGCtXIcDbSayQqD + wN90N+zAALZGhLDR9ddfhGDgJzcFeNGCH8tEBPzrXRH+9S6PnfjcRdKdLwmyPLhPe87WDl6xp4v/+r1V + t1fciBRg36mqkjVrJ7RrAK0Iclyw+wmcO10N8FzMgoZ9ZXMrwNMW2/ihbJUZi+VFAsDuNuFN20NvLYOQ + ppJNp6M8qFpEwBsumsMnjw5w12osBTLxhJJfxz6bycA7LdlOAIGRAKZzcOViLTfJPNGhH2qeD8+y6H/f + EuBHZh962L7tsvkIrz8way7Vry+o6+u+mhF5Og7Mm0fZ1GDlPaiCmZpEBUq2X4MOfP5pjw9q8AsGLu8R + Xrc1+MF/JBvUXrNvBk9ZbEMU/BF1HXXC9bVD1rVj2ckiNGsA1gNOMym9YruHgD49HlDzgFit9U9yYs/t + Ifa1H5L+Tdu2ToC3PGwOs1FgwT3XdPu6zl4R23euImQ9jkUDMI7YqrtMy/bTGEY56eC4H7rGpXdDmi9G + MPD8BcLLFh+S/pO2F+3s4qpd3SIBkB8X+MGBPHMBrNuHAWx5ehuCNp7SNg+1qndORHk5+AA0nt1bGRey + rQW8eXuIuYfwP3HrBIQ3XzyH3bbCIbVd2mGnUl6Hb/KAsQV18383PbDWI6tujos2k5E52f18P+wEQFKl + CwCEJEOHIZRPSgyvXArwzPmHHui02hMX2/jZC2YdIsSu9n9NApjrkPSa7mLXACZGPia7QosjJaSHOm1V + y0AeEuWTO6kfALi0R3jDtgAPCf/pttdfNIvHb27V+ADJAPYm0PWYaMfegshMANOYxKPi4myJPRUJP8Qy + jfSW00MMBKcTTdQ9o0kGGtVU+TW+hPrzTKXgR2Gf4s7H4lTKa/afKjCeOks4ngBH12zxZ58L4eb7GusQ + TnBNzPbN2PFgXLWIK3cPATx9Swe3nB6CJ8G4i5LQtEy8tiKCeSYCjzDDNHqz2x2uxow33HpKagH6sGHD + MjJtl1dppaKvs7CMxlBV9ictVTibT54MudlkuD7SAUkM44yxZCpnZpqkQqu2Q8CAgRaRVUAEAK5fZnx8 + OXF/FWmPZAVopvVFy4611XqaLxsPkYOYx9ubjsH6+ow+tJRg5vEBWD0HQ1vO1vtRz1W4IEYpBVmGA8ms + wU4aHSxk97ltVo1/qQFsbCNXjCv52lTeiNI+sZaoD4ANefsKgLRapKXv+Xakbc/mfbTzyGm32QBcFPIo + JBEV/Rz5avVeSZtMRK2AYcrqNJTLIlJThs1zOwzY/lK4qiOW8u3LfKDne7Apv18bG8AojtxiHWTqOQrA + Z82FxEWyKBDFmABKRABlbIF2PcwqKZkIoEwO3iKQPdJesy4xJVN44wmAIWNOtnQpF3XGgfjIAn51kA4R + aRJ/HFIpEkBRwheWK1LfphHo4CsVRC5pB8p5NJRXhnpdJigqPfOKEFLWES1mKlP1+2JLxZ58OXNpqDPn + JMeKDCAbNUEtYZRtxwq5Fmv4c2EmJC5oMlwoxsOs7kOFc+bYVu6/0s43Jb15J8LVEPF0ChK4EMCETJMI + 4GQfaIdAO5B/WwEomLzAokqEuQqvA9RQRo2U2XBU1V9V5cvlEMqALmsE5kdGuhlg1CoYRjPACGYq48y4 + nTwmVTKDBnCVbVnZT4nElLQEyjQ3bT9OwUxcHJBn6tCkWQdVuWHq8VUFSeEIVkY/Mo+fRQ5+ltfFpfNT + QWthw3VlPMZKOTX2BbdrB8/MjISBUQIMEmCYfpwPMBEBTNgY6WDwGFiHjDxGBLRCUDsEtwM5JCGsqX6j + ATjIAJxLaDJIfxWcyrBdzd7X1f+CpgA7wIl0MJPFHNAJg4rHMlVPM1XOtmpOBCPGqbSh2bdjGXNSqBeY + A40Kw3QLALYU5GD9WAbQlyU2cpCaAG8iBpVsNK9FKtXHSzllvFx7UL/nJCD/snZtrLBMdk69BsVEuORU + cI6EBPogkd8TMZb8fM40gCk3wcCQ5Q2txaCQZD5SOwBnWkIUyGUG50UAQqCCl4rgzIlAVe8VNYE0M6FE + GiWQUhn0JlIpHI/Knn8d+CppFMBJ5p/q/Vk4Mh9JbWCeUiFkky+Ba37rZFBar6jyGUYKPoAUZIzisFXi + scTOzAId9Hm9Bs7Bm0twkJTKxMXteOx7YU0rYWKNVHR1n/JjcO6f4bEWoFEMA+CAIAR71QLJLy5WAD8U + UtrHouhn2IB27glA79mCASFvntaSNIMl1QraoSSFFgFRgDAM8giA7uQz/S6ZAKR77jUiKEQBLFK85EMw + kQOXwa7vWwI3mUsw1E1lbsJg6eLh5jRS9mXFEs806JIktxCFTaEADECGCezZXy5L/oxPlAlvTY733AJg + 9bsirQ2zFDBz0eLR1H9O+4dqAlBKCvlvkgqv+eEqs67EUqWnQQIeCiBOsjJFZX/BBEPjz08CqOp8DMl8 + MQP9RAIgJFAUIOiECDvShyDNBhhU+LHzj1R7PvsOMgLZgMcSbopOQSqQR3Fbss6EZlLTCx7/wvnIiG4z + gcDooKPSTdS8B1ZUXN2mV9dbz0kpgDSDvEAOZtAb7XpNUEKJqOiBBdZLDJbMDC4qHxpxMI2df6QcU/Vh + ZhymXo9KIAlpgBUZ2AVopEr3VPDxmEQeiHb+EEBFh5RF3BIkQ4FwLUYrChBEUivgjAxaofQthGMHAJk0 + Bd0xZjAVTM5DdbATWR2FCvhLIT2U5gs0AdlKEDlJGFlJtqC6LosXEUMDOBtK2BvsdiNh6GTBqikwdiCO + AU1FcCpilxUEjrUFLhEGFyINyO31jGwLlcM0cmLNzMlqPVJ6XGJOtYFU+qfXKRJGMhIa2IUUaIIr7Hdq + WEzknBCAd9rRBjXJtIOEkTCjy0ArEaAhgygBAulP4Mx8SD+ckUKWF6tFCnTVmyoktr6MKsN8hv0VG9Vo + 3zsuGx+7zEClqIIPGVhm7OKSBC+TgLqyDHitSlVOAtoRM4mrXTobL5GLqr/BBCj4KshQahCKeUMS2Kqf + QuUnhub7zCqLjhKIYYJhX2A0kHY7CS4kIOV/NU3n3EjPiQlgg65rAk6JBWN1xGgFhE4UoB2StAYEg4Rk + XFonUCA/CAkcyegDtwJwJImBM2LQ/QoWEBdyBFBjMthMDLIk82gOyMKxUJMApK/X0n9rikKU3klJntIY + SWx7jyY7XSmcyioIoABTIwbmYl4Ma8+XdVKBqgkUPf1gVl0OBdVdn4CXlP0pcypyKrUTBsWZZBe5iRrH + AoOhwCAREAIwJUlNEasb0h4wE0BRyBo/r6FgDEcCUUJoh4ROSGiFhCgdCCNrwTMoBpAkoAGAIJX4QSAJ + IKKcEBAFEGFKGPnoGTKq/dmw2zHeSsm7Bj+cFlGwbKefR69WbM0dACpmYFMDbobCqwHK1Xm1B84Gpx+r + 9ny+XTGObirKK4HLORiFsi4j4IybM6ed1KIZohhoGJtwPA7dSSUjk+qKAy8lQ+Kx8w6CQUn6iQUoTgGf + +aISBqdSPRGMYcLoxwJDwRB6Qk4D6c4P4BD4yHi5DLMrl9xuZyNMhirCiAUjFsB6zAgDzsmgEwZohXJs + PAVq1l/aMRLIlz5kxXEISQBhAA4hySEkiPQvByQ90ESVqcKkRgLynAUYE40KvykzdshqgqgntI25qp7Y + yZJWqYX7rN2yAGbN6adK70KSDufLBEvABwBmQ2ApJOxsBdjVJuxoEbZEhIUQ6AVyXAMAjJixLoAzMePE + iHF4KHBoKHD/gHF8xFhJGEmBmLVS4hnIU6ccJQI0kn+lQ47HEalsnkRwGo4XGCZAPxEYJpIEuMJrt3GA + 5mabsXVXjjLydd3D61ppA+6fqlfHQk48sRYzQmKEgdQO5EeaC1GQFsqAIuSVUuuZKUExQAMeh/yCsWbA + QWpChAQRyu8iUAgiSG1cm7pOsE6XSTVZh5WOQgDaLJpeaeNsk2SkD+4xbA+UHGjZNoIIghkdAna1CZf1 + AlwxQ7ikG2Bvm7A5IvQC9y7DAPqCcToG7hsIfGstwS1nE3xzOcbhszEGA4FAMMJEgATSJBpJBJxKfxbj + HAGG1CwSEGJmDGOBQSKl/TD1OxXz/ifD6EbgvvoAxoMICwE8AOjmcsedtElCZwwFg2ICQSAICFFAaGnE + 0AqAKAQi0NgtoCQHZeYlCSlZpLqYahPqOIPU0ZiTQJASREAQARQtgiBIikGmcQiqPEbA4Gw0kEDFjNzW + faz9zBbXL9n25fWsaQAJy0eyt0X4kdkQV84FePQMYbvPPAeGRgB6AaHXBna1Q/zIfIhXbQdODAS+dWqE + Lxwe4MajQ9y3LjASnJO7SD8MOZNQLMYgHySMUSIQCyn5SyMFp9XRN0RBaHRQEU10dxthFvhygOKaFanO + GViSZLIMy4QZ/YSBOBsDIBAGQBQEafBA+hLa6d9WShpRAIQK4AMaq5w5UWTOIyZJEmnGmRpqzIiFaax6 + MI1Ni5wsCssAQSlbB/JEnJ6UC151KKE17QG4dh2Tow5UsO2LO4+XZ5sIIfO3Hj5DeMGmEM+cl5J+I+NJ + AQHbugG27ergyl0dHF5L8IXDA3zi3nXceGSI5aEE9yiRQiFOJbsKdion/DrWGJg2RnkDjlne264BbJQq + Q40RXk1lDLzwwhkIBj5573rtzGYFczfNxIyFQD8X9eMBQgHJ9OMwJYGWpkWov8OAEQWUmx+ZqSFxTmPn + VkYWYFCSahoiI5TxMGJS4s8LbcKPbAnxlVMCyyPOzZf8BEoYg6msSeSDYyrz6TEeEqsKLVX9LXxHcSy/ + kI6lh88TfnRHhCcuhliINhL29ve7aybEyy6awQv2dvGp+/r4g2+u4PP397GesIwaGcA+XdQ1YIhza0KI + CFITMuzAPvgbO+keANtfMPDii+bw+8/dDsHAL/zjUfzt99YQkH+kgbSTcj7pJGOY6Y1KWI00oiCCBH5W + jy+QUQmpYaSaBCnfA1m+KwpY1vALeLyvEohYbBNefWELz9oe4VHHEvzJ3UOcVar/UDqISd6zJJHcPAEK + y0ydvZDTzqzVulAGuxh/I/fQ750J8MKdEZ66LcTcAwB8U1toB7j6ohn86N4uPnr3Gn7n62dx6/FhnsRT + 16+bYnmjgMw+2kGWRGXeJYkg5550vIHzxfYfJ9QIZrz44jn83nO2Y9esjGr+/nO24/UpCYSllNXm90DG + fYtEgbR0WdE5VszgMyUiqUSSmxfp9ls6Ad7+uA6evV3e35XbQpwZtfDrX+/jxEBqHEGuqWSEoGgbKTEF + ZFAYbE+Yi2SQE0HqwecU8Jn2tNACfvqCFl51YRs7uucH8E1E8JpHzuF5e3r4vdvP4I++dRYn1hPFF+EL + dkMVIa8+vBF3yT7LY7MGkJdZsVhAvrZ/I8zV7yQYKfh3YM/cOKVh71yE33/OdvziPx7D396zZjcHqkhh + Qq6jmgVUApvuPickYCx1Avz7R3dx9b5WYf8f3x3h1LCD/+u2Pu5fE2mx1HGozV6UoOIabR3GWPYrJQMG + Lt8c4Ncf1cGLdrfkZHPneds7F+KtT17Es/d08Rs3nsKNRwYOVTAbagJNd/ItKlgZs7WuTEJccvWbAcyX + dto8D3Raxc5jSnkrVLOhhtuPlxnr9+l1/gAIJgn+5xbBn7WFdoAr9/Rw5+kRvnN6pOXnmzzu2tBe1/sA + LFODV8TvTPeurRdM2NIhvPPxM3jNRW2jR//yzSF29QLccDzBWsy5CTJ2DVAxkqEuBwwfLi9j03LZoUIC + Xravhd97Yg9P2xpN5NU/140IeNimFl6wr4flocA3Tw6RCK0kXCPcTlAkdSOIhQgYjIBTK6a1yyEuufqN + ADaVdlqcAzrthkBwBwSVQF5DACAIAC++eN4K/gIJ7FZJwA58E8mYBwS4EoDnvSvrBYClDuEdj5vBz1zU + qXy/l28OsbMX4AvHE6zGbJk1hvy1GZNamy4TDMxEwJsf2cFbL+9gV+/BW2B8UyfAj+6bQTckfOXoAP2E + 3ZXbBng0EsZG+heIgMEQOG0kgJMhLrn6lwAslXbaPAt02xWd2VcS+oGgihSk5N9ZCX4zCcTGar21BOBA + ak7aj3Z/Ji1Agj/AOx5fD34TCazFXCphpp289LXcqdhKBoKlQ/L/eXQXb7mkg94GiP1BwliJgeUhY3kk + cHbEWIulbwWQjtVpnrUVEJ6+q4tdMyG+dHiAlZFII6lc/2x8CbUx2LnZ9kRAfwicXjVtfTwCMCwfhB2K + Dvra9+r2zZx+AsBz983g95+3M3f4ubS9cxHe/+xt+MXPHk99AloWi5MfoKJqseuy0i2pUQqZx7DUJS/w + Z+2aC1oYCeAtt6xjLUnVdNYHHbBfP9Y6k2BgS5vw9iu6eNWB1lRAOBLAobUEdywnuP10jO8sx7hvTeBE + X2A1ZoyE9Ee1AsJMKMlxz0yAh2+K8OjFCJdujrB3NkQ7mOxqAgKuvXQe8+0Ab/zcMdy/mjQPC07sFGwI + dlsTbPMDDCIAA5d7cruehgN8PEjh1CDBkbXYiwDGJLAVv/hPx2WIEJg8oFHgEVMY1EAGpntlKGr/rDf4 + ATn0/L41gViohy+W44LLPVs6lWBgsUV4+2O7ePWFrYkf211nE/zj4RE+dWiIW0/GuH89wXrM+ai6sVOu + WOM/i0wQgF4I7OgFuGKphefv6eC5u7t4+KbJfBFXXyyn9/rlzx7D4bU4dSBXaAJNnYKNFYkmwLTuMwxx + ydXXAthbWrUwC8woHZGmqAo3dAQSAfevxrjpyABP2tn1JgFpDnRx57LmE5i6GVC3T/E7M0nwP2EWP3Nx + txH43/7NPt51xwBDoV/H5I1ZDtr5j5d38bMXtRsfJxbAl4+P8I5vrOM3b1vDn93dx+2nE5weMkQK6nwa + MxTTsIm4ONUZZJrx6YHAt07H+OR9fXz8nnV869QI860Au2dChA21gkuX2tg+E+KzB9exHrv7BHgqmoCF + hJuaDkTA2gA4YzQB7glxydWvBnBhGS0zwEzXQACugN4YRyARcGhlWiRg9wlMFA2o20dZLiDj/JOC/53f + SsFvHR7YtBMCITH+z0s6eNMjO2iqad98IsZvfG0N//Fra/jckRinh0IZOsGWqh8WACjr8wFdkD6Drx4f + 4q/vWcc3To2wcybE3tmo0Rwal2/toBUQPndwHQmPZwpoBEbrI54kF4Crn5faD9f6wJk100G+G+KSq18B + 4GGlVXM9YLbXHASOHnR3R+D4e0CUkkB/MhI4HY81gUoCqLuHZlqA4NTh98Q5vGYi8PcxEMrYeCPgmzGA + YODl+1v4j5d30W2gWx/rC7z3W338q5tX8fmjI/STfLxUo47NFeuzxKd+wvjaiSH+5z3rODkQuHSphXnP + BAUC8PjtHRxdi/HVIwN3EqmInkwX7K43QsDKOnB23bT22yEuufqnAFxaOt9cT34qQTDFmLgHARAIQQAc + Wp0CCSzH1hBhk/BevRYg/xMMLHUnBf863vnNQQ7+UinyJrhXWsLAExZD/O4Te9je9Q/1ffFYjDfctIoP + 3jXAmVGWf69Lvorvpk7P9USRaQUrI8YNhwf44pEBLpyPcGDBr49EAeHx2zu46egAdy+PFO1nkgxAC8Cn + qfbr1ZzOpgRQ7gtfD3HJ1T8J4PLSkeZ6wHwdAZiXkaPknyghCDLt9dBqjJuO9vGkHQ1JYFdKAqfKPgFX + MBvv37YeSqjvifN4zcMagv8b63jnN1PJX0Z/mQgM66o6EUM6/d73hB6euBR6XZ9g4EN3D/ArN63itlNJ + Pj4BleCvBzq7qr3p4iwJ6p6zMT51Xx8zEeGxW9teU8zPtwNcvKmFv7tnDWdTs8WMX1f7f0oOQNcIAEGC + f2XdpHbdHOKSq18I4AmlHWe6wPyMdrANcASaSMORAMbmQDIdEjD4BKjWlq+4H8O2Y8k/KfjXU8lfVRbI + 1ieotoMxgF98RBuvu7jjZUMPBfDeb63j129dw7G+LMpiHsRSMXsAs4GQmmkHzHLU5NkR47MH1zEQjKfs + 6KLl4cy4YKGFQcL4p/vWMK1mtf+nqgmk7cwasNo3EcCXQlxy9fMAPKV0kF5HRgKMBFAN6IkzAtX1FWZA + tiwgwqHVRDoGd/QmIAHFMTiJFmAhjlzy/8g8XvOwXnPwf2Ndkfz6tfiRgaklDDxuMcS7HtfDpjZ5Xd/b + bl/D225fx3oMmW9hmyVY7+xcieh6M6AGMATGiIEvHR5gdcR4xm4/Erh0qY0vHu7je2dSU6DK1jctm5Kl + YL/XihMsr8pIQJkAPh8AMMYHpjP7aF38dEphE8i89JuP9vFznz6MW44NvPffOxfh/c/cghdd0JO3rs8N + b7sfS5YYa/cpGFhqTwj+29fwztvXMEgYVHr5bKj8xOV1Dp9uALzhER3snXG3+xMG3vtNlZyqwM9e37kh + Keh1+wgyFPm7X1/Gf/rKKQwT9762tRfiLY9bxHwrmKyCDlcta6DiuzQ7llcDAGeNZ8mKI3oBeqOaYU56 + w7LpkgBXMLCl97H5eUhvP00O/gxcVtAbwG4ig4pPwoxnbo9w1V6/ZJ8P3jXA27+xjmHCaRaiC/jh+Z0b + Sf+CTwyyZuRv33YGv3/7Ga97/LELZ/HCC2eLlYCnGf/3gIMzYXCKZfNRzlYQQPPCoOxLFFUPkf1YNCTg + 5iODKZDAjDKRizvYi+9ElfwLeM3Dm4CfNcmvVeOpIoIqyW96hGnCz+se1sF8y109/vzREX7jtrU8h94d + /Ba73ybFPUihSnMjAP1Y4K1fOYX/eY+7Xd8NCT//mM3Y3AndQG/pw03s/+aVhq1p/QxgJQCwAmNVIK6b + 5dFv2YYQoflBSk1gUhJYwov298rPzkH9z2PoAljsEN7xpPnG4H/b19fwjtvX0Bdqdi8Xn7WJCExkUCAG + 7QOZjffUrRGeu8Pdh3J4XeDf37qGg2uJTK/WnXYu4NefXa3TkB3eR3WfDUjmKPy7L53E3WdGzvf7jD09 + PG/fjBSqvNE1/dmJHCo1oKxcU7klGQGslgmAUhOAN+RemvkBfBwprJDAkan4BJhrOqOmEQiWxTze+aQF + vObhM43A//avFyW/UaLqOK+S/jWtHQA/fWHbWfozgN+9Yx03HB0hVEi57LGvAb/N7vfJFTBJf5uWptQz + uOXYAO++5TRiR59XJyRcc+kCZlpkL5rl3H+nFP+vfEkMsIDBC5wTwAr0smCEihFEbpL/gTQDsjb2CTQl + gRDvv1IhAdNLNnSyLMPvnU+eDPzvuH0NA8HauB62A770k+HqCBQCePh8iOfvcrf9bzg6wn//54FSI9RC + UJ7gr8C2AynAgajHiwICPvztFXz63nXn+37W3hlcvrUz9hOdS/Xf12GYjewtc3qM1Am4AqCsA9mHED6A + zf+B5iTwmSmQgKhXPceSf9Nk4P/6qpT8OsGwImUBi7qPMhmYCEH5MBgv2BVht2Nxj0HC+L07+jjST0DE + dpW/8NsN/GzzDXD982d2j9RkYwlODRL8l9tO4+zIbYqMpW6IFx2Ys/S58wwz9qH9IygmgKEmgDDvOIkf + YKrhQHeVKiSS5sAUSCCpMAUKkv8RDcH/tVW842ur41AfYLX7jURgBLqFEBR3wHxEeOFu95F+nz86wt8f + Gozt/iqVv/J3Bfg9wwVuZlp5dUjAPx1cxyc9HIIvuHAWS93QceKQCcN/Te1/IBXkRmIbqgRQRkU6jZI1 + 99EB5BtrBmjnqVGrcp/ApCSwv2dU/YSQob53PnkTXvOI2ebg//rqWO2vtPHLRGAkgxrJnzn/Hj4f4IpF + t5TfWAAf/G4fp4eslVG35CLoJoAr+L3yBmzYd4vgrI0E/vRbZ7Aeu0nwS5c6ePTWjnmOwPNF/c9MebNi + 0wewFgBYTz/aRbEtfjj9NlVnoJ1ZxyRwdCIS+HE1OpA5/LoB3vmUzZOBP5f8+iQcbkRgJIN6/IMZePLW + CFs6bur/N5dj/MP9meOvCvjsaAK4gh+Oqr9/wlZAhP91aB03H+s7PYP5doBn7O417K987iwFuzO/D2A9 + yL7YCYCqGXYaZoArQdQ9yDp2ZdUnMCkJdPMJZZc6E4L/thW842srmsNPB7CBIHUiqCADIzGkm7YC4Clb + 3Z1/f39wiMPryTjbjw19x9kEqAI/nPIGfCM0pk0JjJMDgb+9e9X5OTxlVw/diBz7amXnLvfVxsvUVhnN + WwPQDyDV/xUjASSi/sLPhRngwKqMCgminXd6JNDDlm6Adz5lsTH433bbSlnyW0FvQJstGqAvshEDMza3 + CI9yVP/XYsan7x9a8sTYfM2NwV+fKGTDkkvWZqlvMvAP967h1CBxehaXbulgWy9KtUGu6bHnWP3PWmIl + gFWVAM5ad55qm9QZ2FCdMrz/aZDA7165iOuetxWvngj8K+gnYiz5Syq/CdQ1YK9L/VPDfwzsnQmc8/7v + OpvgG6dihPrBjEDn8m+lczuDHw6mQ01otoyd8oqAgO+cGuLbJ4dOz2LnbIQLF1pjZ7l3f92g3H83DJ8B + MAwg44HL3gTQSOWvOw7K7Gzdrs7JUp8wEhLh5mPNfQL75yI8f2/Xu0zWUDDedutZvOO2s7m3v8z2NtDr + IK4GeJ0jkJlx4VyATY4Vc752KsaJgUjVfxfb3wDauiiBb7iQLe/YkxQIjOWhwFePuvWF2VaAh21u1/bp + eulfh40m6r8TAcQBCImRAHITgOuvcBIzoLTINce6qgPVPGw1OgBMRAK+bQz+lVKor5T3Xin9UV7OFSl/ + FWMCDsyFiBwH/n3t5EiOorOp/zVkwFwXFWiQKwAXU8E+UlNdLQTjNsd+QAAu2tyyzKDno61ukPoPrjIB + lsGUZGMbLRpAMqFGMoEz0GmUlacvwKIRhCRJ4LUbTAIFyZ87/IqglaWvfYigjgyq84ADwFn9HwngO2cS + Q8zfAfhGlb/qXTZJFKrFvlOewT+fHmLNMSlo73yrWCrMVfpPBeAO8Eus/ozTSCstA8BJMwEIJ3zbgQ0L + 67rtYwd+NeP6PXTk0YGvbiAJDJMU/LeeNTv8tN/uRFBHBhopaJ+QGNsds/9WY4FDa0k63NdN/c+B7xEV + cM4VYEsf8VT9i2YAcHgtxpmhGwFs72WTktTZ/rau6DHyr8m4ATuGT2UCoIIAEod04CbAdnQGNtECnM0D + NoYIv3psgNf+w3RJQIL/DN5x6xkMSg6/aoCzTcJbwc52QjC0FhE2Ow7+WRkxTg9MdfHYOHrUbOtXgR3u + uQLOgLd5/e0EcWYgsOxIAJs6IVoBWWSUgwZaJ+kn0Q6YqzSAkyoBnIJpRGAi6isDTewMbKoFWGwsl4df + EyL86tEBXvsPx6ZCAkXwmzL8DFK9ThsA6u1+k+Q3OABDYsxEbgSwFjPWYi2DyAJ8N6nvbhI4gR/277VD + i9PjEAHrscCKIwH0okBOiV47MAnTB33deUTmxzOOBCxoAKehDwgiVDkQGpEBu2ZoOWkBts7lkoRRPdhE + kkAfPzehJjBIGL91yxm8/ZYzltz+it8mbYDZkQwcHYFpB3CtjTcUQCz0cmRF0LODP8BvrIAH+J18AzUO + wxQzA8dyYa0QCAPTo/aR/mjg/HPBY3oz5dc7SjGfE8AyTAOCBDvmAkwwaMi63nYa7eVXqP/+JajH3wnA + PWdifP9sPBEB3H5yNJ5yukrl9/T6G4mgAHKz1NePJScTce9V7CTtq4Bv8PpXmATNwK9zibsPIL8nx+dB + 6jNvLP2bgN7hCu0a/CDFfE4AZyBTAzUCEPLjPKFkPbCnpgVUXoTNIej2XQhZuvtdz9iCFx/wT/LJ2kI7 + wHuetoifuEAdO1Cv8nsTAZvTfIuEAKNZIFjWyHNpEUntKD9nY+CbwFLOImwOfl+7v/g9JJke7dLiDGPk + aH5WwqTOzvfQBEjBb7mtp5jPCWAFlenALiriBI6/yv0rnIBcBWT4mQLZqD7OwL8V11660GheObXtmwvx + e1cujasNTwL6KrufzYRQR5wJw3kEXDcidEKTVWjzBzQlA1OobwLwV0qc8nPshIRZRwbox2JcTcip77qA + 2sM3UMUAdhN+BWn2b3aXqxkjFJpgIHbLi65V+RtrAahmc+szcWHkYgcSQo7qe9eVEvzTantnQ/zeM5by + AUSVAPfy+lfY/GwgBe0DZoyEwBnHmPdcRFhoUfoebDkAqFlevV1+bYV7xGTgdy4wIveaawVYaLsRwNmh + kJWQbSHoiaQ/PEwCQ4sTmwmQa/zZXfaROgWMB3FuTaQ8OxAH15yyPvmnzh8gJX+Idz1j21TBn5NAYRSh + pwlQuxze4b/89QrgeN+RAFqEHb2g4jQ+hFAn9VFNjo3AX9XtOL+Grb0Qmzpug6NOrMcYGdVsByJopPJ7 + eAHt2D2VYj4ngBGAE0ZwxYn7SRtrAQ2yA51NgXrnXzae/11XbsO1l00f/GUS0CoL+WT7NQn/WZ2BjEQw + Dq66kXw3JFw8H1kG+RgA7pEefG7A75AcxMCFCy1nE+DgSpzjzDvrbyOlP1Lt3bz9yRTzOQEkAI57HqSa + BbylvGm9i0OwwhSoSxOGIvk3GPw6Cbxofw+JYANm6rL9UEEGNZqS5XPP2cR5IqhHL0YICdYcAHhkCWbg + t96/9bcL+OEB/mIq4KO3duA6E/r3locAM6Y+4/Gk0r9aeB9LMY8Ao1zVOWI8kC8BNNECnIjBBewVot5g + CmQFPN/1zG249rJN3mDuJ4z7VxPv/fRCo8xTsPtrE3/MjYhx99kYq46OwCu2tFM/gOHkHv4Af6lf8dsI + /hpBYuh3DEYvIjxhh9ukrYOE8c+nBp59tLhwY6S/SgDGdlQCIEGAhX5xoZEAfAckTEkLqNh2ElOA81Bf + iHc9c3sj8A8Txtu+cgr/2ycO4+ZplBznOiJgO9idEn/MYwEIwPdXYhxecyOyR26KcPFCJP0YXCHtfYDv + EhqFPSrgBH7UE4hgYP98C4/Z6kYAx9di3HV6WB4N6BPC2wjpnz2jOIElgieFfaeLAKtdlQAs6cCehUGc + VHoDAzoN4HAM81SQQB7qe+Z2XPuoZuD/ra+ewju+egpfOLSO1zVMG9ZJwAgQHfBWu58bOQIDAMfXBb69 + 7JbwtKUb4Jk7OxaZYCMED+B7mgCMKYYLBePpu91nl/7u6SEOrYws/Q61ZgDX+AYaS39AYtacBZhAmgDA + IEaAj78iJzTo1YGzdOBGlYHcbX320ggMvz3CvdLhF+Jdz5oA/F85hbd/5RQGCSMMZGWh105KAto0ZEYi + 0MFeGwJkJ2fgeixw01H3a/8X+7vYpIYDrf6ACkIrMwR8TQAnh58r+BnotgL8xEXzzgVebjq8hpWhKI/v + qAKvLSpV2X990V+J2wEyf9/HXwnV1XkStmzARHjNL18N4KbqfwNTQDtO5vB797O249pHbW4I/pN4+1dO + ylF96TMJ0rEDE5HAM5fwov1dOfmICxGYgO4i+Q0cwABuODJw9gM8aXsbT9zWzufHM57GKPFRIfX133ZA + l4dKNwO/ulww4zFbO7hyr9t8DsOE8fl7V4tx9jopPrEZ4NgywW3W3NegjP5VCeA0KpOBmqTE1QHYoA65 + hmtc0z01yf/uZ++YAviV3P70+GFOAkenMzW5JVTG7OLprw//qZ8QcszCd067TZI53wrwyofNQM+VMV5j + XTjTJy2abVGDZuBXSSQg4KcvWcDWnlv8/3vLQ9x8eB35dMguqr8x7OdDIB4MUJ0EdMpEAGfVFYULjBM0 + ahM4+czf7WpWlT8gc/i9+1kTgP+mk3j7TScxiFmjQp0EmhcV0SckrXOk1RICnPAPAnB8PcE/HOw7X+tP + XjiDx29rIxbs4MBEPfBdhkV7RAWcwZ9K/0dt6eBlj3APA//Tvas4eHYkayMCNYDGFJyEns3uvD8FJe1f + JYB1mHIBGMAonuBK3MHuNS2U46aCgaVegHc/eyeufXRT8J/A279yQkp+UoBZ6J08JoFj0yQBlQiq7Wwn + QrA0wcDffn/duRLO1m6A1182j15Ixf5cOVbBY7xDrcrv6vyrBj/AiALg569YxL55t7kR+jHj43eeGc8V + WQdo7V4akYIv5kaxbfdjUOYBGRMAYQhjLkDlwRzxX63+GyW5x+itHCPa8rHaPyH4c8lvGEdg+J2RwM9N + gwSEQethu7fdRAgunwCMm48N8SUPZ+BLD8zgX+xPr9GnWKkHGdSq/OyhFRj6lxCM5+ydxSsvcXcI33Jk + HTccXNXCf+yn+nuZAQ0wZxfaRwAalglAXt39xgOOmuQC2IjMN+zn8r1MArna/+yduPbRixOAX5X8phdj + /p0VGp2YBC6cGTsGjYlRBkJo+KqWBwJ/fucqHGthYLZF+LXHL+CC+Ugb5AT/8QwG4Dur/E3Bz8CO2Qj/ + 9ilbsdgNnZ/Tn3/rNE6uxUVT0KvfejoJvfHGErPmdn+auqgRgGwHy9tXOhT8WcAB7Ow0I4z9ZQtmLPVC + vPs5u3DtYxqC/8YTePuNJ4qSX1fJUf170pLjBRJgLbnGmnOuk4KBHCyfkIBP3LPuldj0hG0d/NrjNqEb + Zu/NdyCTQerXagY1JoAD+BlyzP+vPnELnrXPvebDN4/38dHvnIYT+tlT9Z/I8ae0asf9wQzWYwK4/pps + 5SHoyUAEWVhw0olCnRx7NU49h7ROzkJ9E4D/rTcex9tuOo5+LLTZb+FkAqjXE2LSGYgyc2Cm6BPwlvz1 + DEBgHFlP8MffWnHWAgDgNZfM4ecumzeD23Vsg6vUrzUBiu+qNGtyNupPANdcugm/+Nglr/fxga+fxL1n + RsV+4ZPw4ztSsREBCEkA5iSgQyrmdQ3gMEwThSYNcwHcWcAIcF9/ADOk5H/u7onAn0t+MiVsuJgAxXub + fBqyCO9/luIT4ApwV0l9hxYA+Ohdq7jhsHtEoBMS/v0TF/FTB2br/QFwBL7LFGnG35b+o2wvBOOFB2bx + 1it3OI/6A6Ttf903T/vb/T6q/6ToJ8gx3om1EtAR/X2r7ThMlYESkToVJmQA5xi/73dF8j93Asn/5eN4 + +5ePYxCLQuFLdgV9hTYwHRLYOjYHKk0BAzGAreMBimMDGMfWE7zvtmXnxCBApgi/9xlL+HFVU6nxB/hN + glKzjc2M0AAnBOPZ+2bxu8/b5Zzym/WP933lGA6dGSqRoEn7bRWJTMAAcWzT2FegRfp0AjgNWy7AKMFU + mospYLWdLNsIVfIveV+SBP8xvP3GY8VQn4kE9JflQQw5CXz6yBRIAKiV+g1bQMDf3bOOv7xzxWu/PXMR + fv/ZW/GSi2YUcJfVf//Zj+xAL8f/zeDPZrt/wYVz+MMf242LTXP6VbSP//MZ/NUdy8i9wVPqu1NV/bM2 + qswBOFVFAGdhGhU4cS6AMwsYv1cl+XDm8Hvublx7+QTg//JxQ6ivqPKbpYqDNqAsG0cHJiSBgk9Af7au + Eh/GMQPEjH4s8M5bTuOOUyPv6/uvz96G1z5qAa2A8mnEjYVLJ8gNMKn85Xck14v0ub/qsk34by/cbZ7Q + s6LdszzEW284gtVhUq7u3KDPbiz6K8P2R6Fp+DoB9JE5CfSDDuMp43+yGD+QSv5uiHc/b09z8H/pGN7+ + pWNjtX98QqtNZzUJKrWB8TKpCQwm0wSevVXxCXBDqW/fKSDgjlMj/MebTmF15OcA3tYL8Z5nbMVvPXUJ + O3rBuGhmFaD1d25bxrCq/KY+IgRjSzfEbzxtG97//F3YM9fyupdBwvjPNxzFLYfXQURwmby0SSXqqWJr + aBXWBwEuOHfGwc9Lrs52fxKAp5d2bUXA5jlMXCZXbeqxrN/z/wACSBl7tdSL8O7n78G1l29pCP6jUvIX + 4vykuDqo8Ef/TaX1+v72ZQEIh1Zj3HRkgCft7HrZo4AsOX7l7h7uPC1z+O2vpfn7IjC+fWqEuXaAp+/q + eu3bCghP2dnFk3Z2cXA1wT1nRogFlySONfTlSgYwa2YiTXF+xt5Z/PZzZS5IJ/R/Fn9460m888tHEbM+ + f4Iv+LHxwh8psZ44AwxGJqx+AqBPAQzc8RGNAB75sqyvXALgx0udKCBJAEGAqTYnEiDlK429/T+6dzLw + fymz+Q1ArwR18TfVEIVtv4BwjkigKQHIsuG3HBvgYZvauHSp7X2MC+Zb+IkDs9g9G+L7Z2Mc6ycQIlM9 + LUOZrcO97YN51OQeBvDwzW38qydtwW9duR2Xb+s2osFP3n0Wb/7MQZzuJ/mYnyrwV4PcwR8wjZYI4Piy + jASUb/rPAdwIkIEALrsK6WvZDeBlKKYJSxBungOicLoXTDpgDN9VEmBgcSbCe56/F9de0RD8XzyKt335 + KIZxelgygdbvt1UbqCGCMQn08aSdveYkcGqEb58apjP9kOEZN2ipFF0dCXzl6ACP39bB/vmW92F6EeFJ + O7t40YFZ7OhFON6PcWI9SU0DKuda2IBvAn+a+MUsp+i6ZKmDX3rsEt7+rB34yYvnvcJ8arv5yDpe94n7 + 8L3TgwrwY7IENkwZ/IB0AJ5YNiXuxQD+GMAdoBi443qNAO74aGYGLAB4BYCyzrdpFuhE079oFxIgAEzY + Ohvh3ZOC/0tHc7WfrITThBSaEYEkgWQyEtjTwz8vj3Dn6RGm3YiAE32Bm48N8OQGmkrWNndCPGN3Dy+5 + aA5XbOugFQZYGQqsjgRiIVLMKNpeyc6XIBPpXxZAGBB2z0V4/gWz+D+fuBX/4anb8OKHzWOp21xQ3XFi + gNd+4l7cemStBvwWj79Hdaqp46g/Ak6eNWkWZwH8HoBDuP7V+ULTmzwKGQ4sjo4QInUu0PSZi5FOrUTV + 35nxjH1zeMWjGsb5v3hEgj8eq/0MlqDNzwXt3JJ4iokBht/5bnIZsQr68nZ6JwhBuPlIHz/36cP4o+fv + xOO2dbzub+9chF949AL+6eA6zg7F1M2BEMBtxwZ43WeO4g+ftx2P9bw+te2cjfDKRy7gXz58HveciXHz + 0T5uPNLH7ccH+P6ZEU72E6zFAsMEac4DQAHQCgkzUYDFToj98y08amsHP7Kziyfs6OHAQgvtcPKbzsD/ + 5YOr7uD3BjxviPAHSGLUnANwGlkpMI0zxu0l1yEF/qcBPLEE0l1LwM7FDbp4ODkCe60Av/b0XfhXT9vp + /MKHCeOtNxwpSH5d2tOEJoBpGZU0iqp9ZUsYePz2riSB7e4gu+34AD//maO46WjfovFPVNKpcH2P3dbB + +5+9HU/1dAzWtX7CON1PcKKf4FQ/wZmhwCCW8OpEhPlWgKVuiC29EJs7IXrRdFnu1iPreP3f34cvHVy1 + 1nwwgt/JN7CBdr/6ig+fAu4/aXrdNwH4UQDLSuo/inqSNAEEgBdCOgOLD6HTBhZmsaGtxhEYC8YN960i + IMJT984hrCngloP/i0fsDj+dBDTSKf2uBHOFWeBABAWfwA43dfu24wO89tNHcOORPoJpi36tBQTcvxLj + cwfXceGmFh652J7asaOAMNcOsH0mwv6FFh6+2MalWzq4dEsHj1hs44KFFrbPRJhvB85Tmru2z3xvBa/7 + u/twy+G1KYAf5x78WTu1Aqz3TRGArwC4DoDIHIAGAvgpACQAPA3Ak0sHb4XTDwWaWAzVJJA4koAE/2G8 + 7YtH89z+smZRBuJGaANORJB+9SGBDPw3Helrk1lQxfOtaFy/IiDgeD/BZ76/hk5IuGJrF1GwscSzUW0k + GP/9ayfxxk8fwl2nBlMCv4szcAMas3QAmkOAnwLwtwBgJ4AtHwJm7wCASwH8WLHjkAwBbkQosIoELIRQ + RwLDhPHWLxwuS37jMT1IwLK9DxGYj1/cPgBwaCXBTUftJHDbsQFe++nDEvznGIABAasjxj/et4b7zsZ4 + zLYOFjshHkzt4NkR/t3nDuOtXzyCU+vx9MFv9Q1sUEsEcPyMbSDQXwD4EviVwLd/00IAj3905vjaCeBq + lDMFNyYUOCEJkEYCBfDnkr8CxJbfZondTPrXEoFhXUCEQytZiLBIAgXwV2gTU2mWgi55nsDRAT533xq2 + 9EI8bHP7nJORb4sF439+9yx++ZMH8dHvLCMWvDHg33Cnn9aGsUwCMocA/xDAHaDbgTv+ykIA3/6rzA8w + D1MokAEszADdNs5JcySBL6Yk8LR9cxACEvw3HC47/JxIoAzWem2gARE4kkExT0CSwG3HBnjtpzLJP/ED + xiS9M+PWQ6sJ/u57K7hreYQLFlrYObsB4eIptG8e7+M3/tcR/Ob/Ooy70hi/HfxaZebzGfxEwPpQhgDL + TQkBXlNYURblkgAiAC8HUI63zfaAmS7OWXPIEchIQDDw2XtW8PYbDss526kmqciFBNKv5LCNHxHYl+uJ + PAEBh1ZifPVoH3OtAP/uhmO48UgfockXs9HC1zIAKSBgKBi3HB3gE3ev4Ph6gn3zLWzpnR9mwV2nh/id + rxzH//2P9+PTd58dCwcnENeAHw8w+LM+fXYNOLNqWnt/SgDLqv1v7i4yFDgP4O8BPLX4nhnYsQjs2oJz + 2ioBO/4uVU/Kp952tvtdiMAa2nMlBgcisABYHf/QCUkbu3BeMEBhVTZU+cCmFq5+xAJe/ogFXL6tM3XP + fV2LBeObJwb4H986jb/41mnceXKQ9gu3uo7jbl9hyzuvOwft/hPAkVMmB+AXIX16Z3UNwKanrQG4t0QA + gPQwMm9sJKDUsbg4DjtLDtLWJYIL65gVLaC0n8tv5Uuey8NjEjAlD8G2TEEI64BXe1uZDNREEzkpCZVx + SA4A3WAeyJOg0mu5a3mEd954An9y+2k8a98MXnLxPJ6xZwZ751vYKC5gBg6tjHDDwVVcf+cZ/OM9Z3H/ + 2Vi5rh9Q8DNLbJrbvTDN+mUkADnkMQHwvfLmSqZRGJ77G3QgAX0dM49V+GygSRUp6OsNgOb0N9WC3gBs + G+BNAGZzTj8b0Edcg6jp5AGVwF61b5Ce99hajP9xxzKuv/MsLlxo4Sm7enjm3hk8fkcPF25qYVMnRNMk + PsHA8iDB988MccuRPj537wpuOLiKu08PMYyFfEtkA6Wrs+88Bz+gZeqW2t0oTfxrJYD8BX7XuG4UywEH + UXju7JsJSSADLRW2VcHKRXWe9d+wagNuRKCgwgZ4I9j1wTH2QT5c8zJqCcIH4LVkUVyQjblIBOPOUwPc + eXKA6751GkvdEPsXWnjkokz0uWhzG7vnIix1Q8y1AnSiAFHqZUwE0E8EVocCJ/sJ7l8Z4a7lIb5zYoBv + nxzgnuUhTvQTiGQM+rEJ6Cn1H2zgJ0hMjmIb0X/XtmuZAJJEJl4Dd0EWCCl6/BIhVY1eB+eeAVxIQAe2 + jQRQbwI4aANeRKAurzIDjOsdCMFCDt6AdgK5w0qDoyyg8bWdWE9wfC3GzffLOrRhIH0c3TBANyJ0Qsqj + HIkAhonAeiyrFfVjMS6QSgrR6KZpndSvA38V2M8H8GcvezCyxf/7kBpAmuNXRwAfe3XmCLwXsn7YrsJ6 + wUB/+MCAv0ACCrgqgVzclqH5BUogd9AGmhKBcX8HsFslf5UaPm0jmxtswpXbEJQcjbSwUT9mrMfxuG6N + pWCITOokhVDhJeVNgGUfsD9Q3n7bg+8PkVdBKbZTKZaBj77agQDG7ShkebBdpZOtD+WIgQZ9LAwIIclr + zcZxc8N7LowUrLPtbX4BG8iN2oC+TeGLIxEUScObDKrATZ6AnToXuGsCVYRBKAZU2FQ9uvDAa4A+qcrv + pRW4tywzPSBCQDKpKmkyAY+AxKTaF8ftEEx1Ph0I4Ayk7fCE4lUTMBhKU6FBRmBEhJl2gERwfsMJc4EQ + GpFADmR3Fb/WJIALMcAq5Y1E0JQMqgihjhjOHQNUA9VznR/wHYB7HoBfBXxI0sSRfwnrI9GMAJJEYtIc + mftuimUPApBASgB807h+GEubo+XvCAwDYKYlCUAwkDDLeUeYC6TgrB14+gFKfgGjSVAH+jqzoAjsAhEU + ti/9qCAKC8DPldT34gL228YJ+DUk0oAMylOaV/12IRfz68lAr4I9JKkJh0FKBgFhlDR4fwSJxWFs2+Kb + ABKbth5ZDyrb7ZB5xMXthADW+sBcz7vTRQGhFwUQLMEuFAIQGREYSIFTLcGNBCpIwfC7bBK4gt5GBNoP + jQhyMqgCuzHWb7Kp3R2B0wV5xcoGpMBWgE8K/PIyb6nvCf6ylB+DvfCXCEH6PSDCatBk+j2SWDQXAYkB + fL3qHZoJQARAwADwbQAnAWwvMeNqelLPhKCQCN2UADK1f0wEDMGUE4BKDolGFAJsGHjlZwKUTAIXbcCH + CAqgJc2vV0EGJbBTNbCoCpuTsgA3WlUP3irQKwts99yQDNgzKuDi6S9KeRXkqtRP1yvAzwgi+xs1Gdch + hMSiOTnvZIph6SdwJoCPv1KNBHyvRABEwPpAxh3bfkUigwDoRgTBlJIApSQgJ5EQik8g/1swDeTyODUT + MqLIzQVPE0AHr1EbaEoEageusPtLZGAlEZRJoRaIPFFR0Ik2bgr6jQB+g6hAlQkQpCFHM9jHUj1bFtCY + ADLw578VEvBuo1hikawJQPdJTF/jQQBZ++g1y3jpdbdCzhVQPvFqX1YJcvXcsbzZdhikKj3lWkD+N6CC + VqATQUYWRSeiwZkIdxPApg1sCBEUAF0GO5Me7iIzGMj2zGlCIDdkBetiD39AVXRhasA3bVf/m5ACNUAt + 2McgLwM8UH5n30kxFbwakcSg3f6/DdxbBq1bD1FNAC+9DgC+DOC1pZ4lGDizBmye95IwAclJIxiU2/XM + BAEuaQU6QeQAT8Gu+xB0v0FGJPks1bWJPmUwFyIFJrKoI4J8kYNWYACBkRDqwLJRwQCnVAB23KeJtPdb + 3kjqp9uM1fpMUpPVntdV+bF6r4Jd+QupPWQkQOmyIMvCdX1/QkgMmtV/BvClKvBXEwAHWebQVwGcALDV + yD6DoVd9gACUEoC8boExQOX3Mvg5HeFXIAZR1hJyv4GiEYx9CCgcj9UOYJTgntpA4+UmMnAnhAIpeAB1 + Onzg6gA03UjFdlMHPpwyAintn0GAgjTXQZ/Z+iXg2wCvAp2QEwAp3yUBeDL3YCQxaN7veIpdIBQNCOBj + P535Ab4L4BsAnlXaZhRLBuq1nTsdkYwEMANMJGd0Y/n4x7b8+LvAGPQFsyHQtALVbBCpmVCILKBoMuT7 + ZX2j3kyYGhHkiyvseEdCyDu8Q98hR9HCbqLeb4M6P8UUCMFX3VelfAjSbPmiOh8qmkAQ2NX5wt90TIIq + 5WW6crouI4JsuQ/4CRJ7o8rw310AgL96dQMCkOIGIF4B8E9GAmAAp1eApXnnpKDMlsoyvDitsS8JAfnU + TplTTxQIgVLAcoEYdI2hSASKVsAMIWhMBlz0I4h8Btsas8BGBDqwawFvWedECDUEUgVsagpqDzZwIYgp + aQHs4SPI+p8O8rGnHopqrwJ/7ANQbfrcN6DZ9KqaXwY65YDPfwN+Q6RHicSe3WT4LICVuhdRTQDjTvdp + AG+GLBRS7H/rA3kh2zY5J0YESp5nnsKdkkCQzwGiagdFc0Hk5EAGZ6LiTxB2LUECf2xaJHpSknI+ZyKw + kUZpeR0ZOBCClRQs+08MdJ7weA6OPuv65sDPQBYCCIJAA70ak0eekKM778q/VRt+LNkDBeSBDnhAAT0V + eH+c+uzIAJQK3vWBbZezAD4Dh2NWE8D112RmwG0AbgVwpXG7E2fkfAHtyPn68++Kk5uVyjdMUiVgRTsw + aQmiypkYmJ2JQvEJFMwEUEoAujNR/mZW1W0fIihun3+hKkleQwi1wONzlAjUFPAOoLesqwK+nl9fALwC + 9pCKjjo1POfivFNBrkv5QJHy0Egg+13CgbOBBmCQFv+0t1tSzEKvAORHAAAQJIAIzwD4mJUA+kM5I+lu + x1JhTOPqLBoZjJdq2gHGZkFg0A5yc8HgTJTLiubCWCugYqgx/0sFf4H8DS3USNqAMC6XDisBvg7sNsnP + BgalDQDuRoHdLKFd11eNCyg674ogV+PwoQ54qgG8Ju0zdV9V8Y1qPYpSniwV3wiO71Fvx5fTEbnW9jEA + Z0wlP/0JQOTpSX8N4A0ALjBud/IMMNeVE4i62KNKltq43xei91btACWtwN2ZyKbcAyA3A4ohx3SZTgQm + ZyJUc6FGK6gEu4/k1x60sR9tQCZgkwShhk5Ak7TPpTxMufU64MsgDws2u4fzDgbVPnPeZcs1YUbGt0Gl + W3Z6SwTg9KrEmr3dA+Bv5NdkCgRw/aukGcD8HRB9FMCbjNvFQs5J1m7ZowIkx3sPYoG2Ws+axsgu4qJY + gx4mQrA4EwshRpTNhdx/kDsToX1SLUEjh3E2otlvkOTmCMYmQ3rt5GP3N5H87Lxwg5qrJlC9nUnaZ4Av + jaIrOPRMYTkL4FHtvKuV8sr7pFrAm0GfR59AGAnG+kjYmYAgh/wePimxZmeMj4LwHTBq1X83AkCB0j4A + 4F8C2G29wIPHgf3bpT/A8IJPrI9w69FVPGyxh82dEMXcB9ImH6Za7SDbjw3aQYBqZ2L2fexMhOJERNF3 + oBJBlnUI5KaB0CIKaugx91GYTAQT2MlD8tO0Jb4jeL35hWv8iFx6BERq/nxxEE0G+kJ+fUG916Q74Bii + UyW+FqKbUMpL0HOB/xnAmWGM757q48ja0A7+QSyxtT6sesWHAHzAh/PdCCCMgSQCwpnbkKx9AMC/sV7o + yjpw3zFg7zYjCTCAo2sjLA8S7JlrY+98B7OtIPcJEKsPVjoBbdqByhUF/wHReGyAqhWUCCE1CzD2GRTN + hTFBCEXVL/oQVHNBDTOqhEBKGDLVWKoUQFdTwAhA3hge4IY7ODoBc8AH+lj5shMvqJP0Jekue09Qpdbn + 9rtFrVfi9JV2vDUHqTi8nRlYGwkcWh3ivrMDrMfCDv5hDBw8JrFV/V4/gI++8ja89MNAK3F6S+7dREYD + AGAfgOsBPL5y+4UZYM82oBNVdoJeFGDnbBu7ZttY6ISI0qdfUKtIfwlkEJJKfj2ZJQsrW3IK/Gx5Rgpj + s4G1kCNysihqBdB8CuWwY6J9T7QsRpWsyOd1nS8zcLmUAtO4Lbt0VVIXsu9UkAcKyGFKwEEu1XMPPXTn + naLOo5yAQyAtJIdqs02fT0j1/SjaJoAC8BPBODtMcP/qEIdXR1gdJdWve5CC/8xa3Vu4GcBVyAb/OKj/ + 7hoAAAxngM4awLgXwP8D4E8BLFi3P7MGJEekJlCRKbgeC9y93MfBlQGWui3smm1jqRthphWUbS49eUIL + s6iaQP4MLemVppHEqlxmjRjUaEMWVSjkJmA8KlHkUYcyQYyjDBpBiLGZUCSECVBOPisnjfPbd2aDWh8Y + 1He7Zx4ltb0g1TG22wthOUPfyAUIVUnz4r0X7XYlVK0CnDKhMk5zz53UkIVMT/ZjHF4d4sR6jEEi6t/d + +lBq06v9uoe8DOA3AdwHZq+S/X69a6wFBAB+HcB/gGkCUbXj9NrAziWpEQRU3ZlYFiSeiUJs6UXY1mth + qRuhFwWIAiq85LH9ZnLOFLUHVWPwiqAp9lolMRSWo2A+sKYtsB6ByMkApVGQQiMl9cLPt+k32cIWmXQt + SXKbbW5R3fW8ef1d26S4qsq73IBe51O12ZmhCQPWxrFkH/ke10cCpwYxjq2NcKIvpb2oq6VJGA+0O3yy + zuYH5Kl/E+D/lJf9dZT+zfrRmATmALwPwM/W7hMEwOIcsGWTJARykCoKGWzuhNiSksFcK0Q7lKGfkteW + itlWZc2Byh5b0lW++k7OBelGOSFAJQSoHYMLeQoZSQjtu25K6OZEQeroL/BcM4JhMJ/qHDOBOtTsc9Kc + dMXUWZMXvpw+C+KiWVjzONgAeFWSQ3lfBY1PXaaSs/KuBonA6jDBqUGM4+sxTvdjrMUOoM8umFOpf2IZ + OLViq/Kjtz8G8EYAq77gb95txiSwBcDvQs4kXN9h2hGweRZYnJcjCIPArZZA6u5vBYS5VojN3QiL3Qib + OyFmWyE6odQQcgLQnTsGNVEnBsCkOXh0KOg+BuW70YzgQphynMRULJCqEkMCzW/AvvX+XV+3n85Pmmqu + Z8+VQm2lgTFlgg4UQiaDyk6+70YlTl26a++gINnT3+ozz4h5EAusjgSWBzFO9mOcHsRYGSUYJuw+rJdI + Ar0/BE6dlXH+Yez6qv4MMjfnRBPwAz4+ALUJIcErT/wrkBkH19T2vVEMHE3Zba4HbJ4DZrtyIBGRnQzS + hzESjFODGKf6Me5OCWGmFWK+LbWETZ0I8+0QvShAJwwQBiwHbFA2romLHl8eD8EklYUJebair5ZgJgUq + EoKi2pfDk0VtoeR4NGkKSof1h68fUVilPGy58mY1vqzCFzPpgPIIORdMqM+AFI2MoDl9uRgR0sGfa2eC + EXM6KclIYGWUYHllQV8kAAAIq0lEQVSQ4HQ/xplhgrXYAniqAT0zECfSvj+9Ij38o0TzQla26yDH55ww + SqwN1QAA4GUfAuJ890UAb4UsHOLmgWBO64O1gfkeMD8jzYOwhgwqNISAgHYQoNcKMJcSw0I7xFw7xEwr + QDcK0A7SzLGgqG7mHbDkSyBDRILctARSHcdcIoYyKVjsSkUCCZQ1A/17pl1Ma76KjASLIDeDvZAfX/iO + isExNulu93fYnLglD7zyPHXCVZ9rVmZulEiH3VossDJMcGaY4OwwwcowwVosMExkVSqvwh066PtDOZX3 + 2fV0Qg+v2poJgD8A8G8hJ/0AOAQ+9orm77Zxe+mH1Kq0MwB+Nf1s8gIvIA3ETlumE8/25NRjrXA8dNC3 + JyuGaRTIIiTdKMBMFGCmFWK2FWC2NSaGTihLlbUDQhSMizgWwkdG34HBo2xJEGHtVzEMWfzObDAdStEH + hRisGkJR0/DpGERlr32VtC+F22wSXo+pG6Id1mdnyaZjbV1BexIKwAVjmIynF1uLBdZSyb42SrA2Eugn + EuiJUArP+iIl216wlOzrA2B1HVhJi+gkjfI1lgG8O/2s5Q/mY/6q/3QIAAB+4k+AKLckAgAvBPBrAJ6G + qgiBFbSpZtCKpEYw25Vk0GkDUTCeXK7pPGxa/k2QVmOVJCGJoBMF6IYBehGhF4XoRnKuum5qWrRDSShR + SIhI1ybImsgHQ8dVL8lMCKZBT6w4pzQNQSUFKEQgimMfTI8vK1QRBHbPvDr+3Vjkgszeed23UpL2DiHP + 7Joz/0iWhp0Be5QIDBJGPxE5wNfTj/zNGKTgHgmRp3Cb+oU/klL7UbBM1R0MgbWBLNm9PpTmb+YN9D++ + AHADgN8C4e+QKniIY+BvXjMRfKfnOx47BgFZPuzlkBGCK7yJQH3jMj1MagPdtiSDXgfotFINIVDUpyno + vJZCPEFOFhL0rZQEOqn20AnH5NEJA3QiuawdEFqpkzIK5MxIKrBMlWDGUqzo+RdcTGKyEYAOftbzEMRY + g8iZWylOWXbmqeWsihGX4hh4m6Qns4arXLsaBo0Fl0A9TCR4B4nAIBboJ4xhvk5glMjtY6UGRNX7nAwx + StUoIaSEH4yklF8fSLV+lMh15np9PsC/DdLT/xeQZb5ku/4aTKNNN3hUJAEA2AngJwD8NGRl4bnJwMlj + cROFMqrQaUli6LTl7yiUQ8Ky7aZFDC5kUZBmSvgrHa2WkUArCNAKxiSSf0JCFARopcNao2BcjFIFpB7z + 1rUHlJxZWsZh9aXnhJdrNGQf8KLmSIwdlsW5HmIBxOn3DKSjRAG5EPn3TKLnc0GwNmWcRzHkqQKdWc6+ + GyfpzFhDCfRsVp44GW9HE1/MCoAbIb38fw3gyPi6GPjoq6Z7m1NvcvSg+iDmADwZMlXxRwFcDKA18XnU + Ap6UjgXNiKHdGv9thWNiUDUGIl0cbXyrO4cCMirY02W1W1W5AxS1CapIfjHOoE3qIyjnreu5DnrWYvE3 + F2otMvvf/4a2Ul0GJRFAiDHQRwkwTAE+VICeCLXU9LSueQRZf/NTkKn2N6ZEIPWAAFOT+ufucV/14TQ5 + KT2NCIBA7AHwVAA/BuDpAA4A6E4XYDzu6QQJ+iCQPoQolD6LKBwTQ6QRhJpQYCIKl458Lltd7QCqAJ++ + jrwe9PnzLIxDqtVc3czOUACefUbZ9xTgcboNi2JIYXpgz1ofcvKOLwD4ewBfRIyD4+B8mk/8sWs2/rFt + aPupD8MwsR9BmgiPhaw09HQAl0D6D4INuQ7WeqsK8CD1NYTZJ1QIIxz/DjOioLE2EVA5RGA6+bkCCjXZ + aBqVgKd5/TXPUA3eC5Fm5wg5U26c/U0UQKeSOxHj7fUUwI0BudoEpB1/Rwr6zwO4FYzDanEpADIq9lev + PD+6ylRb2U+QtTlIbeBxAJ6SEsPFkNmG4Tm9xiqiUAGfaQyh6ROO1wU09kvkpJEdl8p1oypB8EAis2n3 + sYyRzR0W6sAJMba3M1ALDcAZ0BNFoheyec45sG0tgUzU+S5kTc0vpn/vRqbe6/Tw8WvO6QU+8GNKXnJd + eWyA/L0AOfT4UZCRhMsBPBxSa5jHRmkJk5KF3tlKucfqSJdAyZM1aBW6hqHnOuvEpBIHuV47PLbVHQPa + eNdC/qxBQqvf878sVW2hAZi5nC1V9Zwf+CYgq/EeBnAngK9BevC/ATnHprmO1/XXPKAXfX4NKrvquqor + akNqA/sAPALApenfAwB2AdgMoHfe3VMd+Orc2sZyMw6ZRy6eaGb/bU3XbsvSmeQ+z+83tw7gNID7IaX5 + dyAn4rgzBfsJAEPr7te/6ry5mfP7sb/4T4CgcrhCCFmTYBtkmbILAFyU/t0DqS0sQmoMPUwj8vBQ+2Fo + oxTkZyHTbQ8DOAhZcPOu9O8hAMcgJbu9qgePgI9de97e6IOHd3NS+DMgTJ83W8eBEUCdFPibIDWH7QB2 + pJ+d6d+tAJbSbeYg05nbaDpI6qF2vrcYUjKvQdrgywBOQjrmjqRAP5J+jkJK8mUAZ8E8AFlmYqG8Xj3w + kVc/qB7Ig48AqtpLPpSP5HO48xCMNqRmMJeSwGJKFlshtYqt6e8t6bqFdNtZyNBlG1KrOD/8ET98TUBK + 6yFkSG01BfYZSMl9Iv0cS0F+PP19KgX2CoB1EIZghxramRlzHqnwDxGAT7vqL4G5m4DVx/o+owhAJwX9 + TEoCCylpZMSxWfls0sgiIwyVNFpIZ6xK//5wvQuJpiQFcZICWQVzBmgV1MuQtnf2yYC8nK5fgZTufQAD + EMWFfOe61vsOsHYZ8LGX/9C8hB+2TlffXnwd0A7T0FLWT71boIC8o4B/RiGQWeXvvPZ7Nt2ul35U8ugo + JBIpn1AhlOyTjS4PoNUrSYEnlOtVt8/6hjBsnwE2gVSps08G3oEG4vX0s6aAOQP2We13BuA1Zf/BmBxY + NBqWl5XZCgj46MbH1h9M7f8Hcsi/pxsyRxwAAAAASUVORK5CYII= + + + \ No newline at end of file diff --git a/LocalPSM+/Program.cs b/LocalPSM+/Program.cs new file mode 100644 index 0000000..0a70a46 --- /dev/null +++ b/LocalPSM+/Program.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace LocalPSM_ +{ + static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new PSMKeyGen()); + } + } +} diff --git a/LocalPSM+/Properties/AssemblyInfo.cs b/LocalPSM+/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..9679f2f --- /dev/null +++ b/LocalPSM+/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("LocalPSM+")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("LocalPSM+")] +[assembly: AssemblyCopyright("Copyright © 2018")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("95a59c38-8f1b-4689-8fec-976acf0a4829")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/LocalPSM+/Properties/Resources.Designer.cs b/LocalPSM+/Properties/Resources.Designer.cs new file mode 100644 index 0000000..411adc0 --- /dev/null +++ b/LocalPSM+/Properties/Resources.Designer.cs @@ -0,0 +1,322 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace LocalPSM_.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("LocalPSM_.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap bg { + get { + object obj = ResourceManager.GetObject("bg", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.IO.UnmanagedMemoryStream similar to System.IO.MemoryStream. + /// + internal static System.IO.UnmanagedMemoryStream BGM { + get { + return ResourceManager.GetStream("BGM", resourceCulture); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] cygcrypto_1_0_0 { + get { + object obj = ResourceManager.GetObject("cygcrypto_1_0_0", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] cygwin1 { + get { + object obj = ResourceManager.GetObject("cygwin1", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] cygz { + get { + object obj = ResourceManager.GetObject("cygz", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] kconsole_sign { + get { + object obj = ResourceManager.GetObject("kconsole_sign", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Drawing.Bitmap. + /// + internal static System.Drawing.Bitmap Logo { + get { + object obj = ResourceManager.GetObject("Logo", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] psm_activever { + get { + object obj = ResourceManager.GetObject("psm_activever", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] psm_Code { + get { + object obj = ResourceManager.GetObject("psm_Code", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] psm_kconsole_dat { + get { + object obj = ResourceManager.GetObject("psm_kconsole_dat", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] psm_protected_kconsole_cache { + get { + object obj = ResourceManager.GetObject("psm_protected_kconsole_cache", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] psm_target_kdbg_list { + get { + object obj = ResourceManager.GetObject("psm_target_kdbg_list", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] psm_vseed { + get { + object obj = ResourceManager.GetObject("psm_vseed", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] psmdev { + get { + object obj = ResourceManager.GetObject("psmdev", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] psmdev_private { + get { + object obj = ResourceManager.GetObject("psmdev_private", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] psmdev_seed { + get { + object obj = ResourceManager.GetObject("psmdev_seed", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] reverse { + get { + object obj = ResourceManager.GetObject("reverse", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] revoke_sign { + get { + object obj = ResourceManager.GetObject("revoke_sign", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] unity_Code { + get { + object obj = ResourceManager.GetObject("unity_Code", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] unity_kconsole_dat { + get { + object obj = ResourceManager.GetObject("unity_kconsole_dat", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] unity_protected_kconsole_cache { + get { + object obj = ResourceManager.GetObject("unity_protected_kconsole_cache", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] unity_target_kdbg_list { + get { + object obj = ResourceManager.GetObject("unity_target_kdbg_list", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] unity_vseed { + get { + object obj = ResourceManager.GetObject("unity_vseed", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] UnityDev { + get { + object obj = ResourceManager.GetObject("UnityDev", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] UnityDev_private { + get { + object obj = ResourceManager.GetObject("UnityDev_private", resourceCulture); + return ((byte[])(obj)); + } + } + + /// + /// Looks up a localized resource of type System.Byte[]. + /// + internal static byte[] UnityDev_seed { + get { + object obj = ResourceManager.GetObject("UnityDev_seed", resourceCulture); + return ((byte[])(obj)); + } + } + } +} diff --git a/LocalPSM+/Properties/Resources.resx b/LocalPSM+/Properties/Resources.resx new file mode 100644 index 0000000..aa5745e --- /dev/null +++ b/LocalPSM+/Properties/Resources.resx @@ -0,0 +1,199 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\Resources\bg.jpg;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\BGM.wav;System.IO.MemoryStream, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\cygcrypto-1.0.0.dll;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\cygwin1.dll;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\cygz.dll;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\kconsole_sign.exe;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\Logo.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\psmdev.krng;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\psmdev-private.p12;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\psmdev-seed.seed;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\psm_activever.dat;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\psm_Code;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\psm_kconsole_dat.dat;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\psm_protected_kconsole_cache.dat;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\psm_target_kdbg_list.dat;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\psm_vseed.dat;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\reverse.exe;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\revoke_sign.exe;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\UnityDev.krng;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\UnityDev-private.p12;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\UnityDev-seed.seed;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\unity_Code;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\unity_kconsole_dat.dat;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\unity_protected_kconsole_cache.dat;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\unity_target_kdbg_list.dat;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + ..\Resources\unity_vseed.dat;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/LocalPSM+/Properties/Settings.Designer.cs b/LocalPSM+/Properties/Settings.Designer.cs new file mode 100644 index 0000000..1b970c3 --- /dev/null +++ b/LocalPSM+/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace LocalPSM_.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/LocalPSM+/Properties/Settings.settings b/LocalPSM+/Properties/Settings.settings new file mode 100644 index 0000000..abf36c5 --- /dev/null +++ b/LocalPSM+/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/LocalPSM+/Resources/BGM.wav b/LocalPSM+/Resources/BGM.wav new file mode 100644 index 0000000..7965f79 Binary files /dev/null and b/LocalPSM+/Resources/BGM.wav differ diff --git a/LocalPSM+/Resources/Logo.png b/LocalPSM+/Resources/Logo.png new file mode 100644 index 0000000..d878456 Binary files /dev/null and b/LocalPSM+/Resources/Logo.png differ diff --git a/LocalPSM+/Resources/UnityDev-private.p12 b/LocalPSM+/Resources/UnityDev-private.p12 new file mode 100644 index 0000000..8cc609e Binary files /dev/null and b/LocalPSM+/Resources/UnityDev-private.p12 differ diff --git a/LocalPSM+/Resources/UnityDev-seed.seed b/LocalPSM+/Resources/UnityDev-seed.seed new file mode 100644 index 0000000..0b6a4ed Binary files /dev/null and b/LocalPSM+/Resources/UnityDev-seed.seed differ diff --git a/LocalPSM+/Resources/UnityDev.krng b/LocalPSM+/Resources/UnityDev.krng new file mode 100644 index 0000000..66bf58f Binary files /dev/null and b/LocalPSM+/Resources/UnityDev.krng differ diff --git a/LocalPSM+/Resources/bg.jpg b/LocalPSM+/Resources/bg.jpg new file mode 100644 index 0000000..66ea3a2 Binary files /dev/null and b/LocalPSM+/Resources/bg.jpg differ diff --git a/LocalPSM+/Resources/cygcrypto-1.0.0.dll b/LocalPSM+/Resources/cygcrypto-1.0.0.dll new file mode 100644 index 0000000..a24da9b Binary files /dev/null and b/LocalPSM+/Resources/cygcrypto-1.0.0.dll differ diff --git a/LocalPSM+/Resources/cygwin1.dll b/LocalPSM+/Resources/cygwin1.dll new file mode 100644 index 0000000..883342d Binary files /dev/null and b/LocalPSM+/Resources/cygwin1.dll differ diff --git a/LocalPSM+/Resources/cygz.dll b/LocalPSM+/Resources/cygz.dll new file mode 100644 index 0000000..3b5f877 Binary files /dev/null and b/LocalPSM+/Resources/cygz.dll differ diff --git a/LocalPSM+/Resources/kconsole_sign.exe b/LocalPSM+/Resources/kconsole_sign.exe new file mode 100644 index 0000000..8699089 Binary files /dev/null and b/LocalPSM+/Resources/kconsole_sign.exe differ diff --git a/LocalPSM+/Resources/psm_Code b/LocalPSM+/Resources/psm_Code new file mode 100644 index 0000000..46e1ef5 --- /dev/null +++ b/LocalPSM+/Resources/psm_Code @@ -0,0 +1 @@ +RX*fow \ No newline at end of file diff --git a/LocalPSM+/Resources/psm_activever.dat b/LocalPSM+/Resources/psm_activever.dat new file mode 100644 index 0000000..0f6abf4 --- /dev/null +++ b/LocalPSM+/Resources/psm_activever.dat @@ -0,0 +1 @@ +1.21 \ No newline at end of file diff --git a/LocalPSM+/Resources/psm_kconsole_dat.dat b/LocalPSM+/Resources/psm_kconsole_dat.dat new file mode 100644 index 0000000..1c04f88 Binary files /dev/null and b/LocalPSM+/Resources/psm_kconsole_dat.dat differ diff --git a/LocalPSM+/Resources/psm_protected_kconsole_cache.dat b/LocalPSM+/Resources/psm_protected_kconsole_cache.dat new file mode 100644 index 0000000..1c04f88 Binary files /dev/null and b/LocalPSM+/Resources/psm_protected_kconsole_cache.dat differ diff --git a/LocalPSM+/Resources/psm_target_kdbg_list.dat b/LocalPSM+/Resources/psm_target_kdbg_list.dat new file mode 100644 index 0000000..39eb548 Binary files /dev/null and b/LocalPSM+/Resources/psm_target_kdbg_list.dat differ diff --git a/LocalPSM+/Resources/psm_vseed.dat b/LocalPSM+/Resources/psm_vseed.dat new file mode 100644 index 0000000..ba1efb4 --- /dev/null +++ b/LocalPSM+/Resources/psm_vseed.dat @@ -0,0 +1 @@ +1ΨkX\&")#3`Y!C nV];Wj;>`V"d - \ No newline at end of file diff --git a/LocalPSM+/Resources/psmdev-private.p12 b/LocalPSM+/Resources/psmdev-private.p12 new file mode 100644 index 0000000..8cc609e Binary files /dev/null and b/LocalPSM+/Resources/psmdev-private.p12 differ diff --git a/LocalPSM+/Resources/psmdev-seed.seed b/LocalPSM+/Resources/psmdev-seed.seed new file mode 100644 index 0000000..658d6b8 Binary files /dev/null and b/LocalPSM+/Resources/psmdev-seed.seed differ diff --git a/LocalPSM+/Resources/psmdev.krng b/LocalPSM+/Resources/psmdev.krng new file mode 100644 index 0000000..a21b1d8 Binary files /dev/null and b/LocalPSM+/Resources/psmdev.krng differ diff --git a/LocalPSM+/Resources/reverse.exe b/LocalPSM+/Resources/reverse.exe new file mode 100644 index 0000000..6e7de32 Binary files /dev/null and b/LocalPSM+/Resources/reverse.exe differ diff --git a/LocalPSM+/Resources/revoke_sign.exe b/LocalPSM+/Resources/revoke_sign.exe new file mode 100644 index 0000000..94c4799 Binary files /dev/null and b/LocalPSM+/Resources/revoke_sign.exe differ diff --git a/LocalPSM+/Resources/unity_Code b/LocalPSM+/Resources/unity_Code new file mode 100644 index 0000000..46e1ef5 --- /dev/null +++ b/LocalPSM+/Resources/unity_Code @@ -0,0 +1 @@ +RX*fow \ No newline at end of file diff --git a/LocalPSM+/Resources/unity_kconsole_dat.dat b/LocalPSM+/Resources/unity_kconsole_dat.dat new file mode 100644 index 0000000..86646a1 Binary files /dev/null and b/LocalPSM+/Resources/unity_kconsole_dat.dat differ diff --git a/LocalPSM+/Resources/unity_protected_kconsole_cache.dat b/LocalPSM+/Resources/unity_protected_kconsole_cache.dat new file mode 100644 index 0000000..86646a1 Binary files /dev/null and b/LocalPSM+/Resources/unity_protected_kconsole_cache.dat differ diff --git a/LocalPSM+/Resources/unity_target_kdbg_list.dat b/LocalPSM+/Resources/unity_target_kdbg_list.dat new file mode 100644 index 0000000..5655d53 Binary files /dev/null and b/LocalPSM+/Resources/unity_target_kdbg_list.dat differ diff --git a/LocalPSM+/Resources/unity_vseed.dat b/LocalPSM+/Resources/unity_vseed.dat new file mode 100644 index 0000000..3548ffd --- /dev/null +++ b/LocalPSM+/Resources/unity_vseed.dat @@ -0,0 +1 @@ +1ΨkX\&᥸BǢbUxPIm#ǂQ6/S \ No newline at end of file