diff --git a/.gitignore b/.gitignore index ed4e2625..6b7c52d7 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,12 @@ coder-base/device.json .DS_Store Thumbs.db + +# Windows Installer +[Dd]ebug/ +[Rr]elease/ +x64/ +build/ +[Oo]bj/ +!*.exe +!*.dll \ No newline at end of file diff --git a/installer/windows/CoderSetup/CoderSetup.sln b/installer/windows/CoderSetup/CoderSetup.sln new file mode 100644 index 00000000..85efd823 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CoderSetup", "CoderSetup\CoderSetup.csproj", "{395F51B5-3A4D-46F5-A9B1-985B976B48AA}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {395F51B5-3A4D-46F5-A9B1-985B976B48AA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {395F51B5-3A4D-46F5-A9B1-985B976B48AA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {395F51B5-3A4D-46F5-A9B1-985B976B48AA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {395F51B5-3A4D-46F5-A9B1-985B976B48AA}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/installer/windows/CoderSetup/CoderSetup/CoderSetup.csproj b/installer/windows/CoderSetup/CoderSetup/CoderSetup.csproj new file mode 100644 index 00000000..50625f44 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/CoderSetup.csproj @@ -0,0 +1,98 @@ + + + + + Debug + AnyCPU + {395F51B5-3A4D-46F5-A9B1-985B976B48AA} + WinExe + Properties + CoderSetup + CoderSetup + v4.0 + 512 + + + x86 + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + x86 + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + codersd.ico + + + app.manifest + + + + + + + + + + + + + + + + Form + + + FormMain.cs + + + + + + FormMain.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/installer/windows/CoderSetup/CoderSetup/CoderSetup.csproj.DotSettings b/installer/windows/CoderSetup/CoderSetup/CoderSetup.csproj.DotSettings new file mode 100644 index 00000000..ade8d1a4 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/CoderSetup.csproj.DotSettings @@ -0,0 +1,2 @@ + + False \ No newline at end of file diff --git a/installer/windows/CoderSetup/CoderSetup/FormMain.Designer.cs b/installer/windows/CoderSetup/CoderSetup/FormMain.Designer.cs new file mode 100644 index 00000000..43c8ced4 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/FormMain.Designer.cs @@ -0,0 +1,165 @@ +namespace CoderSetup +{ + partial class FormMain + { + /// + /// Variable del diseñador requerida. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Limpiar los recursos que se estén utilizando. + /// + /// true si los recursos administrados se deben eliminar; false en caso contrario. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Código generado por el Diseñador de Windows Forms + + /// + /// Método necesario para admitir el Diseñador. No se puede modificar + /// el contenido del método con el editor de código. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(FormMain)); + this.labelStatus = new System.Windows.Forms.Label(); + this.pictureBoxCoderLogo = new System.Windows.Forms.PictureBox(); + this.tableLayoutPanelMain = new System.Windows.Forms.TableLayoutPanel(); + this.flowLayoutPanelButtons = new System.Windows.Forms.FlowLayoutPanel(); + this.progressBarInstallation = new System.Windows.Forms.ProgressBar(); + this.buttonStart = new System.Windows.Forms.Button(); + this.backgroundWorkerProcess = new System.ComponentModel.BackgroundWorker(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBoxCoderLogo)).BeginInit(); + this.tableLayoutPanelMain.SuspendLayout(); + this.flowLayoutPanelButtons.SuspendLayout(); + this.SuspendLayout(); + // + // labelStatus + // + this.labelStatus.Anchor = System.Windows.Forms.AnchorStyles.None; + this.labelStatus.AutoSize = true; + this.labelStatus.Font = new System.Drawing.Font("Segoe UI", 15.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.labelStatus.Location = new System.Drawing.Point(330, 212); + this.labelStatus.Name = "labelStatus"; + this.labelStatus.Size = new System.Drawing.Size(114, 30); + this.labelStatus.TabIndex = 1; + this.labelStatus.Text = "labelStatus"; + this.labelStatus.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + // + // pictureBoxCoderLogo + // + this.pictureBoxCoderLogo.Anchor = System.Windows.Forms.AnchorStyles.Bottom; + this.pictureBoxCoderLogo.Image = ((System.Drawing.Image)(resources.GetObject("pictureBoxCoderLogo.Image"))); + this.pictureBoxCoderLogo.Location = new System.Drawing.Point(167, 64); + this.pictureBoxCoderLogo.Name = "pictureBoxCoderLogo"; + this.pictureBoxCoderLogo.Size = new System.Drawing.Size(440, 125); + this.pictureBoxCoderLogo.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; + this.pictureBoxCoderLogo.TabIndex = 0; + this.pictureBoxCoderLogo.TabStop = false; + // + // tableLayoutPanelMain + // + this.tableLayoutPanelMain.ColumnCount = 1; + this.tableLayoutPanelMain.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F)); + this.tableLayoutPanelMain.Controls.Add(this.pictureBoxCoderLogo, 0, 0); + this.tableLayoutPanelMain.Controls.Add(this.labelStatus, 0, 1); + this.tableLayoutPanelMain.Controls.Add(this.flowLayoutPanelButtons, 0, 2); + this.tableLayoutPanelMain.Dock = System.Windows.Forms.DockStyle.Fill; + this.tableLayoutPanelMain.Location = new System.Drawing.Point(0, 0); + this.tableLayoutPanelMain.Name = "tableLayoutPanelMain"; + this.tableLayoutPanelMain.RowCount = 3; + this.tableLayoutPanelMain.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 60F)); + this.tableLayoutPanelMain.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 70F)); + this.tableLayoutPanelMain.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 40F)); + this.tableLayoutPanelMain.Size = new System.Drawing.Size(774, 391); + this.tableLayoutPanelMain.TabIndex = 3; + // + // flowLayoutPanelButtons + // + this.flowLayoutPanelButtons.Anchor = System.Windows.Forms.AnchorStyles.Top; + this.flowLayoutPanelButtons.AutoSize = true; + this.flowLayoutPanelButtons.Controls.Add(this.progressBarInstallation); + this.flowLayoutPanelButtons.Controls.Add(this.buttonStart); + this.flowLayoutPanelButtons.FlowDirection = System.Windows.Forms.FlowDirection.TopDown; + this.flowLayoutPanelButtons.Location = new System.Drawing.Point(84, 265); + this.flowLayoutPanelButtons.Name = "flowLayoutPanelButtons"; + this.flowLayoutPanelButtons.Size = new System.Drawing.Size(606, 71); + this.flowLayoutPanelButtons.TabIndex = 2; + // + // progressBarInstallation + // + this.progressBarInstallation.ForeColor = System.Drawing.Color.White; + this.progressBarInstallation.Location = new System.Drawing.Point(3, 3); + this.progressBarInstallation.Name = "progressBarInstallation"; + this.progressBarInstallation.Size = new System.Drawing.Size(600, 6); + this.progressBarInstallation.Style = System.Windows.Forms.ProgressBarStyle.Continuous; + this.progressBarInstallation.TabIndex = 2; + this.progressBarInstallation.Visible = false; + // + // buttonStart + // + this.buttonStart.Anchor = System.Windows.Forms.AnchorStyles.Top; + this.buttonStart.BackColor = System.Drawing.Color.White; + this.buttonStart.FlatStyle = System.Windows.Forms.FlatStyle.Flat; + this.buttonStart.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(59)))), ((int)(((byte)(215)))), ((int)(((byte)(234))))); + this.buttonStart.Location = new System.Drawing.Point(240, 17); + this.buttonStart.Margin = new System.Windows.Forms.Padding(4, 5, 4, 5); + this.buttonStart.Name = "buttonStart"; + this.buttonStart.Size = new System.Drawing.Size(125, 49); + this.buttonStart.TabIndex = 1; + this.buttonStart.UseVisualStyleBackColor = false; + this.buttonStart.Visible = false; + this.buttonStart.Click += new System.EventHandler(this.buttonStart_Click); + // + // backgroundWorkerProcess + // + this.backgroundWorkerProcess.WorkerReportsProgress = true; + this.backgroundWorkerProcess.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorkerProcess_DoWork); + this.backgroundWorkerProcess.ProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(this.backgroundWorkerProcess_ProgressChanged); + this.backgroundWorkerProcess.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorkerProcess_RunWorkerCompleted); + // + // FormMain + // + this.AutoScaleDimensions = new System.Drawing.SizeF(9F, 21F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(59)))), ((int)(((byte)(215)))), ((int)(((byte)(234))))); + this.ClientSize = new System.Drawing.Size(774, 391); + this.Controls.Add(this.tableLayoutPanelMain); + this.Font = new System.Drawing.Font("Segoe UI", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.ForeColor = System.Drawing.Color.White; + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.Margin = new System.Windows.Forms.Padding(4, 5, 4, 5); + this.MaximizeBox = false; + this.Name = "FormMain"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Coder for Pi"; + this.TopMost = true; + this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.FormMain_FormClosed); + ((System.ComponentModel.ISupportInitialize)(this.pictureBoxCoderLogo)).EndInit(); + this.tableLayoutPanelMain.ResumeLayout(false); + this.tableLayoutPanelMain.PerformLayout(); + this.flowLayoutPanelButtons.ResumeLayout(false); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Label labelStatus; + private System.Windows.Forms.PictureBox pictureBoxCoderLogo; + private System.Windows.Forms.TableLayoutPanel tableLayoutPanelMain; + private System.ComponentModel.BackgroundWorker backgroundWorkerProcess; + private System.Windows.Forms.FlowLayoutPanel flowLayoutPanelButtons; + private System.Windows.Forms.ProgressBar progressBarInstallation; + private System.Windows.Forms.Button buttonStart; + } +} + diff --git a/installer/windows/CoderSetup/CoderSetup/FormMain.cs b/installer/windows/CoderSetup/CoderSetup/FormMain.cs new file mode 100644 index 00000000..b93599cb --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/FormMain.cs @@ -0,0 +1,243 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Threading; +using System.Windows.Forms; +using CoderSetup.Properties; +using USB_Image_Tool_Helper; + +namespace CoderSetup +{ + /// + /// Small Wizard for Coder for Pi, uses Alexander Beug Usbit32 library + /// Erwin Ried + /// + /// + /// + public partial class FormMain : Form + { + private int _currentStep = -1; + private readonly String[] _messages = + { + "Remove any SD Cards from your computer and click Start.", + "Insert an SD Card you wish to format with Coder.", + "Click Install to format this SD Card and install Coder.", + "Coder has been successfully installed. You may now remove your SD Card." + Environment.NewLine + + "Follow instructions at goo.gl/coder to get started." + }; + + private string _imagePath; + private bool _error, _finished, _initialized=false; + private List _devices; + private const string LibraryName = "usbit32.dll"; + + public FormMain() + { + InitializeComponent(); + backgroundWorkerProcess.RunWorkerAsync(); + } + + private void buttonStart_Click(object sender, EventArgs e) + { + if (_finished) + Application.Exit(); + else + { + buttonStart.Visible = false; + backgroundWorkerProcess.RunWorkerAsync(); + } + } + + private void backgroundWorkerProcess_DoWork(object sender, DoWorkEventArgs e) + { + if (_currentStep > -1 && !_initialized && !InitializeCmd()) + { + backgroundWorkerProcess.ReportProgress(-1, "Error"); + _error = true; + } + + var timer = Stopwatch.StartNew(); // Just to allow the user to read some messages if his PC is too fast + if (_error) return; + + switch (_currentStep) + { + case -1: + backgroundWorkerProcess.ReportProgress(-2, new[] {"START", _messages[++_currentStep]}); + break; + + case 0: + backgroundWorkerProcess.ReportProgress(-1, "Just a moment..."); + _devices = Usbit32.GetDevices(); // Detecting devices + + do{} while (timer.Elapsed.TotalSeconds < 2); + backgroundWorkerProcess.ReportProgress(-2, new[] {"NEXT", _messages[++_currentStep]}); + break; + + case 1: + backgroundWorkerProcess.ReportProgress(-1, "Looking for your SD Card..."); + var t = Usbit32.GetDevices(); + + do{} while (timer.Elapsed.TotalSeconds < 2); + if (t.Count() == _devices.Count() + 1) + { + // Found one new SD + backgroundWorkerProcess.ReportProgress(-2, new[] {"INSTALL", _messages[++_currentStep]}); + + foreach (var d in t.Where(d => !_devices.Contains(d))) + { + _devices = new List(new[] {d}); + break; // There is only one different... + } + } + else + StartOver("Your card wasn't correctly detected. Let's try again."); + break; + + case 2: + // Install image + _imagePath = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName),"raspi.img")); + + if (!File.Exists(_imagePath)) + { + backgroundWorkerProcess.ReportProgress(-2,new[]{"CLOSE","raspi.img was not found in same directory as installer app"}); + _finished = true; + } + else + { + backgroundWorkerProcess.ReportProgress(-1, "Installing Coder on your SD Card."); + backgroundWorkerProcess.ReportProgress(0); + + try + { + var restore = new Thread(RestoreImage); + var progress = 1; + restore.Start(); + Thread.Sleep(2000); + + do + { + Thread.Sleep(100); + var tmp = (int) Usbit32.GetProgress(_devices[0]); + + if (tmp > progress && tmp <= progressBarInstallation.Maximum) + progress = tmp; + + backgroundWorkerProcess.ReportProgress(progress); + + } while (Usbit32.GetRunning(_devices[0])); + restore.Abort(); + } + catch + { + _error = true; + } + + if (_error) + { + _error = false; + StartOver("There was an error while writing to your SD Card."); + } + else + { + backgroundWorkerProcess.ReportProgress(progressBarInstallation.Maximum); + backgroundWorkerProcess.ReportProgress(-2, new[] {"OK", "Install complete!"}); + Thread.Sleep(2000); + _finished = true; + backgroundWorkerProcess.ReportProgress(-1, _messages[++_currentStep]); + } + } + break; + } + } + + private void RestoreImage() + { + var retry = Stopwatch.StartNew(); + do + { + uint error = 0; + _error = true; + Usbit32.RestoreVolume(_devices[0], _imagePath, 0, true, true, false, ref error); + + if (error == 0) + { + _error = false; + return; // No errors + } + + } while (retry.Elapsed.TotalSeconds<5); // Try until Windows closes the opened handles to the device (if possible) + } + + private void StartOver(string msg) + { + _currentStep = -1; + backgroundWorkerProcess.ReportProgress(-2, new[] { "START OVER", msg}); + } + + private void backgroundWorkerProcess_ProgressChanged(object sender, ProgressChangedEventArgs e) + { + switch (e.ProgressPercentage) + { + case -2: // Update button too + var t = (String[])e.UserState; + buttonStart.Text = t[0]; + labelStatus.Text = t[1]; + progressBarInstallation.Visible = false; + break; + + case -1: + labelStatus.Text = (String)e.UserState; + progressBarInstallation.Visible = false; + break; + + default: + progressBarInstallation.Visible = true; + progressBarInstallation.Value = e.ProgressPercentage; + break; + } + } + + private bool InitializeCmd() + { + try + { + var t = Path.GetTempFileName(); + File.Delete(t); + Directory.CreateDirectory(t); + Environment.CurrentDirectory = t; + + File.WriteAllBytes(LibraryName, Resources.usbit32); + Usbit32.LoadLibrary(LibraryName); + _initialized = true; + return true; + } + catch + { + } + return false; + } + + private void backgroundWorkerProcess_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) + { + if (!_error) + buttonStart.Visible = true; + } + + private void FormMain_FormClosed(object sender, FormClosedEventArgs e) + { + if (_initialized && _devices != null && _devices.Count > 0) + try + { + uint error = 0; + Usbit32.CancelOperation(_devices[0], ref error); + } + catch + { + } + } + } +} diff --git a/installer/windows/CoderSetup/CoderSetup/FormMain.resx b/installer/windows/CoderSetup/CoderSetup/FormMain.resx new file mode 100644 index 00000000..d133b160 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/FormMain.resx @@ -0,0 +1,825 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + R0lGODlhuAF9AIYAAO/6/cfx95vn87Pr9UWzxtz1+iXX6nHf74Di8V7e7lCVpqjp9MBLXyvX67MxSy3Z + 7LPs9I/l8tPz+STZ7b7u9knb7Pj+/kC+z8rO1eX4++CttFkaNFhjdSzX7SPY6u/T1krb7TLP4rTs9i/Z + 7bIANznH2oHj8VoyR0ja7JoNNSzX6lpVZ8tyf53n9G0XNEygslpEV1hxg0qqu3Hg8F/e71V9jn/j8CbX + 7b3t9tKDjfr09cZgb5zn8/Pe4enIy9ygqFhwglOKmyjY6irZ7CbX6ybX6ifY7CvZ6ynY6inY7dz2+iTZ + 6ybZ6ynZ6ybX7CzX6yzX7CnZ7Sba7CbY6ybZ7Cza7SzZ7S7Y7IDi8LTs9SrZ7SvX6i7Y6yTZ7Pf9/tz2 + +yzY7CbY7CPZ67Ts9CzY6yTZ6uX3+9aSmrXt9SvZ6iHY6rPt9SLZ7LTt9SbZ6vfq61Z+j0jc7dufqGiu + v6WirV6WpnRmdx/Z6+W7wD28ziba6ynZ7CnY7CnY6yjY6////yH/C05FVFNDQVBFMi4wAwEBAAAh+QQA + AAAAACwAAAAAuAF9AAAI/wD97OHjh08fI360HPETxc9CPk38dCn4xE9BJn76GNRokaDFjHycHOFDsE/G + j3249FnZJ4mfIgYRmjRZ5EgRJASrZBRipM9AIXuKmNyz56NBJEJ8ruQzUmCVpRb7OClY0KQfIh37NJip + kWQfKQX5GOFTBKRBIXyeJM2YRChMPw1cWk1CdAjVlVpKwiS68mTfln2mnHRC0K4fJlsF941pNWOTJSZx + ZsS6h+XAqCsxGqlieGFRj3umWH2isY9hyBsrF61KsipXw0NaO2lpsbJPKib5EOnrJ2LWii0JEizapUFG + JDiRFBRStedfPwgzQjEZUenJtQahZ+wjZOFHuH6oKP+vTrWsAehe9xyp3HtPkpQRt5okgvAJFT9Vjljl + qrFiE7smvTfETEh0wYRYBumGlnN96MdcQbtBIQQUFsnEhH77WeWBZwShZdJWCcGFhElDGEFaEyshhFUT + 2UUlmkArDaFaH/9ltAeFS/gB1HbDsVeUSSqeZJYVY2WUo0e6bWRQZVAYRMSPIPVxhY4erYTEeh11VOVB + BfHVBBJReEQEHx6MWVJgRAlEUhIHbjdgi5dZJdxqJ7G3khADSrTRdn01sFUUTzABmRZWlUVjEUJ4SBBW + uwkVmx85jtgAQVu915ddS6Rp1R4ANrBHjn5YwdWkq83EB1oZ3QRSEmCV2psfIx7/ZVEVSzrUlXBhOBeV + BwiV9GBfI0Z1lRYOZWrRiDgtcQUSUEyZ0aQebmEEUCuF6ZofQ+xmFB9W1NbEfS+l6gRPLCq3nlXZCtFA + E0+k9lhsP/61oUMSUbvHpKb1IaFBRySxRRNG7MGTbq7N9FJ8ezBRYmVfdmvQlB7o2AG2YLLURxWVGSRF + H2VBURZJBAW8BxVEeFCEbS0thOoeWrQ720pJeGXXr0Q1ccRCXOwG5GECPTnTE1wgETMfVwwhhMklTbad + FJVFAa5+A64Wsl3TTgtyWDQRq+OUfXRx2XbY+vHEpEwxwcTFH81mURFlCBEGdH2E0QejRQxxYbtJNaBc + H0j0/2pStxoNMRW6fDBbBGoDPiHU2Kx9lFRpqPrBqtTvMRer5H8btASeAxlEhW7RfeRBEkJXuDGN3Gm0 + GhEy2u2XeJAWVPdJCjdRFBen5tZBEjqFxyllxv1V2kknkyWXbxzxUVRswvl0Kp8nJZhxZTo9KmdUymOm + JkSeZiWQjTZutUSRSIJ0xRJTJBj29xl559MSwjUg1EFBpUlFEfjnZtJCypE0RAMlsggUXCKkv3jFNEyZ + zUA0gpG5RakBXKPLFayQFDF8hzmNYU9PsAUlWIVlIUZoQhKSYgSXIGl2BGkSS/wWuApZxDshA0lGECIF + skhtJkYQyt1Wk7HtLNBGJMJKWP9a85KMraQBBmhCAyrikaoITCM6yQ75CmIpJ6JnJEURz2csAj9h7Qki + S+HD2XREFZRoJ2DJww17+PAiIxmmQXvyAxj4MKCufUcr+/ueA213BYJEoV+fodNBFuMHMbzMj2Vsi0bE + EK/6SG43fIiCRjxQuNpsZG5aIYgWosMlGVHBCRjBjE+yJBywdUQofDBAH7ZAFoGMiAgYtBFZcjMV0thI + JnxBVEG6FbnGJGGDUxEY7dCmEaxkL0fGUY6aZmKbKWFFI03xSZqE8izDUCUJQuRClhZop6RZpCFENA0Q + zeiYPlDhXiQhg0a28CMiEGEJcvEelTrSR660pisnEaKc+Kb/mixRhQlR6AmqABQ9kDgHCUWpCBGOIEmm + fKckwTKOEcYEmYwMaATM+RRV9oCTopQFRobiyPA4RijMPFEIJ5NlVIrCl415yiRrMRJK9tSHJzwFK0nB + DRuHQpIDHRGBe9jNHpjIJz406S4l0Ym2vFPCcMnHLkR5ppZq4wd2DqUPYPhemLAyhC0Q04Nn6tJVPrUU + Zh0rKk94DEtqox5u2pMJA/kYd5RnMa9ox1Qc28kowxoq9XQpN6mqDF18NbcfOesI3ZqUjQwjlJqNpCQH + nEwXN0qwMN3JMETpSWF6tkK1GkwgN2sMi1wjHOXxCyoZqchsFjqiypANUirxAxSulD0f//pvJQJbY2tc + gsEGXeWAK6mCEYwwEd1IxjWBfElg8qhJc1qMmdm5wmJqSpI9NAFFH+mMdPUoEGoaITZQ0Y8yaSRD53mG + K9YVghChQ5SSLAFAJpkCewoyoJIOIUdWwEkSeEUmHT1xgQ+aAnNsyZcoCXMon8PtcEylG+cJs3/PLFyC + wglfI4CoNKN0MJY4qqOvTOFk03GPwbagn0vGcS9EM+0PyTKdElOlKTA5U8IsQiq0zi06RMReK1vTxFgp + x7r7swqFlkSaxtS0UPhkkRAEtdbKfFQFFQrNm66QlCSQhg8XvkppeExZh6jEYPhME1Yq4ocH3AU5u2LI + Zj21LrFsL/+ATQyLQCaSwQMFBY0zvMy4+tJH3SrUMXo8px7BW0CONMQvS/IJUJBwoEpihnSrIggVxjhd + piyEIyeZzm9jx7HdjKSiIs2T8p6opcoYYTZvcQhuKBQe9gmkVI/bbFFMBF8m9GQPXTCCs7DnEB7Oswo7 + Oo7kCDbD7cTaOER4CqH+8pMoVOZ/QS1Iv2Toqer+CHndQ5JuPGCb0PgkdFwmSReLKSSQQXUp0TaLVgqS + o6AaLQ3ZKYox70gf/dAFQExQZhLquIfvqg8ke7gCEZCQVYws8AnfDWNpuOYHsCSaO8fVH2Tr5JcBGcEm + NEZJA56yGIfzi6VESAIVYkaXUOIWRjH/hYx6nndpkDwKfg+KJFWyA1mYcmfVLApQH6LgIXNCmQhnC4yM + j/AUXvvBCZURDKRognRMNccgmC0Ki7w6tIGMyVD4uR8UBnLpRCXFoUNg2pg88KiGq6COfqBkZcRTvbCC + cN1FQNERkABLBEmkKmMCUFIMA4a2LARjVmIJtbAFhWylbAgt91iP4Ns+4zRkgUXwABJYZMPOpS47GjEC + WD5yE7HsB3BvFIlFLLUESoKqbnQkykCgoMAYdYs+aaCNXfhAherwgVZd0RqgNSJwffGMJoXPS4yQ7ocp + TUenchaCQtaXFSP2gZJN2I2M6PjMigAOgHyIGYXOthU6dgkmE6Aa/x9ylCdLiQG3X/llv5jjHbMgBCM4 + 6UO3YLSYcO51BguggBLM8If++///SqAEWSAAB/A4P3RVZaQtKvRqgnVyPnQYgLVArMRTL6EbtrE2WLAA + AaAEAPB/HugFSiABAxABCWBaXZBh4RIVDyIjOlYaWwFL2wFJYvEZLZABHniDOJiDNwiCEtAGJOgTH4VV + D0FXR1BtmIEWyEESxrFS+GRJGsED/KeDUjiFVEiFElAB0JEU7aU6Q+EhBQECAWABVTiGHxiAAyAAM0An + accdwbRCKJMXsRMz+pIdxkEXKqgbdkFm4vQ1vIIZdFVeTeQ8EeE+LMFKhoIWq1EBPCABXkCGH/8oATwQ + ByvhMWLlQjkyFCcxKBv0PQtmULWBVdIDK+7GBwmwAErgiB4IABQQASYhBWjUB3ClL6ZRHUCoHTnWYSz1 + NX5wiqjYi/+nihGQHSqEIqCWUlxxNhNGTSNFVSshAb74jL5oBhgEOmvzHsbkeShgg9Doi0qwADPQBbVl + FcoSPa9BV5WhLezFJbWBECnlZhbBBBwHUwkyFP0kGtyxdDXXGJ6XEcuGBc64jR4oAax4craRJ3/VJWPh + AXkFKYzEFQWlJDeGGQKgjQDZf15AASWoFXsgSSeXY6vREx/zHSBxMiaBBhX5jBeZAGuEFg2RG0IxLQVx + cRwDJfKhbWczACf/mZM6yANRgi244YWxhpM6iYoAsAAg4FC0MmtEsAXYM1RXAzYEMRUQgTJwgWVFwARC + sDkrhn5rYUsGcTiytR9QBTLsEVJaEAEUOZR/AAACkD0kQQUTqDOpViUZcYI8AlgO5BNAByujlAWNqJb9 + FwAqCSGvQhNnck8aMQXWBBIct4uAiYoBQAMcaU5XsRsywYwzAyMNIAXuxCl8UgCPqZYSYElnkmBfYwVf + EJqOKJj0hxbUxCdPYC7CgQTzsxS29ILDUxNFIhPV1WsclTytSGNTwCYHYllMhGkHwIuquZZY0G9hEDWn + s2OYRhK7MSKWdUdwlC0EgQRDEAEduJx/QAEg/4A1d7QHoFdHo1ZKYsQ3GpGa4FmF4omYl8QbZGROOgNL + HIEh6qGc7wmNBYAE8NSKS2gQznYSoNmfVBgAFcBODHEYeCYlvfNLn4FlYYN+ZhRzE9Y88sZdYTFa8hMF + p0MEZWEczJMEEICg/SeeREBlfeEqFXUE7kQYtIktiuVXDrFvUrIHFfCP/QkAJtArGXNrokJHWGQEUaBK + BNMHMIcQ/ImiOOijrjQh0WQVISQ5JpMRHoAWZ9EXXNCkTkqGBaCk7kVEMcNeR+ClX/p/FrAAUzElNWQR + Y2IFMCoWZZoESTAdBmFrWDUW79EbNOcaqLQ2tYctNQc95ZFqMlIBB+qkAP9wAJ+hWKWRMCthE/NDm3jy + BKtxaV5BRzPwnU46ABApQyJZShwhNdqBpmnqf1kgMJsVqQMxa/gDcFahpQbhnqlKhkqQPUtxH0DCHJJ0 + preqg1eIO2pyEusRYbnxdVhhazeCY5y4RQRRPMoDSoEzFG9CV1LlG0ChBTOQlk7qBRFAKNz2Fc9VFeYq + SAzWIJURAX+ZpgEgkhh0GSRBd9+xEEPQkiaxqMHqgQHAKddaBDKBLzthSiaBG3wjBai6rzcYAKcSRwA3 + P2WRsMGaATOQEQaHnmulEQ2AQTpzPZkEp17RfvNlKYq1HUXXIrX1EQfQrrcqAF3hURwhHxYxG1zQct// + IzCsYxECoLABUBpDIBQIhYnEJiyp0jVFILG32rPf81Hd9h1MkARhgnljgShIq7D9ZwLGJCcfyVWiUrWp + agEzcCBYIZU9xBIqwTAHUaZD9BEIRWZdUAVHRRa2NEpFkSM6pFw6RopiaLU8IDQD0UctOT9AMSWlNXPf + cQBW+wcMy4XbIRpx1hdFIEnMUQRb4LXuuhSQMRX1qZDe0yCwyCD6mrg3KAFuWZkpUhGekRGWm6YAcJQe + gYwkQpMGo58Z4QRl2iJdUkOw6Dw9IXwR6QTrRRJayAcV4K3BCrZiA5xilUcMNyYPAR00wLL7CgFhVFCi + ZElhYWGOKboemAXYo5B8/wCOc+IH2lQZymEFSqQRq5uqOAACl2FZTWI3gcIEVkBAocu9f2AGUDEQ58sR + JISXVmE7SjEUUnAhKBUUiEgivCEVYyGi4LEee+MHFOCLABAAWYAAGGwCJoAFNmACWRAAxluFXjCemLGE + fHI2sUWJEeESRrC+/pcBFLAAGowFJoAAWIAFPKB/z4gFZaEpk/oxI4JpW4EpSJsF3jEmexAxmtMbsQG8 + fkADG2wCOezC/ocFDRsRYZBg29EsLtkAXKAuaIG0A9AHN0CPUueHGEESmnUq8HR7cEoEL9NvbjkdkTEs + qeIVE1IFnwMZ4LUH9+uBbcDCOrESxigWjzMiM2DDOP+8BhLgqai4BmUASVVRBWAAf1djEC8DbDTHEWWw + BEegXhyTG3IXK02IP2mBQLVhAkS5ADQAJZ5HBJ7SK3wAAjzgwqRbEvfyEZ/hE2XwI2Xxkn2wAKiYATwA + An2mHOnDN2XQULTswgBwMnYCRWbiIUBhVL6FsFOYBbQSR31CImNBturjBIr4x1IIAKilud/hHwXhBPvC + HXuAtCIQFjEFPh0GatYiFmABR4qjLZIxHBa2v+goVL0xKS4RxDOBtGigxgbJHyDjzsGjRB5Uio48hgnw + JEvSb1AAKgRBclrmW2kSPa21wMexViHTQafCHkxQFhNdzjzgJKCRuk1Ix0OABev/y4rsg7tgUQQbw0E4 + BAJ7W4UZgADEUhopDbwIPD4AUxI07YjeS6i7KyxWgQT3QRc68c5TGM9rFSVGEAZVQBjZIURJYxUNMAPr + KwLOZRQvVIjqtR3KdLTZ3BJUIASiYlH78YDGpjUE8QQd+6oMaE+OAXVnUqoNqxp8IMYDLGcYFiaWEi/+ + yyKkgwAhrIM9axIpzRFVjUOqYxEGqSUyghwkWit1jRmbxBk3axs8QIYUIIlEFNZLKB9e51UWsQA/PYUA + oDxD/ddG8Zrg5RNCWYUDMHduQifG9Gz+mjp7wAPSq4MWAAItYRzPUzgDsW9v4h1FgbQQMJ+YpxHjE8q5 + IT3Z/+caU4DcY+gFcWARtPgeCYIhO0eVe2CrOZgFPKFrRDEhvcFMFsEcOnNpi3E21EI0dzQW9XtX4LJS + ZmE0x2LVUgjf5kosQ23QG9TdUuEdksSdfiDbZEgDAIRX5EtfGfM5uSNic/g8q/WaahgzqOY+JzE0LrHS + OSgAIik7fz2dYWRiMzDbUsgDDUAhYNZ+hXM2GZMUNp6DXuDiWKOrYGMwprYdTAAFM5DcObgAWCEFV2IS + tnRLXPBRuVPExlYbrIaVABIFi60FUlBy9DVKTT6GC4A2zeMVXBUv6IjgOggBQhC1FuEwGPEUQRxnZTR7 + cxGTMlIqORIR+M08Y7K8Q3BU0f/h3jiYBcMzR5jNHHywecOhH/ScFChCBGdehQHQe8qDJ9vBKgjFQQU+ + XYpGFcgxEJg6G+nzavoIWBgTAWMoAEHIPpqLgCbBGVLCB6zUE5ju5DeYAZYyn3O+NIqxETtbhTxQP7kx + WU1WukcFNASxslUIAFmBFUUyX7mhAiJVxNl3j8LyUTLSW8pUEm9aRmJwAEH+pDnUb6MkI79cEEwjPH0g + xnahHNFxQ242Sg00N/O6wM8EePJWGe13j4HLa2TpB9pOzqo6XVjhVYbRIoTBVu5kBFm6EvpU4yJsb0Bh + GzlXUWGBBCoQKBZ/dJhWEAbdEQPyOd/EH1wSlTya4MaCSe+20cOf+FIdcQRXwFFesRWwXoUJsOW1RVdS + oEJQ5bUL8BPwihkCRSZGSkaeMsh9gLhVeACt8Uy7ATiUuRsopRsK338iIAT5HBXwUyuptaVaICNWsRDz + AxkzMIYz8JrbEZKQoRE8odl8oOg3KAILZuJnhd9SUNWHEa0vNC2Bsba3kcQlopFd8pbW6xpyuL062NSQ + 1j8UOEq9UokcQfhG1PZVGAFocX5eBCIryeqANblXsQSN1URD0AT/QcfXZuESAoMCQH0EaRwSnicY0Bo8 + 2XMEatA5ETEdQ/DyOrgAHrFoV6HLikVHfVABVagEEZF9LCXof8hbz0dJZORVUZQRwkyFFPARfSo3RZeV + cXN7RdAWRQygmdIXDTQbWWVlKz8E5wZHQpQn2z+F3T9VRWDR4SGL6lUYAGFEyR+CBQ3+GeNHoR8kfIjw + 6SOkT8MiVKr08dOHCZ89RBQeiSLETxiFfSDu6UOFj4chUfw08LMHYp8+S2jS5KiQz04/HAcePAghIx8h + e4zspLnHJZ+hPVHuQdmkpxEkNKX2GTIA6NYASJB4yBgTIsyeNBlKMYk0IxI/HvYUWVJk4UIi/02ECOFz + hI8RrBj3xOwZYStQLETlysTI5wlYlX9FMsXYR26SiRBFJhh8UEkUyBH9eHToR+7CJgIyG8TSc0gSiHy2 + SH7rkchfhVRoiiwyUyGUPgBOEwQg0Y+RsH32VNH5OW/GPj8zZ+mTBDli2h79VEnyROGQv2YBH5G5MAkS + 378BMB1i9kmSzz0bDinpZ6PzwRB4GpmChHjPtRnhQ8VJJqjE6w4i/uTiYiGTpCgJp5ts6wMK/hQq4Lcs + IIoCJyrAGqqPMHBqILLEMnIiCZG0GC2j8k4DwA+JnJBCoiKiywivhZjigz2TbmJCwD70Qk4uIjAqjj+s + 3kKpjwB++6MAvf/KwkjHv/5i4ggVFLyJr8SkYEqhJX/zQqIGGiiCsiN6UuwvJ8T68jQlYkoqshFuEslI + 4xo0gq+MluiiDyJMYzKBiDwj8joGI+JjRimOoG+rARRqgCM+mCByCPj8YK8KHLvzYwgrZqyiCNow5YHJ + PwTNKTe/cisLiSkxqvC0NuBrrQ8ncJRLiCGqMmuPjfbg7qI+VCBCCPD8AEOKv7rsEk2U+IDJr5OIvI2P + RoHKIkSTejp0jydsBcwvpRpcAgo+bEqCuCU8KpVJEC7VDSIq9nACJyNETYsnnY4wLrJRqT1Tp5mOYi4D + JiPgSdu+0uqJiYw45dc4yog8iibBAi0Cvjr/oxiyjyloImuPFTOLILFaRerjKH4jZs6PNZvlj9mRBxNA + O2hLOq5SpEwSItbnJBRpiYf9cInSEFszEKk1RbtiLshm3oqHlY4rKwqUFrrUiIf8uPagLLojDqMiRIXP + O4n24K2ngPXdlg9ay7IM3B35YMvFvSjVKKOQ9vB5sISmaEJEIwzAi6MhZsq7x7CQYo3uO4eowAsmsbj6 + JCMzmjE+4wzcyKQktw3LqGZdZY6jsP9i0gso/Tii7v4KnZgjtiQKey7W95D8t9R+LFtHPpqo+y8UUu/X + qG2tE+nMQYUAw4ijuxQ7MogoYJKCiY0z6i/2HJ4II0u7NmgNsYYylwh+/2faQ6LsNpWqJCLW1C7EIqj/ + jQK5GrpTtOpoQ8ra3wbgGUOYEjsD3SQsxOHDRVxzugHFxCag00h6mAKGv0RqCWd620440pz/7WQJ6fGc + QpDzuz5ESoPLwooflnCF0LRnWRJg0gJStpAZcWRIRRHNkPRSp8jUiShEEVEfrMAHzjSgKkyQS5fIYgIm + BaBtfrCLBnXikR/ZCiNEUEGhMoLA0RChb4PBwg75wpT0FUpSWGgiZChVJzTxK1zFYRZTqiLAGfVhBkwq + AESSwITZlGVUynNYEsBXkAHsBDFNMGLLGNIH7ezILBjR04wQU5YDMEkJQtACxY4il6R0qQp1GiRBBv+g + F+MUgUEINMlFKAOZGw2lAVBJkhYUQpvH7KQLwnIRmibCFy7QJiJPCeUfRGA8NpoFR0gQAhHY06UhNOEv + h0NTTKaAFyjsoV2nEQqm/PCtjHCBJUlBAhE69zDd0KQuBuxU5jJCBLbEhSZL4EMH+HLNzPBAWlBsSFOE + MAX3dGSdWwgLmmZiAJQQQSu6O1PgolkUtvlhAUzigXVs0pCd4GUI1eTelFy0LcdIBTcYQULuMmMB2klB + VRDhld1qopBgDkAuJNkNoiJCBpE0gFLSgQltMrQSkxCHDcbyg0gH4wU+ZLIPTSDiPq9DwhANQSJICCZ0 + 8gkXIiXpfBq81LZMoh3/9jSBCJlcSEHR1IXh1GhC+mmAdVDCFpq0lGh+UEGBQkgXHammTlbAiAp0tKsI + GaGSvykACp+wB35dQVcx8YgTHPaZyDRlbJSZZadAg1jh+OemxFkDkw6QHKfBEgkfE42O2BqfDlHHDxc7 + ze6YA0GnJOagp5kBFfWFksJB4QoPDE8uoXeXmMhkP8H8w2MYCUvQdUREfvgiUCAglylA5SQfIwpAj7LY + ITSSWXuoG0SKhRfglgSIdOvJRWpqSKK0tAgoGxEcA7SwIhENRx+TyEkS1RP2GAVn6HRZWVrmv9OIYDiF + aqyCADOgDeaWkUZ45tWIw6QvDGiZLKMLzB7SGp0U/2HC+m0QnEaihd9lVUJtyowPheAwiHzLX6zCrljM + OKNIEUFTfdACE3Unk6V9rFc5kQ+IB7MHoU2oU8x5gttsCJHXNIUIVBAOEZyaniRkIVDmWhONjCA0jnjA + JEewSFT9UGQHAWZxhyIaR8/kMIXVlQ8QCNSPjpJb5pSxoCJpaQOG4JEhaIoP/HwWjuYSYJpkiFJITZKA + bCeW3GiQJ2jBC438oJKWikjO2ivs1SBpEvgg4UzPwokUaYIEM/zmTVtkDXPqaE4+DNFIy3xmom4oky7t + x5gjwkuQg9kiDUMkcCYDL7BewpQhOQElkfIDfBuExt+YIJdaXNZL/JLcgwDAOP9lgx6M/bLRcqawJMqD + olEYBKjTGNtWZBWJruvVMci01DrOlK1COmaF24YVrDdhDxRZZxKV0HMwJoBmfIhTBF9zRyFmCqZ/JWUW + hrJOOQ4Z0DPpXRKpXG0Ltfvx4AyDYBxhRApD0ly5fyOCzjDHJnByVZcVsgS2YoQzcmyuQ9oK2I6sRAv5 + JmGGkmMSKtrNx09JzBD4qRAtROEq/+Kgm2p4hchQkQhBXidKqiDXprrGQAK8GpMq4HHmPEQIPf5xMN+E + hEhFZlF7IPpRIC4alwlLYw3CikeIndqnn3RKV9saH5htEAD+N2UynyNKpNAEl4hlVG/pyxQ0BpEhyLjb + CyH/2E3A5QcrLEsujU5SRs6kFhKGt18qLwsRmnbcO9GNNulxmEeooEMjBMwPacMRH75gIey5xiSCnwjm + WIVDaukdnRAhZdAz8ybIhjwxfqpoW3IClUvdyAlF6DveqJA5HVGKsZZauZu6BIXZjOv3f+EmSo4Q96z2 + JGR8kFAolcATjij2mSr05RBW76ZZDkp50SkU0TdYQD9owZe/ElVGDJ8ZY0tEaKAJISLgJKYIJggIohqB + D9togiM4lCHBm5gwlyKhgnkhIj5AACbxNgDbiKeDJ/vag5ZCHIGRCX5xDJ3ACTZgFQnqle2YCuvYkyKg + CENLGZSoL8UzjmBaA54QGuLo/5jEGBv/KIkucBh+mSOMkIg7+QutUwghyBxoqSCOCpyng4J5ASFW6QmJ + KBs10Yu/QDKX0RX4EAhPAw8+MIClSYKsSpl4gpO044khYhayCDZfOwChMggLmAEME6f0ARYKlAz187SU + aAhdkaUmyBMQwgoo6JOS6Jz0CI/FOow92D8wIgoVGok+8AAycgh+sgI/4IKAk7zumIghGAEGMRYqc0Ac + KZcruIghgQib2AMuWTv+kwIykJTtuAKcU5a9IMAOihlDiokhUAltST0j8IAUNA7uISN4GY0FqQuH2KDK + SKDSe5gmuAK+KEDhYxCPIJiwGJtpYsRFW4IlQI7KgjqFCP+n9du9GhkS5AAD7wOQSZQ3b7EN5BANk4Mi + PiA6hnCZJ3kkc8mRjAgmCeAsZmIOIVgK76jBstALtfgLdaoAChgZLwiABBCCMSItJiQlxTACQfoNCXAM + pnAjpLoOIqmCJ1CJ1uCeZUqCPTiaWYLEySmOyHAL7Jm3wzmCuSuIYUqhufGDW+wMyEAhSuQCrYKsmGCQ + SNwKLFgCm0GTEbLBmPFEXZKeniArCWmZ7DEQ20igm4AMHLGOHUEZjaIY1mAZIRgBa+wgMYAeKEEpk/CA + IzQLJhBHRFm0XCINIlDCuSmbXgy0ZnGQtewfTtmDZTocTUET9LpG6HG1NuOJEfEVmXD/mEUpqtKhNC7p + lP8AHT5wAuJIkkRhmIWYgp1wK3zxvmOJyQz7FpQaSXVTvJhAAgz0HtXQF4UwgiqgAhWiAhAEHYbqo0cK + D6aQAoscye6wCfUxCQzMiQk7nCn4lqv5iKVrqezQiLmJFKdMoSqwAiLoQN0YzMDUsLAKD+VBDGMKmx0x + koBLmnxToZ3gJKFxqqdoHKaYEXiiEepQwk5ZFiPgEufLjfj6vUvpESlwFXxkCCGggsOhvo8QmN3InCFo + KbLKNNxYCJcItZkADVFhNZfonvHhjD64AizrFZqAr/QIlxKqieYaiqgyPX9pHXpsm7ygiRTxC4zYQOVA + nWKrv8wU/43GnLDQbKn0aQC7EI5UwjwakSKeSCK0iI+AIQKY3AMtcCOdeMeL2gNAcyu/NJ5RSSL+0A+m + EIl66YKkIZgmAIMoc04XgbuMcJi7mBYMjb7MSAhL0SOgVAgwG58MI9DIeI/40LpHIhLLdJbOqZfhowkO + sxF6McKh4KekAanGIRPdGwwRIBg9+y8B4ggJMbAJKaA8eZaWmcFa7AkosMpxepbcmJErSI8lQE9lI7oh + SYL8IKOysgl+oqLMnLZEO5fJ2aCyCo9BeSTWCKYxWEZqKRSCISyskCXoipmeeAKU6U0MZKPLaSbLbKAn + QMfBKCRREZaao00h6CVqOaYr2pEhMf+CW8mI4PQYjigKmuCCOYukbZkzmmCNKmCCa3UUwMC4X/SOBjBM + k+gliKDHuciqneCM6gk+WrlNLtkCjCugzfm4xVEITooYt5m3OoIIzuwJvPwfJQO+TsI9TJEJuZi8xqoK + IMJPz9NMUB3Dm/gLFiocp4i8X5S7jXsYihONKCOjz+EOaNINTvrFCamCybkJJmuk4jEnmTAv3QirypoW + 75gRVzkCI2Ch4WAlIhHalYnY2ZAMIlEY/sqMRxmK1rgg77K5KNPGktg5X7LKacMXJRWwxpSPp4wILXsk + h+GOycuwIS2eZUELRpQezOggZhmKwukkmECLrdQXTlIPIukMEY3/lj1BsM+IqjBwKg+IQBIFFiSgjC5Y + xxG8mjpBmSEQmqtQsiXoDvBgNZWQAqITDv4J2fMLOOnJkS4Qgtc4lDraDiaADyZwArZIlLyQi/TIkz7g + gsmRCUs5Cu3Yg9tEGo/4wN+AAJmACSeAS0ArIyIxAESZkSMACda9MyFAJg2CTU0hUQtbp6NiJB0pgqiS + gsGakCNADpogpXQhAgqqoRwBoif9Ly5IvV1F1rKpKl8ksSaI3yRogkZD3ZTYyjSYUZpwKpekzak40OXw + GJFogYMxHsalmyGIMnm1AimwjfO5k+aKPG4yT698Hj9Ai36xV2yJjHKhiU1kii40CXMFSfP8/7cl3IiS + aFeVwInFgYgwHTQFSSKJKEA6Xd4jSBBT7B/5EBokwiG22L7hEB2UwMCYqILVQJu/SESujImoDJFiwRHI + 6tSAkhEduQqpqKH44gOYnLB+8TK7Ib/1/Z8eocnr0C9S2sgIWSSGUSjuMIIFnCUtIY7ahD5Q7BcdnViu + sZB54wiZc5yunEyu5DUMcZsf6YnR0LGtSIA38hEtmDAPsgKbck6tegocE7CkgKXTi9htiSpOiTcD8pcr + nJuxSIyTgzHwuDLPMMeYOMin65J2hFgSDSY0GBUV8he8cQxfKx6yw5qy0BI/8YMrBq+Nagr8uDGcFKWQ + AwzIWOEz4Y0kMP+qmaACJ2iA1+iDIlOxjMDAi4uIgAmPRAOZDXIrV6TYikG8O54j+nMuE0Qn+/rhiHUa + aukt5/LawYAOgSIS2YKgHwYZmTjcnDDRjKBDoPACLRKaRK4RkUCq89ovVssI9qibjAlP/hkbZgHDFj6I + AYC7BsCrsdkcPriSKKnhPgiV1SILgimmTbQKSiVRFSyLxtHPyNDmP3iUOVOvnYjc26SyEWSkyBADqQCo + XyoJ2NxSvMA0nqjQqJIMhsOKeuFSUGxZxg2R8FhJIsSUNtadsDicPiCDKJQJtkCJsTng30gI/oDL3zMS + PRECkjCmKBuKzmQLC2usvkAcE6nSH4vNx1D/aYOAgGguHiK6kag9FzgaODtLIb6oAnvbCoG0sGY6nJ0I + kWQKNraOrFALC2yjm5UkErdYxNtsP5aCXqrpkJ05CdoyJ/lQCA2V5e3wUskikoBpgB6DiaULZGDppD2h + gqIuJPOswStKD27yWe9qgoz2k+vhlyGYnOx0JJFomipQoCRIogLkJBldrT7ou2TKN9StozyR6CLQDifA + QEYcQ7gpp4yBiKiSpQAJs5j1g+wVXFYammAzCTAgipzJiAYQicWikSOsrybgYEaaCeb+PRGZDdzjKJwZ + oH8R3rCCGqBYgLfAsB/jJNftxbkAvKGglYAmO8IrnSrIkKhywVfCDimA/ycoYI1nIQ6wkDZM/k2rzJiX + sIKIKQIib61428T0oYLYKSGAtBA961gRHhGeAOSVwLEKnyQhuOKwchEDkCXV8A5GPo0BgAk9oYl7wSAE + ukJK2amYqJMp8YjMMQ7jpa8jMF1VyQipAKGeKOosSALOrTjdFg70IMqHmfJL9kWkEBAweCR5+QuZG3CU + 6RTmzghzeYKO+bfAcd4QSjz+SYnx2WxTERRlwmuMuDTw891w0Y6hAUoj3FfRyBOhiQIQ2oK8ANb/2Tk+ + ToMpM4mH65eNXMMh8ABLY6TPMIIpjIIikCUVGIIjEAkXU6GKEEAVVoihlK+keAmUOOK9EJXMcXYzev9F + l+GwvPCABuCLMs7tiJhvODGQKehAIxhK9HbyMZ/Nl9jHKXgxnSaKlRQCMYgmz6jV5esDoRULepWMvaC5 + UqObIrCCqOKDJUewJGCNNTW4J7CUiAvtrXGuw8mQQSERv9wZBvkxZBERJtg8B2W900tnn90LttgaeBoO + l+jMAbGa8KCBigaK8WM1nHh20TUJBS+tISC6HUkXBx6OsyEiMFgXNuCDUyIDjIBD5IJeYI6IDIEJlGEW + PwWLh/iWMNCLXykxP2ELHVkCg8SPuKVMiXaaRiOO5qoscN0JJtAa/tALc9e0yLgVjFh32w4o/jGQos4m + HPKW6GBCOB4dx+CQhZD/9FSVC5hc6IDqElaciIyJqqPg2eHbiTMJEc64CDxuj6SOa9qoFwMyc8iIGKvk + wqntA+ZuWF5LNpqUe8l26FZXCBAwGIgCkAZhCidgg0OREACrgqE/876jlVuMJgaZSeLYAhTNn2DVnCci + i21RXA0TQLFyI++Eade9lUePCXDDusFMjkZrFvI7EMjfH9YgOJsOncRgEhsAPrnQkzElq8YR88wQAYx4 + gtzrk0Rz3v0ACCF+ivjx06ePnwYJDfLZg9Ahnz8SJ1KUaGJPQT5E+uzhw8cgEoMPMRaoaHLAQT5V/OzB + iNAJxiZ9NPoJWdDIzJkePRY8WNChn48GgyL0mZFPP84kfobwaUDEzxeTFVESROixCMGNH1M2aIjxp58p + Q/wIcVghg1STADB+7ZmS4Fg/R4Y0YTnzSdCfGIUg3DLWaP9Kjkzq2u3osGRaiVkKVq0S10mfJx+bHElZ + MOiUjkXeIgwq5OPHr1SI+sGLZE8SJnaNtCzCxwiTmX4QJx6D+vRPMEjtBkUqBIlqh0qfHCzSco8UP0lk + J56IpehumESUVkGSxOERPkqa/8kS9yARpH20vEaYJPPuIkh28/Ew84rOmeG5cP+D5evMPZvbehxS1c92 + za2xxGZzIWEZRx3l10d2fPDVxxBPidSZSBgNEUVoRvQ0FkYNHKRQaH7EBh5taYnQk3tQ8HEEWw0Yl1dQ + 4Qnl1hACzQBAfRLxMBRb6G3VxxJDADVjZ5/1YcRHT/FRhAcucZTXQQK15AcRGyHRQID/iQ3wmRFJSLlV + T6fF59AeEg7FElK7yTXEQXsg6dMRDy7RUB9TbJQSH0KyqQWA3A3QU0YGfdVREmGo11tneOl0GRF7NLAS + S/WZgJBAfKggFF+oMVRQlmlt2Z9QanI0BUHLbdSbRk+91MeBRjyFxBP12ZDfZRB+JlJBTUjYqVR/bmWc + bFZxgeaDUQDqkEx8EEjWek/24Z5OThj0ZpuXdSTFR0Kw2AevJp2YU1wFWeFhQUIeBF4fUNS6RxUoUJCj + RBlY1cdGRxjEIZtUMLjEutVe5poTr/Fx4HJkXkZlH1LIxhKnfgLaxUdK3QpaQZWmZIQRTM2o5hJKyYWQ + FVvpWvEQ/0uw2wdWlRU0Ih9bdFvRtxyF5pFSB2K04mV8qGgZXwT5AUURRMjERH1YyERckRox2VOVfTZ3 + ooMfUqqzECN4RGhO7HU2Y4QaoVx0Rp95pOLAfnBRF5scvUwRSglFDZlBRGiInJLQBVXFV0jJ3YCxgs5k + k5N7/MbvmRzx28QVxnLrcNxPlMmHUkXJ2IVPCu9XRR8zBGABvBIdkBOtVviBU2nX9SHtcUvo1FUDBzbx + moI7QTinQV0BWitSa08kwq888SEtFQ1VUcSweS6M8UOdGZHcFD1VIQRftfdRlkEyUbHHEZspG9QeTRok + hO4SndgTUi/u1RFLlSF0hU0/bb1c0P9tSsrHFAgVEYWGvS0BvVVQhP8HSnCWN46ci09+qIKDkgQooxjp + WJJC0so8wAe8COoySMLe/wBQgC8ooYMe/GABPPgFDn4wAAmIQksq1QXJ+ExMRAnX9DrSKIYh5Ah48Y12 + uJMFCH0ECvT63ZKmcEE+6Gt6qksAFhYQAC90biILQA1HWEihj2zBI/QSiB+asAeIaagPVxCCahrilltx + qCijc4kQlmOV/y2GCltQFRWi4IQqqKYPViDeTLQwvYr5zDPKiU39+OIfIwlBMtTbo7ScQBCd9UEpOFkj + d0QQHph4aAoeeUoXmWKvkLAPc/zqgh8CppwlSegK8yMIE5zgKqT/OMQKW0ACFhtQIqlAAHNMIUtGOsND + s7HECmWKm+2KsocmGME9fpBC0SCDkCU0yVG6CtZHinCE/zUxMV5IQFG6UobKEGQPW3iSD9k0pZAIYQp8 + 2cgQnnAFLjiBCQpzWmIA8MERKoGEIvwgjqoplQCYp0NGsFNZ7DW9nQjBNQ7aw2gaEoUhIOF6uBpI9E5V + oQoSUyQ5bM5iukCGjvABlGyA1EgQdK76CW4PB2pTm1hUxb6BJm9ew8lHiHMdNV00MVnYyEbU9RFX9SEK + M0nbbhzCFNXpa4Z5kcxSivYQ2m0mWN/U5f8GYC8rPghKGNGQipLAJqYRBygiSQK0/KBUi+oE/wpIaFRL + BwJPfTaxAENpgEPwhj7bNYU9himbTIwzhHAWgQmxWStbA1ufAEQPpUYQAkzyNJRH1ikleSONMAnYx81M + iCdYPAi/FtecAYzFI59pwhNUU5i/OOsgMCVC/VQWlAMtJWs0mYkTbNYUQBVhOTxB2UCiOhB6xW00QGpk + FVjzmTutj3yl0QqujFC0I4SEVklw0MFwxcYFVmkPktnDFZiCWz5xhLLoC6WRqhMxIihVVYFkCEJOShQi + REWwTUzAExR3pDYJhVXtq8lMVoIp35TxIdR0b2ADgIQiqMAgVliU1ohilCW8DneyIS5EnsWT5WDReB4R + bV5maRIIbCVbo//0COYQuJPeNIBwj5PMiF+zGXV1JFMUAspTiJmTimFkNID11gGHchAh1ZGhS9qNiAUy + ls4WhFwMMsj8LsOEkloFKUHaChvxVNugEDmoLGKCGMmC5Vt+1yBU8KGk1FeQIxxhOWSZMUNqCuCizegy + SWARW4pihJC0jChWxIlCzEy4KPx3zU38lnjstweNFSWNAvWDL8dcE4T9JH9IQdKShLDVF4qNh05oAub2 + oOGKoIFBM1kesPYjBCJs4Wd0dgtLiCk6oVj3XB+z1qYiYy+BguZIYcHOEKKqWqBAqDDo++HV9mAAdnlo + J6JbymXqgwAlReE0Q6DLuRxbkE2zDWNy4YL/AVlULo4MC0Z8wPIw+3ivjFlhLJL6jo5/0hA2xWYjfV6z + CfygupkcuJFGsuRM1NMQrxTEcfntD5CM9G4/cwcAF5F3H0bjkCNhxDrWvcwh7+SEkqF5fzVpiVWGsOTo + evV2HKL2RCCw8PHM91w84UJRdOmWMo3lCjGi0p3IkqmDKcsobuvDDVhpxWlzBwKy8Wqvh6BtlbNECISr + HZUgFxQGOyqZMyo1SOTiEZ8iJKowIeBuBPJTr5EGgh2Gjqg+Ajaw6/hcf9nNwN2LhbHUL0YgvuEVHmey + JyEqZ/jJiKYJDmAvDKACDVmOehtZJLc0wZxNcE1n7jSikBjmZngaSU9c/1IXocz5IGzUFIQGDaPs7IEL + e/ED1Wv4hCpt5Apxv8HoFjm939SIYX7wwIQaoK6zJsnxUPHTI0NlRz5cwV4FsWSDBScFewkODAXNYkH2 + 15Qwi9MPUD/IE7bKBwNGtQjR+4i9pOn8IkTIzeh7rvZaRpz8ZYQKYHPyU3iNxSq4XIxpF2wCQmb9YTYK + Qju7wpISRkOU2iVNoHG/3gWWBaxBBWTHdRzWfMkF6XgRH4DBXsgNvZiRtCDc9OQEFHhAsYVSUAQPrOGE + 1vUE4k3X3NTQzv3FfSEJFh0BFDyFkrRfjNxJ3kQPY+iS7VAJY1hUrukQd7lPQSRBBu6W9gTLSe3RMP/J + htgsl0D5RJTAFfdkWlQ9iZPZCxFACve1lAcmHP30BBQ4DlFgWReYH3eYgBVRAXG900EwQWdZXgAmRgAs + HFnwAWFsUV6AyaaEhk9EWB+AEu3c2Bo2hwTwABHwi5gxBE6cTJowBXFMmLcJ3mrlXroQgYd0xAT2BkuE + R+R9RLOoTc91Bn5YCHMVlK1BTvlszVCIh1CMhYQkHvItCEKEh5hY4sHMRFTtxlSdyzDNlhsWhWvUBJ2w + CeKFX0SEoU7ciYyoImiAjw7RnoLgRwN0HxFgGUIoRP0RS31lhFIEY3NchGXwi7JIy6kwwRGYDJb0oUlk + QAVQAV+ozr59xAM8m0j/2NiUtJZLIAEYVAxDRM/7AZgZUEAEgMCtQIQQTB7NuYqZLdkeDQTp/BJLxGON + QOJBqEuatSLIIAwULsmhqZlUZAGkmdxQINVCkIZQiA6ECJN4pOJqlR2UTBGg1Nq08AHISQSH3Y6jgMTq + 9AQVhAQmHcmjoczQFQQSSEq6NFdZzItO6Ics6lBQ5I8ZsYQTKNOl8eBDyAhvkEEp9gGb7cRTSAbdjRRN + vOQfFMAADEAWiIBYZoFZQoBZjkEWoOUAiEAbrMEAoOUCgEBNpFGCkE5GqEqoqEumQSGVcSKF5KN7BUDR + xY2djc6SYM5NUAiDzAjG/dBXMMWzZYeXPdcqqsll/0iLQugSmxxUEjzh1jjEU+wMksiITCyEAQ5TUOzH + dMwEFIgBhMRFDzUAGQjEaQ5lm/BaExwYH7JNj0gByvmETNhPT33GSigIRxCBiuiXq5WapOCHp/mBy1nG + 8MyEV/5JRjgBXCFFwPQB3pTGWOyH7KxkA2gI/hGQsmHFQEAGR+2bvMFhZ7SXTWnFCPyEsSjLwEQYqq3H + tqHOQclGAsnGInnEE3jXVkBBdZYFRMhnWhQABMQlWYolhKKBWYolBOQTd9BAmhxB+mUWCk0QUISMDJoN + hiDKj1HBfpjcs3QGXHwH6LzjTBAfj5yGV/qcgoFHVZxOroTm9ziY6wVKpUwHqv913GWI01KmhG5dhhg0 + 1yahykGcWizSS0fAVE9MAdFwBxb4JGh4jG8cRGUsCRv50MDcirXUSIndaDTtnF5QotIVTTDlTG84iuOp + y//Y6L2wyXMdJK64BGOQU7chXh90xUOUi0VBhM9IEAh+hrbkSm9OxBjoBXRwwW4ciboIQI7wk100kmcs + 3EdsZnO5Rbpw1Jn9jpB8RXjkx1ao5jF9F2S2SRUcAZKwXR/UxSzCiE8UQWydTh9sQRkszFgciBXJjYh8 + G6UgkNaFB+d1ZlG8jqvUyB3aT8AwaEYKlH4cSANQps0kQfrhBmMiARucDk58qR+wgVhhaU8IxJR9RP2A + kuT/sNETEAcSlAFb2CBDQUFyQFdeTIGxYAdYJEdGDIGkdMWkfg8HDsvp7IGK6FZ47EG5CROZrqTMGAFB + YBGBiEEPUYmHxKZV+FRHNMlJeYQTaKW27EUfSKtJjMGTPIVtDYHHjA4FYWhzJMAMegz/yIaHNMD1QJ9c + JIQwEUQUEEHcsYQRTCL2DeKWYdFGII9KyEZ4iofJVkQW3Ew1ekB3+pQK1BG/oledfAS/iNai/khjjiSa + QIRGxKMZBY1L9tykoYm/uYWrMAyZVEubaIW4FoSkMAy6tmejYAuFPC1FiICjIATWDgR2gE4TfCBPpI9X + YZlIHMHdhgZ+AEdDaFsYTMn//4gAbxmF77DSQ9WKJa0HcjQB7DGME+gUDL2JSExeK+LFlCghG/GnVuzb + gmyKpdaHEtSezgGrzj2BjSUE9kxId+WFG0LQhJBZVRnE8+SMZQpt/6GKbiXhSPLLyHnAXywWWaDPU21F + Z25kptWK6pihurHSHsSGvnxEnRqGdPJefT3XO5VLs6ycbIgYjAAsluqfvfxGQSjJlLBGE1ynFakpe2CK + T/qg33TGFCxBFDwBKE3fbyxXuFgVgRBQ8kTZvfhE00yNJeEXA90M9MjgvFyQLgmTXexH/qYcwuXgZg1F + cymFz7TEiiTHHsBsYkzKBMLe75gOhi0KQ7BImgAo1+4ULv+xpPpU46Z0pkXBIVG8jm6FRHKYC5Zt3LNe + BkgVxEooBXKSYoyITQ/aD6L5K2zYYWA6zMLZHrLlDK0Mp5GIEQXpxI/drQcsgVYaDkdk3xGMBhIkKZrg + 0ouKB6+hr5LtFprARKSYK2ZWkCE3khSgcGKsQY79VpQghIZ8RHJQhi61rkuEh0JkhBVUR3QpkKTZzwoN + CvKaL3egQUNgS63ASU5IgRQQAQ/kiBI8VGSMBcRo1yJJi9xWyLngxZyAxjNiBOM6SQQ+pnhkCkEgnsdo + lpaQRh8BRpTIBXxEjTPbUQNo3SUZhHEgxRYQH2xp6m4pKhcUgUwAha5R6UdQ3WEp4mv/MMGpBkUSIB5S + iFmSSAoCNZixnKZd1AjtRFXGdqYWuMS9AokRZBbi4ZcLU4ge80XRtMU57SRRtEWjKoZ8DKdcSItH0I6r + EUEUZHPhMAZrkB+USEmTIfTZ9ShHXa4JUw5G6Jt0LpyG+G1FmABsngsSDJ970skWJYcQ+FCZLZyU5JKX + KUkF/82ZlSKcskVbqAi/XKdLLNxKPDNLGIcQPNJmiNLrnHNpkJmOLZIWhOtQfsZVuVoJGowyp8Vi8Ebg + ugYY6KX6qZtX8YGk7tvCRYFSCcTosuzo4EaatESS+qej/dKsdtEC6TLo1WOQnIlSzWq+iUdpYKLKOIEQ + wLRE/AnJ/2VToHGuT/SHT+HK4x1MlyUetCiThmQWUCOEIntKUYJFDf0lygyaCcDyLVKJewz02CJbZmPL + V6iOelTXMaVNI/EpU6BjXkQP+gTa1nzI+Jasn/grKlVGwIyzemZHvnGBEYBI8yQBa6yIdOcJ4pXZUghZ + TjRKhTGIQhjBSpzm/6BsyoHW6AVqEZRauoz3UBwepXBBFAzds2FjYtzHaTRJnmhIFAynzqVtc0CAcagK + hwjFnZRBKitHH0gqeWBEFzBh63lI0agBAi5JyDgEFDwXEqiMu/mJhfzVEnTAYfHLU7HKT1Hvfc/LUBQR + gwSN2bRJVnhA3exczeUMlEWSQqBP2v/cTRNIAeEQxFz8VwSkUWkGBeNKGrLlNpMbmK78joTsgRYYp1LA + xKARUVnwy8cGKsZl2blcI0ZumGiFB+2canHQW+o2I4gYR+Qg9FKwBi8iClOExGZUGlxfUmWcVHqLCvQ8 + gRULwVOZlRIehE+tBxyCWGe8qlXWb7T9X5ewqkdI9h8Y+KQmL8OgnB/krBt+hKSy7DLJzBOEhIWHoQTl + zbEl5R3ueHOot4icoQeqxjeFylKoAfbRymWoDkZkD2RIalCkCE1wCEOM7wJxZ5hihFKQ1muAkUhVwWvX + BwDgxZtJiwwigR4VopOpgAExLBLgMgVlcp58xNURRUgk1Lk0AOv/GoTLHZPA5AUbJUGmDbQRBM8ttQeh + ivMeiJJRDsWoEafQgg6QKM4QkFRhRiM3eqlHpLcSTpSduUn7BWieaMvEnStnl2tzYEGeYsRTlHRDbGZZ + ZyRR+gQZIAQXlBmScIGQbMaPdx5cFQUTbKZPXeVWkM7vDFpCPRvKXKemuolpLWbKQcFpZg1HNU+vlU9v + dNVAzFs6y1tvUA6HQprgWMflVS+jpRvcdoZXSkQLtNZSNA/DqM71SgGwjs6M/VigfGRpsVKvjQ7bhkRz + kSJSHNt1akESHB7u6EdxRyBTZo+O5T0SNIvgWLDs7IbipCpHwBKd4ESjgGaZCI6XxLnO8Ujr/1CKQWwU + TfWEFt0tqrTMo6vpEXjlDqXb/kSGijsE5ZzJWFRKrZSLb7kJ2KBJj2NEYsHwdl+uqrhFC3uGfCkYY+8R + pKjAoEIcmTQAExyzz2zEOG8EsYfFbPgJTWnIdajRIQ/FsxecTygluCc6rtScVHcIH1P9dNRg9XoNT8TG + rkce6ZuJbvXBCBxEKwPKmbvEj4RFmhREPcqtTWy3tewqvQQMQPDZI6RPHy1+EPbh46ePHyV/IEaU+AcC + koV+kBhpiMTKwiIFoRQhsqcBn4YJp+w5snAKHylEiBTZM5HmHyxCEO6B0sfIwj1IGPoRsrDPw5oRxzT0 + aYRIwSEMG24x6X9nD8Mufkw2bMgFIVaqfPgclYigjxWNCKFM7bPHJFghe/oUEAsxi1aGI8H2qXKRKEaE + eQvyScJwIR8qWjMG9nOQb16hfYQUuauwD5U9RsVmabKH7RPFa6H6BApa7lyIAphS/UuESVYif/0cgeq1 + ah/ZXsv6GbKHydOErwnDHsKn/8FntX46ls7sFqzQoJyxNqwSHWPDLn2mBO1TEm7VwmwJ/uVzhHLQKUpH + Nw2M+egAIVWMHBFyRSbW3US19vQzHSvc8lyaYGiPpkz7wwQpqGrgCP0Uek0pJipjr6YBFDJiidh8Q/A8 + rD4ij6g9qngCqySaYwiJ4hgqEIuFhliroSI82yPAJfqQoiA/lGuPsobgwmmJrMAKUiE/ihiiqeZMMsKP + 4obsowiBLoKsiCoUusKPJC4c0rshcTTNPfz4IIKP0RLi46nm1sKiwD8AqAAMIIUaar6dFCqsISrwM48w + uBAKkMk+WmRLtfGis1O2BhDyjAkJaRIBqwbYKIJGLlvkq/8P4Piw8FKFwqPsqQChYkK3phC6cDgeoWzL + jyP9eILRiepCMDaoGmrRjyhcVEhErxgayieuwJJCKhV/pOrCqmhTCcKGvjAtC2RXPWkxuJJoQiqZxICK + M67eYohKrHYi0DQs9rD1xqB6iuKvG3OsCQIwCyKIjXX9e43EhpqKgkrITmKL1MBK+iiwnRBtSIjiVqJK + 2lclgqCghzkcCi4jKt3jSYgZnmiAMIdQ8syFEM30zK6WaGo3I5B9AtkquguKxOGKsFGrH+8zSaU9RNyO + jyUyhshhPp7wwAMmBotOi6xyek1Jl/oIgyckOAOr3D4CPAnPKgRO6Igt0dxDI/62a5f/pgH2AIOtp5Sk + qlJVQZZaLdBww3ILP1SEAtlz4d4PwYZ6pgjV7C6aLgkphFD5Iw+6aog8i6ryrcYw6TbNhP1w0s4ijQZr + ko++61oXSMSD9MqJPpLYA1fZkqhiMIKAdIIqJY2YOzseS/Kgzu1UEi+nZudawz+otHgycz6mw0lMgRCa + YU0vKghjiCTKkK05McAyworaGIJCI7SDYjK24/qIgo/zioDwotaGI6yPC4t+bXPTIPDVDwhtrA/8vzpS + CrGL/uoJeRMCoAQBKiEAPPBOA5KAE6U0ZSXkUchlnOWHtFxkDxdKyK0WM6h1+UYj5QnQSpKgIsl8J3Ek + QQiuEMK5/yE8YSrIoQpBkkCFC1qMNichQtH41AfzmUBFQcEJHxAHHa9Bpi1U6Nu7njCc2fnBRq95ysP4 + sr062cov/HkiVoBDtbUkYX0s8sMFNhDGMF6gDxdYQQoc8AOI9IAEbSTBGXRANoYoQIwnUEBb+BCDDeSh + NiGowQk2sAIMQMQBbsyBDv6gATc64I590GMdpQBGMdYgBFGgYxjtyIc8nKAECCnBCS5AhoP4AZBhBEII + vriBCzCBLV6jTgUhxKeq9E0CgnKOULyzroM0gQtCiAxDJDMantiFRxWQwFGUUAGg+OYroDFdc45AS7A0 + QSvUqtSeTGK+nOwhCUqqkM2ipibJMf9ha0JAUOXEQxCl9E0EcBkTxdw5JNcNoQFiatxg3DkQ6hThCpDx + gzjngoXZcIFH7gNLi6i5kL4NYFm8GpNgiiYYP6CsP6viU+WSQCouYk+COYGCX7xSOQJsQAEEMClCTiBI + RWrgDx8ggQY+sFI5XoGOJq3BBghQmzAqoCANoOMLCFCDOUDkjR/wgQNykEgSfOADZ1DlHjiwApMS4AJg + GGlJ6aiAIdQ0qDjtAwwUgBAFwAB7e9gAHAgggxPEoAEjzWlaHOS6Ep2ElQ4xzRf6ADWhCKQq3uEmQtJn + JqohxEq4W8gRjNQdCsyFAtFCXlWKdimE2K5vXxBmH+a2G2pGtE7/SRiOLWsFMRNqD6BiEehJFAIFRLWS + X5JdKJGq4hnKmI0lfWDhBekaHSGkRTEIsUGBTCAY0m1BTmDZGkIkc5eFOkU3GuFTV2ZVkIvxwQlkeFju + hDAEdPLPCb9bC7K4mBe3QnekMmjWDljQ0qVChAUskGMf6Dg7knZhDzLYABBW4CIOcMBmfAjAH14KkR+Q + QKkQ+UAKCNCH/Q7JRm5tyH75QMeTkFQILzhBCEJwghdUji0kZUsQNrAHtzKhAc9VyIL6aQQ6PaWyWglQ + 2i7CRWJSpyFgyNVG+CAq0HhhLl64yxKGUqTr6hMnYpuIEi56I8qoqyFp6+t4JHOEprgTeZky/wkPx4WV + q1CFi1/pzHcbwDktmSkJsrkRdBB7K9T+RVRXGA6oBFXao6zomzzpClGAshArFMVL2hJV1Pgw3TGpp5nB + IkguVSNXtXhTVshqAnDc6hMhuPUh7VXvByCygxx0Dr4buE4ISIqVGnDAviVYghTgQNIQNCUBAGZpgRUJ + EUUmwA/7nU/B3Dq6FcTAD3QEC6jD+lUFjNVmRQt1p/kwXq3Y7EgoRF5B+qYEHdKIryPwQxOE0BGgCMhC + fgDyXRCCqJxYRCGtNs0BVNOk/aSkagsxskQKABf1UMaJYVIKkW57yxwHaThmuZGca2ICaGGtKh+5XEG+ + 1Tc0EOZjCHnL0v90mLBWEWHLQkACwm2LEj7wQEUHFZRGrCugnCjXNGPwyXMn+pfncux1HbVMDreEz556 + Gzplosz4RroCUiuE0n+wtEvPoIEckMAHa8jOEbKqgBVwEiNgBfULAhSCFWzAjqgMQIB1wIAdKNWNGghA + rU/AgRgIgUYjrYEC9CiDIiR96SVoyFjBqq6gEIGkfAgBDFYwaa9WJeQDilpBrJeXvgHAQjTqwlMe0Csr + VMENT5hOEZLghvVdHHJec0xGsILluZgAVQ+zjUyagDy7zgUACGlK5ZykmzARD5i3RS0VaEQEI2hhD1dI + wkcbwHHJYQUswasfVPQzBGq+OyJZUJgVZiP/ID4U1jaighERqGCEJiBBYGIqMRGqkJIBFCgBa/FQNye+ + B9cFZiFO4J1YxgCbi3WTLdmskxOGsJfBOIEPcxMVEWxl8bxUJSQX4gMXfCL5isDsFOAC+AAKeu7nSGAH + GGC9IOA8tmoDOOAEYMDtriAPVKnWgODQRIwDJLAKaMCNSMABekCpmEoOSOANEoADwEoBkOBCcg4GcGp8 + 6GgCK1D6+iDDLgxlmoPu6ugCmsDBRAUn/ENa7CMo/ss0sgIJoq88AEsKFMRJ+sAD/COyLIr8umIBgItP + WqghXCcoqCIJ50L0Lg4r9OphZCO2+mMqpABqCK3E0uIJts80uo8qkCX2/2ajIGpjuZIvIYaiD64AWlrj + NY7n4jxgIcREtfCPWQrkbVppsiTLRaiF+OjC8ySDJ/jH27SD9ahCTM5DVKZgOBoACVAvKJ6EIcjjgu7M + wdbiCRIwvVzqA96ABPDgDwagKyTsBTagkyJw2CZQKcIECejIAFPgDJgqImKNqLxuv1IHOtyqBDbgBVaF + jvxAF0uAD3wJqjhgdKiDDzagBk5KNhzMRn7kXKBrRFZlDgNKO/xgCyiDLSTDYm6ECKBmOMBCPb4lMBpi + sUyjBRxOIOzizgArCwrkAGokKKzESMqE0AiiUiCjCuamRxIHDKygb/6gK4YgCi6uIWQsHwmDc7aNIf8O + IzoUQ0SAgzfApK6EoCfE5CR4rMdeowq6YM94xVZKhCgWijcoitDWJSHyB1qwCEEK4wD9cCACYzfWwidM + Rjf6wK2yAyvK6yHQ69L+4AwY4A86p9c2oOlqwNtWAAb2ywMJ4IsIY7xc4NWQkcCU8Q/sgL+qgjzGCw5g + 4O22kglgoAbE4CQgjDyGAitIKm/GqzBCAyuaIMq0og90by4W4Lm2pPYOoioIzZv6I4sO8zDkwyInB7CC + I7ywwoG00DR4oBO7ojYuhAhuw1wWgkRqYyW48SIuzgJMwwsCZSEuzoJY60ZM4ogEZCtO7kf4gJqKAPNy + gpqaYC/8aSHUyQ+UxzT/CsAk6G+LvrABnkI2ZEgyiiAnS2RJdOMLxcPvMMtO/OAqkCTQ/iIePWN4nqsl + nijSNGIhUgoDVooqXUoDkmJK6MgIuGAYofEF8OUEgsAJwFIGZGDpGmID6GAiFImpzoDofE6qTCoP/MCt + RKzufE0rL+AvFqw2bMXD3tGtpuMiWAhQGCJtyOM1NE8sJAAMr8Ak1OVfFCZktEJdbElhiGQq1mRFIMeB + bCMJbKchWgPgaCIAssN9ogP5DtPhwBBQpOZFHEchlnMulIDhckLJqqIKJohEzu8oHOY5/GMqbuYIPGQt + RghiSJJW9oAfGYtH/IImh+KjcCMhKBErPcI2+rD2/xSioaSlL5DkPACyChpAC7bGSBTCHqmAlVALjC7A + CLioRcwIjeRgjUigBH3uDBxGIRTgBCYqw14AjNwOJ2qA1wgACMKIAy60CU6gDmAzLdsojSAiB1ygjlLp + QmutBvbgUhFCUzmjD4CA1zwPpcJqVaYDUQOEC1NvNEFjO/qgQLzA8kzCgewQIaSMKBrgR0qiYNZs+opA + CJ40oBQCcbRja+4gALsABJQVIbYthxZi9uoUG/sgLUqC22YDTcWCAnqqRfbiOVqIOvpmDcpxC/bgaJLy + I35Igcx1ZwYjdOACDAgWAAokNEW0PA7zgabiCqIpglbFN0bHSS5icbSzVnpCUP9+Aj+UQobGxHG8Awl8 + w7gmKjD0ozXeZy6yIF3F50po5XYeJokOE8b4AA3WJErv7SABRShzJny4yWDEZDqarC1yxfQ+oiuiQExi + Qg9NgpoYogGYIAMKBDWq4zb4p1ycYAjJYAmGwB0RpSmEjCGSIFvlVSx+Igq4oDYgc1ZWC08Y1jQiYK/C + 81y6qUUC0gAwQsXadXQCTUmQpW7nQgDeQjrJaS0Ow86mUGnjFAJEpf7wT1tehPpQNjrEZwlQRtHacQvK + UADWJAGm80jqhGZRZVUoVsyM5CzU4xQFCygaAPlig9CIQwgySp9Mwg2EwAOyi/dWciD41jakpy3UaQmi + AAr/4pRCwuAijACFpFCBpqIBWCY0GkA/QOAlx4WLWMkwAm0IyjFnTYKLIkOwdAj8FmJvIMMJmnai0tax + qMskQrJGxFAspG2weK9fyA8b9awJNiNa8O8PBaICUnUuMgBtAZA2XOdQoKV+kemEmmRFkwQ2TAIvtCOL + bKYPRJf7IGYI++AqdkRwc9NihUJgKIN288qFuAy1HGQPrEAFcAInDFcsAEBJh4A7C6N0wIRUsnRCXMhB + RoLm+Ock+FYViaOChQKFVSAh5M7K7ND7eIQyXgwswqzkMkVjP6RYm6krjqA1FKLEDGMP1NGABwNB/Kd9 + ecMujIDcaNRHCUMjGpeYOIN8/1FLCk2zShQiAtbEBE6lIVjIIgrlo46TSIpFKS4RKz7TNALATDRx2STI + CLqlgzZ4XCbFCWTognClsATz3h5js5pjho+ihqHiFJ1jU/ZFyhRiec33IqRT9QJjSwClrqLDAMzkIoog + kecCB2AHShCFYJNLIHrCRuI0Cw6NRe7xiXbiCYrmgsAC+bYGkqcifZTCcYLENVnHj6ELAB/miDwPX/ji + SpKyo/QCKbWCCqSgCbJ3TXggLQQ4pNRUZmTDN5AFP/AEIAHRI0xigm7kEAtTFQUFBdakTXakTB+GCnWI + KPrCO2RCBaYABbR3LiIAirwFe9IGufqgAnr2gkZH/OrYYv+igJtCjwvuRSuOaw9weV7xqDvSGD/cDG1H + bzn4VyAIggj2JruQNuX4wAqOZPqCokWKYFvnAt2cBC42pF1vBUlkj18Wqgh2IngPBlmX0Ev74tr44GgC + zSNIJTosxIu3YyN3xF/uZlZWhXN+4hLtBFls7B77gmoGRDWigyALpPSWhiGkQitKwiRKjCR6gphQxkef + IldpRSC5MShkyDaUxEaO4JgKJABw5Unk90ZW4jcJI59B5WdtY4zFgnnW5WHuOjrUIDT4rEAWAAnEhCmQ + Zwh24jfBE7Cn4irE5ADW5A9mAKHxaUNeQwtw0wk+6rWSUmWkBjfqBBGJ6JqQRCdm4KH/aVhhoEW7tGRI + WkgyFkojpOA3zZFq7yQJ3sS5g5v+0AQgj2CEEKI1nrgtiuQjmGk8cmihWjJMigW5ViU4Ts5xTOQt07lh + m8IJhIAJFIgt9JCT92C6iyANGcJxINm5h2ibVqJTIGawj0CP1fkjvFhMQIr3tMe6S4c8DOAUgVosAsBF + 3AJRYCwKSqx0SKUFYjui/e7Zhgl7FiJLqDArCmIGCpj0wqdEoMBc+PtgtcIJOIdrqSZKEiWcowR27cQk + DgC5xWIBwBNFPgMjABIhBoOdNkUKm4ycfudEiCIVoaIlOAMJfNtLgQVfZneOA1BEPhY3H6aHaaIu+kAF + TgIsZOLZ/wolIfyJLfxWNgIEAgJafZADSpzCIxKn/HTDrcfEzoBiJPylL/cFKJgir0ji6GALlJN8PJSE + DfwjLUwbgcikWf3AA4qgCWQ8tmkACaDgLfJqxAUTUYxEPa4AyWvCAnhgCD5iJETFCLrgCFRGCnnjCaKA + DVj09o47theAdOa6lbkpn+fHbzudCJYXaxgiDCyOTgFxtfQpKPyWLbzpKXjA1V8dBIjUD64gQORqNB7N + RwVDCF6LCLJjdHB7Z57IQo6AoJrVNf1giZrAbm6lWx4AaYqgCJCvCqiAyfh8UAuCVI6InlRgZ/qSVAii + g0SOKfdZCFaiIVBA0mtiAZoiCa5Adf/K40yIIPRExJZX4iRfcDeMhzMGpFuOYKM55EbeVTaawsRjWwJA + YA3zQlFbMyC7AkGwgNuDFCh4C2KeFxi3sz64ALPnAg22Q0xkyAioANcbIiW8DQo2ivdawOcngnkQ+jls + tsSYIB51m52Q4CmVBCfM7AqOhRQTJyG8gw9mwCIlYg34YF56Gic6SK9Wb34c7rXChE8+S0mxggqGQMvh + Fp10x6U9zz98VyH0YFC8Zp7NrEeXl5684lwhBlcEc8Cp29vIdA8Ss8dQoCCOhvcYQgzcaSiKIys+3Q+e + kyFsZOtdpC/7gP4g5DDaIogDbSSGwOKPwguGnUmklwvhArwDrQL/HHguLCAB8oxl/KMJVtSHZoVPGqAC + sH4iMoDz3sKW3CLhbQYrfBcB4lRjCh7cvUlxzoLMkOc1dNMPDGBr1qLE0HDOuaTgQYAH4F4iSq8IriOh + J/t3AIIIHz9X/Azpo+SPwoUM/0A40qeBnz4H+xjxM7GKHz59Jvbp6IeInz0dQZK8coRIEowTOR7hw0fI + HiJC+tRsCXMPRiNDmGAs0DDogJAYOzoZ2ecJxj0D+0z5iJFj0z5J+kj1AyCo1qF+IBbhs0SnB6hRrW6x + WqSjSJ0dm0Dp04QjSS4dkwwc6IfKEJEcN3YciEWrYIVeKBwYglHKxpYTJ+4REiHAYMELSJrs/2NZ55Ao + MP1cfEySz4LJWjPwQGG1D5GDSzg2WJK3Ao+EpBsC8FOlz0vYIPnkxrhy4BCOTmgPzoKxgRW8VqXyKdKy + DwgbJkwIoGC8dkMscpl0FAIT72IPYtj2gW7lC+ksJPfs8eAn7UaNOKPKbfB3eEeSB4tS9MiHTj6dBRMV + +/Xn0UgTZbeVY0Xx0cRGRqjm2UcClfRgH1VA0ZpaAmjnBQiqHTESUx/tYcBHTfmBhHt89XXEHk/sIdEe + B1XkxxLy+SWSbizRZ0QRDVCgXVBeSDAADyZggcUMTGLRwhpKeFEkQ0pYtRJGNA3ElBAKDocESBsNUQWD + RWZAwQLVLbkkFv88YFdlQyYopZNAQyABk5jwCdcUH2bGCSig7PVlkx9MxORTFBvVdFOPHP0ZaKRFUgBC + j3HxEYVOfVlh1URATQYBElUtNZBAIhmkxUYQsQQenhda5R1EWdUGAUZadKofiWkF18dRfNhFll8B8kHE + RUkoxgdiLM64EknLiTkQdBWYIWm1g2VQwUhJIPEWZisqqKJNOiXGRwJUWosuQ1zB5iVZXGLGkgEjSQVp + uugGAJVdSKG1GJ5+bBFVFN76Ua+99kqwooobMdWaH05cVLBDG53KUklTsIQYW/KJRMQeVBTxhFQ68QBi + AiR5+Wtz44JEhbB8PPHRE07EVGhoGIU5EBSWe0DhGRQ52adbr0IYQcO5BkvqxQE1cdQpRzj35gQTPsmk + mpgHHG1tAEt5J0RaVkkRmqYdfQVuxFhXGQAVeHXwoBMUWhVhH2cxNapOZp8dqQl7pNFigKt95JMfEvGh + HqhDpETSgxMRAdJBXSBhBBEhd0wEETqOgNFwA81KWgADyTTREhNiRHUSwEYEEhMNuP0ReK2H2TV0/wQF + KPhEZEOVmxMyFXGA0XiDOAOLnXnpGM7j8hEGFWAz5bCWfiRB8u9oR+cR4yWdyBxLjfkpfbUBFBF3UizN + 5KBnn/8F1UB3d1+k50eAt5Ju7r3FRwPqkzbA4Ww1tpRfLAsRhShsYUIWGtNHftOH6JHGCyuCEBM4AxMk + 7GRFNeqDT4xwlz4hQYLnuVBBMGMVIeDHLwf5YEtmwDn2acUMNIiCBMHClI4JziYUEY9/qrKHKRCLIn2I + gAVUOBh8NeZ6lqEQilAGLotADIhxgkDrkhAWq5DkIvOyT7cYV5XOrI+JgynAXf6iEY4UIS1fQQj+SkKo + qCwGKh8ZwoRCg5iPXP+kM83pQwoHcwAVFeQl76vYHo5QBCr6QSmkYsNErGA7f20ECm4TAhSoIBA/RKgv + L9sPUvhQgS0eTQIVwOD4OoJBizymIzzDE0y6sJGB4GkISSARHw5wRyaOAV7Pa4lOpjgREn0EdX3gIEY0 + yT4AYKFq41Mb4zwyE7yEp3ody1ThuCipAlRsfIvxSJCeKRgnkgWDpxrWLifShNR8i3yk48gSkmAC7QyT + KahEykackBY6SoRFYsPQv5YAHp1owTsYas2dUMeSDLpkKRCAphcWUM34FCVGmZPLXxzGyo7Yb5df9MAe + KiABaALABNCBDR8u0ocwfEQFaSwJ8XJyqk9BUzD/FMjWTfpwBUpiBDof8RmpOoMXI1QFmCtdSAE+EoV2 + LeYKSbDRuFQqmKEcryRMMacUkPCACh3TD6DzD2Ya5hFsCiYBAWoPSeyXyqsg0ggmShARfXmzsUnSkgIT + IdMkqT0dkmQGWv2dBBLwkSYMaH8cIasnQ+gHznjrRn6h6mOoOpEIxBJvLcWPXJhXy43Y5Qkvcc5AFNMR + n/D0bAHg6hCGsIcwSTE1ibNKbnLzUHg9lGA9jRTCNLUUFVHyUWecoGdKtD+MXKEPyxEPVKRwuKgkoSZU + cEJgJiNEUXXFgkz7i0R6+ZLmeORE7rmLfxZzhC6Ij6op6c0uV+aYNipWekrA/0JFvjYVzDAlDGa9ggzd + Q5amGqWXh/1OFnyHtc5ihgsHgRlI/msQiPwxs9/5Cx/GMobWEoYCCWDc4YjlhqLsiw9nWcwWuIQRJzBP + KvgZgIIBJQAtRKhHBulM/AaowK1ORYJWlS4VaQaeBHWBREvhS1L6QCTBYOuyHpmZd277vFQRBDMiZEui + xuU1fW2kCEeQgtysgoQjWBRc23srrgCTUYN5IQAHSBYrWyK65YqtCEtQ0RFGYL2isIUPiPQbhBKKBCIc + gQcZOJoFcEADoR7hICMssfbI1JHoLu+lQYoPUoEIAApEQAUZ9o1RUPktijSgiBd+a8fEU7+NZPnDtcmA + hv/U4pFUCZUJIfNDjoNiAR4I4VAcWdoXweZkI7RmCnFbzEC2oEv3zCxAPgFBnYNihjhoiwlN0IjbAse0 + JIC2C7udiP2Yo6ixSbckX/Fkyvjg5ARtBGd3gc1MFwMCHmw6UAAIQATaY5AlQwi+Mapc/SzYKU7ZhA8v + 7A0iv6mTLJUkTElIwALqWqVERwA/GgrnJ4sS0TD0CSor+4tl+sUDav3OC0pAUgQSEKNOBfSYDfwIEp6l + UKYJlKxV603EOT0ZCYCgYn3ai5fCuYQmrKQLWAiA0RLN1RxdSHsfLYKTy6yhEu3SCKDrWGmbAxaJgGDc + AFgAtj/SrHuL6XobaZlHiBf/kjracGG3TN9GJILZ8+RStZ8NsJmnaoIFYGexhKl4Fi4+RIxM4ZYtefFU + AjT1sPrhKRmqUE1aqZYTdUUu9MbCAgKgBLb/wQsFsDgN8COSG9HRR+H0UuIm0h9vpuZ5lKQKWb0mHiM4 + OSaDFzwYMEPjZA3ElY1hqMjg5ujBumeepEOjLRfGJdh+RIdewlNu6W7wsFo383zwSWogIvo5sri0z/Ek + Vb0lnq6PjornAc9mYgsVxvVpwBieiKISR7sjlPkuPbKK2yQcJtzSgEkHqAI/n9IHMnCBWGp8AhP2MKEi + wBY6OimzQSCLEc8CBVfQBF1QaKm3d2qlS58RFTT1HJ3R/wQA2BKs1ABVQCL5hBMq8wRkRTN7UARFlW8d + UWZVcBCrNxxC0E0TQWyCswQws0z7I19SZ3uNpExrpBnDsjLEwhFgEBPvsgc+IR8YNBxLRmMkoQYYYhVH + 4FiGsm1/cQWgcxRFRBQaVwWo1QCjk1l98UaD5HAwhRd2IWdFkCqEQn9FAQXg0Se2toGoVUWDtwVCwGJ+ + sRK3Q4Zq1DIjVFQ5ESC+x1tqFhKRhBbH1AVH8YZllRJxV3z88RxpAV+jo0O+cRFPIAS6VEMQUgV5Iltx + sQcr4TPuoTyY5lWgxgUe2BdqRFFcQjN4ZyAKEhpCgFpix0qaUhPu1S5FMBxMgBg+8f8rcjYS1uMlgxNj + FGEiA8Q/1+No1QSDHYEj/NcbCbNmaERL+0EoXbg9gWU7YHBJpbgHKtARCPRfbeQau1QFbkNTIcFBWQJf + ygISSKCLfBBd/tMUQvAEE2V2xZJxFlEhLDIET8COYgMh0BFPttMcykIUgLhhICQVVHF7rLgafpEWeKJD + DWMjC/MREoFBS4AYMrGJe1AF3SR4ysgEMdYl9kE7FjFvcLEE96d/sCEGAGN79ydaIXE8tQYWySJhb+N9 + EyIcFSNHUWEzVsE4mXEimBGUamVr1ch99bRGLMEzE5JFu0QENNUHBoBB7qgiSOABPKZm1CZhGRE4M3Ue + PoMXJIH/BEL1EYjEc+mGEZcyL15IPCBRE5JHkrt0K2KSZmzxTxqXln3ABa4jYB5RRv6CJYwTMl2FgqWI + hFABMPXhfalhP5xhP/GjGlNTXUN5W1ABMyzWRtDRMji0OjtEjUcRgK3RIh9hQhNxMQw3lCA1UzYEQo1h + HpimPWlBBqmyB3HTFJfXGMpiIunjjs0TLmwhExyhEgplEnbRZh8hBmVBj77ZVH6AWTo0EmU2OpIkmqY4 + b0HCPCVIhjWRkvnGfL+pIFZAY2LCBcBxk+fhNarhLy8xEkJAa+8mYFV5HlfhHj1RFFUgQWzwXGoEHTDB + Ove2KhwBWufDNGQAU0ZQBhIWExVI/xExlUp2ASE4Yn6k1xRakAaiF1mOoX9+0Jf4MRzzdB66URO5MRyM + 0wD4IRFIsCEH1ActYyJMQSAPkkMBchE8MzQNEAbURwRcsxSgVRKmAxJV0AAomIRDoDtU8JwNQCJBaXzY + dgNQYQUZ2Re7ZXnP0Zbb1opdkDgQ8Tm4B4LQh0aRtHdJoBfd9hxMxTRuoYT7sxfFZxA46R6ppCgSoRJO + YSPKOBC5ARNG4AEa5kYEaINkSTse8Hn41wdZKSZNUARQoBhMEUdDk6ZtlEq5UWZhwgTeNiEwQ0JrRCbv + NI98cAVlVlR8ChXhdJVaySpGgB8k0pv0tkud0gfetmclKEjw0v+QRMEUJPGK0Ok/IJQUfSUFn/NRbkUS + D9AXsHUTGcQo1HMEWXKr8TFSfaAzZdZnAaIRNUSQfMAzNWIF+BEa/KRxa7Y9cWM6ExGM1+Nwraeab8Rm + PvOfwyEwpJIRozSrvTSrVQEviCEXlzRhQNZLXfWiaUEmHxVa/mFdJTJdOik8LdMHUSBrSKB/rkM7O0Ot + skMR0BE49oQZ8uEazMEfI3FvGEYSAlEFPJGYaaUlmJh/RKeQg8QhA1lqsgpbY8KES3kXI0QW2NMXRMAt + X5Mf+FeZqaRxpTgxB+Y8hsKOEvacYYFhYTAzxNOjAUKhMPGfS/EEo6I9v/VdzMgYU2B139n/OApCVgaX + FlCQfvQ3LgmVTC5DdEewmF63PUvbAAKhSvGUaQ2XPkbQbKHBB3M3SBCxBK1xBBJ0LN/obQ6DrzUYoWxG + Enz3YsXIEoymhyBRfkLApUvJEmQzXaciW76qM1kyEIzGP0Y3ba7TLnARE8HxFRAYQK8nHrZ4tWGEehs2 + SRtxBfyXXq3jjqSHFIoST1DBM2kYq6wioWQxBEKlPTNjT91XBMYzXP1BIhdmETXRjSVhBBHiBP2BdGSF + WGk6EE/gAdHVG1KYITy0Iko4XZdlFVEgZApVWPpDQND5McAyEC3zgcvlB92SbmgoI3uBeyrwiDTzn91i + fD/YB11wEDvD/zypYnsKIq3V2BGcChE45D/CUxZG5XudMawmZQTe+JoNACyfF108MRFJYACTyIhMcztV + 0R9rexDWy6nJmhqXKDD/4b2F5bGCMy6QVQQ3gXkGYT/euR+dgiwjyjzICy7vVr3hwiLm5xeWalhF4TXt + 0TQjhBc8o1uq5QcjgI8QmFpUgVMBon8nmJDEGqdk2xepwhNSuI6nwrxXkSO14weoFJV9egQYxKKIMb4G + OxFXMIT9c3k9qZBN0YkweFhAynNyEUc/g3UVaxVzFB5egkE60QTu1ktDBIgwMRybmCfxEz9+e3nTKEVD + mDJE2z//9bNdwRawwXG3WWJqiyEnI2Evl3w9WjDIVJVBofMWnNoRuyUmVfl/EwxSo+WBanQqOusUOaEv + ++Oec8QbzjEvMmQRFGZdYPHEVYQgLdGJjFES/tcVi5EEpxcezxsFBDcSJWgZYWJ1qnETYGV8VYkp9vSW + BASjVLx6KsI43aRMNrMHzVaf0lhUGKEUnZcsfRAQADs= + + + + 17, 17 + + + + AAABAAMAMDAAAAEAIACoJQAANgAAACAgAAABACAAqBAAAN4lAAAQEAAAAQAgAGgEAACGNgAAKAAAADAA + AABgAAAAAQAgAAAAAACAJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1rs5Ati9Pj3WvDsUAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANi8OxLXuzZv1bgx0te5 + LP3Zvjt3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANW7NwPXvDk/17o3o9a4 + Lfbavi3/4sgw/+XMMf/ZvjHX2sA3BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYvDsV1rs3btS4 + MtHXuiz+3sMv/uTLMf/lzDH+5cwx/uXMMf/fxS/+2sE7RgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1rw6ONe6 + N6TVty3y2r4t/uLIMP/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/kyzH+1rw2qAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANi9 + PxfWvDhz17ot997DL//kyzH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/3cEv+NvD + QBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1bs3A9S8 + PULQukBY07k4o9W4L/Tbvy3+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+4skw/9i+OHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANa8 + QBTVuzl11Lcu1de5LP7Xuiz+3sIu/uTLMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/9m/NdnawDcDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANe7 + NwTWuzdB07g4qNW3K/favi3/4sgw/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XM + Mv/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/9/FL/7ZvzZDAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADZvkEZ1ro0cde5M9fXuiz+3sMv/+TLMf7lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXNMv/lzDH+5cwx/+TLMf7YvjiqAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA2r9BQNe4NafVty312r4t/+LIMP/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XM + Mf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XM + Mf/cwS/11L0+GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADexD4Q2bwv9t7DL//kyzH+5cwx/uXMMf/lzDH+5cwx/+XNMf7lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/+XMMf7iyTD+2r44eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgyDsC5c421uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/+XM + Mf7lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzTH+5cwx/+XMMf7lzDH+2r8x2tm/OwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA59A8deXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/+XMMf7lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/+XMMf7lzDH+38Uv/9vAPUQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA59FDE+bN + M/jlzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XM + Mf/lzDH/5cwx/+XMMf/lzDH/5cwy/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5Msx/9i9 + NqgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAOfPPqjlzDH+5cwx/uXMMf/lzDH+5cwx/+XMMf7lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/+XM + Mf7lzDH+5cwx/9zAL/XZwDsZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAOXPPEHmzDH+5cwx/uXMMf/lzDH+5cwx/+XMMf7lyzH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/+XMMf7lzDH+5cwx/+LJMP7XvDp1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTOPAPlzjnV5cwx/+XMMf/lzDH/5cwx/+XM + Mf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XM + Mf/lzDH/6ddW//Dkiv/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/avzXZ2cA6BAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlzzpx5cwx/uXM + Mf/lzDH+5cwx/+XMMf7lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwy/vbwtv/lzTT+5cwx/+XMMf7lzDH+5cwx/+XMMf7fxS/+2MA7QgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADm0D0Z5s0y9eXMMf/lzDH+5cwx/+XMMf7lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/x6JT+5s86/uXMMf/lzDH+5cwx/u3edf/s3W3+5cwx/+XMMf7lzDH+5cwx/+XM + Mf7kyzH+1744qQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA5c86puXMMf/lzDH/5cwx/+XMMf/lzTH/5cwx/+XMMf/lzDH/5cwx/+XM + Mf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/s22j/7+GA/+XMMf/lzDH/5cwx/+XMMv/n0D7/5cwx/+XM + Mf/lzDH/5cwx/+XMMf/lzDH/3MEv+NrBNxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5tA+QubMMf7lzDH+5cwx/+XMMf7lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzTL+9e6y/vPpn//y55j+7d50/uXN + M//n00j+8OSK/+XMMf7lzDH+5cwx/+XMMf7lzDH+4skw/9m/OHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5c49AebONNjlzDH+5cwx/+XM + Mf7lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/r22X+6dZU/uXMMf/lzDH+69pm/u7h + f//n0ED+8+qk/urXVv/n0D/+7Nxt/+XMMf7lzDH+5cwx/+XMMf7lzDH+5csx/9zEOsAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAObP + QHTlzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/p1lP/7d5z/+7hev/z65//69le/+XM + Mf/lzDH/5cwx//PrpP/w5Y//8umc/+XMMv/lzDH/5cwx/+XNM//lzTP/5cwx/+XMMf/lzDH/5Mox/+HJ + PoEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAOTPPRfmzTP15cwx/+XMMf7lzDL+5cwx/uXMMf/lzDH+7d9w/uXMMf/w5Ir+7+SC/u7h + dv/x6JX+8OSC/uXMMf/lzDH+5cwx/ujSRf/o00n+5cwx/uXMMf/lzDH+5cwx/+vbZv7s22T+5cwx/+XM + Mf7lzDH+5Msx/8+2ObfVvkBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkzzqn5cwx/+XMMf7lzDH+5cwx/uXMMf/lzDH+7+OG/vXv + sf/r3WX+8eeT/ubQPf/p1U3+5s86/uXMMf/lzDH+5cwx/uXMMf/lzDH+5c0z/ubPOP/n0kX+59FC/+7h + fP7r2F7+5cwx/+XMMf7lzDH+5cwx/9zBLv7Yuy712L84GQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADm0D1C5cwx/uXMMf/lzDH/5cwx/+XM + Mf/lzDH/5s86//Ttqf/v4oL/5csy/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/s3Gv/9e+y/+nW + VP/n0kP/9e6y//Xvt//07a3/5s88/+XMMf/lzDH/5cwx/+XMMf/iyTD/2L44dgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlzzsD5s431uXM + Mf7lzDH+5cwx/uXMMf/lzDH+5cwx/uXLMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/o0kj+8OSM/u/h + gP/x55P+7Nxq/vDkjP/mzzr+8uiZ/+jWUf7x5pH+7Ntm/+XMMf7lzDH+5cwx/+XMMf7lzDH+2r8z2dm/ + OAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA59A8c+XMMf7lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/p1lL+69pj/uXM + Mv/x5pH+6dVR/uvaZf/u4Xz+9/LA/ujUTv/m0Dv+5tA9//bxtf7x5pT+5c00/+XMMf7lzDH+5cwx/+XM + Mf7lzDH+38Uv/9m/N0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA6M9GGObNMvflzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzTT/5s01/+XO + Nv/177H/7uF+//Dljf/n0kb/8OWM/+XMM//y6JX/8OOI//Ttqv/z66T/5s85/+XMMf/lzDH/5cwx/+XM + Mf/lzDH/5cwx/+XMMf/lzDH/5Msx/9m+N6kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAObPQlDmzzvA5cwx/uXMMf/lzDH+5cwx/ujU + TP/28sD+9vG9/ufSQf/07KX+5cwx/vLpnf/n0UD+8+qg/ujTSP/y6Zj+5s46/ujSR//lzDH+5cwx/+XM + Mf7lzDH+5cwx/+XMMf7lzDH+5cwx/+XMMf7lzDH+5cwx/93CM+zcxD8FAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADn0D9Q5cwx/uXM + Mf/lzDH/5cwx/+vaYf/w5Ir/5s43/+XMM//y6Jr/6NRN//Djhv/p1lD/7Nxs//Djh//n0D//5cwx/+XM + Mf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XOOMMAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADmzz0H58834+XMMf/lzDH+5cwx/ubPO//28Ln+5c0z/u3fc//o1Ev+9Oyo/vHmkP/lzTT+5cwx/uXM + Mv/lzDH+5cwx/uXMMf/lzDH+5cwx/+XMMf7lzDH+5cwx/+XMMf7lzDH+5cwx/+XMMf7lzDH+5cwx/+XP + PFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA59A7geXMMf/lzDH+5cwx/uXMMf/v4oL+9e60/vXwuP/lzTX+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/+XMMf7lzDH+5cwx/+XMMf7lzDH+5cwx/+XM + Mf7lzDH+58813eXPOgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA59FBIubNMvzlzDH/5cwx/+XMMf/lzDH/59JE/+bO + Nv/lzDH/5cwy/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XM + Mf/lzDH/5cwx/+XMMf/lzDH/5tE+cgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOfPPLTlzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXNMf/lzDH+5cwx/uXMMf/lzDH+5cwx/+XM + Mf7lzDH+5cwx/+XMMf7lzDH+5cwx/+XMMf7nzjfu5s88EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTM + Pm7lzDH+5cwx/uXMMf/lzDH+5cwx/uXNMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/+XMMf7lzDH+5cwx/+XMMf7lzDH+5cwx/+XMMf7m0DyPAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAANrBOKjkyzH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzTH/5cwx/+XMMf/lzDH/5cwx/+XM + Mf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5s4y9efRPKPlzz0aAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAOHNPXTlzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/+XMMf7lzDH+5swy/ufPNtHo0D5u5M9AEgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTPPhnlzTP05cwx/uXMMf/lzDH+5cwx/uXM + Mf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/+bONPPlzzui5dFAP+fP + PQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADmzzun5cwx/+XM + Mf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+XMMf/lzDH/5cwx/+bNMf7o0DrU5dA9bubR + PRUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADlzz1A5cwx/eXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/lzDH+5cwx/uXMMf/nzjXy6NA8o+bQ + PTrmzzoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADmzj4D58842OXMMf/lzDH+5cwy/uXMMf/lzDH+5cwx/uXMMf/lzDH+58850OfR + PW7o0UATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5c87deXMMf/lzDH/5cwx/+XMMf/lzDH/5s4z9ebP + O6Hn0UE959A+AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5M88FebNM/jlzDH+5cwx/efP + ONPm0Dtt59JCEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAObQ + Opjm0Duk59FBPeXPPAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAObRPAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP///////wAA////+P//AAD////g//8AAP///wB//wAA///8AH//AAD///AAf/8AAP// + wAA//wAA//wAAD//AAD/8AAAH/8AAP+AAAAf/wAA/gAAAB//AAD4AAAAD/8AAPAAAAAP/wAA8AAAAAf/ + AAD4AAAAB/8AAPgAAAAH/wAA/AAAAAP/AAD8AAAAA/8AAPwAAAAB/wAA/gAAAAH/AAD+AAAAAf8AAP8A + AAAA/wAA/wAAAAD/AAD/AAAAAP8AAP+AAAAA/wAA/4AAAAB/AAD/wAAAAD8AAP/AAAAAPwAA/8AAAAAf + AAD/4AAAAB8AAP/gAAAAHwAA//AAAAAPAAD/+AAAAB8AAP/4AAAAHwAA//wAAAAfAAD//AAAAD8AAP/+ + AAAAPwAA//4AAAB/AAD//gAAAH8AAP/+AAAB/wAA//4AAAf/AAD//wAAP/8AAP//AAD//wAA//8AB/// + AAD//4Af//8AAP//gP///wAA///D////AAD//9////8AACgAAAAgAAAAQAAAAAEAIAAAAAAAgBAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADLrCQxzq0nVAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK+AIBDRtCtY27wrtt/DLPjawC/xyp8gGAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2sJy7Uti2I2b0t3efLMf/t0jP/6M8y/+7V + M//Uui1rAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGsIiXZuSuZ3sMs9+3SM//r0TL/5s4y/+bM + Mv/mzDL/7dQz/9vAL8lAQAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyqolMNS5LYPWuCyv2r4v8ezRMv/ozzL/5swy/+bM + Mv/mzDL/5swy/+bMMv/nzjL/58kx/M2wKj0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0pR4Rz7EqW9u6LLjbwSz47dEy/+3SM//ozzL/5swy/+bM + Mv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/x1jP/2L4snAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPKqiUw1bcrite9Ld/oyzH/7dIz/+fPMv/mzDL/5swy/+bM + Mv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+nQMv/cwi7syp8gGAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2botSuDGLfnt0jP/6dEy/+bOMv/mzDL/5swy/+bM + Mv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+7VM//Uui1rAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVxC8r5c4z9ufPMv/mzDL/5swy/+bM + Mv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/7dQz/9rA + L8pAQAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiyjGx8NYz/+bM + Mv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bM + Mv/nzjL/5ssu/dWuKzwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN/J + MFDt1DP/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bM + Mv/mzDH/5swy/+bMMv/x1jP/2L4snAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAuaIXC+TMMNnr0TL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5sww/+XN + MP/lyy//6tdP/+vZVv/lyy7/5swy/+nQMv/ewi7stZ8gGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAA3ckwgPLXNP/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+XN + MP/o00D/6NRH/+XLLv/nzzj/7uF1/+XNMP/mzDL/5swy/+7UM//UuitrAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXwy8m5csx9efOMv/mzDL/5swy/+bMMv/mzDL/5swy/+bM + Mv/mzDH/5csv/+fQO//w5Hv/6NND/+bPOP/n0Dz/59E//+bMMf/mzDL/7dQz/9vBL8mAVQAGAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiyjGx8NYz/+bMMv/mzDL/5swy/+bM + Mf/mzDH/5csv/+bPOP/q1kz/5cos/+3dZ//w5YD/8eaF/+jURP/s3GH/5csu/+bMMv/nzjL/48cx/M+1 + KzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN/JMFDt1DP/5swy/+bM + Mv/mzDH/5s83/+bONv/u4HD/8OV+//DkeP/lyy//5s42/+7hc//s3GL/5swy/+XLLv/o00T/5swy/+fP + Mv/hyC70y64uLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuaIXC+TN + Mdrr0TL/5swy/+XLL//q11H/8uiP//Dkff/r2ln/69dR/+bMMv/lyy//5csv/+bPOf/n0Dr/6NND/+7i + dv/lzTD/5swy/+bML/7XuCzXuKMpGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA38wxgfLXNP/mzDL/5swx/+bONv/t3mX/59A7/+XKLf/lyiz/5swx/+jTQf/r2VX/8eaH/+jU + Rv/x5of/8uqW/+rXUv/lyy//5s4y//HWM//UtytqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADXwy8m5c8v+OjQMv/mzDL/5swy/+XKLP/lyiz/5885/+vaWf/o1Eb/7uJ3/+7h + cv/y6pL/7Nxg/+vZVv/w5H//6NNE/+bLL//mzDL/7dQz/9vAL8lmMwAFAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiyzKT6tMw+OfOMv/mzDD/6NND/+3daf/s3GP/7uBw/+3d + aP/s3mX/7Nxi/+3fav/t4G7/5885/+bMMf/mzDD/5swy/+bMMv/mzjL/5swv/cutKzsAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADizDKv8NYz/+XLLf/t4G//7Nxg/+rW + TP/u4HH/7uBx/+vZVP/s3mT/5swy/+XLLv/mzDH/5swy/+bMMv/mzDL/5swy/+fOMv/oyzL72L8sNAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOHKMk3s0zP/5c0w/+jV + Sf/w5YP/7eBu/+rXUf/o1Ef/5csu/+XLLv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/7tUz/+LK + Mrj/AAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAs5kaCuHK + Mtfr0TL/5csv/+rVS//o00H/5csu/+XLL//mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bM + Mv/s0zP/4coyTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA4coxhvHXNP/mzDL/5csv/+bMMP/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bM + Mv/nzjL/9ts1/+HKMNOSkgAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADcwjGT8dc0/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+bM + Mv/r0TL/8tc0/+XLMfXr1DKx3McwOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAN3LLlPt0jP/5swy/+bMMv/mzDL/5swy/+bMMv/mzDL/5swy/+fO + Mv/w1TP/7dQz/+fPMdnmyjGD4cIrKgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuaIXC+TNMNrr0TL/5swy/+bMMv/mzDL/5swy/+vR + Mv/y1zT/5cwy9efOMrHmzTJSxLEnDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4ckwgPLXNP/mzDL/584y//DV + M//t1DP/5c8w2OfQL4HhyDEqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADRxC4n5c8v+PPa + NP/lyzH1584xseDLLlO/vxUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADiyjCU6NAzh+HIKyoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////5////wP///wD///wAf//gAH//AAB/+AA + AP/gAAD/4AAAf/AAAH/wAAB/8AAAP/gAAD/4AAAf/AAAH/wAAB/8AAAP/gAAD/4AAAf/AAAH/4AAB/+A + AAf/gAAP/8AAD//AAB//wAB//8AB///gD///4D////H///////8oAAAAEAAAACAAAAABACAAAAAAAEAE + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4BV + AAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxmyEX2r0tYeXJ + MMHdwClqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsywKC3bwS144sgv3uzR + M//z2TX/5skxy5+AAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHKqiAY2rstYeLHLbvnyzHx7dIz/+vR + M//mzDL/58wy/+vPMvvavC1EAAAAAAAAAAAAAAAAAAAAAAAAAAC/qhUM4sovxO7UM//u0jT/6M4z/+bM + Mv/mzDL/5swy/+bMMv/u1TT/4ccwoAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAejPM5vw1TT/5swy/+bM + Mv/mzDL/5swy/+bMMf/mzDP/6c8z/+XMMOvFtSkfAAAAAAAAAAAAAAAAAAAAAAAAAADhzC8869Ax+efM + Mv/mzDL/5swy/+bMMf/mzzj/59E+/+jTQv/u0jL/28ItcQAAAAAAAAAAAAAAAAAAAAAAAAAAqoAABujP + MMTt0jT/5swx/+bMMf/nzzr/6tdU/+zbXf/o00T/7dIy/+PJMMb/AAACAAAAAAAAAAAAAAAAAAAAAAAA + AADpzTBm7tQz/+fPOf/t3mb/7Ntd/+bON//q1lD/6tRH/+vVRv/kyi3v0rQoMwAAAAAAAAAAAAAAAAAA + AAAAAAAAzsQnGufOMObp0Tb/6NNC/+fRPv/q11D/7uFx/+3fa//q2Vn/8NUw/+HJL6QAAAACAAAAAAAA + AAAAAAAAAAAAAAAAAADpzjFo69Ev/uvZWP/t3Wf/7N5j/+rXU//n0Dz/5swx/+zRM//myzHWuaIXCwAA + AAAAAAAAAAAAAAAAAAAAAAAA0bkXC+fOL9Tu2Ur/6tRJ/+bMNP/lyy//5ssw/+jOMv/22zX/6M8whgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnzjGn7tQy/+bLMP/mzDL/69Az//DWNP/o0DH06NMxstW7 + Kx4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5MwvaPDWNP/u1DT/7dIz/+nNMdvnzjGI5csvMQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANi6Jxrq0DDZ7NMvueXOLlnZvyYUAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3MEsHf8AAAIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAP+fAAD+HwAA8A8AAIAPAACADwAAgAcAAMAHAADAAwAA4AMAAOAB + AADwAQAA8AMAAPgDAAD4DwAA+D8AAPz/AAA= + + + \ No newline at end of file diff --git a/installer/windows/CoderSetup/CoderSetup/Program.cs b/installer/windows/CoderSetup/CoderSetup/Program.cs new file mode 100644 index 00000000..996a46f0 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/Program.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows.Forms; + +namespace CoderSetup +{ + static class Program + { + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new FormMain()); + } + } +} diff --git a/installer/windows/CoderSetup/CoderSetup/Properties/AssemblyInfo.cs b/installer/windows/CoderSetup/CoderSetup/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..cf47b76a --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// La información general sobre un ensamblado se controla mediante el siguiente +// conjunto de atributos. Cambie estos atributos para modificar la información +// asociada con un ensamblado. +[assembly: AssemblyTitle("CoderSetup")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("CoderSetup")] +[assembly: AssemblyCopyright("Copyright © 2013")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Si establece ComVisible como false, los tipos de este ensamblado no estarán visibles +// para los componentes COM. Si necesita obtener acceso a un tipo de este ensamblado desde +// COM, establezca el atributo ComVisible como true en este tipo. +[assembly: ComVisible(false)] + +// El siguiente GUID sirve como identificador de typelib si este proyecto se expone a COM +[assembly: Guid("c80059d5-6412-42fd-abd8-a2d2741c3246")] + +// La información de versión de un ensamblado consta de los cuatro valores siguientes: +// +// Versión principal +// Versión secundaria +// Número de compilación +// Revisión +// +// Puede especificar todos los valores o establecer como predeterminados los números de compilación y de revisión +// mediante el carácter '*', como se muestra a continuación: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/installer/windows/CoderSetup/CoderSetup/Properties/Resources.Designer.cs b/installer/windows/CoderSetup/CoderSetup/Properties/Resources.Designer.cs new file mode 100644 index 00000000..4cf440d6 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/Properties/Resources.Designer.cs @@ -0,0 +1,73 @@ +//------------------------------------------------------------------------------ +// +// Este código fue generado por una herramienta. +// Versión de runtime:4.0.30319.18051 +// +// Los cambios en este archivo podrían causar un comportamiento incorrecto y se perderán si +// se vuelve a generar el código. +// +//------------------------------------------------------------------------------ + +namespace CoderSetup.Properties { + using System; + + + /// + /// Clase de recurso fuertemente tipado, para buscar cadenas traducidas, etc. + /// + // StronglyTypedResourceBuilder generó automáticamente esta clase + // a través de una herramienta como ResGen o Visual Studio. + // Para agregar o quitar un miembro, edite el archivo .ResX y, a continuación, vuelva a ejecutar ResGen + // con la opción /str o recompile su proyecto de VS. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.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() { + } + + /// + /// Devuelve la instancia de ResourceManager almacenada en caché utilizada por esta clase. + /// + [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("CoderSetup.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Reemplaza la propiedad CurrentUICulture del subproceso actual para todas las + /// búsquedas de recursos mediante esta clase de recurso fuertemente tipado. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Busca un recurso adaptado de tipo System.Byte[]. + /// + internal static byte[] usbit32 { + get { + object obj = ResourceManager.GetObject("usbit32", resourceCulture); + return ((byte[])(obj)); + } + } + } +} diff --git a/installer/windows/CoderSetup/CoderSetup/Properties/Resources.resx b/installer/windows/CoderSetup/CoderSetup/Properties/Resources.resx new file mode 100644 index 00000000..2489eb5d --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/Properties/Resources.resx @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\usbit32\usbit32.dll;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/installer/windows/CoderSetup/CoderSetup/Properties/Settings.Designer.cs b/installer/windows/CoderSetup/CoderSetup/Properties/Settings.Designer.cs new file mode 100644 index 00000000..ff65ff75 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.18051 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace CoderSetup.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/installer/windows/CoderSetup/CoderSetup/Properties/Settings.settings b/installer/windows/CoderSetup/CoderSetup/Properties/Settings.settings new file mode 100644 index 00000000..39645652 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/installer/windows/CoderSetup/CoderSetup/Usbit32.cs b/installer/windows/CoderSetup/CoderSetup/Usbit32.cs new file mode 100644 index 00000000..7249b452 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/Usbit32.cs @@ -0,0 +1,97 @@ +//USB Image Tool 1.57 +//COPYRIGHT 2006-2010 Alexander Beug +//http://www.alexpage.de + +//Decompiled from USB Image Tool Helper + +using System.Collections.Generic; + +namespace USB_Image_Tool_Helper +{ + using System; + using System.Runtime.InteropServices; + using System.Text; + + public class Usbit32 + { + public const int MAX_SIZE = 300; + public const uint MODE_PREPARING = 0; + public const uint MODE_READING = 1; + public const uint MODE_WRITING = 2; + public const uint REQ_VERSION_FAIL = 0; + public const uint REQ_VERSION_INIT = 0x3e8; + public const uint REQ_VERSION_TEST = 0x622; + public static uint version = 0x3e8; + public const int WM_DEVICECHANGE = 0x219; + + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool BackupVolume(uint device, string backupfile, string backupfilename, uint compression, bool physical, bool sizeignore, bool checksum, ref uint error); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool CancelOperation(uint device, ref uint error); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern uint CheckVersion(); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern uint CheckWindows(); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool ClearDevices(); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool FindDevices(); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool FindVolumes(); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool GetDeviceID(uint device, StringBuilder deviceid, uint size); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool GetDevicePath(uint device, StringBuilder devicepath, uint size); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern ulong GetDeviceSize(uint device); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern uint GetFirstDevice(bool physical); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool GetFriendlyName(uint device, StringBuilder friendlyname, uint size); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern uint GetLastErrorCode(uint device); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool GetLastErrorText(uint code, StringBuilder errtext, uint size); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern uint GetLocationInfo(uint device, StringBuilder locationinfo, uint size); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern uint GetNextDevice(bool physical); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern uint GetProgress(uint device); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern uint GetProgressMode(uint device); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool GetRunning(uint device); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern uint GetSerialNumber(uint device, StringBuilder serialnumber, uint size); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern ulong GetVolumeFree(uint device); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool GetVolumeFS(uint device, StringBuilder volumefs, uint size); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool GetVolumeName(uint device, StringBuilder volumename, uint size); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool GetVolumePath(uint device, StringBuilder volumepath, uint size); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern ulong GetVolumeSize(uint device); + [DllImport("usbit32.dll", CharSet=CharSet.Auto, SetLastError=true)] + public static extern bool RestoreVolume(uint device, string restorefile, uint compression, bool physical, bool sizeignore, bool trunc, ref uint error); + + // Some extra stuff ... + internal static List GetDevices() + { + var d = new List(); + ClearDevices(); + FindDevices(); + + for (var i = GetFirstDevice(true); i != 0; i = GetNextDevice(true)) + d.Add(i); + + return d; + } + + [DllImport("kernel32.dll")] + public static extern IntPtr LoadLibrary(string dllToLoad); + } +} + diff --git a/installer/windows/CoderSetup/CoderSetup/app.manifest b/installer/windows/CoderSetup/CoderSetup/app.manifest new file mode 100644 index 00000000..c856b7ea --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/app.manifest @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/installer/windows/CoderSetup/CoderSetup/bin/Release/CoderSetup.exe b/installer/windows/CoderSetup/CoderSetup/bin/Release/CoderSetup.exe new file mode 100644 index 00000000..1100a34f Binary files /dev/null and b/installer/windows/CoderSetup/CoderSetup/bin/Release/CoderSetup.exe differ diff --git a/installer/windows/CoderSetup/CoderSetup/codersd.ico b/installer/windows/CoderSetup/CoderSetup/codersd.ico new file mode 100644 index 00000000..985b1228 Binary files /dev/null and b/installer/windows/CoderSetup/CoderSetup/codersd.ico differ diff --git a/installer/windows/CoderSetup/CoderSetup/installerlogo.gif b/installer/windows/CoderSetup/CoderSetup/installerlogo.gif new file mode 100644 index 00000000..0b00f87d Binary files /dev/null and b/installer/windows/CoderSetup/CoderSetup/installerlogo.gif differ diff --git a/installer/windows/CoderSetup/CoderSetup/usbit32/license.txt b/installer/windows/CoderSetup/CoderSetup/usbit32/license.txt new file mode 100644 index 00000000..60a6decf --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/usbit32/license.txt @@ -0,0 +1,27 @@ +USB Image Tool 1.57 +Copyright (c) 2006-2010 Alexander Beug + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, publish, distribute and sublicense copies of the Software, and +to permit persons to whom the Software is furnished to do so, subject to the +following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software has to be distributed free of charge. Permission is granted to be +to distributed the Software together with, but not as a substantial part of, +magazines, software compilations or hardware products. + +Sublicenses shall not restrict or extend the rights or permissions of granted +by this license. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/installer/windows/CoderSetup/CoderSetup/usbit32/usbit32.dll b/installer/windows/CoderSetup/CoderSetup/usbit32/usbit32.dll new file mode 100644 index 00000000..7c26d621 Binary files /dev/null and b/installer/windows/CoderSetup/CoderSetup/usbit32/usbit32.dll differ diff --git a/installer/windows/CoderSetup/CoderSetup/usbit32/usbit32.txt b/installer/windows/CoderSetup/CoderSetup/usbit32/usbit32.txt new file mode 100644 index 00000000..97592652 --- /dev/null +++ b/installer/windows/CoderSetup/CoderSetup/usbit32/usbit32.txt @@ -0,0 +1,121 @@ +USB Image Tool 1.57 +COPYRIGHT 2006-2010 Alexander Beug +http://www.alexpage.de + +USB Image Tool can create images of USB flash drives and MP3 players, +that are mounted as USB drives. It allows you switch between images +with different music styles on your MP3 player or to make an exact +backup image of your USB flash drive. + +- create raw/compressed image files of USB drives +- restore images of USB drives +- show USB device information +- manage favorite USB images + +For USB Image Tool license see license.txt. + +USB Image Tool uses zlib/minizip compression routines. zlib by Jean-loup Gailly +and Mark Adler, minizip by Gilles Vollant. +------------------------------------------------------------------------------- + +USB Image Tool changelog +======================== + + +USB Image Tool 1.57 +- fixed: broken large zip files (using 64bit functions now) + +USB Image Tool 1.56 +- fixed: zip file compression (new zlib/minizip versions) + +USB Image Tool 1.55 +- fixed: error code 3 on Restore because of unknown file systems (atv-patchstick) +- fixed: error code 87 as a result of an invalid device image + +USB Image Tool 1.54 +- changed: Restore now allows shared read access on image file +- fixed: catch an exception for strange link open error + +USB Image Tool 1.53 +- added: truncate oversize images in device mode +- fixed: invalid characters in automatic file names +- changed: device mode is now default when available + +USB Image Tool 1.52 +- added: more detailed error messages + +USB Image Tool 1.51 +- fixed: invalid progress values caused GUI exception +- fixed: Remove favorites button was always disabled + +USB Image Tool 1.50 +- added: parallel operations on different flash drives +- added: progress information in command line utility +- added: show location information (Windows Vista or higher) +- added: optinal suggestion of the backup file name +- fixed: read errors due to wrong size information +- fixed: closing dialog had no effect on leaving the program +- fixed: show device serial number + +USB Image Tool 1.42 +- added: MD5 checksum creation + +USB Image Tool 1.41 +- fixed: "Error reading settings!" message + +USB Image Tool 1.40 +- fixed: compression routines for zip/imz files +- fixed: device mode without unplugging the device +- fixed: progress bar stopped to early on size differences +- added: compression routines for gzip files + +USB Image Tool 1.31 +- fixed: exception when device list focus was lost during file dialog +- fixed: restore of compressed images in device mode under Windows Vista +- added: check for corrupted zip files after backup is finished +- added: check for corrupted zip files before restore is performed + +USB Image Tool 1.30 +- added: device mode (supports bootable USB sticks) +- fixed: compressed file name resolving in command line utility + +USB Image Tool 1.28 +- added: command line utility +- fixed: 64bit compatibility + +USB Image Tool 1.27 +- fixed: Windows Vista UAC issues again + +USB Image Tool 1.26 +- fixed: activated Windows Vista UAC caused detection errors + +USB Image Tool 1.25 +- added: rescan for USB devices +- changed: unknown volumes are not shown anymore + +USB Image Tool 1.24 +- fixed: some more interface issues fixed +- fixed: size check based on partition size +- changed: Windows 2000 not supported anymore + +USB Image Tool 1.23 +- fixed: XZip 1.3 compression routines (bugfixes) +- fixed: device scan only when necessary +- fixed: Favorite Restore button was enabled during transfer + +USB Image Tool 1.22 +- fixed: device change caused errors during transfer operations +- fixed: progress bar did not move when compressing/decompressing +- added: serial number added to device information + +USB Image Tool 1.21 +- fixed: Windows Vista compatibility issues + +USB Image Tool 1.20 +- added: read/write compressed images + +USB Image Tool 1.11 +- fixed: button position when resizing + +USB Image Tool 1.10 +- added: favorite images management \ No newline at end of file