static void Main(string[] args)
        {
            var asmDef = AssemblyDef.Load(args[0]);
            var method = asmDef.ManifestModule.EntryPoint.DeclaringType.FindMethod("Foo");
            var asmResolver = new AssemblyResolver();
            var modCtx = new ModuleContext(asmResolver);

            var ast = new ILAST(method, modCtx);

            Console.WriteLine("-------------------------------");
            Console.WriteLine("         Standard AST");
            Console.WriteLine("-------------------------------");

            foreach (Element element in ast.Elements)
                Console.WriteLine("{0}: {1}", element.GetType().Name, element);

            ILAST.SimplifyElements(ast.Elements);
            Console.WriteLine("\n-------------------------------");
            Console.WriteLine("        Simplified AST");
            Console.WriteLine("-------------------------------");

            foreach (Element element in ast.Elements)
                Console.WriteLine("{0}: {1}", element.GetType().Name, element);

            Console.WriteLine(asmDef);
        }

		public IObfuscatedFile SearchDeobfuscator(string filename)
		{
			ModuleContext context = new ModuleContext();
			ObfuscatedFile.Options fileOptions = new ObfuscatedFile.Options { Filename = filename };
			ObfuscatedFile ofile = CreateObfuscationFile(fileOptions, context);
			return ofile;
		}

        public ILAST(MethodDef method, ModuleContext modCtx)
        {
            Method = method;
            Method.DeclaringType.Module.Context = modCtx;
            Elements = new List<Element>();

            ProcessMethod();
        }

		public dnModule(byte[] module, string fileName, ModuleContext ctx) {
			RawData = module;
			ErrorMessage = null;
			Name = Path.GetFileName(fileName);

			var creator = new dnModuleStreamCreator(module, fileName);
			try {
				Image = new PEImage(creator, ImageLayout.File, true);
			}
			catch (Exception ex) {
				ErrorMessage += string.Format("Error while loading PE Image:{0}{1}{0}{0}",
					Environment.NewLine, ex);

				Image = null;
				return;
			}

			try {
				MetaData = MetaDataCreator.CreateMetaData(Image);
			}
			catch (Exception ex) {
				ErrorMessage += string.Format("Error while loading MetaData:{0}{1}{0}{0}",
					Environment.NewLine, ex);

				MetaData = null;
				return;
			}

			try {
				ModuleDef = (ModuleDefMD)loadInternal.Invoke(null, new object[] {
					MetaData, new ModuleCreationOptions {
						TryToLoadPdbFromDisk = true,
						Context = ctx
					}
				});
				ModuleDef.EnableTypeDefFindCache = true;
			}
			catch (Exception ex) {
				ErrorMessage = string.Format("Error while loading ModuleDef:{0}{1}{0}{0}",
					Environment.NewLine, ex);

				ModuleDef = null;
				return;
			}

			if (ModuleDef.Assembly != null)
				Name = ModuleDef.Assembly.Name;
			else
				Name = ModuleDef.Name;
			if (string.IsNullOrEmpty(Name))
				Name = Path.GetFileName(fileName);
		}

        public FileSystemPath Execute(IAssemblyFile existingAssemblyFile, string newFileName, IProgressIndicator progressIndicator)
        {
            var context = new ModuleContext();
            var fileOptions = new ObfuscatedFile.Options
            {
                Filename = existingAssemblyFile.Location.FullPath,
                NewFilename = newFileName,
            };

            IObfuscatedFile obfuscationFile = CreateObfuscationFile(fileOptions, context);

            return Deobfuscate(obfuscationFile, progressIndicator);
        }

        public ObfuscatedFile(Options options, ModuleContext moduleContext, IAssemblyClientFactory assemblyClientFactory, MemoryStream ms)
        {
            this.assemblyClientFactory = assemblyClientFactory;
            this.options = options;
            userStringDecrypterMethods = options.StringDecrypterMethods.Count > 0;
            options.Filename = Utils.getFullPath(options.Filename);
            assemblyModule = new AssemblyModule(options.Filename, moduleContext, ms);

            if (options.NewFilename == null)
                options.NewFilename = getDefaultNewFilename();

            if (string.Equals(options.Filename, options.NewFilename, StringComparison.OrdinalIgnoreCase))
                throw new UserException(string.Format("filename is same as new filename! ({0})", options.Filename));
        }

		public ObfuscatedFile CreateObfuscationFile(ObfuscatedFile.Options fileOptions, ModuleContext moduleContext)
		{

			ObfuscatedFile ofile = new ObfuscatedFile(fileOptions, moduleContext, new NewAppDomainAssemblyClientFactory());
			ofile.DeobfuscatorContext = new DeobfuscatorContext();

			try
			{
				ofile.Load(CreateDeobfuscatorInfos().Select(di => di.CreateDeobfuscator()).ToList());
			}
			catch (Exception ex)
			{
				MessageBox.Show(ex.Message);
				return null;
			}
			return ofile;
		}

        public static IObfuscatedFile SearchDeobfuscator(string filename)
        {
            TheAssemblyResolver.Instance.ClearAll();

            var fileOptions = new ObfuscatedFile.Options { Filename = filename };
            var moduleContext = new ModuleContext(TheAssemblyResolver.Instance);

            var ofile = new ObfuscatedFile(fileOptions, moduleContext, new NewAppDomainAssemblyClientFactory())
            {
                DeobfuscatorContext = new DeobfuscatorContext(),
            };

            try { ofile.Load(CreateDeobfuscatorInfos().Select(di => di.CreateDeobfuscator()).ToList()); }
            catch (Exception) { return null; }

            return ofile;
        }

			public Options() {
				ModuleContext = new ModuleContext(TheAssemblyResolver.Instance);
				DeobfuscatorInfos = new List<IDeobfuscatorInfo>();
				Files = new List<IObfuscatedFile>();
				SearchDirs = new List<SearchDir>();
				DefaultStringDecrypterMethods = new List<string>();
				RenamerFlags = RenamerFlags.RenameNamespaces |
						RenamerFlags.RenameTypes |
						RenamerFlags.RenameProperties |
						RenamerFlags.RenameEvents |
						RenamerFlags.RenameFields |
						RenamerFlags.RenameMethods |
						RenamerFlags.RenameMethodArgs |
						RenamerFlags.RenameGenericParams |
						RenamerFlags.RestorePropertiesFromNames |
						RenamerFlags.RestoreEventsFromNames |
						RenamerFlags.RestoreProperties |
						RenamerFlags.RestoreEvents;
				RenameSymbols = true;
				ControlFlowDeobfuscation = true;
			}

		/// <summary>
		/// Creates a <see cref="ModuleDefMD"/> instance from a file
		/// </summary>
		/// <param name="fileName">File name of an existing .NET module/assembly</param>
		/// <param name="context">Module context or <c>null</c></param>
		/// <returns>A new <see cref="ModuleDefMD"/> instance</returns>
		public static ModuleDefMD Load(string fileName, ModuleContext context) {
			DotNetFile dnFile = null;
			try {
				return Load(dnFile = DotNetFile.Load(fileName), context);
			}
			catch {
				if (dnFile != null)
					dnFile.Dispose();
				throw;
			}
		}

 /// <summary>
 /// Creates a <see cref="ModuleDefMD"/> instance from a file
 /// </summary>
 /// <param name="fileName">File name of an existing .NET module/assembly</param>
 /// <param name="context">Module context or <c>null</c></param>
 /// <returns>A new <see cref="ModuleDefMD"/> instance</returns>
 public static ModuleDefMD Load(string fileName, ModuleContext context)
 {
     return Load(fileName, new ModuleCreationOptions(context));
 }

		public AssemblyModule(string filename, ModuleContext moduleContext) {
			this.filename = Utils.GetFullPath(filename);
			this.moduleContext = moduleContext;
		}

		private IObfuscatedFile UpdateObfuscationFileWithOptions(De4dotWrapper de4Dot, string location, string newFile)
		{
			ObfuscatedFile.Options options = new ObfuscatedFile.Options();
			options.ControlFlowDeobfuscation = this.EnableControlFlowDeobfuscation;
			options.NewFilename = newFile;
			options.KeepObfuscatorTypes = this.KeepObfuscatorClasses;
			options.Filename = location;
			var context = new ModuleContext();
			ObfuscatedFile result = de4Dot.CreateObfuscationFile(options, context);
			return result;
		}

        AssemblyDef FindClosestAssembly(AssemblyNameInfo assembly, AssemblyDef closest, IEnumerable<string> paths, ModuleContext moduleContext)
        {
            if (paths == null)
                return closest;
            var asmComparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
            foreach (var path in paths) {
                ModuleDefMD mod = null;
                try {
                    mod = ModuleDefMD.Load(path, moduleContext);
                    var asm = mod.Assembly;
                    if (asm != null && asmComparer.CompareClosest(assembly, new AssemblyNameInfo(closest), new AssemblyNameInfo(asm)) == 1) {
                        if (!IsCached(closest) && closest != null && closest.ManifestModule != null)
                            closest.ManifestModule.Dispose();
                        closest = asm;
                        mod = null;
                    }
                }
                catch {
                }
                finally {
                    if (mod != null)
                        mod.Dispose();
                }
            }

            return closest;
        }

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="dnFile">The loaded .NET file</param>
		/// <param name="context">Module context or <c>null</c></param>
		/// <exception cref="ArgumentNullException">If <paramref name="dnFile"/> is <c>null</c></exception>
		ModuleDefMD(DotNetFile dnFile, ModuleContext context)
			: base(null, 1) {
#if DEBUG
			if (dnFile == null)
				throw new ArgumentNullException("dnFile");
#endif
			this.dnFile = dnFile;
			this.context = context;
			Initialize();

			this.Kind = GetKind();
			this.Characteristics = MetaData.PEImage.ImageNTHeaders.FileHeader.Characteristics;
			this.DllCharacteristics = MetaData.PEImage.ImageNTHeaders.OptionalHeader.DllCharacteristics;
			this.RuntimeVersion = MetaData.VersionString;
			this.Machine = MetaData.PEImage.ImageNTHeaders.FileHeader.Machine;
			this.Cor20HeaderFlags = MetaData.ImageCor20Header.Flags;
			this.Cor20HeaderRuntimeVersion = (uint)(MetaData.ImageCor20Header.MajorRuntimeVersion << 16) | MetaData.ImageCor20Header.MinorRuntimeVersion;
			this.TablesHeaderVersion = MetaData.TablesStream.Version;
		}

 /// <summary>
 /// Finds an assembly that exactly matches the requested assembly
 /// </summary>
 /// <param name="assembly">Assembly name to find</param>
 /// <param name="paths">Search paths or <c>null</c> if none</param>
 /// <param name="moduleContext">Module context</param>
 /// <returns>An <see cref="AssemblyDef"/> instance or <c>null</c> if an exact match
 /// couldn't be found.</returns>
 AssemblyDef FindExactAssembly(AssemblyNameInfo assembly, IEnumerable<string> paths, ModuleContext moduleContext)
 {
     if (paths == null)
         return null;
     var asmComparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
     foreach (var path in paths) {
         ModuleDefMD mod = null;
         try {
             mod = ModuleDefMD.Load(path, moduleContext);
             var asm = mod.Assembly;
             if (asm != null && asmComparer.Equals(assembly, new AssemblyNameInfo(asm))) {
                 mod = null;
                 return asm;
             }
         }
         catch {
         }
         finally {
             if (mod != null)
                 mod.Dispose();
         }
     }
     return null;
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="defaultModuleContext">Module context for all resolved assemblies</param>
 public AssemblyResolver(ModuleContext defaultModuleContext)
     : this(defaultModuleContext, true)
 {
 }

        static List<AssemblyDef> LoadAssemblies(string target)
        {
            AssemblyResolver asmResolver = new AssemblyResolver();
            ModuleContext modCtx = new ModuleContext(asmResolver);
            asmResolver.DefaultModuleContext = modCtx;
            asmResolver.EnableTypeDefCache = true;

            var directory = Path.GetFullPath(Path.GetDirectoryName(target));
            asmResolver.PreSearchPaths.Add(directory);

            List<AssemblyDef> assemblies = new List<AssemblyDef>();
            
            foreach (var asm in Directory.GetFiles(directory, "*.*")
                .Where(f=>Path.GetExtension(f.ToLower()) == ".exe" || Path.GetExtension(f.ToLower())==".dll"))
            {
                try
                {
                    var def = AssemblyDef.Load(asm);
                    def.Modules[0].Context = modCtx;
                    asmResolver.AddToCache(def);
                    assemblies.Add(def);
                }
                catch
                {
                    //Ignore
                }
            }

            return assemblies;
        }