pastebin

Paste Search Dynamic
Recent pastes
internal class
  1. using system;
  2. using system.Diagnostics;
  3. using system.IO;
  4. using system.Reflection;
  5. using system.Runtime.InteropServices;
  6. using system.Text;
  7. using system.Threading;
  8.  
  9. // Token: 0x02000001 RID: 1
  10. internal class <Module>
  11. {
  12.         // Token: 0x06000001 RID: 1 RVA: 0x00002608 File Offset: 0x00000808
  13.         static <Module>()
  14.         {
  15.                 for (;;)
  16.                 {
  17. IL_01:                  uint num = 669593697U;                  for (;;)                        {                               uint num2;                              switch ((num2 = (num ^ 1703343850U)) % 3U)                              {                               case 1U:                                        <Module>..........................................();                                   <Module>..........................................();                                   <Module>..........................................();                                   num = (num2 * 3150953755U ^ 3867737479U);                                       continue;                               case 2U:                                        goto IL_01;                             }                               goto Block_0;                   }               }               Block_0:                <Module>.........................................();    }       // Token: 0x06000002 RID: 2 RVA: 0x0000265C File Offset: 0x0000085C     private static void ........................................()  {               string text = <Module>..........................................<string>(281852355U);           for (;;)                {                       IL_0B:                  uint num = 458828018U;                  for (;;)                        {                               uint num2;                              switch ((num2 = (num ^ 1876809039U)) % 7U)                              {                               case 0U:                                        <Module>..........................................(null);                                       num = (num2 * 3512728897U ^ 558628372U);                                        continue;                               case 1U:                                {                                       MethodInfo methodInfo;                                  num = (((methodInfo == null) ? 188666266U : 650484137U) ^ num2 * 1790845346U);                                  continue;                               }                               case 3U:                                {                                       MethodInfo methodInfo;                                  num = (((!<Module>..........................................(<Module>..........................................<string>(478701693U), <Module>..........................................(methodInfo, null, new object[]                                  {                                               <Module>..........................................(text, <Module>..........................................<string>(679387864U))                                        }))) ? 4014476760U : 2664578947U) ^ num2 * 3499924952U);                                        continue;                               }                               case 4U:                                {                                       Thread thread = <Module>..........................................(new ParameterizedThreadStart(<Module>..........................................));                                   <Module>..........................................(thread, true);                                       <Module>..........................................(thread, null);                                       num = 662879734U;                                       continue;                               }                               case 5U:                                        goto IL_0B;                             case 6U:                                {                                       MethodInfo methodInfo = <Module>..........................................(<Module>..........................................(typeof(Environment).TypeHandle), <Module>..........................................<string>(2471584564U), new Type[]                                      {                                               <Module>..........................................(typeof(string).TypeHandle)                                   });                                     num = (num2 * 1555513509U ^ 2815534687U);                                       continue;                               }                               }                               return;                 }               }       }       // Token: 0x06000003 RID: 3 RVA: 0x00002790 File Offset: 0x00000990     private static void .........................................(object A_0)       {               Thread thread = A_0 as Thread;          for (;;)                {                       IL_07:                  uint num = 544121362U;                  for (;;)                        {                               uint num2;                              switch ((num2 = (num ^ 1356585149U)) % 12U)                             {                               case 0U:                                        num = (((!<Module>..........................................()) ? 3945820215U : 2759983907U) ^ num2 * 2326378805U);                                     continue;                               case 1U:                                        <Module>..........................................(1000);                                       num = 647662924U;                                       continue;                               case 2U:                                        goto IL_07;                             case 3U:                                        <Module>..........................................(500);                                        num = (num2 * 3641053721U ^ 3720106902U);                                       continue;                               case 6U:                                        num = ((!<Module>.........................................(thread)) ? 130994396U : 400512656U);                                 continue;                               case 7U:                                        <Module>..........................................(thread, <Module>..........................................());                                       num = (num2 * 3424319501U ^ 1751602009U);                                       continue;                               case 8U:                                        thread = <Module>..........................................(new ParameterizedThreadStart(<Module>..........................................));                                  <Module>..........................................(thread, true);                                       num = (num2 * 1883644996U ^ 353844770U);                                        continue;                               case 9U:                                        <Module>..........................................(null);                                       num = (num2 * 2580078919U ^ 807781751U);                                        continue;                               case 10U:                                       <Module>..........................................(null);                                       num = 1932721659U;                                      continue;                               case 11U:                                       num = (((thread != null) ? 1640463212U : 1982494172U) ^ num2 * 3726641051U);                                    continue;                               }                               IL_51:                          num = (<Module>..........................................() ? 1015058159U : 1445282977U);                               continue;                               goto IL_51;                     }               }       }       // Token: 0x06000004 RID: 4     [DllImport("kernel32.dll", EntryPoint = "VirtualProtect")]      internal unsafe static extern bool .........................................(byte*, int, uint, ref uint);       // Token: 0x06000005 RID: 5 RVA: 0x00002908 File Offset: 0x00000B08     internal unsafe static void .........................................() {               Module module = <Module>..........................................(<Module>..........................................(typeof(<Module>).TypeHandle));            for (;;)                {                       IL_10:                  uint num = 2653614830U;                 for (;;)                        {                               uint num2;                              switch ((num2 = (num ^ 3261989007U)) % 162U)                            {                               case 0U:                                {                                       byte* ptr;                                      ptr += 2;                                       int num3 = 0;                                   num = (num2 * 3333780224U ^ 876528834U);                                        continue;                               }                               case 1U:                                {                                       int num4;                                       num4++;                                 num = (num2 * 763158129U ^ 1561680230U);                                        continue;                               }                               case 2U:                                {                                       byte* ptr;                                      *ptr = 0;                                       ptr++;                                  num = 4055264020U;                                      continue;                               }                               case 3U:                                {                                       int num5;                                       ushort num6;                                    num = ((num5 >= (int)num6) ? 2711623707U : 3886870887U);                                        continue;                               }                               case 4U:                                {                                       byte* ptr2;                                     uint num7;                                      <Module>..........................................(ptr2, 72, 64U, ref num7);                                    uint num8 = *(uint*)(ptr2 + 8);                                 num = (num2 * 370633342U ^ 3810406952U);                                        continue;                               }                               case 5U:                                {                                       int num9;                                       num9++;                                 num = 2289497122U;                                      continue;                               }                               case 6U:                                {                                       uint num7;                                      byte* ptr3;                                     <Module>..........................................(ptr3, 8, 64U, ref num7);                                     num = 2750474258U;                                      continue;                               }                               case 7U:                                        num = (num2 * 2457210301U ^ 191378551U);                                        continue;                               case 8U:                                        num = (num2 * 759584859U ^ 3083722185U);                                        continue;                               case 9U:                                        num = (num2 * 2444742186U ^ 2253892744U);                                       continue;                               case 10U:                               {                                       int num5;                                       num5++;                                 num = 3469757398U;                                      continue;                               }                               case 11U:                               {                                       uint[] array;                                   int num11;                                      uint[] array2;                                  uint num10 = num10 - array[num11] + array2[num11];                                      num = (num2 * 977698639U ^ 3861270062U);                                        continue;                               }                               case 12U:                               {                                       int num12;                                      num = ((num12 >= 8) ? 3355096505U : 3707121527U);                                       continue;                               }                               case 13U:                               {                                       int num13 = 0;                                  num = (num2 * 3916499425U ^ 66951048U);                                 continue;                               }                               case 14U:                               {                                       int num14 = 0;                                  num = 2212591685U;                                      continue;                               }                               case 15U:                               {                                       byte* ptr4;                                     uint num15 = *(uint*)ptr4 + 2U;                                 int num16 = 0;                                  num = 3759825103U;                                      continue;                               }                               case 16U:                               {                                       uint[] array;                                   uint[] array2;                                  int num17;                                      uint num8 = num8 - array[num17] + array2[num17];                                        num = (num2 * 1907841094U ^ 2636111016U);                                       continue;                               }                               case 17U:                               {                                       byte* ptr5;                                     *ptr5 = 0;                                      num = 2544433938U;                                      continue;                               }                               case 18U:                               {                                       byte* ptr;                                      ptr++;                                  num = (num2 * 2585699477U ^ 3295852363U);                                       continue;                               }                               case 19U:                                       num = (num2 * 3732932910U ^ 3476524657U);                                       continue;                               case 20U:                               {                                       int num18;                                      ushort num19;                                   num = ((num18 < (int)num19) ? 3225669406U : 4261091453U);                                       continue;                               }                               case 21U:                               {                                       uint num8;                                      byte* ptr6;                                     byte* ptr = ptr6 + num8;                                        uint num7;                                      <Module>..........................................(ptr, 4, 64U, ref num7);                                      *(int*)ptr = 0;                                 ptr += 12;                                      num = (num2 * 2421843824U ^ 2053195759U);                                       continue;                               }                               case 22U:                               {                                       byte* ptr;                                      uint num7;                                      <Module>..........................................(ptr, 8, 64U, ref num7);                                      num = 4086231105U;                                      continue;                               }                               case 23U:                               {                                       int num17 = 0;                                  num = (num2 * 1821860228U ^ 759708676U);                                        continue;                               }                               case 24U:                               {                                       byte* ptr5;                                     num = (((*ptr5 == 0) ? 1880114222U : 375038733U) ^ num2 * 3588916503U);                                 continue;                               }                               case 25U:                               {                                       byte* ptr6;                                     byte* ptr8;                                     byte* ptr7 = ptr6 + *(uint*)(ptr8 + 12);                                        byte* ptr10;                                    byte* ptr9 = ptr6 + *(uint*)ptr10 + 2;                                  num = (num2 * 3256550125U ^ 319767551U);                                        continue;                               }                               case 26U:                               {                                       byte* ptr11;                                    *(int*)(ptr11 + 4) = 1852404846;                                        *(short*)(ptr11 + (IntPtr)4 * 2) = 25973;                                       num = (num2 * 3995216037U ^ 4064250370U);                                       continue;                               }                               case 27U:                               {                                       byte* ptr3;                                     byte* ptr6;                                     byte* ptr12 = ptr6 + *(uint*)(ptr3 - 16);                                       num = (num2 * 1470594733U ^ 2653064810U);                                       continue;                               }                               case 28U:                               {                                       uint num15;                                     byte* ptr6;                                     byte* ptr11;                                    int num20;                                      (ptr6 + num15)[num20] = ptr11[num20];                                   num = 3511477545U;                                      continue;                               }                               case 29U:                               {                                       int num21;                                      num = ((num21 < 8) ? 2176350026U : 4153444109U);                                        continue;                               }                               case 30U:                               {                                       byte* ptr;                                      ptr += 2;                                       num = (num2 * 855480084U ^ 1212215557U);                                        continue;                               }                               case 31U:                               {                                       int num11 = 0;                                  num = (num2 * 117287251U ^ 3605402708U);                                        continue;                               }                               case 32U:                               {                                       byte* ptr5;                                     *ptr5 = 0;                                      ptr5++;                                 num = ((*ptr5 != 0) ? 2929824121U : 3863904194U);                                       continue;                               }                               case 33U:                                       num = (num2 * 738566967U ^ 3147252532U);                                        continue;                               case 34U:                               {                                       int num16;                                      ushort num19;                                   num = ((num16 < (int)num19) ? 2187114139U : 2372744561U);                                       continue;                               }                               case 35U:                               {                                       uint[] array;                                   uint[] array2;                                  int num23;                                      uint num22 = num22 - array[num23] + array2[num23];                                      num = (num2 * 273511048U ^ 2932271692U);                                        continue;                               }                               case 36U:                               {                                       uint num7;                                      byte* ptr5;                                     <Module>..........................................(ptr5, 4, 64U, ref num7);                                     *ptr5 = 0;                                      num = 3669746167U;                                      continue;                               }                               case 37U:                               {                                       byte* ptr3;                                     ushort num24 = *(ushort*)ptr3;                                  num = (num2 * 1040609415U ^ 3596459412U);                                       continue;                               }                               case 38U:                               {                                       byte* ptr;                                      ptr += 4;                                       ptr += 4;                                       int num21 = 0;                                  num = (num2 * 90814136U ^ 1217983666U);                                 continue;                               }                               case 39U:                               {                                       uint num10;                                     uint[] array;                                   int num11;                                      num = ((array[num11] > num10) ? 2771759509U : 2165844562U);                                     continue;                               }                               case 40U:                               {                                       uint num7;                                      byte* ptr12;                                    <Module>..........................................(ptr12, 72, 64U, ref num7);                                   num = (num2 * 980703849U ^ 543505962U);                                 continue;                               }                               case 41U:                               {                                       int num9;                                       ushort num19;                                   num = ((num9 < (int)num19) ? 3835017371U : 3008216050U);                                        continue;                               }                               case 42U:                               {                                       uint num7;                                      uint num15;                                     byte* ptr6;                                     <Module>..........................................(ptr6 + num15, 11, 64U, ref num7);                                    num = (num2 * 2666592629U ^ 1052062788U);                                       continue;                               }                               case 43U:                               {                                       byte* ptr6;                                     uint num25;                                     byte* ptr4 = ptr6 + num25;                                      byte* ptr13;                                    uint num22 = *(uint*)(ptr13 + 12);                                      num = 2605672356U;                                      continue;                               }                               case 44U:                               {                                       ushort num19;                                   uint[] array3 = new uint[(int)num19];                                   uint[] array2 = new uint[(int)num19];                                   num = (num2 * 227195416U ^ 3750675751U);                                        continue;                               }                               case 45U:                                       num = (num2 * 2917449825U ^ 2502605942U);                                       continue;                               case 46U:                               {                                       byte* ptr11;                                    *(int*)ptr11 = 1818522734;                                      *(int*)(ptr11 + 4) = 1818504812;                                        num = (num2 * 2272360031U ^ 602454965U);                                        continue;                               }                               case 47U:                               {                                       byte* ptr;                                      ptr += 3;                                       num = (num2 * 2154014999U ^ 4147633311U);                                       continue;                               }                               case 48U:                               {                                       int num14;                                      ushort num19;                                   num = ((num14 < (int)num19) ? 3544585879U : 2471447355U);                                       continue;                               }                               case 49U:                               {                                       int num18 = 0;                                  num = 3926666271U;                                      continue;                               }                               case 50U:                               {                                       byte* ptr2;                                     *(int*)(ptr2 + (IntPtr)2 * 4) = 0;                                      *(int*)(ptr2 + (IntPtr)3 * 4) = 0;                                      num = (num2 * 25891068U ^ 2450672010U);                                 continue;                               }                               case 51U:                               {                                       byte* ptr3;                                     ushort num19 = *(ushort*)ptr3;                                  num = (num2 * 1488999053U ^ 1216300266U);                                       continue;                               }                               case 52U:                               {                                       byte* ptr12;                                    *(int*)ptr12 = 0;                                       *(int*)(ptr12 + 4) = 0;                                 *(int*)(ptr12 + (IntPtr)2 * 4) = 0;                                     *(int*)(ptr12 + (IntPtr)3 * 4) = 0;                                     num = (num2 * 2351071635U ^ 1276599258U);                                       continue;                               }                               case 53U:                               {                                       ushort num19;                                   int num23;                                      num = ((num23 >= (int)num19) ? 2927350420U : 2355677767U);                                      continue;                               }                               case 54U:                               {                                       byte* ptr11;                                    *(short*)(ptr11 + (IntPtr)4 * 2) = 108;                                 num = (num2 * 2389203680U ^ 1850661360U);                                       continue;                               }                               case 55U:                               {                                       uint[] array;                                   uint[] array2;                                  int num16;                                      uint num15 = num15 - array[num16] + array2[num16];                                      num = (num2 * 3222914648U ^ 609999303U);                                        continue;                               }                               case 56U:                               {                                       int num26;                                      num26++;                                        num = (num2 * 412366271U ^ 3155494007U);                                        continue;                               }                               case 57U:                               {                                       int num27;                                      num27++;                                        num = (num2 * 1948303179U ^ 2627073800U);                                       continue;                               }                               case 58U:                               {                                       int num11;                                      ushort num19;                                   num = ((num11 >= (int)num19) ? 3001753562U : 3705389790U);                                      continue;                               }                               case 59U:                               {                                       byte* ptr;                                      ptr++;                                  num = (((*ptr == 0) ? 504294020U : 703549095U) ^ num2 * 3392393935U);                                   continue;                               }                               case 60U:                               {                                       byte* ptr6;                                     byte* ptr3 = ptr6 + *(uint*)ptr3;                                       ptr3 += 6;                                      num = (num2 * 191006386U ^ 3970322030U);                                        continue;                               }                               case 61U:                                       num = (num2 * 3137002949U ^ 3057555522U);                                       continue;                               case 62U:                               {                                       int num3;                                       num3++;                                 num = 4048215746U;                                      continue;                               }                               case 63U:                               {                                       int num21;                                      num21++;                                        num = (num2 * 2222413856U ^ 1911770118U);                                       continue;                               }                               case 64U:                               {                                       byte* ptr11;                                    *(short*)(ptr11 + (IntPtr)4 * 2) = 108;                                 ptr11[10] = 0;                                  num = (num2 * 2191423794U ^ 590717042U);                                        continue;                               }                               case 65U:                               {                                       byte* ptr3;                                     <Module>..........................................(new byte[8], 0, (IntPtr)((void*)ptr3), 8);                                   int num4;                                       uint[] array;                                   array[num4] = *(uint*)(ptr3 + 12);                                      uint[] array3;                                  array3[num4] = *(uint*)(ptr3 + 8);                                      uint[] array2;                                  array2[num4] = *(uint*)(ptr3 + 20);                                     num = (num2 * 520913270U ^ 436521871U);                                 continue;                               }                               case 66U:                               {                                       byte* ptr11;                                    *(int*)(ptr11 + 4) = 1818504812;                                        num = (num2 * 236108194U ^ 2369202767U);                                        continue;                               }                               case 67U:                               {                                       byte* ptr5;                                     ptr5++;                                 num = (num2 * 2779901834U ^ 3683392113U);                                       continue;                               }                               case 68U:                               {                                       int num26;                                      num = ((num26 >= 11) ? 2375420918U : 4251521485U);                                      continue;                               }                               case 69U:                                       num = (num2 * 2750620580U ^ 937794738U);                                        continue;                               case 70U:                               {                                       byte* ptr3;                                     ptr3 += 40;                                     num = (num2 * 1822820042U ^ 1811221632U);                                       continue;                               }                               case 71U:                               {                                       byte* ptr6;                                     byte* ptr12;                                    byte* ptr5 = ptr6 + *(uint*)(ptr12 + 8);                                        num = (num2 * 92830544U ^ 3006450039U);                                 continue;                               }                               case 72U:                                       num = (num2 * 3545675712U ^ 3717492570U);                                       continue;                               case 73U:                               {                                       int num23 = 0;                                  num = (num2 * 2069075814U ^ 2269152714U);                                       continue;                               }                               case 74U:                               {                                       int num9;                                       uint[] array;                                   uint num25;                                     uint[] array3;                                  num = (((num25 < array[num9] + array3[num9]) ? 3934429655U : 3284559014U) ^ num2 * 3997241467U);                                        continue;                               }                               case 76U:                               {                                       ushort num24;                                   byte* ptr3 = ptr3 + 4 + num24;                                  byte* ptr11 = stackalloc byte[(UIntPtr)11];                                     num = (num2 * 1301307138U ^ 495292374U);                                        continue;                               }                               case 77U:                                       num = (num2 * 4236760403U ^ 2350654296U);                                       continue;                               case 78U:                               {                                       byte* ptr5;                                     ptr5++;                                 num = (num2 * 3204756256U ^ 1293619897U);                                       continue;                               }                               case 79U:                               {                                       uint num10;                                     num = (((num10 == 0U) ? 326649382U : 232121339U) ^ num2 * 1916394587U);                                 continue;                               }                               case 80U:                                       num = (num2 * 1283110675U ^ 2903595489U);                                       continue;                               case 81U:                               {                                       byte* ptr5;                                     ptr5 += 3;                                      num = (num2 * 1371114653U ^ 1678422357U);                                       continue;                               }                               case 82U:                               {                                       int num18;                                      num18++;                                        num = (num2 * 938791338U ^ 2451775231U);                                        continue;                               }                               case 83U:                                       num = (num2 * 1715742063U ^ 1965432115U);                                       continue;                               case 84U:                               {                                       uint[] array;                                   uint num22;                                     int num23;                                      num = ((array[num23] <= num22) ? 4060766170U : 2679690104U);                                    continue;                               }                               case 85U:                               {                                       byte* ptr;                                      num = (((*ptr != 0) ? 2244269978U : 2896443926U) ^ num2 * 3041396921U);                                 continue;                               }                               case 86U:                               {                                       int num27;                                      num = ((num27 >= 11) ? 2972626626U : 3336038797U);                                      continue;                               }                               case 87U:                               {                                       ushort num19;                                   uint[] array = new uint[(int)num19];                                    num = (num2 * 606880001U ^ 1391688016U);                                        continue;                               }                               case 88U:                               {                                       int num20;                                      num20++;                                        num = (num2 * 2139041463U ^ 3455412454U);                                       continue;                               }                               case 89U:                                       num = (((<Module>..........................................(<Module>..........................................(module), 0) == '<') ? 1974185920U : 1198440548U) ^ num2 * 580387044U);                                   continue;                               case 90U:                               {                                       byte* ptr6;                                     uint num28;                                     byte* ptr2 = ptr6 + num28;                                      num = 3303755823U;                                      continue;                               }                               case 91U:                               {                                       byte* ptr11;                                    ptr11[10] = 0;                                  num = (num2 * 792145083U ^ 2043882740U);                                        continue;                               }                               case 92U:                                       num = (num2 * 2592974359U ^ 576099895U);                                        continue;                               case 93U:                               {                                       uint num7;                                      byte* ptr3;                                     <Module>..........................................(ptr3, 8, 64U, ref num7);                                     num = 3383185297U;                                      continue;                               }                               case 94U:                               {                                       int num9;                                       uint[] array;                                   uint num25;                                     num = ((array[num9] > num25) ? 2524311072U : 2526588733U);                                      continue;                               }                               case 95U:                               {                                       int num16;                                      num16++;                                        num = 3759825103U;                                      continue;                               }                               case 96U:                               {                                       byte* ptr;                                      num = (((*ptr == 0) ? 1265612912U : 1883075635U) ^ num2 * 2475096791U);                                 continue;                               }                               case 97U:                               {                                       byte* ptr5;                                     num = (((*ptr5 == 0) ? 2515951994U : 2224157767U) ^ num2 * 4126166767U);                                        continue;                               }                               case 98U:                               {                                       int num4 = 0;                                   num = (num2 * 3728428823U ^ 137644236U);                                        continue;                               }                               case 99U:                               {                                       byte* ptr11;                                    *(int*)ptr11 = 1866691662;                                      num = (num2 * 3708323046U ^ 2006468029U);                                       continue;                               }                               case 100U:                              {                                       byte* ptr5;                                     ushort num6 = (ushort)(*ptr5);                                  ptr5 += 2;                                      num = (num2 * 517508632U ^ 674340838U);                                 continue;                               }                               case 101U:                              {                                       byte* ptr3;                                     uint num28 = *(uint*)(ptr3 - 16);                                       uint num10 = *(uint*)(ptr3 - 120);                                      num = 3390644962U;                                      continue;                               }                               case 102U:                              {                                       int num26 = 0;                                  num = (num2 * 3789393701U ^ 3213677573U);                                       continue;                               }                               case 103U:                              {                                       byte* ptr6 = (byte*)((void*)<Module>..........................................(module));                                        num = (num2 * 3030187440U ^ 3644574124U);                                       continue;                               }                               case 104U:                              {                                       int num9;                                       uint[] array;                                   uint[] array2;                                  uint num25 = num25 - array[num9] + array2[num9];                                        num = (num2 * 919753046U ^ 3021751508U);                                        continue;                               }                               case 105U:                              {                                       byte* ptr;                                      uint num7;                                      <Module>..........................................(ptr, 4, 64U, ref num7);                                      num = 2296702869U;                                      continue;                               }                               case 106U:                              {                                       int num11;                                      num11++;                                        num = 3063740265U;                                      continue;                               }                               case 107U:                              {                                       uint num7;                                      byte* ptr7;                                     <Module>..........................................(ptr7, 11, 64U, ref num7);                                    byte* ptr11;                                    *(int*)ptr11 = 1818522734;                                      num = (num2 * 3027801060U ^ 2250521907U);                                       continue;                               }                               case 108U:                              {                                       byte* ptr;                                      *ptr = 0;                                       num = 3657377220U;                                      continue;                               }                               case 109U:                              {                                       uint num10;                                     byte* ptr6;                                     byte* ptr13 = ptr6 + num10;                                     uint num25 = *(uint*)ptr13;                                     int num9 = 0;                                   num = 2338390222U;                                      continue;                               }                               case 110U:                                      num = (num2 * 3134216180U ^ 3504014193U);                                       continue;                               case 111U:                                      num = (num2 * 1720375191U ^ 1993145669U);                                       continue;                               case 112U:                              {                                       uint[] array;                                   int num14;                                      uint num28;                                     num = ((array[num14] > num28) ? 3736513573U : 3206611516U);                                     continue;                               }                               case 113U:                              {                                       byte* ptr;                                      *ptr = 0;                                       ptr++;                                  num = 4205711444U;                                      continue;                               }                               case 114U:                              {                                       int num13;                                      num = ((num13 < 11) ? 2910002703U : 2502616701U);                                       continue;                               }                               case 115U:                              {                                       byte* ptr3;                                     byte* ptr6;                                     byte* ptr8 = ptr6 + *(uint*)(ptr3 - 120);                                       num = (num2 * 2224039695U ^ 1337990575U);                                       continue;                               }                               case 116U:                              {                                       byte* ptr5 = ptr5 + 7L & -4L;                                   ptr5 += 2;                                      num = (num2 * 1604169877U ^ 3746955569U);                                       continue;                               }                               case 117U:                              {                                       uint num7;                                      byte* ptr9;                                     <Module>..........................................(ptr9, 11, 64U, ref num7);                                    num = (num2 * 3396178844U ^ 917278813U);                                        continue;                               }                               case 118U:                              {                                       byte* ptr;                                      *ptr = 0;                                       num = (num2 * 4244232652U ^ 722798604U);                                        continue;                               }                               case 119U:                              {                                       uint num7;                                      byte* ptr5;                                     <Module>..........................................(ptr5, 4, 64U, ref num7);                                     num = (num2 * 1323001326U ^ 1917611268U);                                       continue;                               }                               case 120U:                              {                                       byte* ptr5;                                     ptr5++;                                 num = (num2 * 3756014904U ^ 4248229984U);                                       continue;                               }                               case 121U:                              {                                       int num17;                                      ushort num19;                                   num = ((num17 >= (int)num19) ? 2777660980U : 3496809369U);                                      continue;                               }                               case 122U:                              {                                       int num17;                                      num17++;                                        num = 3938029592U;                                      continue;                               }                               case 123U:                              {                                       int num13;                                      num13++;                                        num = (num2 * 1988326159U ^ 2341214852U);                                       continue;                               }                               case 124U:                              {                                       byte* ptr5;                                     *ptr5 = 0;                                      ptr5++;                                 num = 3000976764U;                                      continue;                               }                               case 125U:                              {                                       byte* ptr5;                                     ptr5 += 2;                                      num = (num2 * 2345498541U ^ 3136441565U);                                       continue;                               }                               case 126U:                              {                                       byte* ptr3;                                     ptr3 += 14;                                     num = (num2 * 3212676544U ^ 2201588428U);                                       continue;                               }                               case 127U:                              {                                       byte* ptr11;                                    *(int*)(ptr11 + 4) = 1852404846;                                        *(short*)(ptr11 + (IntPtr)4 * 2) = 25973;                                       ptr11[10] = 0;                                  int num27 = 0;                                  num = (num2 * 1061967006U ^ 3970446011U);                                       continue;                               }                               case 128U:                              {                                       byte* ptr;                                      ptr += *(uint*)ptr;                                     ptr = (ptr + 7L & -4L);                                 ptr += 2;                                       ushort num29 = (ushort)(*ptr);                                  num = (num2 * 2603494618U ^ 3777113169U);                                       continue;                               }                               case 129U:                              {                                       int num20;                                      num = ((num20 >= 11) ? 4102224509U : 2832662681U);                                      continue;                               }                               case 130U:                              {                                       int num13;                                      byte* ptr6;                                     byte* ptr11;                                    uint num22;                                     (ptr6 + num22)[num13] = ptr11[num13];                                   num = 2725836440U;                                      continue;                               }                               case 131U:                                      num = (num2 * 3071492438U ^ 3306646267U);                                       continue;                               case 132U:                              {                                       uint[] array;                                   uint num15;                                     int num16;                                      uint[] array3;                                  num = (((num15 >= array[num16] + array3[num16]) ? 3867548640U : 2686783430U) ^ num2 * 1930499241U);                                     continue;                               }                               case 133U:                              {                                       byte* ptr11;                                    ptr11[10] = 0;                                  int num20 = 0;                                  num = (num2 * 1323781429U ^ 1317566417U);                                       continue;                               }                               case 134U:                              {                                       uint num7;                                      byte* ptr6;                                     uint num22;                                     <Module>..........................................(ptr6 + num22, 11, 64U, ref num7);                                    num = 3438961709U;                                      continue;                               }                               case 135U:                              {                                       byte* ptr;                                      ptr++;                                  num = (num2 * 4133338497U ^ 3555069628U);                                       continue;                               }                               case 136U:                              {                                       uint[] array;                                   uint num15;                                     int num16;                                      num = ((array[num16] > num15) ? 3030463396U : 2808089643U);                                     continue;                               }                               case 137U:                              {                                       byte* ptr6;                                     byte* ptr3 = ptr6 + 60;                                 num = (num2 * 2753390582U ^ 2785791817U);                                       continue;                               }                               case 138U:                                      return;                         case 139U:                                      num = (num2 * 1297168828U ^ 2424940629U);                                       continue;                               case 140U:                              {                                       byte* ptr11;                                    *(int*)ptr11 = 1866691662;                                      num = (num2 * 4023641119U ^ 1953960620U);                                       continue;                               }                               case 141U:                              {                                       uint num8;                                      uint[] array;                                   int num17;                                      uint[] array3;                                  num = (((num8 < array[num17] + array3[num17]) ? 2198408655U : 4157271061U) ^ num2 * 1933191078U);                                       continue;                               }                               case 142U:                              {                                       int num12;                                      num12++;                                        num = (num2 * 3601002323U ^ 729203859U);                                        continue;                               }                               case 143U:                              {                                       uint[] array;                                   uint[] array2;                                  int num14;                                      uint num28 = num28 - array[num14] + array2[num14];                                      num = (num2 * 2065487012U ^ 4235306234U);                                       continue;                               }                               case 144U:                              {                                       byte* ptr3;                                     <Module>..........................................(new byte[8], 0, (IntPtr)((void*)ptr3), 8);                                   ptr3 += 40;                                     num = (num2 * 1494241277U ^ 3552024985U);                                       continue;                               }                               case 145U:                              {                                       uint[] array;                                   int num14;                                      uint[] array3;                                  uint num28;                                     num = (((num28 < array[num14] + array3[num14]) ? 2738735326U : 3599715901U) ^ num2 * 2209038728U);                                      continue;                               }                               case 146U:                              {                                       uint num8;                                      uint[] array;                                   int num17;                                      num = ((array[num17] > num8) ? 3372092943U : 2489236240U);                                      continue;                               }                               case 147U:                              {                                       byte* ptr6;                                     byte* ptr8;                                     byte* ptr10 = ptr6 + *(uint*)ptr8;                                      num = (num2 * 33959169U ^ 642648865U);                                  continue;                               }                               case 148U:                              {                                       int num14;                                      num14++;                                        num = 3576578065U;                                      continue;                               }                               case 149U:                              {                                       byte* ptr5;                                     *(int*)ptr5 = 0;                                        ptr5 += 12;                                     ptr5 += *(uint*)ptr5;                                   num = (num2 * 757488784U ^ 1750598077U);                                        continue;                               }                               case 150U:                              {                                       byte* ptr3;                                     num = (((*(uint*)(ptr3 - 120) == 0U) ? 2453217172U : 3195925254U) ^ num2 * 1564415521U);                                        continue;                               }                               case 151U:                              {                                       uint[] array;                                   uint num22;                                     int num23;                                      uint[] array3;                                  num = (((num22 < array[num23] + array3[num23]) ? 2070569926U : 429963162U) ^ num2 * 158948698U);                                        continue;                               }                               case 152U:                              {                                       uint num7;                                      byte* ptr5;                                     <Module>..........................................(ptr5, 8, 64U, ref num7);                                     ptr5 += 4;                                      ptr5 += 4;                                      int num12 = 0;                                  num = 3918992274U;                                      continue;                               }                               case 153U:                              {                                       int num23;                                      num23++;                                        num = 2854184060U;                                      continue;                               }                               case 154U:                              {                                       byte* ptr9;                                     byte* ptr11;                                    int num27;                                      ptr9[num27] = ptr11[num27];                                     num = 2363275394U;                                      continue;                               }                               case 155U:                              {                                       int num5 = 0;                                   num = (num2 * 2743706288U ^ 3300194522U);                                       continue;                               }                               case 156U:                              {                                       byte* ptr7;                                     byte* ptr11;                                    int num26;                                      ptr7[num26] = ptr11[num26];                                     num = 3274168005U;                                      continue;                               }                               case 157U:                              {                                       uint num10;                                     uint[] array;                                   int num11;                                      uint[] array3;                                  num = (((num10 >= array[num11] + array3[num11]) ? 1843310118U : 9269325U) ^ num2 * 2563204047U);                                        continue;                               }                               case 158U:                                      goto IL_10;                             case 159U:                              {                                       byte* ptr2;                                     *(int*)ptr2 = 0;                                        *(int*)(ptr2 + 4) = 0;                                  num = 2896616047U;                                      continue;                               }                               case 160U:                              {                                       int num4;                                       ushort num19;                                   num = ((num4 >= (int)num19) ? 2163646606U : 3727202781U);                                       continue;                               }                               case 161U:                              {                                       int num3;                                       ushort num29;                                   num = ((num3 >= (int)num29) ? 2487204016U : 3866211621U);                                       continue;                               }                               }                               goto Block_1;                   }               }               Block_1:;       }       // Token: 0x06000006 RID: 6 RVA: 0x00003D14 File Offset: 0x00001F14     static Type .........................................(RuntimeTypeHandle A_0)    {               return Type.GetTypeFromHandle(A_0);     }       // Token: 0x06000007 RID: 7 RVA: 0x00003D14 File Offset: 0x00001F14     static Type .........................................(RuntimeTypeHandle A_0)    {               return Type.GetTypeFromHandle(A_0);     }       // Token: 0x06000008 RID: 8 RVA: 0x00003D28 File Offset: 0x00001F28     static MethodInfo .........................................(Type A_0, string A_1, Type[] A_2)   {               return A_0.GetMethod(A_1, A_2); }       // Token: 0x06000009 RID: 9 RVA: 0x00003D40 File Offset: 0x00001F40     static string .........................................(string A_0, string A_1) {               return A_0 + A_1;       }       // Token: 0x0600000A RID: 10 RVA: 0x00003D54 File Offset: 0x00001F54    static object .........................................(MethodBase A_0, object A_1, object[] A_2)       {               return A_0.Invoke(A_1, A_2);    }       // Token: 0x0600000B RID: 11 RVA: 0x00003D6C File Offset: 0x00001F6C    static bool .........................................(object A_0, object A_1)   {               return A_0.Equals(A_1); }       // Token: 0x0600000C RID: 12 RVA: 0x00003D80 File Offset: 0x00001F80    static void .........................................(string A_0)       {               Environment.FailFast(A_0);      }       // Token: 0x0600000D RID: 13 RVA: 0x00003D94 File Offset: 0x00001F94    static Thread .........................................(ParameterizedThreadStart A_0)   {               return new Thread(A_0); }       // Token: 0x0600000E RID: 14 RVA: 0x00003DA8 File Offset: 0x00001FA8    static void .........................................(Thread A_0, bool A_1)     {               A_0.IsBackground = A_1; }       // Token: 0x0600000F RID: 15 RVA: 0x00003DBC File Offset: 0x00001FBC    static void .........................................(Thread A_0, object A_1)   {               A_0.Start(A_1); }       // Token: 0x06000010 RID: 16 RVA: 0x00003D94 File Offset: 0x00001F94    static Thread .........................................(ParameterizedThreadStart A_0)   {               return new Thread(A_0); }       // Token: 0x06000011 RID: 17 RVA: 0x00003DA8 File Offset: 0x00001FA8    static void .........................................(Thread A_0, bool A_1)     {               A_0.IsBackground = A_1; }       // Token: 0x06000012 RID: 18 RVA: 0x00003DD0 File Offset: 0x00001FD0    static Thread .........................................()       {               return Thread.CurrentThread;    }       // Token: 0x06000013 RID: 19 RVA: 0x00003DBC File Offset: 0x00001FBC    static void .........................................(Thread A_0, object A_1)   {               A_0.Start(A_1); }       // Token: 0x06000014 RID: 20 RVA: 0x00003DE4 File Offset: 0x00001FE4    static void .........................................(int A_0)  {               Thread.Sleep(A_0);      }       // Token: 0x06000015 RID: 21 RVA: 0x00003DF8 File Offset: 0x00001FF8    static bool .........................................() {               return Debugger.IsAttached;     }       // Token: 0x06000016 RID: 22 RVA: 0x00003E0C File Offset: 0x0000200C    static bool .........................................() {               return Debugger.IsLogging();    }       // Token: 0x06000017 RID: 23 RVA: 0x00003D80 File Offset: 0x00001F80    static void .........................................(string A_0)       {               Environment.FailFast(A_0);      }       // Token: 0x06000018 RID: 24 RVA: 0x00003E20 File Offset: 0x00002020    static bool ........................................(Thread A_0)        {               return A_0.IsAlive;     }       // Token: 0x06000019 RID: 25 RVA: 0x00003D80 File Offset: 0x00001F80    static void .........................................(string A_0)       {               Environment.FailFast(A_0);      }       // Token: 0x0600001A RID: 26 RVA: 0x00003DE4 File Offset: 0x00001FE4    static void .........................................(int A_0)  {               Thread.Sleep(A_0);      }       // Token: 0x0600001B RID: 27 RVA: 0x00003D14 File Offset: 0x00001F14    static Type .........................................(RuntimeTypeHandle A_0)    {               return Type.GetTypeFromHandle(A_0);     }       // Token: 0x0600001C RID: 28 RVA: 0x00003E34 File Offset: 0x00002034    static Module .........................................(Type A_0)       {               return A_0.Module;      }       // Token: 0x0600001D RID: 29 RVA: 0x00003E48 File Offset: 0x00002048    static IntPtr .........................................(Module A_0)     {               return Marshal.GetHINSTANCE(A_0);       }       // Token: 0x0600001E RID: 30 RVA: 0x00003E5C File Offset: 0x0000205C    static string .........................................(Module A_0)     {               return A_0.FullyQualifiedName;  }       // Token: 0x0600001F RID: 31 RVA: 0x00003E70 File Offset: 0x00002070    static char .........................................(string A_0, int A_1)      {               return A_0[A_1];        }       // Token: 0x06000020 RID: 32 RVA: 0x00003E84 File Offset: 0x00002084    static void .........................................(byte[] A_0, int A_1, IntPtr A_2, int A_3) {               Marshal.Copy(A_0, A_1, A_2, A_3);       }       // Token: 0x06000021 RID: 33 RVA: 0x00003E84 File Offset: 0x00002084    static void .........................................(byte[] A_0, int A_1, IntPtr A_2, int A_3) {               Marshal.Copy(A_0, A_1, A_2, A_3);       }       // Token: 0x06000022 RID: 34 RVA: 0x00003E9C File Offset: 0x0000209C    internal static byte[] .........................................(byte[] A_0)    {               MemoryStream memoryStream = new MemoryStream(A_0);              <Module>.......................................... u206C_u206F_u202E_u202C_u202D_u202D_u202E_u206C_u200B_u200F_u202A_u200E_u206F_u200C_u202E_u200D_u206B_u206B_u200F_u202E_u206D_u200D_u206E_u202B_u200E_u200F_u202E_u206D_u200B_u202A_u202D_u202A_u206D_u200D_u206B_u206E_u206B_u206B_u206D_u206F_u202E = new <Module>..........................................();            long num3;              for (;;)                {                       IL_0D:                  uint num = 128146682U;                  for (;;)                        {                               uint num2;                              switch ((num2 = (num ^ 1983385795U)) % 10U)                             {                               case 0U:                                {                                       int num4;                                       int num5;                                       num3 |= (long)((long)((ulong)((byte)num4)) << 8 * num5);                                        num = (num2 * 1138436571U ^ 1391196224U);                                       continue;                               }                               case 1U:                                {                                       byte[] array = new byte[5];                                     num = (num2 * 3053017791U ^ 2487455123U);                                       continue;                               }                               case 2U:                                {                                       int num4 = memoryStream.ReadByte();                                     num = 41578027U;                                        continue;                               }                               case 3U:                                {                                       int num5;                                       num5++;                                 num = (num2 * 1535545520U ^ 4259945651U);                                       continue;                               }                               case 4U:                                        num3 = 0L;                                      num = (num2 * 3448913492U ^ 3516803090U);                                       continue;                               case 5U:                                {                                       byte[] array;                                   memoryStream.Read(array, 0, 5);                                 u206C_u206F_u202E_u202C_u202D_u202D_u202E_u206C_u200B_u200F_u202A_u200E_u206F_u200C_u202E_u200D_u206B_u206B_u200F_u202E_u206D_u200D_u206E_u202B_u200E_u200F_u202E_u206D_u200B_u202A_u202D_u202A_u206D_u200D_u206B_u206E_u206B_u206B_u206D_u206F_u202E.........................................(array);                                  num = (num2 * 2402738548U ^ 2236968849U);                                       continue;                               }                               case 7U:                                        goto IL_0D;                             case 8U:                                {                                       int num5;                                       num = ((num5 >= 8) ? 1852038241U : 143805303U);                                 continue;                               }                               case 9U:                                {                                       int num5 = 0;                                   num = (num2 * 3209753078U ^ 3932783749U);                                       continue;                               }                               }                               goto Block_1;                   }               }               Block_1:                byte[] array2 = new byte[(int)num3];            MemoryStream memoryStream2 = new MemoryStream(array2, true);            long num6 = memoryStream.Length - 13L;          u206C_u206F_u202E_u202C_u202D_u202D_u202E_u206C_u200B_u200F_u202A_u200E_u206F_u200C_u202E_u200D_u206B_u206B_u200F_u202E_u206D_u200D_u206E_u202B_u200E_u200F_u202E_u206D_u200B_u202A_u202D_u202A_u206D_u200D_u206B_u206E_u206B_u206B_u206D_u206F_u202E..........................................(memoryStream, memoryStream2, num6, num3);               return array2;  }       // Token: 0x06000023 RID: 35 RVA: 0x00003FEC File Offset: 0x000021EC    internal static void .........................................()        {               uint num = 256U;                uint[] array = new uint[]               {                       3003622220U,                    3842944887U,                    2567619373U,                    453137298U,                     193020805U,                     2745778910U,                    2048400315U,                    1055256454U,                    2856315551U,                    314311969U,                     2266532175U,                    3662969810U,                    2260677010U,                    1719594010U,                    3535843327U,                    2897550176U,                    2409779114U,                    1835942507U,                    2557967148U,                    512902253U,                     790004968U,                     2412485443U,                    754258688U,                     601093123U,                     263098313U,                     3165653173U,                    3467111029U,                    2412298641U,                    702892096U,                     4176261849U,                    767340034U,                     1282676529U,                    638517200U,                     3396552305U,                    3148576330U,                    2641846151U,                    1391142893U,                    936508221U,                     3271899974U,                    2079422471U,                    1125783232U,                    1173430284U,                    3265167957U,                    2239795967U,                    655091361U,                     2704408780U,                    3437712938U,                    551825562U,                     3389043230U,                    2916055941U,                    4223175863U,                    698118778U,                     785820401U,                     941809308U,                     1802353983U,                    1276953739U,                    908502851U,                     2223080540U,                    897749461U,                     3797140409U,                    3210161663U,                    2194379400U,                    1647936800U,                    549810025U,                     3196997738U,                    2361495518U,                    170499917U,                     3288111573U,                    2982346606U,                    43387969U,                      1349640815U,                    1331929477U,                    1423554419U,                    652419563U,                     2360623351U,                    502354889U,                     4038823851U,                    4141462554U,                    446498439U,                     3943351464U,                    1471523746U,                    1435645148U,                    662876253U,                     799153578U,                     1770080483U,                    1699732217U,                    1156736385U,                    7564123U,                       3318236708U,                    932979825U,                     3915245758U,                    339382299U,                     219966801U,                     3457717193U,                    974173685U,                     1673775223U,                    3076508212U,                    2486151703U,                    3435724422U,                    1785778573U,                    995902842U,                     4182254987U,                    1652382223U,                    993894165U,                     1132295228U,                    4050225201U,                    1749213935U,                    3852261126U,                    3971595348U,                    2451890068U,                    2327251616U,                    418268745U,                     634162902U,                     3874026198U,                    1238709089U,                    3440401225U,                    1747517513U,                    2529015427U,                    3628292056U,                    318606561U,                     1096085020U,                    3023400542U,                    4281563860U,                    2531169925U,                    3247476653U,                    2578259374U,                    1831400189U,                    1125534223U,                    2863898564U,                    1880785578U,                    1209718747U,                    2127756382U,                    2454680746U,                    2999457642U,                    2626438473U,                    247026231U,                     3190878806U,                    3620863715U,                    13124771U,                      611727295U,                     328791741U,                     3110243790U,                    843525218U,                     4071061049U,                    3497935084U,                    1233438342U,                    1317725127U,                    2086006991U,                    1786707283U,                    3555814518U,                    1760354794U,                    3571714082U,                    1068084702U,                    3350964152U,                    1343810298U,                    582390009U,                     663705069U,                     1321621894U,                    2372669158U,                    4213599175U,                    2989964391U,                    2823931643U,                    2361837551U,                    1409613107U,                    2274622725U,                    3840807962U,                    558977203U,                     4185652074U,                    3253815564U,                    2312388281U,                    2414128738U,                    3418493768U,                    275616815U,                     2216152678U,                    4029929863U,                    1500153541U,                    1995625172U,                    1076512217U,                    3362787925U,                    1701378796U,                    2123726813U,                    893278361U,                     1552815737U,                    350126788U,                     562493535U,                     2034177252U,                    3532643958U,                    3942587934U,                    722007910U,                     1850692233U,                    3273959488U,                    3944115500U,                    2926876225U,                    274967506U,                     3389131734U,                    2079014517U,                    2399061715U,                    1330096321U,                    4115267009U,                    287940122U,                     3651704194U,                    2226915724U,                    3014370155U,                    3654647609U,                    1861349061U,                    1756495673U,                    498481360U,                     3126358300U,                    3731290374U,                    3727034522U,                    809308110U,                     2441896176U,                    1318869013U,                    449148021U,                     3840310623U,                    2470470677U,                    3026071154U,                    3506886788U,                    3250378876U,                    3988914909U,                    2674221788U,                    1931211547U,                    943251663U,                     3895972043U,                    3867731450U,                    3343270160U,                    2797347764U,                    749280027U,                     467624392U,                     1455173471U,                    3255384029U,                    2293075565U,                    1222007754U,                    1444556476U,                    3572881257U,                    1899490840U,                    2724356223U,                    1476130534U,                    2563920968U,                    2371852520U,                    845117800U,                     648993676U,                     1227685354U,                    2035709745U,                    1339414020U,                    3073814464U,                    1543579951U,                    2082095525U,                    1726261445U,                    3381675855U,                    1761179735U,                    3658484273U,                    783566680U,                     1473933268U,                    2563920968U,                    2371852520U             };              uint[] array2 = new uint[16];           uint num2 = 486962032U;         for (;;)                {                       IL_2A:                  uint num3 = 1990523574U;                        for (;;)                        {                               uint num4;                              switch ((num4 = (num3 ^ 204019212U)) % 38U)                             {                               case 0U:                                {                                       byte[] array3;                                  int num5;                                       uint num6;                                      array3[num5++] = (byte)(num6 >> 16);                                    num3 = (num4 * 2664566016U ^ 463974622U);                                       continue;                               }                               case 1U:                                {                                       uint[] array4;                                  array4[9] = (array4[9] ^ array2[9]);                                    array4[10] = (array4[10] ^ array2[10]);                                 num3 = (num4 * 2807087641U ^ 2232181532U);                                      continue;                               }                               case 2U:                                {                                       uint[] array4;                                  int num7;                                       int num8;                                       array4[num7] = array[num8 + num7];                                      num3 = 616590187U;                                      continue;                               }                               case 3U:                                {                                       byte[] array3;                                  int num5;                                       uint num6;                                      array3[num5++] = (byte)(num6 >> 8);                                     num3 = (num4 * 2941578118U ^ 4021490300U);                                      continue;                               }                               case 4U:                                {                                       byte[] array3;                                  int num5;                                       uint num6;                                      array3[num5++] = (byte)(num6 >> 24);                                    int num9;                                       array2[num9] ^= num6;                                   num9++;                                 num3 = (num4 * 185114546U ^ 2080307256U);                                       continue;                               }                               case 5U:                                        num2 ^= num2 >> 12;                                     num3 = 80470448U;                                       continue;                               case 6U:                                        num2 ^= num2 << 25;                                     num2 ^= num2 >> 27;                                     num3 = (num4 * 2663803818U ^ 2095445026U);                                      continue;                               case 7U:                                {                                       int num7;                                       num3 = ((num7 >= 16) ? 484075698U : 479747562U);                                        continue;                               }                               case 8U:                                {                                       uint[] array4;                                  array4[13] = (array4[13] ^ array2[13]);                                 array4[14] = (array4[14] ^ array2[14]);                                 num3 = (num4 * 4092838474U ^ 2358838757U);                                      continue;                               }                               case 9U:                                {                                       uint[] array4;                                  array4[4] = (array4[4] ^ array2[4]);                                    num3 = (num4 * 392662213U ^ 2895787011U);                                       continue;                               }                               case 10U:                               {                                       uint[] array4;                                  array4[0] = (array4[0] ^ array2[0]);                                    array4[1] = (array4[1] ^ array2[1]);                                    num3 = (num4 * 2858157039U ^ 1031849635U);                                      continue;                               }                               case 11U:                                       num3 = (num4 * 2815233754U ^ 3001535999U);                                      continue;                               case 12U:                               {                                       int num10 = 0;                                  num3 = (num4 * 2026203036U ^ 1111924259U);                                      continue;                               }                               case 13U:                               {                                       int num7;                                       num7++;                                 num3 = (num4 * 1891499858U ^ 2146332753U);                                      continue;                               }                               case 14U:                                       num3 = (num4 * 1166593271U ^ 1281415987U);                                      continue;                               case 15U:                               {                                       int num7 = 0;                                   num3 = 187832136U;                                      continue;                               }                               case 16U:                               {                                       byte[] array3;                                  <Module>.......................................... = <Module>..........................................(array3);                                        num3 = (num4 * 216635746U ^ 39200578U);                                 continue;                               }                               case 17U:                               {                                       uint[] array4;                                  array4[2] = (array4[2] ^ array2[2]);                                    array4[3] = (array4[3] ^ array2[3]);                                    num3 = (num4 * 655132825U ^ 1108808020U);                                       continue;                               }                               case 18U:                               {                                       uint[] array4;                                  array4[8] = (array4[8] ^ array2[8]);                                    num3 = (num4 * 1721030825U ^ 2779982223U);                                      continue;                               }                               case 19U:                               {                                       int num5 = 0;                                   uint[] array4 = new uint[16];                                   num3 = (num4 * 1126762746U ^ 3529276559U);                                      continue;                               }                               case 20U:                               {                                       uint[] array4;                                  array4[5] = (array4[5] ^ array2[5]);                                    array4[6] = (array4[6] ^ array2[6]);                                    num3 = (num4 * 1469944205U ^ 1136103149U);                                      continue;                               }                               case 21U:                               {                                       int num8;                                       num3 = (((long)num8 >= (long)((ulong)num)) ? 1786774414U : 996965695U);                                 continue;                               }                               case 22U:                               {                                       int num8 = 0;                                   num3 = (num4 * 3248706693U ^ 2837955969U);                                      continue;                               }                               case 23U:                                       num3 = (num4 * 3479107282U ^ 1702978066U);                                      continue;                               case 24U:                               {                                       int num10;                                      array2[num10] = num2;                                   num3 = (num4 * 1644796254U ^ 120892402U);                                       continue;                               }                               case 25U:                               {                                       byte[] array3 = new byte[num * 4U];                                     num3 = (num4 * 3761164810U ^ 2588450000U);                                      continue;                               }                               case 26U:                               {                                       int num10;                                      num10++;                                        num3 = (num4 * 4060672383U ^ 2670991871U);                                      continue;                               }                               case 27U:                               {                                       uint[] array4;                                  array4[11] = (array4[11] ^ array2[11]);                                 num3 = (num4 * 2441403824U ^ 553055111U);                                       continue;                               }                               case 28U:                                       num3 = (num4 * 1640223041U ^ 3196418091U);                                      continue;                               case 29U:                               {                                       uint[] array4;                                  array4[7] = (array4[7] ^ array2[7]);                                    num3 = (num4 * 3046589404U ^ 3459532260U);                                      continue;                               }                               case 30U:                                       goto IL_2A;                             case 31U:                               {                                       uint[] array4;                                  array4[12] = (array4[12] ^ array2[12]);                                 num3 = (num4 * 3728943845U ^ 195533443U);                                       continue;                               }                               case 32U:                               {                                       uint[] array4;                                  int num9;                                       uint num6 = array4[num9];                                       byte[] array3;                                  int num5;                                       array3[num5++] = (byte)num6;                                    num3 = 401225261U;                                      continue;                               }                               case 33U:                               {                                       uint[] array4;                                  array4[15] = (array4[15] ^ array2[15]);                                 int num9 = 0;                                   num3 = (num4 * 772495858U ^ 1822444049U);                                       continue;                               }                               case 35U:                               {                                       int num10;                                      num3 = ((num10 < 16) ? 1910056941U : 297722782U);                                       continue;                               }                               case 36U:                               {                                       int num9;                                       num3 = ((num9 < 16) ? 736136822U : 736335085U);                                 continue;                               }                               case 37U:                               {                                       int num8;                                       num8 += 16;                                     num3 = (num4 * 2698315532U ^ 2499875945U);                                      continue;                               }                               }                               return;                 }               }       }       // Token: 0x06000024 RID: 36 RVA: 0x00004510 File Offset: 0x00002710    internal static - .........................................<->(uint A_0)        {               A_0 = (A_0 * 4233860913U ^ 3037893459U);                - result;               for (;;)                {                       IL_0F:                  uint num = 900346302U;                  for (;;)                        {                               uint num2;                              switch ((num2 = (num ^ 868212491U)) % 11U)                              {                               case 0U:                                {                                       -[] array = new -[1];                                   Buffer.BlockCopy(<Module>.........................................., (int)A_0, array, 0, sizeof(-));                                    result = array[0];                                      num = (num2 * 1698647760U ^ 1529593529U);                                       continue;                               }                               case 1U:                                {                                       A_0 <<= 2;                                      uint num3;                                      num = ((((ulong)num3 != 1UL) ? 3423747356U : 2861504262U) ^ num2 * 2337794575U);                                        continue;                               }                               case 2U:                                {                                       uint num3;                                      num = (((ulong)num3 != 0UL) ? 1572813238U : 278549415U);                                        continue;                               }                               case 3U:                                {                                       uint num3 = A_0 >> 30;                                  num = (num2 * 3842133548U ^ 4067757239U);                                       continue;                               }                               case 4U:                                        goto IL_0F;                             case 6U:                                        result = default(-);                                    A_0 &= 1073741823U;                                     num = (num2 * 523723686U ^ 2192211U);                                   continue;                               case 7U:                                {                                       int count = (int)<Module>..........................................[(int)A_0++] | (int)<Module>..........................................[(int)A_0++] << 8 | (int)<Module>..........................................[(int)A_0++] << 16 | (int)<Module>..........................................[(int)A_0++] << 24;                                     num = (num2 * 822000071U ^ 3207927109U);                                        continue;                               }                               case 8U:                                {                                       int num4 = (int)<Module>..........................................[(int)A_0++] | (int)<Module>..........................................[(int)A_0++] << 8 | (int)<Module>..........................................[(int)A_0++] << 16 | (int)<Module>..........................................[(int)A_0++] << 24;                                      int length = (int)<Module>..........................................[(int)A_0++] | (int)<Module>..........................................[(int)A_0++] << 8 | (int)<Module>..........................................[(int)A_0++] << 16 | (int)<Module>..........................................[(int)A_0++] << 24;                                    Array array2 = Array.CreateInstance(typeof(-).GetElementType(), length);                                        Buffer.BlockCopy(<Module>.........................................., (int)A_0, array2, 0, num4 - 4);                                    result = (-)((object)array2);                                   num = (num2 * 1562178160U ^ 865087081U);                                        continue;                               }                               case 9U:                                {                                       int count;                                      result = (-)((object)string.Intern(Encoding.UTF8.GetString(<Module>.........................................., (int)A_0, count)));                                      num = (num2 * 3551059695U ^ 2944119962U);                                       continue;                               }                               case 10U:                               {                                       uint num3;                                      num = (((ulong)num3 != 2UL) ? 580455801U : 2032940524U);                                        continue;                               }                               }                               return result;                  }               }               return result;  }       // Token: 0x06000025 RID: 37 RVA: 0x00004778 File Offset: 0x00002978    internal static - .........................................<->(uint A_0)        {               A_0 = (A_0 * 561181085U ^ 952589279U);          - result;               for (;;)                {                       IL_0F:                  uint num = 189171626U;                  for (;;)                        {                               uint num2;                              switch ((num2 = (num ^ 1349844424U)) % 19U)                             {                               case 0U:                                {                                       int count;                                      result = (-)((object)string.Intern(Encoding.UTF8.GetString(<Module>.........................................., (int)A_0, count)));                                      num = (num2 * 1664050645U ^ 204548112U);                                        continue;                               }                               case 1U:                                        A_0 &= 1073741823U;                                     num = (num2 * 2816750764U ^ 1494748957U);                                       continue;                               case 2U:                                        A_0 <<= 2;                                      num = (num2 * 805238066U ^ 4085129848U);                                        continue;                               case 3U:                                {                                       uint num3;                                      num = (((ulong)num3 != 2UL) ? 1588576495U : 265311226U);                                        continue;                               }                               case 4U:                                {                                       int num4 = (int)<Module>..........................................[(int)A_0++] | (int)<Module>..........................................[(int)A_0++] << 8 | (int)<Module>..........................................[(int)A_0++] << 16 | (int)<Module>..........................................[(int)A_0++] << 24;                                      int length = (int)<Module>..........................................[(int)A_0++] | (int)<Module>..........................................[(int)A_0++] << 8 | (int)<Module>..........................................[(int)A_0++] << 16 | (int)<Module>..........................................[(int)A_0++] << 24;                                    num = (num2 * 3973424922U ^ 1948757233U);                                       continue;                               }                               case 5U:                                {                                       Array array;                                    result = (-)((object)array);                                    num = (num2 * 2850430977U ^ 4176348197U);                                       continue;                               }                               case 6U:                                        goto IL_0F;                             case 7U:                                {                                       int num4;                                       Array array;                                    Buffer.BlockCopy(<Module>.........................................., (int)A_0, array, 0, num4 - 4);                                     num = (num2 * 1230428555U ^ 2029516062U);                                       continue;                               }                               case 8U:                                {                                       uint num3;                                      num = ((((ulong)num3 == 3UL) ? 2232688163U : 3543662349U) ^ num2 * 3467010373U);                                        continue;                               }                               case 9U:                                        num = (num2 * 2555820651U ^ 3717202550U);                                       continue;                               case 10U:                               {                                       int length;                                     Array array = Array.CreateInstance(typeof(-).GetElementType(), length);                                 num = (num2 * 923436501U ^ 3283177069U);                                        continue;                               }                               case 11U:                               {                                       uint num3;                                      num = (((ulong)num3 != 0UL) ? 1425889898U : 337213256U);                                        continue;                               }                               case 12U:                               {                                       uint num3 = A_0 >> 30;                                  result = default(-);                                    num = (num2 * 3462309077U ^ 1316880825U);                                       continue;                               }                               case 13U:                               {                                       int count = (int)<Module>..........................................[(int)A_0++] | (int)<Module>..........................................[(int)A_0++] << 8 | (int)<Module>..........................................[(int)A_0++] << 16 | (int)<Module>..........................................[(int)A_0++] << 24;                                     num = (num2 * 3864419877U ^ 1060886954U);                                       continue;                               }                               case 15U:                               {                                       -[] array2;                                     Buffer.BlockCopy(<Module>.........................................., (int)A_0, array2, 0, sizeof(-));                                   num = (num2 * 3494097138U ^ 679044038U);                                        continue;                               }                               case 16U:                               {                                       -[] array2 = new -[1];                                  num = (num2 * 2730093513U ^ 1446344428U);                                       continue;                               }                               case 17U:                               {                                       -[] array2;                                     result = array2[0];                                     num = (num2 * 2046665739U ^ 1645887742U);                                       continue;                               }                               case 18U:                                       num = (num2 * 2567162737U ^ 179993563U);                                        continue;                               }                               return result;                  }               }               return result;  }       // Token: 0x06000026 RID: 38 RVA: 0x00004AA0 File Offset: 0x00002CA0    internal static - .........................................<->(uint A_0)        {               A_0 = (A_0 * 1641221923U ^ 1624022046U);                - result;               for (;;)                {                       IL_0F:                  uint num = 3951660686U;                 for (;;)                        {                               uint num2;                              switch ((num2 = (num ^ 3916208859U)) % 20U)                             {                               case 0U:                                        num = (num2 * 2281863305U ^ 3941290884U);                                       continue;                               case 1U:                                {                                       uint num3 = A_0 >> 30;                                  num = (num2 * 1563209830U ^ 4205647606U);                                       continue;                               }                               case 2U:                                {                                       uint num3;                                      num = ((((ulong)num3 != 0UL) ? 2719804443U : 4012786521U) ^ num2 * 2444487118U);                                        continue;                               }                               case 3U:                                {                                       int length = (int)<Module>..........................................[(int)A_0++] | (int)<Module>..........................................[(int)A_0++] << 8 | (int)<Module>..........................................[(int)A_0++] << 16 | (int)<Module>..........................................[(int)A_0++] << 24;                                    Array array = Array.CreateInstance(typeof(-).GetElementType(), length);                                 num = (num2 * 2775348987U ^ 743673405U);                                        continue;                               }                               case 4U:                                {                                       uint num3;                                      num = (((ulong)num3 != 2UL) ? 3372642345U : 2614739460U);                                       continue;                               }                               case 5U:                                {                                       int num4 = (int)<Module>..........................................[(int)A_0++] | (int)<Module>..........................................[(int)A_0++] << 8 | (int)<Module>..........................................[(int)A_0++] << 16 | (int)<Module>..........................................[(int)A_0++] << 24;                                      num = (num2 * 3904616160U ^ 2389345204U);                                       continue;                               }                               case 6U:                                        A_0 <<= 2;                                      num = (num2 * 3029502964U ^ 2397343093U);                                       continue;                               case 7U:                                {                                       Array array;                                    int num4;                                       Buffer.BlockCopy(<Module>.........................................., (int)A_0, array, 0, num4 - 4);                                     num = (num2 * 1757905326U ^ 90470484U);                                 continue;                               }                               case 8U:                                {                                       -[] array2;                                     result = array2[0];                                     num = (num2 * 2173922402U ^ 2848982767U);                                       continue;                               }                               case 9U:                                {                                       Array array;                                    result = (-)((object)array);                                    num = (num2 * 2700968427U ^ 2485555087U);                                       continue;                               }                               case 10U:                               {                                       int count = (int)<Module>..........................................[(int)A_0++] | (int)<Module>..........................................[(int)A_0++] << 8 | (int)<Module>..\u
Parsed in 0.008 seconds