mirror of
https://github.com/vxunderground/MalwareSourceCode.git
synced 2024-12-25 21:05:28 +00:00
1014 lines
27 KiB
C#
1014 lines
27 KiB
C#
// Decompiled with JetBrains decompiler
|
||
// Type: .
|
||
// Assembly: MyApplication, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
|
||
// MVID: 4C1CA376-1B35-4961-80E8-8029AD6B5A8B
|
||
// Assembly location: C:\Users\Administrateur\Downloads\Virusshare-00000-msil\Trojan.Win32.Fsysna.deeq-bccdbf807edf4ae3f172c9e102415d19675fee38175dc7fe4f296402da8186a9.exe
|
||
|
||
using \u000F;
|
||
using System;
|
||
using System.IO;
|
||
using System.Runtime.CompilerServices;
|
||
using System.Runtime.InteropServices;
|
||
using System.Security.Cryptography;
|
||
|
||
namespace \u000F
|
||
{
|
||
internal sealed class \u000E
|
||
{
|
||
public static byte[] \u0081([In] byte[] obj0)
|
||
{
|
||
\u000E.\u0015 obj1 = new \u000E.\u0015(obj0);
|
||
byte[] numArray1 = new byte[0];
|
||
int num1 = obj1.\u0011();
|
||
if (num1 == 67324752)
|
||
{
|
||
short num2 = (short) obj1.\u0010();
|
||
int num3 = obj1.\u0010();
|
||
int num4 = obj1.\u0010();
|
||
if (num1 != 67324752 || num2 != (short) 20 || num3 != 0 || num4 != 8)
|
||
throw new FormatException("Wrong Header Signature");
|
||
obj1.\u0011();
|
||
obj1.\u0011();
|
||
obj1.\u0011();
|
||
int length = obj1.\u0011();
|
||
int count1 = obj1.\u0010();
|
||
int count2 = obj1.\u0010();
|
||
if (count1 > 0)
|
||
{
|
||
byte[] buffer = new byte[count1];
|
||
obj1.Read(buffer, 0, count1);
|
||
}
|
||
if (count2 > 0)
|
||
{
|
||
byte[] buffer = new byte[count2];
|
||
obj1.Read(buffer, 0, count2);
|
||
}
|
||
byte[] buffer1 = new byte[obj1.Length - obj1.Position];
|
||
obj1.Read(buffer1, 0, buffer1.Length);
|
||
\u000E.\u0007 obj2 = new \u000E.\u0007(buffer1);
|
||
numArray1 = new byte[length];
|
||
obj2.\u0010(numArray1, 0, numArray1.Length);
|
||
}
|
||
else
|
||
{
|
||
int num5 = num1 >> 24;
|
||
if (num1 - (num5 << 24) != 8223355)
|
||
throw new FormatException("Unknown Header");
|
||
if (num5 == 1)
|
||
{
|
||
int length1 = obj1.\u0011();
|
||
numArray1 = new byte[length1];
|
||
int num6;
|
||
for (int index = 0; index < length1; index += num6)
|
||
{
|
||
int length2 = obj1.\u0011();
|
||
num6 = obj1.\u0011();
|
||
byte[] buffer = new byte[length2];
|
||
obj1.Read(buffer, 0, buffer.Length);
|
||
new \u000E.\u0007(buffer).\u0010(numArray1, index, num6);
|
||
}
|
||
}
|
||
if (num5 == 2)
|
||
{
|
||
DESCryptoServiceProvider cryptoServiceProvider = new DESCryptoServiceProvider();
|
||
cryptoServiceProvider.Key = new byte[8]
|
||
{
|
||
(byte) 75,
|
||
(byte) 215,
|
||
(byte) 90,
|
||
(byte) 103,
|
||
(byte) 77,
|
||
(byte) 168,
|
||
(byte) 213,
|
||
(byte) 134
|
||
};
|
||
cryptoServiceProvider.IV = new byte[8]
|
||
{
|
||
(byte) 47,
|
||
(byte) 17,
|
||
(byte) 253,
|
||
(byte) 9,
|
||
(byte) 135,
|
||
(byte) 149,
|
||
(byte) 194,
|
||
(byte) 90
|
||
};
|
||
byte[] numArray2 = cryptoServiceProvider.CreateDecryptor().TransformFinalBlock(obj0, 4, obj0.Length - 4);
|
||
cryptoServiceProvider.Clear();
|
||
numArray1 = \u000E.\u0081(numArray2);
|
||
}
|
||
}
|
||
obj1.Close();
|
||
return numArray1;
|
||
}
|
||
|
||
internal sealed class \u0007
|
||
{
|
||
private static int[] \u0001 = new int[29]
|
||
{
|
||
3,
|
||
4,
|
||
5,
|
||
6,
|
||
7,
|
||
8,
|
||
9,
|
||
10,
|
||
11,
|
||
13,
|
||
15,
|
||
17,
|
||
19,
|
||
23,
|
||
27,
|
||
31,
|
||
35,
|
||
43,
|
||
51,
|
||
59,
|
||
67,
|
||
83,
|
||
99,
|
||
115,
|
||
131,
|
||
163,
|
||
195,
|
||
227,
|
||
258
|
||
};
|
||
private static int[] \u0002 = new int[29]
|
||
{
|
||
0,
|
||
0,
|
||
0,
|
||
0,
|
||
0,
|
||
0,
|
||
0,
|
||
0,
|
||
1,
|
||
1,
|
||
1,
|
||
1,
|
||
2,
|
||
2,
|
||
2,
|
||
2,
|
||
3,
|
||
3,
|
||
3,
|
||
3,
|
||
4,
|
||
4,
|
||
4,
|
||
4,
|
||
5,
|
||
5,
|
||
5,
|
||
5,
|
||
0
|
||
};
|
||
private static int[] \u0003 = new int[30]
|
||
{
|
||
1,
|
||
2,
|
||
3,
|
||
4,
|
||
5,
|
||
7,
|
||
9,
|
||
13,
|
||
17,
|
||
25,
|
||
33,
|
||
49,
|
||
65,
|
||
97,
|
||
129,
|
||
193,
|
||
257,
|
||
385,
|
||
513,
|
||
769,
|
||
1025,
|
||
1537,
|
||
2049,
|
||
3073,
|
||
4097,
|
||
6145,
|
||
8193,
|
||
12289,
|
||
16385,
|
||
24577
|
||
};
|
||
private static int[] \u0004 = new int[30]
|
||
{
|
||
0,
|
||
0,
|
||
0,
|
||
0,
|
||
1,
|
||
1,
|
||
2,
|
||
2,
|
||
3,
|
||
3,
|
||
4,
|
||
4,
|
||
5,
|
||
5,
|
||
6,
|
||
6,
|
||
7,
|
||
7,
|
||
8,
|
||
8,
|
||
9,
|
||
9,
|
||
10,
|
||
10,
|
||
11,
|
||
11,
|
||
12,
|
||
12,
|
||
13,
|
||
13
|
||
};
|
||
private int \u0005;
|
||
private int \u0006;
|
||
private int \u0007;
|
||
private int \u0008;
|
||
private int \u000E;
|
||
private bool \u000F;
|
||
private \u000E.\u0010 \u0010;
|
||
private \u000E.\u0011 \u0011;
|
||
private \u000E.\u0013 \u0012;
|
||
private \u000E.\u0012 \u0013;
|
||
private \u000E.\u0012 \u0014;
|
||
|
||
public \u0007([In] byte[] obj0)
|
||
{
|
||
this.\u0010 = new \u000E.\u0010();
|
||
this.\u0011 = new \u000E.\u0011();
|
||
this.\u0005 = 2;
|
||
this.\u0010.\u0010(obj0, 0, obj0.Length);
|
||
}
|
||
|
||
private bool \u0010()
|
||
{
|
||
int num1 = this.\u0011.\u0010();
|
||
while (num1 >= 258)
|
||
{
|
||
switch (this.\u0005)
|
||
{
|
||
case 7:
|
||
int num2;
|
||
while (((num2 = this.\u0013.\u0010(this.\u0010)) & -256) == 0)
|
||
{
|
||
this.\u0011.\u0010(num2);
|
||
if (--num1 < 258)
|
||
return true;
|
||
}
|
||
if (num2 < 257)
|
||
{
|
||
if (num2 < 0)
|
||
return false;
|
||
this.\u0014 = (\u000E.\u0012) null;
|
||
this.\u0013 = (\u000E.\u0012) null;
|
||
this.\u0005 = 2;
|
||
return true;
|
||
}
|
||
this.\u0007 = \u000E.\u0007.\u0001[num2 - 257];
|
||
this.\u0006 = \u000E.\u0007.\u0002[num2 - 257];
|
||
goto case 8;
|
||
case 8:
|
||
if (this.\u0006 > 0)
|
||
{
|
||
this.\u0005 = 8;
|
||
int num3 = this.\u0010.\u0010(this.\u0006);
|
||
if (num3 < 0)
|
||
return false;
|
||
this.\u0010.\u0010(this.\u0006);
|
||
this.\u0007 += num3;
|
||
}
|
||
this.\u0005 = 9;
|
||
goto case 9;
|
||
case 9:
|
||
int index = this.\u0014.\u0010(this.\u0010);
|
||
if (index < 0)
|
||
return false;
|
||
this.\u0008 = \u000E.\u0007.\u0003[index];
|
||
this.\u0006 = \u000E.\u0007.\u0004[index];
|
||
goto case 10;
|
||
case 10:
|
||
if (this.\u0006 > 0)
|
||
{
|
||
this.\u0005 = 10;
|
||
int num4 = this.\u0010.\u0010(this.\u0006);
|
||
if (num4 < 0)
|
||
return false;
|
||
this.\u0010.\u0010(this.\u0006);
|
||
this.\u0008 += num4;
|
||
}
|
||
this.\u0011.\u0010(this.\u0007, this.\u0008);
|
||
num1 -= this.\u0007;
|
||
this.\u0005 = 7;
|
||
continue;
|
||
default:
|
||
continue;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private bool \u0011()
|
||
{
|
||
switch (this.\u0005)
|
||
{
|
||
case 2:
|
||
if (this.\u000F)
|
||
{
|
||
this.\u0005 = 12;
|
||
return false;
|
||
}
|
||
int num = this.\u0010.\u0010(3);
|
||
if (num < 0)
|
||
return false;
|
||
this.\u0010.\u0010(3);
|
||
if ((num & 1) != 0)
|
||
this.\u000F = true;
|
||
switch (num >> 1)
|
||
{
|
||
case 0:
|
||
this.\u0010.\u0010();
|
||
this.\u0005 = 3;
|
||
break;
|
||
case 1:
|
||
this.\u0013 = \u000E.\u0012.\u0003;
|
||
this.\u0014 = \u000E.\u0012.\u0004;
|
||
this.\u0005 = 7;
|
||
break;
|
||
case 2:
|
||
this.\u0012 = new \u000E.\u0013();
|
||
this.\u0005 = 6;
|
||
break;
|
||
}
|
||
return true;
|
||
case 3:
|
||
if ((this.\u000E = this.\u0010.\u0010(16)) < 0)
|
||
return false;
|
||
this.\u0010.\u0010(16);
|
||
this.\u0005 = 4;
|
||
goto case 4;
|
||
case 4:
|
||
if (this.\u0010.\u0010(16) < 0)
|
||
return false;
|
||
this.\u0010.\u0010(16);
|
||
this.\u0005 = 5;
|
||
goto case 5;
|
||
case 5:
|
||
this.\u000E -= this.\u0011.\u0010(this.\u0010, this.\u000E);
|
||
if (this.\u000E != 0)
|
||
return !this.\u0010.\u0010();
|
||
this.\u0005 = 2;
|
||
return true;
|
||
case 6:
|
||
if (!this.\u0012.\u0010(this.\u0010))
|
||
return false;
|
||
this.\u0013 = this.\u0012.\u0010();
|
||
this.\u0014 = this.\u0012.\u0011();
|
||
this.\u0005 = 7;
|
||
goto case 7;
|
||
case 7:
|
||
case 8:
|
||
case 9:
|
||
case 10:
|
||
return this.\u0010();
|
||
case 12:
|
||
return false;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public int \u0010([In] byte[] obj0, [In] int obj1, [In] int obj2)
|
||
{
|
||
int num1 = 0;
|
||
do
|
||
{
|
||
if (this.\u0005 != 11)
|
||
goto label_5;
|
||
label_2:
|
||
continue;
|
||
label_5:
|
||
int num2 = this.\u0011.\u0010(obj0, obj1, obj2);
|
||
obj1 += num2;
|
||
num1 += num2;
|
||
obj2 -= num2;
|
||
if (obj2 != 0)
|
||
goto label_2;
|
||
else
|
||
goto label_1;
|
||
}
|
||
while (this.\u0011() || this.\u0011.\u0011() > 0 && this.\u0005 != 11);
|
||
goto label_3;
|
||
label_1:
|
||
return num1;
|
||
label_3:
|
||
return num1;
|
||
}
|
||
}
|
||
|
||
internal sealed class \u0010
|
||
{
|
||
private byte[] \u0001;
|
||
private int \u0002;
|
||
private int \u0003;
|
||
private uint \u0004;
|
||
private int \u0005;
|
||
|
||
public int \u0010([In] int obj0)
|
||
{
|
||
if (this.\u0005 < obj0)
|
||
goto label_4;
|
||
label_3:
|
||
return (int) ((long) this.\u0004 & (long) ((1 << obj0) - 1));
|
||
label_4:
|
||
if (this.\u0002 == this.\u0003)
|
||
return -1;
|
||
this.\u0004 |= (uint) (((int) this.\u0001[this.\u0002++] & (int) byte.MaxValue | ((int) this.\u0001[this.\u0002++] & (int) byte.MaxValue) << 8) << this.\u0005);
|
||
this.\u0005 += 16;
|
||
goto label_3;
|
||
}
|
||
|
||
public void \u0010([In] int obj0)
|
||
{
|
||
this.\u0004 >>= obj0;
|
||
this.\u0005 -= obj0;
|
||
}
|
||
|
||
[SpecialName]
|
||
public int \u0010() => this.\u0005;
|
||
|
||
[SpecialName]
|
||
public int \u0011() => this.\u0003 - this.\u0002 + (this.\u0005 >> 3);
|
||
|
||
public void \u0010()
|
||
{
|
||
this.\u0004 >>= this.\u0005 & 7;
|
||
this.\u0005 &= -8;
|
||
}
|
||
|
||
[SpecialName]
|
||
public bool \u0010() => this.\u0002 == this.\u0003;
|
||
|
||
public int \u0010([In] byte[] obj0, [In] int obj1, [In] int obj2)
|
||
{
|
||
int num1 = 0;
|
||
while (this.\u0005 > 0 && obj2 > 0)
|
||
{
|
||
obj0[obj1++] = (byte) this.\u0004;
|
||
this.\u0004 >>= 8;
|
||
this.\u0005 -= 8;
|
||
--obj2;
|
||
++num1;
|
||
}
|
||
if (obj2 == 0)
|
||
return num1;
|
||
int num2 = this.\u0003 - this.\u0002;
|
||
if (obj2 > num2)
|
||
obj2 = num2;
|
||
Array.Copy((Array) this.\u0001, this.\u0002, (Array) obj0, obj1, obj2);
|
||
this.\u0002 += obj2;
|
||
if ((this.\u0002 - this.\u0003 & 1) != 0)
|
||
{
|
||
this.\u0004 = (uint) this.\u0001[this.\u0002++] & (uint) byte.MaxValue;
|
||
this.\u0005 = 8;
|
||
}
|
||
return num1 + obj2;
|
||
}
|
||
|
||
public void \u0010([In] byte[] obj0, [In] int obj1, [In] int obj2)
|
||
{
|
||
if (this.\u0002 < this.\u0003)
|
||
throw new InvalidOperationException();
|
||
int num = obj1 + obj2;
|
||
if (0 > obj1 || obj1 > num || num > obj0.Length)
|
||
throw new ArgumentOutOfRangeException();
|
||
if ((obj2 & 1) != 0)
|
||
{
|
||
this.\u0004 |= (uint) (((int) obj0[obj1++] & (int) byte.MaxValue) << this.\u0005);
|
||
this.\u0005 += 8;
|
||
}
|
||
this.\u0001 = obj0;
|
||
this.\u0002 = obj1;
|
||
this.\u0003 = num;
|
||
}
|
||
}
|
||
|
||
internal sealed class \u0011
|
||
{
|
||
private static int \u0001 = 32768;
|
||
private static int \u0002 = \u000E.\u0011.\u0001 - 1;
|
||
private byte[] \u0003 = new byte[\u000E.\u0011.\u0001];
|
||
private int \u0004;
|
||
private int \u0005;
|
||
|
||
public void \u0010([In] int obj0)
|
||
{
|
||
\u000E.\u0011 obj = this;
|
||
int num1;
|
||
int num2 = num1 = obj.\u0005;
|
||
obj.\u0005 = num1 + 1;
|
||
if (num2 == \u000E.\u0011.\u0001)
|
||
throw new InvalidOperationException();
|
||
this.\u0003[this.\u0004++] = (byte) obj0;
|
||
this.\u0004 &= \u000E.\u0011.\u0002;
|
||
}
|
||
|
||
private void \u0010([In] int obj0, [In] int obj1, [In] int obj2)
|
||
{
|
||
while (obj1-- > 0)
|
||
{
|
||
byte[] numArray = this.\u0003;
|
||
\u000E.\u0011 obj = this;
|
||
int num1;
|
||
int num2 = num1 = obj.\u0004;
|
||
obj.\u0004 = num1 + 1;
|
||
int index = num2;
|
||
int num3 = (int) this.\u0003[obj0++];
|
||
numArray[index] = (byte) num3;
|
||
this.\u0004 &= \u000E.\u0011.\u0002;
|
||
obj0 &= \u000E.\u0011.\u0002;
|
||
}
|
||
}
|
||
|
||
public void \u0010([In] int obj0, [In] int obj1)
|
||
{
|
||
if ((this.\u0005 += obj0) > \u000E.\u0011.\u0001)
|
||
throw new InvalidOperationException();
|
||
int sourceIndex = this.\u0004 - obj1 & \u000E.\u0011.\u0002;
|
||
int num = \u000E.\u0011.\u0001 - obj0;
|
||
if (sourceIndex <= num && this.\u0004 < num)
|
||
{
|
||
if (obj0 <= obj1)
|
||
{
|
||
Array.Copy((Array) this.\u0003, sourceIndex, (Array) this.\u0003, this.\u0004, obj0);
|
||
this.\u0004 += obj0;
|
||
}
|
||
else
|
||
{
|
||
while (obj0-- > 0)
|
||
this.\u0003[this.\u0004++] = this.\u0003[sourceIndex++];
|
||
}
|
||
}
|
||
else
|
||
this.\u0010(sourceIndex, obj0, obj1);
|
||
}
|
||
|
||
public int \u0010([In] \u000E.\u0010 obj0, [In] int obj1)
|
||
{
|
||
obj1 = Math.Min(Math.Min(obj1, \u000E.\u0011.\u0001 - this.\u0005), obj0.\u0011());
|
||
int num1 = \u000E.\u0011.\u0001 - this.\u0004;
|
||
int num2;
|
||
if (obj1 > num1)
|
||
{
|
||
num2 = obj0.\u0010(this.\u0003, this.\u0004, num1);
|
||
if (num2 == num1)
|
||
num2 += obj0.\u0010(this.\u0003, 0, obj1 - num1);
|
||
}
|
||
else
|
||
num2 = obj0.\u0010(this.\u0003, this.\u0004, obj1);
|
||
this.\u0004 = this.\u0004 + num2 & \u000E.\u0011.\u0002;
|
||
this.\u0005 += num2;
|
||
return num2;
|
||
}
|
||
|
||
public int \u0010() => \u000E.\u0011.\u0001 - this.\u0005;
|
||
|
||
public int \u0011() => this.\u0005;
|
||
|
||
public int \u0010([In] byte[] obj0, [In] int obj1, [In] int obj2)
|
||
{
|
||
int num1 = this.\u0004;
|
||
if (obj2 > this.\u0005)
|
||
obj2 = this.\u0005;
|
||
else
|
||
num1 = this.\u0004 - this.\u0005 + obj2 & \u000E.\u0011.\u0002;
|
||
int num2 = obj2;
|
||
int length = obj2 - num1;
|
||
if (length > 0)
|
||
{
|
||
Array.Copy((Array) this.\u0003, \u000E.\u0011.\u0001 - length, (Array) obj0, obj1, length);
|
||
obj1 += length;
|
||
obj2 = num1;
|
||
}
|
||
Array.Copy((Array) this.\u0003, num1 - obj2, (Array) obj0, obj1, obj2);
|
||
this.\u0005 -= num2;
|
||
if (this.\u0005 < 0)
|
||
throw new InvalidOperationException();
|
||
return num2;
|
||
}
|
||
}
|
||
|
||
internal sealed class \u0012
|
||
{
|
||
private static int \u0001 = 15;
|
||
private short[] \u0002;
|
||
public static \u000E.\u0012 \u0003;
|
||
public static \u000E.\u0012 \u0004;
|
||
|
||
static \u0012()
|
||
{
|
||
byte[] numArray1 = new byte[288];
|
||
int num1 = 0;
|
||
while (num1 < 144)
|
||
numArray1[num1++] = (byte) 8;
|
||
while (num1 < 256)
|
||
numArray1[num1++] = (byte) 9;
|
||
while (num1 < 280)
|
||
numArray1[num1++] = (byte) 7;
|
||
while (num1 < 288)
|
||
numArray1[num1++] = (byte) 8;
|
||
\u000E.\u0012.\u0003 = new \u000E.\u0012(numArray1);
|
||
byte[] numArray2 = new byte[32];
|
||
int num2 = 0;
|
||
while (num2 < 32)
|
||
numArray2[num2++] = (byte) 5;
|
||
\u000E.\u0012.\u0004 = new \u000E.\u0012(numArray2);
|
||
}
|
||
|
||
public \u0012([In] byte[] obj0) => this.\u0010(obj0);
|
||
|
||
private void \u0010([In] byte[] obj0)
|
||
{
|
||
int[] numArray1 = new int[\u000E.\u0012.\u0001 + 1];
|
||
int[] numArray2 = new int[\u000E.\u0012.\u0001 + 1];
|
||
for (int index1 = 0; index1 < obj0.Length; ++index1)
|
||
{
|
||
int index2 = (int) obj0[index1];
|
||
if (index2 > 0)
|
||
++numArray1[index2];
|
||
}
|
||
int num1 = 0;
|
||
int length = 512;
|
||
for (int index = 1; index <= \u000E.\u0012.\u0001; ++index)
|
||
{
|
||
numArray2[index] = num1;
|
||
num1 += numArray1[index] << 16 - index;
|
||
if (index >= 10)
|
||
{
|
||
int num2 = numArray2[index] & 130944;
|
||
int num3 = num1 & 130944;
|
||
length += num3 - num2 >> 16 - index;
|
||
}
|
||
}
|
||
this.\u0002 = new short[length];
|
||
int num4 = 512;
|
||
for (int index3 = \u000E.\u0012.\u0001; index3 >= 10; --index3)
|
||
{
|
||
int num5 = num1 & 130944;
|
||
num1 -= numArray1[index3] << 16 - index3;
|
||
for (int index4 = num1 & 130944; index4 < num5; index4 += 128)
|
||
{
|
||
this.\u0002[(int) \u000E.\u0014.\u0010(index4)] = (short) (-num4 << 4 | index3);
|
||
num4 += 1 << index3 - 9;
|
||
}
|
||
}
|
||
for (int index5 = 0; index5 < obj0.Length; ++index5)
|
||
{
|
||
int index6 = (int) obj0[index5];
|
||
if (index6 != 0)
|
||
{
|
||
int num6 = numArray2[index6];
|
||
int index7 = (int) \u000E.\u0014.\u0010(num6);
|
||
if (index6 <= 9)
|
||
{
|
||
do
|
||
{
|
||
this.\u0002[index7] = (short) (index5 << 4 | index6);
|
||
index7 += 1 << index6;
|
||
}
|
||
while (index7 < 512);
|
||
}
|
||
else
|
||
{
|
||
int num7 = (int) this.\u0002[index7 & 511];
|
||
int num8 = 1 << (num7 & 15);
|
||
int num9 = -(num7 >> 4);
|
||
do
|
||
{
|
||
this.\u0002[num9 | index7 >> 9] = (short) (index5 << 4 | index6);
|
||
index7 += 1 << index6;
|
||
}
|
||
while (index7 < num8);
|
||
}
|
||
numArray2[index6] = num6 + (1 << 16 - index6);
|
||
}
|
||
}
|
||
}
|
||
|
||
public int \u0010([In] \u000E.\u0010 obj0)
|
||
{
|
||
int index;
|
||
if ((index = obj0.\u0010(9)) >= 0)
|
||
{
|
||
int num1;
|
||
if ((num1 = (int) this.\u0002[index]) >= 0)
|
||
{
|
||
obj0.\u0010(num1 & 15);
|
||
return num1 >> 4;
|
||
}
|
||
int num2 = -(num1 >> 4);
|
||
int num3 = num1 & 15;
|
||
int num4;
|
||
if ((num4 = obj0.\u0010(num3)) >= 0)
|
||
{
|
||
int num5 = (int) this.\u0002[num2 | num4 >> 9];
|
||
obj0.\u0010(num5 & 15);
|
||
return num5 >> 4;
|
||
}
|
||
int num6 = obj0.\u0010();
|
||
int num7 = obj0.\u0010(num6);
|
||
int num8 = (int) this.\u0002[num2 | num7 >> 9];
|
||
if ((num8 & 15) > num6)
|
||
return -1;
|
||
obj0.\u0010(num8 & 15);
|
||
return num8 >> 4;
|
||
}
|
||
int num9 = obj0.\u0010();
|
||
int num10 = (int) this.\u0002[obj0.\u0010(num9)];
|
||
if (num10 < 0 || (num10 & 15) > num9)
|
||
return -1;
|
||
obj0.\u0010(num10 & 15);
|
||
return num10 >> 4;
|
||
}
|
||
}
|
||
|
||
internal sealed class \u0013
|
||
{
|
||
private static readonly int[] \u0001 = new int[3]
|
||
{
|
||
3,
|
||
3,
|
||
11
|
||
};
|
||
private static readonly int[] \u0002 = new int[3]
|
||
{
|
||
2,
|
||
3,
|
||
7
|
||
};
|
||
private byte[] \u0003;
|
||
private byte[] \u0004;
|
||
private \u000E.\u0012 \u0005;
|
||
private int \u0006;
|
||
private int \u0007;
|
||
private int \u0008;
|
||
private int \u000E;
|
||
private int \u000F;
|
||
private int \u0010;
|
||
private byte \u0011;
|
||
private int \u0012;
|
||
private static readonly int[] \u0013 = new int[19]
|
||
{
|
||
16,
|
||
17,
|
||
18,
|
||
0,
|
||
8,
|
||
7,
|
||
9,
|
||
6,
|
||
10,
|
||
5,
|
||
11,
|
||
4,
|
||
12,
|
||
3,
|
||
13,
|
||
2,
|
||
14,
|
||
1,
|
||
15
|
||
};
|
||
|
||
public bool \u0010([In] \u000E.\u0010 obj0)
|
||
{
|
||
while (true)
|
||
{
|
||
switch (this.\u0006)
|
||
{
|
||
case 0:
|
||
this.\u0007 = obj0.\u0010(5);
|
||
if (this.\u0007 >= 0)
|
||
{
|
||
this.\u0007 += 257;
|
||
obj0.\u0010(5);
|
||
this.\u0006 = 1;
|
||
goto case 1;
|
||
}
|
||
else
|
||
goto label_2;
|
||
case 1:
|
||
this.\u0008 = obj0.\u0010(5);
|
||
if (this.\u0008 >= 0)
|
||
{
|
||
++this.\u0008;
|
||
obj0.\u0010(5);
|
||
this.\u000F = this.\u0007 + this.\u0008;
|
||
this.\u0004 = new byte[this.\u000F];
|
||
this.\u0006 = 2;
|
||
goto case 2;
|
||
}
|
||
else
|
||
goto label_5;
|
||
case 2:
|
||
this.\u000E = obj0.\u0010(4);
|
||
if (this.\u000E >= 0)
|
||
{
|
||
this.\u000E += 4;
|
||
obj0.\u0010(4);
|
||
this.\u0003 = new byte[19];
|
||
this.\u0012 = 0;
|
||
this.\u0006 = 3;
|
||
goto case 3;
|
||
}
|
||
else
|
||
goto label_8;
|
||
case 3:
|
||
for (; this.\u0012 < this.\u000E; ++this.\u0012)
|
||
{
|
||
int num = obj0.\u0010(3);
|
||
if (num < 0)
|
||
return false;
|
||
obj0.\u0010(3);
|
||
this.\u0003[\u000E.\u0013.\u0013[this.\u0012]] = (byte) num;
|
||
}
|
||
this.\u0005 = new \u000E.\u0012(this.\u0003);
|
||
this.\u0003 = (byte[]) null;
|
||
this.\u0012 = 0;
|
||
this.\u0006 = 4;
|
||
goto case 4;
|
||
case 4:
|
||
int num1;
|
||
while (((num1 = this.\u0005.\u0010(obj0)) & -16) == 0)
|
||
{
|
||
this.\u0004[this.\u0012++] = this.\u0011 = (byte) num1;
|
||
if (this.\u0012 == this.\u000F)
|
||
return true;
|
||
}
|
||
if (num1 >= 0)
|
||
{
|
||
if (num1 >= 17)
|
||
this.\u0011 = (byte) 0;
|
||
this.\u0010 = num1 - 16;
|
||
this.\u0006 = 5;
|
||
goto case 5;
|
||
}
|
||
else
|
||
goto label_19;
|
||
case 5:
|
||
int num2 = \u000E.\u0013.\u0002[this.\u0010];
|
||
int num3 = obj0.\u0010(num2);
|
||
if (num3 >= 0)
|
||
{
|
||
obj0.\u0010(num2);
|
||
int num4 = num3 + \u000E.\u0013.\u0001[this.\u0010];
|
||
while (num4-- > 0)
|
||
this.\u0004[this.\u0012++] = this.\u0011;
|
||
if (this.\u0012 != this.\u000F)
|
||
{
|
||
this.\u0006 = 4;
|
||
continue;
|
||
}
|
||
goto label_29;
|
||
}
|
||
else
|
||
goto label_24;
|
||
default:
|
||
continue;
|
||
}
|
||
}
|
||
label_2:
|
||
return false;
|
||
label_5:
|
||
return false;
|
||
label_8:
|
||
return false;
|
||
label_19:
|
||
return false;
|
||
label_24:
|
||
return false;
|
||
label_29:
|
||
return true;
|
||
}
|
||
|
||
public \u000E.\u0012 \u0010()
|
||
{
|
||
byte[] destinationArray = new byte[this.\u0007];
|
||
Array.Copy((Array) this.\u0004, 0, (Array) destinationArray, 0, this.\u0007);
|
||
return new \u000E.\u0012(destinationArray);
|
||
}
|
||
|
||
public \u000E.\u0012 \u0011()
|
||
{
|
||
byte[] destinationArray = new byte[this.\u0008];
|
||
Array.Copy((Array) this.\u0004, this.\u0007, (Array) destinationArray, 0, this.\u0008);
|
||
return new \u000E.\u0012(destinationArray);
|
||
}
|
||
}
|
||
|
||
internal sealed class \u0014
|
||
{
|
||
private static int \u0001 = 16384;
|
||
private static int \u0002 = 286;
|
||
private static int \u0003 = 30;
|
||
private static int \u0004 = 19;
|
||
private static int \u0005 = 16;
|
||
private static int \u0006 = 17;
|
||
private static int \u0007 = 18;
|
||
private static int \u0008 = 256;
|
||
private static int[] \u000E = new int[19]
|
||
{
|
||
16,
|
||
17,
|
||
18,
|
||
0,
|
||
8,
|
||
7,
|
||
9,
|
||
6,
|
||
10,
|
||
5,
|
||
11,
|
||
4,
|
||
12,
|
||
3,
|
||
13,
|
||
2,
|
||
14,
|
||
1,
|
||
15
|
||
};
|
||
private static byte[] \u000F = new byte[16]
|
||
{
|
||
(byte) 0,
|
||
(byte) 8,
|
||
(byte) 4,
|
||
(byte) 12,
|
||
(byte) 2,
|
||
(byte) 10,
|
||
(byte) 6,
|
||
(byte) 14,
|
||
(byte) 1,
|
||
(byte) 9,
|
||
(byte) 5,
|
||
(byte) 13,
|
||
(byte) 3,
|
||
(byte) 11,
|
||
(byte) 7,
|
||
(byte) 15
|
||
};
|
||
private static short[] \u0010 = new short[\u000E.\u0014.\u0002];
|
||
private static byte[] \u0011 = new byte[\u000E.\u0014.\u0002];
|
||
private static short[] \u0012;
|
||
private static byte[] \u0013;
|
||
|
||
public static short \u0010([In] int obj0) => (short) ((int) \u000E.\u0014.\u000F[obj0 & 15] << 12 | (int) \u000E.\u0014.\u000F[obj0 >> 4 & 15] << 8 | (int) \u000E.\u0014.\u000F[obj0 >> 8 & 15] << 4 | (int) \u000E.\u0014.\u000F[obj0 >> 12]);
|
||
|
||
static \u0014()
|
||
{
|
||
int index1;
|
||
for (index1 = 0; index1 < 144; \u000E.\u0014.\u0011[index1++] = (byte) 8)
|
||
\u000E.\u0014.\u0010[index1] = \u000E.\u0014.\u0010(48 + index1 << 8);
|
||
for (; index1 < 256; \u000E.\u0014.\u0011[index1++] = (byte) 9)
|
||
\u000E.\u0014.\u0010[index1] = \u000E.\u0014.\u0010(256 + index1 << 7);
|
||
for (; index1 < 280; \u000E.\u0014.\u0011[index1++] = (byte) 7)
|
||
\u000E.\u0014.\u0010[index1] = \u000E.\u0014.\u0010(index1 - 256 << 9);
|
||
for (; index1 < \u000E.\u0014.\u0002; \u000E.\u0014.\u0011[index1++] = (byte) 8)
|
||
\u000E.\u0014.\u0010[index1] = \u000E.\u0014.\u0010(index1 - 88 << 8);
|
||
\u000E.\u0014.\u0012 = new short[\u000E.\u0014.\u0003];
|
||
\u000E.\u0014.\u0013 = new byte[\u000E.\u0014.\u0003];
|
||
for (int index2 = 0; index2 < \u000E.\u0014.\u0003; ++index2)
|
||
{
|
||
\u000E.\u0014.\u0012[index2] = \u000E.\u0014.\u0010(index2 << 11);
|
||
\u000E.\u0014.\u0013[index2] = (byte) 5;
|
||
}
|
||
}
|
||
}
|
||
|
||
internal sealed class \u0015 : MemoryStream
|
||
{
|
||
public int \u0010() => this.ReadByte() | this.ReadByte() << 8;
|
||
|
||
public int \u0011() => this.\u0010() | this.\u0010() << 16;
|
||
|
||
public \u0015([In] byte[] obj0)
|
||
: base(obj0, false)
|
||
{
|
||
}
|
||
}
|
||
}
|
||
}
|