From 20f76ca5151712c5269274fc6f9851b61f82c254 Mon Sep 17 00:00:00 2001 From: Michal Buzik Date: Thu, 18 Sep 2025 15:24:42 +0200 Subject: [PATCH] iPerl Reader - NOT FINISHED Add initial implementation for `iPerlReaderUNI` with `Factory`, `ProcParams`, and `IPerlReader` classes. --- .../RegisterReaders/iPerlReaderUNI/Factory.cs | 23 + .../iPerlReaderUNI/IPerlCfg.cs | 70 + .../iPerlReaderUNI/IPerlCfgCtrl.cs | 163 + .../iPerlReaderUNI/IPerlCfgCtrl.designer.cs | 441 ++ .../iPerlReaderUNI/IPerlCfgCtrl.resx | 120 + .../iPerlReaderUNI/IPerlReader.cs | 1492 +++++++ .../IperlHeadTestCtrl.Designer.cs | 137 + .../iPerlReaderUNI/IperlHeadTestCtrl.cs | 192 + .../iPerlReaderUNI/IperlHeadTestCtrl.resx | 120 + .../iPerlReaderUNI/ProcParams.cs | 184 + .../comminication/CalibrationStruct.cs | 242 ++ .../comminication/CalibrationStructV4.cs | 258 ++ .../comminication/ConfigStruct.cs | 266 ++ .../iPerlReaderUNI/comminication/Enums.cs | 113 + .../comminication/OptoReceivedEventArgs.cs | 20 + .../iPerlReaderUNI/test/OpticalHeadTest.cs | 131 + .../test/iPerlCommunicationForm.cs | 2883 +++++++++++++ .../test/iPerlCommunicationForm.designer.cs | 2902 +++++++++++++ .../test/iPerlCommunicationForm.resx | 3577 +++++++++++++++++ TBF/TBF.csproj | 38 +- .../TBFTests.csproj.AssemblyReference.cache | Bin 20629 -> 21110 bytes 21 files changed, 13371 insertions(+), 1 deletion(-) create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/Factory.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfg.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.designer.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.resx create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlReader.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.Designer.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.resx create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/ProcParams.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/CalibrationStruct.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/CalibrationStructV4.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/ConfigStruct.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/Enums.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/OptoReceivedEventArgs.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/test/OpticalHeadTest.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.designer.cs create mode 100644 TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.resx diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/Factory.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/Factory.cs new file mode 100644 index 000000000..f99396c85 --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/Factory.cs @@ -0,0 +1,23 @@ +using TBF.Rig.Generic; +using System.Collections.Generic; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI +{ + public class Factory: IComponentFactory + { + public string ClassName { get { return this.GetType().Namespace.Substring(8); } } + + public override string ToString() { return ClassName; } + + public IComponent DummyComponent() { return new IPerlReader(); } + + public IComponent GetComponent(IComponentCfg cfg, IList components) { return new IPerlReader(cfg); } + + public IComponentCfg DefaultConfig() { return new IPerlCfg(this); } + + public IComponentCfg CmpntCfgFromCmpntEntity(Config.Entities.Component component) + { + return ComponentCfgBase.CreateFromDbEntity(IPerlCfg.Serializer, component, this); + } + } +} \ No newline at end of file diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfg.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfg.cs new file mode 100644 index 000000000..fca3524e4 --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfg.cs @@ -0,0 +1,70 @@ +using System.Collections.Generic; +using System.Xml.Serialization; +using Common; +using Config.Entities; +using TBF.Rig.Generic; +using TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication; + + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI +{ + public class IPerlCfg : ComponentCfgBase, Generic.IComponentCfg + { + public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(IPerlCfg) })[0]; + public override XmlSerializer GetSerializer() { return Serializer; } + public IComponentCfgCtrl GetControl(IList cmpntEntities) + { + return new IPerlCfgCtrl(); + } + + + + /// + /// Serialized parameters + /// + public bool UseTcpIP; + public string OptoIPAddress; + public ushort OptoTcpipPortNr; + public int HeadCommunicationComPortNr; + public int OptoComPortNr; + public int RfidComPortNr; /// 0 = use MuxBoardNr + public int MuxBoardNr; /// 0 = use RfidComPort(Nr), otherwise mux. board nr. 1 .. 4 + public int Group; /// Number written to QuidoRS to connct the watermeter to RfidComPort, 1 .. 10 + public CommunicationInterface CommunicationInterface; /// Communication Interface: RFID or NFC + + /// Procedure parameters + [XmlIgnore] + public ProcParams ProcParams; + public override IParamsProvider GetRuntimeProcParamsProvider() { return ProcParams; } + public override IParamsProvider CreateProcParamsProvider() { return new ProcParams(true); } + + [XmlIgnore] + public MeterType MeterType { get { return (ProcParams != null) ? ProcParams.MeterType : MeterType.AutoDetect; } } + + + + /// Private parameterless constructor invoked by all other (public) constructors + IPerlCfg() + { + Name = "iPerl"; + ParentName = string.Empty; + OptoComPortNr = 10; + RfidComPortNr = 0; /// = use mux. board + MuxBoardNr = 1; + ProcParams = CreateProcParamsProvider() as ProcParams; + CommunicationInterface = CommunicationInterface.RFID; + HeadCommunicationComPortNr = 0; + } + + public IPerlCfg(IComponentFactory factory) + : this() + { + this.Factory = factory; + } + + public string ToString(int i) + { + return $"{Name} Group1 (mux#)={MuxBoardNr}, Group2={Group}, Opto=Com{OptoComPortNr}, {CommunicationInterface}=Com{RfidComPortNr}"; + } + } +} \ No newline at end of file diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.cs new file mode 100644 index 000000000..cedf5f590 --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.cs @@ -0,0 +1,163 @@ +/// +/// Copyright (c) 2015-2017 Sensus Metering Systems +/// +using System; +using System.Net; +using System.Windows.Forms; +using Common; +using TBF.Rig.Generic; +using TBF.Resources; +using TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI +{ + public partial class IPerlCfgCtrl : UserControl, IComponentCfgCtrl + { + public bool ShowMore { get { return false; } } + + IPerlCfg config; + public IComponentCfg Config + { + get { return config as IComponentCfg; } + set + { + config = value as IPerlCfg; + Redraw(); + } + } + + public IPerlCfgCtrl() + { + InitializeComponent(); + } + + private void WaterMeterCfgCtrl_Load(object sender, EventArgs e) + { + nameLabel.Text = Strings.Name; + classNameLabel.Text = config.Factory.ClassName; + Redraw(); + } + + public void Closing() + { + } + + void Redraw() + { + if (config == null) return; /// Control was not loaded, settings were not changed + nameTextBox.Text = config.Name; + radioButton1.Checked = config.UseTcpIP; + radioButton2.Checked = !config.UseTcpIP; + ipAddressTextBox.Text = (config.OptoIPAddress != null) ? config.OptoIPAddress : "0.0.0.0"; + tcpipPortTextBox.Text = config.OptoTcpipPortNr.ToString(); + headPortNrTextBox.Text = config.HeadCommunicationComPortNr.ToString(); + optoSerialPortTextBox.Text = config.OptoComPortNr.ToString(); + rfidPortNrTextBox.Text = config.RfidComPortNr.ToString(); + muxBoardNrTextBox.Text = config.MuxBoardNr.ToString(); + groupTextBox.Text = config.Group.ToString(); + comboBoxCommunicationInterface.SelectedItem = config.CommunicationInterface.ToString(); + tabPage2.Controls.Add(new IperlHeadTestCtrl(config)); + } + + public void Unlock() + { + nameTextBox.Enabled = true; + radioButton1.Enabled = true; + radioButton2.Enabled = true; + ipAddressTextBox.Enabled = true; + tcpipPortTextBox.Enabled = true; + optoSerialPortTextBox.Enabled = true; + rfidPortNrTextBox.Enabled = true; + headPortNrTextBox.Enabled = true; + muxBoardNrTextBox.Enabled = true; + groupTextBox.Enabled = true; + comboBoxCommunicationInterface.Enabled = true; + } + + public CfgUpdateFlags VerifyCfg(ref string message) + { + CfgUpdateFlags flags = CfgUpdateFlags.None; + + int dummy; + if (radioButton1.Checked) + { + IPAddress dummyIPAddress; + if (!IPAddress.TryParse(ipAddressTextBox.Text, out dummyIPAddress)) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'IP address' is not valid"; + } + + ushort sdummy; + if (!ushort.TryParse(tcpipPortTextBox.Text, out sdummy)) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'TCP/IP port nr.' is not valid"; + } + } + else + { + if (!int.TryParse(optoSerialPortTextBox.Text, out dummy) || dummy < 1 || dummy > 999) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'Opto serial port nr.' is not valid"; + } + } + + if (!int.TryParse(rfidPortNrTextBox.Text, out dummy) || dummy < 0 || dummy > 999) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'RFID serial port nr.' is not valid"; + } + + if (!int.TryParse(headPortNrTextBox.Text, out dummy) || dummy < 0 || dummy > 999) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + "'Head communication serial port nr.' is not valid"; + } + + if (!int.TryParse(muxBoardNrTextBox.Text, out dummy) || dummy < 1 || dummy > 4) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + string.Format(Strings.Invalid_0, muxBoardNrLabel.Text); + } + + if (!int.TryParse(groupTextBox.Text, out dummy) || dummy < 1 || dummy > 10) + { + flags |= CfgUpdateFlags.Error; + message += Environment.NewLine + string.Format(Strings.Invalid_0, groupLabel.Text); + } + + return flags; + } + + public CfgUpdateFlags UpdateCfg() + { + CfgUpdateFlags flags = CfgUpdateFlags.RestartRqrd; + + if (config == null) return CfgUpdateFlags.Error; /// Control was not loaded, settings were not changed + + config.Name = nameTextBox.Text; + + if (radioButton1.Checked) + { + config.UseTcpIP = true; + config.OptoIPAddress = ipAddressTextBox.Text; + config.OptoTcpipPortNr = ushort.Parse(tcpipPortTextBox.Text); + } + else + { + config.UseTcpIP = false; + config.OptoComPortNr = int.Parse(optoSerialPortTextBox.Text); + } + + config.RfidComPortNr = int.Parse(rfidPortNrTextBox.Text); + config.MuxBoardNr = int.Parse(muxBoardNrTextBox.Text); + config.Group = int.Parse(groupTextBox.Text); + config.CommunicationInterface = (CommunicationInterface)comboBoxCommunicationInterface.SelectedIndex; + config.HeadCommunicationComPortNr = int.Parse(headPortNrTextBox.Text); + + return flags; + } + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.designer.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.designer.cs new file mode 100644 index 000000000..d7d59d88b --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.designer.cs @@ -0,0 +1,441 @@ +/// +/// Copyright (c) 2015-2017 Sensus Metering Systems +/// +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI +{ + partial class IPerlCfgCtrl + { + /// + /// 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 Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.tabControl1 = new System.Windows.Forms.TabControl(); + this.tabPage1 = new System.Windows.Forms.TabPage(); + this.label4 = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.comboBoxCommunicationInterface = new System.Windows.Forms.ComboBox(); + this.label1 = new System.Windows.Forms.Label(); + this.rfidPortNrTextBox = new System.Windows.Forms.TextBox(); + this.rfidSerialPortNrLabel = new System.Windows.Forms.Label(); + this.optoDataGroupBox = new System.Windows.Forms.GroupBox(); + this.tcpipPortLabel = new System.Windows.Forms.Label(); + this.tcpipPortTextBox = new System.Windows.Forms.TextBox(); + this.ipAddressLabel = new System.Windows.Forms.Label(); + this.ipAddressTextBox = new System.Windows.Forms.TextBox(); + this.radioButton1 = new System.Windows.Forms.RadioButton(); + this.radioButton2 = new System.Windows.Forms.RadioButton(); + this.optoSerialPortLabel = new System.Windows.Forms.Label(); + this.optoSerialPortTextBox = new System.Windows.Forms.TextBox(); + this.groupTextBox = new System.Windows.Forms.TextBox(); + this.groupLabel = new System.Windows.Forms.Label(); + this.muxBoardNrTextBox = new System.Windows.Forms.TextBox(); + this.muxBoardNrLabel = new System.Windows.Forms.Label(); + this.nameTextBox = new System.Windows.Forms.TextBox(); + this.nameLabel = new System.Windows.Forms.Label(); + this.classNameLabel = new System.Windows.Forms.Label(); + this.tabPage2 = new System.Windows.Forms.TabPage(); + this.groupBox2 = new System.Windows.Forms.GroupBox(); + this.label2 = new System.Windows.Forms.Label(); + this.headPortNrTextBox = new System.Windows.Forms.TextBox(); + this.tabControl1.SuspendLayout(); + this.tabPage1.SuspendLayout(); + this.groupBox1.SuspendLayout(); + this.optoDataGroupBox.SuspendLayout(); + this.groupBox2.SuspendLayout(); + this.SuspendLayout(); + // + // tabControl1 + // + this.tabControl1.Controls.Add(this.tabPage1); + this.tabControl1.Controls.Add(this.tabPage2); + this.tabControl1.Location = new System.Drawing.Point(3, 3); + this.tabControl1.Name = "tabControl1"; + this.tabControl1.SelectedIndex = 0; + this.tabControl1.Size = new System.Drawing.Size(611, 432); + this.tabControl1.TabIndex = 0; + // + // tabPage1 + // + this.tabPage1.Controls.Add(this.groupBox2); + this.tabPage1.Controls.Add(this.label4); + this.tabPage1.Controls.Add(this.label3); + this.tabPage1.Controls.Add(this.groupBox1); + this.tabPage1.Controls.Add(this.optoDataGroupBox); + this.tabPage1.Controls.Add(this.groupTextBox); + this.tabPage1.Controls.Add(this.groupLabel); + this.tabPage1.Controls.Add(this.muxBoardNrTextBox); + this.tabPage1.Controls.Add(this.muxBoardNrLabel); + this.tabPage1.Controls.Add(this.nameTextBox); + this.tabPage1.Controls.Add(this.nameLabel); + this.tabPage1.Controls.Add(this.classNameLabel); + this.tabPage1.Location = new System.Drawing.Point(4, 25); + this.tabPage1.Name = "tabPage1"; + this.tabPage1.Padding = new System.Windows.Forms.Padding(3); + this.tabPage1.Size = new System.Drawing.Size(603, 403); + this.tabPage1.TabIndex = 0; + this.tabPage1.Text = "Config"; + this.tabPage1.UseVisualStyleBackColor = true; + // + // label4 + // + this.label4.AutoSize = true; + this.label4.Location = new System.Drawing.Point(208, 101); + this.label4.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(40, 16); + this.label4.TabIndex = 25; + this.label4.Text = "1 .. 10"; + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(208, 72); + this.label3.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(33, 16); + this.label3.TabIndex = 24; + this.label3.Text = "1 .. 4"; + // + // groupBox1 + // + this.groupBox1.Controls.Add(this.comboBoxCommunicationInterface); + this.groupBox1.Controls.Add(this.label1); + this.groupBox1.Controls.Add(this.rfidPortNrTextBox); + this.groupBox1.Controls.Add(this.rfidSerialPortNrLabel); + this.groupBox1.Location = new System.Drawing.Point(10, 259); + this.groupBox1.Margin = new System.Windows.Forms.Padding(4); + this.groupBox1.Name = "groupBox1"; + this.groupBox1.Padding = new System.Windows.Forms.Padding(4); + this.groupBox1.Size = new System.Drawing.Size(552, 68); + this.groupBox1.TabIndex = 23; + this.groupBox1.TabStop = false; + this.groupBox1.Text = "RFID / NFC communication (in case mux. board is not used)"; + // + // comboBoxCommunicationInterface + // + this.comboBoxCommunicationInterface.Enabled = false; + this.comboBoxCommunicationInterface.FormattingEnabled = true; + this.comboBoxCommunicationInterface.Items.AddRange(new object[] { + "RFID", + "NFC"}); + this.comboBoxCommunicationInterface.Location = new System.Drawing.Point(201, 27); + this.comboBoxCommunicationInterface.Name = "comboBoxCommunicationInterface"; + this.comboBoxCommunicationInterface.Size = new System.Drawing.Size(71, 24); + this.comboBoxCommunicationInterface.TabIndex = 9; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(41, 30); + this.label1.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(153, 16); + this.label1.TabIndex = 8; + this.label1.Text = "Communication Interface"; + // + // rfidPortNrTextBox + // + this.rfidPortNrTextBox.Enabled = false; + this.rfidPortNrTextBox.Location = new System.Drawing.Point(439, 26); + this.rfidPortNrTextBox.Margin = new System.Windows.Forms.Padding(4); + this.rfidPortNrTextBox.Name = "rfidPortNrTextBox"; + this.rfidPortNrTextBox.Size = new System.Drawing.Size(44, 22); + this.rfidPortNrTextBox.TabIndex = 7; + // + // rfidSerialPortNrLabel + // + this.rfidSerialPortNrLabel.AutoSize = true; + this.rfidSerialPortNrLabel.Location = new System.Drawing.Point(321, 30); + this.rfidSerialPortNrLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.rfidSerialPortNrLabel.Name = "rfidSerialPortNrLabel"; + this.rfidSerialPortNrLabel.Size = new System.Drawing.Size(88, 16); + this.rfidSerialPortNrLabel.TabIndex = 6; + this.rfidSerialPortNrLabel.Text = "Serial port nr.:"; + // + // optoDataGroupBox + // + this.optoDataGroupBox.Controls.Add(this.tcpipPortLabel); + this.optoDataGroupBox.Controls.Add(this.tcpipPortTextBox); + this.optoDataGroupBox.Controls.Add(this.ipAddressLabel); + this.optoDataGroupBox.Controls.Add(this.ipAddressTextBox); + this.optoDataGroupBox.Controls.Add(this.radioButton1); + this.optoDataGroupBox.Controls.Add(this.radioButton2); + this.optoDataGroupBox.Controls.Add(this.optoSerialPortLabel); + this.optoDataGroupBox.Controls.Add(this.optoSerialPortTextBox); + this.optoDataGroupBox.Location = new System.Drawing.Point(10, 131); + this.optoDataGroupBox.Margin = new System.Windows.Forms.Padding(4); + this.optoDataGroupBox.Name = "optoDataGroupBox"; + this.optoDataGroupBox.Padding = new System.Windows.Forms.Padding(4); + this.optoDataGroupBox.Size = new System.Drawing.Size(552, 119); + this.optoDataGroupBox.TabIndex = 18; + this.optoDataGroupBox.TabStop = false; + this.optoDataGroupBox.Text = "Opto-data"; + // + // tcpipPortLabel + // + this.tcpipPortLabel.AutoSize = true; + this.tcpipPortLabel.Location = new System.Drawing.Point(41, 87); + this.tcpipPortLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.tcpipPortLabel.Name = "tcpipPortLabel"; + this.tcpipPortLabel.Size = new System.Drawing.Size(54, 16); + this.tcpipPortLabel.TabIndex = 4; + this.tcpipPortLabel.Text = "Port nr..:"; + // + // tcpipPortTextBox + // + this.tcpipPortTextBox.Enabled = false; + this.tcpipPortTextBox.Location = new System.Drawing.Point(143, 84); + this.tcpipPortTextBox.Margin = new System.Windows.Forms.Padding(4); + this.tcpipPortTextBox.Name = "tcpipPortTextBox"; + this.tcpipPortTextBox.Size = new System.Drawing.Size(51, 22); + this.tcpipPortTextBox.TabIndex = 5; + // + // ipAddressLabel + // + this.ipAddressLabel.AutoSize = true; + this.ipAddressLabel.Location = new System.Drawing.Point(41, 59); + this.ipAddressLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.ipAddressLabel.Name = "ipAddressLabel"; + this.ipAddressLabel.Size = new System.Drawing.Size(78, 16); + this.ipAddressLabel.TabIndex = 2; + this.ipAddressLabel.Text = "IP address.:"; + // + // ipAddressTextBox + // + this.ipAddressTextBox.Enabled = false; + this.ipAddressTextBox.Location = new System.Drawing.Point(143, 55); + this.ipAddressTextBox.Margin = new System.Windows.Forms.Padding(4); + this.ipAddressTextBox.Name = "ipAddressTextBox"; + this.ipAddressTextBox.Size = new System.Drawing.Size(129, 22); + this.ipAddressTextBox.TabIndex = 3; + // + // radioButton1 + // + this.radioButton1.AutoSize = true; + this.radioButton1.Checked = true; + this.radioButton1.Enabled = false; + this.radioButton1.Location = new System.Drawing.Point(29, 23); + this.radioButton1.Margin = new System.Windows.Forms.Padding(4); + this.radioButton1.Name = "radioButton1"; + this.radioButton1.Size = new System.Drawing.Size(99, 20); + this.radioButton1.TabIndex = 0; + this.radioButton1.TabStop = true; + this.radioButton1.Text = "Use TCP/IP"; + this.radioButton1.UseVisualStyleBackColor = true; + // + // radioButton2 + // + this.radioButton2.AutoSize = true; + this.radioButton2.Enabled = false; + this.radioButton2.Location = new System.Drawing.Point(312, 23); + this.radioButton2.Margin = new System.Windows.Forms.Padding(4); + this.radioButton2.Name = "radioButton2"; + this.radioButton2.Size = new System.Drawing.Size(115, 20); + this.radioButton2.TabIndex = 1; + this.radioButton2.Text = "Use serial port"; + this.radioButton2.UseVisualStyleBackColor = true; + // + // optoSerialPortLabel + // + this.optoSerialPortLabel.AutoSize = true; + this.optoSerialPortLabel.Location = new System.Drawing.Point(321, 55); + this.optoSerialPortLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.optoSerialPortLabel.Name = "optoSerialPortLabel"; + this.optoSerialPortLabel.Size = new System.Drawing.Size(88, 16); + this.optoSerialPortLabel.TabIndex = 6; + this.optoSerialPortLabel.Text = "Serial port nr.:"; + // + // optoSerialPortTextBox + // + this.optoSerialPortTextBox.Enabled = false; + this.optoSerialPortTextBox.Location = new System.Drawing.Point(439, 52); + this.optoSerialPortTextBox.Margin = new System.Windows.Forms.Padding(4); + this.optoSerialPortTextBox.Name = "optoSerialPortTextBox"; + this.optoSerialPortTextBox.Size = new System.Drawing.Size(44, 22); + this.optoSerialPortTextBox.TabIndex = 7; + // + // groupTextBox + // + this.groupTextBox.Enabled = false; + this.groupTextBox.Location = new System.Drawing.Point(153, 97); + this.groupTextBox.Margin = new System.Windows.Forms.Padding(4); + this.groupTextBox.Name = "groupTextBox"; + this.groupTextBox.Size = new System.Drawing.Size(44, 22); + this.groupTextBox.TabIndex = 22; + // + // groupLabel + // + this.groupLabel.AutoSize = true; + this.groupLabel.Location = new System.Drawing.Point(6, 101); + this.groupLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.groupLabel.Name = "groupLabel"; + this.groupLabel.Size = new System.Drawing.Size(54, 16); + this.groupLabel.TabIndex = 21; + this.groupLabel.Text = "Group 2"; + // + // muxBoardNrTextBox + // + this.muxBoardNrTextBox.Enabled = false; + this.muxBoardNrTextBox.Location = new System.Drawing.Point(153, 69); + this.muxBoardNrTextBox.Margin = new System.Windows.Forms.Padding(4); + this.muxBoardNrTextBox.Name = "muxBoardNrTextBox"; + this.muxBoardNrTextBox.Size = new System.Drawing.Size(44, 22); + this.muxBoardNrTextBox.TabIndex = 20; + // + // muxBoardNrLabel + // + this.muxBoardNrLabel.AutoSize = true; + this.muxBoardNrLabel.Location = new System.Drawing.Point(6, 72); + this.muxBoardNrLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.muxBoardNrLabel.Name = "muxBoardNrLabel"; + this.muxBoardNrLabel.Size = new System.Drawing.Size(131, 16); + this.muxBoardNrLabel.TabIndex = 19; + this.muxBoardNrLabel.Text = "Group 1 (mux. board)"; + // + // nameTextBox + // + this.nameTextBox.Enabled = false; + this.nameTextBox.Location = new System.Drawing.Point(153, 40); + this.nameTextBox.Margin = new System.Windows.Forms.Padding(4); + this.nameTextBox.Name = "nameTextBox"; + this.nameTextBox.Size = new System.Drawing.Size(160, 22); + this.nameTextBox.TabIndex = 17; + // + // nameLabel + // + this.nameLabel.AutoSize = true; + this.nameLabel.Location = new System.Drawing.Point(6, 44); + this.nameLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.nameLabel.Name = "nameLabel"; + this.nameLabel.Size = new System.Drawing.Size(44, 16); + this.nameLabel.TabIndex = 16; + this.nameLabel.Text = "Name"; + // + // classNameLabel + // + this.classNameLabel.AutoSize = true; + this.classNameLabel.Location = new System.Drawing.Point(149, 11); + this.classNameLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.classNameLabel.Name = "classNameLabel"; + this.classNameLabel.Size = new System.Drawing.Size(78, 16); + this.classNameLabel.TabIndex = 15; + this.classNameLabel.Text = "ClassName"; + // + // tabPage2 + // + this.tabPage2.Location = new System.Drawing.Point(4, 25); + this.tabPage2.Name = "tabPage2"; + this.tabPage2.Padding = new System.Windows.Forms.Padding(3); + this.tabPage2.Size = new System.Drawing.Size(603, 403); + this.tabPage2.TabIndex = 1; + this.tabPage2.Text = "Test"; + this.tabPage2.UseVisualStyleBackColor = true; + // + // groupBox2 + // + this.groupBox2.Controls.Add(this.headPortNrTextBox); + this.groupBox2.Controls.Add(this.label2); + this.groupBox2.Location = new System.Drawing.Point(10, 335); + this.groupBox2.Name = "groupBox2"; + this.groupBox2.Size = new System.Drawing.Size(552, 50); + this.groupBox2.TabIndex = 26; + this.groupBox2.TabStop = false; + this.groupBox2.Text = "Head Communication"; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(321, 18); + this.label2.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(88, 16); + this.label2.TabIndex = 7; + this.label2.Text = "Serial port nr.:"; + // + // headPortNrTextBox + // + this.headPortNrTextBox.Enabled = false; + this.headPortNrTextBox.Location = new System.Drawing.Point(439, 15); + this.headPortNrTextBox.Margin = new System.Windows.Forms.Padding(4); + this.headPortNrTextBox.Name = "headPortNrTextBox"; + this.headPortNrTextBox.Size = new System.Drawing.Size(44, 22); + this.headPortNrTextBox.TabIndex = 8; + // + // IperlHeadCfgCtrl + // + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 16F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.tabControl1); + this.Margin = new System.Windows.Forms.Padding(4); + this.Name = "IPerlCfgCtrl"; + this.Size = new System.Drawing.Size(617, 438); + this.Load += new System.EventHandler(this.WaterMeterCfgCtrl_Load); + this.tabControl1.ResumeLayout(false); + this.tabPage1.ResumeLayout(false); + this.tabPage1.PerformLayout(); + this.groupBox1.ResumeLayout(false); + this.groupBox1.PerformLayout(); + this.optoDataGroupBox.ResumeLayout(false); + this.optoDataGroupBox.PerformLayout(); + this.groupBox2.ResumeLayout(false); + this.groupBox2.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.TabControl tabControl1; + private System.Windows.Forms.TabPage tabPage1; + private System.Windows.Forms.Label label4; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.ComboBox comboBoxCommunicationInterface; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox rfidPortNrTextBox; + private System.Windows.Forms.Label rfidSerialPortNrLabel; + private System.Windows.Forms.GroupBox optoDataGroupBox; + private System.Windows.Forms.Label tcpipPortLabel; + private System.Windows.Forms.TextBox tcpipPortTextBox; + private System.Windows.Forms.Label ipAddressLabel; + private System.Windows.Forms.TextBox ipAddressTextBox; + private System.Windows.Forms.RadioButton radioButton1; + private System.Windows.Forms.RadioButton radioButton2; + private System.Windows.Forms.Label optoSerialPortLabel; + private System.Windows.Forms.TextBox optoSerialPortTextBox; + private System.Windows.Forms.TextBox groupTextBox; + private System.Windows.Forms.Label groupLabel; + private System.Windows.Forms.TextBox muxBoardNrTextBox; + private System.Windows.Forms.Label muxBoardNrLabel; + private System.Windows.Forms.TextBox nameTextBox; + private System.Windows.Forms.Label nameLabel; + private System.Windows.Forms.Label classNameLabel; + private System.Windows.Forms.TabPage tabPage2; + private System.Windows.Forms.GroupBox groupBox2; + private System.Windows.Forms.TextBox headPortNrTextBox; + private System.Windows.Forms.Label label2; + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.resx b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.resx new file mode 100644 index 000000000..1af7de150 --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlCfgCtrl.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlReader.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlReader.cs new file mode 100644 index 000000000..dd814836f --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IPerlReader.cs @@ -0,0 +1,1492 @@ +using System; +using System.IO; +using System.IO.Ports; +using System.Linq; +using System.Xml.Linq; +using Common; +using Common.Iperl; +using Config.Entities; +using log4net; +using NHibernate; +using Sensus.iPerl.NfcHandler; +using TBF.Rig.Generic; +using TBF.Rig.GenericDevices; +using TBF.Rig.TestMethods.iPerlCommunication.iPerlHead; +using CalibrationStruct = TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication.CalibrationStruct; +using CalibrationStructV4 = TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication.CalibrationStructV4; +using CommunicationInterface = TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication.CommunicationInterface; +using ConfigStruct = TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication.ConfigStruct; +using MeterType = TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication.MeterType; + + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI +{ + /// + /// based on IperlHead class + /// + public class IPerlReader : ComponentBase, IDevice,IRegReaderDatastream, ISessionDataMngmnt, IOperation + { + private static readonly ILog log = LogManager.GetLogger(typeof(IPerlReader)); + public override string ToString() { return string.Format("{0}({1})", ClassName, Cfg.ToString(-1)); } + + +#if TURA_SPECIAL + public const int OptoDataBufferSize = 250000; +#else + public const int OptoDataBufferSize = 40000; /// Opto data count is not limitted by the buffer size +#endif + public const string OptoDataDirectory = "C:\\TBF\\ProcessData"; + public const int StartOptoDataCount = OptoDataBufferSize / 2; + public const int EndOptoDataCount = OptoDataBufferSize - StartOptoDataCount; + public const int StartEndFilterSamplesCount2 = 20; /// StartEndFilterSamplesCount = 2 * StartEndFilterSamplesCount2 + 1 + public const int FeatureVectorSize = 9; + + readonly IPerlCfg _iPerlCfg; + + public int RfidComPortNr { get { return _iPerlCfg.RfidComPortNr; } } + public int OptoComPortNr { get { return _iPerlCfg.OptoComPortNr; } } + public int MuxBoardNrOrGroup14 { get { return _iPerlCfg.MuxBoardNr; } } + public int Group { get { return _iPerlCfg.Group; } } + public MeterType MeterType { get { return _iPerlCfg.MeterType; } } + public CommunicationInterface CommInterface { get { return _iPerlCfg.CommunicationInterface; } } + + public double CalibTarget { get { return _iPerlCfg.ProcParams.CalibTarget; } } + public ushort FactorLimitLo { get { return (ushort)_iPerlCfg.ProcParams.FactorLimitLo; } } + public ushort FactorLimitHi { get { return (ushort)_iPerlCfg.ProcParams.FactorLimitHi; } } + public Counting InitFlowDir { get { return (_iPerlCfg != null && _iPerlCfg.ProcParams != null) ? _iPerlCfg.ProcParams.Counting : Counting.Arbitrary; } } + + string simulatedPcbNr = null; + /// Properties set by the Begin and the End form + public string SerialNr + { + get + { + if (ConfigStruct != null) + return ConfigStruct.GetPcbNrString(); + else if (simulatedPcbNr != null) + return simulatedPcbNr; + else + return string.Empty; + } + set + { + simulatedPcbNr = value; + } + } + + public bool Disabled; + public bool CommFailed; + public int ResultCode; + + + string extraDataPath; + public string ExtraDataPath { get { return extraDataPath; } } + + float[] x; + public float[] X { get { return x; } } + + /// + /// Passed to OptoTelegramRaw.UpdateFromString(...) + /// + Int64 volumeRawExtLast; + Int64 timestampExtLast; + + FlowDirectionDetection flowDirectionDetection; + + public bool PositiveCounting; + + + public ConfigStruct ConfigStruct; /// ConfigStruct of WM obtained or updated by iPerlCommunication + public CalibrationStruct CalibrationStruct; /// CalibrationStruct of WM obtained or updated by iPerlCommunication + public CalibrationStructV4 CalibrationStructV4; /// CalibrationStruct of WM obtained or updated by iPerlCommunication + + public Byte OrigTestModeConfig; /// Written to by StartTestingSealedMeter(), read from by EndTestingSealedMeter() + + public ushort OrigCalibFactor; + public ushort CalibFactor + { + get + { + return (CalibrationStruct != null) ? CalibrationStruct.Calibration + : ((CalibrationStructV4 != null) ? CalibrationStructV4.Calibration + : (ushort)0); + } + } + + public ushort OrigCalibFactorLNA; + public ushort CalibFactorLNA { get { return (CalibrationStructV4 != null) ? CalibrationStructV4.CalibrationLNA : (ushort)0; } } + + + public double Q2ErrWOCorrection; + public int Q2CorrRL; + public int Q2CorrLR; + + public double Diff2Hz8Hz; + public bool Hz2CorrectionDone; + public int Hz2Correction; + + public string FWVersion + { + get + { + return (CalibrationStruct != null) ? CalibrationStruct.FWVersionStr() + : ((CalibrationStructV4 != null) ? CalibrationStructV4.FWVersionStr() + : string.Empty); + } + } + + + /// Result of the last test used to calculate Q2 correction factors, etc + public Results.Entities.MeterTestRslt LastTestResult; + public Results.Entities.MeterTestRslt LastTestResult2; + + + + /// + Test test; + int repetitionNr; + + + /// + /// Indices to determine centers of start / end samples + /// + public int TestStartTelegramIx; + public int TestEndTelegramIx; + int endTelegramIdx1; + int endTelegramIdx2; + int endTelegramIdx3; + + int currentTelegramIx; + bool startSampleAcquired; + + /// + /// Timestamp from the opto telegram + /// + private Int64 lastTimestamp; + private double timestampSec; + private double timestampSec0; + + int timeFromStart; /// [s] Time from test start to determine when the test start sample should be taken + + + /// Test start volume for metrology in seconds + public double TimestampSecStart + { + get { return TimeFromSamples(optoData, optoDataCount, TestStartTelegramIx, StartEndFilterSamplesCount2); } + } + /// Test end time for metrology in seconds + public double TimestampSecEnd + { + get { return TimeFromSamples(optoData, optoDataCount, TestEndTelegramIx, StartEndFilterSamplesCount2); } + } + /// + public bool NoSamples + { + get { return TimestampSecStart == 0 || TimestampSecEnd == 0 || (TimestampSecEnd - TimestampSecStart) < float.Epsilon; } + } + + /// + /// Volume of water from the opto telegram + /// + private Int64 lastVolumeRaw; /// Last read raw volume + private double volumeLtr; + private double volumeLtr0; + + /// Test start volume for metrology in liters + public double VolumeLtrStart + { + get { return NoSamples ? 0 : VolumeFromSamples(optoData, optoDataCount, TestStartTelegramIx, ScalingFactor(), StartEndFilterSamplesCount2); } + } + /// Test end volume for metrology in liters + public double VolumeLtrEnd + { + get { return NoSamples ? 0 : VolumeFromSamples(optoData, optoDataCount, TestEndTelegramIx, ScalingFactor(), StartEndFilterSamplesCount2); } + } + + + OptoTelegramRaw[] optoData; + int optoDataCount; /// Real opto deta count, can be larger then optoData.Length + /// + OptoTelegramRaw toBeFlushed; + + /// + /// Opto serial port and worker thread related private variables + /// + private SerialPort optoSerialPort; + + + DataStreamState dataStreamState; + /// + /// Variables storing the context of serial port data parsing (ReadOptoSerialPort(...)) + /// + bool synchronized; + bool synchronized2; + string partOfTelegram; + + Counting currentFlowDir; + + + /// + /// /////////////////////////////////////////// + /// + + public IPerlReader() { } + + public IPerlReader(Generic.IComponentCfg cfg) + : base(cfg) + { + _iPerlCfg = cfg as IPerlCfg; + } + + + /// + /// + /// + /// + + public override void Initialize() + { + x = new float[FeatureVectorSize]; + flowDirectionDetection = new FlowDirectionDetection(); + + /// Allocate memory for opto-data from iPerl + optoData = new OptoTelegramRaw[OptoDataBufferSize]; + for (int i = 0; i < OptoDataBufferSize; i++) + { + optoData[i] = new OptoTelegramRaw(); + } + + toBeFlushed = new OptoTelegramRaw(); + + dataStreamState = DataStreamState.Flush; + synchronized = false; + synchronized2 = false; + partOfTelegram = string.Empty; + optoSerialPort = null; + + if (DebugLevel == DebugMode.Normal) + { + /// Open serial port: 9600 Bd, 8 data bits, 1 stop bit, no parity + /// Check whether head is connected, working + try + { + OpenOptoSerialPort($"COM{_iPerlCfg.OptoComPortNr}", 9600, Parity.None, 8, StopBits.One, Handshake.None); + CloseOptoSerialPort(); + log.FatalFormat($"{Name} initialized: {this}"); + } + catch (Exception ex) + { + throw new Exception(ex.Message); + } + } + else + { + log.FatalFormat($"{Name} simulated: {this}"); + } + } + + public void RunDeviceBefore() + { + if (DebugLevel == DebugMode.Normal) + { + try + { + ReadOptoData(dataStreamState); + } + catch (Exception e) + { + DebugLevel = DebugMode.FailureDuringOperation; + + log.FatalFormat("Opto-data serial port failure : {0}", e.Message); + if (e.InnerException != null) + { + log.FatalFormat("InnerMessage : {0}", e.InnerException.Message); + } + } + } + else if (DebugLevel == DebugMode.FailureDuringOperation) + { + } + } + + public void RunDeviceAfter() { } + + public void StopDevice() + { + try + { + if (optoSerialPort != null) + { + CloseOptoSerialPort(); + } + } + catch + { + } + } + + public void StopDevice2() { } + + /// + /// Events: Event.ReadRegisterDone, Event.Error + /// + /// ReadWaterMeter instance reference casted to IOperaton + public IOperation ReadRegisterOp() + { + return this; + } + + public RegisterReaderType RegisterReaderType { get { return RegisterReaderType.DataStream; } } + public int Position + { + get + { + int firstDigitPos = Name.IndexOfAny(new char[] { '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' }); + int position; + return (firstDigitPos < 0) ? 0 : (int.TryParse(Name.Substring(firstDigitPos), out position) ? position : 0); + } + } + + int wmPulses; + int wmRefPulses; + double beginWMState; + double endWMState; + double wmVolume; + double wmTestTime; + + public double PulsesPerLtr { get { return 1000.0; } } + public double LtrsPerPulse { get { return 1 / PulsesPerLtr; } } + public int WMPulses { get { return wmPulses; } } + public int WMRefPulses { get { return wmRefPulses; }} + public double WMVolume { get { return wmVolume; } } + public double BeginWMState { get { return beginWMState; } } + public double EndWMState { get { return endWMState; } } + public IOperation ReadDatastreamOp() + { + return this; + } + + /// + /// Clear data related to a specific water meter + /// + public void StartSession() + { + ResultCode = 0; + + Disabled = false; + CommFailed = false; + + ConfigStruct = null; + CalibrationStruct = null; + CalibrationStructV4 = null; + + OrigTestModeConfig = 0; + + LastTestResult = null; + LastTestResult2 = null; + + OrigCalibFactor = 0; + OrigCalibFactorLNA = 0; + Q2ErrWOCorrection = 0; + Q2CorrRL = 0; + Q2CorrLR = 0; + + simulatedPcbNr = null; + + dataStreamState = DataStreamState.Flush; + + currentFlowDir = InitFlowDir; + } + + + public void SaveMark(object mark) + { + /// TODO + } + + public void EndSession() + { + StopDataStreamProcessing(); + } + + /// + /// Start this operation + /// + public void Start() + { + lock (this) + { + Clear(); + ReadPulses(); + StartDataStreamProcessing(); + } + } + + /// + /// Run this operation + /// + /// eventDone + public Event Run() + { + lock (this) + { + timeFromStart += StateMachine.Period; + ReadPulses(); + + if (!startSampleAcquired && (timeFromStart >= 8) && (currentTelegramIx >= 0)) + { + /// Take the test start sample + startSampleAcquired = true; + TestStartTelegramIx = currentTelegramIx; + } + else if (startSampleAcquired) + { + /// Shift data in pipelines + TestEndTelegramIx = endTelegramIdx3; + endTelegramIdx3 = endTelegramIdx2; + endTelegramIdx2 = endTelegramIdx1; + endTelegramIdx1 = currentTelegramIx; + } + } + + return Event.ReadRegisterDone; + } + + /// + /// Stop this operation + /// + public void Stop() + { + log.DebugFormat("Flow filtering end, feature vector calculation start: {0:HH:mm:ss.fff}", DateTime.Now); + + int startIx; + int endIx; + + lock (this) + { + StopDataStreamProcessing(); + AddTestStartEndMarksToData(out startIx, out endIx); + } + + DataStreamPostProcessing(); + + // TODO: Enable when calculations completed + // + // float[] offsetV, kOhmsR, kOhmsC, dutFlow, refFlow, flowRatio, magField, emfV; + // x = Common.StatisticalMetrics.Calculate(optoData, optoDataCount, startIx, endIx, true, + // out offsetV, out kOhmsR, out kOhmsC, out dutFlow, + // out refFlow, out flowRatio, out magField, out emfV); + // + // log.DebugFormat("Feature vector calculation end, save opto-file start: {0:HH:mm:ss.fff}", DateTime.Now); + +#if ORACLE_DB + if (test.RawDataId + (test.Repeats - repetitionNr) * test.RawDataIdRepetMulti != 0) + { + string relativeDirectory = Path.Combine(StateMachine.CycleStartTimeStamp.ToString("yy"), + StateMachine.CycleStartTimeStamp.ToString("MM"), + StateMachine.CycleStartTimeStamp.ToString("dd")); + string fileName = DetermineExtraDataFileName(); + if (SaveOptoDataToFile(Path.Combine(OptoDataDirectory, relativeDirectory), fileName)) + { + extraDataPath = Path.Combine(relativeDirectory, fileName); + } + + log.WarnFormat("IperlHead.Stop() startIx={0} endIx={1} len={2} raw data file = {3}", + startIx, endIx, optoData.Length, fileName); + } + else +#endif + { + log.WarnFormat("IperlHead.Stop() startIx={0} endIx={1} len={2} no raw data file", startIx, endIx, optoData.Length); + } + + if (TestStartTelegramIx == 0 || optoDataCount < 100) + { + ResultCode |= (int)Results.Entities.ResultCode.MissingOptoData; + } + else if (VolumeLtrEnd == VolumeLtrStart) + { + ResultCode |= (int)Results.Entities.ResultCode.OptoDataWithZeroFlow; + } + } + + + + + //////////////////////////////////////////////////////// + /// + /// + /// New calibration factor calculated from the original factor (argument) + /// and results of any test(s). + /// Uses also: this.CalibTarget, this.VolumeLtrStart, this.VolumeLtrEnd + /// Side effects: this.OrigCalibFactor, this.PositiveCounting + /// + /// Test result for calculations + /// Original calibration factor + /// Lower limit for the calibration factor + /// Upper limit for the calibration factor + /// New calibration factor or 0 (= Out of range) + public UInt16 CalculateNewCalibFactor(Results.Entities.MeterTestRslt adjustTestResult, UInt16 originalCalibrationFactor, UInt16 factorLimitLo, UInt16 factorLimitHi) + { + double meterVolume = adjustTestResult.VolumeMeter; + double targetVolume = adjustTestResult.VolumeRef * (1.0f + CalibTarget / 100.0f); + + OrigCalibFactor = originalCalibrationFactor; + + if (meterVolume > 1E-2) + { + PositiveCounting = VolumeLtrEnd > VolumeLtrStart; + + UInt16 newFactor = (UInt16)((double)originalCalibrationFactor * targetVolume / meterVolume + 0.5); + log.InfoFormat("Calibration factor: orig={0} new={1} V_iperl={2} V_ref={3} V_target={4}", + originalCalibrationFactor, + newFactor, + meterVolume.ToString("F3"), + adjustTestResult.VolumeRef.ToString("F3"), + targetVolume.ToString("F3")); + + + if (newFactor < factorLimitLo || newFactor > factorLimitHi) return 0; + + return newFactor; + } + else + { + log.ErrorFormat("Calibration factor: orig={0} new={0} (unchanged!) V_iperl={1}", + originalCalibrationFactor, + meterVolume.ToString("F3")); + return originalCalibrationFactor; /// Too small volume in the denominator -> no correction at all + } + } + + + /// + /// Q2 correction factor calculated from the last test (Q2). + /// This factor should be used only for R800 meters. + /// + /// A test result from which to calculate the factor + /// Nominal flow in m3/h + /// 0 or the current Q2 correction factor when updating the factor + /// Calculated Q2 correction factor + public double CalculateQ2CorrectionFactor(Results.Entities.MeterTestRslt currentQ2Result, int currentFactor, double nominalFlow, double errorTarget = 0) + { + double nominalTestFlowLph = Units.ConvertTo(Unit.lph, nominalFlow); + double volumeRefShiftedToTarget = currentQ2Result.VolumeRef * (1.0 + errorTarget / 100.0); + double q2adjErrorShiftedToTarget = Config.Formulas.ErrorFromVolumes(currentQ2Result.VolumeMeter, volumeRefShiftedToTarget); + + double A = 16.0 / ScalingFactor(); /// Raw units per ml: DN15=16, DN20=8, DN25=4, DN32=2, DN40=1 + const double B = 8.0; /// Raw units per minute, 8 + const double C = B * 60.0; /// Raw units per hour, 480 + double D = C / A; /// ml correction per hour + double F = D / (nominalTestFlowLph * 10.0); /// Error corrected with 8 Raw Units per minute [%] + double G = F / B; /// Error corrected with 1 Raw Unit per minute [%] + + /// Do not change the factor for an invalid measurement (q2adjResult.VolumeMeter == 0) + double q2CorrectionFactor = (Math.Abs(currentQ2Result.VolumeMeter) <= float.Epsilon) ? Convert.ToDouble(currentFactor) : + Convert.ToDouble(currentFactor) - (q2adjErrorShiftedToTarget / G) * (volumeRefShiftedToTarget / currentQ2Result.VolumeMeter); + + log.WarnFormat("CalculateQ2CorrectionFactor() : Pos={0}, PCB#={1}, Error={2}%, Target={3}%, Current factor={4} New factor={5}", + Name, + SerialNr, + currentQ2Result.Error.ToString("F2"), + errorTarget.ToString("F3"), + currentFactor.ToString("F1"), + q2CorrectionFactor.ToString("F1")); + + return q2CorrectionFactor; + } + + + /// + /// 2 Hz correction factor calculated from two Q3 tests - done at 2Hz and at 8Hz. + /// This factors should be used only for DN32 and DN40 meters. + /// + /// Test result @2Hz from which to calculate the factor + /// Test result @8Hz from which to calculate the factor + /// The calculated Q2 correction factor + /// true = OK, false = failed + public bool Calculate2HzCorrectionFactor(Results.Entities.MeterTestRslt resultAt2Hz, + Results.Entities.MeterTestRslt resultAt8Hz, + out double diff2Hz8Hz, out int hz2CorrectionFactor) + { + hz2CorrectionFactor = 0; + diff2Hz8Hz = 0; + + if ((resultAt2Hz == null) || (resultAt8Hz == null)) + { + return false; /// Test result @2Hz and/or @8Hz is missing ==> water meter failed + } + + diff2Hz8Hz = resultAt2Hz.Error - resultAt8Hz.Error; + + if (Math.Abs(diff2Hz8Hz) > 2.5) return false; /// Difference of errors > 2.5 % ==> water meter failed + + hz2CorrectionFactor = -1 * (int)Math.Round(10 * diff2Hz8Hz); + + log.WarnFormat("2Hz correction: Pos={0}, PCB#={1}, corrFactor={2}, erro@2Hz={3}%, erro@8Hz={4}%", + Name, + SerialNr, + hz2CorrectionFactor, + resultAt2Hz.Error.ToString("F2"), + resultAt8Hz.Error.ToString("F2")); + + return true; + } + + + /// + /// Store/update values to be used as a part of the opto-data log file name. + /// Stop data stream processing and saving, if it is enabled. + /// + /// Currently executed test + /// Currently executed repetition number + public void TestIsGoingToStartSoon(Test _test, int _repetitionNr) + { + /// Store/update values to be used as a part of the opto-data log file name + this.test = _test; + this.repetitionNr = _repetitionNr; + + if (IsDataStreamProcessing()) + { + StopDataStreamProcessing(); + + /// Dummy '#### start test ####' and '#### end of test ####' marks are added + /// to the raw data file on request of Joern Goege + if (optoDataCount >= 100 && optoDataCount <= optoData.Length && + optoData[40].Flags == OptoTelegramFlags.OK && + optoData[optoDataCount - 40].Flags == OptoTelegramFlags.OK) + { + optoData[40].Flags = OptoTelegramFlags.OK_TestStart; + optoData[optoDataCount - 40].Flags = OptoTelegramFlags.OK_TestEnd; + } + + DataStreamPostProcessing(); + + string pcbNr = (ConfigStruct != null) ? ConfigStruct.GetPcbNrString() : "UnknownPcbNr"; + string wmPosition = Name.Substring(5); /// WMPosition is extracted from a component name in form 'iPerl#' + if (wmPosition.Length == 1) wmPosition = "0" + wmPosition; + string cycleStartTime = StateMachine.CycleStartTimeStamp.ToString("HH_mm_ss"); + /// + string relativeDirectory = Path.Combine(StateMachine.CycleStartTimeStamp.ToString("yy"), + StateMachine.CycleStartTimeStamp.ToString("MM"), + StateMachine.CycleStartTimeStamp.ToString("dd")); + string directory = Path.Combine(OptoDataDirectory, relativeDirectory); + string fileName = string.Format("{0}_{1}_{2}_{3}.txt", pcbNr, wmPosition, "WM", cycleStartTime); + + if (SaveOptoDataToFile(directory, fileName)) + { + extraDataPath = Path.Combine(relativeDirectory, fileName); + } + } + } + + /// + /// Reads opto-datastream via serial port. Invoked from RunDeviceBefore() + /// + /// Telegram description: + /// AAAAAA[tab]BBBB[tab]CCCC[tab]DDDDDD[tab]EEEE[tab]FFFFFFFF[tab]GG[cr][lf] (42 bytes) + /// Example: + /// FFFFFE 51EA 0000 65324E 0087 F6319DFF 86 + /// FFDD3A 51F9 0000 65324E 0088 F631A60B 45 + /// ... + /// + /// OptoState.Read or OptoState.Flush + void ReadOptoData(DataStreamState optoState) + { + if (optoSerialPort is null) return; + lock (this) + { + int nrBytes = optoSerialPort.BytesToRead; + if (nrBytes > 0) + { + char[] buffer = new char[nrBytes]; + optoSerialPort.Read(buffer, 0, nrBytes); + string received = new string(buffer); + + string allRcvd = partOfTelegram + received; + + while (true) + { + int pos = allRcvd.IndexOf("\r\n"); + + if (pos < 0) + { + /// No CR+LF found, wait for more characters in the next invocation + partOfTelegram = allRcvd; + return; + } + else + { + /// CR+LF found + if (optoState == DataStreamState.ProcessAndSave) + { + int bufferIx = BufferIdx(optoDataCount); + + if (pos < OptoTelegramRaw.Length - 2) + { + /// CR+LF found too early, truncate the beginning incl CR+LF and keep scanning in this loop + allRcvd = allRcvd.Substring(pos + 2); + if (synchronized) + { + optoData[bufferIx].Counter = optoDataCount; + optoData[bufferIx].SetFlags(OptoTelegramFlags.SyncError); + } + synchronized = true; + } + else if (optoData[bufferIx].UpdateFromString(allRcvd.Substring(pos - OptoTelegramRaw.Length + 2), + optoDataCount, + Convert.ToSingle(Sequences.ProcessData.RefFlow.Val), + ref volumeRawExtLast, ref timestampExtLast)) + { + /// CR+LF was found && (pos >= OptoTelegramRaw.Length - 2) && the telegram is OK + flowDirectionDetection.WriteToFifo(volumeRawExtLast, timestampExtLast); + OptoTelegramReceived(optoDataCount, synchronized2, volumeRawExtLast, timestampExtLast); + synchronized2 = synchronized; + allRcvd = allRcvd.Substring(pos + 2); + } + else + { + /// CR+LF was found && (pos >= OptoTelegramRaw.Length - 2) but the telgram was not OK + optoData[bufferIx].Counter = optoDataCount; + optoDataCount++; + allRcvd = allRcvd.Substring(pos + 2); + } + + optoDataCount++; + } + else /// optoState == OptoState.Flush + { + if (pos < OptoTelegramRaw.Length - 2) + { + /// CR+LF found too early, truncate the beginning incl CR+LF and keep scanning in this loop + allRcvd = allRcvd.Substring(pos + 2); + synchronized = true; + } + // CR+LF found and (pos >= OptoTelegram.Length - 2) + else if (toBeFlushed.UpdateFromString(allRcvd.Substring(pos - OptoTelegramRaw.Length + 2), + 0, + Convert.ToSingle(Sequences.ProcessData.RefFlow.Val), + ref volumeRawExtLast, ref timestampExtLast)) + { + flowDirectionDetection.WriteToFifo(volumeRawExtLast, timestampExtLast); + synchronized2 = synchronized; + allRcvd = allRcvd.Substring(pos + 2); + } + else + { + allRcvd = allRcvd.Substring(pos + 2); + } + } + } + } + + //OnOptoReceived(this, new OptoReceivedEventArgs(s)); + } + else + { + //OnOptoReceived(this, new OptoReceivedEventArgs(".")); + } + } + } + + public string ReadOptoData() + { + if (optoSerialPort is null) return ""; + string received = "."; + lock (this) + { + int nrBytes = optoSerialPort.BytesToRead; + if (nrBytes > 0) + { + char[] buffer = new char[nrBytes]; + optoSerialPort.Read(buffer, 0, nrBytes); + received = new string(buffer); + } + } + return received; + } + + + void OptoTelegramReceived(int currentIx, bool async, Int64 volumeRawExt, Int64 timestampRawExt) + { + currentTelegramIx = currentIx; + + lastVolumeRaw = volumeRawExt; + lastTimestamp = timestampRawExt; + + if (volumeLtr == 0 && volumeLtr0 == 0) + { + volumeLtr = (double)lastVolumeRaw * ScalingFactor() / 16000.0; + volumeLtr0 = volumeLtr; + } + else + { + volumeLtr = (double)lastVolumeRaw * ScalingFactor() / 16000.0; + } + + if (timestampSec == 0 && timestampSec0 == 0) + { + timestampSec = (double)lastTimestamp / 8192.0; + timestampSec0 = timestampSec; + } + else + { + timestampSec = (double)lastTimestamp / 8192.0; + } + } + + + /// + /// + /// Called from the state machine when a test is selected and UI needs to be updated. + /// + public void OnOptoReceived(object sender, OptoReceivedEventArgs args) + { + if (OptoReceivedHandler == null) return; + try { OptoReceivedHandler(sender, args); } + catch (Exception) { } + } + + public event EventHandler OptoReceivedHandler; + + + void AddTestStartEndMarksToData(out int startIx, out int endIx) + { + startIx = BufferIdx(TestStartTelegramIx); + if ((startIx > 0) && (startIx < StartOptoDataCount) && (optoData[startIx].Flags == OptoTelegramFlags.OK)) + { + optoData[startIx].Flags = OptoTelegramFlags.OK_TestStart; + OptoTelegramRaw.TestStartTimestampDec = optoData[startIx].TimestampDec(); + } + else + { + for (int ix = 0; ix < StartOptoDataCount; ix++) + { + if (optoData[ix].Flags == OptoTelegramFlags.OK) + { + /// This is the first correct opto-telegram received + OptoTelegramRaw.TestStartTimestampDec = optoData[ix].TimestampDec(); + break; + } + } + } + + endIx = BufferIdx(TestEndTelegramIx); + if ((endIx > 0) && (optoData[endIx].Flags == OptoTelegramFlags.OK)) + { + optoData[endIx].Flags = OptoTelegramFlags.OK_TestEnd; + } + } + + /// + /// Data stream post processing: + /// Flow from a reference flowmeter is FIR filtered + /// + void DataStreamPostProcessing() + { + if (optoDataCount <= OptoDataBufferSize) + { + FIRFilterFlow(optoData, 0, optoDataCount - 1); + } + else + { + FIRFilterFlow(optoData, 0, StartOptoDataCount - 1); + FIRFilterFlow(optoData, (optoDataCount - EndOptoDataCount), optoDataCount - 1); + } + } + + /// + /// Determine opto data file name: PCB_AA_BB_HH_MI_SS..txt + /// + /// Test name + /// Test repeats count (>= 1) + /// Repetition number (1 .. testRepeats) + /// + string DetermineExtraDataFileName() + { + /// + /// Get required pieces of information + /// + string pcbNr = (ConfigStruct != null) ? ConfigStruct.GetPcbNrString() : "UnknownPcbNr"; + string wmPosition = Name.Substring(5); /// WMPosition is extracted from a component name in form 'iPerl#' + if (wmPosition.Length == 1) wmPosition = "0" + wmPosition; + string cycleStartTime = StateMachine.CycleStartTimeStamp.ToString("HH_mm_ss"); +#if ORACLE_DB + string[] designations = string.IsNullOrEmpty(test.RawDataDesignation) ? new string[0] : test.RawDataDesignation.Split(new char[] { '~' }); + int testId = test.RawDataId + (test.Repeats - repetitionNr) * test.RawDataIdRepetMulti; + string designation = string.IsNullOrEmpty(test.RawDataDesignation) + ? testId.ToString(testId > 0 ? "D2" : "D1") /// Name is generated from Id + : (designations.Length > repetitionNr - 1) ? designations[repetitionNr - 1] /// Name is from 'RawDataDesignation' parameter + : string.Format("{0}-{1}", designations[0], repetitionNr); /// Name is form test name and repetition nr. +#else + int testId = 0; + string designation = (test.Repeats == 1) ? test.Name : string.Format("{0}-{1}", test.Name, repetitionNr); +#endif + /// + /// Return the file name + /// + return string.Format("{0}_{1}_{2}_{3}.txt", pcbNr, wmPosition, designation, cycleStartTime); + } + + + /// + /// Save opto data to a file. + /// + bool SaveOptoDataToFile(string directory, string fileName) + { + string fullFileName = Path.Combine(directory, fileName); + log.WarnFormat("Saving {0} raw data to {1}", Name, fullFileName); + + try + { + Directory.CreateDirectory(directory); + + double scalFact = ScalingFactor(); + + using (TextWriter optoLogFile = new StreamWriter(fullFileName)) + { + if (optoDataCount <= OptoDataBufferSize) + { + /// Telegrams are stored continuously, save them. + optoLogFile.WriteLine(optoData[0].ToString(scalFact, null)); + for (int i = 1; i < optoDataCount; i++) + { + optoLogFile.WriteLine(optoData[i].ToString(scalFact, optoData[i - 1])); + } + } + else /// if (optoDataCount > MaxOptoDataCount) + { + /// Buffer overflow + /// First part of the buffer is saved as is + optoLogFile.WriteLine(optoData[0].ToString(scalFact, null)); + for (int i = 1; i < StartOptoDataCount; i++) + { + optoLogFile.WriteLine(optoData[i].ToString(scalFact, optoData[i - 1])); + } + + optoLogFile.WriteLine(" ..."); + + /// Second part of the buffer is an overflowed circular buffer + optoLogFile.WriteLine(optoData[BufferIdx(optoDataCount)].ToString(scalFact, null)); + for (int i = optoDataCount - EndOptoDataCount + 1; i < optoDataCount; i++) + { + optoLogFile.WriteLine(optoData[BufferIdx(i)].ToString(scalFact, optoData[BufferIdx(i - 1)])); + } + } + + log.WarnFormat("{0} opto data successfully saved: {1} lines", Name, optoDataCount); + + optoLogFile.Close(); + } + + return true; + } + catch (Exception exc) + { + File.Delete(fullFileName); + log.ErrorFormat(string.Format("Error writing into file {0}", fullFileName)); + log.ErrorFormat(string.Format("Exception message: {0}", exc.Message)); + return false; + } + } + + void ReadPulses() + { + beginWMState = volumeLtr0; + endWMState = volumeLtr; + wmVolume = Math.Abs(endWMState - beginWMState); + wmPulses = (int)(wmVolume * (double)PulsesPerLtr + 0.5); + wmRefPulses = StateMachine.ControlBoardMain.RefPulses; + wmTestTime = timestampSec - timestampSec0; + } + + private void OpenOptoSerialPort(string comPort, int baudRate, Parity parity, int dataBits, StopBits stopBit, Handshake handshake) + { + if (DebugLevel == DebugMode.FailureDuringOperation) DebugLevel = DebugMode.Normal; + if (DebugLevel == DebugMode.Normal) + { + /// Open serial port: 9600 Bd, 8 data bits, 1 stop bit, no parity + try + { + CloseOptoSerialPort(); + optoSerialPort = new SerialPort(comPort, baudRate, parity, dataBits, stopBit); + optoSerialPort.Handshake = handshake; + optoSerialPort.Open(); + log.FatalFormat($"{Name} OptoPort opened: {this}"); + } + catch (Exception ex) + { + log.FatalFormat($"{Name} OptoPort - error opening port: {this}" + Environment.NewLine + ex.Message); + throw ex; + } + } + else + { + optoSerialPort = null; + log.FatalFormat($"{Name} OproPort simulated: {this}"); + } + } + + private void CloseOptoSerialPort() + { + if (optoSerialPort != null) + { + optoSerialPort.Close(); + optoSerialPort = null; + log.FatalFormat($"{Name} OptoPort closed: {this}"); + } + } + + + + /// + /// Reset counters / indices / time and start processing and saving datastream data + /// + public void StartDataStreamProcessing() + { + try + { + OpenOptoSerialPort($"COM{_iPerlCfg.OptoComPortNr}", 9600, Parity.None, 8, StopBits.One, Handshake.None); + } + catch (Exception) + { + } + /// Reset opto-data, etc. + optoDataCount = 0; + timeFromStart = 0; + currentTelegramIx = -1; + startSampleAcquired = false; + TestStartTelegramIx = 0; + endTelegramIdx1 = 0; + endTelegramIdx2 = 0; + endTelegramIdx3 = 0; + TestEndTelegramIx = 0; + + if (optoSerialPort != null && optoSerialPort.IsOpen) optoSerialPort.DiscardInBuffer(); + + if (flowDirectionDetection != null) flowDirectionDetection.ClearFifo(); /// Clear FIFO for flow direction detection + + /// Enable opto-data parsing and saving + dataStreamState = DataStreamState.ProcessAndSave; + } + + /// + /// Returns true when processing and saving datastream data is in progress + /// + bool IsDataStreamProcessing() + { + return dataStreamState == DataStreamState.ProcessAndSave; + } + + /// + /// Stop processing and saving datastream data + /// + public void StopDataStreamProcessing() + { + dataStreamState = DataStreamState.Flush; + CloseOptoSerialPort(); + } + + /// + /// Compares CalibrationStruct.MeterType with iPerlCfg.MeterType. + /// iPerlCfg.MeterType == MeterType.AutoDetect disables type checking + /// CalibrationStruct == null disables type checking ... + /// ... so that failed RFID communication does not cause type verification failure) + /// + /// true when type is OK + public bool VerifyIPerlType() + { + if (_iPerlCfg.MeterType == MeterType.AutoDetect || CalibrationStruct == null) + { + return true; + } + + return _iPerlCfg.MeterType == CalibrationStruct.MeterType; + } + + public static double UnitVolume(VolumeUnits units) + { + switch (units) + { + default: + case VolumeUnits.m3: return Common.Units.ConvertFrom(Common.Unit.m3, 1.0); /// 1 liter + case VolumeUnits.UK_gallon: return Common.Units.ConvertFrom(Common.Unit.UKgal, 1.0); /// 1 imperial gallon + case VolumeUnits.US_gallon: return Common.Units.ConvertFrom(Common.Unit.USgal, 1.0); /// 1 US gallon + } + } + + public double ScalingFactor() + { + if ((_iPerlCfg.MeterType == MeterType.AutoDetect) && (CalibrationStruct != null)) + { + return ScalingFactor(CalibrationStruct.MeterType); + } + else if (_iPerlCfg.MeterType != MeterType.AutoDetect) + { + return ScalingFactor(_iPerlCfg.MeterType); + } + else + { + return ScalingFactor(MeterType.DN20); + } + } + + /// + /// Scaling factor: + /// 0, 1 (DN15, Coax) . . . . 1 + /// 2 (DN20) . . . . . . . . 2 + /// 3 (DN25) . . . . . . . . 4 + /// 4, 5 (DN26, DN32) . . . . 8 + /// 6 (DN40) . . . . . . . . 16 + /// + /// MeterType (0..6) + /// Scaling factor + public static double ScalingFactor(MeterType meterType) + { + switch (meterType) + { + default: + case MeterType.DN15: + case MeterType.CoaxManifold: + return 1.0; + + case MeterType.DN20: + return 2.0; + + case MeterType.DN25: + return 4.0; + + case MeterType.DN25_Q3_10: + case MeterType.DN32: + return 8.0; + + case MeterType.DN40: + return 16.0; + } + } + + /// + /// Calculate a filtered volume from data stream samples + /// + /// Samples used in calculation are centered around unwrappedIx + /// Count of samples used in calculation is 2 * smaplesCount2 + 1 + /// Filtered volume + double VolumeFromSamples(OptoTelegramRaw[] optoData, int optoDataCount, int unwrappedIx, double scalingFactor, int samplesCount2 = 0) + { + if (samplesCount2 < 0) samplesCount2 = 0; + if ((unwrappedIx - samplesCount2) < 0 || (unwrappedIx + samplesCount2) >= optoDataCount) return 0; + + Int64 sum = 0; + for (int i = unwrappedIx - samplesCount2; i <= unwrappedIx + samplesCount2; i++) + { + int wrappedIx = BufferIdx(i); + + if (optoData[wrappedIx].Flags != OptoTelegramFlags.OK && + optoData[wrappedIx].Flags != OptoTelegramFlags.OK_TestStart && + optoData[wrappedIx].Flags != OptoTelegramFlags.OK_TestEnd) + { + return 0; + } + + sum += optoData[wrappedIx].VolumeRawExt; + } + + return 0.0000625 * scalingFactor * sum / (double)(2 * samplesCount2 + 1); + } + + /// + /// Calculate a filtered time from data stream samples + /// + /// Samples used in calculation are centered around unwrappedIx + /// Count of samples used in calculation is 2 * smaplesCount2 + 1 + /// Filtered time + double TimeFromSamples(OptoTelegramRaw[] optoData, int optoDataCount, int unwrappedIx, int samplesCount2 = 0) + { + if (samplesCount2 < 0) samplesCount2 = 0; + if ((unwrappedIx - samplesCount2) < 0 || (unwrappedIx + samplesCount2) >= optoDataCount) return 0; + + Int64 sum = 0; + for (int i = unwrappedIx - samplesCount2; i <= unwrappedIx + samplesCount2; i++) + { + int wrappedIx = BufferIdx(i); + + if (optoData[wrappedIx].Flags != OptoTelegramFlags.OK && + optoData[wrappedIx].Flags != OptoTelegramFlags.OK_TestStart && + optoData[wrappedIx].Flags != OptoTelegramFlags.OK_TestEnd) + { + return 0; + } + + sum += optoData[wrappedIx].TimestampExt; + } + + return sum / (double)(8192 * (2 * samplesCount2 + 1)); + } + + /// + /// Filter RefFlow data in an array of OptoTelegramRaw objects by a FIR filter: + /// + /// kSize = 5, kSize2 = 2 + /// + /// i k + /// --------------------------------------------------------------------------- + /// 0 -5 filtered[0] = data[0] + /// 1 -4 filtered[1] = data[1] + /// 2 -3 filtered[2] = data[0]*k[0] + ... + data[4]*k[4] + /// 3 -2 filtered[3] = data[1]*k[0] + ... + data[5]*k[4] + /// 4 -1 filtered[4] = data[2]*k[0] + ... + data[6]*k[4] + /// 5 0 data[0] = filtered[0], filtered[0] = data[3]*k[0] + ... + data[7]*k[4] + /// 6 1 data[1] = filtered[1], filtered[1] = data[4]*k[0] + ... + data[8]*k[4] + /// 7 ... + /// + /// array of OptoTelegramRaw objects + /// Index of the first optoData item to process + /// Index of the last optoData item to process + public static void FIRFilterFlow(OptoTelegramRaw[] optoData, int from, int to) + { + float[] kernel = new float[] { 0.1f, 0.2f, 0.4f, 0.2f, 0.1f }; + int kSize = kernel.Length; + int kSize2 = kernel.Length / 2; + + float[] filtered = new float[kSize]; + + for (int i = from; i <= to; i++) + { + if ((i < from + kSize2) || (i > to - kSize2)) + { + /// Beginning or end of optoData buffer => Just copy data (=do not filter) + filtered[i % kSize] = optoData[BufferIdx(i)].RefFlow; + } + else + { + /// Make a convolution of optoData and the kernel + float weightedSum = 0; + for (int j = -kSize2; j <= kSize2; j++) + weightedSum += optoData[BufferIdx(i + j)].RefFlow * kernel[j + kSize2]; + + filtered[i % kSize] = weightedSum; + } + + if (i >= from + kSize) + { + /// filtered[] buffer full => copy filtered data to optoData + optoData[BufferIdx(i - kSize)].RefFlow = filtered[i % kSize]; + } + } + + for (int i = to - kSize + 1; i <= to; i++) + { + if (i >= 0) optoData[BufferIdx(i)].RefFlow = filtered[i % kSize]; + } + } + + /// + /// Get index to optoData buffer + /// + /// Original unwrapped index + /// Index to the buffer + public static int BufferIdx(int index) + { + if (index < IperlHead.OptoDataBufferSize) + { + return index; + } + else + { + return IperlHead.StartOptoDataCount + (index - IperlHead.OptoDataBufferSize) % IperlHead.EndOptoDataCount; + } + } + + public void WriteBinary(BinaryWriter writer) + { + writer.Write(Disabled); + writer.Write(CommFailed); + writer.Write(ResultCode); + writer.Write(PositiveCounting); + + if (ConfigStruct != null) + { + writer.Write(true); + ConfigStruct.WriteBinary(writer); + } + else writer.Write(false); + + if (CalibrationStruct != null) + { + writer.Write(true); + CalibrationStruct.WriteBinary(writer); + } + else writer.Write(false); + + if (CalibrationStructV4 != null) + { + writer.Write(true); + CalibrationStructV4.WriteBinary(writer); + } + else writer.Write(false); + + writer.Write(OrigCalibFactor); + writer.Write(OrigCalibFactorLNA); + writer.Write(Q2ErrWOCorrection); + writer.Write(Q2CorrRL); + writer.Write(Q2CorrLR); + writer.Write(Diff2Hz8Hz); + writer.Write(Hz2CorrectionDone); + writer.Write(Hz2Correction); + + if (LastTestResult != null) + { + writer.Write(true); + LastTestResult.WriteBinary(writer); + } + else writer.Write(false); + + if (LastTestResult2 != null) + { + writer.Write(true); + LastTestResult2.WriteBinary(writer); + } + else writer.Write(false); + } + + public void ReadBinary(BinaryReader reader) + { + Disabled = reader.ReadBoolean(); + CommFailed = reader.ReadBoolean(); + ResultCode = reader.ReadInt32(); + PositiveCounting = reader.ReadBoolean(); + + if (reader.ReadBoolean()) (ConfigStruct = new ConfigStruct()).ReadBinary(reader); + if (reader.ReadBoolean()) (CalibrationStruct = new CalibrationStruct()).ReadBinary(reader); + if (reader.ReadBoolean()) (CalibrationStructV4 = new CalibrationStructV4()).ReadBinary(reader); + + OrigCalibFactor = reader.ReadUInt16(); + OrigCalibFactorLNA = reader.ReadUInt16(); + Q2ErrWOCorrection = reader.ReadDouble(); + Q2CorrRL = reader.ReadInt32(); + Q2CorrLR = reader.ReadInt32(); + Diff2Hz8Hz = reader.ReadDouble(); + Hz2CorrectionDone = reader.ReadBoolean(); + Hz2Correction = reader.ReadInt32(); + + if (reader.ReadBoolean()) (LastTestResult = new Results.Entities.MeterTestRslt()).ReadBinary(reader, null); + if (reader.ReadBoolean()) (LastTestResult2 = new Results.Entities.MeterTestRslt()).ReadBinary(reader, null); + } + + internal void ResetNfcInterface(bool? nfc_on = null) + { + if (_iPerlCfg.HeadCommunicationComPortNr == 0) return; + + SERIAL_Driver _SERIAL_Driver_Head_Config = new SERIAL_Driver(); + _SERIAL_Driver_Head_Config.OpenConnection($"COM{_iPerlCfg.HeadCommunicationComPortNr}", 9600, 8, Parity.None, StopBits.One); + + NFCHeadConfig _NFCHead_Config = new NFCHeadConfig(_SERIAL_Driver_Head_Config); + if (nfc_on == null || nfc_on == false) _NFCHead_Config.NFCHeadConfig_SetInterface(false); // set RFID interface + if (nfc_on == null || nfc_on == true ) _NFCHead_Config.NFCHeadConfig_SetInterface(true); // set NFC interface + _SERIAL_Driver_Head_Config.Close(); + _SERIAL_Driver_Head_Config.Dispose(); + } + + internal void SetNfcInterface() + { + ResetNfcInterface(true); + } + + internal void SetRfidInterface() + { + ResetNfcInterface(false); + } + + internal void SetCommunicationInterface(CommunicationInterface commInterface) + { + //using (ISession session = TBF.DB.ConfigDBSessionFactory.OpenSession()) + // Replace the problematic line with the following code to fix the error: + using (ISession session = TBF.DB.SessionFactories[(int)DBKind.Config].OpenSession()) + using (ITransaction tx = session.BeginTransaction()) + { + try + { + var cmpntEntities = session.QueryOver() + .OrderBy(x => x.ItemNr).Asc + .List(); + var cmpnt = cmpntEntities.Where(x => x.Name == Name).First(); + if (cmpnt != null) + { + XDocument doc = XDocument.Parse(cmpnt.Parameters); + if (doc != null) + { + XElement element = doc.Root.Element("CommunicationInterface"); + if (element != null) + { + element.Value = commInterface.ToString(); + cmpnt.Parameters = doc.ToString(); + session.SaveOrUpdate(cmpnt); + tx.Commit(); + log.FatalFormat($"Set CommunicationInterface {Name} to {commInterface.ToString()}"); + } + } + } + } + catch (Exception ex) + { + if (tx != null) tx.Rollback(); + log.FatalFormat($"Set CommunicationInterface {Name} error: {ex.Message}"); + } + } + } + + /// + public OptoHeadState CheckFlowDirection() + { + return (flowDirectionDetection != null) ? flowDirectionDetection.CheckFlowDirection(currentFlowDir, Name) : OptoHeadState.DirNok; + } + /// + public void ChangeFlowDirection() + { + switch (InitFlowDir) + { + case Counting.Positive: + currentFlowDir = Counting.Negative; + break; + + case Counting.Negative: + currentFlowDir = Counting.Positive; + break; + + case Counting.Arbitrary: + default: + currentFlowDir = Counting.Arbitrary; + break; + } + + if (flowDirectionDetection != null) flowDirectionDetection.ClearFifo(); /// Clear FIFO for flow direction detection + } + + /// + /// Clear data/counters related to a specific tests + /// + public void Clear() + { + ResultCode = 0; + + volumeLtr = 0; + volumeLtr0 = 0; + timestampSec = 0; + timestampSec0 = 0; + + extraDataPath = null; + + /// Clear the feature vector + for (int i = 0; i < FeatureVectorSize; i++) + { + x[i] = 0; + } + } + + public void TestCompleted() + { + /// TODO: Implement + } + + } +} \ No newline at end of file diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.Designer.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.Designer.cs new file mode 100644 index 000000000..442547a0b --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.Designer.cs @@ -0,0 +1,137 @@ +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI +{ + partial class IperlHeadTestCtrl + { + /// + /// 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 Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.optoTestGroupBox = new System.Windows.Forms.GroupBox(); + this.optoListBox = new System.Windows.Forms.ListBox(); + this.rfidOutputListBox = new System.Windows.Forms.ListBox(); + this.RfidTestGroupBox = new System.Windows.Forms.GroupBox(); + this.label2 = new System.Windows.Forms.Label(); + this.rfidCommandComboBox = new System.Windows.Forms.ComboBox(); + this.commandTestButton = new System.Windows.Forms.Button(); + this.optoTestGroupBox.SuspendLayout(); + this.RfidTestGroupBox.SuspendLayout(); + this.SuspendLayout(); + // + // optoTestGroupBox + // + this.optoTestGroupBox.Controls.Add(this.optoListBox); + this.optoTestGroupBox.Location = new System.Drawing.Point(5, 4); + this.optoTestGroupBox.Name = "optoTestGroupBox"; + this.optoTestGroupBox.Size = new System.Drawing.Size(591, 161); + this.optoTestGroupBox.TabIndex = 2; + this.optoTestGroupBox.TabStop = false; + this.optoTestGroupBox.Text = "Opto-data"; + // + // optoListBox + // + this.optoListBox.FormattingEnabled = true; + this.optoListBox.ItemHeight = 16; + this.optoListBox.Location = new System.Drawing.Point(7, 22); + this.optoListBox.Name = "optoListBox"; + this.optoListBox.Size = new System.Drawing.Size(573, 132); + this.optoListBox.TabIndex = 0; + // + // rfidOutputListBox + // + this.rfidOutputListBox.FormattingEnabled = true; + this.rfidOutputListBox.ItemHeight = 16; + this.rfidOutputListBox.Location = new System.Drawing.Point(5, 54); + this.rfidOutputListBox.Name = "rfidOutputListBox"; + this.rfidOutputListBox.SelectionMode = System.Windows.Forms.SelectionMode.None; + this.rfidOutputListBox.Size = new System.Drawing.Size(575, 164); + this.rfidOutputListBox.TabIndex = 3; + // + // RfidTestGroupBox + // + this.RfidTestGroupBox.Controls.Add(this.rfidOutputListBox); + this.RfidTestGroupBox.Controls.Add(this.label2); + this.RfidTestGroupBox.Controls.Add(this.rfidCommandComboBox); + this.RfidTestGroupBox.Controls.Add(this.commandTestButton); + this.RfidTestGroupBox.Location = new System.Drawing.Point(5, 171); + this.RfidTestGroupBox.Name = "RfidTestGroupBox"; + this.RfidTestGroupBox.Size = new System.Drawing.Size(591, 224); + this.RfidTestGroupBox.TabIndex = 3; + this.RfidTestGroupBox.TabStop = false; + this.RfidTestGroupBox.Text = "RFID / NFC data"; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(2, 25); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(69, 16); + this.label2.TabIndex = 2; + this.label2.Text = "Command"; + // + // rfidCommandComboBox + // + this.rfidCommandComboBox.FormattingEnabled = true; + this.rfidCommandComboBox.Location = new System.Drawing.Point(86, 19); + this.rfidCommandComboBox.Name = "rfidCommandComboBox"; + this.rfidCommandComboBox.Size = new System.Drawing.Size(341, 24); + this.rfidCommandComboBox.TabIndex = 1; + // + // commandTestButton + // + this.commandTestButton.Location = new System.Drawing.Point(449, 19); + this.commandTestButton.Name = "commandTestButton"; + this.commandTestButton.Size = new System.Drawing.Size(126, 24); + this.commandTestButton.TabIndex = 0; + this.commandTestButton.Text = "Send command"; + this.commandTestButton.UseVisualStyleBackColor = true; + this.commandTestButton.MouseClick += new System.Windows.Forms.MouseEventHandler(this.CommandTestButtonClick); + // + // IperlHeadTestCtrl + // + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 16F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.optoTestGroupBox); + this.Controls.Add(this.RfidTestGroupBox); + this.Name = "IperlHeadTestCtrl"; + this.Size = new System.Drawing.Size(611, 432); + this.Load += new System.EventHandler(this.UserControl_Load); + this.optoTestGroupBox.ResumeLayout(false); + this.RfidTestGroupBox.ResumeLayout(false); + this.RfidTestGroupBox.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.GroupBox optoTestGroupBox; + private System.Windows.Forms.ListBox rfidOutputListBox; + private System.Windows.Forms.GroupBox RfidTestGroupBox; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.ComboBox rfidCommandComboBox; + private System.Windows.Forms.Button commandTestButton; + private System.Windows.Forms.ListBox optoListBox; + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.cs new file mode 100644 index 000000000..1fa55e9ae --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.cs @@ -0,0 +1,192 @@ +using System; +using System.Threading; +using System.Web.UI.WebControls; +using System.Windows.Forms; +using TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication; +using TBF.Rig.Sequences; +using TBF.Rig.TestMethods.iPerlCommunication; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI +{ + public partial class IperlHeadTestCtrl : UserControl + { + IPerlCfg config; + IPerlReader _iPerlReader; + Thread optoThread; + + private bool stopWorkerThread; + public event EventHandler OptoReceivedHandler; + + public IperlHeadTestCtrl(IPerlCfg config) + { + this.config = config; + InitializeComponent(); + if (config == null) return; + + //TODO fix possibility set test method in config + //iPerlCommunicationForm.cfg = new TestMethodCfg(null); // default values for iPerlCommunication + + foreach(var head in ProcessData.IperlHeads) + { + if (head != null && head.Name == config.Name) { _iPerlReader = head; } + } + + rfidCommandComboBox.DisplayMember = "Name"; + rfidCommandComboBox.ValueMember = "Value"; + var items = new[] + { + new {Name = "Read PCB", Value = "ReadPCB" }, + new {Name = "Set Test Mode", Value = "SetTestMode" }, + new {Name = "Set Active Mode", Value = "SetActiveMode" }, +#if DEBUG + new {Name = "Start Read Opto Data", Value = "ReadOptoData" }, + new {Name = "Stop Read Opto Data", Value = "StopReadOptoData" }, +#endif + new {Name = " ", Value = "" }, + new {Name = "Reset NFC Head", Value = "ResetNfcHead" }, + new {Name = "Set NFC Head Interface", Value = "SetNfcHead" }, + new {Name = "Set RFID Head interface", Value = "SetRfidHead" } + }; + /* + // CTRL+ALT+double click - hidden poweruser menu + if (((Keyboard.ModifierKeys & Keys.Control) == Keys.Control) && ((Keyboard.ModifierKeys & Keys.Alt) == Keys.Alt) && Users.CurrentUser.AuthorizedAs == AuthorizedAs.PowerUser) + { + Array.Resize(ref items, items.Length + 1); + items[items.Length - 1] = new { Name = "Kluc", Value = "Kluc" }; + } + */ + rfidCommandComboBox.DataSource = items; + + stopWorkerThread = false; + + OptoReceivedHandler += (EventHandler)((sndr, args) => + { + if (this.InvokeRequired) + this.Invoke((Delegate)new EventHandler(this.OnOptoReceived2), sndr, (object)args); + else + this.OnOptoReceived2(sndr, args); + }); + } + + public void OnOptoReceived2(object sender, OptoReceivedEventArgs args) + { + optoListBox.Items.Insert(0,args.Data); + } + + private void CommandTestButtonClick(object sender, MouseEventArgs e) + { + rfidOutputListBox.Items.Clear(); + + using (Tools.LogChecker logChecker = new Tools.LogChecker("RfidData", log4net.Core.Level.Debug)) + { + ListItem rfidListItem = new ListItem(); + rfidListItem.Attributes.Add("style", "font-weight:bold"); + switch (rfidCommandComboBox.SelectedValue) + { + case "ReadPCB": + rfidListItem.Text = $"PCB: {OpticalHeadTest.ReadRequest_PCB(_iPerlReader)}"; + break; + case "SetTestMode": + rfidListItem.Text = OpticalHeadTest.SetTestMode(_iPerlReader); + optoListBox.Items.Clear(); + stopWorkerThread = false; + optoThread = new Thread(OptoWorker); + if (!optoThread.IsAlive) + { + _iPerlReader.StartDataStreamProcessing(); // open opto port + optoThread.Start(); + } + break; + case "SetActiveMode": + rfidListItem.Text = OpticalHeadTest.SetActiveMode(_iPerlReader); + stopWorkerThread = true; + _iPerlReader.StopDataStreamProcessing(); // close opto port + break; + case "ResetNfcHead": + _iPerlReader.ResetNfcInterface(); + break; + case "SetNfcHead": + _iPerlReader.SetNfcInterface(); + break; + case "SetRfidHead": + _iPerlReader.SetRfidInterface(); + break; + case "ReadOptoData": + optoListBox.Items.Clear(); + stopWorkerThread = false; + optoThread = new Thread(OptoWorker); + if (optoThread.IsAlive) + { + stopWorkerThread = true; + _iPerlReader.StopDataStreamProcessing(); // close opto port + } + if (!optoThread.IsAlive) + { + _iPerlReader.StartDataStreamProcessing(); // open opto port + optoThread.Start(); + } + break; + case "StopReadOptoData": + stopWorkerThread = true; + _iPerlReader.StopDataStreamProcessing(); // close opto port + break; + } + rfidOutputListBox.Items.Add(rfidListItem); + rfidOutputListBox.Items.AddRange(logChecker.Messages.ToArray()); + } + } + + private void OptoWorker() + { + while (!this.stopWorkerThread) + { + Thread.Sleep(250); + if (this.stopWorkerThread) + break; + + try + { + string buffer = _iPerlReader.ReadOptoData(); + if (string.IsNullOrEmpty(buffer)) + { + this.OnOptoReceived((object)this, new OptoReceivedEventArgs(".")); + } + else + OnOptoReceived((object)this, new OptoReceivedEventArgs(buffer)); + } + catch (Exception ex) + { + this.OnOptoReceived((object)this, new OptoReceivedEventArgs(ex.Message)); + } + } + } + + public void OnOptoReceived(object sender, OptoReceivedEventArgs args) + { + if (this.OptoReceivedHandler == null) + return; + try + { + this.OptoReceivedHandler(sender, args); + } + catch (Exception ex) + { + } + } + + private void UserControl_Load(object sender, EventArgs e) + { + this.ParentForm.FormClosing += new FormClosingEventHandler(ParentForm_FormClosing); + } + + void ParentForm_FormClosing(object sender, FormClosingEventArgs e) + { + //OnHandleDestroyed(new EventArgs()); + stopWorkerThread = true; + if (optoThread != null) + { + optoThread.Abort(); + } + } + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.resx b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.resx new file mode 100644 index 000000000..d58980a38 --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/IperlHeadTestCtrl.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + \ No newline at end of file diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/ProcParams.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/ProcParams.cs new file mode 100644 index 000000000..649b2b2bd --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/ProcParams.cs @@ -0,0 +1,184 @@ +using System.Collections.Generic; +using System.IO; +using System.Xml.Serialization; +using Common; +using Config.Entities; +using TBF.Rig.Generic; +using TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI +{ + public class ProcParams : ProcedureParamsBase, IParamsProvider, IProcedureParams + { + + public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(ProcParams) })[0]; + public override XmlSerializer GetSerializer() { return Serializer; } + + public int WMType_ID; + public MeterType MeterType; + public float CalibTarget; /// Target error after calibration in [%] + public int FactorLimitLo; /// Lower limit for the calibration factor + public int FactorLimitHi; /// Upper limit for the calibration factor + public Counting Counting; /// Initial iPerl counting (Artbitrary, Positive or Negative) + + + public override void InitializeAll() + { + MeterType = MeterType.AutoDetect; + CalibTarget = 0; + FactorLimitLo = 1000; + FactorLimitHi = 8000; + Counting = Counting.Arbitrary; + } + + string[] paramNames = new string[] + { + "iPerl type", + "Calib. target [%]", + "Calib. factor Lo", + "Calib. factor Hi", + "Counting", + }; + public override string ParamName(int i) { return paramNames[i]; } + public override int ParamsCount() { return paramNames.Length; } + + public override ICollection ParamValues(int i) + { + if (i == 0) + { + var retVal = new List(); + for (MeterType mt = 0; mt < MeterType.Count; mt++) retVal.Add(mt.ToString()); + return retVal; + } + else if (i == 5) + { + var retVal = new List(); + for (Counting c = 0; c < Counting.Count; c++) retVal.Add(c.ToString()); + return retVal; + } + return null; + } + + public override string ToString(int i) + { + switch (i) + { + case 0: return MeterType.ToString(); + case 1: return CalibTarget.ToString(); + case 2: return FactorLimitLo.ToString(); + case 3: return FactorLimitHi.ToString(); + case 4: return Counting.ToString(); + default: return string.Empty; + } + } + + + //implement IParamsProvider + public bool ValidateParam(int i, string strValue, out string message) + { + message = string.Empty; + + int iDummy; + float fDummy; + + switch (i) + { + case 0: + for (MeterType mt = 0; mt < MeterType.Count; mt++) if (mt.ToString().Equals(strValue)) return true; + break; + case 1: + if (Utils.TryParseSFloat(strValue, out fDummy) && fDummy >= -10.0f && fDummy <= 10.0f) return true; + break; + case 2: + case 3: + if (int.TryParse(strValue, out iDummy) && iDummy >= 1000 && iDummy <= 8000) return true; + break; + case 4: + for (Counting c = 0; c < Counting.Count; c++) if (c.ToString().Equals(strValue)) return true; + break; + default: + message = "Invalid index"; + return false; + } + + message = ParamName(i) + " is invalid"; + return false; + } + + public CfgUpdateFlags UpdateParam(int i, string strValue) + { + switch (i) + { + case 0: + for (MeterType mt = 0; mt < MeterType.Count; mt++) + { + if (mt.ToString().Equals(strValue)) { MeterType = mt; return CfgUpdateFlags.None; } + } + break; + case 1: CalibTarget = Utils.ParseSFloat(strValue); return CfgUpdateFlags.None; + case 2: FactorLimitLo = int.Parse(strValue); return CfgUpdateFlags.None; + case 3: FactorLimitHi = int.Parse(strValue); return CfgUpdateFlags.None; + case 4: + for (Counting c = 0; c < Counting.Count; c++) + { + if (c.ToString().Equals(strValue)) { Counting = c; return CfgUpdateFlags.None; } + } + break; + default: return CfgUpdateFlags.None; + } + + return CfgUpdateFlags.None; + } + + void CopyContentTo(ProcParams prms) + { + prms.MeterType = this.MeterType; + prms.CalibTarget = this.CalibTarget; + prms.FactorLimitLo = this.FactorLimitLo; + prms.FactorLimitHi = this.FactorLimitHi; + prms.Counting = this.Counting; + } + + public IParamsProvider Clone() + { + ProcParams pars = new ProcParams(); + CopyContentTo(pars); + return pars; + } + + public override void UpdateFromDbEntity(ComponentProcedure dbEntity) + { + if (dbEntity == null) return; + try + { + ProcParams tmp = Serializer.Deserialize(new StringReader(dbEntity.Parameters)) as ProcParams; + + procedureParamsEntity = dbEntity; + componentName = dbEntity.CmpntName; + procedure = dbEntity.Procedure; + + if (tmp != null) tmp.CopyContentTo(this); + } + catch + { + } + } + + + public ProcParams() + { + } + + public ProcParams(bool initialize) + { + if (initialize) InitializeAll(); + } + + public ProcParams(ComponentProcedure procParamsEntity, string componentName, Procedure procedure) + { + this.procedureParamsEntity = procParamsEntity; + this.componentName = componentName; + this.procedure = procedure; + } + } +} \ No newline at end of file diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/CalibrationStruct.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/CalibrationStruct.cs new file mode 100644 index 000000000..d4aecc544 --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/CalibrationStruct.cs @@ -0,0 +1,242 @@ +/// +/// Copyright (c) 2015-2020 Sensus Metering Systems +/// +using System; +using System.IO; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication +{ + public class CalibrationStruct + { + public const int Length = 35; + + public Byte Version; + public MeterType MeterType; + public UInt16 Calibration; + public VolumeUnits VolumeUnits; + public FlowArrow FlowArrow; + public UInt16 FWVersion; + public UInt16[] TargetField; + public UInt16 RecipMeanCurrent; + public UInt16 ThresholdVolume; + public UInt16 ThresholdTime; + public UInt16 FlowActivationThr; + public UInt16 VolumeArrowThr; + public UInt32 CalibrationTime; + public ulong SerialNumber; + public MeterSealed MeterSealed; + public byte CheckSum; + + + public CalibrationStruct() + { + TargetField = new UInt16[3]; + } + + public byte[] ToByteArray() + { + byte[] result = new byte[Length]; + + result[0] = Version; + result[1] = (byte)MeterType; + + result[2] = (byte)(Calibration & 0x00FF); + result[3] = (byte)((Calibration >> 8) & 0x00FF); + + result[4] = (byte)VolumeUnits; + + result[5] = (byte)FlowArrow; + + result[6] = (byte)(FWVersion & 0x00FF); + result[7] = (byte)((FWVersion >> 8) & 0x00FF); + + result[8] = (byte)( TargetField[0] & 0x00FF); + result[9] = (byte)((TargetField[0] >> 8) & 0x00FF); + result[10] = (byte)( TargetField[1] & 0x00FF); + result[11] = (byte)((TargetField[1] >> 8) & 0x00FF); + result[12] = (byte)( TargetField[2] & 0x00FF); + result[13] = (byte)((TargetField[2] >> 8) & 0x00FF); + + result[14] = (byte)(RecipMeanCurrent & 0x00FF); + result[15] = (byte)((RecipMeanCurrent >> 8) & 0x00FF); + + result[16] = (byte)(ThresholdVolume & 0x00FF); + result[17] = (byte)((ThresholdVolume >> 8) & 0x00FF); + + result[18] = (byte)(ThresholdTime & 0x00FF); + result[19] = (byte)((ThresholdTime >> 8) & 0x00FF); + + result[20] = (byte)(FlowActivationThr & 0x00FF); + result[21] = (byte)((FlowActivationThr >> 8) & 0x00FF); + + result[22] = (byte)(VolumeArrowThr & 0x00FF); + result[23] = (byte)((VolumeArrowThr >> 8) & 0x00FF); + + result[24] = (byte)(CalibrationTime & 0x000000FF); + result[25] = (byte)((CalibrationTime >> 8) & 0x000000FF); + result[26] = (byte)((CalibrationTime >> 16) & 0x000000FF); + result[27] = (byte)((CalibrationTime >> 24) & 0x000000FF); + + result[28] = (byte)(SerialNumber & 0x00000000000000FF); + result[29] = (byte)((SerialNumber >> 8) & 0x00000000000000FF); + result[30] = (byte)((SerialNumber >> 16) & 0x00000000000000FF); + result[31] = (byte)((SerialNumber >> 24) & 0x00000000000000FF); + result[32] = (byte)((SerialNumber >> 32) & 0x00000000000000FF); + + result[33] = (byte)MeterSealed; + result[34] = CheckSum; + + return result; + } + + /// + /// Create a calibration structure from a complete byte array + /// + /// A complete byte array data + /// CalibrationStruct or null when byte array was not complete + public static CalibrationStruct FromByteArray(byte[] data) + { + if (data.Length != Length) return null; + + CalibrationStruct result = new CalibrationStruct(); + + result.Version = data[0]; + result.MeterType = (MeterType)data[1]; + result.Calibration = (UInt16)(data[2] + 256 * data[3]); + result.VolumeUnits = (VolumeUnits)data[4]; + result.FlowArrow = (FlowArrow)data[5]; + result.FWVersion = (UInt16)(data[6] + 256 * data[7]); + result.TargetField[0] = (UInt16)(data[8] + 256 * data[9]); + result.TargetField[1] = (UInt16)(data[10] + 256 * data[11]); + result.TargetField[2] = (UInt16)(data[12] + 256 * data[13]); + result.RecipMeanCurrent = (UInt16)(data[14] + 256 * data[15]); + result.ThresholdVolume = (UInt16)(data[16] + 256 * data[17]); + result.ThresholdTime = (UInt16)(data[18] + 256 * data[19]); + result.FlowActivationThr = (UInt16)(data[20] + 256 * data[21]); + result.VolumeArrowThr = (UInt16)(data[22] + 256 * data[23]); + result.CalibrationTime = (((UInt32)data[27] * 256 + data[26]) * 256 + data[25]) * 256 + data[24]; + result.SerialNumber = ((((UInt64)data[32] * 256 + data[31]) * 256 + data[30]) * 256 + data[29]) * 256 + data[28]; + result.MeterSealed = (MeterSealed)data[33]; + result.CheckSum = data[34]; + + return result; + } + + /// + /// Update the calibration structure from an incomplete byte array + /// + /// Byte array data + /// Offset of byte array data in CalibrationStruct + /// true when successful, false when data are not appropriate + public bool Update(byte[] data, int offset) + { + if ((data.Length == 2) && (offset == 2)) + { + /// Data containing iPerl calibration factor + Calibration = (UInt16)(data[0] + 256 * data[1]); + return true; + } + else if ((data.Length == Length) && (offset == 0)) + { + /// Data containing a complete CalibrationStruct + Version = data[0]; + MeterType = (MeterType)data[1]; + Calibration = (UInt16)(data[2] + 256 * data[3]); + VolumeUnits = (VolumeUnits)data[4]; + FlowArrow = (FlowArrow)data[5]; + FWVersion = (UInt16)(data[6] + 256 * data[7]); + TargetField[0] = (UInt16)(data[8] + 256 * data[9]); + TargetField[1] = (UInt16)(data[10] + 256 * data[11]); + TargetField[2] = (UInt16)(data[12] + 256 * data[13]); + RecipMeanCurrent = (UInt16)(data[14] + 256 * data[15]); + ThresholdVolume = (UInt16)(data[16] + 256 * data[17]); + ThresholdTime = (UInt16)(data[18] + 256 * data[19]); + FlowActivationThr = (UInt16)(data[20] + 256 * data[21]); + VolumeArrowThr = (UInt16)(data[22] + 256 * data[23]); + CalibrationTime = (((UInt32)data[27] * 256 + data[26]) * 256 + data[25]) * 256 + data[24]; + SerialNumber = ((((UInt64)data[32] * 256 + data[31]) * 256 + data[30]) * 256 + data[29]) * 256 + data[28]; + MeterSealed = (MeterSealed)data[33]; + CheckSum = data[34]; + return true; + } + else + return false; + } + + public string FWVersionStr() + { + int d1 = (FWVersion >> 8) & 0x000F; + int d2 = (FWVersion >> 12) & 0x000F; + int d3 = (FWVersion >> 4) & 0x000F; + int d4 = FWVersion & 0x000F; + return string.Format("{0}.{1}{2}{3}", d1, d2, d3, d4); + } + + public override string ToString() + { + return string.Format("Calibration: V{0} Type={1} Cal={2} Units={3} FlowArrow.{4} FW={5} Hi={6} Norm={7} Low={8} RMC={9} ThrVol={10} ThrTime={11} FlActThr={12} VolArrThr={13} CalTm={14} SN={15} MeterSealed={16} Chksum={17}", + Version, + MeterType, + Calibration, + VolumeUnits, + FlowArrow, + FWVersion, + TargetField[0], + TargetField[1], + TargetField[2], + RecipMeanCurrent, + ThresholdVolume, + ThresholdTime, + FlowActivationThr, + VolumeArrowThr, + CalibrationTime, + SerialNumber, + MeterSealed, + CheckSum.ToString("X2")); + } + + public virtual void WriteBinary(BinaryWriter writer) + { + writer.Write(Version); + writer.Write((byte)MeterType); + writer.Write(Calibration); + writer.Write((byte)VolumeUnits); + writer.Write((byte)FlowArrow); + writer.Write(FWVersion); + writer.Write(TargetField[0]); + writer.Write(TargetField[1]); + writer.Write(TargetField[2]); + writer.Write(RecipMeanCurrent); + writer.Write(ThresholdVolume); + writer.Write(ThresholdTime); + writer.Write(FlowActivationThr); + writer.Write(VolumeArrowThr); + writer.Write(CalibrationTime); + writer.Write(SerialNumber); + writer.Write((byte)MeterSealed); + writer.Write(CheckSum); + } + + public virtual void ReadBinary(BinaryReader reader) + { + Version = reader.ReadByte(); + MeterType = (MeterType)reader.ReadByte(); + Calibration = reader.ReadUInt16(); + VolumeUnits = (VolumeUnits)reader.ReadByte(); + FlowArrow = (FlowArrow)reader.ReadByte(); + FWVersion = reader.ReadUInt16(); + TargetField[0] = reader.ReadUInt16(); + TargetField[1] = reader.ReadUInt16(); + TargetField[2] = reader.ReadUInt16(); + RecipMeanCurrent = reader.ReadUInt16(); + ThresholdVolume = reader.ReadUInt16(); + ThresholdTime = reader.ReadUInt16(); + FlowActivationThr = reader.ReadUInt16(); + VolumeArrowThr = reader.ReadUInt16(); + CalibrationTime = reader.ReadUInt32(); + SerialNumber = reader.ReadUInt64(); + MeterSealed = (MeterSealed)reader.ReadByte(); + CheckSum = reader.ReadByte(); + } + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/CalibrationStructV4.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/CalibrationStructV4.cs new file mode 100644 index 000000000..d66f0493f --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/CalibrationStructV4.cs @@ -0,0 +1,258 @@ +/// +/// Copyright (c) 2018-2020 Sensus Slovensko a.s. +/// +using System; +using System.IO; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication +{ + public class CalibrationStructV4 + { + public const int Length = 37; + + public Byte Version; + public MeterType MeterType; + public UInt16 Calibration; + public VolumeUnits VolumeUnits; + public FlowArrow FlowArrow; + public UInt16 FWVersion; + public UInt16[] TargetField; + public UInt16 RecipMeanCurrent; + public UInt16 ThresholdVolume; + public UInt16 ThresholdTime; + public UInt16 FlowActivationThr; + public UInt16 VolumeArrowThr; + public UInt32 CalibrationTime; + public ulong SerialNumber; + public MeterSealed MeterSealed; + public UInt16 CalibrationLNA; + public byte CheckSum; + + + public CalibrationStructV4() + { + TargetField = new UInt16[3]; + } + + public byte[] ToByteArray() + { + byte[] result = new byte[Length]; + + result[0] = Version; + result[1] = (byte)MeterType; + + result[2] = (byte)(Calibration & 0x00FF); + result[3] = (byte)((Calibration >> 8) & 0x00FF); + + result[4] = (byte)VolumeUnits; + + result[5] = (byte)FlowArrow; + + result[6] = (byte)(FWVersion & 0x00FF); + result[7] = (byte)((FWVersion >> 8) & 0x00FF); + + result[8] = (byte)( TargetField[0] & 0x00FF); + result[9] = (byte)((TargetField[0] >> 8) & 0x00FF); + result[10] = (byte)( TargetField[1] & 0x00FF); + result[11] = (byte)((TargetField[1] >> 8) & 0x00FF); + result[12] = (byte)( TargetField[2] & 0x00FF); + result[13] = (byte)((TargetField[2] >> 8) & 0x00FF); + + result[14] = (byte)(RecipMeanCurrent & 0x00FF); + result[15] = (byte)((RecipMeanCurrent >> 8) & 0x00FF); + + result[16] = (byte)(ThresholdVolume & 0x00FF); + result[17] = (byte)((ThresholdVolume >> 8) & 0x00FF); + + result[18] = (byte)(ThresholdTime & 0x00FF); + result[19] = (byte)((ThresholdTime >> 8) & 0x00FF); + + result[20] = (byte)(FlowActivationThr & 0x00FF); + result[21] = (byte)((FlowActivationThr >> 8) & 0x00FF); + + result[22] = (byte)(VolumeArrowThr & 0x00FF); + result[23] = (byte)((VolumeArrowThr >> 8) & 0x00FF); + + result[24] = (byte)(CalibrationTime & 0x000000FF); + result[25] = (byte)((CalibrationTime >> 8) & 0x000000FF); + result[26] = (byte)((CalibrationTime >> 16) & 0x000000FF); + result[27] = (byte)((CalibrationTime >> 24) & 0x000000FF); + + result[28] = (byte)(SerialNumber & 0x00000000000000FF); + result[29] = (byte)((SerialNumber >> 8) & 0x00000000000000FF); + result[30] = (byte)((SerialNumber >> 16) & 0x00000000000000FF); + result[31] = (byte)((SerialNumber >> 24) & 0x00000000000000FF); + result[32] = (byte)((SerialNumber >> 32) & 0x00000000000000FF); + + result[33] = (byte)MeterSealed; + + result[34] = (byte)(CalibrationLNA & 0x00FF); + result[35] = (byte)((CalibrationLNA >> 8) & 0x00FF); + + result[36] = CheckSum; + + return result; + } + + /// + /// Create a calibration structure from a complete byte array + /// + /// A complete byte array data + /// CalibrationStructV4 or null when byte array was not complete + public static CalibrationStructV4 FromByteArray(byte[] data) + { + if (data.Length != Length) return null; + + CalibrationStructV4 result = new CalibrationStructV4(); + + result.Version = data[0]; + result.MeterType = (MeterType)data[1]; + result.Calibration = (UInt16)(data[2] + 256 * data[3]); + result.VolumeUnits = (VolumeUnits)data[4]; + result.FlowArrow = (FlowArrow)data[5]; + result.FWVersion = (UInt16)(data[6] + 256 * data[7]); + result.TargetField[0] = (UInt16)(data[8] + 256 * data[9]); + result.TargetField[1] = (UInt16)(data[10] + 256 * data[11]); + result.TargetField[2] = (UInt16)(data[12] + 256 * data[13]); + result.RecipMeanCurrent = (UInt16)(data[14] + 256 * data[15]); + result.ThresholdVolume = (UInt16)(data[16] + 256 * data[17]); + result.ThresholdTime = (UInt16)(data[18] + 256 * data[19]); + result.FlowActivationThr = (UInt16)(data[20] + 256 * data[21]); + result.VolumeArrowThr = (UInt16)(data[22] + 256 * data[23]); + result.CalibrationTime = (((UInt32)data[27] * 256 + data[26]) * 256 + data[25]) * 256 + data[24]; + result.SerialNumber = ((((UInt64)data[32] * 256 + data[31]) * 256 + data[30]) * 256 + data[29]) * 256 + data[28]; + result.MeterSealed = (MeterSealed)data[33]; + result.CalibrationLNA = (UInt16)(data[34] + 256 * data[35]); + result.CheckSum = data[36]; + + return result; + } + + /// + /// Update the calibration structure from an incomplete byte array + /// + /// Byte array data + /// Offset of byte array data in CalibrationStructV2 + /// true when successful, false when data are not appropriate + public bool Update(byte[] data, int offset) + { + if ((data.Length == 2) && (offset == 2)) + { + /// Data containing iPerl calibration factor + Calibration = (UInt16)(data[0] + 256 * data[1]); + return true; + } + else if ((data.Length == 2) && (offset == 34)) + { + /// Data containing iPerl calibration factor + CalibrationLNA = (UInt16)(data[0] + 256 * data[1]); + return true; + } + else if ((data.Length == Length) && (offset == 0)) + { + /// Data containing a complete CalibrationStruct + Version = data[0]; + MeterType = (MeterType)data[1]; + Calibration = (UInt16)(data[2] + 256 * data[3]); + VolumeUnits = (VolumeUnits)data[4]; + FlowArrow = (FlowArrow)data[5]; + FWVersion = (UInt16)(data[6] + 256 * data[7]); + TargetField[0] = (UInt16)(data[8] + 256 * data[9]); + TargetField[1] = (UInt16)(data[10] + 256 * data[11]); + TargetField[2] = (UInt16)(data[12] + 256 * data[13]); + RecipMeanCurrent = (UInt16)(data[14] + 256 * data[15]); + ThresholdVolume = (UInt16)(data[16] + 256 * data[17]); + ThresholdTime = (UInt16)(data[18] + 256 * data[19]); + FlowActivationThr = (UInt16)(data[20] + 256 * data[21]); + VolumeArrowThr = (UInt16)(data[22] + 256 * data[23]); + CalibrationTime = (((UInt32)data[27] * 256 + data[26]) * 256 + data[25]) * 256 + data[24]; + SerialNumber = ((((UInt64)data[32] * 256 + data[31]) * 256 + data[30]) * 256 + data[29]) * 256 + data[28]; + MeterSealed = (MeterSealed)data[33]; + CalibrationLNA = (UInt16)(data[34] + 256 * data[35]); + CheckSum = data[36]; + return true; + } + else + return false; + } + + public string FWVersionStr() + { + int d1 = (FWVersion >> 8) & 0x000F; + int d2 = (FWVersion >> 12) & 0x000F; + int d3 = (FWVersion >> 4) & 0x000F; + int d4 = FWVersion & 0x000F; + return string.Format("{0}.{1}{2}{3}", d1, d2, d3, d4); + } + + public override string ToString() + { + return string.Format("Calibration: V{0} Type={1} Cal={2} Units={3} FlowArrow.{4} FW={5} Hi={6} Norm={7} Low={8} RMC={9} ThrVol={10} ThrTime={11} FlActThr={12} VolArrThr={13} CalTm={14} SN={15} MeterSealed={16} CalLNA={17} Chksum={18}", + Version, + MeterType, + Calibration, + VolumeUnits, + FlowArrow, + FWVersion, + TargetField[0], + TargetField[1], + TargetField[2], + RecipMeanCurrent, + ThresholdVolume, + ThresholdTime, + FlowActivationThr, + VolumeArrowThr, + CalibrationTime, + SerialNumber, + MeterSealed, + CalibrationLNA, + CheckSum.ToString("X2")); + } + + public virtual void WriteBinary(BinaryWriter writer) + { + writer.Write(Version); + writer.Write((byte)MeterType); + writer.Write(Calibration); + writer.Write((byte)VolumeUnits); + writer.Write((byte)FlowArrow); + writer.Write(FWVersion); + writer.Write(TargetField[0]); + writer.Write(TargetField[1]); + writer.Write(TargetField[2]); + writer.Write(RecipMeanCurrent); + writer.Write(ThresholdVolume); + writer.Write(ThresholdTime); + writer.Write(FlowActivationThr); + writer.Write(VolumeArrowThr); + writer.Write(CalibrationTime); + writer.Write(SerialNumber); + writer.Write((byte)MeterSealed); + writer.Write(CalibrationLNA); + writer.Write(CheckSum); + } + + public virtual void ReadBinary(BinaryReader reader) + { + Version = reader.ReadByte(); + MeterType = (MeterType)reader.ReadByte(); + Calibration = reader.ReadUInt16(); + VolumeUnits = (VolumeUnits)reader.ReadByte(); + FlowArrow = (FlowArrow)reader.ReadByte(); + FWVersion = reader.ReadUInt16(); + TargetField[0] = reader.ReadUInt16(); + TargetField[1] = reader.ReadUInt16(); + TargetField[2] = reader.ReadUInt16(); + RecipMeanCurrent = reader.ReadUInt16(); + ThresholdVolume = reader.ReadUInt16(); + ThresholdTime = reader.ReadUInt16(); + FlowActivationThr = reader.ReadUInt16(); + VolumeArrowThr = reader.ReadUInt16(); + CalibrationTime = reader.ReadUInt32(); + SerialNumber = reader.ReadUInt64(); + MeterSealed = (MeterSealed)reader.ReadByte(); + CalibrationLNA = reader.ReadUInt16(); + CheckSum = reader.ReadByte(); + } + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/ConfigStruct.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/ConfigStruct.cs new file mode 100644 index 000000000..a7ca580e6 --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/ConfigStruct.cs @@ -0,0 +1,266 @@ +/// +/// Copyright (c) 2015-2020 Sensus Metering Systems +/// +using System; +using System.IO; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication +{ + public class ConfigStruct + { + public const int Length = 32; + + public Byte Version; /// 0: 1 byte + public MeterState MeterState; /// 1: 1 byte + public UInt32 TargetTimeVeryLowBatt; /// 2: 4 bytes in seconds + public UInt32 TargetTimeLowBatt; /// 6: 4 bytes, in seconds + public UInt32 TestModeTime; /// 10: 4 bytes, Max. test mode time in seconds + public UInt16 EmptyPipeThreshold; /// 14: 2 bytes + public byte[] PCBNumber; /// 16: 5 bytes + public byte TestModeConfig; /// 21: 1 byte + public UInt32 RadioAddress; /// 22: 4 bytes + public UInt16 TempCalibration; /// 26: 2 bytes + public UInt16 AlarmMask; /// 28: 2 bytes, Default 0xA3F7 + public UInt16 ConfigCheckSum; /// 30: 2 bytes + + public ConfigStruct() + { + PCBNumber = new byte[5]; + } + + public byte[] ToByteArray() + { + byte[] result = new byte[Length]; + + result[0] = Version; + result[1] = (byte)MeterState; + + result[2] = (byte)(TargetTimeVeryLowBatt & 0x000000FF); + result[3] = (byte)((TargetTimeVeryLowBatt >> 8) & 0x000000FF); + result[4] = (byte)((TargetTimeVeryLowBatt >> 16) & 0x000000FF); + result[5] = (byte)((TargetTimeVeryLowBatt >> 24) & 0x000000FF); + + result[6] = (byte)(TargetTimeLowBatt & 0x000000FF); + result[7] = (byte)((TargetTimeLowBatt >> 8) & 0x000000FF); + result[8] = (byte)((TargetTimeLowBatt >> 16) & 0x000000FF); + result[9] = (byte)((TargetTimeLowBatt >> 24) & 0x000000FF); + + result[10] = (byte)(TestModeTime & 0x000000FF); + result[11] = (byte)((TestModeTime >> 8) & 0x000000FF); + result[12] = (byte)((TestModeTime >> 16) & 0x000000FF); + result[13] = (byte)((TestModeTime >> 24) & 0x000000FF); + + result[14] = (byte)(EmptyPipeThreshold & 0x00FF); + result[15] = (byte)((EmptyPipeThreshold >> 8) & 0x00FF); + + result[16] = PCBNumber[0]; + result[17] = PCBNumber[1]; + result[18] = PCBNumber[2]; + result[19] = PCBNumber[3]; + result[20] = PCBNumber[4]; + + result[21] = TestModeConfig; + + result[22] = (byte)(RadioAddress & 0x000000FF); + result[23] = (byte)((RadioAddress >> 8) & 0x000000FF); + result[24] = (byte)((RadioAddress >> 16) & 0x000000FF); + result[25] = (byte)((RadioAddress >> 24) & 0x000000FF); + + result[26] = (byte)(TempCalibration & 0x00FF); + result[27] = (byte)((TempCalibration >> 8) & 0x00FF); + + result[28] = (byte)(AlarmMask & 0x00FF); + result[29] = (byte)((AlarmMask >> 8) & 0x00FF); + + result[30] = (byte)(ConfigCheckSum & 0x00FF); + result[31] = (byte)((ConfigCheckSum >> 8) & 0x00FF); + + return result; + } + + /// + /// Create a configuration structure from a complete byte array + /// + /// A complete byte array data + /// ConfigStruct or null when byte array was not complete + public static ConfigStruct FromByteArray(byte[] data) + { + if (data.Length != Length) return null; + + ConfigStruct result = new ConfigStruct(); + + result.Version = data[0]; + result.MeterState = (MeterState)data[1]; + result.TargetTimeVeryLowBatt = (((UInt32)data[5] * 256 + data[4]) * 256 + data[3]) * 256 + data[2]; + result.TargetTimeLowBatt = (((UInt32)data[9] * 256 + data[8]) * 256 + data[7]) * 256 + data[6]; + result.TestModeTime = (((UInt32)data[13] * 256 + data[12]) * 256 + data[11]) * 256 + data[10]; + result.EmptyPipeThreshold = (UInt16)(data[15] * 256 + data[14]); + result.PCBNumber[0] = data[16]; + result.PCBNumber[1] = data[17]; + result.PCBNumber[2] = data[18]; + result.PCBNumber[3] = data[19]; + result.PCBNumber[4] = data[20]; + result.TestModeConfig = data[21]; + result.RadioAddress = (((UInt32)data[25] * 256 + data[24]) * 256 + data[23]) * 256 + data[22]; + result.TempCalibration = (UInt16)(data[27] * 256 + data[26]); + result.AlarmMask = (UInt16)(data[29] * 256 + data[28]); + result.ConfigCheckSum = (UInt16)(data[31] * 256 + data[30]); + + return result; + } + + /// + /// Update the configuration structure from an incomplete byte array + /// + /// Offset of byte array data in ConfigStruct + /// Byte array data + /// true when successful, false when data are not appropriate + public bool Update(int offset, byte[] data) + { + if (offset == 0 && data.Length == 2) + { + /// iPerl mode of function + Version = data[0]; + MeterState = (MeterState)data[1]; + return true; + } + else if (offset == 0 && data.Length == 4) + { + /// iPerl mode of function and extra 2 bytes + Version = data[0]; + MeterState = (MeterState)data[1]; + return true; + } + else if (offset == 21 && data.Length == 1) + { + /// TestModeConfig value + TestModeConfig = data[21 - offset]; + return true; + } + else if (offset == 0 && data.Length == Length) + { + /// Complete ConfigStruct + Version = data[0]; + MeterState = (MeterState)data[1]; + TargetTimeVeryLowBatt = (((UInt32)data[5] * 256 + data[4]) * 256 + data[3]) * 256 + data[2]; + TargetTimeLowBatt = (((UInt32)data[9] * 256 + data[8]) * 256 + data[7]) * 256 + data[6]; + TestModeTime = (((UInt32)data[13] * 256 + data[12]) * 256 + data[11]) * 256 + data[10]; + EmptyPipeThreshold = (UInt16)(data[15] * 256 + data[14]); + PCBNumber[0] = data[16]; + PCBNumber[1] = data[17]; + PCBNumber[2] = data[18]; + PCBNumber[3] = data[19]; + PCBNumber[4] = data[20]; + TestModeConfig = data[21]; + RadioAddress = (((UInt32)data[25] * 256 + data[24]) * 256 + data[23]) * 256 + data[22]; + TempCalibration = (UInt16)(data[27] * 256 + data[26]); + AlarmMask = (UInt16)(data[29] * 256 + data[28]); + ConfigCheckSum = (UInt16)(data[31] * 256 + data[30]); + return true; + } + else + return false; + } + + /// + /// Returns PCB number string (12 characters, 12 decimal digits) + /// + /// PCB number STRING + public string GetPcbNrString() + { + return PCBNumber2String(this.PCBNumber); + } + + /// + /// Converts PCBNumber to string (12 characters, 12 decimal digits) + /// + /// + /// PCB number string + public static string PCBNumber2String(byte[] pcbNumber) + { + if (pcbNumber.Length != 5) return string.Empty; + + Int64 number = 0; + for (int i = 4; i >= 0; i--) + { + number = 256 * number + (Int64)pcbNumber[i]; + } + + return number.ToString(); + } + + public override string ToString() + { + return string.Format("Config: V{0} State={1} VLoBattT={2}s LoBattT={3}s TestModeT={4}s EPThld={5} PCB#={6} TMCfg={7} RadioAddr={8} TempCalib={9} AlarmMask={10} CfgCheckSum={11}", + Version, + MeterState, + TargetTimeVeryLowBatt, + TargetTimeLowBatt, + TestModeTime, + EmptyPipeThreshold, + GetPcbNrString(), + TestModeConfig.ToString("X2"), + RadioAddress, + TempCalibration, + AlarmMask.ToString("X4"), + ConfigCheckSum.ToString("X4")); + } + + public string ToString(int sel) + { + return string.Format("{1} PCB#={6} TMCfg={7}", + Version, + MeterState, + TargetTimeVeryLowBatt, + TargetTimeLowBatt, + TestModeTime, + EmptyPipeThreshold, + GetPcbNrString(), + TestModeConfig.ToString("X2"), + RadioAddress, + TempCalibration, + AlarmMask.ToString("X4"), + ConfigCheckSum.ToString("X4")); + } + + public virtual void WriteBinary(BinaryWriter writer) + { + writer.Write(Version); + writer.Write((byte)MeterState); + writer.Write(TargetTimeVeryLowBatt); + writer.Write(TargetTimeLowBatt); + writer.Write(TestModeTime); + writer.Write(EmptyPipeThreshold); + writer.Write(PCBNumber[0]); + writer.Write(PCBNumber[1]); + writer.Write(PCBNumber[2]); + writer.Write(PCBNumber[3]); + writer.Write(PCBNumber[4]); + writer.Write(TestModeConfig); + writer.Write(RadioAddress); + writer.Write(TempCalibration); + writer.Write(AlarmMask); + writer.Write(ConfigCheckSum); + } + + public virtual void ReadBinary(BinaryReader reader) + { + Version = reader.ReadByte(); + MeterState = (MeterState)reader.ReadByte(); + TargetTimeVeryLowBatt = reader.ReadUInt32(); + TargetTimeLowBatt = reader.ReadUInt32(); + TestModeTime = reader.ReadUInt32(); + EmptyPipeThreshold = reader.ReadUInt16(); + PCBNumber[0] = reader.ReadByte(); + PCBNumber[1] = reader.ReadByte(); + PCBNumber[2] = reader.ReadByte(); + PCBNumber[3] = reader.ReadByte(); + PCBNumber[4] = reader.ReadByte(); + TestModeConfig = reader.ReadByte(); + RadioAddress = reader.ReadUInt32(); + TempCalibration = reader.ReadUInt16(); + AlarmMask = reader.ReadUInt16(); + ConfigCheckSum = reader.ReadUInt16(); + } + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/Enums.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/Enums.cs new file mode 100644 index 000000000..060fcfeb0 --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/Enums.cs @@ -0,0 +1,113 @@ +/// +/// Copyright (c) 2015-2021 Sensus Metering Systems +/// +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication +{ + public enum MessageID + { + Calibration = 0x00, /// Access to stCalibration + Configuration = 0x01, /// Access to stConfig + Status = 0x02, /// Access to stStaus, read only + Power = 0x03, /// Access to stPower, containing power info from both processors + LCD = 0x04, /// Access to stLCD + EventData = 0x05, /// NOT USED + IntervalData = 0x06, /// NOT USED + Diagnostics = 0x07, /// Access tostMetroDiagArray, read onl + MetrologyMemory = 0x08, /// Memory block access, read only + Error_LongAck = 0x09, /// Error message + Command = 0x0A, /// Command to execute, with no arguments + Parameterizing = 0x0B, /// Parameterizing message is used in MCI-SPI interface only + Error_ShortAck = 0x0C, /// Short acknowledge message is used in MCI-SPI interface only + ChanelAlive = 0x0D, /// Channel alive message is used in MCI-SPI interface only + RadioPassthrough = 0x0E, /// RFID <-> Metrology <-> Radio passthrough message + ASICRegisterReadTest = 0x0F, /// ASIC Register read test + IMIDebugMessagesAccess = 0x10, /// IMI debug messages read test + ProductionChecksumsRead = 0x11, /// Production checksum read: Calibration (1 byte), Configuration (2 bytes), spare (4 bytes) + HardwareParametersTest = 0x12, /// Hardware Parameters Testing: User configurable fixed field drive time (1 byte) + /// + /// Notes: + /// 1. Short Ack message contains 1-byte error code and all the fields (Offset, Payload length, payload and password) will not be present. + /// 2. Channel Alive message does not contain the fields (Offset, Payload length, payload and password). + /// 3. Except the above two special messages, rest all the messages in the above table will follow the message format mentioned in sections 3.1 and 3.2. + /// + Count /// Number of MessageID-s + } + + public enum MeterType : byte + { + DN15 = 0, + CoaxManifold = 1, + DN20 = 2, + DN25 = 3, /// DN25 Q3 = 6.3 m3/h + DN25_Q3_10 = 4, /// DN25 Q3 = 10 m3/h + DN32 = 5, + DN40 = 6, + AutoDetect, + Count /// Number of meter types + } + + public enum VolumeUnits : byte + { + m3 = 0, + UK_gallon = 1, + US_gallon = 2, + Count /// Number of volume units + } + + public enum FlowArrow : byte + { + No = 0, + Right = 1, + Left = 2, + Count /// Number of flow arrows + } + + public enum MeterSealed : byte + { + InProduction = 0x00, + OutOfProduction = 0xA5, + Sealed = 0x5A, + } + + public enum MeterState : byte + { + None = 0, + Idle = 1, + Active = 2, + Test = 3, + EndOfLife = 4, + Count /// Number of meter states + } + + public enum Command : byte + { + SetActiveMode = 6, + SetTestMode = 7, + } + + public enum FlowState : byte + { + No = 0, + Reverse = 1, + Forward = 2, + EmptyPipe = 3, + Count /// Number of flow states + } + + public enum DataStreamState + { + Flush = 0, + ProcessAndSave, + } + + public enum CommunicationInterface + { + RFID, + NFC + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/OptoReceivedEventArgs.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/OptoReceivedEventArgs.cs new file mode 100644 index 000000000..e6c2b035c --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/comminication/OptoReceivedEventArgs.cs @@ -0,0 +1,20 @@ +/// +/// Copyright (c) 2015-2017 Sensus Metering Systems +/// +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI.comminication +{ + public class OptoReceivedEventArgs : EventArgs + { + public string Data; + + public OptoReceivedEventArgs(string data) + { + this.Data = data; + } + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/OpticalHeadTest.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/OpticalHeadTest.cs new file mode 100644 index 000000000..3116d301a --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/OpticalHeadTest.cs @@ -0,0 +1,131 @@ +using Config.Resources; +using log4net; +using Sensus.iPerl.RfidCom.Helper; +using Sensus.iPerl.RfidCom.Services; +using Sensus.iPerl.RfidCom.Structures; +using System; +using System.Threading; +using TBF.Rig.Hart.Common; +using TBF.Rig.TestMethods.iPerlCommunication.iPerlHead; +using static Sensus.iPerl.NfcHandler.MCI_Protocol; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI.test +{ + internal class OpticalHeadTest + { + protected static readonly ILog rfidDataLogger = LogManager.GetLogger("RfidData"); + + internal static string OpenSealing(IperlHead iHead) + { + if (RfidCommands.OpenSealing($"COM{iHead.RfidComPortNr}")) return "OK"; + return "Error Open Sealing"; + } + + internal static string ReadRequest_PCB(IperlHead iHead) + { + try + { + byte[] pcb = null; + int readRetVal = iPerlCommunicationForm.ReadRequestPort(iHead, MessageID.Configuration, Sensus.iPerl.NfcHandler.MCI_Protocol.StructName.Configuration, 16, 5, out pcb); + if (readRetVal == 0) + { + return RfidHelper.HexLiteral2Unsigned(RfidHelper.SwapHexcode(BitConverter.ToString(pcb).Replace("-", string.Empty))).ToString(); + } + rfidDataLogger.Error($"COM{iHead.RfidComPortNr}: ReadRequest_PCB ({MessageID.Configuration},16,5...) <- Error: {readRetVal}"); + return "Error"; + } + catch (Exception ex) + { + return (ex.Message.ToString()); + } + } + + internal static string SetActiveMode(IperlHead iHead) + { + byte[] cmd = new byte[1] { (byte)Command.SetActiveMode }; + if (0 == iPerlCommunicationForm.WriteRequestPort(iHead, MessageID.Command, StructName.Command, 0, 1, cmd)) + { + return "OK"; + } + else + { + return "Error Set Active Mode"; + } + } + + internal static string SetTestMode(IperlHead iHead) + { + byte[] cmd = new byte[1] { (byte)Command.SetTestMode }; + if (0 == iPerlCommunicationForm.WriteRequestPort(iHead, MessageID.Command, StructName.Command, 0, 1, cmd)) + { + return "OK"; + } + else + { + return "Error Set Test Mode"; + } + } + +#if IPERL + internal static string TurnOffRadio(IperlHead iHead) + { + try + { + int retValue = iPerlCommunicationForm.WriteRequestPort(iHead, MessageID.RadioPassthrough, StructName.RadioParams, 0x1898, 1, new byte[] { (byte)3 }); // WakeUpInterval + return 0 == retValue ? "OK" : "Error"; + } + catch (Exception ex) + { + return (ex.Message.ToString()); + } + } + + internal static string SetProductionMode(IperlHead iHead) + { + try + { + int retValue = iPerlCommunicationForm.WriteRequestPort(iHead, MessageID.RadioPassthrough, StructName.RadioInfo, 0x1804, 1, new byte[] { (byte)1 }); // System Status + return 0 == retValue ? "OK" : "Error"; + } + catch (Exception ex) + { + return (ex.Message.ToString()); + } + } + + internal static string WriteRequestPort_u8_Customer_Text(IperlHead iHead) + { + string custText = "FF0123456789ABCDEF"; // Sample text to test write function + /*try + { + byte[] cmd = RfidHelper.HexStringToByteArray(custText); + if (0 == iPerlCommunicationForm.WriteRequestPort(iHead, MessageID.RadioPassthrough, Sensus.iPerl.NfcHandler.MCI_Protocol.StructName.RadioParams, 0x1899, 9, cmd)) + { + RfidCommunicationService rfidCommunicationService = new RfidCommunicationService { ComPort = $"COM{iHead.RfidComPortNr}", WaitTimeAfterFailure = 2200, PassThroughWaitTime = 1500, MaxRetries = 3, TimeOut = 5000 }; + //rfidCommunicationService.RfidWrite(Params.u8_Customer_Text, custText); + return rfidCommunicationService.RfidRead(Params.u8_Customer_Text).ToString(); + } + } + catch (Exception ex) + { + return (ex.Message.ToString()); + }*/ + return $"Error COM{iHead.RfidComPortNr}"; + } + + internal static string SetRfidMode(IperlHead iHead) + { + iHead.SetRfidInterface(); + iHead.SetCommunicationInterface(CommunicationInterface.RFID); + return ($"OK - {Strings.Program_restart_is_required_to_apply_some_settings}"); + } + + internal static string SetNfcMode(IperlHead iHead) + { + iHead.SetNfcInterface(); + iHead.SetCommunicationInterface(CommunicationInterface.NFC); + return ($"OK - {Strings.Program_restart_is_required_to_apply_some_settings}"); + } +#endif /// IPERL + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.cs new file mode 100644 index 000000000..65f16e382 --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.cs @@ -0,0 +1,2883 @@ +/// +/// Copyright (c) 2015-2023 Sensus Slovensko a.s. +/// +//#define VERIFY_ACTIVE_MODE +//#define VERIFY_Q2_CORR_RESET + +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Globalization; +using System.Linq; +using System.Threading; +using System.Windows.Forms; +using log4net; +using Common; +using Config.Entities; +using TBF.Resources; +using TBF.Rig.Sequences; +using TBF.Rig.TestMethods.iPerlCommunication.iPerlHead; +using Results.Entities; +using static Sensus.iPerl.NfcHandler.MCI_Protocol; +using System.Threading.Tasks; + +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI.test +{ + public enum CommErr + { + None = 0, + CommFailed, /// 1 + OpenPort, /// 2 + Read, /// 3 + Read1, /// 4 + Read2, /// 5 + Read3, /// 6 + Read4, /// 7 + Write, /// 8 + ReadAfterWrite, /// 9 + CmdActive, /// 0AH = 10 + CmdTest, /// 0BH = 11 + Verify, /// 0CH = 12 + WrongIPerlType, /// 0DH = 13 + OutOfRange, /// 0EH = 14 + Q2OutOfRange, /// 0FH = 15 + MissingTest, /// 10H = 16 + RFPowerRecordMissing, /// 11H = 17 + HeadDisabledByUser, /// 12H = 18 + WrongArguments, /// 13H = 19 + } + + + public partial class iPerlCommunicationForm : Form, GenericDevices.IHasCompleted + { + private static readonly ILog log = LogManager.GetLogger(typeof(iPerlCommunicationForm)); + protected static readonly ILog rfidDataLogger = LogManager.GetLogger("RfidData"); + + const int Hz2CorrFactorsAddr = 0x1875; /// Used by Reset2HzCorrection(...) and Write2HzCorrection(...) + const int Q2CorrFactorsAddr = 0x1878; /// Used by ResetQ2Correction(...) and WriteQ2Correction(...) + const int Q2CorrFactorsAddrLR = 0x1878; + const int Q2CorrFactorsAddrRL = 0x1879; + + public const string ReadConfigurationStr = "Read configuration"; /// Example: "Read configuration" or "Read configuration if enabled" + public const string SetTestModeStr = "Set Test mode"; /// Example: "Set Test mode" or "Set Test mode A0" (hexadecimal number is the required 'testModeConfig' + public const string SetActiveModeStr = "Set Active mode"; + public const string ReadCalibrationStr = "Read calibration"; + public const string ReadCalibrationV4Str = "Read calibration_V4"; + public const string WriteCalibrationFactorStr = "Write calibration factor"; + public const string WriteCalibrationV4FactorsStr = "Write calibration_V4"; + public const string NormalizeCalibrationFactorStr = "Normalize calibration factor"; + public const string NormalizeCalibrationV4FactorsStr = "Normalize calibration_V4"; + public const string GetDefaultQ2CorrectionsStr = "Get default Q2 corrections"; + public const string ReadQ2CorrectionStr = "Read Q2 corrections"; + public const string ResetQ2CorrectionStr = "Reset Q2 correction"; + public const string WriteDefaultQ2CorrectionsStr = "Write default Q2 corrections"; + public const string InitOrReadQ2CorrectionsStr = "Init or read Q2 corrections"; + public const string WriteQ2CorrectionStr = "Write Q2 correction"; /// No arguments + public const string WriteQ2CorrectionAltStr = "Write Q2 correction Alt"; /// No arguments + public const string WriteQ2CorrectionGreeceStr = "Write Q2 correction Greece"; /// Arguments: test_name + public const string WriteQ2CorrectionRLStr = "Write Q2 correction R-L"; /// Arguments: test_name + public const string WriteQ2CorrectionLRStr = "Write Q2 correction L-R"; /// Arguments: test_name + public const string WriteQ2CorrectionIncl05Str = "Write_Q2_correction_incl.-0,5..0,5%"; /// No arguments + public const string WriteQ2CorrectionAltIncl05Str = "Write_Q2_correction_Alt_incl.-0,5..0,5%"; /// No arguments + public const string WriteQ2CorrectionPlusIncl05Str = "Write_Q2_correction_plus_incl.-0,5..0,5%"; /// No arguments + public const string WriteQ2CorrectionPlusAltIncl05Str = "Write_Q2_correction_plus_Alt_incl.-0,5..0,5%"; /// No arguments + public const string WriteQ2CorrectionGreeceIncl05Str = "Write_Q2_correction_Greece_incl.-0,5..0,5%"; /// Arguments: test_name + public const string WriteQ2CorrectionRLIncl05Str = "Write_Q2_correction_R-L_incl.-0,5..0,5%"; /// Arguments: test_name + public const string WriteQ2CorrectionLRIncl05Str = "Write_Q2_correction_L-R_incl.-0,5..0,5%"; /// Arguments: test_name + public const string UpdateBothQ2FactorsTestRLOnlyStr = "Update_both_Q2_factors_Test_RL_only"; /// No arguments + public const string UpdateBothQ2FactorsTestLROnlyStr = "Update_both_Q2_factors_Test_LR_only"; /// No arguments + public const string UpdateQ2CorrectionsStr = "Update Q2 corrections"; /// Arguments: R-L_test_name L-R_test_name + public const string ConditnlUpdateQ2CorrectionsStr = "Conditional update of Q2 corrections"; /// Arguments: R-L_test_name L-R_test_name + public const string ConditnlUpdateQ2CorrRLStr = "Conditional update of Q2 correction R-L"; /// Arguments: R-L_test_name + public const string ConditnlUpdateQ2CorrLRStr = "Conditional update of Q2 correction L-R"; /// Arguments: L-R_test_name + public const string Reset2HzCorrectionStr = "Reset 2Hz correction"; + public const string Write2HzCorrectionStr = "Write 2Hz correction"; + public const string DewaReworkRLStr = "DEWA rework R-L"; + public const string DewaReworkLRStr = "DEWA rework L-R"; + public const string StartTestingSealedMetersStr = "Start testing sealed meters"; + public const string EndTestingSealedMetersStr = "End testing sealed meters"; + public const string SimulateCmd = "simulate "; + + public static Color DisabledColor = Color.DarkGray; + public static Color OptoAndDirOKColor = Color.Green; + public static Color OptoNokColor = Color.Orange; + public static Color DirNokColor = Color.Red; + + + #region Simulation / RFID / NFC Interface: ReadRequestPort, WriteRequestPort + /// + /// Wrapper function with safe interface and unsafe body + /// + /// Water meter (iPerlHead) object + /// Value returned by readRequestPort(...) + public static int ReadRequestPort(IperlHead iperlHead, MessageID messageID, StructName structName, int offset, int length, out byte[] buffer) + { + Thread.Sleep(Math.Max(250, cfg.DelayBetweenRetries)); + if (iperlHead.DebugLevel == DebugMode.FailureDuringOperation) iperlHead.DebugLevel = DebugMode.Normal; + + if (iperlHead.DebugLevel != DebugMode.Normal) // Simulation + { + return SimulationServices.ReadRequest(cfg, iperlHead, messageID, offset, length, out buffer); + } + + if (iperlHead.CommInterface == CommunicationInterface.NFC) // NFC Interface + { + return NfcServices.ReadRequest(cfg, iperlHead, structName, offset, length, out buffer); + } + else // RFID Interface + { + return RfidServices.ReadRequest(cfg, iperlHead, messageID, offset, length, out buffer); + } + } + + /// + /// Wrapper function with safe interface and unsafe body + /// + /// Water meter (iPerlHead) object + /// Value returned by writeRequestPort(...) + public static int WriteRequestPort(IperlHead iperlHead, MessageID messageID, StructName structName, int offset, int length, byte[] buffer) + { + Thread.Sleep(Math.Max(250, cfg.DelayBetweenRetries)); + if (iperlHead.DebugLevel == DebugMode.FailureDuringOperation) iperlHead.DebugLevel = DebugMode.Normal; + + if (iperlHead.DebugLevel != DebugMode.Normal) // Simulation + { + return SimulationServices.WriteRequest(cfg, iperlHead, messageID, offset, length, buffer); + } + + if (iperlHead.CommInterface == CommunicationInterface.NFC) // NFC Interface + { + return NfcServices.WriteRequest(cfg, iperlHead, structName, offset, length, buffer); + } + else // RFID Interface + { + return RfidServices.WriteRequest(cfg, iperlHead, messageID, offset, length, buffer); + } + } + #endregion iPerl_Head_RFID_Interface: ReadRequestPort, WriteRequestPort + + + readonly bool checkBoxesEditMode; + + DateTime startTime; + int startTimeSec; + + + // Set to 'true' when the form closes + public bool Completed { get { return formCompleted; } } + bool formCompleted; + + bool forcedClose; /// Set in the forced close handler + + + /// Number of text boxes for serial numbers + public int WaterMetersCount; + + const int MaxTextBoxesCount = 48; + int textBoxesCount; + + Label[] labels; + PictureBox[] counters; + TextBox[] messages; + CheckBoxImage[] checkBoxes; + static int[] ckbIndex; + static bool[] ckbState; + + static IList iperlHeads; + static IList waterMeterPositions0; /// keeps original 0-based indices in RegisterReaders list + static int commonWMType; + + + /// + /// RFID multiplexer PCB / RFID serial port and worker thread related variables + /// + static TestMethod testMethod; + public static TestMethodCfg cfg; + static IList tests; + static IList multiTestParams; + + + static int currentActivityStep; + static int currentGroup; /// form -> worker thread (0 = none) + static int lastGroup; + static int completedCommCount; /// Number of completed communication steps + + static IList workerThreads; + static IList muxBrdOrGroup14Nrs; + static bool stopWorkerThreads; /// form -> worker thread + + + /// Parameterless constructor (without watermeters, threads) + public iPerlCommunicationForm() + { + InitializeComponent(); + } + + /// + /// Constructor for checkBox states (active/inactive iPerl head) editing. + /// + /// Initial check box states + public iPerlCommunicationForm(bool isCheckBoxesEditMode) + : this() + { + iPerlCommunicationForm.cfg = new TestMethodCfg(null); // default iPerl Head communication params + if (isCheckBoxesEditMode) + { + checkBoxesEditMode = true; + saveButton.Visible = true; + activityLabel.Text = Strings.Optical_heads; + ShuffleTextBoxes(ProcessData.WMsCount, ProcessData.LineSize); + +#if IPERL + ContextMenu cm = new ContextMenu(); + cm.MenuItems.Add(NewMenuItem("Read PCB Number" , "ReadPCB")); + cm.MenuItems.Add(NewMenuItem("Enter Test Mode" , "StartTestMode")); + cm.MenuItems.Add(NewMenuItem("Turn Off Test Mode (Enter Active Mode)", "TurnOffTestMode")); + cm.MenuItems.Add(NewMenuItem("Set Production Mode (Radio not start with flow)" , "SetProductionMode")); + cm.MenuItems.Add(NewMenuItem("Turn Off Radio" , "TurnOffRadio")); + cm.MenuItems.Add(NewMenuItem($"Set RFID mode ({Strings.Program_restart_is_required_to_apply_some_settings})" , "SetRFID")); + cm.MenuItems.Add(NewMenuItem($"Set NFC mode ({Strings.Program_restart_is_required_to_apply_some_settings})" , "SetNFC")); + /*if (Users.CurrentUser.AuthorizedAs == AuthorizedAs.PowerUser) + { + //cm.MenuItems.Add(NewMenuItem("Test WriteRequestPort (u8_Customer_Text)", "WriteRequestPort_u8_Customer_Text")); + cm.MenuItems.Add(NewMenuItem("Open sealing", "OpenSealing")); + }*/ + this.ContextMenu = cm; +#endif + } + } + + + /// + /// Constructor for one iPerlCommunication 'test' + /// + /// Number of text boxes for serial numbers + public iPerlCommunicationForm(TestMethod testMethod, Test test, iPerlCommunicationParams testParams) + : this(testMethod, new List { test }, new List { testParams }) + { + } + + /// + /// Constructor for multiple iPerlCommunication 'tests' + /// + /// Number of text boxes for serial numbers + public iPerlCommunicationForm(TestMethod testMethod, IList tests, IList multiTestParams) + : this() + { + checkBoxesEditMode = false; + + iPerlCommunicationForm.testMethod = testMethod; + iPerlCommunicationForm.cfg = testMethod.Cfg as TestMethodCfg; + iPerlCommunicationForm.tests = tests; + iPerlCommunicationForm.multiTestParams = multiTestParams; + + if (multiTestParams.Count > 0) + { + ProcessData.RegisterReaders = StateMachine.GetMetersPath(tests[0]).RegisterReaders; + activityLabel.Text = multiTestParams[0].Activity; + foreach (var p in multiTestParams) + { + if (p.Activity.ToLower() == GetDefaultQ2CorrectionsStr.ToLower()) + { + /// Reset IsQ2PreCorrectionCalculated that is used for synchronization/to prevent double REST call + ProcessData.IsQ2PreCorrectionCalculated = false; + commonWMType = 0; + break; + } + } + } + + PrepareForTestsActivities(); + } + + + void PrepareForTestsActivities() + { + startTime = DateTime.Now; + startTimeSec = StateMachine.Time; + + /// Attach to 'CommCompleted' handler + CommCompletedHandler += delegate(object sender, CommCompletedEventArgs args) + { + if (InvokeRequired) + { + Invoke(new EventHandler(DoOnCommCompleted), sender, args); + } + else DoOnCommCompleted(sender, args); + }; + + /// Attach to 'AllCompleted' handler + AllCompletedHandler += delegate(object sender, AllCompletedEventArgs args) + { + if (InvokeRequired) + { + Invoke(new EventHandler(DoOnAllCompleted), sender, args); + } + else DoOnAllCompleted(sender, args); + }; + + formCompleted = false; + StartForceCloseHandler(); + + + iperlHeads = new List(); + waterMeterPositions0 = new List(); + /// + for (int wmPos = 0; wmPos < ProcessData.RegisterReaders.Length; wmPos++) + { + IperlHead iperlHead = ProcessData.RegisterReaders[wmPos] as IperlHead; + + if (iperlHead != null) + { + iperlHeads.Add(iperlHead); + waterMeterPositions0.Add(wmPos); + } + } + + WaterMetersCount = iperlHeads.Count; + ShuffleTextBoxes(WaterMetersCount, ProcessData.LineSize); + + /// + /// Prepare worker threads, 'rfidPortNrs', 'lastGroup', etc.. + /// + currentActivityStep = 0; + currentGroup = 0; + completedCommCount = 0; + stopWorkerThreads = false; + + /// group numbers are >=1, lastGroup == 0 means there is no group + lastGroup = 0; + foreach (var iPerl in iPerlCommunicationForm.iperlHeads) + { + if (iPerl.Group > lastGroup) lastGroup = iPerl.Group; + } + + workerThreads = new List(); + for (int i = 0; i < cfg.NrThreads; i++) + { + Thread thread = new Thread(Worker); + thread.CurrentCulture = CultureInfo.CurrentCulture; + thread.CurrentUICulture = CultureInfo.CurrentUICulture; + workerThreads.Add(thread); + } + + muxBrdOrGroup14Nrs = new List(); + foreach (var iPerl in iPerlCommunicationForm.iperlHeads) + { + if (!muxBrdOrGroup14Nrs.Contains(iPerl.MuxBoardNrOrGroup14)) muxBrdOrGroup14Nrs.Add(iPerl.MuxBoardNrOrGroup14); + } + + log.WarnFormat("nrThreads = {0}", workerThreads.Count); + } + + /// + /// Make sure the layout of labels/text boxes on the screen + /// corresponds to the layout of watermeters of the test bench. + /// + /// Number of watermeters + /// Number of watermeters in one line + void ShuffleTextBoxes(int wmsCount, int lineSize) + { + labels = new Label[MaxTextBoxesCount] + { + wmLabel1, wmLabel2, wmLabel3, wmLabel4, wmLabel5, wmLabel6, wmLabel7, wmLabel8, wmLabel9, wmLabel10, + wmLabel11, wmLabel12, wmLabel13, wmLabel14, wmLabel15, wmLabel16, wmLabel17, wmLabel18, wmLabel19, wmLabel20, + wmLabel21, wmLabel22, wmLabel23, wmLabel24, wmLabel25, wmLabel26, wmLabel27, wmLabel28, wmLabel29, wmLabel30, + wmLabel31, wmLabel32, wmLabel33, wmLabel34, wmLabel35, wmLabel36, wmLabel37, wmLabel38, wmLabel39, wmLabel40, + wmLabel41, wmLabel42, wmLabel43, wmLabel44, wmLabel45, wmLabel46, wmLabel47, wmLabel48, + }; + counters = new PictureBox[MaxTextBoxesCount] + { + pictureBox1, pictureBox2, pictureBox3, pictureBox4, pictureBox5, pictureBox6, pictureBox7, pictureBox8, pictureBox9, pictureBox10, + pictureBox11, pictureBox12, pictureBox13, pictureBox14, pictureBox15, pictureBox16, pictureBox17, pictureBox18, pictureBox19, pictureBox20, + pictureBox21, pictureBox22, pictureBox23, pictureBox24, pictureBox25, pictureBox26, pictureBox27, pictureBox28, pictureBox29, pictureBox30, + pictureBox31, pictureBox32, pictureBox33, pictureBox34, pictureBox35, pictureBox36, pictureBox37, pictureBox38, pictureBox39, pictureBox40, + pictureBox41, pictureBox42, pictureBox43, pictureBox44, pictureBox45, pictureBox46, pictureBox47, pictureBox48, + }; + messages = new TextBox[MaxTextBoxesCount] + { + wmTextBox1, wmTextBox2, wmTextBox3, wmTextBox4, wmTextBox5, wmTextBox6, wmTextBox7, wmTextBox8, wmTextBox9, wmTextBox10, + wmTextBox11, wmTextBox12, wmTextBox13, wmTextBox14, wmTextBox15, wmTextBox16, wmTextBox17, wmTextBox18, wmTextBox19, wmTextBox20, + wmTextBox21, wmTextBox22, wmTextBox23, wmTextBox24, wmTextBox25, wmTextBox26, wmTextBox27, wmTextBox28, wmTextBox29, wmTextBox30, + wmTextBox31, wmTextBox32, wmTextBox33, wmTextBox34, wmTextBox35, wmTextBox36, wmTextBox37, wmTextBox38, wmTextBox39, wmTextBox40, + wmTextBox41, wmTextBox42, wmTextBox43, wmTextBox44, wmTextBox45, wmTextBox46, wmTextBox47, wmTextBox48, + }; + checkBoxes = new CheckBoxImage[MaxTextBoxesCount] + { + checkBoxImage1, checkBoxImage2, checkBoxImage3, checkBoxImage4, checkBoxImage5, checkBoxImage6, checkBoxImage7, checkBoxImage8, checkBoxImage9, checkBoxImage10, + checkBoxImage11, checkBoxImage12, checkBoxImage13, checkBoxImage14, checkBoxImage15, checkBoxImage16, checkBoxImage17, checkBoxImage18, checkBoxImage19, checkBoxImage20, + checkBoxImage21, checkBoxImage22, checkBoxImage23, checkBoxImage24, checkBoxImage25, checkBoxImage26, checkBoxImage27, checkBoxImage28, checkBoxImage29, checkBoxImage30, + checkBoxImage31, checkBoxImage32, checkBoxImage33, checkBoxImage34, checkBoxImage35, checkBoxImage36, checkBoxImage37, checkBoxImage38, checkBoxImage39, checkBoxImage40, + checkBoxImage41, checkBoxImage42, checkBoxImage43, checkBoxImage44, checkBoxImage45, checkBoxImage46, checkBoxImage47, checkBoxImage48, + }; + ckbIndex = new int[MaxTextBoxesCount]; + ckbState = new bool[MaxTextBoxesCount]; + + + textBoxesCount = MaxTextBoxesCount; + /// + if (wmsCount < textBoxesCount && lineSize > 0) + { + int nrLines = (wmsCount + lineSize - 1) / lineSize; + int gap = (textBoxesCount - wmsCount) / nrLines; + + for (int i = 0; i < ckbIndex.Length; i++) + { + ckbIndex[i] = -1; /// Initialize with invalid indices + } + + int dest = 0; + for (int l = 0; l < nrLines; l++) + { + for (int i = 0; i < lineSize; i++) + { + int origin = l * lineSize + l * gap + i; + labels[dest] = labels[origin]; + counters[dest] = counters[origin]; + messages[dest] = messages[origin]; + checkBoxes[dest] = checkBoxes[origin]; + ckbIndex[origin] = dest; + dest++; + } + } + + textBoxesCount = wmsCount; + } + + int count = checkBoxesEditMode ? textBoxesCount : Math.Min(textBoxesCount, iperlHeads.Count); + for (int j = 0; j < count; j++) + { + labels[j].Text = (j + 1).ToString(); + } + + ResizeDlgToFitEnabledControls(); + } + + void ResizeDlgToFitEnabledControls() + { + int xMax = 0; + int yMax = 0; + for (int i = 0; i < textBoxesCount; i++) + { + if (messages[i].Left + messages[i].Width > xMax) xMax = messages[i].Left + messages[i].Width; + if (messages[i].Top + messages[i].Height > yMax) yMax = messages[i].Top + messages[i].Height; + } + Width = xMax + 50; + Height = yMax + 60; + } + + + void Localize() + { + Text = checkBoxesEditMode ? Strings.Optical_heads : Strings.Water_Meter_States; + saveButton.Text = Strings.Save; + + sampleLabel1.Text = Strings.Direction_and_pulses_are_OK; + sampleLabel2.Text = Strings.There_are_no_opto_pulses; + sampleLabel3.Text = Strings.Direction_is_NOK; + + samplePictureBox1.BackColor = OptoAndDirOKColor; + samplePictureBox2.BackColor = OptoNokColor; + samplePictureBox3.BackColor = DirNokColor; + } + + + private void iPerlCommunicationForm_Load(object sender, EventArgs e) + { + Localize(); + + if (checkBoxesEditMode) + { + /// Check box edit mode => Hide explanation of activity colours + sampleLabel1.Visible = false; + sampleLabel2.Visible = false; + sampleLabel3.Visible = false; + samplePictureBox1.Visible = false; + samplePictureBox2.Visible = false; + samplePictureBox3.Visible = false; + } + + /// + /// Set checkbox states accroding to iPerlHeads[i].Disabled states + /// + for (int i = 0; i < textBoxesCount; i++) + { + labels[i].Visible = counters[i].Visible = messages[i].Visible = checkBoxes[i].Visible = true; + + if (!checkBoxesEditMode && (iperlHeads[i] == null || iperlHeads[i].Disabled)) + { + /// iPerl position i+1 is disabled + checkBoxes[i].Enabled = checkBoxes[i].Checked = ckbState[i] = false; + counters[i].BackColor = DisabledColor; + messages[i].Text = Strings.Head_was_disabled_by_the_user; + } + else + { + /// iPerl position i+1 is enabled + checkBoxes[i].Enabled = checkBoxes[i].Checked = ckbState[i] = true; + messages[i].Text = "---"; + } + } + + /// + /// Set location and checkbox states to values stored in local settings + /// + TBF.LocalSettings ls = Program.LocalSettings; + Left = (ls.iPerlCommunicationsFormLeft != 0) ? ls.iPerlCommunicationsFormLeft : 150; + Top = (ls.iPerlCommunicationsFormTop != 0) ? ls.iPerlCommunicationsFormTop : 150; + SetCheckBoxStates(ls.OptoHeadsEnabled); + + if (!checkBoxesEditMode) + { + /// Regular activity (not a checkbox edit mode invoked from TBF menu) + + /// Reset opto-data indication + for (int i = 0; i < iperlHeads.Count; i++) + { + counters[i].BackColor = OptoNokColor; + } + + /// Start communication process by incrementing 'currentGroup'. + currentGroup++; + + int wtId = 0; + foreach (var wt in workerThreads) + { + wt.Start(new Boxes.IntBox(wtId++)); /// Start worker threads !!! + } + } + } + + + private void NormalClose() + { + CommCompletedHandler = null; + AllCompletedHandler = null; + + if (multiTestParams != null && + multiTestParams.Count > 0 && + !multiTestParams[0].SimultWithNext) /// RFID Communication at the end of the cycle does not influence the result + { + UpdateRfidCommResult(tests); /// TODO: Pass the test info in a correct way + } + + long checkboxStates = GetCheckBoxStates(); + if (Program.LocalSettings.iPerlCommunicationsFormLeft != Location.X || + Program.LocalSettings.iPerlCommunicationsFormTop != Location.Y || + Program.LocalSettings.OptoHeadsEnabled != checkboxStates) + { + /// Update local settings + Program.LocalSettings.iPerlCommunicationsFormLeft = Location.X; + Program.LocalSettings.iPerlCommunicationsFormTop = Location.Y; + Program.LocalSettings.OptoHeadsEnabled = checkboxStates; + Program.LocalSettings.Save(); + } + + formCompleted = true; + + DialogResult = DialogResult.OK; + Close(); + } + + + #region Forced close handling + + public void StartForceCloseHandler() + { + UiBridge.Bridge.CloseModelessFormHandler += delegate(object sender, EventArgs args) + { + if (InvokeRequired) { Invoke(new EventHandler(OnForceClose), sender, args); } + else OnForceClose(sender, args); + }; + } + + void OnForceClose(object sender, EventArgs args) + { + CommCompletedHandler = null; + AllCompletedHandler = null; + + stopWorkerThreads = true; + forcedClose = true; + + DialogResult = DialogResult.Cancel; + Close(); + } + + #endregion + + + /// + /// Worker thread + /// + /// Thread ID (integer) wrapped into IntBox + void Worker(object threadData) + { + int threadID = (threadData as Boxes.IntBox).Val; + + int activityStep = 0; /// activity step > 0 in case multiTestParams are used + + for (int i = 0; i < multiTestParams.Count; i++ ) + { + Test currentTest = tests[i]; + iPerlCommunicationParams currentTestParams = multiTestParams[i]; + string currentActivity = currentTestParams.Activity; /// Current activity + + TBF.UiBridge.TestProgressEventArgs.SetEstimatedTimes(new int[] { 0, 0, 10, 0, 140, 0, 0, 0 }); + TBF.UiBridge.Bridge.OnTestProgress(null, new TBF.UiBridge.TestProgressEventArgs(tests[i], Progress.JustStarted)); + + + if (threadID == 0) + { + /// Check whether previous activity was 'Set test mode A0' or 'A4' + if (i > 0 && multiTestParams[i - 1].Activity.ToLower().Contains(SetTestModeStr.ToLower()) && !multiTestParams[i - 1].Activity.Contains("80")) + { + /// Start processing of opto-datastreams from all iPERL-s + int count = 0; + for (int wmNr0 = 0; wmNr0 < iperlHeads.Count; wmNr0++) + { + WaterMeter wm = (ProcessData.BatchRslts.Batch.WaterMeters != null && ProcessData.BatchRslts.Batch.WaterMeters.Count > wmNr0) + ? ProcessData.BatchRslts.Batch.WaterMeters[wmNr0] : null; + + IperlHead ihead = iperlHeads[wmNr0]; + + if (ihead != null && wm != null && !wm.Disabled) + { + lock (ihead) + { + ihead.StartDataStreamProcessing(); + count++; + } + } + } + log.WarnFormat("End of activity '{0}', StartDataStreamProcessing() of {1} heads was called.", multiTestParams[i - 1].Activity, count); + } + + /// A new activity starts - information into RFID data log + rfidDataLogger.InfoFormat(""); + rfidDataLogger.WarnFormat("Activity = {0}", currentActivity); + rfidDataLogger.InfoFormat(""); + } + + for (int group = 1; group <= lastGroup; group++) + { + /// Synchronize with QuidoRS and other threads + while (((group != currentGroup) || (activityStep != currentActivityStep)) && !stopWorkerThreads) + { + Thread.Sleep(50); + } + + if (stopWorkerThreads) break; + +#if TURA_SPECIAL + int threadIx = threadID; /// Just one thread for TURA_SPECIAL +#else + for (int threadIx = threadID; threadIx < threadID + 4; threadIx += cfg.NrThreads) +#endif + { + bool wmFound = false; + + for (int wmNr0 = 0; wmNr0 < iperlHeads.Count; wmNr0++) + { + IperlHead ihead = iperlHeads[wmNr0]; + if ((ihead.Group == group) && (threadIx < muxBrdOrGroup14Nrs.Count) && (ihead.MuxBoardNrOrGroup14 == muxBrdOrGroup14Nrs[threadIx])) + { + wmFound = true; + + WaterMeter wm = null; + if (ProcessData.BatchRslts.Batch.WaterMeters != null) + { + foreach (var w in ProcessData.BatchRslts.Batch.WaterMeters) + { + if (w.WMPosition == wmNr0 + 1) + { + wm = w; + break; + } + } + } + + CommErr error; + string resultStr = string.Empty; + + /// + /// RFID communication activity call + /// + if ((ihead == null) || ihead.Disabled || !ckbState[wmNr0]) error = CommErr.HeadDisabledByUser; +#if IPERL + else if (currentActivity.ToLower().Contains(SetTestModeStr.ToLower())) error = SetTestMode(threadID, ihead, ref resultStr); + else if (currentActivity.ToLower().Equals(SetActiveModeStr.ToLower())) error = SetActiveMode(threadID, ihead, ref resultStr); + /// + /// RFID communication functions below require a reference to water meter entity (wm != null) + /// + else if (wm == null) error = CommErr.CommFailed; + else if (currentActivity.ToLower().Contains(ReadConfigurationStr.ToLower())) error = ReadConfiguration(ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == ReadCalibrationStr.ToLower()) error = ReadCalibration(ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == ReadCalibrationV4Str.ToLower()) error = ReadCalibrationV4(ihead, wm, ref resultStr); + else if (currentActivity.ToLower().Contains(WriteCalibrationFactorStr.ToLower())) error = WriteCalibrationFactor(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower().Contains(WriteCalibrationV4FactorsStr.ToLower())) error = WriteCalibrationV4Factors(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == NormalizeCalibrationFactorStr.ToLower()) error = NormalizeCalibrationFactor(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == NormalizeCalibrationV4FactorsStr.ToLower()) error = NormalizeCalibrationV4Factors(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == ReadQ2CorrectionStr.ToLower()) error = ReadQ2Correction(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == ResetQ2CorrectionStr.ToLower()) error = ResetQ2Correction(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == WriteDefaultQ2CorrectionsStr.ToLower()) error = WriteDefaultQ2Corrections(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == InitOrReadQ2CorrectionsStr.ToLower()) error = InitOrReadQ2Corrections(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == WriteQ2CorrectionStr.ToLower()) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.Standard, null); + else if (currentActivity.ToLower() == WriteQ2CorrectionAltStr.ToLower()) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.Dewa, null); + else if (currentActivity.ToLower().Contains(WriteQ2CorrectionGreeceStr.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.Greece, currentActivity.Substring(WriteQ2CorrectionGreeceStr.Length).Trim()); + else if (currentActivity.ToLower().Contains(WriteQ2CorrectionRLStr.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.RL, currentActivity.Substring(WriteQ2CorrectionRLStr.Length).Trim()); + else if (currentActivity.ToLower().Contains(WriteQ2CorrectionLRStr.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.LR, currentActivity.Substring(WriteQ2CorrectionLRStr.Length).Trim()); + else if (currentActivity.ToLower() == WriteQ2CorrectionIncl05Str.ToLower()) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.Standard_incl_05, null); + else if (currentActivity.ToLower() == WriteQ2CorrectionPlusIncl05Str.ToLower()) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.Standard_plus_incl_05, null); + else if (currentActivity.ToLower() == WriteQ2CorrectionAltIncl05Str.ToLower()) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.Dewa_incl_05, null); + else if (currentActivity.ToLower() == WriteQ2CorrectionPlusAltIncl05Str.ToLower()) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.Dewa_plus_incl_05, null); + else if (currentActivity.ToLower().Contains(WriteQ2CorrectionGreeceIncl05Str.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.Greece_incl_05, currentActivity.Substring(WriteQ2CorrectionGreeceIncl05Str.Length).Trim()); + else if (currentActivity.ToLower().Contains(WriteQ2CorrectionRLIncl05Str.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.RL_incl_05, currentActivity.Substring(WriteQ2CorrectionRLIncl05Str.Length).Trim()); + else if (currentActivity.ToLower().Contains(WriteQ2CorrectionLRIncl05Str.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.LR_incl_05, currentActivity.Substring(WriteQ2CorrectionLRIncl05Str.Length).Trim()); + else if (currentActivity.ToLower().Contains(UpdateBothQ2FactorsTestRLOnlyStr.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.UpdateBothQ2FactorsTestRLDir, null); + else if (currentActivity.ToLower().Contains(UpdateBothQ2FactorsTestLROnlyStr.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.UpdateBothQ2FactorsTestLRDir, null); + else if (currentActivity.ToLower().Contains(UpdateQ2CorrectionsStr.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.Update, currentActivity.Substring(UpdateQ2CorrectionsStr.Length).Trim()); + else if (currentActivity.ToLower().Contains(ConditnlUpdateQ2CorrectionsStr.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.ConditionalUpdate, currentActivity.Substring(ConditnlUpdateQ2CorrectionsStr.Length).Trim()); + else if (currentActivity.ToLower().Contains(ConditnlUpdateQ2CorrRLStr.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.ConditionalUpdateRL, currentActivity.Substring(ConditnlUpdateQ2CorrRLStr.Length).Trim()); + else if (currentActivity.ToLower().Contains(ConditnlUpdateQ2CorrLRStr.ToLower())) error = CalculateAndWriteQ2Corrections(threadID, ihead, wm, currentTest, ref resultStr, Q2CorrType.ConditionalUpdateLR, currentActivity.Substring(ConditnlUpdateQ2CorrLRStr.Length).Trim()); + else if (currentActivity.ToLower() == Reset2HzCorrectionStr.ToLower()) error = Reset2HzCorrection(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == Write2HzCorrectionStr.ToLower()) error = Write2HzCorrection(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == GetDefaultQ2CorrectionsStr.ToLower()) error = GetQ2PreCorrectionsFormRest(threadID, ihead, wm, ref resultStr); + else if (currentActivity.ToLower() == DewaReworkRLStr.ToLower()) error = DewaRework(ihead, wm, FlowDir.R_L, ref resultStr); + else if (currentActivity.ToLower() == DewaReworkLRStr.ToLower()) error = DewaRework(ihead, wm, FlowDir.L_R, ref resultStr); + else if (currentActivity.ToLower().Contains(StartTestingSealedMetersStr.ToLower())) error = StartTestingSealedMeter(ihead, wm, ref resultStr); + else if (currentActivity.ToLower().Contains(EndTestingSealedMetersStr.ToLower())) error = EndTestingSealedMeter(ihead, wm, ref resultStr); + else if (currentActivity.ToLower().Contains(SimulateCmd.ToLower())) error = Simulate(ihead, wm, ref resultStr); +#endif + else + { + error = CommErr.None; + + ConditionID id = ConditionID.Count; +#if IPERL + for (id = ConditionID.A; id < ConditionID.Count; id++) + { + if (currentActivity.ToLower() == string.Format(SequenceConditionOp.ConditionNameFmt, id).ToLower()) + { + error = SetIperlCommMilestoneReached(testMethod, id, ref resultStr); + break; + } + } +#endif + if (id == ConditionID.Count) + { + resultStr = "Invalid activity"; /// No activity or milestone + } + } + + /// + /// Process the result of RFID communication activity + /// + if (error == CommErr.HeadDisabledByUser || !ckbState[wmNr0]) + { + OnCommCompleted(null, new CommCompletedEventArgs(threadID, wmNr0, ihead, wm, Strings.Head_was_disabled_by_the_user, CommErr.HeadDisabledByUser)); + } + else if (error == CommErr.None) + { + OnCommCompleted(null, new CommCompletedEventArgs(threadID, wmNr0, ihead, wm, resultStr, CommErr.None)); + } + else if ((error == CommErr.OutOfRange) || (error == CommErr.Q2OutOfRange)) + { + OnCommCompleted(null, new CommCompletedEventArgs(threadID, wmNr0, ihead, wm, resultStr, CommErr.CommFailed)); + } + else if (ihead.CommFailed || (error == CommErr.CommFailed)) + { + ihead.CommFailed = true; + + if (wm != null && (wm.ResultCode & (int)Results.Entities.ResultCode.RfidErrorCodeMask) == 0) + { + wm.ResultCode |= (((int)error << 16) | ((int)tests[i].ItemNr << 20)); + } + + OnCommCompleted(null, new CommCompletedEventArgs(threadID, wmNr0, ihead, wm, Strings.RFID_communication_failed, error)); + } + else + { + ihead.CommFailed = true; + + if (wm != null && (wm.ResultCode & (int)Results.Entities.ResultCode.RfidErrorCodeMask) == 0) + { + wm.ResultCode |= (((int)error << 16) | ((int)tests[i].ItemNr << 20)); + } + + string failureCauseLocal = string.Format(Strings.failed_0_1_exclamation, currentActivity, error); + rfidDataLogger.ErrorFormat("Group={0}, Board={1}, {2}", currentGroup, ihead.MuxBoardNrOrGroup14, failureCauseLocal); + + OnCommCompleted(null, new CommCompletedEventArgs(threadID, wmNr0, ihead, wm, failureCauseLocal, error)); + } + + break; + } + + TBF.UiBridge.Bridge.OnTestProgress(null, new TBF.UiBridge.TestProgressEventArgs(tests[i], Progress.FlowSetting)); + } + + if (!wmFound) + { + OnCommCompleted(null, new CommCompletedEventArgs(threadID, -1, null, null, string.Empty, CommErr.None)); /// Send negative wmNr + } + + if (stopWorkerThreads) break; + } + + if (stopWorkerThreads) break; + } /// for (int group + + TBF.UiBridge.Bridge.OnTestProgress(null, new TBF.UiBridge.TestProgressEventArgs(tests[i], Progress.Completed)); + activityStep++; + + if (stopWorkerThreads) break; + } + } + + #region Communication functions + +#if IPERL + + /// + /// Read a complete configuration structure of the watermeter + /// + /// iPERL head object + /// Water meter object + /// String passed to caller + /// true on success + static CommErr ReadConfiguration(IperlHead ihead, WaterMeter wm, ref string resultStr) + { + /// + /// The activity is "Read configuration" (this enables the watermeter, resets error flag) + /// or "Read configuration if enabled" (this keeps the error flag). + /// + if (!multiTestParams[currentActivityStep].Activity.ToLower().Contains(" if enabled")) + { + ihead.CommFailed = false; + } + + if (ihead.CommFailed) return CommErr.CommFailed; + + ihead.ConfigStruct = null; /// Clear previous ConfigStruct, avoid reuse of (not anymore valid) PCB Number + + CommErr error = CommErr.Read; + int readRetVal = 0; + + /// Read configuration + byte[] config = null; + readRetVal = ReadRequestPort(ihead, MessageID.Configuration, StructName.Configuration, 0, ConfigStruct.Length, out config); + if (readRetVal == 0) + { + error = CommErr.None; + ihead.ConfigStruct = ConfigStruct.FromByteArray(config); + resultStr = ihead.ConfigStruct.ToString(1); + } + + return error + Math.Max(0, Math.Min(readRetVal, 4)); + } + + + /// + /// Set the watermeter to the test mode. + /// If testModeConfig is specified as a hexadeximal number appended to "set test mode ", it is verified + /// whether the testModeConfig is correctly set, if necessary it is changed to the specified value. + /// Read a part of configuration afterwards to verify the mode was set correctly. + /// + /// Thread ID passed to RFID communication functions + /// iPERL head object + /// String passed to caller + /// true on success + static CommErr SetTestMode(int threadId, IperlHead ihead, ref string resultStr) + { + if (ihead.CommFailed || ihead.ConfigStruct == null) return CommErr.CommFailed; + + Byte testModeConfig = 0xA0; /// Default value + /// + if (multiTestParams[currentActivityStep].Activity.Length > SetTestModeStr.Length) + { + string testModeConfigStr = multiTestParams[currentActivityStep].Activity.Substring(SetTestModeStr.Length + 1); + UInt16 byteVal; + if (UInt16.TryParse(testModeConfigStr, NumberStyles.HexNumber, CultureInfo.CurrentCulture, out byteVal) && byteVal <= 255) + { + testModeConfig = (Byte)byteVal; /// Update with specified value + } + } + + if (ihead.ConfigStruct.MeterState == MeterState.Test && ihead.ConfigStruct.TestModeConfig == testModeConfig) + { + /// Already in the correct test mode + resultStr = "Already " + ihead.ConfigStruct.ToString(1); + return CommErr.None; + } + + /// Communication necessary + CommErr error = CommErr.None; + + if (error==CommErr.None && (ihead.ConfigStruct.TestModeConfig != testModeConfig) && (ihead.ConfigStruct.MeterState != MeterState.Active)) + { + /// Switch to Active mode in order to change TestModeConfig + error = CommErr.CmdActive; + byte[] cmd = new byte[1] { (byte)Command.SetActiveMode }; + if (0 == WriteRequestPort(ihead, MessageID.Command, StructName.Command, 0, 1, cmd)) + { + error = CommErr.None; + } + + /// Delay min. 250 ms + Thread.Sleep(Math.Max(250, cfg.DelayBetweenRetries)); + } + + if (error == CommErr.None && (ihead.ConfigStruct.TestModeConfig != testModeConfig)) + { + /// Change the TestModeConfig if necessary + error = CommErr.Write; + byte[] tstMdCfg = new byte[1] { testModeConfig }; + if (0 == WriteRequestPort(ihead, MessageID.Configuration, StructName.Configuration, 21, 1, tstMdCfg)) + { + ihead.ConfigStruct.Update(21, tstMdCfg); + error = CommErr.None; + } + + /// Delay min. 250 ms + Thread.Sleep(Math.Max(250, cfg.DelayBetweenRetries)); + } + + if (error == CommErr.None) + { + /// Switch to test mode + error = CommErr.CmdTest; + byte[] cmd = new byte[1] { (byte)Command.SetTestMode }; + if (0 == WriteRequestPort(ihead, MessageID.Command, StructName.Command, 0, 1, cmd)) + { + error = CommErr.None; + } + + /// Delay min. 250 ms + Thread.Sleep(Math.Max(250, cfg.DelayBetweenRetries)); + } + + /// Now the meter should be in the Test mode ... verify + if (error == CommErr.None) + { + /// Verify the configuration + Thread.Sleep(2000); // RFID: 1000 ms is enough, NFC needs min 2000 ms + error = CommErr.Verify; + byte[] config = null; + int retVal = ReadRequestPort(ihead, MessageID.Configuration, StructName.Configuration, 0, ConfigStruct.Length, out config); + if (0 == retVal) + { + ihead.ConfigStruct = ConfigStruct.FromByteArray(config); + if ((ihead.ConfigStruct.MeterState == MeterState.Test) && (ihead.ConfigStruct.TestModeConfig == testModeConfig)) + { + error = CommErr.None; + resultStr = ihead.ConfigStruct.ToString(1); + } + } + } + + return error; + } + + + /// + /// Set the watermeter to the active mode. + /// Read a part of configuration afterwards to verify the mode was set correctly. + /// + /// iPERL head object + /// String passed to caller + /// true on success + static CommErr SetActiveMode(int threadId, IperlHead ihead, ref string resultStr) + { + CommErr error = CommErr.CmdActive; + + /// Switch to active mode + byte[] cmd = new byte[1] { (byte)Command.SetActiveMode }; + if (0 == WriteRequestPort(ihead, MessageID.Command, StructName.Command, 0, 1, cmd)) + { + error = CommErr.None; + } + +#if VERIFY_ACTIVE_MODE + if (error == CommErr.None) + { + error = CommErr.Verify; + + /// Read configuration + byte[] cfg_0_3 = null; + if (ihead.ConfigStruct == null) + { + if (0 == ReadRequestPort(threadId, ihead, MessageID.Configuration, 0, 4, out cfg_0_3)) + { + ihead.ConfigStruct.Update(0, cfg_0_3); + if (ihead.ConfigStruct.MeterState == MeterState.Active) + { + error = CommErr.None; + resultStr = ihead.ConfigStruct.ToString(1); + } + } + } + } +#else + if (error == CommErr.None) + { + if (ihead.ConfigStruct == null) + resultStr = "OK (Config not available)"; + else + resultStr = ihead.ConfigStruct.ToString(1); + } +#endif + + return error; + } + + + /// + /// Read a complete calibration structure from the watermeter + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr ReadCalibration(IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed) return CommErr.CommFailed; + + CommErr error = CommErr.Read; + int readRetVal = 0; + + /// Read calibration + byte[] calib = null; + readRetVal = ReadRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 0, CalibrationStruct.Length, out calib); + if (readRetVal == 0) + { + ihead.CalibrationStruct = CalibrationStruct.FromByteArray(calib); + + if (wm.OrigCalibFactor == 0) + { + wm.OrigCalibFactor = ihead.CalibrationStruct.Calibration; + wm.FWVersion = ihead.CalibrationStruct.FWVersionStr(); + } + + resultStr = ihead.CalibrationStruct.ToString(); + error = ihead.VerifyIPerlType() ? CommErr.None : CommErr.WrongIPerlType; + } + + return error + Math.Max(0, Math.Min(readRetVal, 4)); + } + + + /// + /// Read a complete calibration structure from the watermeter + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr ReadCalibrationV4(IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed) return CommErr.CommFailed; + + CommErr error = CommErr.Read; + int readRetVal = 0; + + /// Read calibration + byte[] calib = null; + readRetVal = ReadRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 0, CalibrationStructV4.Length, out calib); + if (readRetVal == 0) + { + ihead.CalibrationStructV4 = CalibrationStructV4.FromByteArray(calib); + + if ((wm.OrigCalibFactor == 0) && (wm.OrigCalibFactorLNA == 0)) + { + wm.OrigCalibFactor = ihead.CalibrationStructV4.Calibration; + wm.OrigCalibFactorLNA = ihead.CalibrationStructV4.CalibrationLNA; + wm.FWVersion = ihead.CalibrationStructV4.FWVersionStr(); + } + + resultStr = ihead.CalibrationStructV4.ToString(); + error = ihead.VerifyIPerlType() ? CommErr.None : CommErr.WrongIPerlType; + } + + return error + Math.Max(0, Math.Min(readRetVal, 4)); + } + + + /// + /// Write the calculated calibration factor to the water meter. + /// Read a part of CalibrationStruct afterwards to verify factor was written correctly. + /// + /// Thread ID + /// IperlHead object + /// Water meter object + /// String passed to caller + /// true on success + static CommErr WriteCalibrationFactor(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed || (ihead.CalibrationStruct == null)) return CommErr.CommFailed; + + /// + /// Parse calibration factor (1 argument) or calibration factor limits (2 arguments) + /// + UInt16 newCalibFactor = 0; + if (multiTestParams[currentActivityStep].Activity.Length > WriteCalibrationFactorStr.Length) + { + UInt16 factorLimitLo; + UInt16 factorLimitHi; + UInt16 val; + + string calibFactrorStr = multiTestParams[currentActivityStep].Activity.Substring(WriteCalibrationFactorStr.Length + 1); + string[] arguments = calibFactrorStr.Split(new char[] { ' ' }); + + if (arguments.Length >= 2 && + UInt16.TryParse(arguments[0], out factorLimitLo) && factorLimitLo > 0 && + UInt16.TryParse(arguments[1], out factorLimitHi) && factorLimitHi > 0) + { + /// + /// Lower and upper limits for the calibration factor are specified as iPerlCommunication activity arguments + /// + if (ihead.LastTestResult == null || !ihead.LastTestResult.TestDone) return CommErr.MissingTest; + + newCalibFactor = ihead.CalculateNewCalibFactor(ihead.LastTestResult, ihead.CalibFactor, factorLimitLo, factorLimitHi); + } + else if (arguments.Length == 1 && UInt16.TryParse(arguments[0], out val) && val > 0) + { + /// + /// Calibration factor value is specified as an iPerlCommunication activity argument + /// + newCalibFactor = val; /// Update with specified value + } + else if (arguments.Length == 1 && wm.GetTestData(arguments[0]) != null) + { + /// + /// Adjustment test name is specified as an iPerlCommunication activity argument + /// + Results.Entities.TestData adjustTestData = wm.GetTestData(arguments[0]); + Results.Entities.MeterTestRslt adjustTestRslt; + if (adjustTestData == null) + { + return CommErr.MissingTest; + } + else if (adjustTestData.Repeats == 1) + { + /// Find a test result if Repeats == 1 + adjustTestRslt = wm.GetMeterTestRslt(arguments[0]); + + if (adjustTestRslt == null || !adjustTestRslt.TestDone) return CommErr.MissingTest; + } + else + { + /// Calculate a summarized test result if Repeats > 1 + adjustTestRslt = new Results.Entities.MeterTestRslt(); + for (int i = 1; i <= adjustTestData.Repeats; i++) + { + Results.Entities.MeterTestRslt oneMTR = wm.GetMeterTestRslt(Utils.TestTitle(adjustTestData, i)); + if (oneMTR == null || !oneMTR.TestDone) return CommErr.MissingTest; + + adjustTestRslt.VolumeMeter += oneMTR.VolumeMeter; + adjustTestRslt.VolumeRef += oneMTR.VolumeRef; + } + } + + newCalibFactor = ihead.CalculateNewCalibFactor(adjustTestRslt, ihead.CalibFactor, ihead.FactorLimitLo, ihead.FactorLimitHi); + } + else + { + /// + /// Otherwise the last test is supposed to be an adjustment test + /// + if (ihead.LastTestResult == null || !ihead.LastTestResult.TestDone) return CommErr.MissingTest; + + newCalibFactor = ihead.CalculateNewCalibFactor(ihead.LastTestResult, ihead.CalibFactor, ihead.FactorLimitLo, ihead.FactorLimitHi); + } + } + else + { + /// + /// No iPerlCommunication activity arguments --> The last test is supposed to be an adjustment test + /// + if (ihead.LastTestResult == null || !ihead.LastTestResult.TestDone) return CommErr.MissingTest; + + newCalibFactor = ihead.CalculateNewCalibFactor(ihead.LastTestResult, ihead.CalibFactor, ihead.FactorLimitLo, ihead.FactorLimitHi); + } + + if (newCalibFactor == 0) return CommErr.OutOfRange; + + /// + /// Start communication with iPerl + /// + CommErr error; + byte[] data = new byte[2] { (byte)(newCalibFactor & 0x00FF), (byte)((newCalibFactor >> 8) & 0x00FF) }; + /// + /// Write the new calibration factor (up to cfg.MaxCommRetries tims) + /// + error = CommErr.Write; + if (0 == WriteRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 2, 2, data)) + { + /// + /// Read and verify the calibration factor + /// + error = CommErr.ReadAfterWrite; + byte[] calib_2_3 = null; + if (0 == ReadRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 2, 2, out calib_2_3)) + { + error = CommErr.Verify; + if (calib_2_3 != null && calib_2_3.Length == 2 && data[0] == calib_2_3[0] && data[1] == calib_2_3[1]) + { + error = CommErr.None; + ihead.CalibrationStruct.Update(data, 2); + wm.CalibFactor = newCalibFactor; + resultStr = ihead.CalibrationStruct.ToString(); + } + } + } + + ihead.CalibrationStruct.Update(data, 2); + + return error; + } + + + /// + /// Write the calculated calibration factor to the water meter. + /// Read a part of CalibrationStruct afterwards to verify factor was written correctly. + /// + /// Thread ID + /// IperlHead object + /// Water meter object + /// String passed to caller + /// true on success + static CommErr WriteCalibrationV4Factors(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed || (ihead.CalibrationStructV4 == null)) return CommErr.CommFailed; + + /// + /// Parse calibration factor (1 argument) or calibration factor limits (2 arguments) + /// + UInt16 newCalibFactor = 0; + UInt16 newCalibFactorLNA = 0; + if (multiTestParams[currentActivityStep].Activity.Length > WriteCalibrationV4FactorsStr.Length) + { + UInt16 factorLimitLo = 0; + UInt16 factorLimitHi = 0; + UInt16 lnaFactorLimitLo = 0; + UInt16 lnaFactorLimitHi = 0; + Results.Entities.TestData adjustTestData = null; + Results.Entities.TestData lnaAdjustTestData = null; + Results.Entities.MeterTestRslt adjustTestRslt = null; + Results.Entities.MeterTestRslt lnaAdjustTestRslt = null; + + string calibFactrorStr = multiTestParams[currentActivityStep].Activity.Substring(WriteCalibrationV4FactorsStr.Length + 1); + string[] arguments = calibFactrorStr.Split(new char[] { ' ' }); + + if (arguments.Length == 6) + { + if (!wm.TryGetTestData(arguments[0], out adjustTestData) || + !UInt16.TryParse(arguments[1], out factorLimitLo) || factorLimitLo <= 0 && + !UInt16.TryParse(arguments[2], out factorLimitHi) || factorLimitHi <= 0 && + !wm.TryGetTestData(arguments[3], out lnaAdjustTestData) || + !UInt16.TryParse(arguments[4], out lnaFactorLimitLo) || lnaFactorLimitLo <= 0 && + !UInt16.TryParse(arguments[5], out lnaFactorLimitHi) || lnaFactorLimitHi <= 0) + { + return CommErr.WrongArguments; + } + else + { + adjustTestRslt = GetAverageTestRslt(wm, adjustTestData); + lnaAdjustTestRslt = GetAverageTestRslt(wm, lnaAdjustTestData); + + if ((adjustTestRslt == null) || (lnaAdjustTestRslt == null)) + { + return CommErr.MissingTest; + } + + newCalibFactor = ihead.CalculateNewCalibFactor(adjustTestRslt, ihead.CalibFactor, factorLimitLo, factorLimitHi); + newCalibFactorLNA = ihead.CalculateNewCalibFactor(lnaAdjustTestRslt, ihead.CalibFactorLNA, lnaFactorLimitLo, lnaFactorLimitHi); + } + } + else if (arguments.Length == 4) + { + if (!wm.TryGetTestData(arguments[0], out adjustTestData) || + !wm.TryGetTestData(arguments[1], out lnaAdjustTestData) || + !UInt16.TryParse(arguments[2], out lnaFactorLimitLo) || lnaFactorLimitLo <= 0 && + !UInt16.TryParse(arguments[3], out lnaFactorLimitHi) || lnaFactorLimitHi <= 0) + { + return CommErr.WrongArguments; + } + else + { + factorLimitLo = ihead.FactorLimitLo; + factorLimitHi = ihead.FactorLimitHi; + + adjustTestRslt = GetAverageTestRslt(wm, adjustTestData); + lnaAdjustTestRslt = GetAverageTestRslt(wm, lnaAdjustTestData); + + if ((adjustTestRslt == null) || (lnaAdjustTestRslt == null)) + { + return CommErr.MissingTest; + } + + newCalibFactor = ihead.CalculateNewCalibFactor(adjustTestRslt, ihead.CalibFactor, factorLimitLo, factorLimitHi); + newCalibFactorLNA = ihead.CalculateNewCalibFactor(lnaAdjustTestRslt, ihead.CalibFactorLNA, lnaFactorLimitLo, lnaFactorLimitHi); + } + } + else if (arguments.Length == 2) + { + if (!wm.TryGetTestData(arguments[0], out adjustTestData) || + !wm.TryGetTestData(arguments[1], out lnaAdjustTestData)) + { + return CommErr.WrongArguments; + } + else + { + factorLimitLo = ihead.FactorLimitLo; + factorLimitHi = ihead.FactorLimitHi; + lnaFactorLimitLo = ihead.FactorLimitLo; + lnaFactorLimitHi = ihead.FactorLimitHi; + + adjustTestRslt = GetAverageTestRslt(wm, adjustTestData); + lnaAdjustTestRslt = GetAverageTestRslt(wm, lnaAdjustTestData); + + if ((adjustTestRslt == null) || (lnaAdjustTestRslt == null)) + { + return CommErr.MissingTest; + } + + newCalibFactor = ihead.CalculateNewCalibFactor(adjustTestRslt, ihead.CalibFactor, factorLimitLo, factorLimitHi); + newCalibFactorLNA = ihead.CalculateNewCalibFactor(lnaAdjustTestRslt, ihead.CalibFactorLNA, lnaFactorLimitLo, lnaFactorLimitHi); + } + } + else + { + return CommErr.WrongArguments; + } + } + else + { + return CommErr.WrongArguments; + } + + if (newCalibFactor == 0 || newCalibFactorLNA == 0) return CommErr.OutOfRange; + + /// + /// Start communication with iPerl + /// + CommErr error; + byte[] data = new byte[2] { (byte)(newCalibFactor & 0x00FF), (byte)((newCalibFactor >> 8) & 0x00FF) }; + byte[] dataLNA = new byte[2] { (byte)(newCalibFactorLNA & 0x00FF), (byte)((newCalibFactorLNA >> 8) & 0x00FF) }; + /// + /// Write the new calibration factor (up to cfg.MaxCommRetries tims) + /// + error = CommErr.Write; + if (0 == WriteRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 2, 2, data) && + 0 == WriteRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 34, 2, dataLNA)) + { + /// + /// Read and verify the calibration factor + /// + error = CommErr.ReadAfterWrite; + byte[] calib_2_3 = null; + byte[] calib_34_35 = null; + if (0 == ReadRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 2, 2, out calib_2_3) && + 0 == ReadRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 34, 2, out calib_34_35)) + { + error = CommErr.Verify; + if (calib_2_3 != null && calib_2_3.Length == 2 && data[0] == calib_2_3[0] && data[1] == calib_2_3[1] && + calib_34_35 != null && calib_34_35.Length == 2 && dataLNA[0] == calib_34_35[0] && dataLNA[1] == calib_34_35[1]) + { + error = CommErr.None; + ihead.CalibrationStructV4.Update(data, 2); + ihead.CalibrationStructV4.Update(dataLNA, 34); + wm.CalibFactor = newCalibFactor; + wm.CalibFactorLNA = newCalibFactorLNA; + resultStr = ihead.CalibrationStructV4.ToString(); + } + } + } + + ihead.CalibrationStructV4.Update(data, 2); + ihead.CalibrationStructV4.Update(dataLNA, 34); + + return error; + } + + + /// + /// Get averaged meter test result using test name and repetitions from a given test data. + /// + /// Water meter + /// TestData (name and repetitions) + /// (1) selected MeterTestRslt or (2) average of repeated MTR-s or (3) null when at least one MTR is missing + static Results.Entities.MeterTestRslt GetAverageTestRslt(WaterMeter wm, Results.Entities.TestData testData) + { + Results.Entities.MeterTestRslt avgTestRslt; + + if (testData.Repeats > 1) + { + /// Calculate a summarized test result if Repeats > 1 + avgTestRslt = new Results.Entities.MeterTestRslt(); + for (int i = 1; i <= testData.Repeats; i++) + { + Results.Entities.MeterTestRslt oneMTR = wm.GetMeterTestRslt(Utils.TestTitle(testData, i)); + if (oneMTR == null || !oneMTR.TestDone) return null; + + avgTestRslt.VolumeMeter += oneMTR.VolumeMeter; + avgTestRslt.VolumeRef += oneMTR.VolumeRef; + } + } + else + { + avgTestRslt = wm.GetMeterTestRslt(Utils.TestTitle(testData, 1)); + if (avgTestRslt == null || !avgTestRslt.TestDone) return null; + } + + return avgTestRslt; + } + + /// + /// Normalize calibration factor in case ti is close to value 8000. + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr NormalizeCalibrationFactor(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed || (ihead.CalibrationStruct == null)) return CommErr.CommFailed; + + if (ihead.FactorLimitLo <= ihead.CalibFactor && ihead.CalibFactor <= ihead.FactorLimitHi) + { + resultStr = "Calibration factor is OK"; + return CommErr.None; /// No need to update the calibration factor + } + + CommErr error = CommErr.Write; + + /// Determine the new calibration factor + UInt16 defaultCalibFactor; + switch (ihead.CalibrationStruct.MeterType) + { + case MeterType.DN15: + defaultCalibFactor = 2710; + break; + case MeterType.DN20: + defaultCalibFactor = 3746; + break; + case MeterType.DN25: + defaultCalibFactor = 3300; + break; + case MeterType.DN32: + defaultCalibFactor = 2500; + break; + case MeterType.DN40: + defaultCalibFactor = 3080; + break; + case MeterType.DN25_Q3_10: + case MeterType.CoaxManifold: + default: + defaultCalibFactor = 3040; + break; + } + + byte[] data = new byte[2] { (byte)(defaultCalibFactor & 0x00FF), (byte)((defaultCalibFactor >> 8) & 0x00FF) }; + if (0 == WriteRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 2, 2, data)) + { + error = CommErr.None; + ihead.CalibrationStruct.Update(data, 2); + } + + if (error == CommErr.None) + { + error = CommErr.Verify; + + /// Read calibration + byte[] calib_2_3 = null; + if (0 == ReadRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 2, 2, out calib_2_3)) + { + error = CommErr.None; + ihead.CalibrationStruct.Update(calib_2_3, 2); + resultStr = ihead.CalibrationStruct.ToString(); + } + } + + return error; + } + + + /// + /// Normalize calibration factor in case ti is close to value 8000. + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr NormalizeCalibrationV4Factors(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed || (ihead.CalibrationStructV4 == null)) return CommErr.CommFailed; + + if (ihead.FactorLimitLo <= ihead.CalibFactor && ihead.CalibFactor <= ihead.FactorLimitHi) + { + resultStr = "Calibratin factor is OK"; + return CommErr.None; /// No need to update the calibration factor + } + + CommErr error = CommErr.Write; + + /// Determine the new calibration factor + UInt16 defaultCalibFactor; + switch (ihead.CalibrationStructV4.MeterType) + { + case MeterType.DN15: + defaultCalibFactor = 2710; + break; + case MeterType.DN20: + defaultCalibFactor = 3746; + break; + case MeterType.DN25: + defaultCalibFactor = 3300; + break; + case MeterType.DN32: + defaultCalibFactor = 2500; + break; + case MeterType.DN40: + defaultCalibFactor = 3080; + break; + case MeterType.DN25_Q3_10: + case MeterType.CoaxManifold: + default: + defaultCalibFactor = 3040; + break; + } + + byte[] data = new byte[2] { (byte)(defaultCalibFactor & 0x00FF), (byte)((defaultCalibFactor >> 8) & 0x00FF) }; + if (0 == WriteRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 2, 2, data)) + { + error = CommErr.None; + ihead.CalibrationStructV4.Update(data, 2); + } + + if (error == CommErr.None) + { + error = CommErr.Verify; + + /// Read calibration + byte[] calib_2_3 = null; + if (0 == ReadRequestPort(ihead, MessageID.Calibration, StructName.Calibration, 2, 2, out calib_2_3)) + { + error = CommErr.None; + ihead.CalibrationStructV4.Update(calib_2_3, 2); + resultStr = ihead.CalibrationStructV4.ToString(); + } + } + + return error; + } + + + /// + /// Reset both Q2 correction factors in the memory to 0. + /// Read them back to verify factors were written correctly. + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr ReadQ2Correction(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed) return CommErr.CommFailed; + + CommErr error = CommErr.Read; + + /// Write zero Q2 correction + byte[] rdData = null; + /// + if (0 == ReadRequestPort(ihead, MessageID.MetrologyMemory, StructName.ProductionInfo, Q2CorrFactorsAddr, 2, out rdData)) + { + error = CommErr.None; + } + + if ((error == CommErr.None) && (rdData != null) && (rdData.Length == 2)) + { + resultStr = "Q2 corrections successfully read"; + wm.Q2CorrLR = ihead.Q2CorrLR = (int)((SByte)rdData[0]); + wm.Q2CorrRL = ihead.Q2CorrRL = (int)((SByte)rdData[1]); + } + + return error; + } + + /// + /// Reset both Q2 correction factors to 0. + /// Read them back to verify factors were written correctly. + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr ResetQ2Correction(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + return WriteQ2Corrections(threadId, ihead, wm, ref resultStr, 0, 0); + } + + /// + /// Set both Q2 correction factors to default values obtained by a REST service + /// Read them back to verify factors were written correctly. + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr WriteDefaultQ2Corrections(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed) return CommErr.CommFailed; + + if (ProcessData.IsQ2PreCorrectionCalculated) + { + return WriteQ2Corrections(threadId, ihead, wm, ref resultStr, ProcessData.CalculatedQ2PreCorrectionLR, + ProcessData.CalculatedQ2PreCorrectionRL); + } + else + { + int q2corrRL; + int q2corrLR; + switch (ihead.MeterType) + { + case MeterType.DN15: + q2corrRL = cfg.DfltQ2c_15_rl; + q2corrLR = cfg.DfltQ2c_15_lr; + break; + case MeterType.DN20: + q2corrRL = cfg.DfltQ2c_20_rl; + q2corrLR = cfg.DfltQ2c_20_lr; + break; + case MeterType.DN25: + q2corrRL = cfg.DfltQ2c_25_63_rl; + q2corrLR = cfg.DfltQ2c_25_63_lr; + break; + case MeterType.DN25_Q3_10: + q2corrRL = cfg.DfltQ2c_25_10_rl; + q2corrLR = cfg.DfltQ2c_25_10_lr; + break; + case MeterType.DN32: + q2corrRL = cfg.DfltQ2c_32_rl; + q2corrLR = cfg.DfltQ2c_32_lr; + break; + case MeterType.DN40: + q2corrRL = cfg.DfltQ2c_40_rl; + q2corrLR = cfg.DfltQ2c_40_lr; + break; + default: + q2corrRL = 0; + q2corrLR = 0; + break; + } + + return WriteQ2Corrections(threadId, ihead, wm, ref resultStr, q2corrLR, q2corrRL); + } + } + + /// + /// Write both Q2 correction factors to given values. + /// Read them back to verify factors were written correctly. + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr WriteQ2Corrections(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr, int factorLR, int factorRL) + { + if (ihead.CommFailed) return CommErr.CommFailed; + + CommErr error = CommErr.Write; + + /// Write zero Q2 correction + byte[] wrData = new byte[2] { (byte)factorLR, (byte)factorRL }; + /// + if (0 == WriteRequestPort(ihead, MessageID.MetrologyMemory, StructName.ProductionInfo, Q2CorrFactorsAddr, wrData.Length, wrData)) + { + wm.Q2CorrRL = ihead.Q2CorrRL = factorRL; + wm.Q2CorrLR = ihead.Q2CorrLR = factorLR; + error = CommErr.None; + } + + /// + /// Verification disabled on 16.02.2016 + /// +#if VERIFY_Q2_CORR_RESET + /// Verify the correction factors + if (error == CommErr.None) + { + error = CommErr.Verify; + + /// Read calibration + byte[] rdData = null; + if ((0 == ReadRequestPort(threadId, ihead, MessageID.MetrologyMemory, Q2CorrFactorsAddr, 2, out rdData)) && + (rdData != null) && (rdData.Length == 2) && (rdData[0] == 0) && (rdData[1] == 0)) + { + error = CommErr.None; + resultStr = string.Format("Q2 correction set to LR={0}, RL={1}", factorLR, factorRL); + } + } +#else + if (error == CommErr.None) + { + resultStr = string.Format("Q2 correction set to LR={0}, RL={1}", factorLR, factorRL); + } +#endif + + return error; + } + + + static CommErr InitOrReadQ2Corrections(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed) return CommErr.CommFailed; + if (wm.Pruefindex == 0) return CommErr.CommFailed; /// Unknown pruefindex + + if (wm.Pruefindex == 1) + { + int q2corrRL; + int q2corrLR; + if (ProcessData.IsQ2PreCorrectionCalculated) + { + q2corrRL = ProcessData.CalculatedQ2PreCorrectionRL; + q2corrLR = ProcessData.CalculatedQ2PreCorrectionLR; + } + else + { + switch (ihead.MeterType) + { + case MeterType.DN15: + q2corrRL = cfg.DfltQ2c_15_rl; + q2corrLR = cfg.DfltQ2c_15_lr; + break; + case MeterType.DN20: + q2corrRL = cfg.DfltQ2c_20_rl; + q2corrLR = cfg.DfltQ2c_20_lr; + break; + case MeterType.DN25: + q2corrRL = cfg.DfltQ2c_25_63_rl; + q2corrLR = cfg.DfltQ2c_25_63_lr; + break; + case MeterType.DN25_Q3_10: + q2corrRL = cfg.DfltQ2c_25_10_rl; + q2corrLR = cfg.DfltQ2c_25_10_lr; + break; + case MeterType.DN32: + q2corrRL = cfg.DfltQ2c_32_rl; + q2corrLR = cfg.DfltQ2c_32_lr; + break; + case MeterType.DN40: + q2corrRL = cfg.DfltQ2c_40_rl; + q2corrLR = cfg.DfltQ2c_40_lr; + break; + default: + q2corrRL = 0; + q2corrLR = 0; + break; + } + } + + return WriteQ2Corrections(threadId, ihead, wm, ref resultStr, q2corrLR, q2corrRL); + } + else + { + return ReadQ2Correction(threadId, ihead, wm, ref resultStr); + } + } + + + /// + /// Reset 2Hz correction factor in the memory to 0. + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr Reset2HzCorrection(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed) return CommErr.CommFailed; + + CommErr error = CommErr.Write; + + /// Write zero Q2 correction + byte[] wrData = new byte[1] { 0 }; + /// + if (0 == WriteRequestPort(ihead, MessageID.MetrologyMemory, StructName.ProductionInfo, Hz2CorrFactorsAddr, wrData.Length, wrData)) + { + error = CommErr.None; + } + + /// + /// Verification disabled on 16.02.2016 + /// +#if false + /// Verify the correction factors + if (error == CommErr.None) + { + error = CommErr.Verify; + + /// Read calibration + byte[] rdData = null; + if ((0 == ReadRequestPort(threadId, ihead, MessageID.MetrologyMemory, Hz2CorrFactorsAddr, 1, out rdData)) && + (rdData != null) && (rdData.Length == 2) && (rdData[0] == 0) && (rdData[1] == 0)) + { + error = CommErr.None; + resultStr = "2Hz correction reset to 0"; + ihead.Q2CorrectionFactor = 0; + } + } +#else + if (error == CommErr.None) + { + resultStr = "2Hz correction reset to 0"; + ihead.Hz2Correction = 0; + } +#endif + + return error; + } + + + /// + /// Write the calculated Q2 correction factors to the memory. + /// Read them back to verify factors were written correctly. + /// + /// Write Q2 correction + /// Write Q2 correction Alt + /// Write Q2 correction [Greece | R-L | L-R] testname + /// Update Q2 corrections + /// Conditional update of Q2 corrections + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr CalculateAndWriteQ2Corrections(int threadId, IperlHead ihead, WaterMeter wm, + Test test, ref string resultStr, Q2CorrType q2CorrType, string restOfLine) + { + var args = string.IsNullOrEmpty(restOfLine) ? new string[0] : restOfLine.Split(new char[] { ' ' }); + + Results.Entities.MeterTestRslt q2adjResult; /// The only test or the 1st test (the test in R-L direction) + Results.Entities.TestData q2adjTestData; /// The 2nd test in L-R direction in case tests in both directions are done + /// + if (args.Length == 0) + { + /// In case of no test name argument, ihead.LastTestResult is used (if it exists) + if (ihead.LastTestResult == null || !ihead.LastTestResult.TestDone) return CommErr.MissingTest; + q2adjResult = ihead.LastTestResult; + q2adjTestData = q2adjResult.TestRslt.TestData; + } + else // if (args.Length >= 1) + { + /// Get test data from (the 1st) test name + q2adjTestData = wm.GetTestData(args[0]); + if (q2adjTestData == null) return CommErr.MissingTest; + + if (q2adjTestData.Repeats == 1) + { + /// Find a test result if Repets == 1 + q2adjResult = wm.GetMeterTestRslt(args[0]); + if (q2adjResult == null || !q2adjResult.TestDone) return CommErr.MissingTest; + } + else + { + /// Calculate a summarized test result if Repeats > 1 + q2adjResult = new Results.Entities.MeterTestRslt(); + for (int i = 1; i <= q2adjTestData.Repeats; i++) + { + Results.Entities.MeterTestRslt oneMTR = wm.GetMeterTestRslt(string.Format("{0} ({1}/{2})", args[0], i, q2adjTestData.Repeats)); + if (oneMTR == null || !oneMTR.TestDone) return CommErr.MissingTest; + + q2adjResult.VolumeMeter += oneMTR.VolumeMeter; + q2adjResult.VolumeRef += oneMTR.VolumeRef; + + if (i == 1) + { + q2adjResult.CalibFactor = oneMTR.CalibFactor; + q2adjResult.CalibFactorLNA = oneMTR.CalibFactorLNA; + q2adjResult.Q2CorrRL = oneMTR.Q2CorrRL; + q2adjResult.Q2CorrLR = oneMTR.Q2CorrLR; + } + } + + q2adjResult.Error = Config.Formulas.ErrorFromVolumes(q2adjResult.VolumeMeter, q2adjResult.VolumeRef); + } + } + + var q3mtr = wm.MeterTestRslts.FirstOrDefault(x => x.Name() == "Q3"); + double q3error = (q3mtr != null) ? q3mtr.Error : 0; + + Results.Entities.MeterTestRslt q2adjResult2 = null; /// 2nd test name for a test in L-R direction + Results.Entities.TestData q2adjTestData2 = null; + /// + if (args.Length >= 2) + { + /// Get the 2nd test data from the 2nd test name + q2adjTestData2 = wm.GetTestData(args[1]); + if (q2adjTestData2 == null) return CommErr.MissingTest; + + if (q2adjTestData2.Repeats == 1) + { + /// Find a test result if Repets == 1 + q2adjResult2 = wm.GetMeterTestRslt(args[1]); + if (q2adjResult2 == null || !q2adjResult2.TestDone) return CommErr.MissingTest; + } + else + { + /// Calculate a summarized test result if Repeats > 1 + q2adjResult2 = new Results.Entities.MeterTestRslt(); + for (int i = 1; i <= q2adjTestData2.Repeats; i++) + { + Results.Entities.MeterTestRslt oneMTR = wm.GetMeterTestRslt(string.Format("{0} ({1}/{2})", args[1], i, q2adjTestData2.Repeats)); + if (oneMTR == null || !oneMTR.TestDone) return CommErr.MissingTest; + + q2adjResult2.VolumeMeter += oneMTR.VolumeMeter; + q2adjResult2.VolumeRef += oneMTR.VolumeRef; + + if (i == 1) + { + q2adjResult2.CalibFactor = oneMTR.CalibFactor; + q2adjResult2.CalibFactorLNA = oneMTR.CalibFactorLNA; + q2adjResult2.Q2CorrRL = oneMTR.Q2CorrRL; + q2adjResult2.Q2CorrLR = oneMTR.Q2CorrLR; + } + } + + q2adjResult2.Error = Config.Formulas.ErrorFromVolumes(q2adjResult2.VolumeMeter, q2adjResult2.VolumeRef); + } + } + + + if (q2adjResult == null || + ((q2CorrType == Q2CorrType.Update || q2CorrType == Q2CorrType.ConditionalUpdate) && q2adjResult2 == null)) + { + return CommErr.MissingTest; /// Procedure configuration error + } + + + if ((q2CorrType == Q2CorrType.ConditionalUpdate || + q2CorrType == Q2CorrType.ConditionalUpdateRL || + q2CorrType == Q2CorrType.ConditionalUpdateLR) && wm.PassedFromTests()) + { + resultStr = string.Format("No Q2 correction update"); + rfidDataLogger.InfoFormat("{0}({1}): No Q2 correction update", ihead.Name, ihead.SerialNr); + return CommErr.None; /// No Q2 correction when doing conditional update and WM passed + } + + double errLimitLo = test.ErrLimLo + test.Uncertainty; + double errLimitHi = test.ErrLimHi - test.Uncertainty; + + /// + /// Calculate Q2 correction factor(s) + /// + int q2CorrRL = 0; + int q2CorrLR = 0; + /// + if (q2CorrType == Q2CorrType.Standard || + q2CorrType == Q2CorrType.Standard_incl_05 || + q2CorrType == Q2CorrType.Standard_plus_incl_05) + { + /// + /// Standard process (RL) + /// No 2nd Q2 test, MakeQ2CorrectedFrom(...) is used to calculate Q2 error + /// Do not forget to modify iPerlCommunicationSeq.MakeQ2CorrectedFrom(...) + /// + double errorTarget = (q3error * q2adjResult.Error < 0) ? (0.1 * q2adjResult.Error) : (-0.1 * q2adjResult.Error); + q2CorrRL = Math.Max(-128, Math.Min(127, Convert.ToInt32(ihead.CalculateQ2CorrectionFactor(q2adjResult, q2adjResult.Q2CorrRL, q2adjTestData.Qfrom, errorTarget)))); + } + else if (q2CorrType == Q2CorrType.Dewa || + q2CorrType == Q2CorrType.Dewa_incl_05 || + q2CorrType == Q2CorrType.Dewa_plus_incl_05) + { + /// + /// Standard process for the oposite flow direction (LR) + /// No 2nd Q2 test, MakeQ2CorrectedFrom(...) is used to calculate Q2 error + /// Do not forget to modify iPerlCommunicationSeq.MakeQ2CorrectedFrom(...) + /// + double errorTarget = (q3error * q2adjResult.Error < 0) ? (0.1 * q2adjResult.Error) : (-0.1 * q2adjResult.Error); + q2CorrLR = Math.Max(-128, Math.Min(127, Convert.ToInt32(ihead.CalculateQ2CorrectionFactor(q2adjResult, q2adjResult.Q2CorrLR, q2adjTestData.Qfrom, errorTarget)))); + } + else if (q2CorrType == Q2CorrType.RL || + q2CorrType == Q2CorrType.RL_incl_05 || + q2CorrType == Q2CorrType.ConditionalUpdateRL) + { + /// + /// RL only + /// Assuming the 2nd Q2 test is done afterwards + /// MakeQ2CorrectedFrom(...) is not used + /// + if (q2CorrType == Q2CorrType.RL && Math.Abs(q2adjResult.Error) <= 0.5) + { + resultStr = string.Format("Q2 correction = 0 (writing bypassed)"); + return CommErr.None; + } + + q2CorrRL = Math.Max(-128, Math.Min(127, Convert.ToInt32(ihead.CalculateQ2CorrectionFactor(q2adjResult, q2adjResult.Q2CorrRL, q2adjTestData.Qfrom)))); + } + else if (q2CorrType == Q2CorrType.LR || + q2CorrType == Q2CorrType.LR_incl_05 || + q2CorrType == Q2CorrType.ConditionalUpdateLR) + { + /// + /// LR only + /// Assuming the 2nd Q2 test is done afterwards + /// MakeQ2CorrectedFrom(...) is not used + /// + if (q2CorrType == Q2CorrType.LR && Math.Abs(q2adjResult.Error) <= 0.5) + { + resultStr = string.Format("Q2 correction = 0 (writing bypassed)"); + return CommErr.None; + } + + q2CorrLR = Math.Max(-128, Math.Min(127, Convert.ToInt32(ihead.CalculateQ2CorrectionFactor(q2adjResult, q2adjResult.Q2CorrLR, q2adjTestData.Qfrom)))); + } + else if (q2CorrType == Q2CorrType.Update || q2CorrType == Q2CorrType.ConditionalUpdate) + { + /// + /// After tests in both directions + /// Assuming the 2nd Q2 tests are done afterwards + /// MakeQ2CorrectedFrom(...) is not used + /// + q2CorrRL = Math.Max(-128, Math.Min(127, Convert.ToInt32(ihead.CalculateQ2CorrectionFactor(q2adjResult, q2adjResult.Q2CorrRL, q2adjTestData.Qfrom)))); + q2CorrLR = Math.Max(-128, Math.Min(127, Convert.ToInt32(ihead.CalculateQ2CorrectionFactor(q2adjResult2, q2adjResult2.Q2CorrLR, q2adjTestData2.Qfrom)))); + } + else if (q2CorrType == Q2CorrType.Greece || q2CorrType == Q2CorrType.Greece_incl_05 || q2CorrType == Q2CorrType.UpdateBothQ2FactorsTestLRDir) + { + /// + /// Process for Greece + /// + if (q2CorrType == Q2CorrType.Greece && Math.Abs(q2adjResult.Error) <= 0.5) + { + resultStr = string.Format("Q2 correction = 0 (writing bypassed)"); + return CommErr.None; + } + + q2CorrLR = Math.Max(-128, Math.Min(127, Convert.ToInt32(ihead.CalculateQ2CorrectionFactor(q2adjResult, q2adjResult.Q2CorrLR, q2adjTestData.Qfrom)))); + q2CorrRL = q2CorrLR; + } + else if (q2CorrType == Q2CorrType.UpdateBothQ2FactorsTestRLDir) + { + /// + /// Another strange process + /// + double errorTarget = (q3error * q2adjResult.Error < 0) ? (0.1 * q2adjResult.Error) : (-0.1 * q2adjResult.Error); + q2CorrRL = Math.Max(-128, Math.Min(127, Convert.ToInt32(ihead.CalculateQ2CorrectionFactor(q2adjResult, q2adjResult.Q2CorrRL, q2adjTestData.Qfrom, errorTarget)))); + q2CorrLR = q2CorrRL; + } + + + /// + /// Write calculated Q2 correction factors into the water meter + /// + if (ihead.CommFailed) return CommErr.CommFailed; + + CommErr error = CommErr.Write; + + if (q2CorrType == Q2CorrType.Standard || + q2CorrType == Q2CorrType.Standard_incl_05 || + q2CorrType == Q2CorrType.Standard_plus_incl_05 || + q2CorrType == Q2CorrType.RL || + q2CorrType == Q2CorrType.RL_incl_05 || + q2CorrType == Q2CorrType.ConditionalUpdateRL) + { + /// + /// Write R-L Q2 correction factor only + /// + byte[] wrData = new byte[1] { (byte)q2CorrRL }; + if (0 == WriteRequestPort(ihead, MessageID.MetrologyMemory, StructName.ProductionInfo, Q2CorrFactorsAddrRL, wrData.Length, wrData)) + { + wm.Q2CorrRL = ihead.Q2CorrRL = q2CorrRL; + resultStr = string.Format("Q2 correction: RL={0}", q2CorrRL); + error = CommErr.None; + } + } + else if (q2CorrType == Q2CorrType.Dewa || + q2CorrType == Q2CorrType.Dewa_incl_05 || + q2CorrType == Q2CorrType.Dewa_plus_incl_05 || + q2CorrType == Q2CorrType.LR || + q2CorrType == Q2CorrType.LR_incl_05 || + q2CorrType == Q2CorrType.ConditionalUpdateLR) + { + /// + /// Write L-R Q2 correction factor only + /// + byte[] wrData = new byte[1] { (byte)q2CorrLR }; + if (0 == WriteRequestPort(ihead, MessageID.MetrologyMemory, StructName.ProductionInfo, Q2CorrFactorsAddrLR, wrData.Length, wrData)) + { + wm.Q2CorrLR = ihead.Q2CorrLR = q2CorrLR; + resultStr = string.Format("Q2 correction: LR={0}", q2CorrLR); + error = CommErr.None; + } + } + else + { + /// + /// Write both Q2 correction factors + /// + byte[] wrData = new byte[2] { (byte)q2CorrLR, (byte)q2CorrRL }; + if (0 == WriteRequestPort(ihead, MessageID.MetrologyMemory, StructName.ProductionInfo, Q2CorrFactorsAddr, wrData.Length, wrData)) + { + wm.Q2CorrRL = ihead.Q2CorrRL = q2CorrRL; + wm.Q2CorrLR = ihead.Q2CorrLR = q2CorrLR; + resultStr = string.Format("Q2 correction: RL={0}, LR={1}", q2CorrRL, q2CorrLR); + error = CommErr.None; + } + } + + + /// + /// Q2 correction factor was successfully written to the water meter. + /// Check whether the original error at Q2 was within limits. + /// + if (error == CommErr.None && + (q2adjResult.Error < errLimitLo || errLimitHi < q2adjResult.Error || + (q2adjResult2 != null && (q2adjResult2.Error < errLimitLo || errLimitHi < q2adjResult2.Error)))) + { + resultStr += " (OoR)"; + + /// At least one of Q2 errors is out of range for Q2 correction + log.WarnFormat("OoR => anyhow Q2 correction was done: Pos={0}, PCB#={1}, ***Q2_RL err={2}%***, ***Q2_LR err={3}%***, [Lo={4}%, Hi={5}%]", + ihead.Name, + ihead.SerialNr, + q2adjResult.Error.ToString("F2"), + q2adjResult2 != null ? q2adjResult2.Error.ToString("F2") : string.Empty, + errLimitLo.ToString("F2"), + errLimitHi.ToString("F2")); + + rfidDataLogger.InfoFormat("{0}({1}): Q2 error ({2},{3}) is out of range ({4}..{5}) => Failed", + ihead.Name, + ihead.SerialNr, + q2adjResult.Error.ToString("F2"), + q2adjResult2 != null ? q2adjResult2.Error.ToString("F2") : string.Empty, + errLimitLo.ToString("F2"), + errLimitHi.ToString("F2")); + + error = CommErr.Q2OutOfRange; + } + + /// + /// Verification disabled on 16.02.2016 + /// +#if false + if (error == CommErr.None) + { + error = CommErr.Verify; + + /// Read calibration + byte[] rdData = null; + if ((0 == ReadRequestPort(threadId, ihead, MessageID.MetrologyMemory, Q2CorrFactorsAddr, 2, out rdData)) && + (rdData != null) && (rdData.Length == 2) && (rdData[0] == q2CorrRFlow) && (rdData[1] == q2CorrLFlow)) + { + error = CommErr.None; + resultStr = string.Format("Q2 factors: R-flow={0}, L-flow={1}", (SByte)q2CorrRFlow, (SByte)q2CorrLFlow); + rfidDataLogger.Warn(ihead.Name + ": " + resultStr); + + wm.Q2ErrWOCorrection = ihead.Q2ErrorWOCorrection; + if (q2CorrType != Q2CorrType.LR) wm.Q2CorrRFlow = ihead.Q2CorrRFlow = (int)(sbyte)q2CorrRFlow; + if (q2CorrType != Q2CorrType.RL) wm.Q2CorrLFlow = ihead.Q2CorrLFlow = (int)(sbyte)q2CorrLFlow; + } + } +#else + + if ((q2CorrType != Q2CorrType.Update) && (q2CorrType != Q2CorrType.ConditionalUpdate)) + { + wm.Q2ErrWOCorrection = ihead.Q2ErrWOCorrection = q2adjResult.Error; + } + + /// + /// Update WaterMeter entity and IperlHead + /// + if (error == CommErr.None) + { + rfidDataLogger.WarnFormat("{0}({1}): {2}", ihead.Name, ihead.SerialNr, resultStr); + } +#endif + + return error; + } + + + /// + /// Write the calculated 2Hz correction factor to the memory. + /// + /// Water meter object + /// String passed to caller + /// true on success + static CommErr Write2HzCorrection(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed) return CommErr.CommFailed; + + /// Calculate the correction + ihead.Hz2CorrectionDone = false; + int hz2CorrectionFactor; + bool wmOK = ihead.Calculate2HzCorrectionFactor(ihead.LastTestResult2, ihead.LastTestResult, out ihead.Diff2Hz8Hz, out hz2CorrectionFactor); + + if (hz2CorrectionFactor == 0) + { + resultStr = string.Format("2Hz correction = 0 (writing bypassed)"); + return CommErr.None; + } + + CommErr error = CommErr.Write; + + Byte hz2CorrectionByte = (byte)(hz2CorrectionFactor & 0x000000FF); + byte[] wrData = new byte[1] { hz2CorrectionByte }; + /// + if (0 == WriteRequestPort(ihead, MessageID.MetrologyMemory, StructName.ProductionInfo, Hz2CorrFactorsAddr, wrData.Length, wrData)) + { + error = CommErr.None; + wm.Hz2Correction = ihead.Hz2Correction = hz2CorrectionFactor; + wm.Hz2CorrectionDone = ihead.Hz2CorrectionDone = true; + } + + /// + /// Verification disabled on 16.02.2016 + /// +#if false + if (error == CommErr.None) + { + error = CommErr.Verify; + + /// Read calibration + byte[] rdData = null; + if ((0 == ReadRequestPort(wm, MessageID.MetrologyMemory, Hz2CorrFactorsAddr, 1, out rdData)) && + (rdData != null) && (rdData.Length == 2) && (rdData[0] == hz2CorrectionByte)) + { + error = CommErr.None; + resultStr = string.Format("2Hz factor = {0}", (SByte)hz2CorrectionByte); + rfidDataLogger.Warn(ihead.Name + ": " + resultStr); + wm.Hz2Correction = ihead.Hz2CorrectionFactor = hz2CorrectionFactor; + wm.Diff2Hz8Hz = ihead.Diff2Hz8Hz; + wm.Hz2CorrectionDone = ihead.Hz2CorrectionDone; + } + } +#else + if (error == CommErr.None) + { + resultStr = string.Format("2Hz correction = {0}", (SByte)hz2CorrectionByte); + rfidDataLogger.Warn(ihead.Name + ": " + resultStr); + wm.Diff2Hz8Hz = ihead.Diff2Hz8Hz; + wm.Hz2CorrectionDone = ihead.Hz2CorrectionDone = true; + wm.Hz2Correction = ihead.Hz2Correction = hz2CorrectionFactor; + } +#endif + + return error; + } + + /// + /// DEWA rework. + /// + /// iPERL head object + /// Water meter object + /// Arrow direction + /// String passed to caller + /// true on success + static CommErr DewaRework(IperlHead ihead, WaterMeter wm, FlowDir flowDir, ref string resultStr) + { + if (ihead.CommFailed) return CommErr.CommFailed; + + byte arrow = (flowDir == FlowDir.L_R) ? (byte)1 : (byte)2; /// L-R is reverse flow (=1), R-L is forward flow (=2)(default) + + List dataToBeWritten = new List + { + new iPerlDataWrite(MessageID.MetrologyMemory, StructName.Calibration, ihead.CommInterface == CommunicationInterface.NFC? 33:0x19A1, new byte[] { (byte)0xA5 }, "Open Sealing"), // ????? + new iPerlDataWrite(MessageID.MetrologyMemory, StructName.Calibration, ihead.CommInterface == CommunicationInterface.NFC? 5:0x1985, new byte[] { arrow }, "Arrow"), + new iPerlDataWrite(MessageID.MetrologyMemory, StructName.Calibration, ihead.CommInterface == CommunicationInterface.NFC? 28:0x199C, new byte[5], "Clear S/N"), + new iPerlDataWrite(MessageID.Configuration, StructName.Configuration, 0x0015, new byte[] { (byte)0xA0 }, "Test mode config = A0"), + new iPerlDataWrite(MessageID.MetrologyMemory, StructName.Calibration, ihead.CommInterface == CommunicationInterface.NFC? 14:0x198E, new byte[] { (byte)(2510 & 0xFF), (byte)((2510 >> 8) & 0xFF) }, "Receipt mean current") + }; + + // check meter status: 1-Idle, 2-Active, 3-Test, 4-End Of Life + if (0 == ReadRequestPort(ihead, MessageID.Configuration, StructName.Configuration, 1, 1, out byte[] rdData)) + { + int eMeterState = (int)((SByte)rdData[0]); + switch (eMeterState) + { + case 1: // Idle -> Test -> Active + dataToBeWritten.Add(new iPerlDataWrite(MessageID.Command, StructName.Command, 0x0000, new byte[] { (byte)Command.SetTestMode }, "Set test mode")); + dataToBeWritten.Add(new iPerlDataWrite(MessageID.Command, StructName.Command, 0x0000, new byte[] { (byte)Command.SetActiveMode }, "Set active mode")); + break; + case 3: // Test Mode -> Active + dataToBeWritten.Add(new iPerlDataWrite(MessageID.Command, StructName.Command, 0x0000, new byte[] { (byte)Command.SetActiveMode }, "Set active mode")); + break; + } + } + + dataToBeWritten.Add(new iPerlDataWrite(MessageID.RadioPassthrough, StructName.RadioInfo, 0x1804, new byte[] { (byte)1 }, "System Status")); + dataToBeWritten.Add(new iPerlDataWrite(MessageID.RadioPassthrough, StructName.RadioParams, 0x1898, new byte[] { (byte)3 }, "WakeUpInterval")); + dataToBeWritten.Add(new iPerlDataWrite(MessageID.RadioPassthrough, StructName.RadioParams, 0x18A2, new byte[] { (byte)0x4A, (byte)0x53, (byte)0x3B, (byte)0x8F, + (byte)0x70, (byte)0x31, (byte)0xC2, (byte)0x5D, + (byte)0x6F, (byte)0x2D, (byte)0xE8, (byte)0x07, + (byte)0x6E, (byte)0x0F, (byte)0x97, (byte)0xC3, }, "AES Key Crypted")); + + int successfyllyWrittenFlags = 0; /// Ones in this word represent communication failures, LSB represents the first step + int mask = 1; + foreach (var wData in dataToBeWritten) + { + bool isSuccessfullyWritten = false; + if (0 == WriteRequestPort(ihead, wData.MessageID, wData.StructName, wData.Offset, wData.Data.Length, wData.Data)) + { + isSuccessfullyWritten = true; + } + + if (!isSuccessfullyWritten) + { + /// Communication failed in this step + successfyllyWrittenFlags = (successfyllyWrittenFlags | mask); + } + + mask = (mask << 1); /// Adjust the mask for the next step + } + + if (successfyllyWrittenFlags == 0) + { + /// Success + if (ihead.ConfigStruct != null) + { + ihead.ConfigStruct.MeterState = MeterState.Active; + ihead.ConfigStruct.TestModeConfig = (byte)0xA0; + } + + resultStr = "OK"; + return CommErr.None; + } + else + { + return CommErr.Write; + } + } + + /// + /// Start testing a sealed meter + /// + /// iPERL head object + /// Water meter object + /// String passed to caller + /// true on success + static CommErr StartTestingSealedMeter(IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed) return CommErr.CommFailed; + + Byte testModeConfig = 0xA0; /// Default value + /// + if (multiTestParams[currentActivityStep].Activity.Length > StartTestingSealedMetersStr.Length) + { + string testModeConfigStr = multiTestParams[currentActivityStep].Activity.Substring(StartTestingSealedMetersStr.Length + 1); + UInt16 byteVal; + if (UInt16.TryParse(testModeConfigStr, NumberStyles.HexNumber, CultureInfo.CurrentCulture, out byteVal) && byteVal <= 255) + { + testModeConfig = (Byte)byteVal; /// Update with specified value + } + } + + iPerlDataWrite[] dataToBeWritten = new iPerlDataWrite[] + { + new iPerlDataWrite(MessageID.MetrologyMemory, StructName.Calibration, ihead.CommInterface == CommunicationInterface.NFC? 33:0x19A1, new byte[] { (byte)0xA5 }, "Open Sealing"), /// 0x5A=sealed, 0xA5=unsealed ?????? + new iPerlDataWrite(MessageID.RadioPassthrough, StructName.RadioInfo, 0x1804, new byte[] { (byte)1 }, "System Status"), + new iPerlDataWrite(MessageID.Command, StructName.Command, 0x0000, new byte[] { (byte)Command.SetActiveMode }, "Set active mode"), + new iPerlDataWrite(MessageID.Configuration, StructName.Configuration, 0x0015, new byte[] { testModeConfig }, string.Format("Test mode config = {0:X2}", testModeConfig)), + }; + + if (ihead.ConfigStruct != null) ihead.OrigTestModeConfig = ihead.ConfigStruct.TestModeConfig; + + int successfyllyWrittenFlags = 0; /// Ones in this word represent communication failures, LSB represents the first step + int mask = 1; + foreach (var wData in dataToBeWritten) + { + bool isSuccessfullyWritten = false; + if (0 == WriteRequestPort(ihead, wData.MessageID, wData.StructName, wData.Offset, wData.Data.Length, wData.Data)) + { + isSuccessfullyWritten = true; + } + + if (!isSuccessfullyWritten) + { + /// Communication failed in this step + successfyllyWrittenFlags = (successfyllyWrittenFlags | mask); + } + + mask = (mask << 1); /// Adjust the mask for the next step + } + + if (successfyllyWrittenFlags == 0) + { + /// Success + if (ihead.ConfigStruct != null) + { + ihead.ConfigStruct.MeterState = MeterState.Active; + ihead.ConfigStruct.TestModeConfig = (byte)0xA0; + } + + resultStr = "OK"; + return CommErr.None; + } + else + { + return CommErr.Write; + } + } + + /// + /// End testing a sealed meter + /// + /// iPERL head object + /// Water meter object + /// String passed to caller + /// true on success + static CommErr EndTestingSealedMeter(IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (ihead.CommFailed) return CommErr.CommFailed; + + Byte testModeConfig = (ihead.OrigTestModeConfig != 0) ? ihead.OrigTestModeConfig : (byte)0x80; /// Restore original value (default is 0x80) + + iPerlDataWrite[] dataToBeWritten = new iPerlDataWrite[] + { + new iPerlDataWrite(MessageID.Command, StructName.Command, 0x0000, new byte[] { (byte)Command.SetActiveMode }, "Set active mode"), + new iPerlDataWrite(MessageID.Configuration, StructName.Configuration, 0x0015, new byte[] { testModeConfig }, string.Format("Test mode config = {0:X2}", testModeConfig)), + new iPerlDataWrite(MessageID.RadioPassthrough, StructName.RadioInfo, 0x1804, new byte[] { (byte)0 }, "System Status"), + new iPerlDataWrite(MessageID.MetrologyMemory, StructName.Calibration, ihead.CommInterface == CommunicationInterface.NFC? 33:0x19A1, new byte[] { (byte)0x5A }, "Close Sealing") /// 0x5A=sealed, 0xA5=unsealed ?????? + }; + + int successfyllyWrittenFlags = 0; /// Ones in this word represent communication failures, LSB represents the first step + int mask = 1; + foreach (var wData in dataToBeWritten) + { + bool isSuccessfullyWritten = false; + if (0 == WriteRequestPort(ihead, wData.MessageID, wData.StructName, wData.Offset, wData.Data.Length, wData.Data)) + { + isSuccessfullyWritten = true; + } + + if (!isSuccessfullyWritten) + { + /// Communication failed in this step + successfyllyWrittenFlags = (successfyllyWrittenFlags | mask); + } + + mask = (mask << 1); /// Adjust the mask for the next step + } + + if (successfyllyWrittenFlags == 0) + { + /// Success + if (ihead.ConfigStruct != null) + { + ihead.ConfigStruct.MeterState = MeterState.Active; + ihead.ConfigStruct.TestModeConfig = (byte)0xA0; + } + + resultStr = "OK"; + return CommErr.None; + } + else + { + return CommErr.Write; + } + } + + static CommErr GetQ2PreCorrectionsFormRest(int threadId, IperlHead ihead, WaterMeter wm, ref string resultStr) + { + if (!ProcessData.IsQ2PreCorrectionCalculated) + { + ProcessData.IsQ2PreCorrectionCalculated = true; + /*bool success = iPerlCommunicationSeq.GetQ2PreCorrectionsOrBackups(cfg, wm.WMTypeId(), + out ProcessData.CalculatedQ2PreCorrectionLR, + out ProcessData.CalculatedQ2PreCorrectionRL);*/ + } + + resultStr = string.Format("Q2 pre-corrections: LR={0} RL={1}", ProcessData.CalculatedQ2PreCorrectionLR, ProcessData.CalculatedQ2PreCorrectionRL); + return CommErr.None; + } + + static CommErr SetIperlCommMilestoneReached(TestMethod testMethod, ConditionID id, ref string resultStr) + { + if (id < ConditionID.A || id >= ConditionID.Count) + { + resultStr = Strings.Error; + return CommErr.WrongArguments; + } + + testMethod.IperlCommMilestone[(int)id] = true; + resultStr = string.Format(SequenceConditionOp.ConditionNameFmt, id); + return CommErr.None; + } + + static CommErr Simulate(IperlHead ihead, WaterMeter wm, ref string resultStr) + { + string[] arguments = multiTestParams[currentActivityStep].Activity.Split(new char[] { ' ' }); + + if (arguments.Length < 2 || arguments[1].ToLower() != "iperls") return CommErr.None; + + if (ihead.CommFailed) return CommErr.CommFailed; + + string[] pcbNrs = new string[] { "831232435539", "831232435562", + "831232435587", "831232432141", + "831232432497", "831232763641" }; + + if (wm.WMPosition > 0 && wm.WMPosition <= pcbNrs.Length) + { + ihead.SerialNr = wm.SerialNr = pcbNrs[wm.WMPosition - 1]; + } + + resultStr = string.Format("PCB Nr. = {0}", wm.SerialNr ?? ""); + return CommErr.None; + } + +#endif /// IPERL + + #endregion + + /// + /// Called when communication with one watermeter is completed + /// + public static void OnCommCompleted(object sender, CommCompletedEventArgs data) + { + if (CommCompletedHandler == null) return; + try { CommCompletedHandler(sender, data); } + catch (Exception e) { log.Error("CommCompletedHandler(...) failed", e); } + } + public static event EventHandler CommCompletedHandler; + + void DoOnCommCompleted(object sender, CommCompletedEventArgs data) + { + try + { + /// + /// Update the text message + /// + if (data.WMNr0 >= 0) messages[data.WMNr0].Text = data.CommMessage; + + /// + /// Update head active/inactive switch + /// + if (data.WMNr0 >= 0 && data.CommErr == CommErr.HeadDisabledByUser) + { + /// iPerl head was disabled by the user + ckbState[data.WMNr0] = false; + checkBoxes[data.WMNr0].Checked = false; + checkBoxes[data.WMNr0].Enabled = false; + if (data.Ihead != null) data.Ihead.Disabled = true; + if (data.Wm != null) data.Wm.Disabled = true; + } + else if (data.WMNr0 >= 0 && data.CommErr == CommErr.None) + { + /// One RFID communication successful => iPerl cannot be disabled by the user anymore + ckbState[data.WMNr0] = true; + checkBoxes[data.WMNr0].Checked = true; + checkBoxes[data.WMNr0].Enabled = false; + } + + /// + /// Update opto-communication indication + /// + for (int i = 0; i < iperlHeads.Count; i++) + { + if (iperlHeads[i] == null || iperlHeads[i].Disabled) + { + counters[i].BackColor = DisabledColor; + } + else + { + switch (iperlHeads[i].CheckFlowDirection()) + { + case OptoHeadState.OptoAndDirOK: + counters[i].BackColor = OptoAndDirOKColor; + break; + + case OptoHeadState.DirNok: + counters[i].BackColor = DirNokColor; + break; + + default: + case OptoHeadState.OptoNok: + counters[i].BackColor = OptoNokColor; + break; + } + } + } + +#if !TURA_SPECIAL + /// + /// Branch + /// + lock (this) + { + if (++completedCommCount < 4) return; + completedCommCount = 0; + } +#endif + + if (currentGroup < lastGroup) + { + /// Go to the next step / next group + currentGroup++; + } + else if (currentActivityStep + 1 < multiTestParams.Count) + { + currentGroup = 0; + currentActivityStep++; + activityLabel.Text = multiTestParams[currentActivityStep].Activity; + currentGroup++; + } + else + { + /// Wait until all threads are finished + workerThreads[data.ThreadId].Join(2000); + NormalClose(); + } + } + catch (Exception e) + { + log.ErrorFormat("DoOnCommCompleted({0}) failed: {1}", data, e.Message); + log.FatalFormat("StackTrace : {0}{1}", Environment.NewLine, e.StackTrace); + } + } + + + /// + /// Called when communication with all watermeters is completed + /// + public static void OnAllCompleted(object sender, AllCompletedEventArgs data) + { + if (AllCompletedHandler == null) return; + try { AllCompletedHandler(sender, data); } + catch (Exception e) { log.Error("AllCompletedHandler(...) failed", e); } + } + public static event EventHandler AllCompletedHandler; + + void DoOnAllCompleted(object sender, AllCompletedEventArgs data) + { + Text = data.CommMessage; + } + + /// + /// Update test result representing RFID communication success/failure + /// + /// + void UpdateRfidCommResult(IList tests) + { + DateTime endTime = DateTime.Now; + int testTime = StateMachine.Time - startTimeSec; + + if (!tests.Contains(StateMachine.TestInstances[0].Test)) + { + tests.Insert(0, StateMachine.TestInstances[0].Test); /// Add RFID test as the 1st item + } + + foreach (var test in tests) + { + Results.Entities.TestRslt tstRslt = ProcessData.BatchRslts.GetTestRslt(test.Name, test.Part); + + if (tstRslt != null) + { + Results.Utils.GetCounterStates(tstRslt, Program.LocalSettings.Counters); + + /// Auxiliary results ... not required + + /// Main results + tstRslt.MethodClass = TbfComponents.FindComponent(test.Method).ClassName; + tstRslt.TestDone = true; + tstRslt.StartTime = tstRslt.Batch.StartTime; + tstRslt.EndTime = endTime; + tstRslt.FlowSetTime = 0; + tstRslt.MassOfEvapWater = 0; + tstRslt.TestTime += testTime; /// [s] total communication time of all tests + + for (int i = 0; i < iperlHeads.Count; i++) + { + Results.Entities.MeterTestRslt meterRslt = + ProcessData.BatchRslts.GetMeterTestRslt(test.Name, waterMeterPositions0[i], CompoundMeterId.Single); + + if (meterRslt != null && iperlHeads[i] != null) + { + meterRslt.WaterMeter.SerialNr = iperlHeads[i].SerialNr; + meterRslt.Passed = (!iperlHeads[i].CommFailed && !iperlHeads[i].Disabled); + meterRslt.TestDone = true; + } + } + } + } + + UiBridge.Bridge.OnTestCompleted(this, new UiBridge.TestCompletedEventArgs(string.Empty, null)); + } + +#if IPERL + private MenuItem NewMenuItem(string text, string tag) + { + MenuItem menuItem = new MenuItem { Text = text, Tag = tag }; + menuItem.Click += OnClick_Optical_Heads_Settings_Menu; + return menuItem; + } + private async void OnClick_Optical_Heads_Settings_Menu(object sender, EventArgs e) + { + MenuItem menuItem = (MenuItem)sender; + activityLabel.Text = menuItem.Text; + List tasks = new List(); + foreach (var iHead in ProcessData.IperlHeads) + { + if (!checkBoxes[iHead.Position - 1].Checked) + { + if (iHead.Position - 1 < messages.Length) messages[iHead.Position - 1].Text = ""; + continue; + } + messages[iHead.Position - 1].Text = $"COM{iHead.RfidComPortNr}"; + Application.DoEvents(); // Refresh UI + tasks.Add(Task.Run(async () => + { + string result = await ProcessTask(iHead, menuItem.Tag); + this.Invoke((Action)(() => + { + messages[iHead.Position - 1].Text = result; + Application.DoEvents(); // Refresh UI + })); + + })); + + } + await Task.WhenAll(tasks); + } + + private async Task ProcessTask(IperlHead iHead, object tag) + { + string txt = ""; + switch (tag) + { + case "ReadPCB": + txt = OpticalHeadTest.ReadRequest_PCB(iHead); + break; + case "WriteRequestPort_u8_Customer_Text": + txt = OpticalHeadTest.WriteRequestPort_u8_Customer_Text(iHead); + break; + case "OpenSealing": + txt = OpticalHeadTest.OpenSealing(iHead); + break; + case "StartTestMode": + txt = OpticalHeadTest.SetTestMode(iHead); + break; + case "TurnOffTestMode": + txt = OpticalHeadTest.SetActiveMode(iHead); + break; + case "TurnOffRadio": + txt = OpticalHeadTest.TurnOffRadio(iHead); + break; + case "SetProductionMode": + txt = OpticalHeadTest.SetProductionMode(iHead); + break; + case "SetRFID": + txt = OpticalHeadTest.SetRfidMode(iHead); + break; + case "SetNFC": + txt = OpticalHeadTest.SetNfcMode(iHead); + break; + } + return txt; + } +#endif /// IPERL + + #region Check boxes edit mode support + + private void checkBoxImage1_Click(object sender, EventArgs e) { ckbState[ckbIndex[0]] = checkBoxImage1.Checked; } + private void checkBoxImage2_Click(object sender, EventArgs e) { ckbState[ckbIndex[1]] = checkBoxImage2.Checked; } + private void checkBoxImage3_Click(object sender, EventArgs e) { ckbState[ckbIndex[2]] = checkBoxImage3.Checked; } + private void checkBoxImage4_Click(object sender, EventArgs e) { ckbState[ckbIndex[3]] = checkBoxImage4.Checked; } + private void checkBoxImage5_Click(object sender, EventArgs e) { ckbState[ckbIndex[4]] = checkBoxImage5.Checked; } + private void checkBoxImage6_Click(object sender, EventArgs e) { ckbState[ckbIndex[5]] = checkBoxImage6.Checked; } + private void checkBoxImage7_Click(object sender, EventArgs e) { ckbState[ckbIndex[6]] = checkBoxImage7.Checked; } + private void checkBoxImage8_Click(object sender, EventArgs e) { ckbState[ckbIndex[7]] = checkBoxImage8.Checked; } + private void checkBoxImage9_Click(object sender, EventArgs e) { ckbState[ckbIndex[8]] = checkBoxImage9.Checked; } + private void checkBoxImage10_Click(object sender, EventArgs e) { ckbState[ckbIndex[9]] = checkBoxImage10.Checked; } + private void checkBoxImage11_Click(object sender, EventArgs e) { ckbState[ckbIndex[10]] = checkBoxImage11.Checked; } + private void checkBoxImage12_Click(object sender, EventArgs e) { ckbState[ckbIndex[11]] = checkBoxImage12.Checked; } + private void checkBoxImage13_Click(object sender, EventArgs e) { ckbState[ckbIndex[12]] = checkBoxImage13.Checked; } + private void checkBoxImage14_Click(object sender, EventArgs e) { ckbState[ckbIndex[13]] = checkBoxImage14.Checked; } + private void checkBoxImage15_Click(object sender, EventArgs e) { ckbState[ckbIndex[14]] = checkBoxImage15.Checked; } + private void checkBoxImage16_Click(object sender, EventArgs e) { ckbState[ckbIndex[15]] = checkBoxImage16.Checked; } + private void checkBoxImage17_Click(object sender, EventArgs e) { ckbState[ckbIndex[16]] = checkBoxImage17.Checked; } + private void checkBoxImage18_Click(object sender, EventArgs e) { ckbState[ckbIndex[17]] = checkBoxImage18.Checked; } + private void checkBoxImage19_Click(object sender, EventArgs e) { ckbState[ckbIndex[18]] = checkBoxImage19.Checked; } + private void checkBoxImage20_Click(object sender, EventArgs e) { ckbState[ckbIndex[19]] = checkBoxImage20.Checked; } + private void checkBoxImage21_Click(object sender, EventArgs e) { ckbState[ckbIndex[20]] = checkBoxImage21.Checked; } + private void checkBoxImage22_Click(object sender, EventArgs e) { ckbState[ckbIndex[21]] = checkBoxImage22.Checked; } + private void checkBoxImage23_Click(object sender, EventArgs e) { ckbState[ckbIndex[22]] = checkBoxImage23.Checked; } + private void checkBoxImage24_Click(object sender, EventArgs e) { ckbState[ckbIndex[23]] = checkBoxImage24.Checked; } + private void checkBoxImage25_Click(object sender, EventArgs e) { ckbState[ckbIndex[24]] = checkBoxImage25.Checked; } + private void checkBoxImage26_Click(object sender, EventArgs e) { ckbState[ckbIndex[25]] = checkBoxImage26.Checked; } + private void checkBoxImage27_Click(object sender, EventArgs e) { ckbState[ckbIndex[26]] = checkBoxImage27.Checked; } + private void checkBoxImage28_Click(object sender, EventArgs e) { ckbState[ckbIndex[27]] = checkBoxImage28.Checked; } + private void checkBoxImage29_Click(object sender, EventArgs e) { ckbState[ckbIndex[28]] = checkBoxImage29.Checked; } + private void checkBoxImage30_Click(object sender, EventArgs e) { ckbState[ckbIndex[29]] = checkBoxImage30.Checked; } + private void checkBoxImage31_Click(object sender, EventArgs e) { ckbState[ckbIndex[30]] = checkBoxImage31.Checked; } + private void checkBoxImage32_Click(object sender, EventArgs e) { ckbState[ckbIndex[31]] = checkBoxImage32.Checked; } + private void checkBoxImage33_Click(object sender, EventArgs e) { ckbState[ckbIndex[32]] = checkBoxImage33.Checked; } + private void checkBoxImage34_Click(object sender, EventArgs e) { ckbState[ckbIndex[33]] = checkBoxImage34.Checked; } + private void checkBoxImage35_Click(object sender, EventArgs e) { ckbState[ckbIndex[34]] = checkBoxImage35.Checked; } + private void checkBoxImage36_Click(object sender, EventArgs e) { ckbState[ckbIndex[35]] = checkBoxImage36.Checked; } + private void checkBoxImage37_Click(object sender, EventArgs e) { ckbState[ckbIndex[36]] = checkBoxImage37.Checked; } + private void checkBoxImage38_Click(object sender, EventArgs e) { ckbState[ckbIndex[37]] = checkBoxImage38.Checked; } + private void checkBoxImage39_Click(object sender, EventArgs e) { ckbState[ckbIndex[38]] = checkBoxImage39.Checked; } + private void checkBoxImage40_Click(object sender, EventArgs e) { ckbState[ckbIndex[39]] = checkBoxImage40.Checked; } + private void checkBoxImage41_Click(object sender, EventArgs e) { ckbState[ckbIndex[40]] = checkBoxImage41.Checked; } + private void checkBoxImage42_Click(object sender, EventArgs e) { ckbState[ckbIndex[41]] = checkBoxImage42.Checked; } + private void checkBoxImage43_Click(object sender, EventArgs e) { ckbState[ckbIndex[42]] = checkBoxImage43.Checked; } + private void checkBoxImage44_Click(object sender, EventArgs e) { ckbState[ckbIndex[43]] = checkBoxImage44.Checked; } + private void checkBoxImage45_Click(object sender, EventArgs e) { ckbState[ckbIndex[44]] = checkBoxImage45.Checked; } + private void checkBoxImage46_Click(object sender, EventArgs e) { ckbState[ckbIndex[45]] = checkBoxImage46.Checked; } + private void checkBoxImage47_Click(object sender, EventArgs e) { ckbState[ckbIndex[46]] = checkBoxImage47.Checked; } + private void checkBoxImage48_Click(object sender, EventArgs e) { ckbState[ckbIndex[47]] = checkBoxImage48.Checked; } + + /// + /// Get states of checkboxes as one bitfield (long) + /// + /// Long bitfield + private long GetCheckBoxStates() + { + long result = 0; + for (int i = 0; i < 48; i++) + { + int wmNr0 = ckbIndex[i]; + if (wmNr0 >= 0 && ckbState[wmNr0]) + { + result += (1L << wmNr0); + } + } + return result; + } + + /// + /// Set checkboxes to states stored in a bitfield (long) + /// + private void SetCheckBoxStates(long state) + { + CheckBoxImage[] chkBoxes = new CheckBoxImage[48] + { + checkBoxImage1, checkBoxImage2, checkBoxImage3, checkBoxImage4, checkBoxImage5, + checkBoxImage6, checkBoxImage7, checkBoxImage8, checkBoxImage9, checkBoxImage10, + checkBoxImage11, checkBoxImage12, checkBoxImage13, checkBoxImage14, checkBoxImage15, + checkBoxImage16, checkBoxImage17, checkBoxImage18, checkBoxImage19, checkBoxImage20, + checkBoxImage21, checkBoxImage22, checkBoxImage23, checkBoxImage24, checkBoxImage25, + checkBoxImage26, checkBoxImage27, checkBoxImage28, checkBoxImage29, checkBoxImage30, + checkBoxImage31, checkBoxImage32, checkBoxImage33, checkBoxImage34, checkBoxImage35, + checkBoxImage36, checkBoxImage37, checkBoxImage38, checkBoxImage39, checkBoxImage40, + checkBoxImage41, checkBoxImage42, checkBoxImage43, checkBoxImage44, checkBoxImage45, + checkBoxImage46, checkBoxImage47, checkBoxImage48, + }; + for (int i = 0; i < 48; i++) + { + int wmNr0 = ckbIndex[i]; + if (wmNr0 >= 0) + { + chkBoxes[i].Checked = ckbState[wmNr0] = ((state & (1L << wmNr0)) != 0); + } + } + } + + private void saveButton_Click(object sender, EventArgs e) + { + Program.LocalSettings.OptoHeadsEnabled = GetCheckBoxStates(); + Program.LocalSettings.Save(); + DialogResult = DialogResult.OK; + Close(); + } + + #endregion + + private void iPerlCommunicationForm_FormClosing(object sender, FormClosingEventArgs e) + { + if (!forcedClose && !formCompleted && !checkBoxesEditMode) + { + e.Cancel = true; + } + } + } +} diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.designer.cs b/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.designer.cs new file mode 100644 index 000000000..d21299f9b --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.designer.cs @@ -0,0 +1,2902 @@ +/// +/// Copyright (c) 2015 Sensus Metering Systems +/// Author: Milan Hanajík +/// +namespace TBF.Rig.RegisterReaders.iPerlReaderUNI.test +{ + partial class iPerlCommunicationForm + { + /// + /// 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(iPerlCommunicationForm)); + this.wmTextBox2 = new System.Windows.Forms.TextBox(); + this.wmLabel2 = new System.Windows.Forms.Label(); + this.wmLabel1 = new System.Windows.Forms.Label(); + this.wmTextBox3 = new System.Windows.Forms.TextBox(); + this.wmLabel3 = new System.Windows.Forms.Label(); + this.wmTextBox4 = new System.Windows.Forms.TextBox(); + this.wmLabel4 = new System.Windows.Forms.Label(); + this.wmTextBox5 = new System.Windows.Forms.TextBox(); + this.wmLabel5 = new System.Windows.Forms.Label(); + this.wmTextBox6 = new System.Windows.Forms.TextBox(); + this.wmLabel6 = new System.Windows.Forms.Label(); + this.wmTextBox1 = new System.Windows.Forms.TextBox(); + this.wmTextBox7 = new System.Windows.Forms.TextBox(); + this.wmLabel7 = new System.Windows.Forms.Label(); + this.wmTextBox8 = new System.Windows.Forms.TextBox(); + this.wmLabel8 = new System.Windows.Forms.Label(); + this.wmTextBox9 = new System.Windows.Forms.TextBox(); + this.wmLabel9 = new System.Windows.Forms.Label(); + this.wmTextBox10 = new System.Windows.Forms.TextBox(); + this.wmLabel10 = new System.Windows.Forms.Label(); + this.wmTextBox12 = new System.Windows.Forms.TextBox(); + this.wmLabel12 = new System.Windows.Forms.Label(); + this.wmTextBox11 = new System.Windows.Forms.TextBox(); + this.wmLabel11 = new System.Windows.Forms.Label(); + this.wmTextBox24 = new System.Windows.Forms.TextBox(); + this.wmLabel24 = new System.Windows.Forms.Label(); + this.wmTextBox23 = new System.Windows.Forms.TextBox(); + this.wmLabel23 = new System.Windows.Forms.Label(); + this.wmTextBox22 = new System.Windows.Forms.TextBox(); + this.wmLabel22 = new System.Windows.Forms.Label(); + this.wmTextBox21 = new System.Windows.Forms.TextBox(); + this.wmLabel21 = new System.Windows.Forms.Label(); + this.wmTextBox20 = new System.Windows.Forms.TextBox(); + this.wmLabel20 = new System.Windows.Forms.Label(); + this.wmTextBox19 = new System.Windows.Forms.TextBox(); + this.wmLabel19 = new System.Windows.Forms.Label(); + this.wmTextBox18 = new System.Windows.Forms.TextBox(); + this.wmLabel18 = new System.Windows.Forms.Label(); + this.wmTextBox17 = new System.Windows.Forms.TextBox(); + this.wmLabel17 = new System.Windows.Forms.Label(); + this.wmTextBox16 = new System.Windows.Forms.TextBox(); + this.wmLabel16 = new System.Windows.Forms.Label(); + this.wmTextBox15 = new System.Windows.Forms.TextBox(); + this.wmLabel15 = new System.Windows.Forms.Label(); + this.wmTextBox14 = new System.Windows.Forms.TextBox(); + this.wmLabel14 = new System.Windows.Forms.Label(); + this.wmTextBox13 = new System.Windows.Forms.TextBox(); + this.wmLabel13 = new System.Windows.Forms.Label(); + this.wmTextBox48 = new System.Windows.Forms.TextBox(); + this.wmLabel48 = new System.Windows.Forms.Label(); + this.wmTextBox47 = new System.Windows.Forms.TextBox(); + this.wmLabel47 = new System.Windows.Forms.Label(); + this.wmTextBox46 = new System.Windows.Forms.TextBox(); + this.wmLabel46 = new System.Windows.Forms.Label(); + this.wmTextBox45 = new System.Windows.Forms.TextBox(); + this.wmLabel45 = new System.Windows.Forms.Label(); + this.wmTextBox44 = new System.Windows.Forms.TextBox(); + this.wmLabel44 = new System.Windows.Forms.Label(); + this.wmTextBox43 = new System.Windows.Forms.TextBox(); + this.wmLabel43 = new System.Windows.Forms.Label(); + this.wmTextBox42 = new System.Windows.Forms.TextBox(); + this.wmLabel42 = new System.Windows.Forms.Label(); + this.wmTextBox41 = new System.Windows.Forms.TextBox(); + this.wmLabel41 = new System.Windows.Forms.Label(); + this.wmTextBox40 = new System.Windows.Forms.TextBox(); + this.wmLabel40 = new System.Windows.Forms.Label(); + this.wmTextBox39 = new System.Windows.Forms.TextBox(); + this.wmLabel39 = new System.Windows.Forms.Label(); + this.wmTextBox38 = new System.Windows.Forms.TextBox(); + this.wmLabel38 = new System.Windows.Forms.Label(); + this.wmTextBox37 = new System.Windows.Forms.TextBox(); + this.wmLabel37 = new System.Windows.Forms.Label(); + this.wmTextBox36 = new System.Windows.Forms.TextBox(); + this.wmLabel36 = new System.Windows.Forms.Label(); + this.wmTextBox35 = new System.Windows.Forms.TextBox(); + this.wmLabel35 = new System.Windows.Forms.Label(); + this.wmTextBox34 = new System.Windows.Forms.TextBox(); + this.wmLabel34 = new System.Windows.Forms.Label(); + this.wmTextBox33 = new System.Windows.Forms.TextBox(); + this.wmLabel33 = new System.Windows.Forms.Label(); + this.wmTextBox32 = new System.Windows.Forms.TextBox(); + this.wmLabel32 = new System.Windows.Forms.Label(); + this.wmTextBox31 = new System.Windows.Forms.TextBox(); + this.wmLabel31 = new System.Windows.Forms.Label(); + this.wmTextBox30 = new System.Windows.Forms.TextBox(); + this.wmLabel30 = new System.Windows.Forms.Label(); + this.wmTextBox29 = new System.Windows.Forms.TextBox(); + this.wmLabel29 = new System.Windows.Forms.Label(); + this.wmTextBox28 = new System.Windows.Forms.TextBox(); + this.wmLabel28 = new System.Windows.Forms.Label(); + this.wmTextBox27 = new System.Windows.Forms.TextBox(); + this.wmLabel27 = new System.Windows.Forms.Label(); + this.wmTextBox26 = new System.Windows.Forms.TextBox(); + this.wmLabel26 = new System.Windows.Forms.Label(); + this.wmTextBox25 = new System.Windows.Forms.TextBox(); + this.wmLabel25 = new System.Windows.Forms.Label(); + this.activityLabel = new System.Windows.Forms.Label(); + this.pictureBox48 = new System.Windows.Forms.PictureBox(); + this.pictureBox47 = new System.Windows.Forms.PictureBox(); + this.pictureBox46 = new System.Windows.Forms.PictureBox(); + this.pictureBox45 = new System.Windows.Forms.PictureBox(); + this.pictureBox44 = new System.Windows.Forms.PictureBox(); + this.pictureBox43 = new System.Windows.Forms.PictureBox(); + this.pictureBox42 = new System.Windows.Forms.PictureBox(); + this.pictureBox41 = new System.Windows.Forms.PictureBox(); + this.pictureBox40 = new System.Windows.Forms.PictureBox(); + this.pictureBox39 = new System.Windows.Forms.PictureBox(); + this.pictureBox38 = new System.Windows.Forms.PictureBox(); + this.pictureBox37 = new System.Windows.Forms.PictureBox(); + this.pictureBox36 = new System.Windows.Forms.PictureBox(); + this.pictureBox35 = new System.Windows.Forms.PictureBox(); + this.pictureBox34 = new System.Windows.Forms.PictureBox(); + this.pictureBox33 = new System.Windows.Forms.PictureBox(); + this.pictureBox32 = new System.Windows.Forms.PictureBox(); + this.pictureBox31 = new System.Windows.Forms.PictureBox(); + this.pictureBox30 = new System.Windows.Forms.PictureBox(); + this.pictureBox29 = new System.Windows.Forms.PictureBox(); + this.pictureBox28 = new System.Windows.Forms.PictureBox(); + this.pictureBox27 = new System.Windows.Forms.PictureBox(); + this.pictureBox26 = new System.Windows.Forms.PictureBox(); + this.pictureBox25 = new System.Windows.Forms.PictureBox(); + this.pictureBox24 = new System.Windows.Forms.PictureBox(); + this.pictureBox23 = new System.Windows.Forms.PictureBox(); + this.pictureBox22 = new System.Windows.Forms.PictureBox(); + this.pictureBox21 = new System.Windows.Forms.PictureBox(); + this.pictureBox20 = new System.Windows.Forms.PictureBox(); + this.pictureBox19 = new System.Windows.Forms.PictureBox(); + this.pictureBox18 = new System.Windows.Forms.PictureBox(); + this.pictureBox17 = new System.Windows.Forms.PictureBox(); + this.pictureBox16 = new System.Windows.Forms.PictureBox(); + this.pictureBox15 = new System.Windows.Forms.PictureBox(); + this.pictureBox14 = new System.Windows.Forms.PictureBox(); + this.pictureBox13 = new System.Windows.Forms.PictureBox(); + this.pictureBox12 = new System.Windows.Forms.PictureBox(); + this.pictureBox11 = new System.Windows.Forms.PictureBox(); + this.pictureBox10 = new System.Windows.Forms.PictureBox(); + this.pictureBox9 = new System.Windows.Forms.PictureBox(); + this.pictureBox8 = new System.Windows.Forms.PictureBox(); + this.pictureBox7 = new System.Windows.Forms.PictureBox(); + this.pictureBox6 = new System.Windows.Forms.PictureBox(); + this.pictureBox5 = new System.Windows.Forms.PictureBox(); + this.pictureBox4 = new System.Windows.Forms.PictureBox(); + this.pictureBox3 = new System.Windows.Forms.PictureBox(); + this.pictureBox2 = new System.Windows.Forms.PictureBox(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.saveButton = new System.Windows.Forms.Button(); + this.samplePictureBox1 = new System.Windows.Forms.PictureBox(); + this.samplePictureBox2 = new System.Windows.Forms.PictureBox(); + this.samplePictureBox3 = new System.Windows.Forms.PictureBox(); + this.sampleLabel1 = new System.Windows.Forms.Label(); + this.sampleLabel2 = new System.Windows.Forms.Label(); + this.sampleLabel3 = new System.Windows.Forms.Label(); + this.checkBoxImage48 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage47 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage46 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage45 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage44 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage43 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage42 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage41 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage40 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage39 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage38 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage37 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage36 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage35 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage34 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage33 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage32 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage31 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage30 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage29 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage28 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage27 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage26 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage25 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage24 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage23 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage22 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage21 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage20 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage19 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage18 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage17 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage16 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage15 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage14 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage13 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage12 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage11 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage10 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage9 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage8 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage7 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage6 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage5 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage4 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage3 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage2 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + this.checkBoxImage1 = new TBF.Rig.TestMethods.iPerlCommunication.CheckBoxImage(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox48)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox47)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox46)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox45)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox44)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox43)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox42)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox41)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox40)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox39)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox38)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox37)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox36)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox35)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox34)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox33)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox32)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox31)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox30)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox29)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox28)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox27)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox26)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox25)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox24)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox23)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox22)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox21)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox20)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox19)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox18)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox17)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox16)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox15)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox14)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox13)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox12)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox11)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox10)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox9)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox8)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox7)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox6)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox5)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox4)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox3)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.samplePictureBox1)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.samplePictureBox2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.samplePictureBox3)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage48)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage47)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage46)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage45)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage44)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage43)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage42)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage41)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage40)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage39)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage38)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage37)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage36)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage35)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage34)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage33)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage32)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage31)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage30)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage29)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage28)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage27)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage26)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage25)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage24)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage23)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage22)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage21)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage20)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage19)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage18)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage17)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage16)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage15)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage14)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage13)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage12)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage11)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage10)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage9)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage8)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage7)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage6)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage5)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage4)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage3)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage2)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage1)).BeginInit(); + this.SuspendLayout(); + // + // wmTextBox2 + // + this.wmTextBox2.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox2.Location = new System.Drawing.Point(160, 118); + this.wmTextBox2.Name = "wmTextBox2"; + this.wmTextBox2.Size = new System.Drawing.Size(380, 23); + this.wmTextBox2.TabIndex = 1; + this.wmTextBox2.Visible = false; + // + // wmLabel2 + // + this.wmLabel2.AutoSize = true; + this.wmLabel2.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel2.Location = new System.Drawing.Point(35, 124); + this.wmLabel2.Name = "wmLabel2"; + this.wmLabel2.Size = new System.Drawing.Size(16, 16); + this.wmLabel2.TabIndex = 0; + this.wmLabel2.Text = "2"; + this.wmLabel2.Visible = false; + // + // wmLabel1 + // + this.wmLabel1.AutoSize = true; + this.wmLabel1.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel1.Location = new System.Drawing.Point(35, 95); + this.wmLabel1.Name = "wmLabel1"; + this.wmLabel1.Size = new System.Drawing.Size(16, 16); + this.wmLabel1.TabIndex = 0; + this.wmLabel1.Text = "1"; + this.wmLabel1.Visible = false; + // + // wmTextBox3 + // + this.wmTextBox3.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox3.Location = new System.Drawing.Point(160, 147); + this.wmTextBox3.Name = "wmTextBox3"; + this.wmTextBox3.Size = new System.Drawing.Size(380, 23); + this.wmTextBox3.TabIndex = 1; + this.wmTextBox3.Visible = false; + // + // wmLabel3 + // + this.wmLabel3.AutoSize = true; + this.wmLabel3.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel3.Location = new System.Drawing.Point(35, 153); + this.wmLabel3.Name = "wmLabel3"; + this.wmLabel3.Size = new System.Drawing.Size(16, 16); + this.wmLabel3.TabIndex = 0; + this.wmLabel3.Text = "3"; + this.wmLabel3.Visible = false; + // + // wmTextBox4 + // + this.wmTextBox4.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox4.Location = new System.Drawing.Point(160, 176); + this.wmTextBox4.Name = "wmTextBox4"; + this.wmTextBox4.Size = new System.Drawing.Size(380, 23); + this.wmTextBox4.TabIndex = 1; + this.wmTextBox4.Visible = false; + // + // wmLabel4 + // + this.wmLabel4.AutoSize = true; + this.wmLabel4.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel4.Location = new System.Drawing.Point(35, 182); + this.wmLabel4.Name = "wmLabel4"; + this.wmLabel4.Size = new System.Drawing.Size(16, 16); + this.wmLabel4.TabIndex = 0; + this.wmLabel4.Text = "4"; + this.wmLabel4.Visible = false; + // + // wmTextBox5 + // + this.wmTextBox5.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox5.Location = new System.Drawing.Point(160, 205); + this.wmTextBox5.Name = "wmTextBox5"; + this.wmTextBox5.Size = new System.Drawing.Size(380, 23); + this.wmTextBox5.TabIndex = 1; + this.wmTextBox5.Visible = false; + // + // wmLabel5 + // + this.wmLabel5.AutoSize = true; + this.wmLabel5.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel5.Location = new System.Drawing.Point(35, 211); + this.wmLabel5.Name = "wmLabel5"; + this.wmLabel5.Size = new System.Drawing.Size(16, 16); + this.wmLabel5.TabIndex = 0; + this.wmLabel5.Text = "5"; + this.wmLabel5.Visible = false; + // + // wmTextBox6 + // + this.wmTextBox6.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox6.Location = new System.Drawing.Point(160, 234); + this.wmTextBox6.Name = "wmTextBox6"; + this.wmTextBox6.Size = new System.Drawing.Size(380, 23); + this.wmTextBox6.TabIndex = 1; + this.wmTextBox6.Visible = false; + // + // wmLabel6 + // + this.wmLabel6.AutoSize = true; + this.wmLabel6.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel6.Location = new System.Drawing.Point(35, 241); + this.wmLabel6.Name = "wmLabel6"; + this.wmLabel6.Size = new System.Drawing.Size(16, 16); + this.wmLabel6.TabIndex = 0; + this.wmLabel6.Text = "6"; + this.wmLabel6.Visible = false; + // + // wmTextBox1 + // + this.wmTextBox1.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox1.Location = new System.Drawing.Point(160, 89); + this.wmTextBox1.Name = "wmTextBox1"; + this.wmTextBox1.Size = new System.Drawing.Size(380, 23); + this.wmTextBox1.TabIndex = 1; + this.wmTextBox1.Visible = false; + // + // wmTextBox7 + // + this.wmTextBox7.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox7.Location = new System.Drawing.Point(160, 263); + this.wmTextBox7.Name = "wmTextBox7"; + this.wmTextBox7.Size = new System.Drawing.Size(380, 23); + this.wmTextBox7.TabIndex = 9; + this.wmTextBox7.Visible = false; + // + // wmLabel7 + // + this.wmLabel7.AutoSize = true; + this.wmLabel7.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel7.Location = new System.Drawing.Point(35, 270); + this.wmLabel7.Name = "wmLabel7"; + this.wmLabel7.Size = new System.Drawing.Size(16, 16); + this.wmLabel7.TabIndex = 8; + this.wmLabel7.Text = "7"; + this.wmLabel7.Visible = false; + // + // wmTextBox8 + // + this.wmTextBox8.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox8.Location = new System.Drawing.Point(160, 292); + this.wmTextBox8.Name = "wmTextBox8"; + this.wmTextBox8.Size = new System.Drawing.Size(380, 23); + this.wmTextBox8.TabIndex = 11; + this.wmTextBox8.Visible = false; + // + // wmLabel8 + // + this.wmLabel8.AutoSize = true; + this.wmLabel8.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel8.Location = new System.Drawing.Point(35, 299); + this.wmLabel8.Name = "wmLabel8"; + this.wmLabel8.Size = new System.Drawing.Size(16, 16); + this.wmLabel8.TabIndex = 10; + this.wmLabel8.Text = "8"; + this.wmLabel8.Visible = false; + // + // wmTextBox9 + // + this.wmTextBox9.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox9.Location = new System.Drawing.Point(160, 321); + this.wmTextBox9.Name = "wmTextBox9"; + this.wmTextBox9.Size = new System.Drawing.Size(380, 23); + this.wmTextBox9.TabIndex = 13; + this.wmTextBox9.Visible = false; + // + // wmLabel9 + // + this.wmLabel9.AutoSize = true; + this.wmLabel9.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel9.Location = new System.Drawing.Point(35, 327); + this.wmLabel9.Name = "wmLabel9"; + this.wmLabel9.Size = new System.Drawing.Size(16, 16); + this.wmLabel9.TabIndex = 12; + this.wmLabel9.Text = "9"; + this.wmLabel9.Visible = false; + // + // wmTextBox10 + // + this.wmTextBox10.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox10.Location = new System.Drawing.Point(160, 350); + this.wmTextBox10.Name = "wmTextBox10"; + this.wmTextBox10.Size = new System.Drawing.Size(380, 23); + this.wmTextBox10.TabIndex = 15; + this.wmTextBox10.Visible = false; + // + // wmLabel10 + // + this.wmLabel10.AutoSize = true; + this.wmLabel10.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel10.Location = new System.Drawing.Point(35, 356); + this.wmLabel10.Name = "wmLabel10"; + this.wmLabel10.Size = new System.Drawing.Size(24, 16); + this.wmLabel10.TabIndex = 14; + this.wmLabel10.Text = "10"; + this.wmLabel10.Visible = false; + // + // wmTextBox12 + // + this.wmTextBox12.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox12.Location = new System.Drawing.Point(160, 408); + this.wmTextBox12.Name = "wmTextBox12"; + this.wmTextBox12.Size = new System.Drawing.Size(380, 23); + this.wmTextBox12.TabIndex = 19; + this.wmTextBox12.Visible = false; + // + // wmLabel12 + // + this.wmLabel12.AutoSize = true; + this.wmLabel12.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel12.Location = new System.Drawing.Point(35, 414); + this.wmLabel12.Name = "wmLabel12"; + this.wmLabel12.Size = new System.Drawing.Size(24, 16); + this.wmLabel12.TabIndex = 18; + this.wmLabel12.Text = "12"; + this.wmLabel12.Visible = false; + // + // wmTextBox11 + // + this.wmTextBox11.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox11.Location = new System.Drawing.Point(160, 379); + this.wmTextBox11.Name = "wmTextBox11"; + this.wmTextBox11.Size = new System.Drawing.Size(380, 23); + this.wmTextBox11.TabIndex = 17; + this.wmTextBox11.Visible = false; + // + // wmLabel11 + // + this.wmLabel11.AutoSize = true; + this.wmLabel11.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel11.Location = new System.Drawing.Point(35, 385); + this.wmLabel11.Name = "wmLabel11"; + this.wmLabel11.Size = new System.Drawing.Size(24, 16); + this.wmLabel11.TabIndex = 16; + this.wmLabel11.Text = "11"; + this.wmLabel11.Visible = false; + // + // wmTextBox24 + // + this.wmTextBox24.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox24.Location = new System.Drawing.Point(160, 756); + this.wmTextBox24.Name = "wmTextBox24"; + this.wmTextBox24.Size = new System.Drawing.Size(380, 23); + this.wmTextBox24.TabIndex = 43; + this.wmTextBox24.Visible = false; + // + // wmLabel24 + // + this.wmLabel24.AutoSize = true; + this.wmLabel24.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel24.Location = new System.Drawing.Point(35, 762); + this.wmLabel24.Name = "wmLabel24"; + this.wmLabel24.Size = new System.Drawing.Size(24, 16); + this.wmLabel24.TabIndex = 42; + this.wmLabel24.Text = "24"; + this.wmLabel24.Visible = false; + // + // wmTextBox23 + // + this.wmTextBox23.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox23.Location = new System.Drawing.Point(160, 727); + this.wmTextBox23.Name = "wmTextBox23"; + this.wmTextBox23.Size = new System.Drawing.Size(380, 23); + this.wmTextBox23.TabIndex = 41; + this.wmTextBox23.Visible = false; + // + // wmLabel23 + // + this.wmLabel23.AutoSize = true; + this.wmLabel23.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel23.Location = new System.Drawing.Point(35, 733); + this.wmLabel23.Name = "wmLabel23"; + this.wmLabel23.Size = new System.Drawing.Size(24, 16); + this.wmLabel23.TabIndex = 40; + this.wmLabel23.Text = "23"; + this.wmLabel23.Visible = false; + // + // wmTextBox22 + // + this.wmTextBox22.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox22.Location = new System.Drawing.Point(160, 698); + this.wmTextBox22.Name = "wmTextBox22"; + this.wmTextBox22.Size = new System.Drawing.Size(380, 23); + this.wmTextBox22.TabIndex = 39; + this.wmTextBox22.Visible = false; + // + // wmLabel22 + // + this.wmLabel22.AutoSize = true; + this.wmLabel22.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel22.Location = new System.Drawing.Point(35, 704); + this.wmLabel22.Name = "wmLabel22"; + this.wmLabel22.Size = new System.Drawing.Size(24, 16); + this.wmLabel22.TabIndex = 38; + this.wmLabel22.Text = "22"; + this.wmLabel22.Visible = false; + // + // wmTextBox21 + // + this.wmTextBox21.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox21.Location = new System.Drawing.Point(160, 669); + this.wmTextBox21.Name = "wmTextBox21"; + this.wmTextBox21.Size = new System.Drawing.Size(380, 23); + this.wmTextBox21.TabIndex = 37; + this.wmTextBox21.Visible = false; + // + // wmLabel21 + // + this.wmLabel21.AutoSize = true; + this.wmLabel21.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel21.Location = new System.Drawing.Point(35, 675); + this.wmLabel21.Name = "wmLabel21"; + this.wmLabel21.Size = new System.Drawing.Size(24, 16); + this.wmLabel21.TabIndex = 36; + this.wmLabel21.Text = "21"; + this.wmLabel21.Visible = false; + // + // wmTextBox20 + // + this.wmTextBox20.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox20.Location = new System.Drawing.Point(160, 640); + this.wmTextBox20.Name = "wmTextBox20"; + this.wmTextBox20.Size = new System.Drawing.Size(380, 23); + this.wmTextBox20.TabIndex = 35; + this.wmTextBox20.Visible = false; + // + // wmLabel20 + // + this.wmLabel20.AutoSize = true; + this.wmLabel20.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel20.Location = new System.Drawing.Point(35, 647); + this.wmLabel20.Name = "wmLabel20"; + this.wmLabel20.Size = new System.Drawing.Size(24, 16); + this.wmLabel20.TabIndex = 34; + this.wmLabel20.Text = "20"; + this.wmLabel20.Visible = false; + // + // wmTextBox19 + // + this.wmTextBox19.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox19.Location = new System.Drawing.Point(160, 611); + this.wmTextBox19.Name = "wmTextBox19"; + this.wmTextBox19.Size = new System.Drawing.Size(380, 23); + this.wmTextBox19.TabIndex = 33; + this.wmTextBox19.Visible = false; + // + // wmLabel19 + // + this.wmLabel19.AutoSize = true; + this.wmLabel19.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel19.Location = new System.Drawing.Point(35, 618); + this.wmLabel19.Name = "wmLabel19"; + this.wmLabel19.Size = new System.Drawing.Size(24, 16); + this.wmLabel19.TabIndex = 32; + this.wmLabel19.Text = "19"; + this.wmLabel19.Visible = false; + // + // wmTextBox18 + // + this.wmTextBox18.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox18.Location = new System.Drawing.Point(160, 582); + this.wmTextBox18.Name = "wmTextBox18"; + this.wmTextBox18.Size = new System.Drawing.Size(380, 23); + this.wmTextBox18.TabIndex = 27; + this.wmTextBox18.Visible = false; + // + // wmLabel18 + // + this.wmLabel18.AutoSize = true; + this.wmLabel18.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel18.Location = new System.Drawing.Point(35, 589); + this.wmLabel18.Name = "wmLabel18"; + this.wmLabel18.Size = new System.Drawing.Size(24, 16); + this.wmLabel18.TabIndex = 23; + this.wmLabel18.Text = "18"; + this.wmLabel18.Visible = false; + // + // wmTextBox17 + // + this.wmTextBox17.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox17.Location = new System.Drawing.Point(160, 553); + this.wmTextBox17.Name = "wmTextBox17"; + this.wmTextBox17.Size = new System.Drawing.Size(380, 23); + this.wmTextBox17.TabIndex = 26; + this.wmTextBox17.Visible = false; + // + // wmLabel17 + // + this.wmLabel17.AutoSize = true; + this.wmLabel17.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel17.Location = new System.Drawing.Point(35, 559); + this.wmLabel17.Name = "wmLabel17"; + this.wmLabel17.Size = new System.Drawing.Size(24, 16); + this.wmLabel17.TabIndex = 22; + this.wmLabel17.Text = "17"; + this.wmLabel17.Visible = false; + // + // wmTextBox16 + // + this.wmTextBox16.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox16.Location = new System.Drawing.Point(160, 524); + this.wmTextBox16.Name = "wmTextBox16"; + this.wmTextBox16.Size = new System.Drawing.Size(380, 23); + this.wmTextBox16.TabIndex = 30; + this.wmTextBox16.Visible = false; + // + // wmLabel16 + // + this.wmLabel16.AutoSize = true; + this.wmLabel16.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel16.Location = new System.Drawing.Point(35, 530); + this.wmLabel16.Name = "wmLabel16"; + this.wmLabel16.Size = new System.Drawing.Size(24, 16); + this.wmLabel16.TabIndex = 21; + this.wmLabel16.Text = "16"; + this.wmLabel16.Visible = false; + // + // wmTextBox15 + // + this.wmTextBox15.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox15.Location = new System.Drawing.Point(160, 495); + this.wmTextBox15.Name = "wmTextBox15"; + this.wmTextBox15.Size = new System.Drawing.Size(380, 23); + this.wmTextBox15.TabIndex = 31; + this.wmTextBox15.Visible = false; + // + // wmLabel15 + // + this.wmLabel15.AutoSize = true; + this.wmLabel15.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel15.Location = new System.Drawing.Point(35, 501); + this.wmLabel15.Name = "wmLabel15"; + this.wmLabel15.Size = new System.Drawing.Size(24, 16); + this.wmLabel15.TabIndex = 20; + this.wmLabel15.Text = "15"; + this.wmLabel15.Visible = false; + // + // wmTextBox14 + // + this.wmTextBox14.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox14.Location = new System.Drawing.Point(160, 466); + this.wmTextBox14.Name = "wmTextBox14"; + this.wmTextBox14.Size = new System.Drawing.Size(380, 23); + this.wmTextBox14.TabIndex = 28; + this.wmTextBox14.Visible = false; + // + // wmLabel14 + // + this.wmLabel14.AutoSize = true; + this.wmLabel14.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel14.Location = new System.Drawing.Point(35, 472); + this.wmLabel14.Name = "wmLabel14"; + this.wmLabel14.Size = new System.Drawing.Size(24, 16); + this.wmLabel14.TabIndex = 25; + this.wmLabel14.Text = "14"; + this.wmLabel14.Visible = false; + // + // wmTextBox13 + // + this.wmTextBox13.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox13.Location = new System.Drawing.Point(160, 437); + this.wmTextBox13.Name = "wmTextBox13"; + this.wmTextBox13.Size = new System.Drawing.Size(380, 23); + this.wmTextBox13.TabIndex = 29; + this.wmTextBox13.Visible = false; + // + // wmLabel13 + // + this.wmLabel13.AutoSize = true; + this.wmLabel13.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel13.Location = new System.Drawing.Point(35, 443); + this.wmLabel13.Name = "wmLabel13"; + this.wmLabel13.Size = new System.Drawing.Size(24, 16); + this.wmLabel13.TabIndex = 24; + this.wmLabel13.Text = "13"; + this.wmLabel13.Visible = false; + // + // wmTextBox48 + // + this.wmTextBox48.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox48.Location = new System.Drawing.Point(720, 756); + this.wmTextBox48.Name = "wmTextBox48"; + this.wmTextBox48.Size = new System.Drawing.Size(380, 23); + this.wmTextBox48.TabIndex = 94; + this.wmTextBox48.Visible = false; + // + // wmLabel48 + // + this.wmLabel48.AutoSize = true; + this.wmLabel48.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel48.Location = new System.Drawing.Point(595, 762); + this.wmLabel48.Name = "wmLabel48"; + this.wmLabel48.Size = new System.Drawing.Size(24, 16); + this.wmLabel48.TabIndex = 93; + this.wmLabel48.Text = "48"; + this.wmLabel48.Visible = false; + // + // wmTextBox47 + // + this.wmTextBox47.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox47.Location = new System.Drawing.Point(720, 727); + this.wmTextBox47.Name = "wmTextBox47"; + this.wmTextBox47.Size = new System.Drawing.Size(380, 23); + this.wmTextBox47.TabIndex = 92; + this.wmTextBox47.Visible = false; + // + // wmLabel47 + // + this.wmLabel47.AutoSize = true; + this.wmLabel47.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel47.Location = new System.Drawing.Point(595, 733); + this.wmLabel47.Name = "wmLabel47"; + this.wmLabel47.Size = new System.Drawing.Size(24, 16); + this.wmLabel47.TabIndex = 91; + this.wmLabel47.Text = "47"; + this.wmLabel47.Visible = false; + // + // wmTextBox46 + // + this.wmTextBox46.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox46.Location = new System.Drawing.Point(720, 698); + this.wmTextBox46.Name = "wmTextBox46"; + this.wmTextBox46.Size = new System.Drawing.Size(380, 23); + this.wmTextBox46.TabIndex = 90; + this.wmTextBox46.Visible = false; + // + // wmLabel46 + // + this.wmLabel46.AutoSize = true; + this.wmLabel46.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel46.Location = new System.Drawing.Point(595, 704); + this.wmLabel46.Name = "wmLabel46"; + this.wmLabel46.Size = new System.Drawing.Size(24, 16); + this.wmLabel46.TabIndex = 89; + this.wmLabel46.Text = "46"; + this.wmLabel46.Visible = false; + // + // wmTextBox45 + // + this.wmTextBox45.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox45.Location = new System.Drawing.Point(720, 669); + this.wmTextBox45.Name = "wmTextBox45"; + this.wmTextBox45.Size = new System.Drawing.Size(380, 23); + this.wmTextBox45.TabIndex = 88; + this.wmTextBox45.Visible = false; + // + // wmLabel45 + // + this.wmLabel45.AutoSize = true; + this.wmLabel45.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel45.Location = new System.Drawing.Point(595, 675); + this.wmLabel45.Name = "wmLabel45"; + this.wmLabel45.Size = new System.Drawing.Size(24, 16); + this.wmLabel45.TabIndex = 87; + this.wmLabel45.Text = "45"; + this.wmLabel45.Visible = false; + // + // wmTextBox44 + // + this.wmTextBox44.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox44.Location = new System.Drawing.Point(720, 640); + this.wmTextBox44.Name = "wmTextBox44"; + this.wmTextBox44.Size = new System.Drawing.Size(380, 23); + this.wmTextBox44.TabIndex = 86; + this.wmTextBox44.Visible = false; + // + // wmLabel44 + // + this.wmLabel44.AutoSize = true; + this.wmLabel44.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel44.Location = new System.Drawing.Point(595, 647); + this.wmLabel44.Name = "wmLabel44"; + this.wmLabel44.Size = new System.Drawing.Size(24, 16); + this.wmLabel44.TabIndex = 85; + this.wmLabel44.Text = "44"; + this.wmLabel44.Visible = false; + // + // wmTextBox43 + // + this.wmTextBox43.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox43.Location = new System.Drawing.Point(720, 611); + this.wmTextBox43.Name = "wmTextBox43"; + this.wmTextBox43.Size = new System.Drawing.Size(380, 23); + this.wmTextBox43.TabIndex = 84; + this.wmTextBox43.Visible = false; + // + // wmLabel43 + // + this.wmLabel43.AutoSize = true; + this.wmLabel43.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel43.Location = new System.Drawing.Point(595, 618); + this.wmLabel43.Name = "wmLabel43"; + this.wmLabel43.Size = new System.Drawing.Size(24, 16); + this.wmLabel43.TabIndex = 83; + this.wmLabel43.Text = "43"; + this.wmLabel43.Visible = false; + // + // wmTextBox42 + // + this.wmTextBox42.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox42.Location = new System.Drawing.Point(720, 582); + this.wmTextBox42.Name = "wmTextBox42"; + this.wmTextBox42.Size = new System.Drawing.Size(380, 23); + this.wmTextBox42.TabIndex = 78; + this.wmTextBox42.Visible = false; + // + // wmLabel42 + // + this.wmLabel42.AutoSize = true; + this.wmLabel42.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel42.Location = new System.Drawing.Point(595, 589); + this.wmLabel42.Name = "wmLabel42"; + this.wmLabel42.Size = new System.Drawing.Size(24, 16); + this.wmLabel42.TabIndex = 74; + this.wmLabel42.Text = "42"; + this.wmLabel42.Visible = false; + // + // wmTextBox41 + // + this.wmTextBox41.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox41.Location = new System.Drawing.Point(720, 553); + this.wmTextBox41.Name = "wmTextBox41"; + this.wmTextBox41.Size = new System.Drawing.Size(380, 23); + this.wmTextBox41.TabIndex = 77; + this.wmTextBox41.Visible = false; + // + // wmLabel41 + // + this.wmLabel41.AutoSize = true; + this.wmLabel41.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel41.Location = new System.Drawing.Point(595, 559); + this.wmLabel41.Name = "wmLabel41"; + this.wmLabel41.Size = new System.Drawing.Size(24, 16); + this.wmLabel41.TabIndex = 73; + this.wmLabel41.Text = "41"; + this.wmLabel41.Visible = false; + // + // wmTextBox40 + // + this.wmTextBox40.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox40.Location = new System.Drawing.Point(720, 524); + this.wmTextBox40.Name = "wmTextBox40"; + this.wmTextBox40.Size = new System.Drawing.Size(380, 23); + this.wmTextBox40.TabIndex = 81; + this.wmTextBox40.Visible = false; + // + // wmLabel40 + // + this.wmLabel40.AutoSize = true; + this.wmLabel40.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel40.Location = new System.Drawing.Point(595, 530); + this.wmLabel40.Name = "wmLabel40"; + this.wmLabel40.Size = new System.Drawing.Size(24, 16); + this.wmLabel40.TabIndex = 72; + this.wmLabel40.Text = "40"; + this.wmLabel40.Visible = false; + // + // wmTextBox39 + // + this.wmTextBox39.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox39.Location = new System.Drawing.Point(720, 495); + this.wmTextBox39.Name = "wmTextBox39"; + this.wmTextBox39.Size = new System.Drawing.Size(380, 23); + this.wmTextBox39.TabIndex = 82; + this.wmTextBox39.Visible = false; + // + // wmLabel39 + // + this.wmLabel39.AutoSize = true; + this.wmLabel39.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel39.Location = new System.Drawing.Point(595, 501); + this.wmLabel39.Name = "wmLabel39"; + this.wmLabel39.Size = new System.Drawing.Size(24, 16); + this.wmLabel39.TabIndex = 71; + this.wmLabel39.Text = "39"; + this.wmLabel39.Visible = false; + // + // wmTextBox38 + // + this.wmTextBox38.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox38.Location = new System.Drawing.Point(720, 466); + this.wmTextBox38.Name = "wmTextBox38"; + this.wmTextBox38.Size = new System.Drawing.Size(380, 23); + this.wmTextBox38.TabIndex = 79; + this.wmTextBox38.Visible = false; + // + // wmLabel38 + // + this.wmLabel38.AutoSize = true; + this.wmLabel38.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel38.Location = new System.Drawing.Point(595, 472); + this.wmLabel38.Name = "wmLabel38"; + this.wmLabel38.Size = new System.Drawing.Size(24, 16); + this.wmLabel38.TabIndex = 76; + this.wmLabel38.Text = "38"; + this.wmLabel38.Visible = false; + // + // wmTextBox37 + // + this.wmTextBox37.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox37.Location = new System.Drawing.Point(720, 437); + this.wmTextBox37.Name = "wmTextBox37"; + this.wmTextBox37.Size = new System.Drawing.Size(380, 23); + this.wmTextBox37.TabIndex = 80; + this.wmTextBox37.Visible = false; + // + // wmLabel37 + // + this.wmLabel37.AutoSize = true; + this.wmLabel37.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel37.Location = new System.Drawing.Point(595, 443); + this.wmLabel37.Name = "wmLabel37"; + this.wmLabel37.Size = new System.Drawing.Size(24, 16); + this.wmLabel37.TabIndex = 75; + this.wmLabel37.Text = "37"; + this.wmLabel37.Visible = false; + // + // wmTextBox36 + // + this.wmTextBox36.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox36.Location = new System.Drawing.Point(720, 408); + this.wmTextBox36.Name = "wmTextBox36"; + this.wmTextBox36.Size = new System.Drawing.Size(380, 23); + this.wmTextBox36.TabIndex = 70; + this.wmTextBox36.Visible = false; + // + // wmLabel36 + // + this.wmLabel36.AutoSize = true; + this.wmLabel36.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel36.Location = new System.Drawing.Point(595, 414); + this.wmLabel36.Name = "wmLabel36"; + this.wmLabel36.Size = new System.Drawing.Size(24, 16); + this.wmLabel36.TabIndex = 69; + this.wmLabel36.Text = "36"; + this.wmLabel36.Visible = false; + // + // wmTextBox35 + // + this.wmTextBox35.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox35.Location = new System.Drawing.Point(720, 379); + this.wmTextBox35.Name = "wmTextBox35"; + this.wmTextBox35.Size = new System.Drawing.Size(380, 23); + this.wmTextBox35.TabIndex = 68; + this.wmTextBox35.Visible = false; + // + // wmLabel35 + // + this.wmLabel35.AutoSize = true; + this.wmLabel35.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel35.Location = new System.Drawing.Point(595, 385); + this.wmLabel35.Name = "wmLabel35"; + this.wmLabel35.Size = new System.Drawing.Size(24, 16); + this.wmLabel35.TabIndex = 67; + this.wmLabel35.Text = "35"; + this.wmLabel35.Visible = false; + // + // wmTextBox34 + // + this.wmTextBox34.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox34.Location = new System.Drawing.Point(720, 350); + this.wmTextBox34.Name = "wmTextBox34"; + this.wmTextBox34.Size = new System.Drawing.Size(380, 23); + this.wmTextBox34.TabIndex = 66; + this.wmTextBox34.Visible = false; + // + // wmLabel34 + // + this.wmLabel34.AutoSize = true; + this.wmLabel34.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel34.Location = new System.Drawing.Point(595, 356); + this.wmLabel34.Name = "wmLabel34"; + this.wmLabel34.Size = new System.Drawing.Size(24, 16); + this.wmLabel34.TabIndex = 65; + this.wmLabel34.Text = "34"; + this.wmLabel34.Visible = false; + // + // wmTextBox33 + // + this.wmTextBox33.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox33.Location = new System.Drawing.Point(720, 321); + this.wmTextBox33.Name = "wmTextBox33"; + this.wmTextBox33.Size = new System.Drawing.Size(380, 23); + this.wmTextBox33.TabIndex = 64; + this.wmTextBox33.Visible = false; + // + // wmLabel33 + // + this.wmLabel33.AutoSize = true; + this.wmLabel33.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel33.Location = new System.Drawing.Point(595, 327); + this.wmLabel33.Name = "wmLabel33"; + this.wmLabel33.Size = new System.Drawing.Size(24, 16); + this.wmLabel33.TabIndex = 63; + this.wmLabel33.Text = "33"; + this.wmLabel33.Visible = false; + // + // wmTextBox32 + // + this.wmTextBox32.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox32.Location = new System.Drawing.Point(720, 292); + this.wmTextBox32.Name = "wmTextBox32"; + this.wmTextBox32.Size = new System.Drawing.Size(380, 23); + this.wmTextBox32.TabIndex = 62; + this.wmTextBox32.Visible = false; + // + // wmLabel32 + // + this.wmLabel32.AutoSize = true; + this.wmLabel32.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel32.Location = new System.Drawing.Point(595, 299); + this.wmLabel32.Name = "wmLabel32"; + this.wmLabel32.Size = new System.Drawing.Size(24, 16); + this.wmLabel32.TabIndex = 61; + this.wmLabel32.Text = "32"; + this.wmLabel32.Visible = false; + // + // wmTextBox31 + // + this.wmTextBox31.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox31.Location = new System.Drawing.Point(720, 263); + this.wmTextBox31.Name = "wmTextBox31"; + this.wmTextBox31.Size = new System.Drawing.Size(380, 23); + this.wmTextBox31.TabIndex = 60; + this.wmTextBox31.Visible = false; + // + // wmLabel31 + // + this.wmLabel31.AutoSize = true; + this.wmLabel31.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel31.Location = new System.Drawing.Point(595, 270); + this.wmLabel31.Name = "wmLabel31"; + this.wmLabel31.Size = new System.Drawing.Size(24, 16); + this.wmLabel31.TabIndex = 59; + this.wmLabel31.Text = "31"; + this.wmLabel31.Visible = false; + // + // wmTextBox30 + // + this.wmTextBox30.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox30.Location = new System.Drawing.Point(720, 234); + this.wmTextBox30.Name = "wmTextBox30"; + this.wmTextBox30.Size = new System.Drawing.Size(380, 23); + this.wmTextBox30.TabIndex = 54; + this.wmTextBox30.Visible = false; + // + // wmLabel30 + // + this.wmLabel30.AutoSize = true; + this.wmLabel30.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel30.Location = new System.Drawing.Point(595, 241); + this.wmLabel30.Name = "wmLabel30"; + this.wmLabel30.Size = new System.Drawing.Size(24, 16); + this.wmLabel30.TabIndex = 50; + this.wmLabel30.Text = "30"; + this.wmLabel30.Visible = false; + // + // wmTextBox29 + // + this.wmTextBox29.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox29.Location = new System.Drawing.Point(720, 205); + this.wmTextBox29.Name = "wmTextBox29"; + this.wmTextBox29.Size = new System.Drawing.Size(380, 23); + this.wmTextBox29.TabIndex = 53; + this.wmTextBox29.Visible = false; + // + // wmLabel29 + // + this.wmLabel29.AutoSize = true; + this.wmLabel29.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel29.Location = new System.Drawing.Point(595, 211); + this.wmLabel29.Name = "wmLabel29"; + this.wmLabel29.Size = new System.Drawing.Size(24, 16); + this.wmLabel29.TabIndex = 49; + this.wmLabel29.Text = "29"; + this.wmLabel29.Visible = false; + // + // wmTextBox28 + // + this.wmTextBox28.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox28.Location = new System.Drawing.Point(720, 176); + this.wmTextBox28.Name = "wmTextBox28"; + this.wmTextBox28.Size = new System.Drawing.Size(380, 23); + this.wmTextBox28.TabIndex = 57; + this.wmTextBox28.Visible = false; + // + // wmLabel28 + // + this.wmLabel28.AutoSize = true; + this.wmLabel28.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel28.Location = new System.Drawing.Point(595, 182); + this.wmLabel28.Name = "wmLabel28"; + this.wmLabel28.Size = new System.Drawing.Size(24, 16); + this.wmLabel28.TabIndex = 48; + this.wmLabel28.Text = "28"; + this.wmLabel28.Visible = false; + // + // wmTextBox27 + // + this.wmTextBox27.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox27.Location = new System.Drawing.Point(720, 147); + this.wmTextBox27.Name = "wmTextBox27"; + this.wmTextBox27.Size = new System.Drawing.Size(380, 23); + this.wmTextBox27.TabIndex = 58; + this.wmTextBox27.Visible = false; + // + // wmLabel27 + // + this.wmLabel27.AutoSize = true; + this.wmLabel27.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel27.Location = new System.Drawing.Point(595, 153); + this.wmLabel27.Name = "wmLabel27"; + this.wmLabel27.Size = new System.Drawing.Size(24, 16); + this.wmLabel27.TabIndex = 47; + this.wmLabel27.Text = "27"; + this.wmLabel27.Visible = false; + // + // wmTextBox26 + // + this.wmTextBox26.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox26.Location = new System.Drawing.Point(720, 118); + this.wmTextBox26.Name = "wmTextBox26"; + this.wmTextBox26.Size = new System.Drawing.Size(380, 23); + this.wmTextBox26.TabIndex = 55; + this.wmTextBox26.Visible = false; + // + // wmLabel26 + // + this.wmLabel26.AutoSize = true; + this.wmLabel26.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel26.Location = new System.Drawing.Point(595, 124); + this.wmLabel26.Name = "wmLabel26"; + this.wmLabel26.Size = new System.Drawing.Size(24, 16); + this.wmLabel26.TabIndex = 52; + this.wmLabel26.Text = "26"; + this.wmLabel26.Visible = false; + // + // wmTextBox25 + // + this.wmTextBox25.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmTextBox25.Location = new System.Drawing.Point(720, 89); + this.wmTextBox25.Name = "wmTextBox25"; + this.wmTextBox25.Size = new System.Drawing.Size(380, 23); + this.wmTextBox25.TabIndex = 56; + this.wmTextBox25.Visible = false; + // + // wmLabel25 + // + this.wmLabel25.AutoSize = true; + this.wmLabel25.Font = new System.Drawing.Font("Verdana", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.wmLabel25.Location = new System.Drawing.Point(595, 95); + this.wmLabel25.Name = "wmLabel25"; + this.wmLabel25.Size = new System.Drawing.Size(24, 16); + this.wmLabel25.TabIndex = 51; + this.wmLabel25.Text = "25"; + this.wmLabel25.Visible = false; + // + // activityLabel + // + this.activityLabel.AutoSize = true; + this.activityLabel.Font = new System.Drawing.Font("Microsoft Sans Serif", 27.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.activityLabel.Location = new System.Drawing.Point(189, 22); + this.activityLabel.Name = "activityLabel"; + this.activityLabel.Size = new System.Drawing.Size(225, 42); + this.activityLabel.TabIndex = 95; + this.activityLabel.Text = "Activity label"; + // + // pictureBox48 + // + this.pictureBox48.Location = new System.Drawing.Point(680, 756); + this.pictureBox48.Name = "pictureBox48"; + this.pictureBox48.Size = new System.Drawing.Size(23, 23); + this.pictureBox48.TabIndex = 143; + this.pictureBox48.TabStop = false; + // + // pictureBox47 + // + this.pictureBox47.Location = new System.Drawing.Point(680, 727); + this.pictureBox47.Name = "pictureBox47"; + this.pictureBox47.Size = new System.Drawing.Size(23, 23); + this.pictureBox47.TabIndex = 142; + this.pictureBox47.TabStop = false; + // + // pictureBox46 + // + this.pictureBox46.Location = new System.Drawing.Point(680, 698); + this.pictureBox46.Name = "pictureBox46"; + this.pictureBox46.Size = new System.Drawing.Size(23, 23); + this.pictureBox46.TabIndex = 141; + this.pictureBox46.TabStop = false; + // + // pictureBox45 + // + this.pictureBox45.Location = new System.Drawing.Point(680, 669); + this.pictureBox45.Name = "pictureBox45"; + this.pictureBox45.Size = new System.Drawing.Size(23, 23); + this.pictureBox45.TabIndex = 140; + this.pictureBox45.TabStop = false; + // + // pictureBox44 + // + this.pictureBox44.Location = new System.Drawing.Point(680, 640); + this.pictureBox44.Name = "pictureBox44"; + this.pictureBox44.Size = new System.Drawing.Size(23, 23); + this.pictureBox44.TabIndex = 139; + this.pictureBox44.TabStop = false; + // + // pictureBox43 + // + this.pictureBox43.Location = new System.Drawing.Point(680, 611); + this.pictureBox43.Name = "pictureBox43"; + this.pictureBox43.Size = new System.Drawing.Size(23, 23); + this.pictureBox43.TabIndex = 138; + this.pictureBox43.TabStop = false; + // + // pictureBox42 + // + this.pictureBox42.Location = new System.Drawing.Point(680, 582); + this.pictureBox42.Name = "pictureBox42"; + this.pictureBox42.Size = new System.Drawing.Size(23, 23); + this.pictureBox42.TabIndex = 137; + this.pictureBox42.TabStop = false; + // + // pictureBox41 + // + this.pictureBox41.Location = new System.Drawing.Point(680, 553); + this.pictureBox41.Name = "pictureBox41"; + this.pictureBox41.Size = new System.Drawing.Size(23, 23); + this.pictureBox41.TabIndex = 136; + this.pictureBox41.TabStop = false; + // + // pictureBox40 + // + this.pictureBox40.Location = new System.Drawing.Point(680, 524); + this.pictureBox40.Name = "pictureBox40"; + this.pictureBox40.Size = new System.Drawing.Size(23, 23); + this.pictureBox40.TabIndex = 135; + this.pictureBox40.TabStop = false; + // + // pictureBox39 + // + this.pictureBox39.Location = new System.Drawing.Point(680, 495); + this.pictureBox39.Name = "pictureBox39"; + this.pictureBox39.Size = new System.Drawing.Size(23, 23); + this.pictureBox39.TabIndex = 134; + this.pictureBox39.TabStop = false; + // + // pictureBox38 + // + this.pictureBox38.Location = new System.Drawing.Point(680, 466); + this.pictureBox38.Name = "pictureBox38"; + this.pictureBox38.Size = new System.Drawing.Size(23, 23); + this.pictureBox38.TabIndex = 133; + this.pictureBox38.TabStop = false; + // + // pictureBox37 + // + this.pictureBox37.Location = new System.Drawing.Point(680, 437); + this.pictureBox37.Name = "pictureBox37"; + this.pictureBox37.Size = new System.Drawing.Size(23, 23); + this.pictureBox37.TabIndex = 132; + this.pictureBox37.TabStop = false; + // + // pictureBox36 + // + this.pictureBox36.Location = new System.Drawing.Point(680, 408); + this.pictureBox36.Name = "pictureBox36"; + this.pictureBox36.Size = new System.Drawing.Size(23, 23); + this.pictureBox36.TabIndex = 131; + this.pictureBox36.TabStop = false; + // + // pictureBox35 + // + this.pictureBox35.Location = new System.Drawing.Point(680, 379); + this.pictureBox35.Name = "pictureBox35"; + this.pictureBox35.Size = new System.Drawing.Size(23, 23); + this.pictureBox35.TabIndex = 130; + this.pictureBox35.TabStop = false; + // + // pictureBox34 + // + this.pictureBox34.Location = new System.Drawing.Point(680, 350); + this.pictureBox34.Name = "pictureBox34"; + this.pictureBox34.Size = new System.Drawing.Size(23, 23); + this.pictureBox34.TabIndex = 129; + this.pictureBox34.TabStop = false; + // + // pictureBox33 + // + this.pictureBox33.Location = new System.Drawing.Point(680, 321); + this.pictureBox33.Name = "pictureBox33"; + this.pictureBox33.Size = new System.Drawing.Size(23, 23); + this.pictureBox33.TabIndex = 128; + this.pictureBox33.TabStop = false; + // + // pictureBox32 + // + this.pictureBox32.Location = new System.Drawing.Point(680, 292); + this.pictureBox32.Name = "pictureBox32"; + this.pictureBox32.Size = new System.Drawing.Size(23, 23); + this.pictureBox32.TabIndex = 127; + this.pictureBox32.TabStop = false; + // + // pictureBox31 + // + this.pictureBox31.Location = new System.Drawing.Point(680, 263); + this.pictureBox31.Name = "pictureBox31"; + this.pictureBox31.Size = new System.Drawing.Size(23, 23); + this.pictureBox31.TabIndex = 126; + this.pictureBox31.TabStop = false; + // + // pictureBox30 + // + this.pictureBox30.Location = new System.Drawing.Point(680, 234); + this.pictureBox30.Name = "pictureBox30"; + this.pictureBox30.Size = new System.Drawing.Size(23, 23); + this.pictureBox30.TabIndex = 125; + this.pictureBox30.TabStop = false; + // + // pictureBox29 + // + this.pictureBox29.Location = new System.Drawing.Point(680, 205); + this.pictureBox29.Name = "pictureBox29"; + this.pictureBox29.Size = new System.Drawing.Size(23, 23); + this.pictureBox29.TabIndex = 124; + this.pictureBox29.TabStop = false; + // + // pictureBox28 + // + this.pictureBox28.Location = new System.Drawing.Point(680, 176); + this.pictureBox28.Name = "pictureBox28"; + this.pictureBox28.Size = new System.Drawing.Size(23, 23); + this.pictureBox28.TabIndex = 123; + this.pictureBox28.TabStop = false; + // + // pictureBox27 + // + this.pictureBox27.Location = new System.Drawing.Point(680, 147); + this.pictureBox27.Name = "pictureBox27"; + this.pictureBox27.Size = new System.Drawing.Size(23, 23); + this.pictureBox27.TabIndex = 122; + this.pictureBox27.TabStop = false; + // + // pictureBox26 + // + this.pictureBox26.Location = new System.Drawing.Point(680, 118); + this.pictureBox26.Name = "pictureBox26"; + this.pictureBox26.Size = new System.Drawing.Size(23, 23); + this.pictureBox26.TabIndex = 121; + this.pictureBox26.TabStop = false; + // + // pictureBox25 + // + this.pictureBox25.Location = new System.Drawing.Point(680, 89); + this.pictureBox25.Name = "pictureBox25"; + this.pictureBox25.Size = new System.Drawing.Size(23, 23); + this.pictureBox25.TabIndex = 120; + this.pictureBox25.TabStop = false; + // + // pictureBox24 + // + this.pictureBox24.Location = new System.Drawing.Point(120, 756); + this.pictureBox24.Name = "pictureBox24"; + this.pictureBox24.Size = new System.Drawing.Size(23, 23); + this.pictureBox24.TabIndex = 119; + this.pictureBox24.TabStop = false; + // + // pictureBox23 + // + this.pictureBox23.Location = new System.Drawing.Point(120, 727); + this.pictureBox23.Name = "pictureBox23"; + this.pictureBox23.Size = new System.Drawing.Size(23, 23); + this.pictureBox23.TabIndex = 118; + this.pictureBox23.TabStop = false; + // + // pictureBox22 + // + this.pictureBox22.Location = new System.Drawing.Point(120, 698); + this.pictureBox22.Name = "pictureBox22"; + this.pictureBox22.Size = new System.Drawing.Size(23, 23); + this.pictureBox22.TabIndex = 117; + this.pictureBox22.TabStop = false; + // + // pictureBox21 + // + this.pictureBox21.Location = new System.Drawing.Point(120, 669); + this.pictureBox21.Name = "pictureBox21"; + this.pictureBox21.Size = new System.Drawing.Size(23, 23); + this.pictureBox21.TabIndex = 116; + this.pictureBox21.TabStop = false; + // + // pictureBox20 + // + this.pictureBox20.Location = new System.Drawing.Point(120, 640); + this.pictureBox20.Name = "pictureBox20"; + this.pictureBox20.Size = new System.Drawing.Size(23, 23); + this.pictureBox20.TabIndex = 115; + this.pictureBox20.TabStop = false; + // + // pictureBox19 + // + this.pictureBox19.Location = new System.Drawing.Point(120, 611); + this.pictureBox19.Name = "pictureBox19"; + this.pictureBox19.Size = new System.Drawing.Size(23, 23); + this.pictureBox19.TabIndex = 114; + this.pictureBox19.TabStop = false; + // + // pictureBox18 + // + this.pictureBox18.Location = new System.Drawing.Point(120, 582); + this.pictureBox18.Name = "pictureBox18"; + this.pictureBox18.Size = new System.Drawing.Size(23, 23); + this.pictureBox18.TabIndex = 113; + this.pictureBox18.TabStop = false; + // + // pictureBox17 + // + this.pictureBox17.Location = new System.Drawing.Point(120, 553); + this.pictureBox17.Name = "pictureBox17"; + this.pictureBox17.Size = new System.Drawing.Size(23, 23); + this.pictureBox17.TabIndex = 112; + this.pictureBox17.TabStop = false; + // + // pictureBox16 + // + this.pictureBox16.Location = new System.Drawing.Point(120, 524); + this.pictureBox16.Name = "pictureBox16"; + this.pictureBox16.Size = new System.Drawing.Size(23, 23); + this.pictureBox16.TabIndex = 111; + this.pictureBox16.TabStop = false; + // + // pictureBox15 + // + this.pictureBox15.Location = new System.Drawing.Point(120, 495); + this.pictureBox15.Name = "pictureBox15"; + this.pictureBox15.Size = new System.Drawing.Size(23, 23); + this.pictureBox15.TabIndex = 110; + this.pictureBox15.TabStop = false; + // + // pictureBox14 + // + this.pictureBox14.Location = new System.Drawing.Point(120, 466); + this.pictureBox14.Name = "pictureBox14"; + this.pictureBox14.Size = new System.Drawing.Size(23, 23); + this.pictureBox14.TabIndex = 109; + this.pictureBox14.TabStop = false; + // + // pictureBox13 + // + this.pictureBox13.Location = new System.Drawing.Point(120, 437); + this.pictureBox13.Name = "pictureBox13"; + this.pictureBox13.Size = new System.Drawing.Size(23, 23); + this.pictureBox13.TabIndex = 108; + this.pictureBox13.TabStop = false; + // + // pictureBox12 + // + this.pictureBox12.Location = new System.Drawing.Point(120, 408); + this.pictureBox12.Name = "pictureBox12"; + this.pictureBox12.Size = new System.Drawing.Size(23, 23); + this.pictureBox12.TabIndex = 107; + this.pictureBox12.TabStop = false; + // + // pictureBox11 + // + this.pictureBox11.Location = new System.Drawing.Point(120, 379); + this.pictureBox11.Name = "pictureBox11"; + this.pictureBox11.Size = new System.Drawing.Size(23, 23); + this.pictureBox11.TabIndex = 106; + this.pictureBox11.TabStop = false; + // + // pictureBox10 + // + this.pictureBox10.Location = new System.Drawing.Point(120, 350); + this.pictureBox10.Name = "pictureBox10"; + this.pictureBox10.Size = new System.Drawing.Size(23, 23); + this.pictureBox10.TabIndex = 105; + this.pictureBox10.TabStop = false; + // + // pictureBox9 + // + this.pictureBox9.Location = new System.Drawing.Point(120, 321); + this.pictureBox9.Name = "pictureBox9"; + this.pictureBox9.Size = new System.Drawing.Size(23, 23); + this.pictureBox9.TabIndex = 104; + this.pictureBox9.TabStop = false; + // + // pictureBox8 + // + this.pictureBox8.Location = new System.Drawing.Point(120, 292); + this.pictureBox8.Name = "pictureBox8"; + this.pictureBox8.Size = new System.Drawing.Size(23, 23); + this.pictureBox8.TabIndex = 103; + this.pictureBox8.TabStop = false; + // + // pictureBox7 + // + this.pictureBox7.Location = new System.Drawing.Point(120, 263); + this.pictureBox7.Name = "pictureBox7"; + this.pictureBox7.Size = new System.Drawing.Size(23, 23); + this.pictureBox7.TabIndex = 102; + this.pictureBox7.TabStop = false; + // + // pictureBox6 + // + this.pictureBox6.Location = new System.Drawing.Point(120, 234); + this.pictureBox6.Name = "pictureBox6"; + this.pictureBox6.Size = new System.Drawing.Size(23, 23); + this.pictureBox6.TabIndex = 101; + this.pictureBox6.TabStop = false; + // + // pictureBox5 + // + this.pictureBox5.Location = new System.Drawing.Point(120, 205); + this.pictureBox5.Name = "pictureBox5"; + this.pictureBox5.Size = new System.Drawing.Size(23, 23); + this.pictureBox5.TabIndex = 100; + this.pictureBox5.TabStop = false; + // + // pictureBox4 + // + this.pictureBox4.Location = new System.Drawing.Point(120, 176); + this.pictureBox4.Name = "pictureBox4"; + this.pictureBox4.Size = new System.Drawing.Size(23, 23); + this.pictureBox4.TabIndex = 99; + this.pictureBox4.TabStop = false; + // + // pictureBox3 + // + this.pictureBox3.Location = new System.Drawing.Point(120, 147); + this.pictureBox3.Name = "pictureBox3"; + this.pictureBox3.Size = new System.Drawing.Size(23, 23); + this.pictureBox3.TabIndex = 98; + this.pictureBox3.TabStop = false; + // + // pictureBox2 + // + this.pictureBox2.Location = new System.Drawing.Point(120, 118); + this.pictureBox2.Name = "pictureBox2"; + this.pictureBox2.Size = new System.Drawing.Size(23, 23); + this.pictureBox2.TabIndex = 97; + this.pictureBox2.TabStop = false; + // + // pictureBox1 + // + this.pictureBox1.Location = new System.Drawing.Point(120, 89); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.Size = new System.Drawing.Size(23, 23); + this.pictureBox1.TabIndex = 96; + this.pictureBox1.TabStop = false; + // + // saveButton + // + this.saveButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.saveButton.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(238))); + this.saveButton.Location = new System.Drawing.Point(1025, 22); + this.saveButton.Name = "saveButton"; + this.saveButton.Size = new System.Drawing.Size(75, 42); + this.saveButton.TabIndex = 192; + this.saveButton.Text = "Save"; + this.saveButton.UseVisualStyleBackColor = true; + this.saveButton.Visible = false; + this.saveButton.Click += new System.EventHandler(this.saveButton_Click); + // + // samplePictureBox1 + // + this.samplePictureBox1.Location = new System.Drawing.Point(7, 7); + this.samplePictureBox1.Name = "samplePictureBox1"; + this.samplePictureBox1.Size = new System.Drawing.Size(23, 23); + this.samplePictureBox1.TabIndex = 193; + this.samplePictureBox1.TabStop = false; + // + // samplePictureBox2 + // + this.samplePictureBox2.Location = new System.Drawing.Point(7, 32); + this.samplePictureBox2.Name = "samplePictureBox2"; + this.samplePictureBox2.Size = new System.Drawing.Size(23, 23); + this.samplePictureBox2.TabIndex = 194; + this.samplePictureBox2.TabStop = false; + // + // samplePictureBox3 + // + this.samplePictureBox3.Location = new System.Drawing.Point(7, 57); + this.samplePictureBox3.Name = "samplePictureBox3"; + this.samplePictureBox3.Size = new System.Drawing.Size(23, 23); + this.samplePictureBox3.TabIndex = 195; + this.samplePictureBox3.TabStop = false; + // + // sampleLabel1 + // + this.sampleLabel1.AutoSize = true; + this.sampleLabel1.Location = new System.Drawing.Point(36, 12); + this.sampleLabel1.Name = "sampleLabel1"; + this.sampleLabel1.Size = new System.Drawing.Size(139, 13); + this.sampleLabel1.TabIndex = 196; + this.sampleLabel1.Text = "Direction and pulses are OK"; + // + // sampleLabel2 + // + this.sampleLabel2.AutoSize = true; + this.sampleLabel2.Location = new System.Drawing.Point(36, 37); + this.sampleLabel2.Name = "sampleLabel2"; + this.sampleLabel2.Size = new System.Drawing.Size(125, 13); + this.sampleLabel2.TabIndex = 197; + this.sampleLabel2.Text = "There are no opto pulses"; + // + // sampleLabel3 + // + this.sampleLabel3.AutoSize = true; + this.sampleLabel3.Location = new System.Drawing.Point(36, 62); + this.sampleLabel3.Name = "sampleLabel3"; + this.sampleLabel3.Size = new System.Drawing.Size(85, 13); + this.sampleLabel3.TabIndex = 198; + this.sampleLabel3.Text = "Direction is NOK"; + // + // checkBoxImage48 + // + this.checkBoxImage48.Checked = false; + this.checkBoxImage48.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage48.Image"))); + this.checkBoxImage48.Location = new System.Drawing.Point(630, 758); + this.checkBoxImage48.Name = "checkBoxImage48"; + this.checkBoxImage48.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage48.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage48.TabIndex = 191; + this.checkBoxImage48.TabStop = false; + this.checkBoxImage48.Visible = false; + this.checkBoxImage48.Click += new System.EventHandler(this.checkBoxImage48_Click); + // + // checkBoxImage47 + // + this.checkBoxImage47.Checked = false; + this.checkBoxImage47.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage47.Image"))); + this.checkBoxImage47.Location = new System.Drawing.Point(630, 729); + this.checkBoxImage47.Name = "checkBoxImage47"; + this.checkBoxImage47.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage47.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage47.TabIndex = 190; + this.checkBoxImage47.TabStop = false; + this.checkBoxImage47.Visible = false; + this.checkBoxImage47.Click += new System.EventHandler(this.checkBoxImage47_Click); + // + // checkBoxImage46 + // + this.checkBoxImage46.Checked = false; + this.checkBoxImage46.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage46.Image"))); + this.checkBoxImage46.Location = new System.Drawing.Point(630, 700); + this.checkBoxImage46.Name = "checkBoxImage46"; + this.checkBoxImage46.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage46.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage46.TabIndex = 189; + this.checkBoxImage46.TabStop = false; + this.checkBoxImage46.Visible = false; + this.checkBoxImage46.Click += new System.EventHandler(this.checkBoxImage46_Click); + // + // checkBoxImage45 + // + this.checkBoxImage45.Checked = false; + this.checkBoxImage45.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage45.Image"))); + this.checkBoxImage45.Location = new System.Drawing.Point(630, 671); + this.checkBoxImage45.Name = "checkBoxImage45"; + this.checkBoxImage45.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage45.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage45.TabIndex = 188; + this.checkBoxImage45.TabStop = false; + this.checkBoxImage45.Visible = false; + this.checkBoxImage45.Click += new System.EventHandler(this.checkBoxImage45_Click); + // + // checkBoxImage44 + // + this.checkBoxImage44.Checked = false; + this.checkBoxImage44.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage44.Image"))); + this.checkBoxImage44.Location = new System.Drawing.Point(630, 642); + this.checkBoxImage44.Name = "checkBoxImage44"; + this.checkBoxImage44.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage44.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage44.TabIndex = 187; + this.checkBoxImage44.TabStop = false; + this.checkBoxImage44.Visible = false; + this.checkBoxImage44.Click += new System.EventHandler(this.checkBoxImage44_Click); + // + // checkBoxImage43 + // + this.checkBoxImage43.Checked = false; + this.checkBoxImage43.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage43.Image"))); + this.checkBoxImage43.Location = new System.Drawing.Point(630, 613); + this.checkBoxImage43.Name = "checkBoxImage43"; + this.checkBoxImage43.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage43.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage43.TabIndex = 186; + this.checkBoxImage43.TabStop = false; + this.checkBoxImage43.Visible = false; + this.checkBoxImage43.Click += new System.EventHandler(this.checkBoxImage43_Click); + // + // checkBoxImage42 + // + this.checkBoxImage42.Checked = false; + this.checkBoxImage42.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage42.Image"))); + this.checkBoxImage42.Location = new System.Drawing.Point(630, 584); + this.checkBoxImage42.Name = "checkBoxImage42"; + this.checkBoxImage42.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage42.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage42.TabIndex = 185; + this.checkBoxImage42.TabStop = false; + this.checkBoxImage42.Visible = false; + this.checkBoxImage42.Click += new System.EventHandler(this.checkBoxImage42_Click); + // + // checkBoxImage41 + // + this.checkBoxImage41.Checked = false; + this.checkBoxImage41.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage41.Image"))); + this.checkBoxImage41.Location = new System.Drawing.Point(630, 555); + this.checkBoxImage41.Name = "checkBoxImage41"; + this.checkBoxImage41.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage41.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage41.TabIndex = 184; + this.checkBoxImage41.TabStop = false; + this.checkBoxImage41.Visible = false; + this.checkBoxImage41.Click += new System.EventHandler(this.checkBoxImage41_Click); + // + // checkBoxImage40 + // + this.checkBoxImage40.Checked = false; + this.checkBoxImage40.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage40.Image"))); + this.checkBoxImage40.Location = new System.Drawing.Point(630, 526); + this.checkBoxImage40.Name = "checkBoxImage40"; + this.checkBoxImage40.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage40.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage40.TabIndex = 183; + this.checkBoxImage40.TabStop = false; + this.checkBoxImage40.Visible = false; + this.checkBoxImage40.Click += new System.EventHandler(this.checkBoxImage40_Click); + // + // checkBoxImage39 + // + this.checkBoxImage39.Checked = false; + this.checkBoxImage39.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage39.Image"))); + this.checkBoxImage39.Location = new System.Drawing.Point(630, 497); + this.checkBoxImage39.Name = "checkBoxImage39"; + this.checkBoxImage39.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage39.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage39.TabIndex = 182; + this.checkBoxImage39.TabStop = false; + this.checkBoxImage39.Visible = false; + this.checkBoxImage39.Click += new System.EventHandler(this.checkBoxImage39_Click); + // + // checkBoxImage38 + // + this.checkBoxImage38.Checked = false; + this.checkBoxImage38.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage38.Image"))); + this.checkBoxImage38.Location = new System.Drawing.Point(630, 468); + this.checkBoxImage38.Name = "checkBoxImage38"; + this.checkBoxImage38.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage38.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage38.TabIndex = 181; + this.checkBoxImage38.TabStop = false; + this.checkBoxImage38.Visible = false; + this.checkBoxImage38.Click += new System.EventHandler(this.checkBoxImage38_Click); + // + // checkBoxImage37 + // + this.checkBoxImage37.Checked = false; + this.checkBoxImage37.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage37.Image"))); + this.checkBoxImage37.Location = new System.Drawing.Point(630, 439); + this.checkBoxImage37.Name = "checkBoxImage37"; + this.checkBoxImage37.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage37.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage37.TabIndex = 180; + this.checkBoxImage37.TabStop = false; + this.checkBoxImage37.Visible = false; + this.checkBoxImage37.Click += new System.EventHandler(this.checkBoxImage37_Click); + // + // checkBoxImage36 + // + this.checkBoxImage36.Checked = false; + this.checkBoxImage36.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage36.Image"))); + this.checkBoxImage36.Location = new System.Drawing.Point(630, 410); + this.checkBoxImage36.Name = "checkBoxImage36"; + this.checkBoxImage36.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage36.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage36.TabIndex = 179; + this.checkBoxImage36.TabStop = false; + this.checkBoxImage36.Visible = false; + this.checkBoxImage36.Click += new System.EventHandler(this.checkBoxImage36_Click); + // + // checkBoxImage35 + // + this.checkBoxImage35.Checked = false; + this.checkBoxImage35.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage35.Image"))); + this.checkBoxImage35.Location = new System.Drawing.Point(630, 381); + this.checkBoxImage35.Name = "checkBoxImage35"; + this.checkBoxImage35.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage35.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage35.TabIndex = 178; + this.checkBoxImage35.TabStop = false; + this.checkBoxImage35.Visible = false; + this.checkBoxImage35.Click += new System.EventHandler(this.checkBoxImage35_Click); + // + // checkBoxImage34 + // + this.checkBoxImage34.Checked = false; + this.checkBoxImage34.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage34.Image"))); + this.checkBoxImage34.Location = new System.Drawing.Point(630, 352); + this.checkBoxImage34.Name = "checkBoxImage34"; + this.checkBoxImage34.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage34.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage34.TabIndex = 177; + this.checkBoxImage34.TabStop = false; + this.checkBoxImage34.Visible = false; + this.checkBoxImage34.Click += new System.EventHandler(this.checkBoxImage34_Click); + // + // checkBoxImage33 + // + this.checkBoxImage33.Checked = false; + this.checkBoxImage33.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage33.Image"))); + this.checkBoxImage33.Location = new System.Drawing.Point(630, 323); + this.checkBoxImage33.Name = "checkBoxImage33"; + this.checkBoxImage33.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage33.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage33.TabIndex = 176; + this.checkBoxImage33.TabStop = false; + this.checkBoxImage33.Visible = false; + this.checkBoxImage33.Click += new System.EventHandler(this.checkBoxImage33_Click); + // + // checkBoxImage32 + // + this.checkBoxImage32.Checked = false; + this.checkBoxImage32.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage32.Image"))); + this.checkBoxImage32.Location = new System.Drawing.Point(630, 294); + this.checkBoxImage32.Name = "checkBoxImage32"; + this.checkBoxImage32.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage32.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage32.TabIndex = 175; + this.checkBoxImage32.TabStop = false; + this.checkBoxImage32.Visible = false; + this.checkBoxImage32.Click += new System.EventHandler(this.checkBoxImage32_Click); + // + // checkBoxImage31 + // + this.checkBoxImage31.Checked = false; + this.checkBoxImage31.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage31.Image"))); + this.checkBoxImage31.Location = new System.Drawing.Point(630, 265); + this.checkBoxImage31.Name = "checkBoxImage31"; + this.checkBoxImage31.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage31.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage31.TabIndex = 174; + this.checkBoxImage31.TabStop = false; + this.checkBoxImage31.Visible = false; + this.checkBoxImage31.Click += new System.EventHandler(this.checkBoxImage31_Click); + // + // checkBoxImage30 + // + this.checkBoxImage30.Checked = false; + this.checkBoxImage30.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage30.Image"))); + this.checkBoxImage30.Location = new System.Drawing.Point(630, 236); + this.checkBoxImage30.Name = "checkBoxImage30"; + this.checkBoxImage30.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage30.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage30.TabIndex = 173; + this.checkBoxImage30.TabStop = false; + this.checkBoxImage30.Visible = false; + this.checkBoxImage30.Click += new System.EventHandler(this.checkBoxImage30_Click); + // + // checkBoxImage29 + // + this.checkBoxImage29.Checked = false; + this.checkBoxImage29.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage29.Image"))); + this.checkBoxImage29.Location = new System.Drawing.Point(630, 207); + this.checkBoxImage29.Name = "checkBoxImage29"; + this.checkBoxImage29.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage29.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage29.TabIndex = 172; + this.checkBoxImage29.TabStop = false; + this.checkBoxImage29.Visible = false; + this.checkBoxImage29.Click += new System.EventHandler(this.checkBoxImage29_Click); + // + // checkBoxImage28 + // + this.checkBoxImage28.Checked = false; + this.checkBoxImage28.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage28.Image"))); + this.checkBoxImage28.Location = new System.Drawing.Point(630, 178); + this.checkBoxImage28.Name = "checkBoxImage28"; + this.checkBoxImage28.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage28.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage28.TabIndex = 171; + this.checkBoxImage28.TabStop = false; + this.checkBoxImage28.Visible = false; + this.checkBoxImage28.Click += new System.EventHandler(this.checkBoxImage28_Click); + // + // checkBoxImage27 + // + this.checkBoxImage27.Checked = false; + this.checkBoxImage27.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage27.Image"))); + this.checkBoxImage27.Location = new System.Drawing.Point(630, 149); + this.checkBoxImage27.Name = "checkBoxImage27"; + this.checkBoxImage27.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage27.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage27.TabIndex = 170; + this.checkBoxImage27.TabStop = false; + this.checkBoxImage27.Visible = false; + this.checkBoxImage27.Click += new System.EventHandler(this.checkBoxImage27_Click); + // + // checkBoxImage26 + // + this.checkBoxImage26.Checked = false; + this.checkBoxImage26.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage26.Image"))); + this.checkBoxImage26.Location = new System.Drawing.Point(630, 120); + this.checkBoxImage26.Name = "checkBoxImage26"; + this.checkBoxImage26.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage26.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage26.TabIndex = 169; + this.checkBoxImage26.TabStop = false; + this.checkBoxImage26.Visible = false; + this.checkBoxImage26.Click += new System.EventHandler(this.checkBoxImage26_Click); + // + // checkBoxImage25 + // + this.checkBoxImage25.Checked = false; + this.checkBoxImage25.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage25.Image"))); + this.checkBoxImage25.Location = new System.Drawing.Point(630, 91); + this.checkBoxImage25.Name = "checkBoxImage25"; + this.checkBoxImage25.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage25.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage25.TabIndex = 168; + this.checkBoxImage25.TabStop = false; + this.checkBoxImage25.Visible = false; + this.checkBoxImage25.Click += new System.EventHandler(this.checkBoxImage25_Click); + // + // checkBoxImage24 + // + this.checkBoxImage24.Checked = false; + this.checkBoxImage24.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage24.Image"))); + this.checkBoxImage24.Location = new System.Drawing.Point(70, 758); + this.checkBoxImage24.Name = "checkBoxImage24"; + this.checkBoxImage24.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage24.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage24.TabIndex = 167; + this.checkBoxImage24.TabStop = false; + this.checkBoxImage24.Visible = false; + this.checkBoxImage24.Click += new System.EventHandler(this.checkBoxImage24_Click); + // + // checkBoxImage23 + // + this.checkBoxImage23.Checked = false; + this.checkBoxImage23.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage23.Image"))); + this.checkBoxImage23.Location = new System.Drawing.Point(70, 729); + this.checkBoxImage23.Name = "checkBoxImage23"; + this.checkBoxImage23.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage23.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage23.TabIndex = 166; + this.checkBoxImage23.TabStop = false; + this.checkBoxImage23.Visible = false; + this.checkBoxImage23.Click += new System.EventHandler(this.checkBoxImage23_Click); + // + // checkBoxImage22 + // + this.checkBoxImage22.Checked = false; + this.checkBoxImage22.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage22.Image"))); + this.checkBoxImage22.Location = new System.Drawing.Point(70, 700); + this.checkBoxImage22.Name = "checkBoxImage22"; + this.checkBoxImage22.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage22.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage22.TabIndex = 165; + this.checkBoxImage22.TabStop = false; + this.checkBoxImage22.Visible = false; + this.checkBoxImage22.Click += new System.EventHandler(this.checkBoxImage22_Click); + // + // checkBoxImage21 + // + this.checkBoxImage21.Checked = false; + this.checkBoxImage21.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage21.Image"))); + this.checkBoxImage21.Location = new System.Drawing.Point(70, 671); + this.checkBoxImage21.Name = "checkBoxImage21"; + this.checkBoxImage21.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage21.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage21.TabIndex = 164; + this.checkBoxImage21.TabStop = false; + this.checkBoxImage21.Visible = false; + this.checkBoxImage21.Click += new System.EventHandler(this.checkBoxImage21_Click); + // + // checkBoxImage20 + // + this.checkBoxImage20.Checked = false; + this.checkBoxImage20.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage20.Image"))); + this.checkBoxImage20.Location = new System.Drawing.Point(70, 642); + this.checkBoxImage20.Name = "checkBoxImage20"; + this.checkBoxImage20.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage20.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage20.TabIndex = 163; + this.checkBoxImage20.TabStop = false; + this.checkBoxImage20.Visible = false; + this.checkBoxImage20.Click += new System.EventHandler(this.checkBoxImage20_Click); + // + // checkBoxImage19 + // + this.checkBoxImage19.Checked = false; + this.checkBoxImage19.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage19.Image"))); + this.checkBoxImage19.Location = new System.Drawing.Point(70, 613); + this.checkBoxImage19.Name = "checkBoxImage19"; + this.checkBoxImage19.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage19.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage19.TabIndex = 162; + this.checkBoxImage19.TabStop = false; + this.checkBoxImage19.Visible = false; + this.checkBoxImage19.Click += new System.EventHandler(this.checkBoxImage19_Click); + // + // checkBoxImage18 + // + this.checkBoxImage18.Checked = false; + this.checkBoxImage18.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage18.Image"))); + this.checkBoxImage18.Location = new System.Drawing.Point(70, 584); + this.checkBoxImage18.Name = "checkBoxImage18"; + this.checkBoxImage18.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage18.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage18.TabIndex = 161; + this.checkBoxImage18.TabStop = false; + this.checkBoxImage18.Visible = false; + this.checkBoxImage18.Click += new System.EventHandler(this.checkBoxImage18_Click); + // + // checkBoxImage17 + // + this.checkBoxImage17.Checked = false; + this.checkBoxImage17.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage17.Image"))); + this.checkBoxImage17.Location = new System.Drawing.Point(70, 555); + this.checkBoxImage17.Name = "checkBoxImage17"; + this.checkBoxImage17.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage17.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage17.TabIndex = 160; + this.checkBoxImage17.TabStop = false; + this.checkBoxImage17.Visible = false; + this.checkBoxImage17.Click += new System.EventHandler(this.checkBoxImage17_Click); + // + // checkBoxImage16 + // + this.checkBoxImage16.Checked = false; + this.checkBoxImage16.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage16.Image"))); + this.checkBoxImage16.Location = new System.Drawing.Point(70, 526); + this.checkBoxImage16.Name = "checkBoxImage16"; + this.checkBoxImage16.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage16.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage16.TabIndex = 159; + this.checkBoxImage16.TabStop = false; + this.checkBoxImage16.Visible = false; + this.checkBoxImage16.Click += new System.EventHandler(this.checkBoxImage16_Click); + // + // checkBoxImage15 + // + this.checkBoxImage15.Checked = false; + this.checkBoxImage15.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage15.Image"))); + this.checkBoxImage15.Location = new System.Drawing.Point(70, 497); + this.checkBoxImage15.Name = "checkBoxImage15"; + this.checkBoxImage15.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage15.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage15.TabIndex = 158; + this.checkBoxImage15.TabStop = false; + this.checkBoxImage15.Visible = false; + this.checkBoxImage15.Click += new System.EventHandler(this.checkBoxImage15_Click); + // + // checkBoxImage14 + // + this.checkBoxImage14.Checked = false; + this.checkBoxImage14.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage14.Image"))); + this.checkBoxImage14.Location = new System.Drawing.Point(70, 468); + this.checkBoxImage14.Name = "checkBoxImage14"; + this.checkBoxImage14.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage14.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage14.TabIndex = 157; + this.checkBoxImage14.TabStop = false; + this.checkBoxImage14.Visible = false; + this.checkBoxImage14.Click += new System.EventHandler(this.checkBoxImage14_Click); + // + // checkBoxImage13 + // + this.checkBoxImage13.Checked = false; + this.checkBoxImage13.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage13.Image"))); + this.checkBoxImage13.Location = new System.Drawing.Point(70, 439); + this.checkBoxImage13.Name = "checkBoxImage13"; + this.checkBoxImage13.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage13.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage13.TabIndex = 156; + this.checkBoxImage13.TabStop = false; + this.checkBoxImage13.Visible = false; + this.checkBoxImage13.Click += new System.EventHandler(this.checkBoxImage13_Click); + // + // checkBoxImage12 + // + this.checkBoxImage12.Checked = false; + this.checkBoxImage12.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage12.Image"))); + this.checkBoxImage12.Location = new System.Drawing.Point(70, 410); + this.checkBoxImage12.Name = "checkBoxImage12"; + this.checkBoxImage12.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage12.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage12.TabIndex = 155; + this.checkBoxImage12.TabStop = false; + this.checkBoxImage12.Visible = false; + this.checkBoxImage12.Click += new System.EventHandler(this.checkBoxImage12_Click); + // + // checkBoxImage11 + // + this.checkBoxImage11.Checked = false; + this.checkBoxImage11.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage11.Image"))); + this.checkBoxImage11.Location = new System.Drawing.Point(70, 381); + this.checkBoxImage11.Name = "checkBoxImage11"; + this.checkBoxImage11.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage11.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage11.TabIndex = 154; + this.checkBoxImage11.TabStop = false; + this.checkBoxImage11.Visible = false; + this.checkBoxImage11.Click += new System.EventHandler(this.checkBoxImage11_Click); + // + // checkBoxImage10 + // + this.checkBoxImage10.Checked = false; + this.checkBoxImage10.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage10.Image"))); + this.checkBoxImage10.Location = new System.Drawing.Point(70, 352); + this.checkBoxImage10.Name = "checkBoxImage10"; + this.checkBoxImage10.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage10.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage10.TabIndex = 153; + this.checkBoxImage10.TabStop = false; + this.checkBoxImage10.Visible = false; + this.checkBoxImage10.Click += new System.EventHandler(this.checkBoxImage10_Click); + // + // checkBoxImage9 + // + this.checkBoxImage9.Checked = false; + this.checkBoxImage9.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage9.Image"))); + this.checkBoxImage9.Location = new System.Drawing.Point(70, 323); + this.checkBoxImage9.Name = "checkBoxImage9"; + this.checkBoxImage9.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage9.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage9.TabIndex = 152; + this.checkBoxImage9.TabStop = false; + this.checkBoxImage9.Visible = false; + this.checkBoxImage9.Click += new System.EventHandler(this.checkBoxImage9_Click); + // + // checkBoxImage8 + // + this.checkBoxImage8.Checked = false; + this.checkBoxImage8.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage8.Image"))); + this.checkBoxImage8.Location = new System.Drawing.Point(70, 294); + this.checkBoxImage8.Name = "checkBoxImage8"; + this.checkBoxImage8.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage8.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage8.TabIndex = 151; + this.checkBoxImage8.TabStop = false; + this.checkBoxImage8.Visible = false; + this.checkBoxImage8.Click += new System.EventHandler(this.checkBoxImage8_Click); + // + // checkBoxImage7 + // + this.checkBoxImage7.Checked = false; + this.checkBoxImage7.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage7.Image"))); + this.checkBoxImage7.Location = new System.Drawing.Point(70, 265); + this.checkBoxImage7.Name = "checkBoxImage7"; + this.checkBoxImage7.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage7.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage7.TabIndex = 150; + this.checkBoxImage7.TabStop = false; + this.checkBoxImage7.Visible = false; + this.checkBoxImage7.Click += new System.EventHandler(this.checkBoxImage7_Click); + // + // checkBoxImage6 + // + this.checkBoxImage6.Checked = false; + this.checkBoxImage6.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage6.Image"))); + this.checkBoxImage6.Location = new System.Drawing.Point(70, 236); + this.checkBoxImage6.Name = "checkBoxImage6"; + this.checkBoxImage6.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage6.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage6.TabIndex = 149; + this.checkBoxImage6.TabStop = false; + this.checkBoxImage6.Visible = false; + this.checkBoxImage6.Click += new System.EventHandler(this.checkBoxImage6_Click); + // + // checkBoxImage5 + // + this.checkBoxImage5.Checked = false; + this.checkBoxImage5.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage5.Image"))); + this.checkBoxImage5.Location = new System.Drawing.Point(70, 207); + this.checkBoxImage5.Name = "checkBoxImage5"; + this.checkBoxImage5.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage5.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage5.TabIndex = 148; + this.checkBoxImage5.TabStop = false; + this.checkBoxImage5.Visible = false; + this.checkBoxImage5.Click += new System.EventHandler(this.checkBoxImage5_Click); + // + // checkBoxImage4 + // + this.checkBoxImage4.Checked = false; + this.checkBoxImage4.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage4.Image"))); + this.checkBoxImage4.Location = new System.Drawing.Point(70, 178); + this.checkBoxImage4.Name = "checkBoxImage4"; + this.checkBoxImage4.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage4.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage4.TabIndex = 147; + this.checkBoxImage4.TabStop = false; + this.checkBoxImage4.Visible = false; + this.checkBoxImage4.Click += new System.EventHandler(this.checkBoxImage4_Click); + // + // checkBoxImage3 + // + this.checkBoxImage3.Checked = false; + this.checkBoxImage3.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage3.Image"))); + this.checkBoxImage3.Location = new System.Drawing.Point(70, 149); + this.checkBoxImage3.Name = "checkBoxImage3"; + this.checkBoxImage3.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage3.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage3.TabIndex = 146; + this.checkBoxImage3.TabStop = false; + this.checkBoxImage3.Visible = false; + this.checkBoxImage3.Click += new System.EventHandler(this.checkBoxImage3_Click); + // + // checkBoxImage2 + // + this.checkBoxImage2.Checked = false; + this.checkBoxImage2.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage2.Image"))); + this.checkBoxImage2.Location = new System.Drawing.Point(70, 120); + this.checkBoxImage2.Name = "checkBoxImage2"; + this.checkBoxImage2.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage2.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage2.TabIndex = 145; + this.checkBoxImage2.TabStop = false; + this.checkBoxImage2.Visible = false; + this.checkBoxImage2.Click += new System.EventHandler(this.checkBoxImage2_Click); + // + // checkBoxImage1 + // + this.checkBoxImage1.Checked = false; + this.checkBoxImage1.Image = ((System.Drawing.Image)(resources.GetObject("checkBoxImage1.Image"))); + this.checkBoxImage1.Location = new System.Drawing.Point(70, 91); + this.checkBoxImage1.Name = "checkBoxImage1"; + this.checkBoxImage1.Size = new System.Drawing.Size(32, 21); + this.checkBoxImage1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage; + this.checkBoxImage1.TabIndex = 144; + this.checkBoxImage1.TabStop = false; + this.checkBoxImage1.Visible = false; + this.checkBoxImage1.Click += new System.EventHandler(this.checkBoxImage1_Click); + // + // iPerlCommunicationForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.Color.DarkGray; + this.ClientSize = new System.Drawing.Size(1134, 800); + this.Controls.Add(this.sampleLabel3); + this.Controls.Add(this.sampleLabel2); + this.Controls.Add(this.sampleLabel1); + this.Controls.Add(this.samplePictureBox3); + this.Controls.Add(this.samplePictureBox2); + this.Controls.Add(this.samplePictureBox1); + this.Controls.Add(this.saveButton); + this.Controls.Add(this.checkBoxImage48); + this.Controls.Add(this.checkBoxImage47); + this.Controls.Add(this.checkBoxImage46); + this.Controls.Add(this.checkBoxImage45); + this.Controls.Add(this.checkBoxImage44); + this.Controls.Add(this.checkBoxImage43); + this.Controls.Add(this.checkBoxImage42); + this.Controls.Add(this.checkBoxImage41); + this.Controls.Add(this.checkBoxImage40); + this.Controls.Add(this.checkBoxImage39); + this.Controls.Add(this.checkBoxImage38); + this.Controls.Add(this.checkBoxImage37); + this.Controls.Add(this.checkBoxImage36); + this.Controls.Add(this.checkBoxImage35); + this.Controls.Add(this.checkBoxImage34); + this.Controls.Add(this.checkBoxImage33); + this.Controls.Add(this.checkBoxImage32); + this.Controls.Add(this.checkBoxImage31); + this.Controls.Add(this.checkBoxImage30); + this.Controls.Add(this.checkBoxImage29); + this.Controls.Add(this.checkBoxImage28); + this.Controls.Add(this.checkBoxImage27); + this.Controls.Add(this.checkBoxImage26); + this.Controls.Add(this.checkBoxImage25); + this.Controls.Add(this.checkBoxImage24); + this.Controls.Add(this.checkBoxImage23); + this.Controls.Add(this.checkBoxImage22); + this.Controls.Add(this.checkBoxImage21); + this.Controls.Add(this.checkBoxImage20); + this.Controls.Add(this.checkBoxImage19); + this.Controls.Add(this.checkBoxImage18); + this.Controls.Add(this.checkBoxImage17); + this.Controls.Add(this.checkBoxImage16); + this.Controls.Add(this.checkBoxImage15); + this.Controls.Add(this.checkBoxImage14); + this.Controls.Add(this.checkBoxImage13); + this.Controls.Add(this.checkBoxImage12); + this.Controls.Add(this.checkBoxImage11); + this.Controls.Add(this.checkBoxImage10); + this.Controls.Add(this.checkBoxImage9); + this.Controls.Add(this.checkBoxImage8); + this.Controls.Add(this.checkBoxImage7); + this.Controls.Add(this.checkBoxImage6); + this.Controls.Add(this.checkBoxImage5); + this.Controls.Add(this.checkBoxImage4); + this.Controls.Add(this.checkBoxImage3); + this.Controls.Add(this.checkBoxImage2); + this.Controls.Add(this.checkBoxImage1); + this.Controls.Add(this.pictureBox48); + this.Controls.Add(this.pictureBox47); + this.Controls.Add(this.pictureBox46); + this.Controls.Add(this.pictureBox45); + this.Controls.Add(this.pictureBox44); + this.Controls.Add(this.pictureBox43); + this.Controls.Add(this.pictureBox42); + this.Controls.Add(this.pictureBox41); + this.Controls.Add(this.pictureBox40); + this.Controls.Add(this.pictureBox39); + this.Controls.Add(this.pictureBox38); + this.Controls.Add(this.pictureBox37); + this.Controls.Add(this.pictureBox36); + this.Controls.Add(this.pictureBox35); + this.Controls.Add(this.pictureBox34); + this.Controls.Add(this.pictureBox33); + this.Controls.Add(this.pictureBox32); + this.Controls.Add(this.pictureBox31); + this.Controls.Add(this.pictureBox30); + this.Controls.Add(this.pictureBox29); + this.Controls.Add(this.pictureBox28); + this.Controls.Add(this.pictureBox27); + this.Controls.Add(this.pictureBox26); + this.Controls.Add(this.pictureBox25); + this.Controls.Add(this.pictureBox24); + this.Controls.Add(this.pictureBox23); + this.Controls.Add(this.pictureBox22); + this.Controls.Add(this.pictureBox21); + this.Controls.Add(this.pictureBox20); + this.Controls.Add(this.pictureBox19); + this.Controls.Add(this.pictureBox18); + this.Controls.Add(this.pictureBox17); + this.Controls.Add(this.pictureBox16); + this.Controls.Add(this.pictureBox15); + this.Controls.Add(this.pictureBox14); + this.Controls.Add(this.pictureBox13); + this.Controls.Add(this.pictureBox12); + this.Controls.Add(this.pictureBox11); + this.Controls.Add(this.pictureBox10); + this.Controls.Add(this.pictureBox9); + this.Controls.Add(this.pictureBox8); + this.Controls.Add(this.pictureBox7); + this.Controls.Add(this.pictureBox6); + this.Controls.Add(this.pictureBox5); + this.Controls.Add(this.pictureBox4); + this.Controls.Add(this.pictureBox3); + this.Controls.Add(this.pictureBox2); + this.Controls.Add(this.pictureBox1); + this.Controls.Add(this.activityLabel); + this.Controls.Add(this.wmTextBox48); + this.Controls.Add(this.wmLabel48); + this.Controls.Add(this.wmTextBox47); + this.Controls.Add(this.wmLabel47); + this.Controls.Add(this.wmTextBox46); + this.Controls.Add(this.wmLabel46); + this.Controls.Add(this.wmTextBox45); + this.Controls.Add(this.wmLabel45); + this.Controls.Add(this.wmTextBox44); + this.Controls.Add(this.wmLabel44); + this.Controls.Add(this.wmTextBox43); + this.Controls.Add(this.wmLabel43); + this.Controls.Add(this.wmTextBox42); + this.Controls.Add(this.wmLabel42); + this.Controls.Add(this.wmTextBox41); + this.Controls.Add(this.wmLabel41); + this.Controls.Add(this.wmTextBox40); + this.Controls.Add(this.wmLabel40); + this.Controls.Add(this.wmTextBox39); + this.Controls.Add(this.wmLabel39); + this.Controls.Add(this.wmTextBox38); + this.Controls.Add(this.wmLabel38); + this.Controls.Add(this.wmTextBox37); + this.Controls.Add(this.wmLabel37); + this.Controls.Add(this.wmTextBox36); + this.Controls.Add(this.wmLabel36); + this.Controls.Add(this.wmTextBox35); + this.Controls.Add(this.wmLabel35); + this.Controls.Add(this.wmTextBox34); + this.Controls.Add(this.wmLabel34); + this.Controls.Add(this.wmTextBox33); + this.Controls.Add(this.wmLabel33); + this.Controls.Add(this.wmTextBox32); + this.Controls.Add(this.wmLabel32); + this.Controls.Add(this.wmTextBox31); + this.Controls.Add(this.wmLabel31); + this.Controls.Add(this.wmTextBox30); + this.Controls.Add(this.wmLabel30); + this.Controls.Add(this.wmTextBox29); + this.Controls.Add(this.wmLabel29); + this.Controls.Add(this.wmTextBox28); + this.Controls.Add(this.wmLabel28); + this.Controls.Add(this.wmTextBox27); + this.Controls.Add(this.wmLabel27); + this.Controls.Add(this.wmTextBox26); + this.Controls.Add(this.wmLabel26); + this.Controls.Add(this.wmTextBox25); + this.Controls.Add(this.wmLabel25); + this.Controls.Add(this.wmTextBox24); + this.Controls.Add(this.wmLabel24); + this.Controls.Add(this.wmTextBox23); + this.Controls.Add(this.wmLabel23); + this.Controls.Add(this.wmTextBox22); + this.Controls.Add(this.wmLabel22); + this.Controls.Add(this.wmTextBox21); + this.Controls.Add(this.wmLabel21); + this.Controls.Add(this.wmTextBox20); + this.Controls.Add(this.wmLabel20); + this.Controls.Add(this.wmTextBox19); + this.Controls.Add(this.wmLabel19); + this.Controls.Add(this.wmTextBox18); + this.Controls.Add(this.wmLabel18); + this.Controls.Add(this.wmTextBox17); + this.Controls.Add(this.wmLabel17); + this.Controls.Add(this.wmTextBox16); + this.Controls.Add(this.wmLabel16); + this.Controls.Add(this.wmTextBox15); + this.Controls.Add(this.wmLabel15); + this.Controls.Add(this.wmTextBox14); + this.Controls.Add(this.wmLabel14); + this.Controls.Add(this.wmTextBox13); + this.Controls.Add(this.wmLabel13); + this.Controls.Add(this.wmTextBox12); + this.Controls.Add(this.wmLabel12); + this.Controls.Add(this.wmTextBox11); + this.Controls.Add(this.wmLabel11); + this.Controls.Add(this.wmTextBox10); + this.Controls.Add(this.wmLabel10); + this.Controls.Add(this.wmTextBox9); + this.Controls.Add(this.wmLabel9); + this.Controls.Add(this.wmTextBox8); + this.Controls.Add(this.wmLabel8); + this.Controls.Add(this.wmTextBox7); + this.Controls.Add(this.wmLabel7); + this.Controls.Add(this.wmTextBox6); + this.Controls.Add(this.wmLabel6); + this.Controls.Add(this.wmTextBox5); + this.Controls.Add(this.wmLabel5); + this.Controls.Add(this.wmTextBox4); + this.Controls.Add(this.wmLabel4); + this.Controls.Add(this.wmTextBox3); + this.Controls.Add(this.wmLabel3); + this.Controls.Add(this.wmTextBox2); + this.Controls.Add(this.wmLabel2); + this.Controls.Add(this.wmTextBox1); + this.Controls.Add(this.wmLabel1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "iPerlCommunicationForm"; + this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide; + this.Text = "iPerl Communication"; + this.TopMost = true; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.iPerlCommunicationForm_FormClosing); + this.Load += new System.EventHandler(this.iPerlCommunicationForm_Load); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox48)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox47)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox46)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox45)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox44)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox43)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox42)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox41)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox40)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox39)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox38)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox37)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox36)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox35)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox34)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox33)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox32)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox31)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox30)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox29)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox28)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox27)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox26)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox25)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox24)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox23)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox22)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox21)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox20)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox19)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox18)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox17)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox16)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox15)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox14)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox13)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox12)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox11)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox10)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox9)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox8)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox7)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox6)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox5)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox4)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox3)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.samplePictureBox1)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.samplePictureBox2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.samplePictureBox3)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage48)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage47)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage46)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage45)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage44)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage43)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage42)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage41)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage40)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage39)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage38)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage37)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage36)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage35)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage34)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage33)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage32)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage31)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage30)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage29)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage28)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage27)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage26)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage25)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage24)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage23)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage22)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage21)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage20)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage19)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage18)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage17)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage16)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage15)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage14)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage13)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage12)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage11)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage10)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage9)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage8)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage7)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage6)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage5)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage4)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage3)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage2)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.checkBoxImage1)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.TextBox wmTextBox2; + private System.Windows.Forms.Label wmLabel2; + private System.Windows.Forms.Label wmLabel1; + private System.Windows.Forms.TextBox wmTextBox3; + private System.Windows.Forms.Label wmLabel3; + private System.Windows.Forms.TextBox wmTextBox4; + private System.Windows.Forms.Label wmLabel4; + private System.Windows.Forms.TextBox wmTextBox5; + private System.Windows.Forms.Label wmLabel5; + private System.Windows.Forms.TextBox wmTextBox6; + private System.Windows.Forms.Label wmLabel6; + private System.Windows.Forms.TextBox wmTextBox1; + private System.Windows.Forms.TextBox wmTextBox7; + private System.Windows.Forms.Label wmLabel7; + private System.Windows.Forms.TextBox wmTextBox8; + private System.Windows.Forms.Label wmLabel8; + private System.Windows.Forms.TextBox wmTextBox9; + private System.Windows.Forms.Label wmLabel9; + private System.Windows.Forms.TextBox wmTextBox10; + private System.Windows.Forms.Label wmLabel10; + private System.Windows.Forms.TextBox wmTextBox12; + private System.Windows.Forms.Label wmLabel12; + private System.Windows.Forms.TextBox wmTextBox11; + private System.Windows.Forms.Label wmLabel11; + private System.Windows.Forms.TextBox wmTextBox24; + private System.Windows.Forms.Label wmLabel24; + private System.Windows.Forms.TextBox wmTextBox23; + private System.Windows.Forms.Label wmLabel23; + private System.Windows.Forms.TextBox wmTextBox22; + private System.Windows.Forms.Label wmLabel22; + private System.Windows.Forms.TextBox wmTextBox21; + private System.Windows.Forms.Label wmLabel21; + private System.Windows.Forms.TextBox wmTextBox20; + private System.Windows.Forms.Label wmLabel20; + private System.Windows.Forms.TextBox wmTextBox19; + private System.Windows.Forms.Label wmLabel19; + private System.Windows.Forms.TextBox wmTextBox18; + private System.Windows.Forms.Label wmLabel18; + private System.Windows.Forms.TextBox wmTextBox17; + private System.Windows.Forms.Label wmLabel17; + private System.Windows.Forms.TextBox wmTextBox16; + private System.Windows.Forms.Label wmLabel16; + private System.Windows.Forms.TextBox wmTextBox15; + private System.Windows.Forms.Label wmLabel15; + private System.Windows.Forms.TextBox wmTextBox14; + private System.Windows.Forms.Label wmLabel14; + private System.Windows.Forms.TextBox wmTextBox13; + private System.Windows.Forms.Label wmLabel13; + private System.Windows.Forms.TextBox wmTextBox48; + private System.Windows.Forms.Label wmLabel48; + private System.Windows.Forms.TextBox wmTextBox47; + private System.Windows.Forms.Label wmLabel47; + private System.Windows.Forms.TextBox wmTextBox46; + private System.Windows.Forms.Label wmLabel46; + private System.Windows.Forms.TextBox wmTextBox45; + private System.Windows.Forms.Label wmLabel45; + private System.Windows.Forms.TextBox wmTextBox44; + private System.Windows.Forms.Label wmLabel44; + private System.Windows.Forms.TextBox wmTextBox43; + private System.Windows.Forms.Label wmLabel43; + private System.Windows.Forms.TextBox wmTextBox42; + private System.Windows.Forms.Label wmLabel42; + private System.Windows.Forms.TextBox wmTextBox41; + private System.Windows.Forms.Label wmLabel41; + private System.Windows.Forms.TextBox wmTextBox40; + private System.Windows.Forms.Label wmLabel40; + private System.Windows.Forms.TextBox wmTextBox39; + private System.Windows.Forms.Label wmLabel39; + private System.Windows.Forms.TextBox wmTextBox38; + private System.Windows.Forms.Label wmLabel38; + private System.Windows.Forms.TextBox wmTextBox37; + private System.Windows.Forms.Label wmLabel37; + private System.Windows.Forms.TextBox wmTextBox36; + private System.Windows.Forms.Label wmLabel36; + private System.Windows.Forms.TextBox wmTextBox35; + private System.Windows.Forms.Label wmLabel35; + private System.Windows.Forms.TextBox wmTextBox34; + private System.Windows.Forms.Label wmLabel34; + private System.Windows.Forms.TextBox wmTextBox33; + private System.Windows.Forms.Label wmLabel33; + private System.Windows.Forms.TextBox wmTextBox32; + private System.Windows.Forms.Label wmLabel32; + private System.Windows.Forms.TextBox wmTextBox31; + private System.Windows.Forms.Label wmLabel31; + private System.Windows.Forms.TextBox wmTextBox30; + private System.Windows.Forms.Label wmLabel30; + private System.Windows.Forms.TextBox wmTextBox29; + private System.Windows.Forms.Label wmLabel29; + private System.Windows.Forms.TextBox wmTextBox28; + private System.Windows.Forms.Label wmLabel28; + private System.Windows.Forms.TextBox wmTextBox27; + private System.Windows.Forms.Label wmLabel27; + private System.Windows.Forms.TextBox wmTextBox26; + private System.Windows.Forms.Label wmLabel26; + private System.Windows.Forms.TextBox wmTextBox25; + private System.Windows.Forms.Label wmLabel25; + private System.Windows.Forms.Label activityLabel; + private System.Windows.Forms.PictureBox pictureBox1; + private System.Windows.Forms.PictureBox pictureBox2; + private System.Windows.Forms.PictureBox pictureBox3; + private System.Windows.Forms.PictureBox pictureBox4; + private System.Windows.Forms.PictureBox pictureBox5; + private System.Windows.Forms.PictureBox pictureBox6; + private System.Windows.Forms.PictureBox pictureBox7; + private System.Windows.Forms.PictureBox pictureBox8; + private System.Windows.Forms.PictureBox pictureBox9; + private System.Windows.Forms.PictureBox pictureBox10; + private System.Windows.Forms.PictureBox pictureBox11; + private System.Windows.Forms.PictureBox pictureBox12; + private System.Windows.Forms.PictureBox pictureBox13; + private System.Windows.Forms.PictureBox pictureBox14; + private System.Windows.Forms.PictureBox pictureBox15; + private System.Windows.Forms.PictureBox pictureBox16; + private System.Windows.Forms.PictureBox pictureBox17; + private System.Windows.Forms.PictureBox pictureBox18; + private System.Windows.Forms.PictureBox pictureBox19; + private System.Windows.Forms.PictureBox pictureBox20; + private System.Windows.Forms.PictureBox pictureBox21; + private System.Windows.Forms.PictureBox pictureBox22; + private System.Windows.Forms.PictureBox pictureBox23; + private System.Windows.Forms.PictureBox pictureBox24; + private System.Windows.Forms.PictureBox pictureBox25; + private System.Windows.Forms.PictureBox pictureBox26; + private System.Windows.Forms.PictureBox pictureBox27; + private System.Windows.Forms.PictureBox pictureBox28; + private System.Windows.Forms.PictureBox pictureBox29; + private System.Windows.Forms.PictureBox pictureBox30; + private System.Windows.Forms.PictureBox pictureBox31; + private System.Windows.Forms.PictureBox pictureBox32; + private System.Windows.Forms.PictureBox pictureBox33; + private System.Windows.Forms.PictureBox pictureBox34; + private System.Windows.Forms.PictureBox pictureBox35; + private System.Windows.Forms.PictureBox pictureBox36; + private System.Windows.Forms.PictureBox pictureBox37; + private System.Windows.Forms.PictureBox pictureBox38; + private System.Windows.Forms.PictureBox pictureBox39; + private System.Windows.Forms.PictureBox pictureBox40; + private System.Windows.Forms.PictureBox pictureBox41; + private System.Windows.Forms.PictureBox pictureBox42; + private System.Windows.Forms.PictureBox pictureBox43; + private System.Windows.Forms.PictureBox pictureBox44; + private System.Windows.Forms.PictureBox pictureBox45; + private System.Windows.Forms.PictureBox pictureBox46; + private System.Windows.Forms.PictureBox pictureBox47; + private System.Windows.Forms.PictureBox pictureBox48; + private CheckBoxImage checkBoxImage1; + private CheckBoxImage checkBoxImage2; + private CheckBoxImage checkBoxImage3; + private CheckBoxImage checkBoxImage4; + private CheckBoxImage checkBoxImage5; + private CheckBoxImage checkBoxImage6; + private CheckBoxImage checkBoxImage7; + private CheckBoxImage checkBoxImage8; + private CheckBoxImage checkBoxImage9; + private CheckBoxImage checkBoxImage10; + private CheckBoxImage checkBoxImage11; + private CheckBoxImage checkBoxImage12; + private CheckBoxImage checkBoxImage13; + private CheckBoxImage checkBoxImage14; + private CheckBoxImage checkBoxImage15; + private CheckBoxImage checkBoxImage16; + private CheckBoxImage checkBoxImage17; + private CheckBoxImage checkBoxImage18; + private CheckBoxImage checkBoxImage19; + private CheckBoxImage checkBoxImage20; + private CheckBoxImage checkBoxImage21; + private CheckBoxImage checkBoxImage22; + private CheckBoxImage checkBoxImage23; + private CheckBoxImage checkBoxImage24; + private CheckBoxImage checkBoxImage25; + private CheckBoxImage checkBoxImage26; + private CheckBoxImage checkBoxImage27; + private CheckBoxImage checkBoxImage28; + private CheckBoxImage checkBoxImage29; + private CheckBoxImage checkBoxImage30; + private CheckBoxImage checkBoxImage31; + private CheckBoxImage checkBoxImage32; + private CheckBoxImage checkBoxImage33; + private CheckBoxImage checkBoxImage34; + private CheckBoxImage checkBoxImage35; + private CheckBoxImage checkBoxImage36; + private CheckBoxImage checkBoxImage37; + private CheckBoxImage checkBoxImage38; + private CheckBoxImage checkBoxImage39; + private CheckBoxImage checkBoxImage40; + private CheckBoxImage checkBoxImage41; + private CheckBoxImage checkBoxImage42; + private CheckBoxImage checkBoxImage43; + private CheckBoxImage checkBoxImage44; + private CheckBoxImage checkBoxImage45; + private CheckBoxImage checkBoxImage46; + private CheckBoxImage checkBoxImage47; + private CheckBoxImage checkBoxImage48; + private System.Windows.Forms.Button saveButton; + private System.Windows.Forms.PictureBox samplePictureBox1; + private System.Windows.Forms.PictureBox samplePictureBox2; + private System.Windows.Forms.PictureBox samplePictureBox3; + private System.Windows.Forms.Label sampleLabel1; + private System.Windows.Forms.Label sampleLabel2; + private System.Windows.Forms.Label sampleLabel3; + + } +} \ No newline at end of file diff --git a/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.resx b/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.resx new file mode 100644 index 000000000..20987c220 --- /dev/null +++ b/TBF/Rig/RegisterReaders/iPerlReaderUNI/test/iPerlCommunicationForm.resx @@ -0,0 +1,3577 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAADAAAAAeCAYAAABqpJ3BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAD4pJREFUWEd1WHeUXPV53TgNI4MAdW1T2V2tyqoLJIqBOMc2f/icnJwkzskxJ8RY + 2MYBUww4BJwAFqYaHEAFGQkhIWlXEhJCSNt7b7O7U3Z6773tzM7s7N7c78lLQtM5V783772Z/e5X7vf9 + fkW1tbX4OoTDYURiUQWxWOwzRONcE3EkUkkk0ykkk1yJdDKFDDGVSCI3lUE2k0Y2m0V6OotULov4TBax + mRwihRwSmEUcBaRmC5iem8Mc+E/+K/C/6RlgKgdk8phL5ZCPJr/SPsHXEhDj/UEfvF4v7HY7HDY7fD4f + 75NQJIZQKEIyCUSjUeXdWCSKdDyBLElNk8x0LI4Yv4+ZPPI0PhQKIJlNIZHPwp+KIYUZBWliam6GtuaQ + yWSQz2SBfAFzuVmQIwrZWRRIRK6/ys6vJOB2u2FzWGF32mA2mxVMjI2jt7sHra3tCtraOtDV1QODwYBA + IIB4OIIESUT9fgXZWARzaRKJRxBy2ZGKBunePGLRAFKZGNK5FMKpsILENIkXpvmcVs4VkMtOI5VII08i + MzOzmGVQkqkphOiUL9r6JQJOp1MxWKtVQ6OZwEBfPzrbO3Dxwsf48PgJvH/kGI788SiOHTuOU6dqcfDg + Qezfvx8XPzoHzZgKSUZjJpPC7FQSM8kIMiFGIRVBIeJHLugCEkEUkgHkuWI2jbk5plkuiqnpmIJpEmPY + FDJurwfZ2RnEmIJTvCMpF5ye/py9nyPg8XiuentiAiMjQ2hpacKFj87j6HtHcOjAQRp/FLWn6nDy5Gmc + OHEShw4dJolTOHv2LI68dxiHD+xH3YkT6G1thkuvwWzYA8RCQPRPmNQAHjvgsgFerk4TECapdJjPSTTs + JkG+l47S5THmD2uAKZcnoQCjFuUanM3Bmoh8mYCkgcPhgFqtRm9vL1OkBcePH8PxYx/g8KF3lfXj8xfQ + 1NSCxsZmfPLJp+jtG0B9Y4Py/XNn63Dpk49x+eJ51L1/BMdeexk/+Zu78OOdO/Gr3bvxXzt349l1G/D7 + zdvx3s234h2u72zdiTe2bcdLW7fgv4l9e/bg/N4HYDt6FHNDg0CIURIH5NNMIabo3BQYV4TmppVofEZA + ilC8L/nc39+P+vp6erWO6bGfHj+Ny5c+VdKora0Nzc2taGENtHd04WTdGXzy6SUM8I8NDQ2guamBRE6j + /twZ9J05jfcefQS/3LEDP1tejNcrN+HMlj14f3E5Tly/EheWrkHdDSU4fVMpji8tw+ElJdi/rAxvLCrG + 0wtuxE+/dSPqH3kcMz09JMLoZOPI5ZOwBZ1K8SfnWE9MrSJFbVh0VqsVKpWKBjajrq4O7zElzpypRUND + gxKR4eFRpWglAkKgpaMTfSMjaO3swKX6K2hsbkB3dyd6ezrQfuUi2k99ANP5s7j02OPYf+ud+Gj77VDt + /h7UFbtgKtkMT9k2xCt3I8jP9vKtsKy7GZZNt0NdvRvtFdvwYfkGvFZagVe33wx6Dgh4Mcs0m52dQpxk + pDbyc7MoCgaDn3l/YGAAly5dYoEew4EDB9DX14ceeqCnq5sR6FIItLV3orO7C528bmxtQVtHO7r6etHV + 3422bkamvRX9XW3Q9bRi8vJ5GI+/j+YHfo7TG3ahY9VWGrsToWWbkSvejvRN1UjcVInUig0IE66l6+BY + Xg3L6q3Q1tyK5g078VTRn+N3Gzdhpq2VNRLEbDKuFHgsnkSBolUUpfz5PF5ManXo7uxSCvaP7x5WrsXw + vp5eDPb2KegnJBq9vd3KtTyX+0K8racLLb1d6O4X0l3o7WrGeHcztJc/ho+FXnvLnbhMI70VtwPr7oTn + r8sQv34NsGo78iUbEbqxHNGla5FdXYNwWTWs5VVQV21Ay7r1eGPZCvx+D7/nZJEHI4rasm0gT7Eq8rjc + SpNSj0+gqaFRKdZzZ85iZGgUQwPDGO4fwBCldLiX4PXAgBhMQsQwjR0dHGL+D6GHNdA51I++/kElcr19 + TLHOZuj72mA9VwvtY0+hteZ2DC3ZCMP1FcD27yK3fg+GihYgVLwe/pVVRAXcS0oxtWErrCtLYFxTAc3m + rThVUo5nVxRD89YBqhVlls2NNXw1AhaTGVazRWlUojKnPjyJjrZ2SqkGY6PjGBseUYwcGxyGamhYkdeh + kUHWBMkREqHubkZkdBTD/I3RARXG+oYxPjIKq06NvvqPYav/BPmTJ/HqwmXQ3fp9OLZ/B43XLMfg8irk + 7vkntC1cCcP6HdCw0FUlazBeshrujUyjVZVQVa1H946b8ezCG/DcLbsZgRBmQpRdGs8pBEWGST3sVpuS + QmepKnWnazFMg8fH1RgbmyAJFSYI7bAKatUYRsdGMDxOsGkNDg+xeJtwpb4R/SSqUeuhGRiHtkcF06gW + 4z19GOtqgauzCWBvOL7nNjTtvA34zSvAUy+gdmExsv/678CjzyD4D/cCDz0G/PQXKPyQ1//4I0yUVyqk + THf9LV6+8Sb8fMkiQK9lRyOBXJ5tgkWsVWsUAiaDEefPfaREQXrBKA1UjY8pkdEQk4yGrGMT4xhRX8Xg + 6AgaWlpxpamV1+PQqY2YHNTA2DsB14gRtkE1PPytqIqa3tEM1a8eB958B3/45iL03PE94LdvovDrfTi3 + cRfeXVYO7HsFtWVrcW5pMUbWboKhcitUK9dCs2UX6ioq8fjiG+A4f5q9IcCBL4MCB8MiMVDSyKg3KHrf + cKVeUSQxdFw9Ac2EGjoBo6FlnUxoGBmdBiqOGmMaLQZGxuh9pg29r9OaYBjSw9o3CfeAEe7BSWg6O5Ez + 6zHVeBkH7rwDiWeex9n129C06y7gxbeAV/cj/eRz6L/n7xVyeOFlJO+9H/jRXvi23Ab1ktVQr63B+VVr + 8PRNC9H75oscTYQAxxB2aSUCYryOxjQ3NqGNHjWZTNBO6qDTT0Kvm4SRMGknYWCayT2NAn5n0gCD3gK9 + wQLNpMxPFpjHbbCPmuEZscAzqkfYYMKs1YSZ1ia0/2Qv8Pr/4PD1y6D5zt8hff8jwEtv49P1O3GRpPDM + C6hbsQoNJZXQV2yFY/VmGBevZTFvxsXS1Xjyumth+uAQRw0S4GiRz02hSIyX9BEVEuOlgKUuJAoCeWY1 + mmCjIbIajUYYTEauZpIzwGqwMYJUMZ2JsMCkd8GmtcM2YkDC6mY9sJN6Oe8wikf23IG+O+8BnnieNfBb + 1F2zBHjgEcrrGnSu2wLsfQjdFZsxvKYG5tWb4C7bCCcL3V61A5+WV+PRb16L0OULzH925WQYmWwSRVK8 + QkLSSLS/ix1WojFfFwpIyEJvW3it1+ths9ngc7jgt7nhMblg0VuhNVqhszpgtHlgMTtJzAIHf9dj1CFn + nASrHqp79+LEt1bAue1utF+zGOrla6ErrcTY8lVQFVdgpIRYUYHJ0mp4V9XQ+Ao4V6yHpnwzTvH5fX/2 + lwDHfOTSVKAscjOZqzKqeJwYGhhUxmchIP1BSLgcTgVOXjss3CPIPfYNj5kkTDZ4DXbYTWK4E3oXO7rb + CxNXu9MBs0GDmJt/MELVuNSIo/Sq6ebvQrdsHeLVuxBjofpL18JPtQlVbWGTq4G9bD3cjECUsmplb/BU + 7cLA2m14/i8W4uy/3AfurhBlRCMx7iMyjIDX7VHyXFJICnacUilrgN3ZRxJCRN7xOGg04fO64bbb4Ddb + EWTqhMwORsMDq88Lvd+nwOTzwMFxOexzKLmKyUl4X/4DPizdiOFSzkGcfULF1YjS85Hl7MgkEVtVDQ+9 + b128BpYV66BnUzNUbkZXSRUOLliMB7+xAIkLl9nIEsqGJzs7q+zklFFCvC96L6kkxqvYhDz0etDrU7wv + nVqM9rmcCPi98NK7EaZQzO5C3OFF2OuHg9tHAwcuvZ9kAh54xXiZ6yOcJCmlzf98H9p33g37trug4dgQ + prJEV1chxOL0rSyHr6wKAea/d/V2GFdthm7jDkx++268WPQNvLBkObqfeBqUPcyFYshM5eHnLBTNTKMo + wW2adGKJgOS7yKqkklFvQigQhv9PJMR4v5t573ORGA3nbinOrWecKROi91002hrk/jnshy8SwEyKQxfD + jKAfLnb3g1tvQcvOb6OLU6adY7WpehNshGltJbTsvAamj6NmD8wbb8NAxXZcrKzBvoUL8Usqzwc/pMSq + xygGbhRkiOMM5ORMFExShSQCkiZmKoxEQlJohCODelxD4wOQ54IE8zgS8MMfcCPM+TwR8CkkYh63QsDD + e554EMEUN/fcC3PHz91VHFEOdj+rWoe3a7ahcfddeP+6RejggHa5rBRXyktQX1JKlKOpbB0ul1SjbtEa + HLqxFM8vWoFHipej7sF/Q7y7gZMoI5pLIuR0KQTSHOaSxNUNDecL8bQoktJ5mUYyRuh0emVSTSW4OU/L + cUkcEW7Ko7Egd3wEPS2Ic9cUn4rxB5PITKdQEAKRGNxUtb17duMH1y3Aw9cvxBvFJXhr6WI8W1SE15Zc + h5cWXYt9C67B7xZch1dI7Pm/ugG/ESwuw9MbamA4ehgFPbt4jo5zcL8dZ01Shfy+MEthGtEpjhJCQBCP + xhT1kVQSrRcC3d29rL9J5cgkn5lCju07lUpwFg9hKh0nqYSCHLtiHjkOiNxk5KeRS8SQc3lx7IV9ePuh + h9H55hu4+OAv0Pf4o2h74MewvfQcGh+8n3n9MAb/40ni1xhkjvc98Z+wvv42UM/Zn2oHrwNTPiNScQcC + QTOicQ9m8hnaE0eKIfhsSzkP2dhYLBZ6XsdhjqMEIRt8jeZqt5adm5zdzHAGmZsrKOc9MzRYRsMCFWEq + m4ZskGxsdFbVBJI2Bwp+1oPLhVlKMH/8qmE2XrOXgHUFPqPm8jNTxM55n4oGpw8Z1lfU7UTISwSZqnRa + IhlBPH71kG3e5s8REMiximwvJQparVYhME9GiMmphZCUwy451IpEIkpjkwYn78sqqhUUFbNTYmm4n0bL + dUAOx/hZVkGI74SZ04II6zDONE4FgkhzXJa0DoX+D7L1lb/3/40XfImAQDwt0RASMpmK8WNjY8oq0RBD + JbXmIcTkvqwyR9lopMNiZsOzsgGyI/NaZFjkV1aB9BRRtQBFQCBCIJDrIMUhyMhJNMVwcZIYL/iirV9J + QCBfdDG84m0hMm+oeHgecgggEZJ3JHLyvhzNyPtyKGY2GxkpKyMkESMph43vsacwNQReyuI8AlQ1Hxug + y+Wg80gscJWAeF8IfNHz8/haAgIhIT8gZ6KSMuJdMVy8LZERwyV95L5cz5OV1UzPm+h5o5lDID0uo4WF + ERHIiZt8djICNkZC4JFeQu/LfXk+7/15fJV9tbW1+F9fRhPYu2Ht2AAAAABJRU5ErkJggg== + + + \ No newline at end of file diff --git a/TBF/TBF.csproj b/TBF/TBF.csproj index 890022ecc..7f6ca43c5 100644 --- a/TBF/TBF.csproj +++ b/TBF/TBF.csproj @@ -1171,6 +1171,34 @@ + + + + + + + + UserControl + + + IPerlCfgCtrl.cs + + + UserControl + + + IperlHeadTestCtrl.cs + + + + + + Form + + + iPerlCommunicationForm.cs + + Form @@ -3057,6 +3085,15 @@ RRCfgCtrl.cs + + IPerlCfgCtrl.cs + + + IperlHeadTestCtrl.cs + + + iPerlCommunicationForm.cs + CycleBeginningForm.cs @@ -3757,7 +3794,6 @@ Results -