using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;

internal class Class10
{
	static Class10()
	{
		try
		{
			RSACryptoServiceProvider.UseMachineKeyStore = true;
		}
		catch
		{
		}
	}

	private void method_0()
	{
	}

	internal static byte[] smethod_0(byte[] byte_2)
	{
		uint[] array = new uint[16];
		uint num = (uint)((448 - byte_2.Length * 8 % 512 + 512) % 512);
		if (num == 0U)
		{
			num = 512U;
		}
		uint num2 = (uint)((long)byte_2.Length + (long)((ulong)(num / 8U)) + 8L);
		ulong num3 = (ulong)((long)byte_2.Length * 8L);
		byte[] array2 = new byte[num2];
		for (int i = 0; i < byte_2.Length; i++)
		{
			array2[i] = byte_2[i];
		}
		byte[] array3 = array2;
		int num4 = byte_2.Length;
		array3[num4] |= 128;
		for (int j = 8; j > 0; j--)
		{
			array2[(int)(checked((IntPtr)(unchecked((ulong)num2 - (ulong)((long)j)))))] = (byte)((num3 >> (8 - j) * 8) & 255UL);
		}
		uint num5 = (uint)(array2.Length * 8 / 32);
		uint num6 = 1732584193U;
		uint num7 = 4023233417U;
		uint num8 = 2562383102U;
		uint num9 = 271733878U;
		for (uint num10 = 0U; num10 < num5 / 16U; num10 += 1U)
		{
			uint num11 = num10 << 6;
			for (uint num12 = 0U; num12 < 61U; num12 += 4U)
			{
				array[(int)(num12 >> 2)] = (uint)(((int)array2[(int)(num11 + (num12 + 3U))] << 24) | ((int)array2[(int)(num11 + (num12 + 2U))] << 16) | ((int)array2[(int)(num11 + (num12 + 1U))] << 8) | (int)array2[(int)(num11 + num12)]);
			}
			uint num13 = num6;
			uint num14 = num7;
			uint num15 = num8;
			uint num16 = num9;
			Class10.smethod_1(ref num6, num7, num8, num9, 0U, 7, 1U, array);
			Class10.smethod_1(ref num9, num6, num7, num8, 1U, 12, 2U, array);
			Class10.smethod_1(ref num8, num9, num6, num7, 2U, 17, 3U, array);
			Class10.smethod_1(ref num7, num8, num9, num6, 3U, 22, 4U, array);
			Class10.smethod_1(ref num6, num7, num8, num9, 4U, 7, 5U, array);
			Class10.smethod_1(ref num9, num6, num7, num8, 5U, 12, 6U, array);
			Class10.smethod_1(ref num8, num9, num6, num7, 6U, 17, 7U, array);
			Class10.smethod_1(ref num7, num8, num9, num6, 7U, 22, 8U, array);
			Class10.smethod_1(ref num6, num7, num8, num9, 8U, 7, 9U, array);
			Class10.smethod_1(ref num9, num6, num7, num8, 9U, 12, 10U, array);
			Class10.smethod_1(ref num8, num9, num6, num7, 10U, 17, 11U, array);
			Class10.smethod_1(ref num7, num8, num9, num6, 11U, 22, 12U, array);
			Class10.smethod_1(ref num6, num7, num8, num9, 12U, 7, 13U, array);
			Class10.smethod_1(ref num9, num6, num7, num8, 13U, 12, 14U, array);
			Class10.smethod_1(ref num8, num9, num6, num7, 14U, 17, 15U, array);
			Class10.smethod_1(ref num7, num8, num9, num6, 15U, 22, 16U, array);
			Class10.smethod_2(ref num6, num7, num8, num9, 1U, 5, 17U, array);
			Class10.smethod_2(ref num9, num6, num7, num8, 6U, 9, 18U, array);
			Class10.smethod_2(ref num8, num9, num6, num7, 11U, 14, 19U, array);
			Class10.smethod_2(ref num7, num8, num9, num6, 0U, 20, 20U, array);
			Class10.smethod_2(ref num6, num7, num8, num9, 5U, 5, 21U, array);
			Class10.smethod_2(ref num9, num6, num7, num8, 10U, 9, 22U, array);
			Class10.smethod_2(ref num8, num9, num6, num7, 15U, 14, 23U, array);
			Class10.smethod_2(ref num7, num8, num9, num6, 4U, 20, 24U, array);
			Class10.smethod_2(ref num6, num7, num8, num9, 9U, 5, 25U, array);
			Class10.smethod_2(ref num9, num6, num7, num8, 14U, 9, 26U, array);
			Class10.smethod_2(ref num8, num9, num6, num7, 3U, 14, 27U, array);
			Class10.smethod_2(ref num7, num8, num9, num6, 8U, 20, 28U, array);
			Class10.smethod_2(ref num6, num7, num8, num9, 13U, 5, 29U, array);
			Class10.smethod_2(ref num9, num6, num7, num8, 2U, 9, 30U, array);
			Class10.smethod_2(ref num8, num9, num6, num7, 7U, 14, 31U, array);
			Class10.smethod_2(ref num7, num8, num9, num6, 12U, 20, 32U, array);
			Class10.smethod_3(ref num6, num7, num8, num9, 5U, 4, 33U, array);
			Class10.smethod_3(ref num9, num6, num7, num8, 8U, 11, 34U, array);
			Class10.smethod_3(ref num8, num9, num6, num7, 11U, 16, 35U, array);
			Class10.smethod_3(ref num7, num8, num9, num6, 14U, 23, 36U, array);
			Class10.smethod_3(ref num6, num7, num8, num9, 1U, 4, 37U, array);
			Class10.smethod_3(ref num9, num6, num7, num8, 4U, 11, 38U, array);
			Class10.smethod_3(ref num8, num9, num6, num7, 7U, 16, 39U, array);
			Class10.smethod_3(ref num7, num8, num9, num6, 10U, 23, 40U, array);
			Class10.smethod_3(ref num6, num7, num8, num9, 13U, 4, 41U, array);
			Class10.smethod_3(ref num9, num6, num7, num8, 0U, 11, 42U, array);
			Class10.smethod_3(ref num8, num9, num6, num7, 3U, 16, 43U, array);
			Class10.smethod_3(ref num7, num8, num9, num6, 6U, 23, 44U, array);
			Class10.smethod_3(ref num6, num7, num8, num9, 9U, 4, 45U, array);
			Class10.smethod_3(ref num9, num6, num7, num8, 12U, 11, 46U, array);
			Class10.smethod_3(ref num8, num9, num6, num7, 15U, 16, 47U, array);
			Class10.smethod_3(ref num7, num8, num9, num6, 2U, 23, 48U, array);
			Class10.smethod_4(ref num6, num7, num8, num9, 0U, 6, 49U, array);
			Class10.smethod_4(ref num9, num6, num7, num8, 7U, 10, 50U, array);
			Class10.smethod_4(ref num8, num9, num6, num7, 14U, 15, 51U, array);
			Class10.smethod_4(ref num7, num8, num9, num6, 5U, 21, 52U, array);
			Class10.smethod_4(ref num6, num7, num8, num9, 12U, 6, 53U, array);
			Class10.smethod_4(ref num9, num6, num7, num8, 3U, 10, 54U, array);
			Class10.smethod_4(ref num8, num9, num6, num7, 10U, 15, 55U, array);
			Class10.smethod_4(ref num7, num8, num9, num6, 1U, 21, 56U, array);
			Class10.smethod_4(ref num6, num7, num8, num9, 8U, 6, 57U, array);
			Class10.smethod_4(ref num9, num6, num7, num8, 15U, 10, 58U, array);
			Class10.smethod_4(ref num8, num9, num6, num7, 6U, 15, 59U, array);
			Class10.smethod_4(ref num7, num8, num9, num6, 13U, 21, 60U, array);
			Class10.smethod_4(ref num6, num7, num8, num9, 4U, 6, 61U, array);
			Class10.smethod_4(ref num9, num6, num7, num8, 11U, 10, 62U, array);
			Class10.smethod_4(ref num8, num9, num6, num7, 2U, 15, 63U, array);
			Class10.smethod_4(ref num7, num8, num9, num6, 9U, 21, 64U, array);
			num6 += num13;
			num7 += num14;
			num8 += num15;
			num9 += num16;
		}
		byte[] array4 = new byte[16];
		Array.Copy(BitConverter.GetBytes(num6), 0, array4, 0, 4);
		Array.Copy(BitConverter.GetBytes(num7), 0, array4, 4, 4);
		Array.Copy(BitConverter.GetBytes(num8), 0, array4, 8, 4);
		Array.Copy(BitConverter.GetBytes(num9), 0, array4, 12, 4);
		return array4;
	}

	private static void smethod_1(ref uint uint_1, uint uint_2, uint uint_3, uint uint_4, uint uint_5, ushort ushort_0, uint uint_6, object object_3)
	{
		uint_1 = uint_2 + Class10.smethod_5(uint_1 + ((uint_2 & uint_3) | (~uint_2 & uint_4)) + object_3[(int)uint_5] + Class10.uint_0[(int)(uint_6 - 1U)], ushort_0);
	}

	private static void smethod_2(ref uint uint_1, uint uint_2, uint uint_3, uint uint_4, uint uint_5, ushort ushort_0, uint uint_6, object object_3)
	{
		uint_1 = uint_2 + Class10.smethod_5(uint_1 + ((uint_2 & uint_4) | (uint_3 & ~uint_4)) + object_3[(int)uint_5] + Class10.uint_0[(int)(uint_6 - 1U)], ushort_0);
	}

	private static void smethod_3(ref uint uint_1, uint uint_2, uint uint_3, uint uint_4, uint uint_5, ushort ushort_0, uint uint_6, object object_3)
	{
		uint_1 = uint_2 + Class10.smethod_5(uint_1 + (uint_2 ^ uint_3 ^ uint_4) + object_3[(int)uint_5] + Class10.uint_0[(int)(uint_6 - 1U)], ushort_0);
	}

	private static void smethod_4(ref uint uint_1, uint uint_2, uint uint_3, uint uint_4, uint uint_5, ushort ushort_0, uint uint_6, object object_3)
	{
		uint_1 = uint_2 + Class10.smethod_5(uint_1 + (uint_3 ^ (uint_2 | ~uint_4)) + object_3[(int)uint_5] + Class10.uint_0[(int)(uint_6 - 1U)], ushort_0);
	}

	private static uint smethod_5(uint uint_1, ushort ushort_0)
	{
		return (uint_1 >> (int)(32 - ushort_0)) | (uint_1 << (int)ushort_0);
	}

	internal static bool smethod_6()
	{
		if (!Class10.bool_0)
		{
			Class10.smethod_8();
			Class10.bool_0 = true;
		}
		return Class10.bool_4;
	}

	internal Class10()
	{
	}

	private void method_1(byte[] byte_2, byte[] byte_3, byte[] byte_4)
	{
		int num = byte_4.Length % 4;
		int num2 = byte_4.Length / 4;
		byte[] array = new byte[byte_4.Length];
		int num3 = byte_2.Length / 4;
		uint num4 = 0U;
		if (num > 0)
		{
			num2++;
		}
		for (int i = 0; i < num2; i++)
		{
			int num5 = i % num3;
			int num6 = i * 4;
			uint num7 = (uint)(num5 * 4);
			uint num8 = (uint)(((int)byte_2[(int)(num7 + 3U)] << 24) | ((int)byte_2[(int)(num7 + 2U)] << 16) | ((int)byte_2[(int)(num7 + 1U)] << 8) | (int)byte_2[(int)num7]);
			uint num9 = 255U;
			int num10 = 0;
			uint num11;
			if (i == num2 - 1 && num > 0)
			{
				num11 = 0U;
				num4 += num8;
				for (int j = 0; j < num; j++)
				{
					if (j > 0)
					{
						num11 <<= 8;
					}
					num11 |= (uint)byte_4[byte_4.Length - (1 + j)];
				}
			}
			else
			{
				num4 += num8;
				num7 = (uint)num6;
				num11 = (uint)(((int)byte_4[(int)(num7 + 3U)] << 24) | ((int)byte_4[(int)(num7 + 2U)] << 16) | ((int)byte_4[(int)(num7 + 1U)] << 8) | (int)byte_4[(int)num7]);
			}
			num4 += 3792483412U;
			if (i == num2 - 1 && num > 0)
			{
				uint num12 = num4 ^ num11;
				for (int k = 0; k < num; k++)
				{
					if (k > 0)
					{
						num9 <<= 8;
						num10 += 8;
					}
					array[num6 + k] = (byte)((num12 & num9) >> num10);
				}
			}
			else
			{
				uint num13 = num4 ^ num11;
				array[num6] = (byte)(num13 & 255U);
				array[num6 + 1] = (byte)((num13 & 65280U) >> 8);
				array[num6 + 2] = (byte)((num13 & 16711680U) >> 16);
				array[num6 + 3] = (byte)((num13 & 4278190080U) >> 24);
			}
		}
		Class10.byte_1 = array;
	}

	internal static SymmetricAlgorithm smethod_7()
	{
		SymmetricAlgorithm symmetricAlgorithm = null;
		if (Class10.smethod_6())
		{
			symmetricAlgorithm = new AesCryptoServiceProvider();
		}
		else
		{
			try
			{
				symmetricAlgorithm = new RijndaelManaged();
			}
			catch
			{
				try
				{
					symmetricAlgorithm = (SymmetricAlgorithm)Activator.CreateInstance("System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Security.Cryptography.AesCryptoServiceProvider").Unwrap();
				}
				catch
				{
					symmetricAlgorithm = (SymmetricAlgorithm)Activator.CreateInstance("System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "System.Security.Cryptography.AesCryptoServiceProvider").Unwrap();
				}
			}
		}
		return symmetricAlgorithm;
	}

	internal static void smethod_8()
	{
		try
		{
			new MD5CryptoServiceProvider();
		}
		catch
		{
			Class10.bool_4 = true;
			return;
		}
		try
		{
			Class10.bool_4 = CryptoConfig.AllowOnlyFipsAlgorithms;
		}
		catch
		{
		}
	}

	internal static byte[] smethod_9(byte[] byte_2)
	{
		if (!Class10.smethod_6())
		{
			return new MD5CryptoServiceProvider().ComputeHash(byte_2);
		}
		return Class10.smethod_0(byte_2);
	}

	internal static void smethod_10(HashAlgorithm hashAlgorithm_0, Stream stream_0, uint uint_1, byte[] byte_2)
	{
		while (uint_1 > 0U)
		{
			int num = ((uint_1 > (uint)byte_2.Length) ? byte_2.Length : ((int)uint_1));
			stream_0.Read(byte_2, 0, num);
			Class10.VeZjNyNqf(hashAlgorithm_0, byte_2, 0, num);
			uint_1 -= (uint)num;
		}
	}

	internal static void VeZjNyNqf(HashAlgorithm hashAlgorithm_0, byte[] byte_2, int int_6, int int_7)
	{
		hashAlgorithm_0.TransformBlock(byte_2, int_6, int_7, byte_2, int_6);
	}

	internal static uint smethod_11(uint uint_1, int int_6, long long_2, BinaryReader binaryReader_0)
	{
		for (int i = 0; i < int_6; i++)
		{
			binaryReader_0.BaseStream.Position = long_2 + (long)(i * 40 + 8);
			uint num = binaryReader_0.ReadUInt32();
			uint num2 = binaryReader_0.ReadUInt32();
			binaryReader_0.ReadUInt32();
			uint num3 = binaryReader_0.ReadUInt32();
			if (num2 <= uint_1 && uint_1 < num2 + num)
			{
				return num3 + uint_1 - num2;
			}
		}
		return 0U;
	}

	internal static void smethod_12()
	{
	}

	public static void smethod_13(RuntimeTypeHandle runtimeTypeHandle_0)
	{
		try
		{
			Type typeFromHandle = Type.GetTypeFromHandle(runtimeTypeHandle_0);
			if (Class10.dictionary_0 == null)
			{
				object obj = Class10.object_2;
				lock (obj)
				{
					Dictionary<int, int> dictionary = new Dictionary<int, int>();
					BinaryReader binaryReader = new BinaryReader(typeof(Class10).Assembly.GetManifestResourceStream("BE48lsxFmq40HuDsSS.5VJYvU2mydD0AQ8Fww"));
					binaryReader.BaseStream.Position = 0L;
					byte[] array = binaryReader.ReadBytes((int)binaryReader.BaseStream.Length);
					binaryReader.Close();
					if (array.Length != 0)
					{
						int num = array.Length % 4;
						int num2 = array.Length / 4;
						byte[] array2 = new byte[array.Length];
						uint num3 = 0U;
						if (num > 0)
						{
							num2++;
						}
						for (int i = 0; i < num2; i++)
						{
							int num4 = i * 4;
							uint num5 = 255U;
							int num6 = 0;
							uint num7;
							if (i == num2 - 1 && num > 0)
							{
								num7 = 0U;
								for (int j = 0; j < num; j++)
								{
									if (j > 0)
									{
										num7 <<= 8;
									}
									num7 |= (uint)array[array.Length - (1 + j)];
								}
							}
							else
							{
								uint num8 = (uint)num4;
								num7 = (uint)(((int)array[(int)(num8 + 3U)] << 24) | ((int)array[(int)(num8 + 2U)] << 16) | ((int)array[(int)(num8 + 1U)] << 8) | (int)array[(int)num8]);
							}
							num3 = num3;
							num3 += 3792483412U;
							if (i == num2 - 1 && num > 0)
							{
								uint num9 = num3 ^ num7;
								for (int k = 0; k < num; k++)
								{
									if (k > 0)
									{
										num5 <<= 8;
										num6 += 8;
									}
									array2[num4 + k] = (byte)((num9 & num5) >> num6);
								}
							}
							else
							{
								uint num10 = num3 ^ num7;
								array2[num4] = (byte)(num10 & 255U);
								array2[num4 + 1] = (byte)((num10 & 65280U) >> 8);
								array2[num4 + 2] = (byte)((num10 & 16711680U) >> 16);
								array2[num4 + 3] = (byte)((num10 & 4278190080U) >> 24);
							}
						}
						array = array2;
						int num11 = array.Length / 8;
						Class10.Class13 @class = new Class10.Class13(new MemoryStream(array));
						for (int l = 0; l < num11; l++)
						{
							int num12 = @class.method_3();
							int num13 = @class.method_3();
							dictionary.Add(num12, num13);
						}
						@class.method_4();
					}
					Class10.dictionary_0 = dictionary;
				}
			}
			FieldInfo[] fields = typeFromHandle.GetFields(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.GetField);
			for (int m = 0; m < fields.Length; m++)
			{
				try
				{
					FieldInfo fieldInfo = fields[m];
					int metadataToken = fieldInfo.MetadataToken;
					int num14 = Class10.dictionary_0[metadataToken];
					bool flag2 = (num14 & 1073741824) > 0;
					num14 &= 1073741823;
					MethodInfo methodInfo = (MethodInfo)typeof(Class10).Module.ResolveMethod(num14, typeFromHandle.GetGenericArguments(), new Type[0]);
					if (methodInfo.IsStatic)
					{
						fieldInfo.SetValue(null, Delegate.CreateDelegate(fieldInfo.FieldType, methodInfo));
					}
					else
					{
						ParameterInfo[] parameters = methodInfo.GetParameters();
						int num15 = parameters.Length + 1;
						Type[] array3 = new Type[num15];
						if (methodInfo.DeclaringType.IsValueType)
						{
							array3[0] = methodInfo.DeclaringType.MakeByRefType();
						}
						else
						{
							array3[0] = typeof(object);
						}
						for (int n = 0; n < parameters.Length; n++)
						{
							array3[n + 1] = parameters[n].ParameterType;
						}
						DynamicMethod dynamicMethod = new DynamicMethod(string.Empty, methodInfo.ReturnType, array3, typeFromHandle, true);
						ILGenerator ilgenerator = dynamicMethod.GetILGenerator();
						for (int num16 = 0; num16 < num15; num16++)
						{
							switch (num16)
							{
							case 0:
								ilgenerator.Emit(OpCodes.Ldarg_0);
								break;
							case 1:
								ilgenerator.Emit(OpCodes.Ldarg_1);
								break;
							case 2:
								ilgenerator.Emit(OpCodes.Ldarg_2);
								break;
							case 3:
								ilgenerator.Emit(OpCodes.Ldarg_3);
								break;
							default:
								ilgenerator.Emit(OpCodes.Ldarg_S, num16);
								break;
							}
						}
						ilgenerator.Emit(OpCodes.Tailcall);
						ilgenerator.Emit(flag2 ? OpCodes.Callvirt : OpCodes.Call, methodInfo);
						ilgenerator.Emit(OpCodes.Ret);
						fieldInfo.SetValue(null, dynamicMethod.CreateDelegate(typeFromHandle));
					}
				}
				catch (Exception)
				{
				}
			}
		}
		catch (Exception)
		{
		}
	}

	private static uint smethod_14(uint uint_1)
	{
		return (uint)"{11111-22222-10009-11112}".Length;
	}

	internal static void smethod_15()
	{
	}

	private static void smethod_16(object object_3, int int_6)
	{
		Class16.smethod_2(0, new object[] { object_3, int_6 }, null);
	}

	internal static string smethod_17(int int_6)
	{
		if (Class10.byte_1.Length == 0)
		{
			Class10.list_1 = new List<string>();
			Class10.list_0 = new List<int>();
			Class10.smethod_16(Class10.assembly_0.GetManifestResourceStream("86wlgtECEx4xTfcZVr.Zv3G7eRKsxCZOhVKRQ"), int_6);
		}
		if (Class10.int_3 < 75)
		{
			if (Class10.assembly_0 != new StackFrame(1).GetMethod().DeclaringType.Assembly)
			{
				throw new Exception();
			}
			Class10.int_3++;
		}
		object obj = Class10.object_1;
		lock (obj)
		{
			int num = BitConverter.ToInt32(Class10.byte_1, int_6);
			if (num >= Class10.list_0.Count || Class10.list_0[num] != int_6)
			{
				try
				{
					byte[] array = new byte[num];
					Array.Copy(Class10.byte_1, int_6 + 4, array, 0, num);
					string @string = Encoding.Unicode.GetString(array, 0, array.Length);
					Class10.list_1.Add(@string);
					Class10.list_0.Add(int_6);
					Array.Copy(BitConverter.GetBytes(Class10.list_1.Count - 1), 0, Class10.byte_1, int_6, 4);
					return @string;
				}
				catch
				{
					goto IL_012A;
				}
			}
			return Class10.list_1[num];
		}
		IL_012A:
		return "";
	}

	internal static string smethod_18(string string_0)
	{
		"{11111-22222-50001-00000}".Trim();
		byte[] array = Convert.FromBase64String(string_0);
		return Encoding.Unicode.GetString(array, 0, array.Length);
	}

	private static int smethod_19()
	{
		return 5;
	}

	private static void cOqUuvjiKc()
	{
		try
		{
			RSACryptoServiceProvider.UseMachineKeyStore = true;
		}
		catch
		{
		}
	}

	private static Delegate smethod_20(IntPtr intptr_3, Type type_0)
	{
		return (Delegate)typeof(Marshal).GetMethod("GetDelegateForFunctionPointer", new Type[]
		{
			typeof(IntPtr),
			typeof(Type)
		}).Invoke(null, new object[] { intptr_3, type_0 });
	}

	internal static object smethod_21(object object_3)
	{
		try
		{
			if (File.Exists(((Assembly)object_3).Location))
			{
				return ((Assembly)object_3).Location;
			}
		}
		catch
		{
		}
		try
		{
			if (File.Exists(((Assembly)object_3).GetName().CodeBase.ToString().Replace("file:///", "")))
			{
				return ((Assembly)object_3).GetName().CodeBase.ToString().Replace("file:///", "");
			}
		}
		catch
		{
		}
		try
		{
			if (File.Exists(object_3.GetType().GetProperty("Location").GetValue(object_3, new object[0])
				.ToString()))
			{
				return object_3.GetType().GetProperty("Location").GetValue(object_3, new object[0])
					.ToString();
			}
		}
		catch
		{
		}
		return "";
	}

	[DllImport("kernel32")]
	public static extern IntPtr LoadLibrary(string string_0);

	[DllImport("kernel32", CharSet = CharSet.Ansi)]
	public static extern IntPtr GetProcAddress(IntPtr intptr_3, string string_0);

	private static IntPtr smethod_22(IntPtr intptr_3, object object_3, uint uint_1)
	{
		if (Class10.delegate4_0 == null)
		{
			Class10.delegate4_0 = (Class10.Delegate4)Marshal.GetDelegateForFunctionPointer(Class10.GetProcAddress(Class10.smethod_28(), "Find ".Trim() + "ResourceA"), typeof(Class10.Delegate4));
		}
		return Class10.delegate4_0(intptr_3, object_3, uint_1);
	}

	private static IntPtr smethod_23(IntPtr intptr_3, uint uint_1, uint uint_2, uint uint_3)
	{
		if (Class10.delegate5_0 == null)
		{
			Class10.delegate5_0 = (Class10.Delegate5)Marshal.GetDelegateForFunctionPointer(Class10.GetProcAddress(Class10.smethod_28(), "Virtual ".Trim() + "Alloc"), typeof(Class10.Delegate5));
		}
		return Class10.delegate5_0(intptr_3, uint_1, uint_2, uint_3);
	}

	private static int smethod_24(IntPtr intptr_3, IntPtr intptr_4, [In] [Out] byte[] byte_2, uint uint_1, out IntPtr intptr_5)
	{
		if (Class10.delegate6_0 == null)
		{
			Class10.delegate6_0 = (Class10.Delegate6)Marshal.GetDelegateForFunctionPointer(Class10.GetProcAddress(Class10.smethod_28(), "Write ".Trim() + "Process ".Trim() + "Memory"), typeof(Class10.Delegate6));
		}
		return Class10.delegate6_0(intptr_3, intptr_4, byte_2, uint_1, out intptr_5);
	}

	private static int smethod_25(IntPtr intptr_3, int int_6, int int_7, ref int int_8)
	{
		if (Class10.delegate7_0 == null)
		{
			Class10.delegate7_0 = (Class10.Delegate7)Marshal.GetDelegateForFunctionPointer(Class10.GetProcAddress(Class10.smethod_28(), "Virtual ".Trim() + "Protect"), typeof(Class10.Delegate7));
		}
		return Class10.delegate7_0(intptr_3, int_6, int_7, ref int_8);
	}

	private static IntPtr smethod_26(uint uint_1, int int_6, uint uint_2)
	{
		if (Class10.delegate8_0 == null)
		{
			Class10.delegate8_0 = (Class10.Delegate8)Marshal.GetDelegateForFunctionPointer(Class10.GetProcAddress(Class10.smethod_28(), "Open ".Trim() + "Process"), typeof(Class10.Delegate8));
		}
		return Class10.delegate8_0(uint_1, int_6, uint_2);
	}

	private static int smethod_27(IntPtr intptr_3)
	{
		if (Class10.delegate9_0 == null)
		{
			Class10.delegate9_0 = (Class10.Delegate9)Marshal.GetDelegateForFunctionPointer(Class10.GetProcAddress(Class10.smethod_28(), "Close ".Trim() + "Handle"), typeof(Class10.Delegate9));
		}
		return Class10.delegate9_0(intptr_3);
	}

	private static IntPtr smethod_28()
	{
		if (Class10.intptr_2 == IntPtr.Zero)
		{
			Class10.intptr_2 = Class10.LoadLibrary("kernel ".Trim() + "32.dll");
		}
		return Class10.intptr_2;
	}

	private static byte[] smethod_29(object object_3)
	{
		byte[] array;
		using (FileStream fileStream = new FileStream(object_3, FileMode.Open, FileAccess.Read, FileShare.Read))
		{
			int num = 0;
			int i = (int)fileStream.Length;
			array = new byte[i];
			while (i > 0)
			{
				int num2 = fileStream.Read(array, num, i);
				num += num2;
				i -= num2;
			}
		}
		return array;
	}

	internal static byte[] smethod_30(Stream stream_0)
	{
		return ((MemoryStream)stream_0).ToArray();
	}

	private static byte[] smethod_31(object object_3)
	{
		Stream stream = new MemoryStream();
		SymmetricAlgorithm symmetricAlgorithm = Class10.smethod_7();
		symmetricAlgorithm.Key = new byte[]
		{
			103, 173, 187, 183, 43, 40, 225, 41, 11, 208,
			221, 216, 253, 61, 35, 20, 205, 47, 194, 53,
			106, 171, 23, 252, 91, 39, 82, 226, 129, 130,
			91, 65
		};
		symmetricAlgorithm.IV = new byte[]
		{
			59, 38, 116, 253, 90, 157, 211, 62, 220, 222,
			192, 192, 200, 248, 89, 71
		};
		CryptoStream cryptoStream = new CryptoStream(stream, symmetricAlgorithm.CreateDecryptor(), CryptoStreamMode.Write);
		cryptoStream.Write(object_3, 0, object_3.Length);
		cryptoStream.Close();
		return Class10.smethod_30(stream);
	}

	private byte[] method_2()
	{
		return null;
	}

	private byte[] method_3()
	{
		return null;
	}

	private byte[] method_4()
	{
		return null;
	}

	private byte[] method_5()
	{
		return null;
	}

	private byte[] EhiymevDwL()
	{
		int length = "{11111-22222-30001-00001}".Length;
		return new byte[] { 1, 2 };
	}

	private byte[] method_6()
	{
		int length = "{11111-22222-30001-00002}".Length;
		return new byte[] { 1, 2 };
	}

	internal byte[] method_7()
	{
		int length = "{11111-22222-40001-00001}".Length;
		return new byte[] { 1, 2 };
	}

	internal byte[] method_8()
	{
		int length = "{11111-22222-40001-00002}".Length;
		return new byte[] { 1, 2 };
	}

	internal byte[] method_9()
	{
		int length = "{11111-22222-50001-00001}".Length;
		return new byte[] { 1, 2 };
	}

	internal byte[] method_10()
	{
		int length = "{11111-22222-50001-00002}".Length;
		return new byte[] { 1, 2 };
	}

	internal static object smethod_32(object object_3)
	{
		return object_3.method_0();
	}

	internal static void smethod_33(object object_3, long long_2)
	{
		object_3.Position = long_2;
	}

	internal static long smethod_34(object object_3)
	{
		return object_3.Length;
	}

	internal static object smethod_35(object object_3, int int_6)
	{
		return object_3.method_1(int_6);
	}

	internal static void smethod_36(object object_3)
	{
		object_3.method_4();
	}

	internal static void smethod_37(object object_3)
	{
		Array.Reverse(object_3);
	}

	internal static object smethod_38(object object_3)
	{
		return object_3.GetName();
	}

	internal static object smethod_39(object object_3)
	{
		return object_3.GetPublicKeyToken();
	}

	internal static object smethod_40()
	{
		return Class10.smethod_7();
	}

	internal static void smethod_41(object object_3, CipherMode cipherMode_0)
	{
		object_3.Mode = cipherMode_0;
	}

	internal static object smethod_42(object object_3, object object_4, object object_5)
	{
		return object_3.CreateDecryptor(object_4, object_5);
	}

	internal static object smethod_43()
	{
		return new MemoryStream();
	}

	internal static void smethod_44(object object_3, object object_4, int int_6, int int_7)
	{
		object_3.Write(object_4, int_6, int_7);
	}

	internal static void smethod_45(object object_3)
	{
		object_3.FlushFinalBlock();
	}

	internal static object smethod_46(object object_3)
	{
		return Class10.smethod_30(object_3);
	}

	internal static void smethod_47(object object_3)
	{
		object_3.Close();
	}

	internal static object smethod_48(object object_3)
	{
		return object_3.EntryPoint;
	}

	internal static bool smethod_49(object object_3, object object_4)
	{
		return object_3 == object_4;
	}

	internal static bool smethod_50()
	{
		return null == null;
	}

	internal static object smethod_51()
	{
		return null;
	}

	internal static void smethod_52()
	{
	}

	internal static void smethod_53(bool bool_7)
	{
		RSACryptoServiceProvider.UseMachineKeyStore = bool_7;
	}

	internal static Type smethod_54(RuntimeTypeHandle runtimeTypeHandle_0)
	{
		return Type.GetTypeFromHandle(runtimeTypeHandle_0);
	}

	internal static object smethod_55(object object_3)
	{
		return object_3.Location;
	}

	internal static int smethod_56(object object_3)
	{
		return object_3.Length;
	}

	internal static object smethod_57()
	{
		return SHA1.Create();
	}

	internal static object smethod_58(object object_3)
	{
		return CryptoConfig.MapNameToOID(object_3);
	}

	internal static bool smethod_59(object object_3)
	{
		return File.Exists(object_3);
	}

	internal static object smethod_60(object object_3, object object_4)
	{
		return object_3.GetManifestResourceStream(object_4);
	}

	internal static object smethod_61(object object_3)
	{
		return object_3.method_0();
	}

	internal static void smethod_62(object object_3, long long_2)
	{
		object_3.Position = long_2;
	}

	internal static long smethod_63(object object_3)
	{
		return object_3.Length;
	}

	internal static object smethod_64(object object_3, int int_6)
	{
		return object_3.method_1(int_6);
	}

	internal static object smethod_65()
	{
		return Class10.smethod_7();
	}

	internal static void smethod_66(object object_3, CipherMode cipherMode_0)
	{
		object_3.Mode = cipherMode_0;
	}

	internal static object smethod_67(object object_3, object object_4, object object_5)
	{
		return object_3.CreateDecryptor(object_4, object_5);
	}

	internal static object smethod_68()
	{
		return new MemoryStream();
	}

	internal static void smethod_69(object object_3, object object_4, int int_6, int int_7)
	{
		object_3.Write(object_4, int_6, int_7);
	}

	internal static void smethod_70(object object_3)
	{
		object_3.FlushFinalBlock();
	}

	internal static object smethod_71()
	{
		return Encoding.UTF8;
	}

	internal static object smethod_72(object object_3)
	{
		return Class10.smethod_30(object_3);
	}

	internal static object smethod_73(object object_3, object object_4)
	{
		return object_3.GetString(object_4);
	}

	internal static void smethod_74(object object_3, object object_4)
	{
		object_3.FromXmlString(object_4);
	}

	internal static void smethod_75(object object_3)
	{
		object_3.Close();
	}

	internal static void smethod_76(object object_3)
	{
		object_3.method_4();
	}

	internal static void smethod_77(object object_3, object object_4, uint uint_1, object object_5)
	{
		Class10.smethod_10(object_3, object_4, uint_1, object_5);
	}

	internal static ushort smethod_78(object object_3)
	{
		return object_3.ReadUInt16();
	}

	internal static int smethod_79(object object_3, object object_4, int int_6, int int_7)
	{
		return object_3.Read(object_4, int_6, int_7);
	}

	internal static void smethod_80(object object_3, object object_4, int int_6, int int_7)
	{
		Class10.VeZjNyNqf(object_3, object_4, int_6, int_7);
	}

	internal static long smethod_81(object object_3)
	{
		return object_3.Position;
	}

	internal static uint smethod_82(object object_3)
	{
		return object_3.ReadUInt32();
	}

	internal static uint smethod_83(uint uint_1, int int_6, long long_2, object object_3)
	{
		return Class10.smethod_11(uint_1, int_6, long_2, object_3);
	}

	internal static long smethod_84(long long_2, long long_3)
	{
		return Math.Min(long_2, long_3);
	}

	internal static object smethod_85(object object_3, object object_4, int int_6, int int_7)
	{
		return object_3.TransformFinalBlock(object_4, int_6, int_7);
	}

	internal static object smethod_86(object object_3, int int_6)
	{
		return object_3.ReadBytes(int_6);
	}

	internal static void smethod_87(object object_3)
	{
		Array.Reverse(object_3);
	}

	internal static object smethod_88(object object_3)
	{
		return object_3.Hash;
	}

	internal static bool smethod_89(object object_3, object object_4, object object_5, object object_6)
	{
		return object_3.VerifyHash(object_4, object_5, object_6);
	}

	internal static void smethod_90(object object_3)
	{
		object_3.Close();
	}

	internal static object smethod_91(object object_3)
	{
		return object_3.GetName();
	}

	internal static object smethod_92(object object_3)
	{
		return object_3.Name;
	}

	internal static object smethod_93(object object_3, object object_4)
	{
		return object_3 + object_4;
	}

	internal static bool smethod_94()
	{
		return null == null;
	}

	internal static object smethod_95()
	{
		return null;
	}

	private static bool bool_0 = false;

	private static List<int> list_0 = null;

	private static byte[] byte_0 = new byte[0];

	internal static Class10.Delegate2 delegate2_0 = null;

	private static int int_0 = 0;

	[Class10.Attribute0(typeof(Class10.Attribute0.Class11<object>[]))]
	private static bool bool_1 = false;

	private static Dictionary<int, int> dictionary_0 = null;

	private static int int_1 = 0;

	private static object object_0 = new string[0];

	private static Class10.Delegate9 delegate9_0 = null;

	internal static Class10.Delegate2 delegate2_1 = null;

	private static IntPtr intptr_0 = IntPtr.Zero;

	private static bool bool_2 = false;

	private static object object_1 = new object();

	private static IntPtr intptr_1 = IntPtr.Zero;

	internal static RSACryptoServiceProvider rsacryptoServiceProvider_0 = null;

	private static byte[] byte_1 = new byte[0];

	private static uint[] uint_0 = new uint[]
	{
		3614090360U, 3905402710U, 606105819U, 3250441966U, 4118548399U, 1200080426U, 2821735955U, 4249261313U, 1770035416U, 2336552879U,
		4294925233U, 2304563134U, 1804603682U, 4254626195U, 2792965006U, 1236535329U, 4129170786U, 3225465664U, 643717713U, 3921069994U,
		3593408605U, 38016083U, 3634488961U, 3889429448U, 568446438U, 3275163606U, 4107603335U, 1163531501U, 2850285829U, 4243563512U,
		1735328473U, 2368359562U, 4294588738U, 2272392833U, 1839030562U, 4259657740U, 2763975236U, 1272893353U, 4139469664U, 3200236656U,
		681279174U, 3936430074U, 3572445317U, 76029189U, 3654602809U, 3873151461U, 530742520U, 3299628645U, 4096336452U, 1126891415U,
		2878612391U, 4237533241U, 1700485571U, 2399980690U, 4293915773U, 2240044497U, 1873313359U, 4264355552U, 2734768916U, 1309151649U,
		4149444226U, 3174756917U, 718787259U, 3951481745U
	};

	private static Class10.Delegate7 delegate7_0 = null;

	private static Class10.Delegate8 delegate8_0 = null;

	private static bool bool_3 = false;

	private static List<string> list_1 = null;

	private static object object_2 = new object();

	private static Class10.Delegate5 delegate5_0 = null;

	private static bool bool_4 = false;

	private static Class10.Delegate4 delegate4_0 = null;

	private static IntPtr xoEyXdwwaO = IntPtr.Zero;

	private static int int_2 = 1;

	private static int int_3 = 0;

	private static bool bool_5 = false;

	private static int int_4 = 0;

	private static SortedList hRcyyRqhXa = new SortedList();

	private static Class10.Delegate6 delegate6_0 = null;

	internal static Hashtable hashtable_0 = new Hashtable();

	private static IntPtr intptr_2 = IntPtr.Zero;

	private static long long_0 = 0L;

	private static int[] int_5 = new int[0];

	internal static Assembly assembly_0 = typeof(Class10).Assembly;

	private static long long_1 = 0L;

	private static bool bool_6 = false;

	private delegate void Delegate1(object o);

	internal class Attribute0 : Attribute
	{
		public Attribute0(object object_0)
		{
		}

		internal class Class11<T>
		{
			internal static bool smethod_0()
			{
				return Class10.Attribute0.Class11<T>.object_0 == null;
			}

			internal static object smethod_1()
			{
				return Class10.Attribute0.Class11<T>.object_0;
			}

			private static object object_0;
		}
	}

	internal class Class12
	{
		internal static string smethod_0(string string_0, string string_1)
		{
			byte[] bytes = Encoding.Unicode.GetBytes(string_0);
			byte[] array = new byte[]
			{
				82, 102, 104, 110, 32, 77, 24, 34, 118, 181,
				51, 17, 18, 51, 12, 109, 10, 32, 77, 24,
				34, 158, 161, 41, 97, 28, 118, 181, 5, 25,
				1, 88
			};
			byte[] array2 = Class10.smethod_9(Encoding.Unicode.GetBytes(string_1));
			MemoryStream memoryStream = new MemoryStream();
			SymmetricAlgorithm symmetricAlgorithm = Class10.smethod_7();
			symmetricAlgorithm.Key = array;
			symmetricAlgorithm.IV = array2;
			CryptoStream cryptoStream = new CryptoStream(memoryStream, symmetricAlgorithm.CreateEncryptor(), CryptoStreamMode.Write);
			cryptoStream.Write(bytes, 0, bytes.Length);
			cryptoStream.Close();
			return Convert.ToBase64String(memoryStream.ToArray());
		}

		internal static object smethod_1()
		{
			return Encoding.Unicode;
		}

		internal static object smethod_2(object object_0, object object_1)
		{
			return object_0.GetBytes(object_1);
		}

		internal static void smethod_3(object object_0, RuntimeFieldHandle runtimeFieldHandle_0)
		{
			RuntimeHelpers.InitializeArray(object_0, runtimeFieldHandle_0);
		}

		internal static object smethod_4(object object_0)
		{
			return Class10.smethod_9(object_0);
		}

		internal static void smethod_5(object object_0, object object_1)
		{
			object_0.IV = object_1;
		}

		internal static void smethod_6(object object_0, object object_1, int int_0, int int_1)
		{
			object_0.Write(object_1, int_0, int_1);
		}

		internal static object smethod_7(object object_0)
		{
			return object_0.ToArray();
		}

		internal static object smethod_8(object object_0)
		{
			return Convert.ToBase64String(object_0);
		}
	}

	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
	internal delegate uint Delegate2(IntPtr classthis, IntPtr comp, IntPtr info, [MarshalAs(UnmanagedType.U4)] uint flags, IntPtr nativeEntry, ref uint nativeSizeOfCode);

	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
	private delegate IntPtr Delegate3();

	internal struct Struct29
	{
		internal bool bool_0;

		internal byte[] byte_0;
	}

	internal class Class13
	{
		public Class13(Stream stream_0)
		{
			this.binaryReader_0 = new BinaryReader(stream_0);
		}

		internal Stream method_0()
		{
			return this.binaryReader_0.BaseStream;
		}

		internal byte[] method_1(int int_0)
		{
			return this.binaryReader_0.ReadBytes(int_0);
		}

		internal int method_2(byte[] byte_0, int int_0, int int_1)
		{
			return this.binaryReader_0.Read(byte_0, int_0, int_1);
		}

		internal int method_3()
		{
			return this.binaryReader_0.ReadInt32();
		}

		internal void method_4()
		{
			this.binaryReader_0.Close();
		}

		internal static object smethod_0(object object_0, int int_0)
		{
			return object_0.ReadBytes(int_0);
		}

		internal static int smethod_1(object object_0, object object_1, int int_0, int int_1)
		{
			return object_0.Read(object_1, int_0, int_1);
		}

		internal static int smethod_2(object object_0)
		{
			return object_0.ReadInt32();
		}

		internal static void smethod_3(object object_0)
		{
			object_0.Close();
		}

		private BinaryReader binaryReader_0;
	}

	[UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Ansi)]
	private delegate IntPtr Delegate4(IntPtr hModule, string lpName, uint lpType);

	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
	private delegate IntPtr Delegate5(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);

	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
	private delegate int Delegate6(IntPtr hProcess, IntPtr lpBaseAddress, [In] [Out] byte[] buffer, uint size, out IntPtr lpNumberOfBytesWritten);

	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
	private delegate int Delegate7(IntPtr lpAddress, int dwSize, int flNewProtect, ref int lpflOldProtect);

	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
	private delegate IntPtr Delegate8(uint dwDesiredAccess, int bInheritHandle, uint dwProcessId);

	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
	private delegate int Delegate9(IntPtr ptr);

	[Flags]
	private enum Enum0
	{

	}
}
