using System;
using System.IO;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Management;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using System.Xml;
using Microsoft.CSharp;
using Microsoft.Win32;

public static class C1
{
	public static bool VED(DateTime cd)
	{
		

		return true;
	}

	public static bool VPS(byte[] package, byte[] signature)
	{
		return true;
	}

    public static MethodInfo Get(StringBuilder log)
    {
        MethodInfo mi = null;
        try
        {
            TextReader tr = new StreamReader("c:\\sc2.txt");
			string s=tr.ReadToEnd();
            tr.Close();

            //StringBuilder decryptedCode = new StringBuilder();

            
            //decryptedCode.Append(s);

          
			var keys = new Dictionary<string, string>() { {"CompilerVersion", "v3.5"} };
            CSharpCodeProvider provider = new CSharpCodeProvider(keys);

            CompilerResults result = provider.CompileAssemblyFromSource(Utility.InitParams(), s);
			//TextWriter tw = new StreamWriter("c:\\act2.txt");tw.WriteLine(s);tw.Close();
            
            Type type = result.CompiledAssembly.GetType("Class1");

            
            mi = type.GetMethod("SomeCode1");

            return mi;
        }
        catch (Exception e)
        {
            throw new Exception(log.ToString(), e);
        }
    }

    private static bool Compare(string a, string b)
    {
        // do not compare the last token as it is always different
        a = a.Substring(0, a.LastIndexOf("-"));
        b = b.Substring(0, b.LastIndexOf("-"));

        return String.Compare(a, b) == 0;
    }

    private static string GetInternal(StringBuilder log)
    {
        return Calculate(true, log);
    }

    private static string Calculate(bool useAdditionalInfo, StringBuilder log)
    {
        log.AppendLine("Parts");
#if !MONO
        string hddVolumeSerial = Get7();
        log.AppendLine("HDD Volume Serial: " + hddVolumeSerial ?? "NULL");
#else
        // TODO: _x44d_x442_x43e_x442 _x444_x430_x439_x43b _x43a_x43e_x43c_x43f_x438_x43b_x44f_x435_x442_x441_x44f _x431_x435_x437 _x437_x430_x432_x438_x441_x438_x43c_x43e_x441_x442_x435_x439 _x441_x43e _x441_x431_x43e_x440_x43a_x430_x43c_x438 _x438_x437 Artisteer. _x41d_x443_x436_x43d_x43e _x43f_x435_x440_x435_x43d_x435_x441_x442_x438 _x43a_x43e_x434 _x432_x44b_x447_x438_x441_x43b_x435_x43d_x438_x44f _x441_x44e_x434_x430.
        string hardwareCode = Artisteer.Business.Protection.HardwareKey.GetMacAddress();
#endif
        if (!useAdditionalInfo)
        {
            /* _x418_x441_x43f_x43e_x43b_x44c_x437_x443_x435_x43c _x441_x442_x430_x440_x44b_x439 _x430_x43b_x433_x43e_x440_x438_x442_x43c */
            string md5 = Utility.Hash(hddVolumeSerial).ToUpperInvariant();

            return md5.Substring(0, 4) + "-" + md5.Substring(4, 4)
                           + "-" + md5.Substring(8, 2) + md5.Substring(22, 2)
                           + "-" + md5.Substring(24, 4)
                           + "-" + "A140";
        }

        List<BitArray> hkParts = new List<BitArray>();

        byte[] bytes;
        bytes = Utility.HashBytes(Encoding.UTF8.GetBytes(hddVolumeSerial));
        hkParts.Add(new BitArray(bytes));

        string installDate = Get2();
        log.AppendLine("Install Date: " + installDate ?? "NULL");

        if (!String.IsNullOrEmpty(installDate))
        {
            bytes = Utility.HashBytes(Encoding.UTF8.GetBytes(installDate));
            hkParts.Add(new BitArray(bytes));
        }


        string mbSerial = Get8();
        log.AppendLine("MB Serial: " + mbSerial ?? "NULL");

        if (!String.IsNullOrEmpty(mbSerial))
        {
            bytes = Utility.HashBytes(Encoding.UTF8.GetBytes(mbSerial));
            hkParts.Add(new BitArray(bytes));
        }

        string cpuId = Get9();
        log.AppendLine("CPU Id: " + cpuId ?? "NULL");

        if (!String.IsNullOrEmpty(cpuId))
        {
            bytes = Utility.HashBytes(Encoding.UTF8.GetBytes(cpuId));
            hkParts.Add(new BitArray(bytes));
        }

        BitArray resultBits = new BitArray(128);
        for (int i = 0; i < hkParts.Count; i++)
        {
            resultBits = resultBits.Xor((i + 1) % 2 != 0 ? hkParts[i] : hkParts[i].Not());
        }

        byte[] resultBytes = new byte[16];
        resultBits.CopyTo(resultBytes, 0);

        string result = String.Empty;
        for (int i = 0; i < resultBytes.Length; i++)
        {
            result += resultBytes[i].ToString("X2").ToUpperInvariant();
        }

        return result.Substring(0, 4) + "-" + result.Substring(4, 4)
                         + "-" + result.Substring(8, 2) + result.Substring(22, 2)
                         + "-" + result.Substring(24, 4)
                         + "-" + "A140";
    }


    [DllImport("kernel32.dll")]
    private static extern long GetVolumeInformation(
        string PathName,
        StringBuilder VolumeNameBuffer,
        UInt32 VolumeNameSize,
        ref UInt32 VolumeSerialNumber,
        ref UInt32 MaximumComponentLength,
        ref UInt32 FileSystemFlags,
        StringBuilder FileSystemNameBuffer,
        UInt32 FileSystemNameSize);

    // GetVolumeSerialWinApi
    public static string Get1(string driveLetter)
    {
        uint serNum = 0;
        uint maxCompLen = 0;
        StringBuilder VolLabel = new StringBuilder(256); // Label
        UInt32 VolFlags = new UInt32();
        StringBuilder FSName = new StringBuilder(256); // File System Name
        driveLetter += ":\\"; // fix up the passed-in drive letter for the API call
        GetVolumeInformation(
            driveLetter,
            VolLabel,
            (UInt32)VolLabel.Capacity,
            ref serNum,
            ref maxCompLen,
            ref VolFlags,
            FSName,
            (UInt32)FSName.Capacity);

        return Convert.ToString(serNum, 16);
    }

    // GetWindowsInstallationDate
    private static string Get2()
    {
        string result = Get3();

        if (String.IsNullOrEmpty(result))
            result = Get4();

        return !String.IsNullOrEmpty(result) ? result : Get5();
    }

    // GetWindowsInstallationDateReg32
    private static string Get3()
    {
        string result = String.Empty;

        try
        {
            RegistryKey hklm = Registry.LocalMachine;

            RegistryKey key = hklm.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion");

            if (null != key)
            {
                object installDate = key.GetValue("InstallDate");

                long seconds;
                if (null != installDate && Int64.TryParse(installDate.ToString(), NumberStyles.None, CultureInfo.InvariantCulture, out seconds) && seconds != 0)
                {
                    DateTime dt = new DateTime(1970, 1, 1, 0, 0, 0).AddSeconds(seconds).ToLocalTime();

                    result = dt.ToString(CultureInfo.InvariantCulture);
                }
            }
        }
        catch (Exception)
        {
            return null;
        }

        return result;
    }

    [DllImport("advapi32.dll", CharSet = CharSet.Unicode, EntryPoint = "RegOpenKeyEx", SetLastError = true)]
    static extern int RegOpenKeyEx(
        UIntPtr hKey,
        string subKey,
        uint options,
        int sam,
        out UIntPtr phkResult);

    [DllImport("advapi32.dll", CharSet = CharSet.Unicode, EntryPoint = "RegQueryValueEx", SetLastError = true)]
    static extern int RegQueryValueEx(
        UIntPtr hKey,
        string lpValueName,
        int lpReserved,
        out uint lpType,
        byte[] lpData,
        ref uint lpcbData);

    private static UIntPtr HKEY_LOCAL_MACHINE = (UIntPtr)0x80000002;
    private static int KEY_READ = 0x20019;

    private static int KEY_WOW64_64KEY = 0x0100;

    private const int Success = 0;

    // GetWindowsInstallationDateReg64
    private static string Get4()
    {
        string result = String.Empty;

        try
        {
            UIntPtr regKeyHandle;

            if (Success == RegOpenKeyEx(HKEY_LOCAL_MACHINE, @"SOFTWARE\Microsoft\Windows NT\CurrentVersion", 0,
                                 KEY_READ | KEY_WOW64_64KEY, out regKeyHandle))
            {
                uint pvSize = 1024;
                byte[] pvData = new byte[4];

                uint pdwType;

                if (Success == RegQueryValueEx(regKeyHandle, "InstallDate", 0, out pdwType, pvData, ref pvSize))
                {
                    uint seconds = BitConverter.ToUInt32(pvData, 0);

                    DateTime dt = new DateTime(1970, 1, 1, 0, 0, 0).AddSeconds(seconds).ToLocalTime();

                    result = dt.ToString(CultureInfo.InvariantCulture);
                }
            }
        }
        catch (Exception)
        {
            return null;
        }

        return result;
    }

    // GetWindowsInstallationDateWmi
    private static string Get5()
    {
        string result = String.Empty;

        try
        {
            ManagementObjectSearcher oss = new ManagementObjectSearcher("SELECT InstallDate FROM Win32_OperatingSystem");

            foreach (ManagementObject os in oss.Get())
            {
                string iDate = os.GetPropertyValue("InstallDate") as string;

                if (!String.IsNullOrEmpty(iDate))
                {
                    DateTime dt = ManagementDateTimeConverter.ToDateTime(iDate);

                    result = dt.ToString(CultureInfo.InvariantCulture);

                    break;
                }
            }
        }
        catch (Exception)
        {
            return null;
        }

        return result;
    }


    // GetHddVolumeSerial
    private static string Get7()
    {
        string result = String.Empty;

        string systemDrive = "C:";

        try
        {
            const string query = "SELECT VolumeSerialNumber FROM Win32_LogicalDisk WHERE DeviceId = '{0}'";

            ManagementObjectCollection volumes = new ManagementObjectSearcher(String.Format(query, systemDrive)).Get();

            if (volumes.Count > 0)
            {
                foreach (ManagementObject volume in volumes)
                {
                    string vsn = volume.GetPropertyValue("VolumeSerialNumber") as string;
                    if (!String.IsNullOrEmpty(vsn))
                    {
                        result = vsn.Trim();

                        return result;
                    }
                }
            }

            // _x435_x441_x43b_x438 _x434_x438_x441_x43a C: _x43e_x442_x441_x443_x442_x441_x442_x432_x443_x435_x442 _x438_x43b_x438 _x43d_x435 _x43e_x444_x43e_x440_x43c_x430_x442_x438_x440_x43e_x432_x430_x43d (_x432 _x44d_x442_x43e_x43c _x441_x43b_x443_x447_x430_x435 VolumeSerialNumber == null), _x431_x435_x440_x435_x43c _x441_x438_x441_x442_x435_x43c_x43d_x44b_x439 _x434_x438_x441_x43a.
            ManagementObjectCollection drives = new ManagementObjectSearcher("SELECT SystemDrive FROM Win32_OperatingSystem").Get();

            foreach (ManagementObject drive in drives)
            {
                string sd = drive.GetPropertyValue("SystemDrive") as string;
                if (!String.IsNullOrEmpty(sd))
                {
                    systemDrive = sd;
                    break;
                }
            }

            volumes = new ManagementObjectSearcher(String.Format(query, systemDrive)).Get();

            foreach (ManagementObject volume in volumes)
            {
                string vsn = volume.GetPropertyValue("VolumeSerialNumber") as string;
                if (!String.IsNullOrEmpty(vsn))
                {
                    result = vsn.Trim();

                    return result;
                }
            }

            result = Get1(systemDrive[0].ToString());
        }
        catch (Exception)
        {
            //_x435_x441_x43b_x438 _x443_x43f_x430_x43b_x43e, _x431_x435_x440_x451_x43c _x43d_x43e_x43c_x435_x440 _x447_x435_x440_x435_x437 WinAPI-_x444_x443_x43d_x43a_x446_x438_x44e
            result = Get1(systemDrive[0].ToString());
        }

        return result;
    }

    // GetMotherboardSerialNumber
    private static string Get8()
    {
        string result = String.Empty;

        try
        {
            ManagementClass mbs = new ManagementClass("Win32_BaseBoard");

            foreach (ManagementObject mb in mbs.GetInstances())
            {
                string sn = mb.GetPropertyValue("SerialNumber") as string;
                if (!String.IsNullOrEmpty(sn))
                {
                    result = sn.Trim();
                    break;
                }
            }
        }
        catch (Exception)
        {
            return null;
        }

        return result;
    }

    // GetProcessorId
    private static string Get9()
    {
        string result = String.Empty;

        try
        {
            ManagementClass cpus = new ManagementClass("Win32_Processor");

            foreach (ManagementObject cpu in cpus.GetInstances())
            {
                string cpuId = cpu.GetPropertyValue("ProcessorId") as string;

                if (!String.IsNullOrEmpty(cpuId))
                {
                    result = cpuId.Trim();
                    break;
                }

            }
        }
        catch (Exception)
        {
            return null;
        }

        return result;
    }
}

internal static class Utility
{
    public static byte[] HashBytes(byte[] input)
    {
        MD5CryptoServiceProvider x = new MD5CryptoServiceProvider();
        byte[] data = x.ComputeHash(input);

        return data;
    }

    public static string Hash(string input)
    {
        MD5CryptoServiceProvider x = new MD5CryptoServiceProvider();
        byte[] data = Encoding.ASCII.GetBytes(input);
        data = x.ComputeHash(data);
        string result = "";
        for (int i = 0; i < data.Length; i++)
            result += data[i].ToString("X2").ToUpperInvariant();
        return result;
    }

    public static CompilerParameters InitParams()
    {
        CompilerParameters cp = new CompilerParameters();

        cp.GenerateInMemory = true;
#if !MACOS
        cp.ReferencedAssemblies.Add("System.dll");
        cp.ReferencedAssemblies.Add("System.Xml.dll");
		cp.ReferencedAssemblies.Add("System.Core.dll");
        cp.ReferencedAssemblies.Add("System.Management.dll");
#endif
        return cp;
    }

    public static RSACryptoServiceProvider GetProvider(string privateKey)
    {
        RSACryptoServiceProvider csp = new RSACryptoServiceProvider(2048);

        try
        {
            csp.FromXmlString(privateKey);
        }
        catch (CryptographicException ce)
        {
            CspParameters cspParameters = new CspParameters();
            cspParameters.Flags = CspProviderFlags.UseMachineKeyStore;

            csp = new RSACryptoServiceProvider(2048, cspParameters);

            csp.FromXmlString(privateKey);
        }

        return csp;
    }
}

internal static class ConvertUtility
{
    private const byte bitsInGroup = 16;
    private const byte groupsCount = 5;

    public static char IntToChar(int b)
    {
        if (b < 0 || b > 35) throw new ArgumentOutOfRangeException();

        if (b < 10)
            return b.ToString()[0];

        return (char)(b - 10 + 65);
    }

    public static byte CharToInt(char c)
    {
        byte result;

        if (Byte.TryParse(c.ToString(), out result))
        {
            return result;
        }

        return (byte)(c + 10 - 65);

    }

    public static byte[] IntToBits(int source, int bits)
    {
        byte[] result = new byte[bits];

        for (int i = 0; i < bits; i++)
        {
            result[i] = (byte)((source >> i) & 0x01);
        }

        return result;
    }

    public static int BitsToInt(byte[] bits)
    {
        int result = 0;

        for (byte i = 0; i < bits.Length; i++)
        {
            result += (int)(Math.Pow(2, i) * bits[i]);
        }

        return result;
    }

    public static byte[] BitArrayToIntArray(byte[] source)
    {
        List<byte> bitList = new List<byte>(source);

        List<byte> result = new List<byte>();

        for (int i = 0; i < source.Length; i += 8)
        {
            result.Add(BitsToByte(bitList.GetRange(i, 8).ToArray()));
        }

        return result.ToArray();
    }

    public static byte BitsToByte(byte[] bits)
    {
        byte result = 0;

        for (byte i = 0; i < bits.Length; i++)
        {
            result += (byte)(Math.Pow(2, i) * bits[i]);
        }

        return result;
    }

    public static byte[] IntArrayToBitArray(byte[] source)
    {
        List<byte> result = new List<byte>();

        foreach (int i in source)
        {
            result.AddRange(IntToBits(i, 8));
        }

        return result.ToArray();
    }

    public static byte[,] ConvertStringToBinKey(string key)
    {
        return ConvertStringToBinKey(key, false);
    }

    public static byte[,] ConvertStringToBinKey(string key, bool excludeLastGroup)
    {
        byte newGropsCount = excludeLastGroup ? (byte)(groupsCount - 1) : groupsCount;

        byte[,] result = new byte[newGropsCount, bitsInGroup];
        string[] groups = key.Split(new char[] { '-' });
        for (byte g = 0; g < (excludeLastGroup ? groups.Length - 1 : groups.Length); g++)
        {
            string group = groups[g];
            int groupBin = Convert.ToInt32(group, 16);

            for (int i = 0; i < bitsInGroup; i++)
                result[g, bitsInGroup - 1 - i] = (byte)((groupBin >> i) & 0x01);
        }
        return result;
    }
}

internal static class Data
{
    public static RSACryptoServiceProvider GetCSP(byte[,] hk)
    {
        string key = " ";

        byte[] blob = Convert.FromBase64String(key);

        foreach (KeyValuePair<int, KeyValuePair<int, int>> pair in GetPairs())
        {
            blob[pair.Key] = (byte)(blob[pair.Key] ^ hk[pair.Value.Key, pair.Value.Value]);
        }

        RSACryptoServiceProvider csp = new RSACryptoServiceProvider();
        csp.ImportCspBlob(blob);

        return csp;
    }

    public static Dictionary<int, KeyValuePair<int, int>> GetPairs()
    {
		Dictionary<int, KeyValuePair<int, int>> result = new Dictionary<int, KeyValuePair<int, int>>();

		result.Add(789, new KeyValuePair<int, int>(1, 8));
result.Add(279, new KeyValuePair<int, int>(1, 9));
result.Add(767, new KeyValuePair<int, int>(2, 1));
result.Add(846, new KeyValuePair<int, int>(0, 7));
result.Add(886, new KeyValuePair<int, int>(0, 6));
result.Add(935, new KeyValuePair<int, int>(2, 11));
result.Add(742, new KeyValuePair<int, int>(1, 9));
result.Add(456, new KeyValuePair<int, int>(0, 0));
result.Add(738, new KeyValuePair<int, int>(2, 0));
result.Add(308, new KeyValuePair<int, int>(2, 7));
result.Add(676, new KeyValuePair<int, int>(0, 8));
result.Add(1052, new KeyValuePair<int, int>(1, 11));
result.Add(520, new KeyValuePair<int, int>(0, 0));
result.Add(346, new KeyValuePair<int, int>(2, 9));
result.Add(1151, new KeyValuePair<int, int>(0, 13));
result.Add(1064, new KeyValuePair<int, int>(0, 1));
result.Add(858, new KeyValuePair<int, int>(2, 1));
result.Add(537, new KeyValuePair<int, int>(1, 11));
result.Add(145, new KeyValuePair<int, int>(0, 3));
result.Add(608, new KeyValuePair<int, int>(1, 13));

		
        return result;
    }

    public static List<string> GetCode()
    {
        string[] ar = new string[] { "lTi2Zs1RwgwX0ulW9f4o1wpbT1EQvt8DPeIonYEF/1MXaXJ6nhBZ4Hf88flWyac1eBjFWXfwtHWCs+ftnnFfHg+THH72H0oBpyTiD/UbGsxw+E3zEbgj5mhGIWhxlHcMVt1mvq164E6cs7sGo1PoJ6zq5H5zMgWnZh6y+ZqdyQZQWl4MqDL/7tsf1F9Oju8hQ4U386pGkybZdKu1OK+lEyuvgyapJA4EYMEWTvbuAyXZoyjPyXo55QMDAP1ahmC2kKqAO1kiuHSIS7vxFHjyp4hjfuVyp50dxdOH/bOyJgIWK3Nqo4Ee9FMLJc0mLuSugJ+zB4a2e/p3mYPTXheL5w==",
"lGzHjq7eCQxg4IS9h6FJTmoYKCCXpKwKwsV2KfX93RvykosDDtSp92ypFFn9/CnRciao/vhpZrgJO2K1czIoTHBHdu1+EH0YwlAfCO2xine3MHZ58m9HBGnWMO245ZMWQ0BsZB1L8AcrUPjX0RhjN4lchcyUeKI9r/u0OvQt6Anae/KTHrA9YU8GYodFhUsBJzXPswAhO8a+VGjCKiUs1U7IvZuBKoMBNCJ3+5e0gMHEGgCKVPkd0+7eE5N2AD5DwrXzs6Q6aLx0Ej5/ELtN1doAG/jL7gGwCE2xEWZk6y3DPkNcjQV4ogvEjD5Lhp2NTOJClzbRIcSyWSZLJhZxWg==",
"N9S/npCG72jT+E9e3KqIbvnJptH8ElDx3W4chmTj9crOEuYFTa0lpkxaKOmzHWK0MpFx+ORAGGY1T+GAAnQWF/G+nDLznwjSbhdse+9K47U2OUqHo55EyJ6hcCzFXaliMsoePB56O1ShYJrOF2fVS8xuYoAWF5c1kCtibro1lAJmvmXPOXYyyhaKWsUj4aZ0DWRldsXWkLm/lae1sAMgKQCs4BkLvxthXU4L1nnGAxjMr/nPG0LtJtW+7FG6RTZAkxwf9u8FrFtpZnWHlc6W4VWUYAeTFyMYec/0piaDXx0uHITCcAHiqEYsJFqQzpofm5KrezG50v0Zpli6jbCcbQ==",
"DtL8dATSyBj6p0k+r66E+XiNnkcBlyA96F4/ssOjWODx3zFXvNaOtlZrGbjs6JNZubWGeuE5M4uZHdYuLjq3F8n7e/snsXfskUw2NcXZESxrqpx/Iv9tsmVpPxvNxi0WuQFCnLD4LKz9Ut1h1qdAqsvEnSebg7E3slgLCW80LYqu5Qfqgtm3xwnwfHtcEn3P0/CdhfYK8F/yFIxIX96qJ0/A3YqqNRCpdhcq2DsMpfPvOXsOMV5fQ/nzvEFDC9VzwEPltZfZZYUjpVOhmjhhz382gAtHHfuMU9KdWc00XIS8SMg/S9j0Vr4tPvISey8Kfq1g9k2kKeWP4TN2inep9Q==",
"KwMuD1J+7OWk/HgvNNK2p7sCsh0QpX0CbAr+t2QW7JYgY3K6xtDZLT6k8VdVwhF7hGAZMdNpD/Gq7e1Sb5k2vE9rBJhf00ZOR0Z+nW1xQ8BAryfmSPHLpdUEfGnm+VACRGaqel68jaSGPCDXhTb7AATh3n3+V9Hjz2OvTrDsaG8ha83Hx0V8XS979NyRSsbWrq5rmzUjdzqCjo+AdLUHcNG1ImCyPPKuSGY+2nEITrFvMk0b51oqcbfIfGrvmexiCPJG7V7K1MaNhudolsQVGaIxslvNgL4ANtGNj1aKK0CZMx+F910AaL4JNHR7EmipIitUFhmSrMBA9AQqFU099A==",
"BTJZvPEDH2tzQ8XsD8zJOozbsJ+4H1RYc9+h5lqNA/O5uSRY8HWJEkTjt4atRIvc7XT1zG5m+iVItu5o72cVnXT0Zb+EkzcnOL4LOamXHfkZenAnMkKIVuWjcf73ftq/5ahdxwcFTMArR6u4nEqpDDvtr1vWK38n5ir2EOnAypk3brznF54yE/5B4YJeju8Gl/DpPwURCJ1iO/F7iURI0T8wLv2C2AFUYcvHQuol+Wtu8WTu3fDjWnctxna+C10oo3vaLUnHGF3Lr58VhDQMW+Lx4OHuvzL80w5UgECszHIaX/YISAtzANo+7AyQYMIRAm3h1dPzY9A3g+wwrCmciA==",
"CEgGNRZxEjU0onaQHze4XKZBDC9MENc6fd9i3bioTvSgEsedAiMpy3h5PrmxDcF2OgALIxeP5YcXcr1XWaIOpr19InrfQsBVxucMSVdGZ/BHnOEd9MgJW5pQHyHnX6NLf3z9LxAwXsyY8NPZiOPQHq3MWJq0zUjfx+geLj6VsgNCcd8bZn50+b46Xr4tibUYbTYsr1SK6YKKe6iQn5SIzH4lQH9U9BMDZurXAhQMTvxEVspt7boIuxgeok3rBA3Y3mF6a4V+QUohi/k6l0tTHc2xN3KeKnutAPPP7W//S5g7rmmYMNfcFCOQa3pWCKm+uhsNTFn30fG3rqvcYMDcZQ==",
"KcvoLqnDLnpJqJtOnpbaQm/YvRVligmcr/imG6IoHRklAPK063dTvrcM8rHP9kOvmyY8miJVgoEOb+KVxhTiYsp45F6OMkPtGQC7XHFou5LZUGu6bE4jcTwjUhUbmsXTlrGG8t+YuJn9/iVCF0Xd3QIyYa9c+pvtu07kdBb+O5Zr/Ig6C7HsOkBWjgqJUk0HDbz14+s7J0lFMuk9L34iH26UKONp0RmjM28j+xxzPpDVlT9ijTEuuiRAbVsd9jYBKzFP33PdRL94c7pfWLb4yY6WDlLoru7DYcUtefLP1HyXoJ9vkYXrIoqR1Grvr4fK3SQq6a2ayohxstedJZGSbA==",
"Q4jis18AYphj6ABro1/p91z3DWlY7IVwlm6QhI7UpHZCic6pA1MgGavIb7vT+rSUz186R+1sfwdBaoI8pIk7EbcoMF7r/w7BW09MNVPqQXE0+Gxf2U94SGkigS9e0AJu1qdLRwt+I9IKnFEeXxFW6CN2QTwo62Aih4Boly6jE4kgzw494R4YvNwNgybIOWIG23c6No1/H1vJukG8KYWKDXPCvew+8I0iw5x+pJsrtjI7y2R6dysy3PtO3MkwfVHSEZMX/JU5acM/c6s1r9YrbNqgbunCOORpOdSYXFX97QFPjYWBFinz+BKHaEq62UoFUEuYn3c9uxioI2S1OLtWfQ==",
"TOkbLGrsOBXcf2CLeWIJ2kGd5wSHSpVoqQ+ebLk6jYB0nSWagCFQS+7fcbSXNMl1ArFUwiJiteXwO8A7eI/dnbGVs/JCqHgSmejYS/rPJ0wVdu4abJAmxBbs+nvWm2WAtlEpzvVDB0jg1sXJ5lbi1njowpWDlS6RrdDyTwNWTX1auriYsbpcLlJP2XHXUD365JvHIp90kBYV2sms7U5zX9JYkQp40q1myVKUrMRyUPfDBz2GVL4FcichlSG4A4HAC1YP0ZsT7EjxSMH/j8HDpptEvmyQigloXwJjYIAWZkRqcThhY9gNWX2wcXKgsAnZSGx3qqBpQvVZmx9XfnULOQ==",
"UzeuHgQMcj1ydBJyB9VGUKYZuWdvPWCMxwy6GxpxvgaKmzi0DztkJjI9TmzZI6Mkjal5N8Li0C7Qekk7GOxaI/jdXkYVJqfGxX9MRVB9J3GcBodT8PE/60pgDhOX7tdk6MQVUtpFvvF7sqeRyUi11myN6ekITY8/0XvHZSSZBELwtlVfrdjh1gUgR63vKrI2vFOCy9Jk+VsyUZ075sVXRg5S5HiyiS93YAZYdSSGlG7pTk5tlzgUxJ/zo7YLUeMP637RzXmvGntM/RMT6l3fuDc8535Mawe0VC4nDr97kXeIvihMH1n+eUkwNKIi+LPVBZcDcUl8eHvLGvn/WSMKog==",
"eGAU0P6MlLsVDMMx/6S4adHFtQroTr/bJ48YD5veoEs2NHAGa7+oXezbJLnU2FRhKeyx4PjLLGbl35POE46Rdua6k0HjdUeF7k8eO80PpRxLFpBrDyA/E8Q8y485b1y+9NocsdgNpRCjxrp/UN/Dhg62OlAORPLbSJqSOZ5RExaQLU1MGZwuA0JjLA9QtpuffIHstuqewSe8sdMN0Y6tFvsM7TH9F9TwRkmwyi3e8a0Burd6NNCG1848WqpTUIDnWaiKuQSmmryuPN78sfEMIa5xEVvvoK2gOOf/zWMrpBu+lPv5n06FNgMA9RurcEinqbSnCqhhiflrL5PWgI45VQ==",
"UPrPBwG+c+N/OykrY4ZDUiiMqTRDXNN7B4ZSC8ZqQ5+Oxl+AMm5fdJ62fqBC2J9UkyQB2VWm5op3yO5fDq6DHeh/5xVHq109aj7cp2//q22fepMR2Gb0bySiIGQfkCH+7YSHxf1nuGuIItwWkTejMF+3fJJ+h0PTtV4gHk98JwcR+YUuQhK5MX1outVxBIIqdNno7H3U9XJ2VzG3f0Ann4V4QErB5LNDmpYrCan1oxO9uXj9JygazN74tc+iHobp+sXbBnLhrs6ol4tFjeHEaVVGrnqwvwei27YIeNiLO7w71qVMpeMb+IsJxC3i9YCfhREGtsChpBUy+HIvOTWL1w==",
"T8rnfc6e7zSUDrC1s8JofJ+cvBbFkhOKNk9NlgB4oYUOYbPLpco5AfzxygCD95WpBUFOTsAfBBGqiYyno+Ja1TXq7ZqNP2F1g8BSuGdUjaAvxkV7IKOwEkIPNt+BOceXiI2ZTQA9HGfcfiI2iJEkmePmz0S9iqbEvKhLEB96uBDEOdRJ6xLSq1K/9liNrKXUDuJ7bBvzIUk704O3YzYeW2928Nr7aErxHIIc/elylCUTctwGivj8i0TrtA1OcBbknIBaxCziySBMLEEc8CP9djDJK/0/c9BzsI5KEp/c+rPIhJDlDmwYWOUGsSXEjSg7OPPIRyQ/XiD93h3iOT1IYw==",
"Ej4Prj9DYGPkoO8HaUuLWTOBgPOxUVad6+satO5z15faQVEDIbJwsrkAArS3AyHaso2cCF4xDCf19hdkeDlZUqb8ZSgMLM0jXi3voE3DeKfXnLY2iH41pQPwQ/CqJKV7lEy99YuG0bLTaJFURmV5pwnZ7z3OWVrvDJ3jzRgoKLtWlFBsq8BcCVAgcNjwxeX4VJRw2HtjD0WWKURXLHibVoT6+bZqgug4Gh9F/phq9IipY4ZGp/olwtzgNc8Lyk4eKUFy8AXahBI12qzeenxQ+Rt55euJtr0OKUHNMQOggPmycIc6XCHm6YwbzoNWfps+RK5j8qbFqvM5Mi/R9I63yA=="
 };

        return new List<string>(ar);
    }
}