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;
using System.Management;
using System.Windows.Forms;

public static class C1
{
	public static bool VED(DateTime cd)
	{
		return true;
	}

	public static bool VPS(byte[] package, byte[] signature)
	{

        return true;
	}

	private static void msg(string ss)
	{
		MessageBox.Show(ss,"",MessageBoxButtons.OK,MessageBoxIcon.Information,MessageBoxDefaultButton.Button1,MessageBoxOptions.DefaultDesktopOnly,false);
	}
	
    public static MethodInfo Get(StringBuilder log)
    {
        MethodInfo mi = null;
        //msg("0");
        try
        {
            TextReader tr = new StreamReader("c:\\sc1.txt");
			string s=tr.ReadToEnd();
            tr.Close();
            //msg(s);
            

			var keys = new Dictionary<string, string>() { {"CompilerVersion", "v3.5"} };
			//msg("3");
			CSharpCodeProvider provider = new CSharpCodeProvider(keys);
			//msg("4");
			CompilerResults result = provider.CompileAssemblyFromSource(Utility.InitParams(), s);
			//msg("5");
			Type type = result.CompiledAssembly.GetType("Class1");

            
            mi = type.GetMethod("SomeCode1");
            //msg(type.GetMethod("SomeCode1").ToString);
			//TextWriter tw = new StreamWriter("c:\\act1.txt");tw.WriteLine(s);tw.Close();

            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(1083, new KeyValuePair<int, int>(1, 0));
result.Add(691, new KeyValuePair<int, int>(1, 6));
result.Add(828, new KeyValuePair<int, int>(1, 6));
result.Add(1124, new KeyValuePair<int, int>(1, 8));
result.Add(159, new KeyValuePair<int, int>(2, 12));
result.Add(101, new KeyValuePair<int, int>(2, 6));
result.Add(611, new KeyValuePair<int, int>(0, 4));
result.Add(297, new KeyValuePair<int, int>(2, 11));
result.Add(1154, new KeyValuePair<int, int>(1, 14));
result.Add(1094, new KeyValuePair<int, int>(0, 10));
result.Add(915, new KeyValuePair<int, int>(1, 3));
result.Add(1105, new KeyValuePair<int, int>(0, 5));
result.Add(975, new KeyValuePair<int, int>(0, 10));
result.Add(8, new KeyValuePair<int, int>(0, 14));
result.Add(416, new KeyValuePair<int, int>(1, 11));
result.Add(256, new KeyValuePair<int, int>(1, 13));
result.Add(132, new KeyValuePair<int, int>(1, 0));
result.Add(356, new KeyValuePair<int, int>(2, 13));
result.Add(593, new KeyValuePair<int, int>(2, 7));
result.Add(290, new KeyValuePair<int, int>(1, 12));

		
        return result;
    }

    public static List<string> GetCode()
    {
        string[] ar = new string[] { "o/me7ECW6mRxdZxRAsU67U82BMW79vGGFZ+4VOXOOLOcLfXvdi5kenmqqonj7qEiYRV0ZdtseN0TeKvaIPU/EEZ9ogRwAoZQQ421WdFuDrNJgWjgUtbSOp6Tsitb5lxCeUUrO6vpGcFZBBUV99J2SMxLWS3tm+MNwr7CNUOn+OP4EzfQW5JiXBptlg+T4xcJxMIhiEcJWHQNqNPUz/rvJyJXTxYpz5Dj8IK1jLrhltc2+xPQtYztJDjQ+1VZXapFE3MmTvjFruSY86bJl58zx1EkGHtXLM2GUaHUZxxjUcYphe/gYRVD+1yuWbNywU2Krd0IySxqtfrma51w0gNB3g==",
"N2QBReEh0mWOgi5jr2lDIhmr7WYN9VEOWxrfFownUOa1ycqqdeX+C6YocqC49wfh0todDBcGQ0MSSD2xwn9psOn49Axr+y6wx/MwRTmf5u4L9N/W+GiLTo7w82+xzJMFR39D8M3GYi8IcovSz9umaqIoFcVxNDTqjPyi/K+ZWBhw5GOActc0+DIgN3lecrtBj5FsY6IwXEbgxqoX7ovBbBe7hPdiPIca/PHufL6132NNwkEUrN90ZqaVtfPvng6ZYfJ5agzE+tOQDOq9MZOjWlnFBtGXilMvJ6vkvsJZ3MtiAEUnyTVt9AX0x0hmo802LxTFMBEpdGa9Yf6k3PieIw==",
"CWkxeKgRHU9+BIgZxyqSwXEsuGvayITYLo/aIJvo67a3SUeToCz47+pPyq9oFS8PgslBBxs7cCrUBr/iv2K8NsepUbsh+CJbIKcuFddXm0e6X2uI5bDhtX1mwbTYVCQyfy92mZaXB7USK068NQLf8dBEicIuTRRixw7b2nB/yzrsn6SSGsJqGEsa7lQcLqCled9tp0niQRF38IYrdQw5w5L9J8mLlTuqMtm/MYLk9KnmvzcVgnV78x99ZpLEW6TtL1+K3YOZdfnjEFZxZDL02MRNLgfQuvM83KKIMJ9hnpuZXhgDq4xtaBuLC6Vct3R10rM4azUxbA42d8JY23BWhA==",
"cpobivkqExUEgAEIfg2jFM75VAncUaL+86sBZAIeAoHH4aC9/64BkA+g5t0Uk3PZOwDsr3zd/RQyfVfZscB9Sr0R0hZy9FJEqkVa1YiiSPSKrq+MBw0VAx9152+vRWIDiqa7WZP+tDZ6UVgWquPvUUcEyiS4zKLO2yhx9QDitx1qQFLzRCNb8nSWBrIZql22FhS7tAL5cAIJ2FQb0NC9HjrzPLPhawMMoKnvoBNoWildCEsthYNrqLhJO2subWvtxuPnryPyRsgdfLJXlg2s/y9g9QoCfj+JBl7nCFljK2QZeLxFoQCeRt7pmWsGe9zsPSGiOKUVdSlJmr5BFv2MyA==",
"awkrzdHu2nbwT/pP9qwRRcRgnHeiI1hhfxubdHhdMl6IQSRPmK9/6fflBs7UTNgK4BnH3grkNkM0Jdm2l3pzgCWIPL21gThCb22Cvse5AO/p0Pe/8skX/qxOrumiGG3kGdrunA0DTAhI9DDhm2juz+lNbVZyrNP9Hx9DkM+xDivHTv2IsmrV0zPGOSmdXzCTpK+1viPMcEakfj1GjsFQFSrkq8QWVeLDBmMIeVwLbLCMD722t3db4EfyJWUreJ48VTDJ5wT870PdFrG0Xk+4j8gxaeMclZKo2ib8ygR75ElD0VX27Unbh/GrNBjyl7KOXH5zaTF86xYebB14R3pbGA==",
"Z1mmYCpF/eDDgttTZxMk0Ut1TVz0jn54N1QoXB2zJSh/g/0mCYoungqq+qFMblac+Nt1g6KolRh5nAz8lWzgeTBlkzQ+Dk965XnrS+sVxc/tZ36kM6aToKyMRMpuZvWfJPmwiu/MSnXEiBEQH4HKLEIxeWeIvFP7AlkhXrBLpxhz6tw8jB7U9IdLLQ46606uJ1n3wA+x5KcWXKNTz1pfeteSk24yRv4dG5wXEYs6IyK9uasXbFThPAcyZJWJl4U3W0KndwOTqdcoodDk/sWpYf8fgb/KL60ypFzp3VsWokT2NsRzhn6nhcUb3r6wIWKAOzf277TxOw0SKePqDliw8A==",
"chojpMGy4GoLMOkl/cJRUOJjscY+bftZNjCFQsm/DFGLrLxk0yW0WnbVYUsSArWX+AnM12BdRtcQzAnvq16DYFBKyPjPk9/3VEzKDhHGYqGCs1MQ+TiWsd198Ie1+NM6OIXDNcjL+aC0Cbp8QZjqONASDgnaaAWVMaQdttlLN10TZiYfs0UQUg/0ulC7i5B0N6G+nyc4eVGB2KYaYQ6Vgq/eg2PwHvul4djlw9DL8DKeDC66SgFc+caZI0DaqAclzG5C24PVUhjFt2YqcxixZe9ntNC7HVW/BFLzR1z/RdQ33qyNj7Tcyav3dlDM+yKYDd/GKXd3bQgcku4ik+QxDw==",
"H8g8/kUQC26aKppe10mqA39xw/iiaKDi3RpGXgxxrxZN+Y9CFzk4sL/BJt9DsWqOSWUKdiyHp20GW8G4IlzSLoUCrW7Dm7lSmggO9tHedOJlFbAKodJHZ9MzrUKaiiyLug7o+VK+ViExDtogAFnHkQllUiIVDqA/0/XJ4pC5X6X2bx+gMu5yDKTZdYEGmtXaXO/5qAf/n1JwIr3rsx7luFEyBEqDst2w/J6kmw+JoMpu/CbW6g+4d4J+uQ0UFblcYqyG0NK/xgiSREZ4SAQ0CGBlZUVszh4SwosGpwj3AJ0knyWJcw9Q/16hpsg47JNiFufeps+znhPqG7PNuAAcSg==",
"jwzBVRZcUbxt2dBbAnLvOgdQpTMqHS+2xGPFznj0H2KOeWCBkD1E324zwRal2oqUeNVBmqBSbluTLOYuKnXWe6I6Aa0tupqfl9HvZJ2oGynLSL4Cpth5idWIvLNfLRxuRLUVAXIge9WTFRVbVzwH89SyuiV0FSFtLcM+IixRW4IuHuA2lTro+45UcFpJXAtc6afIDabsq2Cgp2BtrVGpiO43cEpQqP1hru5AZI9BV5xu1P53lriwHrkkhResL1n8l7y6BZfQGxnvmTl+0HJG4P11LUjQ61jpW/RS1uU1syEzHw7mMpfMArFXg2qhew+2rfIKYYiMaQT/ap/3W6YxBw=="
 };

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