diff --git a/AgroBase/.vs/AgroBase/v16/.suo b/AgroBase/.vs/AgroBase/v16/.suo index 58fc1660d..fa7c09a6b 100644 Binary files a/AgroBase/.vs/AgroBase/v16/.suo and b/AgroBase/.vs/AgroBase/v16/.suo differ diff --git a/AgroBase/AgroBase/AgroBase.csproj b/AgroBase/AgroBase/AgroBase.csproj index a84a43c77..7527d1acb 100644 --- a/AgroBase/AgroBase/AgroBase.csproj +++ b/AgroBase/AgroBase/AgroBase.csproj @@ -156,6 +156,12 @@ + + Form + + + frmAtuConfig.cs + Form @@ -174,11 +180,11 @@ frmAcompanhamento.cs - + Form - - frmCamera.cs + + frmAtuCamera.cs Form @@ -216,6 +222,18 @@ frmMovPlot.cs + + Form + + + frmOperacaoSeguidorLinha.cs + + + Form + + + frmSenCamera.cs + Form @@ -224,14 +242,17 @@ + - + + + @@ -242,9 +263,15 @@ + + + + + frmAtuConfig.cs + frmDirConfig.cs @@ -254,8 +281,8 @@ frmAcompanhamento.cs - - frmCamera.cs + + frmAtuCamera.cs frmMapa.cs @@ -278,6 +305,12 @@ frmJoystick.cs + + frmOperacaoSeguidorLinha.cs + + + frmSenCamera.cs + frmSenConfig.cs @@ -349,6 +382,12 @@ Always + + Always + + + Always + Always diff --git a/AgroBase/AgroBase/Forms/frmCamera.Designer.cs b/AgroBase/AgroBase/Forms/Atuador/frmAtuCamera.Designer.cs similarity index 97% rename from AgroBase/AgroBase/Forms/frmCamera.Designer.cs rename to AgroBase/AgroBase/Forms/Atuador/frmAtuCamera.Designer.cs index d5b9ce9b7..d302a5857 100644 --- a/AgroBase/AgroBase/Forms/frmCamera.Designer.cs +++ b/AgroBase/AgroBase/Forms/Atuador/frmAtuCamera.Designer.cs @@ -1,7 +1,7 @@  namespace AgroBase.Forms { - partial class frmCamera + partial class frmAtuCamera { /// /// Required designer variable. @@ -114,7 +114,7 @@ namespace AgroBase.Forms this.cmbCameras.Size = new System.Drawing.Size(176, 24); this.cmbCameras.TabIndex = 0; // - // frmCamera + // frmAtuCamera // this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 16F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; @@ -122,9 +122,9 @@ namespace AgroBase.Forms this.Controls.Add(this.gpbCameras); this.Controls.Add(this.pnlLeituras); this.Controls.Add(this.pnlCamera); - this.Name = "frmCamera"; + this.Name = "frmAtuCamera"; this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; - this.Text = "Câmera"; + this.Text = "Identificação do solo"; this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.frmCamera_FormClosing); this.Load += new System.EventHandler(this.frmCamera_Load); this.gpbCameras.ResumeLayout(false); diff --git a/AgroBase/AgroBase/Forms/Atuador/frmAtuCamera.cs b/AgroBase/AgroBase/Forms/Atuador/frmAtuCamera.cs new file mode 100644 index 000000000..71dd249e7 --- /dev/null +++ b/AgroBase/AgroBase/Forms/Atuador/frmAtuCamera.cs @@ -0,0 +1,209 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Diagnostics; +using System.Drawing; +using System.IO; +using System.Linq; +using System.Management; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using AgroBase.Models; +using AgroBase.Services; +using CefSharp.WinForms; +using Emgu.CV; +using Emgu.CV.CvEnum; +using Emgu.CV.Structure; +using Newtonsoft.Json; + +namespace AgroBase.Forms +{ + public partial class frmAtuCamera : Form + { + private CameraService cameraService = new CameraService(); + private ChromiumWebBrowser chromiumWebBrowser = null; + private Timer tmrLeitura; + + private int MaxLeituras = 10; + private string VideoPorta = "8080"; + private string VideoUrl = "green_objects"; + private string SocketPorta = "6536"; + private string ArquivoLeitura = "objetos.json"; + + public frmAtuCamera() + { + InitializeComponent(); + } + + private void frmCamera_Load(object sender, EventArgs e) + { + AtualizaListaCameras(); + } + + private void frmCamera_FormClosing(object sender, FormClosingEventArgs e) + { + try + { + cameraService.socket.Disconnect(); + cameraService.pythonProcess.Kill(); + } + catch (Exception ex) + { + Console.WriteLine(ex.Message); + } + } + + private void TmrLeitura_Tick(object sender, EventArgs e) + { + ListarObjetosDetectados(); + } + + + + private void btnAtualizar_Click(object sender, EventArgs e) + { + AtualizaListaCameras(); + } + + private void btnSalvar_Click(object sender, EventArgs e) + { + if (btnSalvar.Text == "Editar") + { + btnSalvar.Text = "Salvar"; + } + else + { + btnSalvar.Text = "Editar"; + cameraService.selectedCamera = cmbCameras.SelectedIndex; + } + btnIniciar.Enabled = btnSalvar.Text == "Editar" && cmbCameras.SelectedIndex > 0; + cmbCameras.Enabled = btnSalvar.Text == "Salvar"; + } + + private void btnIniciar_Click(object sender, EventArgs e) + { + cameraService.ArquivoLeitura = ArquivoLeitura; + cameraService.IniciarCamera( + PythonService.ScriptGreenDetector, + new string[] { MaxLeituras.ToString(), VideoPorta, VideoUrl, ArquivoLeitura, "1", SocketPorta }, + VideoPorta, + VideoUrl, + SocketPorta + ); + + tmrLeitura = new Timer() { Interval = 200 }; + tmrLeitura.Tick += TmrLeitura_Tick; + tmrLeitura.Start(); + } + + + private void AtualizaListaCameras() + { + cameraService.selectedCamera = cmbCameras.SelectedIndex > 0 ? cmbCameras.SelectedIndex : 0; + cmbCameras.Items.Clear(); + cmbCameras.Items.AddRange(cameraService.AtualizaListaCameras().ToArray()); + if (cmbCameras.Items.Count == 1) + { + cameraService.selectedCamera = 0; + } + cmbCameras.SelectedIndex = cameraService.selectedCamera; + } + + private void ListarObjetosDetectados() + { + if (chromiumWebBrowser == null) + { + chromiumWebBrowser = new ChromiumWebBrowser(cameraService.URLcamera); + this.pnlCamera.Controls.Add(chromiumWebBrowser); + chromiumWebBrowser.Dock = DockStyle.Fill; + } + + this.pnlLeituras.Controls.Clear(); + int i = 0; + + //var coordenadas = cameraService.AferirDadosCamera(); + var leituras = cameraService.socket.DadosRecebidos.ToList().OrderByDescending(x => x.timestamp).Take(MaxLeituras).ToList(); + if (!leituras.Any()) + { + return; + } + + foreach (var objeto in leituras.FirstOrDefault().objetos) + { + GroupBox gpb = new GroupBox() + { + Name = "gpbLeitura" + i, + Size = new Size(120, 170), + Text = "Leitura " + (i + 1), + Location = new Point(3, 3 + (i * 190)) + }; + Label _lblID = new Label() + { + Name = "lblLeitura" + i + "ID", + Size = new Size(100, 20), + Text = "ID: " + objeto.id, + Location = new Point(6, 20) + }; + Label _lblDescricao = new Label() + { + Name = "lblLeitura" + i + "Descricao", + Size = new Size(100, 20), + Text = "Descrição: " + objeto.descricao, + Location = new Point(6, 40) + }; + Label _lblConfianca = new Label() + { + Name = "lblLeitura" + i + "Confianca", + Size = new Size(100, 20), + Text = "Confiança: " + (objeto.confianca * 100).ToString("0.00") + "%", + Location = new Point(6, 60) + }; + Label _lblX = new Label() + { + Name = "lblLeitura" + i + "X", + Size = new Size(100, 20), + Text = "X: " + objeto.x, + Location = new Point(6, 80) + }; + Label _lblY = new Label() + { + Name = "lblLeitura" + i + "Y", + Size = new Size(100, 20), + Text = "Y: " + objeto.y, + Location = new Point(6, 100) + }; + Label _lblAltura = new Label() + { + Name = "lblLeitura" + i + "Altura", + Size = new Size(100, 20), + Text = "Altura: " + objeto.altura, + Location = new Point(6, 120) + }; + Label _lblLargura = new Label() + { + Name = "lblLeitura" + i + "Largura", + Size = new Size(100, 20), + Text = "Largura: " + objeto.largura, + Location = new Point(6, 140) + }; + gpb.Controls.Add(_lblID); + gpb.Controls.Add(_lblDescricao); + gpb.Controls.Add(_lblConfianca); + gpb.Controls.Add(_lblX); + gpb.Controls.Add(_lblY); + gpb.Controls.Add(_lblAltura); + gpb.Controls.Add(_lblLargura); + + pnlLeituras.Controls.Add(gpb); + + i++; + } + + } + + } + + +} diff --git a/AgroBase/AgroBase/Forms/frmCamera.resx b/AgroBase/AgroBase/Forms/Atuador/frmAtuCamera.resx similarity index 100% rename from AgroBase/AgroBase/Forms/frmCamera.resx rename to AgroBase/AgroBase/Forms/Atuador/frmAtuCamera.resx diff --git a/AgroBase/AgroBase/Forms/Atuador/frmAtuConfig.Designer.cs b/AgroBase/AgroBase/Forms/Atuador/frmAtuConfig.Designer.cs new file mode 100644 index 000000000..58676c7c7 --- /dev/null +++ b/AgroBase/AgroBase/Forms/Atuador/frmAtuConfig.Designer.cs @@ -0,0 +1,588 @@ + +namespace AgroBase.Forms.Atuador +{ + partial class frmAtuConfig + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(frmAtuConfig)); + this.cmbGND1 = new System.Windows.Forms.ComboBox(); + this.cmb5V = new System.Windows.Forms.ComboBox(); + this.cmbGPIO14 = new System.Windows.Forms.ComboBox(); + this.cmbGND2 = new System.Windows.Forms.ComboBox(); + this.cmbGND3 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO19 = new System.Windows.Forms.ComboBox(); + this.btnSalvar = new System.Windows.Forms.Button(); + this.cmbGPIO20 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO21 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO47 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO48 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO45 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO0 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO35 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO36 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO37 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO38 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO39 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO40 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO41 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO42 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO2 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO1 = new System.Windows.Forms.ComboBox(); + this.cmbRX = new System.Windows.Forms.ComboBox(); + this.cmbTX = new System.Windows.Forms.ComboBox(); + this.cmbGND4 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO13 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO12 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO11 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO10 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO9 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO46 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO3 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO8 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO18 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO17 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO16 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO15 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO7 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO6 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO5 = new System.Windows.Forms.ComboBox(); + this.cmbGPIO4 = new System.Windows.Forms.ComboBox(); + this.cmbRst = new System.Windows.Forms.ComboBox(); + this.cmb3v3_2 = new System.Windows.Forms.ComboBox(); + this.cmb3v3_1 = new System.Windows.Forms.ComboBox(); + this.imgESP32 = new System.Windows.Forms.PictureBox(); + this.lblPinout = new System.Windows.Forms.Label(); + ((System.ComponentModel.ISupportInitialize)(this.imgESP32)).BeginInit(); + this.SuspendLayout(); + // + // cmbGND1 + // + this.cmbGND1.Enabled = false; + this.cmbGND1.FormattingEnabled = true; + this.cmbGND1.Location = new System.Drawing.Point(18, 719); + this.cmbGND1.Name = "cmbGND1"; + this.cmbGND1.Size = new System.Drawing.Size(148, 24); + this.cmbGND1.TabIndex = 179; + // + // cmb5V + // + this.cmb5V.Enabled = false; + this.cmb5V.FormattingEnabled = true; + this.cmb5V.Location = new System.Drawing.Point(18, 689); + this.cmb5V.Name = "cmb5V"; + this.cmb5V.Size = new System.Drawing.Size(148, 24); + this.cmb5V.TabIndex = 178; + // + // cmbGPIO14 + // + this.cmbGPIO14.FormattingEnabled = true; + this.cmbGPIO14.Location = new System.Drawing.Point(18, 659); + this.cmbGPIO14.Name = "cmbGPIO14"; + this.cmbGPIO14.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO14.TabIndex = 177; + // + // cmbGND2 + // + this.cmbGND2.Enabled = false; + this.cmbGND2.FormattingEnabled = true; + this.cmbGND2.Location = new System.Drawing.Point(584, 719); + this.cmbGND2.Name = "cmbGND2"; + this.cmbGND2.Size = new System.Drawing.Size(148, 24); + this.cmbGND2.TabIndex = 176; + // + // cmbGND3 + // + this.cmbGND3.Enabled = false; + this.cmbGND3.FormattingEnabled = true; + this.cmbGND3.Location = new System.Drawing.Point(584, 689); + this.cmbGND3.Name = "cmbGND3"; + this.cmbGND3.Size = new System.Drawing.Size(148, 24); + this.cmbGND3.TabIndex = 175; + // + // cmbGPIO19 + // + this.cmbGPIO19.FormattingEnabled = true; + this.cmbGPIO19.Location = new System.Drawing.Point(584, 659); + this.cmbGPIO19.Name = "cmbGPIO19"; + this.cmbGPIO19.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO19.TabIndex = 174; + // + // btnSalvar + // + this.btnSalvar.Location = new System.Drawing.Point(584, 786); + this.btnSalvar.Name = "btnSalvar"; + this.btnSalvar.Size = new System.Drawing.Size(148, 40); + this.btnSalvar.TabIndex = 173; + this.btnSalvar.Text = "Salvar"; + this.btnSalvar.UseVisualStyleBackColor = true; + this.btnSalvar.Click += new System.EventHandler(this.btnSalvar_Click); + // + // cmbGPIO20 + // + this.cmbGPIO20.FormattingEnabled = true; + this.cmbGPIO20.Location = new System.Drawing.Point(584, 629); + this.cmbGPIO20.Name = "cmbGPIO20"; + this.cmbGPIO20.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO20.TabIndex = 172; + // + // cmbGPIO21 + // + this.cmbGPIO21.FormattingEnabled = true; + this.cmbGPIO21.Location = new System.Drawing.Point(584, 599); + this.cmbGPIO21.Name = "cmbGPIO21"; + this.cmbGPIO21.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO21.TabIndex = 171; + // + // cmbGPIO47 + // + this.cmbGPIO47.FormattingEnabled = true; + this.cmbGPIO47.Location = new System.Drawing.Point(584, 569); + this.cmbGPIO47.Name = "cmbGPIO47"; + this.cmbGPIO47.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO47.TabIndex = 170; + // + // cmbGPIO48 + // + this.cmbGPIO48.FormattingEnabled = true; + this.cmbGPIO48.Location = new System.Drawing.Point(584, 539); + this.cmbGPIO48.Name = "cmbGPIO48"; + this.cmbGPIO48.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO48.TabIndex = 169; + // + // cmbGPIO45 + // + this.cmbGPIO45.FormattingEnabled = true; + this.cmbGPIO45.Location = new System.Drawing.Point(584, 509); + this.cmbGPIO45.Name = "cmbGPIO45"; + this.cmbGPIO45.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO45.TabIndex = 168; + // + // cmbGPIO0 + // + this.cmbGPIO0.FormattingEnabled = true; + this.cmbGPIO0.Location = new System.Drawing.Point(584, 479); + this.cmbGPIO0.Name = "cmbGPIO0"; + this.cmbGPIO0.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO0.TabIndex = 167; + // + // cmbGPIO35 + // + this.cmbGPIO35.FormattingEnabled = true; + this.cmbGPIO35.Location = new System.Drawing.Point(584, 449); + this.cmbGPIO35.Name = "cmbGPIO35"; + this.cmbGPIO35.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO35.TabIndex = 166; + // + // cmbGPIO36 + // + this.cmbGPIO36.FormattingEnabled = true; + this.cmbGPIO36.Location = new System.Drawing.Point(584, 419); + this.cmbGPIO36.Name = "cmbGPIO36"; + this.cmbGPIO36.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO36.TabIndex = 165; + // + // cmbGPIO37 + // + this.cmbGPIO37.FormattingEnabled = true; + this.cmbGPIO37.Location = new System.Drawing.Point(584, 389); + this.cmbGPIO37.Name = "cmbGPIO37"; + this.cmbGPIO37.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO37.TabIndex = 164; + // + // cmbGPIO38 + // + this.cmbGPIO38.FormattingEnabled = true; + this.cmbGPIO38.Location = new System.Drawing.Point(584, 359); + this.cmbGPIO38.Name = "cmbGPIO38"; + this.cmbGPIO38.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO38.TabIndex = 163; + // + // cmbGPIO39 + // + this.cmbGPIO39.FormattingEnabled = true; + this.cmbGPIO39.Location = new System.Drawing.Point(584, 329); + this.cmbGPIO39.Name = "cmbGPIO39"; + this.cmbGPIO39.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO39.TabIndex = 162; + // + // cmbGPIO40 + // + this.cmbGPIO40.FormattingEnabled = true; + this.cmbGPIO40.Location = new System.Drawing.Point(584, 299); + this.cmbGPIO40.Name = "cmbGPIO40"; + this.cmbGPIO40.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO40.TabIndex = 161; + // + // cmbGPIO41 + // + this.cmbGPIO41.FormattingEnabled = true; + this.cmbGPIO41.Location = new System.Drawing.Point(584, 269); + this.cmbGPIO41.Name = "cmbGPIO41"; + this.cmbGPIO41.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO41.TabIndex = 160; + // + // cmbGPIO42 + // + this.cmbGPIO42.FormattingEnabled = true; + this.cmbGPIO42.Location = new System.Drawing.Point(584, 239); + this.cmbGPIO42.Name = "cmbGPIO42"; + this.cmbGPIO42.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO42.TabIndex = 159; + // + // cmbGPIO2 + // + this.cmbGPIO2.FormattingEnabled = true; + this.cmbGPIO2.Location = new System.Drawing.Point(584, 209); + this.cmbGPIO2.Name = "cmbGPIO2"; + this.cmbGPIO2.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO2.TabIndex = 158; + // + // cmbGPIO1 + // + this.cmbGPIO1.FormattingEnabled = true; + this.cmbGPIO1.Location = new System.Drawing.Point(584, 179); + this.cmbGPIO1.Name = "cmbGPIO1"; + this.cmbGPIO1.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO1.TabIndex = 157; + // + // cmbRX + // + this.cmbRX.Enabled = false; + this.cmbRX.FormattingEnabled = true; + this.cmbRX.Location = new System.Drawing.Point(584, 149); + this.cmbRX.Name = "cmbRX"; + this.cmbRX.Size = new System.Drawing.Size(148, 24); + this.cmbRX.TabIndex = 156; + // + // cmbTX + // + this.cmbTX.Enabled = false; + this.cmbTX.FormattingEnabled = true; + this.cmbTX.Location = new System.Drawing.Point(584, 119); + this.cmbTX.Name = "cmbTX"; + this.cmbTX.Size = new System.Drawing.Size(148, 24); + this.cmbTX.TabIndex = 155; + // + // cmbGND4 + // + this.cmbGND4.Enabled = false; + this.cmbGND4.FormattingEnabled = true; + this.cmbGND4.Location = new System.Drawing.Point(584, 89); + this.cmbGND4.Name = "cmbGND4"; + this.cmbGND4.Size = new System.Drawing.Size(148, 24); + this.cmbGND4.TabIndex = 154; + // + // cmbGPIO13 + // + this.cmbGPIO13.FormattingEnabled = true; + this.cmbGPIO13.Location = new System.Drawing.Point(18, 629); + this.cmbGPIO13.Name = "cmbGPIO13"; + this.cmbGPIO13.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO13.TabIndex = 153; + // + // cmbGPIO12 + // + this.cmbGPIO12.FormattingEnabled = true; + this.cmbGPIO12.Location = new System.Drawing.Point(18, 599); + this.cmbGPIO12.Name = "cmbGPIO12"; + this.cmbGPIO12.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO12.TabIndex = 152; + // + // cmbGPIO11 + // + this.cmbGPIO11.FormattingEnabled = true; + this.cmbGPIO11.Location = new System.Drawing.Point(18, 569); + this.cmbGPIO11.Name = "cmbGPIO11"; + this.cmbGPIO11.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO11.TabIndex = 151; + // + // cmbGPIO10 + // + this.cmbGPIO10.FormattingEnabled = true; + this.cmbGPIO10.Location = new System.Drawing.Point(18, 539); + this.cmbGPIO10.Name = "cmbGPIO10"; + this.cmbGPIO10.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO10.TabIndex = 150; + // + // cmbGPIO9 + // + this.cmbGPIO9.FormattingEnabled = true; + this.cmbGPIO9.Location = new System.Drawing.Point(18, 509); + this.cmbGPIO9.Name = "cmbGPIO9"; + this.cmbGPIO9.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO9.TabIndex = 149; + // + // cmbGPIO46 + // + this.cmbGPIO46.FormattingEnabled = true; + this.cmbGPIO46.Location = new System.Drawing.Point(18, 479); + this.cmbGPIO46.Name = "cmbGPIO46"; + this.cmbGPIO46.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO46.TabIndex = 148; + // + // cmbGPIO3 + // + this.cmbGPIO3.FormattingEnabled = true; + this.cmbGPIO3.Location = new System.Drawing.Point(18, 449); + this.cmbGPIO3.Name = "cmbGPIO3"; + this.cmbGPIO3.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO3.TabIndex = 147; + // + // cmbGPIO8 + // + this.cmbGPIO8.FormattingEnabled = true; + this.cmbGPIO8.Location = new System.Drawing.Point(18, 419); + this.cmbGPIO8.Name = "cmbGPIO8"; + this.cmbGPIO8.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO8.TabIndex = 146; + // + // cmbGPIO18 + // + this.cmbGPIO18.FormattingEnabled = true; + this.cmbGPIO18.Location = new System.Drawing.Point(18, 389); + this.cmbGPIO18.Name = "cmbGPIO18"; + this.cmbGPIO18.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO18.TabIndex = 145; + // + // cmbGPIO17 + // + this.cmbGPIO17.FormattingEnabled = true; + this.cmbGPIO17.Location = new System.Drawing.Point(18, 359); + this.cmbGPIO17.Name = "cmbGPIO17"; + this.cmbGPIO17.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO17.TabIndex = 144; + // + // cmbGPIO16 + // + this.cmbGPIO16.FormattingEnabled = true; + this.cmbGPIO16.Location = new System.Drawing.Point(18, 329); + this.cmbGPIO16.Name = "cmbGPIO16"; + this.cmbGPIO16.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO16.TabIndex = 143; + // + // cmbGPIO15 + // + this.cmbGPIO15.FormattingEnabled = true; + this.cmbGPIO15.Location = new System.Drawing.Point(18, 299); + this.cmbGPIO15.Name = "cmbGPIO15"; + this.cmbGPIO15.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO15.TabIndex = 142; + // + // cmbGPIO7 + // + this.cmbGPIO7.FormattingEnabled = true; + this.cmbGPIO7.Location = new System.Drawing.Point(18, 269); + this.cmbGPIO7.Name = "cmbGPIO7"; + this.cmbGPIO7.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO7.TabIndex = 141; + // + // cmbGPIO6 + // + this.cmbGPIO6.FormattingEnabled = true; + this.cmbGPIO6.Location = new System.Drawing.Point(18, 239); + this.cmbGPIO6.Name = "cmbGPIO6"; + this.cmbGPIO6.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO6.TabIndex = 140; + // + // cmbGPIO5 + // + this.cmbGPIO5.FormattingEnabled = true; + this.cmbGPIO5.Location = new System.Drawing.Point(18, 209); + this.cmbGPIO5.Name = "cmbGPIO5"; + this.cmbGPIO5.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO5.TabIndex = 139; + // + // cmbGPIO4 + // + this.cmbGPIO4.FormattingEnabled = true; + this.cmbGPIO4.Location = new System.Drawing.Point(18, 179); + this.cmbGPIO4.Name = "cmbGPIO4"; + this.cmbGPIO4.Size = new System.Drawing.Size(148, 24); + this.cmbGPIO4.TabIndex = 138; + // + // cmbRst + // + this.cmbRst.Enabled = false; + this.cmbRst.FormattingEnabled = true; + this.cmbRst.Location = new System.Drawing.Point(18, 149); + this.cmbRst.Name = "cmbRst"; + this.cmbRst.Size = new System.Drawing.Size(148, 24); + this.cmbRst.TabIndex = 137; + // + // cmb3v3_2 + // + this.cmb3v3_2.Enabled = false; + this.cmb3v3_2.FormattingEnabled = true; + this.cmb3v3_2.Location = new System.Drawing.Point(18, 119); + this.cmb3v3_2.Name = "cmb3v3_2"; + this.cmb3v3_2.Size = new System.Drawing.Size(148, 24); + this.cmb3v3_2.TabIndex = 136; + // + // cmb3v3_1 + // + this.cmb3v3_1.Enabled = false; + this.cmb3v3_1.FormattingEnabled = true; + this.cmb3v3_1.Location = new System.Drawing.Point(18, 89); + this.cmb3v3_1.Name = "cmb3v3_1"; + this.cmb3v3_1.Size = new System.Drawing.Size(148, 24); + this.cmb3v3_1.TabIndex = 135; + // + // imgESP32 + // + this.imgESP32.Image = ((System.Drawing.Image)(resources.GetObject("imgESP32.Image"))); + this.imgESP32.Location = new System.Drawing.Point(172, -2); + this.imgESP32.Name = "imgESP32"; + this.imgESP32.Size = new System.Drawing.Size(406, 847); + this.imgESP32.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.imgESP32.TabIndex = 134; + this.imgESP32.TabStop = false; + // + // lblPinout + // + this.lblPinout.AutoSize = true; + this.lblPinout.Location = new System.Drawing.Point(15, 12); + this.lblPinout.Name = "lblPinout"; + this.lblPinout.Size = new System.Drawing.Size(48, 17); + this.lblPinout.TabIndex = 180; + this.lblPinout.Text = "Pinout"; + // + // frmAtuConfig + // + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 16F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.Color.White; + this.ClientSize = new System.Drawing.Size(1285, 838); + this.Controls.Add(this.lblPinout); + this.Controls.Add(this.cmbGND1); + this.Controls.Add(this.cmb5V); + this.Controls.Add(this.cmbGPIO14); + this.Controls.Add(this.cmbGND2); + this.Controls.Add(this.cmbGND3); + this.Controls.Add(this.cmbGPIO19); + this.Controls.Add(this.btnSalvar); + this.Controls.Add(this.cmbGPIO20); + this.Controls.Add(this.cmbGPIO21); + this.Controls.Add(this.cmbGPIO47); + this.Controls.Add(this.cmbGPIO48); + this.Controls.Add(this.cmbGPIO45); + this.Controls.Add(this.cmbGPIO0); + this.Controls.Add(this.cmbGPIO35); + this.Controls.Add(this.cmbGPIO36); + this.Controls.Add(this.cmbGPIO37); + this.Controls.Add(this.cmbGPIO38); + this.Controls.Add(this.cmbGPIO39); + this.Controls.Add(this.cmbGPIO40); + this.Controls.Add(this.cmbGPIO41); + this.Controls.Add(this.cmbGPIO42); + this.Controls.Add(this.cmbGPIO2); + this.Controls.Add(this.cmbGPIO1); + this.Controls.Add(this.cmbRX); + this.Controls.Add(this.cmbTX); + this.Controls.Add(this.cmbGND4); + this.Controls.Add(this.cmbGPIO13); + this.Controls.Add(this.cmbGPIO12); + this.Controls.Add(this.cmbGPIO11); + this.Controls.Add(this.cmbGPIO10); + this.Controls.Add(this.cmbGPIO9); + this.Controls.Add(this.cmbGPIO46); + this.Controls.Add(this.cmbGPIO3); + this.Controls.Add(this.cmbGPIO8); + this.Controls.Add(this.cmbGPIO18); + this.Controls.Add(this.cmbGPIO17); + this.Controls.Add(this.cmbGPIO16); + this.Controls.Add(this.cmbGPIO15); + this.Controls.Add(this.cmbGPIO7); + this.Controls.Add(this.cmbGPIO6); + this.Controls.Add(this.cmbGPIO5); + this.Controls.Add(this.cmbGPIO4); + this.Controls.Add(this.cmbRst); + this.Controls.Add(this.cmb3v3_2); + this.Controls.Add(this.cmb3v3_1); + this.Controls.Add(this.imgESP32); + this.Name = "frmAtuConfig"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Atuadores - Parametrização"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.frmAtuConfig_FormClosing); + this.Load += new System.EventHandler(this.frmAtuConfig_Load); + ((System.ComponentModel.ISupportInitialize)(this.imgESP32)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.ComboBox cmbGND1; + private System.Windows.Forms.ComboBox cmb5V; + private System.Windows.Forms.ComboBox cmbGPIO14; + private System.Windows.Forms.ComboBox cmbGND2; + private System.Windows.Forms.ComboBox cmbGND3; + private System.Windows.Forms.ComboBox cmbGPIO19; + private System.Windows.Forms.Button btnSalvar; + private System.Windows.Forms.ComboBox cmbGPIO20; + private System.Windows.Forms.ComboBox cmbGPIO21; + private System.Windows.Forms.ComboBox cmbGPIO47; + private System.Windows.Forms.ComboBox cmbGPIO48; + private System.Windows.Forms.ComboBox cmbGPIO45; + private System.Windows.Forms.ComboBox cmbGPIO0; + private System.Windows.Forms.ComboBox cmbGPIO35; + private System.Windows.Forms.ComboBox cmbGPIO36; + private System.Windows.Forms.ComboBox cmbGPIO37; + private System.Windows.Forms.ComboBox cmbGPIO38; + private System.Windows.Forms.ComboBox cmbGPIO39; + private System.Windows.Forms.ComboBox cmbGPIO40; + private System.Windows.Forms.ComboBox cmbGPIO41; + private System.Windows.Forms.ComboBox cmbGPIO42; + private System.Windows.Forms.ComboBox cmbGPIO2; + private System.Windows.Forms.ComboBox cmbGPIO1; + private System.Windows.Forms.ComboBox cmbRX; + private System.Windows.Forms.ComboBox cmbTX; + private System.Windows.Forms.ComboBox cmbGND4; + private System.Windows.Forms.ComboBox cmbGPIO13; + private System.Windows.Forms.ComboBox cmbGPIO12; + private System.Windows.Forms.ComboBox cmbGPIO11; + private System.Windows.Forms.ComboBox cmbGPIO10; + private System.Windows.Forms.ComboBox cmbGPIO9; + private System.Windows.Forms.ComboBox cmbGPIO46; + private System.Windows.Forms.ComboBox cmbGPIO3; + private System.Windows.Forms.ComboBox cmbGPIO8; + private System.Windows.Forms.ComboBox cmbGPIO18; + private System.Windows.Forms.ComboBox cmbGPIO17; + private System.Windows.Forms.ComboBox cmbGPIO16; + private System.Windows.Forms.ComboBox cmbGPIO15; + private System.Windows.Forms.ComboBox cmbGPIO7; + private System.Windows.Forms.ComboBox cmbGPIO6; + private System.Windows.Forms.ComboBox cmbGPIO5; + private System.Windows.Forms.ComboBox cmbGPIO4; + private System.Windows.Forms.ComboBox cmbRst; + private System.Windows.Forms.ComboBox cmb3v3_2; + private System.Windows.Forms.ComboBox cmb3v3_1; + private System.Windows.Forms.PictureBox imgESP32; + private System.Windows.Forms.Label lblPinout; + } +} \ No newline at end of file diff --git a/AgroBase/AgroBase/Forms/Atuador/frmAtuConfig.cs b/AgroBase/AgroBase/Forms/Atuador/frmAtuConfig.cs new file mode 100644 index 000000000..6369f206c --- /dev/null +++ b/AgroBase/AgroBase/Forms/Atuador/frmAtuConfig.cs @@ -0,0 +1,98 @@ +using AgroBase.Comum; +using AgroBase.Models; +using AgroBase.Models.Modules; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows.Forms; +using static AgroBase.Models.Enuns; + +namespace AgroBase.Forms.Atuador +{ + public partial class frmAtuConfig : Form + { + DispositivosService Disp = (DispositivosService)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Atu); + + public frmAtuConfig() + { + InitializeComponent(); + } + + private void frmAtuConfig_Load(object sender, EventArgs e) + { + if (Disp == null) + { + return; + } + + List Pinos = new List() + { + Enum.GetName(typeof(FuncoesPinout), FuncoesPinout.NaoConectado), + }; + + AtuadorModel.Funcoes.ForEach(x => Pinos.Add(Enum.GetName(typeof(FuncoesPinout), x))); + + foreach (var Sensor in Disp.Dados.BicosPulverizadores) + { + Sensor.Funcoes.ForEach(x => Pinos.Add(Sensor.ID + " " + Enum.GetName(typeof(FuncoesPinout), x))); + } + + List cmbs = this.Controls.OfType().Where(x => x.Name.Contains("cmbGPIO") && x.Enabled).ToList(); + foreach (var cmb in cmbs) + { + cmb.SelectedIndexChanged += Cmb_SelectedIndexChanged; + cmb.Items.Clear(); + Pinos.ForEach(x => cmb.Items.Add(x)); + int pino = int.Parse(cmb.Name.Replace("cmbGPIO", "")); + cmb.SelectedIndex = 0; + + var Selecionado = AtuadorModel.Pinout.FirstOrDefault(x => x.Pino == pino); + if (Selecionado != null) cmb.SelectedItem = (Selecionado.Funcao != FuncoesPinout.Geral ? Selecionado.ComponenteID + " " : "") + Enum.GetName(typeof(FuncoesPinout), Selecionado.Funcao); + } + } + + private void frmAtuConfig_FormClosing(object sender, FormClosingEventArgs e) + { + e.Cancel = true; + this.Visible = false; + } + + private void Cmb_SelectedIndexChanged(object sender, EventArgs e) + { + var cmb = (ComboBox)sender; + this.Controls.OfType().Where(x => x.Name != cmb.Name && x.SelectedItem != null && x.SelectedItem.ToString() == cmb.SelectedItem.ToString()).ToList().ForEach(x => x.SelectedIndex = 0); + } + + private void btnSalvar_Click(object sender, EventArgs e) + { + if (Disp == null) + { + return; + } + + AtuadorModel.Pinout.ForEach(x => + { + x.ComponenteID = ""; + x.Funcao = FuncoesPinout.NaoConectado; + }); + + List cmbs = this.Controls.OfType().Where(x => x.Enabled).ToList(); + foreach (var cmb in cmbs) + { + int pino = int.Parse(cmb.Name.Replace("cmbGPIO", "")); + string ComponenteID = cmb.SelectedItem.ToString().Split(' ').Length > 1 ? cmb.SelectedItem.ToString().Split(' ')[0] : ""; + FuncoesPinout Funcao = (FuncoesPinout)Enum.Parse(typeof(FuncoesPinout), ComponenteID != "" ? (cmb.SelectedItem.ToString().Split(' ')[1]) : cmb.SelectedItem.ToString()); + AtuadorModel.Pinout.FirstOrDefault(x => x.Pino == pino).Funcao = Funcao; + AtuadorModel.Pinout.FirstOrDefault(x => x.Pino == pino).ComponenteID = ComponenteID; + } + + Disp.Dados.SalvarPinout(AtuadorModel.Pinout, "pinout" + Enum.GetName(typeof(T_Code), Disp.Dispositivo) + ".pin"); + } + + } +} diff --git a/AgroBase/AgroBase/Forms/Atuador/frmAtuConfig.resx b/AgroBase/AgroBase/Forms/Atuador/frmAtuConfig.resx new file mode 100644 index 000000000..c505e9814 --- /dev/null +++ b/AgroBase/AgroBase/Forms/Atuador/frmAtuConfig.resx @@ -0,0 +1,991 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + /9j/4AAQSkZJRgABAQEAeAB4AAD/2wBDAAIBAQIBAQICAgICAgICAwUDAwMDAwYEBAMFBwYHBwcGBwcI + CQsJCAgKCAcHCg0KCgsMDAwMBwkODw0MDgsMDAz/2wBDAQICAgMDAwYDAwYMCAcIDAwMDAwMDAwMDAwM + DAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAz/wAARCAI+AQ4DASIAAhEBAxEB/8QA + HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIh + MUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW + V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG + x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQF + BgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAV + YnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE + hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq + 8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD9/KKKKACiiigAooooAKbJIsKFmZVVeSScAU6vDf8AgpbqE+k/ + sE/Fa5tZpLe4g0Cd45I2KshGOQRyKAPZl8Q6e3S+sz24mX/Gl/t+x/5/bT/v8v8AjX8hEPxi8X317FH/ + AMJNr26Yqo/0+Xqfxrul0D4hPDu/4TDUg393+0Jjj9aAP6vf7fsf+f20/wC/y/40f2/Y/wDP7af9/l/x + r+UD+wPiL/0OGpf+B03+NMn0f4iW8MkjeMNSIjRnwL+YZwM9zQB/WF/b9j/z+2n/AH+X/Gj+37H/AJ/b + T/v8v+NfyBD4zeLhkHxPr2VOD/p8n+NA+M3i4kD/AISfXeSBzfycfrQB/X7/AG/Y/wDP7af9/l/xo/t+ + x/5/bT/v8v8AjX8nFtp/xGntFm/4SrVArANzqEowD+NP/s34hf8AQ3aj/wCDOX/GgD+sT+37H/n9tP8A + v8v+NH9v2P8Az+2n/f5f8a/k8GkfERhx4s1I/wDcSlrk/FHxE8beEtYezufE+tGRQDlNQkIOfxoA/rv/ + ALfsf+f20/7/AC/40f2/Y/8AP7af9/l/xr+QIfGbxaf+Zn17/wADpP8AGum8Hat488a2TXFt4q1aONX2 + HzNQkBz+dAH9a/8Ab9j/AM/tp/3+X/Gj+37H/n9tP+/y/wCNfyhf8I98RM/8jjqI/wC3+b/Gj/hHviIf + +Zy1D/wPm/xoA/q9/t+x/wCf20/7/L/jR/b9j/z+2n/f5f8AGv5Qh4d+IjdPGWon/t/m/wAaP+Eb+In/ + AEOGpf8AgdP/AI0Af1e/2/Y/8/tp/wB/l/xp8OsWdxIEjureRm6KsgJP61/J7JoPxDQN/wAVlqGVUsR9 + vmzgfjXoX/BLT4peJtT/AOCjnwjsbrxFrNxbyeJIY5Y3vJGSQYbggnBH1oA/qIDZopqR7elOoAKKKKAC + iiigAooooAKKKKACiiigAooooAK8H/4Ke/8AKPz4tf8AYu3H9K94rwf/AIKe/wDKPz4tf9i7cf0oA/lS + 0qTy9Ys2/wCmkf8AMV678avE1/4f0ewazuHt2kdg20DngH+teQ6d/wAhWz/66R/zFeoftBf8gPTf+urf + +gigDhz8UNeA/wCQlP8ApXpnww1278RfD+5nvJmnl3SR7m642/8A168Uf7tev/BY4+Gd1/11l/8AQRQB + 46zb3Zv7xJooH9aKAPb/AIn69d+HfANrc2cxhmEsaggdin/1q82/4W/4g/5/m/75Fd98a/8AkmVr/wBd + ov8A0A143QB6l8HfiFq3iHxSbW8ummhaNn2lRwRXL/G7958Q7r/dX+VXvgH/AMjyP+uD1R+NX/JQ7z/d + X+QoA5WMYNewfA0lPBt6ynaysxBHY4NeQJ96vXvgd/yJd99W/kaAOGufilrzXEmdQk+8ewq94T+Imsah + 4lsoZb2Ro5JQrDA5FcjP/r5P94/zrU8Df8jfp/8A12WgD0b45eMdS8OXlitldSW6yIchQOcVwP8Awtfx + B/0Epv0rqv2jv+P7Tv8Acb+deZ0Ae1/BrxNfeIfDF5JeTefIkjKGYDIG2t//AIJULu/4KZ/CH/sZ4v8A + 2euR+AH/ACKN/wD9dW/9ArsP+CU//KTL4Qf9jPF/7PQB/VIBgUUUUAFFFFABRRRQAUUUUAFFFFABRRRQ + AUUUUAFeD/8ABT3/AJR+fFr/ALF24/pXvFeD/wDBT3/lH58Wv+xduP6UAfyo6d/yFbP/AK6R/wAxXqH7 + QhxoWm/9dW/9BWvL9O/5Ctn/ANdI/wCYr0/9oX/kA6b/ANdW/ktAHk5fIr2T4HW/2v4eTw52+ZM65xnA + IxmvGqnttSuLVNkVxNGrdQjkA0Aeov8As42rSMV1S4wWPBhHH45pD+zjCoz/AGlN7/IBXmY129Vsfarj + /v4acdavGX/j6uP+/hoA9Z+OkXk/D2KNX3eXcRgcdQFIzXjI6VPNf3NxB5Uk80katuCsxIFQYoA7b4CS + qvjrBZc+Q/eu38XfBe28Ya5NqD3s0LS4UqqggYHvXi1tPJZy+ZCzxvjG5Tg4qSXWb1h/x9XX/fxqAPUk + /ZxtN3/IUuP+/Y/xrpPDfgyPwJ4fureOeSZWVmLMMdq8HXVrwN/x93X/AH9alfVbxxj7Zdf9/TzQAy4L + LcSAjB3Hgj3rU8CNnxhp/wD12Wscnca1/Af/ACOGn/8AXYUAdr+0d/x/ad/uN/OvM69M/aO/4/tO/wBx + v515nQB638A22+Eb7/rs3/oFdd/wSmkJ/wCCmPwf/wCxni/k9ch8BP8AkUb7/rs3/oFdd/wSl/5SY/B/ + /sZ4v5PQB/VQpyKKRPu0tABRRRQAUUUUAFFFFABRQDmigAoziiq+q3n9naZcXGN3kxtJgd8DNAFjNFfz + cftRf8FxP2lfip8ePFU3h/x7J8PPDel6tdWOl6ZpljbynyopWj3yySoxZyVJ4wOelcIP+CuX7VUbfN8f + PFHToLCyH/tGp51sw16H9QVeD/8ABT3/AJR+fFr/ALF24/pX8+4/4K6/tUN0+PXiz8bGy/8AjNZXxA/4 + KU/tPfE7wPqWi658YPFeu+H9WhNteWj6faCO5jbqhZYgRn25olJRV5bBu7Lc+arK7jgv7eRsssbozAde + CM13nxl8baf4n0uwhsrjz2jYyPhcbAQBj61wculXCXnk/Z7gTEbhHsO7HrjrUn9hX3/Pndf9+W/wpU6k + Zx5ou6DVblWirX9hX3/Pndf9+W/wo/sK+/587r/vy3+FWBVzzS7jVn+wr7/nzuv+/Lf4Uf2Fff8APndf + 9+W/woArbjRuNWf7Cvv+fO6/78t/hR/YV9/z53X/AH5b/CgCtuNITmrX9hX3/Pndf9+W/wAKP7Cvv+fO + 6/78t/hQBVoq1/YV9/z53X/flv8ACj+wr7/nzuv+/Lf4UAVa2fh7C1x420yNMl3nUKAM5NUP7Cvv+fO6 + /wC/Lf4Va0aHVvD+r2t9aW95FdWcglibyW4YdO1ZVuf2b9n8VtPUqNrrm2PRf2q/Dl54c1bS0vI/K82I + sg67hmvJq7b4sfEjxR8Z9TtbrWreaSSzi8qIR27KqjqfxNcn/YV9/wA+d1/35b/CuTLfrf1dfXbe0622 + KxCpudqV7Hsn7M/gvUfEfgLVri0t3mjt5XL4HbZ61uf8Ep1C/wDBS34Qs3yBfE0ROT04evL/AIe/Ffxl + 8MdEvdP0k3UNnfA+apt2OOMZH4VlfDXxb4m8CePdO8R+G7y/03XtKuvPtL+CEPJbzDuAylc89CD1rHDV + MZCvU+tuKp3XJ39H+g6lODSdK7fU/sJSVGHysG+hpdwr+X6b/grH+1jp8irN8dPFcTsN217CyXP/AJBo + X/grn+1c4+X47eJm+lnZf/Ga9W5hGXNsf1A7hmkSVZPusG+lfy+yf8Fdv2rdrD/hfHiZW6cWdjkc/wDX + Gv1I/wCDfD/gp38SP2w9c8cfD34m3kPiDVPCun2+rWGtLEsE00Lv5LxTIuFZgyhgygfeb2wuZFa9j9PK + KKKoAoooLbaAPzzT/g6E/ZHx/wAjJ48/8IfVf/jNH/EUJ+yN/wBDJ48/8IfVf/jNfcJ+BngkH/kT/C+P + +wVB/wDE0v8AworwR/0J/hf/AMFUH/xNAHw7/wARQn7I3/QyePP/AAh9V/8AjNVdb/4Oev2Sb7RbyFPE + vjrfNC6LnwPquMlSB/yxr7s/4UV4I/6E/wAL/wDgqg/+Jqj4m+B3gqLw5qDL4P8AC6sLaQgjS4OPlP8A + s0XS1YH4I/8ABKT9jTwX+143jL4heJo/7W0OTX7ptOsXLwiZJJpJA7jhh8rD5eCOc19uXn/BNr4JXmny + Qv4B0tVZCm9Jpgy/Q76/P3/gnF+1D4i+BPxh+IGg6PZ6XqOk3et6jK2mzXS2sjMlzLt8jPBYDjHHAr6s + P/BWCf7JfNH4BmhSztoLp7q51OGO1jSY7UJfOOW7Dng1/Efizwb4l4riSriMnqT9hKzjyzsku1j9EyPM + Mnp4RU66XP1uj4M/4KCfsxab+yx+0DcaDo9xcTaXdQLd2ombc0at1XPcDpmvt/8A4JUWXh+T9iFW1SHR + 2um1Ofa1wkZkI85f73NfB/7c/wAR/FXxK/aAvtY8WLYJeX0UclnHZTedbpbEZj2N3BHevq7/AIJ2/sQ+ + Cfj1+yfD4h15td+3vqM0DLa6g0MO1ZQB8o7+9f0phcJj8Hwe6ObTftY0Xzyvd/Dq/VHxtSVH+0ObDLTm + VvvPZfCnhbw7q/8AwVa1SG307R7izh8GxOFjgjaNH3gZ4GM19WD4d6ASf+JJpfHX/RU/wr46/Zl+AHh/ + 9nP/AIKa61ofh1tQazk8JJPm8uTcSFjIM/Me1fU3xY1XUNP1fQ7exmvIxfSyrILeJXkYKoPGeOP8a6/D + GdGXDOE9hNzjyL3pbvzZpnEX9cnzK2ux0C/DrQHYgaLpRKjJ/wBFTgflTV+Hvh9lYjRdKwpwf9FTg/lX + G69fa9ZxWKtJrsdkEdp5o7ZGug+443KBwu3uAaq6t4+mNxpw0/XbyZZtOM8DR2m43ku7ABXsD9RivvTz + OVHeP8PfD6Lk6LpWP+vVPr6Uf8K88P4H/El0rkZH+ip/hXJeMdT1vQ9N03Vnurq1kmkt1uLYRKbSDLIr + iRvvcksAexxWtq1xqFj4+0yGz1SS8a8lLT2W1fJgtwDlyQMg5xgk8nt1oDlRsf8ACutA/wCgLpf/AICp + /hSf8K88P/8AQF0r/wABU/wrL8ReNJtb8Oamugm5+32ciRsPKKuFZsMUzwSAG/HFUvC+oXXibSdUs4Nc + 1aO8t1jLLdWyx3VtyPugjBD4IzjjPegOVHQj4d+Hz/zBdK/8BU/woPw+8Pj/AJguk9cf8eqf4Vzvgr4i + PZ+H7ptWuLiSS0v2tQrW5Nwi7UKiUKMBvmJz0IIrN8XfETVtPvNW0+1l/wBMWSG5tN0fWFlJIx3xsb6Z + oDlR2g+Hnh8n/kC6V/4Cp/hTh8OdBY4GiaXn/r1T/CuF8RfEq9vdAfULO9mtbKa/t7eKWCISOiMqlyBg + 5zu/MU7SfH+rahoOn20d8ztquotaW+oPDskEQ5LFem7ggUByo7b/AIV/4fP/ADBdJ9/9FTj9KB8PfD7D + /kC6T/4Cp/hXF+JvF+seAJrjTftzahJcJF9nvJ0Aki3vsO4AYOOvapfFOqa18OoZof7VbUBd2U0sTyRK + skMiLnIwMY+tAcqOvb4f+H0HOi6T/wCAqf4Up+HegKu7+xdKwOSfsqf4VwNh8Steuo9BgmHkyQzRRajN + twJy65Xb+HJruB4yGu6TfR6WxjvLVG+eeNgint25oDlRJP8ADnw+1tL/AMSXSvuHI+ypzx9K+Rv+Cc+j + +G4/g94sju7TRUkXxneBFlii3Igul6ZGQOMV9b+BNXutY8AWN5eMHubi0DysBwWI5r4F/Y5/Ya8EftA+ + DfFniLX5fEH9of8ACYXlti01JoItv2jaBtA6/N1+lfkvi9KhHL8NKvUcF7aGq73Vk/JnsZH7taTSv7r0 + ex45/wAFp4NPtv2o9IXS4bGG1bQYg4tVVYy4ll67eN2CK9i/4Jjf8E5vh/8AEX4FWvjbxppa+ILzXJHN + tbyTOkNtErFeikZYlT3xivnX/gqj8AdB/Zy+Pum6H4bbUn0+40eK6c3t01xJ5hklU4Y9sKOK6r/gn5/w + Up1z9n7wxb+BJ/D8viSxmvANMjgmCzxvKwBjAPBBbGPqa4fGLKOIsx4e9jw1Nxqppuzs3HsmLh3EYWli + 1PGK8fS9mfeXiP8A4JhfBDxTok9mvgawsHmUhZ7WaZZIWIOGXLEZB9QRXyV/wTH/AGsvhX/wSD/4KKfG + TS/id4jvtP019HTSdOnh0+a+e4K3fmglYVbb8hHJxzkV6X8bv+Cx6/CaJrG38K211rDb0XydTiuYbeVD + gpLsJIIPBHfB5rN/4N0vsf7Rv7fPxo1vxlpel+ILzVPDkWov9utUuFjlkvssVDg464+gr4TwC4d42wGI + xFXiWcnTaXKpS5te6Pa4nxeX1oR+ppedlY+0/wDiJh/ZFP8AzPmuf+EvqH/xqj/iJh/ZF/6HzXP/AAl9 + Q/8AjVfYq/s4fD0n/kR/CP8A4J7f/wCIpf8Ahm/4ff8AQj+EP/BNbf8AxFf1GfFnxz/xEw/si/8AQ+a5 + /wCEvqH/AMapG/4OYv2RQP8AkfNcP/cs34/9pV9j/wDDN/w+/wChH8If+Ca2/wDiKQ/s4/D1f+ZF8Ht9 + dFtv/iKAO2or83x+wx/wUG/6Ov8Ah/8A+ErJS/8ADDX/AAUG/wCjsPh//wCErJQB+j9Z/ilc+G9Q/wCv + aT/0A1+eP/DDn/BQZOv7V3w/b/uVZKp+IP2Jf+CgC6FeeZ+1R4CkjEDll/4RaT5htORQDPyq/Yu0HXLz + 9ovx5deGvDeseItbt9Z1IRQ2siR24DXUo/fMwPyHP8ODXuOvfsl/GC/+GGh6DqHgG5htNMu/tWoTWF3G + ZryJNxiiUNwAhYkA12//AAQq8W6boui/ETw5q+pWM3jZfEFy17OAI2v9s0qs6A87S+47R61+gc91DHC7 + NIqqoySx4H51/Gfib4+cS5FxDWyzL8OnTi0k3Fts+9yPhrA4nBxrVJWfU/Bf9q/xxqHjL4uzR6lo95od + 1o9vHp7Q3hBumEfAMhAAz9BjFfWX7Anw3+NHij9k/wC0eCfHGiaD4fbUJVS0urRpJBIJFBOQO7YNeT/8 + FcPGnh3xz+1rdTeH5bWb7LaJBezwOHWWZeoyOpHSvWv2Av2pfE3wo/ZTXSNL+GfiLxVZJqMsqXtkyCNm + MqsV57jpX9EYXOsXm3CLzGrDlqVKXNyvZNxvZ36X/A+Tr0IUcb7OL91SWq7XPVP2TfDHjzwn/wAFKdet + fiBr2m+ItYHhVCLm0gMaiMuNq4PpX2p4m8IWvio2rXElxG9k7PE8MmxlLDB59xXxh+yp8V9W+Mf/AAUq + 13VtW8K6p4OuD4USP7DflTIQrjDcdjX3HXoeHsa0eHsLHEJKXKr8trfK2mmw8zlGWLqcm1+pgSfDy1dF + /wBM1RWVSpcXJ3MDyQeKsaT4H0/RLuCa1iaNraAW0YB+VUB3dPr3rXor7Q4TB1n4d2PiDUWuLqS8kDSL + IYfOIiLLgg7fqAabF8NtPt9eutSikvYri8kEkwSYhXI6DHp7fWugooAp6vo0es6e1vI00asyvuifYwKn + I5rLh+HFjBBcKs19510VMlx5/wC+O05HzY6Z7dK6CigDO8N+GLXwrbSR2vmFp5jPLJI295XIAyx78AD6 + Co9T8H6fq3iGHVJ4N93BC9urf7Ldf0yPxrVooAw9K+HemaRo1vYwQsltazi4jXd0cHI5pt78OdLuxcfu + XjFxKJyI32+W4/iX0Nb1FAHPxfDXTPst3HMk9ybxQkkk0m6QgdMHtj2psPw002IS+d9qvGmhNuXuJTIw + Q9h6V0VFAGbe+GLK+t7SOSL5bJkeMjj5lGBmrV9p66hpklqxkSOQbW8tsNj61YooAyvD3he38IaM1raG + ZoQMASvv2j0Br86v2WPhx8bfFHhnxldeAfHOh6D4bHi68T7Fd2bSyeeJ8FgwHTJU49q/Sib/AI95f9w1 + +bf7Jf7VniT4P+GPF2jaV8MfEniyzbxfeTG/snQRBjcAlOecjAH41+YeKCrvBUPq8YyftIXUrWtdbX69 + j2MljB1pc7a917Hz3/wU78IeOfCfx+sLX4ga9p/iLWv7IieK5s4TFGsRdwFwR1BBrmP2Pv2ffiN8Q/HW + n+J/BPh2TVY/DOoQ3DyudkJZfm2bu/Tt0zXVf8FRPjDqvxk+P2m6rq/hPVPB1wujxwrZX5DSuokkO8Ed + jk/lX3b/AMEhvHXh3Vf2Q9K0vTri1i1bTZpjqdvuAkLs+VkI6kFSteb4vcb5hwpkizDK6HtJXtrqlfrb + sTkOV0sXivY1pWivxPlH9rH9h74keLPDWkzaH8PbzT7Hw3BP5qvdRT3E4dt/G0Asq4IGeetezf8ABrTZ + zWP7Z/xYimjkjmg8H20cqOu1o3F7yCPUYr7qvtWtdLsJrm5ube1t4kLPNO21EGOuT/nrX5v/ALFvgD4u + ftK/8FQvjlefs3/E/QPhrF/Z6z3dzfaa15FqELXZACBenz5bPvXxPgb4uZ1xZia+HzTDqCgk1JKy16an + pcS5BhMvjGdCfxdGz+gFWC9fpXnH7Xn7UPh79jf9nDxV8SvE0u3R/C9k126A4a4YfcjX/aZiAPc1+Z/7 + Zvw8/wCCgn7Fv7OPiT4ot+0H4P8AGdn4MhXUL3SbTw46zXFsrDzSpbj5UJY+ymn/APBUb9qfSP8Agp9o + /wCyT8F/A97FfQfHDU7Lxd4gt4JPM+y6TbIJJYpSvQibAP8A1yav6XPkz6B/4Jjf8Flda/bK+NV18O/i + b8NZvhP4u1HRI/FPhm2muzMut6W/IkBIBEgUhiozgZr7yuTIFHllQe+RXwr/AMFI/wDglb48/aX+N3wo + +JvwX8eaJ8LfHnwxt7iwhv7qxe4jmtJY/LEQRPQDGDxhjXA3X7DP/BQjYoX9q7wM2O48MSc0AfpYOKK+ + MR/wcJfsbkf8l28K/wDgNd//ABqj/iIU/Y3/AOi7+Ff/AAGu/wD41QB9nEZFZ/ikbPDOoH/p2k/9BNfI + P/EQp+xv/wBF38K/+A13/wDGqp67/wAHBn7HN5ol5Cvx28Ls0kDqoFtd8kqQP+WVTINtT8SP2U/BWm+P + P2h/GdjfzXFlJJq2qfZLqG4lt3ilF1MQFePoTgD5uK7nV/D1x4e+H1r4nvvEHiW603WJLawsbV9WnIa4 + yftJJUksqheg9a6b/glf+yNpf7WmrePPGlzrWpR+EZdcvFt0sZ2tzqIkuJHDFhzt2sD2619oD/gln8KZ + NIt7KG1163isyXtdmqy7beQ/xqM4B/nX878a+N/BmTZxLL8xoupVhZSfKml5Xe9j6zK+HcficP7WjK0e + iPyu/a4+HGk/Df4pR2+ht5mm32nwXsUnmtIHZx8xBcBuvZua+2/+CZ/7U3w5+EX7GUGj+JPFmk6Pqq6p + cTG2uHIkCGVSDwDxgV8f/wDBQf8AZ5vP2b/2hLnRZ9WutatpIlntbi5fdL5Z6KfoeK+2P+CW/wAG/Cfj + L9iCPUtY0HR9Qvv7Unj8+4gR5NomUYyeelfqGYZ1gs24Xq5hhHzUalKTVtHbl2XZ9EeH7CdHGRp1HqpK + /wB503wO+LXh34zf8FQ9a1bwrrFlrmmr4Rjjee1bKqyuMg9K+y9xr5C+FvgbR/Af/BUzWrTQ9NsNMsm8 + IRu8VpGqIXL9SF719eVz+F8qMuF8G8OpRjyLSW/zN84v9cqXd9RwY5p1RjrUlfoETzAoops8ywQOzMqq + qklicBeOv4daoB1FcP4P+POj+M9I1zUojLa6Vok3l/bZVxFcqAclfYY/UV4/4q/b+a11/ZpOkw3Wmrn9 + 7KxDSfQDoKAPpaadLeMvI6xqvVmOAKiXU7Z2wtxAxPQCQHNfPyftbeEfi14dm0XxJb32lxXRAaWJuAQc + ggjkc4rk/GP7NOp2Wl/2v4M8QSazYqDIix3BMqj8+ePxoA+si6gDkfN0wacDmvibwD+1T4t+GepfY75p + r23jfY8F6p8yP1weoP1r6q+Efxl0n4vaN9o0+ULNGAZrdj88J96AOvoozmigAooooAbN/wAe8v8AuGvg + z9hv9qj4dfCP4eeMNF8S+LNH0bWD4wu5ltbiQq5Q3AO7p6AmvvOb/j3l/wBw18U/8E//AIQ+D/Gnwm8X + X+vaBoeo6gPGd7Gs11bpJLsFyMDJ5xya/JfF94ZZZQWJUnF1qfw735la/l3PXyWN60l/dZ8l/wDBYT4v + +GPjP+0fo+peFNas9c0+LRI4WmtmLIriSTK5I7DH515T+yvr9jZa1rFvdwagzLpV3exyWl/Laspt7eSb + B2dclcV7N/wWZ8G6H4H/AGmdLs9D0+w020bRIZGjtYxGpYyygnA+gr07/gmr/wAE0vC3xa+EUPjjxdca + hctrXmLaWtrcNAscIYo25l5JYqwIPY17HHXGmS8OZS8bm8eam7JRte76LUyynA18bW9lhnaR4P8AFfR7 + uf8AZJ0zxcL3xYb7XLhbeazn1WWSOwiEsgFyVLZKTABF3DGVY9xX1B/waynz/wBsv4s9QP8AhD7Q49P9 + Mr2jxl/wSl+FvibwhdabbLr1k01ulujrqcjhET/VrtPBVTyAeK+av+CQv7Snwr/4JSf8FC/jNonxh8d6 + f4Utl0OLS9OuruORkvDHd7+BGrYbYVPNfM+GPinwzxNXqYbJaXs5xV2rJXXfQ6s6yXF4SKliZX+Z+9vi + XwpYeMfDd9pGp28d5p2pQPbXVvINyTxupVlYdwQSMV8n/sJ/8ETvgn/wTy+NWteO/BNjqk2tajBJaWTa + jdNcJolq772gtg33EJ447D61XsP+Dgf9jvUr2G3h+OvhdpriRYo1MVwu5mIAGTFjkkVX/wCC6n7W2sfs + xfsIX0PhO6a38dfEjULbwj4bKHEourttu9MfxJGHf/gNftB8+fY2jeItP8RRyNp99Z3ywtskNvMsgRvQ + 7ScH2NWJI8+tfin8MprT/g3J/bq+Hun+NPHGuzfB740eFyniLUdYuZbqPT9egUPJcqPmKq7nGAOFavuD + /iIT/Y4kX5fjn4Zb6QXX/wAaoA9oX/gnn8DQv/JKPAv/AIKYv8KT/h3h8DP+iUeBf/BTF/hXrHiTxFZe + D9AvtU1K4jtNP02B7q5nkO1IY0BZmJ6AAAmvgj9jj/g4R+H/AO1v+1PZfD0+DPE3hHRvFz3UfgjxPqci + /YvFrW7lZRGu0GM+gJbOQOCaAPp//h3h8DP+iUeBf/BTF/hVTxB/wT0+BsOg3zL8KfAu5YHIP9kxcfKf + avcAciqXiX/kXdQ/69pP/QTSaT3E1dWP51/+CZH7UOvfs6eN/iFoOm+FbnXvCTa7fPJDZvHHJp7Lcyqv + lqxG7KjG1eeBX13N/wAFS9HbRrW6i8D+KUXUmCWX2iS2tvPY8Dh3BUEjGSMV8F/sa+P9S8P/ABW8eaTp + Hh3UvEN9qXiW8bbaWome1jF3MHkUn7rgHg+tenfEr9mrxbffBrTbVvBvjLxB4g0u+hlgvLqyhhlsbZJC + zRqyOTJkdiOCa/n7jrwv8O8yzeWKzmpGFeVrpTUW35ruz6nLc6zOlh1HDxbiurVzwn9vb4n+KvjL+0Jf + a14q0uHRbnAit7JJ45mgiXoGKMee5zX01/wT9/YqsvjZ+yV/wkE3izxdpM02oyQfZbC8MVuAsoXIHqQc + /WvjH9ozXl8T/HPxFqRtb2xa4uyfs93GY5oSFVSrL2PFfZH7AE3x6b9lgD4fv4N/4Rdb6Ur/AGk5Fws3 + mjd0Q8Zx3r9PxuXYTL+G6uFytxjThSag9OVaaO/VdWzw/rEquL9rVWrkm/PU9U/Za+BFv+zz/wAFMtc0 + G21zWtcRvCSXJm1OXzZgS4wufSvuKvhr9leL4jP/AMFLdck+JR0P/hIW8KoANJJaAQhxjOQOfwr7lrDw + 7hVjw9hlWqKpLlV5R2fobZpb63UsrK4DrUlRjrUlfcROEK8h/ac8U3msXek+BdHkePUvET5uJEPzQWoy + GPHryPwNevDrzXz7aeLYbH4x/EbxxcL9oXwtbJYWyE4BZsgD8Sv5MfWqA9A8YeA/DejfB1vC8t9a6Hp8 + 0CwrJLIqsx4JbnqWxk/WvC5/2PNK1lfL8P8AjPS76TbhInZSzYHopz+leR+PfiFrHxH8QSXmqXUt1JM5 + KoP9XGDzhR+OBWLFJJpt4rxmS3ljPBGUK0Adx8Qv2bvFnw4Ekt5p73FlGcNPCN6r9R1H1NY3w7+LGtfD + LWkutNvJY1B+eFjuSQehHSux+GP7WXiLwLIsOoSf25puNjw3P7w7fQE12Hjv4O+H/jt4Ym8TeBtsN8i+ + ddad0IPcAev04NAF66s/Df7Xnh2S4tVt9I8ZWse9o/u/aAP5g/mDXjvhjxNrPwH+ITS7LizubOQJcwE/ + fX3HfNYHhrWNS8EeJ4bq0lltb2yl+YsNpUg8qR+mK97+KmiWH7SPwmXxlpsPl69pMflXsK9WC9frxyPy + oA+jfAfi+38e+E7PVrRg0N1EH4P3T3Fa9fPP7A3i+a88OaposrHZZzedED/CG6gfjX0NQAUUUUANm/1E + n+4a/N/9kb9imx+Ofhzxh4im8X+LtDm/4S68thbadd+XCcThd2PXnNfpBN/x7y/7hr81/wBlKP4+Dw/4 + s/4V3N4LXwy3i28JGplhOJftHPRTx071+W+KksVHA0PqtWNNurC/Ns1daLzZ6+Syarysr+6zwX/gqj8C + rf8AZ+/aA0vR7fWNY1xZtHjuTPqU3mzJukcbc+ny5x717J/wTD/bw1r4bfDS88I3HhPUfEWl+Hys0M9h + JGssCzEkIyuRv3MH2heeOleMf8FQYviNL8etNb4mHQW1z+yIhEdJYmHyfMk27sgfNnd09Kt/8E7NY8Q+ + HZfEEegeEdU8TzajeaezS20CuLKOIzeY25sBZB5gKYOeK9DjzhnI87yl4fiGypJp3b5bPun0ObKcVisN + X58KryZ9o+OP+Cvej+HvBV1q1r4F8UNCttHcxSziOOArMWWI7gTnLKRtAyNrZAxmvPP+CC3hPw3+25/w + UD+NGvfEfwzofiiS+8OwaikV/aLNFbSveYOwMOMAbfoK8j+NXwQ8bR/ssW/g0eCfGTW/h6QapaX7wBmn + uZWY3Eciqx2wxxtlCMncrH+OvZf+DV9vK/bC+K0bK6lfB9qCCen+nv179j1r5vwv4E4PySdWrw5JSk93 + z8zOzOsxzDExj9bTS6aH6Bf8FBv+COfwp/aT/Y98ceEPCXgHwn4c8U6lpznR9QtNOjhlt7tPniO4DIG8 + AHHYmvjD9lP4b/Hz/gpH+1D+z5pfxq+HOu+DPCf7L1l5+t3OqKPL8Sa1CPJhki/56fIoO4ZHzOc5IFfs + 4rbhXB/tKfH7w7+yx8D/ABJ8QfFdz9j0HwrYyX13JjLBVGcKO7E4AHqa/ZjwSz8VvgF4K+PNtaw+M/Cu + i+JobJjJbx6laJcCBiMEruBwcelcdJ/wT0+BjIqn4UeBf/BTD/hXhf8AwTN/4LPaD/wUO+IereEb7wN4 + i+GXii309Nd0rT9bkVm1vTJGxHdREKvUFTtwcA5ya+15FyBQB+U37Rf7LP8AwUs/aZ+BniTwFrPjL4B2 + ek+LbKTTL2Sx+029wsEgCvtbyjglSw49ah/4K1fsIf8ADIn/AASe+DOs+DbW1Pib9lO70nV4bu2jKm6S + LEd+3rtkLvMwPUqK/WBStc/8SfAWi/GHwFrPhjW7eHUdH1y1ksb22Y5EkcilWU/UZoA+B/8AgoJ/wVO+ + IFt/wzn4P/Zvk8M6p8QPjw8V/avqsRuLS305oN7TSBMlFDMMkZ2hW9KzNU8J/wDBT86JdPc+KP2a1h8l + zIq21yWC7TnH7r0r0f8A4J2f8EKfh7/wTv8AjXd+N9N8TeKvGmpWtnJpPhxNeuBNH4YsJHLvBbgDjOSN + 3HBI7nP2p4pP/FLaj/17Sf8AoJoB7H4e/wDBCe9sbfwj8RINXbTv+E8/4SG5OptCMh/30obysjPlmTce + npmv0AVlePbtU5PTbX8+en+Odf8AAfxh8SXnh3VNR0vUv+Eh1FI5bOdopMm8l4BUg19K/tBeKfit8H/g + R4b1a68ffEmTUtUuXtdU8+9nFnGSgdUQnrwcEkkZ4r+P/Er6NuY8RcQVs4wmNUY1HdqV7ryVunY++yri + zD4TCqhKnqu1jF/4K+XGgz/tg339jSW8ky28a35gxs80euP4sda9h/4J8/tpWPwM/ZS/sGbwV4019l1C + SY3OmWPmwkGQNgN68YNfA+oXcmpXslzcSSTTzNueR23M5Pcnua/T7/glr8X/AAX4N/Yqi07WvFHhzSdQ + XVZpGt73UYbeYL5wIO1mBxX71TyD+xeDZZXUk6rp0XF95Wjt89kfKTxTxGPVZu15L5alr9lP4/Q/tF/8 + FLdc1u10HXvDccfhJIHtdWt/Km+VxyB6H1r7kr4/+GHjPQfGn/BVbWLzw/q2m6xp7eD41E1hcpcQ794y + NyEj8K+wK28M1TXDWEVOk6a5V7r1a8ncvOP99qa31eoDrUlRjrUlffRPNBRlq+Z4fC83i7wT8YbC2jke + 8XVfO8tfvELhl475w1fTAfyzu/u814/4PDfD/wDav12zYqtr4wtEvoc8DzYyRj05y/6e1UB8e+HtcuPB + +vWeoRwq81lIsgjlXIJHVSP0r3W2/au8K/EmOGx8Z+FLVo5Pl8+3QMYyec8/MMex/wAK9F+LH7Gmh/ED + UJNQsZ5tJurpvMZY0DQyZ77eCpz36e1eB/Gb9l7WvgzYyahK8epaWrBXuLfkQE4A3AZ9evT+VAG58W/2 + YLey8ON4n8G3TapomN0kSNuaIeo6Egd8jOa4H4UfFPUPhH4wt9Ss3bywQk8O75Zo+4NdJ+zL8ap/hL4y + hs7qZptB1QiC6ic71jDH7wB+vOOtRftRfC6L4a/Em4SzRV03UP8AS7cr90Bj8yj6Hn8RQB1P7VfgC01j + TdP8eaFBs0/Vgq3CD+ByPvf0PuKwf2R/id/whfxHXTbpg2la5m2uI26bjwD+ddn+zFqP/Cyvg54o8HXk + gYW8Bnt9w3deoHpg4NfP1vM+ja2snKvaz5P/AAE0AfYn7Pnwev8A4Z/FXxVJ5O3R7hgbRweGBOcevHIr + 2asnwHq39veDNLvN24XVtHLnOeqitagAooooAbN/x7y/7hr82f2T/wBtzT/gX4Z8W+HZvBfjXXpm8X3k + /wBr0yx86Bf9IViucjnjFfpNN/x7y/7hr4j/AOCfXxe8F+Dvhb4wste8T+GtKvm8aXrC3vdRhgl2/aQc + 7WYHHB5r8n8WnS+oYf2tB1V7WGivo+Za6dEevkc5fWJKEuX3Xr+h8ef8FPfjxb/tCfHnT9Yg0TXtAWHS + Yrf7Nqtt5E3yySkMBk5B3da+8v8Agj5L4fm/Y10mDS1hGordXB1ILjcZTIcFu/3duD9a+Lv+CyvjbQvH + X7T+n3vh3VtI1i0TRIYmmsLmO4jVhJKSpKEgH6181/C/4s+JPhfraz6H4j1/QEmdVuH0y6aGRl3DOMHk + gfy/Cl4teHtfi7JP7NoV/ZSTTT6ejt2HkmZRwFf2rXMtT+gqSKOBWD7Qu0h9wyuMEnPbGB1PpX5p/sSa + d8b9c/4KffHT/hlHVPh3pv8AoQkvZPEsLtay2xuz/qfLRufOLYzj5cV8/wD7Ufx/+IGg+KLfSIPHnj68 + 8P6xoenakI9T1SSZmN1ZwzujngHa0jL07HOa+sv+DWG4aT9sn4rZbO7wdas3uRe9f1r4jwT8FcdwZia+ + KxeKVXnSVop2011ud/EXEEMwpwhCPLZntH7Wnx3/AOCkn7EnwC134oeJtQ+BGv8Ahzwii3mqWelWcz3T + WwYB2UNGo4ByeegNXv8Agsr+0dp/7ffwl/Zg+DfgfUEul/aQ13T9bvoYJdzLosKpcSh8cj52jU54+Rx2 + NfqD8QvAelfFHwPq3hzXLGDUtH1y0ksr22mXdHPDIpV1YehBNfFn/BPH/ggx8Nf+Cf3x/vPiDp/iLxZ4 + u1Gys5NK8Mwa5dedH4Ysncu0UH1yRuPOCe5JP9IHyhz/APwUa/4Jm/FzxZ+038HfjD+zbqXgfwv40+G2 + nz6HOutiSO1uLF4vLSPbGjb1UAjacY3ZzxWLN4L/AOCnkn3PFf7Oa+pEFz/8br9Io5kn+627HcDj86BH + jt+YoA+O/wBqX/gtt+zv8Ev2dvGXivw78ZvhX4t8QaFpM93pmj6Z4psrq51K5CHyoUjjkLNl9oOBwDX5 + 1/s/+IPjx/wTu1n9nP8Aah+JHxQ8S+JtA/aM1KOz+IGh6nc/8S/Rxfgy2MsEXSNVj5JGADtHQkV+lF1/ + wQ2/ZKuyvmfAX4fnYwZcWGMEcjoatf8ABWH9iGH9r/8A4JzeMPhn4f021h1OzsI7jw1bwwhY7W6tCsls + iKMBVBQKAOADigD3D4x/tIfD/wDZ28J22vfEDxt4X8FaLfTi3tr3XdUgsIJ5GBZUR5GUMxUE4HOAT2ry + bxF/wVh/ZfufD19DH+0N8F2lkgdVUeMtPyxKnA/1tfmZ8ItS8Z/8F4v2hvgF4F+I/wANfEug+A/gFYG8 + +JUOv6fJBb6prUKeQluucCQSbdxweBI3XHP6Eav/AMEPf2S7PQLx4/gP8P8AdHC7KxsckEKSOSaUtFcU + rtaH4z/8E/v2ANN/bc8VeNfFGpa3cW/hKz8QXywSaa6M+oM9zKylHIZQm0g7gDnIx1r7K1b/AII2/DjU + vCcWkf8ACQ+OGtIZWliV9SjZYnYY3bTFgn618i/8E2f28PD37FPiXxv4N17T7mPwjceIb02clmu86b5d + xKgTZnmMqAOORgV9ueJ/+CrPwx8E6DbalqmmeOrG1vk3Wclz4fuLdLzjI8tpAqtkcg5xjmv4i8VsX4o0 + uJKsMm9p9X05ORaW8/M/Rchp5LLBRliEubrfc/Lv9sH9mS7/AGT/AIzXnha4vP7Qt0UTWl0V2NNE3TcP + 7w6HHFfa3/BNL9lH4c/Fn9jBtb8T+EdF1jUm1GaEXNzAHl2LMoCg9cCvjP8AbZ/alf8Aa3+ON94nWxfT + 7FUFtYwSMGkSFehYgY3HqQK+p/8Agnn+yv4r+LX7KX9s6V8WvFHg+xbUJYxp1jGrQhhIoLAnnJPJr+ls + HLMv9Tb5zLlr+yfO+z5dX8tz4/Eex+v/ALhe5zKy+Z7D8DfhF4Z+CX/BUXWtH8K6PY6FpreEI5fs9snl + oWLjJx6mvsyvh39mH4S6z8Fv+Cl+s6TrfjDVfG143hVJf7RvxtlCs4+TA4wK+4q7PDdt8N4WUqvtbxXv + a6+evcebRti52VtdgHWpKjHWpK+6iecBGRXm/wC0V4BvvFXhuDUtFAXxB4dl+22J7ykDmP6HHTua9Ipr + puFUB80ftG/G/UPiL8E9K1Tw/wDa7e3kuRDrKRriSzcL8iP3ClskH1xnrVf9jo6p428K+J7HVpLm60Bo + DHH553RCTncAT6DnA4716L8S/g5qnhrxDceLPBZt0vLj/kI6XKP9H1Jc88EbQ3XmpvCvxj0HxhoV14f2 + /wDCE680TRSWV7GI/JkYYyh4Vxzkfh9aAPiy+sxZ6pLDH/q4ZyBjphW/+tXu/wC1XcrrXwc8BajMN1zJ + GIix6keXnP47RXOeIP2OfG+k66qw28OoWsk2BdW0yMpXP3iCQRx1HPOa9r+Pf7N2rfE3wNoNjo95Z2/9 + gw4MNwjKJyEUZ3DOOh64HNAHkP7Dlz9k+MEqndJFdWUqOg9Rg1e0v9jrxBr/AMWbg31itrob30kzy+cO + Yi5IAGc8jiuo+C/wht/2Z9Zl8ReM9e0uxdrZo4rWN90gBPLc43Z9gfrXUHxh4s+Pus28GgrdeG/CsbB5 + NQmTZcXgBz+7A5wfegD2LSNMg0XTILO2jEVvbII40H8IHAqxUdtE0EKI0jSFQAXK4Le5qSgAooooAbN/ + x7y/7hr4H/Yj/ZO+Hvxh+H/i7XvFHg/Rda1QeMbu2S6uoA8gQXAAXPpyfwNffE3/AB7y/wC4a/N/9kr9 + lXxb8VvCvjHWtH+LHirwjp7eLruI6bpyIIt32gDfknJJznn0r8s8WGv7OoL6x7F+1hrrrqtNO57GS8rr + SjJX91nif/BXP4P+Ffgr+0bpem+FdFsdDsrjRYrh4LWPYjN5sg3Y9eMfhXe/8E7P+CWemftAfDm18eeL + tY1bT7G7mb+zLbTSiMwjcgyO7K3VgQAMEYryz/gqb8JdY+D37Q1jputeM9Y8bXD6RFKt5qIAkRS8g2DB + PAIPp1r2f/gnH/wVA8NfAz4S2vgbxla6rtsZiNOubGDzhIjksY2UYO4MxA65zj0FeZ41VOJocPr/AFVu + 6t1fl+Ll8vMvh36nLE/7X8K6Hvnxl/4JEeE/jJZLcX3i/wAa3GsWtqYLK5vLyO5EA4wpUxjK8DgEHgci + vJv+CGHxN8C/8E/P+Cg3xm0H4reO/CPgn7JoEemW95ruqwadDeyR3uSIzK4DErhsDJx9DXtnxO/4K6fC + /wCGkdxa3Vr4xj1qOISxabd6JNZTyZ+6f3wUBT69x0rwf/gjP8Dvh7/wUw/4KF/GbXPi14D0DxdHcaDD + qdpbajbCVbNmvCg2nPZMLz2HbpXwPgDX49liMRHirn9lZcvOtb+XkejxT/ZihD6ja99bH66WX/BVn9mP + ULyG2g/aC+DMs9w6xRIvjCw3OxOAB+9rgv8Agtn+2Vq/7Fn7Cmt6t4TmVfHXiq6g8MeGUB+d766by1Ke + rIu58dcIfSvKP+Cgv/Bv18DPin+x7440n4WfCjwd4V+I39ntc+HtRs4BbyR3kREkS7s4AdlCHPHzZr5V + /Z3+IvxQ/wCCz37UP7NfhHxp4B8Y+F/D/wCzch1j4h3Ot6Y9vBfeILdBDEqO33yQC3HP75zyADX9SHx5 + 0/7LPjXxZ/wQt/bj8DeB/jZ8XtW8QfC/45eGG1C81zxdqii30DX4lDzASyFRHCxbYAf7wJPSv0Jn/wCC + tn7MJRfL/aI+C5PcDxjp5I/8i12n7S/7EXwn/bGs9Jt/if4D8P8AjWLQ5GksBqcHmm1Zhhtp6jI615QP + +CH37Jaf80H8At/245/rQB9U6hew6ZYz3VxJHDBbxtLLI7bVRVGSSewAFfE/7I3/AAXy+A/7Zf7U178K + /DEnimz1J2mGh6tqmnLbaX4pMBxMLGQOzPt5Pzqm4A7c8A/P/wC1R4g/4KWftLfs7+LPAH/Cifhb4fXx + dp02lzalYeNoPtFnFKhRmjDPjdtZuvtjBrm/+CnH7BB/YK/4Jdfs9+NvCNjaR+Nv2VtR0rUry5s/lFzF + IVTUssACUaZ/NyedsYGOKAP19VFUHAOSSevr1ql4jGPDuof9e0n/AKCa+G/+CjH/AAVf8WfAnRfgVo/w + R8L6D8RfiB8d7q3bR7C+v/s1uLSSESecWB+UfMg3McDJz0ridY/aN/4KWTaPdGb9nH4MQwmF9x/4TeNt + q7Tk43+npQD8j8Qbnw9qfib4seKLXSbG81C8fxDqRSK2haRz/pcvQAGvoP8AaK+C+r698MtAm/4RHXNS + 8ZW6p9u1Gy0S9tYIrVYsLDIJvvyAjlkULgdTX0X/AMEJtCsdV8PfETWNW0+zt/HzeIrldRijKzGyBmlL + ojcnZv3DI4OBX6ELmNfmXp/eHH41/I/iR9JLF8O57Vyijg1JU3bmd035q3Q+3yXg+li8Kq/tLX7dPU/n + Vmga3maORWjkjO1lYYZSOxH9K+9f2A/iX8ePDn7KbWfw/wDh1oPiLw7HfyvHf3Orw28zyeYpZdjyKcBs + DOOleVf8FetB0Dw3+1reJoNvZwyXVrFLfrAAFSY9eF43Edc817B/wTv/AG8/AH7Pv7KZ8N+I5NcGpJqE + 1wVtdNlnjKtIpHzqpGeOma/dKWfVM74QeZujyurSbUH/AIXp89j5yvhVhsd7Hn0Ulr213+R6V+yl4p8f + +M/+ClevXXxI8N6f4V8Qr4UQCzsrtLqExBxhgyu/Jz0Jr7kr4e/Zj/aF8OftHf8ABTbXPEHhdr86d/wi + aWx+2Wklu+5XGcKwB/HpX3DXR4cxnHh7DKpS9m+VXito+S8gzZWxdS0ubXfuA61JUY61JX3UTzwoooqg + DNc/48+GOgfEa1WPW9KttQ8viNnXDx/7rdV/AiugoIzQB5bbfsw2+iLs0PxV4q0WFTxDFeb4gP8AdYGp + J/2eNYu3YTfELxW0b8MscixEj6qAR+FenIvNSUAeb+Ff2WvCHhfUVvpNPbVdRVt32q/la4k3evzEjP4V + 6Io2LtUBV9AMCnP0ptABRRRQAUUUUANm/wCPeX/cNfmv+yj8TPj14Y8L+MLP4e/DnQfFHhv/AIS67Y39 + 3q0NtIJTccpsaVTgYAzjHNfpRN/x7y/7hr85/wBkL9urwH8APCni7w3rr64upN4wurgpb6XNcRFTcA53 + quM4B4zX5f4pRqPBYd0aCrP2sLp3slffpqtz1Mm/jy5tuVnzj/wU78TfEPxf8fLC8+JXhXTfCOtf2TGk + FpZXqXSSQh5MOWV3AJbdxn8K8V+GHw/1fx/4vsLbSLTVppI7qJpLjT7aSeWyG8fvQIwWyvJAGCcYBBOa + 9z/4Ko/tCaD+0h+0Fp+ueHGv20+00eK0YXVq9u2/fIx+VwDjnr65/D7t/wCCPvh7QNL/AGNtIvdHjt21 + C9upzqcqr+887zDhWPXheR9TWXit4gVeEMlWZ0qXtJXUbdPVmeQ5XHH4j2FSXL1Pg39t/wCFGrQSeH4/ + D9r4m1bwn4X002UM15pN5FcQ5kaV3mkmVd7PI8jfKoC5x2yfqD/g1hXb+2X8Vt38Pgy0Uj3+3E/1r76v + LJZ7SSK4G+KZWR0dsqy4JIIPsDX5o/sQ+JvjV8H/APgqN8dLf9lrwD4P8eK1htvbbWtXXTbeyt/tmR5R + Y/NiXcuAfugV8b4M+NeI41xVbC4nDqm6aTTV7O/c9fPOHVl1NSpzumf0BMiuVJHKnI9q5X41fGHw/wDs + +/DHW/GnivUIdJ8P+H7R7y/u5SdsMSAsTgdT6Dv0r8zf2m/+Cmv7fX7GXwd1L4i/EL9nn4W23g3w+0Um + qTaf4qF1PFC0iqWCISeM9cHHpW1/wXG/aFtv2sP2fv2f/hD4HvVvH/ae1/TZAsR/eHRQq3E8nynIzmJG + B4xIRmv6HPlD6G/4Jyf8FmfhT/wUt1/XtD8H2fjHw7r2hQJfLp3ibTFsbnUrF2Kx3sAWRw8LHHOQRuGQ + K+uwhAr80/8AgoR+wF8aPhh+118EfjZ+yr4N8M6rrvgPQ5vCuraRfanFpdtNpvkhIUbcyh1XkYGSpwR3 + qe4/aL/4KaSr/wAm5fBng9vG8f8A8XQB+ku3Fcl8a/g9of7QPwq8Q+DfElt9s0LxNYy6dexE8NHIpU4z + xnng+teb/tUf8FDPhp+zT+zt4z8dTeLfDep/8ItpM+oR2VtqMUk13IiEpEqhiSzMAv41+Wf7NP7XH7T3 + 7JnxB/Z/+P3xo8fXfif4Z/tPakdP1Tw80CpaeE2ut0mnmE/wqUBbJ5wMEknNAH1p/wAE2/8Agg+n7D/7 + Qtv488XfEzWPik/gzTpdC8BWl/biJfDVjI7FudzbpNrFMjAA6dsfoD4lOfDOof8AXtJ/6Aaq+LfH2h+A + 9LW+1zVdP0ezkdY1nvLhYY2Y9FDMQMn0rjvE37Tnw5/4Ry/2+OvCf/HvIP8AkKQ8/Kf9qgG7K5/L54Q+ + NXir4FfGnxXq3hLXL3Q9QfXdQjeSBsh1+1y8MpBUj6g19O/tDftVfHf4T+BtLvJPiJqt7HqYSO7mgttP + WK2kkiEoiBjzKrbSD8wQ+lcT+xN/wT8vP22fiZ451KTWk0jwzpuv3wa7hi8953a6lIEfOCMck54r7K+J + f/BJlPiL4KtdF1L4la1Lb2O14h/Z0WWdU2K0hUqXwvA3EkCv59418QfDnA5tLC53CEq8bXfJdryb/wAz + 6bLctzaph+fDtqD/AB9D8ptf8QXvi3WbnUdSuri+vrtzJNPM5eSRj3JNfqT/AMEnhoq/sQILwaX9o/ta + d288R7yomXH3ua/O/wDan/Zy1T9lP4t3XhTVpYrp4QJILmLhbiM9Hx1H0r7G/wCCdX7CXw3/AGgP2UP+ + Ek8TaJNfas2oTQGZbqWMbFkCgYVgOma/TczzDA4rhqpi8FJexlSk04raPK9lpsvxPFp06tPFRjNe9zLf + vc928Gw2af8ABVvV/wCz1sxbr4PjH+j7dud4z93vX1hXxH+zX8AfC/7Ov/BTPWvD/hXT207Tf+ETjuDG + 0zyEuzDJyxJr7cri8MZUXwzhPq8nKPKrOW79TqzeMo4ypzrVsB1qSox1qSv0CJ5oUUUVQBRRRQAZo3UU + UAGc0UUUAFFFFABRRRQA2b/j3l/3DXxz/wAE7Do//CnPF/2v+zhd/wDCaXmPN2CQj7UMdecV9jTf8e8v + +4a/On9kD9g/4b/tB+D/ABd4k8UaFPqGrL4uvLbzI7mSNWT7QAAQpx0JH41+R+L1TDwwOGliZyivawty + q93zKyeu3c9bI51IYmTp2u4vc8p/4LZRacP2otMOn/Y/JGhw5+z7cFjJLnO3vXk/7Dvjb4gaT8QW0vwf + 4w1PwrphH2rVJ4YxcR2seVXzPJbKsxZkUDHJYCuq/wCCqv7PnhX9nH4/abo3hGwl0+xn0lLiSOSdpm3m + SQHliTjjpXef8E3f+CdHiT4zeFT46bxlrHgvTLhzFajTS3nXmxxksQygLlRgHOSDxivouOs+yLKspdfi + DldHRWkr3fZLucOV4HFVq9sM7T8g8Y/tJ/FXUvB3xWs9Q+KniWGXwPdz2audItrW3vlW6jhijEqfvFnl + VnbYoOFQknGSPXv+DWS4bVP2zPixdNNJNJN4PtmaRySzk3vJJPPXNd948/4Jh6n4p+HniDR4/iPdXU+u + TzXsr6ppEFx5k8ilSxkyXXjgEZ2gYHHFcH/wbtS2P7Mn7fHxq0Dxpqmm6De6b4eisnN5cLCksiXxztLE + ZB5Ix2r5fwy4s4OzedWnw0owlGzklGza8zuzjAY/D2ljpN32P2i+NPwl0X47/C3XfBviSyj1HQfE1lNp + 1/buOJIpEKN+h6jkV8K/8E4f+CC1n+w9+0ba+O/FPxM1z4oR+DdOl0TwDYanbKieF7KRyxGQSGfBK5wA + MkjsF+3IP2l/h3eXEcKeNvCzSSsERf7UhyzHoB83U14v/wAFev20Lz9hf9iLxJ4u0UCTxXfmLRvD0JXc + Zb+5YRQ/L3wzbsDspr9iPFPppZVZto6imz7sDa238K/J/wDYf/aE+NH/AATk/bm8K/Cn9pL4mT+MtA+N + Hhn+2tM1jVdkMej6wi+ZPZh+B5eG2AkjJxwBX6Tf8NOfDl1G7x54TX3/ALUh5/8AHqAPj66/4Njv2O5r + fb/wrOb5WDADVZl5HuDXd/8ABX/9hmP9pH/gmH4h+HfhHTI4dQ8IafbX3ha3jH/HvNYbWt407/dj2fQ1 + 9iXdzHZ2kk0zrHHEpd2Y4Cgckmvlv9nH/gsb8A/2sP2ktW+FHgrxgt/4s0vzCqTWskNvqXlMVmFtKwCz + FMHOwnofSgD81bj4tn/g4n+N37Ofwl1Dw7rtv4O+Gtl/bvxViureW3jh1CCPyPsu7A+aRg2CDkCQehr7 + C1n/AINlP2PtP0q6kX4ayZihdwx1Sc4IUkcZr758P+BNF8KXt1caVo+mabNfv5lzJa2qQtcserOVALH3 + OTU3i3jwxqHr9mk/9BNNOzuG+jP54f8AglX+2d4O/Y01bxl8O/ERk0rw2mu3aaZdhGkWARzyIEfHPQAA + +1fb+t/8FLPgxo+mG6uPFkflEZXbbyZfHYcc1+MPiGzm1L4n+Ko7eGW4m/4SHUtqxqWY/wCly9MV6t8a + td8U+IfhF4V8NzW+qapHp6m9vJmtWzC7DYsQOOioOnvX828ceAvCeeZxUzTG4h0asneUbrV97M+sy3ij + GYej7GlC6Wwn7f37Ttt+1X8f7zxDp9vNb6Vbxra2YlUeY6L/ABH0yfyr6X/4J7fBj4r+Mf2Tv7S8I/ES + 18O6PJqEsaWMliJSriQBm3e55r4BaDyWKspVl4IPavrj9jz/AIKcy/sxfA5PA8PhCXXWW5lvBKlzsJy3 + mH5cdgpr9flkNLL+HnlWVq6jTcYLe/u2ivmfPyxksRi/a1urV/LU+mv2WPAni/wH/wAFKdcsfGniWHxV + q48KRuL1LfyfkLjC4HpX3F5ftX5A6H/wWFt7b9sC4+J0/g6aO2vNEXSXtI7kMwIIIcE17da/8F9dLv4j + JB8PfEE6KcFo3VgD+FZ8FU8Rgshw1LNEqdRRSktEk+yKx37zFT9ldq/4H6IbcGivz1i/4L26W83l/wDC + uvEHnbd3llxvx0zjrTZ/+C+WkWsm2b4deIIWJwN7hdx68Z619RHMMNzKHtFd7arU5fZT6J/cfoZRX56T + f8F8NKt4mkk+G/iNI0XczE4Cjrk8Uqf8F7dJmUNH8OfEEqNyrI4ZW+hFCzPBtXVWP3oFSn1T+4/Qqivz + zi/4L56PcMyx/DvxBI0f3wjhin19KH/4L5aRHcxQt8OvEAmmUske8bmA68dapZhhXLlVRX9UV7GfY/Qy + ivzzvP8AgvnpGnQ+ZcfDrxBDHnAZ3Cgn8acf+C9emKCf+Fb+JNqjO7I24+tT/aWF5VL2kddtUT7KfY/Q + qivzzt/+C+mkXlussPw68QSxt91kYMD9DSRf8F9NInkZF+HXiBpIzhl3jK/UdqI5lhnf31pvqtPUfsZn + 6G0V+ecn/BfLSIZ442+HfiBZJfuKXALfT1on/wCC+Ok2sDSy/DnxBFGvJZ3CgfnRHMsM3FKa97bVa+ge + xmfoZRX56r/wXp0113L8N/EjKeQQRyKbbf8ABfLSLxN0Pw78QTKDglHDYP4Vf1/DWbdSNlvqtBqjN7I/ + Qqb/AI95f9w1+b/7JPwZ+K3jjwv4v1Dwb8RrXwvoq+LrtGsZbHzy0n2gAvn64OPar2pf8HAOi2ayRP8A + D3W45mQ7VlmVOccZz2rw/wDZO/4KzP8ABDwjq3h6PwTNrE+razca3vju9jKrP57KRg52hTyO2a+C8RMJ + mGNwND+yaaqP2kG72a5U9Wr/AIM9DKasKNaUqjto0c3/AMFSvh94y+H37Q1ha+NPFEPirUn0iKRLqK38 + jy4y8mEx9Qxz719Ff8EyP+Ckng34bfBex8B+Mr6TR7jRZHFlMYGaG5jcl+q5wwYkYOM9q+U/26P2tv8A + hsj4uWviYaKdE+z6ell5Jn8z7ru2c/8AAv0rH/Y01rQ/DPxnTVdftb65XT0D6f8AZrT7UkdzuTa8i/3V + Xecc8gcda6PEDgjKuKMpWCzWThFWad0mn89CMrzSrhK/tKKufqt4r/4KffBvw54eutQj8UJffZeTDbwO + zytk/IOOpwfwr5J/4Jf/ALKPwp/4LDf8FCPjDq/xY8Lf2pYx6PHqtha/aHjNs0l15YyVIyQgxXm/xd0J + da+EvxYW01TT4dGm8UtrGkw3NsLW5nQGYyMvGSrCVFQE9A3Ar6G/4NXIVX9r74rDr/xR9pk4HP8Aphr5 + Twv8J8i4WrVcTlVR1ZSsm202l2sjrzzPMVjlGNaNkj279vr/AINlfgPb/sjeNL/4N+BZNN+Jmk2J1DQJ + FvpX8y4iIkEeGJHzhSo9yK8f8BftTa9/wXU/aL/ZZ+H8mh63FpnwdCeLfifLeWTxpFrFqhgjiJYAZZg7 + Y5GZh/dNft6VyuOg9q5TX5PBvwD8K654ovINE8M6ZaQyX2q36wJbgqoLNJIwALHGeTk1+26Hh6Hlv7a/ + /BNj4O/8FEdP8Pw/FTwydeXw1I8un7bh4GhLjDDK8lTxx7V8/t/wbKfsfoN0Xw2dXbrnU5sfzr2z9gv/ + AIKqfBf/AIKMXevWvwx1+6v77w8Q1za3tlJZzPCThZ41kALRMejDivpCUAryrNz2o0DQ/KH9q/8Abs/b + e+OP7OfjLwf4f/ZI8UeGtW8TaVNpsOprqaO1l5qlC6qOdwBY59cV57+3d/wT/j/4Jmf8E5/2Yfir4R0a + Cy8c/s76lpl14muLYDzbyC72rqCyOPvKJn4J4CqfWv2kwHFcL+0z+z7of7UvwH8UeAPEUPnaR4o0+Wwn + 4yUDrgMPcHBH0qST5m/4KIf8FZpv2QvB/wAIV8D+D5PiZ4u+Ml5DBoOi2l0I3uY5IhJ5it3B3KB/vCvK + vEP/AAU6/bAvNAuo2/Yv8SxJNbuC/wDa8Z2Aqece1V/+CbH/AARF8ffs7ftI+G/HHxm+Idr8RbP4TaXL + oXw9sljYf2bbu5xNIW6yLGQox0wPQV+kHimPb4b1A9vs0nf/AGTTi7O4H4U/8EPPhvofjDTfH3jDXNKg + Xxc/iC5intZwJG03fLKzJg992Rn/AGa/Qa88M6fdWsiNp9nKsgwy+QvzfpX4cfA34/8Air4E/tEeJ5vC + /iAaANS8Q30Nw8q77dh9rlAMi9wK+sYv2zPjlrD+MreHxhojSeFJEiC2elbri8V03iRE3ZAAIycHFfxZ + 4oeA/F+e8R1s1y/EfuptNJzaa8kj73JeJcvwuEVCrT95eS1PD/8AgrB8NPD3wx/aovY9Bhhs4762juJ7 + WBQscErdcAdM9a+fvh3rFrofi+2ub55I7UJLHI0a7mUPE6ZA+rCnfEDx/q3xL8XX+sa5f3Gp6leylpri + Y5Zz/T6Vi7BX9VcH5LiMryehgMZUdSpTilKT6ux8Zja1OtXlVpqyb2JbvwP4fS0YQ6xdPIq/Lm12gn86 + /Tj/AIImeCtHuf2YdQa+tdLuZhrMqq1zGjOV2qf4h0r8wtgrZ8O/EPXvCNqYNL1jUtPhZi5S3uXjUn1w + DW3EXC+CzvDPB46/I3f3W07rzX4kYXE1MPU9pT38z9UrHwXo7f8ABXOSP+z9JayXwHI3l+TH5Yfz4edu + MZwev1pn/BUzwRosOh/C02mm6XC0njWzjlaKFFyp6hiB09jX5aL8TvEa6+dUGu6sNSaLyTdfan84p/d3 + ZzjgcUutfFDxJ4kW3XUNe1a9W1lE8ImuncRuOjDJ4I9a+Yh4U5FGtSrrnvTjyx992t5q+r89zr/tjFKE + opr3n2Wnoftd+1N4E8Oxfsq/EdodM0VJo/Cmpujx20W5WFnKQRgdc1z3/BPjwFoL/sQfDxbjTdHmuW0h + GZ5beIsSWY8kjOe1fjzffGHxZqdjNa3HiTW57edDHJE95IyyKRggjPII7VHpPxY8UaDpkNlY+IdatbO3 + XbFDFeSKkY9AAeK4/wDiDnDywrwlqnK5c3xyvf1vt5bG39u4tVPaabWtZWP1S/YQ8H6Hd/tAftCGbTdJ + kjh8XKIfMhjKogjIwoIwBkjgVD8ZPA2ij/gqd8HljsdL+ySaDqpliWGMRkiGTBIxivyw0f4n+I/D893L + Y67q1rJfv5ly8V06tO3qxzyfc0l18TPEV9rlvqc2uatJqFojRwXLXTmWJW6hWzkA5rq/4hPkLxEsS4z5 + pR5H78tVa3fe3XuL+3MUoqKto77K+5+rH/BWjwdokH7J5azsNLt5Y9Xsl3QwRqwBmGRwM+ma94v/AAB4 + bX4RTx/2foaSf2SxBNvEGz5RI7V+GGt/E/xJ4ksvs2oa9q19bkhjFPdPIuRyDgnFWX+M/i6SBo28Ta60 + bLtKm9kwR6da5v8AiD3D31enheWfLCTkv3kr3dt3fyLfEGM5uZW7bI/VL/gkn4J0PUf2I/DbX2n6Tc3Q + uLjdJcQxtIfn4yWGelR/s5eAdBm/4KB/GiOax0d7eK3s/KieGPy1yoztGMflX5U6H8UfEnhnS0sdP17V + rGzjOVhgunRFPsAaba/ErxFY6pcX0OuatDeXeBPOl06yS46bmzk/jW9bwlyCrWr15Kd63xe/Lum7a6ar + oZyzzGaWa020X4n6qftieEtHtv2yfgPFbWOix2ralN5yJAgVgEP3sDB/Gtz/AIKZ+CtAh/Yt8WfZdN0m + C62R7ZILaNWHzjpgZr8kL/4n+I9Uv7O6udc1a4udPJa2lkunZ4CepUk8fhS6z8VPE3iKxa1vvEGsXlu5 + BaKa7d0bHqCcVdLwm4fhOjNRn+5+H35euuuvzKln2KlFxdtfJH7g/A/wN4bn+AnhcyaToskraRBuZ7aI + sx8sdeOteGf8EofCOjX/AMCtekvNP0mZv+EjvghnhjZgolOByM4r8ubf40eLrS1SGLxNrkcMa7VRb2QK + oHYDNVdD+JviLwzaPb6frmrWMMjmRkgunRWY9ScHrXPU8HeHZ0a1Bxnaq1KXvyvda6a6eg459ilZq11t + oj37/gsX4Q0+3/bTmW1W2s7NtPtdy28aqq/KMkBa8H8Cad4a8CeIP7TXVL24ZLO7gWM22AWltpYl5z2L + g/hWP4i12+8W3/2rU7y6v7rAXzZ5TI+B0GTzVE2ykY5/OvvsqyrD5dhIYHCp8kFZXbb+97nlVqsq0uer + q/QUTAv8udvYnrX67f8ABIX4Q+F9M/ZP0rxBZ2On3WrazNM19cPGHkR1kZQmT0wAOK/IgRbDwOK+gP2E + /wBoD4ofD7xmvhvwP4gj03Tbwm5vUvI/Os7RB9+Zl7Htx1LAdTX5n4zcD5rxRkX1HJ63s6id3q4prs2j + 2OH8dh8Fifa4iN16J/mfs9qXgnRtY0iexvNL0+a1ul2SRPbqysOnIx6f41+cf7C3xZ8efsYf8FL/AI42 + PwM+Ed58XIfsC2ctnZ3aQDTYFuywbc3X5yU49K1PFPx//aE8S/Cjxpff8Jdo9kugrqm2SDT/AC/tUNg7 + JOySE4VyElYLydqE9q6T/g1z1ObWf20vjBdXUk1xcXHhK2lklm6yM18xJPuSc/jXwfgR4U8RcK4uvXzq + upRkklFSclfvqelxLnWDx8YrDxs0+yPdvjj/AMFwf2kv2ZfAFx4y+IH7I/iDw/4R0uWIajqB1WN1to3d + U3EL9fpXSf8ABe39oWP40fsr/CL4UeBdQa6v/wBpXxDptlatbP8AvG0httxPMPVChRT7SV94/tD/AAB0 + H9p/4G+KvAPia3E+h+LNOl067UD5grrgMvoynBB9QK+BP+Ccv/BDLx1+zp+074V8cfF34lQ/EbTPg/pM + ugfDqwEJQadbu5PnS5/5aBMKAOhx2UV/UB8qYv7Z/wCx78Sf2Gv2yvgj8Yv2ZfhfceLrbQfD0nhDxToG + mMtul7aJEFgaT3UgkMf4gM9a7W6/4Kdftgx8/wDDF3iIjPH/ABN4zX6LxyKPl7A/nUj/ADD5W2+9IR5r + +0p+1L4W/Zp+APi7x7rGqWbaf4T0qfUpo4rhGklEaFgijP3mIAA9TX5V/sjf8FPv2nvhj8YPgT8Tvjnq + GnXXwX/agvp7HT9MhtvKPhGSVibEF+rB0GcnqoJ9K9t1j/g1r+AOuafJaXviL4oXltMQJIZvEk8kci55 + BVmIP416j/wWO/YRh+Ln/BKfUvBfgXTvJ1T4X2VjqvhS3j5kt300IY40PXJiRkyOu6oIPtq+1q00u286 + 6uYLeHcFDySBVJPQZPrWN4p8aaPJ4Z1BV1bTSWtpAB9pT+6fevxb+Jv7S0H/AAcAfEf9mb4OeENV8Qad + oOn2H/CT/E+Sxlls5NMlgiMDWryLgh2kWQKP9tTX0jq//BsL8C7LRbmZfFXxW3QwO/Pie56hSf71AI/M + P9jP9ivxB+1X8efFmoabLYWui+H/ABJfPc3N5EZYZmN1IVQKPvV9p6n/AMEx9WHjfUfE2n+IPD9n4gu4 + fKinGmlVgOzYSAG7jjNeEf8ABIH9qjwb+zGnjD4b+INQ/suzt9cuzp1/dsW80RzyRlZH/vYAOT15r7wn + /bO+FkEUkknjTQ28kbnRZizAfQAmv4f8VvETxFy3iSrhMppyVCNuW0ObmXdvzP0LJcrymphIzqv3nvrs + fiv+0N8C9e/Z2+LGqeGdfhjW9tZPMEkXMcyN0dT6GuJ3V75/wUg/aQ0f9pv9pG61jw+pbR9NhFlbTsm1 + rgL1bHoT0zXgdf1zwZjsfjMkw2JzOHJWlCLkuza1Picwp0qeIlCi7xvoG6jdRRX05xhuo3UUUAG6jdRR + QAbqN1FFABuo3UUUAG6jdRRQAbqN1FFABuo3UUUAG6jdRRQA5T81fY3/AATY/YZ+IXxUsLjxponiS38H + 6PcMbYMYRNJqQSQMV2kY2b1Bye4NfHCfer9Q/wDglL+3B4J0f9nzTvAevarb6PrWhyy+QsoOy6id2k3A + gdQSQQfQV+N+NWe8QZTkbxPDkOardXaV2l3t1Pc4cwuGxGN9ninaNjpPiT+wB8Rdb+HXiSxt/HGl39/q + i6g8ZnsSuBd/66JNpwgdQUzjIDt6muX/AODabRLj4Wft2fGjR/EE0Om6hp3hiC0niuJQm10v3Bxk8856 + dsV9MeI/24PhR4a8MX2q3XjbSZLazjLMsEhd2bnCjA+8cHAr4X/4J5fsdeBf+Cwv/BRX4y6t4qvvFGi6 + amlR6rYro+oyWMuGujEocoeRsAOPXmvgfAXjLjXOMVXhxHBqlFK0nHl17eeh63FGW5dh4ReFfvX73P38 + h8WaUZFVdU05mc7VUXKEsT0HWvCf+Cpn7ba/sDfsU+LPiFbwx3WuW8aWOi2rjP2q+nYRwJ/32wJ9ga+A + f+CgX/BuD4T+Fn7JPjHxR8I/FHxRuPiD4aszquk20/iK4mW7eAiRotm7lmVWA98Vx2tftmw/8F2fjn+y + L8MPD8N1d2PhmSLx38TwIWSPS7qzj8n7PIcY+aTzWCnu0fev6mPkT2//AIJ6/tp/H79nv9tPw38Gf2oP + EGm69L8XPCy+JfDWqRwC2XT7sDfNYMeB8q8Z9Riv02HjTSI41/4m2lMeh/0tP8a+cf8AgoT/AMEnPhr/ + AMFJJfCM3jhta0++8Fyytp95pF61rPGrqAy7lwcHCnHtXzvdf8GwvwJgwf8AhLvi8mf7vie4Of8Ax6lu + Lc/SiRljRmchVUZJJ4Arw34Jf8FIPgb+0p8c/Enwx8G/EHQfEHjLwzvS/wBNhc5IQ7ZPLZgFl2ng7Ccc + 9ga+F/2uP+CyPxu+Jv7OXjLw34J/ZS+OWg+KvEGlT6dpuoz2astjLKuwSnbk/KCSMdxXiv7Tv/BPmL/g + kt+xL+yj8cvDmlSab4++Duq2EvjyeIbpr6G/x9tSZh9/ZM6qCcjaGqCD9lPhp+zv4F+DesarqHhTwjoH + h2+1yTzb+ews0gku2znLlRzySa6PxOMeGdQ/69pP/QTXy3/wUL/4KteG/wBgzwX8OtRj8Na54+1j4pXs + VloGjaLIrXF5vi8wSJnO7ggYHUke1eKal/wXE+IN7oF2G/Y++OqxyQupka2j2gbTyfamtXYHorn4j+Fp + ruD9orUWs57G3uF8U3+yS7x5Mf8ApkuWYEHgD2NfVGm33gjSNY+Iy6hrelQ3+tXEM6X9rO6E2ggw4RhG + fmMg5TjOa7n/AIIp/APwz8XbPxx8RPEGhQzaw/iG7jhs71Qz6aHmkkZWX++CcHP901+gF18FvCFzbSRy + eG9FdZAQwFmnI/Kv5X4++khgOHc8qZPPCOo6bs5XsfZZZwdVxeHVdVEk+mp/PtcBVurjY/mR+a21sY3D + PBPvTa+jv+CpnwR0H4E/tU3ll4bt47XT9UtUvDao2Vtmbrgds9cV841/Q/CufUc5yqjmeHVo1IqSXqfK + 4rDyoVpUZO/LoFFFFfQHOFFFFABXtX7NH7AnxC/ay8JX2ueEYdKm0/T7xrCY3N35TCVY45DgbTxtlT86 + 8Vr9Xv8AghAP+MUvFXr/AMJXKP8AyUtaAPlF/wDgjB8bF/5dPDv4aj/9hXzj+298BvG/7Cut6HZ+KrTT + fN12F5ofInMo2qcHJwO9f0KFcrX48/8ABzZFt+Jfwx299Ou8/wDfxKAPz+Px6vCP+PO3/M/40n/C+rz/ + AJ87f8zXAJkLzS0Ad9/wvq8/587f8zWt4I+LNx4o8QxWctvHGsgY7l65AryuvQP2ZPh3rnxS+Ltjo/h3 + S7rV9TmjkdLa3XdIyquWOPYUAeoUV6237B/xgU/8k/8AEX/fgf41keN/2SviV8N/DdxrGueDda03TbUA + y3E0QCJnpk5oA87ooI2migAooooAVfvV6R+ypfXGj/GvTNQt7u2s/sOZ52nuzaq8YxuXzArEZ9AMkAgV + 5un3q/V3/gk1+zL4Ntv2atL8WXWk6fqWu6+8xmnniWVoUSQqqDPTpnHvX5p4peIVDhDKv7Sr03Uu+VRX + Vv8AI9XJ8rnjq/sYS5Xbc+YfE/xd8Ez/AAp+K0bPa/YdUvNbh0e1iTa2pyXF0slvcPEU+TyRja24YVcY + zXuv/Bq3kftkfFkbWX/ij7UYbr/x+d/zr7J134CeDPEui3FneeF9DmtpYyrI1qgyOmBxn06V8A/sCfHu + +/4Jr/8ABSr43aZ4N+FPjb4q2J09dPjs/DSrLPpqJdbwZM/w9E+or5Lwl8bcFxliKuEpYd0pwSdt1Z+n + U7864dlgEpynzXP38uU3x4429DkV574W+Dvw5/Zx/wCEg8TaT4f8M+DxeI13rGowW0dr5ir8zPK4A4HU + 5r4O+JP/AAcSa38FvC0mveNP2WfjV4W8OWssSXeqX8MccFqHdUDM2MYyR161u/8ABfv9oS51v9jjwH8N + vBOofaNa/aO1/T/D2nTWrbi1hNiaacAclDEMZHTzFr97R8+fWf7JH/BQf4P/ALc8Wst8LfG+meLG8PzG + C+W3Do8RzgNtcAlCejAYNezMu7+HdX5GftNfsu+Iv+CQH7cnwW+KXwH+FviTxd4Lk8LyeD/F+g+Grfc9 + yIox5FxIBxv3ZbcepHXmvYJP+C43xEdMf8Md/HiLB6m2j5pWJsfosoyPxrzX9r39mjR/2uv2bfGXw31z + Mel+LtLl0+SRVy0JZTsdfdTg/hW58ePjRon7O/wa8T+N/ENx9l0Xwrp02pXcmMkRxIXOPc4xX5a/saf8 + FoP2hL/47fCHxJ8bvDPhnQ/gj+0teXNn4Qe0iZLvw/MrEW8dxIeH81QCD/EAzYUDFSSdZ/wTl/4JFfHP + wz+0v4D8XftG+KvDfivQvgLpEmieALawdpGmOdsd5PuUASJEFUdTkDn5ef038QJt8OX/AL28mf8Avk1f + ZBKi8/KpwM8VT8RxsNAvhtP/AB7yc+nymjXoTJXVj+X/APZj/ay8Yfsz/HvxRF4X1Sys4da8S38V1FqA + /wBDk/0uUBn7jHqORX1ppf8AwUo+KGr+M9f8Myat4B03VtKJCO1hcSJMgj8wuhztUAED5+5r5S/ZV/ZC + 8UftR/tBeKv7F0/T5tP0XxJfSX82oSPHbAfa5cITH8xJwcBSOnJFfXPxA/4JX+P9c1nxRq2kaj4J03UP + ElilnIIhcjYowG2sxYqWCgE81/PvHWK8Mnm0lxB7P6zpzX3+dj6vK6ebrDR+qt8nQ/Pn4xfE/WvjN8Q9 + Q8ReIL5tR1S+kO+bGBjsABwB6AVytdJ8YvhB4g/Z/wDiLf8AhfxJafZNSsX2uobejDsytgAqR0wK5uv2 + 7JfqX1Kn/Z1vY2XLy7WtpbyPm8R7T20vbfFfUKKKK9QyCiiigAr2n9nP9sn4o/s6eCrrR/A13NDpd3et + e3CpZCb98yKhOSp42xpxnqa8Wr9WP+CE2n29z+y34mklghkdfFcwDMgJA+x2tAHyiP8AgqR+0If+YlcD + 66Uv/wATXyp/wUR/aT8eftHeJPDtx44mkurjTYJUtmaDyNqMQTxgZ5H61/Ri+k2bf8utv/36X/Cvx/8A + +DmS2h0/4kfDPyY44VawutwRQufnWgD8vyuKKA+9KKACvsv/AIIK8/8ABSDwz76df/8Aog18aV9l/wDB + BT/lJD4Y/wCwdf8A/og0Afv2RmT8a+ef+CqKD/hiHxh/1zT/ANCr6G/5afjXzx/wVT5/Yh8X/wC5GT/3 + 0KAPxQhG6FSeuKfsFXPDnh3UPFl9HZ6Tp95qV1ICywW0RkkIHU4HPFavif4TeKvBenfbNX8N61ptnvCe + fc2jxR7j0GWA54P5UAc664FNpxcOvFNoAVfvV9Nf8E+v2wviL8KfEEfgXw7qVi2n65P/AKNbX1lLeJBM + TklFi+f5j1xwBkmvmVPvV9Q/8E//ANg7xd+0Hft4pg03SP8AhH9PcxRSanPPAsswwQ0Yiw7bfXco5718 + Lx9U4ejlkv8AWfl+r/3u/l5ndl8cS6v+yX5vI+i/Ef7bPx21T4TeNtWjuvh/pp8JyX9ldmC3lY7rZ0hc + rI25FZmlTy1bBc5x0Nan/BsB4hu/Ff7b3xf1LUJprm+vvCkM08srbnd2vssSe5zV3xr+w98ZNP8AhR42 + s7fVfBWrX3icag82FntjILqSOWUBcmNn/dgKzjIwOeM1V/4NhdCvPBf7b/xg0fU7eaz1DS/CkFtcxSja + 0Ui320qe+QRXzPhhX4IlKrHhPkvb3nHR+XyO3Nf7S5Usbe3S5+un7Wf7Nei/tdfs3+Mfhv4ij3aR4w0y + bT5nABaAup2yLnjcrYYe4r88/wDgnJ/wR5+OvhD9p74f+Jv2iPGHh3xV4Z/Z90mXRPh7a2DO0lyGIVLu + cMAEZY1QAfMflUZwvP6q+cr9Pm+leGf8FIP20NO/YB/Y88YfE69gW8m0O2CWFkThr67kYJBCPdpGFfr6 + 0PGuz3JRg/oKbLlh03V+av8AwTV/4KS/HiT9rrT/AIN/tQab4e0vxD8SPDSeL/BlxpUJjTYVEklhKDj9 + 7HGcng8qRk5r9KN7bP8AWKvuw61cRn5b+PP+DZOD4leF7zRdf/ah/aE1vR9Qj8u5sL7XfPtrlf7rowKs + D7g16R/wWo/Ybgv/APgkXb+G/ANndLqXwLi0zWfCwh5uYTpiqo2lRne0IdSQP4ya/QZkGK818EftTfCr + 41fEnxN8P/Dvjzwb4m8V+GwY9b0Kx1WC5vLAcKwliViwAJCtkcE4ODxUkH5TftP/ALad5/wWj8afsr/B + v4L/ABA8SeG/+Ers18VePtQ8Oak1teaBBBF5csErIchxJ5m1WGGKoe4r2HXP+DcvUbXSrqRf2t/2lcRw + sxX/AISI84BOK+4v2eP2C/g/+yj4x1zxB8Ofh34Y8H6z4mkaTU7rTbRYpLos24gnHCknOFwM16p4jUDw + /ff9e8n/AKCaBS1Vj8Df+CLn7QXg/wCAtt44+HPiDXFs763166Npf6jMqNqYSZ0YyOSAZDgHnrk9+K/Q + W9+Ofgmzs2mm8V+G7eELv8x9SgAx1/vV+D+hzMf2gtWlhtdLvG/4Sq/Kw6k0aWrf6XL/AKxpGVAvuzAV + 9d/CzQvCOmeIfic2sT+BVFzLb3FmYNT0uTETW53jDOy+TuzkQneDjAxX8s8efRsy7iDO6mbfW3TdRpuP + n1sfX5bxbWweGWHjC9up5L/wVE+P+g/tDftOXGo+GZobzS9NgWz+1pHhLplzlkJHKjoDjmvnWpb1ozeT + eWyugkYKyghSM8Yzzioq/orhrIaOTZZRyzDtuFOKim93ZHzOKxMsRVdae7CiiivcOcKKKKACvsP/AIJ6 + f8FLND/Yx+D2reG9T8N6rrFxqGtSamktrcJGio0EEe0hgckGIn6NXx5X3t/wSq/YN+HH7VHwL17XfGWl + 3d9qFhr0ljC8N7NABELe3cAhWAPzSN2oA9G/4f1eFP8AoRPEX/gbD/8AE18C/wDBZH9tvTP22fGngrUN + M0bUNFj0O0ngkS5mSTzSzKc/KK/VIf8ABG/4FN/zL+qf+Da5/wDi6/Nf/gu3+yb4J/ZS8d+BbPwbp9xY + Q6lZXE1wJbqS4MjB1A+8Tjr70AfArLgU2lL7lpKACvsv/ggp/wApIfDH/YOv/wD0Qa+NK+nf+CQnxw8P + fs8ftv6D4o8UXM1rpFrZXcUkkULTMGeIqvyrz1oA/op/5afjXzz/AMFUf+TIfGH/AFzT/wBCrEi/4LD/ + AALmO7/hINUXOeDpU3H6V5F+3l/wUm+E/wAc/wBmDxF4Z8O61e3Wr6kqLBHJYSRKxB/vMAKAPCP+CFnh + +38Tftqqt1GWW20e4dNpxj7o/rX33/wWe+H2nw/sH+IJ1jbzLS8tpU/eHG7cR/WvhX/ggjAyftxgN8gO + h3Ocn3Svv7/gtQzSfsBeJ9rdLq2J56jzKzNLLlufhajs33uD35z+tOpq9elOrQzFX71fqx/wSY/az8Ex + /sy6d4O1LWtJ0XXdBmlD293dJA10ryMyyJuIDcHBxyMDjGK/KdPvV6J+yZFNbfHHTbiKCOa3t9016pms + of3A++Q14fJGAeS3ON2PWvzXxR8PcPxflH9m4io6dmpKS6WPWyfNp5fX9tCNz9t/FX7QvgPwjotxqGoe + NPC9pa2Y3vI2pxEnAJ+UA5Y8dAM1+eH7DP7K8H/BWH/go/8AGbUtE+J3xE+Fmkx6cupW9x4WvTYXOoIb + rykE2OxGXweQzV5B41+Kem+D/DnxXsNPm8M6lomtavdaZ4dtLeytJGt4pJmeS6VwvmrGkQCRHO0mQFc7 + Mj6m/wCDVdGT9sD4rKWLBfCNsMnv/ptfI+EfgzgeDa1XE0MQ605q3ZJHdnnEk8xhGE4ctjuv27P+CG3x + I/Zk/ZU8YfET4bftNftB+JvF3ge0Gt2ulah4hlaG+W3ZZJEwnzbtisRjqQBWX+0X+2vo/wDwW++JH7Hf + wl8F3kepWutXMHxA+IkFk37vSEs4yGtZwOADN5hCtj7kZHUV+001pHcQvHIivHIpVlbkMD1FeO/An9h/ + 4M/sg+JvEnifwH4B8H+Cb/xBmbV9RsbZbd5wDuO5icKufmOCATyRmv3jmufPXPJf+ClH/BIjw3/wUa17 + wHrdx408XfDvxJ8PZZW03V/Dcy293skUKyb8blxgYIPrxXgo/wCDcnUpZG8z9rr9pphnIH/CSmvvj4G/ + tT/DX9py31Sb4dePPCXjiLRbg2l++h6pDfLaSj+FzGxxnt2PbNd6zhepxVRFc/J79rT/AIOR9A1f9mnx + xZ/Df4YfHe28cahpM1nos+oeDpoba3upEZElZyfl2k56HJAr598e/sDf8OcP2Z/2Uf2mtFtdTtPHnh3V + bJfijPKG8/UbfVgGmF11YtDK6xYIySzE1+8iRh/mZVJPHI7V5N+3R+ypp/7a37J/jj4Y6o8cMPizTZLW + Gdxn7NPtzHL6/K4U5HNSScL+3p/wVI+HP/BPT4f+Etf8Z2viXVD43u47LSNP0GxF9e3Tum/Kx7lJUDuM + nkYBzXzZrX/Byv8ACa70a7jT4W/tCK0kLoGPga4KqSpGT81ee/8ABPP/AIJ5ftMfFL9q74W+IP2oLPR7 + Hwx+zNpR0vwiLW+ju38SXi5jgv3Cs2zbEqHLBWJVeOTX6t+Jznw7qH/XtJ/6CaL21B6an8/3/BHX9l/w + b+0rF4y+I3ifSRqUb6/diw0++gGIRJNJJuljYH5+QMHpzX3pffsbfCnU7Zo5vh74TaNhghbCNOPbC8H3 + Ffkl+zJ+3P4q/Yz+Lvjd9Ht7LVNJ1XX783VhcsyqzLdTYcEcBucdO9fY/wAX/wDgqV8RvhD4B03XtT8A + +GVt9a2x27Raw8jQO8fmKsiBRzt5647da/iHxU8MvETMuI6uNyqrL2Mrclp2svQ/RMmzjKKOEjTrRXN1 + 0ufIP/BSb9nXQv2bv2kL3SPDa/Z9Ju4Vu4LMuXNqG6qCeqg9M818+12Xx2+OfiH9on4i33ifxJOs2oXh + ChU+5Eg+6ij0FcbX9acHYPMcJk2Hw2aT560IpSfdpHxGY1KM8TKdBWi2FGaK7j9nT4W2Xxj+K9pod+92 + lrJBPOwtnVJHMcbOFUt8oyVxzxzX1ETiOHor6c8Z/sV+Hfh7q2qX13N4gvtNt5LGztdKtZYBf/bLmJpT + HJKSYgiIv3gDuLDAHJpvgP8AYl0Hx54T8VzTHxNpWqaXeapa2sNy9ustv9lh82NJochpJG5UmLdg4+XG + aoD5lbIHHUciv0s/4ItfHzwX8Kf2c/EWm+JPFWg6Hd3HiSaeOC9vEhkaP7LaqGwxGQSrDj+6a+efBn7B + uh2/gSz1DxJqWoDULi1F1dRW1wsMkKEQsy28Rif7S6C5hDfNGC7FFJKkjD1L9jXw/wCEvD0usatqerTW + ekx6xNqa2QRGufsd9DaRCHdnaXMoLbtwVQcZOKAP1lH7Zvwn37f+FheEf/BnF/jX5Rf8HFXxd8MfFX4m + fD2Tw3rul65Fa6fcLK9lcpMqEuCM7ScdDU/ww/YR0n4peM9G1K2uPEFv4H1nSkvfNdEe9t7mSSSBLX5R + scmSNm3cDy0JO3oef8cfsQ+HLX9kX/hPr2a8uNYhVHEcqxNEGa9a2aIxY8xcKofzG+Qk4HrQB+fB+5Ta + 94PgXR2b/kH2hH/XFR/Snf8ACBaL/wBAyz/79j/CgDwWuo+D7FfHEG3IPlvjH0r1L/hAtF/6Bln/AN+x + /hU1j4T03SrgTWtlbwTKMB0QAgGgC5ECMZ61IDimquDTqAPU/wBj/wDai1T9kH4wQ+LtLsY9Rmit5Lc2 + zzGFZFfGcsAT29K9p/a3/wCCuXij9rL4LXHgu88OWOjWl1cRTyzw3rys4TJ2YKgYJI/KvkZPu0tBUdhr + LgU2nP0ptBQq/er9RP8AglX+xJ8Pdc/ZysvGXiLQtP1/XNekkI+2L5y28SuyBVU5XquTxnkV+Xafer6z + /wCCdn7ffjP4M3dv4DtIvD+oaPdTNLbLq149sIJGPKqwDfeJAwFJ79jX4742cN5/nOQfVuHqnLV5k3Z2 + cl2uexw/XwtHFe0xMbq33H6SeIv2IfhH4s0S4sLzwB4bMc0ZQSRWiwyof7yuoBU8nkV8N/8ABPj9rXwb + /wAEi/8Agov8ZtJ1rw94+8VWDaaum2I8NaRJqc0SC681TKFIwAuFyTncCPeu/wDiP/wVM+JmleAPFV+v + gfw1oR0G6uNMae41IyF7mJ/LkWJAo8zaT97O3jqTjOp/wbJ+K7/4g/t3/GjX9Xna61XWPC1vdXMp/wCW + rPfFifzJ47Zr4HwF4I4zyPFV63EVRunKNlFy5te56XEuOy7ERisLHVdbH0jq/wDwc+fBPwvBHca14D+O + Wg6e00cMl9qPhCWC2t97BQzuz4AGfc/Wuo/4OAf2hdQ8OfsL6H4J8G6hu8SfHzXbHwhpEtrISJILo75p + AynOwwK+GAIyy+tfU37cX7K2lftsfsreNvhfrEgt7XxdpklpHcld32ObG6KYDvskCtj2r85f+CfP/BN3 + 9pr4j/tXfCnWP2mLXQbPwX+y9pMmkeEVsL8XH/CS3efLivCoJwqRInLhW+VRjlsf08nc+VOV+K3wX0v/ + AIN7v24/hF42+Hfg7xdqHwr8XeGG8KeNNP8AD2myXsk11bxhorzaoI85n+c92+Yd+fff+ImD4Wr/AM0p + /aGbP/Uh3H+J/lX6QKMIOMe3pROAyLld1aInyML4sfE7SPgv8Ndd8V69dR2Oi+HbCbUb24kOFihiQszH + 6AV+Yv7Fn/Bev4lfGD9pX4f2/wATPhbb+DPg/wDHu5u7f4ea155NwXhcKi3IOQPM6Dpy3GQDS/FX/gg1 + +0p8b/h7qXhXxb+2t4w1rw9rEZt7+xl0aJY7qFsbkYqQcECu1/4LMfsKnwd/wSD8NaX4Cjk/t39nEaVr + egTwwgzONPUJK2B/E8XmEj+81SSfo9EqncwH3uCR3xVXxN/yLmof9e0n/oJr8nf2zP2//Gv/AAUF179l + v4U/s4/Ei68Ja78VbZfEniLWNIEc82iWMcOJhKOR8sokBXjJix3Nddrf/BHX9rKHQ7xpP25vGsiLA5Zf + 7Dg+YbTkUMmTsrn5J/CP9lTxp+1P8aPFum+EdN+1/Zdc1B7m4lkEcFuPtcuNzNxk9h1r7M/aN/YI+Mnx + q+FPh/w1Do/h6FfD/lyxD+1gwVli8sxw7kURq2NxDMQW9Kb/AMENvihovgXQ/HPgXW9ctj4qTxBcySXd + ywhfVhHLIjvjpncCxH+1X6CT+KNPFu5a/s1VRnJmXGPzr+KfFLxw4yyXiGrl2W4f91C1m4t8y7n6FkvD + eX4nCqrUl7z/AAP5/fiN8Oda+FPiy80LxBYTabqli+yaCUYKn+o9xwawa+lv+CrfxW8P/Fj9qi6uPDdz + DdW+nW6WdxcQ4ZLiVfvYI646Zr5pr+rODc3xeaZLhswx0OSpUinJdmfF5hh4UMRKlTd0mFa3gfx1ffDz + X21HT2jS4NvLbkuu5dkiMjcf7rH6Vk17l/wTa+EHh349ftn+DfCfijT/AO0dF1S7KXUHmtH5q7CcZUgj + oOhr6iJxn0h+zt+xz8dviB8I/DviDT9U+HuoaDrWlWpisNbgaZZIkBaFnQxELIgbAZSDjg5rxb4rfE74 + lfAr48+IPBV3J4Tm8S6hq8kz6hFYh/s1xeoqu0LkZjBV8cDge+K/f3wX+yJ4H+F/gSw0PSbe+s9K0mBb + e2i+1FvJjUYVckZIHqea8W+Jn/BLb9nj4l/FK48Ua3oN7feILudJWu2v5UMbJgIQFwvG0dQelUB8N2/7 + HHx4j8Drbxa5omnarHarGLqy1iZIXZY1QTGBrZsNtjThWClhuwGGT8CaX+0Z4w+GV3BpPmabqFvoLXtj + Jb39uLuG9WeUPP5wb/WbpEDAnDAgEEV/Sxp/wC8L3lt+5a8lh2lDiYdMY/u1+GX/AAXa/ZV8E/sj/tX+ + HfD/AIE0t9J0/VfC0OrXivO8xnuXvb1GkJYnBIjXgYHA4oA+c4v2wPH1l49s9e0/WpNF+weWlvp2mA2m + nRRxqwRBAhC4BdjzkksSTS61+134y8SfDW48M3z6TNDd2wsri/Nmp1C5txN54iec/MVEnzevGCSK8z2U + bKAG9/0HsKKUrikoAKKKKACiiigAooooKiFFFFBQq/er6J/YK/ZE8efGbxkPE3h/S77+zNIYhdRj1P8A + s3ZMeyy4JOOQwUHqea+dlPzV+uX/AASO+MvhfWv2UtN8P295Y22t6BLLHe20kqpI29yyyAHqGB69flPp + X5D40cbZtwzkX17J6XtKjdtrqKfVo9jIcto4zFeyrysjzr4g/so/HS2+FPjSP+wNF1SbWBqjRWNnrIjt + Vivn82U/ZyqrJNGQTGxII+tX/wDg1y0ybSv20Pi7bXFrNa3Fn4StYJo5QVaNxenIKnkfj6V9tar430TR + NNmurvVdNhtbVGlllknVVjVQSScmvzc/Ys+BXjr9vv8A4KWfGq/+Cfxm1L4M2405L6S+020S6bVIWuiq + qQ3Cjdl+PWvz3wJ8U+JeKK9fD51Q5YQSakouOvbU9biLJcNgYJ0JXvuf0FSDcleP/t2ftbaL+wz+yn4w + +JuuL5tn4ZsWmjtw2Gu5z8sUS/7TOVA+tfmn+29+wF+2Z+x7+zH4o+J2i/tdeNvHV14Itxq8mirpUMJu + 4YWDyjcAeiBjgg5AxVr9uz9rvRf+CvOofsf/AAh8E3i3sHxQvrTxx4utoD5iWVjaLmW2mweMTb+vP7nn + qM/01E+RPcv+CYX/AAVn+Jnx0/aRj+FPx88B6X8O/Fnizw3F4w8IJZ3Xmx6jYSAN5TZ5EyRncy9hnIFf + olI+0d/TgZr4l/4KYf8ABJK+/bd+Jfwz8deA/iNffCPxx8Nkngs9WsLNZ5jBKgXYMkAYxjGCCCa8in/4 + I7ftbSj5f25/GhOckNoUGK0iK3U/TrdlfX2rkl8aeD/ipe634Xj1XQ9auLMNbarpi3Ec0kAYYKyx5JAI + OOR3r88v2r/+Dln4H6T+zh40m+HWqeINV8df2TOmh2z6HcorXbIVjJJXGAxB/CvkHS/2SdY/4I+/DH9l + 39rSLVdam8T+MNUt4vi0bqV3Oo2+sASh5s94iVXB5DuD/DVEH6z/ALHX/BKP4I/sI/ErxD4r+HHg+30X + XPEm5Li4ad5jBEzFzDEGOI49xztFfQniZc+HNQ/69pP/AEE14r+2b/wUR+F37BPw60PxV8SddfS9L8S3 + iWeneRbvcS3DspcYRQWxtGScV876t/wcf/su32h3UKeJvEQkmgdVVvD90OSpx/BQDPwK8USyQ/EfxQ8U + jQyL4h1ErIpwyn7XLyDXuvx8sZNP/Zr8F6o32nT9YvLl7a5UGeAzQ+XuUlHY7wevmAAZ4r1j/glV+xl4 + M/a6uPGnxB8Qq2qaG2v3f9nWmWj84PPJJucdeARxX3Jrf/BOr4ReKoPLvPCkcrLH5McjXMrNCuOAuWOM + V/NvG30geGMhzepleMw7qThZOSSdvv10PrMv4WxuKoqtSlZM/EGTgn1JyTTa90/4KF/szaf+yr+0BcaD + pVxJPpd1Cl1aiTl4lbqpPt2rwuv3bhvO8LnGW0cywX8OpFOOltGfN4vDyw9aVGe6eoV9Lf8ABHj/AJSL + fD3/AK/T/wCgNXzTX0t/wR4/5SLfD3/r9P8A6A1e4c5/Q18TtfnXUI7KNtkajdJg43Z9a5WRPMX+hrpP + iZpcia0Lk8wyqAMeo4ry3xN8cfD3hP4i6b4Vvbp01jVgpt4hGSG3FgOen8JrhxmMo4aKlWkopuyv1b2R + 0UKbm9EegeE9Xn0fWbdVkYxSSBGTPBzx/WvyE/4OcP8Ak+Hwaf8AqRrX/wBL9Qr9efCWmzaxrMCqu3yn + WRyewBB/X+tfkP8A8HOB3ftz+Df+xDtf/ThqFdkGmrpmctz84z9ym05/u02qAKKKKACiiigAooooAKKK + KACiiigAAy1eifsqWLXnxv0hRYtqEG/dcoltJOyxAgswWMqcj64Gea88T71fpb/wS1/4J8+DfGXwRsfH + 3iS3uNQ1LWjKtvEtw8SRQh2jI+UgndtOQa/P/EjjrLOFMr/tHNIc8G7KKV7v5npZXltfG1fZ0Hr6ngvx + D8C2WqfCv4tWOmtDBH4T13VZorzUPNnt7i1jmRIbaCfftEw5ABB3ZNfQP/Bq8EH7YnxUZV2hvBtqR/4G + 4/pX0H4k/wCCbPwl8TeFrnR28Nm1s5y0ipBdSKIpSCBIFJ27hnrjOCa+Rf8AgmF+1b8N/wDgkn/wUS+M + ukfEbVtQgsV0ePSbCa1sZLp5tt40ilggJXMeDz3NfK+F3i7kXF1WrhsrpOnOCu1ZLTvodWc5FicDFSru + 9z9/NX0m317TJrS6hjuLW6jaKWKVAySowIKsDwQQelfOv7KX/BKb4F/sK/EXxB4w+HPgqy0HXPEAYXFy + ZHl+zRM25oodxIijJGcD+XFeNj/g5N/ZXint0m8Va5ax3EyQebPodzHHGXYKCzFcAZIq9/wX4/ao1T4K + /sHx6F4L1BofGPxh1e18HaBJbt+8dro/vJEYcjbEHYEeg9a/ZrWPBVz7I8BfEbw78R7a5k8P65pOtJYz + G3uDZXKTCCQcFG2k4I9DW8RX4o2vgvw//wAG3P7cXwt1C1m11vg38UvDD6T4vMaS3mNYt4w4vNig4Z3O + T/skivrj/iJL/ZbhRTJ4j8S8+nh66P8A7JVRDU+0n+Cfg1gP+KT8M8eulwf/ABNeZ/8ABRb9kO3/AG2v + 2L/HXwyYQxTeINNZLCRhgWt0mHgdfQiRVOe1eweOfGenfDnwZq3iDWLqKy0rRbSW+vLiRtqQxRqXdiew + Cgmvzk/Ys/4ODF/aW/ad8KeGfE3w11bwP4D+Kkl3F8PfEt5LhNca3fYUdf4Wcjj61RJ5B+xf+yv+0R+3 + b+1T8GLr9pLwDN4X8H/sw6c1pH9sCyReLtUjPlQ3AU5DKESNySMHB/vV+qviT4J+EV8P32zwr4aUrbSY + I0yEY+U/7Ndz1qj4oGfDeof9e0n/AKCaLtaoUttT+aH9ij9urVv2Pvij4y0ey0k6zo+seIr5TYRnYySC + 6lVfL7Dg4x9K+0NQ/wCComvaRqerafN8MdQiuNHtluLt5L6NYbfcMqrN/ePoOeK/PT9mbwN4r8V/tT69 + eeD/AAyvijUNN8Q6lI1vOP3EK/apVDM3Y9wa+19V+DfxYNtrC/8ACt5rWDURbztBaX0U/wBqkiiZCkvm + Ako27PGDkV+Acc8F+G+LzaWJz+dOOIlZtOVm/VH1eW5hm9PD8mFTlDyR8G/tR/tCa1+038Xb7xRrEcMM + lwQkUERPlwRr91R6/jXntanjfw5qHg3xTe6bqunzaXqFvMyzW0iFDE2Txg+lZdftmT4TA4XBU8PlqSox + SUUtrdLHzeIlUdVurfm63CvbP+Ccvxk0X4AftoeCPFXiKZrfRrC+AuZgM+SGBXcfYZGa8ToGCfmG4ele + mYn9W2kfGTwb8QvC9pd2utafeafqEKywTK2VkQgEEH34rx/xzq/7P8vxLW91rxV4bi8RaS6Rxfab0LcQ + HGRhc9ecg471+TfwA/4LOQfBT4K+GvCTeDJr5vD9hFZG4F0F87YuN2K+Yv2gf2kl+N37T178RF0w2K3V + 3Bci0Mm7b5SooGffZ+tYV8PTrJKpFOzur62ff1KjWnFWR/TPpPjHwvoFqzQ6pZsuNxkL/eGPWvxB/wCD + jD4q+G/ir+2h4T1Dw1rWn65Z2/gq2tZZrSUSJHML6/YxkjowUg4963v+H8sJsvJPgOZv3ewn7aME4xnG + Pxr879f1L+3tcvr1l2/a7mScKedgZiQPwBxW60CJU37lpKUrtFJQUFFFFABRRRQAUUUUAFFFFABRRRQA + qfer7C/YJ/4Kca1+zh4Th8E3GgP4ms5JyumpFJtmiaRh+7XscsTj3NfHqfer2X9jj4CfED4mfEfTfEXg + /wAMya1b+Gb2K6mmdxHbh1bOwsepx2HTNfD8fZPkGYZXKlxHy+wT3k7Wfr3OzLauLp1+bBr3j7m+Of8A + wV31b4QWcdtcfD+4trzVLZpbC5ku0kt5AGZCdy9drKQQOhFU/wDg3M1KL9oD/goD8bNf8WabpurX2reG + 4L6X7RbLMiO96T8ocHGAcfQV47+2T+x78YPiZYafd2fg+8k03w7DdTtGJojJ+9kDlI404CIAFAHXr1Ne + sf8ABrXaS2v7afxahuI5IZofB9orxsMMjC9IIPuCCK+Y8L+HOCctdapwtKDlKylyyu/Q7M6xWY1YxWMu + l0ufqJ/wUC/4J8+FP2xf2QfHHw7tNF0HR9R8Rac8dhew2EUbWtyvzwvuVQQBIqk4PSvz1/Yc/ZQ/aV/b + E/am+CI/aG8E3nhHwZ+yxp0ltDNdzh18WaomIYLlAPvARxo276/3q/ZMjivNP2vf2mNB/Y5/Zz8VfEjx + NIy6R4Vsmu5kUjdOR92Nc/xMSAPc1+vnixZ2WueCtH8WxRR6tpOm6lHAxeJLy1SYRHpkBgcHHpWdL8Gf + BpUBvCfhsjsP7Lg/+Jr40/4Jnf8ABYfU/wBsf4yXXw9+Inw7v/hf4u1DRIvFPh21up/MGsaZJyjr6OFw + xHpk193qPMA47UFH5T/G/wD4Jgft5ftB/CfXvBfir9pnwfd+H/E1o1hqEEOhPC0sDYDruByNykjit3/g + sN+winwG/wCCRXw5fwNHGPEX7Lj6Vrul3cEOJJRaKqXcmBz+8UyyEdzX6hMcCuf8R6doPxO0bV/DuoLY + 6pZ3UDWl/Zs6yZjkUgq65yNy54PvQZn5r/t8/wDBSj4gfH26/Zj+Hf7MvjKw0vxt8b1TXLjUvs4uksNO + WHMrSIOgVyQ3/XNhV3Uv2Kf+Chtvol1JL+1F4HkVYXLqPDp6YORnNfQP7CX/AARY+DP/AAT3+K2seM/B + Nnq91rWoQvaWT6neNcjRbZ3LvBbBv9WhLHgdjX1J4qTb4V1If9O0h/8AHTSd7aAfhv8A8EKPFOk6NoXx + C8OaxeWM/jxfEVw97MFEbX+2aRWdR6b8nA6ZFfoadsc29iFAHJPYV/PRf67eeGPil4nu9PvLqxuI/EOo + kS28hjdf9Ll6EV9KftPaxe+HfgD4f1vSvFGvQtqNwlqqNqVwZLyIwB3kdHxtIkyuRkEGv5G8Rvo1YniL + P55vQxjgqru01dr0PuMp4ujhMKsPODfLtYo/8Fd/Gnh7xj+1leNoUsE32O3jgu54GDJJMOoyPavl2nyy + NOzO7FmY7iTySfU0yv6T4SyFZLlFDKlJy9lFRu93ZbnyOOxX1mvKta1wooor6WJyhRRRVAFFFFBUQooo + oKCiiigAooooAKKKKACiiigAooooAVPvV+wf/BHvxr4f1P8AZA0vS9Mktf7Y0u5nGpRKw80SM5YMR1wU + Kc+1fj2p+evYP2IfDdx4v+NKQrrFzpNlYRi6vVgvjaveoGVRCjZG5mZ1HsMntX5Z4t+HT4xyb+zqdZ0p + KSknunbo0etkuaRy/E+3lHmVrH7kahfw2NjJcXEsdvFCjOXc7VUAEnJ6Acd6/M/9i/wP8Wv2kP8Agpl8 + arr9mb4i6L8O42sBc3d3d2H2qG+gN2QAg/hzJlvpXH/EzRtYvvhl8WNHTVtRm1Dwjq+oyzte6hcMlvp8 + UsaxiOQHynkCsAUbJOfWvaf+DVpfK/a/+KSM3J8G2zbc52/6cT/7N+lfEeDHgrW4LxNbE4jEe0lUSSS0 + Vu9u56Gf8RxzGnGEYcqXc9N/bQ8C/wDBQr9i/wDZv8SfFCb49+G/Flj4LiTUb3TLPQ/Lmnt0dfMwSSMB + ckj0BrU/4Kl/tSaV/wAFNdB/ZL+DvgW8W8i+OusWHi3XbWJ9wt9Jth5ksUuPu4mwP+2L1+r3irwtp/jj + w3faPq1pBqGl6pA9reW0yBo7iJwVZGB6gg4r5X/YZ/4Is/Bf/gn/APGHVvHHgux1a41y+gezsm1K8a6T + RrZ3LtDbBv8AVqST07Gv6KPl4nD/APBTD/gl14//AGhvjX8Kvid8D/HWj/DXxt8NrWfTkvLqzMyy2skY + RUwuAVAyMHsa87n/AGJv+Ch6oMftReBpE7BfDhyP1r9K9N1O11GNvst1b3fkuYpDFIH2MOqnHQjuO1Wa + B3PgT9q//g4h/Zt+HP7OHjTWfBHxW8M+JfGFjpNxJo2mQeZvurvYfKXlQMF8Z9ga+CPhj8JviJ/wSttP + 2af2tNa8beJtWm+NWqRWnxUttRu3lt2h1X9/bzbCcJ5fygjszDHAr9lH/YD+CwlWQfCv4fgqcj/iSQf/ + ABNcn/wVB/Yrh/bd/YK8a/C/T0is76808PohQBVtbuAiS32joAGRRQQdx+0v+2v8Mf2OvAml+JPiX4u0 + vwpousXCWtpdXZbbNIwLKAFBP3QTnGBivCfEv/BeT9ke68O30cXxu8JvJJbuqKPOyxKnA+5Xw/8Asw/D + f4zf8Fdv2mvgbo/xy+FXiHwZ4J/ZpsGPiQ63aMlv4q1iJfJiMYYASxsEDsRuXBbB6V+n3iD9gH4KQeHr + wr8K/AgaO2faRo8PGFOP4aOoXtqfhh/wTV/YR8N/tq+IPGXjbXLuS68Kx6/eiyitnKfbPMuJXD54O3aQ + fxr7T8Rf8EmfhH4htfLnttYYrGI4mfUpG8kYwNoJxXwr/wAE9P26Lj9j/wCI3jLwj/YdxrOgat4kvkt7 + OwXE0Ei3MqgRr6FeMewr7Wh/4Kn6ZqM2tW9j8PfG13eeH0zexeUi+Q2M7Sc9cc4GTjtX8Q+K+W+J9biW + rVyeVT2F1ycj91JH6NklbJ4YOMcTbm63Pzf/AG6v2Yl/ZO+Otz4bt7o3umzQrdWUjf6zyz2b3HTNeM16 + l+2J+0df/tX/ABpvPFV/a/YVYLDbWu7cbeNeApPr615bX9acHLMlk9COcO+IUVzvvK2p8Hjp0ZYifsPh + voFFFFfUROUKKKKoAooooKiFFHBZcjPI6034ofETw58JfGa6XLZajfXFvaWV25MqeW7T2sNwRjbnAMmP + woKHUV6X4t/4KpeB/EC+IFt/hHpVr/bXhqLQ4im3/Q508zN0vy/ebePf5etV9d/4Kk+DdWbX9nwl0m2/ + tfQbbSYsOoFpNFuzcL8v3n3c9+OtAHnlFel6r/wVW8FahPrnl/CXSYzqukwafHtKn7LLHwZV+Xq3fvXC + /Hr9uPwd8aPEdpqFr4J/4Rdrezjt3gsZUWOVkGC5+XqaAM6ivafi58VPBvir4B+H7PTNLsbbVLq3trmB + IdLjhksk2kSeZcqd85cjPzAY6dq8WoAKKKKACiiigAQfPX6Df8E2v+CZ3hT4x/B618c+L5L6aXUpn+xW + 1vMYlVEYrvLDnJI6e1fn0v3q+4/+Cb//AAUwm+CfhK1+HereHdT8QL9pxphsGHmjzDkRlW4POSMetfjv + jVhOJ6+QuPC9/a3V+XSTj2R7OQVMLDFqWL+HbXa59ceJv+CWvw38ReDNR0WGbxBYw6hK90SupSMDcNnM + jAnDEkg89xXzb/wR9+P/AMNf+CW//BRL4y6H8WfGml+FYLfQ49Ksrm8Dbbxluw4wVB5KYNe5+Lv+Cptp + a+APEWraZ8O/Ft0vh95re7klEaQ28sTBXDEEsVRiNxUEL3ry7/ggX4e0H9tX/goF8ZvEXxD8L6L4knv/ + AA5FfrDqFsk8dtI98c7FYcccfSvz/wAAsDx3h8TX/wBaFL2TXuqbu+bv6WPT4mqZbNL6pbm8tj9GrT/g + u/8Asl397b20Pxq8JyTXUqQxrmYbmZgqj7nckdeKzf8Aguh+1zrX7K/7Ct6nhG5aDxv8RNStvCHh14n2 + yC5u22l4z/eWMO//AAGrH/BQz/gkL8Mf2nv2OPHHg/wr4I8I+F/FOpae0mj6jaadHBJb3cZEkXzqMhS6 + gH2Jr4b/AGPPDnx7/wCCnv7VH7P+lfGT4a+JvBHhL9lmyM3iK41q3McHiXW4lEEEkRxiUbUzuXcvzOc8 + iv6iPkYi/CaO1/4N2v24fh1o/jLx5q1x8IPjR4ZKa/qGrzy3C2GvQKHedSclVkc4x2U190/8P5v2RyMf + 8Lw8KfgJmP8A6Lr6S+J/wL8G/G6xtLfxh4X0PxLDYsZLePUrRLhYWIwSu4HBxXHt+wR8Eyu0/CvwHt7Y + 0eD/AOJoKPU/EniCz8KeH77VNQuI7Ww0+B7m4mkYKsUaAszEngAAE818D/sb/wDBwd8O/wBsL9p7S/h7 + F4M8XeF9L8YSXSeC/EeqIEsfFRt3Kv5QwCueoGWPIBwTXjH7QH7M3/BT79pv4K+Jfh/4h8U/s+2ei+Kr + J9OvZ9P8+C5EEnyyBGEPBK5H40//AIK1/sKv+yH/AMEm/gz4h8E2sDeL/wBle60rWIry2hI85IwqX7D+ + II5Z5SOeVGRxwGZ+s8a4H1qn4lbHh6+/695P/QTX50/8FHf+Co3xFsdG/Zy8I/s03HhfVPiF8eXiv7Sb + VYPtVrb6eYBI0kgXcUUMwDMAdu1xgEcc3q3hf/gqc3h+6efXv2aVTyHLoLecOVwc4/c+lTJX0Bn5A/DT + 4e618Sf2ktcsdEsdZuriPxPqErtp1uZpYUF5LlgMgfmQPevt/QvAvjb4cT+J7hfh34wuVvr6LVba4bT4 + XmLJb+S0WzzWI3cfOASMnAq9/wAEKHs/+EP+IcesPpr+Pj4huDqjW4GJB50hby8jPlh93THGM1+gbR5j + bb97tX8d+Jf0js24e4jq5TgsKnCm0ryTu/NeT6H3WT8IUcZhFiKk9WfzxeJ1uovEeoC9tJrG6+0yGW2l + Uq0LFiSpU8jHTFZ1fVH/AAWJn0H/AIbGvl0WG2W5FpEuomDG3zsc546+tfK9f07wfnk85yehmc4cjqRU + uV7q58djMP8AV60qKd1F2Ciiivp4nMFFFFUAUUUUFRO0/Z58G6b8QfjV4d0XWLLVdR03ULsRXFtpozdT + Lg8R+9eJ/t36bb6J+1n4y0+0t9WtLPTJ4bG2g1OMR3cMUNvFFGkgHcKij3ABr6A/ZCYJ+0p4PJbW1H29 + edI/4/Rwf9X7/wBM14X/AMFA42uv21/iAkZ1ht2q4zq3/H5/q05l/wBr+mKCjxpPu0rrujqxbWC3Ejqs + o2xttZtp4OcdBQbIqGG6P9221gT0/SgCtGmKS4g81P4OuctVwaex3bWj+Vguc8dMnmor6L7NFu+WVSOC + OQaAPunx/wDDLQdH/Y++F/iS10nxVba3qlksVzeXqBbG4Vd2PK9a8hr3z4nyrJ+wD8Ifm8asy2vTUP8A + kGDlv+Pfnn8vWvA6ACiiigAooooAVfv17l+wPpOvL8U7vVNB8C6n41khgNuGtZDD/Z5Zk3MHxtDFQyjJ + HDk9q8NT71fsV/wR7Tw/N+xtpLaO0J1KO5nXVFQjcJvMONw/3duM1+T+MHiBieEck/tHB0lUm5JWey83 + 5Hr5FlccwxX1epKy3PAvHekeMvDPwW+KFvN8MfGWnReKH1eSGAQpdsjXcsUiy+YkhZI18rLxhfn3deM1 + 03/Bqwm39r/4qq25XHg+23Kd3B+3H1r76ubdZoWSXaUcEMGHBGCT+mTz6V+ZP7HEHx61D/gp98dF/ZKv + vhzYsLTOpN4kR2tngF1/yxMatz5pb8K+I8EvGjH8ZYithcfQUHBJqUb29D0OJOHKOWqNSnK/Nof0FOPl + rhf2ifjx4d/Za+CPib4geK7kWfh/wtYyX95IB8xVR91R3YnAA9TX5d/tYftDf8FMP2LfgZrHxO8XXXwL + 1jwv4R8q91W30i0mluzbCRRIVVo1yApOcEEDJ7V1H/BZX9pbT/27fhb+zD8G/At79qj/AGkde07WL6FG + DMuiRKtxLvIPykSGNT67XHav6PPlonv3/BNX/gs34d/4KFfEnVvCN14H8S/DXxRb6XHr2mWGuKBLrGly + NiO6i4GVIIOMHg5yRzX2pnKj7tfnj/wUn/4JsfGTW/2k/g18Yv2Y9R8G+HvG3w102fQLhNdaRLa5094h + GkZWNG3ADIwQMZ46VzI0H/gqih3Nr37NoU9NsVxn8cwigo/TpTkVg/Ev4baP8Xvh7rXhbxBZx6honiCz + lsb23cfLLFIpVh+Rr5o/a1/4LEfAz9n/APZp8beMtH+Kvw28Saz4e0i4vLDSrLxJaT3F/cKh8qJERyzF + mwOAeK/Nb9nrxT8f/wDgnv4r/Z1/ai+JHxU8U+MPDf7SmorY+P8AQNRui2naKL/99YSwRMSsKqgyGUDY + NqcKxFBmffX/AATy/wCCEnw9/wCCffxxl8d2fivxh441LTbKbSvDEOv3CzQ+FLKV2d4LUY+UHewz6E+p + r7S8TR7tCvv+veT/ANBNYPxW/aC8D/Afwza6z448X+GfB+k30qwW95rWpw2NvNIwyEV5WVSxAJAByRXm + fiD/AIKVfs9zaDfCP43fCSUtBIBt8W2DZO08cSZ/KjfQD+a/wD4y1DwD+0Rq1/p+q65pLL4m1BJJdJuT + b3RU3koIVsHr9DX0je/tCeN7/wAc/EPw9N4++Ikf9j2El3poGsMEgVYlfEjAAsTuxxt9/Ss//gnZ+wu3 + 7XnxG8Y+ND4kvtF0HSfEl6bO90icLPcyPcyuGhl/hAU53DrkYr7Zn/4JhafnUJ4fip8Yo73Uo/KuJj4i + djOoG0BxtG9QDjBPT0r+e+NvFjgPK84ngs3pqdeFk2oc1vJvuj6TK8jzPEYfno6RfS7R+Od3qU+rTyXV + 1JJPcTMWkkdizOxPJJPJzUNer/tk/swX/wCyf8ab7wzcXX9qWgAntbtVOZY26Fsk/N68mvKK/a8jzLBY + /AUsZl7/AHU4pxtorPVHhYmjOjVdOpugooor14mAUUUVQBRRRQVE9K/Y/m8j9pTwi/8AxUHy3v8AzAxn + UPuN/qR3b+ma8J/b9lb/AIbP8fyL/wAJBu/tLd/xO026gP3af64dm/pivYP2dfF2m+A/jZ4d1jWL7XdM + 0uwuxJc3WjMFvoEwctESD81eK/t03tvrP7W/jLUbO6168sdRuYry2n1uVZL+eGW3ikjeVl4LlWU+wIB5 + zQUeXvqTosnkqsPnY3Ffvdc9aP7R/wBEWPy0OG3bj1b6+tQ9aKALK6kGLboY9rHOMdDUF/MLqPbhY1A4 + BOAKbmkJyP4T9RmgD9Cfic+P2AfhGu74hYW2AxqqbdJ/i/49T3//AF14HXrPjv4l+HdY/ZE+GPh2z17x + 1ea7ptksl3YalOj6VbK27H2ZQNwH1968moAKKKKACiiigAR+a9x/YHg8Yat8Yvs/hvxF4i8P6dHGbnWH + 0i8MM9xAhVFRVBG5i7KBn7oBOCAceHKOa+4/+CdP/BLOx+P/AMM4/HnifXNY0m0v7iRNPg0p1gmcRtjz + GkIJyGGRjpgV8F4hcUZHkeWPFZ+k6V7Wte7fl1O/K8LiMRW5MLpLuZvxO+PXiq08H/F7R/FHiL4gK/h2 + 9m0fTpv+EgdReSyzFYIXiCYKrAHkc78EJjqwr2X/AINYX/4zH+K+3d/yJ1p945J/0zvXYeNv+CN3grxN + od5ap4z8d/aLqVrsNfXy3ULXRXHmumxcswADNnJwOeufPv8Agg54v8J/sO/8FA/jRofxM8Y+GfBv2Pw9 + Dp8NxrGrRWMd46XhP7syuN2Vw2Bzg+nNfNeGPH3CGfVKlHh6KhOKu1y8ra7+Z051lWOoKM8W2101P3B+ + Jvw+0f4ufD7WfDGv2MOpaLr1nLYXttMu5J4ZFKOpHuCa+Lv+CfP/AAQg+Hf7AHx+k8f6f4o8YeNL/TbK + TSvDFt4guxcQ+FbKR2Z4LbjIB3sMnsx9a+gbf/gpB+z3PPFCvxw+E7STyLDEn/CWWJaV2IVVUebyxYgA + Dkk15j/wWq/bL1T9i39hHXtb8MSrF458S3EHh3wwobEh1C6cRxsg/iKAs+B2Q1+xHixPrgnJpsnTt+Nf + jv8AskeM/Gn/AARI/bu8F/D341fF7WvFXw1+Onho6lca34s1gNDoXiGJRJPiWZsJE5bZyRnIJ9v0gf8A + 4KQfs945+OHwm/4D4usR/KWgDgU/4Iffsjwsrx/s+fDFHVgyn+yEOCKP+CsP7Dsf7Xf/AATh8YfDXw7Y + 21rqFjp0Vz4aggjWOO0urPbJbJGoxtGY1UAEYBIr6k1C+h0jTprq6mjt7e3QyyyOcLGoGSSfQAV8X/sj + f8F5fgT+2j+01c/Cvwrfa3b6pObgaHqV9ZGHTvEwgbbIbOXP7wDBPIBIGRmgk+CPgx418Qf8HAH7RXwE + 8C+OvAGvaX4J+AunG++J1vrunslrqWsRL5C2wDcOJNpY5AIEjcfLk/orrf8AwQ+/ZFtdAvHj/Z6+F6yR + wSMrro6BgQpwc+tfWUcW4Z/WqviQbfDeof8AXtJ/6CaH5gfzo/8ABM79ufQ/2MfFnjDwTquj3T+F7rX7 + xdPXTLfzZLBkuJYwixjGVK7RwSRgcV9wQ/8ABUT4d3surQW+keOLy50RDJfQR6BMXtABnMgI+T6mvyJ8 + D6VqGqftG6kumzahbzp4nv38+xhea4t8XkvzKifMT7Dmvqg+Ab/wn8RPHHi6NviNA2oWo/s9ZvDt/Hay + SmII0s4CnJABxnglutfzrx14McF5xm0sxzKsqdWpZtc6jfpe1z6jA8R5jQo+yoK8V5HhP7cP7Tf/AA1n + 8c73xJFZSafp0KrbWMEhzIsa/wATY/iPXFeP1NeI8NxIsiyLJvOd67Wzn0/xqGv3LIcrweW5fRwWXq1K + EUo9dEu587iK8q1R1J7sKKKD908hTjgn1r2DEM0Zr7c+In7FXw/NzpJ0/T5Ik0++8vU4rTUJZJJR9ga6 + VJfMB2u5RgDGTgds4FcJ4G+DXgv4jeBJPHTeFbzSY9Bs9Unn0KC/maPVGtvJ2HzHLSIP3+XKkkiMkYyc + AHy9mivqnwn8KPAstjpGuXngeHy/E3g3V9ebSJ9Ruc2Vxp63O1oyGDGGbykOHLMOQDjBHzBrWp2+r6tc + XVrYxaZbzOWjtY5HdYB/dBclj+JJoKiVf8MZ9Kd8UPh94T+L/jNNYk1fWbG6urOwsmi+wxtGrwWsNsTu + 84cExbunANNYbhTfLoKPRvE3/BKbwroza81v8aPC90NH8PRa5EEEe68lcuPsa4lx5g2gkAE/OPbNbXf+ + CWHh3Rv7e8v4yeF7h9H0S31eAx7P9Nlkzm3T9799MDI5PI4rgvLo8ugD0jU/+CT3hOw/tor8a/Ctwuk6 + TBqMZTYftkknW3T9795e/wDKuF+N37B3g/4LeLbPTG+IbeJo7qzjujc6LaRTRxMwyY2Jn4I6f4VR8ugJ + g0AaHiG7sXOn2untdPa6faR2iPcKqvJszliFJAPPqao5r6e+AX7O/g3xt+y3da7rFms2rMt/IkkF5Kt6 + PI2bPKhB2OBuO7I6c1c8VfC34W+CviTpel6hp2hx2UtsG3/ar8yC4aJWUXRGQiFjyYxn6UAfKtGa+pfH + XwS8K/Cz4XXWq6p4d8Nw60+pTxLa3Op3sivEu0oIDGwBXBPLnODXmX7Sek+GdC0PwidB8MWWhza1pUWp + 3MsV1PMXdxyoEjsAv0GfegDyeigHNFACr96v0L/4Jg/8FHdL+H3w5s/hrr2i+INQvNPaR9Nl0mwa8eaN + mZyhRfm+TJ5AIr880+9XrH7Hegw6z8ZLeS6l8RR2tjC1y8ejW80012yMpSFvKBYRs20scHhfXFfC+IHB + uTcSZY8Fnj5aSd+a9rNeZ6GV4+vg63tMPrJn6ZeLP+Ctvwz8P+GNU1KCx8V3raTKbeRDpMkKxXOCRE7t + hUb5TwTnANeE/wDBGf4F/DX/AIKa/wDBQn40a78Xvh/4d8aw3Whw6rZ2msWq3Edg73e0bB/CRGFT6LXi + XxH8AeIbr4PfEr/hJJPFVv8A21r7a5bLN4evYbJ2HntKQWXbGZGnK84x5f0z9E/8Grxk/wCGzfi15jDH + /CHWnHcf6Z3r5Xwz8MOFuG6k8TkNT2k5pXfNzWS6HZnWcY3GxSxGlulrH19/wUJ/4N9/gL8Tv2O/HWl/ + Cj4O+BPCPxH/ALOe58Palp1glvOl5F+8jQPkYDldhOeN1fKP7OHxi+IP/BbH9p/9m/wb4q8E+LNA0P8A + ZrhXWviTLrNnJDHPr1uggiiO4j94212x97965xha/cDINcx8YvitoHwI+GGueMPE15Dpug+HbSS9vrl8 + BYo0GSa/ZDwYnJftI/sW/Cn9sSz0qH4oeAPC3jq30ctJZR6xYJci1dgAxTcMjI4NeTv/AMEQv2SSPl/Z + 8+Fye66Kg/lUH/BOn/gsh8Kf+ClPiPW9D8Gx+IdH1zRrZdQWw1uy+yTX1kzbUuoQSd0ZPftkZ619ZM4X + 1/AUFH5IftMfET/gpt+0p8AvFngKT4B/DzwxD4t06XS5dTsPFMDXFpHKpR2QGbrtJx6Vl/8ABTP9gyT9 + gj/glv8As7+OPCmm2tv42/ZZ1HS9Uvrq1482OTaupDcOWQzP5mT2jH4/sOGzXK/HH4OaH+0F8IvEPgnx + JbfatD8TWMtheRdzHIpU49xnNBmfFn/BS3/gqz4y/Z+8L/AnSfgb4b0L4hfEL45XNudG028uTHby2jwi + TzSwKhcsyDcSAATnpXnWrftW/wDBTJtCumuP2Z/hT5fkvvK+LIflXBzwZetdj/wTf/4IXH9ir9oHTfHP + i34mat8Tm8E6ZNofgW0v7fy08N2ErliAcnfJhyuewPGMAD9APE//ACLGof8AXtJ/6CaBSbS0Pw5/4ITe + F9N1Lwp8Qta1aws7fx83iC5GowZ8xrDdNIzoh5yu/cMg4OK/QJiyRE/Lx6jcPyr8G/hL8Ztf+DX7RWuX + Oh+JtQ8MifxJfw3VzbRibMZvJM5iPyv9DX1l4Y/a0+K/jf4l+M/CZ+JGrQnR7Jp7W5jsLNGdPLD5ZW5J + 5xhAT3r+MfEz6PPEOecR1c1wWIXs5tNXdnHyR95k3FWEw+EjRnG7W55T/wAFf9A8P+Gv2vbyPQ7eG3ku + rWOa+WBQqCc8kkDgEj86+Wa0PFPiPUPFuv3moatfXGpahdSFprmeRnkkbPUkms8DFf1RwnkdXJ8ow+W1 + p88qcVFy72R8djsVHEYiVWCsmySzs5dRu4reFQ00zhEBOMknAr6z+Hf/AASh1668LC+8dahe+E5rqUCy + hiskuxcx7VYvnzV28nGCPevlDR9SOj6ta3YTzDbSrKFJxuwc9a/Ur4MftpyftcfCw6hd6PDoaeG7n7LJ + tm8wOohQ7ugxxX0kTlPO/Ev7I/ifxM+nC8+NHimaPQ7hZ7JBpEaLDIowHG2cZIHGWyccUap+x74i1jxt + ZeIJvjN4qbWNLheK1uE0iJPIVvvBVWYKN3Ocg575r85/23/+CyXxA8Z/FHVNL+HesSeGvC+mzNbQTQRo + 1xehTguWZTtUkZAHT15NeAj/AIKO/HIFj/wsrxF83o0f/wATVAfsJrP7DWqeKvFV1reofFzxJdanPYS6 + YZZNHjwtrIrRvCqicKqFHYYUAfMT3ri9V/4JKtceHrz/AIRnxRqOua5HAZbTT30uOFblgVypfzjt+Usc + 4P3fevzf+Cv/AAVx+NXwp8V295d+KrjxLY+YDcWOoxo6TDPOGChlOPQ49q/ZL4L/ALZ1nd/s2w/GbQ7F + 7y2Gkm++xySbWWQv5bxE842tkfhQVE/On4tfCbXPgh42uPDviSzbT9Ys9vnwEhtm5Qw5GR0Irm69I/ax + +P8AJ+038bdS8XzaeNLkv0ija3EnmBPLQJ1wOuK83oKCiiigAr2r9mL9hnxl+0xFDqmn2c0PheO5MF9q + UYSQ2oAyTsLKW+leK19lf8E1/wBuuX4R6ZD8M10SG6h8S37b71pfmi3rj7uO31oA6vw7+wFceEbS0h0z + 4pa9Yx6f5rwImjxjYZRtfj7RjkdRXQ2/7M3i6zmg8r41eJEa3QRxn+w7Y4XAAU/vcEAcc14v/wAFXf8A + go9qn7Htnpnh3wmtr/wlmtRtMbmUeYtnD03AZ+8e2a/NTUv+Clnxyv7qSZviRr6tI24hGRVH0AXAoA/Y + m7/Y61680XUtPm+MviKaz1V3lu4pNHgdZmb7x+ac4Jx+lcpq/wDwTOs/FBs1v/iVrV0tlAttbh9FRvIj + Xoo/f9K/Jux/4KUfHSw1CO5T4ka80kTblEhjkX8VZSDX6Z/8En/+CjWoftg6FqXhzxYtuvizQolmM8Sh + FvoSSN+P7wPUD26UAea/tQ/sO+MP2ZWn1K+tZLnwpJem10/VX2Rm8BBKN5asSuVGcc49a8Zzmvsn/gpR + +3RN8Wbe++F8mhxWkfhPV2Rb0S7muPLDLyuOM5r41HyCgBV+8K/Yb/gj/wCHtB0v9j7SrzSVt/7Q1C4m + bVJF/wBY0yuwUN7BQMV+PCv81e4/sRfHjxV8LviZDpei+JPEWk2OtOsb2+mW8d15khICsY5PlAGSSwwc + A1+R+MfAeN4syN5fl9b2c1JPXZ+TPYyLMoYHFKrUV01r3R+3l7bR3lg8ckMMyMrAxyKGWQEEEHPHQmvz + J/Y28ZfG74H/APBTf442v7Lfw58L/EFlsxDf2uqakmnxWMAuifkJcBsS5UY7VveJfiv8W/F3wV8cTXHx + SvI1sYNZl0+4tba2hgv4LGSRXVXHzB5I4pXGwHaFGSMiui/4NbLh7z9tD4uPL50kknhC1ZnY5LE3gySf + evhfA/whzjhDEVsRmVZS9orKK1Xr6nocScQYfHqNOitj1j9oz/gp7+39+yP8KdQ+IHxD/Zz+Hel+C9Ba + KXV7u08QrdSQQF1UsESQnv1wQOtdl/wXQ/aDt/2qP2fPgH8H/Ad+95J+0x4g0928ptsp0MKk88mBkfxR + IwPGHb0r9GPjP8I9D+Pfwm8ReC/E1nHqGgeKNPm02+t3H+silQq2PQjOQexFfDH/AATs/wCCDlv+xl+0 + XpPjzxZ8S9Z+Jy+AdNn0TwBZahbCKPw1ZysxYdTvcBmAbtn2GP6WPlYnOf8ABQn9g74zfCP9rP4KfGj9 + lfwboGu634D0KXwpq+j3GoRada3mnCFUhRyzLvVQCBySCAcU2b9q3/gpifv/ALMvwr2Z4H/CWQ8f+RTX + 6ax/0pJI1uBhs8c9aA5jxP8Aaz/bo8C/su/s3+NPH1x4i0XUI/Cukz6gltBfRPLdSIhKRIAxyzNgfjX5 + V/sw/thftO/sq/E34B/Hn4z+NLnxD8Mf2nr97HU/D0sQFt4Re6Jk09oT1QGIZ5yCoIOScj7Tuf8Ag27/ + AGR7pFWb4cyzKpyVk1a6ZW5BGQZMdq6P/gr7+wzH+0F/wTE8R+AvB+nrDqng+xttQ8LQRZzbTaeFaCOP + uPlTZ64OKCT648QeL9M8Lacl3q2oWGl28hCrJd3CwozegLEA1zHiT46eC28Nah/xV3hpm+zSAAalDk/K + f9qvxsi+OH/EQ18av2cvhfJo+uQ+D/hraf278VormOW3WG/hTyfsm7jmRgxGOQHB7V9qax/wbj/sl22h + Xky/D268yOB2U/2xdcEKSP46N9yep+TH7Cf7Dep/td/F/wAaeIrLVo9F0fQfEd8RfNbpc+bKbuUqERsq + 3HPPHSvs/WP+CWupXNzqWpQ/EqY6tqCBXvG8PWay427cBlAK8cZHOK+Z/wDgll+2d4P/AGO77xl8Pdej + bTdA/t68bT7oKZBD5dxJHsY8n7oHJ9K+2Jf+Cm3wbEUu3xQJJI13GJIHZzjnpjNfxB4r8VeJmH4mrUMq + jNYdNcnLG6a7t/mfonD+Dyipg1LENc3U/JX9qj9nbVv2Xvi3e+F9UkjumhxLDcR/cuI25DD0+lecjpXu + H/BQL9pmw/ao/aBvte0mKSHSbeNbW138O6r1Zh7+navD6/rjgzE5liMkw1bN48tdxXOvPqfD5lGnHFTV + H4b6Do42mlVY13MxAA9a+6v2DvhbrOj/ALP3ijTdY0/UNH/tq9dInuITGWRrdFLLnrjNfDuhaguk65ZX + UgYx29xHKwHUgMDX6sRf8FBfh7+0R4H0/wCyalHosmisIJY9SlWFpMxr8yjPK9Rn1FfTnHE/ng/aF+DG + u/AP4ua54Z8QWc1re2F06gsDtlQnKup/iUrggiuI61/Qh8YPCnwR+PyQjxdP4J1loBiOWadPOUem8HOK + 84H7En7LKtj7D4N5Of8Aj/P/AMVQUfh1p2nz6pqMdvbwyTzzNsSNE3MxPYCv3E/Zu/Z88Q/CT/glnN4P + urK6uPEcmiSzvYxIXmSSWYS+VgckqGAI7EH0rpvhv+z3+zj8Htaj1TQbfwPa6hG4dJzcrI8bDoVLE4Ne + z6J+1v4D+Dl1ceJLjxFpeoQ6Vbs5trS5WSecthAqgdTkigqJ+VniPwxqPg7V5NP1ayuNPvoQPMgnQpJH + kAjIPsao169+3R8eNL/aQ/aR1rxZo8U0Om36QRxCYbZMpEqnI/A15DQUFFFFABXsH7Ffw48Qa58e/C+q + 2Wj6hc6Xa3ymW7SFmhjIzkFgMDHvXj9fdn/BMv8Abt8H/BL4T3XgHXDcW99rV+7pdthbeEMuMux6UAfH + f/Bfv4Ea0fiboPj62t7i50SSyGnTuqkrbyISRn0yD1r846/o98T+OPh7430e403WNe8I6pY3YKzW091H + JG49wa8Suf2Kv2X7+5kmk0zwUrSMWIjv9qj6ANxQB+F9fo3/AMEC/gFrX/Cx9f8AiBcWs1tosNkdNt5X + UqtzI5Vm2+oXaOfevre0/Yp/ZdsrqOaPTfBe6NgwEl9vU49i1ez+GfH/AMO/BujR6ZpOteFNNsYfkhgt + 7pEjjHoFHHPrQB8Pftu/D3XNF/aI8bavdaRqFvpN3rUxgu5IWWGXLEja3Q5x2rxsHIr7m/4KcftzeD/j + n8K7PwFoH2m6vvD+pKZbsAG2mVFZcow6gk5FfC8abExQA5F/eV9vf8E0P2AvFHxK0RviDD4sHhG1ulms + bN4rKO7muEPyyHbICoBxjI56jNfES/er9G/+CY3/AAUY8F/DT4I2PgXxZPNpt9o80wtplhMqzxu5cD5c + kMCx49PpX4543ZpxNgMg9pwxFuo5LmaV2l5I9rIaeFqYtRxfw2PSPE//AASx8QD4c61pGmfFK8jj1CKZ + RbSaNbQxESFWkjVkGY0com5UwDjpyc8v/wAG5dhB+zx+378aNB8Valpuk3Wl+GYdPkN1crEryR3vO0sc + EEHP/wCuvbvFX/BUH4P6L4VvNSh8RSahFaZX9xauwZ+y5xgE9Oa+Vv8Aglp+y/8ADP8A4K0f8FDvjNqn + xQ8Nyappv9jx6rp9tHdyW5ty92Y1yYyMny8A5781+feAefcc4/FV48TQfskvdclZ37I9HijC5dThCWD3 + vrY/dX/heXgssq/8Jd4a3MQoH9pRck9B96vC/wDgrn+2tdfsLfsOeJ/GuiiObxRcmLSfD0TDd51/cuIo + cL/FgtuI9FNfJv8AwUC/4NxPgvH+yD42uvg74QvtJ+JWl2X9oaFMuqXExaeFllCBWYglgpUe5FeIeAf2 + r9W/4Lp/tCfst/DuHR9Wt7D4QeX4r+KTXlq8Mdvq1qogWE5AHzMXOP8ApoOODX9SHyUT1n9gb4//ABv/ + AOCe37cHhP4S/tGfEaTxtofxq8M/27pmr6mUhXRtXRd9xZ7+BsGdozxnGMV+nB+OfgmT73i7w6PpqcI/ + 9mrzn9sv/gm78H/2+7TQofij4Vj8QL4bd5NOZbiS3a3LgBsMhBwcDj2rwS+/4Nvf2SpQu34eXSnOc/23 + d/8Axygo+8SlI8W5SM9a/Mr/AIe5ftkf9GN+Lv8AwZJ/8VR/w9y/bI/6Mb8Xf+DJP/iqDM/Rvwv8MfDv + gi/vrrRtC0fSbjVJPOvJbOzjge7f+9IVALt7tk1d8Urt8M6gf+naT/0E1+a//D3L9sj/AKMb8Xf+DJP/ + AIqqevf8Fbf2xp9DvEb9h3xZGrwupY6kmFBU8/eoA/G3wu19cftFagNPFv8AbP8AhKb4xmdN8an7ZLks + MEED6V9ZeEIPB/gH4veML/X2vm1LXImWG7g0p5rWGAwAMFIUKrsw/AV3/wDwQv8AhvofjLQfHnjPW9It + Y/F8viC6E1rcqJH0vfLI7RjPfcSuf9mv0Cl8OWUytHJb20kbcFWiUqR6dOlfyh4hfSUXDuf1MnpYNzjT + aTk3a/ex9tlPB/1vDe3c7N7H88mpLGmp3QiLNF5zbGZdpYZ4OKhr6c/4KzfDHQfhp+1pfQeH7eG1t722 + S7lghxtikbrx2B64r5jr+j+FeIKed5VRzSjFxjVipJPdXPj8dhXh68qLd3FhRRRX0BzxCiiigoKKKKCo + hRRRQUFFFFABRRRQAUUUUAFIRmlooARRiloooAVPvV6v+xpqNx4f+P2j36zQW1rbuDdyTQmRfJLLuAGC + dx7Y5615ODg1+u//AASH+EnhzRP2TtJ163tLGbWNamna8uXRZJAVkIVM9VAAHHvX5j4reIceDsmeZul7 + RtqKXS77nrZLlUswxDop8qte58aeEvGEfw8/Zt8ceH9c0+OS3a2vrOweCOQ/bLi4eNo7h4ymMRbSQ5II + 2kAc19Ef8GsbKP2xvimq5+XwZbcdcf6ca+6tV8GabrelS2N5p+n3NrcIY2jlt1dWBGDwfbNfmr+xb+0H + 4u/YJ/4KbfHK2+Dvwh1j4vQyWC2L2OkTKh02EXW8MxPUBj5f1U18T4P+OC41xNXBuh7KUEpb3TWx2Z5w + 9LLoqTlzJn9BRG5fQ9vasnw18PtB8GX+oXWj6LpOl3GrTfaL2W0s44ZLyTn55GUAu3J5bJ5NfnKP+Czf + 7TzL/wAmT/ED/wADE/xpP+HzH7Tv/Rk/xA/8DI/8a/oQ+b6H6Z0EZr8zP+HzH7Tv/Rk/xA/8DI/8ahvf + +Cy37TrRj/jCjx8vPe7T/GgLM/TspgU2mtfQ7f8AXRf99imfbof+e0X/AH2KCSWqfiP/AJFzUP8Ar2k/ + 9BNT/bof+e0X/fYqn4ivof8AhHtQ/fR/8e0n8Q/umh3toB/MB+yn8bPF3wk/ax1K38L6+uh/234jv7W4 + MyCS3dTdy8uhIBx2zX1nrv7ZXx3ury4s7LWdPiS3v0srxrjRUhlt4XjLi4GCQV4IBr5q/Y9/Yr8RftWf + HLxdfaa9hZ6ToPiK9a5ub2Iywu5u5iI9n8XA6Zr7Fl/4Jo/Ectrlxb/ErSRJrGmrpL266TtiS3XJVIxu + +Qj+8Oa/n3jjPvDLD5vKjxJGlLExtzNxd/nY+my/C5xOhzYVyjDsj8zfil441T4h+OtT1XWNTm1a+uJ2 + 8y6lPzTYJAPtx27Vz1dx+0F8Ade/Zv8AiZfeGPEEaLfWh3CSM7kmQ9HB964ev3DJ62BrYKnVy63sWk48 + u1uh8/iI1FUarX5utwooor0jEKKCcCigAooooKiFFFFBQUUUUAFFFFABRRRnFABRRRQAUUUUACHLV7j+ + xf8AtV/FD4P+NLPwx4G1a3WPxFdx26Wl7GJbaOV3AEgB+6ecHHUV4en3q+q/2EP+Cc/jX4/2Nr46sdXh + 8L2VheB9OupITLJM8bcsq5HAIxz1r4Tj/MOHcJlspcT8rw70tJXV/Tud2W08XKtbB/Edt+05/wAFLvi1 + 4Y0a3sdP8RQyWuuQyBb9dDWzZlB27oWJJIOfvD1r1f8A4NcdSm1f9tj4u3V1JJcXVx4RtpJJXbczE3uW + JPck85NRftC/8EjPGXxT0S0ZfGfh+SXRYJWsrSHS/ssUjytvfJUnBZhnpgdK0v8Ag2b8IXnw3/b3+NGg + 6un2fVNJ8LwWtxGeArpfFWH5j8q+a8M824IxUpw4PjCNvj5VZ+W50ZxSzKmovGJtPq2ft4xylNppu4tv + +tj/AO+hTftUf/PSP/voV+wHiklAOKj+1R/89I/++hTZr+KIf6xPzzQNH54/8QzfwJ/6Gn4xf+Fne/8A + xdH/ABDN/An/AKGj4xf+Fne//F1+izCm0D5j87B/wbNfAk/8zR8Yv/Czvf8A4uq2tf8ABtF8C7LRruZf + FHxh3RQu4z4zvcZCn/br9H0+7VHxU23wzqB/6dpP/QTQLmZ/Px/wSE/an8FfsvSeNvhz4kv10uxi126/ + s/ULpi28RzSR7ZG6lsAHcevPrX3Nd/t0/COwglkbx1oO2FdzFZCSB9MZr8OvFUkcnxJ8Uef8sR8RahvI + 7L9rkzX0L+0/4N0aP4M2F5o9xocdqLy2g0y0tUt3uLuJ4VLSFl/e7w+QwbjNfzfxp9G7JeIc5qZxVrzh + Ko7yS2v5H1uXcWYjCUFQjFNLqzJ/4KRftH6L+0p+0Zd6x4f3SaRZwpaW8zLtafb1cj3rwQHcP8K+q9L/ + AOCOvxW1X4Sf8JV5miwSm2+1ppbysbhkxuxuA2hsdua+V7u0m0y9mt5kMc0MhR1PVSDgiv3ThvIcPkuW + 0sswl+SmklfeyPm8ZiJV60q0t2dD4D+HTeNdE8RXwvI7VfD9mt4ymPd5wLhduc8HnOTXonhD9jbUPFmt + yWi61awomhQ6uspgLeZJMheK2Az99sEA9ODXF/Bj4jXHw8vNWYaNDr2l6laG21G2kV8eXkEHcvK8gHNe + k6P+2r488LWkd14b09dFimvIHjeC1Z1niiRUit9zA5RdpIwckuea9w5StpH7FT33wFHj288RPp9jHC1z + NE+mM0aIs/ksgm8wBperBNoyAeRXHfHb4L6V8HYtB+w+JJdem1zTrfVVDaabURQTxLJHkmR8thuQOB6m + uw8Q/tN+KvEllrmk/wDCNtDot9Yz20+mRwyGOES3BuVlK9QyOeD6EivNfib8Q7z4m2Wh3U9l9nt9C0q0 + 0WORUYI628QjUkn+IgZNAHL5zQTimocD5s9cfSvqD9nz/gk/8Rv2g/hDF4us7nR9Jt9QiMun2947iS6H + OGOBhVODzyeRxjmgqJ8vv0pta3jvwXqnw48X6joGtWr2eraTO1tdQt1jkU4I9x6HuMVk0FBRRRQAUUV7 + f+yB+wT4y/bGmvptDm0/T9K007bi8uywXceiKAPmP5CgDxCkP+R616T+1H+yv4r/AGSviGug+Jo7YtPF + 59rcW7F4rmPpkHjBB6givN4kaYhVUszcAAZzQB3Hgz4JSeLvhzH4gXUo4Vk16DQ/I8gsVMqhhJuz0APT + HPrXoviL9h1vDunGVvEclzJJq50mNrfTGkhicSiPMr7/AN2SDuAI5HeuU+Cfxc1L4eaXc+H5vCcfiKBr + 2PVYraeOUSW91Fwsg24OAMZB4PFdJ4f/AGq/EXhy31S9j8KtPqmvXizX2psJylxiYSeXsz5YbcqgEDIG + fWgDn/2mf2Wrr9m+PQ5LjUJ76PWklZBPYm0kjMblT8pZsqccHPI7V5TXqnx3+M+q/FSOx0NfDbaHDDPJ + fC0Bmlmmlk+848zLBTjoOK8rcGORlYFWUlWBHII6g0AKv3q/Tz/gll+3d4B8J/s82Hg3xNrFroOoaHLI + iNckqlwruXBB9ixFfBv7K/7Kvir9rnx/JoPhmO2iktovPubq6crDbx525JAyST0Ar0n4qfsG6x+yD8bf + BEXxCk0+68I63fxBr+3YtDIoIMkbA8qQOT7Z98fn/iN4e4Hi/LP7OxsnGzumt0z0ctzSpga3tY6+R+nn + ij9vX4R+GdEuL6bx1oc0VvHvCQSGSR+pG0d84NfEv/BOn9lfwl/wVs/4KNfGbU9a17xl4Y0+HS01Ox/s + LUnsJ3VrsoBKyH5ht28HuM186/tq+HY7S58L3Mn9kwXt1BciSz0+O28qzjSQLGqtABujIyU35bHWvsj/ + AINWofL/AGyvixz/AMybaDp/0+Cvk/DHwVyzgrEVMThKsqk6is3Lol6HXnGfVMxgozVrH1s3/Btj8K3P + PxM+N/4eLbgf1pP+Ia/4U/8ARTPjj/4V9x/jX6NP92mV+2Hgpn50f8Q1/wAKf+imfHH/AMK+4/xqK7/4 + NrPhc6r5XxM+N27PO/xdcH/2av0cooDmCiiigkKo+J/+Ra1D/r2k/wDQTV6qPif/AJFrUP8Ar2k/9BNA + H8jfixN/j/xZ/wBjBqP/AKVy1Y8EjzPG2io7N5K38BClvlT94ucelQ+Kv+SgeK/+xg1H/wBKpaqJcSWs + iyxM0ckbB0YdVIOQaDQ/oesYY18EQL8u1rFTjsf3Yr8A/jGI1+LPiTG1f+JlPwD0/eGv1P8A2Tf2vvEH + xN/ZN0OTV4YZNUuLeWwa9iLJIVT5FfGdu7HfGM14jqn/AATt+HWt6pcXl0/iJp7mRpZX/tAAszHJOAmP + 1oA9K/4IsfD7Qdc/ZV8RTX2mafdSahqUsU7zQq5lQIAFye3OMVBpHhix039jz4WxR2sKmPxxAgPljcq+ + fLx9Old1+y9Lpf7JHw4m8MeHNPN9Y3F012z3s7NKGIwcFccU2GDS/wDhW2geF1sbgaf4d1hdatpDdHzX + mDs+1j0K5Y8AA+9AF+20e0f9pL46Rta2xRfCVk6AxL8p8q4zjj6Zx7Vz+t/DHw6f+CQi7dF01XbwdFfs + wt13m4aNXMmcZ3biTn/E11TeL7NfHXivXl0wi68YabHpd9H9oYxCJFdQVGchsSHqSOnFRXXiKzu/2cf+ + FYtpqjQf7IXRvNE3+k+SqBM5+7uxjnbjrxQB+NAb59pYt7k1+837FkaH9k74exKu3zNDtgFUeqf/AK6+ + FW/4Jt/DFZAqw+I9i4+X7cmD/wCOV9MfDf4vTfs3/AC40XSbU6jF4T0W9uLKS/lLyHybeWVEcpt3KCoH + rjvQB+cn/BTs5/bw+I3yhf8ATouAP+naGvBq3Pif8QdV+LXxD1fxNrlyl3q+t3LXdzKE2gs3YDsAMADs + AKw6ACiiigAr9XP+CGMSj9nDXmKbWbVTz6gLX5R19kf8EgP2nNc+GHxP1bwlHDb3uh6paS35ikJ3RTRq + cMpUgjPQjmgDvP8AgvUgHjnwNtjXd9km5A5xuFfPv/BL/QLPxB+2d4Th1G0hureNpJRHMgZNyrwcH0r7 + M/ak+Bfh39rvxvba34mbV4pLOHyLeC0uljihXqeCpJJ9yaxf2f8A9k/wb+zl8UrDxXosOrXGoacGEcd5 + dq8Lbhg5AAP5GgD3m+8C6PYf8FH9He10+zj+3eD7hpgkK7ZmWcAEjHJA79a8G8MaLat+wNpsn2eHzm8e + Kpbyxux9tfv+le4XHxIt7n402fjltKjXVrHTX0uOMSN5HlO+88ZznPvXH6f4c0Gy+Etv4Lj02b+y7fVx + rSuZz5pnEplGTjG3cTxjp3oA7nwr4F0e7/bu1qa40uymmt/CdmsbSQhtm53LYz0z7V+Yn/BSPw/ZeG/2 + 0fHFvp1rDZ2v24uIolwikgE4Hbkmv040/wCKVvpXxXvPF0ekx/2le6fDprx+a3kiOMkggddx3HPOPavA + fjr+x54H/aC+Kmr+LtXh1i31HWpRLOlteBYgQAOAyk9vWgDm/wDggXGsnjL4kttXctnYc9/vXGf5DNel + f8F5Fz+zb4PcH/mYgBwDkeRNn88UfsofA7w/+x941vNa8Lf2pLJqNv8AZ7q3vLpZIZ1ByCQADkdiD6+p + r5x/4LA/tJa98V/ilo/hm4jhsdD0e0S9itoiSJJ5dytIxJJPyqAM9BnHU0ES3PjldzDLMWb1PYen+fWv + 02/4NYP+Tx/ix/2J1p/6WV+Zdfpp/wAGsP8AyeP8WP8AsTrT/wBLKLD6H7mUUUUEhRRRQAUUUUAFUfE/ + /Itah/17Sf8AoJq9VHxP/wAi3qH/AF7Sf+gmgD+R3xV/yUDxX/2MGo/+lUtUZAWTA6+1XfFZx8QfFf8A + 2MGo/wDpXLTNI0t9b1a1so9vmXkyQrkZGWYAZ/Og0P0T/YPGf2VPDR+X/WXP/oyvXafpf7NFv+yh8OvD + PhOO7e8mjsxdXEjEcyS4dgMdhnAplABRRRQAUUUUAKn3x9ayfiMNvw28Xe/h7Ux+dlNWsn3x9a1vDfgi + 2+Jmqf8ACOXkjR2evQTadcMpAIjlieNsE8D5WPJ4oA/GrO6SnV6F+1b8Bpf2Yf2ifFngGW4+2N4Zvjar + NgfvEKq6E44ztZc44znFee0AFFFFABX0F/wTQU/8NK5x00m75/7Zmvn2vuv/AIJS/stw6p8N/FPxXnup + A+ls2lW1uuFUtIvzse7cUAfSTR4+akp24eUB702gAooooAKKKKAHRf6wV8Ef8FLD/wAZGr/2Crb+b197 + xf6wV80f8FZf2XU8MeBPBPxYtpmK+I3fRruFmVhHJFuZCuORuUMSG74xxQB8NP0r9Mv+DWH/AJPH+LH/ + AGJ1p/6WV+Zr9K/TL/g1h/5PH+LH/YnWn/pZQKWx+5lFFFBAUUUUAFFFFABVHxL/AMi5qH/XtJ/6CavV + U1+PzdBvlwxLW8gAHU/KaAP5GfGH/JRvFf8A2MGo/wDpXLVrwLdR2PjfRppm8uGG+gkkYn7qiRST+VV/ + HtvJpXxY8YWN0jW95b+IdREkMg2uv+lSHkHnoQaosy45baPXNBofuJ+05rtj4n8RaPqGn3lvfWd5pkMs + UsI+UqUXGM15pXk/7D+pXGp/sueGGuJpbho3niQyNuKqH4A9hXrOxvQ/lQAlFKVI7GkoAKKKKAFT74+t + dX8Hyo+Jmjbm2K1wFLYzjIIrlE++PrVD4g6ncaR8OPFF1aSyQ3Vvod/JHIhw0bC1lIYH1GCfwoA+E/8A + gqr4jsfFn/BQj4oX2nXcN9ZzaoipPFnY5SCJGx9GUj8K+fadLcSXkjSyyPLJISzux3Mx7kn1ptABRRRQ + AV+oH/BJbxBpt3+wL4101b+3GpW+siVrQ/6woVwG+lfl/X0b/wAEyNWubb9oOa1hnlS3uNKuTLErYWUh + cjcOhwemaAPu1Sd34mnUxW3Pn3NPoAKKKKACiiigB0X+sFee/wDBYjxJp9t+wb8LdFa+gbVLjxBPfLaj + PmCFYpELn23MBXoUX+sFfBv/AAU31qe9/aIgtpbmR4bTSbcRRFvljB3E4HbJzQB86v0r9Mv+DWH/AJPH + +LH/AGJ1n/6WV+ZruMdRX6df8Grul3E/7WXxc1CO3maxh8J2NrJcBD5aTG7ZxGW6bioJx1wM0ClsfuJR + RRQQFFFFABRTtlGygBtDDcvpTtlGygD5p+Pf/BIf9nn9pXx7L4m8V/DnS7jXLpi1zdWsstm12fWTymUM + fc81xb/8EDf2VVUn/hWka47/ANqXf/xyvsrZR5eaCuY/NfUf2PPC/hGw8UR/DfRm0HwJ4JRvJj8ySYXM + 5YbtpclsZ757V5WunXnmYNvcdf8Anma/Xf8As6ERNH5MflNnKbRtOeuRUJ8O2O7/AI8rP/vyv+FAcx+S + Mul3Xln/AEef/v2ah/sy5/595/8Av2a/XU+HrDH/AB42n/flf8Kb/wAI5Y/8+Nn/AN+V/wAKA5j8jP7M + uf8An3n/AO/Zo/sy5/595/8Av2a/XP8A4Ryx/wCfGz/78r/hR/wjlj/z42f/AH5X/CgOY/I1NLut4/0e + fr/zzNd94f8AgEfEfwgn8Vapp8mreHV1GXR9b0xQyyy2bwIHZSORuEzrx0wp9a/TQeHLEH/jys/+/K/4 + VJHpFvDBJDHDCkM33kCAKeMHj8KA5j4w8P8A/BCL9k3xNoVnqFr8NY5La9hWeJzql4CysMgn951wat/8 + OBP2U/8AomUf/g1u/wD45X2VHbrCiqiqqqAAoGAAKdsoDmPjP/hwJ+yn/wBEyj/8Gt3/APHKP+HAn7Kf + /RMo/wDwa3f/AMcr7M2UbKA5j4z/AOHAn7Kf/RMo/wDwa3f/AMcrh/i1/wAEvfgh+zVqul2/wv8AADaf + 461xvs1tcpe3Ey2sJ/1hYM5Xkcc1+gmyom0+J5/MaOMyYwH2/MB7HrQHMflF8T/hvdfDvx/qWisJrltP + kETSiM4c7QTjj1JFYP8AZ1x/z7z/APfs1+u0vh6xmkMj2dq0jdWaIEn8cU3/AIRyx/58bP8A78r/AIUB + zH5F/wBnXH/PvP8A9+zR/Z1x/wA+8/8A37Nfrp/wjlj/AM+Nn/35X/Cj/hHLH/nxs/8Avyv+FA+Y/Iv+ + zrj/AJ95/wDv2aP7OuP+fef/AL9mv10/4Ryx/wCfGz/78r/hR/wjlj/z42f/AH5X/CgOY/K/4TfC28+K + Xjyz0KEtaz329YpJIzsDBSQD9cY/GvVvgv8A8EvvgZ+1OdTk+Jnw9+3ePPDkg0+/kkvbiHzIwW8sgI4H + r29PWvvyHQ7S2lDx2ttG69GWMKR+OKki0+OGeSRY41klwXYDBfHqe9AuY+OW/wCCBH7KjD/kl8P/AINL + z/47X0N+zZ+yn8Pf2RfA7eHfh34V0zwvpUjiWVLVDvuHxjfI7ZZ292J6mvRtlGygLobRTtlGygkbRTtl + GygD/9k= + + + \ No newline at end of file diff --git a/AgroBase/AgroBase/Forms/Direcional/frmDirConfig.cs b/AgroBase/AgroBase/Forms/Direcional/frmDirConfig.cs index b7ebff45f..e48f69763 100644 --- a/AgroBase/AgroBase/Forms/Direcional/frmDirConfig.cs +++ b/AgroBase/AgroBase/Forms/Direcional/frmDirConfig.cs @@ -1,4 +1,5 @@ using AgroBase.Comum; +using AgroBase.Models; using AgroBase.Models.Modules; using System; using System.Collections.Generic; @@ -15,7 +16,7 @@ namespace AgroBase.Forms.Direcional { public partial class frmDirConfig : Form { - DispositivosService Disp = frmPrincipal.Dispositivos.FirstOrDefault(x => x.Dispositivo == T_Code.Dir); + DispositivosService Disp = (DispositivosService)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Dir); public frmDirConfig() { diff --git a/AgroBase/AgroBase/Forms/Direcional/frmDirPlot.cs b/AgroBase/AgroBase/Forms/Direcional/frmDirPlot.cs index b10bae0ee..fc5e37582 100644 --- a/AgroBase/AgroBase/Forms/Direcional/frmDirPlot.cs +++ b/AgroBase/AgroBase/Forms/Direcional/frmDirPlot.cs @@ -1,4 +1,5 @@ -using AgroBase.Models.Modules; +using AgroBase.Models; +using AgroBase.Models.Modules; using System; using System.Collections.Generic; using System.ComponentModel; @@ -35,7 +36,7 @@ namespace AgroBase.Forms.Direcional private void DesenharGraficos(object sender, PaintEventArgs e) { PictureBox pic = (PictureBox)sender; - var Motor = ((DirecionalModel)frmPrincipal.Dispositivos.FirstOrDefault(d => d.Dispositivo == T_Code.Dir).Dados).Motores.FirstOrDefault(m => m.ID == pic.Name.Replace("pic", "")); + var Motor = ((DirecionalModel)Variaveis.DispositivosConectados.FirstOrDefault(d => d.Dispositivo == T_Code.Dir).Dados).Motores.FirstOrDefault(m => m.ID == pic.Name.Replace("pic", "")); Label lbl = Controls.OfType private void InitializeComponent() { - System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea5 = new System.Windows.Forms.DataVisualization.Charting.ChartArea(); - System.Windows.Forms.DataVisualization.Charting.Legend legend5 = new System.Windows.Forms.DataVisualization.Charting.Legend(); - System.Windows.Forms.DataVisualization.Charting.Series series5 = new System.Windows.Forms.DataVisualization.Charting.Series(); - System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea6 = new System.Windows.Forms.DataVisualization.Charting.ChartArea(); - System.Windows.Forms.DataVisualization.Charting.Legend legend6 = new System.Windows.Forms.DataVisualization.Charting.Legend(); - System.Windows.Forms.DataVisualization.Charting.Series series6 = new System.Windows.Forms.DataVisualization.Charting.Series(); - System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea7 = new System.Windows.Forms.DataVisualization.Charting.ChartArea(); - System.Windows.Forms.DataVisualization.Charting.Legend legend7 = new System.Windows.Forms.DataVisualization.Charting.Legend(); - System.Windows.Forms.DataVisualization.Charting.Series series7 = new System.Windows.Forms.DataVisualization.Charting.Series(); - System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea8 = new System.Windows.Forms.DataVisualization.Charting.ChartArea(); - System.Windows.Forms.DataVisualization.Charting.Legend legend8 = new System.Windows.Forms.DataVisualization.Charting.Legend(); - System.Windows.Forms.DataVisualization.Charting.Series series8 = new System.Windows.Forms.DataVisualization.Charting.Series(); + System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea1 = new System.Windows.Forms.DataVisualization.Charting.ChartArea(); + System.Windows.Forms.DataVisualization.Charting.Legend legend1 = new System.Windows.Forms.DataVisualization.Charting.Legend(); + System.Windows.Forms.DataVisualization.Charting.Series series1 = new System.Windows.Forms.DataVisualization.Charting.Series(); + System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea2 = new System.Windows.Forms.DataVisualization.Charting.ChartArea(); + System.Windows.Forms.DataVisualization.Charting.Legend legend2 = new System.Windows.Forms.DataVisualization.Charting.Legend(); + System.Windows.Forms.DataVisualization.Charting.Series series2 = new System.Windows.Forms.DataVisualization.Charting.Series(); + System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea3 = new System.Windows.Forms.DataVisualization.Charting.ChartArea(); + System.Windows.Forms.DataVisualization.Charting.Legend legend3 = new System.Windows.Forms.DataVisualization.Charting.Legend(); + System.Windows.Forms.DataVisualization.Charting.Series series3 = new System.Windows.Forms.DataVisualization.Charting.Series(); + System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea4 = new System.Windows.Forms.DataVisualization.Charting.ChartArea(); + System.Windows.Forms.DataVisualization.Charting.Legend legend4 = new System.Windows.Forms.DataVisualization.Charting.Legend(); + System.Windows.Forms.DataVisualization.Charting.Series series4 = new System.Windows.Forms.DataVisualization.Charting.Series(); System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(frmAcompanhamento)); this.pnlFundo = new System.Windows.Forms.Panel(); + this.lblDistanciaParcial = new System.Windows.Forms.Label(); + this.lblDistanciaTotal = new System.Windows.Forms.Label(); + this.lblTempoEmMovimento = new System.Windows.Forms.Label(); + this.lblTempoConectado = new System.Windows.Forms.Label(); this.chbDTLivre = new System.Windows.Forms.CheckBox(); this.chbDTControlar = new System.Windows.Forms.CheckBox(); this.chbETLivre = new System.Windows.Forms.CheckBox(); @@ -120,10 +124,6 @@ namespace AgroBase.Forms this.btnEFReferenciar = new System.Windows.Forms.Button(); this.lblM1 = new System.Windows.Forms.Label(); this.picEF = new System.Windows.Forms.PictureBox(); - this.lblTempoConectado = new System.Windows.Forms.Label(); - this.lblTempoEmMovimento = new System.Windows.Forms.Label(); - this.lblDistanciaTotal = new System.Windows.Forms.Label(); - this.lblDistanciaParcial = new System.Windows.Forms.Label(); this.pnlFundo.SuspendLayout(); ((System.ComponentModel.ISupportInitialize)(this.chartET)).BeginInit(); ((System.ComponentModel.ISupportInitialize)(this.chartDT)).BeginInit(); @@ -227,6 +227,42 @@ namespace AgroBase.Forms this.pnlFundo.Size = new System.Drawing.Size(1924, 994); this.pnlFundo.TabIndex = 0; // + // lblDistanciaParcial + // + this.lblDistanciaParcial.AutoSize = true; + this.lblDistanciaParcial.Location = new System.Drawing.Point(852, 233); + this.lblDistanciaParcial.Name = "lblDistanciaParcial"; + this.lblDistanciaParcial.Size = new System.Drawing.Size(212, 17); + this.lblDistanciaParcial.TabIndex = 170; + this.lblDistanciaParcial.Text = "Distância percorrida parcial: 0 m"; + // + // lblDistanciaTotal + // + this.lblDistanciaTotal.AutoSize = true; + this.lblDistanciaTotal.Location = new System.Drawing.Point(852, 216); + this.lblDistanciaTotal.Name = "lblDistanciaTotal"; + this.lblDistanciaTotal.Size = new System.Drawing.Size(197, 17); + this.lblDistanciaTotal.TabIndex = 169; + this.lblDistanciaTotal.Text = "Distância percorrida total: 0 m"; + // + // lblTempoEmMovimento + // + this.lblTempoEmMovimento.AutoSize = true; + this.lblTempoEmMovimento.Location = new System.Drawing.Point(852, 199); + this.lblTempoEmMovimento.Name = "lblTempoEmMovimento"; + this.lblTempoEmMovimento.Size = new System.Drawing.Size(235, 17); + this.lblTempoEmMovimento.TabIndex = 168; + this.lblTempoEmMovimento.Text = "Tempo em movimento: 00:00:00 hrs"; + // + // lblTempoConectado + // + this.lblTempoConectado.AutoSize = true; + this.lblTempoConectado.Location = new System.Drawing.Point(852, 182); + this.lblTempoConectado.Name = "lblTempoConectado"; + this.lblTempoConectado.Size = new System.Drawing.Size(210, 17); + this.lblTempoConectado.TabIndex = 167; + this.lblTempoConectado.Text = "Tempo conectado: 00:00:00 hrs"; + // // chbDTLivre // this.chbDTLivre.AutoSize = true; @@ -309,64 +345,64 @@ namespace AgroBase.Forms // // chartET // - chartArea5.Name = "ChartArea1"; - this.chartET.ChartAreas.Add(chartArea5); - legend5.Name = "Legend1"; - this.chartET.Legends.Add(legend5); + chartArea1.Name = "ChartArea1"; + this.chartET.ChartAreas.Add(chartArea1); + legend1.Name = "Legend1"; + this.chartET.Legends.Add(legend1); this.chartET.Location = new System.Drawing.Point(268, 504); this.chartET.Name = "chartET"; - series5.ChartArea = "ChartArea1"; - series5.Legend = "Legend1"; - series5.Name = "Series1"; - this.chartET.Series.Add(series5); + series1.ChartArea = "ChartArea1"; + series1.Legend = "Legend1"; + series1.Name = "Series1"; + this.chartET.Series.Add(series1); this.chartET.Size = new System.Drawing.Size(578, 480); this.chartET.TabIndex = 94; this.chartET.Text = "chart1"; // // chartDT // - chartArea6.Name = "ChartArea1"; - this.chartDT.ChartAreas.Add(chartArea6); - legend6.Name = "Legend1"; - this.chartDT.Legends.Add(legend6); + chartArea2.Name = "ChartArea1"; + this.chartDT.ChartAreas.Add(chartArea2); + legend2.Name = "Legend1"; + this.chartDT.Legends.Add(legend2); this.chartDT.Location = new System.Drawing.Point(1112, 504); this.chartDT.Name = "chartDT"; - series6.ChartArea = "ChartArea1"; - series6.Legend = "Legend1"; - series6.Name = "Series1"; - this.chartDT.Series.Add(series6); + series2.ChartArea = "ChartArea1"; + series2.Legend = "Legend1"; + series2.Name = "Series1"; + this.chartDT.Series.Add(series2); this.chartDT.Size = new System.Drawing.Size(577, 480); this.chartDT.TabIndex = 110; this.chartDT.Text = "chart1"; // // chartDF // - chartArea7.Name = "ChartArea1"; - this.chartDF.ChartAreas.Add(chartArea7); - legend7.Name = "Legend1"; - this.chartDF.Legends.Add(legend7); + chartArea3.Name = "ChartArea1"; + this.chartDF.ChartAreas.Add(chartArea3); + legend3.Name = "Legend1"; + this.chartDF.Legends.Add(legend3); this.chartDF.Location = new System.Drawing.Point(1112, 5); this.chartDF.Name = "chartDF"; - series7.ChartArea = "ChartArea1"; - series7.Legend = "Legend1"; - series7.Name = "Series1"; - this.chartDF.Series.Add(series7); + series3.ChartArea = "ChartArea1"; + series3.Legend = "Legend1"; + series3.Name = "Series1"; + this.chartDF.Series.Add(series3); this.chartDF.Size = new System.Drawing.Size(577, 480); this.chartDF.TabIndex = 109; this.chartDF.Text = "chart1"; // // chartEF // - chartArea8.Name = "ChartArea1"; - this.chartEF.ChartAreas.Add(chartArea8); - legend8.Name = "Legend1"; - this.chartEF.Legends.Add(legend8); + chartArea4.Name = "ChartArea1"; + this.chartEF.ChartAreas.Add(chartArea4); + legend4.Name = "Legend1"; + this.chartEF.Legends.Add(legend4); this.chartEF.Location = new System.Drawing.Point(268, 5); this.chartEF.Name = "chartEF"; - series8.ChartArea = "ChartArea1"; - series8.Legend = "Legend1"; - series8.Name = "Series1"; - this.chartEF.Series.Add(series8); + series4.ChartArea = "ChartArea1"; + series4.Legend = "Legend1"; + series4.Name = "Series1"; + this.chartEF.Series.Add(series4); this.chartEF.Size = new System.Drawing.Size(578, 480); this.chartEF.TabIndex = 93; this.chartEF.Text = "chart1"; @@ -957,42 +993,6 @@ namespace AgroBase.Forms this.picEF.TabIndex = 90; this.picEF.TabStop = false; // - // lblTempoConectado - // - this.lblTempoConectado.AutoSize = true; - this.lblTempoConectado.Location = new System.Drawing.Point(852, 182); - this.lblTempoConectado.Name = "lblTempoConectado"; - this.lblTempoConectado.Size = new System.Drawing.Size(210, 17); - this.lblTempoConectado.TabIndex = 167; - this.lblTempoConectado.Text = "Tempo conectado: 00:00:00 hrs"; - // - // lblTempoEmMovimento - // - this.lblTempoEmMovimento.AutoSize = true; - this.lblTempoEmMovimento.Location = new System.Drawing.Point(852, 199); - this.lblTempoEmMovimento.Name = "lblTempoEmMovimento"; - this.lblTempoEmMovimento.Size = new System.Drawing.Size(235, 17); - this.lblTempoEmMovimento.TabIndex = 168; - this.lblTempoEmMovimento.Text = "Tempo em movimento: 00:00:00 hrs"; - // - // lblDistanciaTotal - // - this.lblDistanciaTotal.AutoSize = true; - this.lblDistanciaTotal.Location = new System.Drawing.Point(852, 216); - this.lblDistanciaTotal.Name = "lblDistanciaTotal"; - this.lblDistanciaTotal.Size = new System.Drawing.Size(197, 17); - this.lblDistanciaTotal.TabIndex = 169; - this.lblDistanciaTotal.Text = "Distância percorrida total: 0 m"; - // - // lblDistanciaParcial - // - this.lblDistanciaParcial.AutoSize = true; - this.lblDistanciaParcial.Location = new System.Drawing.Point(852, 233); - this.lblDistanciaParcial.Name = "lblDistanciaParcial"; - this.lblDistanciaParcial.Size = new System.Drawing.Size(212, 17); - this.lblDistanciaParcial.TabIndex = 170; - this.lblDistanciaParcial.Text = "Distância percorrida parcial: 0 m"; - // // frmAcompanhamento // this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 16F); @@ -1001,7 +1001,7 @@ namespace AgroBase.Forms this.Controls.Add(this.pnlFundo); this.Name = "frmAcompanhamento"; this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; - this.Text = "frmAcompanhamento"; + this.Text = "Acompanhamento"; this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.frmAcompanhamento_FormClosing); this.Load += new System.EventHandler(this.frmAcompanhamento_Load); this.Shown += new System.EventHandler(this.frmAcompanhamento_Shown); diff --git a/AgroBase/AgroBase/Forms/frmAcompanhamento.cs b/AgroBase/AgroBase/Forms/frmAcompanhamento.cs index 123f30581..4cb6d7b94 100644 --- a/AgroBase/AgroBase/Forms/frmAcompanhamento.cs +++ b/AgroBase/AgroBase/Forms/frmAcompanhamento.cs @@ -1,4 +1,5 @@ -using AgroBase.Models; +using AgroBase.Comum; +using AgroBase.Models; using AgroBase.Models.Modules; using System; using System.Collections.Generic; @@ -59,7 +60,7 @@ namespace AgroBase.Forms private void PreencherOpcoes() { - var DispCon = frmPrincipal.Dispositivos.Where(x => x.Dispositivo == T_Code.Dir).ToList(); + var DispCon = Variaveis.DispositivosConectados.Where(x => x.Dispositivo == T_Code.Dir).ToList(); foreach (var Dispositivo in DispCon) { foreach (var Motor in ((DirecionalModel)Dispositivo.Dados).Motores) @@ -93,7 +94,7 @@ namespace AgroBase.Forms private void AtualzarDadosMovimentacao() { - var DispMov = frmPrincipal.Dispositivos.FirstOrDefault(x => x._Porta.IsOpen && x.Dispositivo == T_Code.Mov); + var DispMov = (DispositivosService)Variaveis.DispositivosConectados.FirstOrDefault(x => x._Porta.IsOpen && x.Dispositivo == T_Code.Mov); if (DispMov == null) { return; @@ -106,11 +107,11 @@ namespace AgroBase.Forms else { lblTempoConectado.Text = "Tempo conectado: " + TimeSpan.FromSeconds(DispMov.TempoConectado).ToString(@"hh\:mm\:ss") + " hrs"; - lblTempoEmMovimento.Text = "Tempo em movimento: " + TimeSpan.FromSeconds(((MovimentacaoModel)DispMov.Dados).TempoEmAtividade).ToString(@"hh\:mm\:ss") + " hrs"; - lblDistanciaTotal.Text = "Distancia percorrida total: " + ((MovimentacaoModel)DispMov.Dados).DistanciaPercorridaTotal.ToString("0.00") + " m"; - lblDistanciaParcial.Text = "Distancia percorrida parcial: " + ((MovimentacaoModel)DispMov.Dados).DistanciaPercorridaParcial.ToString("0.00") + " m"; + lblTempoEmMovimento.Text = "Tempo em movimento: " + TimeSpan.FromSeconds(DispMov.Dados.TempoEmAtividade).ToString(@"hh\:mm\:ss") + " hrs"; + lblDistanciaTotal.Text = "Distancia percorrida total: " + DispMov.Dados.DistanciaPercorridaTotal.ToString("0.00") + " m"; + lblDistanciaParcial.Text = "Distancia percorrida parcial: " + DispMov.Dados.DistanciaPercorridaParcial.ToString("0.00") + " m"; - foreach (var Motor in ((MovimentacaoModel)DispMov.Dados).Motores.Where(x => x.Comandar)) + foreach (var Motor in DispMov.Dados.Motores.Where(x => x.Comandar)) { Label lblM_RPMSP = pnlFundo.Controls.OfType