public void Phase1(ModuleDefinition mod)
            {
                AssemblyDefinition i = AssemblyDefinition.ReadAssembly(typeof(Iid).Assembly.Location);
                i.MainModule.ReadSymbols();
                root = CecilHelper.Inject(mod, i.MainModule.GetType("AntiTamperMem"));
                mod.Types.Add(root);
                MethodDefinition cctor = mod.GetType("<Module>").GetStaticConstructor();
                cctor.Body.GetILProcessor().InsertBefore(0, Instruction.Create(OpCodes.Call, root.Methods.FirstOrDefault(mtd => mtd.Name == "Initalize")));

                Mutator mutator = new Mutator();
                mutator.IntKeys = new int[]
                {
                    key0,
                    (int)sectName.ToCharArray().Sum(_ => (int)_),
                    key2,
                    key3,
                    key4,
                    key5,
                    key6
                };
                mutator.LongKeys = new long[] { key1 };
                mutator.Mutate(Confuser.Random, root);

                root.Name = Confuser.ObfuscationHelper.GetRandomName();
                root.Namespace = "";
                AddHelper(root, HelperAttribute.NoInjection);
                foreach (MethodDefinition mtdDef in root.Methods)
                {
                    mtdDef.Name = Confuser.ObfuscationHelper.GetRandomName();
                    AddHelper(mtdDef, HelperAttribute.NoInjection);
                }
                Confuser.Database.AddEntry("AntiTamper", "Helper", root.FullName);
            }

 public static void PatchModule(ModuleDefinition baseModule)
 {
     var type = baseModule.AllNestedTypes().Single(t => t.FullName == "TowerFall.TeamSelectOverlay");
     var method = type.Methods.Single(m => m.FullName == "System.Void TowerFall.TeamSelectOverlay::.ctor(TowerFall.CustomMapButton)");
     var instructions = method.Body.Instructions.ToList();
     instructions.ForEach(i => ChangeFoursToEights(i));
 }

		public void EntryPoint (ModuleDefinition module)
		{
			var entry_point = module.EntryPoint;
			Assert.IsNotNull (entry_point);

			Assert.AreEqual ("System.Void Program::Main()", entry_point.ToString ());
		}

 protected override void ProcessAssemblyReferences(ModuleDefinition moduleDef, IList<AssemblyNameReference> assemblyNameRefs)
 {
     for (int i = assemblyNameRefs.Count - 1; i >= 0; --i) {
         AssemblyNameReference replacement = null;
         var other = assemblyNameRefs[i];
         var otherName = other.Name + "," + other.Version;
         if (_assemblyReplacements.TryGetValue(other.Name, out replacement)) {
             assemblyNameRefs[i].Version = replacement.Version;
             assemblyNameRefs[i].PublicKeyToken = replacement.PublicKeyToken;
             assemblyNameRefs[i].IsRetargetable = replacement.IsRetargetable;
             var replacementName = replacement.Name + "," + replacement.Version;
             Trace.WriteLine(string.Format("Replacing {0} with {1}.", otherName, replacementName), "RetargetReferences");
         } else {
             if (_removeOthers) {
                 try {
                     var otherAss = moduleDef.AssemblyResolver.Resolve(other);
                     var otherProfile = otherAss.GetAssemblyProfileFromAttribute();
                     if (otherProfile != null && otherProfile.IsPortable) {
                         Trace.WriteLine(string.Format("Keeping {0}.", otherName), "RetargetReferences");
                         continue;
                     }
                 } catch(Exception ex) {
                     Trace.WriteLine(string.Format("Failed resolving {0}.", otherName), "RetargetReferences");
                 }
                 Trace.WriteLine(string.Format("Removing {0}.", otherName), "RetargetReferences");
                 assemblyNameRefs.RemoveAt(i);
             } else {
                 Trace.WriteLine(string.Format("Keeping {0}.", otherName), "RetargetReferences");
             }
         }
     }
     base.ProcessAssemblyReferences(moduleDef, assemblyNameRefs);
 }

        public void Rewrite(ModuleDefinition module, IEnumerable<ImplementedEventSource> loggers)
        {
            var tmp = from l in loggers
                      let old = l.Old.FindMethod("IsEnabled")
                      where old != null
                      select new
                      {
                          Old = old,
                          New = l.New.BaseType.Resolve().FindMethod("IsEnabled").ImportInto(module)
                      };

            var fixMap = tmp.ToDictionary(a => a.Old.FullName, a => a.New);
            var moduleMethods = module.Types.SelectMany(t => t.Methods).Where(m => m.HasBody).ToArray();

            MethodReference impl;

            foreach (var method in moduleMethods)
            {
                var ops = method.GetOpsOf(OpCodes.Callvirt).ToArray();

                foreach (var o in ops)
                {
                    var fullName = (o.Operand as MethodReference)?.FullName;

                    if (fullName != null && fixMap.TryGetValue(fullName, out impl))
                    {
                        o.OpCode = OpCodes.Call;
                        o.Operand = impl;
                    }
                }
            }
        }

 protected FrameworkVersion GetFrameworkVersionForModule(ModuleDefinition module, IFrameworkResolver frameworkResolver)
 {
     //TODO: handle Silverlight/WinPhone projects
     TargetPlatform platform = module.AssemblyResolver.GetTargetPlatform(module.FilePath);
     switch (platform)
     {
         case TargetPlatform.CLR_1:
             return FrameworkVersion.v1_1;
         case TargetPlatform.CLR_2:
             return FrameworkVersion.v2_0;
         case TargetPlatform.CLR_2_3:
         case TargetPlatform.CLR_3_5:
             return FrameworkVersion.v3_5;
         case TargetPlatform.CLR_4:
             return GetFramework4Version(module, frameworkResolver);
         case TargetPlatform.WinRT:
             return FrameworkVersion.WinRT;
         case TargetPlatform.Silverlight:
             return FrameworkVersion.Silverlight;
         case TargetPlatform.WindowsCE:
             return FrameworkVersion.WindowsCE;
         case TargetPlatform.WindowsPhone:
             return FrameworkVersion.WindowsPhone;
         default:
             return FrameworkVersion.Unknown;
     }
 }

        private MethodUsage CreateUsage(MemberReference operand, ModuleDefinition assembly, TypeDefinition type, MethodDefinition method, string testAssemblyPath)
        {
            if (operand == null)
                return null;

            Test test = new Test
                {
                    PathToAssembly = Path.GetDirectoryName(testAssemblyPath),
                    AssemblyName = assembly.Assembly.Name.Name,
                    NamespaceName = type.Namespace,
                    ClassName = type.Name,
                    MethodName = method.Name
                };

            var instructionCall = new MethodUsage
                {
                    AssemblyName = operand.DeclaringType.Scope.Name + ".dll",
                    NamespaceName = operand.DeclaringType.Namespace,
                    ClassName = operand.DeclaringType.Name,
                    MethodName = operand.Name,
                    TestCoverage = new List<Test> {test}
                };

            return instructionCall;
        }

        public static ModuleReader Read(ModuleDefinition module)
        {
            var reader = new ModuleReader();

            if (module.AssemblyReferences.All(reference => reference.Name != "Stiletto"))
            {
                return reader;
            }

            var allTypes = module.GetTypes();

            foreach (var t in allTypes)
            {
                if (IsModule(t))
                {
                    reader.ModuleTypes.Add(t);
                }

                if (IsInject(t))
                {
                    reader.InjectTypes.Add(t);
                }
            }

            return reader;
        }

 public ImageReader(IDeobfuscatorContext deobfuscatorContext, ModuleDefinition module, byte[] data)
 {
     this.deobfuscatorContext = deobfuscatorContext;
     this.module = module;
     this.reader = new BinaryReader(new MemoryStream(data));
     this.memberReferenceConverter = new MemberReferenceConverter(module);
 }

        public override void ImportReferences(ModuleDefinition module)
        {
            // Import the references from the base class
            base.ImportReferences(module);

            _modifiableInterfaceType = module.ImportType<IModifiableType>();
        }

        public Either<MemberReference, PropertyReferenceContainer> Convert(IAstReference astReference, ModuleDefinition module)
        {
            var reflectedType = astReference as AstReflectedType;
            if (reflectedType != null)
                return module.Import(reflectedType.ActualType);

            var reflectedMethod = astReference as AstReflectedMethod;
            if (reflectedMethod != null)
                return module.Import(reflectedMethod.Method);

            var reflectedConstructor = astReference as AstReflectedConstructor;
            if (reflectedConstructor != null)
                return module.Import(reflectedConstructor.Constructor);

            var reflectedProperty = astReference as AstReflectedProperty;
            if (reflectedProperty != null) {
                var getMethod = reflectedProperty.Property.GetGetMethod();
                var setMethod = reflectedProperty.Property.GetSetMethod();
                return new PropertyReferenceContainer(
                    getMethod != null ? module.Import(getMethod) : null,
                    setMethod != null ? module.Import(setMethod) : null
                );
            }

            return null;
        }

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

		public void ReturnGenericInstance (ModuleDefinition module)
		{
			var bar = module.GetType ("Bar`1");

			var self = bar.GetMethod ("Self");
			Assert.IsNotNull (self);

			var bar_t = self.ReturnType;

			Assert.IsTrue (bar_t.IsGenericInstance);

			var bar_t_instance = (GenericInstanceType) bar_t;

			Assert.AreEqual (bar.GenericParameters [0], bar_t_instance.GenericArguments [0]);

			var self_str = bar.GetMethod ("SelfString");
			Assert.IsNotNull (self_str);

			var bar_str = self_str.ReturnType;
			Assert.IsTrue (bar_str.IsGenericInstance);

			var bar_str_instance = (GenericInstanceType) bar_str;

			Assert.AreEqual ("System.String", bar_str_instance.GenericArguments [0].FullName);
		}

        public void Replace(IMethodContext context, ModuleDefinition targetModule)
        {
            var currentMethod = context.CurrentMethod;
            var currentArguments = context.CurrentArguments;
            var currentArgument = context.CurrentArgument;
            var pushMethod = targetModule.ImportMethod<Stack<object>>("Push");
            var worker = context.CilWorker;

            var methodMap = _context.MethodMap;
            var targetDependency = _context.TargetDependency;
            var interfaceType = _context.InterfaceType;

            var adapterConstructor = _adapterBuilder.CreateAdapterConstructor(methodMap);
            foreach (ParameterReference param in currentMethod.Parameters)
            {
                var arguments = new ParameterContext(worker,
                interfaceType,
                pushMethod,
                currentArguments,
                currentArgument,
                targetDependency, adapterConstructor, param);

                // Save the current argument
                _pushParameter.Adapt(arguments);
            }
        }

        internal virtual TypeDefinition GetInjecteeCecilType(ModuleDefinition module)
        {
            if (_injecteeCecilDef == null)
                _injecteeCecilDef = module.FindMatchingType(InjecteeType, true);

            return _injecteeCecilDef;
        }

        public Either<MemberReference, PropertyReferenceContainer> Convert(IAstReference astReference, ModuleDefinition module, IReferenceProvider recursive)
        {
            if (astReference != AstVoidType.Instance)
                return null;

            return module.Import(typeof(void));
        }

		public Sample(string targetFileName)
		{
			_targetFileName = targetFileName;

			// Read the module with default parameters
			_module = ModuleDefinition.ReadModule(_targetFileName);
		}

 public ModuleResult ProcessModule(ModuleDefinition module, TypeResult[] typeResults)
 {
     ModuleResult result = new ModuleResult(module.Name);
     result.TypeResults = typeResults;
     result.Result = typeResults.Sum(r => r.Result);
     return result;
 }

        Either<MemberReference, PropertyReferenceContainer> IReferenceProvider.Convert(IAstReference astReference, ModuleDefinition module, IReferenceProvider recursive)
        {
            if (module != this.module)
                throw new InvalidOperationException("Expected module to be " + this.module + ", received " + module);

            return this.ConvertReference(astReference);
        }

        /// <summary>
        /// Emits a call that obtains the hash code for the current service instance.
        /// </summary>
        /// <param name="il">The <see cref="ILProcessor"/> that points to the method body.</param>
        /// <param name="module">The target module.</param>
        /// <param name="serviceInstance">The local variable that contains the service instance.</param>
        private void GetServiceHash(ILProcessor il, ModuleDefinition module, VariableDefinition serviceInstance)
        {
            il.Emit(OpCodes.Ldloc, serviceInstance);

            var getHashCodeMethod = module.ImportMethod<object>("GetHashCode");
            il.Emit(OpCodes.Callvirt, getHashCodeMethod);
        }