Upcoming changes

Optimizer/Hardware.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Optimizer
+{
+    public class CPU
+    {
+        public string Name { get; set; }
+        public ByteSize L2CacheSize { get; set; }
+        public ByteSize L3CacheSize { get; set; }
+        public UInt32 Cores { get; set; }
+        public UInt32 Threads { get; set; }
+        public UInt32 LogicalCpus { get; set; }
+        public string Virtualization { get; set; }
+        public string DataExecutionPrevention { get; set; }
+        public string Stepping { get; set; }
+        public string Revision { get; set; }
+    }
+
+    public class RAM
+    {
+        public string BankLabel { get; set; }
+        public UInt64 Capacity { get; set; }
+        public string FormFactor { get; set; }
+        public string Manufacturer { get; set; }
+        public string MemoryType { get; set; }
+        public UInt32 Speed { get; set; }
+    }
+
+    public class VirtualMemory
+    {
+        public ByteSize TotalVirtualMemory { get; set; }
+        public ByteSize AvailableVirtualMemory { get; set; }
+        public ByteSize UsedVirtualMemory { get; set; }
+    }
+
+    public class GPU
+    {
+        public string Name { get; set; }
+        public ByteSize Memory { get; set; }
+        public UInt32 ResolutionX { get; set; }
+        public UInt32 ResolutionY { get; set; }
+        public UInt32 RefreshRate { get; set; }
+        public string DACType { get; set; }
+        public string VideoMemoryType { get; set; }
+    }
+
+    public class Disk
+    {
+        public UInt32 BytesPerSector { get; set; }
+        public string FirmwareRevision { get; set; }
+        public string MediaType { get; set; }
+        public string Model { get; set; }
+        public ByteSize Capacity { get; set; }
+    }
+
+    public class Volume
+    {
+        public UInt64 BlockSize { get; set; }
+        public ByteSize Capacity { get; set; }
+        public string Compressed { get; set; }
+        public string DriveLetter { get; set; }
+        public string DriveType { get; set; }
+        public string FileSystem { get; set; }
+        public ByteSize FreeSpace { get; set; }
+        public ByteSize UsedSpace { get; set; }
+        public string Indexing { get; set; }
+        public string Label { get; set; }
+    }
+
+    public class NetworkDevice
+    {
+        public string AdapterType { get; set; }
+        public string Manufacturer { get; set; }
+        public string ProductName { get; set; }
+        public string PhysicalAdapter { get; set; }
+        public string MacAddress { get; set; }
+        public string ServiceName { get; set; }
+    }
+
+    public class Keyboard
+    {
+        public string Name { get; set; }
+        public string Layout { get; set; }
+        public string Status { get; set; }
+        public UInt16 FunctionKeys { get; set; }
+        public string Locked { get; set; }
+    }
+
+    public class PointingDevice
+    {
+        public string Name { get; set; }
+        public string Manufacturer { get; set; }
+        public string Status { get; set; }
+        public UInt16 Buttons { get; set; }
+        public string Locked { get; set; }
+        public string HardwareType { get; set; }
+        public string PointingType { get; set; }
+        public string DeviceInterface { get; set; }
+    }
+
+    public class AudioDevice
+    {
+        public string ProductName { get; set; }
+        public string Manufacturer { get; set; }
+        public string Status { get; set; }
+    }
+
+    public class Motherboard
+    {
+        public string Model { get; set; }
+        public string Manufacturer { get; set; }
+        public string Chipset { get; set; }
+        public string Product { get; set; }
+        public string Version { get; set; }
+        public string Revision { get; set; }
+        public string SystemModel { get; set; }
+
+        public string BIOSName { get; set; }
+        public string BIOSManufacturer { get; set; }
+        public string BIOSVersion { get; set; }
+        public string BIOSBuildNumber { get; set; }
+    }
+}

Optimizer/IndiciumHelper.cs

@@ -0,0 +1,477 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Management;
+using System.IO;
+using System.Net.NetworkInformation;
+using System.Runtime.InteropServices;
+using System.Globalization;
+using Microsoft.Win32;
+
+namespace Optimizer
+{
+    public static class IndiciumHelper
+    {
+        public static List<CPU> GetCPUs()
+        {
+            List<CPU> CPUs = new List<CPU>();
+            CPU cpu;
+
+            ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Processor");
+            foreach (ManagementObject mo in searcher.Get())
+            {
+                cpu = new CPU();
+
+                cpu.Name = Convert.ToString(mo.Properties["Name"].Value);
+                cpu.L2CacheSize = ByteSize.FromKiloBytes(Convert.ToDouble(mo.Properties["L2CacheSize"].Value));
+                cpu.L3CacheSize = ByteSize.FromKiloBytes(Convert.ToDouble(mo.Properties["L3CacheSize"].Value));
+                cpu.Cores = Convert.ToUInt32(mo.Properties["NumberOfCores"].Value);
+                cpu.Threads = Convert.ToUInt32(mo.Properties["ThreadCount"].Value);
+                cpu.LogicalCpus = Convert.ToUInt32(mo.Properties["NumberOfLogicalProcessors"].Value);
+                bool temp = Convert.ToBoolean(mo.Properties["VirtualizationFirmwareEnabled"].Value);
+                cpu.Virtualization = (temp) ? "Yes" : "No";
+                cpu.Stepping = Convert.ToString(mo.Properties["Description"].Value);
+                cpu.Revision = Convert.ToString(mo.Properties["Revision"].Value);
+
+                try
+                {
+                    ManagementObjectSearcher searcher2 = new ManagementObjectSearcher("SELECT * FROM Win32_OperatingSystem");
+                    foreach (ManagementObject mo2 in searcher2.Get())
+                    {
+                        bool temp2 = Convert.ToBoolean(mo2.Properties["DataExecutionPrevention_Available"].Value);
+                        cpu.DataExecutionPrevention = (temp2) ? "Yes" : "No";
+                    }
+                }
+                catch { }
+
+                if (string.IsNullOrEmpty(cpu.Name)) cpu.Name = GetCPUNameAlternative();
+
+                CPUs.Add(cpu);
+            }
+
+            return CPUs;
+        }
+
+        private static string GetCPUNameAlternative()
+        {
+            using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"HARDWARE\DESCRIPTION\System\CentralProcessor\0", false))
+            {
+                return key.GetValue("ProcessorNameString").ToString();
+            }
+        }
+
+        public static List<RAM> GetRAM()
+        {
+            List<RAM> modules = new List<RAM>();
+            RAM module;
+
+            ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMemory");
+            foreach (ManagementObject mo in searcher.Get())
+            {
+                module = new RAM();
+
+                module.BankLabel = Convert.ToString(mo.Properties["BankLabel"].Value);
+                module.Capacity = Convert.ToUInt64(mo.Properties["Capacity"].Value);
+                module.Manufacturer = Convert.ToString(mo.Properties["Manufacturer"].Value);
+                module.Speed = Convert.ToUInt32(mo.Properties["Speed"].Value);
+                UInt16 memorytype = Convert.ToUInt16(mo.Properties["MemoryType"].Value);
+                UInt16 formfactor = Convert.ToUInt16(mo.Properties["FormFactor"].Value);
+                module.MemoryType = SanitizeMemoryType(memorytype);
+                module.FormFactor = SanitizeFormFactor(formfactor);
+
+                modules.Add(module);
+            }
+
+            return modules;
+        }
+
+        public static List<GPU> GetGPUs()
+        {
+            List<GPU> GPUs = new List<GPU>();
+            GPU gpu;
+
+            ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_VideoController");
+            foreach (ManagementObject mo in searcher.Get())
+            {
+                gpu = new GPU();
+
+                gpu.Name = Convert.ToString(mo.Properties["Name"].Value);
+                gpu.Memory = ByteSize.FromBytes(Convert.ToDouble(mo.Properties["AdapterRAM"].Value));
+                gpu.ResolutionX = Convert.ToUInt32(mo.Properties["CurrentHorizontalResolution"].Value);
+                gpu.ResolutionY = Convert.ToUInt32(mo.Properties["CurrentVerticalResolution"].Value);
+                gpu.RefreshRate = Convert.ToUInt32(mo.Properties["CurrentRefreshRate"].Value);
+                gpu.DACType = Convert.ToString(mo.Properties["AdapterDACType"].Value);
+                UInt16 vtype = Convert.ToUInt16(mo.Properties["VideoMemoryType"].Value);
+                gpu.VideoMemoryType = SanitizeVideoMemoryType(vtype);
+
+                GPUs.Add(gpu);
+            }
+
+            return GPUs;
+        }
+
+        public static List<Motherboard> GetMotherboards()
+        {
+            List<Motherboard> motherboards = new List<Motherboard>();
+            Motherboard mobo;
+
+            ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_BaseBoard");
+            foreach (ManagementObject mo in searcher.Get())
+            {
+                mobo = new Motherboard();
+
+                mobo.Model = Convert.ToString(mo.Properties["Model"].Value);
+                mobo.Manufacturer = Convert.ToString(mo.Properties["Manufacturer"].Value);
+                mobo.Product = Convert.ToString(mo.Properties["Product"].Value);
+                mobo.Version = Convert.ToString(mo.Properties["Version"].Value);
+
+                try
+                {
+                    ManagementObjectSearcher searcher2 = new ManagementObjectSearcher("SELECT * FROM Win32_IDEController");
+                    foreach (ManagementObject mo2 in searcher2.Get())
+                    {
+                        mobo.Chipset = Convert.ToString(mo2.Properties["Description"].Value);
+                    }
+                }
+                catch { }
+
+                try
+                {
+                    ManagementObjectSearcher searcher3 = new ManagementObjectSearcher("SELECT * FROM Win32_IDEController");
+                    foreach (ManagementObject mo3 in searcher3.Get())
+                    {
+                        mobo.Revision = Convert.ToString(mo3.Properties["RevisionNumber"].Value);
+                    }
+                }
+                catch { }
+
+                try
+                {
+                    ManagementObjectSearcher searcher4 = new ManagementObjectSearcher("SELECT * FROM Win32_ComputerSystem");
+                    foreach (ManagementObject mo4 in searcher4.Get())
+                    {
+                        mobo.SystemModel = Convert.ToString(mo4.Properties["Model"].Value);
+                    }
+                }
+                catch { }
+
+                ManagementObjectSearcher searcher5 = new ManagementObjectSearcher("SELECT * FROM Win32_BIOS");
+                foreach (ManagementObject mo5 in searcher5.Get())
+                {
+                    mobo.BIOSName = Convert.ToString(mo5.Properties["Name"].Value);
+                    mobo.BIOSManufacturer = Convert.ToString(mo5.Properties["Manufacturer"].Value);
+                    mobo.BIOSVersion = Convert.ToString(mo5.Properties["Version"].Value);
+                    mobo.BIOSBuildNumber = Convert.ToString(mo5.Properties["BuildNumber"].Value);
+                    //ReleaseDate = DateTime.Parse(mo.Properties["ReleaseDate"].Value.ToString());
+                }
+
+                motherboards.Add(mobo);
+            }
+
+            return motherboards;
+        }
+
+        public static List<Disk> GetStorageDevices()
+        {
+            List<Disk> Disks = new List<Disk>();
+            //List<Volume> Volumes = new List<Volume>();
+            //List<Volume> Removables = new List<Volume>();
+            //List<Volume> Opticals = new List<Volume>();
+
+            Disk disk;
+
+            ManagementObjectSearcher searcher2 = new ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive");
+            foreach (ManagementObject mo2 in searcher2.Get())
+            {
+                disk = new Disk();
+
+                disk.Model = Convert.ToString(mo2.Properties["Model"].Value);
+                disk.BytesPerSector = Convert.ToUInt32(mo2.Properties["BytesPerSector"].Value);
+                disk.FirmwareRevision = Convert.ToString(mo2.Properties["FirmwareRevision"].Value);
+                disk.MediaType = Convert.ToString(mo2.Properties["MediaType"].Value);
+                disk.Capacity = ByteSize.FromBytes(Convert.ToDouble(mo2.Properties["Size"].Value));
+
+                Disks.Add(disk);
+            }
+
+            return Disks;
+        }
+
+        public static List<NetworkDevice> GetNetworkDevices()
+        {
+            List<NetworkDevice> adapters = new List<NetworkDevice>();
+            NetworkDevice adapter;
+
+            ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapter");
+            foreach (ManagementObject mo in searcher.Get())
+            {
+                adapter = new NetworkDevice();
+
+                adapter.AdapterType = Convert.ToString(mo.Properties["AdapterType"].Value);
+                adapter.Manufacturer = Convert.ToString(mo.Properties["Manufacturer"].Value);
+                adapter.ProductName = Convert.ToString(mo.Properties["ProductName"].Value);
+                bool isPhysical = Convert.ToBoolean(mo.Properties["PhysicalAdapter"].Value);
+                adapter.PhysicalAdapter = (isPhysical) ? "Yes" : "No";
+                adapter.MacAddress = Convert.ToString(mo.Properties["MacAddress"].Value);
+                adapter.ServiceName = Convert.ToString(mo.Properties["ServiceName"].Value);
+
+                if (isPhysical) adapters.Add(adapter);
+            }
+
+            return adapters;
+        }
+
+        private static string SanitizeDriveType(UInt32 i)
+        {
+            string result = string.Empty;
+
+            switch (i)
+            {
+                case 0:
+                    result = "Unknown";
+                    break;
+                case 1:
+                    result = "No Root Directory";
+                    break;
+                case 2:
+                    result = "Removable Disk";
+                    break;
+                case 3:
+                    result = "Local Disk";
+                    break;
+                case 4:
+                    result = "Network Drive";
+                    break;
+                case 5:
+                    result = "Compact Disk";
+                    break;
+                case 6:
+                    result = "RAM Disk";
+                    break;
+            }
+
+            return result;
+        }
+
+        private static string SanitizeVideoMemoryType(UInt16 i)
+        {
+            string result = string.Empty;
+
+            switch (i)
+            {
+                case 1:
+                    result = "Other";
+                    break;
+                case 2:
+                    result = "Unknown";
+                    break;
+                case 3:
+                    result = "VRAM";
+                    break;
+                case 4:
+                    result = "DRAM";
+                    break;
+                case 5:
+                    result = "SRAM";
+                    break;
+                case 6:
+                    result = "WRAM";
+                    break;
+                case 7:
+                    result = "EDO RAM";
+                    break;
+                case 8:
+                    result = "Burst Synchronous DRAM";
+                    break;
+                case 9:
+                    result = "Pipelined Burst SRAM";
+                    break;
+                case 10:
+                    result = "CDRAM";
+                    break;
+                case 11:
+                    result = "3DRAM";
+                    break;
+                case 12:
+                    result = "SDRAM";
+                    break;
+                case 13:
+                    result = "SGRAM";
+                    break;
+            }
+
+            return result;
+        }
+
+        private static string SanitizeFormFactor(UInt16 i)
+        {
+            string result = string.Empty;
+
+            switch (i)
+            {
+                case 0:
+                    result = "Unknown";
+                    break;
+                case 1:
+                    result = "Other";
+                    break;
+                case 2:
+                    result = "SIP";
+                    break;
+                case 3:
+                    result = "DIP";
+                    break;
+                case 4:
+                    result = "ZIP";
+                    break;
+                case 5:
+                    result = "SOJ";
+                    break;
+                case 6:
+                    result = "Proprietary";
+                    break;
+                case 7:
+                    result = "SIMM";
+                    break;
+                case 8:
+                    result = "DIMM";
+                    break;
+                case 9:
+                    result = "TSOP";
+                    break;
+                case 10:
+                    result = "PGA";
+                    break;
+                case 11:
+                    result = "RIMM";
+                    break;
+                case 12:
+                    result = "SODIMM";
+                    break;
+                case 13:
+                    result = "SRIMM";
+                    break;
+                case 14:
+                    result = "SMD";
+                    break;
+                case 15:
+                    result = "SSMP";
+                    break;
+                case 16:
+                    result = "QFP";
+                    break;
+                case 17:
+                    result = "TQFP";
+                    break;
+                case 18:
+                    result = "SOIC";
+                    break;
+                case 19:
+                    result = "LCC";
+                    break;
+                case 20:
+                    result = "PLCC";
+                    break;
+                case 21:
+                    result = "BGA";
+                    break;
+                case 22:
+                    result = "FPBGA";
+                    break;
+                case 23:
+                    result = "LGA";
+                    break;
+            }
+
+            return result;
+        }
+
+        private static string SanitizeMemoryType(UInt16 i)
+        {
+            string result = string.Empty;
+
+            switch (i)
+            {
+                case 0:
+                    result = "Unknown";
+                    break;
+                case 1:
+                    result = "Other";
+                    break;
+                case 2:
+                    result = "DRAM";
+                    break;
+                case 3:
+                    result = "Synchonous DRAM";
+                    break;
+                case 4:
+                    result = "Cache DRAM";
+                    break;
+                case 5:
+                    result = "EDO";
+                    break;
+                case 6:
+                    result = "EDRAM";
+                    break;
+                case 7:
+                    result = "VRAM";
+                    break;
+                case 8:
+                    result = "SRAM";
+                    break;
+                case 9:
+                    result = "RAM";
+                    break;
+                case 10:
+                    result = "ROM";
+                    break;
+                case 11:
+                    result = "Flash";
+                    break;
+                case 12:
+                    result = "EEPROM";
+                    break;
+                case 13:
+                    result = "FEPROM";
+                    break;
+                case 14:
+                    result = "EPROM";
+                    break;
+                case 15:
+                    result = "CDRAM";
+                    break;
+                case 16:
+                    result = "3DRAM";
+                    break;
+                case 17:
+                    result = "SDRAM";
+                    break;
+                case 18:
+                    result = "SGRAM";
+                    break;
+                case 19:
+                    result = "RDRAM";
+                    break;
+                case 20:
+                    result = "DDR";
+                    break;
+                case 21:
+                    result = "DDR2";
+                    break;
+                case 22:
+                    result = "DDR2 FB-DIMM";
+                    break;
+                case 24:
+                    result = "DDR3";
+                    break;
+                case 25:
+                    result = "FBD2";
+                    break;
+            }
+
+            return result;
+        }
+    }
+}

Optimizer/MainForm.cs

@@ -37,8 +37,8 @@ namespace Optimizer
         PingReply tmpReply;
 
         //NetworkMonitor _networkMonitor;
-        double uploadSpeed = 0;
-        double downloadSpeed = 0;
+        //double uploadSpeed = 0;
+        //double downloadSpeed = 0;
 
         DesktopItemType _desktopItemType = DesktopItemType.Program;
         DesktopTypePosition _desktopItemPosition = DesktopTypePosition.Top;
@@ -548,7 +548,7 @@ namespace Optimizer
             GetDesktopItems();
             GetCustomCommands();
 
-            GetFeed();
+            //GetFeed();
             GetFootprint();
 
             LoadSettings();
@@ -604,6 +604,48 @@ namespace Optimizer
                 lblUpdateDisabled.Visible = true;
             }
 
+            // Indicium-related
+            var CPUs = IndiciumHelper.GetCPUs();
+            var RAM = IndiciumHelper.GetRAM();
+            var GPUs = IndiciumHelper.GetGPUs();
+            var Motherboards = IndiciumHelper.GetMotherboards();
+            var Storage = IndiciumHelper.GetStorageDevices();
+            var Network = IndiciumHelper.GetNetworkDevices();
+
+            foreach (var x in CPUs)
+            {
+                txtCPU.Text += string.Format("{0} ({1} Cores, {2} Threads)\nVirtualization: {3}\nL2 Cache: {4}\nL3 Cache: {5}\n\n", x.Name, x.Cores, x.Threads, x.Virtualization, x.L2CacheSize, x.L3CacheSize);
+            }
+
+            ulong totalMemory = 0;
+            string ramDetails = string.Empty;
+            foreach (var x in RAM)
+            {
+                totalMemory += (x.Capacity);
+                ramDetails = x.MemoryType + " @ " + x.Speed;
+            }
+            txtRAM.Text = string.Format("{0} GB {1} MHz\n{2} modules", totalMemory / 1024 / 1024 / 1024, ramDetails, RAM.Count);
+
+            foreach (var x in GPUs)
+            {
+                txtGPU.Text += string.Format("{0} ({1} × {2} @ {3} Hz)\n\n", x.Name, x.ResolutionX, x.ResolutionY, x.RefreshRate);
+            }
+
+            foreach (var x in Motherboards)
+            {
+                txtMobo.Text += string.Format("{0} - {1}\n{2}\n\n", x.Manufacturer, x.Product, x.Chipset);
+            } 
+
+            foreach (var x in Storage)
+            {
+                txtStorage.Text += string.Format("{0} ({1})\nFirmware: {2}\n\n", x.Model, x.Capacity, x.FirmwareRevision);
+            }
+
+            foreach (var x in Network)
+            {
+                txtNetwork.Text += string.Format("{0}\nMAC Address: {1}\n\n", x.ProductName, x.MacAddress);
+            }
+
             // network monitoring
             //_networkMonitor = new NetworkMonitor();
         }
@@ -705,14 +747,12 @@ namespace Optimizer
 
             try
             {
+                byte[] feedData;
                 string tmpImageFileName = string.Empty;
-                string tmpDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Optimizer-tmp");
 
-                Directory.CreateDirectory(tmpDir);
-                client.DownloadFile(_feedImages, Path.Combine(tmpDir, "feed-images.raw"));
+                feedData = client.DownloadData(_feedImages);
 
-                using (FileStream fs = new FileStream(Path.Combine(tmpDir, "feed-images.raw"), FileMode.Open))
-                using (ZipArchive zip = new ZipArchive(fs))
+                using (ZipArchive zip = new ZipArchive(new MemoryStream(feedData)))
                 {
                     var zipEntries = zip.Entries;
 

Optimizer/MainForm.resx

@@ -137,6 +137,517 @@
         UeQoaCh7mQhyNDSc0ebT0gINaZT5pLRBw9rafEpaoaFtZT4h7dDwXjVHyyzQEJ81R8ps0DAfNUfJrNBQ
         7zVHyOzQcL8zr8oq0JC/Mq/IatCwr82jsio09It5RFbH4ct/S5CfRERERERERERERERE5CZvb38B7qmZ
         VUrZey8AAAAASUVORK5CYII=
+</value>
+  </data>
+  <data name="pictureBox11.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
+        EgAACxIB0t1+/AAAD85JREFUeF7tkkGu5MiOBPv+p+qbzd8YplRFi6aSlZEvhHQDbOfOoAT+E0IIIYQQ
+        QgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQggf5d9///2/HTK+YNlX
+        ZMyPYnudJGuG0GMH9A4ZX7DsqzLqx7CdTpR1Q1hjh/MOGV+w7Ksy6kewfU6WtUNw7GjeIeMLln1VRv0I
+        ts/psnoIFTuYd8j4gmUnMu7j2C6ny+ohVOxg3iHjC5adyLiPYns8QdYPoWIH8w4ZX7DsVEZ+BHv/KfIJ
+        Icywo+qkWrDs38jYrdi7T5LPCGGGHVUn1YJl/1ZGb8Pe/JSs8BuW+y+phTDDjqqTasGy75Dxb8Xe+aSs
+        scQ6JvEQZthRdVItWPZd8sRbsPmflDVarPunREOYYUfVSbVg2XfLUyNs3qdllVtY/0+JhjDDjqqTasGy
+        O+XZFuv+lKx0G5txlVgIM+yoOqkWLBt/yW96CZtzlVgIM+yoOqkWLBt/yW96CZtzlVgIM+yoOqkWLBt/
+        yW96CZtzlVgIM+yoOqkWLBt/l191G5txlVgIM+yoOqkWLBt/l191C+v/KdEQZthRdVItWDZW+V0t1v1T
+        oiHMsKPqpFqwbHT5ZUusYxIPYYYdVSfVgmXjWn7bb1juv6QWwgw7qk6qBcvGvfLrQ5hhR9VJtWDZuFd+
+        fQgz7Kg6qRYsG/fKrw9hhh1VJ9WCZeNe+fUhzLCj6qRasOxKKo/A9j9FVgxhhh1VJ9WCZVdSeQS2/ymy
+        Yggz7Kg6qRYsu5LKI7D9T5EVQ5hhR9VJtWDZlVQege1/iqwYwgw7qk6qBcuupPIIbP9TZMUQZthRdVIt
+        WHYllUdg+58iK4Yww46qk2rBsiupPALb/xRZMYQZdlSdVAuWXUlFsfxueVqx/CmyYggz7Kg6qRYsu5KK
+        Yvnd8rRi+VNkxRBm2FF1Ui1YdiUVxfK75WnF8qfIiiHMsKPqpFqw7EoqiuV3y9OK5U+RFUOYYUfVSbVg
+        2ZVUFMvvlqcVy9+VEWNs5lViIcywo+qkWrDsSiqK5XfL04rl78qIMTbzKrEQZthRdVItWHYlFcXyu+Vp
+        xfJ3ZcQYm3mVWAgz7Kg6qRYsu5KKYvnd8rRi+bsyYozNvEoshBl2VJ1UC5ZdSUWx/G55WrH8XRkxxmZe
+        JRbCDDuqTqoFy66kolh+tzytWP6ujBhjM68SC2GGHVUn1YJlV1JRLL9bnlYsf1dGjLGZV4mFMMOOqpNq
+        wbIrqSiW3y1PK5Y/RVYMYYYdVSfVgmVXUlEsv1ueVix/iqwYwgw7qk6qBcuupKJYfrc8rVj+FFkxhBl2
+        VJ1UC5ZdSUWx/G55WrH8KbJiCDPsqDqpFiy7ksojsP1PkRVDmGFH1Um1YNmVVB6B7X+KrBjCDDuqTqoF
+        y66k8ghs/1NkxRBm2FF1Ui1YdiWVR2D7nyIrhjDDjqqTasGyK6k8Atv/FFkxhBl2VJ1UC5ZdSeUR2P6n
+        yIohzLCj6qRasOxKKo/A9j9FVgxhhh1VJ9WCZeNe+fUhzLCj6qRasGzcK78+hBl2VJ1UC5aNe+XXhzDD
+        jqqTasGyca/8+hBm2FF1Ui1Y9tvl14yxmVeJhTDDjqqTasGy3y6/ZozNvEoshBl2VJ1UC5b9dvk1Y2zm
+        VWIhzLCj6qRasOy3y68ZYzOvEgthhh1VJ9WCZb9dfs0Ym3mVWAgz7Kg6qRYs++3ya8bYzKvEQphhR9VJ
+        tWDZuFd+fQgz7Kg6qRYsG/fKrw9hhh1VJ9WCZeNe+fUhzLCj6qRasGzcK78+hBl2VJ1UC5ZdSeUR2P6n
+        yIohzLCj6qRasOxKKo/A9j9FVgxhhh1VJ9WCZVdSeQS2/ymyYggz7Kg6qRYsu5LKI7D9T5EVQ5hhR9VJ
+        tWDZlVQege1/iqwYwgw7qk6qBcuupPIIbP9TZMUQZthRdVItWHYllUdg+58iK4Yww46qk2rBsiupKJbf
+        LU8rlj9FVgxhhh1VJ9WCZVdSUSy/W55WLH+KrBjCDDuqTqoFy66kolh+tzytWP4UWTGEGXZUnVQLll1J
+        RbH8bnlasfwpsmIIM+yoOqkWLLuSimL53fK0Yvm7MmKMzbxKLIQZdlSdVAuWXUlFsfxueVqx/F0ZMcZm
+        XiUWwgw7qk6qBcuupKJYfrc8rVj+rowYYzOvEgthhh1VJ9WCZVdSUSy/W55WLH9XRoyxmVeJhTDDjqqT
+        asGyK6kolt8tTyuWvysjxtjMq8RCmGFH1Um1YNmVVBTL75anFcvflRFjbOZVYiHMsKPqpFqw7EoqiuV3
+        y9OK5U+RFUOYYUfVSbVg2ZVUFMvvlqcVy58iK4Yww46qk2rBsiupKJbfLU8rlj9FVgxhhh1VJ9WCZVdS
+        USy/W55WLH+KrBjCDDuqTqoFy66k8ghs/1NkxRBm2FF1Ui1YdiWVR2D7nyIrhjDDjqqTasGyK6k8Atv/
+        FFkxhBl2VJ1UC5ZdSeUR2P6nyIohzLCj6qRasOxKKo/A9j9FVgxhhh1VJ9WCZVdSeQS2/ymyYggz7Kg6
+        qRYsu5LKI7D9T5EVQ5hhR9VJtWDZuFd+fQgz7Kg6qRYsG/fKrw9hhh1VJ9WCZeNe+fUhzLCj6qRasGzc
+        K78+hBl2VJ1UC5b9dvk1Y2zmVWIhzLCj6qRasOy3y68ZYzOvEgthhh1VJ9WCZb9dfs0Ym3mVWAgz7Kg6
+        qRYs++3ya8bYzKvEQphhR9VJtWDZb5dfM8ZmXiUWwgw7qk6qBct+u/yaMTbzKrEQZthRdVItWPbb5deM
+        sZlXiYUww46qk2rBsnGv/PoQZthRdVItWDbulV8fwgw7qk6qBcvGvfLrQ5hhR9VJtWDZuFd+fQgz7Kg6
+        qRYsu5LKI7D9T5EVQ5hhR9VJtWDZlVQege1/iqwYwgw7qk6qBcuupPIIbP9TZMUQZthRdVItWHYllUdg
+        +58iK4Yww46qk2rBsiupPALb/xRZMYQZdlSdVAuWXUnlEdj+p8iKIcywo+qkWrDsSiqPwPY/RVYMYYYd
+        VSfVgmVXUlEsv1ueVix/iqwYwgw7qk6qBcuupKJYfrc8rVj+FFkxhBl2VJ1UC5ZdSUWx/G55WrH8KbJi
+        CDPsqDqpFiy7kopi+d3ytGL5U2TFEGbYUXVSLVh2JRXF8rvlacXyd2XEGJt5lVgIM+yoOqkWLLuSimL5
+        3fK0Yvm7MmKMzbxKLIQZdlSdVAuWXUlFsfxueVqx/F0ZMcZmXiUWwgw7qk6qBcuupKJYfrc8rVj+rowY
+        YzOvEgthhh1VJ9WCZVdSUSy/W55WLH9XRoyxmVeJhTDDjqqTasGyK6kolt8tTyuWvysjxtjMq8RCmGFH
+        1Um1YNmVVBTL75anFcufIiuGMMOOqpNqwbIrqSiW3y1PK5Y/RVYMYYYdVSfVgmVXUlEsv1ueVix/iqwY
+        wgw7qk6qBcuupKJYfrc8rVj+FFkxhBl2VJ1UC5ZdSeUR2P6nyIohzLCj6qRasOxKKo/A9j9FVgxhhh1V
+        J9WCZVdSeQS2/ymyYggz7Kg6qRYsu5LKI7D9T5EVQ5hhR9VJtWDZlVQege1/iqwYwgw7qk6qBcuupPII
+        bP9TZMUQZthRdVItWHYllUdg+58iK4Yww46qk2rBsnGv/PoQZthRdVItWDbulV8fwgw7qk6qBcvGvfLr
+        Q5hhR9VJtWDZuFd+fQgz7Kg6qRYs++3ya8bYzKvEQphhR9VJtWDZb5dfM8ZmXiUWwgw7qk6qBct+u/ya
+        MTbzKrEQZthRdVItWPbb5deMsZlXiYUww46qk2rBst8uv2aMzbxKLIQZdlSdVAuW/Xb5NWNs5lViIcyw
+        o+qkWrBs3Cu/PoQZdlSdVAuWjXvl14cww46qk2rBsnGv/PoQZthRdVItWDbulV8fwgw7qk6qBcuupPII
+        bP9TZMUQZthRdVItWHYllUdg+58iK4Yww46qk2rBsiupPALb/xRZMYQZdlSdVAuWXUnlEdj+p8iKIcyw
+        o+qkWrDsSiqPwPY/RVYMYYYdVSfVgmVXUnkEtv8psmIIM+yoOqkWLLuSyiOw/U+RFUOYYUfVSbVg2ZVU
+        FMvvlqcVy58iK4Yww46qk2rBsiupKJbfLU8rlj9FVgxhhh1VJ9WCZVdSUSy/W55WLH+KrBjCDDuqTqoF
+        y66kolh+tzytWP4UWTGEGXZUnVQLll1JRbH8bnlasfxdGTHGZl4lFsIMO6pOqgXLrqSiWH63PK1Y/q6M
+        GGMzrxILYYYdVSfVgmVXUlEsv1ueVix/V0aMsZlXiYUww46qk2rBsiupKJbfLU8rlr8rI8bYzKvEQphh
+        R9VJtWDZlVQUy++WpxXL35URY2zmVWIhzLCj6qRasOxKKorld8vTiuXvyogxNvMqsRBm2FF1Ui1YdiUV
+        xfK75WnF8ndlxBibeZVYCDPsqDqpFiy7kopi+d3ytGL5U2TFEGbYUXVSLVh2JRXF8rvlacXyp8iKIcyw
+        o+qkWrDsSiqK5XfL04rlT5EVQ5hhR9VJtWDZlVQUy++WpxXLnyIrhjDDjqqTasGyK6k8Atv/FFkxhBl2
+        VJ1UC5ZdSeUR2P6nyIohzLCj6qRasOxKKo/A9j9FVgxhhh1VJ9WCZVdSeQS2/ymyYggz7Kg6qRYsu5LK
+        I7D9T5EVQ5hhR9VJtWDZlVQege1/iqwYwgw7qk6qBcuupPIIbP9TZMUQZthRdVItWDbulV8fwgw7qk6q
+        BcvGvfLrQ5hhR9VJtWDZuFd+fQgz7Kg6qRYsG/fKrw9hhh1VJ9WCZeNaflvBsiuphDDDjqqTasGyscrv
+        +k+sZxIPYYYdVSfVgmVjld/VYt0/JRrCDDuqTqoFy8bf5VfdxmZcJRbCDDuqTqoFy8Zf8ptewuZcJRbC
+        DDuqTqoFy8Zf8ptewuZcJRbCDDuqTqoFy8Zf8ptewuZcJRbCDDuqTqoFy35Cnv8Ny/20rPYSNucqsRBm
+        2FF1Ui1Ydoc89xI25ydkndvYjKvEQphhR9VJtWDZd8ozf4XN/aSscQvr/ynREGbYUXVSLVj2XfLEW7D5
+        n5Q1Wqz7p0RDmGFH1Um1YNl3yPi3Y299SlZYYh2TeAgz7Kg6qRYs+7cyehv25idljf/HMv8ltRAqdjDv
+        kPEFy/6NjN2Ovf0U+YQQKnYw75DxBctOZeRHsPefIp8QQsUO5h0yvmDZiYz7KLbHE2T9ECp2MO+Q8QXL
+        TmTcx7FdTpfVQ6jYwbxDxhcs+6qM+hFsn5Nl7RAcO5p3yPiCZV+VUT+G7XSqrByCY0fzDhlfsOwrMuZH
+        sb1Ok1VD+G/seN4h4wuWfUXG/Ci210myZgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBC
+        CCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEMJm/vnnf9Am/pQwewxKAAAAAElFTkSuQmCC
+</value>
+  </data>
+  <data name="pictureBox9.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
+        EgAACxIB0t1+/AAAEmtJREFUeF7tlFGS5TYOwHL/U+Vmu50JknpbC083KcmWaKIKX9OGSPl5/miapmma
+        pmmapmmapmn2588///zPkzJG0zQrsY9vZxm7aZoo9kFVkPWapvkH+1DeJNfQNO/BPoS2/zNoCmM/+PZa
+        rq1pzsV+2G1crrNp9sd+wO08ueam2Qf7obbr5fqb5hnsR9neL6+jae7BfoTt8/J6mmY+9oNr95XX1jRj
+        2I+rPUdeY9PEsB9Te6681qb5HvsBtTXkFTfN/2M/mLaevO6m+Rv7kbT15fU3b8V+FO375OfQvAn7IZzg
+        brP/uswP7G9OkPGb6tjL31nG/hf7m6dltEvsmV1l5KYi9sJ3k1EV+/tdZMQfYc/vJGM2VbCXvIuM+CPs
+        +Z1kzBDW2UVGbE7GXuzTMloI6+wmo6ax5tMyWnMa9jKflLFSWG/Uld0ZWPtJGas5AXuBT8lIQ1h31FXd
+        v/w19CSs/5SM1OyMvbgnZJxhrD0q6V/Yv49Kejp21t0ySrMb9rLullGmYWeMSvp/sL8blfQS7Ly7ZZRm
+        B+wF3SljTMfOGpGsYn8/Itml2Ll3yhjNk9iLuUtGWIKdNyppxf5+VNLLsbPvkhGaJ7AXcoccvxQ7d0Sy
+        v8WeG5X0Ldj5d8jxzZ3Yi1gtRy/Hzh6R7I+w50ckeys2x2o5ulmNXf4dcvxy7OxRSf8Ie35U0rdic9wh
+        xzcrsAtfLUffhs0wItkQ1hmR7CPYPKvl6GYmdtEr5dhbsTlGJJvCeiOSfQybaaUc28zALnilHHs7NsuI
+        ZNNYc0Syj2EzrZRjmxHsYlfJkY9g84xIdgjrjkj2cWy2VXJkk8EudJUc+Qg2z4hkp2D9Eck+js22So5s
+        IthFrpIjH8NmGpHsFKw/ItktsPlWyZHNT7ALXCHHPYrNNSLZqdg5I5LdBptxhRzX/A67uBVy3OPYbCOS
+        nY6dlZXkVticK+S4xrALWyHHPY7NNiLZJdh5I5LdCptzthzVGHZhM+WYbbAZs5Jcip2bleSW2Lwz5Zjm
+        E7uomXLMNtiMI5Jdip07ItktsXlnyjHNX9gFzZRjtsLmzEryFuz8rCS3xWaeKce8G7uYmXLMVticI5K9
+        BTt/RLLbYjPPlGPeiV3ITDlmO2zWrCRvxebISnJrbO6Zcsy7sIuYKcdsh806ItnbsVmyktwam3umHPMe
+        7BJmyRFbYvNmJfkINk9Wkttjs8+SI96BXcAsOWJLbN4RyT6GzZSV5PbY7LPkiNrY4rPkiG2xmbOSfBSb
+        KyvJI7D5Z8kRNbGFZ8kRW2NzZyX5ODZbVpJHYPPPkiPqYcvOkPzW2NxZSW6BzZeV5DHYDjMkXwtbdIbk
+        t8dmz0pyG2zGjOSOwvaYIfka2IIzJL89NntWklthc2YleRS2xwzJn48tNyrpI7D5s5LcDps1I7njsF1G
+        JX02ttgMyR+BzZ+R3JbYvFlJHoXtMUPyZ2ILzZD8Edj8WUluic2bleRx2C4zJH8etsyopI/BdshIbmts
+        7ozkjsT2GZX0Wdgio5I+BtshK8mtsbmzkjwS22dU0mdgC4xK+ihsj4zkjsDmz0juWGynUUnvjw0/Kumj
+        sD0ykjsCmz8rySOxfUYlvTc2+Kikj8L2yEryGGyHjOSOxXYalfS+2NAjkj0O2yUjuaOwPTKSOxrba0Sy
+        e2IDj0j2SGyfjOSOwvbISvJobK8Rye6FDToq6eOwXTKSOxLbJyO5o7G9RiS7FzboiGSPxPbJSO5IbJ+M
+        5I7HdhuR7B7YgKOSPg7bJSvJY7GdMpI7GttrVNLPY8ONSPZIbJ+M5I7G9spI7nhstxHJPosNNiLZY7Gd
+        MpI7GtsrI7kS2H4jkn0OG2pEssdiO2Ukdzy2W0Zyx2O7jUj2GWygEckei+2UkVwJbL+M5Epg+41I9n5s
+        mBHJHovtlJFcCWy/jORKYPuNSPZ+bJisJI/G9spIrgy2Y0ZyJbD9spK8FxskK8mjsb0ykiuF7ZmRXBls
+        x6wk78OGaNv2Gfks78EGaNv2Wfk812OHt237rHyea7GD27bdQz7TddihbdvuIZ/pOuzQtm33kM90DXZg
+        27Z7yec6Hzusbdu95HOdjx3Wtu1e8rnOxQ5q23ZP+WznYYe0bbunfLbzsEPatt1TPts52AFt2+4tn+84
+        Fm/bdm/5fMexeNu2e8vnO4aF27Y9Qz7jPBbNSK4MtmNGcq/D7iIqqZLYvhnJ5bFoRnJlsB2jknoldh9R
+        SZXE9s1ILocFM5Irhe0ZldQrsfuISqostnNGcnEslpFcKWzPqKReid1HVFJlsZ0zkotjsYzkSmF7RiX1
+        Suw+MpIrie2bkVwci2UkVwrbMyqpV2L3kZFcSWzfjOTiWCwqqVLYnhnJvRa7k6ikymI7RyUVw0IZyZXC
+        9oxK6tXYvUQlVRbbOSO5n2ORjORKYXtGJfVq7F6ikiqL7ZyR3M+xSFRS5bBdo5J6NXYvUUmVxvaOSurn
+        WCQqqXLYrlFJvRq7l6ikSmN7RyX1cywSlVQ5bNeopF6N3UtGcmWxnaOS+hkWyEiuHLZrVFKvx+4mKqmy
+        2M4ZyX2PPZyRXClsz4zkXo/dTVRSZbGdM5L7Hns4Kqly2K5RSTVf2P1EJVUa2zsqqe+xh6OSKoftGpVU
+        84XdT1RSpbG9o5L6Hns4Kqly2K5RSTVf2P1EJVUa2zsqqe+xh6OSKoftGpVU84XdT1RSpbG9o5L6PfZg
+        RnLlsF2jkmq+sPuJSqo0tndGctfYQxnJlcN2jUqq+cLuJyqp0tjeGcldYw9FJVUS2zcqqeYLu5+opMpj
+        u0cldY09FJVUSWzfqKSaL+x+opIqj+0eldQ19lBUUiWxfaOSasDuKCqp0tjeUUldYw9FJVUS2zcqqQbs
+        jqKSKo3tHZXUNfZQVFIlsX2jkmrA7igqqdLY3lFJXWMPRSVVEts3IpnmA7unqKRKY3tHJXWNPRSVVDls
+        16ikmg/snqKSKo3tHZXUNfZQVFLlsF2jkmo+sHuKSqo0tndUUtfYQ1FJlcN2jUqq+cDuKSqp0tjeUUld
+        Yw9FJVUO2zUqqeYDu6eopEpje0cldY09FJVUOWzXqKSaD+yeopIqje0dldQ19lBUUuWwXaOSaj6we4pK
+        qjS2d1RS19hDUUmVw3aNSqr5wO4pKqnS2N5RSV1jD0UlVQ7bNSqp5gO7p6ikSmN7RyV1jT0UlVQ5bNeo
+        pJoP7J6ikiqN7R2V1DX2UFRS5bBdo5JqPrB7ikqqNLZ3VFLX2ENRSZXDdo1KqvnA7ikqqdLY3lFJXWMP
+        RSVVDts1KqnmA7unqKRKY3tHJXWNPRSVVDls16ikmg/snqKSKo3tHZXUNfZQVFLlsF2jkmo+sHuKSqo0
+        tndUUtfYQ1FJlcN2jUqq+cDuKSqp0tjeUUldYw9FJVUO2zUqqeYDu6eopEpje0cldY09FJVUSWzfqKQa
+        sDuKSqo0tndUUtfYQ1FJlcT2jUqqAbujqKRKY3tHJXWNPRSVVEls36ikGrA7ikqqNLZ3VFLX2ENRSZXE
+        9o1KqgG7o6ikSmN7RyV1jT0UlVRJbN+opJov7H4ykiuN7R2V1DX2UFRSJbF9o5JqvrD7iUqqPLZ7VFLX
+        2EMZyZXDdo1KqvnC7icqqdLY3hnJXWMPZSRXDts1KqnmC7ufqKRKY3tnJPd77MGopMphu0Yl1Xxh9xOV
+        VGls76ikvscejkqqHLZrVFLNF3Y/UUmVxvaOSup77OGopMphu0Yl1Xxh9xOVVGls76ikvscejkqqHLZr
+        RnKvx+4mKqnS2N5RSX2PPZyRXClsz4zkXo/dTVRSZbGdM5L7Hns4I7ly2K5RSb0eu5uopMpiO2ck9zMs
+        EJVUOWzXqKRejd1LRnJlsZ2jkvo5FolKqhy2a1RSr8buJSO5stjOUUn9HItEJVUO2zUqqVdj9xKVVGls
+        76ikfo5FMpIrhe0ZldSrsXuJSqostnNGcj/HIhnJlcL2zEjutdidRCVVFts5I7kYFopKqhS2Z0Zyr8Xu
+        JCqpstjOUUnFsVhUUuWwXaOSei12J1FJlcV2jkoqjsUykiuF7RmV1Cux+8hIriS2b0ZycSyWkVwpbM+o
+        pF6J3UdUUmWxnTOSi2OxjORKYXtGJfVK7D6ikiqL7ZyRXA4LZiRXBtsxI7l/sb9p26z8rPJYtG3bM+Qz
+        zmPRtm3PkM94DAu3bbu3fL7jWLxt273l8x3H4m3b7i2f7xzsgLZt95TPdh52SNu2e8pnOw87pG3bPeWz
+        nYsd1LbtXvK5zscOa9t2L/lc52OHtW27l3yua7AD27bdQz7TddihbdvuIZ/pOuzQtm33kM90LXZw27bP
+        yue5Hju8bdufyWf0C/v3rCTvwQZ4m1zFL+zfM5Irhe2ZkVwZbMesJO/DhshK8mhsr4zkSmF7ZiRXBtsx
+        K8l7sUGykjwa2ysjuTLYjhnJlcD2y0ryfmyYrCSPxvbKSK4Etl9GciWw/UYkez82zIhkj8V2ykiuBLZf
+        RnIlsP1GJPsMNtCIZI/E9slK8nhst4zkjsd2G5Hsc9hQI5I9FtspI7mjsb0ykiuB7Tci2WexwUYkeyS2
+        T0ZyR2N7ZSR3PLbbiGSfx4YbkeyR2D5ZSR6J7ZOV5NHYXqOS3gMbcESyR2L7ZCR3JLZPRnLHY7uNSHYf
+        bMhRSR+H7ZKR3JHYPhnJHY3tNSLZ/bBhRyR7HLZLVpJHYXtkJXksttOopPfEBh6R7HHYLhnJHYXtkZHc
+        0dheI5LdFxt6VNJHYXtkJXkMtkNGcsdiO41Kem9s8FFJH4PtkJXkEdj8WUkeie0zKun9seFHJX0UtkdG
+        ckdg82ckdyy206ikz8AWGJX0MdgOWUlujc2dleSR2D6jkj4LW2RU0sdgO2QktzU2d0ZyR2L7jEr6PGyZ
+        GZI/Aps/K8ktsXmzkjwO22WG5M/EFpoh+e2x2bOS3BKbNyvJo7A9Zkj+bGyxUUkfgc2fleRW2JxZSR6H
+        7TIq6fOx5WZIfnts9qwkt8LmzEryKGyPGZKvgS04Q/LbY7NnJbkFNl9Wkkdhe8yQfC1s0RmS3xqbOyvJ
+        LbD5spI8BtthhuTrYcvOkiO2xubOSvJxbLasJI/A5p8lR9TEFp4lR2yLzZyV5KPYXFlJHoHNP0uOqI0t
+        PkuO2BKbd0Syj2EzZSW5PTb7LDniHdgFzJIjtsTmzUryEWyerCS3x2afJUe8B7uEmXLMdtisI5K9FZtj
+        RLJbY3PPlGPehV3ETDlmO2zWrCRvxebISnJrbO6Zcsw7sQuZKcdshc05ItlbsPNHJLstNvNMOebd2MXM
+        lGO2wubMSvIW7PysJLfFZp4pxzR/YRc0U47ZBptxRLJLsXNHJLslNu9MOab5xC5qthy1BTZfVpJLsXOz
+        ktwOm3W2HNUYdmGz5ajHsdlGJLsEO29Eslthc86Wo5or7NJWyHGPY7ONSHY6dlZWklthc66Q45rfYRe3
+        Qo57FJtrRLJTsXNGJLsNNuMKOa75CXaBq+TIx7CZRiQ7BeuPSHYLbL5VcmQTwS5ylRz5CDbPiGSnYP0R
+        yT6OzbZKjmwy2IWulGNvx2YZkewQ1h2R7KPYXCvl2GYEu9iVcuzt2Cwjkk1hvVFJP4bNtFKObWZgF7xS
+        jr0Vm2NEsimsNyLZx7CZVsqxzUzsolfL0bdhM4xINoR1RiT7CDbPajm6WYVd+mo5ejl29qikf4Q9Pyrp
+        W7E5VsvRzR3YC1gtRy/Hzh6R7I+w50ckeys2x2o5urkTexF3yPFLsXNHJPtb7LlRSd+CnX+HHN88gb2Q
+        u2SEJdh5o5JW7O9HJb0cO/suGaF5Ensxd8oY07GzRiSr2N+PSHYpdu6dMkazA/aC7pZRpmFnjEr6f7C/
+        G5X0Euy8u2WUZjfsZT0h4wxj7VFJ/8L+fVTSU7FznpBxmp2xF/eUjDSEdUdd1f3LX0NPwvpPyUjNCdgL
+        fFLGSmG9UVd2Z2DtJ2Ws5jTsZT4to4Wwzm4yahprPi2jNSdjL3YXGfFH2PM7yZghrLOLjNhUwV7ybjKq
+        Yn+/i4z4LfbsbjJqUxF74TvL2P9if/O0jHaJPbOrjNxUx17+Ce42+6/L/MD+5gQZv3kT9kNo3yc/h+at
+        2I+irS+vv2n+xn4kbT153U3j2I+mrSGvuGl+j/142nPltTZNDPsxtefIa2yaMezH1e4rr61p5mM/uPZ5
+        eT1Ncw/2I2zvl9fRNM9gP8p2vVx/0+yD/VDbeXLNTbM/9gNu43KdTXMu9sNur+XamqYe9oNv+6NvXoh9
+        CG+Sa2ia5h/sQ6kg6zVNE8U+qJ1l7KZpVmIf350yRtM0TdM0TdM0TdM0TbMtf/zxX3EpjEj54MAmAAAA
+        AElFTkSuQmCC
+</value>
+  </data>
+  <data name="pictureBox8.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
+        EgAACxIB0t1+/AAADrVJREFUeF7tlFF23EYSBH3/U/lmu892SLuig2IDAwwrGxnvxZeI6szuGv2Rxp9/
+        /vmfWqfKmpYrsYuudbqsbzmLXWqtabLOZRW7xFrTZb3L77CLq3UXWfPyEbusWneVtS9/YRdU6+6y/s/G
+        LqbWp8jP4JnYhdT6NPk5PA+7jFqfKD+J52CXUOtT5WfxDOwCan26/Dz2xorXWv+Rn8m+WOlXZfRP7G9q
+        fVXW6yf2N6/K6D2xwmdl5JfYt7Wuyhp9iX17Vkbuh5U9KqMOY7Nq/UzW5jA266iM2g8re0TGnMZm1vpR
+        1uU0NvOIjNkLK3pExryMza71h6zJy9jsIzJmH6zkqoy4DDujVtbjMuyMVRmxD1ZyVUZcip1TnytrcSl2
+        zqqM2AcruSKfX46dVZ8ra3E5dtaKfL4HVnBVRtyCnVefJ+twC3beqozIx8qtyOe3YWfW58k63IaduSKf
+        52PlVuTz27Az6/NkHW7DzlyRz/Oxcivy+W3YmfV5sg63YWeuyOf5WLkV+fw27Mz6PFmH27AzV+TzfKzc
+        inx+G3ZmfZ6sw23YmSvyeT5WbkU+vw07sz5P1uE27MwV+TwfK7cin9+GnVmfJ+twG3bminyej5VblRG3
+        YOfV58k63IKdtyoj8rFyqzLicuys+lxZi8uxs1ZlRD5W7oiMuRQ7pz5X1uJS7JwjMiYfK3dExlyGnVEr
+        63EZdsYRGZOPlTsqo17GZtf6Q9bkZWz2URmVj5U7I+NOYzNr/SjrchqbeUbG5WPlzsrIw9isWj+TtTmM
+        zTorI/Oxcq/K6C+xb2tdlTX6Evv2VRmdj5W7Uo75Bfu7Ws/KWv2C/d2Vckw+Vq7W+nv5+eRj5ZKl1hZY
+        vzpDnigfK5cstbbA+tUZ8kT5WLlkqbUF1q/OkCfKx8olS60tsH51hjxRPlYuWWptgfWrM+SJ8rFyyVJr
+        C6xfnSFPlI+VS5ZaW2D96gx5onysXLLU2gLrV2fIE+Vj5ZKl1hZYvzpDnigfK5cstbbA+tUZ8kT5WLlk
+        qbUF1q/OkCfKx8olS60tsH51hjxRPlYuWWptgfWrM+SJ8rFyyVJrC6xfnSFPlI+VS5ZaW2D96gx5onys
+        XLLU2gLrV2fIE+Vj5ZKl1hZYvzpDnigfK5cstbbA+tUZ8kT5WLlkqbUF1q/OkCfKx8olS60tsH51hjxR
+        PlYuWWptgfWrM+SJ8rFyyVJrC6xfnSFPlI+VS5ZaW2D96gx5onysXLLU2gLrV2fIE+Vj5ZKl1hZYvzpD
+        nigfK1dr/b38fPKxcrV+t9N38+8fzw5YuVq/U1az/wG8AytX63fJWv6N/fsUiZiPlav1O2Qlf2J/M0Ui
+        5mPlan23rOMv2N9NkYj5WLla3ymr+C/sb6dIxHysXK3vkjVU7O+nSMR8rFyt75AV/BT7ZopEzMfK1Xq3
+        rN9vse+mSMR8rFytd8rqfYl9O0Ui5mPlar1L1m4J+36KRMzHytV6h6zcMjZjikTMx8rVerWs2yFszhSJ
+        mI+Vq/VKWbXD2KwpEjEfK1frVbJmp7B5UyRiPlau1itkxU5jM6dIxHysXK2vynq9hM2dIhHzsXK1viKr
+        9TI2e4pEzMfK1XpW1uoSbP4UiZiPlav1jKzUZdgZUyRiPlau1qOyTpdi50yRiPlYuVqPyCpdjp01RSLm
+        Y+VqXZU1ugU7b4pEzMfK1boiK3QbduYUiZiPlav1K1mfW7Fzp0jEfKxcfY88wWls5jvk+Nuxs6dIxHys
+        XL1WrvptWIar5Ii3YOdPkYj5WLn6ulzvt2PZzsrIt2EZpkjEfKxcPS7XOR7LviKfvxXLMUUi5mPl6rpc
+        YxzW5TP55O1YlikSMR8rV38vV7cN1vGH/Mm3YHmmSMR8rFx1ubJtmdb3Y55JEjEfK1d/lat6DFM6f3yH
+        SRIxHytX/5ErKt+EvckUiZiPlav98U/A3mWKRMzHyj1ZrqUMwN5nikTMx8o9Va6kDMHeaIpEzMfKPU2u
+        ogzD3mqKRMzHyj1JrqEMxN5rikTMx8o9Ra6gDMXebIpEzMfKPUHql8HYu02RiPlYud2lehmOvd0UiZiP
+        ldtVKpcQ7A2nSMR8rNyOUrcEYe84RSLmY+V2k6olDHvLKRIxHyu3k9Qsgdh7TpGI+Vi5naRmCcTec4pE
+        zMfK7SIVSyj2plMkYj5WbgepV4Kxd50iEfOxculSrYRjbztFIuZj5ZKlVtkAe98pEjEfK5cstcoG2PtO
+        kYj5WLlUqVQ2wd54ikTMx8olSp2yEfbOUyRiPlYuUeqUjbB3niIR87FyaVKlbIa99RSJmI+VS5IaZUPs
+        vadIxHysXJLUKBti7z1FIuZj5VKkQtkUe/MpEjEfK5ciFcqm2JtPkYj5WLkEiV82xt59ikTMx8olSPyy
+        MfbuUyRiPlZuukQvm2NvP0Ui5mPlpkv0LbB+K/L51ljvKRIxHys3WWJHY71ekbHbYV2nSMR8rNxkiR2J
+        9blSjtkG6zhFIuZj5SZL7Cisx51ybDzWbYpEzMfKTZXIMViHd0qMWKzTFImYj5WbKpEjsPzfIXEisT5T
+        JGI+Vm6qRB6PZf9OiRWHdZkiEfOxchMl7ngs+wSJF4X1mCIR87FyEyXuaCz3JIkZg3WYIhHzsXITJe5Y
+        LPNEiRuB5Z8iEfOxctMk6mgs90SJG4HlnyIR87Fy0yTqWCzzZIk9Hss+RSLmY+WmSdSRWN4EiT8ayz1F
+        IuZj5aZJ1JFY3gSJPxrLPUUi5mPlpknUcVjWJKkxFss8RSLmY+UmScyRWN4kqTEWyzxFIuZj5SZJzHFY
+        1kSpMxLLO0Ui5mPlJknMcVjWRKkzEss7RSLmY+UmScxxWNZEqTMSyztFIuZj5SZJzHFY1kSpMxLLO0Ui
+        5mPlJknMUVjOZKk1Dss6RSLmY+UmScxRWM5kqTUOyzpFIuZj5SZJzFFYzmSpNQ7LOkUi5mPlJknMUVjO
+        ZKk1Dss6RSLmY+UmScxRWM5kqTUOyzpFIuZj5SZJzFFYzmSpNQrLOUli5mPlJknMUVjOZKk1Css5SWLm
+        Y+UmScxRWM5kqTUKyzlJYuZj5SZJzFFYzmSpNQrLOUli5mPlJknMUVjOZKk1Css5SWLmY+UmScxRWM5k
+        qTUKyzlJYuZj5SZJzHFY1kSpMw7LOkli5mPlJknMcVjWRKkzDss6SWLmY+UmScxxWNZEqTMOyzpJYuZj
+        5SZJzHFY1kSpMw7LOkli5mPlJknMkVjeJKkxEss7SWLmY+WmSdRxWNYkqTEOyzpNouZj5aZJ1JFY3gSJ
+        PxLLO02i5mPlpknUkVjeBIk/Ess7TaLmY+WmSdSxWObJEnsslnmaRM3Hyk2TqGOxzJMl9lgs8zSJmo+V
+        myhxx2KZJ0rcsVjmiRI3Hys3UeKOxnJPkpijsdwTJW4+Vm6ixB2PZZ8g8cZj2SdK3Hys3FSJPB7L/p0S
+        azyWfapEzsfKTZXIEVj+75A4EVj+qRI5Hys3VSLHYB3eKTFisA5TJXI+Vm6yxI7Cetwpx0ZhPSZL7Hys
+        3GSJHYd1uUOOi8O6TJbY+Vi5yRI7Fut0hYyPxTpNltj5WLnpEj0e63ZExsRj3aZL9Hys3HSJviXW9y/5
+        5y2xvtMlej5WLkHil3DsbRMkfj5WLkHil3DsbRMkfj5WLkUqlFDsTVOkQj5WLkUqlFDsTVOkQj5WLklq
+        lDDsLZOkRj5WLklqlDDsLZOkRj5WLk2qlBDsDdOkSj5WLlHqlOHY2yVKnXysXKLUKcOxt0uUOvlYuVSp
+        VIZib5YqlfKxcslSqwzD3ipZauVj5ZKlVhmGvVWy1MrHyqVLtTIEe6N0qZaPldtB6pVvxt5mB6mXj5Xb
+        RSqWb8LeZBepmI+V20lqljdjb7GT1MzHyu0mVcubsDfYTarmY+V2lLrlZuzud5S6+Vi5XaVyuQm7812l
+        cj5WbmepXS7G7npnqZ2PldtdqpeLsDveXarnY+WeIPXLi9jdPkHq52PlniJXUE5id/oUuYJ8rNyT5BrK
+        QewunyTXkI+Ve6JcR/kCu7snynXkY+WeKldSPsHu7KlyJflYuafL1ZT/w+7pyXIt+Vi52v8EfmB3U/sf
+        wGPkmh6H3UX9n1xTPlau/luua3use/23XFc+Vq5+Lte2Hda1fi7Xlo+Vq1/L9cVj3erXcn35WLm6LtcY
+        h3Wp63KN+Vi5ek6udCyWuZ6TK83HytXX5Xq/HctWX5frzcfK1evlum/Hzq7Xy3XnY+Xq++QZDmOz6vvk
+        GfKxcrXW38vPJx8rd6Uc8wv2d7WelbX6Bfu7K+WYfKzcqzJ6Cfu+1q9kfZaw71+V0flYubMy8jA2q9bP
+        ZG0OY7POysh8rNwZGXcam1nrR1mX09jMMzIuHyt3VEa9jM2u9YesycvY7KMyKh8rd0TGXIadUSvrcRl2
+        xhEZk4+VOyJjLsXOqc+VtbgUO+eIjMnHyq3KiMuxs+pzZS0ux85alRH5WLlVGXELdl59nqzDLdh5qzIi
+        Hyu3Ip/fhp1ZnyfrcBt25op8no+VW5HPb8POrM+TdbgNO3NFPs/Hyq3I57dhZ9bnyTrchp25Ip/nY+VW
+        5PPbsDPr82QdbsPOXJHP87FyK/L5bdiZ9XmyDrdhZ67I5/lYuRX5/DbszPo8WYfbsDNX5PN8rNyKfH4b
+        dmZ9nqzDbdiZK/J5PlZuVUbcgp1XnyfrcAt23qqM2AMruCKfX46dVZ8ra3E5dtaKfL4PVnJVRlyKnVOf
+        K2txKXbOqozYByu5KiMuw86olfW4DDtjVUbsg5U8ImNexmbX+kPW5GVs9hEZsxdW9IiMOY3NrPWjrMtp
+        bOYRGbMfVvaojDqMzar1M1mbw9isozJqP6zsWRn5JfZtrauyRl9i356VkXtihV+V0T+xv6n1VVmvn9jf
+        vCqj98VK11r/kZ/J3ljxWp8uP49nYBdQ61PlZ/Ec7BJqfaL8JJ6HXUatT5OfwzOxC6n1KfIzeDZ2MbXu
+        Lutf/sIuqNZdZe3LR+yyat1F1rz8Dru4WtNlvcsqdom1psk6l7PYpdY6Xda3XIlddK1TZE1D+OOP/wJo
+        lIwfEN4jTwAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="pictureBox7.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
+        EgAACxIB0t1+/AAAF7hJREFUeF7tnW2W3MiRLTUza9R+tbP3ki0TjwttjgKQEQhk8to59ke8192B6lR/
+        kCz+I4QQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGE
+        EEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCP/Nv/71r/8XYxwrH69nY4fH
+        GMfIx+y52NExxnHyUXsmdnCMcax83J6HHRtjHOs//vnP/+Mj9yzs2BjjePnIPQs7NMY4Rz52z8IOjTHO
+        kY/dd2APWCUWwldjf+3vSe3zsYerEgvh67G//vek9tnYg1WJhfAn8L/2GdiT3udiD1UlFsIfgX0G9nzs
+        Tw8exR6qSiyEPwb7HOxJ7TOxB6oSC+GPwj4Le1L7POxhqsRC+OOwz8Oe1D4Le5AqsRD+SOwzsSe1z8Ee
+        4qiMCF+Gfa1HyPiPw55lT2qfgT3AGRkTPhj7ut4h6z+B7/3pQTv+jIwJH4R9HZ8g5z0Su3fPj/npQTv+
+        jIwJD8e+dk+Wsx+F3bkntWdjh5+RMeGh2Nfsk+QxHoPduCe152JHn5Ex4WHY1+qT5bEegd23J7VnYgef
+        kTHhIdjX6JvkMZdjt+1J7XnYsUdlRHgA9vX5Znnspdhde1Ibjy0bJSuWYneNkPEfjT3XnySvYRXrf3rQ
+        loyUNcuwm0bKmk/kf+x5RsmOXay3wtcp//Pvi+7H7tlz+E8P2pKRsmYZdtNIWfNR2HO8K6PPcvj/hMj/
+        xjLvyujbsVv2pDYGWzBS1izDbhopaz4Ge4arMvItbG4nlb9h2asy8nbslj2pvY8NHylrlmE3jZQ1j8du
+        vyLjhmJ7TOK7WO+KjLsVu2NPau9hg0fKmmXYTSNlzaOxu8/KqFkc/o9h5H/Eumdl1K3YHXtSu44NHSlr
+        lmE3jZQ1j8VuPiNjpmO7TeKHsRlnZMyt2B2dVK5jQ0fKmmXYTSNlzSOxe4/KiDs59E8BZE9js47KiDsZ
+        /k9ELTa0SqzFOkdlxFRsb5VYi3WqxB6H3XpURtyO3bL1Ffvff6fPY/OOyojbsBtM4texoVViLdY5I2Om
+        YTurxFqsUyX2KOzOI76qlz9cI7CbTOKXsZlHpH4bdsNWotexoVViLdY5I2OmYTurxFqsUyX2GOzGKzLu
+        duyWrUTfwuYekfpt2A1VYtexoVViLdY5I2OmYTurxFqsUyX2COy+d737G1PYDVuJjuDSr4akewu2v0rs
+        Oja0SqzFOmdkzDRsZ5VYi3WqxJZjt42UNdOx3VuJDsN2/CTV6djuKrHr2NAqsRbrnJEx07CdVWIt1qkS
+        W4rdNUtWTsN2biU6FNvzk1SnYnurxK5jQ6vEWqxzRsZMw3ZWibVYp0psGXbTbFk9BdtnEh+K7dnzjn89
+        sr1VYtexoVViLdY5KiOmYnurxFqsUyW2DLvpLjlhOLZrK9Gh2J6fpDoN21kldh0bWiXWYp0qsWXYTVVi
+        LdapEluC3XO3nDIU27OV6FBszxGpT8H2VYldx4ZWibVYp0psGXZTlViLdarEbsdu2ZPabyxzVUYOw3Zs
+        JToU23NURgzHdlWJXceGVom1WKdKbBl2U5VYi3WqxO7m1E9f0dnj7W8Owpwh2PytRIdhO874GjHlm4rY
+        riqx69jQKrEW61SJLcNuqhJrsU6V2K3YHZ1UDmMzjsqIt7HZW4kOw3aclVFDsT1VYtexoVViLdapEluG
+        3VQl1mKdKrHbsBs6X/HLf1eyeUek/hY2dyvRYdiOKzJuGLajSuw6NrRKrMU6VWLLsJuqxFqsUyV2G3ZD
+        J5XL2MwjUr/K1N8V2DDs+yMybxi2o0rsOja0SqzFOlViy7CbqsRarFMldgu2v5PKEGz+nq/K1N+xR3QY
+        tuMdGTsEm18ldh0bWiXWYp0qsWXYTVViLdapErsF228SH4rt2ZPaaWzWVqLDsB1bX7HL38D0HWx+ldh1
+        bOhdcsJUbG+VWIt1qsSmY7s7qQzHdu1J7RQ2ZyvRIdh880z2l38NH4DNrhK7jg29U86Yhu2sEmuxTpXY
+        dGy3SXwatnNPaoexGVuJDsHmm8Rv/zrY7Cqx69jQO+WMadjOKrEW61SJTcX2msSnY7s7qRzGZmwl+jY2
+        2yT+G8uYxN/C5laJXceG3ilnTMN2Vom1WKdKbCq21yR+C7a/k8oRDv17Ntm3sLmdVH5jGZP4W9jcKrHr
+        2NA75Yxp2M4qsRbrVIlNw3aaxG/DbtiT2i7WM4m/hc01u9/xZ1mT+GVsZpXYdWzonXLGNGxnlViLdarE
+        pmE7TeK3Ynd0UtnFeluJvoXN7aTyNyxrEr+MzawSu44NvVPOmIbtrBJrsU6V2BRsn0l8CXZPJ5UW62wl
+        ehmb2UmlxTom8UvYvCqx97DBd8j6qdjeKrEW61SJTcH2mcSXYTeZxFuss5XoJWzentRarGMSv4TNqxJb
+        hx1VJbYMu6lKrMU6VWJTsH1biS7F7polK09js/ak9iPW3Ur0EjavSmwddlSV2DLspiqxFutUiQ3HdpnE
+        l2O3jZZVp7FZe1I7hPVN4qexWVVi67CjqsSWYTdVibVYp0psOLbLJP4Ehv2Gmk72HMZmHJH6IaxvEj+N
+        zaoSW4cdVSW2DLupSqzFOlViw7FdW4k+BrtxtKz6EesekfopbM5WoqexWVVi67CjqsSWYTdVibVYp0ps
+        NLf9gphR2H0zZa1i+SNSP43N2kr0NDarSmwddlSV2DLspiqxFutUiQ3F9pjEl2O33SHrf2OZozLiEjbP
+        JH4Km1Mltg47qkpsGXZTlViLdarEhmJ7thI9jM2oEjvPP//5fzbvLrnirf/+wIy3sLlbiZ7C5lSJrcOO
+        qhJbht1UJdZinSqxodierUT/zoQPJJMVy3+SPMbb2OytRE9hc6rE1mFHHZURU7G9I2XNUGzPVqJ/YT8+
+        U9bevne0PMYQbP5WoqewOVVi67CjzsiYadjOkbJmGLbDPJN9kn895D6HvifgO752DP8W3rbHJH4Ym1El
+        tg476oyMmYbtHClrhmE7vkEe7zA2Y4SMn4Lt20r0MDajSmwddtQZGTMN2zlS1gzDdnyyr0e6/A1CXwz9
+        pwFmTsN2biV6GJtRJbYOO+qMjJmG7Rwpa4ZhOz7V1+O88+H/D2//nwBzpmO7txI9jM2oEluHHXVGxkzD
+        do6UNcOwHZ8qj/Q2NvuojLgF27+V6GFsRpXYOuyoMzJmGrZzpKwZhu34RHmcYdiOPandit2xlehhbEaV
+        2DrsqKMyYjq2e4SMH4rtGSUrFMtftfs2Wu9ge0ziS7B7thI9jM2oEnsPGzxKVoSD2Du8IuPexmb/JNXh
+        2K6tRJdg92wlehibUSV2HRs6UtaEg9g7POqrPuI/uu1ie7cSHY7t2kp0CXbPVqKHsRlVYtexoSNlTTiI
+        vcOffNWm/Nn0hu3fSnQ4tmsr0SXYPVuJHsZmVIldx4aOlDXhIPYO96R2G3bDVqLDsV1bid7NtD830GZU
+        iV3Hho6UNeEg9g7NV3T6P+4bdstWosOxXVuJ3obdsCe1w9iMKrHr2NCRsiYcxN7hVqJLsHu2Eh2O7dpK
+        dD4Xf9cl7cPYjCqx69jQkbImHMTe4VaiS7B7thIdju3a+orN/e8hb/52a6YcxmZUib2HDR4lK8JB7B1u
+        JboEu2cr0eHYrp981Yb8H4LNviLjDmMzqsTWYUcdlRGhYO9pK9El2D0m8WHYjnfc+8VKlh8lKw5jM6rE
+        1mFHnZExAewdbSV6K3bHntSGYTs+UR7nMDajSmwddtQZGRPA3tFWordg+4/KiLex2Z8qj3QYm1Eltg47
+        6oyMCWDvaCvR6djuM75GPOK3Az9JnukwNqNKbB121BkZE8De0Vai07CdV32Ne8w3BHmCPNdhbEaV2Drs
+        qDMyJoC9o61Ep2D7Rsj4w9iMb5DHO4zNqBJbhx11RsYEsHdkEh/JLX+3ZdceH/d3/V9H2/9u/vWEJ7AZ
+        VWLrsKOOyoiwwd7VVqJDsPmfJI9x+3Ow9i/sx7cSPYXNqRJ7Dxs8SlYsxe4aIeOHY7u2En0bm/1J8hiK
+        5d/xNbL9RUWW30r0FDanSuw6NnSkrFmG3TRS1gzF9mwl+hY296iv+r8/DBP+JKIz/nXDRWzefyRyGJux
+        legpbE6V2HVs6EhZswy7aaSsGYrtMYlfwuYdlRG/scwdsn45dptJ/BQ2p0rsOjZ0pKxZht00UtYMx3Zt
+        JXoam3VE6orlZ8raR2D3bSV6GptVJXYdGzpS1izDbhopa4Zju7YSPYXNOSL1H7HuaFn1GOzGrURPY7Oq
+        xK5jQ0fKmmXYTSNlzXBsl0n8ENY/IvXD2IyRvlbc9i3QfsLuM4mfxmZViV3Hho6UNcuwm0bKmuHYLpP4
+        EU7/Gfr0TmOzRsuq5dhtJvHT2KwqsevY0JGyZhl200hZMwXbt5Xoj1h3T2qnsVmzZOVS7K6tRC9h86rE
+        rmNDq8RarHNURkzF9laJtVinSmwKts8k3mKdPaldwuZtJdpiHZP4Muwmk/glbF6V2HVsaJVYi3XOyJhp
+        2M4qsRbrVIlNwfaZxFus00nlMjZzK9EW63RSWYLdYxK/hM2rEruODa0Sa7HOGRkzDdtZJdZinSqxadhO
+        k/jfsGwnlbewuVuJ7mK9Tiq3YneYxC9jM6vErmNDq8RarHNGxkzDdlaJtVinSmwattMk/l9YrpPKW9hc
+        k/gu1tuT2m3YDSbxy9jMKrHr2NAqsRbrnJEx07CdVWIt1qkSm4rtNYn/xjKdVN7C5m4legjrd1K5Bdtv
+        En8Lm1sldh0bWiXWYp0zMmYatrNKrMU6VWJTsb0m8d9YxiT+NjZ7K9HD2IxOKtOx3Sbxt7C5VWLXsaFV
+        Yi3WOSNjpmE7q8RarFMlNh3bbRI/nR+Bzd9K9DA2Y09q07CdJvG3sdlVYtexoVViLdY5KiOmYnurxFqs
+        UyU2HdvdeSb/1/BB2PytRE9hc/akNhzb1UnlbWx2ldh1bGiVWIt1qsSWYTdVibVYp0rsFmy/+Yoe+q46
+        /546DtuxlehpbNae1IZie0ziQ7D5VWLXsaFVYi3WqRJbht1UJdZinSqxW7D978jYYdiOrUSvcNsvZTZs
+        fieVIdj8KrHr2NAqsRbrVIktw26qEmuxTpXYbdgNV3yNGvobamzH1lfsrZ0284jUL2MzO6kMw3ZUiV3H
+        hlaJtVinSmwZdlOVWIt1qsRuw264IuOGYTu2En0Lm3tE6lc49U1K6QzDdlSJXceGVom1WKdKbBl2U5VY
+        i3WqxG7F7jgro4ZhO7YSfRubfVRGHMZmdFIZiu2pEruODa0Sa7FOldgy7KYqsRbrVIndzel/H97KnGHY
+        jq1Eh2Dzz/ga8eO/jliv8xWf8j0KbFeV2HVsaJVYi3WqxJZhN1WJtVinSux27JajMmIotmcr0WHYjqsy
+        8jeW2ZPacGxXldh1bGiVWIt1qsSWYTdVibVYp0psCXbPEakPxfZsJToU23O3nDIF21cldh0bWiXWYp2j
+        MmIqtrdKrMU6VWLLsJt+kupQbM9WosOxXXfJCdOwnVVi17GhVWIt1jkjY6ZhO6vEWqxTJbaS03+UFr2h
+        2B6T+BRs30x//ZkIrJ6G7a0Su44NrRJrsc4ZGTMN21kl1mKdKrGl2F0/SXUotmcr0WnYzlmyciq2t0rs
+        Oja0SqzFOmdkzDRsZ5VYi3WqxJZjt/0k1WHYjq1Ep2O7R8qa6djuKrHr2NAqsRbrnJEx07CdVWIt1qkS
+        ewR230++au/8+f3/hc3fSvQeJv2xZUy/BdtfJXYdG1ol1mKdMzJmGrazSqzFOlVij8FuPCL1t7C5W4ne
+        jt1yRcbdht1QJXYdG1ol1mKdMzJmGrazSqzFOlVij8LuPCL1y9hMk/gqTv9H0/9I/zbshq1Er2NDq8Ra
+        rHNURkzF9laJtVinSuxx2K1HZcR5Dv4jN+nbsVuOyojbsBtM4texoVViLdapEluG3TRS1jwSu/eor/ql
+        X9pqs7a+YsP+u8NR7I6jMuJODv9TCvnr2NAqsRbrVIktw24aKWsei918RsYcxmaYxKdju8/ImFuxOzqp
+        XMeGVom1WKdKbBl200hZ82js7rMy6kesa76iU/8pwHaelVG3YnfsSe06NrRKrMU6VWLLsJtGyprnM+in
+        xJi2i/VM4kOxPWe941f4GXbLntTewwZXibVYp0psGXbTSFnzMdgzXJWRf8OynVTewuZelZG3Y7fsSe19
+        bHiVWIt1qsSWYTeNlDUfhT3HuzL6N5YxX9Fp/7HxrIy+HbtlT2pjsAVVYi3WqRJbht00UtZ8Im9/U5FR
+        cs8u1hslK5Zg9+w5/F9PbEmVWIt1qsSWYneNkPEfjT3XnySvYRXrfyenLblLTggPwL4+3yyPvRS7a09q
+        Y7FFd8oZ4SHY1+ib5DGXY7ftSW08tuxOOSM8DPtafbI81iOw+/akNgdbeKecER6Kfc0+SR7jMdiNe1Kb
+        hy29U84IT2fS762fJVc/CrtzT2pzscV3yhnhg7Cv4xPkvEdi9+55269GtOV3yhnhg7Gv6x2y/hN4xDdu
+        bbED7pD14cuwr/UIGf9x2LPsSe0zsAeoEgvhj8Q+E3tS+xzsIarEQvjjsM/DntQ+C3uQKrEQ/ijss7An
+        tc/DHqZKLIQ/Bvsc7EntM7EHqhIL4Y/APgN7rvrmI8Owh6oSC+FP4Nk/3TcDe6gqsRC+Hvvrf09qn409
+        WJVYCF+N/bW/J7VnYAfGGOfIx+4Z2IExxjnysXsOdmSMcbx85J6FHRpjHOtjf7rPjo0xjpWP2/OwY2OM
+        4+Sj9kzs4BjjGPmYPRs7PMb4nny8vht78CqxadjOKrFp2M4qsRbrVImFSdg7rxILHfbSqsSmYTurxKZh
+        O6vEWqxTJRYmYe+8Six02EurEpuG7awSm4btrBJrsU6VWJiEvfMqsdBhL61KbBq2s0psGrazSqzFOlVi
+        YRL2zqvEQoe9tCqxadjOKrFp2M4qsRbrVImFSdg7rxILHfbSqsSmYTurxKZhO6vEWqxTJRYmYe+8Six0
+        2EurEpuG7awSm4btrBJrsU6VWJiEvfMqsdBhL61KbBq2s0psGrazSqzFOlViYRL2zqvEQoe9tCqxadjO
+        KrFdrPdLfngX61WJtVinSmwX6/2SH/4R6/6SH/4R6/6SH/4R6/6SH/4R6/6SH97FelViocNeWpXYNGxn
+        lViLdarEWqxTJdZinSqxFutUibVYp0qsxTpVYi3WqRJrsU6VWIt1qsRCh720KrFp2M4qsRbrVIm1WKdK
+        rMU6VWIt1qkSa7FOlViLdarEWqxTJdZinSqxFutUiYUOe2lVYtOwnVViLdapEmuxTpVYi3WqxFqsUyXW
+        Yp0qsRbrVIm1WKdKrMU6VWIt1qkSCx320qrEpmE7q8RarFMl1mKdKrEW61SJtVinSqzFOlViLdapEmux
+        TpVYi3WqxFqsUyUWOuylVYlNw3ZWibVYp0qsxTpVYi3WqRJrsU6VWIt1qsRarFMl1mKdKrEW61SJtVin
+        Six02EurEpuG7awSa7FOlViLdarEWqxTJdZinSqxFutUibVYp0qsxTpVYi3WqRJrsU6VWOiwl1YlNg3b
+        WSXWYp0qsRbrVIm1WKdKrMU6VWIt1qkSa7FOlViLdarEWqxTJdZinSqx0GEvrUpsGrbzSXJmi3Xic+TL
+        FDrspVWJTcN2PknObLFOfI58mUKHvbQqsWnYzifJmS3Wic+RL1PosJdWJTYN2/kkObPFOvE58mUKHfbS
+        qsSmYTufJGe2WCc+R75MocNeWpXYNGznk+TMFuvE58iXKXTYS6sSm4btfJKc2WKd+Bz5MoUOe2lVYlOx
+        vU+Q837EunG9fHnCHvbiqsRCCN+IfeirxEII34h96KvEQgjfiH3oq8RCCN+IfeirxEII34h96KvEQgjf
+        iH3oq8RCCN+IfeirxEII34h96KvEQgjfiH3oq8RCCN+IfeirxEII34h96KvEQgjfiH3oq8RCCN+Ifeir
+        xEII34h96KvEQgjfin3wf8kPhxBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQ
+        QgghhBBCCCGEEEIIIYQQQgghhPBl/OMf/x+PjaVS7RewEQAAAABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="pictureBox6.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
+        EgAACxIB0t1+/AAAFmhJREFUeF7tkwGOG0kSxO7/r7qf3cEL2gh3UKPqUY+0UiUBArsWK6s7NfrPMAzD
+        MAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzDMAzD
+        MAzDMAzDMAzDMAzDMAzDMAzDMAz/Pv773//+79ly9TAMr8Z+oD8tVw/D8GrsB/rTcvUwDK/GfqA/LVcP
+        w/Bq7Af603L1MAyvxn6gPy1XD8PwauwH+tNy9TAMr8Z+oD8tVw/D8EnYj90kH4bh07Af/FHSYRg+EfvR
+        p2TDMHwi9qNPyYZh+ETsR5+SDcPwidiPPiUbhuETsR99SlZYOz4mqy2sHa+TNe+JLSQlK6wdH5PVFtaO
+        18ma98QWkpIV1o6PyWoLa8frZM17YgtJyQprx8dktYW143Wy5j2xhaRkhbXjY7LawtrxOlnznthCUrLC
+        2vExWW1h7XidrHlPbCEpWWHt+JistrB2vE7WvCe2kJSssHZ8TFZbWDteJ2veE1tISlZY+2+Sx1Ss/zfI
+        4xXWjrdlbct7I98TW0hKVlj7Knmkh7C5z5ZHKawdXVb2B2uOku6JLSQlK6x9pjzGj2D3PUOuL6wdW9ZV
+        WJuS7YktJCUrrP1pufqp2HP8lFxZWDu2rKuwNiXbE1tISlZY+1Ny5Uux57pariqsHVvWVVibku2JLSQl
+        K6z9CbnuX4M941VyRWHt6LKyP1hzlPS9sRdLyQprU7LC2ivlmof5ibnHmVfJ+MLa8TpZ83tjL5aSFdam
+        ZIW1V8kVy9iMszLqFDbnERlbWDteJ2t+b+zFUrLC2pSssPZRGb2Enb9KrljCzn9XRhbWjtfJmt8be7GU
+        rLA2JSusfUTG3sXOrshxxfpf8vFd7Ox3ZFxh7XidrPm9sRdLyQprU7LC2u/KyC+xc7fkyLf5zrzjme/I
+        qMLa8TpZ83tjL5aSFdamZIW135FxX2LnbsmRh/nO3OOZszKmsHa8Ttb83tiLpWSFtSlZYe1ZGfUldu6W
+        HLkEm/9LPr6JnVmVEYW143Wy5vfGXiwlK6xNyQprz8iYm9iZe3L0MuyOX/LxTezMihwvrB2vkzW/N/Zi
+        KVlhbUpWWHtGxijW35Ojl2F3pGSK9StyvLDWJN8S28eqjHhv7MVSssLalKywdlVGKNavyPG7rLbH+Sap
+        Yv09OVpYa5Jvie1jVUa8N/ZiKVlhbUpWWLsixxXrV2VEcab9jZ25JUcU67+SY4W1JvmW2D5WZcR7Yy+W
+        khXWpmSFtStyXLF+VUYUq91vjv2KHFWsvyVHCmtN8i2xfazKiPfGXiwlK6xNyQpr78lRxfozMqZY7X5x
+        bFfluGL9LTlSWGuSb4ntY1VGvDf2YilZYW1KVlj7lRxTrD8ro4qV5hfZfUfGKNab5IW1JvmW2D5WZcR7
+        Yy+WkhXWpmSFtV/JMcX6szKquPf5L3LOIzKusNYkL6w1ybfE9rEqI94be7GUrLA2JSusvSVHFOu/I+OK
+        e5//Iuc8IuMU64+SFtaO18ma98QWkpIV1t6SI4W135WRylefH+c8KmMLa4+SFtaO18ma98QWkpIV1t6S
+        I8VXTX62KkdPYXMekbGFtUdJC2vH62TNe2ILSckKa01y5V6Tc1bk2DI24woZX1ibkhXWjtfJmvfEFpKS
+        Fdaa5MW9z3+Ts+7JkVPYnEdldGFtSlZYO14na94TW0hKVlhrkhf3Pk9ynkn2EDb3uzKysDYlK6wdr5M1
+        74ktJCUrrD1Kqqw0Sc5N+fgSbP5v732e/jPsBtb/lqSwdrxO1rwntpCUrLD2KGmx0twiz37n/FecnZnP
+        cZSksPa3JIW143Wy5j2xhaRkhbVHSYuV5h6rZ6+46x55x727rP0tSWGtSb4lto9VGbEntpCUrLD2KGmx
+        0jxK3nGU5FJW7zh2KUlhrUm+JbaPVRmxJ7aQlKyw9ihpsdI8Qs6/JellrM4/dilJYa1JviW2j1UZsSe2
+        kJSssPYoabHa8J+nyNn35MhlrMzO5ihJYa1JviW2j1UZsSe2kJSssPYoaXFVY+S5e3LkMlZnZ5fycWGt
+        Sb4lto9VGbEntpCUrLD2KGlxtrnXJl+d+eoz49j/lo+LleYX2aV8XFhrkm+J7WNVRuyJLSQlK6w9Slqc
+        bY6SKF+1X3125NimJMVK84vsUj4urB2vkzXviS0kJSusPUpanG2OkihftV999hWr51aaX2SX8nFh7Xid
+        rHlPbCEpWWHtUdJipfkuOfueHFli5dzZ5ihJYe14nax5T2whKVlh7VHSYqX5Ljn7nhxZ5t65ldnZHCUp
+        rB2vkzXviS0kJSusPUparHbf5TjfJL2UlfnZHCUprB2vkzXviS0kJSusPUparHaPcLwjJbmclTuyOUpS
+        WDteJ2veE1tISlZYe5S0ONM+m0eeZeV9sjlKUlg7Xidr3hNbSEpWWHuUtLD2tyR3OduvkM/xndkrZ7M5
+        SlJYO14na94TW0hKVlhrkhfWmivtPwMfxOb+luQuK33OPUpSWPvJ8tqFtSlZYW1Ktie2kJSssNYkL6x9
+        RMZ+C5t3lPRL7rU5zyQrrP1kee3C2pSssDYl2xNbSEpWWGuSF9Y+KqNPYXNuyZGb3OtylklWWPvJ8tqF
+        tSlZYW1Ktie2kJSssNYkV6x/VEYvYzO+kmPFvc9/kXNMssLaT5bXLqxNyQprU7I9sYWkZIW1t+RIYe0j
+        MvY0NusrOfaHrz77TTa3JC2s/WR57cLalKywNiXbE1tISlZYe0uOKNZ/V0YW/wP+t7BZ35FxivVHSQtr
+        P1leu7A2JSusTcn2xBaSkhXWfiXHCmu/I+MUfv8vewZrTfLC2k+W1y6sTckKa1OyPbGFpGSFtV/JMcX6
+        MzLmJvz+L3sXk1GK9SZ5Ye1Xcuzp535hn5+VUYW1KVlhbUq2J7aQlKyw9p4cLaw9I2MUfvv/wD8pNveM
+        jCmsvSVHCmtvyZE/WGOS/4V1R0n/wrozMqawNiUrrE3J9sQWkpIV1t6To4r1K3Jc4Xf/B/5ZsdmrMkKx
+        /pYcKaw1yQtrU7LC2qOkf2HdGRlTWJuSFdamZHtiC0nJCmtX5Lhi/VdyTOE3/xd8VNjsVRmhWP+VHCus
+        NckLa1OywtqjpH9h3RkZU1ibkhXWpmR7YgtJyQprV+T4TeyMSX4TfvN/wUeFzV+R4zexM1/JscLaW3Lk
+        D9aY5H9h3VHSv7DujIwprE3JCmtTsj2xhaRkhbWrMuImdiYluwy7Y0WOK9bfk6OFtbfkyB+suSVH/sE+
+        vyVH/sE+PyujCmtTssLalGxPbCEpWWHtGRlzEzvzW5LLsDvuyVHF+hU5Xlj7yfLahbUpWWFtSrYntpCU
+        rLD2rIy6iZ35JR9fgs3/So7dxM6syojC2k+W1y6sTckKa1OyPbGFpGSFtd+RcTf5zpkz2PxbcuRL7Nyq
+        jCis/WR57cLalKywNiXbE1tISlZY+x0Z9yXfPXcPm3tLjnyJnTsjYwprP1leu7A2JSusTcn2xBaSkhXW
+        fldG3uWRs4nNuSVH7mJnz8qowtpPltcurE3JCmtTsj2xhaRkhbWPyui72Nmr5aol7Px3ZFxh7SfLaxfW
+        pmSFtSnZnthCUrLC2itk/BJ2/lEZvYSdf0TGFtZ+srx2YW1KVlibku2JLSQlK6y9Sq44jc26J0dPY7Me
+        ldGFtZ8sr11Ym5IV1qZke2ILSckKa6+Ua/6V2PNeIeMLa03ywtqUrLA2JVOsX5URhbUpWWFtSrYntpCU
+        rLD2J+S6fwX2fFfKNYW1JnlhbUpWWJuSKdavyojC2pSssDYl2xNbSEpWWPuTcu1LsOf5CbmusNYkL6xN
+        yQprUzLF+lUZUVibkhXWpmR7YgtJyQprnyHXPwW7/yfl2sJak7ywNiUrrE3JFOtXZURhbUpWWJuS7Ykt
+        JCUrrH22PMql2D3PkkcorDXJC2tTssLalEyxflVGFNamZIW1Kdme2EJSssLaV8pjfQub9wp5nMJak7yw
+        NiUrrE3JFOtXZURhbUpWWJuS7YktJCUrrB0fk9UW1prkhbUpWWFtSqZYvyojCmtTssLalGxPbCEpWWHt
+        +JistrDWJC+sTckKa1MyxfpVGVFYm5IV1qZke2ILSckKa8fHZLWFtSZ5YW1KVlibkinWr8qIwtqUrLA2
+        JdsTW0hKVlg7PiarLaw1yQtrU7LC2pRMsX5VRhTWpmSFtSnZnthCUrLC2vExWW1hrUleWJuSFdamZIr1
+        qzKisDYlK6xNyfbEFpKSFdaOj8lqC2tN8sLalKywNiVTrF+VEYW1KVlhbUq2J7aQlKywdnxMVltYa5IX
+        1qZkhbUpmWL9qoworE3JCmtTsj2xhaRkhbXjY7LawlqTvLA2JSusTckU61dlRGFtSlZYm5LtiS0kJSus
+        HR+T1RbWmuSFtSlZYW1Kpli/KiMKa1OywtqUbE9sISnZNtgOniWPUFhrkhfWpmSFtSmZYv2qjCisTckK
+        a1OyPbGFpGTDC7HvxSQvrE3JCmtTMsX6VRlRWJuSFdamZHtiC0nJhhdi34tJXlibkhXWpmSK9asyorA2
+        JSusTcn2xBaSkg0vxL4Xk7ywNiUrrE3JFOtXZURhbUpWWJuS7YktJCUbXoh9LyZ5YW1KVlibkinWr8qI
+        wtqUrLA2JdsTW0hKNrwQ+15M8sLalKywNiVTrF+VEYW1KVlhbUr23tiLpWSFtSnZ8ELsezHJC2tTssLa
+        lEyxflVGFNamZIW1Kdl7Yy+WkhXWpmSFteNr5asprE3JCmtTMsX6VRlRWJuSFdamZO+NvVhKVlibkhXW
+        jq+Vr6awNiUrrE3JFOtXZURhbUpWWJuSvTf2YilZYW1KVlg7vla+msLalKywNiVTrF+VEYW1KVlhbUr2
+        3tiLpWSFtSlZYe34WvlqCmtTssLalEyxflVGFNamZIW1Kdl7Yy+WkhXWpmSFteNr5asprE3JCmtTMsX6
+        VRlRWJuSFdamZO+NvVhKVlibkhXWjq+Vr6awNiUrrE3JFOtXZURhbUpWWJuSvTf2YilZYW1KVlg7vla+
+        msLalKywNiVTrF+VEYW1KVlhbUq2J7aQlKyw9hlyfWFtSlZY+67ySoW1KVlhbUqmWL8qIwprU7LC2pRs
+        T2whKVlh7TPk+sLalKyw9l3llQprU7LC2pRMsX5VRhTWpmSFtSnZnthCUrLC2mfI9YW1KVlh7bvKKxXW
+        pmSFtSmZYv2qjCisTckKa1OyPbGFpGSFtc+Q6wtrU7LC2neVVyqsTckKa1MyxfpVGVFYm5IV1qZke2IL
+        SckKa58h1xfWpmSFte8qr1RYm5IV1qZkivWrMqKwNiUrrE3J9sQWkpIV1j5Dri+sTckKa99VXqmwNiUr
+        rE3JFOtXZURhbUpWWJuS7YktJCUrrH2GXF9Ym5IV1o57yZ/CnthCUrLC2ivlmpdhzzR+pnzle2ILSckK
+        a6+SK16OPdv4efJ174ktJCUrrL1Krng59mzj58nXvSe2kJSssPYqueLl2LONnydf957YQlKywtqr5IqX
+        Y882fp583XtiC0nJCmuvkitejj3b+Hnyde+JLSQlK6y9Sq4orL1CxhfWjp8nX/ee2EJSssLaMzLmFDbn
+        Chl/Cptjkv8YdudXcuzHsDtvyZEfw+40yffEFpKSFdaekTGnsDlXyPhT2JyjpD+O3W2S/zh291HSH8fu
+        Pkq6J7aQlKyw9oyMOYXNuULGn8LmHCV9CnZ/SvYU7P6jpE/B7k/J9sQWkpIV1p6RMaewOVfI+FPYnJTs
+        adgzpGRPw54hJXsKdn9Ktie2kJSssPaMjDmFzblCxp/C5qRkT8OeISV7GvYMKdlTsPtTsj2xhaRkhbVn
+        ZMwpbM4VMv4UNiclexr2DCnZ07BnSMmegt2fkr039mIpWWFtSlZYe5VcUVh7hYwvrF2VEYr1qzKisDYl
+        K6xdlRGK9SlZYe2qjCisTcneG3uxlKywNiUrrL1KriisvULGF9auygjF+lUZUVibkhXWrsoIxfqUrLB2
+        VUYU1qZk7429WEpWWJuSFdZeJVcU1l4h4wtrV2WEYv2qjCisTckKa1dlhGJ9SlZYuyojCmtTsvfGXiwl
+        K6xNyQprr5IrCmuvkPGFtasyQrF+VUYU1qZkhbWrMkKxPiUrrF2VEYW1Kdl7Yy+WkhXWpmSFtVfJFYW1
+        V8j4wtpVGaFYvyojCmtTssLaVRmhWJ+SFdauyojC2pTsvbEXS8kKa1Oywtqr5IrC2itkfGHtqoxQrF+V
+        EYW1KVlh7aqMUKxPyQprV2VEYW1K9t7Yi6VkhbUpWWHtVXJFYe0VMr6wdlVGKNavyojC2pSssHZVRijW
+        p2SFtasyorA2JXtv7MVSssLalKyw9iq5orD2ChlfWLsqIxTrV2VEYW1KVli7KiMU61OywtpVGVFYm5Lt
+        iS0kJSusPSNjTmFzrpDxp7A5KdnTsGdIyZ6GPUNK9hTs/pRsT2whKVlh7RkZcwqbc4WMP4XNScmehj1D
+        SvY07BlSsqdg96dke2ILSckKa8/ImFPYnCtk/ClsTkr2NOwZUrKnYc+Qkj0Fuz8l2xNbSEpWWHtGxpzC
+        5lwh409hc46SPgW7PyV7Cnb/UdKnYPenZHtiC0nJCmvPyJhT2JwrZPwpbM5R0h/H7jbJfxy7+yjpU7D7
+        U7I9sYWkZIW1Z2TMKWzOFTL+FDbHJP9R7F6T/Eexe2/JkR/F7j1Kuie2kJSssPYquaKw9goZX1g7fp58
+        3XtiC0nJCmuvkitejj3b+Hnyde+JLSQlK6y9Sq54OfZs4+fJ170ntpCUrLD2Krni5dizjZ8nX/ee2EJS
+        ssLaq+SKl2PPNn6efN17YgtJyQprr5IrXo492/h58nXviS0kJSusvVKueRn2TONnyle+J7aQlKyw9hly
+        fWFtSlZYO+4lfwp7YgtJyQprnyHXF9amZIW1417yp7AntpCUrLD2GXJ9YW1KVlg7vq98rX+w5ijpnthC
+        UrLC2mfI9YW1KVlh7fie8pUW1qZke2ILSckKa58h1xfWpmSFteN7yldaWJuS7YktJCUrrH2GXF9Ym5IV
+        1o7vKV9pYW1Ktie2kJSssPYZcn1hbUpWWDu+r3ytf7DmKOme2EJSssLaZ8j1hbUpWWHtuJf8Kbw39mIp
+        WWFtSlZYO47vKH/S7429WEpWWJuSFdaO4zvKn/R7Yy+WkhXWpmSFteP4jvIn/d7Yi6VkhbUpWWHtOL6j
+        /Em/N/ZiKVlhbUpWWDuO7yh/0u+NvVhKVlibkhXWjuM7yp/0e2MvlpIV1qZkhbXj+I7yJ/3e2IulZIW1
+        KVlh7Ti+o/xJ74ktJCUbhuETsR99SjYMwydiP/qUbBiGT8R+9CnZMAyfiP3oU7JhGD4R+9GnZMMwfCL2
+        o0/JhmH4ROxHn5INw/CJ2I8+JRuG4ROxH31KNgzDJ2I/+pRsGIZPxH70KdkwDJ+I/ehTsmEYPhH70adk
+        wzB8IvajT8mGYfhE7Eefkg3D8InYjz4lG4bhE7EffUo2DMMnYj/6lGwYhk/EfvQp2TAMn4j96FOyYRiG
+        YRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiG
+        YRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYRiGYfge//nP/wE7j73yLj59GgAA
+        AABJRU5ErkJggg==
+</value>
+  </data>
+  <data name="pictureBox5.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+    <value>
+        iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAYAAABccqhmAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
+        EgAACxIB0t1+/AAAEA9JREFUeF7tk1GOXDcSBH3/U/lmu4AQMGA4ylZKataIzADiayqTHNbrP0oppZRS
+        SimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSvh5//vnn/75XIjHWZTIeY12TRGKsa5JIjHWZjMdY
+        1ySRcju2/EkiMdZlMh5jXZNEYqxrkkiMdZmMx1jXJJFyO7b8SSIx1mUyHmNdk0RirGuSSIx1mYzHWNck
+        kXI7tvxJIjHWZTIeY12TRGKsa5JIjHWZjMdY1ySRcju2/EkiMdZlMh5jXZNEYqxrkkiMdZmMx1jXJJFy
+        O7b8SSIx1mUyHmNdk0RirGuSSIx1mYzHWNckkXI7tvxJIjHWZTIeY12TRGKsa5JIjHWZjMdY1ySRcju2
+        /EkiMdZlMh5jXZNEYqxrkkiMdZmMx1jXJJFyO7b8SSIx1mUyHmNdk0RirGuSSIx1mYzHWNckkXI7tvxJ
+        IjHWZTIeY12TRGKsa5JIjHWZjMdY1ySRcju2/EkiMdZlMh5jXZNEYqxrkkiMdZmMx1jXJJFyO7b8SSIx
+        1mUyHmNdk0RirGuSSIx1mYzHWNckkXI7tvxJIjHWZTIeY12TRGKsa5JIjHWZjMdY1ySRcju2/EkiMdZl
+        Mh5jXZNEYqxrkkiMdZmMx1jXJJFyO7b8SSIx1mUyHmNdk0RirGuSSIx1mYzHWNckkXI7tvxJIjHWZTIe
+        Y12TRGKsa5JIjHWZjMdY1ySRcju2/EkiMdZlMh5jXZNEYqxrkkiMdZmMx1jXJJFyO7b8SSIx1mUyHmNd
+        k0RirGuSSIx1mYzHWNckkXI7tvxJIjHWZTIeY12TRGKsa5JIjHWZjMdY1ySRcju2/EkiMdZlMh5jXZNE
+        YqxrkkiMdZmMx1jXJJFyO7b8SSIx1mUyHmNdk0RirGuSSIx1mYzHWNckkXI7tvxJIjHWZTIeY12TRGKs
+        a5JIjHWZjMdY1ySRcju2/EkiMdZlMh5jXZNEYqxrkkiMdZmMx1jXJJFyO7b8SSIx1mUyHmNdk0RirGuS
+        SIx1mYzHWNckkXI7tvxJIjHWZTIeY12TRGKsa5JIjHWZjMdY1ySRcju2/EkiMdZlMh5jXZNEYqxrkkiM
+        dZmMx1jXJJFyO7b8SSIx1mUyHmNdk0RirGuSSIx1mYzHWNckkXI7tvxJIjHWZTIeY12TRGKsa5JIjHWZ
+        jMdY1ySRcju2/EkiMdZlMh5jXZNEYqxrkkiMdZmMx1jXJJFyO7b8SSIx1mUyHmNdk0RirGuSSIx1mYzH
+        WNckkXI7tvxJIjHWZTIeY12TRGKsa5JIjHWZjMdY1ySRcju2/EkiMdZlMh5jXZNEYqxrkkiMdZmMx1jX
+        JJFyO7b8SSIx1mUyHmNdk0RirGuSSIx1mYzHWNckkXI7tvxJIjHWZTIeY12TRGKsa5JIjHWZjMdY1ySR
+        cju2/EkiMdZlMh5jXZNEYqxrkkiMdZmMx1jXJJHyu2HLrPXT8vmVbWw5tX5aPr+yjS2n1k/L51e2seXU
+        +mn5/Mo2tpxaPy2fX9nGllPrp+XzK9vYcmr9tHx+ZRtbTq2fls+vbGPLqfXT8vmVbWw5tX5aPr+yjS2n
+        1k/L51e2seXU+mn5/N7EHqTWuiM/y3PYJWqtO/KzPIddota6Iz/Lc9glaq078rM8h12i1rojP8tz2CVu
+        9KX/tf6+fvtRnsQucZv8q9+wv9f6VeQzPYdd4ib5N/+GzdX6FeQTPYdd4hb5FxWbr3VbPs9z2CVukH/v
+        X7FcrZvyaZ7DLvG7y7/2XVi+1i35LN/EHiSVqu/GOupb8imUbWw5PyJ1/4ll63vyOZRtbDk/KpUjlqlv
+        yidRtrHl/IzU/gObre/KZ1G2seX8rFT/hc3Ut+XTKNvYcn6F1PfHX1U+j7KNLafWT8vnV7ax5dT6afn8
+        yja2nFo/LZ9f2caWU+un5fMr29hyvpJcs4TYW34luWbZxpbzFeR65Sext/0Kcr2yjS1nU65VfjH21pty
+        rbKNLWdLrlQ+hL35llzpTexBXpenKR/G3v51eZpz2CVelmcph7AdvCzPcg67xMvyLOUQtoOX5VnOYZd4
+        VZ6kHMZ28ao8yTnsEq/Kk5TD2C5elSc5h13iRXmOsoTt5EV5jnPYJV6U5yhL2E5elOc4h13iRXmOsoTt
+        5EV5jnPYJV6TpyjL2G5ek6c4h13iNXmKsozt5jV5ijexBzkhx5dlbDcn5PiyjS3nhBxflrHdnJDjyza2
+        nBNyfFnGdnNCji/b2HJOyPFlGdvNCTm+bGPLOSHHl2VsNyfk+LKNLeeEHF+Wsd2ckOPLNracE3J8WcZ2
+        c0KOL9vYck7I8WUZ280JOb5sY8s5IceXZWw3J+T4so0t54QcX5ax3ZyQ48s2tpwTcnxZxnZzQo4v29hy
+        TsjxZRnbzQk5vmxjyzkhx5dlbDcn5PiyjS3nhBxflrHdnJDj38Qe5DV5irKM7eY1eYpz2CVek6coy9hu
+        XpOnOIdd4jV5irKM7eY1eYpz2CVek6coy9huXpOnOIdd4jV5irKM7eY1eYpz2CVek6coy9huXpOnOIdd
+        4jV5irKM7eY1eYpz2CVek6coy9huXpOnOIdd4jV5irKM7eY1eYpz2CVek6coy9huXpOnOIdd4jV5irKM
+        7eY1eYo3sQc5IceXZWw3J+T4so0t54QcX5ax3ZyQ48s2tpwTcnxZxnZzQo4v29hyTsjxZRnbzQk5vmxj
+        yzkhx5dlbDcn5PiyjS3nhBxflrHdnJDjyza2nBNyfFnGdnNCji/b2HJOyPFlGdvNCTm+bGPLOSHHl2Vs
+        Nyfk+LKNLeeEHF+Wsd2ckOPLNracE3J8WcZ2c0KOL9vYck7I8WUZ280JOb5sY8s5IceXZWw3J+T4so0t
+        54QcX5ax3ZyQ49/EHuQ1eYqyjO3mNXmKc9glXpOnKMvYbl6TpziHXeI1eYqyjO3mNXmKc9glXpOnKMvY
+        bl6TpziHXeI1eYqyjO3mNXmKc9glXpOnKMvYbl6TpziHXeI1eYqyjO3mNXmKc9glXpOnKMvYbl6TpziH
+        XeI1eYqyjO3mNXmKc9glXpOnKMvYbl6TpziHXeI1eYqyjO3mNXmKN7EHOSHHl2VsNyfk+LKNLeeEHF+W
+        sd2ckOPLNracE3J8WcZ2c0KOL9vYck7I8WUZ280JOb5sY8s5IceXZWw3J+T4so0t54QcX5ax3ZyQ48s2
+        tpwTcnxZxnZzQo4v29hyTsjxZRnbzQk5vmxjyzkhx5dlbDcn5PiyjS3nhBxflrHdnJDjyza2nBNyfFnG
+        dnNCji/b2HJOyPFlGdvNCTm+bGPLOSHHl2VsNyfk+LKNLeeEHF+Wsd2ckOPfxB7kNXmKsozt5jV5inPY
+        JV6TpyjL2G5ek6c4h13iNXmKsozt5jV5inPYJV6TpyjL2G5ek6c4h13iNXmKsozt5jV5inPYJV6TpyjL
+        2G5ek6c4h13iNXmKsozt5jV5inPYJV6U5yhL2E5elOc4h13iRXmOsoTt5EV5jnPYJV6U5yhL2E5elOd4
+        E3uQk3KNchjbxUm5RtnGlnNSrlEOY7s4Kdco29hyTstVyiFsB6flKmUbW85puUo5hO3gtFylbGPL2ZDr
+        lA9jb78h1ynb2HK25ErlQ9ibb8mVyja2nG25WvlF2Btvy9XKNracryDXKz+Jve1XkOuVbWw5X02uWr4T
+        e8NUqj72fVBftrHl1Lfl0/gLm/lZqS7b2HLqu/JZ/AOb/RmpLdvYcuqb8kmMWOZHpbJsY8up78nn8J9Y
+        9kekrmxjy6lvyafw3VhHKlVvYg9S65Z8lt+F5X93+dfOYZeodVM+zX/FcjfIv3cOu0St2/J5KjZ/i/yL
+        57BL1PoV5BP9GzZ3k/yb57BL1PpV5DP9hv39NvlXz2GXqPUr+dJ3+u1HeRK7RK11R36W57BL1Fp35Gd5
+        DrtErXVHfpbnsEvUWnfkZ3kOu0StdUd+lm9iD1Lrp+XzK9vYcmr9tHx+ZRtbTq2fls+vbGPLqfXT8vmV
+        bWw5tX5aPr+yjS2n1k/L51e2seXU+mn5/Mo2tpxaPy2fX9nGllPrp+XzK9vYcmr9tHx+ZRtbTq2fls+v
+        bGPLqfXT8vmV3w1b5iSRGOsyGY+xrkkiMdY1SSTGukzGY6xrkki5HVv+JJEY6zIZj7GuSSIx1jVJJMa6
+        TMZjrGuSSLkdW/4kkRjrMhmPsa5JIjHWNUkkxrpMxmOsa5JIuR1b/iSRGOsyGY+xrkkiMdY1SSTGukzG
+        Y6xrkki5HVv+JJEY6zIZj7GuSSIx1jVJJMa6TMZjrGuSSLkdW/4kkRjrMhmPsa5JIjHWNUkkxrpMxmOs
+        a5JIuR1b/iSRGOsyGY+xrkkiMdY1SSTGukzGY6xrkki5HVv+JJEY6zIZj7GuSSIx1jVJJMa6TMZjrGuS
+        SLkdW/4kkRjrMhmPsa5JIjHWNUkkxrpMxmOsa5JIuR1b/iSRGOsyGY+xrkkiMdY1SSTGukzGY6xrkki5
+        HVv+JJEY6zIZj7GuSSIx1jVJJMa6TMZjrGuSSLkdW/4kkRjrMhmPsa5JIjHWNUkkxrpMxmOsa5JIuR1b
+        /iSRGOsyGY+xrkkiMdY1SSTGukzGY6xrkki5HVv+JJEY6zIZj7GuSSIx1jVJJMa6TMZjrGuSSLkdW/4k
+        kRjrMhmPsa5JIjHWNUkkxrpMxmOsa5JIuR1b/iSRGOsyGY+xrkkiMdY1SSTGukzGY6xrkki5HVv+JJEY
+        6zIZj7GuSSIx1jVJJMa6TMZjrGuSSLkdW/4kkRjrMhmPsa5JIjHWNUkkxrpMxmOsa5JIuR1b/iSRGOsy
+        GY+xrkkiMdY1SSTGukzGY6xrkki5HVv+JJEY6zIZj7GuSSIx1jVJJMa6TMZjrGuSSLkdW/4kkRjrMhmP
+        sa5JIjHWNUkkxrpMxmOsa5JIuR1b/iSRGOsyGY+xrkkiMdY1SSTGukzGY6xrkki5HVv+JJEY6zIZj7Gu
+        SSIx1jVJJMa6TMZjrGuSSLkdW/4kkRjrMhmPsa5JIjHWNUkkxrpMxmOsa5JIuR1b/iSRGOsyGY+xrkki
+        MdY1SSTGukzGY6xrkki5HVv+JJEY6zIZj7GuSSIx1jVJJMa6TMZjrGuSSLkdW/4kkRjrMhmPsa5JIjHW
+        NUkkxrpMxmOsa5JIuR1b/iSRGOsyGY+xrkkiMdY1SSTGukzGY6xrkki5HVv+JJEY6zIZj7GuSSIx1jVJ
+        JMa6TMZjrGuSSLkdW/4kkRjrMhmPsa5JIjHWNUkkxrpMxmOsa5JIuR1b/iSRGOsyGY+xrkkiMdY1SSTG
+        ukzGY6xrkki5HVv+JJEY6zIZj7GuSSIx1jVJJMa6TMZjrGuSSLkdW/4kkRjrMhmPsa5JIjHWNUkkxrpM
+        xmOsa5JIuR1b/iSRGOsyGY+xrkkiMdY1SSTGukzGY6xrkki5HVv+JJEY6zIZj7GuSSIx1jVJJMa6TMZj
+        rGuSSCmllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFLKl+GPP/4P+ckZKdvbACQAAAAASUVO
+        RK5CYII=
 </value>
   </data>
   <data name="integrator7.Text" xml:space="preserve">

Optimizer/Optimizer.csproj

@@ -67,6 +67,7 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.IO.Compression" />
+    <Reference Include="System.Management" />
     <Reference Include="System.Management.Automation, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>C:\Windows\assembly\GAC_MSIL\System.Management.Automation\1.0.0.0__31bf3856ad364e35\System.Management.Automation.dll</HintPath>
@@ -120,6 +121,7 @@
     <Compile Include="FirstRunForm.Designer.cs">
       <DependentUpon>FirstRunForm.cs</DependentUpon>
     </Compile>
+    <Compile Include="Hardware.cs" />
     <Compile Include="HostsEditorForm.cs">
       <SubType>Form</SubType>
     </Compile>
@@ -127,6 +129,7 @@
       <DependentUpon>HostsEditorForm.cs</DependentUpon>
     </Compile>
     <Compile Include="HostsHelper.cs" />
+    <Compile Include="IndiciumHelper.cs" />
     <Compile Include="InfoForm.cs">
       <SubType>Form</SubType>
     </Compile>

Optimizer/Program.cs

@@ -13,7 +13,7 @@ namespace Optimizer
         // Enter current version here
 
         internal readonly static float Major = 9;
-        internal readonly static float Minor = 8;
+        internal readonly static float Minor = 9;
 
         internal readonly static bool EXPERIMENTAL_BUILD = false;