public static EmbeddedAssemblyInfo create(ModuleDefMD module, string encName, string rsrcName)
        {
            var info = new EmbeddedAssemblyInfo();

            try {
                if (encName == "" || Convert.ToBase64String(Convert.FromBase64String(encName)) != encName)
                    return null;
            }
            catch (FormatException) {
                return null;
            }

            if (rsrcName.Length > 0 && rsrcName[0] == '[') {
                int i = rsrcName.IndexOf(']');
                if (i < 0)
                    return null;
                info.flags = rsrcName.Substring(1, i - 1);
                info.isTempFile = info.flags.IndexOf('t') >= 0;
                info.isCompressed = info.flags.IndexOf('z') >= 0;
                rsrcName = rsrcName.Substring(i + 1);
            }
            if (rsrcName == "")
                return null;

            info.assemblyName = Encoding.UTF8.GetString(Convert.FromBase64String(encName));
            info.resourceName = rsrcName;
            info.resource = DotNetUtils.getResource(module, rsrcName) as EmbeddedResource;
            info.simpleName = Utils.getAssemblySimpleName(info.assemblyName);

            return info;
        }

 public AssemblyResolver(ModuleDefMD module, DecrypterType decrypterType)
 {
     this.module = module;
     this.frameworkType = DotNetUtils.getFrameworkType(module);
     this.decrypterType = decrypterType;
     this.codeCompilerMethodCallRestorer = new CodeCompilerMethodCallRestorer(module);
 }

 public ReferenceFolderTreeNode(ModuleDefMD module, AssemblyTreeNode parentAssembly, AssemblyListTreeNode assemblyListTreeNode)
 {
     this.module = module;
     this.parentAssembly = parentAssembly;
     this.assemblyListTreeNode = assemblyListTreeNode;
     this.LazyLoading = true;
 }

 public ImageReader(IDeobfuscatorContext deobfuscatorContext, ModuleDefMD module, byte[] data)
 {
     this.deobfuscatorContext = deobfuscatorContext;
     this.module = module;
     this.reader = MemoryImageStream.Create(data);
     this.memberRefConverter = new MemberRefConverter(module);
 }

		public MethodsDecrypter(ModuleDefMD module, MethodsDecrypter oldOne) {
			this.module = module;
			this.encryptedResource = new EncryptedResource(module, oldOne.encryptedResource);
			this.tokenToNativeMethod = oldOne.tokenToNativeMethod;
			this.totalEncryptedNativeMethods = oldOne.totalEncryptedNativeMethods;
			this.xorKey = oldOne.xorKey;
		}

 public static EmbeddedResource findEmbeddedResource(ModuleDefMD module, TypeDef decrypterType, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
 {
     return findEmbeddedResource(module, decrypterType, (method) => {
         simpleDeobfuscator.deobfuscate(method);
         simpleDeobfuscator.decryptStrings(method, deob);
     });
 }

		ModuleDefMD SetModule(ModuleDefMD newModule) {
			module = newModule;
			TheAssemblyResolver.Instance.AddModule(module);
			module.EnableTypeDefFindCache = true;
			module.Location = filename;
			return module;
		}

 private static FieldDef CreateField(ModuleDefMD module)
 {
     FieldAttributes attrb = FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.HasFieldRVA | FieldAttributes.CompilerControlled;
     FieldDef field = new FieldDefUser("", new FieldSig(module.CorLibTypes.String), attrb);
     RenameTask.Rename(field);
     return field;
 }

        public BamlDocument Analyze(ModuleDefMD module, string bamlName, byte[] data)
        {
            this.module = module;
            this.bamlName = bamlName;
            if (module.IsClr40) {
                things = thingsv4 ?? (thingsv4 = new KnownThingsv4(context, module));
            }
            else {
                things = thingsv3 ?? (thingsv3 = new KnownThingsv3(context, module));
            }

            Debug.Assert(BitConverter.ToInt32(data, 0) == data.Length - 4);

            BamlDocument document = BamlReader.ReadDocument(new MemoryStream(data, 4, data.Length - 4));

            // Remove debug infos
            document.RemoveWhere(rec => rec is LineNumberAndPositionRecord || rec is LinePositionRecord);

            // Populate references
            PopulateReferences(document);

            // Process elements
            BamlElement rootElem = BamlElement.Read(document);
            BamlElement trueRoot = rootElem.Children.Single();
            var stack = new Stack<BamlElement>();
            stack.Push(rootElem);
            while (stack.Count > 0) {
                BamlElement elem = stack.Pop();
                ProcessBAMLElement(trueRoot, elem);
                foreach (BamlElement child in elem.Children)
                    stack.Push(child);
            }

            return document;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="module">The .NET protected ModuleDefMD</param>
        /// <param name="Methoddecryption">The method which decrypt the strings</param>
        public static void DecryptStringsInMethod(ModuleDefMD module, MethodDef Methoddecryption)
        {
            foreach (TypeDef type in module.Types)
            {
                foreach (MethodDef method in type.Methods)
                {
                    if (!method.HasBody)
                        break;
                    for (int i = 0; i < method.Body.Instructions.Count; i++)
                    {
                        if (method.Body.Instructions[i].OpCode == OpCodes.Call)
                        {
                            if (method.Body.Instructions[i].Operand.ToString().ToLower().Contains(Typedecryption.Name.ToLower()))
                            {
                                Type2Remove.Add(Typedecryption);
                                var CalledDecMethod = (MethodDef)method.Body.Instructions[i].Operand;
                                var decryptedstring = ExtractStringFromMethod(CalledDecMethod);
                                if (decryptedstring == "[DEObfuscar] Error")
                                {
                                    //
                                }
                                else
                                {
                                    CilBody body = method.Body;
                                    body.Instructions[i].OpCode = OpCodes.Ldstr;
                                    body.Instructions[i].Operand = decryptedstring;
                                    DeobedStringNumber = DeobedStringNumber + 1;
                                }
                            }

                        }
                    }
                }
            }
        }

        public static MethodDef GetDecryptType(ModuleDefMD asmodule)
        {
            //
            var module_types = asmodule.Types;
            asm = asmodule;
            //
            foreach (TypeDef type in module_types)
            {
                if (type.Name == "<Module>") continue;
                foreach (MethodDef method in type.Methods)
                {
                    if (!method.HasBody) continue;
                    if (!method.IsConstructor) continue;
                    var instrsdec = method.Body.Instructions;
                    if (instrsdec.Count < 5) continue;
                    for (int i = 0; i < instrsdec.Count; i++)
                    {
                        if (method.Body.Instructions[0].OpCode == OpCodes.Ldstr && method.Body.Instructions[1].OpCode == OpCodes.Call
                            && method.Body.Instructions[2].OpCode == OpCodes.Stsfld)
                        {

                            return method;
                        }

                    }
                }
            }
            return null;
        }

 public ResolverBase(ModuleDefMD module, ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
 {
     this.module = module;
     this.frameworkType = DotNetUtils.getFrameworkType(module);
     this.simpleDeobfuscator = simpleDeobfuscator;
     this.deob = deob;
 }

 ResourceWriter(ModuleDefMD module, Stream stream, ResourceElementSet resources)
 {
     this.module = module;
     this.typeCreator = new ResourceDataCreator(module);
     this.writer = new BinaryWriter(stream);
     this.resources = resources;
 }

		// Following codes are auto-generated, do not modify.

		void InitAssemblies(ModuleDefMD initMod) {
			assemblies[0] = context.Resolver.ResolveThrow("PresentationFramework, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35", initMod);
			assemblies[1] = context.Resolver.ResolveThrow("PresentationCore, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35", initMod);
			assemblies[2] = context.Resolver.ResolveThrow("mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", initMod);
			assemblies[3] = context.Resolver.ResolveThrow("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", initMod);
			assemblies[4] = context.Resolver.ResolveThrow("WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35", initMod);
			assemblies[5] = context.Resolver.ResolveThrow("System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", initMod);
		}

 private static List<MethodDef> GetInstrumentationMethods(ModuleDefMD instrumentationAssembly, TypeDef instrumentedAttribute, ModuleDefMD sourceAssembly)
 {
     return instrumentationAssembly.Types
         .Where(x => x.FullName != instrumentedAttribute.FullName)
         .Where(x => FindSourceType(x.ToTypeSig(), sourceAssembly) != null)
         .SelectMany(x => x.Methods)
         .Where(y => y.CustomAttributes.Any(x => x.AttributeType == instrumentedAttribute)).ToList();
 }

		static EmbeddedResource FindEmbeddedResource1(ModuleDefMD module, MethodDef method) {
			foreach (var s in DotNetUtils.GetCodeStrings(method)) {
				var resource = DotNetUtils.GetResource(module, s) as EmbeddedResource;
				if (resource != null)
					return resource;
			}
			return null;
		}

		public Csvm(IDeobfuscatorContext deobfuscatorContext, ModuleDefMD module, Csvm oldOne) {
			this.deobfuscatorContext = deobfuscatorContext;
			this.module = module;
			if (oldOne.resource != null)
				this.resource = (EmbeddedResource)module.Resources[oldOne.module.Resources.IndexOf(oldOne.resource)];
			if (oldOne.vmAssemblyRef != null)
				this.vmAssemblyRef = module.ResolveAssemblyRef(oldOne.vmAssemblyRef.Rid);
		}

 CustomAttributeReader(ModuleDefMD readerModule, uint offset)
 {
     this.module = readerModule;
     this.reader = readerModule.BlobStream.CreateStream(offset);
     this.ownReader = true;
     this.genericArguments = null;
     this.recursionCounter = new RecursionCounter();
     this.verifyReadAllBytes = false;
 }

		public MyDeobfuscator(ModuleDefMD module) {
			cliSecureRtType = new CliSecureRtType(module);
			cliSecureRtType.Find(null);
			stringDecrypter = new StringDecrypter(module, cliSecureRtType.StringDecrypterMethod);
			stringDecrypter.Find();
			cliSecureRtType.FindStringDecrypterMethod();
			stringDecrypter.Method = cliSecureRtType.StringDecrypterMethod;
			staticStringInliner.Add(stringDecrypter.Method, (method, gim, args) => stringDecrypter.Decrypt((string)args[0]));
		}

 public ProxyCallFixer(ModuleDefMD module, byte[] fileData)
     : base(module)
 {
     this.fileData = fileData;
     if (module.Assembly == null)
         ourAsm = " -1-1-1-1-1- , Version=1.2.3.4, Culture=neutral, PublicKeyToken=null";
     else
         ourAsm = module.Assembly.FullName;
 }